projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* elf32-sh.c (sh_elf_create_dynamic_sections): Don't call
[deliverable/binutils-gdb.git] / bfd / elf32-sh.c
CommitLineData
ef230218 1/* Renesas / SuperH SH specific support for 32-bit ELF
571fe01f 2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
7898deda 3 Free Software Foundation, Inc.
252b5132
RH		 4 Contributed by Ian Lance Taylor, Cygnus Support.
5
571fe01f 6 This file is part of BFD, the Binary File Descriptor library.
252b5132 7
571fe01f
NC		 8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
252b5132 12
571fe01f
NC		 13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
252b5132 17
571fe01f
NC		 18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
252b5132
RH		 21
22#include "bfd.h"
23#include "sysdep.h"
24#include "bfdlink.h"
25#include "libbfd.h"
26#include "elf-bfd.h"
27#include "elf/sh.h"
28
29static bfd_reloc_status_type sh_elf_reloc
30 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
31static bfd_reloc_status_type sh_elf_ignore_reloc
32 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
33static reloc_howto_type *sh_elf_reloc_type_lookup
34 PARAMS ((bfd *, bfd_reloc_code_real_type));
35static void sh_elf_info_to_howto
36 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
b34976b6 37static bfd_boolean sh_elf_set_private_flags
d4845d57 38 PARAMS ((bfd *, flagword));
b34976b6 39static bfd_boolean sh_elf_copy_private_data
d4845d57 40 PARAMS ((bfd *, bfd *));
b34976b6 41static bfd_boolean sh_elf_merge_private_data
d4845d57 42 PARAMS ((bfd *, bfd *));
b34976b6 43static bfd_boolean sh_elf_set_mach_from_flags
d4845d57 44 PARAMS ((bfd *));
b34976b6
AM		 45static bfd_boolean sh_elf_relax_section
46 PARAMS ((bfd *, asection *, struct bfd_link_info *, bfd_boolean *));
47static bfd_boolean sh_elf_relax_delete_bytes
252b5132 48 PARAMS ((bfd *, asection *, bfd_vma, int));
b34976b6
AM		 49static bfd_boolean sh_elf_align_loads
50 PARAMS ((bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, bfd_boolean *));
51static bfd_boolean sh_elf_swap_insns
252b5132 52 PARAMS ((bfd *, asection *, PTR, bfd_byte *, bfd_vma));
b34976b6 53static bfd_boolean sh_elf_relocate_section
252b5132
RH		 54 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
55 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
56static bfd_byte *sh_elf_get_relocated_section_contents
57 PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *,
b34976b6 58 bfd_byte *, bfd_boolean, asymbol **));
067653c5
AM		 59static void sh_elf_copy_indirect_symbol
60 PARAMS ((struct elf_backend_data *, struct elf_link_hash_entry *,
61 struct elf_link_hash_entry *));
3376eaf5
KK		 62static int sh_elf_optimized_tls_reloc
63 PARAMS ((struct bfd_link_info *, int, int));
b34976b6 64static bfd_boolean sh_elf_mkobject
571fe01f 65 PARAMS ((bfd *));
b34976b6 66static bfd_boolean sh_elf_object_p
571fe01f 67 PARAMS ((bfd *));
b34976b6 68static bfd_boolean sh_elf_check_relocs
37c644f2
AO		 69 PARAMS ((bfd *, struct bfd_link_info *, asection *,
70 const Elf_Internal_Rela *));
71static struct bfd_hash_entry *sh_elf_link_hash_newfunc
72 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
73static struct bfd_link_hash_table *sh_elf_link_hash_table_create
74 PARAMS ((bfd *));
b34976b6 75static bfd_boolean sh_elf_adjust_dynamic_symbol
37c644f2 76 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
b34976b6 77static bfd_boolean sh_elf_size_dynamic_sections
37c644f2 78 PARAMS ((bfd *, struct bfd_link_info *));
b34976b6 79static bfd_boolean sh_elf_finish_dynamic_symbol
37c644f2
AO		 80 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
81 Elf_Internal_Sym *));
b34976b6 82static bfd_boolean sh_elf_finish_dynamic_sections
37c644f2 83 PARAMS ((bfd *, struct bfd_link_info *));
917583ad
NC		 84static bfd_reloc_status_type sh_elf_reloc_loop
85 PARAMS ((int, bfd *, asection *, bfd_byte *, bfd_vma, asection *,
86 bfd_vma, bfd_vma));
b34976b6 87static bfd_boolean create_got_section
571fe01f 88 PARAMS ((bfd *, struct bfd_link_info *));
b34976b6 89static bfd_boolean sh_elf_create_dynamic_sections
917583ad 90 PARAMS ((bfd *, struct bfd_link_info *));
3376eaf5
KK		 91static bfd_vma dtpoff_base
92 PARAMS ((struct bfd_link_info *));
267fb3c1
KK		 93static bfd_vma tpoff
94 PARAMS ((struct bfd_link_info *, bfd_vma));
917583ad 95static asection * sh_elf_gc_mark_hook
1e2f5b6e 96 PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
917583ad 97 struct elf_link_hash_entry *, Elf_Internal_Sym *));
b34976b6 98static bfd_boolean sh_elf_gc_sweep_hook
917583ad
NC		 99 PARAMS ((bfd *, struct bfd_link_info *, asection *,
100 const Elf_Internal_Rela *));
b34976b6 101static bfd_boolean allocate_dynrelocs
067653c5 102 PARAMS ((struct elf_link_hash_entry *, PTR));
b34976b6 103static bfd_boolean readonly_dynrelocs
067653c5 104 PARAMS ((struct elf_link_hash_entry *, PTR));
99e4ae17 105static enum elf_reloc_type_class sh_elf_reloc_type_class
f51e552e 106 PARAMS ((const Elf_Internal_Rela *));
518313c3
AO		 107#ifdef INCLUDE_SHMEDIA
108inline static void movi_shori_putval PARAMS ((bfd *, unsigned long, char *));
109#endif
b34976b6 110static bfd_boolean elf32_shlin_grok_prstatus
2bc3c89a 111 PARAMS ((bfd *abfd, Elf_Internal_Note *note));
b34976b6 112static bfd_boolean elf32_shlin_grok_psinfo
2bc3c89a 113 PARAMS ((bfd *abfd, Elf_Internal_Note *note));
37c644f2
AO		 114
115/* The name of the dynamic interpreter. This is put in the .interp
116 section. */
117
118#define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
252b5132 119
38b1a46c
NC		 120static reloc_howto_type sh_elf_howto_table[] =
121{
252b5132
RH		 122 /* No relocation. */
123 HOWTO (R_SH_NONE, /* type */
124 0, /* rightshift */
125 0, /* size (0 = byte, 1 = short, 2 = long) */
126 0, /* bitsize */
b34976b6 127 FALSE, /* pc_relative */
252b5132
RH		 128 0, /* bitpos */
129 complain_overflow_dont, /* complain_on_overflow */
015551fc 130 sh_elf_ignore_reloc, /* special_function */
252b5132 131 "R_SH_NONE", /* name */
b34976b6 132 FALSE, /* partial_inplace */
252b5132
RH		 133 0, /* src_mask */
134 0, /* dst_mask */
b34976b6 135 FALSE), /* pcrel_offset */
252b5132 136
b34976b6 137 /* 32 bit absolute relocation. Setting partial_inplace to TRUE and
252b5132
RH		 138 src_mask to a non-zero value is similar to the COFF toolchain. */
139 HOWTO (R_SH_DIR32, /* type */
140 0, /* rightshift */
141 2, /* size (0 = byte, 1 = short, 2 = long) */
142 32, /* bitsize */
b34976b6 143 FALSE, /* pc_relative */
252b5132
RH		 144 0, /* bitpos */
145 complain_overflow_bitfield, /* complain_on_overflow */
146 sh_elf_reloc, /* special_function */
147 "R_SH_DIR32", /* name */
b34976b6 148 TRUE, /* partial_inplace */
252b5132
RH		 149 0xffffffff, /* src_mask */
150 0xffffffff, /* dst_mask */
b34976b6 151 FALSE), /* pcrel_offset */
252b5132
RH		 152
153 /* 32 bit PC relative relocation. */
154 HOWTO (R_SH_REL32, /* type */
155 0, /* rightshift */
156 2, /* size (0 = byte, 1 = short, 2 = long) */
157 32, /* bitsize */
b34976b6 158 TRUE, /* pc_relative */
252b5132
RH		 159 0, /* bitpos */
160 complain_overflow_signed, /* complain_on_overflow */
015551fc 161 sh_elf_ignore_reloc, /* special_function */
252b5132 162 "R_SH_REL32", /* name */
b34976b6 163 TRUE, /* partial_inplace */
146be91a 164 0xffffffff, /* src_mask */
252b5132 165 0xffffffff, /* dst_mask */
b34976b6 166 TRUE), /* pcrel_offset */
252b5132
RH		 167
168 /* 8 bit PC relative branch divided by 2. */
169 HOWTO (R_SH_DIR8WPN, /* type */
170 1, /* rightshift */
171 1, /* size (0 = byte, 1 = short, 2 = long) */
172 8, /* bitsize */
b34976b6 173 TRUE, /* pc_relative */
252b5132
RH		 174 0, /* bitpos */
175 complain_overflow_signed, /* complain_on_overflow */
015551fc 176 sh_elf_ignore_reloc, /* special_function */
252b5132 177 "R_SH_DIR8WPN", /* name */
b34976b6 178 TRUE, /* partial_inplace */
252b5132
RH		 179 0xff, /* src_mask */
180 0xff, /* dst_mask */
b34976b6 181 TRUE), /* pcrel_offset */
252b5132
RH		 182
183 /* 12 bit PC relative branch divided by 2. */
bdfaef52
JR		 184 /* This cannot be partial_inplace because relaxation can't know the
185 eventual value of a symbol. */
252b5132
RH		 186 HOWTO (R_SH_IND12W, /* type */
187 1, /* rightshift */
188 1, /* size (0 = byte, 1 = short, 2 = long) */
189 12, /* bitsize */
b34976b6 190 TRUE, /* pc_relative */
252b5132
RH		 191 0, /* bitpos */
192 complain_overflow_signed, /* complain_on_overflow */
bdfaef52 193 NULL, /* special_function */
252b5132 194 "R_SH_IND12W", /* name */
bdfaef52
JR		 195 FALSE, /* partial_inplace */
196 0x0, /* src_mask */
252b5132 197 0xfff, /* dst_mask */
b34976b6 198 TRUE), /* pcrel_offset */
252b5132
RH		 199
200 /* 8 bit unsigned PC relative divided by 4. */
201 HOWTO (R_SH_DIR8WPL, /* type */
202 2, /* rightshift */
203 1, /* size (0 = byte, 1 = short, 2 = long) */
204 8, /* bitsize */
b34976b6 205 TRUE, /* pc_relative */
252b5132
RH		 206 0, /* bitpos */
207 complain_overflow_unsigned, /* complain_on_overflow */
015551fc 208 sh_elf_ignore_reloc, /* special_function */
252b5132 209 "R_SH_DIR8WPL", /* name */
b34976b6 210 TRUE, /* partial_inplace */
252b5132
RH		 211 0xff, /* src_mask */
212 0xff, /* dst_mask */
b34976b6 213 TRUE), /* pcrel_offset */
252b5132
RH		 214
215 /* 8 bit unsigned PC relative divided by 2. */
216 HOWTO (R_SH_DIR8WPZ, /* type */
217 1, /* rightshift */
218 1, /* size (0 = byte, 1 = short, 2 = long) */
219 8, /* bitsize */
b34976b6 220 TRUE, /* pc_relative */
252b5132
RH		 221 0, /* bitpos */
222 complain_overflow_unsigned, /* complain_on_overflow */
015551fc 223 sh_elf_ignore_reloc, /* special_function */
252b5132 224 "R_SH_DIR8WPZ", /* name */
b34976b6 225 TRUE, /* partial_inplace */
252b5132
RH		 226 0xff, /* src_mask */
227 0xff, /* dst_mask */
b34976b6 228 TRUE), /* pcrel_offset */
252b5132
RH		 229
230 /* 8 bit GBR relative. FIXME: This only makes sense if we have some
231 special symbol for the GBR relative area, and that is not
232 implemented. */
233 HOWTO (R_SH_DIR8BP, /* type */
234 0, /* rightshift */
235 1, /* size (0 = byte, 1 = short, 2 = long) */
236 8, /* bitsize */
b34976b6 237 FALSE, /* pc_relative */
252b5132
RH		 238 0, /* bitpos */
239 complain_overflow_unsigned, /* complain_on_overflow */
015551fc 240 sh_elf_ignore_reloc, /* special_function */
252b5132 241 "R_SH_DIR8BP", /* name */
b34976b6 242 FALSE, /* partial_inplace */
252b5132
RH		 243 0, /* src_mask */
244 0xff, /* dst_mask */
b34976b6 245 TRUE), /* pcrel_offset */
252b5132
RH		 246
247 /* 8 bit GBR relative divided by 2. FIXME: This only makes sense if
248 we have some special symbol for the GBR relative area, and that
249 is not implemented. */
250 HOWTO (R_SH_DIR8W, /* type */
251 1, /* rightshift */
252 1, /* size (0 = byte, 1 = short, 2 = long) */
253 8, /* bitsize */
b34976b6 254 FALSE, /* pc_relative */
252b5132
RH		 255 0, /* bitpos */
256 complain_overflow_unsigned, /* complain_on_overflow */
015551fc 257 sh_elf_ignore_reloc, /* special_function */
252b5132 258 "R_SH_DIR8W", /* name */
b34976b6 259 FALSE, /* partial_inplace */
252b5132
RH		 260 0, /* src_mask */
261 0xff, /* dst_mask */
b34976b6 262 TRUE), /* pcrel_offset */
252b5132
RH		 263
264 /* 8 bit GBR relative divided by 4. FIXME: This only makes sense if
265 we have some special symbol for the GBR relative area, and that
266 is not implemented. */
267 HOWTO (R_SH_DIR8L, /* type */
268 2, /* rightshift */
269 1, /* size (0 = byte, 1 = short, 2 = long) */
270 8, /* bitsize */
b34976b6 271 FALSE, /* pc_relative */
252b5132
RH		 272 0, /* bitpos */
273 complain_overflow_unsigned, /* complain_on_overflow */
015551fc 274 sh_elf_ignore_reloc, /* special_function */
252b5132 275 "R_SH_DIR8L", /* name */
b34976b6 276 FALSE, /* partial_inplace */
252b5132
RH		 277 0, /* src_mask */
278 0xff, /* dst_mask */
b34976b6 279 TRUE), /* pcrel_offset */
252b5132 280
06bb75c1
AO		 281 EMPTY_HOWTO (10),
282 EMPTY_HOWTO (11),
283 EMPTY_HOWTO (12),
284 EMPTY_HOWTO (13),
285 EMPTY_HOWTO (14),
286 EMPTY_HOWTO (15),
287 EMPTY_HOWTO (16),
288 EMPTY_HOWTO (17),
5f771d47
ILT		 289 EMPTY_HOWTO (18),
290 EMPTY_HOWTO (19),
291 EMPTY_HOWTO (20),
292 EMPTY_HOWTO (21),
293 EMPTY_HOWTO (22),
294 EMPTY_HOWTO (23),
295 EMPTY_HOWTO (24),
252b5132
RH		 296
297 /* The remaining relocs are a GNU extension used for relaxing. The
298 final pass of the linker never needs to do anything with any of
299 these relocs. Any required operations are handled by the
300 relaxation code. */
301
302 /* A 16 bit switch table entry. This is generated for an expression
303 such as ``.word L1 - L2''. The offset holds the difference
304 between the reloc address and L2. */
305 HOWTO (R_SH_SWITCH16, /* type */
306 0, /* rightshift */
307 1, /* size (0 = byte, 1 = short, 2 = long) */
308 16, /* bitsize */
b34976b6 309 FALSE, /* pc_relative */
252b5132
RH		 310 0, /* bitpos */
311 complain_overflow_unsigned, /* complain_on_overflow */
312 sh_elf_ignore_reloc, /* special_function */
313 "R_SH_SWITCH16", /* name */
b34976b6 314 FALSE, /* partial_inplace */
252b5132
RH		 315 0, /* src_mask */
316 0, /* dst_mask */
b34976b6 317 TRUE), /* pcrel_offset */
252b5132
RH		 318
319 /* A 32 bit switch table entry. This is generated for an expression
320 such as ``.long L1 - L2''. The offset holds the difference
321 between the reloc address and L2. */
322 HOWTO (R_SH_SWITCH32, /* type */
323 0, /* rightshift */
324 2, /* size (0 = byte, 1 = short, 2 = long) */
325 32, /* bitsize */
b34976b6 326 FALSE, /* pc_relative */
252b5132
RH		 327 0, /* bitpos */
328 complain_overflow_unsigned, /* complain_on_overflow */
329 sh_elf_ignore_reloc, /* special_function */
330 "R_SH_SWITCH32", /* name */
b34976b6 331 FALSE, /* partial_inplace */
252b5132
RH		 332 0, /* src_mask */
333 0, /* dst_mask */
b34976b6 334 TRUE), /* pcrel_offset */
252b5132
RH		 335
336 /* Indicates a .uses pseudo-op. The compiler will generate .uses
337 pseudo-ops when it finds a function call which can be relaxed.
338 The offset field holds the PC relative offset to the instruction
339 which loads the register used in the function call. */
340 HOWTO (R_SH_USES, /* type */
341 0, /* rightshift */
342 1, /* size (0 = byte, 1 = short, 2 = long) */
343 0, /* bitsize */
b34976b6 344 FALSE, /* pc_relative */
252b5132
RH		 345 0, /* bitpos */
346 complain_overflow_unsigned, /* complain_on_overflow */
347 sh_elf_ignore_reloc, /* special_function */
348 "R_SH_USES", /* name */
b34976b6 349 FALSE, /* partial_inplace */
252b5132
RH		 350 0, /* src_mask */
351 0, /* dst_mask */
b34976b6 352 TRUE), /* pcrel_offset */
252b5132
RH		 353
354 /* The assembler will generate this reloc for addresses referred to
355 by the register loads associated with USES relocs. The offset
356 field holds the number of times the address is referenced in the
357 object file. */
358 HOWTO (R_SH_COUNT, /* type */
359 0, /* rightshift */
360 1, /* size (0 = byte, 1 = short, 2 = long) */
361 0, /* bitsize */
b34976b6 362 FALSE, /* pc_relative */
252b5132
RH		 363 0, /* bitpos */
364 complain_overflow_unsigned, /* complain_on_overflow */
365 sh_elf_ignore_reloc, /* special_function */
366 "R_SH_COUNT", /* name */
b34976b6 367 FALSE, /* partial_inplace */
252b5132
RH		 368 0, /* src_mask */
369 0, /* dst_mask */
b34976b6 370 TRUE), /* pcrel_offset */
252b5132
RH		 371
372 /* Indicates an alignment statement. The offset field is the power
373 of 2 to which subsequent portions of the object file must be
374 aligned. */
375 HOWTO (R_SH_ALIGN, /* type */
376 0, /* rightshift */
377 1, /* size (0 = byte, 1 = short, 2 = long) */
378 0, /* bitsize */
b34976b6 379 FALSE, /* pc_relative */
252b5132
RH		 380 0, /* bitpos */
381 complain_overflow_unsigned, /* complain_on_overflow */
382 sh_elf_ignore_reloc, /* special_function */
383 "R_SH_ALIGN", /* name */
b34976b6 384 FALSE, /* partial_inplace */
252b5132
RH		 385 0, /* src_mask */
386 0, /* dst_mask */
b34976b6 387 TRUE), /* pcrel_offset */
252b5132
RH		 388
389 /* The assembler will generate this reloc before a block of
390 instructions. A section should be processed as assumining it
391 contains data, unless this reloc is seen. */
392 HOWTO (R_SH_CODE, /* type */
393 0, /* rightshift */
394 1, /* size (0 = byte, 1 = short, 2 = long) */
395 0, /* bitsize */
b34976b6 396 FALSE, /* pc_relative */
252b5132
RH		 397 0, /* bitpos */
398 complain_overflow_unsigned, /* complain_on_overflow */
399 sh_elf_ignore_reloc, /* special_function */
400 "R_SH_CODE", /* name */
b34976b6 401 FALSE, /* partial_inplace */
252b5132
RH		 402 0, /* src_mask */
403 0, /* dst_mask */
b34976b6 404 TRUE), /* pcrel_offset */
252b5132
RH		 405
406 /* The assembler will generate this reloc after a block of
407 instructions when it sees data that is not instructions. */
408 HOWTO (R_SH_DATA, /* type */
409 0, /* rightshift */
410 1, /* size (0 = byte, 1 = short, 2 = long) */
411 0, /* bitsize */
b34976b6 412 FALSE, /* pc_relative */
252b5132
RH		 413 0, /* bitpos */
414 complain_overflow_unsigned, /* complain_on_overflow */
415 sh_elf_ignore_reloc, /* special_function */
416 "R_SH_DATA", /* name */
b34976b6 417 FALSE, /* partial_inplace */
252b5132
RH		 418 0, /* src_mask */
419 0, /* dst_mask */
b34976b6 420 TRUE), /* pcrel_offset */
252b5132
RH		 421
422 /* The assembler generates this reloc for each label within a block
423 of instructions. This permits the linker to avoid swapping
424 instructions which are the targets of branches. */
425 HOWTO (R_SH_LABEL, /* type */
426 0, /* rightshift */
427 1, /* size (0 = byte, 1 = short, 2 = long) */
428 0, /* bitsize */
b34976b6 429 FALSE, /* pc_relative */
252b5132
RH		 430 0, /* bitpos */
431 complain_overflow_unsigned, /* complain_on_overflow */
432 sh_elf_ignore_reloc, /* special_function */
433 "R_SH_LABEL", /* name */
b34976b6 434 FALSE, /* partial_inplace */
252b5132
RH		 435 0, /* src_mask */
436 0, /* dst_mask */
b34976b6 437 TRUE), /* pcrel_offset */
252b5132
RH		 438
439 /* An 8 bit switch table entry. This is generated for an expression
440 such as ``.word L1 - L2''. The offset holds the difference
441 between the reloc address and L2. */
442 HOWTO (R_SH_SWITCH8, /* type */
443 0, /* rightshift */
444 0, /* size (0 = byte, 1 = short, 2 = long) */
445 8, /* bitsize */
b34976b6 446 FALSE, /* pc_relative */
252b5132
RH		 447 0, /* bitpos */
448 complain_overflow_unsigned, /* complain_on_overflow */
449 sh_elf_ignore_reloc, /* special_function */
450 "R_SH_SWITCH8", /* name */
b34976b6 451 FALSE, /* partial_inplace */
252b5132
RH		 452 0, /* src_mask */
453 0, /* dst_mask */
b34976b6 454 TRUE), /* pcrel_offset */
252b5132
RH		 455
456 /* GNU extension to record C++ vtable hierarchy */
457 HOWTO (R_SH_GNU_VTINHERIT, /* type */
067653c5
AM		 458 0, /* rightshift */
459 2, /* size (0 = byte, 1 = short, 2 = long) */
460 0, /* bitsize */
b34976b6 461 FALSE, /* pc_relative */
067653c5
AM		 462 0, /* bitpos */
463 complain_overflow_dont, /* complain_on_overflow */
464 NULL, /* special_function */
465 "R_SH_GNU_VTINHERIT", /* name */
b34976b6 466 FALSE, /* partial_inplace */
067653c5
AM		 467 0, /* src_mask */
468 0, /* dst_mask */
b34976b6 469 FALSE), /* pcrel_offset */
252b5132
RH		 470
471 /* GNU extension to record C++ vtable member usage */
472 HOWTO (R_SH_GNU_VTENTRY, /* type */
067653c5
AM		 473 0, /* rightshift */
474 2, /* size (0 = byte, 1 = short, 2 = long) */
475 0, /* bitsize */
b34976b6 476 FALSE, /* pc_relative */
067653c5
AM		 477 0, /* bitpos */
478 complain_overflow_dont, /* complain_on_overflow */
479 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
480 "R_SH_GNU_VTENTRY", /* name */
b34976b6 481 FALSE, /* partial_inplace */
067653c5
AM		 482 0, /* src_mask */
483 0, /* dst_mask */
b34976b6 484 FALSE), /* pcrel_offset */
252b5132 485
015551fc
JR		 486 /* 8 bit PC relative divided by 2 - but specified in a very odd way. */
487 HOWTO (R_SH_LOOP_START, /* type */
488 1, /* rightshift */
489 1, /* size (0 = byte, 1 = short, 2 = long) */
490 8, /* bitsize */
b34976b6 491 FALSE, /* pc_relative */
015551fc
JR		 492 0, /* bitpos */
493 complain_overflow_signed, /* complain_on_overflow */
494 sh_elf_ignore_reloc, /* special_function */
495 "R_SH_LOOP_START", /* name */
b34976b6 496 TRUE, /* partial_inplace */
015551fc
JR		 497 0xff, /* src_mask */
498 0xff, /* dst_mask */
b34976b6 499 TRUE), /* pcrel_offset */
015551fc
JR		 500
501 /* 8 bit PC relative divided by 2 - but specified in a very odd way. */
502 HOWTO (R_SH_LOOP_END, /* type */
503 1, /* rightshift */
504 1, /* size (0 = byte, 1 = short, 2 = long) */
505 8, /* bitsize */
b34976b6 506 FALSE, /* pc_relative */
015551fc
JR		 507 0, /* bitpos */
508 complain_overflow_signed, /* complain_on_overflow */
509 sh_elf_ignore_reloc, /* special_function */
510 "R_SH_LOOP_END", /* name */
b34976b6 511 TRUE, /* partial_inplace */
015551fc
JR		 512 0xff, /* src_mask */
513 0xff, /* dst_mask */
b34976b6 514 TRUE), /* pcrel_offset */
015551fc 515
06bb75c1
AO		 516 EMPTY_HOWTO (38),
517 EMPTY_HOWTO (39),
518 EMPTY_HOWTO (40),
519 EMPTY_HOWTO (41),
520 EMPTY_HOWTO (42),
521 EMPTY_HOWTO (43),
522 EMPTY_HOWTO (44),
fbca6ad9
AO		 523
524#ifdef INCLUDE_SHMEDIA
525 /* Used in SHLLI.L and SHLRI.L. */
526 HOWTO (R_SH_DIR5U, /* type */
527 0, /* rightshift */
528 2, /* size (0 = byte, 1 = short, 2 = long) */
529 5, /* bitsize */
b34976b6 530 FALSE, /* pc_relative */
fbca6ad9
AO		 531 10, /* bitpos */
532 complain_overflow_unsigned, /* complain_on_overflow */
533 bfd_elf_generic_reloc, /* special_function */
534 "R_SH_DIR5U", /* name */
b34976b6 535 FALSE, /* partial_inplace */
fbca6ad9
AO		 536 0, /* src_mask */
537 0xfc00, /* dst_mask */
b34976b6 538 FALSE), /* pcrel_offset */
fbca6ad9
AO		 539
540 /* Used in SHARI, SHLLI et al. */
541 HOWTO (R_SH_DIR6U, /* type */
542 0, /* rightshift */
543 2, /* size (0 = byte, 1 = short, 2 = long) */
544 6, /* bitsize */
b34976b6 545 FALSE, /* pc_relative */
fbca6ad9
AO		 546 10, /* bitpos */
547 complain_overflow_unsigned, /* complain_on_overflow */
548 bfd_elf_generic_reloc, /* special_function */
549 "R_SH_DIR6U", /* name */
b34976b6 550 FALSE, /* partial_inplace */
fbca6ad9
AO		 551 0, /* src_mask */
552 0xfc00, /* dst_mask */
b34976b6 553 FALSE), /* pcrel_offset */
fbca6ad9
AO		 554
555 /* Used in BxxI, LDHI.L et al. */
556 HOWTO (R_SH_DIR6S, /* type */
557 0, /* rightshift */
558 2, /* size (0 = byte, 1 = short, 2 = long) */
559 6, /* bitsize */
b34976b6 560 FALSE, /* pc_relative */
fbca6ad9
AO		 561 10, /* bitpos */
562 complain_overflow_signed, /* complain_on_overflow */
563 bfd_elf_generic_reloc, /* special_function */
564 "R_SH_DIR6S", /* name */
b34976b6 565 FALSE, /* partial_inplace */
fbca6ad9
AO		 566 0, /* src_mask */
567 0xfc00, /* dst_mask */
b34976b6 568 FALSE), /* pcrel_offset */
fbca6ad9
AO		 569
570 /* Used in ADDI, ANDI et al. */
571 HOWTO (R_SH_DIR10S, /* type */
572 0, /* rightshift */
573 2, /* size (0 = byte, 1 = short, 2 = long) */
574 10, /* bitsize */
b34976b6 575 FALSE, /* pc_relative */
fbca6ad9
AO		 576 10, /* bitpos */
577 complain_overflow_signed, /* complain_on_overflow */
578 bfd_elf_generic_reloc, /* special_function */
579 "R_SH_DIR10S", /* name */
b34976b6 580 FALSE, /* partial_inplace */
fbca6ad9
AO		 581 0, /* src_mask */
582 0xffc00, /* dst_mask */
b34976b6 583 FALSE), /* pcrel_offset */
fbca6ad9 584
067653c5 585 /* Used in LD.UW, ST.W et al. */
fbca6ad9
AO		 586 HOWTO (R_SH_DIR10SW, /* type */
587 1, /* rightshift */
588 2, /* size (0 = byte, 1 = short, 2 = long) */
589 11, /* bitsize */
b34976b6 590 FALSE, /* pc_relative */
fbca6ad9
AO		 591 10, /* bitpos */
592 complain_overflow_signed, /* complain_on_overflow */
593 bfd_elf_generic_reloc, /* special_function */
594 "R_SH_DIR10SW", /* name */
b34976b6 595 FALSE, /* partial_inplace */
fbca6ad9
AO		 596 0, /* src_mask */
597 0xffc00, /* dst_mask */
b34976b6 598 FALSE), /* pcrel_offset */
fbca6ad9 599
067653c5 600 /* Used in LD.L, FLD.S et al. */
fbca6ad9
AO		 601 HOWTO (R_SH_DIR10SL, /* type */
602 2, /* rightshift */
603 2, /* size (0 = byte, 1 = short, 2 = long) */
604 12, /* bitsize */
b34976b6 605 FALSE, /* pc_relative */
fbca6ad9
AO		 606 10, /* bitpos */
607 complain_overflow_signed, /* complain_on_overflow */
608 bfd_elf_generic_reloc, /* special_function */
609 "R_SH_DIR10SL", /* name */
b34976b6 610 FALSE, /* partial_inplace */
fbca6ad9
AO		 611 0, /* src_mask */
612 0xffc00, /* dst_mask */
b34976b6 613 FALSE), /* pcrel_offset */
fbca6ad9
AO		 614
615 /* Used in FLD.D, FST.P et al. */
616 HOWTO (R_SH_DIR10SQ, /* type */
617 3, /* rightshift */
618 2, /* size (0 = byte, 1 = short, 2 = long) */
619 13, /* bitsize */
b34976b6 620 FALSE, /* pc_relative */
fbca6ad9
AO		 621 10, /* bitpos */
622 complain_overflow_signed, /* complain_on_overflow */
623 bfd_elf_generic_reloc, /* special_function */
624 "R_SH_DIR10SQ", /* name */
b34976b6 625 FALSE, /* partial_inplace */
fbca6ad9
AO		 626 0, /* src_mask */
627 0xffc00, /* dst_mask */
b34976b6 628 FALSE), /* pcrel_offset */
fbca6ad9
AO		 629
630#else
06bb75c1
AO		 631 EMPTY_HOWTO (45),
632 EMPTY_HOWTO (46),
633 EMPTY_HOWTO (47),
634 EMPTY_HOWTO (48),
635 EMPTY_HOWTO (49),
636 EMPTY_HOWTO (50),
637 EMPTY_HOWTO (51),
fbca6ad9
AO		 638#endif
639
06bb75c1
AO		 640 EMPTY_HOWTO (52),
641 EMPTY_HOWTO (53),
642 EMPTY_HOWTO (54),
643 EMPTY_HOWTO (55),
644 EMPTY_HOWTO (56),
645 EMPTY_HOWTO (57),
646 EMPTY_HOWTO (58),
647 EMPTY_HOWTO (59),
648 EMPTY_HOWTO (60),
649 EMPTY_HOWTO (61),
650 EMPTY_HOWTO (62),
651 EMPTY_HOWTO (63),
652 EMPTY_HOWTO (64),
653 EMPTY_HOWTO (65),
654 EMPTY_HOWTO (66),
655 EMPTY_HOWTO (67),
656 EMPTY_HOWTO (68),
657 EMPTY_HOWTO (69),
658 EMPTY_HOWTO (70),
659 EMPTY_HOWTO (71),
660 EMPTY_HOWTO (72),
661 EMPTY_HOWTO (73),
662 EMPTY_HOWTO (74),
663 EMPTY_HOWTO (75),
664 EMPTY_HOWTO (76),
665 EMPTY_HOWTO (77),
666 EMPTY_HOWTO (78),
667 EMPTY_HOWTO (79),
668 EMPTY_HOWTO (80),
669 EMPTY_HOWTO (81),
670 EMPTY_HOWTO (82),
671 EMPTY_HOWTO (83),
672 EMPTY_HOWTO (84),
673 EMPTY_HOWTO (85),
674 EMPTY_HOWTO (86),
675 EMPTY_HOWTO (87),
676 EMPTY_HOWTO (88),
677 EMPTY_HOWTO (89),
678 EMPTY_HOWTO (90),
679 EMPTY_HOWTO (91),
680 EMPTY_HOWTO (92),
681 EMPTY_HOWTO (93),
682 EMPTY_HOWTO (94),
683 EMPTY_HOWTO (95),
684 EMPTY_HOWTO (96),
685 EMPTY_HOWTO (97),
686 EMPTY_HOWTO (98),
687 EMPTY_HOWTO (99),
688 EMPTY_HOWTO (100),
689 EMPTY_HOWTO (101),
690 EMPTY_HOWTO (102),
691 EMPTY_HOWTO (103),
692 EMPTY_HOWTO (104),
693 EMPTY_HOWTO (105),
694 EMPTY_HOWTO (106),
695 EMPTY_HOWTO (107),
696 EMPTY_HOWTO (108),
697 EMPTY_HOWTO (109),
698 EMPTY_HOWTO (110),
699 EMPTY_HOWTO (111),
700 EMPTY_HOWTO (112),
701 EMPTY_HOWTO (113),
702 EMPTY_HOWTO (114),
703 EMPTY_HOWTO (115),
704 EMPTY_HOWTO (116),
705 EMPTY_HOWTO (117),
706 EMPTY_HOWTO (118),
707 EMPTY_HOWTO (119),
708 EMPTY_HOWTO (120),
709 EMPTY_HOWTO (121),
710 EMPTY_HOWTO (122),
711 EMPTY_HOWTO (123),
712 EMPTY_HOWTO (124),
713 EMPTY_HOWTO (125),
714 EMPTY_HOWTO (126),
715 EMPTY_HOWTO (127),
716 EMPTY_HOWTO (128),
717 EMPTY_HOWTO (129),
718 EMPTY_HOWTO (130),
719 EMPTY_HOWTO (131),
720 EMPTY_HOWTO (132),
721 EMPTY_HOWTO (133),
722 EMPTY_HOWTO (134),
723 EMPTY_HOWTO (135),
724 EMPTY_HOWTO (136),
725 EMPTY_HOWTO (137),
726 EMPTY_HOWTO (138),
727 EMPTY_HOWTO (139),
728 EMPTY_HOWTO (140),
729 EMPTY_HOWTO (141),
730 EMPTY_HOWTO (142),
731 EMPTY_HOWTO (143),
3376eaf5
KK		 732
733 HOWTO (R_SH_TLS_GD_32, /* type */
734 0, /* rightshift */
735 2, /* size (0 = byte, 1 = short, 2 = long) */
736 32, /* bitsize */
b34976b6 737 FALSE, /* pc_relative */
3376eaf5
KK		 738 0, /* bitpos */
739 complain_overflow_bitfield, /* complain_on_overflow */
740 bfd_elf_generic_reloc, /* */
741 "R_SH_TLS_GD_32", /* name */
b34976b6 742 TRUE, /* partial_inplace */
3376eaf5
KK		 743 0xffffffff, /* src_mask */
744 0xffffffff, /* dst_mask */
b34976b6 745 FALSE), /* pcrel_offset */
3376eaf5
KK		 746
747 HOWTO (R_SH_TLS_LD_32, /* type */
748 0, /* rightshift */
749 2, /* size (0 = byte, 1 = short, 2 = long) */
750 32, /* bitsize */
b34976b6 751 FALSE, /* pc_relative */
3376eaf5
KK		 752 0, /* bitpos */
753 complain_overflow_bitfield, /* complain_on_overflow */
754 bfd_elf_generic_reloc, /* */
755 "R_SH_TLS_LD_32", /* name */
b34976b6 756 TRUE, /* partial_inplace */
3376eaf5
KK		 757 0xffffffff, /* src_mask */
758 0xffffffff, /* dst_mask */
b34976b6 759 FALSE), /* pcrel_offset */
3376eaf5
KK		 760
761 HOWTO (R_SH_TLS_LDO_32, /* type */
762 0, /* rightshift */
763 2, /* size (0 = byte, 1 = short, 2 = long) */
764 32, /* bitsize */
b34976b6 765 FALSE, /* pc_relative */
3376eaf5
KK		 766 0, /* bitpos */
767 complain_overflow_bitfield, /* complain_on_overflow */
768 bfd_elf_generic_reloc, /* */
769 "R_SH_TLS_LDO_32", /* name */
b34976b6 770 TRUE, /* partial_inplace */
3376eaf5
KK		 771 0xffffffff, /* src_mask */
772 0xffffffff, /* dst_mask */
b34976b6 773 FALSE), /* pcrel_offset */
3376eaf5
KK		 774
775 HOWTO (R_SH_TLS_IE_32, /* type */
776 0, /* rightshift */
777 2, /* size (0 = byte, 1 = short, 2 = long) */
778 32, /* bitsize */
b34976b6 779 FALSE, /* pc_relative */
3376eaf5
KK		 780 0, /* bitpos */
781 complain_overflow_bitfield, /* complain_on_overflow */
782 bfd_elf_generic_reloc, /* */
783 "R_SH_TLS_IE_32", /* name */
b34976b6 784 TRUE, /* partial_inplace */
3376eaf5
KK		 785 0xffffffff, /* src_mask */
786 0xffffffff, /* dst_mask */
b34976b6 787 FALSE), /* pcrel_offset */
3376eaf5
KK		 788
789 HOWTO (R_SH_TLS_LE_32, /* type */
790 0, /* rightshift */
791 2, /* size (0 = byte, 1 = short, 2 = long) */
792 32, /* bitsize */
b34976b6 793 FALSE, /* pc_relative */
3376eaf5
KK		 794 0, /* bitpos */
795 complain_overflow_bitfield, /* complain_on_overflow */
796 bfd_elf_generic_reloc, /* */
797 "R_SH_TLS_LE_32", /* name */
b34976b6 798 TRUE, /* partial_inplace */
3376eaf5
KK		 799 0xffffffff, /* src_mask */
800 0xffffffff, /* dst_mask */
b34976b6 801 FALSE), /* pcrel_offset */
3376eaf5
KK		 802
803 HOWTO (R_SH_TLS_DTPMOD32, /* type */
804 0, /* rightshift */
805 2, /* size (0 = byte, 1 = short, 2 = long) */
806 32, /* bitsize */
b34976b6 807 FALSE, /* pc_relative */
3376eaf5
KK		 808 0, /* bitpos */
809 complain_overflow_bitfield, /* complain_on_overflow */
810 bfd_elf_generic_reloc, /* */
811 "R_SH_TLS_DTPMOD32", /* name */
b34976b6 812 TRUE, /* partial_inplace */
3376eaf5
KK		 813 0xffffffff, /* src_mask */
814 0xffffffff, /* dst_mask */
b34976b6 815 FALSE), /* pcrel_offset */
3376eaf5
KK		 816
817 HOWTO (R_SH_TLS_DTPOFF32, /* type */
818 0, /* rightshift */
819 2, /* size (0 = byte, 1 = short, 2 = long) */
820 32, /* bitsize */
b34976b6 821 FALSE, /* pc_relative */
3376eaf5
KK		 822 0, /* bitpos */
823 complain_overflow_bitfield, /* complain_on_overflow */
824 bfd_elf_generic_reloc, /* */
825 "R_SH_TLS_DTPOFF32", /* name */
b34976b6 826 TRUE, /* partial_inplace */
3376eaf5
KK		 827 0xffffffff, /* src_mask */
828 0xffffffff, /* dst_mask */
b34976b6 829 FALSE), /* pcrel_offset */
3376eaf5
KK		 830
831 HOWTO (R_SH_TLS_TPOFF32, /* type */
832 0, /* rightshift */
833 2, /* size (0 = byte, 1 = short, 2 = long) */
834 32, /* bitsize */
b34976b6 835 FALSE, /* pc_relative */
3376eaf5
KK		 836 0, /* bitpos */
837 complain_overflow_bitfield, /* complain_on_overflow */
838 bfd_elf_generic_reloc, /* */
839 "R_SH_TLS_TPOFF32", /* name */
b34976b6 840 TRUE, /* partial_inplace */
3376eaf5
KK		 841 0xffffffff, /* src_mask */
842 0xffffffff, /* dst_mask */
b34976b6 843 FALSE), /* pcrel_offset */
3376eaf5 844
06bb75c1
AO		 845 EMPTY_HOWTO (152),
846 EMPTY_HOWTO (153),
847 EMPTY_HOWTO (154),
848 EMPTY_HOWTO (155),
849 EMPTY_HOWTO (156),
850 EMPTY_HOWTO (157),
851 EMPTY_HOWTO (158),
852 EMPTY_HOWTO (159),
853
854 HOWTO (R_SH_GOT32, /* type */
855 0, /* rightshift */
856 2, /* size (0 = byte, 1 = short, 2 = long) */
857 32, /* bitsize */
b34976b6 858 FALSE, /* pc_relative */
06bb75c1
AO		 859 0, /* bitpos */
860 complain_overflow_bitfield, /* complain_on_overflow */
861 bfd_elf_generic_reloc, /* */
862 "R_SH_GOT32", /* name */
b34976b6 863 TRUE, /* partial_inplace */
06bb75c1
AO		 864 0xffffffff, /* src_mask */
865 0xffffffff, /* dst_mask */
b34976b6 866 FALSE), /* pcrel_offset */
06bb75c1
AO		 867
868 HOWTO (R_SH_PLT32, /* type */
869 0, /* rightshift */
870 2, /* size (0 = byte, 1 = short, 2 = long) */
871 32, /* bitsize */
b34976b6 872 TRUE, /* pc_relative */
06bb75c1
AO		 873 0, /* bitpos */
874 complain_overflow_bitfield, /* complain_on_overflow */
875 bfd_elf_generic_reloc, /* */
876 "R_SH_PLT32", /* name */
b34976b6 877 TRUE, /* partial_inplace */
06bb75c1
AO		 878 0xffffffff, /* src_mask */
879 0xffffffff, /* dst_mask */
b34976b6 880 TRUE), /* pcrel_offset */
06bb75c1
AO		 881
882 HOWTO (R_SH_COPY, /* type */
883 0, /* rightshift */
884 2, /* size (0 = byte, 1 = short, 2 = long) */
885 32, /* bitsize */
b34976b6 886 FALSE, /* pc_relative */
06bb75c1
AO		 887 0, /* bitpos */
888 complain_overflow_bitfield, /* complain_on_overflow */
889 bfd_elf_generic_reloc, /* */
890 "R_SH_COPY", /* name */
b34976b6 891 TRUE, /* partial_inplace */
06bb75c1
AO		 892 0xffffffff, /* src_mask */
893 0xffffffff, /* dst_mask */
b34976b6 894 FALSE), /* pcrel_offset */
06bb75c1
AO		 895
896 HOWTO (R_SH_GLOB_DAT, /* type */
897 0, /* rightshift */
898 2, /* size (0 = byte, 1 = short, 2 = long) */
899 32, /* bitsize */
b34976b6 900 FALSE, /* pc_relative */
06bb75c1
AO		 901 0, /* bitpos */
902 complain_overflow_bitfield, /* complain_on_overflow */
903 bfd_elf_generic_reloc, /* */
904 "R_SH_GLOB_DAT", /* name */
b34976b6 905 TRUE, /* partial_inplace */
06bb75c1
AO		 906 0xffffffff, /* src_mask */
907 0xffffffff, /* dst_mask */
b34976b6 908 FALSE), /* pcrel_offset */
06bb75c1
AO		 909
910 HOWTO (R_SH_JMP_SLOT, /* type */
911 0, /* rightshift */
912 2, /* size (0 = byte, 1 = short, 2 = long) */
913 32, /* bitsize */
b34976b6 914 FALSE, /* pc_relative */
06bb75c1
AO		 915 0, /* bitpos */
916 complain_overflow_bitfield, /* complain_on_overflow */
917 bfd_elf_generic_reloc, /* */
918 "R_SH_JMP_SLOT", /* name */
b34976b6 919 TRUE, /* partial_inplace */
06bb75c1
AO		 920 0xffffffff, /* src_mask */
921 0xffffffff, /* dst_mask */
b34976b6 922 FALSE), /* pcrel_offset */
06bb75c1
AO		 923
924 HOWTO (R_SH_RELATIVE, /* type */
925 0, /* rightshift */
926 2, /* size (0 = byte, 1 = short, 2 = long) */
927 32, /* bitsize */
b34976b6 928 FALSE, /* pc_relative */
06bb75c1
AO		 929 0, /* bitpos */
930 complain_overflow_bitfield, /* complain_on_overflow */
931 bfd_elf_generic_reloc, /* */
932 "R_SH_RELATIVE", /* name */
b34976b6 933 TRUE, /* partial_inplace */
06bb75c1
AO		 934 0xffffffff, /* src_mask */
935 0xffffffff, /* dst_mask */
b34976b6 936 FALSE), /* pcrel_offset */
06bb75c1
AO		 937
938 HOWTO (R_SH_GOTOFF, /* type */
939 0, /* rightshift */
940 2, /* size (0 = byte, 1 = short, 2 = long) */
941 32, /* bitsize */
b34976b6 942 FALSE, /* pc_relative */
06bb75c1
AO		 943 0, /* bitpos */
944 complain_overflow_bitfield, /* complain_on_overflow */
945 bfd_elf_generic_reloc, /* */
946 "R_SH_GOTOFF", /* name */
b34976b6 947 TRUE, /* partial_inplace */
06bb75c1
AO		 948 0xffffffff, /* src_mask */
949 0xffffffff, /* dst_mask */
b34976b6 950 FALSE), /* pcrel_offset */
06bb75c1
AO		 951
952 HOWTO (R_SH_GOTPC, /* type */
953 0, /* rightshift */
954 2, /* size (0 = byte, 1 = short, 2 = long) */
955 32, /* bitsize */
b34976b6 956 TRUE, /* pc_relative */
06bb75c1
AO		 957 0, /* bitpos */
958 complain_overflow_bitfield, /* complain_on_overflow */
959 bfd_elf_generic_reloc, /* */
960 "R_SH_GOTPC", /* name */
b34976b6 961 TRUE, /* partial_inplace */
06bb75c1
AO		 962 0xffffffff, /* src_mask */
963 0xffffffff, /* dst_mask */
b34976b6 964 TRUE), /* pcrel_offset */
06bb75c1 965
fbca6ad9
AO		 966 HOWTO (R_SH_GOTPLT32, /* type */
967 0, /* rightshift */
968 2, /* size (0 = byte, 1 = short, 2 = long) */
969 32, /* bitsize */
b34976b6 970 FALSE, /* pc_relative */
fbca6ad9
AO		 971 0, /* bitpos */
972 complain_overflow_bitfield, /* complain_on_overflow */
973 bfd_elf_generic_reloc, /* */
974 "R_SH_GOTPLT32", /* name */
b34976b6 975 FALSE, /* partial_inplace */
fbca6ad9
AO		 976 0xffffffff, /* src_mask */
977 0xffffffff, /* dst_mask */
b34976b6 978 FALSE), /* pcrel_offset */
fbca6ad9
AO		 979
980#ifdef INCLUDE_SHMEDIA
981 /* Used in MOVI and SHORI (x & 65536). */
982 HOWTO (R_SH_GOT_LOW16, /* type */
983 0, /* rightshift */
984 2, /* size (0 = byte, 1 = short, 2 = long) */
985 64, /* bitsize */
b34976b6 986 FALSE, /* pc_relative */
fbca6ad9
AO		 987 10, /* bitpos */
988 complain_overflow_dont, /* complain_on_overflow */
989 bfd_elf_generic_reloc, /* special_function */
067653c5 990 "R_SH_GOT_LOW16", /* name */
b34976b6 991 FALSE, /* partial_inplace */
fbca6ad9
AO		 992 0, /* src_mask */
993 0x3fffc00, /* dst_mask */
b34976b6 994 FALSE), /* pcrel_offset */
fbca6ad9
AO		 995
996 /* Used in MOVI and SHORI ((x >> 16) & 65536). */
997 HOWTO (R_SH_GOT_MEDLOW16, /* type */
998 16, /* rightshift */
999 2, /* size (0 = byte, 1 = short, 2 = long) */
1000 64, /* bitsize */
b34976b6 1001 FALSE, /* pc_relative */
fbca6ad9
AO		 1002 10, /* bitpos */
1003 complain_overflow_dont, /* complain_on_overflow */
1004 bfd_elf_generic_reloc, /* special_function */
1005 "R_SH_GOT_MEDLOW16", /* name */
b34976b6 1006 FALSE, /* partial_inplace */
fbca6ad9
AO		 1007 0, /* src_mask */
1008 0x3fffc00, /* dst_mask */
b34976b6 1009 FALSE), /* pcrel_offset */
fbca6ad9
AO		 1010
1011 /* Used in MOVI and SHORI ((x >> 32) & 65536). */
1012 HOWTO (R_SH_GOT_MEDHI16, /* type */
1013 32, /* rightshift */
1014 2, /* size (0 = byte, 1 = short, 2 = long) */
1015 64, /* bitsize */
b34976b6 1016 FALSE, /* pc_relative */
fbca6ad9
AO		 1017 10, /* bitpos */
1018 complain_overflow_dont, /* complain_on_overflow */
1019 bfd_elf_generic_reloc, /* special_function */
1020 "R_SH_GOT_MEDHI16", /* name */
b34976b6 1021 FALSE, /* partial_inplace */
fbca6ad9
AO		 1022 0, /* src_mask */
1023 0x3fffc00, /* dst_mask */
b34976b6 1024 FALSE), /* pcrel_offset */
fbca6ad9
AO		 1025
1026 /* Used in MOVI and SHORI ((x >> 48) & 65536). */
1027 HOWTO (R_SH_GOT_HI16, /* type */
1028 48, /* rightshift */
1029 2, /* size (0 = byte, 1 = short, 2 = long) */
1030 64, /* bitsize */
b34976b6 1031 FALSE, /* pc_relative */
fbca6ad9
AO		 1032 10, /* bitpos */
1033 complain_overflow_dont, /* complain_on_overflow */
1034 bfd_elf_generic_reloc, /* special_function */
1035 "R_SH_GOT_HI16", /* name */
b34976b6 1036 FALSE, /* partial_inplace */
fbca6ad9
AO		 1037 0, /* src_mask */
1038 0x3fffc00, /* dst_mask */
b34976b6 1039 FALSE), /* pcrel_offset */
fbca6ad9
AO		 1040
1041 /* Used in MOVI and SHORI (x & 65536). */
1042 HOWTO (R_SH_GOTPLT_LOW16, /* type */
1043 0, /* rightshift */
1044 2, /* size (0 = byte, 1 = short, 2 = long) */
1045 64, /* bitsize */
b34976b6 1046 FALSE, /* pc_relative */
fbca6ad9
AO		 1047 10, /* bitpos */
1048 complain_overflow_dont, /* complain_on_overflow */
1049 bfd_elf_generic_reloc, /* special_function */
067653c5 1050 "R_SH_GOTPLT_LOW16", /* name */
b34976b6 1051 FALSE, /* partial_inplace */
fbca6ad9
AO		 1052 0, /* src_mask */
1053 0x3fffc00, /* dst_mask */
b34976b6 1054 FALSE), /* pcrel_offset */
fbca6ad9
AO		 1055
1056 /* Used in MOVI and SHORI ((x >> 16) & 65536). */
1057 HOWTO (R_SH_GOTPLT_MEDLOW16, /* type */
1058 16, /* rightshift */
1059 2, /* size (0 = byte, 1 = short, 2 = long) */
1060 64, /* bitsize */
b34976b6 1061 FALSE, /* pc_relative */
fbca6ad9
AO		 1062 10, /* bitpos */
1063 complain_overflow_dont, /* complain_on_overflow */
1064 bfd_elf_generic_reloc, /* special_function */
1065 "R_SH_GOTPLT_MEDLOW16", /* name */
b34976b6 1066 FALSE, /* partial_inplace */
fbca6ad9
AO		 1067 0, /* src_mask */
1068 0x3fffc00, /* dst_mask */
b34976b6 1069 FALSE), /* pcrel_offset */
fbca6ad9
AO		 1070
1071 /* Used in MOVI and SHORI ((x >> 32) & 65536). */
1072 HOWTO (R_SH_GOTPLT_MEDHI16, /* type */
1073 32, /* rightshift */
1074 2, /* size (0 = byte, 1 = short, 2 = long) */
1075 64, /* bitsize */
b34976b6 1076 FALSE, /* pc_relative */
fbca6ad9
AO		 1077 10, /* bitpos */
1078 complain_overflow_dont, /* complain_on_overflow */
1079 bfd_elf_generic_reloc, /* special_function */
1080 "R_SH_GOTPLT_MEDHI16", /* name */
b34976b6 1081 FALSE, /* partial_inplace */
fbca6ad9
AO		 1082 0, /* src_mask */
1083 0x3fffc00, /* dst_mask */
b34976b6 1084 FALSE), /* pcrel_offset */
fbca6ad9
AO		 1085
1086 /* Used in MOVI and SHORI ((x >> 48) & 65536). */
1087 HOWTO (R_SH_GOTPLT_HI16, /* type */
1088 48, /* rightshift */
1089 2, /* size (0 = byte, 1 = short, 2 = long) */
1090 64, /* bitsize */
b34976b6 1091 FALSE, /* pc_relative */
fbca6ad9
AO		 1092 10, /* bitpos */
1093 complain_overflow_dont, /* complain_on_overflow */
1094 bfd_elf_generic_reloc, /* special_function */
1095 "R_SH_GOTPLT_HI16", /* name */
b34976b6 1096 FALSE, /* partial_inplace */
fbca6ad9
AO		 1097 0, /* src_mask */
1098 0x3fffc00, /* dst_mask */
b34976b6 1099 FALSE), /* pcrel_offset */
fbca6ad9
AO		 1100
1101 /* Used in MOVI and SHORI (x & 65536). */
1102 HOWTO (R_SH_PLT_LOW16, /* type */
1103 0, /* rightshift */
1104 2, /* size (0 = byte, 1 = short, 2 = long) */
1105 64, /* bitsize */
b34976b6 1106 TRUE, /* pc_relative */
fbca6ad9
AO		 1107 10, /* bitpos */
1108 complain_overflow_dont, /* complain_on_overflow */
1109 bfd_elf_generic_reloc, /* special_function */
067653c5 1110 "R_SH_PLT_LOW16", /* name */
b34976b6 1111 FALSE, /* partial_inplace */
fbca6ad9
AO		 1112 0, /* src_mask */
1113 0x3fffc00, /* dst_mask */
b34976b6 1114 TRUE), /* pcrel_offset */
fbca6ad9
AO		 1115
1116 /* Used in MOVI and SHORI ((x >> 16) & 65536). */
1117 HOWTO (R_SH_PLT_MEDLOW16, /* type */
1118 16, /* rightshift */
1119 2, /* size (0 = byte, 1 = short, 2 = long) */
1120 64, /* bitsize */
b34976b6 1121 TRUE, /* pc_relative */
fbca6ad9
AO		 1122 10, /* bitpos */
1123 complain_overflow_dont, /* complain_on_overflow */
1124 bfd_elf_generic_reloc, /* special_function */
1125 "R_SH_PLT_MEDLOW16", /* name */
b34976b6 1126 FALSE, /* partial_inplace */
fbca6ad9
AO		 1127 0, /* src_mask */
1128 0x3fffc00, /* dst_mask */
b34976b6 1129 TRUE), /* pcrel_offset */
fbca6ad9
AO		 1130
1131 /* Used in MOVI and SHORI ((x >> 32) & 65536). */
1132 HOWTO (R_SH_PLT_MEDHI16, /* type */
1133 32, /* rightshift */
1134 2, /* size (0 = byte, 1 = short, 2 = long) */
1135 64, /* bitsize */
b34976b6 1136 TRUE, /* pc_relative */
fbca6ad9
AO		 1137 10, /* bitpos */
1138 complain_overflow_dont, /* complain_on_overflow */
1139 bfd_elf_generic_reloc, /* special_function */
1140 "R_SH_PLT_MEDHI16", /* name */
b34976b6 1141 FALSE, /* partial_inplace */
fbca6ad9
AO		 1142 0, /* src_mask */
1143 0x3fffc00, /* dst_mask */
b34976b6 1144 TRUE), /* pcrel_offset */
fbca6ad9
AO		 1145
1146 /* Used in MOVI and SHORI ((x >> 48) & 65536). */
1147 HOWTO (R_SH_PLT_HI16, /* type */
1148 48, /* rightshift */
1149 2, /* size (0 = byte, 1 = short, 2 = long) */
1150 64, /* bitsize */
b34976b6 1151 TRUE, /* pc_relative */
fbca6ad9
AO		 1152 10, /* bitpos */
1153 complain_overflow_dont, /* complain_on_overflow */
1154 bfd_elf_generic_reloc, /* special_function */
1155 "R_SH_PLT_HI16", /* name */
b34976b6 1156 FALSE, /* partial_inplace */
fbca6ad9
AO		 1157 0, /* src_mask */
1158 0x3fffc00, /* dst_mask */
b34976b6 1159 TRUE), /* pcrel_offset */
fbca6ad9
AO		 1160
1161 /* Used in MOVI and SHORI (x & 65536). */
1162 HOWTO (R_SH_GOTOFF_LOW16, /* type */
1163 0, /* rightshift */
1164 2, /* size (0 = byte, 1 = short, 2 = long) */
1165 64, /* bitsize */
b34976b6 1166 FALSE, /* pc_relative */
fbca6ad9
AO		 1167 10, /* bitpos */
1168 complain_overflow_dont, /* complain_on_overflow */
1169 bfd_elf_generic_reloc, /* special_function */
067653c5 1170 "R_SH_GOTOFF_LOW16", /* name */
b34976b6 1171 FALSE, /* partial_inplace */
fbca6ad9
AO		 1172 0, /* src_mask */
1173 0x3fffc00, /* dst_mask */
b34976b6 1174 FALSE), /* pcrel_offset */
fbca6ad9
AO		 1175
1176 /* Used in MOVI and SHORI ((x >> 16) & 65536). */
1177 HOWTO (R_SH_GOTOFF_MEDLOW16, /* type */
1178 16, /* rightshift */
1179 2, /* size (0 = byte, 1 = short, 2 = long) */
1180 64, /* bitsize */
b34976b6 1181 FALSE, /* pc_relative */
fbca6ad9
AO		 1182 10, /* bitpos */
1183 complain_overflow_dont, /* complain_on_overflow */
1184 bfd_elf_generic_reloc, /* special_function */
1185 "R_SH_GOTOFF_MEDLOW16", /* name */
b34976b6 1186 FALSE, /* partial_inplace */
fbca6ad9
AO		 1187 0, /* src_mask */
1188 0x3fffc00, /* dst_mask */
b34976b6 1189 FALSE), /* pcrel_offset */
fbca6ad9
AO		 1190
1191 /* Used in MOVI and SHORI ((x >> 32) & 65536). */
1192 HOWTO (R_SH_GOTOFF_MEDHI16, /* type */
1193 32, /* rightshift */
1194 2, /* size (0 = byte, 1 = short, 2 = long) */
1195 64, /* bitsize */
b34976b6 1196 FALSE, /* pc_relative */
fbca6ad9
AO		 1197 10, /* bitpos */
1198 complain_overflow_dont, /* complain_on_overflow */
1199 bfd_elf_generic_reloc, /* special_function */
1200 "R_SH_GOTOFF_MEDHI16", /* name */
b34976b6 1201 FALSE, /* partial_inplace */
fbca6ad9
AO		 1202 0, /* src_mask */
1203 0x3fffc00, /* dst_mask */
b34976b6 1204 FALSE), /* pcrel_offset */
fbca6ad9
AO		 1205
1206 /* Used in MOVI and SHORI ((x >> 48) & 65536). */
1207 HOWTO (R_SH_GOTOFF_HI16, /* type */
1208 48, /* rightshift */
1209 2, /* size (0 = byte, 1 = short, 2 = long) */
1210 64, /* bitsize */
b34976b6 1211 FALSE, /* pc_relative */
fbca6ad9
AO		 1212 10, /* bitpos */
1213 complain_overflow_dont, /* complain_on_overflow */
1214 bfd_elf_generic_reloc, /* special_function */
1215 "R_SH_GOTOFF_HI16", /* name */
b34976b6 1216 FALSE, /* partial_inplace */
fbca6ad9
AO		 1217 0, /* src_mask */
1218 0x3fffc00, /* dst_mask */
b34976b6 1219 FALSE), /* pcrel_offset */
fbca6ad9
AO		 1220
1221 /* Used in MOVI and SHORI (x & 65536). */
1222 HOWTO (R_SH_GOTPC_LOW16, /* type */
1223 0, /* rightshift */
1224 2, /* size (0 = byte, 1 = short, 2 = long) */
1225 64, /* bitsize */
b34976b6 1226 TRUE, /* pc_relative */
fbca6ad9
AO		 1227 10, /* bitpos */
1228 complain_overflow_dont, /* complain_on_overflow */
1229 bfd_elf_generic_reloc, /* special_function */
067653c5 1230 "R_SH_GOTPC_LOW16", /* name */
b34976b6 1231 FALSE, /* partial_inplace */
fbca6ad9
AO		 1232 0, /* src_mask */
1233 0x3fffc00, /* dst_mask */
b34976b6 1234 TRUE), /* pcrel_offset */
fbca6ad9
AO		 1235
1236 /* Used in MOVI and SHORI ((x >> 16) & 65536). */
1237 HOWTO (R_SH_GOTPC_MEDLOW16, /* type */
1238 16, /* rightshift */
1239 2, /* size (0 = byte, 1 = short, 2 = long) */
1240 64, /* bitsize */
b34976b6 1241 TRUE, /* pc_relative */
fbca6ad9
AO		 1242 10, /* bitpos */
1243 complain_overflow_dont, /* complain_on_overflow */
1244 bfd_elf_generic_reloc, /* special_function */
1245 "R_SH_GOTPC_MEDLOW16", /* name */
b34976b6 1246 FALSE, /* partial_inplace */
fbca6ad9
AO		 1247 0, /* src_mask */
1248 0x3fffc00, /* dst_mask */
b34976b6 1249 TRUE), /* pcrel_offset */
fbca6ad9
AO		 1250
1251 /* Used in MOVI and SHORI ((x >> 32) & 65536). */
1252 HOWTO (R_SH_GOTPC_MEDHI16, /* type */
1253 32, /* rightshift */
1254 2, /* size (0 = byte, 1 = short, 2 = long) */
1255 64, /* bitsize */
b34976b6 1256 TRUE, /* pc_relative */
fbca6ad9
AO		 1257 10, /* bitpos */
1258 complain_overflow_dont, /* complain_on_overflow */
1259 bfd_elf_generic_reloc, /* special_function */
1260 "R_SH_GOTPC_MEDHI16", /* name */
b34976b6 1261 FALSE, /* partial_inplace */
fbca6ad9
AO		 1262 0, /* src_mask */
1263 0x3fffc00, /* dst_mask */
b34976b6 1264 TRUE), /* pcrel_offset */
fbca6ad9
AO		 1265
1266 /* Used in MOVI and SHORI ((x >> 48) & 65536). */
1267 HOWTO (R_SH_GOTPC_HI16, /* type */
1268 48, /* rightshift */
1269 2, /* size (0 = byte, 1 = short, 2 = long) */
1270 64, /* bitsize */
b34976b6 1271 TRUE, /* pc_relative */
fbca6ad9
AO		 1272 10, /* bitpos */
1273 complain_overflow_dont, /* complain_on_overflow */
1274 bfd_elf_generic_reloc, /* special_function */
1275 "R_SH_GOTPC_HI16", /* name */
b34976b6 1276 FALSE, /* partial_inplace */
fbca6ad9
AO		 1277 0, /* src_mask */
1278 0x3fffc00, /* dst_mask */
b34976b6 1279 TRUE), /* pcrel_offset */
fbca6ad9 1280
067653c5 1281 /* Used in LD.L, FLD.S et al. */
fbca6ad9
AO		 1282 HOWTO (R_SH_GOT10BY4, /* type */
1283 2, /* rightshift */
1284 2, /* size (0 = byte, 1 = short, 2 = long) */
1285 12, /* bitsize */
b34976b6 1286 FALSE, /* pc_relative */
fbca6ad9
AO		 1287 10, /* bitpos */
1288 complain_overflow_signed, /* complain_on_overflow */
1289 bfd_elf_generic_reloc, /* special_function */
1290 "R_SH_GOT10BY4", /* name */
b34976b6 1291 FALSE, /* partial_inplace */
fbca6ad9
AO		 1292 0, /* src_mask */
1293 0xffc00, /* dst_mask */
b34976b6 1294 FALSE), /* pcrel_offset */
fbca6ad9 1295
067653c5 1296 /* Used in LD.L, FLD.S et al. */
fbca6ad9
AO		 1297 HOWTO (R_SH_GOTPLT10BY4, /* type */
1298 2, /* rightshift */
1299 2, /* size (0 = byte, 1 = short, 2 = long) */
1300 12, /* bitsize */
b34976b6 1301 FALSE, /* pc_relative */
fbca6ad9
AO		 1302 10, /* bitpos */
1303 complain_overflow_signed, /* complain_on_overflow */
1304 bfd_elf_generic_reloc, /* special_function */
1305 "R_SH_GOTPLT10BY4", /* name */
b34976b6 1306 FALSE, /* partial_inplace */
fbca6ad9
AO		 1307 0, /* src_mask */
1308 0xffc00, /* dst_mask */
b34976b6 1309 FALSE), /* pcrel_offset */
fbca6ad9
AO		 1310
1311 /* Used in FLD.D, FST.P et al. */
1312 HOWTO (R_SH_GOT10BY8, /* type */
1313 3, /* rightshift */
1314 2, /* size (0 = byte, 1 = short, 2 = long) */
1315 13, /* bitsize */
b34976b6 1316 FALSE, /* pc_relative */
fbca6ad9
AO		 1317 10, /* bitpos */
1318 complain_overflow_signed, /* complain_on_overflow */
1319 bfd_elf_generic_reloc, /* special_function */
1320 "R_SH_GOT10BY8", /* name */
b34976b6 1321 FALSE, /* partial_inplace */
fbca6ad9
AO		 1322 0, /* src_mask */
1323 0xffc00, /* dst_mask */
b34976b6 1324 FALSE), /* pcrel_offset */
fbca6ad9
AO		 1325
1326 /* Used in FLD.D, FST.P et al. */
1327 HOWTO (R_SH_GOTPLT10BY8, /* type */
1328 3, /* rightshift */
1329 2, /* size (0 = byte, 1 = short, 2 = long) */
1330 13, /* bitsize */
b34976b6 1331 FALSE, /* pc_relative */
fbca6ad9
AO		 1332 10, /* bitpos */
1333 complain_overflow_signed, /* complain_on_overflow */
1334 bfd_elf_generic_reloc, /* special_function */
1335 "R_SH_GOTPLT10BY8", /* name */
b34976b6 1336 FALSE, /* partial_inplace */
fbca6ad9
AO		 1337 0, /* src_mask */
1338 0xffc00, /* dst_mask */
b34976b6 1339 FALSE), /* pcrel_offset */
fbca6ad9
AO		 1340
1341 HOWTO (R_SH_COPY64, /* type */
1342 0, /* rightshift */
1343 4, /* size (0 = byte, 1 = short, 2 = long) */
1344 64, /* bitsize */
b34976b6 1345 FALSE, /* pc_relative */
fbca6ad9
AO		 1346 0, /* bitpos */
1347 complain_overflow_dont, /* complain_on_overflow */
1348 bfd_elf_generic_reloc, /* special_function */
067653c5 1349 "R_SH_COPY64", /* name */
b34976b6 1350 FALSE, /* partial_inplace */
fbca6ad9
AO		 1351 0, /* src_mask */
1352 ((bfd_vma) 0) - 1, /* dst_mask */
b34976b6 1353 FALSE), /* pcrel_offset */
fbca6ad9
AO		 1354
1355 HOWTO (R_SH_GLOB_DAT64, /* type */
1356 0, /* rightshift */
1357 4, /* size (0 = byte, 1 = short, 2 = long) */
1358 64, /* bitsize */
b34976b6 1359 FALSE, /* pc_relative */
fbca6ad9
AO		 1360 0, /* bitpos */
1361 complain_overflow_dont, /* complain_on_overflow */
1362 bfd_elf_generic_reloc, /* special_function */
067653c5 1363 "R_SH_GLOB_DAT64", /* name */
b34976b6 1364 FALSE, /* partial_inplace */
fbca6ad9
AO		 1365 0, /* src_mask */
1366 ((bfd_vma) 0) - 1, /* dst_mask */
b34976b6 1367 FALSE), /* pcrel_offset */
fbca6ad9
AO		 1368
1369 HOWTO (R_SH_JMP_SLOT64, /* type */
1370 0, /* rightshift */
1371 4, /* size (0 = byte, 1 = short, 2 = long) */
1372 64, /* bitsize */
b34976b6 1373 FALSE, /* pc_relative */
fbca6ad9
AO		 1374 0, /* bitpos */
1375 complain_overflow_dont, /* complain_on_overflow */
1376 bfd_elf_generic_reloc, /* special_function */
067653c5 1377 "R_SH_JMP_SLOT64", /* name */
b34976b6 1378 FALSE, /* partial_inplace */
fbca6ad9
AO		 1379 0, /* src_mask */
1380 ((bfd_vma) 0) - 1, /* dst_mask */
b34976b6 1381 FALSE), /* pcrel_offset */
fbca6ad9
AO		 1382
1383 HOWTO (R_SH_RELATIVE64, /* type */
1384 0, /* rightshift */
1385 4, /* size (0 = byte, 1 = short, 2 = long) */
1386 64, /* bitsize */
b34976b6 1387 FALSE, /* pc_relative */
fbca6ad9
AO		 1388 0, /* bitpos */
1389 complain_overflow_dont, /* complain_on_overflow */
1390 bfd_elf_generic_reloc, /* special_function */
067653c5 1391 "R_SH_RELATIVE64", /* name */
b34976b6 1392 FALSE, /* partial_inplace */
fbca6ad9
AO		 1393 0, /* src_mask */
1394 ((bfd_vma) 0) - 1, /* dst_mask */
b34976b6 1395 FALSE), /* pcrel_offset */
fbca6ad9
AO		 1396
1397 EMPTY_HOWTO (197),
1398 EMPTY_HOWTO (198),
1399 EMPTY_HOWTO (199),
1400 EMPTY_HOWTO (200),
1401 EMPTY_HOWTO (201),
1402 EMPTY_HOWTO (202),
1403 EMPTY_HOWTO (203),
1404 EMPTY_HOWTO (204),
1405 EMPTY_HOWTO (205),
1406 EMPTY_HOWTO (206),
1407 EMPTY_HOWTO (207),
1408 EMPTY_HOWTO (208),
1409 EMPTY_HOWTO (209),
1410 EMPTY_HOWTO (210),
1411 EMPTY_HOWTO (211),
1412 EMPTY_HOWTO (212),
1413 EMPTY_HOWTO (213),
1414 EMPTY_HOWTO (214),
1415 EMPTY_HOWTO (215),
1416 EMPTY_HOWTO (216),
1417 EMPTY_HOWTO (217),
1418 EMPTY_HOWTO (218),
1419 EMPTY_HOWTO (219),
1420 EMPTY_HOWTO (220),
1421 EMPTY_HOWTO (221),
1422 EMPTY_HOWTO (222),
1423 EMPTY_HOWTO (223),
1424 EMPTY_HOWTO (224),
1425 EMPTY_HOWTO (225),
1426 EMPTY_HOWTO (226),
1427 EMPTY_HOWTO (227),
1428 EMPTY_HOWTO (228),
1429 EMPTY_HOWTO (229),
1430 EMPTY_HOWTO (230),
1431 EMPTY_HOWTO (231),
1432 EMPTY_HOWTO (232),
1433 EMPTY_HOWTO (233),
1434 EMPTY_HOWTO (234),
1435 EMPTY_HOWTO (235),
1436 EMPTY_HOWTO (236),
1437 EMPTY_HOWTO (237),
1438 EMPTY_HOWTO (238),
1439 EMPTY_HOWTO (239),
1440 EMPTY_HOWTO (240),
1441 EMPTY_HOWTO (241),
1442
1443 /* Relocations for SHmedia code. None of these are partial_inplace or
1444 use the field being relocated (except R_SH_PT_16). */
1445
1446 /* The assembler will generate this reloc before a block of SHmedia
1447 instructions. A section should be processed as assuming it contains
1448 data, unless this reloc is seen. Note that a block of SHcompact
1449 instructions are instead preceded by R_SH_CODE.
1450 This is currently not implemented, but should be used for SHmedia
1451 linker relaxation. */
1452 HOWTO (R_SH_SHMEDIA_CODE, /* type */
1453 0, /* rightshift */
1454 1, /* size (0 = byte, 1 = short, 2 = long) */
1455 0, /* bitsize */
b34976b6 1456 FALSE, /* pc_relative */
fbca6ad9
AO		 1457 0, /* bitpos */
1458 complain_overflow_unsigned, /* complain_on_overflow */
1459 sh_elf_ignore_reloc, /* special_function */
1460 "R_SH_SHMEDIA_CODE", /* name */
b34976b6 1461 FALSE, /* partial_inplace */
fbca6ad9
AO		 1462 0, /* src_mask */
1463 0, /* dst_mask */
b34976b6 1464 FALSE), /* pcrel_offset */
fbca6ad9
AO		 1465
1466 /* The assembler will generate this reloc at a PTA or PTB instruction,
1467 and the linker checks the right type of target, or changes a PTA to a
1468 PTB, if the original insn was PT. */
1469 HOWTO (R_SH_PT_16, /* type */
1470 2, /* rightshift */
1471 2, /* size (0 = byte, 1 = short, 2 = long) */
1472 18, /* bitsize */
b34976b6 1473 TRUE, /* pc_relative */
fbca6ad9
AO		 1474 10, /* bitpos */
1475 complain_overflow_signed, /* complain_on_overflow */
1476 bfd_elf_generic_reloc, /* special_function */
1477 "R_SH_PT_16", /* name */
b34976b6 1478 FALSE, /* partial_inplace */
fbca6ad9
AO		 1479 0, /* src_mask */
1480 0x3fffc00, /* dst_mask */
b34976b6 1481 TRUE), /* pcrel_offset */
fbca6ad9
AO		 1482
1483 /* Used in unexpanded MOVI. */
1484 HOWTO (R_SH_IMMS16, /* type */
1485 0, /* rightshift */
1486 2, /* size (0 = byte, 1 = short, 2 = long) */
1487 16, /* bitsize */
b34976b6 1488 FALSE, /* pc_relative */
fbca6ad9
AO		 1489 10, /* bitpos */
1490 complain_overflow_signed, /* complain_on_overflow */
1491 bfd_elf_generic_reloc, /* special_function */
1492 "R_SH_IMMS16", /* name */
b34976b6 1493 FALSE, /* partial_inplace */
fbca6ad9
AO		 1494 0, /* src_mask */
1495 0x3fffc00, /* dst_mask */
b34976b6 1496 FALSE), /* pcrel_offset */
fbca6ad9
AO		 1497
1498 /* Used in SHORI. */
1499 HOWTO (R_SH_IMMU16, /* type */
1500 0, /* rightshift */
1501 2, /* size (0 = byte, 1 = short, 2 = long) */
1502 16, /* bitsize */
b34976b6 1503 FALSE, /* pc_relative */
fbca6ad9
AO		 1504 10, /* bitpos */
1505 complain_overflow_unsigned, /* complain_on_overflow */
1506 bfd_elf_generic_reloc, /* special_function */
1507 "R_SH_IMMU16", /* name */
b34976b6 1508 FALSE, /* partial_inplace */
fbca6ad9
AO		 1509 0, /* src_mask */
1510 0x3fffc00, /* dst_mask */
b34976b6 1511 FALSE), /* pcrel_offset */
fbca6ad9
AO		 1512
1513 /* Used in MOVI and SHORI (x & 65536). */
1514 HOWTO (R_SH_IMM_LOW16, /* type */
1515 0, /* rightshift */
1516 2, /* size (0 = byte, 1 = short, 2 = long) */
1517 64, /* bitsize */
b34976b6 1518 FALSE, /* pc_relative */
fbca6ad9
AO		 1519 10, /* bitpos */
1520 complain_overflow_dont, /* complain_on_overflow */
1521 bfd_elf_generic_reloc, /* special_function */
067653c5 1522 "R_SH_IMM_LOW16", /* name */
b34976b6 1523 FALSE, /* partial_inplace */
fbca6ad9
AO		 1524 0, /* src_mask */
1525 0x3fffc00, /* dst_mask */
b34976b6 1526 FALSE), /* pcrel_offset */
fbca6ad9
AO		 1527
1528 /* Used in MOVI and SHORI ((x - $) & 65536). */
1529 HOWTO (R_SH_IMM_LOW16_PCREL, /* type */
1530 0, /* rightshift */
1531 2, /* size (0 = byte, 1 = short, 2 = long) */
1532 64, /* bitsize */
b34976b6 1533 TRUE, /* pc_relative */
fbca6ad9
AO		 1534 10, /* bitpos */
1535 complain_overflow_dont, /* complain_on_overflow */
1536 bfd_elf_generic_reloc, /* special_function */
1537 "R_SH_IMM_LOW16_PCREL", /* name */
b34976b6 1538 FALSE, /* partial_inplace */
fbca6ad9
AO		 1539 0, /* src_mask */
1540 0x3fffc00, /* dst_mask */
b34976b6 1541 TRUE), /* pcrel_offset */
fbca6ad9
AO		 1542
1543 /* Used in MOVI and SHORI ((x >> 16) & 65536). */
1544 HOWTO (R_SH_IMM_MEDLOW16, /* type */
1545 16, /* rightshift */
1546 2, /* size (0 = byte, 1 = short, 2 = long) */
1547 64, /* bitsize */
b34976b6 1548 FALSE, /* pc_relative */
fbca6ad9
AO		 1549 10, /* bitpos */
1550 complain_overflow_dont, /* complain_on_overflow */
1551 bfd_elf_generic_reloc, /* special_function */
1552 "R_SH_IMM_MEDLOW16", /* name */
b34976b6 1553 FALSE, /* partial_inplace */
fbca6ad9
AO		 1554 0, /* src_mask */
1555 0x3fffc00, /* dst_mask */
b34976b6 1556 FALSE), /* pcrel_offset */
fbca6ad9
AO		 1557
1558 /* Used in MOVI and SHORI (((x - $) >> 16) & 65536). */
1559 HOWTO (R_SH_IMM_MEDLOW16_PCREL, /* type */
1560 16, /* rightshift */
1561 2, /* size (0 = byte, 1 = short, 2 = long) */
1562 64, /* bitsize */
b34976b6 1563 TRUE, /* pc_relative */
fbca6ad9
AO		 1564 10, /* bitpos */
1565 complain_overflow_dont, /* complain_on_overflow */
1566 bfd_elf_generic_reloc, /* special_function */
1567 "R_SH_IMM_MEDLOW16_PCREL", /* name */
b34976b6 1568 FALSE, /* partial_inplace */
fbca6ad9
AO		 1569 0, /* src_mask */
1570 0x3fffc00, /* dst_mask */
b34976b6 1571 TRUE), /* pcrel_offset */
fbca6ad9
AO		 1572
1573 /* Used in MOVI and SHORI ((x >> 32) & 65536). */
1574 HOWTO (R_SH_IMM_MEDHI16, /* type */
1575 32, /* rightshift */
1576 2, /* size (0 = byte, 1 = short, 2 = long) */
1577 64, /* bitsize */
b34976b6 1578 FALSE, /* pc_relative */
fbca6ad9
AO		 1579 10, /* bitpos */
1580 complain_overflow_dont, /* complain_on_overflow */
1581 bfd_elf_generic_reloc, /* special_function */
1582 "R_SH_IMM_MEDHI16", /* name */
b34976b6 1583 FALSE, /* partial_inplace */
fbca6ad9
AO		 1584 0, /* src_mask */
1585 0x3fffc00, /* dst_mask */
b34976b6 1586 FALSE), /* pcrel_offset */
fbca6ad9
AO		 1587
1588 /* Used in MOVI and SHORI (((x - $) >> 32) & 65536). */
1589 HOWTO (R_SH_IMM_MEDHI16_PCREL, /* type */
1590 32, /* rightshift */
1591 2, /* size (0 = byte, 1 = short, 2 = long) */
1592 64, /* bitsize */
b34976b6 1593 TRUE, /* pc_relative */
fbca6ad9
AO		 1594 10, /* bitpos */
1595 complain_overflow_dont, /* complain_on_overflow */
1596 bfd_elf_generic_reloc, /* special_function */
1597 "R_SH_IMM_MEDHI16_PCREL", /* name */
b34976b6 1598 FALSE, /* partial_inplace */
fbca6ad9
AO		 1599 0, /* src_mask */
1600 0x3fffc00, /* dst_mask */
b34976b6 1601 TRUE), /* pcrel_offset */
fbca6ad9
AO		 1602
1603 /* Used in MOVI and SHORI ((x >> 48) & 65536). */
1604 HOWTO (R_SH_IMM_HI16, /* type */
1605 48, /* rightshift */
1606 2, /* size (0 = byte, 1 = short, 2 = long) */
1607 64, /* bitsize */
b34976b6 1608 FALSE, /* pc_relative */
fbca6ad9
AO		 1609 10, /* bitpos */
1610 complain_overflow_dont, /* complain_on_overflow */
1611 bfd_elf_generic_reloc, /* special_function */
1612 "R_SH_IMM_HI16", /* name */
b34976b6 1613 FALSE, /* partial_inplace */
fbca6ad9
AO		 1614 0, /* src_mask */
1615 0x3fffc00, /* dst_mask */
b34976b6 1616 FALSE), /* pcrel_offset */
fbca6ad9
AO		 1617
1618 /* Used in MOVI and SHORI (((x - $) >> 48) & 65536). */
1619 HOWTO (R_SH_IMM_HI16_PCREL, /* type */
1620 48, /* rightshift */
1621 2, /* size (0 = byte, 1 = short, 2 = long) */
1622 64, /* bitsize */
b34976b6 1623 TRUE, /* pc_relative */
fbca6ad9
AO		 1624 10, /* bitpos */
1625 complain_overflow_dont, /* complain_on_overflow */
1626 bfd_elf_generic_reloc, /* special_function */
1627 "R_SH_IMM_HI16_PCREL", /* name */
b34976b6 1628 FALSE, /* partial_inplace */
fbca6ad9
AO		 1629 0, /* src_mask */
1630 0x3fffc00, /* dst_mask */
b34976b6 1631 TRUE), /* pcrel_offset */
fbca6ad9
AO		 1632
1633 /* For the .uaquad pseudo. */
1634 HOWTO (R_SH_64, /* type */
1635 0, /* rightshift */
1636 4, /* size (0 = byte, 1 = short, 2 = long) */
1637 64, /* bitsize */
b34976b6 1638 FALSE, /* pc_relative */
fbca6ad9
AO		 1639 0, /* bitpos */
1640 complain_overflow_dont, /* complain_on_overflow */
1641 bfd_elf_generic_reloc, /* special_function */
067653c5 1642 "R_SH_64", /* name */
b34976b6 1643 FALSE, /* partial_inplace */
fbca6ad9
AO		 1644 0, /* src_mask */
1645 ((bfd_vma) 0) - 1, /* dst_mask */
b34976b6 1646 FALSE), /* pcrel_offset */
fbca6ad9
AO		 1647
1648 /* For the .uaquad pseudo, (x - $). */
1649 HOWTO (R_SH_64_PCREL, /* type */
1650 48, /* rightshift */
1651 2, /* size (0 = byte, 1 = short, 2 = long) */
1652 64, /* bitsize */
b34976b6 1653 TRUE, /* pc_relative */
fbca6ad9
AO		 1654 10, /* bitpos */
1655 complain_overflow_dont, /* complain_on_overflow */
1656 bfd_elf_generic_reloc, /* special_function */
1657 "R_SH_64_PCREL", /* name */
b34976b6 1658 FALSE, /* partial_inplace */
fbca6ad9
AO		 1659 0, /* src_mask */
1660 ((bfd_vma) 0) - 1, /* dst_mask */
b34976b6 1661 TRUE), /* pcrel_offset */
fbca6ad9
AO		 1662
1663#endif
252b5132
RH		 1664};
1665
015551fc
JR		 1666static bfd_reloc_status_type
1667sh_elf_reloc_loop (r_type, input_bfd, input_section, contents, addr,
435b1e90 1668 symbol_section, start, end)
61ff1804 1669 int r_type ATTRIBUTE_UNUSED;
015551fc
JR		 1670 bfd *input_bfd;
1671 asection *input_section;
1672 bfd_byte *contents;
1673 bfd_vma addr;
1674 asection *symbol_section;
1675 bfd_vma start, end;
1676{
1677 static bfd_vma last_addr;
00fdaf47 1678 static asection *last_symbol_section;
015551fc
JR		 1679 bfd_byte *start_ptr, *ptr, *last_ptr;
1680 int diff, cum_diff;
1681 bfd_signed_vma x;
1682 int insn;
1683
1684 /* Sanity check the address. */
1685 if (addr > input_section->_raw_size)
1686 return bfd_reloc_outofrange;
1687
1688 /* We require the start and end relocations to be processed consecutively -
1689 although we allow then to be processed forwards or backwards. */
1690 if (! last_addr)
1691 {
1692 last_addr = addr;
1693 last_symbol_section = symbol_section;
1694 return bfd_reloc_ok;
1695 }
1696 if (last_addr != addr)
1697 abort ();
1698 last_addr = 0;
1699
1700 if (! symbol_section || last_symbol_section != symbol_section || end < start)
1701 return bfd_reloc_outofrange;
1702
1703 /* Get the symbol_section contents. */
1704 if (symbol_section != input_section)
1705 {
1706 if (elf_section_data (symbol_section)->this_hdr.contents != NULL)
1707 contents = elf_section_data (symbol_section)->this_hdr.contents;
1708 else
1709 {
dc810e39 1710 contents = (bfd_byte *) bfd_malloc (symbol_section->_raw_size);
015551fc
JR		 1711 if (contents == NULL)
1712 return bfd_reloc_outofrange;
1713 if (! bfd_get_section_contents (input_bfd, symbol_section, contents,
1714 (file_ptr) 0,
1715 symbol_section->_raw_size))
1716 {
1717 free (contents);
1718 return bfd_reloc_outofrange;
1719 }
1720 }
1721 }
1722#define IS_PPI(PTR) ((bfd_get_16 (input_bfd, (PTR)) & 0xfc00) == 0xf800)
1723 start_ptr = contents + start;
1724 for (cum_diff = -6, ptr = contents + end; cum_diff < 0 && ptr > start_ptr;)
1725 {
1726 for (last_ptr = ptr, ptr -= 4; ptr >= start_ptr && IS_PPI (ptr);)
1727 ptr -= 2;
1728 ptr += 2;
61ff1804 1729 diff = (last_ptr - ptr) >> 1;
015551fc
JR		 1730 cum_diff += diff & 1;
1731 cum_diff += diff;
1732 }
1733 /* Calculate the start / end values to load into rs / re minus four -
1734 so that will cancel out the four we would otherwise have to add to
1735 addr to get the value to subtract in order to get relative addressing. */
1736 if (cum_diff >= 0)
1737 {
1738 start -= 4;
1739 end = (ptr + cum_diff * 2) - contents;
1740 }
1741 else
1742 {
1743 bfd_vma start0 = start - 4;
1744
a0fc8ba1 1745 while (start0 && IS_PPI (contents + start0))
015551fc
JR		 1746 start0 -= 2;
1747 start0 = start - 2 - ((start - start0) & 2);
1748 start = start0 - cum_diff - 2;
1749 end = start0;
1750 }
1751
6cdc0ccc
AM		 1752 if (contents != NULL
1753 && elf_section_data (symbol_section)->this_hdr.contents != contents)
1754 free (contents);
015551fc
JR		 1755
1756 insn = bfd_get_16 (input_bfd, contents + addr);
1757
1758 x = (insn & 0x200 ? end : start) - addr;
1759 if (input_section != symbol_section)
1760 x += ((symbol_section->output_section->vma + symbol_section->output_offset)
1761 - (input_section->output_section->vma
1762 + input_section->output_offset));
1763 x >>= 1;
1764 if (x < -128 || x > 127)
1765 return bfd_reloc_overflow;
1766
61ff1804 1767 x = (insn & ~0xff) | (x & 0xff);
dc810e39 1768 bfd_put_16 (input_bfd, (bfd_vma) x, contents + addr);
015551fc
JR		 1769
1770 return bfd_reloc_ok;
1771}
1772
1773/* This function is used for normal relocs. This used to be like the COFF
252b5132
RH		 1774 function, and is almost certainly incorrect for other ELF targets. */
1775
1776static bfd_reloc_status_type
1777sh_elf_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd,
435b1e90 1778 error_message)
252b5132
RH		 1779 bfd *abfd;
1780 arelent *reloc_entry;
1781 asymbol *symbol_in;
1782 PTR data;
1783 asection *input_section;
1784 bfd *output_bfd;
5f771d47 1785 char **error_message ATTRIBUTE_UNUSED;
252b5132
RH		 1786{
1787 unsigned long insn;
1788 bfd_vma sym_value;
1789 enum elf_sh_reloc_type r_type;
1790 bfd_vma addr = reloc_entry->address;
1791 bfd_byte *hit_data = addr + (bfd_byte *) data;
1792
1793 r_type = (enum elf_sh_reloc_type) reloc_entry->howto->type;
1794
1795 if (output_bfd != NULL)
1796 {
1797 /* Partial linking--do nothing. */
1798 reloc_entry->address += input_section->output_offset;
1799 return bfd_reloc_ok;
1800 }
1801
1802 /* Almost all relocs have to do with relaxing. If any work must be
1803 done for them, it has been done in sh_relax_section. */
015551fc 1804 if (r_type == R_SH_IND12W && (symbol_in->flags & BSF_LOCAL) != 0)
252b5132
RH		 1805 return bfd_reloc_ok;
1806
1807 if (symbol_in != NULL
1808 && bfd_is_und_section (symbol_in->section))
1809 return bfd_reloc_undefined;
1810
1811 if (bfd_is_com_section (symbol_in->section))
435b1e90
KH		 1812 sym_value = 0;
1813 else
252b5132
RH		 1814 sym_value = (symbol_in->value +
1815 symbol_in->section->output_section->vma +
1816 symbol_in->section->output_offset);
1817
1818 switch (r_type)
1819 {
1820 case R_SH_DIR32:
1821 insn = bfd_get_32 (abfd, hit_data);
1822 insn += sym_value + reloc_entry->addend;
dc810e39 1823 bfd_put_32 (abfd, (bfd_vma) insn, hit_data);
252b5132
RH		 1824 break;
1825 case R_SH_IND12W:
1826 insn = bfd_get_16 (abfd, hit_data);
1827 sym_value += reloc_entry->addend;
1828 sym_value -= (input_section->output_section->vma
1829 + input_section->output_offset
1830 + addr
1831 + 4);
1832 sym_value += (insn & 0xfff) << 1;
1833 if (insn & 0x800)
1834 sym_value -= 0x1000;
1835 insn = (insn & 0xf000) | (sym_value & 0xfff);
dc810e39 1836 bfd_put_16 (abfd, (bfd_vma) insn, hit_data);
252b5132
RH		 1837 if (sym_value < (bfd_vma) -0x1000 || sym_value >= 0x1000)
1838 return bfd_reloc_overflow;
1839 break;
1840 default:
1841 abort ();
1842 break;
1843 }
1844
1845 return bfd_reloc_ok;
1846}
1847
1848/* This function is used for relocs which are only used for relaxing,
1849 which the linker should otherwise ignore. */
1850
1851static bfd_reloc_status_type
1852sh_elf_ignore_reloc (abfd, reloc_entry, symbol, data, input_section,
1853 output_bfd, error_message)
5f771d47 1854 bfd *abfd ATTRIBUTE_UNUSED;
252b5132 1855 arelent *reloc_entry;
5f771d47
ILT		 1856 asymbol *symbol ATTRIBUTE_UNUSED;
1857 PTR data ATTRIBUTE_UNUSED;
252b5132
RH		 1858 asection *input_section;
1859 bfd *output_bfd;
5f771d47 1860 char **error_message ATTRIBUTE_UNUSED;
252b5132
RH		 1861{
1862 if (output_bfd != NULL)
1863 reloc_entry->address += input_section->output_offset;
1864 return bfd_reloc_ok;
1865}
1866
1867/* This structure is used to map BFD reloc codes to SH ELF relocs. */
1868
38b1a46c
NC		 1869struct elf_reloc_map
1870{
252b5132
RH		 1871 bfd_reloc_code_real_type bfd_reloc_val;
1872 unsigned char elf_reloc_val;
1873};
1874
1875/* An array mapping BFD reloc codes to SH ELF relocs. */
1876
38b1a46c
NC		 1877static const struct elf_reloc_map sh_reloc_map[] =
1878{
252b5132
RH		 1879 { BFD_RELOC_NONE, R_SH_NONE },
1880 { BFD_RELOC_32, R_SH_DIR32 },
1881 { BFD_RELOC_CTOR, R_SH_DIR32 },
1882 { BFD_RELOC_32_PCREL, R_SH_REL32 },
1883 { BFD_RELOC_SH_PCDISP8BY2, R_SH_DIR8WPN },
1884 { BFD_RELOC_SH_PCDISP12BY2, R_SH_IND12W },
1885 { BFD_RELOC_SH_PCRELIMM8BY2, R_SH_DIR8WPZ },
1886 { BFD_RELOC_SH_PCRELIMM8BY4, R_SH_DIR8WPL },
1887 { BFD_RELOC_8_PCREL, R_SH_SWITCH8 },
1888 { BFD_RELOC_SH_SWITCH16, R_SH_SWITCH16 },
1889 { BFD_RELOC_SH_SWITCH32, R_SH_SWITCH32 },
1890 { BFD_RELOC_SH_USES, R_SH_USES },
1891 { BFD_RELOC_SH_COUNT, R_SH_COUNT },
1892 { BFD_RELOC_SH_ALIGN, R_SH_ALIGN },
1893 { BFD_RELOC_SH_CODE, R_SH_CODE },
1894 { BFD_RELOC_SH_DATA, R_SH_DATA },
1895 { BFD_RELOC_SH_LABEL, R_SH_LABEL },
1896 { BFD_RELOC_VTABLE_INHERIT, R_SH_GNU_VTINHERIT },
1897 { BFD_RELOC_VTABLE_ENTRY, R_SH_GNU_VTENTRY },
015551fc
JR		 1898 { BFD_RELOC_SH_LOOP_START, R_SH_LOOP_START },
1899 { BFD_RELOC_SH_LOOP_END, R_SH_LOOP_END },
3376eaf5
KK		 1900 { BFD_RELOC_SH_TLS_GD_32, R_SH_TLS_GD_32 },
1901 { BFD_RELOC_SH_TLS_LD_32, R_SH_TLS_LD_32 },
1902 { BFD_RELOC_SH_TLS_LDO_32, R_SH_TLS_LDO_32 },
1903 { BFD_RELOC_SH_TLS_IE_32, R_SH_TLS_IE_32 },
1904 { BFD_RELOC_SH_TLS_LE_32, R_SH_TLS_LE_32 },
1905 { BFD_RELOC_SH_TLS_DTPMOD32, R_SH_TLS_DTPMOD32 },
1906 { BFD_RELOC_SH_TLS_DTPOFF32, R_SH_TLS_DTPOFF32 },
1907 { BFD_RELOC_SH_TLS_TPOFF32, R_SH_TLS_TPOFF32 },
37c644f2
AO		 1908 { BFD_RELOC_32_GOT_PCREL, R_SH_GOT32 },
1909 { BFD_RELOC_32_PLT_PCREL, R_SH_PLT32 },
1910 { BFD_RELOC_SH_COPY, R_SH_COPY },
1911 { BFD_RELOC_SH_GLOB_DAT, R_SH_GLOB_DAT },
1912 { BFD_RELOC_SH_JMP_SLOT, R_SH_JMP_SLOT },
1913 { BFD_RELOC_SH_RELATIVE, R_SH_RELATIVE },
1914 { BFD_RELOC_32_GOTOFF, R_SH_GOTOFF },
1915 { BFD_RELOC_SH_GOTPC, R_SH_GOTPC },
fbca6ad9
AO		 1916 { BFD_RELOC_SH_GOTPLT32, R_SH_GOTPLT32 },
1917#ifdef INCLUDE_SHMEDIA
1918 { BFD_RELOC_SH_GOT_LOW16, R_SH_GOT_LOW16 },
1919 { BFD_RELOC_SH_GOT_MEDLOW16, R_SH_GOT_MEDLOW16 },
1920 { BFD_RELOC_SH_GOT_MEDHI16, R_SH_GOT_MEDHI16 },
1921 { BFD_RELOC_SH_GOT_HI16, R_SH_GOT_HI16 },
1922 { BFD_RELOC_SH_GOTPLT_LOW16, R_SH_GOTPLT_LOW16 },
1923 { BFD_RELOC_SH_GOTPLT_MEDLOW16, R_SH_GOTPLT_MEDLOW16 },
1924 { BFD_RELOC_SH_GOTPLT_MEDHI16, R_SH_GOTPLT_MEDHI16 },
1925 { BFD_RELOC_SH_GOTPLT_HI16, R_SH_GOTPLT_HI16 },
1926 { BFD_RELOC_SH_PLT_LOW16, R_SH_PLT_LOW16 },
1927 { BFD_RELOC_SH_PLT_MEDLOW16, R_SH_PLT_MEDLOW16 },
1928 { BFD_RELOC_SH_PLT_MEDHI16, R_SH_PLT_MEDHI16 },
1929 { BFD_RELOC_SH_PLT_HI16, R_SH_PLT_HI16 },
1930 { BFD_RELOC_SH_GOTOFF_LOW16, R_SH_GOTOFF_LOW16 },
1931 { BFD_RELOC_SH_GOTOFF_MEDLOW16, R_SH_GOTOFF_MEDLOW16 },
1932 { BFD_RELOC_SH_GOTOFF_MEDHI16, R_SH_GOTOFF_MEDHI16 },
1933 { BFD_RELOC_SH_GOTOFF_HI16, R_SH_GOTOFF_HI16 },
1934 { BFD_RELOC_SH_GOTPC_LOW16, R_SH_GOTPC_LOW16 },
1935 { BFD_RELOC_SH_GOTPC_MEDLOW16, R_SH_GOTPC_MEDLOW16 },
1936 { BFD_RELOC_SH_GOTPC_MEDHI16, R_SH_GOTPC_MEDHI16 },
1937 { BFD_RELOC_SH_GOTPC_HI16, R_SH_GOTPC_HI16 },
1938 { BFD_RELOC_SH_COPY64, R_SH_COPY64 },
1939 { BFD_RELOC_SH_GLOB_DAT64, R_SH_GLOB_DAT64 },
1940 { BFD_RELOC_SH_JMP_SLOT64, R_SH_JMP_SLOT64 },
1941 { BFD_RELOC_SH_RELATIVE64, R_SH_RELATIVE64 },
1942 { BFD_RELOC_SH_GOT10BY4, R_SH_GOT10BY4 },
1943 { BFD_RELOC_SH_GOT10BY8, R_SH_GOT10BY8 },
1944 { BFD_RELOC_SH_GOTPLT10BY4, R_SH_GOTPLT10BY4 },
1945 { BFD_RELOC_SH_GOTPLT10BY8, R_SH_GOTPLT10BY8 },
1946 { BFD_RELOC_SH_PT_16, R_SH_PT_16 },
1947 { BFD_RELOC_SH_SHMEDIA_CODE, R_SH_SHMEDIA_CODE },
1948 { BFD_RELOC_SH_IMMU5, R_SH_DIR5U },
1949 { BFD_RELOC_SH_IMMS6, R_SH_DIR6S },
1950 { BFD_RELOC_SH_IMMU6, R_SH_DIR6U },
1951 { BFD_RELOC_SH_IMMS10, R_SH_DIR10S },
1952 { BFD_RELOC_SH_IMMS10BY2, R_SH_DIR10SW },
1953 { BFD_RELOC_SH_IMMS10BY4, R_SH_DIR10SL },
1954 { BFD_RELOC_SH_IMMS10BY8, R_SH_DIR10SQ },
1955 { BFD_RELOC_SH_IMMS16, R_SH_IMMS16 },
1956 { BFD_RELOC_SH_IMMU16, R_SH_IMMU16 },
1957 { BFD_RELOC_SH_IMM_LOW16, R_SH_IMM_LOW16 },
1958 { BFD_RELOC_SH_IMM_LOW16_PCREL, R_SH_IMM_LOW16_PCREL },
1959 { BFD_RELOC_SH_IMM_MEDLOW16, R_SH_IMM_MEDLOW16 },
1960 { BFD_RELOC_SH_IMM_MEDLOW16_PCREL, R_SH_IMM_MEDLOW16_PCREL },
1961 { BFD_RELOC_SH_IMM_MEDHI16, R_SH_IMM_MEDHI16 },
1962 { BFD_RELOC_SH_IMM_MEDHI16_PCREL, R_SH_IMM_MEDHI16_PCREL },
1963 { BFD_RELOC_SH_IMM_HI16, R_SH_IMM_HI16 },
1964 { BFD_RELOC_SH_IMM_HI16_PCREL, R_SH_IMM_HI16_PCREL },
1965 { BFD_RELOC_64, R_SH_64 },
1966 { BFD_RELOC_64_PCREL, R_SH_64_PCREL },
1967#endif /* not INCLUDE_SHMEDIA */
252b5132
RH		 1968};
1969
1970/* Given a BFD reloc code, return the howto structure for the
1971 corresponding SH ELf reloc. */
1972
1973static reloc_howto_type *
1974sh_elf_reloc_type_lookup (abfd, code)
5f771d47 1975 bfd *abfd ATTRIBUTE_UNUSED;
252b5132
RH		 1976 bfd_reloc_code_real_type code;
1977{
1978 unsigned int i;
1979
1980 for (i = 0; i < sizeof (sh_reloc_map) / sizeof (struct elf_reloc_map); i++)
1981 {
1982 if (sh_reloc_map[i].bfd_reloc_val == code)
1983 return &sh_elf_howto_table[(int) sh_reloc_map[i].elf_reloc_val];
1984 }
1985
1986 return NULL;
1987}
1988
1989/* Given an ELF reloc, fill in the howto field of a relent. */
1990
1991static void
1992sh_elf_info_to_howto (abfd, cache_ptr, dst)
5f771d47 1993 bfd *abfd ATTRIBUTE_UNUSED;
252b5132
RH		 1994 arelent *cache_ptr;
1995 Elf_Internal_Rela *dst;
1996{
1997 unsigned int r;
1998
1999 r = ELF32_R_TYPE (dst->r_info);
2000
2001 BFD_ASSERT (r < (unsigned int) R_SH_max);
2002 BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC || r > R_SH_LAST_INVALID_RELOC);
06bb75c1 2003 BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_2 || r > R_SH_LAST_INVALID_RELOC_2);
fbca6ad9
AO		 2004 BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_3 || r > R_SH_LAST_INVALID_RELOC_3);
2005 BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_4 || r > R_SH_LAST_INVALID_RELOC_4);
3376eaf5 2006 BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_5 || r > R_SH_LAST_INVALID_RELOC_5);
252b5132
RH		 2007
2008 cache_ptr->howto = &sh_elf_howto_table[r];
2009}
2010\f
2011/* This function handles relaxing for SH ELF. See the corresponding
2012 function in coff-sh.c for a description of what this does. FIXME:
2013 There is a lot of duplication here between this code and the COFF
2014 specific code. The format of relocs and symbols is wound deeply
2015 into this code, but it would still be better if the duplication
2016 could be eliminated somehow. Note in particular that although both
2017 functions use symbols like R_SH_CODE, those symbols have different
2018 values; in coff-sh.c they come from include/coff/sh.h, whereas here
2019 they come from enum elf_sh_reloc_type in include/elf/sh.h. */
2020
b34976b6 2021static bfd_boolean
252b5132
RH		 2022sh_elf_relax_section (abfd, sec, link_info, again)
2023 bfd *abfd;
2024 asection *sec;
2025 struct bfd_link_info *link_info;
b34976b6 2026 bfd_boolean *again;
252b5132
RH		 2027{
2028 Elf_Internal_Shdr *symtab_hdr;
2029 Elf_Internal_Rela *internal_relocs;
b34976b6 2030 bfd_boolean have_code;
252b5132
RH		 2031 Elf_Internal_Rela *irel, *irelend;
2032 bfd_byte *contents = NULL;
6cdc0ccc 2033 Elf_Internal_Sym *isymbuf = NULL;
252b5132 2034
b34976b6 2035 *again = FALSE;
252b5132 2036
1049f94e 2037 if (link_info->relocatable
252b5132
RH		 2038 || (sec->flags & SEC_RELOC) == 0
2039 || sec->reloc_count == 0)
b34976b6 2040 return TRUE;
252b5132 2041
fbca6ad9
AO		 2042#ifdef INCLUDE_SHMEDIA
2043 if (elf_section_data (sec)->this_hdr.sh_flags
2044 & (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED))
2045 {
b34976b6 2046 return TRUE;
fbca6ad9
AO		 2047 }
2048#endif
2049
252b5132
RH		 2050 /* If this is the first time we have been called for this section,
2051 initialize the cooked size. */
2052 if (sec->_cooked_size == 0)
2053 sec->_cooked_size = sec->_raw_size;
2054
2055 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2056
45d6a902 2057 internal_relocs = (_bfd_elf_link_read_relocs
252b5132
RH		 2058 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
2059 link_info->keep_memory));
2060 if (internal_relocs == NULL)
2061 goto error_return;
252b5132 2062
b34976b6 2063 have_code = FALSE;
252b5132
RH		 2064
2065 irelend = internal_relocs + sec->reloc_count;
2066 for (irel = internal_relocs; irel < irelend; irel++)
2067 {
2068 bfd_vma laddr, paddr, symval;
2069 unsigned short insn;
2070 Elf_Internal_Rela *irelfn, *irelscan, *irelcount;
2071 bfd_signed_vma foff;
2072
2073 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_CODE)
b34976b6 2074 have_code = TRUE;
252b5132
RH		 2075
2076 if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_USES)
2077 continue;
2078
2079 /* Get the section contents. */
2080 if (contents == NULL)
2081 {
2082 if (elf_section_data (sec)->this_hdr.contents != NULL)
2083 contents = elf_section_data (sec)->this_hdr.contents;
2084 else
2085 {
2086 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
2087 if (contents == NULL)
2088 goto error_return;
252b5132
RH		 2089
2090 if (! bfd_get_section_contents (abfd, sec, contents,
2091 (file_ptr) 0, sec->_raw_size))
2092 goto error_return;
2093 }
2094 }
2095
2096 /* The r_addend field of the R_SH_USES reloc will point us to
067653c5
AM		 2097 the register load. The 4 is because the r_addend field is
2098 computed as though it were a jump offset, which are based
2099 from 4 bytes after the jump instruction. */
252b5132
RH		 2100 laddr = irel->r_offset + 4 + irel->r_addend;
2101 if (laddr >= sec->_raw_size)
2102 {
2103 (*_bfd_error_handler) (_("%s: 0x%lx: warning: bad R_SH_USES offset"),
8f615d07 2104 bfd_archive_filename (abfd),
252b5132
RH		 2105 (unsigned long) irel->r_offset);
2106 continue;
2107 }
2108 insn = bfd_get_16 (abfd, contents + laddr);
2109
2110 /* If the instruction is not mov.l NN,rN, we don't know what to
067653c5 2111 do. */
252b5132
RH		 2112 if ((insn & 0xf000) != 0xd000)
2113 {
2114 ((*_bfd_error_handler)
2115 (_("%s: 0x%lx: warning: R_SH_USES points to unrecognized insn 0x%x"),
8f615d07 2116 bfd_archive_filename (abfd), (unsigned long) irel->r_offset, insn));
252b5132
RH		 2117 continue;
2118 }
2119
2120 /* Get the address from which the register is being loaded. The
99e4ae17
AJ		 2121 displacement in the mov.l instruction is quadrupled. It is a
2122 displacement from four bytes after the movl instruction, but,
2123 before adding in the PC address, two least significant bits
2124 of the PC are cleared. We assume that the section is aligned
2125 on a four byte boundary. */
252b5132
RH		 2126 paddr = insn & 0xff;
2127 paddr *= 4;
dc810e39 2128 paddr += (laddr + 4) &~ (bfd_vma) 3;
252b5132
RH		 2129 if (paddr >= sec->_raw_size)
2130 {
2131 ((*_bfd_error_handler)
2132 (_("%s: 0x%lx: warning: bad R_SH_USES load offset"),
8f615d07 2133 bfd_archive_filename (abfd), (unsigned long) irel->r_offset));
252b5132
RH		 2134 continue;
2135 }
2136
2137 /* Get the reloc for the address from which the register is
067653c5
AM		 2138 being loaded. This reloc will tell us which function is
2139 actually being called. */
252b5132
RH		 2140 for (irelfn = internal_relocs; irelfn < irelend; irelfn++)
2141 if (irelfn->r_offset == paddr
2142 && ELF32_R_TYPE (irelfn->r_info) == (int) R_SH_DIR32)
2143 break;
2144 if (irelfn >= irelend)
2145 {
2146 ((*_bfd_error_handler)
2147 (_("%s: 0x%lx: warning: could not find expected reloc"),
8f615d07 2148 bfd_archive_filename (abfd), (unsigned long) paddr));
252b5132
RH		 2149 continue;
2150 }
2151
2152 /* Read this BFD's symbols if we haven't done so already. */
6cdc0ccc 2153 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
252b5132 2154 {
6cdc0ccc
AM		 2155 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2156 if (isymbuf == NULL)
2157 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2158 symtab_hdr->sh_info, 0,
2159 NULL, NULL, NULL);
2160 if (isymbuf == NULL)
2161 goto error_return;
252b5132
RH		 2162 }
2163
2164 /* Get the value of the symbol referred to by the reloc. */
2165 if (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
2166 {
9ad5cbcf 2167 /* A local symbol. */
6cdc0ccc 2168 Elf_Internal_Sym *isym;
252b5132 2169
6cdc0ccc
AM		 2170 isym = isymbuf + ELF32_R_SYM (irelfn->r_info);
2171 if (isym->st_shndx
d426c6b0 2172 != (unsigned int) _bfd_elf_section_from_bfd_section (abfd, sec))
252b5132
RH		 2173 {
2174 ((*_bfd_error_handler)
2175 (_("%s: 0x%lx: warning: symbol in unexpected section"),
8f615d07 2176 bfd_archive_filename (abfd), (unsigned long) paddr));
252b5132
RH		 2177 continue;
2178 }
2179
6cdc0ccc 2180 symval = (isym->st_value
252b5132
RH		 2181 + sec->output_section->vma
2182 + sec->output_offset);
2183 }
2184 else
2185 {
2186 unsigned long indx;
2187 struct elf_link_hash_entry *h;
2188
2189 indx = ELF32_R_SYM (irelfn->r_info) - symtab_hdr->sh_info;
2190 h = elf_sym_hashes (abfd)[indx];
2191 BFD_ASSERT (h != NULL);
2192 if (h->root.type != bfd_link_hash_defined
2193 && h->root.type != bfd_link_hash_defweak)
2194 {
2195 /* This appears to be a reference to an undefined
067653c5
AM		 2196 symbol. Just ignore it--it will be caught by the
2197 regular reloc processing. */
252b5132
RH		 2198 continue;
2199 }
2200
2201 symval = (h->root.u.def.value
2202 + h->root.u.def.section->output_section->vma
2203 + h->root.u.def.section->output_offset);
2204 }
2205
2206 symval += bfd_get_32 (abfd, contents + paddr);
2207
2208 /* See if this function call can be shortened. */
2209 foff = (symval
2210 - (irel->r_offset
2211 + sec->output_section->vma
2212 + sec->output_offset
2213 + 4));
2214 if (foff < -0x1000 || foff >= 0x1000)
2215 {
2216 /* After all that work, we can't shorten this function call. */
2217 continue;
2218 }
2219
2220 /* Shorten the function call. */
2221
2222 /* For simplicity of coding, we are going to modify the section
2223 contents, the section relocs, and the BFD symbol table. We
2224 must tell the rest of the code not to free up this
2225 information. It would be possible to instead create a table
2226 of changes which have to be made, as is done in coff-mips.c;
2227 that would be more work, but would require less memory when
2228 the linker is run. */
2229
2230 elf_section_data (sec)->relocs = internal_relocs;
252b5132 2231 elf_section_data (sec)->this_hdr.contents = contents;
6cdc0ccc 2232 symtab_hdr->contents = (unsigned char *) isymbuf;
252b5132
RH		 2233
2234 /* Replace the jsr with a bsr. */
2235
2236 /* Change the R_SH_USES reloc into an R_SH_IND12W reloc, and
067653c5 2237 replace the jsr with a bsr. */
252b5132 2238 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irelfn->r_info), R_SH_IND12W);
bdfaef52
JR		 2239 /* We used to test (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
2240 here, but that only checks if the symbol is an external symbol,
2241 not if the symbol is in a different section. Besides, we need
2242 a consistent meaning for the relocation, so we just assume here that
2243 the value of the symbol is not available. */
2244#if 0
252b5132
RH		 2245 if (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info)
2246 {
2247 /* If this needs to be changed because of future relaxing,
067653c5
AM		 2248 it will be handled here like other internal IND12W
2249 relocs. */
252b5132 2250 bfd_put_16 (abfd,
dc810e39 2251 (bfd_vma) 0xb000 | ((foff >> 1) & 0xfff),
252b5132
RH		 2252 contents + irel->r_offset);
2253 }
2254 else
bdfaef52 2255#endif
252b5132
RH		 2256 {
2257 /* We can't fully resolve this yet, because the external
067653c5
AM		 2258 symbol value may be changed by future relaxing. We let
2259 the final link phase handle it. */
dc810e39 2260 bfd_put_16 (abfd, (bfd_vma) 0xb000, contents + irel->r_offset);
252b5132 2261 }
bdfaef52 2262 irel->r_addend = -4;
252b5132
RH		 2263
2264 /* See if there is another R_SH_USES reloc referring to the same
067653c5 2265 register load. */
252b5132
RH		 2266 for (irelscan = internal_relocs; irelscan < irelend; irelscan++)
2267 if (ELF32_R_TYPE (irelscan->r_info) == (int) R_SH_USES
2268 && laddr == irelscan->r_offset + 4 + irelscan->r_addend)
2269 break;
2270 if (irelscan < irelend)
2271 {
2272 /* Some other function call depends upon this register load,
2273 and we have not yet converted that function call.
2274 Indeed, we may never be able to convert it. There is
2275 nothing else we can do at this point. */
2276 continue;
2277 }
2278
2279 /* Look for a R_SH_COUNT reloc on the location where the
067653c5
AM		 2280 function address is stored. Do this before deleting any
2281 bytes, to avoid confusion about the address. */
252b5132
RH		 2282 for (irelcount = internal_relocs; irelcount < irelend; irelcount++)
2283 if (irelcount->r_offset == paddr
2284 && ELF32_R_TYPE (irelcount->r_info) == (int) R_SH_COUNT)
2285 break;
2286
2287 /* Delete the register load. */
2288 if (! sh_elf_relax_delete_bytes (abfd, sec, laddr, 2))
2289 goto error_return;
2290
2291 /* That will change things, so, just in case it permits some
067653c5
AM		 2292 other function call to come within range, we should relax
2293 again. Note that this is not required, and it may be slow. */
b34976b6 2294 *again = TRUE;
252b5132
RH		 2295
2296 /* Now check whether we got a COUNT reloc. */
2297 if (irelcount >= irelend)
2298 {
2299 ((*_bfd_error_handler)
2300 (_("%s: 0x%lx: warning: could not find expected COUNT reloc"),
8f615d07 2301 bfd_archive_filename (abfd), (unsigned long) paddr));
252b5132
RH		 2302 continue;
2303 }
2304
2305 /* The number of uses is stored in the r_addend field. We've
067653c5 2306 just deleted one. */
252b5132
RH		 2307 if (irelcount->r_addend == 0)
2308 {
2309 ((*_bfd_error_handler) (_("%s: 0x%lx: warning: bad count"),
8f615d07 2310 bfd_archive_filename (abfd),
252b5132
RH		 2311 (unsigned long) paddr));
2312 continue;
2313 }
2314
2315 --irelcount->r_addend;
2316
2317 /* If there are no more uses, we can delete the address. Reload
067653c5
AM		 2318 the address from irelfn, in case it was changed by the
2319 previous call to sh_elf_relax_delete_bytes. */
252b5132
RH		 2320 if (irelcount->r_addend == 0)
2321 {
2322 if (! sh_elf_relax_delete_bytes (abfd, sec, irelfn->r_offset, 4))
2323 goto error_return;
2324 }
2325
2326 /* We've done all we can with that function call. */
2327 }
2328
2329 /* Look for load and store instructions that we can align on four
2330 byte boundaries. */
bdfaef52
JR		 2331 if ((elf_elfheader (abfd)->e_flags & EF_SH_MACH_MASK) != EF_SH4
2332 && have_code)
252b5132 2333 {
b34976b6 2334 bfd_boolean swapped;
252b5132
RH		 2335
2336 /* Get the section contents. */
2337 if (contents == NULL)
2338 {
2339 if (elf_section_data (sec)->this_hdr.contents != NULL)
2340 contents = elf_section_data (sec)->this_hdr.contents;
2341 else
2342 {
2343 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
2344 if (contents == NULL)
2345 goto error_return;
252b5132
RH		 2346
2347 if (! bfd_get_section_contents (abfd, sec, contents,
2348 (file_ptr) 0, sec->_raw_size))
2349 goto error_return;
2350 }
2351 }
2352
2353 if (! sh_elf_align_loads (abfd, sec, internal_relocs, contents,
2354 &swapped))
2355 goto error_return;
2356
2357 if (swapped)
2358 {
2359 elf_section_data (sec)->relocs = internal_relocs;
252b5132 2360 elf_section_data (sec)->this_hdr.contents = contents;
6cdc0ccc 2361 symtab_hdr->contents = (unsigned char *) isymbuf;
252b5132
RH		 2362 }
2363 }
2364
6cdc0ccc
AM		 2365 if (isymbuf != NULL
2366 && symtab_hdr->contents != (unsigned char *) isymbuf)
252b5132
RH		 2367 {
2368 if (! link_info->keep_memory)
6cdc0ccc 2369 free (isymbuf);
252b5132
RH		 2370 else
2371 {
6cdc0ccc
AM		 2372 /* Cache the symbols for elf_link_input_bfd. */
2373 symtab_hdr->contents = (unsigned char *) isymbuf;
252b5132 2374 }
9ad5cbcf
AM		 2375 }
2376
6cdc0ccc
AM		 2377 if (contents != NULL
2378 && elf_section_data (sec)->this_hdr.contents != contents)
252b5132
RH		 2379 {
2380 if (! link_info->keep_memory)
6cdc0ccc
AM		 2381 free (contents);
2382 else
252b5132 2383 {
6cdc0ccc
AM		 2384 /* Cache the section contents for elf_link_input_bfd. */
2385 elf_section_data (sec)->this_hdr.contents = contents;
252b5132 2386 }
252b5132
RH		 2387 }
2388
6cdc0ccc
AM		 2389 if (internal_relocs != NULL
2390 && elf_section_data (sec)->relocs != internal_relocs)
2391 free (internal_relocs);
2392
b34976b6 2393 return TRUE;
252b5132
RH		 2394
2395 error_return:
6cdc0ccc
AM		 2396 if (isymbuf != NULL
2397 && symtab_hdr->contents != (unsigned char *) isymbuf)
2398 free (isymbuf);
2399 if (contents != NULL
2400 && elf_section_data (sec)->this_hdr.contents != contents)
2401 free (contents);
2402 if (internal_relocs != NULL
2403 && elf_section_data (sec)->relocs != internal_relocs)
2404 free (internal_relocs);
9ad5cbcf 2405
b34976b6 2406 return FALSE;
252b5132
RH		 2407}
2408
2409/* Delete some bytes from a section while relaxing. FIXME: There is a
2410 lot of duplication between this function and sh_relax_delete_bytes
2411 in coff-sh.c. */
2412
b34976b6 2413static bfd_boolean
252b5132
RH		 2414sh_elf_relax_delete_bytes (abfd, sec, addr, count)
2415 bfd *abfd;
2416 asection *sec;
2417 bfd_vma addr;
2418 int count;
2419{
2420 Elf_Internal_Shdr *symtab_hdr;
9ad5cbcf 2421 unsigned int sec_shndx;
252b5132
RH		 2422 bfd_byte *contents;
2423 Elf_Internal_Rela *irel, *irelend;
2424 Elf_Internal_Rela *irelalign;
2425 bfd_vma toaddr;
6cdc0ccc 2426 Elf_Internal_Sym *isymbuf, *isym, *isymend;
9ad5cbcf
AM		 2427 struct elf_link_hash_entry **sym_hashes;
2428 struct elf_link_hash_entry **end_hashes;
2429 unsigned int symcount;
252b5132
RH		 2430 asection *o;
2431
2432 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6cdc0ccc 2433 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
9ad5cbcf
AM		 2434
2435 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
252b5132
RH		 2436
2437 contents = elf_section_data (sec)->this_hdr.contents;
2438
2439 /* The deletion must stop at the next ALIGN reloc for an aligment
2440 power larger than the number of bytes we are deleting. */
2441
2442 irelalign = NULL;
2443 toaddr = sec->_cooked_size;
2444
2445 irel = elf_section_data (sec)->relocs;
2446 irelend = irel + sec->reloc_count;
2447 for (; irel < irelend; irel++)
2448 {
2449 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_ALIGN
2450 && irel->r_offset > addr
2451 && count < (1 << irel->r_addend))
2452 {
2453 irelalign = irel;
2454 toaddr = irel->r_offset;
2455 break;
2456 }
2457 }
2458
2459 /* Actually delete the bytes. */
dc810e39
AM		 2460 memmove (contents + addr, contents + addr + count,
2461 (size_t) (toaddr - addr - count));
252b5132
RH		 2462 if (irelalign == NULL)
2463 sec->_cooked_size -= count;
2464 else
2465 {
2466 int i;
2467
2468#define NOP_OPCODE (0x0009)
2469
2470 BFD_ASSERT ((count & 1) == 0);
2471 for (i = 0; i < count; i += 2)
dc810e39 2472 bfd_put_16 (abfd, (bfd_vma) NOP_OPCODE, contents + toaddr - count + i);
252b5132
RH		 2473 }
2474
2475 /* Adjust all the relocs. */
2476 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
2477 {
2478 bfd_vma nraddr, stop;
2479 bfd_vma start = 0;
2480 int insn = 0;
252b5132
RH		 2481 int off, adjust, oinsn;
2482 bfd_signed_vma voff = 0;
b34976b6 2483 bfd_boolean overflow;
252b5132
RH		 2484
2485 /* Get the new reloc address. */
2486 nraddr = irel->r_offset;
2487 if ((irel->r_offset > addr
2488 && irel->r_offset < toaddr)
2489 || (ELF32_R_TYPE (irel->r_info) == (int) R_SH_ALIGN
2490 && irel->r_offset == toaddr))
2491 nraddr -= count;
2492
2493 /* See if this reloc was for the bytes we have deleted, in which
2494 case we no longer care about it. Don't delete relocs which
2495 represent addresses, though. */
2496 if (irel->r_offset >= addr
2497 && irel->r_offset < addr + count
2498 && ELF32_R_TYPE (irel->r_info) != (int) R_SH_ALIGN
2499 && ELF32_R_TYPE (irel->r_info) != (int) R_SH_CODE
2500 && ELF32_R_TYPE (irel->r_info) != (int) R_SH_DATA
2501 && ELF32_R_TYPE (irel->r_info) != (int) R_SH_LABEL)
2502 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2503 (int) R_SH_NONE);
2504
2505 /* If this is a PC relative reloc, see if the range it covers
067653c5 2506 includes the bytes we have deleted. */
252b5132
RH		 2507 switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
2508 {
2509 default:
2510 break;
2511
2512 case R_SH_DIR8WPN:
2513 case R_SH_IND12W:
2514 case R_SH_DIR8WPZ:
2515 case R_SH_DIR8WPL:
2516 start = irel->r_offset;
2517 insn = bfd_get_16 (abfd, contents + nraddr);
2518 break;
2519 }
2520
2521 switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
2522 {
2523 default:
2524 start = stop = addr;
2525 break;
2526
2527 case R_SH_DIR32:
2528 /* If this reloc is against a symbol defined in this
067653c5
AM		 2529 section, and the symbol will not be adjusted below, we
2530 must check the addend to see it will put the value in
2531 range to be adjusted, and hence must be changed. */
252b5132
RH		 2532 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2533 {
6cdc0ccc
AM		 2534 isym = isymbuf + ELF32_R_SYM (irel->r_info);
2535 if (isym->st_shndx == sec_shndx
2536 && (isym->st_value <= addr
2537 || isym->st_value >= toaddr))
252b5132
RH		 2538 {
2539 bfd_vma val;
2540
2541 val = bfd_get_32 (abfd, contents + nraddr);
6cdc0ccc 2542 val += isym->st_value;
252b5132
RH		 2543 if (val > addr && val < toaddr)
2544 bfd_put_32 (abfd, val - count, contents + nraddr);
2545 }
2546 }
2547 start = stop = addr;
2548 break;
2549
2550 case R_SH_DIR8WPN:
2551 off = insn & 0xff;
2552 if (off & 0x80)
2553 off -= 0x100;
2554 stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
2555 break;
2556
2557 case R_SH_IND12W:
bdfaef52
JR		 2558 off = insn & 0xfff;
2559 if (! off)
2560 {
2561 /* This has been made by previous relaxation. Since the
2562 relocation will be against an external symbol, the
2563 final relocation will just do the right thing. */
2564 start = stop = addr;
2565 }
252b5132
RH		 2566 else
2567 {
252b5132
RH		 2568 if (off & 0x800)
2569 off -= 0x1000;
2570 stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2);
bdfaef52
JR		 2571
2572 /* The addend will be against the section symbol, thus
2573 for adjusting the addend, the relevant start is the
2574 start of the section.
2575 N.B. If we want to abandom in-place changes here and
2576 test directly using symbol + addend, we have to take into
2577 account that the addend has already been adjusted by -4. */
2578 if (stop > addr && stop < toaddr)
2579 irel->r_addend -= count;
252b5132
RH		 2580 }
2581 break;
2582
2583 case R_SH_DIR8WPZ:
2584 off = insn & 0xff;
2585 stop = start + 4 + off * 2;
2586 break;
2587
2588 case R_SH_DIR8WPL:
2589 off = insn & 0xff;
435b1e90 2590 stop = (start & ~(bfd_vma) 3) + 4 + off * 4;
252b5132
RH		 2591 break;
2592
2593 case R_SH_SWITCH8:
2594 case R_SH_SWITCH16:
2595 case R_SH_SWITCH32:
2596 /* These relocs types represent
2597 .word L2-L1
06e1ba78 2598 The r_addend field holds the difference between the reloc
252b5132
RH		 2599 address and L1. That is the start of the reloc, and
2600 adding in the contents gives us the top. We must adjust
06e1ba78
JR		 2601 both the r_offset field and the section contents.
2602 N.B. in gas / coff bfd, the elf bfd r_addend is called r_offset,
2603 and the elf bfd r_offset is called r_vaddr. */
252b5132 2604
06e1ba78
JR		 2605 stop = irel->r_offset;
2606 start = (bfd_vma) ((bfd_signed_vma) stop - (long) irel->r_addend);
252b5132
RH		 2607
2608 if (start > addr
2609 && start < toaddr
2610 && (stop <= addr || stop >= toaddr))
2611 irel->r_addend += count;
2612 else if (stop > addr
2613 && stop < toaddr
2614 && (start <= addr || start >= toaddr))
2615 irel->r_addend -= count;
2616
252b5132
RH		 2617 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_SWITCH16)
2618 voff = bfd_get_signed_16 (abfd, contents + nraddr);
2619 else if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_SWITCH8)
2620 voff = bfd_get_8 (abfd, contents + nraddr);
2621 else
2622 voff = bfd_get_signed_32 (abfd, contents + nraddr);
2623 stop = (bfd_vma) ((bfd_signed_vma) start + voff);
2624
2625 break;
2626
2627 case R_SH_USES:
2628 start = irel->r_offset;
2629 stop = (bfd_vma) ((bfd_signed_vma) start
2630 + (long) irel->r_addend
2631 + 4);
2632 break;
2633 }
2634
2635 if (start > addr
2636 && start < toaddr
2637 && (stop <= addr || stop >= toaddr))
2638 adjust = count;
2639 else if (stop > addr
2640 && stop < toaddr
2641 && (start <= addr || start >= toaddr))
2642 adjust = - count;
2643 else
2644 adjust = 0;
2645
2646 if (adjust != 0)
2647 {
2648 oinsn = insn;
b34976b6 2649 overflow = FALSE;
252b5132
RH		 2650 switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info))
2651 {
2652 default:
2653 abort ();
2654 break;
2655
2656 case R_SH_DIR8WPN:
2657 case R_SH_DIR8WPZ:
2658 insn += adjust / 2;
2659 if ((oinsn & 0xff00) != (insn & 0xff00))
b34976b6 2660 overflow = TRUE;
dc810e39 2661 bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr);
252b5132
RH		 2662 break;
2663
2664 case R_SH_IND12W:
2665 insn += adjust / 2;
2666 if ((oinsn & 0xf000) != (insn & 0xf000))
b34976b6 2667 overflow = TRUE;
dc810e39 2668 bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr);
252b5132
RH		 2669 break;
2670
2671 case R_SH_DIR8WPL:
2672 BFD_ASSERT (adjust == count || count >= 4);
2673 if (count >= 4)
2674 insn += adjust / 4;
2675 else
2676 {
2677 if ((irel->r_offset & 3) == 0)
2678 ++insn;
2679 }
2680 if ((oinsn & 0xff00) != (insn & 0xff00))
b34976b6 2681 overflow = TRUE;
dc810e39 2682 bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr);
252b5132
RH		 2683 break;
2684
851cde10
JR		 2685 case R_SH_SWITCH8:
2686 voff += adjust;
2687 if (voff < 0 || voff >= 0xff)
b34976b6 2688 overflow = TRUE;
851cde10
JR		 2689 bfd_put_8 (abfd, voff, contents + nraddr);
2690 break;
2691
252b5132
RH		 2692 case R_SH_SWITCH16:
2693 voff += adjust;
2694 if (voff < - 0x8000 || voff >= 0x8000)
b34976b6 2695 overflow = TRUE;
dc810e39 2696 bfd_put_signed_16 (abfd, (bfd_vma) voff, contents + nraddr);
252b5132
RH		 2697 break;
2698
2699 case R_SH_SWITCH32:
2700 voff += adjust;
dc810e39 2701 bfd_put_signed_32 (abfd, (bfd_vma) voff, contents + nraddr);
252b5132
RH		 2702 break;
2703
2704 case R_SH_USES:
2705 irel->r_addend += adjust;
2706 break;
2707 }
2708
2709 if (overflow)
2710 {
2711 ((*_bfd_error_handler)
2712 (_("%s: 0x%lx: fatal: reloc overflow while relaxing"),
8f615d07 2713 bfd_archive_filename (abfd), (unsigned long) irel->r_offset));
252b5132 2714 bfd_set_error (bfd_error_bad_value);
b34976b6 2715 return FALSE;
252b5132
RH		 2716 }
2717 }
2718
2719 irel->r_offset = nraddr;
2720 }
2721
2722 /* Look through all the other sections. If there contain any IMM32
2723 relocs against internal symbols which we are not going to adjust
2724 below, we may need to adjust the addends. */
2725 for (o = abfd->sections; o != NULL; o = o->next)
2726 {
2727 Elf_Internal_Rela *internal_relocs;
2728 Elf_Internal_Rela *irelscan, *irelscanend;
2729 bfd_byte *ocontents;
2730
2731 if (o == sec
2732 || (o->flags & SEC_RELOC) == 0
2733 || o->reloc_count == 0)
2734 continue;
2735
2736 /* We always cache the relocs. Perhaps, if info->keep_memory is
b34976b6 2737 FALSE, we should free them, if we are permitted to, when we
067653c5 2738 leave sh_coff_relax_section. */
45d6a902 2739 internal_relocs = (_bfd_elf_link_read_relocs
252b5132 2740 (abfd, o, (PTR) NULL, (Elf_Internal_Rela *) NULL,
b34976b6 2741 TRUE));
252b5132 2742 if (internal_relocs == NULL)
b34976b6 2743 return FALSE;
252b5132
RH		 2744
2745 ocontents = NULL;
2746 irelscanend = internal_relocs + o->reloc_count;
2747 for (irelscan = internal_relocs; irelscan < irelscanend; irelscan++)
2748 {
084aa3aa
JR		 2749 /* Dwarf line numbers use R_SH_SWITCH32 relocs. */
2750 if (ELF32_R_TYPE (irelscan->r_info) == (int) R_SH_SWITCH32)
2751 {
2752 bfd_vma start, stop;
2753 bfd_signed_vma voff;
2754
2755 if (ocontents == NULL)
2756 {
2757 if (elf_section_data (o)->this_hdr.contents != NULL)
2758 ocontents = elf_section_data (o)->this_hdr.contents;
2759 else
2760 {
2761 /* We always cache the section contents.
b34976b6 2762 Perhaps, if info->keep_memory is FALSE, we
067653c5
AM		 2763 should free them, if we are permitted to,
2764 when we leave sh_coff_relax_section. */
084aa3aa
JR		 2765 ocontents = (bfd_byte *) bfd_malloc (o->_raw_size);
2766 if (ocontents == NULL)
b34976b6 2767 return FALSE;
084aa3aa
JR		 2768 if (! bfd_get_section_contents (abfd, o, ocontents,
2769 (file_ptr) 0,
2770 o->_raw_size))
b34976b6 2771 return FALSE;
084aa3aa
JR		 2772 elf_section_data (o)->this_hdr.contents = ocontents;
2773 }
2774 }
2775
2776 stop = irelscan->r_offset;
2777 start
2778 = (bfd_vma) ((bfd_signed_vma) stop - (long) irelscan->r_addend);
2779
2780 /* STOP is in a different section, so it won't change. */
2781 if (start > addr && start < toaddr)
2782 irelscan->r_addend += count;
2783
2784 voff = bfd_get_signed_32 (abfd, ocontents + irelscan->r_offset);
2785 stop = (bfd_vma) ((bfd_signed_vma) start + voff);
2786
2787 if (start > addr
2788 && start < toaddr
2789 && (stop <= addr || stop >= toaddr))
dc810e39 2790 bfd_put_signed_32 (abfd, (bfd_vma) voff + count,
084aa3aa
JR		 2791 ocontents + irelscan->r_offset);
2792 else if (stop > addr
2793 && stop < toaddr
2794 && (start <= addr || start >= toaddr))
dc810e39 2795 bfd_put_signed_32 (abfd, (bfd_vma) voff - count,
084aa3aa
JR		 2796 ocontents + irelscan->r_offset);
2797 }
2798
252b5132
RH		 2799 if (ELF32_R_TYPE (irelscan->r_info) != (int) R_SH_DIR32)
2800 continue;
2801
2802 if (ELF32_R_SYM (irelscan->r_info) >= symtab_hdr->sh_info)
2803 continue;
2804
252b5132 2805
6cdc0ccc
AM		 2806 isym = isymbuf + ELF32_R_SYM (irelscan->r_info);
2807 if (isym->st_shndx == sec_shndx
2808 && (isym->st_value <= addr
2809 || isym->st_value >= toaddr))
252b5132
RH		 2810 {
2811 bfd_vma val;
2812
2813 if (ocontents == NULL)
2814 {
2815 if (elf_section_data (o)->this_hdr.contents != NULL)
2816 ocontents = elf_section_data (o)->this_hdr.contents;
2817 else
2818 {
2819 /* We always cache the section contents.
b34976b6 2820 Perhaps, if info->keep_memory is FALSE, we
067653c5
AM		 2821 should free them, if we are permitted to,
2822 when we leave sh_coff_relax_section. */
252b5132
RH		 2823 ocontents = (bfd_byte *) bfd_malloc (o->_raw_size);
2824 if (ocontents == NULL)
b34976b6 2825 return FALSE;
252b5132
RH		 2826 if (! bfd_get_section_contents (abfd, o, ocontents,
2827 (file_ptr) 0,
2828 o->_raw_size))
b34976b6 2829 return FALSE;
252b5132
RH		 2830 elf_section_data (o)->this_hdr.contents = ocontents;
2831 }
2832 }
2833
2834 val = bfd_get_32 (abfd, ocontents + irelscan->r_offset);
6cdc0ccc 2835 val += isym->st_value;
252b5132
RH		 2836 if (val > addr && val < toaddr)
2837 bfd_put_32 (abfd, val - count,
2838 ocontents + irelscan->r_offset);
2839 }
2840 }
2841 }
2842
2843 /* Adjust the local symbols defined in this section. */
6cdc0ccc
AM		 2844 isymend = isymbuf + symtab_hdr->sh_info;
2845 for (isym = isymbuf; isym < isymend; isym++)
252b5132 2846 {
6cdc0ccc
AM		 2847 if (isym->st_shndx == sec_shndx
2848 && isym->st_value > addr
2849 && isym->st_value < toaddr)
2850 isym->st_value -= count;
252b5132
RH		 2851 }
2852
2853 /* Now adjust the global symbols defined in this section. */
9ad5cbcf
AM		 2854 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2855 - symtab_hdr->sh_info);
2856 sym_hashes = elf_sym_hashes (abfd);
2857 end_hashes = sym_hashes + symcount;
2858 for (; sym_hashes < end_hashes; sym_hashes++)
252b5132 2859 {
9ad5cbcf
AM		 2860 struct elf_link_hash_entry *sym_hash = *sym_hashes;
2861 if ((sym_hash->root.type == bfd_link_hash_defined
2862 || sym_hash->root.type == bfd_link_hash_defweak)
2863 && sym_hash->root.u.def.section == sec
2864 && sym_hash->root.u.def.value > addr
2865 && sym_hash->root.u.def.value < toaddr)
252b5132 2866 {
9ad5cbcf 2867 sym_hash->root.u.def.value -= count;
252b5132
RH		 2868 }
2869 }
2870
2871 /* See if we can move the ALIGN reloc forward. We have adjusted
2872 r_offset for it already. */
2873 if (irelalign != NULL)
2874 {
2875 bfd_vma alignto, alignaddr;
2876
2877 alignto = BFD_ALIGN (toaddr, 1 << irelalign->r_addend);
2878 alignaddr = BFD_ALIGN (irelalign->r_offset,
2879 1 << irelalign->r_addend);
2880 if (alignto != alignaddr)
2881 {
2882 /* Tail recursion. */
2883 return sh_elf_relax_delete_bytes (abfd, sec, alignaddr,
dc810e39 2884 (int) (alignto - alignaddr));
252b5132
RH		 2885 }
2886 }
2887
b34976b6 2888 return TRUE;
252b5132
RH		 2889}
2890
2891/* Look for loads and stores which we can align to four byte
2892 boundaries. This is like sh_align_loads in coff-sh.c. */
2893
b34976b6 2894static bfd_boolean
252b5132 2895sh_elf_align_loads (abfd, sec, internal_relocs, contents, pswapped)
518313c3 2896 bfd *abfd ATTRIBUTE_UNUSED;
252b5132
RH		 2897 asection *sec;
2898 Elf_Internal_Rela *internal_relocs;
518313c3 2899 bfd_byte *contents ATTRIBUTE_UNUSED;
b34976b6 2900 bfd_boolean *pswapped;
252b5132
RH		 2901{
2902 Elf_Internal_Rela *irel, *irelend;
2903 bfd_vma *labels = NULL;
2904 bfd_vma *label, *label_end;
dc810e39 2905 bfd_size_type amt;
252b5132 2906
b34976b6 2907 *pswapped = FALSE;
252b5132
RH		 2908
2909 irelend = internal_relocs + sec->reloc_count;
2910
2911 /* Get all the addresses with labels on them. */
dc810e39
AM		 2912 amt = sec->reloc_count;
2913 amt *= sizeof (bfd_vma);
2914 labels = (bfd_vma *) bfd_malloc (amt);
252b5132
RH		 2915 if (labels == NULL)
2916 goto error_return;
2917 label_end = labels;
2918 for (irel = internal_relocs; irel < irelend; irel++)
2919 {
2920 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_LABEL)
2921 {
2922 *label_end = irel->r_offset;
2923 ++label_end;
2924 }
2925 }
2926
2927 /* Note that the assembler currently always outputs relocs in
2928 address order. If that ever changes, this code will need to sort
2929 the label values and the relocs. */
2930
2931 label = labels;
2932
2933 for (irel = internal_relocs; irel < irelend; irel++)
2934 {
2935 bfd_vma start, stop;
2936
2937 if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_CODE)
2938 continue;
2939
2940 start = irel->r_offset;
2941
2942 for (irel++; irel < irelend; irel++)
2943 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_DATA)
2944 break;
2945 if (irel < irelend)
2946 stop = irel->r_offset;
2947 else
2948 stop = sec->_cooked_size;
2949
2950 if (! _bfd_sh_align_load_span (abfd, sec, contents, sh_elf_swap_insns,
2951 (PTR) internal_relocs, &label,
2952 label_end, start, stop, pswapped))
2953 goto error_return;
2954 }
2955
2956 free (labels);
2957
b34976b6 2958 return TRUE;
252b5132
RH		 2959
2960 error_return:
2961 if (labels != NULL)
2962 free (labels);
b34976b6 2963 return FALSE;
252b5132
RH		 2964}
2965
2966/* Swap two SH instructions. This is like sh_swap_insns in coff-sh.c. */
2967
b34976b6 2968static bfd_boolean
252b5132
RH		 2969sh_elf_swap_insns (abfd, sec, relocs, contents, addr)
2970 bfd *abfd;
2971 asection *sec;
2972 PTR relocs;
2973 bfd_byte *contents;
2974 bfd_vma addr;
2975{
2976 Elf_Internal_Rela *internal_relocs = (Elf_Internal_Rela *) relocs;
2977 unsigned short i1, i2;
2978 Elf_Internal_Rela *irel, *irelend;
2979
2980 /* Swap the instructions themselves. */
2981 i1 = bfd_get_16 (abfd, contents + addr);
2982 i2 = bfd_get_16 (abfd, contents + addr + 2);
dc810e39
AM		 2983 bfd_put_16 (abfd, (bfd_vma) i2, contents + addr);
2984 bfd_put_16 (abfd, (bfd_vma) i1, contents + addr + 2);
252b5132
RH		 2985
2986 /* Adjust all reloc addresses. */
2987 irelend = internal_relocs + sec->reloc_count;
2988 for (irel = internal_relocs; irel < irelend; irel++)
2989 {
2990 enum elf_sh_reloc_type type;
2991 int add;
2992
2993 /* There are a few special types of relocs that we don't want to
067653c5
AM		 2994 adjust. These relocs do not apply to the instruction itself,
2995 but are only associated with the address. */
252b5132
RH		 2996 type = (enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info);
2997 if (type == R_SH_ALIGN
2998 || type == R_SH_CODE
2999 || type == R_SH_DATA
3000 || type == R_SH_LABEL)
3001 continue;
3002
3003 /* If an R_SH_USES reloc points to one of the addresses being
067653c5
AM		 3004 swapped, we must adjust it. It would be incorrect to do this
3005 for a jump, though, since we want to execute both
3006 instructions after the jump. (We have avoided swapping
3007 around a label, so the jump will not wind up executing an
3008 instruction it shouldn't). */
252b5132
RH		 3009 if (type == R_SH_USES)
3010 {
3011 bfd_vma off;
3012
3013 off = irel->r_offset + 4 + irel->r_addend;
3014 if (off == addr)
3015 irel->r_offset += 2;
3016 else if (off == addr + 2)
3017 irel->r_offset -= 2;
3018 }
3019
3020 if (irel->r_offset == addr)
3021 {
3022 irel->r_offset += 2;
3023 add = -2;
3024 }
3025 else if (irel->r_offset == addr + 2)
3026 {
3027 irel->r_offset -= 2;
3028 add = 2;
3029 }
3030 else
3031 add = 0;
3032
3033 if (add != 0)
3034 {
3035 bfd_byte *loc;
3036 unsigned short insn, oinsn;
b34976b6 3037 bfd_boolean overflow;
252b5132
RH		 3038
3039 loc = contents + irel->r_offset;
b34976b6 3040 overflow = FALSE;
252b5132
RH		 3041 switch (type)
3042 {
3043 default:
3044 break;
3045
3046 case R_SH_DIR8WPN:
3047 case R_SH_DIR8WPZ:
3048 insn = bfd_get_16 (abfd, loc);
3049 oinsn = insn;
3050 insn += add / 2;
3051 if ((oinsn & 0xff00) != (insn & 0xff00))
b34976b6 3052 overflow = TRUE;
dc810e39 3053 bfd_put_16 (abfd, (bfd_vma) insn, loc);
252b5132
RH		 3054 break;
3055
3056 case R_SH_IND12W:
3057 insn = bfd_get_16 (abfd, loc);
3058 oinsn = insn;
3059 insn += add / 2;
3060 if ((oinsn & 0xf000) != (insn & 0xf000))
b34976b6 3061 overflow = TRUE;
dc810e39 3062 bfd_put_16 (abfd, (bfd_vma) insn, loc);
252b5132
RH		 3063 break;
3064
3065 case R_SH_DIR8WPL:
3066 /* This reloc ignores the least significant 3 bits of
067653c5
AM		 3067 the program counter before adding in the offset.
3068 This means that if ADDR is at an even address, the
3069 swap will not affect the offset. If ADDR is an at an
3070 odd address, then the instruction will be crossing a
3071 four byte boundary, and must be adjusted. */
252b5132
RH		 3072 if ((addr & 3) != 0)
3073 {
3074 insn = bfd_get_16 (abfd, loc);
3075 oinsn = insn;
3076 insn += add / 2;
3077 if ((oinsn & 0xff00) != (insn & 0xff00))
b34976b6 3078 overflow = TRUE;
dc810e39 3079 bfd_put_16 (abfd, (bfd_vma) insn, loc);
252b5132
RH		 3080 }
3081
3082 break;
3083 }
3084
3085 if (overflow)
3086 {
3087 ((*_bfd_error_handler)
3088 (_("%s: 0x%lx: fatal: reloc overflow while relaxing"),
8f615d07 3089 bfd_archive_filename (abfd), (unsigned long) irel->r_offset));
252b5132 3090 bfd_set_error (bfd_error_bad_value);
b34976b6 3091 return FALSE;
252b5132
RH		 3092 }
3093 }
3094 }
3095
b34976b6 3096 return TRUE;
252b5132
RH		 3097}
3098\f
fbca6ad9
AO		 3099#ifdef INCLUDE_SHMEDIA
3100
3101/* The size in bytes of an entry in the procedure linkage table. */
3102
3103#define PLT_ENTRY_SIZE 64
3104
3105/* First entry in an absolute procedure linkage table look like this. */
3106
3107static const bfd_byte elf_sh_plt0_entry_be[PLT_ENTRY_SIZE] =
3108{
3109 0xcc, 0x00, 0x01, 0x10, /* movi .got.plt >> 16, r17 */
3110 0xc8, 0x00, 0x01, 0x10, /* shori .got.plt & 65535, r17 */
3111 0x89, 0x10, 0x09, 0x90, /* ld.l r17, 8, r25 */
c8614e8e 3112 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
fbca6ad9
AO		 3113 0x89, 0x10, 0x05, 0x10, /* ld.l r17, 4, r17 */
3114 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
3115 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3116 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3117 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3118 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3119 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3120 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3121 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3122 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3123 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3124 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3125};
3126
3127static const bfd_byte elf_sh_plt0_entry_le[PLT_ENTRY_SIZE] =
3128{
3129 0x10, 0x01, 0x00, 0xcc, /* movi .got.plt >> 16, r17 */
3130 0x10, 0x01, 0x00, 0xc8, /* shori .got.plt & 65535, r17 */
3131 0x90, 0x09, 0x10, 0x89, /* ld.l r17, 8, r25 */
c8614e8e 3132 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
fbca6ad9
AO		 3133 0x10, 0x05, 0x10, 0x89, /* ld.l r17, 4, r17 */
3134 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
3135 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3136 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3137 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3138 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3139 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3140 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3141 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3142 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3143 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3144 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3145};
3146
3147/* Sebsequent entries in an absolute procedure linkage table look like
3148 this. */
3149
3150static const bfd_byte elf_sh_plt_entry_be[PLT_ENTRY_SIZE] =
3151{
3152 0xcc, 0x00, 0x01, 0x90, /* movi nameN-in-GOT >> 16, r25 */
3153 0xc8, 0x00, 0x01, 0x90, /* shori nameN-in-GOT & 65535, r25 */
3154 0x89, 0x90, 0x01, 0x90, /* ld.l r25, 0, r25 */
3155 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
3156 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
3157 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3158 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3159 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3160 0xcc, 0x00, 0x01, 0x90, /* movi .PLT0 >> 16, r25 */
3161 0xc8, 0x00, 0x01, 0x90, /* shori .PLT0 & 65535, r25 */
3162 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
3163 0xcc, 0x00, 0x01, 0x50, /* movi reloc-offset >> 16, r21 */
3164 0xc8, 0x00, 0x01, 0x50, /* shori reloc-offset & 65535, r21 */
3165 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
3166 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3167 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3168};
3169
3170static const bfd_byte elf_sh_plt_entry_le[PLT_ENTRY_SIZE] =
3171{
3172 0x90, 0x01, 0x00, 0xcc, /* movi nameN-in-GOT >> 16, r25 */
3173 0x90, 0x01, 0x00, 0xc8, /* shori nameN-in-GOT & 65535, r25 */
3174 0x90, 0x01, 0x90, 0x89, /* ld.l r25, 0, r25 */
3175 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
3176 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
3177 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3178 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3179 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3180 0x90, 0x01, 0x00, 0xcc, /* movi .PLT0 >> 16, r25 */
3181 0x90, 0x01, 0x00, 0xc8, /* shori .PLT0 & 65535, r25 */
3182 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
3183 0x50, 0x01, 0x00, 0xcc, /* movi reloc-offset >> 16, r21 */
3184 0x50, 0x01, 0x00, 0xc8, /* shori reloc-offset & 65535, r21 */
3185 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
3186 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3187 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3188};
3189
3190/* Entries in a PIC procedure linkage table look like this. */
3191
3192static const bfd_byte elf_sh_pic_plt_entry_be[PLT_ENTRY_SIZE] =
3193{
3194 0xcc, 0x00, 0x01, 0x90, /* movi nameN@GOT >> 16, r25 */
3195 0xc8, 0x00, 0x01, 0x90, /* shori nameN@GOT & 65535, r25 */
3196 0x40, 0xc2, 0x65, 0x90, /* ldx.l r12, r25, r25 */
3197 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
3198 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
3199 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3200 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3201 0x6f, 0xf0, 0xff, 0xf0, /* nop */
3202 0xce, 0x00, 0x01, 0x10, /* movi -GOT_BIAS, r17 */
0a4ef3f4 3203 0x00, 0xc8, 0x45, 0x10, /* add.l r12, r17, r17 */
fbca6ad9
AO		 3204 0x89, 0x10, 0x09, 0x90, /* ld.l r17, 8, r25 */
3205 0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
3206 0x89, 0x10, 0x05, 0x10, /* ld.l r17, 4, r17 */
3207 0xcc, 0x00, 0x01, 0x50, /* movi reloc-offset >> 16, r21 */
3208 0xc8, 0x00, 0x01, 0x50, /* shori reloc-offset & 65535, r21 */
3209 0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
3210};
3211
3212static const bfd_byte elf_sh_pic_plt_entry_le[PLT_ENTRY_SIZE] =
3213{
3214 0x90, 0x01, 0x00, 0xcc, /* movi nameN@GOT >> 16, r25 */
3215 0x90, 0x01, 0x00, 0xc8, /* shori nameN@GOT & 65535, r25 */
3216 0x90, 0x65, 0xc2, 0x40, /* ldx.l r12, r25, r25 */
3217 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
3218 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
3219 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3220 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3221 0xf0, 0xff, 0xf0, 0x6f, /* nop */
3222 0x10, 0x01, 0x00, 0xce, /* movi -GOT_BIAS, r17 */
0a4ef3f4 3223 0x10, 0x45, 0xc8, 0x00, /* add.l r12, r17, r17 */
fbca6ad9
AO		 3224 0x90, 0x09, 0x10, 0x89, /* ld.l r17, 8, r25 */
3225 0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
3226 0x10, 0x05, 0x10, 0x89, /* ld.l r17, 4, r17 */
3227 0x50, 0x01, 0x00, 0xcc, /* movi reloc-offset >> 16, r21 */
3228 0x50, 0x01, 0x00, 0xc8, /* shori reloc-offset & 65535, r21 */
3229 0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
3230};
3231
3232static const bfd_byte *elf_sh_plt0_entry;
3233static const bfd_byte *elf_sh_plt_entry;
3234static const bfd_byte *elf_sh_pic_plt_entry;
3235
3236/* Return size of a PLT entry. */
3237#define elf_sh_sizeof_plt(info) PLT_ENTRY_SIZE
3238
3239/* Return offset of the PLT0 address in an absolute PLT entry. */
3240#define elf_sh_plt_plt0_offset(info) 32
3241
3242/* Return offset of the linker in PLT0 entry. */
3243#define elf_sh_plt0_gotplt_offset(info) 0
3244
3245/* Return offset of the trampoline in PLT entry */
3246#define elf_sh_plt_temp_offset(info) 33 /* Add one because it's SHmedia. */
3247
3248/* Return offset of the symbol in PLT entry. */
3249#define elf_sh_plt_symbol_offset(info) 0
3250
3251/* Return offset of the relocation in PLT entry. */
3252#define elf_sh_plt_reloc_offset(info) (info->shared ? 52 : 44)
3253
3254inline static void
3255movi_shori_putval (output_bfd, value, addr)
3256 bfd *output_bfd;
3257 unsigned long value;
3258 char *addr;
3259{
3260 bfd_put_32 (output_bfd,
3261 bfd_get_32 (output_bfd, addr)
3262 | ((value >> 6) & 0x3fffc00),
3263 addr);
3264 bfd_put_32 (output_bfd,
3265 bfd_get_32 (output_bfd, addr + 4)
3266 | ((value << 10) & 0x3fffc00),
3267 addr + 4);
3268}
3269
3270#else
37c644f2 3271/* The size in bytes of an entry in the procedure linkage table. */
252b5132 3272
37c644f2
AO		 3273#define PLT_ENTRY_SIZE 28
3274
3275/* First entry in an absolute procedure linkage table look like this. */
3276
6c426cf3
NC		 3277#if 1
3278/* Note - this code has been "optimised" not to use r2. r2 is used by
3279 GCC to return the address of large strutcures, so it should not be
3280 corrupted here. This does mean however, that this PLT does not conform
3281 to the SH PIC ABI. That spec says that r0 contains the type of the PLT
3282 and r2 contains the GOT id. This version stores the GOT id in r0 and
3283 ignores the type. Loaders can easily detect this difference however,
3284 since the type will always be 0 or 8, and the GOT ids will always be
3285 greater than or equal to 12. */
3286static const bfd_byte elf_sh_plt0_entry_be[PLT_ENTRY_SIZE] =
3287{
3288 0xd0, 0x05, /* mov.l 2f,r0 */
3289 0x60, 0x02, /* mov.l @r0,r0 */
3290 0x2f, 0x06, /* mov.l r0,@-r15 */
3291 0xd0, 0x03, /* mov.l 1f,r0 */
3292 0x60, 0x02, /* mov.l @r0,r0 */
3293 0x40, 0x2b, /* jmp @r0 */
3294 0x60, 0xf6, /* mov.l @r15+,r0 */
3295 0x00, 0x09, /* nop */
3296 0x00, 0x09, /* nop */
3297 0x00, 0x09, /* nop */
3298 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
3299 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
3300};
3301
3302static const bfd_byte elf_sh_plt0_entry_le[PLT_ENTRY_SIZE] =
3303{
3304 0x05, 0xd0, /* mov.l 2f,r0 */
3305 0x02, 0x60, /* mov.l @r0,r0 */
3306 0x06, 0x2f, /* mov.l r0,@-r15 */
3307 0x03, 0xd0, /* mov.l 1f,r0 */
3308 0x02, 0x60, /* mov.l @r0,r0 */
3309 0x2b, 0x40, /* jmp @r0 */
3310 0xf6, 0x60, /* mov.l @r15+,r0 */
3311 0x09, 0x00, /* nop */
3312 0x09, 0x00, /* nop */
3313 0x09, 0x00, /* nop */
3314 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
3315 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
3316};
3317
3318/* Sebsequent entries in an absolute procedure linkage table look like
3319 this. */
3320
3321static const bfd_byte elf_sh_plt_entry_be[PLT_ENTRY_SIZE] =
3322{
3323 0xd0, 0x04, /* mov.l 1f,r0 */
3324 0x60, 0x02, /* mov.l @r0,r0 */
3325 0xd1, 0x02, /* mov.l 0f,r1 */
3326 0x40, 0x2b, /* jmp @r0 */
3327 0x60, 0x13, /* mov r1,r0 */
3328 0xd1, 0x03, /* mov.l 2f,r1 */
3329 0x40, 0x2b, /* jmp @r0 */
3330 0x00, 0x09, /* nop */
3331 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */
3332 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
3333 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
3334};
3335
3336static const bfd_byte elf_sh_plt_entry_le[PLT_ENTRY_SIZE] =
3337{
3338 0x04, 0xd0, /* mov.l 1f,r0 */
3339 0x02, 0x60, /* mov.l @r0,r0 */
3340 0x02, 0xd1, /* mov.l 0f,r1 */
3341 0x2b, 0x40, /* jmp @r0 */
3342 0x13, 0x60, /* mov r1,r0 */
3343 0x03, 0xd1, /* mov.l 2f,r1 */
3344 0x2b, 0x40, /* jmp @r0 */
3345 0x09, 0x00, /* nop */
3346 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */
3347 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
3348 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
3349};
3350
3351/* Entries in a PIC procedure linkage table look like this. */
3352
3353static const bfd_byte elf_sh_pic_plt_entry_be[PLT_ENTRY_SIZE] =
3354{
3355 0xd0, 0x04, /* mov.l 1f,r0 */
3356 0x00, 0xce, /* mov.l @(r0,r12),r0 */
3357 0x40, 0x2b, /* jmp @r0 */
3358 0x00, 0x09, /* nop */
3359 0x50, 0xc2, /* mov.l @(8,r12),r0 */
3360 0xd1, 0x03, /* mov.l 2f,r1 */
3361 0x40, 0x2b, /* jmp @r0 */
3362 0x50, 0xc1, /* mov.l @(4,r12),r0 */
3363 0x00, 0x09, /* nop */
3364 0x00, 0x09, /* nop */
3365 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
3366 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
3367};
3368
3369static const bfd_byte elf_sh_pic_plt_entry_le[PLT_ENTRY_SIZE] =
3370{
3371 0x04, 0xd0, /* mov.l 1f,r0 */
3372 0xce, 0x00, /* mov.l @(r0,r12),r0 */
3373 0x2b, 0x40, /* jmp @r0 */
3374 0x09, 0x00, /* nop */
3375 0xc2, 0x50, /* mov.l @(8,r12),r0 */
3376 0x03, 0xd1, /* mov.l 2f,r1 */
3377 0x2b, 0x40, /* jmp @r0 */
3378 0xc1, 0x50, /* mov.l @(4,r12),r0 */
3379 0x09, 0x00, /* nop */
3380 0x09, 0x00, /* nop */
3381 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
3382 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
3383};
3384
3385#else /* These are the old style PLT entries. */
38b1a46c
NC		 3386static const bfd_byte elf_sh_plt0_entry_be[PLT_ENTRY_SIZE] =
3387{
37c644f2
AO		 3388 0xd0, 0x04, /* mov.l 1f,r0 */
3389 0xd2, 0x05, /* mov.l 2f,r2 */
3390 0x60, 0x02, /* mov.l @r0,r0 */
3391 0x62, 0x22, /* mov.l @r2,r2 */
3392 0x40, 0x2b, /* jmp @r0 */
3393 0xe0, 0x00, /* mov #0,r0 */
3394 0x00, 0x09, /* nop */
3395 0x00, 0x09, /* nop */
3396 0x00, 0x09, /* nop */
3397 0x00, 0x09, /* nop */
3398 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
3399 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
3400};
252b5132 3401
38b1a46c
NC		 3402static const bfd_byte elf_sh_plt0_entry_le[PLT_ENTRY_SIZE] =
3403{
37c644f2
AO		 3404 0x04, 0xd0, /* mov.l 1f,r0 */
3405 0x05, 0xd2, /* mov.l 2f,r2 */
3406 0x02, 0x60, /* mov.l @r0,r0 */
3407 0x22, 0x62, /* mov.l @r2,r2 */
3408 0x2b, 0x40, /* jmp @r0 */
3409 0x00, 0xe0, /* mov #0,r0 */
3410 0x09, 0x00, /* nop */
3411 0x09, 0x00, /* nop */
3412 0x09, 0x00, /* nop */
3413 0x09, 0x00, /* nop */
3414 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */
3415 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */
3416};
252b5132 3417
37c644f2
AO		 3418/* Sebsequent entries in an absolute procedure linkage table look like
3419 this. */
252b5132 3420
38b1a46c
NC		 3421static const bfd_byte elf_sh_plt_entry_be[PLT_ENTRY_SIZE] =
3422{
37c644f2
AO		 3423 0xd0, 0x04, /* mov.l 1f,r0 */
3424 0x60, 0x02, /* mov.l @r0,r0 */
3425 0xd2, 0x02, /* mov.l 0f,r2 */
3426 0x40, 0x2b, /* jmp @r0 */
3427 0x60, 0x23, /* mov r2,r0 */
3428 0xd1, 0x03, /* mov.l 2f,r1 */
3429 0x40, 0x2b, /* jmp @r0 */
3430 0x00, 0x09, /* nop */
3431 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */
3432 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
3433 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
3434};
252b5132 3435
38b1a46c
NC		 3436static const bfd_byte elf_sh_plt_entry_le[PLT_ENTRY_SIZE] =
3437{
37c644f2
AO		 3438 0x04, 0xd0, /* mov.l 1f,r0 */
3439 0x02, 0x60, /* mov.l @r0,r0 */
3440 0x02, 0xd2, /* mov.l 0f,r2 */
3441 0x2b, 0x40, /* jmp @r0 */
3442 0x23, 0x60, /* mov r2,r0 */
3443 0x03, 0xd1, /* mov.l 2f,r1 */
3444 0x2b, 0x40, /* jmp @r0 */
3445 0x09, 0x00, /* nop */
3446 0, 0, 0, 0, /* 0: replaced with address of .PLT. */
3447 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
3448 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */
3449};
252b5132 3450
37c644f2 3451/* Entries in a PIC procedure linkage table look like this. */
252b5132 3452
38b1a46c
NC		 3453static const bfd_byte elf_sh_pic_plt_entry_be[PLT_ENTRY_SIZE] =
3454{
37c644f2
AO		 3455 0xd0, 0x04, /* mov.l 1f,r0 */
3456 0x00, 0xce, /* mov.l @(r0,r12),r0 */
3457 0x40, 0x2b, /* jmp @r0 */
3458 0x00, 0x09, /* nop */
3459 0x50, 0xc2, /* 0: mov.l @(8,r12),r0 */
3460 0x52, 0xc1, /* 1: mov.l @(4,r12),r2 */
3461 0xd1, 0x02, /* mov.l 2f,r1 */
3462 0x40, 0x2b, /* jmp @r0 */
3463 0xe0, 0x00, /* mov #0,r0 ! shows the type of PLT. */
3464 0x00, 0x09, /* nop */
3465 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
3466 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
3467};
252b5132 3468
38b1a46c
NC		 3469static const bfd_byte elf_sh_pic_plt_entry_le[PLT_ENTRY_SIZE] =
3470{
37c644f2
AO		 3471 0x04, 0xd0, /* mov.l 1f,r0 */
3472 0xce, 0x00, /* mov.l @(r0,r12),r0 */
3473 0x2b, 0x40, /* jmp @r0 */
3474 0x09, 0x00, /* nop */
3475 0xc2, 0x50, /* 0: mov.l @(8,r12),r0 */
3476 0xc1, 0x52, /* 1: mov.l @(4,r12),r2 */
3477 0x02, 0xd1, /* mov.l 2f,r1 */
3478 0x2b, 0x40, /* jmp @r0 */
3479 0x00, 0xe0, /* mov #0,r0 ! shows the type of PLT. */
3480 0x09, 0x00, /* nop */
3481 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */
3482 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */
3483};
6c426cf3 3484#endif /* old style PLT entries. */
252b5132 3485
37c644f2
AO		 3486static const bfd_byte *elf_sh_plt0_entry;
3487static const bfd_byte *elf_sh_plt_entry;
3488static const bfd_byte *elf_sh_pic_plt_entry;
252b5132 3489
37c644f2
AO		 3490/* Return size of a PLT entry. */
3491#define elf_sh_sizeof_plt(info) PLT_ENTRY_SIZE
252b5132 3492
37c644f2
AO		 3493/* Return offset of the PLT0 address in an absolute PLT entry. */
3494#define elf_sh_plt_plt0_offset(info) 16
252b5132 3495
37c644f2
AO		 3496/* Return offset of the linker in PLT0 entry. */
3497#define elf_sh_plt0_linker_offset(info) 20
9bdafcce 3498
37c644f2
AO		 3499/* Return offset of the GOT id in PLT0 entry. */
3500#define elf_sh_plt0_gotid_offset(info) 24
9bdafcce 3501
37c644f2
AO		 3502/* Return offset of the tempoline in PLT entry */
3503#define elf_sh_plt_temp_offset(info) 8
9bdafcce 3504
37c644f2
AO		 3505/* Return offset of the symbol in PLT entry. */
3506#define elf_sh_plt_symbol_offset(info) 20
9bdafcce 3507
37c644f2
AO		 3508/* Return offset of the relocation in PLT entry. */
3509#define elf_sh_plt_reloc_offset(info) 24
fbca6ad9 3510#endif
015551fc 3511
37c644f2 3512/* The sh linker needs to keep track of the number of relocs that it
067653c5
AM		 3513 decides to copy as dynamic relocs in check_relocs for each symbol.
3514 This is so that it can later discard them if they are found to be
3515 unnecessary. We store the information in a field extending the
3516 regular ELF linker hash table. */
252b5132 3517
067653c5 3518struct elf_sh_dyn_relocs
38b1a46c 3519{
067653c5
AM		 3520 struct elf_sh_dyn_relocs *next;
3521
3522 /* The input section of the reloc. */
3523 asection *sec;
3524
3525 /* Total number of relocs copied for the input section. */
37c644f2 3526 bfd_size_type count;
067653c5
AM		 3527
3528 /* Number of pc-relative relocs copied for the input section. */
3529 bfd_size_type pc_count;
37c644f2 3530};
252b5132 3531
37c644f2
AO		 3532/* sh ELF linker hash entry. */
3533
38b1a46c
NC		 3534struct elf_sh_link_hash_entry
3535{
37c644f2
AO		 3536 struct elf_link_hash_entry root;
3537
fbca6ad9 3538#ifdef INCLUDE_SHMEDIA
396a6083
SC		 3539 union
3540 {
3541 bfd_signed_vma refcount;
3542 bfd_vma offset;
3543 } datalabel_got;
fbca6ad9
AO		 3544#endif
3545
067653c5
AM		 3546 /* Track dynamic relocs copied for this symbol. */
3547 struct elf_sh_dyn_relocs *dyn_relocs;
4989d792
SC		 3548
3549 bfd_signed_vma gotplt_refcount;
3376eaf5
KK		 3550
3551 enum {
3552 GOT_UNKNOWN = 0, GOT_NORMAL, GOT_TLS_GD, GOT_TLS_IE
3553 } tls_type;
3376eaf5
KK		 3554};
3555
3556#define sh_elf_hash_entry(ent) ((struct elf_sh_link_hash_entry *)(ent))
3557
3558struct sh_elf_obj_tdata
3559{
3560 struct elf_obj_tdata root;
3561
3562 /* tls_type for each local got entry. */
3563 char *local_got_tls_type;
37c644f2
AO		 3564};
3565
3376eaf5
KK		 3566#define sh_elf_tdata(abfd) \
3567 ((struct sh_elf_obj_tdata *) (abfd)->tdata.any)
3568
3569#define sh_elf_local_got_tls_type(abfd) \
3570 (sh_elf_tdata (abfd)->local_got_tls_type)
3571
3572/* Override the generic function because we need to store sh_elf_obj_tdata
3573 as the specific tdata. */
3574
b34976b6 3575static bfd_boolean
3376eaf5
KK		 3576sh_elf_mkobject (abfd)
3577 bfd *abfd;
3578{
3579 bfd_size_type amt = sizeof (struct sh_elf_obj_tdata);
3580 abfd->tdata.any = bfd_zalloc (abfd, amt);
3581 if (abfd->tdata.any == NULL)
b34976b6
AM		 3582 return FALSE;
3583 return TRUE;
3376eaf5 3584}
b34976b6 3585
37c644f2
AO		 3586/* sh ELF linker hash table. */
3587
38b1a46c
NC		 3588struct elf_sh_link_hash_table
3589{
37c644f2 3590 struct elf_link_hash_table root;
37c644f2 3591
067653c5
AM		 3592 /* Short-cuts to get to dynamic linker sections. */
3593 asection *sgot;
3594 asection *sgotplt;
3595 asection *srelgot;
3596 asection *splt;
3597 asection *srelplt;
3598 asection *sdynbss;
3599 asection *srelbss;
37c644f2 3600
067653c5
AM		 3601 /* Small local sym to section mapping cache. */
3602 struct sym_sec_cache sym_sec;
3376eaf5
KK		 3603
3604 /* A counter or offset to track a TLS got entry. */
3605 union
3606 {
3607 bfd_signed_vma refcount;
3608 bfd_vma offset;
3609 } tls_ldm_got;
067653c5 3610};
37c644f2
AO		 3611
3612/* Traverse an sh ELF linker hash table. */
3613
3614#define sh_elf_link_hash_traverse(table, func, info) \
3615 (elf_link_hash_traverse \
3616 (&(table)->root, \
b34976b6 3617 (bfd_boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
37c644f2
AO		 3618 (info)))
3619
3620/* Get the sh ELF linker hash table from a link_info structure. */
3621
3622#define sh_elf_hash_table(p) \
3623 ((struct elf_sh_link_hash_table *) ((p)->hash))
3624
3625/* Create an entry in an sh ELF linker hash table. */
3626
3627static struct bfd_hash_entry *
3628sh_elf_link_hash_newfunc (entry, table, string)
3629 struct bfd_hash_entry *entry;
3630 struct bfd_hash_table *table;
3631 const char *string;
3632{
3633 struct elf_sh_link_hash_entry *ret =
3634 (struct elf_sh_link_hash_entry *) entry;
3635
3636 /* Allocate the structure if it has not already been allocated by a
3637 subclass. */
3638 if (ret == (struct elf_sh_link_hash_entry *) NULL)
3639 ret = ((struct elf_sh_link_hash_entry *)
3640 bfd_hash_allocate (table,
3641 sizeof (struct elf_sh_link_hash_entry)));
3642 if (ret == (struct elf_sh_link_hash_entry *) NULL)
3643 return (struct bfd_hash_entry *) ret;
3644
3645 /* Call the allocation method of the superclass. */
3646 ret = ((struct elf_sh_link_hash_entry *)
3647 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
3648 table, string));
3649 if (ret != (struct elf_sh_link_hash_entry *) NULL)
3650 {
396a6083
SC		 3651 ret->dyn_relocs = NULL;
3652 ret->gotplt_refcount = 0;
fbca6ad9 3653#ifdef INCLUDE_SHMEDIA
396a6083 3654 ret->datalabel_got.refcount = ret->root.got.refcount;
fbca6ad9 3655#endif
3376eaf5 3656 ret->tls_type = GOT_UNKNOWN;
37c644f2
AO		 3657 }
3658
3659 return (struct bfd_hash_entry *) ret;
3660}
3661
3662/* Create an sh ELF linker hash table. */
3663
3664static struct bfd_link_hash_table *
3665sh_elf_link_hash_table_create (abfd)
3666 bfd *abfd;
3667{
3668 struct elf_sh_link_hash_table *ret;
dc810e39 3669 bfd_size_type amt = sizeof (struct elf_sh_link_hash_table);
37c644f2 3670
e2d34d7d 3671 ret = (struct elf_sh_link_hash_table *) bfd_malloc (amt);
37c644f2
AO		 3672 if (ret == (struct elf_sh_link_hash_table *) NULL)
3673 return NULL;
3674
3675 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
3676 sh_elf_link_hash_newfunc))
3677 {
e2d34d7d 3678 free (ret);
37c644f2
AO		 3679 return NULL;
3680 }
3681
067653c5
AM		 3682 ret->sgot = NULL;
3683 ret->sgotplt = NULL;
3684 ret->srelgot = NULL;
3685 ret->splt = NULL;
3686 ret->srelplt = NULL;
3687 ret->sdynbss = NULL;
3688 ret->srelbss = NULL;
3689 ret->sym_sec.abfd = NULL;
3376eaf5 3690 ret->tls_ldm_got.refcount = 0;
067653c5 3691
37c644f2
AO		 3692 return &ret->root.root;
3693}
3694
067653c5
AM		 3695/* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
3696 shortcuts to them in our hash table. */
3697
b34976b6 3698static bfd_boolean
067653c5
AM		 3699create_got_section (dynobj, info)
3700 bfd *dynobj;
3701 struct bfd_link_info *info;
3702{
3703 struct elf_sh_link_hash_table *htab;
3704
3705 if (! _bfd_elf_create_got_section (dynobj, info))
b34976b6 3706 return FALSE;
067653c5
AM		 3707
3708 htab = sh_elf_hash_table (info);
3709 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
3710 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
3711 if (! htab->sgot || ! htab->sgotplt)
3712 abort ();
3713
3714 htab->srelgot = bfd_make_section (dynobj, ".rela.got");
3715 if (htab->srelgot == NULL
3716 || ! bfd_set_section_flags (dynobj, htab->srelgot,
3717 (SEC_ALLOC
3718 | SEC_LOAD
3719 | SEC_HAS_CONTENTS
3720 | SEC_IN_MEMORY
3721 | SEC_LINKER_CREATED
3722 | SEC_READONLY))
3723 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
b34976b6
AM		 3724 return FALSE;
3725 return TRUE;
067653c5
AM		 3726}
3727
37c644f2
AO		 3728/* Create dynamic sections when linking against a dynamic object. */
3729
b34976b6 3730static bfd_boolean
37c644f2
AO		 3731sh_elf_create_dynamic_sections (abfd, info)
3732 bfd *abfd;
3733 struct bfd_link_info *info;
3734{
067653c5 3735 struct elf_sh_link_hash_table *htab;
37c644f2
AO		 3736 flagword flags, pltflags;
3737 register asection *s;
3738 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3739 int ptralign = 0;
3740
3741 switch (bed->s->arch_size)
3742 {
3743 case 32:
3744 ptralign = 2;
3745 break;
3746
3747 case 64:
3748 ptralign = 3;
3749 break;
3750
3751 default:
3752 bfd_set_error (bfd_error_bad_value);
b34976b6 3753 return FALSE;
37c644f2
AO		 3754 }
3755
067653c5
AM		 3756 htab = sh_elf_hash_table (info);
3757
37c644f2
AO		 3758 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
3759 .rel[a].bss sections. */
3760
3761 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3762 | SEC_LINKER_CREATED);
3763
3764 pltflags = flags;
3765 pltflags |= SEC_CODE;
3766 if (bed->plt_not_loaded)
3767 pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
3768 if (bed->plt_readonly)
3769 pltflags |= SEC_READONLY;
3770
03151a5a
KK		 3771 s = htab->splt;
3772 if (s == NULL)
3773 {
3774 s = bfd_make_section (abfd, ".plt");
3775 htab->splt = s;
3776 if (s == NULL
3777 || ! bfd_set_section_flags (abfd, s, pltflags)
3778 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
3779 return FALSE;
3780 }
37c644f2
AO		 3781
3782 if (bed->want_plt_sym)
3783 {
3784 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
3785 .plt section. */
14a793b2
AM		 3786 struct elf_link_hash_entry *h;
3787 struct bfd_link_hash_entry *bh = NULL;
3788
37c644f2
AO		 3789 if (! (_bfd_generic_link_add_one_symbol
3790 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
b34976b6 3791 (bfd_vma) 0, (const char *) NULL, FALSE,
14a793b2 3792 get_elf_backend_data (abfd)->collect, &bh)))
b34976b6 3793 return FALSE;
14a793b2
AM		 3794
3795 h = (struct elf_link_hash_entry *) bh;
37c644f2
AO		 3796 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3797 h->type = STT_OBJECT;
3798
3799 if (info->shared
3800 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 3801 return FALSE;
37c644f2
AO		 3802 }
3803
03151a5a
KK		 3804 if (htab->srelplt == NULL)
3805 {
3806 s = bfd_make_section (abfd,
3807 (bed->default_use_rela_p ?
3808 ".rela.plt" : ".rel.plt"));
3809 htab->srelplt = s;
3810 if (s == NULL
3811 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3812 || ! bfd_set_section_alignment (abfd, s, ptralign))
3813 return FALSE;
3814 }
37c644f2 3815
2293c499
AM		 3816 if (htab->sgot == NULL
3817 && !create_got_section (abfd, info))
b34976b6 3818 return FALSE;
37c644f2
AO		 3819
3820 {
3821 const char *secname;
3822 char *relname;
3823 flagword secflags;
3824 asection *sec;
3825
3826 for (sec = abfd->sections; sec; sec = sec->next)
3827 {
3828 secflags = bfd_get_section_flags (abfd, sec);
3829 if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
3830 || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
3831 continue;
3832 secname = bfd_get_section_name (abfd, sec);
dc810e39 3833 relname = (char *) bfd_malloc ((bfd_size_type) strlen (secname) + 6);
37c644f2
AO		 3834 strcpy (relname, ".rela");
3835 strcat (relname, secname);
03151a5a
KK		 3836 if (bfd_get_section_by_name (abfd, secname))
3837 continue;
37c644f2
AO		 3838 s = bfd_make_section (abfd, relname);
3839 if (s == NULL
3840 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3841 || ! bfd_set_section_alignment (abfd, s, ptralign))
b34976b6 3842 return FALSE;
37c644f2
AO		 3843 }
3844 }
3845
3846 if (bed->want_dynbss)
3847 {
3848 /* The .dynbss section is a place to put symbols which are defined
3849 by dynamic objects, are referenced by regular objects, and are
3850 not functions. We must allocate space for them in the process
3851 image and use a R_*_COPY reloc to tell the dynamic linker to
3852 initialize them at run time. The linker script puts the .dynbss
3853 section into the .bss section of the final image. */
03151a5a
KK		 3854 if (htab->sdynbss == NULL)
3855 {
3856 s = bfd_make_section (abfd, ".dynbss");
3857 htab->sdynbss = s;
3858 if (s == NULL
3859 || ! bfd_set_section_flags (abfd, s, SEC_ALLOC))
3860 return FALSE;
3861 }
37c644f2
AO		 3862
3863 /* The .rel[a].bss section holds copy relocs. This section is not
3864 normally needed. We need to create it here, though, so that the
3865 linker will map it to an output section. We can't just create it
3866 only if we need it, because we will not know whether we need it
3867 until we have seen all the input files, and the first time the
3868 main linker code calls BFD after examining all the input files
3869 (size_dynamic_sections) the input sections have already been
3870 mapped to the output sections. If the section turns out not to
3871 be needed, we can discard it later. We will never need this
3872 section when generating a shared object, since they do not use
3873 copy relocs. */
03151a5a 3874 if (! info->shared && htab->srelbss == NULL)
37c644f2 3875 {
435b1e90
KH		 3876 s = bfd_make_section (abfd,
3877 (bed->default_use_rela_p
3878 ? ".rela.bss" : ".rel.bss"));
067653c5 3879 htab->srelbss = s;
37c644f2
AO		 3880 if (s == NULL
3881 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3882 || ! bfd_set_section_alignment (abfd, s, ptralign))
b34976b6 3883 return FALSE;
37c644f2
AO		 3884 }
3885 }
3886
b34976b6 3887 return TRUE;
37c644f2
AO		 3888}
3889\f
37c644f2
AO		 3890/* Adjust a symbol defined by a dynamic object and referenced by a
3891 regular object. The current definition is in some section of the
3892 dynamic object, but we're not including those sections. We have to
3893 change the definition to something the rest of the link can
3894 understand. */
3895
b34976b6 3896static bfd_boolean
37c644f2
AO		 3897sh_elf_adjust_dynamic_symbol (info, h)
3898 struct bfd_link_info *info;
3899 struct elf_link_hash_entry *h;
3900{
067653c5
AM		 3901 struct elf_sh_link_hash_table *htab;
3902 struct elf_sh_link_hash_entry *eh;
3903 struct elf_sh_dyn_relocs *p;
37c644f2
AO		 3904 asection *s;
3905 unsigned int power_of_two;
3906
2293c499 3907 htab = sh_elf_hash_table (info);
37c644f2
AO		 3908
3909 /* Make sure we know what is going on here. */
2293c499 3910 BFD_ASSERT (htab->root.dynobj != NULL
37c644f2
AO		 3911 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
3912 || h->weakdef != NULL
3913 || ((h->elf_link_hash_flags
3914 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
3915 && (h->elf_link_hash_flags
3916 & ELF_LINK_HASH_REF_REGULAR) != 0
3917 && (h->elf_link_hash_flags
3918 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
3919
3920 /* If this is a function, put it in the procedure linkage table. We
3921 will fill in the contents of the procedure linkage table later,
3922 when we know the address of the .got section. */
3923 if (h->type == STT_FUNC
3924 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
3925 {
067653c5
AM		 3926 if (h->plt.refcount <= 0
3927 || (! info->shared
3928 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
3929 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0
3930 && h->root.type != bfd_link_hash_undefweak
3931 && h->root.type != bfd_link_hash_undefined))
37c644f2
AO		 3932 {
3933 /* This case can occur if we saw a PLT reloc in an input
3934 file, but the symbol was never referred to by a dynamic
3935 object. In such a case, we don't actually need to build
3936 a procedure linkage table, and we can just do a REL32
3937 reloc instead. */
067653c5
AM		 3938 h->plt.offset = (bfd_vma) -1;
3939 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
37c644f2
AO		 3940 }
3941
b34976b6 3942 return TRUE;
37c644f2 3943 }
067653c5
AM		 3944 else
3945 h->plt.offset = (bfd_vma) -1;
37c644f2
AO		 3946
3947 /* If this is a weak symbol, and there is a real definition, the
3948 processor independent code will have arranged for us to see the
3949 real definition first, and we can just use the same value. */
3950 if (h->weakdef != NULL)
3951 {
3952 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
3953 || h->weakdef->root.type == bfd_link_hash_defweak);
3954 h->root.u.def.section = h->weakdef->root.u.def.section;
3955 h->root.u.def.value = h->weakdef->root.u.def.value;
04e534c3
KK		 3956 if (info->nocopyreloc)
3957 h->elf_link_hash_flags
3958 = ((h->elf_link_hash_flags & ~ELF_LINK_NON_GOT_REF)
3959 | (h->weakdef->elf_link_hash_flags & ELF_LINK_NON_GOT_REF));
b34976b6 3960 return TRUE;
37c644f2
AO		 3961 }
3962
3963 /* This is a reference to a symbol defined by a dynamic object which
3964 is not a function. */
3965
3966 /* If we are creating a shared library, we must presume that the
3967 only references to the symbol are via the global offset table.
3968 For such cases we need not do anything here; the relocations will
3969 be handled correctly by relocate_section. */
3970 if (info->shared)
b34976b6 3971 return TRUE;
37c644f2
AO		 3972
3973 /* If there are no references to this symbol that do not use the
3974 GOT, we don't need to generate a copy reloc. */
3975 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
b34976b6 3976 return TRUE;
37c644f2 3977
067653c5
AM		 3978 /* If -z nocopyreloc was given, we won't generate them either. */
3979 if (info->nocopyreloc)
3980 {
3981 h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
b34976b6 3982 return TRUE;
067653c5
AM		 3983 }
3984
3985 eh = (struct elf_sh_link_hash_entry *) h;
3986 for (p = eh->dyn_relocs; p != NULL; p = p->next)
3987 {
3988 s = p->sec->output_section;
3989 if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
3990 break;
3991 }
3992
3993 /* If we didn't find any dynamic relocs in sections which needs the
3994 copy reloc, then we'll be keeping the dynamic relocs and avoiding
3995 the copy reloc. */
3996 if (p == NULL)
3997 {
3998 h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
b34976b6 3999 return TRUE;
067653c5
AM		 4000 }
4001
37c644f2
AO		 4002 /* We must allocate the symbol in our .dynbss section, which will
4003 become part of the .bss section of the executable. There will be
4004 an entry for this symbol in the .dynsym section. The dynamic
4005 object will contain position independent code, so all references
4006 from the dynamic object to this symbol will go through the global
4007 offset table. The dynamic linker will use the .dynsym entry to
4008 determine the address it must put in the global offset table, so
4009 both the dynamic object and the regular object will refer to the
4010 same memory location for the variable. */
4011
067653c5 4012 s = htab->sdynbss;
37c644f2
AO		 4013 BFD_ASSERT (s != NULL);
4014
4015 /* We must generate a R_SH_COPY reloc to tell the dynamic linker to
4016 copy the initial value out of the dynamic object and into the
4017 runtime process image. We need to remember the offset into the
4018 .rela.bss section we are going to use. */
4019 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
4020 {
4021 asection *srel;
4022
067653c5 4023 srel = htab->srelbss;
37c644f2
AO		 4024 BFD_ASSERT (srel != NULL);
4025 srel->_raw_size += sizeof (Elf32_External_Rela);
4026 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
4027 }
4028
4029 /* We need to figure out the alignment required for this symbol. I
4030 have no idea how ELF linkers handle this. */
4031 power_of_two = bfd_log2 (h->size);
4032 if (power_of_two > 3)
4033 power_of_two = 3;
4034
4035 /* Apply the required alignment. */
067653c5 4036 s->_raw_size = BFD_ALIGN (s->_raw_size, (bfd_size_type) (1 << power_of_two));
2293c499 4037 if (power_of_two > bfd_get_section_alignment (htab->root.dynobj, s))
37c644f2 4038 {
2293c499 4039 if (! bfd_set_section_alignment (htab->root.dynobj, s, power_of_two))
b34976b6 4040 return FALSE;
37c644f2
AO		 4041 }
4042
4043 /* Define the symbol as being at this point in the section. */
4044 h->root.u.def.section = s;
4045 h->root.u.def.value = s->_raw_size;
4046
4047 /* Increment the section size to make room for the symbol. */
4048 s->_raw_size += h->size;
4049
b34976b6 4050 return TRUE;
37c644f2
AO		 4051}
4052
067653c5
AM		 4053/* This is the condition under which sh_elf_finish_dynamic_symbol
4054 will be called from elflink.h. If elflink.h doesn't call our
4055 finish_dynamic_symbol routine, we'll need to do something about
4056 initializing any .plt and .got entries in sh_elf_relocate_section. */
267fb3c1 4057#define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, SHARED, H) \
067653c5 4058 ((DYN) \
267fb3c1 4059 && ((SHARED) \
067653c5
AM		 4060 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
4061 && ((H)->dynindx != -1 \
4062 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
4063
4064/* Allocate space in .plt, .got and associated reloc sections for
4065 dynamic relocs. */
4066
b34976b6 4067static bfd_boolean
067653c5
AM		 4068allocate_dynrelocs (h, inf)
4069 struct elf_link_hash_entry *h;
4070 PTR inf;
4071{
4072 struct bfd_link_info *info;
4073 struct elf_sh_link_hash_table *htab;
4074 struct elf_sh_link_hash_entry *eh;
4075 struct elf_sh_dyn_relocs *p;
4076
4077 if (h->root.type == bfd_link_hash_indirect)
b34976b6 4078 return TRUE;
067653c5
AM		 4079
4080 if (h->root.type == bfd_link_hash_warning)
4081 /* When warning symbols are created, they **replace** the "real"
4082 entry in the hash table, thus we never get to see the real
4083 symbol in a hash traversal. So look at it now. */
4084 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4085
4086 info = (struct bfd_link_info *) inf;
4087 htab = sh_elf_hash_table (info);
4088
4989d792
SC		 4089 eh = (struct elf_sh_link_hash_entry *) h;
4090 if ((h->got.refcount > 0
4091 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
4092 && eh->gotplt_refcount > 0)
4093 {
4094 /* The symbol has been forced local, or we have some direct got refs,
26e41594 4095 so treat all the gotplt refs as got refs. */
4989d792
SC		 4096 h->got.refcount += eh->gotplt_refcount;
4097 if (h->plt.refcount >= eh->gotplt_refcount)
4098 h->plt.refcount -= eh->gotplt_refcount;
4099 }
4100
067653c5 4101 if (htab->root.dynamic_sections_created
04e534c3
KK		 4102 && h->plt.refcount > 0
4103 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4104 || h->root.type != bfd_link_hash_undefweak))
067653c5
AM		 4105 {
4106 /* Make sure this symbol is output as a dynamic symbol.
4107 Undefined weak syms won't yet be marked as dynamic. */
4108 if (h->dynindx == -1
4109 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
4110 {
4111 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
b34976b6 4112 return FALSE;
067653c5
AM		 4113 }
4114
267fb3c1
KK		 4115 if (info->shared
4116 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
067653c5
AM		 4117 {
4118 asection *s = htab->splt;
4119
4120 /* If this is the first .plt entry, make room for the special
4121 first entry. */
4122 if (s->_raw_size == 0)
4123 s->_raw_size += PLT_ENTRY_SIZE;
4124
4125 h->plt.offset = s->_raw_size;
4126
4127 /* If this symbol is not defined in a regular file, and we are
4128 not generating a shared library, then set the symbol to this
4129 location in the .plt. This is required to make function
4130 pointers compare as equal between the normal executable and
4131 the shared library. */
4132 if (! info->shared
4133 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
4134 {
4135 h->root.u.def.section = s;
4136 h->root.u.def.value = h->plt.offset;
4137 }
4138
4139 /* Make room for this entry. */
4140 s->_raw_size += PLT_ENTRY_SIZE;
4141
4142 /* We also need to make an entry in the .got.plt section, which
4143 will be placed in the .got section by the linker script. */
4144 htab->sgotplt->_raw_size += 4;
4145
4146 /* We also need to make an entry in the .rel.plt section. */
4147 htab->srelplt->_raw_size += sizeof (Elf32_External_Rela);
4148 }
4149 else
4150 {
4151 h->plt.offset = (bfd_vma) -1;
4152 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
4153 }
4154 }
4155 else
4156 {
4157 h->plt.offset = (bfd_vma) -1;
4158 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
4159 }
4160
4161 if (h->got.refcount > 0)
4162 {
4163 asection *s;
b34976b6 4164 bfd_boolean dyn;
3376eaf5 4165 int tls_type = sh_elf_hash_entry (h)->tls_type;
067653c5
AM		 4166
4167 /* Make sure this symbol is output as a dynamic symbol.
4168 Undefined weak syms won't yet be marked as dynamic. */
4169 if (h->dynindx == -1
4170 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
4171 {
4172 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
b34976b6 4173 return FALSE;
067653c5
AM		 4174 }
4175
4176 s = htab->sgot;
067653c5 4177 h->got.offset = s->_raw_size;
067653c5 4178 s->_raw_size += 4;
3376eaf5
KK		 4179 /* R_SH_TLS_GD needs 2 consecutive GOT slots. */
4180 if (tls_type == GOT_TLS_GD)
4181 s->_raw_size += 4;
067653c5 4182 dyn = htab->root.dynamic_sections_created;
267fb3c1 4183 /* R_SH_TLS_IE_32 needs one dynamic relocation if dynamic,
3376eaf5
KK		 4184 R_SH_TLS_GD needs one if local symbol and two if global. */
4185 if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
267fb3c1 4186 || (tls_type == GOT_TLS_IE && dyn))
3376eaf5
KK		 4187 htab->srelgot->_raw_size += sizeof (Elf32_External_Rela);
4188 else if (tls_type == GOT_TLS_GD)
4189 htab->srelgot->_raw_size += 2 * sizeof (Elf32_External_Rela);
04e534c3
KK		 4190 else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4191 || h->root.type != bfd_link_hash_undefweak)
4192 && (info->shared
4193 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
067653c5
AM		 4194 htab->srelgot->_raw_size += sizeof (Elf32_External_Rela);
4195 }
4196 else
4197 h->got.offset = (bfd_vma) -1;
4198
396a6083
SC		 4199#ifdef INCLUDE_SHMEDIA
4200 if (eh->datalabel_got.refcount > 0)
4201 {
4202 asection *s;
b34976b6 4203 bfd_boolean dyn;
396a6083
SC		 4204
4205 /* Make sure this symbol is output as a dynamic symbol.
4206 Undefined weak syms won't yet be marked as dynamic. */
4207 if (h->dynindx == -1
4208 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
4209 {
4210 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
b34976b6 4211 return FALSE;
396a6083
SC		 4212 }
4213
4214 s = htab->sgot;
4215 eh->datalabel_got.offset = s->_raw_size;
4216 s->_raw_size += 4;
4217 dyn = htab->root.dynamic_sections_created;
267fb3c1 4218 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
396a6083
SC		 4219 htab->srelgot->_raw_size += sizeof (Elf32_External_Rela);
4220 }
4221 else
4222 eh->datalabel_got.offset = (bfd_vma) -1;
4223#endif
4224
067653c5 4225 if (eh->dyn_relocs == NULL)
b34976b6 4226 return TRUE;
067653c5
AM		 4227
4228 /* In the shared -Bsymbolic case, discard space allocated for
4229 dynamic pc-relative relocs against symbols which turn out to be
4230 defined in regular objects. For the normal shared case, discard
4231 space for pc-relative relocs that have become local due to symbol
4232 visibility changes. */
4233
4234 if (info->shared)
4235 {
4236 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
4237 && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
4238 || info->symbolic))
4239 {
4240 struct elf_sh_dyn_relocs **pp;
4241
4242 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
4243 {
4244 p->count -= p->pc_count;
4245 p->pc_count = 0;
4246 if (p->count == 0)
4247 *pp = p->next;
4248 else
4249 pp = &p->next;
4250 }
4251 }
04e534c3
KK		 4252
4253 /* Also discard relocs on undefined weak syms with non-default
4254 visibility. */
4255 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
4256 && h->root.type == bfd_link_hash_undefweak)
4257 eh->dyn_relocs = NULL;
067653c5
AM		 4258 }
4259 else
4260 {
4261 /* For the non-shared case, discard space for relocs against
4262 symbols which turn out to need copy relocs or are not
4263 dynamic. */
4264
4265 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
4266 && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
4267 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
4268 || (htab->root.dynamic_sections_created
4269 && (h->root.type == bfd_link_hash_undefweak
4270 || h->root.type == bfd_link_hash_undefined))))
4271 {
4272 /* Make sure this symbol is output as a dynamic symbol.
4273 Undefined weak syms won't yet be marked as dynamic. */
4274 if (h->dynindx == -1
4275 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
4276 {
4277 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
b34976b6 4278 return FALSE;
067653c5
AM		 4279 }
4280
4281 /* If that succeeded, we know we'll be keeping all the
4282 relocs. */
4283 if (h->dynindx != -1)
4284 goto keep;
4285 }
4286
4287 eh->dyn_relocs = NULL;
4288
4289 keep: ;
4290 }
4291
4292 /* Finally, allocate space. */
4293 for (p = eh->dyn_relocs; p != NULL; p = p->next)
4294 {
4295 asection *sreloc = elf_section_data (p->sec)->sreloc;
4296 sreloc->_raw_size += p->count * sizeof (Elf32_External_Rela);
4297 }
4298
b34976b6 4299 return TRUE;
067653c5
AM		 4300}
4301
4302/* Find any dynamic relocs that apply to read-only sections. */
4303
b34976b6 4304static bfd_boolean
067653c5
AM		 4305readonly_dynrelocs (h, inf)
4306 struct elf_link_hash_entry *h;
4307 PTR inf;
4308{
4309 struct elf_sh_link_hash_entry *eh;
4310 struct elf_sh_dyn_relocs *p;
4311
4312 if (h->root.type == bfd_link_hash_warning)
4313 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4314
4315 eh = (struct elf_sh_link_hash_entry *) h;
4316 for (p = eh->dyn_relocs; p != NULL; p = p->next)
4317 {
4318 asection *s = p->sec->output_section;
4319
4320 if (s != NULL && (s->flags & SEC_READONLY) != 0)
4321 {
4322 struct bfd_link_info *info = (struct bfd_link_info *) inf;
4323
4324 info->flags |= DF_TEXTREL;
4325
4326 /* Not an error, just cut short the traversal. */
b34976b6 4327 return FALSE;
067653c5
AM		 4328 }
4329 }
b34976b6 4330 return TRUE;
067653c5
AM		 4331}
4332
37c644f2
AO		 4333/* Set the sizes of the dynamic sections. */
4334
b34976b6 4335static bfd_boolean
37c644f2 4336sh_elf_size_dynamic_sections (output_bfd, info)
99e4ae17 4337 bfd *output_bfd ATTRIBUTE_UNUSED;
37c644f2
AO		 4338 struct bfd_link_info *info;
4339{
067653c5 4340 struct elf_sh_link_hash_table *htab;
37c644f2
AO		 4341 bfd *dynobj;
4342 asection *s;
b34976b6 4343 bfd_boolean relocs;
067653c5 4344 bfd *ibfd;
37c644f2 4345
067653c5
AM		 4346 htab = sh_elf_hash_table (info);
4347 dynobj = htab->root.dynobj;
37c644f2
AO		 4348 BFD_ASSERT (dynobj != NULL);
4349
067653c5 4350 if (htab->root.dynamic_sections_created)
37c644f2
AO		 4351 {
4352 /* Set the contents of the .interp section to the interpreter. */
2558b9a9 4353 if (info->executable)
37c644f2
AO		 4354 {
4355 s = bfd_get_section_by_name (dynobj, ".interp");
4356 BFD_ASSERT (s != NULL);
4357 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
4358 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
4359 }
4360 }
37c644f2 4361
067653c5
AM		 4362 /* Set up .got offsets for local syms, and space for local dynamic
4363 relocs. */
4364 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
37c644f2 4365 {
067653c5
AM		 4366 bfd_signed_vma *local_got;
4367 bfd_signed_vma *end_local_got;
3376eaf5 4368 char *local_tls_type;
067653c5
AM		 4369 bfd_size_type locsymcount;
4370 Elf_Internal_Shdr *symtab_hdr;
4371 asection *srel;
37c644f2 4372
067653c5 4373 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
37c644f2
AO		 4374 continue;
4375
067653c5 4376 for (s = ibfd->sections; s != NULL; s = s->next)
37c644f2 4377 {
067653c5
AM		 4378 struct elf_sh_dyn_relocs *p;
4379
4380 for (p = ((struct elf_sh_dyn_relocs *)
4381 elf_section_data (s)->local_dynrel);
4382 p != NULL;
4383 p = p->next)
37c644f2 4384 {
067653c5
AM		 4385 if (! bfd_is_abs_section (p->sec)
4386 && bfd_is_abs_section (p->sec->output_section))
4387 {
4388 /* Input section has been discarded, either because
4389 it is a copy of a linkonce section or due to
4390 linker script /DISCARD/, so we'll be discarding
4391 the relocs too. */
4392 }
4393 else if (p->count != 0)
4394 {
4395 srel = elf_section_data (p->sec)->sreloc;
4396 srel->_raw_size += p->count * sizeof (Elf32_External_Rela);
4397 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
4398 info->flags |= DF_TEXTREL;
4399 }
37c644f2
AO		 4400 }
4401 }
067653c5
AM		 4402
4403 local_got = elf_local_got_refcounts (ibfd);
4404 if (!local_got)
4405 continue;
4406
4407 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
4408 locsymcount = symtab_hdr->sh_info;
4409#ifdef INCLUDE_SHMEDIA
4410 /* Count datalabel local GOT. */
4411 locsymcount *= 2;
4412#endif
4413 end_local_got = local_got + locsymcount;
3376eaf5 4414 local_tls_type = sh_elf_local_got_tls_type (ibfd);
067653c5
AM		 4415 s = htab->sgot;
4416 srel = htab->srelgot;
4417 for (; local_got < end_local_got; ++local_got)
37c644f2 4418 {
067653c5 4419 if (*local_got > 0)
37c644f2 4420 {
067653c5
AM		 4421 *local_got = s->_raw_size;
4422 s->_raw_size += 4;
3376eaf5
KK		 4423 if (*local_tls_type == GOT_TLS_GD)
4424 s->_raw_size += 4;
067653c5
AM		 4425 if (info->shared)
4426 srel->_raw_size += sizeof (Elf32_External_Rela);
37c644f2
AO		 4427 }
4428 else
067653c5 4429 *local_got = (bfd_vma) -1;
3376eaf5 4430 ++local_tls_type;
37c644f2 4431 }
067653c5
AM		 4432 }
4433
3376eaf5
KK		 4434 if (htab->tls_ldm_got.refcount > 0)
4435 {
4436 /* Allocate 2 got entries and 1 dynamic reloc for R_SH_TLS_LD_32
4437 relocs. */
4438 htab->tls_ldm_got.offset = htab->sgot->_raw_size;
4439 htab->sgot->_raw_size += 8;
4440 htab->srelgot->_raw_size += sizeof (Elf32_External_Rela);
4441 }
4442 else
4443 htab->tls_ldm_got.offset = -1;
4444
067653c5
AM		 4445 /* Allocate global sym .plt and .got entries, and space for global
4446 sym dynamic relocs. */
4447 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, (PTR) info);
4448
4449 /* We now have determined the sizes of the various dynamic sections.
4450 Allocate memory for them. */
b34976b6 4451 relocs = FALSE;
067653c5
AM		 4452 for (s = dynobj->sections; s != NULL; s = s->next)
4453 {
4454 if ((s->flags & SEC_LINKER_CREATED) == 0)
4455 continue;
4456
4457 if (s == htab->splt
4458 || s == htab->sgot
4459 || s == htab->sgotplt)
4460 {
4461 /* Strip this section if we don't need it; see the
4462 comment below. */
4463 }
4464 else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
4465 {
4466 if (s->_raw_size != 0 && s != htab->srelplt)
b34976b6 4467 relocs = TRUE;
067653c5
AM		 4468
4469 /* We use the reloc_count field as a counter if we need
4470 to copy relocs into the output file. */
4471 s->reloc_count = 0;
4472 }
4473 else
37c644f2
AO		 4474 {
4475 /* It's not one of our sections, so don't allocate space. */
4476 continue;
4477 }
4478
067653c5 4479 if (s->_raw_size == 0)
37c644f2 4480 {
067653c5
AM		 4481 /* If we don't need this section, strip it from the
4482 output file. This is mostly to handle .rela.bss and
4483 .rela.plt. We must create both sections in
4484 create_dynamic_sections, because they must be created
4485 before the linker maps input sections to output
4486 sections. The linker does that before
4487 adjust_dynamic_symbol is called, and it is that
4488 function which decides whether anything needs to go
4489 into these sections. */
4490
37c644f2
AO		 4491 _bfd_strip_section_from_output (info, s);
4492 continue;
4493 }
4494
067653c5
AM		 4495 /* Allocate memory for the section contents. We use bfd_zalloc
4496 here in case unused entries are not reclaimed before the
4497 section's contents are written out. This should not happen,
4498 but this way if it does, we get a R_SH_NONE reloc instead
4499 of garbage. */
957dcaa8 4500 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
067653c5 4501 if (s->contents == NULL)
b34976b6 4502 return FALSE;
37c644f2
AO		 4503 }
4504
067653c5 4505 if (htab->root.dynamic_sections_created)
37c644f2
AO		 4506 {
4507 /* Add some entries to the .dynamic section. We fill in the
4508 values later, in sh_elf_finish_dynamic_sections, but we
4509 must add the entries now so that we get the correct size for
4510 the .dynamic section. The DT_DEBUG entry is filled in by the
4511 dynamic linker and used by the debugger. */
dc810e39
AM		 4512#define add_dynamic_entry(TAG, VAL) \
4513 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
4514
2558b9a9 4515 if (info->executable)
37c644f2 4516 {
067653c5 4517 if (! add_dynamic_entry (DT_DEBUG, 0))
b34976b6 4518 return FALSE;
37c644f2
AO		 4519 }
4520
067653c5 4521 if (htab->splt->_raw_size != 0)
37c644f2 4522 {
067653c5
AM		 4523 if (! add_dynamic_entry (DT_PLTGOT, 0)
4524 || ! add_dynamic_entry (DT_PLTRELSZ, 0)
4525 || ! add_dynamic_entry (DT_PLTREL, DT_RELA)
4526 || ! add_dynamic_entry (DT_JMPREL, 0))
b34976b6 4527 return FALSE;
37c644f2
AO		 4528 }
4529
4530 if (relocs)
4531 {
067653c5
AM		 4532 if (! add_dynamic_entry (DT_RELA, 0)
4533 || ! add_dynamic_entry (DT_RELASZ, 0)
4534 || ! add_dynamic_entry (DT_RELAENT,
4535 sizeof (Elf32_External_Rela)))
b34976b6 4536 return FALSE;
37c644f2 4537
067653c5
AM		 4538 /* If any dynamic relocs apply to a read-only section,
4539 then we need a DT_TEXTREL entry. */
4540 if ((info->flags & DF_TEXTREL) == 0)
4541 elf_link_hash_traverse (&htab->root, readonly_dynrelocs,
4542 (PTR) info);
4543
4544 if ((info->flags & DF_TEXTREL) != 0)
4545 {
4546 if (! add_dynamic_entry (DT_TEXTREL, 0))
b34976b6 4547 return FALSE;
067653c5 4548 }
37c644f2
AO		 4549 }
4550 }
dc810e39 4551#undef add_dynamic_entry
37c644f2 4552
b34976b6 4553 return TRUE;
37c644f2 4554}
37c644f2
AO		 4555\f
4556/* Relocate an SH ELF section. */
4557
b34976b6 4558static bfd_boolean
37c644f2
AO		 4559sh_elf_relocate_section (output_bfd, info, input_bfd, input_section,
4560 contents, relocs, local_syms, local_sections)
f8df10f4 4561 bfd *output_bfd;
37c644f2
AO		 4562 struct bfd_link_info *info;
4563 bfd *input_bfd;
4564 asection *input_section;
4565 bfd_byte *contents;
4566 Elf_Internal_Rela *relocs;
4567 Elf_Internal_Sym *local_syms;
4568 asection **local_sections;
4569{
067653c5 4570 struct elf_sh_link_hash_table *htab;
37c644f2
AO		 4571 Elf_Internal_Shdr *symtab_hdr;
4572 struct elf_link_hash_entry **sym_hashes;
4573 Elf_Internal_Rela *rel, *relend;
4574 bfd *dynobj;
4575 bfd_vma *local_got_offsets;
4576 asection *sgot;
fbca6ad9 4577 asection *sgotplt;
37c644f2
AO		 4578 asection *splt;
4579 asection *sreloc;
3376eaf5 4580 asection *srelgot;
37c644f2 4581
067653c5 4582 htab = sh_elf_hash_table (info);
37c644f2
AO		 4583 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4584 sym_hashes = elf_sym_hashes (input_bfd);
067653c5 4585 dynobj = htab->root.dynobj;
37c644f2
AO		 4586 local_got_offsets = elf_local_got_offsets (input_bfd);
4587
067653c5
AM		 4588 sgot = htab->sgot;
4589 sgotplt = htab->sgotplt;
4590 splt = htab->splt;
37c644f2 4591 sreloc = NULL;
3376eaf5 4592 srelgot = NULL;
37c644f2
AO		 4593
4594 rel = relocs;
4595 relend = relocs + input_section->reloc_count;
4596 for (; rel < relend; rel++)
4597 {
4598 int r_type;
4599 reloc_howto_type *howto;
4600 unsigned long r_symndx;
4601 Elf_Internal_Sym *sym;
4602 asection *sec;
4603 struct elf_link_hash_entry *h;
4604 bfd_vma relocation;
435b1e90 4605 bfd_vma addend = (bfd_vma) 0;
37c644f2 4606 bfd_reloc_status_type r;
fbca6ad9 4607 int seen_stt_datalabel = 0;
3376eaf5
KK		 4608 bfd_vma off;
4609 int tls_type;
37c644f2
AO		 4610
4611 r_symndx = ELF32_R_SYM (rel->r_info);
4612
37c644f2
AO		 4613 r_type = ELF32_R_TYPE (rel->r_info);
4614
4615 /* Many of the relocs are only used for relaxing, and are
067653c5 4616 handled entirely by the relaxation code. */
37c644f2
AO		 4617 if (r_type > (int) R_SH_LAST_INVALID_RELOC
4618 && r_type < (int) R_SH_LOOP_START)
4619 continue;
c5aeb40f
AO		 4620 if (r_type == (int) R_SH_NONE)
4621 continue;
37c644f2
AO		 4622
4623 if (r_type < 0
4624 || r_type >= R_SH_max
4625 || (r_type >= (int) R_SH_FIRST_INVALID_RELOC
06bb75c1 4626 && r_type <= (int) R_SH_LAST_INVALID_RELOC)
fbca6ad9
AO		 4627 || ( r_type >= (int) R_SH_FIRST_INVALID_RELOC_3
4628 && r_type <= (int) R_SH_LAST_INVALID_RELOC_3)
4629 || ( r_type >= (int) R_SH_FIRST_INVALID_RELOC_4
4630 && r_type <= (int) R_SH_LAST_INVALID_RELOC_4)
3376eaf5
KK		 4631 || ( r_type >= (int) R_SH_FIRST_INVALID_RELOC_5
4632 && r_type <= (int) R_SH_LAST_INVALID_RELOC_5)
06bb75c1
AO		 4633 || (r_type >= (int) R_SH_FIRST_INVALID_RELOC_2
4634 && r_type <= (int) R_SH_LAST_INVALID_RELOC_2))
37c644f2
AO		 4635 {
4636 bfd_set_error (bfd_error_bad_value);
b34976b6 4637 return FALSE;
37c644f2
AO		 4638 }
4639
4640 howto = sh_elf_howto_table + r_type;
4641
146be91a 4642 /* For relocs that aren't partial_inplace, we get the addend from
067653c5 4643 the relocation. */
146be91a
HPN		 4644 if (! howto->partial_inplace)
4645 addend = rel->r_addend;
4646
37c644f2
AO		 4647 h = NULL;
4648 sym = NULL;
4649 sec = NULL;
4650 if (r_symndx < symtab_hdr->sh_info)
4651 {
4652 sym = local_syms + r_symndx;
4653 sec = local_sections[r_symndx];
4654 relocation = (sec->output_section->vma
4655 + sec->output_offset
4656 + sym->st_value);
fbca6ad9
AO		 4657 /* A local symbol never has STO_SH5_ISA32, so we don't need
4658 datalabel processing here. Make sure this does not change
4659 without notice. */
4660 if ((sym->st_other & STO_SH5_ISA32) != 0)
4661 ((*info->callbacks->reloc_dangerous)
4662 (info,
4663 _("Unexpected STO_SH5_ISA32 on local symbol is not handled"),
4664 input_bfd, input_section, rel->r_offset));
1049f94e 4665 if (info->relocatable)
8a3975e6 4666 {
1049f94e 4667 /* This is a relocatable link. We don't have to change
8a3975e6
AO		 4668 anything, unless the reloc is against a section symbol,
4669 in which case we have to adjust according to where the
4670 section symbol winds up in the output section. */
4671 sym = local_syms + r_symndx;
4672 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
146be91a
HPN		 4673 {
4674 if (! howto->partial_inplace)
4675 {
4676 /* For relocations with the addend in the
4677 relocation, we need just to update the addend.
4678 All real relocs are of type partial_inplace; this
4679 code is mostly for completeness. */
4680 rel->r_addend += sec->output_offset + sym->st_value;
4681
4682 continue;
4683 }
4684
4685 /* Relocs of type partial_inplace need to pick up the
4686 contents in the contents and add the offset resulting
4687 from the changed location of the section symbol.
4688 Using _bfd_final_link_relocate (e.g. goto
4689 final_link_relocate) here would be wrong, because
4690 relocations marked pc_relative would get the current
4691 location subtracted, and we must only do that at the
4692 final link. */
4693 r = _bfd_relocate_contents (howto, input_bfd,
4694 sec->output_offset
4695 + sym->st_value,
4696 contents + rel->r_offset);
4697 goto relocation_done;
4698 }
8a3975e6
AO		 4699
4700 continue;
4701 }
f8df10f4
JJ		 4702 else if (! howto->partial_inplace)
4703 {
4704 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
4705 addend = rel->r_addend;
4706 }
4707 else if ((sec->flags & SEC_MERGE)
4708 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4709 {
4710 asection *msec;
4711
4712 if (howto->rightshift || howto->src_mask != 0xffffffff)
4713 {
4714 (*_bfd_error_handler)
4715 (_("%s(%s+0x%lx): %s relocation against SEC_MERGE section"),
4716 bfd_archive_filename (input_bfd),
4717 bfd_get_section_name (input_bfd, input_section),
4718 (long) rel->r_offset, howto->name);
b34976b6 4719 return FALSE;
f8df10f4
JJ		 4720 }
4721
067653c5
AM		 4722 addend = bfd_get_32 (input_bfd, contents + rel->r_offset);
4723 msec = sec;
4724 addend =
c629eae0 4725 _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
f8df10f4
JJ		 4726 - relocation;
4727 addend += msec->output_section->vma + msec->output_offset;
4728 bfd_put_32 (input_bfd, addend, contents + rel->r_offset);
4729 addend = 0;
4730 }
37c644f2
AO		 4731 }
4732 else
4733 {
8a3975e6
AO		 4734 /* Section symbol are never (?) placed in the hash table, so
4735 we can just ignore hash relocations when creating a
1049f94e
AM		 4736 relocatable object file. */
4737 if (info->relocatable)
8a3975e6
AO		 4738 continue;
4739
37c644f2
AO		 4740 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4741 while (h->root.type == bfd_link_hash_indirect
4742 || h->root.type == bfd_link_hash_warning)
fbca6ad9
AO		 4743 {
4744#ifdef INCLUDE_SHMEDIA
4745 /* If the reference passes a symbol marked with
4746 STT_DATALABEL, then any STO_SH5_ISA32 on the final value
4747 doesn't count. */
4748 seen_stt_datalabel |= h->type == STT_DATALABEL;
4749#endif
4750 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4751 }
37c644f2
AO		 4752 if (h->root.type == bfd_link_hash_defined
4753 || h->root.type == bfd_link_hash_defweak)
4754 {
b34976b6 4755 bfd_boolean dyn;
067653c5
AM		 4756
4757 dyn = htab->root.dynamic_sections_created;
37c644f2
AO		 4758 sec = h->root.u.def.section;
4759 /* In these cases, we don't need the relocation value.
4760 We check specially because in some obscure cases
435b1e90 4761 sec->output_section will be NULL. */
37c644f2 4762 if (r_type == R_SH_GOTPC
fbca6ad9
AO		 4763 || r_type == R_SH_GOTPC_LOW16
4764 || r_type == R_SH_GOTPC_MEDLOW16
4765 || r_type == R_SH_GOTPC_MEDHI16
4766 || r_type == R_SH_GOTPC_HI16
4767 || ((r_type == R_SH_PLT32
4768 || r_type == R_SH_PLT_LOW16
4769 || r_type == R_SH_PLT_MEDLOW16
4770 || r_type == R_SH_PLT_MEDHI16
4771 || r_type == R_SH_PLT_HI16)
37c644f2 4772 && h->plt.offset != (bfd_vma) -1)
fbca6ad9
AO		 4773 || ((r_type == R_SH_GOT32
4774 || r_type == R_SH_GOT_LOW16
4775 || r_type == R_SH_GOT_MEDLOW16
4776 || r_type == R_SH_GOT_MEDHI16
4777 || r_type == R_SH_GOT_HI16)
267fb3c1 4778 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
37c644f2
AO		 4779 && (! info->shared
4780 || (! info->symbolic && h->dynindx != -1)
4781 || (h->elf_link_hash_flags
4782 & ELF_LINK_HASH_DEF_REGULAR) == 0))
4783 /* The cases above are those in which relocation is
4784 overwritten in the switch block below. The cases
4785 below are those in which we must defer relocation
4786 to run-time, because we can't resolve absolute
4787 addresses when creating a shared library. */
4788 || (info->shared
4789 && ((! info->symbolic && h->dynindx != -1)
4790 || (h->elf_link_hash_flags
4791 & ELF_LINK_HASH_DEF_REGULAR) == 0)
4792 && ((r_type == R_SH_DIR32
067653c5
AM		 4793 && (h->elf_link_hash_flags
4794 & ELF_LINK_FORCED_LOCAL) == 0)
37c644f2
AO		 4795 || r_type == R_SH_REL32)
4796 && ((input_section->flags & SEC_ALLOC) != 0
4797 /* DWARF will emit R_SH_DIR32 relocations in its
4798 sections against symbols defined externally
4799 in shared libraries. We can't do anything
4800 with them here. */
067653c5
AM		 4801 || ((input_section->flags & SEC_DEBUGGING) != 0
4802 && (h->elf_link_hash_flags
3376eaf5 4803 & ELF_LINK_HASH_DEF_DYNAMIC) != 0)))
1448fa32
KK		 4804 /* Dynamic relocs are not propagated for SEC_DEBUGGING
4805 sections because such sections are not SEC_ALLOC and
4806 thus ld.so will not process them. */
4807 || (sec->output_section == NULL
4808 && ((input_section->flags & SEC_DEBUGGING) != 0
4809 && (h->elf_link_hash_flags
4810 & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
3376eaf5
KK		 4811 || (sec->output_section == NULL
4812 && (sh_elf_hash_entry (h)->tls_type == GOT_TLS_IE
4813 || sh_elf_hash_entry (h)->tls_type == GOT_TLS_GD)))
37c644f2
AO		 4814 relocation = 0;
4815 else if (sec->output_section == NULL)
4816 {
4817 (*_bfd_error_handler)
3376eaf5 4818 (_("%s: unresolvable relocation against symbol `%s' from %s section"),
8f615d07 4819 bfd_archive_filename (input_bfd), h->root.root.string,
37c644f2 4820 bfd_get_section_name (input_bfd, input_section));
b34976b6 4821 return FALSE;
37c644f2
AO		 4822 }
4823 else
fbca6ad9 4824 relocation = ((h->root.u.def.value
37c644f2 4825 + sec->output_section->vma
fbca6ad9
AO		 4826 + sec->output_offset)
4827 /* A STO_SH5_ISA32 causes a "bitor 1" to the
4828 symbol value, unless we've seen
4829 STT_DATALABEL on the way to it. */
4830 | ((h->other & STO_SH5_ISA32) != 0
4831 && ! seen_stt_datalabel));
37c644f2
AO		 4832 }
4833 else if (h->root.type == bfd_link_hash_undefweak)
4834 relocation = 0;
671bae9c 4835 else if (info->shared
067653c5
AM		 4836 && ! info->no_undefined
4837 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
37c644f2
AO		 4838 relocation = 0;
4839 else
4840 {
4841 if (! ((*info->callbacks->undefined_symbol)
4842 (info, h->root.root.string, input_bfd,
067653c5
AM		 4843 input_section, rel->r_offset,
4844 (!info->shared || info->no_undefined
4845 || ELF_ST_VISIBILITY (h->other)))))
b34976b6 4846 return FALSE;
37c644f2
AO		 4847 relocation = 0;
4848 }
4849 }
4850
435b1e90 4851 switch ((int) r_type)
37c644f2
AO		 4852 {
4853 final_link_relocate:
4854 /* COFF relocs don't use the addend. The addend is used for
435b1e90 4855 R_SH_DIR32 to be compatible with other compilers. */
37c644f2
AO		 4856 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4857 contents, rel->r_offset,
4858 relocation, addend);
4859 break;
4860
4861 case R_SH_IND12W:
cd6ec716
DD		 4862 goto final_link_relocate;
4863
37c644f2
AO		 4864 case R_SH_DIR8WPN:
4865 case R_SH_DIR8WPZ:
4866 case R_SH_DIR8WPL:
cd6ec716
DD		 4867 /* If the reloc is against the start of this section, then
4868 the assembler has already taken care of it and the reloc
4869 is here only to assist in relaxing. If the reloc is not
4870 against the start of this section, then it's against an
4871 external symbol and we must deal with it ourselves. */
4872 if (input_section->output_section->vma + input_section->output_offset
4873 != relocation)
4874 {
4875 int disp = (relocation
4876 - input_section->output_section->vma
4877 - input_section->output_offset
4878 - rel->r_offset);
4879 int mask = 0;
4880 switch (r_type)
4881 {
4882 case R_SH_DIR8WPN:
4883 case R_SH_DIR8WPZ: mask = 1; break;
4884 case R_SH_DIR8WPL: mask = 3; break;
4885 default: mask = 0; break;
4886 }
4887 if (disp & mask)
4888 {
4889 ((*_bfd_error_handler)
4890 (_("%s: 0x%lx: fatal: unaligned branch target for relax-support relocation"),
8f615d07 4891 bfd_archive_filename (input_section->owner),
cd6ec716
DD		 4892 (unsigned long) rel->r_offset));
4893 bfd_set_error (bfd_error_bad_value);
b34976b6 4894 return FALSE;
cd6ec716
DD		 4895 }
4896 relocation -= 4;
4897 goto final_link_relocate;
4898 }
4899 r = bfd_reloc_ok;
4900 break;
37c644f2
AO		 4901
4902 default:
fbca6ad9
AO		 4903#ifdef INCLUDE_SHMEDIA
4904 if (shmedia_prepare_reloc (info, input_bfd, input_section,
4905 contents, rel, &relocation))
4906 goto final_link_relocate;
4907#endif
37c644f2 4908 bfd_set_error (bfd_error_bad_value);
b34976b6 4909 return FALSE;
37c644f2
AO		 4910
4911 case R_SH_DIR32:
4912 case R_SH_REL32:
4913 if (info->shared
04e534c3
KK		 4914 && (h == NULL
4915 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4916 || h->root.type != bfd_link_hash_undefweak)
ec338859 4917 && r_symndx != 0
37c644f2
AO		 4918 && (input_section->flags & SEC_ALLOC) != 0
4919 && (r_type != R_SH_REL32
4920 || (h != NULL
4921 && h->dynindx != -1
4922 && (! info->symbolic
4923 || (h->elf_link_hash_flags
4924 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
4925 {
4926 Elf_Internal_Rela outrel;
947216bf 4927 bfd_byte *loc;
b34976b6 4928 bfd_boolean skip, relocate;
37c644f2
AO		 4929
4930 /* When generating a shared object, these relocations
4931 are copied into the output file to be resolved at run
4932 time. */
4933
4934 if (sreloc == NULL)
4935 {
4936 const char *name;
4937
4938 name = (bfd_elf_string_from_elf_section
4939 (input_bfd,
4940 elf_elfheader (input_bfd)->e_shstrndx,
4941 elf_section_data (input_section)->rel_hdr.sh_name));
4942 if (name == NULL)
b34976b6 4943 return FALSE;
37c644f2
AO		 4944
4945 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
4946 && strcmp (bfd_get_section_name (input_bfd,
4947 input_section),
4948 name + 5) == 0);
4949
4950 sreloc = bfd_get_section_by_name (dynobj, name);
4951 BFD_ASSERT (sreloc != NULL);
4952 }
4953
b34976b6
AM		 4954 skip = FALSE;
4955 relocate = FALSE;
37c644f2 4956
c629eae0
JJ		 4957 outrel.r_offset =
4958 _bfd_elf_section_offset (output_bfd, info, input_section,
4959 rel->r_offset);
4960 if (outrel.r_offset == (bfd_vma) -1)
b34976b6 4961 skip = TRUE;
0bb2d96a 4962 else if (outrel.r_offset == (bfd_vma) -2)
b34976b6 4963 skip = TRUE, relocate = TRUE;
37c644f2
AO		 4964 outrel.r_offset += (input_section->output_section->vma
4965 + input_section->output_offset);
4966
4967 if (skip)
0bb2d96a 4968 memset (&outrel, 0, sizeof outrel);
37c644f2
AO		 4969 else if (r_type == R_SH_REL32)
4970 {
4971 BFD_ASSERT (h != NULL && h->dynindx != -1);
37c644f2 4972 outrel.r_info = ELF32_R_INFO (h->dynindx, R_SH_REL32);
146be91a
HPN		 4973 outrel.r_addend
4974 = bfd_get_32 (input_bfd, contents + rel->r_offset);
37c644f2
AO		 4975 }
4976 else
4977 {
4978 /* h->dynindx may be -1 if this symbol was marked to
4979 become local. */
4980 if (h == NULL
4981 || ((info->symbolic || h->dynindx == -1)
4982 && (h->elf_link_hash_flags
4983 & ELF_LINK_HASH_DEF_REGULAR) != 0))
4984 {
b34976b6 4985 relocate = TRUE;
37c644f2 4986 outrel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
146be91a
HPN		 4987 outrel.r_addend
4988 = relocation + bfd_get_32 (input_bfd,
4989 contents + rel->r_offset);
37c644f2
AO		 4990 }
4991 else
4992 {
4993 BFD_ASSERT (h->dynindx != -1);
37c644f2 4994 outrel.r_info = ELF32_R_INFO (h->dynindx, R_SH_DIR32);
146be91a
HPN		 4995 outrel.r_addend
4996 = relocation + bfd_get_32 (input_bfd,
4997 contents + rel->r_offset);
37c644f2
AO		 4998 }
4999 }
5000
947216bf
AM		 5001 loc = sreloc->contents;
5002 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
5003 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
37c644f2
AO		 5004
5005 /* If this reloc is against an external symbol, we do
5006 not want to fiddle with the addend. Otherwise, we
5007 need to include the symbol value so that it becomes
5008 an addend for the dynamic reloc. */
5009 if (! relocate)
5010 continue;
5011 }
37c644f2
AO		 5012 goto final_link_relocate;
5013
fbca6ad9
AO		 5014 case R_SH_GOTPLT32:
5015#ifdef INCLUDE_SHMEDIA
5016 case R_SH_GOTPLT_LOW16:
5017 case R_SH_GOTPLT_MEDLOW16:
5018 case R_SH_GOTPLT_MEDHI16:
5019 case R_SH_GOTPLT_HI16:
5020 case R_SH_GOTPLT10BY4:
5021 case R_SH_GOTPLT10BY8:
5022#endif
5023 /* Relocation is to the entry for this symbol in the
5024 procedure linkage table. */
5025
5026 if (h == NULL
067653c5 5027 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)
fbca6ad9
AO		 5028 || ! info->shared
5029 || info->symbolic
5030 || h->dynindx == -1
5031 || h->plt.offset == (bfd_vma) -1
5032 || h->got.offset != (bfd_vma) -1)
5033 goto force_got;
5034
5035 /* Relocation is to the entry for this symbol in the global
5036 offset table extension for the procedure linkage table. */
fbca6ad9 5037
067653c5 5038 BFD_ASSERT (sgotplt != NULL);
fbca6ad9
AO		 5039 relocation = (sgotplt->output_offset
5040 + ((h->plt.offset / elf_sh_sizeof_plt (info)
5041 - 1 + 3) * 4));
5042
5043#ifdef GOT_BIAS
5044 relocation -= GOT_BIAS;
5045#endif
5046
5047 goto final_link_relocate;
5048
5049 force_got:
37c644f2 5050 case R_SH_GOT32:
fbca6ad9
AO		 5051#ifdef INCLUDE_SHMEDIA
5052 case R_SH_GOT_LOW16:
5053 case R_SH_GOT_MEDLOW16:
5054 case R_SH_GOT_MEDHI16:
5055 case R_SH_GOT_HI16:
5056 case R_SH_GOT10BY4:
5057 case R_SH_GOT10BY8:
5058#endif
37c644f2
AO		 5059 /* Relocation is to the entry for this symbol in the global
5060 offset table. */
067653c5
AM		 5061
5062 BFD_ASSERT (sgot != NULL);
37c644f2
AO		 5063
5064 if (h != NULL)
5065 {
b34976b6 5066 bfd_boolean dyn;
37c644f2
AO		 5067
5068 off = h->got.offset;
fbca6ad9
AO		 5069#ifdef INCLUDE_SHMEDIA
5070 if (seen_stt_datalabel)
5071 {
5072 struct elf_sh_link_hash_entry *hsh;
5073
5074 hsh = (struct elf_sh_link_hash_entry *)h;
396a6083 5075 off = hsh->datalabel_got.offset;
fbca6ad9
AO		 5076 }
5077#endif
37c644f2
AO		 5078 BFD_ASSERT (off != (bfd_vma) -1);
5079
067653c5 5080 dyn = htab->root.dynamic_sections_created;
267fb3c1 5081 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
37c644f2
AO		 5082 || (info->shared
5083 && (info->symbolic || h->dynindx == -1
067653c5 5084 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
04e534c3
KK		 5085 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
5086 || (ELF_ST_VISIBILITY (h->other)
5087 && h->root.type == bfd_link_hash_undefweak))
37c644f2
AO		 5088 {
5089 /* This is actually a static link, or it is a
5090 -Bsymbolic link and the symbol is defined
5091 locally, or the symbol was forced to be local
5092 because of a version file. We must initialize
5093 this entry in the global offset table. Since the
5094 offset must always be a multiple of 4, we use the
5095 least significant bit to record whether we have
5096 initialized it already.
5097
5098 When doing a dynamic link, we create a .rela.got
5099 relocation entry to initialize the value. This
5100 is done in the finish_dynamic_symbol routine. */
5101 if ((off & 1) != 0)
5102 off &= ~1;
5103 else
5104 {
5105 bfd_put_32 (output_bfd, relocation,
5106 sgot->contents + off);
fbca6ad9
AO		 5107#ifdef INCLUDE_SHMEDIA
5108 if (seen_stt_datalabel)
5109 {
5110 struct elf_sh_link_hash_entry *hsh;
5111
5112 hsh = (struct elf_sh_link_hash_entry *)h;
396a6083 5113 hsh->datalabel_got.offset |= 1;
fbca6ad9
AO		 5114 }
5115 else
5116#endif
5117 h->got.offset |= 1;
37c644f2
AO		 5118 }
5119 }
5120
5121 relocation = sgot->output_offset + off;
5122 }
5123 else
5124 {
fbca6ad9
AO		 5125#ifdef INCLUDE_SHMEDIA
5126 if (rel->r_addend)
5127 {
5128 BFD_ASSERT (local_got_offsets != NULL
5129 && (local_got_offsets[symtab_hdr->sh_info
5130 + r_symndx]
5131 != (bfd_vma) -1));
5132
5133 off = local_got_offsets[symtab_hdr->sh_info
5134 + r_symndx];
5135 }
5136 else
5137 {
5138#endif
37c644f2
AO		 5139 BFD_ASSERT (local_got_offsets != NULL
5140 && local_got_offsets[r_symndx] != (bfd_vma) -1);
5141
5142 off = local_got_offsets[r_symndx];
fbca6ad9
AO		 5143#ifdef INCLUDE_SHMEDIA
5144 }
5145#endif
37c644f2
AO		 5146
5147 /* The offset must always be a multiple of 4. We use
5148 the least significant bit to record whether we have
5149 already generated the necessary reloc. */
5150 if ((off & 1) != 0)
5151 off &= ~1;
5152 else
5153 {
5154 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
5155
5156 if (info->shared)
5157 {
37c644f2 5158 Elf_Internal_Rela outrel;
947216bf 5159 bfd_byte *loc;
37c644f2 5160
3376eaf5
KK		 5161 if (srelgot == NULL)
5162 {
5163 srelgot = bfd_get_section_by_name (dynobj,
5164 ".rela.got");
5165 BFD_ASSERT (srelgot != NULL);
5166 }
37c644f2
AO		 5167
5168 outrel.r_offset = (sgot->output_section->vma
5169 + sgot->output_offset
5170 + off);
5171 outrel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
5172 outrel.r_addend = relocation;
947216bf
AM		 5173 loc = srelgot->contents;
5174 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
5175 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
37c644f2
AO		 5176 }
5177
fbca6ad9
AO		 5178#ifdef INCLUDE_SHMEDIA
5179 if (rel->r_addend)
5180 local_got_offsets[symtab_hdr->sh_info + r_symndx] |= 1;
5181 else
5182#endif
5183 local_got_offsets[r_symndx] |= 1;
37c644f2
AO		 5184 }
5185
5186 relocation = sgot->output_offset + off;
5187 }
5188
fbca6ad9 5189#ifdef GOT_BIAS
067653c5 5190 relocation -= GOT_BIAS;
fbca6ad9
AO		 5191#endif
5192
37c644f2
AO		 5193 goto final_link_relocate;
5194
5195 case R_SH_GOTOFF:
fbca6ad9
AO		 5196#ifdef INCLUDE_SHMEDIA
5197 case R_SH_GOTOFF_LOW16:
5198 case R_SH_GOTOFF_MEDLOW16:
5199 case R_SH_GOTOFF_MEDHI16:
5200 case R_SH_GOTOFF_HI16:
5201#endif
37c644f2
AO		 5202 /* Relocation is relative to the start of the global offset
5203 table. */
5204
067653c5 5205 BFD_ASSERT (sgot != NULL);
37c644f2
AO		 5206
5207 /* Note that sgot->output_offset is not involved in this
5208 calculation. We always want the start of .got. If we
5209 defined _GLOBAL_OFFSET_TABLE in a different way, as is
5210 permitted by the ABI, we might have to change this
5211 calculation. */
5212 relocation -= sgot->output_section->vma;
5213
fbca6ad9
AO		 5214#ifdef GOT_BIAS
5215 relocation -= GOT_BIAS;
5216#endif
5217
5218 addend = rel->r_addend;
5219
37c644f2
AO		 5220 goto final_link_relocate;
5221
5222 case R_SH_GOTPC:
fbca6ad9
AO		 5223#ifdef INCLUDE_SHMEDIA
5224 case R_SH_GOTPC_LOW16:
5225 case R_SH_GOTPC_MEDLOW16:
5226 case R_SH_GOTPC_MEDHI16:
5227 case R_SH_GOTPC_HI16:
5228#endif
37c644f2
AO		 5229 /* Use global offset table as symbol value. */
5230
067653c5 5231 BFD_ASSERT (sgot != NULL);
37c644f2
AO		 5232 relocation = sgot->output_section->vma;
5233
fbca6ad9
AO		 5234#ifdef GOT_BIAS
5235 relocation += GOT_BIAS;
5236#endif
5237
5238 addend = rel->r_addend;
5239
37c644f2
AO		 5240 goto final_link_relocate;
5241
5242 case R_SH_PLT32:
fbca6ad9
AO		 5243#ifdef INCLUDE_SHMEDIA
5244 case R_SH_PLT_LOW16:
5245 case R_SH_PLT_MEDLOW16:
5246 case R_SH_PLT_MEDHI16:
5247 case R_SH_PLT_HI16:
5248#endif
37c644f2
AO		 5249 /* Relocation is to the entry for this symbol in the
5250 procedure linkage table. */
5251
5252 /* Resolve a PLT reloc against a local symbol directly,
5253 without using the procedure linkage table. */
5254 if (h == NULL)
5255 goto final_link_relocate;
5256
067653c5 5257 if (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)
37c644f2
AO		 5258 goto final_link_relocate;
5259
5260 if (h->plt.offset == (bfd_vma) -1)
5261 {
5262 /* We didn't make a PLT entry for this symbol. This
5263 happens when statically linking PIC code, or when
5264 using -Bsymbolic. */
5265 goto final_link_relocate;
5266 }
5267
067653c5 5268 BFD_ASSERT (splt != NULL);
37c644f2
AO		 5269 relocation = (splt->output_section->vma
5270 + splt->output_offset
5271 + h->plt.offset);
5272
fbca6ad9
AO		 5273#ifdef INCLUDE_SHMEDIA
5274 relocation++;
5275#endif
5276
5277 addend = rel->r_addend;
5278
37c644f2
AO		 5279 goto final_link_relocate;
5280
5281 case R_SH_LOOP_START:
5282 {
5283 static bfd_vma start, end;
5284
5285 start = (relocation + rel->r_addend
5286 - (sec->output_section->vma + sec->output_offset));
5287 r = sh_elf_reloc_loop (r_type, input_bfd, input_section, contents,
5288 rel->r_offset, sec, start, end);
5289 break;
5290
5291 case R_SH_LOOP_END:
5292 end = (relocation + rel->r_addend
5293 - (sec->output_section->vma + sec->output_offset));
5294 r = sh_elf_reloc_loop (r_type, input_bfd, input_section, contents,
5295 rel->r_offset, sec, start, end);
5296 break;
5297 }
3376eaf5
KK		 5298
5299 case R_SH_TLS_GD_32:
5300 case R_SH_TLS_IE_32:
5301 r_type = sh_elf_optimized_tls_reloc (info, r_type, h == NULL);
5302 tls_type = GOT_UNKNOWN;
5303 if (h == NULL && local_got_offsets)
5304 tls_type = sh_elf_local_got_tls_type (input_bfd) [r_symndx];
5305 else if (h != NULL)
5306 {
5307 tls_type = sh_elf_hash_entry (h)->tls_type;
5308 if (! info->shared
5309 && (h->dynindx == -1
c95b8a7a 5310 || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
267fb3c1 5311 r_type = R_SH_TLS_LE_32;
3376eaf5
KK		 5312 }
5313
5314 if (r_type == R_SH_TLS_GD_32 && tls_type == GOT_TLS_IE)
5315 r_type = R_SH_TLS_IE_32;
5316
5317 if (r_type == R_SH_TLS_LE_32)
5318 {
5319 bfd_vma offset;
5320 unsigned short insn;
3376eaf5
KK		 5321
5322 if (ELF32_R_TYPE (rel->r_info) == R_SH_TLS_GD_32)
5323 {
5324 /* GD->LE transition:
5325 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
b34976b6 5326 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
3376eaf5
KK		 5327 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
5328 We change it into:
5329 mov.l 1f,r4; stc gbr,r0; add r4,r0; nop;
5330 nop; nop; ...
5331 1: .long x@TPOFF; 2: .long __tls_get_addr@PLT; 3:. */
5332
5333 offset = rel->r_offset;
5334 BFD_ASSERT (offset >= 16);
5335 /* Size of GD instructions is 16 or 18. */
5336 offset -= 16;
5337 insn = bfd_get_16 (input_bfd, contents + offset + 0);
5338 if ((insn & 0xff00) == 0xc700)
5339 {
5340 BFD_ASSERT (offset >= 2);
5341 offset -= 2;
5342 insn = bfd_get_16 (input_bfd, contents + offset + 0);
5343 }
5344
5345 BFD_ASSERT ((insn & 0xff00) == 0xd400);
5346 insn = bfd_get_16 (input_bfd, contents + offset + 2);
5347 BFD_ASSERT ((insn & 0xff00) == 0xc700);
5348 insn = bfd_get_16 (input_bfd, contents + offset + 4);
5349 BFD_ASSERT ((insn & 0xff00) == 0xd100);
5350 insn = bfd_get_16 (input_bfd, contents + offset + 6);
5351 BFD_ASSERT (insn == 0x310c);
5352 insn = bfd_get_16 (input_bfd, contents + offset + 8);
5353 BFD_ASSERT (insn == 0x410b);
5354 insn = bfd_get_16 (input_bfd, contents + offset + 10);
5355 BFD_ASSERT (insn == 0x34cc);
5356
5357 bfd_put_16 (output_bfd, 0x0012, contents + offset + 2);
5358 bfd_put_16 (output_bfd, 0x304c, contents + offset + 4);
5359 bfd_put_16 (output_bfd, 0x0009, contents + offset + 6);
5360 bfd_put_16 (output_bfd, 0x0009, contents + offset + 8);
5361 bfd_put_16 (output_bfd, 0x0009, contents + offset + 10);
5362 }
5363 else
5364 {
5365 int index;
5366
5367 /* IE->LE transition:
5368 mov.l 1f,r0; stc gbr,rN; mov.l @(r0,r12),rM;
5369 bra 2f; add ...; .align 2; 1: x@GOTTPOFF; 2:
5370 We change it into:
5371 mov.l .Ln,rM; stc gbr,rN; nop; ...;
5372 1: x@TPOFF; 2:. */
5373
5374 offset = rel->r_offset;
5375 BFD_ASSERT (offset >= 16);
5376 /* Size of IE instructions is 10 or 12. */
5377 offset -= 10;
5378 insn = bfd_get_16 (input_bfd, contents + offset + 0);
5379 if ((insn & 0xf0ff) == 0x0012)
5380 {
5381 BFD_ASSERT (offset >= 2);
5382 offset -= 2;
5383 insn = bfd_get_16 (input_bfd, contents + offset + 0);
5384 }
5385
5386 BFD_ASSERT ((insn & 0xff00) == 0xd000);
5387 index = insn & 0x00ff;
5388 insn = bfd_get_16 (input_bfd, contents + offset + 2);
5389 BFD_ASSERT ((insn & 0xf0ff) == 0x0012);
5390 insn = bfd_get_16 (input_bfd, contents + offset + 4);
5391 BFD_ASSERT ((insn & 0xf0ff) == 0x00ce);
5392 insn = 0xd000 | (insn & 0x0f00) | index;
5393 bfd_put_16 (output_bfd, insn, contents + offset + 0);
5394 bfd_put_16 (output_bfd, 0x0009, contents + offset + 4);
5395 }
5396
267fb3c1
KK		 5397 bfd_put_32 (output_bfd, tpoff (info, relocation),
5398 contents + rel->r_offset);
3376eaf5
KK		 5399 continue;
5400 }
5401
5402 sgot = htab->sgot;
5403 if (sgot == NULL)
5404 abort ();
5405
5406 if (h != NULL)
5407 off = h->got.offset;
5408 else
5409 {
5410 if (local_got_offsets == NULL)
5411 abort ();
5412
5413 off = local_got_offsets[r_symndx];
5414 }
5415
267fb3c1
KK		 5416 /* Relocate R_SH_TLS_IE_32 directly when statically linking. */
5417 if (r_type == R_SH_TLS_IE_32
5418 && ! htab->root.dynamic_sections_created)
5419 {
5420 off &= ~1;
5421 bfd_put_32 (output_bfd, tpoff (info, relocation),
5422 sgot->contents + off);
5423 bfd_put_32 (output_bfd, sgot->output_offset + off,
5424 contents + rel->r_offset);
5425 continue;
5426 }
5427
3376eaf5
KK		 5428 if ((off & 1) != 0)
5429 off &= ~1;
26e41594 5430 else
3376eaf5
KK		 5431 {
5432 Elf_Internal_Rela outrel;
947216bf 5433 bfd_byte *loc;
3376eaf5
KK		 5434 int dr_type, indx;
5435
5436 if (srelgot == NULL)
5437 {
5438 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
5439 BFD_ASSERT (srelgot != NULL);
5440 }
5441
5442 outrel.r_offset = (sgot->output_section->vma
5443 + sgot->output_offset + off);
5444
267fb3c1 5445 if (h == NULL || h->dynindx == -1)
c95b8a7a
KK		 5446 indx = 0;
5447 else
5448 indx = h->dynindx;
267fb3c1 5449
3376eaf5
KK		 5450 dr_type = (r_type == R_SH_TLS_GD_32 ? R_SH_TLS_DTPMOD32 :
5451 R_SH_TLS_TPOFF32);
5452 if (dr_type == R_SH_TLS_TPOFF32 && indx == 0)
5453 outrel.r_addend = relocation - dtpoff_base (info);
5454 else
5455 outrel.r_addend = 0;
5456 outrel.r_info = ELF32_R_INFO (indx, dr_type);
947216bf
AM		 5457 loc = srelgot->contents;
5458 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
3376eaf5
KK		 5459 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5460
5461 if (r_type == R_SH_TLS_GD_32)
5462 {
5463 if (indx == 0)
5464 {
5465 bfd_put_32 (output_bfd,
5466 relocation - dtpoff_base (info),
5467 sgot->contents + off + 4);
5468 }
5469 else
5470 {
5471 outrel.r_info = ELF32_R_INFO (indx,
5472 R_SH_TLS_DTPOFF32);
5473 outrel.r_offset += 4;
5474 outrel.r_addend = 0;
5475 srelgot->reloc_count++;
947216bf
AM		 5476 loc += sizeof (Elf32_External_Rela);
5477 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3376eaf5
KK		 5478 }
5479 }
5480
5481 if (h != NULL)
5482 h->got.offset |= 1;
5483 else
5484 local_got_offsets[r_symndx] |= 1;
5485 }
5486
5487 if (off >= (bfd_vma) -2)
5488 abort ();
5489
5490 if (r_type == (int) ELF32_R_TYPE (rel->r_info))
5491 relocation = sgot->output_offset + off;
5492 else
5493 {
5494 bfd_vma offset;
5495 unsigned short insn;
5496
5497 /* GD->IE transition:
5498 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5499 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5500 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3:
5501 We change it into:
5502 mov.l 1f,r0; stc gbr,r4; mov.l @(r0,r12),r0; add r4,r0;
5503 nop; nop; bra 3f; nop; .align 2;
5504 1: .long x@TPOFF; 2:...; 3:. */
5505
5506 offset = rel->r_offset;
5507 BFD_ASSERT (offset >= 16);
5508 /* Size of GD instructions is 16 or 18. */
5509 offset -= 16;
5510 insn = bfd_get_16 (input_bfd, contents + offset + 0);
5511 if ((insn & 0xff00) == 0xc700)
5512 {
5513 BFD_ASSERT (offset >= 2);
5514 offset -= 2;
5515 insn = bfd_get_16 (input_bfd, contents + offset + 0);
5516 }
5517
5518 BFD_ASSERT ((insn & 0xff00) == 0xd400);
5519
5520 /* Replace mov.l 1f,R4 with mov.l 1f,r0. */
5521 bfd_put_16 (output_bfd, insn & 0xf0ff, contents + offset);
5522
5523 insn = bfd_get_16 (input_bfd, contents + offset + 2);
5524 BFD_ASSERT ((insn & 0xff00) == 0xc700);
5525 insn = bfd_get_16 (input_bfd, contents + offset + 4);
5526 BFD_ASSERT ((insn & 0xff00) == 0xd100);
5527 insn = bfd_get_16 (input_bfd, contents + offset + 6);
5528 BFD_ASSERT (insn == 0x310c);
5529 insn = bfd_get_16 (input_bfd, contents + offset + 8);
5530 BFD_ASSERT (insn == 0x410b);
5531 insn = bfd_get_16 (input_bfd, contents + offset + 10);
5532 BFD_ASSERT (insn == 0x34cc);
5533
5534 bfd_put_16 (output_bfd, 0x0412, contents + offset + 2);
5535 bfd_put_16 (output_bfd, 0x00ce, contents + offset + 4);
5536 bfd_put_16 (output_bfd, 0x304c, contents + offset + 6);
5537 bfd_put_16 (output_bfd, 0x0009, contents + offset + 8);
5538 bfd_put_16 (output_bfd, 0x0009, contents + offset + 10);
5539
5540 bfd_put_32 (output_bfd, sgot->output_offset + off,
5541 contents + rel->r_offset);
5542
5543 continue;
5544 }
5545
5546 addend = rel->r_addend;
5547
5548 goto final_link_relocate;
5549
5550 case R_SH_TLS_LD_32:
5551 if (! info->shared)
5552 {
5553 bfd_vma offset;
5554 unsigned short insn;
5555
5556 /* LD->LE transition:
5557 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1;
5558 jsr @r1; add r12,r4; bra 3f; nop; .align 2;
5559 1: .long x$TLSLD; 2: .long __tls_get_addr@PLT; 3:
5560 We change it into:
5561 stc gbr,r0; nop; nop; nop;
5562 nop; nop; bra 3f; ...; 3:. */
5563
5564 offset = rel->r_offset;
5565 BFD_ASSERT (offset >= 16);
5566 /* Size of LD instructions is 16 or 18. */
5567 offset -= 16;
5568 insn = bfd_get_16 (input_bfd, contents + offset + 0);
5569 if ((insn & 0xff00) == 0xc700)
5570 {
5571 BFD_ASSERT (offset >= 2);
5572 offset -= 2;
5573 insn = bfd_get_16 (input_bfd, contents + offset + 0);
5574 }
5575
5576 BFD_ASSERT ((insn & 0xff00) == 0xd400);
5577 insn = bfd_get_16 (input_bfd, contents + offset + 2);
5578 BFD_ASSERT ((insn & 0xff00) == 0xc700);
5579 insn = bfd_get_16 (input_bfd, contents + offset + 4);
5580 BFD_ASSERT ((insn & 0xff00) == 0xd100);
5581 insn = bfd_get_16 (input_bfd, contents + offset + 6);
5582 BFD_ASSERT (insn == 0x310c);
5583 insn = bfd_get_16 (input_bfd, contents + offset + 8);
5584 BFD_ASSERT (insn == 0x410b);
5585 insn = bfd_get_16 (input_bfd, contents + offset + 10);
5586 BFD_ASSERT (insn == 0x34cc);
5587
5588 bfd_put_16 (output_bfd, 0x0012, contents + offset + 0);
5589 bfd_put_16 (output_bfd, 0x0009, contents + offset + 2);
5590 bfd_put_16 (output_bfd, 0x0009, contents + offset + 4);
5591 bfd_put_16 (output_bfd, 0x0009, contents + offset + 6);
5592 bfd_put_16 (output_bfd, 0x0009, contents + offset + 8);
5593 bfd_put_16 (output_bfd, 0x0009, contents + offset + 10);
5594
5595 continue;
5596 }
5597
5598 sgot = htab->sgot;
5599 if (sgot == NULL)
5600 abort ();
5601
5602 off = htab->tls_ldm_got.offset;
5603 if (off & 1)
5604 off &= ~1;
5605 else
5606 {
5607 Elf_Internal_Rela outrel;
947216bf 5608 bfd_byte *loc;
3376eaf5
KK		 5609
5610 srelgot = htab->srelgot;
5611 if (srelgot == NULL)
5612 abort ();
5613
5614 outrel.r_offset = (sgot->output_section->vma
5615 + sgot->output_offset + off);
5616 outrel.r_addend = 0;
5617 outrel.r_info = ELF32_R_INFO (0, R_SH_TLS_DTPMOD32);
947216bf
AM		 5618 loc = srelgot->contents;
5619 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
3376eaf5
KK		 5620 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
5621 htab->tls_ldm_got.offset |= 1;
5622 }
5623
5624 relocation = sgot->output_offset + off;
5625 addend = rel->r_addend;
5626
5627 goto final_link_relocate;
5628
5629 case R_SH_TLS_LDO_32:
5630 if (! info->shared)
267fb3c1 5631 relocation = tpoff (info, relocation);
3376eaf5
KK		 5632 else
5633 relocation -= dtpoff_base (info);
5634
5635 addend = rel->r_addend;
5636 goto final_link_relocate;
5637
5638 case R_SH_TLS_LE_32:
5639 {
5640 int indx;
5641 Elf_Internal_Rela outrel;
947216bf 5642 bfd_byte *loc;
3376eaf5 5643
267fb3c1
KK		 5644 if (! info->shared)
5645 {
5646 relocation = tpoff (info, relocation);
5647 addend = rel->r_addend;
5648 goto final_link_relocate;
5649 }
5650
3376eaf5
KK		 5651 if (sreloc == NULL)
5652 {
5653 const char *name;
5654
5655 name = (bfd_elf_string_from_elf_section
5656 (input_bfd,
5657 elf_elfheader (input_bfd)->e_shstrndx,
5658 elf_section_data (input_section)->rel_hdr.sh_name));
5659 if (name == NULL)
b34976b6 5660 return FALSE;
3376eaf5
KK		 5661
5662 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
5663 && strcmp (bfd_get_section_name (input_bfd,
5664 input_section),
5665 name + 5) == 0);
5666
5667 sreloc = bfd_get_section_by_name (dynobj, name);
5668 BFD_ASSERT (sreloc != NULL);
5669 }
5670
267fb3c1
KK		 5671 if (h == NULL || h->dynindx == -1)
5672 indx = 0;
5673 else
5674 indx = h->dynindx;
5675
3376eaf5
KK		 5676 outrel.r_offset = (input_section->output_section->vma
5677 + input_section->output_offset
5678 + rel->r_offset);
5679 outrel.r_info = ELF32_R_INFO (indx, R_SH_TLS_TPOFF32);
5680 if (indx == 0)
5681 outrel.r_addend = relocation - dtpoff_base (info);
5682 else
5683 outrel.r_addend = 0;
3376eaf5 5684
947216bf
AM		 5685 loc = sreloc->contents;
5686 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
5687 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3376eaf5
KK		 5688 continue;
5689 }
37c644f2
AO		 5690 }
5691
146be91a 5692 relocation_done:
37c644f2
AO		 5693 if (r != bfd_reloc_ok)
5694 {
5695 switch (r)
5696 {
5697 default:
5698 case bfd_reloc_outofrange:
5699 abort ();
5700 case bfd_reloc_overflow:
5701 {
5702 const char *name;
5703
5704 if (h != NULL)
5705 name = h->root.root.string;
5706 else
5707 {
252b5132
RH		 5708 name = (bfd_elf_string_from_elf_section
5709 (input_bfd, symtab_hdr->sh_link, sym->st_name));
5710 if (name == NULL)
b34976b6 5711 return FALSE;
252b5132
RH		 5712 if (*name == '\0')
5713 name = bfd_section_name (input_bfd, sec);
5714 }
5715 if (! ((*info->callbacks->reloc_overflow)
5716 (info, name, howto->name, (bfd_vma) 0,
5717 input_bfd, input_section, rel->r_offset)))
b34976b6 5718 return FALSE;
252b5132
RH		 5719 }
5720 break;
5721 }
5722 }
5723 }
5724
b34976b6 5725 return TRUE;
252b5132
RH		 5726}
5727
5728/* This is a version of bfd_generic_get_relocated_section_contents
5729 which uses sh_elf_relocate_section. */
5730
5731static bfd_byte *
5732sh_elf_get_relocated_section_contents (output_bfd, link_info, link_order,
1049f94e 5733 data, relocatable, symbols)
252b5132
RH		 5734 bfd *output_bfd;
5735 struct bfd_link_info *link_info;
5736 struct bfd_link_order *link_order;
5737 bfd_byte *data;
1049f94e 5738 bfd_boolean relocatable;
252b5132
RH		 5739 asymbol **symbols;
5740{
5741 Elf_Internal_Shdr *symtab_hdr;
5742 asection *input_section = link_order->u.indirect.section;
5743 bfd *input_bfd = input_section->owner;
5744 asection **sections = NULL;
5745 Elf_Internal_Rela *internal_relocs = NULL;
6cdc0ccc 5746 Elf_Internal_Sym *isymbuf = NULL;
252b5132
RH		 5747
5748 /* We only need to handle the case of relaxing, or of having a
5749 particular set of section contents, specially. */
1049f94e 5750 if (relocatable
252b5132
RH		 5751 || elf_section_data (input_section)->this_hdr.contents == NULL)
5752 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
5753 link_order, data,
1049f94e 5754 relocatable,
252b5132
RH		 5755 symbols);
5756
5757 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
5758
5759 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
dc810e39 5760 (size_t) input_section->_raw_size);
252b5132
RH		 5761
5762 if ((input_section->flags & SEC_RELOC) != 0
5763 && input_section->reloc_count > 0)
5764 {
252b5132 5765 asection **secpp;
6cdc0ccc 5766 Elf_Internal_Sym *isym, *isymend;
9ad5cbcf 5767 bfd_size_type amt;
252b5132 5768
45d6a902 5769 internal_relocs = (_bfd_elf_link_read_relocs
252b5132 5770 (input_bfd, input_section, (PTR) NULL,
b34976b6 5771 (Elf_Internal_Rela *) NULL, FALSE));
252b5132
RH		 5772 if (internal_relocs == NULL)
5773 goto error_return;
5774
6cdc0ccc
AM		 5775 if (symtab_hdr->sh_info != 0)
5776 {
5777 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
5778 if (isymbuf == NULL)
5779 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
5780 symtab_hdr->sh_info, 0,
5781 NULL, NULL, NULL);
5782 if (isymbuf == NULL)
5783 goto error_return;
5784 }
252b5132 5785
9ad5cbcf
AM		 5786 amt = symtab_hdr->sh_info;
5787 amt *= sizeof (asection *);
5788 sections = (asection **) bfd_malloc (amt);
5789 if (sections == NULL && amt != 0)
252b5132
RH		 5790 goto error_return;
5791
6cdc0ccc
AM		 5792 isymend = isymbuf + symtab_hdr->sh_info;
5793 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
252b5132
RH		 5794 {
5795 asection *isec;
5796
6cdc0ccc 5797 if (isym->st_shndx == SHN_UNDEF)
252b5132 5798 isec = bfd_und_section_ptr;
6cdc0ccc 5799 else if (isym->st_shndx == SHN_ABS)
252b5132 5800 isec = bfd_abs_section_ptr;
6cdc0ccc 5801 else if (isym->st_shndx == SHN_COMMON)
252b5132
RH		 5802 isec = bfd_com_section_ptr;
5803 else
6cdc0ccc 5804 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
252b5132
RH		 5805
5806 *secpp = isec;
5807 }
5808
5809 if (! sh_elf_relocate_section (output_bfd, link_info, input_bfd,
5810 input_section, data, internal_relocs,
6cdc0ccc 5811 isymbuf, sections))
252b5132
RH		 5812 goto error_return;
5813
5814 if (sections != NULL)
5815 free (sections);
6cdc0ccc
AM		 5816 if (isymbuf != NULL
5817 && symtab_hdr->contents != (unsigned char *) isymbuf)
5818 free (isymbuf);
5819 if (elf_section_data (input_section)->relocs != internal_relocs)
252b5132 5820 free (internal_relocs);
252b5132
RH		 5821 }
5822
5823 return data;
5824
5825 error_return:
252b5132
RH		 5826 if (sections != NULL)
5827 free (sections);
6cdc0ccc
AM		 5828 if (isymbuf != NULL
5829 && symtab_hdr->contents != (unsigned char *) isymbuf)
5830 free (isymbuf);
5831 if (internal_relocs != NULL
5832 && elf_section_data (input_section)->relocs != internal_relocs)
5833 free (internal_relocs);
252b5132
RH		 5834 return NULL;
5835}
917583ad 5836
3376eaf5
KK		 5837/* Return the base VMA address which should be subtracted from real addresses
5838 when resolving @dtpoff relocation.
5839 This is PT_TLS segment p_vaddr. */
5840
5841static bfd_vma
5842dtpoff_base (info)
5843 struct bfd_link_info *info;
5844{
267fb3c1
KK		 5845 /* If tls_segment is NULL, we should have signalled an error already. */
5846 if (elf_hash_table (info)->tls_segment == NULL)
5847 return 0;
3376eaf5
KK		 5848 return elf_hash_table (info)->tls_segment->start;
5849}
5850
267fb3c1
KK		 5851/* Return the relocation value for R_SH_TLS_TPOFF32.. */
5852
5853static bfd_vma
5854tpoff (info, address)
5855 struct bfd_link_info *info;
5856 bfd_vma address;
5857{
5858 /* If tls_segment is NULL, we should have signalled an error already. */
5859 if (elf_hash_table (info)->tls_segment == NULL)
5860 return 0;
5861 /* SH TLS ABI is variant I and static TLS block start just after tcbhead
5862 structure which has 2 pointer fields. */
5863 return (address - dtpoff_base (info) + 8);
5864}
5865
252b5132 5866static asection *
1e2f5b6e
AM		 5867sh_elf_gc_mark_hook (sec, info, rel, h, sym)
5868 asection *sec;
435b1e90
KH		 5869 struct bfd_link_info *info ATTRIBUTE_UNUSED;
5870 Elf_Internal_Rela *rel;
5871 struct elf_link_hash_entry *h;
5872 Elf_Internal_Sym *sym;
252b5132
RH		 5873{
5874 if (h != NULL)
5875 {
5876 switch (ELF32_R_TYPE (rel->r_info))
435b1e90
KH		 5877 {
5878 case R_SH_GNU_VTINHERIT:
5879 case R_SH_GNU_VTENTRY:
5880 break;
252b5132 5881
435b1e90 5882 default:
4972a8e9
SC		 5883#ifdef INCLUDE_SHMEDIA
5884 while (h->root.type == bfd_link_hash_indirect
5885 && h->root.u.i.link)
5886 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5887#endif
435b1e90
KH		 5888 switch (h->root.type)
5889 {
5890 case bfd_link_hash_defined:
5891 case bfd_link_hash_defweak:
5892 return h->root.u.def.section;
252b5132 5893
435b1e90
KH		 5894 case bfd_link_hash_common:
5895 return h->root.u.c.p->section;
e049a0de 5896
435b1e90
KH		 5897 default:
5898 break;
5899 }
5900 }
5901 }
5902 else
1e2f5b6e 5903 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
9ad5cbcf 5904
252b5132
RH		 5905 return NULL;
5906}
5907
37c644f2
AO		 5908/* Update the got entry reference counts for the section being removed. */
5909
b34976b6 5910static bfd_boolean
252b5132 5911sh_elf_gc_sweep_hook (abfd, info, sec, relocs)
067653c5
AM		 5912 bfd *abfd;
5913 struct bfd_link_info *info;
5914 asection *sec;
5915 const Elf_Internal_Rela *relocs;
252b5132 5916{
067653c5
AM		 5917 Elf_Internal_Shdr *symtab_hdr;
5918 struct elf_link_hash_entry **sym_hashes;
5919 bfd_signed_vma *local_got_refcounts;
5920 const Elf_Internal_Rela *rel, *relend;
067653c5
AM		 5921
5922 elf_section_data (sec)->local_dynrel = NULL;
5923
5924 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5925 sym_hashes = elf_sym_hashes (abfd);
5926 local_got_refcounts = elf_local_got_refcounts (abfd);
5927
5928 relend = relocs + sec->reloc_count;
5929 for (rel = relocs; rel < relend; rel++)
396a6083 5930 {
26e41594
AM		 5931 unsigned long r_symndx;
5932 unsigned int r_type;
5933 struct elf_link_hash_entry *h = NULL;
396a6083
SC		 5934#ifdef INCLUDE_SHMEDIA
5935 int seen_stt_datalabel = 0;
5936#endif
3376eaf5 5937
396a6083 5938 r_symndx = ELF32_R_SYM (rel->r_info);
26e41594 5939 if (r_symndx >= symtab_hdr->sh_info)
396a6083 5940 {
26e41594
AM		 5941 struct elf_sh_link_hash_entry *eh;
5942 struct elf_sh_dyn_relocs **pp;
5943 struct elf_sh_dyn_relocs *p;
5944
396a6083 5945 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
067653c5 5946#ifdef INCLUDE_SHMEDIA
396a6083
SC		 5947 while (h->root.type == bfd_link_hash_indirect
5948 || h->root.type == bfd_link_hash_warning)
5949 {
5950 seen_stt_datalabel |= h->type == STT_DATALABEL;
5951 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5952 }
067653c5 5953#endif
26e41594
AM		 5954 eh = (struct elf_sh_link_hash_entry *) h;
5955 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
5956 if (p->sec == sec)
5957 {
5958 /* Everything must go for SEC. */
5959 *pp = p->next;
5960 break;
5961 }
396a6083 5962 }
067653c5 5963
26e41594
AM		 5964 r_type = ELF32_R_TYPE (rel->r_info);
5965 switch (sh_elf_optimized_tls_reloc (info, r_type, h != NULL))
396a6083
SC		 5966 {
5967 case R_SH_TLS_LD_32:
5968 if (sh_elf_hash_table (info)->tls_ldm_got.refcount > 0)
5969 sh_elf_hash_table (info)->tls_ldm_got.refcount -= 1;
5970 break;
5971
5972 case R_SH_GOT32:
5973 case R_SH_GOTOFF:
5974 case R_SH_GOTPC:
5975#ifdef INCLUDE_SHMEDIA
5976 case R_SH_GOT_LOW16:
5977 case R_SH_GOT_MEDLOW16:
5978 case R_SH_GOT_MEDHI16:
5979 case R_SH_GOT_HI16:
5980 case R_SH_GOT10BY4:
5981 case R_SH_GOT10BY8:
5982 case R_SH_GOTOFF_LOW16:
5983 case R_SH_GOTOFF_MEDLOW16:
5984 case R_SH_GOTOFF_MEDHI16:
5985 case R_SH_GOTOFF_HI16:
5986 case R_SH_GOTPC_LOW16:
5987 case R_SH_GOTPC_MEDLOW16:
5988 case R_SH_GOTPC_MEDHI16:
5989 case R_SH_GOTPC_HI16:
5990#endif
5991 case R_SH_TLS_GD_32:
5992 case R_SH_TLS_IE_32:
5993 if (h != NULL)
5994 {
5995#ifdef INCLUDE_SHMEDIA
5996 if (seen_stt_datalabel)
5997 {
26e41594
AM		 5998 struct elf_sh_link_hash_entry *eh;
5999 eh = (struct elf_sh_link_hash_entry *) h;
396a6083
SC		 6000 if (eh->datalabel_got.refcount > 0)
6001 eh->datalabel_got.refcount -= 1;
6002 }
6003 else
6004#endif
6005 if (h->got.refcount > 0)
6006 h->got.refcount -= 1;
6007 }
6008 else if (local_got_refcounts != NULL)
6009 {
6010#ifdef INCLUDE_SHMEDIA
6011 if (rel->r_addend & 1)
6012 {
6013 if (local_got_refcounts[symtab_hdr->sh_info + r_symndx] > 0)
6014 local_got_refcounts[symtab_hdr->sh_info + r_symndx] -= 1;
6015 }
6016 else
6017#endif
6018 if (local_got_refcounts[r_symndx] > 0)
6019 local_got_refcounts[r_symndx] -= 1;
6020 }
6021 break;
6022
6023 case R_SH_DIR32:
6024 case R_SH_REL32:
26e41594
AM		 6025 if (info->shared)
6026 break;
6027 /* Fall thru */
396a6083
SC		 6028
6029 case R_SH_PLT32:
6030#ifdef INCLUDE_SHMEDIA
6031 case R_SH_PLT_LOW16:
6032 case R_SH_PLT_MEDLOW16:
6033 case R_SH_PLT_MEDHI16:
6034 case R_SH_PLT_HI16:
6035#endif
6036 if (h != NULL)
6037 {
6038 if (h->plt.refcount > 0)
6039 h->plt.refcount -= 1;
6040 }
6041 break;
067653c5 6042
396a6083
SC		 6043 case R_SH_GOTPLT32:
6044#ifdef INCLUDE_SHMEDIA
6045 case R_SH_GOTPLT_LOW16:
6046 case R_SH_GOTPLT_MEDLOW16:
6047 case R_SH_GOTPLT_MEDHI16:
6048 case R_SH_GOTPLT_HI16:
6049 case R_SH_GOTPLT10BY4:
6050 case R_SH_GOTPLT10BY8:
6051#endif
6052 if (h != NULL)
6053 {
26e41594
AM		 6054 struct elf_sh_link_hash_entry *eh;
6055 eh = (struct elf_sh_link_hash_entry *) h;
396a6083 6056 if (eh->gotplt_refcount > 0)
067653c5 6057 {
396a6083
SC		 6058 eh->gotplt_refcount -= 1;
6059 if (h->plt.refcount > 0)
6060 h->plt.refcount -= 1;
067653c5 6061 }
067653c5 6062#ifdef INCLUDE_SHMEDIA
396a6083
SC		 6063 else if (seen_stt_datalabel)
6064 {
6065 if (eh->datalabel_got.refcount > 0)
6066 eh->datalabel_got.refcount -= 1;
6067 }
067653c5 6068#endif
396a6083
SC		 6069 else if (h->got.refcount > 0)
6070 h->got.refcount -= 1;
6071 }
6072 else if (local_got_refcounts != NULL)
6073 {
067653c5 6074#ifdef INCLUDE_SHMEDIA
396a6083
SC		 6075 if (rel->r_addend & 1)
6076 {
6077 if (local_got_refcounts[symtab_hdr->sh_info + r_symndx] > 0)
6078 local_got_refcounts[symtab_hdr->sh_info + r_symndx] -= 1;
6079 }
6080 else
067653c5 6081#endif
396a6083
SC		 6082 if (local_got_refcounts[r_symndx] > 0)
6083 local_got_refcounts[r_symndx] -= 1;
6084 }
6085 break;
067653c5 6086
396a6083
SC		 6087 default:
6088 break;
6089 }
6090 }
067653c5 6091
b34976b6 6092 return TRUE;
252b5132
RH		 6093}
6094
067653c5
AM		 6095/* Copy the extra info we tack onto an elf_link_hash_entry. */
6096
6097static void
6098sh_elf_copy_indirect_symbol (bed, dir, ind)
6099 struct elf_backend_data *bed;
6100 struct elf_link_hash_entry *dir, *ind;
6101{
6102 struct elf_sh_link_hash_entry *edir, *eind;
396a6083
SC		 6103#ifdef INCLUDE_SHMEDIA
6104 bfd_signed_vma tmp;
6105#endif
067653c5
AM		 6106
6107 edir = (struct elf_sh_link_hash_entry *) dir;
6108 eind = (struct elf_sh_link_hash_entry *) ind;
6109
6110 if (eind->dyn_relocs != NULL)
6111 {
6112 if (edir->dyn_relocs != NULL)
6113 {
6114 struct elf_sh_dyn_relocs **pp;
6115 struct elf_sh_dyn_relocs *p;
6116
6117 BFD_ASSERT (ind->root.type != bfd_link_hash_indirect);
6118
6119 /* Add reloc counts against the weak sym to the strong sym
6120 list. Merge any entries against the same section. */
6121 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
6122 {
6123 struct elf_sh_dyn_relocs *q;
6124
6125 for (q = edir->dyn_relocs; q != NULL; q = q->next)
6126 if (q->sec == p->sec)
6127 {
6128 q->pc_count += p->pc_count;
6129 q->count += p->count;
6130 *pp = p->next;
6131 break;
6132 }
6133 if (q == NULL)
6134 pp = &p->next;
6135 }
6136 *pp = edir->dyn_relocs;
6137 }
6138
6139 edir->dyn_relocs = eind->dyn_relocs;
6140 eind->dyn_relocs = NULL;
6141 }
4989d792
SC		 6142 edir->gotplt_refcount = eind->gotplt_refcount;
6143 eind->gotplt_refcount = 0;
396a6083
SC		 6144#ifdef INCLUDE_SHMEDIA
6145 tmp = edir->datalabel_got.refcount;
6146 if (tmp < 1)
6147 {
6148 edir->datalabel_got.refcount = eind->datalabel_got.refcount;
6149 eind->datalabel_got.refcount = tmp;
6150 }
6151 else
6152 BFD_ASSERT (eind->datalabel_got.refcount < 1);
6153#endif
067653c5 6154
3376eaf5
KK		 6155 if (ind->root.type == bfd_link_hash_indirect
6156 && dir->got.refcount <= 0)
6157 {
6158 edir->tls_type = eind->tls_type;
6159 eind->tls_type = GOT_UNKNOWN;
6160 }
6161
04e534c3
KK		 6162 if (ind->root.type != bfd_link_hash_indirect
6163 && (dir->elf_link_hash_flags & ELF_LINK_HASH_DYNAMIC_ADJUSTED) != 0)
6164 /* If called to transfer flags for a weakdef during processing
6165 of elf_adjust_dynamic_symbol, don't copy ELF_LINK_NON_GOT_REF.
6166 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
6167 dir->elf_link_hash_flags |=
6168 (ind->elf_link_hash_flags & (ELF_LINK_HASH_REF_DYNAMIC
6169 | ELF_LINK_HASH_REF_REGULAR
6170 | ELF_LINK_HASH_REF_REGULAR_NONWEAK));
6171 else
6172 _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
067653c5
AM		 6173}
6174
3376eaf5
KK		 6175static int
6176sh_elf_optimized_tls_reloc (info, r_type, is_local)
6177 struct bfd_link_info *info;
6178 int r_type;
6179 int is_local;
6180{
6181 if (info->shared)
6182 return r_type;
6183
6184 switch (r_type)
6185 {
6186 case R_SH_TLS_GD_32:
6187 case R_SH_TLS_IE_32:
6188 if (is_local)
6189 return R_SH_TLS_LE_32;
6190 return R_SH_TLS_IE_32;
6191 case R_SH_TLS_LD_32:
6192 return R_SH_TLS_LE_32;
6193 }
6194
6195 return r_type;
6196}
6197
252b5132
RH		 6198/* Look through the relocs for a section during the first phase.
6199 Since we don't do .gots or .plts, we just need to consider the
6200 virtual table relocs for gc. */
435b1e90 6201
b34976b6 6202static bfd_boolean
252b5132
RH		 6203sh_elf_check_relocs (abfd, info, sec, relocs)
6204 bfd *abfd;
6205 struct bfd_link_info *info;
6206 asection *sec;
6207 const Elf_Internal_Rela *relocs;
6208{
6209 Elf_Internal_Shdr *symtab_hdr;
6210 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
067653c5 6211 struct elf_sh_link_hash_table *htab;
252b5132
RH		 6212 const Elf_Internal_Rela *rel;
6213 const Elf_Internal_Rela *rel_end;
37c644f2
AO		 6214 bfd_vma *local_got_offsets;
6215 asection *sgot;
6216 asection *srelgot;
6217 asection *sreloc;
3376eaf5
KK		 6218 unsigned int r_type;
6219 int tls_type, old_tls_type;
435b1e90 6220
37c644f2
AO		 6221 sgot = NULL;
6222 srelgot = NULL;
6223 sreloc = NULL;
6224
1049f94e 6225 if (info->relocatable)
b34976b6 6226 return TRUE;
435b1e90 6227
252b5132
RH		 6228 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6229 sym_hashes = elf_sym_hashes (abfd);
435b1e90 6230 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
252b5132
RH		 6231 if (!elf_bad_symtab (abfd))
6232 sym_hashes_end -= symtab_hdr->sh_info;
435b1e90 6233
067653c5 6234 htab = sh_elf_hash_table (info);
37c644f2
AO		 6235 local_got_offsets = elf_local_got_offsets (abfd);
6236
252b5132
RH		 6237 rel_end = relocs + sec->reloc_count;
6238 for (rel = relocs; rel < rel_end; rel++)
6239 {
6240 struct elf_link_hash_entry *h;
6241 unsigned long r_symndx;
396a6083
SC		 6242#ifdef INCLUDE_SHMEDIA
6243 int seen_stt_datalabel = 0;
6244#endif
435b1e90 6245
252b5132 6246 r_symndx = ELF32_R_SYM (rel->r_info);
3376eaf5
KK		 6247 r_type = ELF32_R_TYPE (rel->r_info);
6248
252b5132 6249 if (r_symndx < symtab_hdr->sh_info)
435b1e90 6250 h = NULL;
252b5132 6251 else
396a6083
SC		 6252 {
6253 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6254#ifdef INCLUDE_SHMEDIA
6255 while (h->root.type == bfd_link_hash_indirect
6256 || h->root.type == bfd_link_hash_warning)
6257 {
6258 seen_stt_datalabel |= h->type == STT_DATALABEL;
6259 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6260 }
6261#endif
6262 }
435b1e90 6263
3376eaf5
KK		 6264 r_type = sh_elf_optimized_tls_reloc (info, r_type, h == NULL);
6265 if (! info->shared
6266 && r_type == R_SH_TLS_IE_32
6267 && h != NULL
6268 && h->root.type != bfd_link_hash_undefined
6269 && h->root.type != bfd_link_hash_undefweak
6270 && (h->dynindx == -1
6271 || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
6272 r_type = R_SH_TLS_LE_32;
6273
37c644f2 6274 /* Some relocs require a global offset table. */
067653c5 6275 if (htab->sgot == NULL)
37c644f2 6276 {
3376eaf5 6277 switch (r_type)
37c644f2 6278 {
fbca6ad9 6279 case R_SH_GOTPLT32:
37c644f2
AO		 6280 case R_SH_GOT32:
6281 case R_SH_GOTOFF:
6282 case R_SH_GOTPC:
fbca6ad9
AO		 6283#ifdef INCLUDE_SHMEDIA
6284 case R_SH_GOTPLT_LOW16:
6285 case R_SH_GOTPLT_MEDLOW16:
6286 case R_SH_GOTPLT_MEDHI16:
6287 case R_SH_GOTPLT_HI16:
6288 case R_SH_GOTPLT10BY4:
6289 case R_SH_GOTPLT10BY8:
6290 case R_SH_GOT_LOW16:
6291 case R_SH_GOT_MEDLOW16:
6292 case R_SH_GOT_MEDHI16:
6293 case R_SH_GOT_HI16:
6294 case R_SH_GOT10BY4:
6295 case R_SH_GOT10BY8:
6296 case R_SH_GOTOFF_LOW16:
6297 case R_SH_GOTOFF_MEDLOW16:
6298 case R_SH_GOTOFF_MEDHI16:
6299 case R_SH_GOTOFF_HI16:
6300 case R_SH_GOTPC_LOW16:
6301 case R_SH_GOTPC_MEDLOW16:
6302 case R_SH_GOTPC_MEDHI16:
6303 case R_SH_GOTPC_HI16:
6304#endif
3376eaf5
KK		 6305 case R_SH_TLS_GD_32:
6306 case R_SH_TLS_LD_32:
6307 case R_SH_TLS_IE_32:
2293c499
AM		 6308 if (htab->sgot == NULL)
6309 {
6310 if (htab->root.dynobj == NULL)
6311 htab->root.dynobj = abfd;
6312 if (!create_got_section (htab->root.dynobj, info))
6313 return FALSE;
6314 }
37c644f2
AO		 6315 break;
6316
6317 default:
6318 break;
6319 }
6320 }
6321
3376eaf5 6322 switch (r_type)
067653c5
AM		 6323 {
6324 /* This relocation describes the C++ object vtable hierarchy.
6325 Reconstruct it for later use during GC. */
435b1e90
KH		 6326 case R_SH_GNU_VTINHERIT:
6327 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
b34976b6 6328 return FALSE;
435b1e90
KH		 6329 break;
6330
067653c5
AM		 6331 /* This relocation describes which C++ vtable entries are actually
6332 used. Record for later use during GC. */
435b1e90
KH		 6333 case R_SH_GNU_VTENTRY:
6334 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
b34976b6 6335 return FALSE;
435b1e90 6336 break;
37c644f2 6337
3376eaf5
KK		 6338 case R_SH_TLS_IE_32:
6339 if (info->shared)
6340 info->flags |= DF_STATIC_TLS;
6341
6342 /* FALLTHROUGH */
267fb3c1 6343 force_got:
3376eaf5 6344 case R_SH_TLS_GD_32:
37c644f2 6345 case R_SH_GOT32:
fbca6ad9
AO		 6346#ifdef INCLUDE_SHMEDIA
6347 case R_SH_GOT_LOW16:
6348 case R_SH_GOT_MEDLOW16:
6349 case R_SH_GOT_MEDHI16:
6350 case R_SH_GOT_HI16:
6351 case R_SH_GOT10BY4:
6352 case R_SH_GOT10BY8:
6353#endif
3376eaf5
KK		 6354 switch (r_type)
6355 {
6356 default:
6357 tls_type = GOT_NORMAL;
6358 break;
6359 case R_SH_TLS_GD_32:
6360 tls_type = GOT_TLS_GD;
6361 break;
6362 case R_SH_TLS_IE_32:
6363 tls_type = GOT_TLS_IE;
6364 break;
6365 }
6366
37c644f2 6367 if (h != NULL)
3376eaf5 6368 {
396a6083
SC		 6369#ifdef INCLUDE_SHMEDIA
6370 if (seen_stt_datalabel)
6371 {
b34976b6
AM		 6372 struct elf_sh_link_hash_entry *eh
6373 = (struct elf_sh_link_hash_entry *) h;
396a6083
SC		 6374
6375 eh->datalabel_got.refcount += 1;
6376 }
6377 else
6378#endif
6379 h->got.refcount += 1;
3376eaf5
KK		 6380 old_tls_type = sh_elf_hash_entry (h)->tls_type;
6381 }
37c644f2
AO		 6382 else
6383 {
067653c5
AM		 6384 bfd_signed_vma *local_got_refcounts;
6385
435b1e90 6386 /* This is a global offset table entry for a local
067653c5
AM		 6387 symbol. */
6388 local_got_refcounts = elf_local_got_refcounts (abfd);
6389 if (local_got_refcounts == NULL)
37c644f2 6390 {
dc810e39 6391 bfd_size_type size;
37c644f2 6392
dc810e39 6393 size = symtab_hdr->sh_info;
067653c5 6394 size *= sizeof (bfd_signed_vma);
fbca6ad9
AO		 6395#ifdef INCLUDE_SHMEDIA
6396 /* Reserve space for both the datalabel and
6397 codelabel local GOT offsets. */
6398 size *= 2;
6399#endif
3376eaf5 6400 size += symtab_hdr->sh_info;
067653c5
AM		 6401 local_got_refcounts = ((bfd_signed_vma *)
6402 bfd_zalloc (abfd, size));
6403 if (local_got_refcounts == NULL)
b34976b6 6404 return FALSE;
067653c5 6405 elf_local_got_refcounts (abfd) = local_got_refcounts;
3376eaf5
KK		 6406#ifdef INCLUDE_SHMEDIA
6407 /* Take care of both the datalabel and codelabel local
6408 GOT offsets. */
6409 sh_elf_local_got_tls_type (abfd)
6410 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
6411#else
6412 sh_elf_local_got_tls_type (abfd)
6413 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
6414#endif
37c644f2 6415 }
396a6083
SC		 6416#ifdef INCLUDE_SHMEDIA
6417 if (rel->r_addend & 1)
6418 local_got_refcounts[symtab_hdr->sh_info + r_symndx] += 1;
6419 else
6420#endif
6421 local_got_refcounts[r_symndx] += 1;
3376eaf5
KK		 6422 old_tls_type = sh_elf_local_got_tls_type (abfd) [r_symndx];
6423 }
6424
6425 /* If a TLS symbol is accessed using IE at least once,
6426 there is no point to use dynamic model for it. */
6427 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
6428 && (old_tls_type != GOT_TLS_GD || tls_type != GOT_TLS_IE))
6429 {
6430 if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD)
6431 tls_type = GOT_TLS_IE;
6432 else
6433 {
6434 (*_bfd_error_handler)
6435 (_("%s: `%s' accessed both as normal and thread local symbol"),
6436 bfd_archive_filename (abfd), h->root.root.string);
b34976b6 6437 return FALSE;
3376eaf5
KK		 6438 }
6439 }
6440
6441 if (old_tls_type != tls_type)
6442 {
6443 if (h != NULL)
6444 sh_elf_hash_entry (h)->tls_type = tls_type;
6445 else
6446 sh_elf_local_got_tls_type (abfd) [r_symndx] = tls_type;
37c644f2 6447 }
3376eaf5
KK		 6448
6449 break;
6450
6451 case R_SH_TLS_LD_32:
6452 sh_elf_hash_table(info)->tls_ldm_got.refcount += 1;
37c644f2
AO		 6453 break;
6454
fbca6ad9
AO		 6455 case R_SH_GOTPLT32:
6456#ifdef INCLUDE_SHMEDIA
6457 case R_SH_GOTPLT_LOW16:
6458 case R_SH_GOTPLT_MEDLOW16:
6459 case R_SH_GOTPLT_MEDHI16:
6460 case R_SH_GOTPLT_HI16:
6461 case R_SH_GOTPLT10BY4:
6462 case R_SH_GOTPLT10BY8:
6463#endif
6464 /* If this is a local symbol, we resolve it directly without
6465 creating a procedure linkage table entry. */
6466
6467 if (h == NULL
067653c5 6468 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)
fbca6ad9
AO		 6469 || ! info->shared
6470 || info->symbolic
067653c5 6471 || h->dynindx == -1)
fbca6ad9
AO		 6472 goto force_got;
6473
fbca6ad9 6474 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
067653c5 6475 h->plt.refcount += 1;
4989d792 6476 ((struct elf_sh_link_hash_entry *) h)->gotplt_refcount += 1;
fbca6ad9
AO		 6477
6478 break;
6479
37c644f2 6480 case R_SH_PLT32:
fbca6ad9
AO		 6481#ifdef INCLUDE_SHMEDIA
6482 case R_SH_PLT_LOW16:
6483 case R_SH_PLT_MEDLOW16:
6484 case R_SH_PLT_MEDHI16:
6485 case R_SH_PLT_HI16:
6486#endif
37c644f2
AO		 6487 /* This symbol requires a procedure linkage table entry. We
6488 actually build the entry in adjust_dynamic_symbol,
6489 because this might be a case of linking PIC code which is
6490 never referenced by a dynamic object, in which case we
6491 don't need to generate a procedure linkage table entry
6492 after all. */
6493
6494 /* If this is a local symbol, we resolve it directly without
6495 creating a procedure linkage table entry. */
6496 if (h == NULL)
6497 continue;
6498
067653c5 6499 if (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)
37c644f2
AO		 6500 break;
6501
6502 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
067653c5 6503 h->plt.refcount += 1;
37c644f2
AO		 6504 break;
6505
6506 case R_SH_DIR32:
6507 case R_SH_REL32:
067653c5
AM		 6508 if (h != NULL && ! info->shared)
6509 {
6510 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
6511 h->plt.refcount += 1;
6512 }
37c644f2
AO		 6513
6514 /* If we are creating a shared library, and this is a reloc
6515 against a global symbol, or a non PC relative reloc
6516 against a local symbol, then we need to copy the reloc
6517 into the shared library. However, if we are linking with
6518 -Bsymbolic, we do not need to copy a reloc against a
6519 global symbol which is defined in an object we are
6520 including in the link (i.e., DEF_REGULAR is set). At
6521 this point we have not seen all the input files, so it is
6522 possible that DEF_REGULAR is not set now but will be set
6523 later (it is never cleared). We account for that
6524 possibility below by storing information in the
067653c5
AM		 6525 dyn_relocs field of the hash table entry. A similar
6526 situation occurs when creating shared libraries and symbol
6527 visibility changes render the symbol local.
6528
6529 If on the other hand, we are creating an executable, we
6530 may need to keep relocations for symbols satisfied by a
6531 dynamic library if we manage to avoid copy relocs for the
6532 symbol. */
6533 if ((info->shared
6534 && (sec->flags & SEC_ALLOC) != 0
3376eaf5 6535 && (r_type != R_SH_REL32
067653c5
AM		 6536 || (h != NULL
6537 && (! info->symbolic
6538 || h->root.type == bfd_link_hash_defweak
6539 || (h->elf_link_hash_flags
6540 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
6541 || (! info->shared
6542 && (sec->flags & SEC_ALLOC) != 0
6543 && h != NULL
6544 && (h->root.type == bfd_link_hash_defweak
6545 || (h->elf_link_hash_flags
6546 & ELF_LINK_HASH_DEF_REGULAR) == 0)))
37c644f2 6547 {
067653c5
AM		 6548 struct elf_sh_dyn_relocs *p;
6549 struct elf_sh_dyn_relocs **head;
6550
2293c499
AM		 6551 if (htab->root.dynobj == NULL)
6552 htab->root.dynobj = abfd;
067653c5 6553
37c644f2
AO		 6554 /* When creating a shared object, we must copy these
6555 reloc types into the output file. We create a reloc
6556 section in dynobj and make room for this reloc. */
6557 if (sreloc == NULL)
6558 {
6559 const char *name;
6560
6561 name = (bfd_elf_string_from_elf_section
6562 (abfd,
6563 elf_elfheader (abfd)->e_shstrndx,
6564 elf_section_data (sec)->rel_hdr.sh_name));
6565 if (name == NULL)
b34976b6 6566 return FALSE;
37c644f2
AO		 6567
6568 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
6569 && strcmp (bfd_get_section_name (abfd, sec),
6570 name + 5) == 0);
6571
2293c499 6572 sreloc = bfd_get_section_by_name (htab->root.dynobj, name);
37c644f2
AO		 6573 if (sreloc == NULL)
6574 {
6575 flagword flags;
6576
2293c499 6577 sreloc = bfd_make_section (htab->root.dynobj, name);
37c644f2
AO		 6578 flags = (SEC_HAS_CONTENTS | SEC_READONLY
6579 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
6580 if ((sec->flags & SEC_ALLOC) != 0)
6581 flags |= SEC_ALLOC | SEC_LOAD;
6582 if (sreloc == NULL
2293c499
AM		 6583 || ! bfd_set_section_flags (htab->root.dynobj,
6584 sreloc, flags)
6585 || ! bfd_set_section_alignment (htab->root.dynobj,
6586 sreloc, 2))
b34976b6 6587 return FALSE;
37c644f2 6588 }
99e4ae17
AJ		 6589 if (sec->flags & SEC_READONLY)
6590 info->flags |= DF_TEXTREL;
067653c5 6591 elf_section_data (sec)->sreloc = sreloc;
37c644f2
AO		 6592 }
6593
067653c5
AM		 6594 /* If this is a global symbol, we count the number of
6595 relocations we need for this symbol. */
6596 if (h != NULL)
6597 head = &((struct elf_sh_link_hash_entry *) h)->dyn_relocs;
6598 else
37c644f2 6599 {
067653c5 6600 asection *s;
37c644f2 6601
067653c5
AM		 6602 /* Track dynamic relocs needed for local syms too. */
6603 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
6604 sec, r_symndx);
6605 if (s == NULL)
b34976b6 6606 return FALSE;
37c644f2 6607
067653c5
AM		 6608 head = ((struct elf_sh_dyn_relocs **)
6609 &elf_section_data (s)->local_dynrel);
6610 }
37c644f2 6611
067653c5
AM		 6612 p = *head;
6613 if (p == NULL || p->sec != sec)
6614 {
6615 bfd_size_type amt = sizeof (*p);
2293c499 6616 p = bfd_alloc (htab->root.dynobj, amt);
37c644f2 6617 if (p == NULL)
b34976b6 6618 return FALSE;
067653c5
AM		 6619 p->next = *head;
6620 *head = p;
6621 p->sec = sec;
6622 p->count = 0;
6623 p->pc_count = 0;
37c644f2 6624 }
067653c5
AM		 6625
6626 p->count += 1;
3376eaf5 6627 if (r_type == R_SH_REL32)
067653c5 6628 p->pc_count += 1;
37c644f2
AO		 6629 }
6630
6631 break;
3376eaf5
KK		 6632
6633 case R_SH_TLS_LE_32:
6634 if (info->shared)
6635 {
6636 (*_bfd_error_handler) (_("%s: TLS local exec code cannot be linked into shared objects"),
6637 bfd_archive_filename (abfd));
b34976b6 6638 return FALSE;
3376eaf5
KK		 6639 }
6640
267fb3c1 6641 break;
3376eaf5 6642
3376eaf5 6643 case R_SH_TLS_LDO_32:
267fb3c1 6644 /* Nothing to do. */
3376eaf5
KK		 6645 break;
6646
6647 default:
6648 break;
435b1e90 6649 }
252b5132 6650 }
435b1e90 6651
b34976b6 6652 return TRUE;
252b5132
RH		 6653}
6654
fbca6ad9 6655#ifndef sh_elf_set_mach_from_flags
b34976b6 6656static bfd_boolean
d4845d57 6657sh_elf_set_mach_from_flags (abfd)
435b1e90 6658 bfd *abfd;
d4845d57
JR		 6659{
6660 flagword flags = elf_elfheader (abfd)->e_flags;
6661
86033394 6662 switch (flags & EF_SH_MACH_MASK)
d4845d57
JR		 6663 {
6664 case EF_SH1:
6665 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh);
6666 break;
6667 case EF_SH2:
6668 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh2);
6669 break;
5177500f
NC		 6670 case EF_SH2E:
6671 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh2e);
6672 break;
d4845d57
JR		 6673 case EF_SH_DSP:
6674 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh_dsp);
6675 break;
6676 case EF_SH3:
6677 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3);
6678 break;
6679 case EF_SH3_DSP:
6680 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3_dsp);
6681 break;
6682 case EF_SH3E:
6683 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh3e);
6684 break;
6685 case EF_SH_UNKNOWN:
6686 case EF_SH4:
6687 bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh4);
6688 break;
6689 default:
b34976b6 6690 return FALSE;
d4845d57 6691 }
b34976b6 6692 return TRUE;
d4845d57 6693}
fbca6ad9 6694#endif /* not sh_elf_set_mach_from_flags */
d4845d57 6695
fbca6ad9 6696#ifndef sh_elf_set_private_flags
435b1e90
KH		 6697/* Function to keep SH specific file flags. */
6698
b34976b6 6699static bfd_boolean
d4845d57 6700sh_elf_set_private_flags (abfd, flags)
435b1e90 6701 bfd *abfd;
d4845d57
JR		 6702 flagword flags;
6703{
6704 BFD_ASSERT (! elf_flags_init (abfd)
6705 || elf_elfheader (abfd)->e_flags == flags);
6706
6707 elf_elfheader (abfd)->e_flags = flags;
b34976b6 6708 elf_flags_init (abfd) = TRUE;
d4845d57
JR		 6709 return sh_elf_set_mach_from_flags (abfd);
6710}
fbca6ad9 6711#endif /* not sh_elf_set_private_flags */
d4845d57 6712
fbca6ad9 6713#ifndef sh_elf_copy_private_data
d4845d57 6714/* Copy backend specific data from one object module to another */
435b1e90 6715
b34976b6 6716static bfd_boolean
d4845d57 6717sh_elf_copy_private_data (ibfd, obfd)
38b1a46c
NC		 6718 bfd * ibfd;
6719 bfd * obfd;
d4845d57 6720{
38b1a46c 6721 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
d4845d57 6722 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
b34976b6 6723 return TRUE;
d4845d57
JR		 6724
6725 return sh_elf_set_private_flags (obfd, elf_elfheader (ibfd)->e_flags);
6726}
fbca6ad9 6727#endif /* not sh_elf_copy_private_data */
d4845d57 6728
fbca6ad9 6729#ifndef sh_elf_merge_private_data
d4845d57
JR		 6730/* This routine checks for linking big and little endian objects
6731 together, and for linking sh-dsp with sh3e / sh4 objects. */
6732
b34976b6 6733static bfd_boolean
d4845d57
JR		 6734sh_elf_merge_private_data (ibfd, obfd)
6735 bfd *ibfd;
6736 bfd *obfd;
6737{
6738 flagword old_flags, new_flags;
6739
82e51918 6740 if (! _bfd_generic_verify_endian_match (ibfd, obfd))
b34976b6 6741 return FALSE;
d4845d57
JR		 6742
6743 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6744 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
b34976b6 6745 return TRUE;
d4845d57
JR		 6746
6747 if (! elf_flags_init (obfd))
6748 {
a39b79b9 6749 /* This happens when ld starts out with a 'blank' output file. */
b34976b6 6750 elf_flags_init (obfd) = TRUE;
a39b79b9 6751 elf_elfheader (obfd)->e_flags = EF_SH1;
d4845d57
JR		 6752 }
6753 old_flags = elf_elfheader (obfd)->e_flags;
6754 new_flags = elf_elfheader (ibfd)->e_flags;
6755 if ((EF_SH_HAS_DSP (old_flags) && EF_SH_HAS_FP (new_flags))
6756 || (EF_SH_HAS_DSP (new_flags) && EF_SH_HAS_FP (old_flags)))
6757 {
6758 (*_bfd_error_handler)
6759 ("%s: uses %s instructions while previous modules use %s instructions",
8f615d07 6760 bfd_archive_filename (ibfd),
d4845d57
JR		 6761 EF_SH_HAS_DSP (new_flags) ? "dsp" : "floating point",
6762 EF_SH_HAS_DSP (new_flags) ? "floating point" : "dsp");
6763 bfd_set_error (bfd_error_bad_value);
b34976b6 6764 return FALSE;
d4845d57
JR		 6765 }
6766 elf_elfheader (obfd)->e_flags = EF_SH_MERGE_MACH (old_flags, new_flags);
6767
6768 return sh_elf_set_mach_from_flags (obfd);
6769}
fbca6ad9 6770#endif /* not sh_elf_merge_private_data */
d4845d57 6771
3376eaf5
KK		 6772/* Override the generic function because we need to store sh_elf_obj_tdata
6773 as the specific tdata. We set also the machine architecture from flags
6774 here. */
6775
b34976b6 6776static bfd_boolean
3376eaf5
KK		 6777sh_elf_object_p (abfd)
6778 bfd *abfd;
6779{
6780 struct sh_elf_obj_tdata *new_tdata;
6781 bfd_size_type amt = sizeof (struct sh_elf_obj_tdata);
6782
b34976b6
AM		 6783 if (!sh_elf_set_mach_from_flags (abfd))
6784 return FALSE;
3376eaf5
KK		 6785
6786 /* Allocate our special target data. */
6787 new_tdata = bfd_zalloc (abfd, amt);
6788 if (new_tdata == NULL)
b34976b6 6789 return FALSE;
3376eaf5
KK		 6790 new_tdata->root = *abfd->tdata.elf_obj_data;
6791 abfd->tdata.any = new_tdata;
b34976b6 6792 return TRUE;
3376eaf5
KK		 6793}
6794
37c644f2
AO		 6795/* Finish up dynamic symbol handling. We set the contents of various
6796 dynamic sections here. */
6797
b34976b6 6798static bfd_boolean
37c644f2
AO		 6799sh_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
6800 bfd *output_bfd;
6801 struct bfd_link_info *info;
6802 struct elf_link_hash_entry *h;
6803 Elf_Internal_Sym *sym;
6804{
067653c5 6805 struct elf_sh_link_hash_table *htab;
37c644f2 6806
067653c5 6807 htab = sh_elf_hash_table (info);
37c644f2
AO		 6808
6809 if (h->plt.offset != (bfd_vma) -1)
6810 {
6811 asection *splt;
6812 asection *sgot;
6813 asection *srel;
6814
6815 bfd_vma plt_index;
6816 bfd_vma got_offset;
6817 Elf_Internal_Rela rel;
947216bf 6818 bfd_byte *loc;
37c644f2
AO		 6819
6820 /* This symbol has an entry in the procedure linkage table. Set
6821 it up. */
6822
6823 BFD_ASSERT (h->dynindx != -1);
6824
067653c5
AM		 6825 splt = htab->splt;
6826 sgot = htab->sgotplt;
6827 srel = htab->srelplt;
37c644f2
AO		 6828 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
6829
6830 /* Get the index in the procedure linkage table which
6831 corresponds to this symbol. This is the index of this symbol
6832 in all the symbols for which we are making plt entries. The
6833 first entry in the procedure linkage table is reserved. */
6834 plt_index = h->plt.offset / elf_sh_sizeof_plt (info) - 1;
6835
6836 /* Get the offset into the .got table of the entry that
6837 corresponds to this function. Each .got entry is 4 bytes.
6838 The first three are reserved. */
6839 got_offset = (plt_index + 3) * 4;
6840
fbca6ad9 6841#ifdef GOT_BIAS
c8614e8e
AM		 6842 if (info->shared)
6843 got_offset -= GOT_BIAS;
fbca6ad9
AO		 6844#endif
6845
37c644f2
AO		 6846 /* Fill in the entry in the procedure linkage table. */
6847 if (! info->shared)
6848 {
6849 if (elf_sh_plt_entry == NULL)
6850 {
435b1e90 6851 elf_sh_plt_entry = (bfd_big_endian (output_bfd) ?
37c644f2
AO		 6852 elf_sh_plt_entry_be : elf_sh_plt_entry_le);
6853 }
6854 memcpy (splt->contents + h->plt.offset, elf_sh_plt_entry,
6855 elf_sh_sizeof_plt (info));
fbca6ad9
AO		 6856#ifdef INCLUDE_SHMEDIA
6857 movi_shori_putval (output_bfd,
6858 (sgot->output_section->vma
6859 + sgot->output_offset
6860 + got_offset),
6861 (splt->contents + h->plt.offset
6862 + elf_sh_plt_symbol_offset (info)));
6863
c8614e8e 6864 /* Set bottom bit because its for a branch to SHmedia */
fbca6ad9 6865 movi_shori_putval (output_bfd,
c8614e8e
AM		 6866 (splt->output_section->vma + splt->output_offset)
6867 | 1,
fbca6ad9
AO		 6868 (splt->contents + h->plt.offset
6869 + elf_sh_plt_plt0_offset (info)));
6870#else
37c644f2
AO		 6871 bfd_put_32 (output_bfd,
6872 (sgot->output_section->vma
6873 + sgot->output_offset
6874 + got_offset),
6875 (splt->contents + h->plt.offset
6876 + elf_sh_plt_symbol_offset (info)));
6877
6878 bfd_put_32 (output_bfd,
6879 (splt->output_section->vma + splt->output_offset),
6880 (splt->contents + h->plt.offset
6881 + elf_sh_plt_plt0_offset (info)));
fbca6ad9 6882#endif
37c644f2
AO		 6883 }
6884 else
6885 {
6886 if (elf_sh_pic_plt_entry == NULL)
6887 {
435b1e90 6888 elf_sh_pic_plt_entry = (bfd_big_endian (output_bfd) ?
37c644f2
AO		 6889 elf_sh_pic_plt_entry_be :
6890 elf_sh_pic_plt_entry_le);
6891 }
6892 memcpy (splt->contents + h->plt.offset, elf_sh_pic_plt_entry,
6893 elf_sh_sizeof_plt (info));
fbca6ad9
AO		 6894#ifdef INCLUDE_SHMEDIA
6895 movi_shori_putval (output_bfd, got_offset,
6896 (splt->contents + h->plt.offset
6897 + elf_sh_plt_symbol_offset (info)));
6898#else
37c644f2
AO		 6899 bfd_put_32 (output_bfd, got_offset,
6900 (splt->contents + h->plt.offset
6901 + elf_sh_plt_symbol_offset (info)));
fbca6ad9 6902#endif
37c644f2
AO		 6903 }
6904
fbca6ad9 6905#ifdef GOT_BIAS
c8614e8e
AM		 6906 if (info->shared)
6907 got_offset += GOT_BIAS;
fbca6ad9
AO		 6908#endif
6909
6910#ifdef INCLUDE_SHMEDIA
6911 movi_shori_putval (output_bfd,
6912 plt_index * sizeof (Elf32_External_Rela),
6913 (splt->contents + h->plt.offset
6914 + elf_sh_plt_reloc_offset (info)));
6915#else
37c644f2
AO		 6916 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
6917 (splt->contents + h->plt.offset
6918 + elf_sh_plt_reloc_offset (info)));
fbca6ad9 6919#endif
37c644f2
AO		 6920
6921 /* Fill in the entry in the global offset table. */
6922 bfd_put_32 (output_bfd,
6923 (splt->output_section->vma
6924 + splt->output_offset
6925 + h->plt.offset
6926 + elf_sh_plt_temp_offset (info)),
6927 sgot->contents + got_offset);
6928
6929 /* Fill in the entry in the .rela.plt section. */
6930 rel.r_offset = (sgot->output_section->vma
6931 + sgot->output_offset
6932 + got_offset);
6933 rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_JMP_SLOT);
6934 rel.r_addend = 0;
fbca6ad9
AO		 6935#ifdef GOT_BIAS
6936 rel.r_addend = GOT_BIAS;
6937#endif
947216bf
AM		 6938 loc = srel->contents + plt_index * sizeof (Elf32_External_Rela);
6939 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
37c644f2
AO		 6940
6941 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
6942 {
6943 /* Mark the symbol as undefined, rather than as defined in
6944 the .plt section. Leave the value alone. */
6945 sym->st_shndx = SHN_UNDEF;
6946 }
6947 }
6948
3376eaf5
KK		 6949 if (h->got.offset != (bfd_vma) -1
6950 && sh_elf_hash_entry (h)->tls_type != GOT_TLS_GD
6951 && sh_elf_hash_entry (h)->tls_type != GOT_TLS_IE)
37c644f2
AO		 6952 {
6953 asection *sgot;
6954 asection *srel;
6955 Elf_Internal_Rela rel;
947216bf 6956 bfd_byte *loc;
37c644f2
AO		 6957
6958 /* This symbol has an entry in the global offset table. Set it
6959 up. */
6960
067653c5
AM		 6961 sgot = htab->sgot;
6962 srel = htab->srelgot;
37c644f2
AO		 6963 BFD_ASSERT (sgot != NULL && srel != NULL);
6964
6965 rel.r_offset = (sgot->output_section->vma
6966 + sgot->output_offset
dc810e39 6967 + (h->got.offset &~ (bfd_vma) 1));
37c644f2 6968
067653c5
AM		 6969 /* If this is a static link, or it is a -Bsymbolic link and the
6970 symbol is defined locally or was forced to be local because
6971 of a version file, we just want to emit a RELATIVE reloc.
37c644f2
AO		 6972 The entry in the global offset table will already have been
6973 initialized in the relocate_section function. */
6974 if (info->shared
067653c5
AM		 6975 && (info->symbolic
6976 || h->dynindx == -1
6977 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
37c644f2
AO		 6978 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
6979 {
6980 rel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
6981 rel.r_addend = (h->root.u.def.value
6982 + h->root.u.def.section->output_section->vma
6983 + h->root.u.def.section->output_offset);
6984 }
6985 else
6986 {
6987 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
6988 rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_GLOB_DAT);
6989 rel.r_addend = 0;
6990 }
6991
947216bf
AM		 6992 loc = srel->contents;
6993 loc += srel->reloc_count++ * sizeof (Elf32_External_Rela);
6994 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
37c644f2
AO		 6995 }
6996
396a6083
SC		 6997#ifdef INCLUDE_SHMEDIA
6998 {
6999 struct elf_sh_link_hash_entry *eh;
7000
7001 eh = (struct elf_sh_link_hash_entry *) h;
7002 if (eh->datalabel_got.offset != (bfd_vma) -1)
7003 {
7004 asection *sgot;
7005 asection *srel;
7006 Elf_Internal_Rela rel;
947216bf 7007 bfd_byte *loc;
396a6083
SC		 7008
7009 /* This symbol has a datalabel entry in the global offset table.
7010 Set it up. */
7011
7012 sgot = htab->sgot;
7013 srel = htab->srelgot;
7014 BFD_ASSERT (sgot != NULL && srel != NULL);
7015
7016 rel.r_offset = (sgot->output_section->vma
7017 + sgot->output_offset
7018 + (eh->datalabel_got.offset &~ (bfd_vma) 1));
7019
7020 /* If this is a static link, or it is a -Bsymbolic link and the
7021 symbol is defined locally or was forced to be local because
7022 of a version file, we just want to emit a RELATIVE reloc.
7023 The entry in the global offset table will already have been
7024 initialized in the relocate_section function. */
7025 if (info->shared
7026 && (info->symbolic
7027 || h->dynindx == -1
7028 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
7029 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
7030 {
7031 rel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE);
7032 rel.r_addend = (h->root.u.def.value
7033 + h->root.u.def.section->output_section->vma
7034 + h->root.u.def.section->output_offset);
7035 }
7036 else
7037 {
7038 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents
7039 + eh->datalabel_got.offset);
7040 rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_GLOB_DAT);
7041 rel.r_addend = 0;
7042 }
7043
947216bf
AM		 7044 loc = srel->contents;
7045 loc += srel->reloc_count++ * sizeof (Elf32_External_Rela);
7046 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
396a6083
SC		 7047 }
7048 }
7049#endif
7050
37c644f2
AO		 7051 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
7052 {
7053 asection *s;
7054 Elf_Internal_Rela rel;
947216bf 7055 bfd_byte *loc;
37c644f2
AO		 7056
7057 /* This symbol needs a copy reloc. Set it up. */
7058
7059 BFD_ASSERT (h->dynindx != -1
7060 && (h->root.type == bfd_link_hash_defined
7061 || h->root.type == bfd_link_hash_defweak));
7062
7063 s = bfd_get_section_by_name (h->root.u.def.section->owner,
7064 ".rela.bss");
7065 BFD_ASSERT (s != NULL);
7066
7067 rel.r_offset = (h->root.u.def.value
7068 + h->root.u.def.section->output_section->vma
7069 + h->root.u.def.section->output_offset);
7070 rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_COPY);
7071 rel.r_addend = 0;
947216bf
AM		 7072 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
7073 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
37c644f2
AO		 7074 }
7075
7076 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
7077 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
7078 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
7079 sym->st_shndx = SHN_ABS;
7080
b34976b6 7081 return TRUE;
37c644f2
AO		 7082}
7083
7084/* Finish up the dynamic sections. */
7085
b34976b6 7086static bfd_boolean
37c644f2
AO		 7087sh_elf_finish_dynamic_sections (output_bfd, info)
7088 bfd *output_bfd;
7089 struct bfd_link_info *info;
7090{
067653c5 7091 struct elf_sh_link_hash_table *htab;
37c644f2
AO		 7092 asection *sgot;
7093 asection *sdyn;
7094
067653c5 7095 htab = sh_elf_hash_table (info);
067653c5 7096 sgot = htab->sgotplt;
2293c499 7097 sdyn = bfd_get_section_by_name (htab->root.dynobj, ".dynamic");
37c644f2 7098
067653c5 7099 if (htab->root.dynamic_sections_created)
37c644f2
AO		 7100 {
7101 asection *splt;
7102 Elf32_External_Dyn *dyncon, *dynconend;
7103
067653c5 7104 BFD_ASSERT (sgot != NULL && sdyn != NULL);
37c644f2
AO		 7105
7106 dyncon = (Elf32_External_Dyn *) sdyn->contents;
7107 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
7108 for (; dyncon < dynconend; dyncon++)
7109 {
7110 Elf_Internal_Dyn dyn;
37c644f2 7111 asection *s;
067653c5
AM		 7112#ifdef INCLUDE_SHMEDIA
7113 const char *name;
7114#endif
37c644f2 7115
2293c499 7116 bfd_elf32_swap_dyn_in (htab->root.dynobj, dyncon, &dyn);
37c644f2
AO		 7117
7118 switch (dyn.d_tag)
7119 {
7120 default:
7121 break;
7122
3b587c71
AM		 7123#ifdef INCLUDE_SHMEDIA
7124 case DT_INIT:
7125 name = info->init_function;
7126 goto get_sym;
7127
7128 case DT_FINI:
7129 name = info->fini_function;
7130 get_sym:
7131 if (dyn.d_un.d_val != 0)
7132 {
067653c5
AM		 7133 struct elf_link_hash_entry *h;
7134
7135 h = elf_link_hash_lookup (&htab->root, name,
b34976b6 7136 FALSE, FALSE, TRUE);
3b587c71
AM		 7137 if (h != NULL && (h->other & STO_SH5_ISA32))
7138 {
7139 dyn.d_un.d_val |= 1;
7140 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7141 }
7142 }
7143 break;
7144#endif
7145
37c644f2 7146 case DT_PLTGOT:
067653c5 7147 s = htab->sgot->output_section;
37c644f2
AO		 7148 goto get_vma;
7149
7150 case DT_JMPREL:
067653c5 7151 s = htab->srelplt->output_section;
37c644f2 7152 get_vma:
37c644f2
AO		 7153 BFD_ASSERT (s != NULL);
7154 dyn.d_un.d_ptr = s->vma;
7155 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7156 break;
7157
7158 case DT_PLTRELSZ:
067653c5 7159 s = htab->srelplt->output_section;
37c644f2
AO		 7160 BFD_ASSERT (s != NULL);
7161 if (s->_cooked_size != 0)
7162 dyn.d_un.d_val = s->_cooked_size;
7163 else
7164 dyn.d_un.d_val = s->_raw_size;
7165 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7166 break;
7167
7168 case DT_RELASZ:
7169 /* My reading of the SVR4 ABI indicates that the
7170 procedure linkage table relocs (DT_JMPREL) should be
7171 included in the overall relocs (DT_RELA). This is
7172 what Solaris does. However, UnixWare can not handle
7173 that case. Therefore, we override the DT_RELASZ entry
7174 here to make it not include the JMPREL relocs. Since
7175 the linker script arranges for .rela.plt to follow all
7176 other relocation sections, we don't have to worry
7177 about changing the DT_RELA entry. */
067653c5 7178 if (htab->srelplt != NULL)
37c644f2 7179 {
067653c5 7180 s = htab->srelplt->output_section;
37c644f2
AO		 7181 if (s->_cooked_size != 0)
7182 dyn.d_un.d_val -= s->_cooked_size;
7183 else
7184 dyn.d_un.d_val -= s->_raw_size;
7185 }
7186 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
7187 break;
7188 }
7189 }
7190
7191 /* Fill in the first entry in the procedure linkage table. */
067653c5 7192 splt = htab->splt;
37c644f2
AO		 7193 if (splt && splt->_raw_size > 0)
7194 {
7195 if (info->shared)
7196 {
7197 if (elf_sh_pic_plt_entry == NULL)
7198 {
435b1e90 7199 elf_sh_pic_plt_entry = (bfd_big_endian (output_bfd) ?
37c644f2
AO		 7200 elf_sh_pic_plt_entry_be :
7201 elf_sh_pic_plt_entry_le);
7202 }
7203 memcpy (splt->contents, elf_sh_pic_plt_entry,
7204 elf_sh_sizeof_plt (info));
7205 }
7206 else
7207 {
7208 if (elf_sh_plt0_entry == NULL)
7209 {
435b1e90 7210 elf_sh_plt0_entry = (bfd_big_endian (output_bfd) ?
37c644f2
AO		 7211 elf_sh_plt0_entry_be :
7212 elf_sh_plt0_entry_le);
7213 }
7214 memcpy (splt->contents, elf_sh_plt0_entry, PLT_ENTRY_SIZE);
fbca6ad9
AO		 7215#ifdef INCLUDE_SHMEDIA
7216 movi_shori_putval (output_bfd,
7217 sgot->output_section->vma
7218 + sgot->output_offset,
7219 splt->contents
7220 + elf_sh_plt0_gotplt_offset (info));
7221#else
37c644f2
AO		 7222 bfd_put_32 (output_bfd,
7223 sgot->output_section->vma + sgot->output_offset + 4,
7224 splt->contents + elf_sh_plt0_gotid_offset (info));
7225 bfd_put_32 (output_bfd,
7226 sgot->output_section->vma + sgot->output_offset + 8,
7227 splt->contents + elf_sh_plt0_linker_offset (info));
fbca6ad9 7228#endif
37c644f2
AO		 7229 }
7230
7231 /* UnixWare sets the entsize of .plt to 4, although that doesn't
7232 really seem like the right value. */
7233 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
7234 }
7235 }
7236
7237 /* Fill in the first three entries in the global offset table. */
067653c5 7238 if (sgot && sgot->_raw_size > 0)
37c644f2
AO		 7239 {
7240 if (sdyn == NULL)
7241 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
7242 else
7243 bfd_put_32 (output_bfd,
7244 sdyn->output_section->vma + sdyn->output_offset,
7245 sgot->contents);
7246 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
7247 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
37c644f2 7248
067653c5
AM		 7249 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
7250 }
37c644f2 7251
b34976b6 7252 return TRUE;
37c644f2
AO		 7253}
7254
99e4ae17 7255static enum elf_reloc_type_class
f51e552e
AM		 7256sh_elf_reloc_type_class (rela)
7257 const Elf_Internal_Rela *rela;
99e4ae17 7258{
f51e552e 7259 switch ((int) ELF32_R_TYPE (rela->r_info))
99e4ae17
AJ		 7260 {
7261 case R_SH_RELATIVE:
7262 return reloc_class_relative;
7263 case R_SH_JMP_SLOT:
7264 return reloc_class_plt;
7265 case R_SH_COPY:
7266 return reloc_class_copy;
7267 default:
7268 return reloc_class_normal;
7269 }
7270}
7271
571fe01f 7272/* Support for Linux core dump NOTE sections. */
b34976b6 7273static bfd_boolean
2bc3c89a
AM		 7274elf32_shlin_grok_prstatus (abfd, note)
7275 bfd *abfd;
7276 Elf_Internal_Note *note;
7277{
7278 int offset;
7279 unsigned int raw_size;
7280
7281 switch (note->descsz)
7282 {
7283 default:
b34976b6 7284 return FALSE;
2bc3c89a
AM		 7285
7286 case 168: /* Linux/SH */
7287 /* pr_cursig */
7288 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
7289
7290 /* pr_pid */
7291 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
7292
7293 /* pr_reg */
7294 offset = 72;
7295 raw_size = 92;
7296
7297 break;
7298 }
7299
7300 /* Make a ".reg/999" section. */
7301 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
7302 raw_size, note->descpos + offset);
7303}
7304
b34976b6 7305static bfd_boolean
2bc3c89a
AM		 7306elf32_shlin_grok_psinfo (abfd, note)
7307 bfd *abfd;
7308 Elf_Internal_Note *note;
7309{
7310 switch (note->descsz)
7311 {
7312 default:
b34976b6 7313 return FALSE;
2bc3c89a
AM		 7314
7315 case 124: /* Linux/SH elf_prpsinfo */
7316 elf_tdata (abfd)->core_program
7317 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
7318 elf_tdata (abfd)->core_command
7319 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
7320 }
7321
7322 /* Note that for some reason, a spurious space is tacked
7323 onto the end of the args in some (at least one anyway)
7324 implementations, so strip it off if it exists. */
7325
7326 {
7327 char *command = elf_tdata (abfd)->core_command;
7328 int n = strlen (command);
7329
7330 if (0 < n && command[n - 1] == ' ')
7331 command[n - 1] = '\0';
7332 }
7333
b34976b6 7334 return TRUE;
2bc3c89a
AM		 7335}
7336
252b5132
RH		 7337#define TARGET_BIG_SYM bfd_elf32_sh_vec
7338#define TARGET_BIG_NAME "elf32-sh"
7339#define TARGET_LITTLE_SYM bfd_elf32_shl_vec
7340#define TARGET_LITTLE_NAME "elf32-shl"
7341#define ELF_ARCH bfd_arch_sh
7342#define ELF_MACHINE_CODE EM_SH
4bb5e078 7343#define ELF_MAXPAGESIZE 128
252b5132
RH		 7344
7345#define elf_symbol_leading_char '_'
7346
7347#define bfd_elf32_bfd_reloc_type_lookup sh_elf_reloc_type_lookup
7348#define elf_info_to_howto sh_elf_info_to_howto
7349#define bfd_elf32_bfd_relax_section sh_elf_relax_section
7350#define elf_backend_relocate_section sh_elf_relocate_section
7351#define bfd_elf32_bfd_get_relocated_section_contents \
7352 sh_elf_get_relocated_section_contents
3376eaf5
KK		 7353#define bfd_elf32_mkobject sh_elf_mkobject
7354#define elf_backend_object_p sh_elf_object_p
d4845d57
JR		 7355#define bfd_elf32_bfd_set_private_bfd_flags \
7356 sh_elf_set_private_flags
7357#define bfd_elf32_bfd_copy_private_bfd_data \
7358 sh_elf_copy_private_data
875f7f69 7359#define bfd_elf32_bfd_merge_private_bfd_data \
d4845d57 7360 sh_elf_merge_private_data
252b5132 7361
067653c5
AM		 7362#define elf_backend_gc_mark_hook sh_elf_gc_mark_hook
7363#define elf_backend_gc_sweep_hook sh_elf_gc_sweep_hook
7364#define elf_backend_check_relocs sh_elf_check_relocs
7365#define elf_backend_copy_indirect_symbol \
7366 sh_elf_copy_indirect_symbol
37c644f2
AO		 7367#define elf_backend_create_dynamic_sections \
7368 sh_elf_create_dynamic_sections
7369#define bfd_elf32_bfd_link_hash_table_create \
7370 sh_elf_link_hash_table_create
7371#define elf_backend_adjust_dynamic_symbol \
7372 sh_elf_adjust_dynamic_symbol
7373#define elf_backend_size_dynamic_sections \
7374 sh_elf_size_dynamic_sections
7375#define elf_backend_finish_dynamic_symbol \
7376 sh_elf_finish_dynamic_symbol
7377#define elf_backend_finish_dynamic_sections \
7378 sh_elf_finish_dynamic_sections
99e4ae17 7379#define elf_backend_reloc_type_class sh_elf_reloc_type_class
37c644f2 7380
067653c5
AM		 7381#define elf_backend_can_gc_sections 1
7382#define elf_backend_can_refcount 1
37c644f2
AO		 7383#define elf_backend_want_got_plt 1
7384#define elf_backend_plt_readonly 1
7385#define elf_backend_want_plt_sym 0
7386#define elf_backend_got_header_size 12
7387#define elf_backend_plt_header_size PLT_ENTRY_SIZE
ed71e111 7388
2bc3c89a
AM		 7389#ifndef INCLUDE_SHMEDIA
7390
252b5132 7391#include "elf32-target.h"
ed71e111 7392
2bc3c89a
AM		 7393/* NetBSD support. */
7394#undef TARGET_BIG_SYM
7395#define TARGET_BIG_SYM bfd_elf32_shnbsd_vec
7396#undef TARGET_BIG_NAME
7397#define TARGET_BIG_NAME "elf32-sh-nbsd"
7398#undef TARGET_LITTLE_SYM
7399#define TARGET_LITTLE_SYM bfd_elf32_shlnbsd_vec
7400#undef TARGET_LITTLE_NAME
7401#define TARGET_LITTLE_NAME "elf32-shl-nbsd"
7402#undef ELF_MAXPAGESIZE
7403#define ELF_MAXPAGESIZE 0x10000
7404#undef elf_symbol_leading_char
7405#define elf_symbol_leading_char 0
571fe01f 7406#undef elf32_bed
2bc3c89a
AM		 7407#define elf32_bed elf32_sh_nbsd_bed
7408
7409#include "elf32-target.h"
7410
2bc3c89a
AM		 7411
7412/* Linux support. */
7413#undef TARGET_BIG_SYM
7414#define TARGET_BIG_SYM bfd_elf32_shblin_vec
7415#undef TARGET_BIG_NAME
7416#define TARGET_BIG_NAME "elf32-shbig-linux"
7417#undef TARGET_LITTLE_SYM
7418#define TARGET_LITTLE_SYM bfd_elf32_shlin_vec
7419#undef TARGET_LITTLE_NAME
7420#define TARGET_LITTLE_NAME "elf32-sh-linux"
7421
7422#undef elf_backend_grok_prstatus
7423#define elf_backend_grok_prstatus elf32_shlin_grok_prstatus
7424#undef elf_backend_grok_psinfo
7425#define elf_backend_grok_psinfo elf32_shlin_grok_psinfo
571fe01f 7426#undef elf32_bed
2bc3c89a
AM		 7427#define elf32_bed elf32_sh_lin_bed
7428
7429#include "elf32-target.h"
7430
2bc3c89a 7431#endif /* INCLUDE_SHMEDIA */
GDB Binutils - Deliverables
This page took 0.611871 seconds and 4 git commands to generate.