projects / deliverable / binutils-gdb.git / blob
? search:


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