bfd/mmo.c

   1 /* BFD back-end for mmo objects (MMIX-specific object-format).
   2    Copyright 2001
   3    Free Software Foundation, Inc.
   4    Written by Hans-Peter Nilsson (hp@bitrange.com).
   5    Infrastructure and other bits originally copied from srec.c and
   6    binary.c.
   7
   8 This file is part of BFD, the Binary File Descriptor library.
   9
  10 This program is free software; you can redistribute it and/or modify
  11 it under the terms of the GNU General Public License as published by
  12 the Free Software Foundation; either version 2 of the License, or
  13 (at your option) any later version.
  14
  15 This program is distributed in the hope that it will be useful,
  16 but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 GNU General Public License for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with this program; if not, write to the Free Software
  22 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  23
  24 /*
  25 SECTION
  26         mmo backend
  27
  28         The mmo object format is used exclusively together with Professor
  29         Donald E.@: Knuth's educational 64-bit processor MMIX.  The simulator
  30         @emph{mmix} which is available at
  31         @emph{http://www-cs-faculty.stanford.edu/~knuth/programs/mmix.tar.gz}
  32         understands this format.  That package also includes a combined
  33         assembler and linker called @emph{mmixal}.  The mmo format has
  34         no advantages feature-wise compared to e.g. ELF.  It is a simple
  35         non-relocatable object format with no support for archives or
  36         debugging information, except for symbol value information and
  37         line numbers (which is not yet implemented in BFD).  See
  38         @emph{http://www-cs-faculty.stanford.edu/~knuth/mmix.html} for more
  39         information about MMIX.  The ELF format is used for intermediate
  40         object files in the BFD implementation.
  41
  42 @c We want to xref the symbol table node.  A feature in "chew"
  43 @c requires that "commands" do not contain spaces in the
  44 @c arguments.  Hence the hyphen in "Symbol-table".
  45 @menu
  46 @* File layout::
  47 @* Symbol-table::
  48 @* mmo section mapping::
  49 @end menu
  50
  51 INODE
  52 File layout, Symbol-table, mmo, mmo
  53 SUBSECTION
  54         File layout
  55
  56         The mmo file contents is not partitioned into named sections as
  57         with e.g.@: ELF.  Memory areas is formed by specifying the
  58         location of the data that follows.  Only the memory area
  59         @samp{0x0000@dots{}00} to @samp{0x01ff@dots{}ff} is executable, so
  60         it is used for code (and constants) and the area
  61         @samp{0x2000@dots{}00} to @samp{0x20ff@dots{}ff} is used for
  62         writable data.  @xref{mmo section mapping}.
  63
  64         Contents is entered as 32-bit words, xor:ed over previous
  65         contents, always zero-initialized.  A word that starts with the
  66         byte @samp{0x98} forms a command called a @samp{lopcode}, where
  67         the next byte distinguished between the thirteen lopcodes.  The
  68         two remaining bytes, called the @samp{Y} and @samp{Z} fields, or
  69         the @samp{YZ} field (a 16-bit big-endian number), are used for
  70         various purposes different for each lopcode.  As documented in
  71         @emph{http://www-cs-faculty.stanford.edu/~knuth/mmixal-intro.ps.gz},
  72         the lopcodes are:
  73
  74         There is provision for specifying ``special data'' of 65536
  75         different types.  We use type 80 (decimal), arbitrarily chosen the
  76         same as the ELF <<e_machine>> number for MMIX, filling it with
  77         section information normally found in ELF objects. @xref{mmo
  78         section mapping}.
  79
  80         @table @code
  81         @item lop_quote
  82         0x98000001.  The next word is contents, regardless of whether it
  83         starts with 0x98 or not.
  84
  85         @item lop_loc
  86         0x9801YYZZ, where @samp{Z} is 1 or 2.  This is a location
  87         directive, setting the location for the next data to the next
  88         32-bit word (for @math{Z = 1}) or 64-bit word (for @math{Z = 2}),
  89         plus @math{Y * 2^56}.  Normally @samp{Y} is 0 for the text segment
  90         and 2 for the data segment.
  91
  92         @item lop_skip
  93         0x9802YYZZ.  Increase the current location by @samp{YZ} bytes.
  94
  95         @item lop_fixo
  96         0x9803YYZZ, where @samp{Z} is 1 or 2.  Store the current location
  97         as 64 bits into the location pointed to by the next 32-bit
  98         (@math{Z = 1}) or 64-bit (@math{Z = 2}) word, plus @math{Y *
  99         2^56}.
 100
 101         @item lop_fixr
 102         0x9804YYZZ.  @samp{YZ} is stored into the current location plus
 103         @math{2 - 4 * YZ}.
 104
 105         @item lop_fixrx
 106         0x980500ZZ.  @samp{Z} is 16 or 24.  A value @samp{L} derived from
 107         the following 32-bit word are used in a manner similar to
 108         @samp{YZ} in lop_fixr: it is xor:ed into the current location
 109         minus @math{4 * L}.  The first byte of the word is 0 or 1.  If it
 110         is 1, then @math{L = (@var{lowest 24 bits of word}) - 2^Z}, if 0,
 111         then @math{L = (@var{lowest 24 bits of word})}.
 112
 113         @item lop_file
 114         0x9806YYZZ.  @samp{Y} is the file number, @samp{Z} is count of
 115         32-bit words.  Set the file number to @samp{Y} and the line
 116         counter to 0.  The next @math{Z * 4} bytes contain the file name,
 117         padded with zeros if the count is not a multiple of four.  The
 118         same @samp{Y} may occur multiple times, but @samp{Z} must be 0 for
 119         all but the first occurrence.
 120
 121         @item lop_line
 122         0x9807YYZZ.  @samp{YZ} is the line number.  Together with
 123         lop_file, it forms the source location for the next 32-bit word.
 124         Note that for each non-lopcode 32-bit word, line numbers are
 125         assumed incremented by one.
 126
 127         @item lop_spec
 128         0x9808YYZZ.  @samp{YZ} is the type number.  Data until the next
 129         lopcode other than lop_quote forms special data of type @samp{YZ}.
 130         @xref{mmo section mapping}.
 131
 132         Other types than 80, (or type 80 with a content that does not
 133         parse) is stored in sections named <<.MMIX.spec_data.@var{n}>>
 134         where @var{n} is the @samp{YZ}-type.  The flags for such a
 135         sections say not to allocate or load the data.  The vma is 0.
 136         Contents of multiple occurrences of special data @var{n} is
 137         concatenated to the data of the previous lop_spec @var{n}s.  The
 138         location in data or code at which the lop_spec occurred is lost.
 139
 140         @item lop_pre
 141         0x980901ZZ.  The first lopcode in a file.  The @samp{Z} field forms the
 142         length of header information in 32-bit words, where the first word
 143         tells the time in seconds since @samp{00:00:00 GMT Jan 1 1970}.
 144
 145         @item lop_post
 146         0x980a00ZZ.  @math{Z > 32}.  This lopcode follows after all
 147         content-generating lopcodes in a program.  The @samp{Z} field
 148         denotes the value of @samp{rG} at the beginning of the program.
 149         The following @math{256 - Z} big-endian 64-bit words are loaded
 150         into global registers @samp{$G} @dots{} @samp{$255}.
 151
 152         @item lop_stab
 153         0x980b0000.  The next-to-last lopcode in a program.  Must follow
 154         immediately after the lop_post lopcode and its data.  After this
 155         lopcode follows all symbols in a compressed format
 156         (@pxref{Symbol-table}).
 157
 158         @item lop_end
 159         0x980cYYZZ.  The last lopcode in a program.  It must follow the
 160         lop_stab lopcode and its data.  The @samp{YZ} field contains the
 161         number of 32-bit words of symbol table information after the
 162         preceding lop_stab lopcode.
 163         @end table
 164
 165         Note that the lopcode "fixups"; <<lop_fixr>>, <<lop_fixrx>> and
 166         <<lop_fixo>> are not generated by BFD, but are handled.  They are
 167         generated by <<mmixal>>.
 168
 169 EXAMPLE
 170         This trivial one-label, one-instruction file:
 171
 172 | :Main TRAP 1,2,3
 173
 174         can be represented this way in mmo:
 175
 176 | 0x98090101 - lop_pre, one 32-bit word with timestamp.
 177 | <timestamp>
 178 | 0x98010002 - lop_loc, text segment, using a 64-bit address.
 179 |              Note that mmixal does not emit this for the file above.
 180 | 0x00000000 - Address, high 32 bits.
 181 | 0x00000000 - Address, low 32 bits.
 182 | 0x98060002 - lop_file, 2 32-bit words for file-name.
 183 | 0x74657374 - "test"
 184 | 0x2e730000 - ".s\0\0"
 185 | 0x98070001 - lop_line, line 1.
 186 | 0x00010203 - TRAP 1,2,3
 187 | 0x980a00ff - lop_post, setting $255 to 0.
 188 | 0x00000000
 189 | 0x00000000
 190 | 0x980b0000 - lop_stab for ":Main" = 0, serial 1.
 191 | 0x203a4040   @xref{Symbol-table}.
 192 | 0x10404020
 193 | 0x4d206120
 194 | 0x69016e00
 195 | 0x81000000
 196 | 0x980c0005 - lop_end; symbol table contained five 32-bit words.  */
 197
 198 #include "bfd.h"
 199 #include "sysdep.h"
 200 #include "libbfd.h"
 201 #include "libiberty.h"
 202 #include "elf/mmix.h"
 203 #include "opcode/mmix.h"
 204 #include <ctype.h>
 205
 206 #define LOP 0x98
 207 #define LOP_QUOTE 0
 208 #define LOP_LOC 1
 209 #define LOP_SKIP 2
 210 #define LOP_FIXO 3
 211 #define LOP_FIXR 4
 212 #define LOP_FIXRX 5
 213 #define LOP_FILE 6
 214 #define LOP_LINE 7
 215 #define LOP_SPEC 8
 216 #define LOP_PRE 9
 217 #define LOP_POST 10
 218 #define LOP_STAB 11
 219 #define LOP_END 12
 220
 221 #define LOP_QUOTE_NEXT ((LOP << 24) | (LOP_QUOTE << 16) | 1)
 222 #define SPEC_DATA_SECTION 80
 223 #define LOP_SPEC_SECTION \
 224  ((LOP << 24) | (LOP_SPEC << 16) | SPEC_DATA_SECTION)
 225
 226 /* Must be a power of two.  If you change this to be >= 64k, you need a
 227    new test-case; the ld test b-loc64k.d touches chunk-size problem areas.  */
 228 #define MMO_SEC_CONTENTS_CHUNK_SIZE (1 << 15)
 229
 230 /* An arbitrary number for the maximum length section name size.  */
 231 #define MAX_SECTION_NAME_SIZE (1024 * 1024)
 232
 233 /* A quite arbitrary number for the maximum length section size.  */
 234 #define MAX_ARTIFICIAL_SECTION_SIZE (1024 * 1024 * 1024)
 235
 236 #define MMO3_WCHAR 0x80
 237 #define MMO3_LEFT 0x40
 238 #define MMO3_MIDDLE 0x20
 239 #define MMO3_RIGHT 0x10
 240 #define MMO3_TYPEBITS 0xf
 241 #define MMO3_REGQUAL_BITS 0xf
 242 #define MMO3_UNDEF 2
 243 #define MMO3_DATA 8
 244 #define MMO3_SYMBITS 0x2f
 245
 246 /* Put these everywhere in new code.  */
 247 #define FATAL_DEBUG                                             \
 248  _bfd_abort (__FILE__, __LINE__,                                \
 249              "Internal: Non-debugged code (test-case missing)")
 250
 251 #define BAD_CASE(x)                             \
 252  _bfd_abort (__FILE__, __LINE__,                \
 253              "bad case for " #x)
 254
 255 enum mmo_sym_type { mmo_reg_sym, mmo_undef_sym, mmo_data_sym, mmo_abs_sym};
 256
 257 /* When scanning the mmo file, a linked list of mmo_symbol
 258    structures is built to represent the symbol table (if there is
 259    one).  */
 260
 261 struct mmo_symbol
 262   {
 263     struct mmo_symbol *next;
 264     CONST char *name;
 265     bfd_vma value;
 266     enum mmo_sym_type sym_type;
 267     unsigned int serno;
 268   };
 269
 270 struct mmo_data_list_struct
 271   {
 272     struct mmo_data_list_struct *next;
 273     bfd_vma where;
 274     bfd_size_type size;
 275     bfd_size_type allocated_size;
 276     bfd_byte data[1];
 277   };
 278
 279 typedef struct mmo_data_list_struct mmo_data_list_type;
 280
 281 struct mmo_symbol_trie
 282   {
 283     struct mmo_symbol_trie *left;
 284     struct mmo_symbol_trie *right;
 285     struct mmo_symbol_trie *middle;
 286
 287     bfd_byte symchar;
 288
 289     /* A zero name means there's nothing here.  */
 290     struct mmo_symbol sym;
 291   };
 292
 293 /* The mmo tdata information.  */
 294
 295 struct mmo_data_struct
 296   {
 297     struct mmo_symbol *symbols;
 298     struct mmo_symbol *symtail;
 299     asymbol *csymbols;
 300
 301     /* File representation of time (NULL) when this file was created.  */
 302     bfd_byte created[4];
 303
 304     /* When we're reading bytes recursively, check this occasionally.
 305        Also holds write errors.  */
 306     boolean have_error;
 307
 308     /* Max symbol length that may appear in the lop_stab table.  Note that
 309        this table might just hold a subset of symbols for not-really large
 310        programs, as it can only be 65536 * 4 bytes large.  */
 311     int max_symbol_length;
 312
 313     /* Here's the symbol we build in lop_stab.  */
 314     char *lop_stab_symbol;
 315
 316     /* Index into lop_stab_symbol for the next character when parsing the
 317        symbol information.  */
 318     int symbol_position;
 319
 320     /* When creating arbitrary sections, we need to count section numbers.  */
 321     int sec_no;
 322
 323     /* When writing or reading byte-wise, we need to count the bytes
 324        within a 32-bit word.  */
 325     int byte_no;
 326
 327     /* We also need a buffer to hold the bytes we count reading or writing.  */
 328     bfd_byte buf[4];
 329   };
 330
 331 typedef struct mmo_data_struct tdata_type;
 332
 333 struct mmo_section_data_struct
 334   {
 335     mmo_data_list_type *head;
 336     mmo_data_list_type *tail;
 337   };
 338
 339 /* These structures are used in bfd_map_over_sections constructs.  */
 340
 341 /* Used when writing out sections; all but the register contents section
 342    which is stored in reg_section.  */
 343 struct mmo_write_sec_info
 344   {
 345     asection *reg_section;
 346     boolean retval;
 347   };
 348
 349 /* Used when trying to find a section corresponding to addr.  */
 350 struct mmo_find_sec_info
 351   {
 352     asection *sec;
 353     bfd_vma addr;
 354   };
 355
 356 static boolean mmo_bfd_copy_private_bfd_data PARAMS ((bfd *, bfd *));
 357 static void mmo_write_section_unless_reg_contents
 358  PARAMS ((bfd *, asection *, PTR));
 359 static void mmo_find_sec_w_addr PARAMS ((bfd *, asection *, PTR));
 360 static void mmo_find_sec_w_addr_grow PARAMS ((bfd *, asection *, PTR));
 361 static asection *mmo_make_section PARAMS ((bfd *, CONST char *));
 362 static void mmo_get_symbol_info PARAMS ((bfd *, asymbol *, symbol_info *));
 363 static void mmo_print_symbol
 364  PARAMS ((bfd *, PTR, asymbol *, bfd_print_symbol_type));
 365 static void mmo_init PARAMS ((void));
 366 static boolean mmo_mkobject PARAMS ((bfd *));
 367 static boolean mmo_scan PARAMS ((bfd *));
 368 static asection *mmo_decide_section PARAMS ((bfd *, bfd_vma));
 369 static asection *mmo_get_generic_spec_data_section PARAMS ((bfd *, int));
 370 static asection *mmo_get_spec_section PARAMS ((bfd *, int));
 371 static INLINE bfd_byte *mmo_get_loc PARAMS ((asection *, bfd_vma, int));
 372 static void mmo_xore_64 PARAMS ((asection *, bfd_vma vma, bfd_vma value));
 373 static void mmo_xore_32 PARAMS ((asection *, bfd_vma vma, unsigned int));
 374 static void mmo_xore_16 PARAMS ((asection *, bfd_vma vma, unsigned int));
 375 static CONST bfd_target *mmo_object_p PARAMS ((bfd *));
 376 static void mmo_map_set_sizes PARAMS ((bfd *, asection *, PTR));
 377 static boolean mmo_get_symbols PARAMS ((bfd *));
 378 static boolean mmo_create_symbol PARAMS ((bfd *, CONST char *, bfd_vma,
 379                                           enum mmo_sym_type, unsigned int));
 380 static boolean mmo_get_section_contents
 381   PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type));
 382 static long mmo_get_symtab_upper_bound PARAMS ((bfd *));
 383 static long mmo_get_symtab PARAMS ((bfd *, asymbol **));
 384 static asymbol *mmo_make_empty_symbol PARAMS ((bfd *));
 385 static void mmo_get_symbol_info PARAMS ((bfd *, asymbol *, symbol_info *));
 386 static void mmo_print_symbol PARAMS ((bfd *, PTR, asymbol *,
 387                                       bfd_print_symbol_type));
 388 static boolean mmo_set_section_contents
 389   PARAMS ((bfd *, sec_ptr, PTR, file_ptr, bfd_size_type));
 390 static int mmo_sizeof_headers PARAMS ((bfd *, boolean));
 391 static long mmo_get_reloc_upper_bound PARAMS ((bfd *, asection *));
 392
 393 static boolean mmo_internal_write_header PARAMS ((bfd *));
 394 static boolean mmo_internal_write_post PARAMS ((bfd *, int, asection *));
 395 static boolean mmo_internal_add_3_sym
 396  PARAMS ((bfd *, struct mmo_symbol_trie *, CONST struct mmo_symbol *));
 397 static unsigned int mmo_internal_3_length
 398  PARAMS ((bfd *, struct mmo_symbol_trie *));
 399 static void mmo_internal_3_dump
 400  PARAMS ((bfd *, struct mmo_symbol_trie *));
 401 static void mmo_beb128_out PARAMS ((bfd *, int, int));
 402 static boolean mmo_internal_write_section
 403   PARAMS ((bfd *, asection *));
 404 static void mmo_write_tetra PARAMS ((bfd *, unsigned int));
 405 static void mmo_write_tetra_raw PARAMS ((bfd *, unsigned int));
 406 static void mmo_write_octa PARAMS ((bfd *, bfd_vma));
 407 static void mmo_write_octa_raw PARAMS ((bfd *, bfd_vma));
 408 static boolean mmo_write_chunk
 409   PARAMS ((bfd *, CONST bfd_byte *, unsigned int));
 410 static boolean mmo_write_loc_chunk
 411   PARAMS ((bfd *, bfd_vma, CONST bfd_byte *, unsigned int));
 412 static boolean mmo_write_chunk_list PARAMS ((bfd *, mmo_data_list_type *));
 413 static boolean mmo_write_loc_chunk_list
 414   PARAMS ((bfd *, mmo_data_list_type *));
 415 static boolean mmo_write_symbols_and_terminator PARAMS ((bfd *));
 416 static flagword mmo_sec_flags_from_bfd_flags PARAMS ((flagword));
 417 static flagword bfd_sec_flags_from_mmo_flags PARAMS ((flagword));
 418 static bfd_byte mmo_get_byte PARAMS ((bfd *));
 419 static void mmo_write_byte PARAMS ((bfd *, bfd_byte));
 420 static boolean mmo_new_section_hook PARAMS ((bfd *, asection *));
 421 static int mmo_sort_mmo_symbols PARAMS ((CONST PTR, CONST PTR));
 422 static boolean mmo_write_object_contents PARAMS ((bfd *));
 423 static long mmo_canonicalize_reloc
 424   PARAMS ((bfd *, sec_ptr, arelent **, asymbol **));
 425
 426 /* Global "const" variables initialized once.  Must not depend on
 427    particular input or caller; put such things into the bfd or elsewhere.
 428    Look ma, no static per-invocation data!  */
 429
 430 static unsigned
 431 char valid_mmo_symbol_character_set[/* A-Z a-z (we assume consecutive
 432                                        codes; sorry EBCDIC:ers!).  */
 433                                     + 'Z' - 'A' + 1 + 'z' - 'a' + 1
 434                                     /* Digits.  */
 435                                     + 10
 436                                     /* ':' and '_'.  */
 437                                     + 1 + 1
 438                                     /* Codes higher than 126.  */
 439                                     + 256 - 126
 440                                     /* Ending zero.  */
 441                                     + 1];
 442
 443
 444 /* Get section SECNAME or create one if it doesn't exist.  When creating
 445    one, new memory for the name is allocated.  */
 446
 447 static asection *
 448 mmo_make_section (abfd, secname)
 449      bfd *abfd;
 450      CONST char *secname;
 451 {
 452   asection *sec = bfd_get_section_by_name (abfd, secname);
 453
 454   if (sec == NULL)
 455     {
 456       char *newsecname = strdup (secname);
 457
 458       if (newsecname == NULL)
 459         {
 460           (*_bfd_error_handler)
 461             (_("%s: No core to allocate section name %s\n"),
 462              bfd_get_filename (abfd), secname);
 463           bfd_set_error (bfd_error_system_call);
 464           return NULL;
 465         }
 466       sec = bfd_make_section (abfd, newsecname);
 467     }
 468
 469   return sec;
 470 }
 471
 472 /* Nothing to do, but keep as a placeholder if we need it.
 473    Note that state that might differ between bfd:s must not be initialized
 474    here, nor must it be static.  Add it to tdata information instead.  */
 475
 476 static void
 477 mmo_init ()
 478 {
 479   static boolean inited = false;
 480   int i = 0;
 481   int j = 0;
 482   static const char letters[]
 483     = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789:_";
 484
 485   if (inited == false)
 486     {
 487       inited = true;
 488     }
 489
 490   /* Fill in the set of valid symbol characters.  */
 491   strcpy (valid_mmo_symbol_character_set, letters);
 492   i = strlen (letters);
 493
 494   for (j = 126; j < 256; j++)
 495     valid_mmo_symbol_character_set[i++] = j;
 496 }
 497
 498 /* Check whether an existing file is an mmo file.  */
 499
 500 static CONST bfd_target *
 501 mmo_object_p (abfd)
 502      bfd *abfd;
 503 {
 504   struct stat statbuf;
 505   bfd_byte b[4];
 506
 507   mmo_init ();
 508
 509   if (bfd_stat (abfd, &statbuf) < 0
 510       || bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
 511       || bfd_bread (b, 4, abfd) != 4)
 512     goto bad_final;
 513
 514   /* All mmo files are a multiple of four bytes long.
 515      Only recognize version one.  */
 516   if ((statbuf.st_size % 4) != 0
 517       || b[0] != LOP || b[1] != LOP_PRE || b[2] != 1)
 518     goto bad_format;
 519
 520   /* Get the last 32-bit word.  */
 521   if (bfd_seek (abfd, (file_ptr) statbuf.st_size - 4, SEEK_SET) != 0
 522       || bfd_bread (b, 4, abfd) != 4)
 523     goto bad_final;
 524
 525   /* Check if the file ends in a lop_end lopcode. */
 526   if (b[0] != LOP || b[1] != LOP_END || ! mmo_mkobject (abfd))
 527     goto bad_format;
 528
 529   /* Compute an upper bound on the max symbol length.  Not really
 530      important as all of the symbol information can only be 256k.  */
 531   abfd->tdata.mmo_data->max_symbol_length = (b[2] * 256 + b[3]) * 4;
 532   abfd->tdata.mmo_data->lop_stab_symbol
 533     = bfd_malloc (abfd->tdata.mmo_data->max_symbol_length + 1);
 534
 535   if (abfd->tdata.mmo_data->lop_stab_symbol == NULL)
 536     {
 537       (*_bfd_error_handler)
 538         (_("%s: No core to allocate a symbol %d bytes long\n"),
 539          bfd_get_filename (abfd), abfd->tdata.mmo_data->max_symbol_length);
 540       goto bad_final;
 541     }
 542
 543   /* Read in everything.  */
 544   if (! mmo_scan (abfd))
 545     goto bad_format_free;
 546
 547   if (abfd->symcount > 0)
 548     abfd->flags |= HAS_SYMS;
 549
 550   /* You'll have to tweak this if you want to use this format for other
 551      arches (not recommended due to its small-size limitations).  Look at
 552      the ELF format for how to make it target-generic.  */
 553   if (! bfd_default_set_arch_mach (abfd, bfd_arch_mmix, 0))
 554     goto bad_format_free;
 555
 556   return abfd->xvec;
 557
 558  bad_format_free:
 559   free (abfd->tdata.mmo_data->lop_stab_symbol);
 560  bad_format:
 561   bfd_set_error (bfd_error_wrong_format);
 562  bad_final:
 563   return NULL;
 564 }
 565
 566 /* Set up the mmo tdata information.  */
 567
 568 static boolean
 569 mmo_mkobject (abfd)
 570      bfd *abfd;
 571 {
 572   mmo_init ();
 573
 574   if (abfd->tdata.mmo_data == NULL)
 575     {
 576       time_t created;
 577
 578       /* All fields are zero-initialized, so we don't have to explicitly
 579          initialize most.  */
 580       tdata_type *tdata = (tdata_type *) bfd_zmalloc (sizeof (tdata_type));
 581       if (tdata == NULL)
 582         return false;
 583
 584       created = time (NULL);
 585       bfd_put_32 (abfd, created, tdata->created);
 586
 587       abfd->tdata.mmo_data = tdata;
 588     }
 589
 590   return true;
 591 }
 592
 593 static boolean
 594 mmo_bfd_copy_private_bfd_data (ibfd, obfd)
 595      bfd *ibfd;
 596      bfd *obfd;
 597 {
 598   if (bfd_get_flavour (ibfd) != bfd_target_mmo_flavour
 599       || bfd_get_flavour (obfd) != bfd_target_mmo_flavour)
 600     return true;
 601
 602   /* Copy the time the copied-from file was created.  If people want the
 603      time the file was last *modified*, they have that in the normal file
 604      information.  */
 605   memcpy (obfd->tdata.mmo_data->created, ibfd->tdata.mmo_data->created,
 606           sizeof (obfd->tdata.mmo_data->created));
 607   return true;
 608 }
 609
 610 /* Helper functions for mmo_decide_section, used through
 611    bfd_map_over_sections.  */
 612
 613 static void
 614 mmo_find_sec_w_addr (abfd, sec, p)
 615      bfd *abfd ATTRIBUTE_UNUSED;
 616      asection *sec;
 617      PTR p;
 618 {
 619   struct mmo_find_sec_info *infop = (struct mmo_find_sec_info *) p;
 620   bfd_vma vma = bfd_get_section_vma (abfd, sec);
 621
 622   /* Ignore sections that aren't loaded.  */
 623   if ((bfd_get_section_flags (abfd, sec) & (SEC_LOAD | SEC_ALLOC))
 624       !=  (SEC_LOAD | SEC_ALLOC))
 625     return;
 626
 627   if (infop->addr >= vma && infop->addr < vma + sec->_raw_size)
 628     infop->sec = sec;
 629 }
 630
 631 static void
 632 mmo_find_sec_w_addr_grow (abfd, sec, p)
 633      bfd *abfd ATTRIBUTE_UNUSED;
 634      asection *sec;
 635      PTR p;
 636 {
 637   struct mmo_find_sec_info *infop = (struct mmo_find_sec_info *) p;
 638   bfd_vma vma = bfd_get_section_vma (abfd, sec);
 639
 640   /* Ignore sections that aren't loaded.  */
 641   if ((bfd_get_section_flags (abfd, sec) & (SEC_LOAD | SEC_ALLOC))
 642       !=  (SEC_LOAD | SEC_ALLOC))
 643     return;
 644
 645   if (infop->addr >= vma && infop->addr < vma + MAX_ARTIFICIAL_SECTION_SIZE)
 646     infop->sec = sec;
 647 }
 648
 649 /* Find a section that corresponds to a VMA.  Automatically create .text
 650    or .data and set current section to it, depending on what vma.  If we
 651    can't deduce a section, make one up as ".MMIX.sec.N", where N is an
 652    increasing number.  */
 653
 654 static asection *
 655 mmo_decide_section (abfd, vma)
 656      bfd *abfd;
 657      bfd_vma vma;
 658 {
 659   asection *sec = NULL;
 660   char sec_name[sizeof (".MMIX.sec.") + 20];
 661   struct mmo_find_sec_info info;
 662
 663   info.addr = vma;
 664   info.sec = NULL;
 665
 666   /* First see if there's a section that would match exactly.  */
 667   bfd_map_over_sections (abfd, mmo_find_sec_w_addr, &info);
 668
 669   if (info.sec != NULL)
 670     return info.sec;
 671
 672   /* If there's no such section, try and expand one of the existing ones,
 673      up to a limit.  Make sure we have .text and .data before we try that;
 674      create them corresponding to expected addresses and set flags to make
 675      them match the "loaded and with contents" expectation.  */
 676   if ((vma >> 56) == 0)
 677     {
 678       sec = bfd_make_section_old_way (abfd, MMO_TEXT_SECTION_NAME);
 679
 680       if (sec == NULL)
 681         return NULL;
 682
 683       if (! sec->user_set_vma)
 684         bfd_set_section_vma (abfd, sec, vma);
 685       if (! bfd_set_section_flags (abfd, sec,
 686                                    bfd_get_section_flags (abfd, sec)
 687                                    | SEC_CODE | SEC_LOAD | SEC_ALLOC))
 688         return NULL;
 689     }
 690   else if ((vma >> 56) == 0x20)
 691     {
 692       sec = bfd_make_section_old_way (abfd, MMO_DATA_SECTION_NAME);
 693
 694       if (sec == NULL)
 695         return NULL;
 696
 697       if (! sec->user_set_vma)
 698         bfd_set_section_vma (abfd, sec, vma);
 699       if (! bfd_set_section_flags (abfd, sec,
 700                                    bfd_get_section_flags (abfd, sec)
 701                                    | SEC_LOAD | SEC_ALLOC))
 702         return NULL;
 703     }
 704
 705   bfd_map_over_sections (abfd, mmo_find_sec_w_addr_grow, &info);
 706
 707   if (info.sec != NULL)
 708     return info.sec;
 709
 710   /* If there's still no suitable section, make a new one.  */
 711   sprintf (sec_name, ".MMIX.sec.%d", abfd->tdata.mmo_data->sec_no++);
 712   sec = mmo_make_section (abfd, sec_name);
 713   if (! sec->user_set_vma)
 714     bfd_set_section_vma (abfd, sec, vma);
 715
 716   if (! bfd_set_section_flags (abfd, sec,
 717                                bfd_get_section_flags (abfd, sec)
 718                                | SEC_LOAD | SEC_ALLOC))
 719     return NULL;
 720   return sec;
 721 }
 722
 723 /* Xor in a 64-bit value VALUE at VMA.  */
 724
 725 static INLINE void
 726 mmo_xore_64 (sec, vma, value)
 727      asection *sec;
 728      bfd_vma vma;
 729      bfd_vma value;
 730 {
 731   bfd_byte *loc = mmo_get_loc (sec, vma, 8);
 732   bfd_vma prev = bfd_get_64 (sec->owner, loc);
 733
 734   value ^= prev;
 735   bfd_put_64 (sec->owner, value, loc);
 736 }
 737
 738 /* Xor in a 32-bit value VALUE at VMA.  */
 739
 740 static INLINE void
 741 mmo_xore_32 (sec, vma, value)
 742      asection *sec;
 743      bfd_vma vma;
 744      unsigned int value;
 745 {
 746   bfd_byte *loc = mmo_get_loc (sec, vma, 4);
 747   unsigned int prev = bfd_get_32 (sec->owner, loc);
 748
 749   value ^= prev;
 750   bfd_put_32 (sec->owner, value, loc);
 751 }
 752
 753 /* Xor in a 16-bit value VALUE at VMA.  */
 754
 755 static INLINE void
 756 mmo_xore_16 (sec, vma, value)
 757      asection *sec;
 758      bfd_vma vma;
 759      unsigned int value;
 760 {
 761   bfd_byte *loc = mmo_get_loc (sec, vma, 2);
 762   unsigned int prev = bfd_get_16 (sec->owner, loc);
 763
 764   value ^= prev;
 765   bfd_put_16 (sec->owner, value, loc);
 766 }
 767
 768 /* Write a 32-bit word to output file, no lop_quote generated.  */
 769
 770 static INLINE void
 771 mmo_write_tetra_raw (abfd, value)
 772      bfd *abfd;
 773      unsigned int value;
 774 {
 775   bfd_byte buf[4];
 776
 777   bfd_put_32 (abfd, value, buf);
 778
 779   if (bfd_bwrite ((PTR) buf, 4, abfd) != 4)
 780     abfd->tdata.mmo_data->have_error = true;
 781 }
 782
 783 /* Write a 32-bit word to output file; lop_quote if necessary.  */
 784
 785 static INLINE void
 786 mmo_write_tetra (abfd, value)
 787      bfd *abfd;
 788      unsigned int value;
 789 {
 790   if (((value >> 24) & 0xff) == LOP)
 791     mmo_write_tetra_raw (abfd, LOP_QUOTE_NEXT);
 792
 793   mmo_write_tetra_raw (abfd, value);
 794 }
 795
 796 /* Write a 64-bit word to output file, perhaps with lop_quoting.  */
 797
 798 static INLINE void
 799 mmo_write_octa (abfd, value)
 800      bfd *abfd;
 801      bfd_vma value;
 802 {
 803   mmo_write_tetra (abfd, (unsigned int) (value >> 32));
 804   mmo_write_tetra (abfd, (unsigned int) value);
 805 }
 806
 807 /* Write a 64-bit word to output file, without lop_quoting.  */
 808
 809 static INLINE void
 810 mmo_write_octa_raw (abfd, value)
 811      bfd *abfd;
 812      bfd_vma value;
 813 {
 814   mmo_write_tetra_raw (abfd, (unsigned int) (value >> 32));
 815   mmo_write_tetra_raw (abfd, (unsigned int) value);
 816 }
 817
 818 /* Write quoted contents, zero filled.  */
 819
 820 static INLINE boolean
 821 mmo_write_chunk (abfd, loc, len)
 822      bfd *abfd;
 823      CONST bfd_byte *loc;
 824      unsigned int len;
 825 {
 826   boolean retval = true;
 827   bfd_byte buf[4] = {0, 0, 0, 0};
 828
 829   while (len >= 4)
 830     {
 831       if (loc[0] == LOP)
 832         mmo_write_tetra_raw (abfd, LOP_QUOTE_NEXT);
 833
 834       retval
 835         = (retval == true
 836            && abfd->tdata.mmo_data->have_error == false
 837            && 4 == bfd_bwrite ((PTR) loc, 4, abfd));
 838
 839       loc += 4;
 840       len -= 4;
 841     }
 842
 843   if (len)
 844     {
 845       memcpy (buf, loc, len);
 846       if (buf[0] == LOP)
 847         mmo_write_tetra_raw (abfd, LOP_QUOTE_NEXT);
 848
 849       retval
 850         = (retval == true
 851            && abfd->tdata.mmo_data->have_error == false
 852            && 4 == bfd_bwrite ((PTR) buf, 4, abfd));
 853     }
 854
 855   return retval;
 856 }
 857
 858 /* Same, but from a list.  */
 859
 860 static INLINE boolean
 861 mmo_write_chunk_list (abfd, datap)
 862      bfd *abfd;
 863      mmo_data_list_type *datap;
 864 {
 865   for (; datap != NULL; datap = datap->next)
 866     if (! mmo_write_chunk (abfd, datap->data, datap->size))
 867       return false;
 868
 869   return true;
 870 }
 871
 872 /* Write a lop_loc and some contents.  */
 873
 874 static boolean
 875 mmo_write_loc_chunk (abfd, vma, loc, len)
 876      bfd *abfd;
 877      bfd_vma vma;
 878      CONST bfd_byte *loc;
 879      unsigned int len;
 880 {
 881   /* We always write the location as 64 bits; no use saving bytes here.  */
 882   mmo_write_tetra_raw (abfd, (LOP << 24) | (LOP_LOC << 16) | 2);
 883
 884   /* Find an initial and trailing section of zero tetras; we don't need to
 885      write out zeros.  FIXME: When we do this, we should emit section size
 886      and address specifiers, else objcopy can't perform a unity
 887      translation.  */
 888   while (len >= 4 && bfd_get_32 (abfd, loc) == 0)
 889     {
 890       vma += 4;
 891       len -= 4;
 892       loc += 4;
 893     }
 894
 895   while (len >= 4 && bfd_get_32 (abfd, loc + len - 4) == 0)
 896     len -= 4;
 897
 898   mmo_write_octa_raw (abfd, vma);
 899   return
 900     abfd->tdata.mmo_data->have_error == false
 901     && mmo_write_chunk (abfd, loc, len);
 902 }
 903
 904 /* Same, but from a list.  */
 905
 906 static INLINE boolean
 907 mmo_write_loc_chunk_list (abfd, datap)
 908      bfd *abfd;
 909      mmo_data_list_type *datap;
 910 {
 911   for (; datap != NULL; datap = datap->next)
 912     if (! mmo_write_loc_chunk (abfd, datap->where, datap->data, datap->size))
 913       return false;
 914
 915   return true;
 916 }
 917
 918 /* Make a .MMIX.spec_data.N section.  */
 919
 920 static asection *
 921 mmo_get_generic_spec_data_section (abfd, spec_data_number)
 922      bfd *abfd;
 923      int spec_data_number;
 924 {
 925   asection *sec;
 926   char secname[sizeof (MMIX_OTHER_SPEC_SECTION_PREFIX) + 20]
 927     = MMIX_OTHER_SPEC_SECTION_PREFIX;
 928
 929   sprintf (secname + strlen (MMIX_OTHER_SPEC_SECTION_PREFIX),
 930            "%d", spec_data_number);
 931
 932   sec = mmo_make_section (abfd, secname);
 933
 934   return sec;
 935 }
 936
 937 /* Make a special section for SPEC_DATA_NUMBER.  If it is the one we use
 938    ourselves, parse some of its data to get at the section name.  */
 939
 940 static asection *
 941 mmo_get_spec_section (abfd, spec_data_number)
 942      bfd *abfd;
 943      int spec_data_number;
 944 {
 945   bfd_byte *secname;
 946   asection *sec;
 947   bfd_byte buf[4];
 948   unsigned int secname_length;
 949   unsigned int i;
 950   bfd_vma section_length;
 951   bfd_vma section_vma;
 952   mmo_data_list_type *loc;
 953   flagword flags;
 954   long orig_pos;
 955
 956   /* If this isn't the "special" special data, then make a placeholder
 957      section.  */
 958   if (spec_data_number != SPEC_DATA_SECTION)
 959     return mmo_get_generic_spec_data_section (abfd, spec_data_number);
 960
 961   /* Seek back to this position if there was a format error.  */
 962   orig_pos = bfd_tell (abfd);
 963
 964   /* Read the length (in 32-bit words).  */
 965   if (bfd_bread (buf, 4, abfd) != 4)
 966     goto format_error;
 967
 968   if (buf[0] == LOP)
 969     {
 970       if (buf[1] != LOP_QUOTE)
 971         goto format_error;
 972
 973       if (bfd_bread (buf, 4, abfd) != 4)
 974         goto format_error;
 975     }
 976
 977   /* We don't care to keep the name length accurate.  It's
 978      zero-terminated.  */
 979   secname_length = bfd_get_32 (abfd, buf) * 4;
 980
 981   /* Check section name length for sanity.  */
 982   if (secname_length > MAX_SECTION_NAME_SIZE)
 983     goto format_error;
 984
 985   /* This should be free'd regardless if a section is created.  */
 986   secname = bfd_malloc (secname_length + 1);
 987   secname[secname_length] = 0;
 988
 989   for (i = 0; i < secname_length / 4; i++)
 990     {
 991       if (bfd_bread (secname + i * 4, 4, abfd) != 4)
 992         goto format_error_free;
 993
 994       if (secname[i * 4] == LOP)
 995         {
 996           /* A bit of overkill, but we handle char 0x98 in a section name,
 997              and recognize misparsing.  */
 998           if (secname[i * 4 + 1] != LOP_QUOTE
 999               || bfd_bread (secname + i * 4, 4, abfd) != 4)
1000             /* Whoops.  We thought this was a name, and now we found a
1001                non-lop_quote lopcode before we parsed the whole length of
1002                the name.  Signal end-of-file in the same manner.  */
1003               goto format_error_free;
1004         }
1005     }
1006
1007   /* Get the section flags.  */
1008   if (bfd_bread (buf, 4, abfd) != 4
1009       || (buf[0] == LOP
1010           && (buf[1] != LOP_QUOTE || bfd_bread (buf, 4, abfd) != 4)))
1011     goto format_error_free;
1012
1013   flags = bfd_get_32 (abfd, buf);
1014
1015   /* Get the section length.  */
1016   if (bfd_bread (buf, 4, abfd) != 4
1017       || (buf[0] == LOP
1018           && (buf[1] != LOP_QUOTE || bfd_bread (buf, 4, abfd) != 4)))
1019     goto format_error_free;
1020
1021   section_length = (bfd_vma) bfd_get_32 (abfd, buf) << 32;
1022
1023   /* That's the first, high-part.  Now get the low part.  */
1024
1025   if (bfd_bread (buf, 4, abfd) != 4
1026       || (buf[0] == LOP
1027           && (buf[1] != LOP_QUOTE || bfd_bread (buf, 4, abfd) != 4)))
1028     goto format_error_free;
1029
1030   section_length |= (bfd_vma) bfd_get_32 (abfd, buf);
1031
1032   /* Check the section length for sanity.  */
1033   if (section_length > MAX_ARTIFICIAL_SECTION_SIZE)
1034     goto format_error_free;
1035
1036   /* Get the section VMA.  */
1037   if (bfd_bread (buf, 4, abfd) != 4
1038       || (buf[0] == LOP
1039           && (buf[1] != LOP_QUOTE || bfd_bread (buf, 4, abfd) != 4)))
1040     goto format_error_free;
1041
1042   section_vma = (bfd_vma) bfd_get_32 (abfd, buf) << 32;
1043
1044   /* That's the first, high-part.  Now get the low part.  */
1045   if (bfd_bread (buf, 4, abfd) != 4
1046       || (buf[0] == LOP
1047           && (buf[1] != LOP_QUOTE || bfd_bread (buf, 4, abfd) != 4)))
1048     goto format_error_free;
1049
1050   section_vma |= (bfd_vma) bfd_get_32 (abfd, buf);
1051
1052   sec = mmo_make_section (abfd, secname);
1053   free (secname);
1054   if (sec == NULL)
1055     goto format_error;
1056
1057   /* We allocate a buffer here for the advertised size, with head room for
1058      tetrabyte alignment.  */
1059   loc = bfd_zmalloc (section_length + 3
1060                      + sizeof (struct mmo_data_list_struct));
1061   if (loc == NULL)
1062     goto format_error;
1063
1064   /* Use a TETRA-rounded size for the allocated buffer; we set the
1065      "visible" section size below.  */
1066   loc->size = (section_length + 3) & ~3;
1067
1068   /* Add in the section flags we found to those bfd entered during this
1069      process and set the contents.  */
1070   if (! bfd_set_section_flags (abfd, sec,
1071                                bfd_sec_flags_from_mmo_flags (flags)
1072                                | bfd_get_section_flags (abfd, sec)
1073                                | (section_length != 0 ? SEC_HAS_CONTENTS : 0))
1074       || ! bfd_set_section_size (abfd, sec,
1075                                  sec->_cooked_size + section_length)
1076       /* Set VMA only for the first occurrence.  */
1077       || (! sec->user_set_vma
1078           && ! bfd_set_section_vma  (abfd, sec, section_vma)))
1079     {
1080       /* If we get an error for any of the calls above, signal more than
1081          just a format error for the spec section.  */
1082       return NULL;
1083     }
1084
1085   loc->next = NULL;
1086   if (((struct mmo_section_data_struct *) (sec->used_by_bfd))->tail != NULL)
1087     ((struct mmo_section_data_struct *) (sec->used_by_bfd))->tail->next
1088       = loc;
1089   else
1090     ((struct mmo_section_data_struct *) (sec->used_by_bfd))->head = loc;
1091   ((struct mmo_section_data_struct *) (sec->used_by_bfd))->tail = loc;
1092   loc->where = section_vma;
1093
1094   return sec;
1095
1096  format_error_free:
1097   free (secname);
1098  format_error:
1099   if (bfd_seek (abfd, orig_pos, SEEK_SET) != 0)
1100     return NULL;
1101
1102   return mmo_get_generic_spec_data_section (abfd, spec_data_number);
1103 }
1104
1105 /* Read a byte, but read from file in multiples of 32-bit words.  */
1106
1107 static bfd_byte
1108 mmo_get_byte (abfd)
1109      bfd *abfd;
1110 {
1111   bfd_byte retval;
1112
1113   if (abfd->tdata.mmo_data->byte_no == 0)
1114     {
1115       if (abfd->tdata.mmo_data->have_error == false
1116           && bfd_bread (abfd->tdata.mmo_data->buf, 4, abfd) != 4)
1117         {
1118           abfd->tdata.mmo_data->have_error = true;
1119
1120           /* A value somewhat safe against tripping on some inconsistency
1121              when mopping up after this error.  */
1122           return 128;
1123         }
1124     }
1125
1126   retval = abfd->tdata.mmo_data->buf[abfd->tdata.mmo_data->byte_no];
1127   abfd->tdata.mmo_data->byte_no = (abfd->tdata.mmo_data->byte_no + 1) % 4;
1128
1129   return retval;
1130 }
1131
1132 /* Write a byte, in multiples of 32-bit words.  */
1133
1134 static void
1135 mmo_write_byte (abfd, value)
1136      bfd *abfd;
1137      bfd_byte value;
1138 {
1139   abfd->tdata.mmo_data->buf[(abfd->tdata.mmo_data->byte_no++ % 4)] = value;
1140   if ((abfd->tdata.mmo_data->byte_no % 4) == 0)
1141     {
1142       if (abfd->tdata.mmo_data->have_error == false
1143           && bfd_bwrite (abfd->tdata.mmo_data->buf, 4, abfd) != 4)
1144         abfd->tdata.mmo_data->have_error = true;
1145     }
1146 }
1147
1148 /* Create a symbol.  */
1149
1150 static boolean
1151 mmo_create_symbol (abfd, symname, addr, sym_type, serno)
1152      bfd *abfd;
1153      CONST char *symname;
1154      bfd_vma addr;
1155      enum mmo_sym_type sym_type;
1156      unsigned int serno;
1157 {
1158   struct mmo_symbol *n;
1159
1160   n = (struct mmo_symbol *) bfd_alloc (abfd, sizeof (struct mmo_symbol));
1161   if (n == NULL)
1162     return false;
1163
1164   n->name = bfd_alloc (abfd, strlen (symname) + 1);
1165   if (n->name == NULL)
1166     return false;
1167
1168   strcpy ((PTR) n->name, symname);
1169
1170   n->value = addr;
1171   n->sym_type = sym_type;
1172   n->serno = serno;
1173
1174   if (abfd->tdata.mmo_data->symbols == NULL)
1175     abfd->tdata.mmo_data->symbols = n;
1176   else
1177     abfd->tdata.mmo_data->symtail->next = n;
1178   abfd->tdata.mmo_data->symtail = n;
1179   n->next = NULL;
1180
1181   ++abfd->symcount;
1182
1183   /* Check that :Main equals the last octa of the .MMIX.reg_contents
1184      section, as it's the one place we're sure to pass when reading a mmo
1185      object.  For written objects, we do it while setting the symbol
1186      table.  */
1187   if (strcmp (symname, MMIX_START_SYMBOL_NAME) == 0
1188       && bfd_get_start_address (abfd) != addr)
1189     {
1190       (*_bfd_error_handler)
1191         (_("%s: invalid mmo file: initialization value for $255 is not `Main'\n"),
1192          bfd_get_filename (abfd));
1193       bfd_set_error (bfd_error_bad_value);
1194       return false;
1195     }
1196
1197   return true;
1198 }
1199
1200 /* Read in symbols.  */
1201
1202 static boolean
1203 mmo_get_symbols (abfd)
1204      bfd *abfd;
1205 {
1206 /*
1207 INODE
1208 Symbol-table, mmo section mapping, File layout, mmo
1209 SUBSECTION
1210         Symbol table format
1211
1212         From mmixal.w (or really, the generated mmixal.tex) in
1213         @emph{http://www-cs-faculty.stanford.edu/~knuth/programs/mmix.tar.gz}):
1214         ``Symbols are stored and retrieved by means of a @samp{ternary
1215         search trie}, following ideas of Bentley and Sedgewick. (See
1216         ACM--SIAM Symp.@: on Discrete Algorithms @samp{8} (1997), 360--369;
1217         R.@:Sedgewick, @samp{Algorithms in C} (Reading, Mass.@:
1218         Addison--Wesley, 1998), @samp{15.4}.)  Each trie node stores a
1219         character, and there are branches to subtries for the cases where
1220         a given character is less than, equal to, or greater than the
1221         character in the trie.  There also is a pointer to a symbol table
1222         entry if a symbol ends at the current node.''
1223
1224         So it's a tree encoded as a stream of bytes.  The stream of bytes
1225         acts on a single virtual global symbol, adding and removing
1226         characters and signalling complete symbol points.  Here, we read
1227         the stream and create symbols at the completion points.
1228
1229         First, there's a control byte <<m>>.  If any of the listed bits
1230         in <<m>> is nonzero, we execute what stands at the right, in
1231         the listed order:
1232
1233 | (MMO3_LEFT)
1234 | 0x40 - Traverse left trie.
1235 |        (Read a new command byte and recurse.)
1236 |
1237 | (MMO3_SYMBITS)
1238 | 0x2f - Read the next byte as a character and store it in the
1239 |        current character position; increment character position.
1240 |        Test the bits of <<m>>:
1241 |
1242 |        (MMO3_WCHAR)
1243 |        0x80 - The character is 16-bit (so read another byte,
1244 |               merge into current character.
1245 |
1246 |        (MMO3_TYPEBITS)
1247 |        0xf  - We have a complete symbol; parse the type, value
1248 |               and serial number and do what should be done
1249 |               with a symbol.  The type and length information
1250 |               is in j = (m & 0xf).
1251 |
1252 |               (MMO3_REGQUAL_BITS)
1253 |               j == 0xf: A register variable.  The following
1254 |                         byte tells which register.
1255 |               j <= 8:   An absolute symbol.  Read j bytes as the
1256 |                         big-endian number the symbol equals.
1257 |                         A j = 2 with two zero bytes denotes an
1258 |                         unknown symbol.
1259 |               j > 8:    As with j <= 8, but add (0x20 << 56)
1260 |                         to the value in the following j - 8
1261 |                         bytes.
1262 |
1263 |               Then comes the serial number, as a variant of
1264 |               uleb128, but better named ubeb128:
1265 |               Read bytes and shift the previous value left 7
1266 |               (multiply by 128).  Add in the new byte, repeat
1267 |               until a byte has bit 7 set.  The serial number
1268 |               is the computed value minus 128.
1269 |
1270 |        (MMO3_MIDDLE)
1271 |        0x20 - Traverse middle trie.  (Read a new command byte
1272 |               and recurse.)  Decrement character position.
1273 |
1274 | (MMO3_RIGHT)
1275 | 0x10 - Traverse right trie.  (Read a new command byte and
1276 |        recurse.)
1277
1278         Let's look again at the <<lop_stab>> for the trivial file
1279         (@pxref{File layout}).
1280
1281 | 0x980b0000 - lop_stab for ":Main" = 0, serial 1.
1282 | 0x203a4040
1283 | 0x10404020
1284 | 0x4d206120
1285 | 0x69016e00
1286 | 0x81000000
1287
1288         This forms the trivial trie (note that the path between ``:'' and
1289         ``M'' is redundant):
1290
1291 | 203a     ":"
1292 | 40       /
1293 | 40      /
1294 | 10      \
1295 | 40      /
1296 | 40     /
1297 | 204d  "M"
1298 | 2061  "a"
1299 | 2069  "i"
1300 | 016e  "n" is the last character in a full symbol, and
1301 |       with a value represented in one byte.
1302 | 00    The value is 0.
1303 | 81    The serial number is 1.  */
1304
1305   bfd_byte m = mmo_get_byte (abfd);
1306
1307   /* Check first if we have a bad hair day.  */
1308   if (abfd->tdata.mmo_data->have_error == true)
1309     return false;
1310
1311   if (m & MMO3_LEFT)
1312     /* Traverse left trie. */
1313     mmo_get_symbols (abfd);
1314
1315   if (m & MMO3_SYMBITS)
1316     {
1317       bfd_byte c = mmo_get_byte (abfd);
1318       bfd_byte j = m & MMO3_TYPEBITS;
1319       bfd_vma addr = 0;
1320       enum mmo_sym_type sym_type;
1321       unsigned int serno = 0;
1322       bfd_byte k;
1323
1324       if (m & MMO3_WCHAR)
1325         {
1326           bfd_byte c2 = mmo_get_byte (abfd);
1327
1328           /* A two-byte character.  We can't grok this, but neither can
1329              mmotype, for other cases than the second byte being zero.  */
1330
1331           if (c != 0)
1332             {
1333               abfd->tdata.mmo_data->lop_stab_symbol
1334                 [abfd->tdata.mmo_data->symbol_position] = 0;
1335
1336               (*_bfd_error_handler)
1337                 (_("%s: unsupported wide character sequence\
1338  0x%02X 0x%02X after symbol name starting with `%s'\n"),
1339                  bfd_get_filename (abfd), c, c2,
1340                  abfd->tdata.mmo_data->lop_stab_symbol);
1341               bfd_set_error (bfd_error_bad_value);
1342               abfd->tdata.mmo_data->have_error = true;
1343               return false;
1344             }
1345           else
1346             c = c2;
1347         }
1348
1349       abfd->tdata.mmo_data->lop_stab_symbol[abfd->tdata.mmo_data->symbol_position++] = c;
1350       abfd->tdata.mmo_data->lop_stab_symbol[abfd->tdata.mmo_data->symbol_position] = 0;
1351
1352       if (j & MMO3_REGQUAL_BITS)
1353         {
1354           if (j == MMO3_REGQUAL_BITS)
1355             {
1356               sym_type = mmo_reg_sym;
1357               addr = mmo_get_byte (abfd);
1358             }
1359           else if (j <= 8)
1360             {
1361               unsigned int i;
1362
1363               for (i = 0; i < j; i++)
1364                 addr = (addr << 8) + mmo_get_byte (abfd);
1365
1366               if (addr == 0 && j == MMO3_UNDEF)
1367                 sym_type = mmo_undef_sym;
1368               else
1369                 sym_type = mmo_abs_sym;
1370             }
1371           else
1372             {
1373               unsigned int i;
1374
1375               for (i = MMO3_DATA; i < j; i++)
1376                 addr = (addr << 8) + mmo_get_byte (abfd);
1377
1378               addr += (bfd_vma) 0x20 << 56;
1379               sym_type = mmo_data_sym;
1380             }
1381
1382           /* Get the serial number.  */
1383           do
1384             {
1385               k = mmo_get_byte (abfd);
1386               serno = (serno << 7) + k;
1387             }
1388           while (k < 128);
1389           serno -= 128;
1390
1391           /* Got it.  Now enter it.  Skip a leading ":".  */
1392           if (abfd->tdata.mmo_data->have_error == false
1393               && ! mmo_create_symbol (abfd,
1394                                       abfd->tdata.mmo_data->lop_stab_symbol
1395                                       + 1,
1396                                       addr, sym_type, serno))
1397             abfd->tdata.mmo_data->have_error = true;
1398         }
1399
1400       if (m & MMO3_MIDDLE)
1401         /* Traverse middle trie. */
1402         mmo_get_symbols (abfd);
1403
1404       abfd->tdata.mmo_data->symbol_position--;
1405     }
1406
1407   if (m & MMO3_RIGHT)
1408     /* Traverse right trie.  */
1409     mmo_get_symbols (abfd);
1410
1411   return abfd->tdata.mmo_data->have_error == false;
1412 }
1413
1414 /* Get the location of memory area [VMA..VMA + SIZE - 1], which we think
1415    is in section SEC.  Adjust and reallocate zero-initialized contents.
1416    If there's new contents, allocate to the next multiple of
1417    MMO_SEC_CONTENTS_CHUNK_SIZE.  */
1418
1419 static INLINE bfd_byte *
1420 mmo_get_loc (sec, vma, size)
1421      asection *sec;
1422      bfd_vma vma;
1423      int size;
1424 {
1425   bfd_size_type allocated_size;
1426   struct mmo_section_data_struct *sdatap
1427     = (struct mmo_section_data_struct *) sec->used_by_bfd;
1428   struct mmo_data_list_struct *datap = sdatap->head;
1429   struct mmo_data_list_struct *entry;
1430
1431   for (; datap != NULL; datap = datap->next)
1432     {
1433       if (datap->where <= vma
1434           && datap->where + datap->size >= vma + size)
1435         return datap->data + vma - datap->where;
1436       else if (datap->where <= vma
1437                && datap->where + datap->allocated_size >= vma + size
1438                /* Only munch on the "allocated size" if it does not
1439                   overlap the next chunk.  */
1440                && (datap->next == NULL || datap->next->where >= vma + size))
1441         {
1442           /* There was room allocated, but the size wasn't set to include
1443              it.  Do that now.  */
1444           datap->size += (vma + size) - (datap->where + datap->size);
1445
1446           /* Update the section size.  */
1447           if (vma + size > sec->vma + sec->_raw_size)
1448             sec->_raw_size += (vma + size) - (sec->vma + sec->_raw_size);
1449
1450           return datap->data + vma - datap->where;
1451         }
1452     }
1453
1454   /* Not found; allocate a new block.  First check in case we get a
1455      request for a size split up over several blocks; we'll have to return
1456      NULL for those cases, requesting the caller to split up the request.
1457      Requests with an address aligned on MMO_SEC_CONTENTS_CHUNK_SIZE bytes and
1458      for no more than MMO_SEC_CONTENTS_CHUNK_SIZE will always get resolved.  */
1459
1460   for (datap = sdatap->head; datap != NULL; datap = datap->next)
1461     if ((datap->where <= vma && datap->where + datap->size > vma)
1462         || (datap->where < vma + size
1463             && datap->where + datap->size >= vma + size))
1464       return NULL;
1465
1466   allocated_size
1467     = (size + MMO_SEC_CONTENTS_CHUNK_SIZE - 1) & ~(MMO_SEC_CONTENTS_CHUNK_SIZE - 1);
1468   entry = (mmo_data_list_type *)
1469     bfd_zalloc (sec->owner, sizeof (mmo_data_list_type) + allocated_size);
1470   if (entry == NULL)
1471     return false;
1472   entry->where = vma;
1473   entry->size = size;
1474   entry->allocated_size = allocated_size;
1475
1476   datap = sdatap->head;
1477
1478   /* Sort the records by address.  Optimize for the common case of adding
1479      a record to the end of the list.  */
1480   if (sdatap->tail != NULL && entry->where >= sdatap->tail->where)
1481     {
1482       sdatap->tail->next = entry;
1483       entry->next = NULL;
1484       sdatap->tail = entry;
1485     }
1486   else
1487     {
1488       mmo_data_list_type **look;
1489       for (look = &sdatap->head;
1490            *look != NULL && (*look)->where < entry->where;
1491            look = &(*look)->next)
1492         ;
1493       entry->next = *look;
1494       *look = entry;
1495       if (entry->next == NULL)
1496         {
1497           sdatap->tail = entry;
1498
1499           /* We get here for the first time (at other times too) for this
1500              section.  Say we have contents.  */
1501           if (! bfd_set_section_flags (sec->owner, sec,
1502                                        bfd_get_section_flags (sec->owner, sec)
1503                                        | SEC_HAS_CONTENTS))
1504             return NULL;
1505         }
1506     }
1507
1508   /* Update the section size.  */
1509   if (vma + size > sec->vma + sec->_raw_size)
1510     sec->_raw_size += (vma + size) - (sec->vma + sec->_raw_size);
1511   return entry->data;
1512 }
1513
1514 /* Set sizes once we've read in all sections.  */
1515
1516 static void
1517 mmo_map_set_sizes (abfd, sec, ignored)
1518      bfd *abfd ATTRIBUTE_UNUSED;
1519      asection *sec;
1520      PTR ignored ATTRIBUTE_UNUSED;
1521 {
1522   sec->_cooked_size = sec->_raw_size;
1523   sec->lma = sec->vma;
1524 }
1525
1526 /* Read the mmo file and turn it into sections.  */
1527
1528 static boolean
1529 mmo_scan (abfd)
1530      bfd *abfd;
1531 {
1532   unsigned int i;
1533   unsigned int lineno = 1;
1534   boolean error = false;
1535   bfd_vma vma = 0;
1536   asection *sec = bfd_make_section_old_way (abfd, MMO_TEXT_SECTION_NAME);
1537   asection *non_spec_sec = NULL;
1538   bfd_vma non_spec_vma = 0;
1539   char *current_filename = NULL;
1540   bfd_size_type nbytes_read = 0;
1541   /* Buffer with room to read a 64-bit value.  */
1542   bfd_byte buf[8];
1543   long stab_loc = -1;
1544   char *file_names[256];
1545
1546   memset (file_names, 0, sizeof (file_names));
1547
1548   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
1549     goto error_return;
1550
1551   while ((nbytes_read = bfd_bread (buf, 4, abfd)) == 4)
1552     {
1553       if (buf[0] == LOP)
1554         {
1555           unsigned int y = bfd_get_8 (abfd, buf + 2);
1556           unsigned int z = bfd_get_8 (abfd, buf + 3);
1557
1558           /* Change back to the original section for lopcodes other
1559              than LOP_QUOTE that comes after a LOP_SPEC.  */
1560           if ((buf[1] != LOP_QUOTE || y != 0 || z != 1)
1561               && non_spec_sec != NULL)
1562             {
1563               sec = non_spec_sec;
1564               vma = non_spec_vma;
1565               non_spec_sec = NULL;
1566             }
1567
1568           switch (buf[1])
1569             {
1570             default:
1571               (*_bfd_error_handler)
1572                 (_("%s: invalid mmo file: unsupported lopcode `%d'\n"),
1573                  bfd_get_filename (abfd), buf[1]);
1574               bfd_set_error (bfd_error_bad_value);
1575               goto error_return;
1576
1577             case LOP_QUOTE:
1578               /* Quote the next 32-bit word.  */
1579               if (y != 0 || z != 1)
1580                 {
1581                   (*_bfd_error_handler)
1582                     (_("%s: invalid mmo file: expected YZ = 1 got YZ = %d for lop_quote\n"),
1583                      bfd_get_filename (abfd), y*256+z);
1584                   bfd_set_error (bfd_error_bad_value);
1585                   goto error_return;
1586                 }
1587               if (bfd_bread (buf, 4, abfd) != 4)
1588                 goto error_return;
1589
1590               mmo_xore_32 (sec, vma, bfd_get_32 (abfd, buf));
1591               vma += 4;
1592               vma &= ~3;
1593               lineno++;
1594               break;
1595
1596             case LOP_LOC:
1597               /* Set vma (and section).  */
1598               vma = (bfd_vma) y << 56;
1599               if (z == 1)
1600                 {
1601                   /* Get a 32-bit value.  */
1602                   if (bfd_bread (buf, 4, abfd) != 4)
1603                     goto error_return;
1604
1605                   vma += bfd_get_32 (abfd, buf);
1606                 }
1607               else if (z == 2)
1608                 {
1609                   /* Get a 64-bit value.  */
1610                   if (bfd_bread (buf, 8, abfd) != 8)
1611                     goto error_return;
1612
1613                   vma += bfd_get_64 (abfd, buf);
1614                 }
1615               else
1616                 {
1617                   (*_bfd_error_handler)
1618                     (_("%s: invalid mmo file: expected z = 1 or z = 2, got z = %d for lop_loc\n"),
1619                      bfd_get_filename (abfd), z);
1620                   bfd_set_error (bfd_error_bad_value);
1621                   goto error_return;
1622                 }
1623
1624               sec = mmo_decide_section (abfd, vma);
1625               if (sec == NULL)
1626                 goto error_return;
1627               break;
1628
1629             case LOP_SKIP:
1630               /* Move forward within the same section.  */
1631               vma += y * 256 + z;
1632
1633               sec = mmo_decide_section (abfd, vma);
1634               if (sec == NULL)
1635                 goto error_return;
1636               break;
1637
1638             case LOP_FIXO:
1639               /* A fixup: Store the current vma somewhere.  Position using
1640                  same format as LOP_LOC.  */
1641               {
1642                 bfd_vma p = (bfd_vma) y << 56;
1643                 asection *fixosec;
1644
1645                 if (z == 1)
1646                   {
1647                     /* Get a 32-bit value.  */
1648                     if (bfd_bread (buf, 4, abfd) != 4)
1649                       goto error_return;
1650
1651                     p += bfd_get_32 (abfd, buf);
1652                   }
1653                 else if (z == 2)
1654                   {
1655                     /* Get a 64-bit value.  */
1656                     if (bfd_bread (buf, 8, abfd) != 8)
1657                       goto error_return;
1658
1659                     p += bfd_get_64 (abfd, buf);
1660                   }
1661                 else
1662                   {
1663                     (*_bfd_error_handler)
1664                       (_("%s: invalid mmo file: expected z = 1 or z = 2, got z = %d for lop_fixo\n"),
1665                        bfd_get_filename (abfd), z);
1666                     bfd_set_error (bfd_error_bad_value);
1667                     goto error_return;
1668                   }
1669
1670                 /* The section where we store this address might be a
1671                    different one than the current section.  */
1672                 fixosec = mmo_decide_section (abfd, p);
1673                 if (fixosec == NULL)
1674                   goto error_return;
1675                 mmo_xore_64 (fixosec, p, vma);
1676               }
1677             break;
1678
1679             case LOP_FIXR:
1680               /* A fixup: Store YZ of this lopcode into YZ at vma - 4 * yz.  */
1681               {
1682                 unsigned int yz = (y * 256 + z);
1683                 bfd_vma p = vma + 2 - 4 * yz;
1684                 asection *fixrsec = mmo_decide_section (abfd, p);
1685                 if (fixrsec == NULL)
1686                   goto error_return;
1687                 mmo_xore_16 (fixrsec, p, yz);
1688               }
1689             break;
1690
1691             case LOP_FIXRX:
1692               /* A fixup, similar to lop_fixr, but taking larger numbers
1693                  and can change branches into the opposite direction
1694                  (gasp!).  */
1695               {
1696                 bfd_vma delta;
1697                 bfd_vma p;
1698                 asection *fixrsec;
1699
1700                 if (y != 0)
1701                   {
1702                     (*_bfd_error_handler)
1703                       (_("%s: invalid mmo file: expected y = 0, got y = %d for lop_fixrx\n"),
1704                        bfd_get_filename (abfd), y);
1705                     bfd_set_error (bfd_error_bad_value);
1706                     goto error_return;
1707                   }
1708
1709                 if (z != 16 && z != 24)
1710                   {
1711                     (*_bfd_error_handler)
1712                       (_("%s: invalid mmo file: expected z = 16 or z = 24, got z = %d for lop_fixrx\n"),
1713                        bfd_get_filename (abfd), z);
1714                     bfd_set_error (bfd_error_bad_value);
1715                     goto error_return;
1716                   }
1717
1718                 /* Get the next 32-bit value.  */
1719                 if (bfd_bread (buf, 4, abfd) != 4)
1720                   goto error_return;
1721
1722                 delta = bfd_get_32 (abfd, buf);
1723
1724                 /* Do an, ehm, involved calculation for the location of
1725                    the fixup.  See mmixal documentation for a verbose
1726                    explanation.  We follow it verbosely here for the
1727                    readers delight.  */
1728                 if (buf[0] == 0)
1729                   p = vma - 4 * delta;
1730                 else if (buf[0] == 1)
1731                   p = vma - 4 * ((delta & 0xffffff) - (1 << z));
1732                 else
1733                   {
1734                     (*_bfd_error_handler)
1735                       (_("%s: invalid mmo file: leading byte of operand word must be 0 or 1, got %d for lop_fixrx\n"),
1736                        bfd_get_filename (abfd), buf[0]);
1737                     bfd_set_error (bfd_error_bad_value);
1738                     goto error_return;
1739                   }
1740
1741                 fixrsec = mmo_decide_section (abfd, vma);
1742                 if (fixrsec == NULL)
1743                   goto error_return;
1744                 mmo_xore_32 (fixrsec, p, delta);
1745               }
1746             break;
1747
1748             case LOP_FILE:
1749               /* Set current file and perhaps the file name.  Reset line
1750                  number.  */
1751               if (z != 0)
1752                 {
1753                   char *fname = bfd_malloc (z * 4 + 1);
1754
1755                   if (fname == NULL)
1756                     {
1757                       (*_bfd_error_handler)
1758                         (_("%s: cannot allocate file name for file number %d, %d bytes\n"),
1759                          bfd_get_filename (abfd), y, z * 4 + 1);
1760                       bfd_set_error (bfd_error_system_call);
1761                       goto error_return;
1762                     }
1763
1764                   fname[z * 4] = 0;
1765
1766                   for (i = 0; i < z; i++)
1767                     {
1768                       if (bfd_bread (fname + i * 4, 4, abfd) != 4)
1769                         {
1770                           free (fname);
1771                           goto error_return;
1772                         }
1773                     }
1774
1775                   if (file_names[y] != NULL)
1776                     {
1777                       (*_bfd_error_handler)
1778                         (_("%s: invalid mmo file: file number %d `%s',\
1779  was already entered as `%s'\n"),
1780                          bfd_get_filename (abfd), y, fname, file_names[y]);
1781                       bfd_set_error (bfd_error_bad_value);
1782                       goto error_return;
1783                     }
1784
1785                   file_names[y] = fname;
1786                 }
1787
1788               if (file_names[y] == NULL)
1789                 {
1790                   (*_bfd_error_handler)
1791                     (_("%s: invalid mmo file: file name for number %d\
1792  was not specified before use\n"),
1793                      bfd_get_filename (abfd), y);
1794                   bfd_set_error (bfd_error_bad_value);
1795                   goto error_return;
1796                 }
1797
1798               current_filename = file_names[y];
1799               lineno = 0;
1800               break;
1801
1802             case LOP_LINE:
1803               /* Set line number.  */
1804               lineno = y * 256 + z;
1805               /* FIXME: Create a sequence of mmo-specific line number
1806                  entries for each section, then translate into canonical
1807                  format.  */
1808               break;
1809
1810             case LOP_SPEC:
1811               /* Special data follows until the next non-lop_quote
1812                  lopcode.  */
1813               non_spec_sec = sec;
1814               non_spec_vma = vma;
1815               sec = mmo_get_spec_section (abfd, y * 256 + z);
1816               if (sec == NULL)
1817                 goto error_return;
1818
1819               vma = sec->vma;
1820               break;
1821
1822             case LOP_PRE:
1823               {
1824                 /* We ignore header information, except we read in the
1825                    creation time from the first 32-bit word with the time
1826                    in seconds since era.  */
1827                 if (z >= 1
1828                     && bfd_bread (abfd->tdata.mmo_data->created, 4,
1829                                  abfd) != 4)
1830                   goto error_return;
1831
1832                 for (i = 1; i < z; i++)
1833                   if (bfd_bread (buf, 4, abfd) != 4)
1834                     goto error_return;
1835               }
1836               break;
1837
1838             case LOP_POST:
1839               /* This tells of the contents of registers $Z..$255 at
1840                  startup.  We make a section out of it, with VMA = Z * 8,
1841                  but only if Z != 255 or the contents is non-zero.  */
1842               {
1843                 asection *rsec;
1844                 bfd_byte *loc;
1845                 bfd_vma first_octa;
1846                 bfd_vma startaddr_octa;
1847
1848                 /* Read first octaword outside loop to simplify logic when
1849                    excluding the Z == 255, octa == 0 case.  */
1850                 if (bfd_bread (buf, 8, abfd) != 8)
1851                   goto error_return;
1852
1853                 first_octa = bfd_get_64 (abfd, buf);
1854
1855                 /* Don't emit contents for the trivial case which is
1856                    always present; $255 pointing to Main.  */
1857                 if (z != 255)
1858                   {
1859                     rsec
1860                       = bfd_make_section_old_way (abfd,
1861                                                   MMIX_REG_CONTENTS_SECTION_NAME);
1862                     rsec->vma = z * 8;
1863                     loc = mmo_get_loc (rsec, z * 8, (255 - z) * 8);
1864                     bfd_put_64 (abfd, first_octa, loc);
1865
1866                     for (i = z + 1; i < 255; i++)
1867                       {
1868                         if (bfd_bread (loc + (i - z) * 8, 8, abfd) != 8)
1869                           goto error_return;
1870                       }
1871
1872                     /* Read out the last octabyte, and use it to set the
1873                        start address.  */
1874                     if (bfd_bread (buf, 8, abfd) != 8)
1875                       goto error_return;
1876
1877                     startaddr_octa = bfd_get_64 (abfd, buf);
1878                   }
1879                 else
1880                   startaddr_octa = first_octa;
1881
1882                 if (! bfd_set_start_address (abfd, startaddr_octa))
1883                   {
1884                     /* Currently this can't fail, but this should handle
1885                        future failures.  */
1886                     bfd_set_error (bfd_error_bad_value);
1887                     goto error_return;
1888                   }
1889               }
1890               break;
1891
1892             case LOP_STAB:
1893               /* We read in the symbols now, not later.  */
1894               if (y != 0 || z != 0)
1895                 {
1896                   (*_bfd_error_handler)
1897                     (_("%s: invalid mmo file: fields y and z of lop_stab\
1898  non-zero, y: %d, z: %d\n"),
1899                      bfd_get_filename (abfd), y, z);
1900                   bfd_set_error (bfd_error_bad_value);
1901                   goto error_return;
1902                 }
1903
1904               /* Save the location, so we can check that YZ in the LOP_END
1905                  is correct.  */
1906               stab_loc = bfd_tell (abfd);
1907
1908               /* It's not said that an MMO can be without symbols (though
1909                  mmixal will refuse to assemble files without Main), but
1910                  it seems it would still be a valid mmo-file, so allow it.
1911                  We detect the absence of a symbol area in that the upper
1912                  limit is computed (from the lop_end YZ field) as 0.
1913                  Don't call mmo_get_symbols; it can only detect the end of
1914                  a valid symbol trie, not the absence of one.  */
1915               if (abfd->tdata.mmo_data->max_symbol_length != 0
1916                   && ! mmo_get_symbols (abfd))
1917                 goto error_return;
1918               break;
1919
1920             case LOP_END:
1921               {
1922                 /* This must be the last 32-bit word in an mmo file.
1923                    Let's find out.  */
1924                 struct stat statbuf;
1925                 long curpos = bfd_tell (abfd);
1926
1927                 if (bfd_stat (abfd, &statbuf) < 0)
1928                   goto error_return;
1929
1930                 if (statbuf.st_size != curpos)
1931                   {
1932                     (*_bfd_error_handler)
1933                       (_("%s: invalid mmo file: lop_end not last item in\
1934  file\n"),
1935                        bfd_get_filename (abfd));
1936                     bfd_set_error (bfd_error_bad_value);
1937                     goto error_return;
1938                   }
1939
1940                 /* Check that the YZ field is right.  Subtract the size of
1941                    this LOP_END in the calculation; YZ does not include
1942                    it.  */
1943                 if ((long) (y * 256 + z) * 4 != (curpos - stab_loc) - 4)
1944                   {
1945                     (*_bfd_error_handler)
1946                       (_("%s: invalid mmo file: YZ of lop_end (%ld)\
1947  not equal to the number of tetras to the preceding lop_stab (%ld)\n"),
1948                        bfd_get_filename (abfd), (long) (y * 256 + z),
1949                        (curpos - stab_loc - 4)/4);
1950                     bfd_set_error (bfd_error_bad_value);
1951                     goto error_return;
1952                   }
1953
1954                 bfd_map_over_sections (abfd, mmo_map_set_sizes, NULL);
1955                 goto done;
1956               }
1957             }
1958         }
1959       else
1960         {
1961           /* This wasn't a lopcode, so store it in the current section.  */
1962           mmo_xore_32 (sec, vma & ~3, bfd_get_32 (abfd, buf));
1963           vma += 4;
1964           vma &= ~3;
1965           lineno++;
1966         }
1967     }
1968
1969   /* We know this file is a multiple of four bytes (checked in
1970      mmo_object_p), so if we got something other than 0, this was a bad
1971      file (although it's more likely we'll get 0 in that case too).
1972      If we got end-of-file, then there was no lop_stab, so the file has
1973      invalid format.  */
1974
1975   if (nbytes_read != 0)
1976     bfd_set_error (bfd_error_system_call);
1977   else
1978     bfd_set_error (bfd_error_bad_value);
1979
1980  error_return:
1981   error = true;
1982  done:
1983   /* Mark the .text and .data section with their normal attribute if they
1984      contain anything.  This is not redundant wrt. mmo_decide_section,
1985      since that code might never execute, and conversely the alloc+code
1986      section flags must be set then.  */
1987   sec = bfd_get_section_by_name (abfd, MMO_TEXT_SECTION_NAME);
1988   if (sec != NULL
1989       && (bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS)
1990       && ! bfd_set_section_flags (abfd, sec,
1991                                   bfd_get_section_flags (abfd, sec)
1992                                   | SEC_ALLOC | SEC_LOAD | SEC_CODE))
1993     error = true;
1994
1995   sec = bfd_get_section_by_name (abfd, MMO_DATA_SECTION_NAME);
1996   if (sec != NULL
1997       && (bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS)
1998       && ! bfd_set_section_flags (abfd, sec,
1999                                   bfd_get_section_flags (abfd, sec)
2000                                   | SEC_ALLOC | SEC_LOAD))
2001     error = true;
2002
2003   /* Free whatever resources we took.  */
2004   for (i = 0; i < sizeof (file_names) / sizeof (file_names[0]); i++)
2005     if (file_names[i])
2006       free (file_names[i]);
2007   return error ? false : true;
2008 }
2009
2010 /* A hook to set up object file dependent section information.  For mmo,
2011    we point out the shape of allocated section contents.  */
2012
2013 static boolean
2014 mmo_new_section_hook (abfd, newsect)
2015      bfd *abfd ATTRIBUTE_UNUSED;
2016      asection *newsect;
2017 {
2018   /* We zero-fill all fields and assume NULL is represented by an all
2019      zero-bit pattern.  */
2020   newsect->used_by_bfd =
2021     (PTR) bfd_zalloc (abfd, sizeof (struct mmo_section_data_struct));
2022
2023   if (!newsect->used_by_bfd)
2024     return false;
2025
2026   /* Always align to at least 32-bit words.  */
2027   newsect->alignment_power = 2;
2028   return true;
2029 }
2030
2031 /* We already have section contents loaded for sections that have
2032    contents.  */
2033
2034 static boolean
2035 mmo_get_section_contents (abfd, sec, location, offset, bytes_to_do)
2036      bfd *abfd ATTRIBUTE_UNUSED;
2037      asection *sec ATTRIBUTE_UNUSED;
2038      PTR location ATTRIBUTE_UNUSED;
2039      file_ptr offset ATTRIBUTE_UNUSED;
2040      bfd_size_type bytes_to_do ATTRIBUTE_UNUSED;
2041 {
2042   /* Iterate over diminishing chunk sizes, copying contents, like
2043      mmo_set_section_contents.  */
2044   while (bytes_to_do)
2045     {
2046       /* A minor song-and-dance to make sure we're not bitten by the
2047          distant possibility of the cast from bfd_vma to int making the
2048          chunk zero-sized.  */
2049       int chunk_size
2050         = (int) bytes_to_do != 0 ? bytes_to_do : MMO_SEC_CONTENTS_CHUNK_SIZE;
2051       bfd_byte *loc;
2052
2053       do
2054         loc = mmo_get_loc (sec, sec->vma + offset, chunk_size);
2055       while (loc == NULL && (chunk_size /= 2) != 0);
2056
2057       if (chunk_size == 0)
2058         return false;
2059
2060       memcpy (location, loc, chunk_size);
2061
2062       location += chunk_size;
2063       bytes_to_do -= chunk_size;
2064       offset += chunk_size;
2065     }
2066   return true;
2067 }
2068
2069 /* Return the amount of memory needed to read the symbol table.  */
2070
2071 static long
2072 mmo_get_symtab_upper_bound (abfd)
2073      bfd *abfd ATTRIBUTE_UNUSED;
2074 {
2075   return (abfd->symcount + 1) * sizeof (asymbol *);
2076 }
2077
2078 /* Sort mmo symbols by serial number.  */
2079
2080 static int
2081 mmo_sort_mmo_symbols (arg1, arg2)
2082      CONST PTR arg1;
2083      CONST PTR arg2;
2084 {
2085   CONST struct mmo_symbol *sym1 = *(CONST struct mmo_symbol **) arg1;
2086   CONST struct mmo_symbol *sym2 = *(CONST struct mmo_symbol **) arg2;
2087
2088   /* Sort by serial number first.  */
2089   if (sym1->serno < sym2->serno)
2090     return -1;
2091   else if (sym1->serno > sym2->serno)
2092     return 1;
2093
2094   /* Then sort by address of the table entries.  */
2095   return ((CONST char *) arg1 - (CONST char *) arg2);
2096 }
2097
2098 /* Translate the symbol table.  */
2099
2100 static long
2101 mmo_get_symtab (abfd, alocation)
2102      bfd *abfd;
2103      asymbol **alocation;
2104 {
2105   unsigned int symcount = bfd_get_symcount (abfd);
2106   asymbol *csymbols;
2107   unsigned int i;
2108
2109   csymbols = abfd->tdata.mmo_data->csymbols;
2110   if (csymbols == NULL)
2111     {
2112       asymbol *c;
2113       struct mmo_symbol *s;
2114       struct mmo_symbol **msp;
2115
2116       /* First we store the symbols into the table we'll return, then we
2117          qsort it on the serial number, with secondary on the address of
2118          the symbol, to preserve order if there would be non-unique serial
2119          numbers.  */
2120       for (s = abfd->tdata.mmo_data->symbols,
2121              msp = (struct mmo_symbol **) alocation;
2122            s != NULL;
2123            s = s->next, ++msp)
2124         *msp = s;
2125
2126       *msp = NULL;
2127
2128       qsort (alocation, symcount, sizeof (struct mmo_symbol *),
2129              mmo_sort_mmo_symbols);
2130
2131       csymbols = (asymbol *) bfd_alloc (abfd, symcount * sizeof (asymbol));
2132       if (csymbols == NULL && symcount != 0)
2133         return false;
2134       abfd->tdata.mmo_data->csymbols = csymbols;
2135
2136       for (msp = (struct mmo_symbol **) alocation, c = csymbols;
2137            *msp != NULL;
2138            msp++, ++c)
2139         {
2140           s = *msp;
2141           c->the_bfd = abfd;
2142           c->name = s->name;
2143           c->value = s->value;
2144           c->flags = BSF_GLOBAL;
2145
2146           if (s->sym_type == mmo_data_sym)
2147             {
2148               c->section
2149                 = bfd_get_section_by_name (abfd, MMO_DATA_SECTION_NAME);
2150
2151               if (c->section == NULL)
2152                 c->section = bfd_abs_section_ptr;
2153               else
2154                 c->value -= c->section->vma;
2155             }
2156           else if (s->sym_type == mmo_undef_sym)
2157             c->section = bfd_und_section_ptr;
2158           else if (s->sym_type == mmo_reg_sym)
2159             {
2160               c->section
2161                 = bfd_make_section_old_way (abfd, MMIX_REG_SECTION_NAME);
2162             }
2163           else
2164             {
2165               asection *textsec
2166                 = bfd_get_section_by_name (abfd, MMO_TEXT_SECTION_NAME);
2167
2168               if (textsec != NULL
2169                   && c->value >= textsec->vma
2170                   && c->value <= textsec->vma + textsec->_cooked_size)
2171                 {
2172                   c->section = textsec;
2173                   c->value -= c->section->vma;
2174                 }
2175               else
2176                 c->section = bfd_abs_section_ptr;
2177             }
2178
2179           c->udata.p = NULL;
2180         }
2181     }
2182
2183   /* Last, overwrite the incoming table with the right-type entries.  */
2184   for (i = 0; i < symcount; i++)
2185     *alocation++ = csymbols++;
2186   *alocation = NULL;
2187
2188   return symcount;
2189 }
2190
2191 /* Make an empty symbol.  */
2192
2193 static asymbol *
2194 mmo_make_empty_symbol (abfd)
2195      bfd *abfd;
2196 {
2197   asymbol *new = (asymbol *) bfd_zalloc (abfd, sizeof (asymbol));
2198
2199   if (new)
2200     new->the_bfd = abfd;
2201   return new;
2202 }
2203
2204 /* Get information about a symbol.  */
2205
2206 static void
2207 mmo_get_symbol_info (ignore_abfd, symbol, ret)
2208      bfd *ignore_abfd ATTRIBUTE_UNUSED;
2209      asymbol *symbol;
2210      symbol_info *ret;
2211 {
2212   bfd_symbol_info (symbol, ret);
2213 }
2214
2215 static void
2216 mmo_print_symbol (abfd, afile, symbol, how)
2217      bfd *abfd;
2218      PTR afile;
2219      asymbol *symbol;
2220      bfd_print_symbol_type how;
2221 {
2222   FILE *file = (FILE *) afile;
2223
2224   switch (how)
2225     {
2226     case bfd_print_symbol_name:
2227       fprintf (file, "%s", symbol->name);
2228       break;
2229     default:
2230       bfd_print_symbol_vandf (abfd, (PTR) file, symbol);
2231
2232       fprintf (file, " %-5s %s",
2233                symbol->section->name,
2234                symbol->name);
2235     }
2236 }
2237
2238 /* We can't map a file directly into executable code, so the
2239    size of header information is irrelevant.  */
2240
2241 static int
2242 mmo_sizeof_headers (abfd, exec)
2243      bfd *abfd ATTRIBUTE_UNUSED;
2244      boolean exec ATTRIBUTE_UNUSED;
2245 {
2246   return 0;
2247 }
2248
2249 /* Write the (section-neutral) file preamble.  */
2250
2251 static boolean
2252 mmo_internal_write_header (abfd)
2253      bfd *abfd;
2254 {
2255   CONST char lop_pre_bfd[] = { LOP, LOP_PRE, 1, 1};
2256
2257   if (bfd_bwrite (lop_pre_bfd, 4, abfd) != 4)
2258     return false;
2259
2260   /* Copy creation time of original file.  */
2261   if (bfd_bwrite (abfd->tdata.mmo_data->created, 4, abfd) != 4)
2262     return false;
2263
2264   return true;
2265 }
2266
2267 /* Write the LOP_POST record, with global register initializations.
2268    Z is the Z field of the LOP_POST, corresponding to 255 - number of
2269    registers at DATA.  The Z = 255 field is filled in with the
2270    start-address.  */
2271
2272 static boolean
2273 mmo_internal_write_post (abfd, z, sec)
2274      bfd *abfd;
2275      int z;
2276      asection *sec;
2277 {
2278   int i;
2279   bfd_byte buf[8];
2280   mmo_write_tetra_raw (abfd, (LOP << 24) | (LOP_POST << 16) | z);
2281
2282   for (i = z; i < 255; i++)
2283     {
2284       bfd_byte *data = mmo_get_loc (sec, i * 8, 8);
2285
2286       if (bfd_bwrite (data, 8, abfd) != 8)
2287         return false;
2288     }
2289
2290   /* For Z == $255, we always emit the start location; supposedly Main,
2291      but we have it handy at bfd_get_start_address.  If we're called with
2292      Z == 255, don't assume DATA is valid.  */
2293   bfd_put_64 (abfd, bfd_get_start_address (abfd), buf);
2294
2295   return
2296     abfd->tdata.mmo_data->have_error == false
2297     && bfd_bwrite (buf, 8, abfd) == 8;
2298 }
2299
2300 /* Translate to and from BFD flags.  This is to make sure that we don't
2301    get bitten by BFD flag number changes.  */
2302
2303 static flagword
2304 mmo_sec_flags_from_bfd_flags (flags)
2305      flagword flags;
2306 {
2307   flagword oflags = 0;
2308
2309   if (flags & SEC_ALLOC)
2310     oflags |= MMO_SEC_ALLOC;
2311   if (flags & SEC_LOAD)
2312     oflags |= MMO_SEC_LOAD;
2313   if (flags & SEC_RELOC)
2314     oflags |= MMO_SEC_RELOC;
2315   if (flags & SEC_READONLY)
2316     oflags |= MMO_SEC_READONLY;
2317   if (flags & SEC_CODE)
2318     oflags |= MMO_SEC_CODE;
2319   if (flags & SEC_DATA)
2320     oflags |= MMO_SEC_DATA;
2321   if (flags & SEC_NEVER_LOAD)
2322     oflags |= MMO_SEC_NEVER_LOAD;
2323   if (flags & SEC_IS_COMMON)
2324     oflags |= MMO_SEC_IS_COMMON;
2325   if (flags & SEC_DEBUGGING)
2326     oflags |= MMO_SEC_DEBUGGING;
2327
2328   return oflags;
2329 }
2330
2331 static flagword
2332 bfd_sec_flags_from_mmo_flags (flags)
2333      flagword flags;
2334 {
2335   flagword oflags = 0;
2336
2337   if (flags & MMO_SEC_ALLOC)
2338     oflags |= SEC_ALLOC;
2339   if (flags & MMO_SEC_LOAD)
2340     oflags |= SEC_LOAD;
2341   if (flags & MMO_SEC_RELOC)
2342     oflags |= SEC_RELOC;
2343   if (flags & MMO_SEC_READONLY)
2344     oflags |= SEC_READONLY;
2345   if (flags & MMO_SEC_CODE)
2346     oflags |= SEC_CODE;
2347   if (flags & MMO_SEC_DATA)
2348     oflags |= SEC_DATA;
2349   if (flags & MMO_SEC_NEVER_LOAD)
2350     oflags |= SEC_NEVER_LOAD;
2351   if (flags & MMO_SEC_IS_COMMON)
2352     oflags |= SEC_IS_COMMON;
2353   if (flags & MMO_SEC_DEBUGGING)
2354     oflags |= SEC_DEBUGGING;
2355
2356   return oflags;
2357 }
2358
2359 /* Write a section.  */
2360
2361 static boolean
2362 mmo_internal_write_section (abfd, sec)
2363      bfd *abfd;
2364      asection *sec;
2365 {
2366   /* We do it differently depending on what section this is:
2367
2368    ".text": Output, prepended by information about the first source file
2369    (not yet implemented.)
2370
2371    ".data": Output.
2372
2373    (".MMIX.reg_contents": Not handled here.)
2374
2375    Anything else: Output inside a lop_spec 80, in the format described
2376    above.  */
2377
2378   if (strcmp (sec->name, MMO_TEXT_SECTION_NAME) == 0)
2379     /* FIXME: Output source file name and line number.  */
2380     return
2381       mmo_write_loc_chunk_list (abfd,
2382                                 ((struct mmo_section_data_struct *)
2383                                  (sec->used_by_bfd))->head);
2384   else if (strcmp (sec->name, MMO_DATA_SECTION_NAME) == 0)
2385     return
2386       mmo_write_loc_chunk_list (abfd,
2387                                 ((struct mmo_section_data_struct *)
2388                                  (sec->used_by_bfd))->head);
2389   else if (strcmp (sec->name, MMIX_REG_CONTENTS_SECTION_NAME) == 0)
2390     /* Not handled here.  */
2391     {
2392       /* This would normally be an abort call since this can't happen, but
2393          we don't do that.  */
2394       bfd_set_error (bfd_error_bad_value);
2395       return false;
2396     }
2397   else if (strncmp (sec->name, MMIX_OTHER_SPEC_SECTION_PREFIX,
2398                     strlen (MMIX_OTHER_SPEC_SECTION_PREFIX)) == 0)
2399     {
2400       int n = atoi (sec->name + strlen (MMIX_OTHER_SPEC_SECTION_PREFIX));
2401       mmo_write_tetra_raw (abfd, (LOP << 24) | (LOP_SPEC << 16) | n);
2402       return
2403         abfd->tdata.mmo_data->have_error == false
2404         && mmo_write_chunk_list (abfd,
2405                                  ((struct mmo_section_data_struct *)
2406                                   (sec->used_by_bfd))->head);
2407     }
2408   /* Ignore sections that are just allocated or empty; we write out
2409      _contents_ here.  */
2410   else if ((bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS) != 0
2411            && sec->_raw_size != 0)
2412     {
2413       /* Keep the document-comment formatted the way it is.  */
2414 /*
2415 INODE
2416 mmo section mapping, , Symbol-table, mmo
2417 SUBSECTION
2418         mmo section mapping
2419
2420         The implementation in BFD uses special data type 80 (decimal) to
2421         encapsulate and describe named sections, containing e.g.@: debug
2422         information.  If needed, any datum in the encapsulation will be
2423         quoted using lop_quote.  First comes a 32-bit word holding the
2424         number of 32-bit words containing the zero-terminated zero-padded
2425         segment name.  After the name there's a 32-bit word holding flags
2426         describing the section type.  Then comes a 64-bit big-endian word
2427         with the section length (in bytes), then another with the section
2428         start address.  Depending on the type of section, the contents
2429         might follow, zero-padded to 32-bit boundary.  For a loadable
2430         section (such as data or code), the contents might follow at some
2431         later point, not necessarily immediately, as a lop_loc with the
2432         same start address as in the section description, followed by the
2433         contents.  This in effect forms a descriptor that must be emitted
2434         before the actual contents.  Sections described this way must not
2435         overlap.
2436
2437         For areas that don't have such descriptors, synthetic sections are
2438         formed by BFD.  Consecutive contents in the two memory areas
2439         @samp{0x0000@dots{}00} to @samp{0x01ff@dots{}ff} and
2440         @samp{0x2000@dots{}00} to @samp{0x20ff@dots{}ff} are entered in
2441         sections named <<.text>> and <<.data>> respectively.  If an area
2442         is not otherwise described, but would together with a neighboring
2443         lower area be less than @samp{0x40000000} bytes long, it is joined
2444         with the lower area and the gap is zero-filled.  For other cases,
2445         a new section is formed, named <<.MMIX.sec.@var{n}>>.  Here,
2446         @var{n} is a number, a running count through the mmo file,
2447         starting at 0.
2448
2449 EXAMPLE
2450         A loadable section specified as:
2451
2452 | .section secname,"ax"
2453 | TETRA 1,2,3,4,-1,-2009
2454 | BYTE 80
2455
2456         and linked to address @samp{0x4}, is represented by the sequence:
2457
2458 | 0x98080050 - lop_spec 80
2459 | 0x00000002 - two 32-bit words for the section name
2460 | 0x7365636e - "secn"
2461 | 0x616d6500 - "ame\0"
2462 | 0x00000033 - flags CODE, READONLY, LOAD, ALLOC
2463 | 0x00000000 - high 32 bits of section length
2464 | 0x0000001c - section length is 28 bytes; 6 * 4 + 1 + alignment to 32 bits
2465 | 0x00000000 - high 32 bits of section address
2466 | 0x00000004 - section address is 4
2467 | 0x98010002 - 64 bits with address of following data
2468 | 0x00000000 - high 64 bits of address
2469 | 0x00000004 - data starts at address 4
2470 | 0x00000001 - 1
2471 | 0x00000002 - 2
2472 | 0x00000003 - 3
2473 | 0x00000004 - 4
2474 | 0xffffffff - -1
2475 | 0xfffff827 - -2009
2476 | 0x50000000 - 80 as a byte, padded with zeros.
2477
2478         Note that the lop_spec wrapping does not include the section
2479         contents.  Compare this to a non-loaded section specified as:
2480
2481 | .section thirdsec
2482 | TETRA 200001,100002
2483 | BYTE 38,40
2484
2485         This, when linked to address @samp{0x200000000000001c}, is
2486         represented by:
2487
2488 | 0x98080050 - lop_spec 80
2489 | 0x00000002 - two 32-bit words for the section name
2490 | 0x7365636e - "thir"
2491 | 0x616d6500 - "dsec"
2492 | 0x00000010 - flag READONLY
2493 | 0x00000000 - high 32 bits of section length
2494 | 0x0000000c - section length is 12 bytes; 2 * 4 + 2 + alignment to 32 bits
2495 | 0x20000000 - high 64 bits of address
2496 | 0x0000001c - low 64 bits of address 0x200000000000001c
2497 | 0x00030d41 - 200001
2498 | 0x000186a2 - 100002
2499 | 0x26280000 - 38, 40 as bytes, padded with zeros
2500
2501         For the latter example, the section contents must not to appear
2502         loaded in memory, and is therefore specified as part of the
2503         special data.  The address is usually unimportant but might
2504         provide information for e.g.@: the DWARF 2 debugging format.  */
2505
2506       mmo_write_tetra_raw (abfd, LOP_SPEC_SECTION);
2507       mmo_write_tetra (abfd, (strlen (sec->name) + 3) / 4);
2508       mmo_write_chunk (abfd, sec->name, strlen (sec->name));
2509       /* FIXME: We can get debug sections (.debug_line & Co.) with a
2510          section flag still having SEC_RELOC set.  Investigate.  This
2511          might be true for all alien sections; perhaps mmo.em should clear
2512          that flag.  Might be related to weak references.  */
2513       mmo_write_tetra (abfd,
2514                        mmo_sec_flags_from_bfd_flags
2515                        (bfd_get_section_flags (abfd, sec)));
2516       mmo_write_octa (abfd, sec->_raw_size);
2517       mmo_write_octa (abfd, bfd_get_section_vma (abfd, sec));
2518
2519       /* Writing a LOP_LOC ends the LOP_SPEC data, and makes data actually
2520          loaded.  */
2521       if (bfd_get_section_flags (abfd, sec) & SEC_LOAD)
2522           return
2523             abfd->tdata.mmo_data->have_error == false
2524             && mmo_write_loc_chunk_list (abfd,
2525                                          ((struct mmo_section_data_struct *)
2526                                           (sec->used_by_bfd))->head);
2527       return
2528         abfd->tdata.mmo_data->have_error == false
2529         && mmo_write_chunk_list (abfd,
2530                                  ((struct mmo_section_data_struct *)
2531                                   (sec->used_by_bfd))->head);
2532     }
2533   return true;
2534 }
2535
2536 /* We save up all data before output.  */
2537
2538 static boolean
2539 mmo_set_section_contents (abfd, sec, location, offset, bytes_to_do)
2540      bfd *abfd ATTRIBUTE_UNUSED;
2541      sec_ptr sec;
2542      PTR location;
2543      file_ptr offset;
2544      bfd_size_type bytes_to_do;
2545 {
2546   /* Iterate over diminishing chunk sizes, copying contents.  */
2547   while (bytes_to_do)
2548     {
2549       /* A minor song-and-dance to make sure we're not bitten by the
2550          distant possibility of the cast from bfd_vma to int making the
2551          chunk zero-sized.  */
2552       int chunk_size
2553         = (int) bytes_to_do != 0 ? bytes_to_do : MMO_SEC_CONTENTS_CHUNK_SIZE;
2554       bfd_byte *loc;
2555
2556       do
2557         loc = mmo_get_loc (sec, sec->vma + offset, chunk_size);
2558       while (loc == NULL && (chunk_size /= 2) != 0);
2559
2560       if (chunk_size == 0)
2561         return false;
2562
2563       memcpy (loc, location, chunk_size);
2564
2565       location += chunk_size;
2566       bytes_to_do -= chunk_size;
2567       offset += chunk_size;
2568     }
2569   return true;
2570 }
2571
2572 /* Add a symbol to a trie-tree.  */
2573
2574 static boolean
2575 mmo_internal_add_3_sym (abfd, rootp, symp)
2576      bfd *abfd;
2577      struct mmo_symbol_trie *rootp;
2578      CONST struct mmo_symbol *symp;
2579 {
2580   CONST char *name = symp->name;
2581   struct mmo_symbol_trie *trie = rootp;
2582   struct mmo_symbol_trie **triep = NULL;
2583
2584   while (*name && trie != NULL)
2585     {
2586       if (*name < trie->symchar)
2587         {
2588           triep = &trie->left;
2589           trie = trie->left;
2590         }
2591       else if (*name > trie->symchar)
2592         {
2593           triep = &trie->right;
2594           trie = trie->right;
2595         }
2596       else if (*name == trie->symchar)
2597         {
2598           triep = &trie->middle;
2599           name++;
2600
2601           /* Make sure "trie" points to where we should fill in the
2602              current symbol whenever we've iterated through "name".  We
2603              would lose the right position if we encounter "foobar" then
2604              "foo".  */
2605           if (*name)
2606             trie = trie->middle;
2607         }
2608     }
2609
2610   while (*name != 0)
2611     {
2612       /* Create middle branches for the rest of the characters.  */
2613       trie = bfd_zalloc (abfd, sizeof (struct mmo_symbol_trie));
2614       *triep = trie;
2615       trie->symchar = *name++;
2616       triep = &trie->middle;
2617     }
2618
2619   /* We discover a duplicate symbol rather late in the process, but still;
2620      we discover it and bail out.  */
2621   if (trie->sym.name != NULL)
2622     {
2623       (*_bfd_error_handler)
2624         (_("%s: invalid symbol table: duplicate symbol `%s'\n"),
2625          bfd_get_filename (abfd), trie->sym.name);
2626       bfd_set_error (bfd_error_bad_value);
2627       return false;
2628     }
2629
2630   memcpy (&trie->sym, symp, sizeof *symp);
2631   return true;
2632 }
2633
2634 /* Find out the length of the serialized version of a trie in bytes.  */
2635
2636 static unsigned int
2637 mmo_internal_3_length (abfd, trie)
2638      bfd *abfd;
2639      struct mmo_symbol_trie *trie;
2640 {
2641   /* First, one for the control byte.  */
2642   unsigned int length = 1;
2643
2644   if (trie == NULL)
2645     return 0;
2646
2647   /* Add in the recursion to the left.  */
2648   length += mmo_internal_3_length (abfd, trie->left);
2649
2650   /* Add in the middle trie and the character.  */
2651   length += 1 + mmo_internal_3_length (abfd, trie->middle);
2652
2653   /* Add in the recursion to the right.  */
2654   length += mmo_internal_3_length (abfd, trie->right);
2655
2656   /* Add in bytes for the symbol (if this is an endnode). */
2657   if (trie->sym.name != NULL)
2658     {
2659       unsigned int serno = trie->sym.serno;
2660
2661       /* First what it takes to encode the value. */
2662       if (trie->sym.sym_type == mmo_reg_sym)
2663         length++;
2664       else if (trie->sym.sym_type == mmo_undef_sym)
2665         length += 2;
2666       else
2667         {
2668           bfd_vma value = trie->sym.value;
2669
2670           /* Coded in one to eight following bytes.  */
2671           if (trie->sym.sym_type == mmo_data_sym)
2672             value -= (bfd_vma) 0x20 << 56;
2673
2674           do
2675             {
2676               value >>= 8;
2677               length++;
2678             }
2679           while (value != 0);
2680         }
2681
2682       /* Find out what it takes to encode the serial number.  */
2683       do
2684         {
2685           serno >>= 7;
2686           length++;
2687         }
2688       while (serno != 0);
2689     }
2690
2691   return length;
2692 }
2693
2694 /* Helper function for outputting the serial number of a symbol, output as
2695    a variant of leb128 (see dwarf2 documentation) which could be called
2696    beb128.  Using a helper function and recursion simplifies debugging.  */
2697
2698 static void
2699 mmo_beb128_out (abfd, serno, marker)
2700      bfd *abfd;
2701      int serno;
2702      int marker;
2703 {
2704   if (serno & ~0x7f)
2705     mmo_beb128_out (abfd, serno >> 7, 0);
2706   mmo_write_byte (abfd, marker | (serno & 0x7f));
2707 }
2708
2709 /* Serialize a trie.  */
2710
2711 static void
2712 mmo_internal_3_dump (abfd, trie)
2713      bfd *abfd;
2714      struct mmo_symbol_trie *trie;
2715 {
2716   bfd_byte control = 0;
2717
2718   if (trie == NULL)
2719     return;
2720
2721   if (trie->left)
2722     control |= MMO3_LEFT;
2723
2724   if (trie->middle)
2725     control |= MMO3_MIDDLE;
2726
2727   if (trie->right)
2728     control |= MMO3_RIGHT;
2729
2730   if (trie->sym.name != NULL)
2731     {
2732       /* Encode the symbol type and length of value bytes.  */
2733       if (trie->sym.sym_type == mmo_reg_sym)
2734         control |= MMO3_REGQUAL_BITS;
2735       else if (trie->sym.sym_type == mmo_undef_sym)
2736         control |= MMO3_UNDEF;
2737       else
2738         {
2739           bfd_vma value = trie->sym.value;
2740
2741           /* Coded in 1..8 following bytes.  */
2742           if (trie->sym.sym_type == mmo_data_sym)
2743             {
2744               control |= MMO3_DATA;
2745               value -= (bfd_vma) 0x20 << 56;
2746             }
2747
2748           do
2749             {
2750               value >>= 8;
2751               control++;
2752             }
2753           while (value != 0);
2754         }
2755     }
2756
2757   /* The control byte is output before recursing.  */
2758   mmo_write_byte (abfd, control);
2759
2760   mmo_internal_3_dump (abfd, trie->left);
2761
2762   if (control & MMO3_SYMBITS)
2763     {
2764       mmo_write_byte (abfd, trie->symchar);
2765
2766       if (trie->sym.name != NULL)
2767         {
2768           if (trie->sym.sym_type == mmo_reg_sym)
2769             mmo_write_byte (abfd, trie->sym.value);
2770           else if (trie->sym.sym_type == mmo_undef_sym)
2771             {
2772               mmo_write_byte (abfd, 0);
2773               mmo_write_byte (abfd, 0);
2774             }
2775           else
2776             {
2777               bfd_vma value = trie->sym.value;
2778
2779               bfd_byte byte_n = control & 15;
2780
2781               /* Coded in 1..8 following bytes.  Note that the value is
2782                  shifted out big-endian.  */
2783               if (trie->sym.sym_type == mmo_data_sym)
2784                 {
2785                   value -= (bfd_vma) 0x20 << 56;
2786                   byte_n -= 8;
2787                 }
2788
2789               do
2790                 {
2791                   mmo_write_byte (abfd, (value >> ((byte_n - 1) * 8)) & 0xff);
2792                   byte_n--;
2793                 }
2794               while (byte_n != 0);
2795             }
2796
2797           mmo_beb128_out (abfd, trie->sym.serno, 128);
2798         }
2799       mmo_internal_3_dump (abfd, trie->middle);
2800     }
2801   mmo_internal_3_dump (abfd, trie->right);
2802 }
2803
2804 /* Write symbols, either in mmo format or hidden in a lop_spec 80 section.
2805    Write the lop_end terminator also.  */
2806
2807 static boolean
2808 mmo_write_symbols_and_terminator (abfd)
2809      bfd *abfd;
2810 {
2811   int count = bfd_get_symcount (abfd);
2812   asymbol *fakemain[2];
2813   asymbol **table;
2814   int serno = 2;
2815   struct mmo_symbol_trie root;
2816   int trie_len;
2817   int i;
2818   bfd_byte buf[4];
2819
2820   /* Create a symbol for "Main".  */
2821   asymbol *mainsym = bfd_make_empty_symbol (abfd);
2822
2823   mainsym->flags = BSF_GLOBAL;
2824   mainsym->value = bfd_get_start_address (abfd);
2825   mainsym->name = MMIX_START_SYMBOL_NAME;
2826   mainsym->section = bfd_abs_section_ptr;
2827   fakemain[0] = mainsym;
2828   fakemain[1] = NULL;
2829
2830   memset (&root, 0, sizeof (root));
2831
2832   /* Make all symbols take a left turn.  */
2833   root.symchar = 0xff;
2834
2835   /* There must always be a ":Main", so we'll add one
2836      if there are no symbols.  */
2837   if (count == 0)
2838     {
2839       table = fakemain;
2840       count = 1;
2841     }
2842   else
2843     table = bfd_get_outsymbols (abfd);
2844
2845   for (i = 0; i < count && table[i] != NULL; i++)
2846     {
2847       asymbol *s = table[i];
2848
2849       /* It's not enough to consult bfd_is_local_label, since it does not
2850          mean "local" in the sense of linkable-and-observable-after-link.
2851          Let's just check the BSF_GLOBAL flag.
2852
2853          Also, don't export symbols with characters not in the allowed set.  */
2854       if ((s->flags & (BSF_DEBUGGING|BSF_GLOBAL)) == BSF_GLOBAL
2855           && strspn (s->name,
2856                      valid_mmo_symbol_character_set) == strlen (s->name))
2857         {
2858           struct mmo_symbol sym;
2859           memset (&sym, 0, sizeof (sym));
2860
2861           sym.name = s->name;
2862           sym.value =
2863             s->value
2864             + s->section->output_section->vma
2865             + s->section->output_offset;
2866
2867           if (bfd_is_und_section (s->section))
2868             sym.sym_type = mmo_undef_sym;
2869           else if (strcmp (s->section->name, MMO_DATA_SECTION_NAME) == 0
2870                    /* The encoding of data symbols require that the "rest"
2871                       of the value fits in 6 bytes, so the upper two bytes
2872                       must be 0x2000.  All other symbols get to be the
2873                       absolute type.  */
2874                    && (sym.value >> 48) == 0x2000)
2875             sym.sym_type = mmo_data_sym;
2876           else if (strcmp (s->section->name, MMIX_REG_SECTION_NAME) == 0)
2877             sym.sym_type = mmo_reg_sym;
2878           else if (strcmp (s->section->name,
2879                            MMIX_REG_CONTENTS_SECTION_NAME) == 0)
2880             {
2881               sym.sym_type = mmo_reg_sym;
2882               sym.value /= 8;
2883             }
2884           else
2885             sym.sym_type = mmo_abs_sym;
2886
2887           /* FIXME: We assume the order of the received symbols is an
2888              ordered mapping of the serial numbers.  This is not
2889              necessarily true if we e.g. objcopy a mmo file to another and
2890              there are gaps in the numbering.  Note sure if this can
2891              happen.  Not sure what to do.  */
2892           /* Make sure Main has serial number 1; others start at 2.  */
2893           if (strcmp (s->name, MMIX_START_SYMBOL_NAME) == 0)
2894             {
2895               sym.serno = 1;
2896
2897               /* Check that the value assigned to :Main is the same as the
2898                  entry address.  The default linker script asserts this.
2899                  This is as good a place as any to check this consistency. */
2900               if (sym.value != bfd_get_start_address (abfd))
2901                 {
2902                   /* Arbitrary buffer to hold the printable representation
2903                      of a vma.  */
2904                   char vmas_main[40];
2905                   char vmas_start[40];
2906                   bfd_vma vma_start = bfd_get_start_address (abfd);
2907
2908                   sprintf_vma (vmas_main, s->value);
2909                   sprintf_vma (vmas_start, vma_start);
2910
2911                   (*_bfd_error_handler)
2912                     (_("%s: Bad symbol definition: `Main' set to %s rather\
2913  than the start address %s\n"),
2914                      bfd_get_filename (abfd), vmas_main, vmas_start);
2915                   bfd_set_error (bfd_error_bad_value);
2916                   return false;
2917                 }
2918             }
2919           else
2920             sym.serno = serno++;
2921
2922           if (! mmo_internal_add_3_sym (abfd, &root, &sym))
2923             return false;
2924         }
2925     }
2926
2927   /* Change the root node to be a ":"-prefix.  */
2928   root.symchar = ':';
2929   root.middle = root.left;
2930   root.right = NULL;
2931   root.left = NULL;
2932
2933   /* We have to find out if we can fit the whole symbol table in the mmo
2934      symtab.  It would be bad to assume we can always fit it in 262144
2935      bytes.  If we can't, just leave the Main symbol.  */
2936   trie_len = (mmo_internal_3_length (abfd, &root) + 3)/4;
2937
2938   if (trie_len > 0xffff)
2939     {
2940       /* Test this code by using a lower limit in the test above and check
2941          that the single "Main" symbol is emitted and handled properly.
2942          There's no specific test-case.  */
2943       struct mmo_symbol sym;
2944
2945       (*_bfd_error_handler)
2946         (_("%s: warning: symbol table too large for mmo, larger than 65535\
2947  32-bit words: %d.  Only `Main' will be emitted.\n"),
2948          bfd_get_filename (abfd), trie_len);
2949
2950       memset (&sym, 0, sizeof (sym));
2951       sym.sym_type = mmo_abs_sym;
2952       sym.name = MMIX_START_SYMBOL_NAME;
2953       sym.serno = 1;
2954       sym.value = bfd_get_start_address (abfd);
2955
2956       /* Then patch up a symbol table to be just the ":Main" symbol.  */
2957       memset (&root, 0, sizeof (root));
2958       root.left = root.middle;
2959       root.symchar = 0xff;
2960       root.middle = NULL;
2961       root.right = NULL;
2962
2963       if (! mmo_internal_add_3_sym (abfd, &root, &sym))
2964         return false;
2965
2966       root.symchar = ':';
2967       root.middle = root.left;
2968       root.right = NULL;
2969       root.left = NULL;
2970
2971       trie_len = (mmo_internal_3_length (abfd, &root) + 3)/4;
2972     }
2973
2974   /* Reset the written-bytes counter.  */
2975   abfd->tdata.mmo_data->byte_no = 0;
2976
2977   /* Put out the lop_stab mark.  */
2978   bfd_put_32 (abfd, (LOP << 24) | (LOP_STAB << 16), buf);
2979   if (bfd_bwrite (buf, 4, abfd) != 4)
2980     return false;
2981
2982   /* Dump out symbols.  */
2983   mmo_internal_3_dump (abfd, &root);
2984
2985   if (trie_len != (abfd->tdata.mmo_data->byte_no + 3)/4)
2986     {
2987       /* I haven't seen this trig.  It seems no use claiming this case
2988          isn't debugged and abort if we get here.  Instead emit a
2989          diagnostic and fail "normally".  */
2990       (*_bfd_error_handler)
2991         (_("%s: internal error, symbol table changed size from %d to %d\
2992  words\n"),
2993          bfd_get_filename (abfd), trie_len,
2994          (abfd->tdata.mmo_data->byte_no + 3)/4);
2995       bfd_set_error (bfd_error_bad_value);
2996       return false;
2997     }
2998
2999   /* Dump out remaining bytes in the buffer and handle I/O errors by
3000      propagating errors.  */
3001   if ((abfd->tdata.mmo_data->byte_no % 4) != 0
3002       || abfd->tdata.mmo_data->have_error)
3003     {
3004       memset (abfd->tdata.mmo_data->buf + (abfd->tdata.mmo_data->byte_no % 4),
3005               0, 4 - (abfd->tdata.mmo_data->byte_no % 4));
3006
3007       if (abfd->tdata.mmo_data->have_error
3008           || bfd_bwrite (abfd->tdata.mmo_data->buf, 4, abfd) != 4)
3009         return false;
3010     }
3011
3012   bfd_put_32 (abfd, (LOP << 24) | (LOP_END << 16) | trie_len, buf);
3013   return bfd_bwrite (buf, 4, abfd) == 4;
3014 }
3015
3016 /* Write section unless it is the register contents section.  For that, we
3017    instead store the section in the supplied pointer.  This function is
3018    used through bfd_map_over_sections.  */
3019
3020 static void
3021 mmo_write_section_unless_reg_contents (abfd, sec, p)
3022      bfd *abfd;
3023      asection *sec;
3024      PTR p;
3025 {
3026   struct mmo_write_sec_info *infop = (struct mmo_write_sec_info *) p;
3027
3028   if (infop->retval == false)
3029     return;
3030
3031   if (strcmp (sec->name, MMIX_REG_CONTENTS_SECTION_NAME) == 0)
3032     {
3033       infop->reg_section = sec;
3034       return;
3035     }
3036
3037   /* Exclude the convenience register section.  */
3038   if (strcmp (sec->name, MMIX_REG_SECTION_NAME) == 0)
3039     {
3040       if (bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS)
3041         {
3042           /* Make sure it hasn't got contents.  It seems impossible to
3043              make it carry contents, so we don't have a test-case for
3044              this.  */
3045           (*_bfd_error_handler)
3046             (_("%s: internal error, internal register section %s had\
3047  contents\n"),
3048              bfd_get_filename (abfd), sec->name);
3049           bfd_set_error (bfd_error_bad_value);
3050           infop->retval = false;
3051           return;
3052         }
3053
3054       return;
3055     }
3056
3057   infop->retval = mmo_internal_write_section (abfd, sec);
3058 }
3059
3060 /* Do the actual output of a file.  Assumes mmo_set_section_contents is
3061    already called. */
3062
3063 static boolean
3064 mmo_write_object_contents (abfd)
3065      bfd *abfd;
3066 {
3067   struct mmo_write_sec_info wsecinfo;
3068
3069   /* First, there are a few words of preamble.  */
3070   if (! mmo_internal_write_header (abfd))
3071     return false;
3072
3073   wsecinfo.reg_section = NULL;
3074   wsecinfo.retval = true;
3075
3076   bfd_map_over_sections (abfd, mmo_write_section_unless_reg_contents,
3077                          (PTR) &wsecinfo);
3078
3079   if (wsecinfo.retval == false)
3080     return false;
3081
3082   if (wsecinfo.reg_section != NULL)
3083     {
3084       asection *sec = wsecinfo.reg_section;
3085       unsigned int z = (unsigned int) (sec->vma / 8);
3086
3087       /* Registers 0..31 must not be global.  Do sanity check on the "vma"
3088          of the register contents section and check that it corresponds to
3089          the length of the section.  */
3090       if (z < 32 || z >= 255 || (sec->vma & 7) != 0
3091           || sec->vma != 256 * 8 - sec->_raw_size - 8)
3092         {
3093           bfd_set_error (bfd_error_bad_value);
3094
3095           if (sec->_raw_size == 0)
3096             /* There must always be at least one such register.  */
3097             (*_bfd_error_handler)
3098               (_("%s: no initialized registers; section length 0\n"),
3099                bfd_get_filename (abfd));
3100           else if (sec->vma > (256 - 32) * 8)
3101             /* Provide better error message for the case of too many
3102                global registers.  */
3103             (*_bfd_error_handler)
3104               (_("%s: too many initialized registers; section length %ld\n"),
3105                bfd_get_filename (abfd),
3106                (long) sec->_raw_size);
3107           else
3108             (*_bfd_error_handler)
3109               (_("%s: invalid start address for initialized registers of\
3110  length %ld: 0x%lx%08lx\n"),
3111                bfd_get_filename (abfd),
3112                (long) sec->_raw_size,
3113                (unsigned long) (sec->vma >> 32), (unsigned long) (sec->vma));
3114
3115           return false;
3116         }
3117
3118       if (! mmo_internal_write_post (abfd, z, sec))
3119         return false;
3120     }
3121   else
3122     if (! mmo_internal_write_post (abfd, 255, NULL))
3123       return false;
3124
3125   return mmo_write_symbols_and_terminator (abfd);
3126 }
3127
3128 /* Return the size of a NULL pointer, so we support linking in an mmo
3129    object.  */
3130
3131 static long
3132 mmo_get_reloc_upper_bound (abfd, sec)
3133      bfd *abfd ATTRIBUTE_UNUSED;
3134      asection *sec ATTRIBUTE_UNUSED;
3135 {
3136   return sizeof (PTR);
3137 }
3138
3139 /* Similarly canonicalize relocs to empty, filling in the terminating NULL
3140    pointer.  */
3141
3142 long
3143 mmo_canonicalize_reloc (abfd, section, relptr, symbols)
3144      bfd *abfd ATTRIBUTE_UNUSED;
3145      sec_ptr section ATTRIBUTE_UNUSED;
3146      arelent **relptr;
3147      asymbol **symbols ATTRIBUTE_UNUSED;
3148 {
3149   *relptr = NULL;
3150   return 0;
3151 }
3152
3153 /* If there's anything in particular in a mmo bfd that we want to free,
3154    make this a real function.  Only do this if you see major memory
3155    thrashing; zealous free:ing will cause unwanted behavior, especially if
3156    you "free" memory allocated with "bfd_alloc", or even "bfd_release" a
3157    block allocated with "bfd_alloc"; they're really allocated from an
3158    obstack, and we don't know what was allocated there since this
3159    particular allocation.  */
3160
3161 #define mmo_close_and_cleanup _bfd_generic_close_and_cleanup
3162 #define mmo_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
3163
3164 /* Perhaps we need to adjust this one; mmo labels (originally) without a
3165    leading ':' might more appropriately be called local.  */
3166 #define mmo_bfd_is_local_label_name bfd_generic_is_local_label_name
3167
3168 /* Is this one really used or defined by anyone?  */
3169 #define mmo_get_lineno _bfd_nosymbols_get_lineno
3170
3171 /* FIXME: We can do better on this one, if we have a dwarf2 .debug_line
3172    section or if MMO line numbers are implemented.  */
3173 #define mmo_find_nearest_line _bfd_nosymbols_find_nearest_line
3174 #define mmo_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
3175 #define mmo_read_minisymbols _bfd_generic_read_minisymbols
3176 #define mmo_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
3177
3178 #define mmo_get_section_contents_in_window \
3179   _bfd_generic_get_section_contents_in_window
3180 #define mmo_bfd_get_relocated_section_contents \
3181   bfd_generic_get_relocated_section_contents
3182 #define mmo_bfd_gc_sections bfd_generic_gc_sections
3183 #define mmo_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
3184 #define mmo_bfd_link_add_symbols _bfd_generic_link_add_symbols
3185 #define mmo_bfd_final_link _bfd_generic_final_link
3186 #define mmo_bfd_link_split_section _bfd_generic_link_split_section
3187
3188 /* Strictly speaking, only MMIX uses this restricted format, but let's not
3189    stop anybody from shooting themselves in the foot.  */
3190 #define mmo_set_arch_mach bfd_default_set_arch_mach
3191 #define mmo_bfd_relax_section bfd_generic_relax_section
3192 #define mmo_bfd_merge_sections bfd_generic_merge_sections
3193
3194 /* objcopy will be upset if we return -1 from bfd_get_reloc_upper_bound by
3195    using BFD_JUMP_TABLE_RELOCS (_bfd_norelocs) rather than 0.  FIXME: Most
3196    likely a bug in the _bfd_norelocs definition.
3197
3198    On the other hand, we smuggle in an mmo object (because setting up ELF
3199    is too cumbersome) when linking (from other formats, presumably ELF) to
3200    represent the g255 entry.  We need to link that object, so need to say
3201    it has no relocs.  Upper bound for the size of the relocation table is
3202    the size of a NULL pointer, and we support "canonicalization" for that
3203    pointer.  */
3204 #define mmo_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
3205
3206 /* We want to copy time of creation, otherwise we'd use
3207    BFD_JUMP_TABLE_COPY (_bfd_generic).  */
3208 #define mmo_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
3209 #define mmo_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
3210 #define mmo_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
3211 #define mmo_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
3212 #define mmo_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
3213
3214 CONST bfd_target bfd_mmo_vec =
3215 {
3216   "mmo",                        /* name */
3217   bfd_target_mmo_flavour,
3218   BFD_ENDIAN_BIG,               /* target byte order */
3219   BFD_ENDIAN_BIG,               /* target headers byte order */
3220
3221   /* FIXME: Might need adjustments.  */
3222   (HAS_RELOC | EXEC_P |         /* object flags */
3223    HAS_LINENO | HAS_DEBUG |
3224    HAS_SYMS | HAS_LOCALS | WP_TEXT),
3225
3226   /* FIXME: Might need adjustments.  */
3227   (SEC_CODE | SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
3228    | SEC_READONLY | SEC_EXCLUDE | SEC_DEBUGGING | SEC_IN_MEMORY),
3229                                 /* section flags */
3230   0,                            /* leading underscore */
3231   ' ',                          /* ar_pad_char */
3232   16,                           /* ar_max_namelen */
3233   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
3234   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
3235   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* data */
3236   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
3237   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
3238   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* hdrs */
3239
3240   {
3241     _bfd_dummy_target,
3242     mmo_object_p,               /* bfd_check_format */
3243     _bfd_dummy_target,
3244     _bfd_dummy_target,
3245   },
3246   {
3247     bfd_false,
3248     mmo_mkobject,
3249     bfd_false,
3250     bfd_false,
3251   },
3252   {                             /* bfd_write_contents */
3253     bfd_false,
3254     mmo_write_object_contents,
3255     bfd_false,
3256     bfd_false,
3257   },
3258
3259   BFD_JUMP_TABLE_GENERIC (mmo),
3260   BFD_JUMP_TABLE_COPY (mmo),
3261   BFD_JUMP_TABLE_CORE (_bfd_nocore),
3262   BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
3263   BFD_JUMP_TABLE_SYMBOLS (mmo),
3264   /* We have to provide a valid method for getting relocs, returning zero,
3265      so we can't say BFD_JUMP_TABLE_RELOCS (_bfd_norelocs).  */
3266   BFD_JUMP_TABLE_RELOCS (mmo),
3267   BFD_JUMP_TABLE_WRITE (mmo),
3268   BFD_JUMP_TABLE_LINK (mmo),
3269   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
3270
3271   NULL,
3272
3273   NULL
3274 };