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