bfd/elf64-mmix.c

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