aboutsummaryrefslogtreecommitdiff
path: root/bfd/mmo.c
diff options
context:
space:
mode:
authorNick Clifton <nickc@redhat.com>2001-10-30 15:20:14 +0000
committerNick Clifton <nickc@redhat.com>2001-10-30 15:20:14 +0000
commit3c3bdf30e42268e6193693acd1dc66d2d1792536 (patch)
tree8f6b2752d885c3e71d0bef5717e981faac396928 /bfd/mmo.c
parentf5ffc9190a633d0f8eb1632a64a28eda75206b55 (diff)
downloadgdb-3c3bdf30e42268e6193693acd1dc66d2d1792536.zip
gdb-3c3bdf30e42268e6193693acd1dc66d2d1792536.tar.gz
gdb-3c3bdf30e42268e6193693acd1dc66d2d1792536.tar.bz2
Add MMIX support
Diffstat (limited to 'bfd/mmo.c')
-rw-r--r--bfd/mmo.c3274
1 files changed, 3274 insertions, 0 deletions
diff --git a/bfd/mmo.c b/bfd/mmo.c
new file mode 100644
index 0000000..8bb5095
--- /dev/null
+++ b/bfd/mmo.c
@@ -0,0 +1,3274 @@
+/* BFD back-end for mmo objects (MMIX-specific object-format).
+ Copyright 2001
+ 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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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
+ @emph{mmix} which is available at
+ @emph{http://www-cs-faculty.stanford.edu/~knuth/programs/mmix.tar.gz}
+ understands this format. That package also includes a combined
+ assembler and linker called @emph{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
+ @emph{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}.
+
+ 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
+ @emph{http://www-cs-faculty.stanford.edu/~knuth/mmixal-intro.ps.gz},
+ the lopcodes are:
+
+ 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}.
+
+ @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 "bfd.h"
+#include "sysdep.h"
+#include "libbfd.h"
+#include "libiberty.h"
+#include "elf/mmix.h"
+#include "opcode/mmix.h"
+#include <ctype.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;
+ CONST 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. */
+ 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;
+ };
+
+/* 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;
+ boolean retval;
+ };
+
+/* Used when trying to find a section corresponding to addr. */
+struct mmo_find_sec_info
+ {
+ asection *sec;
+ bfd_vma addr;
+ };
+
+static boolean mmo_bfd_copy_private_bfd_data PARAMS ((bfd *, bfd *));
+static void mmo_write_section_unless_reg_contents
+ PARAMS ((bfd *, asection *, PTR));
+static void mmo_find_sec_w_addr PARAMS ((bfd *, asection *, PTR));
+static void mmo_find_sec_w_addr_grow PARAMS ((bfd *, asection *, PTR));
+static asection *mmo_make_section PARAMS ((bfd *, CONST char *));
+static void mmo_get_symbol_info PARAMS ((bfd *, asymbol *, symbol_info *));
+static void mmo_print_symbol
+ PARAMS ((bfd *, PTR, asymbol *, bfd_print_symbol_type));
+static void mmo_init PARAMS ((void));
+static boolean mmo_mkobject PARAMS ((bfd *));
+static boolean mmo_scan PARAMS ((bfd *));
+static asection *mmo_decide_section PARAMS ((bfd *, bfd_vma));
+static asection *mmo_get_generic_spec_data_section PARAMS ((bfd *, int));
+static asection *mmo_get_spec_section PARAMS ((bfd *, int));
+static INLINE bfd_byte *mmo_get_loc PARAMS ((asection *, bfd_vma, int));
+static void mmo_xore_64 PARAMS ((asection *, bfd_vma vma, bfd_vma value));
+static void mmo_xore_32 PARAMS ((asection *, bfd_vma vma, unsigned int));
+static void mmo_xore_16 PARAMS ((asection *, bfd_vma vma, unsigned int));
+static CONST bfd_target *mmo_object_p PARAMS ((bfd *));
+static void mmo_map_set_sizes PARAMS ((bfd *, asection *, PTR));
+static boolean mmo_get_symbols PARAMS ((bfd *));
+static boolean mmo_create_symbol PARAMS ((bfd *, CONST char *, bfd_vma,
+ enum mmo_sym_type, unsigned int));
+static boolean mmo_get_section_contents
+ PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type));
+static long mmo_get_symtab_upper_bound PARAMS ((bfd *));
+static long mmo_get_symtab PARAMS ((bfd *, asymbol **));
+static asymbol *mmo_make_empty_symbol PARAMS ((bfd *));
+static void mmo_get_symbol_info PARAMS ((bfd *, asymbol *, symbol_info *));
+static void mmo_print_symbol PARAMS ((bfd *, PTR, asymbol *,
+ bfd_print_symbol_type));
+static boolean mmo_set_section_contents
+ PARAMS ((bfd *, sec_ptr, PTR, file_ptr, bfd_size_type));
+static int mmo_sizeof_headers PARAMS ((bfd *, boolean));
+static long mmo_get_reloc_upper_bound PARAMS ((bfd *, asection *));
+
+static boolean mmo_internal_write_header PARAMS ((bfd *));
+static boolean mmo_internal_write_post PARAMS ((bfd *, int, asection *));
+static boolean mmo_internal_add_3_sym
+ PARAMS ((bfd *, struct mmo_symbol_trie *, CONST struct mmo_symbol *));
+static unsigned int mmo_internal_3_length
+ PARAMS ((bfd *, struct mmo_symbol_trie *));
+static void mmo_internal_3_dump
+ PARAMS ((bfd *, struct mmo_symbol_trie *));
+static void mmo_beb128_out PARAMS ((bfd *, int, int));
+static boolean mmo_internal_write_section
+ PARAMS ((bfd *, asection *));
+static void mmo_write_tetra PARAMS ((bfd *, unsigned int));
+static void mmo_write_tetra_raw PARAMS ((bfd *, unsigned int));
+static void mmo_write_octa PARAMS ((bfd *, bfd_vma));
+static void mmo_write_octa_raw PARAMS ((bfd *, bfd_vma));
+static boolean mmo_write_chunk
+ PARAMS ((bfd *, CONST bfd_byte *, unsigned int));
+static boolean mmo_write_loc_chunk
+ PARAMS ((bfd *, bfd_vma, CONST bfd_byte *, unsigned int));
+static boolean mmo_write_chunk_list PARAMS ((bfd *, mmo_data_list_type *));
+static boolean mmo_write_loc_chunk_list
+ PARAMS ((bfd *, mmo_data_list_type *));
+static boolean mmo_write_symbols_and_terminator PARAMS ((bfd *));
+static flagword mmo_sec_flags_from_bfd_flags PARAMS ((flagword));
+static flagword bfd_sec_flags_from_mmo_flags PARAMS ((flagword));
+static bfd_byte mmo_get_byte PARAMS ((bfd *));
+static void mmo_write_byte PARAMS ((bfd *, bfd_byte));
+static boolean mmo_new_section_hook PARAMS ((bfd *, asection *));
+static int mmo_sort_mmo_symbols PARAMS ((CONST PTR, CONST PTR));
+static boolean mmo_write_object_contents PARAMS ((bfd *));
+static long mmo_canonicalize_reloc
+ PARAMS ((bfd *, sec_ptr, arelent **, asymbol **));
+
+/* 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 unsigned
+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 (abfd, secname)
+ 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 ()
+{
+ static boolean inited = false;
+ int i = 0;
+ int j = 0;
+ static const char letters[]
+ = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789:_";
+
+ if (inited == false)
+ {
+ 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 (abfd)
+ 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 boolean
+mmo_mkobject (abfd)
+ 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 boolean
+mmo_bfd_copy_private_bfd_data (ibfd, obfd)
+ 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 (abfd, sec, p)
+ bfd *abfd ATTRIBUTE_UNUSED;
+ asection *sec;
+ PTR 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->_raw_size)
+ infop->sec = sec;
+}
+
+static void
+mmo_find_sec_w_addr_grow (abfd, sec, p)
+ bfd *abfd ATTRIBUTE_UNUSED;
+ asection *sec;
+ PTR 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 (abfd, vma)
+ 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 (sec, vma, value)
+ 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 (sec, vma, value)
+ 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);
+}
+
+/* Xor in a 16-bit value VALUE at VMA. */
+
+static INLINE void
+mmo_xore_16 (sec, vma, value)
+ asection *sec;
+ bfd_vma vma;
+ unsigned int value;
+{
+ bfd_byte *loc = mmo_get_loc (sec, vma, 2);
+ unsigned int prev = bfd_get_16 (sec->owner, loc);
+
+ value ^= prev;
+ bfd_put_16 (sec->owner, value, loc);
+}
+
+/* Write a 32-bit word to output file, no lop_quote generated. */
+
+static INLINE void
+mmo_write_tetra_raw (abfd, value)
+ bfd *abfd;
+ unsigned int value;
+{
+ bfd_byte buf[4];
+
+ bfd_put_32 (abfd, value, buf);
+
+ if (bfd_bwrite ((PTR) 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 (abfd, value)
+ 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 (abfd, value)
+ 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 (abfd, value)
+ 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, zero filled. */
+
+static INLINE boolean
+mmo_write_chunk (abfd, loc, len)
+ bfd *abfd;
+ CONST bfd_byte *loc;
+ unsigned int len;
+{
+ boolean retval = true;
+ bfd_byte buf[4] = {0, 0, 0, 0};
+
+ while (len >= 4)
+ {
+ if (loc[0] == LOP)
+ mmo_write_tetra_raw (abfd, LOP_QUOTE_NEXT);
+
+ retval
+ = (retval == true
+ && abfd->tdata.mmo_data->have_error == false
+ && 4 == bfd_bwrite ((PTR) loc, 4, abfd));
+
+ loc += 4;
+ len -= 4;
+ }
+
+ if (len)
+ {
+ memcpy (buf, loc, len);
+ if (buf[0] == LOP)
+ mmo_write_tetra_raw (abfd, LOP_QUOTE_NEXT);
+
+ retval
+ = (retval == true
+ && abfd->tdata.mmo_data->have_error == false
+ && 4 == bfd_bwrite ((PTR) buf, 4, abfd));
+ }
+
+ return retval;
+}
+
+/* Same, but from a list. */
+
+static INLINE boolean
+mmo_write_chunk_list (abfd, datap)
+ 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 true;
+}
+
+/* Write a lop_loc and some contents. */
+
+static boolean
+mmo_write_loc_chunk (abfd, vma, loc, len)
+ bfd *abfd;
+ bfd_vma vma;
+ CONST bfd_byte *loc;
+ unsigned int len;
+{
+ /* We always write the location as 64 bits; no use saving bytes here. */
+ mmo_write_tetra_raw (abfd, (LOP << 24) | (LOP_LOC << 16) | 2);
+
+ /* Find an initial and trailing section of zero 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 perform a unity
+ translation. */
+ while (len >= 4 && bfd_get_32 (abfd, loc) == 0)
+ {
+ vma += 4;
+ len -= 4;
+ loc += 4;
+ }
+
+ while (len >= 4 && bfd_get_32 (abfd, loc + len - 4) == 0)
+ len -= 4;
+
+ mmo_write_octa_raw (abfd, vma);
+ return
+ abfd->tdata.mmo_data->have_error == false
+ && mmo_write_chunk (abfd, loc, len);
+}
+
+/* Same, but from a list. */
+
+static INLINE boolean
+mmo_write_loc_chunk_list (abfd, datap)
+ bfd *abfd;
+ mmo_data_list_type *datap;
+{
+ for (; datap != NULL; datap = datap->next)
+ if (! mmo_write_loc_chunk (abfd, datap->where, datap->data, datap->size))
+ return false;
+
+ return true;
+}
+
+/* Make a .MMIX.spec_data.N section. */
+
+static asection *
+mmo_get_generic_spec_data_section (abfd, spec_data_number)
+ 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 (abfd, spec_data_number)
+ bfd *abfd;
+ int spec_data_number;
+{
+ bfd_byte *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_bread (buf, 4, abfd) != 4)
+ goto format_error;
+
+ if (buf[0] == LOP)
+ {
+ if (buf[1] != LOP_QUOTE)
+ goto format_error;
+
+ if (bfd_bread (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_bread (secname + i * 4, 4, abfd) != 4)
+ goto format_error_free;
+
+ if (secname[i * 4] == 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_bread (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. */
+ goto format_error_free;
+ }
+ }
+
+ /* Get the section flags. */
+ if (bfd_bread (buf, 4, abfd) != 4
+ || (buf[0] == LOP
+ && (buf[1] != LOP_QUOTE || bfd_bread (buf, 4, abfd) != 4)))
+ goto format_error_free;
+
+ flags = bfd_get_32 (abfd, buf);
+
+ /* Get the section length. */
+ if (bfd_bread (buf, 4, abfd) != 4
+ || (buf[0] == LOP
+ && (buf[1] != LOP_QUOTE || bfd_bread (buf, 4, abfd) != 4)))
+ goto format_error_free;
+
+ section_length = (bfd_vma) bfd_get_32 (abfd, buf) << 32;
+
+ /* That's the first, high-part. Now get the low part. */
+
+ if (bfd_bread (buf, 4, abfd) != 4
+ || (buf[0] == LOP
+ && (buf[1] != LOP_QUOTE || bfd_bread (buf, 4, abfd) != 4)))
+ goto format_error_free;
+
+ section_length |= (bfd_vma) bfd_get_32 (abfd, buf);
+
+ /* Check the section length for sanity. */
+ if (section_length > MAX_ARTIFICIAL_SECTION_SIZE)
+ goto format_error_free;
+
+ /* Get the section VMA. */
+ if (bfd_bread (buf, 4, abfd) != 4
+ || (buf[0] == LOP
+ && (buf[1] != LOP_QUOTE || bfd_bread (buf, 4, abfd) != 4)))
+ goto format_error_free;
+
+ section_vma = (bfd_vma) bfd_get_32 (abfd, buf) << 32;
+
+ /* That's the first, high-part. Now get the low part. */
+ if (bfd_bread (buf, 4, abfd) != 4
+ || (buf[0] == LOP
+ && (buf[1] != LOP_QUOTE || bfd_bread (buf, 4, abfd) != 4)))
+ goto format_error_free;
+
+ section_vma |= (bfd_vma) bfd_get_32 (abfd, buf);
+
+ sec = mmo_make_section (abfd, secname);
+ free (secname);
+ if (sec == NULL)
+ goto format_error;
+
+ /* We allocate a buffer here for the advertised size, with head room for
+ tetrabyte alignment. */
+ loc = bfd_zmalloc (section_length + 3
+ + sizeof (struct mmo_data_list_struct));
+ if (loc == NULL)
+ goto format_error;
+
+ /* Use a TETRA-rounded size for the allocated buffer; we set the
+ "visible" section size below. */
+ loc->size = (section_length + 3) & ~3;
+
+ /* Add in the section flags we found to those bfd entered during this
+ process and set the contents. */
+ if (! bfd_set_section_flags (abfd, sec,
+ bfd_sec_flags_from_mmo_flags (flags)
+ | bfd_get_section_flags (abfd, sec)
+ | (section_length != 0 ? SEC_HAS_CONTENTS : 0))
+ || ! bfd_set_section_size (abfd, sec,
+ sec->_cooked_size + section_length)
+ /* Set VMA only for the first occurrence. */
+ || (! sec->user_set_vma
+ && ! bfd_set_section_vma (abfd, sec, section_vma)))
+ {
+ /* If we get an error for any of the calls above, signal more than
+ just a format error for the spec section. */
+ return NULL;
+ }
+
+ loc->next = NULL;
+ if (((struct mmo_section_data_struct *) (sec->used_by_bfd))->tail != NULL)
+ ((struct mmo_section_data_struct *) (sec->used_by_bfd))->tail->next
+ = loc;
+ else
+ ((struct mmo_section_data_struct *) (sec->used_by_bfd))->head = loc;
+ ((struct mmo_section_data_struct *) (sec->used_by_bfd))->tail = loc;
+ loc->where = section_vma;
+
+ return sec;
+
+ format_error_free:
+ free (secname);
+ format_error:
+ if (bfd_seek (abfd, orig_pos, SEEK_SET) != 0)
+ return NULL;
+
+ return mmo_get_generic_spec_data_section (abfd, spec_data_number);
+}
+
+/* Read a byte, but read from file in multiples of 32-bit words. */
+
+static bfd_byte
+mmo_get_byte (abfd)
+ bfd *abfd;
+{
+ bfd_byte retval;
+
+ if (abfd->tdata.mmo_data->byte_no == 0)
+ {
+ if (abfd->tdata.mmo_data->have_error == false
+ && bfd_bread (abfd->tdata.mmo_data->buf, 4, abfd) != 4)
+ {
+ abfd->tdata.mmo_data->have_error = true;
+
+ /* A value somewhat safe against tripping on some inconsistency
+ when mopping up after this error. */
+ return 128;
+ }
+ }
+
+ retval = abfd->tdata.mmo_data->buf[abfd->tdata.mmo_data->byte_no];
+ abfd->tdata.mmo_data->byte_no = (abfd->tdata.mmo_data->byte_no + 1) % 4;
+
+ return retval;
+}
+
+/* Write a byte, in multiples of 32-bit words. */
+
+static void
+mmo_write_byte (abfd, value)
+ bfd *abfd;
+ bfd_byte value;
+{
+ abfd->tdata.mmo_data->buf[(abfd->tdata.mmo_data->byte_no++ % 4)] = value;
+ if ((abfd->tdata.mmo_data->byte_no % 4) == 0)
+ {
+ if (abfd->tdata.mmo_data->have_error == false
+ && bfd_bwrite (abfd->tdata.mmo_data->buf, 4, abfd) != 4)
+ abfd->tdata.mmo_data->have_error = true;
+ }
+}
+
+/* Create a symbol. */
+
+static boolean
+mmo_create_symbol (abfd, symname, addr, sym_type, serno)
+ bfd *abfd;
+ CONST char *symname;
+ bfd_vma addr;
+ enum mmo_sym_type sym_type;
+ unsigned int serno;
+{
+ struct mmo_symbol *n;
+
+ n = (struct mmo_symbol *) bfd_alloc (abfd, sizeof (struct mmo_symbol));
+ if (n == NULL)
+ return false;
+
+ n->name = bfd_alloc (abfd, strlen (symname) + 1);
+ if (n->name == NULL)
+ return false;
+
+ strcpy ((PTR) n->name, symname);
+
+ n->value = addr;
+ n->sym_type = sym_type;
+ n->serno = serno;
+
+ if (abfd->tdata.mmo_data->symbols == NULL)
+ abfd->tdata.mmo_data->symbols = n;
+ else
+ abfd->tdata.mmo_data->symtail->next = n;
+ abfd->tdata.mmo_data->symtail = n;
+ n->next = NULL;
+
+ ++abfd->symcount;
+
+ /* Check that :Main equals the last octa of the .MMIX.reg_contents
+ section, as it's the one place we're sure to pass when reading a mmo
+ object. For written objects, we do it while setting the symbol
+ table. */
+ if (strcmp (symname, MMIX_START_SYMBOL_NAME) == 0
+ && bfd_get_start_address (abfd) != addr)
+ {
+ (*_bfd_error_handler)
+ (_("%s: invalid mmo file: initialization value for $255 is not `Main'\n"),
+ bfd_get_filename (abfd));
+ bfd_set_error (bfd_error_bad_value);
+ return false;
+ }
+
+ return true;
+}
+
+/* Read in symbols. */
+
+static boolean
+mmo_get_symbols (abfd)
+ bfd *abfd;
+{
+/*
+INODE
+Symbol-table, mmo section mapping, File layout, mmo
+SUBSECTION
+ Symbol table format
+
+ From mmixal.w (or really, the generated mmixal.tex) in
+ @emph{http://www-cs-faculty.stanford.edu/~knuth/programs/mmix.tar.gz}):
+ ``Symbols are stored and retrieved by means of a @samp{ternary
+ search trie}, following ideas of Bentley and Sedgewick. (See
+ ACM--SIAM Symp.@: on Discrete Algorithms @samp{8} (1997), 360--369;
+ R.@:Sedgewick, @samp{Algorithms in C} (Reading, Mass.@:
+ Addison--Wesley, 1998), @samp{15.4}.) Each trie node stores a
+ character, and there are branches to subtries for the cases where
+ a given character is less than, equal to, or greater than the
+ character in the trie. There also is a pointer to a symbol table
+ entry if a symbol ends at the current node.''
+
+ So it's a tree encoded as a stream of bytes. The stream of bytes
+ acts on a single virtual global symbol, adding and removing
+ characters and signalling complete symbol points. Here, we read
+ the stream and create symbols at the completion points.
+
+ First, there's a control byte <<m>>. If any of the listed bits
+ in <<m>> is nonzero, we execute what stands at the right, in
+ the listed order:
+
+| (MMO3_LEFT)
+| 0x40 - Traverse left trie.
+| (Read a new command byte and recurse.)
+|
+| (MMO3_SYMBITS)
+| 0x2f - Read the next byte as a character and store it in the
+| current character position; increment character position.
+| Test the bits of <<m>>:
+|
+| (MMO3_WCHAR)
+| 0x80 - The character is 16-bit (so read another byte,
+| merge into current character.
+|
+| (MMO3_TYPEBITS)
+| 0xf - We have a complete symbol; parse the type, value
+| and serial number and do what should be done
+| with a symbol. The type and length information
+| is in j = (m & 0xf).
+|
+| (MMO3_REGQUAL_BITS)
+| j == 0xf: A register variable. The following
+| byte tells which register.
+| j <= 8: An absolute symbol. Read j bytes as the
+| big-endian number the symbol equals.
+| A j = 2 with two zero bytes denotes an
+| unknown symbol.
+| j > 8: As with j <= 8, but add (0x20 << 56)
+| to the value in the following j - 8
+| bytes.
+|
+| Then comes the serial number, as a variant of
+| uleb128, but better named ubeb128:
+| Read bytes and shift the previous value left 7
+| (multiply by 128). Add in the new byte, repeat
+| until a byte has bit 7 set. The serial number
+| is the computed value minus 128.
+|
+| (MMO3_MIDDLE)
+| 0x20 - Traverse middle trie. (Read a new command byte
+| and recurse.) Decrement character position.
+|
+| (MMO3_RIGHT)
+| 0x10 - Traverse right trie. (Read a new command byte and
+| recurse.)
+
+ Let's look again at the <<lop_stab>> for the trivial file
+ (@pxref{File layout}).
+
+| 0x980b0000 - lop_stab for ":Main" = 0, serial 1.
+| 0x203a4040
+| 0x10404020
+| 0x4d206120
+| 0x69016e00
+| 0x81000000
+
+ This forms the trivial trie (note that the path between ``:'' and
+ ``M'' is redundant):
+
+| 203a ":"
+| 40 /
+| 40 /
+| 10 \
+| 40 /
+| 40 /
+| 204d "M"
+| 2061 "a"
+| 2069 "i"
+| 016e "n" is the last character in a full symbol, and
+| with a value represented in one byte.
+| 00 The value is 0.
+| 81 The serial number is 1. */
+
+ bfd_byte m = mmo_get_byte (abfd);
+
+ /* Check first if we have a bad hair day. */
+ if (abfd->tdata.mmo_data->have_error == true)
+ return false;
+
+ if (m & MMO3_LEFT)
+ /* Traverse left trie. */
+ mmo_get_symbols (abfd);
+
+ if (m & MMO3_SYMBITS)
+ {
+ bfd_byte c = mmo_get_byte (abfd);
+ bfd_byte j = m & MMO3_TYPEBITS;
+ bfd_vma addr = 0;
+ enum mmo_sym_type sym_type;
+ unsigned int serno = 0;
+ bfd_byte k;
+
+ if (m & MMO3_WCHAR)
+ {
+ bfd_byte c2 = mmo_get_byte (abfd);
+
+ /* A two-byte character. We can't grok this, but neither can
+ mmotype, for other cases than the second byte being zero. */
+
+ if (c != 0)
+ {
+ abfd->tdata.mmo_data->lop_stab_symbol
+ [abfd->tdata.mmo_data->symbol_position] = 0;
+
+ (*_bfd_error_handler)
+ (_("%s: unsupported wide character sequence\
+ 0x%02X 0x%02X after symbol name starting with `%s'\n"),
+ bfd_get_filename (abfd), c, c2,
+ abfd->tdata.mmo_data->lop_stab_symbol);
+ bfd_set_error (bfd_error_bad_value);
+ abfd->tdata.mmo_data->have_error = true;
+ return false;
+ }
+ else
+ c = c2;
+ }
+
+ abfd->tdata.mmo_data->lop_stab_symbol[abfd->tdata.mmo_data->symbol_position++] = c;
+ abfd->tdata.mmo_data->lop_stab_symbol[abfd->tdata.mmo_data->symbol_position] = 0;
+
+ if (j & MMO3_REGQUAL_BITS)
+ {
+ if (j == MMO3_REGQUAL_BITS)
+ {
+ sym_type = mmo_reg_sym;
+ addr = mmo_get_byte (abfd);
+ }
+ else if (j <= 8)
+ {
+ unsigned int i;
+
+ for (i = 0; i < j; i++)
+ addr = (addr << 8) + mmo_get_byte (abfd);
+
+ if (addr == 0 && j == MMO3_UNDEF)
+ sym_type = mmo_undef_sym;
+ else
+ sym_type = mmo_abs_sym;
+ }
+ else
+ {
+ unsigned int i;
+
+ for (i = MMO3_DATA; i < j; i++)
+ addr = (addr << 8) + mmo_get_byte (abfd);
+
+ addr += (bfd_vma) 0x20 << 56;
+ sym_type = mmo_data_sym;
+ }
+
+ /* Get the serial number. */
+ do
+ {
+ k = mmo_get_byte (abfd);
+ serno = (serno << 7) + k;
+ }
+ while (k < 128);
+ serno -= 128;
+
+ /* Got it. Now enter it. Skip a leading ":". */
+ if (abfd->tdata.mmo_data->have_error == false
+ && ! mmo_create_symbol (abfd,
+ abfd->tdata.mmo_data->lop_stab_symbol
+ + 1,
+ addr, sym_type, serno))
+ abfd->tdata.mmo_data->have_error = true;
+ }
+
+ if (m & MMO3_MIDDLE)
+ /* Traverse middle trie. */
+ mmo_get_symbols (abfd);
+
+ abfd->tdata.mmo_data->symbol_position--;
+ }
+
+ if (m & MMO3_RIGHT)
+ /* Traverse right trie. */
+ mmo_get_symbols (abfd);
+
+ return abfd->tdata.mmo_data->have_error == false;
+}
+
+/* Get the location of memory area [VMA..VMA + SIZE - 1], which we think
+ is in section SEC. Adjust and reallocate zero-initialized contents.
+ If there's new contents, allocate to the next multiple of
+ MMO_SEC_CONTENTS_CHUNK_SIZE. */
+
+static INLINE bfd_byte *
+mmo_get_loc (sec, vma, size)
+ asection *sec;
+ bfd_vma vma;
+ int size;
+{
+ bfd_size_type allocated_size;
+ struct mmo_section_data_struct *sdatap
+ = (struct mmo_section_data_struct *) sec->used_by_bfd;
+ struct mmo_data_list_struct *datap = sdatap->head;
+ struct mmo_data_list_struct *entry;
+
+ for (; datap != NULL; datap = datap->next)
+ {
+ if (datap->where <= vma
+ && datap->where + datap->size >= vma + size)
+ return datap->data + vma - datap->where;
+ else if (datap->where <= vma
+ && datap->where + datap->allocated_size >= vma + size
+ /* Only munch on the "allocated size" if it does not
+ overlap the next chunk. */
+ && (datap->next == NULL || datap->next->where >= vma + size))
+ {
+ /* There was room allocated, but the size wasn't set to include
+ it. Do that now. */
+ datap->size += (vma + size) - (datap->where + datap->size);
+
+ /* Update the section size. */
+ if (vma + size > sec->vma + sec->_raw_size)
+ sec->_raw_size += (vma + size) - (sec->vma + sec->_raw_size);
+
+ return datap->data + vma - datap->where;
+ }
+ }
+
+ /* Not found; allocate a new block. First check in case we get a
+ request for a size split up over several blocks; we'll have to return
+ NULL for those cases, requesting the caller to split up the request.
+ Requests with an address aligned on MMO_SEC_CONTENTS_CHUNK_SIZE bytes and
+ for no more than MMO_SEC_CONTENTS_CHUNK_SIZE will always get resolved. */
+
+ for (datap = sdatap->head; datap != NULL; datap = datap->next)
+ if ((datap->where <= vma && datap->where + datap->size > vma)
+ || (datap->where < vma + size
+ && datap->where + datap->size >= vma + size))
+ return NULL;
+
+ allocated_size
+ = (size + MMO_SEC_CONTENTS_CHUNK_SIZE - 1) & ~(MMO_SEC_CONTENTS_CHUNK_SIZE - 1);
+ entry = (mmo_data_list_type *)
+ bfd_zalloc (sec->owner, sizeof (mmo_data_list_type) + allocated_size);
+ if (entry == NULL)
+ return false;
+ entry->where = vma;
+ entry->size = size;
+ entry->allocated_size = allocated_size;
+
+ datap = sdatap->head;
+
+ /* Sort the records by address. Optimize for the common case of adding
+ a record to the end of the list. */
+ if (sdatap->tail != NULL && entry->where >= sdatap->tail->where)
+ {
+ sdatap->tail->next = entry;
+ entry->next = NULL;
+ sdatap->tail = entry;
+ }
+ else
+ {
+ mmo_data_list_type **look;
+ for (look = &sdatap->head;
+ *look != NULL && (*look)->where < entry->where;
+ look = &(*look)->next)
+ ;
+ entry->next = *look;
+ *look = entry;
+ if (entry->next == NULL)
+ {
+ sdatap->tail = entry;
+
+ /* We get here for the first time (at other times too) for this
+ section. Say we have contents. */
+ if (! bfd_set_section_flags (sec->owner, sec,
+ bfd_get_section_flags (sec->owner, sec)
+ | SEC_HAS_CONTENTS))
+ return NULL;
+ }
+ }
+
+ /* Update the section size. */
+ if (vma + size > sec->vma + sec->_raw_size)
+ sec->_raw_size += (vma + size) - (sec->vma + sec->_raw_size);
+ return entry->data;
+}
+
+/* Set sizes once we've read in all sections. */
+
+static void
+mmo_map_set_sizes (abfd, sec, ignored)
+ bfd *abfd ATTRIBUTE_UNUSED;
+ asection *sec;
+ PTR ignored ATTRIBUTE_UNUSED;
+{
+ sec->_cooked_size = sec->_raw_size;
+ sec->lma = sec->vma;
+}
+
+/* Read the mmo file and turn it into sections. */
+
+static boolean
+mmo_scan (abfd)
+ bfd *abfd;
+{
+ unsigned int i;
+ unsigned int lineno = 1;
+ boolean error = false;
+ bfd_vma vma = 0;
+ asection *sec = bfd_make_section_old_way (abfd, MMO_TEXT_SECTION_NAME);
+ asection *non_spec_sec = NULL;
+ bfd_vma non_spec_vma = 0;
+ char *current_filename = NULL;
+ bfd_size_type nbytes_read = 0;
+ /* Buffer with room to read a 64-bit value. */
+ bfd_byte buf[8];
+ long stab_loc = -1;
+ char *file_names[256];
+
+ memset (file_names, 0, sizeof (file_names));
+
+ if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
+ goto error_return;
+
+ while ((nbytes_read = bfd_bread (buf, 4, abfd)) == 4)
+ {
+ if (buf[0] == LOP)
+ {
+ unsigned int y = bfd_get_8 (abfd, buf + 2);
+ unsigned int z = bfd_get_8 (abfd, buf + 3);
+
+ /* Change back to the original section for lopcodes other
+ than LOP_QUOTE that comes after a LOP_SPEC. */
+ if ((buf[1] != LOP_QUOTE || y != 0 || z != 1)
+ && non_spec_sec != NULL)
+ {
+ sec = non_spec_sec;
+ vma = non_spec_vma;
+ non_spec_sec = NULL;
+ }
+
+ switch (buf[1])
+ {
+ default:
+ (*_bfd_error_handler)
+ (_("%s: invalid mmo file: unsupported lopcode `%d'\n"),
+ bfd_get_filename (abfd), buf[1]);
+ bfd_set_error (bfd_error_bad_value);
+ goto error_return;
+
+ case LOP_QUOTE:
+ /* Quote the next 32-bit word. */
+ if (y != 0 || z != 1)
+ {
+ (*_bfd_error_handler)
+ (_("%s: invalid mmo file: expected YZ = 1 got YZ = %d for lop_quote\n"),
+ bfd_get_filename (abfd), y*256+z);
+ bfd_set_error (bfd_error_bad_value);
+ goto error_return;
+ }
+ if (bfd_bread (buf, 4, abfd) != 4)
+ goto error_return;
+
+ mmo_xore_32 (sec, vma, bfd_get_32 (abfd, buf));
+ vma += 4;
+ vma &= ~3;
+ lineno++;
+ break;
+
+ case LOP_LOC:
+ /* Set vma (and section). */
+ vma = (bfd_vma) y << 56;
+ if (z == 1)
+ {
+ /* Get a 32-bit value. */
+ if (bfd_bread (buf, 4, abfd) != 4)
+ goto error_return;
+
+ vma += bfd_get_32 (abfd, buf);
+ }
+ else if (z == 2)
+ {
+ /* Get a 64-bit value. */
+ if (bfd_bread (buf, 8, abfd) != 8)
+ goto error_return;
+
+ vma += bfd_get_64 (abfd, buf);
+ }
+ else
+ {
+ (*_bfd_error_handler)
+ (_("%s: invalid mmo file: expected z = 1 or z = 2, got z = %d for lop_loc\n"),
+ bfd_get_filename (abfd), z);
+ bfd_set_error (bfd_error_bad_value);
+ goto error_return;
+ }
+
+ sec = mmo_decide_section (abfd, vma);
+ if (sec == NULL)
+ goto error_return;
+ break;
+
+ case LOP_SKIP:
+ /* Move forward within the same section. */
+ vma += y * 256 + z;
+
+ sec = mmo_decide_section (abfd, vma);
+ if (sec == NULL)
+ goto error_return;
+ break;
+
+ case LOP_FIXO:
+ /* A fixup: Store the current vma somewhere. Position using
+ same format as LOP_LOC. */
+ {
+ bfd_vma p = (bfd_vma) y << 56;
+ asection *fixosec;
+
+ if (z == 1)
+ {
+ /* Get a 32-bit value. */
+ if (bfd_bread (buf, 4, abfd) != 4)
+ goto error_return;
+
+ p += bfd_get_32 (abfd, buf);
+ }
+ else if (z == 2)
+ {
+ /* Get a 64-bit value. */
+ if (bfd_bread (buf, 8, abfd) != 8)
+ goto error_return;
+
+ p += bfd_get_64 (abfd, buf);
+ }
+ else
+ {
+ (*_bfd_error_handler)
+ (_("%s: invalid mmo file: expected z = 1 or z = 2, got z = %d for lop_fixo\n"),
+ bfd_get_filename (abfd), z);
+ bfd_set_error (bfd_error_bad_value);
+ goto error_return;
+ }
+
+ /* The section where we store this address might be a
+ different one than the current section. */
+ fixosec = mmo_decide_section (abfd, p);
+ if (fixosec == NULL)
+ goto error_return;
+ mmo_xore_64 (fixosec, p, vma);
+ }
+ break;
+
+ case LOP_FIXR:
+ /* A fixup: Store YZ of this lopcode into YZ at vma - 4 * yz. */
+ {
+ unsigned int yz = (y * 256 + z);
+ bfd_vma p = vma + 2 - 4 * yz;
+ asection *fixrsec = mmo_decide_section (abfd, p);
+ if (fixrsec == NULL)
+ goto error_return;
+ mmo_xore_16 (fixrsec, p, yz);
+ }
+ break;
+
+ case LOP_FIXRX:
+ /* A fixup, similar to lop_fixr, but taking larger numbers
+ and can change branches into the opposite direction
+ (gasp!). */
+ {
+ bfd_vma delta;
+ bfd_vma p;
+ asection *fixrsec;
+
+ if (y != 0)
+ {
+ (*_bfd_error_handler)
+ (_("%s: invalid mmo file: expected y = 0, got y = %d for lop_fixrx\n"),
+ bfd_get_filename (abfd), y);
+ bfd_set_error (bfd_error_bad_value);
+ goto error_return;
+ }
+
+ if (z != 16 && z != 24)
+ {
+ (*_bfd_error_handler)
+ (_("%s: invalid mmo file: expected z = 16 or z = 24, got z = %d for lop_fixrx\n"),
+ bfd_get_filename (abfd), z);
+ bfd_set_error (bfd_error_bad_value);
+ goto error_return;
+ }
+
+ /* Get the next 32-bit value. */
+ if (bfd_bread (buf, 4, abfd) != 4)
+ goto error_return;
+
+ delta = bfd_get_32 (abfd, buf);
+
+ /* Do an, ehm, involved calculation for the location of
+ the fixup. See mmixal documentation for a verbose
+ explanation. We follow it verbosely here for the
+ readers delight. */
+ if (buf[0] == 0)
+ p = vma - 4 * delta;
+ else if (buf[0] == 1)
+ p = vma - 4 * ((delta & 0xffffff) - (1 << z));
+ else
+ {
+ (*_bfd_error_handler)
+ (_("%s: invalid mmo file: leading byte of operand word must be 0 or 1, got %d for lop_fixrx\n"),
+ bfd_get_filename (abfd), buf[0]);
+ bfd_set_error (bfd_error_bad_value);
+ goto error_return;
+ }
+
+ fixrsec = mmo_decide_section (abfd, vma);
+ if (fixrsec == NULL)
+ goto error_return;
+ mmo_xore_32 (fixrsec, p, delta);
+ }
+ break;
+
+ case LOP_FILE:
+ /* Set current file and perhaps the file name. Reset line
+ number. */
+ if (z != 0)
+ {
+ char *fname = bfd_malloc (z * 4 + 1);
+
+ if (fname == NULL)
+ {
+ (*_bfd_error_handler)
+ (_("%s: cannot allocate file name for file number %d, %d bytes\n"),
+ bfd_get_filename (abfd), y, z * 4 + 1);
+ bfd_set_error (bfd_error_system_call);
+ goto error_return;
+ }
+
+ fname[z * 4] = 0;
+
+ for (i = 0; i < z; i++)
+ {
+ if (bfd_bread (fname + i * 4, 4, abfd) != 4)
+ {
+ free (fname);
+ goto error_return;
+ }
+ }
+
+ if (file_names[y] != NULL)
+ {
+ (*_bfd_error_handler)
+ (_("%s: invalid mmo file: file number %d `%s',\
+ was already entered as `%s'\n"),
+ bfd_get_filename (abfd), y, fname, file_names[y]);
+ bfd_set_error (bfd_error_bad_value);
+ goto error_return;
+ }
+
+ file_names[y] = fname;
+ }
+
+ if (file_names[y] == NULL)
+ {
+ (*_bfd_error_handler)
+ (_("%s: invalid mmo file: file name for number %d\
+ was not specified before use\n"),
+ bfd_get_filename (abfd), y);
+ bfd_set_error (bfd_error_bad_value);
+ goto error_return;
+ }
+
+ current_filename = file_names[y];
+ lineno = 0;
+ break;
+
+ case LOP_LINE:
+ /* Set line number. */
+ lineno = y * 256 + z;
+ /* FIXME: Create a sequence of mmo-specific line number
+ entries for each section, then translate into canonical
+ format. */
+ break;
+
+ case LOP_SPEC:
+ /* Special data follows until the next non-lop_quote
+ lopcode. */
+ non_spec_sec = sec;
+ non_spec_vma = vma;
+ sec = mmo_get_spec_section (abfd, y * 256 + z);
+ if (sec == NULL)
+ goto error_return;
+
+ vma = sec->vma;
+ break;
+
+ case LOP_PRE:
+ {
+ /* We ignore header information, except we read in the
+ creation time from the first 32-bit word with the time
+ in seconds since era. */
+ if (z >= 1
+ && bfd_bread (abfd->tdata.mmo_data->created, 4,
+ abfd) != 4)
+ goto error_return;
+
+ for (i = 1; i < z; i++)
+ if (bfd_bread (buf, 4, abfd) != 4)
+ goto error_return;
+ }
+ break;
+
+ case LOP_POST:
+ /* This tells of the contents of registers $Z..$255 at
+ startup. We make a section out of it, with VMA = Z * 8,
+ but only if Z != 255 or the contents is non-zero. */
+ {
+ asection *rsec;
+ bfd_byte *loc;
+ bfd_vma first_octa;
+ bfd_vma startaddr_octa;
+
+ /* Read first octaword outside loop to simplify logic when
+ excluding the Z == 255, octa == 0 case. */
+ if (bfd_bread (buf, 8, abfd) != 8)
+ goto error_return;
+
+ first_octa = bfd_get_64 (abfd, buf);
+
+ /* Don't emit contents for the trivial case which is
+ always present; $255 pointing to Main. */
+ if (z != 255)
+ {
+ rsec
+ = bfd_make_section_old_way (abfd,
+ MMIX_REG_CONTENTS_SECTION_NAME);
+ rsec->vma = z * 8;
+ loc = mmo_get_loc (rsec, z * 8, (255 - z) * 8);
+ bfd_put_64 (abfd, first_octa, loc);
+
+ for (i = z + 1; i < 255; i++)
+ {
+ if (bfd_bread (loc + (i - z) * 8, 8, abfd) != 8)
+ goto error_return;
+ }
+
+ /* Read out the last octabyte, and use it to set the
+ start address. */
+ if (bfd_bread (buf, 8, abfd) != 8)
+ goto error_return;
+
+ startaddr_octa = bfd_get_64 (abfd, buf);
+ }
+ else
+ startaddr_octa = first_octa;
+
+ if (! bfd_set_start_address (abfd, startaddr_octa))
+ {
+ /* Currently this can't fail, but this should handle
+ future failures. */
+ bfd_set_error (bfd_error_bad_value);
+ goto error_return;
+ }
+ }
+ break;
+
+ case LOP_STAB:
+ /* We read in the symbols now, not later. */
+ if (y != 0 || z != 0)
+ {
+ (*_bfd_error_handler)
+ (_("%s: invalid mmo file: fields y and z of lop_stab\
+ non-zero, y: %d, z: %d\n"),
+ bfd_get_filename (abfd), y, z);
+ bfd_set_error (bfd_error_bad_value);
+ goto error_return;
+ }
+
+ /* Save the location, so we can check that YZ in the LOP_END
+ is correct. */
+ stab_loc = bfd_tell (abfd);
+
+ /* It's not said that an MMO can be without symbols (though
+ mmixal will refuse to assemble files without Main), but
+ it seems it would still be a valid mmo-file, so allow it.
+ We detect the absence of a symbol area in that the upper
+ limit is computed (from the lop_end YZ field) as 0.
+ Don't call mmo_get_symbols; it can only detect the end of
+ a valid symbol trie, not the absence of one. */
+ if (abfd->tdata.mmo_data->max_symbol_length != 0
+ && ! mmo_get_symbols (abfd))
+ goto error_return;
+ break;
+
+ case LOP_END:
+ {
+ /* This must be the last 32-bit word in an mmo file.
+ Let's find out. */
+ struct stat statbuf;
+ long curpos = bfd_tell (abfd);
+
+ if (bfd_stat (abfd, &statbuf) < 0)
+ goto error_return;
+
+ if (statbuf.st_size != curpos)
+ {
+ (*_bfd_error_handler)
+ (_("%s: invalid mmo file: lop_end not last item in\
+ file\n"),
+ bfd_get_filename (abfd));
+ bfd_set_error (bfd_error_bad_value);
+ goto error_return;
+ }
+
+ /* Check that the YZ field is right. Subtract the size of
+ this LOP_END in the calculation; YZ does not include
+ it. */
+ if ((long) (y * 256 + z) * 4 != (curpos - stab_loc) - 4)
+ {
+ (*_bfd_error_handler)
+ (_("%s: invalid mmo file: YZ of lop_end (%ld)\
+ not equal to the number of tetras to the preceding lop_stab (%ld)\n"),
+ bfd_get_filename (abfd), (long) (y * 256 + z),
+ (curpos - stab_loc - 4)/4);
+ bfd_set_error (bfd_error_bad_value);
+ goto error_return;
+ }
+
+ bfd_map_over_sections (abfd, mmo_map_set_sizes, NULL);
+ goto done;
+ }
+ }
+ }
+ else
+ {
+ /* This wasn't a lopcode, so store it in the current section. */
+ mmo_xore_32 (sec, vma & ~3, bfd_get_32 (abfd, buf));
+ vma += 4;
+ vma &= ~3;
+ lineno++;
+ }
+ }
+
+ /* We know this file is a multiple of four bytes (checked in
+ mmo_object_p), so if we got something other than 0, this was a bad
+ file (although it's more likely we'll get 0 in that case too).
+ If we got end-of-file, then there was no lop_stab, so the file has
+ invalid format. */
+
+ if (nbytes_read != 0)
+ bfd_set_error (bfd_error_system_call);
+ else
+ bfd_set_error (bfd_error_bad_value);
+
+ error_return:
+ error = true;
+ done:
+ /* Mark the .text and .data section with their normal attribute if they
+ contain anything. This is not redundant wrt. mmo_decide_section,
+ since that code might never execute, and conversely the alloc+code
+ section flags must be set then. */
+ sec = bfd_get_section_by_name (abfd, MMO_TEXT_SECTION_NAME);
+ if (sec != NULL
+ && (bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS)
+ && ! bfd_set_section_flags (abfd, sec,
+ bfd_get_section_flags (abfd, sec)
+ | SEC_ALLOC | SEC_LOAD | SEC_CODE))
+ error = true;
+
+ sec = bfd_get_section_by_name (abfd, MMO_DATA_SECTION_NAME);
+ if (sec != NULL
+ && (bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS)
+ && ! bfd_set_section_flags (abfd, sec,
+ bfd_get_section_flags (abfd, sec)
+ | SEC_ALLOC | SEC_LOAD))
+ error = true;
+
+ /* Free whatever resources we took. */
+ for (i = 0; i < sizeof (file_names) / sizeof (file_names[0]); i++)
+ if (file_names[i])
+ free (file_names[i]);
+ return error ? false : true;
+}
+
+/* A hook to set up object file dependent section information. For mmo,
+ we point out the shape of allocated section contents. */
+
+static boolean
+mmo_new_section_hook (abfd, newsect)
+ bfd *abfd ATTRIBUTE_UNUSED;
+ asection *newsect;
+{
+ /* We zero-fill all fields and assume NULL is represented by an all
+ zero-bit pattern. */
+ newsect->used_by_bfd =
+ (PTR) bfd_zalloc (abfd, sizeof (struct mmo_section_data_struct));
+
+ if (!newsect->used_by_bfd)
+ return false;
+
+ /* Always align to at least 32-bit words. */
+ newsect->alignment_power = 2;
+ return true;
+}
+
+/* We already have section contents loaded for sections that have
+ contents. */
+
+static boolean
+mmo_get_section_contents (abfd, sec, location, offset, bytes_to_do)
+ bfd *abfd ATTRIBUTE_UNUSED;
+ asection *sec ATTRIBUTE_UNUSED;
+ PTR location ATTRIBUTE_UNUSED;
+ file_ptr offset ATTRIBUTE_UNUSED;
+ bfd_size_type bytes_to_do ATTRIBUTE_UNUSED;
+{
+ /* Iterate over diminishing chunk sizes, copying contents, like
+ mmo_set_section_contents. */
+ while (bytes_to_do)
+ {
+ /* A minor song-and-dance to make sure we're not bitten by the
+ distant possibility of the cast from bfd_vma to int making the
+ chunk zero-sized. */
+ int chunk_size
+ = (int) bytes_to_do != 0 ? bytes_to_do : MMO_SEC_CONTENTS_CHUNK_SIZE;
+ bfd_byte *loc;
+
+ do
+ loc = mmo_get_loc (sec, sec->vma + offset, chunk_size);
+ while (loc == NULL && (chunk_size /= 2) != 0);
+
+ if (chunk_size == 0)
+ return false;
+
+ memcpy (location, loc, chunk_size);
+
+ location += chunk_size;
+ bytes_to_do -= chunk_size;
+ offset += chunk_size;
+ }
+ return true;
+}
+
+/* Return the amount of memory needed to read the symbol table. */
+
+static long
+mmo_get_symtab_upper_bound (abfd)
+ bfd *abfd ATTRIBUTE_UNUSED;
+{
+ return (abfd->symcount + 1) * sizeof (asymbol *);
+}
+
+/* Sort mmo symbols by serial number. */
+
+static int
+mmo_sort_mmo_symbols (arg1, arg2)
+ CONST PTR arg1;
+ CONST PTR arg2;
+{
+ CONST struct mmo_symbol *sym1 = *(CONST struct mmo_symbol **) arg1;
+ CONST struct mmo_symbol *sym2 = *(CONST struct mmo_symbol **) arg2;
+
+ /* Sort by serial number first. */
+ if (sym1->serno < sym2->serno)
+ return -1;
+ else if (sym1->serno > sym2->serno)
+ return 1;
+
+ /* Then sort by address of the table entries. */
+ return ((CONST char *) arg1 - (CONST char *) arg2);
+}
+
+/* Translate the symbol table. */
+
+static long
+mmo_get_symtab (abfd, alocation)
+ bfd *abfd;
+ asymbol **alocation;
+{
+ unsigned int symcount = bfd_get_symcount (abfd);
+ asymbol *csymbols;
+ unsigned int i;
+
+ csymbols = abfd->tdata.mmo_data->csymbols;
+ if (csymbols == NULL)
+ {
+ asymbol *c;
+ struct mmo_symbol *s;
+ struct mmo_symbol **msp;
+
+ /* First we store the symbols into the table we'll return, then we
+ qsort it on the serial number, with secondary on the address of
+ the symbol, to preserve order if there would be non-unique serial
+ numbers. */
+ for (s = abfd->tdata.mmo_data->symbols,
+ msp = (struct mmo_symbol **) alocation;
+ s != NULL;
+ s = s->next, ++msp)
+ *msp = s;
+
+ *msp = NULL;
+
+ qsort (alocation, symcount, sizeof (struct mmo_symbol *),
+ mmo_sort_mmo_symbols);
+
+ csymbols = (asymbol *) bfd_alloc (abfd, symcount * sizeof (asymbol));
+ if (csymbols == NULL && symcount != 0)
+ return false;
+ abfd->tdata.mmo_data->csymbols = csymbols;
+
+ for (msp = (struct mmo_symbol **) alocation, c = csymbols;
+ *msp != NULL;
+ msp++, ++c)
+ {
+ s = *msp;
+ c->the_bfd = abfd;
+ c->name = s->name;
+ c->value = s->value;
+ c->flags = BSF_GLOBAL;
+
+ if (s->sym_type == mmo_data_sym)
+ {
+ c->section
+ = bfd_get_section_by_name (abfd, MMO_DATA_SECTION_NAME);
+
+ if (c->section == NULL)
+ c->section = bfd_abs_section_ptr;
+ else
+ c->value -= c->section->vma;
+ }
+ else if (s->sym_type == mmo_undef_sym)
+ c->section = bfd_und_section_ptr;
+ else if (s->sym_type == mmo_reg_sym)
+ {
+ c->section
+ = bfd_make_section_old_way (abfd, MMIX_REG_SECTION_NAME);
+ }
+ else
+ {
+ asection *textsec
+ = bfd_get_section_by_name (abfd, MMO_TEXT_SECTION_NAME);
+
+ if (textsec != NULL
+ && c->value >= textsec->vma
+ && c->value <= textsec->vma + textsec->_cooked_size)
+ {
+ c->section = textsec;
+ c->value -= c->section->vma;
+ }
+ else
+ c->section = bfd_abs_section_ptr;
+ }
+
+ c->udata.p = NULL;
+ }
+ }
+
+ /* Last, overwrite the incoming table with the right-type entries. */
+ for (i = 0; i < symcount; i++)
+ *alocation++ = csymbols++;
+ *alocation = NULL;
+
+ return symcount;
+}
+
+/* Make an empty symbol. */
+
+static asymbol *
+mmo_make_empty_symbol (abfd)
+ bfd *abfd;
+{
+ asymbol *new = (asymbol *) bfd_zalloc (abfd, sizeof (asymbol));
+
+ if (new)
+ new->the_bfd = abfd;
+ return new;
+}
+
+/* Get information about a symbol. */
+
+static void
+mmo_get_symbol_info (ignore_abfd, symbol, ret)
+ bfd *ignore_abfd ATTRIBUTE_UNUSED;
+ asymbol *symbol;
+ symbol_info *ret;
+{
+ bfd_symbol_info (symbol, ret);
+}
+
+static void
+mmo_print_symbol (abfd, afile, symbol, how)
+ bfd *abfd;
+ PTR afile;
+ asymbol *symbol;
+ bfd_print_symbol_type how;
+{
+ FILE *file = (FILE *) afile;
+
+ switch (how)
+ {
+ case bfd_print_symbol_name:
+ fprintf (file, "%s", symbol->name);
+ break;
+ default:
+ bfd_print_symbol_vandf (abfd, (PTR) file, symbol);
+
+ fprintf (file, " %-5s %s",
+ symbol->section->name,
+ symbol->name);
+ }
+}
+
+/* We can't map a file directly into executable code, so the
+ size of header information is irrelevant. */
+
+static int
+mmo_sizeof_headers (abfd, exec)
+ bfd *abfd ATTRIBUTE_UNUSED;
+ boolean exec ATTRIBUTE_UNUSED;
+{
+ return 0;
+}
+
+/* Write the (section-neutral) file preamble. */
+
+static boolean
+mmo_internal_write_header (abfd)
+ bfd *abfd;
+{
+ CONST char lop_pre_bfd[] = { LOP, LOP_PRE, 1, 1};
+
+ if (bfd_bwrite (lop_pre_bfd, 4, abfd) != 4)
+ return false;
+
+ /* Copy creation time of original file. */
+ if (bfd_bwrite (abfd->tdata.mmo_data->created, 4, abfd) != 4)
+ return false;
+
+ return true;
+}
+
+/* Write the LOP_POST record, with global register initializations.
+ Z is the Z field of the LOP_POST, corresponding to 255 - number of
+ registers at DATA. The Z = 255 field is filled in with the
+ start-address. */
+
+static boolean
+mmo_internal_write_post (abfd, z, sec)
+ bfd *abfd;
+ int z;
+ asection *sec;
+{
+ int i;
+ bfd_byte buf[8];
+ mmo_write_tetra_raw (abfd, (LOP << 24) | (LOP_POST << 16) | z);
+
+ for (i = z; i < 255; i++)
+ {
+ bfd_byte *data = mmo_get_loc (sec, i * 8, 8);
+
+ if (bfd_bwrite (data, 8, abfd) != 8)
+ return false;
+ }
+
+ /* For Z == $255, we always emit the start location; supposedly Main,
+ but we have it handy at bfd_get_start_address. If we're called with
+ Z == 255, don't assume DATA is valid. */
+ bfd_put_64 (abfd, bfd_get_start_address (abfd), buf);
+
+ return
+ abfd->tdata.mmo_data->have_error == false
+ && bfd_bwrite (buf, 8, abfd) == 8;
+}
+
+/* Translate to and from BFD flags. This is to make sure that we don't
+ get bitten by BFD flag number changes. */
+
+static flagword
+mmo_sec_flags_from_bfd_flags (flags)
+ flagword flags;
+{
+ flagword oflags = 0;
+
+ if (flags & SEC_ALLOC)
+ oflags |= MMO_SEC_ALLOC;
+ if (flags & SEC_LOAD)
+ oflags |= MMO_SEC_LOAD;
+ if (flags & SEC_RELOC)
+ oflags |= MMO_SEC_RELOC;
+ if (flags & SEC_READONLY)
+ oflags |= MMO_SEC_READONLY;
+ if (flags & SEC_CODE)
+ oflags |= MMO_SEC_CODE;
+ if (flags & SEC_DATA)
+ oflags |= MMO_SEC_DATA;
+ if (flags & SEC_NEVER_LOAD)
+ oflags |= MMO_SEC_NEVER_LOAD;
+ if (flags & SEC_IS_COMMON)
+ oflags |= MMO_SEC_IS_COMMON;
+ if (flags & SEC_DEBUGGING)
+ oflags |= MMO_SEC_DEBUGGING;
+
+ return oflags;
+}
+
+static flagword
+bfd_sec_flags_from_mmo_flags (flags)
+ flagword flags;
+{
+ flagword oflags = 0;
+
+ if (flags & MMO_SEC_ALLOC)
+ oflags |= SEC_ALLOC;
+ if (flags & MMO_SEC_LOAD)
+ oflags |= SEC_LOAD;
+ if (flags & MMO_SEC_RELOC)
+ oflags |= SEC_RELOC;
+ if (flags & MMO_SEC_READONLY)
+ oflags |= SEC_READONLY;
+ if (flags & MMO_SEC_CODE)
+ oflags |= SEC_CODE;
+ if (flags & MMO_SEC_DATA)
+ oflags |= SEC_DATA;
+ if (flags & MMO_SEC_NEVER_LOAD)
+ oflags |= SEC_NEVER_LOAD;
+ if (flags & MMO_SEC_IS_COMMON)
+ oflags |= SEC_IS_COMMON;
+ if (flags & MMO_SEC_DEBUGGING)
+ oflags |= SEC_DEBUGGING;
+
+ return oflags;
+}
+
+/* Write a section. */
+
+static boolean
+mmo_internal_write_section (abfd, sec)
+ bfd *abfd;
+ asection *sec;
+{
+ /* We do it differently depending on what section this is:
+
+ ".text": Output, prepended by information about the first source file
+ (not yet implemented.)
+
+ ".data": Output.
+
+ (".MMIX.reg_contents": Not handled here.)
+
+ Anything else: Output inside a lop_spec 80, in the format described
+ above. */
+
+ if (strcmp (sec->name, MMO_TEXT_SECTION_NAME) == 0)
+ /* FIXME: Output source file name and line number. */
+ return
+ mmo_write_loc_chunk_list (abfd,
+ ((struct mmo_section_data_struct *)
+ (sec->used_by_bfd))->head);
+ else if (strcmp (sec->name, MMO_DATA_SECTION_NAME) == 0)
+ return
+ mmo_write_loc_chunk_list (abfd,
+ ((struct mmo_section_data_struct *)
+ (sec->used_by_bfd))->head);
+ else if (strcmp (sec->name, MMIX_REG_CONTENTS_SECTION_NAME) == 0)
+ /* Not handled here. */
+ {
+ /* This would normally be an abort call since this can't happen, but
+ we don't do that. */
+ bfd_set_error (bfd_error_bad_value);
+ return false;
+ }
+ else if (strncmp (sec->name, MMIX_OTHER_SPEC_SECTION_PREFIX,
+ strlen (MMIX_OTHER_SPEC_SECTION_PREFIX)) == 0)
+ {
+ int n = atoi (sec->name + strlen (MMIX_OTHER_SPEC_SECTION_PREFIX));
+ mmo_write_tetra_raw (abfd, (LOP << 24) | (LOP_SPEC << 16) | n);
+ return
+ abfd->tdata.mmo_data->have_error == false
+ && mmo_write_chunk_list (abfd,
+ ((struct mmo_section_data_struct *)
+ (sec->used_by_bfd))->head);
+ }
+ /* Ignore sections that are just allocated or empty; we write out
+ _contents_ here. */
+ else if ((bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS) != 0
+ && sec->_raw_size != 0)
+ {
+ /* Keep the document-comment formatted the way it is. */
+/*
+INODE
+mmo section mapping, , Symbol-table, mmo
+SUBSECTION
+ mmo section mapping
+
+ The implementation in BFD uses special data type 80 (decimal) to
+ encapsulate and describe named sections, containing e.g.@: debug
+ information. If needed, any datum in the encapsulation will be
+ quoted using lop_quote. First comes a 32-bit word holding the
+ number of 32-bit words containing the zero-terminated zero-padded
+ segment name. After the name there's a 32-bit word holding flags
+ describing the section type. Then comes a 64-bit big-endian word
+ with the section length (in bytes), then another with the section
+ start address. Depending on the type of section, the contents
+ might follow, zero-padded to 32-bit boundary. For a loadable
+ section (such as data or code), the contents might follow at some
+ later point, not necessarily immediately, as a lop_loc with the
+ same start address as in the section description, followed by the
+ contents. This in effect forms a descriptor that must be emitted
+ before the actual contents. Sections described this way must not
+ overlap.
+
+ For areas that don't have such descriptors, synthetic sections are
+ formed by BFD. Consecutive contents in the two memory areas
+ @samp{0x0000@dots{}00} to @samp{0x01ff@dots{}ff} and
+ @samp{0x2000@dots{}00} to @samp{0x20ff@dots{}ff} are entered in
+ sections named <<.text>> and <<.data>> respectively. If an area
+ is not otherwise described, but would together with a neighboring
+ lower area be less than @samp{0x40000000} bytes long, it is joined
+ with the lower area and the gap is zero-filled. For other cases,
+ a new section is formed, named <<.MMIX.sec.@var{n}>>. Here,
+ @var{n} is a number, a running count through the mmo file,
+ starting at 0.
+
+EXAMPLE
+ A loadable section specified as:
+
+| .section secname,"ax"
+| TETRA 1,2,3,4,-1,-2009
+| BYTE 80
+
+ and linked to address @samp{0x4}, is represented by the sequence:
+
+| 0x98080050 - lop_spec 80
+| 0x00000002 - two 32-bit words for the section name
+| 0x7365636e - "secn"
+| 0x616d6500 - "ame\0"
+| 0x00000033 - flags CODE, READONLY, LOAD, ALLOC
+| 0x00000000 - high 32 bits of section length
+| 0x0000001c - section length is 28 bytes; 6 * 4 + 1 + alignment to 32 bits
+| 0x00000000 - high 32 bits of section address
+| 0x00000004 - section address is 4
+| 0x98010002 - 64 bits with address of following data
+| 0x00000000 - high 64 bits of address
+| 0x00000004 - data starts at address 4
+| 0x00000001 - 1
+| 0x00000002 - 2
+| 0x00000003 - 3
+| 0x00000004 - 4
+| 0xffffffff - -1
+| 0xfffff827 - -2009
+| 0x50000000 - 80 as a byte, padded with zeros.
+
+ Note that the lop_spec wrapping does not include the section
+ contents. Compare this to a non-loaded section specified as:
+
+| .section thirdsec
+| TETRA 200001,100002
+| BYTE 38,40
+
+ This, when linked to address @samp{0x200000000000001c}, is
+ represented by:
+
+| 0x98080050 - lop_spec 80
+| 0x00000002 - two 32-bit words for the section name
+| 0x7365636e - "thir"
+| 0x616d6500 - "dsec"
+| 0x00000010 - flag READONLY
+| 0x00000000 - high 32 bits of section length
+| 0x0000000c - section length is 12 bytes; 2 * 4 + 2 + alignment to 32 bits
+| 0x20000000 - high 64 bits of address
+| 0x0000001c - low 64 bits of address 0x200000000000001c
+| 0x00030d41 - 200001
+| 0x000186a2 - 100002
+| 0x26280000 - 38, 40 as bytes, padded with zeros
+
+ For the latter example, the section contents must not to appear
+ loaded in memory, and is therefore specified as part of the
+ special data. The address is usually unimportant but might
+ provide information for e.g.@: the DWARF 2 debugging format. */
+
+ mmo_write_tetra_raw (abfd, LOP_SPEC_SECTION);
+ mmo_write_tetra (abfd, (strlen (sec->name) + 3) / 4);
+ mmo_write_chunk (abfd, sec->name, strlen (sec->name));
+ /* FIXME: We can get debug sections (.debug_line & Co.) with a
+ section flag still having SEC_RELOC set. Investigate. This
+ might be true for all alien sections; perhaps mmo.em should clear
+ that flag. Might be related to weak references. */
+ mmo_write_tetra (abfd,
+ mmo_sec_flags_from_bfd_flags
+ (bfd_get_section_flags (abfd, sec)));
+ mmo_write_octa (abfd, sec->_raw_size);
+ mmo_write_octa (abfd, bfd_get_section_vma (abfd, sec));
+
+ /* Writing a LOP_LOC ends the LOP_SPEC data, and makes data actually
+ loaded. */
+ if (bfd_get_section_flags (abfd, sec) & SEC_LOAD)
+ return
+ abfd->tdata.mmo_data->have_error == false
+ && mmo_write_loc_chunk_list (abfd,
+ ((struct mmo_section_data_struct *)
+ (sec->used_by_bfd))->head);
+ return
+ abfd->tdata.mmo_data->have_error == false
+ && mmo_write_chunk_list (abfd,
+ ((struct mmo_section_data_struct *)
+ (sec->used_by_bfd))->head);
+ }
+ return true;
+}
+
+/* We save up all data before output. */
+
+static boolean
+mmo_set_section_contents (abfd, sec, location, offset, bytes_to_do)
+ bfd *abfd ATTRIBUTE_UNUSED;
+ sec_ptr sec;
+ PTR location;
+ file_ptr offset;
+ bfd_size_type bytes_to_do;
+{
+ /* Iterate over diminishing chunk sizes, copying contents. */
+ while (bytes_to_do)
+ {
+ /* A minor song-and-dance to make sure we're not bitten by the
+ distant possibility of the cast from bfd_vma to int making the
+ chunk zero-sized. */
+ int chunk_size
+ = (int) bytes_to_do != 0 ? bytes_to_do : MMO_SEC_CONTENTS_CHUNK_SIZE;
+ bfd_byte *loc;
+
+ do
+ loc = mmo_get_loc (sec, sec->vma + offset, chunk_size);
+ while (loc == NULL && (chunk_size /= 2) != 0);
+
+ if (chunk_size == 0)
+ return false;
+
+ memcpy (loc, location, chunk_size);
+
+ location += chunk_size;
+ bytes_to_do -= chunk_size;
+ offset += chunk_size;
+ }
+ return true;
+}
+
+/* Add a symbol to a trie-tree. */
+
+static boolean
+mmo_internal_add_3_sym (abfd, rootp, symp)
+ bfd *abfd;
+ struct mmo_symbol_trie *rootp;
+ CONST struct mmo_symbol *symp;
+{
+ CONST char *name = symp->name;
+ struct mmo_symbol_trie *trie = rootp;
+ struct mmo_symbol_trie **triep = NULL;
+
+ while (*name && trie != NULL)
+ {
+ if (*name < trie->symchar)
+ {
+ triep = &trie->left;
+ trie = trie->left;
+ }
+ else if (*name > trie->symchar)
+ {
+ triep = &trie->right;
+ trie = trie->right;
+ }
+ else if (*name == trie->symchar)
+ {
+ triep = &trie->middle;
+ name++;
+
+ /* Make sure "trie" points to where we should fill in the
+ current symbol whenever we've iterated through "name". We
+ would lose the right position if we encounter "foobar" then
+ "foo". */
+ if (*name)
+ trie = trie->middle;
+ }
+ }
+
+ while (*name != 0)
+ {
+ /* Create middle branches for the rest of the characters. */
+ trie = bfd_zalloc (abfd, sizeof (struct mmo_symbol_trie));
+ *triep = trie;
+ trie->symchar = *name++;
+ triep = &trie->middle;
+ }
+
+ /* We discover a duplicate symbol rather late in the process, but still;
+ we discover it and bail out. */
+ if (trie->sym.name != NULL)
+ {
+ (*_bfd_error_handler)
+ (_("%s: invalid symbol table: duplicate symbol `%s'\n"),
+ bfd_get_filename (abfd), trie->sym.name);
+ bfd_set_error (bfd_error_bad_value);
+ return false;
+ }
+
+ memcpy (&trie->sym, symp, sizeof *symp);
+ return true;
+}
+
+/* Find out the length of the serialized version of a trie in bytes. */
+
+static unsigned int
+mmo_internal_3_length (abfd, trie)
+ bfd *abfd;
+ struct mmo_symbol_trie *trie;
+{
+ /* First, one for the control byte. */
+ unsigned int length = 1;
+
+ if (trie == NULL)
+ return 0;
+
+ /* Add in the recursion to the left. */
+ length += mmo_internal_3_length (abfd, trie->left);
+
+ /* Add in the middle trie and the character. */
+ length += 1 + mmo_internal_3_length (abfd, trie->middle);
+
+ /* Add in the recursion to the right. */
+ length += mmo_internal_3_length (abfd, trie->right);
+
+ /* Add in bytes for the symbol (if this is an endnode). */
+ if (trie->sym.name != NULL)
+ {
+ unsigned int serno = trie->sym.serno;
+
+ /* First what it takes to encode the value. */
+ if (trie->sym.sym_type == mmo_reg_sym)
+ length++;
+ else if (trie->sym.sym_type == mmo_undef_sym)
+ length += 2;
+ else
+ {
+ bfd_vma value = trie->sym.value;
+
+ /* Coded in one to eight following bytes. */
+ if (trie->sym.sym_type == mmo_data_sym)
+ value -= (bfd_vma) 0x20 << 56;
+
+ do
+ {
+ value >>= 8;
+ length++;
+ }
+ while (value != 0);
+ }
+
+ /* Find out what it takes to encode the serial number. */
+ do
+ {
+ serno >>= 7;
+ length++;
+ }
+ while (serno != 0);
+ }
+
+ return length;
+}
+
+/* Helper function for outputting the serial number of a symbol, output as
+ a variant of leb128 (see dwarf2 documentation) which could be called
+ beb128. Using a helper function and recursion simplifies debugging. */
+
+static void
+mmo_beb128_out (abfd, serno, marker)
+ bfd *abfd;
+ int serno;
+ int marker;
+{
+ if (serno & ~0x7f)
+ mmo_beb128_out (abfd, serno >> 7, 0);
+ mmo_write_byte (abfd, marker | (serno & 0x7f));
+}
+
+/* Serialize a trie. */
+
+static void
+mmo_internal_3_dump (abfd, trie)
+ bfd *abfd;
+ struct mmo_symbol_trie *trie;
+{
+ bfd_byte control = 0;
+
+ if (trie == NULL)
+ return;
+
+ if (trie->left)
+ control |= MMO3_LEFT;
+
+ if (trie->middle)
+ control |= MMO3_MIDDLE;
+
+ if (trie->right)
+ control |= MMO3_RIGHT;
+
+ if (trie->sym.name != NULL)
+ {
+ /* Encode the symbol type and length of value bytes. */
+ if (trie->sym.sym_type == mmo_reg_sym)
+ control |= MMO3_REGQUAL_BITS;
+ else if (trie->sym.sym_type == mmo_undef_sym)
+ control |= MMO3_UNDEF;
+ else
+ {
+ bfd_vma value = trie->sym.value;
+
+ /* Coded in 1..8 following bytes. */
+ if (trie->sym.sym_type == mmo_data_sym)
+ {
+ control |= MMO3_DATA;
+ value -= (bfd_vma) 0x20 << 56;
+ }
+
+ do
+ {
+ value >>= 8;
+ control++;
+ }
+ while (value != 0);
+ }
+ }
+
+ /* The control byte is output before recursing. */
+ mmo_write_byte (abfd, control);
+
+ mmo_internal_3_dump (abfd, trie->left);
+
+ if (control & MMO3_SYMBITS)
+ {
+ mmo_write_byte (abfd, trie->symchar);
+
+ if (trie->sym.name != NULL)
+ {
+ if (trie->sym.sym_type == mmo_reg_sym)
+ mmo_write_byte (abfd, trie->sym.value);
+ else if (trie->sym.sym_type == mmo_undef_sym)
+ {
+ mmo_write_byte (abfd, 0);
+ mmo_write_byte (abfd, 0);
+ }
+ else
+ {
+ bfd_vma value = trie->sym.value;
+
+ bfd_byte byte_n = control & 15;
+
+ /* Coded in 1..8 following bytes. Note that the value is
+ shifted out big-endian. */
+ if (trie->sym.sym_type == mmo_data_sym)
+ {
+ value -= (bfd_vma) 0x20 << 56;
+ byte_n -= 8;
+ }
+
+ do
+ {
+ mmo_write_byte (abfd, (value >> ((byte_n - 1) * 8)) & 0xff);
+ byte_n--;
+ }
+ while (byte_n != 0);
+ }
+
+ mmo_beb128_out (abfd, trie->sym.serno, 128);
+ }
+ mmo_internal_3_dump (abfd, trie->middle);
+ }
+ mmo_internal_3_dump (abfd, trie->right);
+}
+
+/* Write symbols, either in mmo format or hidden in a lop_spec 80 section.
+ Write the lop_end terminator also. */
+
+static boolean
+mmo_write_symbols_and_terminator (abfd)
+ bfd *abfd;
+{
+ int count = bfd_get_symcount (abfd);
+ asymbol *fakemain[2];
+ asymbol **table;
+ int serno = 2;
+ struct mmo_symbol_trie root;
+ int trie_len;
+ int i;
+ bfd_byte buf[4];
+
+ /* Create a symbol for "Main". */
+ asymbol *mainsym = bfd_make_empty_symbol (abfd);
+
+ mainsym->flags = BSF_GLOBAL;
+ mainsym->value = bfd_get_start_address (abfd);
+ mainsym->name = MMIX_START_SYMBOL_NAME;
+ mainsym->section = bfd_abs_section_ptr;
+ fakemain[0] = mainsym;
+ fakemain[1] = NULL;
+
+ memset (&root, 0, sizeof (root));
+
+ /* Make all symbols take a left turn. */
+ root.symchar = 0xff;
+
+ /* There must always be a ":Main", so we'll add one
+ if there are no symbols. */
+ if (count == 0)
+ {
+ table = fakemain;
+ count = 1;
+ }
+ else
+ table = bfd_get_outsymbols (abfd);
+
+ for (i = 0; i < count && table[i] != NULL; i++)
+ {
+ asymbol *s = table[i];
+
+ /* It's not enough to consult bfd_is_local_label, since it does not
+ mean "local" in the sense of linkable-and-observable-after-link.
+ Let's just check the BSF_GLOBAL flag.
+
+ Also, don't export symbols with characters not in the allowed set. */
+ if ((s->flags & (BSF_DEBUGGING|BSF_GLOBAL)) == BSF_GLOBAL
+ && strspn (s->name,
+ valid_mmo_symbol_character_set) == strlen (s->name))
+ {
+ struct mmo_symbol sym;
+ memset (&sym, 0, sizeof (sym));
+
+ sym.name = s->name;
+ sym.value =
+ s->value
+ + s->section->output_section->vma
+ + s->section->output_offset;
+
+ if (bfd_is_und_section (s->section))
+ sym.sym_type = mmo_undef_sym;
+ else if (strcmp (s->section->name, MMO_DATA_SECTION_NAME) == 0
+ /* The encoding of data symbols require that the "rest"
+ of the value fits in 6 bytes, so the upper two bytes
+ must be 0x2000. All other symbols get to be the
+ absolute type. */
+ && (sym.value >> 48) == 0x2000)
+ sym.sym_type = mmo_data_sym;
+ else if (strcmp (s->section->name, MMIX_REG_SECTION_NAME) == 0)
+ sym.sym_type = mmo_reg_sym;
+ else if (strcmp (s->section->name,
+ MMIX_REG_CONTENTS_SECTION_NAME) == 0)
+ {
+ sym.sym_type = mmo_reg_sym;
+ sym.value /= 8;
+ }
+ else
+ sym.sym_type = mmo_abs_sym;
+
+ /* FIXME: We assume the order of the received symbols is an
+ ordered mapping of the serial numbers. This is not
+ necessarily true if we e.g. objcopy a mmo file to another and
+ there are gaps in the numbering. Note sure if this can
+ happen. Not sure what to do. */
+ /* Make sure Main has serial number 1; others start at 2. */
+ if (strcmp (s->name, MMIX_START_SYMBOL_NAME) == 0)
+ {
+ sym.serno = 1;
+
+ /* Check that the value assigned to :Main is the same as the
+ entry address. The default linker script asserts this.
+ This is as good a place as any to check this consistency. */
+ if (sym.value != bfd_get_start_address (abfd))
+ {
+ /* Arbitrary buffer to hold the printable representation
+ of a vma. */
+ char vmas_main[40];
+ char vmas_start[40];
+ bfd_vma vma_start = bfd_get_start_address (abfd);
+
+ sprintf_vma (vmas_main, s->value);
+ sprintf_vma (vmas_start, vma_start);
+
+ (*_bfd_error_handler)
+ (_("%s: Bad symbol definition: `Main' set to %s rather\
+ than the start address %s\n"),
+ bfd_get_filename (abfd), vmas_main, vmas_start);
+ bfd_set_error (bfd_error_bad_value);
+ return false;
+ }
+ }
+ else
+ sym.serno = serno++;
+
+ if (! mmo_internal_add_3_sym (abfd, &root, &sym))
+ return false;
+ }
+ }
+
+ /* Change the root node to be a ":"-prefix. */
+ root.symchar = ':';
+ root.middle = root.left;
+ root.right = NULL;
+ root.left = NULL;
+
+ /* We have to find out if we can fit the whole symbol table in the mmo
+ symtab. It would be bad to assume we can always fit it in 262144
+ bytes. If we can't, just leave the Main symbol. */
+ trie_len = (mmo_internal_3_length (abfd, &root) + 3)/4;
+
+ if (trie_len > 0xffff)
+ {
+ /* Test this code by using a lower limit in the test above and check
+ that the single "Main" symbol is emitted and handled properly.
+ There's no specific test-case. */
+ struct mmo_symbol sym;
+
+ (*_bfd_error_handler)
+ (_("%s: warning: symbol table too large for mmo, larger than 65535\
+ 32-bit words: %d. Only `Main' will be emitted.\n"),
+ bfd_get_filename (abfd), trie_len);
+
+ memset (&sym, 0, sizeof (sym));
+ sym.sym_type = mmo_abs_sym;
+ sym.name = MMIX_START_SYMBOL_NAME;
+ sym.serno = 1;
+ sym.value = bfd_get_start_address (abfd);
+
+ /* Then patch up a symbol table to be just the ":Main" symbol. */
+ memset (&root, 0, sizeof (root));
+ root.left = root.middle;
+ root.symchar = 0xff;
+ root.middle = NULL;
+ root.right = NULL;
+
+ if (! mmo_internal_add_3_sym (abfd, &root, &sym))
+ return false;
+
+ root.symchar = ':';
+ root.middle = root.left;
+ root.right = NULL;
+ root.left = NULL;
+
+ trie_len = (mmo_internal_3_length (abfd, &root) + 3)/4;
+ }
+
+ /* Reset the written-bytes counter. */
+ abfd->tdata.mmo_data->byte_no = 0;
+
+ /* Put out the lop_stab mark. */
+ bfd_put_32 (abfd, (LOP << 24) | (LOP_STAB << 16), buf);
+ if (bfd_bwrite (buf, 4, abfd) != 4)
+ return false;
+
+ /* Dump out symbols. */
+ mmo_internal_3_dump (abfd, &root);
+
+ if (trie_len != (abfd->tdata.mmo_data->byte_no + 3)/4)
+ {
+ /* I haven't seen this trig. It seems no use claiming this case
+ isn't debugged and abort if we get here. Instead emit a
+ diagnostic and fail "normally". */
+ (*_bfd_error_handler)
+ (_("%s: internal error, symbol table changed size from %d to %d\
+ words\n"),
+ bfd_get_filename (abfd), trie_len,
+ (abfd->tdata.mmo_data->byte_no + 3)/4);
+ bfd_set_error (bfd_error_bad_value);
+ return false;
+ }
+
+ /* Dump out remaining bytes in the buffer and handle I/O errors by
+ propagating errors. */
+ if ((abfd->tdata.mmo_data->byte_no % 4) != 0
+ || abfd->tdata.mmo_data->have_error)
+ {
+ memset (abfd->tdata.mmo_data->buf + (abfd->tdata.mmo_data->byte_no % 4),
+ 0, 4 - (abfd->tdata.mmo_data->byte_no % 4));
+
+ if (abfd->tdata.mmo_data->have_error
+ || bfd_bwrite (abfd->tdata.mmo_data->buf, 4, abfd) != 4)
+ return false;
+ }
+
+ bfd_put_32 (abfd, (LOP << 24) | (LOP_END << 16) | trie_len, buf);
+ return bfd_bwrite (buf, 4, abfd) == 4;
+}
+
+/* Write section unless it is the register contents section. For that, we
+ instead store the section in the supplied pointer. This function is
+ used through bfd_map_over_sections. */
+
+static void
+mmo_write_section_unless_reg_contents (abfd, sec, p)
+ bfd *abfd;
+ asection *sec;
+ PTR p;
+{
+ struct mmo_write_sec_info *infop = (struct mmo_write_sec_info *) p;
+
+ if (infop->retval == false)
+ return;
+
+ if (strcmp (sec->name, MMIX_REG_CONTENTS_SECTION_NAME) == 0)
+ {
+ infop->reg_section = sec;
+ return;
+ }
+
+ /* Exclude the convenience register section. */
+ if (strcmp (sec->name, MMIX_REG_SECTION_NAME) == 0)
+ {
+ if (bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS)
+ {
+ /* Make sure it hasn't got contents. It seems impossible to
+ make it carry contents, so we don't have a test-case for
+ this. */
+ (*_bfd_error_handler)
+ (_("%s: internal error, internal register section %s had\
+ contents\n"),
+ bfd_get_filename (abfd), sec->name);
+ bfd_set_error (bfd_error_bad_value);
+ infop->retval = false;
+ return;
+ }
+
+ return;
+ }
+
+ infop->retval = mmo_internal_write_section (abfd, sec);
+}
+
+/* Do the actual output of a file. Assumes mmo_set_section_contents is
+ already called. */
+
+static boolean
+mmo_write_object_contents (abfd)
+ bfd *abfd;
+{
+ struct mmo_write_sec_info wsecinfo;
+
+ /* First, there are a few words of preamble. */
+ if (! mmo_internal_write_header (abfd))
+ return false;
+
+ wsecinfo.reg_section = NULL;
+ wsecinfo.retval = true;
+
+ bfd_map_over_sections (abfd, mmo_write_section_unless_reg_contents,
+ (PTR) &wsecinfo);
+
+ if (wsecinfo.retval == false)
+ return false;
+
+ if (wsecinfo.reg_section != NULL)
+ {
+ asection *sec = wsecinfo.reg_section;
+ unsigned int z = (unsigned int) (sec->vma / 8);
+
+ /* Registers 0..31 must not be global. Do sanity check on the "vma"
+ of the register contents section and check that it corresponds to
+ the length of the section. */
+ if (z < 32 || z >= 255 || (sec->vma & 7) != 0
+ || sec->vma != 256 * 8 - sec->_raw_size - 8)
+ {
+ bfd_set_error (bfd_error_bad_value);
+
+ if (sec->_raw_size == 0)
+ /* There must always be at least one such register. */
+ (*_bfd_error_handler)
+ (_("%s: no initialized registers; section length 0\n"),
+ bfd_get_filename (abfd));
+ else if (sec->vma > (256 - 32) * 8)
+ /* Provide better error message for the case of too many
+ global registers. */
+ (*_bfd_error_handler)
+ (_("%s: too many initialized registers; section length %ld\n"),
+ bfd_get_filename (abfd),
+ (long) sec->_raw_size);
+ else
+ (*_bfd_error_handler)
+ (_("%s: invalid start address for initialized registers of\
+ length %ld: 0x%lx%08lx\n"),
+ bfd_get_filename (abfd),
+ (long) sec->_raw_size,
+ (unsigned long) (sec->vma >> 32), (unsigned long) (sec->vma));
+
+ return false;
+ }
+
+ if (! mmo_internal_write_post (abfd, z, sec))
+ return false;
+ }
+ else
+ if (! mmo_internal_write_post (abfd, 255, NULL))
+ return false;
+
+ return mmo_write_symbols_and_terminator (abfd);
+}
+
+/* Return the size of a NULL pointer, so we support linking in an mmo
+ object. */
+
+static long
+mmo_get_reloc_upper_bound (abfd, sec)
+ bfd *abfd ATTRIBUTE_UNUSED;
+ asection *sec ATTRIBUTE_UNUSED;
+{
+ return sizeof (PTR);
+}
+
+/* Similarly canonicalize relocs to empty, filling in the terminating NULL
+ pointer. */
+
+long
+mmo_canonicalize_reloc (abfd, section, relptr, symbols)
+ bfd *abfd ATTRIBUTE_UNUSED;
+ sec_ptr section ATTRIBUTE_UNUSED;
+ arelent **relptr;
+ asymbol **symbols ATTRIBUTE_UNUSED;
+{
+ *relptr = NULL;
+ return 0;
+}
+
+/* If there's anything in particular in a mmo bfd that we want to free,
+ make this a real function. Only do this if you see major memory
+ thrashing; zealous free:ing will cause unwanted behavior, especially if
+ you "free" memory allocated with "bfd_alloc", or even "bfd_release" a
+ block allocated with "bfd_alloc"; they're really allocated from an
+ obstack, and we don't know what was allocated there since this
+ particular allocation. */
+
+#define mmo_close_and_cleanup _bfd_generic_close_and_cleanup
+#define mmo_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
+
+/* Perhaps we need to adjust this one; mmo labels (originally) without a
+ leading ':' might more appropriately be called local. */
+#define mmo_bfd_is_local_label_name bfd_generic_is_local_label_name
+
+/* Is this one really used or defined by anyone? */
+#define mmo_get_lineno _bfd_nosymbols_get_lineno
+
+/* FIXME: We can do better on this one, if we have a dwarf2 .debug_line
+ section or if MMO line numbers are implemented. */
+#define mmo_find_nearest_line _bfd_nosymbols_find_nearest_line
+#define mmo_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
+#define mmo_read_minisymbols _bfd_generic_read_minisymbols
+#define mmo_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
+
+#define mmo_get_section_contents_in_window \
+ _bfd_generic_get_section_contents_in_window
+#define mmo_bfd_get_relocated_section_contents \
+ bfd_generic_get_relocated_section_contents
+#define mmo_bfd_gc_sections bfd_generic_gc_sections
+#define mmo_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
+#define mmo_bfd_link_add_symbols _bfd_generic_link_add_symbols
+#define mmo_bfd_final_link _bfd_generic_final_link
+#define mmo_bfd_link_split_section _bfd_generic_link_split_section
+
+/* Strictly speaking, only MMIX uses this restricted format, but let's not
+ stop anybody from shooting themselves in the foot. */
+#define mmo_set_arch_mach bfd_default_set_arch_mach
+#define mmo_bfd_relax_section bfd_generic_relax_section
+#define mmo_bfd_merge_sections bfd_generic_merge_sections
+
+/* objcopy will be upset if we return -1 from bfd_get_reloc_upper_bound by
+ using BFD_JUMP_TABLE_RELOCS (_bfd_norelocs) rather than 0. FIXME: Most
+ likely a bug in the _bfd_norelocs definition.
+
+ On the other hand, we smuggle in an mmo object (because setting up ELF
+ is too cumbersome) when linking (from other formats, presumably ELF) to
+ represent the g255 entry. We need to link that object, so need to say
+ it has no relocs. Upper bound for the size of the relocation table is
+ the size of a NULL pointer, and we support "canonicalization" for that
+ pointer. */
+#define mmo_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
+
+/* We want to copy time of creation, otherwise we'd use
+ BFD_JUMP_TABLE_COPY (_bfd_generic). */
+#define mmo_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
+#define mmo_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
+#define mmo_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
+#define mmo_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
+#define mmo_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
+
+CONST bfd_target bfd_mmo_vec =
+{
+ "mmo", /* name */
+ bfd_target_mmo_flavour,
+ BFD_ENDIAN_BIG, /* target byte order */
+ BFD_ENDIAN_BIG, /* target headers byte order */
+
+ /* FIXME: Might need adjustments. */
+ (HAS_RELOC | EXEC_P | /* object flags */
+ HAS_LINENO | HAS_DEBUG |
+ HAS_SYMS | HAS_LOCALS | WP_TEXT),
+
+ /* FIXME: Might need adjustments. */
+ (SEC_CODE | SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
+ | SEC_READONLY | SEC_EXCLUDE | SEC_DEBUGGING | SEC_IN_MEMORY),
+ /* section flags */
+ 0, /* leading underscore */
+ ' ', /* ar_pad_char */
+ 16, /* ar_max_namelen */
+ bfd_getb64, bfd_getb_signed_64, bfd_putb64,
+ bfd_getb32, bfd_getb_signed_32, bfd_putb32,
+ bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
+ bfd_getb64, bfd_getb_signed_64, bfd_putb64,
+ bfd_getb32, bfd_getb_signed_32, bfd_putb32,
+ bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
+
+ {
+ _bfd_dummy_target,
+ mmo_object_p, /* bfd_check_format */
+ _bfd_dummy_target,
+ _bfd_dummy_target,
+ },
+ {
+ bfd_false,
+ mmo_mkobject,
+ bfd_false,
+ bfd_false,
+ },
+ { /* bfd_write_contents */
+ bfd_false,
+ mmo_write_object_contents,
+ bfd_false,
+ bfd_false,
+ },
+
+ BFD_JUMP_TABLE_GENERIC (mmo),
+ BFD_JUMP_TABLE_COPY (mmo),
+ BFD_JUMP_TABLE_CORE (_bfd_nocore),
+ BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
+ BFD_JUMP_TABLE_SYMBOLS (mmo),
+ /* We have to provide a valid method for getting relocs, returning zero,
+ so we can't say BFD_JUMP_TABLE_RELOCS (_bfd_norelocs). */
+ BFD_JUMP_TABLE_RELOCS (mmo),
+ BFD_JUMP_TABLE_WRITE (mmo),
+ BFD_JUMP_TABLE_LINK (mmo),
+ BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
+
+ NULL,
+
+ NULL
+};