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