Subversion Repositories openrisc

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

   Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009

   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://www-cs-faculty.stanford.edu/~knuth/programs/mmix.tar.gz}

        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://www-cs-faculty.stanford.edu/~knuth/mmix.html} 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://www-cs-faculty.stanford.edu/~knuth/mmixal-intro.ps.gz},

        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.

        @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 0x98

#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.  */

    bfd_boolean 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];

  };

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;

    bfd_boolean retval;

  };

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

struct mmo_find_sec_info

  {

    asection *sec;

    bfd_vma addr;

  };

static bfd_boolean 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 bfd_boolean mmo_mkobject (bfd *);

static bfd_boolean 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 INLINE bfd_byte *mmo_get_loc (asection *, bfd_vma, int);

static void mmo_xore_64 (asection *, bfd_vma vma, bfd_vma value);

static void mmo_xore_32 (asection *, bfd_vma vma, unsigned int);

static void mmo_xore_16 (asection *, bfd_vma vma, unsigned int);

static const bfd_target *mmo_object_p (bfd *);

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

static bfd_boolean mmo_get_symbols (bfd *);

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

                                      enum mmo_sym_type, unsigned int);

static bfd_boolean 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 bfd_boolean 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 bfd_boolean mmo_internal_write_header (bfd *);

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

static bfd_boolean 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 bfd_boolean 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 bfd_boolean mmo_write_chunk (bfd *, const bfd_byte *, unsigned int);

static bfd_boolean mmo_flush_chunk (bfd *);

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

                                        unsigned int, bfd_vma *);

static bfd_boolean mmo_write_chunk_list (bfd *, mmo_data_list_type *);

static bfd_boolean mmo_write_loc_chunk_list (bfd *, mmo_data_list_type *);

static bfd_boolean 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 bfd_boolean mmo_new_section_hook (bfd *, asection *);

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

static bfd_boolean mmo_write_object_contents (bfd *);

static bfd_boolean mmo_write_section_description (bfd *, asection *);

static bfd_boolean mmo_has_leading_or_trailing_zero_tetra_p (bfd *,

                                                             asection *);

/* Global "const" variables initialized once.  Must not depend on

   particular input or caller; put such things into the bfd or elsewhere.

   Look ma, no static per-invocation data!  */

static

char valid_mmo_symbol_character_set[/* A-Z a-z (we assume consecutive

                                       codes; sorry EBCDIC:ers!).  */

                                    + 'Z' - 'A' + 1 + 'z' - 'a' + 1

                                    /* Digits.  */

                                    + 10

                                    /* ':' and '_'.  */

                                    + 1 + 1

                                    /* Codes higher than 126.  */

                                    + 256 - 126

                                    /* Ending zero.  */

                                    + 1];

/* 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)

    {

      char *newsecname = strdup (secname);

      if (newsecname == NULL)

        {

          (*_bfd_error_handler)

            (_("%s: No core to allocate section name %s\n"),

             bfd_get_filename (abfd), secname);

          bfd_set_error (bfd_error_system_call);

          return NULL;

        }

      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 bfd_boolean inited = FALSE;

  int i = 0;

  int j = 0;

  static const char letters[]

    = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789:_";

  if (inited)

    return;

  inited = TRUE;

  /* Fill in the set of valid symbol characters.  */

  strcpy (valid_mmo_symbol_character_set, letters);

  i = strlen (letters);

  for (j = 126; j < 256; j++)

    valid_mmo_symbol_character_set[i++] = j;

}

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

static const bfd_target *

mmo_object_p (bfd *abfd)

{

  struct stat statbuf;

  bfd_byte b[4];

  mmo_init ();

  if (bfd_stat (abfd, &statbuf) < 0

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

      || bfd_bread (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, (file_ptr) statbuf.st_size - 4, SEEK_SET) != 0

      || bfd_bread (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_malloc (abfd->tdata.mmo_data->max_symbol_length + 1);

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

    {

      (*_bfd_error_handler)

        (_("%s: No core to allocate a symbol %d bytes long\n"),

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

      goto bad_final;

    }

  /* Read in everything.  */

  if (! mmo_scan (abfd))

    goto bad_format_free;

  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_free;

  return abfd->xvec;

 bad_format_free:

  free (abfd->tdata.mmo_data->lop_stab_symbol);

 bad_format:

  bfd_set_error (bfd_error_wrong_format);

 bad_final:

  return NULL;

}

/* Set up the mmo tdata information.  */

static bfd_boolean

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_zmalloc (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 bfd_boolean

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_get_section_vma (abfd, sec);

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

  if ((bfd_get_section_flags (abfd, 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_get_section_vma (abfd, sec);

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

  if ((bfd_get_section_flags (abfd, 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 (abfd, sec, vma);

      if (! bfd_set_section_flags (abfd, sec,

                                   bfd_get_section_flags (abfd, 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 (abfd, sec, vma);

      if (! bfd_set_section_flags (abfd, sec,

                                   bfd_get_section_flags (abfd, 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->user_set_vma)

    bfd_set_section_vma (abfd, sec, vma);

  if (! bfd_set_section_flags (abfd, sec,

                               bfd_get_section_flags (abfd, sec)

                               | SEC_LOAD | SEC_ALLOC))

    return NULL;

  return sec;

}

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

static INLINE void

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

{

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

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

  value ^= prev;

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

}

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

static INLINE void

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

{

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

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

  value ^= prev;

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

}