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