OpenCores
URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [bfd/] [elf64-sh64.c] - Blame information for rev 139

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 14 khays
/* SuperH SH64-specific support for 64-bit ELF
2
   Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
3
   2010  Free Software Foundation, Inc.
4
 
5
   This file is part of BFD, the Binary File Descriptor library.
6
 
7
   This program is free software; you can redistribute it and/or modify
8
   it under the terms of the GNU General Public License as published by
9
   the Free Software Foundation; either version 3 of the License, or
10
   (at your option) any later version.
11
 
12
   This program is distributed in the hope that it will be useful,
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
   GNU General Public License for more details.
16
 
17
   You should have received a copy of the GNU General Public License
18
   along with this program; if not, write to the Free Software
19
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20
   MA 02110-1301, USA.  */
21
 
22
#define SH64_ELF64
23
 
24
#include "sysdep.h"
25
#include "bfd.h"
26
#include "bfdlink.h"
27
#include "libbfd.h"
28
#include "elf-bfd.h"
29
#include "elf/sh.h"
30
 
31
/* Add a suffix for datalabel indirection symbols.  It must not match any
32
   other symbols; user symbols with or without version or other
33
   decoration.  It must only be used internally and not emitted by any
34
   means.  */
35
#define DATALABEL_SUFFIX " DL"
36
 
37
#define GOT_BIAS (-((long)-32768))
38
 
39
#define PLT_ENTRY_SIZE 64
40
 
41
/* Return size of a PLT entry.  */
42
#define elf_sh64_sizeof_plt(info) PLT_ENTRY_SIZE
43
 
44
/* Return offset of the PLT0 address in an absolute PLT entry.  */
45
#define elf_sh64_plt_plt0_offset(info) 32
46
 
47
/* Return offset of the linker in PLT0 entry.  */
48
#define elf_sh64_plt0_gotplt_offset(info) 0
49
 
50
/* Return offset of the trampoline in PLT entry */
51
#define elf_sh64_plt_temp_offset(info) 33 /* Add one because it's SHmedia.  */
52
 
53
/* Return offset of the symbol in PLT entry.  */
54
#define elf_sh64_plt_symbol_offset(info) 0
55
 
56
/* Return offset of the relocation in PLT entry.  */
57
#define elf_sh64_plt_reloc_offset(info) (info->shared ? 52 : 44)
58
 
59
#define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
60
 
61
/* The sh linker needs to keep track of the number of relocs that it
62
   decides to copy in check_relocs for each symbol.  This is so that
63
   it can discard PC relative relocs if it doesn't need them when
64
   linking with -Bsymbolic.  We store the information in a field
65
   extending the regular ELF linker hash table.  */
66
 
67
/* This structure keeps track of the number of PC relative relocs we
68
   have copied for a given symbol.  */
69
 
70
struct elf_sh64_pcrel_relocs_copied
71
{
72
  /* Next section.  */
73
  struct elf_sh64_pcrel_relocs_copied *next;
74
  /* A section in dynobj.  */
75
  asection *section;
76
  /* Number of relocs copied in this section.  */
77
  bfd_size_type count;
78
};
79
 
80
/* sh ELF linker hash entry.  */
81
 
82
struct elf_sh64_link_hash_entry
83
{
84
  struct elf_link_hash_entry root;
85
 
86
  bfd_vma datalabel_got_offset;
87
 
88
  /* Number of PC relative relocs copied for this symbol.  */
89
  struct elf_sh64_pcrel_relocs_copied *pcrel_relocs_copied;
90
};
91
 
92
/* Traverse an sh ELF linker hash table.  */
93
 
94
#define sh64_elf64_link_hash_traverse(table, func, info)        \
95
  (elf_link_hash_traverse                                       \
96
   ((table),                                                    \
97
    (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
98
    (info)))
99
 
100
static bfd_reloc_status_type sh_elf64_ignore_reloc
101
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
102
static bfd_reloc_status_type sh_elf64_reloc
103
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
104
 
105
static reloc_howto_type sh_elf64_howto_table[] = {
106
  /* No relocation.  */
107
  HOWTO (R_SH_NONE,             /* type */
108
         0,                      /* rightshift */
109
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
110
         0,                      /* bitsize */
111
         FALSE,                 /* pc_relative */
112
         0,                      /* bitpos */
113
         complain_overflow_dont, /* complain_on_overflow */
114
         sh_elf64_ignore_reloc, /* special_function */
115
         "R_SH_NONE",           /* name */
116
         FALSE,                 /* partial_inplace */
117
         0,                      /* src_mask */
118
         0,                      /* dst_mask */
119
         FALSE),                /* pcrel_offset */
120
 
121
  /* 32 bit absolute relocation.  Setting partial_inplace to TRUE and
122
     src_mask to a non-zero value is similar to the COFF toolchain.  */
123
  HOWTO (R_SH_DIR32,            /* type */
124
         0,                      /* rightshift */
125
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
126
         32,                    /* bitsize */
127
         FALSE,                 /* pc_relative */
128
         0,                      /* bitpos */
129
         complain_overflow_bitfield, /* complain_on_overflow */
130
         sh_elf64_reloc,                /* special_function */
131
         "R_SH_DIR32",          /* name */
132
         TRUE,                  /* partial_inplace */
133
         0xffffffff,            /* src_mask */
134
         0xffffffff,            /* dst_mask */
135
         FALSE),                /* pcrel_offset */
136
 
137
  /* 32 bit PC relative relocation.  */
138
  HOWTO (R_SH_REL32,            /* type */
139
         0,                      /* rightshift */
140
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
141
         32,                    /* bitsize */
142
         TRUE,                  /* pc_relative */
143
         0,                      /* bitpos */
144
         complain_overflow_signed, /* complain_on_overflow */
145
         sh_elf64_ignore_reloc, /* special_function */
146
         "R_SH_REL32",          /* name */
147
         FALSE,                 /* partial_inplace */
148
         0,                      /* src_mask */
149
         0xffffffff,            /* dst_mask */
150
         TRUE),                 /* pcrel_offset */
151
 
152
  /* For 32-bit sh, this is R_SH_DIR8WPN.  */
153
  EMPTY_HOWTO (3),
154
 
155
  /* For 32-bit sh, this is R_SH_IND12W.  */
156
  EMPTY_HOWTO (4),
157
 
158
  /* For 32-bit sh, this is R_SH_DIR8WPL.  */
159
  EMPTY_HOWTO (5),
160
 
161
  /* For 32-bit sh, this is R_SH_DIR8WPZ.  */
162
  EMPTY_HOWTO (6),
163
 
164
  /* For 32-bit sh, this is R_SH_DIR8BP.  */
165
  EMPTY_HOWTO (7),
166
 
167
  /* For 32-bit sh, this is R_SH_DIR8W.  */
168
  EMPTY_HOWTO (8),
169
 
170
  /* For 32-bit sh, this is R_SH_DIR8L.  */
171
  EMPTY_HOWTO (9),
172
 
173
  EMPTY_HOWTO (10),
174
  EMPTY_HOWTO (11),
175
  EMPTY_HOWTO (12),
176
  EMPTY_HOWTO (13),
177
  EMPTY_HOWTO (14),
178
  EMPTY_HOWTO (15),
179
  EMPTY_HOWTO (16),
180
  EMPTY_HOWTO (17),
181
  EMPTY_HOWTO (18),
182
  EMPTY_HOWTO (19),
183
  EMPTY_HOWTO (20),
184
  EMPTY_HOWTO (21),
185
  EMPTY_HOWTO (22),
186
  EMPTY_HOWTO (23),
187
  EMPTY_HOWTO (24),
188
 
189
  /* The remaining relocs are a GNU extension used for relaxing.  The
190
     final pass of the linker never needs to do anything with any of
191
     these relocs.  Any required operations are handled by the
192
     relaxation code.  */
193
 
194
  /* A 16 bit switch table entry.  This is generated for an expression
195
     such as ``.word L1 - L2''.  The offset holds the difference
196
     between the reloc address and L2.  */
197
  HOWTO (R_SH_SWITCH16,         /* type */
198
         0,                      /* rightshift */
199
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
200
         16,                    /* bitsize */
201
         FALSE,                 /* pc_relative */
202
         0,                      /* bitpos */
203
         complain_overflow_unsigned, /* complain_on_overflow */
204
         sh_elf64_ignore_reloc, /* special_function */
205
         "R_SH_SWITCH16",       /* name */
206
         FALSE,                 /* partial_inplace */
207
         0,                      /* src_mask */
208
         0,                      /* dst_mask */
209
         TRUE),                 /* pcrel_offset */
210
 
211
  /* A 32 bit switch table entry.  This is generated for an expression
212
     such as ``.long L1 - L2''.  The offset holds the difference
213
     between the reloc address and L2.  */
214
  HOWTO (R_SH_SWITCH32,         /* type */
215
         0,                      /* rightshift */
216
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
217
         32,                    /* bitsize */
218
         FALSE,                 /* pc_relative */
219
         0,                      /* bitpos */
220
         complain_overflow_unsigned, /* complain_on_overflow */
221
         sh_elf64_ignore_reloc, /* special_function */
222
         "R_SH_SWITCH32",       /* name */
223
         FALSE,                 /* partial_inplace */
224
         0,                      /* src_mask */
225
         0,                      /* dst_mask */
226
         TRUE),                 /* pcrel_offset */
227
 
228
  /* For 32-bit sh, this is R_SH_USES.  */
229
  EMPTY_HOWTO (27),
230
 
231
  /* For 32-bit sh, this is R_SH_COUNT.  */
232
  EMPTY_HOWTO (28),
233
 
234
  /* For 32-bit sh, this is R_SH_ALIGN.  FIXME: For linker relaxation,
235
     this might be emitted.  When linker relaxation is implemented, we
236
     might want to use it.  */
237
  EMPTY_HOWTO (29),
238
 
239
  /* For 32-bit sh, this is R_SH_CODE.  FIXME: For linker relaxation,
240
     this might be emitted.  When linker relaxation is implemented, we
241
     might want to use it.  */
242
  EMPTY_HOWTO (30),
243
 
244
  /* For 32-bit sh, this is R_SH_DATA.  FIXME: For linker relaxation,
245
     this might be emitted.  When linker relaxation is implemented, we
246
     might want to use it.  */
247
  EMPTY_HOWTO (31),
248
 
249
  /* For 32-bit sh, this is R_SH_LABEL.  FIXME: For linker relaxation,
250
     this might be emitted.  When linker relaxation is implemented, we
251
     might want to use it.  */
252
  EMPTY_HOWTO (32),
253
 
254
  /* An 8 bit switch table entry.  This is generated for an expression
255
     such as ``.word L1 - L2''.  The offset holds the difference
256
     between the reloc address and L2.  */
257
  HOWTO (R_SH_SWITCH8,          /* type */
258
         0,                      /* rightshift */
259
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
260
         8,                     /* bitsize */
261
         FALSE,                 /* pc_relative */
262
         0,                      /* bitpos */
263
         complain_overflow_unsigned, /* complain_on_overflow */
264
         sh_elf64_ignore_reloc, /* special_function */
265
         "R_SH_SWITCH8",        /* name */
266
         FALSE,                 /* partial_inplace */
267
         0,                      /* src_mask */
268
         0,                      /* dst_mask */
269
         TRUE),                 /* pcrel_offset */
270
 
271
  /* GNU extension to record C++ vtable hierarchy */
272
  HOWTO (R_SH_GNU_VTINHERIT, /* type */
273
         0,                     /* rightshift */
274
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
275
         0,                     /* bitsize */
276
         FALSE,                 /* pc_relative */
277
         0,                     /* bitpos */
278
         complain_overflow_dont, /* complain_on_overflow */
279
         NULL,                  /* special_function */
280
         "R_SH_GNU_VTINHERIT", /* name */
281
         FALSE,                 /* partial_inplace */
282
         0,                     /* src_mask */
283
         0,                     /* dst_mask */
284
         FALSE),                /* pcrel_offset */
285
 
286
  /* GNU extension to record C++ vtable member usage */
287
  HOWTO (R_SH_GNU_VTENTRY,     /* type */
288
         0,                     /* rightshift */
289
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
290
         0,                     /* bitsize */
291
         FALSE,                 /* pc_relative */
292
         0,                     /* bitpos */
293
         complain_overflow_dont, /* complain_on_overflow */
294
         _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
295
         "R_SH_GNU_VTENTRY",   /* name */
296
         FALSE,                 /* partial_inplace */
297
         0,                     /* src_mask */
298
         0,                     /* dst_mask */
299
         FALSE),                /* pcrel_offset */
300
 
301
  /* For 32-bit sh, this is R_SH_LOOP_START.  */
302
  EMPTY_HOWTO (36),
303
 
304
  /* For 32-bit sh, this is R_SH_LOOP_END.  */
305
  EMPTY_HOWTO (37),
306
 
307
  EMPTY_HOWTO (38),
308
  EMPTY_HOWTO (39),
309
  EMPTY_HOWTO (40),
310
  EMPTY_HOWTO (41),
311
  EMPTY_HOWTO (42),
312
  EMPTY_HOWTO (43),
313
  EMPTY_HOWTO (44),
314
 
315
  /* Used in SHLLI.L and SHLRI.L.  */
316
  HOWTO (R_SH_DIR5U,            /* type */
317
         0,                      /* rightshift */
318
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
319
         5,                     /* bitsize */
320
         FALSE,                 /* pc_relative */
321
         10,                    /* bitpos */
322
         complain_overflow_unsigned, /* complain_on_overflow */
323
         bfd_elf_generic_reloc, /* special_function */
324
         "R_SH_DIR5U",          /* name */
325
         FALSE,                 /* partial_inplace */
326
         0,                      /* src_mask */
327
         0xfc00,                /* dst_mask */
328
         FALSE),                /* pcrel_offset */
329
 
330
  /* Used in SHARI, SHLLI et al.  */
331
  HOWTO (R_SH_DIR6U,            /* type */
332
         0,                      /* rightshift */
333
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
334
         6,                     /* bitsize */
335
         FALSE,                 /* pc_relative */
336
         10,                    /* bitpos */
337
         complain_overflow_unsigned, /* complain_on_overflow */
338
         bfd_elf_generic_reloc, /* special_function */
339
         "R_SH_DIR6U",          /* name */
340
         FALSE,                 /* partial_inplace */
341
         0,                      /* src_mask */
342
         0xfc00,                /* dst_mask */
343
         FALSE),                /* pcrel_offset */
344
 
345
  /* Used in BxxI, LDHI.L et al.  */
346
  HOWTO (R_SH_DIR6S,            /* type */
347
         0,                      /* rightshift */
348
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
349
         6,                     /* bitsize */
350
         FALSE,                 /* pc_relative */
351
         10,                    /* bitpos */
352
         complain_overflow_signed, /* complain_on_overflow */
353
         bfd_elf_generic_reloc, /* special_function */
354
         "R_SH_DIR6S",          /* name */
355
         FALSE,                 /* partial_inplace */
356
         0,                      /* src_mask */
357
         0xfc00,                /* dst_mask */
358
         FALSE),                /* pcrel_offset */
359
 
360
  /* Used in ADDI, ANDI et al.  */
361
  HOWTO (R_SH_DIR10S,           /* type */
362
         0,                      /* rightshift */
363
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
364
         10,                    /* bitsize */
365
         FALSE,                 /* pc_relative */
366
         10,                    /* bitpos */
367
         complain_overflow_signed, /* complain_on_overflow */
368
         bfd_elf_generic_reloc, /* special_function */
369
         "R_SH_DIR10S",         /* name */
370
         FALSE,                 /* partial_inplace */
371
         0,                      /* src_mask */
372
         0xffc00,               /* dst_mask */
373
         FALSE),                /* pcrel_offset */
374
 
375
  /* Used in LD.UW, ST.W et al.  */
376
  HOWTO (R_SH_DIR10SW,  /* type */
377
         1,                     /* rightshift */
378
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
379
         11,                    /* bitsize */
380
         FALSE,                 /* pc_relative */
381
         10,                    /* bitpos */
382
         complain_overflow_signed, /* complain_on_overflow */
383
         bfd_elf_generic_reloc, /* special_function */
384
         "R_SH_DIR10SW",        /* name */
385
         FALSE,                 /* partial_inplace */
386
         0,                      /* src_mask */
387
         0xffc00,               /* dst_mask */
388
         FALSE),                /* pcrel_offset */
389
 
390
  /* Used in LD.L, FLD.S et al.  */
391
  HOWTO (R_SH_DIR10SL,  /* type */
392
         2,                     /* rightshift */
393
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
394
         12,                    /* bitsize */
395
         FALSE,                 /* pc_relative */
396
         10,                    /* bitpos */
397
         complain_overflow_signed, /* complain_on_overflow */
398
         bfd_elf_generic_reloc, /* special_function */
399
         "R_SH_DIR10SL",        /* name */
400
         FALSE,                 /* partial_inplace */
401
         0,                      /* src_mask */
402
         0xffc00,               /* dst_mask */
403
         FALSE),                /* pcrel_offset */
404
 
405
  /* Used in FLD.D, FST.P et al.  */
406
  HOWTO (R_SH_DIR10SQ,  /* type */
407
         3,                     /* rightshift */
408
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
409
         13,                    /* bitsize */
410
         FALSE,                 /* pc_relative */
411
         10,                    /* bitpos */
412
         complain_overflow_signed, /* complain_on_overflow */
413
         bfd_elf_generic_reloc, /* special_function */
414
         "R_SH_DIR10SQ",        /* name */
415
         FALSE,                 /* partial_inplace */
416
         0,                      /* src_mask */
417
         0xffc00,               /* dst_mask */
418
         FALSE),                /* pcrel_offset */
419
 
420
  EMPTY_HOWTO (52),
421
  EMPTY_HOWTO (53),
422
  EMPTY_HOWTO (54),
423
  EMPTY_HOWTO (55),
424
  EMPTY_HOWTO (56),
425
  EMPTY_HOWTO (57),
426
  EMPTY_HOWTO (58),
427
  EMPTY_HOWTO (59),
428
  EMPTY_HOWTO (60),
429
  EMPTY_HOWTO (61),
430
  EMPTY_HOWTO (62),
431
  EMPTY_HOWTO (63),
432
  EMPTY_HOWTO (64),
433
  EMPTY_HOWTO (65),
434
  EMPTY_HOWTO (66),
435
  EMPTY_HOWTO (67),
436
  EMPTY_HOWTO (68),
437
  EMPTY_HOWTO (69),
438
  EMPTY_HOWTO (70),
439
  EMPTY_HOWTO (71),
440
  EMPTY_HOWTO (72),
441
  EMPTY_HOWTO (73),
442
  EMPTY_HOWTO (74),
443
  EMPTY_HOWTO (75),
444
  EMPTY_HOWTO (76),
445
  EMPTY_HOWTO (77),
446
  EMPTY_HOWTO (78),
447
  EMPTY_HOWTO (79),
448
  EMPTY_HOWTO (80),
449
  EMPTY_HOWTO (81),
450
  EMPTY_HOWTO (82),
451
  EMPTY_HOWTO (83),
452
  EMPTY_HOWTO (84),
453
  EMPTY_HOWTO (85),
454
  EMPTY_HOWTO (86),
455
  EMPTY_HOWTO (87),
456
  EMPTY_HOWTO (88),
457
  EMPTY_HOWTO (89),
458
  EMPTY_HOWTO (90),
459
  EMPTY_HOWTO (91),
460
  EMPTY_HOWTO (92),
461
  EMPTY_HOWTO (93),
462
  EMPTY_HOWTO (94),
463
  EMPTY_HOWTO (95),
464
  EMPTY_HOWTO (96),
465
  EMPTY_HOWTO (97),
466
  EMPTY_HOWTO (98),
467
  EMPTY_HOWTO (99),
468
  EMPTY_HOWTO (100),
469
  EMPTY_HOWTO (101),
470
  EMPTY_HOWTO (102),
471
  EMPTY_HOWTO (103),
472
  EMPTY_HOWTO (104),
473
  EMPTY_HOWTO (105),
474
  EMPTY_HOWTO (106),
475
  EMPTY_HOWTO (107),
476
  EMPTY_HOWTO (108),
477
  EMPTY_HOWTO (109),
478
  EMPTY_HOWTO (110),
479
  EMPTY_HOWTO (111),
480
  EMPTY_HOWTO (112),
481
  EMPTY_HOWTO (113),
482
  EMPTY_HOWTO (114),
483
  EMPTY_HOWTO (115),
484
  EMPTY_HOWTO (116),
485
  EMPTY_HOWTO (117),
486
  EMPTY_HOWTO (118),
487
  EMPTY_HOWTO (119),
488
  EMPTY_HOWTO (120),
489
  EMPTY_HOWTO (121),
490
  EMPTY_HOWTO (122),
491
  EMPTY_HOWTO (123),
492
  EMPTY_HOWTO (124),
493
  EMPTY_HOWTO (125),
494
  EMPTY_HOWTO (126),
495
  EMPTY_HOWTO (127),
496
  EMPTY_HOWTO (128),
497
  EMPTY_HOWTO (129),
498
  EMPTY_HOWTO (130),
499
  EMPTY_HOWTO (131),
500
  EMPTY_HOWTO (132),
501
  EMPTY_HOWTO (133),
502
  EMPTY_HOWTO (134),
503
  EMPTY_HOWTO (135),
504
  EMPTY_HOWTO (136),
505
  EMPTY_HOWTO (137),
506
  EMPTY_HOWTO (138),
507
  EMPTY_HOWTO (139),
508
  EMPTY_HOWTO (140),
509
  EMPTY_HOWTO (141),
510
  EMPTY_HOWTO (142),
511
  EMPTY_HOWTO (143),
512
  EMPTY_HOWTO (144),
513
  EMPTY_HOWTO (145),
514
  EMPTY_HOWTO (146),
515
  EMPTY_HOWTO (147),
516
  EMPTY_HOWTO (148),
517
  EMPTY_HOWTO (149),
518
  EMPTY_HOWTO (150),
519
  EMPTY_HOWTO (151),
520
  EMPTY_HOWTO (152),
521
  EMPTY_HOWTO (153),
522
  EMPTY_HOWTO (154),
523
  EMPTY_HOWTO (155),
524
  EMPTY_HOWTO (156),
525
  EMPTY_HOWTO (157),
526
  EMPTY_HOWTO (158),
527
  EMPTY_HOWTO (159),
528
 
529
  /* Relocs for dynamic linking for 32-bit SH would follow.  We don't have
530
     any dynamic linking support for 64-bit SH at present.  */
531
 
532
  EMPTY_HOWTO (160),
533
  EMPTY_HOWTO (161),
534
  EMPTY_HOWTO (162),
535
  EMPTY_HOWTO (163),
536
  EMPTY_HOWTO (164),
537
  EMPTY_HOWTO (165),
538
  EMPTY_HOWTO (166),
539
  EMPTY_HOWTO (167),
540
  EMPTY_HOWTO (168),
541
 
542
  /* Back to SH5 relocations.  */
543
  /* Used in MOVI and SHORI (x & 65536).  */
544
  HOWTO (R_SH_GOT_LOW16,        /* type */
545
         0,                      /* rightshift */
546
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
547
         64,                    /* bitsize */
548
         FALSE,                 /* pc_relative */
549
         10,                    /* bitpos */
550
         complain_overflow_dont, /* complain_on_overflow */
551
         bfd_elf_generic_reloc, /* special_function */
552
         "R_SH_GOT_LOW16",      /* name */
553
         FALSE,                 /* partial_inplace */
554
         0,                      /* src_mask */
555
         0x3fffc00,             /* dst_mask */
556
         FALSE),                /* pcrel_offset */
557
 
558
  /* Used in MOVI and SHORI ((x >> 16) & 65536).  */
559
  HOWTO (R_SH_GOT_MEDLOW16,     /* type */
560
         16,                    /* rightshift */
561
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
562
         64,                    /* bitsize */
563
         FALSE,                 /* pc_relative */
564
         10,                    /* bitpos */
565
         complain_overflow_dont, /* complain_on_overflow */
566
         bfd_elf_generic_reloc, /* special_function */
567
         "R_SH_GOT_MEDLOW16",   /* name */
568
         FALSE,                 /* partial_inplace */
569
         0,                      /* src_mask */
570
         0x3fffc00,             /* dst_mask */
571
         FALSE),                /* pcrel_offset */
572
 
573
  /* Used in MOVI and SHORI ((x >> 32) & 65536).  */
574
  HOWTO (R_SH_GOT_MEDHI16,      /* type */
575
         32,                    /* rightshift */
576
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
577
         64,                    /* bitsize */
578
         FALSE,                 /* pc_relative */
579
         10,                    /* bitpos */
580
         complain_overflow_dont, /* complain_on_overflow */
581
         bfd_elf_generic_reloc, /* special_function */
582
         "R_SH_GOT_MEDHI16",    /* name */
583
         FALSE,                 /* partial_inplace */
584
         0,                      /* src_mask */
585
         0x3fffc00,             /* dst_mask */
586
         FALSE),                /* pcrel_offset */
587
 
588
  /* Used in MOVI and SHORI ((x >> 48) & 65536).  */
589
  HOWTO (R_SH_GOT_HI16,         /* type */
590
         48,                    /* rightshift */
591
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
592
         64,                    /* bitsize */
593
         FALSE,                 /* pc_relative */
594
         10,                    /* bitpos */
595
         complain_overflow_dont, /* complain_on_overflow */
596
         bfd_elf_generic_reloc, /* special_function */
597
         "R_SH_GOT_HI16",       /* name */
598
         FALSE,                 /* partial_inplace */
599
         0,                      /* src_mask */
600
         0x3fffc00,             /* dst_mask */
601
         FALSE),                /* pcrel_offset */
602
 
603
  /* Used in MOVI and SHORI (x & 65536).  */
604
  HOWTO (R_SH_GOTPLT_LOW16,     /* type */
605
         0,                      /* rightshift */
606
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
607
         64,                    /* bitsize */
608
         FALSE,                 /* pc_relative */
609
         10,                    /* bitpos */
610
         complain_overflow_dont, /* complain_on_overflow */
611
         bfd_elf_generic_reloc, /* special_function */
612
         "R_SH_GOTPLT_LOW16",   /* name */
613
         FALSE,                 /* partial_inplace */
614
         0,                      /* src_mask */
615
         0x3fffc00,             /* dst_mask */
616
         FALSE),                /* pcrel_offset */
617
 
618
  /* Used in MOVI and SHORI ((x >> 16) & 65536).  */
619
  HOWTO (R_SH_GOTPLT_MEDLOW16,  /* type */
620
         16,                    /* rightshift */
621
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
622
         64,                    /* bitsize */
623
         FALSE,                 /* pc_relative */
624
         10,                    /* bitpos */
625
         complain_overflow_dont, /* complain_on_overflow */
626
         bfd_elf_generic_reloc, /* special_function */
627
         "R_SH_GOTPLT_MEDLOW16", /* name */
628
         FALSE,                 /* partial_inplace */
629
         0,                      /* src_mask */
630
         0x3fffc00,             /* dst_mask */
631
         FALSE),                /* pcrel_offset */
632
 
633
  /* Used in MOVI and SHORI ((x >> 32) & 65536).  */
634
  HOWTO (R_SH_GOTPLT_MEDHI16,   /* type */
635
         32,                    /* rightshift */
636
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
637
         64,                    /* bitsize */
638
         FALSE,                 /* pc_relative */
639
         10,                    /* bitpos */
640
         complain_overflow_dont, /* complain_on_overflow */
641
         bfd_elf_generic_reloc, /* special_function */
642
         "R_SH_GOTPLT_MEDHI16", /* name */
643
         FALSE,                 /* partial_inplace */
644
         0,                      /* src_mask */
645
         0x3fffc00,             /* dst_mask */
646
         FALSE),                /* pcrel_offset */
647
 
648
  /* Used in MOVI and SHORI ((x >> 48) & 65536).  */
649
  HOWTO (R_SH_GOTPLT_HI16,      /* type */
650
         48,                    /* rightshift */
651
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
652
         64,                    /* bitsize */
653
         FALSE,                 /* pc_relative */
654
         10,                    /* bitpos */
655
         complain_overflow_dont, /* complain_on_overflow */
656
         bfd_elf_generic_reloc, /* special_function */
657
         "R_SH_GOTPLT_HI16",    /* name */
658
         FALSE,                 /* partial_inplace */
659
         0,                      /* src_mask */
660
         0x3fffc00,             /* dst_mask */
661
         FALSE),                /* pcrel_offset */
662
 
663
  /* Used in MOVI and SHORI (x & 65536).  */
664
  HOWTO (R_SH_PLT_LOW16,        /* type */
665
         0,                      /* rightshift */
666
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
667
         64,                    /* bitsize */
668
         TRUE,                  /* pc_relative */
669
         10,                    /* bitpos */
670
         complain_overflow_dont, /* complain_on_overflow */
671
         bfd_elf_generic_reloc, /* special_function */
672
         "R_SH_PLT_LOW16",      /* name */
673
         FALSE,                 /* partial_inplace */
674
         0,                      /* src_mask */
675
         0x3fffc00,             /* dst_mask */
676
         TRUE),                 /* pcrel_offset */
677
 
678
  /* Used in MOVI and SHORI ((x >> 16) & 65536).  */
679
  HOWTO (R_SH_PLT_MEDLOW16,     /* type */
680
         16,                    /* rightshift */
681
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
682
         64,                    /* bitsize */
683
         TRUE,                  /* pc_relative */
684
         10,                    /* bitpos */
685
         complain_overflow_dont, /* complain_on_overflow */
686
         bfd_elf_generic_reloc, /* special_function */
687
         "R_SH_PLT_MEDLOW16",   /* name */
688
         FALSE,                 /* partial_inplace */
689
         0,                      /* src_mask */
690
         0x3fffc00,             /* dst_mask */
691
         TRUE),                 /* pcrel_offset */
692
 
693
  /* Used in MOVI and SHORI ((x >> 32) & 65536).  */
694
  HOWTO (R_SH_PLT_MEDHI16,      /* type */
695
         32,                    /* rightshift */
696
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
697
         64,                    /* bitsize */
698
         TRUE,                  /* pc_relative */
699
         10,                    /* bitpos */
700
         complain_overflow_dont, /* complain_on_overflow */
701
         bfd_elf_generic_reloc, /* special_function */
702
         "R_SH_PLT_MEDHI16",    /* name */
703
         FALSE,                 /* partial_inplace */
704
         0,                      /* src_mask */
705
         0x3fffc00,             /* dst_mask */
706
         TRUE),                 /* pcrel_offset */
707
 
708
  /* Used in MOVI and SHORI ((x >> 48) & 65536).  */
709
  HOWTO (R_SH_PLT_HI16,         /* type */
710
         48,                    /* rightshift */
711
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
712
         64,                    /* bitsize */
713
         TRUE,                  /* pc_relative */
714
         10,                    /* bitpos */
715
         complain_overflow_dont, /* complain_on_overflow */
716
         bfd_elf_generic_reloc, /* special_function */
717
         "R_SH_PLT_HI16",       /* name */
718
         FALSE,                 /* partial_inplace */
719
         0,                      /* src_mask */
720
         0x3fffc00,             /* dst_mask */
721
         TRUE),                 /* pcrel_offset */
722
 
723
  /* Used in MOVI and SHORI (x & 65536).  */
724
  HOWTO (R_SH_GOTOFF_LOW16,     /* type */
725
         0,                      /* rightshift */
726
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
727
         64,                    /* bitsize */
728
         FALSE,                 /* pc_relative */
729
         10,                    /* bitpos */
730
         complain_overflow_dont, /* complain_on_overflow */
731
         bfd_elf_generic_reloc, /* special_function */
732
         "R_SH_GOTOFF_LOW16",   /* name */
733
         FALSE,                 /* partial_inplace */
734
         0,                      /* src_mask */
735
         0x3fffc00,             /* dst_mask */
736
         FALSE),                /* pcrel_offset */
737
 
738
  /* Used in MOVI and SHORI ((x >> 16) & 65536).  */
739
  HOWTO (R_SH_GOTOFF_MEDLOW16,  /* type */
740
         16,                    /* rightshift */
741
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
742
         64,                    /* bitsize */
743
         FALSE,                 /* pc_relative */
744
         10,                    /* bitpos */
745
         complain_overflow_dont, /* complain_on_overflow */
746
         bfd_elf_generic_reloc, /* special_function */
747
         "R_SH_GOTOFF_MEDLOW16", /* name */
748
         FALSE,                 /* partial_inplace */
749
         0,                      /* src_mask */
750
         0x3fffc00,             /* dst_mask */
751
         FALSE),                /* pcrel_offset */
752
 
753
  /* Used in MOVI and SHORI ((x >> 32) & 65536).  */
754
  HOWTO (R_SH_GOTOFF_MEDHI16,   /* type */
755
         32,                    /* rightshift */
756
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
757
         64,                    /* bitsize */
758
         FALSE,                 /* pc_relative */
759
         10,                    /* bitpos */
760
         complain_overflow_dont, /* complain_on_overflow */
761
         bfd_elf_generic_reloc, /* special_function */
762
         "R_SH_GOTOFF_MEDHI16", /* name */
763
         FALSE,                 /* partial_inplace */
764
         0,                      /* src_mask */
765
         0x3fffc00,             /* dst_mask */
766
         FALSE),                /* pcrel_offset */
767
 
768
  /* Used in MOVI and SHORI ((x >> 48) & 65536).  */
769
  HOWTO (R_SH_GOTOFF_HI16,      /* type */
770
         48,                    /* rightshift */
771
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
772
         64,                    /* bitsize */
773
         FALSE,                 /* pc_relative */
774
         10,                    /* bitpos */
775
         complain_overflow_dont, /* complain_on_overflow */
776
         bfd_elf_generic_reloc, /* special_function */
777
         "R_SH_GOTOFF_HI16",    /* name */
778
         FALSE,                 /* partial_inplace */
779
         0,                      /* src_mask */
780
         0x3fffc00,             /* dst_mask */
781
         FALSE),                /* pcrel_offset */
782
 
783
  /* Used in MOVI and SHORI (x & 65536).  */
784
  HOWTO (R_SH_GOTPC_LOW16,      /* type */
785
         0,                      /* rightshift */
786
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
787
         64,                    /* bitsize */
788
         TRUE,                  /* pc_relative */
789
         10,                    /* bitpos */
790
         complain_overflow_dont, /* complain_on_overflow */
791
         bfd_elf_generic_reloc, /* special_function */
792
         "R_SH_GOTPC_LOW16",    /* name */
793
         FALSE,                 /* partial_inplace */
794
         0,                      /* src_mask */
795
         0x3fffc00,             /* dst_mask */
796
         TRUE),                 /* pcrel_offset */
797
 
798
  /* Used in MOVI and SHORI ((x >> 16) & 65536).  */
799
  HOWTO (R_SH_GOTPC_MEDLOW16,   /* type */
800
         16,                    /* rightshift */
801
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
802
         64,                    /* bitsize */
803
         TRUE,                  /* pc_relative */
804
         10,                    /* bitpos */
805
         complain_overflow_dont, /* complain_on_overflow */
806
         bfd_elf_generic_reloc, /* special_function */
807
         "R_SH_GOTPC_MEDLOW16", /* name */
808
         FALSE,                 /* partial_inplace */
809
         0,                      /* src_mask */
810
         0x3fffc00,             /* dst_mask */
811
         TRUE),                 /* pcrel_offset */
812
 
813
  /* Used in MOVI and SHORI ((x >> 32) & 65536).  */
814
  HOWTO (R_SH_GOTPC_MEDHI16,    /* type */
815
         32,                    /* rightshift */
816
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
817
         64,                    /* bitsize */
818
         TRUE,                  /* pc_relative */
819
         10,                    /* bitpos */
820
         complain_overflow_dont, /* complain_on_overflow */
821
         bfd_elf_generic_reloc, /* special_function */
822
         "R_SH_GOTPC_MEDHI16",  /* name */
823
         FALSE,                 /* partial_inplace */
824
         0,                      /* src_mask */
825
         0x3fffc00,             /* dst_mask */
826
         TRUE),                 /* pcrel_offset */
827
 
828
  /* Used in MOVI and SHORI ((x >> 48) & 65536).  */
829
  HOWTO (R_SH_GOTPC_HI16,       /* type */
830
         48,                    /* rightshift */
831
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
832
         64,                    /* bitsize */
833
         TRUE,                  /* pc_relative */
834
         10,                    /* bitpos */
835
         complain_overflow_dont, /* complain_on_overflow */
836
         bfd_elf_generic_reloc, /* special_function */
837
         "R_SH_GOTPC_HI16",     /* name */
838
         FALSE,                 /* partial_inplace */
839
         0,                      /* src_mask */
840
         0x3fffc00,             /* dst_mask */
841
         TRUE),                 /* pcrel_offset */
842
 
843
  /* Used in LD.L, FLD.S et al.  */
844
  HOWTO (R_SH_GOT10BY4,         /* type */
845
         2,                     /* rightshift */
846
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
847
         12,                    /* bitsize */
848
         FALSE,                 /* pc_relative */
849
         10,                    /* bitpos */
850
         complain_overflow_signed, /* complain_on_overflow */
851
         bfd_elf_generic_reloc, /* special_function */
852
         "R_SH_GOT10BY4",       /* name */
853
         FALSE,                 /* partial_inplace */
854
         0,                      /* src_mask */
855
         0xffc00,               /* dst_mask */
856
         FALSE),                /* pcrel_offset */
857
 
858
  /* Used in LD.L, FLD.S et al.  */
859
  HOWTO (R_SH_GOTPLT10BY4,      /* type */
860
         2,                     /* rightshift */
861
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
862
         12,                    /* bitsize */
863
         FALSE,                 /* pc_relative */
864
         10,                    /* bitpos */
865
         complain_overflow_signed, /* complain_on_overflow */
866
         bfd_elf_generic_reloc, /* special_function */
867
         "R_SH_GOTPLT10BY4",    /* name */
868
         FALSE,                 /* partial_inplace */
869
         0,                      /* src_mask */
870
         0xffc00,               /* dst_mask */
871
         FALSE),                /* pcrel_offset */
872
 
873
  /* Used in FLD.D, FST.P et al.  */
874
  HOWTO (R_SH_GOT10BY8,         /* type */
875
         3,                     /* rightshift */
876
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
877
         13,                    /* bitsize */
878
         FALSE,                 /* pc_relative */
879
         10,                    /* bitpos */
880
         complain_overflow_signed, /* complain_on_overflow */
881
         bfd_elf_generic_reloc, /* special_function */
882
         "R_SH_GOT10BY8",       /* name */
883
         FALSE,                 /* partial_inplace */
884
         0,                      /* src_mask */
885
         0xffc00,               /* dst_mask */
886
         FALSE),                /* pcrel_offset */
887
 
888
  /* Used in FLD.D, FST.P et al.  */
889
  HOWTO (R_SH_GOTPLT10BY8,      /* type */
890
         3,                     /* rightshift */
891
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
892
         13,                    /* bitsize */
893
         FALSE,                 /* pc_relative */
894
         10,                    /* bitpos */
895
         complain_overflow_signed, /* complain_on_overflow */
896
         bfd_elf_generic_reloc, /* special_function */
897
         "R_SH_GOTPLT10BY8",    /* name */
898
         FALSE,                 /* partial_inplace */
899
         0,                      /* src_mask */
900
         0xffc00,               /* dst_mask */
901
         FALSE),                /* pcrel_offset */
902
 
903
  HOWTO (R_SH_COPY64,           /* type */
904
         0,                      /* rightshift */
905
         4,                     /* size (0 = byte, 1 = short, 2 = long) */
906
         64,                    /* bitsize */
907
         FALSE,                 /* pc_relative */
908
         0,                      /* bitpos */
909
         complain_overflow_dont, /* complain_on_overflow */
910
         bfd_elf_generic_reloc, /* special_function */
911
         "R_SH_COPY64",         /* name */
912
         FALSE,                 /* partial_inplace */
913
         0,                      /* src_mask */
914
         ((bfd_vma) 0) - 1,      /* dst_mask */
915
         FALSE),                /* pcrel_offset */
916
 
917
  HOWTO (R_SH_GLOB_DAT64,       /* type */
918
         0,                      /* rightshift */
919
         4,                     /* size (0 = byte, 1 = short, 2 = long) */
920
         64,                    /* bitsize */
921
         FALSE,                 /* pc_relative */
922
         0,                      /* bitpos */
923
         complain_overflow_dont, /* complain_on_overflow */
924
         bfd_elf_generic_reloc, /* special_function */
925
         "R_SH_GLOB_DAT64",     /* name */
926
         FALSE,                 /* partial_inplace */
927
         0,                      /* src_mask */
928
         ((bfd_vma) 0) - 1,      /* dst_mask */
929
         FALSE),                /* pcrel_offset */
930
 
931
  HOWTO (R_SH_JMP_SLOT64,       /* type */
932
         0,                      /* rightshift */
933
         4,                     /* size (0 = byte, 1 = short, 2 = long) */
934
         64,                    /* bitsize */
935
         FALSE,                 /* pc_relative */
936
         0,                      /* bitpos */
937
         complain_overflow_dont, /* complain_on_overflow */
938
         bfd_elf_generic_reloc, /* special_function */
939
         "R_SH_JMP_SLOT64",     /* name */
940
         FALSE,                 /* partial_inplace */
941
         0,                      /* src_mask */
942
         ((bfd_vma) 0) - 1,      /* dst_mask */
943
         FALSE),                /* pcrel_offset */
944
 
945
  HOWTO (R_SH_RELATIVE64,       /* type */
946
         0,                      /* rightshift */
947
         4,                     /* size (0 = byte, 1 = short, 2 = long) */
948
         64,                    /* bitsize */
949
         FALSE,                 /* pc_relative */
950
         0,                      /* bitpos */
951
         complain_overflow_dont, /* complain_on_overflow */
952
         bfd_elf_generic_reloc, /* special_function */
953
         "R_SH_RELATIVE64",     /* name */
954
         FALSE,                 /* partial_inplace */
955
         0,                      /* src_mask */
956
         ((bfd_vma) 0) - 1,      /* dst_mask */
957
         FALSE),                /* pcrel_offset */
958
 
959
  EMPTY_HOWTO (197),
960
  EMPTY_HOWTO (198),
961
  EMPTY_HOWTO (199),
962
  EMPTY_HOWTO (200),
963
  EMPTY_HOWTO (201),
964
  EMPTY_HOWTO (202),
965
  EMPTY_HOWTO (203),
966
  EMPTY_HOWTO (204),
967
  EMPTY_HOWTO (205),
968
  EMPTY_HOWTO (206),
969
  EMPTY_HOWTO (207),
970
  EMPTY_HOWTO (208),
971
  EMPTY_HOWTO (209),
972
  EMPTY_HOWTO (210),
973
  EMPTY_HOWTO (211),
974
  EMPTY_HOWTO (212),
975
  EMPTY_HOWTO (213),
976
  EMPTY_HOWTO (214),
977
  EMPTY_HOWTO (215),
978
  EMPTY_HOWTO (216),
979
  EMPTY_HOWTO (217),
980
  EMPTY_HOWTO (218),
981
  EMPTY_HOWTO (219),
982
  EMPTY_HOWTO (220),
983
  EMPTY_HOWTO (221),
984
  EMPTY_HOWTO (222),
985
  EMPTY_HOWTO (223),
986
  EMPTY_HOWTO (224),
987
  EMPTY_HOWTO (225),
988
  EMPTY_HOWTO (226),
989
  EMPTY_HOWTO (227),
990
  EMPTY_HOWTO (228),
991
  EMPTY_HOWTO (229),
992
  EMPTY_HOWTO (230),
993
  EMPTY_HOWTO (231),
994
  EMPTY_HOWTO (232),
995
  EMPTY_HOWTO (233),
996
  EMPTY_HOWTO (234),
997
  EMPTY_HOWTO (235),
998
  EMPTY_HOWTO (236),
999
  EMPTY_HOWTO (237),
1000
  EMPTY_HOWTO (238),
1001
  EMPTY_HOWTO (239),
1002
  EMPTY_HOWTO (240),
1003
  EMPTY_HOWTO (241),
1004
 
1005
  /* Relocations for SHmedia code.  None of these are partial_inplace or
1006
     use the field being relocated.  */
1007
 
1008
  /* The assembler will generate this reloc before a block of SHmedia
1009
     instructions.  A section should be processed as assuming it contains
1010
     data, unless this reloc is seen.  Note that a block of SHcompact
1011
     instructions are instead preceded by R_SH_CODE.
1012
     This is currently not implemented, but should be used for SHmedia
1013
     linker relaxation.  */
1014
  HOWTO (R_SH_SHMEDIA_CODE,     /* type */
1015
         0,                      /* rightshift */
1016
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
1017
         0,                      /* bitsize */
1018
         FALSE,                 /* pc_relative */
1019
         0,                      /* bitpos */
1020
         complain_overflow_unsigned, /* complain_on_overflow */
1021
         sh_elf64_ignore_reloc, /* special_function */
1022
         "R_SH_SHMEDIA_CODE",   /* name */
1023
         FALSE,                 /* partial_inplace */
1024
         0,                      /* src_mask */
1025
         0,                      /* dst_mask */
1026
         FALSE),                /* pcrel_offset */
1027
 
1028
  /* The assembler will generate this reloc at a PTA or PTB instruction,
1029
     and the linker checks the right type of target, or changes a PTA to a
1030
     PTB, if the original insn was PT.  */
1031
  HOWTO (R_SH_PT_16,            /* type */
1032
         2,                     /* rightshift */
1033
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
1034
         18,                    /* bitsize */
1035
         TRUE,                  /* pc_relative */
1036
         10,                    /* bitpos */
1037
         complain_overflow_signed, /* complain_on_overflow */
1038
         bfd_elf_generic_reloc, /* special_function */
1039
         "R_SH_PT_16",          /* name */
1040
         FALSE,                 /* partial_inplace */
1041
         0,                      /* src_mask */
1042
         0x3fffc00,             /* dst_mask */
1043
         TRUE),                 /* pcrel_offset */
1044
 
1045
  /* Used in unexpanded MOVI.  */
1046
  HOWTO (R_SH_IMMS16,           /* type */
1047
         0,                      /* rightshift */
1048
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
1049
         16,                    /* bitsize */
1050
         FALSE,                 /* pc_relative */
1051
         10,                    /* bitpos */
1052
         complain_overflow_signed, /* complain_on_overflow */
1053
         bfd_elf_generic_reloc, /* special_function */
1054
         "R_SH_IMMS16",         /* name */
1055
         FALSE,                 /* partial_inplace */
1056
         0,                      /* src_mask */
1057
         0x3fffc00,             /* dst_mask */
1058
         FALSE),                /* pcrel_offset */
1059
 
1060
  /* Used in SHORI.  */
1061
  HOWTO (R_SH_IMMU16,           /* type */
1062
         0,                      /* rightshift */
1063
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
1064
         16,                    /* bitsize */
1065
         FALSE,                 /* pc_relative */
1066
         10,                    /* bitpos */
1067
         complain_overflow_unsigned, /* complain_on_overflow */
1068
         bfd_elf_generic_reloc, /* special_function */
1069
         "R_SH_IMMU16",         /* name */
1070
         FALSE,                 /* partial_inplace */
1071
         0,                      /* src_mask */
1072
         0x3fffc00,             /* dst_mask */
1073
         FALSE),                /* pcrel_offset */
1074
 
1075
  /* Used in MOVI and SHORI (x & 65536).  */
1076
  HOWTO (R_SH_IMM_LOW16,        /* type */
1077
         0,                      /* rightshift */
1078
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
1079
         64,                    /* bitsize */
1080
         FALSE,                 /* pc_relative */
1081
         10,                    /* bitpos */
1082
         complain_overflow_dont, /* complain_on_overflow */
1083
         bfd_elf_generic_reloc, /* special_function */
1084
         "R_SH_IMM_LOW16",      /* name */
1085
         FALSE,                 /* partial_inplace */
1086
         0,                      /* src_mask */
1087
         0x3fffc00,             /* dst_mask */
1088
         FALSE),                /* pcrel_offset */
1089
 
1090
  /* Used in MOVI and SHORI ((x - $) & 65536).  */
1091
  HOWTO (R_SH_IMM_LOW16_PCREL,  /* type */
1092
         0,                      /* rightshift */
1093
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
1094
         64,                    /* bitsize */
1095
         TRUE,                  /* pc_relative */
1096
         10,                    /* bitpos */
1097
         complain_overflow_dont, /* complain_on_overflow */
1098
         bfd_elf_generic_reloc, /* special_function */
1099
         "R_SH_IMM_LOW16_PCREL", /* name */
1100
         FALSE,                 /* partial_inplace */
1101
         0,                      /* src_mask */
1102
         0x3fffc00,             /* dst_mask */
1103
         TRUE),                 /* pcrel_offset */
1104
 
1105
  /* Used in MOVI and SHORI ((x >> 16) & 65536).  */
1106
  HOWTO (R_SH_IMM_MEDLOW16,     /* type */
1107
         16,                    /* rightshift */
1108
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
1109
         64,                    /* bitsize */
1110
         FALSE,                 /* pc_relative */
1111
         10,                    /* bitpos */
1112
         complain_overflow_dont, /* complain_on_overflow */
1113
         bfd_elf_generic_reloc, /* special_function */
1114
         "R_SH_IMM_MEDLOW16",   /* name */
1115
         FALSE,                 /* partial_inplace */
1116
         0,                      /* src_mask */
1117
         0x3fffc00,             /* dst_mask */
1118
         FALSE),                /* pcrel_offset */
1119
 
1120
  /* Used in MOVI and SHORI (((x - $) >> 16) & 65536).  */
1121
  HOWTO (R_SH_IMM_MEDLOW16_PCREL, /* type */
1122
         16,                    /* rightshift */
1123
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
1124
         64,                    /* bitsize */
1125
         TRUE,                  /* pc_relative */
1126
         10,                    /* bitpos */
1127
         complain_overflow_dont, /* complain_on_overflow */
1128
         bfd_elf_generic_reloc, /* special_function */
1129
         "R_SH_IMM_MEDLOW16_PCREL", /* name */
1130
         FALSE,                 /* partial_inplace */
1131
         0,                      /* src_mask */
1132
         0x3fffc00,             /* dst_mask */
1133
         TRUE),                 /* pcrel_offset */
1134
 
1135
  /* Used in MOVI and SHORI ((x >> 32) & 65536).  */
1136
  HOWTO (R_SH_IMM_MEDHI16,      /* type */
1137
         32,                    /* rightshift */
1138
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
1139
         64,                    /* bitsize */
1140
         FALSE,                 /* pc_relative */
1141
         10,                    /* bitpos */
1142
         complain_overflow_dont, /* complain_on_overflow */
1143
         bfd_elf_generic_reloc, /* special_function */
1144
         "R_SH_IMM_MEDHI16",    /* name */
1145
         FALSE,                 /* partial_inplace */
1146
         0,                      /* src_mask */
1147
         0x3fffc00,             /* dst_mask */
1148
         FALSE),                /* pcrel_offset */
1149
 
1150
  /* Used in MOVI and SHORI (((x - $) >> 32) & 65536).  */
1151
  HOWTO (R_SH_IMM_MEDHI16_PCREL, /* type */
1152
         32,                    /* rightshift */
1153
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
1154
         64,                    /* bitsize */
1155
         TRUE,                  /* pc_relative */
1156
         10,                    /* bitpos */
1157
         complain_overflow_dont, /* complain_on_overflow */
1158
         bfd_elf_generic_reloc, /* special_function */
1159
         "R_SH_IMM_MEDHI16_PCREL", /* name */
1160
         FALSE,                 /* partial_inplace */
1161
         0,                      /* src_mask */
1162
         0x3fffc00,             /* dst_mask */
1163
         TRUE),                 /* pcrel_offset */
1164
 
1165
  /* Used in MOVI and SHORI ((x >> 48) & 65536).  */
1166
  HOWTO (R_SH_IMM_HI16,         /* type */
1167
         48,                    /* rightshift */
1168
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
1169
         64,                    /* bitsize */
1170
         FALSE,                 /* pc_relative */
1171
         10,                    /* bitpos */
1172
         complain_overflow_dont, /* complain_on_overflow */
1173
         bfd_elf_generic_reloc, /* special_function */
1174
         "R_SH_IMM_HI16",       /* name */
1175
         FALSE,                 /* partial_inplace */
1176
         0,                      /* src_mask */
1177
         0x3fffc00,             /* dst_mask */
1178
         FALSE),                /* pcrel_offset */
1179
 
1180
  /* Used in MOVI and SHORI (((x - $) >> 48) & 65536).  */
1181
  HOWTO (R_SH_IMM_HI16_PCREL,   /* type */
1182
         48,                    /* rightshift */
1183
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
1184
         64,                    /* bitsize */
1185
         TRUE,                  /* pc_relative */
1186
         10,                    /* bitpos */
1187
         complain_overflow_dont, /* complain_on_overflow */
1188
         bfd_elf_generic_reloc, /* special_function */
1189
         "R_SH_IMM_HI16_PCREL", /* name */
1190
         FALSE,                 /* partial_inplace */
1191
         0,                      /* src_mask */
1192
         0x3fffc00,             /* dst_mask */
1193
         TRUE),                 /* pcrel_offset */
1194
 
1195
  /* For the .uaquad pseudo.  */
1196
  HOWTO (R_SH_64,               /* type */
1197
         0,                      /* rightshift */
1198
         4,                     /* size (0 = byte, 1 = short, 2 = long) */
1199
         64,                    /* bitsize */
1200
         FALSE,                 /* pc_relative */
1201
         0,                      /* bitpos */
1202
         complain_overflow_dont, /* complain_on_overflow */
1203
         bfd_elf_generic_reloc, /* special_function */
1204
         "R_SH_64",             /* name */
1205
         FALSE,                 /* partial_inplace */
1206
         0,                      /* src_mask */
1207
         ((bfd_vma) 0) - 1,      /* dst_mask */
1208
         FALSE),                /* pcrel_offset */
1209
 
1210
  /* For the .uaquad pseudo, (x - $).  */
1211
  HOWTO (R_SH_64_PCREL,         /* type */
1212
         48,                    /* rightshift */
1213
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
1214
         64,                    /* bitsize */
1215
         TRUE,                  /* pc_relative */
1216
         10,                    /* bitpos */
1217
         complain_overflow_dont, /* complain_on_overflow */
1218
         bfd_elf_generic_reloc, /* special_function */
1219
         "R_SH_64_PCREL",       /* name */
1220
         FALSE,                 /* partial_inplace */
1221
         0,                      /* src_mask */
1222
         ((bfd_vma) 0) - 1,      /* dst_mask */
1223
         TRUE),                 /* pcrel_offset */
1224
 
1225
};
1226
 
1227
/* This function is used for relocs which are only used for relaxing,
1228
   which the linker should otherwise ignore.  */
1229
 
1230
static bfd_reloc_status_type
1231
sh_elf64_ignore_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
1232
                       asymbol *symbol ATTRIBUTE_UNUSED,
1233
                       void *data ATTRIBUTE_UNUSED, asection *input_section,
1234
                       bfd *output_bfd,
1235
                       char **error_message ATTRIBUTE_UNUSED)
1236
{
1237
  if (output_bfd != NULL)
1238
    reloc_entry->address += input_section->output_offset;
1239
  return bfd_reloc_ok;
1240
}
1241
 
1242
/* This function is used for normal relocs.  This used to be like the COFF
1243
   function, and is almost certainly incorrect for other ELF targets.
1244
 
1245
   See sh_elf_reloc in elf32-sh.c for the original.  */
1246
 
1247
static bfd_reloc_status_type
1248
sh_elf64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol_in,
1249
                void *data, asection *input_section, bfd *output_bfd,
1250
                char **error_message ATTRIBUTE_UNUSED)
1251
{
1252
  unsigned long insn;
1253
  bfd_vma sym_value;
1254
  enum elf_sh_reloc_type r_type;
1255
  bfd_vma addr = reloc_entry->address;
1256
  bfd_byte *hit_data = addr + (bfd_byte *) data;
1257
 
1258
  r_type = (enum elf_sh_reloc_type) reloc_entry->howto->type;
1259
 
1260
  if (output_bfd != NULL)
1261
    {
1262
      /* Partial linking--do nothing.  */
1263
      reloc_entry->address += input_section->output_offset;
1264
      return bfd_reloc_ok;
1265
    }
1266
 
1267
  if (symbol_in != NULL
1268
      && bfd_is_und_section (symbol_in->section))
1269
    return bfd_reloc_undefined;
1270
 
1271
  if (bfd_is_com_section (symbol_in->section))
1272
    sym_value = 0;
1273
  else
1274
    sym_value = (symbol_in->value +
1275
                 symbol_in->section->output_section->vma +
1276
                 symbol_in->section->output_offset);
1277
 
1278
  switch (r_type)
1279
    {
1280
    case R_SH_DIR32:
1281
      insn = bfd_get_32 (abfd, hit_data);
1282
      insn += sym_value + reloc_entry->addend;
1283
      bfd_put_32 (abfd, insn, hit_data);
1284
      break;
1285
 
1286
    default:
1287
      abort ();
1288
      break;
1289
    }
1290
 
1291
  return bfd_reloc_ok;
1292
}
1293
 
1294
/* This structure is used to map BFD reloc codes to SH ELF relocs.  */
1295
 
1296
struct elf_reloc_map
1297
{
1298
  bfd_reloc_code_real_type bfd_reloc_val;
1299
  unsigned char elf_reloc_val;
1300
};
1301
 
1302
/* An array mapping BFD reloc codes to SH ELF relocs.  */
1303
 
1304
static const struct elf_reloc_map sh64_reloc_map[] =
1305
{
1306
  { BFD_RELOC_NONE, R_SH_NONE },
1307
  { BFD_RELOC_32, R_SH_DIR32 },
1308
  { BFD_RELOC_CTOR, R_SH_DIR32 },
1309
  { BFD_RELOC_32_PCREL, R_SH_REL32 },
1310
  { BFD_RELOC_8_PCREL, R_SH_SWITCH8 },
1311
  { BFD_RELOC_SH_SWITCH16, R_SH_SWITCH16 },
1312
  { BFD_RELOC_SH_SWITCH32, R_SH_SWITCH32 },
1313
  { BFD_RELOC_VTABLE_INHERIT, R_SH_GNU_VTINHERIT },
1314
  { BFD_RELOC_VTABLE_ENTRY, R_SH_GNU_VTENTRY },
1315
  { BFD_RELOC_SH_GOT_LOW16, R_SH_GOT_LOW16 },
1316
  { BFD_RELOC_SH_GOT_MEDLOW16, R_SH_GOT_MEDLOW16 },
1317
  { BFD_RELOC_SH_GOT_MEDHI16, R_SH_GOT_MEDHI16 },
1318
  { BFD_RELOC_SH_GOT_HI16, R_SH_GOT_HI16 },
1319
  { BFD_RELOC_SH_GOTPLT_LOW16, R_SH_GOTPLT_LOW16 },
1320
  { BFD_RELOC_SH_GOTPLT_MEDLOW16, R_SH_GOTPLT_MEDLOW16 },
1321
  { BFD_RELOC_SH_GOTPLT_MEDHI16, R_SH_GOTPLT_MEDHI16 },
1322
  { BFD_RELOC_SH_GOTPLT_HI16, R_SH_GOTPLT_HI16 },
1323
  { BFD_RELOC_SH_PLT_LOW16, R_SH_PLT_LOW16 },
1324
  { BFD_RELOC_SH_PLT_MEDLOW16, R_SH_PLT_MEDLOW16 },
1325
  { BFD_RELOC_SH_PLT_MEDHI16, R_SH_PLT_MEDHI16 },
1326
  { BFD_RELOC_SH_PLT_HI16, R_SH_PLT_HI16 },
1327
  { BFD_RELOC_SH_GOTOFF_LOW16, R_SH_GOTOFF_LOW16 },
1328
  { BFD_RELOC_SH_GOTOFF_MEDLOW16, R_SH_GOTOFF_MEDLOW16 },
1329
  { BFD_RELOC_SH_GOTOFF_MEDHI16, R_SH_GOTOFF_MEDHI16 },
1330
  { BFD_RELOC_SH_GOTOFF_HI16, R_SH_GOTOFF_HI16 },
1331
  { BFD_RELOC_SH_GOTPC_LOW16, R_SH_GOTPC_LOW16 },
1332
  { BFD_RELOC_SH_GOTPC_MEDLOW16, R_SH_GOTPC_MEDLOW16 },
1333
  { BFD_RELOC_SH_GOTPC_MEDHI16, R_SH_GOTPC_MEDHI16 },
1334
  { BFD_RELOC_SH_GOTPC_HI16, R_SH_GOTPC_HI16 },
1335
  { BFD_RELOC_SH_COPY64, R_SH_COPY64 },
1336
  { BFD_RELOC_SH_GLOB_DAT64, R_SH_GLOB_DAT64 },
1337
  { BFD_RELOC_SH_JMP_SLOT64, R_SH_JMP_SLOT64 },
1338
  { BFD_RELOC_SH_RELATIVE64, R_SH_RELATIVE64 },
1339
  { BFD_RELOC_SH_GOT10BY4, R_SH_GOT10BY4 },
1340
  { BFD_RELOC_SH_GOT10BY8, R_SH_GOT10BY8 },
1341
  { BFD_RELOC_SH_GOTPLT10BY4, R_SH_GOTPLT10BY4 },
1342
  { BFD_RELOC_SH_GOTPLT10BY8, R_SH_GOTPLT10BY8 },
1343
  { BFD_RELOC_SH_PT_16, R_SH_PT_16 },
1344
  { BFD_RELOC_SH_SHMEDIA_CODE, R_SH_SHMEDIA_CODE },
1345
  { BFD_RELOC_SH_IMMU5, R_SH_DIR5U },
1346
  { BFD_RELOC_SH_IMMS6, R_SH_DIR6S },
1347
  { BFD_RELOC_SH_IMMU6, R_SH_DIR6U },
1348
  { BFD_RELOC_SH_IMMS10, R_SH_DIR10S },
1349
  { BFD_RELOC_SH_IMMS10BY2, R_SH_DIR10SW },
1350
  { BFD_RELOC_SH_IMMS10BY4, R_SH_DIR10SL },
1351
  { BFD_RELOC_SH_IMMS10BY8, R_SH_DIR10SQ },
1352
  { BFD_RELOC_SH_IMMS16, R_SH_IMMS16 },
1353
  { BFD_RELOC_SH_IMMU16, R_SH_IMMU16 },
1354
  { BFD_RELOC_SH_IMM_LOW16, R_SH_IMM_LOW16 },
1355
  { BFD_RELOC_SH_IMM_LOW16_PCREL, R_SH_IMM_LOW16_PCREL },
1356
  { BFD_RELOC_SH_IMM_MEDLOW16, R_SH_IMM_MEDLOW16 },
1357
  { BFD_RELOC_SH_IMM_MEDLOW16_PCREL, R_SH_IMM_MEDLOW16_PCREL },
1358
  { BFD_RELOC_SH_IMM_MEDHI16, R_SH_IMM_MEDHI16 },
1359
  { BFD_RELOC_SH_IMM_MEDHI16_PCREL, R_SH_IMM_MEDHI16_PCREL },
1360
  { BFD_RELOC_SH_IMM_HI16, R_SH_IMM_HI16 },
1361
  { BFD_RELOC_SH_IMM_HI16_PCREL, R_SH_IMM_HI16_PCREL },
1362
  { BFD_RELOC_64, R_SH_64 },
1363
  { BFD_RELOC_64_PCREL, R_SH_64_PCREL },
1364
};
1365
 
1366
/* Given a BFD reloc code, return the howto structure for the
1367
   corresponding SH ELf reloc.  */
1368
 
1369
static reloc_howto_type *
1370
sh_elf64_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1371
                            bfd_reloc_code_real_type code)
1372
{
1373
  unsigned int i;
1374
 
1375
  for (i = 0; i < sizeof (sh64_reloc_map) / sizeof (struct elf_reloc_map); i++)
1376
    {
1377
      if (sh64_reloc_map[i].bfd_reloc_val == code)
1378
        return &sh_elf64_howto_table[(int) sh64_reloc_map[i].elf_reloc_val];
1379
    }
1380
 
1381
  return NULL;
1382
}
1383
 
1384
static reloc_howto_type *
1385
sh_elf64_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1386
                            const char *r_name)
1387
{
1388
  unsigned int i;
1389
 
1390
  for (i = 0;
1391
       i < sizeof (sh_elf64_howto_table) / sizeof (sh_elf64_howto_table[0]);
1392
       i++)
1393
    if (sh_elf64_howto_table[i].name != NULL
1394
        && strcasecmp (sh_elf64_howto_table[i].name, r_name) == 0)
1395
      return &sh_elf64_howto_table[i];
1396
 
1397
  return NULL;
1398
}
1399
 
1400
/* Given an ELF reloc, fill in the howto field of a relent.
1401
 
1402
   See sh_elf_info_to_howto in elf32-sh.c for the original.  */
1403
 
1404
static void
1405
sh_elf64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
1406
                        Elf_Internal_Rela *dst)
1407
{
1408
  unsigned int r;
1409
 
1410
  r = ELF64_R_TYPE (dst->r_info);
1411
 
1412
  BFD_ASSERT (r <= (unsigned int) R_SH_64_PCREL);
1413
  BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC || r > R_SH_LAST_INVALID_RELOC);
1414
  BFD_ASSERT (r < R_SH_DIR8WPN || r > R_SH_LAST_INVALID_RELOC_2);
1415
  BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_3 || r > R_SH_GOTPLT32);
1416
  BFD_ASSERT (r < R_SH_FIRST_INVALID_RELOC_4 || r > R_SH_LAST_INVALID_RELOC_4);
1417
 
1418
  cache_ptr->howto = &sh_elf64_howto_table[r];
1419
}
1420
 
1421
/* Relocate an SH ELF section.
1422
 
1423
   See sh_elf_info_to_howto in elf32-sh.c for the original.  */
1424
 
1425
static bfd_boolean
1426
sh_elf64_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
1427
                           struct bfd_link_info *info, bfd *input_bfd,
1428
                           asection *input_section, bfd_byte *contents,
1429
                           Elf_Internal_Rela *relocs,
1430
                           Elf_Internal_Sym *local_syms,
1431
                           asection **local_sections)
1432
{
1433
  Elf_Internal_Shdr *symtab_hdr;
1434
  struct elf_link_hash_entry **sym_hashes;
1435
  Elf_Internal_Rela *rel, *relend;
1436
  bfd *dynobj;
1437
  bfd_vma *local_got_offsets;
1438
  asection *sgot;
1439
  asection *sgotplt;
1440
  asection *splt;
1441
  asection *sreloc;
1442
  bfd_vma disp, dropped;
1443
 
1444
  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1445
  sym_hashes = elf_sym_hashes (input_bfd);
1446
  dynobj = elf_hash_table (info)->dynobj;
1447
  local_got_offsets = elf_local_got_offsets (input_bfd);
1448
 
1449
  sgot = NULL;
1450
  sgotplt = NULL;
1451
  splt = NULL;
1452
  sreloc = NULL;
1453
 
1454
  rel = relocs;
1455
  relend = relocs + input_section->reloc_count;
1456
  for (; rel < relend; rel++)
1457
    {
1458
      int r_type;
1459
      reloc_howto_type *howto;
1460
      unsigned long r_symndx;
1461
      Elf_Internal_Sym *sym;
1462
      asection *sec;
1463
      struct elf_link_hash_entry *h;
1464
      bfd_vma relocation;
1465
      bfd_vma addend = (bfd_vma)0;
1466
      bfd_reloc_status_type r;
1467
      int seen_stt_datalabel = 0;
1468
 
1469
      r_symndx = ELF64_R_SYM (rel->r_info);
1470
 
1471
      r_type = ELF64_R_TYPE (rel->r_info);
1472
 
1473
      if (r_type == (int) R_SH_NONE)
1474
        continue;
1475
 
1476
      if (r_type < 0
1477
          || r_type > R_SH_64_PCREL
1478
          || (r_type >= (int) R_SH_FIRST_INVALID_RELOC
1479
              && r_type <= (int) R_SH_LAST_INVALID_RELOC)
1480
          || (r_type >= (int) R_SH_DIR8WPN
1481
              && r_type <= (int) R_SH_LAST_INVALID_RELOC)
1482
          || (r_type >= (int) R_SH_GNU_VTINHERIT
1483
              && r_type <= (int) R_SH_PSHL)
1484
          || (r_type >= (int) R_SH_FIRST_INVALID_RELOC_2
1485
              && r_type <= R_SH_GOTPLT32)
1486
          || (r_type >= (int) R_SH_FIRST_INVALID_RELOC_4
1487
              && r_type <= (int) R_SH_LAST_INVALID_RELOC_4))
1488
        {
1489
          bfd_set_error (bfd_error_bad_value);
1490
          return FALSE;
1491
        }
1492
 
1493
      howto = sh_elf64_howto_table + r_type;
1494
 
1495
      h = NULL;
1496
      sym = NULL;
1497
      sec = NULL;
1498
      relocation = 0;
1499
      if (r_symndx < symtab_hdr->sh_info)
1500
        {
1501
          sym = local_syms + r_symndx;
1502
          sec = local_sections[r_symndx];
1503
          relocation = ((sec->output_section->vma
1504
                         + sec->output_offset
1505
                         + sym->st_value)
1506
                        | ((sym->st_other & STO_SH5_ISA32) != 0));
1507
 
1508
          /* A local symbol never has STO_SH5_ISA32, so we don't need
1509
             datalabel processing here.  Make sure this does not change
1510
             without notice.  */
1511
          if ((sym->st_other & STO_SH5_ISA32) != 0)
1512
            ((*info->callbacks->reloc_dangerous)
1513
             (info,
1514
              _("Unexpected STO_SH5_ISA32 on local symbol is not handled"),
1515
              input_bfd, input_section, rel->r_offset));
1516
 
1517
          if (sec != NULL && elf_discarded_section (sec))
1518
            /* Handled below.  */
1519
            ;
1520
          else if (info->relocatable)
1521
            {
1522
              /* This is a relocatable link.  We don't have to change
1523
                 anything, unless the reloc is against a section symbol,
1524
                 in which case we have to adjust according to where the
1525
                 section symbol winds up in the output section.  */
1526
              if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1527
                goto final_link_relocate;
1528
 
1529
              continue;
1530
            }
1531
          else if (! howto->partial_inplace)
1532
            {
1533
              relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1534
              relocation |= ((sym->st_other & STO_SH5_ISA32) != 0);
1535
            }
1536
          else if ((sec->flags & SEC_MERGE)
1537
                   && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1538
            {
1539
              asection *msec;
1540
 
1541
              if (howto->rightshift || howto->src_mask != 0xffffffff)
1542
                {
1543
                  (*_bfd_error_handler)
1544
                    (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
1545
                     input_bfd, input_section,
1546
                     (long) rel->r_offset, howto->name);
1547
                  return FALSE;
1548
                }
1549
 
1550
              addend = bfd_get_32 (input_bfd, contents + rel->r_offset);
1551
              msec = sec;
1552
              addend =
1553
                _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
1554
                - relocation;
1555
              addend += msec->output_section->vma + msec->output_offset;
1556
              bfd_put_32 (input_bfd, addend, contents + rel->r_offset);
1557
              addend = 0;
1558
            }
1559
        }
1560
      else
1561
        {
1562
          /* ??? Could we use the RELOC_FOR_GLOBAL_SYMBOL macro here ?  */
1563
 
1564
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1565
          while (h->root.type == bfd_link_hash_indirect
1566
                 || h->root.type == bfd_link_hash_warning)
1567
            {
1568
              /* If the reference passes a symbol marked with
1569
                 STT_DATALABEL, then any STO_SH5_ISA32 on the final value
1570
                 doesn't count.  */
1571
              seen_stt_datalabel |= h->type == STT_DATALABEL;
1572
              h = (struct elf_link_hash_entry *) h->root.u.i.link;
1573
            }
1574
 
1575
          if (h->root.type == bfd_link_hash_defined
1576
              || h->root.type == bfd_link_hash_defweak)
1577
            {
1578
              sec = h->root.u.def.section;
1579
              /* In these cases, we don't need the relocation value.
1580
                 We check specially because in some obscure cases
1581
                 sec->output_section will be NULL.  */
1582
              if (r_type == R_SH_GOTPC_LOW16
1583
                  || r_type == R_SH_GOTPC_MEDLOW16
1584
                  || r_type == R_SH_GOTPC_MEDHI16
1585
                  || r_type == R_SH_GOTPC_HI16
1586
                  || ((r_type == R_SH_PLT_LOW16
1587
                       || r_type == R_SH_PLT_MEDLOW16
1588
                       || r_type == R_SH_PLT_MEDHI16
1589
                       || r_type == R_SH_PLT_HI16)
1590
                      && h->plt.offset != (bfd_vma) -1)
1591
                  || ((r_type == R_SH_GOT_LOW16
1592
                       || r_type == R_SH_GOT_MEDLOW16
1593
                       || r_type == R_SH_GOT_MEDHI16
1594
                       || r_type == R_SH_GOT_HI16)
1595
                      && elf_hash_table (info)->dynamic_sections_created
1596
                      && (! info->shared
1597
                          || (! info->symbolic && h->dynindx != -1)
1598
                          || !h->def_regular))
1599
                  /* The cases above are those in which relocation is
1600
                     overwritten in the switch block below.  The cases
1601
                     below are those in which we must defer relocation
1602
                     to run-time, because we can't resolve absolute
1603
                     addresses when creating a shared library.  */
1604
                  || (info->shared
1605
                      && ((! info->symbolic && h->dynindx != -1)
1606
                          || !h->def_regular)
1607
                      && ((r_type == R_SH_64
1608
                           && !(ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
1609
                                || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN))
1610
                          || r_type == R_SH_64_PCREL)
1611
                      && ((input_section->flags & SEC_ALLOC) != 0
1612
                          /* DWARF will emit R_SH_DIR32 relocations in its
1613
                             sections against symbols defined externally
1614
                             in shared libraries.  We can't do anything
1615
                             with them here.  */
1616
                          || (input_section->flags & SEC_DEBUGGING) != 0))
1617
                  /* Dynamic relocs are not propagated for SEC_DEBUGGING
1618
                     sections because such sections are not SEC_ALLOC and
1619
                     thus ld.so will not process them.  */
1620
                  || (sec->output_section == NULL
1621
                      && ((input_section->flags & SEC_DEBUGGING) != 0
1622
                          && h->def_dynamic)))
1623
                ;
1624
              else if (sec->output_section != NULL)
1625
                relocation = ((h->root.u.def.value
1626
                               + sec->output_section->vma
1627
                               + sec->output_offset)
1628
                              /* A STO_SH5_ISA32 causes a "bitor 1" to the
1629
                                 symbol value, unless we've seen
1630
                                 STT_DATALABEL on the way to it.  */
1631
                              | ((h->other & STO_SH5_ISA32) != 0
1632
                                 && ! seen_stt_datalabel));
1633
              else if (!info->relocatable)
1634
                {
1635
                  (*_bfd_error_handler)
1636
                    (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
1637
                     input_bfd,
1638
                     input_section,
1639
                     (long) rel->r_offset,
1640
                     howto->name,
1641
                     h->root.root.string);
1642
                }
1643
            }
1644
          else if (h->root.type == bfd_link_hash_undefweak)
1645
            ;
1646
          else if (info->unresolved_syms_in_objects == RM_IGNORE
1647
                   && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1648
            ;
1649
          else if (!info->relocatable)
1650
            {
1651
              if (! ((*info->callbacks->undefined_symbol)
1652
                     (info, h->root.root.string, input_bfd,
1653
                      input_section, rel->r_offset,
1654
                      (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
1655
                       || ELF_ST_VISIBILITY (h->other)))))
1656
                return FALSE;
1657
            }
1658
        }
1659
 
1660
      if (sec != NULL && elf_discarded_section (sec))
1661
        RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1662
                                         rel, relend, howto, contents);
1663
 
1664
      if (info->relocatable)
1665
        continue;
1666
 
1667
      disp = (relocation
1668
              - input_section->output_section->vma
1669
              - input_section->output_offset
1670
              - rel->r_offset);
1671
      dropped = 0;
1672
      switch ((int)r_type)
1673
        {
1674
        case R_SH_PT_16:     dropped = disp & 2; break;
1675
        case R_SH_DIR10SW: dropped = disp & 1; break;
1676
        case R_SH_DIR10SL: dropped = disp & 3; break;
1677
        case R_SH_DIR10SQ: dropped = disp & 7; break;
1678
        }
1679
      if (dropped != 0)
1680
        {
1681
          (*_bfd_error_handler)
1682
            (_("%s: error: unaligned relocation type %d at %08x reloc %08x\n"),
1683
             bfd_get_filename (input_bfd), (int)r_type, (unsigned)rel->r_offset, (unsigned)relocation);
1684
          bfd_set_error (bfd_error_bad_value);
1685
          return FALSE;
1686
        }
1687
      switch ((int)r_type)
1688
        {
1689
        case R_SH_64:
1690
        case R_SH_64_PCREL:
1691
          if (info->shared
1692
              && (input_section->flags & SEC_ALLOC) != 0
1693
              && (r_type != R_SH_64_PCREL
1694
                  || (h != NULL
1695
                      && h->dynindx != -1
1696
                      && (! info->symbolic
1697
                          || !h->def_regular))))
1698
            {
1699
              Elf_Internal_Rela outrel;
1700
              bfd_byte *loc;
1701
              bfd_boolean skip, relocate;
1702
 
1703
              /* When generating a shared object, these relocations
1704
                 are copied into the output file to be resolved at run
1705
                 time.  */
1706
 
1707
              if (sreloc == NULL)
1708
                {
1709
                  sreloc = _bfd_elf_get_dynamic_reloc_section
1710
                    (input_bfd, input_section, /*rela?*/ TRUE);
1711
                  if (sreloc == NULL)
1712
                    return FALSE;
1713
                }
1714
 
1715
              skip = FALSE;
1716
              relocate = FALSE;
1717
 
1718
              outrel.r_offset
1719
                = _bfd_elf_section_offset (output_bfd, info,
1720
                                           input_section, rel->r_offset);
1721
 
1722
              if (outrel.r_offset == (bfd_vma) -1)
1723
                skip = TRUE;
1724
              else if (outrel.r_offset == (bfd_vma) -2)
1725
                skip = TRUE, relocate = TRUE;
1726
 
1727
              outrel.r_offset += (input_section->output_section->vma
1728
                                  + input_section->output_offset);
1729
 
1730
              if (skip)
1731
                memset (&outrel, 0, sizeof outrel);
1732
              else if (r_type == R_SH_64_PCREL)
1733
                {
1734
                  BFD_ASSERT (h != NULL && h->dynindx != -1);
1735
                  outrel.r_info = ELF64_R_INFO (h->dynindx, R_SH_64_PCREL);
1736
                  outrel.r_addend = rel->r_addend;
1737
                }
1738
              else
1739
                {
1740
                  /* h->dynindx may be -1 if this symbol was marked to
1741
                     become local.  */
1742
                  if (h == NULL
1743
                      || ((info->symbolic || h->dynindx == -1)
1744
                          && h->def_regular))
1745
                    {
1746
                      relocate = TRUE;
1747
                      outrel.r_info = ELF64_R_INFO (0, R_SH_RELATIVE64);
1748
                      outrel.r_addend = relocation + rel->r_addend;
1749
                    }
1750
                  else
1751
                    {
1752
                      BFD_ASSERT (h->dynindx != -1);
1753
                      outrel.r_info = ELF64_R_INFO (h->dynindx, R_SH_64);
1754
                      outrel.r_addend = relocation + rel->r_addend;
1755
                    }
1756
                }
1757
 
1758
              loc = sreloc->contents;
1759
              loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
1760
              bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
1761
 
1762
              /* If this reloc is against an external symbol, we do
1763
                 not want to fiddle with the addend.  Otherwise, we
1764
                 need to include the symbol value so that it becomes
1765
                 an addend for the dynamic reloc.  */
1766
              if (! relocate)
1767
                continue;
1768
            }
1769
          else if (r_type == R_SH_64)
1770
            addend = rel->r_addend;
1771
          goto final_link_relocate;
1772
 
1773
        case R_SH_GOTPLT_LOW16:
1774
        case R_SH_GOTPLT_MEDLOW16:
1775
        case R_SH_GOTPLT_MEDHI16:
1776
        case R_SH_GOTPLT_HI16:
1777
        case R_SH_GOTPLT10BY4:
1778
        case R_SH_GOTPLT10BY8:
1779
          /* Relocation is to the entry for this symbol in the
1780
             procedure linkage table.  */
1781
 
1782
          if (h == NULL
1783
              || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
1784
              || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
1785
              || ! info->shared
1786
              || info->symbolic
1787
              || h->dynindx == -1
1788
              || h->plt.offset == (bfd_vma) -1
1789
              || h->got.offset != (bfd_vma) -1)
1790
            goto force_got;
1791
 
1792
          /* Relocation is to the entry for this symbol in the global
1793
             offset table extension for the procedure linkage table.  */
1794
          if (sgotplt == NULL)
1795
            {
1796
              sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
1797
              BFD_ASSERT (sgotplt != NULL);
1798
            }
1799
 
1800
          relocation = (sgotplt->output_offset
1801
                        + ((h->plt.offset / elf_sh64_sizeof_plt (info)
1802
                            - 1 + 3) * 8));
1803
 
1804
          relocation -= GOT_BIAS;
1805
 
1806
          goto final_link_relocate;
1807
 
1808
        force_got:
1809
        case R_SH_GOT_LOW16:
1810
        case R_SH_GOT_MEDLOW16:
1811
        case R_SH_GOT_MEDHI16:
1812
        case R_SH_GOT_HI16:
1813
        case R_SH_GOT10BY4:
1814
        case R_SH_GOT10BY8:
1815
          /* Relocation is to the entry for this symbol in the global
1816
             offset table.  */
1817
          if (sgot == NULL)
1818
            {
1819
              sgot = bfd_get_section_by_name (dynobj, ".got");
1820
              BFD_ASSERT (sgot != NULL);
1821
            }
1822
 
1823
          if (h != NULL)
1824
            {
1825
              bfd_vma off;
1826
 
1827
              off = h->got.offset;
1828
              if (seen_stt_datalabel)
1829
                {
1830
                  struct elf_sh64_link_hash_entry *hsh;
1831
 
1832
                  hsh = (struct elf_sh64_link_hash_entry *)h;
1833
                  off = hsh->datalabel_got_offset;
1834
                }
1835
              BFD_ASSERT (off != (bfd_vma) -1);
1836
 
1837
              if (! elf_hash_table (info)->dynamic_sections_created
1838
                  || (info->shared
1839
                      && (info->symbolic || h->dynindx == -1
1840
                          || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
1841
                          || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
1842
                      && h->def_regular))
1843
                {
1844
                  /* This is actually a static link, or it is a
1845
                     -Bsymbolic link and the symbol is defined
1846
                     locally, or the symbol was forced to be local
1847
                     because of a version file.  We must initialize
1848
                     this entry in the global offset table.  Since the
1849
                     offset must always be a multiple of 4, we use the
1850
                     least significant bit to record whether we have
1851
                     initialized it already.
1852
 
1853
                     When doing a dynamic link, we create a .rela.got
1854
                     relocation entry to initialize the value.  This
1855
                     is done in the finish_dynamic_symbol routine.  */
1856
                  if ((off & 1) != 0)
1857
                    off &= ~1;
1858
                  else
1859
                    {
1860
                      bfd_put_64 (output_bfd, relocation,
1861
                                  sgot->contents + off);
1862
                      if (seen_stt_datalabel)
1863
                        {
1864
                          struct elf_sh64_link_hash_entry *hsh;
1865
 
1866
                          hsh = (struct elf_sh64_link_hash_entry *)h;
1867
                          hsh->datalabel_got_offset |= 1;
1868
                        }
1869
                      else
1870
                        h->got.offset |= 1;
1871
                    }
1872
                }
1873
 
1874
              relocation = sgot->output_offset + off;
1875
            }
1876
          else
1877
            {
1878
              bfd_vma off;
1879
 
1880
              if (rel->r_addend)
1881
                {
1882
                  BFD_ASSERT (local_got_offsets != NULL
1883
                              && (local_got_offsets[symtab_hdr->sh_info
1884
                                                    + r_symndx]
1885
                                  != (bfd_vma) -1));
1886
 
1887
                  off = local_got_offsets[symtab_hdr->sh_info
1888
                                          + r_symndx];
1889
                }
1890
              else
1891
                {
1892
                  BFD_ASSERT (local_got_offsets != NULL
1893
                              && local_got_offsets[r_symndx] != (bfd_vma) -1);
1894
 
1895
                  off = local_got_offsets[r_symndx];
1896
                }
1897
 
1898
              /* The offset must always be a multiple of 8.  We use
1899
                 the least significant bit to record whether we have
1900
                 already generated the necessary reloc.  */
1901
              if ((off & 1) != 0)
1902
                off &= ~1;
1903
              else
1904
                {
1905
                  bfd_put_64 (output_bfd, relocation, sgot->contents + off);
1906
 
1907
                  if (info->shared)
1908
                    {
1909
                      asection *s;
1910
                      Elf_Internal_Rela outrel;
1911
                      bfd_byte *loc;
1912
 
1913
                      s = bfd_get_section_by_name (dynobj, ".rela.got");
1914
                      BFD_ASSERT (s != NULL);
1915
 
1916
                      outrel.r_offset = (sgot->output_section->vma
1917
                                         + sgot->output_offset
1918
                                         + off);
1919
                      outrel.r_info = ELF64_R_INFO (0, R_SH_RELATIVE64);
1920
                      outrel.r_addend = relocation;
1921
                      loc = s->contents;
1922
                      loc += s->reloc_count++ * sizeof (Elf64_External_Rela);
1923
                      bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
1924
                    }
1925
 
1926
                  if (rel->r_addend)
1927
                    local_got_offsets[symtab_hdr->sh_info + r_symndx] |= 1;
1928
                  else
1929
                    local_got_offsets[r_symndx] |= 1;
1930
                }
1931
 
1932
              relocation = sgot->output_offset + off;
1933
            }
1934
 
1935
          relocation -= GOT_BIAS;
1936
 
1937
          goto final_link_relocate;
1938
 
1939
        case R_SH_GOTOFF_LOW16:
1940
        case R_SH_GOTOFF_MEDLOW16:
1941
        case R_SH_GOTOFF_MEDHI16:
1942
        case R_SH_GOTOFF_HI16:
1943
          /* Relocation is relative to the start of the global offset
1944
             table.  */
1945
 
1946
          if (sgot == NULL)
1947
            {
1948
              sgot = bfd_get_section_by_name (dynobj, ".got");
1949
              BFD_ASSERT (sgot != NULL);
1950
            }
1951
 
1952
          /* Note that sgot->output_offset is not involved in this
1953
             calculation.  We always want the start of .got.  If we
1954
             defined _GLOBAL_OFFSET_TABLE in a different way, as is
1955
             permitted by the ABI, we might have to change this
1956
             calculation.  */
1957
          relocation -= sgot->output_section->vma;
1958
 
1959
          relocation -= GOT_BIAS;
1960
 
1961
          addend = rel->r_addend;
1962
 
1963
          goto final_link_relocate;
1964
 
1965
        case R_SH_GOTPC_LOW16:
1966
        case R_SH_GOTPC_MEDLOW16:
1967
        case R_SH_GOTPC_MEDHI16:
1968
        case R_SH_GOTPC_HI16:
1969
          /* Use global offset table as symbol value.  */
1970
 
1971
          if (sgot == NULL)
1972
            {
1973
              sgot = bfd_get_section_by_name (dynobj, ".got");
1974
              BFD_ASSERT (sgot != NULL);
1975
            }
1976
 
1977
          relocation = sgot->output_section->vma;
1978
 
1979
          relocation += GOT_BIAS;
1980
 
1981
          addend = rel->r_addend;
1982
 
1983
          goto final_link_relocate;
1984
 
1985
        case R_SH_PLT_LOW16:
1986
        case R_SH_PLT_MEDLOW16:
1987
        case R_SH_PLT_MEDHI16:
1988
        case R_SH_PLT_HI16:
1989
          /* Relocation is to the entry for this symbol in the
1990
             procedure linkage table.  */
1991
 
1992
          /* Resolve a PLT reloc against a local symbol directly,
1993
             without using the procedure linkage table.  */
1994
          if (h == NULL)
1995
            goto final_link_relocate;
1996
 
1997
          if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
1998
              || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
1999
            goto final_link_relocate;
2000
 
2001
          if (h->plt.offset == (bfd_vma) -1)
2002
            {
2003
              /* We didn't make a PLT entry for this symbol.  This
2004
                 happens when statically linking PIC code, or when
2005
                 using -Bsymbolic.  */
2006
              goto final_link_relocate;
2007
            }
2008
 
2009
          if (splt == NULL)
2010
            {
2011
              splt = bfd_get_section_by_name (dynobj, ".plt");
2012
              BFD_ASSERT (splt != NULL);
2013
            }
2014
 
2015
          relocation = (splt->output_section->vma
2016
                        + splt->output_offset
2017
                        + h->plt.offset);
2018
          relocation++;
2019
 
2020
          addend = rel->r_addend;
2021
 
2022
          goto final_link_relocate;
2023
 
2024
        case R_SH_DIR32:
2025
        case R_SH_SHMEDIA_CODE:
2026
        case R_SH_PT_16:
2027
        case R_SH_DIR5U:
2028
        case R_SH_DIR6S:
2029
        case R_SH_DIR6U:
2030
        case R_SH_DIR10S:
2031
        case R_SH_DIR10SW:
2032
        case R_SH_DIR10SL:
2033
        case R_SH_DIR10SQ:
2034
        case R_SH_IMMS16:
2035
        case R_SH_IMMU16:
2036
        case R_SH_IMM_LOW16:
2037
        case R_SH_IMM_LOW16_PCREL:
2038
        case R_SH_IMM_MEDLOW16:
2039
        case R_SH_IMM_MEDLOW16_PCREL:
2040
        case R_SH_IMM_MEDHI16:
2041
        case R_SH_IMM_MEDHI16_PCREL:
2042
        case R_SH_IMM_HI16:
2043
        case R_SH_IMM_HI16_PCREL:
2044
          addend = rel->r_addend;
2045
          /* Fall through.  */
2046
        case R_SH_REL32:
2047
        final_link_relocate:
2048
          r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2049
                                        contents, rel->r_offset,
2050
                                        relocation, addend);
2051
          break;
2052
 
2053
        default:
2054
          bfd_set_error (bfd_error_bad_value);
2055
          return FALSE;
2056
 
2057
        }
2058
 
2059
      if (r != bfd_reloc_ok)
2060
        {
2061
          switch (r)
2062
            {
2063
            default:
2064
            case bfd_reloc_outofrange:
2065
              abort ();
2066
            case bfd_reloc_overflow:
2067
              {
2068
                const char *name;
2069
 
2070
                if (h != NULL)
2071
                  name = NULL;
2072
                else
2073
                  {
2074
                    name = (bfd_elf_string_from_elf_section
2075
                            (input_bfd, symtab_hdr->sh_link, sym->st_name));
2076
                    if (name == NULL)
2077
                      return FALSE;
2078
                    if (*name == '\0')
2079
                      name = bfd_section_name (input_bfd, sec);
2080
                  }
2081
                if (! ((*info->callbacks->reloc_overflow)
2082
                       (info, (h ? &h->root : NULL), name, howto->name,
2083
                        (bfd_vma) 0, input_bfd, input_section,
2084
                        rel->r_offset)))
2085
                  return FALSE;
2086
              }
2087
              break;
2088
            }
2089
        }
2090
    }
2091
 
2092
  return TRUE;
2093
}
2094
 
2095
/* This is a version of bfd_generic_get_relocated_section_contents
2096
   that uses sh_elf64_relocate_section.
2097
 
2098
   See sh_elf_relocate_section in elf32-sh.c for the original.  */
2099
 
2100
static bfd_byte *
2101
sh_elf64_get_relocated_section_contents (bfd *output_bfd,
2102
                                         struct bfd_link_info *link_info,
2103
                                         struct bfd_link_order *link_order,
2104
                                         bfd_byte *data,
2105
                                         bfd_boolean relocatable,
2106
                                         asymbol **symbols)
2107
{
2108
  Elf_Internal_Shdr *symtab_hdr;
2109
  asection *input_section = link_order->u.indirect.section;
2110
  bfd *input_bfd = input_section->owner;
2111
  asection **sections = NULL;
2112
  Elf_Internal_Rela *internal_relocs = NULL;
2113
  Elf_Internal_Sym *isymbuf = NULL;
2114
 
2115
  /* We only need to handle the case of relaxing, or of having a
2116
     particular set of section contents, specially.  */
2117
  if (relocatable
2118
      || elf_section_data (input_section)->this_hdr.contents == NULL)
2119
    return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
2120
                                                       link_order, data,
2121
                                                       relocatable,
2122
                                                       symbols);
2123
 
2124
  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2125
 
2126
  memcpy (data, elf_section_data (input_section)->this_hdr.contents,
2127
          input_section->size);
2128
 
2129
  if ((input_section->flags & SEC_RELOC) != 0
2130
      && input_section->reloc_count > 0)
2131
    {
2132
      Elf_Internal_Sym *isymp;
2133
      Elf_Internal_Sym *isymend;
2134
      asection **secpp;
2135
 
2136
      /* Read this BFD's local symbols.  */
2137
      if (symtab_hdr->sh_info != 0)
2138
        {
2139
          isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2140
          if (isymbuf == NULL)
2141
            isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2142
                                            symtab_hdr->sh_info, 0,
2143
                                            NULL, NULL, NULL);
2144
          if (isymbuf == NULL)
2145
            goto error_return;
2146
        }
2147
 
2148
      internal_relocs = (_bfd_elf_link_read_relocs
2149
                         (input_bfd, input_section, NULL,
2150
                          (Elf_Internal_Rela *) NULL, FALSE));
2151
      if (internal_relocs == NULL)
2152
        goto error_return;
2153
 
2154
      sections = (asection **) bfd_malloc (symtab_hdr->sh_info
2155
                                           * sizeof (asection *));
2156
      if (sections == NULL && symtab_hdr->sh_info > 0)
2157
        goto error_return;
2158
 
2159
      secpp = sections;
2160
      isymend = isymbuf + symtab_hdr->sh_info;
2161
      for (isymp = isymbuf; isymp < isymend; ++isymp, ++secpp)
2162
        {
2163
          asection *isec;
2164
 
2165
          if (isymp->st_shndx == SHN_UNDEF)
2166
            isec = bfd_und_section_ptr;
2167
          else if (isymp->st_shndx == SHN_ABS)
2168
            isec = bfd_abs_section_ptr;
2169
          else if (isymp->st_shndx == SHN_COMMON)
2170
            isec = bfd_com_section_ptr;
2171
          else
2172
            isec = bfd_section_from_elf_index (input_bfd, isymp->st_shndx);
2173
 
2174
          *secpp = isec;
2175
        }
2176
 
2177
      if (! sh_elf64_relocate_section (output_bfd, link_info, input_bfd,
2178
                                       input_section, data, internal_relocs,
2179
                                       isymbuf, sections))
2180
        goto error_return;
2181
 
2182
      if (sections != NULL)
2183
        free (sections);
2184
      if (internal_relocs != elf_section_data (input_section)->relocs)
2185
        free (internal_relocs);
2186
      if (isymbuf != NULL
2187
          && (unsigned char *) isymbuf != symtab_hdr->contents)
2188
        free (isymbuf);
2189
    }
2190
 
2191
  return data;
2192
 
2193
 error_return:
2194
  if (sections != NULL)
2195
    free (sections);
2196
  if (internal_relocs != NULL
2197
      && internal_relocs != elf_section_data (input_section)->relocs)
2198
    free (internal_relocs);
2199
  if (isymbuf != NULL
2200
      && (unsigned char *) isymbuf != symtab_hdr->contents)
2201
    free (isymbuf);
2202
  return NULL;
2203
}
2204
 
2205
/* Set the SHF_SH5_ISA32 flag for ISA SHmedia code sections.  */
2206
 
2207
static bfd_boolean
2208
sh64_elf64_fake_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2209
                          Elf_Internal_Shdr *elf_section_hdr,
2210
                          asection *asect)
2211
{
2212
  /* Code sections can only contain SH64 code, so mark them as such.  */
2213
  if (bfd_get_section_flags (output_bfd, asect) & SEC_CODE)
2214
    elf_section_hdr->sh_flags |= SHF_SH5_ISA32;
2215
 
2216
  return TRUE;
2217
}
2218
 
2219
static bfd_boolean
2220
sh_elf64_set_mach_from_flags (bfd *abfd)
2221
{
2222
  flagword flags = elf_elfheader (abfd)->e_flags;
2223
 
2224
  switch (flags & EF_SH_MACH_MASK)
2225
    {
2226
    case EF_SH5:
2227
      /* Just one, but keep the switch construct to make additions easy.  */
2228
      bfd_default_set_arch_mach (abfd, bfd_arch_sh, bfd_mach_sh5);
2229
      break;
2230
 
2231
    default:
2232
      bfd_set_error (bfd_error_wrong_format);
2233
      return FALSE;
2234
    }
2235
  return TRUE;
2236
}
2237
 
2238
/* Function to keep SH64 specific file flags.
2239
 
2240
   See sh64_elf_set_private_flags in elf32-sh64.c for the original.  */
2241
 
2242
static bfd_boolean
2243
sh_elf64_set_private_flags (bfd *abfd, flagword flags)
2244
{
2245
  BFD_ASSERT (! elf_flags_init (abfd)
2246
              || elf_elfheader (abfd)->e_flags == flags);
2247
 
2248
  elf_elfheader (abfd)->e_flags = flags;
2249
  elf_flags_init (abfd) = TRUE;
2250
  return sh_elf64_set_mach_from_flags (abfd);
2251
}
2252
 
2253
/* Copy the SHF_SH5_ISA32 attribute that we keep on all sections with
2254
   code, to keep attributes the same as for SHmedia in 32-bit ELF.  */
2255
 
2256
static bfd_boolean
2257
sh_elf64_copy_private_data_internal (bfd *ibfd, bfd *obfd)
2258
{
2259
  Elf_Internal_Shdr **o_shdrp;
2260
  asection *isec;
2261
  asection *osec;
2262
 
2263
  if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2264
      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2265
    return TRUE;
2266
 
2267
  o_shdrp = elf_elfsections (obfd);
2268
  for (osec = obfd->sections; osec; osec = osec->next)
2269
    {
2270
      int oIndex = ((struct bfd_elf_section_data *) elf_section_data (osec))->this_idx;
2271
      for (isec = ibfd->sections; isec; isec = isec->next)
2272
        {
2273
          if (strcmp (osec->name, isec->name) == 0)
2274
            {
2275
              /* Note that we're not disallowing mixing data and code.  */
2276
              if ((elf_section_data (isec)->this_hdr.sh_flags
2277
                   & SHF_SH5_ISA32) != 0)
2278
                o_shdrp[oIndex]->sh_flags |= SHF_SH5_ISA32;
2279
              break;
2280
            }
2281
        }
2282
    }
2283
 
2284
  /* Copy object attributes.  */
2285
  _bfd_elf_copy_obj_attributes (ibfd, obfd);
2286
 
2287
  return sh_elf64_set_private_flags (obfd, elf_elfheader (ibfd)->e_flags);
2288
}
2289
 
2290
static bfd_boolean
2291
sh_elf64_copy_private_data (bfd *ibfd, bfd *obfd)
2292
{
2293
  return sh_elf64_copy_private_data_internal (ibfd, obfd);
2294
}
2295
 
2296
static bfd_boolean
2297
sh_elf64_merge_private_data (bfd *ibfd, bfd *obfd)
2298
{
2299
  flagword old_flags, new_flags;
2300
 
2301
  if (! _bfd_generic_verify_endian_match (ibfd, obfd))
2302
    return FALSE;
2303
 
2304
  if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2305
      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2306
    return TRUE;
2307
 
2308
  if (bfd_get_arch_size (ibfd) != bfd_get_arch_size (obfd))
2309
    {
2310
      const char *msg;
2311
 
2312
      if (bfd_get_arch_size (ibfd) == 32
2313
          && bfd_get_arch_size (obfd) == 64)
2314
        msg = _("%s: compiled as 32-bit object and %s is 64-bit");
2315
      else if (bfd_get_arch_size (ibfd) == 64
2316
               && bfd_get_arch_size (obfd) == 32)
2317
        msg = _("%s: compiled as 64-bit object and %s is 32-bit");
2318
      else
2319
        msg = _("%s: object size does not match that of target %s");
2320
 
2321
      (*_bfd_error_handler) (msg, bfd_get_filename (ibfd),
2322
                             bfd_get_filename (obfd));
2323
      bfd_set_error (bfd_error_wrong_format);
2324
      return FALSE;
2325
    }
2326
 
2327
  old_flags = elf_elfheader (obfd)->e_flags;
2328
  new_flags = elf_elfheader (ibfd)->e_flags;
2329
  if (! elf_flags_init (obfd))
2330
    {
2331
      /* This happens when ld starts out with a 'blank' output file.  */
2332
      elf_flags_init (obfd) = TRUE;
2333
      elf_elfheader (obfd)->e_flags = old_flags = new_flags;
2334
    }
2335
  /* We don't allow linking in anything else than SH64 code, and since
2336
     this is a 64-bit ELF, we assume the 64-bit ABI is used.  Add code
2337
     here as things change.  */
2338
  else if ((new_flags & EF_SH_MACH_MASK) != EF_SH5)
2339
    {
2340
      (*_bfd_error_handler)
2341
        ("%s: does not use the SH64 64-bit ABI as previous modules do",
2342
         bfd_get_filename (ibfd));
2343
      bfd_set_error (bfd_error_bad_value);
2344
      return FALSE;
2345
    }
2346
 
2347
  sh_elf64_copy_private_data_internal (ibfd, obfd);
2348
 
2349
  /* I can't think of anything sane other than old_flags being EF_SH5 and
2350
     that we need to preserve that.  */
2351
  elf_elfheader (obfd)->e_flags = old_flags;
2352
 
2353
  return sh_elf64_set_mach_from_flags (obfd);
2354
}
2355
 
2356
/* Return the section that should be marked against GC for a given
2357
   relocation.  */
2358
 
2359
static asection *
2360
sh_elf64_gc_mark_hook (asection *sec,
2361
                       struct bfd_link_info *info,
2362
                       Elf_Internal_Rela *rel,
2363
                       struct elf_link_hash_entry *h,
2364
                       Elf_Internal_Sym *sym)
2365
{
2366
  if (h != NULL)
2367
    switch (ELF64_R_TYPE (rel->r_info))
2368
      {
2369
      case R_SH_GNU_VTINHERIT:
2370
      case R_SH_GNU_VTENTRY:
2371
        return NULL;
2372
      }
2373
 
2374
  return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2375
}
2376
 
2377
/* Look through the relocs for a section during the first phase.
2378
   Since we don't do .gots or .plts, we just need to consider the
2379
   virtual table relocs for gc.  */
2380
 
2381
static bfd_boolean
2382
sh_elf64_check_relocs (bfd *abfd, struct bfd_link_info *info,
2383
                       asection *sec, const Elf_Internal_Rela *relocs)
2384
{
2385
  Elf_Internal_Shdr *symtab_hdr;
2386
  struct elf_link_hash_entry **sym_hashes;
2387
  const Elf_Internal_Rela *rel;
2388
  const Elf_Internal_Rela *rel_end;
2389
  bfd *dynobj;
2390
  bfd_vma *local_got_offsets;
2391
  asection *sgot;
2392
  asection *srelgot;
2393
  asection *sreloc;
2394
 
2395
  sgot = NULL;
2396
  srelgot = NULL;
2397
  sreloc = NULL;
2398
 
2399
  if (info->relocatable)
2400
    return TRUE;
2401
 
2402
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2403
  sym_hashes = elf_sym_hashes (abfd);
2404
 
2405
  dynobj = elf_hash_table (info)->dynobj;
2406
  local_got_offsets = elf_local_got_offsets (abfd);
2407
 
2408
  rel_end = relocs + sec->reloc_count;
2409
  for (rel = relocs; rel < rel_end; rel++)
2410
    {
2411
      struct elf_link_hash_entry *h;
2412
      unsigned long r_symndx;
2413
 
2414
      r_symndx = ELF64_R_SYM (rel->r_info);
2415
      if (r_symndx < symtab_hdr->sh_info)
2416
        h = NULL;
2417
      else
2418
        {
2419
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2420
          while (h->root.type == bfd_link_hash_indirect
2421
                 || h->root.type == bfd_link_hash_warning)
2422
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
2423
        }
2424
 
2425
      /* Some relocs require a global offset table.  */
2426
      if (dynobj == NULL)
2427
        {
2428
          switch (ELF64_R_TYPE (rel->r_info))
2429
            {
2430
            case R_SH_GOTPLT_LOW16:
2431
            case R_SH_GOTPLT_MEDLOW16:
2432
            case R_SH_GOTPLT_MEDHI16:
2433
            case R_SH_GOTPLT_HI16:
2434
            case R_SH_GOTPLT10BY4:
2435
            case R_SH_GOTPLT10BY8:
2436
            case R_SH_GOT_LOW16:
2437
            case R_SH_GOT_MEDLOW16:
2438
            case R_SH_GOT_MEDHI16:
2439
            case R_SH_GOT_HI16:
2440
            case R_SH_GOT10BY4:
2441
            case R_SH_GOT10BY8:
2442
            case R_SH_GOTOFF_LOW16:
2443
            case R_SH_GOTOFF_MEDLOW16:
2444
            case R_SH_GOTOFF_MEDHI16:
2445
            case R_SH_GOTOFF_HI16:
2446
            case R_SH_GOTPC_LOW16:
2447
            case R_SH_GOTPC_MEDLOW16:
2448
            case R_SH_GOTPC_MEDHI16:
2449
            case R_SH_GOTPC_HI16:
2450
              elf_hash_table (info)->dynobj = dynobj = abfd;
2451
              if (! _bfd_elf_create_got_section (dynobj, info))
2452
                return FALSE;
2453
              break;
2454
 
2455
            default:
2456
              break;
2457
            }
2458
        }
2459
 
2460
      switch (ELF64_R_TYPE (rel->r_info))
2461
        {
2462
          /* This relocation describes the C++ object vtable hierarchy.
2463
             Reconstruct it for later use during GC.  */
2464
        case R_SH_GNU_VTINHERIT:
2465
          if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2466
            return FALSE;
2467
          break;
2468
 
2469
          /* This relocation describes which C++ vtable entries are actually
2470
             used.  Record for later use during GC.  */
2471
        case R_SH_GNU_VTENTRY:
2472
          BFD_ASSERT (h != NULL);
2473
          if (h != NULL
2474
              && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2475
            return FALSE;
2476
          break;
2477
 
2478
        force_got:
2479
        case R_SH_GOT_LOW16:
2480
        case R_SH_GOT_MEDLOW16:
2481
        case R_SH_GOT_MEDHI16:
2482
        case R_SH_GOT_HI16:
2483
        case R_SH_GOT10BY4:
2484
        case R_SH_GOT10BY8:
2485
          /* This symbol requires a global offset table entry.  */
2486
 
2487
          if (sgot == NULL)
2488
            {
2489
              sgot = bfd_get_section_by_name (dynobj, ".got");
2490
              BFD_ASSERT (sgot != NULL);
2491
            }
2492
 
2493
          if (srelgot == NULL
2494
              && (h != NULL || info->shared))
2495
            {
2496
              srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
2497
              if (srelgot == NULL)
2498
                {
2499
                  srelgot = bfd_make_section_with_flags (dynobj,
2500
                                                         ".rela.got",
2501
                                                         (SEC_ALLOC
2502
                                                          | SEC_LOAD
2503
                                                          | SEC_HAS_CONTENTS
2504
                                                          | SEC_IN_MEMORY
2505
                                                          | SEC_LINKER_CREATED
2506
                                                          | SEC_READONLY));
2507
                  if (srelgot == NULL
2508
                      || ! bfd_set_section_alignment (dynobj, srelgot, 2))
2509
                    return FALSE;
2510
                }
2511
            }
2512
 
2513
          if (h != NULL)
2514
            {
2515
              if (h->type == STT_DATALABEL)
2516
                {
2517
                  struct elf_sh64_link_hash_entry *hsh;
2518
 
2519
                  h = (struct elf_link_hash_entry *) h->root.u.i.link;
2520
                  hsh = (struct elf_sh64_link_hash_entry *)h;
2521
                  if (hsh->datalabel_got_offset != (bfd_vma) -1)
2522
                    break;
2523
 
2524
                  hsh->datalabel_got_offset = sgot->size;
2525
                }
2526
              else
2527
                {
2528
                  if (h->got.offset != (bfd_vma) -1)
2529
                    {
2530
                      /* We have already allocated space in the .got.  */
2531
                      break;
2532
                    }
2533
                  h->got.offset = sgot->size;
2534
                }
2535
 
2536
              /* Make sure this symbol is output as a dynamic symbol.  */
2537
              if (h->dynindx == -1)
2538
                {
2539
                  if (! bfd_elf_link_record_dynamic_symbol (info, h))
2540
                    return FALSE;
2541
                }
2542
 
2543
              srelgot->size += sizeof (Elf64_External_Rela);
2544
            }
2545
          else
2546
            {
2547
              /* This is a global offset table entry for a local
2548
                 symbol.  */
2549
              if (local_got_offsets == NULL)
2550
                {
2551
                  size_t size;
2552
                  register unsigned int i;
2553
 
2554
                  size = symtab_hdr->sh_info * sizeof (bfd_vma);
2555
                  /* Reserve space for both the datalabel and
2556
                     codelabel local GOT offsets.  */
2557
                  size *= 2;
2558
                  local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
2559
                  if (local_got_offsets == NULL)
2560
                    return FALSE;
2561
                  elf_local_got_offsets (abfd) = local_got_offsets;
2562
                  for (i = 0; i < symtab_hdr->sh_info; i++)
2563
                    local_got_offsets[i] = (bfd_vma) -1;
2564
                  for (; i < 2 * symtab_hdr->sh_info; i++)
2565
                    local_got_offsets[i] = (bfd_vma) -1;
2566
                }
2567
              if ((rel->r_addend & 1) != 0)
2568
                {
2569
                  if (local_got_offsets[symtab_hdr->sh_info
2570
                                        + r_symndx] != (bfd_vma) -1)
2571
                    {
2572
                      /* We have already allocated space in the .got.  */
2573
                      break;
2574
                    }
2575
                  local_got_offsets[symtab_hdr->sh_info
2576
                                    + r_symndx] = sgot->size;
2577
                }
2578
              else
2579
                {
2580
                  if (local_got_offsets[r_symndx] != (bfd_vma) -1)
2581
                    {
2582
                      /* We have already allocated space in the .got.  */
2583
                      break;
2584
                    }
2585
                  local_got_offsets[r_symndx] = sgot->size;
2586
                }
2587
 
2588
              if (info->shared)
2589
                {
2590
                  /* If we are generating a shared object, we need to
2591
                     output a R_SH_RELATIVE reloc so that the dynamic
2592
                     linker can adjust this GOT entry.  */
2593
                  srelgot->size += sizeof (Elf64_External_Rela);
2594
                }
2595
            }
2596
 
2597
          sgot->size += 8;
2598
 
2599
          break;
2600
 
2601
        case R_SH_GOTPLT_LOW16:
2602
        case R_SH_GOTPLT_MEDLOW16:
2603
        case R_SH_GOTPLT_MEDHI16:
2604
        case R_SH_GOTPLT_HI16:
2605
        case R_SH_GOTPLT10BY4:
2606
        case R_SH_GOTPLT10BY8:
2607
          /* If this is a local symbol, we resolve it directly without
2608
             creating a procedure linkage table entry.  */
2609
 
2610
          if (h == NULL
2611
              || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
2612
              || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
2613
              || ! info->shared
2614
              || info->symbolic
2615
              || h->dynindx == -1
2616
              || h->got.offset != (bfd_vma) -1)
2617
            goto force_got;
2618
 
2619
          /* Make sure this symbol is output as a dynamic symbol.  */
2620
          if (h->dynindx == -1)
2621
            {
2622
              if (! bfd_elf_link_record_dynamic_symbol (info, h))
2623
                return FALSE;
2624
            }
2625
 
2626
          h->needs_plt = 1;
2627
 
2628
          break;
2629
 
2630
        case R_SH_PLT_LOW16:
2631
        case R_SH_PLT_MEDLOW16:
2632
        case R_SH_PLT_MEDHI16:
2633
        case R_SH_PLT_HI16:
2634
          /* This symbol requires a procedure linkage table entry.  We
2635
             actually build the entry in adjust_dynamic_symbol,
2636
             because this might be a case of linking PIC code which is
2637
             never referenced by a dynamic object, in which case we
2638
             don't need to generate a procedure linkage table entry
2639
             after all.  */
2640
 
2641
          /* If this is a local symbol, we resolve it directly without
2642
             creating a procedure linkage table entry.  */
2643
          if (h == NULL)
2644
            continue;
2645
 
2646
          if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
2647
              || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
2648
            break;
2649
 
2650
          h->needs_plt = 1;
2651
 
2652
          break;
2653
 
2654
        case R_SH_64:
2655
        case R_SH_64_PCREL:
2656
          if (h != NULL)
2657
            h->non_got_ref = 1;
2658
 
2659
          /* If we are creating a shared library, and this is a reloc
2660
             against a global symbol, or a non PC relative reloc
2661
             against a local symbol, then we need to copy the reloc
2662
             into the shared library.  However, if we are linking with
2663
             -Bsymbolic, we do not need to copy a reloc against a
2664
             global symbol which is defined in an object we are
2665
             including in the link (i.e., DEF_REGULAR is set).  At
2666
             this point we have not seen all the input files, so it is
2667
             possible that DEF_REGULAR is not set now but will be set
2668
             later (it is never cleared).  We account for that
2669
             possibility below by storing information in the
2670
             pcrel_relocs_copied field of the hash table entry.  */
2671
          if (info->shared
2672
              && (sec->flags & SEC_ALLOC) != 0
2673
              && (ELF32_R_TYPE (rel->r_info) != R_SH_64_PCREL
2674
                  || (h != NULL
2675
                      && (! info->symbolic
2676
                          || !h->def_regular))))
2677
            {
2678
              /* When creating a shared object, we must copy these
2679
                 reloc types into the output file.  We create a reloc
2680
                 section in dynobj and make room for this reloc.  */
2681
              if (sreloc == NULL)
2682
                {
2683
                  sreloc = _bfd_elf_make_dynamic_reloc_section
2684
                    (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
2685
 
2686
                  if (sreloc == NULL)
2687
                    return FALSE;
2688
                }
2689
 
2690
              sreloc->size += sizeof (Elf64_External_Rela);
2691
 
2692
              /* If we are linking with -Bsymbolic, and this is a
2693
                 global symbol, we count the number of PC relative
2694
                 relocations we have entered for this symbol, so that
2695
                 we can discard them again if the symbol is later
2696
                 defined by a regular object.  Note that this function
2697
                 is only called if we are using an elf_sh linker
2698
                 hash table, which means that h is really a pointer to
2699
                 an elf_sh_link_hash_entry.  */
2700
              if (h != NULL && info->symbolic
2701
                  && ELF64_R_TYPE (rel->r_info) == R_SH_64_PCREL)
2702
                {
2703
                  struct elf_sh64_link_hash_entry *eh;
2704
                  struct elf_sh64_pcrel_relocs_copied *p;
2705
 
2706
                  eh = (struct elf_sh64_link_hash_entry *) h;
2707
 
2708
                  for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
2709
                    if (p->section == sreloc)
2710
                      break;
2711
 
2712
                  if (p == NULL)
2713
                    {
2714
                      p = ((struct elf_sh64_pcrel_relocs_copied *)
2715
                           bfd_alloc (dynobj, sizeof *p));
2716
                      if (p == NULL)
2717
                        return FALSE;
2718
                      p->next = eh->pcrel_relocs_copied;
2719
                      eh->pcrel_relocs_copied = p;
2720
                      p->section = sreloc;
2721
                      p->count = 0;
2722
                    }
2723
 
2724
                  ++p->count;
2725
                }
2726
            }
2727
 
2728
          break;
2729
        }
2730
    }
2731
 
2732
  return TRUE;
2733
}
2734
 
2735
static int
2736
sh64_elf64_get_symbol_type (Elf_Internal_Sym * elf_sym, int type)
2737
{
2738
  if (ELF_ST_TYPE (elf_sym->st_info) == STT_DATALABEL)
2739
    return STT_DATALABEL;
2740
 
2741
  return type;
2742
}
2743
 
2744
/* FIXME: This is a copy of sh64_elf_add_symbol_hook in elf32-sh64.c.
2745
   Either file can presumably exist without the other, but do not differ
2746
   in elf-size-ness.  How to share?
2747
 
2748
   Hook called by the linker routine which adds symbols from an object
2749
   file.  We must make indirect symbols for undefined symbols marked with
2750
   STT_DATALABEL, so relocations passing them will pick up that attribute
2751
   and neutralize STO_SH5_ISA32 found on the symbol definition.
2752
 
2753
   There is a problem, though: We want to fill in the hash-table entry for
2754
   this symbol and signal to the caller that no further processing is
2755
   needed.  But we don't have the index for this hash-table entry.  We
2756
   rely here on that the current entry is the first hash-entry with NULL,
2757
   which seems brittle.  Also, iterating over the hash-table to find that
2758
   entry is a linear operation on the number of symbols in this input
2759
   file, and this function should take constant time, so that's not good
2760
   too.  Only comfort is that DataLabel references should only be found in
2761
   hand-written assembly code and thus be rare.  FIXME: Talk maintainers
2762
   into adding an option to elf_add_symbol_hook (preferably) for the index
2763
   or the hash entry, alternatively adding the index to Elf_Internal_Sym
2764
   (not so good).  */
2765
 
2766
static bfd_boolean
2767
sh64_elf64_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
2768
                            Elf_Internal_Sym *sym, const char **namep,
2769
                            flagword *flagsp ATTRIBUTE_UNUSED,
2770
                            asection **secp, bfd_vma *valp)
2771
{
2772
  /* We want to do this for relocatable as well as final linking.  */
2773
  if (ELF_ST_TYPE (sym->st_info) == STT_DATALABEL
2774
      && is_elf_hash_table (info->hash))
2775
    {
2776
      struct elf_link_hash_entry *h;
2777
 
2778
      /* For relocatable links, we register the DataLabel sym in its own
2779
         right, and tweak the name when it's output.  Otherwise, we make
2780
         an indirect symbol of it.  */
2781
      flagword flags
2782
        = info->relocatable || info->emitrelocations
2783
        ? BSF_GLOBAL : BSF_GLOBAL | BSF_INDIRECT;
2784
 
2785
      char *dl_name
2786
        = bfd_malloc (strlen (*namep) + sizeof (DATALABEL_SUFFIX));
2787
      struct elf_link_hash_entry ** sym_hash = elf_sym_hashes (abfd);
2788
 
2789
      BFD_ASSERT (sym_hash != NULL);
2790
 
2791
      /* Allocation may fail.  */
2792
      if (dl_name == NULL)
2793
        return FALSE;
2794
 
2795
      strcpy (dl_name, *namep);
2796
      strcat (dl_name, DATALABEL_SUFFIX);
2797
 
2798
      h = (struct elf_link_hash_entry *)
2799
        bfd_link_hash_lookup (info->hash, dl_name, FALSE, FALSE, FALSE);
2800
 
2801
      if (h == NULL)
2802
        {
2803
          /* No previous datalabel symbol.  Make one.  */
2804
          struct bfd_link_hash_entry *bh = NULL;
2805
          const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2806
 
2807
          if (! _bfd_generic_link_add_one_symbol (info, abfd, dl_name,
2808
                                                  flags, *secp, *valp,
2809
                                                  *namep, FALSE,
2810
                                                  bed->collect, &bh))
2811
            {
2812
              free (dl_name);
2813
              return FALSE;
2814
            }
2815
 
2816
          h = (struct elf_link_hash_entry *) bh;
2817
          h->non_elf = 0;
2818
          h->type = STT_DATALABEL;
2819
        }
2820
      else
2821
        /* If a new symbol was created, it holds the allocated name.
2822
           Otherwise, we don't need it anymore and should deallocate it.  */
2823
        free (dl_name);
2824
 
2825
      if (h->type != STT_DATALABEL
2826
          || ((info->relocatable || info->emitrelocations)
2827
              && h->root.type != bfd_link_hash_undefined)
2828
          || (! info->relocatable && !info->emitrelocations
2829
              && h->root.type != bfd_link_hash_indirect))
2830
        {
2831
          /* Make sure we don't get confused on invalid input.  */
2832
          (*_bfd_error_handler)
2833
            (_("%s: encountered datalabel symbol in input"),
2834
             bfd_get_filename (abfd));
2835
          bfd_set_error (bfd_error_bad_value);
2836
          return FALSE;
2837
        }
2838
 
2839
      /* Now find the hash-table slot for this entry and fill it in.  */
2840
      while (*sym_hash != NULL)
2841
        sym_hash++;
2842
      *sym_hash = h;
2843
 
2844
      /* Signal to caller to skip this symbol - we've handled it.  */
2845
      *namep = NULL;
2846
    }
2847
 
2848
  return TRUE;
2849
}
2850
 
2851
/* This hook function is called before the linker writes out a global
2852
   symbol.  For relocatable links, DataLabel symbols will be present in
2853
   linker output.  We cut off the special suffix on those symbols, so the
2854
   right name appears in the output.
2855
 
2856
   When linking and emitting relocations, there can appear global symbols
2857
   that are not referenced by relocs, but rather only implicitly through
2858
   DataLabel references, a relation that is not visible to the linker.
2859
   Since no stripping of global symbols in done when doing such linking,
2860
   we don't need to look up and make sure to emit the main symbol for each
2861
   DataLabel symbol.  */
2862
 
2863
static int
2864
sh64_elf64_link_output_symbol_hook (struct bfd_link_info *info,
2865
                                    const char *cname,
2866
                                    Elf_Internal_Sym *sym,
2867
                                    asection *input_sec ATTRIBUTE_UNUSED,
2868
                                    struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
2869
{
2870
  char *name = (char *) cname;
2871
 
2872
  if (info->relocatable || info->emitrelocations)
2873
    {
2874
      if (ELF_ST_TYPE (sym->st_info) == STT_DATALABEL)
2875
        name[strlen (name) - strlen (DATALABEL_SUFFIX)] = 0;
2876
    }
2877
 
2878
  return 1;
2879
}
2880
 
2881
/* Set bit 0 on the entry address; it always points to SHmedia code.  This
2882
   is mostly for symmetry with the 32-bit format, where code can be
2883
   SHcompact and we need to make a distinction to make sure execution
2884
   starts in the right ISA mode.  It is also convenient for a loader,
2885
   which would otherwise have to set this bit when loading a TR register
2886
   before jumping to the program entry.  */
2887
 
2888
static void
2889
sh64_elf64_final_write_processing (bfd *abfd,
2890
                                   bfd_boolean linker ATTRIBUTE_UNUSED)
2891
{
2892
  /* FIXME: Perhaps we shouldn't do this if the entry address was supplied
2893
     numerically, but we currently lack the infrastructure to recognize
2894
     that: The entry symbol, and info whether it is numeric or a symbol
2895
     name is kept private in the linker.  */
2896
  if (elf_elfheader (abfd)->e_type == ET_EXEC)
2897
    elf_elfheader (abfd)->e_entry |= 1;
2898
}
2899
 
2900
/* First entry in an absolute procedure linkage table look like this.  */
2901
 
2902
static const bfd_byte elf_sh64_plt0_entry_be[PLT_ENTRY_SIZE] =
2903
{
2904
  0xcc, 0x00, 0x01, 0x10, /* movi  .got.plt >> 48, r17 */
2905
  0xc8, 0x00, 0x01, 0x10, /* shori (.got.plt >> 32) & 65535, r17 */
2906
  0xc8, 0x00, 0x01, 0x10, /* shori (.got.plt >> 16) & 65535, r17 */
2907
  0xc8, 0x00, 0x01, 0x10, /* shori .got.plt & 65535, r17 */
2908
  0x8d, 0x10, 0x09, 0x90, /* ld.q  r17, 16, r25 */
2909
  0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
2910
  0x8d, 0x10, 0x05, 0x10, /* ld.q  r17, 8, r17 */
2911
  0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
2912
  0x6f, 0xf0, 0xff, 0xf0, /* nop */
2913
  0x6f, 0xf0, 0xff, 0xf0, /* nop */
2914
  0x6f, 0xf0, 0xff, 0xf0, /* nop */
2915
  0x6f, 0xf0, 0xff, 0xf0, /* nop */
2916
  0x6f, 0xf0, 0xff, 0xf0, /* nop */
2917
  0x6f, 0xf0, 0xff, 0xf0, /* nop */
2918
  0x6f, 0xf0, 0xff, 0xf0, /* nop */
2919
  0x6f, 0xf0, 0xff, 0xf0, /* nop */
2920
};
2921
 
2922
static const bfd_byte elf_sh64_plt0_entry_le[PLT_ENTRY_SIZE] =
2923
{
2924
  0x10, 0x01, 0x00, 0xcc, /* movi  .got.plt >> 16, r17 */
2925
  0x10, 0x01, 0x00, 0xc8, /* shori (.got.plt >> 32) & 65535, r17 */
2926
  0x10, 0x01, 0x00, 0xc8, /* shori (.got.plt >> 16) & 65535, r17 */
2927
  0x10, 0x01, 0x00, 0xc8, /* shori .got.plt & 65535, r17 */
2928
  0x90, 0x09, 0x10, 0x8d, /* ld.q  r17, 16, r25 */
2929
  0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
2930
  0x10, 0x05, 0x10, 0x8d, /* ld.q  r17, 8, r17 */
2931
  0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
2932
  0xf0, 0xff, 0xf0, 0x6f, /* nop */
2933
  0xf0, 0xff, 0xf0, 0x6f, /* nop */
2934
  0xf0, 0xff, 0xf0, 0x6f, /* nop */
2935
  0xf0, 0xff, 0xf0, 0x6f, /* nop */
2936
  0xf0, 0xff, 0xf0, 0x6f, /* nop */
2937
  0xf0, 0xff, 0xf0, 0x6f, /* nop */
2938
  0xf0, 0xff, 0xf0, 0x6f, /* nop */
2939
  0xf0, 0xff, 0xf0, 0x6f, /* nop */
2940
};
2941
 
2942
/* Sebsequent entries in an absolute procedure linkage table look like
2943
   this.  */
2944
 
2945
static const bfd_byte elf_sh64_plt_entry_be[PLT_ENTRY_SIZE] =
2946
{
2947
  0xcc, 0x00, 0x01, 0x90, /* movi  nameN-in-GOT >> 48, r25 */
2948
  0xc8, 0x00, 0x01, 0x90, /* shori (nameN-in-GOT >> 32) & 65535, r25 */
2949
  0xc8, 0x00, 0x01, 0x90, /* shori (nameN-in-GOT >> 16) & 65535, r25 */
2950
  0xc8, 0x00, 0x01, 0x90, /* shori nameN-in-GOT & 65535, r25 */
2951
  0x8d, 0x90, 0x01, 0x90, /* ld.q  r25, 0, r25 */
2952
  0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
2953
  0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
2954
  0x6f, 0xf0, 0xff, 0xf0, /* nop */
2955
  0xcc, 0x00, 0x01, 0x90, /* movi  (.+8-.PLT0) >> 16, r25 */
2956
  0xc8, 0x00, 0x01, 0x90, /* shori (.+4-.PLT0) & 65535, r25 */
2957
  0x6b, 0xf5, 0x66, 0x00, /* ptrel r25, tr0 */
2958
  0xcc, 0x00, 0x01, 0x50, /* movi  reloc-offset >> 16, r21 */
2959
  0xc8, 0x00, 0x01, 0x50, /* shori reloc-offset & 65535, r21 */
2960
  0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
2961
  0x6f, 0xf0, 0xff, 0xf0, /* nop */
2962
  0x6f, 0xf0, 0xff, 0xf0, /* nop */
2963
};
2964
 
2965
static const bfd_byte elf_sh64_plt_entry_le[PLT_ENTRY_SIZE] =
2966
{
2967
  0x90, 0x01, 0x00, 0xcc, /* movi  nameN-in-GOT >> 16, r25 */
2968
  0x90, 0x01, 0x00, 0xc8, /* shori nameN-in-GOT & 65535, r25 */
2969
  0x90, 0x01, 0x00, 0xc8, /* shori nameN-in-GOT & 65535, r25 */
2970
  0x90, 0x01, 0x00, 0xc8, /* shori nameN-in-GOT & 65535, r25 */
2971
  0x90, 0x01, 0x90, 0x8d, /* ld.q  r25, 0, r25 */
2972
  0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
2973
  0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
2974
  0xf0, 0xff, 0xf0, 0x6f, /* nop */
2975
  0x90, 0x01, 0x00, 0xcc, /* movi  (.+8-.PLT0) >> 16, r25 */
2976
  0x90, 0x01, 0x00, 0xc8, /* shori (.+4-.PLT0) & 65535, r25 */
2977
  0x00, 0x66, 0xf5, 0x6b, /* ptrel r25, tr0 */
2978
  0x50, 0x01, 0x00, 0xcc, /* movi  reloc-offset >> 16, r21 */
2979
  0x50, 0x01, 0x00, 0xc8, /* shori reloc-offset & 65535, r21 */
2980
  0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
2981
  0xf0, 0xff, 0xf0, 0x6f, /* nop */
2982
  0xf0, 0xff, 0xf0, 0x6f, /* nop */
2983
};
2984
 
2985
/* Entries in a PIC procedure linkage table look like this.  */
2986
 
2987
static const bfd_byte elf_sh64_pic_plt_entry_be[PLT_ENTRY_SIZE] =
2988
{
2989
  0xcc, 0x00, 0x01, 0x90, /* movi  nameN@GOT >> 16, r25 */
2990
  0xc8, 0x00, 0x01, 0x90, /* shori nameN@GOT & 65535, r25 */
2991
  0x40, 0xc3, 0x65, 0x90, /* ldx.q r12, r25, r25 */
2992
  0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
2993
  0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
2994
  0x6f, 0xf0, 0xff, 0xf0, /* nop */
2995
  0x6f, 0xf0, 0xff, 0xf0, /* nop */
2996
  0x6f, 0xf0, 0xff, 0xf0, /* nop */
2997
  0xce, 0x00, 0x01, 0x10, /* movi  -GOT_BIAS, r17 */
2998
  0x00, 0xc9, 0x45, 0x10, /* add   r12, r17, r17 */
2999
  0x8d, 0x10, 0x09, 0x90, /* ld.q  r17, 16, r25 */
3000
  0x6b, 0xf1, 0x66, 0x00, /* ptabs r25, tr0 */
3001
  0x8d, 0x10, 0x05, 0x10, /* ld.q  r17, 8, r17 */
3002
  0xcc, 0x00, 0x01, 0x50, /* movi  reloc-offset >> 16, r21 */
3003
  0xc8, 0x00, 0x01, 0x50, /* shori reloc-offset & 65535, r21 */
3004
  0x44, 0x01, 0xff, 0xf0, /* blink tr0, r63 */
3005
};
3006
 
3007
static const bfd_byte elf_sh64_pic_plt_entry_le[PLT_ENTRY_SIZE] =
3008
{
3009
  0x90, 0x01, 0x00, 0xcc, /* movi  nameN@GOT >> 16, r25 */
3010
  0x90, 0x01, 0x00, 0xc8, /* shori nameN@GOT & 65535, r25 */
3011
  0x90, 0x65, 0xc3, 0x40, /* ldx.q r12, r25, r25 */
3012
  0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
3013
  0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
3014
  0xf0, 0xff, 0xf0, 0x6f, /* nop */
3015
  0xf0, 0xff, 0xf0, 0x6f, /* nop */
3016
  0xf0, 0xff, 0xf0, 0x6f, /* nop */
3017
  0x10, 0x01, 0x00, 0xce, /* movi  -GOT_BIAS, r17 */
3018
  0x10, 0x45, 0xc9, 0x00, /* add   r12, r17, r17 */
3019
  0x90, 0x09, 0x10, 0x8d, /* ld.q  r17, 16, r25 */
3020
  0x00, 0x66, 0xf1, 0x6b, /* ptabs r25, tr0 */
3021
  0x10, 0x05, 0x10, 0x8d, /* ld.q  r17, 8, r17 */
3022
  0x50, 0x01, 0x00, 0xcc, /* movi  reloc-offset >> 16, r21 */
3023
  0x50, 0x01, 0x00, 0xc8, /* shori reloc-offset & 65535, r21 */
3024
  0xf0, 0xff, 0x01, 0x44, /* blink tr0, r63 */
3025
};
3026
 
3027
static const bfd_byte *elf_sh64_plt0_entry;
3028
static const bfd_byte *elf_sh64_plt_entry;
3029
static const bfd_byte *elf_sh64_pic_plt_entry;
3030
 
3031
/* Create an entry in an sh ELF linker hash table.  */
3032
 
3033
static struct bfd_hash_entry *
3034
sh64_elf64_link_hash_newfunc (struct bfd_hash_entry *entry,
3035
                              struct bfd_hash_table *table,
3036
                              const char *string)
3037
{
3038
  struct elf_sh64_link_hash_entry *ret =
3039
    (struct elf_sh64_link_hash_entry *) entry;
3040
 
3041
  /* Allocate the structure if it has not already been allocated by a
3042
     subclass.  */
3043
  if (ret == (struct elf_sh64_link_hash_entry *) NULL)
3044
    ret = ((struct elf_sh64_link_hash_entry *)
3045
           bfd_hash_allocate (table,
3046
                              sizeof (struct elf_sh64_link_hash_entry)));
3047
  if (ret == (struct elf_sh64_link_hash_entry *) NULL)
3048
    return (struct bfd_hash_entry *) ret;
3049
 
3050
  /* Call the allocation method of the superclass.  */
3051
  ret = ((struct elf_sh64_link_hash_entry *)
3052
         _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
3053
                                     table, string));
3054
  if (ret != (struct elf_sh64_link_hash_entry *) NULL)
3055
    {
3056
      ret->pcrel_relocs_copied = NULL;
3057
      ret->datalabel_got_offset = (bfd_vma) -1;
3058
    }
3059
 
3060
  return (struct bfd_hash_entry *) ret;
3061
}
3062
 
3063
/* Create an sh64 ELF linker hash table.  */
3064
 
3065
static struct bfd_link_hash_table *
3066
sh64_elf64_link_hash_table_create (bfd *abfd)
3067
{
3068
  struct elf_link_hash_table *ret;
3069
 
3070
  ret = (struct elf_link_hash_table *) bfd_malloc (sizeof (* ret));
3071
  if (ret == (struct elf_link_hash_table *) NULL)
3072
    return NULL;
3073
 
3074
  if (!_bfd_elf_link_hash_table_init (ret, abfd,
3075
                                      sh64_elf64_link_hash_newfunc,
3076
                                      sizeof (struct elf_sh64_link_hash_entry),
3077
                                      GENERIC_ELF_DATA))
3078
    {
3079
      free (ret);
3080
      return NULL;
3081
    }
3082
 
3083
  return &ret->root;
3084
}
3085
 
3086
inline static void
3087
movi_shori_putval (bfd *output_bfd, unsigned long value, bfd_byte *addr)
3088
{
3089
  bfd_put_32 (output_bfd,
3090
              bfd_get_32 (output_bfd, addr)
3091
              | ((value >> 6) & 0x3fffc00),
3092
              addr);
3093
  bfd_put_32 (output_bfd,
3094
              bfd_get_32 (output_bfd, addr + 4)
3095
              | ((value << 10) & 0x3fffc00),
3096
              addr + 4);
3097
}
3098
 
3099
inline static void
3100
movi_3shori_putval (bfd *output_bfd, bfd_vma value, bfd_byte *addr)
3101
{
3102
  bfd_put_32 (output_bfd,
3103
              bfd_get_32 (output_bfd, addr)
3104
              | ((value >> 38) & 0x3fffc00),
3105
              addr);
3106
  bfd_put_32 (output_bfd,
3107
              bfd_get_32 (output_bfd, addr + 4)
3108
              | ((value >> 22) & 0x3fffc00),
3109
              addr + 4);
3110
  bfd_put_32 (output_bfd,
3111
              bfd_get_32 (output_bfd, addr + 8)
3112
              | ((value >> 6) & 0x3fffc00),
3113
              addr + 8);
3114
  bfd_put_32 (output_bfd,
3115
              bfd_get_32 (output_bfd, addr + 12)
3116
              | ((value << 10) & 0x3fffc00),
3117
              addr + 12);
3118
}
3119
 
3120
/* Create dynamic sections when linking against a dynamic object.  */
3121
 
3122
static bfd_boolean
3123
sh64_elf64_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
3124
{
3125
  flagword flags, pltflags;
3126
  register asection *s;
3127
  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3128
  int ptralign = 0;
3129
 
3130
  switch (bed->s->arch_size)
3131
    {
3132
    case 32:
3133
      ptralign = 2;
3134
      break;
3135
 
3136
    case 64:
3137
      ptralign = 3;
3138
      break;
3139
 
3140
    default:
3141
      bfd_set_error (bfd_error_bad_value);
3142
      return FALSE;
3143
    }
3144
 
3145
  /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
3146
     .rel[a].bss sections.  */
3147
 
3148
  flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3149
           | SEC_LINKER_CREATED);
3150
 
3151
  pltflags = flags;
3152
  pltflags |= SEC_CODE;
3153
  if (bed->plt_not_loaded)
3154
    pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
3155
  if (bed->plt_readonly)
3156
    pltflags |= SEC_READONLY;
3157
 
3158
  s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
3159
  if (s == NULL
3160
      || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
3161
    return FALSE;
3162
 
3163
  if (bed->want_plt_sym)
3164
    {
3165
      /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
3166
         .plt section.  */
3167
      struct elf_link_hash_entry *h;
3168
      struct bfd_link_hash_entry *bh = NULL;
3169
 
3170
      if (! (_bfd_generic_link_add_one_symbol
3171
             (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
3172
              (bfd_vma) 0, (const char *) NULL, FALSE, bed->collect, &bh)))
3173
        return FALSE;
3174
 
3175
      h = (struct elf_link_hash_entry *) bh;
3176
      h->def_regular = 1;
3177
      h->type = STT_OBJECT;
3178
      elf_hash_table (info)->hplt = h;
3179
 
3180
      if (info->shared
3181
          && ! bfd_elf_link_record_dynamic_symbol (info, h))
3182
        return FALSE;
3183
    }
3184
 
3185
  s = bfd_make_section_with_flags (abfd,
3186
                                   bed->default_use_rela_p ? ".rela.plt" : ".rel.plt",
3187
                                   flags | SEC_READONLY);
3188
  if (s == NULL
3189
      || ! bfd_set_section_alignment (abfd, s, ptralign))
3190
    return FALSE;
3191
 
3192
  if (! _bfd_elf_create_got_section (abfd, info))
3193
    return FALSE;
3194
 
3195
  {
3196
    const char *secname;
3197
    char *relname;
3198
    flagword secflags;
3199
    asection *sec;
3200
 
3201
    for (sec = abfd->sections; sec; sec = sec->next)
3202
      {
3203
        secflags = bfd_get_section_flags (abfd, sec);
3204
        if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
3205
            || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
3206
          continue;
3207
        secname = bfd_get_section_name (abfd, sec);
3208
        relname = (char *) bfd_malloc (strlen (secname) + 6);
3209
        strcpy (relname, ".rela");
3210
        strcat (relname, secname);
3211
        s = bfd_make_section_with_flags (abfd, relname,
3212
                                         flags | SEC_READONLY);
3213
        if (s == NULL
3214
            || ! bfd_set_section_alignment (abfd, s, ptralign))
3215
          return FALSE;
3216
      }
3217
  }
3218
 
3219
  if (bed->want_dynbss)
3220
    {
3221
      /* The .dynbss section is a place to put symbols which are defined
3222
         by dynamic objects, are referenced by regular objects, and are
3223
         not functions.  We must allocate space for them in the process
3224
         image and use a R_*_COPY reloc to tell the dynamic linker to
3225
         initialize them at run time.  The linker script puts the .dynbss
3226
         section into the .bss section of the final image.  */
3227
      s = bfd_make_section_with_flags (abfd, ".dynbss",
3228
                                       SEC_ALLOC | SEC_LINKER_CREATED);
3229
      if (s == NULL)
3230
        return FALSE;
3231
 
3232
      /* The .rel[a].bss section holds copy relocs.  This section is not
3233
         normally needed.  We need to create it here, though, so that the
3234
         linker will map it to an output section.  We can't just create it
3235
         only if we need it, because we will not know whether we need it
3236
         until we have seen all the input files, and the first time the
3237
         main linker code calls BFD after examining all the input files
3238
         (size_dynamic_sections) the input sections have already been
3239
         mapped to the output sections.  If the section turns out not to
3240
         be needed, we can discard it later.  We will never need this
3241
         section when generating a shared object, since they do not use
3242
         copy relocs.  */
3243
      if (! info->shared)
3244
        {
3245
          s = bfd_make_section_with_flags (abfd,
3246
                                           (bed->default_use_rela_p
3247
                                            ? ".rela.bss" : ".rel.bss"),
3248
                                           flags | SEC_READONLY);
3249
          if (s == NULL
3250
              || ! bfd_set_section_alignment (abfd, s, ptralign))
3251
            return FALSE;
3252
        }
3253
    }
3254
 
3255
  return TRUE;
3256
}
3257
 
3258
/* Adjust a symbol defined by a dynamic object and referenced by a
3259
   regular object.  The current definition is in some section of the
3260
   dynamic object, but we're not including those sections.  We have to
3261
   change the definition to something the rest of the link can
3262
   understand.  */
3263
 
3264
static bfd_boolean
3265
sh64_elf64_adjust_dynamic_symbol (struct bfd_link_info *info,
3266
                                  struct elf_link_hash_entry *h)
3267
{
3268
  bfd *dynobj;
3269
  asection *s;
3270
 
3271
  dynobj = elf_hash_table (info)->dynobj;
3272
 
3273
  /* Make sure we know what is going on here.  */
3274
  BFD_ASSERT (dynobj != NULL
3275
              && (h->needs_plt
3276
                  || h->u.weakdef != NULL
3277
                  || (h->def_dynamic
3278
                      && h->ref_regular
3279
                      && !h->def_regular)));
3280
 
3281
  /* If this is a function, put it in the procedure linkage table.  We
3282
     will fill in the contents of the procedure linkage table later,
3283
     when we know the address of the .got section.  */
3284
  if (h->type == STT_FUNC
3285
      || h->needs_plt)
3286
    {
3287
      if (! info->shared
3288
          && !h->def_dynamic
3289
          && !h->ref_dynamic)
3290
        {
3291
          /* This case can occur if we saw a PLT reloc in an input
3292
             file, but the symbol was never referred to by a dynamic
3293
             object.  In such a case, we don't actually need to build
3294
             a procedure linkage table, and we can just do a REL64
3295
             reloc instead.  */
3296
          BFD_ASSERT (h->needs_plt);
3297
          return TRUE;
3298
        }
3299
 
3300
      /* Make sure this symbol is output as a dynamic symbol.  */
3301
      if (h->dynindx == -1)
3302
        {
3303
          if (! bfd_elf_link_record_dynamic_symbol (info, h))
3304
            return FALSE;
3305
        }
3306
 
3307
      s = bfd_get_section_by_name (dynobj, ".plt");
3308
      BFD_ASSERT (s != NULL);
3309
 
3310
      /* If this is the first .plt entry, make room for the special
3311
         first entry.  */
3312
      if (s->size == 0)
3313
        s->size += PLT_ENTRY_SIZE;
3314
 
3315
      /* If this symbol is not defined in a regular file, and we are
3316
         not generating a shared library, then set the symbol to this
3317
         location in the .plt.  This is required to make function
3318
         pointers compare as equal between the normal executable and
3319
         the shared library.  */
3320
      if (! info->shared
3321
          && !h->def_regular)
3322
        {
3323
          h->root.u.def.section = s;
3324
          h->root.u.def.value = s->size;
3325
        }
3326
 
3327
      h->plt.offset = s->size;
3328
 
3329
      /* Make room for this entry.  */
3330
      s->size += elf_sh64_sizeof_plt (info);
3331
 
3332
      /* We also need to make an entry in the .got.plt section, which
3333
         will be placed in the .got section by the linker script.  */
3334
 
3335
      s = bfd_get_section_by_name (dynobj, ".got.plt");
3336
      BFD_ASSERT (s != NULL);
3337
      s->size += 8;
3338
 
3339
      /* We also need to make an entry in the .rela.plt section.  */
3340
 
3341
      s = bfd_get_section_by_name (dynobj, ".rela.plt");
3342
      BFD_ASSERT (s != NULL);
3343
      s->size += sizeof (Elf64_External_Rela);
3344
 
3345
      return TRUE;
3346
    }
3347
 
3348
  /* If this is a weak symbol, and there is a real definition, the
3349
     processor independent code will have arranged for us to see the
3350
     real definition first, and we can just use the same value.  */
3351
  if (h->u.weakdef != NULL)
3352
    {
3353
      BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
3354
                  || h->u.weakdef->root.type == bfd_link_hash_defweak);
3355
      h->root.u.def.section = h->u.weakdef->root.u.def.section;
3356
      h->root.u.def.value = h->u.weakdef->root.u.def.value;
3357
      return TRUE;
3358
    }
3359
 
3360
  /* This is a reference to a symbol defined by a dynamic object which
3361
     is not a function.  */
3362
 
3363
  /* If we are creating a shared library, we must presume that the
3364
     only references to the symbol are via the global offset table.
3365
     For such cases we need not do anything here; the relocations will
3366
     be handled correctly by relocate_section.  */
3367
  if (info->shared)
3368
    return TRUE;
3369
 
3370
  /* If there are no references to this symbol that do not use the
3371
     GOT, we don't need to generate a copy reloc.  */
3372
  if (!h->non_got_ref)
3373
    return TRUE;
3374
 
3375
  if (h->size == 0)
3376
    {
3377
      (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
3378
                             h->root.root.string);
3379
      return TRUE;
3380
    }
3381
 
3382
  /* We must allocate the symbol in our .dynbss section, which will
3383
     become part of the .bss section of the executable.  There will be
3384
     an entry for this symbol in the .dynsym section.  The dynamic
3385
     object will contain position independent code, so all references
3386
     from the dynamic object to this symbol will go through the global
3387
     offset table.  The dynamic linker will use the .dynsym entry to
3388
     determine the address it must put in the global offset table, so
3389
     both the dynamic object and the regular object will refer to the
3390
     same memory location for the variable.  */
3391
 
3392
  s = bfd_get_section_by_name (dynobj, ".dynbss");
3393
  BFD_ASSERT (s != NULL);
3394
 
3395
  /* We must generate a R_SH_COPY reloc to tell the dynamic linker to
3396
     copy the initial value out of the dynamic object and into the
3397
     runtime process image.  We need to remember the offset into the
3398
     .rela.bss section we are going to use.  */
3399
  if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
3400
    {
3401
      asection *srel;
3402
 
3403
      srel = bfd_get_section_by_name (dynobj, ".rela.bss");
3404
      BFD_ASSERT (srel != NULL);
3405
      srel->size += sizeof (Elf64_External_Rela);
3406
      h->needs_copy = 1;
3407
    }
3408
 
3409
  return _bfd_elf_adjust_dynamic_copy (h, s);
3410
}
3411
 
3412
/* This function is called via sh_elf_link_hash_traverse if we are
3413
   creating a shared object with -Bsymbolic.  It discards the space
3414
   allocated to copy PC relative relocs against symbols which are
3415
   defined in regular objects.  We allocated space for them in the
3416
   check_relocs routine, but we won't fill them in in the
3417
   relocate_section routine.  */
3418
 
3419
static bfd_boolean
3420
sh64_elf64_discard_copies (struct elf_sh64_link_hash_entry *h,
3421
                           void *ignore ATTRIBUTE_UNUSED)
3422
{
3423
  struct elf_sh64_pcrel_relocs_copied *s;
3424
 
3425
  if (h->root.root.type == bfd_link_hash_warning)
3426
    h = (struct elf_sh64_link_hash_entry *) h->root.root.u.i.link;
3427
 
3428
  /* We only discard relocs for symbols defined in a regular object.  */
3429
  if (!h->root.def_regular)
3430
    return TRUE;
3431
 
3432
  for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
3433
    s->section->size -= s->count * sizeof (Elf64_External_Rela);
3434
 
3435
  return TRUE;
3436
}
3437
 
3438
/* Set the sizes of the dynamic sections.  */
3439
 
3440
static bfd_boolean
3441
sh64_elf64_size_dynamic_sections (bfd *output_bfd,
3442
                                  struct bfd_link_info *info)
3443
{
3444
  bfd *dynobj;
3445
  asection *s;
3446
  bfd_boolean plt;
3447
  bfd_boolean relocs;
3448
  bfd_boolean reltext;
3449
 
3450
  dynobj = elf_hash_table (info)->dynobj;
3451
  BFD_ASSERT (dynobj != NULL);
3452
 
3453
  if (elf_hash_table (info)->dynamic_sections_created)
3454
    {
3455
      /* Set the contents of the .interp section to the interpreter.  */
3456
      if (info->executable)
3457
        {
3458
          s = bfd_get_section_by_name (dynobj, ".interp");
3459
          BFD_ASSERT (s != NULL);
3460
          s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3461
          s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3462
        }
3463
    }
3464
  else
3465
    {
3466
      /* We may have created entries in the .rela.got section.
3467
         However, if we are not creating the dynamic sections, we will
3468
         not actually use these entries.  Reset the size of .rela.got,
3469
         which will cause it to get stripped from the output file
3470
         below.  */
3471
      s = bfd_get_section_by_name (dynobj, ".rela.got");
3472
      if (s != NULL)
3473
        s->size = 0;
3474
    }
3475
 
3476
  /* If this is a -Bsymbolic shared link, then we need to discard all
3477
     PC relative relocs against symbols defined in a regular object.
3478
     We allocated space for them in the check_relocs routine, but we
3479
     will not fill them in in the relocate_section routine.  */
3480
  if (info->shared && info->symbolic)
3481
    sh64_elf64_link_hash_traverse (elf_hash_table (info),
3482
                                   sh64_elf64_discard_copies, NULL);
3483
 
3484
  /* The check_relocs and adjust_dynamic_symbol entry points have
3485
     determined the sizes of the various dynamic sections.  Allocate
3486
     memory for them.  */
3487
  plt = FALSE;
3488
  relocs = FALSE;
3489
  reltext = FALSE;
3490
  for (s = dynobj->sections; s != NULL; s = s->next)
3491
    {
3492
      const char *name;
3493
 
3494
      if ((s->flags & SEC_LINKER_CREATED) == 0)
3495
        continue;
3496
 
3497
      /* It's OK to base decisions on the section name, because none
3498
         of the dynobj section names depend upon the input files.  */
3499
      name = bfd_get_section_name (dynobj, s);
3500
 
3501
      if (strcmp (name, ".plt") == 0)
3502
        {
3503
          /* Remember whether there is a PLT.  */
3504
          plt = s->size != 0;
3505
        }
3506
      else if (CONST_STRNEQ (name, ".rela"))
3507
        {
3508
          if (s->size != 0)
3509
            {
3510
              asection *target;
3511
 
3512
              /* Remember whether there are any reloc sections other
3513
                 than .rela.plt.  */
3514
              if (strcmp (name, ".rela.plt") != 0)
3515
                {
3516
                  const char *outname;
3517
 
3518
                  relocs = TRUE;
3519
 
3520
                  /* If this relocation section applies to a read only
3521
                     section, then we probably need a DT_TEXTREL
3522
                     entry.  The entries in the .rela.plt section
3523
                     really apply to the .got section, which we
3524
                     created ourselves and so know is not readonly.  */
3525
                  outname = bfd_get_section_name (output_bfd,
3526
                                                  s->output_section);
3527
                  target = bfd_get_section_by_name (output_bfd, outname + 5);
3528
                  if (target != NULL
3529
                      && (target->flags & SEC_READONLY) != 0
3530
                      && (target->flags & SEC_ALLOC) != 0)
3531
                    reltext = TRUE;
3532
                }
3533
 
3534
              /* We use the reloc_count field as a counter if we need
3535
                 to copy relocs into the output file.  */
3536
              s->reloc_count = 0;
3537
            }
3538
        }
3539
      else if (! CONST_STRNEQ (name, ".got")
3540
               && strcmp (name, ".dynbss") != 0)
3541
        {
3542
          /* It's not one of our sections, so don't allocate space.  */
3543
          continue;
3544
        }
3545
 
3546
      if (s->size == 0)
3547
        {
3548
          /* If we don't need this section, strip it from the
3549
             output file.  This is mostly to handle .rela.bss and
3550
             .rela.plt.  We must create both sections in
3551
             create_dynamic_sections, because they must be created
3552
             before the linker maps input sections to output
3553
             sections.  The linker does that before
3554
             adjust_dynamic_symbol is called, and it is that
3555
             function which decides whether anything needs to go
3556
             into these sections.  */
3557
          s->flags |= SEC_EXCLUDE;
3558
          continue;
3559
        }
3560
 
3561
      if ((s->flags & SEC_HAS_CONTENTS) == 0)
3562
        continue;
3563
 
3564
      /* Allocate memory for the section contents.  */
3565
      s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
3566
      if (s->contents == NULL)
3567
        return FALSE;
3568
    }
3569
 
3570
  if (elf_hash_table (info)->dynamic_sections_created)
3571
    {
3572
      /* Add some entries to the .dynamic section.  We fill in the
3573
         values later, in sh64_elf64_finish_dynamic_sections, but we
3574
         must add the entries now so that we get the correct size for
3575
         the .dynamic section.  The DT_DEBUG entry is filled in by the
3576
         dynamic linker and used by the debugger.  */
3577
      if (info->executable)
3578
        {
3579
          if (!_bfd_elf_add_dynamic_entry (info, DT_DEBUG, 0))
3580
            return FALSE;
3581
        }
3582
 
3583
      if (plt)
3584
        {
3585
          if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0)
3586
              || !_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
3587
              || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
3588
              || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0))
3589
            return FALSE;
3590
        }
3591
 
3592
      if (relocs)
3593
        {
3594
          if (!_bfd_elf_add_dynamic_entry (info, DT_RELA, 0)
3595
              || !_bfd_elf_add_dynamic_entry (info, DT_RELASZ, 0)
3596
              || !_bfd_elf_add_dynamic_entry (info, DT_RELAENT,
3597
                                              sizeof (Elf64_External_Rela)))
3598
            return FALSE;
3599
        }
3600
 
3601
      if (reltext)
3602
        {
3603
          if (!_bfd_elf_add_dynamic_entry (info, DT_TEXTREL, 0))
3604
            return FALSE;
3605
        }
3606
    }
3607
 
3608
  return TRUE;
3609
}
3610
 
3611
/* Finish up dynamic symbol handling.  We set the contents of various
3612
   dynamic sections here.  */
3613
 
3614
static bfd_boolean
3615
sh64_elf64_finish_dynamic_symbol (bfd *output_bfd,
3616
                                  struct bfd_link_info *info,
3617
                                  struct elf_link_hash_entry *h,
3618
                                  Elf_Internal_Sym *sym)
3619
{
3620
  bfd *dynobj;
3621
 
3622
  dynobj = elf_hash_table (info)->dynobj;
3623
 
3624
  if (h->plt.offset != (bfd_vma) -1)
3625
    {
3626
      asection *splt;
3627
      asection *sgot;
3628
      asection *srel;
3629
 
3630
      bfd_vma plt_index;
3631
      bfd_vma got_offset;
3632
      Elf_Internal_Rela rel;
3633
      bfd_byte *loc;
3634
 
3635
      /* This symbol has an entry in the procedure linkage table.  Set
3636
         it up.  */
3637
 
3638
      BFD_ASSERT (h->dynindx != -1);
3639
 
3640
      splt = bfd_get_section_by_name (dynobj, ".plt");
3641
      sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3642
      srel = bfd_get_section_by_name (dynobj, ".rela.plt");
3643
      BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
3644
 
3645
      /* Get the index in the procedure linkage table which
3646
         corresponds to this symbol.  This is the index of this symbol
3647
         in all the symbols for which we are making plt entries.  The
3648
         first entry in the procedure linkage table is reserved.  */
3649
      plt_index = h->plt.offset / elf_sh64_sizeof_plt (info) - 1;
3650
 
3651
      /* Get the offset into the .got table of the entry that
3652
         corresponds to this function.  Each .got entry is 8 bytes.
3653
         The first three are reserved.  */
3654
      got_offset = (plt_index + 3) * 8;
3655
 
3656
      if (info->shared)
3657
        got_offset -= GOT_BIAS;
3658
 
3659
      /* Fill in the entry in the procedure linkage table.  */
3660
      if (! info->shared)
3661
        {
3662
          if (elf_sh64_plt_entry == NULL)
3663
            {
3664
              elf_sh64_plt_entry = (bfd_big_endian (output_bfd) ?
3665
                                  elf_sh64_plt_entry_be : elf_sh64_plt_entry_le);
3666
            }
3667
          memcpy (splt->contents + h->plt.offset, elf_sh64_plt_entry,
3668
                  elf_sh64_sizeof_plt (info));
3669
          movi_3shori_putval (output_bfd,
3670
                              (sgot->output_section->vma
3671
                               + sgot->output_offset
3672
                               + got_offset),
3673
                              (splt->contents + h->plt.offset
3674
                               + elf_sh64_plt_symbol_offset (info)));
3675
 
3676
          /* Set bottom bit because its for a branch to SHmedia */
3677
          movi_shori_putval (output_bfd,
3678
                             -(h->plt.offset
3679
                              + elf_sh64_plt_plt0_offset (info) + 8)
3680
                             | 1,
3681
                             (splt->contents + h->plt.offset
3682
                              + elf_sh64_plt_plt0_offset (info)));
3683
        }
3684
      else
3685
        {
3686
          if (elf_sh64_pic_plt_entry == NULL)
3687
            {
3688
              elf_sh64_pic_plt_entry = (bfd_big_endian (output_bfd) ?
3689
                                      elf_sh64_pic_plt_entry_be :
3690
                                      elf_sh64_pic_plt_entry_le);
3691
            }
3692
          memcpy (splt->contents + h->plt.offset, elf_sh64_pic_plt_entry,
3693
                  elf_sh64_sizeof_plt (info));
3694
          movi_shori_putval (output_bfd, got_offset,
3695
                             (splt->contents + h->plt.offset
3696
                              + elf_sh64_plt_symbol_offset (info)));
3697
        }
3698
 
3699
      if (info->shared)
3700
        got_offset += GOT_BIAS;
3701
 
3702
      movi_shori_putval (output_bfd,
3703
                         plt_index * sizeof (Elf64_External_Rela),
3704
                         (splt->contents + h->plt.offset
3705
                          + elf_sh64_plt_reloc_offset (info)));
3706
 
3707
      /* Fill in the entry in the global offset table.  */
3708
      bfd_put_64 (output_bfd,
3709
                  (splt->output_section->vma
3710
                   + splt->output_offset
3711
                   + h->plt.offset
3712
                   + elf_sh64_plt_temp_offset (info)),
3713
                  sgot->contents + got_offset);
3714
 
3715
      /* Fill in the entry in the .rela.plt section.  */
3716
      rel.r_offset = (sgot->output_section->vma
3717
                      + sgot->output_offset
3718
                      + got_offset);
3719
      rel.r_info = ELF64_R_INFO (h->dynindx, R_SH_JMP_SLOT64);
3720
      rel.r_addend = 0;
3721
      rel.r_addend = GOT_BIAS;
3722
      loc = srel->contents + plt_index * sizeof (Elf64_External_Rela);
3723
      bfd_elf64_swap_reloca_out (output_bfd, &rel, loc);
3724
 
3725
      if (!h->def_regular)
3726
        {
3727
          /* Mark the symbol as undefined, rather than as defined in
3728
             the .plt section.  Leave the value alone.  */
3729
          sym->st_shndx = SHN_UNDEF;
3730
        }
3731
    }
3732
 
3733
  if (h->got.offset != (bfd_vma) -1)
3734
    {
3735
      asection *sgot;
3736
      asection *srel;
3737
      Elf_Internal_Rela rel;
3738
      bfd_byte *loc;
3739
 
3740
      /* This symbol has an entry in the global offset table.  Set it
3741
         up.  */
3742
 
3743
      sgot = bfd_get_section_by_name (dynobj, ".got");
3744
      srel = bfd_get_section_by_name (dynobj, ".rela.got");
3745
      BFD_ASSERT (sgot != NULL && srel != NULL);
3746
 
3747
      rel.r_offset = (sgot->output_section->vma
3748
                      + sgot->output_offset
3749
                      + (h->got.offset &~ 1));
3750
 
3751
      /* If this is a -Bsymbolic link, and the symbol is defined
3752
         locally, we just want to emit a RELATIVE reloc.  Likewise if
3753
         the symbol was forced to be local because of a version file.
3754
         The entry in the global offset table will already have been
3755
         initialized in the relocate_section function.  */
3756
      if (info->shared
3757
          && (info->symbolic || h->dynindx == -1)
3758
          && h->def_regular)
3759
        {
3760
          rel.r_info = ELF64_R_INFO (0, R_SH_RELATIVE64);
3761
          rel.r_addend = (h->root.u.def.value
3762
                          + h->root.u.def.section->output_section->vma
3763
                          + h->root.u.def.section->output_offset);
3764
        }
3765
      else
3766
        {
3767
          bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
3768
          rel.r_info = ELF64_R_INFO (h->dynindx, R_SH_GLOB_DAT64);
3769
          rel.r_addend = 0;
3770
        }
3771
 
3772
      loc = srel->contents;
3773
      loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
3774
      bfd_elf64_swap_reloca_out (output_bfd, &rel, loc);
3775
    }
3776
 
3777
  if (h->needs_copy)
3778
    {
3779
      asection *s;
3780
      Elf_Internal_Rela rel;
3781
      bfd_byte *loc;
3782
 
3783
      /* This symbol needs a copy reloc.  Set it up.  */
3784
 
3785
      BFD_ASSERT (h->dynindx != -1
3786
                  && (h->root.type == bfd_link_hash_defined
3787
                      || h->root.type == bfd_link_hash_defweak));
3788
 
3789
      s = bfd_get_section_by_name (h->root.u.def.section->owner,
3790
                                   ".rela.bss");
3791
      BFD_ASSERT (s != NULL);
3792
 
3793
      rel.r_offset = (h->root.u.def.value
3794
                      + h->root.u.def.section->output_section->vma
3795
                      + h->root.u.def.section->output_offset);
3796
      rel.r_info = ELF64_R_INFO (h->dynindx, R_SH_COPY64);
3797
      rel.r_addend = 0;
3798
      loc = s->contents;
3799
      loc += s->reloc_count++ * sizeof (Elf64_External_Rela);
3800
      bfd_elf64_swap_reloca_out (output_bfd, &rel, loc);
3801
    }
3802
 
3803
  /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
3804
  if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3805
      || h == elf_hash_table (info)->hgot)
3806
    sym->st_shndx = SHN_ABS;
3807
 
3808
  return TRUE;
3809
}
3810
 
3811
/* Finish up the dynamic sections.  */
3812
 
3813
static bfd_boolean
3814
sh64_elf64_finish_dynamic_sections (bfd *output_bfd,
3815
                                    struct bfd_link_info *info)
3816
{
3817
  bfd *dynobj;
3818
  asection *sgot;
3819
  asection *sdyn;
3820
 
3821
  dynobj = elf_hash_table (info)->dynobj;
3822
 
3823
  sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3824
  BFD_ASSERT (sgot != NULL);
3825
  sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3826
 
3827
  if (elf_hash_table (info)->dynamic_sections_created)
3828
    {
3829
      asection *splt;
3830
      Elf64_External_Dyn *dyncon, *dynconend;
3831
 
3832
      BFD_ASSERT (sdyn != NULL);
3833
 
3834
      dyncon = (Elf64_External_Dyn *) sdyn->contents;
3835
      dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
3836
      for (; dyncon < dynconend; dyncon++)
3837
        {
3838
          Elf_Internal_Dyn dyn;
3839
          const char *name;
3840
          asection *s;
3841
          struct elf_link_hash_entry *h;
3842
 
3843
          bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3844
 
3845
          switch (dyn.d_tag)
3846
            {
3847
            default:
3848
              break;
3849
 
3850
            case DT_INIT:
3851
              name = info->init_function;
3852
              goto get_sym;
3853
 
3854
            case DT_FINI:
3855
              name = info->fini_function;
3856
            get_sym:
3857
              if (dyn.d_un.d_val != 0)
3858
                {
3859
                  h = elf_link_hash_lookup (elf_hash_table (info), name,
3860
                                            FALSE, FALSE, TRUE);
3861
                  if (h != NULL && (h->other & STO_SH5_ISA32))
3862
                    {
3863
                      dyn.d_un.d_val |= 1;
3864
                      bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3865
                    }
3866
                }
3867
              break;
3868
 
3869
            case DT_PLTGOT:
3870
              name = ".got";
3871
              goto get_vma;
3872
 
3873
            case DT_JMPREL:
3874
              name = ".rela.plt";
3875
            get_vma:
3876
              s = bfd_get_section_by_name (output_bfd, name);
3877
              BFD_ASSERT (s != NULL);
3878
              dyn.d_un.d_ptr = s->vma;
3879
              bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3880
              break;
3881
 
3882
            case DT_PLTRELSZ:
3883
              s = bfd_get_section_by_name (output_bfd, ".rela.plt");
3884
              BFD_ASSERT (s != NULL);
3885
              dyn.d_un.d_val = s->size;
3886
              bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3887
              break;
3888
 
3889
            case DT_RELASZ:
3890
              /* My reading of the SVR4 ABI indicates that the
3891
                 procedure linkage table relocs (DT_JMPREL) should be
3892
                 included in the overall relocs (DT_RELA).  This is
3893
                 what Solaris does.  However, UnixWare can not handle
3894
                 that case.  Therefore, we override the DT_RELASZ entry
3895
                 here to make it not include the JMPREL relocs.  Since
3896
                 the linker script arranges for .rela.plt to follow all
3897
                 other relocation sections, we don't have to worry
3898
                 about changing the DT_RELA entry.  */
3899
              s = bfd_get_section_by_name (output_bfd, ".rela.plt");
3900
              if (s != NULL)
3901
                dyn.d_un.d_val -= s->size;
3902
              bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3903
              break;
3904
            }
3905
        }
3906
 
3907
      /* Fill in the first entry in the procedure linkage table.  */
3908
      splt = bfd_get_section_by_name (dynobj, ".plt");
3909
      if (splt && splt->size > 0)
3910
        {
3911
          if (info->shared)
3912
            {
3913
              if (elf_sh64_pic_plt_entry == NULL)
3914
                {
3915
                  elf_sh64_pic_plt_entry = (bfd_big_endian (output_bfd) ?
3916
                                          elf_sh64_pic_plt_entry_be :
3917
                                          elf_sh64_pic_plt_entry_le);
3918
                }
3919
              memcpy (splt->contents, elf_sh64_pic_plt_entry,
3920
                      elf_sh64_sizeof_plt (info));
3921
            }
3922
          else
3923
            {
3924
              if (elf_sh64_plt0_entry == NULL)
3925
                {
3926
                  elf_sh64_plt0_entry = (bfd_big_endian (output_bfd) ?
3927
                                       elf_sh64_plt0_entry_be :
3928
                                       elf_sh64_plt0_entry_le);
3929
                }
3930
              memcpy (splt->contents, elf_sh64_plt0_entry, PLT_ENTRY_SIZE);
3931
              movi_3shori_putval (output_bfd,
3932
                                  sgot->output_section->vma
3933
                                  + sgot->output_offset,
3934
                                  splt->contents
3935
                                  + elf_sh64_plt0_gotplt_offset (info));
3936
            }
3937
 
3938
          /* UnixWare sets the entsize of .plt to 8, although that doesn't
3939
             really seem like the right value.  */
3940
          elf_section_data (splt->output_section)->this_hdr.sh_entsize = 8;
3941
        }
3942
    }
3943
 
3944
  /* Fill in the first three entries in the global offset table.  */
3945
  if (sgot->size > 0)
3946
    {
3947
      if (sdyn == NULL)
3948
        bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents);
3949
      else
3950
        bfd_put_64 (output_bfd,
3951
                    sdyn->output_section->vma + sdyn->output_offset,
3952
                    sgot->contents);
3953
      bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
3954
      bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + 16);
3955
    }
3956
 
3957
  elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 8;
3958
 
3959
  return TRUE;
3960
}
3961
 
3962
/* Merge non visibility st_other attribute when the symbol comes from
3963
   a dynamic object.  */
3964
static void
3965
sh64_elf64_merge_symbol_attribute (struct elf_link_hash_entry *h,
3966
                                   const Elf_Internal_Sym *isym,
3967
                                   bfd_boolean definition,
3968
                                   bfd_boolean dynamic ATTRIBUTE_UNUSED)
3969
{
3970
  if ((isym->st_other & ~ELF_ST_VISIBILITY (-1)) != 0)
3971
    {
3972
      unsigned char other;
3973
 
3974
      /* Take the balance of OTHER from the definition.  */
3975
      other = (definition ? isym->st_other : h->other);
3976
      other &= ~ ELF_ST_VISIBILITY (-1);
3977
      h->other = other | ELF_ST_VISIBILITY (h->other);
3978
    }
3979
 
3980
  return;
3981
}
3982
 
3983
static const struct bfd_elf_special_section sh64_elf64_special_sections[]=
3984
{
3985
  { STRING_COMMA_LEN (".cranges"), 0, SHT_PROGBITS, 0 },
3986
  { NULL,                       0, 0, 0,            0 }
3987
};
3988
 
3989
#define TARGET_BIG_SYM          bfd_elf64_sh64_vec
3990
#define TARGET_BIG_NAME         "elf64-sh64"
3991
#define TARGET_LITTLE_SYM       bfd_elf64_sh64l_vec
3992
#define TARGET_LITTLE_NAME      "elf64-sh64l"
3993
#define ELF_ARCH                bfd_arch_sh
3994
#define ELF_MACHINE_CODE        EM_SH
3995
#define ELF_MAXPAGESIZE         128
3996
 
3997
#define elf_symbol_leading_char '_'
3998
 
3999
#define bfd_elf64_bfd_reloc_type_lookup sh_elf64_reloc_type_lookup
4000
#define bfd_elf64_bfd_reloc_name_lookup \
4001
                                        sh_elf64_reloc_name_lookup
4002
#define elf_info_to_howto               sh_elf64_info_to_howto
4003
 
4004
/* Note: there's no relaxation at present.  */
4005
 
4006
#define elf_backend_relocate_section    sh_elf64_relocate_section
4007
#define bfd_elf64_bfd_get_relocated_section_contents \
4008
                                        sh_elf64_get_relocated_section_contents
4009
#define elf_backend_object_p            sh_elf64_set_mach_from_flags
4010
#define bfd_elf64_bfd_set_private_flags \
4011
                                        sh_elf64_set_private_flags
4012
#define bfd_elf64_bfd_copy_private_bfd_data \
4013
                                        sh_elf64_copy_private_data
4014
#define bfd_elf64_bfd_merge_private_bfd_data \
4015
                                        sh_elf64_merge_private_data
4016
#define elf_backend_fake_sections       sh64_elf64_fake_sections
4017
 
4018
#define elf_backend_gc_mark_hook        sh_elf64_gc_mark_hook
4019
#define elf_backend_check_relocs        sh_elf64_check_relocs
4020
 
4021
#define elf_backend_can_gc_sections     1
4022
 
4023
#define elf_backend_get_symbol_type     sh64_elf64_get_symbol_type
4024
 
4025
#define elf_backend_add_symbol_hook     sh64_elf64_add_symbol_hook
4026
 
4027
#define elf_backend_link_output_symbol_hook \
4028
        sh64_elf64_link_output_symbol_hook
4029
 
4030
#define elf_backend_merge_symbol_attribute \
4031
        sh64_elf64_merge_symbol_attribute
4032
 
4033
#define elf_backend_final_write_processing \
4034
        sh64_elf64_final_write_processing
4035
 
4036
#define elf_backend_create_dynamic_sections \
4037
                                        sh64_elf64_create_dynamic_sections
4038
#define bfd_elf64_bfd_link_hash_table_create \
4039
                                        sh64_elf64_link_hash_table_create
4040
#define elf_backend_adjust_dynamic_symbol \
4041
                                        sh64_elf64_adjust_dynamic_symbol
4042
#define elf_backend_size_dynamic_sections \
4043
                                        sh64_elf64_size_dynamic_sections
4044
#define elf_backend_omit_section_dynsym \
4045
  ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
4046
#define elf_backend_finish_dynamic_symbol \
4047
                                        sh64_elf64_finish_dynamic_symbol
4048
#define elf_backend_finish_dynamic_sections \
4049
                                        sh64_elf64_finish_dynamic_sections
4050
#define elf_backend_special_sections    sh64_elf64_special_sections
4051
 
4052
#define elf_backend_want_got_plt        1
4053
#define elf_backend_plt_readonly        1
4054
#define elf_backend_want_plt_sym        0
4055
#define elf_backend_got_header_size     24
4056
 
4057
#include "elf64-target.h"
4058
 
4059
/* NetBSD support.  */
4060
#undef  TARGET_BIG_SYM
4061
#define TARGET_BIG_SYM                  bfd_elf64_sh64nbsd_vec
4062
#undef  TARGET_BIG_NAME
4063
#define TARGET_BIG_NAME                 "elf64-sh64-nbsd"
4064
#undef  TARGET_LITTLE_SYM
4065
#define TARGET_LITTLE_SYM               bfd_elf64_sh64lnbsd_vec
4066
#undef  TARGET_LITTLE_NAME
4067
#define TARGET_LITTLE_NAME              "elf64-sh64l-nbsd"
4068
#undef  ELF_MAXPAGESIZE
4069
#define ELF_MAXPAGESIZE                 0x10000
4070
#undef  elf_symbol_leading_char
4071
#define elf_symbol_leading_char         0
4072
 
4073
#define elf64_bed                       elf64_sh64_nbsd_bed
4074
 
4075
#include "elf64-target.h"
4076
 
4077
/* Linux support.  */
4078
#undef  TARGET_BIG_SYM
4079
#define TARGET_BIG_SYM                  bfd_elf64_sh64blin_vec
4080
#undef  TARGET_BIG_NAME
4081
#define TARGET_BIG_NAME                 "elf64-sh64big-linux"
4082
#undef  TARGET_LITTLE_SYM
4083
#define TARGET_LITTLE_SYM               bfd_elf64_sh64lin_vec
4084
#undef  TARGET_LITTLE_NAME
4085
#define TARGET_LITTLE_NAME              "elf64-sh64-linux"
4086
#undef elf64_bed
4087
#define elf64_bed                       elf64_sh64_linux_bed
4088
 
4089
#include "elf64-target.h"

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.