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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [bfd/] [elf64-sh64.c] - Blame information for rev 225

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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