projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
2006-05-23 H.J. Lu <hongjiu.lu@intel.com>
[deliverable/binutils-gdb.git] / bfd / elf32-arm.c
1 /* 32-bit ELF support for ARM
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
3 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 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
20
21 #include "bfd.h"
22 #include "sysdep.h"
23 #include "libiberty.h"
24 #include "libbfd.h"
25 #include "elf-bfd.h"
26 #include "elf-vxworks.h"
27 #include "elf/arm.h"
28
29 #ifndef NUM_ELEM
30 #define NUM_ELEM(a) (sizeof (a) / (sizeof (a)[0]))
31 #endif
32
33 /* Return the relocation section associated with NAME. HTAB is the
34 bfd's elf32_arm_link_hash_entry. */
35 #define RELOC_SECTION(HTAB, NAME) \
36 ((HTAB)->use_rel ? ".rel" NAME : ".rela" NAME)
37
38 /* Return size of a relocation entry. HTAB is the bfd's
39 elf32_arm_link_hash_entry. */
40 #define RELOC_SIZE(HTAB) \
41 ((HTAB)->use_rel \
42 ? sizeof (Elf32_External_Rel) \
43 : sizeof (Elf32_External_Rela))
44
45 /* Return function to swap relocations in. HTAB is the bfd's
46 elf32_arm_link_hash_entry. */
47 #define SWAP_RELOC_IN(HTAB) \
48 ((HTAB)->use_rel \
49 ? bfd_elf32_swap_reloc_in \
50 : bfd_elf32_swap_reloca_in)
51
52 /* Return function to swap relocations out. HTAB is the bfd's
53 elf32_arm_link_hash_entry. */
54 #define SWAP_RELOC_OUT(HTAB) \
55 ((HTAB)->use_rel \
56 ? bfd_elf32_swap_reloc_out \
57 : bfd_elf32_swap_reloca_out)
58
59 #define elf_info_to_howto 0
60 #define elf_info_to_howto_rel elf32_arm_info_to_howto
61
62 #define ARM_ELF_ABI_VERSION 0
63 #define ARM_ELF_OS_ABI_VERSION ELFOSABI_ARM
64
65 static const struct elf_backend_data elf32_arm_vxworks_bed;
66
67 /* Note: code such as elf32_arm_reloc_type_lookup expect to use e.g.
68 R_ARM_PC24 as an index into this, and find the R_ARM_PC24 HOWTO
69 in that slot. */
70
71 static reloc_howto_type elf32_arm_howto_table_1[] =
72 {
73 /* No relocation */
74 HOWTO (R_ARM_NONE, /* type */
75 0, /* rightshift */
76 0, /* size (0 = byte, 1 = short, 2 = long) */
77 0, /* bitsize */
78 FALSE, /* pc_relative */
79 0, /* bitpos */
80 complain_overflow_dont,/* complain_on_overflow */
81 bfd_elf_generic_reloc, /* special_function */
82 "R_ARM_NONE", /* name */
83 FALSE, /* partial_inplace */
84 0, /* src_mask */
85 0, /* dst_mask */
86 FALSE), /* pcrel_offset */
87
88 HOWTO (R_ARM_PC24, /* type */
89 2, /* rightshift */
90 2, /* size (0 = byte, 1 = short, 2 = long) */
91 24, /* bitsize */
92 TRUE, /* pc_relative */
93 0, /* bitpos */
94 complain_overflow_signed,/* complain_on_overflow */
95 bfd_elf_generic_reloc, /* special_function */
96 "R_ARM_PC24", /* name */
97 FALSE, /* partial_inplace */
98 0x00ffffff, /* src_mask */
99 0x00ffffff, /* dst_mask */
100 TRUE), /* pcrel_offset */
101
102 /* 32 bit absolute */
103 HOWTO (R_ARM_ABS32, /* type */
104 0, /* rightshift */
105 2, /* size (0 = byte, 1 = short, 2 = long) */
106 32, /* bitsize */
107 FALSE, /* pc_relative */
108 0, /* bitpos */
109 complain_overflow_bitfield,/* complain_on_overflow */
110 bfd_elf_generic_reloc, /* special_function */
111 "R_ARM_ABS32", /* name */
112 FALSE, /* partial_inplace */
113 0xffffffff, /* src_mask */
114 0xffffffff, /* dst_mask */
115 FALSE), /* pcrel_offset */
116
117 /* standard 32bit pc-relative reloc */
118 HOWTO (R_ARM_REL32, /* type */
119 0, /* rightshift */
120 2, /* size (0 = byte, 1 = short, 2 = long) */
121 32, /* bitsize */
122 TRUE, /* pc_relative */
123 0, /* bitpos */
124 complain_overflow_bitfield,/* complain_on_overflow */
125 bfd_elf_generic_reloc, /* special_function */
126 "R_ARM_REL32", /* name */
127 FALSE, /* partial_inplace */
128 0xffffffff, /* src_mask */
129 0xffffffff, /* dst_mask */
130 TRUE), /* pcrel_offset */
131
132 /* 8 bit absolute - R_ARM_LDR_PC_G0 in AAELF */
133 HOWTO (R_ARM_PC13, /* type */
134 0, /* rightshift */
135 0, /* size (0 = byte, 1 = short, 2 = long) */
136 8, /* bitsize */
137 FALSE, /* pc_relative */
138 0, /* bitpos */
139 complain_overflow_bitfield,/* complain_on_overflow */
140 bfd_elf_generic_reloc, /* special_function */
141 "R_ARM_PC13", /* name */
142 FALSE, /* partial_inplace */
143 0x000000ff, /* src_mask */
144 0x000000ff, /* dst_mask */
145 FALSE), /* pcrel_offset */
146
147 /* 16 bit absolute */
148 HOWTO (R_ARM_ABS16, /* type */
149 0, /* rightshift */
150 1, /* size (0 = byte, 1 = short, 2 = long) */
151 16, /* bitsize */
152 FALSE, /* pc_relative */
153 0, /* bitpos */
154 complain_overflow_bitfield,/* complain_on_overflow */
155 bfd_elf_generic_reloc, /* special_function */
156 "R_ARM_ABS16", /* name */
157 FALSE, /* partial_inplace */
158 0x0000ffff, /* src_mask */
159 0x0000ffff, /* dst_mask */
160 FALSE), /* pcrel_offset */
161
162 /* 12 bit absolute */
163 HOWTO (R_ARM_ABS12, /* type */
164 0, /* rightshift */
165 2, /* size (0 = byte, 1 = short, 2 = long) */
166 12, /* bitsize */
167 FALSE, /* pc_relative */
168 0, /* bitpos */
169 complain_overflow_bitfield,/* complain_on_overflow */
170 bfd_elf_generic_reloc, /* special_function */
171 "R_ARM_ABS12", /* name */
172 FALSE, /* partial_inplace */
173 0x00000fff, /* src_mask */
174 0x00000fff, /* dst_mask */
175 FALSE), /* pcrel_offset */
176
177 HOWTO (R_ARM_THM_ABS5, /* type */
178 6, /* rightshift */
179 1, /* size (0 = byte, 1 = short, 2 = long) */
180 5, /* bitsize */
181 FALSE, /* pc_relative */
182 0, /* bitpos */
183 complain_overflow_bitfield,/* complain_on_overflow */
184 bfd_elf_generic_reloc, /* special_function */
185 "R_ARM_THM_ABS5", /* name */
186 FALSE, /* partial_inplace */
187 0x000007e0, /* src_mask */
188 0x000007e0, /* dst_mask */
189 FALSE), /* pcrel_offset */
190
191 /* 8 bit absolute */
192 HOWTO (R_ARM_ABS8, /* type */
193 0, /* rightshift */
194 0, /* size (0 = byte, 1 = short, 2 = long) */
195 8, /* bitsize */
196 FALSE, /* pc_relative */
197 0, /* bitpos */
198 complain_overflow_bitfield,/* complain_on_overflow */
199 bfd_elf_generic_reloc, /* special_function */
200 "R_ARM_ABS8", /* name */
201 FALSE, /* partial_inplace */
202 0x000000ff, /* src_mask */
203 0x000000ff, /* dst_mask */
204 FALSE), /* pcrel_offset */
205
206 HOWTO (R_ARM_SBREL32, /* type */
207 0, /* rightshift */
208 2, /* size (0 = byte, 1 = short, 2 = long) */
209 32, /* bitsize */
210 FALSE, /* pc_relative */
211 0, /* bitpos */
212 complain_overflow_dont,/* complain_on_overflow */
213 bfd_elf_generic_reloc, /* special_function */
214 "R_ARM_SBREL32", /* name */
215 FALSE, /* partial_inplace */
216 0xffffffff, /* src_mask */
217 0xffffffff, /* dst_mask */
218 FALSE), /* pcrel_offset */
219
220 /* FIXME: Has two more bits of offset in Thumb32. */
221 HOWTO (R_ARM_THM_CALL, /* type */
222 1, /* rightshift */
223 2, /* size (0 = byte, 1 = short, 2 = long) */
224 23, /* bitsize */
225 TRUE, /* pc_relative */
226 0, /* bitpos */
227 complain_overflow_signed,/* complain_on_overflow */
228 bfd_elf_generic_reloc, /* special_function */
229 "R_ARM_THM_CALL", /* name */
230 FALSE, /* partial_inplace */
231 0x07ff07ff, /* src_mask */
232 0x07ff07ff, /* dst_mask */
233 TRUE), /* pcrel_offset */
234
235 HOWTO (R_ARM_THM_PC8, /* type */
236 1, /* rightshift */
237 1, /* size (0 = byte, 1 = short, 2 = long) */
238 8, /* bitsize */
239 TRUE, /* pc_relative */
240 0, /* bitpos */
241 complain_overflow_signed,/* complain_on_overflow */
242 bfd_elf_generic_reloc, /* special_function */
243 "R_ARM_THM_PC8", /* name */
244 FALSE, /* partial_inplace */
245 0x000000ff, /* src_mask */
246 0x000000ff, /* dst_mask */
247 TRUE), /* pcrel_offset */
248
249 HOWTO (R_ARM_BREL_ADJ, /* type */
250 1, /* rightshift */
251 1, /* size (0 = byte, 1 = short, 2 = long) */
252 32, /* bitsize */
253 FALSE, /* pc_relative */
254 0, /* bitpos */
255 complain_overflow_signed,/* complain_on_overflow */
256 bfd_elf_generic_reloc, /* special_function */
257 "R_ARM_BREL_ADJ", /* name */
258 FALSE, /* partial_inplace */
259 0xffffffff, /* src_mask */
260 0xffffffff, /* dst_mask */
261 FALSE), /* pcrel_offset */
262
263 HOWTO (R_ARM_SWI24, /* type */
264 0, /* rightshift */
265 0, /* size (0 = byte, 1 = short, 2 = long) */
266 0, /* bitsize */
267 FALSE, /* pc_relative */
268 0, /* bitpos */
269 complain_overflow_signed,/* complain_on_overflow */
270 bfd_elf_generic_reloc, /* special_function */
271 "R_ARM_SWI24", /* name */
272 FALSE, /* partial_inplace */
273 0x00000000, /* src_mask */
274 0x00000000, /* dst_mask */
275 FALSE), /* pcrel_offset */
276
277 HOWTO (R_ARM_THM_SWI8, /* type */
278 0, /* rightshift */
279 0, /* size (0 = byte, 1 = short, 2 = long) */
280 0, /* bitsize */
281 FALSE, /* pc_relative */
282 0, /* bitpos */
283 complain_overflow_signed,/* complain_on_overflow */
284 bfd_elf_generic_reloc, /* special_function */
285 "R_ARM_SWI8", /* name */
286 FALSE, /* partial_inplace */
287 0x00000000, /* src_mask */
288 0x00000000, /* dst_mask */
289 FALSE), /* pcrel_offset */
290
291 /* BLX instruction for the ARM. */
292 HOWTO (R_ARM_XPC25, /* type */
293 2, /* rightshift */
294 2, /* size (0 = byte, 1 = short, 2 = long) */
295 25, /* bitsize */
296 TRUE, /* pc_relative */
297 0, /* bitpos */
298 complain_overflow_signed,/* complain_on_overflow */
299 bfd_elf_generic_reloc, /* special_function */
300 "R_ARM_XPC25", /* name */
301 FALSE, /* partial_inplace */
302 0x00ffffff, /* src_mask */
303 0x00ffffff, /* dst_mask */
304 TRUE), /* pcrel_offset */
305
306 /* BLX instruction for the Thumb. */
307 HOWTO (R_ARM_THM_XPC22, /* type */
308 2, /* rightshift */
309 2, /* size (0 = byte, 1 = short, 2 = long) */
310 22, /* bitsize */
311 TRUE, /* pc_relative */
312 0, /* bitpos */
313 complain_overflow_signed,/* complain_on_overflow */
314 bfd_elf_generic_reloc, /* special_function */
315 "R_ARM_THM_XPC22", /* name */
316 FALSE, /* partial_inplace */
317 0x07ff07ff, /* src_mask */
318 0x07ff07ff, /* dst_mask */
319 TRUE), /* pcrel_offset */
320
321 /* Dynamic TLS relocations. */
322
323 HOWTO (R_ARM_TLS_DTPMOD32, /* type */
324 0, /* rightshift */
325 2, /* size (0 = byte, 1 = short, 2 = long) */
326 32, /* bitsize */
327 FALSE, /* pc_relative */
328 0, /* bitpos */
329 complain_overflow_bitfield,/* complain_on_overflow */
330 bfd_elf_generic_reloc, /* special_function */
331 "R_ARM_TLS_DTPMOD32", /* name */
332 TRUE, /* partial_inplace */
333 0xffffffff, /* src_mask */
334 0xffffffff, /* dst_mask */
335 FALSE), /* pcrel_offset */
336
337 HOWTO (R_ARM_TLS_DTPOFF32, /* type */
338 0, /* rightshift */
339 2, /* size (0 = byte, 1 = short, 2 = long) */
340 32, /* bitsize */
341 FALSE, /* pc_relative */
342 0, /* bitpos */
343 complain_overflow_bitfield,/* complain_on_overflow */
344 bfd_elf_generic_reloc, /* special_function */
345 "R_ARM_TLS_DTPOFF32", /* name */
346 TRUE, /* partial_inplace */
347 0xffffffff, /* src_mask */
348 0xffffffff, /* dst_mask */
349 FALSE), /* pcrel_offset */
350
351 HOWTO (R_ARM_TLS_TPOFF32, /* type */
352 0, /* rightshift */
353 2, /* size (0 = byte, 1 = short, 2 = long) */
354 32, /* bitsize */
355 FALSE, /* pc_relative */
356 0, /* bitpos */
357 complain_overflow_bitfield,/* complain_on_overflow */
358 bfd_elf_generic_reloc, /* special_function */
359 "R_ARM_TLS_TPOFF32", /* name */
360 TRUE, /* partial_inplace */
361 0xffffffff, /* src_mask */
362 0xffffffff, /* dst_mask */
363 FALSE), /* pcrel_offset */
364
365 /* Relocs used in ARM Linux */
366
367 HOWTO (R_ARM_COPY, /* type */
368 0, /* rightshift */
369 2, /* size (0 = byte, 1 = short, 2 = long) */
370 32, /* bitsize */
371 FALSE, /* pc_relative */
372 0, /* bitpos */
373 complain_overflow_bitfield,/* complain_on_overflow */
374 bfd_elf_generic_reloc, /* special_function */
375 "R_ARM_COPY", /* name */
376 TRUE, /* partial_inplace */
377 0xffffffff, /* src_mask */
378 0xffffffff, /* dst_mask */
379 FALSE), /* pcrel_offset */
380
381 HOWTO (R_ARM_GLOB_DAT, /* type */
382 0, /* rightshift */
383 2, /* size (0 = byte, 1 = short, 2 = long) */
384 32, /* bitsize */
385 FALSE, /* pc_relative */
386 0, /* bitpos */
387 complain_overflow_bitfield,/* complain_on_overflow */
388 bfd_elf_generic_reloc, /* special_function */
389 "R_ARM_GLOB_DAT", /* name */
390 TRUE, /* partial_inplace */
391 0xffffffff, /* src_mask */
392 0xffffffff, /* dst_mask */
393 FALSE), /* pcrel_offset */
394
395 HOWTO (R_ARM_JUMP_SLOT, /* type */
396 0, /* rightshift */
397 2, /* size (0 = byte, 1 = short, 2 = long) */
398 32, /* bitsize */
399 FALSE, /* pc_relative */
400 0, /* bitpos */
401 complain_overflow_bitfield,/* complain_on_overflow */
402 bfd_elf_generic_reloc, /* special_function */
403 "R_ARM_JUMP_SLOT", /* name */
404 TRUE, /* partial_inplace */
405 0xffffffff, /* src_mask */
406 0xffffffff, /* dst_mask */
407 FALSE), /* pcrel_offset */
408
409 HOWTO (R_ARM_RELATIVE, /* type */
410 0, /* rightshift */
411 2, /* size (0 = byte, 1 = short, 2 = long) */
412 32, /* bitsize */
413 FALSE, /* pc_relative */
414 0, /* bitpos */
415 complain_overflow_bitfield,/* complain_on_overflow */
416 bfd_elf_generic_reloc, /* special_function */
417 "R_ARM_RELATIVE", /* name */
418 TRUE, /* partial_inplace */
419 0xffffffff, /* src_mask */
420 0xffffffff, /* dst_mask */
421 FALSE), /* pcrel_offset */
422
423 HOWTO (R_ARM_GOTOFF32, /* type */
424 0, /* rightshift */
425 2, /* size (0 = byte, 1 = short, 2 = long) */
426 32, /* bitsize */
427 FALSE, /* pc_relative */
428 0, /* bitpos */
429 complain_overflow_bitfield,/* complain_on_overflow */
430 bfd_elf_generic_reloc, /* special_function */
431 "R_ARM_GOTOFF32", /* name */
432 TRUE, /* partial_inplace */
433 0xffffffff, /* src_mask */
434 0xffffffff, /* dst_mask */
435 FALSE), /* pcrel_offset */
436
437 HOWTO (R_ARM_GOTPC, /* type */
438 0, /* rightshift */
439 2, /* size (0 = byte, 1 = short, 2 = long) */
440 32, /* bitsize */
441 TRUE, /* pc_relative */
442 0, /* bitpos */
443 complain_overflow_bitfield,/* complain_on_overflow */
444 bfd_elf_generic_reloc, /* special_function */
445 "R_ARM_GOTPC", /* name */
446 TRUE, /* partial_inplace */
447 0xffffffff, /* src_mask */
448 0xffffffff, /* dst_mask */
449 TRUE), /* pcrel_offset */
450
451 HOWTO (R_ARM_GOT32, /* type */
452 0, /* rightshift */
453 2, /* size (0 = byte, 1 = short, 2 = long) */
454 32, /* bitsize */
455 FALSE, /* pc_relative */
456 0, /* bitpos */
457 complain_overflow_bitfield,/* complain_on_overflow */
458 bfd_elf_generic_reloc, /* special_function */
459 "R_ARM_GOT32", /* name */
460 TRUE, /* partial_inplace */
461 0xffffffff, /* src_mask */
462 0xffffffff, /* dst_mask */
463 FALSE), /* pcrel_offset */
464
465 HOWTO (R_ARM_PLT32, /* type */
466 2, /* rightshift */
467 2, /* size (0 = byte, 1 = short, 2 = long) */
468 24, /* bitsize */
469 TRUE, /* pc_relative */
470 0, /* bitpos */
471 complain_overflow_bitfield,/* complain_on_overflow */
472 bfd_elf_generic_reloc, /* special_function */
473 "R_ARM_PLT32", /* name */
474 FALSE, /* partial_inplace */
475 0x00ffffff, /* src_mask */
476 0x00ffffff, /* dst_mask */
477 TRUE), /* pcrel_offset */
478
479 HOWTO (R_ARM_CALL, /* type */
480 2, /* rightshift */
481 2, /* size (0 = byte, 1 = short, 2 = long) */
482 24, /* bitsize */
483 TRUE, /* pc_relative */
484 0, /* bitpos */
485 complain_overflow_signed,/* complain_on_overflow */
486 bfd_elf_generic_reloc, /* special_function */
487 "R_ARM_CALL", /* name */
488 FALSE, /* partial_inplace */
489 0x00ffffff, /* src_mask */
490 0x00ffffff, /* dst_mask */
491 TRUE), /* pcrel_offset */
492
493 HOWTO (R_ARM_JUMP24, /* type */
494 2, /* rightshift */
495 2, /* size (0 = byte, 1 = short, 2 = long) */
496 24, /* bitsize */
497 TRUE, /* pc_relative */
498 0, /* bitpos */
499 complain_overflow_signed,/* complain_on_overflow */
500 bfd_elf_generic_reloc, /* special_function */
501 "R_ARM_JUMP24", /* name */
502 FALSE, /* partial_inplace */
503 0x00ffffff, /* src_mask */
504 0x00ffffff, /* dst_mask */
505 TRUE), /* pcrel_offset */
506
507 HOWTO (R_ARM_THM_JUMP24, /* type */
508 1, /* rightshift */
509 2, /* size (0 = byte, 1 = short, 2 = long) */
510 24, /* bitsize */
511 TRUE, /* pc_relative */
512 0, /* bitpos */
513 complain_overflow_signed,/* complain_on_overflow */
514 bfd_elf_generic_reloc, /* special_function */
515 "R_ARM_THM_JUMP24", /* name */
516 FALSE, /* partial_inplace */
517 0x07ff2fff, /* src_mask */
518 0x07ff2fff, /* dst_mask */
519 TRUE), /* pcrel_offset */
520
521 HOWTO (R_ARM_BASE_ABS, /* type */
522 0, /* rightshift */
523 2, /* size (0 = byte, 1 = short, 2 = long) */
524 32, /* bitsize */
525 FALSE, /* pc_relative */
526 0, /* bitpos */
527 complain_overflow_dont,/* complain_on_overflow */
528 bfd_elf_generic_reloc, /* special_function */
529 "R_ARM_BASE_ABS", /* name */
530 FALSE, /* partial_inplace */
531 0xffffffff, /* src_mask */
532 0xffffffff, /* dst_mask */
533 FALSE), /* pcrel_offset */
534
535 HOWTO (R_ARM_ALU_PCREL7_0, /* type */
536 0, /* rightshift */
537 2, /* size (0 = byte, 1 = short, 2 = long) */
538 12, /* bitsize */
539 TRUE, /* pc_relative */
540 0, /* bitpos */
541 complain_overflow_dont,/* complain_on_overflow */
542 bfd_elf_generic_reloc, /* special_function */
543 "R_ARM_ALU_PCREL_7_0", /* name */
544 FALSE, /* partial_inplace */
545 0x00000fff, /* src_mask */
546 0x00000fff, /* dst_mask */
547 TRUE), /* pcrel_offset */
548
549 HOWTO (R_ARM_ALU_PCREL15_8, /* type */
550 0, /* rightshift */
551 2, /* size (0 = byte, 1 = short, 2 = long) */
552 12, /* bitsize */
553 TRUE, /* pc_relative */
554 8, /* bitpos */
555 complain_overflow_dont,/* complain_on_overflow */
556 bfd_elf_generic_reloc, /* special_function */
557 "R_ARM_ALU_PCREL_15_8",/* name */
558 FALSE, /* partial_inplace */
559 0x00000fff, /* src_mask */
560 0x00000fff, /* dst_mask */
561 TRUE), /* pcrel_offset */
562
563 HOWTO (R_ARM_ALU_PCREL23_15, /* type */
564 0, /* rightshift */
565 2, /* size (0 = byte, 1 = short, 2 = long) */
566 12, /* bitsize */
567 TRUE, /* pc_relative */
568 16, /* bitpos */
569 complain_overflow_dont,/* complain_on_overflow */
570 bfd_elf_generic_reloc, /* special_function */
571 "R_ARM_ALU_PCREL_23_15",/* name */
572 FALSE, /* partial_inplace */
573 0x00000fff, /* src_mask */
574 0x00000fff, /* dst_mask */
575 TRUE), /* pcrel_offset */
576
577 HOWTO (R_ARM_LDR_SBREL_11_0, /* type */
578 0, /* rightshift */
579 2, /* size (0 = byte, 1 = short, 2 = long) */
580 12, /* bitsize */
581 FALSE, /* pc_relative */
582 0, /* bitpos */
583 complain_overflow_dont,/* complain_on_overflow */
584 bfd_elf_generic_reloc, /* special_function */
585 "R_ARM_LDR_SBREL_11_0",/* name */
586 FALSE, /* partial_inplace */
587 0x00000fff, /* src_mask */
588 0x00000fff, /* dst_mask */
589 FALSE), /* pcrel_offset */
590
591 HOWTO (R_ARM_ALU_SBREL_19_12, /* type */
592 0, /* rightshift */
593 2, /* size (0 = byte, 1 = short, 2 = long) */
594 8, /* bitsize */
595 FALSE, /* pc_relative */
596 12, /* bitpos */
597 complain_overflow_dont,/* complain_on_overflow */
598 bfd_elf_generic_reloc, /* special_function */
599 "R_ARM_ALU_SBREL_19_12",/* name */
600 FALSE, /* partial_inplace */
601 0x000ff000, /* src_mask */
602 0x000ff000, /* dst_mask */
603 FALSE), /* pcrel_offset */
604
605 HOWTO (R_ARM_ALU_SBREL_27_20, /* type */
606 0, /* rightshift */
607 2, /* size (0 = byte, 1 = short, 2 = long) */
608 8, /* bitsize */
609 FALSE, /* pc_relative */
610 20, /* bitpos */
611 complain_overflow_dont,/* complain_on_overflow */
612 bfd_elf_generic_reloc, /* special_function */
613 "R_ARM_ALU_SBREL_27_20",/* name */
614 FALSE, /* partial_inplace */
615 0x0ff00000, /* src_mask */
616 0x0ff00000, /* dst_mask */
617 FALSE), /* pcrel_offset */
618
619 HOWTO (R_ARM_TARGET1, /* type */
620 0, /* rightshift */
621 2, /* size (0 = byte, 1 = short, 2 = long) */
622 32, /* bitsize */
623 FALSE, /* pc_relative */
624 0, /* bitpos */
625 complain_overflow_dont,/* complain_on_overflow */
626 bfd_elf_generic_reloc, /* special_function */
627 "R_ARM_TARGET1", /* name */
628 FALSE, /* partial_inplace */
629 0xffffffff, /* src_mask */
630 0xffffffff, /* dst_mask */
631 FALSE), /* pcrel_offset */
632
633 HOWTO (R_ARM_ROSEGREL32, /* type */
634 0, /* rightshift */
635 2, /* size (0 = byte, 1 = short, 2 = long) */
636 32, /* bitsize */
637 FALSE, /* pc_relative */
638 0, /* bitpos */
639 complain_overflow_dont,/* complain_on_overflow */
640 bfd_elf_generic_reloc, /* special_function */
641 "R_ARM_ROSEGREL32", /* name */
642 FALSE, /* partial_inplace */
643 0xffffffff, /* src_mask */
644 0xffffffff, /* dst_mask */
645 FALSE), /* pcrel_offset */
646
647 HOWTO (R_ARM_V4BX, /* type */
648 0, /* rightshift */
649 2, /* size (0 = byte, 1 = short, 2 = long) */
650 32, /* bitsize */
651 FALSE, /* pc_relative */
652 0, /* bitpos */
653 complain_overflow_dont,/* complain_on_overflow */
654 bfd_elf_generic_reloc, /* special_function */
655 "R_ARM_V4BX", /* name */
656 FALSE, /* partial_inplace */
657 0xffffffff, /* src_mask */
658 0xffffffff, /* dst_mask */
659 FALSE), /* pcrel_offset */
660
661 HOWTO (R_ARM_TARGET2, /* type */
662 0, /* rightshift */
663 2, /* size (0 = byte, 1 = short, 2 = long) */
664 32, /* bitsize */
665 FALSE, /* pc_relative */
666 0, /* bitpos */
667 complain_overflow_signed,/* complain_on_overflow */
668 bfd_elf_generic_reloc, /* special_function */
669 "R_ARM_TARGET2", /* name */
670 FALSE, /* partial_inplace */
671 0xffffffff, /* src_mask */
672 0xffffffff, /* dst_mask */
673 TRUE), /* pcrel_offset */
674
675 HOWTO (R_ARM_PREL31, /* type */
676 0, /* rightshift */
677 2, /* size (0 = byte, 1 = short, 2 = long) */
678 31, /* bitsize */
679 TRUE, /* pc_relative */
680 0, /* bitpos */
681 complain_overflow_signed,/* complain_on_overflow */
682 bfd_elf_generic_reloc, /* special_function */
683 "R_ARM_PREL31", /* name */
684 FALSE, /* partial_inplace */
685 0x7fffffff, /* src_mask */
686 0x7fffffff, /* dst_mask */
687 TRUE), /* pcrel_offset */
688
689 HOWTO (R_ARM_MOVW_ABS_NC, /* type */
690 0, /* rightshift */
691 2, /* size (0 = byte, 1 = short, 2 = long) */
692 16, /* bitsize */
693 FALSE, /* pc_relative */
694 0, /* bitpos */
695 complain_overflow_dont,/* complain_on_overflow */
696 bfd_elf_generic_reloc, /* special_function */
697 "R_ARM_MOVW_ABS_NC", /* name */
698 FALSE, /* partial_inplace */
699 0x0000ffff, /* src_mask */
700 0x0000ffff, /* dst_mask */
701 FALSE), /* pcrel_offset */
702
703 HOWTO (R_ARM_MOVT_ABS, /* type */
704 0, /* rightshift */
705 2, /* size (0 = byte, 1 = short, 2 = long) */
706 16, /* bitsize */
707 FALSE, /* pc_relative */
708 0, /* bitpos */
709 complain_overflow_bitfield,/* complain_on_overflow */
710 bfd_elf_generic_reloc, /* special_function */
711 "R_ARM_MOVT_ABS", /* name */
712 FALSE, /* partial_inplace */
713 0x0000ffff, /* src_mask */
714 0x0000ffff, /* dst_mask */
715 FALSE), /* pcrel_offset */
716
717 HOWTO (R_ARM_MOVW_PREL_NC, /* type */
718 0, /* rightshift */
719 2, /* size (0 = byte, 1 = short, 2 = long) */
720 16, /* bitsize */
721 TRUE, /* pc_relative */
722 0, /* bitpos */
723 complain_overflow_dont,/* complain_on_overflow */
724 bfd_elf_generic_reloc, /* special_function */
725 "R_ARM_MOVW_PREL_NC", /* name */
726 FALSE, /* partial_inplace */
727 0x0000ffff, /* src_mask */
728 0x0000ffff, /* dst_mask */
729 TRUE), /* pcrel_offset */
730
731 HOWTO (R_ARM_MOVT_PREL, /* type */
732 0, /* rightshift */
733 2, /* size (0 = byte, 1 = short, 2 = long) */
734 16, /* bitsize */
735 TRUE, /* pc_relative */
736 0, /* bitpos */
737 complain_overflow_bitfield,/* complain_on_overflow */
738 bfd_elf_generic_reloc, /* special_function */
739 "R_ARM_MOVT_PREL", /* name */
740 FALSE, /* partial_inplace */
741 0x0000ffff, /* src_mask */
742 0x0000ffff, /* dst_mask */
743 TRUE), /* pcrel_offset */
744
745 HOWTO (R_ARM_THM_MOVW_ABS_NC, /* type */
746 0, /* rightshift */
747 2, /* size (0 = byte, 1 = short, 2 = long) */
748 16, /* bitsize */
749 FALSE, /* pc_relative */
750 0, /* bitpos */
751 complain_overflow_dont,/* complain_on_overflow */
752 bfd_elf_generic_reloc, /* special_function */
753 "R_ARM_THM_MOVW_ABS_NC",/* name */
754 FALSE, /* partial_inplace */
755 0x040f70ff, /* src_mask */
756 0x040f70ff, /* dst_mask */
757 FALSE), /* pcrel_offset */
758
759 HOWTO (R_ARM_THM_MOVT_ABS, /* type */
760 0, /* rightshift */
761 2, /* size (0 = byte, 1 = short, 2 = long) */
762 16, /* bitsize */
763 FALSE, /* pc_relative */
764 0, /* bitpos */
765 complain_overflow_bitfield,/* complain_on_overflow */
766 bfd_elf_generic_reloc, /* special_function */
767 "R_ARM_THM_MOVT_ABS", /* name */
768 FALSE, /* partial_inplace */
769 0x040f70ff, /* src_mask */
770 0x040f70ff, /* dst_mask */
771 FALSE), /* pcrel_offset */
772
773 HOWTO (R_ARM_THM_MOVW_PREL_NC,/* type */
774 0, /* rightshift */
775 2, /* size (0 = byte, 1 = short, 2 = long) */
776 16, /* bitsize */
777 TRUE, /* pc_relative */
778 0, /* bitpos */
779 complain_overflow_dont,/* complain_on_overflow */
780 bfd_elf_generic_reloc, /* special_function */
781 "R_ARM_THM_MOVW_PREL_NC",/* name */
782 FALSE, /* partial_inplace */
783 0x040f70ff, /* src_mask */
784 0x040f70ff, /* dst_mask */
785 TRUE), /* pcrel_offset */
786
787 HOWTO (R_ARM_THM_MOVT_PREL, /* type */
788 0, /* rightshift */
789 2, /* size (0 = byte, 1 = short, 2 = long) */
790 16, /* bitsize */
791 TRUE, /* pc_relative */
792 0, /* bitpos */
793 complain_overflow_bitfield,/* complain_on_overflow */
794 bfd_elf_generic_reloc, /* special_function */
795 "R_ARM_THM_MOVT_PREL", /* name */
796 FALSE, /* partial_inplace */
797 0x040f70ff, /* src_mask */
798 0x040f70ff, /* dst_mask */
799 TRUE), /* pcrel_offset */
800
801 HOWTO (R_ARM_THM_JUMP19, /* type */
802 1, /* rightshift */
803 2, /* size (0 = byte, 1 = short, 2 = long) */
804 19, /* bitsize */
805 TRUE, /* pc_relative */
806 0, /* bitpos */
807 complain_overflow_signed,/* complain_on_overflow */
808 bfd_elf_generic_reloc, /* special_function */
809 "R_ARM_THM_JUMP19", /* name */
810 FALSE, /* partial_inplace */
811 0x043f2fff, /* src_mask */
812 0x043f2fff, /* dst_mask */
813 TRUE), /* pcrel_offset */
814
815 HOWTO (R_ARM_THM_JUMP6, /* type */
816 1, /* rightshift */
817 1, /* size (0 = byte, 1 = short, 2 = long) */
818 6, /* bitsize */
819 TRUE, /* pc_relative */
820 0, /* bitpos */
821 complain_overflow_unsigned,/* complain_on_overflow */
822 bfd_elf_generic_reloc, /* special_function */
823 "R_ARM_THM_JUMP6", /* name */
824 FALSE, /* partial_inplace */
825 0x02f8, /* src_mask */
826 0x02f8, /* dst_mask */
827 TRUE), /* pcrel_offset */
828
829 /* These are declared as 13-bit signed relocations because we can
830 address -4095 .. 4095(base) by altering ADDW to SUBW or vice
831 versa. */
832 HOWTO (R_ARM_THM_ALU_PREL_11_0,/* type */
833 0, /* rightshift */
834 2, /* size (0 = byte, 1 = short, 2 = long) */
835 13, /* bitsize */
836 TRUE, /* pc_relative */
837 0, /* bitpos */
838 complain_overflow_signed,/* complain_on_overflow */
839 bfd_elf_generic_reloc, /* special_function */
840 "R_ARM_THM_ALU_PREL_11_0",/* name */
841 FALSE, /* partial_inplace */
842 0x040070ff, /* src_mask */
843 0x040070ff, /* dst_mask */
844 TRUE), /* pcrel_offset */
845
846 HOWTO (R_ARM_THM_PC12, /* type */
847 0, /* rightshift */
848 2, /* size (0 = byte, 1 = short, 2 = long) */
849 13, /* bitsize */
850 TRUE, /* pc_relative */
851 0, /* bitpos */
852 complain_overflow_signed,/* complain_on_overflow */
853 bfd_elf_generic_reloc, /* special_function */
854 "R_ARM_THM_PC12", /* name */
855 FALSE, /* partial_inplace */
856 0x040070ff, /* src_mask */
857 0x040070ff, /* dst_mask */
858 TRUE), /* pcrel_offset */
859
860 HOWTO (R_ARM_ABS32_NOI, /* type */
861 0, /* rightshift */
862 2, /* size (0 = byte, 1 = short, 2 = long) */
863 32, /* bitsize */
864 FALSE, /* pc_relative */
865 0, /* bitpos */
866 complain_overflow_dont,/* complain_on_overflow */
867 bfd_elf_generic_reloc, /* special_function */
868 "R_ARM_ABS32_NOI", /* name */
869 FALSE, /* partial_inplace */
870 0xffffffff, /* src_mask */
871 0xffffffff, /* dst_mask */
872 FALSE), /* pcrel_offset */
873
874 HOWTO (R_ARM_REL32_NOI, /* type */
875 0, /* rightshift */
876 2, /* size (0 = byte, 1 = short, 2 = long) */
877 32, /* bitsize */
878 TRUE, /* pc_relative */
879 0, /* bitpos */
880 complain_overflow_dont,/* complain_on_overflow */
881 bfd_elf_generic_reloc, /* special_function */
882 "R_ARM_REL32_NOI", /* name */
883 FALSE, /* partial_inplace */
884 0xffffffff, /* src_mask */
885 0xffffffff, /* dst_mask */
886 FALSE), /* pcrel_offset */
887 };
888
889 /* Relocations 57 .. 83 are the "group relocations" which we do not
890 support. */
891
892 static reloc_howto_type elf32_arm_howto_table_2[] =
893 {
894 HOWTO (R_ARM_MOVW_BREL_NC, /* type */
895 0, /* rightshift */
896 2, /* size (0 = byte, 1 = short, 2 = long) */
897 16, /* bitsize */
898 FALSE, /* pc_relative */
899 0, /* bitpos */
900 complain_overflow_dont,/* complain_on_overflow */
901 bfd_elf_generic_reloc, /* special_function */
902 "R_ARM_MOVW_BREL_NC", /* name */
903 FALSE, /* partial_inplace */
904 0x0000ffff, /* src_mask */
905 0x0000ffff, /* dst_mask */
906 FALSE), /* pcrel_offset */
907
908 HOWTO (R_ARM_MOVT_BREL, /* type */
909 0, /* rightshift */
910 2, /* size (0 = byte, 1 = short, 2 = long) */
911 16, /* bitsize */
912 FALSE, /* pc_relative */
913 0, /* bitpos */
914 complain_overflow_bitfield,/* complain_on_overflow */
915 bfd_elf_generic_reloc, /* special_function */
916 "R_ARM_MOVT_BREL", /* name */
917 FALSE, /* partial_inplace */
918 0x0000ffff, /* src_mask */
919 0x0000ffff, /* dst_mask */
920 FALSE), /* pcrel_offset */
921
922 HOWTO (R_ARM_MOVW_BREL, /* type */
923 0, /* rightshift */
924 2, /* size (0 = byte, 1 = short, 2 = long) */
925 16, /* bitsize */
926 FALSE, /* pc_relative */
927 0, /* bitpos */
928 complain_overflow_dont,/* complain_on_overflow */
929 bfd_elf_generic_reloc, /* special_function */
930 "R_ARM_MOVW_BREL", /* name */
931 FALSE, /* partial_inplace */
932 0x0000ffff, /* src_mask */
933 0x0000ffff, /* dst_mask */
934 FALSE), /* pcrel_offset */
935
936 HOWTO (R_ARM_THM_MOVW_BREL_NC,/* type */
937 0, /* rightshift */
938 2, /* size (0 = byte, 1 = short, 2 = long) */
939 16, /* bitsize */
940 FALSE, /* pc_relative */
941 0, /* bitpos */
942 complain_overflow_dont,/* complain_on_overflow */
943 bfd_elf_generic_reloc, /* special_function */
944 "R_ARM_THM_MOVW_BREL_NC",/* name */
945 FALSE, /* partial_inplace */
946 0x040f70ff, /* src_mask */
947 0x040f70ff, /* dst_mask */
948 FALSE), /* pcrel_offset */
949
950 HOWTO (R_ARM_THM_MOVT_BREL, /* type */
951 0, /* rightshift */
952 2, /* size (0 = byte, 1 = short, 2 = long) */
953 16, /* bitsize */
954 FALSE, /* pc_relative */
955 0, /* bitpos */
956 complain_overflow_bitfield,/* complain_on_overflow */
957 bfd_elf_generic_reloc, /* special_function */
958 "R_ARM_THM_MOVT_BREL", /* name */
959 FALSE, /* partial_inplace */
960 0x040f70ff, /* src_mask */
961 0x040f70ff, /* dst_mask */
962 FALSE), /* pcrel_offset */
963
964 HOWTO (R_ARM_THM_MOVW_BREL, /* type */
965 0, /* rightshift */
966 2, /* size (0 = byte, 1 = short, 2 = long) */
967 16, /* bitsize */
968 FALSE, /* pc_relative */
969 0, /* bitpos */
970 complain_overflow_dont,/* complain_on_overflow */
971 bfd_elf_generic_reloc, /* special_function */
972 "R_ARM_THM_MOVW_BREL", /* name */
973 FALSE, /* partial_inplace */
974 0x040f70ff, /* src_mask */
975 0x040f70ff, /* dst_mask */
976 FALSE), /* pcrel_offset */
977
978 EMPTY_HOWTO (90), /* unallocated */
979 EMPTY_HOWTO (91),
980 EMPTY_HOWTO (92),
981 EMPTY_HOWTO (93),
982
983 HOWTO (R_ARM_PLT32_ABS, /* type */
984 0, /* rightshift */
985 2, /* size (0 = byte, 1 = short, 2 = long) */
986 32, /* bitsize */
987 FALSE, /* pc_relative */
988 0, /* bitpos */
989 complain_overflow_dont,/* complain_on_overflow */
990 bfd_elf_generic_reloc, /* special_function */
991 "R_ARM_PLT32_ABS", /* name */
992 FALSE, /* partial_inplace */
993 0xffffffff, /* src_mask */
994 0xffffffff, /* dst_mask */
995 FALSE), /* pcrel_offset */
996
997 HOWTO (R_ARM_GOT_ABS, /* type */
998 0, /* rightshift */
999 2, /* size (0 = byte, 1 = short, 2 = long) */
1000 32, /* bitsize */
1001 FALSE, /* pc_relative */
1002 0, /* bitpos */
1003 complain_overflow_dont,/* complain_on_overflow */
1004 bfd_elf_generic_reloc, /* special_function */
1005 "R_ARM_GOT_ABS", /* name */
1006 FALSE, /* partial_inplace */
1007 0xffffffff, /* src_mask */
1008 0xffffffff, /* dst_mask */
1009 FALSE), /* pcrel_offset */
1010
1011 HOWTO (R_ARM_GOT_PREL, /* type */
1012 0, /* rightshift */
1013 2, /* size (0 = byte, 1 = short, 2 = long) */
1014 32, /* bitsize */
1015 TRUE, /* pc_relative */
1016 0, /* bitpos */
1017 complain_overflow_dont, /* complain_on_overflow */
1018 bfd_elf_generic_reloc, /* special_function */
1019 "R_ARM_GOT_PREL", /* name */
1020 FALSE, /* partial_inplace */
1021 0xffffffff, /* src_mask */
1022 0xffffffff, /* dst_mask */
1023 TRUE), /* pcrel_offset */
1024
1025 HOWTO (R_ARM_GOT_BREL12, /* type */
1026 0, /* rightshift */
1027 2, /* size (0 = byte, 1 = short, 2 = long) */
1028 12, /* bitsize */
1029 FALSE, /* pc_relative */
1030 0, /* bitpos */
1031 complain_overflow_bitfield,/* complain_on_overflow */
1032 bfd_elf_generic_reloc, /* special_function */
1033 "R_ARM_GOT_BREL12", /* name */
1034 FALSE, /* partial_inplace */
1035 0x00000fff, /* src_mask */
1036 0x00000fff, /* dst_mask */
1037 FALSE), /* pcrel_offset */
1038
1039 HOWTO (R_ARM_GOTOFF12, /* type */
1040 0, /* rightshift */
1041 2, /* size (0 = byte, 1 = short, 2 = long) */
1042 12, /* bitsize */
1043 FALSE, /* pc_relative */
1044 0, /* bitpos */
1045 complain_overflow_bitfield,/* complain_on_overflow */
1046 bfd_elf_generic_reloc, /* special_function */
1047 "R_ARM_GOTOFF12", /* name */
1048 FALSE, /* partial_inplace */
1049 0x00000fff, /* src_mask */
1050 0x00000fff, /* dst_mask */
1051 FALSE), /* pcrel_offset */
1052
1053 EMPTY_HOWTO (R_ARM_GOTRELAX), /* reserved for future GOT-load optimizations */
1054
1055 /* GNU extension to record C++ vtable member usage */
1056 HOWTO (R_ARM_GNU_VTENTRY, /* type */
1057 0, /* rightshift */
1058 2, /* size (0 = byte, 1 = short, 2 = long) */
1059 0, /* bitsize */
1060 FALSE, /* pc_relative */
1061 0, /* bitpos */
1062 complain_overflow_dont, /* complain_on_overflow */
1063 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
1064 "R_ARM_GNU_VTENTRY", /* name */
1065 FALSE, /* partial_inplace */
1066 0, /* src_mask */
1067 0, /* dst_mask */
1068 FALSE), /* pcrel_offset */
1069
1070 /* GNU extension to record C++ vtable hierarchy */
1071 HOWTO (R_ARM_GNU_VTINHERIT, /* type */
1072 0, /* rightshift */
1073 2, /* size (0 = byte, 1 = short, 2 = long) */
1074 0, /* bitsize */
1075 FALSE, /* pc_relative */
1076 0, /* bitpos */
1077 complain_overflow_dont, /* complain_on_overflow */
1078 NULL, /* special_function */
1079 "R_ARM_GNU_VTINHERIT", /* name */
1080 FALSE, /* partial_inplace */
1081 0, /* src_mask */
1082 0, /* dst_mask */
1083 FALSE), /* pcrel_offset */
1084
1085 HOWTO (R_ARM_THM_JUMP11, /* type */
1086 1, /* rightshift */
1087 1, /* size (0 = byte, 1 = short, 2 = long) */
1088 11, /* bitsize */
1089 TRUE, /* pc_relative */
1090 0, /* bitpos */
1091 complain_overflow_signed, /* complain_on_overflow */
1092 bfd_elf_generic_reloc, /* special_function */
1093 "R_ARM_THM_JUMP11", /* name */
1094 FALSE, /* partial_inplace */
1095 0x000007ff, /* src_mask */
1096 0x000007ff, /* dst_mask */
1097 TRUE), /* pcrel_offset */
1098
1099 HOWTO (R_ARM_THM_JUMP8, /* type */
1100 1, /* rightshift */
1101 1, /* size (0 = byte, 1 = short, 2 = long) */
1102 8, /* bitsize */
1103 TRUE, /* pc_relative */
1104 0, /* bitpos */
1105 complain_overflow_signed, /* complain_on_overflow */
1106 bfd_elf_generic_reloc, /* special_function */
1107 "R_ARM_THM_JUMP8", /* name */
1108 FALSE, /* partial_inplace */
1109 0x000000ff, /* src_mask */
1110 0x000000ff, /* dst_mask */
1111 TRUE), /* pcrel_offset */
1112
1113 /* TLS relocations */
1114 HOWTO (R_ARM_TLS_GD32, /* type */
1115 0, /* rightshift */
1116 2, /* size (0 = byte, 1 = short, 2 = long) */
1117 32, /* bitsize */
1118 FALSE, /* pc_relative */
1119 0, /* bitpos */
1120 complain_overflow_bitfield,/* complain_on_overflow */
1121 NULL, /* special_function */
1122 "R_ARM_TLS_GD32", /* name */
1123 TRUE, /* partial_inplace */
1124 0xffffffff, /* src_mask */
1125 0xffffffff, /* dst_mask */
1126 FALSE), /* pcrel_offset */
1127
1128 HOWTO (R_ARM_TLS_LDM32, /* type */
1129 0, /* rightshift */
1130 2, /* size (0 = byte, 1 = short, 2 = long) */
1131 32, /* bitsize */
1132 FALSE, /* pc_relative */
1133 0, /* bitpos */
1134 complain_overflow_bitfield,/* complain_on_overflow */
1135 bfd_elf_generic_reloc, /* special_function */
1136 "R_ARM_TLS_LDM32", /* name */
1137 TRUE, /* partial_inplace */
1138 0xffffffff, /* src_mask */
1139 0xffffffff, /* dst_mask */
1140 FALSE), /* pcrel_offset */
1141
1142 HOWTO (R_ARM_TLS_LDO32, /* type */
1143 0, /* rightshift */
1144 2, /* size (0 = byte, 1 = short, 2 = long) */
1145 32, /* bitsize */
1146 FALSE, /* pc_relative */
1147 0, /* bitpos */
1148 complain_overflow_bitfield,/* complain_on_overflow */
1149 bfd_elf_generic_reloc, /* special_function */
1150 "R_ARM_TLS_LDO32", /* name */
1151 TRUE, /* partial_inplace */
1152 0xffffffff, /* src_mask */
1153 0xffffffff, /* dst_mask */
1154 FALSE), /* pcrel_offset */
1155
1156 HOWTO (R_ARM_TLS_IE32, /* type */
1157 0, /* rightshift */
1158 2, /* size (0 = byte, 1 = short, 2 = long) */
1159 32, /* bitsize */
1160 FALSE, /* pc_relative */
1161 0, /* bitpos */
1162 complain_overflow_bitfield,/* complain_on_overflow */
1163 NULL, /* special_function */
1164 "R_ARM_TLS_IE32", /* name */
1165 TRUE, /* partial_inplace */
1166 0xffffffff, /* src_mask */
1167 0xffffffff, /* dst_mask */
1168 FALSE), /* pcrel_offset */
1169
1170 HOWTO (R_ARM_TLS_LE32, /* type */
1171 0, /* rightshift */
1172 2, /* size (0 = byte, 1 = short, 2 = long) */
1173 32, /* bitsize */
1174 FALSE, /* pc_relative */
1175 0, /* bitpos */
1176 complain_overflow_bitfield,/* complain_on_overflow */
1177 bfd_elf_generic_reloc, /* special_function */
1178 "R_ARM_TLS_LE32", /* name */
1179 TRUE, /* partial_inplace */
1180 0xffffffff, /* src_mask */
1181 0xffffffff, /* dst_mask */
1182 FALSE), /* pcrel_offset */
1183
1184 HOWTO (R_ARM_TLS_LDO12, /* type */
1185 0, /* rightshift */
1186 2, /* size (0 = byte, 1 = short, 2 = long) */
1187 12, /* bitsize */
1188 FALSE, /* pc_relative */
1189 0, /* bitpos */
1190 complain_overflow_bitfield,/* complain_on_overflow */
1191 bfd_elf_generic_reloc, /* special_function */
1192 "R_ARM_TLS_LDO12", /* name */
1193 FALSE, /* partial_inplace */
1194 0x00000fff, /* src_mask */
1195 0x00000fff, /* dst_mask */
1196 FALSE), /* pcrel_offset */
1197
1198 HOWTO (R_ARM_TLS_LE12, /* type */
1199 0, /* rightshift */
1200 2, /* size (0 = byte, 1 = short, 2 = long) */
1201 12, /* bitsize */
1202 FALSE, /* pc_relative */
1203 0, /* bitpos */
1204 complain_overflow_bitfield,/* complain_on_overflow */
1205 bfd_elf_generic_reloc, /* special_function */
1206 "R_ARM_TLS_LE12", /* name */
1207 FALSE, /* partial_inplace */
1208 0x00000fff, /* src_mask */
1209 0x00000fff, /* dst_mask */
1210 FALSE), /* pcrel_offset */
1211
1212 HOWTO (R_ARM_TLS_IE12GP, /* type */
1213 0, /* rightshift */
1214 2, /* size (0 = byte, 1 = short, 2 = long) */
1215 12, /* bitsize */
1216 FALSE, /* pc_relative */
1217 0, /* bitpos */
1218 complain_overflow_bitfield,/* complain_on_overflow */
1219 bfd_elf_generic_reloc, /* special_function */
1220 "R_ARM_TLS_IE12GP", /* name */
1221 FALSE, /* partial_inplace */
1222 0x00000fff, /* src_mask */
1223 0x00000fff, /* dst_mask */
1224 FALSE), /* pcrel_offset */
1225 };
1226
1227 /* 112-127 private relocations
1228 128 R_ARM_ME_TOO, obsolete
1229 129-255 unallocated in AAELF.
1230
1231 249-255 extended, currently unused, relocations: */
1232
1233 static reloc_howto_type elf32_arm_howto_table_3[4] =
1234 {
1235 HOWTO (R_ARM_RREL32, /* type */
1236 0, /* rightshift */
1237 0, /* size (0 = byte, 1 = short, 2 = long) */
1238 0, /* bitsize */
1239 FALSE, /* pc_relative */
1240 0, /* bitpos */
1241 complain_overflow_dont,/* complain_on_overflow */
1242 bfd_elf_generic_reloc, /* special_function */
1243 "R_ARM_RREL32", /* name */
1244 FALSE, /* partial_inplace */
1245 0, /* src_mask */
1246 0, /* dst_mask */
1247 FALSE), /* pcrel_offset */
1248
1249 HOWTO (R_ARM_RABS32, /* type */
1250 0, /* rightshift */
1251 0, /* size (0 = byte, 1 = short, 2 = long) */
1252 0, /* bitsize */
1253 FALSE, /* pc_relative */
1254 0, /* bitpos */
1255 complain_overflow_dont,/* complain_on_overflow */
1256 bfd_elf_generic_reloc, /* special_function */
1257 "R_ARM_RABS32", /* name */
1258 FALSE, /* partial_inplace */
1259 0, /* src_mask */
1260 0, /* dst_mask */
1261 FALSE), /* pcrel_offset */
1262
1263 HOWTO (R_ARM_RPC24, /* type */
1264 0, /* rightshift */
1265 0, /* size (0 = byte, 1 = short, 2 = long) */
1266 0, /* bitsize */
1267 FALSE, /* pc_relative */
1268 0, /* bitpos */
1269 complain_overflow_dont,/* complain_on_overflow */
1270 bfd_elf_generic_reloc, /* special_function */
1271 "R_ARM_RPC24", /* name */
1272 FALSE, /* partial_inplace */
1273 0, /* src_mask */
1274 0, /* dst_mask */
1275 FALSE), /* pcrel_offset */
1276
1277 HOWTO (R_ARM_RBASE, /* type */
1278 0, /* rightshift */
1279 0, /* size (0 = byte, 1 = short, 2 = long) */
1280 0, /* bitsize */
1281 FALSE, /* pc_relative */
1282 0, /* bitpos */
1283 complain_overflow_dont,/* complain_on_overflow */
1284 bfd_elf_generic_reloc, /* special_function */
1285 "R_ARM_RBASE", /* name */
1286 FALSE, /* partial_inplace */
1287 0, /* src_mask */
1288 0, /* dst_mask */
1289 FALSE) /* pcrel_offset */
1290 };
1291
1292 static reloc_howto_type *
1293 elf32_arm_howto_from_type (unsigned int r_type)
1294 {
1295 if (r_type < NUM_ELEM (elf32_arm_howto_table_1))
1296 return &elf32_arm_howto_table_1[r_type];
1297
1298 if (r_type >= R_ARM_MOVW_BREL_NC
1299 && r_type < R_ARM_MOVW_BREL_NC + NUM_ELEM (elf32_arm_howto_table_2))
1300 return &elf32_arm_howto_table_2[r_type - R_ARM_MOVW_BREL_NC];
1301
1302 if (r_type >= R_ARM_RREL32
1303 && r_type < R_ARM_RREL32 + NUM_ELEM (elf32_arm_howto_table_2))
1304 return &elf32_arm_howto_table_3[r_type - R_ARM_RREL32];
1305
1306 return NULL;
1307 }
1308
1309 static void
1310 elf32_arm_info_to_howto (bfd * abfd ATTRIBUTE_UNUSED, arelent * bfd_reloc,
1311 Elf_Internal_Rela * elf_reloc)
1312 {
1313 unsigned int r_type;
1314
1315 r_type = ELF32_R_TYPE (elf_reloc->r_info);
1316 bfd_reloc->howto = elf32_arm_howto_from_type (r_type);
1317 }
1318
1319 struct elf32_arm_reloc_map
1320 {
1321 bfd_reloc_code_real_type bfd_reloc_val;
1322 unsigned char elf_reloc_val;
1323 };
1324
1325 /* All entries in this list must also be present in elf32_arm_howto_table. */
1326 static const struct elf32_arm_reloc_map elf32_arm_reloc_map[] =
1327 {
1328 {BFD_RELOC_NONE, R_ARM_NONE},
1329 {BFD_RELOC_ARM_PCREL_BRANCH, R_ARM_PC24},
1330 {BFD_RELOC_ARM_PCREL_CALL, R_ARM_CALL},
1331 {BFD_RELOC_ARM_PCREL_JUMP, R_ARM_JUMP24},
1332 {BFD_RELOC_ARM_PCREL_BLX, R_ARM_XPC25},
1333 {BFD_RELOC_THUMB_PCREL_BLX, R_ARM_THM_XPC22},
1334 {BFD_RELOC_32, R_ARM_ABS32},
1335 {BFD_RELOC_32_PCREL, R_ARM_REL32},
1336 {BFD_RELOC_8, R_ARM_ABS8},
1337 {BFD_RELOC_16, R_ARM_ABS16},
1338 {BFD_RELOC_ARM_OFFSET_IMM, R_ARM_ABS12},
1339 {BFD_RELOC_ARM_THUMB_OFFSET, R_ARM_THM_ABS5},
1340 {BFD_RELOC_THUMB_PCREL_BRANCH25, R_ARM_THM_JUMP24},
1341 {BFD_RELOC_THUMB_PCREL_BRANCH23, R_ARM_THM_CALL},
1342 {BFD_RELOC_THUMB_PCREL_BRANCH12, R_ARM_THM_JUMP11},
1343 {BFD_RELOC_THUMB_PCREL_BRANCH20, R_ARM_THM_JUMP19},
1344 {BFD_RELOC_THUMB_PCREL_BRANCH9, R_ARM_THM_JUMP8},
1345 {BFD_RELOC_THUMB_PCREL_BRANCH7, R_ARM_THM_JUMP6},
1346 {BFD_RELOC_ARM_GLOB_DAT, R_ARM_GLOB_DAT},
1347 {BFD_RELOC_ARM_JUMP_SLOT, R_ARM_JUMP_SLOT},
1348 {BFD_RELOC_ARM_RELATIVE, R_ARM_RELATIVE},
1349 {BFD_RELOC_ARM_GOTOFF, R_ARM_GOTOFF32},
1350 {BFD_RELOC_ARM_GOTPC, R_ARM_GOTPC},
1351 {BFD_RELOC_ARM_GOT32, R_ARM_GOT32},
1352 {BFD_RELOC_ARM_PLT32, R_ARM_PLT32},
1353 {BFD_RELOC_ARM_TARGET1, R_ARM_TARGET1},
1354 {BFD_RELOC_ARM_ROSEGREL32, R_ARM_ROSEGREL32},
1355 {BFD_RELOC_ARM_SBREL32, R_ARM_SBREL32},
1356 {BFD_RELOC_ARM_PREL31, R_ARM_PREL31},
1357 {BFD_RELOC_ARM_TARGET2, R_ARM_TARGET2},
1358 {BFD_RELOC_ARM_PLT32, R_ARM_PLT32},
1359 {BFD_RELOC_ARM_TLS_GD32, R_ARM_TLS_GD32},
1360 {BFD_RELOC_ARM_TLS_LDO32, R_ARM_TLS_LDO32},
1361 {BFD_RELOC_ARM_TLS_LDM32, R_ARM_TLS_LDM32},
1362 {BFD_RELOC_ARM_TLS_DTPMOD32, R_ARM_TLS_DTPMOD32},
1363 {BFD_RELOC_ARM_TLS_DTPOFF32, R_ARM_TLS_DTPOFF32},
1364 {BFD_RELOC_ARM_TLS_TPOFF32, R_ARM_TLS_TPOFF32},
1365 {BFD_RELOC_ARM_TLS_IE32, R_ARM_TLS_IE32},
1366 {BFD_RELOC_ARM_TLS_LE32, R_ARM_TLS_LE32},
1367 {BFD_RELOC_VTABLE_INHERIT, R_ARM_GNU_VTINHERIT},
1368 {BFD_RELOC_VTABLE_ENTRY, R_ARM_GNU_VTENTRY},
1369 {BFD_RELOC_ARM_MOVW, R_ARM_MOVW_ABS_NC},
1370 {BFD_RELOC_ARM_MOVT, R_ARM_MOVT_ABS},
1371 {BFD_RELOC_ARM_MOVW_PCREL, R_ARM_MOVW_PREL_NC},
1372 {BFD_RELOC_ARM_MOVT_PCREL, R_ARM_MOVT_PREL},
1373 {BFD_RELOC_ARM_THUMB_MOVW, R_ARM_THM_MOVW_ABS_NC},
1374 {BFD_RELOC_ARM_THUMB_MOVT, R_ARM_THM_MOVT_ABS},
1375 {BFD_RELOC_ARM_THUMB_MOVW_PCREL, R_ARM_THM_MOVW_PREL_NC},
1376 {BFD_RELOC_ARM_THUMB_MOVT_PCREL, R_ARM_THM_MOVT_PREL},
1377 };
1378
1379 static reloc_howto_type *
1380 elf32_arm_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1381 bfd_reloc_code_real_type code)
1382 {
1383 unsigned int i;
1384 for (i = 0; i < NUM_ELEM (elf32_arm_reloc_map); i ++)
1385 if (elf32_arm_reloc_map[i].bfd_reloc_val == code)
1386 return elf32_arm_howto_from_type (elf32_arm_reloc_map[i].elf_reloc_val);
1387
1388 return NULL;
1389 }
1390
1391 /* Support for core dump NOTE sections */
1392 static bfd_boolean
1393 elf32_arm_nabi_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
1394 {
1395 int offset;
1396 size_t size;
1397
1398 switch (note->descsz)
1399 {
1400 default:
1401 return FALSE;
1402
1403 case 148: /* Linux/ARM 32-bit*/
1404 /* pr_cursig */
1405 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
1406
1407 /* pr_pid */
1408 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
1409
1410 /* pr_reg */
1411 offset = 72;
1412 size = 72;
1413
1414 break;
1415 }
1416
1417 /* Make a ".reg/999" section. */
1418 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
1419 size, note->descpos + offset);
1420 }
1421
1422 static bfd_boolean
1423 elf32_arm_nabi_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
1424 {
1425 switch (note->descsz)
1426 {
1427 default:
1428 return FALSE;
1429
1430 case 124: /* Linux/ARM elf_prpsinfo */
1431 elf_tdata (abfd)->core_program
1432 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
1433 elf_tdata (abfd)->core_command
1434 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
1435 }
1436
1437 /* Note that for some reason, a spurious space is tacked
1438 onto the end of the args in some (at least one anyway)
1439 implementations, so strip it off if it exists. */
1440
1441 {
1442 char *command = elf_tdata (abfd)->core_command;
1443 int n = strlen (command);
1444
1445 if (0 < n && command[n - 1] == ' ')
1446 command[n - 1] = '\0';
1447 }
1448
1449 return TRUE;
1450 }
1451
1452 #define TARGET_LITTLE_SYM bfd_elf32_littlearm_vec
1453 #define TARGET_LITTLE_NAME "elf32-littlearm"
1454 #define TARGET_BIG_SYM bfd_elf32_bigarm_vec
1455 #define TARGET_BIG_NAME "elf32-bigarm"
1456
1457 #define elf_backend_grok_prstatus elf32_arm_nabi_grok_prstatus
1458 #define elf_backend_grok_psinfo elf32_arm_nabi_grok_psinfo
1459
1460 typedef unsigned long int insn32;
1461 typedef unsigned short int insn16;
1462
1463 /* In lieu of proper flags, assume all EABIv4 or later objects are
1464 interworkable. */
1465 #define INTERWORK_FLAG(abfd) \
1466 (EF_ARM_EABI_VERSION (elf_elfheader (abfd)->e_flags) >= EF_ARM_EABI_VER4 \
1467 || (elf_elfheader (abfd)->e_flags & EF_ARM_INTERWORK))
1468
1469 /* The linker script knows the section names for placement.
1470 The entry_names are used to do simple name mangling on the stubs.
1471 Given a function name, and its type, the stub can be found. The
1472 name can be changed. The only requirement is the %s be present. */
1473 #define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
1474 #define THUMB2ARM_GLUE_ENTRY_NAME "__%s_from_thumb"
1475
1476 #define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
1477 #define ARM2THUMB_GLUE_ENTRY_NAME "__%s_from_arm"
1478
1479 /* The name of the dynamic interpreter. This is put in the .interp
1480 section. */
1481 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
1482
1483 #ifdef FOUR_WORD_PLT
1484
1485 /* The first entry in a procedure linkage table looks like
1486 this. It is set up so that any shared library function that is
1487 called before the relocation has been set up calls the dynamic
1488 linker first. */
1489 static const bfd_vma elf32_arm_plt0_entry [] =
1490 {
1491 0xe52de004, /* str lr, [sp, #-4]! */
1492 0xe59fe010, /* ldr lr, [pc, #16] */
1493 0xe08fe00e, /* add lr, pc, lr */
1494 0xe5bef008, /* ldr pc, [lr, #8]! */
1495 };
1496
1497 /* Subsequent entries in a procedure linkage table look like
1498 this. */
1499 static const bfd_vma elf32_arm_plt_entry [] =
1500 {
1501 0xe28fc600, /* add ip, pc, #NN */
1502 0xe28cca00, /* add ip, ip, #NN */
1503 0xe5bcf000, /* ldr pc, [ip, #NN]! */
1504 0x00000000, /* unused */
1505 };
1506
1507 #else
1508
1509 /* The first entry in a procedure linkage table looks like
1510 this. It is set up so that any shared library function that is
1511 called before the relocation has been set up calls the dynamic
1512 linker first. */
1513 static const bfd_vma elf32_arm_plt0_entry [] =
1514 {
1515 0xe52de004, /* str lr, [sp, #-4]! */
1516 0xe59fe004, /* ldr lr, [pc, #4] */
1517 0xe08fe00e, /* add lr, pc, lr */
1518 0xe5bef008, /* ldr pc, [lr, #8]! */
1519 0x00000000, /* &GOT[0] - . */
1520 };
1521
1522 /* Subsequent entries in a procedure linkage table look like
1523 this. */
1524 static const bfd_vma elf32_arm_plt_entry [] =
1525 {
1526 0xe28fc600, /* add ip, pc, #0xNN00000 */
1527 0xe28cca00, /* add ip, ip, #0xNN000 */
1528 0xe5bcf000, /* ldr pc, [ip, #0xNNN]! */
1529 };
1530
1531 #endif
1532
1533 /* The format of the first entry in the procedure linkage table
1534 for a VxWorks executable. */
1535 static const bfd_vma elf32_arm_vxworks_exec_plt0_entry[] =
1536 {
1537 0xe52dc008, /* str ip,[sp,#-8]! */
1538 0xe59fc000, /* ldr ip,[pc] */
1539 0xe59cf008, /* ldr pc,[ip,#8] */
1540 0x00000000, /* .long _GLOBAL_OFFSET_TABLE_ */
1541 };
1542
1543 /* The format of subsequent entries in a VxWorks executable. */
1544 static const bfd_vma elf32_arm_vxworks_exec_plt_entry[] =
1545 {
1546 0xe59fc000, /* ldr ip,[pc] */
1547 0xe59cf000, /* ldr pc,[ip] */
1548 0x00000000, /* .long @got */
1549 0xe59fc000, /* ldr ip,[pc] */
1550 0xea000000, /* b _PLT */
1551 0x00000000, /* .long @pltindex*sizeof(Elf32_Rela) */
1552 };
1553
1554 /* The format of entries in a VxWorks shared library. */
1555 static const bfd_vma elf32_arm_vxworks_shared_plt_entry[] =
1556 {
1557 0xe59fc000, /* ldr ip,[pc] */
1558 0xe79cf009, /* ldr pc,[ip,r9] */
1559 0x00000000, /* .long @got */
1560 0xe59fc000, /* ldr ip,[pc] */
1561 0xe599f008, /* ldr pc,[r9,#8] */
1562 0x00000000, /* .long @pltindex*sizeof(Elf32_Rela) */
1563 };
1564
1565 /* An initial stub used if the PLT entry is referenced from Thumb code. */
1566 #define PLT_THUMB_STUB_SIZE 4
1567 static const bfd_vma elf32_arm_plt_thumb_stub [] =
1568 {
1569 0x4778, /* bx pc */
1570 0x46c0 /* nop */
1571 };
1572
1573 /* The entries in a PLT when using a DLL-based target with multiple
1574 address spaces. */
1575 static const bfd_vma elf32_arm_symbian_plt_entry [] =
1576 {
1577 0xe51ff004, /* ldr pc, [pc, #-4] */
1578 0x00000000, /* dcd R_ARM_GLOB_DAT(X) */
1579 };
1580
1581 /* Used to build a map of a section. This is required for mixed-endian
1582 code/data. */
1583
1584 typedef struct elf32_elf_section_map
1585 {
1586 bfd_vma vma;
1587 char type;
1588 }
1589 elf32_arm_section_map;
1590
1591 typedef struct _arm_elf_section_data
1592 {
1593 struct bfd_elf_section_data elf;
1594 unsigned int mapcount;
1595 elf32_arm_section_map *map;
1596 }
1597 _arm_elf_section_data;
1598
1599 #define elf32_arm_section_data(sec) \
1600 ((_arm_elf_section_data *) elf_section_data (sec))
1601
1602 /* The size of the thread control block. */
1603 #define TCB_SIZE 8
1604
1605 #define NUM_KNOWN_ATTRIBUTES 32
1606
1607 typedef struct aeabi_attribute
1608 {
1609 int type;
1610 unsigned int i;
1611 char *s;
1612 } aeabi_attribute;
1613
1614 typedef struct aeabi_attribute_list
1615 {
1616 struct aeabi_attribute_list *next;
1617 int tag;
1618 aeabi_attribute attr;
1619 } aeabi_attribute_list;
1620
1621 struct elf32_arm_obj_tdata
1622 {
1623 struct elf_obj_tdata root;
1624
1625 /* tls_type for each local got entry. */
1626 char *local_got_tls_type;
1627
1628 aeabi_attribute known_eabi_attributes[NUM_KNOWN_ATTRIBUTES];
1629 aeabi_attribute_list *other_eabi_attributes;
1630 };
1631
1632 #define elf32_arm_tdata(abfd) \
1633 ((struct elf32_arm_obj_tdata *) (abfd)->tdata.any)
1634
1635 #define elf32_arm_local_got_tls_type(abfd) \
1636 (elf32_arm_tdata (abfd)->local_got_tls_type)
1637
1638 static bfd_boolean
1639 elf32_arm_mkobject (bfd *abfd)
1640 {
1641 bfd_size_type amt = sizeof (struct elf32_arm_obj_tdata);
1642 abfd->tdata.any = bfd_zalloc (abfd, amt);
1643 if (abfd->tdata.any == NULL)
1644 return FALSE;
1645 return TRUE;
1646 }
1647
1648 /* The ARM linker needs to keep track of the number of relocs that it
1649 decides to copy in check_relocs for each symbol. This is so that
1650 it can discard PC relative relocs if it doesn't need them when
1651 linking with -Bsymbolic. We store the information in a field
1652 extending the regular ELF linker hash table. */
1653
1654 /* This structure keeps track of the number of relocs we have copied
1655 for a given symbol. */
1656 struct elf32_arm_relocs_copied
1657 {
1658 /* Next section. */
1659 struct elf32_arm_relocs_copied * next;
1660 /* A section in dynobj. */
1661 asection * section;
1662 /* Number of relocs copied in this section. */
1663 bfd_size_type count;
1664 /* Number of PC-relative relocs copied in this section. */
1665 bfd_size_type pc_count;
1666 };
1667
1668 #define elf32_arm_hash_entry(ent) ((struct elf32_arm_link_hash_entry *)(ent))
1669
1670 /* Arm ELF linker hash entry. */
1671 struct elf32_arm_link_hash_entry
1672 {
1673 struct elf_link_hash_entry root;
1674
1675 /* Number of PC relative relocs copied for this symbol. */
1676 struct elf32_arm_relocs_copied * relocs_copied;
1677
1678 /* We reference count Thumb references to a PLT entry separately,
1679 so that we can emit the Thumb trampoline only if needed. */
1680 bfd_signed_vma plt_thumb_refcount;
1681
1682 /* Since PLT entries have variable size if the Thumb prologue is
1683 used, we need to record the index into .got.plt instead of
1684 recomputing it from the PLT offset. */
1685 bfd_signed_vma plt_got_offset;
1686
1687 #define GOT_UNKNOWN 0
1688 #define GOT_NORMAL 1
1689 #define GOT_TLS_GD 2
1690 #define GOT_TLS_IE 4
1691 unsigned char tls_type;
1692 };
1693
1694 /* Traverse an arm ELF linker hash table. */
1695 #define elf32_arm_link_hash_traverse(table, func, info) \
1696 (elf_link_hash_traverse \
1697 (&(table)->root, \
1698 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
1699 (info)))
1700
1701 /* Get the ARM elf linker hash table from a link_info structure. */
1702 #define elf32_arm_hash_table(info) \
1703 ((struct elf32_arm_link_hash_table *) ((info)->hash))
1704
1705 /* ARM ELF linker hash table. */
1706 struct elf32_arm_link_hash_table
1707 {
1708 /* The main hash table. */
1709 struct elf_link_hash_table root;
1710
1711 /* The size in bytes of the section containing the Thumb-to-ARM glue. */
1712 bfd_size_type thumb_glue_size;
1713
1714 /* The size in bytes of the section containing the ARM-to-Thumb glue. */
1715 bfd_size_type arm_glue_size;
1716
1717 /* An arbitrary input BFD chosen to hold the glue sections. */
1718 bfd * bfd_of_glue_owner;
1719
1720 /* Nonzero to output a BE8 image. */
1721 int byteswap_code;
1722
1723 /* Zero if R_ARM_TARGET1 means R_ARM_ABS32.
1724 Nonzero if R_ARM_TARGET1 means R_ARM_ABS32. */
1725 int target1_is_rel;
1726
1727 /* The relocation to use for R_ARM_TARGET2 relocations. */
1728 int target2_reloc;
1729
1730 /* Nonzero to fix BX instructions for ARMv4 targets. */
1731 int fix_v4bx;
1732
1733 /* Nonzero if the ARM/Thumb BLX instructions are available for use. */
1734 int use_blx;
1735
1736 /* The number of bytes in the initial entry in the PLT. */
1737 bfd_size_type plt_header_size;
1738
1739 /* The number of bytes in the subsequent PLT etries. */
1740 bfd_size_type plt_entry_size;
1741
1742 /* True if the target system is VxWorks. */
1743 int vxworks_p;
1744
1745 /* True if the target system is Symbian OS. */
1746 int symbian_p;
1747
1748 /* True if the target uses REL relocations. */
1749 int use_rel;
1750
1751 /* Short-cuts to get to dynamic linker sections. */
1752 asection *sgot;
1753 asection *sgotplt;
1754 asection *srelgot;
1755 asection *splt;
1756 asection *srelplt;
1757 asection *sdynbss;
1758 asection *srelbss;
1759
1760 /* The (unloaded but important) VxWorks .rela.plt.unloaded section. */
1761 asection *srelplt2;
1762
1763 /* Data for R_ARM_TLS_LDM32 relocations. */
1764 union {
1765 bfd_signed_vma refcount;
1766 bfd_vma offset;
1767 } tls_ldm_got;
1768
1769 /* Small local sym to section mapping cache. */
1770 struct sym_sec_cache sym_sec;
1771
1772 /* For convenience in allocate_dynrelocs. */
1773 bfd * obfd;
1774 };
1775
1776 /* Create an entry in an ARM ELF linker hash table. */
1777
1778 static struct bfd_hash_entry *
1779 elf32_arm_link_hash_newfunc (struct bfd_hash_entry * entry,
1780 struct bfd_hash_table * table,
1781 const char * string)
1782 {
1783 struct elf32_arm_link_hash_entry * ret =
1784 (struct elf32_arm_link_hash_entry *) entry;
1785
1786 /* Allocate the structure if it has not already been allocated by a
1787 subclass. */
1788 if (ret == (struct elf32_arm_link_hash_entry *) NULL)
1789 ret = bfd_hash_allocate (table, sizeof (struct elf32_arm_link_hash_entry));
1790 if (ret == NULL)
1791 return (struct bfd_hash_entry *) ret;
1792
1793 /* Call the allocation method of the superclass. */
1794 ret = ((struct elf32_arm_link_hash_entry *)
1795 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
1796 table, string));
1797 if (ret != NULL)
1798 {
1799 ret->relocs_copied = NULL;
1800 ret->tls_type = GOT_UNKNOWN;
1801 ret->plt_thumb_refcount = 0;
1802 ret->plt_got_offset = -1;
1803 }
1804
1805 return (struct bfd_hash_entry *) ret;
1806 }
1807
1808 /* Return true if NAME is the name of the relocation section associated
1809 with S. */
1810
1811 static bfd_boolean
1812 reloc_section_p (struct elf32_arm_link_hash_table *htab,
1813 const char *name, asection *s)
1814 {
1815 if (htab->use_rel)
1816 return strncmp (name, ".rel", 4) == 0 && strcmp (s->name, name + 4) == 0;
1817 else
1818 return strncmp (name, ".rela", 5) == 0 && strcmp (s->name, name + 5) == 0;
1819 }
1820
1821 /* Create .got, .gotplt, and .rel(a).got sections in DYNOBJ, and set up
1822 shortcuts to them in our hash table. */
1823
1824 static bfd_boolean
1825 create_got_section (bfd *dynobj, struct bfd_link_info *info)
1826 {
1827 struct elf32_arm_link_hash_table *htab;
1828
1829 htab = elf32_arm_hash_table (info);
1830 /* BPABI objects never have a GOT, or associated sections. */
1831 if (htab->symbian_p)
1832 return TRUE;
1833
1834 if (! _bfd_elf_create_got_section (dynobj, info))
1835 return FALSE;
1836
1837 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
1838 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
1839 if (!htab->sgot || !htab->sgotplt)
1840 abort ();
1841
1842 htab->srelgot = bfd_make_section_with_flags (dynobj,
1843 RELOC_SECTION (htab, ".got"),
1844 (SEC_ALLOC | SEC_LOAD
1845 | SEC_HAS_CONTENTS
1846 | SEC_IN_MEMORY
1847 | SEC_LINKER_CREATED
1848 | SEC_READONLY));
1849 if (htab->srelgot == NULL
1850 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
1851 return FALSE;
1852 return TRUE;
1853 }
1854
1855 /* Create .plt, .rel(a).plt, .got, .got.plt, .rel(a).got, .dynbss, and
1856 .rel(a).bss sections in DYNOBJ, and set up shortcuts to them in our
1857 hash table. */
1858
1859 static bfd_boolean
1860 elf32_arm_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
1861 {
1862 struct elf32_arm_link_hash_table *htab;
1863
1864 htab = elf32_arm_hash_table (info);
1865 if (!htab->sgot && !create_got_section (dynobj, info))
1866 return FALSE;
1867
1868 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
1869 return FALSE;
1870
1871 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
1872 htab->srelplt = bfd_get_section_by_name (dynobj,
1873 RELOC_SECTION (htab, ".plt"));
1874 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
1875 if (!info->shared)
1876 htab->srelbss = bfd_get_section_by_name (dynobj,
1877 RELOC_SECTION (htab, ".bss"));
1878
1879 if (htab->vxworks_p)
1880 {
1881 if (!elf_vxworks_create_dynamic_sections (dynobj, info, &htab->srelplt2))
1882 return FALSE;
1883
1884 if (info->shared)
1885 {
1886 htab->plt_header_size = 0;
1887 htab->plt_entry_size
1888 = 4 * ARRAY_SIZE (elf32_arm_vxworks_shared_plt_entry);
1889 }
1890 else
1891 {
1892 htab->plt_header_size
1893 = 4 * ARRAY_SIZE (elf32_arm_vxworks_exec_plt0_entry);
1894 htab->plt_entry_size
1895 = 4 * ARRAY_SIZE (elf32_arm_vxworks_exec_plt_entry);
1896 }
1897 }
1898
1899 if (!htab->splt
1900 || !htab->srelplt
1901 || !htab->sdynbss
1902 || (!info->shared && !htab->srelbss))
1903 abort ();
1904
1905 return TRUE;
1906 }
1907
1908 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1909
1910 static void
1911 elf32_arm_copy_indirect_symbol (struct bfd_link_info *info,
1912 struct elf_link_hash_entry *dir,
1913 struct elf_link_hash_entry *ind)
1914 {
1915 struct elf32_arm_link_hash_entry *edir, *eind;
1916
1917 edir = (struct elf32_arm_link_hash_entry *) dir;
1918 eind = (struct elf32_arm_link_hash_entry *) ind;
1919
1920 if (eind->relocs_copied != NULL)
1921 {
1922 if (edir->relocs_copied != NULL)
1923 {
1924 struct elf32_arm_relocs_copied **pp;
1925 struct elf32_arm_relocs_copied *p;
1926
1927 /* Add reloc counts against the indirect sym to the direct sym
1928 list. Merge any entries against the same section. */
1929 for (pp = &eind->relocs_copied; (p = *pp) != NULL; )
1930 {
1931 struct elf32_arm_relocs_copied *q;
1932
1933 for (q = edir->relocs_copied; q != NULL; q = q->next)
1934 if (q->section == p->section)
1935 {
1936 q->pc_count += p->pc_count;
1937 q->count += p->count;
1938 *pp = p->next;
1939 break;
1940 }
1941 if (q == NULL)
1942 pp = &p->next;
1943 }
1944 *pp = edir->relocs_copied;
1945 }
1946
1947 edir->relocs_copied = eind->relocs_copied;
1948 eind->relocs_copied = NULL;
1949 }
1950
1951 /* Copy over PLT info. */
1952 edir->plt_thumb_refcount += eind->plt_thumb_refcount;
1953 eind->plt_thumb_refcount = 0;
1954
1955 if (ind->root.type == bfd_link_hash_indirect
1956 && dir->got.refcount <= 0)
1957 {
1958 edir->tls_type = eind->tls_type;
1959 eind->tls_type = GOT_UNKNOWN;
1960 }
1961
1962 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1963 }
1964
1965 /* Create an ARM elf linker hash table. */
1966
1967 static struct bfd_link_hash_table *
1968 elf32_arm_link_hash_table_create (bfd *abfd)
1969 {
1970 struct elf32_arm_link_hash_table *ret;
1971 bfd_size_type amt = sizeof (struct elf32_arm_link_hash_table);
1972
1973 ret = bfd_malloc (amt);
1974 if (ret == NULL)
1975 return NULL;
1976
1977 if (!_bfd_elf_link_hash_table_init (& ret->root, abfd,
1978 elf32_arm_link_hash_newfunc,
1979 sizeof (struct elf32_arm_link_hash_entry)))
1980 {
1981 free (ret);
1982 return NULL;
1983 }
1984
1985 ret->sgot = NULL;
1986 ret->sgotplt = NULL;
1987 ret->srelgot = NULL;
1988 ret->splt = NULL;
1989 ret->srelplt = NULL;
1990 ret->sdynbss = NULL;
1991 ret->srelbss = NULL;
1992 ret->srelplt2 = NULL;
1993 ret->thumb_glue_size = 0;
1994 ret->arm_glue_size = 0;
1995 ret->bfd_of_glue_owner = NULL;
1996 ret->byteswap_code = 0;
1997 ret->target1_is_rel = 0;
1998 ret->target2_reloc = R_ARM_NONE;
1999 #ifdef FOUR_WORD_PLT
2000 ret->plt_header_size = 16;
2001 ret->plt_entry_size = 16;
2002 #else
2003 ret->plt_header_size = 20;
2004 ret->plt_entry_size = 12;
2005 #endif
2006 ret->fix_v4bx = 0;
2007 ret->use_blx = 0;
2008 ret->vxworks_p = 0;
2009 ret->symbian_p = 0;
2010 ret->use_rel = 1;
2011 ret->sym_sec.abfd = NULL;
2012 ret->obfd = abfd;
2013 ret->tls_ldm_got.refcount = 0;
2014
2015 return &ret->root.root;
2016 }
2017
2018 /* Locate the Thumb encoded calling stub for NAME. */
2019
2020 static struct elf_link_hash_entry *
2021 find_thumb_glue (struct bfd_link_info *link_info,
2022 const char *name,
2023 bfd *input_bfd)
2024 {
2025 char *tmp_name;
2026 struct elf_link_hash_entry *hash;
2027 struct elf32_arm_link_hash_table *hash_table;
2028
2029 /* We need a pointer to the armelf specific hash table. */
2030 hash_table = elf32_arm_hash_table (link_info);
2031
2032 tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
2033 + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
2034
2035 BFD_ASSERT (tmp_name);
2036
2037 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
2038
2039 hash = elf_link_hash_lookup
2040 (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
2041
2042 if (hash == NULL)
2043 /* xgettext:c-format */
2044 (*_bfd_error_handler) (_("%B: unable to find THUMB glue '%s' for `%s'"),
2045 input_bfd, tmp_name, name);
2046
2047 free (tmp_name);
2048
2049 return hash;
2050 }
2051
2052 /* Locate the ARM encoded calling stub for NAME. */
2053
2054 static struct elf_link_hash_entry *
2055 find_arm_glue (struct bfd_link_info *link_info,
2056 const char *name,
2057 bfd *input_bfd)
2058 {
2059 char *tmp_name;
2060 struct elf_link_hash_entry *myh;
2061 struct elf32_arm_link_hash_table *hash_table;
2062
2063 /* We need a pointer to the elfarm specific hash table. */
2064 hash_table = elf32_arm_hash_table (link_info);
2065
2066 tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
2067 + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
2068
2069 BFD_ASSERT (tmp_name);
2070
2071 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
2072
2073 myh = elf_link_hash_lookup
2074 (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
2075
2076 if (myh == NULL)
2077 /* xgettext:c-format */
2078 (*_bfd_error_handler) (_("%B: unable to find ARM glue '%s' for `%s'"),
2079 input_bfd, tmp_name, name);
2080
2081 free (tmp_name);
2082
2083 return myh;
2084 }
2085
2086 /* ARM->Thumb glue (static images):
2087
2088 .arm
2089 __func_from_arm:
2090 ldr r12, __func_addr
2091 bx r12
2092 __func_addr:
2093 .word func @ behave as if you saw a ARM_32 reloc.
2094
2095 (relocatable images)
2096 .arm
2097 __func_from_arm:
2098 ldr r12, __func_offset
2099 add r12, r12, pc
2100 bx r12
2101 __func_offset:
2102 .word func - .
2103 */
2104
2105 #define ARM2THUMB_STATIC_GLUE_SIZE 12
2106 static const insn32 a2t1_ldr_insn = 0xe59fc000;
2107 static const insn32 a2t2_bx_r12_insn = 0xe12fff1c;
2108 static const insn32 a2t3_func_addr_insn = 0x00000001;
2109
2110 #define ARM2THUMB_PIC_GLUE_SIZE 16
2111 static const insn32 a2t1p_ldr_insn = 0xe59fc004;
2112 static const insn32 a2t2p_add_pc_insn = 0xe08cc00f;
2113 static const insn32 a2t3p_bx_r12_insn = 0xe12fff1c;
2114
2115 /* Thumb->ARM: Thumb->(non-interworking aware) ARM
2116
2117 .thumb .thumb
2118 .align 2 .align 2
2119 __func_from_thumb: __func_from_thumb:
2120 bx pc push {r6, lr}
2121 nop ldr r6, __func_addr
2122 .arm mov lr, pc
2123 __func_change_to_arm: bx r6
2124 b func .arm
2125 __func_back_to_thumb:
2126 ldmia r13! {r6, lr}
2127 bx lr
2128 __func_addr:
2129 .word func */
2130
2131 #define THUMB2ARM_GLUE_SIZE 8
2132 static const insn16 t2a1_bx_pc_insn = 0x4778;
2133 static const insn16 t2a2_noop_insn = 0x46c0;
2134 static const insn32 t2a3_b_insn = 0xea000000;
2135
2136 #ifndef ELFARM_NABI_C_INCLUDED
2137 bfd_boolean
2138 bfd_elf32_arm_allocate_interworking_sections (struct bfd_link_info * info)
2139 {
2140 asection * s;
2141 bfd_byte * foo;
2142 struct elf32_arm_link_hash_table * globals;
2143
2144 globals = elf32_arm_hash_table (info);
2145
2146 BFD_ASSERT (globals != NULL);
2147
2148 if (globals->arm_glue_size != 0)
2149 {
2150 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2151
2152 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
2153 ARM2THUMB_GLUE_SECTION_NAME);
2154
2155 BFD_ASSERT (s != NULL);
2156
2157 foo = bfd_alloc (globals->bfd_of_glue_owner, globals->arm_glue_size);
2158
2159 s->size = globals->arm_glue_size;
2160 s->contents = foo;
2161 }
2162
2163 if (globals->thumb_glue_size != 0)
2164 {
2165 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2166
2167 s = bfd_get_section_by_name
2168 (globals->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
2169
2170 BFD_ASSERT (s != NULL);
2171
2172 foo = bfd_alloc (globals->bfd_of_glue_owner, globals->thumb_glue_size);
2173
2174 s->size = globals->thumb_glue_size;
2175 s->contents = foo;
2176 }
2177
2178 return TRUE;
2179 }
2180
2181 static void
2182 record_arm_to_thumb_glue (struct bfd_link_info * link_info,
2183 struct elf_link_hash_entry * h)
2184 {
2185 const char * name = h->root.root.string;
2186 asection * s;
2187 char * tmp_name;
2188 struct elf_link_hash_entry * myh;
2189 struct bfd_link_hash_entry * bh;
2190 struct elf32_arm_link_hash_table * globals;
2191 bfd_vma val;
2192
2193 globals = elf32_arm_hash_table (link_info);
2194
2195 BFD_ASSERT (globals != NULL);
2196 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2197
2198 s = bfd_get_section_by_name
2199 (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
2200
2201 BFD_ASSERT (s != NULL);
2202
2203 tmp_name = bfd_malloc ((bfd_size_type) strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
2204
2205 BFD_ASSERT (tmp_name);
2206
2207 sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
2208
2209 myh = elf_link_hash_lookup
2210 (&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
2211
2212 if (myh != NULL)
2213 {
2214 /* We've already seen this guy. */
2215 free (tmp_name);
2216 return;
2217 }
2218
2219 /* The only trick here is using hash_table->arm_glue_size as the value.
2220 Even though the section isn't allocated yet, this is where we will be
2221 putting it. */
2222 bh = NULL;
2223 val = globals->arm_glue_size + 1;
2224 _bfd_generic_link_add_one_symbol (link_info, globals->bfd_of_glue_owner,
2225 tmp_name, BSF_GLOBAL, s, val,
2226 NULL, TRUE, FALSE, &bh);
2227
2228 myh = (struct elf_link_hash_entry *) bh;
2229 myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
2230 myh->forced_local = 1;
2231
2232 free (tmp_name);
2233
2234 if ((link_info->shared || globals->root.is_relocatable_executable))
2235 globals->arm_glue_size += ARM2THUMB_PIC_GLUE_SIZE;
2236 else
2237 globals->arm_glue_size += ARM2THUMB_STATIC_GLUE_SIZE;
2238
2239 return;
2240 }
2241
2242 static void
2243 record_thumb_to_arm_glue (struct bfd_link_info *link_info,
2244 struct elf_link_hash_entry *h)
2245 {
2246 const char *name = h->root.root.string;
2247 asection *s;
2248 char *tmp_name;
2249 struct elf_link_hash_entry *myh;
2250 struct bfd_link_hash_entry *bh;
2251 struct elf32_arm_link_hash_table *hash_table;
2252 bfd_vma val;
2253
2254 hash_table = elf32_arm_hash_table (link_info);
2255
2256 BFD_ASSERT (hash_table != NULL);
2257 BFD_ASSERT (hash_table->bfd_of_glue_owner != NULL);
2258
2259 s = bfd_get_section_by_name
2260 (hash_table->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
2261
2262 BFD_ASSERT (s != NULL);
2263
2264 tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
2265 + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
2266
2267 BFD_ASSERT (tmp_name);
2268
2269 sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
2270
2271 myh = elf_link_hash_lookup
2272 (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
2273
2274 if (myh != NULL)
2275 {
2276 /* We've already seen this guy. */
2277 free (tmp_name);
2278 return;
2279 }
2280
2281 bh = NULL;
2282 val = hash_table->thumb_glue_size + 1;
2283 _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
2284 tmp_name, BSF_GLOBAL, s, val,
2285 NULL, TRUE, FALSE, &bh);
2286
2287 /* If we mark it 'Thumb', the disassembler will do a better job. */
2288 myh = (struct elf_link_hash_entry *) bh;
2289 myh->type = ELF_ST_INFO (STB_LOCAL, STT_ARM_TFUNC);
2290 myh->forced_local = 1;
2291
2292 free (tmp_name);
2293
2294 #define CHANGE_TO_ARM "__%s_change_to_arm"
2295 #define BACK_FROM_ARM "__%s_back_from_arm"
2296
2297 /* Allocate another symbol to mark where we switch to Arm mode. */
2298 tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
2299 + strlen (CHANGE_TO_ARM) + 1);
2300
2301 BFD_ASSERT (tmp_name);
2302
2303 sprintf (tmp_name, CHANGE_TO_ARM, name);
2304
2305 bh = NULL;
2306 val = hash_table->thumb_glue_size + 4,
2307 _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
2308 tmp_name, BSF_LOCAL, s, val,
2309 NULL, TRUE, FALSE, &bh);
2310
2311 free (tmp_name);
2312
2313 hash_table->thumb_glue_size += THUMB2ARM_GLUE_SIZE;
2314
2315 return;
2316 }
2317
2318 /* Add the glue sections to ABFD. This function is called from the
2319 linker scripts in ld/emultempl/{armelf}.em. */
2320
2321 bfd_boolean
2322 bfd_elf32_arm_add_glue_sections_to_bfd (bfd *abfd,
2323 struct bfd_link_info *info)
2324 {
2325 flagword flags;
2326 asection *sec;
2327
2328 /* If we are only performing a partial
2329 link do not bother adding the glue. */
2330 if (info->relocatable)
2331 return TRUE;
2332
2333 sec = bfd_get_section_by_name (abfd, ARM2THUMB_GLUE_SECTION_NAME);
2334
2335 if (sec == NULL)
2336 {
2337 /* Note: we do not include the flag SEC_LINKER_CREATED, as this
2338 will prevent elf_link_input_bfd() from processing the contents
2339 of this section. */
2340 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_CODE | SEC_READONLY;
2341
2342 sec = bfd_make_section_with_flags (abfd,
2343 ARM2THUMB_GLUE_SECTION_NAME,
2344 flags);
2345
2346 if (sec == NULL
2347 || !bfd_set_section_alignment (abfd, sec, 2))
2348 return FALSE;
2349
2350 /* Set the gc mark to prevent the section from being removed by garbage
2351 collection, despite the fact that no relocs refer to this section. */
2352 sec->gc_mark = 1;
2353 }
2354
2355 sec = bfd_get_section_by_name (abfd, THUMB2ARM_GLUE_SECTION_NAME);
2356
2357 if (sec == NULL)
2358 {
2359 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2360 | SEC_CODE | SEC_READONLY;
2361
2362 sec = bfd_make_section_with_flags (abfd,
2363 THUMB2ARM_GLUE_SECTION_NAME,
2364 flags);
2365
2366 if (sec == NULL
2367 || !bfd_set_section_alignment (abfd, sec, 2))
2368 return FALSE;
2369
2370 sec->gc_mark = 1;
2371 }
2372
2373 return TRUE;
2374 }
2375
2376 /* Select a BFD to be used to hold the sections used by the glue code.
2377 This function is called from the linker scripts in ld/emultempl/
2378 {armelf/pe}.em */
2379
2380 bfd_boolean
2381 bfd_elf32_arm_get_bfd_for_interworking (bfd *abfd, struct bfd_link_info *info)
2382 {
2383 struct elf32_arm_link_hash_table *globals;
2384
2385 /* If we are only performing a partial link
2386 do not bother getting a bfd to hold the glue. */
2387 if (info->relocatable)
2388 return TRUE;
2389
2390 /* Make sure we don't attach the glue sections to a dynamic object. */
2391 BFD_ASSERT (!(abfd->flags & DYNAMIC));
2392
2393 globals = elf32_arm_hash_table (info);
2394
2395 BFD_ASSERT (globals != NULL);
2396
2397 if (globals->bfd_of_glue_owner != NULL)
2398 return TRUE;
2399
2400 /* Save the bfd for later use. */
2401 globals->bfd_of_glue_owner = abfd;
2402
2403 return TRUE;
2404 }
2405
2406 static void check_use_blx(struct elf32_arm_link_hash_table *globals)
2407 {
2408 if (elf32_arm_get_eabi_attr_int (globals->obfd, Tag_CPU_arch) > 2)
2409 globals->use_blx = 1;
2410 }
2411
2412 bfd_boolean
2413 bfd_elf32_arm_process_before_allocation (bfd *abfd,
2414 struct bfd_link_info *link_info,
2415 int byteswap_code)
2416 {
2417 Elf_Internal_Shdr *symtab_hdr;
2418 Elf_Internal_Rela *internal_relocs = NULL;
2419 Elf_Internal_Rela *irel, *irelend;
2420 bfd_byte *contents = NULL;
2421
2422 asection *sec;
2423 struct elf32_arm_link_hash_table *globals;
2424
2425 /* If we are only performing a partial link do not bother
2426 to construct any glue. */
2427 if (link_info->relocatable)
2428 return TRUE;
2429
2430 /* Here we have a bfd that is to be included on the link. We have a hook
2431 to do reloc rummaging, before section sizes are nailed down. */
2432 globals = elf32_arm_hash_table (link_info);
2433 check_use_blx (globals);
2434
2435 BFD_ASSERT (globals != NULL);
2436 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2437
2438 if (byteswap_code && !bfd_big_endian (abfd))
2439 {
2440 _bfd_error_handler (_("%B: BE8 images only valid in big-endian mode."),
2441 abfd);
2442 return FALSE;
2443 }
2444 globals->byteswap_code = byteswap_code;
2445
2446 /* Rummage around all the relocs and map the glue vectors. */
2447 sec = abfd->sections;
2448
2449 if (sec == NULL)
2450 return TRUE;
2451
2452 for (; sec != NULL; sec = sec->next)
2453 {
2454 if (sec->reloc_count == 0)
2455 continue;
2456
2457 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2458
2459 /* Load the relocs. */
2460 internal_relocs
2461 = _bfd_elf_link_read_relocs (abfd, sec, (void *) NULL,
2462 (Elf_Internal_Rela *) NULL, FALSE);
2463
2464 if (internal_relocs == NULL)
2465 goto error_return;
2466
2467 irelend = internal_relocs + sec->reloc_count;
2468 for (irel = internal_relocs; irel < irelend; irel++)
2469 {
2470 long r_type;
2471 unsigned long r_index;
2472
2473 struct elf_link_hash_entry *h;
2474
2475 r_type = ELF32_R_TYPE (irel->r_info);
2476 r_index = ELF32_R_SYM (irel->r_info);
2477
2478 /* These are the only relocation types we care about. */
2479 if ( r_type != R_ARM_PC24
2480 && r_type != R_ARM_PLT32
2481 && r_type != R_ARM_CALL
2482 && r_type != R_ARM_JUMP24
2483 && r_type != R_ARM_THM_CALL)
2484 continue;
2485
2486 /* Get the section contents if we haven't done so already. */
2487 if (contents == NULL)
2488 {
2489 /* Get cached copy if it exists. */
2490 if (elf_section_data (sec)->this_hdr.contents != NULL)
2491 contents = elf_section_data (sec)->this_hdr.contents;
2492 else
2493 {
2494 /* Go get them off disk. */
2495 if (! bfd_malloc_and_get_section (abfd, sec, &contents))
2496 goto error_return;
2497 }
2498 }
2499
2500 /* If the relocation is not against a symbol it cannot concern us. */
2501 h = NULL;
2502
2503 /* We don't care about local symbols. */
2504 if (r_index < symtab_hdr->sh_info)
2505 continue;
2506
2507 /* This is an external symbol. */
2508 r_index -= symtab_hdr->sh_info;
2509 h = (struct elf_link_hash_entry *)
2510 elf_sym_hashes (abfd)[r_index];
2511
2512 /* If the relocation is against a static symbol it must be within
2513 the current section and so cannot be a cross ARM/Thumb relocation. */
2514 if (h == NULL)
2515 continue;
2516
2517 /* If the call will go through a PLT entry then we do not need
2518 glue. */
2519 if (globals->splt != NULL && h->plt.offset != (bfd_vma) -1)
2520 continue;
2521
2522 switch (r_type)
2523 {
2524 case R_ARM_PC24:
2525 case R_ARM_PLT32:
2526 case R_ARM_CALL:
2527 case R_ARM_JUMP24:
2528 /* This one is a call from arm code. We need to look up
2529 the target of the call. If it is a thumb target, we
2530 insert glue. */
2531 if (ELF_ST_TYPE(h->type) == STT_ARM_TFUNC
2532 && !(r_type == R_ARM_CALL && globals->use_blx))
2533 record_arm_to_thumb_glue (link_info, h);
2534 break;
2535
2536 case R_ARM_THM_CALL:
2537 /* This one is a call from thumb code. We look
2538 up the target of the call. If it is not a thumb
2539 target, we insert glue. */
2540 if (ELF_ST_TYPE (h->type) != STT_ARM_TFUNC && !globals->use_blx)
2541 record_thumb_to_arm_glue (link_info, h);
2542 break;
2543
2544 default:
2545 abort ();
2546 }
2547 }
2548
2549 if (contents != NULL
2550 && elf_section_data (sec)->this_hdr.contents != contents)
2551 free (contents);
2552 contents = NULL;
2553
2554 if (internal_relocs != NULL
2555 && elf_section_data (sec)->relocs != internal_relocs)
2556 free (internal_relocs);
2557 internal_relocs = NULL;
2558 }
2559
2560 return TRUE;
2561
2562 error_return:
2563 if (contents != NULL
2564 && elf_section_data (sec)->this_hdr.contents != contents)
2565 free (contents);
2566 if (internal_relocs != NULL
2567 && elf_section_data (sec)->relocs != internal_relocs)
2568 free (internal_relocs);
2569
2570 return FALSE;
2571 }
2572 #endif
2573
2574
2575 /* Set target relocation values needed during linking. */
2576
2577 void
2578 bfd_elf32_arm_set_target_relocs (struct bfd_link_info *link_info,
2579 int target1_is_rel,
2580 char * target2_type,
2581 int fix_v4bx,
2582 int use_blx)
2583 {
2584 struct elf32_arm_link_hash_table *globals;
2585
2586 globals = elf32_arm_hash_table (link_info);
2587
2588 globals->target1_is_rel = target1_is_rel;
2589 if (strcmp (target2_type, "rel") == 0)
2590 globals->target2_reloc = R_ARM_REL32;
2591 else if (strcmp (target2_type, "abs") == 0)
2592 globals->target2_reloc = R_ARM_ABS32;
2593 else if (strcmp (target2_type, "got-rel") == 0)
2594 globals->target2_reloc = R_ARM_GOT_PREL;
2595 else
2596 {
2597 _bfd_error_handler (_("Invalid TARGET2 relocation type '%s'."),
2598 target2_type);
2599 }
2600 globals->fix_v4bx = fix_v4bx;
2601 globals->use_blx |= use_blx;
2602 }
2603
2604 /* The thumb form of a long branch is a bit finicky, because the offset
2605 encoding is split over two fields, each in it's own instruction. They
2606 can occur in any order. So given a thumb form of long branch, and an
2607 offset, insert the offset into the thumb branch and return finished
2608 instruction.
2609
2610 It takes two thumb instructions to encode the target address. Each has
2611 11 bits to invest. The upper 11 bits are stored in one (identified by
2612 H-0.. see below), the lower 11 bits are stored in the other (identified
2613 by H-1).
2614
2615 Combine together and shifted left by 1 (it's a half word address) and
2616 there you have it.
2617
2618 Op: 1111 = F,
2619 H-0, upper address-0 = 000
2620 Op: 1111 = F,
2621 H-1, lower address-0 = 800
2622
2623 They can be ordered either way, but the arm tools I've seen always put
2624 the lower one first. It probably doesn't matter. krk@cygnus.com
2625
2626 XXX: Actually the order does matter. The second instruction (H-1)
2627 moves the computed address into the PC, so it must be the second one
2628 in the sequence. The problem, however is that whilst little endian code
2629 stores the instructions in HI then LOW order, big endian code does the
2630 reverse. nickc@cygnus.com. */
2631
2632 #define LOW_HI_ORDER 0xF800F000
2633 #define HI_LOW_ORDER 0xF000F800
2634
2635 static insn32
2636 insert_thumb_branch (insn32 br_insn, int rel_off)
2637 {
2638 unsigned int low_bits;
2639 unsigned int high_bits;
2640
2641 BFD_ASSERT ((rel_off & 1) != 1);
2642
2643 rel_off >>= 1; /* Half word aligned address. */
2644 low_bits = rel_off & 0x000007FF; /* The bottom 11 bits. */
2645 high_bits = (rel_off >> 11) & 0x000007FF; /* The top 11 bits. */
2646
2647 if ((br_insn & LOW_HI_ORDER) == LOW_HI_ORDER)
2648 br_insn = LOW_HI_ORDER | (low_bits << 16) | high_bits;
2649 else if ((br_insn & HI_LOW_ORDER) == HI_LOW_ORDER)
2650 br_insn = HI_LOW_ORDER | (high_bits << 16) | low_bits;
2651 else
2652 /* FIXME: abort is probably not the right call. krk@cygnus.com */
2653 abort (); /* Error - not a valid branch instruction form. */
2654
2655 return br_insn;
2656 }
2657
2658 /* Thumb code calling an ARM function. */
2659
2660 static int
2661 elf32_thumb_to_arm_stub (struct bfd_link_info * info,
2662 const char * name,
2663 bfd * input_bfd,
2664 bfd * output_bfd,
2665 asection * input_section,
2666 bfd_byte * hit_data,
2667 asection * sym_sec,
2668 bfd_vma offset,
2669 bfd_signed_vma addend,
2670 bfd_vma val)
2671 {
2672 asection * s = 0;
2673 bfd_vma my_offset;
2674 unsigned long int tmp;
2675 long int ret_offset;
2676 struct elf_link_hash_entry * myh;
2677 struct elf32_arm_link_hash_table * globals;
2678
2679 myh = find_thumb_glue (info, name, input_bfd);
2680 if (myh == NULL)
2681 return FALSE;
2682
2683 globals = elf32_arm_hash_table (info);
2684
2685 BFD_ASSERT (globals != NULL);
2686 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2687
2688 my_offset = myh->root.u.def.value;
2689
2690 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
2691 THUMB2ARM_GLUE_SECTION_NAME);
2692
2693 BFD_ASSERT (s != NULL);
2694 BFD_ASSERT (s->contents != NULL);
2695 BFD_ASSERT (s->output_section != NULL);
2696
2697 if ((my_offset & 0x01) == 0x01)
2698 {
2699 if (sym_sec != NULL
2700 && sym_sec->owner != NULL
2701 && !INTERWORK_FLAG (sym_sec->owner))
2702 {
2703 (*_bfd_error_handler)
2704 (_("%B(%s): warning: interworking not enabled.\n"
2705 " first occurrence: %B: thumb call to arm"),
2706 sym_sec->owner, input_bfd, name);
2707
2708 return FALSE;
2709 }
2710
2711 --my_offset;
2712 myh->root.u.def.value = my_offset;
2713
2714 bfd_put_16 (output_bfd, (bfd_vma) t2a1_bx_pc_insn,
2715 s->contents + my_offset);
2716
2717 bfd_put_16 (output_bfd, (bfd_vma) t2a2_noop_insn,
2718 s->contents + my_offset + 2);
2719
2720 ret_offset =
2721 /* Address of destination of the stub. */
2722 ((bfd_signed_vma) val)
2723 - ((bfd_signed_vma)
2724 /* Offset from the start of the current section
2725 to the start of the stubs. */
2726 (s->output_offset
2727 /* Offset of the start of this stub from the start of the stubs. */
2728 + my_offset
2729 /* Address of the start of the current section. */
2730 + s->output_section->vma)
2731 /* The branch instruction is 4 bytes into the stub. */
2732 + 4
2733 /* ARM branches work from the pc of the instruction + 8. */
2734 + 8);
2735
2736 bfd_put_32 (output_bfd,
2737 (bfd_vma) t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF),
2738 s->contents + my_offset + 4);
2739 }
2740
2741 BFD_ASSERT (my_offset <= globals->thumb_glue_size);
2742
2743 /* Now go back and fix up the original BL insn to point to here. */
2744 ret_offset =
2745 /* Address of where the stub is located. */
2746 (s->output_section->vma + s->output_offset + my_offset)
2747 /* Address of where the BL is located. */
2748 - (input_section->output_section->vma + input_section->output_offset
2749 + offset)
2750 /* Addend in the relocation. */
2751 - addend
2752 /* Biassing for PC-relative addressing. */
2753 - 8;
2754
2755 tmp = bfd_get_32 (input_bfd, hit_data
2756 - input_section->vma);
2757
2758 bfd_put_32 (output_bfd,
2759 (bfd_vma) insert_thumb_branch (tmp, ret_offset),
2760 hit_data - input_section->vma);
2761
2762 return TRUE;
2763 }
2764
2765 /* Arm code calling a Thumb function. */
2766
2767 static int
2768 elf32_arm_to_thumb_stub (struct bfd_link_info * info,
2769 const char * name,
2770 bfd * input_bfd,
2771 bfd * output_bfd,
2772 asection * input_section,
2773 bfd_byte * hit_data,
2774 asection * sym_sec,
2775 bfd_vma offset,
2776 bfd_signed_vma addend,
2777 bfd_vma val)
2778 {
2779 unsigned long int tmp;
2780 bfd_vma my_offset;
2781 asection * s;
2782 long int ret_offset;
2783 struct elf_link_hash_entry * myh;
2784 struct elf32_arm_link_hash_table * globals;
2785
2786 myh = find_arm_glue (info, name, input_bfd);
2787 if (myh == NULL)
2788 return FALSE;
2789
2790 globals = elf32_arm_hash_table (info);
2791
2792 BFD_ASSERT (globals != NULL);
2793 BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2794
2795 my_offset = myh->root.u.def.value;
2796 s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
2797 ARM2THUMB_GLUE_SECTION_NAME);
2798 BFD_ASSERT (s != NULL);
2799 BFD_ASSERT (s->contents != NULL);
2800 BFD_ASSERT (s->output_section != NULL);
2801
2802 if ((my_offset & 0x01) == 0x01)
2803 {
2804 if (sym_sec != NULL
2805 && sym_sec->owner != NULL
2806 && !INTERWORK_FLAG (sym_sec->owner))
2807 {
2808 (*_bfd_error_handler)
2809 (_("%B(%s): warning: interworking not enabled.\n"
2810 " first occurrence: %B: arm call to thumb"),
2811 sym_sec->owner, input_bfd, name);
2812 }
2813
2814 --my_offset;
2815 myh->root.u.def.value = my_offset;
2816
2817 if ((info->shared || globals->root.is_relocatable_executable))
2818 {
2819 /* For relocatable objects we can't use absolute addresses,
2820 so construct the address from a relative offset. */
2821 /* TODO: If the offset is small it's probably worth
2822 constructing the address with adds. */
2823 bfd_put_32 (output_bfd, (bfd_vma) a2t1p_ldr_insn,
2824 s->contents + my_offset);
2825 bfd_put_32 (output_bfd, (bfd_vma) a2t2p_add_pc_insn,
2826 s->contents + my_offset + 4);
2827 bfd_put_32 (output_bfd, (bfd_vma) a2t3p_bx_r12_insn,
2828 s->contents + my_offset + 8);
2829 /* Adjust the offset by 4 for the position of the add,
2830 and 8 for the pipeline offset. */
2831 ret_offset = (val - (s->output_offset
2832 + s->output_section->vma
2833 + my_offset + 12))
2834 | 1;
2835 bfd_put_32 (output_bfd, ret_offset,
2836 s->contents + my_offset + 12);
2837 }
2838 else
2839 {
2840 bfd_put_32 (output_bfd, (bfd_vma) a2t1_ldr_insn,
2841 s->contents + my_offset);
2842
2843 bfd_put_32 (output_bfd, (bfd_vma) a2t2_bx_r12_insn,
2844 s->contents + my_offset + 4);
2845
2846 /* It's a thumb address. Add the low order bit. */
2847 bfd_put_32 (output_bfd, val | a2t3_func_addr_insn,
2848 s->contents + my_offset + 8);
2849 }
2850 }
2851
2852 BFD_ASSERT (my_offset <= globals->arm_glue_size);
2853
2854 tmp = bfd_get_32 (input_bfd, hit_data);
2855 tmp = tmp & 0xFF000000;
2856
2857 /* Somehow these are both 4 too far, so subtract 8. */
2858 ret_offset = (s->output_offset
2859 + my_offset
2860 + s->output_section->vma
2861 - (input_section->output_offset
2862 + input_section->output_section->vma
2863 + offset + addend)
2864 - 8);
2865
2866 tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF);
2867
2868 bfd_put_32 (output_bfd, (bfd_vma) tmp, hit_data - input_section->vma);
2869
2870 return TRUE;
2871 }
2872
2873 /* Some relocations map to different relocations depending on the
2874 target. Return the real relocation. */
2875 static int
2876 arm_real_reloc_type (struct elf32_arm_link_hash_table * globals,
2877 int r_type)
2878 {
2879 switch (r_type)
2880 {
2881 case R_ARM_TARGET1:
2882 if (globals->target1_is_rel)
2883 return R_ARM_REL32;
2884 else
2885 return R_ARM_ABS32;
2886
2887 case R_ARM_TARGET2:
2888 return globals->target2_reloc;
2889
2890 default:
2891 return r_type;
2892 }
2893 }
2894
2895 /* Return the base VMA address which should be subtracted from real addresses
2896 when resolving @dtpoff relocation.
2897 This is PT_TLS segment p_vaddr. */
2898
2899 static bfd_vma
2900 dtpoff_base (struct bfd_link_info *info)
2901 {
2902 /* If tls_sec is NULL, we should have signalled an error already. */
2903 if (elf_hash_table (info)->tls_sec == NULL)
2904 return 0;
2905 return elf_hash_table (info)->tls_sec->vma;
2906 }
2907
2908 /* Return the relocation value for @tpoff relocation
2909 if STT_TLS virtual address is ADDRESS. */
2910
2911 static bfd_vma
2912 tpoff (struct bfd_link_info *info, bfd_vma address)
2913 {
2914 struct elf_link_hash_table *htab = elf_hash_table (info);
2915 bfd_vma base;
2916
2917 /* If tls_sec is NULL, we should have signalled an error already. */
2918 if (htab->tls_sec == NULL)
2919 return 0;
2920 base = align_power ((bfd_vma) TCB_SIZE, htab->tls_sec->alignment_power);
2921 return address - htab->tls_sec->vma + base;
2922 }
2923
2924 /* Perform an R_ARM_ABS12 relocation on the field pointed to by DATA.
2925 VALUE is the relocation value. */
2926
2927 static bfd_reloc_status_type
2928 elf32_arm_abs12_reloc (bfd *abfd, void *data, bfd_vma value)
2929 {
2930 if (value > 0xfff)
2931 return bfd_reloc_overflow;
2932
2933 value |= bfd_get_32 (abfd, data) & 0xfffff000;
2934 bfd_put_32 (abfd, value, data);
2935 return bfd_reloc_ok;
2936 }
2937
2938 /* Perform a relocation as part of a final link. */
2939
2940 static bfd_reloc_status_type
2941 elf32_arm_final_link_relocate (reloc_howto_type * howto,
2942 bfd * input_bfd,
2943 bfd * output_bfd,
2944 asection * input_section,
2945 bfd_byte * contents,
2946 Elf_Internal_Rela * rel,
2947 bfd_vma value,
2948 struct bfd_link_info * info,
2949 asection * sym_sec,
2950 const char * sym_name,
2951 int sym_flags,
2952 struct elf_link_hash_entry * h,
2953 bfd_boolean * unresolved_reloc_p)
2954 {
2955 unsigned long r_type = howto->type;
2956 unsigned long r_symndx;
2957 bfd_byte * hit_data = contents + rel->r_offset;
2958 bfd * dynobj = NULL;
2959 Elf_Internal_Shdr * symtab_hdr;
2960 struct elf_link_hash_entry ** sym_hashes;
2961 bfd_vma * local_got_offsets;
2962 asection * sgot = NULL;
2963 asection * splt = NULL;
2964 asection * sreloc = NULL;
2965 bfd_vma addend;
2966 bfd_signed_vma signed_addend;
2967 struct elf32_arm_link_hash_table * globals;
2968
2969 globals = elf32_arm_hash_table (info);
2970
2971 /* Some relocation type map to different relocations depending on the
2972 target. We pick the right one here. */
2973 r_type = arm_real_reloc_type (globals, r_type);
2974 if (r_type != howto->type)
2975 howto = elf32_arm_howto_from_type (r_type);
2976
2977 /* If the start address has been set, then set the EF_ARM_HASENTRY
2978 flag. Setting this more than once is redundant, but the cost is
2979 not too high, and it keeps the code simple.
2980
2981 The test is done here, rather than somewhere else, because the
2982 start address is only set just before the final link commences.
2983
2984 Note - if the user deliberately sets a start address of 0, the
2985 flag will not be set. */
2986 if (bfd_get_start_address (output_bfd) != 0)
2987 elf_elfheader (output_bfd)->e_flags |= EF_ARM_HASENTRY;
2988
2989 dynobj = elf_hash_table (info)->dynobj;
2990 if (dynobj)
2991 {
2992 sgot = bfd_get_section_by_name (dynobj, ".got");
2993 splt = bfd_get_section_by_name (dynobj, ".plt");
2994 }
2995 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
2996 sym_hashes = elf_sym_hashes (input_bfd);
2997 local_got_offsets = elf_local_got_offsets (input_bfd);
2998 r_symndx = ELF32_R_SYM (rel->r_info);
2999
3000 if (globals->use_rel)
3001 {
3002 addend = bfd_get_32 (input_bfd, hit_data) & howto->src_mask;
3003
3004 if (addend & ((howto->src_mask + 1) >> 1))
3005 {
3006 signed_addend = -1;
3007 signed_addend &= ~ howto->src_mask;
3008 signed_addend |= addend;
3009 }
3010 else
3011 signed_addend = addend;
3012 }
3013 else
3014 addend = signed_addend = rel->r_addend;
3015
3016 switch (r_type)
3017 {
3018 case R_ARM_NONE:
3019 /* We don't need to find a value for this symbol. It's just a
3020 marker. */
3021 *unresolved_reloc_p = FALSE;
3022 return bfd_reloc_ok;
3023
3024 case R_ARM_ABS12:
3025 if (!globals->vxworks_p)
3026 return elf32_arm_abs12_reloc (input_bfd, hit_data, value + addend);
3027
3028 case R_ARM_PC24:
3029 case R_ARM_ABS32:
3030 case R_ARM_REL32:
3031 case R_ARM_CALL:
3032 case R_ARM_JUMP24:
3033 case R_ARM_XPC25:
3034 case R_ARM_PREL31:
3035 case R_ARM_PLT32:
3036 /* r_symndx will be zero only for relocs against symbols
3037 from removed linkonce sections, or sections discarded by
3038 a linker script. */
3039 if (r_symndx == 0)
3040 return bfd_reloc_ok;
3041
3042 /* Handle relocations which should use the PLT entry. ABS32/REL32
3043 will use the symbol's value, which may point to a PLT entry, but we
3044 don't need to handle that here. If we created a PLT entry, all
3045 branches in this object should go to it. */
3046 if ((r_type != R_ARM_ABS32 && r_type != R_ARM_REL32)
3047 && h != NULL
3048 && splt != NULL
3049 && h->plt.offset != (bfd_vma) -1)
3050 {
3051 /* If we've created a .plt section, and assigned a PLT entry to
3052 this function, it should not be known to bind locally. If
3053 it were, we would have cleared the PLT entry. */
3054 BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info, h));
3055
3056 value = (splt->output_section->vma
3057 + splt->output_offset
3058 + h->plt.offset);
3059 *unresolved_reloc_p = FALSE;
3060 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3061 contents, rel->r_offset, value,
3062 rel->r_addend);
3063 }
3064
3065 /* When generating a shared object or relocatable executable, these
3066 relocations are copied into the output file to be resolved at
3067 run time. */
3068 if ((info->shared || globals->root.is_relocatable_executable)
3069 && (input_section->flags & SEC_ALLOC)
3070 && (r_type != R_ARM_REL32
3071 || !SYMBOL_CALLS_LOCAL (info, h))
3072 && (h == NULL
3073 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3074 || h->root.type != bfd_link_hash_undefweak)
3075 && r_type != R_ARM_PC24
3076 && r_type != R_ARM_CALL
3077 && r_type != R_ARM_JUMP24
3078 && r_type != R_ARM_PREL31
3079 && r_type != R_ARM_PLT32)
3080 {
3081 Elf_Internal_Rela outrel;
3082 bfd_byte *loc;
3083 bfd_boolean skip, relocate;
3084
3085 *unresolved_reloc_p = FALSE;
3086
3087 if (sreloc == NULL)
3088 {
3089 const char * name;
3090
3091 name = (bfd_elf_string_from_elf_section
3092 (input_bfd,
3093 elf_elfheader (input_bfd)->e_shstrndx,
3094 elf_section_data (input_section)->rel_hdr.sh_name));
3095 if (name == NULL)
3096 return bfd_reloc_notsupported;
3097
3098 BFD_ASSERT (reloc_section_p (globals, name, input_section));
3099
3100 sreloc = bfd_get_section_by_name (dynobj, name);
3101 BFD_ASSERT (sreloc != NULL);
3102 }
3103
3104 skip = FALSE;
3105 relocate = FALSE;
3106
3107 outrel.r_addend = addend;
3108 outrel.r_offset =
3109 _bfd_elf_section_offset (output_bfd, info, input_section,
3110 rel->r_offset);
3111 if (outrel.r_offset == (bfd_vma) -1)
3112 skip = TRUE;
3113 else if (outrel.r_offset == (bfd_vma) -2)
3114 skip = TRUE, relocate = TRUE;
3115 outrel.r_offset += (input_section->output_section->vma
3116 + input_section->output_offset);
3117
3118 if (skip)
3119 memset (&outrel, 0, sizeof outrel);
3120 else if (h != NULL
3121 && h->dynindx != -1
3122 && (!info->shared
3123 || !info->symbolic
3124 || !h->def_regular))
3125 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
3126 else
3127 {
3128 int symbol;
3129
3130 /* This symbol is local, or marked to become local. */
3131 if (sym_flags == STT_ARM_TFUNC)
3132 value |= 1;
3133 if (globals->symbian_p)
3134 {
3135 /* On Symbian OS, the data segment and text segement
3136 can be relocated independently. Therefore, we
3137 must indicate the segment to which this
3138 relocation is relative. The BPABI allows us to
3139 use any symbol in the right segment; we just use
3140 the section symbol as it is convenient. (We
3141 cannot use the symbol given by "h" directly as it
3142 will not appear in the dynamic symbol table.) */
3143 if (sym_sec)
3144 symbol = elf_section_data (sym_sec->output_section)->dynindx;
3145 else
3146 symbol = elf_section_data (input_section->output_section)->dynindx;
3147 BFD_ASSERT (symbol != 0);
3148 }
3149 else
3150 /* On SVR4-ish systems, the dynamic loader cannot
3151 relocate the text and data segments independently,
3152 so the symbol does not matter. */
3153 symbol = 0;
3154 outrel.r_info = ELF32_R_INFO (symbol, R_ARM_RELATIVE);
3155 if (globals->use_rel)
3156 relocate = TRUE;
3157 else
3158 outrel.r_addend += value;
3159 }
3160
3161 loc = sreloc->contents;
3162 loc += sreloc->reloc_count++ * RELOC_SIZE (globals);
3163 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
3164
3165 /* If this reloc is against an external symbol, we do not want to
3166 fiddle with the addend. Otherwise, we need to include the symbol
3167 value so that it becomes an addend for the dynamic reloc. */
3168 if (! relocate)
3169 return bfd_reloc_ok;
3170
3171 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3172 contents, rel->r_offset, value,
3173 (bfd_vma) 0);
3174 }
3175 else switch (r_type)
3176 {
3177 case R_ARM_ABS12:
3178 return elf32_arm_abs12_reloc (input_bfd, hit_data, value + addend);
3179
3180 case R_ARM_XPC25: /* Arm BLX instruction. */
3181 case R_ARM_CALL:
3182 case R_ARM_JUMP24:
3183 case R_ARM_PC24: /* Arm B/BL instruction */
3184 case R_ARM_PLT32:
3185 if (r_type == R_ARM_XPC25)
3186 {
3187 /* Check for Arm calling Arm function. */
3188 /* FIXME: Should we translate the instruction into a BL
3189 instruction instead ? */
3190 if (sym_flags != STT_ARM_TFUNC)
3191 (*_bfd_error_handler)
3192 (_("\%B: Warning: Arm BLX instruction targets Arm function '%s'."),
3193 input_bfd,
3194 h ? h->root.root.string : "(local)");
3195 }
3196 else if (r_type != R_ARM_CALL || !globals->use_blx)
3197 {
3198 /* Check for Arm calling Thumb function. */
3199 if (sym_flags == STT_ARM_TFUNC)
3200 {
3201 elf32_arm_to_thumb_stub (info, sym_name, input_bfd,
3202 output_bfd, input_section,
3203 hit_data, sym_sec, rel->r_offset,
3204 signed_addend, value);
3205 return bfd_reloc_ok;
3206 }
3207 }
3208
3209 /* The ARM ELF ABI says that this reloc is computed as: S - P + A
3210 where:
3211 S is the address of the symbol in the relocation.
3212 P is address of the instruction being relocated.
3213 A is the addend (extracted from the instruction) in bytes.
3214
3215 S is held in 'value'.
3216 P is the base address of the section containing the
3217 instruction plus the offset of the reloc into that
3218 section, ie:
3219 (input_section->output_section->vma +
3220 input_section->output_offset +
3221 rel->r_offset).
3222 A is the addend, converted into bytes, ie:
3223 (signed_addend * 4)
3224
3225 Note: None of these operations have knowledge of the pipeline
3226 size of the processor, thus it is up to the assembler to
3227 encode this information into the addend. */
3228 value -= (input_section->output_section->vma
3229 + input_section->output_offset);
3230 value -= rel->r_offset;
3231 if (globals->use_rel)
3232 value += (signed_addend << howto->size);
3233 else
3234 /* RELA addends do not have to be adjusted by howto->size. */
3235 value += signed_addend;
3236
3237 signed_addend = value;
3238 signed_addend >>= howto->rightshift;
3239
3240 /* It is not an error for an undefined weak reference to be
3241 out of range. Any program that branches to such a symbol
3242 is going to crash anyway, so there is no point worrying
3243 about getting the destination exactly right. */
3244 if (! h || h->root.type != bfd_link_hash_undefweak)
3245 {
3246 /* Perform a signed range check. */
3247 if ( signed_addend > ((bfd_signed_vma) (howto->dst_mask >> 1))
3248 || signed_addend < - ((bfd_signed_vma) ((howto->dst_mask + 1) >> 1)))
3249 return bfd_reloc_overflow;
3250 }
3251
3252 addend = (value & 2);
3253
3254 value = (signed_addend & howto->dst_mask)
3255 | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask));
3256
3257 /* Set the H bit in the BLX instruction. */
3258 if (sym_flags == STT_ARM_TFUNC)
3259 {
3260 if (addend)
3261 value |= (1 << 24);
3262 else
3263 value &= ~(bfd_vma)(1 << 24);
3264 }
3265 if (r_type == R_ARM_CALL)
3266 {
3267 /* Select the correct instruction (BL or BLX). */
3268 if (sym_flags == STT_ARM_TFUNC)
3269 value |= (1 << 28);
3270 else
3271 {
3272 value &= ~(bfd_vma)(1 << 28);
3273 value |= (1 << 24);
3274 }
3275 }
3276 break;
3277
3278 case R_ARM_ABS32:
3279 value += addend;
3280 if (sym_flags == STT_ARM_TFUNC)
3281 value |= 1;
3282 break;
3283
3284 case R_ARM_REL32:
3285 value += addend;
3286 if (sym_flags == STT_ARM_TFUNC)
3287 value |= 1;
3288 value -= (input_section->output_section->vma
3289 + input_section->output_offset + rel->r_offset);
3290 break;
3291
3292 case R_ARM_PREL31:
3293 value -= (input_section->output_section->vma
3294 + input_section->output_offset + rel->r_offset);
3295 value += signed_addend;
3296 if (! h || h->root.type != bfd_link_hash_undefweak)
3297 {
3298 /* Check for overflow */
3299 if ((value ^ (value >> 1)) & (1 << 30))
3300 return bfd_reloc_overflow;
3301 }
3302 value &= 0x7fffffff;
3303 value |= (bfd_get_32 (input_bfd, hit_data) & 0x80000000);
3304 if (sym_flags == STT_ARM_TFUNC)
3305 value |= 1;
3306 break;
3307 }
3308
3309 bfd_put_32 (input_bfd, value, hit_data);
3310 return bfd_reloc_ok;
3311
3312 case R_ARM_ABS8:
3313 value += addend;
3314 if ((long) value > 0x7f || (long) value < -0x80)
3315 return bfd_reloc_overflow;
3316
3317 bfd_put_8 (input_bfd, value, hit_data);
3318 return bfd_reloc_ok;
3319
3320 case R_ARM_ABS16:
3321 value += addend;
3322
3323 if ((long) value > 0x7fff || (long) value < -0x8000)
3324 return bfd_reloc_overflow;
3325
3326 bfd_put_16 (input_bfd, value, hit_data);
3327 return bfd_reloc_ok;
3328
3329 case R_ARM_THM_ABS5:
3330 /* Support ldr and str instructions for the thumb. */
3331 if (globals->use_rel)
3332 {
3333 /* Need to refetch addend. */
3334 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
3335 /* ??? Need to determine shift amount from operand size. */
3336 addend >>= howto->rightshift;
3337 }
3338 value += addend;
3339
3340 /* ??? Isn't value unsigned? */
3341 if ((long) value > 0x1f || (long) value < -0x10)
3342 return bfd_reloc_overflow;
3343
3344 /* ??? Value needs to be properly shifted into place first. */
3345 value |= bfd_get_16 (input_bfd, hit_data) & 0xf83f;
3346 bfd_put_16 (input_bfd, value, hit_data);
3347 return bfd_reloc_ok;
3348
3349 case R_ARM_THM_XPC22:
3350 case R_ARM_THM_CALL:
3351 /* Thumb BL (branch long instruction). */
3352 {
3353 bfd_vma relocation;
3354 bfd_boolean overflow = FALSE;
3355 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
3356 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
3357 bfd_signed_vma reloc_signed_max = ((1 << (howto->bitsize - 1)) - 1) >> howto->rightshift;
3358 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
3359 bfd_vma check;
3360 bfd_signed_vma signed_check;
3361
3362 /* Need to refetch the addend and squish the two 11 bit pieces
3363 together. */
3364 if (globals->use_rel)
3365 {
3366 bfd_vma upper = upper_insn & 0x7ff;
3367 bfd_vma lower = lower_insn & 0x7ff;
3368 upper = (upper ^ 0x400) - 0x400; /* Sign extend. */
3369 addend = (upper << 12) | (lower << 1);
3370 signed_addend = addend;
3371 }
3372
3373 if (r_type == R_ARM_THM_XPC22)
3374 {
3375 /* Check for Thumb to Thumb call. */
3376 /* FIXME: Should we translate the instruction into a BL
3377 instruction instead ? */
3378 if (sym_flags == STT_ARM_TFUNC)
3379 (*_bfd_error_handler)
3380 (_("%B: Warning: Thumb BLX instruction targets thumb function '%s'."),
3381 input_bfd,
3382 h ? h->root.root.string : "(local)");
3383 }
3384 else
3385 {
3386 /* If it is not a call to Thumb, assume call to Arm.
3387 If it is a call relative to a section name, then it is not a
3388 function call at all, but rather a long jump. Calls through
3389 the PLT do not require stubs. */
3390 if (sym_flags != STT_ARM_TFUNC && sym_flags != STT_SECTION
3391 && (h == NULL || splt == NULL
3392 || h->plt.offset == (bfd_vma) -1))
3393 {
3394 if (globals->use_blx)
3395 {
3396 /* Convert BL to BLX. */
3397 lower_insn = (lower_insn & ~0x1000) | 0x0800;
3398 }
3399 else if (elf32_thumb_to_arm_stub
3400 (info, sym_name, input_bfd, output_bfd, input_section,
3401 hit_data, sym_sec, rel->r_offset, signed_addend, value))
3402 return bfd_reloc_ok;
3403 else
3404 return bfd_reloc_dangerous;
3405 }
3406 else if (sym_flags == STT_ARM_TFUNC && globals->use_blx)
3407 {
3408 /* Make sure this is a BL. */
3409 lower_insn |= 0x1800;
3410 }
3411 }
3412
3413 /* Handle calls via the PLT. */
3414 if (h != NULL && splt != NULL && h->plt.offset != (bfd_vma) -1)
3415 {
3416 value = (splt->output_section->vma
3417 + splt->output_offset
3418 + h->plt.offset);
3419 if (globals->use_blx)
3420 {
3421 /* If the Thumb BLX instruction is available, convert the
3422 BL to a BLX instruction to call the ARM-mode PLT entry. */
3423 lower_insn = (lower_insn & ~0x1000) | 0x0800;
3424 }
3425 else
3426 /* Target the Thumb stub before the ARM PLT entry. */
3427 value -= PLT_THUMB_STUB_SIZE;
3428 *unresolved_reloc_p = FALSE;
3429 }
3430
3431 relocation = value + signed_addend;
3432
3433 relocation -= (input_section->output_section->vma
3434 + input_section->output_offset
3435 + rel->r_offset);
3436
3437 check = relocation >> howto->rightshift;
3438
3439 /* If this is a signed value, the rightshift just dropped
3440 leading 1 bits (assuming twos complement). */
3441 if ((bfd_signed_vma) relocation >= 0)
3442 signed_check = check;
3443 else
3444 signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
3445
3446 /* Assumes two's complement. */
3447 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
3448 overflow = TRUE;
3449
3450 if ((lower_insn & 0x1800) == 0x0800)
3451 /* For a BLX instruction, make sure that the relocation is rounded up
3452 to a word boundary. This follows the semantics of the instruction
3453 which specifies that bit 1 of the target address will come from bit
3454 1 of the base address. */
3455 relocation = (relocation + 2) & ~ 3;
3456
3457 /* Put RELOCATION back into the insn. */
3458 upper_insn = (upper_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 12) & 0x7ff);
3459 lower_insn = (lower_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 1) & 0x7ff);
3460
3461 /* Put the relocated value back in the object file: */
3462 bfd_put_16 (input_bfd, upper_insn, hit_data);
3463 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
3464
3465 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
3466 }
3467 break;
3468
3469 case R_ARM_THM_JUMP24:
3470 /* Thumb32 unconditional branch instruction. */
3471 {
3472 bfd_vma relocation;
3473 bfd_boolean overflow = FALSE;
3474 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
3475 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
3476 bfd_signed_vma reloc_signed_max = ((1 << (howto->bitsize - 1)) - 1) >> howto->rightshift;
3477 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
3478 bfd_vma check;
3479 bfd_signed_vma signed_check;
3480
3481 /* Need to refetch the addend, reconstruct the top three bits, and glue the
3482 two pieces together. */
3483 if (globals->use_rel)
3484 {
3485 bfd_vma S = (upper_insn & 0x0400) >> 10;
3486 bfd_vma hi = (upper_insn & 0x03ff);
3487 bfd_vma I1 = (lower_insn & 0x2000) >> 13;
3488 bfd_vma I2 = (lower_insn & 0x0800) >> 11;
3489 bfd_vma lo = (lower_insn & 0x07ff);
3490
3491 I1 = !(I1 ^ S);
3492 I2 = !(I2 ^ S);
3493 S = !S;
3494
3495 signed_addend = (S << 24) | (I1 << 23) | (I2 << 22) | (hi << 12) | (lo << 1);
3496 signed_addend -= (1 << 24); /* Sign extend. */
3497 }
3498
3499 /* ??? Should handle interworking? GCC might someday try to
3500 use this for tail calls. */
3501
3502 relocation = value + signed_addend;
3503 relocation -= (input_section->output_section->vma
3504 + input_section->output_offset
3505 + rel->r_offset);
3506
3507 check = relocation >> howto->rightshift;
3508
3509 /* If this is a signed value, the rightshift just dropped
3510 leading 1 bits (assuming twos complement). */
3511 if ((bfd_signed_vma) relocation >= 0)
3512 signed_check = check;
3513 else
3514 signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
3515
3516 /* Assumes two's complement. */
3517 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
3518 overflow = TRUE;
3519
3520 /* Put RELOCATION back into the insn. */
3521 {
3522 bfd_vma S = (relocation & 0x01000000) >> 24;
3523 bfd_vma I1 = (relocation & 0x00800000) >> 23;
3524 bfd_vma I2 = (relocation & 0x00400000) >> 22;
3525 bfd_vma hi = (relocation & 0x003ff000) >> 12;
3526 bfd_vma lo = (relocation & 0x00000ffe) >> 1;
3527
3528 I1 = !(I1 ^ S);
3529 I2 = !(I2 ^ S);
3530
3531 upper_insn = (upper_insn & (bfd_vma) 0xf800) | (S << 10) | hi;
3532 lower_insn = (lower_insn & (bfd_vma) 0xd000) | (I1 << 13) | (I2 << 11) | lo;
3533 }
3534
3535 /* Put the relocated value back in the object file: */
3536 bfd_put_16 (input_bfd, upper_insn, hit_data);
3537 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
3538
3539 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
3540 }
3541
3542 case R_ARM_THM_JUMP19:
3543 /* Thumb32 conditional branch instruction. */
3544 {
3545 bfd_vma relocation;
3546 bfd_boolean overflow = FALSE;
3547 bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
3548 bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
3549 bfd_signed_vma reloc_signed_max = ((1 << (howto->bitsize - 1)) - 1) >> howto->rightshift;
3550 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
3551 bfd_vma check;
3552 bfd_signed_vma signed_check;
3553
3554 /* Need to refetch the addend, reconstruct the top three bits,
3555 and squish the two 11 bit pieces together. */
3556 if (globals->use_rel)
3557 {
3558 bfd_vma S = (upper_insn & 0x0400) >> 10;
3559 bfd_vma upper = (upper_insn & 0x001f);
3560 bfd_vma J1 = (lower_insn & 0x2000) >> 13;
3561 bfd_vma J2 = (lower_insn & 0x0800) >> 11;
3562 bfd_vma lower = (lower_insn & 0x07ff);
3563
3564 upper |= J2 << 6;
3565 upper |= J1 << 7;
3566 upper |= ~S << 8;
3567 upper -= 0x0100; /* Sign extend. */
3568
3569 addend = (upper << 12) | (lower << 1);
3570 signed_addend = addend;
3571 }
3572
3573 /* ??? Should handle interworking? GCC might someday try to
3574 use this for tail calls. */
3575
3576 relocation = value + signed_addend;
3577 relocation -= (input_section->output_section->vma
3578 + input_section->output_offset
3579 + rel->r_offset);
3580
3581 check = relocation >> howto->rightshift;
3582
3583 /* If this is a signed value, the rightshift just dropped
3584 leading 1 bits (assuming twos complement). */
3585 if ((bfd_signed_vma) relocation >= 0)
3586 signed_check = check;
3587 else
3588 signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
3589
3590 /* Assumes two's complement. */
3591 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
3592 overflow = TRUE;
3593
3594 /* Put RELOCATION back into the insn. */
3595 {
3596 bfd_vma S = (relocation & 0x00100000) >> 20;
3597 bfd_vma J2 = (relocation & 0x00080000) >> 19;
3598 bfd_vma J1 = (relocation & 0x00040000) >> 18;
3599 bfd_vma hi = (relocation & 0x0003f000) >> 12;
3600 bfd_vma lo = (relocation & 0x00000ffe) >> 1;
3601
3602 upper_insn = (upper_insn & 0xfb30) | (S << 10) | hi;
3603 lower_insn = (lower_insn & 0xd000) | (J1 << 13) | (J2 << 11) | lo;
3604 }
3605
3606 /* Put the relocated value back in the object file: */
3607 bfd_put_16 (input_bfd, upper_insn, hit_data);
3608 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
3609
3610 return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
3611 }
3612
3613 case R_ARM_THM_JUMP11:
3614 case R_ARM_THM_JUMP8:
3615 case R_ARM_THM_JUMP6:
3616 /* Thumb B (branch) instruction). */
3617 {
3618 bfd_signed_vma relocation;
3619 bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
3620 bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
3621 bfd_signed_vma signed_check;
3622
3623 /* CZB cannot jump backward. */
3624 if (r_type == R_ARM_THM_JUMP6)
3625 reloc_signed_min = 0;
3626
3627 if (globals->use_rel)
3628 {
3629 /* Need to refetch addend. */
3630 addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
3631 if (addend & ((howto->src_mask + 1) >> 1))
3632 {
3633 signed_addend = -1;
3634 signed_addend &= ~ howto->src_mask;
3635 signed_addend |= addend;
3636 }
3637 else
3638 signed_addend = addend;
3639 /* The value in the insn has been right shifted. We need to
3640 undo this, so that we can perform the address calculation
3641 in terms of bytes. */
3642 signed_addend <<= howto->rightshift;
3643 }
3644 relocation = value + signed_addend;
3645
3646 relocation -= (input_section->output_section->vma
3647 + input_section->output_offset
3648 + rel->r_offset);
3649
3650 relocation >>= howto->rightshift;
3651 signed_check = relocation;
3652
3653 if (r_type == R_ARM_THM_JUMP6)
3654 relocation = ((relocation & 0x0020) << 4) | ((relocation & 0x001f) << 3);
3655 else
3656 relocation &= howto->dst_mask;
3657 relocation |= (bfd_get_16 (input_bfd, hit_data) & (~ howto->dst_mask));
3658
3659 bfd_put_16 (input_bfd, relocation, hit_data);
3660
3661 /* Assumes two's complement. */
3662 if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
3663 return bfd_reloc_overflow;
3664
3665 return bfd_reloc_ok;
3666 }
3667
3668 case R_ARM_ALU_PCREL7_0:
3669 case R_ARM_ALU_PCREL15_8:
3670 case R_ARM_ALU_PCREL23_15:
3671 {
3672 bfd_vma insn;
3673 bfd_vma relocation;
3674
3675 insn = bfd_get_32 (input_bfd, hit_data);
3676 if (globals->use_rel)
3677 {
3678 /* Extract the addend. */
3679 addend = (insn & 0xff) << ((insn & 0xf00) >> 7);
3680 signed_addend = addend;
3681 }
3682 relocation = value + signed_addend;
3683
3684 relocation -= (input_section->output_section->vma
3685 + input_section->output_offset
3686 + rel->r_offset);
3687 insn = (insn & ~0xfff)
3688 | ((howto->bitpos << 7) & 0xf00)
3689 | ((relocation >> howto->bitpos) & 0xff);
3690 bfd_put_32 (input_bfd, value, hit_data);
3691 }
3692 return bfd_reloc_ok;
3693
3694 case R_ARM_GNU_VTINHERIT:
3695 case R_ARM_GNU_VTENTRY:
3696 return bfd_reloc_ok;
3697
3698 case R_ARM_GOTOFF32:
3699 /* Relocation is relative to the start of the
3700 global offset table. */
3701
3702 BFD_ASSERT (sgot != NULL);
3703 if (sgot == NULL)
3704 return bfd_reloc_notsupported;
3705
3706 /* If we are addressing a Thumb function, we need to adjust the
3707 address by one, so that attempts to call the function pointer will
3708 correctly interpret it as Thumb code. */
3709 if (sym_flags == STT_ARM_TFUNC)
3710 value += 1;
3711
3712 /* Note that sgot->output_offset is not involved in this
3713 calculation. We always want the start of .got. If we
3714 define _GLOBAL_OFFSET_TABLE in a different way, as is
3715 permitted by the ABI, we might have to change this
3716 calculation. */
3717 value -= sgot->output_section->vma;
3718 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3719 contents, rel->r_offset, value,
3720 rel->r_addend);
3721
3722 case R_ARM_GOTPC:
3723 /* Use global offset table as symbol value. */
3724 BFD_ASSERT (sgot != NULL);
3725
3726 if (sgot == NULL)
3727 return bfd_reloc_notsupported;
3728
3729 *unresolved_reloc_p = FALSE;
3730 value = sgot->output_section->vma;
3731 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3732 contents, rel->r_offset, value,
3733 rel->r_addend);
3734
3735 case R_ARM_GOT32:
3736 case R_ARM_GOT_PREL:
3737 /* Relocation is to the entry for this symbol in the
3738 global offset table. */
3739 if (sgot == NULL)
3740 return bfd_reloc_notsupported;
3741
3742 if (h != NULL)
3743 {
3744 bfd_vma off;
3745 bfd_boolean dyn;
3746
3747 off = h->got.offset;
3748 BFD_ASSERT (off != (bfd_vma) -1);
3749 dyn = globals->root.dynamic_sections_created;
3750
3751 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3752 || (info->shared
3753 && SYMBOL_REFERENCES_LOCAL (info, h))
3754 || (ELF_ST_VISIBILITY (h->other)
3755 && h->root.type == bfd_link_hash_undefweak))
3756 {
3757 /* This is actually a static link, or it is a -Bsymbolic link
3758 and the symbol is defined locally. We must initialize this
3759 entry in the global offset table. Since the offset must
3760 always be a multiple of 4, we use the least significant bit
3761 to record whether we have initialized it already.
3762
3763 When doing a dynamic link, we create a .rel(a).got relocation
3764 entry to initialize the value. This is done in the
3765 finish_dynamic_symbol routine. */
3766 if ((off & 1) != 0)
3767 off &= ~1;
3768 else
3769 {
3770 /* If we are addressing a Thumb function, we need to
3771 adjust the address by one, so that attempts to
3772 call the function pointer will correctly
3773 interpret it as Thumb code. */
3774 if (sym_flags == STT_ARM_TFUNC)
3775 value |= 1;
3776
3777 bfd_put_32 (output_bfd, value, sgot->contents + off);
3778 h->got.offset |= 1;
3779 }
3780 }
3781 else
3782 *unresolved_reloc_p = FALSE;
3783
3784 value = sgot->output_offset + off;
3785 }
3786 else
3787 {
3788 bfd_vma off;
3789
3790 BFD_ASSERT (local_got_offsets != NULL &&
3791 local_got_offsets[r_symndx] != (bfd_vma) -1);
3792
3793 off = local_got_offsets[r_symndx];
3794
3795 /* The offset must always be a multiple of 4. We use the
3796 least significant bit to record whether we have already
3797 generated the necessary reloc. */
3798 if ((off & 1) != 0)
3799 off &= ~1;
3800 else
3801 {
3802 /* If we are addressing a Thumb function, we need to
3803 adjust the address by one, so that attempts to
3804 call the function pointer will correctly
3805 interpret it as Thumb code. */
3806 if (sym_flags == STT_ARM_TFUNC)
3807 value |= 1;
3808
3809 if (globals->use_rel)
3810 bfd_put_32 (output_bfd, value, sgot->contents + off);
3811
3812 if (info->shared)
3813 {
3814 asection * srelgot;
3815 Elf_Internal_Rela outrel;
3816 bfd_byte *loc;
3817
3818 srelgot = (bfd_get_section_by_name
3819 (dynobj, RELOC_SECTION (globals, ".got")));
3820 BFD_ASSERT (srelgot != NULL);
3821
3822 outrel.r_addend = addend + value;
3823 outrel.r_offset = (sgot->output_section->vma
3824 + sgot->output_offset
3825 + off);
3826 outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
3827 loc = srelgot->contents;
3828 loc += srelgot->reloc_count++ * RELOC_SIZE (globals);
3829 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
3830 }
3831
3832 local_got_offsets[r_symndx] |= 1;
3833 }
3834
3835 value = sgot->output_offset + off;
3836 }
3837 if (r_type != R_ARM_GOT32)
3838 value += sgot->output_section->vma;
3839
3840 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3841 contents, rel->r_offset, value,
3842 rel->r_addend);
3843
3844 case R_ARM_TLS_LDO32:
3845 value = value - dtpoff_base (info);
3846
3847 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3848 contents, rel->r_offset, value,
3849 rel->r_addend);
3850
3851 case R_ARM_TLS_LDM32:
3852 {
3853 bfd_vma off;
3854
3855 if (globals->sgot == NULL)
3856 abort ();
3857
3858 off = globals->tls_ldm_got.offset;
3859
3860 if ((off & 1) != 0)
3861 off &= ~1;
3862 else
3863 {
3864 /* If we don't know the module number, create a relocation
3865 for it. */
3866 if (info->shared)
3867 {
3868 Elf_Internal_Rela outrel;
3869 bfd_byte *loc;
3870
3871 if (globals->srelgot == NULL)
3872 abort ();
3873
3874 outrel.r_addend = 0;
3875 outrel.r_offset = (globals->sgot->output_section->vma
3876 + globals->sgot->output_offset + off);
3877 outrel.r_info = ELF32_R_INFO (0, R_ARM_TLS_DTPMOD32);
3878
3879 if (globals->use_rel)
3880 bfd_put_32 (output_bfd, outrel.r_addend,
3881 globals->sgot->contents + off);
3882
3883 loc = globals->srelgot->contents;
3884 loc += globals->srelgot->reloc_count++ * RELOC_SIZE (globals);
3885 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
3886 }
3887 else
3888 bfd_put_32 (output_bfd, 1, globals->sgot->contents + off);
3889
3890 globals->tls_ldm_got.offset |= 1;
3891 }
3892
3893 value = globals->sgot->output_section->vma + globals->sgot->output_offset + off
3894 - (input_section->output_section->vma + input_section->output_offset + rel->r_offset);
3895
3896 return _bfd_final_link_relocate (howto, input_bfd, input_section,
3897 contents, rel->r_offset, value,
3898 rel->r_addend);
3899 }
3900
3901 case R_ARM_TLS_GD32:
3902 case R_ARM_TLS_IE32:
3903 {
3904 bfd_vma off;
3905 int indx;
3906 char tls_type;
3907
3908 if (globals->sgot == NULL)
3909 abort ();
3910
3911 indx = 0;
3912 if (h != NULL)
3913 {
3914 bfd_boolean dyn;
3915 dyn = globals->root.dynamic_sections_created;
3916 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3917 && (!info->shared
3918 || !SYMBOL_REFERENCES_LOCAL (info, h)))
3919 {
3920 *unresolved_reloc_p = FALSE;
3921 indx = h->dynindx;
3922 }
3923 off = h->got.offset;
3924 tls_type = ((struct elf32_arm_link_hash_entry *) h)->tls_type;
3925 }
3926 else
3927 {
3928 if (local_got_offsets == NULL)
3929 abort ();
3930 off = local_got_offsets[r_symndx];
3931 tls_type = elf32_arm_local_got_tls_type (input_bfd)[r_symndx];
3932 }
3933
3934 if (tls_type == GOT_UNKNOWN)
3935 abort ();
3936
3937 if ((off & 1) != 0)
3938 off &= ~1;
3939 else
3940 {
3941 bfd_boolean need_relocs = FALSE;
3942 Elf_Internal_Rela outrel;
3943 bfd_byte *loc = NULL;
3944 int cur_off = off;
3945
3946 /* The GOT entries have not been initialized yet. Do it
3947 now, and emit any relocations. If both an IE GOT and a
3948 GD GOT are necessary, we emit the GD first. */
3949
3950 if ((info->shared || indx != 0)
3951 && (h == NULL
3952 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3953 || h->root.type != bfd_link_hash_undefweak))
3954 {
3955 need_relocs = TRUE;
3956 if (globals->srelgot == NULL)
3957 abort ();
3958 loc = globals->srelgot->contents;
3959 loc += globals->srelgot->reloc_count * RELOC_SIZE (globals);
3960 }
3961
3962 if (tls_type & GOT_TLS_GD)
3963 {
3964 if (need_relocs)
3965 {
3966 outrel.r_addend = 0;
3967 outrel.r_offset = (globals->sgot->output_section->vma
3968 + globals->sgot->output_offset
3969 + cur_off);
3970 outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_DTPMOD32);
3971
3972 if (globals->use_rel)
3973 bfd_put_32 (output_bfd, outrel.r_addend,
3974 globals->sgot->contents + cur_off);
3975
3976 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
3977 globals->srelgot->reloc_count++;
3978 loc += RELOC_SIZE (globals);
3979
3980 if (indx == 0)
3981 bfd_put_32 (output_bfd, value - dtpoff_base (info),
3982 globals->sgot->contents + cur_off + 4);
3983 else
3984 {
3985 outrel.r_addend = 0;
3986 outrel.r_info = ELF32_R_INFO (indx,
3987 R_ARM_TLS_DTPOFF32);
3988 outrel.r_offset += 4;
3989
3990 if (globals->use_rel)
3991 bfd_put_32 (output_bfd, outrel.r_addend,
3992 globals->sgot->contents + cur_off + 4);
3993
3994
3995 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
3996 globals->srelgot->reloc_count++;
3997 loc += RELOC_SIZE (globals);
3998 }
3999 }
4000 else
4001 {
4002 /* If we are not emitting relocations for a
4003 general dynamic reference, then we must be in a
4004 static link or an executable link with the
4005 symbol binding locally. Mark it as belonging
4006 to module 1, the executable. */
4007 bfd_put_32 (output_bfd, 1,
4008 globals->sgot->contents + cur_off);
4009 bfd_put_32 (output_bfd, value - dtpoff_base (info),
4010 globals->sgot->contents + cur_off + 4);
4011 }
4012
4013 cur_off += 8;
4014 }
4015
4016 if (tls_type & GOT_TLS_IE)
4017 {
4018 if (need_relocs)
4019 {
4020 if (indx == 0)
4021 outrel.r_addend = value - dtpoff_base (info);
4022 else
4023 outrel.r_addend = 0;
4024 outrel.r_offset = (globals->sgot->output_section->vma
4025 + globals->sgot->output_offset
4026 + cur_off);
4027 outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_TPOFF32);
4028
4029 if (globals->use_rel)
4030 bfd_put_32 (output_bfd, outrel.r_addend,
4031 globals->sgot->contents + cur_off);
4032
4033 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
4034 globals->srelgot->reloc_count++;
4035 loc += RELOC_SIZE (globals);
4036 }
4037 else
4038 bfd_put_32 (output_bfd, tpoff (info, value),
4039 globals->sgot->contents + cur_off);
4040 cur_off += 4;
4041 }
4042
4043 if (h != NULL)
4044 h->got.offset |= 1;
4045 else
4046 local_got_offsets[r_symndx] |= 1;
4047 }
4048
4049 if ((tls_type & GOT_TLS_GD) && r_type != R_ARM_TLS_GD32)
4050 off += 8;
4051 value = globals->sgot->output_section->vma + globals->sgot->output_offset + off
4052 - (input_section->output_section->vma + input_section->output_offset + rel->r_offset);
4053
4054 return _bfd_final_link_relocate (howto, input_bfd, input_section,
4055 contents, rel->r_offset, value,
4056 rel->r_addend);
4057 }
4058
4059 case R_ARM_TLS_LE32:
4060 if (info->shared)
4061 {
4062 (*_bfd_error_handler)
4063 (_("%B(%A+0x%lx): R_ARM_TLS_LE32 relocation not permitted in shared object"),
4064 input_bfd, input_section,
4065 (long) rel->r_offset, howto->name);
4066 return FALSE;
4067 }
4068 else
4069 value = tpoff (info, value);
4070
4071 return _bfd_final_link_relocate (howto, input_bfd, input_section,
4072 contents, rel->r_offset, value,
4073 rel->r_addend);
4074
4075 case R_ARM_V4BX:
4076 if (globals->fix_v4bx)
4077 {
4078 bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
4079
4080 /* Ensure that we have a BX instruction. */
4081 BFD_ASSERT ((insn & 0x0ffffff0) == 0x012fff10);
4082
4083 /* Preserve Rm (lowest four bits) and the condition code
4084 (highest four bits). Other bits encode MOV PC,Rm. */
4085 insn = (insn & 0xf000000f) | 0x01a0f000;
4086
4087 bfd_put_32 (input_bfd, insn, hit_data);
4088 }
4089 return bfd_reloc_ok;
4090
4091 case R_ARM_MOVW_ABS_NC:
4092 case R_ARM_MOVT_ABS:
4093 case R_ARM_MOVW_PREL_NC:
4094 case R_ARM_MOVT_PREL:
4095 {
4096 bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
4097
4098 if (globals->use_rel)
4099 {
4100 addend = ((insn >> 4) & 0xf000) | (insn & 0xfff);
4101 signed_addend = (addend ^ 0x10000) - 0x10000;
4102 }
4103 value += signed_addend;
4104 if (sym_flags == STT_ARM_TFUNC)
4105 value |= 1;
4106
4107 if (r_type == R_ARM_MOVW_PREL_NC || r_type == R_ARM_MOVT_PREL)
4108 value -= (input_section->output_section->vma
4109 + input_section->output_offset + rel->r_offset);
4110
4111 if (r_type == R_ARM_MOVT_ABS || r_type == R_ARM_MOVT_PREL)
4112 value >>= 16;
4113
4114 insn &= 0xfff0f000;
4115 insn |= value & 0xfff;
4116 insn |= (value & 0xf000) << 4;
4117 bfd_put_32 (input_bfd, insn, hit_data);
4118 }
4119 return bfd_reloc_ok;
4120
4121 case R_ARM_THM_MOVW_ABS_NC:
4122 case R_ARM_THM_MOVT_ABS:
4123 case R_ARM_THM_MOVW_PREL_NC:
4124 case R_ARM_THM_MOVT_PREL:
4125 {
4126 bfd_vma insn;
4127
4128 insn = bfd_get_16 (input_bfd, hit_data) << 16;
4129 insn |= bfd_get_16 (input_bfd, hit_data + 2);
4130
4131 if (globals->use_rel)
4132 {
4133 addend = ((insn >> 4) & 0xf000)
4134 | ((insn >> 15) & 0x0800)
4135 | ((insn >> 4) & 0x0700)
4136 | (insn & 0x00ff);
4137 signed_addend = (addend ^ 0x10000) - 0x10000;
4138 }
4139 value += signed_addend;
4140 if (sym_flags == STT_ARM_TFUNC)
4141 value |= 1;
4142
4143 if (r_type == R_ARM_THM_MOVW_PREL_NC || r_type == R_ARM_THM_MOVT_PREL)
4144 value -= (input_section->output_section->vma
4145 + input_section->output_offset + rel->r_offset);
4146
4147 if (r_type == R_ARM_THM_MOVT_ABS || r_type == R_ARM_THM_MOVT_PREL)
4148 value >>= 16;
4149
4150 insn &= 0xfbf08f00;
4151 insn |= (value & 0xf000) << 4;
4152 insn |= (value & 0x0800) << 15;
4153 insn |= (value & 0x0700) << 4;
4154 insn |= (value & 0x00ff);
4155
4156 bfd_put_16 (input_bfd, insn >> 16, hit_data);
4157 bfd_put_16 (input_bfd, insn & 0xffff, hit_data + 2);
4158 }
4159 return bfd_reloc_ok;
4160
4161 default:
4162 return bfd_reloc_notsupported;
4163 }
4164 }
4165
4166
4167 static int
4168 uleb128_size (unsigned int i)
4169 {
4170 int size;
4171 size = 1;
4172 while (i >= 0x80)
4173 {
4174 i >>= 7;
4175 size++;
4176 }
4177 return size;
4178 }
4179
4180 /* Return TRUE if the attribute has the default value (0/""). */
4181 static bfd_boolean
4182 is_default_attr (aeabi_attribute *attr)
4183 {
4184 if ((attr->type & 1) && attr->i != 0)
4185 return FALSE;
4186 if ((attr->type & 2) && attr->s && *attr->s)
4187 return FALSE;
4188
4189 return TRUE;
4190 }
4191
4192 /* Return the size of a single attribute. */
4193 static bfd_vma
4194 eabi_attr_size(int tag, aeabi_attribute *attr)
4195 {
4196 bfd_vma size;
4197
4198 if (is_default_attr (attr))
4199 return 0;
4200
4201 size = uleb128_size (tag);
4202 if (attr->type & 1)
4203 size += uleb128_size (attr->i);
4204 if (attr->type & 2)
4205 size += strlen ((char *)attr->s) + 1;
4206 return size;
4207 }
4208
4209 /* Returns the size of the eabi object attributess section. */
4210 bfd_vma
4211 elf32_arm_eabi_attr_size (bfd *abfd)
4212 {
4213 bfd_vma size;
4214 aeabi_attribute *attr;
4215 aeabi_attribute_list *list;
4216 int i;
4217
4218 attr = elf32_arm_tdata (abfd)->known_eabi_attributes;
4219 size = 16; /* 'A' <size> "aeabi" 0x1 <size>. */
4220 for (i = 4; i < NUM_KNOWN_ATTRIBUTES; i++)
4221 size += eabi_attr_size (i, &attr[i]);
4222
4223 for (list = elf32_arm_tdata (abfd)->other_eabi_attributes;
4224 list;
4225 list = list->next)
4226 size += eabi_attr_size (list->tag, &list->attr);
4227
4228 return size;
4229 }
4230
4231 static bfd_byte *
4232 write_uleb128 (bfd_byte *p, unsigned int val)
4233 {
4234 bfd_byte c;
4235 do
4236 {
4237 c = val & 0x7f;
4238 val >>= 7;
4239 if (val)
4240 c |= 0x80;
4241 *(p++) = c;
4242 }
4243 while (val);
4244 return p;
4245 }
4246
4247 /* Write attribute ATTR to butter P, and return a pointer to the following
4248 byte. */
4249 static bfd_byte *
4250 write_eabi_attribute (bfd_byte *p, int tag, aeabi_attribute *attr)
4251 {
4252 /* Suppress default entries. */
4253 if (is_default_attr(attr))
4254 return p;
4255
4256 p = write_uleb128 (p, tag);
4257 if (attr->type & 1)
4258 p = write_uleb128 (p, attr->i);
4259 if (attr->type & 2)
4260 {
4261 int len;
4262
4263 len = strlen (attr->s) + 1;
4264 memcpy (p, attr->s, len);
4265 p += len;
4266 }
4267
4268 return p;
4269 }
4270
4271 /* Write the contents of the eabi attributes section to p. */
4272 void
4273 elf32_arm_set_eabi_attr_contents (bfd *abfd, bfd_byte *contents, bfd_vma size)
4274 {
4275 bfd_byte *p;
4276 aeabi_attribute *attr;
4277 aeabi_attribute_list *list;
4278 int i;
4279
4280 p = contents;
4281 *(p++) = 'A';
4282 bfd_put_32 (abfd, size - 1, p);
4283 p += 4;
4284 memcpy (p, "aeabi", 6);
4285 p += 6;
4286 *(p++) = Tag_File;
4287 bfd_put_32 (abfd, size - 11, p);
4288 p += 4;
4289
4290 attr = elf32_arm_tdata (abfd)->known_eabi_attributes;
4291 for (i = 4; i < NUM_KNOWN_ATTRIBUTES; i++)
4292 p = write_eabi_attribute (p, i, &attr[i]);
4293
4294 for (list = elf32_arm_tdata (abfd)->other_eabi_attributes;
4295 list;
4296 list = list->next)
4297 p = write_eabi_attribute (p, list->tag, &list->attr);
4298 }
4299
4300 /* Override final_link to handle EABI object attribute sections. */
4301
4302 static bfd_boolean
4303 elf32_arm_bfd_final_link (bfd *abfd, struct bfd_link_info *info)
4304 {
4305 asection *o;
4306 struct bfd_link_order *p;
4307 asection *attr_section = NULL;
4308 bfd_byte *contents;
4309 bfd_vma size = 0;
4310
4311 /* elf32_arm_merge_private_bfd_data will already have merged the
4312 object attributes. Remove the input sections from the link, and set
4313 the contents of the output secton. */
4314 for (o = abfd->sections; o != NULL; o = o->next)
4315 {
4316 if (strcmp (o->name, ".ARM.attributes") == 0)
4317 {
4318 for (p = o->map_head.link_order; p != NULL; p = p->next)
4319 {
4320 asection *input_section;
4321
4322 if (p->type != bfd_indirect_link_order)
4323 continue;
4324 input_section = p->u.indirect.section;
4325 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4326 elf_link_input_bfd ignores this section. */
4327 input_section->flags &= ~SEC_HAS_CONTENTS;
4328 }
4329
4330 size = elf32_arm_eabi_attr_size (abfd);
4331 bfd_set_section_size (abfd, o, size);
4332 attr_section = o;
4333 /* Skip this section later on. */
4334 o->map_head.link_order = NULL;
4335 }
4336 }
4337 /* Invoke the ELF linker to do all the work. */
4338 if (!bfd_elf_final_link (abfd, info))
4339 return FALSE;
4340
4341 if (attr_section)
4342 {
4343 contents = bfd_malloc(size);
4344 if (contents == NULL)
4345 return FALSE;
4346 elf32_arm_set_eabi_attr_contents (abfd, contents, size);
4347 bfd_set_section_contents (abfd, attr_section, contents, 0, size);
4348 free (contents);
4349 }
4350 return TRUE;
4351 }
4352
4353
4354 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
4355 static void
4356 arm_add_to_rel (bfd * abfd,
4357 bfd_byte * address,
4358 reloc_howto_type * howto,
4359 bfd_signed_vma increment)
4360 {
4361 bfd_signed_vma addend;
4362
4363 if (howto->type == R_ARM_THM_CALL)
4364 {
4365 int upper_insn, lower_insn;
4366 int upper, lower;
4367
4368 upper_insn = bfd_get_16 (abfd, address);
4369 lower_insn = bfd_get_16 (abfd, address + 2);
4370 upper = upper_insn & 0x7ff;
4371 lower = lower_insn & 0x7ff;
4372
4373 addend = (upper << 12) | (lower << 1);
4374 addend += increment;
4375 addend >>= 1;
4376
4377 upper_insn = (upper_insn & 0xf800) | ((addend >> 11) & 0x7ff);
4378 lower_insn = (lower_insn & 0xf800) | (addend & 0x7ff);
4379
4380 bfd_put_16 (abfd, (bfd_vma) upper_insn, address);
4381 bfd_put_16 (abfd, (bfd_vma) lower_insn, address + 2);
4382 }
4383 else
4384 {
4385 bfd_vma contents;
4386
4387 contents = bfd_get_32 (abfd, address);
4388
4389 /* Get the (signed) value from the instruction. */
4390 addend = contents & howto->src_mask;
4391 if (addend & ((howto->src_mask + 1) >> 1))
4392 {
4393 bfd_signed_vma mask;
4394
4395 mask = -1;
4396 mask &= ~ howto->src_mask;
4397 addend |= mask;
4398 }
4399
4400 /* Add in the increment, (which is a byte value). */
4401 switch (howto->type)
4402 {
4403 default:
4404 addend += increment;
4405 break;
4406
4407 case R_ARM_PC24:
4408 case R_ARM_PLT32:
4409 case R_ARM_CALL:
4410 case R_ARM_JUMP24:
4411 addend <<= howto->size;
4412 addend += increment;
4413
4414 /* Should we check for overflow here ? */
4415
4416 /* Drop any undesired bits. */
4417 addend >>= howto->rightshift;
4418 break;
4419 }
4420
4421 contents = (contents & ~ howto->dst_mask) | (addend & howto->dst_mask);
4422
4423 bfd_put_32 (abfd, contents, address);
4424 }
4425 }
4426
4427 #define IS_ARM_TLS_RELOC(R_TYPE) \
4428 ((R_TYPE) == R_ARM_TLS_GD32 \
4429 || (R_TYPE) == R_ARM_TLS_LDO32 \
4430 || (R_TYPE) == R_ARM_TLS_LDM32 \
4431 || (R_TYPE) == R_ARM_TLS_DTPOFF32 \
4432 || (R_TYPE) == R_ARM_TLS_DTPMOD32 \
4433 || (R_TYPE) == R_ARM_TLS_TPOFF32 \
4434 || (R_TYPE) == R_ARM_TLS_LE32 \
4435 || (R_TYPE) == R_ARM_TLS_IE32)
4436
4437 /* Relocate an ARM ELF section. */
4438 static bfd_boolean
4439 elf32_arm_relocate_section (bfd * output_bfd,
4440 struct bfd_link_info * info,
4441 bfd * input_bfd,
4442 asection * input_section,
4443 bfd_byte * contents,
4444 Elf_Internal_Rela * relocs,
4445 Elf_Internal_Sym * local_syms,
4446 asection ** local_sections)
4447 {
4448 Elf_Internal_Shdr *symtab_hdr;
4449 struct elf_link_hash_entry **sym_hashes;
4450 Elf_Internal_Rela *rel;
4451 Elf_Internal_Rela *relend;
4452 const char *name;
4453 struct elf32_arm_link_hash_table * globals;
4454
4455 globals = elf32_arm_hash_table (info);
4456 if (info->relocatable && !globals->use_rel)
4457 return TRUE;
4458
4459 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
4460 sym_hashes = elf_sym_hashes (input_bfd);
4461
4462 rel = relocs;
4463 relend = relocs + input_section->reloc_count;
4464 for (; rel < relend; rel++)
4465 {
4466 int r_type;
4467 reloc_howto_type * howto;
4468 unsigned long r_symndx;
4469 Elf_Internal_Sym * sym;
4470 asection * sec;
4471 struct elf_link_hash_entry * h;
4472 bfd_vma relocation;
4473 bfd_reloc_status_type r;
4474 arelent bfd_reloc;
4475 char sym_type;
4476 bfd_boolean unresolved_reloc = FALSE;
4477
4478 r_symndx = ELF32_R_SYM (rel->r_info);
4479 r_type = ELF32_R_TYPE (rel->r_info);
4480 r_type = arm_real_reloc_type (globals, r_type);
4481
4482 if ( r_type == R_ARM_GNU_VTENTRY
4483 || r_type == R_ARM_GNU_VTINHERIT)
4484 continue;
4485
4486 bfd_reloc.howto = elf32_arm_howto_from_type (r_type);
4487 howto = bfd_reloc.howto;
4488
4489 if (info->relocatable && globals->use_rel)
4490 {
4491 /* This is a relocatable link. We don't have to change
4492 anything, unless the reloc is against a section symbol,
4493 in which case we have to adjust according to where the
4494 section symbol winds up in the output section. */
4495 if (r_symndx < symtab_hdr->sh_info)
4496 {
4497 sym = local_syms + r_symndx;
4498 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4499 {
4500 sec = local_sections[r_symndx];
4501 arm_add_to_rel (input_bfd, contents + rel->r_offset,
4502 howto,
4503 (bfd_signed_vma) (sec->output_offset
4504 + sym->st_value));
4505 }
4506 }
4507
4508 continue;
4509 }
4510
4511 /* This is a final link. */
4512 h = NULL;
4513 sym = NULL;
4514 sec = NULL;
4515
4516 if (r_symndx < symtab_hdr->sh_info)
4517 {
4518 sym = local_syms + r_symndx;
4519 sym_type = ELF32_ST_TYPE (sym->st_info);
4520 sec = local_sections[r_symndx];
4521 if (globals->use_rel)
4522 {
4523 relocation = (sec->output_section->vma
4524 + sec->output_offset
4525 + sym->st_value);
4526 if ((sec->flags & SEC_MERGE)
4527 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4528 {
4529 asection *msec;
4530 bfd_vma addend, value;
4531
4532 if (howto->rightshift)
4533 {
4534 (*_bfd_error_handler)
4535 (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
4536 input_bfd, input_section,
4537 (long) rel->r_offset, howto->name);
4538 return FALSE;
4539 }
4540
4541 value = bfd_get_32 (input_bfd, contents + rel->r_offset);
4542
4543 /* Get the (signed) value from the instruction. */
4544 addend = value & howto->src_mask;
4545 if (addend & ((howto->src_mask + 1) >> 1))
4546 {
4547 bfd_signed_vma mask;
4548
4549 mask = -1;
4550 mask &= ~ howto->src_mask;
4551 addend |= mask;
4552 }
4553 msec = sec;
4554 addend =
4555 _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
4556 - relocation;
4557 addend += msec->output_section->vma + msec->output_offset;
4558 value = (value & ~ howto->dst_mask) | (addend & howto->dst_mask);
4559 bfd_put_32 (input_bfd, value, contents + rel->r_offset);
4560 }
4561 }
4562 else
4563 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
4564 }
4565 else
4566 {
4567 bfd_boolean warned;
4568
4569 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
4570 r_symndx, symtab_hdr, sym_hashes,
4571 h, sec, relocation,
4572 unresolved_reloc, warned);
4573
4574 sym_type = h->type;
4575 }
4576
4577 if (h != NULL)
4578 name = h->root.root.string;
4579 else
4580 {
4581 name = (bfd_elf_string_from_elf_section
4582 (input_bfd, symtab_hdr->sh_link, sym->st_name));
4583 if (name == NULL || *name == '\0')
4584 name = bfd_section_name (input_bfd, sec);
4585 }
4586
4587 if (r_symndx != 0
4588 && r_type != R_ARM_NONE
4589 && (h == NULL
4590 || h->root.type == bfd_link_hash_defined
4591 || h->root.type == bfd_link_hash_defweak)
4592 && IS_ARM_TLS_RELOC (r_type) != (sym_type == STT_TLS))
4593 {
4594 (*_bfd_error_handler)
4595 ((sym_type == STT_TLS
4596 ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
4597 : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
4598 input_bfd,
4599 input_section,
4600 (long) rel->r_offset,
4601 howto->name,
4602 name);
4603 }
4604
4605 r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
4606 input_section, contents, rel,
4607 relocation, info, sec, name,
4608 (h ? ELF_ST_TYPE (h->type) :
4609 ELF_ST_TYPE (sym->st_info)), h,
4610 &unresolved_reloc);
4611
4612 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4613 because such sections are not SEC_ALLOC and thus ld.so will
4614 not process them. */
4615 if (unresolved_reloc
4616 && !((input_section->flags & SEC_DEBUGGING) != 0
4617 && h->def_dynamic))
4618 {
4619 (*_bfd_error_handler)
4620 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4621 input_bfd,
4622 input_section,
4623 (long) rel->r_offset,
4624 howto->name,
4625 h->root.root.string);
4626 return FALSE;
4627 }
4628
4629 if (r != bfd_reloc_ok)
4630 {
4631 const char * msg = (const char *) 0;
4632
4633 switch (r)
4634 {
4635 case bfd_reloc_overflow:
4636 /* If the overflowing reloc was to an undefined symbol,
4637 we have already printed one error message and there
4638 is no point complaining again. */
4639 if ((! h ||
4640 h->root.type != bfd_link_hash_undefined)
4641 && (!((*info->callbacks->reloc_overflow)
4642 (info, (h ? &h->root : NULL), name, howto->name,
4643 (bfd_vma) 0, input_bfd, input_section,
4644 rel->r_offset))))
4645 return FALSE;
4646 break;
4647
4648 case bfd_reloc_undefined:
4649 if (!((*info->callbacks->undefined_symbol)
4650 (info, name, input_bfd, input_section,
4651 rel->r_offset, TRUE)))
4652 return FALSE;
4653 break;
4654
4655 case bfd_reloc_outofrange:
4656 msg = _("internal error: out of range error");
4657 goto common_error;
4658
4659 case bfd_reloc_notsupported:
4660 msg = _("internal error: unsupported relocation error");
4661 goto common_error;
4662
4663 case bfd_reloc_dangerous:
4664 msg = _("internal error: dangerous error");
4665 goto common_error;
4666
4667 default:
4668 msg = _("internal error: unknown error");
4669 /* fall through */
4670
4671 common_error:
4672 if (!((*info->callbacks->warning)
4673 (info, msg, name, input_bfd, input_section,
4674 rel->r_offset)))
4675 return FALSE;
4676 break;
4677 }
4678 }
4679 }
4680
4681 return TRUE;
4682 }
4683
4684 /* Allocate/find an object attribute. */
4685 static aeabi_attribute *
4686 elf32_arm_new_eabi_attr (bfd *abfd, int tag)
4687 {
4688 aeabi_attribute *attr;
4689 aeabi_attribute_list *list;
4690 aeabi_attribute_list *p;
4691 aeabi_attribute_list **lastp;
4692
4693
4694 if (tag < NUM_KNOWN_ATTRIBUTES)
4695 {
4696 /* Knwon tags are preallocated. */
4697 attr = &elf32_arm_tdata (abfd)->known_eabi_attributes[tag];
4698 }
4699 else
4700 {
4701 /* Create a new tag. */
4702 list = (aeabi_attribute_list *)
4703 bfd_alloc (abfd, sizeof (aeabi_attribute_list));
4704 memset (list, 0, sizeof (aeabi_attribute_list));
4705 list->tag = tag;
4706 /* Keep the tag list in order. */
4707 lastp = &elf32_arm_tdata (abfd)->other_eabi_attributes;
4708 for (p = *lastp; p; p = p->next)
4709 {
4710 if (tag < p->tag)
4711 break;
4712 lastp = &p->next;
4713 }
4714 list->next = *lastp;
4715 *lastp = list;
4716 attr = &list->attr;
4717 }
4718
4719 return attr;
4720 }
4721
4722 int
4723 elf32_arm_get_eabi_attr_int (bfd *abfd, int tag)
4724 {
4725 aeabi_attribute_list *p;
4726
4727 if (tag < NUM_KNOWN_ATTRIBUTES)
4728 {
4729 /* Knwon tags are preallocated. */
4730 return elf32_arm_tdata (abfd)->known_eabi_attributes[tag].i;
4731 }
4732 else
4733 {
4734 for (p = elf32_arm_tdata (abfd)->other_eabi_attributes;
4735 p;
4736 p = p->next)
4737 {
4738 if (tag == p->tag)
4739 return p->attr.i;
4740 if (tag < p->tag)
4741 break;
4742 }
4743 return 0;
4744 }
4745 }
4746
4747 void
4748 elf32_arm_add_eabi_attr_int (bfd *abfd, int tag, unsigned int i)
4749 {
4750 aeabi_attribute *attr;
4751
4752 attr = elf32_arm_new_eabi_attr (abfd, tag);
4753 attr->type = 1;
4754 attr->i = i;
4755 }
4756
4757 static char *
4758 attr_strdup (bfd *abfd, const char * s)
4759 {
4760 char * p;
4761 int len;
4762
4763 len = strlen (s) + 1;
4764 p = (char *)bfd_alloc(abfd, len);
4765 return memcpy (p, s, len);
4766 }
4767
4768 void
4769 elf32_arm_add_eabi_attr_string (bfd *abfd, int tag, const char *s)
4770 {
4771 aeabi_attribute *attr;
4772
4773 attr = elf32_arm_new_eabi_attr (abfd, tag);
4774 attr->type = 2;
4775 attr->s = attr_strdup (abfd, s);
4776 }
4777
4778 void
4779 elf32_arm_add_eabi_attr_compat (bfd *abfd, unsigned int i, const char *s)
4780 {
4781 aeabi_attribute_list *list;
4782 aeabi_attribute_list *p;
4783 aeabi_attribute_list **lastp;
4784
4785 list = (aeabi_attribute_list *)
4786 bfd_alloc (abfd, sizeof (aeabi_attribute_list));
4787 memset (list, 0, sizeof (aeabi_attribute_list));
4788 list->tag = Tag_compatibility;
4789 list->attr.type = 3;
4790 list->attr.i = i;
4791 list->attr.s = attr_strdup (abfd, s);
4792
4793 lastp = &elf32_arm_tdata (abfd)->other_eabi_attributes;
4794 for (p = *lastp; p; p = p->next)
4795 {
4796 int cmp;
4797 if (p->tag != Tag_compatibility)
4798 break;
4799 cmp = strcmp(s, p->attr.s);
4800 if (cmp < 0 || (cmp == 0 && i < p->attr.i))
4801 break;
4802 lastp = &p->next;
4803 }
4804 list->next = *lastp;
4805 *lastp = list;
4806 }
4807
4808 /* Set the right machine number. */
4809
4810 static bfd_boolean
4811 elf32_arm_object_p (bfd *abfd)
4812 {
4813 unsigned int mach;
4814
4815 mach = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION);
4816
4817 if (mach != bfd_mach_arm_unknown)
4818 bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
4819
4820 else if (elf_elfheader (abfd)->e_flags & EF_ARM_MAVERICK_FLOAT)
4821 bfd_default_set_arch_mach (abfd, bfd_arch_arm, bfd_mach_arm_ep9312);
4822
4823 else
4824 bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
4825
4826 return TRUE;
4827 }
4828
4829 /* Function to keep ARM specific flags in the ELF header. */
4830
4831 static bfd_boolean
4832 elf32_arm_set_private_flags (bfd *abfd, flagword flags)
4833 {
4834 if (elf_flags_init (abfd)
4835 && elf_elfheader (abfd)->e_flags != flags)
4836 {
4837 if (EF_ARM_EABI_VERSION (flags) == EF_ARM_EABI_UNKNOWN)
4838 {
4839 if (flags & EF_ARM_INTERWORK)
4840 (*_bfd_error_handler)
4841 (_("Warning: Not setting interworking flag of %B since it has already been specified as non-interworking"),
4842 abfd);
4843 else
4844 _bfd_error_handler
4845 (_("Warning: Clearing the interworking flag of %B due to outside request"),
4846 abfd);
4847 }
4848 }
4849 else
4850 {
4851 elf_elfheader (abfd)->e_flags = flags;
4852 elf_flags_init (abfd) = TRUE;
4853 }
4854
4855 return TRUE;
4856 }
4857
4858 /* Copy the eabi object attribute from IBFD to OBFD. */
4859 static void
4860 copy_eabi_attributes (bfd *ibfd, bfd *obfd)
4861 {
4862 aeabi_attribute *in_attr;
4863 aeabi_attribute *out_attr;
4864 aeabi_attribute_list *list;
4865 int i;
4866
4867 in_attr = elf32_arm_tdata (ibfd)->known_eabi_attributes;
4868 out_attr = elf32_arm_tdata (obfd)->known_eabi_attributes;
4869 for (i = 4; i < NUM_KNOWN_ATTRIBUTES; i++)
4870 {
4871 out_attr->i = in_attr->i;
4872 if (in_attr->s && *in_attr->s)
4873 out_attr->s = attr_strdup (obfd, in_attr->s);
4874 in_attr++;
4875 out_attr++;
4876 }
4877
4878 for (list = elf32_arm_tdata (ibfd)->other_eabi_attributes;
4879 list;
4880 list = list->next)
4881 {
4882 in_attr = &list->attr;
4883 switch (in_attr->type)
4884 {
4885 case 1:
4886 elf32_arm_add_eabi_attr_int (obfd, list->tag, in_attr->i);
4887 break;
4888 case 2:
4889 elf32_arm_add_eabi_attr_string (obfd, list->tag, in_attr->s);
4890 break;
4891 case 3:
4892 elf32_arm_add_eabi_attr_compat (obfd, in_attr->i, in_attr->s);
4893 break;
4894 default:
4895 abort();
4896 }
4897 }
4898 }
4899
4900
4901 /* Copy backend specific data from one object module to another. */
4902
4903 static bfd_boolean
4904 elf32_arm_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
4905 {
4906 flagword in_flags;
4907 flagword out_flags;
4908
4909 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4910 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4911 return TRUE;
4912
4913 in_flags = elf_elfheader (ibfd)->e_flags;
4914 out_flags = elf_elfheader (obfd)->e_flags;
4915
4916 if (elf_flags_init (obfd)
4917 && EF_ARM_EABI_VERSION (out_flags) == EF_ARM_EABI_UNKNOWN
4918 && in_flags != out_flags)
4919 {
4920 /* Cannot mix APCS26 and APCS32 code. */
4921 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
4922 return FALSE;
4923
4924 /* Cannot mix float APCS and non-float APCS code. */
4925 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
4926 return FALSE;
4927
4928 /* If the src and dest have different interworking flags
4929 then turn off the interworking bit. */
4930 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
4931 {
4932 if (out_flags & EF_ARM_INTERWORK)
4933 _bfd_error_handler
4934 (_("Warning: Clearing the interworking flag of %B because non-interworking code in %B has been linked with it"),
4935 obfd, ibfd);
4936
4937 in_flags &= ~EF_ARM_INTERWORK;
4938 }
4939
4940 /* Likewise for PIC, though don't warn for this case. */
4941 if ((in_flags & EF_ARM_PIC) != (out_flags & EF_ARM_PIC))
4942 in_flags &= ~EF_ARM_PIC;
4943 }
4944
4945 elf_elfheader (obfd)->e_flags = in_flags;
4946 elf_flags_init (obfd) = TRUE;
4947
4948 /* Also copy the EI_OSABI field. */
4949 elf_elfheader (obfd)->e_ident[EI_OSABI] =
4950 elf_elfheader (ibfd)->e_ident[EI_OSABI];
4951
4952 /* Copy EABI object attributes. */
4953 copy_eabi_attributes (ibfd, obfd);
4954
4955 return TRUE;
4956 }
4957
4958 /* Values for Tag_ABI_PCS_R9_use. */
4959 enum
4960 {
4961 AEABI_R9_V6,
4962 AEABI_R9_SB,
4963 AEABI_R9_TLS,
4964 AEABI_R9_unused
4965 };
4966
4967 /* Values for Tag_ABI_PCS_RW_data. */
4968 enum
4969 {
4970 AEABI_PCS_RW_data_absolute,
4971 AEABI_PCS_RW_data_PCrel,
4972 AEABI_PCS_RW_data_SBrel,
4973 AEABI_PCS_RW_data_unused
4974 };
4975
4976 /* Values for Tag_ABI_enum_size. */
4977 enum
4978 {
4979 AEABI_enum_unused,
4980 AEABI_enum_short,
4981 AEABI_enum_wide,
4982 AEABI_enum_forced_wide
4983 };
4984
4985 /* Merge EABI object attributes from IBFD into OBFD. Raise an error if there
4986 are conflicting attributes. */
4987 static bfd_boolean
4988 elf32_arm_merge_eabi_attributes (bfd *ibfd, bfd *obfd)
4989 {
4990 aeabi_attribute *in_attr;
4991 aeabi_attribute *out_attr;
4992 aeabi_attribute_list *in_list;
4993 aeabi_attribute_list *out_list;
4994 /* Some tags have 0 = don't care, 1 = strong requirement,
4995 2 = weak requirement. */
4996 static const int order_312[3] = {3, 1, 2};
4997 int i;
4998
4999 if (!elf32_arm_tdata (ibfd)->known_eabi_attributes[0].i)
5000 {
5001 /* This is the first object. Copy the attributes. */
5002 copy_eabi_attributes (ibfd, obfd);
5003 return TRUE;
5004 }
5005
5006 /* Use the Tag_null value to indicate the attributes have been
5007 initialized. */
5008 elf32_arm_tdata (ibfd)->known_eabi_attributes[0].i = 1;
5009
5010 in_attr = elf32_arm_tdata (ibfd)->known_eabi_attributes;
5011 out_attr = elf32_arm_tdata (obfd)->known_eabi_attributes;
5012 /* This needs to happen before Tag_ABI_FP_number_model is merged. */
5013 if (in_attr[Tag_ABI_VFP_args].i != out_attr[Tag_ABI_VFP_args].i)
5014 {
5015 /* Ignore mismatches if teh object doesn't use floating point. */
5016 if (out_attr[Tag_ABI_FP_number_model].i == 0)
5017 out_attr[Tag_ABI_VFP_args].i = in_attr[Tag_ABI_VFP_args].i;
5018 else if (in_attr[Tag_ABI_FP_number_model].i != 0)
5019 {
5020 _bfd_error_handler
5021 (_("ERROR: %B uses VFP register arguments, %B does not"),
5022 ibfd, obfd);
5023 return FALSE;
5024 }
5025 }
5026
5027 for (i = 4; i < NUM_KNOWN_ATTRIBUTES; i++)
5028 {
5029 /* Merge this attribute with existing attributes. */
5030 switch (i)
5031 {
5032 case Tag_CPU_raw_name:
5033 case Tag_CPU_name:
5034 /* Use whichever has the greatest architecture requirements. */
5035 if (in_attr[Tag_CPU_arch].i > out_attr[Tag_CPU_arch].i)
5036 out_attr[i].s = attr_strdup(obfd, in_attr[i].s);
5037 break;
5038
5039 case Tag_ABI_optimization_goals:
5040 case Tag_ABI_FP_optimization_goals:
5041 /* Use the first value seen. */
5042 break;
5043
5044 case Tag_CPU_arch:
5045 case Tag_ARM_ISA_use:
5046 case Tag_THUMB_ISA_use:
5047 case Tag_VFP_arch:
5048 case Tag_WMMX_arch:
5049 case Tag_NEON_arch:
5050 /* ??? Do NEON and WMMX conflict? */
5051 case Tag_ABI_FP_rounding:
5052 case Tag_ABI_FP_denormal:
5053 case Tag_ABI_FP_exceptions:
5054 case Tag_ABI_FP_user_exceptions:
5055 case Tag_ABI_FP_number_model:
5056 case Tag_ABI_align8_preserved:
5057 case Tag_ABI_HardFP_use:
5058 /* Use the largest value specified. */
5059 if (in_attr[i].i > out_attr[i].i)
5060 out_attr[i].i = in_attr[i].i;
5061 break;
5062
5063 case Tag_CPU_arch_profile:
5064 /* Warn if conflicting architecture profiles used. */
5065 if (out_attr[i].i && in_attr[i].i && in_attr[i].i != out_attr[i].i)
5066 {
5067 _bfd_error_handler
5068 (_("ERROR: %B: Conflicting architecture profiles %c/%c"),
5069 ibfd, in_attr[i].i, out_attr[i].i);
5070 return FALSE;
5071 }
5072 if (in_attr[i].i)
5073 out_attr[i].i = in_attr[i].i;
5074 break;
5075 case Tag_PCS_config:
5076 if (out_attr[i].i == 0)
5077 out_attr[i].i = in_attr[i].i;
5078 else if (in_attr[i].i != 0 && out_attr[i].i != 0)
5079 {
5080 /* It's sometimes ok to mix different configs, so this is only
5081 a warning. */
5082 _bfd_error_handler
5083 (_("Warning: %B: Conflicting platform configuration"), ibfd);
5084 }
5085 break;
5086 case Tag_ABI_PCS_R9_use:
5087 if (out_attr[i].i != AEABI_R9_unused
5088 && in_attr[i].i != AEABI_R9_unused)
5089 {
5090 _bfd_error_handler
5091 (_("ERROR: %B: Conflicting use of R9"), ibfd);
5092 return FALSE;
5093 }
5094 if (out_attr[i].i == AEABI_R9_unused)
5095 out_attr[i].i = in_attr[i].i;
5096 break;
5097 case Tag_ABI_PCS_RW_data:
5098 if (in_attr[i].i == AEABI_PCS_RW_data_SBrel
5099 && out_attr[Tag_ABI_PCS_R9_use].i != AEABI_R9_SB
5100 && out_attr[Tag_ABI_PCS_R9_use].i != AEABI_R9_unused)
5101 {
5102 _bfd_error_handler
5103 (_("ERROR: %B: SB relative addressing conflicts with use of R9"),
5104 ibfd);
5105 return FALSE;
5106 }
5107 /* Use the smallest value specified. */
5108 if (in_attr[i].i < out_attr[i].i)
5109 out_attr[i].i = in_attr[i].i;
5110 break;
5111 case Tag_ABI_PCS_RO_data:
5112 /* Use the smallest value specified. */
5113 if (in_attr[i].i < out_attr[i].i)
5114 out_attr[i].i = in_attr[i].i;
5115 break;
5116 case Tag_ABI_PCS_GOT_use:
5117 if (in_attr[i].i > 2 || out_attr[i].i > 2
5118 || order_312[in_attr[i].i] < order_312[out_attr[i].i])
5119 out_attr[i].i = in_attr[i].i;
5120 break;
5121 case Tag_ABI_PCS_wchar_t:
5122 if (out_attr[i].i && in_attr[i].i && out_attr[i].i != in_attr[i].i)
5123 {
5124 _bfd_error_handler
5125 (_("ERROR: %B: Conflicting definitions of wchar_t"), ibfd);
5126 return FALSE;
5127 }
5128 if (in_attr[i].i)
5129 out_attr[i].i = in_attr[i].i;
5130 break;
5131 case Tag_ABI_align8_needed:
5132 /* ??? Check against Tag_ABI_align8_preserved. */
5133 if (in_attr[i].i > 2 || out_attr[i].i > 2
5134 || order_312[in_attr[i].i] < order_312[out_attr[i].i])
5135 out_attr[i].i = in_attr[i].i;
5136 break;
5137 case Tag_ABI_enum_size:
5138 if (in_attr[i].i != AEABI_enum_unused)
5139 {
5140 if (out_attr[i].i == AEABI_enum_unused
5141 || out_attr[i].i == AEABI_enum_forced_wide)
5142 {
5143 /* The existing object is compatible with anything.
5144 Use whatever requirements the new object has. */
5145 out_attr[i].i = in_attr[i].i;
5146 }
5147 else if (in_attr[i].i != AEABI_enum_forced_wide
5148 && out_attr[i].i != in_attr[i].i)
5149 {
5150 _bfd_error_handler
5151 (_("ERROR: %B: Conflicting enum sizes"), ibfd);
5152 }
5153 }
5154 break;
5155 case Tag_ABI_VFP_args:
5156 /* Aready done. */
5157 break;
5158 case Tag_ABI_WMMX_args:
5159 if (in_attr[i].i != out_attr[i].i)
5160 {
5161 _bfd_error_handler
5162 (_("ERROR: %B uses iWMMXt register arguments, %B does not"),
5163 ibfd, obfd);
5164 return FALSE;
5165 }
5166 break;
5167 default: /* All known attributes should be explicitly covered. */
5168 abort ();
5169 }
5170 }
5171
5172 in_list = elf32_arm_tdata (ibfd)->other_eabi_attributes;
5173 out_list = elf32_arm_tdata (ibfd)->other_eabi_attributes;
5174 while (in_list && in_list->tag == Tag_compatibility)
5175 {
5176 in_attr = &in_list->attr;
5177 if (in_attr->i == 0)
5178 continue;
5179 if (in_attr->i == 1)
5180 {
5181 _bfd_error_handler
5182 (_("ERROR: %B: Must be processed by '%s' toolchain"),
5183 ibfd, in_attr->s);
5184 return FALSE;
5185 }
5186 if (!out_list || out_list->tag != Tag_compatibility
5187 || strcmp (in_attr->s, out_list->attr.s) != 0)
5188 {
5189 /* Add this compatibility tag to the output. */
5190 elf32_arm_add_eabi_attr_compat (obfd, in_attr->i, in_attr->s);
5191 continue;
5192 }
5193 out_attr = &out_list->attr;
5194 /* Check all the input tags with the same identifier. */
5195 for (;;)
5196 {
5197 if (out_list->tag != Tag_compatibility
5198 || in_attr->i != out_attr->i
5199 || strcmp (in_attr->s, out_attr->s) != 0)
5200 {
5201 _bfd_error_handler
5202 (_("ERROR: %B: Incompatible object tag '%s':%d"),
5203 ibfd, in_attr->s, in_attr->i);
5204 return FALSE;
5205 }
5206 in_list = in_list->next;
5207 if (in_list->tag != Tag_compatibility
5208 || strcmp (in_attr->s, in_list->attr.s) != 0)
5209 break;
5210 in_attr = &in_list->attr;
5211 out_list = out_list->next;
5212 if (out_list)
5213 out_attr = &out_list->attr;
5214 }
5215
5216 /* Check the output doesn't have extra tags with this identifier. */
5217 if (out_list && out_list->tag == Tag_compatibility
5218 && strcmp (in_attr->s, out_list->attr.s) == 0)
5219 {
5220 _bfd_error_handler
5221 (_("ERROR: %B: Incompatible object tag '%s':%d"),
5222 ibfd, in_attr->s, out_list->attr.i);
5223 return FALSE;
5224 }
5225 }
5226
5227 for (; in_list; in_list = in_list->next)
5228 {
5229 if ((in_list->tag & 128) < 64)
5230 {
5231 _bfd_error_handler
5232 (_("Warning: %B: Unknown EABI object attribute %d"),
5233 ibfd, in_list->tag);
5234 break;
5235 }
5236 }
5237 return TRUE;
5238 }
5239
5240
5241 /* Return TRUE if the two EABI versions are incompatible. */
5242
5243 static bfd_boolean
5244 elf32_arm_versions_compatible (unsigned iver, unsigned over)
5245 {
5246 /* v4 and v5 are the same spec before and after it was released,
5247 so allow mixing them. */
5248 if ((iver == EF_ARM_EABI_VER4 && over == EF_ARM_EABI_VER5)
5249 || (iver == EF_ARM_EABI_VER5 && over == EF_ARM_EABI_VER4))
5250 return TRUE;
5251
5252 return (iver == over);
5253 }
5254
5255 /* Merge backend specific data from an object file to the output
5256 object file when linking. */
5257
5258 static bfd_boolean
5259 elf32_arm_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
5260 {
5261 flagword out_flags;
5262 flagword in_flags;
5263 bfd_boolean flags_compatible = TRUE;
5264 asection *sec;
5265
5266 /* Check if we have the same endianess. */
5267 if (! _bfd_generic_verify_endian_match (ibfd, obfd))
5268 return FALSE;
5269
5270 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5271 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5272 return TRUE;
5273
5274 if (!elf32_arm_merge_eabi_attributes (ibfd, obfd))
5275 return FALSE;
5276
5277 /* The input BFD must have had its flags initialised. */
5278 /* The following seems bogus to me -- The flags are initialized in
5279 the assembler but I don't think an elf_flags_init field is
5280 written into the object. */
5281 /* BFD_ASSERT (elf_flags_init (ibfd)); */
5282
5283 in_flags = elf_elfheader (ibfd)->e_flags;
5284 out_flags = elf_elfheader (obfd)->e_flags;
5285
5286 if (!elf_flags_init (obfd))
5287 {
5288 /* If the input is the default architecture and had the default
5289 flags then do not bother setting the flags for the output
5290 architecture, instead allow future merges to do this. If no
5291 future merges ever set these flags then they will retain their
5292 uninitialised values, which surprise surprise, correspond
5293 to the default values. */
5294 if (bfd_get_arch_info (ibfd)->the_default
5295 && elf_elfheader (ibfd)->e_flags == 0)
5296 return TRUE;
5297
5298 elf_flags_init (obfd) = TRUE;
5299 elf_elfheader (obfd)->e_flags = in_flags;
5300
5301 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
5302 && bfd_get_arch_info (obfd)->the_default)
5303 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
5304
5305 return TRUE;
5306 }
5307
5308 /* Determine what should happen if the input ARM architecture
5309 does not match the output ARM architecture. */
5310 if (! bfd_arm_merge_machines (ibfd, obfd))
5311 return FALSE;
5312
5313 /* Identical flags must be compatible. */
5314 if (in_flags == out_flags)
5315 return TRUE;
5316
5317 /* Check to see if the input BFD actually contains any sections. If
5318 not, its flags may not have been initialised either, but it
5319 cannot actually cause any incompatiblity. Do not short-circuit
5320 dynamic objects; their section list may be emptied by
5321 elf_link_add_object_symbols.
5322
5323 Also check to see if there are no code sections in the input.
5324 In this case there is no need to check for code specific flags.
5325 XXX - do we need to worry about floating-point format compatability
5326 in data sections ? */
5327 if (!(ibfd->flags & DYNAMIC))
5328 {
5329 bfd_boolean null_input_bfd = TRUE;
5330 bfd_boolean only_data_sections = TRUE;
5331
5332 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
5333 {
5334 /* Ignore synthetic glue sections. */
5335 if (strcmp (sec->name, ".glue_7")
5336 && strcmp (sec->name, ".glue_7t"))
5337 {
5338 if ((bfd_get_section_flags (ibfd, sec)
5339 & (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
5340 == (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
5341 only_data_sections = FALSE;
5342
5343 null_input_bfd = FALSE;
5344 break;
5345 }
5346 }
5347
5348 if (null_input_bfd || only_data_sections)
5349 return TRUE;
5350 }
5351
5352 /* Complain about various flag mismatches. */
5353 if (!elf32_arm_versions_compatible (EF_ARM_EABI_VERSION (in_flags),
5354 EF_ARM_EABI_VERSION (out_flags)))
5355 {
5356 _bfd_error_handler
5357 (_("ERROR: Source object %B has EABI version %d, but target %B has EABI version %d"),
5358 ibfd, obfd,
5359 (in_flags & EF_ARM_EABIMASK) >> 24,
5360 (out_flags & EF_ARM_EABIMASK) >> 24);
5361 return FALSE;
5362 }
5363
5364 /* Not sure what needs to be checked for EABI versions >= 1. */
5365 /* VxWorks libraries do not use these flags. */
5366 if (get_elf_backend_data (obfd) != &elf32_arm_vxworks_bed
5367 && get_elf_backend_data (ibfd) != &elf32_arm_vxworks_bed
5368 && EF_ARM_EABI_VERSION (in_flags) == EF_ARM_EABI_UNKNOWN)
5369 {
5370 if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
5371 {
5372 _bfd_error_handler
5373 (_("ERROR: %B is compiled for APCS-%d, whereas target %B uses APCS-%d"),
5374 ibfd, obfd,
5375 in_flags & EF_ARM_APCS_26 ? 26 : 32,
5376 out_flags & EF_ARM_APCS_26 ? 26 : 32);
5377 flags_compatible = FALSE;
5378 }
5379
5380 if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
5381 {
5382 if (in_flags & EF_ARM_APCS_FLOAT)
5383 _bfd_error_handler
5384 (_("ERROR: %B passes floats in float registers, whereas %B passes them in integer registers"),
5385 ibfd, obfd);
5386 else
5387 _bfd_error_handler
5388 (_("ERROR: %B passes floats in integer registers, whereas %B passes them in float registers"),
5389 ibfd, obfd);
5390
5391 flags_compatible = FALSE;
5392 }
5393
5394 if ((in_flags & EF_ARM_VFP_FLOAT) != (out_flags & EF_ARM_VFP_FLOAT))
5395 {
5396 if (in_flags & EF_ARM_VFP_FLOAT)
5397 _bfd_error_handler
5398 (_("ERROR: %B uses VFP instructions, whereas %B does not"),
5399 ibfd, obfd);
5400 else
5401 _bfd_error_handler
5402 (_("ERROR: %B uses FPA instructions, whereas %B does not"),
5403 ibfd, obfd);
5404
5405 flags_compatible = FALSE;
5406 }
5407
5408 if ((in_flags & EF_ARM_MAVERICK_FLOAT) != (out_flags & EF_ARM_MAVERICK_FLOAT))
5409 {
5410 if (in_flags & EF_ARM_MAVERICK_FLOAT)
5411 _bfd_error_handler
5412 (_("ERROR: %B uses Maverick instructions, whereas %B does not"),
5413 ibfd, obfd);
5414 else
5415 _bfd_error_handler
5416 (_("ERROR: %B does not use Maverick instructions, whereas %B does"),
5417 ibfd, obfd);
5418
5419 flags_compatible = FALSE;
5420 }
5421
5422 #ifdef EF_ARM_SOFT_FLOAT
5423 if ((in_flags & EF_ARM_SOFT_FLOAT) != (out_flags & EF_ARM_SOFT_FLOAT))
5424 {
5425 /* We can allow interworking between code that is VFP format
5426 layout, and uses either soft float or integer regs for
5427 passing floating point arguments and results. We already
5428 know that the APCS_FLOAT flags match; similarly for VFP
5429 flags. */
5430 if ((in_flags & EF_ARM_APCS_FLOAT) != 0
5431 || (in_flags & EF_ARM_VFP_FLOAT) == 0)
5432 {
5433 if (in_flags & EF_ARM_SOFT_FLOAT)
5434 _bfd_error_handler
5435 (_("ERROR: %B uses software FP, whereas %B uses hardware FP"),
5436 ibfd, obfd);
5437 else
5438 _bfd_error_handler
5439 (_("ERROR: %B uses hardware FP, whereas %B uses software FP"),
5440 ibfd, obfd);
5441
5442 flags_compatible = FALSE;
5443 }
5444 }
5445 #endif
5446
5447 /* Interworking mismatch is only a warning. */
5448 if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
5449 {
5450 if (in_flags & EF_ARM_INTERWORK)
5451 {
5452 _bfd_error_handler
5453 (_("Warning: %B supports interworking, whereas %B does not"),
5454 ibfd, obfd);
5455 }
5456 else
5457 {
5458 _bfd_error_handler
5459 (_("Warning: %B does not support interworking, whereas %B does"),
5460 ibfd, obfd);
5461 }
5462 }
5463 }
5464
5465 return flags_compatible;
5466 }
5467
5468 /* Display the flags field. */
5469
5470 static bfd_boolean
5471 elf32_arm_print_private_bfd_data (bfd *abfd, void * ptr)
5472 {
5473 FILE * file = (FILE *) ptr;
5474 unsigned long flags;
5475
5476 BFD_ASSERT (abfd != NULL && ptr != NULL);
5477
5478 /* Print normal ELF private data. */
5479 _bfd_elf_print_private_bfd_data (abfd, ptr);
5480
5481 flags = elf_elfheader (abfd)->e_flags;
5482 /* Ignore init flag - it may not be set, despite the flags field
5483 containing valid data. */
5484
5485 /* xgettext:c-format */
5486 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
5487
5488 switch (EF_ARM_EABI_VERSION (flags))
5489 {
5490 case EF_ARM_EABI_UNKNOWN:
5491 /* The following flag bits are GNU extensions and not part of the
5492 official ARM ELF extended ABI. Hence they are only decoded if
5493 the EABI version is not set. */
5494 if (flags & EF_ARM_INTERWORK)
5495 fprintf (file, _(" [interworking enabled]"));
5496
5497 if (flags & EF_ARM_APCS_26)
5498 fprintf (file, " [APCS-26]");
5499 else
5500 fprintf (file, " [APCS-32]");
5501
5502 if (flags & EF_ARM_VFP_FLOAT)
5503 fprintf (file, _(" [VFP float format]"));
5504 else if (flags & EF_ARM_MAVERICK_FLOAT)
5505 fprintf (file, _(" [Maverick float format]"));
5506 else
5507 fprintf (file, _(" [FPA float format]"));
5508
5509 if (flags & EF_ARM_APCS_FLOAT)
5510 fprintf (file, _(" [floats passed in float registers]"));
5511
5512 if (flags & EF_ARM_PIC)
5513 fprintf (file, _(" [position independent]"));
5514
5515 if (flags & EF_ARM_NEW_ABI)
5516 fprintf (file, _(" [new ABI]"));
5517
5518 if (flags & EF_ARM_OLD_ABI)
5519 fprintf (file, _(" [old ABI]"));
5520
5521 if (flags & EF_ARM_SOFT_FLOAT)
5522 fprintf (file, _(" [software FP]"));
5523
5524 flags &= ~(EF_ARM_INTERWORK | EF_ARM_APCS_26 | EF_ARM_APCS_FLOAT
5525 | EF_ARM_PIC | EF_ARM_NEW_ABI | EF_ARM_OLD_ABI
5526 | EF_ARM_SOFT_FLOAT | EF_ARM_VFP_FLOAT
5527 | EF_ARM_MAVERICK_FLOAT);
5528 break;
5529
5530 case EF_ARM_EABI_VER1:
5531 fprintf (file, _(" [Version1 EABI]"));
5532
5533 if (flags & EF_ARM_SYMSARESORTED)
5534 fprintf (file, _(" [sorted symbol table]"));
5535 else
5536 fprintf (file, _(" [unsorted symbol table]"));
5537
5538 flags &= ~ EF_ARM_SYMSARESORTED;
5539 break;
5540
5541 case EF_ARM_EABI_VER2:
5542 fprintf (file, _(" [Version2 EABI]"));
5543
5544 if (flags & EF_ARM_SYMSARESORTED)
5545 fprintf (file, _(" [sorted symbol table]"));
5546 else
5547 fprintf (file, _(" [unsorted symbol table]"));
5548
5549 if (flags & EF_ARM_DYNSYMSUSESEGIDX)
5550 fprintf (file, _(" [dynamic symbols use segment index]"));
5551
5552 if (flags & EF_ARM_MAPSYMSFIRST)
5553 fprintf (file, _(" [mapping symbols precede others]"));
5554
5555 flags &= ~(EF_ARM_SYMSARESORTED | EF_ARM_DYNSYMSUSESEGIDX
5556 | EF_ARM_MAPSYMSFIRST);
5557 break;
5558
5559 case EF_ARM_EABI_VER3:
5560 fprintf (file, _(" [Version3 EABI]"));
5561 break;
5562
5563 case EF_ARM_EABI_VER4:
5564 fprintf (file, _(" [Version4 EABI]"));
5565 goto eabi;
5566
5567 case EF_ARM_EABI_VER5:
5568 fprintf (file, _(" [Version5 EABI]"));
5569 eabi:
5570 if (flags & EF_ARM_BE8)
5571 fprintf (file, _(" [BE8]"));
5572
5573 if (flags & EF_ARM_LE8)
5574 fprintf (file, _(" [LE8]"));
5575
5576 flags &= ~(EF_ARM_LE8 | EF_ARM_BE8);
5577 break;
5578
5579 default:
5580 fprintf (file, _(" <EABI version unrecognised>"));
5581 break;
5582 }
5583
5584 flags &= ~ EF_ARM_EABIMASK;
5585
5586 if (flags & EF_ARM_RELEXEC)
5587 fprintf (file, _(" [relocatable executable]"));
5588
5589 if (flags & EF_ARM_HASENTRY)
5590 fprintf (file, _(" [has entry point]"));
5591
5592 flags &= ~ (EF_ARM_RELEXEC | EF_ARM_HASENTRY);
5593
5594 if (flags)
5595 fprintf (file, _("<Unrecognised flag bits set>"));
5596
5597 fputc ('\n', file);
5598
5599 return TRUE;
5600 }
5601
5602 static int
5603 elf32_arm_get_symbol_type (Elf_Internal_Sym * elf_sym, int type)
5604 {
5605 switch (ELF_ST_TYPE (elf_sym->st_info))
5606 {
5607 case STT_ARM_TFUNC:
5608 return ELF_ST_TYPE (elf_sym->st_info);
5609
5610 case STT_ARM_16BIT:
5611 /* If the symbol is not an object, return the STT_ARM_16BIT flag.
5612 This allows us to distinguish between data used by Thumb instructions
5613 and non-data (which is probably code) inside Thumb regions of an
5614 executable. */
5615 if (type != STT_OBJECT && type != STT_TLS)
5616 return ELF_ST_TYPE (elf_sym->st_info);
5617 break;
5618
5619 default:
5620 break;
5621 }
5622
5623 return type;
5624 }
5625
5626 static asection *
5627 elf32_arm_gc_mark_hook (asection * sec,
5628 struct bfd_link_info * info ATTRIBUTE_UNUSED,
5629 Elf_Internal_Rela * rel,
5630 struct elf_link_hash_entry * h,
5631 Elf_Internal_Sym * sym)
5632 {
5633 if (h != NULL)
5634 {
5635 switch (ELF32_R_TYPE (rel->r_info))
5636 {
5637 case R_ARM_GNU_VTINHERIT:
5638 case R_ARM_GNU_VTENTRY:
5639 break;
5640
5641 default:
5642 switch (h->root.type)
5643 {
5644 case bfd_link_hash_defined:
5645 case bfd_link_hash_defweak:
5646 return h->root.u.def.section;
5647
5648 case bfd_link_hash_common:
5649 return h->root.u.c.p->section;
5650
5651 default:
5652 break;
5653 }
5654 }
5655 }
5656 else
5657 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
5658
5659 return NULL;
5660 }
5661
5662 /* Update the got entry reference counts for the section being removed. */
5663
5664 static bfd_boolean
5665 elf32_arm_gc_sweep_hook (bfd * abfd,
5666 struct bfd_link_info * info,
5667 asection * sec,
5668 const Elf_Internal_Rela * relocs)
5669 {
5670 Elf_Internal_Shdr *symtab_hdr;
5671 struct elf_link_hash_entry **sym_hashes;
5672 bfd_signed_vma *local_got_refcounts;
5673 const Elf_Internal_Rela *rel, *relend;
5674 struct elf32_arm_link_hash_table * globals;
5675
5676 globals = elf32_arm_hash_table (info);
5677
5678 elf_section_data (sec)->local_dynrel = NULL;
5679
5680 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5681 sym_hashes = elf_sym_hashes (abfd);
5682 local_got_refcounts = elf_local_got_refcounts (abfd);
5683
5684 relend = relocs + sec->reloc_count;
5685 for (rel = relocs; rel < relend; rel++)
5686 {
5687 unsigned long r_symndx;
5688 struct elf_link_hash_entry *h = NULL;
5689 int r_type;
5690
5691 r_symndx = ELF32_R_SYM (rel->r_info);
5692 if (r_symndx >= symtab_hdr->sh_info)
5693 {
5694 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5695 while (h->root.type == bfd_link_hash_indirect
5696 || h->root.type == bfd_link_hash_warning)
5697 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5698 }
5699
5700 r_type = ELF32_R_TYPE (rel->r_info);
5701 r_type = arm_real_reloc_type (globals, r_type);
5702 switch (r_type)
5703 {
5704 case R_ARM_GOT32:
5705 case R_ARM_GOT_PREL:
5706 case R_ARM_TLS_GD32:
5707 case R_ARM_TLS_IE32:
5708 if (h != NULL)
5709 {
5710 if (h->got.refcount > 0)
5711 h->got.refcount -= 1;
5712 }
5713 else if (local_got_refcounts != NULL)
5714 {
5715 if (local_got_refcounts[r_symndx] > 0)
5716 local_got_refcounts[r_symndx] -= 1;
5717 }
5718 break;
5719
5720 case R_ARM_TLS_LDM32:
5721 elf32_arm_hash_table (info)->tls_ldm_got.refcount -= 1;
5722 break;
5723
5724 case R_ARM_ABS32:
5725 case R_ARM_REL32:
5726 case R_ARM_PC24:
5727 case R_ARM_PLT32:
5728 case R_ARM_CALL:
5729 case R_ARM_JUMP24:
5730 case R_ARM_PREL31:
5731 case R_ARM_THM_CALL:
5732 case R_ARM_MOVW_ABS_NC:
5733 case R_ARM_MOVT_ABS:
5734 case R_ARM_MOVW_PREL_NC:
5735 case R_ARM_MOVT_PREL:
5736 case R_ARM_THM_MOVW_ABS_NC:
5737 case R_ARM_THM_MOVT_ABS:
5738 case R_ARM_THM_MOVW_PREL_NC:
5739 case R_ARM_THM_MOVT_PREL:
5740 /* Should the interworking branches be here also? */
5741
5742 if (h != NULL)
5743 {
5744 struct elf32_arm_link_hash_entry *eh;
5745 struct elf32_arm_relocs_copied **pp;
5746 struct elf32_arm_relocs_copied *p;
5747
5748 eh = (struct elf32_arm_link_hash_entry *) h;
5749
5750 if (h->plt.refcount > 0)
5751 {
5752 h->plt.refcount -= 1;
5753 if (ELF32_R_TYPE (rel->r_info) == R_ARM_THM_CALL)
5754 eh->plt_thumb_refcount--;
5755 }
5756
5757 if (r_type == R_ARM_ABS32
5758 || r_type == R_ARM_REL32)
5759 {
5760 for (pp = &eh->relocs_copied; (p = *pp) != NULL;
5761 pp = &p->next)
5762 if (p->section == sec)
5763 {
5764 p->count -= 1;
5765 if (ELF32_R_TYPE (rel->r_info) == R_ARM_REL32)
5766 p->pc_count -= 1;
5767 if (p->count == 0)
5768 *pp = p->next;
5769 break;
5770 }
5771 }
5772 }
5773 break;
5774
5775 default:
5776 break;
5777 }
5778 }
5779
5780 return TRUE;
5781 }
5782
5783 /* Look through the relocs for a section during the first phase. */
5784
5785 static bfd_boolean
5786 elf32_arm_check_relocs (bfd *abfd, struct bfd_link_info *info,
5787 asection *sec, const Elf_Internal_Rela *relocs)
5788 {
5789 Elf_Internal_Shdr *symtab_hdr;
5790 struct elf_link_hash_entry **sym_hashes;
5791 struct elf_link_hash_entry **sym_hashes_end;
5792 const Elf_Internal_Rela *rel;
5793 const Elf_Internal_Rela *rel_end;
5794 bfd *dynobj;
5795 asection *sreloc;
5796 bfd_vma *local_got_offsets;
5797 struct elf32_arm_link_hash_table *htab;
5798
5799 if (info->relocatable)
5800 return TRUE;
5801
5802 htab = elf32_arm_hash_table (info);
5803 sreloc = NULL;
5804
5805 /* Create dynamic sections for relocatable executables so that we can
5806 copy relocations. */
5807 if (htab->root.is_relocatable_executable
5808 && ! htab->root.dynamic_sections_created)
5809 {
5810 if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
5811 return FALSE;
5812 }
5813
5814 dynobj = elf_hash_table (info)->dynobj;
5815 local_got_offsets = elf_local_got_offsets (abfd);
5816
5817 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5818 sym_hashes = elf_sym_hashes (abfd);
5819 sym_hashes_end = sym_hashes
5820 + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
5821
5822 if (!elf_bad_symtab (abfd))
5823 sym_hashes_end -= symtab_hdr->sh_info;
5824
5825 rel_end = relocs + sec->reloc_count;
5826 for (rel = relocs; rel < rel_end; rel++)
5827 {
5828 struct elf_link_hash_entry *h;
5829 struct elf32_arm_link_hash_entry *eh;
5830 unsigned long r_symndx;
5831 int r_type;
5832
5833 r_symndx = ELF32_R_SYM (rel->r_info);
5834 r_type = ELF32_R_TYPE (rel->r_info);
5835 r_type = arm_real_reloc_type (htab, r_type);
5836
5837 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
5838 {
5839 (*_bfd_error_handler) (_("%B: bad symbol index: %d"), abfd,
5840 r_symndx);
5841 return FALSE;
5842 }
5843
5844 if (r_symndx < symtab_hdr->sh_info)
5845 h = NULL;
5846 else
5847 {
5848 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5849 while (h->root.type == bfd_link_hash_indirect
5850 || h->root.type == bfd_link_hash_warning)
5851 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5852 }
5853
5854 eh = (struct elf32_arm_link_hash_entry *) h;
5855
5856 switch (r_type)
5857 {
5858 case R_ARM_GOT32:
5859 case R_ARM_GOT_PREL:
5860 case R_ARM_TLS_GD32:
5861 case R_ARM_TLS_IE32:
5862 /* This symbol requires a global offset table entry. */
5863 {
5864 int tls_type, old_tls_type;
5865
5866 switch (r_type)
5867 {
5868 case R_ARM_TLS_GD32: tls_type = GOT_TLS_GD; break;
5869 case R_ARM_TLS_IE32: tls_type = GOT_TLS_IE; break;
5870 default: tls_type = GOT_NORMAL; break;
5871 }
5872
5873 if (h != NULL)
5874 {
5875 h->got.refcount++;
5876 old_tls_type = elf32_arm_hash_entry (h)->tls_type;
5877 }
5878 else
5879 {
5880 bfd_signed_vma *local_got_refcounts;
5881
5882 /* This is a global offset table entry for a local symbol. */
5883 local_got_refcounts = elf_local_got_refcounts (abfd);
5884 if (local_got_refcounts == NULL)
5885 {
5886 bfd_size_type size;
5887
5888 size = symtab_hdr->sh_info;
5889 size *= (sizeof (bfd_signed_vma) + sizeof(char));
5890 local_got_refcounts = bfd_zalloc (abfd, size);
5891 if (local_got_refcounts == NULL)
5892 return FALSE;
5893 elf_local_got_refcounts (abfd) = local_got_refcounts;
5894 elf32_arm_local_got_tls_type (abfd)
5895 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
5896 }
5897 local_got_refcounts[r_symndx] += 1;
5898 old_tls_type = elf32_arm_local_got_tls_type (abfd) [r_symndx];
5899 }
5900
5901 /* We will already have issued an error message if there is a
5902 TLS / non-TLS mismatch, based on the symbol type. We don't
5903 support any linker relaxations. So just combine any TLS
5904 types needed. */
5905 if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
5906 && tls_type != GOT_NORMAL)
5907 tls_type |= old_tls_type;
5908
5909 if (old_tls_type != tls_type)
5910 {
5911 if (h != NULL)
5912 elf32_arm_hash_entry (h)->tls_type = tls_type;
5913 else
5914 elf32_arm_local_got_tls_type (abfd) [r_symndx] = tls_type;
5915 }
5916 }
5917 /* Fall through */
5918
5919 case R_ARM_TLS_LDM32:
5920 if (r_type == R_ARM_TLS_LDM32)
5921 htab->tls_ldm_got.refcount++;
5922 /* Fall through */
5923
5924 case R_ARM_GOTOFF32:
5925 case R_ARM_GOTPC:
5926 if (htab->sgot == NULL)
5927 {
5928 if (htab->root.dynobj == NULL)
5929 htab->root.dynobj = abfd;
5930 if (!create_got_section (htab->root.dynobj, info))
5931 return FALSE;
5932 }
5933 break;
5934
5935 case R_ARM_ABS12:
5936 /* VxWorks uses dynamic R_ARM_ABS12 relocations for
5937 ldr __GOTT_INDEX__ offsets. */
5938 if (!htab->vxworks_p)
5939 break;
5940 /* Fall through */
5941
5942 case R_ARM_ABS32:
5943 case R_ARM_REL32:
5944 case R_ARM_PC24:
5945 case R_ARM_PLT32:
5946 case R_ARM_CALL:
5947 case R_ARM_JUMP24:
5948 case R_ARM_PREL31:
5949 case R_ARM_THM_CALL:
5950 case R_ARM_MOVW_ABS_NC:
5951 case R_ARM_MOVT_ABS:
5952 case R_ARM_MOVW_PREL_NC:
5953 case R_ARM_MOVT_PREL:
5954 case R_ARM_THM_MOVW_ABS_NC:
5955 case R_ARM_THM_MOVT_ABS:
5956 case R_ARM_THM_MOVW_PREL_NC:
5957 case R_ARM_THM_MOVT_PREL:
5958 /* Should the interworking branches be listed here? */
5959 if (h != NULL)
5960 {
5961 /* If this reloc is in a read-only section, we might
5962 need a copy reloc. We can't check reliably at this
5963 stage whether the section is read-only, as input
5964 sections have not yet been mapped to output sections.
5965 Tentatively set the flag for now, and correct in
5966 adjust_dynamic_symbol. */
5967 if (!info->shared)
5968 h->non_got_ref = 1;
5969
5970 /* We may need a .plt entry if the function this reloc
5971 refers to is in a different object. We can't tell for
5972 sure yet, because something later might force the
5973 symbol local. */
5974 if (r_type != R_ARM_ABS32 && r_type != R_ARM_REL32)
5975 h->needs_plt = 1;
5976
5977 /* If we create a PLT entry, this relocation will reference
5978 it, even if it's an ABS32 relocation. */
5979 h->plt.refcount += 1;
5980
5981 if (r_type == R_ARM_THM_CALL)
5982 eh->plt_thumb_refcount += 1;
5983 }
5984
5985 /* If we are creating a shared library or relocatable executable,
5986 and this is a reloc against a global symbol, or a non PC
5987 relative reloc against a local symbol, then we need to copy
5988 the reloc into the shared library. However, if we are linking
5989 with -Bsymbolic, we do not need to copy a reloc against a
5990 global symbol which is defined in an object we are
5991 including in the link (i.e., DEF_REGULAR is set). At
5992 this point we have not seen all the input files, so it is
5993 possible that DEF_REGULAR is not set now but will be set
5994 later (it is never cleared). We account for that
5995 possibility below by storing information in the
5996 relocs_copied field of the hash table entry. */
5997 if ((info->shared || htab->root.is_relocatable_executable)
5998 && (sec->flags & SEC_ALLOC) != 0
5999 && (r_type == R_ARM_ABS32
6000 || (h != NULL && ! h->needs_plt
6001 && (! info->symbolic || ! h->def_regular))))
6002 {
6003 struct elf32_arm_relocs_copied *p, **head;
6004
6005 /* When creating a shared object, we must copy these
6006 reloc types into the output file. We create a reloc
6007 section in dynobj and make room for this reloc. */
6008 if (sreloc == NULL)
6009 {
6010 const char * name;
6011
6012 name = (bfd_elf_string_from_elf_section
6013 (abfd,
6014 elf_elfheader (abfd)->e_shstrndx,
6015 elf_section_data (sec)->rel_hdr.sh_name));
6016 if (name == NULL)
6017 return FALSE;
6018
6019 BFD_ASSERT (reloc_section_p (htab, name, sec));
6020
6021 sreloc = bfd_get_section_by_name (dynobj, name);
6022 if (sreloc == NULL)
6023 {
6024 flagword flags;
6025
6026 flags = (SEC_HAS_CONTENTS | SEC_READONLY
6027 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
6028 if ((sec->flags & SEC_ALLOC) != 0
6029 /* BPABI objects never have dynamic
6030 relocations mapped. */
6031 && !htab->symbian_p)
6032 flags |= SEC_ALLOC | SEC_LOAD;
6033 sreloc = bfd_make_section_with_flags (dynobj,
6034 name,
6035 flags);
6036 if (sreloc == NULL
6037 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
6038 return FALSE;
6039 }
6040
6041 elf_section_data (sec)->sreloc = sreloc;
6042 }
6043
6044 /* If this is a global symbol, we count the number of
6045 relocations we need for this symbol. */
6046 if (h != NULL)
6047 {
6048 head = &((struct elf32_arm_link_hash_entry *) h)->relocs_copied;
6049 }
6050 else
6051 {
6052 /* Track dynamic relocs needed for local syms too.
6053 We really need local syms available to do this
6054 easily. Oh well. */
6055
6056 asection *s;
6057 void *vpp;
6058
6059 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
6060 sec, r_symndx);
6061 if (s == NULL)
6062 return FALSE;
6063
6064 vpp = &elf_section_data (s)->local_dynrel;
6065 head = (struct elf32_arm_relocs_copied **) vpp;
6066 }
6067
6068 p = *head;
6069 if (p == NULL || p->section != sec)
6070 {
6071 bfd_size_type amt = sizeof *p;
6072
6073 p = bfd_alloc (htab->root.dynobj, amt);
6074 if (p == NULL)
6075 return FALSE;
6076 p->next = *head;
6077 *head = p;
6078 p->section = sec;
6079 p->count = 0;
6080 p->pc_count = 0;
6081 }
6082
6083 if (r_type == R_ARM_REL32)
6084 p->pc_count += 1;
6085 p->count += 1;
6086 }
6087 break;
6088
6089 /* This relocation describes the C++ object vtable hierarchy.
6090 Reconstruct it for later use during GC. */
6091 case R_ARM_GNU_VTINHERIT:
6092 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
6093 return FALSE;
6094 break;
6095
6096 /* This relocation describes which C++ vtable entries are actually
6097 used. Record for later use during GC. */
6098 case R_ARM_GNU_VTENTRY:
6099 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
6100 return FALSE;
6101 break;
6102 }
6103 }
6104
6105 return TRUE;
6106 }
6107
6108 /* Treat mapping symbols as special target symbols. */
6109
6110 static bfd_boolean
6111 elf32_arm_is_target_special_symbol (bfd * abfd ATTRIBUTE_UNUSED, asymbol * sym)
6112 {
6113 return bfd_is_arm_special_symbol_name (sym->name,
6114 BFD_ARM_SPECIAL_SYM_TYPE_ANY);
6115 }
6116
6117 /* This is a copy of elf_find_function() from elf.c except that
6118 ARM mapping symbols are ignored when looking for function names
6119 and STT_ARM_TFUNC is considered to a function type. */
6120
6121 static bfd_boolean
6122 arm_elf_find_function (bfd * abfd ATTRIBUTE_UNUSED,
6123 asection * section,
6124 asymbol ** symbols,
6125 bfd_vma offset,
6126 const char ** filename_ptr,
6127 const char ** functionname_ptr)
6128 {
6129 const char * filename = NULL;
6130 asymbol * func = NULL;
6131 bfd_vma low_func = 0;
6132 asymbol ** p;
6133
6134 for (p = symbols; *p != NULL; p++)
6135 {
6136 elf_symbol_type *q;
6137
6138 q = (elf_symbol_type *) *p;
6139
6140 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
6141 {
6142 default:
6143 break;
6144 case STT_FILE:
6145 filename = bfd_asymbol_name (&q->symbol);
6146 break;
6147 case STT_FUNC:
6148 case STT_ARM_TFUNC:
6149 case STT_NOTYPE:
6150 /* Skip mapping symbols. */
6151 if ((q->symbol.flags & BSF_LOCAL)
6152 && bfd_is_arm_special_symbol_name (q->symbol.name,
6153 BFD_ARM_SPECIAL_SYM_TYPE_ANY))
6154 continue;
6155 /* Fall through. */
6156 if (bfd_get_section (&q->symbol) == section
6157 && q->symbol.value >= low_func
6158 && q->symbol.value <= offset)
6159 {
6160 func = (asymbol *) q;
6161 low_func = q->symbol.value;
6162 }
6163 break;
6164 }
6165 }
6166
6167 if (func == NULL)
6168 return FALSE;
6169
6170 if (filename_ptr)
6171 *filename_ptr = filename;
6172 if (functionname_ptr)
6173 *functionname_ptr = bfd_asymbol_name (func);
6174
6175 return TRUE;
6176 }
6177
6178
6179 /* Find the nearest line to a particular section and offset, for error
6180 reporting. This code is a duplicate of the code in elf.c, except
6181 that it uses arm_elf_find_function. */
6182
6183 static bfd_boolean
6184 elf32_arm_find_nearest_line (bfd * abfd,
6185 asection * section,
6186 asymbol ** symbols,
6187 bfd_vma offset,
6188 const char ** filename_ptr,
6189 const char ** functionname_ptr,
6190 unsigned int * line_ptr)
6191 {
6192 bfd_boolean found = FALSE;
6193
6194 /* We skip _bfd_dwarf1_find_nearest_line since no known ARM toolchain uses it. */
6195
6196 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
6197 filename_ptr, functionname_ptr,
6198 line_ptr, 0,
6199 & elf_tdata (abfd)->dwarf2_find_line_info))
6200 {
6201 if (!*functionname_ptr)
6202 arm_elf_find_function (abfd, section, symbols, offset,
6203 *filename_ptr ? NULL : filename_ptr,
6204 functionname_ptr);
6205
6206 return TRUE;
6207 }
6208
6209 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
6210 & found, filename_ptr,
6211 functionname_ptr, line_ptr,
6212 & elf_tdata (abfd)->line_info))
6213 return FALSE;
6214
6215 if (found && (*functionname_ptr || *line_ptr))
6216 return TRUE;
6217
6218 if (symbols == NULL)
6219 return FALSE;
6220
6221 if (! arm_elf_find_function (abfd, section, symbols, offset,
6222 filename_ptr, functionname_ptr))
6223 return FALSE;
6224
6225 *line_ptr = 0;
6226 return TRUE;
6227 }
6228
6229 static bfd_boolean
6230 elf32_arm_find_inliner_info (bfd * abfd,
6231 const char ** filename_ptr,
6232 const char ** functionname_ptr,
6233 unsigned int * line_ptr)
6234 {
6235 bfd_boolean found;
6236 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
6237 functionname_ptr, line_ptr,
6238 & elf_tdata (abfd)->dwarf2_find_line_info);
6239 return found;
6240 }
6241
6242 /* Adjust a symbol defined by a dynamic object and referenced by a
6243 regular object. The current definition is in some section of the
6244 dynamic object, but we're not including those sections. We have to
6245 change the definition to something the rest of the link can
6246 understand. */
6247
6248 static bfd_boolean
6249 elf32_arm_adjust_dynamic_symbol (struct bfd_link_info * info,
6250 struct elf_link_hash_entry * h)
6251 {
6252 bfd * dynobj;
6253 asection * s;
6254 unsigned int power_of_two;
6255 struct elf32_arm_link_hash_entry * eh;
6256 struct elf32_arm_link_hash_table *globals;
6257
6258 globals = elf32_arm_hash_table (info);
6259 dynobj = elf_hash_table (info)->dynobj;
6260
6261 /* Make sure we know what is going on here. */
6262 BFD_ASSERT (dynobj != NULL
6263 && (h->needs_plt
6264 || h->u.weakdef != NULL
6265 || (h->def_dynamic
6266 && h->ref_regular
6267 && !h->def_regular)));
6268
6269 eh = (struct elf32_arm_link_hash_entry *) h;
6270
6271 /* If this is a function, put it in the procedure linkage table. We
6272 will fill in the contents of the procedure linkage table later,
6273 when we know the address of the .got section. */
6274 if (h->type == STT_FUNC || h->type == STT_ARM_TFUNC
6275 || h->needs_plt)
6276 {
6277 if (h->plt.refcount <= 0
6278 || SYMBOL_CALLS_LOCAL (info, h)
6279 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6280 && h->root.type == bfd_link_hash_undefweak))
6281 {
6282 /* This case can occur if we saw a PLT32 reloc in an input
6283 file, but the symbol was never referred to by a dynamic
6284 object, or if all references were garbage collected. In
6285 such a case, we don't actually need to build a procedure
6286 linkage table, and we can just do a PC24 reloc instead. */
6287 h->plt.offset = (bfd_vma) -1;
6288 eh->plt_thumb_refcount = 0;
6289 h->needs_plt = 0;
6290 }
6291
6292 return TRUE;
6293 }
6294 else
6295 {
6296 /* It's possible that we incorrectly decided a .plt reloc was
6297 needed for an R_ARM_PC24 or similar reloc to a non-function sym
6298 in check_relocs. We can't decide accurately between function
6299 and non-function syms in check-relocs; Objects loaded later in
6300 the link may change h->type. So fix it now. */
6301 h->plt.offset = (bfd_vma) -1;
6302 eh->plt_thumb_refcount = 0;
6303 }
6304
6305 /* If this is a weak symbol, and there is a real definition, the
6306 processor independent code will have arranged for us to see the
6307 real definition first, and we can just use the same value. */
6308 if (h->u.weakdef != NULL)
6309 {
6310 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6311 || h->u.weakdef->root.type == bfd_link_hash_defweak);
6312 h->root.u.def.section = h->u.weakdef->root.u.def.section;
6313 h->root.u.def.value = h->u.weakdef->root.u.def.value;
6314 return TRUE;
6315 }
6316
6317 /* If there are no non-GOT references, we do not need a copy
6318 relocation. */
6319 if (!h->non_got_ref)
6320 return TRUE;
6321
6322 /* This is a reference to a symbol defined by a dynamic object which
6323 is not a function. */
6324
6325 /* If we are creating a shared library, we must presume that the
6326 only references to the symbol are via the global offset table.
6327 For such cases we need not do anything here; the relocations will
6328 be handled correctly by relocate_section. Relocatable executables
6329 can reference data in shared objects directly, so we don't need to
6330 do anything here. */
6331 if (info->shared || globals->root.is_relocatable_executable)
6332 return TRUE;
6333
6334 if (h->size == 0)
6335 {
6336 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
6337 h->root.root.string);
6338 return TRUE;
6339 }
6340
6341 /* We must allocate the symbol in our .dynbss section, which will
6342 become part of the .bss section of the executable. There will be
6343 an entry for this symbol in the .dynsym section. The dynamic
6344 object will contain position independent code, so all references
6345 from the dynamic object to this symbol will go through the global
6346 offset table. The dynamic linker will use the .dynsym entry to
6347 determine the address it must put in the global offset table, so
6348 both the dynamic object and the regular object will refer to the
6349 same memory location for the variable. */
6350 s = bfd_get_section_by_name (dynobj, ".dynbss");
6351 BFD_ASSERT (s != NULL);
6352
6353 /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
6354 copy the initial value out of the dynamic object and into the
6355 runtime process image. We need to remember the offset into the
6356 .rel(a).bss section we are going to use. */
6357 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
6358 {
6359 asection *srel;
6360
6361 srel = bfd_get_section_by_name (dynobj, RELOC_SECTION (globals, ".bss"));
6362 BFD_ASSERT (srel != NULL);
6363 srel->size += RELOC_SIZE (globals);
6364 h->needs_copy = 1;
6365 }
6366
6367 /* We need to figure out the alignment required for this symbol. I
6368 have no idea how ELF linkers handle this. */
6369 power_of_two = bfd_log2 (h->size);
6370 if (power_of_two > 3)
6371 power_of_two = 3;
6372
6373 /* Apply the required alignment. */
6374 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
6375 if (power_of_two > bfd_get_section_alignment (dynobj, s))
6376 {
6377 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
6378 return FALSE;
6379 }
6380
6381 /* Define the symbol as being at this point in the section. */
6382 h->root.u.def.section = s;
6383 h->root.u.def.value = s->size;
6384
6385 /* Increment the section size to make room for the symbol. */
6386 s->size += h->size;
6387
6388 return TRUE;
6389 }
6390
6391 /* Allocate space in .plt, .got and associated reloc sections for
6392 dynamic relocs. */
6393
6394 static bfd_boolean
6395 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
6396 {
6397 struct bfd_link_info *info;
6398 struct elf32_arm_link_hash_table *htab;
6399 struct elf32_arm_link_hash_entry *eh;
6400 struct elf32_arm_relocs_copied *p;
6401
6402 eh = (struct elf32_arm_link_hash_entry *) h;
6403
6404 if (h->root.type == bfd_link_hash_indirect)
6405 return TRUE;
6406
6407 if (h->root.type == bfd_link_hash_warning)
6408 /* When warning symbols are created, they **replace** the "real"
6409 entry in the hash table, thus we never get to see the real
6410 symbol in a hash traversal. So look at it now. */
6411 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6412
6413 info = (struct bfd_link_info *) inf;
6414 htab = elf32_arm_hash_table (info);
6415
6416 if (htab->root.dynamic_sections_created
6417 && h->plt.refcount > 0)
6418 {
6419 /* Make sure this symbol is output as a dynamic symbol.
6420 Undefined weak syms won't yet be marked as dynamic. */
6421 if (h->dynindx == -1
6422 && !h->forced_local)
6423 {
6424 if (! bfd_elf_link_record_dynamic_symbol (info, h))
6425 return FALSE;
6426 }
6427
6428 if (info->shared
6429 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
6430 {
6431 asection *s = htab->splt;
6432
6433 /* If this is the first .plt entry, make room for the special
6434 first entry. */
6435 if (s->size == 0)
6436 s->size += htab->plt_header_size;
6437
6438 h->plt.offset = s->size;
6439
6440 /* If we will insert a Thumb trampoline before this PLT, leave room
6441 for it. */
6442 if (!htab->use_blx && eh->plt_thumb_refcount > 0)
6443 {
6444 h->plt.offset += PLT_THUMB_STUB_SIZE;
6445 s->size += PLT_THUMB_STUB_SIZE;
6446 }
6447
6448 /* If this symbol is not defined in a regular file, and we are
6449 not generating a shared library, then set the symbol to this
6450 location in the .plt. This is required to make function
6451 pointers compare as equal between the normal executable and
6452 the shared library. */
6453 if (! info->shared
6454 && !h->def_regular)
6455 {
6456 h->root.u.def.section = s;
6457 h->root.u.def.value = h->plt.offset;
6458
6459 /* Make sure the function is not marked as Thumb, in case
6460 it is the target of an ABS32 relocation, which will
6461 point to the PLT entry. */
6462 if (ELF_ST_TYPE (h->type) == STT_ARM_TFUNC)
6463 h->type = ELF_ST_INFO (ELF_ST_BIND (h->type), STT_FUNC);
6464 }
6465
6466 /* Make room for this entry. */
6467 s->size += htab->plt_entry_size;
6468
6469 if (!htab->symbian_p)
6470 {
6471 /* We also need to make an entry in the .got.plt section, which
6472 will be placed in the .got section by the linker script. */
6473 eh->plt_got_offset = htab->sgotplt->size;
6474 htab->sgotplt->size += 4;
6475 }
6476
6477 /* We also need to make an entry in the .rel(a).plt section. */
6478 htab->srelplt->size += RELOC_SIZE (htab);
6479
6480 /* VxWorks executables have a second set of relocations for
6481 each PLT entry. They go in a separate relocation section,
6482 which is processed by the kernel loader. */
6483 if (htab->vxworks_p && !info->shared)
6484 {
6485 /* There is a relocation for the initial PLT entry:
6486 an R_ARM_32 relocation for _GLOBAL_OFFSET_TABLE_. */
6487 if (h->plt.offset == htab->plt_header_size)
6488 htab->srelplt2->size += RELOC_SIZE (htab);
6489
6490 /* There are two extra relocations for each subsequent
6491 PLT entry: an R_ARM_32 relocation for the GOT entry,
6492 and an R_ARM_32 relocation for the PLT entry. */
6493 htab->srelplt2->size += RELOC_SIZE (htab) * 2;
6494 }
6495 }
6496 else
6497 {
6498 h->plt.offset = (bfd_vma) -1;
6499 h->needs_plt = 0;
6500 }
6501 }
6502 else
6503 {
6504 h->plt.offset = (bfd_vma) -1;
6505 h->needs_plt = 0;
6506 }
6507
6508 if (h->got.refcount > 0)
6509 {
6510 asection *s;
6511 bfd_boolean dyn;
6512 int tls_type = elf32_arm_hash_entry (h)->tls_type;
6513 int indx;
6514
6515 /* Make sure this symbol is output as a dynamic symbol.
6516 Undefined weak syms won't yet be marked as dynamic. */
6517 if (h->dynindx == -1
6518 && !h->forced_local)
6519 {
6520 if (! bfd_elf_link_record_dynamic_symbol (info, h))
6521 return FALSE;
6522 }
6523
6524 if (!htab->symbian_p)
6525 {
6526 s = htab->sgot;
6527 h->got.offset = s->size;
6528
6529 if (tls_type == GOT_UNKNOWN)
6530 abort ();
6531
6532 if (tls_type == GOT_NORMAL)
6533 /* Non-TLS symbols need one GOT slot. */
6534 s->size += 4;
6535 else
6536 {
6537 if (tls_type & GOT_TLS_GD)
6538 /* R_ARM_TLS_GD32 needs 2 consecutive GOT slots. */
6539 s->size += 8;
6540 if (tls_type & GOT_TLS_IE)
6541 /* R_ARM_TLS_IE32 needs one GOT slot. */
6542 s->size += 4;
6543 }
6544
6545 dyn = htab->root.dynamic_sections_created;
6546
6547 indx = 0;
6548 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
6549 && (!info->shared
6550 || !SYMBOL_REFERENCES_LOCAL (info, h)))
6551 indx = h->dynindx;
6552
6553 if (tls_type != GOT_NORMAL
6554 && (info->shared || indx != 0)
6555 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
6556 || h->root.type != bfd_link_hash_undefweak))
6557 {
6558 if (tls_type & GOT_TLS_IE)
6559 htab->srelgot->size += RELOC_SIZE (htab);
6560
6561 if (tls_type & GOT_TLS_GD)
6562 htab->srelgot->size += RELOC_SIZE (htab);
6563
6564 if ((tls_type & GOT_TLS_GD) && indx != 0)
6565 htab->srelgot->size += RELOC_SIZE (htab);
6566 }
6567 else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
6568 || h->root.type != bfd_link_hash_undefweak)
6569 && (info->shared
6570 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
6571 htab->srelgot->size += RELOC_SIZE (htab);
6572 }
6573 }
6574 else
6575 h->got.offset = (bfd_vma) -1;
6576
6577 if (eh->relocs_copied == NULL)
6578 return TRUE;
6579
6580 /* In the shared -Bsymbolic case, discard space allocated for
6581 dynamic pc-relative relocs against symbols which turn out to be
6582 defined in regular objects. For the normal shared case, discard
6583 space for pc-relative relocs that have become local due to symbol
6584 visibility changes. */
6585
6586 if (info->shared || htab->root.is_relocatable_executable)
6587 {
6588 /* The only reloc that uses pc_count is R_ARM_REL32, which will
6589 appear on something like ".long foo - .". We want calls to
6590 protected symbols to resolve directly to the function rather
6591 than going via the plt. If people want function pointer
6592 comparisons to work as expected then they should avoid
6593 writing assembly like ".long foo - .". */
6594 if (SYMBOL_CALLS_LOCAL (info, h))
6595 {
6596 struct elf32_arm_relocs_copied **pp;
6597
6598 for (pp = &eh->relocs_copied; (p = *pp) != NULL; )
6599 {
6600 p->count -= p->pc_count;
6601 p->pc_count = 0;
6602 if (p->count == 0)
6603 *pp = p->next;
6604 else
6605 pp = &p->next;
6606 }
6607 }
6608
6609 /* Also discard relocs on undefined weak syms with non-default
6610 visibility. */
6611 if (eh->relocs_copied != NULL
6612 && h->root.type == bfd_link_hash_undefweak)
6613 {
6614 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
6615 eh->relocs_copied = NULL;
6616
6617 /* Make sure undefined weak symbols are output as a dynamic
6618 symbol in PIEs. */
6619 else if (h->dynindx == -1
6620 && !h->forced_local)
6621 {
6622 if (! bfd_elf_link_record_dynamic_symbol (info, h))
6623 return FALSE;
6624 }
6625 }
6626
6627 else if (htab->root.is_relocatable_executable && h->dynindx == -1
6628 && h->root.type == bfd_link_hash_new)
6629 {
6630 /* Output absolute symbols so that we can create relocations
6631 against them. For normal symbols we output a relocation
6632 against the section that contains them. */
6633 if (! bfd_elf_link_record_dynamic_symbol (info, h))
6634 return FALSE;
6635 }
6636
6637 }
6638 else
6639 {
6640 /* For the non-shared case, discard space for relocs against
6641 symbols which turn out to need copy relocs or are not
6642 dynamic. */
6643
6644 if (!h->non_got_ref
6645 && ((h->def_dynamic
6646 && !h->def_regular)
6647 || (htab->root.dynamic_sections_created
6648 && (h->root.type == bfd_link_hash_undefweak
6649 || h->root.type == bfd_link_hash_undefined))))
6650 {
6651 /* Make sure this symbol is output as a dynamic symbol.
6652 Undefined weak syms won't yet be marked as dynamic. */
6653 if (h->dynindx == -1
6654 && !h->forced_local)
6655 {
6656 if (! bfd_elf_link_record_dynamic_symbol (info, h))
6657 return FALSE;
6658 }
6659
6660 /* If that succeeded, we know we'll be keeping all the
6661 relocs. */
6662 if (h->dynindx != -1)
6663 goto keep;
6664 }
6665
6666 eh->relocs_copied = NULL;
6667
6668 keep: ;
6669 }
6670
6671 /* Finally, allocate space. */
6672 for (p = eh->relocs_copied; p != NULL; p = p->next)
6673 {
6674 asection *sreloc = elf_section_data (p->section)->sreloc;
6675 sreloc->size += p->count * RELOC_SIZE (htab);
6676 }
6677
6678 return TRUE;
6679 }
6680
6681 /* Find any dynamic relocs that apply to read-only sections. */
6682
6683 static bfd_boolean
6684 elf32_arm_readonly_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
6685 {
6686 struct elf32_arm_link_hash_entry *eh;
6687 struct elf32_arm_relocs_copied *p;
6688
6689 if (h->root.type == bfd_link_hash_warning)
6690 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6691
6692 eh = (struct elf32_arm_link_hash_entry *) h;
6693 for (p = eh->relocs_copied; p != NULL; p = p->next)
6694 {
6695 asection *s = p->section;
6696
6697 if (s != NULL && (s->flags & SEC_READONLY) != 0)
6698 {
6699 struct bfd_link_info *info = (struct bfd_link_info *) inf;
6700
6701 info->flags |= DF_TEXTREL;
6702
6703 /* Not an error, just cut short the traversal. */
6704 return FALSE;
6705 }
6706 }
6707 return TRUE;
6708 }
6709
6710 /* Set the sizes of the dynamic sections. */
6711
6712 static bfd_boolean
6713 elf32_arm_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
6714 struct bfd_link_info * info)
6715 {
6716 bfd * dynobj;
6717 asection * s;
6718 bfd_boolean plt;
6719 bfd_boolean relocs;
6720 bfd *ibfd;
6721 struct elf32_arm_link_hash_table *htab;
6722
6723 htab = elf32_arm_hash_table (info);
6724 dynobj = elf_hash_table (info)->dynobj;
6725 BFD_ASSERT (dynobj != NULL);
6726 check_use_blx (htab);
6727
6728 if (elf_hash_table (info)->dynamic_sections_created)
6729 {
6730 /* Set the contents of the .interp section to the interpreter. */
6731 if (info->executable)
6732 {
6733 s = bfd_get_section_by_name (dynobj, ".interp");
6734 BFD_ASSERT (s != NULL);
6735 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
6736 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
6737 }
6738 }
6739
6740 /* Set up .got offsets for local syms, and space for local dynamic
6741 relocs. */
6742 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
6743 {
6744 bfd_signed_vma *local_got;
6745 bfd_signed_vma *end_local_got;
6746 char *local_tls_type;
6747 bfd_size_type locsymcount;
6748 Elf_Internal_Shdr *symtab_hdr;
6749 asection *srel;
6750
6751 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
6752 continue;
6753
6754 for (s = ibfd->sections; s != NULL; s = s->next)
6755 {
6756 struct elf32_arm_relocs_copied *p;
6757
6758 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
6759 {
6760 if (!bfd_is_abs_section (p->section)
6761 && bfd_is_abs_section (p->section->output_section))
6762 {
6763 /* Input section has been discarded, either because
6764 it is a copy of a linkonce section or due to
6765 linker script /DISCARD/, so we'll be discarding
6766 the relocs too. */
6767 }
6768 else if (p->count != 0)
6769 {
6770 srel = elf_section_data (p->section)->sreloc;
6771 srel->size += p->count * RELOC_SIZE (htab);
6772 if ((p->section->output_section->flags & SEC_READONLY) != 0)
6773 info->flags |= DF_TEXTREL;
6774 }
6775 }
6776 }
6777
6778 local_got = elf_local_got_refcounts (ibfd);
6779 if (!local_got)
6780 continue;
6781
6782 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
6783 locsymcount = symtab_hdr->sh_info;
6784 end_local_got = local_got + locsymcount;
6785 local_tls_type = elf32_arm_local_got_tls_type (ibfd);
6786 s = htab->sgot;
6787 srel = htab->srelgot;
6788 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
6789 {
6790 if (*local_got > 0)
6791 {
6792 *local_got = s->size;
6793 if (*local_tls_type & GOT_TLS_GD)
6794 /* TLS_GD relocs need an 8-byte structure in the GOT. */
6795 s->size += 8;
6796 if (*local_tls_type & GOT_TLS_IE)
6797 s->size += 4;
6798 if (*local_tls_type == GOT_NORMAL)
6799 s->size += 4;
6800
6801 if (info->shared || *local_tls_type == GOT_TLS_GD)
6802 srel->size += RELOC_SIZE (htab);
6803 }
6804 else
6805 *local_got = (bfd_vma) -1;
6806 }
6807 }
6808
6809 if (htab->tls_ldm_got.refcount > 0)
6810 {
6811 /* Allocate two GOT entries and one dynamic relocation (if necessary)
6812 for R_ARM_TLS_LDM32 relocations. */
6813 htab->tls_ldm_got.offset = htab->sgot->size;
6814 htab->sgot->size += 8;
6815 if (info->shared)
6816 htab->srelgot->size += RELOC_SIZE (htab);
6817 }
6818 else
6819 htab->tls_ldm_got.offset = -1;
6820
6821 /* Allocate global sym .plt and .got entries, and space for global
6822 sym dynamic relocs. */
6823 elf_link_hash_traverse (& htab->root, allocate_dynrelocs, info);
6824
6825 /* The check_relocs and adjust_dynamic_symbol entry points have
6826 determined the sizes of the various dynamic sections. Allocate
6827 memory for them. */
6828 plt = FALSE;
6829 relocs = FALSE;
6830 for (s = dynobj->sections; s != NULL; s = s->next)
6831 {
6832 const char * name;
6833
6834 if ((s->flags & SEC_LINKER_CREATED) == 0)
6835 continue;
6836
6837 /* It's OK to base decisions on the section name, because none
6838 of the dynobj section names depend upon the input files. */
6839 name = bfd_get_section_name (dynobj, s);
6840
6841 if (strcmp (name, ".plt") == 0)
6842 {
6843 /* Remember whether there is a PLT. */
6844 plt = s->size != 0;
6845 }
6846 else if (strncmp (name, ".rel", 4) == 0)
6847 {
6848 if (s->size != 0)
6849 {
6850 /* Remember whether there are any reloc sections other
6851 than .rel(a).plt and .rela.plt.unloaded. */
6852 if (s != htab->srelplt && s != htab->srelplt2)
6853 relocs = TRUE;
6854
6855 /* We use the reloc_count field as a counter if we need
6856 to copy relocs into the output file. */
6857 s->reloc_count = 0;
6858 }
6859 }
6860 else if (strncmp (name, ".got", 4) != 0
6861 && strcmp (name, ".dynbss") != 0)
6862 {
6863 /* It's not one of our sections, so don't allocate space. */
6864 continue;
6865 }
6866
6867 if (s->size == 0)
6868 {
6869 /* If we don't need this section, strip it from the
6870 output file. This is mostly to handle .rel(a).bss and
6871 .rel(a).plt. We must create both sections in
6872 create_dynamic_sections, because they must be created
6873 before the linker maps input sections to output
6874 sections. The linker does that before
6875 adjust_dynamic_symbol is called, and it is that
6876 function which decides whether anything needs to go
6877 into these sections. */
6878 s->flags |= SEC_EXCLUDE;
6879 continue;
6880 }
6881
6882 if ((s->flags & SEC_HAS_CONTENTS) == 0)
6883 continue;
6884
6885 /* Allocate memory for the section contents. */
6886 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
6887 if (s->contents == NULL)
6888 return FALSE;
6889 }
6890
6891 if (elf_hash_table (info)->dynamic_sections_created)
6892 {
6893 /* Add some entries to the .dynamic section. We fill in the
6894 values later, in elf32_arm_finish_dynamic_sections, but we
6895 must add the entries now so that we get the correct size for
6896 the .dynamic section. The DT_DEBUG entry is filled in by the
6897 dynamic linker and used by the debugger. */
6898 #define add_dynamic_entry(TAG, VAL) \
6899 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
6900
6901 if (info->executable)
6902 {
6903 if (!add_dynamic_entry (DT_DEBUG, 0))
6904 return FALSE;
6905 }
6906
6907 if (plt)
6908 {
6909 if ( !add_dynamic_entry (DT_PLTGOT, 0)
6910 || !add_dynamic_entry (DT_PLTRELSZ, 0)
6911 || !add_dynamic_entry (DT_PLTREL,
6912 htab->use_rel ? DT_REL : DT_RELA)
6913 || !add_dynamic_entry (DT_JMPREL, 0))
6914 return FALSE;
6915 }
6916
6917 if (relocs)
6918 {
6919 if (htab->use_rel)
6920 {
6921 if (!add_dynamic_entry (DT_REL, 0)
6922 || !add_dynamic_entry (DT_RELSZ, 0)
6923 || !add_dynamic_entry (DT_RELENT, RELOC_SIZE (htab)))
6924 return FALSE;
6925 }
6926 else
6927 {
6928 if (!add_dynamic_entry (DT_RELA, 0)
6929 || !add_dynamic_entry (DT_RELASZ, 0)
6930 || !add_dynamic_entry (DT_RELAENT, RELOC_SIZE (htab)))
6931 return FALSE;
6932 }
6933 }
6934
6935 /* If any dynamic relocs apply to a read-only section,
6936 then we need a DT_TEXTREL entry. */
6937 if ((info->flags & DF_TEXTREL) == 0)
6938 elf_link_hash_traverse (&htab->root, elf32_arm_readonly_dynrelocs,
6939 (PTR) info);
6940
6941 if ((info->flags & DF_TEXTREL) != 0)
6942 {
6943 if (!add_dynamic_entry (DT_TEXTREL, 0))
6944 return FALSE;
6945 }
6946 }
6947 #undef add_dynamic_entry
6948
6949 return TRUE;
6950 }
6951
6952 /* Finish up dynamic symbol handling. We set the contents of various
6953 dynamic sections here. */
6954
6955 static bfd_boolean
6956 elf32_arm_finish_dynamic_symbol (bfd * output_bfd, struct bfd_link_info * info,
6957 struct elf_link_hash_entry * h, Elf_Internal_Sym * sym)
6958 {
6959 bfd * dynobj;
6960 struct elf32_arm_link_hash_table *htab;
6961 struct elf32_arm_link_hash_entry *eh;
6962
6963 dynobj = elf_hash_table (info)->dynobj;
6964 htab = elf32_arm_hash_table (info);
6965 eh = (struct elf32_arm_link_hash_entry *) h;
6966
6967 if (h->plt.offset != (bfd_vma) -1)
6968 {
6969 asection * splt;
6970 asection * srel;
6971 bfd_byte *loc;
6972 bfd_vma plt_index;
6973 Elf_Internal_Rela rel;
6974
6975 /* This symbol has an entry in the procedure linkage table. Set
6976 it up. */
6977
6978 BFD_ASSERT (h->dynindx != -1);
6979
6980 splt = bfd_get_section_by_name (dynobj, ".plt");
6981 srel = bfd_get_section_by_name (dynobj, RELOC_SECTION (htab, ".plt"));
6982 BFD_ASSERT (splt != NULL && srel != NULL);
6983
6984 /* Fill in the entry in the procedure linkage table. */
6985 if (htab->symbian_p)
6986 {
6987 unsigned i;
6988 for (i = 0; i < htab->plt_entry_size / 4; ++i)
6989 bfd_put_32 (output_bfd,
6990 elf32_arm_symbian_plt_entry[i],
6991 splt->contents + h->plt.offset + 4 * i);
6992
6993 /* Fill in the entry in the .rel.plt section. */
6994 rel.r_offset = (splt->output_section->vma
6995 + splt->output_offset
6996 + h->plt.offset + 4 * (i - 1));
6997 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
6998
6999 /* Get the index in the procedure linkage table which
7000 corresponds to this symbol. This is the index of this symbol
7001 in all the symbols for which we are making plt entries. The
7002 first entry in the procedure linkage table is reserved. */
7003 plt_index = ((h->plt.offset - htab->plt_header_size)
7004 / htab->plt_entry_size);
7005 }
7006 else
7007 {
7008 bfd_vma got_offset, got_address, plt_address;
7009 bfd_vma got_displacement;
7010 asection * sgot;
7011
7012 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
7013 BFD_ASSERT (sgot != NULL);
7014
7015 /* Get the offset into the .got.plt table of the entry that
7016 corresponds to this function. */
7017 got_offset = eh->plt_got_offset;
7018
7019 /* Get the index in the procedure linkage table which
7020 corresponds to this symbol. This is the index of this symbol
7021 in all the symbols for which we are making plt entries. The
7022 first three entries in .got.plt are reserved; after that
7023 symbols appear in the same order as in .plt. */
7024 plt_index = (got_offset - 12) / 4;
7025
7026 /* Calculate the address of the GOT entry. */
7027 got_address = (sgot->output_section->vma
7028 + sgot->output_offset
7029 + got_offset);
7030
7031 /* ...and the address of the PLT entry. */
7032 plt_address = (splt->output_section->vma
7033 + splt->output_offset
7034 + h->plt.offset);
7035
7036 if (htab->vxworks_p && info->shared)
7037 {
7038 unsigned int i;
7039 bfd_vma val;
7040
7041 for (i = 0; i != htab->plt_entry_size / 4; i++)
7042 {
7043 val = elf32_arm_vxworks_shared_plt_entry[i];
7044 if (i == 2)
7045 val |= got_address - sgot->output_section->vma;
7046 if (i == 5)
7047 val |= plt_index * RELOC_SIZE (htab);
7048 bfd_put_32 (output_bfd, val,
7049 htab->splt->contents + h->plt.offset + i * 4);
7050 }
7051 }
7052 else if (htab->vxworks_p)
7053 {
7054 unsigned int i;
7055 bfd_vma val;
7056
7057 for (i = 0; i != htab->plt_entry_size / 4; i++)
7058 {
7059 val = elf32_arm_vxworks_exec_plt_entry[i];
7060 if (i == 2)
7061 val |= got_address;
7062 if (i == 4)
7063 val |= 0xffffff & -((h->plt.offset + i * 4 + 8) >> 2);
7064 if (i == 5)
7065 val |= plt_index * RELOC_SIZE (htab);
7066 bfd_put_32 (output_bfd, val,
7067 htab->splt->contents + h->plt.offset + i * 4);
7068 }
7069
7070 loc = (htab->srelplt2->contents
7071 + (plt_index * 2 + 1) * RELOC_SIZE (htab));
7072
7073 /* Create the .rela.plt.unloaded R_ARM_ABS32 relocation
7074 referencing the GOT for this PLT entry. */
7075 rel.r_offset = plt_address + 8;
7076 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
7077 rel.r_addend = got_offset;
7078 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
7079 loc += RELOC_SIZE (htab);
7080
7081 /* Create the R_ARM_ABS32 relocation referencing the
7082 beginning of the PLT for this GOT entry. */
7083 rel.r_offset = got_address;
7084 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_ARM_ABS32);
7085 rel.r_addend = 0;
7086 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
7087 }
7088 else
7089 {
7090 /* Calculate the displacement between the PLT slot and the
7091 entry in the GOT. The eight-byte offset accounts for the
7092 value produced by adding to pc in the first instruction
7093 of the PLT stub. */
7094 got_displacement = got_address - (plt_address + 8);
7095
7096 BFD_ASSERT ((got_displacement & 0xf0000000) == 0);
7097
7098 if (!htab->use_blx && eh->plt_thumb_refcount > 0)
7099 {
7100 bfd_put_16 (output_bfd, elf32_arm_plt_thumb_stub[0],
7101 splt->contents + h->plt.offset - 4);
7102 bfd_put_16 (output_bfd, elf32_arm_plt_thumb_stub[1],
7103 splt->contents + h->plt.offset - 2);
7104 }
7105
7106 bfd_put_32 (output_bfd,
7107 elf32_arm_plt_entry[0]
7108 | ((got_displacement & 0x0ff00000) >> 20),
7109 splt->contents + h->plt.offset + 0);
7110 bfd_put_32 (output_bfd,
7111 elf32_arm_plt_entry[1]
7112 | ((got_displacement & 0x000ff000) >> 12),
7113 splt->contents + h->plt.offset + 4);
7114 bfd_put_32 (output_bfd,
7115 elf32_arm_plt_entry[2]
7116 | (got_displacement & 0x00000fff),
7117 splt->contents + h->plt.offset + 8);
7118 #ifdef FOUR_WORD_PLT
7119 bfd_put_32 (output_bfd, elf32_arm_plt_entry[3],
7120 splt->contents + h->plt.offset + 12);
7121 #endif
7122 }
7123
7124 /* Fill in the entry in the global offset table. */
7125 bfd_put_32 (output_bfd,
7126 (splt->output_section->vma
7127 + splt->output_offset),
7128 sgot->contents + got_offset);
7129
7130 /* Fill in the entry in the .rel(a).plt section. */
7131 rel.r_addend = 0;
7132 rel.r_offset = got_address;
7133 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
7134 }
7135
7136 loc = srel->contents + plt_index * RELOC_SIZE (htab);
7137 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
7138
7139 if (!h->def_regular)
7140 {
7141 /* Mark the symbol as undefined, rather than as defined in
7142 the .plt section. Leave the value alone. */
7143 sym->st_shndx = SHN_UNDEF;
7144 /* If the symbol is weak, we do need to clear the value.
7145 Otherwise, the PLT entry would provide a definition for
7146 the symbol even if the symbol wasn't defined anywhere,
7147 and so the symbol would never be NULL. */
7148 if (!h->ref_regular_nonweak)
7149 sym->st_value = 0;
7150 }
7151 }
7152
7153 if (h->got.offset != (bfd_vma) -1
7154 && (elf32_arm_hash_entry (h)->tls_type & GOT_TLS_GD) == 0
7155 && (elf32_arm_hash_entry (h)->tls_type & GOT_TLS_IE) == 0)
7156 {
7157 asection * sgot;
7158 asection * srel;
7159 Elf_Internal_Rela rel;
7160 bfd_byte *loc;
7161 bfd_vma offset;
7162
7163 /* This symbol has an entry in the global offset table. Set it
7164 up. */
7165 sgot = bfd_get_section_by_name (dynobj, ".got");
7166 srel = bfd_get_section_by_name (dynobj, RELOC_SECTION (htab, ".got"));
7167 BFD_ASSERT (sgot != NULL && srel != NULL);
7168
7169 offset = (h->got.offset & ~(bfd_vma) 1);
7170 rel.r_addend = 0;
7171 rel.r_offset = (sgot->output_section->vma
7172 + sgot->output_offset
7173 + offset);
7174
7175 /* If this is a static link, or it is a -Bsymbolic link and the
7176 symbol is defined locally or was forced to be local because
7177 of a version file, we just want to emit a RELATIVE reloc.
7178 The entry in the global offset table will already have been
7179 initialized in the relocate_section function. */
7180 if (info->shared
7181 && SYMBOL_REFERENCES_LOCAL (info, h))
7182 {
7183 BFD_ASSERT((h->got.offset & 1) != 0);
7184 rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
7185 if (!htab->use_rel)
7186 {
7187 rel.r_addend = bfd_get_32 (output_bfd, sgot->contents + offset);
7188 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + offset);
7189 }
7190 }
7191 else
7192 {
7193 BFD_ASSERT((h->got.offset & 1) == 0);
7194 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + offset);
7195 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
7196 }
7197
7198 loc = srel->contents + srel->reloc_count++ * RELOC_SIZE (htab);
7199 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
7200 }
7201
7202 if (h->needs_copy)
7203 {
7204 asection * s;
7205 Elf_Internal_Rela rel;
7206 bfd_byte *loc;
7207
7208 /* This symbol needs a copy reloc. Set it up. */
7209 BFD_ASSERT (h->dynindx != -1
7210 && (h->root.type == bfd_link_hash_defined
7211 || h->root.type == bfd_link_hash_defweak));
7212
7213 s = bfd_get_section_by_name (h->root.u.def.section->owner,
7214 RELOC_SECTION (htab, ".bss"));
7215 BFD_ASSERT (s != NULL);
7216
7217 rel.r_addend = 0;
7218 rel.r_offset = (h->root.u.def.value
7219 + h->root.u.def.section->output_section->vma
7220 + h->root.u.def.section->output_offset);
7221 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
7222 loc = s->contents + s->reloc_count++ * RELOC_SIZE (htab);
7223 SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
7224 }
7225
7226 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. On VxWorks,
7227 the _GLOBAL_OFFSET_TABLE_ symbol is not absolute: it is relative
7228 to the ".got" section. */
7229 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
7230 || (!htab->vxworks_p && h == htab->root.hgot))
7231 sym->st_shndx = SHN_ABS;
7232
7233 return TRUE;
7234 }
7235
7236 /* Finish up the dynamic sections. */
7237
7238 static bfd_boolean
7239 elf32_arm_finish_dynamic_sections (bfd * output_bfd, struct bfd_link_info * info)
7240 {
7241 bfd * dynobj;
7242 asection * sgot;
7243 asection * sdyn;
7244
7245 dynobj = elf_hash_table (info)->dynobj;
7246
7247 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
7248 BFD_ASSERT (elf32_arm_hash_table (info)->symbian_p || sgot != NULL);
7249 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
7250
7251 if (elf_hash_table (info)->dynamic_sections_created)
7252 {
7253 asection *splt;
7254 Elf32_External_Dyn *dyncon, *dynconend;
7255 struct elf32_arm_link_hash_table *htab;
7256
7257 htab = elf32_arm_hash_table (info);
7258 splt = bfd_get_section_by_name (dynobj, ".plt");
7259 BFD_ASSERT (splt != NULL && sdyn != NULL);
7260
7261 dyncon = (Elf32_External_Dyn *) sdyn->contents;
7262 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
7263
7264 for (; dyncon < dynconend; dyncon++)
7265 {
7266 Elf_Internal_Dyn dyn;
7267 const char * name;
7268 asection * s;
7269
7270 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
7271
7272 switch (dyn.d_tag)
7273 {
7274 unsigned int type;
7275
7276 default:
7277 break;
7278
7279 case DT_HASH:
7280 name = ".hash";
7281 goto get_vma_if_bpabi;
7282 case DT_STRTAB:
7283 name = ".dynstr";
7284 goto get_vma_if_bpabi;
7285 case DT_SYMTAB:
7286 name = ".dynsym";
7287 goto get_vma_if_bpabi;
7288 case DT_VERSYM:
7289 name = ".gnu.version";
7290 goto get_vma_if_bpabi;
7291 case DT_VERDEF:
7292 name = ".gnu.version_d";
7293 goto get_vma_if_bpabi;
7294 case DT_VERNEED:
7295 name = ".gnu.version_r";
7296 goto get_vma_if_bpabi;
7297
7298 case DT_PLTGOT:
7299 name = ".got";
7300 goto get_vma;
7301 case DT_JMPREL:
7302 name = RELOC_SECTION (htab, ".plt");
7303 get_vma:
7304 s = bfd_get_section_by_name (output_bfd, name);
7305 BFD_ASSERT (s != NULL);
7306 if (!htab->symbian_p)
7307 dyn.d_un.d_ptr = s->vma;
7308 else
7309 /* In the BPABI, tags in the PT_DYNAMIC section point
7310 at the file offset, not the memory address, for the
7311 convenience of the post linker. */
7312 dyn.d_un.d_ptr = s->filepos;
7313 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7314 break;
7315
7316 get_vma_if_bpabi:
7317 if (htab->symbian_p)
7318 goto get_vma;
7319 break;
7320
7321 case DT_PLTRELSZ:
7322 s = bfd_get_section_by_name (output_bfd,
7323 RELOC_SECTION (htab, ".plt"));
7324 BFD_ASSERT (s != NULL);
7325 dyn.d_un.d_val = s->size;
7326 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7327 break;
7328
7329 case DT_RELSZ:
7330 case DT_RELASZ:
7331 if (!htab->symbian_p)
7332 {
7333 /* My reading of the SVR4 ABI indicates that the
7334 procedure linkage table relocs (DT_JMPREL) should be
7335 included in the overall relocs (DT_REL). This is
7336 what Solaris does. However, UnixWare can not handle
7337 that case. Therefore, we override the DT_RELSZ entry
7338 here to make it not include the JMPREL relocs. Since
7339 the linker script arranges for .rel(a).plt to follow all
7340 other relocation sections, we don't have to worry
7341 about changing the DT_REL entry. */
7342 s = bfd_get_section_by_name (output_bfd,
7343 RELOC_SECTION (htab, ".plt"));
7344 if (s != NULL)
7345 dyn.d_un.d_val -= s->size;
7346 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7347 break;
7348 }
7349 /* Fall through */
7350
7351 case DT_REL:
7352 case DT_RELA:
7353 /* In the BPABI, the DT_REL tag must point at the file
7354 offset, not the VMA, of the first relocation
7355 section. So, we use code similar to that in
7356 elflink.c, but do not check for SHF_ALLOC on the
7357 relcoation section, since relocations sections are
7358 never allocated under the BPABI. The comments above
7359 about Unixware notwithstanding, we include all of the
7360 relocations here. */
7361 if (htab->symbian_p)
7362 {
7363 unsigned int i;
7364 type = ((dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
7365 ? SHT_REL : SHT_RELA);
7366 dyn.d_un.d_val = 0;
7367 for (i = 1; i < elf_numsections (output_bfd); i++)
7368 {
7369 Elf_Internal_Shdr *hdr
7370 = elf_elfsections (output_bfd)[i];
7371 if (hdr->sh_type == type)
7372 {
7373 if (dyn.d_tag == DT_RELSZ
7374 || dyn.d_tag == DT_RELASZ)
7375 dyn.d_un.d_val += hdr->sh_size;
7376 else if ((ufile_ptr) hdr->sh_offset
7377 <= dyn.d_un.d_val - 1)
7378 dyn.d_un.d_val = hdr->sh_offset;
7379 }
7380 }
7381 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7382 }
7383 break;
7384
7385 /* Set the bottom bit of DT_INIT/FINI if the
7386 corresponding function is Thumb. */
7387 case DT_INIT:
7388 name = info->init_function;
7389 goto get_sym;
7390 case DT_FINI:
7391 name = info->fini_function;
7392 get_sym:
7393 /* If it wasn't set by elf_bfd_final_link
7394 then there is nothing to adjust. */
7395 if (dyn.d_un.d_val != 0)
7396 {
7397 struct elf_link_hash_entry * eh;
7398
7399 eh = elf_link_hash_lookup (elf_hash_table (info), name,
7400 FALSE, FALSE, TRUE);
7401 if (eh != (struct elf_link_hash_entry *) NULL
7402 && ELF_ST_TYPE (eh->type) == STT_ARM_TFUNC)
7403 {
7404 dyn.d_un.d_val |= 1;
7405 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7406 }
7407 }
7408 break;
7409 }
7410 }
7411
7412 /* Fill in the first entry in the procedure linkage table. */
7413 if (splt->size > 0 && elf32_arm_hash_table (info)->plt_header_size)
7414 {
7415 const bfd_vma *plt0_entry;
7416 bfd_vma got_address, plt_address, got_displacement;
7417
7418 /* Calculate the addresses of the GOT and PLT. */
7419 got_address = sgot->output_section->vma + sgot->output_offset;
7420 plt_address = splt->output_section->vma + splt->output_offset;
7421
7422 if (htab->vxworks_p)
7423 {
7424 /* The VxWorks GOT is relocated by the dynamic linker.
7425 Therefore, we must emit relocations rather than simply
7426 computing the values now. */
7427 Elf_Internal_Rela rel;
7428
7429 plt0_entry = elf32_arm_vxworks_exec_plt0_entry;
7430 bfd_put_32 (output_bfd, plt0_entry[0], splt->contents + 0);
7431 bfd_put_32 (output_bfd, plt0_entry[1], splt->contents + 4);
7432 bfd_put_32 (output_bfd, plt0_entry[2], splt->contents + 8);
7433 bfd_put_32 (output_bfd, got_address, splt->contents + 12);
7434
7435 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_. */
7436 rel.r_offset = plt_address + 12;
7437 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
7438 rel.r_addend = 0;
7439 SWAP_RELOC_OUT (htab) (output_bfd, &rel,
7440 htab->srelplt2->contents);
7441 }
7442 else
7443 {
7444 got_displacement = got_address - (plt_address + 16);
7445
7446 plt0_entry = elf32_arm_plt0_entry;
7447 bfd_put_32 (output_bfd, plt0_entry[0], splt->contents + 0);
7448 bfd_put_32 (output_bfd, plt0_entry[1], splt->contents + 4);
7449 bfd_put_32 (output_bfd, plt0_entry[2], splt->contents + 8);
7450 bfd_put_32 (output_bfd, plt0_entry[3], splt->contents + 12);
7451
7452 #ifdef FOUR_WORD_PLT
7453 /* The displacement value goes in the otherwise-unused
7454 last word of the second entry. */
7455 bfd_put_32 (output_bfd, got_displacement, splt->contents + 28);
7456 #else
7457 bfd_put_32 (output_bfd, got_displacement, splt->contents + 16);
7458 #endif
7459 }
7460 }
7461
7462 /* UnixWare sets the entsize of .plt to 4, although that doesn't
7463 really seem like the right value. */
7464 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
7465
7466 if (htab->vxworks_p && !info->shared && htab->splt->size > 0)
7467 {
7468 /* Correct the .rel(a).plt.unloaded relocations. They will have
7469 incorrect symbol indexes. */
7470 int num_plts;
7471 unsigned char *p;
7472
7473 num_plts = ((htab->splt->size - htab->plt_header_size)
7474 / htab->plt_entry_size);
7475 p = htab->srelplt2->contents + RELOC_SIZE (htab);
7476
7477 for (; num_plts; num_plts--)
7478 {
7479 Elf_Internal_Rela rel;
7480
7481 SWAP_RELOC_IN (htab) (output_bfd, p, &rel);
7482 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
7483 SWAP_RELOC_OUT (htab) (output_bfd, &rel, p);
7484 p += RELOC_SIZE (htab);
7485
7486 SWAP_RELOC_IN (htab) (output_bfd, p, &rel);
7487 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_ARM_ABS32);
7488 SWAP_RELOC_OUT (htab) (output_bfd, &rel, p);
7489 p += RELOC_SIZE (htab);
7490 }
7491 }
7492 }
7493
7494 /* Fill in the first three entries in the global offset table. */
7495 if (sgot)
7496 {
7497 if (sgot->size > 0)
7498 {
7499 if (sdyn == NULL)
7500 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
7501 else
7502 bfd_put_32 (output_bfd,
7503 sdyn->output_section->vma + sdyn->output_offset,
7504 sgot->contents);
7505 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
7506 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
7507 }
7508
7509 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
7510 }
7511
7512 return TRUE;
7513 }
7514
7515 static void
7516 elf32_arm_post_process_headers (bfd * abfd, struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
7517 {
7518 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
7519 struct elf32_arm_link_hash_table *globals;
7520
7521 i_ehdrp = elf_elfheader (abfd);
7522
7523 if (EF_ARM_EABI_VERSION (i_ehdrp->e_flags) == EF_ARM_EABI_UNKNOWN)
7524 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_ARM;
7525 else
7526 i_ehdrp->e_ident[EI_OSABI] = 0;
7527 i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
7528
7529 if (link_info)
7530 {
7531 globals = elf32_arm_hash_table (link_info);
7532 if (globals->byteswap_code)
7533 i_ehdrp->e_flags |= EF_ARM_BE8;
7534 }
7535 }
7536
7537 static enum elf_reloc_type_class
7538 elf32_arm_reloc_type_class (const Elf_Internal_Rela *rela)
7539 {
7540 switch ((int) ELF32_R_TYPE (rela->r_info))
7541 {
7542 case R_ARM_RELATIVE:
7543 return reloc_class_relative;
7544 case R_ARM_JUMP_SLOT:
7545 return reloc_class_plt;
7546 case R_ARM_COPY:
7547 return reloc_class_copy;
7548 default:
7549 return reloc_class_normal;
7550 }
7551 }
7552
7553 /* Set the right machine number for an Arm ELF file. */
7554
7555 static bfd_boolean
7556 elf32_arm_section_flags (flagword *flags, const Elf_Internal_Shdr *hdr)
7557 {
7558 if (hdr->sh_type == SHT_NOTE)
7559 *flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_CONTENTS;
7560
7561 return TRUE;
7562 }
7563
7564 static void
7565 elf32_arm_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED)
7566 {
7567 bfd_arm_update_notes (abfd, ARM_NOTE_SECTION);
7568 }
7569
7570 /* Return TRUE if this is an unwinding table entry. */
7571
7572 static bfd_boolean
7573 is_arm_elf_unwind_section_name (bfd * abfd ATTRIBUTE_UNUSED, const char * name)
7574 {
7575 size_t len1, len2;
7576
7577 len1 = sizeof (ELF_STRING_ARM_unwind) - 1;
7578 len2 = sizeof (ELF_STRING_ARM_unwind_once) - 1;
7579 return (strncmp (name, ELF_STRING_ARM_unwind, len1) == 0
7580 || strncmp (name, ELF_STRING_ARM_unwind_once, len2) == 0);
7581 }
7582
7583
7584 /* Set the type and flags for an ARM section. We do this by
7585 the section name, which is a hack, but ought to work. */
7586
7587 static bfd_boolean
7588 elf32_arm_fake_sections (bfd * abfd, Elf_Internal_Shdr * hdr, asection * sec)
7589 {
7590 const char * name;
7591
7592 name = bfd_get_section_name (abfd, sec);
7593
7594 if (is_arm_elf_unwind_section_name (abfd, name))
7595 {
7596 hdr->sh_type = SHT_ARM_EXIDX;
7597 hdr->sh_flags |= SHF_LINK_ORDER;
7598 }
7599 else if (strcmp(name, ".ARM.attributes") == 0)
7600 {
7601 hdr->sh_type = SHT_ARM_ATTRIBUTES;
7602 }
7603 return TRUE;
7604 }
7605
7606 /* Parse an Arm EABI attributes section. */
7607 static void
7608 elf32_arm_parse_attributes (bfd *abfd, Elf_Internal_Shdr * hdr)
7609 {
7610 bfd_byte *contents;
7611 bfd_byte *p;
7612 bfd_vma len;
7613
7614 contents = bfd_malloc (hdr->sh_size);
7615 if (!contents)
7616 return;
7617 if (!bfd_get_section_contents (abfd, hdr->bfd_section, contents, 0,
7618 hdr->sh_size))
7619 {
7620 free (contents);
7621 return;
7622 }
7623 p = contents;
7624 if (*(p++) == 'A')
7625 {
7626 len = hdr->sh_size - 1;
7627 while (len > 0)
7628 {
7629 int namelen;
7630 bfd_vma section_len;
7631
7632 section_len = bfd_get_32 (abfd, p);
7633 p += 4;
7634 if (section_len > len)
7635 section_len = len;
7636 len -= section_len;
7637 namelen = strlen ((char *)p) + 1;
7638 section_len -= namelen + 4;
7639 if (strcmp((char *)p, "aeabi") != 0)
7640 {
7641 /* Vendor section. Ignore it. */
7642 p += namelen + section_len;
7643 }
7644 else
7645 {
7646 p += namelen;
7647 while (section_len > 0)
7648 {
7649 int tag;
7650 unsigned int n;
7651 unsigned int val;
7652 bfd_vma subsection_len;
7653 bfd_byte *end;
7654
7655 tag = read_unsigned_leb128 (abfd, p, &n);
7656 p += n;
7657 subsection_len = bfd_get_32 (abfd, p);
7658 p += 4;
7659 if (subsection_len > section_len)
7660 subsection_len = section_len;
7661 section_len -= subsection_len;
7662 subsection_len -= n + 4;
7663 end = p + subsection_len;
7664 switch (tag)
7665 {
7666 case Tag_File:
7667 while (p < end)
7668 {
7669 bfd_boolean is_string;
7670
7671 tag = read_unsigned_leb128 (abfd, p, &n);
7672 p += n;
7673 if (tag == 4 || tag == 5)
7674 is_string = 1;
7675 else if (tag < 32)
7676 is_string = 0;
7677 else
7678 is_string = (tag & 1) != 0;
7679 if (tag == Tag_compatibility)
7680 {
7681 val = read_unsigned_leb128 (abfd, p, &n);
7682 p += n;
7683 elf32_arm_add_eabi_attr_compat (abfd, val,
7684 (char *)p);
7685 p += strlen ((char *)p) + 1;
7686 }
7687 else if (is_string)
7688 {
7689 elf32_arm_add_eabi_attr_string (abfd, tag,
7690 (char *)p);
7691 p += strlen ((char *)p) + 1;
7692 }
7693 else
7694 {
7695 val = read_unsigned_leb128 (abfd, p, &n);
7696 p += n;
7697 elf32_arm_add_eabi_attr_int (abfd, tag, val);
7698 }
7699 }
7700 break;
7701 case Tag_Section:
7702 case Tag_Symbol:
7703 /* Don't have anywhere convenient to attach these.
7704 Fall through for now. */
7705 default:
7706 /* Ignore things we don't kow about. */
7707 p += subsection_len;
7708 subsection_len = 0;
7709 break;
7710 }
7711 }
7712 }
7713 }
7714 }
7715 free (contents);
7716 }
7717
7718 /* Handle an ARM specific section when reading an object file. This is
7719 called when bfd_section_from_shdr finds a section with an unknown
7720 type. */
7721
7722 static bfd_boolean
7723 elf32_arm_section_from_shdr (bfd *abfd,
7724 Elf_Internal_Shdr * hdr,
7725 const char *name,
7726 int shindex)
7727 {
7728 /* There ought to be a place to keep ELF backend specific flags, but
7729 at the moment there isn't one. We just keep track of the
7730 sections by their name, instead. Fortunately, the ABI gives
7731 names for all the ARM specific sections, so we will probably get
7732 away with this. */
7733 switch (hdr->sh_type)
7734 {
7735 case SHT_ARM_EXIDX:
7736 case SHT_ARM_PREEMPTMAP:
7737 case SHT_ARM_ATTRIBUTES:
7738 break;
7739
7740 default:
7741 return FALSE;
7742 }
7743
7744 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
7745 return FALSE;
7746
7747 if (hdr->sh_type == SHT_ARM_ATTRIBUTES)
7748 elf32_arm_parse_attributes(abfd, hdr);
7749 return TRUE;
7750 }
7751
7752 /* A structure used to record a list of sections, independently
7753 of the next and prev fields in the asection structure. */
7754 typedef struct section_list
7755 {
7756 asection * sec;
7757 struct section_list * next;
7758 struct section_list * prev;
7759 }
7760 section_list;
7761
7762 /* Unfortunately we need to keep a list of sections for which
7763 an _arm_elf_section_data structure has been allocated. This
7764 is because it is possible for functions like elf32_arm_write_section
7765 to be called on a section which has had an elf_data_structure
7766 allocated for it (and so the used_by_bfd field is valid) but
7767 for which the ARM extended version of this structure - the
7768 _arm_elf_section_data structure - has not been allocated. */
7769 static section_list * sections_with_arm_elf_section_data = NULL;
7770
7771 static void
7772 record_section_with_arm_elf_section_data (asection * sec)
7773 {
7774 struct section_list * entry;
7775
7776 entry = bfd_malloc (sizeof (* entry));
7777 if (entry == NULL)
7778 return;
7779 entry->sec = sec;
7780 entry->next = sections_with_arm_elf_section_data;
7781 entry->prev = NULL;
7782 if (entry->next != NULL)
7783 entry->next->prev = entry;
7784 sections_with_arm_elf_section_data = entry;
7785 }
7786
7787 static struct section_list *
7788 find_arm_elf_section_entry (asection * sec)
7789 {
7790 struct section_list * entry;
7791 static struct section_list * last_entry = NULL;
7792
7793 /* This is a short cut for the typical case where the sections are added
7794 to the sections_with_arm_elf_section_data list in forward order and
7795 then looked up here in backwards order. This makes a real difference
7796 to the ld-srec/sec64k.exp linker test. */
7797 entry = sections_with_arm_elf_section_data;
7798 if (last_entry != NULL)
7799 {
7800 if (last_entry->sec == sec)
7801 entry = last_entry;
7802 else if (last_entry->next != NULL
7803 && last_entry->next->sec == sec)
7804 entry = last_entry->next;
7805 }
7806
7807 for (; entry; entry = entry->next)
7808 if (entry->sec == sec)
7809 break;
7810
7811 if (entry)
7812 /* Record the entry prior to this one - it is the entry we are most
7813 likely to want to locate next time. Also this way if we have been
7814 called from unrecord_section_with_arm_elf_section_data() we will not
7815 be caching a pointer that is about to be freed. */
7816 last_entry = entry->prev;
7817
7818 return entry;
7819 }
7820
7821 static _arm_elf_section_data *
7822 get_arm_elf_section_data (asection * sec)
7823 {
7824 struct section_list * entry;
7825
7826 entry = find_arm_elf_section_entry (sec);
7827
7828 if (entry)
7829 return elf32_arm_section_data (entry->sec);
7830 else
7831 return NULL;
7832 }
7833
7834 static void
7835 unrecord_section_with_arm_elf_section_data (asection * sec)
7836 {
7837 struct section_list * entry;
7838
7839 entry = find_arm_elf_section_entry (sec);
7840
7841 if (entry)
7842 {
7843 if (entry->prev != NULL)
7844 entry->prev->next = entry->next;
7845 if (entry->next != NULL)
7846 entry->next->prev = entry->prev;
7847 if (entry == sections_with_arm_elf_section_data)
7848 sections_with_arm_elf_section_data = entry->next;
7849 free (entry);
7850 }
7851 }
7852
7853 /* Called for each symbol. Builds a section map based on mapping symbols.
7854 Does not alter any of the symbols. */
7855
7856 static bfd_boolean
7857 elf32_arm_output_symbol_hook (struct bfd_link_info *info,
7858 const char *name,
7859 Elf_Internal_Sym *elfsym,
7860 asection *input_sec,
7861 struct elf_link_hash_entry *h)
7862 {
7863 int mapcount;
7864 elf32_arm_section_map *map;
7865 elf32_arm_section_map *newmap;
7866 _arm_elf_section_data *arm_data;
7867 struct elf32_arm_link_hash_table *globals;
7868
7869 globals = elf32_arm_hash_table (info);
7870 if (globals->vxworks_p
7871 && !elf_vxworks_link_output_symbol_hook (info, name, elfsym,
7872 input_sec, h))
7873 return FALSE;
7874
7875 /* Only do this on final link. */
7876 if (info->relocatable)
7877 return TRUE;
7878
7879 /* Only build a map if we need to byteswap code. */
7880 if (!globals->byteswap_code)
7881 return TRUE;
7882
7883 /* We only want mapping symbols. */
7884 if (!bfd_is_arm_special_symbol_name (name, BFD_ARM_SPECIAL_SYM_TYPE_MAP))
7885 return TRUE;
7886
7887 /* If this section has not been allocated an _arm_elf_section_data
7888 structure then we cannot record anything. */
7889 arm_data = get_arm_elf_section_data (input_sec);
7890 if (arm_data == NULL)
7891 return TRUE;
7892
7893 mapcount = arm_data->mapcount + 1;
7894 map = arm_data->map;
7895
7896 /* TODO: This may be inefficient, but we probably don't usually have many
7897 mapping symbols per section. */
7898 newmap = bfd_realloc (map, mapcount * sizeof (* map));
7899 if (newmap != NULL)
7900 {
7901 arm_data->map = newmap;
7902 arm_data->mapcount = mapcount;
7903
7904 newmap[mapcount - 1].vma = elfsym->st_value;
7905 newmap[mapcount - 1].type = name[1];
7906 }
7907
7908 return TRUE;
7909 }
7910
7911 /* Allocate target specific section data. */
7912
7913 static bfd_boolean
7914 elf32_arm_new_section_hook (bfd *abfd, asection *sec)
7915 {
7916 if (!sec->used_by_bfd)
7917 {
7918 _arm_elf_section_data *sdata;
7919 bfd_size_type amt = sizeof (*sdata);
7920
7921 sdata = bfd_zalloc (abfd, amt);
7922 if (sdata == NULL)
7923 return FALSE;
7924 sec->used_by_bfd = sdata;
7925 }
7926
7927 record_section_with_arm_elf_section_data (sec);
7928
7929 return _bfd_elf_new_section_hook (abfd, sec);
7930 }
7931
7932
7933 /* Used to order a list of mapping symbols by address. */
7934
7935 static int
7936 elf32_arm_compare_mapping (const void * a, const void * b)
7937 {
7938 return ((const elf32_arm_section_map *) a)->vma
7939 > ((const elf32_arm_section_map *) b)->vma;
7940 }
7941
7942
7943 /* Do code byteswapping. Return FALSE afterwards so that the section is
7944 written out as normal. */
7945
7946 static bfd_boolean
7947 elf32_arm_write_section (bfd *output_bfd ATTRIBUTE_UNUSED, asection *sec,
7948 bfd_byte *contents)
7949 {
7950 int mapcount;
7951 _arm_elf_section_data *arm_data;
7952 elf32_arm_section_map *map;
7953 bfd_vma ptr;
7954 bfd_vma end;
7955 bfd_vma offset;
7956 bfd_byte tmp;
7957 int i;
7958
7959 /* If this section has not been allocated an _arm_elf_section_data
7960 structure then we cannot record anything. */
7961 arm_data = get_arm_elf_section_data (sec);
7962 if (arm_data == NULL)
7963 return FALSE;
7964
7965 mapcount = arm_data->mapcount;
7966 map = arm_data->map;
7967
7968 if (mapcount == 0)
7969 return FALSE;
7970
7971 qsort (map, mapcount, sizeof (* map), elf32_arm_compare_mapping);
7972
7973 offset = sec->output_section->vma + sec->output_offset;
7974 ptr = map[0].vma - offset;
7975 for (i = 0; i < mapcount; i++)
7976 {
7977 if (i == mapcount - 1)
7978 end = sec->size;
7979 else
7980 end = map[i + 1].vma - offset;
7981
7982 switch (map[i].type)
7983 {
7984 case 'a':
7985 /* Byte swap code words. */
7986 while (ptr + 3 < end)
7987 {
7988 tmp = contents[ptr];
7989 contents[ptr] = contents[ptr + 3];
7990 contents[ptr + 3] = tmp;
7991 tmp = contents[ptr + 1];
7992 contents[ptr + 1] = contents[ptr + 2];
7993 contents[ptr + 2] = tmp;
7994 ptr += 4;
7995 }
7996 break;
7997
7998 case 't':
7999 /* Byte swap code halfwords. */
8000 while (ptr + 1 < end)
8001 {
8002 tmp = contents[ptr];
8003 contents[ptr] = contents[ptr + 1];
8004 contents[ptr + 1] = tmp;
8005 ptr += 2;
8006 }
8007 break;
8008
8009 case 'd':
8010 /* Leave data alone. */
8011 break;
8012 }
8013 ptr = end;
8014 }
8015
8016 free (map);
8017 arm_data->mapcount = 0;
8018 arm_data->map = NULL;
8019 unrecord_section_with_arm_elf_section_data (sec);
8020
8021 return FALSE;
8022 }
8023
8024 static void
8025 unrecord_section_via_map_over_sections (bfd * abfd ATTRIBUTE_UNUSED,
8026 asection * sec,
8027 void * ignore ATTRIBUTE_UNUSED)
8028 {
8029 unrecord_section_with_arm_elf_section_data (sec);
8030 }
8031
8032 static bfd_boolean
8033 elf32_arm_close_and_cleanup (bfd * abfd)
8034 {
8035 if (abfd->sections)
8036 bfd_map_over_sections (abfd,
8037 unrecord_section_via_map_over_sections,
8038 NULL);
8039
8040 return _bfd_elf_close_and_cleanup (abfd);
8041 }
8042
8043 static bfd_boolean
8044 elf32_arm_bfd_free_cached_info (bfd * abfd)
8045 {
8046 if (abfd->sections)
8047 bfd_map_over_sections (abfd,
8048 unrecord_section_via_map_over_sections,
8049 NULL);
8050
8051 return _bfd_free_cached_info (abfd);
8052 }
8053
8054 /* Display STT_ARM_TFUNC symbols as functions. */
8055
8056 static void
8057 elf32_arm_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
8058 asymbol *asym)
8059 {
8060 elf_symbol_type *elfsym = (elf_symbol_type *) asym;
8061
8062 if (ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_ARM_TFUNC)
8063 elfsym->symbol.flags |= BSF_FUNCTION;
8064 }
8065
8066
8067 /* Mangle thumb function symbols as we read them in. */
8068
8069 static void
8070 elf32_arm_swap_symbol_in (bfd * abfd,
8071 const void *psrc,
8072 const void *pshn,
8073 Elf_Internal_Sym *dst)
8074 {
8075 bfd_elf32_swap_symbol_in (abfd, psrc, pshn, dst);
8076
8077 /* New EABI objects mark thumb function symbols by setting the low bit of
8078 the address. Turn these into STT_ARM_TFUNC. */
8079 if (ELF_ST_TYPE (dst->st_info) == STT_FUNC
8080 && (dst->st_value & 1))
8081 {
8082 dst->st_info = ELF_ST_INFO (ELF_ST_BIND (dst->st_info), STT_ARM_TFUNC);
8083 dst->st_value &= ~(bfd_vma) 1;
8084 }
8085 }
8086
8087
8088 /* Mangle thumb function symbols as we write them out. */
8089
8090 static void
8091 elf32_arm_swap_symbol_out (bfd *abfd,
8092 const Elf_Internal_Sym *src,
8093 void *cdst,
8094 void *shndx)
8095 {
8096 Elf_Internal_Sym newsym;
8097
8098 /* We convert STT_ARM_TFUNC symbols into STT_FUNC with the low bit
8099 of the address set, as per the new EABI. We do this unconditionally
8100 because objcopy does not set the elf header flags until after
8101 it writes out the symbol table. */
8102 if (ELF_ST_TYPE (src->st_info) == STT_ARM_TFUNC)
8103 {
8104 newsym = *src;
8105 newsym.st_info = ELF_ST_INFO (ELF_ST_BIND (src->st_info), STT_FUNC);
8106 newsym.st_value |= 1;
8107
8108 src = &newsym;
8109 }
8110 bfd_elf32_swap_symbol_out (abfd, src, cdst, shndx);
8111 }
8112
8113 /* Add the PT_ARM_EXIDX program header. */
8114
8115 static bfd_boolean
8116 elf32_arm_modify_segment_map (bfd *abfd,
8117 struct bfd_link_info *info ATTRIBUTE_UNUSED)
8118 {
8119 struct elf_segment_map *m;
8120 asection *sec;
8121
8122 sec = bfd_get_section_by_name (abfd, ".ARM.exidx");
8123 if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
8124 {
8125 /* If there is already a PT_ARM_EXIDX header, then we do not
8126 want to add another one. This situation arises when running
8127 "strip"; the input binary already has the header. */
8128 m = elf_tdata (abfd)->segment_map;
8129 while (m && m->p_type != PT_ARM_EXIDX)
8130 m = m->next;
8131 if (!m)
8132 {
8133 m = bfd_zalloc (abfd, sizeof (struct elf_segment_map));
8134 if (m == NULL)
8135 return FALSE;
8136 m->p_type = PT_ARM_EXIDX;
8137 m->count = 1;
8138 m->sections[0] = sec;
8139
8140 m->next = elf_tdata (abfd)->segment_map;
8141 elf_tdata (abfd)->segment_map = m;
8142 }
8143 }
8144
8145 return TRUE;
8146 }
8147
8148 /* We may add a PT_ARM_EXIDX program header. */
8149
8150 static int
8151 elf32_arm_additional_program_headers (bfd *abfd)
8152 {
8153 asection *sec;
8154
8155 sec = bfd_get_section_by_name (abfd, ".ARM.exidx");
8156 if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
8157 return 1;
8158 else
8159 return 0;
8160 }
8161
8162 /* We use this to override swap_symbol_in and swap_symbol_out. */
8163 const struct elf_size_info elf32_arm_size_info = {
8164 sizeof (Elf32_External_Ehdr),
8165 sizeof (Elf32_External_Phdr),
8166 sizeof (Elf32_External_Shdr),
8167 sizeof (Elf32_External_Rel),
8168 sizeof (Elf32_External_Rela),
8169 sizeof (Elf32_External_Sym),
8170 sizeof (Elf32_External_Dyn),
8171 sizeof (Elf_External_Note),
8172 4,
8173 1,
8174 32, 2,
8175 ELFCLASS32, EV_CURRENT,
8176 bfd_elf32_write_out_phdrs,
8177 bfd_elf32_write_shdrs_and_ehdr,
8178 bfd_elf32_write_relocs,
8179 elf32_arm_swap_symbol_in,
8180 elf32_arm_swap_symbol_out,
8181 bfd_elf32_slurp_reloc_table,
8182 bfd_elf32_slurp_symbol_table,
8183 bfd_elf32_swap_dyn_in,
8184 bfd_elf32_swap_dyn_out,
8185 bfd_elf32_swap_reloc_in,
8186 bfd_elf32_swap_reloc_out,
8187 bfd_elf32_swap_reloca_in,
8188 bfd_elf32_swap_reloca_out
8189 };
8190
8191 #define ELF_ARCH bfd_arch_arm
8192 #define ELF_MACHINE_CODE EM_ARM
8193 #ifdef __QNXTARGET__
8194 #define ELF_MAXPAGESIZE 0x1000
8195 #else
8196 #define ELF_MAXPAGESIZE 0x8000
8197 #endif
8198 #define ELF_MINPAGESIZE 0x1000
8199
8200 #define bfd_elf32_mkobject elf32_arm_mkobject
8201
8202 #define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
8203 #define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
8204 #define bfd_elf32_bfd_set_private_flags elf32_arm_set_private_flags
8205 #define bfd_elf32_bfd_print_private_bfd_data elf32_arm_print_private_bfd_data
8206 #define bfd_elf32_bfd_link_hash_table_create elf32_arm_link_hash_table_create
8207 #define bfd_elf32_bfd_reloc_type_lookup elf32_arm_reloc_type_lookup
8208 #define bfd_elf32_find_nearest_line elf32_arm_find_nearest_line
8209 #define bfd_elf32_find_inliner_info elf32_arm_find_inliner_info
8210 #define bfd_elf32_new_section_hook elf32_arm_new_section_hook
8211 #define bfd_elf32_bfd_is_target_special_symbol elf32_arm_is_target_special_symbol
8212 #define bfd_elf32_close_and_cleanup elf32_arm_close_and_cleanup
8213 #define bfd_elf32_bfd_free_cached_info elf32_arm_bfd_free_cached_info
8214 #define bfd_elf32_bfd_final_link elf32_arm_bfd_final_link
8215
8216 #define elf_backend_get_symbol_type elf32_arm_get_symbol_type
8217 #define elf_backend_gc_mark_hook elf32_arm_gc_mark_hook
8218 #define elf_backend_gc_sweep_hook elf32_arm_gc_sweep_hook
8219 #define elf_backend_check_relocs elf32_arm_check_relocs
8220 #define elf_backend_relocate_section elf32_arm_relocate_section
8221 #define elf_backend_write_section elf32_arm_write_section
8222 #define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
8223 #define elf_backend_create_dynamic_sections elf32_arm_create_dynamic_sections
8224 #define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
8225 #define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
8226 #define elf_backend_link_output_symbol_hook elf32_arm_output_symbol_hook
8227 #define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
8228 #define elf_backend_post_process_headers elf32_arm_post_process_headers
8229 #define elf_backend_reloc_type_class elf32_arm_reloc_type_class
8230 #define elf_backend_object_p elf32_arm_object_p
8231 #define elf_backend_section_flags elf32_arm_section_flags
8232 #define elf_backend_fake_sections elf32_arm_fake_sections
8233 #define elf_backend_section_from_shdr elf32_arm_section_from_shdr
8234 #define elf_backend_final_write_processing elf32_arm_final_write_processing
8235 #define elf_backend_copy_indirect_symbol elf32_arm_copy_indirect_symbol
8236 #define elf_backend_symbol_processing elf32_arm_symbol_processing
8237 #define elf_backend_size_info elf32_arm_size_info
8238 #define elf_backend_modify_segment_map elf32_arm_modify_segment_map
8239 #define elf_backend_additional_program_headers \
8240 elf32_arm_additional_program_headers
8241
8242 #define elf_backend_can_refcount 1
8243 #define elf_backend_can_gc_sections 1
8244 #define elf_backend_plt_readonly 1
8245 #define elf_backend_want_got_plt 1
8246 #define elf_backend_want_plt_sym 0
8247 #define elf_backend_may_use_rel_p 1
8248 #define elf_backend_may_use_rela_p 0
8249 #define elf_backend_default_use_rela_p 0
8250 #define elf_backend_rela_normal 0
8251
8252 #define elf_backend_got_header_size 12
8253
8254 #include "elf32-target.h"
8255
8256 /* VxWorks Targets */
8257
8258 #undef TARGET_LITTLE_SYM
8259 #define TARGET_LITTLE_SYM bfd_elf32_littlearm_vxworks_vec
8260 #undef TARGET_LITTLE_NAME
8261 #define TARGET_LITTLE_NAME "elf32-littlearm-vxworks"
8262 #undef TARGET_BIG_SYM
8263 #define TARGET_BIG_SYM bfd_elf32_bigarm_vxworks_vec
8264 #undef TARGET_BIG_NAME
8265 #define TARGET_BIG_NAME "elf32-bigarm-vxworks"
8266
8267 /* Like elf32_arm_link_hash_table_create -- but overrides
8268 appropriately for VxWorks. */
8269 static struct bfd_link_hash_table *
8270 elf32_arm_vxworks_link_hash_table_create (bfd *abfd)
8271 {
8272 struct bfd_link_hash_table *ret;
8273
8274 ret = elf32_arm_link_hash_table_create (abfd);
8275 if (ret)
8276 {
8277 struct elf32_arm_link_hash_table *htab
8278 = (struct elf32_arm_link_hash_table *) ret;
8279 htab->use_rel = 0;
8280 htab->vxworks_p = 1;
8281 }
8282 return ret;
8283 }
8284
8285 static void
8286 elf32_arm_vxworks_final_write_processing (bfd *abfd, bfd_boolean linker)
8287 {
8288 elf32_arm_final_write_processing (abfd, linker);
8289 elf_vxworks_final_write_processing (abfd, linker);
8290 }
8291
8292 #undef elf32_bed
8293 #define elf32_bed elf32_arm_vxworks_bed
8294
8295 #undef bfd_elf32_bfd_link_hash_table_create
8296 #define bfd_elf32_bfd_link_hash_table_create \
8297 elf32_arm_vxworks_link_hash_table_create
8298 #undef elf_backend_add_symbol_hook
8299 #define elf_backend_add_symbol_hook \
8300 elf_vxworks_add_symbol_hook
8301 #undef elf_backend_final_write_processing
8302 #define elf_backend_final_write_processing \
8303 elf32_arm_vxworks_final_write_processing
8304 #undef elf_backend_emit_relocs
8305 #define elf_backend_emit_relocs \
8306 elf_vxworks_emit_relocs
8307
8308 #undef elf_backend_may_use_rel_p
8309 #define elf_backend_may_use_rel_p 0
8310 #undef elf_backend_may_use_rela_p
8311 #define elf_backend_may_use_rela_p 1
8312 #undef elf_backend_default_use_rela_p
8313 #define elf_backend_default_use_rela_p 1
8314 #undef elf_backend_rela_normal
8315 #define elf_backend_rela_normal 1
8316 #undef elf_backend_want_plt_sym
8317 #define elf_backend_want_plt_sym 1
8318 #undef ELF_MAXPAGESIZE
8319 #define ELF_MAXPAGESIZE 0x1000
8320
8321 #include "elf32-target.h"
8322
8323
8324 /* Symbian OS Targets */
8325
8326 #undef TARGET_LITTLE_SYM
8327 #define TARGET_LITTLE_SYM bfd_elf32_littlearm_symbian_vec
8328 #undef TARGET_LITTLE_NAME
8329 #define TARGET_LITTLE_NAME "elf32-littlearm-symbian"
8330 #undef TARGET_BIG_SYM
8331 #define TARGET_BIG_SYM bfd_elf32_bigarm_symbian_vec
8332 #undef TARGET_BIG_NAME
8333 #define TARGET_BIG_NAME "elf32-bigarm-symbian"
8334
8335 /* Like elf32_arm_link_hash_table_create -- but overrides
8336 appropriately for Symbian OS. */
8337 static struct bfd_link_hash_table *
8338 elf32_arm_symbian_link_hash_table_create (bfd *abfd)
8339 {
8340 struct bfd_link_hash_table *ret;
8341
8342 ret = elf32_arm_link_hash_table_create (abfd);
8343 if (ret)
8344 {
8345 struct elf32_arm_link_hash_table *htab
8346 = (struct elf32_arm_link_hash_table *)ret;
8347 /* There is no PLT header for Symbian OS. */
8348 htab->plt_header_size = 0;
8349 /* The PLT entries are each three instructions. */
8350 htab->plt_entry_size = 4 * NUM_ELEM (elf32_arm_symbian_plt_entry);
8351 htab->symbian_p = 1;
8352 /* Symbian uses armv5t or above, so use_blx is always true. */
8353 htab->use_blx = 1;
8354 htab->root.is_relocatable_executable = 1;
8355 }
8356 return ret;
8357 }
8358
8359 static const struct bfd_elf_special_section
8360 elf32_arm_symbian_special_sections[] =
8361 {
8362 /* In a BPABI executable, the dynamic linking sections do not go in
8363 the loadable read-only segment. The post-linker may wish to
8364 refer to these sections, but they are not part of the final
8365 program image. */
8366 { ".dynamic", 8, 0, SHT_DYNAMIC, 0 },
8367 { ".dynstr", 7, 0, SHT_STRTAB, 0 },
8368 { ".dynsym", 7, 0, SHT_DYNSYM, 0 },
8369 { ".got", 4, 0, SHT_PROGBITS, 0 },
8370 { ".hash", 5, 0, SHT_HASH, 0 },
8371 /* These sections do not need to be writable as the SymbianOS
8372 postlinker will arrange things so that no dynamic relocation is
8373 required. */
8374 { ".init_array", 11, 0, SHT_INIT_ARRAY, SHF_ALLOC },
8375 { ".fini_array", 11, 0, SHT_FINI_ARRAY, SHF_ALLOC },
8376 { ".preinit_array", 14, 0, SHT_PREINIT_ARRAY, SHF_ALLOC },
8377 { NULL, 0, 0, 0, 0 }
8378 };
8379
8380 static void
8381 elf32_arm_symbian_begin_write_processing (bfd *abfd,
8382 struct bfd_link_info *link_info
8383 ATTRIBUTE_UNUSED)
8384 {
8385 /* BPABI objects are never loaded directly by an OS kernel; they are
8386 processed by a postlinker first, into an OS-specific format. If
8387 the D_PAGED bit is set on the file, BFD will align segments on
8388 page boundaries, so that an OS can directly map the file. With
8389 BPABI objects, that just results in wasted space. In addition,
8390 because we clear the D_PAGED bit, map_sections_to_segments will
8391 recognize that the program headers should not be mapped into any
8392 loadable segment. */
8393 abfd->flags &= ~D_PAGED;
8394 }
8395
8396 static bfd_boolean
8397 elf32_arm_symbian_modify_segment_map (bfd *abfd,
8398 struct bfd_link_info *info)
8399 {
8400 struct elf_segment_map *m;
8401 asection *dynsec;
8402
8403 /* BPABI shared libraries and executables should have a PT_DYNAMIC
8404 segment. However, because the .dynamic section is not marked
8405 with SEC_LOAD, the generic ELF code will not create such a
8406 segment. */
8407 dynsec = bfd_get_section_by_name (abfd, ".dynamic");
8408 if (dynsec)
8409 {
8410 m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
8411 m->next = elf_tdata (abfd)->segment_map;
8412 elf_tdata (abfd)->segment_map = m;
8413 }
8414
8415 /* Also call the generic arm routine. */
8416 return elf32_arm_modify_segment_map (abfd, info);
8417 }
8418
8419 #undef elf32_bed
8420 #define elf32_bed elf32_arm_symbian_bed
8421
8422 /* The dynamic sections are not allocated on SymbianOS; the postlinker
8423 will process them and then discard them. */
8424 #undef ELF_DYNAMIC_SEC_FLAGS
8425 #define ELF_DYNAMIC_SEC_FLAGS \
8426 (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED)
8427
8428 #undef bfd_elf32_bfd_link_hash_table_create
8429 #define bfd_elf32_bfd_link_hash_table_create \
8430 elf32_arm_symbian_link_hash_table_create
8431 #undef elf_backend_add_symbol_hook
8432
8433 #undef elf_backend_special_sections
8434 #define elf_backend_special_sections elf32_arm_symbian_special_sections
8435
8436 #undef elf_backend_begin_write_processing
8437 #define elf_backend_begin_write_processing \
8438 elf32_arm_symbian_begin_write_processing
8439 #undef elf_backend_final_write_processing
8440 #define elf_backend_final_write_processing \
8441 elf32_arm_final_write_processing
8442 #undef elf_backend_emit_relocs
8443
8444 #undef elf_backend_modify_segment_map
8445 #define elf_backend_modify_segment_map elf32_arm_symbian_modify_segment_map
8446
8447 /* There is no .got section for BPABI objects, and hence no header. */
8448 #undef elf_backend_got_header_size
8449 #define elf_backend_got_header_size 0
8450
8451 /* Similarly, there is no .got.plt section. */
8452 #undef elf_backend_want_got_plt
8453 #define elf_backend_want_got_plt 0
8454
8455 #undef elf_backend_may_use_rel_p
8456 #define elf_backend_may_use_rel_p 1
8457 #undef elf_backend_may_use_rela_p
8458 #define elf_backend_may_use_rela_p 0
8459 #undef elf_backend_default_use_rela_p
8460 #define elf_backend_default_use_rela_p 0
8461 #undef elf_backend_rela_normal
8462 #define elf_backend_rela_normal 0
8463 #undef elf_backend_want_plt_sym
8464 #define elf_backend_want_plt_sym 0
8465 #undef ELF_MAXPAGESIZE
8466 #define ELF_MAXPAGESIZE 0x8000
8467
8468 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.210776 seconds and 4 git commands to generate.