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