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