?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* config.sub, config.guess: Update from upstream sources.
[binutils.git] / bfd / elf32-arm.c
blob49c80ad798e9eb44b00ec615bf9c50ce6a157ff9
1 /* 32-bit ELF support for ARM
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3 2008, 2009 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 <limits.h>
24
25 #include "bfd.h"
26 #include "libiberty.h"
27 #include "libbfd.h"
28 #include "elf-bfd.h"
29 #include "elf-vxworks.h"
30 #include "elf/arm.h"
31
32 /* Return the relocation section associated with NAME. HTAB is the
33 bfd's elf32_arm_link_hash_entry. */
34 #define RELOC_SECTION(HTAB, NAME) \
35 ((HTAB)->use_rel ? ".rel" NAME : ".rela" NAME)
36
37 /* Return size of a relocation entry. HTAB is the bfd's
38 elf32_arm_link_hash_entry. */
39 #define RELOC_SIZE(HTAB) \
40 ((HTAB)->use_rel \
41 ? sizeof (Elf32_External_Rel) \
42 : sizeof (Elf32_External_Rela))
43
44 /* Return function to swap relocations in. HTAB is the bfd's
45 elf32_arm_link_hash_entry. */
46 #define SWAP_RELOC_IN(HTAB) \
47 ((HTAB)->use_rel \
48 ? bfd_elf32_swap_reloc_in \
49 : bfd_elf32_swap_reloca_in)
50
51 /* Return function to swap relocations out. HTAB is the bfd's
52 elf32_arm_link_hash_entry. */
53 #define SWAP_RELOC_OUT(HTAB) \
54 ((HTAB)->use_rel \
55 ? bfd_elf32_swap_reloc_out \
56 : bfd_elf32_swap_reloca_out)
57
58 #define elf_info_to_howto 0
59 #define elf_info_to_howto_rel elf32_arm_info_to_howto
60
61 #define ARM_ELF_ABI_VERSION 0
62 #define ARM_ELF_OS_ABI_VERSION ELFOSABI_ARM
63
64 static struct elf_backend_data elf32_arm_vxworks_bed;
65
66 static bfd_boolean elf32_arm_write_section (bfd *output_bfd,
67 struct bfd_link_info *link_info,
68 asection *sec,
69 bfd_byte *contents);
70
71 /* Note: code such as elf32_arm_reloc_type_lookup expect to use e.g.
72 R_ARM_PC24 as an index into this, and find the R_ARM_PC24 HOWTO
73 in that slot. */
74
75 static reloc_howto_type elf32_arm_howto_table_1[] =
76 {
77 /* No relocation. */
78 HOWTO (R_ARM_NONE, /* type */
79 0, /* rightshift */
80 0, /* size (0 = byte, 1 = short, 2 = long) */
81 0, /* bitsize */
82 FALSE, /* pc_relative */
83 0, /* bitpos */
84 complain_overflow_dont,/* complain_on_overflow */
85 bfd_elf_generic_reloc, /* special_function */
86 "R_ARM_NONE", /* name */
87 FALSE, /* partial_inplace */
88 0, /* src_mask */
89 0, /* dst_mask */
90 FALSE), /* pcrel_offset */
91
92 HOWTO (R_ARM_PC24, /* type */
93 2, /* rightshift */
94 2, /* size (0 = byte, 1 = short, 2 = long) */
95 24, /* bitsize */
96 TRUE, /* pc_relative */
97 0, /* bitpos */
98 complain_overflow_signed,/* complain_on_overflow */
99 bfd_elf_generic_reloc, /* special_function */
100 "R_ARM_PC24", /* name */
101 FALSE, /* partial_inplace */
102 0x00ffffff, /* src_mask */
103 0x00ffffff, /* dst_mask */
104 TRUE), /* pcrel_offset */
105
106 /* 32 bit absolute */
107 HOWTO (R_ARM_ABS32, /* type */
108 0, /* rightshift */
109 2, /* size (0 = byte, 1 = short, 2 = long) */
110 32, /* bitsize */
111 FALSE, /* pc_relative */
112 0, /* bitpos */
113 complain_overflow_bitfield,/* complain_on_overflow */
114 bfd_elf_generic_reloc, /* special_function */
115 "R_ARM_ABS32", /* name */
116 FALSE, /* partial_inplace */
117 0xffffffff, /* src_mask */
118 0xffffffff, /* dst_mask */
119 FALSE), /* pcrel_offset */
120
121 /* standard 32bit pc-relative reloc */
122 HOWTO (R_ARM_REL32, /* type */
123 0, /* rightshift */
124 2, /* size (0 = byte, 1 = short, 2 = long) */
125 32, /* bitsize */
126 TRUE, /* pc_relative */
127 0, /* bitpos */
128 complain_overflow_bitfield,/* complain_on_overflow */
129 bfd_elf_generic_reloc, /* special_function */
130 "R_ARM_REL32", /* name */
131 FALSE, /* partial_inplace */
132 0xffffffff, /* src_mask */
133 0xffffffff, /* dst_mask */
134 TRUE), /* pcrel_offset */
135
136 /* 8 bit absolute - R_ARM_LDR_PC_G0 in AAELF */
137 HOWTO (R_ARM_LDR_PC_G0, /* type */
138 0, /* rightshift */
139 0, /* size (0 = byte, 1 = short, 2 = long) */
140 32, /* bitsize */
141 TRUE, /* pc_relative */
142 0, /* bitpos */
143 complain_overflow_dont,/* complain_on_overflow */
144 bfd_elf_generic_reloc, /* special_function */
145 "R_ARM_LDR_PC_G0", /* name */
146 FALSE, /* partial_inplace */
147 0xffffffff, /* src_mask */
148 0xffffffff, /* dst_mask */
149 TRUE), /* pcrel_offset */
150
151 /* 16 bit absolute */
152 HOWTO (R_ARM_ABS16, /* type */
153 0, /* rightshift */
154 1, /* size (0 = byte, 1 = short, 2 = long) */
155 16, /* bitsize */
156 FALSE, /* pc_relative */
157 0, /* bitpos */
158 complain_overflow_bitfield,/* complain_on_overflow */
159 bfd_elf_generic_reloc, /* special_function */
160 "R_ARM_ABS16", /* name */
161 FALSE, /* partial_inplace */
162 0x0000ffff, /* src_mask */
163 0x0000ffff, /* dst_mask */
164 FALSE), /* pcrel_offset */
165
166 /* 12 bit absolute */
167 HOWTO (R_ARM_ABS12, /* type */
168 0, /* rightshift */
169 2, /* size (0 = byte, 1 = short, 2 = long) */
170 12, /* bitsize */
171 FALSE, /* pc_relative */
172 0, /* bitpos */
173 complain_overflow_bitfield,/* complain_on_overflow */
174 bfd_elf_generic_reloc, /* special_function */
175 "R_ARM_ABS12", /* name */
176 FALSE, /* partial_inplace */
177 0x00000fff, /* src_mask */
178 0x00000fff, /* dst_mask */
179 FALSE), /* pcrel_offset */
180
181 HOWTO (R_ARM_THM_ABS5, /* type */
182 6, /* rightshift */
183 1, /* size (0 = byte, 1 = short, 2 = long) */
184 5, /* bitsize */
185 FALSE, /* pc_relative */
186 0, /* bitpos */
187 complain_overflow_bitfield,/* complain_on_overflow */
188 bfd_elf_generic_reloc, /* special_function */
189 "R_ARM_THM_ABS5", /* name */
190 FALSE, /* partial_inplace */
191 0x000007e0, /* src_mask */
192 0x000007e0, /* dst_mask */
193 FALSE), /* pcrel_offset */
194
195 /* 8 bit absolute */
196 HOWTO (R_ARM_ABS8, /* type */
197 0, /* rightshift */
198 0, /* size (0 = byte, 1 = short, 2 = long) */
199 8, /* bitsize */
200 FALSE, /* pc_relative */
201 0, /* bitpos */
202 complain_overflow_bitfield,/* complain_on_overflow */
203 bfd_elf_generic_reloc, /* special_function */
204 "R_ARM_ABS8", /* name */
205 FALSE, /* partial_inplace */
206 0x000000ff, /* src_mask */
207 0x000000ff, /* dst_mask */
208 FALSE), /* pcrel_offset */
209
210 HOWTO (R_ARM_SBREL32, /* type */
211 0, /* rightshift */
212 2, /* size (0 = byte, 1 = short, 2 = long) */
213 32, /* bitsize */
214 FALSE, /* pc_relative */
215 0, /* bitpos */
216 complain_overflow_dont,/* complain_on_overflow */
217 bfd_elf_generic_reloc, /* special_function */
218 "R_ARM_SBREL32", /* name */
219 FALSE, /* partial_inplace */
220 0xffffffff, /* src_mask */
221 0xffffffff, /* dst_mask */
222 FALSE), /* pcrel_offset */
223
224 HOWTO (R_ARM_THM_CALL, /* type */
225 1, /* rightshift */
226 2, /* size (0 = byte, 1 = short, 2 = long) */
227 25, /* bitsize */
228 TRUE, /* pc_relative */
229 0, /* bitpos */
230 complain_overflow_signed,/* complain_on_overflow */
231 bfd_elf_generic_reloc, /* special_function */
232 "R_ARM_THM_CALL", /* name */
233 FALSE, /* partial_inplace */
234 0x07ff07ff, /* src_mask */
235 0x07ff07ff, /* dst_mask */
236 TRUE), /* pcrel_offset */
237
238 HOWTO (R_ARM_THM_PC8, /* type */
239 1, /* rightshift */
240 1, /* size (0 = byte, 1 = short, 2 = long) */
241 8, /* bitsize */
242 TRUE, /* pc_relative */
243 0, /* bitpos */
244 complain_overflow_signed,/* complain_on_overflow */
245 bfd_elf_generic_reloc, /* special_function */
246 "R_ARM_THM_PC8", /* name */
247 FALSE, /* partial_inplace */
248 0x000000ff, /* src_mask */
249 0x000000ff, /* dst_mask */
250 TRUE), /* pcrel_offset */
251
252 HOWTO (R_ARM_BREL_ADJ, /* type */
253 1, /* rightshift */
254 1, /* size (0 = byte, 1 = short, 2 = long) */
255 32, /* bitsize */
256 FALSE, /* pc_relative */
257 0, /* bitpos */
258 complain_overflow_signed,/* complain_on_overflow */
259 bfd_elf_generic_reloc, /* special_function */
260 "R_ARM_BREL_ADJ", /* name */
261 FALSE, /* partial_inplace */
262 0xffffffff, /* src_mask */
263 0xffffffff, /* dst_mask */
264 FALSE), /* pcrel_offset */
265
266 HOWTO (R_ARM_SWI24, /* type */
267 0, /* rightshift */
268 0, /* size (0 = byte, 1 = short, 2 = long) */
269 0, /* bitsize */
270 FALSE, /* pc_relative */
271 0, /* bitpos */
272 complain_overflow_signed,/* complain_on_overflow */
273 bfd_elf_generic_reloc, /* special_function */
274 "R_ARM_SWI24", /* name */
275 FALSE, /* partial_inplace */
276 0x00000000, /* src_mask */
277 0x00000000, /* dst_mask */
278 FALSE), /* pcrel_offset */
279
280 HOWTO (R_ARM_THM_SWI8, /* type */
281 0, /* rightshift */
282 0, /* size (0 = byte, 1 = short, 2 = long) */
283 0, /* bitsize */
284 FALSE, /* pc_relative */
285 0, /* bitpos */
286 complain_overflow_signed,/* complain_on_overflow */
287 bfd_elf_generic_reloc, /* special_function */
288 "R_ARM_SWI8", /* name */
289 FALSE, /* partial_inplace */
290 0x00000000, /* src_mask */
291 0x00000000, /* dst_mask */
292 FALSE), /* pcrel_offset */
293
294 /* BLX instruction for the ARM. */
295 HOWTO (R_ARM_XPC25, /* type */
296 2, /* rightshift */
297 2, /* size (0 = byte, 1 = short, 2 = long) */
298 25, /* bitsize */
299 TRUE, /* pc_relative */
300 0, /* bitpos */
301 complain_overflow_signed,/* complain_on_overflow */
302 bfd_elf_generic_reloc, /* special_function */
303 "R_ARM_XPC25", /* name */
304 FALSE, /* partial_inplace */
305 0x00ffffff, /* src_mask */
306 0x00ffffff, /* dst_mask */
307 TRUE), /* pcrel_offset */
308
309 /* BLX instruction for the Thumb. */
310 HOWTO (R_ARM_THM_XPC22, /* type */
311 2, /* rightshift */
312 2, /* size (0 = byte, 1 = short, 2 = long) */
313 22, /* bitsize */
314 TRUE, /* pc_relative */
315 0, /* bitpos */
316 complain_overflow_signed,/* complain_on_overflow */
317 bfd_elf_generic_reloc, /* special_function */
318 "R_ARM_THM_XPC22", /* name */
319 FALSE, /* partial_inplace */
320 0x07ff07ff, /* src_mask */
321 0x07ff07ff, /* dst_mask */
322 TRUE), /* pcrel_offset */
323
324 /* Dynamic TLS relocations. */
325
326 HOWTO (R_ARM_TLS_DTPMOD32, /* type */
327 0, /* rightshift */
328 2, /* size (0 = byte, 1 = short, 2 = long) */
329 32, /* bitsize */
330 FALSE, /* pc_relative */
331 0, /* bitpos */
332 complain_overflow_bitfield,/* complain_on_overflow */
333 bfd_elf_generic_reloc, /* special_function */
334 "R_ARM_TLS_DTPMOD32", /* name */
335 TRUE, /* partial_inplace */
336 0xffffffff, /* src_mask */
337 0xffffffff, /* dst_mask */
338 FALSE), /* pcrel_offset */
339
340 HOWTO (R_ARM_TLS_DTPOFF32, /* type */
341 0, /* rightshift */
342 2, /* size (0 = byte, 1 = short, 2 = long) */
343 32, /* bitsize */
344 FALSE, /* pc_relative */
345 0, /* bitpos */
346 complain_overflow_bitfield,/* complain_on_overflow */
347 bfd_elf_generic_reloc, /* special_function */
348 "R_ARM_TLS_DTPOFF32", /* name */
349 TRUE, /* partial_inplace */
350 0xffffffff, /* src_mask */
351 0xffffffff, /* dst_mask */
352 FALSE), /* pcrel_offset */
353
354 HOWTO (R_ARM_TLS_TPOFF32, /* type */
355 0, /* rightshift */
356 2, /* size (0 = byte, 1 = short, 2 = long) */
357 32, /* bitsize */
358 FALSE, /* pc_relative */
359 0, /* bitpos */
360 complain_overflow_bitfield,/* complain_on_overflow */
361 bfd_elf_generic_reloc, /* special_function */
362 "R_ARM_TLS_TPOFF32", /* name */
363 TRUE, /* partial_inplace */
364 0xffffffff, /* src_mask */
365 0xffffffff, /* dst_mask */
366 FALSE), /* pcrel_offset */
367
368 /* Relocs used in ARM Linux */
369
370 HOWTO (R_ARM_COPY, /* type */
371 0, /* rightshift */
372 2, /* size (0 = byte, 1 = short, 2 = long) */
373 32, /* bitsize */
374 FALSE, /* pc_relative */
375 0, /* bitpos */
376 complain_overflow_bitfield,/* complain_on_overflow */
377 bfd_elf_generic_reloc, /* special_function */
378 "R_ARM_COPY", /* name */
379 TRUE, /* partial_inplace */
380 0xffffffff, /* src_mask */
381 0xffffffff, /* dst_mask */
382 FALSE), /* pcrel_offset */
383
384 HOWTO (R_ARM_GLOB_DAT, /* type */
385 0, /* rightshift */
386 2, /* size (0 = byte, 1 = short, 2 = long) */
387 32, /* bitsize */
388 FALSE, /* pc_relative */
389 0, /* bitpos */
390 complain_overflow_bitfield,/* complain_on_overflow */
391 bfd_elf_generic_reloc, /* special_function */
392 "R_ARM_GLOB_DAT", /* name */
393 TRUE, /* partial_inplace */
394 0xffffffff, /* src_mask */
395 0xffffffff, /* dst_mask */
396 FALSE), /* pcrel_offset */
397
398 HOWTO (R_ARM_JUMP_SLOT, /* type */
399 0, /* rightshift */
400 2, /* size (0 = byte, 1 = short, 2 = long) */
401 32, /* bitsize */
402 FALSE, /* pc_relative */
403 0, /* bitpos */
404 complain_overflow_bitfield,/* complain_on_overflow */
405 bfd_elf_generic_reloc, /* special_function */
406 "R_ARM_JUMP_SLOT", /* name */
407 TRUE, /* partial_inplace */
408 0xffffffff, /* src_mask */
409 0xffffffff, /* dst_mask */
410 FALSE), /* pcrel_offset */
411
412 HOWTO (R_ARM_RELATIVE, /* type */
413 0, /* rightshift */
414 2, /* size (0 = byte, 1 = short, 2 = long) */
415 32, /* bitsize */
416 FALSE, /* pc_relative */
417 0, /* bitpos */
418 complain_overflow_bitfield,/* complain_on_overflow */
419 bfd_elf_generic_reloc, /* special_function */
420 "R_ARM_RELATIVE", /* name */
421 TRUE, /* partial_inplace */
422 0xffffffff, /* src_mask */
423 0xffffffff, /* dst_mask */
424 FALSE), /* pcrel_offset */
425
426 HOWTO (R_ARM_GOTOFF32, /* type */
427 0, /* rightshift */
428 2, /* size (0 = byte, 1 = short, 2 = long) */
429 32, /* bitsize */
430 FALSE, /* pc_relative */
431 0, /* bitpos */
432 complain_overflow_bitfield,/* complain_on_overflow */
433 bfd_elf_generic_reloc, /* special_function */
434 "R_ARM_GOTOFF32", /* name */
435 TRUE, /* partial_inplace */
436 0xffffffff, /* src_mask */
437 0xffffffff, /* dst_mask */
438 FALSE), /* pcrel_offset */
439
440 HOWTO (R_ARM_GOTPC, /* type */
441 0, /* rightshift */
442 2, /* size (0 = byte, 1 = short, 2 = long) */
443 32, /* bitsize */
444 TRUE, /* pc_relative */
445 0, /* bitpos */
446 complain_overflow_bitfield,/* complain_on_overflow */
447 bfd_elf_generic_reloc, /* special_function */
448 "R_ARM_GOTPC", /* name */
449 TRUE, /* partial_inplace */
450 0xffffffff, /* src_mask */
451 0xffffffff, /* dst_mask */
452 TRUE), /* pcrel_offset */
453
454 HOWTO (R_ARM_GOT32, /* type */
455 0, /* rightshift */
456 2, /* size (0 = byte, 1 = short, 2 = long) */
457 32, /* bitsize */
458 FALSE, /* pc_relative */
459 0, /* bitpos */
460 complain_overflow_bitfield,/* complain_on_overflow */
461 bfd_elf_generic_reloc, /* special_function */
462 "R_ARM_GOT32", /* name */
463 TRUE, /* partial_inplace */
464 0xffffffff, /* src_mask */
465 0xffffffff, /* dst_mask */
466 FALSE), /* pcrel_offset */
467
468 HOWTO (R_ARM_PLT32, /* type */
469 2, /* rightshift */
470 2, /* size (0 = byte, 1 = short, 2 = long) */
471 24, /* bitsize */
472 TRUE, /* pc_relative */
473 0, /* bitpos */
474 complain_overflow_bitfield,/* complain_on_overflow */
475 bfd_elf_generic_reloc, /* special_function */
476 "R_ARM_PLT32", /* name */
477 FALSE, /* partial_inplace */
478 0x00ffffff, /* src_mask */
479 0x00ffffff, /* dst_mask */
480 TRUE), /* pcrel_offset */
481
482 HOWTO (R_ARM_CALL, /* type */
483 2, /* rightshift */
484 2, /* size (0 = byte, 1 = short, 2 = long) */
485 24, /* bitsize */
486 TRUE, /* pc_relative */
487 0, /* bitpos */
488 complain_overflow_signed,/* complain_on_overflow */
489 bfd_elf_generic_reloc, /* special_function */
490 "R_ARM_CALL", /* name */
491 FALSE, /* partial_inplace */
492 0x00ffffff, /* src_mask */
493 0x00ffffff, /* dst_mask */
494 TRUE), /* pcrel_offset */
495
496 HOWTO (R_ARM_JUMP24, /* type */
497 2, /* rightshift */
498 2, /* size (0 = byte, 1 = short, 2 = long) */
499 24, /* bitsize */
500 TRUE, /* pc_relative */
501 0, /* bitpos */
502 complain_overflow_signed,/* complain_on_overflow */
503 bfd_elf_generic_reloc, /* special_function */
504 "R_ARM_JUMP24", /* name */
505 FALSE, /* partial_inplace */
506 0x00ffffff, /* src_mask */
507 0x00ffffff, /* dst_mask */
508 TRUE), /* pcrel_offset */
509
510 HOWTO (R_ARM_THM_JUMP24, /* type */
511 1, /* rightshift */
512 2, /* size (0 = byte, 1 = short, 2 = long) */
513 24, /* bitsize */
514 TRUE, /* pc_relative */
515 0, /* bitpos */
516 complain_overflow_signed,/* complain_on_overflow */
517 bfd_elf_generic_reloc, /* special_function */
518 "R_ARM_THM_JUMP24", /* name */
519 FALSE, /* partial_inplace */
520 0x07ff2fff, /* src_mask */
521 0x07ff2fff, /* dst_mask */
522 TRUE), /* pcrel_offset */
523
524 HOWTO (R_ARM_BASE_ABS, /* type */
525 0, /* rightshift */
526 2, /* size (0 = byte, 1 = short, 2 = long) */
527 32, /* bitsize */
528 FALSE, /* pc_relative */
529 0, /* bitpos */
530 complain_overflow_dont,/* complain_on_overflow */
531 bfd_elf_generic_reloc, /* special_function */
532 "R_ARM_BASE_ABS", /* name */
533 FALSE, /* partial_inplace */
534 0xffffffff, /* src_mask */
535 0xffffffff, /* dst_mask */
536 FALSE), /* pcrel_offset */
537
538 HOWTO (R_ARM_ALU_PCREL7_0, /* type */
539 0, /* rightshift */
540 2, /* size (0 = byte, 1 = short, 2 = long) */
541 12, /* bitsize */
542 TRUE, /* pc_relative */
543 0, /* bitpos */
544 complain_overflow_dont,/* complain_on_overflow */
545 bfd_elf_generic_reloc, /* special_function */
546 "R_ARM_ALU_PCREL_7_0", /* name */
547 FALSE, /* partial_inplace */
548 0x00000fff, /* src_mask */
549 0x00000fff, /* dst_mask */
550 TRUE), /* pcrel_offset */
551
552 HOWTO (R_ARM_ALU_PCREL15_8, /* type */
553 0, /* rightshift */
554 2, /* size (0 = byte, 1 = short, 2 = long) */
555 12, /* bitsize */
556 TRUE, /* pc_relative */
557 8, /* bitpos */
558 complain_overflow_dont,/* complain_on_overflow */
559 bfd_elf_generic_reloc, /* special_function */
560 "R_ARM_ALU_PCREL_15_8",/* name */
561 FALSE, /* partial_inplace */
562 0x00000fff, /* src_mask */
563 0x00000fff, /* dst_mask */
564 TRUE), /* pcrel_offset */
565
566 HOWTO (R_ARM_ALU_PCREL23_15, /* type */
567 0, /* rightshift */
568 2, /* size (0 = byte, 1 = short, 2 = long) */
569 12, /* bitsize */
570 TRUE, /* pc_relative */
571 16, /* bitpos */
572 complain_overflow_dont,/* complain_on_overflow */
573 bfd_elf_generic_reloc, /* special_function */
574 "R_ARM_ALU_PCREL_23_15",/* name */
575 FALSE, /* partial_inplace */
576 0x00000fff, /* src_mask */
577 0x00000fff, /* dst_mask */
578 TRUE), /* pcrel_offset */
579
580 HOWTO (R_ARM_LDR_SBREL_11_0, /* type */
581 0, /* rightshift */
582 2, /* size (0 = byte, 1 = short, 2 = long) */
583 12, /* bitsize */
584 FALSE, /* pc_relative */
585 0, /* bitpos */
586 complain_overflow_dont,/* complain_on_overflow */
587 bfd_elf_generic_reloc, /* special_function */
588 "R_ARM_LDR_SBREL_11_0",/* name */
589 FALSE, /* partial_inplace */
590 0x00000fff, /* src_mask */
591 0x00000fff, /* dst_mask */
592 FALSE), /* pcrel_offset */
593
594 HOWTO (R_ARM_ALU_SBREL_19_12, /* type */
595 0, /* rightshift */
596 2, /* size (0 = byte, 1 = short, 2 = long) */
597 8, /* bitsize */
598 FALSE, /* pc_relative */
599 12, /* bitpos */
600 complain_overflow_dont,/* complain_on_overflow */
601 bfd_elf_generic_reloc, /* special_function */
602 "R_ARM_ALU_SBREL_19_12",/* name */
603 FALSE, /* partial_inplace */
604 0x000ff000, /* src_mask */
605 0x000ff000, /* dst_mask */
606 FALSE), /* pcrel_offset */
607
608 HOWTO (R_ARM_ALU_SBREL_27_20, /* type */
609 0, /* rightshift */
610 2, /* size (0 = byte, 1 = short, 2 = long) */
611 8, /* bitsize */
612 FALSE, /* pc_relative */
613 20, /* bitpos */
614 complain_overflow_dont,/* complain_on_overflow */
615 bfd_elf_generic_reloc, /* special_function */
616 "R_ARM_ALU_SBREL_27_20",/* name */
617 FALSE, /* partial_inplace */
618 0x0ff00000, /* src_mask */
619 0x0ff00000, /* dst_mask */
620 FALSE), /* pcrel_offset */
621
622 HOWTO (R_ARM_TARGET1, /* type */
623 0, /* rightshift */
624 2, /* size (0 = byte, 1 = short, 2 = long) */
625 32, /* bitsize */
626 FALSE, /* pc_relative */
627 0, /* bitpos */
628 complain_overflow_dont,/* complain_on_overflow */
629 bfd_elf_generic_reloc, /* special_function */
630 "R_ARM_TARGET1", /* name */
631 FALSE, /* partial_inplace */
632 0xffffffff, /* src_mask */
633 0xffffffff, /* dst_mask */
634 FALSE), /* pcrel_offset */
635
636 HOWTO (R_ARM_ROSEGREL32, /* type */
637 0, /* rightshift */
638 2, /* size (0 = byte, 1 = short, 2 = long) */
639 32, /* bitsize */
640 FALSE, /* pc_relative */
641 0, /* bitpos */
642 complain_overflow_dont,/* complain_on_overflow */
643 bfd_elf_generic_reloc, /* special_function */
644 "R_ARM_ROSEGREL32", /* name */
645 FALSE, /* partial_inplace */
646 0xffffffff, /* src_mask */
647 0xffffffff, /* dst_mask */
648 FALSE), /* pcrel_offset */
649
650 HOWTO (R_ARM_V4BX, /* type */
651 0, /* rightshift */
652 2, /* size (0 = byte, 1 = short, 2 = long) */
653 32, /* bitsize */
654 FALSE, /* pc_relative */
655 0, /* bitpos */
656 complain_overflow_dont,/* complain_on_overflow */
657 bfd_elf_generic_reloc, /* special_function */
658 "R_ARM_V4BX", /* name */
659 FALSE, /* partial_inplace */
660 0xffffffff, /* src_mask */
661 0xffffffff, /* dst_mask */
662 FALSE), /* pcrel_offset */
663
664 HOWTO (R_ARM_TARGET2, /* type */
665 0, /* rightshift */
666 2, /* size (0 = byte, 1 = short, 2 = long) */
667 32, /* bitsize */
668 FALSE, /* pc_relative */
669 0, /* bitpos */
670 complain_overflow_signed,/* complain_on_overflow */
671 bfd_elf_generic_reloc, /* special_function */
672 "R_ARM_TARGET2", /* name */
673 FALSE, /* partial_inplace */
674 0xffffffff, /* src_mask */
675 0xffffffff, /* dst_mask */
676 TRUE), /* pcrel_offset */
677
678 HOWTO (R_ARM_PREL31, /* type */
679 0, /* rightshift */
680 2, /* size (0 = byte, 1 = short, 2 = long) */
681 31, /* bitsize */
682 TRUE, /* pc_relative */
683 0, /* bitpos */
684 complain_overflow_signed,/* complain_on_overflow */
685 bfd_elf_generic_reloc, /* special_function */
686 "R_ARM_PREL31", /* name */
687 FALSE, /* partial_inplace */
688 0x7fffffff, /* src_mask */
689 0x7fffffff, /* dst_mask */
690 TRUE), /* pcrel_offset */
691
692 HOWTO (R_ARM_MOVW_ABS_NC, /* type */
693 0, /* rightshift */
694 2, /* size (0 = byte, 1 = short, 2 = long) */
695 16, /* bitsize */
696 FALSE, /* pc_relative */
697 0, /* bitpos */
698 complain_overflow_dont,/* complain_on_overflow */
699 bfd_elf_generic_reloc, /* special_function */
700 "R_ARM_MOVW_ABS_NC", /* name */
701 FALSE, /* partial_inplace */
702 0x000f0fff, /* src_mask */
703 0x000f0fff, /* dst_mask */
704 FALSE), /* pcrel_offset */
705
706 HOWTO (R_ARM_MOVT_ABS, /* type */
707 0, /* rightshift */
708 2, /* size (0 = byte, 1 = short, 2 = long) */
709 16, /* bitsize */
710 FALSE, /* pc_relative */
711 0, /* bitpos */
712 complain_overflow_bitfield,/* complain_on_overflow */
713 bfd_elf_generic_reloc, /* special_function */
714 "R_ARM_MOVT_ABS", /* name */
715 FALSE, /* partial_inplace */
716 0x000f0fff, /* src_mask */
717 0x000f0fff, /* dst_mask */
718 FALSE), /* pcrel_offset */
719
720 HOWTO (R_ARM_MOVW_PREL_NC, /* type */
721 0, /* rightshift */
722 2, /* size (0 = byte, 1 = short, 2 = long) */
723 16, /* bitsize */
724 TRUE, /* pc_relative */
725 0, /* bitpos */
726 complain_overflow_dont,/* complain_on_overflow */
727 bfd_elf_generic_reloc, /* special_function */
728 "R_ARM_MOVW_PREL_NC", /* name */
729 FALSE, /* partial_inplace */
730 0x000f0fff, /* src_mask */
731 0x000f0fff, /* dst_mask */
732 TRUE), /* pcrel_offset */
733
734 HOWTO (R_ARM_MOVT_PREL, /* type */
735 0, /* rightshift */
736 2, /* size (0 = byte, 1 = short, 2 = long) */
737 16, /* bitsize */
738 TRUE, /* pc_relative */
739 0, /* bitpos */
740 complain_overflow_bitfield,/* complain_on_overflow */
741 bfd_elf_generic_reloc, /* special_function */
742 "R_ARM_MOVT_PREL", /* name */
743 FALSE, /* partial_inplace */
744 0x000f0fff, /* src_mask */
745 0x000f0fff, /* dst_mask */
746 TRUE), /* pcrel_offset */
747
748 HOWTO (R_ARM_THM_MOVW_ABS_NC, /* type */
749 0, /* rightshift */
750 2, /* size (0 = byte, 1 = short, 2 = long) */
751 16, /* bitsize */
752 FALSE, /* pc_relative */
753 0, /* bitpos */
754 complain_overflow_dont,/* complain_on_overflow */
755 bfd_elf_generic_reloc, /* special_function */
756 "R_ARM_THM_MOVW_ABS_NC",/* name */
757 FALSE, /* partial_inplace */
758 0x040f70ff, /* src_mask */
759 0x040f70ff, /* dst_mask */
760 FALSE), /* pcrel_offset */
761
762 HOWTO (R_ARM_THM_MOVT_ABS, /* type */
763 0, /* rightshift */
764 2, /* size (0 = byte, 1 = short, 2 = long) */
765 16, /* bitsize */
766 FALSE, /* pc_relative */
767 0, /* bitpos */
768 complain_overflow_bitfield,/* complain_on_overflow */
769 bfd_elf_generic_reloc, /* special_function */
770 "R_ARM_THM_MOVT_ABS", /* name */
771 FALSE, /* partial_inplace */
772 0x040f70ff, /* src_mask */
773 0x040f70ff, /* dst_mask */
774 FALSE), /* pcrel_offset */
775
776 HOWTO (R_ARM_THM_MOVW_PREL_NC,/* type */
777 0, /* rightshift */
778 2, /* size (0 = byte, 1 = short, 2 = long) */
779 16, /* bitsize */
780 TRUE, /* pc_relative */
781 0, /* bitpos */
782 complain_overflow_dont,/* complain_on_overflow */
783 bfd_elf_generic_reloc, /* special_function */
784 "R_ARM_THM_MOVW_PREL_NC",/* name */
785 FALSE, /* partial_inplace */
786 0x040f70ff, /* src_mask */
787 0x040f70ff, /* dst_mask */
788 TRUE), /* pcrel_offset */
789
790 HOWTO (R_ARM_THM_MOVT_PREL, /* type */
791 0, /* rightshift */
792 2, /* size (0 = byte, 1 = short, 2 = long) */
793 16, /* bitsize */
794 TRUE, /* pc_relative */
795 0, /* bitpos */
796 complain_overflow_bitfield,/* complain_on_overflow */
797 bfd_elf_generic_reloc, /* special_function */
798 "R_ARM_THM_MOVT_PREL", /* name */
799 FALSE, /* partial_inplace */
800 0x040f70ff, /* src_mask */
801 0x040f70ff, /* dst_mask */
802 TRUE), /* pcrel_offset */
803
804 HOWTO (R_ARM_THM_JUMP19, /* type */
805 1, /* rightshift */
806 2, /* size (0 = byte, 1 = short, 2 = long) */
807 19, /* bitsize */
808 TRUE, /* pc_relative */
809 0, /* bitpos */
810 complain_overflow_signed,/* complain_on_overflow */
811 bfd_elf_generic_reloc, /* special_function */
812 "R_ARM_THM_JUMP19", /* name */
813 FALSE, /* partial_inplace */
814 0x043f2fff, /* src_mask */
815 0x043f2fff, /* dst_mask */
816 TRUE), /* pcrel_offset */
817
818 HOWTO (R_ARM_THM_JUMP6, /* type */
819 1, /* rightshift */
820 1, /* size (0 = byte, 1 = short, 2 = long) */
821 6, /* bitsize */
822 TRUE, /* pc_relative */
823 0, /* bitpos */
824 complain_overflow_unsigned,/* complain_on_overflow */
825 bfd_elf_generic_reloc, /* special_function */
826 "R_ARM_THM_JUMP6", /* name */
827 FALSE, /* partial_inplace */
828 0x02f8, /* src_mask */
829 0x02f8, /* dst_mask */
830 TRUE), /* pcrel_offset */
831
832 /* These are declared as 13-bit signed relocations because we can
833 address -4095 .. 4095(base) by altering ADDW to SUBW or vice
834 versa. */
835 HOWTO (R_ARM_THM_ALU_PREL_11_0,/* type */
836 0, /* rightshift */
837 2, /* size (0 = byte, 1 = short, 2 = long) */
838 13, /* bitsize */
839 TRUE, /* pc_relative */
840 0, /* bitpos */
841 complain_overflow_dont,/* complain_on_overflow */
842 bfd_elf_generic_reloc, /* special_function */
843 "R_ARM_THM_ALU_PREL_11_0",/* name */
844 FALSE, /* partial_inplace */
845 0xffffffff, /* src_mask */
846 0xffffffff, /* dst_mask */
847 TRUE), /* pcrel_offset */
848
849 HOWTO (R_ARM_THM_PC12, /* type */
850 0, /* rightshift */
851 2, /* size (0 = byte, 1 = short, 2 = long) */
852 13, /* bitsize */
853 TRUE, /* pc_relative */
854 0, /* bitpos */
855 complain_overflow_dont,/* complain_on_overflow */
856 bfd_elf_generic_reloc, /* special_function */
857 "R_ARM_THM_PC12", /* name */
858 FALSE, /* partial_inplace */
859 0xffffffff, /* src_mask */
860 0xffffffff, /* dst_mask */
861 TRUE), /* pcrel_offset */
862
863 HOWTO (R_ARM_ABS32_NOI, /* type */
864 0, /* rightshift */
865 2, /* size (0 = byte, 1 = short, 2 = long) */
866 32, /* bitsize */
867 FALSE, /* pc_relative */
868 0, /* bitpos */
869 complain_overflow_dont,/* complain_on_overflow */
870 bfd_elf_generic_reloc, /* special_function */
871 "R_ARM_ABS32_NOI", /* name */
872 FALSE, /* partial_inplace */
873 0xffffffff, /* src_mask */
874 0xffffffff, /* dst_mask */
875 FALSE), /* pcrel_offset */
876
877 HOWTO (R_ARM_REL32_NOI, /* type */
878 0, /* rightshift */
879 2, /* size (0 = byte, 1 = short, 2 = long) */
880 32, /* bitsize */
881 TRUE, /* pc_relative */
882 0, /* bitpos */
883 complain_overflow_dont,/* complain_on_overflow */
884 bfd_elf_generic_reloc, /* special_function */
885 "R_ARM_REL32_NOI", /* name */
886 FALSE, /* partial_inplace */
887 0xffffffff, /* src_mask */
888 0xffffffff, /* dst_mask */
889 FALSE), /* pcrel_offset */
890
891 /* Group relocations. */
892
893 HOWTO (R_ARM_ALU_PC_G0_NC, /* type */
894 0, /* rightshift */
895 2, /* size (0 = byte, 1 = short, 2 = long) */
896 32, /* bitsize */
897 TRUE, /* pc_relative */
898 0, /* bitpos */
899 complain_overflow_dont,/* complain_on_overflow */
900 bfd_elf_generic_reloc, /* special_function */
901 "R_ARM_ALU_PC_G0_NC", /* name */
902 FALSE, /* partial_inplace */
903 0xffffffff, /* src_mask */
904 0xffffffff, /* dst_mask */
905 TRUE), /* pcrel_offset */
906
907 HOWTO (R_ARM_ALU_PC_G0, /* type */
908 0, /* rightshift */
909 2, /* size (0 = byte, 1 = short, 2 = long) */
910 32, /* bitsize */
911 TRUE, /* pc_relative */
912 0, /* bitpos */
913 complain_overflow_dont,/* complain_on_overflow */
914 bfd_elf_generic_reloc, /* special_function */
915 "R_ARM_ALU_PC_G0", /* name */
916 FALSE, /* partial_inplace */
917 0xffffffff, /* src_mask */
918 0xffffffff, /* dst_mask */
919 TRUE), /* pcrel_offset */
920
921 HOWTO (R_ARM_ALU_PC_G1_NC, /* type */
922 0, /* rightshift */
923 2, /* size (0 = byte, 1 = short, 2 = long) */
924 32, /* bitsize */
925 TRUE, /* pc_relative */
926 0, /* bitpos */
927 complain_overflow_dont,/* complain_on_overflow */
928 bfd_elf_generic_reloc, /* special_function */
929 "R_ARM_ALU_PC_G1_NC", /* name */
930 FALSE, /* partial_inplace */
931 0xffffffff, /* src_mask */
932 0xffffffff, /* dst_mask */
933 TRUE), /* pcrel_offset */
934
935 HOWTO (R_ARM_ALU_PC_G1, /* type */
936 0, /* rightshift */
937 2, /* size (0 = byte, 1 = short, 2 = long) */
938 32, /* bitsize */
939 TRUE, /* pc_relative */
940 0, /* bitpos */
941 complain_overflow_dont,/* complain_on_overflow */
942 bfd_elf_generic_reloc, /* special_function */
943 "R_ARM_ALU_PC_G1", /* name */
944 FALSE, /* partial_inplace */
945 0xffffffff, /* src_mask */
946 0xffffffff, /* dst_mask */
947 TRUE), /* pcrel_offset */
948
949 HOWTO (R_ARM_ALU_PC_G2, /* type */
950 0, /* rightshift */
951 2, /* size (0 = byte, 1 = short, 2 = long) */
952 32, /* bitsize */
953 TRUE, /* pc_relative */
954 0, /* bitpos */
955 complain_overflow_dont,/* complain_on_overflow */
956 bfd_elf_generic_reloc, /* special_function */
957 "R_ARM_ALU_PC_G2", /* name */
958 FALSE, /* partial_inplace */
959 0xffffffff, /* src_mask */
960 0xffffffff, /* dst_mask */
961 TRUE), /* pcrel_offset */
962
963 HOWTO (R_ARM_LDR_PC_G1, /* type */
964 0, /* rightshift */
965 2, /* size (0 = byte, 1 = short, 2 = long) */
966 32, /* bitsize */
967 TRUE, /* pc_relative */
968 0, /* bitpos */
969 complain_overflow_dont,/* complain_on_overflow */
970 bfd_elf_generic_reloc, /* special_function */
971 "R_ARM_LDR_PC_G1", /* name */
972 FALSE, /* partial_inplace */
973 0xffffffff, /* src_mask */
974 0xffffffff, /* dst_mask */
975 TRUE), /* pcrel_offset */
976
977 HOWTO (R_ARM_LDR_PC_G2, /* type */
978 0, /* rightshift */
979 2, /* size (0 = byte, 1 = short, 2 = long) */
980 32, /* bitsize */
981 TRUE, /* pc_relative */
982 0, /* bitpos */
983 complain_overflow_dont,/* complain_on_overflow */
984 bfd_elf_generic_reloc, /* special_function */
985 "R_ARM_LDR_PC_G2", /* name */
986 FALSE, /* partial_inplace */
987 0xffffffff, /* src_mask */
988 0xffffffff, /* dst_mask */
989 TRUE), /* pcrel_offset */
990
991 HOWTO (R_ARM_LDRS_PC_G0, /* type */
992 0, /* rightshift */
993 2, /* size (0 = byte, 1 = short, 2 = long) */
994 32, /* bitsize */
995 TRUE, /* pc_relative */
996 0, /* bitpos */
997 complain_overflow_dont,/* complain_on_overflow */
998 bfd_elf_generic_reloc, /* special_function */
999 "R_ARM_LDRS_PC_G0", /* name */
1000 FALSE, /* partial_inplace */
1001 0xffffffff, /* src_mask */
1002 0xffffffff, /* dst_mask */
1003 TRUE), /* pcrel_offset */
1004
1005 HOWTO (R_ARM_LDRS_PC_G1, /* type */
1006 0, /* rightshift */
1007 2, /* size (0 = byte, 1 = short, 2 = long) */
1008 32, /* bitsize */
1009 TRUE, /* pc_relative */
1010 0, /* bitpos */
1011 complain_overflow_dont,/* complain_on_overflow */
1012 bfd_elf_generic_reloc, /* special_function */
1013 "R_ARM_LDRS_PC_G1", /* name */
1014 FALSE, /* partial_inplace */
1015 0xffffffff, /* src_mask */
1016 0xffffffff, /* dst_mask */
1017 TRUE), /* pcrel_offset */
1018
1019 HOWTO (R_ARM_LDRS_PC_G2, /* type */
1020 0, /* rightshift */
1021 2, /* size (0 = byte, 1 = short, 2 = long) */
1022 32, /* bitsize */
1023 TRUE, /* pc_relative */
1024 0, /* bitpos */
1025 complain_overflow_dont,/* complain_on_overflow */
1026 bfd_elf_generic_reloc, /* special_function */
1027 "R_ARM_LDRS_PC_G2", /* name */
1028 FALSE, /* partial_inplace */
1029 0xffffffff, /* src_mask */
1030 0xffffffff, /* dst_mask */
1031 TRUE), /* pcrel_offset */
1032
1033 HOWTO (R_ARM_LDC_PC_G0, /* type */
1034 0, /* rightshift */
1035 2, /* size (0 = byte, 1 = short, 2 = long) */
1036 32, /* bitsize */
1037 TRUE, /* pc_relative */
1038 0, /* bitpos */
1039 complain_overflow_dont,/* complain_on_overflow */
1040 bfd_elf_generic_reloc, /* special_function */
1041 "R_ARM_LDC_PC_G0", /* name */
1042 FALSE, /* partial_inplace */
1043 0xffffffff, /* src_mask */
1044 0xffffffff, /* dst_mask */
1045 TRUE), /* pcrel_offset */
1046
1047 HOWTO (R_ARM_LDC_PC_G1, /* type */
1048 0, /* rightshift */
1049 2, /* size (0 = byte, 1 = short, 2 = long) */
1050 32, /* bitsize */
1051 TRUE, /* pc_relative */
1052 0, /* bitpos */
1053 complain_overflow_dont,/* complain_on_overflow */
1054 bfd_elf_generic_reloc, /* special_function */
1055 "R_ARM_LDC_PC_G1", /* name */
1056 FALSE, /* partial_inplace */
1057 0xffffffff, /* src_mask */
1058 0xffffffff, /* dst_mask */
1059 TRUE), /* pcrel_offset */
1060
1061 HOWTO (R_ARM_LDC_PC_G2, /* type */
1062 0, /* rightshift */
1063 2, /* size (0 = byte, 1 = short, 2 = long) */
1064 32, /* bitsize */
1065 TRUE, /* pc_relative */
1066 0, /* bitpos */
1067 complain_overflow_dont,/* complain_on_overflow */
1068 bfd_elf_generic_reloc, /* special_function */
1069 "R_ARM_LDC_PC_G2", /* name */
1070 FALSE, /* partial_inplace */
1071 0xffffffff, /* src_mask */
1072 0xffffffff, /* dst_mask */
1073 TRUE), /* pcrel_offset */
1074
1075 HOWTO (R_ARM_ALU_SB_G0_NC, /* type */
1076 0, /* rightshift */
1077 2, /* size (0 = byte, 1 = short, 2 = long) */
1078 32, /* bitsize */
1079 TRUE, /* pc_relative */
1080 0, /* bitpos */
1081 complain_overflow_dont,/* complain_on_overflow */
1082 bfd_elf_generic_reloc, /* special_function */
1083 "R_ARM_ALU_SB_G0_NC", /* name */
1084 FALSE, /* partial_inplace */
1085 0xffffffff, /* src_mask */
1086 0xffffffff, /* dst_mask */
1087 TRUE), /* pcrel_offset */
1088
1089 HOWTO (R_ARM_ALU_SB_G0, /* type */
1090 0, /* rightshift */
1091 2, /* size (0 = byte, 1 = short, 2 = long) */
1092 32, /* bitsize */
1093 TRUE, /* pc_relative */
1094 0, /* bitpos */
1095 complain_overflow_dont,/* complain_on_overflow */
1096 bfd_elf_generic_reloc, /* special_function */
1097 "R_ARM_ALU_SB_G0", /* name */
1098 FALSE, /* partial_inplace */
1099 0xffffffff, /* src_mask */
1100 0xffffffff, /* dst_mask */
1101 TRUE), /* pcrel_offset */
1102
1103 HOWTO (R_ARM_ALU_SB_G1_NC, /* type */
1104 0, /* rightshift */
1105 2, /* size (0 = byte, 1 = short, 2 = long) */
1106 32, /* bitsize */
1107 TRUE, /* pc_relative */
1108 0, /* bitpos */
1109 complain_overflow_dont,/* complain_on_overflow */
1110 bfd_elf_generic_reloc, /* special_function */
1111 "R_ARM_ALU_SB_G1_NC", /* name */
1112 FALSE, /* partial_inplace */
1113 0xffffffff, /* src_mask */
1114 0xffffffff, /* dst_mask */
1115 TRUE), /* pcrel_offset */
1116
1117 HOWTO (R_ARM_ALU_SB_G1, /* type */
1118 0, /* rightshift */
1119 2, /* size (0 = byte, 1 = short, 2 = long) */
1120 32, /* bitsize */
1121 TRUE, /* pc_relative */
1122 0, /* bitpos */
1123 complain_overflow_dont,/* complain_on_overflow */
1124 bfd_elf_generic_reloc, /* special_function */
1125 "R_ARM_ALU_SB_G1", /* name */
1126 FALSE, /* partial_inplace */
1127 0xffffffff, /* src_mask */
1128 0xffffffff, /* dst_mask */
1129 TRUE), /* pcrel_offset */
1130
1131 HOWTO (R_ARM_ALU_SB_G2, /* type */
1132 0, /* rightshift */
1133 2, /* size (0 = byte, 1 = short, 2 = long) */
1134 32, /* bitsize */
1135 TRUE, /* pc_relative */
1136 0, /* bitpos */
1137 complain_overflow_dont,/* complain_on_overflow */
1138 bfd_elf_generic_reloc, /* special_function */
1139 "R_ARM_ALU_SB_G2", /* name */
1140 FALSE, /* partial_inplace */
1141 0xffffffff, /* src_mask */
1142 0xffffffff, /* dst_mask */
1143 TRUE), /* pcrel_offset */
1144
1145 HOWTO (R_ARM_LDR_SB_G0, /* type */
1146 0, /* rightshift */
1147 2, /* size (0 = byte, 1 = short, 2 = long) */
1148 32, /* bitsize */
1149 TRUE, /* pc_relative */
1150 0, /* bitpos */
1151 complain_overflow_dont,/* complain_on_overflow */
1152 bfd_elf_generic_reloc, /* special_function */
1153 "R_ARM_LDR_SB_G0", /* name */
1154 FALSE, /* partial_inplace */
1155 0xffffffff, /* src_mask */
1156 0xffffffff, /* dst_mask */
1157 TRUE), /* pcrel_offset */
1158
1159 HOWTO (R_ARM_LDR_SB_G1, /* type */
1160 0, /* rightshift */
1161 2, /* size (0 = byte, 1 = short, 2 = long) */
1162 32, /* bitsize */
1163 TRUE, /* pc_relative */
1164 0, /* bitpos */
1165 complain_overflow_dont,/* complain_on_overflow */
1166 bfd_elf_generic_reloc, /* special_function */
1167 "R_ARM_LDR_SB_G1", /* name */
1168 FALSE, /* partial_inplace */
1169 0xffffffff, /* src_mask */
1170 0xffffffff, /* dst_mask */
1171 TRUE), /* pcrel_offset */
1172
1173 HOWTO (R_ARM_LDR_SB_G2, /* type */
1174 0, /* rightshift */
1175 2, /* size (0 = byte, 1 = short, 2 = long) */
1176 32, /* bitsize */
1177 TRUE, /* pc_relative */
1178 0, /* bitpos */
1179 complain_overflow_dont,/* complain_on_overflow */
1180 bfd_elf_generic_reloc, /* special_function */
1181 "R_ARM_LDR_SB_G2", /* name */
1182 FALSE, /* partial_inplace */
1183 0xffffffff, /* src_mask */
1184 0xffffffff, /* dst_mask */
1185 TRUE), /* pcrel_offset */
1186
1187 HOWTO (R_ARM_LDRS_SB_G0, /* type */
1188 0, /* rightshift */
1189 2, /* size (0 = byte, 1 = short, 2 = long) */
1190 32, /* bitsize */
1191 TRUE, /* pc_relative */
1192 0, /* bitpos */
1193 complain_overflow_dont,/* complain_on_overflow */
1194 bfd_elf_generic_reloc, /* special_function */
1195 "R_ARM_LDRS_SB_G0", /* name */
1196 FALSE, /* partial_inplace */
1197 0xffffffff, /* src_mask */
1198 0xffffffff, /* dst_mask */
1199 TRUE), /* pcrel_offset */
1200
1201 HOWTO (R_ARM_LDRS_SB_G1, /* type */
1202 0, /* rightshift */
1203 2, /* size (0 = byte, 1 = short, 2 = long) */
1204 32, /* bitsize */
1205 TRUE, /* pc_relative */
1206 0, /* bitpos */
1207 complain_overflow_dont,/* complain_on_overflow */
1208 bfd_elf_generic_reloc, /* special_function */
1209 "R_ARM_LDRS_SB_G1", /* name */
1210 FALSE, /* partial_inplace */
1211 0xffffffff, /* src_mask */
1212 0xffffffff, /* dst_mask */
1213 TRUE), /* pcrel_offset */
1214
1215 HOWTO (R_ARM_LDRS_SB_G2, /* type */
1216 0, /* rightshift */
1217 2, /* size (0 = byte, 1 = short, 2 = long) */
1218 32, /* bitsize */
1219 TRUE, /* pc_relative */
1220 0, /* bitpos */
1221 complain_overflow_dont,/* complain_on_overflow */
1222 bfd_elf_generic_reloc, /* special_function */
1223 "R_ARM_LDRS_SB_G2", /* name */
1224 FALSE, /* partial_inplace */
1225 0xffffffff, /* src_mask */
1226 0xffffffff, /* dst_mask */
1227 TRUE), /* pcrel_offset */
1228
1229 HOWTO (R_ARM_LDC_SB_G0, /* type */
1230 0, /* rightshift */
1231 2, /* size (0 = byte, 1 = short, 2 = long) */
1232 32, /* bitsize */
1233 TRUE, /* pc_relative */
1234 0, /* bitpos */
1235 complain_overflow_dont,/* complain_on_overflow */
1236 bfd_elf_generic_reloc, /* special_function */
1237 "R_ARM_LDC_SB_G0", /* name */
1238 FALSE, /* partial_inplace */
1239 0xffffffff, /* src_mask */
1240 0xffffffff, /* dst_mask */
1241 TRUE), /* pcrel_offset */
1242
1243 HOWTO (R_ARM_LDC_SB_G1, /* type */
1244 0, /* rightshift */
1245 2, /* size (0 = byte, 1 = short, 2 = long) */
1246 32, /* bitsize */
1247 TRUE, /* pc_relative */
1248 0, /* bitpos */
1249 complain_overflow_dont,/* complain_on_overflow */
1250 bfd_elf_generic_reloc, /* special_function */
1251 "R_ARM_LDC_SB_G1", /* name */
1252 FALSE, /* partial_inplace */
1253 0xffffffff, /* src_mask */
1254 0xffffffff, /* dst_mask */
1255 TRUE), /* pcrel_offset */
1256
1257 HOWTO (R_ARM_LDC_SB_G2, /* type */
1258 0, /* rightshift */
1259 2, /* size (0 = byte, 1 = short, 2 = long) */
1260 32, /* bitsize */
1261 TRUE, /* pc_relative */
1262 0, /* bitpos */
1263 complain_overflow_dont,/* complain_on_overflow */
1264 bfd_elf_generic_reloc, /* special_function */
1265 "R_ARM_LDC_SB_G2", /* name */
1266 FALSE, /* partial_inplace */
1267 0xffffffff, /* src_mask */
1268 0xffffffff, /* dst_mask */
1269 TRUE), /* pcrel_offset */
1270
1271 /* End of group relocations. */
1272
1273 HOWTO (R_ARM_MOVW_BREL_NC, /* type */
1274 0, /* rightshift */
1275 2, /* size (0 = byte, 1 = short, 2 = long) */
1276 16, /* bitsize */
1277 FALSE, /* pc_relative */
1278 0, /* bitpos */
1279 complain_overflow_dont,/* complain_on_overflow */
1280 bfd_elf_generic_reloc, /* special_function */
1281 "R_ARM_MOVW_BREL_NC", /* name */
1282 FALSE, /* partial_inplace */
1283 0x0000ffff, /* src_mask */
1284 0x0000ffff, /* dst_mask */
1285 FALSE), /* pcrel_offset */
1286
1287 HOWTO (R_ARM_MOVT_BREL, /* type */
1288 0, /* rightshift */
1289 2, /* size (0 = byte, 1 = short, 2 = long) */
1290 16, /* bitsize */
1291 FALSE, /* pc_relative */
1292 0, /* bitpos */
1293 complain_overflow_bitfield,/* complain_on_overflow */
1294 bfd_elf_generic_reloc, /* special_function */
1295 "R_ARM_MOVT_BREL", /* name */
1296 FALSE, /* partial_inplace */
1297 0x0000ffff, /* src_mask */
1298 0x0000ffff, /* dst_mask */
1299 FALSE), /* pcrel_offset */
1300
1301 HOWTO (R_ARM_MOVW_BREL, /* type */
1302 0, /* rightshift */
1303 2, /* size (0 = byte, 1 = short, 2 = long) */
1304 16, /* bitsize */
1305 FALSE, /* pc_relative */
1306 0, /* bitpos */
1307 complain_overflow_dont,/* complain_on_overflow */
1308 bfd_elf_generic_reloc, /* special_function */
1309 "R_ARM_MOVW_BREL", /* name */
1310 FALSE, /* partial_inplace */
1311 0x0000ffff, /* src_mask */
1312 0x0000ffff, /* dst_mask */
1313 FALSE), /* pcrel_offset */
1314
1315 HOWTO (R_ARM_THM_MOVW_BREL_NC,/* type */
1316 0, /* rightshift */
1317 2, /* size (0 = byte, 1 = short, 2 = long) */
1318 16, /* bitsize */
1319 FALSE, /* pc_relative */
1320 0, /* bitpos */
1321 complain_overflow_dont,/* complain_on_overflow */
1322 bfd_elf_generic_reloc, /* special_function */
1323 "R_ARM_THM_MOVW_BREL_NC",/* name */
1324 FALSE, /* partial_inplace */
1325 0x040f70ff, /* src_mask */
1326 0x040f70ff, /* dst_mask */
1327 FALSE), /* pcrel_offset */
1328
1329 HOWTO (R_ARM_THM_MOVT_BREL, /* type */
1330 0, /* rightshift */
1331 2, /* size (0 = byte, 1 = short, 2 = long) */
1332 16, /* bitsize */
1333 FALSE, /* pc_relative */
1334 0, /* bitpos */
1335 complain_overflow_bitfield,/* complain_on_overflow */
1336 bfd_elf_generic_reloc, /* special_function */
1337 "R_ARM_THM_MOVT_BREL", /* name */
1338 FALSE, /* partial_inplace */
1339 0x040f70ff, /* src_mask */
1340 0x040f70ff, /* dst_mask */
1341 FALSE), /* pcrel_offset */
1342
1343 HOWTO (R_ARM_THM_MOVW_BREL, /* type */
1344 0, /* rightshift */
1345 2, /* size (0 = byte, 1 = short, 2 = long) */
1346 16, /* bitsize */
1347 FALSE, /* pc_relative */
1348 0, /* bitpos */
1349 complain_overflow_dont,/* complain_on_overflow */
1350 bfd_elf_generic_reloc, /* special_function */
1351 "R_ARM_THM_MOVW_BREL", /* name */
1352 FALSE, /* partial_inplace */
1353 0x040f70ff, /* src_mask */
1354 0x040f70ff, /* dst_mask */
1355 FALSE), /* pcrel_offset */
1356
1357 EMPTY_HOWTO (90), /* Unallocated. */
1358 EMPTY_HOWTO (91),
1359 EMPTY_HOWTO (92),
1360 EMPTY_HOWTO (93),
1361
1362 HOWTO (R_ARM_PLT32_ABS, /* type */
1363 0, /* rightshift */
1364 2, /* size (0 = byte, 1 = short, 2 = long) */
1365 32, /* bitsize */
1366 FALSE, /* pc_relative */
1367 0, /* bitpos */
1368 complain_overflow_dont,/* complain_on_overflow */
1369 bfd_elf_generic_reloc, /* special_function */
1370 "R_ARM_PLT32_ABS", /* name */
1371 FALSE, /* partial_inplace */
1372 0xffffffff, /* src_mask */
1373 0xffffffff, /* dst_mask */
1374 FALSE), /* pcrel_offset */
1375
1376 HOWTO (R_ARM_GOT_ABS, /* type */
1377 0, /* rightshift */
1378 2, /* size (0 = byte, 1 = short, 2 = long) */
1379 32, /* bitsize */
1380 FALSE, /* pc_relative */
1381 0, /* bitpos */
1382 complain_overflow_dont,/* complain_on_overflow */
1383 bfd_elf_generic_reloc, /* special_function */
1384 "R_ARM_GOT_ABS", /* name */
1385 FALSE, /* partial_inplace */
1386 0xffffffff, /* src_mask */
1387 0xffffffff, /* dst_mask */
1388 FALSE), /* pcrel_offset */
1389
1390 HOWTO (R_ARM_GOT_PREL, /* type */
1391 0, /* rightshift */
1392 2, /* size (0 = byte, 1 = short, 2 = long) */
1393 32, /* bitsize */
1394 TRUE, /* pc_relative */
1395 0, /* bitpos */
1396 complain_overflow_dont, /* complain_on_overflow */
1397 bfd_elf_generic_reloc, /* special_function */
1398 "R_ARM_GOT_PREL", /* name */
1399 FALSE, /* partial_inplace */
1400 0xffffffff, /* src_mask */
1401 0xffffffff, /* dst_mask */
1402 TRUE), /* pcrel_offset */
1403
1404 HOWTO (R_ARM_GOT_BREL12, /* type */
1405 0, /* rightshift */
1406 2, /* size (0 = byte, 1 = short, 2 = long) */
1407 12, /* bitsize */
1408 FALSE, /* pc_relative */
1409 0, /* bitpos */
1410 complain_overflow_bitfield,/* complain_on_overflow */
1411 bfd_elf_generic_reloc, /* special_function */
1412 "R_ARM_GOT_BREL12", /* name */
1413 FALSE, /* partial_inplace */
1414 0x00000fff, /* src_mask */
1415 0x00000fff, /* dst_mask */
1416 FALSE), /* pcrel_offset */
1417
1418 HOWTO (R_ARM_GOTOFF12, /* type */
1419 0, /* rightshift */
1420 2, /* size (0 = byte, 1 = short, 2 = long) */
1421 12, /* bitsize */
1422 FALSE, /* pc_relative */
1423 0, /* bitpos */
1424 complain_overflow_bitfield,/* complain_on_overflow */
1425 bfd_elf_generic_reloc, /* special_function */
1426 "R_ARM_GOTOFF12", /* name */
1427 FALSE, /* partial_inplace */
1428 0x00000fff, /* src_mask */
1429 0x00000fff, /* dst_mask */
1430 FALSE), /* pcrel_offset */
1431
1432 EMPTY_HOWTO (R_ARM_GOTRELAX), /* reserved for future GOT-load optimizations */
1433
1434 /* GNU extension to record C++ vtable member usage */
1435 HOWTO (R_ARM_GNU_VTENTRY, /* type */
1436 0, /* rightshift */
1437 2, /* size (0 = byte, 1 = short, 2 = long) */
1438 0, /* bitsize */
1439 FALSE, /* pc_relative */
1440 0, /* bitpos */
1441 complain_overflow_dont, /* complain_on_overflow */
1442 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
1443 "R_ARM_GNU_VTENTRY", /* name */
1444 FALSE, /* partial_inplace */
1445 0, /* src_mask */
1446 0, /* dst_mask */
1447 FALSE), /* pcrel_offset */
1448
1449 /* GNU extension to record C++ vtable hierarchy */
1450 HOWTO (R_ARM_GNU_VTINHERIT, /* type */
1451 0, /* rightshift */
1452 2, /* size (0 = byte, 1 = short, 2 = long) */
1453 0, /* bitsize */
1454 FALSE, /* pc_relative */
1455 0, /* bitpos */
1456 complain_overflow_dont, /* complain_on_overflow */
1457 NULL, /* special_function */
1458 "R_ARM_GNU_VTINHERIT", /* name */
1459 FALSE, /* partial_inplace */
1460 0, /* src_mask */
1461 0, /* dst_mask */
1462 FALSE), /* pcrel_offset */
1463
1464 HOWTO (R_ARM_THM_JUMP11, /* type */
1465 1, /* rightshift */
1466 1, /* size (0 = byte, 1 = short, 2 = long) */
1467 11, /* bitsize */
1468 TRUE, /* pc_relative */
1469 0, /* bitpos */
1470 complain_overflow_signed, /* complain_on_overflow */
1471 bfd_elf_generic_reloc, /* special_function */
1472 "R_ARM_THM_JUMP11", /* name */
1473 FALSE, /* partial_inplace */
1474 0x000007ff, /* src_mask */
1475 0x000007ff, /* dst_mask */
1476 TRUE), /* pcrel_offset */
1477
1478 HOWTO (R_ARM_THM_JUMP8, /* type */
1479 1, /* rightshift */
1480 1, /* size (0 = byte, 1 = short, 2 = long) */
1481 8, /* bitsize */
1482 TRUE, /* pc_relative */
1483 0, /* bitpos */
1484 complain_overflow_signed, /* complain_on_overflow */
1485 bfd_elf_generic_reloc, /* special_function */
1486 "R_ARM_THM_JUMP8", /* name */
1487 FALSE, /* partial_inplace */
1488 0x000000ff, /* src_mask */
1489 0x000000ff, /* dst_mask */
1490 TRUE), /* pcrel_offset */
1491
1492 /* TLS relocations */
1493 HOWTO (R_ARM_TLS_GD32, /* type */
1494 0, /* rightshift */
1495 2, /* size (0 = byte, 1 = short, 2 = long) */
1496 32, /* bitsize */
1497 FALSE, /* pc_relative */
1498 0, /* bitpos */
1499 complain_overflow_bitfield,/* complain_on_overflow */
1500 NULL, /* special_function */
1501 "R_ARM_TLS_GD32", /* name */
1502 TRUE, /* partial_inplace */
1503 0xffffffff, /* src_mask */
1504 0xffffffff, /* dst_mask */
1505 FALSE), /* pcrel_offset */
1506
1507 HOWTO (R_ARM_TLS_LDM32, /* type */
1508 0, /* rightshift */
1509 2, /* size (0 = byte, 1 = short, 2 = long) */
1510 32, /* bitsize */
1511 FALSE, /* pc_relative */
1512 0, /* bitpos */
1513 complain_overflow_bitfield,/* complain_on_overflow */
1514 bfd_elf_generic_reloc, /* special_function */
1515 "R_ARM_TLS_LDM32", /* name */
1516 TRUE, /* partial_inplace */
1517 0xffffffff, /* src_mask */
1518 0xffffffff, /* dst_mask */
1519 FALSE), /* pcrel_offset */
1520
1521 HOWTO (R_ARM_TLS_LDO32, /* type */
1522 0, /* rightshift */
1523 2, /* size (0 = byte, 1 = short, 2 = long) */
1524 32, /* bitsize */
1525 FALSE, /* pc_relative */
1526 0, /* bitpos */
1527 complain_overflow_bitfield,/* complain_on_overflow */
1528 bfd_elf_generic_reloc, /* special_function */
1529 "R_ARM_TLS_LDO32", /* name */
1530 TRUE, /* partial_inplace */
1531 0xffffffff, /* src_mask */
1532 0xffffffff, /* dst_mask */
1533 FALSE), /* pcrel_offset */
1534
1535 HOWTO (R_ARM_TLS_IE32, /* type */
1536 0, /* rightshift */
1537 2, /* size (0 = byte, 1 = short, 2 = long) */
1538 32, /* bitsize */
1539 FALSE, /* pc_relative */
1540 0, /* bitpos */
1541 complain_overflow_bitfield,/* complain_on_overflow */
1542 NULL, /* special_function */
1543 "R_ARM_TLS_IE32", /* name */
1544 TRUE, /* partial_inplace */
1545 0xffffffff, /* src_mask */
1546 0xffffffff, /* dst_mask */
1547 FALSE), /* pcrel_offset */
1548
1549 HOWTO (R_ARM_TLS_LE32, /* type */
1550 0, /* rightshift */
1551 2, /* size (0 = byte, 1 = short, 2 = long) */
1552 32, /* bitsize */
1553 FALSE, /* pc_relative */
1554 0, /* bitpos */
1555 complain_overflow_bitfield,/* complain_on_overflow */
1556 bfd_elf_generic_reloc, /* special_function */
1557 "R_ARM_TLS_LE32", /* name */
1558 TRUE, /* partial_inplace */
1559 0xffffffff, /* src_mask */
1560 0xffffffff, /* dst_mask */
1561 FALSE), /* pcrel_offset */
1562
1563 HOWTO (R_ARM_TLS_LDO12, /* type */
1564 0, /* rightshift */
1565 2, /* size (0 = byte, 1 = short, 2 = long) */
1566 12, /* bitsize */
1567 FALSE, /* pc_relative */
1568 0, /* bitpos */
1569 complain_overflow_bitfield,/* complain_on_overflow */
1570 bfd_elf_generic_reloc, /* special_function */
1571 "R_ARM_TLS_LDO12", /* name */
1572 FALSE, /* partial_inplace */
1573 0x00000fff, /* src_mask */
1574 0x00000fff, /* dst_mask */
1575 FALSE), /* pcrel_offset */
1576
1577 HOWTO (R_ARM_TLS_LE12, /* type */
1578 0, /* rightshift */
1579 2, /* size (0 = byte, 1 = short, 2 = long) */
1580 12, /* bitsize */
1581 FALSE, /* pc_relative */
1582 0, /* bitpos */
1583 complain_overflow_bitfield,/* complain_on_overflow */
1584 bfd_elf_generic_reloc, /* special_function */
1585 "R_ARM_TLS_LE12", /* name */
1586 FALSE, /* partial_inplace */
1587 0x00000fff, /* src_mask */
1588 0x00000fff, /* dst_mask */
1589 FALSE), /* pcrel_offset */
1590
1591 HOWTO (R_ARM_TLS_IE12GP, /* type */
1592 0, /* rightshift */
1593 2, /* size (0 = byte, 1 = short, 2 = long) */
1594 12, /* bitsize */
1595 FALSE, /* pc_relative */
1596 0, /* bitpos */
1597 complain_overflow_bitfield,/* complain_on_overflow */
1598 bfd_elf_generic_reloc, /* special_function */
1599 "R_ARM_TLS_IE12GP", /* name */
1600 FALSE, /* partial_inplace */
1601 0x00000fff, /* src_mask */
1602 0x00000fff, /* dst_mask */
1603 FALSE), /* pcrel_offset */
1604 };
1605
1606 /* 112-127 private relocations
1607 128 R_ARM_ME_TOO, obsolete
1608 129-255 unallocated in AAELF.
1609
1610 249-255 extended, currently unused, relocations: */
1611
1612 static reloc_howto_type elf32_arm_howto_table_2[4] =
1613 {
1614 HOWTO (R_ARM_RREL32, /* type */
1615 0, /* rightshift */
1616 0, /* size (0 = byte, 1 = short, 2 = long) */
1617 0, /* bitsize */
1618 FALSE, /* pc_relative */
1619 0, /* bitpos */
1620 complain_overflow_dont,/* complain_on_overflow */
1621 bfd_elf_generic_reloc, /* special_function */
1622 "R_ARM_RREL32", /* name */
1623 FALSE, /* partial_inplace */
1624 0, /* src_mask */
1625 0, /* dst_mask */
1626 FALSE), /* pcrel_offset */
1627
1628 HOWTO (R_ARM_RABS32, /* type */
1629 0, /* rightshift */
1630 0, /* size (0 = byte, 1 = short, 2 = long) */
1631 0, /* bitsize */
1632 FALSE, /* pc_relative */
1633 0, /* bitpos */
1634 complain_overflow_dont,/* complain_on_overflow */
1635 bfd_elf_generic_reloc, /* special_function */
1636 "R_ARM_RABS32", /* name */
1637 FALSE, /* partial_inplace */
1638 0, /* src_mask */
1639 0, /* dst_mask */
1640 FALSE), /* pcrel_offset */
1641
1642 HOWTO (R_ARM_RPC24, /* type */
1643 0, /* rightshift */
1644 0, /* size (0 = byte, 1 = short, 2 = long) */
1645 0, /* bitsize */
1646 FALSE, /* pc_relative */
1647 0, /* bitpos */
1648 complain_overflow_dont,/* complain_on_overflow */
1649 bfd_elf_generic_reloc, /* special_function */
1650 "R_ARM_RPC24", /* name */
1651 FALSE, /* partial_inplace */
1652 0, /* src_mask */
1653 0, /* dst_mask */
1654 FALSE), /* pcrel_offset */
1655
1656 HOWTO (R_ARM_RBASE, /* type */
1657 0, /* rightshift */
1658 0, /* size (0 = byte, 1 = short, 2 = long) */
1659 0, /* bitsize */
1660 FALSE, /* pc_relative */
1661 0, /* bitpos */
1662 complain_overflow_dont,/* complain_on_overflow */
1663 bfd_elf_generic_reloc, /* special_function */
1664 "R_ARM_RBASE", /* name */
1665 FALSE, /* partial_inplace */
1666 0, /* src_mask */
1667 0, /* dst_mask */
1668 FALSE) /* pcrel_offset */
1669 };
1670
1671 static reloc_howto_type *
1672 elf32_arm_howto_from_type (unsigned int r_type)
1673 {
1674 if (r_type < ARRAY_SIZE (elf32_arm_howto_table_1))
1675 return &elf32_arm_howto_table_1[r_type];
1676
1677 if (r_type >= R_ARM_RREL32
1678 && r_type < R_ARM_RREL32 + ARRAY_SIZE (elf32_arm_howto_table_2))
1679 return &elf32_arm_howto_table_2[r_type - R_ARM_RREL32];
1680
1681 return NULL;
1682 }
1683
1684 static void
1685 elf32_arm_info_to_howto (bfd * abfd ATTRIBUTE_UNUSED, arelent * bfd_reloc,
1686 Elf_Internal_Rela * elf_reloc)
1687 {
1688 unsigned int r_type;
1689
1690 r_type = ELF32_R_TYPE (elf_reloc->r_info);
1691 bfd_reloc->howto = elf32_arm_howto_from_type (r_type);
1692 }
1693
1694 struct elf32_arm_reloc_map
1695 {
1696 bfd_reloc_code_real_type bfd_reloc_val;
1697 unsigned char elf_reloc_val;
1698 };
1699
1700 /* All entries in this list must also be present in elf32_arm_howto_table. */
1701 static const struct elf32_arm_reloc_map elf32_arm_reloc_map[] =
1702 {
1703 {BFD_RELOC_NONE, R_ARM_NONE},
1704 {BFD_RELOC_ARM_PCREL_BRANCH, R_ARM_PC24},
1705 {BFD_RELOC_ARM_PCREL_CALL, R_ARM_CALL},
1706 {BFD_RELOC_ARM_PCREL_JUMP, R_ARM_JUMP24},
1707 {BFD_RELOC_ARM_PCREL_BLX, R_ARM_XPC25},
1708 {BFD_RELOC_THUMB_PCREL_BLX, R_ARM_THM_XPC22},
1709 {BFD_RELOC_32, R_ARM_ABS32},
1710 {BFD_RELOC_32_PCREL, R_ARM_REL32},
1711 {BFD_RELOC_8, R_ARM_ABS8},
1712 {BFD_RELOC_16, R_ARM_ABS16},
1713 {BFD_RELOC_ARM_OFFSET_IMM, R_ARM_ABS12},
1714 {BFD_RELOC_ARM_THUMB_OFFSET, R_ARM_THM_ABS5},
1715 {BFD_RELOC_THUMB_PCREL_BRANCH25, R_ARM_THM_JUMP24},
1716 {BFD_RELOC_THUMB_PCREL_BRANCH23, R_ARM_THM_CALL},
1717 {BFD_RELOC_THUMB_PCREL_BRANCH12, R_ARM_THM_JUMP11},
1718 {BFD_RELOC_THUMB_PCREL_BRANCH20, R_ARM_THM_JUMP19},
1719 {BFD_RELOC_THUMB_PCREL_BRANCH9, R_ARM_THM_JUMP8},
1720 {BFD_RELOC_THUMB_PCREL_BRANCH7, R_ARM_THM_JUMP6},
1721 {BFD_RELOC_ARM_GLOB_DAT, R_ARM_GLOB_DAT},
1722 {BFD_RELOC_ARM_JUMP_SLOT, R_ARM_JUMP_SLOT},
1723 {BFD_RELOC_ARM_RELATIVE, R_ARM_RELATIVE},
1724 {BFD_RELOC_ARM_GOTOFF, R_ARM_GOTOFF32},
1725 {BFD_RELOC_ARM_GOTPC, R_ARM_GOTPC},
1726 {BFD_RELOC_ARM_GOT32, R_ARM_GOT32},
1727 {BFD_RELOC_ARM_PLT32, R_ARM_PLT32},
1728 {BFD_RELOC_ARM_TARGET1, R_ARM_TARGET1},
1729 {BFD_RELOC_ARM_ROSEGREL32, R_ARM_ROSEGREL32},
1730 {BFD_RELOC_ARM_SBREL32, R_ARM_SBREL32},
1731 {BFD_RELOC_ARM_PREL31, R_ARM_PREL31},
1732 {BFD_RELOC_ARM_TARGET2, R_ARM_TARGET2},
1733 {BFD_RELOC_ARM_PLT32, R_ARM_PLT32},
1734 {BFD_RELOC_ARM_TLS_GD32, R_ARM_TLS_GD32},
1735 {BFD_RELOC_ARM_TLS_LDO32, R_ARM_TLS_LDO32},
1736 {BFD_RELOC_ARM_TLS_LDM32, R_ARM_TLS_LDM32},
1737 {BFD_RELOC_ARM_TLS_DTPMOD32, R_ARM_TLS_DTPMOD32},
1738 {BFD_RELOC_ARM_TLS_DTPOFF32, R_ARM_TLS_DTPOFF32},
1739 {BFD_RELOC_ARM_TLS_TPOFF32, R_ARM_TLS_TPOFF32},
1740 {BFD_RELOC_ARM_TLS_IE32, R_ARM_TLS_IE32},
1741 {BFD_RELOC_ARM_TLS_LE32, R_ARM_TLS_LE32},
1742 {BFD_RELOC_VTABLE_INHERIT, R_ARM_GNU_VTINHERIT},
1743 {BFD_RELOC_VTABLE_ENTRY, R_ARM_GNU_VTENTRY},
1744 {BFD_RELOC_ARM_MOVW, R_ARM_MOVW_ABS_NC},
1745 {BFD_RELOC_ARM_MOVT, R_ARM_MOVT_ABS},
1746 {BFD_RELOC_ARM_MOVW_PCREL, R_ARM_MOVW_PREL_NC},
1747 {BFD_RELOC_ARM_MOVT_PCREL, R_ARM_MOVT_PREL},
1748 {BFD_RELOC_ARM_THUMB_MOVW, R_ARM_THM_MOVW_ABS_NC},
1749 {BFD_RELOC_ARM_THUMB_MOVT, R_ARM_THM_MOVT_ABS},
1750 {BFD_RELOC_ARM_THUMB_MOVW_PCREL, R_ARM_THM_MOVW_PREL_NC},
1751 {BFD_RELOC_ARM_THUMB_MOVT_PCREL, R_ARM_THM_MOVT_PREL},
1752 {BFD_RELOC_ARM_ALU_PC_G0_NC, R_ARM_ALU_PC_G0_NC},
1753 {BFD_RELOC_ARM_ALU_PC_G0, R_ARM_ALU_PC_G0},
1754 {BFD_RELOC_ARM_ALU_PC_G1_NC, R_ARM_ALU_PC_G1_NC},
1755 {BFD_RELOC_ARM_ALU_PC_G1, R_ARM_ALU_PC_G1},
1756 {BFD_RELOC_ARM_ALU_PC_G2, R_ARM_ALU_PC_G2},
1757 {BFD_RELOC_ARM_LDR_PC_G0, R_ARM_LDR_PC_G0},
1758 {BFD_RELOC_ARM_LDR_PC_G1, R_ARM_LDR_PC_G1},
1759 {BFD_RELOC_ARM_LDR_PC_G2, R_ARM_LDR_PC_G2},
1760 {BFD_RELOC_ARM_LDRS_PC_G0, R_ARM_LDRS_PC_G0},
1761 {BFD_RELOC_ARM_LDRS_PC_G1, R_ARM_LDRS_PC_G1},
1762 {BFD_RELOC_ARM_LDRS_PC_G2, R_ARM_LDRS_PC_G2},
1763 {BFD_RELOC_ARM_LDC_PC_G0, R_ARM_LDC_PC_G0},
1764 {BFD_RELOC_ARM_LDC_PC_G1, R_ARM_LDC_PC_G1},
1765 {BFD_RELOC_ARM_LDC_PC_G2, R_ARM_LDC_PC_G2},
1766 {BFD_RELOC_ARM_ALU_SB_G0_NC, R_ARM_ALU_SB_G0_NC},
1767 {BFD_RELOC_ARM_ALU_SB_G0, R_ARM_ALU_SB_G0},
1768 {BFD_RELOC_ARM_ALU_SB_G1_NC, R_ARM_ALU_SB_G1_NC},
1769 {BFD_RELOC_ARM_ALU_SB_G1, R_ARM_ALU_SB_G1},
1770 {BFD_RELOC_ARM_ALU_SB_G2, R_ARM_ALU_SB_G2},
1771 {BFD_RELOC_ARM_LDR_SB_G0, R_ARM_LDR_SB_G0},
1772 {BFD_RELOC_ARM_LDR_SB_G1, R_ARM_LDR_SB_G1},
1773 {BFD_RELOC_ARM_LDR_SB_G2, R_ARM_LDR_SB_G2},
1774 {BFD_RELOC_ARM_LDRS_SB_G0, R_ARM_LDRS_SB_G0},
1775 {BFD_RELOC_ARM_LDRS_SB_G1, R_ARM_LDRS_SB_G1},
1776 {BFD_RELOC_ARM_LDRS_SB_G2, R_ARM_LDRS_SB_G2},
1777 {BFD_RELOC_ARM_LDC_SB_G0, R_ARM_LDC_SB_G0},
1778 {BFD_RELOC_ARM_LDC_SB_G1, R_ARM_LDC_SB_G1},
1779 {BFD_RELOC_ARM_LDC_SB_G2, R_ARM_LDC_SB_G2},
1780 {BFD_RELOC_ARM_V4BX, R_ARM_V4BX}
1781 };
1782
1783 static reloc_howto_type *
1784 elf32_arm_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1785 bfd_reloc_code_real_type code)
1786 {
1787 unsigned int i;
1788
1789 for (i = 0; i < ARRAY_SIZE (elf32_arm_reloc_map); i ++)
1790 if (elf32_arm_reloc_map[i].bfd_reloc_val == code)
1791 return elf32_arm_howto_from_type (elf32_arm_reloc_map[i].elf_reloc_val);
1792
1793 return NULL;
1794 }
1795
1796 static reloc_howto_type *
1797 elf32_arm_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1798 const char *r_name)
1799 {
1800 unsigned int i;
1801
1802 for (i = 0; i < ARRAY_SIZE (elf32_arm_howto_table_1); i++)
1803 if (elf32_arm_howto_table_1[i].name != NULL
1804 && strcasecmp (elf32_arm_howto_table_1[i].name, r_name) == 0)
1805 return &elf32_arm_howto_table_1[i];
1806
1807 for (i = 0; i < ARRAY_SIZE (elf32_arm_howto_table_2); i++)
1808 if (elf32_arm_howto_table_2[i].name != NULL
1809 && strcasecmp (elf32_arm_howto_table_2[i].name, r_name) == 0)
1810 return &elf32_arm_howto_table_2[i];
1811
1812 return NULL;
1813 }
1814
1815 /* Support for core dump NOTE sections. */
1816
1817 static bfd_boolean
1818 elf32_arm_nabi_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
1819 {
1820 int offset;
1821 size_t size;
1822
1823 switch (note->descsz)
1824 {
1825 default:
1826 return FALSE;
1827
1828 case 148: /* Linux/ARM 32-bit. */
1829 /* pr_cursig */
1830 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
1831
1832 /* pr_pid */
1833 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
1834
1835 /* pr_reg */
1836 offset = 72;
1837 size = 72;
1838
1839 break;
1840 }
1841
1842 /* Make a ".reg/999" section. */
1843 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
1844 size, note->descpos + offset);
1845 }
1846
1847 static bfd_boolean
1848 elf32_arm_nabi_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
1849 {
1850 switch (note->descsz)
1851 {
1852 default:
1853 return FALSE;
1854
1855 case 124: /* Linux/ARM elf_prpsinfo. */
1856 elf_tdata (abfd)->core_program
1857 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
1858 elf_tdata (abfd)->core_command
1859 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
1860 }
1861
1862 /* Note that for some reason, a spurious space is tacked
1863 onto the end of the args in some (at least one anyway)
1864 implementations, so strip it off if it exists. */
1865 {
1866 char *command = elf_tdata (abfd)->core_command;
1867 int n = strlen (command);
1868
1869 if (0 < n && command[n - 1] == ' ')
1870 command[n - 1] = '\0';
1871 }
1872
1873 return TRUE;
1874 }
1875
1876 #define TARGET_LITTLE_SYM bfd_elf32_littlearm_vec
1877 #define TARGET_LITTLE_NAME "elf32-littlearm"
1878 #define TARGET_BIG_SYM bfd_elf32_bigarm_vec
1879 #define TARGET_BIG_NAME "elf32-bigarm"
1880
1881 #define elf_backend_grok_prstatus elf32_arm_nabi_grok_prstatus
1882 #define elf_backend_grok_psinfo elf32_arm_nabi_grok_psinfo
1883
1884 typedef unsigned long int insn32;
1885 typedef unsigned short int insn16;
1886
1887 /* In lieu of proper flags, assume all EABIv4 or later objects are
1888 interworkable. */
1889 #define INTERWORK_FLAG(abfd) \
1890 (EF_ARM_EABI_VERSION (elf_elfheader (abfd)->e_flags) >= EF_ARM_EABI_VER4 \
1891 || (elf_elfheader (abfd)->e_flags & EF_ARM_INTERWORK) \
1892 || ((abfd)->flags & BFD_LINKER_CREATED))
1893
1894 /* The linker script knows the section names for placement.
1895 The entry_names are used to do simple name mangling on the stubs.
1896 Given a function name, and its type, the stub can be found. The
1897 name can be changed. The only requirement is the %s be present. */
1898 #define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
1899 #define THUMB2ARM_GLUE_ENTRY_NAME "__%s_from_thumb"
1900
1901 #define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
1902 #define ARM2THUMB_GLUE_ENTRY_NAME "__%s_from_arm"
1903
1904 #define VFP11_ERRATUM_VENEER_SECTION_NAME ".vfp11_veneer"
1905 #define VFP11_ERRATUM_VENEER_ENTRY_NAME "__vfp11_veneer_%x"
1906
1907 #define ARM_BX_GLUE_SECTION_NAME ".v4_bx"
1908 #define ARM_BX_GLUE_ENTRY_NAME "__bx_r%d"
1909
1910 #define STUB_ENTRY_NAME "__%s_veneer"
1911
1912 /* The name of the dynamic interpreter. This is put in the .interp
1913 section. */
1914 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
1915
1916 #ifdef FOUR_WORD_PLT
1917
1918 /* The first entry in a procedure linkage table looks like
1919 this. It is set up so that any shared library function that is
1920 called before the relocation has been set up calls the dynamic
1921 linker first. */
1922 static const bfd_vma elf32_arm_plt0_entry [] =
1923 {
1924 0xe52de004, /* str lr, [sp, #-4]! */
1925 0xe59fe010, /* ldr lr, [pc, #16] */
1926 0xe08fe00e, /* add lr, pc, lr */
1927 0xe5bef008, /* ldr pc, [lr, #8]! */
1928 };
1929
1930 /* Subsequent entries in a procedure linkage table look like
1931 this. */
1932 static const bfd_vma elf32_arm_plt_entry [] =
1933 {
1934 0xe28fc600, /* add ip, pc, #NN */
1935 0xe28cca00, /* add ip, ip, #NN */
1936 0xe5bcf000, /* ldr pc, [ip, #NN]! */
1937 0x00000000, /* unused */
1938 };
1939
1940 #else
1941
1942 /* The first entry in a procedure linkage table looks like
1943 this. It is set up so that any shared library function that is
1944 called before the relocation has been set up calls the dynamic
1945 linker first. */
1946 static const bfd_vma elf32_arm_plt0_entry [] =
1947 {
1948 0xe52de004, /* str lr, [sp, #-4]! */
1949 0xe59fe004, /* ldr lr, [pc, #4] */
1950 0xe08fe00e, /* add lr, pc, lr */
1951 0xe5bef008, /* ldr pc, [lr, #8]! */
1952 0x00000000, /* &GOT[0] - . */
1953 };
1954
1955 /* Subsequent entries in a procedure linkage table look like
1956 this. */
1957 static const bfd_vma elf32_arm_plt_entry [] =
1958 {
1959 0xe28fc600, /* add ip, pc, #0xNN00000 */
1960 0xe28cca00, /* add ip, ip, #0xNN000 */
1961 0xe5bcf000, /* ldr pc, [ip, #0xNNN]! */
1962 };
1963
1964 #endif
1965
1966 /* The format of the first entry in the procedure linkage table
1967 for a VxWorks executable. */
1968 static const bfd_vma elf32_arm_vxworks_exec_plt0_entry[] =
1969 {
1970 0xe52dc008, /* str ip,[sp,#-8]! */
1971 0xe59fc000, /* ldr ip,[pc] */
1972 0xe59cf008, /* ldr pc,[ip,#8] */
1973 0x00000000, /* .long _GLOBAL_OFFSET_TABLE_ */
1974 };
1975
1976 /* The format of subsequent entries in a VxWorks executable. */
1977 static const bfd_vma elf32_arm_vxworks_exec_plt_entry[] =
1978 {
1979 0xe59fc000, /* ldr ip,[pc] */
1980 0xe59cf000, /* ldr pc,[ip] */
1981 0x00000000, /* .long @got */
1982 0xe59fc000, /* ldr ip,[pc] */
1983 0xea000000, /* b _PLT */
1984 0x00000000, /* .long @pltindex*sizeof(Elf32_Rela) */
1985 };
1986
1987 /* The format of entries in a VxWorks shared library. */
1988 static const bfd_vma elf32_arm_vxworks_shared_plt_entry[] =
1989 {
1990 0xe59fc000, /* ldr ip,[pc] */
1991 0xe79cf009, /* ldr pc,[ip,r9] */
1992 0x00000000, /* .long @got */
1993 0xe59fc000, /* ldr ip,[pc] */
1994 0xe599f008, /* ldr pc,[r9,#8] */
1995 0x00000000, /* .long @pltindex*sizeof(Elf32_Rela) */
1996 };
1997
1998 /* An initial stub used if the PLT entry is referenced from Thumb code. */
1999 #define PLT_THUMB_STUB_SIZE 4
2000 static const bfd_vma elf32_arm_plt_thumb_stub [] =
2001 {
2002 0x4778, /* bx pc */
2003 0x46c0 /* nop */
2004 };
2005
2006 /* The entries in a PLT when using a DLL-based target with multiple
2007 address spaces. */
2008 static const bfd_vma elf32_arm_symbian_plt_entry [] =
2009 {
2010 0xe51ff004, /* ldr pc, [pc, #-4] */
2011 0x00000000, /* dcd R_ARM_GLOB_DAT(X) */
2012 };
2013
2014 #define ARM_MAX_FWD_BRANCH_OFFSET ((((1 << 23) - 1) << 2) + 8)
2015 #define ARM_MAX_BWD_BRANCH_OFFSET ((-((1 << 23) << 2)) + 8)
2016 #define THM_MAX_FWD_BRANCH_OFFSET ((1 << 22) -2 + 4)
2017 #define THM_MAX_BWD_BRANCH_OFFSET (-(1 << 22) + 4)
2018 #define THM2_MAX_FWD_BRANCH_OFFSET (((1 << 24) - 2) + 4)
2019 #define THM2_MAX_BWD_BRANCH_OFFSET (-(1 << 24) + 4)
2020
2021 enum stub_insn_type
2022 {
2023 THUMB16_TYPE = 1,
2024 THUMB32_TYPE,
2025 ARM_TYPE,
2026 DATA_TYPE
2027 };
2028
2029 #define THUMB16_INSN(X) {(X), THUMB16_TYPE, R_ARM_NONE, 0}
2030 /* A bit of a hack. A Thumb conditional branch, in which the proper condition
2031 is inserted in arm_build_one_stub(). */
2032 #define THUMB16_BCOND_INSN(X) {(X), THUMB16_TYPE, R_ARM_NONE, 1}
2033 #define THUMB32_INSN(X) {(X), THUMB32_TYPE, R_ARM_NONE, 0}
2034 #define THUMB32_B_INSN(X, Z) {(X), THUMB32_TYPE, R_ARM_THM_JUMP24, (Z)}
2035 #define ARM_INSN(X) {(X), ARM_TYPE, R_ARM_NONE, 0}
2036 #define ARM_REL_INSN(X, Z) {(X), ARM_TYPE, R_ARM_JUMP24, (Z)}
2037 #define DATA_WORD(X,Y,Z) {(X), DATA_TYPE, (Y), (Z)}
2038
2039 typedef struct
2040 {
2041 bfd_vma data;
2042 enum stub_insn_type type;
2043 unsigned int r_type;
2044 int reloc_addend;
2045 } insn_sequence;
2046
2047 /* Arm/Thumb -> Arm/Thumb long branch stub. On V5T and above, use blx
2048 to reach the stub if necessary. */
2049 static const insn_sequence elf32_arm_stub_long_branch_any_any[] =
2050 {
2051 ARM_INSN(0xe51ff004), /* ldr pc, [pc, #-4] */
2052 DATA_WORD(0, R_ARM_ABS32, 0), /* dcd R_ARM_ABS32(X) */
2053 };
2054
2055 /* V4T Arm -> Thumb long branch stub. Used on V4T where blx is not
2056 available. */
2057 static const insn_sequence elf32_arm_stub_long_branch_v4t_arm_thumb[] =
2058 {
2059 ARM_INSN(0xe59fc000), /* ldr ip, [pc, #0] */
2060 ARM_INSN(0xe12fff1c), /* bx ip */
2061 DATA_WORD(0, R_ARM_ABS32, 0), /* dcd R_ARM_ABS32(X) */
2062 };
2063
2064 /* Thumb -> Thumb long branch stub. Used on M-profile architectures. */
2065 static const insn_sequence elf32_arm_stub_long_branch_thumb_only[] =
2066 {
2067 THUMB16_INSN(0xb401), /* push {r0} */
2068 THUMB16_INSN(0x4802), /* ldr r0, [pc, #8] */
2069 THUMB16_INSN(0x4684), /* mov ip, r0 */
2070 THUMB16_INSN(0xbc01), /* pop {r0} */
2071 THUMB16_INSN(0x4760), /* bx ip */
2072 THUMB16_INSN(0xbf00), /* nop */
2073 DATA_WORD(0, R_ARM_ABS32, 0), /* dcd R_ARM_ABS32(X) */
2074 };
2075
2076 /* V4T Thumb -> Thumb long branch stub. Using the stack is not
2077 allowed. */
2078 static const insn_sequence elf32_arm_stub_long_branch_v4t_thumb_thumb[] =
2079 {
2080 THUMB16_INSN(0x4778), /* bx pc */
2081 THUMB16_INSN(0x46c0), /* nop */
2082 ARM_INSN(0xe59fc000), /* ldr ip, [pc, #0] */
2083 ARM_INSN(0xe12fff1c), /* bx ip */
2084 DATA_WORD(0, R_ARM_ABS32, 0), /* dcd R_ARM_ABS32(X) */
2085 };
2086
2087 /* V4T Thumb -> ARM long branch stub. Used on V4T where blx is not
2088 available. */
2089 static const insn_sequence elf32_arm_stub_long_branch_v4t_thumb_arm[] =
2090 {
2091 THUMB16_INSN(0x4778), /* bx pc */
2092 THUMB16_INSN(0x46c0), /* nop */
2093 ARM_INSN(0xe51ff004), /* ldr pc, [pc, #-4] */
2094 DATA_WORD(0, R_ARM_ABS32, 0), /* dcd R_ARM_ABS32(X) */
2095 };
2096
2097 /* V4T Thumb -> ARM short branch stub. Shorter variant of the above
2098 one, when the destination is close enough. */
2099 static const insn_sequence elf32_arm_stub_short_branch_v4t_thumb_arm[] =
2100 {
2101 THUMB16_INSN(0x4778), /* bx pc */
2102 THUMB16_INSN(0x46c0), /* nop */
2103 ARM_REL_INSN(0xea000000, -8), /* b (X-8) */
2104 };
2105
2106 /* ARM/Thumb -> ARM long branch stub, PIC. On V5T and above, use
2107 blx to reach the stub if necessary. */
2108 static const insn_sequence elf32_arm_stub_long_branch_any_arm_pic[] =
2109 {
2110 ARM_INSN(0xe59fc000), /* ldr r12, [pc] */
2111 ARM_INSN(0xe08ff00c), /* add pc, pc, ip */
2112 DATA_WORD(0, R_ARM_REL32, -4), /* dcd R_ARM_REL32(X-4) */
2113 };
2114
2115 /* ARM/Thumb -> Thumb long branch stub, PIC. On V5T and above, use
2116 blx to reach the stub if necessary. We can not add into pc;
2117 it is not guaranteed to mode switch (different in ARMv6 and
2118 ARMv7). */
2119 static const insn_sequence elf32_arm_stub_long_branch_any_thumb_pic[] =
2120 {
2121 ARM_INSN(0xe59fc004), /* ldr r12, [pc, #4] */
2122 ARM_INSN(0xe08fc00c), /* add ip, pc, ip */
2123 ARM_INSN(0xe12fff1c), /* bx ip */
2124 DATA_WORD(0, R_ARM_REL32, 0), /* dcd R_ARM_REL32(X) */
2125 };
2126
2127 /* V4T ARM -> ARM long branch stub, PIC. */
2128 static const insn_sequence elf32_arm_stub_long_branch_v4t_arm_thumb_pic[] =
2129 {
2130 ARM_INSN(0xe59fc004), /* ldr ip, [pc, #4] */
2131 ARM_INSN(0xe08fc00c), /* add ip, pc, ip */
2132 ARM_INSN(0xe12fff1c), /* bx ip */
2133 DATA_WORD(0, R_ARM_REL32, 0), /* dcd R_ARM_REL32(X) */
2134 };
2135
2136 /* V4T Thumb -> ARM long branch stub, PIC. */
2137 static const insn_sequence elf32_arm_stub_long_branch_v4t_thumb_arm_pic[] =
2138 {
2139 THUMB16_INSN(0x4778), /* bx pc */
2140 THUMB16_INSN(0x46c0), /* nop */
2141 ARM_INSN(0xe59fc000), /* ldr ip, [pc, #0] */
2142 ARM_INSN(0xe08cf00f), /* add pc, ip, pc */
2143 DATA_WORD(0, R_ARM_REL32, -4), /* dcd R_ARM_REL32(X) */
2144 };
2145
2146 /* Thumb -> Thumb long branch stub, PIC. Used on M-profile
2147 architectures. */
2148 static const insn_sequence elf32_arm_stub_long_branch_thumb_only_pic[] =
2149 {
2150 THUMB16_INSN(0xb401), /* push {r0} */
2151 THUMB16_INSN(0x4802), /* ldr r0, [pc, #8] */
2152 THUMB16_INSN(0x46fc), /* mov ip, pc */
2153 THUMB16_INSN(0x4484), /* add ip, r0 */
2154 THUMB16_INSN(0xbc01), /* pop {r0} */
2155 THUMB16_INSN(0x4760), /* bx ip */
2156 DATA_WORD(0, R_ARM_REL32, 4), /* dcd R_ARM_REL32(X) */
2157 };
2158
2159 /* V4T Thumb -> Thumb long branch stub, PIC. Using the stack is not
2160 allowed. */
2161 static const insn_sequence elf32_arm_stub_long_branch_v4t_thumb_thumb_pic[] =
2162 {
2163 THUMB16_INSN(0x4778), /* bx pc */
2164 THUMB16_INSN(0x46c0), /* nop */
2165 ARM_INSN(0xe59fc004), /* ldr ip, [pc, #4] */
2166 ARM_INSN(0xe08fc00c), /* add ip, pc, ip */
2167 ARM_INSN(0xe12fff1c), /* bx ip */
2168 DATA_WORD(0, R_ARM_REL32, 0), /* dcd R_ARM_REL32(X) */
2169 };
2170
2171 /* Cortex-A8 erratum-workaround stubs. */
2172
2173 /* Stub used for conditional branches (which may be beyond +/-1MB away, so we
2174 can't use a conditional branch to reach this stub). */
2175
2176 static const insn_sequence elf32_arm_stub_a8_veneer_b_cond[] =
2177 {
2178 THUMB16_BCOND_INSN(0xd001), /* b<cond>.n true. */
2179 THUMB32_B_INSN(0xf000b800, -4), /* b.w insn_after_original_branch. */
2180 THUMB32_B_INSN(0xf000b800, -4) /* true: b.w original_branch_dest. */
2181 };
2182
2183 /* Stub used for b.w and bl.w instructions. */
2184
2185 static const insn_sequence elf32_arm_stub_a8_veneer_b[] =
2186 {
2187 THUMB32_B_INSN(0xf000b800, -4) /* b.w original_branch_dest. */
2188 };
2189
2190 static const insn_sequence elf32_arm_stub_a8_veneer_bl[] =
2191 {
2192 THUMB32_B_INSN(0xf000b800, -4) /* b.w original_branch_dest. */
2193 };
2194
2195 /* Stub used for Thumb-2 blx.w instructions. We modified the original blx.w
2196 instruction (which switches to ARM mode) to point to this stub. Jump to the
2197 real destination using an ARM-mode branch. */
2198
2199 static const insn_sequence elf32_arm_stub_a8_veneer_blx[] =
2200 {
2201 ARM_REL_INSN(0xea000000, -8) /* b original_branch_dest. */
2202 };
2203
2204 /* Section name for stubs is the associated section name plus this
2205 string. */
2206 #define STUB_SUFFIX ".stub"
2207
2208 /* One entry per long/short branch stub defined above. */
2209 #define DEF_STUBS \
2210 DEF_STUB(long_branch_any_any) \
2211 DEF_STUB(long_branch_v4t_arm_thumb) \
2212 DEF_STUB(long_branch_thumb_only) \
2213 DEF_STUB(long_branch_v4t_thumb_thumb) \
2214 DEF_STUB(long_branch_v4t_thumb_arm) \
2215 DEF_STUB(short_branch_v4t_thumb_arm) \
2216 DEF_STUB(long_branch_any_arm_pic) \
2217 DEF_STUB(long_branch_any_thumb_pic) \
2218 DEF_STUB(long_branch_v4t_thumb_thumb_pic) \
2219 DEF_STUB(long_branch_v4t_arm_thumb_pic) \
2220 DEF_STUB(long_branch_v4t_thumb_arm_pic) \
2221 DEF_STUB(long_branch_thumb_only_pic) \
2222 DEF_STUB(a8_veneer_b_cond) \
2223 DEF_STUB(a8_veneer_b) \
2224 DEF_STUB(a8_veneer_bl) \
2225 DEF_STUB(a8_veneer_blx)
2226
2227 #define DEF_STUB(x) arm_stub_##x,
2228 enum elf32_arm_stub_type {
2229 arm_stub_none,
2230 DEF_STUBS
2231 /* Note the first a8_veneer type */
2232 arm_stub_a8_veneer_lwm = arm_stub_a8_veneer_b_cond
2233 };
2234 #undef DEF_STUB
2235
2236 typedef struct
2237 {
2238 const insn_sequence* template;
2239 int template_size;
2240 } stub_def;
2241
2242 #define DEF_STUB(x) {elf32_arm_stub_##x, ARRAY_SIZE(elf32_arm_stub_##x)},
2243 static const stub_def stub_definitions[] = {
2244 {NULL, 0},
2245 DEF_STUBS
2246 };
2247
2248 struct elf32_arm_stub_hash_entry
2249 {
2250 /* Base hash table entry structure. */
2251 struct bfd_hash_entry root;
2252
2253 /* The stub section. */
2254 asection *stub_sec;
2255
2256 /* Offset within stub_sec of the beginning of this stub. */
2257 bfd_vma stub_offset;
2258
2259 /* Given the symbol's value and its section we can determine its final
2260 value when building the stubs (so the stub knows where to jump). */
2261 bfd_vma target_value;
2262 asection *target_section;
2263
2264 /* Offset to apply to relocation referencing target_value. */
2265 bfd_vma target_addend;
2266
2267 /* The instruction which caused this stub to be generated (only valid for
2268 Cortex-A8 erratum workaround stubs at present). */
2269 unsigned long orig_insn;
2270
2271 /* The stub type. */
2272 enum elf32_arm_stub_type stub_type;
2273 /* Its encoding size in bytes. */
2274 int stub_size;
2275 /* Its template. */
2276 const insn_sequence *stub_template;
2277 /* The size of the template (number of entries). */
2278 int stub_template_size;
2279
2280 /* The symbol table entry, if any, that this was derived from. */
2281 struct elf32_arm_link_hash_entry *h;
2282
2283 /* Destination symbol type (STT_ARM_TFUNC, ...) */
2284 unsigned char st_type;
2285
2286 /* Where this stub is being called from, or, in the case of combined
2287 stub sections, the first input section in the group. */
2288 asection *id_sec;
2289
2290 /* The name for the local symbol at the start of this stub. The
2291 stub name in the hash table has to be unique; this does not, so
2292 it can be friendlier. */
2293 char *output_name;
2294 };
2295
2296 /* Used to build a map of a section. This is required for mixed-endian
2297 code/data. */
2298
2299 typedef struct elf32_elf_section_map
2300 {
2301 bfd_vma vma;
2302 char type;
2303 }
2304 elf32_arm_section_map;
2305
2306 /* Information about a VFP11 erratum veneer, or a branch to such a veneer. */
2307
2308 typedef enum
2309 {
2310 VFP11_ERRATUM_BRANCH_TO_ARM_VENEER,
2311 VFP11_ERRATUM_BRANCH_TO_THUMB_VENEER,
2312 VFP11_ERRATUM_ARM_VENEER,
2313 VFP11_ERRATUM_THUMB_VENEER
2314 }
2315 elf32_vfp11_erratum_type;
2316
2317 typedef struct elf32_vfp11_erratum_list
2318 {
2319 struct elf32_vfp11_erratum_list *next;
2320 bfd_vma vma;
2321 union
2322 {
2323 struct
2324 {
2325 struct elf32_vfp11_erratum_list *veneer;
2326 unsigned int vfp_insn;
2327 } b;
2328 struct
2329 {
2330 struct elf32_vfp11_erratum_list *branch;
2331 unsigned int id;
2332 } v;
2333 } u;
2334 elf32_vfp11_erratum_type type;
2335 }
2336 elf32_vfp11_erratum_list;
2337
2338 typedef enum
2339 {
2340 DELETE_EXIDX_ENTRY,
2341 INSERT_EXIDX_CANTUNWIND_AT_END
2342 }
2343 arm_unwind_edit_type;
2344
2345 /* A (sorted) list of edits to apply to an unwind table. */
2346 typedef struct arm_unwind_table_edit
2347 {
2348 arm_unwind_edit_type type;
2349 /* Note: we sometimes want to insert an unwind entry corresponding to a
2350 section different from the one we're currently writing out, so record the
2351 (text) section this edit relates to here. */
2352 asection *linked_section;
2353 unsigned int index;
2354 struct arm_unwind_table_edit *next;
2355 }
2356 arm_unwind_table_edit;
2357
2358 typedef struct _arm_elf_section_data
2359 {
2360 /* Information about mapping symbols. */
2361 struct bfd_elf_section_data elf;
2362 unsigned int mapcount;
2363 unsigned int mapsize;
2364 elf32_arm_section_map *map;
2365 /* Information about CPU errata. */
2366 unsigned int erratumcount;
2367 elf32_vfp11_erratum_list *erratumlist;
2368 /* Information about unwind tables. */
2369 union
2370 {
2371 /* Unwind info attached to a text section. */
2372 struct
2373 {
2374 asection *arm_exidx_sec;
2375 } text;
2376
2377 /* Unwind info attached to an .ARM.exidx section. */
2378 struct
2379 {
2380 arm_unwind_table_edit *unwind_edit_list;
2381 arm_unwind_table_edit *unwind_edit_tail;
2382 } exidx;
2383 } u;
2384 }
2385 _arm_elf_section_data;
2386
2387 #define elf32_arm_section_data(sec) \
2388 ((_arm_elf_section_data *) elf_section_data (sec))
2389
2390 /* A fix which might be required for Cortex-A8 Thumb-2 branch/TLB erratum.
2391 These fixes are subject to a relaxation procedure (in elf32_arm_size_stubs),
2392 so may be created multiple times: we use an array of these entries whilst
2393 relaxing which we can refresh easily, then create stubs for each potentially
2394 erratum-triggering instruction once we've settled on a solution. */
2395
2396 struct a8_erratum_fix {
2397 bfd *input_bfd;
2398 asection *section;
2399 bfd_vma offset;
2400 bfd_vma addend;
2401 unsigned long orig_insn;
2402 char *stub_name;
2403 enum elf32_arm_stub_type stub_type;
2404 };
2405
2406 /* A table of relocs applied to branches which might trigger Cortex-A8
2407 erratum. */
2408
2409 struct a8_erratum_reloc {
2410 bfd_vma from;
2411 bfd_vma destination;
2412 unsigned int r_type;
2413 unsigned char st_type;
2414 const char *sym_name;
2415 bfd_boolean non_a8_stub;
2416 };
2417
2418 /* The size of the thread control block. */
2419 #define TCB_SIZE 8
2420
2421 struct elf_arm_obj_tdata
2422 {
2423 struct elf_obj_tdata root;
2424
2425 /* tls_type for each local got entry. */
2426 char *local_got_tls_type;
2427
2428 /* Zero to warn when linking objects with incompatible enum sizes. */
2429 int no_enum_size_warning;
2430
2431 /* Zero to warn when linking objects with incompatible wchar_t sizes. */
2432 int no_wchar_size_warning;
2433 };
2434
2435 #define elf_arm_tdata(bfd) \
2436 ((struct elf_arm_obj_tdata *) (bfd)->tdata.any)
2437
2438 #define elf32_arm_local_got_tls_type(bfd) \
2439 (elf_arm_tdata (bfd)->local_got_tls_type)
2440
2441 #define is_arm_elf(bfd) \
2442 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2443 && elf_tdata (bfd) != NULL \
2444 && elf_object_id (bfd) == ARM_ELF_TDATA)
2445
2446 static bfd_boolean
2447 elf32_arm_mkobject (bfd *abfd)
2448 {
2449 return bfd_elf_allocate_object (abfd, sizeof (struct elf_arm_obj_tdata),
2450 ARM_ELF_TDATA);
2451 }
2452
2453 /* The ARM linker needs to keep track of the number of relocs that it
2454 decides to copy in check_relocs for each symbol. This is so that
2455 it can discard PC relative relocs if it doesn't need them when
2456 linking with -Bsymbolic. We store the information in a field
2457 extending the regular ELF linker hash table. */
2458
2459 /* This structure keeps track of the number of relocs we have copied
2460 for a given symbol. */
2461 struct elf32_arm_relocs_copied
2462 {
2463 /* Next section. */
2464 struct elf32_arm_relocs_copied * next;
2465 /* A section in dynobj. */
2466 asection * section;
2467 /* Number of relocs copied in this section. */
2468 bfd_size_type count;
2469 /* Number of PC-relative relocs copied in this section. */
2470 bfd_size_type pc_count;
2471 };
2472
2473 #define elf32_arm_hash_entry(ent) ((struct elf32_arm_link_hash_entry *)(ent))
2474
2475 /* Arm ELF linker hash entry. */
2476 struct elf32_arm_link_hash_entry
2477 {
2478 struct elf_link_hash_entry root;
2479
2480 /* Number of PC relative relocs copied for this symbol. */
2481 struct elf32_arm_relocs_copied * relocs_copied;
2482
2483 /* We reference count Thumb references to a PLT entry separately,
2484 so that we can emit the Thumb trampoline only if needed. */
2485 bfd_signed_vma plt_thumb_refcount;
2486
2487 /* Some references from Thumb code may be eliminated by BL->BLX
2488 conversion, so record them separately. */
2489 bfd_signed_vma plt_maybe_thumb_refcount;
2490
2491 /* Since PLT entries have variable size if the Thumb prologue is
2492 used, we need to record the index into .got.plt instead of
2493 recomputing it from the PLT offset. */
2494 bfd_signed_vma plt_got_offset;
2495
2496 #define GOT_UNKNOWN 0
2497 #define GOT_NORMAL 1
2498 #define GOT_TLS_GD 2
2499 #define GOT_TLS_IE 4
2500 unsigned char tls_type;
2501
2502 /* The symbol marking the real symbol location for exported thumb
2503 symbols with Arm stubs. */
2504 struct elf_link_hash_entry *export_glue;
2505
2506 /* A pointer to the most recently used stub hash entry against this
2507 symbol. */
2508 struct elf32_arm_stub_hash_entry *stub_cache;
2509 };
2510
2511 /* Traverse an arm ELF linker hash table. */
2512 #define elf32_arm_link_hash_traverse(table, func, info) \
2513 (elf_link_hash_traverse \
2514 (&(table)->root, \
2515 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
2516 (info)))
2517
2518 /* Get the ARM elf linker hash table from a link_info structure. */
2519 #define elf32_arm_hash_table(info) \
2520 ((struct elf32_arm_link_hash_table *) ((info)->hash))
2521
2522 #define arm_stub_hash_lookup(table, string, create, copy) \
2523 ((struct elf32_arm_stub_hash_entry *) \
2524 bfd_hash_lookup ((table), (string), (create), (copy)))
2525
2526 /* ARM ELF linker hash table. */
2527 struct elf32_arm_link_hash_table
2528 {
2529 /* The main hash table. */
2530 struct elf_link_hash_table root;
2531
2532 /* The size in bytes of the section containing the Thumb-to-ARM glue. */
2533 bfd_size_type thumb_glue_size;
2534
2535 /* The size in bytes of the section containing the ARM-to-Thumb glue. */
2536 bfd_size_type arm_glue_size;
2537
2538 /* The size in bytes of section containing the ARMv4 BX veneers. */
2539 bfd_size_type bx_glue_size;
2540
2541 /* Offsets of ARMv4 BX veneers. Bit1 set if present, and Bit0 set when
2542 veneer has been populated. */
2543 bfd_vma bx_glue_offset[15];
2544
2545 /* The size in bytes of the section containing glue for VFP11 erratum
2546 veneers. */
2547 bfd_size_type vfp11_erratum_glue_size;
2548
2549 /* A table of fix locations for Cortex-A8 Thumb-2 branch/TLB erratum. This
2550 holds Cortex-A8 erratum fix locations between elf32_arm_size_stubs() and
2551 elf32_arm_write_section(). */
2552 struct a8_erratum_fix *a8_erratum_fixes;
2553 unsigned int num_a8_erratum_fixes;
2554
2555 /* An arbitrary input BFD chosen to hold the glue sections. */
2556 bfd * bfd_of_glue_owner;
2557
2558 /* Nonzero to output a BE8 image. */
2559 int byteswap_code;
2560
2561 /* Zero if R_ARM_TARGET1 means R_ARM_ABS32.
2562 Nonzero if R_ARM_TARGET1 means R_ARM_REL32. */
2563 int target1_is_rel;
2564
2565 /* The relocation to use for R_ARM_TARGET2 relocations. */
2566 int target2_reloc;
2567
2568 /* 0 = Ignore R_ARM_V4BX.
2569 1 = Convert BX to MOV PC.
2570 2 = Generate v4 interworing stubs. */
2571 int fix_v4bx;
2572
2573 /* Whether we should fix the Cortex-A8 Thumb-2 branch/TLB erratum. */
2574 int fix_cortex_a8;
2575
2576 /* Nonzero if the ARM/Thumb BLX instructions are available for use. */
2577 int use_blx;
2578
2579 /* What sort of code sequences we should look for which may trigger the
2580 VFP11 denorm erratum. */
2581 bfd_arm_vfp11_fix vfp11_fix;
2582
2583 /* Global counter for the number of fixes we have emitted. */
2584 int num_vfp11_fixes;
2585
2586 /* Nonzero to force PIC branch veneers. */
2587 int pic_veneer;
2588
2589 /* The number of bytes in the initial entry in the PLT. */
2590 bfd_size_type plt_header_size;
2591
2592 /* The number of bytes in the subsequent PLT etries. */
2593 bfd_size_type plt_entry_size;
2594
2595 /* True if the target system is VxWorks. */
2596 int vxworks_p;
2597
2598 /* True if the target system is Symbian OS. */
2599 int symbian_p;
2600
2601 /* True if the target uses REL relocations. */
2602 int use_rel;
2603
2604 /* Short-cuts to get to dynamic linker sections. */
2605 asection *sgot;
2606 asection *sgotplt;
2607 asection *srelgot;
2608 asection *splt;
2609 asection *srelplt;
2610 asection *sdynbss;
2611 asection *srelbss;
2612
2613 /* The (unloaded but important) VxWorks .rela.plt.unloaded section. */
2614 asection *srelplt2;
2615
2616 /* Data for R_ARM_TLS_LDM32 relocations. */
2617 union
2618 {
2619 bfd_signed_vma refcount;
2620 bfd_vma offset;
2621 } tls_ldm_got;
2622
2623 /* Small local sym cache. */
2624 struct sym_cache sym_cache;
2625
2626 /* For convenience in allocate_dynrelocs. */
2627 bfd * obfd;
2628
2629 /* The stub hash table. */
2630 struct bfd_hash_table stub_hash_table;
2631
2632 /* Linker stub bfd. */
2633 bfd *stub_bfd;
2634
2635 /* Linker call-backs. */
2636 asection * (*add_stub_section) (const char *, asection *);
2637 void (*layout_sections_again) (void);
2638
2639 /* Array to keep track of which stub sections have been created, and
2640 information on stub grouping. */
2641 struct map_stub
2642 {
2643 /* This is the section to which stubs in the group will be
2644 attached. */
2645 asection *link_sec;
2646 /* The stub section. */
2647 asection *stub_sec;
2648 } *stub_group;
2649
2650 /* Assorted information used by elf32_arm_size_stubs. */
2651 unsigned int bfd_count;
2652 int top_index;
2653 asection **input_list;
2654 };
2655
2656 /* Create an entry in an ARM ELF linker hash table. */
2657
2658 static struct bfd_hash_entry *
2659 elf32_arm_link_hash_newfunc (struct bfd_hash_entry * entry,
2660 struct bfd_hash_table * table,
2661 const char * string)
2662 {
2663 struct elf32_arm_link_hash_entry * ret =
2664 (struct elf32_arm_link_hash_entry *) entry;
2665
2666 /* Allocate the structure if it has not already been allocated by a
2667 subclass. */
2668 if (ret == NULL)
2669 ret = bfd_hash_allocate (table, sizeof (struct elf32_arm_link_hash_entry));
2670 if (ret == NULL)
2671 return (struct bfd_hash_entry *) ret;
2672
2673 /* Call the allocation method of the superclass. */
2674 ret = ((struct elf32_arm_link_hash_entry *)
2675 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
2676 table, string));
2677 if (ret != NULL)
2678 {
2679 ret->relocs_copied = NULL;
2680 ret->tls_type = GOT_UNKNOWN;
2681 ret->plt_thumb_refcount = 0;
2682 ret->plt_maybe_thumb_refcount = 0;
2683 ret->plt_got_offset = -1;
2684 ret->export_glue = NULL;
2685
2686 ret->stub_cache = NULL;
2687 }
2688
2689 return (struct bfd_hash_entry *) ret;
2690 }
2691
2692 /* Initialize an entry in the stub hash table. */
2693
2694 static struct bfd_hash_entry *
2695 stub_hash_newfunc (struct bfd_hash_entry *entry,
2696 struct bfd_hash_table *table,
2697 const char *string)
2698 {
2699 /* Allocate the structure if it has not already been allocated by a
2700 subclass. */
2701 if (entry == NULL)
2702 {
2703 entry = bfd_hash_allocate (table,
2704 sizeof (struct elf32_arm_stub_hash_entry));
2705 if (entry == NULL)
2706 return entry;
2707 }
2708
2709 /* Call the allocation method of the superclass. */
2710 entry = bfd_hash_newfunc (entry, table, string);
2711 if (entry != NULL)
2712 {
2713 struct elf32_arm_stub_hash_entry *eh;
2714
2715 /* Initialize the local fields. */
2716 eh = (struct elf32_arm_stub_hash_entry *) entry;
2717 eh->stub_sec = NULL;
2718 eh->stub_offset = 0;
2719 eh->target_value = 0;
2720 eh->target_section = NULL;
2721 eh->target_addend = 0;
2722 eh->orig_insn = 0;
2723 eh->stub_type = arm_stub_none;
2724 eh->stub_size = 0;
2725 eh->stub_template = NULL;
2726 eh->stub_template_size = 0;
2727 eh->h = NULL;
2728 eh->id_sec = NULL;
2729 eh->output_name = NULL;
2730 }
2731
2732 return entry;
2733 }
2734
2735 /* Create .got, .gotplt, and .rel(a).got sections in DYNOBJ, and set up
2736 shortcuts to them in our hash table. */
2737
2738 static bfd_boolean
2739 create_got_section (bfd *dynobj, struct bfd_link_info *info)
2740 {
2741 struct elf32_arm_link_hash_table *htab;
2742
2743 htab = elf32_arm_hash_table (info);
2744 /* BPABI objects never have a GOT, or associated sections. */
2745 if (htab->symbian_p)
2746 return TRUE;
2747
2748 if (! _bfd_elf_create_got_section (dynobj, info))
2749 return FALSE;
2750
2751 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
2752 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
2753 if (!htab->sgot || !htab->sgotplt)
2754 abort ();
2755
2756 htab->srelgot = bfd_get_section_by_name (dynobj,
2757 RELOC_SECTION (htab, ".got"));
2758 if (htab->srelgot == NULL)
2759 return FALSE;
2760 return TRUE;
2761 }
2762
2763 /* Create .plt, .rel(a).plt, .got, .got.plt, .rel(a).got, .dynbss, and
2764 .rel(a).bss sections in DYNOBJ, and set up shortcuts to them in our
2765 hash table. */
2766
2767 static bfd_boolean
2768 elf32_arm_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
2769 {
2770 struct elf32_arm_link_hash_table *htab;
2771
2772 htab = elf32_arm_hash_table (info);
2773 if (!htab->sgot && !create_got_section (dynobj, info))
2774 return FALSE;
2775
2776 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
2777 return FALSE;
2778
2779 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
2780 htab->srelplt = bfd_get_section_by_name (dynobj,
2781 RELOC_SECTION (htab, ".plt"));
2782 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
2783 if (!info->shared)
2784 htab->srelbss = bfd_get_section_by_name (dynobj,
2785 RELOC_SECTION (htab, ".bss"));
2786
2787 if (htab->vxworks_p)
2788 {
2789 if (!elf_vxworks_create_dynamic_sections (dynobj, info, &htab->srelplt2))
2790 return FALSE;
2791
2792 if (info->shared)
2793 {
2794 htab->plt_header_size = 0;
2795 htab->plt_entry_size
2796 = 4 * ARRAY_SIZE (elf32_arm_vxworks_shared_plt_entry);
2797 }
2798 else
2799 {
2800 htab->plt_header_size
2801 = 4 * ARRAY_SIZE (elf32_arm_vxworks_exec_plt0_entry);
2802 htab->plt_entry_size
2803 = 4 * ARRAY_SIZE (elf32_arm_vxworks_exec_plt_entry);
2804 }
2805 }
2806
2807 if (!htab->splt
2808 || !htab->srelplt
2809 || !htab->sdynbss
2810 || (!info->shared && !htab->srelbss))
2811 abort ();
2812
2813 return TRUE;
2814 }
2815
2816 /* Copy the extra info we tack onto an elf_link_hash_entry. */
2817
2818 static void
2819 elf32_arm_copy_indirect_symbol (struct bfd_link_info *info,
2820 struct elf_link_hash_entry *dir,
2821 struct elf_link_hash_entry *ind)
2822 {
2823 struct elf32_arm_link_hash_entry *edir, *eind;
2824
2825 edir = (struct elf32_arm_link_hash_entry *) dir;
2826 eind = (struct elf32_arm_link_hash_entry *) ind;
2827
2828 if (eind->relocs_copied != NULL)
2829 {
2830 if (edir->relocs_copied != NULL)
2831 {
2832 struct elf32_arm_relocs_copied **pp;
2833 struct elf32_arm_relocs_copied *p;
2834
2835 /* Add reloc counts against the indirect sym to the direct sym
2836 list. Merge any entries against the same section. */
2837 for (pp = &eind->relocs_copied; (p = *pp) != NULL; )
2838 {
2839 struct elf32_arm_relocs_copied *q;
2840
2841 for (q = edir->relocs_copied; q != NULL; q = q->next)
2842 if (q->section == p->section)
2843 {
2844 q->pc_count += p->pc_count;
2845 q->count += p->count;
2846 *pp = p->next;
2847 break;
2848 }
2849 if (q == NULL)
2850 pp = &p->next;
2851 }
2852 *pp = edir->relocs_copied;
2853 }
2854
2855 edir->relocs_copied = eind->relocs_copied;
2856 eind->relocs_copied = NULL;
2857 }
2858
2859 if (ind->root.type == bfd_link_hash_indirect)
2860 {
2861 /* Copy over PLT info. */
2862 edir->plt_thumb_refcount += eind->plt_thumb_refcount;
2863 eind->plt_thumb_refcount = 0;
2864 edir->plt_maybe_thumb_refcount += eind->plt_maybe_thumb_refcount;
2865 eind->plt_maybe_thumb_refcount = 0;
2866
2867 if (dir->got.refcount <= 0)
2868 {
2869 edir->tls_type = eind->tls_type;
2870 eind->tls_type = GOT_UNKNOWN;
2871 }
2872 }
2873
2874 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
2875 }
2876
2877 /* Create an ARM elf linker hash table. */
2878
2879 static struct bfd_link_hash_table *
2880 elf32_arm_link_hash_table_create (bfd *abfd)
2881 {
2882 struct elf32_arm_link_hash_table *ret;
2883 bfd_size_type amt = sizeof (struct elf32_arm_link_hash_table);
2884
2885 ret = bfd_malloc (amt);
2886 if (ret == NULL)
2887 return NULL;
2888
2889 if (!_bfd_elf_link_hash_table_init (& ret->root, abfd,
2890 elf32_arm_link_hash_newfunc,
2891 sizeof (struct elf32_arm_link_hash_entry)))
2892 {
2893 free (ret);
2894 return NULL;
2895 }
2896
2897 ret->sgot = NULL;
2898 ret->sgotplt = NULL;
2899 ret->srelgot = NULL;
2900 ret->splt = NULL;
2901 ret->srelplt = NULL;
2902 ret->sdynbss = NULL;
2903 ret->srelbss = NULL;
2904 ret->srelplt2 = NULL;
2905 ret->thumb_glue_size = 0;
2906 ret->arm_glue_size = 0;
2907 ret->bx_glue_size = 0;
2908 memset (ret->bx_glue_offset, 0, sizeof (ret->bx_glue_offset));
2909 ret->vfp11_fix = BFD_ARM_VFP11_FIX_NONE;
2910 ret->vfp11_erratum_glue_size = 0;
2911 ret->num_vfp11_fixes = 0;
2912 ret->fix_cortex_a8 = 0;
2913 ret->bfd_of_glue_owner = NULL;
2914 ret->byteswap_code = 0;
2915 ret->target1_is_rel = 0;
2916 ret->target2_reloc = R_ARM_NONE;
2917 #ifdef FOUR_WORD_PLT
2918 ret->plt_header_size = 16;
2919 ret->plt_entry_size = 16;
2920 #else
2921 ret->plt_header_size = 20;
2922 ret->plt_entry_size = 12;
2923 #endif
2924 ret->fix_v4bx = 0;
2925 ret->use_blx = 0;
2926 ret->vxworks_p = 0;
2927 ret->symbian_p = 0;
2928 ret->use_rel = 1;
2929 ret->sym_cache.abfd = NULL;
2930 ret->obfd = abfd;
2931 ret->tls_ldm_got.refcount = 0;
2932 ret->stub_bfd = NULL;
2933 ret->add_stub_section = NULL;
2934 ret->layout_sections_again = NULL;
2935 ret->stub_group = NULL;
2936 ret->bfd_count = 0;
2937 ret->top_index = 0;
2938 ret->input_list = NULL;
2939
2940 if (!bfd_hash_table_init (&ret->stub_hash_table, stub_hash_newfunc,
2941 sizeof (struct elf32_arm_stub_hash_entry)))
2942 {
2943 free (ret);
2944 return NULL;
2945 }
2946
2947 return &ret->root.root;
2948 }
2949
2950 /* Free the derived linker hash table. */
2951
2952 static void
2953 elf32_arm_hash_table_free (struct bfd_link_hash_table *hash)
2954 {
2955 struct elf32_arm_link_hash_table *ret
2956 = (struct elf32_arm_link_hash_table *) hash;
2957
2958 bfd_hash_table_free (&ret->stub_hash_table);
2959 _bfd_generic_link_hash_table_free (hash);
2960 }
2961
2962 /* Determine if we're dealing with a Thumb only architecture. */
2963
2964 static bfd_boolean
2965 using_thumb_only (struct elf32_arm_link_hash_table *globals)
2966 {
2967 int arch = bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC,
2968 Tag_CPU_arch);
2969 int profile;
2970
2971 if (arch != TAG_CPU_ARCH_V7)
2972 return FALSE;
2973
2974 profile = bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC,
2975 Tag_CPU_arch_profile);
2976
2977 return profile == 'M';
2978 }
2979
2980 /* Determine if we're dealing with a Thumb-2 object. */
2981
2982 static bfd_boolean
2983 using_thumb2 (struct elf32_arm_link_hash_table *globals)
2984 {
2985 int arch = bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC,
2986 Tag_CPU_arch);
2987 return arch == TAG_CPU_ARCH_V6T2 || arch >= TAG_CPU_ARCH_V7;
2988 }
2989
2990 static bfd_boolean
2991 arm_stub_is_thumb (enum elf32_arm_stub_type stub_type)
2992 {
2993 switch (stub_type)
2994 {
2995 case arm_stub_long_branch_thumb_only:
2996 case arm_stub_long_branch_v4t_thumb_arm:
2997 case arm_stub_short_branch_v4t_thumb_arm:
2998 case arm_stub_long_branch_v4t_thumb_arm_pic:
2999 case arm_stub_long_branch_thumb_only_pic:
3000 return TRUE;
3001 case arm_stub_none:
3002 BFD_FAIL ();
3003 return FALSE;
3004 break;
3005 default:
3006 return FALSE;
3007 }
3008 }
3009
3010 /* Determine the type of stub needed, if any, for a call. */
3011
3012 static enum elf32_arm_stub_type
3013 arm_type_of_stub (struct bfd_link_info *info,
3014 asection *input_sec,
3015 const Elf_Internal_Rela *rel,
3016 unsigned char st_type,
3017 struct elf32_arm_link_hash_entry *hash,
3018 bfd_vma destination,
3019 asection *sym_sec,
3020 bfd *input_bfd,
3021 const char *name)
3022 {
3023 bfd_vma location;
3024 bfd_signed_vma branch_offset;
3025 unsigned int r_type;
3026 struct elf32_arm_link_hash_table * globals;
3027 int thumb2;
3028 int thumb_only;
3029 enum elf32_arm_stub_type stub_type = arm_stub_none;
3030 int use_plt = 0;
3031
3032 /* We don't know the actual type of destination in case it is of
3033 type STT_SECTION: give up. */
3034 if (st_type == STT_SECTION)
3035 return stub_type;
3036
3037 globals = elf32_arm_hash_table (info);
3038
3039 thumb_only = using_thumb_only (globals);
3040
3041 thumb2 = using_thumb2 (globals);
3042
3043 /* Determine where the call point is. */
3044 location = (input_sec->output_offset
3045 + input_sec->output_section->vma
3046 + rel->r_offset);
3047
3048 branch_offset = (bfd_signed_vma)(destination - location);
3049
3050 r_type = ELF32_R_TYPE (rel->r_info);
3051
3052 /* Keep a simpler condition, for the sake of clarity. */
3053 if (globals->splt != NULL && hash != NULL && hash->root.plt.offset != (bfd_vma) -1)
3054 {
3055 use_plt = 1;
3056 /* Note when dealing with PLT entries: the main PLT stub is in
3057 ARM mode, so if the branch is in Thumb mode, another
3058 Thumb->ARM stub will be inserted later just before the ARM
3059 PLT stub. We don't take this extra distance into account
3060 here, because if a long branch stub is needed, we'll add a
3061 Thumb->Arm one and branch directly to the ARM PLT entry
3062 because it avoids spreading offset corrections in several
3063 places. */
3064 }
3065
3066 if (r_type == R_ARM_THM_CALL || r_type == R_ARM_THM_JUMP24)
3067 {
3068 /* Handle cases where:
3069 - this call goes too far (different Thumb/Thumb2 max
3070 distance)
3071 - it's a Thumb->Arm call and blx is not available, or it's a
3072 Thumb->Arm branch (not bl). A stub is needed in this case,
3073 but only if this call is not through a PLT entry. Indeed,
3074 PLT stubs handle mode switching already.
3075 */
3076 if ((!thumb2
3077 && (branch_offset > THM_MAX_FWD_BRANCH_OFFSET
3078 || (branch_offset < THM_MAX_BWD_BRANCH_OFFSET)))
3079 || (thumb2
3080 && (branch_offset > THM2_MAX_FWD_BRANCH_OFFSET
3081 || (branch_offset < THM2_MAX_BWD_BRANCH_OFFSET)))
3082 || ((st_type != STT_ARM_TFUNC)
3083 && (((r_type == R_ARM_THM_CALL) && !globals->use_blx)
3084 || (r_type == R_ARM_THM_JUMP24))
3085 && !use_plt))
3086 {
3087 if (st_type == STT_ARM_TFUNC)
3088 {
3089 /* Thumb to thumb. */
3090 if (!thumb_only)
3091 {
3092 stub_type = (info->shared | globals->pic_veneer)
3093 /* PIC stubs. */
3094 ? ((globals->use_blx
3095 && (r_type ==R_ARM_THM_CALL))
3096 /* V5T and above. Stub starts with ARM code, so
3097 we must be able to switch mode before
3098 reaching it, which is only possible for 'bl'
3099 (ie R_ARM_THM_CALL relocation). */
3100 ? arm_stub_long_branch_any_thumb_pic
3101 /* On V4T, use Thumb code only. */
3102 : arm_stub_long_branch_v4t_thumb_thumb_pic)
3103
3104 /* non-PIC stubs. */
3105 : ((globals->use_blx
3106 && (r_type ==R_ARM_THM_CALL))
3107 /* V5T and above. */
3108 ? arm_stub_long_branch_any_any
3109 /* V4T. */
3110 : arm_stub_long_branch_v4t_thumb_thumb);
3111 }
3112 else
3113 {
3114 stub_type = (info->shared | globals->pic_veneer)
3115 /* PIC stub. */
3116 ? arm_stub_long_branch_thumb_only_pic
3117 /* non-PIC stub. */
3118 : arm_stub_long_branch_thumb_only;
3119 }
3120 }
3121 else
3122 {
3123 /* Thumb to arm. */
3124 if (sym_sec != NULL
3125 && sym_sec->owner != NULL
3126 && !INTERWORK_FLAG (sym_sec->owner))
3127 {
3128 (*_bfd_error_handler)
3129 (_("%B(%s): warning: interworking not enabled.\n"
3130 " first occurrence: %B: Thumb call to ARM"),
3131 sym_sec->owner, input_bfd, name);
3132 }
3133
3134 stub_type = (info->shared | globals->pic_veneer)
3135 /* PIC stubs. */
3136 ? ((globals->use_blx
3137 && (r_type ==R_ARM_THM_CALL))
3138 /* V5T and above. */
3139 ? arm_stub_long_branch_any_arm_pic
3140 /* V4T PIC stub. */
3141 : arm_stub_long_branch_v4t_thumb_arm_pic)
3142
3143 /* non-PIC stubs. */
3144 : ((globals->use_blx
3145 && (r_type ==R_ARM_THM_CALL))
3146 /* V5T and above. */
3147 ? arm_stub_long_branch_any_any
3148 /* V4T. */
3149 : arm_stub_long_branch_v4t_thumb_arm);
3150
3151 /* Handle v4t short branches. */
3152 if ((stub_type == arm_stub_long_branch_v4t_thumb_arm)
3153 && (branch_offset <= THM_MAX_FWD_BRANCH_OFFSET)
3154 && (branch_offset >= THM_MAX_BWD_BRANCH_OFFSET))
3155 stub_type = arm_stub_short_branch_v4t_thumb_arm;
3156 }
3157 }
3158 }
3159 else if (r_type == R_ARM_CALL || r_type == R_ARM_JUMP24 || r_type == R_ARM_PLT32)
3160 {
3161 if (st_type == STT_ARM_TFUNC)
3162 {
3163 /* Arm to thumb. */
3164
3165 if (sym_sec != NULL
3166 && sym_sec->owner != NULL
3167 && !INTERWORK_FLAG (sym_sec->owner))
3168 {
3169 (*_bfd_error_handler)
3170 (_("%B(%s): warning: interworking not enabled.\n"
3171 " first occurrence: %B: ARM call to Thumb"),
3172 sym_sec->owner, input_bfd, name);
3173 }
3174
3175 /* We have an extra 2-bytes reach because of
3176 the mode change (bit 24 (H) of BLX encoding). */
3177 if (branch_offset > (ARM_MAX_FWD_BRANCH_OFFSET + 2)
3178 || (branch_offset < ARM_MAX_BWD_BRANCH_OFFSET)
3179 || ((r_type == R_ARM_CALL) && !globals->use_blx)
3180 || (r_type == R_ARM_JUMP24)
3181 || (r_type == R_ARM_PLT32))
3182 {
3183 stub_type = (info->shared | globals->pic_veneer)
3184 /* PIC stubs. */
3185 ? ((globals->use_blx)
3186 /* V5T and above. */
3187 ? arm_stub_long_branch_any_thumb_pic
3188 /* V4T stub. */
3189 : arm_stub_long_branch_v4t_arm_thumb_pic)
3190
3191 /* non-PIC stubs. */
3192 : ((globals->use_blx)
3193 /* V5T and above. */
3194 ? arm_stub_long_branch_any_any
3195 /* V4T. */
3196 : arm_stub_long_branch_v4t_arm_thumb);
3197 }
3198 }
3199 else
3200 {
3201 /* Arm to arm. */
3202 if (branch_offset > ARM_MAX_FWD_BRANCH_OFFSET
3203 || (branch_offset < ARM_MAX_BWD_BRANCH_OFFSET))
3204 {
3205 stub_type = (info->shared | globals->pic_veneer)
3206 /* PIC stubs. */
3207 ? arm_stub_long_branch_any_arm_pic
3208 /* non-PIC stubs. */
3209 : arm_stub_long_branch_any_any;
3210 }
3211 }
3212 }
3213
3214 return stub_type;
3215 }
3216
3217 /* Build a name for an entry in the stub hash table. */
3218
3219 static char *
3220 elf32_arm_stub_name (const asection *input_section,
3221 const asection *sym_sec,
3222 const struct elf32_arm_link_hash_entry *hash,
3223 const Elf_Internal_Rela *rel)
3224 {
3225 char *stub_name;
3226 bfd_size_type len;
3227
3228 if (hash)
3229 {
3230 len = 8 + 1 + strlen (hash->root.root.root.string) + 1 + 8 + 1;
3231 stub_name = bfd_malloc (len);
3232 if (stub_name != NULL)
3233 sprintf (stub_name, "%08x_%s+%x",
3234 input_section->id & 0xffffffff,
3235 hash->root.root.root.string,
3236 (int) rel->r_addend & 0xffffffff);
3237 }
3238 else
3239 {
3240 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
3241 stub_name = bfd_malloc (len);
3242 if (stub_name != NULL)
3243 sprintf (stub_name, "%08x_%x:%x+%x",
3244 input_section->id & 0xffffffff,
3245 sym_sec->id & 0xffffffff,
3246 (int) ELF32_R_SYM (rel->r_info) & 0xffffffff,
3247 (int) rel->r_addend & 0xffffffff);
3248 }
3249
3250 return stub_name;
3251 }
3252
3253 /* Look up an entry in the stub hash. Stub entries are cached because
3254 creating the stub name takes a bit of time. */
3255
3256 static struct elf32_arm_stub_hash_entry *
3257 elf32_arm_get_stub_entry (const asection *input_section,
3258 const asection *sym_sec,
3259 struct elf_link_hash_entry *hash,
3260 const Elf_Internal_Rela *rel,
3261 struct elf32_arm_link_hash_table *htab)
3262 {
3263 struct elf32_arm_stub_hash_entry *stub_entry;
3264 struct elf32_arm_link_hash_entry *h = (struct elf32_arm_link_hash_entry *) hash;
3265 const asection *id_sec;
3266
3267 if ((input_section->flags & SEC_CODE) == 0)
3268 return NULL;
3269
3270 /* If this input section is part of a group of sections sharing one
3271 stub section, then use the id of the first section in the group.
3272 Stub names need to include a section id, as there may well be
3273 more than one stub used to reach say, printf, and we need to
3274 distinguish between them. */
3275 id_sec = htab->stub_group[input_section->id].link_sec;
3276
3277 if (h != NULL && h->stub_cache != NULL
3278 && h->stub_cache->h == h
3279 && h->stub_cache->id_sec == id_sec)
3280 {
3281 stub_entry = h->stub_cache;
3282 }
3283 else
3284 {
3285 char *stub_name;
3286
3287 stub_name = elf32_arm_stub_name (id_sec, sym_sec, h, rel);
3288 if (stub_name == NULL)
3289 return NULL;
3290
3291 stub_entry = arm_stub_hash_lookup (&htab->stub_hash_table,
3292 stub_name, FALSE, FALSE);
3293 if (h != NULL)
3294 h->stub_cache = stub_entry;
3295
3296 free (stub_name);
3297 }
3298
3299 return stub_entry;
3300 }
3301
3302 /* Find or create a stub section. Returns a pointer to the stub section, and
3303 the section to which the stub section will be attached (in *LINK_SEC_P).
3304 LINK_SEC_P may be NULL. */
3305
3306 static asection *
3307 elf32_arm_create_or_find_stub_sec (asection **link_sec_p, asection *section,
3308 struct elf32_arm_link_hash_table *htab)
3309 {
3310 asection *link_sec;
3311 asection *stub_sec;
3312
3313 link_sec = htab->stub_group[section->id].link_sec;
3314 stub_sec = htab->stub_group[section->id].stub_sec;
3315 if (stub_sec == NULL)
3316 {
3317 stub_sec = htab->stub_group[link_sec->id].stub_sec;
3318 if (stub_sec == NULL)
3319 {
3320 size_t namelen;
3321 bfd_size_type len;
3322 char *s_name;
3323
3324 namelen = strlen (link_sec->name);
3325 len = namelen + sizeof (STUB_SUFFIX);
3326 s_name = bfd_alloc (htab->stub_bfd, len);
3327 if (s_name == NULL)
3328 return NULL;
3329
3330 memcpy (s_name, link_sec->name, namelen);
3331 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
3332 stub_sec = (*htab->add_stub_section) (s_name, link_sec);
3333 if (stub_sec == NULL)
3334 return NULL;
3335 htab->stub_group[link_sec->id].stub_sec = stub_sec;
3336 }
3337 htab->stub_group[section->id].stub_sec = stub_sec;
3338 }
3339
3340 if (link_sec_p)
3341 *link_sec_p = link_sec;
3342
3343 return stub_sec;
3344 }
3345
3346 /* Add a new stub entry to the stub hash. Not all fields of the new
3347 stub entry are initialised. */
3348
3349 static struct elf32_arm_stub_hash_entry *
3350 elf32_arm_add_stub (const char *stub_name,
3351 asection *section,
3352 struct elf32_arm_link_hash_table *htab)
3353 {
3354 asection *link_sec;
3355 asection *stub_sec;
3356 struct elf32_arm_stub_hash_entry *stub_entry;
3357
3358 stub_sec = elf32_arm_create_or_find_stub_sec (&link_sec, section, htab);
3359 if (stub_sec == NULL)
3360 return NULL;
3361
3362 /* Enter this entry into the linker stub hash table. */
3363 stub_entry = arm_stub_hash_lookup (&htab->stub_hash_table, stub_name,
3364 TRUE, FALSE);
3365 if (stub_entry == NULL)
3366 {
3367 (*_bfd_error_handler) (_("%s: cannot create stub entry %s"),
3368 section->owner,
3369 stub_name);
3370 return NULL;
3371 }
3372
3373 stub_entry->stub_sec = stub_sec;
3374 stub_entry->stub_offset = 0;
3375 stub_entry->id_sec = link_sec;
3376
3377 return stub_entry;
3378 }
3379
3380 /* Store an Arm insn into an output section not processed by
3381 elf32_arm_write_section. */
3382
3383 static void
3384 put_arm_insn (struct elf32_arm_link_hash_table * htab,
3385 bfd * output_bfd, bfd_vma val, void * ptr)
3386 {
3387 if (htab->byteswap_code != bfd_little_endian (output_bfd))
3388 bfd_putl32 (val, ptr);
3389 else
3390 bfd_putb32 (val, ptr);
3391 }
3392
3393 /* Store a 16-bit Thumb insn into an output section not processed by
3394 elf32_arm_write_section. */
3395
3396 static void
3397 put_thumb_insn (struct elf32_arm_link_hash_table * htab,
3398 bfd * output_bfd, bfd_vma val, void * ptr)
3399 {
3400 if (htab->byteswap_code != bfd_little_endian (output_bfd))
3401 bfd_putl16 (val, ptr);
3402 else
3403 bfd_putb16 (val, ptr);
3404 }
3405
3406 static bfd_reloc_status_type elf32_arm_final_link_relocate
3407 (reloc_howto_type *, bfd *, bfd *, asection *, bfd_byte *,
3408 Elf_Internal_Rela *, bfd_vma, struct bfd_link_info *, asection *,
3409 const char *, int, struct elf_link_hash_entry *, bfd_boolean *, char **);
3410
3411 static bfd_boolean
3412 arm_build_one_stub (struct bfd_hash_entry *gen_entry,
3413 void * in_arg)
3414 {
3415 #define MAXRELOCS 2
3416 struct elf32_arm_stub_hash_entry *stub_entry;
3417 struct bfd_link_info *info;
3418 struct elf32_arm_link_hash_table *htab;
3419 asection *stub_sec;
3420 bfd *stub_bfd;
3421 bfd_vma stub_addr;
3422 bfd_byte *loc;
3423 bfd_vma sym_value;
3424 int template_size;
3425 int size;
3426 const insn_sequence *template;
3427 int i;
3428 struct elf32_arm_link_hash_table * globals;
3429 int stub_reloc_idx[MAXRELOCS] = {-1, -1};
3430 int stub_reloc_offset[MAXRELOCS] = {0, 0};
3431 int nrelocs = 0;
3432
3433 /* Massage our args to the form they really have. */
3434 stub_entry = (struct elf32_arm_stub_hash_entry *) gen_entry;
3435 info = (struct bfd_link_info *) in_arg;
3436
3437 globals = elf32_arm_hash_table (info);
3438
3439 htab = elf32_arm_hash_table (info);
3440 stub_sec = stub_entry->stub_sec;
3441
3442 if ((htab->fix_cortex_a8 < 0)
3443 != (stub_entry->stub_type >= arm_stub_a8_veneer_lwm))
3444 /* We have to do the a8 fixes last, as they are less aligned than
3445 the other veneers. */
3446 return TRUE;
3447
3448 /* Make a note of the offset within the stubs for this entry. */
3449 stub_entry->stub_offset = stub_sec->size;
3450 loc = stub_sec->contents + stub_entry->stub_offset;
3451
3452 stub_bfd = stub_sec->owner;
3453
3454 /* This is the address of the start of the stub. */
3455 stub_addr = stub_sec->output_section->vma + stub_sec->output_offset
3456 + stub_entry->stub_offset;
3457
3458 /* This is the address of the stub destination. */
3459 sym_value = (stub_entry->target_value
3460 + stub_entry->target_section->output_offset
3461 + stub_entry->target_section->output_section->vma);
3462
3463 template = stub_entry->stub_template;
3464 template_size = stub_entry->stub_template_size;
3465
3466 size = 0;
3467 for (i = 0; i < template_size; i++)
3468 {
3469 switch (template[i].type)
3470 {
3471 case THUMB16_TYPE:
3472 {
3473 bfd_vma data = template[i].data;
3474 if (template[i].reloc_addend != 0)
3475 {
3476 /* We've borrowed the reloc_addend field to mean we should
3477 insert a condition code into this (Thumb-1 branch)
3478 instruction. See THUMB16_BCOND_INSN. */
3479 BFD_ASSERT ((data & 0xff00) == 0xd000);
3480 data |= ((stub_entry->orig_insn >> 22) & 0xf) << 8;
3481 }
3482 put_thumb_insn (globals, stub_bfd, data, loc + size);
3483 size += 2;
3484 }
3485 break;
3486
3487 case THUMB32_TYPE:
3488 put_thumb_insn (globals, stub_bfd, (template[i].data >> 16) & 0xffff,
3489 loc + size);
3490 put_thumb_insn (globals, stub_bfd, template[i].data & 0xffff,
3491 loc + size + 2);
3492 if (template[i].r_type != R_ARM_NONE)
3493 {
3494 stub_reloc_idx[nrelocs] = i;
3495 stub_reloc_offset[nrelocs++] = size;
3496 }
3497 size += 4;
3498 break;
3499
3500 case ARM_TYPE:
3501 put_arm_insn (globals, stub_bfd, template[i].data, loc + size);
3502 /* Handle cases where the target is encoded within the
3503 instruction. */
3504 if (template[i].r_type == R_ARM_JUMP24)
3505 {
3506 stub_reloc_idx[nrelocs] = i;
3507 stub_reloc_offset[nrelocs++] = size;
3508 }
3509 size += 4;
3510 break;
3511
3512 case DATA_TYPE:
3513 bfd_put_32 (stub_bfd, template[i].data, loc + size);
3514 stub_reloc_idx[nrelocs] = i;
3515 stub_reloc_offset[nrelocs++] = size;
3516 size += 4;
3517 break;
3518
3519 default:
3520 BFD_FAIL ();
3521 return FALSE;
3522 }
3523 }
3524
3525 stub_sec->size += size;
3526
3527 /* Stub size has already been computed in arm_size_one_stub. Check
3528 consistency. */
3529 BFD_ASSERT (size == stub_entry->stub_size);
3530
3531 /* Destination is Thumb. Force bit 0 to 1 to reflect this. */
3532 if (stub_entry->st_type == STT_ARM_TFUNC)
3533 sym_value |= 1;
3534
3535 /* Assume there is at least one and at most MAXRELOCS entries to relocate
3536 in each stub. */
3537 BFD_ASSERT (nrelocs != 0 && nrelocs <= MAXRELOCS);
3538
3539 for (i = 0; i < nrelocs; i++)
3540 if (template[stub_reloc_idx[i]].r_type == R_ARM_THM_JUMP24
3541 || template[stub_reloc_idx[i]].r_type == R_ARM_THM_JUMP19
3542 || template[stub_reloc_idx[i]].r_type == R_ARM_THM_CALL
3543 || template[stub_reloc_idx[i]].r_type == R_ARM_THM_XPC22)
3544 {
3545 Elf_Internal_Rela rel;
3546 bfd_boolean unresolved_reloc;
3547 char *error_message;
3548 int sym_flags
3549 = (template[stub_reloc_idx[i]].r_type != R_ARM_THM_XPC22)
3550 ? STT_ARM_TFUNC : 0;
3551 bfd_vma points_to = sym_value + stub_entry->target_addend;
3552
3553 rel.r_offset = stub_entry->stub_offset + stub_reloc_offset[i];
3554 rel.r_info = ELF32_R_INFO (0, template[stub_reloc_idx[i]].r_type);
3555 rel.r_addend = template[stub_reloc_idx[i]].reloc_addend;
3556
3557 if (stub_entry->stub_type == arm_stub_a8_veneer_b_cond && i == 0)
3558 /* The first relocation in the elf32_arm_stub_a8_veneer_b_cond[]
3559 template should refer back to the instruction after the original
3560 branch. */
3561 points_to = sym_value;
3562
3563 /* There may be unintended consequences if this is not true. */
3564 BFD_ASSERT (stub_entry->h == NULL);
3565
3566 /* Note: _bfd_final_link_relocate doesn't handle these relocations
3567 properly. We should probably use this function unconditionally,
3568 rather than only for certain relocations listed in the enclosing
3569 conditional, for the sake of consistency. */
3570 elf32_arm_final_link_relocate (elf32_arm_howto_from_type
3571 (template[stub_reloc_idx[i]].r_type),
3572 stub_bfd, info->output_bfd, stub_sec, stub_sec->contents, &rel,
3573 points_to, info, stub_entry->target_section, "", sym_flags,
3574 (struct elf_link_hash_entry *) stub_entry->h, &unresolved_reloc,
3575 &error_message);
3576 }
3577 else
3578 {
3579 _bfd_final_link_relocate (elf32_arm_howto_from_type
3580 (template[stub_reloc_idx[i]].r_type), stub_bfd, stub_sec,
3581 stub_sec->contents, stub_entry->stub_offset + stub_reloc_offset[i],
3582 sym_value + stub_entry->target_addend,
3583 template[stub_reloc_idx[i]].reloc_addend);
3584 }
3585
3586 return TRUE;
3587 #undef MAXRELOCS
3588 }
3589
3590 /* Calculate the template, template size and instruction size for a stub.
3591 Return value is the instruction size. */
3592
3593 static unsigned int
3594 find_stub_size_and_template (enum elf32_arm_stub_type stub_type,
3595 const insn_sequence **stub_template,
3596 int *stub_template_size)
3597 {
3598 const insn_sequence *template = NULL;
3599 int template_size = 0, i;
3600 unsigned int size;
3601
3602 template = stub_definitions[stub_type].template;
3603 template_size = stub_definitions[stub_type].template_size;
3604
3605 size = 0;
3606 for (i = 0; i < template_size; i++)
3607 {
3608 switch (template[i].type)
3609 {
3610 case THUMB16_TYPE:
3611 size += 2;
3612 break;
3613
3614 case ARM_TYPE:
3615 case THUMB32_TYPE:
3616 case DATA_TYPE:
3617 size += 4;
3618 break;
3619
3620 default:
3621 BFD_FAIL ();
3622 return FALSE;
3623 }
3624 }
3625
3626 if (stub_template)
3627 *stub_template = template;
3628
3629 if (stub_template_size)
3630 *stub_template_size = template_size;
3631
3632 return size;
3633 }
3634
3635 /* As above, but don't actually build the stub. Just bump offset so
3636 we know stub section sizes. */
3637
3638 static bfd_boolean
3639 arm_size_one_stub (struct bfd_hash_entry *gen_entry,
3640 void * in_arg)
3641 {
3642 struct elf32_arm_stub_hash_entry *stub_entry;
3643 struct elf32_arm_link_hash_table *htab;
3644 const insn_sequence *template;
3645 int template_size, size;
3646
3647 /* Massage our args to the form they really have. */
3648 stub_entry = (struct elf32_arm_stub_hash_entry *) gen_entry;
3649 htab = (struct elf32_arm_link_hash_table *) in_arg;
3650
3651 BFD_ASSERT((stub_entry->stub_type > arm_stub_none)
3652 && stub_entry->stub_type < ARRAY_SIZE(stub_definitions));
3653
3654 size = find_stub_size_and_template (stub_entry->stub_type, &template,
3655 &template_size);
3656
3657 stub_entry->stub_size = size;
3658 stub_entry->stub_template = template;
3659 stub_entry->stub_template_size = template_size;
3660
3661 size = (size + 7) & ~7;
3662 stub_entry->stub_sec->size += size;
3663
3664 return TRUE;
3665 }
3666
3667 /* External entry points for sizing and building linker stubs. */
3668
3669 /* Set up various things so that we can make a list of input sections
3670 for each output section included in the link. Returns -1 on error,
3671 0 when no stubs will be needed, and 1 on success. */
3672
3673 int
3674 elf32_arm_setup_section_lists (bfd *output_bfd,
3675 struct bfd_link_info *info)
3676 {
3677 bfd *input_bfd;
3678 unsigned int bfd_count;
3679 int top_id, top_index;
3680 asection *section;
3681 asection **input_list, **list;
3682 bfd_size_type amt;
3683 struct elf32_arm_link_hash_table *htab = elf32_arm_hash_table (info);
3684
3685 if (! is_elf_hash_table (htab))
3686 return 0;
3687
3688 /* Count the number of input BFDs and find the top input section id. */
3689 for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
3690 input_bfd != NULL;
3691 input_bfd = input_bfd->link_next)
3692 {
3693 bfd_count += 1;
3694 for (section = input_bfd->sections;
3695 section != NULL;
3696 section = section->next)
3697 {
3698 if (top_id < section->id)
3699 top_id = section->id;
3700 }
3701 }
3702 htab->bfd_count = bfd_count;
3703
3704 amt = sizeof (struct map_stub) * (top_id + 1);
3705 htab->stub_group = bfd_zmalloc (amt);
3706 if (htab->stub_group == NULL)
3707 return -1;
3708
3709 /* We can't use output_bfd->section_count here to find the top output
3710 section index as some sections may have been removed, and
3711 _bfd_strip_section_from_output doesn't renumber the indices. */
3712 for (section = output_bfd->sections, top_index = 0;
3713 section != NULL;
3714 section = section->next)
3715 {
3716 if (top_index < section->index)
3717 top_index = section->index;
3718 }
3719
3720 htab->top_index = top_index;
3721 amt = sizeof (asection *) * (top_index + 1);
3722 input_list = bfd_malloc (amt);
3723 htab->input_list = input_list;
3724 if (input_list == NULL)
3725 return -1;
3726
3727 /* For sections we aren't interested in, mark their entries with a
3728 value we can check later. */
3729 list = input_list + top_index;
3730 do
3731 *list = bfd_abs_section_ptr;
3732 while (list-- != input_list);
3733
3734 for (section = output_bfd->sections;
3735 section != NULL;
3736 section = section->next)
3737 {
3738 if ((section->flags & SEC_CODE) != 0)
3739 input_list[section->index] = NULL;
3740 }
3741
3742 return 1;
3743 }
3744
3745 /* The linker repeatedly calls this function for each input section,
3746 in the order that input sections are linked into output sections.
3747 Build lists of input sections to determine groupings between which
3748 we may insert linker stubs. */
3749
3750 void
3751 elf32_arm_next_input_section (struct bfd_link_info *info,
3752 asection *isec)
3753 {
3754 struct elf32_arm_link_hash_table *htab = elf32_arm_hash_table (info);
3755
3756 if (isec->output_section->index <= htab->top_index)
3757 {
3758 asection **list = htab->input_list + isec->output_section->index;
3759
3760 if (*list != bfd_abs_section_ptr)
3761 {
3762 /* Steal the link_sec pointer for our list. */
3763 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
3764 /* This happens to make the list in reverse order,
3765 which we reverse later. */
3766 PREV_SEC (isec) = *list;
3767 *list = isec;
3768 }
3769 }
3770 }
3771
3772 /* See whether we can group stub sections together. Grouping stub
3773 sections may result in fewer stubs. More importantly, we need to
3774 put all .init* and .fini* stubs at the end of the .init or
3775 .fini output sections respectively, because glibc splits the
3776 _init and _fini functions into multiple parts. Putting a stub in
3777 the middle of a function is not a good idea. */
3778
3779 static void
3780 group_sections (struct elf32_arm_link_hash_table *htab,
3781 bfd_size_type stub_group_size,
3782 bfd_boolean stubs_always_after_branch)
3783 {
3784 asection **list = htab->input_list;
3785
3786 do
3787 {
3788 asection *tail = *list;
3789 asection *head;
3790
3791 if (tail == bfd_abs_section_ptr)
3792 continue;
3793
3794 /* Reverse the list: we must avoid placing stubs at the
3795 beginning of the section because the beginning of the text
3796 section may be required for an interrupt vector in bare metal
3797 code. */
3798 #define NEXT_SEC PREV_SEC
3799 head = NULL;
3800 while (tail != NULL)
3801 {
3802 /* Pop from tail. */
3803 asection *item = tail;
3804 tail = PREV_SEC (item);
3805
3806 /* Push on head. */
3807 NEXT_SEC (item) = head;
3808 head = item;
3809 }
3810
3811 while (head != NULL)
3812 {
3813 asection *curr;
3814 asection *next;
3815 bfd_vma stub_group_start = head->output_offset;
3816 bfd_vma end_of_next;
3817
3818 curr = head;
3819 while (NEXT_SEC (curr) != NULL)
3820 {
3821 next = NEXT_SEC (curr);
3822 end_of_next = next->output_offset + next->size;
3823 if (end_of_next - stub_group_start >= stub_group_size)
3824 /* End of NEXT is too far from start, so stop. */
3825 break;
3826 /* Add NEXT to the group. */
3827 curr = next;
3828 }
3829
3830 /* OK, the size from the start to the start of CURR is less
3831 than stub_group_size and thus can be handled by one stub
3832 section. (Or the head section is itself larger than
3833 stub_group_size, in which case we may be toast.)
3834 We should really be keeping track of the total size of
3835 stubs added here, as stubs contribute to the final output
3836 section size. */
3837 do
3838 {
3839 next = NEXT_SEC (head);
3840 /* Set up this stub group. */
3841 htab->stub_group[head->id].link_sec = curr;
3842 }
3843 while (head != curr && (head = next) != NULL);
3844
3845 /* But wait, there's more! Input sections up to stub_group_size
3846 bytes after the stub section can be handled by it too. */
3847 if (!stubs_always_after_branch)
3848 {
3849 stub_group_start = curr->output_offset + curr->size;
3850
3851 while (next != NULL)
3852 {
3853 end_of_next = next->output_offset + next->size;
3854 if (end_of_next - stub_group_start >= stub_group_size)
3855 /* End of NEXT is too far from stubs, so stop. */
3856 break;
3857 /* Add NEXT to the stub group. */
3858 head = next;
3859 next = NEXT_SEC (head);
3860 htab->stub_group[head->id].link_sec = curr;
3861 }
3862 }
3863 head = next;
3864 }
3865 }
3866 while (list++ != htab->input_list + htab->top_index);
3867
3868 free (htab->input_list);
3869 #undef PREV_SEC
3870 #undef NEXT_SEC
3871 }
3872
3873 /* Comparison function for sorting/searching relocations relating to Cortex-A8
3874 erratum fix. */
3875
3876 static int
3877 a8_reloc_compare (const void *a, const void *b)
3878 {
3879 const struct a8_erratum_reloc *ra = a, *rb = b;
3880
3881 if (ra->from < rb->from)
3882 return -1;
3883 else if (ra->from > rb->from)
3884 return 1;
3885 else
3886 return 0;
3887 }
3888
3889 static struct elf_link_hash_entry *find_thumb_glue (struct bfd_link_info *,
3890 const char *, char **);
3891
3892 /* Helper function to scan code for sequences which might trigger the Cortex-A8
3893 branch/TLB erratum. Fill in the table described by A8_FIXES_P,
3894 NUM_A8_FIXES_P, A8_FIX_TABLE_SIZE_P. Returns true if an error occurs, false
3895 otherwise. */
3896
3897 static bfd_boolean
3898 cortex_a8_erratum_scan (bfd *input_bfd,
3899 struct bfd_link_info *info,
3900 struct a8_erratum_fix **a8_fixes_p,
3901 unsigned int *num_a8_fixes_p,
3902 unsigned int *a8_fix_table_size_p,
3903 struct a8_erratum_reloc *a8_relocs,
3904 unsigned int num_a8_relocs,
3905 unsigned prev_num_a8_fixes,
3906 bfd_boolean *stub_changed_p)
3907 {
3908 asection *section;
3909 struct elf32_arm_link_hash_table *htab = elf32_arm_hash_table (info);
3910 struct a8_erratum_fix *a8_fixes = *a8_fixes_p;
3911 unsigned int num_a8_fixes = *num_a8_fixes_p;
3912 unsigned int a8_fix_table_size = *a8_fix_table_size_p;
3913
3914 for (section = input_bfd->sections;
3915 section != NULL;
3916 section = section->next)
3917 {
3918 bfd_byte *contents = NULL;
3919 struct _arm_elf_section_data *sec_data;
3920 unsigned int span;
3921 bfd_vma base_vma;
3922
3923 if (elf_section_type (section) != SHT_PROGBITS
3924 || (elf_section_flags (section) & SHF_EXECINSTR) == 0
3925 || (section->flags & SEC_EXCLUDE) != 0
3926 || (section->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
3927 || (section->output_section == bfd_abs_section_ptr))
3928 continue;
3929
3930 base_vma = section->output_section->vma + section->output_offset;
3931
3932 if (elf_section_data (section)->this_hdr.contents != NULL)
3933 contents = elf_section_data (section)->this_hdr.contents;
3934 else if (! bfd_malloc_and_get_section (input_bfd, section, &contents))
3935 return TRUE;
3936
3937 sec_data = elf32_arm_section_data (section);
3938
3939 for (span = 0; span < sec_data->mapcount; span++)
3940 {
3941 unsigned int span_start = sec_data->map[span].vma;
3942 unsigned int span_end = (span == sec_data->mapcount - 1)
3943 ? section->size : sec_data->map[span + 1].vma;
3944 unsigned int i;
3945 char span_type = sec_data->map[span].type;
3946 bfd_boolean last_was_32bit = FALSE, last_was_branch = FALSE;
3947
3948 if (span_type != 't')
3949 continue;
3950
3951 /* Span is entirely within a single 4KB region: skip scanning. */
3952 if (((base_vma + span_start) & ~0xfff)
3953 == ((base_vma + span_end) & ~0xfff))
3954 continue;
3955
3956 /* Scan for 32-bit Thumb-2 branches which span two 4K regions, where:
3957
3958 * The opcode is BLX.W, BL.W, B.W, Bcc.W
3959 * The branch target is in the same 4KB region as the
3960 first half of the branch.
3961 * The instruction before the branch is a 32-bit
3962 length non-branch instruction. */
3963 for (i = span_start; i < span_end;)
3964 {
3965 unsigned int insn = bfd_getl16 (&contents[i]);
3966 bfd_boolean insn_32bit = FALSE, is_blx = FALSE, is_b = FALSE;
3967 bfd_boolean is_bl = FALSE, is_bcc = FALSE, is_32bit_branch;
3968
3969 if ((insn & 0xe000) == 0xe000 && (insn & 0x1800) != 0x0000)
3970 insn_32bit = TRUE;
3971
3972 if (insn_32bit)
3973 {
3974 /* Load the rest of the insn (in manual-friendly order). */
3975 insn = (insn << 16) | bfd_getl16 (&contents[i + 2]);
3976
3977 /* Encoding T4: B<c>.W. */
3978 is_b = (insn & 0xf800d000) == 0xf0009000;
3979 /* Encoding T1: BL<c>.W. */
3980 is_bl = (insn & 0xf800d000) == 0xf000d000;
3981 /* Encoding T2: BLX<c>.W. */
3982 is_blx = (insn & 0xf800d000) == 0xf000c000;
3983 /* Encoding T3: B<c>.W (not permitted in IT block). */
3984 is_bcc = (insn & 0xf800d000) == 0xf0008000
3985 && (insn & 0x07f00000) != 0x03800000;
3986 }
3987
3988 is_32bit_branch = is_b || is_bl || is_blx || is_bcc;
3989
3990 if (((base_vma + i) & 0xfff) == 0xffe
3991 && insn_32bit
3992 && is_32bit_branch
3993 && last_was_32bit
3994 && ! last_was_branch)
3995 {
3996 bfd_signed_vma offset;
3997 bfd_boolean force_target_arm = FALSE;
3998 bfd_boolean force_target_thumb = FALSE;
3999 bfd_vma target;
4000 enum elf32_arm_stub_type stub_type = arm_stub_none;
4001 struct a8_erratum_reloc key, *found;
4002
4003 key.from = base_vma + i;
4004 found = bsearch (&key, a8_relocs, num_a8_relocs,
4005 sizeof (struct a8_erratum_reloc),
4006 &a8_reloc_compare);
4007
4008 if (found)
4009 {
4010 char *error_message = NULL;
4011 struct elf_link_hash_entry *entry;
4012
4013 /* We don't care about the error returned from this
4014 function, only if there is glue or not. */
4015 entry = find_thumb_glue (info, found->sym_name,
4016 &error_message);
4017
4018 if (entry)
4019 found->non_a8_stub = TRUE;
4020
4021 if (found->r_type == R_ARM_THM_CALL
4022 && found->st_type != STT_ARM_TFUNC)
4023 force_target_arm = TRUE;
4024 else if (found->r_type == R_ARM_THM_CALL
4025 && found->st_type == STT_ARM_TFUNC)
4026 force_target_thumb = TRUE;
4027 }
4028
4029 /* Check if we have an offending branch instruction. */
4030
4031 if (found && found->non_a8_stub)
4032 /* We've already made a stub for this instruction, e.g.
4033 it's a long branch or a Thumb->ARM stub. Assume that
4034 stub will suffice to work around the A8 erratum (see
4035 setting of always_after_branch above). */
4036 ;
4037 else if (is_bcc)
4038 {
4039 offset = (insn & 0x7ff) << 1;
4040 offset |= (insn & 0x3f0000) >> 4;
4041 offset |= (insn & 0x2000) ? 0x40000 : 0;
4042 offset |= (insn & 0x800) ? 0x80000 : 0;
4043 offset |= (insn & 0x4000000) ? 0x100000 : 0;
4044 if (offset & 0x100000)
4045 offset |= ~ ((bfd_signed_vma) 0xfffff);
4046 stub_type = arm_stub_a8_veneer_b_cond;
4047 }
4048 else if (is_b || is_bl || is_blx)
4049 {
4050 int s = (insn & 0x4000000) != 0;
4051 int j1 = (insn & 0x2000) != 0;
4052 int j2 = (insn & 0x800) != 0;
4053 int i1 = !(j1 ^ s);
4054 int i2 = !(j2 ^ s);
4055
4056 offset = (insn & 0x7ff) << 1;
4057 offset |= (insn & 0x3ff0000) >> 4;
4058 offset |= i2 << 22;
4059 offset |= i1 << 23;
4060 offset |= s << 24;
4061 if (offset & 0x1000000)
4062 offset |= ~ ((bfd_signed_vma) 0xffffff);
4063
4064 if (is_blx)
4065 offset &= ~ ((bfd_signed_vma) 3);
4066
4067 stub_type = is_blx ? arm_stub_a8_veneer_blx :
4068 is_bl ? arm_stub_a8_veneer_bl : arm_stub_a8_veneer_b;
4069 }
4070
4071 if (stub_type != arm_stub_none)
4072 {
4073 bfd_vma pc_for_insn = base_vma + i + 4;
4074
4075 /* The original instruction is a BL, but the target is
4076 an ARM instruction. If we were not making a stub,
4077 the BL would have been converted to a BLX. Use the
4078 BLX stub instead in that case. */
4079 if (htab->use_blx && force_target_arm
4080 && stub_type == arm_stub_a8_veneer_bl)
4081 {
4082 stub_type = arm_stub_a8_veneer_blx;
4083 is_blx = TRUE;
4084 is_bl = FALSE;
4085 }
4086 /* Conversely, if the original instruction was
4087 BLX but the target is Thumb mode, use the BL
4088 stub. */
4089 else if (force_target_thumb
4090 && stub_type == arm_stub_a8_veneer_blx)
4091 {
4092 stub_type = arm_stub_a8_veneer_bl;
4093 is_blx = FALSE;
4094 is_bl = TRUE;
4095 }
4096
4097 if (is_blx)
4098 pc_for_insn &= ~ ((bfd_vma) 3);
4099
4100 /* If we found a relocation, use the proper destination,
4101 not the offset in the (unrelocated) instruction.
4102 Note this is always done if we switched the stub type
4103 above. */
4104 if (found)
4105 offset =
4106 (bfd_signed_vma) (found->destination - pc_for_insn);
4107
4108 target = pc_for_insn + offset;
4109
4110 /* The BLX stub is ARM-mode code. Adjust the offset to
4111 take the different PC value (+8 instead of +4) into
4112 account. */
4113 if (stub_type == arm_stub_a8_veneer_blx)
4114 offset += 4;
4115
4116 if (((base_vma + i) & ~0xfff) == (target & ~0xfff))
4117 {
4118 char *stub_name = NULL;
4119
4120 if (num_a8_fixes == a8_fix_table_size)
4121 {
4122 a8_fix_table_size *= 2;
4123 a8_fixes = bfd_realloc (a8_fixes,
4124 sizeof (struct a8_erratum_fix)
4125 * a8_fix_table_size);
4126 }
4127
4128 if (num_a8_fixes < prev_num_a8_fixes)
4129 {
4130 /* If we're doing a subsequent scan,
4131 check if we've found the same fix as
4132 before, and try and reuse the stub
4133 name. */
4134 stub_name = a8_fixes[num_a8_fixes].stub_name;
4135 if ((a8_fixes[num_a8_fixes].section != section)
4136 || (a8_fixes[num_a8_fixes].offset != i))
4137 {
4138 free (stub_name);
4139 stub_name = NULL;
4140 *stub_changed_p = TRUE;
4141 }
4142 }
4143
4144 if (!stub_name)
4145 {
4146 stub_name = bfd_malloc (8 + 1 + 8 + 1);
4147 if (stub_name != NULL)
4148 sprintf (stub_name, "%x:%x", section->id, i);
4149 }
4150
4151 a8_fixes[num_a8_fixes].input_bfd = input_bfd;
4152 a8_fixes[num_a8_fixes].section = section;
4153 a8_fixes[num_a8_fixes].offset = i;
4154 a8_fixes[num_a8_fixes].addend = offset;
4155 a8_fixes[num_a8_fixes].orig_insn = insn;
4156 a8_fixes[num_a8_fixes].stub_name = stub_name;
4157 a8_fixes[num_a8_fixes].stub_type = stub_type;
4158
4159 num_a8_fixes++;
4160 }
4161 }
4162 }
4163
4164 i += insn_32bit ? 4 : 2;
4165 last_was_32bit = insn_32bit;
4166 last_was_branch = is_32bit_branch;
4167 }
4168 }
4169
4170 if (elf_section_data (section)->this_hdr.contents == NULL)
4171 free (contents);
4172 }
4173
4174 *a8_fixes_p = a8_fixes;
4175 *num_a8_fixes_p = num_a8_fixes;
4176 *a8_fix_table_size_p = a8_fix_table_size;
4177
4178 return FALSE;
4179 }
4180
4181 /* Determine and set the size of the stub section for a final link.
4182
4183 The basic idea here is to examine all the relocations looking for
4184 PC-relative calls to a target that is unreachable with a "bl"
4185 instruction. */
4186
4187 bfd_boolean
4188 elf32_arm_size_stubs (bfd *output_bfd,
4189 bfd *stub_bfd,
4190 struct bfd_link_info *info,
4191 bfd_signed_vma group_size,
4192 asection * (*add_stub_section) (const char *, asection *),
4193 void (*layout_sections_again) (void))
4194 {
4195 bfd_size_type stub_group_size;
4196 bfd_boolean stubs_always_after_branch;
4197 struct elf32_arm_link_hash_table *htab = elf32_arm_hash_table (info);
4198 struct a8_erratum_fix *a8_fixes = NULL;
4199 unsigned int num_a8_fixes = 0, a8_fix_table_size = 10;
4200 struct a8_erratum_reloc *a8_relocs = NULL;
4201 unsigned int num_a8_relocs = 0, a8_reloc_table_size = 10, i;
4202
4203 if (htab->fix_cortex_a8)
4204 {
4205 a8_fixes = bfd_zmalloc (sizeof (struct a8_erratum_fix)
4206 * a8_fix_table_size);
4207 a8_relocs = bfd_zmalloc (sizeof (struct a8_erratum_reloc)
4208 * a8_reloc_table_size);
4209 }
4210
4211 /* Propagate mach to stub bfd, because it may not have been
4212 finalized when we created stub_bfd. */
4213 bfd_set_arch_mach (stub_bfd, bfd_get_arch (output_bfd),
4214 bfd_get_mach (output_bfd));
4215
4216 /* Stash our params away. */
4217 htab->stub_bfd = stub_bfd;
4218 htab->add_stub_section = add_stub_section;
4219 htab->layout_sections_again = layout_sections_again;
4220 stubs_always_after_branch = group_size < 0;
4221
4222 /* The Cortex-A8 erratum fix depends on stubs not being in the same 4K page
4223 as the first half of a 32-bit branch straddling two 4K pages. This is a
4224 crude way of enforcing that. */
4225 if (htab->fix_cortex_a8)
4226 stubs_always_after_branch = 1;
4227
4228 if (group_size < 0)
4229 stub_group_size = -group_size;
4230 else
4231 stub_group_size = group_size;
4232
4233 if (stub_group_size == 1)
4234 {
4235 /* Default values. */
4236 /* Thumb branch range is +-4MB has to be used as the default
4237 maximum size (a given section can contain both ARM and Thumb
4238 code, so the worst case has to be taken into account).
4239
4240 This value is 24K less than that, which allows for 2025
4241 12-byte stubs. If we exceed that, then we will fail to link.
4242 The user will have to relink with an explicit group size
4243 option. */
4244 stub_group_size = 4170000;
4245 }
4246
4247 group_sections (htab, stub_group_size, stubs_always_after_branch);
4248
4249 /* If we're applying the cortex A8 fix, we need to determine the
4250 program header size now, because we cannot change it later --
4251 that could alter section placements. Notice the A8 erratum fix
4252 ends up requiring the section addresses to remain unchanged
4253 modulo the page size. That's something we cannot represent
4254 inside BFD, and we don't want to force the section alignment to
4255 be the page size. */
4256 if (htab->fix_cortex_a8)
4257 (*htab->layout_sections_again) ();
4258
4259 while (1)
4260 {
4261 bfd *input_bfd;
4262 unsigned int bfd_indx;
4263 asection *stub_sec;
4264 bfd_boolean stub_changed = FALSE;
4265 unsigned prev_num_a8_fixes = num_a8_fixes;
4266
4267 num_a8_fixes = 0;
4268 for (input_bfd = info->input_bfds, bfd_indx = 0;
4269 input_bfd != NULL;
4270 input_bfd = input_bfd->link_next, bfd_indx++)
4271 {
4272 Elf_Internal_Shdr *symtab_hdr;
4273 asection *section;
4274 Elf_Internal_Sym *local_syms = NULL;
4275
4276 num_a8_relocs = 0;
4277
4278 /* We'll need the symbol table in a second. */
4279 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4280 if (symtab_hdr->sh_info == 0)
4281 continue;
4282
4283 /* Walk over each section attached to the input bfd. */
4284 for (section = input_bfd->sections;
4285 section != NULL;
4286 section = section->next)
4287 {
4288 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
4289
4290 /* If there aren't any relocs, then there's nothing more
4291 to do. */
4292 if ((section->flags & SEC_RELOC) == 0
4293 || section->reloc_count == 0
4294 || (section->flags & SEC_CODE) == 0)
4295 continue;
4296
4297 /* If this section is a link-once section that will be
4298 discarded, then don't create any stubs. */
4299 if (section->output_section == NULL
4300 || section->output_section->owner != output_bfd)
4301 continue;
4302
4303 /* Get the relocs. */
4304 internal_relocs
4305 = _bfd_elf_link_read_relocs (input_bfd, section, NULL,
4306 NULL, info->keep_memory);
4307 if (internal_relocs == NULL)
4308 goto error_ret_free_local;
4309
4310 /* Now examine each relocation. */
4311 irela = internal_relocs;
4312 irelaend = irela + section->reloc_count;
4313 for (; irela < irelaend; irela++)
4314 {
4315 unsigned int r_type, r_indx;
4316 enum elf32_arm_stub_type stub_type;
4317 struct elf32_arm_stub_hash_entry *stub_entry;
4318 asection *sym_sec;
4319 bfd_vma sym_value;
4320 bfd_vma destination;
4321 struct elf32_arm_link_hash_entry *hash;
4322 const char *sym_name;
4323 char *stub_name;
4324 const asection *id_sec;
4325 unsigned char st_type;
4326 bfd_boolean created_stub = FALSE;
4327
4328 r_type = ELF32_R_TYPE (irela->r_info);
4329 r_indx = ELF32_R_SYM (irela->r_info);
4330
4331 if (r_type >= (unsigned int) R_ARM_max)
4332 {
4333 bfd_set_error (bfd_error_bad_value);
4334 error_ret_free_internal:
4335 if (elf_section_data (section)->relocs == NULL)
4336 free (internal_relocs);
4337 goto error_ret_free_local;
4338 }
4339
4340 /* Only look for stubs on branch instructions. */
4341 if ((r_type != (unsigned int) R_ARM_CALL)
4342 && (r_type != (unsigned int) R_ARM_THM_CALL)
4343 && (r_type != (unsigned int) R_ARM_JUMP24)
4344 && (r_type != (unsigned int) R_ARM_THM_JUMP19)
4345 && (r_type != (unsigned int) R_ARM_THM_XPC22)
4346 && (r_type != (unsigned int) R_ARM_THM_JUMP24)
4347 && (r_type != (unsigned int) R_ARM_PLT32))
4348 continue;
4349
4350 /* Now determine the call target, its name, value,
4351 section. */
4352 sym_sec = NULL;
4353 sym_value = 0;
4354 destination = 0;
4355 hash = NULL;
4356 sym_name = NULL;
4357 if (r_indx < symtab_hdr->sh_info)
4358 {
4359 /* It's a local symbol. */
4360 Elf_Internal_Sym *sym;
4361 Elf_Internal_Shdr *hdr;
4362
4363 if (local_syms == NULL)
4364 {
4365 local_syms
4366 = (Elf_Internal_Sym *) symtab_hdr->contents;
4367 if (local_syms == NULL)
4368 local_syms
4369 = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
4370 symtab_hdr->sh_info, 0,
4371 NULL, NULL, NULL);
4372 if (local_syms == NULL)
4373 goto error_ret_free_internal;
4374 }
4375
4376 sym = local_syms + r_indx;
4377 hdr = elf_elfsections (input_bfd)[sym->st_shndx];
4378 sym_sec = hdr->bfd_section;
4379 if (!sym_sec)
4380 /* This is an undefined symbol. It can never
4381 be resolved. */
4382 continue;
4383
4384 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
4385 sym_value = sym->st_value;
4386 destination = (sym_value + irela->r_addend
4387 + sym_sec->output_offset
4388 + sym_sec->output_section->vma);
4389 st_type = ELF_ST_TYPE (sym->st_info);
4390 sym_name
4391 = bfd_elf_string_from_elf_section (input_bfd,
4392 symtab_hdr->sh_link,
4393 sym->st_name);
4394 }
4395 else
4396 {
4397 /* It's an external symbol. */
4398 int e_indx;
4399
4400 e_indx = r_indx - symtab_hdr->sh_info;
4401 hash = ((struct elf32_arm_link_hash_entry *)
4402 elf_sym_hashes (input_bfd)[e_indx]);
4403
4404 while (hash->root.root.type == bfd_link_hash_indirect
4405 || hash->root.root.type == bfd_link_hash_warning)
4406 hash = ((struct elf32_arm_link_hash_entry *)
4407 hash->root.root.u.i.link);
4408
4409 if (hash->root.root.type == bfd_link_hash_defined
4410 || hash->root.root.type == bfd_link_hash_defweak)
4411 {
4412 sym_sec = hash->root.root.u.def.section;
4413 sym_value = hash->root.root.u.def.value;
4414
4415 struct elf32_arm_link_hash_table *globals =
4416 elf32_arm_hash_table (info);
4417
4418 /* For a destination in a shared library,
4419 use the PLT stub as target address to
4420 decide whether a branch stub is
4421 needed. */
4422 if (globals->splt != NULL && hash != NULL
4423 && hash->root.plt.offset != (bfd_vma) -1)
4424 {
4425 sym_sec = globals->splt;
4426 sym_value = hash->root.plt.offset;
4427 if (sym_sec->output_section != NULL)
4428 destination = (sym_value
4429 + sym_sec->output_offset
4430 + sym_sec->output_section->vma);
4431 }
4432 else if (sym_sec->output_section != NULL)
4433 destination = (sym_value + irela->r_addend
4434 + sym_sec->output_offset
4435 + sym_sec->output_section->vma);
4436 }
4437 else if ((hash->root.root.type == bfd_link_hash_undefined)
4438 || (hash->root.root.type == bfd_link_hash_undefweak))
4439 {
4440 /* For a shared library, use the PLT stub as
4441 target address to decide whether a long
4442 branch stub is needed.
4443 For absolute code, they cannot be handled. */
4444 struct elf32_arm_link_hash_table *globals =
4445 elf32_arm_hash_table (info);
4446
4447 if (globals->splt != NULL && hash != NULL
4448 && hash->root.plt.offset != (bfd_vma) -1)
4449 {
4450 sym_sec = globals->splt;
4451 sym_value = hash->root.plt.offset;
4452 if (sym_sec->output_section != NULL)
4453 destination = (sym_value
4454 + sym_sec->output_offset
4455 + sym_sec->output_section->vma);
4456 }
4457 else
4458 continue;
4459 }
4460 else
4461 {
4462 bfd_set_error (bfd_error_bad_value);
4463 goto error_ret_free_internal;
4464 }
4465 st_type = ELF_ST_TYPE (hash->root.type);
4466 sym_name = hash->root.root.root.string;
4467 }
4468
4469 do
4470 {
4471 /* Determine what (if any) linker stub is needed. */
4472 stub_type = arm_type_of_stub (info, section, irela,
4473 st_type, hash,
4474 destination, sym_sec,
4475 input_bfd, sym_name);
4476 if (stub_type == arm_stub_none)
4477 break;
4478
4479 /* Support for grouping stub sections. */
4480 id_sec = htab->stub_group[section->id].link_sec;
4481
4482 /* Get the name of this stub. */
4483 stub_name = elf32_arm_stub_name (id_sec, sym_sec, hash,
4484 irela);
4485 if (!stub_name)
4486 goto error_ret_free_internal;
4487
4488 /* We've either created a stub for this reloc already,
4489 or we are about to. */
4490 created_stub = TRUE;
4491
4492 stub_entry = arm_stub_hash_lookup
4493 (&htab->stub_hash_table, stub_name,
4494 FALSE, FALSE);
4495 if (stub_entry != NULL)
4496 {
4497 /* The proper stub has already been created. */
4498 free (stub_name);
4499 stub_entry->target_value = sym_value;
4500 break;
4501 }
4502
4503 stub_entry = elf32_arm_add_stub (stub_name, section,
4504 htab);
4505 if (stub_entry == NULL)
4506 {
4507 free (stub_name);
4508 goto error_ret_free_internal;
4509 }
4510
4511 stub_entry->target_value = sym_value;
4512 stub_entry->target_section = sym_sec;
4513 stub_entry->stub_type = stub_type;
4514 stub_entry->h = hash;
4515 stub_entry->st_type = st_type;
4516
4517 if (sym_name == NULL)
4518 sym_name = "unnamed";
4519 stub_entry->output_name
4520 = bfd_alloc (htab->stub_bfd,
4521 sizeof (THUMB2ARM_GLUE_ENTRY_NAME)
4522 + strlen (sym_name));
4523 if (stub_entry->output_name == NULL)
4524 {
4525 free (stub_name);
4526 goto error_ret_free_internal;
4527 }
4528
4529 /* For historical reasons, use the existing names for
4530 ARM-to-Thumb and Thumb-to-ARM stubs. */
4531 if ( ((r_type == (unsigned int) R_ARM_THM_CALL)
4532 || (r_type == (unsigned int) R_ARM_THM_JUMP24))
4533 && st_type != STT_ARM_TFUNC)
4534 sprintf (stub_entry->output_name,
4535 THUMB2ARM_GLUE_ENTRY_NAME, sym_name);
4536 else if ( ((r_type == (unsigned int) R_ARM_CALL)
4537 || (r_type == (unsigned int) R_ARM_JUMP24))
4538 && st_type == STT_ARM_TFUNC)
4539 sprintf (stub_entry->output_name,
4540 ARM2THUMB_GLUE_ENTRY_NAME, sym_name);
4541 else
4542 sprintf (stub_entry->output_name, STUB_ENTRY_NAME,
4543 sym_name);
4544
4545 stub_changed = TRUE;
4546 }
4547 while (0);
4548
4549 /* Look for relocations which might trigger Cortex-A8
4550 erratum. */
4551 if (htab->fix_cortex_a8
4552 && (r_type == (unsigned int) R_ARM_THM_JUMP24
4553 || r_type == (unsigned int) R_ARM_THM_JUMP19
4554 || r_type == (unsigned int) R_ARM_THM_CALL
4555 || r_type == (unsigned int) R_ARM_THM_XPC22))
4556 {
4557 bfd_vma from = section->output_section->vma
4558 + section->output_offset
4559 + irela->r_offset;
4560
4561 if ((from & 0xfff) == 0xffe)
4562 {
4563 /* Found a candidate. Note we haven't checked the
4564 destination is within 4K here: if we do so (and
4565 don't create an entry in a8_relocs) we can't tell
4566 that a branch should have been relocated when
4567 scanning later. */
4568 if (num_a8_relocs == a8_reloc_table_size)
4569 {
4570 a8_reloc_table_size *= 2;
4571 a8_relocs = bfd_realloc (a8_relocs,
4572 sizeof (struct a8_erratum_reloc)
4573 * a8_reloc_table_size);
4574 }
4575
4576 a8_relocs[num_a8_relocs].from = from;
4577 a8_relocs[num_a8_relocs].destination = destination;
4578 a8_relocs[num_a8_relocs].r_type = r_type;
4579 a8_relocs[num_a8_relocs].st_type = st_type;
4580 a8_relocs[num_a8_relocs].sym_name = sym_name;
4581 a8_relocs[num_a8_relocs].non_a8_stub = created_stub;
4582
4583 num_a8_relocs++;
4584 }
4585 }
4586 }
4587
4588 /* We're done with the internal relocs, free them. */
4589 if (elf_section_data (section)->relocs == NULL)
4590 free (internal_relocs);
4591 }
4592
4593 if (htab->fix_cortex_a8)
4594 {
4595 /* Sort relocs which might apply to Cortex-A8 erratum. */
4596 qsort (a8_relocs, num_a8_relocs,
4597 sizeof (struct a8_erratum_reloc),
4598 &a8_reloc_compare);
4599
4600 /* Scan for branches which might trigger Cortex-A8 erratum. */
4601 if (cortex_a8_erratum_scan (input_bfd, info, &a8_fixes,
4602 &num_a8_fixes, &a8_fix_table_size,
4603 a8_relocs, num_a8_relocs,
4604 prev_num_a8_fixes, &stub_changed)
4605 != 0)
4606 goto error_ret_free_local;
4607 }
4608 }
4609
4610 if (prev_num_a8_fixes != num_a8_fixes)
4611 stub_changed = TRUE;
4612
4613 if (!stub_changed)
4614 break;
4615
4616 /* OK, we've added some stubs. Find out the new size of the
4617 stub sections. */
4618 for (stub_sec = htab->stub_bfd->sections;
4619 stub_sec != NULL;
4620 stub_sec = stub_sec->next)
4621 {
4622 /* Ignore non-stub sections. */
4623 if (!strstr (stub_sec->name, STUB_SUFFIX))
4624 continue;
4625
4626 stub_sec->size = 0;
4627 }
4628
4629 bfd_hash_traverse (&htab->stub_hash_table, arm_size_one_stub, htab);
4630
4631 /* Add Cortex-A8 erratum veneers to stub section sizes too. */
4632 if (htab->fix_cortex_a8)
4633 for (i = 0; i < num_a8_fixes; i++)
4634 {
4635 stub_sec = elf32_arm_create_or_find_stub_sec (NULL,
4636 a8_fixes[i].section, htab);
4637
4638 if (stub_sec == NULL)
4639 goto error_ret_free_local;
4640
4641 stub_sec->size
4642 += find_stub_size_and_template (a8_fixes[i].stub_type, NULL,
4643 NULL);
4644 }
4645
4646
4647 /* Ask the linker to do its stuff. */
4648 (*htab->layout_sections_again) ();
4649 }
4650
4651 /* Add stubs for Cortex-A8 erratum fixes now. */
4652 if (htab->fix_cortex_a8)
4653 {
4654 for (i = 0; i < num_a8_fixes; i++)
4655 {
4656 struct elf32_arm_stub_hash_entry *stub_entry;
4657 char *stub_name = a8_fixes[i].stub_name;
4658 asection *section = a8_fixes[i].section;
4659 unsigned int section_id = a8_fixes[i].section->id;
4660 asection *link_sec = htab->stub_group[section_id].link_sec;
4661 asection *stub_sec = htab->stub_group[section_id].stub_sec;
4662 const insn_sequence *template;
4663 int template_size, size = 0;
4664
4665 stub_entry = arm_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4666 TRUE, FALSE);
4667 if (stub_entry == NULL)
4668 {
4669 (*_bfd_error_handler) (_("%s: cannot create stub entry %s"),
4670 section->owner,
4671 stub_name);
4672 return FALSE;
4673 }
4674
4675 stub_entry->stub_sec = stub_sec;
4676 stub_entry->stub_offset = 0;
4677 stub_entry->id_sec = link_sec;
4678 stub_entry->stub_type = a8_fixes[i].stub_type;
4679 stub_entry->target_section = a8_fixes[i].section;
4680 stub_entry->target_value = a8_fixes[i].offset;
4681 stub_entry->target_addend = a8_fixes[i].addend;
4682 stub_entry->orig_insn = a8_fixes[i].orig_insn;
4683 stub_entry->st_type = STT_ARM_TFUNC;
4684
4685 size = find_stub_size_and_template (a8_fixes[i].stub_type, &template,
4686 &template_size);
4687
4688 stub_entry->stub_size = size;
4689 stub_entry->stub_template = template;
4690 stub_entry->stub_template_size = template_size;
4691 }
4692
4693 /* Stash the Cortex-A8 erratum fix array for use later in
4694 elf32_arm_write_section(). */
4695 htab->a8_erratum_fixes = a8_fixes;
4696 htab->num_a8_erratum_fixes = num_a8_fixes;
4697 }
4698 else
4699 {
4700 htab->a8_erratum_fixes = NULL;
4701 htab->num_a8_erratum_fixes = 0;
4702 }
4703 return TRUE;
4704
4705 error_ret_free_local:
4706 return FALSE;
4707 }
4708
4709 /* Build all the stubs associated with the current output file. The
4710 stubs are kept in a hash table attached to the main linker hash
4711 table. We also set up the .plt entries for statically linked PIC
4712 functions here. This function is called via arm_elf_finish in the
4713 linker. */
4714
4715 bfd_boolean
4716 elf32_arm_build_stubs (struct bfd_link_info *info)
4717 {
4718 asection *stub_sec;
4719 struct bfd_hash_table *table;
4720 struct elf32_arm_link_hash_table *htab;
4721
4722 htab = elf32_arm_hash_table (info);
4723
4724 for (stub_sec = htab->stub_bfd->sections;
4725 stub_sec != NULL;
4726 stub_sec = stub_sec->next)
4727 {
4728 bfd_size_type size;
4729
4730 /* Ignore non-stub sections. */
4731 if (!strstr (stub_sec->name, STUB_SUFFIX))
4732 continue;
4733
4734 /* Allocate memory to hold the linker stubs. */
4735 size = stub_sec->size;
4736 stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
4737 if (stub_sec->contents == NULL && size != 0)
4738 return FALSE;
4739 stub_sec->size = 0;
4740 }
4741
4742 /* Build the stubs as directed by the stub hash table. */
4743 table = &htab->stub_hash_table;
4744 bfd_hash_traverse (table, arm_build_one_stub, info);
4745 if (htab->fix_cortex_a8)
4746 {
4747 /* Place the cortex a8 stubs last. */
4748 htab->fix_cortex_a8 = -1;
4749 bfd_hash_traverse (table, arm_build_one_stub, info);
4750 }
4751
4752 return TRUE;
4753 }
4754
4755 /* Locate the Thumb encoded calling stub for NAME. */
4756
4757 static struct elf_link_hash_entry *
4758 find_thumb_glue (struct bfd_link_info *link_info,
4759 const char *name,
4760 char **error_message)
4761 {
4762 char *tmp_name;
4763 struct elf_link_hash_entry *hash;
4764 struct elf32_arm_link_hash_table *hash_table;
4765
4766 /* We need a pointer to the armelf specific hash table. */
4767 hash_table = elf32_arm_hash_table (link_info);
4768
4769 tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
4770 + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
4771
4772 BFD_ASSERT (tmp_name);
4773
4774 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
4775
4776 hash = elf_link_hash_lookup
4777 (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
4778
4779 if (hash == NULL
4780 && asprintf (error_message, _("unable to find THUMB glue '%s' for '%s'"),
4781 tmp_name, name) == -1)
4782 *error_message = (char *) bfd_errmsg (bfd_error_system_call);
4783
4784 free (tmp_name);
4785
4786 return hash;
4787 }
4788
4789 /* Locate the ARM encoded calling stub for NAME. */
4790
4791 static struct elf_link_hash_entry *
4792 find_arm_glue (struct bfd_link_info *link_info,
4793 const char *name,
4794 char **error_message)
4795 {
4796 char *tmp_name;
4797 struct elf_link_hash_entry *myh;
4798 struct elf32_arm_link_hash_table *hash_table;
4799
4800 /* We need a pointer to the elfarm specific hash table. */
4801 hash_table = elf32_arm_hash_table (link_info);
4802
4803 tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
4804 + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
4805
4806 BFD_ASSERT (tmp_name);
4807
4808 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
4809
4810 myh = elf_link_hash_lookup
4811 (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
4812
4813 if (myh == NULL
4814 && asprintf (error_message, _("unable to find ARM glue '%s' for '%s'"),
4815 tmp_name, name) == -1)
4816 *error_message = (char *) bfd_errmsg (bfd_error_system_call);
4817
4818 free (tmp_name);
4819
4820 return myh;
4821 }
4822
4823 /* ARM->Thumb glue (static images):
4824
4825 .arm
4826 __func_from_arm:
4827 ldr r12, __func_addr
4828 bx r12
4829 __func_addr:
4830 .word func @ behave as if you saw a ARM_32 reloc.
4831
4832 (v5t static images)
4833 .arm
4834 __func_from_arm:
4835 ldr pc, __func_addr
4836 __func_addr:
4837 .word func @ behave as if you saw a ARM_32 reloc.
4838
4839 (relocatable images)
4840 .arm
4841 __func_from_arm:
4842 ldr r12, __func_offset
4843 add r12, r12, pc
4844 bx r12
4845 __func_offset:
4846 .word func - . */
4847
4848 #define ARM2THUMB_STATIC_GLUE_SIZE 12
4849 static const insn32 a2t1_ldr_insn = 0xe59fc000;
4850 static const insn32 a2t2_bx_r12_insn = 0xe12fff1c;
4851 static const insn32 a2t3_func_addr_insn = 0x00000001;
4852
4853 #define ARM2THUMB_V5_STATIC_GLUE_SIZE 8
4854 static const insn32 a2t1v5_ldr_insn = 0xe51ff004;
4855 static const insn32 a2t2v5_func_addr_insn = 0x00000001;
4856
4857 #define ARM2THUMB_PIC_GLUE_SIZE 16
4858 static const insn32 a2t1p_ldr_insn = 0xe59fc004;
4859 static const insn32 a2t2p_add_pc_insn = 0xe08cc00f;
4860 static const insn32 a2t3p_bx_r12_insn = 0xe12fff1c;
4861
4862 /* Thumb->ARM: Thumb->(non-interworking aware) ARM
4863
4864 .thumb .thumb
4865 .align 2 .align 2
4866 __func_from_thumb: __func_from_thumb:
4867 bx pc push {r6, lr}
4868 nop ldr r6, __func_addr
4869 .arm mov lr, pc
4870 b func bx r6
4871 .arm
4872 ;; back_to_thumb
4873 ldmia r13! {r6, lr}
4874 bx lr
4875 __func_addr:
4876 .word func */
4877
4878 #define THUMB2ARM_GLUE_SIZE 8
4879 static const insn16 t2a1_bx_pc_insn = 0x4778;
4880 static const insn16 t2a2_noop_insn = 0x46c0;
4881 static const insn32 t2a3_b_insn = 0xea000000;
4882
4883 #define VFP11_ERRATUM_VENEER_SIZE 8
4884
4885 #define ARM_BX_VENEER_SIZE 12
4886 static const insn32 armbx1_tst_insn = 0xe3100001;
4887 static const insn32 armbx2_moveq_insn = 0x01a0f000;
4888 static const insn32 armbx3_bx_insn = 0xe12fff10;
4889
4890 #ifndef ELFARM_NABI_C_INCLUDED
4891 static void
4892 arm_allocate_glue_section_space (bfd * abfd, bfd_size_type size, const char * name)
4893 {
4894 asection * s;
4895 bfd_byte * contents;
4896
4897 if (size == 0)
4898 {
4899 /* Do not include empty glue sections in the output. */
4900 if (abfd != NULL)
4901 {
4902 s = bfd_get_section_by_name (abfd, name);
4903 if (s != NULL)
4904 s->flags |= SEC_EXCLUDE;
4905 }
4906 return;
4907 }
4908
4909 BFD_ASSERT (abfd != NULL);
4910
4911 s = bfd_get_section_by_name (abfd, name);
4912 BFD_ASSERT (s != NULL);
4913
4914 contents = bfd_alloc (abfd, size);
4915
4916 BFD_ASSERT (s->size == size);
4917 s->contents = contents;
4918 }
4919
4920 bfd_boolean
4921 bfd_elf32_arm_allocate_interworking_sections (struct bfd_link_info * info)
4922 {
4923 struct elf32_arm_link_hash_table * globals;
4924
4925 globals = elf32_arm_hash_table (info);
4926 BFD_ASSERT (globals != NULL);
4927
4928 arm_allocate_glue_section_space (globals->bfd_of_glue_owner,
4929 globals->arm_glue_size,
4930 ARM2THUMB_GLUE_SECTION_NAME);
4931
4932 arm_allocate_glue_section_space (globals->bfd_of_glue_owner,
4933 globals->thumb_glue_size,
4934 THUMB2ARM_GLUE_SECTION_NAME);
4935
4936 arm_allocate_glue_section_space (globals->bfd_of_glue_owner,
4937 globals->vfp11_erratum_glue_size,
4938 VFP11_ERRATUM_VENEER_SECTION_NAME);
4939
4940 arm_allocate_glue_section_space (globals->bfd_of_glue_owner,
4941 globals->bx_glue_size,
4942 ARM_BX_GLUE_SECTION_NAME);
4943
4944 return TRUE;
4945 }
4946
4947 /* Allocate space and symbols for calling a Thumb function from Arm mode.
4948 returns the symbol identifying the stub. */
4949
4950 static struct elf_link_hash_entry *
4951 record_arm_to_thumb_glue (struct bfd_link_info * link_info,
4952 struct elf_link_hash_entry * h)
4953 {
4954 const char * name = h->root.root.string;
4955 asection * s;
4956 char * tmp_name;
4957 struct elf_link_hash_entry * myh;
4958 struct bfd_link_hash_entry * bh;
4959 struct elf32_arm_link_hash_table * globals;
4960 bfd_vma val;
4961 bfd_size_type size;
4962
4963 globals = elf32_arm_hash_table (link_info);
4964
4965 BFD_ASSERT (globals != NULL);
4966 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
4967
4968 s = bfd_get_section_by_name
4969 (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
4970
4971 BFD_ASSERT (s != NULL);
4972
4973 tmp_name = bfd_malloc ((bfd_size_type) strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
4974
4975 BFD_ASSERT (tmp_name);
4976
4977 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
4978
4979 myh = elf_link_hash_lookup
4980 (&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
4981
4982 if (myh != NULL)
4983 {
4984 /* We've already seen this guy. */
4985 free (tmp_name);
4986 return myh;
4987 }
4988
4989 /* The only trick here is using hash_table->arm_glue_size as the value.
4990 Even though the section isn't allocated yet, this is where we will be
4991 putting it. The +1 on the value marks that the stub has not been
4992 output yet - not that it is a Thumb function. */
4993 bh = NULL;
4994 val = globals->arm_glue_size + 1;
4995 _bfd_generic_link_add_one_symbol (link_info, globals->bfd_of_glue_owner,
4996 tmp_name, BSF_GLOBAL, s, val,
4997 NULL, TRUE, FALSE, &bh);
4998
4999 myh = (struct elf_link_hash_entry *) bh;
5000 myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
5001 myh->forced_local = 1;
5002
5003 free (tmp_name);
5004
5005 if (link_info->shared || globals->root.is_relocatable_executable
5006 || globals->pic_veneer)
5007 size = ARM2THUMB_PIC_GLUE_SIZE;
5008 else if (globals->use_blx)
5009 size = ARM2THUMB_V5_STATIC_GLUE_SIZE;
5010 else
5011 size = ARM2THUMB_STATIC_GLUE_SIZE;
5012
5013 s->size += size;
5014 globals->arm_glue_size += size;
5015
5016 return myh;
5017 }
5018
5019 /* Allocate space for ARMv4 BX veneers. */
5020
5021 static void
5022 record_arm_bx_glue (struct bfd_link_info * link_info, int reg)
5023 {
5024 asection * s;
5025 struct elf32_arm_link_hash_table *globals;
5026 char *tmp_name;
5027 struct elf_link_hash_entry *myh;
5028 struct bfd_link_hash_entry *bh;
5029 bfd_vma val;
5030
5031 /* BX PC does not need a veneer. */
5032 if (reg == 15)
5033 return;
5034
5035 globals = elf32_arm_hash_table (link_info);
5036
5037 BFD_ASSERT (globals != NULL);
5038 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
5039
5040 /* Check if this veneer has already been allocated. */
5041 if (globals->bx_glue_offset[reg])
5042 return;
5043
5044 s = bfd_get_section_by_name
5045 (globals->bfd_of_glue_owner, ARM_BX_GLUE_SECTION_NAME);
5046
5047 BFD_ASSERT (s != NULL);
5048
5049 /* Add symbol for veneer. */
5050 tmp_name = bfd_malloc ((bfd_size_type) strlen (ARM_BX_GLUE_ENTRY_NAME) + 1);
5051
5052 BFD_ASSERT (tmp_name);
5053
5054 sprintf (tmp_name, ARM_BX_GLUE_ENTRY_NAME, reg);
5055
5056 myh = elf_link_hash_lookup
5057 (&(globals)->root, tmp_name, FALSE, FALSE, FALSE);
5058
5059 BFD_ASSERT (myh == NULL);
5060
5061 bh = NULL;
5062 val = globals->bx_glue_size;
5063 _bfd_generic_link_add_one_symbol (link_info, globals->bfd_of_glue_owner,
5064 tmp_name, BSF_FUNCTION | BSF_LOCAL, s, val,
5065 NULL, TRUE, FALSE, &bh);
5066
5067 myh = (struct elf_link_hash_entry *) bh;
5068 myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
5069 myh->forced_local = 1;
5070
5071 s->size += ARM_BX_VENEER_SIZE;
5072 globals->bx_glue_offset[reg] = globals->bx_glue_size | 2;
5073 globals->bx_glue_size += ARM_BX_VENEER_SIZE;
5074 }
5075
5076
5077 /* Add an entry to the code/data map for section SEC. */
5078
5079 static void
5080 elf32_arm_section_map_add (asection *sec, char type, bfd_vma vma)
5081 {
5082 struct _arm_elf_section_data *sec_data = elf32_arm_section_data (sec);
5083 unsigned int newidx;
5084
5085 if (sec_data->map == NULL)
5086 {
5087 sec_data->map = bfd_malloc (sizeof (elf32_arm_section_map));
5088 sec_data->mapcount = 0;
5089 sec_data->mapsize = 1;
5090 }
5091
5092 newidx = sec_data->mapcount++;
5093
5094 if (sec_data->mapcount > sec_data->mapsize)
5095 {
5096 sec_data->mapsize *= 2;
5097 sec_data->map = bfd_realloc_or_free (sec_data->map, sec_data->mapsize
5098 * sizeof (elf32_arm_section_map));
5099 }
5100
5101 if (sec_data->map)
5102 {
5103 sec_data->map[newidx].vma = vma;
5104 sec_data->map[newidx].type = type;
5105 }
5106 }
5107
5108
5109 /* Record information about a VFP11 denorm-erratum veneer. Only ARM-mode
5110 veneers are handled for now. */
5111
5112 static bfd_vma
5113 record_vfp11_erratum_veneer (struct bfd_link_info *link_info,
5114 elf32_vfp11_erratum_list *branch,
5115 bfd *branch_bfd,
5116 asection *branch_sec,
5117 unsigned int offset)
5118 {
5119 asection *s;
5120 struct elf32_arm_link_hash_table *hash_table;
5121 char *tmp_name;
5122 struct elf_link_hash_entry *myh;
5123 struct bfd_link_hash_entry *bh;
5124 bfd_vma val;
5125 struct _arm_elf_section_data *sec_data;
5126 int errcount;
5127 elf32_vfp11_erratum_list *newerr;
5128
5129 hash_table = elf32_arm_hash_table (link_info);
5130
5131 BFD_ASSERT (hash_table != NULL);
5132 BFD_ASSERT (hash_table->bfd_of_glue_owner != NULL);
5133
5134 s = bfd_get_section_by_name
5135 (hash_table->bfd_of_glue_owner, VFP11_ERRATUM_VENEER_SECTION_NAME);
5136
5137 sec_data = elf32_arm_section_data (s);
5138
5139 BFD_ASSERT (s != NULL);
5140
5141 tmp_name = bfd_malloc ((bfd_size_type) strlen
5142 (VFP11_ERRATUM_VENEER_ENTRY_NAME) + 10);
5143
5144 BFD_ASSERT (tmp_name);
5145
5146 sprintf (tmp_name, VFP11_ERRATUM_VENEER_ENTRY_NAME,
5147 hash_table->num_vfp11_fixes);
5148
5149 myh = elf_link_hash_lookup
5150 (&(hash_table)->root, tmp_name, FALSE, FALSE, FALSE);
5151
5152 BFD_ASSERT (myh == NULL);
5153
5154 bh = NULL;
5155 val = hash_table->vfp11_erratum_glue_size;
5156 _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
5157 tmp_name, BSF_FUNCTION | BSF_LOCAL, s, val,
5158 NULL, TRUE, FALSE, &bh);
5159
5160 myh = (struct elf_link_hash_entry *) bh;
5161 myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
5162 myh->forced_local = 1;
5163
5164 /* Link veneer back to calling location. */
5165 errcount = ++(sec_data->erratumcount);
5166 newerr = bfd_zmalloc (sizeof (elf32_vfp11_erratum_list));
5167
5168 newerr->type = VFP11_ERRATUM_ARM_VENEER;
5169 newerr->vma = -1;
5170 newerr->u.v.branch = branch;
5171 newerr->u.v.id = hash_table->num_vfp11_fixes;
5172 branch->u.b.veneer = newerr;
5173
5174 newerr->next = sec_data->erratumlist;
5175 sec_data->erratumlist = newerr;
5176
5177 /* A symbol for the return from the veneer. */
5178 sprintf (tmp_name, VFP11_ERRATUM_VENEER_ENTRY_NAME "_r",
5179 hash_table->num_vfp11_fixes);
5180
5181 myh = elf_link_hash_lookup
5182 (&(hash_table)->root, tmp_name, FALSE, FALSE, FALSE);
5183
5184 if (myh != NULL)
5185 abort ();
5186
5187 bh = NULL;
5188 val = offset + 4;
5189 _bfd_generic_link_add_one_symbol (link_info, branch_bfd, tmp_name, BSF_LOCAL,
5190 branch_sec, val, NULL, TRUE, FALSE, &bh);
5191
5192 myh = (struct elf_link_hash_entry *) bh;
5193 myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
5194 myh->forced_local = 1;
5195
5196 free (tmp_name);
5197
5198 /* Generate a mapping symbol for the veneer section, and explicitly add an
5199 entry for that symbol to the code/data map for the section. */
5200 if (hash_table->vfp11_erratum_glue_size == 0)
5201 {
5202 bh = NULL;
5203 /* FIXME: Creates an ARM symbol. Thumb mode will need attention if it
5204 ever requires this erratum fix. */
5205 _bfd_generic_link_add_one_symbol (link_info,
5206 hash_table->bfd_of_glue_owner, "$a",
5207 BSF_LOCAL, s, 0, NULL,
5208 TRUE, FALSE, &bh);
5209
5210 myh = (struct elf_link_hash_entry *) bh;
5211 myh->type = ELF_ST_INFO (STB_LOCAL, STT_NOTYPE);
5212 myh->forced_local = 1;
5213
5214 /* The elf32_arm_init_maps function only cares about symbols from input
5215 BFDs. We must make a note of this generated mapping symbol
5216 ourselves so that code byteswapping works properly in
5217 elf32_arm_write_section. */
5218 elf32_arm_section_map_add (s, 'a', 0);
5219 }
5220
5221 s->size += VFP11_ERRATUM_VENEER_SIZE;
5222 hash_table->vfp11_erratum_glue_size += VFP11_ERRATUM_VENEER_SIZE;
5223 hash_table->num_vfp11_fixes++;
5224
5225 /* The offset of the veneer. */
5226 return val;
5227 }
5228
5229 #define ARM_GLUE_SECTION_FLAGS \
5230 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_CODE \
5231 | SEC_READONLY | SEC_LINKER_CREATED)
5232
5233 /* Create a fake section for use by the ARM backend of the linker. */
5234
5235 static bfd_boolean
5236 arm_make_glue_section (bfd * abfd, const char * name)
5237 {
5238 asection * sec;
5239
5240 sec = bfd_get_section_by_name (abfd, name);
5241 if (sec != NULL)
5242 /* Already made. */
5243 return TRUE;
5244
5245 sec = bfd_make_section_with_flags (abfd, name, ARM_GLUE_SECTION_FLAGS);
5246
5247 if (sec == NULL
5248 || !bfd_set_section_alignment (abfd, sec, 2))
5249 return FALSE;
5250
5251 /* Set the gc mark to prevent the section from being removed by garbage
5252 collection, despite the fact that no relocs refer to this section. */
5253 sec->gc_mark = 1;
5254
5255 return TRUE;
5256 }
5257
5258 /* Add the glue sections to ABFD. This function is called from the
5259 linker scripts in ld/emultempl/{armelf}.em. */
5260
5261 bfd_boolean
5262 bfd_elf32_arm_add_glue_sections_to_bfd (bfd *abfd,
5263 struct bfd_link_info *info)
5264 {
5265 /* If we are only performing a partial
5266 link do not bother adding the glue. */
5267 if (info->relocatable)
5268 return TRUE;
5269
5270 return arm_make_glue_section (abfd, ARM2THUMB_GLUE_SECTION_NAME)
5271 && arm_make_glue_section (abfd, THUMB2ARM_GLUE_SECTION_NAME)
5272 && arm_make_glue_section (abfd, VFP11_ERRATUM_VENEER_SECTION_NAME)
5273 && arm_make_glue_section (abfd, ARM_BX_GLUE_SECTION_NAME);
5274 }
5275
5276 /* Select a BFD to be used to hold the sections used by the glue code.
5277 This function is called from the linker scripts in ld/emultempl/
5278 {armelf/pe}.em. */
5279
5280 bfd_boolean
5281 bfd_elf32_arm_get_bfd_for_interworking (bfd *abfd, struct bfd_link_info *info)
5282 {
5283 struct elf32_arm_link_hash_table *globals;
5284
5285 /* If we are only performing a partial link
5286 do not bother getting a bfd to hold the glue. */
5287 if (info->relocatable)
5288 return TRUE;
5289
5290 /* Make sure we don't attach the glue sections to a dynamic object. */
5291 BFD_ASSERT (!(abfd->flags & DYNAMIC));
5292
5293 globals = elf32_arm_hash_table (info);
5294
5295 BFD_ASSERT (globals != NULL);
5296
5297 if (globals->bfd_of_glue_owner != NULL)
5298 return TRUE;
5299
5300 /* Save the bfd for later use. */
5301 globals->bfd_of_glue_owner = abfd;
5302
5303 return TRUE;
5304 }
5305
5306 static void
5307 check_use_blx (struct elf32_arm_link_hash_table *globals)
5308 {
5309 if (bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC,
5310 Tag_CPU_arch) > 2)
5311 globals->use_blx = 1;
5312 }
5313
5314 bfd_boolean
5315 bfd_elf32_arm_process_before_allocation (bfd *abfd,
5316 struct bfd_link_info *link_info)
5317 {
5318 Elf_Internal_Shdr *symtab_hdr;
5319 Elf_Internal_Rela *internal_relocs = NULL;
5320 Elf_Internal_Rela *irel, *irelend;
5321 bfd_byte *contents = NULL;
5322
5323 asection *sec;
5324 struct elf32_arm_link_hash_table *globals;
5325
5326 /* If we are only performing a partial link do not bother
5327 to construct any glue. */
5328 if (link_info->relocatable)
5329 return TRUE;
5330
5331 /* Here we have a bfd that is to be included on the link. We have a
5332 hook to do reloc rummaging, before section sizes are nailed down. */
5333 globals = elf32_arm_hash_table (link_info);
5334
5335 BFD_ASSERT (globals != NULL);
5336
5337 check_use_blx (globals);
5338
5339 if (globals->byteswap_code && !bfd_big_endian (abfd))
5340 {
5341 _bfd_error_handler (_("%B: BE8 images only valid in big-endian mode."),
5342 abfd);
5343 return FALSE;
5344 }
5345
5346 /* PR 5398: If we have not decided to include any loadable sections in
5347 the output then we will not have a glue owner bfd. This is OK, it
5348 just means that there is nothing else for us to do here. */
5349 if (globals->bfd_of_glue_owner == NULL)
5350 return TRUE;
5351
5352 /* Rummage around all the relocs and map the glue vectors. */
5353 sec = abfd->sections;
5354
5355 if (sec == NULL)
5356 return TRUE;
5357
5358 for (; sec != NULL; sec = sec->next)
5359 {
5360 if (sec->reloc_count == 0)
5361 continue;
5362
5363 if ((sec->flags & SEC_EXCLUDE) != 0)
5364 continue;
5365
5366 symtab_hdr = & elf_symtab_hdr (abfd);
5367
5368 /* Load the relocs. */
5369 internal_relocs
5370 = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, FALSE);
5371
5372 if (internal_relocs == NULL)
5373 goto error_return;
5374
5375 irelend = internal_relocs + sec->reloc_count;
5376 for (irel = internal_relocs; irel < irelend; irel++)
5377 {
5378 long r_type;
5379 unsigned long r_index;
5380
5381 struct elf_link_hash_entry *h;
5382
5383 r_type = ELF32_R_TYPE (irel->r_info);
5384 r_index = ELF32_R_SYM (irel->r_info);
5385
5386 /* These are the only relocation types we care about. */
5387 if ( r_type != R_ARM_PC24
5388 && (r_type != R_ARM_V4BX || globals->fix_v4bx < 2))
5389 continue;
5390
5391 /* Get the section contents if we haven't done so already. */
5392 if (contents == NULL)
5393 {
5394 /* Get cached copy if it exists. */
5395 if (elf_section_data (sec)->this_hdr.contents != NULL)
5396 contents = elf_section_data (sec)->this_hdr.contents;
5397 else
5398 {
5399 /* Go get them off disk. */
5400 if (! bfd_malloc_and_get_section (abfd, sec, &contents))
5401 goto error_return;
5402 }
5403 }
5404
5405 if (r_type == R_ARM_V4BX)
5406 {
5407 int reg;
5408
5409 reg = bfd_get_32 (abfd, contents + irel->r_offset) & 0xf;
5410 record_arm_bx_glue (link_info, reg);
5411 continue;
5412 }
5413
5414 /* If the relocation is not against a symbol it cannot concern us. */
5415 h = NULL;
5416
5417 /* We don't care about local symbols. */
5418 if (r_index < symtab_hdr->sh_info)
5419 continue;
5420
5421 /* This is an external symbol. */
5422 r_index -= symtab_hdr->sh_info;
5423 h = (struct elf_link_hash_entry *)
5424 elf_sym_hashes (abfd)[r_index];
5425
5426 /* If the relocation is against a static symbol it must be within
5427 the current section and so cannot be a cross ARM/Thumb relocation. */
5428 if (h == NULL)
5429 continue;
5430
5431 /* If the call will go through a PLT entry then we do not need
5432 glue. */
5433 if (globals->splt != NULL && h->plt.offset != (bfd_vma) -1)
5434 continue;
5435
5436 switch (r_type)
5437 {
5438 case R_ARM_PC24:
5439 /* This one is a call from arm code. We need to look up
5440 the target of the call. If it is a thumb target, we
5441 insert glue. */
5442 if (ELF_ST_TYPE (h->type) == STT_ARM_TFUNC)
5443 record_arm_to_thumb_glue (link_info, h);
5444 break;
5445
5446 default:
5447 abort ();
5448 }
5449 }
5450
5451 if (contents != NULL
5452 && elf_section_data (sec)->this_hdr.contents != contents)
5453 free (contents);
5454 contents = NULL;
5455
5456 if (internal_relocs != NULL
5457 && elf_section_data (sec)->relocs != internal_relocs)
5458 free (internal_relocs);
5459 internal_relocs = NULL;
5460 }
5461
5462 return TRUE;
5463
5464 error_return:
5465 if (contents != NULL
5466 && elf_section_data (sec)->this_hdr.contents != contents)
5467 free (contents);
5468 if (internal_relocs != NULL
5469 && elf_section_data (sec)->relocs != internal_relocs)
5470 free (internal_relocs);
5471
5472 return FALSE;
5473 }
5474 #endif
5475
5476
5477 /* Initialise maps of ARM/Thumb/data for input BFDs. */
5478
5479 void
5480 bfd_elf32_arm_init_maps (bfd *abfd)
5481 {
5482 Elf_Internal_Sym *isymbuf;
5483 Elf_Internal_Shdr *hdr;
5484 unsigned int i, localsyms;
5485
5486 /* PR 7093: Make sure that we are dealing with an arm elf binary. */
5487 if (! is_arm_elf (abfd))
5488 return;
5489
5490 if ((abfd->flags & DYNAMIC) != 0)
5491 return;
5492
5493 hdr = & elf_symtab_hdr (abfd);
5494 localsyms = hdr->sh_info;
5495
5496 /* Obtain a buffer full of symbols for this BFD. The hdr->sh_info field
5497 should contain the number of local symbols, which should come before any
5498 global symbols. Mapping symbols are always local. */
5499 isymbuf = bfd_elf_get_elf_syms (abfd, hdr, localsyms, 0, NULL, NULL,
5500 NULL);
5501
5502 /* No internal symbols read? Skip this BFD. */
5503 if (isymbuf == NULL)
5504 return;
5505
5506 for (i = 0; i < localsyms; i++)
5507 {
5508 Elf_Internal_Sym *isym = &isymbuf[i];
5509 asection *sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
5510 const char *name;
5511
5512 if (sec != NULL
5513 && ELF_ST_BIND (isym->st_info) == STB_LOCAL)
5514 {
5515 name = bfd_elf_string_from_elf_section (abfd,
5516 hdr->sh_link, isym->st_name);
5517
5518 if (bfd_is_arm_special_symbol_name (name,
5519 BFD_ARM_SPECIAL_SYM_TYPE_MAP))
5520 elf32_arm_section_map_add (sec, name[1], isym->st_value);
5521 }
5522 }
5523 }
5524
5525
5526 /* Auto-select enabling of Cortex-A8 erratum fix if the user didn't explicitly
5527 say what they wanted. */
5528
5529 void
5530 bfd_elf32_arm_set_cortex_a8_fix (bfd *obfd, struct bfd_link_info *link_info)
5531 {
5532 struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (link_info);
5533 obj_attribute *out_attr = elf_known_obj_attributes_proc (obfd);
5534
5535 if (globals->fix_cortex_a8 == -1)
5536 {
5537 /* Turn on Cortex-A8 erratum workaround for ARMv7-A. */
5538 if (out_attr[Tag_CPU_arch].i == TAG_CPU_ARCH_V7
5539 && (out_attr[Tag_CPU_arch_profile].i == 'A'
5540 || out_attr[Tag_CPU_arch_profile].i == 0))
5541 globals->fix_cortex_a8 = 1;
5542 else
5543 globals->fix_cortex_a8 = 0;
5544 }
5545 }
5546
5547
5548 void
5549 bfd_elf32_arm_set_vfp11_fix (bfd *obfd, struct bfd_link_info *link_info)
5550 {
5551 struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (link_info);
5552 obj_attribute *out_attr = elf_known_obj_attributes_proc (obfd);
5553
5554 /* We assume that ARMv7+ does not need the VFP11 denorm erratum fix. */
5555 if (out_attr[Tag_CPU_arch].i >= TAG_CPU_ARCH_V7)
5556 {
5557 switch (globals->vfp11_fix)
5558 {
5559 case BFD_ARM_VFP11_FIX_DEFAULT:
5560 case BFD_ARM_VFP11_FIX_NONE:
5561 globals->vfp11_fix = BFD_ARM_VFP11_FIX_NONE;
5562 break;
5563
5564 default:
5565 /* Give a warning, but do as the user requests anyway. */
5566 (*_bfd_error_handler) (_("%B: warning: selected VFP11 erratum "
5567 "workaround is not necessary for target architecture"), obfd);
5568 }
5569 }
5570 else if (globals->vfp11_fix == BFD_ARM_VFP11_FIX_DEFAULT)
5571 /* For earlier architectures, we might need the workaround, but do not
5572 enable it by default. If users is running with broken hardware, they
5573 must enable the erratum fix explicitly. */
5574 globals->vfp11_fix = BFD_ARM_VFP11_FIX_NONE;
5575 }
5576
5577
5578 enum bfd_arm_vfp11_pipe
5579 {
5580 VFP11_FMAC,
5581 VFP11_LS,
5582 VFP11_DS,
5583 VFP11_BAD
5584 };
5585
5586 /* Return a VFP register number. This is encoded as RX:X for single-precision
5587 registers, or X:RX for double-precision registers, where RX is the group of
5588 four bits in the instruction encoding and X is the single extension bit.
5589 RX and X fields are specified using their lowest (starting) bit. The return
5590 value is:
5591
5592 0...31: single-precision registers s0...s31
5593 32...63: double-precision registers d0...d31.
5594
5595 Although X should be zero for VFP11 (encoding d0...d15 only), we might
5596 encounter VFP3 instructions, so we allow the full range for DP registers. */
5597
5598 static unsigned int
5599 bfd_arm_vfp11_regno (unsigned int insn, bfd_boolean is_double, unsigned int rx,
5600 unsigned int x)
5601 {
5602 if (is_double)
5603 return (((insn >> rx) & 0xf) | (((insn >> x) & 1) << 4)) + 32;
5604 else
5605 return (((insn >> rx) & 0xf) << 1) | ((insn >> x) & 1);
5606 }
5607
5608 /* Set bits in *WMASK according to a register number REG as encoded by
5609 bfd_arm_vfp11_regno(). Ignore d16-d31. */
5610
5611 static void
5612 bfd_arm_vfp11_write_mask (unsigned int *wmask, unsigned int reg)
5613 {
5614 if (reg < 32)
5615 *wmask |= 1 << reg;
5616 else if (reg < 48)
5617 *wmask |= 3 << ((reg - 32) * 2);
5618 }
5619
5620 /* Return TRUE if WMASK overwrites anything in REGS. */
5621
5622 static bfd_boolean
5623 bfd_arm_vfp11_antidependency (unsigned int wmask, int *regs, int numregs)
5624 {
5625 int i;
5626
5627 for (i = 0; i < numregs; i++)
5628 {
5629 unsigned int reg = regs[i];
5630
5631 if (reg < 32 && (wmask & (1 << reg)) != 0)
5632 return TRUE;
5633
5634 reg -= 32;
5635
5636 if (reg >= 16)
5637 continue;
5638
5639 if ((wmask & (3 << (reg * 2))) != 0)
5640 return TRUE;
5641 }
5642
5643 return FALSE;
5644 }
5645
5646 /* In this function, we're interested in two things: finding input registers
5647 for VFP data-processing instructions, and finding the set of registers which
5648 arbitrary VFP instructions may write to. We use a 32-bit unsigned int to
5649 hold the written set, so FLDM etc. are easy to deal with (we're only
5650 interested in 32 SP registers or 16 dp registers, due to the VFP version
5651 implemented by the chip in question). DP registers are marked by setting
5652 both SP registers in the write mask). */
5653
5654 static enum bfd_arm_vfp11_pipe
5655 bfd_arm_vfp11_insn_decode (unsigned int insn, unsigned int *destmask, int *regs,
5656 int *numregs)
5657 {
5658 enum bfd_arm_vfp11_pipe pipe = VFP11_BAD;
5659 bfd_boolean is_double = ((insn & 0xf00) == 0xb00) ? 1 : 0;
5660
5661 if ((insn & 0x0f000e10) == 0x0e000a00) /* A data-processing insn. */
5662 {
5663 unsigned int pqrs;
5664 unsigned int fd = bfd_arm_vfp11_regno (insn, is_double, 12, 22);
5665 unsigned int fm = bfd_arm_vfp11_regno (insn, is_double, 0, 5);
5666
5667 pqrs = ((insn & 0x00800000) >> 20)
5668 | ((insn & 0x00300000) >> 19)
5669 | ((insn & 0x00000040) >> 6);
5670
5671 switch (pqrs)
5672 {
5673 case 0: /* fmac[sd]. */
5674 case 1: /* fnmac[sd]. */
5675 case 2: /* fmsc[sd]. */
5676 case 3: /* fnmsc[sd]. */
5677 pipe = VFP11_FMAC;
5678 bfd_arm_vfp11_write_mask (destmask, fd);
5679 regs[0] = fd;
5680 regs[1] = bfd_arm_vfp11_regno (insn, is_double, 16, 7); /* Fn. */
5681 regs[2] = fm;
5682 *numregs = 3;
5683 break;
5684
5685 case 4: /* fmul[sd]. */
5686 case 5: /* fnmul[sd]. */
5687 case 6: /* fadd[sd]. */
5688 case 7: /* fsub[sd]. */
5689 pipe = VFP11_FMAC;
5690 goto vfp_binop;
5691
5692 case 8: /* fdiv[sd]. */
5693 pipe = VFP11_DS;
5694 vfp_binop:
5695 bfd_arm_vfp11_write_mask (destmask, fd);
5696 regs[0] = bfd_arm_vfp11_regno (insn, is_double, 16, 7); /* Fn. */
5697 regs[1] = fm;
5698 *numregs = 2;
5699 break;
5700
5701 case 15: /* extended opcode. */
5702 {
5703 unsigned int extn = ((insn >> 15) & 0x1e)
5704 | ((insn >> 7) & 1);
5705
5706 switch (extn)
5707 {
5708 case 0: /* fcpy[sd]. */
5709 case 1: /* fabs[sd]. */
5710 case 2: /* fneg[sd]. */
5711 case 8: /* fcmp[sd]. */
5712 case 9: /* fcmpe[sd]. */
5713 case 10: /* fcmpz[sd]. */
5714 case 11: /* fcmpez[sd]. */
5715 case 16: /* fuito[sd]. */
5716 case 17: /* fsito[sd]. */
5717 case 24: /* ftoui[sd]. */
5718 case 25: /* ftouiz[sd]. */
5719 case 26: /* ftosi[sd]. */
5720 case 27: /* ftosiz[sd]. */
5721 /* These instructions will not bounce due to underflow. */
5722 *numregs = 0;
5723 pipe = VFP11_FMAC;
5724 break;
5725
5726 case 3: /* fsqrt[sd]. */
5727 /* fsqrt cannot underflow, but it can (perhaps) overwrite
5728 registers to cause the erratum in previous instructions. */
5729 bfd_arm_vfp11_write_mask (destmask, fd);
5730 pipe = VFP11_DS;
5731 break;
5732
5733 case 15: /* fcvt{ds,sd}. */
5734 {
5735 int rnum = 0;
5736
5737 bfd_arm_vfp11_write_mask (destmask, fd);
5738
5739 /* Only FCVTSD can underflow. */
5740 if ((insn & 0x100) != 0)
5741 regs[rnum++] = fm;
5742
5743 *numregs = rnum;
5744
5745 pipe = VFP11_FMAC;
5746 }
5747 break;
5748
5749 default:
5750 return VFP11_BAD;
5751 }
5752 }
5753 break;
5754
5755 default:
5756 return VFP11_BAD;
5757 }
5758 }
5759 /* Two-register transfer. */
5760 else if ((insn & 0x0fe00ed0) == 0x0c400a10)
5761 {
5762 unsigned int fm = bfd_arm_vfp11_regno (insn, is_double, 0, 5);
5763
5764 if ((insn & 0x100000) == 0)
5765 {
5766 if (is_double)
5767 bfd_arm_vfp11_write_mask (destmask, fm);
5768 else
5769 {
5770 bfd_arm_vfp11_write_mask (destmask, fm);
5771 bfd_arm_vfp11_write_mask (destmask, fm + 1);
5772 }
5773 }
5774
5775 pipe = VFP11_LS;
5776 }
5777 else if ((insn & 0x0e100e00) == 0x0c100a00) /* A load insn. */
5778 {
5779 int fd = bfd_arm_vfp11_regno (insn, is_double, 12, 22);
5780 unsigned int puw = ((insn >> 21) & 0x1) | (((insn >> 23) & 3) << 1);
5781
5782 switch (puw)
5783 {
5784 case 0: /* Two-reg transfer. We should catch these above. */
5785 abort ();
5786
5787 case 2: /* fldm[sdx]. */
5788 case 3:
5789 case 5:
5790 {
5791 unsigned int i, offset = insn & 0xff;
5792
5793 if (is_double)
5794 offset >>= 1;
5795
5796 for (i = fd; i < fd + offset; i++)
5797 bfd_arm_vfp11_write_mask (destmask, i);
5798 }
5799 break;
5800
5801 case 4: /* fld[sd]. */
5802 case 6:
5803 bfd_arm_vfp11_write_mask (destmask, fd);
5804 break;
5805
5806 default:
5807 return VFP11_BAD;
5808 }
5809
5810 pipe = VFP11_LS;
5811 }
5812 /* Single-register transfer. Note L==0. */
5813 else if ((insn & 0x0f100e10) == 0x0e000a10)
5814 {
5815 unsigned int opcode = (insn >> 21) & 7;
5816 unsigned int fn = bfd_arm_vfp11_regno (insn, is_double, 16, 7);
5817
5818 switch (opcode)
5819 {
5820 case 0: /* fmsr/fmdlr. */
5821 case 1: /* fmdhr. */
5822 /* Mark fmdhr and fmdlr as writing to the whole of the DP
5823 destination register. I don't know if this is exactly right,
5824 but it is the conservative choice. */
5825 bfd_arm_vfp11_write_mask (destmask, fn);
5826 break;
5827
5828 case 7: /* fmxr. */
5829 break;
5830 }
5831
5832 pipe = VFP11_LS;
5833 }
5834
5835 return pipe;
5836 }
5837
5838
5839 static int elf32_arm_compare_mapping (const void * a, const void * b);
5840
5841
5842 /* Look for potentially-troublesome code sequences which might trigger the
5843 VFP11 denormal/antidependency erratum. See, e.g., the ARM1136 errata sheet
5844 (available from ARM) for details of the erratum. A short version is
5845 described in ld.texinfo. */
5846
5847 bfd_boolean
5848 bfd_elf32_arm_vfp11_erratum_scan (bfd *abfd, struct bfd_link_info *link_info)
5849 {
5850 asection *sec;
5851 bfd_byte *contents = NULL;
5852 int state = 0;
5853 int regs[3], numregs = 0;
5854 struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (link_info);
5855 int use_vector = (globals->vfp11_fix == BFD_ARM_VFP11_FIX_VECTOR);
5856
5857 /* We use a simple FSM to match troublesome VFP11 instruction sequences.
5858 The states transition as follows:
5859
5860 0 -> 1 (vector) or 0 -> 2 (scalar)
5861 A VFP FMAC-pipeline instruction has been seen. Fill
5862 regs[0]..regs[numregs-1] with its input operands. Remember this
5863 instruction in 'first_fmac'.
5864
5865 1 -> 2
5866 Any instruction, except for a VFP instruction which overwrites
5867 regs[*].
5868
5869 1 -> 3 [ -> 0 ] or
5870 2 -> 3 [ -> 0 ]
5871 A VFP instruction has been seen which overwrites any of regs[*].
5872 We must make a veneer! Reset state to 0 before examining next
5873 instruction.
5874
5875 2 -> 0
5876 If we fail to match anything in state 2, reset to state 0 and reset
5877 the instruction pointer to the instruction after 'first_fmac'.
5878
5879 If the VFP11 vector mode is in use, there must be at least two unrelated
5880 instructions between anti-dependent VFP11 instructions to properly avoid
5881 triggering the erratum, hence the use of the extra state 1. */
5882
5883 /* If we are only performing a partial link do not bother
5884 to construct any glue. */
5885 if (link_info->relocatable)
5886 return TRUE;
5887
5888 /* Skip if this bfd does not correspond to an ELF image. */
5889 if (! is_arm_elf (abfd))
5890 return TRUE;
5891
5892 /* We should have chosen a fix type by the time we get here. */
5893 BFD_ASSERT (globals->vfp11_fix != BFD_ARM_VFP11_FIX_DEFAULT);
5894
5895 if (globals->vfp11_fix == BFD_ARM_VFP11_FIX_NONE)
5896 return TRUE;
5897
5898 /* Skip this BFD if it corresponds to an executable or dynamic object. */
5899 if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
5900 return TRUE;
5901
5902 for (sec = abfd->sections; sec != NULL; sec = sec->next)
5903 {
5904 unsigned int i, span, first_fmac = 0, veneer_of_insn = 0;
5905 struct _arm_elf_section_data *sec_data;
5906
5907 /* If we don't have executable progbits, we're not interested in this
5908 section. Also skip if section is to be excluded. */
5909 if (elf_section_type (sec) != SHT_PROGBITS
5910 || (elf_section_flags (sec) & SHF_EXECINSTR) == 0
5911 || (sec->flags & SEC_EXCLUDE) != 0
5912 || sec->sec_info_type == ELF_INFO_TYPE_JUST_SYMS
5913 || sec->output_section == bfd_abs_section_ptr
5914 || strcmp (sec->name, VFP11_ERRATUM_VENEER_SECTION_NAME) == 0)
5915 continue;
5916
5917 sec_data = elf32_arm_section_data (sec);
5918
5919 if (sec_data->mapcount == 0)
5920 continue;
5921
5922 if (elf_section_data (sec)->this_hdr.contents != NULL)
5923 contents = elf_section_data (sec)->this_hdr.contents;
5924 else if (! bfd_malloc_and_get_section (abfd, sec, &contents))
5925 goto error_return;
5926
5927 qsort (sec_data->map, sec_data->mapcount, sizeof (elf32_arm_section_map),
5928 elf32_arm_compare_mapping);
5929
5930 for (span = 0; span < sec_data->mapcount; span++)
5931 {
5932 unsigned int span_start = sec_data->map[span].vma;
5933 unsigned int span_end = (span == sec_data->mapcount - 1)
5934 ? sec->size : sec_data->map[span + 1].vma;
5935 char span_type = sec_data->map[span].type;
5936
5937 /* FIXME: Only ARM mode is supported at present. We may need to
5938 support Thumb-2 mode also at some point. */
5939 if (span_type != 'a')
5940 continue;
5941
5942 for (i = span_start; i < span_end;)
5943 {
5944 unsigned int next_i = i + 4;
5945 unsigned int insn = bfd_big_endian (abfd)
5946 ? (contents[i] << 24)
5947 | (contents[i + 1] << 16)
5948 | (contents[i + 2] << 8)
5949 | contents[i + 3]
5950 : (contents[i + 3] << 24)
5951 | (contents[i + 2] << 16)
5952 | (contents[i + 1] << 8)
5953 | contents[i];
5954 unsigned int writemask = 0;
5955 enum bfd_arm_vfp11_pipe pipe;
5956
5957 switch (state)
5958 {
5959 case 0:
5960 pipe = bfd_arm_vfp11_insn_decode (insn, &writemask, regs,
5961 &numregs);
5962 /* I'm assuming the VFP11 erratum can trigger with denorm
5963 operands on either the FMAC or the DS pipeline. This might
5964 lead to slightly overenthusiastic veneer insertion. */
5965 if (pipe == VFP11_FMAC || pipe == VFP11_DS)
5966 {
5967 state = use_vector ? 1 : 2;
5968 first_fmac = i;
5969 veneer_of_insn = insn;
5970 }
5971 break;
5972
5973 case 1:
5974 {
5975 int other_regs[3], other_numregs;
5976 pipe = bfd_arm_vfp11_insn_decode (insn, &writemask,
5977 other_regs,
5978 &other_numregs);
5979 if (pipe != VFP11_BAD
5980 && bfd_arm_vfp11_antidependency (writemask, regs,
5981 numregs))
5982 state = 3;
5983 else
5984 state = 2;
5985 }
5986 break;
5987
5988 case 2:
5989 {
5990 int other_regs[3], other_numregs;
5991 pipe = bfd_arm_vfp11_insn_decode (insn, &writemask,
5992 other_regs,
5993 &other_numregs);
5994 if (pipe != VFP11_BAD
5995 && bfd_arm_vfp11_antidependency (writemask, regs,
5996 numregs))
5997 state = 3;
5998 else
5999 {
6000 state = 0;
6001 next_i = first_fmac + 4;
6002 }
6003 }
6004 break;
6005
6006 case 3:
6007 abort (); /* Should be unreachable. */
6008 }
6009
6010 if (state == 3)
6011 {
6012 elf32_vfp11_erratum_list *newerr
6013 = bfd_zmalloc (sizeof (elf32_vfp11_erratum_list));
6014 int errcount;
6015
6016 errcount = ++(elf32_arm_section_data (sec)->erratumcount);
6017
6018 newerr->u.b.vfp_insn = veneer_of_insn;
6019
6020 switch (span_type)
6021 {
6022 case 'a':
6023 newerr->type = VFP11_ERRATUM_BRANCH_TO_ARM_VENEER;
6024 break;
6025
6026 default:
6027 abort ();
6028 }
6029
6030 record_vfp11_erratum_veneer (link_info, newerr, abfd, sec,
6031 first_fmac);
6032
6033 newerr->vma = -1;
6034
6035 newerr->next = sec_data->erratumlist;
6036 sec_data->erratumlist = newerr;
6037
6038 state = 0;
6039 }
6040
6041 i = next_i;
6042 }
6043 }
6044
6045 if (contents != NULL
6046 && elf_section_data (sec)->this_hdr.contents != contents)
6047 free (contents);
6048 contents = NULL;
6049 }
6050
6051 return TRUE;
6052
6053 error_return:
6054 if (contents != NULL
6055 && elf_section_data (sec)->this_hdr.contents != contents)
6056 free (contents);
6057
6058 return FALSE;
6059 }
6060
6061 /* Find virtual-memory addresses for VFP11 erratum veneers and return locations
6062 after sections have been laid out, using specially-named symbols. */
6063
6064 void
6065 bfd_elf32_arm_vfp11_fix_veneer_locations (bfd *abfd,
6066 struct bfd_link_info *link_info)
6067 {
6068 asection *sec;
6069 struct elf32_arm_link_hash_table *globals;
6070 char *tmp_name;
6071
6072 if (link_info->relocatable)
6073 return;
6074
6075 /* Skip if this bfd does not correspond to an ELF image. */
6076 if (! is_arm_elf (abfd))
6077 return;
6078
6079 globals = elf32_arm_hash_table (link_info);
6080
6081 tmp_name = bfd_malloc ((bfd_size_type) strlen
6082 (VFP11_ERRATUM_VENEER_ENTRY_NAME) + 10);
6083
6084 for (sec = abfd->sections; sec != NULL; sec = sec->next)
6085 {
6086 struct _arm_elf_section_data *sec_data = elf32_arm_section_data (sec);
6087 elf32_vfp11_erratum_list *errnode = sec_data->erratumlist;
6088
6089 for (; errnode != NULL; errnode = errnode->next)
6090 {
6091 struct elf_link_hash_entry *myh;
6092 bfd_vma vma;
6093
6094 switch (errnode->type)
6095 {
6096 case VFP11_ERRATUM_BRANCH_TO_ARM_VENEER:
6097 case VFP11_ERRATUM_BRANCH_TO_THUMB_VENEER:
6098 /* Find veneer symbol. */
6099 sprintf (tmp_name, VFP11_ERRATUM_VENEER_ENTRY_NAME,
6100 errnode->u.b.veneer->u.v.id);
6101
6102 myh = elf_link_hash_lookup
6103 (&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
6104
6105 if (myh == NULL)
6106 (*_bfd_error_handler) (_("%B: unable to find VFP11 veneer "
6107 "`%s'"), abfd, tmp_name);
6108
6109 vma = myh->root.u.def.section->output_section->vma
6110 + myh->root.u.def.section->output_offset
6111 + myh->root.u.def.value;
6112
6113 errnode->u.b.veneer->vma = vma;
6114 break;
6115
6116 case VFP11_ERRATUM_ARM_VENEER:
6117 case VFP11_ERRATUM_THUMB_VENEER:
6118 /* Find return location. */
6119 sprintf (tmp_name, VFP11_ERRATUM_VENEER_ENTRY_NAME "_r",
6120 errnode->u.v.id);
6121
6122 myh = elf_link_hash_lookup
6123 (&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
6124
6125 if (myh == NULL)
6126 (*_bfd_error_handler) (_("%B: unable to find VFP11 veneer "
6127 "`%s'"), abfd, tmp_name);
6128
6129 vma = myh->root.u.def.section->output_section->vma
6130 + myh->root.u.def.section->output_offset
6131 + myh->root.u.def.value;
6132
6133 errnode->u.v.branch->vma = vma;
6134 break;
6135
6136 default:
6137 abort ();
6138 }
6139 }
6140 }
6141
6142 free (tmp_name);
6143 }
6144
6145
6146 /* Set target relocation values needed during linking. */
6147
6148 void
6149 bfd_elf32_arm_set_target_relocs (struct bfd *output_bfd,
6150 struct bfd_link_info *link_info,
6151 int target1_is_rel,
6152 char * target2_type,
6153 int fix_v4bx,
6154 int use_blx,
6155 bfd_arm_vfp11_fix vfp11_fix,
6156 int no_enum_warn, int no_wchar_warn,
6157 int pic_veneer, int fix_cortex_a8)
6158 {
6159 struct elf32_arm_link_hash_table *globals;
6160
6161 globals = elf32_arm_hash_table (link_info);
6162
6163 globals->target1_is_rel = target1_is_rel;
6164 if (strcmp (target2_type, "rel") == 0)
6165 globals->target2_reloc = R_ARM_REL32;
6166 else if (strcmp (target2_type, "abs") == 0)
6167 globals->target2_reloc = R_ARM_ABS32;
6168 else if (strcmp (target2_type, "got-rel") == 0)
6169 globals->target2_reloc = R_ARM_GOT_PREL;
6170 else
6171 {
6172 _bfd_error_handler (_("Invalid TARGET2 relocation type '%s'."),
6173 target2_type);
6174 }
6175 globals->fix_v4bx = fix_v4bx;
6176 globals->use_blx |= use_blx;
6177 globals->vfp11_fix = vfp11_fix;
6178 globals->pic_veneer = pic_veneer;
6179 globals->fix_cortex_a8 = fix_cortex_a8;
6180
6181 BFD_ASSERT (is_arm_elf (output_bfd));
6182 elf_arm_tdata (output_bfd)->no_enum_size_warning = no_enum_warn;
6183 elf_arm_tdata (output_bfd)->no_wchar_size_warning = no_wchar_warn;
6184 }
6185
6186 /* Replace the target offset of a Thumb bl or b.w instruction. */
6187
6188 static void
6189 insert_thumb_branch (bfd *abfd, long int offset, bfd_byte *insn)
6190 {
6191 bfd_vma upper;
6192 bfd_vma lower;
6193 int reloc_sign;
6194
6195 BFD_ASSERT ((offset & 1) == 0);
6196
6197 upper = bfd_get_16 (abfd, insn);
6198 lower = bfd_get_16 (abfd, insn + 2);
6199 reloc_sign = (offset < 0) ? 1 : 0;
6200 upper = (upper & ~(bfd_vma) 0x7ff)
6201 | ((offset >> 12) & 0x3ff)
6202 | (reloc_sign << 10);
6203 lower = (lower & ~(bfd_vma) 0x2fff)
6204 | (((!((offset >> 23) & 1)) ^ reloc_sign) << 13)
6205 | (((!((offset >> 22) & 1)) ^ reloc_sign) << 11)
6206 | ((offset >> 1) & 0x7ff);
6207 bfd_put_16 (abfd, upper, insn);
6208 bfd_put_16 (abfd, lower, insn + 2);
6209 }
6210
6211 /* Thumb code calling an ARM function. */
6212
6213 static int
6214 elf32_thumb_to_arm_stub (struct bfd_link_info * info,
6215 const char * name,
6216 bfd * input_bfd,
6217 bfd * output_bfd,
6218 asection * input_section,
6219 bfd_byte * hit_data,
6220 asection * sym_sec,
6221 bfd_vma offset,
6222 bfd_signed_vma addend,
6223 bfd_vma val,
6224 char **error_message)
6225 {
6226 asection * s = 0;
6227 bfd_vma my_offset;
6228 long int ret_offset;
6229 struct elf_link_hash_entry * myh;
6230 struct elf32_arm_link_hash_table * globals;
6231
6232 myh = find_thumb_glue (info, name, error_message);
6233 if (myh == NULL)
6234 return FALSE;
6235
6236 globals = elf32_arm_hash_table (info);
6237
6238 BFD_ASSERT (globals != NULL);
6239 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
6240
6241 my_offset = myh->root.u.def.value;
6242
6243 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
6244 THUMB2ARM_GLUE_SECTION_NAME);
6245
6246 BFD_ASSERT (s != NULL);
6247 BFD_ASSERT (s->contents != NULL);
6248 BFD_ASSERT (s->output_section != NULL);
6249
6250 if ((my_offset & 0x01) == 0x01)
6251 {
6252 if (sym_sec != NULL
6253 && sym_sec->owner != NULL
6254 && !INTERWORK_FLAG (sym_sec->owner))
6255 {
6256 (*_bfd_error_handler)
6257 (_("%B(%s): warning: interworking not enabled.\n"
6258 " first occurrence: %B: thumb call to arm"),
6259 sym_sec->owner, input_bfd, name);
6260
6261 return FALSE;
6262 }
6263
6264 --my_offset;
6265 myh->root.u.def.value = my_offset;
6266
6267 put_thumb_insn (globals, output_bfd, (bfd_vma) t2a1_bx_pc_insn,
6268 s->contents + my_offset);
6269
6270 put_thumb_insn (globals, output_bfd, (bfd_vma) t2a2_noop_insn,
6271 s->contents + my_offset + 2);
6272
6273 ret_offset =
6274 /* Address of destination of the stub. */
6275 ((bfd_signed_vma) val)
6276 - ((bfd_signed_vma)
6277 /* Offset from the start of the current section
6278 to the start of the stubs. */
6279 (s->output_offset
6280 /* Offset of the start of this stub from the start of the stubs. */
6281 + my_offset
6282 /* Address of the start of the current section. */
6283 + s->output_section->vma)
6284 /* The branch instruction is 4 bytes into the stub. */
6285 + 4
6286 /* ARM branches work from the pc of the instruction + 8. */
6287 + 8);
6288
6289 put_arm_insn (globals, output_bfd,
6290 (bfd_vma) t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF),
6291 s->contents + my_offset + 4);
6292 }
6293
6294 BFD_ASSERT (my_offset <= globals->thumb_glue_size);
6295
6296 /* Now go back and fix up the original BL insn to point to here. */
6297 ret_offset =
6298 /* Address of where the stub is located. */
6299 (s->output_section->vma + s->output_offset + my_offset)
6300 /* Address of where the BL is located. */
6301 - (input_section->output_section->vma + input_section->output_offset
6302 + offset)
6303 /* Addend in the relocation. */
6304 - addend
6305 /* Biassing for PC-relative addressing. */
6306 - 8;
6307
6308 insert_thumb_branch (input_bfd, ret_offset, hit_data - input_section->vma);
6309
6310 return TRUE;
6311 }
6312
6313 /* Populate an Arm to Thumb stub. Returns the stub symbol. */
6314
6315 static struct elf_link_hash_entry *
6316 elf32_arm_create_thumb_stub (struct bfd_link_info * info,
6317 const char * name,
6318 bfd * input_bfd,
6319 bfd * output_bfd,
6320 asection * sym_sec,
6321 bfd_vma val,
6322 asection * s,
6323 char ** error_message)
6324 {
6325 bfd_vma my_offset;
6326 long int ret_offset;
6327 struct elf_link_hash_entry * myh;
6328 struct elf32_arm_link_hash_table * globals;
6329
6330 myh = find_arm_glue (info, name, error_message);
6331 if (myh == NULL)
6332 return NULL;
6333
6334 globals = elf32_arm_hash_table (info);
6335
6336 BFD_ASSERT (globals != NULL);
6337 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
6338
6339 my_offset = myh->root.u.def.value;
6340
6341 if ((my_offset & 0x01) == 0x01)
6342 {
6343 if (sym_sec != NULL
6344 && sym_sec->owner != NULL
6345 && !INTERWORK_FLAG (sym_sec->owner))
6346 {
6347 (*_bfd_error_handler)
6348 (_("%B(%s): warning: interworking not enabled.\n"
6349 " first occurrence: %B: arm call to thumb"),
6350 sym_sec->owner, input_bfd, name);
6351 }
6352
6353 --my_offset;
6354 myh->root.u.def.value = my_offset;
6355
6356 if (info->shared || globals->root.is_relocatable_executable
6357 || globals->pic_veneer)
6358 {
6359 /* For relocatable objects we can't use absolute addresses,
6360 so construct the address from a relative offset. */
6361 /* TODO: If the offset is small it's probably worth
6362 constructing the address with adds. */
6363 put_arm_insn (globals, output_bfd, (bfd_vma) a2t1p_ldr_insn,
6364 s->contents + my_offset);
6365 put_arm_insn (globals, output_bfd, (bfd_vma) a2t2p_add_pc_insn,
6366 s->contents + my_offset + 4);
6367 put_arm_insn (globals, output_bfd, (bfd_vma) a2t3p_bx_r12_insn,
6368 s->contents + my_offset + 8);
6369 /* Adjust the offset by 4 for the position of the add,
6370 and 8 for the pipeline offset. */
6371 ret_offset = (val - (s->output_offset
6372 + s->output_section->vma
6373 + my_offset + 12))
6374 | 1;
6375 bfd_put_32 (output_bfd, ret_offset,
6376 s->contents + my_offset + 12);
6377 }
6378 else if (globals->use_blx)
6379 {
6380 put_arm_insn (globals, output_bfd, (bfd_vma) a2t1v5_ldr_insn,
6381 s->contents + my_offset);
6382
6383 /* It's a thumb address. Add the low order bit. */
6384 bfd_put_32 (output_bfd, val | a2t2v5_func_addr_insn,
6385 s->contents + my_offset + 4);
6386 }
6387 else
6388 {
6389 put_arm_insn (globals, output_bfd, (bfd_vma) a2t1_ldr_insn,
6390 s->contents + my_offset);
6391
6392 put_arm_insn (globals, output_bfd, (bfd_vma) a2t2_bx_r12_insn,
6393 s->contents + my_offset + 4);
6394
6395 /* It's a thumb address. Add the low order bit. */
6396 bfd_put_32 (output_bfd, val | a2t3_func_addr_insn,
6397 s->contents + my_offset + 8);
6398
6399 my_offset += 12;
6400 }
6401 }
6402
6403 BFD_ASSERT (my_offset <= globals->arm_glue_size);
6404
6405 return myh;
6406 }
6407
6408 /* Arm code calling a Thumb function. */
6409
6410 static int
6411 elf32_arm_to_thumb_stub (struct bfd_link_info * info,
6412 const char * name,
6413 bfd * input_bfd,
6414 bfd * output_bfd,
6415 asection * input_section,
6416 bfd_byte * hit_data,
6417 asection * sym_sec,
6418 bfd_vma offset,
6419 bfd_signed_vma addend,
6420 bfd_vma val,
6421 char **error_message)
6422 {
6423 unsigned long int tmp;
6424 bfd_vma my_offset;
6425 asection * s;
6426 long int ret_offset;
6427 struct elf_link_hash_entry * myh;
6428 struct elf32_arm_link_hash_table * globals;
6429
6430 globals = elf32_arm_hash_table (info);
6431
6432 BFD_ASSERT (globals != NULL);
6433 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
6434
6435 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
6436 ARM2THUMB_GLUE_SECTION_NAME);
6437 BFD_ASSERT (s != NULL);
6438 BFD_ASSERT (s->contents != NULL);
6439 BFD_ASSERT (s->output_section != NULL);
6440
6441 myh = elf32_arm_create_thumb_stub (info, name, input_bfd, output_bfd,
6442 sym_sec, val, s, error_message);
6443 if (!myh)
6444 return FALSE;
6445
6446 my_offset = myh->root.u.def.value;
6447 tmp = bfd_get_32 (input_bfd, hit_data);
6448 tmp = tmp & 0xFF000000;
6449
6450 /* Somehow these are both 4 too far, so subtract 8. */
6451 ret_offset = (s->output_offset
6452 + my_offset
6453 + s->output_section->vma
6454 - (input_section->output_offset
6455 + input_section->output_section->vma
6456 + offset + addend)
6457 - 8);
6458
6459 tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF);
6460
6461 bfd_put_32 (output_bfd, (bfd_vma) tmp, hit_data - input_section->vma);
6462
6463 return TRUE;
6464 }
6465
6466 /* Populate Arm stub for an exported Thumb function. */
6467
6468 static bfd_boolean
6469 elf32_arm_to_thumb_export_stub (struct elf_link_hash_entry *h, void * inf)
6470 {
6471 struct bfd_link_info * info = (struct bfd_link_info *) inf;
6472 asection * s;
6473 struct elf_link_hash_entry * myh;
6474 struct elf32_arm_link_hash_entry *eh;
6475 struct elf32_arm_link_hash_table * globals;
6476 asection *sec;
6477 bfd_vma val;
6478 char *error_message;
6479
6480 eh = elf32_arm_hash_entry (h);
6481 /* Allocate stubs for exported Thumb functions on v4t. */
6482 if (eh->export_glue == NULL)
6483 return TRUE;
6484
6485 globals = elf32_arm_hash_table (info);
6486
6487 BFD_ASSERT (globals != NULL);
6488 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
6489
6490 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
6491 ARM2THUMB_GLUE_SECTION_NAME);
6492 BFD_ASSERT (s != NULL);
6493 BFD_ASSERT (s->contents != NULL);
6494 BFD_ASSERT (s->output_section != NULL);
6495
6496 sec = eh->export_glue->root.u.def.section;
6497
6498 BFD_ASSERT (sec->output_section != NULL);
6499
6500 val = eh->export_glue->root.u.def.value + sec->output_offset
6501 + sec->output_section->vma;
6502
6503 myh = elf32_arm_create_thumb_stub (info, h->root.root.string,
6504 h->root.u.def.section->owner,
6505 globals->obfd, sec, val, s,
6506 &error_message);
6507 BFD_ASSERT (myh);
6508 return TRUE;
6509 }
6510
6511 /* Populate ARMv4 BX veneers. Returns the absolute adress of the veneer. */
6512
6513 static bfd_vma
6514 elf32_arm_bx_glue (struct bfd_link_info * info, int reg)
6515 {
6516 bfd_byte *p;
6517 bfd_vma glue_addr;
6518 asection *s;
6519 struct elf32_arm_link_hash_table *globals;
6520
6521 globals = elf32_arm_hash_table (info);
6522
6523 BFD_ASSERT (globals != NULL);
6524 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
6525
6526 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
6527 ARM_BX_GLUE_SECTION_NAME);
6528 BFD_ASSERT (s != NULL);
6529 BFD_ASSERT (s->contents != NULL);
6530 BFD_ASSERT (s->output_section != NULL);
6531
6532 BFD_ASSERT (globals->bx_glue_offset[reg] & 2);
6533
6534 glue_addr = globals->bx_glue_offset[reg] & ~(bfd_vma)3;
6535
6536 if ((globals->bx_glue_offset[reg] & 1) == 0)
6537 {
6538 p = s->contents + glue_addr;
6539 bfd_put_32 (globals->obfd, armbx1_tst_insn + (reg << 16), p);
6540 bfd_put_32 (globals->obfd, armbx2_moveq_insn + reg, p + 4);
6541 bfd_put_32 (globals->obfd, armbx3_bx_insn + reg, p + 8);
6542 globals->bx_glue_offset[reg] |= 1;
6543 }
6544
6545 return glue_addr + s->output_section->vma + s->output_offset;
6546 }
6547
6548 /* Generate Arm stubs for exported Thumb symbols. */
6549 static void
6550 elf32_arm_begin_write_processing (bfd *abfd ATTRIBUTE_UNUSED,
6551 struct bfd_link_info *link_info)
6552 {
6553 struct elf32_arm_link_hash_table * globals;
6554
6555 if (link_info == NULL)
6556 /* Ignore this if we are not called by the ELF backend linker. */
6557 return;
6558
6559 globals = elf32_arm_hash_table (link_info);
6560 /* If blx is available then exported Thumb symbols are OK and there is
6561 nothing to do. */
6562 if (globals->use_blx)
6563 return;
6564
6565 elf_link_hash_traverse (&globals->root, elf32_arm_to_thumb_export_stub,
6566 link_info);
6567 }
6568
6569 /* Some relocations map to different relocations depending on the
6570 target. Return the real relocation. */
6571
6572 static int
6573 arm_real_reloc_type (struct elf32_arm_link_hash_table * globals,
6574 int r_type)
6575 {
6576 switch (r_type)
6577 {
6578 case R_ARM_TARGET1:
6579 if (globals->target1_is_rel)
6580 return R_ARM_REL32;
6581 else
6582 return R_ARM_ABS32;
6583
6584 case R_ARM_TARGET2:
6585 return globals->target2_reloc;
6586
6587 default:
6588 return r_type;
6589 }
6590 }
6591
6592 /* Return the base VMA address which should be subtracted from real addresses
6593 when resolving @dtpoff relocation.
6594 This is PT_TLS segment p_vaddr. */
6595
6596 static bfd_vma
6597 dtpoff_base (struct bfd_link_info *info)
6598 {
6599 /* If tls_sec is NULL, we should have signalled an error already. */
6600 if (elf_hash_table (info)->tls_sec == NULL)
6601 return 0;
6602 return elf_hash_table (info)->tls_sec->vma;
6603 }
6604
6605 /* Return the relocation value for @tpoff relocation
6606 if STT_TLS virtual address is ADDRESS. */
6607
6608 static bfd_vma
6609 tpoff (struct bfd_link_info *info, bfd_vma address)
6610 {
6611 struct elf_link_hash_table *htab = elf_hash_table (info);
6612 bfd_vma base;
6613
6614 /* If tls_sec is NULL, we should have signalled an error already. */
6615 if (htab->tls_sec == NULL)
6616 return 0;
6617 base = align_power ((bfd_vma) TCB_SIZE, htab->tls_sec->alignment_power);
6618 return address - htab->tls_sec->vma + base;
6619 }
6620
6621 /* Perform an R_ARM_ABS12 relocation on the field pointed to by DATA.
6622 VALUE is the relocation value. */
6623
6624 static bfd_reloc_status_type
6625 elf32_arm_abs12_reloc (bfd *abfd, void *data, bfd_vma value)
6626 {
6627 if (value > 0xfff)
6628 return bfd_reloc_overflow;
6629
6630 value |= bfd_get_32 (abfd, data) & 0xfffff000;
6631 bfd_put_32 (abfd, value, data);
6632 return bfd_reloc_ok;
6633 }
6634
6635 /* For a given value of n, calculate the value of G_n as required to
6636 deal with group relocations. We return it in the form of an
6637 encoded constant-and-rotation, together with the final residual. If n is
6638 specified as less than zero, then final_residual is filled with the
6639 input value and no further action is performed. */
6640
6641 static bfd_vma
6642 calculate_group_reloc_mask (bfd_vma value, int n, bfd_vma *final_residual)
6643 {
6644 int current_n;
6645 bfd_vma g_n;
6646 bfd_vma encoded_g_n = 0;
6647 bfd_vma residual = value; /* Also known as Y_n. */
6648
6649 for (current_n = 0; current_n <= n; current_n++)
6650 {
6651 int shift;
6652
6653 /* Calculate which part of the value to mask. */
6654 if (residual == 0)
6655 shift = 0;
6656 else
6657 {
6658 int msb;
6659
6660 /* Determine the most significant bit in the residual and
6661 align the resulting value to a 2-bit boundary. */
6662 for (msb = 30; msb >= 0; msb -= 2)
6663 if (residual & (3 << msb))
6664 break;
6665
6666 /* The desired shift is now (msb - 6), or zero, whichever
6667 is the greater. */
6668 shift = msb - 6;
6669 if (shift < 0)
6670 shift = 0;
6671 }
6672
6673 /* Calculate g_n in 32-bit as well as encoded constant+rotation form. */
6674 g_n = residual & (0xff << shift);
6675 encoded_g_n = (g_n >> shift)
6676 | ((g_n <= 0xff ? 0 : (32 - shift) / 2) << 8);
6677
6678 /* Calculate the residual for the next time around. */
6679 residual &= ~g_n;
6680 }
6681
6682 *final_residual = residual;
6683
6684 return encoded_g_n;
6685 }
6686
6687 /* Given an ARM instruction, determine whether it is an ADD or a SUB.
6688 Returns 1 if it is an ADD, -1 if it is a SUB, and 0 otherwise. */
6689
6690 static int
6691 identify_add_or_sub (bfd_vma insn)
6692 {
6693 int opcode = insn & 0x1e00000;
6694
6695 if (opcode == 1 << 23) /* ADD */
6696 return 1;
6697
6698 if (opcode == 1 << 22) /* SUB */
6699 return -1;
6700
6701 return 0;
6702 }
6703
6704 /* Perform a relocation as part of a final link. */
6705
6706 static bfd_reloc_status_type
6707 elf32_arm_final_link_relocate (reloc_howto_type * howto,
6708 bfd * input_bfd,
6709 bfd * output_bfd,
6710 asection * input_section,
6711 bfd_byte * contents,
6712 Elf_Internal_Rela * rel,
6713 bfd_vma value,
6714 struct bfd_link_info * info,
6715 asection * sym_sec,
6716 const char * sym_name,
6717 int sym_flags,
6718 struct elf_link_hash_entry * h,
6719 bfd_boolean * unresolved_reloc_p,
6720 char ** error_message)
6721 {
6722 unsigned long r_type = howto->type;
6723 unsigned long r_symndx;
6724 bfd_byte * hit_data = contents + rel->r_offset;
6725 bfd * dynobj = NULL;
6726 Elf_Internal_Shdr * symtab_hdr;
6727 struct elf_link_hash_entry ** sym_hashes;
6728 bfd_vma * local_got_offsets;
6729 asection * sgot = NULL;
6730 asection * splt = NULL;
6731 asection * sreloc = NULL;
6732 bfd_vma addend;
6733 bfd_signed_vma signed_addend;
6734 struct elf32_arm_link_hash_table * globals;
6735
6736 globals = elf32_arm_hash_table (info);
6737
6738 BFD_ASSERT (is_arm_elf (input_bfd));
6739
6740 /* Some relocation types map to different relocations depending on the
6741 target. We pick the right one here. */
6742 r_type = arm_real_reloc_type (globals, r_type);
6743 if (r_type != howto->type)
6744 howto = elf32_arm_howto_from_type (r_type);
6745
6746 /* If the start address has been set, then set the EF_ARM_HASENTRY
6747 flag. Setting this more than once is redundant, but the cost is
6748 not too high, and it keeps the code simple.
6749
6750 The test is done here, rather than somewhere else, because the
6751 start address is only set just before the final link commences.
6752
6753 Note - if the user deliberately sets a start address of 0, the
6754 flag will not be set. */
6755 if (bfd_get_start_address (output_bfd) != 0)
6756 elf_elfheader (output_bfd)->e_flags |= EF_ARM_HASENTRY;
6757
6758 dynobj = elf_hash_table (info)->dynobj;
6759 if (dynobj)
6760 {
6761 sgot = bfd_get_section_by_name (dynobj, ".got");
6762 splt = bfd_get_section_by_name (dynobj, ".plt");
6763 }
6764 symtab_hdr = & elf_symtab_hdr (input_bfd);
6765 sym_hashes = elf_sym_hashes (input_bfd);
6766 local_got_offsets = elf_local_got_offsets (input_bfd);
6767 r_symndx = ELF32_R_SYM (rel->r_info);
6768
6769 if (globals->use_rel)
6770 {
6771 addend = bfd_get_32 (input_bfd, hit_data) & howto->src_mask;
6772
6773 if (addend & ((howto->src_mask + 1) >> 1))
6774 {
6775 signed_addend = -1;
6776 signed_addend &= ~ howto->src_mask;
6777 signed_addend |= addend;
6778 }
6779 else
6780 signed_addend = addend;
6781 }
6782 else
6783 addend = signed_addend = rel->r_addend;
6784
6785 switch (r_type)
6786 {
6787 case R_ARM_NONE:
6788 /* We don't need to find a value for this symbol. It's just a
6789 marker. */
6790 *unresolved_reloc_p = FALSE;
6791 return bfd_reloc_ok;
6792
6793 case R_ARM_ABS12:
6794 if (!globals->vxworks_p)
6795 return elf32_arm_abs12_reloc (input_bfd, hit_data, value + addend);
6796
6797 case R_ARM_PC24:
6798 case R_ARM_ABS32:
6799 case R_ARM_ABS32_NOI:
6800 case R_ARM_REL32:
6801 case R_ARM_REL32_NOI:
6802 case R_ARM_CALL:
6803 case R_ARM_JUMP24:
6804 case R_ARM_XPC25:
6805 case R_ARM_PREL31:
6806 case R_ARM_PLT32:
6807 /* Handle relocations which should use the PLT entry. ABS32/REL32
6808 will use the symbol's value, which may point to a PLT entry, but we
6809 don't need to handle that here. If we created a PLT entry, all
6810 branches in this object should go to it, except if the PLT is too
6811 far away, in which case a long branch stub should be inserted. */
6812 if ((r_type != R_ARM_ABS32 && r_type != R_ARM_REL32
6813 && r_type != R_ARM_ABS32_NOI && r_type != R_ARM_REL32_NOI
6814 && r_type != R_ARM_CALL
6815 && r_type != R_ARM_JUMP24
6816 && r_type != R_ARM_PLT32)
6817 && h != NULL
6818 && splt != NULL
6819 && h->plt.offset != (bfd_vma) -1)
6820 {
6821 /* If we've created a .plt section, and assigned a PLT entry to
6822 this function, it should not be known to bind locally. If
6823 it were, we would have cleared the PLT entry. */
6824 BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info, h));
6825
6826 value = (splt->output_section->vma
6827 + splt->output_offset
6828 + h->plt.offset);
6829 *unresolved_reloc_p = FALSE;
6830 return _bfd_final_link_relocate (howto, input_bfd, input_section,
6831 contents, rel->r_offset, value,
6832 rel->r_addend);
6833 }
6834
6835 /* When generating a shared object or relocatable executable, these
6836 relocations are copied into the output file to be resolved at
6837 run time. */
6838 if ((info->shared || globals->root.is_relocatable_executable)
6839 && (input_section->flags & SEC_ALLOC)
6840 && !(elf32_arm_hash_table (info)->vxworks_p
6841 && strcmp (input_section->output_section->name,
6842 ".tls_vars") == 0)
6843 && ((r_type != R_ARM_REL32 && r_type != R_ARM_REL32_NOI)
6844 || !SYMBOL_CALLS_LOCAL (info, h))
6845 && (h == NULL
6846 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
6847 || h->root.type != bfd_link_hash_undefweak)
6848 && r_type != R_ARM_PC24
6849 && r_type != R_ARM_CALL
6850 && r_type != R_ARM_JUMP24
6851 && r_type != R_ARM_PREL31
6852 && r_type != R_ARM_PLT32)
6853 {
6854 Elf_Internal_Rela outrel;
6855 bfd_byte *loc;
6856 bfd_boolean skip, relocate;
6857
6858 *unresolved_reloc_p = FALSE;
6859
6860 if (sreloc == NULL)
6861 {
6862 sreloc = _bfd_elf_get_dynamic_reloc_section (input_bfd, input_section,
6863 ! globals->use_rel);
6864
6865 if (sreloc == NULL)
6866 return bfd_reloc_notsupported;
6867 }
6868
6869 skip = FALSE;
6870 relocate = FALSE;
6871
6872 outrel.r_addend = addend;
6873 outrel.r_offset =
6874 _bfd_elf_section_offset (output_bfd, info, input_section,
6875 rel->r_offset);
6876 if (outrel.r_offset == (bfd_vma) -1)
6877 skip = TRUE;
6878 else if (outrel.r_offset == (bfd_vma) -2)
6879 skip = TRUE, relocate = TRUE;
6880 outrel.r_offset += (input_section->output_section->vma
6881 + input_section->output_offset);
6882
6883 if (skip)
6884 memset (&outrel, 0, sizeof outrel);
6885 else if (h != NULL
6886 && h->dynindx != -1
6887 && (!info->shared
6888 || !info->symbolic
6889 || !h->def_regular))
6890 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
6891 else
6892 {
6893 int symbol;
6894
6895 /* This symbol is local, or marked to become local. */
6896 if (sym_flags == STT_ARM_TFUNC)
6897 value |= 1;
6898 if (globals->symbian_p)
6899 {
6900 asection *osec;
6901
6902 /* On Symbian OS, the data segment and text segement
6903 can be relocated independently. Therefore, we
6904 must indicate the segment to which this
6905 relocation is relative. The BPABI allows us to
6906 use any symbol in the right segment; we just use
6907 the section symbol as it is convenient. (We
6908 cannot use the symbol given by "h" directly as it
6909 will not appear in the dynamic symbol table.)
6910
6911 Note that the dynamic linker ignores the section
6912 symbol value, so we don't subtract osec->vma
6913 from the emitted reloc addend. */
6914 if (sym_sec)
6915 osec = sym_sec->output_section;
6916 else
6917 osec = input_section->output_section;
6918 symbol = elf_section_data (osec)->dynindx;
6919 if (symbol == 0)
6920 {
6921 struct elf_link_hash_table *htab = elf_hash_table (info);
6922
6923 if ((osec->flags & SEC_READONLY) == 0
6924 && htab->data_index_section != NULL)
6925 osec = htab->data_index_section;
6926 else
6927 osec = htab->text_index_section;
6928 symbol = elf_section_data (osec)->dynindx;
6929 }
6930 BFD_ASSERT (symbol != 0);
6931 }
6932 else
6933 /* On SVR4-ish systems, the dynamic loader cannot
6934 relocate the text and data segments independently,
6935 so the symbol does not matter. */
6936 symbol = 0;
6937 outrel.r_info = ELF32_R_INFO (symbol, R_ARM_RELATIVE);
6938 if (globals->use_rel)
6939 relocate = TRUE;
6940 else
6941 outrel.r_addend += value;
6942 }
6943
6944 loc = sreloc->contents;
6945 loc += sreloc->reloc_count++ * RELOC_SIZE (globals);
6946 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
6947
6948 /* If this reloc is against an external symbol, we do not want to
6949 fiddle with the addend. Otherwise, we need to include the symbol
6950 value so that it becomes an addend for the dynamic reloc. */
6951 if (! relocate)
6952 return bfd_reloc_ok;
6953
6954 return _bfd_final_link_relocate (howto, input_bfd, input_section,
6955 contents, rel->r_offset, value,
6956 (bfd_vma) 0);
6957 }
6958 else switch (r_type)
6959 {
6960 case R_ARM_ABS12:
6961 return elf32_arm_abs12_reloc (input_bfd, hit_data, value + addend);
6962
6963 case R_ARM_XPC25: /* Arm BLX instruction. */
6964 case R_ARM_CALL:
6965 case R_ARM_JUMP24:
6966 case R_ARM_PC24: /* Arm B/BL instruction. */
6967 case R_ARM_PLT32:
6968 {
6969 bfd_signed_vma branch_offset;
6970 struct elf32_arm_stub_hash_entry *stub_entry = NULL;
6971
6972 if (r_type == R_ARM_XPC25)
6973 {
6974 /* Check for Arm calling Arm function. */
6975 /* FIXME: Should we translate the instruction into a BL
6976 instruction instead ? */
6977 if (sym_flags != STT_ARM_TFUNC)
6978 (*_bfd_error_handler)
6979 (_("\%B: Warning: Arm BLX instruction targets Arm function '%s'."),
6980 input_bfd,
6981 h ? h->root.root.string : "(local)");
6982 }
6983 else if (r_type == R_ARM_PC24)
6984 {
6985 /* Check for Arm calling Thumb function. */
6986 if (sym_flags == STT_ARM_TFUNC)
6987 {
6988 if (elf32_arm_to_thumb_stub (info, sym_name, input_bfd,
6989 output_bfd, input_section,
6990 hit_data, sym_sec, rel->r_offset,
6991 signed_addend, value,
6992 error_message))
6993 return bfd_reloc_ok;
6994 else
6995 return bfd_reloc_dangerous;
6996 }
6997 }
6998
6999 /* Check if a stub has to be inserted because the
7000 destination is too far or we are changing mode. */
7001 if ( r_type == R_ARM_CALL
7002 || r_type == R_ARM_JUMP24
7003 || r_type == R_ARM_PLT32)
7004 {
7005 bfd_vma from;
7006
7007 /* If the call goes through a PLT entry, make sure to
7008 check distance to the right destination address. */
7009 if (h != NULL && splt != NULL && h->plt.offset != (bfd_vma) -1)
7010 {
7011 value = (splt->output_section->vma
7012 + splt->output_offset
7013 + h->plt.offset);
7014 *unresolved_reloc_p = FALSE;
7015 }
7016
7017 from = (input_section->output_section->vma
7018 + input_section->output_offset
7019 + rel->r_offset);
7020 branch_offset = (bfd_signed_vma)(value - from);
7021
7022 if (branch_offset > ARM_MAX_FWD_BRANCH_OFFSET
7023 || branch_offset < ARM_MAX_BWD_BRANCH_OFFSET
7024 || ((sym_flags == STT_ARM_TFUNC)
7025 && (((r_type == R_ARM_CALL) && !globals->use_blx)
7026 || (r_type == R_ARM_JUMP24)
7027 || (r_type == R_ARM_PLT32) ))
7028 )
7029 {
7030 /* The target is out of reach, so redirect the
7031 branch to the local stub for this function. */
7032
7033 stub_entry = elf32_arm_get_stub_entry (input_section,
7034 sym_sec, h,
7035 rel, globals);
7036 if (stub_entry != NULL)
7037 value = (stub_entry->stub_offset
7038 + stub_entry->stub_sec->output_offset
7039 + stub_entry->stub_sec->output_section->vma);
7040 }
7041 }
7042
7043 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
7044 where:
7045 S is the address of the symbol in the relocation.
7046 P is address of the instruction being relocated.
7047 A is the addend (extracted from the instruction) in bytes.
7048
7049 S is held in 'value'.
7050 P is the base address of the section containing the
7051 instruction plus the offset of the reloc into that
7052 section, ie:
7053 (input_section->output_section->vma +
7054 input_section->output_offset +
7055 rel->r_offset).
7056 A is the addend, converted into bytes, ie:
7057 (signed_addend * 4)
7058
7059 Note: None of these operations have knowledge of the pipeline
7060 size of the processor, thus it is up to the assembler to
7061 encode this information into the addend. */
7062 value -= (input_section->output_section->vma
7063 + input_section->output_offset);
7064 value -= rel->r_offset;
7065 if (globals->use_rel)
7066 value += (signed_addend << howto->size);
7067 else
7068 /* RELA addends do not have to be adjusted by howto->size. */
7069 value += signed_addend;
7070
7071 signed_addend = value;
7072 signed_addend >>= howto->rightshift;
7073
7074 /* A branch to an undefined weak symbol is turned into a jump to
7075 the next instruction unless a PLT entry will be created.
7076 Do the same for local undefined symbols. */
7077 if (h ? (h->root.type == bfd_link_hash_undefweak
7078 && !(splt != NULL && h->plt.offset != (bfd_vma) -1))
7079 : bfd_is_und_section (sym_sec))
7080 {
7081 value = (bfd_get_32 (input_bfd, hit_data) & 0xf0000000)
7082 | 0x0affffff;
7083 }
7084 else
7085 {
7086 /* Perform a signed range check. */
7087 if ( signed_addend > ((bfd_signed_vma) (howto->dst_mask >> 1))
7088 || signed_addend < - ((bfd_signed_vma) ((howto->dst_mask + 1) >> 1)))
7089 return bfd_reloc_overflow;
7090
7091 addend = (value & 2);
7092
7093 value = (signed_addend & howto->dst_mask)
7094 | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask));
7095
7096 if (r_type == R_ARM_CALL)
7097 {
7098 /* Set the H bit in the BLX instruction. */
7099 if (sym_flags == STT_ARM_TFUNC)
7100 {
7101 if (addend)
7102 value |= (1 << 24);
7103 else
7104 value &= ~(bfd_vma)(1 << 24);
7105 }
7106
7107 /* Select the correct instruction (BL or BLX). */
7108 /* Only if we are not handling a BL to a stub. In this
7109 case, mode switching is performed by the stub. */
7110 if (sym_flags == STT_ARM_TFUNC && !stub_entry)
7111 value |= (1 << 28);
7112 else
7113 {
7114 value &= ~(bfd_vma)(1 << 28);
7115 value |= (1 << 24);
7116 }
7117 }
7118 }
7119 }
7120 break;
7121
7122 case R_ARM_ABS32:
7123 value += addend;
7124 if (sym_flags == STT_ARM_TFUNC)
7125 value |= 1;
7126 break;
7127
7128 case R_ARM_ABS32_NOI:
7129 value += addend;
7130 break;
7131
7132 case R_ARM_REL32:
7133 value += addend;
7134 if (sym_flags == STT_ARM_TFUNC)
7135 value |= 1;
7136 value -= (input_section->output_section->vma
7137 + input_section->output_offset + rel->r_offset);
7138 break;
7139
7140 case R_ARM_REL32_NOI:
7141 value += addend;
7142 value -= (input_section->output_section->vma
7143 + input_section->output_offset + rel->r_offset);
7144 break;
7145
7146 case R_ARM_PREL31:
7147 value -= (input_section->output_section->vma
7148 + input_section->output_offset + rel->r_offset);
7149 value += signed_addend;
7150 if (! h || h->root.type != bfd_link_hash_undefweak)
7151 {
7152 /* Check for overflow. */
7153 if ((value ^ (value >> 1)) & (1 << 30))
7154 return bfd_reloc_overflow;
7155 }
7156 value &= 0x7fffffff;
7157 value |= (bfd_get_32 (input_bfd, hit_data) & 0x80000000);
7158 if (sym_flags == STT_ARM_TFUNC)
7159 value |= 1;
7160 break;
7161 }
7162
7163 bfd_put_32 (input_bfd, value, hit_data);
7164 return bfd_reloc_ok;
7165
7166 case R_ARM_ABS8:
7167 value += addend;
7168 if ((long) value > 0x7f || (long) value < -0x80)
7169 return bfd_reloc_overflow;
7170
7171 bfd_put_8 (input_bfd, value, hit_data);
7172 return bfd_reloc_ok;
7173
7174 case R_ARM_ABS16:
7175 value += addend;
7176
7177 if ((long) value > 0x7fff || (long) value < -0x8000)
7178 return bfd_reloc_overflow;
7179
7180 bfd_put_16 (input_bfd, value, hit_data);
7181 return bfd_reloc_ok;
7182
7183 case R_ARM_THM_ABS5:
7184 /* Support ldr and str instructions for the thumb. */
7185 if (globals->use_rel)
7186 {
7187 /* Need to refetch addend. */
7188 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
7189 /* ??? Need to determine shift amount from operand size. */
7190 addend >>= howto->rightshift;
7191 }
7192 value += addend;
7193
7194 /* ??? Isn't value unsigned? */
7195 if ((long) value > 0x1f || (long) value < -0x10)
7196 return bfd_reloc_overflow;
7197
7198 /* ??? Value needs to be properly shifted into place first. */
7199 value |= bfd_get_16 (input_bfd, hit_data) & 0xf83f;
7200 bfd_put_16 (input_bfd, value, hit_data);
7201 return bfd_reloc_ok;
7202
7203 case R_ARM_THM_ALU_PREL_11_0:
7204 /* Corresponds to: addw.w reg, pc, #offset (and similarly for subw). */
7205 {
7206 bfd_vma insn;
7207 bfd_signed_vma relocation;
7208
7209 insn = (bfd_get_16 (input_bfd, hit_data) << 16)
7210 | bfd_get_16 (input_bfd, hit_data + 2);
7211
7212 if (globals->use_rel)
7213 {
7214 signed_addend = (insn & 0xff) | ((insn & 0x7000) >> 4)
7215 | ((insn & (1 << 26)) >> 15);
7216 if (insn & 0xf00000)
7217 signed_addend = -signed_addend;
7218 }
7219
7220 relocation = value + signed_addend;
7221 relocation -= (input_section->output_section->vma
7222 + input_section->output_offset
7223 + rel->r_offset);
7224
7225 value = abs (relocation);
7226
7227 if (value >= 0x1000)
7228 return bfd_reloc_overflow;
7229
7230 insn = (insn & 0xfb0f8f00) | (value & 0xff)
7231 | ((value & 0x700) << 4)
7232 | ((value & 0x800) << 15);
7233 if (relocation < 0)
7234 insn |= 0xa00000;
7235
7236 bfd_put_16 (input_bfd, insn >> 16, hit_data);
7237 bfd_put_16 (input_bfd, insn & 0xffff, hit_data + 2);
7238
7239 return bfd_reloc_ok;
7240 }
7241
7242 case R_ARM_THM_PC8:
7243 /* PR 10073: This reloc is not generated by the GNU toolchain,
7244 but it is supported for compatibility with third party libraries
7245 generated by other compilers, specifically the ARM/IAR. */
7246 {
7247 bfd_vma insn;
7248 bfd_signed_vma relocation;
7249
7250 insn = bfd_get_16 (input_bfd, hit_data);
7251
7252 if (globals->use_rel)
7253 addend = (insn & 0x00ff) << 2;
7254
7255 relocation = value + addend;
7256 relocation -= (input_section->output_section->vma
7257 + input_section->output_offset
7258 + rel->r_offset);
7259
7260 value = abs (relocation);
7261
7262 /* We do not check for overflow of this reloc. Although strictly
7263 speaking this is incorrect, it appears to be necessary in order
7264 to work with IAR generated relocs. Since GCC and GAS do not
7265 generate R_ARM_THM_PC8 relocs, the lack of a check should not be
7266 a problem for them. */
7267 value &= 0x3fc;
7268
7269 insn = (insn & 0xff00) | (value >> 2);
7270
7271 bfd_put_16 (input_bfd, insn, hit_data);
7272
7273 return bfd_reloc_ok;
7274 }
7275
7276 case R_ARM_THM_PC12:
7277 /* Corresponds to: ldr.w reg, [pc, #offset]. */
7278 {
7279 bfd_vma insn;
7280 bfd_signed_vma relocation;
7281
7282 insn = (bfd_get_16 (input_bfd, hit_data) << 16)
7283 | bfd_get_16 (input_bfd, hit_data + 2);
7284
7285 if (globals->use_rel)
7286 {
7287 signed_addend = insn & 0xfff;
7288 if (!(insn & (1 << 23)))
7289 signed_addend = -signed_addend;
7290 }
7291
7292 relocation = value + signed_addend;
7293 relocation -= (input_section->output_section->vma
7294 + input_section->output_offset
7295 + rel->r_offset);
7296
7297 value = abs (relocation);
7298
7299 if (value >= 0x1000)
7300 return bfd_reloc_overflow;
7301
7302 insn = (insn & 0xff7ff000) | value;
7303 if (relocation >= 0)
7304 insn |= (1 << 23);
7305
7306 bfd_put_16 (input_bfd, insn >> 16, hit_data);
7307 bfd_put_16 (input_bfd, insn & 0xffff, hit_data + 2);
7308
7309 return bfd_reloc_ok;
7310 }
7311
7312 case R_ARM_THM_XPC22:
7313 case R_ARM_THM_CALL:
7314 case R_ARM_THM_JUMP24:
7315 /* Thumb BL (branch long instruction). */
7316 {
7317 bfd_vma relocation;
7318 bfd_vma reloc_sign;
7319 bfd_boolean overflow = FALSE;
7320 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
7321 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
7322 bfd_signed_vma reloc_signed_max;
7323 bfd_signed_vma reloc_signed_min;
7324 bfd_vma check;
7325 bfd_signed_vma signed_check;
7326 int bitsize;
7327 int thumb2 = using_thumb2 (globals);
7328
7329 /* A branch to an undefined weak symbol is turned into a jump to
7330 the next instruction unless a PLT entry will be created. */
7331 if (h && h->root.type == bfd_link_hash_undefweak
7332 && !(splt != NULL && h->plt.offset != (bfd_vma) -1))
7333 {
7334 bfd_put_16 (input_bfd, 0xe000, hit_data);
7335 bfd_put_16 (input_bfd, 0xbf00, hit_data + 2);
7336 return bfd_reloc_ok;
7337 }
7338
7339 /* Fetch the addend. We use the Thumb-2 encoding (backwards compatible
7340 with Thumb-1) involving the J1 and J2 bits. */
7341 if (globals->use_rel)
7342 {
7343 bfd_vma s = (upper_insn & (1 << 10)) >> 10;
7344 bfd_vma upper = upper_insn & 0x3ff;
7345 bfd_vma lower = lower_insn & 0x7ff;
7346 bfd_vma j1 = (lower_insn & (1 << 13)) >> 13;
7347 bfd_vma j2 = (lower_insn & (1 << 11)) >> 11;
7348 bfd_vma i1 = j1 ^ s ? 0 : 1;
7349 bfd_vma i2 = j2 ^ s ? 0 : 1;
7350
7351 addend = (i1 << 23) | (i2 << 22) | (upper << 12) | (lower << 1);
7352 /* Sign extend. */
7353 addend = (addend | ((s ? 0 : 1) << 24)) - (1 << 24);
7354
7355 signed_addend = addend;
7356 }
7357
7358 if (r_type == R_ARM_THM_XPC22)
7359 {
7360 /* Check for Thumb to Thumb call. */
7361 /* FIXME: Should we translate the instruction into a BL
7362 instruction instead ? */
7363 if (sym_flags == STT_ARM_TFUNC)
7364 (*_bfd_error_handler)
7365 (_("%B: Warning: Thumb BLX instruction targets thumb function '%s'."),
7366 input_bfd,
7367 h ? h->root.root.string : "(local)");
7368 }
7369 else
7370 {
7371 /* If it is not a call to Thumb, assume call to Arm.
7372 If it is a call relative to a section name, then it is not a
7373 function call at all, but rather a long jump. Calls through
7374 the PLT do not require stubs. */
7375 if (sym_flags != STT_ARM_TFUNC && sym_flags != STT_SECTION
7376 && (h == NULL || splt == NULL
7377 || h->plt.offset == (bfd_vma) -1))
7378 {
7379 if (globals->use_blx && r_type == R_ARM_THM_CALL)
7380 {
7381 /* Convert BL to BLX. */
7382 lower_insn = (lower_insn & ~0x1000) | 0x0800;
7383 }
7384 else if (( r_type != R_ARM_THM_CALL)
7385 && (r_type != R_ARM_THM_JUMP24))
7386 {
7387 if (elf32_thumb_to_arm_stub
7388 (info, sym_name, input_bfd, output_bfd, input_section,
7389 hit_data, sym_sec, rel->r_offset, signed_addend, value,
7390 error_message))
7391 return bfd_reloc_ok;
7392 else
7393 return bfd_reloc_dangerous;
7394 }
7395 }
7396 else if (sym_flags == STT_ARM_TFUNC && globals->use_blx
7397 && r_type == R_ARM_THM_CALL)
7398 {
7399 /* Make sure this is a BL. */
7400 lower_insn |= 0x1800;
7401 }
7402 }
7403
7404 /* Handle calls via the PLT. */
7405 if (h != NULL && splt != NULL && h->plt.offset != (bfd_vma) -1)
7406 {
7407 value = (splt->output_section->vma
7408 + splt->output_offset
7409 + h->plt.offset);
7410 if (globals->use_blx && r_type == R_ARM_THM_CALL)
7411 {
7412 /* If the Thumb BLX instruction is available, convert the
7413 BL to a BLX instruction to call the ARM-mode PLT entry. */
7414 lower_insn = (lower_insn & ~0x1000) | 0x0800;
7415 }
7416 else
7417 /* Target the Thumb stub before the ARM PLT entry. */
7418 value -= PLT_THUMB_STUB_SIZE;
7419 *unresolved_reloc_p = FALSE;
7420 }
7421
7422 if (r_type == R_ARM_THM_CALL || r_type == R_ARM_THM_JUMP24)
7423 {
7424 /* Check if a stub has to be inserted because the destination
7425 is too far. */
7426 bfd_vma from;
7427 bfd_signed_vma branch_offset;
7428 struct elf32_arm_stub_hash_entry *stub_entry = NULL;
7429
7430 from = (input_section->output_section->vma
7431 + input_section->output_offset
7432 + rel->r_offset);
7433 branch_offset = (bfd_signed_vma)(value - from);
7434
7435 if ((!thumb2
7436 && (branch_offset > THM_MAX_FWD_BRANCH_OFFSET
7437 || (branch_offset < THM_MAX_BWD_BRANCH_OFFSET)))
7438 ||
7439 (thumb2
7440 && (branch_offset > THM2_MAX_FWD_BRANCH_OFFSET
7441 || (branch_offset < THM2_MAX_BWD_BRANCH_OFFSET)))
7442 || ((sym_flags != STT_ARM_TFUNC)
7443 && (((r_type == R_ARM_THM_CALL) && !globals->use_blx)
7444 || r_type == R_ARM_THM_JUMP24)))
7445 {
7446 /* The target is out of reach or we are changing modes, so
7447 redirect the branch to the local stub for this
7448 function. */
7449 stub_entry = elf32_arm_get_stub_entry (input_section,
7450 sym_sec, h,
7451 rel, globals);
7452 if (stub_entry != NULL)
7453 value = (stub_entry->stub_offset
7454 + stub_entry->stub_sec->output_offset
7455 + stub_entry->stub_sec->output_section->vma);
7456
7457 /* If this call becomes a call to Arm, force BLX. */
7458 if (globals->use_blx && (r_type == R_ARM_THM_CALL))
7459 {
7460 if ((stub_entry
7461 && !arm_stub_is_thumb (stub_entry->stub_type))
7462 || (sym_flags != STT_ARM_TFUNC))
7463 lower_insn = (lower_insn & ~0x1000) | 0x0800;
7464 }
7465 }
7466 }
7467
7468 relocation = value + signed_addend;
7469
7470 relocation -= (input_section->output_section->vma
7471 + input_section->output_offset
7472 + rel->r_offset);
7473
7474 check = relocation >> howto->rightshift;
7475
7476 /* If this is a signed value, the rightshift just dropped
7477 leading 1 bits (assuming twos complement). */
7478 if ((bfd_signed_vma) relocation >= 0)
7479 signed_check = check;
7480 else
7481 signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
7482
7483 /* Calculate the permissable maximum and minimum values for
7484 this relocation according to whether we're relocating for
7485 Thumb-2 or not. */
7486 bitsize = howto->bitsize;
7487 if (!thumb2)
7488 bitsize -= 2;
7489 reloc_signed_max = ((1 << (bitsize - 1)) - 1) >> howto->rightshift;
7490 reloc_signed_min = ~reloc_signed_max;
7491
7492 /* Assumes two's complement. */
7493 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
7494 overflow = TRUE;
7495
7496 if ((lower_insn & 0x5000) == 0x4000)
7497 /* For a BLX instruction, make sure that the relocation is rounded up
7498 to a word boundary. This follows the semantics of the instruction
7499 which specifies that bit 1 of the target address will come from bit
7500 1 of the base address. */
7501 relocation = (relocation + 2) & ~ 3;
7502
7503 /* Put RELOCATION back into the insn. Assumes two's complement.
7504 We use the Thumb-2 encoding, which is safe even if dealing with
7505 a Thumb-1 instruction by virtue of our overflow check above. */
7506 reloc_sign = (signed_check < 0) ? 1 : 0;
7507 upper_insn = (upper_insn & ~(bfd_vma) 0x7ff)
7508 | ((relocation >> 12) & 0x3ff)
7509 | (reloc_sign << 10);
7510 lower_insn = (lower_insn & ~(bfd_vma) 0x2fff)
7511 | (((!((relocation >> 23) & 1)) ^ reloc_sign) << 13)
7512 | (((!((relocation >> 22) & 1)) ^ reloc_sign) << 11)
7513 | ((relocation >> 1) & 0x7ff);
7514
7515 /* Put the relocated value back in the object file: */
7516 bfd_put_16 (input_bfd, upper_insn, hit_data);
7517 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
7518
7519 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
7520 }
7521 break;
7522
7523 case R_ARM_THM_JUMP19:
7524 /* Thumb32 conditional branch instruction. */
7525 {
7526 bfd_vma relocation;
7527 bfd_boolean overflow = FALSE;
7528 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
7529 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
7530 bfd_signed_vma reloc_signed_max = 0xffffe;
7531 bfd_signed_vma reloc_signed_min = -0x100000;
7532 bfd_signed_vma signed_check;
7533
7534 /* Need to refetch the addend, reconstruct the top three bits,
7535 and squish the two 11 bit pieces together. */
7536 if (globals->use_rel)
7537 {
7538 bfd_vma S = (upper_insn & 0x0400) >> 10;
7539 bfd_vma upper = (upper_insn & 0x003f);
7540 bfd_vma J1 = (lower_insn & 0x2000) >> 13;
7541 bfd_vma J2 = (lower_insn & 0x0800) >> 11;
7542 bfd_vma lower = (lower_insn & 0x07ff);
7543
7544 upper |= J1 << 6;
7545 upper |= J2 << 7;
7546 upper |= (!S) << 8;
7547 upper -= 0x0100; /* Sign extend. */
7548
7549 addend = (upper << 12) | (lower << 1);
7550 signed_addend = addend;
7551 }
7552
7553 /* Handle calls via the PLT. */
7554 if (h != NULL && splt != NULL && h->plt.offset != (bfd_vma) -1)
7555 {
7556 value = (splt->output_section->vma
7557 + splt->output_offset
7558 + h->plt.offset);
7559 /* Target the Thumb stub before the ARM PLT entry. */
7560 value -= PLT_THUMB_STUB_SIZE;
7561 *unresolved_reloc_p = FALSE;
7562 }
7563
7564 /* ??? Should handle interworking? GCC might someday try to
7565 use this for tail calls. */
7566
7567 relocation = value + signed_addend;
7568 relocation -= (input_section->output_section->vma
7569 + input_section->output_offset
7570 + rel->r_offset);
7571 signed_check = (bfd_signed_vma) relocation;
7572
7573 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
7574 overflow = TRUE;
7575
7576 /* Put RELOCATION back into the insn. */
7577 {
7578 bfd_vma S = (relocation & 0x00100000) >> 20;
7579 bfd_vma J2 = (relocation & 0x00080000) >> 19;
7580 bfd_vma J1 = (relocation & 0x00040000) >> 18;
7581 bfd_vma hi = (relocation & 0x0003f000) >> 12;
7582 bfd_vma lo = (relocation & 0x00000ffe) >> 1;
7583
7584 upper_insn = (upper_insn & 0xfbc0) | (S << 10) | hi;
7585 lower_insn = (lower_insn & 0xd000) | (J1 << 13) | (J2 << 11) | lo;
7586 }
7587
7588 /* Put the relocated value back in the object file: */
7589 bfd_put_16 (input_bfd, upper_insn, hit_data);
7590 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
7591
7592 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
7593 }
7594
7595 case R_ARM_THM_JUMP11:
7596 case R_ARM_THM_JUMP8:
7597 case R_ARM_THM_JUMP6:
7598 /* Thumb B (branch) instruction). */
7599 {
7600 bfd_signed_vma relocation;
7601 bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
7602 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
7603 bfd_signed_vma signed_check;
7604
7605 /* CZB cannot jump backward. */
7606 if (r_type == R_ARM_THM_JUMP6)
7607 reloc_signed_min = 0;
7608
7609 if (globals->use_rel)
7610 {
7611 /* Need to refetch addend. */
7612 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
7613 if (addend & ((howto->src_mask + 1) >> 1))
7614 {
7615 signed_addend = -1;
7616 signed_addend &= ~ howto->src_mask;
7617 signed_addend |= addend;
7618 }
7619 else
7620 signed_addend = addend;
7621 /* The value in the insn has been right shifted. We need to
7622 undo this, so that we can perform the address calculation
7623 in terms of bytes. */
7624 signed_addend <<= howto->rightshift;
7625 }
7626 relocation = value + signed_addend;
7627
7628 relocation -= (input_section->output_section->vma
7629 + input_section->output_offset
7630 + rel->r_offset);
7631
7632 relocation >>= howto->rightshift;
7633 signed_check = relocation;
7634
7635 if (r_type == R_ARM_THM_JUMP6)
7636 relocation = ((relocation & 0x0020) << 4) | ((relocation & 0x001f) << 3);
7637 else
7638 relocation &= howto->dst_mask;
7639 relocation |= (bfd_get_16 (input_bfd, hit_data) & (~ howto->dst_mask));
7640
7641 bfd_put_16 (input_bfd, relocation, hit_data);
7642
7643 /* Assumes two's complement. */
7644 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
7645 return bfd_reloc_overflow;
7646
7647 return bfd_reloc_ok;
7648 }
7649
7650 case R_ARM_ALU_PCREL7_0:
7651 case R_ARM_ALU_PCREL15_8:
7652 case R_ARM_ALU_PCREL23_15:
7653 {
7654 bfd_vma insn;
7655 bfd_vma relocation;
7656
7657 insn = bfd_get_32 (input_bfd, hit_data);
7658 if (globals->use_rel)
7659 {
7660 /* Extract the addend. */
7661 addend = (insn & 0xff) << ((insn & 0xf00) >> 7);
7662 signed_addend = addend;
7663 }
7664 relocation = value + signed_addend;
7665
7666 relocation -= (input_section->output_section->vma
7667 + input_section->output_offset
7668 + rel->r_offset);
7669 insn = (insn & ~0xfff)
7670 | ((howto->bitpos << 7) & 0xf00)
7671 | ((relocation >> howto->bitpos) & 0xff);
7672 bfd_put_32 (input_bfd, value, hit_data);
7673 }
7674 return bfd_reloc_ok;
7675
7676 case R_ARM_GNU_VTINHERIT:
7677 case R_ARM_GNU_VTENTRY:
7678 return bfd_reloc_ok;
7679
7680 case R_ARM_GOTOFF32:
7681 /* Relocation is relative to the start of the
7682 global offset table. */
7683
7684 BFD_ASSERT (sgot != NULL);
7685 if (sgot == NULL)
7686 return bfd_reloc_notsupported;
7687
7688 /* If we are addressing a Thumb function, we need to adjust the
7689 address by one, so that attempts to call the function pointer will
7690 correctly interpret it as Thumb code. */
7691 if (sym_flags == STT_ARM_TFUNC)
7692 value += 1;
7693
7694 /* Note that sgot->output_offset is not involved in this
7695 calculation. We always want the start of .got. If we
7696 define _GLOBAL_OFFSET_TABLE in a different way, as is
7697 permitted by the ABI, we might have to change this
7698 calculation. */
7699 value -= sgot->output_section->vma;
7700 return _bfd_final_link_relocate (howto, input_bfd, input_section,
7701 contents, rel->r_offset, value,
7702 rel->r_addend);
7703
7704 case R_ARM_GOTPC:
7705 /* Use global offset table as symbol value. */
7706 BFD_ASSERT (sgot != NULL);
7707
7708 if (sgot == NULL)
7709 return bfd_reloc_notsupported;
7710
7711 *unresolved_reloc_p = FALSE;
7712 value = sgot->output_section->vma;
7713 return _bfd_final_link_relocate (howto, input_bfd, input_section,
7714 contents, rel->r_offset, value,
7715 rel->r_addend);
7716
7717 case R_ARM_GOT32:
7718 case R_ARM_GOT_PREL:
7719 /* Relocation is to the entry for this symbol in the
7720 global offset table. */
7721 if (sgot == NULL)
7722 return bfd_reloc_notsupported;
7723
7724 if (h != NULL)
7725 {
7726 bfd_vma off;
7727 bfd_boolean dyn;
7728
7729 off = h->got.offset;
7730 BFD_ASSERT (off != (bfd_vma) -1);
7731 dyn = globals->root.dynamic_sections_created;
7732
7733 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
7734 || (info->shared
7735 && SYMBOL_REFERENCES_LOCAL (info, h))
7736 || (ELF_ST_VISIBILITY (h->other)
7737 && h->root.type == bfd_link_hash_undefweak))
7738 {
7739 /* This is actually a static link, or it is a -Bsymbolic link
7740 and the symbol is defined locally. We must initialize this
7741 entry in the global offset table. Since the offset must
7742 always be a multiple of 4, we use the least significant bit
7743 to record whether we have initialized it already.
7744
7745 When doing a dynamic link, we create a .rel(a).got relocation
7746 entry to initialize the value. This is done in the
7747 finish_dynamic_symbol routine. */
7748 if ((off & 1) != 0)
7749 off &= ~1;
7750 else
7751 {
7752 /* If we are addressing a Thumb function, we need to
7753 adjust the address by one, so that attempts to
7754 call the function pointer will correctly
7755 interpret it as Thumb code. */
7756 if (sym_flags == STT_ARM_TFUNC)
7757 value |= 1;
7758
7759 bfd_put_32 (output_bfd, value, sgot->contents + off);
7760 h->got.offset |= 1;
7761 }
7762 }
7763 else
7764 *unresolved_reloc_p = FALSE;
7765
7766 value = sgot->output_offset + off;
7767 }
7768 else
7769 {
7770 bfd_vma off;
7771
7772 BFD_ASSERT (local_got_offsets != NULL &&
7773 local_got_offsets[r_symndx] != (bfd_vma) -1);
7774
7775 off = local_got_offsets[r_symndx];
7776
7777 /* The offset must always be a multiple of 4. We use the
7778 least significant bit to record whether we have already
7779 generated the necessary reloc. */
7780 if ((off & 1) != 0)
7781 off &= ~1;
7782 else
7783 {
7784 /* If we are addressing a Thumb function, we need to
7785 adjust the address by one, so that attempts to
7786 call the function pointer will correctly
7787 interpret it as Thumb code. */
7788 if (sym_flags == STT_ARM_TFUNC)
7789 value |= 1;
7790
7791 if (globals->use_rel)
7792 bfd_put_32 (output_bfd, value, sgot->contents + off);
7793
7794 if (info->shared)
7795 {
7796 asection * srelgot;
7797 Elf_Internal_Rela outrel;
7798 bfd_byte *loc;
7799
7800 srelgot = (bfd_get_section_by_name
7801 (dynobj, RELOC_SECTION (globals, ".got")));
7802 BFD_ASSERT (srelgot != NULL);
7803
7804 outrel.r_addend = addend + value;
7805 outrel.r_offset = (sgot->output_section->vma
7806 + sgot->output_offset
7807 + off);
7808 outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
7809 loc = srelgot->contents;
7810 loc += srelgot->reloc_count++ * RELOC_SIZE (globals);
7811 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
7812 }
7813
7814 local_got_offsets[r_symndx] |= 1;
7815 }
7816
7817 value = sgot->output_offset + off;
7818 }
7819 if (r_type != R_ARM_GOT32)
7820 value += sgot->output_section->vma;
7821
7822 return _bfd_final_link_relocate (howto, input_bfd, input_section,
7823 contents, rel->r_offset, value,
7824 rel->r_addend);
7825
7826 case R_ARM_TLS_LDO32:
7827 value = value - dtpoff_base (info);
7828
7829 return _bfd_final_link_relocate (howto, input_bfd, input_section,
7830 contents, rel->r_offset, value,
7831 rel->r_addend);
7832
7833 case R_ARM_TLS_LDM32:
7834 {
7835 bfd_vma off;
7836
7837 if (globals->sgot == NULL)
7838 abort ();
7839
7840 off = globals->tls_ldm_got.offset;
7841
7842 if ((off & 1) != 0)
7843 off &= ~1;
7844 else
7845 {
7846 /* If we don't know the module number, create a relocation
7847 for it. */
7848 if (info->shared)
7849 {
7850 Elf_Internal_Rela outrel;
7851 bfd_byte *loc;
7852
7853 if (globals->srelgot == NULL)
7854 abort ();
7855
7856 outrel.r_addend = 0;
7857 outrel.r_offset = (globals->sgot->output_section->vma
7858 + globals->sgot->output_offset + off);
7859 outrel.r_info = ELF32_R_INFO (0, R_ARM_TLS_DTPMOD32);
7860
7861 if (globals->use_rel)
7862 bfd_put_32 (output_bfd, outrel.r_addend,
7863 globals->sgot->contents + off);
7864
7865 loc = globals->srelgot->contents;
7866 loc += globals->srelgot->reloc_count++ * RELOC_SIZE (globals);
7867 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
7868 }
7869 else
7870 bfd_put_32 (output_bfd, 1, globals->sgot->contents + off);
7871
7872 globals->tls_ldm_got.offset |= 1;
7873 }
7874
7875 value = globals->sgot->output_section->vma + globals->sgot->output_offset + off
7876 - (input_section->output_section->vma + input_section->output_offset + rel->r_offset);
7877
7878 return _bfd_final_link_relocate (howto, input_bfd, input_section,
7879 contents, rel->r_offset, value,
7880 rel->r_addend);
7881 }
7882
7883 case R_ARM_TLS_GD32:
7884 case R_ARM_TLS_IE32:
7885 {
7886 bfd_vma off;
7887 int indx;
7888 char tls_type;
7889
7890 if (globals->sgot == NULL)
7891 abort ();
7892
7893 indx = 0;
7894 if (h != NULL)
7895 {
7896 bfd_boolean dyn;
7897 dyn = globals->root.dynamic_sections_created;
7898 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
7899 && (!info->shared
7900 || !SYMBOL_REFERENCES_LOCAL (info, h)))
7901 {
7902 *unresolved_reloc_p = FALSE;
7903 indx = h->dynindx;
7904 }
7905 off = h->got.offset;
7906 tls_type = ((struct elf32_arm_link_hash_entry *) h)->tls_type;
7907 }
7908 else
7909 {
7910 if (local_got_offsets == NULL)
7911 abort ();
7912 off = local_got_offsets[r_symndx];
7913 tls_type = elf32_arm_local_got_tls_type (input_bfd)[r_symndx];
7914 }
7915
7916 if (tls_type == GOT_UNKNOWN)
7917 abort ();
7918
7919 if ((off & 1) != 0)
7920 off &= ~1;
7921 else
7922 {
7923 bfd_boolean need_relocs = FALSE;
7924 Elf_Internal_Rela outrel;
7925 bfd_byte *loc = NULL;
7926 int cur_off = off;
7927
7928 /* The GOT entries have not been initialized yet. Do it
7929 now, and emit any relocations. If both an IE GOT and a
7930 GD GOT are necessary, we emit the GD first. */
7931
7932 if ((info->shared || indx != 0)
7933 && (h == NULL
7934 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
7935 || h->root.type != bfd_link_hash_undefweak))
7936 {
7937 need_relocs = TRUE;
7938 if (globals->srelgot == NULL)
7939 abort ();
7940 loc = globals->srelgot->contents;
7941 loc += globals->srelgot->reloc_count * RELOC_SIZE (globals);
7942 }
7943
7944 if (tls_type & GOT_TLS_GD)
7945 {
7946 if (need_relocs)
7947 {
7948 outrel.r_addend = 0;
7949 outrel.r_offset = (globals->sgot->output_section->vma
7950 + globals->sgot->output_offset
7951 + cur_off);
7952 outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_DTPMOD32);
7953
7954 if (globals->use_rel)
7955 bfd_put_32 (output_bfd, outrel.r_addend,
7956 globals->sgot->contents + cur_off);
7957
7958 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
7959 globals->srelgot->reloc_count++;
7960 loc += RELOC_SIZE (globals);
7961
7962 if (indx == 0)
7963 bfd_put_32 (output_bfd, value - dtpoff_base (info),
7964 globals->sgot->contents + cur_off + 4);
7965 else
7966 {
7967 outrel.r_addend = 0;
7968 outrel.r_info = ELF32_R_INFO (indx,
7969 R_ARM_TLS_DTPOFF32);
7970 outrel.r_offset += 4;
7971
7972 if (globals->use_rel)
7973 bfd_put_32 (output_bfd, outrel.r_addend,
7974 globals->sgot->contents + cur_off + 4);
7975
7976
7977 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
7978 globals->srelgot->reloc_count++;
7979 loc += RELOC_SIZE (globals);
7980 }
7981 }
7982 else
7983 {
7984 /* If we are not emitting relocations for a
7985 general dynamic reference, then we must be in a
7986 static link or an executable link with the
7987 symbol binding locally. Mark it as belonging
7988 to module 1, the executable. */
7989 bfd_put_32 (output_bfd, 1,
7990 globals->sgot->contents + cur_off);
7991 bfd_put_32 (output_bfd, value - dtpoff_base (info),
7992 globals->sgot->contents + cur_off + 4);
7993 }
7994
7995 cur_off += 8;
7996 }
7997
7998 if (tls_type & GOT_TLS_IE)
7999 {
8000 if (need_relocs)
8001 {
8002 if (indx == 0)
8003 outrel.r_addend = value - dtpoff_base (info);
8004 else
8005 outrel.r_addend = 0;
8006 outrel.r_offset = (globals->sgot->output_section->vma
8007 + globals->sgot->output_offset
8008 + cur_off);
8009 outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_TPOFF32);
8010
8011 if (globals->use_rel)
8012 bfd_put_32 (output_bfd, outrel.r_addend,
8013 globals->sgot->contents + cur_off);
8014
8015 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
8016 globals->srelgot->reloc_count++;
8017 loc += RELOC_SIZE (globals);
8018 }
8019 else
8020 bfd_put_32 (output_bfd, tpoff (info, value),
8021 globals->sgot->contents + cur_off);
8022 cur_off += 4;
8023 }
8024
8025 if (h != NULL)
8026 h->got.offset |= 1;
8027 else
8028 local_got_offsets[r_symndx] |= 1;
8029 }
8030
8031 if ((tls_type & GOT_TLS_GD) && r_type != R_ARM_TLS_GD32)
8032 off += 8;
8033 value = globals->sgot->output_section->vma + globals->sgot->output_offset + off
8034 - (input_section->output_section->vma + input_section->output_offset + rel->r_offset);
8035
8036 return _bfd_final_link_relocate (howto, input_bfd, input_section,
8037 contents, rel->r_offset, value,
8038 rel->r_addend);
8039 }
8040
8041 case R_ARM_TLS_LE32:
8042 if (info->shared)
8043 {
8044 (*_bfd_error_handler)
8045 (_("%B(%A+0x%lx): R_ARM_TLS_LE32 relocation not permitted in shared object"),
8046 input_bfd, input_section,
8047 (long) rel->r_offset, howto->name);
8048 return FALSE;
8049 }
8050 else
8051 value = tpoff (info, value);
8052
8053 return _bfd_final_link_relocate (howto, input_bfd, input_section,
8054 contents, rel->r_offset, value,
8055 rel->r_addend);
8056
8057 case R_ARM_V4BX:
8058 if (globals->fix_v4bx)
8059 {
8060 bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
8061
8062 /* Ensure that we have a BX instruction. */
8063 BFD_ASSERT ((insn & 0x0ffffff0) == 0x012fff10);
8064
8065 if (globals->fix_v4bx == 2 && (insn & 0xf) != 0xf)
8066 {
8067 /* Branch to veneer. */
8068 bfd_vma glue_addr;
8069 glue_addr = elf32_arm_bx_glue (info, insn & 0xf);
8070 glue_addr -= input_section->output_section->vma
8071 + input_section->output_offset
8072 + rel->r_offset + 8;
8073 insn = (insn & 0xf0000000) | 0x0a000000
8074 | ((glue_addr >> 2) & 0x00ffffff);
8075 }
8076 else
8077 {
8078 /* Preserve Rm (lowest four bits) and the condition code
8079 (highest four bits). Other bits encode MOV PC,Rm. */
8080 insn = (insn & 0xf000000f) | 0x01a0f000;
8081 }
8082
8083 bfd_put_32 (input_bfd, insn, hit_data);
8084 }
8085 return bfd_reloc_ok;
8086
8087 case R_ARM_MOVW_ABS_NC:
8088 case R_ARM_MOVT_ABS:
8089 case R_ARM_MOVW_PREL_NC:
8090 case R_ARM_MOVT_PREL:
8091 /* Until we properly support segment-base-relative addressing then
8092 we assume the segment base to be zero, as for the group relocations.
8093 Thus R_ARM_MOVW_BREL_NC has the same semantics as R_ARM_MOVW_ABS_NC
8094 and R_ARM_MOVT_BREL has the same semantics as R_ARM_MOVT_ABS. */
8095 case R_ARM_MOVW_BREL_NC:
8096 case R_ARM_MOVW_BREL:
8097 case R_ARM_MOVT_BREL:
8098 {
8099 bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
8100
8101 if (globals->use_rel)
8102 {
8103 addend = ((insn >> 4) & 0xf000) | (insn & 0xfff);
8104 signed_addend = (addend ^ 0x8000) - 0x8000;
8105 }
8106
8107 value += signed_addend;
8108
8109 if (r_type == R_ARM_MOVW_PREL_NC || r_type == R_ARM_MOVT_PREL)
8110 value -= (input_section->output_section->vma
8111 + input_section->output_offset + rel->r_offset);
8112
8113 if (r_type == R_ARM_MOVW_BREL && value >= 0x10000)
8114 return bfd_reloc_overflow;
8115
8116 if (sym_flags == STT_ARM_TFUNC)
8117 value |= 1;
8118
8119 if (r_type == R_ARM_MOVT_ABS || r_type == R_ARM_MOVT_PREL
8120 || r_type == R_ARM_MOVT_BREL)
8121 value >>= 16;
8122
8123 insn &= 0xfff0f000;
8124 insn |= value & 0xfff;
8125 insn |= (value & 0xf000) << 4;
8126 bfd_put_32 (input_bfd, insn, hit_data);
8127 }
8128 return bfd_reloc_ok;
8129
8130 case R_ARM_THM_MOVW_ABS_NC:
8131 case R_ARM_THM_MOVT_ABS:
8132 case R_ARM_THM_MOVW_PREL_NC:
8133 case R_ARM_THM_MOVT_PREL:
8134 /* Until we properly support segment-base-relative addressing then
8135 we assume the segment base to be zero, as for the above relocations.
8136 Thus R_ARM_THM_MOVW_BREL_NC has the same semantics as
8137 R_ARM_THM_MOVW_ABS_NC and R_ARM_THM_MOVT_BREL has the same semantics
8138 as R_ARM_THM_MOVT_ABS. */
8139 case R_ARM_THM_MOVW_BREL_NC:
8140 case R_ARM_THM_MOVW_BREL:
8141 case R_ARM_THM_MOVT_BREL:
8142 {
8143 bfd_vma insn;
8144
8145 insn = bfd_get_16 (input_bfd, hit_data) << 16;
8146 insn |= bfd_get_16 (input_bfd, hit_data + 2);
8147
8148 if (globals->use_rel)
8149 {
8150 addend = ((insn >> 4) & 0xf000)
8151 | ((insn >> 15) & 0x0800)
8152 | ((insn >> 4) & 0x0700)
8153 | (insn & 0x00ff);
8154 signed_addend = (addend ^ 0x8000) - 0x8000;
8155 }
8156
8157 value += signed_addend;
8158
8159 if (r_type == R_ARM_THM_MOVW_PREL_NC || r_type == R_ARM_THM_MOVT_PREL)
8160 value -= (input_section->output_section->vma
8161 + input_section->output_offset + rel->r_offset);
8162
8163 if (r_type == R_ARM_THM_MOVW_BREL && value >= 0x10000)
8164 return bfd_reloc_overflow;
8165
8166 if (sym_flags == STT_ARM_TFUNC)
8167 value |= 1;
8168
8169 if (r_type == R_ARM_THM_MOVT_ABS || r_type == R_ARM_THM_MOVT_PREL
8170 || r_type == R_ARM_THM_MOVT_BREL)
8171 value >>= 16;
8172
8173 insn &= 0xfbf08f00;
8174 insn |= (value & 0xf000) << 4;
8175 insn |= (value & 0x0800) << 15;
8176 insn |= (value & 0x0700) << 4;
8177 insn |= (value & 0x00ff);
8178
8179 bfd_put_16 (input_bfd, insn >> 16, hit_data);
8180 bfd_put_16 (input_bfd, insn & 0xffff, hit_data + 2);
8181 }
8182 return bfd_reloc_ok;
8183
8184 case R_ARM_ALU_PC_G0_NC:
8185 case R_ARM_ALU_PC_G1_NC:
8186 case R_ARM_ALU_PC_G0:
8187 case R_ARM_ALU_PC_G1:
8188 case R_ARM_ALU_PC_G2:
8189 case R_ARM_ALU_SB_G0_NC:
8190 case R_ARM_ALU_SB_G1_NC:
8191 case R_ARM_ALU_SB_G0:
8192 case R_ARM_ALU_SB_G1:
8193 case R_ARM_ALU_SB_G2:
8194 {
8195 bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
8196 bfd_vma pc = input_section->output_section->vma
8197 + input_section->output_offset + rel->r_offset;
8198 /* sb should be the origin of the *segment* containing the symbol.
8199 It is not clear how to obtain this OS-dependent value, so we
8200 make an arbitrary choice of zero. */
8201 bfd_vma sb = 0;
8202 bfd_vma residual;
8203 bfd_vma g_n;
8204 bfd_signed_vma signed_value;
8205 int group = 0;
8206
8207 /* Determine which group of bits to select. */
8208 switch (r_type)
8209 {
8210 case R_ARM_ALU_PC_G0_NC:
8211 case R_ARM_ALU_PC_G0:
8212 case R_ARM_ALU_SB_G0_NC:
8213 case R_ARM_ALU_SB_G0:
8214 group = 0;
8215 break;
8216
8217 case R_ARM_ALU_PC_G1_NC:
8218 case R_ARM_ALU_PC_G1:
8219 case R_ARM_ALU_SB_G1_NC:
8220 case R_ARM_ALU_SB_G1:
8221 group = 1;
8222 break;
8223
8224 case R_ARM_ALU_PC_G2:
8225 case R_ARM_ALU_SB_G2:
8226 group = 2;
8227 break;
8228
8229 default:
8230 abort ();
8231 }
8232
8233 /* If REL, extract the addend from the insn. If RELA, it will
8234 have already been fetched for us. */
8235 if (globals->use_rel)
8236 {
8237 int negative;
8238 bfd_vma constant = insn & 0xff;
8239 bfd_vma rotation = (insn & 0xf00) >> 8;
8240
8241 if (rotation == 0)
8242 signed_addend = constant;
8243 else
8244 {
8245 /* Compensate for the fact that in the instruction, the
8246 rotation is stored in multiples of 2 bits. */
8247 rotation *= 2;
8248
8249 /* Rotate "constant" right by "rotation" bits. */
8250 signed_addend = (constant >> rotation) |
8251 (constant << (8 * sizeof (bfd_vma) - rotation));
8252 }
8253
8254 /* Determine if the instruction is an ADD or a SUB.
8255 (For REL, this determines the sign of the addend.) */
8256 negative = identify_add_or_sub (insn);
8257 if (negative == 0)
8258 {
8259 (*_bfd_error_handler)
8260 (_("%B(%A+0x%lx): Only ADD or SUB instructions are allowed for ALU group relocations"),
8261 input_bfd, input_section,
8262 (long) rel->r_offset, howto->name);
8263 return bfd_reloc_overflow;
8264 }
8265
8266 signed_addend *= negative;
8267 }
8268
8269 /* Compute the value (X) to go in the place. */
8270 if (r_type == R_ARM_ALU_PC_G0_NC
8271 || r_type == R_ARM_ALU_PC_G1_NC
8272 || r_type == R_ARM_ALU_PC_G0
8273 || r_type == R_ARM_ALU_PC_G1
8274 || r_type == R_ARM_ALU_PC_G2)
8275 /* PC relative. */
8276 signed_value = value - pc + signed_addend;
8277 else
8278 /* Section base relative. */
8279 signed_value = value - sb + signed_addend;
8280
8281 /* If the target symbol is a Thumb function, then set the
8282 Thumb bit in the address. */
8283 if (sym_flags == STT_ARM_TFUNC)
8284 signed_value |= 1;
8285
8286 /* Calculate the value of the relevant G_n, in encoded
8287 constant-with-rotation format. */
8288 g_n = calculate_group_reloc_mask (abs (signed_value), group,
8289 &residual);
8290
8291 /* Check for overflow if required. */
8292 if ((r_type == R_ARM_ALU_PC_G0
8293 || r_type == R_ARM_ALU_PC_G1
8294 || r_type == R_ARM_ALU_PC_G2
8295 || r_type == R_ARM_ALU_SB_G0
8296 || r_type == R_ARM_ALU_SB_G1
8297 || r_type == R_ARM_ALU_SB_G2) && residual != 0)
8298 {
8299 (*_bfd_error_handler)
8300 (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
8301 input_bfd, input_section,
8302 (long) rel->r_offset, abs (signed_value), howto->name);
8303 return bfd_reloc_overflow;
8304 }
8305
8306 /* Mask out the value and the ADD/SUB part of the opcode; take care
8307 not to destroy the S bit. */
8308 insn &= 0xff1ff000;
8309
8310 /* Set the opcode according to whether the value to go in the
8311 place is negative. */
8312 if (signed_value < 0)
8313 insn |= 1 << 22;
8314 else
8315 insn |= 1 << 23;
8316
8317 /* Encode the offset. */
8318 insn |= g_n;
8319
8320 bfd_put_32 (input_bfd, insn, hit_data);
8321 }
8322 return bfd_reloc_ok;
8323
8324 case R_ARM_LDR_PC_G0:
8325 case R_ARM_LDR_PC_G1:
8326 case R_ARM_LDR_PC_G2:
8327 case R_ARM_LDR_SB_G0:
8328 case R_ARM_LDR_SB_G1:
8329 case R_ARM_LDR_SB_G2:
8330 {
8331 bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
8332 bfd_vma pc = input_section->output_section->vma
8333 + input_section->output_offset + rel->r_offset;
8334 bfd_vma sb = 0; /* See note above. */
8335 bfd_vma residual;
8336 bfd_signed_vma signed_value;
8337 int group = 0;
8338
8339 /* Determine which groups of bits to calculate. */
8340 switch (r_type)
8341 {
8342 case R_ARM_LDR_PC_G0:
8343 case R_ARM_LDR_SB_G0:
8344 group = 0;
8345 break;
8346
8347 case R_ARM_LDR_PC_G1:
8348 case R_ARM_LDR_SB_G1:
8349 group = 1;
8350 break;
8351
8352 case R_ARM_LDR_PC_G2:
8353 case R_ARM_LDR_SB_G2:
8354 group = 2;
8355 break;
8356
8357 default:
8358 abort ();
8359 }
8360
8361 /* If REL, extract the addend from the insn. If RELA, it will
8362 have already been fetched for us. */
8363 if (globals->use_rel)
8364 {
8365 int negative = (insn & (1 << 23)) ? 1 : -1;
8366 signed_addend = negative * (insn & 0xfff);
8367 }
8368
8369 /* Compute the value (X) to go in the place. */
8370 if (r_type == R_ARM_LDR_PC_G0
8371 || r_type == R_ARM_LDR_PC_G1
8372 || r_type == R_ARM_LDR_PC_G2)
8373 /* PC relative. */
8374 signed_value = value - pc + signed_addend;
8375 else
8376 /* Section base relative. */
8377 signed_value = value - sb + signed_addend;
8378
8379 /* Calculate the value of the relevant G_{n-1} to obtain
8380 the residual at that stage. */
8381 calculate_group_reloc_mask (abs (signed_value), group - 1, &residual);
8382
8383 /* Check for overflow. */
8384 if (residual >= 0x1000)
8385 {
8386 (*_bfd_error_handler)
8387 (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
8388 input_bfd, input_section,
8389 (long) rel->r_offset, abs (signed_value), howto->name);
8390 return bfd_reloc_overflow;
8391 }
8392
8393 /* Mask out the value and U bit. */
8394 insn &= 0xff7ff000;
8395
8396 /* Set the U bit if the value to go in the place is non-negative. */
8397 if (signed_value >= 0)
8398 insn |= 1 << 23;
8399
8400 /* Encode the offset. */
8401 insn |= residual;
8402
8403 bfd_put_32 (input_bfd, insn, hit_data);
8404 }
8405 return bfd_reloc_ok;
8406
8407 case R_ARM_LDRS_PC_G0:
8408 case R_ARM_LDRS_PC_G1:
8409 case R_ARM_LDRS_PC_G2:
8410 case R_ARM_LDRS_SB_G0:
8411 case R_ARM_LDRS_SB_G1:
8412 case R_ARM_LDRS_SB_G2:
8413 {
8414 bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
8415 bfd_vma pc = input_section->output_section->vma
8416 + input_section->output_offset + rel->r_offset;
8417 bfd_vma sb = 0; /* See note above. */
8418 bfd_vma residual;
8419 bfd_signed_vma signed_value;
8420 int group = 0;
8421
8422 /* Determine which groups of bits to calculate. */
8423 switch (r_type)
8424 {
8425 case R_ARM_LDRS_PC_G0:
8426 case R_ARM_LDRS_SB_G0:
8427 group = 0;
8428 break;
8429
8430 case R_ARM_LDRS_PC_G1:
8431 case R_ARM_LDRS_SB_G1:
8432 group = 1;
8433 break;
8434
8435 case R_ARM_LDRS_PC_G2:
8436 case R_ARM_LDRS_SB_G2:
8437 group = 2;
8438 break;
8439
8440 default:
8441 abort ();
8442 }
8443
8444 /* If REL, extract the addend from the insn. If RELA, it will
8445 have already been fetched for us. */
8446 if (globals->use_rel)
8447 {
8448 int negative = (insn & (1 << 23)) ? 1 : -1;
8449 signed_addend = negative * (((insn & 0xf00) >> 4) + (insn & 0xf));
8450 }
8451
8452 /* Compute the value (X) to go in the place. */
8453 if (r_type == R_ARM_LDRS_PC_G0
8454 || r_type == R_ARM_LDRS_PC_G1
8455 || r_type == R_ARM_LDRS_PC_G2)
8456 /* PC relative. */
8457 signed_value = value - pc + signed_addend;
8458 else
8459 /* Section base relative. */
8460 signed_value = value - sb + signed_addend;
8461
8462 /* Calculate the value of the relevant G_{n-1} to obtain
8463 the residual at that stage. */
8464 calculate_group_reloc_mask (abs (signed_value), group - 1, &residual);
8465
8466 /* Check for overflow. */
8467 if (residual >= 0x100)
8468 {
8469 (*_bfd_error_handler)
8470 (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
8471 input_bfd, input_section,
8472 (long) rel->r_offset, abs (signed_value), howto->name);
8473 return bfd_reloc_overflow;
8474 }
8475
8476 /* Mask out the value and U bit. */
8477 insn &= 0xff7ff0f0;
8478
8479 /* Set the U bit if the value to go in the place is non-negative. */
8480 if (signed_value >= 0)
8481 insn |= 1 << 23;
8482
8483 /* Encode the offset. */
8484 insn |= ((residual & 0xf0) << 4) | (residual & 0xf);
8485
8486 bfd_put_32 (input_bfd, insn, hit_data);
8487 }
8488 return bfd_reloc_ok;
8489
8490 case R_ARM_LDC_PC_G0:
8491 case R_ARM_LDC_PC_G1:
8492 case R_ARM_LDC_PC_G2:
8493 case R_ARM_LDC_SB_G0:
8494 case R_ARM_LDC_SB_G1:
8495 case R_ARM_LDC_SB_G2:
8496 {
8497 bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
8498 bfd_vma pc = input_section->output_section->vma
8499 + input_section->output_offset + rel->r_offset;
8500 bfd_vma sb = 0; /* See note above. */
8501 bfd_vma residual;
8502 bfd_signed_vma signed_value;
8503 int group = 0;
8504
8505 /* Determine which groups of bits to calculate. */
8506 switch (r_type)
8507 {
8508 case R_ARM_LDC_PC_G0:
8509 case R_ARM_LDC_SB_G0:
8510 group = 0;
8511 break;
8512
8513 case R_ARM_LDC_PC_G1:
8514 case R_ARM_LDC_SB_G1:
8515 group = 1;
8516 break;
8517
8518 case R_ARM_LDC_PC_G2:
8519 case R_ARM_LDC_SB_G2:
8520 group = 2;
8521 break;
8522
8523 default:
8524 abort ();
8525 }
8526
8527 /* If REL, extract the addend from the insn. If RELA, it will
8528 have already been fetched for us. */
8529 if (globals->use_rel)
8530 {
8531 int negative = (insn & (1 << 23)) ? 1 : -1;
8532 signed_addend = negative * ((insn & 0xff) << 2);
8533 }
8534
8535 /* Compute the value (X) to go in the place. */
8536 if (r_type == R_ARM_LDC_PC_G0
8537 || r_type == R_ARM_LDC_PC_G1
8538 || r_type == R_ARM_LDC_PC_G2)
8539 /* PC relative. */
8540 signed_value = value - pc + signed_addend;
8541 else
8542 /* Section base relative. */
8543 signed_value = value - sb + signed_addend;
8544
8545 /* Calculate the value of the relevant G_{n-1} to obtain
8546 the residual at that stage. */
8547 calculate_group_reloc_mask (abs (signed_value), group - 1, &residual);
8548
8549 /* Check for overflow. (The absolute value to go in the place must be
8550 divisible by four and, after having been divided by four, must
8551 fit in eight bits.) */
8552 if ((residual & 0x3) != 0 || residual >= 0x400)
8553 {
8554 (*_bfd_error_handler)
8555 (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
8556 input_bfd, input_section,
8557 (long) rel->r_offset, abs (signed_value), howto->name);
8558 return bfd_reloc_overflow;
8559 }
8560
8561 /* Mask out the value and U bit. */
8562 insn &= 0xff7fff00;
8563
8564 /* Set the U bit if the value to go in the place is non-negative. */
8565 if (signed_value >= 0)
8566 insn |= 1 << 23;
8567
8568 /* Encode the offset. */
8569 insn |= residual >> 2;
8570
8571 bfd_put_32 (input_bfd, insn, hit_data);
8572 }
8573 return bfd_reloc_ok;
8574
8575 default:
8576 return bfd_reloc_notsupported;
8577 }
8578 }
8579
8580 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
8581 static void
8582 arm_add_to_rel (bfd * abfd,
8583 bfd_byte * address,
8584 reloc_howto_type * howto,
8585 bfd_signed_vma increment)
8586 {
8587 bfd_signed_vma addend;
8588
8589 if (howto->type == R_ARM_THM_CALL
8590 || howto->type == R_ARM_THM_JUMP24)
8591 {
8592 int upper_insn, lower_insn;
8593 int upper, lower;
8594
8595 upper_insn = bfd_get_16 (abfd, address);
8596 lower_insn = bfd_get_16 (abfd, address + 2);
8597 upper = upper_insn & 0x7ff;
8598 lower = lower_insn & 0x7ff;
8599
8600 addend = (upper << 12) | (lower << 1);
8601 addend += increment;
8602 addend >>= 1;
8603
8604 upper_insn = (upper_insn & 0xf800) | ((addend >> 11) & 0x7ff);
8605 lower_insn = (lower_insn & 0xf800) | (addend & 0x7ff);
8606
8607 bfd_put_16 (abfd, (bfd_vma) upper_insn, address);
8608 bfd_put_16 (abfd, (bfd_vma) lower_insn, address + 2);
8609 }
8610 else
8611 {
8612 bfd_vma contents;
8613
8614 contents = bfd_get_32 (abfd, address);
8615
8616 /* Get the (signed) value from the instruction. */
8617 addend = contents & howto->src_mask;
8618 if (addend & ((howto->src_mask + 1) >> 1))
8619 {
8620 bfd_signed_vma mask;
8621
8622 mask = -1;
8623 mask &= ~ howto->src_mask;
8624 addend |= mask;
8625 }
8626
8627 /* Add in the increment, (which is a byte value). */
8628 switch (howto->type)
8629 {
8630 default:
8631 addend += increment;
8632 break;
8633
8634 case R_ARM_PC24:
8635 case R_ARM_PLT32:
8636 case R_ARM_CALL:
8637 case R_ARM_JUMP24:
8638 addend <<= howto->size;
8639 addend += increment;
8640
8641 /* Should we check for overflow here ? */
8642
8643 /* Drop any undesired bits. */
8644 addend >>= howto->rightshift;
8645 break;
8646 }
8647
8648 contents = (contents & ~ howto->dst_mask) | (addend & howto->dst_mask);
8649
8650 bfd_put_32 (abfd, contents, address);
8651 }
8652 }
8653
8654 #define IS_ARM_TLS_RELOC(R_TYPE) \
8655 ((R_TYPE) == R_ARM_TLS_GD32 \
8656 || (R_TYPE) == R_ARM_TLS_LDO32 \
8657 || (R_TYPE) == R_ARM_TLS_LDM32 \
8658 || (R_TYPE) == R_ARM_TLS_DTPOFF32 \
8659 || (R_TYPE) == R_ARM_TLS_DTPMOD32 \
8660 || (R_TYPE) == R_ARM_TLS_TPOFF32 \
8661 || (R_TYPE) == R_ARM_TLS_LE32 \
8662 || (R_TYPE) == R_ARM_TLS_IE32)
8663
8664 /* Relocate an ARM ELF section. */
8665
8666 static bfd_boolean
8667 elf32_arm_relocate_section (bfd * output_bfd,
8668 struct bfd_link_info * info,
8669 bfd * input_bfd,
8670 asection * input_section,
8671 bfd_byte * contents,
8672 Elf_Internal_Rela * relocs,
8673 Elf_Internal_Sym * local_syms,
8674 asection ** local_sections)
8675 {
8676 Elf_Internal_Shdr *symtab_hdr;
8677 struct elf_link_hash_entry **sym_hashes;
8678 Elf_Internal_Rela *rel;
8679 Elf_Internal_Rela *relend;
8680 const char *name;
8681 struct elf32_arm_link_hash_table * globals;
8682
8683 globals = elf32_arm_hash_table (info);
8684
8685 symtab_hdr = & elf_symtab_hdr (input_bfd);
8686 sym_hashes = elf_sym_hashes (input_bfd);
8687
8688 rel = relocs;
8689 relend = relocs + input_section->reloc_count;
8690 for (; rel < relend; rel++)
8691 {
8692 int r_type;
8693 reloc_howto_type * howto;
8694 unsigned long r_symndx;
8695 Elf_Internal_Sym * sym;
8696 asection * sec;
8697 struct elf_link_hash_entry * h;
8698 bfd_vma relocation;
8699 bfd_reloc_status_type r;
8700 arelent bfd_reloc;
8701 char sym_type;
8702 bfd_boolean unresolved_reloc = FALSE;
8703 char *error_message = NULL;
8704
8705 r_symndx = ELF32_R_SYM (rel->r_info);
8706 r_type = ELF32_R_TYPE (rel->r_info);
8707 r_type = arm_real_reloc_type (globals, r_type);
8708
8709 if ( r_type == R_ARM_GNU_VTENTRY
8710 || r_type == R_ARM_GNU_VTINHERIT)
8711 continue;
8712
8713 bfd_reloc.howto = elf32_arm_howto_from_type (r_type);
8714 howto = bfd_reloc.howto;
8715
8716 h = NULL;
8717 sym = NULL;
8718 sec = NULL;
8719
8720 if (r_symndx < symtab_hdr->sh_info)
8721 {
8722 sym = local_syms + r_symndx;
8723 sym_type = ELF32_ST_TYPE (sym->st_info);
8724 sec = local_sections[r_symndx];
8725
8726 /* An object file might have a reference to a local
8727 undefined symbol. This is a daft object file, but we
8728 should at least do something about it. V4BX & NONE
8729 relocations do not use the symbol and are explicitly
8730 allowed to use the undefined symbol, so allow those. */
8731 if (r_type != R_ARM_V4BX
8732 && r_type != R_ARM_NONE
8733 && bfd_is_und_section (sec)
8734 && ELF_ST_BIND (sym->st_info) != STB_WEAK)
8735 {
8736 if (!info->callbacks->undefined_symbol
8737 (info, bfd_elf_string_from_elf_section
8738 (input_bfd, symtab_hdr->sh_link, sym->st_name),
8739 input_bfd, input_section,
8740 rel->r_offset, TRUE))
8741 return FALSE;
8742 }
8743
8744 if (globals->use_rel)
8745 {
8746 relocation = (sec->output_section->vma
8747 + sec->output_offset
8748 + sym->st_value);
8749 if (!info->relocatable
8750 && (sec->flags & SEC_MERGE)
8751 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
8752 {
8753 asection *msec;
8754 bfd_vma addend, value;
8755
8756 switch (r_type)
8757 {
8758 case R_ARM_MOVW_ABS_NC:
8759 case R_ARM_MOVT_ABS:
8760 value = bfd_get_32 (input_bfd, contents + rel->r_offset);
8761 addend = ((value & 0xf0000) >> 4) | (value & 0xfff);
8762 addend = (addend ^ 0x8000) - 0x8000;
8763 break;
8764
8765 case R_ARM_THM_MOVW_ABS_NC:
8766 case R_ARM_THM_MOVT_ABS:
8767 value = bfd_get_16 (input_bfd, contents + rel->r_offset)
8768 << 16;
8769 value |= bfd_get_16 (input_bfd,
8770 contents + rel->r_offset + 2);
8771 addend = ((value & 0xf7000) >> 4) | (value & 0xff)
8772 | ((value & 0x04000000) >> 15);
8773 addend = (addend ^ 0x8000) - 0x8000;
8774 break;
8775
8776 default:
8777 if (howto->rightshift
8778 || (howto->src_mask & (howto->src_mask + 1)))
8779 {
8780 (*_bfd_error_handler)
8781 (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
8782 input_bfd, input_section,
8783 (long) rel->r_offset, howto->name);
8784 return FALSE;
8785 }
8786
8787 value = bfd_get_32 (input_bfd, contents + rel->r_offset);
8788
8789 /* Get the (signed) value from the instruction. */
8790 addend = value & howto->src_mask;
8791 if (addend & ((howto->src_mask + 1) >> 1))
8792 {
8793 bfd_signed_vma mask;
8794
8795 mask = -1;
8796 mask &= ~ howto->src_mask;
8797 addend |= mask;
8798 }
8799 break;
8800 }
8801
8802 msec = sec;
8803 addend =
8804 _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
8805 - relocation;
8806 addend += msec->output_section->vma + msec->output_offset;
8807
8808 /* Cases here must match those in the preceeding
8809 switch statement. */
8810 switch (r_type)
8811 {
8812 case R_ARM_MOVW_ABS_NC:
8813 case R_ARM_MOVT_ABS:
8814 value = (value & 0xfff0f000) | ((addend & 0xf000) << 4)
8815 | (addend & 0xfff);
8816 bfd_put_32 (input_bfd, value, contents + rel->r_offset);
8817 break;
8818
8819 case R_ARM_THM_MOVW_ABS_NC:
8820 case R_ARM_THM_MOVT_ABS:
8821 value = (value & 0xfbf08f00) | ((addend & 0xf700) << 4)
8822 | (addend & 0xff) | ((addend & 0x0800) << 15);
8823 bfd_put_16 (input_bfd, value >> 16,
8824 contents + rel->r_offset);
8825 bfd_put_16 (input_bfd, value,
8826 contents + rel->r_offset + 2);
8827 break;
8828
8829 default:
8830 value = (value & ~ howto->dst_mask)
8831 | (addend & howto->dst_mask);
8832 bfd_put_32 (input_bfd, value, contents + rel->r_offset);
8833 break;
8834 }
8835 }
8836 }
8837 else
8838 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
8839 }
8840 else
8841 {
8842 bfd_boolean warned;
8843
8844 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
8845 r_symndx, symtab_hdr, sym_hashes,
8846 h, sec, relocation,
8847 unresolved_reloc, warned);
8848
8849 sym_type = h->type;
8850 }
8851
8852 if (sec != NULL && elf_discarded_section (sec))
8853 {
8854 /* For relocs against symbols from removed linkonce sections,
8855 or sections discarded by a linker script, we just want the
8856 section contents zeroed. Avoid any special processing. */
8857 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
8858 rel->r_info = 0;
8859 rel->r_addend = 0;
8860 continue;
8861 }
8862
8863 if (info->relocatable)
8864 {
8865 /* This is a relocatable link. We don't have to change
8866 anything, unless the reloc is against a section symbol,
8867 in which case we have to adjust according to where the
8868 section symbol winds up in the output section. */
8869 if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
8870 {
8871 if (globals->use_rel)
8872 arm_add_to_rel (input_bfd, contents + rel->r_offset,
8873 howto, (bfd_signed_vma) sec->output_offset);
8874 else
8875 rel->r_addend += sec->output_offset;
8876 }
8877 continue;
8878 }
8879
8880 if (h != NULL)
8881 name = h->root.root.string;
8882 else
8883 {
8884 name = (bfd_elf_string_from_elf_section
8885 (input_bfd, symtab_hdr->sh_link, sym->st_name));
8886 if (name == NULL || *name == '\0')
8887 name = bfd_section_name (input_bfd, sec);
8888 }
8889
8890 if (r_symndx != 0
8891 && r_type != R_ARM_NONE
8892 && (h == NULL
8893 || h->root.type == bfd_link_hash_defined
8894 || h->root.type == bfd_link_hash_defweak)
8895 && IS_ARM_TLS_RELOC (r_type) != (sym_type == STT_TLS))
8896 {
8897 (*_bfd_error_handler)
8898 ((sym_type == STT_TLS
8899 ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
8900 : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
8901 input_bfd,
8902 input_section,
8903 (long) rel->r_offset,
8904 howto->name,
8905 name);
8906 }
8907
8908 r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
8909 input_section, contents, rel,
8910 relocation, info, sec, name,
8911 (h ? ELF_ST_TYPE (h->type) :
8912 ELF_ST_TYPE (sym->st_info)), h,
8913 &unresolved_reloc, &error_message);
8914
8915 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
8916 because such sections are not SEC_ALLOC and thus ld.so will
8917 not process them. */
8918 if (unresolved_reloc
8919 && !((input_section->flags & SEC_DEBUGGING) != 0
8920 && h->def_dynamic))
8921 {
8922 (*_bfd_error_handler)
8923 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
8924 input_bfd,
8925 input_section,
8926 (long) rel->r_offset,
8927 howto->name,
8928 h->root.root.string);
8929 return FALSE;
8930 }
8931
8932 if (r != bfd_reloc_ok)
8933 {
8934 switch (r)
8935 {
8936 case bfd_reloc_overflow:
8937 /* If the overflowing reloc was to an undefined symbol,
8938 we have already printed one error message and there
8939 is no point complaining again. */
8940 if ((! h ||
8941 h->root.type != bfd_link_hash_undefined)
8942 && (!((*info->callbacks->reloc_overflow)
8943 (info, (h ? &h->root : NULL), name, howto->name,
8944 (bfd_vma) 0, input_bfd, input_section,
8945 rel->r_offset))))
8946 return FALSE;
8947 break;
8948
8949 case bfd_reloc_undefined:
8950 if (!((*info->callbacks->undefined_symbol)
8951 (info, name, input_bfd, input_section,
8952 rel->r_offset, TRUE)))
8953 return FALSE;
8954 break;
8955
8956 case bfd_reloc_outofrange:
8957 error_message = _("out of range");
8958 goto common_error;
8959
8960 case bfd_reloc_notsupported:
8961 error_message = _("unsupported relocation");
8962 goto common_error;
8963
8964 case bfd_reloc_dangerous:
8965 /* error_message should already be set. */
8966 goto common_error;
8967
8968 default:
8969 error_message = _("unknown error");
8970 /* Fall through. */
8971
8972 common_error:
8973 BFD_ASSERT (error_message != NULL);
8974 if (!((*info->callbacks->reloc_dangerous)
8975 (info, error_message, input_bfd, input_section,
8976 rel->r_offset)))
8977 return FALSE;
8978 break;
8979 }
8980 }
8981 }
8982
8983 return TRUE;
8984 }
8985
8986 /* Add a new unwind edit to the list described by HEAD, TAIL. If INDEX is zero,
8987 adds the edit to the start of the list. (The list must be built in order of
8988 ascending INDEX: the function's callers are primarily responsible for
8989 maintaining that condition). */
8990
8991 static void
8992 add_unwind_table_edit (arm_unwind_table_edit **head,
8993 arm_unwind_table_edit **tail,
8994 arm_unwind_edit_type type,
8995 asection *linked_section,
8996 unsigned int index)
8997 {
8998 arm_unwind_table_edit *new_edit = xmalloc (sizeof (arm_unwind_table_edit));
8999
9000 new_edit->type = type;
9001 new_edit->linked_section = linked_section;
9002 new_edit->index = index;
9003
9004 if (index > 0)
9005 {
9006 new_edit->next = NULL;
9007
9008 if (*tail)
9009 (*tail)->next = new_edit;
9010
9011 (*tail) = new_edit;
9012
9013 if (!*head)
9014 (*head) = new_edit;
9015 }
9016 else
9017 {
9018 new_edit->next = *head;
9019
9020 if (!*tail)
9021 *tail = new_edit;
9022
9023 *head = new_edit;
9024 }
9025 }
9026
9027 static _arm_elf_section_data *get_arm_elf_section_data (asection *);
9028
9029 /* Increase the size of EXIDX_SEC by ADJUST bytes. ADJUST mau be negative. */
9030 static void
9031 adjust_exidx_size(asection *exidx_sec, int adjust)
9032 {
9033 asection *out_sec;
9034
9035 if (!exidx_sec->rawsize)
9036 exidx_sec->rawsize = exidx_sec->size;
9037
9038 bfd_set_section_size (exidx_sec->owner, exidx_sec, exidx_sec->size + adjust);
9039 out_sec = exidx_sec->output_section;
9040 /* Adjust size of output section. */
9041 bfd_set_section_size (out_sec->owner, out_sec, out_sec->size +adjust);
9042 }
9043
9044 /* Insert an EXIDX_CANTUNWIND marker at the end of a section. */
9045 static void
9046 insert_cantunwind_after(asection *text_sec, asection *exidx_sec)
9047 {
9048 struct _arm_elf_section_data *exidx_arm_data;
9049
9050 exidx_arm_data = get_arm_elf_section_data (exidx_sec);
9051 add_unwind_table_edit (
9052 &exidx_arm_data->u.exidx.unwind_edit_list,
9053 &exidx_arm_data->u.exidx.unwind_edit_tail,
9054 INSERT_EXIDX_CANTUNWIND_AT_END, text_sec, UINT_MAX);
9055
9056 adjust_exidx_size(exidx_sec, 8);
9057 }
9058
9059 /* Scan .ARM.exidx tables, and create a list describing edits which should be
9060 made to those tables, such that:
9061
9062 1. Regions without unwind data are marked with EXIDX_CANTUNWIND entries.
9063 2. Duplicate entries are merged together (EXIDX_CANTUNWIND, or unwind
9064 codes which have been inlined into the index).
9065
9066 The edits are applied when the tables are written
9067 (in elf32_arm_write_section).
9068 */
9069
9070 bfd_boolean
9071 elf32_arm_fix_exidx_coverage (asection **text_section_order,
9072 unsigned int num_text_sections,
9073 struct bfd_link_info *info)
9074 {
9075 bfd *inp;
9076 unsigned int last_second_word = 0, i;
9077 asection *last_exidx_sec = NULL;
9078 asection *last_text_sec = NULL;
9079 int last_unwind_type = -1;
9080
9081 /* Walk over all EXIDX sections, and create backlinks from the corrsponding
9082 text sections. */
9083 for (inp = info->input_bfds; inp != NULL; inp = inp->link_next)
9084 {
9085 asection *sec;
9086
9087 for (sec = inp->sections; sec != NULL; sec = sec->next)
9088 {
9089 struct bfd_elf_section_data *elf_sec = elf_section_data (sec);
9090 Elf_Internal_Shdr *hdr = &elf_sec->this_hdr;
9091
9092 if (!hdr || hdr->sh_type != SHT_ARM_EXIDX)
9093 continue;
9094
9095 if (elf_sec->linked_to)
9096 {
9097 Elf_Internal_Shdr *linked_hdr
9098 = &elf_section_data (elf_sec->linked_to)->this_hdr;
9099 struct _arm_elf_section_data *linked_sec_arm_data
9100 = get_arm_elf_section_data (linked_hdr->bfd_section);
9101
9102 if (linked_sec_arm_data == NULL)
9103 continue;
9104
9105 /* Link this .ARM.exidx section back from the text section it
9106 describes. */
9107 linked_sec_arm_data->u.text.arm_exidx_sec = sec;
9108 }
9109 }
9110 }
9111
9112 /* Walk all text sections in order of increasing VMA. Eilminate duplicate
9113 index table entries (EXIDX_CANTUNWIND and inlined unwind opcodes),
9114 and add EXIDX_CANTUNWIND entries for sections with no unwind table data.
9115 */
9116
9117 for (i = 0; i < num_text_sections; i++)
9118 {
9119 asection *sec = text_section_order[i];
9120 asection *exidx_sec;
9121 struct _arm_elf_section_data *arm_data = get_arm_elf_section_data (sec);
9122 struct _arm_elf_section_data *exidx_arm_data;
9123 bfd_byte *contents = NULL;
9124 int deleted_exidx_bytes = 0;
9125 bfd_vma j;
9126 arm_unwind_table_edit *unwind_edit_head = NULL;
9127 arm_unwind_table_edit *unwind_edit_tail = NULL;
9128 Elf_Internal_Shdr *hdr;
9129 bfd *ibfd;
9130
9131 if (arm_data == NULL)
9132 continue;
9133
9134 exidx_sec = arm_data->u.text.arm_exidx_sec;
9135 if (exidx_sec == NULL)
9136 {
9137 /* Section has no unwind data. */
9138 if (last_unwind_type == 0 || !last_exidx_sec)
9139 continue;
9140
9141 /* Ignore zero sized sections. */
9142 if (sec->size == 0)
9143 continue;
9144
9145 insert_cantunwind_after(last_text_sec, last_exidx_sec);
9146 last_unwind_type = 0;
9147 continue;
9148 }
9149
9150 /* Skip /DISCARD/ sections. */
9151 if (bfd_is_abs_section (exidx_sec->output_section))
9152 continue;
9153
9154 hdr = &elf_section_data (exidx_sec)->this_hdr;
9155 if (hdr->sh_type != SHT_ARM_EXIDX)
9156 continue;
9157
9158 exidx_arm_data = get_arm_elf_section_data (exidx_sec);
9159 if (exidx_arm_data == NULL)
9160 continue;
9161
9162 ibfd = exidx_sec->owner;
9163
9164 if (hdr->contents != NULL)
9165 contents = hdr->contents;
9166 else if (! bfd_malloc_and_get_section (ibfd, exidx_sec, &contents))
9167 /* An error? */
9168 continue;
9169
9170 for (j = 0; j < hdr->sh_size; j += 8)
9171 {
9172 unsigned int second_word = bfd_get_32 (ibfd, contents + j + 4);
9173 int unwind_type;
9174 int elide = 0;
9175
9176 /* An EXIDX_CANTUNWIND entry. */
9177 if (second_word == 1)
9178 {
9179 if (last_unwind_type == 0)
9180 elide = 1;
9181 unwind_type = 0;
9182 }
9183 /* Inlined unwinding data. Merge if equal to previous. */
9184 else if ((second_word & 0x80000000) != 0)
9185 {
9186 if (last_second_word == second_word && last_unwind_type == 1)
9187 elide = 1;
9188 unwind_type = 1;
9189 last_second_word = second_word;
9190 }
9191 /* Normal table entry. In theory we could merge these too,
9192 but duplicate entries are likely to be much less common. */
9193 else
9194 unwind_type = 2;
9195
9196 if (elide)
9197 {
9198 add_unwind_table_edit (&unwind_edit_head, &unwind_edit_tail,
9199 DELETE_EXIDX_ENTRY, NULL, j / 8);
9200
9201 deleted_exidx_bytes += 8;
9202 }
9203
9204 last_unwind_type = unwind_type;
9205 }
9206
9207 /* Free contents if we allocated it ourselves. */
9208 if (contents != hdr->contents)
9209 free (contents);
9210
9211 /* Record edits to be applied later (in elf32_arm_write_section). */
9212 exidx_arm_data->u.exidx.unwind_edit_list = unwind_edit_head;
9213 exidx_arm_data->u.exidx.unwind_edit_tail = unwind_edit_tail;
9214
9215 if (deleted_exidx_bytes > 0)
9216 adjust_exidx_size(exidx_sec, -deleted_exidx_bytes);
9217
9218 last_exidx_sec = exidx_sec;
9219 last_text_sec = sec;
9220 }
9221
9222 /* Add terminating CANTUNWIND entry. */
9223 if (last_exidx_sec && last_unwind_type != 0)
9224 insert_cantunwind_after(last_text_sec, last_exidx_sec);
9225
9226 return TRUE;
9227 }
9228
9229 static bfd_boolean
9230 elf32_arm_output_glue_section (struct bfd_link_info *info, bfd *obfd,
9231 bfd *ibfd, const char *name)
9232 {
9233 asection *sec, *osec;
9234
9235 sec = bfd_get_section_by_name (ibfd, name);
9236 if (sec == NULL || (sec->flags & SEC_EXCLUDE) != 0)
9237 return TRUE;
9238
9239 osec = sec->output_section;
9240 if (elf32_arm_write_section (obfd, info, sec, sec->contents))
9241 return TRUE;
9242
9243 if (! bfd_set_section_contents (obfd, osec, sec->contents,
9244 sec->output_offset, sec->size))
9245 return FALSE;
9246
9247 return TRUE;
9248 }
9249
9250 static bfd_boolean
9251 elf32_arm_final_link (bfd *abfd, struct bfd_link_info *info)
9252 {
9253 struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (info);
9254
9255 /* Invoke the regular ELF backend linker to do all the work. */
9256 if (!bfd_elf_final_link (abfd, info))
9257 return FALSE;
9258
9259 /* Write out any glue sections now that we have created all the
9260 stubs. */
9261 if (globals->bfd_of_glue_owner != NULL)
9262 {
9263 if (! elf32_arm_output_glue_section (info, abfd,
9264 globals->bfd_of_glue_owner,
9265 ARM2THUMB_GLUE_SECTION_NAME))
9266 return FALSE;
9267
9268 if (! elf32_arm_output_glue_section (info, abfd,
9269 globals->bfd_of_glue_owner,
9270 THUMB2ARM_GLUE_SECTION_NAME))
9271 return FALSE;
9272
9273 if (! elf32_arm_output_glue_section (info, abfd,
9274 globals->bfd_of_glue_owner,
9275 VFP11_ERRATUM_VENEER_SECTION_NAME))
9276 return FALSE;
9277
9278 if (! elf32_arm_output_glue_section (info, abfd,
9279 globals->bfd_of_glue_owner,
9280 ARM_BX_GLUE_SECTION_NAME))
9281 return FALSE;
9282 }
9283
9284 return TRUE;
9285 }
9286
9287 /* Set the right machine number. */
9288
9289 static bfd_boolean
9290 elf32_arm_object_p (bfd *abfd)
9291 {
9292 unsigned int mach;
9293
9294 mach = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION);
9295
9296 if (mach != bfd_mach_arm_unknown)
9297 bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
9298
9299 else if (elf_elfheader (abfd)->e_flags & EF_ARM_MAVERICK_FLOAT)
9300 bfd_default_set_arch_mach (abfd, bfd_arch_arm, bfd_mach_arm_ep9312);
9301
9302 else
9303 bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
9304
9305 return TRUE;
9306 }
9307
9308 /* Function to keep ARM specific flags in the ELF header. */
9309
9310 static bfd_boolean
9311 elf32_arm_set_private_flags (bfd *abfd, flagword flags)
9312 {
9313 if (elf_flags_init (abfd)
9314 && elf_elfheader (abfd)->e_flags != flags)
9315 {
9316 if (EF_ARM_EABI_VERSION (flags) == EF_ARM_EABI_UNKNOWN)
9317 {
9318 if (flags & EF_ARM_INTERWORK)
9319 (*_bfd_error_handler)
9320 (_("Warning: Not setting interworking flag of %B since it has already been specified as non-interworking"),
9321 abfd);
9322 else
9323 _bfd_error_handler
9324 (_("Warning: Clearing the interworking flag of %B due to outside request"),
9325 abfd);
9326 }
9327 }
9328 else
9329 {
9330 elf_elfheader (abfd)->e_flags = flags;
9331 elf_flags_init (abfd) = TRUE;
9332 }
9333
9334 return TRUE;
9335 }
9336
9337 /* Copy backend specific data from one object module to another. */
9338
9339 static bfd_boolean
9340 elf32_arm_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
9341 {
9342 flagword in_flags;
9343 flagword out_flags;
9344
9345 if (! is_arm_elf (ibfd) || ! is_arm_elf (obfd))
9346 return TRUE;
9347
9348 in_flags = elf_elfheader (ibfd)->e_flags;
9349 out_flags = elf_elfheader (obfd)->e_flags;
9350
9351 if (elf_flags_init (obfd)
9352 && EF_ARM_EABI_VERSION (out_flags) == EF_ARM_EABI_UNKNOWN
9353 && in_flags != out_flags)
9354 {
9355 /* Cannot mix APCS26 and APCS32 code. */
9356 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
9357 return FALSE;
9358
9359 /* Cannot mix float APCS and non-float APCS code. */
9360 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
9361 return FALSE;
9362
9363 /* If the src and dest have different interworking flags
9364 then turn off the interworking bit. */
9365 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
9366 {
9367 if (out_flags & EF_ARM_INTERWORK)
9368 _bfd_error_handler
9369 (_("Warning: Clearing the interworking flag of %B because non-interworking code in %B has been linked with it"),
9370 obfd, ibfd);
9371
9372 in_flags &= ~EF_ARM_INTERWORK;
9373 }
9374
9375 /* Likewise for PIC, though don't warn for this case. */
9376 if ((in_flags & EF_ARM_PIC) != (out_flags & EF_ARM_PIC))
9377 in_flags &= ~EF_ARM_PIC;
9378 }
9379
9380 elf_elfheader (obfd)->e_flags = in_flags;
9381 elf_flags_init (obfd) = TRUE;
9382
9383 /* Also copy the EI_OSABI field. */
9384 elf_elfheader (obfd)->e_ident[EI_OSABI] =
9385 elf_elfheader (ibfd)->e_ident[EI_OSABI];
9386
9387 /* Copy object attributes. */
9388 _bfd_elf_copy_obj_attributes (ibfd, obfd);
9389
9390 return TRUE;
9391 }
9392
9393 /* Values for Tag_ABI_PCS_R9_use. */
9394 enum
9395 {
9396 AEABI_R9_V6,
9397 AEABI_R9_SB,
9398 AEABI_R9_TLS,
9399 AEABI_R9_unused
9400 };
9401
9402 /* Values for Tag_ABI_PCS_RW_data. */
9403 enum
9404 {
9405 AEABI_PCS_RW_data_absolute,
9406 AEABI_PCS_RW_data_PCrel,
9407 AEABI_PCS_RW_data_SBrel,
9408 AEABI_PCS_RW_data_unused
9409 };
9410
9411 /* Values for Tag_ABI_enum_size. */
9412 enum
9413 {
9414 AEABI_enum_unused,
9415 AEABI_enum_short,
9416 AEABI_enum_wide,
9417 AEABI_enum_forced_wide
9418 };
9419
9420 /* Determine whether an object attribute tag takes an integer, a
9421 string or both. */
9422
9423 static int
9424 elf32_arm_obj_attrs_arg_type (int tag)
9425 {
9426 if (tag == Tag_compatibility)
9427 return ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL;
9428 else if (tag == Tag_nodefaults)
9429 return ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_NO_DEFAULT;
9430 else if (tag == Tag_CPU_raw_name || tag == Tag_CPU_name)
9431 return ATTR_TYPE_FLAG_STR_VAL;
9432 else if (tag < 32)
9433 return ATTR_TYPE_FLAG_INT_VAL;
9434 else
9435 return (tag & 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL : ATTR_TYPE_FLAG_INT_VAL;
9436 }
9437
9438 /* The ABI defines that Tag_conformance should be emitted first, and that
9439 Tag_nodefaults should be second (if either is defined). This sets those
9440 two positions, and bumps up the position of all the remaining tags to
9441 compensate. */
9442 static int
9443 elf32_arm_obj_attrs_order (int num)
9444 {
9445 if (num == 4)
9446 return Tag_conformance;
9447 if (num == 5)
9448 return Tag_nodefaults;
9449 if ((num - 2) < Tag_nodefaults)
9450 return num - 2;
9451 if ((num - 1) < Tag_conformance)
9452 return num - 1;
9453 return num;
9454 }
9455
9456 /* Read the architecture from the Tag_also_compatible_with attribute, if any.
9457 Returns -1 if no architecture could be read. */
9458
9459 static int
9460 get_secondary_compatible_arch (bfd *abfd)
9461 {
9462 obj_attribute *attr =
9463 &elf_known_obj_attributes_proc (abfd)[Tag_also_compatible_with];
9464
9465 /* Note: the tag and its argument below are uleb128 values, though
9466 currently-defined values fit in one byte for each. */
9467 if (attr->s
9468 && attr->s[0] == Tag_CPU_arch
9469 && (attr->s[1] & 128) != 128
9470 && attr->s[2] == 0)
9471 return attr->s[1];
9472
9473 /* This tag is "safely ignorable", so don't complain if it looks funny. */
9474 return -1;
9475 }
9476
9477 /* Set, or unset, the architecture of the Tag_also_compatible_with attribute.
9478 The tag is removed if ARCH is -1. */
9479
9480 static void
9481 set_secondary_compatible_arch (bfd *abfd, int arch)
9482 {
9483 obj_attribute *attr =
9484 &elf_known_obj_attributes_proc (abfd)[Tag_also_compatible_with];
9485
9486 if (arch == -1)
9487 {
9488 attr->s = NULL;
9489 return;
9490 }
9491
9492 /* Note: the tag and its argument below are uleb128 values, though
9493 currently-defined values fit in one byte for each. */
9494 if (!attr->s)
9495 attr->s = bfd_alloc (abfd, 3);
9496 attr->s[0] = Tag_CPU_arch;
9497 attr->s[1] = arch;
9498 attr->s[2] = '\0';
9499 }
9500
9501 /* Combine two values for Tag_CPU_arch, taking secondary compatibility tags
9502 into account. */
9503
9504 static int
9505 tag_cpu_arch_combine (bfd *ibfd, int oldtag, int *secondary_compat_out,
9506 int newtag, int secondary_compat)
9507 {
9508 #define T(X) TAG_CPU_ARCH_##X
9509 int tagl, tagh, result;
9510 const int v6t2[] =
9511 {
9512 T(V6T2), /* PRE_V4. */
9513 T(V6T2), /* V4. */
9514 T(V6T2), /* V4T. */
9515 T(V6T2), /* V5T. */
9516 T(V6T2), /* V5TE. */
9517 T(V6T2), /* V5TEJ. */
9518 T(V6T2), /* V6. */
9519 T(V7), /* V6KZ. */
9520 T(V6T2) /* V6T2. */
9521 };
9522 const int v6k[] =
9523 {
9524 T(V6K), /* PRE_V4. */
9525 T(V6K), /* V4. */
9526 T(V6K), /* V4T. */
9527 T(V6K), /* V5T. */
9528 T(V6K), /* V5TE. */
9529 T(V6K), /* V5TEJ. */
9530 T(V6K), /* V6. */
9531 T(V6KZ), /* V6KZ. */
9532 T(V7), /* V6T2. */
9533 T(V6K) /* V6K. */
9534 };
9535 const int v7[] =
9536 {
9537 T(V7), /* PRE_V4. */
9538 T(V7), /* V4. */
9539 T(V7), /* V4T. */
9540 T(V7), /* V5T. */
9541 T(V7), /* V5TE. */
9542 T(V7), /* V5TEJ. */
9543 T(V7), /* V6. */
9544 T(V7), /* V6KZ. */
9545 T(V7), /* V6T2. */
9546 T(V7), /* V6K. */
9547 T(V7) /* V7. */
9548 };
9549 const int v6_m[] =
9550 {
9551 -1, /* PRE_V4. */
9552 -1, /* V4. */
9553 T(V6K), /* V4T. */
9554 T(V6K), /* V5T. */
9555 T(V6K), /* V5TE. */
9556 T(V6K), /* V5TEJ. */
9557 T(V6K), /* V6. */
9558 T(V6KZ), /* V6KZ. */
9559 T(V7), /* V6T2. */
9560 T(V6K), /* V6K. */
9561 T(V7), /* V7. */
9562 T(V6_M) /* V6_M. */
9563 };
9564 const int v6s_m[] =
9565 {
9566 -1, /* PRE_V4. */
9567 -1, /* V4. */
9568 T(V6K), /* V4T. */
9569 T(V6K), /* V5T. */
9570 T(V6K), /* V5TE. */
9571 T(V6K), /* V5TEJ. */
9572 T(V6K), /* V6. */
9573 T(V6KZ), /* V6KZ. */
9574 T(V7), /* V6T2. */
9575 T(V6K), /* V6K. */
9576 T(V7), /* V7. */
9577 T(V6S_M), /* V6_M. */
9578 T(V6S_M) /* V6S_M. */
9579 };
9580 const int v4t_plus_v6_m[] =
9581 {
9582 -1, /* PRE_V4. */
9583 -1, /* V4. */
9584 T(V4T), /* V4T. */
9585 T(V5T), /* V5T. */
9586 T(V5TE), /* V5TE. */
9587 T(V5TEJ), /* V5TEJ. */
9588 T(V6), /* V6. */
9589 T(V6KZ), /* V6KZ. */
9590 T(V6T2), /* V6T2. */
9591 T(V6K), /* V6K. */
9592 T(V7), /* V7. */
9593 T(V6_M), /* V6_M. */
9594 T(V6S_M), /* V6S_M. */
9595 T(V4T_PLUS_V6_M) /* V4T plus V6_M. */
9596 };
9597 const int *comb[] =
9598 {
9599 v6t2,
9600 v6k,
9601 v7,
9602 v6_m,
9603 v6s_m,
9604 /* Pseudo-architecture. */
9605 v4t_plus_v6_m
9606 };
9607
9608 /* Check we've not got a higher architecture than we know about. */
9609
9610 if (oldtag >= MAX_TAG_CPU_ARCH || newtag >= MAX_TAG_CPU_ARCH)
9611 {
9612 _bfd_error_handler (_("error: %B: Unknown CPU architecture"), ibfd);
9613 return -1;
9614 }
9615
9616 /* Override old tag if we have a Tag_also_compatible_with on the output. */
9617
9618 if ((oldtag == T(V6_M) && *secondary_compat_out == T(V4T))
9619 || (oldtag == T(V4T) && *secondary_compat_out == T(V6_M)))
9620 oldtag = T(V4T_PLUS_V6_M);
9621
9622 /* And override the new tag if we have a Tag_also_compatible_with on the
9623 input. */
9624
9625 if ((newtag == T(V6_M) && secondary_compat == T(V4T))
9626 || (newtag == T(V4T) && secondary_compat == T(V6_M)))
9627 newtag = T(V4T_PLUS_V6_M);
9628
9629 tagl = (oldtag < newtag) ? oldtag : newtag;
9630 result = tagh = (oldtag > newtag) ? oldtag : newtag;
9631
9632 /* Architectures before V6KZ add features monotonically. */
9633 if (tagh <= TAG_CPU_ARCH_V6KZ)
9634 return result;
9635
9636 result = comb[tagh - T(V6T2)][tagl];
9637
9638 /* Use Tag_CPU_arch == V4T and Tag_also_compatible_with (Tag_CPU_arch V6_M)
9639 as the canonical version. */
9640 if (result == T(V4T_PLUS_V6_M))
9641 {
9642 result = T(V4T);
9643 *secondary_compat_out = T(V6_M);
9644 }
9645 else
9646 *secondary_compat_out = -1;
9647
9648 if (result == -1)
9649 {
9650 _bfd_error_handler (_("error: %B: Conflicting CPU architectures %d/%d"),
9651 ibfd, oldtag, newtag);
9652 return -1;
9653 }
9654
9655 return result;
9656 #undef T
9657 }
9658
9659 /* Merge EABI object attributes from IBFD into OBFD. Raise an error if there
9660 are conflicting attributes. */
9661
9662 static bfd_boolean
9663 elf32_arm_merge_eabi_attributes (bfd *ibfd, bfd *obfd)
9664 {
9665 obj_attribute *in_attr;
9666 obj_attribute *out_attr;
9667 obj_attribute_list *in_list;
9668 obj_attribute_list *out_list;
9669 obj_attribute_list **out_listp;
9670 /* Some tags have 0 = don't care, 1 = strong requirement,
9671 2 = weak requirement. */
9672 static const int order_021[3] = {0, 2, 1};
9673 /* For use with Tag_VFP_arch. */
9674 static const int order_01243[5] = {0, 1, 2, 4, 3};
9675 int i;
9676 bfd_boolean result = TRUE;
9677
9678 /* Skip the linker stubs file. This preserves previous behavior
9679 of accepting unknown attributes in the first input file - but
9680 is that a bug? */
9681 if (ibfd->flags & BFD_LINKER_CREATED)
9682 return TRUE;
9683
9684 if (!elf_known_obj_attributes_proc (obfd)[0].i)
9685 {
9686 /* This is the first object. Copy the attributes. */
9687 _bfd_elf_copy_obj_attributes (ibfd, obfd);
9688
9689 /* Use the Tag_null value to indicate the attributes have been
9690 initialized. */
9691 elf_known_obj_attributes_proc (obfd)[0].i = 1;
9692
9693 return TRUE;
9694 }
9695
9696 in_attr = elf_known_obj_attributes_proc (ibfd);
9697 out_attr = elf_known_obj_attributes_proc (obfd);
9698 /* This needs to happen before Tag_ABI_FP_number_model is merged. */
9699 if (in_attr[Tag_ABI_VFP_args].i != out_attr[Tag_ABI_VFP_args].i)
9700 {
9701 /* Ignore mismatches if the object doesn't use floating point. */
9702 if (out_attr[Tag_ABI_FP_number_model].i == 0)
9703 out_attr[Tag_ABI_VFP_args].i = in_attr[Tag_ABI_VFP_args].i;
9704 else if (in_attr[Tag_ABI_FP_number_model].i != 0)
9705 {
9706 _bfd_error_handler
9707 (_("error: %B uses VFP register arguments, %B does not"),
9708 ibfd, obfd);
9709 result = FALSE;
9710 }
9711 }
9712
9713 for (i = 4; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
9714 {
9715 /* Merge this attribute with existing attributes. */
9716 switch (i)
9717 {
9718 case Tag_CPU_raw_name:
9719 case Tag_CPU_name:
9720 /* These are merged after Tag_CPU_arch. */
9721 break;
9722
9723 case Tag_ABI_optimization_goals:
9724 case Tag_ABI_FP_optimization_goals:
9725 /* Use the first value seen. */
9726 break;
9727
9728 case Tag_CPU_arch:
9729 {
9730 int secondary_compat = -1, secondary_compat_out = -1;
9731 unsigned int saved_out_attr = out_attr[i].i;
9732 static const char *name_table[] = {
9733 /* These aren't real CPU names, but we can't guess
9734 that from the architecture version alone. */
9735 "Pre v4",
9736 "ARM v4",
9737 "ARM v4T",
9738 "ARM v5T",
9739 "ARM v5TE",
9740 "ARM v5TEJ",
9741 "ARM v6",
9742 "ARM v6KZ",
9743 "ARM v6T2",
9744 "ARM v6K",
9745 "ARM v7",
9746 "ARM v6-M",
9747 "ARM v6S-M"
9748 };
9749
9750 /* Merge Tag_CPU_arch and Tag_also_compatible_with. */
9751 secondary_compat = get_secondary_compatible_arch (ibfd);
9752 secondary_compat_out = get_secondary_compatible_arch (obfd);
9753 out_attr[i].i = tag_cpu_arch_combine (ibfd, out_attr[i].i,
9754 &secondary_compat_out,
9755 in_attr[i].i,
9756 secondary_compat);
9757 set_secondary_compatible_arch (obfd, secondary_compat_out);
9758
9759 /* Merge Tag_CPU_name and Tag_CPU_raw_name. */
9760 if (out_attr[i].i == saved_out_attr)
9761 ; /* Leave the names alone. */
9762 else if (out_attr[i].i == in_attr[i].i)
9763 {
9764 /* The output architecture has been changed to match the
9765 input architecture. Use the input names. */
9766 out_attr[Tag_CPU_name].s = in_attr[Tag_CPU_name].s
9767 ? _bfd_elf_attr_strdup (obfd, in_attr[Tag_CPU_name].s)
9768 : NULL;
9769 out_attr[Tag_CPU_raw_name].s = in_attr[Tag_CPU_raw_name].s
9770 ? _bfd_elf_attr_strdup (obfd, in_attr[Tag_CPU_raw_name].s)
9771 : NULL;
9772 }
9773 else
9774 {
9775 out_attr[Tag_CPU_name].s = NULL;
9776 out_attr[Tag_CPU_raw_name].s = NULL;
9777 }
9778
9779 /* If we still don't have a value for Tag_CPU_name,
9780 make one up now. Tag_CPU_raw_name remains blank. */
9781 if (out_attr[Tag_CPU_name].s == NULL
9782 && out_attr[i].i < ARRAY_SIZE (name_table))
9783 out_attr[Tag_CPU_name].s =
9784 _bfd_elf_attr_strdup (obfd, name_table[out_attr[i].i]);
9785 }
9786 break;
9787
9788 case Tag_ARM_ISA_use:
9789 case Tag_THUMB_ISA_use:
9790 case Tag_WMMX_arch:
9791 case Tag_Advanced_SIMD_arch:
9792 /* ??? Do Advanced_SIMD (NEON) and WMMX conflict? */
9793 case Tag_ABI_FP_rounding:
9794 case Tag_ABI_FP_exceptions:
9795 case Tag_ABI_FP_user_exceptions:
9796 case Tag_ABI_FP_number_model:
9797 case Tag_VFP_HP_extension:
9798 case Tag_CPU_unaligned_access:
9799 case Tag_T2EE_use:
9800 case Tag_Virtualization_use:
9801 case Tag_MPextension_use:
9802 /* Use the largest value specified. */
9803 if (in_attr[i].i > out_attr[i].i)
9804 out_attr[i].i = in_attr[i].i;
9805 break;
9806
9807 case Tag_ABI_align8_preserved:
9808 case Tag_ABI_PCS_RO_data:
9809 /* Use the smallest value specified. */
9810 if (in_attr[i].i < out_attr[i].i)
9811 out_attr[i].i = in_attr[i].i;
9812 break;
9813
9814 case Tag_ABI_align8_needed:
9815 if ((in_attr[i].i > 0 || out_attr[i].i > 0)
9816 && (in_attr[Tag_ABI_align8_preserved].i == 0
9817 || out_attr[Tag_ABI_align8_preserved].i == 0))
9818 {
9819 /* This error message should be enabled once all non-conformant
9820 binaries in the toolchain have had the attributes set
9821 properly.
9822 _bfd_error_handler
9823 (_("error: %B: 8-byte data alignment conflicts with %B"),
9824 obfd, ibfd);
9825 result = FALSE; */
9826 }
9827 /* Fall through. */
9828 case Tag_ABI_FP_denormal:
9829 case Tag_ABI_PCS_GOT_use:
9830 /* Use the "greatest" from the sequence 0, 2, 1, or the largest
9831 value if greater than 2 (for future-proofing). */
9832 if ((in_attr[i].i > 2 && in_attr[i].i > out_attr[i].i)
9833 || (in_attr[i].i <= 2 && out_attr[i].i <= 2
9834 && order_021[in_attr[i].i] > order_021[out_attr[i].i]))
9835 out_attr[i].i = in_attr[i].i;
9836 break;
9837
9838
9839 case Tag_CPU_arch_profile:
9840 if (out_attr[i].i != in_attr[i].i)
9841 {
9842 /* 0 will merge with anything.
9843 'A' and 'S' merge to 'A'.
9844 'R' and 'S' merge to 'R'.
9845 'M' and 'A|R|S' is an error. */
9846 if (out_attr[i].i == 0
9847 || (out_attr[i].i == 'S'
9848 && (in_attr[i].i == 'A' || in_attr[i].i == 'R')))
9849 out_attr[i].i = in_attr[i].i;
9850 else if (in_attr[i].i == 0
9851 || (in_attr[i].i == 'S'
9852 && (out_attr[i].i == 'A' || out_attr[i].i == 'R')))
9853 ; /* Do nothing. */
9854 else
9855 {
9856 _bfd_error_handler
9857 (_("error: %B: Conflicting architecture profiles %c/%c"),
9858 ibfd,
9859 in_attr[i].i ? in_attr[i].i : '0',
9860 out_attr[i].i ? out_attr[i].i : '0');
9861 result = FALSE;
9862 }
9863 }
9864 break;
9865 case Tag_VFP_arch:
9866 /* Use the "greatest" from the sequence 0, 1, 2, 4, 3, or the
9867 largest value if greater than 4 (for future-proofing). */
9868 if ((in_attr[i].i > 4 && in_attr[i].i > out_attr[i].i)
9869 || (in_attr[i].i <= 4 && out_attr[i].i <= 4
9870 && order_01243[in_attr[i].i] > order_01243[out_attr[i].i]))
9871 out_attr[i].i = in_attr[i].i;
9872 break;
9873 case Tag_PCS_config:
9874 if (out_attr[i].i == 0)
9875 out_attr[i].i = in_attr[i].i;
9876 else if (in_attr[i].i != 0 && out_attr[i].i != 0)
9877 {
9878 /* It's sometimes ok to mix different configs, so this is only
9879 a warning. */
9880 _bfd_error_handler
9881 (_("Warning: %B: Conflicting platform configuration"), ibfd);
9882 }
9883 break;
9884 case Tag_ABI_PCS_R9_use:
9885 if (in_attr[i].i != out_attr[i].i
9886 && out_attr[i].i != AEABI_R9_unused
9887 && in_attr[i].i != AEABI_R9_unused)
9888 {
9889 _bfd_error_handler
9890 (_("error: %B: Conflicting use of R9"), ibfd);
9891 result = FALSE;
9892 }
9893 if (out_attr[i].i == AEABI_R9_unused)
9894 out_attr[i].i = in_attr[i].i;
9895 break;
9896 case Tag_ABI_PCS_RW_data:
9897 if (in_attr[i].i == AEABI_PCS_RW_data_SBrel
9898 && out_attr[Tag_ABI_PCS_R9_use].i != AEABI_R9_SB
9899 && out_attr[Tag_ABI_PCS_R9_use].i != AEABI_R9_unused)
9900 {
9901 _bfd_error_handler
9902 (_("error: %B: SB relative addressing conflicts with use of R9"),
9903 ibfd);
9904 result = FALSE;
9905 }
9906 /* Use the smallest value specified. */
9907 if (in_attr[i].i < out_attr[i].i)
9908 out_attr[i].i = in_attr[i].i;
9909 break;
9910 case Tag_ABI_PCS_wchar_t:
9911 if (out_attr[i].i && in_attr[i].i && out_attr[i].i != in_attr[i].i
9912 && !elf_arm_tdata (obfd)->no_wchar_size_warning)
9913 {
9914 _bfd_error_handler
9915 (_("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"),
9916 ibfd, in_attr[i].i, out_attr[i].i);
9917 }
9918 else if (in_attr[i].i && !out_attr[i].i)
9919 out_attr[i].i = in_attr[i].i;
9920 break;
9921 case Tag_ABI_enum_size:
9922 if (in_attr[i].i != AEABI_enum_unused)
9923 {
9924 if (out_attr[i].i == AEABI_enum_unused
9925 || out_attr[i].i == AEABI_enum_forced_wide)
9926 {
9927 /* The existing object is compatible with anything.
9928 Use whatever requirements the new object has. */
9929 out_attr[i].i = in_attr[i].i;
9930 }
9931 else if (in_attr[i].i != AEABI_enum_forced_wide
9932 && out_attr[i].i != in_attr[i].i
9933 && !elf_arm_tdata (obfd)->no_enum_size_warning)
9934 {
9935 static const char *aeabi_enum_names[] =
9936 { "", "variable-size", "32-bit", "" };
9937 const char *in_name =
9938 in_attr[i].i < ARRAY_SIZE(aeabi_enum_names)
9939 ? aeabi_enum_names[in_attr[i].i]
9940 : "<unknown>";
9941 const char *out_name =
9942 out_attr[i].i < ARRAY_SIZE(aeabi_enum_names)
9943 ? aeabi_enum_names[out_attr[i].i]
9944 : "<unknown>";
9945 _bfd_error_handler
9946 (_("warning: %B uses %s enums yet the output is to use %s enums; use of enum values across objects may fail"),
9947 ibfd, in_name, out_name);
9948 }
9949 }
9950 break;
9951 case Tag_ABI_VFP_args:
9952 /* Aready done. */
9953 break;
9954 case Tag_ABI_WMMX_args:
9955 if (in_attr[i].i != out_attr[i].i)
9956 {
9957 _bfd_error_handler
9958 (_("error: %B uses iWMMXt register arguments, %B does not"),
9959 ibfd, obfd);
9960 result = FALSE;
9961 }
9962 break;
9963 case Tag_compatibility:
9964 /* Merged in target-independent code. */
9965 break;
9966 case Tag_ABI_HardFP_use:
9967 /* 1 (SP) and 2 (DP) conflict, so combine to 3 (SP & DP). */
9968 if ((in_attr[i].i == 1 && out_attr[i].i == 2)
9969 || (in_attr[i].i == 2 && out_attr[i].i == 1))
9970 out_attr[i].i = 3;
9971 else if (in_attr[i].i > out_attr[i].i)
9972 out_attr[i].i = in_attr[i].i;
9973 break;
9974 case Tag_ABI_FP_16bit_format:
9975 if (in_attr[i].i != 0 && out_attr[i].i != 0)
9976 {
9977 if (in_attr[i].i != out_attr[i].i)
9978 {
9979 _bfd_error_handler
9980 (_("error: fp16 format mismatch between %B and %B"),
9981 ibfd, obfd);
9982 result = FALSE;
9983 }
9984 }
9985 if (in_attr[i].i != 0)
9986 out_attr[i].i = in_attr[i].i;
9987 break;
9988
9989 case Tag_nodefaults:
9990 /* This tag is set if it exists, but the value is unused (and is
9991 typically zero). We don't actually need to do anything here -
9992 the merge happens automatically when the type flags are merged
9993 below. */
9994 break;
9995 case Tag_also_compatible_with:
9996 /* Already done in Tag_CPU_arch. */
9997 break;
9998 case Tag_conformance:
9999 /* Keep the attribute if it matches. Throw it away otherwise.
10000 No attribute means no claim to conform. */
10001 if (!in_attr[i].s || !out_attr[i].s
10002 || strcmp (in_attr[i].s, out_attr[i].s) != 0)
10003 out_attr[i].s = NULL;
10004 break;
10005
10006 default:
10007 {
10008 bfd *err_bfd = NULL;
10009
10010 /* The "known_obj_attributes" table does contain some undefined
10011 attributes. Ensure that there are unused. */
10012 if (out_attr[i].i != 0 || out_attr[i].s != NULL)
10013 err_bfd = obfd;
10014 else if (in_attr[i].i != 0 || in_attr[i].s != NULL)
10015 err_bfd = ibfd;
10016
10017 if (err_bfd != NULL)
10018 {
10019 /* Attribute numbers >=64 (mod 128) can be safely ignored. */
10020 if ((i & 127) < 64)
10021 {
10022 _bfd_error_handler
10023 (_("%B: Unknown mandatory EABI object attribute %d"),
10024 err_bfd, i);
10025 bfd_set_error (bfd_error_bad_value);
10026 result = FALSE;
10027 }
10028 else
10029 {
10030 _bfd_error_handler
10031 (_("Warning: %B: Unknown EABI object attribute %d"),
10032 err_bfd, i);
10033 }
10034 }
10035
10036 /* Only pass on attributes that match in both inputs. */
10037 if (in_attr[i].i != out_attr[i].i
10038 || in_attr[i].s != out_attr[i].s
10039 || (in_attr[i].s != NULL && out_attr[i].s != NULL
10040 && strcmp (in_attr[i].s, out_attr[i].s) != 0))
10041 {
10042 out_attr[i].i = 0;
10043 out_attr[i].s = NULL;
10044 }
10045 }
10046 }
10047
10048 /* If out_attr was copied from in_attr then it won't have a type yet. */
10049 if (in_attr[i].type && !out_attr[i].type)
10050 out_attr[i].type = in_attr[i].type;
10051 }
10052
10053 /* Merge Tag_compatibility attributes and any common GNU ones. */
10054 _bfd_elf_merge_object_attributes (ibfd, obfd);
10055
10056 /* Check for any attributes not known on ARM. */
10057 in_list = elf_other_obj_attributes_proc (ibfd);
10058 out_listp = &elf_other_obj_attributes_proc (obfd);
10059 out_list = *out_listp;
10060
10061 for (; in_list || out_list; )
10062 {
10063 bfd *err_bfd = NULL;
10064 int err_tag = 0;
10065
10066 /* The tags for each list are in numerical order. */
10067 /* If the tags are equal, then merge. */
10068 if (out_list && (!in_list || in_list->tag > out_list->tag))
10069 {
10070 /* This attribute only exists in obfd. We can't merge, and we don't
10071 know what the tag means, so delete it. */
10072 err_bfd = obfd;
10073 err_tag = out_list->tag;
10074 *out_listp = out_list->next;
10075 out_list = *out_listp;
10076 }
10077 else if (in_list && (!out_list || in_list->tag < out_list->tag))
10078 {
10079 /* This attribute only exists in ibfd. We can't merge, and we don't
10080 know what the tag means, so ignore it. */
10081 err_bfd = ibfd;
10082 err_tag = in_list->tag;
10083 in_list = in_list->next;
10084 }
10085 else /* The tags are equal. */
10086 {
10087 /* As present, all attributes in the list are unknown, and
10088 therefore can't be merged meaningfully. */
10089 err_bfd = obfd;
10090 err_tag = out_list->tag;
10091
10092 /* Only pass on attributes that match in both inputs. */
10093 if (in_list->attr.i != out_list->attr.i
10094 || in_list->attr.s != out_list->attr.s
10095 || (in_list->attr.s && out_list->attr.s
10096 && strcmp (in_list->attr.s, out_list->attr.s) != 0))
10097 {
10098 /* No match. Delete the attribute. */
10099 *out_listp = out_list->next;
10100 out_list = *out_listp;
10101 }
10102 else
10103 {
10104 /* Matched. Keep the attribute and move to the next. */
10105 out_list = out_list->next;
10106 in_list = in_list->next;
10107 }
10108 }
10109
10110 if (err_bfd)
10111 {
10112 /* Attribute numbers >=64 (mod 128) can be safely ignored. */
10113 if ((err_tag & 127) < 64)
10114 {
10115 _bfd_error_handler
10116 (_("%B: Unknown mandatory EABI object attribute %d"),
10117 err_bfd, err_tag);
10118 bfd_set_error (bfd_error_bad_value);
10119 result = FALSE;
10120 }
10121 else
10122 {
10123 _bfd_error_handler
10124 (_("Warning: %B: Unknown EABI object attribute %d"),
10125 err_bfd, err_tag);
10126 }
10127 }
10128 }
10129 return result;
10130 }
10131
10132
10133 /* Return TRUE if the two EABI versions are incompatible. */
10134
10135 static bfd_boolean
10136 elf32_arm_versions_compatible (unsigned iver, unsigned over)
10137 {
10138 /* v4 and v5 are the same spec before and after it was released,
10139 so allow mixing them. */
10140 if ((iver == EF_ARM_EABI_VER4 && over == EF_ARM_EABI_VER5)
10141 || (iver == EF_ARM_EABI_VER5 && over == EF_ARM_EABI_VER4))
10142 return TRUE;
10143
10144 return (iver == over);
10145 }
10146
10147 /* Merge backend specific data from an object file to the output
10148 object file when linking. */
10149
10150 static bfd_boolean
10151 elf32_arm_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
10152 {
10153 flagword out_flags;
10154 flagword in_flags;
10155 bfd_boolean flags_compatible = TRUE;
10156 asection *sec;
10157
10158 /* Check if we have the same endianess. */
10159 if (! _bfd_generic_verify_endian_match (ibfd, obfd))
10160 return FALSE;
10161
10162 if (! is_arm_elf (ibfd) || ! is_arm_elf (obfd))
10163 return TRUE;
10164
10165 if (!elf32_arm_merge_eabi_attributes (ibfd, obfd))
10166 return FALSE;
10167
10168 /* The input BFD must have had its flags initialised. */
10169 /* The following seems bogus to me -- The flags are initialized in
10170 the assembler but I don't think an elf_flags_init field is
10171 written into the object. */
10172 /* BFD_ASSERT (elf_flags_init (ibfd)); */
10173
10174 in_flags = elf_elfheader (ibfd)->e_flags;
10175 out_flags = elf_elfheader (obfd)->e_flags;
10176
10177 /* In theory there is no reason why we couldn't handle this. However
10178 in practice it isn't even close to working and there is no real
10179 reason to want it. */
10180 if (EF_ARM_EABI_VERSION (in_flags) >= EF_ARM_EABI_VER4
10181 && !(ibfd->flags & DYNAMIC)
10182 && (in_flags & EF_ARM_BE8))
10183 {
10184 _bfd_error_handler (_("error: %B is already in final BE8 format"),
10185 ibfd);
10186 return FALSE;
10187 }
10188
10189 if (!elf_flags_init (obfd))
10190 {
10191 /* If the input is the default architecture and had the default
10192 flags then do not bother setting the flags for the output
10193 architecture, instead allow future merges to do this. If no
10194 future merges ever set these flags then they will retain their
10195 uninitialised values, which surprise surprise, correspond
10196 to the default values. */
10197 if (bfd_get_arch_info (ibfd)->the_default
10198 && elf_elfheader (ibfd)->e_flags == 0)
10199 return TRUE;
10200
10201 elf_flags_init (obfd) = TRUE;
10202 elf_elfheader (obfd)->e_flags = in_flags;
10203
10204 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
10205 && bfd_get_arch_info (obfd)->the_default)
10206 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
10207
10208 return TRUE;
10209 }
10210
10211 /* Determine what should happen if the input ARM architecture
10212 does not match the output ARM architecture. */
10213 if (! bfd_arm_merge_machines (ibfd, obfd))
10214 return FALSE;
10215
10216 /* Identical flags must be compatible. */
10217 if (in_flags == out_flags)
10218 return TRUE;
10219
10220 /* Check to see if the input BFD actually contains any sections. If
10221 not, its flags may not have been initialised either, but it
10222 cannot actually cause any incompatiblity. Do not short-circuit
10223 dynamic objects; their section list may be emptied by
10224 elf_link_add_object_symbols.
10225
10226 Also check to see if there are no code sections in the input.
10227 In this case there is no need to check for code specific flags.
10228 XXX - do we need to worry about floating-point format compatability
10229 in data sections ? */
10230 if (!(ibfd->flags & DYNAMIC))
10231 {
10232 bfd_boolean null_input_bfd = TRUE;
10233 bfd_boolean only_data_sections = TRUE;
10234
10235 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
10236 {
10237 /* Ignore synthetic glue sections. */
10238 if (strcmp (sec->name, ".glue_7")
10239 && strcmp (sec->name, ".glue_7t"))
10240 {
10241 if ((bfd_get_section_flags (ibfd, sec)
10242 & (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
10243 == (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
10244 only_data_sections = FALSE;
10245
10246 null_input_bfd = FALSE;
10247 break;
10248 }
10249 }
10250
10251 if (null_input_bfd || only_data_sections)
10252 return TRUE;
10253 }
10254
10255 /* Complain about various flag mismatches. */
10256 if (!elf32_arm_versions_compatible (EF_ARM_EABI_VERSION (in_flags),
10257 EF_ARM_EABI_VERSION (out_flags)))
10258 {
10259 _bfd_error_handler
10260 (_("error: Source object %B has EABI version %d, but target %B has EABI version %d"),
10261 ibfd, obfd,
10262 (in_flags & EF_ARM_EABIMASK) >> 24,
10263 (out_flags & EF_ARM_EABIMASK) >> 24);
10264 return FALSE;
10265 }
10266
10267 /* Not sure what needs to be checked for EABI versions >= 1. */
10268 /* VxWorks libraries do not use these flags. */
10269 if (get_elf_backend_data (obfd) != &elf32_arm_vxworks_bed
10270 && get_elf_backend_data (ibfd) != &elf32_arm_vxworks_bed
10271 && EF_ARM_EABI_VERSION (in_flags) == EF_ARM_EABI_UNKNOWN)
10272 {
10273 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
10274 {
10275 _bfd_error_handler
10276 (_("error: %B is compiled for APCS-%d, whereas target %B uses APCS-%d"),
10277 ibfd, obfd,
10278 in_flags & EF_ARM_APCS_26 ? 26 : 32,
10279 out_flags & EF_ARM_APCS_26 ? 26 : 32);
10280 flags_compatible = FALSE;
10281 }
10282
10283 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
10284 {
10285 if (in_flags & EF_ARM_APCS_FLOAT)
10286 _bfd_error_handler
10287 (_("error: %B passes floats in float registers, whereas %B passes them in integer registers"),
10288 ibfd, obfd);
10289 else
10290 _bfd_error_handler
10291 (_("error: %B passes floats in integer registers, whereas %B passes them in float registers"),
10292 ibfd, obfd);
10293
10294 flags_compatible = FALSE;
10295 }
10296
10297 if ((in_flags & EF_ARM_VFP_FLOAT) != (out_flags & EF_ARM_VFP_FLOAT))
10298 {
10299 if (in_flags & EF_ARM_VFP_FLOAT)
10300 _bfd_error_handler
10301 (_("error: %B uses VFP instructions, whereas %B does not"),
10302 ibfd, obfd);
10303 else
10304 _bfd_error_handler
10305 (_("error: %B uses FPA instructions, whereas %B does not"),
10306 ibfd, obfd);
10307
10308 flags_compatible = FALSE;
10309 }
10310
10311 if ((in_flags & EF_ARM_MAVERICK_FLOAT) != (out_flags & EF_ARM_MAVERICK_FLOAT))
10312 {
10313 if (in_flags & EF_ARM_MAVERICK_FLOAT)
10314 _bfd_error_handler
10315 (_("error: %B uses Maverick instructions, whereas %B does not"),
10316 ibfd, obfd);
10317 else
10318 _bfd_error_handler
10319 (_("error: %B does not use Maverick instructions, whereas %B does"),
10320 ibfd, obfd);
10321
10322 flags_compatible = FALSE;
10323 }
10324
10325 #ifdef EF_ARM_SOFT_FLOAT
10326 if ((in_flags & EF_ARM_SOFT_FLOAT) != (out_flags & EF_ARM_SOFT_FLOAT))
10327 {
10328 /* We can allow interworking between code that is VFP format
10329 layout, and uses either soft float or integer regs for
10330 passing floating point arguments and results. We already
10331 know that the APCS_FLOAT flags match; similarly for VFP
10332 flags. */
10333 if ((in_flags & EF_ARM_APCS_FLOAT) != 0
10334 || (in_flags & EF_ARM_VFP_FLOAT) == 0)
10335 {
10336 if (in_flags & EF_ARM_SOFT_FLOAT)
10337 _bfd_error_handler
10338 (_("error: %B uses software FP, whereas %B uses hardware FP"),
10339 ibfd, obfd);
10340 else
10341 _bfd_error_handler
10342 (_("error: %B uses hardware FP, whereas %B uses software FP"),
10343 ibfd, obfd);
10344
10345 flags_compatible = FALSE;
10346 }
10347 }
10348 #endif
10349
10350 /* Interworking mismatch is only a warning. */
10351 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
10352 {
10353 if (in_flags & EF_ARM_INTERWORK)
10354 {
10355 _bfd_error_handler
10356 (_("Warning: %B supports interworking, whereas %B does not"),
10357 ibfd, obfd);
10358 }
10359 else
10360 {
10361 _bfd_error_handler
10362 (_("Warning: %B does not support interworking, whereas %B does"),
10363 ibfd, obfd);
10364 }
10365 }
10366 }
10367
10368 return flags_compatible;
10369 }
10370
10371 /* Display the flags field. */
10372
10373 static bfd_boolean
10374 elf32_arm_print_private_bfd_data (bfd *abfd, void * ptr)
10375 {
10376 FILE * file = (FILE *) ptr;
10377 unsigned long flags;
10378
10379 BFD_ASSERT (abfd != NULL && ptr != NULL);
10380
10381 /* Print normal ELF private data. */
10382 _bfd_elf_print_private_bfd_data (abfd, ptr);
10383
10384 flags = elf_elfheader (abfd)->e_flags;
10385 /* Ignore init flag - it may not be set, despite the flags field
10386 containing valid data. */
10387
10388 /* xgettext:c-format */
10389 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
10390
10391 switch (EF_ARM_EABI_VERSION (flags))
10392 {
10393 case EF_ARM_EABI_UNKNOWN:
10394 /* The following flag bits are GNU extensions and not part of the
10395 official ARM ELF extended ABI. Hence they are only decoded if
10396 the EABI version is not set. */
10397 if (flags & EF_ARM_INTERWORK)
10398 fprintf (file, _(" [interworking enabled]"));
10399
10400 if (flags & EF_ARM_APCS_26)
10401 fprintf (file, " [APCS-26]");
10402 else
10403 fprintf (file, " [APCS-32]");
10404
10405 if (flags & EF_ARM_VFP_FLOAT)
10406 fprintf (file, _(" [VFP float format]"));
10407 else if (flags & EF_ARM_MAVERICK_FLOAT)
10408 fprintf (file, _(" [Maverick float format]"));
10409 else
10410 fprintf (file, _(" [FPA float format]"));
10411
10412 if (flags & EF_ARM_APCS_FLOAT)
10413 fprintf (file, _(" [floats passed in float registers]"));
10414
10415 if (flags & EF_ARM_PIC)
10416 fprintf (file, _(" [position independent]"));
10417
10418 if (flags & EF_ARM_NEW_ABI)
10419 fprintf (file, _(" [new ABI]"));
10420
10421 if (flags & EF_ARM_OLD_ABI)
10422 fprintf (file, _(" [old ABI]"));
10423
10424 if (flags & EF_ARM_SOFT_FLOAT)
10425 fprintf (file, _(" [software FP]"));
10426
10427 flags &= ~(EF_ARM_INTERWORK | EF_ARM_APCS_26 | EF_ARM_APCS_FLOAT
10428 | EF_ARM_PIC | EF_ARM_NEW_ABI | EF_ARM_OLD_ABI
10429 | EF_ARM_SOFT_FLOAT | EF_ARM_VFP_FLOAT
10430 | EF_ARM_MAVERICK_FLOAT);
10431 break;
10432
10433 case EF_ARM_EABI_VER1:
10434 fprintf (file, _(" [Version1 EABI]"));
10435
10436 if (flags & EF_ARM_SYMSARESORTED)
10437 fprintf (file, _(" [sorted symbol table]"));
10438 else
10439 fprintf (file, _(" [unsorted symbol table]"));
10440
10441 flags &= ~ EF_ARM_SYMSARESORTED;
10442 break;
10443
10444 case EF_ARM_EABI_VER2:
10445 fprintf (file, _(" [Version2 EABI]"));
10446
10447 if (flags & EF_ARM_SYMSARESORTED)
10448 fprintf (file, _(" [sorted symbol table]"));
10449 else
10450 fprintf (file, _(" [unsorted symbol table]"));
10451
10452 if (flags & EF_ARM_DYNSYMSUSESEGIDX)
10453 fprintf (file, _(" [dynamic symbols use segment index]"));
10454
10455 if (flags & EF_ARM_MAPSYMSFIRST)
10456 fprintf (file, _(" [mapping symbols precede others]"));
10457
10458 flags &= ~(EF_ARM_SYMSARESORTED | EF_ARM_DYNSYMSUSESEGIDX
10459 | EF_ARM_MAPSYMSFIRST);
10460 break;
10461
10462 case EF_ARM_EABI_VER3:
10463 fprintf (file, _(" [Version3 EABI]"));
10464 break;
10465
10466 case EF_ARM_EABI_VER4:
10467 fprintf (file, _(" [Version4 EABI]"));
10468 goto eabi;
10469
10470 case EF_ARM_EABI_VER5:
10471 fprintf (file, _(" [Version5 EABI]"));
10472 eabi:
10473 if (flags & EF_ARM_BE8)
10474 fprintf (file, _(" [BE8]"));
10475
10476 if (flags & EF_ARM_LE8)
10477 fprintf (file, _(" [LE8]"));
10478
10479 flags &= ~(EF_ARM_LE8 | EF_ARM_BE8);
10480 break;
10481
10482 default:
10483 fprintf (file, _(" <EABI version unrecognised>"));
10484 break;
10485 }
10486
10487 flags &= ~ EF_ARM_EABIMASK;
10488
10489 if (flags & EF_ARM_RELEXEC)
10490 fprintf (file, _(" [relocatable executable]"));
10491
10492 if (flags & EF_ARM_HASENTRY)
10493 fprintf (file, _(" [has entry point]"));
10494
10495 flags &= ~ (EF_ARM_RELEXEC | EF_ARM_HASENTRY);
10496
10497 if (flags)
10498 fprintf (file, _("<Unrecognised flag bits set>"));
10499
10500 fputc ('\n', file);
10501
10502 return TRUE;
10503 }
10504
10505 static int
10506 elf32_arm_get_symbol_type (Elf_Internal_Sym * elf_sym, int type)
10507 {
10508 switch (ELF_ST_TYPE (elf_sym->st_info))
10509 {
10510 case STT_ARM_TFUNC:
10511 return ELF_ST_TYPE (elf_sym->st_info);
10512
10513 case STT_ARM_16BIT:
10514 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
10515 This allows us to distinguish between data used by Thumb instructions
10516 and non-data (which is probably code) inside Thumb regions of an
10517 executable. */
10518 if (type != STT_OBJECT && type != STT_TLS)
10519 return ELF_ST_TYPE (elf_sym->st_info);
10520 break;
10521
10522 default:
10523 break;
10524 }
10525
10526 return type;
10527 }
10528
10529 static asection *
10530 elf32_arm_gc_mark_hook (asection *sec,
10531 struct bfd_link_info *info,
10532 Elf_Internal_Rela *rel,
10533 struct elf_link_hash_entry *h,
10534 Elf_Internal_Sym *sym)
10535 {
10536 if (h != NULL)
10537 switch (ELF32_R_TYPE (rel->r_info))
10538 {
10539 case R_ARM_GNU_VTINHERIT:
10540 case R_ARM_GNU_VTENTRY:
10541 return NULL;
10542 }
10543
10544 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
10545 }
10546
10547 /* Update the got entry reference counts for the section being removed. */
10548
10549 static bfd_boolean
10550 elf32_arm_gc_sweep_hook (bfd * abfd,
10551 struct bfd_link_info * info,
10552 asection * sec,
10553 const Elf_Internal_Rela * relocs)
10554 {
10555 Elf_Internal_Shdr *symtab_hdr;
10556 struct elf_link_hash_entry **sym_hashes;
10557 bfd_signed_vma *local_got_refcounts;
10558 const Elf_Internal_Rela *rel, *relend;
10559 struct elf32_arm_link_hash_table * globals;
10560
10561 if (info->relocatable)
10562 return TRUE;
10563
10564 globals = elf32_arm_hash_table (info);
10565
10566 elf_section_data (sec)->local_dynrel = NULL;
10567
10568 symtab_hdr = & elf_symtab_hdr (abfd);
10569 sym_hashes = elf_sym_hashes (abfd);
10570 local_got_refcounts = elf_local_got_refcounts (abfd);
10571
10572 check_use_blx (globals);
10573
10574 relend = relocs + sec->reloc_count;
10575 for (rel = relocs; rel < relend; rel++)
10576 {
10577 unsigned long r_symndx;
10578 struct elf_link_hash_entry *h = NULL;
10579 int r_type;
10580
10581 r_symndx = ELF32_R_SYM (rel->r_info);
10582 if (r_symndx >= symtab_hdr->sh_info)
10583 {
10584 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
10585 while (h->root.type == bfd_link_hash_indirect
10586 || h->root.type == bfd_link_hash_warning)
10587 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10588 }
10589
10590 r_type = ELF32_R_TYPE (rel->r_info);
10591 r_type = arm_real_reloc_type (globals, r_type);
10592 switch (r_type)
10593 {
10594 case R_ARM_GOT32:
10595 case R_ARM_GOT_PREL:
10596 case R_ARM_TLS_GD32:
10597 case R_ARM_TLS_IE32:
10598 if (h != NULL)
10599 {
10600 if (h->got.refcount > 0)
10601 h->got.refcount -= 1;
10602 }
10603 else if (local_got_refcounts != NULL)
10604 {
10605 if (local_got_refcounts[r_symndx] > 0)
10606 local_got_refcounts[r_symndx] -= 1;
10607 }
10608 break;
10609
10610 case R_ARM_TLS_LDM32:
10611 elf32_arm_hash_table (info)->tls_ldm_got.refcount -= 1;
10612 break;
10613
10614 case R_ARM_ABS32:
10615 case R_ARM_ABS32_NOI:
10616 case R_ARM_REL32:
10617 case R_ARM_REL32_NOI:
10618 case R_ARM_PC24:
10619 case R_ARM_PLT32:
10620 case R_ARM_CALL:
10621 case R_ARM_JUMP24:
10622 case R_ARM_PREL31:
10623 case R_ARM_THM_CALL:
10624 case R_ARM_THM_JUMP24:
10625 case R_ARM_THM_JUMP19:
10626 case R_ARM_MOVW_ABS_NC:
10627 case R_ARM_MOVT_ABS:
10628 case R_ARM_MOVW_PREL_NC:
10629 case R_ARM_MOVT_PREL:
10630 case R_ARM_THM_MOVW_ABS_NC:
10631 case R_ARM_THM_MOVT_ABS:
10632 case R_ARM_THM_MOVW_PREL_NC:
10633 case R_ARM_THM_MOVT_PREL:
10634 /* Should the interworking branches be here also? */
10635
10636 if (h != NULL)
10637 {
10638 struct elf32_arm_link_hash_entry *eh;
10639 struct elf32_arm_relocs_copied **pp;
10640 struct elf32_arm_relocs_copied *p;
10641
10642 eh = (struct elf32_arm_link_hash_entry *) h;
10643
10644 if (h->plt.refcount > 0)
10645 {
10646 h->plt.refcount -= 1;
10647 if (r_type == R_ARM_THM_CALL)
10648 eh->plt_maybe_thumb_refcount--;
10649
10650 if (r_type == R_ARM_THM_JUMP24
10651 || r_type == R_ARM_THM_JUMP19)
10652 eh->plt_thumb_refcount--;
10653 }
10654
10655 if (r_type == R_ARM_ABS32
10656 || r_type == R_ARM_REL32
10657 || r_type == R_ARM_ABS32_NOI
10658 || r_type == R_ARM_REL32_NOI)
10659 {
10660 for (pp = &eh->relocs_copied; (p = *pp) != NULL;
10661 pp = &p->next)
10662 if (p->section == sec)
10663 {
10664 p->count -= 1;
10665 if (ELF32_R_TYPE (rel->r_info) == R_ARM_REL32
10666 || ELF32_R_TYPE (rel->r_info) == R_ARM_REL32_NOI)
10667 p->pc_count -= 1;
10668 if (p->count == 0)
10669 *pp = p->next;
10670 break;
10671 }
10672 }
10673 }
10674 break;
10675
10676 default:
10677 break;
10678 }
10679 }
10680
10681 return TRUE;
10682 }
10683
10684 /* Look through the relocs for a section during the first phase. */
10685
10686 static bfd_boolean
10687 elf32_arm_check_relocs (bfd *abfd, struct bfd_link_info *info,
10688 asection *sec, const Elf_Internal_Rela *relocs)
10689 {
10690 Elf_Internal_Shdr *symtab_hdr;
10691 struct elf_link_hash_entry **sym_hashes;
10692 const Elf_Internal_Rela *rel;
10693 const Elf_Internal_Rela *rel_end;
10694 bfd *dynobj;
10695 asection *sreloc;
10696 bfd_vma *local_got_offsets;
10697 struct elf32_arm_link_hash_table *htab;
10698 bfd_boolean needs_plt;
10699 unsigned long nsyms;
10700
10701 if (info->relocatable)
10702 return TRUE;
10703
10704 BFD_ASSERT (is_arm_elf (abfd));
10705
10706 htab = elf32_arm_hash_table (info);
10707 sreloc = NULL;
10708
10709 /* Create dynamic sections for relocatable executables so that we can
10710 copy relocations. */
10711 if (htab->root.is_relocatable_executable
10712 && ! htab->root.dynamic_sections_created)
10713 {
10714 if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
10715 return FALSE;
10716 }
10717
10718 dynobj = elf_hash_table (info)->dynobj;
10719 local_got_offsets = elf_local_got_offsets (abfd);
10720
10721 symtab_hdr = & elf_symtab_hdr (abfd);
10722 sym_hashes = elf_sym_hashes (abfd);
10723 nsyms = NUM_SHDR_ENTRIES (symtab_hdr);
10724
10725 rel_end = relocs + sec->reloc_count;
10726 for (rel = relocs; rel < rel_end; rel++)
10727 {
10728 struct elf_link_hash_entry *h;
10729 struct elf32_arm_link_hash_entry *eh;
10730 unsigned long r_symndx;
10731 int r_type;
10732
10733 r_symndx = ELF32_R_SYM (rel->r_info);
10734 r_type = ELF32_R_TYPE (rel->r_info);
10735 r_type = arm_real_reloc_type (htab, r_type);
10736
10737 if (r_symndx >= nsyms
10738 /* PR 9934: It is possible to have relocations that do not
10739 refer to symbols, thus it is also possible to have an
10740 object file containing relocations but no symbol table. */
10741 && (r_symndx > 0 || nsyms > 0))
10742 {
10743 (*_bfd_error_handler) (_("%B: bad symbol index: %d"), abfd,
10744 r_symndx);
10745 return FALSE;
10746 }
10747
10748 if (nsyms == 0 || r_symndx < symtab_hdr->sh_info)
10749 h = NULL;
10750 else
10751 {
10752 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
10753 while (h->root.type == bfd_link_hash_indirect
10754 || h->root.type == bfd_link_hash_warning)
10755 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10756 }
10757
10758 eh = (struct elf32_arm_link_hash_entry *) h;
10759
10760 switch (r_type)
10761 {
10762 case R_ARM_GOT32:
10763 case R_ARM_GOT_PREL:
10764 case R_ARM_TLS_GD32:
10765 case R_ARM_TLS_IE32:
10766 /* This symbol requires a global offset table entry. */
10767 {
10768 int tls_type, old_tls_type;
10769
10770 switch (r_type)
10771 {
10772 case R_ARM_TLS_GD32: tls_type = GOT_TLS_GD; break;
10773 case R_ARM_TLS_IE32: tls_type = GOT_TLS_IE; break;
10774 default: tls_type = GOT_NORMAL; break;
10775 }
10776
10777 if (h != NULL)
10778 {
10779 h->got.refcount++;
10780 old_tls_type = elf32_arm_hash_entry (h)->tls_type;
10781 }
10782 else
10783 {
10784 bfd_signed_vma *local_got_refcounts;
10785
10786 /* This is a global offset table entry for a local symbol. */
10787 local_got_refcounts = elf_local_got_refcounts (abfd);
10788 if (local_got_refcounts == NULL)
10789 {
10790 bfd_size_type size;
10791
10792 size = symtab_hdr->sh_info;
10793 size *= (sizeof (bfd_signed_vma) + sizeof (char));
10794 local_got_refcounts = bfd_zalloc (abfd, size);
10795 if (local_got_refcounts == NULL)
10796 return FALSE;
10797 elf_local_got_refcounts (abfd) = local_got_refcounts;
10798 elf32_arm_local_got_tls_type (abfd)
10799 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
10800 }
10801 local_got_refcounts[r_symndx] += 1;
10802 old_tls_type = elf32_arm_local_got_tls_type (abfd) [r_symndx];
10803 }
10804
10805 /* We will already have issued an error message if there is a
10806 TLS / non-TLS mismatch, based on the symbol type. We don't
10807 support any linker relaxations. So just combine any TLS
10808 types needed. */
10809 if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
10810 && tls_type != GOT_NORMAL)
10811 tls_type |= old_tls_type;
10812
10813 if (old_tls_type != tls_type)
10814 {
10815 if (h != NULL)
10816 elf32_arm_hash_entry (h)->tls_type = tls_type;
10817 else
10818 elf32_arm_local_got_tls_type (abfd) [r_symndx] = tls_type;
10819 }
10820 }
10821 /* Fall through. */
10822
10823 case R_ARM_TLS_LDM32:
10824 if (r_type == R_ARM_TLS_LDM32)
10825 htab->tls_ldm_got.refcount++;
10826 /* Fall through. */
10827
10828 case R_ARM_GOTOFF32:
10829 case R_ARM_GOTPC:
10830 if (htab->sgot == NULL)
10831 {
10832 if (htab->root.dynobj == NULL)
10833 htab->root.dynobj = abfd;
10834 if (!create_got_section (htab->root.dynobj, info))
10835 return FALSE;
10836 }
10837 break;
10838
10839 case R_ARM_ABS12:
10840 /* VxWorks uses dynamic R_ARM_ABS12 relocations for
10841 ldr __GOTT_INDEX__ offsets. */
10842 if (!htab->vxworks_p)
10843 break;
10844 /* Fall through. */
10845
10846 case R_ARM_PC24:
10847 case R_ARM_PLT32:
10848 case R_ARM_CALL:
10849 case R_ARM_JUMP24:
10850 case R_ARM_PREL31:
10851 case R_ARM_THM_CALL:
10852 case R_ARM_THM_JUMP24:
10853 case R_ARM_THM_JUMP19:
10854 needs_plt = 1;
10855 goto normal_reloc;
10856
10857 case R_ARM_MOVW_ABS_NC:
10858 case R_ARM_MOVT_ABS:
10859 case R_ARM_THM_MOVW_ABS_NC:
10860 case R_ARM_THM_MOVT_ABS:
10861 if (info->shared)
10862 {
10863 (*_bfd_error_handler)
10864 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
10865 abfd, elf32_arm_howto_table_1[r_type].name,
10866 (h) ? h->root.root.string : "a local symbol");
10867 bfd_set_error (bfd_error_bad_value);
10868 return FALSE;
10869 }
10870
10871 /* Fall through. */
10872 case R_ARM_ABS32:
10873 case R_ARM_ABS32_NOI:
10874 case R_ARM_REL32:
10875 case R_ARM_REL32_NOI:
10876 case R_ARM_MOVW_PREL_NC:
10877 case R_ARM_MOVT_PREL:
10878 case R_ARM_THM_MOVW_PREL_NC:
10879 case R_ARM_THM_MOVT_PREL:
10880 needs_plt = 0;
10881 normal_reloc:
10882
10883 /* Should the interworking branches be listed here? */
10884 if (h != NULL)
10885 {
10886 /* If this reloc is in a read-only section, we might
10887 need a copy reloc. We can't check reliably at this
10888 stage whether the section is read-only, as input
10889 sections have not yet been mapped to output sections.
10890 Tentatively set the flag for now, and correct in
10891 adjust_dynamic_symbol. */
10892 if (!info->shared)
10893 h->non_got_ref = 1;
10894
10895 /* We may need a .plt entry if the function this reloc
10896 refers to is in a different object. We can't tell for
10897 sure yet, because something later might force the
10898 symbol local. */
10899 if (needs_plt)
10900 h->needs_plt = 1;
10901
10902 /* If we create a PLT entry, this relocation will reference
10903 it, even if it's an ABS32 relocation. */
10904 h->plt.refcount += 1;
10905
10906 /* It's too early to use htab->use_blx here, so we have to
10907 record possible blx references separately from
10908 relocs that definitely need a thumb stub. */
10909
10910 if (r_type == R_ARM_THM_CALL)
10911 eh->plt_maybe_thumb_refcount += 1;
10912
10913 if (r_type == R_ARM_THM_JUMP24
10914 || r_type == R_ARM_THM_JUMP19)
10915 eh->plt_thumb_refcount += 1;
10916 }
10917
10918 /* If we are creating a shared library or relocatable executable,
10919 and this is a reloc against a global symbol, or a non PC
10920 relative reloc against a local symbol, then we need to copy
10921 the reloc into the shared library. However, if we are linking
10922 with -Bsymbolic, we do not need to copy a reloc against a
10923 global symbol which is defined in an object we are
10924 including in the link (i.e., DEF_REGULAR is set). At
10925 this point we have not seen all the input files, so it is
10926 possible that DEF_REGULAR is not set now but will be set
10927 later (it is never cleared). We account for that
10928 possibility below by storing information in the
10929 relocs_copied field of the hash table entry. */
10930 if ((info->shared || htab->root.is_relocatable_executable)
10931 && (sec->flags & SEC_ALLOC) != 0
10932 && ((r_type == R_ARM_ABS32 || r_type == R_ARM_ABS32_NOI)
10933 || (h != NULL && ! h->needs_plt
10934 && (! info->symbolic || ! h->def_regular))))
10935 {
10936 struct elf32_arm_relocs_copied *p, **head;
10937
10938 /* When creating a shared object, we must copy these
10939 reloc types into the output file. We create a reloc
10940 section in dynobj and make room for this reloc. */
10941 if (sreloc == NULL)
10942 {
10943 sreloc = _bfd_elf_make_dynamic_reloc_section
10944 (sec, dynobj, 2, abfd, ! htab->use_rel);
10945
10946 if (sreloc == NULL)
10947 return FALSE;
10948
10949 /* BPABI objects never have dynamic relocations mapped. */
10950 if (htab->symbian_p)
10951 {
10952 flagword flags;
10953
10954 flags = bfd_get_section_flags (dynobj, sreloc);
10955 flags &= ~(SEC_LOAD | SEC_ALLOC);
10956 bfd_set_section_flags (dynobj, sreloc, flags);
10957 }
10958 }
10959
10960 /* If this is a global symbol, we count the number of
10961 relocations we need for this symbol. */
10962 if (h != NULL)
10963 {
10964 head = &((struct elf32_arm_link_hash_entry *) h)->relocs_copied;
10965 }
10966 else
10967 {
10968 /* Track dynamic relocs needed for local syms too.
10969 We really need local syms available to do this
10970 easily. Oh well. */
10971 asection *s;
10972 void *vpp;
10973 Elf_Internal_Sym *isym;
10974
10975 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
10976 abfd, r_symndx);
10977 if (isym == NULL)
10978 return FALSE;
10979
10980 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
10981 if (s == NULL)
10982 s = sec;
10983
10984 vpp = &elf_section_data (s)->local_dynrel;
10985 head = (struct elf32_arm_relocs_copied **) vpp;
10986 }
10987
10988 p = *head;
10989 if (p == NULL || p->section != sec)
10990 {
10991 bfd_size_type amt = sizeof *p;
10992
10993 p = bfd_alloc (htab->root.dynobj, amt);
10994 if (p == NULL)
10995 return FALSE;
10996 p->next = *head;
10997 *head = p;
10998 p->section = sec;
10999 p->count = 0;
11000 p->pc_count = 0;
11001 }
11002
11003 if (r_type == R_ARM_REL32 || r_type == R_ARM_REL32_NOI)
11004 p->pc_count += 1;
11005 p->count += 1;
11006 }
11007 break;
11008
11009 /* This relocation describes the C++ object vtable hierarchy.
11010 Reconstruct it for later use during GC. */
11011 case R_ARM_GNU_VTINHERIT:
11012 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
11013 return FALSE;
11014 break;
11015
11016 /* This relocation describes which C++ vtable entries are actually
11017 used. Record for later use during GC. */
11018 case R_ARM_GNU_VTENTRY:
11019 BFD_ASSERT (h != NULL);
11020 if (h != NULL
11021 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
11022 return FALSE;
11023 break;
11024 }
11025 }
11026
11027 return TRUE;
11028 }
11029
11030 /* Unwinding tables are not referenced directly. This pass marks them as
11031 required if the corresponding code section is marked. */
11032
11033 static bfd_boolean
11034 elf32_arm_gc_mark_extra_sections (struct bfd_link_info *info,
11035 elf_gc_mark_hook_fn gc_mark_hook)
11036 {
11037 bfd *sub;
11038 Elf_Internal_Shdr **elf_shdrp;
11039 bfd_boolean again;
11040
11041 /* Marking EH data may cause additional code sections to be marked,
11042 requiring multiple passes. */
11043 again = TRUE;
11044 while (again)
11045 {
11046 again = FALSE;
11047 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
11048 {
11049 asection *o;
11050
11051 if (! is_arm_elf (sub))
11052 continue;
11053
11054 elf_shdrp = elf_elfsections (sub);
11055 for (o = sub->sections; o != NULL; o = o->next)
11056 {
11057 Elf_Internal_Shdr *hdr;
11058
11059 hdr = &elf_section_data (o)->this_hdr;
11060 if (hdr->sh_type == SHT_ARM_EXIDX
11061 && hdr->sh_link
11062 && hdr->sh_link < elf_numsections (sub)
11063 && !o->gc_mark
11064 && elf_shdrp[hdr->sh_link]->bfd_section->gc_mark)
11065 {
11066 again = TRUE;
11067 if (!_bfd_elf_gc_mark (info, o, gc_mark_hook))
11068 return FALSE;
11069 }
11070 }
11071 }
11072 }
11073
11074 return TRUE;
11075 }
11076
11077 /* Treat mapping symbols as special target symbols. */
11078
11079 static bfd_boolean
11080 elf32_arm_is_target_special_symbol (bfd * abfd ATTRIBUTE_UNUSED, asymbol * sym)
11081 {
11082 return bfd_is_arm_special_symbol_name (sym->name,
11083 BFD_ARM_SPECIAL_SYM_TYPE_ANY);
11084 }
11085
11086 /* This is a copy of elf_find_function() from elf.c except that
11087 ARM mapping symbols are ignored when looking for function names
11088 and STT_ARM_TFUNC is considered to a function type. */
11089
11090 static bfd_boolean
11091 arm_elf_find_function (bfd * abfd ATTRIBUTE_UNUSED,
11092 asection * section,
11093 asymbol ** symbols,
11094 bfd_vma offset,
11095 const char ** filename_ptr,
11096 const char ** functionname_ptr)
11097 {
11098 const char * filename = NULL;
11099 asymbol * func = NULL;
11100 bfd_vma low_func = 0;
11101 asymbol ** p;
11102
11103 for (p = symbols; *p != NULL; p++)
11104 {
11105 elf_symbol_type *q;
11106
11107 q = (elf_symbol_type *) *p;
11108
11109 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
11110 {
11111 default:
11112 break;
11113 case STT_FILE:
11114 filename = bfd_asymbol_name (&q->symbol);
11115 break;
11116 case STT_FUNC:
11117 case STT_ARM_TFUNC:
11118 case STT_NOTYPE:
11119 /* Skip mapping symbols. */
11120 if ((q->symbol.flags & BSF_LOCAL)
11121 && bfd_is_arm_special_symbol_name (q->symbol.name,
11122 BFD_ARM_SPECIAL_SYM_TYPE_ANY))
11123 continue;
11124 /* Fall through. */
11125 if (bfd_get_section (&q->symbol) == section
11126 && q->symbol.value >= low_func
11127 && q->symbol.value <= offset)
11128 {
11129 func = (asymbol *) q;
11130 low_func = q->symbol.value;
11131 }
11132 break;
11133 }
11134 }
11135
11136 if (func == NULL)
11137 return FALSE;
11138
11139 if (filename_ptr)
11140 *filename_ptr = filename;
11141 if (functionname_ptr)
11142 *functionname_ptr = bfd_asymbol_name (func);
11143
11144 return TRUE;
11145 }
11146
11147
11148 /* Find the nearest line to a particular section and offset, for error
11149 reporting. This code is a duplicate of the code in elf.c, except
11150 that it uses arm_elf_find_function. */
11151
11152 static bfd_boolean
11153 elf32_arm_find_nearest_line (bfd * abfd,
11154 asection * section,
11155 asymbol ** symbols,
11156 bfd_vma offset,
11157 const char ** filename_ptr,
11158 const char ** functionname_ptr,
11159 unsigned int * line_ptr)
11160 {
11161 bfd_boolean found = FALSE;
11162
11163 /* We skip _bfd_dwarf1_find_nearest_line since no known ARM toolchain uses it. */
11164
11165 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
11166 filename_ptr, functionname_ptr,
11167 line_ptr, 0,
11168 & elf_tdata (abfd)->dwarf2_find_line_info))
11169 {
11170 if (!*functionname_ptr)
11171 arm_elf_find_function (abfd, section, symbols, offset,
11172 *filename_ptr ? NULL : filename_ptr,
11173 functionname_ptr);
11174
11175 return TRUE;
11176 }
11177
11178 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
11179 & found, filename_ptr,
11180 functionname_ptr, line_ptr,
11181 & elf_tdata (abfd)->line_info))
11182 return FALSE;
11183
11184 if (found && (*functionname_ptr || *line_ptr))
11185 return TRUE;
11186
11187 if (symbols == NULL)
11188 return FALSE;
11189
11190 if (! arm_elf_find_function (abfd, section, symbols, offset,
11191 filename_ptr, functionname_ptr))
11192 return FALSE;
11193
11194 *line_ptr = 0;
11195 return TRUE;
11196 }
11197
11198 static bfd_boolean
11199 elf32_arm_find_inliner_info (bfd * abfd,
11200 const char ** filename_ptr,
11201 const char ** functionname_ptr,
11202 unsigned int * line_ptr)
11203 {
11204 bfd_boolean found;
11205 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
11206 functionname_ptr, line_ptr,
11207 & elf_tdata (abfd)->dwarf2_find_line_info);
11208 return found;
11209 }
11210
11211 /* Adjust a symbol defined by a dynamic object and referenced by a
11212 regular object. The current definition is in some section of the
11213 dynamic object, but we're not including those sections. We have to
11214 change the definition to something the rest of the link can
11215 understand. */
11216
11217 static bfd_boolean
11218 elf32_arm_adjust_dynamic_symbol (struct bfd_link_info * info,
11219 struct elf_link_hash_entry * h)
11220 {
11221 bfd * dynobj;
11222 asection * s;
11223 struct elf32_arm_link_hash_entry * eh;
11224 struct elf32_arm_link_hash_table *globals;
11225
11226 globals = elf32_arm_hash_table (info);
11227 dynobj = elf_hash_table (info)->dynobj;
11228
11229 /* Make sure we know what is going on here. */
11230 BFD_ASSERT (dynobj != NULL
11231 && (h->needs_plt
11232 || h->u.weakdef != NULL
11233 || (h->def_dynamic
11234 && h->ref_regular
11235 && !h->def_regular)));
11236
11237 eh = (struct elf32_arm_link_hash_entry *) h;
11238
11239 /* If this is a function, put it in the procedure linkage table. We
11240 will fill in the contents of the procedure linkage table later,
11241 when we know the address of the .got section. */
11242 if (h->type == STT_FUNC || h->type == STT_ARM_TFUNC
11243 || h->needs_plt)
11244 {
11245 if (h->plt.refcount <= 0
11246 || SYMBOL_CALLS_LOCAL (info, h)
11247 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
11248 && h->root.type == bfd_link_hash_undefweak))
11249 {
11250 /* This case can occur if we saw a PLT32 reloc in an input
11251 file, but the symbol was never referred to by a dynamic
11252 object, or if all references were garbage collected. In
11253 such a case, we don't actually need to build a procedure
11254 linkage table, and we can just do a PC24 reloc instead. */
11255 h->plt.offset = (bfd_vma) -1;
11256 eh->plt_thumb_refcount = 0;
11257 eh->plt_maybe_thumb_refcount = 0;
11258 h->needs_plt = 0;
11259 }
11260
11261 return TRUE;
11262 }
11263 else
11264 {
11265 /* It's possible that we incorrectly decided a .plt reloc was
11266 needed for an R_ARM_PC24 or similar reloc to a non-function sym
11267 in check_relocs. We can't decide accurately between function
11268 and non-function syms in check-relocs; Objects loaded later in
11269 the link may change h->type. So fix it now. */
11270 h->plt.offset = (bfd_vma) -1;
11271 eh->plt_thumb_refcount = 0;
11272 eh->plt_maybe_thumb_refcount = 0;
11273 }
11274
11275 /* If this is a weak symbol, and there is a real definition, the
11276 processor independent code will have arranged for us to see the
11277 real definition first, and we can just use the same value. */
11278 if (h->u.weakdef != NULL)
11279 {
11280 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
11281 || h->u.weakdef->root.type == bfd_link_hash_defweak);
11282 h->root.u.def.section = h->u.weakdef->root.u.def.section;
11283 h->root.u.def.value = h->u.weakdef->root.u.def.value;
11284 return TRUE;
11285 }
11286
11287 /* If there are no non-GOT references, we do not need a copy
11288 relocation. */
11289 if (!h->non_got_ref)
11290 return TRUE;
11291
11292 /* This is a reference to a symbol defined by a dynamic object which
11293 is not a function. */
11294
11295 /* If we are creating a shared library, we must presume that the
11296 only references to the symbol are via the global offset table.
11297 For such cases we need not do anything here; the relocations will
11298 be handled correctly by relocate_section. Relocatable executables
11299 can reference data in shared objects directly, so we don't need to
11300 do anything here. */
11301 if (info->shared || globals->root.is_relocatable_executable)
11302 return TRUE;
11303
11304 if (h->size == 0)
11305 {
11306 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
11307 h->root.root.string);
11308 return TRUE;
11309 }
11310
11311 /* We must allocate the symbol in our .dynbss section, which will
11312 become part of the .bss section of the executable. There will be
11313 an entry for this symbol in the .dynsym section. The dynamic
11314 object will contain position independent code, so all references
11315 from the dynamic object to this symbol will go through the global
11316 offset table. The dynamic linker will use the .dynsym entry to
11317 determine the address it must put in the global offset table, so
11318 both the dynamic object and the regular object will refer to the
11319 same memory location for the variable. */
11320 s = bfd_get_section_by_name (dynobj, ".dynbss");
11321 BFD_ASSERT (s != NULL);
11322
11323 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
11324 copy the initial value out of the dynamic object and into the
11325 runtime process image. We need to remember the offset into the
11326 .rel(a).bss section we are going to use. */
11327 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
11328 {
11329 asection *srel;
11330
11331 srel = bfd_get_section_by_name (dynobj, RELOC_SECTION (globals, ".bss"));
11332 BFD_ASSERT (srel != NULL);
11333 srel->size += RELOC_SIZE (globals);
11334 h->needs_copy = 1;
11335 }
11336
11337 return _bfd_elf_adjust_dynamic_copy (h, s);
11338 }
11339
11340 /* Allocate space in .plt, .got and associated reloc sections for
11341 dynamic relocs. */
11342
11343 static bfd_boolean
11344 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
11345 {
11346 struct bfd_link_info *info;
11347 struct elf32_arm_link_hash_table *htab;
11348 struct elf32_arm_link_hash_entry *eh;
11349 struct elf32_arm_relocs_copied *p;
11350 bfd_signed_vma thumb_refs;
11351
11352 eh = (struct elf32_arm_link_hash_entry *) h;
11353
11354 if (h->root.type == bfd_link_hash_indirect)
11355 return TRUE;
11356
11357 if (h->root.type == bfd_link_hash_warning)
11358 /* When warning symbols are created, they **replace** the "real"
11359 entry in the hash table, thus we never get to see the real
11360 symbol in a hash traversal. So look at it now. */
11361 h = (struct elf_link_hash_entry *) h->root.u.i.link;
11362
11363 info = (struct bfd_link_info *) inf;
11364 htab = elf32_arm_hash_table (info);
11365
11366 if (htab->root.dynamic_sections_created
11367 && h->plt.refcount > 0)
11368 {
11369 /* Make sure this symbol is output as a dynamic symbol.
11370 Undefined weak syms won't yet be marked as dynamic. */
11371 if (h->dynindx == -1
11372 && !h->forced_local)
11373 {
11374 if (! bfd_elf_link_record_dynamic_symbol (info, h))
11375 return FALSE;
11376 }
11377
11378 if (info->shared
11379 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
11380 {
11381 asection *s = htab->splt;
11382
11383 /* If this is the first .plt entry, make room for the special
11384 first entry. */
11385 if (s->size == 0)
11386 s->size += htab->plt_header_size;
11387
11388 h->plt.offset = s->size;
11389
11390 /* If we will insert a Thumb trampoline before this PLT, leave room
11391 for it. */
11392 thumb_refs = eh->plt_thumb_refcount;
11393 if (!htab->use_blx)
11394 thumb_refs += eh->plt_maybe_thumb_refcount;
11395
11396 if (thumb_refs > 0)
11397 {
11398 h->plt.offset += PLT_THUMB_STUB_SIZE;
11399 s->size += PLT_THUMB_STUB_SIZE;
11400 }
11401
11402 /* If this symbol is not defined in a regular file, and we are
11403 not generating a shared library, then set the symbol to this
11404 location in the .plt. This is required to make function
11405 pointers compare as equal between the normal executable and
11406 the shared library. */
11407 if (! info->shared
11408 && !h->def_regular)
11409 {
11410 h->root.u.def.section = s;
11411 h->root.u.def.value = h->plt.offset;
11412 }
11413
11414 /* Make sure the function is not marked as Thumb, in case
11415 it is the target of an ABS32 relocation, which will
11416 point to the PLT entry. */
11417 if (ELF_ST_TYPE (h->type) == STT_ARM_TFUNC)
11418 h->type = ELF_ST_INFO (ELF_ST_BIND (h->type), STT_FUNC);
11419
11420 /* Make room for this entry. */
11421 s->size += htab->plt_entry_size;
11422
11423 if (!htab->symbian_p)
11424 {
11425 /* We also need to make an entry in the .got.plt section, which
11426 will be placed in the .got section by the linker script. */
11427 eh->plt_got_offset = htab->sgotplt->size;
11428 htab->sgotplt->size += 4;
11429 }
11430
11431 /* We also need to make an entry in the .rel(a).plt section. */
11432 htab->srelplt->size += RELOC_SIZE (htab);
11433
11434 /* VxWorks executables have a second set of relocations for
11435 each PLT entry. They go in a separate relocation section,
11436 which is processed by the kernel loader. */
11437 if (htab->vxworks_p && !info->shared)
11438 {
11439 /* There is a relocation for the initial PLT entry:
11440 an R_ARM_32 relocation for _GLOBAL_OFFSET_TABLE_. */
11441 if (h->plt.offset == htab->plt_header_size)
11442 htab->srelplt2->size += RELOC_SIZE (htab);
11443
11444 /* There are two extra relocations for each subsequent
11445 PLT entry: an R_ARM_32 relocation for the GOT entry,
11446 and an R_ARM_32 relocation for the PLT entry. */
11447 htab->srelplt2->size += RELOC_SIZE (htab) * 2;
11448 }
11449 }
11450 else
11451 {
11452 h->plt.offset = (bfd_vma) -1;
11453 h->needs_plt = 0;
11454 }
11455 }
11456 else
11457 {
11458 h->plt.offset = (bfd_vma) -1;
11459 h->needs_plt = 0;
11460 }
11461
11462 if (h->got.refcount > 0)
11463 {
11464 asection *s;
11465 bfd_boolean dyn;
11466 int tls_type = elf32_arm_hash_entry (h)->tls_type;
11467 int indx;
11468
11469 /* Make sure this symbol is output as a dynamic symbol.
11470 Undefined weak syms won't yet be marked as dynamic. */
11471 if (h->dynindx == -1
11472 && !h->forced_local)
11473 {
11474 if (! bfd_elf_link_record_dynamic_symbol (info, h))
11475 return FALSE;
11476 }
11477
11478 if (!htab->symbian_p)
11479 {
11480 s = htab->sgot;
11481 h->got.offset = s->size;
11482
11483 if (tls_type == GOT_UNKNOWN)
11484 abort ();
11485
11486 if (tls_type == GOT_NORMAL)
11487 /* Non-TLS symbols need one GOT slot. */
11488 s->size += 4;
11489 else
11490 {
11491 if (tls_type & GOT_TLS_GD)
11492 /* R_ARM_TLS_GD32 needs 2 consecutive GOT slots. */
11493 s->size += 8;
11494 if (tls_type & GOT_TLS_IE)
11495 /* R_ARM_TLS_IE32 needs one GOT slot. */
11496 s->size += 4;
11497 }
11498
11499 dyn = htab->root.dynamic_sections_created;
11500
11501 indx = 0;
11502 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
11503 && (!info->shared
11504 || !SYMBOL_REFERENCES_LOCAL (info, h)))
11505 indx = h->dynindx;
11506
11507 if (tls_type != GOT_NORMAL
11508 && (info->shared || indx != 0)
11509 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
11510 || h->root.type != bfd_link_hash_undefweak))
11511 {
11512 if (tls_type & GOT_TLS_IE)
11513 htab->srelgot->size += RELOC_SIZE (htab);
11514
11515 if (tls_type & GOT_TLS_GD)
11516 htab->srelgot->size += RELOC_SIZE (htab);
11517
11518 if ((tls_type & GOT_TLS_GD) && indx != 0)
11519 htab->srelgot->size += RELOC_SIZE (htab);
11520 }
11521 else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
11522 || h->root.type != bfd_link_hash_undefweak)
11523 && (info->shared
11524 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
11525 htab->srelgot->size += RELOC_SIZE (htab);
11526 }
11527 }
11528 else
11529 h->got.offset = (bfd_vma) -1;
11530
11531 /* Allocate stubs for exported Thumb functions on v4t. */
11532 if (!htab->use_blx && h->dynindx != -1
11533 && h->def_regular
11534 && ELF_ST_TYPE (h->type) == STT_ARM_TFUNC
11535 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
11536 {
11537 struct elf_link_hash_entry * th;
11538 struct bfd_link_hash_entry * bh;
11539 struct elf_link_hash_entry * myh;
11540 char name[1024];
11541 asection *s;
11542 bh = NULL;
11543 /* Create a new symbol to regist the real location of the function. */
11544 s = h->root.u.def.section;
11545 sprintf (name, "__real_%s", h->root.root.string);
11546 _bfd_generic_link_add_one_symbol (info, s->owner,
11547 name, BSF_GLOBAL, s,
11548 h->root.u.def.value,
11549 NULL, TRUE, FALSE, &bh);
11550
11551 myh = (struct elf_link_hash_entry *) bh;
11552 myh->type = ELF_ST_INFO (STB_LOCAL, STT_ARM_TFUNC);
11553 myh->forced_local = 1;
11554 eh->export_glue = myh;
11555 th = record_arm_to_thumb_glue (info, h);
11556 /* Point the symbol at the stub. */
11557 h->type = ELF_ST_INFO (ELF_ST_BIND (h->type), STT_FUNC);
11558 h->root.u.def.section = th->root.u.def.section;
11559 h->root.u.def.value = th->root.u.def.value & ~1;
11560 }
11561
11562 if (eh->relocs_copied == NULL)
11563 return TRUE;
11564
11565 /* In the shared -Bsymbolic case, discard space allocated for
11566 dynamic pc-relative relocs against symbols which turn out to be
11567 defined in regular objects. For the normal shared case, discard
11568 space for pc-relative relocs that have become local due to symbol
11569 visibility changes. */
11570
11571 if (info->shared || htab->root.is_relocatable_executable)
11572 {
11573 /* The only relocs that use pc_count are R_ARM_REL32 and
11574 R_ARM_REL32_NOI, which will appear on something like
11575 ".long foo - .". We want calls to protected symbols to resolve
11576 directly to the function rather than going via the plt. If people
11577 want function pointer comparisons to work as expected then they
11578 should avoid writing assembly like ".long foo - .". */
11579 if (SYMBOL_CALLS_LOCAL (info, h))
11580 {
11581 struct elf32_arm_relocs_copied **pp;
11582
11583 for (pp = &eh->relocs_copied; (p = *pp) != NULL; )
11584 {
11585 p->count -= p->pc_count;
11586 p->pc_count = 0;
11587 if (p->count == 0)
11588 *pp = p->next;
11589 else
11590 pp = &p->next;
11591 }
11592 }
11593
11594 if (elf32_arm_hash_table (info)->vxworks_p)
11595 {
11596 struct elf32_arm_relocs_copied **pp;
11597
11598 for (pp = &eh->relocs_copied; (p = *pp) != NULL; )
11599 {
11600 if (strcmp (p->section->output_section->name, ".tls_vars") == 0)
11601 *pp = p->next;
11602 else
11603 pp = &p->next;
11604 }
11605 }
11606
11607 /* Also discard relocs on undefined weak syms with non-default
11608 visibility. */
11609 if (eh->relocs_copied != NULL
11610 && h->root.type == bfd_link_hash_undefweak)
11611 {
11612 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
11613 eh->relocs_copied = NULL;
11614
11615 /* Make sure undefined weak symbols are output as a dynamic
11616 symbol in PIEs. */
11617 else if (h->dynindx == -1
11618 && !h->forced_local)
11619 {
11620 if (! bfd_elf_link_record_dynamic_symbol (info, h))
11621 return FALSE;
11622 }
11623 }
11624
11625 else if (htab->root.is_relocatable_executable && h->dynindx == -1
11626 && h->root.type == bfd_link_hash_new)
11627 {
11628 /* Output absolute symbols so that we can create relocations
11629 against them. For normal symbols we output a relocation
11630 against the section that contains them. */
11631 if (! bfd_elf_link_record_dynamic_symbol (info, h))
11632 return FALSE;
11633 }
11634
11635 }
11636 else
11637 {
11638 /* For the non-shared case, discard space for relocs against
11639 symbols which turn out to need copy relocs or are not
11640 dynamic. */
11641
11642 if (!h->non_got_ref
11643 && ((h->def_dynamic
11644 && !h->def_regular)
11645 || (htab->root.dynamic_sections_created
11646 && (h->root.type == bfd_link_hash_undefweak
11647 || h->root.type == bfd_link_hash_undefined))))
11648 {
11649 /* Make sure this symbol is output as a dynamic symbol.
11650 Undefined weak syms won't yet be marked as dynamic. */
11651 if (h->dynindx == -1
11652 && !h->forced_local)
11653 {
11654 if (! bfd_elf_link_record_dynamic_symbol (info, h))
11655 return FALSE;
11656 }
11657
11658 /* If that succeeded, we know we'll be keeping all the
11659 relocs. */
11660 if (h->dynindx != -1)
11661 goto keep;
11662 }
11663
11664 eh->relocs_copied = NULL;
11665
11666 keep: ;
11667 }
11668
11669 /* Finally, allocate space. */
11670 for (p = eh->relocs_copied; p != NULL; p = p->next)
11671 {
11672 asection *sreloc = elf_section_data (p->section)->sreloc;
11673 sreloc->size += p->count * RELOC_SIZE (htab);
11674 }
11675
11676 return TRUE;
11677 }
11678
11679 /* Find any dynamic relocs that apply to read-only sections. */
11680
11681 static bfd_boolean
11682 elf32_arm_readonly_dynrelocs (struct elf_link_hash_entry * h, void * inf)
11683 {
11684 struct elf32_arm_link_hash_entry * eh;
11685 struct elf32_arm_relocs_copied * p;
11686
11687 if (h->root.type == bfd_link_hash_warning)
11688 h = (struct elf_link_hash_entry *) h->root.u.i.link;
11689
11690 eh = (struct elf32_arm_link_hash_entry *) h;
11691 for (p = eh->relocs_copied; p != NULL; p = p->next)
11692 {
11693 asection *s = p->section;
11694
11695 if (s != NULL && (s->flags & SEC_READONLY) != 0)
11696 {
11697 struct bfd_link_info *info = (struct bfd_link_info *) inf;
11698
11699 info->flags |= DF_TEXTREL;
11700
11701 /* Not an error, just cut short the traversal. */
11702 return FALSE;
11703 }
11704 }
11705 return TRUE;
11706 }
11707
11708 void
11709 bfd_elf32_arm_set_byteswap_code (struct bfd_link_info *info,
11710 int byteswap_code)
11711 {
11712 struct elf32_arm_link_hash_table *globals;
11713
11714 globals = elf32_arm_hash_table (info);
11715 globals->byteswap_code = byteswap_code;
11716 }
11717
11718 /* Set the sizes of the dynamic sections. */
11719
11720 static bfd_boolean
11721 elf32_arm_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
11722 struct bfd_link_info * info)
11723 {
11724 bfd * dynobj;
11725 asection * s;
11726 bfd_boolean plt;
11727 bfd_boolean relocs;
11728 bfd *ibfd;
11729 struct elf32_arm_link_hash_table *htab;
11730
11731 htab = elf32_arm_hash_table (info);
11732 dynobj = elf_hash_table (info)->dynobj;
11733 BFD_ASSERT (dynobj != NULL);
11734 check_use_blx (htab);
11735
11736 if (elf_hash_table (info)->dynamic_sections_created)
11737 {
11738 /* Set the contents of the .interp section to the interpreter. */
11739 if (info->executable)
11740 {
11741 s = bfd_get_section_by_name (dynobj, ".interp");
11742 BFD_ASSERT (s != NULL);
11743 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
11744 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
11745 }
11746 }
11747
11748 /* Set up .got offsets for local syms, and space for local dynamic
11749 relocs. */
11750 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11751 {
11752 bfd_signed_vma *local_got;
11753 bfd_signed_vma *end_local_got;
11754 char *local_tls_type;
11755 bfd_size_type locsymcount;
11756 Elf_Internal_Shdr *symtab_hdr;
11757 asection *srel;
11758 bfd_boolean is_vxworks = elf32_arm_hash_table (info)->vxworks_p;
11759
11760 if (! is_arm_elf (ibfd))
11761 continue;
11762
11763 for (s = ibfd->sections; s != NULL; s = s->next)
11764 {
11765 struct elf32_arm_relocs_copied *p;
11766
11767 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
11768 {
11769 if (!bfd_is_abs_section (p->section)
11770 && bfd_is_abs_section (p->section->output_section))
11771 {
11772 /* Input section has been discarded, either because
11773 it is a copy of a linkonce section or due to
11774 linker script /DISCARD/, so we'll be discarding
11775 the relocs too. */
11776 }
11777 else if (is_vxworks
11778 && strcmp (p->section->output_section->name,
11779 ".tls_vars") == 0)
11780 {
11781 /* Relocations in vxworks .tls_vars sections are
11782 handled specially by the loader. */
11783 }
11784 else if (p->count != 0)
11785 {
11786 srel = elf_section_data (p->section)->sreloc;
11787 srel->size += p->count * RELOC_SIZE (htab);
11788 if ((p->section->output_section->flags & SEC_READONLY) != 0)
11789 info->flags |= DF_TEXTREL;
11790 }
11791 }
11792 }
11793
11794 local_got = elf_local_got_refcounts (ibfd);
11795 if (!local_got)
11796 continue;
11797
11798 symtab_hdr = & elf_symtab_hdr (ibfd);
11799 locsymcount = symtab_hdr->sh_info;
11800 end_local_got = local_got + locsymcount;
11801 local_tls_type = elf32_arm_local_got_tls_type (ibfd);
11802 s = htab->sgot;
11803 srel = htab->srelgot;
11804 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
11805 {
11806 if (*local_got > 0)
11807 {
11808 *local_got = s->size;
11809 if (*local_tls_type & GOT_TLS_GD)
11810 /* TLS_GD relocs need an 8-byte structure in the GOT. */
11811 s->size += 8;
11812 if (*local_tls_type & GOT_TLS_IE)
11813 s->size += 4;
11814 if (*local_tls_type == GOT_NORMAL)
11815 s->size += 4;
11816
11817 if (info->shared || *local_tls_type == GOT_TLS_GD)
11818 srel->size += RELOC_SIZE (htab);
11819 }
11820 else
11821 *local_got = (bfd_vma) -1;
11822 }
11823 }
11824
11825 if (htab->tls_ldm_got.refcount > 0)
11826 {
11827 /* Allocate two GOT entries and one dynamic relocation (if necessary)
11828 for R_ARM_TLS_LDM32 relocations. */
11829 htab->tls_ldm_got.offset = htab->sgot->size;
11830 htab->sgot->size += 8;
11831 if (info->shared)
11832 htab->srelgot->size += RELOC_SIZE (htab);
11833 }
11834 else
11835 htab->tls_ldm_got.offset = -1;
11836
11837 /* Allocate global sym .plt and .got entries, and space for global
11838 sym dynamic relocs. */
11839 elf_link_hash_traverse (& htab->root, allocate_dynrelocs, info);
11840
11841 /* Here we rummage through the found bfds to collect glue information. */
11842 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11843 {
11844 if (! is_arm_elf (ibfd))
11845 continue;
11846
11847 /* Initialise mapping tables for code/data. */
11848 bfd_elf32_arm_init_maps (ibfd);
11849
11850 if (!bfd_elf32_arm_process_before_allocation (ibfd, info)
11851 || !bfd_elf32_arm_vfp11_erratum_scan (ibfd, info))
11852 /* xgettext:c-format */
11853 _bfd_error_handler (_("Errors encountered processing file %s"),
11854 ibfd->filename);
11855 }
11856
11857 /* Allocate space for the glue sections now that we've sized them. */
11858 bfd_elf32_arm_allocate_interworking_sections (info);
11859
11860 /* The check_relocs and adjust_dynamic_symbol entry points have
11861 determined the sizes of the various dynamic sections. Allocate
11862 memory for them. */
11863 plt = FALSE;
11864 relocs = FALSE;
11865 for (s = dynobj->sections; s != NULL; s = s->next)
11866 {
11867 const char * name;
11868
11869 if ((s->flags & SEC_LINKER_CREATED) == 0)
11870 continue;
11871
11872 /* It's OK to base decisions on the section name, because none
11873 of the dynobj section names depend upon the input files. */
11874 name = bfd_get_section_name (dynobj, s);
11875
11876 if (strcmp (name, ".plt") == 0)
11877 {
11878 /* Remember whether there is a PLT. */
11879 plt = s->size != 0;
11880 }
11881 else if (CONST_STRNEQ (name, ".rel"))
11882 {
11883 if (s->size != 0)
11884 {
11885 /* Remember whether there are any reloc sections other
11886 than .rel(a).plt and .rela.plt.unloaded. */
11887 if (s != htab->srelplt && s != htab->srelplt2)
11888 relocs = TRUE;
11889
11890 /* We use the reloc_count field as a counter if we need
11891 to copy relocs into the output file. */
11892 s->reloc_count = 0;
11893 }
11894 }
11895 else if (! CONST_STRNEQ (name, ".got")
11896 && strcmp (name, ".dynbss") != 0)
11897 {
11898 /* It's not one of our sections, so don't allocate space. */
11899 continue;
11900 }
11901
11902 if (s->size == 0)
11903 {
11904 /* If we don't need this section, strip it from the
11905 output file. This is mostly to handle .rel(a).bss and
11906 .rel(a).plt. We must create both sections in
11907 create_dynamic_sections, because they must be created
11908 before the linker maps input sections to output
11909 sections. The linker does that before
11910 adjust_dynamic_symbol is called, and it is that
11911 function which decides whether anything needs to go
11912 into these sections. */
11913 s->flags |= SEC_EXCLUDE;
11914 continue;
11915 }
11916
11917 if ((s->flags & SEC_HAS_CONTENTS) == 0)
11918 continue;
11919
11920 /* Allocate memory for the section contents. */
11921 s->contents = bfd_zalloc (dynobj, s->size);
11922 if (s->contents == NULL)
11923 return FALSE;
11924 }
11925
11926 if (elf_hash_table (info)->dynamic_sections_created)
11927 {
11928 /* Add some entries to the .dynamic section. We fill in the
11929 values later, in elf32_arm_finish_dynamic_sections, but we
11930 must add the entries now so that we get the correct size for
11931 the .dynamic section. The DT_DEBUG entry is filled in by the
11932 dynamic linker and used by the debugger. */
11933 #define add_dynamic_entry(TAG, VAL) \
11934 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
11935
11936 if (info->executable)
11937 {
11938 if (!add_dynamic_entry (DT_DEBUG, 0))
11939 return FALSE;
11940 }
11941
11942 if (plt)
11943 {
11944 if ( !add_dynamic_entry (DT_PLTGOT, 0)
11945 || !add_dynamic_entry (DT_PLTRELSZ, 0)
11946 || !add_dynamic_entry (DT_PLTREL,
11947 htab->use_rel ? DT_REL : DT_RELA)
11948 || !add_dynamic_entry (DT_JMPREL, 0))
11949 return FALSE;
11950 }
11951
11952 if (relocs)
11953 {
11954 if (htab->use_rel)
11955 {
11956 if (!add_dynamic_entry (DT_REL, 0)
11957 || !add_dynamic_entry (DT_RELSZ, 0)
11958 || !add_dynamic_entry (DT_RELENT, RELOC_SIZE (htab)))
11959 return FALSE;
11960 }
11961 else
11962 {
11963 if (!add_dynamic_entry (DT_RELA, 0)
11964 || !add_dynamic_entry (DT_RELASZ, 0)
11965 || !add_dynamic_entry (DT_RELAENT, RELOC_SIZE (htab)))
11966 return FALSE;
11967 }
11968 }
11969
11970 /* If any dynamic relocs apply to a read-only section,
11971 then we need a DT_TEXTREL entry. */
11972 if ((info->flags & DF_TEXTREL) == 0)
11973 elf_link_hash_traverse (& htab->root, elf32_arm_readonly_dynrelocs,
11974 info);
11975
11976 if ((info->flags & DF_TEXTREL) != 0)
11977 {
11978 if (!add_dynamic_entry (DT_TEXTREL, 0))
11979 return FALSE;
11980 }
11981 if (htab->vxworks_p
11982 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
11983 return FALSE;
11984 }
11985 #undef add_dynamic_entry
11986
11987 return TRUE;
11988 }
11989
11990 /* Finish up dynamic symbol handling. We set the contents of various
11991 dynamic sections here. */
11992
11993 static bfd_boolean
11994 elf32_arm_finish_dynamic_symbol (bfd * output_bfd,
11995 struct bfd_link_info * info,
11996 struct elf_link_hash_entry * h,
11997 Elf_Internal_Sym * sym)
11998 {
11999 bfd * dynobj;
12000 struct elf32_arm_link_hash_table *htab;
12001 struct elf32_arm_link_hash_entry *eh;
12002
12003 dynobj = elf_hash_table (info)->dynobj;
12004 htab = elf32_arm_hash_table (info);
12005 eh = (struct elf32_arm_link_hash_entry *) h;
12006
12007 if (h->plt.offset != (bfd_vma) -1)
12008 {
12009 asection * splt;
12010 asection * srel;
12011 bfd_byte *loc;
12012 bfd_vma plt_index;
12013 Elf_Internal_Rela rel;
12014
12015 /* This symbol has an entry in the procedure linkage table. Set
12016 it up. */
12017
12018 BFD_ASSERT (h->dynindx != -1);
12019
12020 splt = bfd_get_section_by_name (dynobj, ".plt");
12021 srel = bfd_get_section_by_name (dynobj, RELOC_SECTION (htab, ".plt"));
12022 BFD_ASSERT (splt != NULL && srel != NULL);
12023
12024 /* Fill in the entry in the procedure linkage table. */
12025 if (htab->symbian_p)
12026 {
12027 put_arm_insn (htab, output_bfd,
12028 elf32_arm_symbian_plt_entry[0],
12029 splt->contents + h->plt.offset);
12030 bfd_put_32 (output_bfd,
12031 elf32_arm_symbian_plt_entry[1],
12032 splt->contents + h->plt.offset + 4);
12033
12034 /* Fill in the entry in the .rel.plt section. */
12035 rel.r_offset = (splt->output_section->vma
12036 + splt->output_offset
12037 + h->plt.offset + 4);
12038 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
12039
12040 /* Get the index in the procedure linkage table which
12041 corresponds to this symbol. This is the index of this symbol
12042 in all the symbols for which we are making plt entries. The
12043 first entry in the procedure linkage table is reserved. */
12044 plt_index = ((h->plt.offset - htab->plt_header_size)
12045 / htab->plt_entry_size);
12046 }
12047 else
12048 {
12049 bfd_vma got_offset, got_address, plt_address;
12050 bfd_vma got_displacement;
12051 asection * sgot;
12052 bfd_byte * ptr;
12053
12054 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
12055 BFD_ASSERT (sgot != NULL);
12056
12057 /* Get the offset into the .got.plt table of the entry that
12058 corresponds to this function. */
12059 got_offset = eh->plt_got_offset;
12060
12061 /* Get the index in the procedure linkage table which
12062 corresponds to this symbol. This is the index of this symbol
12063 in all the symbols for which we are making plt entries. The
12064 first three entries in .got.plt are reserved; after that
12065 symbols appear in the same order as in .plt. */
12066 plt_index = (got_offset - 12) / 4;
12067
12068 /* Calculate the address of the GOT entry. */
12069 got_address = (sgot->output_section->vma
12070 + sgot->output_offset
12071 + got_offset);
12072
12073 /* ...and the address of the PLT entry. */
12074 plt_address = (splt->output_section->vma
12075 + splt->output_offset
12076 + h->plt.offset);
12077
12078 ptr = htab->splt->contents + h->plt.offset;
12079 if (htab->vxworks_p && info->shared)
12080 {
12081 unsigned int i;
12082 bfd_vma val;
12083
12084 for (i = 0; i != htab->plt_entry_size / 4; i++, ptr += 4)
12085 {
12086 val = elf32_arm_vxworks_shared_plt_entry[i];
12087 if (i == 2)
12088 val |= got_address - sgot->output_section->vma;
12089 if (i == 5)
12090 val |= plt_index * RELOC_SIZE (htab);
12091 if (i == 2 || i == 5)
12092 bfd_put_32 (output_bfd, val, ptr);
12093 else
12094 put_arm_insn (htab, output_bfd, val, ptr);
12095 }
12096 }
12097 else if (htab->vxworks_p)
12098 {
12099 unsigned int i;
12100 bfd_vma val;
12101
12102 for (i = 0; i != htab->plt_entry_size / 4; i++, ptr += 4)
12103 {
12104 val = elf32_arm_vxworks_exec_plt_entry[i];
12105 if (i == 2)
12106 val |= got_address;
12107 if (i == 4)
12108 val |= 0xffffff & -((h->plt.offset + i * 4 + 8) >> 2);
12109 if (i == 5)
12110 val |= plt_index * RELOC_SIZE (htab);
12111 if (i == 2 || i == 5)
12112 bfd_put_32 (output_bfd, val, ptr);
12113 else
12114 put_arm_insn (htab, output_bfd, val, ptr);
12115 }
12116
12117 loc = (htab->srelplt2->contents
12118 + (plt_index * 2 + 1) * RELOC_SIZE (htab));
12119
12120 /* Create the .rela.plt.unloaded R_ARM_ABS32 relocation
12121 referencing the GOT for this PLT entry. */
12122 rel.r_offset = plt_address + 8;
12123 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
12124 rel.r_addend = got_offset;
12125 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
12126 loc += RELOC_SIZE (htab);
12127
12128 /* Create the R_ARM_ABS32 relocation referencing the
12129 beginning of the PLT for this GOT entry. */
12130 rel.r_offset = got_address;
12131 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_ARM_ABS32);
12132 rel.r_addend = 0;
12133 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
12134 }
12135 else
12136 {
12137 bfd_signed_vma thumb_refs;
12138 /* Calculate the displacement between the PLT slot and the
12139 entry in the GOT. The eight-byte offset accounts for the
12140 value produced by adding to pc in the first instruction
12141 of the PLT stub. */
12142 got_displacement = got_address - (plt_address + 8);
12143
12144 BFD_ASSERT ((got_displacement & 0xf0000000) == 0);
12145
12146 thumb_refs = eh->plt_thumb_refcount;
12147 if (!htab->use_blx)
12148 thumb_refs += eh->plt_maybe_thumb_refcount;
12149
12150 if (thumb_refs > 0)
12151 {
12152 put_thumb_insn (htab, output_bfd,
12153 elf32_arm_plt_thumb_stub[0], ptr - 4);
12154 put_thumb_insn (htab, output_bfd,
12155 elf32_arm_plt_thumb_stub[1], ptr - 2);
12156 }
12157
12158 put_arm_insn (htab, output_bfd,
12159 elf32_arm_plt_entry[0]
12160 | ((got_displacement & 0x0ff00000) >> 20),
12161 ptr + 0);
12162 put_arm_insn (htab, output_bfd,
12163 elf32_arm_plt_entry[1]
12164 | ((got_displacement & 0x000ff000) >> 12),
12165 ptr+ 4);
12166 put_arm_insn (htab, output_bfd,
12167 elf32_arm_plt_entry[2]
12168 | (got_displacement & 0x00000fff),
12169 ptr + 8);
12170 #ifdef FOUR_WORD_PLT
12171 bfd_put_32 (output_bfd, elf32_arm_plt_entry[3], ptr + 12);
12172 #endif
12173 }
12174
12175 /* Fill in the entry in the global offset table. */
12176 bfd_put_32 (output_bfd,
12177 (splt->output_section->vma
12178 + splt->output_offset),
12179 sgot->contents + got_offset);
12180
12181 /* Fill in the entry in the .rel(a).plt section. */
12182 rel.r_addend = 0;
12183 rel.r_offset = got_address;
12184 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
12185 }
12186
12187 loc = srel->contents + plt_index * RELOC_SIZE (htab);
12188 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
12189
12190 if (!h->def_regular)
12191 {
12192 /* Mark the symbol as undefined, rather than as defined in
12193 the .plt section. Leave the value alone. */
12194 sym->st_shndx = SHN_UNDEF;
12195 /* If the symbol is weak, we do need to clear the value.
12196 Otherwise, the PLT entry would provide a definition for
12197 the symbol even if the symbol wasn't defined anywhere,
12198 and so the symbol would never be NULL. */
12199 if (!h->ref_regular_nonweak)
12200 sym->st_value = 0;
12201 }
12202 }
12203
12204 if (h->got.offset != (bfd_vma) -1
12205 && (elf32_arm_hash_entry (h)->tls_type & GOT_TLS_GD) == 0
12206 && (elf32_arm_hash_entry (h)->tls_type & GOT_TLS_IE) == 0)
12207 {
12208 asection * sgot;
12209 asection * srel;
12210 Elf_Internal_Rela rel;
12211 bfd_byte *loc;
12212 bfd_vma offset;
12213
12214 /* This symbol has an entry in the global offset table. Set it
12215 up. */
12216 sgot = bfd_get_section_by_name (dynobj, ".got");
12217 srel = bfd_get_section_by_name (dynobj, RELOC_SECTION (htab, ".got"));
12218 BFD_ASSERT (sgot != NULL && srel != NULL);
12219
12220 offset = (h->got.offset & ~(bfd_vma) 1);
12221 rel.r_addend = 0;
12222 rel.r_offset = (sgot->output_section->vma
12223 + sgot->output_offset
12224 + offset);
12225
12226 /* If this is a static link, or it is a -Bsymbolic link and the
12227 symbol is defined locally or was forced to be local because
12228 of a version file, we just want to emit a RELATIVE reloc.
12229 The entry in the global offset table will already have been
12230 initialized in the relocate_section function. */
12231 if (info->shared
12232 && SYMBOL_REFERENCES_LOCAL (info, h))
12233 {
12234 BFD_ASSERT ((h->got.offset & 1) != 0);
12235 rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
12236 if (!htab->use_rel)
12237 {
12238 rel.r_addend = bfd_get_32 (output_bfd, sgot->contents + offset);
12239 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + offset);
12240 }
12241 }
12242 else
12243 {
12244 BFD_ASSERT ((h->got.offset & 1) == 0);
12245 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + offset);
12246 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
12247 }
12248
12249 loc = srel->contents + srel->reloc_count++ * RELOC_SIZE (htab);
12250 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
12251 }
12252
12253 if (h->needs_copy)
12254 {
12255 asection * s;
12256 Elf_Internal_Rela rel;
12257 bfd_byte *loc;
12258
12259 /* This symbol needs a copy reloc. Set it up. */
12260 BFD_ASSERT (h->dynindx != -1
12261 && (h->root.type == bfd_link_hash_defined
12262 || h->root.type == bfd_link_hash_defweak));
12263
12264 s = bfd_get_section_by_name (h->root.u.def.section->owner,
12265 RELOC_SECTION (htab, ".bss"));
12266 BFD_ASSERT (s != NULL);
12267
12268 rel.r_addend = 0;
12269 rel.r_offset = (h->root.u.def.value
12270 + h->root.u.def.section->output_section->vma
12271 + h->root.u.def.section->output_offset);
12272 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
12273 loc = s->contents + s->reloc_count++ * RELOC_SIZE (htab);
12274 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
12275 }
12276
12277 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. On VxWorks,
12278 the _GLOBAL_OFFSET_TABLE_ symbol is not absolute: it is relative
12279 to the ".got" section. */
12280 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
12281 || (!htab->vxworks_p && h == htab->root.hgot))
12282 sym->st_shndx = SHN_ABS;
12283
12284 return TRUE;
12285 }
12286
12287 /* Finish up the dynamic sections. */
12288
12289 static bfd_boolean
12290 elf32_arm_finish_dynamic_sections (bfd * output_bfd, struct bfd_link_info * info)
12291 {
12292 bfd * dynobj;
12293 asection * sgot;
12294 asection * sdyn;
12295
12296 dynobj = elf_hash_table (info)->dynobj;
12297
12298 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
12299 BFD_ASSERT (elf32_arm_hash_table (info)->symbian_p || sgot != NULL);
12300 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
12301
12302 if (elf_hash_table (info)->dynamic_sections_created)
12303 {
12304 asection *splt;
12305 Elf32_External_Dyn *dyncon, *dynconend;
12306 struct elf32_arm_link_hash_table *htab;
12307
12308 htab = elf32_arm_hash_table (info);
12309 splt = bfd_get_section_by_name (dynobj, ".plt");
12310 BFD_ASSERT (splt != NULL && sdyn != NULL);
12311
12312 dyncon = (Elf32_External_Dyn *) sdyn->contents;
12313 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
12314
12315 for (; dyncon < dynconend; dyncon++)
12316 {
12317 Elf_Internal_Dyn dyn;
12318 const char * name;
12319 asection * s;
12320
12321 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
12322
12323 switch (dyn.d_tag)
12324 {
12325 unsigned int type;
12326
12327 default:
12328 if (htab->vxworks_p
12329 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
12330 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
12331 break;
12332
12333 case DT_HASH:
12334 name = ".hash";
12335 goto get_vma_if_bpabi;
12336 case DT_STRTAB:
12337 name = ".dynstr";
12338 goto get_vma_if_bpabi;
12339 case DT_SYMTAB:
12340 name = ".dynsym";
12341 goto get_vma_if_bpabi;
12342 case DT_VERSYM:
12343 name = ".gnu.version";
12344 goto get_vma_if_bpabi;
12345 case DT_VERDEF:
12346 name = ".gnu.version_d";
12347 goto get_vma_if_bpabi;
12348 case DT_VERNEED:
12349 name = ".gnu.version_r";
12350 goto get_vma_if_bpabi;
12351
12352 case DT_PLTGOT:
12353 name = ".got";
12354 goto get_vma;
12355 case DT_JMPREL:
12356 name = RELOC_SECTION (htab, ".plt");
12357 get_vma:
12358 s = bfd_get_section_by_name (output_bfd, name);
12359 BFD_ASSERT (s != NULL);
12360 if (!htab->symbian_p)
12361 dyn.d_un.d_ptr = s->vma;
12362 else
12363 /* In the BPABI, tags in the PT_DYNAMIC section point
12364 at the file offset, not the memory address, for the
12365 convenience of the post linker. */
12366 dyn.d_un.d_ptr = s->filepos;
12367 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
12368 break;
12369
12370 get_vma_if_bpabi:
12371 if (htab->symbian_p)
12372 goto get_vma;
12373 break;
12374
12375 case DT_PLTRELSZ:
12376 s = bfd_get_section_by_name (output_bfd,
12377 RELOC_SECTION (htab, ".plt"));
12378 BFD_ASSERT (s != NULL);
12379 dyn.d_un.d_val = s->size;
12380 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
12381 break;
12382
12383 case DT_RELSZ:
12384 case DT_RELASZ:
12385 if (!htab->symbian_p)
12386 {
12387 /* My reading of the SVR4 ABI indicates that the
12388 procedure linkage table relocs (DT_JMPREL) should be
12389 included in the overall relocs (DT_REL). This is
12390 what Solaris does. However, UnixWare can not handle
12391 that case. Therefore, we override the DT_RELSZ entry
12392 here to make it not include the JMPREL relocs. Since
12393 the linker script arranges for .rel(a).plt to follow all
12394 other relocation sections, we don't have to worry
12395 about changing the DT_REL entry. */
12396 s = bfd_get_section_by_name (output_bfd,
12397 RELOC_SECTION (htab, ".plt"));
12398 if (s != NULL)
12399 dyn.d_un.d_val -= s->size;
12400 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
12401 break;
12402 }
12403 /* Fall through. */
12404
12405 case DT_REL:
12406 case DT_RELA:
12407 /* In the BPABI, the DT_REL tag must point at the file
12408 offset, not the VMA, of the first relocation
12409 section. So, we use code similar to that in
12410 elflink.c, but do not check for SHF_ALLOC on the
12411 relcoation section, since relocations sections are
12412 never allocated under the BPABI. The comments above
12413 about Unixware notwithstanding, we include all of the
12414 relocations here. */
12415 if (htab->symbian_p)
12416 {
12417 unsigned int i;
12418 type = ((dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
12419 ? SHT_REL : SHT_RELA);
12420 dyn.d_un.d_val = 0;
12421 for (i = 1; i < elf_numsections (output_bfd); i++)
12422 {
12423 Elf_Internal_Shdr *hdr
12424 = elf_elfsections (output_bfd)[i];
12425 if (hdr->sh_type == type)
12426 {
12427 if (dyn.d_tag == DT_RELSZ
12428 || dyn.d_tag == DT_RELASZ)
12429 dyn.d_un.d_val += hdr->sh_size;
12430 else if ((ufile_ptr) hdr->sh_offset
12431 <= dyn.d_un.d_val - 1)
12432 dyn.d_un.d_val = hdr->sh_offset;
12433 }
12434 }
12435 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
12436 }
12437 break;
12438
12439 /* Set the bottom bit of DT_INIT/FINI if the
12440 corresponding function is Thumb. */
12441 case DT_INIT:
12442 name = info->init_function;
12443 goto get_sym;
12444 case DT_FINI:
12445 name = info->fini_function;
12446 get_sym:
12447 /* If it wasn't set by elf_bfd_final_link
12448 then there is nothing to adjust. */
12449 if (dyn.d_un.d_val != 0)
12450 {
12451 struct elf_link_hash_entry * eh;
12452
12453 eh = elf_link_hash_lookup (elf_hash_table (info), name,
12454 FALSE, FALSE, TRUE);
12455 if (eh != NULL
12456 && ELF_ST_TYPE (eh->type) == STT_ARM_TFUNC)
12457 {
12458 dyn.d_un.d_val |= 1;
12459 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
12460 }
12461 }
12462 break;
12463 }
12464 }
12465
12466 /* Fill in the first entry in the procedure linkage table. */
12467 if (splt->size > 0 && elf32_arm_hash_table (info)->plt_header_size)
12468 {
12469 const bfd_vma *plt0_entry;
12470 bfd_vma got_address, plt_address, got_displacement;
12471
12472 /* Calculate the addresses of the GOT and PLT. */
12473 got_address = sgot->output_section->vma + sgot->output_offset;
12474 plt_address = splt->output_section->vma + splt->output_offset;
12475
12476 if (htab->vxworks_p)
12477 {
12478 /* The VxWorks GOT is relocated by the dynamic linker.
12479 Therefore, we must emit relocations rather than simply
12480 computing the values now. */
12481 Elf_Internal_Rela rel;
12482
12483 plt0_entry = elf32_arm_vxworks_exec_plt0_entry;
12484 put_arm_insn (htab, output_bfd, plt0_entry[0],
12485 splt->contents + 0);
12486 put_arm_insn (htab, output_bfd, plt0_entry[1],
12487 splt->contents + 4);
12488 put_arm_insn (htab, output_bfd, plt0_entry[2],
12489 splt->contents + 8);
12490 bfd_put_32 (output_bfd, got_address, splt->contents + 12);
12491
12492 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_. */
12493 rel.r_offset = plt_address + 12;
12494 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
12495 rel.r_addend = 0;
12496 SWAP_RELOC_OUT (htab) (output_bfd, &rel,
12497 htab->srelplt2->contents);
12498 }
12499 else
12500 {
12501 got_displacement = got_address - (plt_address + 16);
12502
12503 plt0_entry = elf32_arm_plt0_entry;
12504 put_arm_insn (htab, output_bfd, plt0_entry[0],
12505 splt->contents + 0);
12506 put_arm_insn (htab, output_bfd, plt0_entry[1],
12507 splt->contents + 4);
12508 put_arm_insn (htab, output_bfd, plt0_entry[2],
12509 splt->contents + 8);
12510 put_arm_insn (htab, output_bfd, plt0_entry[3],
12511 splt->contents + 12);
12512
12513 #ifdef FOUR_WORD_PLT
12514 /* The displacement value goes in the otherwise-unused
12515 last word of the second entry. */
12516 bfd_put_32 (output_bfd, got_displacement, splt->contents + 28);
12517 #else
12518 bfd_put_32 (output_bfd, got_displacement, splt->contents + 16);
12519 #endif
12520 }
12521 }
12522
12523 /* UnixWare sets the entsize of .plt to 4, although that doesn't
12524 really seem like the right value. */
12525 if (splt->output_section->owner == output_bfd)
12526 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
12527
12528 if (htab->vxworks_p && !info->shared && htab->splt->size > 0)
12529 {
12530 /* Correct the .rel(a).plt.unloaded relocations. They will have
12531 incorrect symbol indexes. */
12532 int num_plts;
12533 unsigned char *p;
12534
12535 num_plts = ((htab->splt->size - htab->plt_header_size)
12536 / htab->plt_entry_size);
12537 p = htab->srelplt2->contents + RELOC_SIZE (htab);
12538
12539 for (; num_plts; num_plts--)
12540 {
12541 Elf_Internal_Rela rel;
12542
12543 SWAP_RELOC_IN (htab) (output_bfd, p, &rel);
12544 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
12545 SWAP_RELOC_OUT (htab) (output_bfd, &rel, p);
12546 p += RELOC_SIZE (htab);
12547
12548 SWAP_RELOC_IN (htab) (output_bfd, p, &rel);
12549 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_ARM_ABS32);
12550 SWAP_RELOC_OUT (htab) (output_bfd, &rel, p);
12551 p += RELOC_SIZE (htab);
12552 }
12553 }
12554 }
12555
12556 /* Fill in the first three entries in the global offset table. */
12557 if (sgot)
12558 {
12559 if (sgot->size > 0)
12560 {
12561 if (sdyn == NULL)
12562 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
12563 else
12564 bfd_put_32 (output_bfd,
12565 sdyn->output_section->vma + sdyn->output_offset,
12566 sgot->contents);
12567 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
12568 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
12569 }
12570
12571 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
12572 }
12573
12574 return TRUE;
12575 }
12576
12577 static void
12578 elf32_arm_post_process_headers (bfd * abfd, struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
12579 {
12580 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
12581 struct elf32_arm_link_hash_table *globals;
12582
12583 i_ehdrp = elf_elfheader (abfd);
12584
12585 if (EF_ARM_EABI_VERSION (i_ehdrp->e_flags) == EF_ARM_EABI_UNKNOWN)
12586 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_ARM;
12587 else
12588 i_ehdrp->e_ident[EI_OSABI] = 0;
12589 i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
12590
12591 if (link_info)
12592 {
12593 globals = elf32_arm_hash_table (link_info);
12594 if (globals->byteswap_code)
12595 i_ehdrp->e_flags |= EF_ARM_BE8;
12596 }
12597 }
12598
12599 static enum elf_reloc_type_class
12600 elf32_arm_reloc_type_class (const Elf_Internal_Rela *rela)
12601 {
12602 switch ((int) ELF32_R_TYPE (rela->r_info))
12603 {
12604 case R_ARM_RELATIVE:
12605 return reloc_class_relative;
12606 case R_ARM_JUMP_SLOT:
12607 return reloc_class_plt;
12608 case R_ARM_COPY:
12609 return reloc_class_copy;
12610 default:
12611 return reloc_class_normal;
12612 }
12613 }
12614
12615 /* Set the right machine number for an Arm ELF file. */
12616
12617 static bfd_boolean
12618 elf32_arm_section_flags (flagword *flags, const Elf_Internal_Shdr *hdr)
12619 {
12620 if (hdr->sh_type == SHT_NOTE)
12621 *flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_CONTENTS;
12622
12623 return TRUE;
12624 }
12625
12626 static void
12627 elf32_arm_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED)
12628 {
12629 bfd_arm_update_notes (abfd, ARM_NOTE_SECTION);
12630 }
12631
12632 /* Return TRUE if this is an unwinding table entry. */
12633
12634 static bfd_boolean
12635 is_arm_elf_unwind_section_name (bfd * abfd ATTRIBUTE_UNUSED, const char * name)
12636 {
12637 return (CONST_STRNEQ (name, ELF_STRING_ARM_unwind)
12638 || CONST_STRNEQ (name, ELF_STRING_ARM_unwind_once));
12639 }
12640
12641
12642 /* Set the type and flags for an ARM section. We do this by
12643 the section name, which is a hack, but ought to work. */
12644
12645 static bfd_boolean
12646 elf32_arm_fake_sections (bfd * abfd, Elf_Internal_Shdr * hdr, asection * sec)
12647 {
12648 const char * name;
12649
12650 name = bfd_get_section_name (abfd, sec);
12651
12652 if (is_arm_elf_unwind_section_name (abfd, name))
12653 {
12654 hdr->sh_type = SHT_ARM_EXIDX;
12655 hdr->sh_flags |= SHF_LINK_ORDER;
12656 }
12657 return TRUE;
12658 }
12659
12660 /* Handle an ARM specific section when reading an object file. This is
12661 called when bfd_section_from_shdr finds a section with an unknown
12662 type. */
12663
12664 static bfd_boolean
12665 elf32_arm_section_from_shdr (bfd *abfd,
12666 Elf_Internal_Shdr * hdr,
12667 const char *name,
12668 int shindex)
12669 {
12670 /* There ought to be a place to keep ELF backend specific flags, but
12671 at the moment there isn't one. We just keep track of the
12672 sections by their name, instead. Fortunately, the ABI gives
12673 names for all the ARM specific sections, so we will probably get
12674 away with this. */
12675 switch (hdr->sh_type)
12676 {
12677 case SHT_ARM_EXIDX:
12678 case SHT_ARM_PREEMPTMAP:
12679 case SHT_ARM_ATTRIBUTES:
12680 break;
12681
12682 default:
12683 return FALSE;
12684 }
12685
12686 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
12687 return FALSE;
12688
12689 return TRUE;
12690 }
12691
12692 /* A structure used to record a list of sections, independently
12693 of the next and prev fields in the asection structure. */
12694 typedef struct section_list
12695 {
12696 asection * sec;
12697 struct section_list * next;
12698 struct section_list * prev;
12699 }
12700 section_list;
12701
12702 /* Unfortunately we need to keep a list of sections for which
12703 an _arm_elf_section_data structure has been allocated. This
12704 is because it is possible for functions like elf32_arm_write_section
12705 to be called on a section which has had an elf_data_structure
12706 allocated for it (and so the used_by_bfd field is valid) but
12707 for which the ARM extended version of this structure - the
12708 _arm_elf_section_data structure - has not been allocated. */
12709 static section_list * sections_with_arm_elf_section_data = NULL;
12710
12711 static void
12712 record_section_with_arm_elf_section_data (asection * sec)
12713 {
12714 struct section_list * entry;
12715
12716 entry = bfd_malloc (sizeof (* entry));
12717 if (entry == NULL)
12718 return;
12719 entry->sec = sec;
12720 entry->next = sections_with_arm_elf_section_data;
12721 entry->prev = NULL;
12722 if (entry->next != NULL)
12723 entry->next->prev = entry;
12724 sections_with_arm_elf_section_data = entry;
12725 }
12726
12727 static struct section_list *
12728 find_arm_elf_section_entry (asection * sec)
12729 {
12730 struct section_list * entry;
12731 static struct section_list * last_entry = NULL;
12732
12733 /* This is a short cut for the typical case where the sections are added
12734 to the sections_with_arm_elf_section_data list in forward order and
12735 then looked up here in backwards order. This makes a real difference
12736 to the ld-srec/sec64k.exp linker test. */
12737 entry = sections_with_arm_elf_section_data;
12738 if (last_entry != NULL)
12739 {
12740 if (last_entry->sec == sec)
12741 entry = last_entry;
12742 else if (last_entry->next != NULL
12743 && last_entry->next->sec == sec)
12744 entry = last_entry->next;
12745 }
12746
12747 for (; entry; entry = entry->next)
12748 if (entry->sec == sec)
12749 break;
12750
12751 if (entry)
12752 /* Record the entry prior to this one - it is the entry we are most
12753 likely to want to locate next time. Also this way if we have been
12754 called from unrecord_section_with_arm_elf_section_data() we will not
12755 be caching a pointer that is about to be freed. */
12756 last_entry = entry->prev;
12757
12758 return entry;
12759 }
12760
12761 static _arm_elf_section_data *
12762 get_arm_elf_section_data (asection * sec)
12763 {
12764 struct section_list * entry;
12765
12766 entry = find_arm_elf_section_entry (sec);
12767
12768 if (entry)
12769 return elf32_arm_section_data (entry->sec);
12770 else
12771 return NULL;
12772 }
12773
12774 static void
12775 unrecord_section_with_arm_elf_section_data (asection * sec)
12776 {
12777 struct section_list * entry;
12778
12779 entry = find_arm_elf_section_entry (sec);
12780
12781 if (entry)
12782 {
12783 if (entry->prev != NULL)
12784 entry->prev->next = entry->next;
12785 if (entry->next != NULL)
12786 entry->next->prev = entry->prev;
12787 if (entry == sections_with_arm_elf_section_data)
12788 sections_with_arm_elf_section_data = entry->next;
12789 free (entry);
12790 }
12791 }
12792
12793
12794 typedef struct
12795 {
12796 void *finfo;
12797 struct bfd_link_info *info;
12798 asection *sec;
12799 int sec_shndx;
12800 int (*func) (void *, const char *, Elf_Internal_Sym *,
12801 asection *, struct elf_link_hash_entry *);
12802 } output_arch_syminfo;
12803
12804 enum map_symbol_type
12805 {
12806 ARM_MAP_ARM,
12807 ARM_MAP_THUMB,
12808 ARM_MAP_DATA
12809 };
12810
12811
12812 /* Output a single mapping symbol. */
12813
12814 static bfd_boolean
12815 elf32_arm_output_map_sym (output_arch_syminfo *osi,
12816 enum map_symbol_type type,
12817 bfd_vma offset)
12818 {
12819 static const char *names[3] = {"$a", "$t", "$d"};
12820 struct elf32_arm_link_hash_table *htab;
12821 Elf_Internal_Sym sym;
12822
12823 htab = elf32_arm_hash_table (osi->info);
12824 sym.st_value = osi->sec->output_section->vma
12825 + osi->sec->output_offset
12826 + offset;
12827 sym.st_size = 0;
12828 sym.st_other = 0;
12829 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_NOTYPE);
12830 sym.st_shndx = osi->sec_shndx;
12831 return osi->func (osi->finfo, names[type], &sym, osi->sec, NULL) == 1;
12832 }
12833
12834
12835 /* Output mapping symbols for PLT entries associated with H. */
12836
12837 static bfd_boolean
12838 elf32_arm_output_plt_map (struct elf_link_hash_entry *h, void *inf)
12839 {
12840 output_arch_syminfo *osi = (output_arch_syminfo *) inf;
12841 struct elf32_arm_link_hash_table *htab;
12842 struct elf32_arm_link_hash_entry *eh;
12843 bfd_vma addr;
12844
12845 htab = elf32_arm_hash_table (osi->info);
12846
12847 if (h->root.type == bfd_link_hash_indirect)
12848 return TRUE;
12849
12850 if (h->root.type == bfd_link_hash_warning)
12851 /* When warning symbols are created, they **replace** the "real"
12852 entry in the hash table, thus we never get to see the real
12853 symbol in a hash traversal. So look at it now. */
12854 h = (struct elf_link_hash_entry *) h->root.u.i.link;
12855
12856 if (h->plt.offset == (bfd_vma) -1)
12857 return TRUE;
12858
12859 eh = (struct elf32_arm_link_hash_entry *) h;
12860 addr = h->plt.offset;
12861 if (htab->symbian_p)
12862 {
12863 if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr))
12864 return FALSE;
12865 if (!elf32_arm_output_map_sym (osi, ARM_MAP_DATA, addr + 4))
12866 return FALSE;
12867 }
12868 else if (htab->vxworks_p)
12869 {
12870 if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr))
12871 return FALSE;
12872 if (!elf32_arm_output_map_sym (osi, ARM_MAP_DATA, addr + 8))
12873 return FALSE;
12874 if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr + 12))
12875 return FALSE;
12876 if (!elf32_arm_output_map_sym (osi, ARM_MAP_DATA, addr + 20))
12877 return FALSE;
12878 }
12879 else
12880 {
12881 bfd_signed_vma thumb_refs;
12882
12883 thumb_refs = eh->plt_thumb_refcount;
12884 if (!htab->use_blx)
12885 thumb_refs += eh->plt_maybe_thumb_refcount;
12886
12887 if (thumb_refs > 0)
12888 {
12889 if (!elf32_arm_output_map_sym (osi, ARM_MAP_THUMB, addr - 4))
12890 return FALSE;
12891 }
12892 #ifdef FOUR_WORD_PLT
12893 if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr))
12894 return FALSE;
12895 if (!elf32_arm_output_map_sym (osi, ARM_MAP_DATA, addr + 12))
12896 return FALSE;
12897 #else
12898 /* A three-word PLT with no Thumb thunk contains only Arm code,
12899 so only need to output a mapping symbol for the first PLT entry and
12900 entries with thumb thunks. */
12901 if (thumb_refs > 0 || addr == 20)
12902 {
12903 if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr))
12904 return FALSE;
12905 }
12906 #endif
12907 }
12908
12909 return TRUE;
12910 }
12911
12912 /* Output a single local symbol for a generated stub. */
12913
12914 static bfd_boolean
12915 elf32_arm_output_stub_sym (output_arch_syminfo *osi, const char *name,
12916 bfd_vma offset, bfd_vma size)
12917 {
12918 struct elf32_arm_link_hash_table *htab;
12919 Elf_Internal_Sym sym;
12920
12921 htab = elf32_arm_hash_table (osi->info);
12922 sym.st_value = osi->sec->output_section->vma
12923 + osi->sec->output_offset
12924 + offset;
12925 sym.st_size = size;
12926 sym.st_other = 0;
12927 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
12928 sym.st_shndx = osi->sec_shndx;
12929 return osi->func (osi->finfo, name, &sym, osi->sec, NULL) == 1;
12930 }
12931
12932 static bfd_boolean
12933 arm_map_one_stub (struct bfd_hash_entry * gen_entry,
12934 void * in_arg)
12935 {
12936 struct elf32_arm_stub_hash_entry *stub_entry;
12937 struct bfd_link_info *info;
12938 struct elf32_arm_link_hash_table *htab;
12939 asection *stub_sec;
12940 bfd_vma addr;
12941 char *stub_name;
12942 output_arch_syminfo *osi;
12943 const insn_sequence *template;
12944 enum stub_insn_type prev_type;
12945 int size;
12946 int i;
12947 enum map_symbol_type sym_type;
12948
12949 /* Massage our args to the form they really have. */
12950 stub_entry = (struct elf32_arm_stub_hash_entry *) gen_entry;
12951 osi = (output_arch_syminfo *) in_arg;
12952
12953 info = osi->info;
12954
12955 htab = elf32_arm_hash_table (info);
12956 stub_sec = stub_entry->stub_sec;
12957
12958 /* Ensure this stub is attached to the current section being
12959 processed. */
12960 if (stub_sec != osi->sec)
12961 return TRUE;
12962
12963 addr = (bfd_vma) stub_entry->stub_offset;
12964 stub_name = stub_entry->output_name;
12965
12966 template = stub_entry->stub_template;
12967 switch (template[0].type)
12968 {
12969 case ARM_TYPE:
12970 if (!elf32_arm_output_stub_sym (osi, stub_name, addr, stub_entry->stub_size))
12971 return FALSE;
12972 break;
12973 case THUMB16_TYPE:
12974 case THUMB32_TYPE:
12975 if (!elf32_arm_output_stub_sym (osi, stub_name, addr | 1,
12976 stub_entry->stub_size))
12977 return FALSE;
12978 break;
12979 default:
12980 BFD_FAIL ();
12981 return 0;
12982 }
12983
12984 prev_type = DATA_TYPE;
12985 size = 0;
12986 for (i = 0; i < stub_entry->stub_template_size; i++)
12987 {
12988 switch (template[i].type)
12989 {
12990 case ARM_TYPE:
12991 sym_type = ARM_MAP_ARM;
12992 break;
12993
12994 case THUMB16_TYPE:
12995 case THUMB32_TYPE:
12996 sym_type = ARM_MAP_THUMB;
12997 break;
12998
12999 case DATA_TYPE:
13000 sym_type = ARM_MAP_DATA;
13001 break;
13002
13003 default:
13004 BFD_FAIL ();
13005 return FALSE;
13006 }
13007
13008 if (template[i].type != prev_type)
13009 {
13010 prev_type = template[i].type;
13011 if (!elf32_arm_output_map_sym (osi, sym_type, addr + size))
13012 return FALSE;
13013 }
13014
13015 switch (template[i].type)
13016 {
13017 case ARM_TYPE:
13018 case THUMB32_TYPE:
13019 size += 4;
13020 break;
13021
13022 case THUMB16_TYPE:
13023 size += 2;
13024 break;
13025
13026 case DATA_TYPE:
13027 size += 4;
13028 break;
13029
13030 default:
13031 BFD_FAIL ();
13032 return FALSE;
13033 }
13034 }
13035
13036 return TRUE;
13037 }
13038
13039 /* Output mapping symbols for linker generated sections. */
13040
13041 static bfd_boolean
13042 elf32_arm_output_arch_local_syms (bfd *output_bfd,
13043 struct bfd_link_info *info,
13044 void *finfo,
13045 int (*func) (void *, const char *,
13046 Elf_Internal_Sym *,
13047 asection *,
13048 struct elf_link_hash_entry *))
13049 {
13050 output_arch_syminfo osi;
13051 struct elf32_arm_link_hash_table *htab;
13052 bfd_vma offset;
13053 bfd_size_type size;
13054
13055 htab = elf32_arm_hash_table (info);
13056 check_use_blx (htab);
13057
13058 osi.finfo = finfo;
13059 osi.info = info;
13060 osi.func = func;
13061
13062 /* ARM->Thumb glue. */
13063 if (htab->arm_glue_size > 0)
13064 {
13065 osi.sec = bfd_get_section_by_name (htab->bfd_of_glue_owner,
13066 ARM2THUMB_GLUE_SECTION_NAME);
13067
13068 osi.sec_shndx = _bfd_elf_section_from_bfd_section
13069 (output_bfd, osi.sec->output_section);
13070 if (info->shared || htab->root.is_relocatable_executable
13071 || htab->pic_veneer)
13072 size = ARM2THUMB_PIC_GLUE_SIZE;
13073 else if (htab->use_blx)
13074 size = ARM2THUMB_V5_STATIC_GLUE_SIZE;
13075 else
13076 size = ARM2THUMB_STATIC_GLUE_SIZE;
13077
13078 for (offset = 0; offset < htab->arm_glue_size; offset += size)
13079 {
13080 elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, offset);
13081 elf32_arm_output_map_sym (&osi, ARM_MAP_DATA, offset + size - 4);
13082 }
13083 }
13084
13085 /* Thumb->ARM glue. */
13086 if (htab->thumb_glue_size > 0)
13087 {
13088 osi.sec = bfd_get_section_by_name (htab->bfd_of_glue_owner,
13089 THUMB2ARM_GLUE_SECTION_NAME);
13090
13091 osi.sec_shndx = _bfd_elf_section_from_bfd_section
13092 (output_bfd, osi.sec->output_section);
13093 size = THUMB2ARM_GLUE_SIZE;
13094
13095 for (offset = 0; offset < htab->thumb_glue_size; offset += size)
13096 {
13097 elf32_arm_output_map_sym (&osi, ARM_MAP_THUMB, offset);
13098 elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, offset + 4);
13099 }
13100 }
13101
13102 /* ARMv4 BX veneers. */
13103 if (htab->bx_glue_size > 0)
13104 {
13105 osi.sec = bfd_get_section_by_name (htab->bfd_of_glue_owner,
13106 ARM_BX_GLUE_SECTION_NAME);
13107
13108 osi.sec_shndx = _bfd_elf_section_from_bfd_section
13109 (output_bfd, osi.sec->output_section);
13110
13111 elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, 0);
13112 }
13113
13114 /* Long calls stubs. */
13115 if (htab->stub_bfd && htab->stub_bfd->sections)
13116 {
13117 asection* stub_sec;
13118
13119 for (stub_sec = htab->stub_bfd->sections;
13120 stub_sec != NULL;
13121 stub_sec = stub_sec->next)
13122 {
13123 /* Ignore non-stub sections. */
13124 if (!strstr (stub_sec->name, STUB_SUFFIX))
13125 continue;
13126
13127 osi.sec = stub_sec;
13128
13129 osi.sec_shndx = _bfd_elf_section_from_bfd_section
13130 (output_bfd, osi.sec->output_section);
13131
13132 bfd_hash_traverse (&htab->stub_hash_table, arm_map_one_stub, &osi);
13133 }
13134 }
13135
13136 /* Finally, output mapping symbols for the PLT. */
13137 if (!htab->splt || htab->splt->size == 0)
13138 return TRUE;
13139
13140 osi.sec_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
13141 htab->splt->output_section);
13142 osi.sec = htab->splt;
13143 /* Output mapping symbols for the plt header. SymbianOS does not have a
13144 plt header. */
13145 if (htab->vxworks_p)
13146 {
13147 /* VxWorks shared libraries have no PLT header. */
13148 if (!info->shared)
13149 {
13150 if (!elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, 0))
13151 return FALSE;
13152 if (!elf32_arm_output_map_sym (&osi, ARM_MAP_DATA, 12))
13153 return FALSE;
13154 }
13155 }
13156 else if (!htab->symbian_p)
13157 {
13158 if (!elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, 0))
13159 return FALSE;
13160 #ifndef FOUR_WORD_PLT
13161 if (!elf32_arm_output_map_sym (&osi, ARM_MAP_DATA, 16))
13162 return FALSE;
13163 #endif
13164 }
13165
13166 elf_link_hash_traverse (&htab->root, elf32_arm_output_plt_map, (void *) &osi);
13167 return TRUE;
13168 }
13169
13170 /* Allocate target specific section data. */
13171
13172 static bfd_boolean
13173 elf32_arm_new_section_hook (bfd *abfd, asection *sec)
13174 {
13175 if (!sec->used_by_bfd)
13176 {
13177 _arm_elf_section_data *sdata;
13178 bfd_size_type amt = sizeof (*sdata);
13179
13180 sdata = bfd_zalloc (abfd, amt);
13181 if (sdata == NULL)
13182 return FALSE;
13183 sec->used_by_bfd = sdata;
13184 }
13185
13186 record_section_with_arm_elf_section_data (sec);
13187
13188 return _bfd_elf_new_section_hook (abfd, sec);
13189 }
13190
13191
13192 /* Used to order a list of mapping symbols by address. */
13193
13194 static int
13195 elf32_arm_compare_mapping (const void * a, const void * b)
13196 {
13197 const elf32_arm_section_map *amap = (const elf32_arm_section_map *) a;
13198 const elf32_arm_section_map *bmap = (const elf32_arm_section_map *) b;
13199
13200 if (amap->vma > bmap->vma)
13201 return 1;
13202 else if (amap->vma < bmap->vma)
13203 return -1;
13204 else if (amap->type > bmap->type)
13205 /* Ensure results do not depend on the host qsort for objects with
13206 multiple mapping symbols at the same address by sorting on type
13207 after vma. */
13208 return 1;
13209 else if (amap->type < bmap->type)
13210 return -1;
13211 else
13212 return 0;
13213 }
13214
13215 /* Add OFFSET to lower 31 bits of ADDR, leaving other bits unmodified. */
13216
13217 static unsigned long
13218 offset_prel31 (unsigned long addr, bfd_vma offset)
13219 {
13220 return (addr & ~0x7ffffffful) | ((addr + offset) & 0x7ffffffful);
13221 }
13222
13223 /* Copy an .ARM.exidx table entry, adding OFFSET to (applied) PREL31
13224 relocations. */
13225
13226 static void
13227 copy_exidx_entry (bfd *output_bfd, bfd_byte *to, bfd_byte *from, bfd_vma offset)
13228 {
13229 unsigned long first_word = bfd_get_32 (output_bfd, from);
13230 unsigned long second_word = bfd_get_32 (output_bfd, from + 4);
13231
13232 /* High bit of first word is supposed to be zero. */
13233 if ((first_word & 0x80000000ul) == 0)
13234 first_word = offset_prel31 (first_word, offset);
13235
13236 /* If the high bit of the first word is clear, and the bit pattern is not 0x1
13237 (EXIDX_CANTUNWIND), this is an offset to an .ARM.extab entry. */
13238 if ((second_word != 0x1) && ((second_word & 0x80000000ul) == 0))
13239 second_word = offset_prel31 (second_word, offset);
13240
13241 bfd_put_32 (output_bfd, first_word, to);
13242 bfd_put_32 (output_bfd, second_word, to + 4);
13243 }
13244
13245 /* Data for make_branch_to_a8_stub(). */
13246
13247 struct a8_branch_to_stub_data {
13248 asection *writing_section;
13249 bfd_byte *contents;
13250 };
13251
13252
13253 /* Helper to insert branches to Cortex-A8 erratum stubs in the right
13254 places for a particular section. */
13255
13256 static bfd_boolean
13257 make_branch_to_a8_stub (struct bfd_hash_entry *gen_entry,
13258 void *in_arg)
13259 {
13260 struct elf32_arm_stub_hash_entry *stub_entry;
13261 struct a8_branch_to_stub_data *data;
13262 bfd_byte *contents;
13263 unsigned long branch_insn;
13264 bfd_vma veneered_insn_loc, veneer_entry_loc;
13265 bfd_signed_vma branch_offset;
13266 bfd *abfd;
13267 unsigned int index;
13268
13269 stub_entry = (struct elf32_arm_stub_hash_entry *) gen_entry;
13270 data = (struct a8_branch_to_stub_data *) in_arg;
13271
13272 if (stub_entry->target_section != data->writing_section
13273 || stub_entry->stub_type < arm_stub_a8_veneer_b_cond)
13274 return TRUE;
13275
13276 contents = data->contents;
13277
13278 veneered_insn_loc = stub_entry->target_section->output_section->vma
13279 + stub_entry->target_section->output_offset
13280 + stub_entry->target_value;
13281
13282 veneer_entry_loc = stub_entry->stub_sec->output_section->vma
13283 + stub_entry->stub_sec->output_offset
13284 + stub_entry->stub_offset;
13285
13286 if (stub_entry->stub_type == arm_stub_a8_veneer_blx)
13287 veneered_insn_loc &= ~3u;
13288
13289 branch_offset = veneer_entry_loc - veneered_insn_loc - 4;
13290
13291 abfd = stub_entry->target_section->owner;
13292 index = stub_entry->target_value;
13293
13294 /* We attempt to avoid this condition by setting stubs_always_after_branch
13295 in elf32_arm_size_stubs if we've enabled the Cortex-A8 erratum workaround.
13296 This check is just to be on the safe side... */
13297 if ((veneered_insn_loc & ~0xfff) == (veneer_entry_loc & ~0xfff))
13298 {
13299 (*_bfd_error_handler) (_("%B: error: Cortex-A8 erratum stub is "
13300 "allocated in unsafe location"), abfd);
13301 return FALSE;
13302 }
13303
13304 switch (stub_entry->stub_type)
13305 {
13306 case arm_stub_a8_veneer_b:
13307 case arm_stub_a8_veneer_b_cond:
13308 branch_insn = 0xf0009000;
13309 goto jump24;
13310
13311 case arm_stub_a8_veneer_blx:
13312 branch_insn = 0xf000e800;
13313 goto jump24;
13314
13315 case arm_stub_a8_veneer_bl:
13316 {
13317 unsigned int i1, j1, i2, j2, s;
13318
13319 branch_insn = 0xf000d000;
13320
13321 jump24:
13322 if (branch_offset < -16777216 || branch_offset > 16777214)
13323 {
13324 /* There's not much we can do apart from complain if this
13325 happens. */
13326 (*_bfd_error_handler) (_("%B: error: Cortex-A8 erratum stub out "
13327 "of range (input file too large)"), abfd);
13328 return FALSE;
13329 }
13330
13331 /* i1 = not(j1 eor s), so:
13332 not i1 = j1 eor s
13333 j1 = (not i1) eor s. */
13334
13335 branch_insn |= (branch_offset >> 1) & 0x7ff;
13336 branch_insn |= ((branch_offset >> 12) & 0x3ff) << 16;
13337 i2 = (branch_offset >> 22) & 1;
13338 i1 = (branch_offset >> 23) & 1;
13339 s = (branch_offset >> 24) & 1;
13340 j1 = (!i1) ^ s;
13341 j2 = (!i2) ^ s;
13342 branch_insn |= j2 << 11;
13343 branch_insn |= j1 << 13;
13344 branch_insn |= s << 26;
13345 }
13346 break;
13347
13348 default:
13349 BFD_FAIL ();
13350 return FALSE;
13351 }
13352
13353 bfd_put_16 (abfd, (branch_insn >> 16) & 0xffff, &contents[index]);
13354 bfd_put_16 (abfd, branch_insn & 0xffff, &contents[index + 2]);
13355
13356 return TRUE;
13357 }
13358
13359 /* Do code byteswapping. Return FALSE afterwards so that the section is
13360 written out as normal. */
13361
13362 static bfd_boolean
13363 elf32_arm_write_section (bfd *output_bfd,
13364 struct bfd_link_info *link_info,
13365 asection *sec,
13366 bfd_byte *contents)
13367 {
13368 unsigned int mapcount, errcount;
13369 _arm_elf_section_data *arm_data;
13370 struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (link_info);
13371 elf32_arm_section_map *map;
13372 elf32_vfp11_erratum_list *errnode;
13373 bfd_vma ptr;
13374 bfd_vma end;
13375 bfd_vma offset = sec->output_section->vma + sec->output_offset;
13376 bfd_byte tmp;
13377 unsigned int i;
13378
13379 /* If this section has not been allocated an _arm_elf_section_data
13380 structure then we cannot record anything. */
13381 arm_data = get_arm_elf_section_data (sec);
13382 if (arm_data == NULL)
13383 return FALSE;
13384
13385 mapcount = arm_data->mapcount;
13386 map = arm_data->map;
13387 errcount = arm_data->erratumcount;
13388
13389 if (errcount != 0)
13390 {
13391 unsigned int endianflip = bfd_big_endian (output_bfd) ? 3 : 0;
13392
13393 for (errnode = arm_data->erratumlist; errnode != 0;
13394 errnode = errnode->next)
13395 {
13396 bfd_vma index = errnode->vma - offset;
13397
13398 switch (errnode->type)
13399 {
13400 case VFP11_ERRATUM_BRANCH_TO_ARM_VENEER:
13401 {
13402 bfd_vma branch_to_veneer;
13403 /* Original condition code of instruction, plus bit mask for
13404 ARM B instruction. */
13405 unsigned int insn = (errnode->u.b.vfp_insn & 0xf0000000)
13406 | 0x0a000000;
13407
13408 /* The instruction is before the label. */
13409 index -= 4;
13410
13411 /* Above offset included in -4 below. */
13412 branch_to_veneer = errnode->u.b.veneer->vma
13413 - errnode->vma - 4;
13414
13415 if ((signed) branch_to_veneer < -(1 << 25)
13416 || (signed) branch_to_veneer >= (1 << 25))
13417 (*_bfd_error_handler) (_("%B: error: VFP11 veneer out of "
13418 "range"), output_bfd);
13419
13420 insn |= (branch_to_veneer >> 2) & 0xffffff;
13421 contents[endianflip ^ index] = insn & 0xff;
13422 contents[endianflip ^ (index + 1)] = (insn >> 8) & 0xff;
13423 contents[endianflip ^ (index + 2)] = (insn >> 16) & 0xff;
13424 contents[endianflip ^ (index + 3)] = (insn >> 24) & 0xff;
13425 }
13426 break;
13427
13428 case VFP11_ERRATUM_ARM_VENEER:
13429 {
13430 bfd_vma branch_from_veneer;
13431 unsigned int insn;
13432
13433 /* Take size of veneer into account. */
13434 branch_from_veneer = errnode->u.v.branch->vma
13435 - errnode->vma - 12;
13436
13437 if ((signed) branch_from_veneer < -(1 << 25)
13438 || (signed) branch_from_veneer >= (1 << 25))
13439 (*_bfd_error_handler) (_("%B: error: VFP11 veneer out of "
13440 "range"), output_bfd);
13441
13442 /* Original instruction. */
13443 insn = errnode->u.v.branch->u.b.vfp_insn;
13444 contents[endianflip ^ index] = insn & 0xff;
13445 contents[endianflip ^ (index + 1)] = (insn >> 8) & 0xff;
13446 contents[endianflip ^ (index + 2)] = (insn >> 16) & 0xff;
13447 contents[endianflip ^ (index + 3)] = (insn >> 24) & 0xff;
13448
13449 /* Branch back to insn after original insn. */
13450 insn = 0xea000000 | ((branch_from_veneer >> 2) & 0xffffff);
13451 contents[endianflip ^ (index + 4)] = insn & 0xff;
13452 contents[endianflip ^ (index + 5)] = (insn >> 8) & 0xff;
13453 contents[endianflip ^ (index + 6)] = (insn >> 16) & 0xff;
13454 contents[endianflip ^ (index + 7)] = (insn >> 24) & 0xff;
13455 }
13456 break;
13457
13458 default:
13459 abort ();
13460 }
13461 }
13462 }
13463
13464 if (arm_data->elf.this_hdr.sh_type == SHT_ARM_EXIDX)
13465 {
13466 arm_unwind_table_edit *edit_node
13467 = arm_data->u.exidx.unwind_edit_list;
13468 /* Now, sec->size is the size of the section we will write. The original
13469 size (before we merged duplicate entries and inserted EXIDX_CANTUNWIND
13470 markers) was sec->rawsize. (This isn't the case if we perform no
13471 edits, then rawsize will be zero and we should use size). */
13472 bfd_byte *edited_contents = bfd_malloc (sec->size);
13473 unsigned int input_size = sec->rawsize ? sec->rawsize : sec->size;
13474 unsigned int in_index, out_index;
13475 bfd_vma add_to_offsets = 0;
13476
13477 for (in_index = 0, out_index = 0; in_index * 8 < input_size || edit_node;)
13478 {
13479 if (edit_node)
13480 {
13481 unsigned int edit_index = edit_node->index;
13482
13483 if (in_index < edit_index && in_index * 8 < input_size)
13484 {
13485 copy_exidx_entry (output_bfd, edited_contents + out_index * 8,
13486 contents + in_index * 8, add_to_offsets);
13487 out_index++;
13488 in_index++;
13489 }
13490 else if (in_index == edit_index
13491 || (in_index * 8 >= input_size
13492 && edit_index == UINT_MAX))
13493 {
13494 switch (edit_node->type)
13495 {
13496 case DELETE_EXIDX_ENTRY:
13497 in_index++;
13498 add_to_offsets += 8;
13499 break;
13500
13501 case INSERT_EXIDX_CANTUNWIND_AT_END:
13502 {
13503 asection *text_sec = edit_node->linked_section;
13504 bfd_vma text_offset = text_sec->output_section->vma
13505 + text_sec->output_offset
13506 + text_sec->size;
13507 bfd_vma exidx_offset = offset + out_index * 8;
13508 unsigned long prel31_offset;
13509
13510 /* Note: this is meant to be equivalent to an
13511 R_ARM_PREL31 relocation. These synthetic
13512 EXIDX_CANTUNWIND markers are not relocated by the
13513 usual BFD method. */
13514 prel31_offset = (text_offset - exidx_offset)
13515 & 0x7ffffffful;
13516
13517 /* First address we can't unwind. */
13518 bfd_put_32 (output_bfd, prel31_offset,
13519 &edited_contents[out_index * 8]);
13520
13521 /* Code for EXIDX_CANTUNWIND. */
13522 bfd_put_32 (output_bfd, 0x1,
13523 &edited_contents[out_index * 8 + 4]);
13524
13525 out_index++;
13526 add_to_offsets -= 8;
13527 }
13528 break;
13529 }
13530
13531 edit_node = edit_node->next;
13532 }
13533 }
13534 else
13535 {
13536 /* No more edits, copy remaining entries verbatim. */
13537 copy_exidx_entry (output_bfd, edited_contents + out_index * 8,
13538 contents + in_index * 8, add_to_offsets);
13539 out_index++;
13540 in_index++;
13541 }
13542 }
13543
13544 if (!(sec->flags & SEC_EXCLUDE) && !(sec->flags & SEC_NEVER_LOAD))
13545 bfd_set_section_contents (output_bfd, sec->output_section,
13546 edited_contents,
13547 (file_ptr) sec->output_offset, sec->size);
13548
13549 return TRUE;
13550 }
13551
13552 /* Fix code to point to Cortex-A8 erratum stubs. */
13553 if (globals->fix_cortex_a8)
13554 {
13555 struct a8_branch_to_stub_data data;
13556
13557 data.writing_section = sec;
13558 data.contents = contents;
13559
13560 bfd_hash_traverse (&globals->stub_hash_table, make_branch_to_a8_stub,
13561 &data);
13562 }
13563
13564 if (mapcount == 0)
13565 return FALSE;
13566
13567 if (globals->byteswap_code)
13568 {
13569 qsort (map, mapcount, sizeof (* map), elf32_arm_compare_mapping);
13570
13571 ptr = map[0].vma;
13572 for (i = 0; i < mapcount; i++)
13573 {
13574 if (i == mapcount - 1)
13575 end = sec->size;
13576 else
13577 end = map[i + 1].vma;
13578
13579 switch (map[i].type)
13580 {
13581 case 'a':
13582 /* Byte swap code words. */
13583 while (ptr + 3 < end)
13584 {
13585 tmp = contents[ptr];
13586 contents[ptr] = contents[ptr + 3];
13587 contents[ptr + 3] = tmp;
13588 tmp = contents[ptr + 1];
13589 contents[ptr + 1] = contents[ptr + 2];
13590 contents[ptr + 2] = tmp;
13591 ptr += 4;
13592 }
13593 break;
13594
13595 case 't':
13596 /* Byte swap code halfwords. */
13597 while (ptr + 1 < end)
13598 {
13599 tmp = contents[ptr];
13600 contents[ptr] = contents[ptr + 1];
13601 contents[ptr + 1] = tmp;
13602 ptr += 2;
13603 }
13604 break;
13605
13606 case 'd':
13607 /* Leave data alone. */
13608 break;
13609 }
13610 ptr = end;
13611 }
13612 }
13613
13614 free (map);
13615 arm_data->mapcount = 0;
13616 arm_data->mapsize = 0;
13617 arm_data->map = NULL;
13618 unrecord_section_with_arm_elf_section_data (sec);
13619
13620 return FALSE;
13621 }
13622
13623 static void
13624 unrecord_section_via_map_over_sections (bfd * abfd ATTRIBUTE_UNUSED,
13625 asection * sec,
13626 void * ignore ATTRIBUTE_UNUSED)
13627 {
13628 unrecord_section_with_arm_elf_section_data (sec);
13629 }
13630
13631 static bfd_boolean
13632 elf32_arm_close_and_cleanup (bfd * abfd)
13633 {
13634 if (abfd->sections)
13635 bfd_map_over_sections (abfd,
13636 unrecord_section_via_map_over_sections,
13637 NULL);
13638
13639 return _bfd_elf_close_and_cleanup (abfd);
13640 }
13641
13642 static bfd_boolean
13643 elf32_arm_bfd_free_cached_info (bfd * abfd)
13644 {
13645 if (abfd->sections)
13646 bfd_map_over_sections (abfd,
13647 unrecord_section_via_map_over_sections,
13648 NULL);
13649
13650 return _bfd_free_cached_info (abfd);
13651 }
13652
13653 /* Display STT_ARM_TFUNC symbols as functions. */
13654
13655 static void
13656 elf32_arm_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
13657 asymbol *asym)
13658 {
13659 elf_symbol_type *elfsym = (elf_symbol_type *) asym;
13660
13661 if (ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_ARM_TFUNC)
13662 elfsym->symbol.flags |= BSF_FUNCTION;
13663 }
13664
13665
13666 /* Mangle thumb function symbols as we read them in. */
13667
13668 static bfd_boolean
13669 elf32_arm_swap_symbol_in (bfd * abfd,
13670 const void *psrc,
13671 const void *pshn,
13672 Elf_Internal_Sym *dst)
13673 {
13674 if (!bfd_elf32_swap_symbol_in (abfd, psrc, pshn, dst))
13675 return FALSE;
13676
13677 /* New EABI objects mark thumb function symbols by setting the low bit of
13678 the address. Turn these into STT_ARM_TFUNC. */
13679 if ((ELF_ST_TYPE (dst->st_info) == STT_FUNC)
13680 && (dst->st_value & 1))
13681 {
13682 dst->st_info = ELF_ST_INFO (ELF_ST_BIND (dst->st_info), STT_ARM_TFUNC);
13683 dst->st_value &= ~(bfd_vma) 1;
13684 }
13685 return TRUE;
13686 }
13687
13688
13689 /* Mangle thumb function symbols as we write them out. */
13690
13691 static void
13692 elf32_arm_swap_symbol_out (bfd *abfd,
13693 const Elf_Internal_Sym *src,
13694 void *cdst,
13695 void *shndx)
13696 {
13697 Elf_Internal_Sym newsym;
13698
13699 /* We convert STT_ARM_TFUNC symbols into STT_FUNC with the low bit
13700 of the address set, as per the new EABI. We do this unconditionally
13701 because objcopy does not set the elf header flags until after
13702 it writes out the symbol table. */
13703 if (ELF_ST_TYPE (src->st_info) == STT_ARM_TFUNC)
13704 {
13705 newsym = *src;
13706 newsym.st_info = ELF_ST_INFO (ELF_ST_BIND (src->st_info), STT_FUNC);
13707 if (newsym.st_shndx != SHN_UNDEF)
13708 {
13709 /* Do this only for defined symbols. At link type, the static
13710 linker will simulate the work of dynamic linker of resolving
13711 symbols and will carry over the thumbness of found symbols to
13712 the output symbol table. It's not clear how it happens, but
13713 the thumbness of undefined symbols can well be different at
13714 runtime, and writing '1' for them will be confusing for users
13715 and possibly for dynamic linker itself.
13716 */
13717 newsym.st_value |= 1;
13718 }
13719
13720 src = &newsym;
13721 }
13722 bfd_elf32_swap_symbol_out (abfd, src, cdst, shndx);
13723 }
13724
13725 /* Add the PT_ARM_EXIDX program header. */
13726
13727 static bfd_boolean
13728 elf32_arm_modify_segment_map (bfd *abfd,
13729 struct bfd_link_info *info ATTRIBUTE_UNUSED)
13730 {
13731 struct elf_segment_map *m;
13732 asection *sec;
13733
13734 sec = bfd_get_section_by_name (abfd, ".ARM.exidx");
13735 if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
13736 {
13737 /* If there is already a PT_ARM_EXIDX header, then we do not
13738 want to add another one. This situation arises when running
13739 "strip"; the input binary already has the header. */
13740 m = elf_tdata (abfd)->segment_map;
13741 while (m && m->p_type != PT_ARM_EXIDX)
13742 m = m->next;
13743 if (!m)
13744 {
13745 m = bfd_zalloc (abfd, sizeof (struct elf_segment_map));
13746 if (m == NULL)
13747 return FALSE;
13748 m->p_type = PT_ARM_EXIDX;
13749 m->count = 1;
13750 m->sections[0] = sec;
13751
13752 m->next = elf_tdata (abfd)->segment_map;
13753 elf_tdata (abfd)->segment_map = m;
13754 }
13755 }
13756
13757 return TRUE;
13758 }
13759
13760 /* We may add a PT_ARM_EXIDX program header. */
13761
13762 static int
13763 elf32_arm_additional_program_headers (bfd *abfd,
13764 struct bfd_link_info *info ATTRIBUTE_UNUSED)
13765 {
13766 asection *sec;
13767
13768 sec = bfd_get_section_by_name (abfd, ".ARM.exidx");
13769 if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
13770 return 1;
13771 else
13772 return 0;
13773 }
13774
13775 /* We have two function types: STT_FUNC and STT_ARM_TFUNC. */
13776
13777 static bfd_boolean
13778 elf32_arm_is_function_type (unsigned int type)
13779 {
13780 return (type == STT_FUNC) || (type == STT_ARM_TFUNC);
13781 }
13782
13783 /* We use this to override swap_symbol_in and swap_symbol_out. */
13784 const struct elf_size_info elf32_arm_size_info =
13785 {
13786 sizeof (Elf32_External_Ehdr),
13787 sizeof (Elf32_External_Phdr),
13788 sizeof (Elf32_External_Shdr),
13789 sizeof (Elf32_External_Rel),
13790 sizeof (Elf32_External_Rela),
13791 sizeof (Elf32_External_Sym),
13792 sizeof (Elf32_External_Dyn),
13793 sizeof (Elf_External_Note),
13794 4,
13795 1,
13796 32, 2,
13797 ELFCLASS32, EV_CURRENT,
13798 bfd_elf32_write_out_phdrs,
13799 bfd_elf32_write_shdrs_and_ehdr,
13800 bfd_elf32_checksum_contents,
13801 bfd_elf32_write_relocs,
13802 elf32_arm_swap_symbol_in,
13803 elf32_arm_swap_symbol_out,
13804 bfd_elf32_slurp_reloc_table,
13805 bfd_elf32_slurp_symbol_table,
13806 bfd_elf32_swap_dyn_in,
13807 bfd_elf32_swap_dyn_out,
13808 bfd_elf32_swap_reloc_in,
13809 bfd_elf32_swap_reloc_out,
13810 bfd_elf32_swap_reloca_in,
13811 bfd_elf32_swap_reloca_out
13812 };
13813
13814 #define ELF_ARCH bfd_arch_arm
13815 #define ELF_MACHINE_CODE EM_ARM
13816 #ifdef __QNXTARGET__
13817 #define ELF_MAXPAGESIZE 0x1000
13818 #else
13819 #define ELF_MAXPAGESIZE 0x8000
13820 #endif
13821 #define ELF_MINPAGESIZE 0x1000
13822 #define ELF_COMMONPAGESIZE 0x1000
13823
13824 #define bfd_elf32_mkobject elf32_arm_mkobject
13825
13826 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
13827 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
13828 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
13829 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
13830 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
13831 #define bfd_elf32_bfd_link_hash_table_free elf32_arm_hash_table_free
13832 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
13833 #define bfd_elf32_bfd_reloc_name_lookup elf32_arm_reloc_name_lookup
13834 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
13835 #define bfd_elf32_find_inliner_info elf32_arm_find_inliner_info
13836 #define bfd_elf32_new_section_hook elf32_arm_new_section_hook
13837 #define bfd_elf32_bfd_is_target_special_symbol elf32_arm_is_target_special_symbol
13838 #define bfd_elf32_close_and_cleanup elf32_arm_close_and_cleanup
13839 #define bfd_elf32_bfd_free_cached_info elf32_arm_bfd_free_cached_info
13840 #define bfd_elf32_bfd_final_link elf32_arm_final_link
13841
13842 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
13843 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
13844 #define elf_backend_gc_mark_extra_sections elf32_arm_gc_mark_extra_sections
13845 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
13846 #define elf_backend_check_relocs elf32_arm_check_relocs
13847 #define elf_backend_relocate_section elf32_arm_relocate_section
13848 #define elf_backend_write_section elf32_arm_write_section
13849 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
13850 #define elf_backend_create_dynamic_sections elf32_arm_create_dynamic_sections
13851 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
13852 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
13853 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
13854 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
13855 #define elf_backend_post_process_headers elf32_arm_post_process_headers
13856 #define elf_backend_reloc_type_class elf32_arm_reloc_type_class
13857 #define elf_backend_object_p elf32_arm_object_p
13858 #define elf_backend_section_flags elf32_arm_section_flags
13859 #define elf_backend_fake_sections elf32_arm_fake_sections
13860 #define elf_backend_section_from_shdr elf32_arm_section_from_shdr
13861 #define elf_backend_final_write_processing elf32_arm_final_write_processing
13862 #define elf_backend_copy_indirect_symbol elf32_arm_copy_indirect_symbol
13863 #define elf_backend_symbol_processing elf32_arm_symbol_processing
13864 #define elf_backend_size_info elf32_arm_size_info
13865 #define elf_backend_modify_segment_map elf32_arm_modify_segment_map
13866 #define elf_backend_additional_program_headers elf32_arm_additional_program_headers
13867 #define elf_backend_output_arch_local_syms elf32_arm_output_arch_local_syms
13868 #define elf_backend_begin_write_processing elf32_arm_begin_write_processing
13869 #define elf_backend_is_function_type elf32_arm_is_function_type
13870
13871 #define elf_backend_can_refcount 1
13872 #define elf_backend_can_gc_sections 1
13873 #define elf_backend_plt_readonly 1
13874 #define elf_backend_want_got_plt 1
13875 #define elf_backend_want_plt_sym 0
13876 #define elf_backend_may_use_rel_p 1
13877 #define elf_backend_may_use_rela_p 0
13878 #define elf_backend_default_use_rela_p 0
13879
13880 #define elf_backend_got_header_size 12
13881
13882 #undef elf_backend_obj_attrs_vendor
13883 #define elf_backend_obj_attrs_vendor "aeabi"
13884 #undef elf_backend_obj_attrs_section
13885 #define elf_backend_obj_attrs_section ".ARM.attributes"
13886 #undef elf_backend_obj_attrs_arg_type
13887 #define elf_backend_obj_attrs_arg_type elf32_arm_obj_attrs_arg_type
13888 #undef elf_backend_obj_attrs_section_type
13889 #define elf_backend_obj_attrs_section_type SHT_ARM_ATTRIBUTES
13890 #define elf_backend_obj_attrs_order elf32_arm_obj_attrs_order
13891
13892 #include "elf32-target.h"
13893
13894 /* VxWorks Targets. */
13895
13896 #undef TARGET_LITTLE_SYM
13897 #define TARGET_LITTLE_SYM bfd_elf32_littlearm_vxworks_vec
13898 #undef TARGET_LITTLE_NAME
13899 #define TARGET_LITTLE_NAME "elf32-littlearm-vxworks"
13900 #undef TARGET_BIG_SYM
13901 #define TARGET_BIG_SYM bfd_elf32_bigarm_vxworks_vec
13902 #undef TARGET_BIG_NAME
13903 #define TARGET_BIG_NAME "elf32-bigarm-vxworks"
13904
13905 /* Like elf32_arm_link_hash_table_create -- but overrides
13906 appropriately for VxWorks. */
13907
13908 static struct bfd_link_hash_table *
13909 elf32_arm_vxworks_link_hash_table_create (bfd *abfd)
13910 {
13911 struct bfd_link_hash_table *ret;
13912
13913 ret = elf32_arm_link_hash_table_create (abfd);
13914 if (ret)
13915 {
13916 struct elf32_arm_link_hash_table *htab
13917 = (struct elf32_arm_link_hash_table *) ret;
13918 htab->use_rel = 0;
13919 htab->vxworks_p = 1;
13920 }
13921 return ret;
13922 }
13923
13924 static void
13925 elf32_arm_vxworks_final_write_processing (bfd *abfd, bfd_boolean linker)
13926 {
13927 elf32_arm_final_write_processing (abfd, linker);
13928 elf_vxworks_final_write_processing (abfd, linker);
13929 }
13930
13931 #undef elf32_bed
13932 #define elf32_bed elf32_arm_vxworks_bed
13933
13934 #undef bfd_elf32_bfd_link_hash_table_create
13935 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_vxworks_link_hash_table_create
13936 #undef elf_backend_add_symbol_hook
13937 #define elf_backend_add_symbol_hook elf_vxworks_add_symbol_hook
13938 #undef elf_backend_final_write_processing
13939 #define elf_backend_final_write_processing elf32_arm_vxworks_final_write_processing
13940 #undef elf_backend_emit_relocs
13941 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
13942
13943 #undef elf_backend_may_use_rel_p
13944 #define elf_backend_may_use_rel_p 0
13945 #undef elf_backend_may_use_rela_p
13946 #define elf_backend_may_use_rela_p 1
13947 #undef elf_backend_default_use_rela_p
13948 #define elf_backend_default_use_rela_p 1
13949 #undef elf_backend_want_plt_sym
13950 #define elf_backend_want_plt_sym 1
13951 #undef ELF_MAXPAGESIZE
13952 #define ELF_MAXPAGESIZE 0x1000
13953
13954 #include "elf32-target.h"
13955
13956
13957 /* Symbian OS Targets. */
13958
13959 #undef TARGET_LITTLE_SYM
13960 #define TARGET_LITTLE_SYM bfd_elf32_littlearm_symbian_vec
13961 #undef TARGET_LITTLE_NAME
13962 #define TARGET_LITTLE_NAME "elf32-littlearm-symbian"
13963 #undef TARGET_BIG_SYM
13964 #define TARGET_BIG_SYM bfd_elf32_bigarm_symbian_vec
13965 #undef TARGET_BIG_NAME
13966 #define TARGET_BIG_NAME "elf32-bigarm-symbian"
13967
13968 /* Like elf32_arm_link_hash_table_create -- but overrides
13969 appropriately for Symbian OS. */
13970
13971 static struct bfd_link_hash_table *
13972 elf32_arm_symbian_link_hash_table_create (bfd *abfd)
13973 {
13974 struct bfd_link_hash_table *ret;
13975
13976 ret = elf32_arm_link_hash_table_create (abfd);
13977 if (ret)
13978 {
13979 struct elf32_arm_link_hash_table *htab
13980 = (struct elf32_arm_link_hash_table *)ret;
13981 /* There is no PLT header for Symbian OS. */
13982 htab->plt_header_size = 0;
13983 /* The PLT entries are each one instruction and one word. */
13984 htab->plt_entry_size = 4 * ARRAY_SIZE (elf32_arm_symbian_plt_entry);
13985 htab->symbian_p = 1;
13986 /* Symbian uses armv5t or above, so use_blx is always true. */
13987 htab->use_blx = 1;
13988 htab->root.is_relocatable_executable = 1;
13989 }
13990 return ret;
13991 }
13992
13993 static const struct bfd_elf_special_section
13994 elf32_arm_symbian_special_sections[] =
13995 {
13996 /* In a BPABI executable, the dynamic linking sections do not go in
13997 the loadable read-only segment. The post-linker may wish to
13998 refer to these sections, but they are not part of the final
13999 program image. */
14000 { STRING_COMMA_LEN (".dynamic"), 0, SHT_DYNAMIC, 0 },
14001 { STRING_COMMA_LEN (".dynstr"), 0, SHT_STRTAB, 0 },
14002 { STRING_COMMA_LEN (".dynsym"), 0, SHT_DYNSYM, 0 },
14003 { STRING_COMMA_LEN (".got"), 0, SHT_PROGBITS, 0 },
14004 { STRING_COMMA_LEN (".hash"), 0, SHT_HASH, 0 },
14005 /* These sections do not need to be writable as the SymbianOS
14006 postlinker will arrange things so that no dynamic relocation is
14007 required. */
14008 { STRING_COMMA_LEN (".init_array"), 0, SHT_INIT_ARRAY, SHF_ALLOC },
14009 { STRING_COMMA_LEN (".fini_array"), 0, SHT_FINI_ARRAY, SHF_ALLOC },
14010 { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY, SHF_ALLOC },
14011 { NULL, 0, 0, 0, 0 }
14012 };
14013
14014 static void
14015 elf32_arm_symbian_begin_write_processing (bfd *abfd,
14016 struct bfd_link_info *link_info)
14017 {
14018 /* BPABI objects are never loaded directly by an OS kernel; they are
14019 processed by a postlinker first, into an OS-specific format. If
14020 the D_PAGED bit is set on the file, BFD will align segments on
14021 page boundaries, so that an OS can directly map the file. With
14022 BPABI objects, that just results in wasted space. In addition,
14023 because we clear the D_PAGED bit, map_sections_to_segments will
14024 recognize that the program headers should not be mapped into any
14025 loadable segment. */
14026 abfd->flags &= ~D_PAGED;
14027 elf32_arm_begin_write_processing (abfd, link_info);
14028 }
14029
14030 static bfd_boolean
14031 elf32_arm_symbian_modify_segment_map (bfd *abfd,
14032 struct bfd_link_info *info)
14033 {
14034 struct elf_segment_map *m;
14035 asection *dynsec;
14036
14037 /* BPABI shared libraries and executables should have a PT_DYNAMIC
14038 segment. However, because the .dynamic section is not marked
14039 with SEC_LOAD, the generic ELF code will not create such a
14040 segment. */
14041 dynsec = bfd_get_section_by_name (abfd, ".dynamic");
14042 if (dynsec)
14043 {
14044 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
14045 if (m->p_type == PT_DYNAMIC)
14046 break;
14047
14048 if (m == NULL)
14049 {
14050 m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
14051 m->next = elf_tdata (abfd)->segment_map;
14052 elf_tdata (abfd)->segment_map = m;
14053 }
14054 }
14055
14056 /* Also call the generic arm routine. */
14057 return elf32_arm_modify_segment_map (abfd, info);
14058 }
14059
14060 /* Return address for Ith PLT stub in section PLT, for relocation REL
14061 or (bfd_vma) -1 if it should not be included. */
14062
14063 static bfd_vma
14064 elf32_arm_symbian_plt_sym_val (bfd_vma i, const asection *plt,
14065 const arelent *rel ATTRIBUTE_UNUSED)
14066 {
14067 return plt->vma + 4 * ARRAY_SIZE (elf32_arm_symbian_plt_entry) * i;
14068 }
14069
14070
14071 #undef elf32_bed
14072 #define elf32_bed elf32_arm_symbian_bed
14073
14074 /* The dynamic sections are not allocated on SymbianOS; the postlinker
14075 will process them and then discard them. */
14076 #undef ELF_DYNAMIC_SEC_FLAGS
14077 #define ELF_DYNAMIC_SEC_FLAGS \
14078 (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED)
14079
14080 #undef elf_backend_add_symbol_hook
14081 #undef elf_backend_emit_relocs
14082
14083 #undef bfd_elf32_bfd_link_hash_table_create
14084 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_symbian_link_hash_table_create
14085 #undef elf_backend_special_sections
14086 #define elf_backend_special_sections elf32_arm_symbian_special_sections
14087 #undef elf_backend_begin_write_processing
14088 #define elf_backend_begin_write_processing elf32_arm_symbian_begin_write_processing
14089 #undef elf_backend_final_write_processing
14090 #define elf_backend_final_write_processing elf32_arm_final_write_processing
14091
14092 #undef elf_backend_modify_segment_map
14093 #define elf_backend_modify_segment_map elf32_arm_symbian_modify_segment_map
14094
14095 /* There is no .got section for BPABI objects, and hence no header. */
14096 #undef elf_backend_got_header_size
14097 #define elf_backend_got_header_size 0
14098
14099 /* Similarly, there is no .got.plt section. */
14100 #undef elf_backend_want_got_plt
14101 #define elf_backend_want_got_plt 0
14102
14103 #undef elf_backend_plt_sym_val
14104 #define elf_backend_plt_sym_val elf32_arm_symbian_plt_sym_val
14105
14106 #undef elf_backend_may_use_rel_p
14107 #define elf_backend_may_use_rel_p 1
14108 #undef elf_backend_may_use_rela_p
14109 #define elf_backend_may_use_rela_p 0
14110 #undef elf_backend_default_use_rela_p
14111 #define elf_backend_default_use_rela_p 0
14112 #undef elf_backend_want_plt_sym
14113 #define elf_backend_want_plt_sym 0
14114 #undef ELF_MAXPAGESIZE
14115 #define ELF_MAXPAGESIZE 0x8000
14116
14117 #include "elf32-target.h"
git-cvsimport of binutils cvsroot