projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
unrecognized/unsupported reloc message
[deliverable/binutils-gdb.git] / bfd / elf64-mmix.c
CommitLineData
3c3bdf30 1/* MMIX-specific support for 64-bit ELF.
219d1afa 2 Copyright (C) 2001-2018 Free Software Foundation, Inc.
3c3bdf30
NC		 3 Contributed by Hans-Peter Nilsson <hp@bitrange.com>
4
cd123cb7 5 This file is part of BFD, the Binary File Descriptor library.
3c3bdf30 6
cd123cb7
NC		 7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
3c3bdf30 11
cd123cb7
NC		 12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
3c3bdf30 21
3c3bdf30
NC		 22
23/* No specific ABI or "processor-specific supplement" defined. */
24
25/* TODO:
f60ebe14
HPN		 26 - "Traditional" linker relaxation (shrinking whole sections).
27 - Merge reloc stubs jumping to same location.
28 - GETA stub relaxation (call a stub for out of range new
29 R_MMIX_GETA_STUBBABLE). */
3c3bdf30 30
3c3bdf30 31#include "sysdep.h"
3db64b00 32#include "bfd.h"
3c3bdf30
NC		 33#include "libbfd.h"
34#include "elf-bfd.h"
35#include "elf/mmix.h"
36#include "opcode/mmix.h"
37
38#define MINUS_ONE (((bfd_vma) 0) - 1)
39
f60ebe14
HPN		 40#define MAX_PUSHJ_STUB_SIZE (5 * 4)
41
3c3bdf30
NC		 42/* Put these everywhere in new code. */
43#define FATAL_DEBUG \
44 _bfd_abort (__FILE__, __LINE__, \
45 "Internal: Non-debugged code (test-case missing)")
46
47#define BAD_CASE(x) \
48 _bfd_abort (__FILE__, __LINE__, \
49 "bad case for " #x)
50
f0abc2a1
AM		 51struct _mmix_elf_section_data
52{
53 struct bfd_elf_section_data elf;
54 union
55 {
56 struct bpo_reloc_section_info *reloc;
57 struct bpo_greg_section_info *greg;
58 } bpo;
f60ebe14
HPN		 59
60 struct pushj_stub_info
61 {
62 /* Maximum number of stubs needed for this section. */
63 bfd_size_type n_pushj_relocs;
64
65 /* Size of stubs after a mmix_elf_relax_section round. */
66 bfd_size_type stubs_size_sum;
67
68 /* Per-reloc stubs_size_sum information. The stubs_size_sum member is the sum
69 of these. Allocated in mmix_elf_check_common_relocs. */
70 bfd_size_type *stub_size;
71
72 /* Offset of next stub during relocation. Somewhat redundant with the
73 above: error coverage is easier and we don't have to reset the
74 stubs_size_sum for relocation. */
75 bfd_size_type stub_offset;
76 } pjs;
18978b27
HPN		 77
78 /* Whether there has been a warning that this section could not be
79 linked due to a specific cause. FIXME: a way to access the
80 linker info or output section, then stuff the limiter guard
81 there. */
82 bfd_boolean has_warned_bpo;
83 bfd_boolean has_warned_pushj;
f0abc2a1
AM		 84};
85
86#define mmix_elf_section_data(sec) \
68bfbfcc 87 ((struct _mmix_elf_section_data *) elf_section_data (sec))
f0abc2a1 88
930b4cb2 89/* For each section containing a base-plus-offset (BPO) reloc, we attach
f0abc2a1 90 this struct as mmix_elf_section_data (section)->bpo, which is otherwise
930b4cb2
HPN		 91 NULL. */
92struct bpo_reloc_section_info
93 {
94 /* The base is 1; this is the first number in this section. */
95 size_t first_base_plus_offset_reloc;
96
97 /* Number of BPO-relocs in this section. */
98 size_t n_bpo_relocs_this_section;
99
100 /* Running index, used at relocation time. */
101 size_t bpo_index;
102
103 /* We don't have access to the bfd_link_info struct in
104 mmix_final_link_relocate. What we really want to get at is the
105 global single struct greg_relocation, so we stash it here. */
106 asection *bpo_greg_section;
107 };
108
109/* Helper struct (in global context) for the one below.
110 There's one of these created for every BPO reloc. */
111struct bpo_reloc_request
112 {
113 bfd_vma value;
114
115 /* Valid after relaxation. The base is 0; the first register number
116 must be added. The offset is in range 0..255. */
117 size_t regindex;
118 size_t offset;
119
120 /* The order number for this BPO reloc, corresponding to the order in
121 which BPO relocs were found. Used to create an index after reloc
122 requests are sorted. */
123 size_t bpo_reloc_no;
124
125 /* Set when the value is computed. Better than coding "guard values"
b34976b6 126 into the other members. Is FALSE only for BPO relocs in a GC:ed
930b4cb2 127 section. */
b34976b6 128 bfd_boolean valid;
930b4cb2
HPN		 129 };
130
f0abc2a1 131/* We attach this as mmix_elf_section_data (sec)->bpo in the linker-allocated
930b4cb2
HPN		 132 greg contents section (MMIX_LD_ALLOCATED_REG_CONTENTS_SECTION_NAME),
133 which is linked into the register contents section
134 (MMIX_REG_CONTENTS_SECTION_NAME). This section is created by the
135 linker; using the same hook as for usual with BPO relocs does not
136 collide. */
137struct bpo_greg_section_info
138 {
139 /* After GC, this reflects the number of remaining, non-excluded
140 BPO-relocs. */
141 size_t n_bpo_relocs;
142
143 /* This is the number of allocated bpo_reloc_requests; the size of
144 sorted_indexes. Valid after the check.*relocs functions are called
145 for all incoming sections. It includes the number of BPO relocs in
146 sections that were GC:ed. */
147 size_t n_max_bpo_relocs;
148
149 /* A counter used to find out when to fold the BPO gregs, since we
150 don't have a single "after-relaxation" hook. */
151 size_t n_remaining_bpo_relocs_this_relaxation_round;
152
153 /* The number of linker-allocated GREGs resulting from BPO relocs.
f60ebe14
HPN		 154 This is an approximation after _bfd_mmix_before_linker_allocation
155 and supposedly accurate after mmix_elf_relax_section is called for
156 all incoming non-collected sections. */
930b4cb2
HPN		 157 size_t n_allocated_bpo_gregs;
158
159 /* Index into reloc_request[], sorted on increasing "value", secondary
160 by increasing index for strict sorting order. */
161 size_t *bpo_reloc_indexes;
162
163 /* An array of all relocations, with the "value" member filled in by
164 the relaxation function. */
165 struct bpo_reloc_request *reloc_request;
166 };
167
3c3bdf30 168
2c3fc389 169extern bfd_boolean mmix_elf_final_link (bfd *, struct bfd_link_info *);
3c3bdf30 170
2c3fc389 171extern void mmix_elf_symbol_processing (bfd *, asymbol *);
3c3bdf30 172
4fa5c2a8
HPN		 173/* Only intended to be called from a debugger. */
174extern void mmix_dump_bpo_gregs
52d45da3 175 (struct bfd_link_info *, void (*) (const char *, ...));
4fa5c2a8 176
f60ebe14 177static void
2c3fc389
NC		 178mmix_set_relaxable_size (bfd *, asection *, void *);
179static bfd_reloc_status_type
180mmix_elf_reloc (bfd *, arelent *, asymbol *, void *,
181 asection *, bfd *, char **);
182static bfd_reloc_status_type
183mmix_final_link_relocate (reloc_howto_type *, asection *, bfd_byte *, bfd_vma,
184 bfd_signed_vma, bfd_vma, const char *, asection *,
185 char **);
f60ebe14 186
f60ebe14 187
3c3bdf30
NC		 188/* Watch out: this currently needs to have elements with the same index as
189 their R_MMIX_ number. */
190static reloc_howto_type elf_mmix_howto_table[] =
191 {
192 /* This reloc does nothing. */
193 HOWTO (R_MMIX_NONE, /* type */
194 0, /* rightshift */
6346d5ca
AM		 195 3, /* size (0 = byte, 1 = short, 2 = long) */
196 0, /* bitsize */
b34976b6 197 FALSE, /* pc_relative */
3c3bdf30 198 0, /* bitpos */
6346d5ca 199 complain_overflow_dont, /* complain_on_overflow */
3c3bdf30
NC		 200 bfd_elf_generic_reloc, /* special_function */
201 "R_MMIX_NONE", /* name */
b34976b6 202 FALSE, /* partial_inplace */
3c3bdf30
NC		 203 0, /* src_mask */
204 0, /* dst_mask */
b34976b6 205 FALSE), /* pcrel_offset */
3c3bdf30
NC		 206
207 /* An 8 bit absolute relocation. */
208 HOWTO (R_MMIX_8, /* type */
209 0, /* rightshift */
210 0, /* size (0 = byte, 1 = short, 2 = long) */
211 8, /* bitsize */
b34976b6 212 FALSE, /* pc_relative */
3c3bdf30
NC		 213 0, /* bitpos */
214 complain_overflow_bitfield, /* complain_on_overflow */
215 bfd_elf_generic_reloc, /* special_function */
216 "R_MMIX_8", /* name */
b34976b6 217 FALSE, /* partial_inplace */
930b4cb2 218 0, /* src_mask */
3c3bdf30 219 0xff, /* dst_mask */
b34976b6 220 FALSE), /* pcrel_offset */
3c3bdf30
NC		 221
222 /* An 16 bit absolute relocation. */
223 HOWTO (R_MMIX_16, /* type */
224 0, /* rightshift */
225 1, /* size (0 = byte, 1 = short, 2 = long) */
226 16, /* bitsize */
b34976b6 227 FALSE, /* pc_relative */
3c3bdf30
NC		 228 0, /* bitpos */
229 complain_overflow_bitfield, /* complain_on_overflow */
230 bfd_elf_generic_reloc, /* special_function */
231 "R_MMIX_16", /* name */
b34976b6 232 FALSE, /* partial_inplace */
930b4cb2 233 0, /* src_mask */
3c3bdf30 234 0xffff, /* dst_mask */
b34976b6 235 FALSE), /* pcrel_offset */
3c3bdf30
NC		 236
237 /* An 24 bit absolute relocation. */
238 HOWTO (R_MMIX_24, /* type */
239 0, /* rightshift */
240 2, /* size (0 = byte, 1 = short, 2 = long) */
241 24, /* bitsize */
b34976b6 242 FALSE, /* pc_relative */
3c3bdf30
NC		 243 0, /* bitpos */
244 complain_overflow_bitfield, /* complain_on_overflow */
245 bfd_elf_generic_reloc, /* special_function */
246 "R_MMIX_24", /* name */
b34976b6 247 FALSE, /* partial_inplace */
930b4cb2 248 ~0xffffff, /* src_mask */
3c3bdf30 249 0xffffff, /* dst_mask */
b34976b6 250 FALSE), /* pcrel_offset */
3c3bdf30
NC		 251
252 /* A 32 bit absolute relocation. */
253 HOWTO (R_MMIX_32, /* type */
254 0, /* rightshift */
255 2, /* size (0 = byte, 1 = short, 2 = long) */
256 32, /* bitsize */
b34976b6 257 FALSE, /* pc_relative */
3c3bdf30
NC		 258 0, /* bitpos */
259 complain_overflow_bitfield, /* complain_on_overflow */
260 bfd_elf_generic_reloc, /* special_function */
261 "R_MMIX_32", /* name */
b34976b6 262 FALSE, /* partial_inplace */
930b4cb2 263 0, /* src_mask */
3c3bdf30 264 0xffffffff, /* dst_mask */
b34976b6 265 FALSE), /* pcrel_offset */
3c3bdf30
NC		 266
267 /* 64 bit relocation. */
268 HOWTO (R_MMIX_64, /* type */
269 0, /* rightshift */
270 4, /* size (0 = byte, 1 = short, 2 = long) */
271 64, /* bitsize */
b34976b6 272 FALSE, /* pc_relative */
3c3bdf30
NC		 273 0, /* bitpos */
274 complain_overflow_bitfield, /* complain_on_overflow */
275 bfd_elf_generic_reloc, /* special_function */
276 "R_MMIX_64", /* name */
b34976b6 277 FALSE, /* partial_inplace */
930b4cb2 278 0, /* src_mask */
3c3bdf30 279 MINUS_ONE, /* dst_mask */
b34976b6 280 FALSE), /* pcrel_offset */
3c3bdf30
NC		 281
282 /* An 8 bit PC-relative relocation. */
283 HOWTO (R_MMIX_PC_8, /* type */
284 0, /* rightshift */
285 0, /* size (0 = byte, 1 = short, 2 = long) */
286 8, /* bitsize */
b34976b6 287 TRUE, /* pc_relative */
3c3bdf30
NC		 288 0, /* bitpos */
289 complain_overflow_bitfield, /* complain_on_overflow */
290 bfd_elf_generic_reloc, /* special_function */
291 "R_MMIX_PC_8", /* name */
b34976b6 292 FALSE, /* partial_inplace */
930b4cb2 293 0, /* src_mask */
3c3bdf30 294 0xff, /* dst_mask */
b34976b6 295 TRUE), /* pcrel_offset */
3c3bdf30
NC		 296
297 /* An 16 bit PC-relative relocation. */
298 HOWTO (R_MMIX_PC_16, /* type */
299 0, /* rightshift */
300 1, /* size (0 = byte, 1 = short, 2 = long) */
301 16, /* bitsize */
b34976b6 302 TRUE, /* pc_relative */
3c3bdf30
NC		 303 0, /* bitpos */
304 complain_overflow_bitfield, /* complain_on_overflow */
305 bfd_elf_generic_reloc, /* special_function */
306 "R_MMIX_PC_16", /* name */
b34976b6 307 FALSE, /* partial_inplace */
930b4cb2 308 0, /* src_mask */
3c3bdf30 309 0xffff, /* dst_mask */
b34976b6 310 TRUE), /* pcrel_offset */
3c3bdf30
NC		 311
312 /* An 24 bit PC-relative relocation. */
313 HOWTO (R_MMIX_PC_24, /* type */
314 0, /* rightshift */
315 2, /* size (0 = byte, 1 = short, 2 = long) */
316 24, /* bitsize */
b34976b6 317 TRUE, /* pc_relative */
3c3bdf30
NC		 318 0, /* bitpos */
319 complain_overflow_bitfield, /* complain_on_overflow */
320 bfd_elf_generic_reloc, /* special_function */
321 "R_MMIX_PC_24", /* name */
b34976b6 322 FALSE, /* partial_inplace */
930b4cb2 323 ~0xffffff, /* src_mask */
3c3bdf30 324 0xffffff, /* dst_mask */
b34976b6 325 TRUE), /* pcrel_offset */
3c3bdf30
NC		 326
327 /* A 32 bit absolute PC-relative relocation. */
328 HOWTO (R_MMIX_PC_32, /* type */
329 0, /* rightshift */
330 2, /* size (0 = byte, 1 = short, 2 = long) */
331 32, /* bitsize */
b34976b6 332 TRUE, /* pc_relative */
3c3bdf30
NC		 333 0, /* bitpos */
334 complain_overflow_bitfield, /* complain_on_overflow */
335 bfd_elf_generic_reloc, /* special_function */
336 "R_MMIX_PC_32", /* name */
b34976b6 337 FALSE, /* partial_inplace */
930b4cb2 338 0, /* src_mask */
3c3bdf30 339 0xffffffff, /* dst_mask */
b34976b6 340 TRUE), /* pcrel_offset */
3c3bdf30
NC		 341
342 /* 64 bit PC-relative relocation. */
343 HOWTO (R_MMIX_PC_64, /* type */
344 0, /* rightshift */
345 4, /* size (0 = byte, 1 = short, 2 = long) */
346 64, /* bitsize */
b34976b6 347 TRUE, /* pc_relative */
3c3bdf30
NC		 348 0, /* bitpos */
349 complain_overflow_bitfield, /* complain_on_overflow */
350 bfd_elf_generic_reloc, /* special_function */
351 "R_MMIX_PC_64", /* name */
b34976b6 352 FALSE, /* partial_inplace */
930b4cb2 353 0, /* src_mask */
3c3bdf30 354 MINUS_ONE, /* dst_mask */
b34976b6 355 TRUE), /* pcrel_offset */
3c3bdf30
NC		 356
357 /* GNU extension to record C++ vtable hierarchy. */
358 HOWTO (R_MMIX_GNU_VTINHERIT, /* type */
359 0, /* rightshift */
360 0, /* size (0 = byte, 1 = short, 2 = long) */
361 0, /* bitsize */
b34976b6 362 FALSE, /* pc_relative */
3c3bdf30
NC		 363 0, /* bitpos */
364 complain_overflow_dont, /* complain_on_overflow */
365 NULL, /* special_function */
366 "R_MMIX_GNU_VTINHERIT", /* name */
b34976b6 367 FALSE, /* partial_inplace */
3c3bdf30
NC		 368 0, /* src_mask */
369 0, /* dst_mask */
b34976b6 370 TRUE), /* pcrel_offset */
3c3bdf30
NC		 371
372 /* GNU extension to record C++ vtable member usage. */
373 HOWTO (R_MMIX_GNU_VTENTRY, /* type */
374 0, /* rightshift */
375 0, /* size (0 = byte, 1 = short, 2 = long) */
376 0, /* bitsize */
b34976b6 377 FALSE, /* pc_relative */
3c3bdf30
NC		 378 0, /* bitpos */
379 complain_overflow_dont, /* complain_on_overflow */
380 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
381 "R_MMIX_GNU_VTENTRY", /* name */
b34976b6 382 FALSE, /* partial_inplace */
3c3bdf30
NC		 383 0, /* src_mask */
384 0, /* dst_mask */
b34976b6 385 FALSE), /* pcrel_offset */
3c3bdf30
NC		 386
387 /* The GETA relocation is supposed to get any address that could
388 possibly be reached by the GETA instruction. It can silently expand
389 to get a 64-bit operand, but will complain if any of the two least
390 significant bits are set. The howto members reflect a simple GETA. */
391 HOWTO (R_MMIX_GETA, /* type */
392 2, /* rightshift */
393 2, /* size (0 = byte, 1 = short, 2 = long) */
394 19, /* bitsize */
b34976b6 395 TRUE, /* pc_relative */
3c3bdf30
NC		 396 0, /* bitpos */
397 complain_overflow_signed, /* complain_on_overflow */
398 mmix_elf_reloc, /* special_function */
399 "R_MMIX_GETA", /* name */
b34976b6 400 FALSE, /* partial_inplace */
930b4cb2 401 ~0x0100ffff, /* src_mask */
3c3bdf30 402 0x0100ffff, /* dst_mask */
b34976b6 403 TRUE), /* pcrel_offset */
3c3bdf30
NC		 404
405 HOWTO (R_MMIX_GETA_1, /* type */
406 2, /* rightshift */
407 2, /* size (0 = byte, 1 = short, 2 = long) */
408 19, /* bitsize */
b34976b6 409 TRUE, /* pc_relative */
3c3bdf30
NC		 410 0, /* bitpos */
411 complain_overflow_signed, /* complain_on_overflow */
412 mmix_elf_reloc, /* special_function */
413 "R_MMIX_GETA_1", /* name */
b34976b6 414 FALSE, /* partial_inplace */
930b4cb2 415 ~0x0100ffff, /* src_mask */
3c3bdf30 416 0x0100ffff, /* dst_mask */
b34976b6 417 TRUE), /* pcrel_offset */
3c3bdf30
NC		 418
419 HOWTO (R_MMIX_GETA_2, /* type */
420 2, /* rightshift */
421 2, /* size (0 = byte, 1 = short, 2 = long) */
422 19, /* bitsize */
b34976b6 423 TRUE, /* pc_relative */
3c3bdf30
NC		 424 0, /* bitpos */
425 complain_overflow_signed, /* complain_on_overflow */
426 mmix_elf_reloc, /* special_function */
427 "R_MMIX_GETA_2", /* name */
b34976b6 428 FALSE, /* partial_inplace */
930b4cb2 429 ~0x0100ffff, /* src_mask */
3c3bdf30 430 0x0100ffff, /* dst_mask */
b34976b6 431 TRUE), /* pcrel_offset */
3c3bdf30
NC		 432
433 HOWTO (R_MMIX_GETA_3, /* type */
434 2, /* rightshift */
435 2, /* size (0 = byte, 1 = short, 2 = long) */
436 19, /* bitsize */
b34976b6 437 TRUE, /* pc_relative */
3c3bdf30
NC		 438 0, /* bitpos */
439 complain_overflow_signed, /* complain_on_overflow */
440 mmix_elf_reloc, /* special_function */
441 "R_MMIX_GETA_3", /* name */
b34976b6 442 FALSE, /* partial_inplace */
930b4cb2 443 ~0x0100ffff, /* src_mask */
3c3bdf30 444 0x0100ffff, /* dst_mask */
b34976b6 445 TRUE), /* pcrel_offset */
3c3bdf30
NC		 446
447 /* The conditional branches are supposed to reach any (code) address.
448 It can silently expand to a 64-bit operand, but will emit an error if
449 any of the two least significant bits are set. The howto members
450 reflect a simple branch. */
451 HOWTO (R_MMIX_CBRANCH, /* type */
452 2, /* rightshift */
453 2, /* size (0 = byte, 1 = short, 2 = long) */
454 19, /* bitsize */
b34976b6 455 TRUE, /* pc_relative */
3c3bdf30
NC		 456 0, /* bitpos */
457 complain_overflow_signed, /* complain_on_overflow */
458 mmix_elf_reloc, /* special_function */
459 "R_MMIX_CBRANCH", /* name */
b34976b6 460 FALSE, /* partial_inplace */
930b4cb2 461 ~0x0100ffff, /* src_mask */
3c3bdf30 462 0x0100ffff, /* dst_mask */
07d6d2b8 463 TRUE), /* pcrel_offset */
3c3bdf30
NC		 464
465 HOWTO (R_MMIX_CBRANCH_J, /* type */
466 2, /* rightshift */
467 2, /* size (0 = byte, 1 = short, 2 = long) */
468 19, /* bitsize */
b34976b6 469 TRUE, /* pc_relative */
3c3bdf30
NC		 470 0, /* bitpos */
471 complain_overflow_signed, /* complain_on_overflow */
472 mmix_elf_reloc, /* special_function */
473 "R_MMIX_CBRANCH_J", /* name */
b34976b6 474 FALSE, /* partial_inplace */
930b4cb2 475 ~0x0100ffff, /* src_mask */
3c3bdf30 476 0x0100ffff, /* dst_mask */
b34976b6 477 TRUE), /* pcrel_offset */
3c3bdf30
NC		 478
479 HOWTO (R_MMIX_CBRANCH_1, /* type */
480 2, /* rightshift */
481 2, /* size (0 = byte, 1 = short, 2 = long) */
482 19, /* bitsize */
b34976b6 483 TRUE, /* pc_relative */
3c3bdf30
NC		 484 0, /* bitpos */
485 complain_overflow_signed, /* complain_on_overflow */
486 mmix_elf_reloc, /* special_function */
487 "R_MMIX_CBRANCH_1", /* name */
b34976b6 488 FALSE, /* partial_inplace */
930b4cb2 489 ~0x0100ffff, /* src_mask */
3c3bdf30 490 0x0100ffff, /* dst_mask */
b34976b6 491 TRUE), /* pcrel_offset */
3c3bdf30
NC		 492
493 HOWTO (R_MMIX_CBRANCH_2, /* type */
494 2, /* rightshift */
495 2, /* size (0 = byte, 1 = short, 2 = long) */
496 19, /* bitsize */
b34976b6 497 TRUE, /* pc_relative */
3c3bdf30
NC		 498 0, /* bitpos */
499 complain_overflow_signed, /* complain_on_overflow */
500 mmix_elf_reloc, /* special_function */
501 "R_MMIX_CBRANCH_2", /* name */
b34976b6 502 FALSE, /* partial_inplace */
930b4cb2 503 ~0x0100ffff, /* src_mask */
3c3bdf30 504 0x0100ffff, /* dst_mask */
b34976b6 505 TRUE), /* pcrel_offset */
3c3bdf30
NC		 506
507 HOWTO (R_MMIX_CBRANCH_3, /* type */
508 2, /* rightshift */
509 2, /* size (0 = byte, 1 = short, 2 = long) */
510 19, /* bitsize */
b34976b6 511 TRUE, /* pc_relative */
3c3bdf30
NC		 512 0, /* bitpos */
513 complain_overflow_signed, /* complain_on_overflow */
514 mmix_elf_reloc, /* special_function */
515 "R_MMIX_CBRANCH_3", /* name */
b34976b6 516 FALSE, /* partial_inplace */
930b4cb2 517 ~0x0100ffff, /* src_mask */
3c3bdf30 518 0x0100ffff, /* dst_mask */
b34976b6 519 TRUE), /* pcrel_offset */
3c3bdf30
NC		 520
521 /* The PUSHJ instruction can reach any (code) address, as long as it's
522 the beginning of a function (no usable restriction). It can silently
523 expand to a 64-bit operand, but will emit an error if any of the two
f60ebe14
HPN		 524 least significant bits are set. It can also expand into a call to a
525 stub; see R_MMIX_PUSHJ_STUBBABLE. The howto members reflect a simple
3c3bdf30
NC		 526 PUSHJ. */
527 HOWTO (R_MMIX_PUSHJ, /* type */
528 2, /* rightshift */
529 2, /* size (0 = byte, 1 = short, 2 = long) */
530 19, /* bitsize */
b34976b6 531 TRUE, /* pc_relative */
3c3bdf30
NC		 532 0, /* bitpos */
533 complain_overflow_signed, /* complain_on_overflow */
534 mmix_elf_reloc, /* special_function */
535 "R_MMIX_PUSHJ", /* name */
b34976b6 536 FALSE, /* partial_inplace */
930b4cb2 537 ~0x0100ffff, /* src_mask */
3c3bdf30 538 0x0100ffff, /* dst_mask */
b34976b6 539 TRUE), /* pcrel_offset */
3c3bdf30
NC		 540
541 HOWTO (R_MMIX_PUSHJ_1, /* type */
542 2, /* rightshift */
543 2, /* size (0 = byte, 1 = short, 2 = long) */
544 19, /* bitsize */
b34976b6 545 TRUE, /* pc_relative */
3c3bdf30
NC		 546 0, /* bitpos */
547 complain_overflow_signed, /* complain_on_overflow */
548 mmix_elf_reloc, /* special_function */
549 "R_MMIX_PUSHJ_1", /* name */
b34976b6 550 FALSE, /* partial_inplace */
930b4cb2 551 ~0x0100ffff, /* src_mask */
3c3bdf30 552 0x0100ffff, /* dst_mask */
b34976b6 553 TRUE), /* pcrel_offset */
3c3bdf30
NC		 554
555 HOWTO (R_MMIX_PUSHJ_2, /* type */
556 2, /* rightshift */
557 2, /* size (0 = byte, 1 = short, 2 = long) */
558 19, /* bitsize */
b34976b6 559 TRUE, /* pc_relative */
3c3bdf30
NC		 560 0, /* bitpos */
561 complain_overflow_signed, /* complain_on_overflow */
562 mmix_elf_reloc, /* special_function */
563 "R_MMIX_PUSHJ_2", /* name */
b34976b6 564 FALSE, /* partial_inplace */
930b4cb2 565 ~0x0100ffff, /* src_mask */
3c3bdf30 566 0x0100ffff, /* dst_mask */
b34976b6 567 TRUE), /* pcrel_offset */
3c3bdf30
NC		 568
569 HOWTO (R_MMIX_PUSHJ_3, /* type */
570 2, /* rightshift */
571 2, /* size (0 = byte, 1 = short, 2 = long) */
572 19, /* bitsize */
b34976b6 573 TRUE, /* pc_relative */
3c3bdf30
NC		 574 0, /* bitpos */
575 complain_overflow_signed, /* complain_on_overflow */
576 mmix_elf_reloc, /* special_function */
577 "R_MMIX_PUSHJ_3", /* name */
b34976b6 578 FALSE, /* partial_inplace */
930b4cb2 579 ~0x0100ffff, /* src_mask */
3c3bdf30 580 0x0100ffff, /* dst_mask */
b34976b6 581 TRUE), /* pcrel_offset */
3c3bdf30
NC		 582
583 /* A JMP is supposed to reach any (code) address. By itself, it can
584 reach +-64M; the expansion can reach all 64 bits. Note that the 64M
585 limit is soon reached if you link the program in wildly different
586 memory segments. The howto members reflect a trivial JMP. */
587 HOWTO (R_MMIX_JMP, /* type */
588 2, /* rightshift */
589 2, /* size (0 = byte, 1 = short, 2 = long) */
590 27, /* bitsize */
b34976b6 591 TRUE, /* pc_relative */
3c3bdf30
NC		 592 0, /* bitpos */
593 complain_overflow_signed, /* complain_on_overflow */
594 mmix_elf_reloc, /* special_function */
595 "R_MMIX_JMP", /* name */
b34976b6 596 FALSE, /* partial_inplace */
930b4cb2 597 ~0x1ffffff, /* src_mask */
3c3bdf30 598 0x1ffffff, /* dst_mask */
b34976b6 599 TRUE), /* pcrel_offset */
3c3bdf30
NC		 600
601 HOWTO (R_MMIX_JMP_1, /* type */
602 2, /* rightshift */
603 2, /* size (0 = byte, 1 = short, 2 = long) */
604 27, /* bitsize */
b34976b6 605 TRUE, /* pc_relative */
3c3bdf30
NC		 606 0, /* bitpos */
607 complain_overflow_signed, /* complain_on_overflow */
608 mmix_elf_reloc, /* special_function */
609 "R_MMIX_JMP_1", /* name */
b34976b6 610 FALSE, /* partial_inplace */
930b4cb2 611 ~0x1ffffff, /* src_mask */
3c3bdf30 612 0x1ffffff, /* dst_mask */
b34976b6 613 TRUE), /* pcrel_offset */
3c3bdf30
NC		 614
615 HOWTO (R_MMIX_JMP_2, /* type */
616 2, /* rightshift */
617 2, /* size (0 = byte, 1 = short, 2 = long) */
618 27, /* bitsize */
b34976b6 619 TRUE, /* pc_relative */
3c3bdf30
NC		 620 0, /* bitpos */
621 complain_overflow_signed, /* complain_on_overflow */
622 mmix_elf_reloc, /* special_function */
623 "R_MMIX_JMP_2", /* name */
b34976b6 624 FALSE, /* partial_inplace */
930b4cb2 625 ~0x1ffffff, /* src_mask */
3c3bdf30 626 0x1ffffff, /* dst_mask */
b34976b6 627 TRUE), /* pcrel_offset */
3c3bdf30
NC		 628
629 HOWTO (R_MMIX_JMP_3, /* type */
630 2, /* rightshift */
631 2, /* size (0 = byte, 1 = short, 2 = long) */
632 27, /* bitsize */
b34976b6 633 TRUE, /* pc_relative */
3c3bdf30
NC		 634 0, /* bitpos */
635 complain_overflow_signed, /* complain_on_overflow */
636 mmix_elf_reloc, /* special_function */
637 "R_MMIX_JMP_3", /* name */
b34976b6 638 FALSE, /* partial_inplace */
930b4cb2 639 ~0x1ffffff, /* src_mask */
3c3bdf30 640 0x1ffffff, /* dst_mask */
b34976b6 641 TRUE), /* pcrel_offset */
3c3bdf30
NC		 642
643 /* When we don't emit link-time-relaxable code from the assembler, or
644 when relaxation has done all it can do, these relocs are used. For
645 GETA/PUSHJ/branches. */
646 HOWTO (R_MMIX_ADDR19, /* type */
647 2, /* rightshift */
648 2, /* size (0 = byte, 1 = short, 2 = long) */
649 19, /* bitsize */
b34976b6 650 TRUE, /* pc_relative */
3c3bdf30
NC		 651 0, /* bitpos */
652 complain_overflow_signed, /* complain_on_overflow */
653 mmix_elf_reloc, /* special_function */
654 "R_MMIX_ADDR19", /* name */
b34976b6 655 FALSE, /* partial_inplace */
930b4cb2 656 ~0x0100ffff, /* src_mask */
3c3bdf30 657 0x0100ffff, /* dst_mask */
b34976b6 658 TRUE), /* pcrel_offset */
3c3bdf30
NC		 659
660 /* For JMP. */
661 HOWTO (R_MMIX_ADDR27, /* type */
662 2, /* rightshift */
663 2, /* size (0 = byte, 1 = short, 2 = long) */
664 27, /* bitsize */
b34976b6 665 TRUE, /* pc_relative */
3c3bdf30
NC		 666 0, /* bitpos */
667 complain_overflow_signed, /* complain_on_overflow */
668 mmix_elf_reloc, /* special_function */
669 "R_MMIX_ADDR27", /* name */
b34976b6 670 FALSE, /* partial_inplace */
930b4cb2 671 ~0x1ffffff, /* src_mask */
3c3bdf30 672 0x1ffffff, /* dst_mask */
b34976b6 673 TRUE), /* pcrel_offset */
3c3bdf30
NC		 674
675 /* A general register or the value 0..255. If a value, then the
676 instruction (offset -3) needs adjusting. */
677 HOWTO (R_MMIX_REG_OR_BYTE, /* type */
678 0, /* rightshift */
679 1, /* size (0 = byte, 1 = short, 2 = long) */
680 8, /* bitsize */
b34976b6 681 FALSE, /* pc_relative */
3c3bdf30
NC		 682 0, /* bitpos */
683 complain_overflow_bitfield, /* complain_on_overflow */
684 mmix_elf_reloc, /* special_function */
685 "R_MMIX_REG_OR_BYTE", /* name */
b34976b6 686 FALSE, /* partial_inplace */
930b4cb2 687 0, /* src_mask */
3c3bdf30 688 0xff, /* dst_mask */
b34976b6 689 FALSE), /* pcrel_offset */
3c3bdf30
NC		 690
691 /* A general register. */
692 HOWTO (R_MMIX_REG, /* type */
693 0, /* rightshift */
694 1, /* size (0 = byte, 1 = short, 2 = long) */
695 8, /* bitsize */
b34976b6 696 FALSE, /* pc_relative */
3c3bdf30
NC		 697 0, /* bitpos */
698 complain_overflow_bitfield, /* complain_on_overflow */
699 mmix_elf_reloc, /* special_function */
700 "R_MMIX_REG", /* name */
b34976b6 701 FALSE, /* partial_inplace */
930b4cb2 702 0, /* src_mask */
3c3bdf30 703 0xff, /* dst_mask */
b34976b6 704 FALSE), /* pcrel_offset */
3c3bdf30
NC		 705
706 /* A register plus an index, corresponding to the relocation expression.
707 The sizes must correspond to the valid range of the expression, while
708 the bitmasks correspond to what we store in the image. */
709 HOWTO (R_MMIX_BASE_PLUS_OFFSET, /* type */
710 0, /* rightshift */
711 4, /* size (0 = byte, 1 = short, 2 = long) */
712 64, /* bitsize */
b34976b6 713 FALSE, /* pc_relative */
3c3bdf30
NC		 714 0, /* bitpos */
715 complain_overflow_bitfield, /* complain_on_overflow */
716 mmix_elf_reloc, /* special_function */
717 "R_MMIX_BASE_PLUS_OFFSET", /* name */
b34976b6 718 FALSE, /* partial_inplace */
930b4cb2 719 0, /* src_mask */
3c3bdf30 720 0xffff, /* dst_mask */
b34976b6 721 FALSE), /* pcrel_offset */
3c3bdf30
NC		 722
723 /* A "magic" relocation for a LOCAL expression, asserting that the
724 expression is less than the number of global registers. No actual
725 modification of the contents is done. Implementing this as a
726 relocation was less intrusive than e.g. putting such expressions in a
727 section to discard *after* relocation. */
728 HOWTO (R_MMIX_LOCAL, /* type */
729 0, /* rightshift */
730 0, /* size (0 = byte, 1 = short, 2 = long) */
731 0, /* bitsize */
b34976b6 732 FALSE, /* pc_relative */
3c3bdf30
NC		 733 0, /* bitpos */
734 complain_overflow_dont, /* complain_on_overflow */
735 mmix_elf_reloc, /* special_function */
736 "R_MMIX_LOCAL", /* name */
b34976b6 737 FALSE, /* partial_inplace */
3c3bdf30
NC		 738 0, /* src_mask */
739 0, /* dst_mask */
b34976b6 740 FALSE), /* pcrel_offset */
f60ebe14
HPN		 741
742 HOWTO (R_MMIX_PUSHJ_STUBBABLE, /* type */
743 2, /* rightshift */
744 2, /* size (0 = byte, 1 = short, 2 = long) */
745 19, /* bitsize */
746 TRUE, /* pc_relative */
747 0, /* bitpos */
748 complain_overflow_signed, /* complain_on_overflow */
749 mmix_elf_reloc, /* special_function */
750 "R_MMIX_PUSHJ_STUBBABLE", /* name */
751 FALSE, /* partial_inplace */
752 ~0x0100ffff, /* src_mask */
753 0x0100ffff, /* dst_mask */
754 TRUE) /* pcrel_offset */
3c3bdf30
NC		 755 };
756
757
758/* Map BFD reloc types to MMIX ELF reloc types. */
759
760struct mmix_reloc_map
761 {
762 bfd_reloc_code_real_type bfd_reloc_val;
763 enum elf_mmix_reloc_type elf_reloc_val;
764 };
765
766
767static const struct mmix_reloc_map mmix_reloc_map[] =
768 {
769 {BFD_RELOC_NONE, R_MMIX_NONE},
770 {BFD_RELOC_8, R_MMIX_8},
771 {BFD_RELOC_16, R_MMIX_16},
772 {BFD_RELOC_24, R_MMIX_24},
773 {BFD_RELOC_32, R_MMIX_32},
774 {BFD_RELOC_64, R_MMIX_64},
775 {BFD_RELOC_8_PCREL, R_MMIX_PC_8},
776 {BFD_RELOC_16_PCREL, R_MMIX_PC_16},
777 {BFD_RELOC_24_PCREL, R_MMIX_PC_24},
778 {BFD_RELOC_32_PCREL, R_MMIX_PC_32},
779 {BFD_RELOC_64_PCREL, R_MMIX_PC_64},
780 {BFD_RELOC_VTABLE_INHERIT, R_MMIX_GNU_VTINHERIT},
781 {BFD_RELOC_VTABLE_ENTRY, R_MMIX_GNU_VTENTRY},
782 {BFD_RELOC_MMIX_GETA, R_MMIX_GETA},
783 {BFD_RELOC_MMIX_CBRANCH, R_MMIX_CBRANCH},
784 {BFD_RELOC_MMIX_PUSHJ, R_MMIX_PUSHJ},
785 {BFD_RELOC_MMIX_JMP, R_MMIX_JMP},
786 {BFD_RELOC_MMIX_ADDR19, R_MMIX_ADDR19},
787 {BFD_RELOC_MMIX_ADDR27, R_MMIX_ADDR27},
788 {BFD_RELOC_MMIX_REG_OR_BYTE, R_MMIX_REG_OR_BYTE},
789 {BFD_RELOC_MMIX_REG, R_MMIX_REG},
790 {BFD_RELOC_MMIX_BASE_PLUS_OFFSET, R_MMIX_BASE_PLUS_OFFSET},
f60ebe14
HPN		 791 {BFD_RELOC_MMIX_LOCAL, R_MMIX_LOCAL},
792 {BFD_RELOC_MMIX_PUSHJ_STUBBABLE, R_MMIX_PUSHJ_STUBBABLE}
3c3bdf30
NC		 793 };
794
795static reloc_howto_type *
2c3fc389
NC		 796bfd_elf64_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
797 bfd_reloc_code_real_type code)
3c3bdf30
NC		 798{
799 unsigned int i;
800
801 for (i = 0;
802 i < sizeof (mmix_reloc_map) / sizeof (mmix_reloc_map[0]);
803 i++)
804 {
805 if (mmix_reloc_map[i].bfd_reloc_val == code)
806 return &elf_mmix_howto_table[mmix_reloc_map[i].elf_reloc_val];
807 }
808
809 return NULL;
157090f7
AM		 810}
811
812static reloc_howto_type *
813bfd_elf64_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
814 const char *r_name)
815{
816 unsigned int i;
817
818 for (i = 0;
819 i < sizeof (elf_mmix_howto_table) / sizeof (elf_mmix_howto_table[0]);
820 i++)
821 if (elf_mmix_howto_table[i].name != NULL
822 && strcasecmp (elf_mmix_howto_table[i].name, r_name) == 0)
823 return &elf_mmix_howto_table[i];
824
825 return NULL;
3c3bdf30
NC		 826}
827
f0abc2a1 828static bfd_boolean
2c3fc389 829mmix_elf_new_section_hook (bfd *abfd, asection *sec)
f0abc2a1 830{
f592407e
AM		 831 if (!sec->used_by_bfd)
832 {
833 struct _mmix_elf_section_data *sdata;
834 bfd_size_type amt = sizeof (*sdata);
f0abc2a1 835
f592407e
AM		 836 sdata = bfd_zalloc (abfd, amt);
837 if (sdata == NULL)
838 return FALSE;
839 sec->used_by_bfd = sdata;
840 }
f0abc2a1
AM		 841
842 return _bfd_elf_new_section_hook (abfd, sec);
843}
844
3c3bdf30
NC		 845
846/* This function performs the actual bitfiddling and sanity check for a
847 final relocation. Each relocation gets its *worst*-case expansion
848 in size when it arrives here; any reduction in size should have been
849 caught in linker relaxation earlier. When we get here, the relocation
850 looks like the smallest instruction with SWYM:s (nop:s) appended to the
851 max size. We fill in those nop:s.
852
853 R_MMIX_GETA: (FIXME: Relaxation should break this up in 1, 2, 3 tetra)
854 GETA $N,foo
855 ->
856 SETL $N,foo & 0xffff
857 INCML $N,(foo >> 16) & 0xffff
858 INCMH $N,(foo >> 32) & 0xffff
859 INCH $N,(foo >> 48) & 0xffff
860
861 R_MMIX_CBRANCH: (FIXME: Relaxation should break this up, but
862 condbranches needing relaxation might be rare enough to not be
863 worthwhile.)
864 [P]Bcc $N,foo
865 ->
866 [~P]B~cc $N,.+20
867 SETL $255,foo & ...
868 INCML ...
869 INCMH ...
870 INCH ...
871 GO $255,$255,0
872
873 R_MMIX_PUSHJ: (FIXME: Relaxation...)
874 PUSHJ $N,foo
875 ->
876 SETL $255,foo & ...
877 INCML ...
878 INCMH ...
879 INCH ...
880 PUSHGO $N,$255,0
881
882 R_MMIX_JMP: (FIXME: Relaxation...)
883 JMP foo
884 ->
885 SETL $255,foo & ...
886 INCML ...
887 INCMH ...
888 INCH ...
889 GO $255,$255,0
890
891 R_MMIX_ADDR19 and R_MMIX_ADDR27 are just filled in. */
892
893static bfd_reloc_status_type
18978b27
HPN		 894mmix_elf_perform_relocation (asection *isec, reloc_howto_type *howto,
895 void *datap, bfd_vma addr, bfd_vma value,
896 char **error_message)
3c3bdf30
NC		 897{
898 bfd *abfd = isec->owner;
899 bfd_reloc_status_type flag = bfd_reloc_ok;
900 bfd_reloc_status_type r;
901 int offs = 0;
902 int reg = 255;
903
904 /* The worst case bits are all similar SETL/INCML/INCMH/INCH sequences.
905 We handle the differences here and the common sequence later. */
906 switch (howto->type)
907 {
908 case R_MMIX_GETA:
909 offs = 0;
910 reg = bfd_get_8 (abfd, (bfd_byte *) datap + 1);
911
912 /* We change to an absolute value. */
913 value += addr;
914 break;
915
916 case R_MMIX_CBRANCH:
917 {
918 int in1 = bfd_get_16 (abfd, (bfd_byte *) datap) << 16;
919
920 /* Invert the condition and prediction bit, and set the offset
921 to five instructions ahead.
922
923 We *can* do better if we want to. If the branch is found to be
924 within limits, we could leave the branch as is; there'll just
925 be a bunch of NOP:s after it. But we shouldn't see this
926 sequence often enough that it's worth doing it. */
927
928 bfd_put_32 (abfd,
929 (((in1 ^ ((PRED_INV_BIT | COND_INV_BIT) << 24)) & ~0xffff)
930 | (24/4)),
931 (bfd_byte *) datap);
932
933 /* Put a "GO $255,$255,0" after the common sequence. */
934 bfd_put_32 (abfd,
935 ((GO_INSN_BYTE | IMM_OFFSET_BIT) << 24) | 0xffff00,
936 (bfd_byte *) datap + 20);
937
938 /* Common sequence starts at offset 4. */
939 offs = 4;
940
941 /* We change to an absolute value. */
942 value += addr;
943 }
944 break;
945
f60ebe14
HPN		 946 case R_MMIX_PUSHJ_STUBBABLE:
947 /* If the address fits, we're fine. */
948 if ((value & 3) == 0
949 /* Note rightshift 0; see R_MMIX_JMP case below. */
950 && (r = bfd_check_overflow (complain_overflow_signed,
951 howto->bitsize,
952 0,
953 bfd_arch_bits_per_address (abfd),
954 value)) == bfd_reloc_ok)
955 goto pcrel_mmix_reloc_fits;
956 else
957 {
1a23a9e6 958 bfd_size_type size = isec->rawsize ? isec->rawsize : isec->size;
f60ebe14
HPN		 959
960 /* We have the bytes at the PUSHJ insn and need to get the
961 position for the stub. There's supposed to be room allocated
962 for the stub. */
963 bfd_byte *stubcontents
f075ee0c 964 = ((bfd_byte *) datap
f60ebe14 965 - (addr - (isec->output_section->vma + isec->output_offset))
eea6121a 966 + size
f60ebe14
HPN		 967 + mmix_elf_section_data (isec)->pjs.stub_offset);
968 bfd_vma stubaddr;
969
18978b27
HPN		 970 if (mmix_elf_section_data (isec)->pjs.n_pushj_relocs == 0)
971 {
972 /* This shouldn't happen when linking to ELF or mmo, so
973 this is an attempt to link to "binary", right? We
974 can't access the output bfd, so we can't verify that
975 assumption. We only know that the critical
976 mmix_elf_check_common_relocs has not been called,
977 which happens when the output format is different
978 from the input format (and is not mmo). */
979 if (! mmix_elf_section_data (isec)->has_warned_pushj)
980 {
981 /* For the first such error per input section, produce
982 a verbose message. */
983 *error_message
984 = _("invalid input relocation when producing"
985 " non-ELF, non-mmo format output."
986 "\n Please use the objcopy program to convert from"
987 " ELF or mmo,"
988 "\n or assemble using"
989 " \"-no-expand\" (for gcc, \"-Wa,-no-expand\"");
990 mmix_elf_section_data (isec)->has_warned_pushj = TRUE;
991 return bfd_reloc_dangerous;
992 }
993
994 /* For subsequent errors, return this one, which is
995 rate-limited but looks a little bit different,
996 hopefully without affecting user-friendliness. */
997 return bfd_reloc_overflow;
998 }
999
f60ebe14
HPN		 1000 /* The address doesn't fit, so redirect the PUSHJ to the
1001 location of the stub. */
1002 r = mmix_elf_perform_relocation (isec,
1003 &elf_mmix_howto_table
1004 [R_MMIX_ADDR19],
1005 datap,
1006 addr,
1007 isec->output_section->vma
1008 + isec->output_offset
eea6121a 1009 + size
f60ebe14
HPN		 1010 + (mmix_elf_section_data (isec)
1011 ->pjs.stub_offset)
18978b27
HPN		 1012 - addr,
1013 error_message);
f60ebe14
HPN		 1014 if (r != bfd_reloc_ok)
1015 return r;
1016
1017 stubaddr
1018 = (isec->output_section->vma
1019 + isec->output_offset
eea6121a 1020 + size
f60ebe14
HPN		 1021 + mmix_elf_section_data (isec)->pjs.stub_offset);
1022
1023 /* We generate a simple JMP if that suffices, else the whole 5
1024 insn stub. */
1025 if (bfd_check_overflow (complain_overflow_signed,
1026 elf_mmix_howto_table[R_MMIX_ADDR27].bitsize,
1027 0,
1028 bfd_arch_bits_per_address (abfd),
1029 addr + value - stubaddr) == bfd_reloc_ok)
1030 {
1031 bfd_put_32 (abfd, JMP_INSN_BYTE << 24, stubcontents);
1032 r = mmix_elf_perform_relocation (isec,
1033 &elf_mmix_howto_table
1034 [R_MMIX_ADDR27],
1035 stubcontents,
1036 stubaddr,
18978b27
HPN		 1037 value + addr - stubaddr,
1038 error_message);
f60ebe14
HPN		 1039 mmix_elf_section_data (isec)->pjs.stub_offset += 4;
1040
eea6121a
AM		 1041 if (size + mmix_elf_section_data (isec)->pjs.stub_offset
1042 > isec->size)
f60ebe14
HPN		 1043 abort ();
1044
1045 return r;
1046 }
1047 else
1048 {
1049 /* Put a "GO $255,0" after the common sequence. */
1050 bfd_put_32 (abfd,
1051 ((GO_INSN_BYTE | IMM_OFFSET_BIT) << 24)
1052 | 0xff00, (bfd_byte *) stubcontents + 16);
1053
1054 /* Prepare for the general code to set the first part of the
1055 linker stub, and */
1056 value += addr;
1057 datap = stubcontents;
1058 mmix_elf_section_data (isec)->pjs.stub_offset
1059 += MAX_PUSHJ_STUB_SIZE;
1060 }
1061 }
1062 break;
1063
3c3bdf30
NC		 1064 case R_MMIX_PUSHJ:
1065 {
1066 int inreg = bfd_get_8 (abfd, (bfd_byte *) datap + 1);
1067
1068 /* Put a "PUSHGO $N,$255,0" after the common sequence. */
1069 bfd_put_32 (abfd,
1070 ((PUSHGO_INSN_BYTE | IMM_OFFSET_BIT) << 24)
1071 | (inreg << 16)
1072 | 0xff00,
1073 (bfd_byte *) datap + 16);
1074
1075 /* We change to an absolute value. */
1076 value += addr;
1077 }
1078 break;
1079
1080 case R_MMIX_JMP:
1081 /* This one is a little special. If we get here on a non-relaxing
1082 link, and the destination is actually in range, we don't need to
1083 execute the nops.
1084 If so, we fall through to the bit-fiddling relocs.
1085
1086 FIXME: bfd_check_overflow seems broken; the relocation is
1087 rightshifted before testing, so supply a zero rightshift. */
1088
1089 if (! ((value & 3) == 0
1090 && (r = bfd_check_overflow (complain_overflow_signed,
1091 howto->bitsize,
1092 0,
1093 bfd_arch_bits_per_address (abfd),
1094 value)) == bfd_reloc_ok))
1095 {
1096 /* If the relocation doesn't fit in a JMP, we let the NOP:s be
1097 modified below, and put a "GO $255,$255,0" after the
1098 address-loading sequence. */
1099 bfd_put_32 (abfd,
1100 ((GO_INSN_BYTE | IMM_OFFSET_BIT) << 24)
1101 | 0xffff00,
1102 (bfd_byte *) datap + 16);
1103
1104 /* We change to an absolute value. */
1105 value += addr;
1106 break;
1107 }
cedb70c5 1108 /* FALLTHROUGH. */
3c3bdf30
NC		 1109 case R_MMIX_ADDR19:
1110 case R_MMIX_ADDR27:
f60ebe14 1111 pcrel_mmix_reloc_fits:
3c3bdf30
NC		 1112 /* These must be in range, or else we emit an error. */
1113 if ((value & 3) == 0
1114 /* Note rightshift 0; see above. */
1115 && (r = bfd_check_overflow (complain_overflow_signed,
1116 howto->bitsize,
1117 0,
1118 bfd_arch_bits_per_address (abfd),
1119 value)) == bfd_reloc_ok)
1120 {
1121 bfd_vma in1
1122 = bfd_get_32 (abfd, (bfd_byte *) datap);
1123 bfd_vma highbit;
1124
1125 if ((bfd_signed_vma) value < 0)
1126 {
f60ebe14 1127 highbit = 1 << 24;
3c3bdf30
NC		 1128 value += (1 << (howto->bitsize - 1));
1129 }
1130 else
1131 highbit = 0;
1132
1133 value >>= 2;
1134
1135 bfd_put_32 (abfd,
930b4cb2 1136 (in1 & howto->src_mask)
3c3bdf30
NC		 1137 | highbit
1138 | (value & howto->dst_mask),
1139 (bfd_byte *) datap);
1140
1141 return bfd_reloc_ok;
1142 }
1143 else
1144 return bfd_reloc_overflow;
1145
930b4cb2
HPN		 1146 case R_MMIX_BASE_PLUS_OFFSET:
1147 {
1148 struct bpo_reloc_section_info *bpodata
f0abc2a1 1149 = mmix_elf_section_data (isec)->bpo.reloc;
18978b27
HPN		 1150 asection *bpo_greg_section;
1151 struct bpo_greg_section_info *gregdata;
1152 size_t bpo_index;
1153
1154 if (bpodata == NULL)
1155 {
1156 /* This shouldn't happen when linking to ELF or mmo, so
1157 this is an attempt to link to "binary", right? We
1158 can't access the output bfd, so we can't verify that
1159 assumption. We only know that the critical
1160 mmix_elf_check_common_relocs has not been called, which
1161 happens when the output format is different from the
1162 input format (and is not mmo). */
1163 if (! mmix_elf_section_data (isec)->has_warned_bpo)
1164 {
1165 /* For the first such error per input section, produce
1166 a verbose message. */
1167 *error_message
1168 = _("invalid input relocation when producing"
1169 " non-ELF, non-mmo format output."
1170 "\n Please use the objcopy program to convert from"
1171 " ELF or mmo,"
1172 "\n or compile using the gcc-option"
1173 " \"-mno-base-addresses\".");
1174 mmix_elf_section_data (isec)->has_warned_bpo = TRUE;
1175 return bfd_reloc_dangerous;
1176 }
1177
1178 /* For subsequent errors, return this one, which is
1179 rate-limited but looks a little bit different,
1180 hopefully without affecting user-friendliness. */
1181 return bfd_reloc_overflow;
1182 }
1183
1184 bpo_greg_section = bpodata->bpo_greg_section;
1185 gregdata = mmix_elf_section_data (bpo_greg_section)->bpo.greg;
1186 bpo_index = gregdata->bpo_reloc_indexes[bpodata->bpo_index++];
930b4cb2
HPN		 1187
1188 /* A consistency check: The value we now have in "relocation" must
1189 be the same as the value we stored for that relocation. It
1190 doesn't cost much, so can be left in at all times. */
1191 if (value != gregdata->reloc_request[bpo_index].value)
1192 {
4eca0228 1193 _bfd_error_handler
695344c0 1194 /* xgettext:c-format */
871b3ab2 1195 (_("%pB: Internal inconsistency error for value for\n\
2dcf00ce 1196 linker-allocated global register: linked: %#" PRIx64 " != relaxed: %#" PRIx64 ""),
dae82561 1197 isec->owner,
2dcf00ce
AM		 1198 (uint64_t) value,
1199 (uint64_t) gregdata->reloc_request[bpo_index].value);
930b4cb2
HPN		 1200 bfd_set_error (bfd_error_bad_value);
1201 return bfd_reloc_overflow;
1202 }
1203
1204 /* Then store the register number and offset for that register
1205 into datap and datap + 1 respectively. */
1206 bfd_put_8 (abfd,
1207 gregdata->reloc_request[bpo_index].regindex
1208 + bpo_greg_section->output_section->vma / 8,
1209 datap);
1210 bfd_put_8 (abfd,
1211 gregdata->reloc_request[bpo_index].offset,
1212 ((unsigned char *) datap) + 1);
1213 return bfd_reloc_ok;
1214 }
1215
3c3bdf30
NC		 1216 case R_MMIX_REG_OR_BYTE:
1217 case R_MMIX_REG:
1218 if (value > 255)
1219 return bfd_reloc_overflow;
1220 bfd_put_8 (abfd, value, datap);
1221 return bfd_reloc_ok;
1222
1223 default:
1224 BAD_CASE (howto->type);
1225 }
1226
1227 /* This code adds the common SETL/INCML/INCMH/INCH worst-case
1228 sequence. */
1229
1230 /* Lowest two bits must be 0. We return bfd_reloc_overflow for
1231 everything that looks strange. */
1232 if (value & 3)
1233 flag = bfd_reloc_overflow;
1234
1235 bfd_put_32 (abfd,
1236 (SETL_INSN_BYTE << 24) | (value & 0xffff) | (reg << 16),
1237 (bfd_byte *) datap + offs);
1238 bfd_put_32 (abfd,
1239 (INCML_INSN_BYTE << 24) | ((value >> 16) & 0xffff) | (reg << 16),
1240 (bfd_byte *) datap + offs + 4);
1241 bfd_put_32 (abfd,
1242 (INCMH_INSN_BYTE << 24) | ((value >> 32) & 0xffff) | (reg << 16),
1243 (bfd_byte *) datap + offs + 8);
1244 bfd_put_32 (abfd,
1245 (INCH_INSN_BYTE << 24) | ((value >> 48) & 0xffff) | (reg << 16),
1246 (bfd_byte *) datap + offs + 12);
1247
1248 return flag;
1249}
1250
1251/* Set the howto pointer for an MMIX ELF reloc (type RELA). */
1252
1253static void
0aa13fee 1254mmix_info_to_howto_rela (bfd *abfd,
2c3fc389
NC		 1255 arelent *cache_ptr,
1256 Elf_Internal_Rela *dst)
3c3bdf30
NC		 1257{
1258 unsigned int r_type;
1259
1260 r_type = ELF64_R_TYPE (dst->r_info);
5860e3f8
NC		 1261 if (r_type >= (unsigned int) R_MMIX_max)
1262 {
695344c0 1263 /* xgettext:c-format */
0aa13fee
AM		 1264 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
1265 abfd, r_type);
5860e3f8
NC		 1266 r_type = 0;
1267 }
3c3bdf30
NC		 1268 cache_ptr->howto = &elf_mmix_howto_table[r_type];
1269}
1270
1271/* Any MMIX-specific relocation gets here at assembly time or when linking
1272 to other formats (such as mmo); this is the relocation function from
1273 the reloc_table. We don't get here for final pure ELF linking. */
1274
1275static bfd_reloc_status_type
2c3fc389
NC		 1276mmix_elf_reloc (bfd *abfd,
1277 arelent *reloc_entry,
1278 asymbol *symbol,
1279 void * data,
1280 asection *input_section,
1281 bfd *output_bfd,
1282 char **error_message)
3c3bdf30
NC		 1283{
1284 bfd_vma relocation;
1285 bfd_reloc_status_type r;
1286 asection *reloc_target_output_section;
1287 bfd_reloc_status_type flag = bfd_reloc_ok;
1288 bfd_vma output_base = 0;
3c3bdf30
NC		 1289
1290 r = bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1291 input_section, output_bfd, error_message);
1292
1293 /* If that was all that was needed (i.e. this isn't a final link, only
1294 some segment adjustments), we're done. */
1295 if (r != bfd_reloc_continue)
1296 return r;
1297
1298 if (bfd_is_und_section (symbol->section)
1299 && (symbol->flags & BSF_WEAK) == 0
1300 && output_bfd == (bfd *) NULL)
1301 return bfd_reloc_undefined;
1302
1303 /* Is the address of the relocation really within the section? */
07515404 1304 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
3c3bdf30
NC		 1305 return bfd_reloc_outofrange;
1306
4cc11e76 1307 /* Work out which section the relocation is targeted at and the
3c3bdf30
NC		 1308 initial relocation command value. */
1309
1310 /* Get symbol value. (Common symbols are special.) */
1311 if (bfd_is_com_section (symbol->section))
1312 relocation = 0;
1313 else
1314 relocation = symbol->value;
1315
1316 reloc_target_output_section = bfd_get_output_section (symbol);
1317
1318 /* Here the variable relocation holds the final address of the symbol we
1319 are relocating against, plus any addend. */
1320 if (output_bfd)
1321 output_base = 0;
1322 else
1323 output_base = reloc_target_output_section->vma;
1324
1325 relocation += output_base + symbol->section->output_offset;
1326
3c3bdf30
NC		 1327 if (output_bfd != (bfd *) NULL)
1328 {
1329 /* Add in supplied addend. */
1330 relocation += reloc_entry->addend;
1331
1332 /* This is a partial relocation, and we want to apply the
1333 relocation to the reloc entry rather than the raw data.
1334 Modify the reloc inplace to reflect what we now know. */
1335 reloc_entry->addend = relocation;
1336 reloc_entry->address += input_section->output_offset;
1337 return flag;
1338 }
1339
1340 return mmix_final_link_relocate (reloc_entry->howto, input_section,
1341 data, reloc_entry->address,
1342 reloc_entry->addend, relocation,
1343 bfd_asymbol_name (symbol),
18978b27
HPN		 1344 reloc_target_output_section,
1345 error_message);
3c3bdf30 1346}
e06fcc86 1347\f
3c3bdf30
NC		 1348/* Relocate an MMIX ELF section. Modified from elf32-fr30.c; look to it
1349 for guidance if you're thinking of copying this. */
1350
b34976b6 1351static bfd_boolean
2c3fc389
NC		 1352mmix_elf_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
1353 struct bfd_link_info *info,
1354 bfd *input_bfd,
1355 asection *input_section,
1356 bfd_byte *contents,
1357 Elf_Internal_Rela *relocs,
1358 Elf_Internal_Sym *local_syms,
1359 asection **local_sections)
3c3bdf30
NC		 1360{
1361 Elf_Internal_Shdr *symtab_hdr;
1362 struct elf_link_hash_entry **sym_hashes;
1363 Elf_Internal_Rela *rel;
1364 Elf_Internal_Rela *relend;
1a23a9e6 1365 bfd_size_type size;
f60ebe14 1366 size_t pjsno = 0;
3c3bdf30 1367
1a23a9e6 1368 size = input_section->rawsize ? input_section->rawsize : input_section->size;
3c3bdf30
NC		 1369 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1370 sym_hashes = elf_sym_hashes (input_bfd);
1371 relend = relocs + input_section->reloc_count;
1372
1a23a9e6
AM		 1373 /* Zero the stub area before we start. */
1374 if (input_section->rawsize != 0
1375 && input_section->size > input_section->rawsize)
1376 memset (contents + input_section->rawsize, 0,
1377 input_section->size - input_section->rawsize);
1378
3c3bdf30
NC		 1379 for (rel = relocs; rel < relend; rel ++)
1380 {
1381 reloc_howto_type *howto;
1382 unsigned long r_symndx;
1383 Elf_Internal_Sym *sym;
1384 asection *sec;
1385 struct elf_link_hash_entry *h;
1386 bfd_vma relocation;
1387 bfd_reloc_status_type r;
1388 const char *name = NULL;
1389 int r_type;
b34976b6 1390 bfd_boolean undefined_signalled = FALSE;
3c3bdf30
NC		 1391
1392 r_type = ELF64_R_TYPE (rel->r_info);
1393
1394 if (r_type == R_MMIX_GNU_VTINHERIT
1395 || r_type == R_MMIX_GNU_VTENTRY)
1396 continue;
1397
1398 r_symndx = ELF64_R_SYM (rel->r_info);
1399
ab96bf03
AM		 1400 howto = elf_mmix_howto_table + ELF64_R_TYPE (rel->r_info);
1401 h = NULL;
1402 sym = NULL;
1403 sec = NULL;
1404
1405 if (r_symndx < symtab_hdr->sh_info)
1406 {
1407 sym = local_syms + r_symndx;
1408 sec = local_sections [r_symndx];
1409 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1410
1411 name = bfd_elf_string_from_elf_section (input_bfd,
1412 symtab_hdr->sh_link,
1413 sym->st_name);
1414 if (name == NULL)
1415 name = bfd_section_name (input_bfd, sec);
1416 }
1417 else
1418 {
62d887d4 1419 bfd_boolean unresolved_reloc, ignored;
ab96bf03
AM		 1420
1421 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1422 r_symndx, symtab_hdr, sym_hashes,
1423 h, sec, relocation,
62d887d4
L		 1424 unresolved_reloc, undefined_signalled,
1425 ignored);
ab96bf03
AM		 1426 name = h->root.root.string;
1427 }
1428
dbaa2011 1429 if (sec != NULL && discarded_section (sec))
e4067dbb 1430 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
545fd46b 1431 rel, 1, relend, howto, 0, contents);
ab96bf03 1432
0e1862bb 1433 if (bfd_link_relocatable (info))
3c3bdf30 1434 {
f60ebe14
HPN		 1435 /* This is a relocatable link. For most relocs we don't have to
1436 change anything, unless the reloc is against a section
1437 symbol, in which case we have to adjust according to where
1438 the section symbol winds up in the output section. */
ab96bf03
AM		 1439 if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1440 rel->r_addend += sec->output_offset;
3c3bdf30 1441
f60ebe14
HPN		 1442 /* For PUSHJ stub relocs however, we may need to change the
1443 reloc and the section contents, if the reloc doesn't reach
1444 beyond the end of the output section and previous stubs.
1445 Then we change the section contents to be a PUSHJ to the end
1446 of the input section plus stubs (we can do that without using
1447 a reloc), and then we change the reloc to be a R_MMIX_PUSHJ
1448 at the stub location. */
1449 if (r_type == R_MMIX_PUSHJ_STUBBABLE)
1450 {
1451 /* We've already checked whether we need a stub; use that
1452 knowledge. */
1453 if (mmix_elf_section_data (input_section)->pjs.stub_size[pjsno]
1454 != 0)
1455 {
1456 Elf_Internal_Rela relcpy;
1457
1458 if (mmix_elf_section_data (input_section)
1459 ->pjs.stub_size[pjsno] != MAX_PUSHJ_STUB_SIZE)
1460 abort ();
1461
1462 /* There's already a PUSHJ insn there, so just fill in
1463 the offset bits to the stub. */
1464 if (mmix_final_link_relocate (elf_mmix_howto_table
1465 + R_MMIX_ADDR19,
1466 input_section,
1467 contents,
1468 rel->r_offset,
1469 0,
1470 input_section
1471 ->output_section->vma
1472 + input_section->output_offset
eea6121a 1473 + size
f60ebe14
HPN		 1474 + mmix_elf_section_data (input_section)
1475 ->pjs.stub_offset,
18978b27 1476 NULL, NULL, NULL) != bfd_reloc_ok)
f60ebe14
HPN		 1477 return FALSE;
1478
1479 /* Put a JMP insn at the stub; it goes with the
1480 R_MMIX_JMP reloc. */
1481 bfd_put_32 (output_bfd, JMP_INSN_BYTE << 24,
1482 contents
eea6121a 1483 + size
f60ebe14
HPN		 1484 + mmix_elf_section_data (input_section)
1485 ->pjs.stub_offset);
1486
1487 /* Change the reloc to be at the stub, and to a full
1488 R_MMIX_JMP reloc. */
1489 rel->r_info = ELF64_R_INFO (r_symndx, R_MMIX_JMP);
1490 rel->r_offset
eea6121a 1491 = (size
f60ebe14
HPN		 1492 + mmix_elf_section_data (input_section)
1493 ->pjs.stub_offset);
1494
1495 mmix_elf_section_data (input_section)->pjs.stub_offset
1496 += MAX_PUSHJ_STUB_SIZE;
1497
1498 /* Shift this reloc to the end of the relocs to maintain
1499 the r_offset sorted reloc order. */
1500 relcpy = *rel;
1501 memmove (rel, rel + 1, (char *) relend - (char *) rel);
1502 relend[-1] = relcpy;
1503
1504 /* Back up one reloc, or else we'd skip the next reloc
1505 in turn. */
1506 rel--;
1507 }
1508
1509 pjsno++;
1510 }
3c3bdf30
NC		 1511 continue;
1512 }
1513
3c3bdf30
NC		 1514 r = mmix_final_link_relocate (howto, input_section,
1515 contents, rel->r_offset,
18978b27 1516 rel->r_addend, relocation, name, sec, NULL);
3c3bdf30
NC		 1517
1518 if (r != bfd_reloc_ok)
1519 {
3c3bdf30
NC		 1520 const char * msg = (const char *) NULL;
1521
1522 switch (r)
1523 {
1524 case bfd_reloc_overflow:
1a72702b 1525 info->callbacks->reloc_overflow
dfeffb9f
L		 1526 (info, (h ? &h->root : NULL), name, howto->name,
1527 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
3c3bdf30
NC		 1528 break;
1529
1530 case bfd_reloc_undefined:
1531 /* We may have sent this message above. */
1532 if (! undefined_signalled)
1a72702b
AM		 1533 info->callbacks->undefined_symbol
1534 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
b34976b6 1535 undefined_signalled = TRUE;
3c3bdf30
NC		 1536 break;
1537
1538 case bfd_reloc_outofrange:
1539 msg = _("internal error: out of range error");
1540 break;
1541
1542 case bfd_reloc_notsupported:
1543 msg = _("internal error: unsupported relocation error");
1544 break;
1545
1546 case bfd_reloc_dangerous:
1547 msg = _("internal error: dangerous relocation");
1548 break;
1549
1550 default:
1551 msg = _("internal error: unknown error");
1552 break;
1553 }
1554
1555 if (msg)
1a72702b
AM		 1556 (*info->callbacks->warning) (info, msg, name, input_bfd,
1557 input_section, rel->r_offset);
3c3bdf30
NC		 1558 }
1559 }
1560
b34976b6 1561 return TRUE;
3c3bdf30 1562}
e06fcc86 1563\f
3c3bdf30
NC		 1564/* Perform a single relocation. By default we use the standard BFD
1565 routines. A few relocs we have to do ourselves. */
1566
1567static bfd_reloc_status_type
18978b27
HPN		 1568mmix_final_link_relocate (reloc_howto_type *howto, asection *input_section,
1569 bfd_byte *contents, bfd_vma r_offset,
1570 bfd_signed_vma r_addend, bfd_vma relocation,
1571 const char *symname, asection *symsec,
1572 char **error_message)
3c3bdf30
NC		 1573{
1574 bfd_reloc_status_type r = bfd_reloc_ok;
1575 bfd_vma addr
1576 = (input_section->output_section->vma
1577 + input_section->output_offset
1578 + r_offset);
1579 bfd_signed_vma srel
1580 = (bfd_signed_vma) relocation + r_addend;
1581
1582 switch (howto->type)
1583 {
1584 /* All these are PC-relative. */
f60ebe14 1585 case R_MMIX_PUSHJ_STUBBABLE:
3c3bdf30
NC		 1586 case R_MMIX_PUSHJ:
1587 case R_MMIX_CBRANCH:
1588 case R_MMIX_ADDR19:
1589 case R_MMIX_GETA:
1590 case R_MMIX_ADDR27:
1591 case R_MMIX_JMP:
1592 contents += r_offset;
1593
1594 srel -= (input_section->output_section->vma
1595 + input_section->output_offset
1596 + r_offset);
1597
1598 r = mmix_elf_perform_relocation (input_section, howto, contents,
18978b27 1599 addr, srel, error_message);
3c3bdf30
NC		 1600 break;
1601
930b4cb2
HPN		 1602 case R_MMIX_BASE_PLUS_OFFSET:
1603 if (symsec == NULL)
1604 return bfd_reloc_undefined;
1605
1606 /* Check that we're not relocating against a register symbol. */
1607 if (strcmp (bfd_get_section_name (symsec->owner, symsec),
1608 MMIX_REG_CONTENTS_SECTION_NAME) == 0
1609 || strcmp (bfd_get_section_name (symsec->owner, symsec),
1610 MMIX_REG_SECTION_NAME) == 0)
1611 {
1612 /* Note: This is separated out into two messages in order
1613 to ease the translation into other languages. */
1614 if (symname == NULL || *symname == 0)
4eca0228 1615 _bfd_error_handler
695344c0 1616 /* xgettext:c-format */
871b3ab2
AM		 1617 (_("%pB: base-plus-offset relocation against register symbol:"
1618 " (unknown) in %pA"),
dae82561 1619 input_section->owner, symsec);
930b4cb2 1620 else
4eca0228 1621 _bfd_error_handler
695344c0 1622 /* xgettext:c-format */
871b3ab2
AM		 1623 (_("%pB: base-plus-offset relocation against register symbol:"
1624 " %s in %pA"),
dae82561 1625 input_section->owner, symname, symsec);
930b4cb2
HPN		 1626 return bfd_reloc_overflow;
1627 }
1628 goto do_mmix_reloc;
1629
3c3bdf30
NC		 1630 case R_MMIX_REG_OR_BYTE:
1631 case R_MMIX_REG:
1632 /* For now, we handle these alike. They must refer to an register
1633 symbol, which is either relative to the register section and in
1634 the range 0..255, or is in the register contents section with vma
1635 regno * 8. */
1636
1637 /* FIXME: A better way to check for reg contents section?
1638 FIXME: Postpone section->scaling to mmix_elf_perform_relocation? */
1639 if (symsec == NULL)
1640 return bfd_reloc_undefined;
1641
1642 if (strcmp (bfd_get_section_name (symsec->owner, symsec),
1643 MMIX_REG_CONTENTS_SECTION_NAME) == 0)
1644 {
1645 if ((srel & 7) != 0 || srel < 32*8 || srel > 255*8)
1646 {
1647 /* The bfd_reloc_outofrange return value, though intuitively
1648 a better value, will not get us an error. */
1649 return bfd_reloc_overflow;
1650 }
1651 srel /= 8;
1652 }
1653 else if (strcmp (bfd_get_section_name (symsec->owner, symsec),
1654 MMIX_REG_SECTION_NAME) == 0)
1655 {
1656 if (srel < 0 || srel > 255)
1657 /* The bfd_reloc_outofrange return value, though intuitively a
1658 better value, will not get us an error. */
1659 return bfd_reloc_overflow;
1660 }
1661 else
1662 {
930b4cb2 1663 /* Note: This is separated out into two messages in order
ca09e32b
NC		 1664 to ease the translation into other languages. */
1665 if (symname == NULL || *symname == 0)
4eca0228 1666 _bfd_error_handler
695344c0 1667 /* xgettext:c-format */
871b3ab2
AM		 1668 (_("%pB: register relocation against non-register symbol:"
1669 " (unknown) in %pA"),
dae82561 1670 input_section->owner, symsec);
ca09e32b 1671 else
4eca0228 1672 _bfd_error_handler
695344c0 1673 /* xgettext:c-format */
871b3ab2
AM		 1674 (_("%pB: register relocation against non-register symbol:"
1675 " %s in %pA"),
dae82561 1676 input_section->owner, symname, symsec);
3c3bdf30
NC		 1677
1678 /* The bfd_reloc_outofrange return value, though intuitively a
1679 better value, will not get us an error. */
1680 return bfd_reloc_overflow;
1681 }
930b4cb2 1682 do_mmix_reloc:
3c3bdf30
NC		 1683 contents += r_offset;
1684 r = mmix_elf_perform_relocation (input_section, howto, contents,
18978b27 1685 addr, srel, error_message);
3c3bdf30
NC		 1686 break;
1687
1688 case R_MMIX_LOCAL:
1689 /* This isn't a real relocation, it's just an assertion that the
1690 final relocation value corresponds to a local register. We
1691 ignore the actual relocation; nothing is changed. */
1692 {
1693 asection *regsec
1694 = bfd_get_section_by_name (input_section->output_section->owner,
1695 MMIX_REG_CONTENTS_SECTION_NAME);
1696 bfd_vma first_global;
1697
1698 /* Check that this is an absolute value, or a reference to the
1699 register contents section or the register (symbol) section.
1700 Absolute numbers can get here as undefined section. Undefined
1701 symbols are signalled elsewhere, so there's no conflict in us
1702 accidentally handling it. */
1703 if (!bfd_is_abs_section (symsec)
1704 && !bfd_is_und_section (symsec)
1705 && strcmp (bfd_get_section_name (symsec->owner, symsec),
1706 MMIX_REG_CONTENTS_SECTION_NAME) != 0
1707 && strcmp (bfd_get_section_name (symsec->owner, symsec),
1708 MMIX_REG_SECTION_NAME) != 0)
1709 {
4eca0228 1710 _bfd_error_handler
871b3ab2 1711 (_("%pB: directive LOCAL valid only with a register or absolute value"),
dae82561 1712 input_section->owner);
3c3bdf30
NC		 1713
1714 return bfd_reloc_overflow;
1715 }
1716
1717 /* If we don't have a register contents section, then $255 is the
1718 first global register. */
1719 if (regsec == NULL)
1720 first_global = 255;
1721 else
1722 {
a0f49396
NC		 1723 first_global
1724 = bfd_get_section_vma (input_section->output_section->owner,
1725 regsec) / 8;
3c3bdf30
NC		 1726 if (strcmp (bfd_get_section_name (symsec->owner, symsec),
1727 MMIX_REG_CONTENTS_SECTION_NAME) == 0)
1728 {
1729 if ((srel & 7) != 0 || srel < 32*8 || srel > 255*8)
1730 /* The bfd_reloc_outofrange return value, though
1731 intuitively a better value, will not get us an error. */
1732 return bfd_reloc_overflow;
1733 srel /= 8;
1734 }
1735 }
1736
1737 if ((bfd_vma) srel >= first_global)
1738 {
1739 /* FIXME: Better error message. */
4eca0228 1740 _bfd_error_handler
695344c0 1741 /* xgettext:c-format */
2dcf00ce
AM		 1742 (_("%pB: LOCAL directive: "
1743 "Register $%" PRId64 " is not a local register."
1744 " First global register is $%" PRId64 "."),
1745 input_section->owner, (int64_t) srel, (int64_t) first_global);
3c3bdf30
NC		 1746
1747 return bfd_reloc_overflow;
1748 }
1749 }
1750 r = bfd_reloc_ok;
1751 break;
1752
1753 default:
1754 r = _bfd_final_link_relocate (howto, input_section->owner, input_section,
1755 contents, r_offset,
1756 relocation, r_addend);
1757 }
1758
1759 return r;
1760}
e06fcc86 1761\f
3c3bdf30
NC		 1762/* Return the section that should be marked against GC for a given
1763 relocation. */
1764
1765static asection *
07adf181
AM		 1766mmix_elf_gc_mark_hook (asection *sec,
1767 struct bfd_link_info *info,
1768 Elf_Internal_Rela *rel,
1769 struct elf_link_hash_entry *h,
1770 Elf_Internal_Sym *sym)
3c3bdf30
NC		 1771{
1772 if (h != NULL)
07adf181
AM		 1773 switch (ELF64_R_TYPE (rel->r_info))
1774 {
1775 case R_MMIX_GNU_VTINHERIT:
1776 case R_MMIX_GNU_VTENTRY:
1777 return NULL;
1778 }
3c3bdf30 1779
07adf181 1780 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
3c3bdf30 1781}
e06fcc86 1782\f
3c3bdf30
NC		 1783/* Sort register relocs to come before expanding relocs. */
1784
1785static int
2c3fc389 1786mmix_elf_sort_relocs (const void * p1, const void * p2)
3c3bdf30
NC		 1787{
1788 const Elf_Internal_Rela *r1 = (const Elf_Internal_Rela *) p1;
1789 const Elf_Internal_Rela *r2 = (const Elf_Internal_Rela *) p2;
1790 int r1_is_reg, r2_is_reg;
1791
1792 /* Sort primarily on r_offset & ~3, so relocs are done to consecutive
1793 insns. */
1794 if ((r1->r_offset & ~(bfd_vma) 3) > (r2->r_offset & ~(bfd_vma) 3))
1795 return 1;
1796 else if ((r1->r_offset & ~(bfd_vma) 3) < (r2->r_offset & ~(bfd_vma) 3))
1797 return -1;
1798
1799 r1_is_reg
1800 = (ELF64_R_TYPE (r1->r_info) == R_MMIX_REG_OR_BYTE
1801 || ELF64_R_TYPE (r1->r_info) == R_MMIX_REG);
1802 r2_is_reg
1803 = (ELF64_R_TYPE (r2->r_info) == R_MMIX_REG_OR_BYTE
1804 || ELF64_R_TYPE (r2->r_info) == R_MMIX_REG);
1805 if (r1_is_reg != r2_is_reg)
1806 return r2_is_reg - r1_is_reg;
1807
1808 /* Neither or both are register relocs. Then sort on full offset. */
1809 if (r1->r_offset > r2->r_offset)
1810 return 1;
1811 else if (r1->r_offset < r2->r_offset)
1812 return -1;
1813 return 0;
1814}
1815
930b4cb2
HPN		 1816/* Subset of mmix_elf_check_relocs, common to ELF and mmo linking. */
1817
b34976b6 1818static bfd_boolean
2c3fc389
NC		 1819mmix_elf_check_common_relocs (bfd *abfd,
1820 struct bfd_link_info *info,
1821 asection *sec,
1822 const Elf_Internal_Rela *relocs)
930b4cb2
HPN		 1823{
1824 bfd *bpo_greg_owner = NULL;
1825 asection *allocated_gregs_section = NULL;
1826 struct bpo_greg_section_info *gregdata = NULL;
1827 struct bpo_reloc_section_info *bpodata = NULL;
1828 const Elf_Internal_Rela *rel;
1829 const Elf_Internal_Rela *rel_end;
1830
930b4cb2
HPN		 1831 /* We currently have to abuse this COFF-specific member, since there's
1832 no target-machine-dedicated member. There's no alternative outside
1833 the bfd_link_info struct; we can't specialize a hash-table since
1834 they're different between ELF and mmo. */
1835 bpo_greg_owner = (bfd *) info->base_file;
1836
1837 rel_end = relocs + sec->reloc_count;
1838 for (rel = relocs; rel < rel_end; rel++)
1839 {
1840 switch (ELF64_R_TYPE (rel->r_info))
07d6d2b8 1841 {
930b4cb2
HPN		 1842 /* This relocation causes a GREG allocation. We need to count
1843 them, and we need to create a section for them, so we need an
1844 object to fake as the owner of that section. We can't use
1845 the ELF dynobj for this, since the ELF bits assume lots of
1846 DSO-related stuff if that member is non-NULL. */
1847 case R_MMIX_BASE_PLUS_OFFSET:
f60ebe14 1848 /* We don't do anything with this reloc for a relocatable link. */
0e1862bb 1849 if (bfd_link_relocatable (info))
f60ebe14
HPN		 1850 break;
1851
930b4cb2
HPN		 1852 if (bpo_greg_owner == NULL)
1853 {
1854 bpo_greg_owner = abfd;
2c3fc389 1855 info->base_file = bpo_greg_owner;
930b4cb2
HPN		 1856 }
1857
4fa5c2a8
HPN		 1858 if (allocated_gregs_section == NULL)
1859 allocated_gregs_section
1860 = bfd_get_section_by_name (bpo_greg_owner,
1861 MMIX_LD_ALLOCATED_REG_CONTENTS_SECTION_NAME);
1862
930b4cb2
HPN		 1863 if (allocated_gregs_section == NULL)
1864 {
1865 allocated_gregs_section
3496cb2a
L		 1866 = bfd_make_section_with_flags (bpo_greg_owner,
1867 MMIX_LD_ALLOCATED_REG_CONTENTS_SECTION_NAME,
1868 (SEC_HAS_CONTENTS
1869 | SEC_IN_MEMORY
1870 | SEC_LINKER_CREATED));
930b4cb2
HPN		 1871 /* Setting both SEC_ALLOC and SEC_LOAD means the section is
1872 treated like any other section, and we'd get errors for
1873 address overlap with the text section. Let's set none of
1874 those flags, as that is what currently happens for usual
1875 GREG allocations, and that works. */
1876 if (allocated_gregs_section == NULL
930b4cb2
HPN		 1877 || !bfd_set_section_alignment (bpo_greg_owner,
1878 allocated_gregs_section,
1879 3))
b34976b6 1880 return FALSE;
930b4cb2
HPN		 1881
1882 gregdata = (struct bpo_greg_section_info *)
1883 bfd_zalloc (bpo_greg_owner, sizeof (struct bpo_greg_section_info));
1884 if (gregdata == NULL)
b34976b6 1885 return FALSE;
f0abc2a1
AM		 1886 mmix_elf_section_data (allocated_gregs_section)->bpo.greg
1887 = gregdata;
930b4cb2
HPN		 1888 }
1889 else if (gregdata == NULL)
f0abc2a1
AM		 1890 gregdata
1891 = mmix_elf_section_data (allocated_gregs_section)->bpo.greg;
930b4cb2
HPN		 1892
1893 /* Get ourselves some auxiliary info for the BPO-relocs. */
1894 if (bpodata == NULL)
1895 {
1896 /* No use doing a separate iteration pass to find the upper
1897 limit - just use the number of relocs. */
1898 bpodata = (struct bpo_reloc_section_info *)
1899 bfd_alloc (bpo_greg_owner,
1900 sizeof (struct bpo_reloc_section_info)
1901 * (sec->reloc_count + 1));
1902 if (bpodata == NULL)
b34976b6 1903 return FALSE;
f0abc2a1 1904 mmix_elf_section_data (sec)->bpo.reloc = bpodata;
930b4cb2
HPN		 1905 bpodata->first_base_plus_offset_reloc
1906 = bpodata->bpo_index
1907 = gregdata->n_max_bpo_relocs;
1908 bpodata->bpo_greg_section
1909 = allocated_gregs_section;
4fa5c2a8 1910 bpodata->n_bpo_relocs_this_section = 0;
930b4cb2
HPN		 1911 }
1912
1913 bpodata->n_bpo_relocs_this_section++;
1914 gregdata->n_max_bpo_relocs++;
1915
1916 /* We don't get another chance to set this before GC; we've not
f60ebe14 1917 set up any hook that runs before GC. */
930b4cb2
HPN		 1918 gregdata->n_bpo_relocs
1919 = gregdata->n_max_bpo_relocs;
1920 break;
f60ebe14
HPN		 1921
1922 case R_MMIX_PUSHJ_STUBBABLE:
1923 mmix_elf_section_data (sec)->pjs.n_pushj_relocs++;
1924 break;
930b4cb2
HPN		 1925 }
1926 }
1927
f60ebe14
HPN		 1928 /* Allocate per-reloc stub storage and initialize it to the max stub
1929 size. */
1930 if (mmix_elf_section_data (sec)->pjs.n_pushj_relocs != 0)
1931 {
1932 size_t i;
1933
1934 mmix_elf_section_data (sec)->pjs.stub_size
1935 = bfd_alloc (abfd, mmix_elf_section_data (sec)->pjs.n_pushj_relocs
1936 * sizeof (mmix_elf_section_data (sec)
1937 ->pjs.stub_size[0]));
1938 if (mmix_elf_section_data (sec)->pjs.stub_size == NULL)
1939 return FALSE;
1940
1941 for (i = 0; i < mmix_elf_section_data (sec)->pjs.n_pushj_relocs; i++)
1942 mmix_elf_section_data (sec)->pjs.stub_size[i] = MAX_PUSHJ_STUB_SIZE;
1943 }
1944
b34976b6 1945 return TRUE;
930b4cb2
HPN		 1946}
1947
3c3bdf30
NC		 1948/* Look through the relocs for a section during the first phase. */
1949
b34976b6 1950static bfd_boolean
2c3fc389
NC		 1951mmix_elf_check_relocs (bfd *abfd,
1952 struct bfd_link_info *info,
1953 asection *sec,
1954 const Elf_Internal_Rela *relocs)
3c3bdf30
NC		 1955{
1956 Elf_Internal_Shdr *symtab_hdr;
5582a088 1957 struct elf_link_hash_entry **sym_hashes;
3c3bdf30
NC		 1958 const Elf_Internal_Rela *rel;
1959 const Elf_Internal_Rela *rel_end;
1960
3c3bdf30
NC		 1961 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1962 sym_hashes = elf_sym_hashes (abfd);
3c3bdf30
NC		 1963
1964 /* First we sort the relocs so that any register relocs come before
1965 expansion-relocs to the same insn. FIXME: Not done for mmo. */
2c3fc389 1966 qsort ((void *) relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
3c3bdf30
NC		 1967 mmix_elf_sort_relocs);
1968
930b4cb2
HPN		 1969 /* Do the common part. */
1970 if (!mmix_elf_check_common_relocs (abfd, info, sec, relocs))
b34976b6 1971 return FALSE;
930b4cb2 1972
0e1862bb 1973 if (bfd_link_relocatable (info))
f60ebe14
HPN		 1974 return TRUE;
1975
3c3bdf30
NC		 1976 rel_end = relocs + sec->reloc_count;
1977 for (rel = relocs; rel < rel_end; rel++)
1978 {
1979 struct elf_link_hash_entry *h;
1980 unsigned long r_symndx;
1981
1982 r_symndx = ELF64_R_SYM (rel->r_info);
1983 if (r_symndx < symtab_hdr->sh_info)
07d6d2b8 1984 h = NULL;
3c3bdf30 1985 else
973a3492
L		 1986 {
1987 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1988 while (h->root.type == bfd_link_hash_indirect
1989 || h->root.type == bfd_link_hash_warning)
1990 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1991 }
3c3bdf30
NC		 1992
1993 switch (ELF64_R_TYPE (rel->r_info))
930b4cb2 1994 {
07d6d2b8
AM		 1995 /* This relocation describes the C++ object vtable hierarchy.
1996 Reconstruct it for later use during GC. */
1997 case R_MMIX_GNU_VTINHERIT:
1998 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1999 return FALSE;
2000 break;
2001
2002 /* This relocation describes which C++ vtable entries are actually
2003 used. Record for later use during GC. */
2004 case R_MMIX_GNU_VTENTRY:
2005 BFD_ASSERT (h != NULL);
2006 if (h != NULL
2007 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2008 return FALSE;
2009 break;
930b4cb2
HPN		 2010 }
2011 }
2012
b34976b6 2013 return TRUE;
930b4cb2
HPN		 2014}
2015
2016/* Wrapper for mmix_elf_check_common_relocs, called when linking to mmo.
2017 Copied from elf_link_add_object_symbols. */
2018
b34976b6 2019bfd_boolean
2c3fc389 2020_bfd_mmix_check_all_relocs (bfd *abfd, struct bfd_link_info *info)
930b4cb2
HPN		 2021{
2022 asection *o;
2023
2024 for (o = abfd->sections; o != NULL; o = o->next)
2025 {
2026 Elf_Internal_Rela *internal_relocs;
b34976b6 2027 bfd_boolean ok;
930b4cb2
HPN		 2028
2029 if ((o->flags & SEC_RELOC) == 0
2030 || o->reloc_count == 0
2031 || ((info->strip == strip_all || info->strip == strip_debugger)
2032 && (o->flags & SEC_DEBUGGING) != 0)
2033 || bfd_is_abs_section (o->output_section))
2034 continue;
2035
2036 internal_relocs
2c3fc389 2037 = _bfd_elf_link_read_relocs (abfd, o, NULL,
45d6a902
AM		 2038 (Elf_Internal_Rela *) NULL,
2039 info->keep_memory);
930b4cb2 2040 if (internal_relocs == NULL)
b34976b6 2041 return FALSE;
930b4cb2
HPN		 2042
2043 ok = mmix_elf_check_common_relocs (abfd, info, o, internal_relocs);
2044
2045 if (! info->keep_memory)
2046 free (internal_relocs);
2047
2048 if (! ok)
b34976b6 2049 return FALSE;
3c3bdf30
NC		 2050 }
2051
b34976b6 2052 return TRUE;
3c3bdf30 2053}
e06fcc86 2054\f
3c3bdf30
NC		 2055/* Change symbols relative to the reg contents section to instead be to
2056 the register section, and scale them down to correspond to the register
2057 number. */
2058
6e0b88f1 2059static int
2c3fc389
NC		 2060mmix_elf_link_output_symbol_hook (struct bfd_link_info *info ATTRIBUTE_UNUSED,
2061 const char *name ATTRIBUTE_UNUSED,
2062 Elf_Internal_Sym *sym,
2063 asection *input_sec,
2064 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
3c3bdf30
NC		 2065{
2066 if (input_sec != NULL
2067 && input_sec->name != NULL
2068 && ELF_ST_TYPE (sym->st_info) != STT_SECTION
2069 && strcmp (input_sec->name, MMIX_REG_CONTENTS_SECTION_NAME) == 0)
2070 {
2071 sym->st_value /= 8;
2072 sym->st_shndx = SHN_REGISTER;
2073 }
2074
6e0b88f1 2075 return 1;
3c3bdf30
NC		 2076}
2077
2078/* We fake a register section that holds values that are register numbers.
2079 Having a SHN_REGISTER and register section translates better to other
2080 formats (e.g. mmo) than for example a STT_REGISTER attribute.
2081 This section faking is based on a construct in elf32-mips.c. */
2082static asection mmix_elf_reg_section;
2083static asymbol mmix_elf_reg_section_symbol;
2084static asymbol *mmix_elf_reg_section_symbol_ptr;
2085
f60ebe14 2086/* Handle the special section numbers that a symbol may use. */
3c3bdf30
NC		 2087
2088void
e6c7cdec 2089mmix_elf_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED, asymbol *asym)
3c3bdf30
NC		 2090{
2091 elf_symbol_type *elfsym;
2092
2093 elfsym = (elf_symbol_type *) asym;
2094 switch (elfsym->internal_elf_sym.st_shndx)
2095 {
2096 case SHN_REGISTER:
2097 if (mmix_elf_reg_section.name == NULL)
2098 {
2099 /* Initialize the register section. */
2100 mmix_elf_reg_section.name = MMIX_REG_SECTION_NAME;
2101 mmix_elf_reg_section.flags = SEC_NO_FLAGS;
2102 mmix_elf_reg_section.output_section = &mmix_elf_reg_section;
2103 mmix_elf_reg_section.symbol = &mmix_elf_reg_section_symbol;
2104 mmix_elf_reg_section.symbol_ptr_ptr = &mmix_elf_reg_section_symbol_ptr;
2105 mmix_elf_reg_section_symbol.name = MMIX_REG_SECTION_NAME;
2106 mmix_elf_reg_section_symbol.flags = BSF_SECTION_SYM;
2107 mmix_elf_reg_section_symbol.section = &mmix_elf_reg_section;
2108 mmix_elf_reg_section_symbol_ptr = &mmix_elf_reg_section_symbol;
2109 }
2110 asym->section = &mmix_elf_reg_section;
2111 break;
2112
2113 default:
2114 break;
2115 }
2116}
2117
2118/* Given a BFD section, try to locate the corresponding ELF section
2119 index. */
2120
b34976b6 2121static bfd_boolean
2c3fc389
NC		 2122mmix_elf_section_from_bfd_section (bfd * abfd ATTRIBUTE_UNUSED,
2123 asection * sec,
2124 int * retval)
3c3bdf30
NC		 2125{
2126 if (strcmp (bfd_get_section_name (abfd, sec), MMIX_REG_SECTION_NAME) == 0)
2127 *retval = SHN_REGISTER;
2128 else
b34976b6 2129 return FALSE;
3c3bdf30 2130
b34976b6 2131 return TRUE;
3c3bdf30
NC		 2132}
2133
2134/* Hook called by the linker routine which adds symbols from an object
2135 file. We must handle the special SHN_REGISTER section number here.
2136
2137 We also check that we only have *one* each of the section-start
2138 symbols, since otherwise having two with the same value would cause
2139 them to be "merged", but with the contents serialized. */
2140
2c3fc389
NC		 2141static bfd_boolean
2142mmix_elf_add_symbol_hook (bfd *abfd,
2143 struct bfd_link_info *info ATTRIBUTE_UNUSED,
2144 Elf_Internal_Sym *sym,
2145 const char **namep ATTRIBUTE_UNUSED,
2146 flagword *flagsp ATTRIBUTE_UNUSED,
2147 asection **secp,
2148 bfd_vma *valp ATTRIBUTE_UNUSED)
3c3bdf30
NC		 2149{
2150 if (sym->st_shndx == SHN_REGISTER)
46fda84e
AM		 2151 {
2152 *secp = bfd_make_section_old_way (abfd, MMIX_REG_SECTION_NAME);
2153 (*secp)->flags |= SEC_LINKER_CREATED;
2154 }
3c3bdf30 2155 else if ((*namep)[0] == '_' && (*namep)[1] == '_' && (*namep)[2] == '.'
0112cd26 2156 && CONST_STRNEQ (*namep, MMIX_LOC_SECTION_START_SYMBOL_PREFIX))
3c3bdf30
NC		 2157 {
2158 /* See if we have another one. */
4ab82700
AM		 2159 struct bfd_link_hash_entry *h = bfd_link_hash_lookup (info->hash,
2160 *namep,
b34976b6
AM		 2161 FALSE,
2162 FALSE,
2163 FALSE);
3c3bdf30 2164
4ab82700 2165 if (h != NULL && h->type != bfd_link_hash_undefined)
3c3bdf30
NC		 2166 {
2167 /* How do we get the asymbol (or really: the filename) from h?
4ab82700 2168 h->u.def.section->owner is NULL. */
4eca0228 2169 _bfd_error_handler
695344c0 2170 /* xgettext:c-format */
871b3ab2 2171 (_("%pB: Error: multiple definition of `%s'; start of %s "
4eca0228 2172 "is set in a earlier linked file\n"),
dae82561 2173 abfd, *namep,
4eca0228 2174 *namep + strlen (MMIX_LOC_SECTION_START_SYMBOL_PREFIX));
3c3bdf30 2175 bfd_set_error (bfd_error_bad_value);
b34976b6 2176 return FALSE;
3c3bdf30
NC		 2177 }
2178 }
2179
b34976b6 2180 return TRUE;
3c3bdf30
NC		 2181}
2182
2183/* We consider symbols matching "L.*:[0-9]+" to be local symbols. */
2184
2c3fc389
NC		 2185static bfd_boolean
2186mmix_elf_is_local_label_name (bfd *abfd, const char *name)
3c3bdf30
NC		 2187{
2188 const char *colpos;
2189 int digits;
2190
2191 /* Also include the default local-label definition. */
2192 if (_bfd_elf_is_local_label_name (abfd, name))
b34976b6 2193 return TRUE;
3c3bdf30
NC		 2194
2195 if (*name != 'L')
b34976b6 2196 return FALSE;
3c3bdf30
NC		 2197
2198 /* If there's no ":", or more than one, it's not a local symbol. */
2199 colpos = strchr (name, ':');
2200 if (colpos == NULL || strchr (colpos + 1, ':') != NULL)
b34976b6 2201 return FALSE;
3c3bdf30
NC		 2202
2203 /* Check that there are remaining characters and that they are digits. */
2204 if (colpos[1] == 0)
b34976b6 2205 return FALSE;
3c3bdf30
NC		 2206
2207 digits = strspn (colpos + 1, "0123456789");
2208 return digits != 0 && colpos[1 + digits] == 0;
2209}
2210
2211/* We get rid of the register section here. */
2212
b34976b6 2213bfd_boolean
2c3fc389 2214mmix_elf_final_link (bfd *abfd, struct bfd_link_info *info)
3c3bdf30
NC		 2215{
2216 /* We never output a register section, though we create one for
2217 temporary measures. Check that nobody entered contents into it. */
2218 asection *reg_section;
3c3bdf30
NC		 2219
2220 reg_section = bfd_get_section_by_name (abfd, MMIX_REG_SECTION_NAME);
2221
2222 if (reg_section != NULL)
2223 {
2224 /* FIXME: Pass error state gracefully. */
2225 if (bfd_get_section_flags (abfd, reg_section) & SEC_HAS_CONTENTS)
2226 _bfd_abort (__FILE__, __LINE__, _("Register section has contents\n"));
2227
46fda84e
AM		 2228 /* Really remove the section, if it hasn't already been done. */
2229 if (!bfd_section_removed_from_list (abfd, reg_section))
2230 {
2231 bfd_section_list_remove (abfd, reg_section);
2232 --abfd->section_count;
2233 }
3c3bdf30
NC		 2234 }
2235
c152c796 2236 if (! bfd_elf_final_link (abfd, info))
b34976b6 2237 return FALSE;
3c3bdf30 2238
930b4cb2
HPN		 2239 /* Since this section is marked SEC_LINKER_CREATED, it isn't output by
2240 the regular linker machinery. We do it here, like other targets with
2241 special sections. */
2242 if (info->base_file != NULL)
2243 {
2244 asection *greg_section
2245 = bfd_get_section_by_name ((bfd *) info->base_file,
2246 MMIX_LD_ALLOCATED_REG_CONTENTS_SECTION_NAME);
2247 if (!bfd_set_section_contents (abfd,
2248 greg_section->output_section,
2249 greg_section->contents,
2250 (file_ptr) greg_section->output_offset,
eea6121a 2251 greg_section->size))
b34976b6 2252 return FALSE;
930b4cb2 2253 }
b34976b6 2254 return TRUE;
930b4cb2
HPN		 2255}
2256
f60ebe14 2257/* We need to include the maximum size of PUSHJ-stubs in the initial
eea6121a 2258 section size. This is expected to shrink during linker relaxation. */
f60ebe14
HPN		 2259
2260static void
2c3fc389
NC		 2261mmix_set_relaxable_size (bfd *abfd ATTRIBUTE_UNUSED,
2262 asection *sec,
2263 void *ptr)
f60ebe14
HPN		 2264{
2265 struct bfd_link_info *info = ptr;
2266
2267 /* Make sure we only do this for section where we know we want this,
2268 otherwise we might end up resetting the size of COMMONs. */
2269 if (mmix_elf_section_data (sec)->pjs.n_pushj_relocs == 0)
2270 return;
2271
1a23a9e6 2272 sec->rawsize = sec->size;
eea6121a
AM		 2273 sec->size += (mmix_elf_section_data (sec)->pjs.n_pushj_relocs
2274 * MAX_PUSHJ_STUB_SIZE);
f60ebe14
HPN		 2275
2276 /* For use in relocatable link, we start with a max stubs size. See
2277 mmix_elf_relax_section. */
0e1862bb 2278 if (bfd_link_relocatable (info) && sec->output_section)
f60ebe14
HPN		 2279 mmix_elf_section_data (sec->output_section)->pjs.stubs_size_sum
2280 += (mmix_elf_section_data (sec)->pjs.n_pushj_relocs
2281 * MAX_PUSHJ_STUB_SIZE);
2282}
2283
930b4cb2
HPN		 2284/* Initialize stuff for the linker-generated GREGs to match
2285 R_MMIX_BASE_PLUS_OFFSET relocs seen by the linker. */
2286
b34976b6 2287bfd_boolean
2c3fc389
NC		 2288_bfd_mmix_before_linker_allocation (bfd *abfd ATTRIBUTE_UNUSED,
2289 struct bfd_link_info *info)
930b4cb2
HPN		 2290{
2291 asection *bpo_gregs_section;
2292 bfd *bpo_greg_owner;
2293 struct bpo_greg_section_info *gregdata;
2294 size_t n_gregs;
2295 bfd_vma gregs_size;
2296 size_t i;
2297 size_t *bpo_reloc_indexes;
f60ebe14
HPN		 2298 bfd *ibfd;
2299
2300 /* Set the initial size of sections. */
c72f2fb2 2301 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
f60ebe14 2302 bfd_map_over_sections (ibfd, mmix_set_relaxable_size, info);
930b4cb2
HPN		 2303
2304 /* The bpo_greg_owner bfd is supposed to have been set by
2305 mmix_elf_check_relocs when the first R_MMIX_BASE_PLUS_OFFSET is seen.
2306 If there is no such object, there was no R_MMIX_BASE_PLUS_OFFSET. */
2307 bpo_greg_owner = (bfd *) info->base_file;
2308 if (bpo_greg_owner == NULL)
b34976b6 2309 return TRUE;
930b4cb2
HPN		 2310
2311 bpo_gregs_section
2312 = bfd_get_section_by_name (bpo_greg_owner,
2313 MMIX_LD_ALLOCATED_REG_CONTENTS_SECTION_NAME);
2314
930b4cb2 2315 if (bpo_gregs_section == NULL)
b34976b6 2316 return TRUE;
930b4cb2
HPN		 2317
2318 /* We use the target-data handle in the ELF section data. */
f0abc2a1 2319 gregdata = mmix_elf_section_data (bpo_gregs_section)->bpo.greg;
930b4cb2 2320 if (gregdata == NULL)
b34976b6 2321 return FALSE;
930b4cb2
HPN		 2322
2323 n_gregs = gregdata->n_bpo_relocs;
2324 gregdata->n_allocated_bpo_gregs = n_gregs;
2325
2326 /* When this reaches zero during relaxation, all entries have been
2327 filled in and the size of the linker gregs can be calculated. */
2328 gregdata->n_remaining_bpo_relocs_this_relaxation_round = n_gregs;
2329
2330 /* Set the zeroth-order estimate for the GREGs size. */
2331 gregs_size = n_gregs * 8;
2332
2333 if (!bfd_set_section_size (bpo_greg_owner, bpo_gregs_section, gregs_size))
b34976b6 2334 return FALSE;
930b4cb2
HPN		 2335
2336 /* Allocate and set up the GREG arrays. They're filled in at relaxation
2337 time. Note that we must use the max number ever noted for the array,
2338 since the index numbers were created before GC. */
2339 gregdata->reloc_request
2340 = bfd_zalloc (bpo_greg_owner,
2341 sizeof (struct bpo_reloc_request)
2342 * gregdata->n_max_bpo_relocs);
2343
2344 gregdata->bpo_reloc_indexes
2345 = bpo_reloc_indexes
2346 = bfd_alloc (bpo_greg_owner,
2347 gregdata->n_max_bpo_relocs
2348 * sizeof (size_t));
2349 if (bpo_reloc_indexes == NULL)
b34976b6 2350 return FALSE;
930b4cb2
HPN		 2351
2352 /* The default order is an identity mapping. */
2353 for (i = 0; i < gregdata->n_max_bpo_relocs; i++)
2354 {
2355 bpo_reloc_indexes[i] = i;
2356 gregdata->reloc_request[i].bpo_reloc_no = i;
2357 }
2358
b34976b6 2359 return TRUE;
3c3bdf30 2360}
e06fcc86 2361\f
930b4cb2
HPN		 2362/* Fill in contents in the linker allocated gregs. Everything is
2363 calculated at this point; we just move the contents into place here. */
2364
b34976b6 2365bfd_boolean
2c3fc389
NC		 2366_bfd_mmix_after_linker_allocation (bfd *abfd ATTRIBUTE_UNUSED,
2367 struct bfd_link_info *link_info)
930b4cb2
HPN		 2368{
2369 asection *bpo_gregs_section;
2370 bfd *bpo_greg_owner;
2371 struct bpo_greg_section_info *gregdata;
2372 size_t n_gregs;
2373 size_t i, j;
2374 size_t lastreg;
2375 bfd_byte *contents;
2376
2377 /* The bpo_greg_owner bfd is supposed to have been set by mmix_elf_check_relocs
2378 when the first R_MMIX_BASE_PLUS_OFFSET is seen. If there is no such
2379 object, there was no R_MMIX_BASE_PLUS_OFFSET. */
2380 bpo_greg_owner = (bfd *) link_info->base_file;
2381 if (bpo_greg_owner == NULL)
b34976b6 2382 return TRUE;
930b4cb2
HPN		 2383
2384 bpo_gregs_section
2385 = bfd_get_section_by_name (bpo_greg_owner,
2386 MMIX_LD_ALLOCATED_REG_CONTENTS_SECTION_NAME);
2387
2388 /* This can't happen without DSO handling. When DSOs are handled
2389 without any R_MMIX_BASE_PLUS_OFFSET seen, there will be no such
2390 section. */
2391 if (bpo_gregs_section == NULL)
b34976b6 2392 return TRUE;
930b4cb2
HPN		 2393
2394 /* We use the target-data handle in the ELF section data. */
2395
f0abc2a1 2396 gregdata = mmix_elf_section_data (bpo_gregs_section)->bpo.greg;
930b4cb2 2397 if (gregdata == NULL)
b34976b6 2398 return FALSE;
930b4cb2
HPN		 2399
2400 n_gregs = gregdata->n_allocated_bpo_gregs;
2401
2402 bpo_gregs_section->contents
eea6121a 2403 = contents = bfd_alloc (bpo_greg_owner, bpo_gregs_section->size);
930b4cb2 2404 if (contents == NULL)
b34976b6 2405 return FALSE;
930b4cb2 2406
7e799044
HPN		 2407 /* Sanity check: If these numbers mismatch, some relocation has not been
2408 accounted for and the rest of gregdata is probably inconsistent.
2409 It's a bug, but it's more helpful to identify it than segfaulting
2410 below. */
2411 if (gregdata->n_remaining_bpo_relocs_this_relaxation_round
2412 != gregdata->n_bpo_relocs)
2413 {
4eca0228 2414 _bfd_error_handler
695344c0 2415 /* xgettext:c-format */
d42c267e 2416 (_("Internal inconsistency: remaining %lu != max %lu.\n\
7e799044 2417 Please report this bug."),
d42c267e
AM		 2418 (unsigned long) gregdata->n_remaining_bpo_relocs_this_relaxation_round,
2419 (unsigned long) gregdata->n_bpo_relocs);
b34976b6 2420 return FALSE;
7e799044
HPN		 2421 }
2422
930b4cb2
HPN		 2423 for (lastreg = 255, i = 0, j = 0; j < n_gregs; i++)
2424 if (gregdata->reloc_request[i].regindex != lastreg)
2425 {
2426 bfd_put_64 (bpo_greg_owner, gregdata->reloc_request[i].value,
2427 contents + j * 8);
2428 lastreg = gregdata->reloc_request[i].regindex;
2429 j++;
2430 }
2431
b34976b6 2432 return TRUE;
930b4cb2
HPN		 2433}
2434
2435/* Sort valid relocs to come before non-valid relocs, then on increasing
2436 value. */
2437
2438static int
2c3fc389 2439bpo_reloc_request_sort_fn (const void * p1, const void * p2)
930b4cb2
HPN		 2440{
2441 const struct bpo_reloc_request *r1 = (const struct bpo_reloc_request *) p1;
2442 const struct bpo_reloc_request *r2 = (const struct bpo_reloc_request *) p2;
2443
2444 /* Primary function is validity; non-valid relocs sorted after valid
2445 ones. */
2446 if (r1->valid != r2->valid)
2447 return r2->valid - r1->valid;
2448
4fa5c2a8
HPN		 2449 /* Then sort on value. Don't simplify and return just the difference of
2450 the values: the upper bits of the 64-bit value would be truncated on
2451 a host with 32-bit ints. */
930b4cb2 2452 if (r1->value != r2->value)
4fa5c2a8 2453 return r1->value > r2->value ? 1 : -1;
930b4cb2 2454
dfbbae4c
HPN		 2455 /* As a last re-sort, use the relocation number, so we get a stable
2456 sort. The *addresses* aren't stable since items are swapped during
2457 sorting. It depends on the qsort implementation if this actually
2458 happens. */
2459 return r1->bpo_reloc_no > r2->bpo_reloc_no
2460 ? 1 : (r1->bpo_reloc_no < r2->bpo_reloc_no ? -1 : 0);
930b4cb2
HPN		 2461}
2462
4fa5c2a8
HPN		 2463/* For debug use only. Dumps the global register allocations resulting
2464 from base-plus-offset relocs. */
2465
2466void
e6c7cdec 2467mmix_dump_bpo_gregs (struct bfd_link_info *link_info,
52d45da3 2468 void (*pf) (const char *fmt, ...))
4fa5c2a8
HPN		 2469{
2470 bfd *bpo_greg_owner;
2471 asection *bpo_gregs_section;
2472 struct bpo_greg_section_info *gregdata;
2473 unsigned int i;
2474
2475 if (link_info == NULL || link_info->base_file == NULL)
2476 return;
2477
2478 bpo_greg_owner = (bfd *) link_info->base_file;
2479
2480 bpo_gregs_section
2481 = bfd_get_section_by_name (bpo_greg_owner,
2482 MMIX_LD_ALLOCATED_REG_CONTENTS_SECTION_NAME);
2483
2484 if (bpo_gregs_section == NULL)
2485 return;
2486
f0abc2a1 2487 gregdata = mmix_elf_section_data (bpo_gregs_section)->bpo.greg;
4fa5c2a8
HPN		 2488 if (gregdata == NULL)
2489 return;
2490
2491 if (pf == NULL)
2492 pf = _bfd_error_handler;
2493
2494 /* These format strings are not translated. They are for debug purposes
2495 only and never displayed to an end user. Should they escape, we
2496 surely want them in original. */
2497 (*pf) (" n_bpo_relocs: %u\n n_max_bpo_relocs: %u\n n_remain...round: %u\n\
2498 n_allocated_bpo_gregs: %u\n", gregdata->n_bpo_relocs,
2499 gregdata->n_max_bpo_relocs,
2500 gregdata->n_remaining_bpo_relocs_this_relaxation_round,
2501 gregdata->n_allocated_bpo_gregs);
2502
2503 if (gregdata->reloc_request)
2504 for (i = 0; i < gregdata->n_max_bpo_relocs; i++)
2505 (*pf) ("%4u (%4u)/%4u#%u: 0x%08lx%08lx r: %3u o: %3u\n",
2506 i,
cf3d882d
AM		 2507 (gregdata->bpo_reloc_indexes != NULL
2508 ? gregdata->bpo_reloc_indexes[i] : (size_t) -1),
4fa5c2a8
HPN		 2509 gregdata->reloc_request[i].bpo_reloc_no,
2510 gregdata->reloc_request[i].valid,
2511
2512 (unsigned long) (gregdata->reloc_request[i].value >> 32),
2513 (unsigned long) gregdata->reloc_request[i].value,
2514 gregdata->reloc_request[i].regindex,
2515 gregdata->reloc_request[i].offset);
2516}
2517
930b4cb2
HPN		 2518/* This links all R_MMIX_BASE_PLUS_OFFSET relocs into a special array, and
2519 when the last such reloc is done, an index-array is sorted according to
2520 the values and iterated over to produce register numbers (indexed by 0
2521 from the first allocated register number) and offsets for use in real
80f540b7 2522 relocation. (N.B.: Relocatable runs are handled, not just punted.)
930b4cb2 2523
f60ebe14
HPN		 2524 PUSHJ stub accounting is also done here.
2525
930b4cb2
HPN		 2526 Symbol- and reloc-reading infrastructure copied from elf-m10200.c. */
2527
b34976b6 2528static bfd_boolean
2c3fc389
NC		 2529mmix_elf_relax_section (bfd *abfd,
2530 asection *sec,
2531 struct bfd_link_info *link_info,
2532 bfd_boolean *again)
930b4cb2 2533{
930b4cb2 2534 Elf_Internal_Shdr *symtab_hdr;
930b4cb2 2535 Elf_Internal_Rela *internal_relocs;
930b4cb2
HPN		 2536 Elf_Internal_Rela *irel, *irelend;
2537 asection *bpo_gregs_section = NULL;
2538 struct bpo_greg_section_info *gregdata;
2539 struct bpo_reloc_section_info *bpodata
f0abc2a1 2540 = mmix_elf_section_data (sec)->bpo.reloc;
f60ebe14
HPN		 2541 /* The initialization is to quiet compiler warnings. The value is to
2542 spot a missing actual initialization. */
2543 size_t bpono = (size_t) -1;
2544 size_t pjsno = 0;
6cdc0ccc 2545 Elf_Internal_Sym *isymbuf = NULL;
1a23a9e6 2546 bfd_size_type size = sec->rawsize ? sec->rawsize : sec->size;
f60ebe14
HPN		 2547
2548 mmix_elf_section_data (sec)->pjs.stubs_size_sum = 0;
930b4cb2
HPN		 2549
2550 /* Assume nothing changes. */
b34976b6 2551 *again = FALSE;
930b4cb2 2552
f60ebe14
HPN		 2553 /* We don't have to do anything if this section does not have relocs, or
2554 if this is not a code section. */
2555 if ((sec->flags & SEC_RELOC) == 0
930b4cb2
HPN		 2556 || sec->reloc_count == 0
2557 || (sec->flags & SEC_CODE) == 0
2558 || (sec->flags & SEC_LINKER_CREATED) != 0
f60ebe14 2559 /* If no R_MMIX_BASE_PLUS_OFFSET relocs and no PUSHJ-stub relocs,
07d6d2b8 2560 then nothing to do. */
f60ebe14
HPN		 2561 || (bpodata == NULL
2562 && mmix_elf_section_data (sec)->pjs.n_pushj_relocs == 0))
b34976b6 2563 return TRUE;
930b4cb2
HPN		 2564
2565 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
930b4cb2 2566
f60ebe14
HPN		 2567 if (bpodata != NULL)
2568 {
2569 bpo_gregs_section = bpodata->bpo_greg_section;
2570 gregdata = mmix_elf_section_data (bpo_gregs_section)->bpo.greg;
2571 bpono = bpodata->first_base_plus_offset_reloc;
2572 }
2573 else
2574 gregdata = NULL;
930b4cb2
HPN		 2575
2576 /* Get a copy of the native relocations. */
2577 internal_relocs
2c3fc389 2578 = _bfd_elf_link_read_relocs (abfd, sec, NULL,
45d6a902
AM		 2579 (Elf_Internal_Rela *) NULL,
2580 link_info->keep_memory);
930b4cb2
HPN		 2581 if (internal_relocs == NULL)
2582 goto error_return;
930b4cb2
HPN		 2583
2584 /* Walk through them looking for relaxing opportunities. */
2585 irelend = internal_relocs + sec->reloc_count;
2586 for (irel = internal_relocs; irel < irelend; irel++)
2587 {
2588 bfd_vma symval;
f60ebe14 2589 struct elf_link_hash_entry *h = NULL;
930b4cb2 2590
f60ebe14
HPN		 2591 /* We only process two relocs. */
2592 if (ELF64_R_TYPE (irel->r_info) != (int) R_MMIX_BASE_PLUS_OFFSET
2593 && ELF64_R_TYPE (irel->r_info) != (int) R_MMIX_PUSHJ_STUBBABLE)
930b4cb2
HPN		 2594 continue;
2595
f60ebe14
HPN		 2596 /* We process relocs in a distinctly different way when this is a
2597 relocatable link (for one, we don't look at symbols), so we avoid
2598 mixing its code with that for the "normal" relaxation. */
0e1862bb 2599 if (bfd_link_relocatable (link_info))
f60ebe14
HPN		 2600 {
2601 /* The only transformation in a relocatable link is to generate
2602 a full stub at the location of the stub calculated for the
2603 input section, if the relocated stub location, the end of the
2604 output section plus earlier stubs, cannot be reached. Thus
2605 relocatable linking can only lead to worse code, but it still
2606 works. */
2607 if (ELF64_R_TYPE (irel->r_info) == R_MMIX_PUSHJ_STUBBABLE)
2608 {
2609 /* If we can reach the end of the output-section and beyond
2610 any current stubs, then we don't need a stub for this
2611 reloc. The relaxed order of output stub allocation may
2612 not exactly match the straightforward order, so we always
2613 assume presence of output stubs, which will allow
2614 relaxation only on relocations indifferent to the
2615 presence of output stub allocations for other relocations
2616 and thus the order of output stub allocation. */
2617 if (bfd_check_overflow (complain_overflow_signed,
2618 19,
2619 0,
2620 bfd_arch_bits_per_address (abfd),
2621 /* Output-stub location. */
1a23a9e6 2622 sec->output_section->rawsize
f60ebe14
HPN		 2623 + (mmix_elf_section_data (sec
2624 ->output_section)
2625 ->pjs.stubs_size_sum)
2626 /* Location of this PUSHJ reloc. */
2627 - (sec->output_offset + irel->r_offset)
2628 /* Don't count *this* stub twice. */
2629 - (mmix_elf_section_data (sec)
2630 ->pjs.stub_size[pjsno]
2631 + MAX_PUSHJ_STUB_SIZE))
2632 == bfd_reloc_ok)
2633 mmix_elf_section_data (sec)->pjs.stub_size[pjsno] = 0;
2634
2635 mmix_elf_section_data (sec)->pjs.stubs_size_sum
2636 += mmix_elf_section_data (sec)->pjs.stub_size[pjsno];
2637
2638 pjsno++;
2639 }
2640
2641 continue;
2642 }
2643
930b4cb2
HPN		 2644 /* Get the value of the symbol referred to by the reloc. */
2645 if (ELF64_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2646 {
2647 /* A local symbol. */
6cdc0ccc 2648 Elf_Internal_Sym *isym;
930b4cb2
HPN		 2649 asection *sym_sec;
2650
6cdc0ccc
AM		 2651 /* Read this BFD's local symbols if we haven't already. */
2652 if (isymbuf == NULL)
2653 {
2654 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2655 if (isymbuf == NULL)
2656 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2657 symtab_hdr->sh_info, 0,
2658 NULL, NULL, NULL);
2659 if (isymbuf == 0)
2660 goto error_return;
2661 }
930b4cb2 2662
6cdc0ccc
AM		 2663 isym = isymbuf + ELF64_R_SYM (irel->r_info);
2664 if (isym->st_shndx == SHN_UNDEF)
930b4cb2 2665 sym_sec = bfd_und_section_ptr;
6cdc0ccc 2666 else if (isym->st_shndx == SHN_ABS)
930b4cb2 2667 sym_sec = bfd_abs_section_ptr;
6cdc0ccc 2668 else if (isym->st_shndx == SHN_COMMON)
930b4cb2
HPN		 2669 sym_sec = bfd_com_section_ptr;
2670 else
6cdc0ccc
AM		 2671 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2672 symval = (isym->st_value
930b4cb2
HPN		 2673 + sym_sec->output_section->vma
2674 + sym_sec->output_offset);
2675 }
2676 else
2677 {
2678 unsigned long indx;
930b4cb2
HPN		 2679
2680 /* An external symbol. */
2681 indx = ELF64_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2682 h = elf_sym_hashes (abfd)[indx];
2683 BFD_ASSERT (h != NULL);
284d826d
HPN		 2684 if (h->root.type == bfd_link_hash_undefweak)
2685 /* FIXME: for R_MMIX_PUSHJ_STUBBABLE, there are alternatives to
2686 the canonical value 0 for an unresolved weak symbol to
2687 consider: as the debug-friendly approach, resolve to "abort"
2688 (or a port-specific function), or as the space-friendly
2689 approach resolve to the next instruction (like some other
2690 ports, notably ARM and AArch64). These alternatives require
2691 matching code in mmix_elf_perform_relocation or its caller. */
2692 symval = 0;
2693 else if (h->root.type == bfd_link_hash_defined
2694 || h->root.type == bfd_link_hash_defweak)
2695 symval = (h->root.u.def.value
2696 + h->root.u.def.section->output_section->vma
2697 + h->root.u.def.section->output_offset);
2698 else
930b4cb2 2699 {
f60ebe14
HPN		 2700 /* This appears to be a reference to an undefined symbol. Just
2701 ignore it--it will be caught by the regular reloc processing.
2702 We need to keep BPO reloc accounting consistent, though
2703 else we'll abort instead of emitting an error message. */
2704 if (ELF64_R_TYPE (irel->r_info) == R_MMIX_BASE_PLUS_OFFSET
2705 && gregdata != NULL)
2706 {
2707 gregdata->n_remaining_bpo_relocs_this_relaxation_round--;
2708 bpono++;
2709 }
930b4cb2
HPN		 2710 continue;
2711 }
930b4cb2
HPN		 2712 }
2713
f60ebe14
HPN		 2714 if (ELF64_R_TYPE (irel->r_info) == (int) R_MMIX_PUSHJ_STUBBABLE)
2715 {
2716 bfd_vma value = symval + irel->r_addend;
2717 bfd_vma dot
2718 = (sec->output_section->vma
2719 + sec->output_offset
2720 + irel->r_offset);
2721 bfd_vma stubaddr
2722 = (sec->output_section->vma
2723 + sec->output_offset
eea6121a 2724 + size
f60ebe14
HPN		 2725 + mmix_elf_section_data (sec)->pjs.stubs_size_sum);
2726
2727 if ((value & 3) == 0
2728 && bfd_check_overflow (complain_overflow_signed,
2729 19,
2730 0,
2731 bfd_arch_bits_per_address (abfd),
2732 value - dot
2733 - (value > dot
2734 ? mmix_elf_section_data (sec)
2735 ->pjs.stub_size[pjsno]
2736 : 0))
2737 == bfd_reloc_ok)
2738 /* If the reloc fits, no stub is needed. */
2739 mmix_elf_section_data (sec)->pjs.stub_size[pjsno] = 0;
2740 else
2741 /* Maybe we can get away with just a JMP insn? */
2742 if ((value & 3) == 0
2743 && bfd_check_overflow (complain_overflow_signed,
2744 27,
2745 0,
2746 bfd_arch_bits_per_address (abfd),
2747 value - stubaddr
2748 - (value > dot
2749 ? mmix_elf_section_data (sec)
2750 ->pjs.stub_size[pjsno] - 4
2751 : 0))
2752 == bfd_reloc_ok)
2753 /* Yep, account for a stub consisting of a single JMP insn. */
2754 mmix_elf_section_data (sec)->pjs.stub_size[pjsno] = 4;
2755 else
2756 /* Nope, go for the full insn stub. It doesn't seem useful to
2757 emit the intermediate sizes; those will only be useful for
2758 a >64M program assuming contiguous code. */
2759 mmix_elf_section_data (sec)->pjs.stub_size[pjsno]
2760 = MAX_PUSHJ_STUB_SIZE;
2761
2762 mmix_elf_section_data (sec)->pjs.stubs_size_sum
2763 += mmix_elf_section_data (sec)->pjs.stub_size[pjsno];
2764 pjsno++;
2765 continue;
2766 }
2767
2768 /* We're looking at a R_MMIX_BASE_PLUS_OFFSET reloc. */
2769
930b4cb2
HPN		 2770 gregdata->reloc_request[gregdata->bpo_reloc_indexes[bpono]].value
2771 = symval + irel->r_addend;
b34976b6 2772 gregdata->reloc_request[gregdata->bpo_reloc_indexes[bpono++]].valid = TRUE;
930b4cb2
HPN		 2773 gregdata->n_remaining_bpo_relocs_this_relaxation_round--;
2774 }
2775
2776 /* Check if that was the last BPO-reloc. If so, sort the values and
2777 calculate how many registers we need to cover them. Set the size of
2778 the linker gregs, and if the number of registers changed, indicate
2779 that we need to relax some more because we have more work to do. */
f60ebe14
HPN		 2780 if (gregdata != NULL
2781 && gregdata->n_remaining_bpo_relocs_this_relaxation_round == 0)
930b4cb2
HPN		 2782 {
2783 size_t i;
2784 bfd_vma prev_base;
2785 size_t regindex;
2786
2787 /* First, reset the remaining relocs for the next round. */
2788 gregdata->n_remaining_bpo_relocs_this_relaxation_round
2789 = gregdata->n_bpo_relocs;
2790
2c3fc389 2791 qsort (gregdata->reloc_request,
930b4cb2
HPN		 2792 gregdata->n_max_bpo_relocs,
2793 sizeof (struct bpo_reloc_request),
2794 bpo_reloc_request_sort_fn);
2795
2796 /* Recalculate indexes. When we find a change (however unlikely
2797 after the initial iteration), we know we need to relax again,
2798 since items in the GREG-array are sorted by increasing value and
2799 stored in the relaxation phase. */
2800 for (i = 0; i < gregdata->n_max_bpo_relocs; i++)
2801 if (gregdata->bpo_reloc_indexes[gregdata->reloc_request[i].bpo_reloc_no]
2802 != i)
2803 {
2804 gregdata->bpo_reloc_indexes[gregdata->reloc_request[i].bpo_reloc_no]
2805 = i;
b34976b6 2806 *again = TRUE;
930b4cb2
HPN		 2807 }
2808
2809 /* Allocate register numbers (indexing from 0). Stop at the first
2810 non-valid reloc. */
2811 for (i = 0, regindex = 0, prev_base = gregdata->reloc_request[0].value;
2812 i < gregdata->n_bpo_relocs;
2813 i++)
2814 {
2815 if (gregdata->reloc_request[i].value > prev_base + 255)
2816 {
2817 regindex++;
2818 prev_base = gregdata->reloc_request[i].value;
2819 }
2820 gregdata->reloc_request[i].regindex = regindex;
2821 gregdata->reloc_request[i].offset
2822 = gregdata->reloc_request[i].value - prev_base;
2823 }
2824
2825 /* If it's not the same as the last time, we need to relax again,
2826 because the size of the section has changed. I'm not sure we
2827 actually need to do any adjustments since the shrinking happens
2828 at the start of this section, but better safe than sorry. */
2829 if (gregdata->n_allocated_bpo_gregs != regindex + 1)
2830 {
2831 gregdata->n_allocated_bpo_gregs = regindex + 1;
b34976b6 2832 *again = TRUE;
930b4cb2
HPN		 2833 }
2834
eea6121a 2835 bpo_gregs_section->size = (regindex + 1) * 8;
930b4cb2
HPN		 2836 }
2837
6cdc0ccc 2838 if (isymbuf != NULL && (unsigned char *) isymbuf != symtab_hdr->contents)
930b4cb2
HPN		 2839 {
2840 if (! link_info->keep_memory)
6cdc0ccc
AM		 2841 free (isymbuf);
2842 else
930b4cb2 2843 {
6cdc0ccc
AM		 2844 /* Cache the symbols for elf_link_input_bfd. */
2845 symtab_hdr->contents = (unsigned char *) isymbuf;
930b4cb2
HPN		 2846 }
2847 }
2848
284d826d
HPN		 2849 BFD_ASSERT(pjsno == mmix_elf_section_data (sec)->pjs.n_pushj_relocs);
2850
6cdc0ccc
AM		 2851 if (internal_relocs != NULL
2852 && elf_section_data (sec)->relocs != internal_relocs)
2853 free (internal_relocs);
2854
eea6121a 2855 if (sec->size < size + mmix_elf_section_data (sec)->pjs.stubs_size_sum)
f60ebe14
HPN		 2856 abort ();
2857
eea6121a 2858 if (sec->size > size + mmix_elf_section_data (sec)->pjs.stubs_size_sum)
f60ebe14 2859 {
eea6121a 2860 sec->size = size + mmix_elf_section_data (sec)->pjs.stubs_size_sum;
f60ebe14
HPN		 2861 *again = TRUE;
2862 }
2863
b34976b6 2864 return TRUE;
930b4cb2
HPN		 2865
2866 error_return:
6cdc0ccc
AM		 2867 if (isymbuf != NULL && (unsigned char *) isymbuf != symtab_hdr->contents)
2868 free (isymbuf);
2869 if (internal_relocs != NULL
2870 && elf_section_data (sec)->relocs != internal_relocs)
2871 free (internal_relocs);
b34976b6 2872 return FALSE;
930b4cb2
HPN		 2873}
2874\f
3c3bdf30 2875#define ELF_ARCH bfd_arch_mmix
07d6d2b8 2876#define ELF_MACHINE_CODE EM_MMIX
3c3bdf30
NC		 2877
2878/* According to mmix-doc page 36 (paragraph 45), this should be (1LL << 48LL).
2879 However, that's too much for something somewhere in the linker part of
2880 BFD; perhaps the start-address has to be a non-zero multiple of this
2881 number, or larger than this number. The symptom is that the linker
2882 complains: "warning: allocated section `.text' not in segment". We
2883 settle for 64k; the page-size used in examples is 8k.
2884 #define ELF_MAXPAGESIZE 0x10000
2885
2886 Unfortunately, this causes excessive padding in the supposedly small
2887 for-education programs that are the expected usage (where people would
2888 inspect output). We stick to 256 bytes just to have *some* default
2889 alignment. */
2890#define ELF_MAXPAGESIZE 0x100
2891
6d00b590 2892#define TARGET_BIG_SYM mmix_elf64_vec
3c3bdf30
NC		 2893#define TARGET_BIG_NAME "elf64-mmix"
2894
2895#define elf_info_to_howto_rel NULL
2896#define elf_info_to_howto mmix_info_to_howto_rela
2897#define elf_backend_relocate_section mmix_elf_relocate_section
2898#define elf_backend_gc_mark_hook mmix_elf_gc_mark_hook
930b4cb2 2899
3c3bdf30
NC		 2900#define elf_backend_link_output_symbol_hook \
2901 mmix_elf_link_output_symbol_hook
2902#define elf_backend_add_symbol_hook mmix_elf_add_symbol_hook
2903
2904#define elf_backend_check_relocs mmix_elf_check_relocs
2905#define elf_backend_symbol_processing mmix_elf_symbol_processing
d00dd7dc 2906#define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all
3c3bdf30 2907
cd5b2bab
AM		 2908#define bfd_elf64_bfd_copy_link_hash_symbol_type \
2909 _bfd_generic_copy_link_hash_symbol_type
2910
3c3bdf30
NC		 2911#define bfd_elf64_bfd_is_local_label_name \
2912 mmix_elf_is_local_label_name
2913
2914#define elf_backend_may_use_rel_p 0
2915#define elf_backend_may_use_rela_p 1
2916#define elf_backend_default_use_rela_p 1
2917
2918#define elf_backend_can_gc_sections 1
2919#define elf_backend_section_from_bfd_section \
2920 mmix_elf_section_from_bfd_section
2921
f0abc2a1 2922#define bfd_elf64_new_section_hook mmix_elf_new_section_hook
3c3bdf30 2923#define bfd_elf64_bfd_final_link mmix_elf_final_link
930b4cb2 2924#define bfd_elf64_bfd_relax_section mmix_elf_relax_section
3c3bdf30
NC		 2925
2926#include "elf64-target.h"
GDB Binutils - Deliverables
This page took 0.992704 seconds and 4 git commands to generate.