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