Coverage Report

Created: 2024-05-21 06:29

/src/binutils-gdb/bfd/elf32-nios2.c
Line
Count
Source (jump to first uncovered line)
1
/* 32-bit ELF support for Nios II.
2
   Copyright (C) 2012-2024 Free Software Foundation, Inc.
3
   Contributed by Nigel Gray (ngray@altera.com).
4
   Contributed by Mentor Graphics, Inc.
5
6
   This file is part of BFD, the Binary File Descriptor library.
7
8
   This program is free software; you can redistribute it and/or modify
9
   it under the terms of the GNU General Public License as published by
10
   the Free Software Foundation; either version 3 of the License, or
11
   (at your option) any later version.
12
13
   This program is distributed in the hope that it will be useful,
14
   but WITHOUT ANY WARRANTY; without even the implied warranty of
15
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
   GNU General Public License for more details.
17
18
   You should have received a copy of the GNU General Public License
19
   along with this program; if not, write to the Free Software
20
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21
   MA 02110-1301, USA.  */
22
23
/* This file handles Altera Nios II ELF targets.  */
24
25
#include "sysdep.h"
26
#include "bfd.h"
27
#include "libbfd.h"
28
#include "bfdlink.h"
29
#include "genlink.h"
30
#include "elf-bfd.h"
31
#include "elf/nios2.h"
32
#include "opcode/nios2.h"
33
#include "elf32-nios2.h"
34
#include "libiberty.h"
35
36
/* Use RELA relocations.  */
37
#ifndef USE_RELA
38
#define USE_RELA
39
#endif
40
41
#ifdef USE_REL
42
#undef USE_REL
43
#endif
44
45
/* Forward declarations.  */
46
static bfd_reloc_status_type nios2_elf32_ignore_reloc
47
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
48
static bfd_reloc_status_type nios2_elf32_hi16_relocate
49
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
50
static bfd_reloc_status_type nios2_elf32_lo16_relocate
51
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
52
static bfd_reloc_status_type nios2_elf32_hiadj16_relocate
53
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
54
static bfd_reloc_status_type nios2_elf32_pcrel_lo16_relocate
55
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
56
static bfd_reloc_status_type nios2_elf32_pcrel_hiadj16_relocate
57
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
58
static bfd_reloc_status_type nios2_elf32_pcrel16_relocate
59
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
60
static bfd_reloc_status_type nios2_elf32_call26_relocate
61
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
62
static bfd_reloc_status_type nios2_elf32_gprel_relocate
63
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
64
static bfd_reloc_status_type nios2_elf32_ujmp_relocate
65
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
66
static bfd_reloc_status_type nios2_elf32_cjmp_relocate
67
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
68
static bfd_reloc_status_type nios2_elf32_callr_relocate
69
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
70
71
/* Target vector.  */
72
extern const bfd_target nios2_elf32_le_vec;
73
extern const bfd_target nios2_elf32_be_vec;
74
75
/* Offset of tp and dtp pointers from start of TLS block.  */
76
0
#define TP_OFFSET 0x7000
77
0
#define DTP_OFFSET  0x8000
78
79
/* The relocation tables used for SHT_REL sections.  There are separate
80
   tables for R1 and R2 encodings.  */
81
static reloc_howto_type elf_nios2_r1_howto_table_rel[] = {
82
  /* No relocation.  */
83
  HOWTO (R_NIOS2_NONE,    /* type */
84
   0,     /* rightshift */
85
   0,     /* size */
86
   0,     /* bitsize */
87
   false,     /* pc_relative */
88
   0,     /* bitpos */
89
   complain_overflow_dont,  /* complain_on_overflow */
90
   bfd_elf_generic_reloc, /* special_function */
91
   "R_NIOS2_NONE",  /* name */
92
   false,     /* partial_inplace */
93
   0,     /* src_mask */
94
   0,     /* dst_mask */
95
   false),    /* pcrel_offset */
96
97
  /* 16-bit signed immediate relocation.  */
98
  HOWTO (R_NIOS2_S16,   /* type */
99
   0,     /* rightshift */
100
   4,     /* size */
101
   16,      /* bitsize */
102
   false,     /* pc_relative */
103
   6,     /* bitpos */
104
   complain_overflow_signed,  /* complain on overflow */
105
   bfd_elf_generic_reloc, /* special function */
106
   "R_NIOS2_S16",   /* name */
107
   false,     /* partial_inplace */
108
   0x003fffc0,    /* src_mask */
109
   0x003fffc0,    /* dest_mask */
110
   false),    /* pcrel_offset */
111
112
  /* 16-bit unsigned immediate relocation.  */
113
  HOWTO (R_NIOS2_U16,   /* type */
114
   0,     /* rightshift */
115
   4,     /* size */
116
   16,      /* bitsize */
117
   false,     /* pc_relative */
118
   6,     /* bitpos */
119
   complain_overflow_unsigned,  /* complain on overflow */
120
   bfd_elf_generic_reloc, /* special function */
121
   "R_NIOS2_U16",   /* name */
122
   false,     /* partial_inplace */
123
   0x003fffc0,    /* src_mask */
124
   0x003fffc0,    /* dest_mask */
125
   false),    /* pcrel_offset */
126
127
  HOWTO (R_NIOS2_PCREL16, /* type */
128
   0,     /* rightshift */
129
   4,     /* size */
130
   16,      /* bitsize */
131
   true,      /* pc_relative */
132
   6,     /* bitpos */
133
   complain_overflow_signed,  /* complain on overflow */
134
   nios2_elf32_pcrel16_relocate,  /* special function */
135
   "R_NIOS2_PCREL16", /* name */
136
   false,     /* partial_inplace */
137
   0x003fffc0,    /* src_mask */
138
   0x003fffc0,    /* dest_mask */
139
   true),     /* pcrel_offset */
140
141
  HOWTO (R_NIOS2_CALL26,  /* type */
142
   2,     /* rightshift */
143
   4,     /* size */
144
   26,      /* bitsize */
145
   false,     /* pc_relative */
146
   6,     /* bitpos */
147
   complain_overflow_dont,  /* complain on overflow */
148
   nios2_elf32_call26_relocate, /* special function */
149
   "R_NIOS2_CALL26",  /* name */
150
   false,     /* partial_inplace */
151
   0xffffffc0,    /* src_mask */
152
   0xffffffc0,    /* dst_mask */
153
   false),    /* pcrel_offset */
154
155
  HOWTO (R_NIOS2_IMM5,
156
   0,
157
   4,
158
   5,
159
   false,
160
   6,
161
   complain_overflow_bitfield,
162
   bfd_elf_generic_reloc,
163
   "R_NIOS2_IMM5",
164
   false,
165
   0x000007c0,
166
   0x000007c0,
167
   false),
168
169
  HOWTO (R_NIOS2_CACHE_OPX,
170
   0,
171
   4,
172
   5,
173
   false,
174
   22,
175
   complain_overflow_bitfield,
176
   bfd_elf_generic_reloc,
177
   "R_NIOS2_CACHE_OPX",
178
   false,
179
   0x07c00000,
180
   0x07c00000,
181
   false),
182
183
  HOWTO (R_NIOS2_IMM6,
184
   0,
185
   4,
186
   6,
187
   false,
188
   6,
189
   complain_overflow_bitfield,
190
   bfd_elf_generic_reloc,
191
   "R_NIOS2_IMM6",
192
   false,
193
   0x00000fc0,
194
   0x00000fc0,
195
   false),
196
197
  HOWTO (R_NIOS2_IMM8,
198
   0,
199
   4,
200
   8,
201
   false,
202
   6,
203
   complain_overflow_bitfield,
204
   bfd_elf_generic_reloc,
205
   "R_NIOS2_IMM8",
206
   false,
207
   0x00003fc0,
208
   0x00003fc0,
209
   false),
210
211
  HOWTO (R_NIOS2_HI16,
212
   0,
213
   4,
214
   32,
215
   false,
216
   6,
217
   complain_overflow_dont,
218
   nios2_elf32_hi16_relocate,
219
   "R_NIOS2_HI16",
220
   false,
221
   0x003fffc0,
222
   0x003fffc0,
223
   false),
224
225
  HOWTO (R_NIOS2_LO16,
226
   0,
227
   4,
228
   32,
229
   false,
230
   6,
231
   complain_overflow_dont,
232
   nios2_elf32_lo16_relocate,
233
   "R_NIOS2_LO16",
234
   false,
235
   0x003fffc0,
236
   0x003fffc0,
237
   false),
238
239
  HOWTO (R_NIOS2_HIADJ16,
240
   0,
241
   4,
242
   32,
243
   false,
244
   6,
245
   complain_overflow_dont,
246
   nios2_elf32_hiadj16_relocate,
247
   "R_NIOS2_HIADJ16",
248
   false,
249
   0x003fffc0,
250
   0x003fffc0,
251
   false),
252
253
  HOWTO (R_NIOS2_BFD_RELOC_32,
254
   0,
255
   4,     /* long */
256
   32,
257
   false,
258
   0,
259
   complain_overflow_dont,
260
   bfd_elf_generic_reloc,
261
   "R_NIOS2_BFD_RELOC32",
262
   false,
263
   0xffffffff,
264
   0xffffffff,
265
   false),
266
267
  HOWTO (R_NIOS2_BFD_RELOC_16,
268
   0,
269
   2,     /* short */
270
   16,
271
   false,
272
   0,
273
   complain_overflow_bitfield,
274
   bfd_elf_generic_reloc,
275
   "R_NIOS2_BFD_RELOC16",
276
   false,
277
   0x0000ffff,
278
   0x0000ffff,
279
   false),
280
281
  HOWTO (R_NIOS2_BFD_RELOC_8,
282
   0,
283
   1,     /* byte */
284
   8,
285
   false,
286
   0,
287
   complain_overflow_bitfield,
288
   bfd_elf_generic_reloc,
289
   "R_NIOS2_BFD_RELOC8",
290
   false,
291
   0x000000ff,
292
   0x000000ff,
293
   false),
294
295
  HOWTO (R_NIOS2_GPREL,
296
   0,
297
   4,
298
   32,
299
   false,
300
   6,
301
   complain_overflow_dont,
302
   nios2_elf32_gprel_relocate,
303
   "R_NIOS2_GPREL",
304
   false,
305
   0x003fffc0,
306
   0x003fffc0,
307
   false),
308
309
  HOWTO (R_NIOS2_GNU_VTINHERIT,
310
   0,
311
   4,
312
   0,
313
   false,
314
   0,
315
   complain_overflow_dont,
316
   NULL,
317
   "R_NIOS2_GNU_VTINHERIT",
318
   false,
319
   0,
320
   0,
321
   false),
322
323
  HOWTO (R_NIOS2_GNU_VTENTRY,
324
   0,
325
   4,
326
   0,
327
   false,
328
   0,
329
   complain_overflow_dont,
330
   _bfd_elf_rel_vtable_reloc_fn,
331
   "R_NIOS2_GNU_VTENTRY",
332
   false,
333
   0,
334
   0,
335
   false),
336
337
  HOWTO (R_NIOS2_UJMP,
338
   0,
339
   4,
340
   32,
341
   false,
342
   6,
343
   complain_overflow_dont,
344
   nios2_elf32_ujmp_relocate,
345
   "R_NIOS2_UJMP",
346
   false,
347
   0x003fffc0,
348
   0x003fffc0,
349
   false),
350
351
  HOWTO (R_NIOS2_CJMP,
352
   0,
353
   4,
354
   32,
355
   false,
356
   6,
357
   complain_overflow_dont,
358
   nios2_elf32_cjmp_relocate,
359
   "R_NIOS2_CJMP",
360
   false,
361
   0x003fffc0,
362
   0x003fffc0,
363
   false),
364
365
  HOWTO (R_NIOS2_CALLR,
366
   0,
367
   4,
368
   32,
369
   false,
370
   6,
371
   complain_overflow_dont,
372
   nios2_elf32_callr_relocate,
373
   "R_NIOS2_CALLR",
374
   false,
375
   0x003fffc0,
376
   0x003fffc0,
377
   false),
378
379
  HOWTO (R_NIOS2_ALIGN,
380
   0,
381
   4,
382
   0,
383
   false,
384
   0,
385
   complain_overflow_dont,
386
   nios2_elf32_ignore_reloc,
387
   "R_NIOS2_ALIGN",
388
   false,
389
   0,
390
   0,
391
   true),
392
393
394
  HOWTO (R_NIOS2_GOT16,
395
   0,
396
   4,
397
   16,
398
   false,
399
   6,
400
   complain_overflow_bitfield,
401
   bfd_elf_generic_reloc,
402
   "R_NIOS2_GOT16",
403
   false,
404
   0x003fffc0,
405
   0x003fffc0,
406
   false),
407
408
  HOWTO (R_NIOS2_CALL16,
409
   0,
410
   4,
411
   16,
412
   false,
413
   6,
414
   complain_overflow_bitfield,
415
   bfd_elf_generic_reloc,
416
   "R_NIOS2_CALL16",
417
   false,
418
   0x003fffc0,
419
   0x003fffc0,
420
   false),
421
422
  HOWTO (R_NIOS2_GOTOFF_LO,
423
   0,
424
   4,
425
   16,
426
   false,
427
   6,
428
   complain_overflow_dont,
429
   bfd_elf_generic_reloc,
430
   "R_NIOS2_GOTOFF_LO",
431
   false,
432
   0x003fffc0,
433
   0x003fffc0,
434
   false),
435
436
  HOWTO (R_NIOS2_GOTOFF_HA,
437
   0,
438
   4,
439
   16,
440
   false,
441
   6,
442
   complain_overflow_dont,
443
   bfd_elf_generic_reloc,
444
   "R_NIOS2_GOTOFF_HA",
445
   false,
446
   0x003fffc0,
447
   0x003fffc0,
448
   false),
449
450
  HOWTO (R_NIOS2_PCREL_LO,
451
   0,
452
   4,
453
   16,
454
   true,
455
   6,
456
   complain_overflow_dont,
457
   nios2_elf32_pcrel_lo16_relocate,
458
   "R_NIOS2_PCREL_LO",
459
   false,
460
   0x003fffc0,
461
   0x003fffc0,
462
   true),
463
464
  HOWTO (R_NIOS2_PCREL_HA,
465
   0,
466
   4,
467
   16,
468
   false, /* This is a PC-relative relocation, but we need to subtract
469
       PC ourselves before the HIADJ.  */
470
   6,
471
   complain_overflow_dont,
472
   nios2_elf32_pcrel_hiadj16_relocate,
473
   "R_NIOS2_PCREL_HA",
474
   false,
475
   0x003fffc0,
476
   0x003fffc0,
477
   true),
478
479
  HOWTO (R_NIOS2_TLS_GD16,
480
   0,
481
   4,
482
   16,
483
   false,
484
   6,
485
   complain_overflow_bitfield,
486
   bfd_elf_generic_reloc,
487
   "R_NIOS2_TLS_GD16",
488
   false,
489
   0x003fffc0,
490
   0x003fffc0,
491
   false),
492
493
  HOWTO (R_NIOS2_TLS_LDM16,
494
   0,
495
   4,
496
   16,
497
   false,
498
   6,
499
   complain_overflow_bitfield,
500
   bfd_elf_generic_reloc,
501
   "R_NIOS2_TLS_LDM16",
502
   false,
503
   0x003fffc0,
504
   0x003fffc0,
505
   false),
506
507
  HOWTO (R_NIOS2_TLS_LDO16,
508
   0,
509
   4,
510
   16,
511
   false,
512
   6,
513
   complain_overflow_bitfield,
514
   bfd_elf_generic_reloc,
515
   "R_NIOS2_TLS_LDO16",
516
   false,
517
   0x003fffc0,
518
   0x003fffc0,
519
   false),
520
521
  HOWTO (R_NIOS2_TLS_IE16,
522
   0,
523
   4,
524
   16,
525
   false,
526
   6,
527
   complain_overflow_bitfield,
528
   bfd_elf_generic_reloc,
529
   "R_NIOS2_TLS_IE16",
530
   false,
531
   0x003fffc0,
532
   0x003fffc0,
533
   false),
534
535
  HOWTO (R_NIOS2_TLS_LE16,
536
   0,
537
   4,
538
   16,
539
   false,
540
   6,
541
   complain_overflow_bitfield,
542
   bfd_elf_generic_reloc,
543
   "R_NIOS2_TLS_LE16",
544
   false,
545
   0x003fffc0,
546
   0x003fffc0,
547
   false),
548
549
  HOWTO (R_NIOS2_TLS_DTPMOD,
550
   0,
551
   4,
552
   32,
553
   false,
554
   0,
555
   complain_overflow_dont,
556
   bfd_elf_generic_reloc,
557
   "R_NIOS2_TLS_DTPMOD",
558
   false,
559
   0xffffffff,
560
   0xffffffff,
561
   false),
562
563
  HOWTO (R_NIOS2_TLS_DTPREL,
564
   0,
565
   4,
566
   32,
567
   false,
568
   0,
569
   complain_overflow_dont,
570
   bfd_elf_generic_reloc,
571
   "R_NIOS2_TLS_DTPREL",
572
   false,
573
   0xffffffff,
574
   0xffffffff,
575
   false),
576
577
  HOWTO (R_NIOS2_TLS_TPREL,
578
   0,
579
   4,
580
   32,
581
   false,
582
   0,
583
   complain_overflow_dont,
584
   bfd_elf_generic_reloc,
585
   "R_NIOS2_TLS_TPREL",
586
   false,
587
   0xffffffff,
588
   0xffffffff,
589
   false),
590
591
  HOWTO (R_NIOS2_COPY,
592
   0,
593
   4,
594
   32,
595
   false,
596
   0,
597
   complain_overflow_dont,
598
   bfd_elf_generic_reloc,
599
   "R_NIOS2_COPY",
600
   false,
601
   0,
602
   0,
603
   false),
604
605
  HOWTO (R_NIOS2_GLOB_DAT,
606
   0,
607
   4,
608
   32,
609
   false,
610
   0,
611
   complain_overflow_dont,
612
   bfd_elf_generic_reloc,
613
   "R_NIOS2_GLOB_DAT",
614
   false,
615
   0xffffffff,
616
   0xffffffff,
617
   false),
618
619
  HOWTO (R_NIOS2_JUMP_SLOT,
620
   0,
621
   4,
622
   32,
623
   false,
624
   0,
625
   complain_overflow_dont,
626
   bfd_elf_generic_reloc,
627
   "R_NIOS2_JUMP_SLOT",
628
   false,
629
   0xffffffff,
630
   0xffffffff,
631
   false),
632
633
  HOWTO (R_NIOS2_RELATIVE,
634
   0,
635
   4,
636
   32,
637
   false,
638
   0,
639
   complain_overflow_dont,
640
   bfd_elf_generic_reloc,
641
   "R_NIOS2_RELATIVE",
642
   false,
643
   0xffffffff,
644
   0xffffffff,
645
   false),
646
647
  HOWTO (R_NIOS2_GOTOFF,
648
   0,
649
   4,
650
   32,
651
   false,
652
   0,
653
   complain_overflow_dont,
654
   bfd_elf_generic_reloc,
655
   "R_NIOS2_GOTOFF",
656
   false,
657
   0xffffffff,
658
   0xffffffff,
659
   false),
660
661
  HOWTO (R_NIOS2_CALL26_NOAT, /* type */
662
   2,     /* rightshift */
663
   4,     /* size */
664
   26,      /* bitsize */
665
   false,     /* pc_relative */
666
   6,     /* bitpos */
667
   complain_overflow_dont,  /* complain on overflow */
668
   nios2_elf32_call26_relocate, /* special function */
669
   "R_NIOS2_CALL26_NOAT", /* name */
670
   false,     /* partial_inplace */
671
   0xffffffc0,    /* src_mask */
672
   0xffffffc0,    /* dst_mask */
673
   false),    /* pcrel_offset */
674
675
  HOWTO (R_NIOS2_GOT_LO,
676
   0,
677
   4,
678
   16,
679
   false,
680
   6,
681
   complain_overflow_dont,
682
   bfd_elf_generic_reloc,
683
   "R_NIOS2_GOT_LO",
684
   false,
685
   0x003fffc0,
686
   0x003fffc0,
687
   false),
688
689
  HOWTO (R_NIOS2_GOT_HA,
690
   0,
691
   4,
692
   16,
693
   false,
694
   6,
695
   complain_overflow_dont,
696
   bfd_elf_generic_reloc,
697
   "R_NIOS2_GOT_HA",
698
   false,
699
   0x003fffc0,
700
   0x003fffc0,
701
   false),
702
703
  HOWTO (R_NIOS2_CALL_LO,
704
   0,
705
   4,
706
   16,
707
   false,
708
   6,
709
   complain_overflow_dont,
710
   bfd_elf_generic_reloc,
711
   "R_NIOS2_CALL_LO",
712
   false,
713
   0x003fffc0,
714
   0x003fffc0,
715
   false),
716
717
  HOWTO (R_NIOS2_CALL_HA,
718
   0,
719
   4,
720
   16,
721
   false,
722
   6,
723
   complain_overflow_dont,
724
   bfd_elf_generic_reloc,
725
   "R_NIOS2_CALL_HA",
726
   false,
727
   0x003fffc0,
728
   0x003fffc0,
729
   false),
730
731
/* Add other relocations here.  */
732
};
733
734
static reloc_howto_type elf_nios2_r2_howto_table_rel[] = {
735
  /* No relocation.  */
736
  HOWTO (R_NIOS2_NONE,    /* type */
737
   0,     /* rightshift */
738
   0,     /* size */
739
   0,     /* bitsize */
740
   false,     /* pc_relative */
741
   0,     /* bitpos */
742
   complain_overflow_dont,  /* complain_on_overflow */
743
   bfd_elf_generic_reloc, /* special_function */
744
   "R_NIOS2_NONE",  /* name */
745
   false,     /* partial_inplace */
746
   0,     /* src_mask */
747
   0,     /* dst_mask */
748
   false),    /* pcrel_offset */
749
750
  /* 16-bit signed immediate relocation.  */
751
  HOWTO (R_NIOS2_S16,   /* type */
752
   0,     /* rightshift */
753
   4,     /* size */
754
   16,      /* bitsize */
755
   false,     /* pc_relative */
756
   16,      /* bitpos */
757
   complain_overflow_signed,  /* complain on overflow */
758
   bfd_elf_generic_reloc, /* special function */
759
   "R_NIOS2_S16",   /* name */
760
   false,     /* partial_inplace */
761
   0xffff0000,    /* src_mask */
762
   0xffff0000,    /* dest_mask */
763
   false),    /* pcrel_offset */
764
765
  /* 16-bit unsigned immediate relocation.  */
766
  HOWTO (R_NIOS2_U16,   /* type */
767
   0,     /* rightshift */
768
   4,     /* size */
769
   16,      /* bitsize */
770
   false,     /* pc_relative */
771
   16,      /* bitpos */
772
   complain_overflow_unsigned,  /* complain on overflow */
773
   bfd_elf_generic_reloc, /* special function */
774
   "R_NIOS2_U16",   /* name */
775
   false,     /* partial_inplace */
776
   0xffff0000,    /* src_mask */
777
   0xffff0000,    /* dest_mask */
778
   false),    /* pcrel_offset */
779
780
  HOWTO (R_NIOS2_PCREL16, /* type */
781
   0,     /* rightshift */
782
   4,     /* size */
783
   16,      /* bitsize */
784
   true,      /* pc_relative */
785
   16,      /* bitpos */
786
   complain_overflow_signed,  /* complain on overflow */
787
   nios2_elf32_pcrel16_relocate,  /* special function */
788
   "R_NIOS2_PCREL16", /* name */
789
   false,     /* partial_inplace */
790
   0xffff0000,    /* src_mask */
791
   0xffff0000,    /* dest_mask */
792
   true),     /* pcrel_offset */
793
794
  HOWTO (R_NIOS2_CALL26,  /* type */
795
   2,     /* rightshift */
796
   4,     /* size */
797
   26,      /* bitsize */
798
   false,     /* pc_relative */
799
   6,     /* bitpos */
800
   complain_overflow_dont,  /* complain on overflow */
801
   nios2_elf32_call26_relocate, /* special function */
802
   "R_NIOS2_CALL26",  /* name */
803
   false,     /* partial_inplace */
804
   0xffffffc0,    /* src_mask */
805
   0xffffffc0,    /* dst_mask */
806
   false),    /* pcrel_offset */
807
808
  HOWTO (R_NIOS2_IMM5,
809
   0,
810
   4,
811
   5,
812
   false,
813
   21,
814
   complain_overflow_bitfield,
815
   bfd_elf_generic_reloc,
816
   "R_NIOS2_IMM5",
817
   false,
818
   0x03e00000,
819
   0x03e00000,
820
   false),
821
822
  HOWTO (R_NIOS2_CACHE_OPX,
823
   0,
824
   4,
825
   5,
826
   false,
827
   11,
828
   complain_overflow_bitfield,
829
   bfd_elf_generic_reloc,
830
   "R_NIOS2_CACHE_OPX",
831
   false,
832
   0x0000f800,
833
   0x0000f800,
834
   false),
835
836
  HOWTO (R_NIOS2_IMM6,
837
   0,
838
   4,
839
   6,
840
   false,
841
   26,
842
   complain_overflow_bitfield,
843
   bfd_elf_generic_reloc,
844
   "R_NIOS2_IMM6",
845
   false,
846
   0xfc000000,
847
   0xfc000000,
848
   false),
849
850
  HOWTO (R_NIOS2_IMM8,
851
   0,
852
   4,
853
   8,
854
   false,
855
   24,
856
   complain_overflow_bitfield,
857
   bfd_elf_generic_reloc,
858
   "R_NIOS2_IMM8",
859
   false,
860
   0xff000000,
861
   0xff000000,
862
   false),
863
864
  HOWTO (R_NIOS2_HI16,
865
   0,
866
   4,
867
   32,
868
   false,
869
   16,
870
   complain_overflow_dont,
871
   nios2_elf32_hi16_relocate,
872
   "R_NIOS2_HI16",
873
   false,
874
   0xffff0000,
875
   0xffff0000,
876
   false),
877
878
  HOWTO (R_NIOS2_LO16,
879
   0,
880
   4,
881
   32,
882
   false,
883
   16,
884
   complain_overflow_dont,
885
   nios2_elf32_lo16_relocate,
886
   "R_NIOS2_LO16",
887
   false,
888
   0xffff0000,
889
   0xffff0000,
890
   false),
891
892
  HOWTO (R_NIOS2_HIADJ16,
893
   0,
894
   4,
895
   32,
896
   false,
897
   16,
898
   complain_overflow_dont,
899
   nios2_elf32_hiadj16_relocate,
900
   "R_NIOS2_HIADJ16",
901
   false,
902
   0xffff0000,
903
   0xffff0000,
904
   false),
905
906
  HOWTO (R_NIOS2_BFD_RELOC_32,
907
   0,
908
   4,     /* long */
909
   32,
910
   false,
911
   0,
912
   complain_overflow_dont,
913
   bfd_elf_generic_reloc,
914
   "R_NIOS2_BFD_RELOC32",
915
   false,
916
   0xffffffff,
917
   0xffffffff,
918
   false),
919
920
  HOWTO (R_NIOS2_BFD_RELOC_16,
921
   0,
922
   2,     /* short */
923
   16,
924
   false,
925
   0,
926
   complain_overflow_bitfield,
927
   bfd_elf_generic_reloc,
928
   "R_NIOS2_BFD_RELOC16",
929
   false,
930
   0x0000ffff,
931
   0x0000ffff,
932
   false),
933
934
  HOWTO (R_NIOS2_BFD_RELOC_8,
935
   0,
936
   1,     /* byte */
937
   8,
938
   false,
939
   0,
940
   complain_overflow_bitfield,
941
   bfd_elf_generic_reloc,
942
   "R_NIOS2_BFD_RELOC8",
943
   false,
944
   0x000000ff,
945
   0x000000ff,
946
   false),
947
948
  HOWTO (R_NIOS2_GPREL,
949
   0,
950
   4,
951
   32,
952
   false,
953
   16,
954
   complain_overflow_dont,
955
   nios2_elf32_gprel_relocate,
956
   "R_NIOS2_GPREL",
957
   false,
958
   0xffff0000,
959
   0xffff0000,
960
   false),
961
962
  HOWTO (R_NIOS2_GNU_VTINHERIT,
963
   0,
964
   4,
965
   0,
966
   false,
967
   0,
968
   complain_overflow_dont,
969
   NULL,
970
   "R_NIOS2_GNU_VTINHERIT",
971
   false,
972
   0,
973
   0,
974
   false),
975
976
  HOWTO (R_NIOS2_GNU_VTENTRY,
977
   0,
978
   4,
979
   0,
980
   false,
981
   0,
982
   complain_overflow_dont,
983
   _bfd_elf_rel_vtable_reloc_fn,
984
   "R_NIOS2_GNU_VTENTRY",
985
   false,
986
   0,
987
   0,
988
   false),
989
990
  HOWTO (R_NIOS2_UJMP,
991
   0,
992
   4,
993
   32,
994
   false,
995
   16,
996
   complain_overflow_dont,
997
   nios2_elf32_ujmp_relocate,
998
   "R_NIOS2_UJMP",
999
   false,
1000
   0xffff0000,
1001
   0xffff0000,
1002
   false),
1003
1004
  HOWTO (R_NIOS2_CJMP,
1005
   0,
1006
   4,
1007
   32,
1008
   false,
1009
   16,
1010
   complain_overflow_dont,
1011
   nios2_elf32_cjmp_relocate,
1012
   "R_NIOS2_CJMP",
1013
   false,
1014
   0xffff0000,
1015
   0xffff0000,
1016
   false),
1017
1018
  HOWTO (R_NIOS2_CALLR,
1019
   0,
1020
   4,
1021
   32,
1022
   false,
1023
   16,
1024
   complain_overflow_dont,
1025
   nios2_elf32_callr_relocate,
1026
   "R_NIOS2_CALLR",
1027
   false,
1028
   0xffff0000,
1029
   0xffff0000,
1030
   false),
1031
1032
  HOWTO (R_NIOS2_ALIGN,
1033
   0,
1034
   4,
1035
   0,
1036
   false,
1037
   0,
1038
   complain_overflow_dont,
1039
   nios2_elf32_ignore_reloc,
1040
   "R_NIOS2_ALIGN",
1041
   false,
1042
   0,
1043
   0,
1044
   true),
1045
1046
  HOWTO (R_NIOS2_GOT16,
1047
   0,
1048
   4,
1049
   16,
1050
   false,
1051
   16,
1052
   complain_overflow_bitfield,
1053
   bfd_elf_generic_reloc,
1054
   "R_NIOS2_GOT16",
1055
   false,
1056
   0xffff0000,
1057
   0xffff0000,
1058
   false),
1059
1060
  HOWTO (R_NIOS2_CALL16,
1061
   0,
1062
   4,
1063
   16,
1064
   false,
1065
   16,
1066
   complain_overflow_bitfield,
1067
   bfd_elf_generic_reloc,
1068
   "R_NIOS2_CALL16",
1069
   false,
1070
   0xffff0000,
1071
   0xffff0000,
1072
   false),
1073
1074
  HOWTO (R_NIOS2_GOTOFF_LO,
1075
   0,
1076
   4,
1077
   16,
1078
   false,
1079
   16,
1080
   complain_overflow_dont,
1081
   bfd_elf_generic_reloc,
1082
   "R_NIOS2_GOTOFF_LO",
1083
   false,
1084
   0xffff0000,
1085
   0xffff0000,
1086
   false),
1087
1088
  HOWTO (R_NIOS2_GOTOFF_HA,
1089
   0,
1090
   4,
1091
   16,
1092
   false,
1093
   16,
1094
   complain_overflow_dont,
1095
   bfd_elf_generic_reloc,
1096
   "R_NIOS2_GOTOFF_HA",
1097
   false,
1098
   0xffff0000,
1099
   0xffff0000,
1100
   false),
1101
1102
  HOWTO (R_NIOS2_PCREL_LO,
1103
   0,
1104
   4,
1105
   16,
1106
   true,
1107
   16,
1108
   complain_overflow_dont,
1109
   nios2_elf32_pcrel_lo16_relocate,
1110
   "R_NIOS2_PCREL_LO",
1111
   false,
1112
   0xffff0000,
1113
   0xffff0000,
1114
   true),
1115
1116
  HOWTO (R_NIOS2_PCREL_HA,
1117
   0,
1118
   4,
1119
   16,
1120
   false, /* This is a PC-relative relocation, but we need to subtract
1121
       PC ourselves before the HIADJ.  */
1122
   16,
1123
   complain_overflow_dont,
1124
   nios2_elf32_pcrel_hiadj16_relocate,
1125
   "R_NIOS2_PCREL_HA",
1126
   false,
1127
   0xffff0000,
1128
   0xffff0000,
1129
   true),
1130
1131
  HOWTO (R_NIOS2_TLS_GD16,
1132
   0,
1133
   4,
1134
   16,
1135
   false,
1136
   16,
1137
   complain_overflow_bitfield,
1138
   bfd_elf_generic_reloc,
1139
   "R_NIOS2_TLS_GD16",
1140
   false,
1141
   0xffff0000,
1142
   0xffff0000,
1143
   false),
1144
1145
  HOWTO (R_NIOS2_TLS_LDM16,
1146
   0,
1147
   4,
1148
   16,
1149
   false,
1150
   16,
1151
   complain_overflow_bitfield,
1152
   bfd_elf_generic_reloc,
1153
   "R_NIOS2_TLS_LDM16",
1154
   false,
1155
   0xffff0000,
1156
   0xffff0000,
1157
   false),
1158
1159
  HOWTO (R_NIOS2_TLS_LDO16,
1160
   0,
1161
   4,
1162
   16,
1163
   false,
1164
   16,
1165
   complain_overflow_bitfield,
1166
   bfd_elf_generic_reloc,
1167
   "R_NIOS2_TLS_LDO16",
1168
   false,
1169
   0xffff0000,
1170
   0xffff0000,
1171
   false),
1172
1173
  HOWTO (R_NIOS2_TLS_IE16,
1174
   0,
1175
   4,
1176
   16,
1177
   false,
1178
   16,
1179
   complain_overflow_bitfield,
1180
   bfd_elf_generic_reloc,
1181
   "R_NIOS2_TLS_IE16",
1182
   false,
1183
   0xffff0000,
1184
   0xffff0000,
1185
   false),
1186
1187
  HOWTO (R_NIOS2_TLS_LE16,
1188
   0,
1189
   4,
1190
   16,
1191
   false,
1192
   16,
1193
   complain_overflow_bitfield,
1194
   bfd_elf_generic_reloc,
1195
   "R_NIOS2_TLS_LE16",
1196
   false,
1197
   0xffff0000,
1198
   0xffff0000,
1199
   false),
1200
1201
  HOWTO (R_NIOS2_TLS_DTPMOD,
1202
   0,
1203
   4,
1204
   32,
1205
   false,
1206
   0,
1207
   complain_overflow_dont,
1208
   bfd_elf_generic_reloc,
1209
   "R_NIOS2_TLS_DTPMOD",
1210
   false,
1211
   0xffffffff,
1212
   0xffffffff,
1213
   false),
1214
1215
  HOWTO (R_NIOS2_TLS_DTPREL,
1216
   0,
1217
   4,
1218
   32,
1219
   false,
1220
   0,
1221
   complain_overflow_dont,
1222
   bfd_elf_generic_reloc,
1223
   "R_NIOS2_TLS_DTPREL",
1224
   false,
1225
   0xffffffff,
1226
   0xffffffff,
1227
   false),
1228
1229
  HOWTO (R_NIOS2_TLS_TPREL,
1230
   0,
1231
   4,
1232
   32,
1233
   false,
1234
   0,
1235
   complain_overflow_dont,
1236
   bfd_elf_generic_reloc,
1237
   "R_NIOS2_TLS_TPREL",
1238
   false,
1239
   0xffffffff,
1240
   0xffffffff,
1241
   false),
1242
1243
  HOWTO (R_NIOS2_COPY,
1244
   0,
1245
   4,
1246
   32,
1247
   false,
1248
   0,
1249
   complain_overflow_dont,
1250
   bfd_elf_generic_reloc,
1251
   "R_NIOS2_COPY",
1252
   false,
1253
   0,
1254
   0,
1255
   false),
1256
1257
  HOWTO (R_NIOS2_GLOB_DAT,
1258
   0,
1259
   4,
1260
   32,
1261
   false,
1262
   0,
1263
   complain_overflow_dont,
1264
   bfd_elf_generic_reloc,
1265
   "R_NIOS2_GLOB_DAT",
1266
   false,
1267
   0xffffffff,
1268
   0xffffffff,
1269
   false),
1270
1271
  HOWTO (R_NIOS2_JUMP_SLOT,
1272
   0,
1273
   4,
1274
   32,
1275
   false,
1276
   0,
1277
   complain_overflow_dont,
1278
   bfd_elf_generic_reloc,
1279
   "R_NIOS2_JUMP_SLOT",
1280
   false,
1281
   0xffffffff,
1282
   0xffffffff,
1283
   false),
1284
1285
  HOWTO (R_NIOS2_RELATIVE,
1286
   0,
1287
   4,
1288
   32,
1289
   false,
1290
   0,
1291
   complain_overflow_dont,
1292
   bfd_elf_generic_reloc,
1293
   "R_NIOS2_RELATIVE",
1294
   false,
1295
   0xffffffff,
1296
   0xffffffff,
1297
   false),
1298
1299
  HOWTO (R_NIOS2_GOTOFF,
1300
   0,
1301
   4,
1302
   32,
1303
   false,
1304
   0,
1305
   complain_overflow_dont,
1306
   bfd_elf_generic_reloc,
1307
   "R_NIOS2_GOTOFF",
1308
   false,
1309
   0xffffffff,
1310
   0xffffffff,
1311
   false),
1312
1313
  HOWTO (R_NIOS2_CALL26_NOAT, /* type */
1314
   2,     /* rightshift */
1315
   4,     /* size */
1316
   26,      /* bitsize */
1317
   false,     /* pc_relative */
1318
   6,     /* bitpos */
1319
   complain_overflow_dont,  /* complain on overflow */
1320
   nios2_elf32_call26_relocate, /* special function */
1321
   "R_NIOS2_CALL26_NOAT", /* name */
1322
   false,     /* partial_inplace */
1323
   0xffffffc0,    /* src_mask */
1324
   0xffffffc0,    /* dst_mask */
1325
   false),    /* pcrel_offset */
1326
1327
  HOWTO (R_NIOS2_GOT_LO,
1328
   0,
1329
   4,
1330
   16,
1331
   false,
1332
   16,
1333
   complain_overflow_dont,
1334
   bfd_elf_generic_reloc,
1335
   "R_NIOS2_GOT_LO",
1336
   false,
1337
   0xffff0000,
1338
   0xffff0000,
1339
   false),
1340
1341
  HOWTO (R_NIOS2_GOT_HA,
1342
   0,
1343
   4,
1344
   16,
1345
   false,
1346
   16,
1347
   complain_overflow_dont,
1348
   bfd_elf_generic_reloc,
1349
   "R_NIOS2_GOT_HA",
1350
   false,
1351
   0xffff0000,
1352
   0xffff0000,
1353
   false),
1354
1355
  HOWTO (R_NIOS2_CALL_LO,
1356
   0,
1357
   4,
1358
   16,
1359
   false,
1360
   16,
1361
   complain_overflow_dont,
1362
   bfd_elf_generic_reloc,
1363
   "R_NIOS2_CALL_LO",
1364
   false,
1365
   0xffff0000,
1366
   0xffff0000,
1367
   false),
1368
1369
  HOWTO (R_NIOS2_CALL_HA,
1370
   0,
1371
   4,
1372
   16,
1373
   false,
1374
   16,
1375
   complain_overflow_dont,
1376
   bfd_elf_generic_reloc,
1377
   "R_NIOS2_CALL_HA",
1378
   false,
1379
   0xffff0000,
1380
   0xffff0000,
1381
   false),
1382
1383
  HOWTO (R_NIOS2_R2_S12,
1384
   0,
1385
   4,
1386
   12,
1387
   false,
1388
   16,
1389
   complain_overflow_signed,
1390
   bfd_elf_generic_reloc,
1391
   "R_NIOS2_R2_S12",
1392
   false,
1393
   0x0fff0000,
1394
   0x0fff0000,
1395
   false),
1396
1397
  HOWTO (R_NIOS2_R2_I10_1_PCREL,
1398
   1,
1399
   2,
1400
   10,
1401
   true,
1402
   6,
1403
   complain_overflow_signed,
1404
   bfd_elf_generic_reloc,   /* FIXME? */
1405
   "R_NIOS2_R2_I10_1_PCREL",
1406
   false,
1407
   0xffc0,
1408
   0xffc0,
1409
   true),
1410
1411
  HOWTO (R_NIOS2_R2_T1I7_1_PCREL,
1412
   1,
1413
   2,
1414
   7,
1415
   true,
1416
   9,
1417
   complain_overflow_signed,
1418
   bfd_elf_generic_reloc,   /* FIXME? */
1419
   "R_NIOS2_R2_T1I7_1_PCREL",
1420
   false,
1421
   0xfe00,
1422
   0xfe00,
1423
   true),
1424
1425
  HOWTO (R_NIOS2_R2_T1I7_2,
1426
   2,
1427
   2,
1428
   7,
1429
   false,
1430
   9,
1431
   complain_overflow_unsigned,
1432
   bfd_elf_generic_reloc,
1433
   "R_NIOS2_R2_T1I7_2",
1434
   false,
1435
   0xfe00,
1436
   0xfe00,
1437
   false),
1438
1439
  HOWTO (R_NIOS2_R2_T2I4,
1440
   0,
1441
   2,
1442
   4,
1443
   false,
1444
   12,
1445
   complain_overflow_unsigned,
1446
   bfd_elf_generic_reloc,
1447
   "R_NIOS2_R2_T2I4",
1448
   false,
1449
   0xf000,
1450
   0xf000,
1451
   false),
1452
1453
  HOWTO (R_NIOS2_R2_T2I4_1,
1454
   1,
1455
   2,
1456
   4,
1457
   false,
1458
   12,
1459
   complain_overflow_unsigned,
1460
   bfd_elf_generic_reloc,
1461
   "R_NIOS2_R2_T2I4_1",
1462
   false,
1463
   0xf000,
1464
   0xf000,
1465
   false),
1466
1467
  HOWTO (R_NIOS2_R2_T2I4_2,
1468
   2,
1469
   2,
1470
   4,
1471
   false,
1472
   12,
1473
   complain_overflow_unsigned,
1474
   bfd_elf_generic_reloc,
1475
   "R_NIOS2_R2_T2I4_2",
1476
   false,
1477
   0xf000,
1478
   0xf000,
1479
   false),
1480
1481
  HOWTO (R_NIOS2_R2_X1I7_2,
1482
   2,
1483
   2,
1484
   7,
1485
   false,
1486
   6,
1487
   complain_overflow_unsigned,
1488
   bfd_elf_generic_reloc,
1489
   "R_NIOS2_R2_X1I7_2",
1490
   false,
1491
   0x1fc0,
1492
   0x1fc0,
1493
   false),
1494
1495
  HOWTO (R_NIOS2_R2_X2L5,
1496
   0,
1497
   2,
1498
   5,
1499
   false,
1500
   6,
1501
   complain_overflow_unsigned,
1502
   bfd_elf_generic_reloc,
1503
   "R_NIOS2_R2_X2L5",
1504
   false,
1505
   0x07c0,
1506
   0x07c0,
1507
   false),
1508
1509
  HOWTO (R_NIOS2_R2_F1I5_2,
1510
   2,
1511
   2,
1512
   5,
1513
   false,
1514
   6,
1515
   complain_overflow_unsigned,
1516
   bfd_elf_generic_reloc,
1517
   "R_NIOS2_R2_F1L5_2",
1518
   false,
1519
   0x07c0,
1520
   0x07c0,
1521
   false),
1522
1523
  HOWTO (R_NIOS2_R2_L5I4X1,
1524
   2,
1525
   2,
1526
   4,
1527
   false,
1528
   6,
1529
   complain_overflow_unsigned,
1530
   bfd_elf_generic_reloc,
1531
   "R_NIOS2_R2_L5I4X1",
1532
   false,
1533
   0x03c0,
1534
   0x03c0,
1535
   false),
1536
1537
  HOWTO (R_NIOS2_R2_T1X1I6,
1538
   0,
1539
   2,
1540
   6,
1541
   false,
1542
   9,
1543
   complain_overflow_unsigned,
1544
   bfd_elf_generic_reloc,
1545
   "R_NIOS2_R2_T1X1I6",
1546
   false,
1547
   0x7e00,
1548
   0x7e00,
1549
   false),
1550
1551
  HOWTO (R_NIOS2_R2_T1X1I6_2,
1552
   2,
1553
   4,
1554
   6,
1555
   false,
1556
   9,
1557
   complain_overflow_unsigned,
1558
   bfd_elf_generic_reloc,
1559
   "R_NIOS2_R2_T1I1X6_2",
1560
   false,
1561
   0x7e00,
1562
   0x7e00,
1563
   false),
1564
1565
/* Add other relocations here.  */
1566
};
1567
1568
static unsigned char elf_code_to_howto_index[R_NIOS2_ILLEGAL + 1];
1569
1570
1571
/* Return true if producing output for a R2 BFD.  */
1572
0
#define BFD_IS_R2(abfd) (bfd_get_mach (abfd) == bfd_mach_nios2r2)
1573
1574
/* Return the howto for relocation RTYPE.  */
1575
static reloc_howto_type *
1576
lookup_howto (unsigned int rtype, bfd *abfd)
1577
0
{
1578
0
  static int initialized = 0;
1579
0
  int i;
1580
  /* R2 relocations are a superset of R1, so use that for the lookup
1581
     table.  */
1582
0
  int r1_howto_tbl_size = (int) ARRAY_SIZE (elf_nios2_r1_howto_table_rel);
1583
0
  int r2_howto_tbl_size = (int) ARRAY_SIZE (elf_nios2_r2_howto_table_rel);
1584
1585
0
  if (!initialized)
1586
0
    {
1587
0
      initialized = 1;
1588
0
      memset (elf_code_to_howto_index, 0xff,
1589
0
        sizeof (elf_code_to_howto_index));
1590
0
      for (i = 0; i < r2_howto_tbl_size; i++)
1591
0
  {
1592
0
    elf_code_to_howto_index[elf_nios2_r2_howto_table_rel[i].type] = i;
1593
0
    if (i < r1_howto_tbl_size)
1594
0
      BFD_ASSERT (elf_nios2_r2_howto_table_rel[i].type
1595
0
      == elf_nios2_r1_howto_table_rel[i].type);
1596
0
  }
1597
0
    }
1598
1599
0
  if (rtype > R_NIOS2_ILLEGAL)
1600
0
    return NULL;
1601
0
  i = elf_code_to_howto_index[rtype];
1602
0
  if (BFD_IS_R2 (abfd))
1603
0
    {
1604
0
      if (i >= r2_howto_tbl_size)
1605
0
  return NULL;
1606
0
      return elf_nios2_r2_howto_table_rel + i;
1607
0
    }
1608
0
  else
1609
0
    {
1610
0
      if (i >= r1_howto_tbl_size)
1611
0
  return NULL;
1612
0
      return elf_nios2_r1_howto_table_rel + i;
1613
0
    }
1614
0
}
1615
1616
/* Map for converting BFD reloc types to Nios II reloc types.  */
1617
struct elf_reloc_map
1618
{
1619
  bfd_reloc_code_real_type bfd_val;
1620
  enum elf_nios2_reloc_type elf_val;
1621
};
1622
1623
static const struct elf_reloc_map nios2_reloc_map[] =
1624
{
1625
  {BFD_RELOC_NONE, R_NIOS2_NONE},
1626
  {BFD_RELOC_NIOS2_S16, R_NIOS2_S16},
1627
  {BFD_RELOC_NIOS2_U16, R_NIOS2_U16},
1628
  {BFD_RELOC_16_PCREL, R_NIOS2_PCREL16},
1629
  {BFD_RELOC_NIOS2_CALL26, R_NIOS2_CALL26},
1630
  {BFD_RELOC_NIOS2_IMM5, R_NIOS2_IMM5},
1631
  {BFD_RELOC_NIOS2_CACHE_OPX, R_NIOS2_CACHE_OPX},
1632
  {BFD_RELOC_NIOS2_IMM6, R_NIOS2_IMM6},
1633
  {BFD_RELOC_NIOS2_IMM8, R_NIOS2_IMM8},
1634
  {BFD_RELOC_NIOS2_HI16, R_NIOS2_HI16},
1635
  {BFD_RELOC_NIOS2_LO16, R_NIOS2_LO16},
1636
  {BFD_RELOC_NIOS2_HIADJ16, R_NIOS2_HIADJ16},
1637
  {BFD_RELOC_32, R_NIOS2_BFD_RELOC_32},
1638
  {BFD_RELOC_16, R_NIOS2_BFD_RELOC_16},
1639
  {BFD_RELOC_8, R_NIOS2_BFD_RELOC_8},
1640
  {BFD_RELOC_NIOS2_GPREL, R_NIOS2_GPREL},
1641
  {BFD_RELOC_VTABLE_INHERIT, R_NIOS2_GNU_VTINHERIT},
1642
  {BFD_RELOC_VTABLE_ENTRY, R_NIOS2_GNU_VTENTRY},
1643
  {BFD_RELOC_NIOS2_UJMP, R_NIOS2_UJMP},
1644
  {BFD_RELOC_NIOS2_CJMP, R_NIOS2_CJMP},
1645
  {BFD_RELOC_NIOS2_CALLR, R_NIOS2_CALLR},
1646
  {BFD_RELOC_NIOS2_ALIGN, R_NIOS2_ALIGN},
1647
  {BFD_RELOC_NIOS2_GOT16, R_NIOS2_GOT16},
1648
  {BFD_RELOC_NIOS2_CALL16, R_NIOS2_CALL16},
1649
  {BFD_RELOC_NIOS2_GOTOFF_LO, R_NIOS2_GOTOFF_LO},
1650
  {BFD_RELOC_NIOS2_GOTOFF_HA, R_NIOS2_GOTOFF_HA},
1651
  {BFD_RELOC_NIOS2_PCREL_LO, R_NIOS2_PCREL_LO},
1652
  {BFD_RELOC_NIOS2_PCREL_HA, R_NIOS2_PCREL_HA},
1653
  {BFD_RELOC_NIOS2_TLS_GD16, R_NIOS2_TLS_GD16},
1654
  {BFD_RELOC_NIOS2_TLS_LDM16, R_NIOS2_TLS_LDM16},
1655
  {BFD_RELOC_NIOS2_TLS_LDO16, R_NIOS2_TLS_LDO16},
1656
  {BFD_RELOC_NIOS2_TLS_IE16, R_NIOS2_TLS_IE16},
1657
  {BFD_RELOC_NIOS2_TLS_LE16, R_NIOS2_TLS_LE16},
1658
  {BFD_RELOC_NIOS2_TLS_DTPMOD, R_NIOS2_TLS_DTPMOD},
1659
  {BFD_RELOC_NIOS2_TLS_DTPREL, R_NIOS2_TLS_DTPREL},
1660
  {BFD_RELOC_NIOS2_TLS_TPREL, R_NIOS2_TLS_TPREL},
1661
  {BFD_RELOC_NIOS2_COPY, R_NIOS2_COPY},
1662
  {BFD_RELOC_NIOS2_GLOB_DAT, R_NIOS2_GLOB_DAT},
1663
  {BFD_RELOC_NIOS2_JUMP_SLOT, R_NIOS2_JUMP_SLOT},
1664
  {BFD_RELOC_NIOS2_RELATIVE, R_NIOS2_RELATIVE},
1665
  {BFD_RELOC_NIOS2_GOTOFF, R_NIOS2_GOTOFF},
1666
  {BFD_RELOC_NIOS2_CALL26_NOAT, R_NIOS2_CALL26_NOAT},
1667
  {BFD_RELOC_NIOS2_GOT_LO, R_NIOS2_GOT_LO},
1668
  {BFD_RELOC_NIOS2_GOT_HA, R_NIOS2_GOT_HA},
1669
  {BFD_RELOC_NIOS2_CALL_LO, R_NIOS2_CALL_LO},
1670
  {BFD_RELOC_NIOS2_CALL_HA, R_NIOS2_CALL_HA},
1671
  {BFD_RELOC_NIOS2_R2_S12, R_NIOS2_R2_S12},
1672
  {BFD_RELOC_NIOS2_R2_I10_1_PCREL, R_NIOS2_R2_I10_1_PCREL},
1673
  {BFD_RELOC_NIOS2_R2_T1I7_1_PCREL, R_NIOS2_R2_T1I7_1_PCREL},
1674
  {BFD_RELOC_NIOS2_R2_T1I7_2, R_NIOS2_R2_T1I7_2},
1675
  {BFD_RELOC_NIOS2_R2_T2I4, R_NIOS2_R2_T2I4},
1676
  {BFD_RELOC_NIOS2_R2_T2I4_1, R_NIOS2_R2_T2I4_1},
1677
  {BFD_RELOC_NIOS2_R2_T2I4_2, R_NIOS2_R2_T2I4_2},
1678
  {BFD_RELOC_NIOS2_R2_X1I7_2, R_NIOS2_R2_X1I7_2},
1679
  {BFD_RELOC_NIOS2_R2_X2L5, R_NIOS2_R2_X2L5},
1680
  {BFD_RELOC_NIOS2_R2_F1I5_2, R_NIOS2_R2_F1I5_2},
1681
  {BFD_RELOC_NIOS2_R2_L5I4X1, R_NIOS2_R2_L5I4X1},
1682
  {BFD_RELOC_NIOS2_R2_T1X1I6, R_NIOS2_R2_T1X1I6},
1683
  {BFD_RELOC_NIOS2_R2_T1X1I6_2, R_NIOS2_R2_T1X1I6_2},
1684
};
1685
1686
enum elf32_nios2_stub_type
1687
{
1688
  nios2_stub_call26_before,
1689
  nios2_stub_call26_after,
1690
  nios2_stub_none
1691
};
1692
1693
struct elf32_nios2_stub_hash_entry
1694
{
1695
  /* Base hash table entry structure.  */
1696
  struct bfd_hash_entry bh_root;
1697
1698
  /* The stub section.  */
1699
  asection *stub_sec;
1700
1701
  /* Offset within stub_sec of the beginning of this stub.  */
1702
  bfd_vma stub_offset;
1703
1704
  /* Given the symbol's value and its section we can determine its final
1705
     value when building the stubs (so the stub knows where to jump.  */
1706
  bfd_vma target_value;
1707
  asection *target_section;
1708
1709
  enum elf32_nios2_stub_type stub_type;
1710
1711
  /* The symbol table entry, if any, that this was derived from.  */
1712
  struct elf32_nios2_link_hash_entry *hh;
1713
1714
  /* And the reloc addend that this was derived from.  */
1715
  bfd_vma addend;
1716
1717
  /* Where this stub is being called from, or, in the case of combined
1718
     stub sections, the first input section in the group.  */
1719
  asection *id_sec;
1720
};
1721
1722
#define nios2_stub_hash_entry(ent) \
1723
  ((struct elf32_nios2_stub_hash_entry *)(ent))
1724
1725
#define nios2_stub_hash_lookup(table, string, create, copy) \
1726
0
  ((struct elf32_nios2_stub_hash_entry *) \
1727
0
   bfd_hash_lookup ((table), (string), (create), (copy)))
1728
1729
1730
/* Nios II ELF linker hash entry.  */
1731
1732
struct elf32_nios2_link_hash_entry
1733
{
1734
  struct elf_link_hash_entry root;
1735
1736
  /* A pointer to the most recently used stub hash entry against this
1737
     symbol.  */
1738
  struct elf32_nios2_stub_hash_entry *hsh_cache;
1739
1740
0
#define GOT_UNKNOWN 0
1741
0
#define GOT_NORMAL  1
1742
0
#define GOT_TLS_GD  2
1743
0
#define GOT_TLS_IE  4
1744
  unsigned char tls_type;
1745
1746
  /* We need to detect and take special action for symbols which are only
1747
     referenced with %call() and not with %got().  Such symbols do not need
1748
     a dynamic GOT reloc in shared objects, only a dynamic PLT reloc.  Lazy
1749
     linking will not work if the dynamic GOT reloc exists.
1750
     To check for this condition efficiently, we compare got_types_used against
1751
     CALL_USED, meaning
1752
     (got_types_used & (GOT_USED | CALL_USED)) == CALL_USED.
1753
  */
1754
0
#define GOT_USED  1
1755
0
#define CALL_USED 2
1756
  unsigned char got_types_used;
1757
};
1758
1759
#define elf32_nios2_hash_entry(ent) \
1760
0
  ((struct elf32_nios2_link_hash_entry *) (ent))
1761
1762
/* Get the Nios II elf linker hash table from a link_info structure.  */
1763
#define elf32_nios2_hash_table(info) \
1764
0
  ((struct elf32_nios2_link_hash_table *) ((info)->hash))
1765
1766
/* Nios II ELF linker hash table.  */
1767
struct elf32_nios2_link_hash_table
1768
  {
1769
    /* The main hash table.  */
1770
    struct elf_link_hash_table root;
1771
1772
    /* The stub hash table.  */
1773
    struct bfd_hash_table bstab;
1774
1775
    /* Linker stub bfd.  */
1776
    bfd *stub_bfd;
1777
1778
    /* Linker call-backs.  */
1779
    asection * (*add_stub_section) (const char *, asection *, bool);
1780
    void (*layout_sections_again) (void);
1781
1782
    /* Array to keep track of which stub sections have been created, and
1783
       information on stub grouping.  */
1784
    struct map_stub
1785
    {
1786
      /* These are the section to which stubs in the group will be
1787
   attached.  */
1788
      asection *first_sec, *last_sec;
1789
      /* The stub sections.  There might be stubs inserted either before
1790
   or after the real section.*/
1791
      asection *first_stub_sec, *last_stub_sec;
1792
    } *stub_group;
1793
1794
    /* Assorted information used by nios2_elf32_size_stubs.  */
1795
    unsigned int bfd_count;
1796
    unsigned int top_index;
1797
    asection **input_list;
1798
    Elf_Internal_Sym **all_local_syms;
1799
1800
    /* Short-cuts to get to dynamic linker sections.  */
1801
    asection *sbss;
1802
1803
    /* GOT pointer symbol _gp_got.  */
1804
    struct elf_link_hash_entry *h_gp_got;
1805
1806
    union {
1807
      bfd_signed_vma refcount;
1808
      bfd_vma offset;
1809
    } tls_ldm_got;
1810
1811
    bfd_vma res_n_size;
1812
  };
1813
1814
struct nios2_elf32_obj_tdata
1815
{
1816
  struct elf_obj_tdata root;
1817
1818
  /* tls_type for each local got entry.  */
1819
  char *local_got_tls_type;
1820
1821
  /* TRUE if TLS GD relocs have been seen for this object.  */
1822
  bool has_tlsgd;
1823
};
1824
1825
#define elf32_nios2_tdata(abfd) \
1826
0
  ((struct nios2_elf32_obj_tdata *) (abfd)->tdata.any)
1827
1828
#define elf32_nios2_local_got_tls_type(abfd) \
1829
0
  (elf32_nios2_tdata (abfd)->local_got_tls_type)
1830
1831
/* The name of the dynamic interpreter.  This is put in the .interp
1832
   section.  */
1833
0
#define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
1834
1835
/* PLT implementation for position-dependent code.  */
1836
static const bfd_vma nios2_plt_entry[] = { /* .PLTn: */
1837
  0x03c00034, /* movhi r15, %hiadj(plt_got_slot_address) */
1838
  0x7bc00017, /* ldw r15, %lo(plt_got_slot_address)(r15) */
1839
  0x7800683a  /* jmp r15 */
1840
};
1841
1842
static const bfd_vma nios2_plt0_entry[] = { /* .PLTresolve */
1843
  0x03800034, /* movhi r14, %hiadj(res_0) */
1844
  0x73800004, /* addi r14, r14, %lo(res_0) */
1845
  0x7b9fc83a, /* sub r15, r15, r14 */
1846
  0x03400034, /* movhi r13, %hiadj(_GLOBAL_OFFSET_TABLE_) */
1847
  0x6b800017, /* ldw r14, %lo(_GLOBAL_OFFSET_TABLE_+4)(r13) */
1848
  0x6b400017, /* ldw r13, %lo(_GLOBAL_OFFSET_TABLE_+8)(r13) */
1849
  0x6800683a  /* jmp r13 */
1850
};
1851
1852
/* PLT implementation for position-independent code.  */
1853
static const bfd_vma nios2_so_plt_entry[] = { /* .PLTn */
1854
  0x03c00034, /* movhi r15, %hiadj(index * 4) */
1855
  0x7bc00004, /* addi r15, r15, %lo(index * 4) */
1856
  0x00000006  /* br .PLTresolve */
1857
};
1858
1859
static const bfd_vma nios2_so_plt0_entry[] = { /* .PLTresolve */
1860
  0x001ce03a, /* nextpc r14 */
1861
  0x03400034, /* movhi r13, %hiadj(_GLOBAL_OFFSET_TABLE_) */
1862
  0x6b9b883a, /* add r13, r13, r14 */
1863
  0x6b800017, /* ldw r14, %lo(_GLOBAL_OFFSET_TABLE_+4)(r13) */
1864
  0x6b400017, /* ldw r13, %lo(_GLOBAL_OFFSET_TABLE_+8)(r13) */
1865
  0x6800683a  /* jmp r13 */
1866
};
1867
1868
/* CALL26 stub.  */
1869
static const bfd_vma nios2_call26_stub_entry[] = {
1870
  0x00400034, /* orhi at, r0, %hiadj(dest) */
1871
  0x08400004, /* addi at, at, %lo(dest) */
1872
  0x0800683a  /* jmp at */
1873
};
1874
1875
/* Install 16-bit immediate value VALUE at offset OFFSET into section SEC.  */
1876
static void
1877
nios2_elf32_install_imm16 (asection *sec, bfd_vma offset, bfd_vma value)
1878
0
{
1879
0
  bfd_vma word = bfd_get_32 (sec->owner, sec->contents + offset);
1880
1881
0
  bfd_put_32 (sec->owner, word | ((value & 0xffff) << 6),
1882
0
        sec->contents + offset);
1883
0
}
1884
1885
/* Install COUNT 32-bit values DATA starting at offset OFFSET into
1886
   section SEC. */
1887
static void
1888
nios2_elf32_install_data (asection *sec, const bfd_vma *data, bfd_vma offset,
1889
        int count)
1890
0
{
1891
0
  while (count--)
1892
0
    {
1893
0
      bfd_put_32 (sec->owner, *data, sec->contents + offset);
1894
0
      offset += 4;
1895
0
      ++data;
1896
0
    }
1897
0
}
1898
1899
/* The usual way of loading a 32-bit constant into a Nios II register is to
1900
   load the high 16 bits in one instruction and then add the low 16 bits with
1901
   a signed add. This means that the high halfword needs to be adjusted to
1902
   compensate for the sign bit of the low halfword. This function returns the
1903
   adjusted high halfword for a given 32-bit constant.  */
1904
static
1905
bfd_vma hiadj (bfd_vma symbol_value)
1906
0
{
1907
0
  return ((symbol_value + 0x8000) >> 16) & 0xffff;
1908
0
}
1909
1910
/* Implement elf_backend_grok_prstatus:
1911
   Support for core dump NOTE sections.  */
1912
static bool
1913
nios2_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
1914
0
{
1915
0
  int offset;
1916
0
  size_t size;
1917
1918
0
  switch (note->descsz)
1919
0
    {
1920
0
    default:
1921
0
      return false;
1922
1923
0
    case 212:       /* Linux/Nios II */
1924
      /* pr_cursig */
1925
0
      elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
1926
1927
      /* pr_pid */
1928
0
      elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 24);
1929
1930
      /* pr_reg */
1931
0
      offset = 72;
1932
0
      size = 136;
1933
1934
0
      break;
1935
0
    }
1936
1937
  /* Make a ".reg/999" section.  */
1938
0
  return _bfd_elfcore_make_pseudosection (abfd, ".reg",
1939
0
            size, note->descpos + offset);
1940
0
}
1941
1942
/* Implement elf_backend_grok_psinfo.  */
1943
static bool
1944
nios2_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
1945
0
{
1946
0
  switch (note->descsz)
1947
0
    {
1948
0
    default:
1949
0
      return false;
1950
1951
0
    case 124:       /* Linux/Nios II elf_prpsinfo */
1952
0
      elf_tdata (abfd)->core->program
1953
0
  = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
1954
0
      elf_tdata (abfd)->core->command
1955
0
  = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
1956
0
    }
1957
1958
  /* Note that for some reason, a spurious space is tacked
1959
     onto the end of the args in some (at least one anyway)
1960
     implementations, so strip it off if it exists.  */
1961
1962
0
  {
1963
0
    char *command = elf_tdata (abfd)->core->command;
1964
0
    int n = strlen (command);
1965
1966
0
    if (0 < n && command[n - 1] == ' ')
1967
0
      command[n - 1] = '\0';
1968
0
  }
1969
1970
0
  return true;
1971
0
}
1972
1973
/* Assorted hash table functions.  */
1974
1975
/* Initialize an entry in the stub hash table.  */
1976
static struct bfd_hash_entry *
1977
stub_hash_newfunc (struct bfd_hash_entry *entry,
1978
       struct bfd_hash_table *table,
1979
       const char *string)
1980
0
{
1981
  /* Allocate the structure if it has not already been allocated by a
1982
     subclass.  */
1983
0
  if (entry == NULL)
1984
0
    {
1985
0
      entry = bfd_hash_allocate (table,
1986
0
         sizeof (struct elf32_nios2_stub_hash_entry));
1987
0
      if (entry == NULL)
1988
0
  return entry;
1989
0
    }
1990
1991
  /* Call the allocation method of the superclass.  */
1992
0
  entry = bfd_hash_newfunc (entry, table, string);
1993
0
  if (entry != NULL)
1994
0
    {
1995
0
      struct elf32_nios2_stub_hash_entry *hsh;
1996
1997
      /* Initialize the local fields.  */
1998
0
      hsh = (struct elf32_nios2_stub_hash_entry *) entry;
1999
0
      hsh->stub_sec = NULL;
2000
0
      hsh->stub_offset = 0;
2001
0
      hsh->target_value = 0;
2002
0
      hsh->target_section = NULL;
2003
0
      hsh->stub_type = nios2_stub_none;
2004
0
      hsh->hh = NULL;
2005
0
      hsh->id_sec = NULL;
2006
0
    }
2007
2008
0
  return entry;
2009
0
}
2010
2011
/* Create an entry in a Nios II ELF linker hash table.  */
2012
static struct bfd_hash_entry *
2013
link_hash_newfunc (struct bfd_hash_entry *entry,
2014
       struct bfd_hash_table *table, const char *string)
2015
0
{
2016
  /* Allocate the structure if it has not already been allocated by a
2017
     subclass.  */
2018
0
  if (entry == NULL)
2019
0
    {
2020
0
      entry = bfd_hash_allocate (table,
2021
0
         sizeof (struct elf32_nios2_link_hash_entry));
2022
0
      if (entry == NULL)
2023
0
  return entry;
2024
0
    }
2025
2026
  /* Call the allocation method of the superclass.  */
2027
0
  entry = _bfd_elf_link_hash_newfunc (entry, table, string);
2028
0
  if (entry)
2029
0
    {
2030
0
      struct elf32_nios2_link_hash_entry *eh;
2031
2032
0
      eh = (struct elf32_nios2_link_hash_entry *) entry;
2033
0
      eh->hsh_cache = NULL;
2034
0
      eh->tls_type = GOT_UNKNOWN;
2035
0
      eh->got_types_used = 0;
2036
0
    }
2037
2038
0
  return entry;
2039
0
}
2040
2041
/* Section name for stubs is the associated section name plus this
2042
   string.  */
2043
0
#define STUB_SUFFIX ".stub"
2044
2045
/* Build a name for an entry in the stub hash table.  */
2046
static char *
2047
nios2_stub_name (const asection *input_section,
2048
     const asection *sym_sec,
2049
     const struct elf32_nios2_link_hash_entry *hh,
2050
     const Elf_Internal_Rela *rel,
2051
     enum elf32_nios2_stub_type stub_type)
2052
0
{
2053
0
  char *stub_name;
2054
0
  bfd_size_type len;
2055
0
  char stubpos = (stub_type == nios2_stub_call26_before) ? 'b' : 'a';
2056
2057
0
  if (hh)
2058
0
    {
2059
0
      len = 8 + 1 + 1 + 1+ strlen (hh->root.root.root.string) + 1 + 8 + 1;
2060
0
      stub_name = bfd_malloc (len);
2061
0
      if (stub_name != NULL)
2062
0
  {
2063
0
    sprintf (stub_name, "%08x_%c_%s+%x",
2064
0
       input_section->id & 0xffffffff,
2065
0
       stubpos,
2066
0
       hh->root.root.root.string,
2067
0
       (int) rel->r_addend & 0xffffffff);
2068
0
  }
2069
0
    }
2070
0
  else
2071
0
    {
2072
0
      len = 8 + 1 + 1 + 1+ 8 + 1 + 8 + 1 + 8 + 1;
2073
0
      stub_name = bfd_malloc (len);
2074
0
      if (stub_name != NULL)
2075
0
  {
2076
0
    sprintf (stub_name, "%08x_%c_%x:%x+%x",
2077
0
       input_section->id & 0xffffffff,
2078
0
       stubpos,
2079
0
       sym_sec->id & 0xffffffff,
2080
0
       (int) ELF32_R_SYM (rel->r_info) & 0xffffffff,
2081
0
       (int) rel->r_addend & 0xffffffff);
2082
0
  }
2083
0
    }
2084
0
  return stub_name;
2085
0
}
2086
2087
/* Look up an entry in the stub hash.  Stub entries are cached because
2088
   creating the stub name takes a bit of time.  */
2089
static struct elf32_nios2_stub_hash_entry *
2090
nios2_get_stub_entry (const asection *input_section,
2091
          const asection *sym_sec,
2092
          struct elf32_nios2_link_hash_entry *hh,
2093
          const Elf_Internal_Rela *rel,
2094
          struct elf32_nios2_link_hash_table *htab,
2095
          enum elf32_nios2_stub_type stub_type)
2096
0
{
2097
0
  struct elf32_nios2_stub_hash_entry *hsh;
2098
0
  const asection *id_sec;
2099
2100
  /* If this input section is part of a group of sections sharing one
2101
     stub section, then use the id of the first/last section in the group,
2102
     depending on the stub section placement relative to the group.
2103
     Stub names need to include a section id, as there may well be
2104
     more than one stub used to reach say, printf, and we need to
2105
     distinguish between them.  */
2106
0
  if (stub_type == nios2_stub_call26_before)
2107
0
    id_sec = htab->stub_group[input_section->id].first_sec;
2108
0
  else
2109
0
    id_sec = htab->stub_group[input_section->id].last_sec;
2110
2111
0
  if (hh != NULL && hh->hsh_cache != NULL
2112
0
      && hh->hsh_cache->hh == hh
2113
0
      && hh->hsh_cache->id_sec == id_sec
2114
0
      && hh->hsh_cache->stub_type == stub_type)
2115
0
    {
2116
0
      hsh = hh->hsh_cache;
2117
0
    }
2118
0
  else
2119
0
    {
2120
0
      char *stub_name;
2121
2122
0
      stub_name = nios2_stub_name (id_sec, sym_sec, hh, rel, stub_type);
2123
0
      if (stub_name == NULL)
2124
0
  return NULL;
2125
2126
0
      hsh = nios2_stub_hash_lookup (&htab->bstab,
2127
0
            stub_name, false, false);
2128
2129
0
      if (hh != NULL)
2130
0
  hh->hsh_cache = hsh;
2131
2132
0
      free (stub_name);
2133
0
    }
2134
2135
0
  return hsh;
2136
0
}
2137
2138
/* Add a new stub entry to the stub hash.  Not all fields of the new
2139
   stub entry are initialised.  */
2140
static struct elf32_nios2_stub_hash_entry *
2141
nios2_add_stub (const char *stub_name,
2142
    asection *section,
2143
    struct elf32_nios2_link_hash_table *htab,
2144
    enum elf32_nios2_stub_type stub_type)
2145
0
{
2146
0
  asection *link_sec;
2147
0
  asection *stub_sec;
2148
0
  asection **secptr, **linkptr;
2149
0
  struct elf32_nios2_stub_hash_entry *hsh;
2150
0
  bool afterp;
2151
2152
0
  if (stub_type == nios2_stub_call26_before)
2153
0
    {
2154
0
      link_sec = htab->stub_group[section->id].first_sec;
2155
0
      secptr = &(htab->stub_group[section->id].first_stub_sec);
2156
0
      linkptr = &(htab->stub_group[link_sec->id].first_stub_sec);
2157
0
      afterp = false;
2158
0
    }
2159
0
  else
2160
0
    {
2161
0
      link_sec = htab->stub_group[section->id].last_sec;
2162
0
      secptr = &(htab->stub_group[section->id].last_stub_sec);
2163
0
      linkptr = &(htab->stub_group[link_sec->id].last_stub_sec);
2164
0
      afterp = true;
2165
0
    }
2166
0
  stub_sec = *secptr;
2167
0
  if (stub_sec == NULL)
2168
0
    {
2169
0
      stub_sec = *linkptr;
2170
0
      if (stub_sec == NULL)
2171
0
  {
2172
0
    size_t namelen;
2173
0
    bfd_size_type len;
2174
0
    char *s_name;
2175
2176
0
    namelen = strlen (link_sec->name);
2177
0
    len = namelen + sizeof (STUB_SUFFIX);
2178
0
    s_name = bfd_alloc (htab->stub_bfd, len);
2179
0
    if (s_name == NULL)
2180
0
      return NULL;
2181
2182
0
    memcpy (s_name, link_sec->name, namelen);
2183
0
    memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
2184
2185
0
    stub_sec = (*htab->add_stub_section) (s_name, link_sec, afterp);
2186
0
    if (stub_sec == NULL)
2187
0
      return NULL;
2188
0
    *linkptr = stub_sec;
2189
0
  }
2190
0
      *secptr = stub_sec;
2191
0
    }
2192
2193
  /* Enter this entry into the linker stub hash table.  */
2194
0
  hsh = nios2_stub_hash_lookup (&htab->bstab, stub_name,
2195
0
        true, false);
2196
0
  if (hsh == NULL)
2197
0
    {
2198
      /* xgettext:c-format */
2199
0
      _bfd_error_handler (_("%pB: cannot create stub entry %s"),
2200
0
        section->owner,
2201
0
        stub_name);
2202
0
      return NULL;
2203
0
    }
2204
2205
0
  hsh->stub_sec = stub_sec;
2206
0
  hsh->stub_offset = 0;
2207
0
  hsh->id_sec = link_sec;
2208
0
  return hsh;
2209
0
}
2210
2211
/* Set up various things so that we can make a list of input sections
2212
   for each output section included in the link.  Returns -1 on error,
2213
   0 when no stubs will be needed, and 1 on success.  */
2214
int
2215
nios2_elf32_setup_section_lists (bfd *output_bfd, struct bfd_link_info *info)
2216
0
{
2217
0
  bfd *input_bfd;
2218
0
  unsigned int bfd_count;
2219
0
  unsigned int top_id, top_index;
2220
0
  asection *section;
2221
0
  asection **input_list, **list;
2222
0
  size_t amt;
2223
0
  struct elf32_nios2_link_hash_table *htab = elf32_nios2_hash_table (info);
2224
2225
  /* Count the number of input BFDs and find the top input section id.  */
2226
0
  for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
2227
0
       input_bfd != NULL;
2228
0
       input_bfd = input_bfd->link.next)
2229
0
    {
2230
0
      bfd_count += 1;
2231
0
      for (section = input_bfd->sections;
2232
0
     section != NULL;
2233
0
     section = section->next)
2234
0
  {
2235
0
    if (top_id < section->id)
2236
0
      top_id = section->id;
2237
0
  }
2238
0
    }
2239
2240
0
  htab->bfd_count = bfd_count;
2241
2242
0
  amt = sizeof (struct map_stub) * (top_id + 1);
2243
0
  htab->stub_group = bfd_zmalloc (amt);
2244
0
  if (htab->stub_group == NULL)
2245
0
    return -1;
2246
2247
  /* We can't use output_bfd->section_count here to find the top output
2248
     section index as some sections may have been removed, and
2249
     strip_excluded_output_sections doesn't renumber the indices.  */
2250
0
  for (section = output_bfd->sections, top_index = 0;
2251
0
       section != NULL;
2252
0
       section = section->next)
2253
0
    {
2254
0
      if (top_index < section->index)
2255
0
  top_index = section->index;
2256
0
    }
2257
2258
0
  htab->top_index = top_index;
2259
0
  amt = sizeof (asection *) * (top_index + 1);
2260
0
  input_list = bfd_malloc (amt);
2261
0
  htab->input_list = input_list;
2262
0
  if (input_list == NULL)
2263
0
    return -1;
2264
2265
  /* For sections we aren't interested in, mark their entries with a
2266
     value we can check later.  */
2267
0
  list = input_list + top_index;
2268
0
  do
2269
0
    *list = bfd_abs_section_ptr;
2270
0
  while (list-- != input_list);
2271
2272
0
  for (section = output_bfd->sections;
2273
0
       section != NULL;
2274
0
       section = section->next)
2275
0
    {
2276
      /* FIXME: This is a bit of hack. Currently our .ctors and .dtors
2277
       * have PC relative relocs in them but no code flag set.  */
2278
0
      if (((section->flags & SEC_CODE) != 0) ||
2279
0
    strcmp(".ctors", section->name) ||
2280
0
    strcmp(".dtors", section->name))
2281
0
  input_list[section->index] = NULL;
2282
0
    }
2283
2284
0
  return 1;
2285
0
}
2286
2287
/* The linker repeatedly calls this function for each input section,
2288
   in the order that input sections are linked into output sections.
2289
   Build lists of input sections to determine groupings between which
2290
   we may insert linker stubs.  */
2291
void
2292
nios2_elf32_next_input_section (struct bfd_link_info *info, asection *isec)
2293
0
{
2294
0
  struct elf32_nios2_link_hash_table *htab = elf32_nios2_hash_table (info);
2295
2296
0
  if (isec->output_section->index <= htab->top_index)
2297
0
    {
2298
0
      asection **list = htab->input_list + isec->output_section->index;
2299
0
      if (*list != bfd_abs_section_ptr)
2300
0
  {
2301
    /* Steal the last_sec pointer for our list.
2302
       This happens to make the list in reverse order,
2303
       which is what we want.  */
2304
0
    htab->stub_group[isec->id].last_sec = *list;
2305
0
    *list = isec;
2306
0
  }
2307
0
    }
2308
0
}
2309
2310
/* Segment mask for CALL26 relocation relaxation.  */
2311
0
#define CALL26_SEGMENT(x) ((x) & 0xf0000000)
2312
2313
/* Fudge factor for approximate maximum size of all stubs that might
2314
   be inserted by the linker.  This does not actually limit the number
2315
   of stubs that might be inserted, and only affects strategy for grouping
2316
   and placement of stubs.  Perhaps this should be computed based on number
2317
   of relocations seen, or be specifiable on the command line.  */
2318
#define MAX_STUB_SECTION_SIZE 0xffff
2319
2320
/* See whether we can group stub sections together.  Grouping stub
2321
   sections may result in fewer stubs.  More importantly, we need to
2322
   put all .init* and .fini* stubs at the end of the .init or
2323
   .fini output sections respectively, because glibc splits the
2324
   _init and _fini functions into multiple parts.  Putting a stub in
2325
   the middle of a function is not a good idea.
2326
   Rather than computing groups of a maximum fixed size, for Nios II
2327
   CALL26 relaxation it makes more sense to compute the groups based on
2328
   sections that fit within a 256MB address segment.  Also do not allow
2329
   a group to span more than one output section, since different output
2330
   sections might correspond to different memory banks on a bare-metal
2331
   target, etc.  */
2332
static void
2333
group_sections (struct elf32_nios2_link_hash_table *htab)
2334
0
{
2335
0
  asection **list = htab->input_list + htab->top_index;
2336
0
  do
2337
0
    {
2338
      /* The list is in reverse order so we'll search backwards looking
2339
   for the first section that begins in the same memory segment,
2340
   marking sections along the way to point at the tail for this
2341
   group.  */
2342
0
      asection *tail = *list;
2343
0
      if (tail == bfd_abs_section_ptr)
2344
0
  continue;
2345
0
      while (tail != NULL)
2346
0
  {
2347
0
    bfd_vma start = tail->output_section->vma + tail->output_offset;
2348
0
    bfd_vma end = start + tail->size;
2349
0
    bfd_vma segment = CALL26_SEGMENT (end);
2350
0
    asection *prev;
2351
2352
0
    if (segment != CALL26_SEGMENT (start)
2353
0
        || segment != CALL26_SEGMENT (end + MAX_STUB_SECTION_SIZE))
2354
      /* This section spans more than one memory segment, or is
2355
         close enough to the end of the segment that adding stub
2356
         sections before it might cause it to move so that it
2357
         spans memory segments, or that stubs added at the end of
2358
         this group might overflow into the next memory segment.
2359
         Put it in a group by itself to localize the effects.  */
2360
0
      {
2361
0
        prev = htab->stub_group[tail->id].last_sec;
2362
0
        htab->stub_group[tail->id].last_sec = tail;
2363
0
        htab->stub_group[tail->id].first_sec = tail;
2364
0
      }
2365
0
    else
2366
      /* Collect more sections for this group.  */
2367
0
      {
2368
0
        asection *curr, *first;
2369
0
        for (curr = tail; ; curr = prev)
2370
0
    {
2371
0
      prev = htab->stub_group[curr->id].last_sec;
2372
0
      if (!prev
2373
0
          || tail->output_section != prev->output_section
2374
0
          || (CALL26_SEGMENT (prev->output_section->vma
2375
0
            + prev->output_offset)
2376
0
        != segment))
2377
0
        break;
2378
0
    }
2379
0
        first = curr;
2380
0
        for (curr = tail; ; curr = prev)
2381
0
    {
2382
0
      prev = htab->stub_group[curr->id].last_sec;
2383
0
      htab->stub_group[curr->id].last_sec = tail;
2384
0
      htab->stub_group[curr->id].first_sec = first;
2385
0
      if (curr == first)
2386
0
        break;
2387
0
    }
2388
0
      }
2389
2390
    /* Reset tail for the next group.  */
2391
0
    tail = prev;
2392
0
  }
2393
0
    }
2394
0
  while (list-- != htab->input_list);
2395
0
  free (htab->input_list);
2396
0
}
2397
2398
/* Determine the type of stub needed, if any, for a call.  */
2399
static enum elf32_nios2_stub_type
2400
nios2_type_of_stub (asection *input_sec,
2401
        const Elf_Internal_Rela *rel,
2402
        struct elf32_nios2_link_hash_entry *hh,
2403
        struct elf32_nios2_link_hash_table *htab,
2404
        bfd_vma destination,
2405
        struct bfd_link_info *info ATTRIBUTE_UNUSED)
2406
0
{
2407
0
  bfd_vma location, segment, start, end;
2408
0
  asection *s0, *s1, *s;
2409
2410
0
  if (hh != NULL &&
2411
0
      !(hh->root.root.type == bfd_link_hash_defined
2412
0
  || hh->root.root.type == bfd_link_hash_defweak))
2413
0
    return nios2_stub_none;
2414
2415
  /* Determine where the call point is.  */
2416
0
  location = (input_sec->output_section->vma
2417
0
        + input_sec->output_offset + rel->r_offset);
2418
0
  segment = CALL26_SEGMENT (location);
2419
2420
  /* Nios II CALL and JMPI instructions can transfer control to addresses
2421
     within the same 256MB segment as the PC.  */
2422
0
  if (segment == CALL26_SEGMENT (destination))
2423
0
    return nios2_stub_none;
2424
2425
  /* Find the start and end addresses of the stub group.  Also account for
2426
     any already-created stub sections for this group.  Note that for stubs
2427
     in the end section, only the first instruction of the last stub
2428
     (12 bytes long) needs to be within range.  */
2429
0
  s0 = htab->stub_group[input_sec->id].first_sec;
2430
0
  s = htab->stub_group[s0->id].first_stub_sec;
2431
0
  if (s != NULL && s->size > 0)
2432
0
    start = s->output_section->vma + s->output_offset;
2433
0
  else
2434
0
    start = s0->output_section->vma + s0->output_offset;
2435
2436
0
  s1 = htab->stub_group[input_sec->id].last_sec;
2437
0
  s = htab->stub_group[s1->id].last_stub_sec;
2438
0
  if (s != NULL && s->size > 0)
2439
0
    end = s->output_section->vma + s->output_offset + s->size - 8;
2440
0
  else
2441
0
    end = s1->output_section->vma + s1->output_offset + s1->size;
2442
2443
0
  BFD_ASSERT (start < end);
2444
0
  BFD_ASSERT (start <= location);
2445
0
  BFD_ASSERT (location < end);
2446
2447
  /* Put stubs at the end of the group unless that is not a valid
2448
     location and the beginning of the group is.  It might be that
2449
     neither the beginning nor end works if we have an input section
2450
     so large that it spans multiple segment boundaries.  In that
2451
     case, punt; the end result will be a relocation overflow error no
2452
     matter what we do here.
2453
2454
     Note that adding stubs pushes up the addresses of all subsequent
2455
     sections, so that stubs allocated on one pass through the
2456
     relaxation loop may not be valid on the next pass.  (E.g., we may
2457
     allocate a stub at the beginning of the section on one pass and
2458
     find that the call site has been bumped into the next memory
2459
     segment on the next pass.)  The important thing to note is that
2460
     we never try to reclaim the space allocated to such unused stubs,
2461
     so code size and section addresses can only increase with each
2462
     iteration.  Accounting for the start and end addresses of the
2463
     already-created stub sections ensures that when the algorithm
2464
     converges, it converges accurately, with the entire appropriate
2465
     stub section accessible from the call site and not just the
2466
     address at the start or end of the stub group proper.  */
2467
2468
0
  if (segment == CALL26_SEGMENT (end))
2469
0
    return nios2_stub_call26_after;
2470
0
  else if (segment == CALL26_SEGMENT (start))
2471
0
    return nios2_stub_call26_before;
2472
0
  else
2473
    /* Perhaps this should be a dedicated error code.  */
2474
0
    return nios2_stub_none;
2475
0
}
2476
2477
static bool
2478
nios2_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg ATTRIBUTE_UNUSED)
2479
0
{
2480
0
  struct elf32_nios2_stub_hash_entry *hsh
2481
0
    = (struct elf32_nios2_stub_hash_entry *) gen_entry;
2482
0
  asection *stub_sec = hsh->stub_sec;
2483
0
  bfd_vma sym_value;
2484
0
  struct bfd_link_info *info;
2485
2486
0
  info = (struct bfd_link_info *) in_arg;
2487
2488
  /* Fail if the target section could not be assigned to an output
2489
     section.  The user should fix his linker script.  */
2490
0
  if (hsh->target_section->output_section == NULL
2491
0
      && info->non_contiguous_regions)
2492
0
    info->callbacks->einfo (_("%F%P: Could not assign `%pA' to an output section. "
2493
0
            "Retry without --enable-non-contiguous-regions.\n"),
2494
0
          hsh->target_section);
2495
2496
  /* Make a note of the offset within the stubs for this entry.  */
2497
0
  hsh->stub_offset = stub_sec->size;
2498
2499
0
  switch (hsh->stub_type)
2500
0
    {
2501
0
    case nios2_stub_call26_before:
2502
0
    case nios2_stub_call26_after:
2503
      /* A call26 stub looks like:
2504
     orhi at, %hiadj(dest)
2505
     addi at, at, %lo(dest)
2506
     jmp at
2507
   Note that call/jmpi instructions can't be used in PIC code
2508
   so there is no reason for the stub to be PIC, either.  */
2509
0
      sym_value = (hsh->target_value
2510
0
       + hsh->target_section->output_offset
2511
0
       + hsh->target_section->output_section->vma
2512
0
       + hsh->addend);
2513
2514
0
      nios2_elf32_install_data (stub_sec, nios2_call26_stub_entry,
2515
0
        hsh->stub_offset, 3);
2516
0
      nios2_elf32_install_imm16 (stub_sec, hsh->stub_offset,
2517
0
         hiadj (sym_value));
2518
0
      nios2_elf32_install_imm16 (stub_sec, hsh->stub_offset + 4,
2519
0
         sym_value);
2520
0
      stub_sec->size += 12;
2521
0
      break;
2522
0
    default:
2523
0
      BFD_FAIL ();
2524
0
      return false;
2525
0
    }
2526
2527
0
  return true;
2528
0
}
2529
2530
/* As above, but don't actually build the stub.  Just bump offset so
2531
   we know stub section sizes.  */
2532
static bool
2533
nios2_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg ATTRIBUTE_UNUSED)
2534
0
{
2535
0
  struct elf32_nios2_stub_hash_entry *hsh
2536
0
    = (struct elf32_nios2_stub_hash_entry *) gen_entry;
2537
2538
0
  switch (hsh->stub_type)
2539
0
    {
2540
0
    case nios2_stub_call26_before:
2541
0
    case nios2_stub_call26_after:
2542
0
      hsh->stub_sec->size += 12;
2543
0
      break;
2544
0
    default:
2545
0
      BFD_FAIL ();
2546
0
      return false;
2547
0
    }
2548
0
  return true;
2549
0
}
2550
2551
/* Read in all local syms for all input bfds.
2552
   Returns -1 on error, 0 otherwise.  */
2553
2554
static int
2555
get_local_syms (bfd *output_bfd ATTRIBUTE_UNUSED, bfd *input_bfd,
2556
    struct bfd_link_info *info)
2557
0
{
2558
0
  unsigned int bfd_indx;
2559
0
  Elf_Internal_Sym *local_syms, **all_local_syms;
2560
0
  struct elf32_nios2_link_hash_table *htab = elf32_nios2_hash_table (info);
2561
2562
  /* We want to read in symbol extension records only once.  To do this
2563
     we need to read in the local symbols in parallel and save them for
2564
     later use; so hold pointers to the local symbols in an array.  */
2565
0
  size_t amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
2566
0
  all_local_syms = bfd_zmalloc (amt);
2567
0
  htab->all_local_syms = all_local_syms;
2568
0
  if (all_local_syms == NULL)
2569
0
    return -1;
2570
2571
  /* Walk over all the input BFDs, swapping in local symbols.  */
2572
0
  for (bfd_indx = 0;
2573
0
       input_bfd != NULL;
2574
0
       input_bfd = input_bfd->link.next, bfd_indx++)
2575
0
    {
2576
0
      Elf_Internal_Shdr *symtab_hdr;
2577
2578
      /* We'll need the symbol table in a second.  */
2579
0
      symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2580
0
      if (symtab_hdr->sh_info == 0)
2581
0
  continue;
2582
2583
      /* We need an array of the local symbols attached to the input bfd.  */
2584
0
      local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
2585
0
      if (local_syms == NULL)
2586
0
  {
2587
0
    local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2588
0
               symtab_hdr->sh_info, 0,
2589
0
               NULL, NULL, NULL);
2590
    /* Cache them for elf_link_input_bfd.  */
2591
0
    symtab_hdr->contents = (unsigned char *) local_syms;
2592
0
  }
2593
0
      if (local_syms == NULL)
2594
0
  return -1;
2595
2596
0
      all_local_syms[bfd_indx] = local_syms;
2597
0
    }
2598
2599
0
  return 0;
2600
0
}
2601
2602
/* Determine and set the size of the stub section for a final link.  */
2603
bool
2604
nios2_elf32_size_stubs (bfd *output_bfd, bfd *stub_bfd,
2605
      struct bfd_link_info *info,
2606
      asection *(*add_stub_section) (const char *,
2607
                   asection *, bool),
2608
      void (*layout_sections_again) (void))
2609
0
{
2610
0
  bool stub_changed = false;
2611
0
  struct elf32_nios2_link_hash_table *htab = elf32_nios2_hash_table (info);
2612
2613
  /* Stash our params away.  */
2614
0
  htab->stub_bfd = stub_bfd;
2615
0
  htab->add_stub_section = add_stub_section;
2616
0
  htab->layout_sections_again = layout_sections_again;
2617
2618
  /* FIXME: We only compute the section groups once.  This could cause
2619
     problems if adding a large stub section causes following sections,
2620
     or parts of them, to move into another segment.  However, this seems
2621
     to be consistent with the way other back ends handle this....  */
2622
0
  group_sections (htab);
2623
2624
0
  if (get_local_syms (output_bfd, info->input_bfds, info))
2625
0
    {
2626
0
      if (htab->all_local_syms)
2627
0
  goto error_ret_free_local;
2628
0
      return false;
2629
0
    }
2630
2631
0
  while (1)
2632
0
    {
2633
0
      bfd *input_bfd;
2634
0
      unsigned int bfd_indx;
2635
0
      asection *stub_sec;
2636
2637
0
      for (input_bfd = info->input_bfds, bfd_indx = 0;
2638
0
     input_bfd != NULL;
2639
0
     input_bfd = input_bfd->link.next, bfd_indx++)
2640
0
  {
2641
0
    Elf_Internal_Shdr *symtab_hdr;
2642
0
    asection *section;
2643
0
    Elf_Internal_Sym *local_syms;
2644
2645
    /* We'll need the symbol table in a second.  */
2646
0
    symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2647
0
    if (symtab_hdr->sh_info == 0)
2648
0
      continue;
2649
2650
0
    local_syms = htab->all_local_syms[bfd_indx];
2651
2652
    /* Walk over each section attached to the input bfd.  */
2653
0
    for (section = input_bfd->sections;
2654
0
         section != NULL;
2655
0
         section = section->next)
2656
0
      {
2657
0
        Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
2658
2659
        /* If there aren't any relocs, then there's nothing more
2660
     to do.  */
2661
0
        if ((section->flags & SEC_RELOC) == 0
2662
0
      || section->reloc_count == 0)
2663
0
    continue;
2664
2665
        /* If this section is a link-once section that will be
2666
     discarded, then don't create any stubs.  */
2667
0
        if (section->output_section == NULL
2668
0
      || section->output_section->owner != output_bfd)
2669
0
    continue;
2670
2671
        /* Get the relocs.  */
2672
0
        internal_relocs
2673
0
    = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
2674
0
               info->keep_memory);
2675
0
        if (internal_relocs == NULL)
2676
0
    goto error_ret_free_local;
2677
2678
        /* Now examine each relocation.  */
2679
0
        irela = internal_relocs;
2680
0
        irelaend = irela + section->reloc_count;
2681
0
        for (; irela < irelaend; irela++)
2682
0
    {
2683
0
      unsigned int r_type, r_indx;
2684
0
      enum elf32_nios2_stub_type stub_type;
2685
0
      struct elf32_nios2_stub_hash_entry *hsh;
2686
0
      asection *sym_sec;
2687
0
      bfd_vma sym_value;
2688
0
      bfd_vma destination;
2689
0
      struct elf32_nios2_link_hash_entry *hh;
2690
0
      char *stub_name;
2691
0
      const asection *id_sec;
2692
2693
0
      r_type = ELF32_R_TYPE (irela->r_info);
2694
0
      r_indx = ELF32_R_SYM (irela->r_info);
2695
2696
0
      if (r_type >= (unsigned int) R_NIOS2_ILLEGAL)
2697
0
        {
2698
0
          bfd_set_error (bfd_error_bad_value);
2699
0
        error_ret_free_internal:
2700
0
          if (elf_section_data (section)->relocs == NULL)
2701
0
      free (internal_relocs);
2702
0
          goto error_ret_free_local;
2703
0
        }
2704
2705
      /* Only look for stubs on CALL and JMPI instructions.  */
2706
0
      if (r_type != (unsigned int) R_NIOS2_CALL26)
2707
0
        continue;
2708
2709
      /* Now determine the call target, its name, value,
2710
         section.  */
2711
0
      sym_sec = NULL;
2712
0
      sym_value = 0;
2713
0
      destination = 0;
2714
0
      hh = NULL;
2715
0
      if (r_indx < symtab_hdr->sh_info)
2716
0
        {
2717
          /* It's a local symbol.  */
2718
0
          Elf_Internal_Sym *sym;
2719
0
          Elf_Internal_Shdr *hdr;
2720
0
          unsigned int shndx;
2721
2722
0
          sym = local_syms + r_indx;
2723
0
          if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2724
0
      sym_value = sym->st_value;
2725
0
          shndx = sym->st_shndx;
2726
0
          if (shndx < elf_numsections (input_bfd))
2727
0
      {
2728
0
        hdr = elf_elfsections (input_bfd)[shndx];
2729
0
        sym_sec = hdr->bfd_section;
2730
0
        destination = (sym_value + irela->r_addend
2731
0
           + sym_sec->output_offset
2732
0
           + sym_sec->output_section->vma);
2733
0
      }
2734
0
        }
2735
0
      else
2736
0
        {
2737
          /* It's an external symbol.  */
2738
0
          int e_indx;
2739
2740
0
          e_indx = r_indx - symtab_hdr->sh_info;
2741
0
          hh = ((struct elf32_nios2_link_hash_entry *)
2742
0
          elf_sym_hashes (input_bfd)[e_indx]);
2743
2744
0
          while (hh->root.root.type == bfd_link_hash_indirect
2745
0
           || hh->root.root.type == bfd_link_hash_warning)
2746
0
      hh = ((struct elf32_nios2_link_hash_entry *)
2747
0
            hh->root.root.u.i.link);
2748
2749
0
          if (hh->root.root.type == bfd_link_hash_defined
2750
0
        || hh->root.root.type == bfd_link_hash_defweak)
2751
0
      {
2752
0
        sym_sec = hh->root.root.u.def.section;
2753
0
        sym_value = hh->root.root.u.def.value;
2754
2755
0
        if (sym_sec->output_section != NULL)
2756
0
          destination = (sym_value + irela->r_addend
2757
0
             + sym_sec->output_offset
2758
0
             + sym_sec->output_section->vma);
2759
0
        else
2760
0
          continue;
2761
0
      }
2762
0
          else if (hh->root.root.type == bfd_link_hash_undefweak)
2763
0
      {
2764
0
        if (! bfd_link_pic (info))
2765
0
          continue;
2766
0
      }
2767
0
          else if (hh->root.root.type == bfd_link_hash_undefined)
2768
0
      {
2769
0
        if (! (info->unresolved_syms_in_objects == RM_IGNORE
2770
0
         && (ELF_ST_VISIBILITY (hh->root.other)
2771
0
             == STV_DEFAULT)))
2772
0
          continue;
2773
0
      }
2774
0
          else
2775
0
      {
2776
0
        bfd_set_error (bfd_error_bad_value);
2777
0
        goto error_ret_free_internal;
2778
0
      }
2779
0
        }
2780
2781
      /* Determine what (if any) linker stub is needed.  */
2782
0
      stub_type = nios2_type_of_stub (section, irela, hh, htab,
2783
0
              destination, info);
2784
0
      if (stub_type == nios2_stub_none)
2785
0
        continue;
2786
2787
      /* Support for grouping stub sections.  */
2788
0
      if (stub_type == nios2_stub_call26_before)
2789
0
        id_sec = htab->stub_group[section->id].first_sec;
2790
0
      else
2791
0
        id_sec = htab->stub_group[section->id].last_sec;
2792
2793
      /* Get the name of this stub.  */
2794
0
      stub_name = nios2_stub_name (id_sec, sym_sec, hh, irela,
2795
0
                 stub_type);
2796
0
      if (!stub_name)
2797
0
        goto error_ret_free_internal;
2798
2799
0
      hsh = nios2_stub_hash_lookup (&htab->bstab,
2800
0
            stub_name,
2801
0
            false, false);
2802
0
      if (hsh != NULL)
2803
0
        {
2804
          /* The proper stub has already been created.  */
2805
0
          free (stub_name);
2806
0
          continue;
2807
0
        }
2808
2809
0
      hsh = nios2_add_stub (stub_name, section, htab, stub_type);
2810
0
      if (hsh == NULL)
2811
0
        {
2812
0
          free (stub_name);
2813
0
          goto error_ret_free_internal;
2814
0
        }
2815
0
      hsh->target_value = sym_value;
2816
0
      hsh->target_section = sym_sec;
2817
0
      hsh->stub_type = stub_type;
2818
0
      hsh->hh = hh;
2819
0
      hsh->addend = irela->r_addend;
2820
0
      stub_changed = true;
2821
0
    }
2822
2823
        /* We're done with the internal relocs, free them.  */
2824
0
        if (elf_section_data (section)->relocs == NULL)
2825
0
    free (internal_relocs);
2826
0
      }
2827
0
  }
2828
2829
0
      if (!stub_changed)
2830
0
  break;
2831
2832
      /* OK, we've added some stubs.  Find out the new size of the
2833
   stub sections.  */
2834
0
      for (stub_sec = htab->stub_bfd->sections;
2835
0
     stub_sec != NULL;
2836
0
     stub_sec = stub_sec->next)
2837
0
  stub_sec->size = 0;
2838
2839
0
      bfd_hash_traverse (&htab->bstab, nios2_size_one_stub, htab);
2840
2841
      /* Ask the linker to do its stuff.  */
2842
0
      (*htab->layout_sections_again) ();
2843
0
      stub_changed = false;
2844
0
    }
2845
2846
0
  free (htab->all_local_syms);
2847
0
  return true;
2848
2849
0
 error_ret_free_local:
2850
0
  free (htab->all_local_syms);
2851
0
  return false;
2852
0
}
2853
2854
/* Build all the stubs associated with the current output file.  The
2855
   stubs are kept in a hash table attached to the main linker hash
2856
   table.  This function is called via nios2elf_finish in the linker.  */
2857
bool
2858
nios2_elf32_build_stubs (struct bfd_link_info *info)
2859
0
{
2860
0
  asection *stub_sec;
2861
0
  struct bfd_hash_table *table;
2862
0
  struct elf32_nios2_link_hash_table *htab;
2863
2864
0
  htab = elf32_nios2_hash_table (info);
2865
2866
0
  for (stub_sec = htab->stub_bfd->sections;
2867
0
       stub_sec != NULL;
2868
0
       stub_sec = stub_sec->next)
2869
    /* The stub_bfd may contain non-stub sections if it is also the
2870
       dynobj.  Any such non-stub sections are created with the
2871
       SEC_LINKER_CREATED flag set, while stub sections do not
2872
       have that flag.  Ignore any non-stub sections here.  */
2873
0
    if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
2874
0
      {
2875
0
  bfd_size_type size;
2876
2877
  /* Allocate memory to hold the linker stubs.  */
2878
0
  size = stub_sec->size;
2879
0
  stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
2880
0
  if (stub_sec->contents == NULL && size != 0)
2881
0
    return false;
2882
0
  stub_sec->size = 0;
2883
0
      }
2884
2885
  /* Build the stubs as directed by the stub hash table.  */
2886
0
  table = &htab->bstab;
2887
0
  bfd_hash_traverse (table, nios2_build_one_stub, info);
2888
2889
0
  return true;
2890
0
}
2891
2892
2893
#define is_nios2_elf(bfd) \
2894
0
  (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2895
0
   && elf_object_id (bfd) == NIOS2_ELF_DATA)
2896
2897
/* Merge backend specific data from an object file to the output
2898
   object file when linking.  */
2899
2900
static bool
2901
nios2_elf32_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
2902
0
{
2903
0
  bfd *obfd = info->output_bfd;
2904
0
  flagword old_flags;
2905
0
  flagword new_flags;
2906
2907
0
  if (!is_nios2_elf (ibfd) || !is_nios2_elf (obfd))
2908
0
    return true;
2909
2910
  /* Check if we have the same endianness.  */
2911
0
  if (! _bfd_generic_verify_endian_match (ibfd, info))
2912
0
    return false;
2913
2914
0
  new_flags = elf_elfheader (ibfd)->e_flags;
2915
0
  old_flags = elf_elfheader (obfd)->e_flags;
2916
0
  if (!elf_flags_init (obfd))
2917
0
    {
2918
      /* First call, no flags set.  */
2919
0
      elf_flags_init (obfd) = true;
2920
0
      elf_elfheader (obfd)->e_flags = new_flags;
2921
2922
0
      switch (new_flags)
2923
0
  {
2924
0
  default:
2925
0
  case EF_NIOS2_ARCH_R1:
2926
0
    bfd_default_set_arch_mach (obfd, bfd_arch_nios2, bfd_mach_nios2r1);
2927
0
    break;
2928
0
  case EF_NIOS2_ARCH_R2:
2929
0
    if (bfd_big_endian (ibfd))
2930
0
      {
2931
0
        _bfd_error_handler
2932
0
    (_("error: %pB: big-endian R2 is not supported"), ibfd);
2933
0
        bfd_set_error (bfd_error_bad_value);
2934
0
        return false;
2935
0
      }
2936
0
    bfd_default_set_arch_mach (obfd, bfd_arch_nios2, bfd_mach_nios2r2);
2937
0
    break;
2938
0
  }
2939
0
    }
2940
2941
  /* Incompatible flags.  */
2942
0
  else if (new_flags != old_flags)
2943
0
    {
2944
      /* So far, the only incompatible flags denote incompatible
2945
   architectures.  */
2946
0
      _bfd_error_handler
2947
  /* xgettext:c-format */
2948
0
  (_("error: %pB: conflicting CPU architectures %d/%d"),
2949
0
   ibfd, new_flags, old_flags);
2950
0
      bfd_set_error (bfd_error_bad_value);
2951
0
      return false;
2952
0
    }
2953
2954
  /* Merge Tag_compatibility attributes and any common GNU ones.  */
2955
0
  _bfd_elf_merge_object_attributes (ibfd, info);
2956
2957
0
  return true;
2958
0
}
2959
2960
/* Implement bfd_elf32_bfd_reloc_type_lookup:
2961
   Given a BFD reloc type, return a howto structure.  */
2962
2963
static reloc_howto_type *
2964
nios2_elf32_bfd_reloc_type_lookup (bfd *abfd,
2965
           bfd_reloc_code_real_type code)
2966
0
{
2967
0
  int i;
2968
2969
0
  for (i = 0; i < (int) ARRAY_SIZE (nios2_reloc_map); ++i)
2970
0
    if (nios2_reloc_map[i].bfd_val == code)
2971
0
      return lookup_howto (nios2_reloc_map[i].elf_val, abfd);
2972
0
  return NULL;
2973
0
}
2974
2975
/* Implement bfd_elf32_bfd_reloc_name_lookup:
2976
   Given a reloc name, return a howto structure.  */
2977
2978
static reloc_howto_type *
2979
nios2_elf32_bfd_reloc_name_lookup (bfd *abfd,
2980
           const char *r_name)
2981
0
{
2982
0
  int i;
2983
0
  reloc_howto_type *howto_tbl;
2984
0
  int howto_tbl_size;
2985
2986
0
  if (BFD_IS_R2 (abfd))
2987
0
    {
2988
0
      howto_tbl = elf_nios2_r2_howto_table_rel;
2989
0
      howto_tbl_size = (int) ARRAY_SIZE (elf_nios2_r2_howto_table_rel);
2990
0
    }
2991
0
  else
2992
0
    {
2993
0
      howto_tbl = elf_nios2_r1_howto_table_rel;
2994
0
      howto_tbl_size = (int) ARRAY_SIZE (elf_nios2_r1_howto_table_rel);
2995
0
    }
2996
2997
0
  for (i = 0; i < howto_tbl_size; i++)
2998
0
    if (howto_tbl[i].name && strcasecmp (howto_tbl[i].name, r_name) == 0)
2999
0
      return howto_tbl + i;
3000
3001
0
  return NULL;
3002
0
}
3003
3004
/* Implement elf_info_to_howto:
3005
   Given a ELF32 relocation, fill in a arelent structure.  */
3006
3007
static bool
3008
nios2_elf32_info_to_howto (bfd *abfd, arelent *cache_ptr,
3009
         Elf_Internal_Rela *dst)
3010
0
{
3011
0
  unsigned int r_type;
3012
3013
0
  r_type = ELF32_R_TYPE (dst->r_info);
3014
0
  if ((cache_ptr->howto = lookup_howto (r_type, abfd)) == NULL)
3015
0
    {
3016
      /* xgettext:c-format */
3017
0
      _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
3018
0
        abfd, r_type);
3019
0
      bfd_set_error (bfd_error_bad_value);
3020
0
      return false;
3021
0
    }
3022
0
  return true;
3023
0
}
3024
3025
/* Return the base VMA address which should be subtracted from real addresses
3026
   when resolving @dtpoff relocation.
3027
   This is PT_TLS segment p_vaddr.  */
3028
static bfd_vma
3029
dtpoff_base (struct bfd_link_info *info)
3030
0
{
3031
  /* If tls_sec is NULL, we should have signalled an error already.  */
3032
0
  if (elf_hash_table (info)->tls_sec == NULL)
3033
0
    return 0;
3034
0
  return elf_hash_table (info)->tls_sec->vma;
3035
0
}
3036
3037
/* Return the relocation value for @tpoff relocation
3038
   if STT_TLS virtual address is ADDRESS.  */
3039
static bfd_vma
3040
tpoff (struct bfd_link_info *info, bfd_vma address)
3041
0
{
3042
0
  struct elf_link_hash_table *htab = elf_hash_table (info);
3043
3044
  /* If tls_sec is NULL, we should have signalled an error already.  */
3045
0
  if (htab->tls_sec == NULL)
3046
0
    return 0;
3047
0
  return address - htab->tls_sec->vma;
3048
0
}
3049
3050
/* Set the GP value for OUTPUT_BFD.  Returns FALSE if this is a
3051
   dangerous relocation.  */
3052
static bool
3053
nios2_elf_assign_gp (bfd *output_bfd, bfd_vma *pgp, struct bfd_link_info *info)
3054
0
{
3055
3056
0
  bool gp_found;
3057
0
  struct bfd_hash_entry *h;
3058
0
  struct bfd_link_hash_entry *lh;
3059
3060
  /* If we've already figured out what GP will be, just return it. */
3061
0
  *pgp = _bfd_get_gp_value (output_bfd);
3062
0
  if (*pgp)
3063
0
    return true;
3064
3065
0
  h = bfd_hash_lookup (&info->hash->table, "_gp", false, false);
3066
0
  lh = (struct bfd_link_hash_entry *) h;
3067
0
 lookup:
3068
0
  if (lh)
3069
0
    {
3070
0
      switch (lh->type)
3071
0
  {
3072
0
  case bfd_link_hash_undefined:
3073
0
  case bfd_link_hash_undefweak:
3074
0
  case bfd_link_hash_common:
3075
0
    gp_found = false;
3076
0
    break;
3077
0
  case bfd_link_hash_defined:
3078
0
  case bfd_link_hash_defweak:
3079
0
    gp_found = true;
3080
0
    {
3081
0
      asection *sym_sec = lh->u.def.section;
3082
0
      bfd_vma sym_value = lh->u.def.value;
3083
3084
0
      if (sym_sec->output_section)
3085
0
        sym_value = (sym_value + sym_sec->output_offset
3086
0
         + sym_sec->output_section->vma);
3087
0
      *pgp = sym_value;
3088
0
    }
3089
0
    break;
3090
0
  case bfd_link_hash_indirect:
3091
0
  case bfd_link_hash_warning:
3092
0
    lh = lh->u.i.link;
3093
    /* @@FIXME  ignoring warning for now */
3094
0
    goto lookup;
3095
0
  case bfd_link_hash_new:
3096
0
  default:
3097
0
    abort ();
3098
0
  }
3099
0
    }
3100
0
  else
3101
0
    gp_found = false;
3102
3103
0
  if (!gp_found)
3104
0
    {
3105
      /* Only get the error once. */
3106
0
      *pgp = 4;
3107
0
      _bfd_set_gp_value (output_bfd, *pgp);
3108
0
      return false;
3109
0
    }
3110
3111
0
  _bfd_set_gp_value (output_bfd, *pgp);
3112
3113
0
  return true;
3114
0
}
3115
3116
/* Retrieve the previously cached _gp pointer, returning bfd_reloc_dangerous
3117
   if it's not available as we don't have a link_info pointer available here
3118
   to look it up in the output symbol table.  We don't need to adjust the
3119
   symbol value for an external symbol if we are producing relocatable
3120
   output.  */
3121
static bfd_reloc_status_type
3122
nios2_elf_final_gp (bfd *output_bfd, asymbol *symbol, bool relocatable,
3123
        char **error_message, bfd_vma *pgp)
3124
0
{
3125
0
  if (bfd_is_und_section (symbol->section) && !relocatable)
3126
0
    {
3127
0
      *pgp = 0;
3128
0
      return bfd_reloc_undefined;
3129
0
    }
3130
3131
0
  *pgp = _bfd_get_gp_value (output_bfd);
3132
0
  if (*pgp == 0 && (!relocatable || (symbol->flags & BSF_SECTION_SYM) != 0))
3133
0
    {
3134
0
      if (relocatable)
3135
0
  {
3136
    /* Make up a value.  */
3137
0
    *pgp = symbol->section->output_section->vma + 0x4000;
3138
0
    _bfd_set_gp_value (output_bfd, *pgp);
3139
0
  }
3140
0
      else
3141
0
  {
3142
0
    *error_message
3143
0
      = (char *) _("global pointer relative relocation when _gp not defined");
3144
0
    return bfd_reloc_dangerous;
3145
0
  }
3146
0
    }
3147
3148
0
  return bfd_reloc_ok;
3149
0
}
3150
3151
/* Do the relocations that require special handling.  */
3152
static bfd_reloc_status_type
3153
nios2_elf32_do_hi16_relocate (bfd *abfd, reloc_howto_type *howto,
3154
            asection *input_section,
3155
            bfd_byte *data, bfd_vma offset,
3156
            bfd_vma symbol_value, bfd_vma addend)
3157
0
{
3158
0
  symbol_value = symbol_value + addend;
3159
0
  addend = 0;
3160
0
  symbol_value = (symbol_value >> 16) & 0xffff;
3161
0
  return _bfd_final_link_relocate (howto, abfd, input_section,
3162
0
           data, offset, symbol_value, addend);
3163
0
}
3164
3165
static bfd_reloc_status_type
3166
nios2_elf32_do_lo16_relocate (bfd *abfd, reloc_howto_type *howto,
3167
            asection *input_section,
3168
            bfd_byte *data, bfd_vma offset,
3169
            bfd_vma symbol_value, bfd_vma addend)
3170
0
{
3171
0
  symbol_value = symbol_value + addend;
3172
0
  addend = 0;
3173
0
  symbol_value = symbol_value & 0xffff;
3174
0
  return _bfd_final_link_relocate (howto, abfd, input_section,
3175
0
           data, offset, symbol_value, addend);
3176
0
}
3177
3178
static bfd_reloc_status_type
3179
nios2_elf32_do_hiadj16_relocate (bfd *abfd, reloc_howto_type *howto,
3180
         asection *input_section,
3181
         bfd_byte *data, bfd_vma offset,
3182
         bfd_vma symbol_value, bfd_vma addend)
3183
0
{
3184
0
  symbol_value = symbol_value + addend;
3185
0
  addend = 0;
3186
0
  symbol_value = hiadj(symbol_value);
3187
0
  return _bfd_final_link_relocate (howto, abfd, input_section, data, offset,
3188
0
           symbol_value, addend);
3189
0
}
3190
3191
static bfd_reloc_status_type
3192
nios2_elf32_do_pcrel_lo16_relocate (bfd *abfd, reloc_howto_type *howto,
3193
            asection *input_section,
3194
            bfd_byte *data, bfd_vma offset,
3195
            bfd_vma symbol_value, bfd_vma addend)
3196
0
{
3197
0
  symbol_value = symbol_value + addend;
3198
0
  addend = 0;
3199
0
  symbol_value = symbol_value & 0xffff;
3200
0
  return _bfd_final_link_relocate (howto, abfd, input_section,
3201
0
           data, offset, symbol_value, addend);
3202
0
}
3203
3204
static bfd_reloc_status_type
3205
nios2_elf32_do_pcrel_hiadj16_relocate (bfd *abfd, reloc_howto_type *howto,
3206
               asection *input_section,
3207
               bfd_byte *data, bfd_vma offset,
3208
               bfd_vma symbol_value, bfd_vma addend)
3209
0
{
3210
0
  symbol_value = symbol_value + addend;
3211
0
  symbol_value -= (input_section->output_section->vma
3212
0
       + input_section->output_offset);
3213
0
  symbol_value -= offset;
3214
0
  addend = 0;
3215
0
  symbol_value = hiadj(symbol_value);
3216
0
  return _bfd_final_link_relocate (howto, abfd, input_section, data, offset,
3217
0
           symbol_value, addend);
3218
0
}
3219
3220
static bfd_reloc_status_type
3221
nios2_elf32_do_pcrel16_relocate (bfd *abfd, reloc_howto_type *howto,
3222
         asection *input_section,
3223
         bfd_byte *data, bfd_vma offset,
3224
         bfd_vma symbol_value, bfd_vma addend)
3225
0
{
3226
  /* NIOS2 pc relative relocations are relative to the next 32-bit instruction
3227
     so we need to subtract 4 before doing a final_link_relocate. */
3228
0
  symbol_value = symbol_value + addend - 4;
3229
0
  addend = 0;
3230
0
  return _bfd_final_link_relocate (howto, abfd, input_section,
3231
0
           data, offset, symbol_value, addend);
3232
0
}
3233
3234
static bfd_reloc_status_type
3235
nios2_elf32_do_call26_relocate (bfd *abfd, reloc_howto_type *howto,
3236
        asection *input_section,
3237
        bfd_byte *data, bfd_vma offset,
3238
        bfd_vma symbol_value, bfd_vma addend)
3239
0
{
3240
  /* Check that the relocation is in the same page as the current address.  */
3241
0
  if (CALL26_SEGMENT (symbol_value + addend)
3242
0
      != CALL26_SEGMENT (input_section->output_section->vma
3243
0
       + input_section->output_offset
3244
0
       + offset))
3245
0
    return bfd_reloc_overflow;
3246
3247
  /* Check that the target address is correctly aligned on a 4-byte
3248
     boundary.  */
3249
0
  if ((symbol_value + addend) & 0x3)
3250
0
    return bfd_reloc_overflow;
3251
3252
0
  return _bfd_final_link_relocate (howto, abfd, input_section,
3253
0
           data, offset, symbol_value, addend);
3254
0
}
3255
3256
static bfd_reloc_status_type
3257
nios2_elf32_do_gprel_relocate (bfd *abfd, reloc_howto_type *howto,
3258
             asection *input_section,
3259
             bfd_byte *data, bfd_vma offset,
3260
             bfd_vma symbol_value, bfd_vma addend)
3261
0
{
3262
  /* Because we need the output_bfd, the special handling is done
3263
     in nios2_elf32_relocate_section or in nios2_elf32_gprel_relocate.  */
3264
0
  return _bfd_final_link_relocate (howto, abfd, input_section,
3265
0
           data, offset, symbol_value, addend);
3266
0
}
3267
3268
static bfd_reloc_status_type
3269
nios2_elf32_do_ujmp_relocate (bfd *abfd, reloc_howto_type *howto,
3270
            asection *input_section,
3271
            bfd_byte *data, bfd_vma offset,
3272
            bfd_vma symbol_value, bfd_vma addend)
3273
0
{
3274
0
  bfd_vma symbol_lo16, symbol_hi16;
3275
0
  bfd_reloc_status_type r;
3276
0
  symbol_value = symbol_value + addend;
3277
0
  addend = 0;
3278
0
  symbol_hi16 = (symbol_value >> 16) & 0xffff;
3279
0
  symbol_lo16 = symbol_value & 0xffff;
3280
3281
0
  r = _bfd_final_link_relocate (howto, abfd, input_section,
3282
0
        data, offset, symbol_hi16, addend);
3283
3284
0
  if (r == bfd_reloc_ok)
3285
0
    return _bfd_final_link_relocate (howto, abfd, input_section,
3286
0
             data, offset + 4, symbol_lo16, addend);
3287
3288
0
  return r;
3289
0
}
3290
3291
static bfd_reloc_status_type
3292
nios2_elf32_do_cjmp_relocate (bfd *abfd, reloc_howto_type *howto,
3293
            asection *input_section,
3294
            bfd_byte *data, bfd_vma offset,
3295
            bfd_vma symbol_value, bfd_vma addend)
3296
0
{
3297
0
  bfd_vma symbol_lo16, symbol_hi16;
3298
0
  bfd_reloc_status_type r;
3299
0
  symbol_value = symbol_value + addend;
3300
0
  addend = 0;
3301
0
  symbol_hi16 = (symbol_value >> 16) & 0xffff;
3302
0
  symbol_lo16 = symbol_value & 0xffff;
3303
3304
0
  r = _bfd_final_link_relocate (howto, abfd, input_section,
3305
0
        data, offset, symbol_hi16, addend);
3306
3307
0
  if (r == bfd_reloc_ok)
3308
0
    return _bfd_final_link_relocate (howto, abfd, input_section,
3309
0
             data, offset + 4, symbol_lo16, addend);
3310
3311
0
  return r;
3312
0
}
3313
3314
static bfd_reloc_status_type
3315
nios2_elf32_do_callr_relocate (bfd *abfd, reloc_howto_type *howto,
3316
             asection *input_section,
3317
             bfd_byte *data, bfd_vma offset,
3318
             bfd_vma symbol_value, bfd_vma addend)
3319
0
{
3320
0
  bfd_vma symbol_lo16, symbol_hi16;
3321
0
  bfd_reloc_status_type r;
3322
0
  symbol_value = symbol_value + addend;
3323
0
  addend = 0;
3324
0
  symbol_hi16 = (symbol_value >> 16) & 0xffff;
3325
0
  symbol_lo16 = symbol_value & 0xffff;
3326
3327
0
  r = _bfd_final_link_relocate (howto, abfd, input_section,
3328
0
        data, offset, symbol_hi16, addend);
3329
3330
0
  if (r == bfd_reloc_ok)
3331
0
    return _bfd_final_link_relocate (howto, abfd, input_section,
3332
0
             data, offset + 4, symbol_lo16, addend);
3333
3334
0
  return r;
3335
0
}
3336
3337
/* HOWTO handlers for relocations that require special handling.  */
3338
3339
/* This is for relocations used only when relaxing to ensure
3340
   changes in size of section don't screw up .align.  */
3341
static bfd_reloc_status_type
3342
nios2_elf32_ignore_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
3343
        asymbol *symbol ATTRIBUTE_UNUSED,
3344
        void *data ATTRIBUTE_UNUSED, asection *input_section,
3345
        bfd *output_bfd,
3346
        char **error_message ATTRIBUTE_UNUSED)
3347
0
{
3348
0
  if (output_bfd != NULL)
3349
0
    reloc_entry->address += input_section->output_offset;
3350
0
  return bfd_reloc_ok;
3351
0
}
3352
3353
static bfd_reloc_status_type
3354
nios2_elf32_hi16_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3355
         void *data, asection *input_section,
3356
         bfd *output_bfd,
3357
         char **error_message ATTRIBUTE_UNUSED)
3358
0
{
3359
  /* This part is from bfd_elf_generic_reloc.  */
3360
0
  if (output_bfd != NULL
3361
0
      && (symbol->flags & BSF_SECTION_SYM) == 0
3362
0
      && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3363
0
    {
3364
0
      reloc_entry->address += input_section->output_offset;
3365
0
      return bfd_reloc_ok;
3366
0
    }
3367
3368
0
  if (output_bfd != NULL)
3369
    /* FIXME: See bfd_perform_relocation.  Is this right?  */
3370
0
    return bfd_reloc_continue;
3371
3372
0
  return nios2_elf32_do_hi16_relocate (abfd, reloc_entry->howto,
3373
0
               input_section,
3374
0
               data, reloc_entry->address,
3375
0
               (symbol->value
3376
0
          + symbol->section->output_section->vma
3377
0
          + symbol->section->output_offset),
3378
0
               reloc_entry->addend);
3379
0
}
3380
3381
static bfd_reloc_status_type
3382
nios2_elf32_lo16_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3383
         void *data, asection *input_section,
3384
         bfd *output_bfd,
3385
         char **error_message ATTRIBUTE_UNUSED)
3386
0
{
3387
  /* This part is from bfd_elf_generic_reloc.  */
3388
0
  if (output_bfd != NULL
3389
0
      && (symbol->flags & BSF_SECTION_SYM) == 0
3390
0
      && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3391
0
    {
3392
0
      reloc_entry->address += input_section->output_offset;
3393
0
      return bfd_reloc_ok;
3394
0
    }
3395
3396
0
  if (output_bfd != NULL)
3397
    /* FIXME: See bfd_perform_relocation.  Is this right?  */
3398
0
    return bfd_reloc_continue;
3399
3400
0
  return nios2_elf32_do_lo16_relocate (abfd, reloc_entry->howto,
3401
0
               input_section,
3402
0
               data, reloc_entry->address,
3403
0
               (symbol->value
3404
0
          + symbol->section->output_section->vma
3405
0
          + symbol->section->output_offset),
3406
0
               reloc_entry->addend);
3407
0
}
3408
3409
static bfd_reloc_status_type
3410
nios2_elf32_hiadj16_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3411
            void *data, asection *input_section,
3412
            bfd *output_bfd,
3413
            char **error_message ATTRIBUTE_UNUSED)
3414
0
{
3415
  /* This part is from bfd_elf_generic_reloc.  */
3416
0
  if (output_bfd != NULL
3417
0
      && (symbol->flags & BSF_SECTION_SYM) == 0
3418
0
      && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3419
0
    {
3420
0
      reloc_entry->address += input_section->output_offset;
3421
0
      return bfd_reloc_ok;
3422
0
    }
3423
3424
0
  if (output_bfd != NULL)
3425
    /* FIXME: See bfd_perform_relocation.  Is this right?  */
3426
0
    return bfd_reloc_continue;
3427
3428
0
  return nios2_elf32_do_hiadj16_relocate (abfd, reloc_entry->howto,
3429
0
            input_section,
3430
0
            data, reloc_entry->address,
3431
0
            (symbol->value
3432
0
             + symbol->section->output_section->vma
3433
0
             + symbol->section->output_offset),
3434
0
            reloc_entry->addend);
3435
0
}
3436
3437
static bfd_reloc_status_type
3438
nios2_elf32_pcrel_lo16_relocate (bfd *abfd, arelent *reloc_entry,
3439
         asymbol *symbol, void *data,
3440
         asection *input_section, bfd *output_bfd,
3441
         char **error_message ATTRIBUTE_UNUSED)
3442
0
{
3443
  /* This part is from bfd_elf_generic_reloc.  */
3444
0
  if (output_bfd != NULL
3445
0
      && (symbol->flags & BSF_SECTION_SYM) == 0
3446
0
      && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3447
0
    {
3448
0
      reloc_entry->address += input_section->output_offset;
3449
0
      return bfd_reloc_ok;
3450
0
    }
3451
3452
0
  if (output_bfd != NULL)
3453
    /* FIXME: See bfd_perform_relocation.  Is this right?  */
3454
0
    return bfd_reloc_continue;
3455
3456
0
  return nios2_elf32_do_pcrel_lo16_relocate (
3457
0
    abfd, reloc_entry->howto, input_section, data, reloc_entry->address,
3458
0
    (symbol->value + symbol->section->output_section->vma
3459
0
     + symbol->section->output_offset),
3460
0
    reloc_entry->addend);
3461
0
}
3462
3463
static bfd_reloc_status_type
3464
nios2_elf32_pcrel_hiadj16_relocate (bfd *abfd, arelent *reloc_entry,
3465
            asymbol *symbol, void *data,
3466
            asection *input_section, bfd *output_bfd,
3467
            char **error_message ATTRIBUTE_UNUSED)
3468
0
{
3469
  /* This part is from bfd_elf_generic_reloc.  */
3470
0
  if (output_bfd != NULL
3471
0
      && (symbol->flags & BSF_SECTION_SYM) == 0
3472
0
      && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3473
0
    {
3474
0
      reloc_entry->address += input_section->output_offset;
3475
0
      return bfd_reloc_ok;
3476
0
    }
3477
3478
0
  if (output_bfd != NULL)
3479
    /* FIXME: See bfd_perform_relocation.  Is this right?  */
3480
0
    return bfd_reloc_continue;
3481
3482
0
  return nios2_elf32_do_pcrel_hiadj16_relocate (
3483
0
    abfd, reloc_entry->howto, input_section, data, reloc_entry->address,
3484
0
    (symbol->value + symbol->section->output_section->vma
3485
0
     + symbol->section->output_offset),
3486
0
    reloc_entry->addend);
3487
0
}
3488
3489
static bfd_reloc_status_type
3490
nios2_elf32_pcrel16_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3491
            void *data, asection *input_section,
3492
            bfd *output_bfd,
3493
            char **error_message ATTRIBUTE_UNUSED)
3494
0
{
3495
  /* This part is from bfd_elf_generic_reloc.  */
3496
0
  if (output_bfd != NULL
3497
0
      && (symbol->flags & BSF_SECTION_SYM) == 0
3498
0
      && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3499
0
    {
3500
0
      reloc_entry->address += input_section->output_offset;
3501
0
      return bfd_reloc_ok;
3502
0
    }
3503
3504
0
  if (output_bfd != NULL)
3505
    /* FIXME: See bfd_perform_relocation.  Is this right?  */
3506
0
    return bfd_reloc_continue;
3507
3508
0
  return nios2_elf32_do_pcrel16_relocate (abfd, reloc_entry->howto,
3509
0
            input_section,
3510
0
            data, reloc_entry->address,
3511
0
            (symbol->value
3512
0
             + symbol->section->output_section->vma
3513
0
             + symbol->section->output_offset),
3514
0
            reloc_entry->addend);
3515
0
}
3516
3517
static bfd_reloc_status_type
3518
nios2_elf32_call26_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3519
           void *data, asection *input_section,
3520
           bfd *output_bfd,
3521
           char **error_message ATTRIBUTE_UNUSED)
3522
0
{
3523
  /* This part is from bfd_elf_generic_reloc.  */
3524
0
  if (output_bfd != NULL
3525
0
      && (symbol->flags & BSF_SECTION_SYM) == 0
3526
0
      && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3527
0
    {
3528
0
      reloc_entry->address += input_section->output_offset;
3529
0
      return bfd_reloc_ok;
3530
0
    }
3531
3532
0
  if (output_bfd != NULL)
3533
    /* FIXME: See bfd_perform_relocation.  Is this right?  */
3534
0
    return bfd_reloc_continue;
3535
3536
0
  return nios2_elf32_do_call26_relocate (abfd, reloc_entry->howto,
3537
0
           input_section,
3538
0
           data, reloc_entry->address,
3539
0
           (symbol->value
3540
0
            + symbol->section->output_section->vma
3541
0
            + symbol->section->output_offset),
3542
0
           reloc_entry->addend);
3543
0
}
3544
3545
static bfd_reloc_status_type
3546
nios2_elf32_gprel_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3547
          void *data, asection *input_section,
3548
          bfd *output_bfd, char **msg)
3549
0
{
3550
0
  bfd_vma relocation;
3551
0
  bfd_vma gp;
3552
0
  bfd_reloc_status_type r;
3553
3554
3555
  /* This part is from bfd_elf_generic_reloc.  */
3556
0
  if (output_bfd != NULL
3557
0
      && (symbol->flags & BSF_SECTION_SYM) == 0
3558
0
      && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3559
0
    {
3560
0
      reloc_entry->address += input_section->output_offset;
3561
0
      return bfd_reloc_ok;
3562
0
    }
3563
3564
0
  if (output_bfd != NULL)
3565
    /* FIXME: See bfd_perform_relocation.  Is this right?  */
3566
0
    return bfd_reloc_continue;
3567
3568
0
  relocation = (symbol->value
3569
0
    + symbol->section->output_section->vma
3570
0
    + symbol->section->output_offset);
3571
3572
  /* This assumes we've already cached the _gp symbol.  */
3573
0
  r = nios2_elf_final_gp (abfd, symbol, false, msg, &gp);
3574
0
  if (r == bfd_reloc_ok)
3575
0
    {
3576
0
      relocation = relocation + reloc_entry->addend - gp;
3577
0
      reloc_entry->addend = 0;
3578
0
      if ((signed) relocation < -32768 || (signed) relocation > 32767)
3579
0
  {
3580
0
    *msg = _("global pointer relative address out of range");
3581
0
    r = bfd_reloc_outofrange;
3582
0
  }
3583
0
      else
3584
0
  r = nios2_elf32_do_gprel_relocate (abfd, reloc_entry->howto,
3585
0
             input_section,
3586
0
             data, reloc_entry->address,
3587
0
             relocation, reloc_entry->addend);
3588
0
    }
3589
3590
0
  return r;
3591
0
}
3592
3593
static bfd_reloc_status_type
3594
nios2_elf32_ujmp_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3595
         void *data, asection *input_section,
3596
         bfd *output_bfd, char **msg ATTRIBUTE_UNUSED)
3597
0
{
3598
  /* This part is from bfd_elf_generic_reloc.  */
3599
0
  if (output_bfd != NULL
3600
0
      && (symbol->flags & BSF_SECTION_SYM) == 0
3601
0
      && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3602
0
    {
3603
0
      reloc_entry->address += input_section->output_offset;
3604
0
      return bfd_reloc_ok;
3605
0
    }
3606
3607
0
  if (output_bfd != NULL)
3608
    /* FIXME: See bfd_perform_relocation.  Is this right?  */
3609
0
    return bfd_reloc_continue;
3610
3611
0
  return nios2_elf32_do_ujmp_relocate (abfd, reloc_entry->howto,
3612
0
               input_section,
3613
0
               data, reloc_entry->address,
3614
0
               (symbol->value
3615
0
          + symbol->section->output_section->vma
3616
0
          + symbol->section->output_offset),
3617
0
               reloc_entry->addend);
3618
0
}
3619
3620
static bfd_reloc_status_type
3621
nios2_elf32_cjmp_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3622
         void *data, asection *input_section,
3623
         bfd *output_bfd, char **msg ATTRIBUTE_UNUSED)
3624
0
{
3625
  /* This part is from bfd_elf_generic_reloc.  */
3626
0
  if (output_bfd != NULL
3627
0
      && (symbol->flags & BSF_SECTION_SYM) == 0
3628
0
      && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3629
0
    {
3630
0
      reloc_entry->address += input_section->output_offset;
3631
0
      return bfd_reloc_ok;
3632
0
    }
3633
3634
0
  if (output_bfd != NULL)
3635
    /* FIXME: See bfd_perform_relocation.  Is this right?  */
3636
0
    return bfd_reloc_continue;
3637
3638
0
  return nios2_elf32_do_cjmp_relocate (abfd, reloc_entry->howto,
3639
0
               input_section,
3640
0
               data, reloc_entry->address,
3641
0
               (symbol->value
3642
0
          + symbol->section->output_section->vma
3643
0
          + symbol->section->output_offset),
3644
0
               reloc_entry->addend);
3645
0
}
3646
3647
static bfd_reloc_status_type
3648
nios2_elf32_callr_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3649
          void *data, asection *input_section,
3650
          bfd *output_bfd, char **msg ATTRIBUTE_UNUSED)
3651
0
{
3652
  /* This part is from bfd_elf_generic_reloc.  */
3653
0
  if (output_bfd != NULL
3654
0
      && (symbol->flags & BSF_SECTION_SYM) == 0
3655
0
      && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3656
0
    {
3657
0
      reloc_entry->address += input_section->output_offset;
3658
0
      return bfd_reloc_ok;
3659
0
    }
3660
3661
0
  if (output_bfd != NULL)
3662
    /* FIXME: See bfd_perform_relocation.  Is this right?  */
3663
0
    return bfd_reloc_continue;
3664
3665
0
  return nios2_elf32_do_callr_relocate (abfd, reloc_entry->howto,
3666
0
          input_section,
3667
0
          data, reloc_entry->address,
3668
0
          (symbol->value
3669
0
           + symbol->section->output_section->vma
3670
0
           + symbol->section->output_offset),
3671
0
          reloc_entry->addend);
3672
0
}
3673
3674
3675
/* Implement elf_backend_relocate_section.  */
3676
static int
3677
nios2_elf32_relocate_section (bfd *output_bfd,
3678
            struct bfd_link_info *info,
3679
            bfd *input_bfd,
3680
            asection *input_section,
3681
            bfd_byte *contents,
3682
            Elf_Internal_Rela *relocs,
3683
            Elf_Internal_Sym *local_syms,
3684
            asection **local_sections)
3685
0
{
3686
0
  Elf_Internal_Shdr *symtab_hdr;
3687
0
  struct elf_link_hash_entry **sym_hashes;
3688
0
  Elf_Internal_Rela *rel;
3689
0
  Elf_Internal_Rela *relend;
3690
0
  struct elf32_nios2_link_hash_table *htab;
3691
0
  asection *sgot;
3692
0
  asection *splt;
3693
0
  asection *sreloc = NULL;
3694
0
  bfd_vma *local_got_offsets;
3695
0
  bfd_vma got_base;
3696
3697
0
  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3698
0
  sym_hashes = elf_sym_hashes (input_bfd);
3699
0
  relend = relocs + input_section->reloc_count;
3700
3701
0
  htab = elf32_nios2_hash_table (info);
3702
0
  sgot = htab->root.sgot;
3703
0
  splt = htab->root.splt;
3704
0
  local_got_offsets = elf_local_got_offsets (input_bfd);
3705
3706
0
  if (htab->h_gp_got == NULL)
3707
0
    got_base = 0;
3708
0
  else
3709
0
    got_base = htab->h_gp_got->root.u.def.value;
3710
3711
0
  for (rel = relocs; rel < relend; rel++)
3712
0
    {
3713
0
      reloc_howto_type *howto;
3714
0
      unsigned long r_symndx;
3715
0
      Elf_Internal_Sym *sym;
3716
0
      asection *sec;
3717
0
      struct elf_link_hash_entry *h;
3718
0
      struct elf32_nios2_link_hash_entry *eh;
3719
0
      bfd_vma relocation;
3720
0
      bfd_vma gp;
3721
0
      bfd_reloc_status_type r = bfd_reloc_ok;
3722
0
      const char *name = NULL;
3723
0
      int r_type;
3724
0
      const char *format;
3725
0
      char *msg = NULL;
3726
0
      bool unresolved_reloc;
3727
0
      bfd_vma off;
3728
0
      int use_plt;
3729
3730
0
      r_type = ELF32_R_TYPE (rel->r_info);
3731
0
      r_symndx = ELF32_R_SYM (rel->r_info);
3732
3733
0
      howto = lookup_howto ((unsigned) ELF32_R_TYPE (rel->r_info), output_bfd);
3734
0
      h = NULL;
3735
0
      sym = NULL;
3736
0
      sec = NULL;
3737
3738
0
      if (r_symndx < symtab_hdr->sh_info)
3739
0
  {
3740
0
    sym = local_syms + r_symndx;
3741
0
    sec = local_sections[r_symndx];
3742
0
    relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
3743
0
  }
3744
0
      else
3745
0
  {
3746
0
    bool warned, ignored;
3747
3748
0
    RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3749
0
           r_symndx, symtab_hdr, sym_hashes,
3750
0
           h, sec, relocation,
3751
0
           unresolved_reloc, warned, ignored);
3752
0
  }
3753
3754
0
      if (sec && discarded_section (sec))
3755
0
  RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3756
0
           rel, 1, relend, howto, 0, contents);
3757
3758
      /* Nothing more to do unless this is a final link.  */
3759
0
      if (bfd_link_relocatable (info))
3760
0
  continue;
3761
3762
0
      if (howto)
3763
0
  {
3764
0
    bool resolved_to_zero;
3765
3766
0
    resolved_to_zero = (h != NULL
3767
0
            && UNDEFWEAK_NO_DYNAMIC_RELOC (info, h));
3768
0
    switch (howto->type)
3769
0
      {
3770
0
      case R_NIOS2_HI16:
3771
0
        r = nios2_elf32_do_hi16_relocate (input_bfd, howto,
3772
0
            input_section,
3773
0
            contents, rel->r_offset,
3774
0
            relocation, rel->r_addend);
3775
0
        break;
3776
0
      case R_NIOS2_LO16:
3777
0
        r = nios2_elf32_do_lo16_relocate (input_bfd, howto,
3778
0
            input_section,
3779
0
            contents, rel->r_offset,
3780
0
            relocation, rel->r_addend);
3781
0
        break;
3782
0
      case R_NIOS2_PCREL_LO:
3783
0
        r = nios2_elf32_do_pcrel_lo16_relocate (input_bfd, howto,
3784
0
                  input_section,
3785
0
                  contents,
3786
0
                  rel->r_offset,
3787
0
                  relocation,
3788
0
                  rel->r_addend);
3789
0
        break;
3790
0
      case R_NIOS2_HIADJ16:
3791
0
        r = nios2_elf32_do_hiadj16_relocate (input_bfd, howto,
3792
0
               input_section, contents,
3793
0
               rel->r_offset, relocation,
3794
0
               rel->r_addend);
3795
0
        break;
3796
0
      case R_NIOS2_PCREL_HA:
3797
0
        r = nios2_elf32_do_pcrel_hiadj16_relocate (input_bfd, howto,
3798
0
               input_section,
3799
0
               contents,
3800
0
               rel->r_offset,
3801
0
               relocation,
3802
0
               rel->r_addend);
3803
0
        break;
3804
0
      case R_NIOS2_PCREL16:
3805
0
        r = nios2_elf32_do_pcrel16_relocate (input_bfd, howto,
3806
0
               input_section, contents,
3807
0
               rel->r_offset, relocation,
3808
0
               rel->r_addend);
3809
0
        break;
3810
0
      case R_NIOS2_GPREL:
3811
        /* Turns an absolute address into a gp-relative address.  */
3812
0
        if (!nios2_elf_assign_gp (output_bfd, &gp, info))
3813
0
    {
3814
0
      bfd_vma reloc_address;
3815
3816
0
      if (sec && sec->output_section)
3817
0
        reloc_address = (sec->output_section->vma
3818
0
             + sec->output_offset
3819
0
             + rel->r_offset);
3820
0
      else
3821
0
        reloc_address = 0;
3822
3823
0
      format = _("global pointer relative relocation at address "
3824
0
           "%#" PRIx64 " when _gp not defined\n");
3825
0
      msg = bfd_asprintf (format, (uint64_t) reloc_address);
3826
0
      r = bfd_reloc_dangerous;
3827
0
    }
3828
0
        else
3829
0
    {
3830
0
      bfd_vma symbol_address = rel->r_addend + relocation;
3831
0
      relocation = symbol_address - gp;
3832
0
      rel->r_addend = 0;
3833
0
      if (((signed) relocation < -32768
3834
0
           || (signed) relocation > 32767)
3835
0
          && (!h
3836
0
        || h->root.type == bfd_link_hash_defined
3837
0
        || h->root.type == bfd_link_hash_defweak))
3838
0
        {
3839
0
          if (h)
3840
0
      name = h->root.root.string;
3841
0
          else
3842
0
      {
3843
0
        name = (bfd_elf_string_from_elf_section
3844
0
          (input_bfd, symtab_hdr->sh_link,
3845
0
           sym->st_name));
3846
0
        if (name == NULL || *name == '\0')
3847
0
          name = bfd_section_name (sec);
3848
0
      }
3849
          /* xgettext:c-format */
3850
0
          format = _("unable to reach %s (at %#" PRIx64 ") from "
3851
0
         "the global pointer (at %#" PRIx64 ") "
3852
0
         "because the offset (%" PRId64 ") is out of "
3853
0
         "the allowed range, -32678 to 32767\n" );
3854
0
          msg = bfd_asprintf (format, name,
3855
0
            (uint64_t) symbol_address,
3856
0
            (uint64_t) gp,
3857
0
            (int64_t) relocation);
3858
0
          r = bfd_reloc_outofrange;
3859
0
        }
3860
0
      else
3861
0
        r = _bfd_final_link_relocate (howto, input_bfd,
3862
0
              input_section, contents,
3863
0
              rel->r_offset, relocation,
3864
0
              rel->r_addend);
3865
0
    }
3866
0
        break;
3867
0
      case R_NIOS2_UJMP:
3868
0
        r = nios2_elf32_do_ujmp_relocate (input_bfd, howto,
3869
0
            input_section,
3870
0
            contents, rel->r_offset,
3871
0
            relocation, rel->r_addend);
3872
0
        break;
3873
0
      case R_NIOS2_CJMP:
3874
0
        r = nios2_elf32_do_cjmp_relocate (input_bfd, howto,
3875
0
            input_section,
3876
0
            contents, rel->r_offset,
3877
0
            relocation, rel->r_addend);
3878
0
        break;
3879
0
      case R_NIOS2_CALLR:
3880
0
        r = nios2_elf32_do_callr_relocate (input_bfd, howto,
3881
0
             input_section, contents,
3882
0
             rel->r_offset, relocation,
3883
0
             rel->r_addend);
3884
0
        break;
3885
0
      case R_NIOS2_CALL26:
3886
0
      case R_NIOS2_CALL26_NOAT:
3887
        /* If we have a call to an undefined weak symbol, we just want
3888
     to stuff a zero in the bits of the call instruction and
3889
     bypass the normal call26 relocation handling, because it'll
3890
     diagnose an overflow error if address 0 isn't in the same
3891
     256MB segment as the call site.  Presumably the call
3892
     should be guarded by a null check anyway.  */
3893
0
        if (h != NULL && h->root.type == bfd_link_hash_undefweak)
3894
0
    {
3895
0
      BFD_ASSERT (relocation == 0 && rel->r_addend == 0);
3896
0
      r = _bfd_final_link_relocate (howto, input_bfd,
3897
0
            input_section, contents,
3898
0
            rel->r_offset, relocation,
3899
0
            rel->r_addend);
3900
0
      break;
3901
0
    }
3902
        /* Handle relocations which should use the PLT entry.
3903
     NIOS2_BFD_RELOC_32 relocations will use the symbol's value,
3904
     which may point to a PLT entry, but we don't need to handle
3905
     that here.  If we created a PLT entry, all branches in this
3906
     object should go to it.  */
3907
0
        if (h != NULL && splt != NULL && h->plt.offset != (bfd_vma) -1)
3908
0
    {
3909
      /* If we've created a .plt section, and assigned a PLT entry
3910
         to this function, it should not be known to bind locally.
3911
         If it were, we would have cleared the PLT entry.  */
3912
0
      BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info, h));
3913
3914
0
      relocation = (splt->output_section->vma
3915
0
        + splt->output_offset
3916
0
        + h->plt.offset);
3917
3918
0
      unresolved_reloc = false;
3919
0
    }
3920
        /* Detect R_NIOS2_CALL26 relocations that would overflow the
3921
     256MB segment.  Replace the target with a reference to a
3922
     trampoline instead.
3923
     Note that htab->stub_group is null if relaxation has been
3924
     disabled by the --no-relax linker command-line option, so
3925
     we can use that to skip this processing entirely.  */
3926
0
        if (howto->type == R_NIOS2_CALL26 && htab->stub_group)
3927
0
    {
3928
0
      bfd_vma dest = relocation + rel->r_addend;
3929
0
      enum elf32_nios2_stub_type stub_type;
3930
3931
0
      eh = (struct elf32_nios2_link_hash_entry *)h;
3932
0
      stub_type = nios2_type_of_stub (input_section, rel, eh,
3933
0
              htab, dest, NULL);
3934
3935
0
      if (stub_type != nios2_stub_none)
3936
0
        {
3937
0
          struct elf32_nios2_stub_hash_entry *hsh;
3938
3939
0
          hsh = nios2_get_stub_entry (input_section, sec,
3940
0
              eh, rel, htab, stub_type);
3941
0
          if (hsh == NULL)
3942
0
      {
3943
0
        r = bfd_reloc_undefined;
3944
0
        break;
3945
0
      }
3946
3947
0
          dest = (hsh->stub_offset
3948
0
            + hsh->stub_sec->output_offset
3949
0
            + hsh->stub_sec->output_section->vma);
3950
0
          r = nios2_elf32_do_call26_relocate (input_bfd, howto,
3951
0
                input_section,
3952
0
                contents,
3953
0
                rel->r_offset,
3954
0
                dest, 0);
3955
0
          break;
3956
0
        }
3957
0
    }
3958
3959
        /* Normal case.  */
3960
0
        r = nios2_elf32_do_call26_relocate (input_bfd, howto,
3961
0
              input_section, contents,
3962
0
              rel->r_offset, relocation,
3963
0
              rel->r_addend);
3964
0
        break;
3965
0
      case R_NIOS2_ALIGN:
3966
0
        r = bfd_reloc_ok;
3967
        /* For symmetry this would be
3968
     r = nios2_elf32_do_ignore_reloc (input_bfd, howto,
3969
              input_section, contents,
3970
              rel->r_offset, relocation,
3971
              rel->r_addend);
3972
    but do_ignore_reloc would do no more than return
3973
    bfd_reloc_ok. */
3974
0
        break;
3975
3976
0
      case R_NIOS2_GOT16:
3977
0
      case R_NIOS2_CALL16:
3978
0
      case R_NIOS2_GOT_LO:
3979
0
      case R_NIOS2_GOT_HA:
3980
0
      case R_NIOS2_CALL_LO:
3981
0
      case R_NIOS2_CALL_HA:
3982
        /* Relocation is to the entry for this symbol in the
3983
     global offset table.  */
3984
0
        if (sgot == NULL)
3985
0
    {
3986
0
      r = bfd_reloc_notsupported;
3987
0
      break;
3988
0
    }
3989
3990
0
        use_plt = 0;
3991
3992
0
        if (h != NULL)
3993
0
    {
3994
0
      bool dyn;
3995
3996
0
      eh = (struct elf32_nios2_link_hash_entry *)h;
3997
0
      use_plt = (eh->got_types_used == CALL_USED
3998
0
           && h->plt.offset != (bfd_vma) -1);
3999
4000
0
      off = h->got.offset;
4001
0
      BFD_ASSERT (off != (bfd_vma) -1);
4002
0
      dyn = htab->root.dynamic_sections_created;
4003
0
      if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
4004
0
               bfd_link_pic (info),
4005
0
               h)
4006
0
          || (bfd_link_pic (info)
4007
0
        && SYMBOL_REFERENCES_LOCAL (info, h))
4008
0
          || ((ELF_ST_VISIBILITY (h->other)
4009
0
         || resolved_to_zero)
4010
0
        && h->root.type == bfd_link_hash_undefweak))
4011
0
        {
4012
          /* This is actually a static link, or it is a -Bsymbolic
4013
       link and the symbol is defined locally.  We must
4014
       initialize this entry in the global offset table.
4015
       Since the offset must always be a multiple of 4, we
4016
       use the least significant bit to record whether we
4017
       have initialized it already.
4018
4019
       When doing a dynamic link, we create a .rela.got
4020
       relocation entry to initialize the value.  This is
4021
       done in the finish_dynamic_symbol routine.  */
4022
0
          if ((off & 1) != 0)
4023
0
      off &= ~1;
4024
0
          else
4025
0
      {
4026
0
        bfd_put_32 (output_bfd, relocation,
4027
0
              sgot->contents + off);
4028
0
        h->got.offset |= 1;
4029
0
      }
4030
0
        }
4031
0
      else
4032
0
        unresolved_reloc = false;
4033
0
    }
4034
0
        else
4035
0
    {
4036
0
      BFD_ASSERT (local_got_offsets != NULL
4037
0
            && local_got_offsets[r_symndx] != (bfd_vma) -1);
4038
4039
0
      off = local_got_offsets[r_symndx];
4040
4041
      /* The offset must always be a multiple of 4.  We use the
4042
         least significant bit to record whether we have already
4043
         generated the necessary reloc.  */
4044
0
      if ((off & 1) != 0)
4045
0
        off &= ~1;
4046
0
      else
4047
0
        {
4048
0
          bfd_put_32 (output_bfd, relocation,
4049
0
          sgot->contents + off);
4050
4051
0
          if (bfd_link_pic (info))
4052
0
      {
4053
0
        asection *srelgot;
4054
0
        Elf_Internal_Rela outrel;
4055
0
        bfd_byte *loc;
4056
4057
0
        srelgot = htab->root.srelgot;
4058
0
        BFD_ASSERT (srelgot != NULL);
4059
4060
0
        outrel.r_addend = relocation;
4061
0
        outrel.r_offset = (sgot->output_section->vma
4062
0
               + sgot->output_offset
4063
0
               + off);
4064
0
        outrel.r_info = ELF32_R_INFO (0, R_NIOS2_RELATIVE);
4065
0
        loc = srelgot->contents;
4066
0
        loc += (srelgot->reloc_count++ *
4067
0
          sizeof (Elf32_External_Rela));
4068
0
        bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4069
0
      }
4070
4071
0
          local_got_offsets[r_symndx] |= 1;
4072
0
        }
4073
0
    }
4074
4075
0
        if (use_plt && bfd_link_pic (info))
4076
0
    {
4077
0
      off = ((h->plt.offset - 24) / 12 + 3) * 4;
4078
0
      relocation = (htab->root.sgotplt->output_offset + off
4079
0
        - got_base);
4080
0
    }
4081
0
        else
4082
0
    relocation = sgot->output_offset + off - got_base;
4083
4084
        /* This relocation does not use the addend.  */
4085
0
        rel->r_addend = 0;
4086
4087
0
        switch (howto->type)
4088
0
    {
4089
0
    case R_NIOS2_GOT_LO:
4090
0
    case R_NIOS2_CALL_LO:
4091
0
      r = nios2_elf32_do_lo16_relocate (input_bfd, howto,
4092
0
                input_section, contents,
4093
0
                rel->r_offset, relocation,
4094
0
                rel->r_addend);
4095
0
      break;
4096
0
    case R_NIOS2_GOT_HA:
4097
0
    case R_NIOS2_CALL_HA:
4098
0
      r = nios2_elf32_do_hiadj16_relocate (input_bfd, howto,
4099
0
                   input_section, contents,
4100
0
                   rel->r_offset,
4101
0
                   relocation,
4102
0
                   rel->r_addend);
4103
0
      break;
4104
0
    default:
4105
0
      r = _bfd_final_link_relocate (howto, input_bfd,
4106
0
            input_section, contents,
4107
0
            rel->r_offset, relocation,
4108
0
            rel->r_addend);
4109
0
      break;
4110
0
    }
4111
0
        break;
4112
4113
0
      case R_NIOS2_GOTOFF_LO:
4114
0
      case R_NIOS2_GOTOFF_HA:
4115
0
      case R_NIOS2_GOTOFF:
4116
        /* Relocation is relative to the global offset table pointer.  */
4117
4118
0
        BFD_ASSERT (sgot != NULL);
4119
0
        if (sgot == NULL)
4120
0
    {
4121
0
      r = bfd_reloc_notsupported;
4122
0
      break;
4123
0
    }
4124
4125
        /* Note that sgot->output_offset is not involved in this
4126
     calculation.  We always want the start of .got.  */
4127
0
        relocation -= sgot->output_section->vma;
4128
4129
        /* Now we adjust the relocation to be relative to the GOT pointer
4130
     (the _gp_got symbol), which possibly contains the 0x8000 bias.  */
4131
0
        relocation -= got_base;
4132
4133
0
        switch (howto->type)
4134
0
    {
4135
0
    case R_NIOS2_GOTOFF_LO:
4136
0
      r = nios2_elf32_do_lo16_relocate (input_bfd, howto,
4137
0
                input_section, contents,
4138
0
                rel->r_offset, relocation,
4139
0
                rel->r_addend);
4140
0
      break;
4141
0
    case R_NIOS2_GOTOFF_HA:
4142
0
      r = nios2_elf32_do_hiadj16_relocate (input_bfd, howto,
4143
0
                   input_section, contents,
4144
0
                   rel->r_offset,
4145
0
                   relocation,
4146
0
                   rel->r_addend);
4147
0
      break;
4148
0
    default:
4149
0
      r = _bfd_final_link_relocate (howto, input_bfd,
4150
0
            input_section, contents,
4151
0
            rel->r_offset, relocation,
4152
0
            rel->r_addend);
4153
0
      break;
4154
0
    }
4155
0
        break;
4156
4157
0
      case R_NIOS2_TLS_LDO16:
4158
0
        relocation -= dtpoff_base (info) + DTP_OFFSET;
4159
4160
0
        r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4161
0
              contents, rel->r_offset,
4162
0
              relocation, rel->r_addend);
4163
0
        break;
4164
0
      case R_NIOS2_TLS_LDM16:
4165
0
        if (htab->root.sgot == NULL)
4166
0
    abort ();
4167
4168
0
        off = htab->tls_ldm_got.offset;
4169
4170
0
        if ((off & 1) != 0)
4171
0
    off &= ~1;
4172
0
        else
4173
0
    {
4174
      /* If we don't know the module number, create a relocation
4175
         for it.  */
4176
0
      if (bfd_link_pic (info))
4177
0
        {
4178
0
          Elf_Internal_Rela outrel;
4179
0
          bfd_byte *loc;
4180
4181
0
          if (htab->root.srelgot == NULL)
4182
0
      abort ();
4183
4184
0
          outrel.r_addend = 0;
4185
0
          outrel.r_offset = (htab->root.sgot->output_section->vma
4186
0
           + htab->root.sgot->output_offset
4187
0
           + off);
4188
0
          outrel.r_info = ELF32_R_INFO (0, R_NIOS2_TLS_DTPMOD);
4189
4190
0
          loc = htab->root.srelgot->contents;
4191
0
          loc += (htab->root.srelgot->reloc_count++
4192
0
            * sizeof (Elf32_External_Rela));
4193
0
          bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4194
0
        }
4195
0
      else
4196
0
        bfd_put_32 (output_bfd, 1,
4197
0
        htab->root.sgot->contents + off);
4198
4199
0
      htab->tls_ldm_got.offset |= 1;
4200
0
    }
4201
4202
0
        relocation = htab->root.sgot->output_offset + off - got_base;
4203
4204
0
        r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4205
0
              contents, rel->r_offset,
4206
0
              relocation, rel->r_addend);
4207
4208
0
        break;
4209
0
      case R_NIOS2_TLS_GD16:
4210
0
      case R_NIOS2_TLS_IE16:
4211
0
        {
4212
0
    int indx;
4213
0
    char tls_type;
4214
4215
0
    if (htab->root.sgot == NULL)
4216
0
      abort ();
4217
4218
0
    indx = 0;
4219
0
    if (h != NULL)
4220
0
      {
4221
0
        bool dyn;
4222
0
        dyn = htab->root.dynamic_sections_created;
4223
0
        if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
4224
0
               bfd_link_pic (info),
4225
0
               h)
4226
0
      && (!bfd_link_pic (info)
4227
0
          || !SYMBOL_REFERENCES_LOCAL (info, h)))
4228
0
          {
4229
0
      unresolved_reloc = false;
4230
0
      indx = h->dynindx;
4231
0
          }
4232
0
        off = h->got.offset;
4233
0
        tls_type = (((struct elf32_nios2_link_hash_entry *) h)
4234
0
        ->tls_type);
4235
0
      }
4236
0
    else
4237
0
      {
4238
0
        if (local_got_offsets == NULL)
4239
0
          abort ();
4240
0
        off = local_got_offsets[r_symndx];
4241
0
        tls_type = (elf32_nios2_local_got_tls_type (input_bfd)
4242
0
        [r_symndx]);
4243
0
      }
4244
4245
0
    if (tls_type == GOT_UNKNOWN)
4246
0
      abort ();
4247
4248
0
    if ((off & 1) != 0)
4249
0
      off &= ~1;
4250
0
    else
4251
0
      {
4252
0
        bool need_relocs = false;
4253
0
        Elf_Internal_Rela outrel;
4254
0
        bfd_byte *loc = NULL;
4255
0
        int cur_off = off;
4256
4257
        /* The GOT entries have not been initialized yet.  Do it
4258
           now, and emit any relocations.  If both an IE GOT and a
4259
           GD GOT are necessary, we emit the GD first.  */
4260
4261
0
        if ((bfd_link_pic (info) || indx != 0)
4262
0
      && (h == NULL
4263
0
          || (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4264
0
        && !resolved_to_zero)
4265
0
          || h->root.type != bfd_link_hash_undefweak))
4266
0
          {
4267
0
      need_relocs = true;
4268
0
      if (htab->root.srelgot == NULL)
4269
0
        abort ();
4270
0
      loc = htab->root.srelgot->contents;
4271
0
      loc += (htab->root.srelgot->reloc_count *
4272
0
        sizeof (Elf32_External_Rela));
4273
0
          }
4274
4275
0
        if (tls_type & GOT_TLS_GD)
4276
0
          {
4277
0
      if (need_relocs)
4278
0
        {
4279
0
          outrel.r_addend = 0;
4280
0
          outrel.r_offset = (htab->root.sgot->output_section->vma
4281
0
                 + htab->root.sgot->output_offset
4282
0
                 + cur_off);
4283
0
          outrel.r_info = ELF32_R_INFO (indx,
4284
0
                R_NIOS2_TLS_DTPMOD);
4285
4286
0
          bfd_elf32_swap_reloca_out (output_bfd, &outrel,
4287
0
                   loc);
4288
0
          htab->root.srelgot->reloc_count++;
4289
0
          loc += sizeof (Elf32_External_Rela);
4290
4291
0
          if (indx == 0)
4292
0
            bfd_put_32 (output_bfd,
4293
0
            (relocation - dtpoff_base (info) -
4294
0
             DTP_OFFSET),
4295
0
            htab->root.sgot->contents + cur_off + 4);
4296
0
          else
4297
0
            {
4298
0
        outrel.r_addend = 0;
4299
0
        outrel.r_info = ELF32_R_INFO (indx,
4300
0
          R_NIOS2_TLS_DTPREL);
4301
0
        outrel.r_offset += 4;
4302
4303
0
        bfd_elf32_swap_reloca_out (output_bfd, &outrel,
4304
0
                 loc);
4305
0
        htab->root.srelgot->reloc_count++;
4306
0
        loc += sizeof (Elf32_External_Rela);
4307
0
            }
4308
0
        }
4309
0
      else
4310
0
        {
4311
          /* If we are not emitting relocations for a
4312
             general dynamic reference, then we must be in a
4313
             static link or an executable link with the
4314
             symbol binding locally.  Mark it as belonging
4315
             to module 1, the executable.  */
4316
0
          bfd_put_32 (output_bfd, 1,
4317
0
          htab->root.sgot->contents + cur_off);
4318
0
          bfd_put_32 (output_bfd, (relocation -
4319
0
                 dtpoff_base (info) -
4320
0
                 DTP_OFFSET),
4321
0
          htab->root.sgot->contents + cur_off + 4);
4322
0
        }
4323
4324
0
      cur_off += 8;
4325
0
          }
4326
4327
0
        if (tls_type & GOT_TLS_IE)
4328
0
          {
4329
0
      if (need_relocs)
4330
0
        {
4331
0
          if (indx == 0)
4332
0
            outrel.r_addend = (relocation -
4333
0
             dtpoff_base (info));
4334
0
          else
4335
0
            outrel.r_addend = 0;
4336
0
          outrel.r_offset = (htab->root.sgot->output_section->vma
4337
0
                 + htab->root.sgot->output_offset
4338
0
                 + cur_off);
4339
0
          outrel.r_info = ELF32_R_INFO (indx,
4340
0
                R_NIOS2_TLS_TPREL);
4341
4342
0
          bfd_elf32_swap_reloca_out (output_bfd, &outrel,
4343
0
                   loc);
4344
0
          htab->root.srelgot->reloc_count++;
4345
0
          loc += sizeof (Elf32_External_Rela);
4346
0
        }
4347
0
      else
4348
0
        bfd_put_32 (output_bfd, (tpoff (info, relocation)
4349
0
               - TP_OFFSET),
4350
0
              htab->root.sgot->contents + cur_off);
4351
0
      cur_off += 4;
4352
0
          }
4353
4354
0
        if (h != NULL)
4355
0
          h->got.offset |= 1;
4356
0
        else
4357
0
          local_got_offsets[r_symndx] |= 1;
4358
0
      }
4359
4360
0
    if ((tls_type & GOT_TLS_GD) && r_type != R_NIOS2_TLS_GD16)
4361
0
      off += 8;
4362
0
    relocation = htab->root.sgot->output_offset + off - got_base;
4363
4364
0
    r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4365
0
                contents, rel->r_offset,
4366
0
                relocation, rel->r_addend);
4367
0
        }
4368
4369
0
        break;
4370
0
      case R_NIOS2_TLS_LE16:
4371
0
        if (bfd_link_dll (info))
4372
0
    {
4373
0
      _bfd_error_handler
4374
        /* xgettext:c-format */
4375
0
        (_("%pB(%pA+%#" PRIx64 "): %s relocation not "
4376
0
           "permitted in shared object"),
4377
0
         input_bfd, input_section,
4378
0
         (uint64_t) rel->r_offset, howto->name);
4379
0
      return false;
4380
0
    }
4381
0
        else
4382
0
    relocation = tpoff (info, relocation) - TP_OFFSET;
4383
4384
0
        r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4385
0
              contents, rel->r_offset,
4386
0
              relocation, rel->r_addend);
4387
0
        break;
4388
4389
0
      case R_NIOS2_BFD_RELOC_32:
4390
0
        if (bfd_link_pic (info)
4391
0
      && (input_section->flags & SEC_ALLOC) != 0
4392
0
      && (h == NULL
4393
0
          || (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4394
0
        && !resolved_to_zero)
4395
0
          || h->root.type != bfd_link_hash_undefweak))
4396
0
    {
4397
0
      Elf_Internal_Rela outrel;
4398
0
      bfd_byte *loc;
4399
0
      bool skip, relocate;
4400
4401
      /* When generating a shared object, these relocations
4402
         are copied into the output file to be resolved at run
4403
         time.  */
4404
4405
0
      skip = false;
4406
0
      relocate = false;
4407
4408
0
      outrel.r_offset
4409
0
        = _bfd_elf_section_offset (output_bfd, info,
4410
0
                 input_section, rel->r_offset);
4411
0
      if (outrel.r_offset == (bfd_vma) -1)
4412
0
        skip = true;
4413
0
      else if (outrel.r_offset == (bfd_vma) -2)
4414
0
        skip = true, relocate = true;
4415
0
      outrel.r_offset += (input_section->output_section->vma
4416
0
              + input_section->output_offset);
4417
4418
0
      if (skip)
4419
0
        memset (&outrel, 0, sizeof outrel);
4420
0
      else if (h != NULL
4421
0
         && h->dynindx != -1
4422
0
         && (!bfd_link_pic (info)
4423
0
             || !SYMBOLIC_BIND (info, h)
4424
0
             || !h->def_regular))
4425
0
        {
4426
0
          outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4427
0
          outrel.r_addend = rel->r_addend;
4428
0
        }
4429
0
      else
4430
0
        {
4431
          /* This symbol is local, or marked to become local.  */
4432
0
          outrel.r_addend = relocation + rel->r_addend;
4433
0
          relocate = true;
4434
0
          outrel.r_info = ELF32_R_INFO (0, R_NIOS2_RELATIVE);
4435
0
        }
4436
4437
0
      sreloc = elf_section_data (input_section)->sreloc;
4438
0
      if (sreloc == NULL)
4439
0
        abort ();
4440
4441
0
      loc = sreloc->contents;
4442
0
      loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
4443
0
      bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4444
4445
      /* This reloc will be computed at runtime, so there's no
4446
         need to do anything now, except for R_NIOS2_BFD_RELOC_32
4447
         relocations that have been turned into
4448
         R_NIOS2_RELATIVE.  */
4449
0
      if (!relocate)
4450
0
        break;
4451
0
    }
4452
4453
0
        r = _bfd_final_link_relocate (howto, input_bfd,
4454
0
              input_section, contents,
4455
0
              rel->r_offset, relocation,
4456
0
              rel->r_addend);
4457
0
        break;
4458
4459
0
      case R_NIOS2_TLS_DTPREL:
4460
0
        relocation -= dtpoff_base (info);
4461
        /* Fall through.  */
4462
4463
0
      default:
4464
0
        r = _bfd_final_link_relocate (howto, input_bfd,
4465
0
              input_section, contents,
4466
0
              rel->r_offset, relocation,
4467
0
              rel->r_addend);
4468
0
        break;
4469
0
      }
4470
0
  }
4471
0
      else
4472
0
  r = bfd_reloc_notsupported;
4473
4474
0
      if (r != bfd_reloc_ok)
4475
0
  {
4476
0
    if (h != NULL)
4477
0
      name = h->root.root.string;
4478
0
    else
4479
0
      {
4480
0
        name = bfd_elf_string_from_elf_section (input_bfd,
4481
0
                  symtab_hdr->sh_link,
4482
0
                  sym->st_name);
4483
0
        if (name == NULL || *name == '\0')
4484
0
    name = bfd_section_name (sec);
4485
0
      }
4486
4487
0
    switch (r)
4488
0
      {
4489
0
      case bfd_reloc_overflow:
4490
0
        (*info->callbacks->reloc_overflow) (info, NULL, name,
4491
0
              howto->name, (bfd_vma) 0,
4492
0
              input_bfd, input_section,
4493
0
              rel->r_offset);
4494
0
        break;
4495
4496
0
      case bfd_reloc_undefined:
4497
0
        (*info->callbacks->undefined_symbol) (info, name, input_bfd,
4498
0
                input_section,
4499
0
                rel->r_offset, true);
4500
0
        break;
4501
4502
0
      case bfd_reloc_outofrange:
4503
0
        if (msg == NULL)
4504
0
    msg = _("relocation out of range");
4505
0
        break;
4506
4507
0
      case bfd_reloc_notsupported:
4508
0
        if (msg == NULL)
4509
0
    msg = _("unsupported relocation");
4510
0
        break;
4511
4512
0
      case bfd_reloc_dangerous:
4513
0
        if (msg == NULL)
4514
0
    msg = _("dangerous relocation");
4515
0
        break;
4516
4517
0
      default:
4518
0
        if (msg == NULL)
4519
0
    msg = _("unknown error");
4520
0
        break;
4521
0
      }
4522
4523
0
    if (msg)
4524
0
      {
4525
0
        (*info->callbacks->warning) (info, msg, name, input_bfd,
4526
0
             input_section, rel->r_offset);
4527
0
        return false;
4528
0
      }
4529
0
  }
4530
0
    }
4531
0
  return true;
4532
0
}
4533
4534
/* Implement elf-backend_section_flags:
4535
   Convert NIOS2 specific section flags to bfd internal section flags.  */
4536
static bool
4537
nios2_elf32_section_flags (const Elf_Internal_Shdr *hdr)
4538
8.78k
{
4539
8.78k
  if (hdr->sh_flags & SHF_NIOS2_GPREL)
4540
3.18k
    hdr->bfd_section->flags |= SEC_SMALL_DATA;
4541
4542
8.78k
  return true;
4543
8.78k
}
4544
4545
/* Implement elf_backend_fake_sections:
4546
   Set the correct type for an NIOS2 ELF section.  We do this by the
4547
   section name, which is a hack, but ought to work.  */
4548
static bool
4549
nios2_elf32_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
4550
         Elf_Internal_Shdr *hdr, asection *sec)
4551
0
{
4552
0
  const char *name = bfd_section_name (sec);
4553
4554
0
  if ((sec->flags & SEC_SMALL_DATA)
4555
0
      || strcmp (name, ".sdata") == 0
4556
0
      || strcmp (name, ".sbss") == 0
4557
0
      || strcmp (name, ".lit4") == 0 || strcmp (name, ".lit8") == 0)
4558
0
    hdr->sh_flags |= SHF_NIOS2_GPREL;
4559
4560
0
  return true;
4561
0
}
4562
4563
/* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
4564
   shortcuts to them in our hash table.  */
4565
static bool
4566
create_got_section (bfd *dynobj, struct bfd_link_info *info)
4567
0
{
4568
0
  struct elf32_nios2_link_hash_table *htab;
4569
0
  struct elf_link_hash_entry *h;
4570
4571
0
  htab = elf32_nios2_hash_table (info);
4572
4573
0
  if (! _bfd_elf_create_got_section (dynobj, info))
4574
0
    return false;
4575
4576
  /* In order for the two loads in .PLTresolve to share the same %hiadj,
4577
     _GLOBAL_OFFSET_TABLE_ must be aligned to a 16-byte boundary.  */
4578
0
  if (!bfd_set_section_alignment (htab->root.sgotplt, 4))
4579
0
    return false;
4580
4581
  /* The Nios II ABI specifies that GOT-relative relocations are relative
4582
     to the linker-created symbol _gp_got, rather than using
4583
     _GLOBAL_OFFSET_TABLE_ directly.  In particular, the latter always
4584
     points to the base of the GOT while _gp_got may include a bias.  */
4585
0
  h = _bfd_elf_define_linkage_sym (dynobj, info, htab->root.sgotplt,
4586
0
           "_gp_got");
4587
0
  htab->h_gp_got = h;
4588
0
  if (h == NULL)
4589
0
    return false;
4590
4591
0
  return true;
4592
0
}
4593
4594
/* Implement elf_backend_create_dynamic_sections:
4595
   Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
4596
   .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
4597
   hash table.  */
4598
static bool
4599
nios2_elf32_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4600
0
{
4601
0
  struct elf32_nios2_link_hash_table *htab;
4602
4603
0
  htab = elf32_nios2_hash_table (info);
4604
0
  if (!htab->root.sgot && !create_got_section (dynobj, info))
4605
0
    return false;
4606
4607
0
  if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4608
0
    return false;
4609
4610
  /* In order for the two loads in a shared object .PLTresolve to share the
4611
     same %hiadj, the start of the PLT (as well as the GOT) must be aligned
4612
     to a 16-byte boundary.  This is because the addresses for these loads
4613
     include the -(.plt+4) PIC correction.  */
4614
0
  return bfd_set_section_alignment (htab->root.splt, 4);
4615
0
}
4616
4617
/* Implement elf_backend_copy_indirect_symbol:
4618
   Copy the extra info we tack onto an elf_link_hash_entry.  */
4619
static void
4620
nios2_elf32_copy_indirect_symbol (struct bfd_link_info *info,
4621
          struct elf_link_hash_entry *dir,
4622
          struct elf_link_hash_entry *ind)
4623
0
{
4624
0
  struct elf32_nios2_link_hash_entry *edir, *eind;
4625
4626
0
  edir = (struct elf32_nios2_link_hash_entry *) dir;
4627
0
  eind = (struct elf32_nios2_link_hash_entry *) ind;
4628
4629
0
  if (ind->root.type == bfd_link_hash_indirect
4630
0
      && dir->got.refcount <= 0)
4631
0
    {
4632
0
      edir->tls_type = eind->tls_type;
4633
0
      eind->tls_type = GOT_UNKNOWN;
4634
0
    }
4635
4636
0
  edir->got_types_used |= eind->got_types_used;
4637
4638
0
  _bfd_elf_link_hash_copy_indirect (info, dir, ind);
4639
0
}
4640
4641
/* Set the right machine number for a NIOS2 ELF file.  */
4642
4643
static bool
4644
nios2_elf32_object_p (bfd *abfd)
4645
2.52k
{
4646
2.52k
  unsigned long mach;
4647
4648
2.52k
  mach = elf_elfheader (abfd)->e_flags;
4649
4650
2.52k
  switch (mach)
4651
2.52k
    {
4652
28
    default:
4653
1.51k
    case EF_NIOS2_ARCH_R1:
4654
1.51k
      bfd_default_set_arch_mach (abfd, bfd_arch_nios2, bfd_mach_nios2r1);
4655
1.51k
      break;
4656
1.00k
    case EF_NIOS2_ARCH_R2:
4657
1.00k
      bfd_default_set_arch_mach (abfd, bfd_arch_nios2, bfd_mach_nios2r2);
4658
1.00k
      break;
4659
2.52k
    }
4660
4661
2.52k
  return true;
4662
2.52k
}
4663
4664
/* Implement elf_backend_check_relocs:
4665
   Look through the relocs for a section during the first phase.  */
4666
static bool
4667
nios2_elf32_check_relocs (bfd *abfd, struct bfd_link_info *info,
4668
        asection *sec, const Elf_Internal_Rela *relocs)
4669
0
{
4670
0
  Elf_Internal_Shdr *symtab_hdr;
4671
0
  struct elf_link_hash_entry **sym_hashes;
4672
0
  const Elf_Internal_Rela *rel;
4673
0
  const Elf_Internal_Rela *rel_end;
4674
0
  struct elf32_nios2_link_hash_table *htab;
4675
0
  asection *sreloc = NULL;
4676
0
  bfd_signed_vma *local_got_refcounts;
4677
4678
0
  if (bfd_link_relocatable (info))
4679
0
    return true;
4680
4681
0
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4682
0
  sym_hashes = elf_sym_hashes (abfd);
4683
0
  local_got_refcounts = elf_local_got_refcounts (abfd);
4684
4685
0
  htab = elf32_nios2_hash_table (info);
4686
4687
0
  rel_end = relocs + sec->reloc_count;
4688
0
  for (rel = relocs; rel < rel_end; rel++)
4689
0
    {
4690
0
      unsigned int r_type;
4691
0
      struct elf_link_hash_entry *h;
4692
0
      unsigned long r_symndx;
4693
4694
0
      r_symndx = ELF32_R_SYM (rel->r_info);
4695
0
      if (r_symndx < symtab_hdr->sh_info)
4696
0
  h = NULL;
4697
0
      else
4698
0
  {
4699
0
    h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4700
0
    while (h->root.type == bfd_link_hash_indirect
4701
0
     || h->root.type == bfd_link_hash_warning)
4702
0
      h = (struct elf_link_hash_entry *) h->root.u.i.link;
4703
0
  }
4704
4705
0
      r_type = ELF32_R_TYPE (rel->r_info);
4706
4707
0
      switch (r_type)
4708
0
  {
4709
0
  case R_NIOS2_GOT16:
4710
0
  case R_NIOS2_GOT_LO:
4711
0
  case R_NIOS2_GOT_HA:
4712
0
  case R_NIOS2_CALL16:
4713
0
  case R_NIOS2_CALL_LO:
4714
0
  case R_NIOS2_CALL_HA:
4715
0
  case R_NIOS2_TLS_GD16:
4716
0
  case R_NIOS2_TLS_IE16:
4717
    /* This symbol requires a global offset table entry.  */
4718
0
    {
4719
0
      int tls_type, old_tls_type;
4720
4721
0
      switch (r_type)
4722
0
        {
4723
0
        default:
4724
0
        case R_NIOS2_GOT16:
4725
0
        case R_NIOS2_GOT_LO:
4726
0
        case R_NIOS2_GOT_HA:
4727
0
        case R_NIOS2_CALL16:
4728
0
        case R_NIOS2_CALL_LO:
4729
0
        case R_NIOS2_CALL_HA:
4730
0
    tls_type = GOT_NORMAL;
4731
0
    break;
4732
0
        case R_NIOS2_TLS_GD16:
4733
0
    tls_type = GOT_TLS_GD;
4734
0
    break;
4735
0
        case R_NIOS2_TLS_IE16:
4736
0
    tls_type = GOT_TLS_IE;
4737
0
    break;
4738
0
        }
4739
4740
0
      if (h != NULL)
4741
0
        {
4742
0
    struct elf32_nios2_link_hash_entry *eh
4743
0
      = (struct elf32_nios2_link_hash_entry *)h;
4744
0
    h->got.refcount++;
4745
0
    old_tls_type = elf32_nios2_hash_entry(h)->tls_type;
4746
0
    if (r_type == R_NIOS2_CALL16
4747
0
        || r_type == R_NIOS2_CALL_LO
4748
0
        || r_type == R_NIOS2_CALL_HA)
4749
0
      {
4750
        /* Make sure a plt entry is created for this symbol if
4751
           it turns out to be a function defined by a dynamic
4752
           object.  */
4753
0
        h->plt.refcount++;
4754
0
        h->needs_plt = 1;
4755
0
        h->type = STT_FUNC;
4756
0
        eh->got_types_used |= CALL_USED;
4757
0
      }
4758
0
    else
4759
0
      eh->got_types_used |= GOT_USED;
4760
0
        }
4761
0
      else
4762
0
        {
4763
    /* This is a global offset table entry for a local symbol.  */
4764
0
    if (local_got_refcounts == NULL)
4765
0
      {
4766
0
        bfd_size_type size;
4767
4768
0
        size = symtab_hdr->sh_info;
4769
0
        size *= (sizeof (bfd_signed_vma) + sizeof (char));
4770
0
        local_got_refcounts
4771
0
          = ((bfd_signed_vma *) bfd_zalloc (abfd, size));
4772
0
        if (local_got_refcounts == NULL)
4773
0
          return false;
4774
0
        elf_local_got_refcounts (abfd) = local_got_refcounts;
4775
0
        elf32_nios2_local_got_tls_type (abfd)
4776
0
          = (char *) (local_got_refcounts + symtab_hdr->sh_info);
4777
0
      }
4778
0
    local_got_refcounts[r_symndx]++;
4779
0
    old_tls_type = elf32_nios2_local_got_tls_type (abfd) [r_symndx];
4780
0
        }
4781
4782
      /* We will already have issued an error message if there is a
4783
         TLS / non-TLS mismatch, based on the symbol type.  We don't
4784
         support any linker relaxations.  So just combine any TLS
4785
         types needed.  */
4786
0
      if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
4787
0
    && tls_type != GOT_NORMAL)
4788
0
        tls_type |= old_tls_type;
4789
4790
0
      if (old_tls_type != tls_type)
4791
0
        {
4792
0
    if (h != NULL)
4793
0
      elf32_nios2_hash_entry (h)->tls_type = tls_type;
4794
0
    else
4795
0
      elf32_nios2_local_got_tls_type (abfd) [r_symndx] = tls_type;
4796
0
        }
4797
0
    }
4798
0
  make_got:
4799
0
    if (htab->root.sgot == NULL)
4800
0
      {
4801
0
        if (htab->root.dynobj == NULL)
4802
0
    htab->root.dynobj = abfd;
4803
0
        if (!create_got_section (htab->root.dynobj, info))
4804
0
    return false;
4805
0
      }
4806
0
    break;
4807
4808
0
  case R_NIOS2_TLS_LDM16:
4809
0
    htab->tls_ldm_got.refcount++;
4810
0
    goto make_got;
4811
4812
    /* This relocation describes the C++ object vtable hierarchy.
4813
       Reconstruct it for later use during GC.  */
4814
0
  case R_NIOS2_GNU_VTINHERIT:
4815
0
    if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
4816
0
      return false;
4817
0
    break;
4818
4819
    /* This relocation describes which C++ vtable entries are actually
4820
       used.  Record for later use during GC.  */
4821
0
  case R_NIOS2_GNU_VTENTRY:
4822
0
    if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
4823
0
      return false;
4824
0
    break;
4825
4826
0
  case R_NIOS2_BFD_RELOC_32:
4827
0
  case R_NIOS2_CALL26:
4828
0
  case R_NIOS2_CALL26_NOAT:
4829
0
  case R_NIOS2_HIADJ16:
4830
0
  case R_NIOS2_LO16:
4831
4832
0
    if (h != NULL)
4833
0
      {
4834
        /* If this reloc is in a read-only section, we might
4835
       need a copy reloc.  We can't check reliably at this
4836
       stage whether the section is read-only, as input
4837
       sections have not yet been mapped to output sections.
4838
       Tentatively set the flag for now, and correct in
4839
       adjust_dynamic_symbol.  */
4840
0
        if (!bfd_link_pic (info))
4841
0
    h->non_got_ref = 1;
4842
4843
        /* Make sure a plt entry is created for this symbol if it
4844
     turns out to be a function defined by a dynamic object.  */
4845
0
        h->plt.refcount++;
4846
4847
0
        if (r_type == R_NIOS2_CALL26 || r_type == R_NIOS2_CALL26_NOAT)
4848
0
    h->needs_plt = 1;
4849
0
      }
4850
4851
    /* If we are creating a shared library, we need to copy the
4852
       reloc into the shared library.  */
4853
0
    if (bfd_link_pic (info)
4854
0
        && (sec->flags & SEC_ALLOC) != 0
4855
0
        && (r_type == R_NIOS2_BFD_RELOC_32
4856
0
      || (h != NULL && ! h->needs_plt
4857
0
          && (! SYMBOLIC_BIND (info, h) || ! h->def_regular))))
4858
0
      {
4859
0
        struct elf_dyn_relocs *p;
4860
0
        struct elf_dyn_relocs **head;
4861
4862
        /* When creating a shared object, we must copy these
4863
     reloc types into the output file.  We create a reloc
4864
     section in dynobj and make room for this reloc.  */
4865
0
        if (sreloc == NULL)
4866
0
    {
4867
0
      if (htab->root.dynobj == NULL)
4868
0
        htab->root.dynobj = abfd;
4869
4870
0
      sreloc = _bfd_elf_make_dynamic_reloc_section
4871
0
        (sec, htab->root.dynobj, 2, abfd, true);
4872
0
      if (sreloc == NULL)
4873
0
        return false;
4874
0
    }
4875
4876
        /* If this is a global symbol, we count the number of
4877
     relocations we need for this symbol.  */
4878
0
        if (h != NULL)
4879
0
    head = &h->dyn_relocs;
4880
0
        else
4881
0
    {
4882
      /* Track dynamic relocs needed for local syms too.
4883
         We really need local syms available to do this
4884
         easily.  Oh well.  */
4885
4886
0
      asection *s;
4887
0
      void *vpp;
4888
0
      Elf_Internal_Sym *isym;
4889
4890
0
      isym = bfd_sym_from_r_symndx (&htab->root.sym_cache,
4891
0
            abfd, r_symndx);
4892
0
      if (isym == NULL)
4893
0
        return false;
4894
4895
0
      s = bfd_section_from_elf_index (abfd, isym->st_shndx);
4896
0
      if (s == NULL)
4897
0
        s = sec;
4898
4899
0
      vpp = &elf_section_data (s)->local_dynrel;
4900
0
      head = (struct elf_dyn_relocs **) vpp;
4901
0
    }
4902
4903
0
        p = *head;
4904
0
        if (p == NULL || p->sec != sec)
4905
0
    {
4906
0
      size_t amt = sizeof *p;
4907
0
      p = ((struct elf_dyn_relocs *)
4908
0
           bfd_alloc (htab->root.dynobj, amt));
4909
0
      if (p == NULL)
4910
0
        return false;
4911
0
      p->next = *head;
4912
0
      *head = p;
4913
0
      p->sec = sec;
4914
0
      p->count = 0;
4915
0
      p->pc_count = 0;
4916
0
    }
4917
4918
0
        p->count += 1;
4919
4920
0
      }
4921
0
    break;
4922
0
  }
4923
0
    }
4924
4925
0
  return true;
4926
0
}
4927
4928
4929
/* Implement elf_backend_gc_mark_hook:
4930
   Return the section that should be marked against GC for a given
4931
   relocation.  */
4932
static asection *
4933
nios2_elf32_gc_mark_hook (asection *sec,
4934
        struct bfd_link_info *info,
4935
        Elf_Internal_Rela *rel,
4936
        struct elf_link_hash_entry *h,
4937
        Elf_Internal_Sym *sym)
4938
0
{
4939
0
  if (h != NULL)
4940
0
    switch (ELF32_R_TYPE (rel->r_info))
4941
0
      {
4942
0
      case R_NIOS2_GNU_VTINHERIT:
4943
0
      case R_NIOS2_GNU_VTENTRY:
4944
0
  return NULL;
4945
0
      }
4946
0
  return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
4947
0
}
4948
4949
/* Implement elf_backend_finish_dynamic_symbols:
4950
   Finish up dynamic symbol handling.  We set the contents of various
4951
   dynamic sections here.  */
4952
static bool
4953
nios2_elf32_finish_dynamic_symbol (bfd *output_bfd,
4954
           struct bfd_link_info *info,
4955
           struct elf_link_hash_entry *h,
4956
           Elf_Internal_Sym *sym)
4957
0
{
4958
0
  struct elf32_nios2_link_hash_table *htab;
4959
0
  struct elf32_nios2_link_hash_entry *eh
4960
0
    = (struct elf32_nios2_link_hash_entry *)h;
4961
0
  int use_plt;
4962
4963
0
  htab = elf32_nios2_hash_table (info);
4964
4965
0
  if (h->plt.offset != (bfd_vma) -1)
4966
0
    {
4967
0
      asection *splt;
4968
0
      asection *sgotplt;
4969
0
      asection *srela;
4970
0
      bfd_vma plt_index;
4971
0
      bfd_vma got_offset;
4972
0
      Elf_Internal_Rela rela;
4973
0
      bfd_byte *loc;
4974
0
      bfd_vma got_address;
4975
4976
      /* This symbol has an entry in the procedure linkage table.  Set
4977
   it up.  */
4978
0
      BFD_ASSERT (h->dynindx != -1);
4979
0
      splt = htab->root.splt;
4980
0
      sgotplt = htab->root.sgotplt;
4981
0
      srela = htab->root.srelplt;
4982
0
      BFD_ASSERT (splt != NULL && sgotplt != NULL && srela != NULL);
4983
4984
      /* Emit the PLT entry.  */
4985
0
      if (bfd_link_pic (info))
4986
0
  {
4987
0
    bfd_vma br_offset;
4988
4989
0
    nios2_elf32_install_data (splt, nios2_so_plt_entry, h->plt.offset,
4990
0
            3);
4991
0
    plt_index = (h->plt.offset - 24) / 12;
4992
0
    got_offset = (plt_index + 3) * 4;
4993
0
    nios2_elf32_install_imm16 (splt, h->plt.offset,
4994
0
             hiadj (plt_index * 4));
4995
0
    nios2_elf32_install_imm16 (splt, h->plt.offset + 4,
4996
0
             plt_index * 4);
4997
0
    br_offset = -(h->plt.offset + 12);
4998
    /* If this plt entry is too far away from the start of .plt
4999
       for the "br" to reach .PLTresolve, bounce through one or
5000
       more of the previous "br" instructions.  */
5001
0
    if (br_offset < (bfd_vma) -32768)
5002
0
      {
5003
0
        br_offset += 32768 / 12 * 12 - 4;
5004
0
        while (br_offset < (bfd_vma) -32768)
5005
0
    br_offset += 32768 / 12 * 12;
5006
0
      }
5007
0
    nios2_elf32_install_imm16 (splt, h->plt.offset + 8, br_offset);
5008
5009
0
    got_address = (sgotplt->output_section->vma + sgotplt->output_offset
5010
0
       + got_offset);
5011
5012
    /* Fill in the entry in the global offset table.  There are no
5013
       res_n slots for a shared object PLT, instead the .got.plt entries
5014
       point to the PLT entries.  */
5015
0
    bfd_put_32 (output_bfd,
5016
0
          splt->output_section->vma + splt->output_offset
5017
0
          + h->plt.offset, sgotplt->contents + got_offset);
5018
0
  }
5019
0
      else
5020
0
  {
5021
0
    plt_index = (h->plt.offset - 28 - htab->res_n_size) / 12;
5022
0
    got_offset = (plt_index + 3) * 4;
5023
5024
0
    nios2_elf32_install_data (splt, nios2_plt_entry, h->plt.offset, 3);
5025
0
    got_address = (sgotplt->output_section->vma + sgotplt->output_offset
5026
0
       + got_offset);
5027
0
    nios2_elf32_install_imm16 (splt, h->plt.offset, hiadj (got_address));
5028
0
    nios2_elf32_install_imm16 (splt, h->plt.offset + 4, got_address);
5029
5030
    /* Fill in the entry in the global offset table.  */
5031
0
    bfd_put_32 (output_bfd,
5032
0
          splt->output_section->vma + splt->output_offset
5033
0
          + plt_index * 4, sgotplt->contents + got_offset);
5034
0
  }
5035
5036
      /* Fill in the entry in the .rela.plt section.  */
5037
0
      rela.r_offset = got_address;
5038
0
      rela.r_info = ELF32_R_INFO (h->dynindx, R_NIOS2_JUMP_SLOT);
5039
0
      rela.r_addend = 0;
5040
0
      loc = srela->contents + plt_index * sizeof (Elf32_External_Rela);
5041
0
      bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5042
5043
0
      if (!h->def_regular)
5044
0
  {
5045
    /* Mark the symbol as undefined, rather than as defined in
5046
       the .plt section.  Leave the value alone.  */
5047
0
    sym->st_shndx = SHN_UNDEF;
5048
    /* If the symbol is weak, we do need to clear the value.
5049
       Otherwise, the PLT entry would provide a definition for
5050
       the symbol even if the symbol wasn't defined anywhere,
5051
       and so the symbol would never be NULL.  */
5052
0
    if (!h->ref_regular_nonweak)
5053
0
      sym->st_value = 0;
5054
0
  }
5055
0
    }
5056
5057
0
  use_plt = (eh->got_types_used == CALL_USED
5058
0
       && h->plt.offset != (bfd_vma) -1);
5059
5060
0
  if (!use_plt && h->got.offset != (bfd_vma) -1
5061
0
      && (elf32_nios2_hash_entry (h)->tls_type & GOT_TLS_GD) == 0
5062
0
      && (elf32_nios2_hash_entry (h)->tls_type & GOT_TLS_IE) == 0)
5063
0
    {
5064
0
      asection *sgot;
5065
0
      asection *srela;
5066
0
      Elf_Internal_Rela rela;
5067
0
      bfd_byte *loc;
5068
0
      bfd_vma offset;
5069
5070
      /* This symbol has an entry in the global offset table.  Set it
5071
   up.  */
5072
0
      sgot = htab->root.sgot;
5073
0
      srela = htab->root.srelgot;
5074
0
      BFD_ASSERT (sgot != NULL && srela != NULL);
5075
5076
0
      offset = (h->got.offset & ~(bfd_vma) 1);
5077
0
      rela.r_offset = (sgot->output_section->vma
5078
0
           + sgot->output_offset + offset);
5079
5080
      /* If this is a -Bsymbolic link, and the symbol is defined
5081
   locally, we just want to emit a RELATIVE reloc.  Likewise if
5082
   the symbol was forced to be local because of a version file.
5083
   The entry in the global offset table will already have been
5084
   initialized in the relocate_section function.  */
5085
5086
0
      if (bfd_link_pic (info) && SYMBOL_REFERENCES_LOCAL (info, h))
5087
0
  {
5088
0
    rela.r_info = ELF32_R_INFO (0, R_NIOS2_RELATIVE);
5089
0
    rela.r_addend = bfd_get_signed_32 (output_bfd,
5090
0
               (sgot->contents + offset));
5091
0
    bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + offset);
5092
0
  }
5093
0
      else
5094
0
  {
5095
0
    bfd_put_32 (output_bfd, (bfd_vma) 0,
5096
0
          sgot->contents + offset);
5097
0
    rela.r_info = ELF32_R_INFO (h->dynindx, R_NIOS2_GLOB_DAT);
5098
0
    rela.r_addend = 0;
5099
0
  }
5100
5101
0
      loc = srela->contents;
5102
0
      loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
5103
0
      bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5104
0
    }
5105
5106
0
  if (use_plt && h->got.offset != (bfd_vma) -1)
5107
0
    {
5108
0
      bfd_vma offset = (h->got.offset & ~(bfd_vma) 1);
5109
0
      asection *sgot = htab->root.sgot;
5110
0
      asection *splt = htab->root.splt;
5111
0
      bfd_put_32 (output_bfd, (splt->output_section->vma + splt->output_offset
5112
0
             + h->plt.offset),
5113
0
      sgot->contents + offset);
5114
0
    }
5115
5116
0
  if (h->needs_copy)
5117
0
    {
5118
0
      asection *s;
5119
0
      Elf_Internal_Rela rela;
5120
0
      bfd_byte *loc;
5121
5122
      /* This symbol needs a copy reloc.  Set it up.  */
5123
0
      BFD_ASSERT (h->dynindx != -1
5124
0
      && (h->root.type == bfd_link_hash_defined
5125
0
          || h->root.type == bfd_link_hash_defweak));
5126
5127
0
      rela.r_offset = (h->root.u.def.value
5128
0
           + h->root.u.def.section->output_section->vma
5129
0
           + h->root.u.def.section->output_offset);
5130
0
      rela.r_info = ELF32_R_INFO (h->dynindx, R_NIOS2_COPY);
5131
0
      rela.r_addend = 0;
5132
0
      if (h->root.u.def.section == htab->root.sdynrelro)
5133
0
  s = htab->root.sreldynrelro;
5134
0
      else
5135
0
  s = htab->root.srelbss;
5136
0
      BFD_ASSERT (s != NULL);
5137
0
      loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
5138
0
      bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5139
0
    }
5140
5141
  /* Mark _DYNAMIC, _GLOBAL_OFFSET_TABLE_, and _gp_got as absolute.  */
5142
0
  if (strcmp (h->root.root.string, "_DYNAMIC") == 0
5143
0
      || h == htab->root.hgot
5144
0
      || h == htab->h_gp_got)
5145
0
    sym->st_shndx = SHN_ABS;
5146
5147
0
  return true;
5148
0
}
5149
5150
/* Implement elf_backend_finish_dynamic_sections.  */
5151
static bool
5152
nios2_elf32_finish_dynamic_sections (bfd *output_bfd,
5153
             struct bfd_link_info *info)
5154
0
{
5155
0
  asection *sgotplt;
5156
0
  asection *sdyn;
5157
0
  struct elf32_nios2_link_hash_table *htab;
5158
5159
0
  htab = elf32_nios2_hash_table (info);
5160
0
  sgotplt = htab->root.sgotplt;
5161
0
  sdyn = NULL;
5162
5163
0
  if (htab->root.dynamic_sections_created)
5164
0
    {
5165
0
      asection *splt;
5166
0
      Elf32_External_Dyn *dyncon, *dynconend;
5167
5168
0
      splt = htab->root.splt;
5169
0
      sdyn = bfd_get_linker_section (htab->root.dynobj, ".dynamic");
5170
0
      BFD_ASSERT (splt != NULL && sdyn != NULL && sgotplt != NULL);
5171
5172
0
      dyncon = (Elf32_External_Dyn *) sdyn->contents;
5173
0
      dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
5174
0
      for (; dyncon < dynconend; dyncon++)
5175
0
  {
5176
0
    Elf_Internal_Dyn dyn;
5177
0
    asection *s;
5178
5179
0
    bfd_elf32_swap_dyn_in (htab->root.dynobj, dyncon, &dyn);
5180
5181
0
    switch (dyn.d_tag)
5182
0
      {
5183
0
      default:
5184
0
        break;
5185
5186
0
      case DT_PLTGOT:
5187
0
        s = htab->root.sgotplt;
5188
0
        dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5189
0
        bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5190
0
        break;
5191
5192
0
      case DT_JMPREL:
5193
0
        s = htab->root.srelplt;
5194
0
        dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5195
0
        bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5196
0
        break;
5197
5198
0
      case DT_PLTRELSZ:
5199
0
        s = htab->root.srelplt;
5200
0
        dyn.d_un.d_val = s->size;
5201
0
        bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5202
0
        break;
5203
5204
0
      case DT_NIOS2_GP:
5205
0
        s = htab->root.sgotplt;
5206
0
        dyn.d_un.d_ptr
5207
0
    = s->output_section->vma + s->output_offset + 0x7ff0;
5208
0
        bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5209
0
        break;
5210
0
      }
5211
0
  }
5212
5213
      /* Fill in the first entry in the procedure linkage table.  */
5214
0
      if (splt->size > 0)
5215
0
  {
5216
0
    bfd_vma got_address = (sgotplt->output_section->vma
5217
0
         + sgotplt->output_offset);
5218
0
    if (bfd_link_pic (info))
5219
0
      {
5220
0
        bfd_vma got_pcrel = got_address - (splt->output_section->vma
5221
0
             + splt->output_offset);
5222
        /* Both GOT and PLT must be aligned to a 16-byte boundary
5223
     for the two loads to share the %hiadj part.  The 4-byte
5224
     offset for nextpc is accounted for in the %lo offsets
5225
     on the loads.  */
5226
0
        BFD_ASSERT ((got_pcrel & 0xf) == 0);
5227
0
        nios2_elf32_install_data (splt, nios2_so_plt0_entry, 0, 6);
5228
0
        nios2_elf32_install_imm16 (splt, 4, hiadj (got_pcrel));
5229
0
        nios2_elf32_install_imm16 (splt, 12, got_pcrel);
5230
0
        nios2_elf32_install_imm16 (splt, 16, got_pcrel + 4);
5231
0
      }
5232
0
    else
5233
0
      {
5234
        /* Divide by 4 here, not 3 because we already corrected for the
5235
     res_N branches.  */
5236
0
        bfd_vma res_size = (splt->size - 28) / 4;
5237
0
        bfd_vma res_start = (splt->output_section->vma
5238
0
           + splt->output_offset);
5239
0
        bfd_vma res_offset;
5240
5241
0
        for (res_offset = 0; res_offset < res_size; res_offset += 4)
5242
0
    bfd_put_32 (output_bfd,
5243
0
          6 | ((res_size - (res_offset + 4)) << 6),
5244
0
          splt->contents + res_offset);
5245
5246
        /* The GOT must be aligned to a 16-byte boundary for the
5247
     two loads to share the same %hiadj part.  */
5248
0
        BFD_ASSERT ((got_address & 0xf) == 0);
5249
5250
0
        nios2_elf32_install_data (splt, nios2_plt0_entry, res_size, 7);
5251
0
        nios2_elf32_install_imm16 (splt, res_size, hiadj (res_start));
5252
0
        nios2_elf32_install_imm16 (splt, res_size + 4, res_start);
5253
0
        nios2_elf32_install_imm16 (splt, res_size + 12,
5254
0
           hiadj (got_address));
5255
0
        nios2_elf32_install_imm16 (splt, res_size + 16,
5256
0
           got_address + 4);
5257
0
        nios2_elf32_install_imm16 (splt, res_size + 20,
5258
0
           got_address + 8);
5259
0
      }
5260
0
  }
5261
0
    }
5262
5263
  /* Fill in the first three entries in the global offset table.  */
5264
0
  if (sgotplt != NULL && sgotplt->size > 0)
5265
0
    {
5266
0
      if (sdyn == NULL)
5267
0
  bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents);
5268
0
      else
5269
0
  bfd_put_32 (output_bfd,
5270
0
        sdyn->output_section->vma + sdyn->output_offset,
5271
0
        sgotplt->contents);
5272
0
      bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 4);
5273
0
      bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 8);
5274
5275
0
      if (sgotplt->output_section != bfd_abs_section_ptr)
5276
0
  elf_section_data (sgotplt->output_section)->this_hdr.sh_entsize = 4;
5277
0
    }
5278
5279
0
  return true;
5280
0
}
5281
5282
/* Implement elf_backend_adjust_dynamic_symbol:
5283
   Adjust a symbol defined by a dynamic object and referenced by a
5284
   regular object.  The current definition is in some section of the
5285
   dynamic object, but we're not including those sections.  We have to
5286
   change the definition to something the rest of the link can
5287
   understand.  */
5288
static bool
5289
nios2_elf32_adjust_dynamic_symbol (struct bfd_link_info *info,
5290
           struct elf_link_hash_entry *h)
5291
0
{
5292
0
  struct elf32_nios2_link_hash_table *htab;
5293
0
  bfd *dynobj;
5294
0
  asection *s, *srel;
5295
0
  unsigned align2;
5296
5297
0
  htab = elf32_nios2_hash_table (info);
5298
0
  dynobj = htab->root.dynobj;
5299
5300
  /* Make sure we know what is going on here.  */
5301
0
  BFD_ASSERT (dynobj != NULL
5302
0
        && (h->needs_plt
5303
0
      || h->is_weakalias
5304
0
      || (h->def_dynamic
5305
0
          && h->ref_regular
5306
0
          && !h->def_regular)));
5307
5308
  /* If this is a function, put it in the procedure linkage table.  We
5309
     will fill in the contents of the procedure linkage table later,
5310
     when we know the address of the .got section.  */
5311
0
  if (h->type == STT_FUNC || h->needs_plt)
5312
0
    {
5313
0
      if (h->plt.refcount <= 0
5314
0
    || SYMBOL_CALLS_LOCAL (info, h)
5315
0
    || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
5316
0
        && h->root.type == bfd_link_hash_undefweak))
5317
0
  {
5318
    /* This case can occur if we saw a PLT reloc in an input
5319
       file, but the symbol was never referred to by a dynamic
5320
       object, or if all references were garbage collected.  In
5321
       such a case, we don't actually need to build a procedure
5322
       linkage table, and we can just do a PCREL reloc instead.  */
5323
0
    h->plt.offset = (bfd_vma) -1;
5324
0
    h->needs_plt = 0;
5325
0
  }
5326
5327
0
      return true;
5328
0
    }
5329
5330
  /* Reinitialize the plt offset now that it is not used as a reference
5331
     count any more.  */
5332
0
  h->plt.offset = (bfd_vma) -1;
5333
5334
  /* If this is a weak symbol, and there is a real definition, the
5335
     processor independent code will have arranged for us to see the
5336
     real definition first, and we can just use the same value.  */
5337
0
  if (h->is_weakalias)
5338
0
    {
5339
0
      struct elf_link_hash_entry *def = weakdef (h);
5340
0
      BFD_ASSERT (def->root.type == bfd_link_hash_defined);
5341
0
      h->root.u.def.section = def->root.u.def.section;
5342
0
      h->root.u.def.value = def->root.u.def.value;
5343
0
      return true;
5344
0
    }
5345
5346
  /* If there are no non-GOT references, we do not need a copy
5347
     relocation.  */
5348
0
  if (!h->non_got_ref)
5349
0
    return true;
5350
5351
  /* This is a reference to a symbol defined by a dynamic object which
5352
     is not a function.
5353
     If we are creating a shared library, we must presume that the
5354
     only references to the symbol are via the global offset table.
5355
     For such cases we need not do anything here; the relocations will
5356
     be handled correctly by relocate_section.  */
5357
0
  if (bfd_link_pic (info))
5358
0
    return true;
5359
5360
0
  if (h->size == 0)
5361
0
    {
5362
0
      _bfd_error_handler (_("dynamic variable `%s' is zero size"),
5363
0
        h->root.root.string);
5364
0
      return true;
5365
0
    }
5366
5367
  /* We must allocate the symbol in our .dynbss section, which will
5368
     become part of the .bss section of the executable.  There will be
5369
     an entry for this symbol in the .dynsym section.  The dynamic
5370
     object will contain position independent code, so all references
5371
     from the dynamic object to this symbol will go through the global
5372
     offset table.  The dynamic linker will use the .dynsym entry to
5373
     determine the address it must put in the global offset table, so
5374
     both the dynamic object and the regular object will refer to the
5375
     same memory location for the variable.  */
5376
  /* We must generate a R_NIOS2_COPY reloc to tell the dynamic linker to
5377
     copy the initial value out of the dynamic object and into the
5378
     runtime process image.  We need to remember the offset into the
5379
     .rela.bss section we are going to use.  */
5380
0
  if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
5381
0
    {
5382
0
      s = htab->root.sdynrelro;
5383
0
      srel = htab->root.sreldynrelro;
5384
0
    }
5385
0
  else
5386
0
    {
5387
0
      s = htab->root.sdynbss;
5388
0
      srel = htab->root.srelbss;
5389
0
    }
5390
0
  if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
5391
0
    {
5392
0
      srel->size += sizeof (Elf32_External_Rela);
5393
0
      h->needs_copy = 1;
5394
0
    }
5395
5396
0
  align2 = bfd_log2 (h->size);
5397
0
  if (align2 > h->root.u.def.section->alignment_power)
5398
0
    align2 = h->root.u.def.section->alignment_power;
5399
5400
  /* Align dynbss.  */
5401
0
  s->size = BFD_ALIGN (s->size, (bfd_size_type)1 << align2);
5402
0
  if (align2 > bfd_section_alignment (s)
5403
0
      && !bfd_set_section_alignment (s, align2))
5404
0
    return false;
5405
5406
  /* Define the symbol as being at this point in the section.  */
5407
0
  h->root.u.def.section = s;
5408
0
  h->root.u.def.value = s->size;
5409
5410
  /* Increment the section size to make room for the symbol.  */
5411
0
  s->size += h->size;
5412
5413
0
  return true;
5414
0
}
5415
5416
/* Worker function for nios2_elf32_late_size_sections.  */
5417
static bool
5418
adjust_dynrelocs (struct elf_link_hash_entry *h, void *inf)
5419
0
{
5420
0
  struct bfd_link_info *info;
5421
0
  struct elf32_nios2_link_hash_table *htab;
5422
5423
0
  if (h->root.type == bfd_link_hash_indirect)
5424
0
    return true;
5425
5426
0
  if (h->root.type == bfd_link_hash_warning)
5427
    /* When warning symbols are created, they **replace** the "real"
5428
       entry in the hash table, thus we never get to see the real
5429
       symbol in a hash traversal.  So look at it now.  */
5430
0
    h = (struct elf_link_hash_entry *) h->root.u.i.link;
5431
5432
0
  info = (struct bfd_link_info *) inf;
5433
0
  htab = elf32_nios2_hash_table (info);
5434
5435
0
  if (h->plt.offset != (bfd_vma)-1)
5436
0
    h->plt.offset += htab->res_n_size;
5437
0
  if (htab->root.splt == h->root.u.def.section)
5438
0
    h->root.u.def.value += htab->res_n_size;
5439
5440
0
  return true;
5441
0
}
5442
5443
/* Another worker function for nios2_elf32_late_size_sections.
5444
   Allocate space in .plt, .got and associated reloc sections for
5445
   dynamic relocs.  */
5446
static bool
5447
allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
5448
0
{
5449
0
  struct bfd_link_info *info;
5450
0
  struct elf32_nios2_link_hash_table *htab;
5451
0
  struct elf32_nios2_link_hash_entry *eh;
5452
0
  struct elf_dyn_relocs *p;
5453
0
  int use_plt;
5454
5455
0
  if (h->root.type == bfd_link_hash_indirect)
5456
0
    return true;
5457
5458
0
  if (h->root.type == bfd_link_hash_warning)
5459
    /* When warning symbols are created, they **replace** the "real"
5460
       entry in the hash table, thus we never get to see the real
5461
       symbol in a hash traversal.  So look at it now.  */
5462
0
    h = (struct elf_link_hash_entry *) h->root.u.i.link;
5463
5464
0
  info = (struct bfd_link_info *) inf;
5465
0
  htab = elf32_nios2_hash_table (info);
5466
5467
0
  if (htab->root.dynamic_sections_created
5468
0
      && h->plt.refcount > 0)
5469
0
    {
5470
      /* Make sure this symbol is output as a dynamic symbol.
5471
   Undefined weak syms won't yet be marked as dynamic.  */
5472
0
      if (h->dynindx == -1
5473
0
    && !h->forced_local
5474
0
    && !bfd_elf_link_record_dynamic_symbol (info, h))
5475
0
  return false;
5476
5477
0
      if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
5478
0
  {
5479
0
    asection *s = htab->root.splt;
5480
5481
    /* Allocate room for the header.  */
5482
0
    if (s->size == 0)
5483
0
      {
5484
0
        if (bfd_link_pic (info))
5485
0
    s->size = 24;
5486
0
        else
5487
0
    s->size = 28;
5488
0
      }
5489
5490
0
    h->plt.offset = s->size;
5491
5492
    /* If this symbol is not defined in a regular file, and we are
5493
       not generating a shared library, then set the symbol to this
5494
       location in the .plt.  This is required to make function
5495
       pointers compare as equal between the normal executable and
5496
       the shared library.  */
5497
0
    if (! bfd_link_pic (info)
5498
0
        && !h->def_regular)
5499
0
      {
5500
0
        h->root.u.def.section = s;
5501
0
        h->root.u.def.value = h->plt.offset;
5502
0
      }
5503
5504
    /* Make room for this entry.  */
5505
0
    s->size += 12;
5506
5507
    /* We also need to make an entry in the .rela.plt section.  */
5508
0
    htab->root.srelplt->size += sizeof (Elf32_External_Rela);
5509
5510
    /* And the .got.plt section.  */
5511
0
    htab->root.sgotplt->size += 4;
5512
0
  }
5513
0
      else
5514
0
  {
5515
0
    h->plt.offset = (bfd_vma) -1;
5516
0
    h->needs_plt = 0;
5517
0
  }
5518
0
    }
5519
0
  else
5520
0
    {
5521
0
      h->plt.offset = (bfd_vma) -1;
5522
0
      h->needs_plt = 0;
5523
0
    }
5524
5525
0
  eh = (struct elf32_nios2_link_hash_entry *) h;
5526
0
  use_plt = (eh->got_types_used == CALL_USED
5527
0
       && h->plt.offset != (bfd_vma) -1);
5528
5529
0
  if (h->got.refcount > 0)
5530
0
    {
5531
0
      asection *s;
5532
0
      bool dyn;
5533
0
      int tls_type = eh->tls_type;
5534
0
      int indx;
5535
5536
      /* Make sure this symbol is output as a dynamic symbol.
5537
   Undefined weak syms won't yet be marked as dynamic.  */
5538
0
      if (h->dynindx == -1
5539
0
    && !h->forced_local
5540
0
    && !bfd_elf_link_record_dynamic_symbol (info, h))
5541
0
  return false;
5542
5543
0
      s = htab->root.sgot;
5544
0
      h->got.offset = s->size;
5545
5546
0
      if (tls_type == GOT_UNKNOWN)
5547
0
  abort ();
5548
5549
0
      if (tls_type == GOT_NORMAL)
5550
  /* Non-TLS symbols need one GOT slot.  */
5551
0
  s->size += 4;
5552
0
      else
5553
0
  {
5554
0
    if (tls_type & GOT_TLS_GD)
5555
      /* R_NIOS2_TLS_GD16 needs 2 consecutive GOT slots.  */
5556
0
      s->size += 8;
5557
0
    if (tls_type & GOT_TLS_IE)
5558
      /* R_NIOS2_TLS_IE16 needs one GOT slot.  */
5559
0
      s->size += 4;
5560
0
  }
5561
5562
0
      dyn = htab->root.dynamic_sections_created;
5563
5564
0
      indx = 0;
5565
0
      if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h)
5566
0
    && (!bfd_link_pic (info)
5567
0
        || !SYMBOL_REFERENCES_LOCAL (info, h)))
5568
0
  indx = h->dynindx;
5569
5570
0
      if (tls_type != GOT_NORMAL
5571
0
    && (bfd_link_pic (info) || indx != 0)
5572
0
    && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5573
0
        || h->root.type != bfd_link_hash_undefweak))
5574
0
  {
5575
0
    if (tls_type & GOT_TLS_IE)
5576
0
      htab->root.srelgot->size += sizeof (Elf32_External_Rela);
5577
5578
0
    if (tls_type & GOT_TLS_GD)
5579
0
      htab->root.srelgot->size += sizeof (Elf32_External_Rela);
5580
5581
0
    if ((tls_type & GOT_TLS_GD) && indx != 0)
5582
0
      htab->root.srelgot->size += sizeof (Elf32_External_Rela);
5583
0
  }
5584
0
      else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5585
0
    || h->root.type != bfd_link_hash_undefweak)
5586
0
         && !use_plt
5587
0
         && (bfd_link_pic (info)
5588
0
       || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
5589
0
  htab->root.srelgot->size += sizeof (Elf32_External_Rela);
5590
0
    }
5591
0
  else
5592
0
    h->got.offset = (bfd_vma) -1;
5593
5594
0
  if (h->dyn_relocs == NULL)
5595
0
    return true;
5596
5597
  /* In the shared -Bsymbolic case, discard space allocated for
5598
     dynamic pc-relative relocs against symbols which turn out to be
5599
     defined in regular objects.  For the normal shared case, discard
5600
     space for pc-relative relocs that have become local due to symbol
5601
     visibility changes.  */
5602
5603
0
  if (bfd_link_pic (info))
5604
0
    {
5605
0
      if (h->def_regular
5606
0
    && (h->forced_local || SYMBOLIC_BIND (info, h)))
5607
0
  {
5608
0
    struct elf_dyn_relocs **pp;
5609
5610
0
    for (pp = &h->dyn_relocs; (p = *pp) != NULL; )
5611
0
      {
5612
0
        p->count -= p->pc_count;
5613
0
        p->pc_count = 0;
5614
0
        if (p->count == 0)
5615
0
    *pp = p->next;
5616
0
        else
5617
0
    pp = &p->next;
5618
0
      }
5619
0
  }
5620
5621
      /* Also discard relocs on undefined weak syms with non-default
5622
   visibility.  */
5623
0
      if (h->dyn_relocs != NULL
5624
0
    && h->root.type == bfd_link_hash_undefweak)
5625
0
  {
5626
0
    if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
5627
0
        || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
5628
0
      h->dyn_relocs = NULL;
5629
5630
    /* Make sure undefined weak symbols are output as a dynamic
5631
       symbol in PIEs.  */
5632
0
    else if (h->dynindx == -1
5633
0
       && !h->forced_local
5634
0
       && !bfd_elf_link_record_dynamic_symbol (info, h))
5635
0
      return false;
5636
0
  }
5637
0
    }
5638
0
  else
5639
0
    {
5640
      /* For the non-shared case, discard space for relocs against
5641
   symbols which turn out to need copy relocs or are not
5642
   dynamic.  */
5643
5644
0
      if (!h->non_got_ref
5645
0
    && ((h->def_dynamic && !h->def_regular)
5646
0
        || (htab->root.dynamic_sections_created
5647
0
      && (h->root.type == bfd_link_hash_undefweak
5648
0
          || h->root.type == bfd_link_hash_undefined))))
5649
0
  {
5650
    /* Make sure this symbol is output as a dynamic symbol.
5651
       Undefined weak syms won't yet be marked as dynamic.  */
5652
0
    if (h->dynindx == -1
5653
0
        && !h->forced_local
5654
0
        && !bfd_elf_link_record_dynamic_symbol (info, h))
5655
0
      return false;
5656
5657
    /* If that succeeded, we know we'll be keeping all the
5658
       relocs.  */
5659
0
    if (h->dynindx != -1)
5660
0
      goto keep;
5661
0
  }
5662
5663
0
      h->dyn_relocs = NULL;
5664
5665
0
    keep: ;
5666
0
    }
5667
5668
  /* Finally, allocate space.  */
5669
0
  for (p = h->dyn_relocs; p != NULL; p = p->next)
5670
0
    {
5671
0
      asection *sreloc = elf_section_data (p->sec)->sreloc;
5672
0
      sreloc->size += p->count * sizeof (Elf32_External_Rela);
5673
0
    }
5674
5675
0
  return true;
5676
0
}
5677
5678
/* Implement elf_backend_late_size_sections:
5679
   Set the sizes of the dynamic sections.  */
5680
static bool
5681
nios2_elf32_late_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
5682
        struct bfd_link_info *info)
5683
0
{
5684
0
  bfd *dynobj;
5685
0
  asection *s;
5686
0
  bool relocs;
5687
0
  bfd *ibfd;
5688
0
  struct elf32_nios2_link_hash_table *htab;
5689
5690
0
  htab = elf32_nios2_hash_table (info);
5691
0
  dynobj = htab->root.dynobj;
5692
0
  if (dynobj == NULL)
5693
0
    return true;
5694
5695
0
  htab->res_n_size = 0;
5696
0
  if (htab->root.dynamic_sections_created)
5697
0
    {
5698
      /* Set the contents of the .interp section to the interpreter.  */
5699
0
      if (bfd_link_executable (info) && !info->nointerp)
5700
0
  {
5701
0
    s = bfd_get_linker_section (dynobj, ".interp");
5702
0
    BFD_ASSERT (s != NULL);
5703
0
    s->size = sizeof ELF_DYNAMIC_INTERPRETER;
5704
0
    s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
5705
0
  }
5706
0
    }
5707
0
  else
5708
0
    {
5709
      /* We may have created entries in the .rela.got section.
5710
   However, if we are not creating the dynamic sections, we will
5711
   not actually use these entries.  Reset the size of .rela.got,
5712
   which will cause it to get stripped from the output file
5713
   below.  */
5714
0
      s = htab->root.srelgot;
5715
0
      if (s != NULL)
5716
0
  s->size = 0;
5717
0
    }
5718
5719
  /* Set up .got offsets for local syms, and space for local dynamic
5720
     relocs.  */
5721
0
  for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
5722
0
    {
5723
0
      bfd_signed_vma *local_got;
5724
0
      bfd_signed_vma *end_local_got;
5725
0
      char *local_tls_type;
5726
0
      bfd_size_type locsymcount;
5727
0
      Elf_Internal_Shdr *symtab_hdr;
5728
0
      asection *srel;
5729
5730
0
      if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
5731
0
  continue;
5732
5733
0
      for (s = ibfd->sections; s != NULL; s = s->next)
5734
0
  {
5735
0
    struct elf_dyn_relocs *p;
5736
5737
0
    for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
5738
0
      {
5739
0
        if (!bfd_is_abs_section (p->sec)
5740
0
      && bfd_is_abs_section (p->sec->output_section))
5741
0
    {
5742
      /* Input section has been discarded, either because
5743
         it is a copy of a linkonce section or due to
5744
         linker script /DISCARD/, so we'll be discarding
5745
         the relocs too.  */
5746
0
    }
5747
0
        else if (p->count != 0)
5748
0
    {
5749
0
      srel = elf_section_data (p->sec)->sreloc;
5750
0
      srel->size += p->count * sizeof (Elf32_External_Rela);
5751
0
    }
5752
0
      }
5753
0
  }
5754
5755
0
      local_got = elf_local_got_refcounts (ibfd);
5756
0
      if (!local_got)
5757
0
  continue;
5758
5759
0
      symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
5760
0
      locsymcount = symtab_hdr->sh_info;
5761
0
      end_local_got = local_got + locsymcount;
5762
0
      local_tls_type = elf32_nios2_local_got_tls_type (ibfd);
5763
0
      s = htab->root.sgot;
5764
0
      srel = htab->root.srelgot;
5765
0
      for (; local_got < end_local_got; ++local_got, ++local_tls_type)
5766
0
  {
5767
0
    if (*local_got > 0)
5768
0
      {
5769
0
        *local_got = s->size;
5770
0
        if (*local_tls_type & GOT_TLS_GD)
5771
    /* TLS_GD relocs need an 8-byte structure in the GOT.  */
5772
0
    s->size += 8;
5773
0
        if (*local_tls_type & GOT_TLS_IE)
5774
0
    s->size += 4;
5775
0
        if (*local_tls_type == GOT_NORMAL)
5776
0
    s->size += 4;
5777
5778
0
        if (bfd_link_pic (info) || *local_tls_type == GOT_TLS_GD)
5779
0
    srel->size += sizeof (Elf32_External_Rela);
5780
0
      }
5781
0
    else
5782
0
      *local_got = (bfd_vma) -1;
5783
0
  }
5784
0
    }
5785
5786
0
  if (htab->tls_ldm_got.refcount > 0)
5787
0
    {
5788
      /* Allocate two GOT entries and one dynamic relocation (if necessary)
5789
   for R_NIOS2_TLS_LDM16 relocations.  */
5790
0
      htab->tls_ldm_got.offset = htab->root.sgot->size;
5791
0
      htab->root.sgot->size += 8;
5792
0
      if (bfd_link_pic (info))
5793
0
  htab->root.srelgot->size += sizeof (Elf32_External_Rela);
5794
0
    }
5795
0
  else
5796
0
    htab->tls_ldm_got.offset = -1;
5797
5798
  /* Allocate global sym .plt and .got entries, and space for global
5799
     sym dynamic relocs.  */
5800
0
  elf_link_hash_traverse (& htab->root, allocate_dynrelocs, info);
5801
5802
0
  if (htab->root.dynamic_sections_created)
5803
0
    {
5804
      /* If the .got section is more than 0x8000 bytes, we add
5805
   0x8000 to the value of _gp_got, so that 16-bit relocations
5806
   have a greater chance of working. */
5807
0
      if (htab->root.sgot->size >= 0x8000
5808
0
    && htab->h_gp_got->root.u.def.value == 0)
5809
0
  htab->h_gp_got->root.u.def.value = 0x8000;
5810
0
    }
5811
5812
  /* The check_relocs and adjust_dynamic_symbol entry points have
5813
     determined the sizes of the various dynamic sections.  Allocate
5814
     memory for them.  */
5815
0
  relocs = false;
5816
0
  for (s = dynobj->sections; s != NULL; s = s->next)
5817
0
    {
5818
0
      const char *name;
5819
5820
0
      if ((s->flags & SEC_LINKER_CREATED) == 0)
5821
0
  continue;
5822
5823
      /* It's OK to base decisions on the section name, because none
5824
   of the dynobj section names depend upon the input files.  */
5825
0
      name = bfd_section_name (s);
5826
5827
0
      if (startswith (name, ".rela"))
5828
0
  {
5829
0
    if (s->size != 0)
5830
0
      {
5831
0
        if (s != htab->root.srelplt)
5832
0
    relocs = true;
5833
5834
        /* We use the reloc_count field as a counter if we need
5835
     to copy relocs into the output file.  */
5836
0
        s->reloc_count = 0;
5837
0
      }
5838
0
  }
5839
0
      else if (s == htab->root.splt)
5840
0
  {
5841
    /* Correct for the number of res_N branches.  */
5842
0
    if (s->size != 0 && !bfd_link_pic (info))
5843
0
      {
5844
0
        htab->res_n_size = (s->size - 28) / 3;
5845
0
        s->size += htab->res_n_size;
5846
0
      }
5847
0
  }
5848
0
      else if (s != htab->sbss
5849
0
         && s != htab->root.sgot
5850
0
         && s != htab->root.sgotplt
5851
0
         && s != htab->root.sdynbss
5852
0
         && s != htab->root.sdynrelro)
5853
  /* It's not one of our sections, so don't allocate space.  */
5854
0
  continue;
5855
5856
0
      if (s->size == 0)
5857
0
  {
5858
0
    s->flags |= SEC_EXCLUDE;
5859
0
    continue;
5860
0
  }
5861
5862
0
      if ((s->flags & SEC_HAS_CONTENTS) == 0)
5863
0
  continue;
5864
5865
      /* Allocate memory for the section contents.  */
5866
0
      s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
5867
0
      if (s->contents == NULL)
5868
0
  return false;
5869
0
    }
5870
5871
  /* Adjust dynamic symbols that point to the plt to account for the
5872
     now-known number of resN slots.  */
5873
0
  if (htab->res_n_size)
5874
0
    elf_link_hash_traverse (& htab->root, adjust_dynrelocs, info);
5875
5876
0
  return _bfd_elf_add_dynamic_tags (output_bfd, info, relocs);
5877
0
}
5878
5879
/* Free the derived linker hash table.  */
5880
static void
5881
nios2_elf32_link_hash_table_free (bfd *obfd)
5882
0
{
5883
0
  struct elf32_nios2_link_hash_table *htab
5884
0
    = (struct elf32_nios2_link_hash_table *) obfd->link.hash;
5885
5886
0
  bfd_hash_table_free (&htab->bstab);
5887
0
  _bfd_elf_link_hash_table_free (obfd);
5888
0
}
5889
5890
/* Implement bfd_elf32_bfd_link_hash_table_create.  */
5891
static struct bfd_link_hash_table *
5892
nios2_elf32_link_hash_table_create (bfd *abfd)
5893
0
{
5894
0
  struct elf32_nios2_link_hash_table *ret;
5895
0
  size_t amt = sizeof (struct elf32_nios2_link_hash_table);
5896
5897
0
  ret = bfd_zmalloc (amt);
5898
0
  if (ret == NULL)
5899
0
    return NULL;
5900
5901
0
  if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
5902
0
              link_hash_newfunc,
5903
0
              sizeof (struct
5904
0
                elf32_nios2_link_hash_entry),
5905
0
              NIOS2_ELF_DATA))
5906
0
    {
5907
0
      free (ret);
5908
0
      return NULL;
5909
0
    }
5910
5911
  /* Init the stub hash table too.  */
5912
0
  if (!bfd_hash_table_init (&ret->bstab, stub_hash_newfunc,
5913
0
          sizeof (struct elf32_nios2_stub_hash_entry)))
5914
0
    {
5915
0
      _bfd_elf_link_hash_table_free (abfd);
5916
0
      return NULL;
5917
0
    }
5918
0
  ret->root.root.hash_table_free = nios2_elf32_link_hash_table_free;
5919
5920
0
  return &ret->root.root;
5921
0
}
5922
5923
/* Implement elf_backend_reloc_type_class.  */
5924
static enum elf_reloc_type_class
5925
nios2_elf32_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
5926
            const asection *rel_sec ATTRIBUTE_UNUSED,
5927
            const Elf_Internal_Rela *rela)
5928
0
{
5929
0
  switch ((int) ELF32_R_TYPE (rela->r_info))
5930
0
    {
5931
0
    case R_NIOS2_RELATIVE:
5932
0
      return reloc_class_relative;
5933
0
    case R_NIOS2_JUMP_SLOT:
5934
0
      return reloc_class_plt;
5935
0
    case R_NIOS2_COPY:
5936
0
      return reloc_class_copy;
5937
0
    default:
5938
0
      return reloc_class_normal;
5939
0
    }
5940
0
}
5941
5942
/* Return 1 if target is one of ours.  */
5943
static bool
5944
is_nios2_elf_target (const struct bfd_target *targ)
5945
0
{
5946
0
  return (targ == &nios2_elf32_le_vec
5947
0
    || targ == &nios2_elf32_be_vec);
5948
0
}
5949
5950
/* Implement elf_backend_add_symbol_hook.
5951
   This hook is called by the linker when adding symbols from an object
5952
   file.  We use it to put .comm items in .sbss, and not .bss.  */
5953
static bool
5954
nios2_elf_add_symbol_hook (bfd *abfd,
5955
         struct bfd_link_info *info,
5956
         Elf_Internal_Sym *sym,
5957
         const char **namep ATTRIBUTE_UNUSED,
5958
         flagword *flagsp ATTRIBUTE_UNUSED,
5959
         asection **secp,
5960
         bfd_vma *valp)
5961
0
{
5962
0
  if (sym->st_shndx == SHN_COMMON
5963
0
      && !bfd_link_relocatable (info)
5964
0
      && sym->st_size <= elf_gp_size (abfd)
5965
0
      && is_nios2_elf_target (info->output_bfd->xvec))
5966
0
    {
5967
      /* Common symbols less than or equal to -G nn bytes are automatically
5968
   put into .sbss.  */
5969
0
      struct elf32_nios2_link_hash_table *htab;
5970
5971
0
      htab = elf32_nios2_hash_table (info);
5972
0
      if (htab->sbss == NULL)
5973
0
  {
5974
0
    flagword flags = SEC_IS_COMMON | SEC_SMALL_DATA | SEC_LINKER_CREATED;
5975
5976
0
    if (htab->root.dynobj == NULL)
5977
0
      htab->root.dynobj = abfd;
5978
5979
0
    htab->sbss = bfd_make_section_anyway_with_flags (htab->root.dynobj,
5980
0
                 ".sbss", flags);
5981
0
    if (htab->sbss == NULL)
5982
0
      return false;
5983
0
  }
5984
5985
0
      *secp = htab->sbss;
5986
0
      *valp = sym->st_size;
5987
0
    }
5988
5989
0
  return true;
5990
0
}
5991
5992
/* Implement elf_backend_can_make_relative_eh_frame:
5993
   Decide whether to attempt to turn absptr or lsda encodings in
5994
   shared libraries into pcrel within the given input section.  */
5995
static bool
5996
nios2_elf32_can_make_relative_eh_frame (bfd *input_bfd ATTRIBUTE_UNUSED,
5997
          struct bfd_link_info *info
5998
          ATTRIBUTE_UNUSED,
5999
          asection *eh_frame_section
6000
          ATTRIBUTE_UNUSED)
6001
0
{
6002
  /* We can't use PC-relative encodings in the .eh_frame section.  */
6003
0
  return false;
6004
0
}
6005
6006
/* Implement elf_backend_special_sections.  */
6007
const struct bfd_elf_special_section elf32_nios2_special_sections[] =
6008
{
6009
  { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,
6010
    SHF_ALLOC + SHF_WRITE + SHF_NIOS2_GPREL },
6011
  { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS,
6012
    SHF_ALLOC + SHF_WRITE + SHF_NIOS2_GPREL },
6013
  { NULL,         0,  0, 0,        0 }
6014
};
6015
6016
#define ELF_ARCH      bfd_arch_nios2
6017
#define ELF_TARGET_ID     NIOS2_ELF_DATA
6018
#define ELF_MACHINE_CODE    EM_ALTERA_NIOS2
6019
6020
/* The Nios II MMU uses a 4K page size.  */
6021
6022
#define ELF_MAXPAGESIZE     0x1000
6023
6024
#define bfd_elf32_bfd_link_hash_table_create \
6025
            nios2_elf32_link_hash_table_create
6026
6027
#define bfd_elf32_bfd_merge_private_bfd_data \
6028
            nios2_elf32_merge_private_bfd_data
6029
6030
/* Relocation table lookup macros.  */
6031
6032
#define bfd_elf32_bfd_reloc_type_lookup   nios2_elf32_bfd_reloc_type_lookup
6033
#define bfd_elf32_bfd_reloc_name_lookup   nios2_elf32_bfd_reloc_name_lookup
6034
6035
/* JUMP_TABLE_LINK macros.  */
6036
6037
/* elf_info_to_howto (using RELA relocations).  */
6038
6039
#define elf_info_to_howto     nios2_elf32_info_to_howto
6040
6041
/* elf backend functions.  */
6042
6043
#define elf_backend_can_gc_sections 1
6044
#define elf_backend_can_refcount  1
6045
#define elf_backend_plt_readonly  1
6046
#define elf_backend_want_got_plt  1
6047
#define elf_backend_want_dynrelro 1
6048
#define elf_backend_rela_normal   1
6049
#define elf_backend_dtrel_excludes_plt  1
6050
6051
#define elf_backend_relocate_section    nios2_elf32_relocate_section
6052
#define elf_backend_section_flags   nios2_elf32_section_flags
6053
#define elf_backend_fake_sections   nios2_elf32_fake_sections
6054
#define elf_backend_check_relocs    nios2_elf32_check_relocs
6055
6056
#define elf_backend_gc_mark_hook    nios2_elf32_gc_mark_hook
6057
#define elf_backend_create_dynamic_sections \
6058
            nios2_elf32_create_dynamic_sections
6059
#define elf_backend_finish_dynamic_symbol nios2_elf32_finish_dynamic_symbol
6060
#define elf_backend_finish_dynamic_sections \
6061
            nios2_elf32_finish_dynamic_sections
6062
#define elf_backend_adjust_dynamic_symbol nios2_elf32_adjust_dynamic_symbol
6063
#define elf_backend_reloc_type_class    nios2_elf32_reloc_type_class
6064
#define elf_backend_late_size_sections    nios2_elf32_late_size_sections
6065
#define elf_backend_add_symbol_hook   nios2_elf_add_symbol_hook
6066
#define elf_backend_copy_indirect_symbol  nios2_elf32_copy_indirect_symbol
6067
#define elf_backend_object_p      nios2_elf32_object_p
6068
6069
#define elf_backend_grok_prstatus   nios2_grok_prstatus
6070
#define elf_backend_grok_psinfo     nios2_grok_psinfo
6071
6072
#undef elf_backend_can_make_relative_eh_frame
6073
#define elf_backend_can_make_relative_eh_frame \
6074
            nios2_elf32_can_make_relative_eh_frame
6075
6076
#define elf_backend_special_sections    elf32_nios2_special_sections
6077
6078
#define TARGET_LITTLE_SYM   nios2_elf32_le_vec
6079
#define TARGET_LITTLE_NAME    "elf32-littlenios2"
6080
#define TARGET_BIG_SYM      nios2_elf32_be_vec
6081
#define TARGET_BIG_NAME     "elf32-bignios2"
6082
6083
#define elf_backend_got_header_size 12
6084
#define elf_backend_default_execstack 0
6085
6086
#include "elf32-target.h"