/* BFD back-end for mmo objects (MMIX-specific object-format).

   Copyright (C) 2001-2023 Free Software Foundation, Inc.

   Written by Hans-Peter Nilsson (hp@bitrange.com).

   Infrastructure and other bits originally copied from srec.c and

   binary.c.

   This file is part of BFD, the Binary File Descriptor library.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3 of the License, or

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,

   MA 02110-1301, USA.  */

/*

SECTION

  mmo backend

  The mmo object format is used exclusively together with Professor

  Donald E.@: Knuth's educational 64-bit processor MMIX.  The simulator

  @command{mmix} which is available at

  @url{http://mmix.cs.hm.edu/src/index.html}

  understands this format.  That package also includes a combined

  assembler and linker called @command{mmixal}.  The mmo format has

  no advantages feature-wise compared to e.g. ELF.  It is a simple

  non-relocatable object format with no support for archives or

  debugging information, except for symbol value information and

  line numbers (which is not yet implemented in BFD).  See

  @url{http://mmix.cs.hm.edu/} for more

  information about MMIX.  The ELF format is used for intermediate

  object files in the BFD implementation.

@c We want to xref the symbol table node.  A feature in "chew"

@c requires that "commands" do not contain spaces in the

@c arguments.  Hence the hyphen in "Symbol-table".

@menu

@* File layout::

@* Symbol-table::

@* mmo section mapping::

@end menu

INODE

File layout, Symbol-table, mmo, mmo

SUBSECTION

  File layout

  The mmo file contents is not partitioned into named sections as

  with e.g.@: ELF.  Memory areas is formed by specifying the

  location of the data that follows.  Only the memory area

  @samp{0x0000@dots{}00} to @samp{0x01ff@dots{}ff} is executable, so

  it is used for code (and constants) and the area

  @samp{0x2000@dots{}00} to @samp{0x20ff@dots{}ff} is used for

  writable data.  @xref{mmo section mapping}.

  There is provision for specifying ``special data'' of 65536

  different types.  We use type 80 (decimal), arbitrarily chosen the

  same as the ELF <<e_machine>> number for MMIX, filling it with

  section information normally found in ELF objects. @xref{mmo

  section mapping}.

  Contents is entered as 32-bit words, xor:ed over previous

  contents, always zero-initialized.  A word that starts with the

  byte @samp{0x98} forms a command called a @samp{lopcode}, where

  the next byte distinguished between the thirteen lopcodes.  The

  two remaining bytes, called the @samp{Y} and @samp{Z} fields, or

  the @samp{YZ} field (a 16-bit big-endian number), are used for

  various purposes different for each lopcode.  As documented in

  @url{http://mmix.cs.hm.edu/doc/mmixal.pdf},

  the lopcodes are:

  @table @code

  @item lop_quote

  0x98000001.  The next word is contents, regardless of whether it

  starts with 0x98 or not.

  @item lop_loc

  0x9801YYZZ, where @samp{Z} is 1 or 2.  This is a location

  directive, setting the location for the next data to the next

  32-bit word (for @math{Z = 1}) or 64-bit word (for @math{Z = 2}),

  plus @math{Y * 2^56}.  Normally @samp{Y} is 0 for the text segment

  and 2 for the data segment.  Beware that the low bits of non-

  tetrabyte-aligned values are silently discarded when being

  automatically incremented and when storing contents (in contrast

  to e.g. its use as current location when followed by lop_fixo

  et al before the next possibly-quoted tetrabyte contents).

  @item lop_skip

  0x9802YYZZ.  Increase the current location by @samp{YZ} bytes.

  @item lop_fixo

  0x9803YYZZ, where @samp{Z} is 1 or 2.  Store the current location

  as 64 bits into the location pointed to by the next 32-bit

  (@math{Z = 1}) or 64-bit (@math{Z = 2}) word, plus @math{Y *

  2^56}.

  @item lop_fixr

  0x9804YYZZ.  @samp{YZ} is stored into the current location plus

  @math{2 - 4 * YZ}.

  @item lop_fixrx

  0x980500ZZ.  @samp{Z} is 16 or 24.  A value @samp{L} derived from

  the following 32-bit word are used in a manner similar to

  @samp{YZ} in lop_fixr: it is xor:ed into the current location

  minus @math{4 * L}.  The first byte of the word is 0 or 1.  If it

  is 1, then @math{L = (@var{lowest 24 bits of word}) - 2^Z}, if 0,

  then @math{L = (@var{lowest 24 bits of word})}.

  @item lop_file

  0x9806YYZZ.  @samp{Y} is the file number, @samp{Z} is count of

  32-bit words.  Set the file number to @samp{Y} and the line

  counter to 0.  The next @math{Z * 4} bytes contain the file name,

  padded with zeros if the count is not a multiple of four.  The

  same @samp{Y} may occur multiple times, but @samp{Z} must be 0 for

  all but the first occurrence.

  @item lop_line

  0x9807YYZZ.  @samp{YZ} is the line number.  Together with

  lop_file, it forms the source location for the next 32-bit word.

  Note that for each non-lopcode 32-bit word, line numbers are

  assumed incremented by one.

  @item lop_spec

  0x9808YYZZ.  @samp{YZ} is the type number.  Data until the next

  lopcode other than lop_quote forms special data of type @samp{YZ}.

  @xref{mmo section mapping}.

  Other types than 80, (or type 80 with a content that does not

  parse) is stored in sections named <<.MMIX.spec_data.@var{n}>>

  where @var{n} is the @samp{YZ}-type.  The flags for such a

  sections say not to allocate or load the data.  The vma is 0.

  Contents of multiple occurrences of special data @var{n} is

  concatenated to the data of the previous lop_spec @var{n}s.  The

  location in data or code at which the lop_spec occurred is lost.

  @item lop_pre

  0x980901ZZ.  The first lopcode in a file.  The @samp{Z} field forms the

  length of header information in 32-bit words, where the first word

  tells the time in seconds since @samp{00:00:00 GMT Jan 1 1970}.

  @item lop_post

  0x980a00ZZ.  @math{Z > 32}.  This lopcode follows after all

  content-generating lopcodes in a program.  The @samp{Z} field

  denotes the value of @samp{rG} at the beginning of the program.

  The following @math{256 - Z} big-endian 64-bit words are loaded

  into global registers @samp{$G} @dots{} @samp{$255}.

  @item lop_stab

  0x980b0000.  The next-to-last lopcode in a program.  Must follow

  immediately after the lop_post lopcode and its data.  After this

  lopcode follows all symbols in a compressed format

  (@pxref{Symbol-table}).

  @item lop_end

  0x980cYYZZ.  The last lopcode in a program.  It must follow the

  lop_stab lopcode and its data.  The @samp{YZ} field contains the

  number of 32-bit words of symbol table information after the

  preceding lop_stab lopcode.

  @end table

  Note that the lopcode "fixups"; <<lop_fixr>>, <<lop_fixrx>> and

  <<lop_fixo>> are not generated by BFD, but are handled.  They are

  generated by <<mmixal>>.

EXAMPLE

  This trivial one-label, one-instruction file:

| :Main TRAP 1,2,3

  can be represented this way in mmo:

| 0x98090101 - lop_pre, one 32-bit word with timestamp.

| <timestamp>

| 0x98010002 - lop_loc, text segment, using a 64-bit address.

|              Note that mmixal does not emit this for the file above.

| 0x00000000 - Address, high 32 bits.

| 0x00000000 - Address, low 32 bits.

| 0x98060002 - lop_file, 2 32-bit words for file-name.

| 0x74657374 - "test"

| 0x2e730000 - ".s\0\0"

| 0x98070001 - lop_line, line 1.

| 0x00010203 - TRAP 1,2,3

| 0x980a00ff - lop_post, setting $255 to 0.

| 0x00000000

| 0x00000000

| 0x980b0000 - lop_stab for ":Main" = 0, serial 1.

| 0x203a4040   @xref{Symbol-table}.

| 0x10404020

| 0x4d206120

| 0x69016e00

| 0x81000000

| 0x980c0005 - lop_end; symbol table contained five 32-bit words.  */

#include "sysdep.h"

#include "bfd.h"

#include "libbfd.h"

#include "libiberty.h"

#include "elf/mmix.h"

#include "opcode/mmix.h"

#define LOP 0x98u

#define LOP_QUOTE 0

#define LOP_LOC 1

#define LOP_SKIP 2

#define LOP_FIXO 3

#define LOP_FIXR 4

#define LOP_FIXRX 5

#define LOP_FILE 6

#define LOP_LINE 7

#define LOP_SPEC 8

#define LOP_PRE 9

#define LOP_POST 10

#define LOP_STAB 11

#define LOP_END 12

#define LOP_QUOTE_NEXT ((LOP << 24) | (LOP_QUOTE << 16) | 1)

#define SPEC_DATA_SECTION 80

#define LOP_SPEC_SECTION \

 ((LOP << 24) | (LOP_SPEC << 16) | SPEC_DATA_SECTION)

/* Must be a power of two.  If you change this to be >= 64k, you need a

   new test-case; the ld test b-loc64k.d touches chunk-size problem areas.  */

#define MMO_SEC_CONTENTS_CHUNK_SIZE (1 << 15)

/* An arbitrary number for the maximum length section name size.  */

#define MAX_SECTION_NAME_SIZE (1024 * 1024)

/* A quite arbitrary number for the maximum length section size.  */

#define MAX_ARTIFICIAL_SECTION_SIZE (1024 * 1024 * 1024)

#define MMO3_WCHAR 0x80

#define MMO3_LEFT 0x40

#define MMO3_MIDDLE 0x20

#define MMO3_RIGHT 0x10

#define MMO3_TYPEBITS 0xf

#define MMO3_REGQUAL_BITS 0xf

#define MMO3_UNDEF 2

#define MMO3_DATA 8

#define MMO3_SYMBITS 0x2f

/* Put these everywhere in new code.  */

#define FATAL_DEBUG           \

 _bfd_abort (__FILE__, __LINE__,        \

       "Internal: Non-debugged code (test-case missing)")

#define BAD_CASE(x)       \

 _bfd_abort (__FILE__, __LINE__,    \

       "bad case for " #x)

enum mmo_sym_type { mmo_reg_sym, mmo_undef_sym, mmo_data_sym, mmo_abs_sym};

/* When scanning the mmo file, a linked list of mmo_symbol

   structures is built to represent the symbol table (if there is

   one).  */

struct mmo_symbol

  {

    struct mmo_symbol *next;

    char *name;

    bfd_vma value;

    enum mmo_sym_type sym_type;

    unsigned int serno;

  };

struct mmo_data_list_struct

  {

    struct mmo_data_list_struct *next;

    bfd_vma where;

    bfd_size_type size;

    bfd_size_type allocated_size;

    bfd_byte data[1];

  };

typedef struct mmo_data_list_struct mmo_data_list_type;

struct mmo_symbol_trie

  {

    struct mmo_symbol_trie *left;

    struct mmo_symbol_trie *right;

    struct mmo_symbol_trie *middle;

    bfd_byte symchar;

    /* A zero name means there's nothing here.  */

    struct mmo_symbol sym;

  };

/* The mmo tdata information.  */

struct mmo_data_struct

  {

    struct mmo_symbol *symbols;

    struct mmo_symbol *symtail;

    asymbol *csymbols;

    /* File representation of time (NULL) when this file was created.  */

    bfd_byte created[4];

    /* When we're reading bytes recursively, check this occasionally.

       Also holds write errors.  */

    bool have_error;

    /* Max symbol length that may appear in the lop_stab table.  Note that

       this table might just hold a subset of symbols for not-really large

       programs, as it can only be 65536 * 4 bytes large.  */

    int max_symbol_length;

    /* Here's the symbol we build in lop_stab.  */

    char *lop_stab_symbol;

    /* Index into lop_stab_symbol for the next character when parsing the

       symbol information.  */

    int symbol_position;

    /* When creating arbitrary sections, we need to count section numbers.  */

    int sec_no;

    /* When writing or reading byte-wise, we need to count the bytes

       within a 32-bit word.  */

    int byte_no;

    /* We also need a buffer to hold the bytes we count reading or writing.  */

    bfd_byte buf[4];

    /* Whether we've calculated symbol consistency requirement yet.  We do this

       when-needed, which must be at some time after all section

       contents is known.  */

    bool symbol_consistency_override_calculated;

    /* Whether to consistency-check symbol values, in particular "Main".  */

    bool ignore_symbol_consistency;

  };

typedef struct mmo_data_struct tdata_type;

struct mmo_section_data_struct

  {

    mmo_data_list_type *head;

    mmo_data_list_type *tail;

  };

#define mmo_section_data(sec) \

  ((struct mmo_section_data_struct *) (sec)->used_by_bfd)

/* These structures are used in bfd_map_over_sections constructs.  */

/* Used when writing out sections; all but the register contents section

   which is stored in reg_section.  */

struct mmo_write_sec_info

  {

    asection *reg_section;

    bool retval;

  };

/* Used when trying to find a section corresponding to addr.  */

struct mmo_find_sec_info

  {

    asection *sec;

    bfd_vma addr;

  };

static bool mmo_bfd_copy_private_bfd_data (bfd *, bfd *);

static void mmo_write_section_unless_reg_contents (bfd *, asection *, void *);

static void mmo_find_sec_w_addr (bfd *, asection *, void *);

static void mmo_find_sec_w_addr_grow (bfd *, asection *, void *);

static asection *mmo_make_section (bfd *, const char *);

static void mmo_get_symbol_info (bfd *, asymbol *, symbol_info *);

static void mmo_print_symbol (bfd *, void *, asymbol *,

            bfd_print_symbol_type);

static void mmo_init (void);

static bool mmo_mkobject (bfd *);

static bool mmo_scan (bfd *);

static asection *mmo_decide_section (bfd *, bfd_vma);

static asection *mmo_get_generic_spec_data_section (bfd *, int);

static asection *mmo_get_spec_section (bfd *, int);

static bfd_byte *mmo_get_loc (asection *, bfd_vma, unsigned int);

static bfd_cleanup mmo_object_p (bfd *);

static void mmo_map_set_sizes (bfd *, asection *, void *);

static bool mmo_get_symbols (bfd *);

static bool mmo_create_symbol (bfd *, const char *, bfd_vma,

             enum mmo_sym_type, unsigned int);

static bool mmo_get_section_contents (bfd *, asection *, void *,

              file_ptr, bfd_size_type);

static long mmo_get_symtab_upper_bound (bfd *);

static long mmo_canonicalize_symtab (bfd *, asymbol **);

static void mmo_get_symbol_info (bfd *, asymbol *, symbol_info *);

static void mmo_print_symbol (bfd *, void *, asymbol *,

            bfd_print_symbol_type);

static bool mmo_set_section_contents (bfd *, sec_ptr, const void *,

              file_ptr, bfd_size_type);

static int mmo_sizeof_headers (bfd *, struct bfd_link_info *);

static bool mmo_internal_write_header (bfd *);

static bool mmo_internal_write_post (bfd *, int, asection *);

static bool mmo_internal_add_3_sym (bfd *, struct mmo_symbol_trie *,

             const struct mmo_symbol *);

static unsigned int mmo_internal_3_length (bfd *, struct mmo_symbol_trie *);

static void mmo_internal_3_dump (bfd *, struct mmo_symbol_trie *);

static void mmo_beb128_out (bfd *, int, int);

static bool mmo_internal_write_section (bfd *, asection *);

static void mmo_write_tetra (bfd *, unsigned int);

static void mmo_write_tetra_raw (bfd *, unsigned int);

static void mmo_write_octa (bfd *, bfd_vma);

static void mmo_write_octa_raw (bfd *, bfd_vma);

static bool mmo_write_chunk (bfd *, const bfd_byte *, unsigned int);

static bool mmo_flush_chunk (bfd *);

static bool mmo_write_loc_chunk (bfd *, bfd_vma, const bfd_byte *,

         unsigned int, bfd_vma *);

static bool mmo_write_chunk_list (bfd *, mmo_data_list_type *);

static bool mmo_write_loc_chunk_list (bfd *, mmo_data_list_type *);

static bool mmo_write_symbols_and_terminator (bfd *);

static flagword mmo_sec_flags_from_bfd_flags (flagword);

static flagword bfd_sec_flags_from_mmo_flags (flagword);

static bfd_byte mmo_get_byte (bfd *);

static void mmo_write_byte (bfd *, bfd_byte);

static bool mmo_new_section_hook (bfd *, asection *);

static int mmo_sort_mmo_symbols (const void *, const void *);

static bool mmo_write_object_contents (bfd *);

static bool mmo_write_section_description (bfd *, asection *);

static bool mmo_has_leading_or_trailing_zero_tetra_p (bfd *, asection *);

static const char

valid_mmo_symbol_character_set[] =

{

  'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',

  'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',

  'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',

  'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',

  '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',

  ':', '_', 126, 127, 128, 129,

  130, 131, 132, 133, 134, 135, 136, 137, 138, 139,

  140, 141, 142, 143, 144, 145, 146, 147, 148, 149,

  150, 151, 152, 153, 154, 155, 156, 157, 158, 159,

  160, 161, 162, 163, 164, 165, 166, 167, 168, 169,

  170, 171, 172, 173, 174, 175, 176, 177, 178, 179,

  180, 181, 182, 183, 184, 185, 186, 187, 188, 189,

  190, 191, 192, 193, 194, 195, 196, 197, 198, 199,

  200, 201, 202, 203, 204, 205, 206, 207, 208, 209,

  210, 211, 212, 213, 214, 215, 216, 217, 218, 219,

  220, 221, 222, 223, 224, 225, 226, 227, 228, 229,

  230, 231, 232, 233, 234, 235, 236, 237, 238, 239,

  240, 241, 242, 243, 244, 245, 246, 247, 248, 249,

  250, 251, 252, 253, 254, 255,

  0

};

/* Get section SECNAME or create one if it doesn't exist.  When creating

   one, new memory for the name is allocated.  */

static asection *

mmo_make_section (bfd *abfd, const char *secname)

{

  asection *sec = bfd_get_section_by_name (abfd, secname);

  if (sec == NULL)

    {

      size_t len = strlen (secname) + 1;

      char *newsecname = bfd_alloc (abfd, len);

      if (newsecname == NULL)

  {

    bfd_set_error (bfd_error_no_memory);

    return NULL;

  }

      memcpy (newsecname, secname, len);

      sec = bfd_make_section (abfd, newsecname);

    }

  return sec;

}

/* Nothing to do, but keep as a placeholder if we need it.

   Note that state that might differ between bfd:s must not be initialized

   here, nor must it be static.  Add it to tdata information instead.  */

static void

mmo_init (void)

{

  static bool inited = false;

  if (inited)

    return;

  inited = true;

}

/* Check whether an existing file is an mmo file.  */

static bfd_cleanup

mmo_object_p (bfd *abfd)

{

  struct stat statbuf;

  bfd_byte b[4];

  mmo_init ();

  if (bfd_stat (abfd, &statbuf) < 0

      || bfd_seek (abfd, 0, SEEK_SET) != 0

      || bfd_read (b, 4, abfd) != 4)

    goto bad_final;

  /* All mmo files are a multiple of four bytes long.

     Only recognize version one.  */

  if ((statbuf.st_size % 4) != 0

      || b[0] != LOP || b[1] != LOP_PRE || b[2] != 1)

    goto bad_format;

  /* Get the last 32-bit word.  */

  if (bfd_seek (abfd, statbuf.st_size - 4, SEEK_SET) != 0

      || bfd_read (b, 4, abfd) != 4)

    goto bad_final;

  /* Check if the file ends in a lop_end lopcode. */

  if (b[0] != LOP || b[1] != LOP_END || ! mmo_mkobject (abfd))

    goto bad_format;

  /* Compute an upper bound on the max symbol length.  Not really

     important as all of the symbol information can only be 256k.  */

  abfd->tdata.mmo_data->max_symbol_length = (b[2] * 256 + b[3]) * 4;

  abfd->tdata.mmo_data->lop_stab_symbol

    = bfd_alloc (abfd, abfd->tdata.mmo_data->max_symbol_length + 1);

  if (abfd->tdata.mmo_data->lop_stab_symbol == NULL)

    {

      _bfd_error_handler

  /* xgettext:c-format */

  (_("%pB: no core to allocate a symbol %d bytes long"),

   abfd, abfd->tdata.mmo_data->max_symbol_length);

      goto bad_final;

    }

  /* Read in everything.  */

  if (! mmo_scan (abfd))

    goto bad_format;

  if (abfd->symcount > 0)

    abfd->flags |= HAS_SYMS;

  /* You'll have to tweak this if you want to use this format for other

     arches (not recommended due to its small-size limitations).  Look at

     the ELF format for how to make it target-generic.  */

  if (! bfd_default_set_arch_mach (abfd, bfd_arch_mmix, 0))

    goto bad_format;

  return _bfd_no_cleanup;

 bad_format:

  bfd_set_error (bfd_error_wrong_format);

 bad_final:

  return NULL;

}

/* Set up the mmo tdata information.  */

static bool

mmo_mkobject (bfd *abfd)

{

  mmo_init ();

  if (abfd->tdata.mmo_data == NULL)

    {

      time_t created;

      /* All fields are zero-initialized, so we don't have to explicitly

   initialize most.  */

      tdata_type *tdata = (tdata_type *) bfd_zalloc (abfd, sizeof (tdata_type));

      if (tdata == NULL)

  return false;

      created = time (NULL);

      bfd_put_32 (abfd, created, tdata->created);

      abfd->tdata.mmo_data = tdata;

    }

  return true;

}

static bool

mmo_section_has_contents (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *p ATTRIBUTE_UNUSED)

{

  /* The point is to match what --extract-symbols does (well, negated).  */

  return bfd_section_size (sec) != 0;

}

/* Find out whether we should omit symbol consistency checks for this

   bfd and cache the value.

   This function must only be called when all section contents is

   known.  However, calculating symbol consistency at the time the

   private BFD data is initialized is too late for some uses.  */

static bool

mmo_ignore_symbol_consistency (bfd *abfd)

{

  if (!abfd->tdata.mmo_data->symbol_consistency_override_calculated)

    {

      abfd->tdata.mmo_data->ignore_symbol_consistency =

  bfd_sections_find_if (abfd, mmo_section_has_contents, NULL) == NULL;

      abfd->tdata.mmo_data->symbol_consistency_override_calculated = true;

    }

  return abfd->tdata.mmo_data->ignore_symbol_consistency;

}

static bool

mmo_bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd)

{

  if (bfd_get_flavour (ibfd) != bfd_target_mmo_flavour

      || bfd_get_flavour (obfd) != bfd_target_mmo_flavour)

    return true;

  /* Copy the time the copied-from file was created.  If people want the

     time the file was last *modified*, they have that in the normal file

     information.  */

  memcpy (obfd->tdata.mmo_data->created, ibfd->tdata.mmo_data->created,

    sizeof (obfd->tdata.mmo_data->created));

  return true;

}

/* Helper functions for mmo_decide_section, used through

   bfd_map_over_sections.  */

static void

mmo_find_sec_w_addr (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *p)

{

  struct mmo_find_sec_info *infop = (struct mmo_find_sec_info *) p;

  bfd_vma vma = bfd_section_vma (sec);

  /* Ignore sections that aren't loaded.  */

  if ((bfd_section_flags (sec) & (SEC_LOAD | SEC_ALLOC))

      !=  (SEC_LOAD | SEC_ALLOC))

    return;

  if (infop->addr >= vma && infop->addr < vma + sec->size)

    infop->sec = sec;

}

static void

mmo_find_sec_w_addr_grow (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *p)

{

  struct mmo_find_sec_info *infop = (struct mmo_find_sec_info *) p;

  bfd_vma vma = bfd_section_vma (sec);

  /* Ignore sections that aren't loaded.  */

  if ((bfd_section_flags (sec) & (SEC_LOAD | SEC_ALLOC))

      !=  (SEC_LOAD | SEC_ALLOC))

    return;

  if (infop->addr >= vma && infop->addr < vma + MAX_ARTIFICIAL_SECTION_SIZE)

    infop->sec = sec;

}

/* Find a section that corresponds to a VMA.  Automatically create .text

   or .data and set current section to it, depending on what vma.  If we

   can't deduce a section, make one up as ".MMIX.sec.N", where N is an

   increasing number.  */

static asection *

mmo_decide_section (bfd *abfd, bfd_vma vma)

{

  asection *sec = NULL;

  char sec_name[sizeof (".MMIX.sec.") + 20];

  struct mmo_find_sec_info info;

  info.addr = vma;

  info.sec = NULL;

  /* First see if there's a section that would match exactly.  */

  bfd_map_over_sections (abfd, mmo_find_sec_w_addr, &info);

  if (info.sec != NULL)

    return info.sec;

  /* If there's no such section, try and expand one of the existing ones,

     up to a limit.  Make sure we have .text and .data before we try that;

     create them corresponding to expected addresses and set flags to make

     them match the "loaded and with contents" expectation.  */

  if ((vma >> 56) == 0)

    {

      sec = bfd_make_section_old_way (abfd, MMO_TEXT_SECTION_NAME);

      if (sec == NULL)

  return NULL;

      if (!sec->user_set_vma && !bfd_set_section_vma (sec, vma))

  return NULL;

      if (!bfd_set_section_flags (sec, (bfd_section_flags (sec)

          | SEC_CODE | SEC_LOAD | SEC_ALLOC)))

  return NULL;

    }

  else if ((vma >> 56) == 0x20)

    {

      sec = bfd_make_section_old_way (abfd, MMO_DATA_SECTION_NAME);

      if (sec == NULL)

  return NULL;

      if (!sec->user_set_vma && !bfd_set_section_vma (sec, vma))

  return NULL;

      if (!bfd_set_section_flags (sec, (bfd_section_flags (sec)

          | SEC_LOAD | SEC_ALLOC)))

  return NULL;

    }

  bfd_map_over_sections (abfd, mmo_find_sec_w_addr_grow, &info);

  if (info.sec != NULL)

    return info.sec;

  /* If there's still no suitable section, make a new one.  */

  sprintf (sec_name, ".MMIX.sec.%d", abfd->tdata.mmo_data->sec_no++);

  sec = mmo_make_section (abfd, sec_name);

  if (!sec || (!sec->user_set_vma && !bfd_set_section_vma (sec, vma)))

    return NULL;

  if (!bfd_set_section_flags (sec, (bfd_section_flags (sec)

            | SEC_LOAD | SEC_ALLOC)))

    return NULL;

  return sec;

}

/* Xor in a 64-bit value VALUE at VMA.  */

static inline bfd_byte *

mmo_xore_64 (asection *sec, bfd_vma vma, bfd_vma value)

{

  bfd_byte *loc = mmo_get_loc (sec, vma, 8);

  if (loc)

    {

      bfd_vma prev = bfd_get_64 (sec->owner, loc);

      value ^= prev;

      bfd_put_64 (sec->owner, value, loc);

    }

  return loc;

}

/* Xor in a 32-bit value VALUE at VMA.  */

static inline bfd_byte *

mmo_xore_32 (asection *sec, bfd_vma vma, unsigned int value)

{

  bfd_byte *loc = mmo_get_loc (sec, vma, 4);

  if (loc)

    {

      unsigned int prev = bfd_get_32 (sec->owner, loc);

      value ^= prev;

      bfd_put_32 (sec->owner, value, loc);

    }

  return loc;

}

/* Xor in a 16-bit value VALUE at VMA.  */

static inline bfd_byte *

mmo_xore_16 (asection *sec, bfd_vma vma, unsigned int value)

{

  bfd_byte *loc = mmo_get_loc (sec, vma, 2);

  if (loc)

    {

      unsigned int prev = bfd_get_16 (sec->owner, loc);

      value ^= prev;

      bfd_put_16 (sec->owner, value, loc);

    }

  return loc;

}

/* Write a 32-bit word to output file, no lop_quote generated.  */

static inline void

mmo_write_tetra_raw (bfd *abfd, unsigned int value)

{

  bfd_byte buf[4];

  bfd_put_32 (abfd, value, buf);

  if (bfd_write (buf, 4, abfd) != 4)

    abfd->tdata.mmo_data->have_error = true;

}

/* Write a 32-bit word to output file; lop_quote if necessary.  */

static inline void

mmo_write_tetra (bfd *abfd, unsigned int value)

{

  if (((value >> 24) & 0xff) == LOP)

    mmo_write_tetra_raw (abfd, LOP_QUOTE_NEXT);

  mmo_write_tetra_raw (abfd, value);

}

/* Write a 64-bit word to output file, perhaps with lop_quoting.  */

static inline void

mmo_write_octa (bfd *abfd, bfd_vma value)

{

  mmo_write_tetra (abfd, (unsigned int) (value >> 32));

  mmo_write_tetra (abfd, (unsigned int) value);

}

/* Write a 64-bit word to output file, without lop_quoting.  */

static inline void

mmo_write_octa_raw (bfd *abfd, bfd_vma value)

{

  mmo_write_tetra_raw (abfd, (unsigned int) (value >> 32));

  mmo_write_tetra_raw (abfd, (unsigned int) value);

}

/* Write quoted contents.  Intended to be called multiple times in

   sequence, followed by a call to mmo_flush_chunk.  */

static inline bool

mmo_write_chunk (bfd *abfd, const bfd_byte *loc, unsigned int len)

{

  bool retval = true;

  struct mmo_data_struct *mmop = abfd->tdata.mmo_data;

  /* Fill up a tetra from bytes remaining from a previous chunk.  */

  if (mmop->byte_no != 0)

    {

      while (mmop->byte_no < 4 && len != 0)

  {

    mmop->buf[mmop->byte_no++] = *loc++;

    len--;

  }

      if (mmop->byte_no == 4)

  {

    mmo_write_tetra (abfd, bfd_get_32 (abfd, mmop->buf));

    mmop->byte_no = 0;

  }

    }

  while (len >= 4)

    {

      if (loc[0] == LOP)

  mmo_write_tetra_raw (abfd, LOP_QUOTE_NEXT);

      retval = (retval

    && ! mmop->have_error

    && 4 == bfd_write (loc, 4, abfd));

      loc += 4;

      len -= 4;

    }

  if (len)

    {

      /* We must have flushed a previous remainder if we get one from

   this chunk too.  */

      BFD_ASSERT (mmop->byte_no == 0);

      memcpy (mmop->buf, loc, len);

      mmop->byte_no = len;

    }

  if (! retval)

    mmop->have_error = true;

  return retval;

}

/* Flush remaining bytes, from a previous mmo_write_chunk, zero-padded to

   4 bytes.  */

static inline bool

mmo_flush_chunk (bfd *abfd)

{

  if (abfd->tdata.mmo_data->byte_no != 0)

    {

      memset (abfd->tdata.mmo_data->buf + abfd->tdata.mmo_data->byte_no,

        0, 4 - abfd->tdata.mmo_data->byte_no);

      mmo_write_tetra (abfd,

           bfd_get_32 (abfd, abfd->tdata.mmo_data->buf));

      abfd->tdata.mmo_data->byte_no = 0;

    }

  return ! abfd->tdata.mmo_data->have_error;

}

/* Same, but from a list.  */

static inline bool

mmo_write_chunk_list (bfd *abfd, mmo_data_list_type *datap)

{

  for (; datap != NULL; datap = datap->next)

    if (! mmo_write_chunk (abfd, datap->data, datap->size))

      return false;

  return mmo_flush_chunk (abfd);

}

/* Write a lop_loc and some contents.  A caller needs to call

   mmo_flush_chunk after calling this function.  The location is only

   output if different than *LAST_VMAP, which is updated after this call.  */

static bool

mmo_write_loc_chunk (bfd *abfd, bfd_vma vma, const bfd_byte *loc,

         unsigned int len, bfd_vma *last_vmap)

{

  /* Find an initial and trailing section of zero (aligned) tetras; we don't

     need to write out zeros.  FIXME: When we do this, we should emit

     section size and address specifiers, else objcopy can't always perform

     an identity translation.  Only do this if we *don't* have left-over

     data from a previous write (and will not add any) or else the vma of

     this chunk is *not* the next address, because then data isn't

     tetrabyte-aligned and we're concatenating to that left-over data.  */

  if ((vma & 3) == 0

      && (abfd->tdata.mmo_data->byte_no == 0 || vma != *last_vmap))

    {

      while (len > 4 && bfd_get_32 (abfd, loc) == 0)

  {

    vma += 4;

    len -= 4;

    loc += 4;

  }

      if ((len & 3) == 0)

  while (len > 4 && bfd_get_32 (abfd, loc + len - 4) == 0)

    len -= 4;

    }

  /* Only write out the location if it's different than the one the caller

     (supposedly) previously handled, accounting for omitted leading zeros.  */

  if (vma != *last_vmap)

    {

      /* We might be in the middle of a sequence.  */

      mmo_flush_chunk (abfd);

      /* This should not happen during normal usage, but can presumably

   happen with an erroneous linker-script, so handle gracefully.

   Avoid Knuth-specific terms in the message, such as "tetrabyte".

   Note that this function will get non-4-multiple lengths and

   unaligned vmas but those come in tuples (mostly pairs) and are

   continuous (i.e. the if-condition above false) and they are

   group-wise aligned.  */

      if ((vma & 3) != 0)

  {

    _bfd_error_handler

      /* xgettext:c-format */

      (_("%pB: attempt to emit contents at non-multiple-of-4"

         " address %#" PRIx64 ""),

       abfd, (uint64_t) vma);

    bfd_set_error (bfd_error_bad_value);

    return false;

  }

      /* We always write the location as 64 bits; no use saving bytes

   here.  */

      mmo_write_tetra_raw (abfd, (LOP << 24) | (LOP_LOC << 16) | 2);

      mmo_write_octa_raw (abfd, vma);

    }

  /* Update to reflect end of this chunk, with trailing zeros omitted.  */

  *last_vmap = vma + len;

  return (! abfd->tdata.mmo_data->have_error

    && mmo_write_chunk (abfd, loc, len));

}

/* Same, but from a list.  */

static inline bool

mmo_write_loc_chunk_list (bfd *abfd, mmo_data_list_type *datap)

{

  /* Get an address different than the address of the first chunk.  */

  bfd_vma last_vma = datap ? datap->where - 1 : 0;

  for (; datap != NULL; datap = datap->next)

    if (! mmo_write_loc_chunk (abfd, datap->where, datap->data, datap->size,

             &last_vma))

      return false;

  return mmo_flush_chunk (abfd);

}

/* Make a .MMIX.spec_data.N section.  */

static asection *

mmo_get_generic_spec_data_section (bfd *abfd, int spec_data_number)

{

  asection *sec;

  char secname[sizeof (MMIX_OTHER_SPEC_SECTION_PREFIX) + 20]

    = MMIX_OTHER_SPEC_SECTION_PREFIX;

  sprintf (secname + strlen (MMIX_OTHER_SPEC_SECTION_PREFIX),

     "%d", spec_data_number);

  sec = mmo_make_section (abfd, secname);

  return sec;

}

/* Make a special section for SPEC_DATA_NUMBER.  If it is the one we use

   ourselves, parse some of its data to get at the section name.  */

static asection *

mmo_get_spec_section (bfd *abfd, int spec_data_number)

{

  char *secname;

  asection *sec;

  bfd_byte buf[4];

  unsigned int secname_length;

  unsigned int i;

  bfd_vma section_length;

  bfd_vma section_vma;

  mmo_data_list_type *loc;

  flagword flags;

  long orig_pos;

  /* If this isn't the "special" special data, then make a placeholder

     section.  */

  if (spec_data_number != SPEC_DATA_SECTION)

    return mmo_get_generic_spec_data_section (abfd, spec_data_number);

  /* Seek back to this position if there was a format error.  */

  orig_pos = bfd_tell (abfd);

  /* Read the length (in 32-bit words).  */

  if (bfd_read (buf, 4, abfd) != 4)

    goto format_error;

  if (buf[0] == LOP)

    {

      if (buf[1] != LOP_QUOTE)

  goto format_error;

      if (bfd_read (buf, 4, abfd) != 4)

  goto format_error;

    }

  /* We don't care to keep the name length accurate.  It's

     zero-terminated.  */

  secname_length = bfd_get_32 (abfd, buf) * 4;

  /* Check section name length for sanity.  */

  if (secname_length > MAX_SECTION_NAME_SIZE)

    goto format_error;

  /* This should be free'd regardless if a section is created.  */

  secname = bfd_malloc (secname_length + 1);

  secname[secname_length] = 0;

  for (i = 0; i < secname_length / 4; i++)

    {

      if (bfd_read (secname + i * 4, 4, abfd) != 4)

  goto format_error_free;

      if (secname[i * 4] == (char) LOP)

  {

    /* A bit of overkill, but we handle char 0x98 in a section name,

       and recognize misparsing.  */

    if (secname[i * 4 + 1] != LOP_QUOTE

        || bfd_read (secname + i * 4, 4, abfd) != 4)

      /* Whoops.  We thought this was a name, and now we found a

         non-lop_quote lopcode before we parsed the whole length of

         the name.  Signal end-of-file in the same manner.  */