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