bfd/elf64-mmix.c

   1 /* MMIX-specific support for 64-bit ELF.
   2    Copyright 2001, 2002, 2003 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 *, const 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 static bfd_boolean
 233 mmix_elf_get_section_contents
 234   PARAMS ((bfd *, sec_ptr, void *, file_ptr, bfd_size_type));
 235
 236
 237 /* Watch out: this currently needs to have elements with the same index as
 238    their R_MMIX_ number.  */
 239 static reloc_howto_type elf_mmix_howto_table[] =
 240  {
 241   /* This reloc does nothing.  */
 242   HOWTO (R_MMIX_NONE,           /* type */
 243          0,                     /* rightshift */
 244          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 245          32,                    /* bitsize */
 246          FALSE,                 /* pc_relative */
 247          0,                     /* bitpos */
 248          complain_overflow_bitfield, /* complain_on_overflow */
 249          bfd_elf_generic_reloc, /* special_function */
 250          "R_MMIX_NONE",         /* name */
 251          FALSE,                 /* partial_inplace */
 252          0,                     /* src_mask */
 253          0,                     /* dst_mask */
 254          FALSE),                /* pcrel_offset */
 255
 256   /* An 8 bit absolute relocation.  */
 257   HOWTO (R_MMIX_8,              /* type */
 258          0,                     /* rightshift */
 259          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 260          8,                     /* bitsize */
 261          FALSE,                 /* pc_relative */
 262          0,                     /* bitpos */
 263          complain_overflow_bitfield, /* complain_on_overflow */
 264          bfd_elf_generic_reloc, /* special_function */
 265          "R_MMIX_8",            /* name */
 266          FALSE,                 /* partial_inplace */
 267          0,                     /* src_mask */
 268          0xff,                  /* dst_mask */
 269          FALSE),                /* pcrel_offset */
 270
 271   /* An 16 bit absolute relocation.  */
 272   HOWTO (R_MMIX_16,             /* type */
 273          0,                     /* rightshift */
 274          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 275          16,                    /* bitsize */
 276          FALSE,                 /* pc_relative */
 277          0,                     /* bitpos */
 278          complain_overflow_bitfield, /* complain_on_overflow */
 279          bfd_elf_generic_reloc, /* special_function */
 280          "R_MMIX_16",           /* name */
 281          FALSE,                 /* partial_inplace */
 282          0,                     /* src_mask */
 283          0xffff,                /* dst_mask */
 284          FALSE),                /* pcrel_offset */
 285
 286   /* An 24 bit absolute relocation.  */
 287   HOWTO (R_MMIX_24,             /* type */
 288          0,                     /* rightshift */
 289          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 290          24,                    /* bitsize */
 291          FALSE,                 /* pc_relative */
 292          0,                     /* bitpos */
 293          complain_overflow_bitfield, /* complain_on_overflow */
 294          bfd_elf_generic_reloc, /* special_function */
 295          "R_MMIX_24",           /* name */
 296          FALSE,                 /* partial_inplace */
 297          ~0xffffff,             /* src_mask */
 298          0xffffff,              /* dst_mask */
 299          FALSE),                /* pcrel_offset */
 300
 301   /* A 32 bit absolute relocation.  */
 302   HOWTO (R_MMIX_32,             /* type */
 303          0,                     /* rightshift */
 304          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 305          32,                    /* bitsize */
 306          FALSE,                 /* pc_relative */
 307          0,                     /* bitpos */
 308          complain_overflow_bitfield, /* complain_on_overflow */
 309          bfd_elf_generic_reloc, /* special_function */
 310          "R_MMIX_32",           /* name */
 311          FALSE,                 /* partial_inplace */
 312          0,                     /* src_mask */
 313          0xffffffff,            /* dst_mask */
 314          FALSE),                /* pcrel_offset */
 315
 316   /* 64 bit relocation.  */
 317   HOWTO (R_MMIX_64,             /* type */
 318          0,                     /* rightshift */
 319          4,                     /* size (0 = byte, 1 = short, 2 = long) */
 320          64,                    /* bitsize */
 321          FALSE,                 /* pc_relative */
 322          0,                     /* bitpos */
 323          complain_overflow_bitfield, /* complain_on_overflow */
 324          bfd_elf_generic_reloc, /* special_function */
 325          "R_MMIX_64",           /* name */
 326          FALSE,                 /* partial_inplace */
 327          0,                     /* src_mask */
 328          MINUS_ONE,             /* dst_mask */
 329          FALSE),                /* pcrel_offset */
 330
 331   /* An 8 bit PC-relative relocation.  */
 332   HOWTO (R_MMIX_PC_8,           /* type */
 333          0,                     /* rightshift */
 334          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 335          8,                     /* bitsize */
 336          TRUE,                  /* pc_relative */
 337          0,                     /* bitpos */
 338          complain_overflow_bitfield, /* complain_on_overflow */
 339          bfd_elf_generic_reloc, /* special_function */
 340          "R_MMIX_PC_8",         /* name */
 341          FALSE,                 /* partial_inplace */
 342          0,                     /* src_mask */
 343          0xff,                  /* dst_mask */
 344          TRUE),                 /* pcrel_offset */
 345
 346   /* An 16 bit PC-relative relocation.  */
 347   HOWTO (R_MMIX_PC_16,          /* type */
 348          0,                     /* rightshift */
 349          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 350          16,                    /* bitsize */
 351          TRUE,                  /* pc_relative */
 352          0,                     /* bitpos */
 353          complain_overflow_bitfield, /* complain_on_overflow */
 354          bfd_elf_generic_reloc, /* special_function */
 355          "R_MMIX_PC_16",        /* name */
 356          FALSE,                 /* partial_inplace */
 357          0,                     /* src_mask */
 358          0xffff,                /* dst_mask */
 359          TRUE),                 /* pcrel_offset */
 360
 361   /* An 24 bit PC-relative relocation.  */
 362   HOWTO (R_MMIX_PC_24,          /* type */
 363          0,                     /* rightshift */
 364          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 365          24,                    /* bitsize */
 366          TRUE,                  /* pc_relative */
 367          0,                     /* bitpos */
 368          complain_overflow_bitfield, /* complain_on_overflow */
 369          bfd_elf_generic_reloc, /* special_function */
 370          "R_MMIX_PC_24",        /* name */
 371          FALSE,                 /* partial_inplace */
 372          ~0xffffff,             /* src_mask */
 373          0xffffff,              /* dst_mask */
 374          TRUE),                 /* pcrel_offset */
 375
 376   /* A 32 bit absolute PC-relative relocation.  */
 377   HOWTO (R_MMIX_PC_32,          /* type */
 378          0,                     /* rightshift */
 379          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 380          32,                    /* bitsize */
 381          TRUE,                  /* pc_relative */
 382          0,                     /* bitpos */
 383          complain_overflow_bitfield, /* complain_on_overflow */
 384          bfd_elf_generic_reloc, /* special_function */
 385          "R_MMIX_PC_32",        /* name */
 386          FALSE,                 /* partial_inplace */
 387          0,                     /* src_mask */
 388          0xffffffff,            /* dst_mask */
 389          TRUE),                 /* pcrel_offset */
 390
 391   /* 64 bit PC-relative relocation.  */
 392   HOWTO (R_MMIX_PC_64,          /* type */
 393          0,                     /* rightshift */
 394          4,                     /* size (0 = byte, 1 = short, 2 = long) */
 395          64,                    /* bitsize */
 396          TRUE,                  /* pc_relative */
 397          0,                     /* bitpos */
 398          complain_overflow_bitfield, /* complain_on_overflow */
 399          bfd_elf_generic_reloc, /* special_function */
 400          "R_MMIX_PC_64",        /* name */
 401          FALSE,                 /* partial_inplace */
 402          0,                     /* src_mask */
 403          MINUS_ONE,             /* dst_mask */
 404          TRUE),                 /* pcrel_offset */
 405
 406   /* GNU extension to record C++ vtable hierarchy.  */
 407   HOWTO (R_MMIX_GNU_VTINHERIT, /* type */
 408          0,                     /* rightshift */
 409          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 410          0,                     /* bitsize */
 411          FALSE,                 /* pc_relative */
 412          0,                     /* bitpos */
 413          complain_overflow_dont, /* complain_on_overflow */
 414          NULL,                  /* special_function */
 415          "R_MMIX_GNU_VTINHERIT", /* name */
 416          FALSE,                 /* partial_inplace */
 417          0,                     /* src_mask */
 418          0,                     /* dst_mask */
 419          TRUE),                 /* pcrel_offset */
 420
 421   /* GNU extension to record C++ vtable member usage.  */
 422   HOWTO (R_MMIX_GNU_VTENTRY,    /* type */
 423          0,                     /* rightshift */
 424          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 425          0,                     /* bitsize */
 426          FALSE,                 /* pc_relative */
 427          0,                     /* bitpos */
 428          complain_overflow_dont, /* complain_on_overflow */
 429          _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
 430          "R_MMIX_GNU_VTENTRY", /* name */
 431          FALSE,                 /* partial_inplace */
 432          0,                     /* src_mask */
 433          0,                     /* dst_mask */
 434          FALSE),                /* pcrel_offset */
 435
 436   /* The GETA relocation is supposed to get any address that could
 437      possibly be reached by the GETA instruction.  It can silently expand
 438      to get a 64-bit operand, but will complain if any of the two least
 439      significant bits are set.  The howto members reflect a simple GETA.  */
 440   HOWTO (R_MMIX_GETA,           /* type */
 441          2,                     /* rightshift */
 442          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 443          19,                    /* bitsize */
 444          TRUE,                  /* pc_relative */
 445          0,                     /* bitpos */
 446          complain_overflow_signed, /* complain_on_overflow */
 447          mmix_elf_reloc,        /* special_function */
 448          "R_MMIX_GETA",         /* name */
 449          FALSE,                 /* partial_inplace */
 450          ~0x0100ffff,           /* src_mask */
 451          0x0100ffff,            /* dst_mask */
 452          TRUE),                 /* pcrel_offset */
 453
 454   HOWTO (R_MMIX_GETA_1,         /* type */
 455          2,                     /* rightshift */
 456          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 457          19,                    /* bitsize */
 458          TRUE,                  /* pc_relative */
 459          0,                     /* bitpos */
 460          complain_overflow_signed, /* complain_on_overflow */
 461          mmix_elf_reloc,        /* special_function */
 462          "R_MMIX_GETA_1",               /* name */
 463          FALSE,                 /* partial_inplace */
 464          ~0x0100ffff,           /* src_mask */
 465          0x0100ffff,            /* dst_mask */
 466          TRUE),                 /* pcrel_offset */
 467
 468   HOWTO (R_MMIX_GETA_2,         /* type */
 469          2,                     /* rightshift */
 470          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 471          19,                    /* bitsize */
 472          TRUE,                  /* pc_relative */
 473          0,                     /* bitpos */
 474          complain_overflow_signed, /* complain_on_overflow */
 475          mmix_elf_reloc,        /* special_function */
 476          "R_MMIX_GETA_2",               /* name */
 477          FALSE,                 /* partial_inplace */
 478          ~0x0100ffff,           /* src_mask */
 479          0x0100ffff,            /* dst_mask */
 480          TRUE),                 /* pcrel_offset */
 481
 482   HOWTO (R_MMIX_GETA_3,         /* type */
 483          2,                     /* rightshift */
 484          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 485          19,                    /* bitsize */
 486          TRUE,                  /* pc_relative */
 487          0,                     /* bitpos */
 488          complain_overflow_signed, /* complain_on_overflow */
 489          mmix_elf_reloc,        /* special_function */
 490          "R_MMIX_GETA_3",               /* name */
 491          FALSE,                 /* partial_inplace */
 492          ~0x0100ffff,           /* src_mask */
 493          0x0100ffff,            /* dst_mask */
 494          TRUE),                 /* pcrel_offset */
 495
 496   /* The conditional branches are supposed to reach any (code) address.
 497      It can silently expand to a 64-bit operand, but will emit an error if
 498      any of the two least significant bits are set.  The howto members
 499      reflect a simple branch.  */
 500   HOWTO (R_MMIX_CBRANCH,        /* type */
 501          2,                     /* rightshift */
 502          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 503          19,                    /* bitsize */
 504          TRUE,                  /* pc_relative */
 505          0,                     /* bitpos */
 506          complain_overflow_signed, /* complain_on_overflow */
 507          mmix_elf_reloc,        /* special_function */
 508          "R_MMIX_CBRANCH",      /* name */
 509          FALSE,                 /* partial_inplace */
 510          ~0x0100ffff,           /* src_mask */
 511          0x0100ffff,            /* dst_mask */
 512          TRUE),                 /* pcrel_offset */
 513
 514   HOWTO (R_MMIX_CBRANCH_J,      /* type */
 515          2,                     /* rightshift */
 516          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 517          19,                    /* bitsize */
 518          TRUE,                  /* pc_relative */
 519          0,                     /* bitpos */
 520          complain_overflow_signed, /* complain_on_overflow */
 521          mmix_elf_reloc,        /* special_function */
 522          "R_MMIX_CBRANCH_J",    /* name */
 523          FALSE,                 /* partial_inplace */
 524          ~0x0100ffff,           /* src_mask */
 525          0x0100ffff,            /* dst_mask */
 526          TRUE),                 /* pcrel_offset */
 527
 528   HOWTO (R_MMIX_CBRANCH_1,      /* type */
 529          2,                     /* rightshift */
 530          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 531          19,                    /* bitsize */
 532          TRUE,                  /* pc_relative */
 533          0,                     /* bitpos */
 534          complain_overflow_signed, /* complain_on_overflow */
 535          mmix_elf_reloc,        /* special_function */
 536          "R_MMIX_CBRANCH_1",    /* name */
 537          FALSE,                 /* partial_inplace */
 538          ~0x0100ffff,           /* src_mask */
 539          0x0100ffff,            /* dst_mask */
 540          TRUE),                 /* pcrel_offset */
 541
 542   HOWTO (R_MMIX_CBRANCH_2,      /* type */
 543          2,                     /* rightshift */
 544          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 545          19,                    /* bitsize */
 546          TRUE,                  /* pc_relative */
 547          0,                     /* bitpos */
 548          complain_overflow_signed, /* complain_on_overflow */
 549          mmix_elf_reloc,        /* special_function */
 550          "R_MMIX_CBRANCH_2",    /* name */
 551          FALSE,                 /* partial_inplace */
 552          ~0x0100ffff,           /* src_mask */
 553          0x0100ffff,            /* dst_mask */
 554          TRUE),                 /* pcrel_offset */
 555
 556   HOWTO (R_MMIX_CBRANCH_3,      /* type */
 557          2,                     /* rightshift */
 558          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 559          19,                    /* bitsize */
 560          TRUE,                  /* pc_relative */
 561          0,                     /* bitpos */
 562          complain_overflow_signed, /* complain_on_overflow */
 563          mmix_elf_reloc,        /* special_function */
 564          "R_MMIX_CBRANCH_3",    /* name */
 565          FALSE,                 /* partial_inplace */
 566          ~0x0100ffff,           /* src_mask */
 567          0x0100ffff,            /* dst_mask */
 568          TRUE),                 /* pcrel_offset */
 569
 570   /* The PUSHJ instruction can reach any (code) address, as long as it's
 571      the beginning of a function (no usable restriction).  It can silently
 572      expand to a 64-bit operand, but will emit an error if any of the two
 573      least significant bits are set.  It can also expand into a call to a
 574      stub; see R_MMIX_PUSHJ_STUBBABLE.  The howto members reflect a simple
 575      PUSHJ.  */
 576   HOWTO (R_MMIX_PUSHJ,          /* type */
 577          2,                     /* rightshift */
 578          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 579          19,                    /* bitsize */
 580          TRUE,                  /* pc_relative */
 581          0,                     /* bitpos */
 582          complain_overflow_signed, /* complain_on_overflow */
 583          mmix_elf_reloc,        /* special_function */
 584          "R_MMIX_PUSHJ",        /* name */
 585          FALSE,                 /* partial_inplace */
 586          ~0x0100ffff,           /* src_mask */
 587          0x0100ffff,            /* dst_mask */
 588          TRUE),                 /* pcrel_offset */
 589
 590   HOWTO (R_MMIX_PUSHJ_1,        /* type */
 591          2,                     /* rightshift */
 592          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 593          19,                    /* bitsize */
 594          TRUE,                  /* pc_relative */
 595          0,                     /* bitpos */
 596          complain_overflow_signed, /* complain_on_overflow */
 597          mmix_elf_reloc,        /* special_function */
 598          "R_MMIX_PUSHJ_1",      /* name */
 599          FALSE,                 /* partial_inplace */
 600          ~0x0100ffff,           /* src_mask */
 601          0x0100ffff,            /* dst_mask */
 602          TRUE),                 /* pcrel_offset */
 603
 604   HOWTO (R_MMIX_PUSHJ_2,        /* type */
 605          2,                     /* rightshift */
 606          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 607          19,                    /* bitsize */
 608          TRUE,                  /* pc_relative */
 609          0,                     /* bitpos */
 610          complain_overflow_signed, /* complain_on_overflow */
 611          mmix_elf_reloc,        /* special_function */
 612          "R_MMIX_PUSHJ_2",      /* name */
 613          FALSE,                 /* partial_inplace */
 614          ~0x0100ffff,           /* src_mask */
 615          0x0100ffff,            /* dst_mask */
 616          TRUE),                 /* pcrel_offset */
 617
 618   HOWTO (R_MMIX_PUSHJ_3,        /* type */
 619          2,                     /* rightshift */
 620          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 621          19,                    /* bitsize */
 622          TRUE,                  /* pc_relative */
 623          0,                     /* bitpos */
 624          complain_overflow_signed, /* complain_on_overflow */
 625          mmix_elf_reloc,        /* special_function */
 626          "R_MMIX_PUSHJ_3",      /* name */
 627          FALSE,                 /* partial_inplace */
 628          ~0x0100ffff,           /* src_mask */
 629          0x0100ffff,            /* dst_mask */
 630          TRUE),                 /* pcrel_offset */
 631
 632   /* A JMP is supposed to reach any (code) address.  By itself, it can
 633      reach +-64M; the expansion can reach all 64 bits.  Note that the 64M
 634      limit is soon reached if you link the program in wildly different
 635      memory segments.  The howto members reflect a trivial JMP.  */
 636   HOWTO (R_MMIX_JMP,            /* type */
 637          2,                     /* rightshift */
 638          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 639          27,                    /* bitsize */
 640          TRUE,                  /* pc_relative */
 641          0,                     /* bitpos */
 642          complain_overflow_signed, /* complain_on_overflow */
 643          mmix_elf_reloc,        /* special_function */
 644          "R_MMIX_JMP",          /* name */
 645          FALSE,                 /* partial_inplace */
 646          ~0x1ffffff,            /* src_mask */
 647          0x1ffffff,             /* dst_mask */
 648          TRUE),                 /* pcrel_offset */
 649
 650   HOWTO (R_MMIX_JMP_1,          /* type */
 651          2,                     /* rightshift */
 652          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 653          27,                    /* bitsize */
 654          TRUE,                  /* pc_relative */
 655          0,                     /* bitpos */
 656          complain_overflow_signed, /* complain_on_overflow */
 657          mmix_elf_reloc,        /* special_function */
 658          "R_MMIX_JMP_1",        /* name */
 659          FALSE,                 /* partial_inplace */
 660          ~0x1ffffff,            /* src_mask */
 661          0x1ffffff,             /* dst_mask */
 662          TRUE),                 /* pcrel_offset */
 663
 664   HOWTO (R_MMIX_JMP_2,          /* type */
 665          2,                     /* rightshift */
 666          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 667          27,                    /* bitsize */
 668          TRUE,                  /* pc_relative */
 669          0,                     /* bitpos */
 670          complain_overflow_signed, /* complain_on_overflow */
 671          mmix_elf_reloc,        /* special_function */
 672          "R_MMIX_JMP_2",        /* name */
 673          FALSE,                 /* partial_inplace */
 674          ~0x1ffffff,            /* src_mask */
 675          0x1ffffff,             /* dst_mask */
 676          TRUE),                 /* pcrel_offset */
 677
 678   HOWTO (R_MMIX_JMP_3,          /* type */
 679          2,                     /* rightshift */
 680          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 681          27,                    /* bitsize */
 682          TRUE,                  /* pc_relative */
 683          0,                     /* bitpos */
 684          complain_overflow_signed, /* complain_on_overflow */
 685          mmix_elf_reloc,        /* special_function */
 686          "R_MMIX_JMP_3",        /* name */
 687          FALSE,                 /* partial_inplace */
 688          ~0x1ffffff,            /* src_mask */
 689          0x1ffffff,             /* dst_mask */
 690          TRUE),                 /* pcrel_offset */
 691
 692   /* When we don't emit link-time-relaxable code from the assembler, or
 693      when relaxation has done all it can do, these relocs are used.  For
 694      GETA/PUSHJ/branches.  */
 695   HOWTO (R_MMIX_ADDR19,         /* type */
 696          2,                     /* rightshift */
 697          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 698          19,                    /* bitsize */
 699          TRUE,                  /* pc_relative */
 700          0,                     /* bitpos */
 701          complain_overflow_signed, /* complain_on_overflow */
 702          mmix_elf_reloc,        /* special_function */
 703          "R_MMIX_ADDR19",       /* name */
 704          FALSE,                 /* partial_inplace */
 705          ~0x0100ffff,           /* src_mask */
 706          0x0100ffff,            /* dst_mask */
 707          TRUE),                 /* pcrel_offset */
 708
 709   /* For JMP.  */
 710   HOWTO (R_MMIX_ADDR27,         /* type */
 711          2,                     /* rightshift */
 712          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 713          27,                    /* bitsize */
 714          TRUE,                  /* pc_relative */
 715          0,                     /* bitpos */
 716          complain_overflow_signed, /* complain_on_overflow */
 717          mmix_elf_reloc,        /* special_function */
 718          "R_MMIX_ADDR27",       /* name */
 719          FALSE,                 /* partial_inplace */
 720          ~0x1ffffff,            /* src_mask */
 721          0x1ffffff,             /* dst_mask */
 722          TRUE),                 /* pcrel_offset */
 723
 724   /* A general register or the value 0..255.  If a value, then the
 725      instruction (offset -3) needs adjusting.  */
 726   HOWTO (R_MMIX_REG_OR_BYTE,    /* type */
 727          0,                     /* rightshift */
 728          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 729          8,                     /* bitsize */
 730          FALSE,                 /* pc_relative */
 731          0,                     /* bitpos */
 732          complain_overflow_bitfield, /* complain_on_overflow */
 733          mmix_elf_reloc,        /* special_function */
 734          "R_MMIX_REG_OR_BYTE",  /* name */
 735          FALSE,                 /* partial_inplace */
 736          0,                     /* src_mask */
 737          0xff,                  /* dst_mask */
 738          FALSE),                /* pcrel_offset */
 739
 740   /* A general register.  */
 741   HOWTO (R_MMIX_REG,            /* type */
 742          0,                     /* rightshift */
 743          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 744          8,                     /* bitsize */
 745          FALSE,                 /* pc_relative */
 746          0,                     /* bitpos */
 747          complain_overflow_bitfield, /* complain_on_overflow */
 748          mmix_elf_reloc,        /* special_function */
 749          "R_MMIX_REG",          /* name */
 750          FALSE,                 /* partial_inplace */
 751          0,                     /* src_mask */
 752          0xff,                  /* dst_mask */
 753          FALSE),                /* pcrel_offset */
 754
 755   /* A register plus an index, corresponding to the relocation expression.
 756      The sizes must correspond to the valid range of the expression, while
 757      the bitmasks correspond to what we store in the image.  */
 758   HOWTO (R_MMIX_BASE_PLUS_OFFSET,       /* type */
 759          0,                     /* rightshift */
 760          4,                     /* size (0 = byte, 1 = short, 2 = long) */
 761          64,                    /* bitsize */
 762          FALSE,                 /* pc_relative */
 763          0,                     /* bitpos */
 764          complain_overflow_bitfield, /* complain_on_overflow */
 765          mmix_elf_reloc,        /* special_function */
 766          "R_MMIX_BASE_PLUS_OFFSET", /* name */
 767          FALSE,                 /* partial_inplace */
 768          0,                     /* src_mask */
 769          0xffff,                /* dst_mask */
 770          FALSE),                /* pcrel_offset */
 771
 772   /* A "magic" relocation for a LOCAL expression, asserting that the
 773      expression is less than the number of global registers.  No actual
 774      modification of the contents is done.  Implementing this as a
 775      relocation was less intrusive than e.g. putting such expressions in a
 776      section to discard *after* relocation.  */
 777   HOWTO (R_MMIX_LOCAL,          /* type */
 778          0,                     /* rightshift */
 779          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 780          0,                     /* bitsize */
 781          FALSE,                 /* pc_relative */
 782          0,                     /* bitpos */
 783          complain_overflow_dont, /* complain_on_overflow */
 784          mmix_elf_reloc,        /* special_function */
 785          "R_MMIX_LOCAL",        /* name */
 786          FALSE,                 /* partial_inplace */
 787          0,                     /* src_mask */
 788          0,                     /* dst_mask */
 789          FALSE),                /* pcrel_offset */
 790
 791   HOWTO (R_MMIX_PUSHJ_STUBBABLE, /* type */
 792          2,                     /* rightshift */
 793          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 794          19,                    /* bitsize */
 795          TRUE,                  /* pc_relative */
 796          0,                     /* bitpos */
 797          complain_overflow_signed, /* complain_on_overflow */
 798          mmix_elf_reloc,        /* special_function */
 799          "R_MMIX_PUSHJ_STUBBABLE", /* name */
 800          FALSE,                 /* partial_inplace */
 801          ~0x0100ffff,           /* src_mask */
 802          0x0100ffff,            /* dst_mask */
 803          TRUE)                  /* pcrel_offset */
 804  };
 805
 806
 807 /* Map BFD reloc types to MMIX ELF reloc types.  */
 808
 809 struct mmix_reloc_map
 810   {
 811     bfd_reloc_code_real_type bfd_reloc_val;
 812     enum elf_mmix_reloc_type elf_reloc_val;
 813   };
 814
 815
 816 static const struct mmix_reloc_map mmix_reloc_map[] =
 817   {
 818     {BFD_RELOC_NONE, R_MMIX_NONE},
 819     {BFD_RELOC_8, R_MMIX_8},
 820     {BFD_RELOC_16, R_MMIX_16},
 821     {BFD_RELOC_24, R_MMIX_24},
 822     {BFD_RELOC_32, R_MMIX_32},
 823     {BFD_RELOC_64, R_MMIX_64},
 824     {BFD_RELOC_8_PCREL, R_MMIX_PC_8},
 825     {BFD_RELOC_16_PCREL, R_MMIX_PC_16},
 826     {BFD_RELOC_24_PCREL, R_MMIX_PC_24},
 827     {BFD_RELOC_32_PCREL, R_MMIX_PC_32},
 828     {BFD_RELOC_64_PCREL, R_MMIX_PC_64},
 829     {BFD_RELOC_VTABLE_INHERIT, R_MMIX_GNU_VTINHERIT},
 830     {BFD_RELOC_VTABLE_ENTRY, R_MMIX_GNU_VTENTRY},
 831     {BFD_RELOC_MMIX_GETA, R_MMIX_GETA},
 832     {BFD_RELOC_MMIX_CBRANCH, R_MMIX_CBRANCH},
 833     {BFD_RELOC_MMIX_PUSHJ, R_MMIX_PUSHJ},
 834     {BFD_RELOC_MMIX_JMP, R_MMIX_JMP},
 835     {BFD_RELOC_MMIX_ADDR19, R_MMIX_ADDR19},
 836     {BFD_RELOC_MMIX_ADDR27, R_MMIX_ADDR27},
 837     {BFD_RELOC_MMIX_REG_OR_BYTE, R_MMIX_REG_OR_BYTE},
 838     {BFD_RELOC_MMIX_REG, R_MMIX_REG},
 839     {BFD_RELOC_MMIX_BASE_PLUS_OFFSET, R_MMIX_BASE_PLUS_OFFSET},
 840     {BFD_RELOC_MMIX_LOCAL, R_MMIX_LOCAL},
 841     {BFD_RELOC_MMIX_PUSHJ_STUBBABLE, R_MMIX_PUSHJ_STUBBABLE}
 842   };
 843
 844 static reloc_howto_type *
 845 bfd_elf64_bfd_reloc_type_lookup (abfd, code)
 846      bfd *abfd ATTRIBUTE_UNUSED;
 847      bfd_reloc_code_real_type code;
 848 {
 849   unsigned int i;
 850
 851   for (i = 0;
 852        i < sizeof (mmix_reloc_map) / sizeof (mmix_reloc_map[0]);
 853        i++)
 854     {
 855       if (mmix_reloc_map[i].bfd_reloc_val == code)
 856         return &elf_mmix_howto_table[mmix_reloc_map[i].elf_reloc_val];
 857     }
 858
 859   return NULL;
 860 }
 861
 862 static bfd_boolean
 863 mmix_elf_new_section_hook (abfd, sec)
 864      bfd *abfd;
 865      asection *sec;
 866 {
 867   struct _mmix_elf_section_data *sdata;
 868   bfd_size_type amt = sizeof (*sdata);
 869
 870   sdata = (struct _mmix_elf_section_data *) bfd_zalloc (abfd, amt);
 871   if (sdata == NULL)
 872     return FALSE;
 873   sec->used_by_bfd = (PTR) sdata;
 874
 875   return _bfd_elf_new_section_hook (abfd, sec);
 876 }
 877
 878
 879 /* This function performs the actual bitfiddling and sanity check for a
 880    final relocation.  Each relocation gets its *worst*-case expansion
 881    in size when it arrives here; any reduction in size should have been
 882    caught in linker relaxation earlier.  When we get here, the relocation
 883    looks like the smallest instruction with SWYM:s (nop:s) appended to the
 884    max size.  We fill in those nop:s.
 885
 886    R_MMIX_GETA: (FIXME: Relaxation should break this up in 1, 2, 3 tetra)
 887     GETA $N,foo
 888    ->
 889     SETL $N,foo & 0xffff
 890     INCML $N,(foo >> 16) & 0xffff
 891     INCMH $N,(foo >> 32) & 0xffff
 892     INCH $N,(foo >> 48) & 0xffff
 893
 894    R_MMIX_CBRANCH: (FIXME: Relaxation should break this up, but
 895    condbranches needing relaxation might be rare enough to not be
 896    worthwhile.)
 897     [P]Bcc $N,foo
 898    ->
 899     [~P]B~cc $N,.+20
 900     SETL $255,foo & ...
 901     INCML ...
 902     INCMH ...
 903     INCH ...
 904     GO $255,$255,0
 905
 906    R_MMIX_PUSHJ: (FIXME: Relaxation...)
 907     PUSHJ $N,foo
 908    ->
 909     SETL $255,foo & ...
 910     INCML ...
 911     INCMH ...
 912     INCH ...
 913     PUSHGO $N,$255,0
 914
 915    R_MMIX_JMP: (FIXME: Relaxation...)
 916     JMP foo
 917    ->
 918     SETL $255,foo & ...
 919     INCML ...
 920     INCMH ...
 921     INCH ...
 922     GO $255,$255,0
 923
 924    R_MMIX_ADDR19 and R_MMIX_ADDR27 are just filled in.  */
 925
 926 static bfd_reloc_status_type
 927 mmix_elf_perform_relocation (isec, howto, datap, addr, value)
 928      asection *isec;
 929      reloc_howto_type *howto;
 930      PTR datap;
 931      bfd_vma addr;
 932      bfd_vma value;
 933 {
 934   bfd *abfd = isec->owner;
 935   bfd_reloc_status_type flag = bfd_reloc_ok;
 936   bfd_reloc_status_type r;
 937   int offs = 0;
 938   int reg = 255;
 939
 940   /* The worst case bits are all similar SETL/INCML/INCMH/INCH sequences.
 941      We handle the differences here and the common sequence later.  */
 942   switch (howto->type)
 943     {
 944     case R_MMIX_GETA:
 945       offs = 0;
 946       reg = bfd_get_8 (abfd, (bfd_byte *) datap + 1);
 947
 948       /* We change to an absolute value.  */
 949       value += addr;
 950       break;
 951
 952     case R_MMIX_CBRANCH:
 953       {
 954         int in1 = bfd_get_16 (abfd, (bfd_byte *) datap) << 16;
 955
 956         /* Invert the condition and prediction bit, and set the offset
 957            to five instructions ahead.
 958
 959            We *can* do better if we want to.  If the branch is found to be
 960            within limits, we could leave the branch as is; there'll just
 961            be a bunch of NOP:s after it.  But we shouldn't see this
 962            sequence often enough that it's worth doing it.  */
 963
 964         bfd_put_32 (abfd,
 965                     (((in1 ^ ((PRED_INV_BIT | COND_INV_BIT) << 24)) & ~0xffff)
 966                      | (24/4)),
 967                     (bfd_byte *) datap);
 968
 969         /* Put a "GO $255,$255,0" after the common sequence.  */
 970         bfd_put_32 (abfd,
 971                     ((GO_INSN_BYTE | IMM_OFFSET_BIT) << 24) | 0xffff00,
 972                     (bfd_byte *) datap + 20);
 973
 974         /* Common sequence starts at offset 4.  */
 975         offs = 4;
 976
 977         /* We change to an absolute value.  */
 978         value += addr;
 979       }
 980       break;
 981
 982     case R_MMIX_PUSHJ_STUBBABLE:
 983       /* If the address fits, we're fine.  */
 984       if ((value & 3) == 0
 985           /* Note rightshift 0; see R_MMIX_JMP case below.  */
 986           && (r = bfd_check_overflow (complain_overflow_signed,
 987                                       howto->bitsize,
 988                                       0,
 989                                       bfd_arch_bits_per_address (abfd),
 990                                       value)) == bfd_reloc_ok)
 991         goto pcrel_mmix_reloc_fits;
 992       else
 993         {
 994           bfd_size_type raw_size
 995             = (isec->_raw_size
 996                - mmix_elf_section_data (isec)->pjs.n_pushj_relocs
 997                * MAX_PUSHJ_STUB_SIZE);
 998
 999           /* We have the bytes at the PUSHJ insn and need to get the
1000              position for the stub.  There's supposed to be room allocated
1001              for the stub.  */
1002           bfd_byte *stubcontents
1003             = ((char *) datap
1004                - (addr - (isec->output_section->vma + isec->output_offset))
1005                + raw_size
1006                + mmix_elf_section_data (isec)->pjs.stub_offset);
1007           bfd_vma stubaddr;
1008
1009           /* The address doesn't fit, so redirect the PUSHJ to the
1010              location of the stub.  */
1011           r = mmix_elf_perform_relocation (isec,
1012                                            &elf_mmix_howto_table
1013                                            [R_MMIX_ADDR19],
1014                                            datap,
1015                                            addr,
1016                                            isec->output_section->vma
1017                                            + isec->output_offset
1018                                            + raw_size
1019                                            + (mmix_elf_section_data (isec)
1020                                               ->pjs.stub_offset)
1021                                            - addr);
1022           if (r != bfd_reloc_ok)
1023             return r;
1024
1025           stubaddr
1026             = (isec->output_section->vma
1027                + isec->output_offset
1028                + raw_size
1029                + mmix_elf_section_data (isec)->pjs.stub_offset);
1030
1031           /* We generate a simple JMP if that suffices, else the whole 5
1032              insn stub.  */
1033           if (bfd_check_overflow (complain_overflow_signed,
1034                                   elf_mmix_howto_table[R_MMIX_ADDR27].bitsize,
1035                                   0,
1036                                   bfd_arch_bits_per_address (abfd),
1037                                   addr + value - stubaddr) == bfd_reloc_ok)
1038             {
1039               bfd_put_32 (abfd, JMP_INSN_BYTE << 24, stubcontents);
1040               r = mmix_elf_perform_relocation (isec,
1041                                                &elf_mmix_howto_table
1042                                                [R_MMIX_ADDR27],
1043                                                stubcontents,
1044                                                stubaddr,
1045                                                value + addr - stubaddr);
1046               mmix_elf_section_data (isec)->pjs.stub_offset += 4;
1047
1048               if (raw_size
1049                   + mmix_elf_section_data (isec)->pjs.stub_offset
1050                   > isec->_cooked_size)
1051                 abort ();
1052
1053               return r;
1054             }
1055           else
1056             {
1057               /* Put a "GO $255,0" after the common sequence.  */
1058               bfd_put_32 (abfd,
1059                           ((GO_INSN_BYTE | IMM_OFFSET_BIT) << 24)
1060                           | 0xff00, (bfd_byte *) stubcontents + 16);
1061
1062               /* Prepare for the general code to set the first part of the
1063                  linker stub, and */
1064               value += addr;
1065               datap = stubcontents;
1066               mmix_elf_section_data (isec)->pjs.stub_offset
1067                 += MAX_PUSHJ_STUB_SIZE;
1068             }
1069         }
1070       break;
1071
1072     case R_MMIX_PUSHJ:
1073       {
1074         int inreg = bfd_get_8 (abfd, (bfd_byte *) datap + 1);
1075
1076         /* Put a "PUSHGO $N,$255,0" after the common sequence.  */
1077         bfd_put_32 (abfd,
1078                     ((PUSHGO_INSN_BYTE | IMM_OFFSET_BIT) << 24)
1079                     | (inreg << 16)
1080                     | 0xff00,
1081                     (bfd_byte *) datap + 16);
1082
1083         /* We change to an absolute value.  */
1084         value += addr;
1085       }
1086       break;
1087
1088     case R_MMIX_JMP:
1089       /* This one is a little special.  If we get here on a non-relaxing
1090          link, and the destination is actually in range, we don't need to
1091          execute the nops.
1092          If so, we fall through to the bit-fiddling relocs.
1093
1094          FIXME: bfd_check_overflow seems broken; the relocation is
1095          rightshifted before testing, so supply a zero rightshift.  */
1096
1097       if (! ((value & 3) == 0
1098              && (r = bfd_check_overflow (complain_overflow_signed,
1099                                          howto->bitsize,
1100                                          0,
1101                                          bfd_arch_bits_per_address (abfd),
1102                                          value)) == bfd_reloc_ok))
1103         {
1104           /* If the relocation doesn't fit in a JMP, we let the NOP:s be
1105              modified below, and put a "GO $255,$255,0" after the
1106              address-loading sequence.  */
1107           bfd_put_32 (abfd,
1108                       ((GO_INSN_BYTE | IMM_OFFSET_BIT) << 24)
1109                       | 0xffff00,
1110                       (bfd_byte *) datap + 16);
1111
1112           /* We change to an absolute value.  */
1113           value += addr;
1114           break;
1115         }
1116       /* FALLTHROUGH.  */
1117     case R_MMIX_ADDR19:
1118     case R_MMIX_ADDR27:
1119     pcrel_mmix_reloc_fits:
1120       /* These must be in range, or else we emit an error.  */
1121       if ((value & 3) == 0
1122           /* Note rightshift 0; see above.  */
1123           && (r = bfd_check_overflow (complain_overflow_signed,
1124                                       howto->bitsize,
1125                                       0,
1126                                       bfd_arch_bits_per_address (abfd),
1127                                       value)) == bfd_reloc_ok)
1128         {
1129           bfd_vma in1
1130             = bfd_get_32 (abfd, (bfd_byte *) datap);
1131           bfd_vma highbit;
1132
1133           if ((bfd_signed_vma) value < 0)
1134             {
1135               highbit = 1 << 24;
1136               value += (1 << (howto->bitsize - 1));
1137             }
1138           else
1139             highbit = 0;
1140
1141           value >>= 2;
1142
1143           bfd_put_32 (abfd,
1144                       (in1 & howto->src_mask)
1145                       | highbit
1146                       | (value & howto->dst_mask),
1147                       (bfd_byte *) datap);
1148
1149           return bfd_reloc_ok;
1150         }
1151       else
1152         return bfd_reloc_overflow;
1153
1154     case R_MMIX_BASE_PLUS_OFFSET:
1155       {
1156         struct bpo_reloc_section_info *bpodata
1157           = mmix_elf_section_data (isec)->bpo.reloc;
1158         asection *bpo_greg_section
1159           = bpodata->bpo_greg_section;
1160         struct bpo_greg_section_info *gregdata
1161           = mmix_elf_section_data (bpo_greg_section)->bpo.greg;
1162         size_t bpo_index
1163           = gregdata->bpo_reloc_indexes[bpodata->bpo_index++];
1164
1165         /* A consistency check: The value we now have in "relocation" must
1166            be the same as the value we stored for that relocation.  It
1167            doesn't cost much, so can be left in at all times.  */
1168         if (value != gregdata->reloc_request[bpo_index].value)
1169           {
1170             (*_bfd_error_handler)
1171               (_("%s: Internal inconsistency error for value for\n\
1172  linker-allocated global register: linked: 0x%lx%08lx != relaxed: 0x%lx%08lx\n"),
1173                bfd_get_filename (isec->owner),
1174                (unsigned long) (value >> 32), (unsigned long) value,
1175                (unsigned long) (gregdata->reloc_request[bpo_index].value
1176                                 >> 32),
1177                (unsigned long) gregdata->reloc_request[bpo_index].value);
1178             bfd_set_error (bfd_error_bad_value);
1179             return bfd_reloc_overflow;
1180           }
1181
1182         /* Then store the register number and offset for that register
1183            into datap and datap + 1 respectively.  */
1184         bfd_put_8 (abfd,
1185                    gregdata->reloc_request[bpo_index].regindex
1186                    + bpo_greg_section->output_section->vma / 8,
1187                    datap);
1188         bfd_put_8 (abfd,
1189                    gregdata->reloc_request[bpo_index].offset,
1190                    ((unsigned char *) datap) + 1);
1191         return bfd_reloc_ok;
1192       }
1193
1194     case R_MMIX_REG_OR_BYTE:
1195     case R_MMIX_REG:
1196       if (value > 255)
1197         return bfd_reloc_overflow;
1198       bfd_put_8 (abfd, value, datap);
1199       return bfd_reloc_ok;
1200
1201     default:
1202       BAD_CASE (howto->type);
1203     }
1204
1205   /* This code adds the common SETL/INCML/INCMH/INCH worst-case
1206      sequence.  */
1207
1208   /* Lowest two bits must be 0.  We return bfd_reloc_overflow for
1209      everything that looks strange.  */
1210   if (value & 3)
1211     flag = bfd_reloc_overflow;
1212
1213   bfd_put_32 (abfd,
1214               (SETL_INSN_BYTE << 24) | (value & 0xffff) | (reg << 16),
1215               (bfd_byte *) datap + offs);
1216   bfd_put_32 (abfd,
1217               (INCML_INSN_BYTE << 24) | ((value >> 16) & 0xffff) | (reg << 16),
1218               (bfd_byte *) datap + offs + 4);
1219   bfd_put_32 (abfd,
1220               (INCMH_INSN_BYTE << 24) | ((value >> 32) & 0xffff) | (reg << 16),
1221               (bfd_byte *) datap + offs + 8);
1222   bfd_put_32 (abfd,
1223               (INCH_INSN_BYTE << 24) | ((value >> 48) & 0xffff) | (reg << 16),
1224               (bfd_byte *) datap + offs + 12);
1225
1226   return flag;
1227 }
1228
1229 /* Set the howto pointer for an MMIX ELF reloc (type RELA).  */
1230
1231 static void
1232 mmix_info_to_howto_rela (abfd, cache_ptr, dst)
1233      bfd *abfd ATTRIBUTE_UNUSED;
1234      arelent *cache_ptr;
1235      Elf_Internal_Rela *dst;
1236 {
1237   unsigned int r_type;
1238
1239   r_type = ELF64_R_TYPE (dst->r_info);
1240   BFD_ASSERT (r_type < (unsigned int) R_MMIX_max);
1241   cache_ptr->howto = &elf_mmix_howto_table[r_type];
1242 }
1243
1244 /* Any MMIX-specific relocation gets here at assembly time or when linking
1245    to other formats (such as mmo); this is the relocation function from
1246    the reloc_table.  We don't get here for final pure ELF linking.  */
1247
1248 static bfd_reloc_status_type
1249 mmix_elf_reloc (abfd, reloc_entry, symbol, data, input_section,
1250                 output_bfd, error_message)
1251      bfd *abfd;
1252      arelent *reloc_entry;
1253      asymbol *symbol;
1254      PTR data;
1255      asection *input_section;
1256      bfd *output_bfd;
1257      char **error_message ATTRIBUTE_UNUSED;
1258 {
1259   bfd_vma relocation;
1260   bfd_reloc_status_type r;
1261   asection *reloc_target_output_section;
1262   bfd_reloc_status_type flag = bfd_reloc_ok;
1263   bfd_vma output_base = 0;
1264   bfd_vma addr;
1265
1266   r = bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1267                              input_section, output_bfd, error_message);
1268
1269   /* If that was all that was needed (i.e. this isn't a final link, only
1270      some segment adjustments), we're done.  */
1271   if (r != bfd_reloc_continue)
1272     return r;
1273
1274   if (bfd_is_und_section (symbol->section)
1275       && (symbol->flags & BSF_WEAK) == 0
1276       && output_bfd == (bfd *) NULL)
1277     return bfd_reloc_undefined;
1278
1279   /* Is the address of the relocation really within the section?  */
1280   if (reloc_entry->address > input_section->_cooked_size)
1281     return bfd_reloc_outofrange;
1282
1283   /* Work out which section the relocation is targeted at and the
1284      initial relocation command value.  */
1285
1286   /* Get symbol value.  (Common symbols are special.)  */
1287   if (bfd_is_com_section (symbol->section))
1288     relocation = 0;
1289   else
1290     relocation = symbol->value;
1291
1292   reloc_target_output_section = bfd_get_output_section (symbol);
1293
1294   /* Here the variable relocation holds the final address of the symbol we
1295      are relocating against, plus any addend.  */
1296   if (output_bfd)
1297     output_base = 0;
1298   else
1299     output_base = reloc_target_output_section->vma;
1300
1301   relocation += output_base + symbol->section->output_offset;
1302
1303   /* Get position of relocation.  */
1304   addr = (reloc_entry->address + input_section->output_section->vma
1305           + input_section->output_offset);
1306   if (output_bfd != (bfd *) NULL)
1307     {
1308       /* Add in supplied addend.  */
1309       relocation += reloc_entry->addend;
1310
1311       /* This is a partial relocation, and we want to apply the
1312          relocation to the reloc entry rather than the raw data.
1313          Modify the reloc inplace to reflect what we now know.  */
1314       reloc_entry->addend = relocation;
1315       reloc_entry->address += input_section->output_offset;
1316       return flag;
1317     }
1318
1319   return mmix_final_link_relocate (reloc_entry->howto, input_section,
1320                                    data, reloc_entry->address,
1321                                    reloc_entry->addend, relocation,
1322                                    bfd_asymbol_name (symbol),
1323                                    reloc_target_output_section);
1324 }
1325 \f
1326 /* Relocate an MMIX ELF section.  Modified from elf32-fr30.c; look to it
1327    for guidance if you're thinking of copying this.  */
1328
1329 static bfd_boolean
1330 mmix_elf_relocate_section (output_bfd, info, input_bfd, input_section,
1331                            contents, relocs, local_syms, local_sections)
1332      bfd *output_bfd ATTRIBUTE_UNUSED;
1333      struct bfd_link_info *info;
1334      bfd *input_bfd;
1335      asection *input_section;
1336      bfd_byte *contents;
1337      Elf_Internal_Rela *relocs;
1338      Elf_Internal_Sym *local_syms;
1339      asection **local_sections;
1340 {
1341   Elf_Internal_Shdr *symtab_hdr;
1342   struct elf_link_hash_entry **sym_hashes;
1343   Elf_Internal_Rela *rel;
1344   Elf_Internal_Rela *relend;
1345   bfd_size_type raw_size
1346     = (input_section->_raw_size
1347        - mmix_elf_section_data (input_section)->pjs.n_pushj_relocs
1348        * MAX_PUSHJ_STUB_SIZE);
1349   size_t pjsno = 0;
1350
1351   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1352   sym_hashes = elf_sym_hashes (input_bfd);
1353   relend = relocs + input_section->reloc_count;
1354
1355   for (rel = relocs; rel < relend; rel ++)
1356     {
1357       reloc_howto_type *howto;
1358       unsigned long r_symndx;
1359       Elf_Internal_Sym *sym;
1360       asection *sec;
1361       struct elf_link_hash_entry *h;
1362       bfd_vma relocation;
1363       bfd_reloc_status_type r;
1364       const char *name = NULL;
1365       int r_type;
1366       bfd_boolean undefined_signalled = FALSE;
1367
1368       r_type = ELF64_R_TYPE (rel->r_info);
1369
1370       if (r_type == R_MMIX_GNU_VTINHERIT
1371           || r_type == R_MMIX_GNU_VTENTRY)
1372         continue;
1373
1374       r_symndx = ELF64_R_SYM (rel->r_info);
1375
1376       if (info->relocatable)
1377         {
1378           /* This is a relocatable link.  For most relocs we don't have to
1379              change anything, unless the reloc is against a section
1380              symbol, in which case we have to adjust according to where
1381              the section symbol winds up in the output section.  */
1382           if (r_symndx < symtab_hdr->sh_info)
1383             {
1384               sym = local_syms + r_symndx;
1385
1386               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1387                 {
1388                   sec = local_sections [r_symndx];
1389                   rel->r_addend += sec->output_offset + sym->st_value;
1390                 }
1391             }
1392
1393           /* For PUSHJ stub relocs however, we may need to change the
1394              reloc and the section contents, if the reloc doesn't reach
1395              beyond the end of the output section and previous stubs.
1396              Then we change the section contents to be a PUSHJ to the end
1397              of the input section plus stubs (we can do that without using
1398              a reloc), and then we change the reloc to be a R_MMIX_PUSHJ
1399              at the stub location.  */
1400           if (r_type == R_MMIX_PUSHJ_STUBBABLE)
1401             {
1402               /* We've already checked whether we need a stub; use that
1403                  knowledge.  */
1404               if (mmix_elf_section_data (input_section)->pjs.stub_size[pjsno]
1405                   != 0)
1406                 {
1407                   Elf_Internal_Rela relcpy;
1408
1409                   if (mmix_elf_section_data (input_section)
1410                       ->pjs.stub_size[pjsno] != MAX_PUSHJ_STUB_SIZE)
1411                     abort ();
1412
1413                   /* There's already a PUSHJ insn there, so just fill in
1414                      the offset bits to the stub.  */
1415                   if (mmix_final_link_relocate (elf_mmix_howto_table
1416                                                 + R_MMIX_ADDR19,
1417                                                 input_section,
1418                                                 contents,
1419                                                 rel->r_offset,
1420                                                 0,
1421                                                 input_section
1422                                                 ->output_section->vma
1423                                                 + input_section->output_offset
1424                                                 + raw_size
1425                                                 + mmix_elf_section_data (input_section)
1426                                                 ->pjs.stub_offset,
1427                                                 NULL, NULL) != bfd_reloc_ok)
1428                     return FALSE;
1429
1430                   /* Put a JMP insn at the stub; it goes with the
1431                      R_MMIX_JMP reloc.  */
1432                   bfd_put_32 (output_bfd, JMP_INSN_BYTE << 24,
1433                               contents
1434                               + raw_size
1435                               + mmix_elf_section_data (input_section)
1436                               ->pjs.stub_offset);
1437
1438                   /* Change the reloc to be at the stub, and to a full
1439                      R_MMIX_JMP reloc.  */
1440                   rel->r_info = ELF64_R_INFO (r_symndx, R_MMIX_JMP);
1441                   rel->r_offset
1442                     = (raw_size
1443                        + mmix_elf_section_data (input_section)
1444                        ->pjs.stub_offset);
1445
1446                   mmix_elf_section_data (input_section)->pjs.stub_offset
1447                     += MAX_PUSHJ_STUB_SIZE;
1448
1449                   /* Shift this reloc to the end of the relocs to maintain
1450                      the r_offset sorted reloc order.  */
1451                   relcpy = *rel;
1452                   memmove (rel, rel + 1, (char *) relend - (char *) rel);
1453                   relend[-1] = relcpy;
1454
1455                   /* Back up one reloc, or else we'd skip the next reloc
1456                    in turn.  */
1457                   rel--;
1458                 }
1459
1460               pjsno++;
1461             }
1462           continue;
1463         }
1464
1465       /* This is a final link.  */
1466       howto = elf_mmix_howto_table + ELF64_R_TYPE (rel->r_info);
1467       h = NULL;
1468       sym = NULL;
1469       sec = NULL;
1470
1471       if (r_symndx < symtab_hdr->sh_info)
1472         {
1473           sym = local_syms + r_symndx;
1474           sec = local_sections [r_symndx];
1475           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1476
1477           name = bfd_elf_string_from_elf_section
1478             (input_bfd, symtab_hdr->sh_link, sym->st_name);
1479           name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
1480         }
1481       else
1482         {
1483           bfd_boolean unresolved_reloc;
1484
1485           RELOC_FOR_GLOBAL_SYMBOL (h, sym_hashes, r_symndx, symtab_hdr,
1486                                    relocation, sec, unresolved_reloc,
1487                                    info, undefined_signalled);
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, name, howto->name, (bfd_vma) 0,
1504                  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 (bpo_greg_owner,
1894                                     MMIX_LD_ALLOCATED_REG_CONTENTS_SECTION_NAME);
1895               /* Setting both SEC_ALLOC and SEC_LOAD means the section is
1896                  treated like any other section, and we'd get errors for
1897                  address overlap with the text section.  Let's set none of
1898                  those flags, as that is what currently happens for usual
1899                  GREG allocations, and that works.  */
1900               if (allocated_gregs_section == NULL
1901                   || !bfd_set_section_flags (bpo_greg_owner,
1902                                              allocated_gregs_section,
1903                                              (SEC_HAS_CONTENTS
1904                                               | SEC_IN_MEMORY
1905                                               | SEC_LINKER_CREATED))
1906                   || !bfd_set_section_alignment (bpo_greg_owner,
1907                                                  allocated_gregs_section,
1908                                                  3))
1909                 return FALSE;
1910
1911               gregdata = (struct bpo_greg_section_info *)
1912                 bfd_zalloc (bpo_greg_owner, sizeof (struct bpo_greg_section_info));
1913               if (gregdata == NULL)
1914                 return FALSE;
1915               mmix_elf_section_data (allocated_gregs_section)->bpo.greg
1916                 = gregdata;
1917             }
1918           else if (gregdata == NULL)
1919             gregdata
1920               = mmix_elf_section_data (allocated_gregs_section)->bpo.greg;
1921
1922           /* Get ourselves some auxiliary info for the BPO-relocs.  */
1923           if (bpodata == NULL)
1924             {
1925               /* No use doing a separate iteration pass to find the upper
1926                  limit - just use the number of relocs.  */
1927               bpodata = (struct bpo_reloc_section_info *)
1928                 bfd_alloc (bpo_greg_owner,
1929                            sizeof (struct bpo_reloc_section_info)
1930                            * (sec->reloc_count + 1));
1931               if (bpodata == NULL)
1932                 return FALSE;
1933               mmix_elf_section_data (sec)->bpo.reloc = bpodata;
1934               bpodata->first_base_plus_offset_reloc
1935                 = bpodata->bpo_index
1936                 = gregdata->n_max_bpo_relocs;
1937               bpodata->bpo_greg_section
1938                 = allocated_gregs_section;
1939               bpodata->n_bpo_relocs_this_section = 0;
1940             }
1941
1942           bpodata->n_bpo_relocs_this_section++;
1943           gregdata->n_max_bpo_relocs++;
1944
1945           /* We don't get another chance to set this before GC; we've not
1946              set up any hook that runs before GC.  */
1947           gregdata->n_bpo_relocs
1948             = gregdata->n_max_bpo_relocs;
1949           break;
1950
1951         case R_MMIX_PUSHJ_STUBBABLE:
1952           mmix_elf_section_data (sec)->pjs.n_pushj_relocs++;
1953           break;
1954         }
1955     }
1956
1957   /* Allocate per-reloc stub storage and initialize it to the max stub
1958      size.  */
1959   if (mmix_elf_section_data (sec)->pjs.n_pushj_relocs != 0)
1960     {
1961       size_t i;
1962
1963       mmix_elf_section_data (sec)->pjs.stub_size
1964         = bfd_alloc (abfd, mmix_elf_section_data (sec)->pjs.n_pushj_relocs
1965                      * sizeof (mmix_elf_section_data (sec)
1966                                ->pjs.stub_size[0]));
1967       if (mmix_elf_section_data (sec)->pjs.stub_size == NULL)
1968         return FALSE;
1969
1970       for (i = 0; i < mmix_elf_section_data (sec)->pjs.n_pushj_relocs; i++)
1971         mmix_elf_section_data (sec)->pjs.stub_size[i] = MAX_PUSHJ_STUB_SIZE;
1972     }
1973
1974   return TRUE;
1975 }
1976
1977 /* Look through the relocs for a section during the first phase.  */
1978
1979 static bfd_boolean
1980 mmix_elf_check_relocs (abfd, info, sec, relocs)
1981      bfd *abfd;
1982      struct bfd_link_info *info;
1983      asection *sec;
1984      const Elf_Internal_Rela *relocs;
1985 {
1986   Elf_Internal_Shdr *symtab_hdr;
1987   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
1988   const Elf_Internal_Rela *rel;
1989   const Elf_Internal_Rela *rel_end;
1990
1991   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1992   sym_hashes = elf_sym_hashes (abfd);
1993   sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof(Elf64_External_Sym);
1994   if (!elf_bad_symtab (abfd))
1995     sym_hashes_end -= symtab_hdr->sh_info;
1996
1997   /* First we sort the relocs so that any register relocs come before
1998      expansion-relocs to the same insn.  FIXME: Not done for mmo.  */
1999   qsort ((PTR) relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
2000          mmix_elf_sort_relocs);
2001
2002   /* Do the common part.  */
2003   if (!mmix_elf_check_common_relocs (abfd, info, sec, relocs))
2004     return FALSE;
2005
2006   if (info->relocatable)
2007     return TRUE;
2008
2009   rel_end = relocs + sec->reloc_count;
2010   for (rel = relocs; rel < rel_end; rel++)
2011     {
2012       struct elf_link_hash_entry *h;
2013       unsigned long r_symndx;
2014
2015       r_symndx = ELF64_R_SYM (rel->r_info);
2016       if (r_symndx < symtab_hdr->sh_info)
2017         h = NULL;
2018       else
2019         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2020
2021       switch (ELF64_R_TYPE (rel->r_info))
2022         {
2023         /* This relocation describes the C++ object vtable hierarchy.
2024            Reconstruct it for later use during GC.  */
2025         case R_MMIX_GNU_VTINHERIT:
2026           if (!_bfd_elf64_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2027             return FALSE;
2028           break;
2029
2030         /* This relocation describes which C++ vtable entries are actually
2031            used.  Record for later use during GC.  */
2032         case R_MMIX_GNU_VTENTRY:
2033           if (!_bfd_elf64_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2034             return FALSE;
2035           break;
2036         }
2037     }
2038
2039   return TRUE;
2040 }
2041
2042 /* Wrapper for mmix_elf_check_common_relocs, called when linking to mmo.
2043    Copied from elf_link_add_object_symbols.  */
2044
2045 bfd_boolean
2046 _bfd_mmix_check_all_relocs (abfd, info)
2047      bfd *abfd;
2048      struct bfd_link_info *info;
2049 {
2050   asection *o;
2051
2052   for (o = abfd->sections; o != NULL; o = o->next)
2053     {
2054       Elf_Internal_Rela *internal_relocs;
2055       bfd_boolean ok;
2056
2057       if ((o->flags & SEC_RELOC) == 0
2058           || o->reloc_count == 0
2059           || ((info->strip == strip_all || info->strip == strip_debugger)
2060               && (o->flags & SEC_DEBUGGING) != 0)
2061           || bfd_is_abs_section (o->output_section))
2062         continue;
2063
2064       internal_relocs
2065         = _bfd_elf_link_read_relocs (abfd, o, (PTR) NULL,
2066                                      (Elf_Internal_Rela *) NULL,
2067                                      info->keep_memory);
2068       if (internal_relocs == NULL)
2069         return FALSE;
2070
2071       ok = mmix_elf_check_common_relocs (abfd, info, o, internal_relocs);
2072
2073       if (! info->keep_memory)
2074         free (internal_relocs);
2075
2076       if (! ok)
2077         return FALSE;
2078     }
2079
2080   return TRUE;
2081 }
2082 \f
2083 /* Change symbols relative to the reg contents section to instead be to
2084    the register section, and scale them down to correspond to the register
2085    number.  */
2086
2087 static bfd_boolean
2088 mmix_elf_link_output_symbol_hook (info, name, sym, input_sec, h)
2089      struct bfd_link_info *info ATTRIBUTE_UNUSED;
2090      const char *name ATTRIBUTE_UNUSED;
2091      Elf_Internal_Sym *sym;
2092      asection *input_sec;
2093      struct elf_link_hash_entry *h ATTRIBUTE_UNUSED;
2094 {
2095   if (input_sec != NULL
2096       && input_sec->name != NULL
2097       && ELF_ST_TYPE (sym->st_info) != STT_SECTION
2098       && strcmp (input_sec->name, MMIX_REG_CONTENTS_SECTION_NAME) == 0)
2099     {
2100       sym->st_value /= 8;
2101       sym->st_shndx = SHN_REGISTER;
2102     }
2103
2104   return TRUE;
2105 }
2106
2107 /* We fake a register section that holds values that are register numbers.
2108    Having a SHN_REGISTER and register section translates better to other
2109    formats (e.g. mmo) than for example a STT_REGISTER attribute.
2110    This section faking is based on a construct in elf32-mips.c.  */
2111 static asection mmix_elf_reg_section;
2112 static asymbol mmix_elf_reg_section_symbol;
2113 static asymbol *mmix_elf_reg_section_symbol_ptr;
2114
2115 /* Handle the special section numbers that a symbol may use.  */
2116
2117 void
2118 mmix_elf_symbol_processing (abfd, asym)
2119      bfd *abfd ATTRIBUTE_UNUSED;
2120      asymbol *asym;
2121 {
2122   elf_symbol_type *elfsym;
2123
2124   elfsym = (elf_symbol_type *) asym;
2125   switch (elfsym->internal_elf_sym.st_shndx)
2126     {
2127     case SHN_REGISTER:
2128       if (mmix_elf_reg_section.name == NULL)
2129         {
2130           /* Initialize the register section.  */
2131           mmix_elf_reg_section.name = MMIX_REG_SECTION_NAME;
2132           mmix_elf_reg_section.flags = SEC_NO_FLAGS;
2133           mmix_elf_reg_section.output_section = &mmix_elf_reg_section;
2134           mmix_elf_reg_section.symbol = &mmix_elf_reg_section_symbol;
2135           mmix_elf_reg_section.symbol_ptr_ptr = &mmix_elf_reg_section_symbol_ptr;
2136           mmix_elf_reg_section_symbol.name = MMIX_REG_SECTION_NAME;
2137           mmix_elf_reg_section_symbol.flags = BSF_SECTION_SYM;
2138           mmix_elf_reg_section_symbol.section = &mmix_elf_reg_section;
2139           mmix_elf_reg_section_symbol_ptr = &mmix_elf_reg_section_symbol;
2140         }
2141       asym->section = &mmix_elf_reg_section;
2142       break;
2143
2144     default:
2145       break;
2146     }
2147 }
2148
2149 /* Given a BFD section, try to locate the corresponding ELF section
2150    index.  */
2151
2152 static bfd_boolean
2153 mmix_elf_section_from_bfd_section (abfd, sec, retval)
2154      bfd *                 abfd ATTRIBUTE_UNUSED;
2155      asection *            sec;
2156      int *                 retval;
2157 {
2158   if (strcmp (bfd_get_section_name (abfd, sec), MMIX_REG_SECTION_NAME) == 0)
2159     *retval = SHN_REGISTER;
2160   else
2161     return FALSE;
2162
2163   return TRUE;
2164 }
2165
2166 /* Hook called by the linker routine which adds symbols from an object
2167    file.  We must handle the special SHN_REGISTER section number here.
2168
2169    We also check that we only have *one* each of the section-start
2170    symbols, since otherwise having two with the same value would cause
2171    them to be "merged", but with the contents serialized.  */
2172
2173 bfd_boolean
2174 mmix_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
2175      bfd *abfd;
2176      struct bfd_link_info *info ATTRIBUTE_UNUSED;
2177      const Elf_Internal_Sym *sym;
2178      const char **namep ATTRIBUTE_UNUSED;
2179      flagword *flagsp ATTRIBUTE_UNUSED;
2180      asection **secp;
2181      bfd_vma *valp ATTRIBUTE_UNUSED;
2182 {
2183   if (sym->st_shndx == SHN_REGISTER)
2184     *secp = bfd_make_section_old_way (abfd, MMIX_REG_SECTION_NAME);
2185   else if ((*namep)[0] == '_' && (*namep)[1] == '_' && (*namep)[2] == '.'
2186            && strncmp (*namep, MMIX_LOC_SECTION_START_SYMBOL_PREFIX,
2187                        strlen (MMIX_LOC_SECTION_START_SYMBOL_PREFIX)) == 0)
2188     {
2189       /* See if we have another one.  */
2190       struct bfd_link_hash_entry *h = bfd_link_hash_lookup (info->hash,
2191                                                             *namep,
2192                                                             FALSE,
2193                                                             FALSE,
2194                                                             FALSE);
2195
2196       if (h != NULL && h->type != bfd_link_hash_undefined)
2197         {
2198           /* How do we get the asymbol (or really: the filename) from h?
2199              h->u.def.section->owner is NULL.  */
2200           ((*_bfd_error_handler)
2201            (_("%s: Error: multiple definition of `%s'; start of %s is set in a earlier linked file\n"),
2202             bfd_get_filename (abfd), *namep,
2203             *namep + strlen (MMIX_LOC_SECTION_START_SYMBOL_PREFIX)));
2204            bfd_set_error (bfd_error_bad_value);
2205            return FALSE;
2206         }
2207     }
2208
2209   return TRUE;
2210 }
2211
2212 /* We consider symbols matching "L.*:[0-9]+" to be local symbols.  */
2213
2214 bfd_boolean
2215 mmix_elf_is_local_label_name (abfd, name)
2216      bfd *abfd;
2217      const char *name;
2218 {
2219   const char *colpos;
2220   int digits;
2221
2222   /* Also include the default local-label definition.  */
2223   if (_bfd_elf_is_local_label_name (abfd, name))
2224     return TRUE;
2225
2226   if (*name != 'L')
2227     return FALSE;
2228
2229   /* If there's no ":", or more than one, it's not a local symbol.  */
2230   colpos = strchr (name, ':');
2231   if (colpos == NULL || strchr (colpos + 1, ':') != NULL)
2232     return FALSE;
2233
2234   /* Check that there are remaining characters and that they are digits.  */
2235   if (colpos[1] == 0)
2236     return FALSE;
2237
2238   digits = strspn (colpos + 1, "0123456789");
2239   return digits != 0 && colpos[1 + digits] == 0;
2240 }
2241
2242 /* We get rid of the register section here.  */
2243
2244 bfd_boolean
2245 mmix_elf_final_link (abfd, info)
2246      bfd *abfd;
2247      struct bfd_link_info *info;
2248 {
2249   /* We never output a register section, though we create one for
2250      temporary measures.  Check that nobody entered contents into it.  */
2251   asection *reg_section;
2252   asection **secpp;
2253
2254   reg_section = bfd_get_section_by_name (abfd, MMIX_REG_SECTION_NAME);
2255
2256   if (reg_section != NULL)
2257     {
2258       /* FIXME: Pass error state gracefully.  */
2259       if (bfd_get_section_flags (abfd, reg_section) & SEC_HAS_CONTENTS)
2260         _bfd_abort (__FILE__, __LINE__, _("Register section has contents\n"));
2261
2262       /* Really remove the section.  */
2263       for (secpp = &abfd->sections;
2264            *secpp != reg_section;
2265            secpp = &(*secpp)->next)
2266         ;
2267       bfd_section_list_remove (abfd, secpp);
2268       --abfd->section_count;
2269     }
2270
2271   if (! bfd_elf64_bfd_final_link (abfd, info))
2272     return FALSE;
2273
2274   /* Since this section is marked SEC_LINKER_CREATED, it isn't output by
2275      the regular linker machinery.  We do it here, like other targets with
2276      special sections.  */
2277   if (info->base_file != NULL)
2278     {
2279       asection *greg_section
2280         = bfd_get_section_by_name ((bfd *) info->base_file,
2281                                    MMIX_LD_ALLOCATED_REG_CONTENTS_SECTION_NAME);
2282       if (!bfd_set_section_contents (abfd,
2283                                      greg_section->output_section,
2284                                      greg_section->contents,
2285                                      (file_ptr) greg_section->output_offset,
2286                                      greg_section->_cooked_size))
2287         return FALSE;
2288     }
2289   return TRUE;
2290 }
2291
2292 /* We need to include the maximum size of PUSHJ-stubs in the initial
2293    section size.  This is expected to shrink during linker relaxation.
2294
2295    You might think that we should set *only* _cooked_size, but that won't
2296    work: section contents allocation will be using _raw_size in mixed
2297    format linking and not enough storage will be allocated.  FIXME: That's
2298    a major bug, including the name bfd_get_section_size_before_reloc; it
2299    should be bfd_get_section_size_before_relax.  The relaxation functions
2300    set _cooked size.  Relaxation happens before relocation.  All functions
2301    *after relaxation* should be using _cooked size.  */
2302
2303 static void
2304 mmix_set_relaxable_size (abfd, sec, ptr)
2305      bfd *abfd ATTRIBUTE_UNUSED;
2306      asection *sec;
2307      void *ptr;
2308 {
2309   struct bfd_link_info *info = ptr;
2310
2311   /* Make sure we only do this for section where we know we want this,
2312      otherwise we might end up resetting the size of COMMONs.  */
2313   if (mmix_elf_section_data (sec)->pjs.n_pushj_relocs == 0)
2314     return;
2315
2316   sec->_cooked_size
2317     = (sec->_raw_size
2318        + mmix_elf_section_data (sec)->pjs.n_pushj_relocs
2319        * MAX_PUSHJ_STUB_SIZE);
2320   sec->_raw_size = sec->_cooked_size;
2321
2322   /* For use in relocatable link, we start with a max stubs size.  See
2323      mmix_elf_relax_section.  */
2324   if (info->relocatable && sec->output_section)
2325     mmix_elf_section_data (sec->output_section)->pjs.stubs_size_sum
2326       += (mmix_elf_section_data (sec)->pjs.n_pushj_relocs
2327           * MAX_PUSHJ_STUB_SIZE);
2328 }
2329
2330 /* Initialize stuff for the linker-generated GREGs to match
2331    R_MMIX_BASE_PLUS_OFFSET relocs seen by the linker.  */
2332
2333 bfd_boolean
2334 _bfd_mmix_before_linker_allocation (abfd, info)
2335      bfd *abfd ATTRIBUTE_UNUSED;
2336      struct bfd_link_info *info;
2337 {
2338   asection *bpo_gregs_section;
2339   bfd *bpo_greg_owner;
2340   struct bpo_greg_section_info *gregdata;
2341   size_t n_gregs;
2342   bfd_vma gregs_size;
2343   size_t i;
2344   size_t *bpo_reloc_indexes;
2345   bfd *ibfd;
2346
2347   /* Set the initial size of sections.  */
2348   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2349     bfd_map_over_sections (ibfd, mmix_set_relaxable_size, info);
2350
2351   /* The bpo_greg_owner bfd is supposed to have been set by
2352      mmix_elf_check_relocs when the first R_MMIX_BASE_PLUS_OFFSET is seen.
2353      If there is no such object, there was no R_MMIX_BASE_PLUS_OFFSET.  */
2354   bpo_greg_owner = (bfd *) info->base_file;
2355   if (bpo_greg_owner == NULL)
2356     return TRUE;
2357
2358   bpo_gregs_section
2359     = bfd_get_section_by_name (bpo_greg_owner,
2360                                MMIX_LD_ALLOCATED_REG_CONTENTS_SECTION_NAME);
2361
2362   if (bpo_gregs_section == NULL)
2363     return TRUE;
2364
2365   /* We use the target-data handle in the ELF section data.  */
2366   gregdata = mmix_elf_section_data (bpo_gregs_section)->bpo.greg;
2367   if (gregdata == NULL)
2368     return FALSE;
2369
2370   n_gregs = gregdata->n_bpo_relocs;
2371   gregdata->n_allocated_bpo_gregs = n_gregs;
2372
2373   /* When this reaches zero during relaxation, all entries have been
2374      filled in and the size of the linker gregs can be calculated.  */
2375   gregdata->n_remaining_bpo_relocs_this_relaxation_round = n_gregs;
2376
2377   /* Set the zeroth-order estimate for the GREGs size.  */
2378   gregs_size = n_gregs * 8;
2379
2380   if (!bfd_set_section_size (bpo_greg_owner, bpo_gregs_section, gregs_size))
2381     return FALSE;
2382
2383   /* Allocate and set up the GREG arrays.  They're filled in at relaxation
2384      time.  Note that we must use the max number ever noted for the array,
2385      since the index numbers were created before GC.  */
2386   gregdata->reloc_request
2387     = bfd_zalloc (bpo_greg_owner,
2388                   sizeof (struct bpo_reloc_request)
2389                   * gregdata->n_max_bpo_relocs);
2390
2391   gregdata->bpo_reloc_indexes
2392     = bpo_reloc_indexes
2393     = bfd_alloc (bpo_greg_owner,
2394                  gregdata->n_max_bpo_relocs
2395                  * sizeof (size_t));
2396   if (bpo_reloc_indexes == NULL)
2397     return FALSE;
2398
2399   /* The default order is an identity mapping.  */
2400   for (i = 0; i < gregdata->n_max_bpo_relocs; i++)
2401     {
2402       bpo_reloc_indexes[i] = i;
2403       gregdata->reloc_request[i].bpo_reloc_no = i;
2404     }
2405
2406   return TRUE;
2407 }
2408 \f
2409 /* Fill in contents in the linker allocated gregs.  Everything is
2410    calculated at this point; we just move the contents into place here.  */
2411
2412 bfd_boolean
2413 _bfd_mmix_after_linker_allocation (abfd, link_info)
2414      bfd *abfd ATTRIBUTE_UNUSED;
2415      struct bfd_link_info *link_info;
2416 {
2417   asection *bpo_gregs_section;
2418   bfd *bpo_greg_owner;
2419   struct bpo_greg_section_info *gregdata;
2420   size_t n_gregs;
2421   size_t i, j;
2422   size_t lastreg;
2423   bfd_byte *contents;
2424
2425   /* The bpo_greg_owner bfd is supposed to have been set by mmix_elf_check_relocs
2426      when the first R_MMIX_BASE_PLUS_OFFSET is seen.  If there is no such
2427      object, there was no R_MMIX_BASE_PLUS_OFFSET.  */
2428   bpo_greg_owner = (bfd *) link_info->base_file;
2429   if (bpo_greg_owner == NULL)
2430     return TRUE;
2431
2432   bpo_gregs_section
2433     = bfd_get_section_by_name (bpo_greg_owner,
2434                                MMIX_LD_ALLOCATED_REG_CONTENTS_SECTION_NAME);
2435
2436   /* This can't happen without DSO handling.  When DSOs are handled
2437      without any R_MMIX_BASE_PLUS_OFFSET seen, there will be no such
2438      section.  */
2439   if (bpo_gregs_section == NULL)
2440     return TRUE;
2441
2442   /* We use the target-data handle in the ELF section data.  */
2443
2444   gregdata = mmix_elf_section_data (bpo_gregs_section)->bpo.greg;
2445   if (gregdata == NULL)
2446     return FALSE;
2447
2448   n_gregs = gregdata->n_allocated_bpo_gregs;
2449
2450   /* We need to have a _raw_size contents even though there's only
2451      _cooked_size worth of data, since the generic relocation machinery
2452      will allocate and copy that much temporarily.  */
2453   bpo_gregs_section->contents
2454     = contents = bfd_alloc (bpo_greg_owner, bpo_gregs_section->_raw_size);
2455   if (contents == NULL)
2456     return FALSE;
2457
2458   /* Sanity check: If these numbers mismatch, some relocation has not been
2459      accounted for and the rest of gregdata is probably inconsistent.
2460      It's a bug, but it's more helpful to identify it than segfaulting
2461      below.  */
2462   if (gregdata->n_remaining_bpo_relocs_this_relaxation_round
2463       != gregdata->n_bpo_relocs)
2464     {
2465       (*_bfd_error_handler)
2466         (_("Internal inconsistency: remaining %u != max %u.\n\
2467   Please report this bug."),
2468          gregdata->n_remaining_bpo_relocs_this_relaxation_round,
2469          gregdata->n_bpo_relocs);
2470       return FALSE;
2471     }
2472
2473   for (lastreg = 255, i = 0, j = 0; j < n_gregs; i++)
2474     if (gregdata->reloc_request[i].regindex != lastreg)
2475       {
2476         bfd_put_64 (bpo_greg_owner, gregdata->reloc_request[i].value,
2477                     contents + j * 8);
2478         lastreg = gregdata->reloc_request[i].regindex;
2479         j++;
2480       }
2481
2482   return TRUE;
2483 }
2484
2485 /* Sort valid relocs to come before non-valid relocs, then on increasing
2486    value.  */
2487
2488 static int
2489 bpo_reloc_request_sort_fn (p1, p2)
2490      const PTR p1;
2491      const PTR p2;
2492 {
2493   const struct bpo_reloc_request *r1 = (const struct bpo_reloc_request *) p1;
2494   const struct bpo_reloc_request *r2 = (const struct bpo_reloc_request *) p2;
2495
2496   /* Primary function is validity; non-valid relocs sorted after valid
2497      ones.  */
2498   if (r1->valid != r2->valid)
2499     return r2->valid - r1->valid;
2500
2501   /* Then sort on value.  Don't simplify and return just the difference of
2502      the values: the upper bits of the 64-bit value would be truncated on
2503      a host with 32-bit ints.  */
2504   if (r1->value != r2->value)
2505     return r1->value > r2->value ? 1 : -1;
2506
2507   /* As a last re-sort, use the relocation number, so we get a stable
2508      sort.  The *addresses* aren't stable since items are swapped during
2509      sorting.  It depends on the qsort implementation if this actually
2510      happens.  */
2511   return r1->bpo_reloc_no > r2->bpo_reloc_no
2512     ? 1 : (r1->bpo_reloc_no < r2->bpo_reloc_no ? -1 : 0);
2513 }
2514
2515 /* For debug use only.  Dumps the global register allocations resulting
2516    from base-plus-offset relocs.  */
2517
2518 void
2519 mmix_dump_bpo_gregs (link_info, pf)
2520      struct bfd_link_info *link_info;
2521      bfd_error_handler_type pf;
2522 {
2523   bfd *bpo_greg_owner;
2524   asection *bpo_gregs_section;
2525   struct bpo_greg_section_info *gregdata;
2526   unsigned int i;
2527
2528   if (link_info == NULL || link_info->base_file == NULL)
2529     return;
2530
2531   bpo_greg_owner = (bfd *) link_info->base_file;
2532
2533   bpo_gregs_section
2534     = bfd_get_section_by_name (bpo_greg_owner,
2535                                MMIX_LD_ALLOCATED_REG_CONTENTS_SECTION_NAME);
2536
2537   if (bpo_gregs_section == NULL)
2538     return;
2539
2540   gregdata = mmix_elf_section_data (bpo_gregs_section)->bpo.greg;
2541   if (gregdata == NULL)
2542     return;
2543
2544   if (pf == NULL)
2545     pf = _bfd_error_handler;
2546
2547   /* These format strings are not translated.  They are for debug purposes
2548      only and never displayed to an end user.  Should they escape, we
2549      surely want them in original.  */
2550   (*pf) (" n_bpo_relocs: %u\n n_max_bpo_relocs: %u\n n_remain...round: %u\n\
2551  n_allocated_bpo_gregs: %u\n", gregdata->n_bpo_relocs,
2552      gregdata->n_max_bpo_relocs,
2553      gregdata->n_remaining_bpo_relocs_this_relaxation_round,
2554      gregdata->n_allocated_bpo_gregs);
2555
2556   if (gregdata->reloc_request)
2557     for (i = 0; i < gregdata->n_max_bpo_relocs; i++)
2558       (*pf) ("%4u (%4u)/%4u#%u: 0x%08lx%08lx  r: %3u o: %3u\n",
2559              i,
2560              (gregdata->bpo_reloc_indexes != NULL
2561               ? gregdata->bpo_reloc_indexes[i] : (size_t) -1),
2562              gregdata->reloc_request[i].bpo_reloc_no,
2563              gregdata->reloc_request[i].valid,
2564
2565              (unsigned long) (gregdata->reloc_request[i].value >> 32),
2566              (unsigned long) gregdata->reloc_request[i].value,
2567              gregdata->reloc_request[i].regindex,
2568              gregdata->reloc_request[i].offset);
2569 }
2570
2571 /* This links all R_MMIX_BASE_PLUS_OFFSET relocs into a special array, and
2572    when the last such reloc is done, an index-array is sorted according to
2573    the values and iterated over to produce register numbers (indexed by 0
2574    from the first allocated register number) and offsets for use in real
2575    relocation.
2576
2577    PUSHJ stub accounting is also done here.
2578
2579    Symbol- and reloc-reading infrastructure copied from elf-m10200.c.  */
2580
2581 static bfd_boolean
2582 mmix_elf_relax_section (abfd, sec, link_info, again)
2583      bfd *abfd;
2584      asection *sec;
2585      struct bfd_link_info *link_info;
2586      bfd_boolean *again;
2587 {
2588   Elf_Internal_Shdr *symtab_hdr;
2589   Elf_Internal_Rela *internal_relocs;
2590   Elf_Internal_Rela *irel, *irelend;
2591   asection *bpo_gregs_section = NULL;
2592   struct bpo_greg_section_info *gregdata;
2593   struct bpo_reloc_section_info *bpodata
2594     = mmix_elf_section_data (sec)->bpo.reloc;
2595   /* The initialization is to quiet compiler warnings.  The value is to
2596      spot a missing actual initialization.  */
2597   size_t bpono = (size_t) -1;
2598   size_t pjsno = 0;
2599   bfd *bpo_greg_owner;
2600   Elf_Internal_Sym *isymbuf = NULL;
2601   bfd_size_type raw_size
2602     = (sec->_raw_size
2603        - mmix_elf_section_data (sec)->pjs.n_pushj_relocs
2604        * MAX_PUSHJ_STUB_SIZE);
2605
2606   mmix_elf_section_data (sec)->pjs.stubs_size_sum = 0;
2607
2608   /* Assume nothing changes.  */
2609   *again = FALSE;
2610
2611   /* If this is the first time we have been called for this section,
2612      initialize the cooked size.  */
2613   if (sec->_cooked_size == 0 && sec->_raw_size != 0)
2614     abort ();
2615
2616   /* We don't have to do anything if this section does not have relocs, or
2617      if this is not a code section.  */
2618   if ((sec->flags & SEC_RELOC) == 0
2619       || sec->reloc_count == 0
2620       || (sec->flags & SEC_CODE) == 0
2621       || (sec->flags & SEC_LINKER_CREATED) != 0
2622       /* If no R_MMIX_BASE_PLUS_OFFSET relocs and no PUSHJ-stub relocs,
2623          then nothing to do.  */
2624       || (bpodata == NULL
2625           && mmix_elf_section_data (sec)->pjs.n_pushj_relocs == 0))
2626     return TRUE;
2627
2628   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2629
2630   bpo_greg_owner = (bfd *) link_info->base_file;
2631
2632   if (bpodata != NULL)
2633     {
2634       bpo_gregs_section = bpodata->bpo_greg_section;
2635       gregdata = mmix_elf_section_data (bpo_gregs_section)->bpo.greg;
2636       bpono = bpodata->first_base_plus_offset_reloc;
2637     }
2638   else
2639     gregdata = NULL;
2640
2641   /* Get a copy of the native relocations.  */
2642   internal_relocs
2643     = _bfd_elf_link_read_relocs (abfd, sec, (PTR) NULL,
2644                                  (Elf_Internal_Rela *) NULL,
2645                                  link_info->keep_memory);
2646   if (internal_relocs == NULL)
2647     goto error_return;
2648
2649   /* Walk through them looking for relaxing opportunities.  */
2650   irelend = internal_relocs + sec->reloc_count;
2651   for (irel = internal_relocs; irel < irelend; irel++)
2652     {
2653       bfd_vma symval;
2654       struct elf_link_hash_entry *h = NULL;
2655
2656       /* We only process two relocs.  */
2657       if (ELF64_R_TYPE (irel->r_info) != (int) R_MMIX_BASE_PLUS_OFFSET
2658           && ELF64_R_TYPE (irel->r_info) != (int) R_MMIX_PUSHJ_STUBBABLE)
2659         continue;
2660
2661       /* We process relocs in a distinctly different way when this is a
2662          relocatable link (for one, we don't look at symbols), so we avoid
2663          mixing its code with that for the "normal" relaxation.  */
2664       if (link_info->relocatable)
2665         {
2666           /* The only transformation in a relocatable link is to generate
2667              a full stub at the location of the stub calculated for the
2668              input section, if the relocated stub location, the end of the
2669              output section plus earlier stubs, cannot be reached.  Thus
2670              relocatable linking can only lead to worse code, but it still
2671              works.  */
2672           if (ELF64_R_TYPE (irel->r_info) == R_MMIX_PUSHJ_STUBBABLE)
2673             {
2674               /* If we can reach the end of the output-section and beyond
2675                  any current stubs, then we don't need a stub for this
2676                  reloc.  The relaxed order of output stub allocation may
2677                  not exactly match the straightforward order, so we always
2678                  assume presence of output stubs, which will allow
2679                  relaxation only on relocations indifferent to the
2680                  presence of output stub allocations for other relocations
2681                  and thus the order of output stub allocation.  */
2682               if (bfd_check_overflow (complain_overflow_signed,
2683                                       19,
2684                                       0,
2685                                       bfd_arch_bits_per_address (abfd),
2686                                       /* Output-stub location.  */
2687                                       sec->output_section->_cooked_size
2688                                       + (mmix_elf_section_data (sec
2689                                                                ->output_section)
2690                                          ->pjs.stubs_size_sum)
2691                                       /* Location of this PUSHJ reloc.  */
2692                                       - (sec->output_offset + irel->r_offset)
2693                                       /* Don't count *this* stub twice.  */
2694                                       - (mmix_elf_section_data (sec)
2695                                          ->pjs.stub_size[pjsno]
2696                                          + MAX_PUSHJ_STUB_SIZE))
2697                   == bfd_reloc_ok)
2698                 mmix_elf_section_data (sec)->pjs.stub_size[pjsno] = 0;
2699
2700               mmix_elf_section_data (sec)->pjs.stubs_size_sum
2701                 += mmix_elf_section_data (sec)->pjs.stub_size[pjsno];
2702
2703               pjsno++;
2704             }
2705
2706           continue;
2707         }
2708
2709       /* Get the value of the symbol referred to by the reloc.  */
2710       if (ELF64_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2711         {
2712           /* A local symbol.  */
2713           Elf_Internal_Sym *isym;
2714           asection *sym_sec;
2715
2716           /* Read this BFD's local symbols if we haven't already.  */
2717           if (isymbuf == NULL)
2718             {
2719               isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2720               if (isymbuf == NULL)
2721                 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2722                                                 symtab_hdr->sh_info, 0,
2723                                                 NULL, NULL, NULL);
2724               if (isymbuf == 0)
2725                 goto error_return;
2726             }
2727
2728           isym = isymbuf + ELF64_R_SYM (irel->r_info);
2729           if (isym->st_shndx == SHN_UNDEF)
2730             sym_sec = bfd_und_section_ptr;
2731           else if (isym->st_shndx == SHN_ABS)
2732             sym_sec = bfd_abs_section_ptr;
2733           else if (isym->st_shndx == SHN_COMMON)
2734             sym_sec = bfd_com_section_ptr;
2735           else
2736             sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2737           symval = (isym->st_value
2738                     + sym_sec->output_section->vma
2739                     + sym_sec->output_offset);
2740         }
2741       else
2742         {
2743           unsigned long indx;
2744
2745           /* An external symbol.  */
2746           indx = ELF64_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2747           h = elf_sym_hashes (abfd)[indx];
2748           BFD_ASSERT (h != NULL);
2749           if (h->root.type != bfd_link_hash_defined
2750               && h->root.type != bfd_link_hash_defweak)
2751             {
2752               /* This appears to be a reference to an undefined symbol.  Just
2753                  ignore it--it will be caught by the regular reloc processing.
2754                  We need to keep BPO reloc accounting consistent, though
2755                  else we'll abort instead of emitting an error message.  */
2756               if (ELF64_R_TYPE (irel->r_info) == R_MMIX_BASE_PLUS_OFFSET
2757                   && gregdata != NULL)
2758                 {
2759                   gregdata->n_remaining_bpo_relocs_this_relaxation_round--;
2760                   bpono++;
2761                 }
2762               continue;
2763             }
2764
2765           symval = (h->root.u.def.value
2766                     + h->root.u.def.section->output_section->vma
2767                     + h->root.u.def.section->output_offset);
2768         }
2769
2770       if (ELF64_R_TYPE (irel->r_info) == (int) R_MMIX_PUSHJ_STUBBABLE)
2771         {
2772           bfd_vma value = symval + irel->r_addend;
2773           bfd_vma dot
2774             = (sec->output_section->vma
2775                + sec->output_offset
2776                + irel->r_offset);
2777           bfd_vma stubaddr
2778             = (sec->output_section->vma
2779                + sec->output_offset
2780                + raw_size
2781                + mmix_elf_section_data (sec)->pjs.stubs_size_sum);
2782
2783           if ((value & 3) == 0
2784               && bfd_check_overflow (complain_overflow_signed,
2785                                      19,
2786                                      0,
2787                                      bfd_arch_bits_per_address (abfd),
2788                                      value - dot
2789                                      - (value > dot
2790                                         ? mmix_elf_section_data (sec)
2791                                         ->pjs.stub_size[pjsno]
2792                                         : 0))
2793               == bfd_reloc_ok)
2794             /* If the reloc fits, no stub is needed.  */
2795             mmix_elf_section_data (sec)->pjs.stub_size[pjsno] = 0;
2796           else
2797             /* Maybe we can get away with just a JMP insn?  */
2798             if ((value & 3) == 0
2799                 && bfd_check_overflow (complain_overflow_signed,
2800                                        27,
2801                                        0,
2802                                        bfd_arch_bits_per_address (abfd),
2803                                        value - stubaddr
2804                                        - (value > dot
2805                                           ? mmix_elf_section_data (sec)
2806                                           ->pjs.stub_size[pjsno] - 4
2807                                           : 0))
2808                 == bfd_reloc_ok)
2809               /* Yep, account for a stub consisting of a single JMP insn.  */
2810               mmix_elf_section_data (sec)->pjs.stub_size[pjsno] = 4;
2811           else
2812             /* Nope, go for the full insn stub.  It doesn't seem useful to
2813                emit the intermediate sizes; those will only be useful for
2814                a >64M program assuming contiguous code.  */
2815             mmix_elf_section_data (sec)->pjs.stub_size[pjsno]
2816               = MAX_PUSHJ_STUB_SIZE;
2817
2818           mmix_elf_section_data (sec)->pjs.stubs_size_sum
2819             += mmix_elf_section_data (sec)->pjs.stub_size[pjsno];
2820           pjsno++;
2821           continue;
2822         }
2823
2824       /* We're looking at a R_MMIX_BASE_PLUS_OFFSET reloc.  */
2825
2826       gregdata->reloc_request[gregdata->bpo_reloc_indexes[bpono]].value
2827         = symval + irel->r_addend;
2828       gregdata->reloc_request[gregdata->bpo_reloc_indexes[bpono++]].valid = TRUE;
2829       gregdata->n_remaining_bpo_relocs_this_relaxation_round--;
2830     }
2831
2832   /* Check if that was the last BPO-reloc.  If so, sort the values and
2833      calculate how many registers we need to cover them.  Set the size of
2834      the linker gregs, and if the number of registers changed, indicate
2835      that we need to relax some more because we have more work to do.  */
2836   if (gregdata != NULL
2837       && gregdata->n_remaining_bpo_relocs_this_relaxation_round == 0)
2838     {
2839       size_t i;
2840       bfd_vma prev_base;
2841       size_t regindex;
2842
2843       /* First, reset the remaining relocs for the next round.  */
2844       gregdata->n_remaining_bpo_relocs_this_relaxation_round
2845         = gregdata->n_bpo_relocs;
2846
2847       qsort ((PTR) gregdata->reloc_request,
2848              gregdata->n_max_bpo_relocs,
2849              sizeof (struct bpo_reloc_request),
2850              bpo_reloc_request_sort_fn);
2851
2852       /* Recalculate indexes.  When we find a change (however unlikely
2853          after the initial iteration), we know we need to relax again,
2854          since items in the GREG-array are sorted by increasing value and
2855          stored in the relaxation phase.  */
2856       for (i = 0; i < gregdata->n_max_bpo_relocs; i++)
2857         if (gregdata->bpo_reloc_indexes[gregdata->reloc_request[i].bpo_reloc_no]
2858             != i)
2859           {
2860             gregdata->bpo_reloc_indexes[gregdata->reloc_request[i].bpo_reloc_no]
2861               = i;
2862             *again = TRUE;
2863           }
2864
2865       /* Allocate register numbers (indexing from 0).  Stop at the first
2866          non-valid reloc.  */
2867       for (i = 0, regindex = 0, prev_base = gregdata->reloc_request[0].value;
2868            i < gregdata->n_bpo_relocs;
2869            i++)
2870         {
2871           if (gregdata->reloc_request[i].value > prev_base + 255)
2872             {
2873               regindex++;
2874               prev_base = gregdata->reloc_request[i].value;
2875             }
2876           gregdata->reloc_request[i].regindex = regindex;
2877           gregdata->reloc_request[i].offset
2878             = gregdata->reloc_request[i].value - prev_base;
2879         }
2880
2881       /* If it's not the same as the last time, we need to relax again,
2882          because the size of the section has changed.  I'm not sure we
2883          actually need to do any adjustments since the shrinking happens
2884          at the start of this section, but better safe than sorry.  */
2885       if (gregdata->n_allocated_bpo_gregs != regindex + 1)
2886         {
2887           gregdata->n_allocated_bpo_gregs = regindex + 1;
2888           *again = TRUE;
2889         }
2890
2891       bpo_gregs_section->_cooked_size = (regindex + 1) * 8;
2892     }
2893
2894   if (isymbuf != NULL && (unsigned char *) isymbuf != symtab_hdr->contents)
2895     {
2896       if (! link_info->keep_memory)
2897         free (isymbuf);
2898       else
2899         {
2900           /* Cache the symbols for elf_link_input_bfd.  */
2901           symtab_hdr->contents = (unsigned char *) isymbuf;
2902         }
2903     }
2904
2905   if (internal_relocs != NULL
2906       && elf_section_data (sec)->relocs != internal_relocs)
2907     free (internal_relocs);
2908
2909   if (sec->_cooked_size
2910       < raw_size + mmix_elf_section_data (sec)->pjs.stubs_size_sum)
2911     abort ();
2912
2913   if (sec->_cooked_size
2914       > raw_size + mmix_elf_section_data (sec)->pjs.stubs_size_sum)
2915     {
2916       sec->_cooked_size
2917         = raw_size + mmix_elf_section_data (sec)->pjs.stubs_size_sum;
2918       *again = TRUE;
2919     }
2920
2921   return TRUE;
2922
2923  error_return:
2924   if (isymbuf != NULL && (unsigned char *) isymbuf != symtab_hdr->contents)
2925     free (isymbuf);
2926   if (internal_relocs != NULL
2927       && elf_section_data (sec)->relocs != internal_relocs)
2928     free (internal_relocs);
2929   return FALSE;
2930 }
2931
2932 /* Because we set _raw_size to include the max size of pushj stubs,
2933    i.e. larger than the actual section input size (see
2934    mmix_set_relaxable_raw_size), we have to take care of that when reading
2935    the section.  */
2936
2937 static bfd_boolean
2938 mmix_elf_get_section_contents (abfd, section, location, offset, count)
2939      bfd *abfd;
2940      sec_ptr section;
2941      void *location;
2942      file_ptr offset;
2943      bfd_size_type count;
2944 {
2945   bfd_size_type raw_size
2946     = (section->_raw_size
2947        - mmix_elf_section_data (section)->pjs.n_pushj_relocs
2948        * MAX_PUSHJ_STUB_SIZE);
2949
2950   if (offset + count > section->_raw_size)
2951     {
2952       abort();
2953       bfd_set_error (bfd_error_invalid_operation);
2954       return FALSE;
2955     }
2956
2957   /* Check bounds against the faked raw_size.  */
2958   if (offset + count > raw_size)
2959     {
2960       /* Clear the part in the faked area.  */
2961       memset (location + raw_size - offset, 0, count - (raw_size - offset));
2962
2963       /* If there's no initial part within the "real" contents, we're
2964          done.  */
2965       if ((bfd_size_type) offset >= raw_size)
2966         return TRUE;
2967
2968       /* Else adjust the count and fall through to call the generic
2969          function.  */
2970       count = raw_size - offset;
2971     }
2972
2973   return
2974     _bfd_generic_get_section_contents (abfd, section, location, offset,
2975                                        count);
2976 }
2977
2978 \f
2979 #define ELF_ARCH                bfd_arch_mmix
2980 #define ELF_MACHINE_CODE        EM_MMIX
2981
2982 /* According to mmix-doc page 36 (paragraph 45), this should be (1LL << 48LL).
2983    However, that's too much for something somewhere in the linker part of
2984    BFD; perhaps the start-address has to be a non-zero multiple of this
2985    number, or larger than this number.  The symptom is that the linker
2986    complains: "warning: allocated section `.text' not in segment".  We
2987    settle for 64k; the page-size used in examples is 8k.
2988    #define ELF_MAXPAGESIZE 0x10000
2989
2990    Unfortunately, this causes excessive padding in the supposedly small
2991    for-education programs that are the expected usage (where people would
2992    inspect output).  We stick to 256 bytes just to have *some* default
2993    alignment.  */
2994 #define ELF_MAXPAGESIZE 0x100
2995
2996 #define TARGET_BIG_SYM          bfd_elf64_mmix_vec
2997 #define TARGET_BIG_NAME         "elf64-mmix"
2998
2999 #define elf_info_to_howto_rel           NULL
3000 #define elf_info_to_howto               mmix_info_to_howto_rela
3001 #define elf_backend_relocate_section    mmix_elf_relocate_section
3002 #define elf_backend_gc_mark_hook        mmix_elf_gc_mark_hook
3003 #define elf_backend_gc_sweep_hook       mmix_elf_gc_sweep_hook
3004
3005 #define elf_backend_link_output_symbol_hook \
3006         mmix_elf_link_output_symbol_hook
3007 #define elf_backend_add_symbol_hook     mmix_elf_add_symbol_hook
3008
3009 #define elf_backend_check_relocs        mmix_elf_check_relocs
3010 #define elf_backend_symbol_processing   mmix_elf_symbol_processing
3011
3012 #define bfd_elf64_bfd_is_local_label_name \
3013         mmix_elf_is_local_label_name
3014
3015 #define elf_backend_may_use_rel_p       0
3016 #define elf_backend_may_use_rela_p      1
3017 #define elf_backend_default_use_rela_p  1
3018
3019 #define elf_backend_can_gc_sections     1
3020 #define elf_backend_section_from_bfd_section \
3021         mmix_elf_section_from_bfd_section
3022
3023 #define bfd_elf64_new_section_hook      mmix_elf_new_section_hook
3024 #define bfd_elf64_bfd_final_link        mmix_elf_final_link
3025 #define bfd_elf64_bfd_relax_section     mmix_elf_relax_section
3026 #define bfd_elf64_get_section_contents  mmix_elf_get_section_contents
3027
3028 #include "elf64-target.h"