1 /* BFD back-end for mmo objects (MMIX-specific object-format).
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
8 This file is part of BFD, the Binary File Descriptor library.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
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.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
28 The mmo object format is used exclusively together with Professor
29 Donald E.@: Knuth's educational 64-bit processor MMIX. The simulator
30 @command{mmix} which is available at
31 @url{http://www-cs-faculty.stanford.edu/~knuth/programs/mmix.tar.gz}
32 understands this format. That package also includes a combined
33 assembler and linker called @command{mmixal}. The mmo format has
34 no advantages feature-wise compared to e.g. ELF. It is a simple
35 non-relocatable object format with no support for archives or
36 debugging information, except for symbol value information and
37 line numbers (which is not yet implemented in BFD). See
38 @url{http://www-cs-faculty.stanford.edu/~knuth/mmix.html} for more
39 information about MMIX. The ELF format is used for intermediate
40 object files in the BFD implementation.
42 @c We want to xref the symbol table node. A feature in "chew"
43 @c requires that "commands" do not contain spaces in the
44 @c arguments. Hence the hyphen in "Symbol-table".
48 @* mmo section mapping::
52 File layout, Symbol-table, mmo, mmo
56 The mmo file contents is not partitioned into named sections as
57 with e.g.@: ELF. Memory areas is formed by specifying the
58 location of the data that follows. Only the memory area
59 @samp{0x0000@dots{}00} to @samp{0x01ff@dots{}ff} is executable, so
60 it is used for code (and constants) and the area
61 @samp{0x2000@dots{}00} to @samp{0x20ff@dots{}ff} is used for
62 writable data. @xref{mmo section mapping}.
64 Contents is entered as 32-bit words, xor:ed over previous
65 contents, always zero-initialized. A word that starts with the
66 byte @samp{0x98} forms a command called a @samp{lopcode}, where
67 the next byte distinguished between the thirteen lopcodes. The
68 two remaining bytes, called the @samp{Y} and @samp{Z} fields, or
69 the @samp{YZ} field (a 16-bit big-endian number), are used for
70 various purposes different for each lopcode. As documented in
71 @url{http://www-cs-faculty.stanford.edu/~knuth/mmixal-intro.ps.gz},
74 There is provision for specifying ``special data'' of 65536
75 different types. We use type 80 (decimal), arbitrarily chosen the
76 same as the ELF <<e_machine>> number for MMIX, filling it with
77 section information normally found in ELF objects. @xref{mmo
82 0x98000001. The next word is contents, regardless of whether it
83 starts with 0x98 or not.
86 0x9801YYZZ, where @samp{Z} is 1 or 2. This is a location
87 directive, setting the location for the next data to the next
88 32-bit word (for @math{Z = 1}) or 64-bit word (for @math{Z = 2}),
89 plus @math{Y * 2^56}. Normally @samp{Y} is 0 for the text segment
90 and 2 for the data segment.
93 0x9802YYZZ. Increase the current location by @samp{YZ} bytes.
96 0x9803YYZZ, where @samp{Z} is 1 or 2. Store the current location
97 as 64 bits into the location pointed to by the next 32-bit
98 (@math{Z = 1}) or 64-bit (@math{Z = 2}) word, plus @math{Y *
102 0x9804YYZZ. @samp{YZ} is stored into the current location plus
106 0x980500ZZ. @samp{Z} is 16 or 24. A value @samp{L} derived from
107 the following 32-bit word are used in a manner similar to
108 @samp{YZ} in lop_fixr: it is xor:ed into the current location
109 minus @math{4 * L}. The first byte of the word is 0 or 1. If it
110 is 1, then @math{L = (@var{lowest 24 bits of word}) - 2^Z}, if 0,
111 then @math{L = (@var{lowest 24 bits of word})}.
114 0x9806YYZZ. @samp{Y} is the file number, @samp{Z} is count of
115 32-bit words. Set the file number to @samp{Y} and the line
116 counter to 0. The next @math{Z * 4} bytes contain the file name,
117 padded with zeros if the count is not a multiple of four. The
118 same @samp{Y} may occur multiple times, but @samp{Z} must be 0 for
119 all but the first occurrence.
122 0x9807YYZZ. @samp{YZ} is the line number. Together with
123 lop_file, it forms the source location for the next 32-bit word.
124 Note that for each non-lopcode 32-bit word, line numbers are
125 assumed incremented by one.
128 0x9808YYZZ. @samp{YZ} is the type number. Data until the next
129 lopcode other than lop_quote forms special data of type @samp{YZ}.
130 @xref{mmo section mapping}.
132 Other types than 80, (or type 80 with a content that does not
133 parse) is stored in sections named <<.MMIX.spec_data.@var{n}>>
134 where @var{n} is the @samp{YZ}-type. The flags for such a
135 sections say not to allocate or load the data. The vma is 0.
136 Contents of multiple occurrences of special data @var{n} is
137 concatenated to the data of the previous lop_spec @var{n}s. The
138 location in data or code at which the lop_spec occurred is lost.
141 0x980901ZZ. The first lopcode in a file. The @samp{Z} field forms the
142 length of header information in 32-bit words, where the first word
143 tells the time in seconds since @samp{00:00:00 GMT Jan 1 1970}.
146 0x980a00ZZ. @math{Z > 32}. This lopcode follows after all
147 content-generating lopcodes in a program. The @samp{Z} field
148 denotes the value of @samp{rG} at the beginning of the program.
149 The following @math{256 - Z} big-endian 64-bit words are loaded
150 into global registers @samp{$G} @dots{} @samp{$255}.
153 0x980b0000. The next-to-last lopcode in a program. Must follow
154 immediately after the lop_post lopcode and its data. After this
155 lopcode follows all symbols in a compressed format
156 (@pxref{Symbol-table}).
159 0x980cYYZZ. The last lopcode in a program. It must follow the
160 lop_stab lopcode and its data. The @samp{YZ} field contains the
161 number of 32-bit words of symbol table information after the
162 preceding lop_stab lopcode.
165 Note that the lopcode "fixups"; <<lop_fixr>>, <<lop_fixrx>> and
166 <<lop_fixo>> are not generated by BFD, but are handled. They are
167 generated by <<mmixal>>.
170 This trivial one-label, one-instruction file:
174 can be represented this way in mmo:
176 | 0x98090101 - lop_pre, one 32-bit word with timestamp.
178 | 0x98010002 - lop_loc, text segment, using a 64-bit address.
179 | Note that mmixal does not emit this for the file above.
180 | 0x00000000 - Address, high 32 bits.
181 | 0x00000000 - Address, low 32 bits.
182 | 0x98060002 - lop_file, 2 32-bit words for file-name.
183 | 0x74657374 - "test"
184 | 0x2e730000 - ".s\0\0"
185 | 0x98070001 - lop_line, line 1.
186 | 0x00010203 - TRAP 1,2,3
187 | 0x980a00ff - lop_post, setting $255 to 0.
190 | 0x980b0000 - lop_stab for ":Main" = 0, serial 1.
191 | 0x203a4040 @xref{Symbol-table}.
196 | 0x980c0005 - lop_end; symbol table contained five 32-bit words. */
201 #include "libiberty.h"
202 #include "elf/mmix.h"
203 #include "opcode/mmix.h"
220 #define LOP_QUOTE_NEXT ((LOP << 24) | (LOP_QUOTE << 16) | 1)
221 #define SPEC_DATA_SECTION 80
222 #define LOP_SPEC_SECTION \
223 ((LOP << 24) | (LOP_SPEC << 16) | SPEC_DATA_SECTION)
225 /* Must be a power of two. If you change this to be >= 64k, you need a
226 new test-case; the ld test b-loc64k.d touches chunk-size problem areas. */
227 #define MMO_SEC_CONTENTS_CHUNK_SIZE (1 << 15)
229 /* An arbitrary number for the maximum length section name size. */
230 #define MAX_SECTION_NAME_SIZE (1024 * 1024)
232 /* A quite arbitrary number for the maximum length section size. */
233 #define MAX_ARTIFICIAL_SECTION_SIZE (1024 * 1024 * 1024)
235 #define MMO3_WCHAR 0x80
236 #define MMO3_LEFT 0x40
237 #define MMO3_MIDDLE 0x20
238 #define MMO3_RIGHT 0x10
239 #define MMO3_TYPEBITS 0xf
240 #define MMO3_REGQUAL_BITS 0xf
243 #define MMO3_SYMBITS 0x2f
245 /* Put these everywhere in new code. */
246 #define FATAL_DEBUG \
247 _bfd_abort (__FILE__, __LINE__, \
248 "Internal: Non-debugged code (test-case missing)")
250 #define BAD_CASE(x) \
251 _bfd_abort (__FILE__, __LINE__, \
254 enum mmo_sym_type { mmo_reg_sym, mmo_undef_sym, mmo_data_sym, mmo_abs_sym};
256 /* When scanning the mmo file, a linked list of mmo_symbol
257 structures is built to represent the symbol table (if there is
262 struct mmo_symbol *next;
265 enum mmo_sym_type sym_type;
269 struct mmo_data_list_struct
271 struct mmo_data_list_struct *next;
274 bfd_size_type allocated_size;
278 typedef struct mmo_data_list_struct mmo_data_list_type;
280 struct mmo_symbol_trie
282 struct mmo_symbol_trie *left;
283 struct mmo_symbol_trie *right;
284 struct mmo_symbol_trie *middle;
288 /* A zero name means there's nothing here. */
289 struct mmo_symbol sym;
292 /* The mmo tdata information. */
294 struct mmo_data_struct
296 struct mmo_symbol *symbols;
297 struct mmo_symbol *symtail;
300 /* File representation of time (NULL) when this file was created. */
303 /* When we're reading bytes recursively, check this occasionally.
304 Also holds write errors. */
307 /* Max symbol length that may appear in the lop_stab table. Note that
308 this table might just hold a subset of symbols for not-really large
309 programs, as it can only be 65536 * 4 bytes large. */
310 int max_symbol_length;
312 /* Here's the symbol we build in lop_stab. */
313 char *lop_stab_symbol;
315 /* Index into lop_stab_symbol for the next character when parsing the
316 symbol information. */
319 /* When creating arbitrary sections, we need to count section numbers. */
322 /* When writing or reading byte-wise, we need to count the bytes
323 within a 32-bit word. */
326 /* We also need a buffer to hold the bytes we count reading or writing. */
330 typedef struct mmo_data_struct tdata_type;
332 struct mmo_section_data_struct
334 mmo_data_list_type *head;
335 mmo_data_list_type *tail;
338 /* These structures are used in bfd_map_over_sections constructs. */
340 /* Used when writing out sections; all but the register contents section
341 which is stored in reg_section. */
342 struct mmo_write_sec_info
344 asection *reg_section;
348 /* Used when trying to find a section corresponding to addr. */
349 struct mmo_find_sec_info
355 static boolean mmo_bfd_copy_private_bfd_data PARAMS ((bfd *, bfd *));
356 static void mmo_write_section_unless_reg_contents
357 PARAMS ((bfd *, asection *, PTR));
358 static void mmo_find_sec_w_addr PARAMS ((bfd *, asection *, PTR));
359 static void mmo_find_sec_w_addr_grow PARAMS ((bfd *, asection *, PTR));
360 static asection *mmo_make_section PARAMS ((bfd *, const char *));
361 static void mmo_get_symbol_info PARAMS ((bfd *, asymbol *, symbol_info *));
362 static void mmo_print_symbol
363 PARAMS ((bfd *, PTR, asymbol *, bfd_print_symbol_type));
364 static void mmo_init PARAMS ((void));
365 static boolean mmo_mkobject PARAMS ((bfd *));
366 static boolean mmo_scan PARAMS ((bfd *));
367 static asection *mmo_decide_section PARAMS ((bfd *, bfd_vma));
368 static asection *mmo_get_generic_spec_data_section PARAMS ((bfd *, int));
369 static asection *mmo_get_spec_section PARAMS ((bfd *, int));
370 static INLINE bfd_byte *mmo_get_loc PARAMS ((asection *, bfd_vma, int));
371 static void mmo_xore_64 PARAMS ((asection *, bfd_vma vma, bfd_vma value));
372 static void mmo_xore_32 PARAMS ((asection *, bfd_vma vma, unsigned int));
373 static void mmo_xore_16 PARAMS ((asection *, bfd_vma vma, unsigned int));
374 static const bfd_target *mmo_object_p PARAMS ((bfd *));
375 static void mmo_map_set_sizes PARAMS ((bfd *, asection *, PTR));
376 static boolean mmo_get_symbols PARAMS ((bfd *));
377 static boolean mmo_create_symbol PARAMS ((bfd *, const char *, bfd_vma,
378 enum mmo_sym_type, unsigned int));
379 static boolean mmo_get_section_contents
380 PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type));
381 static long mmo_get_symtab_upper_bound PARAMS ((bfd *));
382 static long mmo_get_symtab PARAMS ((bfd *, asymbol **));
383 static void mmo_get_symbol_info PARAMS ((bfd *, asymbol *, symbol_info *));
384 static void mmo_print_symbol PARAMS ((bfd *, PTR, asymbol *,
385 bfd_print_symbol_type));
386 static boolean mmo_set_section_contents
387 PARAMS ((bfd *, sec_ptr, PTR, file_ptr, bfd_size_type));
388 static int mmo_sizeof_headers PARAMS ((bfd *, boolean));
389 static long mmo_get_reloc_upper_bound PARAMS ((bfd *, asection *));
391 static boolean mmo_internal_write_header PARAMS ((bfd *));
392 static boolean mmo_internal_write_post PARAMS ((bfd *, int, asection *));
393 static boolean mmo_internal_add_3_sym
394 PARAMS ((bfd *, struct mmo_symbol_trie *, const struct mmo_symbol *));
395 static unsigned int mmo_internal_3_length
396 PARAMS ((bfd *, struct mmo_symbol_trie *));
397 static void mmo_internal_3_dump
398 PARAMS ((bfd *, struct mmo_symbol_trie *));
399 static void mmo_beb128_out PARAMS ((bfd *, int, int));
400 static boolean mmo_internal_write_section
401 PARAMS ((bfd *, asection *));
402 static void mmo_write_tetra PARAMS ((bfd *, unsigned int));
403 static void mmo_write_tetra_raw PARAMS ((bfd *, unsigned int));
404 static void mmo_write_octa PARAMS ((bfd *, bfd_vma));
405 static void mmo_write_octa_raw PARAMS ((bfd *, bfd_vma));
406 static boolean mmo_write_chunk
407 PARAMS ((bfd *, const bfd_byte *, unsigned int));
408 static boolean mmo_flush_chunk PARAMS ((bfd *));
409 static boolean mmo_write_loc_chunk
410 PARAMS ((bfd *, bfd_vma, const bfd_byte *, unsigned int, bfd_vma *));
411 static boolean mmo_write_chunk_list PARAMS ((bfd *, mmo_data_list_type *));
412 static boolean mmo_write_loc_chunk_list
413 PARAMS ((bfd *, mmo_data_list_type *));
414 static boolean mmo_write_symbols_and_terminator PARAMS ((bfd *));
415 static flagword mmo_sec_flags_from_bfd_flags PARAMS ((flagword));
416 static flagword bfd_sec_flags_from_mmo_flags PARAMS ((flagword));
417 static bfd_byte mmo_get_byte PARAMS ((bfd *));
418 static void mmo_write_byte PARAMS ((bfd *, bfd_byte));
419 static boolean mmo_new_section_hook PARAMS ((bfd *, asection *));
420 static int mmo_sort_mmo_symbols PARAMS ((const PTR, const PTR));
421 static boolean mmo_write_object_contents PARAMS ((bfd *));
422 static long mmo_canonicalize_reloc
423 PARAMS ((bfd *, sec_ptr, arelent **, asymbol **));
425 /* Global "const" variables initialized once. Must not depend on
426 particular input or caller; put such things into the bfd or elsewhere.
427 Look ma, no static per-invocation data! */
430 char valid_mmo_symbol_character_set[/* A-Z a-z (we assume consecutive
431 codes; sorry EBCDIC:ers!). */
432 + 'Z' - 'A' + 1 + 'z' - 'a' + 1
437 /* Codes higher than 126. */
443 /* Get section SECNAME or create one if it doesn't exist. When creating
444 one, new memory for the name is allocated. */
447 mmo_make_section (abfd, secname)
451 asection *sec = bfd_get_section_by_name (abfd, secname);
455 char *newsecname = strdup (secname);
457 if (newsecname == NULL)
459 (*_bfd_error_handler)
460 (_("%s: No core to allocate section name %s\n"),
461 bfd_get_filename (abfd), secname);
462 bfd_set_error (bfd_error_system_call);
465 sec = bfd_make_section (abfd, newsecname);
471 /* Nothing to do, but keep as a placeholder if we need it.
472 Note that state that might differ between bfd:s must not be initialized
473 here, nor must it be static. Add it to tdata information instead. */
478 static boolean inited = false;
481 static const char letters[]
482 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789:_";
488 /* Fill in the set of valid symbol characters. */
489 strcpy (valid_mmo_symbol_character_set, letters);
490 i = strlen (letters);
492 for (j = 126; j < 256; j++)
493 valid_mmo_symbol_character_set[i++] = j;
496 /* Check whether an existing file is an mmo file. */
498 static const bfd_target *
507 if (bfd_stat (abfd, &statbuf) < 0
508 || bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
509 || bfd_bread (b, 4, abfd) != 4)
512 /* All mmo files are a multiple of four bytes long.
513 Only recognize version one. */
514 if ((statbuf.st_size % 4) != 0
515 || b[0] != LOP || b[1] != LOP_PRE || b[2] != 1)
518 /* Get the last 32-bit word. */
519 if (bfd_seek (abfd, (file_ptr) statbuf.st_size - 4, SEEK_SET) != 0
520 || bfd_bread (b, 4, abfd) != 4)
523 /* Check if the file ends in a lop_end lopcode. */
524 if (b[0] != LOP || b[1] != LOP_END || ! mmo_mkobject (abfd))
527 /* Compute an upper bound on the max symbol length. Not really
528 important as all of the symbol information can only be 256k. */
529 abfd->tdata.mmo_data->max_symbol_length = (b[2] * 256 + b[3]) * 4;
530 abfd->tdata.mmo_data->lop_stab_symbol
531 = bfd_malloc (abfd->tdata.mmo_data->max_symbol_length + 1);
533 if (abfd->tdata.mmo_data->lop_stab_symbol == NULL)
535 (*_bfd_error_handler)
536 (_("%s: No core to allocate a symbol %d bytes long\n"),
537 bfd_get_filename (abfd), abfd->tdata.mmo_data->max_symbol_length);
541 /* Read in everything. */
542 if (! mmo_scan (abfd))
543 goto bad_format_free;
545 if (abfd->symcount > 0)
546 abfd->flags |= HAS_SYMS;
548 /* You'll have to tweak this if you want to use this format for other
549 arches (not recommended due to its small-size limitations). Look at
550 the ELF format for how to make it target-generic. */
551 if (! bfd_default_set_arch_mach (abfd, bfd_arch_mmix, 0))
552 goto bad_format_free;
557 free (abfd->tdata.mmo_data->lop_stab_symbol);
559 bfd_set_error (bfd_error_wrong_format);
564 /* Set up the mmo tdata information. */
572 if (abfd->tdata.mmo_data == NULL)
576 /* All fields are zero-initialized, so we don't have to explicitly
578 tdata_type *tdata = (tdata_type *) bfd_zmalloc (sizeof (tdata_type));
582 created = time (NULL);
583 bfd_put_32 (abfd, created, tdata->created);
585 abfd->tdata.mmo_data = tdata;
592 mmo_bfd_copy_private_bfd_data (ibfd, obfd)
596 if (bfd_get_flavour (ibfd) != bfd_target_mmo_flavour
597 || bfd_get_flavour (obfd) != bfd_target_mmo_flavour)
600 /* Copy the time the copied-from file was created. If people want the
601 time the file was last *modified*, they have that in the normal file
603 memcpy (obfd->tdata.mmo_data->created, ibfd->tdata.mmo_data->created,
604 sizeof (obfd->tdata.mmo_data->created));
608 /* Helper functions for mmo_decide_section, used through
609 bfd_map_over_sections. */
612 mmo_find_sec_w_addr (abfd, sec, p)
613 bfd *abfd ATTRIBUTE_UNUSED;
617 struct mmo_find_sec_info *infop = (struct mmo_find_sec_info *) p;
618 bfd_vma vma = bfd_get_section_vma (abfd, sec);
620 /* Ignore sections that aren't loaded. */
621 if ((bfd_get_section_flags (abfd, sec) & (SEC_LOAD | SEC_ALLOC))
622 != (SEC_LOAD | SEC_ALLOC))
625 if (infop->addr >= vma && infop->addr < vma + sec->_raw_size)
630 mmo_find_sec_w_addr_grow (abfd, sec, p)
631 bfd *abfd ATTRIBUTE_UNUSED;
635 struct mmo_find_sec_info *infop = (struct mmo_find_sec_info *) p;
636 bfd_vma vma = bfd_get_section_vma (abfd, sec);
638 /* Ignore sections that aren't loaded. */
639 if ((bfd_get_section_flags (abfd, sec) & (SEC_LOAD | SEC_ALLOC))
640 != (SEC_LOAD | SEC_ALLOC))
643 if (infop->addr >= vma && infop->addr < vma + MAX_ARTIFICIAL_SECTION_SIZE)
647 /* Find a section that corresponds to a VMA. Automatically create .text
648 or .data and set current section to it, depending on what vma. If we
649 can't deduce a section, make one up as ".MMIX.sec.N", where N is an
650 increasing number. */
653 mmo_decide_section (abfd, vma)
657 asection *sec = NULL;
658 char sec_name[sizeof (".MMIX.sec.") + 20];
659 struct mmo_find_sec_info info;
664 /* First see if there's a section that would match exactly. */
665 bfd_map_over_sections (abfd, mmo_find_sec_w_addr, &info);
667 if (info.sec != NULL)
670 /* If there's no such section, try and expand one of the existing ones,
671 up to a limit. Make sure we have .text and .data before we try that;
672 create them corresponding to expected addresses and set flags to make
673 them match the "loaded and with contents" expectation. */
674 if ((vma >> 56) == 0)
676 sec = bfd_make_section_old_way (abfd, MMO_TEXT_SECTION_NAME);
681 if (! sec->user_set_vma)
682 bfd_set_section_vma (abfd, sec, vma);
683 if (! bfd_set_section_flags (abfd, sec,
684 bfd_get_section_flags (abfd, sec)
685 | SEC_CODE | SEC_LOAD | SEC_ALLOC))
688 else if ((vma >> 56) == 0x20)
690 sec = bfd_make_section_old_way (abfd, MMO_DATA_SECTION_NAME);
695 if (! sec->user_set_vma)
696 bfd_set_section_vma (abfd, sec, vma);
697 if (! bfd_set_section_flags (abfd, sec,
698 bfd_get_section_flags (abfd, sec)
699 | SEC_LOAD | SEC_ALLOC))
703 bfd_map_over_sections (abfd, mmo_find_sec_w_addr_grow, &info);
705 if (info.sec != NULL)
708 /* If there's still no suitable section, make a new one. */
709 sprintf (sec_name, ".MMIX.sec.%d", abfd->tdata.mmo_data->sec_no++);
710 sec = mmo_make_section (abfd, sec_name);
711 if (! sec->user_set_vma)
712 bfd_set_section_vma (abfd, sec, vma);
714 if (! bfd_set_section_flags (abfd, sec,
715 bfd_get_section_flags (abfd, sec)
716 | SEC_LOAD | SEC_ALLOC))
721 /* Xor in a 64-bit value VALUE at VMA. */
724 mmo_xore_64 (sec, vma, value)
729 bfd_byte *loc = mmo_get_loc (sec, vma, 8);
730 bfd_vma prev = bfd_get_64 (sec->owner, loc);
733 bfd_put_64 (sec->owner, value, loc);
736 /* Xor in a 32-bit value VALUE at VMA. */
739 mmo_xore_32 (sec, vma, value)
744 bfd_byte *loc = mmo_get_loc (sec, vma, 4);
745 unsigned int prev = bfd_get_32 (sec->owner, loc);
748 bfd_put_32 (sec->owner, value, loc);
751 /* Xor in a 16-bit value VALUE at VMA. */
754 mmo_xore_16 (sec, vma, value)
759 bfd_byte *loc = mmo_get_loc (sec, vma, 2);
760 unsigned int prev = bfd_get_16 (sec->owner, loc);
763 bfd_put_16 (sec->owner, value, loc);
766 /* Write a 32-bit word to output file, no lop_quote generated. */
769 mmo_write_tetra_raw (abfd, value)
775 bfd_put_32 (abfd, value, buf);
777 if (bfd_bwrite ((PTR) buf, 4, abfd) != 4)
778 abfd->tdata.mmo_data->have_error = true;
781 /* Write a 32-bit word to output file; lop_quote if necessary. */
784 mmo_write_tetra (abfd, value)
788 if (((value >> 24) & 0xff) == LOP)
789 mmo_write_tetra_raw (abfd, LOP_QUOTE_NEXT);
791 mmo_write_tetra_raw (abfd, value);
794 /* Write a 64-bit word to output file, perhaps with lop_quoting. */
797 mmo_write_octa (abfd, value)
801 mmo_write_tetra (abfd, (unsigned int) (value >> 32));
802 mmo_write_tetra (abfd, (unsigned int) value);
805 /* Write a 64-bit word to output file, without lop_quoting. */
808 mmo_write_octa_raw (abfd, value)
812 mmo_write_tetra_raw (abfd, (unsigned int) (value >> 32));
813 mmo_write_tetra_raw (abfd, (unsigned int) value);
816 /* Write quoted contents. Intended to be called multiple times in
817 sequence, followed by a call to mmo_flush_chunk. */
819 static INLINE boolean
820 mmo_write_chunk (abfd, loc, len)
825 boolean retval = true;
827 /* Fill up a tetra from bytes remaining from a previous chunk. */
828 if (abfd->tdata.mmo_data->byte_no != 0)
830 while (abfd->tdata.mmo_data->byte_no < 4 && len != 0)
832 abfd->tdata.mmo_data->buf[abfd->tdata.mmo_data->byte_no++] = *loc++;
836 if (abfd->tdata.mmo_data->byte_no == 4)
838 mmo_write_tetra (abfd,
839 bfd_get_32 (abfd, abfd->tdata.mmo_data->buf));
840 abfd->tdata.mmo_data->byte_no = 0;
847 mmo_write_tetra_raw (abfd, LOP_QUOTE_NEXT);
850 && ! abfd->tdata.mmo_data->have_error
851 && 4 == bfd_bwrite ((PTR) loc, 4, abfd));
859 memcpy (abfd->tdata.mmo_data->buf, loc, len);
860 abfd->tdata.mmo_data->byte_no = len;
864 abfd->tdata.mmo_data->have_error = true;
868 /* Flush remaining bytes, from a previous mmo_write_chunk, zero-padded to
871 static INLINE boolean
872 mmo_flush_chunk (abfd)
875 if (abfd->tdata.mmo_data->byte_no != 0)
877 memset (abfd->tdata.mmo_data->buf + abfd->tdata.mmo_data->byte_no,
878 0, 4 - abfd->tdata.mmo_data->byte_no);
879 mmo_write_tetra (abfd,
880 bfd_get_32 (abfd, abfd->tdata.mmo_data->buf));
881 abfd->tdata.mmo_data->byte_no = 0;
884 return ! abfd->tdata.mmo_data->have_error;
887 /* Same, but from a list. */
889 static INLINE boolean
890 mmo_write_chunk_list (abfd, datap)
892 mmo_data_list_type *datap;
894 for (; datap != NULL; datap = datap->next)
895 if (! mmo_write_chunk (abfd, datap->data, datap->size))
898 return mmo_flush_chunk (abfd);
901 /* Write a lop_loc and some contents. A caller needs to call
902 mmo_flush_chunk after calling this function. The location is only
903 output if different than *LAST_VMAP, which is updated after this call. */
906 mmo_write_loc_chunk (abfd, vma, loc, len, last_vmap)
913 /* Find an initial and trailing section of zero tetras; we don't need to
914 write out zeros. FIXME: When we do this, we should emit section size
915 and address specifiers, else objcopy can't always perform an identity
917 while (len >= 4 && bfd_get_32 (abfd, loc) == 0)
924 while (len >= 4 && bfd_get_32 (abfd, loc + len - 4) == 0)
927 /* Only write out the location if it's different than the one the caller
928 (supposedly) previously handled, accounting for omitted leading zeros. */
929 if (vma != *last_vmap)
931 /* We might be in the middle of a sequence. */
932 mmo_flush_chunk (abfd);
934 /* We always write the location as 64 bits; no use saving bytes
936 mmo_write_tetra_raw (abfd, (LOP << 24) | (LOP_LOC << 16) | 2);
937 mmo_write_octa_raw (abfd, vma);
940 /* Update to reflect end of this chunk, with trailing zeros omitted. */
941 *last_vmap = vma + len;
943 return (! abfd->tdata.mmo_data->have_error
944 && mmo_write_chunk (abfd, loc, len));
947 /* Same, but from a list. */
949 static INLINE boolean
950 mmo_write_loc_chunk_list (abfd, datap)
952 mmo_data_list_type *datap;
954 /* Get an address different than the address of the first chunk. */
955 bfd_vma last_vma = datap ? datap->where - 1 : 0;
957 for (; datap != NULL; datap = datap->next)
958 if (! mmo_write_loc_chunk (abfd, datap->where, datap->data, datap->size,
962 return mmo_flush_chunk (abfd);
965 /* Make a .MMIX.spec_data.N section. */
968 mmo_get_generic_spec_data_section (abfd, spec_data_number)
970 int spec_data_number;
973 char secname[sizeof (MMIX_OTHER_SPEC_SECTION_PREFIX) + 20]
974 = MMIX_OTHER_SPEC_SECTION_PREFIX;
976 sprintf (secname + strlen (MMIX_OTHER_SPEC_SECTION_PREFIX),
977 "%d", spec_data_number);
979 sec = mmo_make_section (abfd, secname);
984 /* Make a special section for SPEC_DATA_NUMBER. If it is the one we use
985 ourselves, parse some of its data to get at the section name. */
988 mmo_get_spec_section (abfd, spec_data_number)
990 int spec_data_number;
995 unsigned int secname_length;
997 bfd_vma section_length;
999 mmo_data_list_type *loc;
1003 /* If this isn't the "special" special data, then make a placeholder
1005 if (spec_data_number != SPEC_DATA_SECTION)
1006 return mmo_get_generic_spec_data_section (abfd, spec_data_number);
1008 /* Seek back to this position if there was a format error. */
1009 orig_pos = bfd_tell (abfd);
1011 /* Read the length (in 32-bit words). */
1012 if (bfd_bread (buf, 4, abfd) != 4)
1017 if (buf[1] != LOP_QUOTE)
1020 if (bfd_bread (buf, 4, abfd) != 4)
1024 /* We don't care to keep the name length accurate. It's
1026 secname_length = bfd_get_32 (abfd, buf) * 4;
1028 /* Check section name length for sanity. */
1029 if (secname_length > MAX_SECTION_NAME_SIZE)
1032 /* This should be free'd regardless if a section is created. */
1033 secname = bfd_malloc (secname_length + 1);
1034 secname[secname_length] = 0;
1036 for (i = 0; i < secname_length / 4; i++)
1038 if (bfd_bread (secname + i * 4, 4, abfd) != 4)
1039 goto format_error_free;
1041 if (secname[i * 4] == LOP)
1043 /* A bit of overkill, but we handle char 0x98 in a section name,
1044 and recognize misparsing. */
1045 if (secname[i * 4 + 1] != LOP_QUOTE
1046 || bfd_bread (secname + i * 4, 4, abfd) != 4)
1047 /* Whoops. We thought this was a name, and now we found a
1048 non-lop_quote lopcode before we parsed the whole length of
1049 the name. Signal end-of-file in the same manner. */
1050 goto format_error_free;
1054 /* Get the section flags. */
1055 if (bfd_bread (buf, 4, abfd) != 4
1057 && (buf[1] != LOP_QUOTE || bfd_bread (buf, 4, abfd) != 4)))
1058 goto format_error_free;
1060 flags = bfd_get_32 (abfd, buf);
1062 /* Get the section length. */
1063 if (bfd_bread (buf, 4, abfd) != 4
1065 && (buf[1] != LOP_QUOTE || bfd_bread (buf, 4, abfd) != 4)))
1066 goto format_error_free;
1068 section_length = (bfd_vma) bfd_get_32 (abfd, buf) << 32;
1070 /* That's the first, high-part. Now get the low part. */
1072 if (bfd_bread (buf, 4, abfd) != 4
1074 && (buf[1] != LOP_QUOTE || bfd_bread (buf, 4, abfd) != 4)))
1075 goto format_error_free;
1077 section_length |= (bfd_vma) bfd_get_32 (abfd, buf);
1079 /* Check the section length for sanity. */
1080 if (section_length > MAX_ARTIFICIAL_SECTION_SIZE)
1081 goto format_error_free;
1083 /* Get the section VMA. */
1084 if (bfd_bread (buf, 4, abfd) != 4
1086 && (buf[1] != LOP_QUOTE || bfd_bread (buf, 4, abfd) != 4)))
1087 goto format_error_free;
1089 section_vma = (bfd_vma) bfd_get_32 (abfd, buf) << 32;
1091 /* That's the first, high-part. Now get the low part. */
1092 if (bfd_bread (buf, 4, abfd) != 4
1094 && (buf[1] != LOP_QUOTE || bfd_bread (buf, 4, abfd) != 4)))
1095 goto format_error_free;
1097 section_vma |= (bfd_vma) bfd_get_32 (abfd, buf);
1099 sec = mmo_make_section (abfd, secname);
1104 /* We allocate a buffer here for the advertised size, with head room for
1105 tetrabyte alignment. */
1106 loc = bfd_zmalloc (section_length + 3
1107 + sizeof (struct mmo_data_list_struct));
1111 /* Use a TETRA-rounded size for the allocated buffer; we set the
1112 "visible" section size below. */
1113 loc->size = (section_length + 3) & ~3;
1115 /* Add in the section flags we found to those bfd entered during this
1116 process and set the contents. */
1117 if (! bfd_set_section_flags (abfd, sec,
1118 bfd_sec_flags_from_mmo_flags (flags)
1119 | bfd_get_section_flags (abfd, sec)
1120 | (section_length != 0 ? SEC_HAS_CONTENTS : 0))
1121 || ! bfd_set_section_size (abfd, sec,
1122 sec->_cooked_size + section_length)
1123 /* Set VMA only for the first occurrence. */
1124 || (! sec->user_set_vma
1125 && ! bfd_set_section_vma (abfd, sec, section_vma)))
1127 /* If we get an error for any of the calls above, signal more than
1128 just a format error for the spec section. */
1133 if (((struct mmo_section_data_struct *) (sec->used_by_bfd))->tail != NULL)
1134 ((struct mmo_section_data_struct *) (sec->used_by_bfd))->tail->next
1137 ((struct mmo_section_data_struct *) (sec->used_by_bfd))->head = loc;
1138 ((struct mmo_section_data_struct *) (sec->used_by_bfd))->tail = loc;
1139 loc->where = section_vma;
1146 if (bfd_seek (abfd, orig_pos, SEEK_SET) != 0)
1149 return mmo_get_generic_spec_data_section (abfd, spec_data_number);
1152 /* Read a byte, but read from file in multiples of 32-bit words. */
1160 if (abfd->tdata.mmo_data->byte_no == 0)
1162 if (! abfd->tdata.mmo_data->have_error
1163 && bfd_bread (abfd->tdata.mmo_data->buf, 4, abfd) != 4)
1165 abfd->tdata.mmo_data->have_error = true;
1167 /* A value somewhat safe against tripping on some inconsistency
1168 when mopping up after this error. */
1173 retval = abfd->tdata.mmo_data->buf[abfd->tdata.mmo_data->byte_no];
1174 abfd->tdata.mmo_data->byte_no = (abfd->tdata.mmo_data->byte_no + 1) % 4;
1179 /* Write a byte, in multiples of 32-bit words. */
1182 mmo_write_byte (abfd, value)
1186 abfd->tdata.mmo_data->buf[(abfd->tdata.mmo_data->byte_no++ % 4)] = value;
1187 if ((abfd->tdata.mmo_data->byte_no % 4) == 0)
1189 if (! abfd->tdata.mmo_data->have_error
1190 && bfd_bwrite (abfd->tdata.mmo_data->buf, 4, abfd) != 4)
1191 abfd->tdata.mmo_data->have_error = true;
1195 /* Create a symbol. */
1198 mmo_create_symbol (abfd, symname, addr, sym_type, serno)
1200 const char *symname;
1202 enum mmo_sym_type sym_type;
1205 struct mmo_symbol *n;
1207 n = (struct mmo_symbol *) bfd_alloc (abfd, sizeof (struct mmo_symbol));
1211 n->name = bfd_alloc (abfd, strlen (symname) + 1);
1212 if (n->name == NULL)
1215 strcpy ((PTR) n->name, symname);
1218 n->sym_type = sym_type;
1221 if (abfd->tdata.mmo_data->symbols == NULL)
1222 abfd->tdata.mmo_data->symbols = n;
1224 abfd->tdata.mmo_data->symtail->next = n;
1225 abfd->tdata.mmo_data->symtail = n;
1230 /* Check that :Main equals the last octa of the .MMIX.reg_contents
1231 section, as it's the one place we're sure to pass when reading a mmo
1232 object. For written objects, we do it while setting the symbol
1234 if (strcmp (symname, MMIX_START_SYMBOL_NAME) == 0
1235 && bfd_get_start_address (abfd) != addr)
1237 (*_bfd_error_handler)
1238 (_("%s: invalid mmo file: initialization value for $255 is not `Main'\n"),
1239 bfd_get_filename (abfd));
1240 bfd_set_error (bfd_error_bad_value);
1247 /* Read in symbols. */
1250 mmo_get_symbols (abfd)
1255 Symbol-table, mmo section mapping, File layout, mmo
1259 From mmixal.w (or really, the generated mmixal.tex) in
1260 @url{http://www-cs-faculty.stanford.edu/~knuth/programs/mmix.tar.gz}):
1261 ``Symbols are stored and retrieved by means of a @samp{ternary
1262 search trie}, following ideas of Bentley and Sedgewick. (See
1263 ACM--SIAM Symp.@: on Discrete Algorithms @samp{8} (1997), 360--369;
1264 R.@:Sedgewick, @samp{Algorithms in C} (Reading, Mass.@:
1265 Addison--Wesley, 1998), @samp{15.4}.) Each trie node stores a
1266 character, and there are branches to subtries for the cases where
1267 a given character is less than, equal to, or greater than the
1268 character in the trie. There also is a pointer to a symbol table
1269 entry if a symbol ends at the current node.''
1271 So it's a tree encoded as a stream of bytes. The stream of bytes
1272 acts on a single virtual global symbol, adding and removing
1273 characters and signalling complete symbol points. Here, we read
1274 the stream and create symbols at the completion points.
1276 First, there's a control byte <<m>>. If any of the listed bits
1277 in <<m>> is nonzero, we execute what stands at the right, in
1281 | 0x40 - Traverse left trie.
1282 | (Read a new command byte and recurse.)
1285 | 0x2f - Read the next byte as a character and store it in the
1286 | current character position; increment character position.
1287 | Test the bits of <<m>>:
1290 | 0x80 - The character is 16-bit (so read another byte,
1291 | merge into current character.
1294 | 0xf - We have a complete symbol; parse the type, value
1295 | and serial number and do what should be done
1296 | with a symbol. The type and length information
1297 | is in j = (m & 0xf).
1299 | (MMO3_REGQUAL_BITS)
1300 | j == 0xf: A register variable. The following
1301 | byte tells which register.
1302 | j <= 8: An absolute symbol. Read j bytes as the
1303 | big-endian number the symbol equals.
1304 | A j = 2 with two zero bytes denotes an
1306 | j > 8: As with j <= 8, but add (0x20 << 56)
1307 | to the value in the following j - 8
1310 | Then comes the serial number, as a variant of
1311 | uleb128, but better named ubeb128:
1312 | Read bytes and shift the previous value left 7
1313 | (multiply by 128). Add in the new byte, repeat
1314 | until a byte has bit 7 set. The serial number
1315 | is the computed value minus 128.
1318 | 0x20 - Traverse middle trie. (Read a new command byte
1319 | and recurse.) Decrement character position.
1322 | 0x10 - Traverse right trie. (Read a new command byte and
1325 Let's look again at the <<lop_stab>> for the trivial file
1326 (@pxref{File layout}).
1328 | 0x980b0000 - lop_stab for ":Main" = 0, serial 1.
1335 This forms the trivial trie (note that the path between ``:'' and
1336 ``M'' is redundant):
1347 | 016e "n" is the last character in a full symbol, and
1348 | with a value represented in one byte.
1349 | 00 The value is 0.
1350 | 81 The serial number is 1. */
1352 bfd_byte m = mmo_get_byte (abfd);
1354 /* Check first if we have a bad hair day. */
1355 if (abfd->tdata.mmo_data->have_error)
1359 /* Traverse left trie. */
1360 mmo_get_symbols (abfd);
1362 if (m & MMO3_SYMBITS)
1364 bfd_byte c = mmo_get_byte (abfd);
1365 bfd_byte j = m & MMO3_TYPEBITS;
1367 enum mmo_sym_type sym_type;
1368 unsigned int serno = 0;
1373 bfd_byte c2 = mmo_get_byte (abfd);
1375 /* A two-byte character. We can't grok this, but neither can
1376 mmotype, for other cases than the second byte being zero. */
1380 abfd->tdata.mmo_data->lop_stab_symbol
1381 [abfd->tdata.mmo_data->symbol_position] = 0;
1383 (*_bfd_error_handler)
1384 (_("%s: unsupported wide character sequence\
1385 0x%02X 0x%02X after symbol name starting with `%s'\n"),
1386 bfd_get_filename (abfd), c, c2,
1387 abfd->tdata.mmo_data->lop_stab_symbol);
1388 bfd_set_error (bfd_error_bad_value);
1389 abfd->tdata.mmo_data->have_error = true;
1396 abfd->tdata.mmo_data->lop_stab_symbol[abfd->tdata.mmo_data->symbol_position++] = c;
1397 abfd->tdata.mmo_data->lop_stab_symbol[abfd->tdata.mmo_data->symbol_position] = 0;
1399 if (j & MMO3_REGQUAL_BITS)
1401 if (j == MMO3_REGQUAL_BITS)
1403 sym_type = mmo_reg_sym;
1404 addr = mmo_get_byte (abfd);
1410 for (i = 0; i < j; i++)
1411 addr = (addr << 8) + mmo_get_byte (abfd);
1413 if (addr == 0 && j == MMO3_UNDEF)
1414 sym_type = mmo_undef_sym;
1416 sym_type = mmo_abs_sym;
1422 for (i = MMO3_DATA; i < j; i++)
1423 addr = (addr << 8) + mmo_get_byte (abfd);
1425 addr += (bfd_vma) 0x20 << 56;
1426 sym_type = mmo_data_sym;
1429 /* Get the serial number. */
1432 k = mmo_get_byte (abfd);
1433 serno = (serno << 7) + k;
1438 /* Got it. Now enter it. Skip a leading ":". */
1439 if (! abfd->tdata.mmo_data->have_error
1440 && ! mmo_create_symbol (abfd,
1441 abfd->tdata.mmo_data->lop_stab_symbol
1443 addr, sym_type, serno))
1444 abfd->tdata.mmo_data->have_error = true;
1447 if (m & MMO3_MIDDLE)
1448 /* Traverse middle trie. */
1449 mmo_get_symbols (abfd);
1451 abfd->tdata.mmo_data->symbol_position--;
1455 /* Traverse right trie. */
1456 mmo_get_symbols (abfd);
1458 return ! abfd->tdata.mmo_data->have_error;
1461 /* Get the location of memory area [VMA..VMA + SIZE - 1], which we think
1462 is in section SEC. Adjust and reallocate zero-initialized contents.
1463 If there's new contents, allocate to the next multiple of
1464 MMO_SEC_CONTENTS_CHUNK_SIZE. */
1466 static INLINE bfd_byte *
1467 mmo_get_loc (sec, vma, size)
1472 bfd_size_type allocated_size;
1473 struct mmo_section_data_struct *sdatap
1474 = (struct mmo_section_data_struct *) sec->used_by_bfd;
1475 struct mmo_data_list_struct *datap = sdatap->head;
1476 struct mmo_data_list_struct *entry;
1478 /* First search the list to see if we have the requested chunk in one
1479 piece, or perhaps if we have a suitable chunk with room to fit. */
1480 for (; datap != NULL; datap = datap->next)
1482 if (datap->where <= vma
1483 && datap->where + datap->size >= vma + size)
1484 return datap->data + vma - datap->where;
1485 else if (datap->where <= vma
1486 && datap->where + datap->allocated_size >= vma + size
1487 /* Only munch on the "allocated size" if it does not
1488 overlap the next chunk. */
1489 && (datap->next == NULL || datap->next->where >= vma + size))
1491 /* There was room allocated, but the size wasn't set to include
1493 datap->size += (vma + size) - (datap->where + datap->size);
1495 /* Update the section size. This happens only if we update the
1496 32-bit-aligned chunk size. Callers that have
1497 non-32-bit-aligned sections should do all allocation and
1498 size-setting by themselves or at least set the section size
1499 after the last allocating call to this function. */
1500 if (vma + size > sec->vma + sec->_raw_size)
1501 sec->_raw_size += (vma + size) - (sec->vma + sec->_raw_size);
1503 return datap->data + vma - datap->where;
1507 /* Not found; allocate a new block. First check in case we get a
1508 request for a size split up over several blocks; we'll have to return
1509 NULL for those cases, requesting the caller to split up the request.
1510 Requests with an address aligned on MMO_SEC_CONTENTS_CHUNK_SIZE bytes and
1511 for no more than MMO_SEC_CONTENTS_CHUNK_SIZE will always get resolved. */
1513 for (datap = sdatap->head; datap != NULL; datap = datap->next)
1514 if ((datap->where <= vma && datap->where + datap->size > vma)
1515 || (datap->where < vma + size
1516 && datap->where + datap->size >= vma + size))
1520 = (size + MMO_SEC_CONTENTS_CHUNK_SIZE - 1) & ~(MMO_SEC_CONTENTS_CHUNK_SIZE - 1);
1521 entry = (mmo_data_list_type *)
1522 bfd_zalloc (sec->owner, sizeof (mmo_data_list_type) + allocated_size);
1527 entry->allocated_size = allocated_size;
1529 datap = sdatap->head;
1531 /* Sort the records by address. Optimize for the common case of adding
1532 a record to the end of the list. */
1533 if (sdatap->tail != NULL && entry->where >= sdatap->tail->where)
1535 sdatap->tail->next = entry;
1537 sdatap->tail = entry;
1541 mmo_data_list_type **look;
1542 for (look = &sdatap->head;
1543 *look != NULL && (*look)->where < entry->where;
1544 look = &(*look)->next)
1546 entry->next = *look;
1548 if (entry->next == NULL)
1550 sdatap->tail = entry;
1552 /* We get here for the first time (at other times too) for this
1553 section. Say we have contents. */
1554 if (! bfd_set_section_flags (sec->owner, sec,
1555 bfd_get_section_flags (sec->owner, sec)
1556 | SEC_HAS_CONTENTS))
1561 /* Update the section size. This happens only when we add contents and
1562 re-size as we go. The section size will then be aligned to 32 bits. */
1563 if (vma + size > sec->vma + sec->_raw_size)
1564 sec->_raw_size += (vma + size) - (sec->vma + sec->_raw_size);
1568 /* Set sizes once we've read in all sections. */
1571 mmo_map_set_sizes (abfd, sec, ignored)
1572 bfd *abfd ATTRIBUTE_UNUSED;
1574 PTR ignored ATTRIBUTE_UNUSED;
1576 sec->_cooked_size = sec->_raw_size;
1577 sec->lma = sec->vma;
1580 /* Read the mmo file and turn it into sections. */
1587 unsigned int lineno = 1;
1588 boolean error = false;
1590 asection *sec = bfd_make_section_old_way (abfd, MMO_TEXT_SECTION_NAME);
1591 asection *non_spec_sec = NULL;
1592 bfd_vma non_spec_vma = 0;
1593 char *current_filename = NULL;
1594 bfd_size_type nbytes_read = 0;
1595 /* Buffer with room to read a 64-bit value. */
1598 char *file_names[256];
1600 memset (file_names, 0, sizeof (file_names));
1602 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
1605 while ((nbytes_read = bfd_bread (buf, 4, abfd)) == 4)
1609 unsigned int y = bfd_get_8 (abfd, buf + 2);
1610 unsigned int z = bfd_get_8 (abfd, buf + 3);
1612 /* Change back to the original section for lopcodes other
1613 than LOP_QUOTE that comes after a LOP_SPEC. */
1614 if ((buf[1] != LOP_QUOTE || y != 0 || z != 1)
1615 && non_spec_sec != NULL)
1619 non_spec_sec = NULL;
1625 (*_bfd_error_handler)
1626 (_("%s: invalid mmo file: unsupported lopcode `%d'\n"),
1627 bfd_get_filename (abfd), buf[1]);
1628 bfd_set_error (bfd_error_bad_value);
1632 /* Quote the next 32-bit word. */
1633 if (y != 0 || z != 1)
1635 (*_bfd_error_handler)
1636 (_("%s: invalid mmo file: expected YZ = 1 got YZ = %d for lop_quote\n"),
1637 bfd_get_filename (abfd), y*256+z);
1638 bfd_set_error (bfd_error_bad_value);
1641 if (bfd_bread (buf, 4, abfd) != 4)
1644 mmo_xore_32 (sec, vma, bfd_get_32 (abfd, buf));
1651 /* Set vma (and section). */
1652 vma = (bfd_vma) y << 56;
1655 /* Get a 32-bit value. */
1656 if (bfd_bread (buf, 4, abfd) != 4)
1659 vma += bfd_get_32 (abfd, buf);
1663 /* Get a 64-bit value. */
1664 if (bfd_bread (buf, 8, abfd) != 8)
1667 vma += bfd_get_64 (abfd, buf);
1671 (*_bfd_error_handler)
1672 (_("%s: invalid mmo file: expected z = 1 or z = 2, got z = %d for lop_loc\n"),
1673 bfd_get_filename (abfd), z);
1674 bfd_set_error (bfd_error_bad_value);
1678 sec = mmo_decide_section (abfd, vma);
1684 /* Move forward within the same section. */
1687 sec = mmo_decide_section (abfd, vma);
1693 /* A fixup: Store the current vma somewhere. Position using
1694 same format as LOP_LOC. */
1696 bfd_vma p = (bfd_vma) y << 56;
1701 /* Get a 32-bit value. */
1702 if (bfd_bread (buf, 4, abfd) != 4)
1705 p += bfd_get_32 (abfd, buf);
1709 /* Get a 64-bit value. */
1710 if (bfd_bread (buf, 8, abfd) != 8)
1713 p += bfd_get_64 (abfd, buf);
1717 (*_bfd_error_handler)
1718 (_("%s: invalid mmo file: expected z = 1 or z = 2, got z = %d for lop_fixo\n"),
1719 bfd_get_filename (abfd), z);
1720 bfd_set_error (bfd_error_bad_value);
1724 /* The section where we store this address might be a
1725 different one than the current section. */
1726 fixosec = mmo_decide_section (abfd, p);
1727 if (fixosec == NULL)
1729 mmo_xore_64 (fixosec, p, vma);
1734 /* A fixup: Store YZ of this lopcode into YZ at vma - 4 * yz. */
1736 unsigned int yz = (y * 256 + z);
1737 bfd_vma p = vma + 2 - 4 * yz;
1738 asection *fixrsec = mmo_decide_section (abfd, p);
1739 if (fixrsec == NULL)
1741 mmo_xore_16 (fixrsec, p, yz);
1746 /* A fixup, similar to lop_fixr, but taking larger numbers
1747 and can change branches into the opposite direction
1756 (*_bfd_error_handler)
1757 (_("%s: invalid mmo file: expected y = 0, got y = %d for lop_fixrx\n"),
1758 bfd_get_filename (abfd), y);
1759 bfd_set_error (bfd_error_bad_value);
1763 if (z != 16 && z != 24)
1765 (*_bfd_error_handler)
1766 (_("%s: invalid mmo file: expected z = 16 or z = 24, got z = %d for lop_fixrx\n"),
1767 bfd_get_filename (abfd), z);
1768 bfd_set_error (bfd_error_bad_value);
1772 /* Get the next 32-bit value. */
1773 if (bfd_bread (buf, 4, abfd) != 4)
1776 delta = bfd_get_32 (abfd, buf);
1778 /* Do an, ehm, involved calculation for the location of
1779 the fixup. See mmixal documentation for a verbose
1780 explanation. We follow it verbosely here for the
1783 p = vma - 4 * delta;
1784 else if (buf[0] == 1)
1785 p = vma - 4 * ((delta & 0xffffff) - (1 << z));
1788 (*_bfd_error_handler)
1789 (_("%s: invalid mmo file: leading byte of operand word must be 0 or 1, got %d for lop_fixrx\n"),
1790 bfd_get_filename (abfd), buf[0]);
1791 bfd_set_error (bfd_error_bad_value);
1795 fixrsec = mmo_decide_section (abfd, vma);
1796 if (fixrsec == NULL)
1798 mmo_xore_32 (fixrsec, p, delta);
1803 /* Set current file and perhaps the file name. Reset line
1807 char *fname = bfd_malloc (z * 4 + 1);
1811 (*_bfd_error_handler)
1812 (_("%s: cannot allocate file name for file number %d, %d bytes\n"),
1813 bfd_get_filename (abfd), y, z * 4 + 1);
1814 bfd_set_error (bfd_error_system_call);
1820 for (i = 0; i < z; i++)
1822 if (bfd_bread (fname + i * 4, 4, abfd) != 4)
1829 if (file_names[y] != NULL)
1831 (*_bfd_error_handler)
1832 (_("%s: invalid mmo file: file number %d `%s',\
1833 was already entered as `%s'\n"),
1834 bfd_get_filename (abfd), y, fname, file_names[y]);
1835 bfd_set_error (bfd_error_bad_value);
1839 file_names[y] = fname;
1842 if (file_names[y] == NULL)
1844 (*_bfd_error_handler)
1845 (_("%s: invalid mmo file: file name for number %d\
1846 was not specified before use\n"),
1847 bfd_get_filename (abfd), y);
1848 bfd_set_error (bfd_error_bad_value);
1852 current_filename = file_names[y];
1857 /* Set line number. */
1858 lineno = y * 256 + z;
1859 /* FIXME: Create a sequence of mmo-specific line number
1860 entries for each section, then translate into canonical
1865 /* Special data follows until the next non-lop_quote
1869 sec = mmo_get_spec_section (abfd, y * 256 + z);
1878 /* We ignore header information, except we read in the
1879 creation time from the first 32-bit word with the time
1880 in seconds since era. */
1882 && bfd_bread (abfd->tdata.mmo_data->created, 4,
1886 for (i = 1; i < z; i++)
1887 if (bfd_bread (buf, 4, abfd) != 4)
1893 /* This tells of the contents of registers $Z..$255 at
1894 startup. We make a section out of it, with VMA = Z * 8,
1895 but only if Z != 255 or the contents is non-zero. */
1900 bfd_vma startaddr_octa;
1902 /* Read first octaword outside loop to simplify logic when
1903 excluding the Z == 255, octa == 0 case. */
1904 if (bfd_bread (buf, 8, abfd) != 8)
1907 first_octa = bfd_get_64 (abfd, buf);
1909 /* Don't emit contents for the trivial case which is
1910 always present; $255 pointing to Main. */
1914 = bfd_make_section_old_way (abfd,
1915 MMIX_REG_CONTENTS_SECTION_NAME);
1917 loc = mmo_get_loc (rsec, z * 8, (255 - z) * 8);
1918 bfd_put_64 (abfd, first_octa, loc);
1920 for (i = z + 1; i < 255; i++)
1922 if (bfd_bread (loc + (i - z) * 8, 8, abfd) != 8)
1926 /* Read out the last octabyte, and use it to set the
1928 if (bfd_bread (buf, 8, abfd) != 8)
1931 startaddr_octa = bfd_get_64 (abfd, buf);
1934 startaddr_octa = first_octa;
1936 if (! bfd_set_start_address (abfd, startaddr_octa))
1938 /* Currently this can't fail, but this should handle
1940 bfd_set_error (bfd_error_bad_value);
1947 /* We read in the symbols now, not later. */
1948 if (y != 0 || z != 0)
1950 (*_bfd_error_handler)
1951 (_("%s: invalid mmo file: fields y and z of lop_stab\
1952 non-zero, y: %d, z: %d\n"),
1953 bfd_get_filename (abfd), y, z);
1954 bfd_set_error (bfd_error_bad_value);
1958 /* Save the location, so we can check that YZ in the LOP_END
1960 stab_loc = bfd_tell (abfd);
1962 /* It's not said that an MMO can be without symbols (though
1963 mmixal will refuse to assemble files without Main), but
1964 it seems it would still be a valid mmo-file, so allow it.
1965 We detect the absence of a symbol area in that the upper
1966 limit is computed (from the lop_end YZ field) as 0.
1967 Don't call mmo_get_symbols; it can only detect the end of
1968 a valid symbol trie, not the absence of one. */
1969 if (abfd->tdata.mmo_data->max_symbol_length != 0
1970 && ! mmo_get_symbols (abfd))
1976 /* This must be the last 32-bit word in an mmo file.
1978 struct stat statbuf;
1979 long curpos = bfd_tell (abfd);
1981 if (bfd_stat (abfd, &statbuf) < 0)
1984 if (statbuf.st_size != curpos)
1986 (*_bfd_error_handler)
1987 (_("%s: invalid mmo file: lop_end not last item in\
1989 bfd_get_filename (abfd));
1990 bfd_set_error (bfd_error_bad_value);
1994 /* Check that the YZ field is right. Subtract the size of
1995 this LOP_END in the calculation; YZ does not include
1997 if ((long) (y * 256 + z) * 4 != (curpos - stab_loc) - 4)
1999 (*_bfd_error_handler)
2000 (_("%s: invalid mmo file: YZ of lop_end (%ld)\
2001 not equal to the number of tetras to the preceding lop_stab (%ld)\n"),
2002 bfd_get_filename (abfd), (long) (y * 256 + z),
2003 (curpos - stab_loc - 4)/4);
2004 bfd_set_error (bfd_error_bad_value);
2008 bfd_map_over_sections (abfd, mmo_map_set_sizes, NULL);
2015 /* This wasn't a lopcode, so store it in the current section. */
2016 mmo_xore_32 (sec, vma & ~3, bfd_get_32 (abfd, buf));
2023 /* We know this file is a multiple of four bytes (checked in
2024 mmo_object_p), so if we got something other than 0, this was a bad
2025 file (although it's more likely we'll get 0 in that case too).
2026 If we got end-of-file, then there was no lop_stab, so the file has
2029 if (nbytes_read != 0)
2030 bfd_set_error (bfd_error_system_call);
2032 bfd_set_error (bfd_error_bad_value);
2037 /* Mark the .text and .data section with their normal attribute if they
2038 contain anything. This is not redundant wrt. mmo_decide_section,
2039 since that code might never execute, and conversely the alloc+code
2040 section flags must be set then. */
2041 sec = bfd_get_section_by_name (abfd, MMO_TEXT_SECTION_NAME);
2043 && (bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS)
2044 && ! bfd_set_section_flags (abfd, sec,
2045 bfd_get_section_flags (abfd, sec)
2046 | SEC_ALLOC | SEC_LOAD | SEC_CODE))
2049 sec = bfd_get_section_by_name (abfd, MMO_DATA_SECTION_NAME);
2051 && (bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS)
2052 && ! bfd_set_section_flags (abfd, sec,
2053 bfd_get_section_flags (abfd, sec)
2054 | SEC_ALLOC | SEC_LOAD))
2057 /* Free whatever resources we took. */
2058 for (i = 0; i < sizeof (file_names) / sizeof (file_names[0]); i++)
2060 free (file_names[i]);
2064 /* A hook to set up object file dependent section information. For mmo,
2065 we point out the shape of allocated section contents. */
2068 mmo_new_section_hook (abfd, newsect)
2069 bfd *abfd ATTRIBUTE_UNUSED;
2072 /* We zero-fill all fields and assume NULL is represented by an all
2073 zero-bit pattern. */
2074 newsect->used_by_bfd =
2075 (PTR) bfd_zalloc (abfd, sizeof (struct mmo_section_data_struct));
2077 if (!newsect->used_by_bfd)
2080 /* Always align to at least 32-bit words. */
2081 newsect->alignment_power = 2;
2085 /* We already have section contents loaded for sections that have
2089 mmo_get_section_contents (abfd, sec, location, offset, bytes_to_do)
2090 bfd *abfd ATTRIBUTE_UNUSED;
2091 asection *sec ATTRIBUTE_UNUSED;
2092 PTR location ATTRIBUTE_UNUSED;
2093 file_ptr offset ATTRIBUTE_UNUSED;
2094 bfd_size_type bytes_to_do ATTRIBUTE_UNUSED;
2096 /* Iterate over diminishing chunk sizes, copying contents, like
2097 mmo_set_section_contents. */
2100 /* A minor song-and-dance to make sure we're not bitten by the
2101 distant possibility of the cast from bfd_vma to int making the
2102 chunk zero-sized. */
2104 = (int) bytes_to_do != 0 ? bytes_to_do : MMO_SEC_CONTENTS_CHUNK_SIZE;
2108 loc = mmo_get_loc (sec, sec->vma + offset, chunk_size);
2109 while (loc == NULL && (chunk_size /= 2) != 0);
2111 if (chunk_size == 0)
2114 memcpy (location, loc, chunk_size);
2116 location += chunk_size;
2117 bytes_to_do -= chunk_size;
2118 offset += chunk_size;
2123 /* Return the amount of memory needed to read the symbol table. */
2126 mmo_get_symtab_upper_bound (abfd)
2127 bfd *abfd ATTRIBUTE_UNUSED;
2129 return (abfd->symcount + 1) * sizeof (asymbol *);
2132 /* Sort mmo symbols by serial number. */
2135 mmo_sort_mmo_symbols (arg1, arg2)
2139 const struct mmo_symbol *sym1 = *(const struct mmo_symbol **) arg1;
2140 const struct mmo_symbol *sym2 = *(const struct mmo_symbol **) arg2;
2142 /* Sort by serial number first. */
2143 if (sym1->serno < sym2->serno)
2145 else if (sym1->serno > sym2->serno)
2148 /* Then sort by address of the table entries. */
2149 return ((const char *) arg1 - (const char *) arg2);
2152 /* Translate the symbol table. */
2155 mmo_get_symtab (abfd, alocation)
2157 asymbol **alocation;
2159 unsigned int symcount = bfd_get_symcount (abfd);
2163 csymbols = abfd->tdata.mmo_data->csymbols;
2164 if (csymbols == NULL)
2167 struct mmo_symbol *s;
2168 struct mmo_symbol **msp;
2170 /* First we store the symbols into the table we'll return, then we
2171 qsort it on the serial number, with secondary on the address of
2172 the symbol, to preserve order if there would be non-unique serial
2174 for (s = abfd->tdata.mmo_data->symbols,
2175 msp = (struct mmo_symbol **) alocation;
2182 qsort (alocation, symcount, sizeof (struct mmo_symbol *),
2183 mmo_sort_mmo_symbols);
2185 csymbols = (asymbol *) bfd_alloc (abfd, symcount * sizeof (asymbol));
2186 if (csymbols == NULL && symcount != 0)
2188 abfd->tdata.mmo_data->csymbols = csymbols;
2190 for (msp = (struct mmo_symbol **) alocation, c = csymbols;
2197 c->value = s->value;
2198 c->flags = BSF_GLOBAL;
2200 if (s->sym_type == mmo_data_sym)
2203 = bfd_get_section_by_name (abfd, MMO_DATA_SECTION_NAME);
2205 if (c->section == NULL)
2206 c->section = bfd_abs_section_ptr;
2208 c->value -= c->section->vma;
2210 else if (s->sym_type == mmo_undef_sym)
2211 c->section = bfd_und_section_ptr;
2212 else if (s->sym_type == mmo_reg_sym)
2215 = bfd_make_section_old_way (abfd, MMIX_REG_SECTION_NAME);
2220 = bfd_get_section_by_name (abfd, MMO_TEXT_SECTION_NAME);
2223 && c->value >= textsec->vma
2224 && c->value <= textsec->vma + textsec->_cooked_size)
2226 c->section = textsec;
2227 c->value -= c->section->vma;
2230 c->section = bfd_abs_section_ptr;
2237 /* Last, overwrite the incoming table with the right-type entries. */
2238 for (i = 0; i < symcount; i++)
2239 *alocation++ = csymbols++;
2245 /* Get information about a symbol. */
2248 mmo_get_symbol_info (ignore_abfd, symbol, ret)
2249 bfd *ignore_abfd ATTRIBUTE_UNUSED;
2253 bfd_symbol_info (symbol, ret);
2257 mmo_print_symbol (abfd, afile, symbol, how)
2261 bfd_print_symbol_type how;
2263 FILE *file = (FILE *) afile;
2267 case bfd_print_symbol_name:
2268 fprintf (file, "%s", symbol->name);
2271 bfd_print_symbol_vandf (abfd, (PTR) file, symbol);
2273 fprintf (file, " %-5s %s",
2274 symbol->section->name,
2279 /* We can't map a file directly into executable code, so the
2280 size of header information is irrelevant. */
2283 mmo_sizeof_headers (abfd, exec)
2284 bfd *abfd ATTRIBUTE_UNUSED;
2285 boolean exec ATTRIBUTE_UNUSED;
2290 /* Write the (section-neutral) file preamble. */
2293 mmo_internal_write_header (abfd)
2296 const char lop_pre_bfd[] = { LOP, LOP_PRE, 1, 1};
2298 if (bfd_bwrite (lop_pre_bfd, 4, abfd) != 4)
2301 /* Copy creation time of original file. */
2302 if (bfd_bwrite (abfd->tdata.mmo_data->created, 4, abfd) != 4)
2308 /* Write the LOP_POST record, with global register initializations.
2309 Z is the Z field of the LOP_POST, corresponding to 255 - number of
2310 registers at DATA. The Z = 255 field is filled in with the
2314 mmo_internal_write_post (abfd, z, sec)
2321 mmo_write_tetra_raw (abfd, (LOP << 24) | (LOP_POST << 16) | z);
2323 for (i = z; i < 255; i++)
2325 bfd_byte *data = mmo_get_loc (sec, i * 8, 8);
2327 if (bfd_bwrite (data, 8, abfd) != 8)
2331 /* For Z == $255, we always emit the start location; supposedly Main,
2332 but we have it handy at bfd_get_start_address. If we're called with
2333 Z == 255, don't assume DATA is valid. */
2334 bfd_put_64 (abfd, bfd_get_start_address (abfd), buf);
2336 return ! abfd->tdata.mmo_data->have_error && bfd_bwrite (buf, 8, abfd) == 8;
2339 /* Translate to and from BFD flags. This is to make sure that we don't
2340 get bitten by BFD flag number changes. */
2343 mmo_sec_flags_from_bfd_flags (flags)
2346 flagword oflags = 0;
2348 if (flags & SEC_ALLOC)
2349 oflags |= MMO_SEC_ALLOC;
2350 if (flags & SEC_LOAD)
2351 oflags |= MMO_SEC_LOAD;
2352 if (flags & SEC_RELOC)
2353 oflags |= MMO_SEC_RELOC;
2354 if (flags & SEC_READONLY)
2355 oflags |= MMO_SEC_READONLY;
2356 if (flags & SEC_CODE)
2357 oflags |= MMO_SEC_CODE;
2358 if (flags & SEC_DATA)
2359 oflags |= MMO_SEC_DATA;
2360 if (flags & SEC_NEVER_LOAD)
2361 oflags |= MMO_SEC_NEVER_LOAD;
2362 if (flags & SEC_IS_COMMON)
2363 oflags |= MMO_SEC_IS_COMMON;
2364 if (flags & SEC_DEBUGGING)
2365 oflags |= MMO_SEC_DEBUGGING;
2371 bfd_sec_flags_from_mmo_flags (flags)
2374 flagword oflags = 0;
2376 if (flags & MMO_SEC_ALLOC)
2377 oflags |= SEC_ALLOC;
2378 if (flags & MMO_SEC_LOAD)
2380 if (flags & MMO_SEC_RELOC)
2381 oflags |= SEC_RELOC;
2382 if (flags & MMO_SEC_READONLY)
2383 oflags |= SEC_READONLY;
2384 if (flags & MMO_SEC_CODE)
2386 if (flags & MMO_SEC_DATA)
2388 if (flags & MMO_SEC_NEVER_LOAD)
2389 oflags |= SEC_NEVER_LOAD;
2390 if (flags & MMO_SEC_IS_COMMON)
2391 oflags |= SEC_IS_COMMON;
2392 if (flags & MMO_SEC_DEBUGGING)
2393 oflags |= SEC_DEBUGGING;
2398 /* Write a section. */
2401 mmo_internal_write_section (abfd, sec)
2405 /* We do it differently depending on what section this is:
2407 ".text": Output, prepended by information about the first source file
2408 (not yet implemented.)
2412 (".MMIX.reg_contents": Not handled here.)
2414 Anything else: Output inside a lop_spec 80, in the format described
2417 if (strcmp (sec->name, MMO_TEXT_SECTION_NAME) == 0)
2418 /* FIXME: Output source file name and line number. */
2420 mmo_write_loc_chunk_list (abfd,
2421 ((struct mmo_section_data_struct *)
2422 (sec->used_by_bfd))->head);
2423 else if (strcmp (sec->name, MMO_DATA_SECTION_NAME) == 0)
2425 mmo_write_loc_chunk_list (abfd,
2426 ((struct mmo_section_data_struct *)
2427 (sec->used_by_bfd))->head);
2428 else if (strcmp (sec->name, MMIX_REG_CONTENTS_SECTION_NAME) == 0)
2429 /* Not handled here. */
2431 /* This would normally be an abort call since this can't happen, but
2432 we don't do that. */
2433 bfd_set_error (bfd_error_bad_value);
2436 else if (strncmp (sec->name, MMIX_OTHER_SPEC_SECTION_PREFIX,
2437 strlen (MMIX_OTHER_SPEC_SECTION_PREFIX)) == 0)
2439 int n = atoi (sec->name + strlen (MMIX_OTHER_SPEC_SECTION_PREFIX));
2440 mmo_write_tetra_raw (abfd, (LOP << 24) | (LOP_SPEC << 16) | n);
2441 return (! abfd->tdata.mmo_data->have_error
2442 && mmo_write_chunk_list (abfd,
2443 ((struct mmo_section_data_struct *)
2444 (sec->used_by_bfd))->head));
2446 /* Ignore sections that are just allocated or empty; we write out
2448 else if ((bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS) != 0
2449 && sec->_raw_size != 0)
2451 /* Keep the document-comment formatted the way it is. */
2454 mmo section mapping, , Symbol-table, mmo
2458 The implementation in BFD uses special data type 80 (decimal) to
2459 encapsulate and describe named sections, containing e.g.@: debug
2460 information. If needed, any datum in the encapsulation will be
2461 quoted using lop_quote. First comes a 32-bit word holding the
2462 number of 32-bit words containing the zero-terminated zero-padded
2463 segment name. After the name there's a 32-bit word holding flags
2464 describing the section type. Then comes a 64-bit big-endian word
2465 with the section length (in bytes), then another with the section
2466 start address. Depending on the type of section, the contents
2467 might follow, zero-padded to 32-bit boundary. For a loadable
2468 section (such as data or code), the contents might follow at some
2469 later point, not necessarily immediately, as a lop_loc with the
2470 same start address as in the section description, followed by the
2471 contents. This in effect forms a descriptor that must be emitted
2472 before the actual contents. Sections described this way must not
2475 For areas that don't have such descriptors, synthetic sections are
2476 formed by BFD. Consecutive contents in the two memory areas
2477 @samp{0x0000@dots{}00} to @samp{0x01ff@dots{}ff} and
2478 @samp{0x2000@dots{}00} to @samp{0x20ff@dots{}ff} are entered in
2479 sections named <<.text>> and <<.data>> respectively. If an area
2480 is not otherwise described, but would together with a neighboring
2481 lower area be less than @samp{0x40000000} bytes long, it is joined
2482 with the lower area and the gap is zero-filled. For other cases,
2483 a new section is formed, named <<.MMIX.sec.@var{n}>>. Here,
2484 @var{n} is a number, a running count through the mmo file,
2488 A loadable section specified as:
2490 | .section secname,"ax"
2491 | TETRA 1,2,3,4,-1,-2009
2494 and linked to address @samp{0x4}, is represented by the sequence:
2496 | 0x98080050 - lop_spec 80
2497 | 0x00000002 - two 32-bit words for the section name
2498 | 0x7365636e - "secn"
2499 | 0x616d6500 - "ame\0"
2500 | 0x00000033 - flags CODE, READONLY, LOAD, ALLOC
2501 | 0x00000000 - high 32 bits of section length
2502 | 0x0000001c - section length is 28 bytes; 6 * 4 + 1 + alignment to 32 bits
2503 | 0x00000000 - high 32 bits of section address
2504 | 0x00000004 - section address is 4
2505 | 0x98010002 - 64 bits with address of following data
2506 | 0x00000000 - high 32 bits of address
2507 | 0x00000004 - low 32 bits: data starts at address 4
2513 | 0xfffff827 - -2009
2514 | 0x50000000 - 80 as a byte, padded with zeros.
2516 Note that the lop_spec wrapping does not include the section
2517 contents. Compare this to a non-loaded section specified as:
2520 | TETRA 200001,100002
2523 This, when linked to address @samp{0x200000000000001c}, is
2526 | 0x98080050 - lop_spec 80
2527 | 0x00000002 - two 32-bit words for the section name
2528 | 0x7365636e - "thir"
2529 | 0x616d6500 - "dsec"
2530 | 0x00000010 - flag READONLY
2531 | 0x00000000 - high 32 bits of section length
2532 | 0x0000000c - section length is 12 bytes; 2 * 4 + 2 + alignment to 32 bits
2533 | 0x20000000 - high 32 bits of address
2534 | 0x0000001c - low 32 bits of address 0x200000000000001c
2535 | 0x00030d41 - 200001
2536 | 0x000186a2 - 100002
2537 | 0x26280000 - 38, 40 as bytes, padded with zeros
2539 For the latter example, the section contents must not be
2540 loaded in memory, and is therefore specified as part of the
2541 special data. The address is usually unimportant but might
2542 provide information for e.g.@: the DWARF 2 debugging format. */
2544 mmo_write_tetra_raw (abfd, LOP_SPEC_SECTION);
2545 mmo_write_tetra (abfd, (strlen (sec->name) + 3) / 4);
2546 mmo_write_chunk (abfd, sec->name, strlen (sec->name));
2547 mmo_flush_chunk (abfd);
2548 /* FIXME: We can get debug sections (.debug_line & Co.) with a
2549 section flag still having SEC_RELOC set. Investigate. This
2550 might be true for all alien sections; perhaps mmo.em should clear
2551 that flag. Might be related to weak references. */
2552 mmo_write_tetra (abfd,
2553 mmo_sec_flags_from_bfd_flags
2554 (bfd_get_section_flags (abfd, sec)));
2555 mmo_write_octa (abfd, sec->_raw_size);
2556 mmo_write_octa (abfd, bfd_get_section_vma (abfd, sec));
2558 /* Writing a LOP_LOC ends the LOP_SPEC data, and makes data actually
2560 if (bfd_get_section_flags (abfd, sec) & SEC_LOAD)
2562 ! abfd->tdata.mmo_data->have_error
2563 && mmo_write_loc_chunk_list (abfd,
2564 ((struct mmo_section_data_struct *)
2565 (sec->used_by_bfd))->head);
2567 ! abfd->tdata.mmo_data->have_error
2568 && mmo_write_chunk_list (abfd,
2569 ((struct mmo_section_data_struct *)
2570 (sec->used_by_bfd))->head);
2575 /* We save up all data before output. */
2578 mmo_set_section_contents (abfd, sec, location, offset, bytes_to_do)
2579 bfd *abfd ATTRIBUTE_UNUSED;
2583 bfd_size_type bytes_to_do;
2585 /* Iterate over diminishing chunk sizes, copying contents. */
2588 /* A minor song-and-dance to make sure we're not bitten by the
2589 distant possibility of the cast from bfd_vma to int making the
2590 chunk zero-sized. */
2592 = (int) bytes_to_do != 0 ? bytes_to_do : MMO_SEC_CONTENTS_CHUNK_SIZE;
2596 loc = mmo_get_loc (sec, sec->vma + offset, chunk_size);
2597 while (loc == NULL && (chunk_size /= 2) != 0);
2599 if (chunk_size == 0)
2602 memcpy (loc, location, chunk_size);
2604 location += chunk_size;
2605 bytes_to_do -= chunk_size;
2606 offset += chunk_size;
2611 /* Add a symbol to a trie-tree. */
2614 mmo_internal_add_3_sym (abfd, rootp, symp)
2616 struct mmo_symbol_trie *rootp;
2617 const struct mmo_symbol *symp;
2619 const char *name = symp->name;
2620 struct mmo_symbol_trie *trie = rootp;
2621 struct mmo_symbol_trie **triep = NULL;
2623 while (*name && trie != NULL)
2625 if (*name < trie->symchar)
2627 triep = &trie->left;
2630 else if (*name > trie->symchar)
2632 triep = &trie->right;
2635 else if (*name == trie->symchar)
2637 triep = &trie->middle;
2640 /* Make sure "trie" points to where we should fill in the
2641 current symbol whenever we've iterated through "name". We
2642 would lose the right position if we encounter "foobar" then
2645 trie = trie->middle;
2651 /* Create middle branches for the rest of the characters. */
2652 trie = bfd_zalloc (abfd, sizeof (struct mmo_symbol_trie));
2654 trie->symchar = *name++;
2655 triep = &trie->middle;
2658 /* We discover a duplicate symbol rather late in the process, but still;
2659 we discover it and bail out. */
2660 if (trie->sym.name != NULL)
2662 (*_bfd_error_handler)
2663 (_("%s: invalid symbol table: duplicate symbol `%s'\n"),
2664 bfd_get_filename (abfd), trie->sym.name);
2665 bfd_set_error (bfd_error_bad_value);
2669 memcpy (&trie->sym, symp, sizeof *symp);
2673 /* Find out the length of the serialized version of a trie in bytes. */
2676 mmo_internal_3_length (abfd, trie)
2678 struct mmo_symbol_trie *trie;
2680 /* First, one for the control byte. */
2681 unsigned int length = 1;
2686 /* Add in the recursion to the left. */
2687 length += mmo_internal_3_length (abfd, trie->left);
2689 /* Add in the middle trie and the character. */
2690 length += 1 + mmo_internal_3_length (abfd, trie->middle);
2692 /* Add in the recursion to the right. */
2693 length += mmo_internal_3_length (abfd, trie->right);
2695 /* Add in bytes for the symbol (if this is an endnode). */
2696 if (trie->sym.name != NULL)
2698 unsigned int serno = trie->sym.serno;
2700 /* First what it takes to encode the value. */
2701 if (trie->sym.sym_type == mmo_reg_sym)
2703 else if (trie->sym.sym_type == mmo_undef_sym)
2707 bfd_vma value = trie->sym.value;
2709 /* Coded in one to eight following bytes. */
2710 if (trie->sym.sym_type == mmo_data_sym)
2711 value -= (bfd_vma) 0x20 << 56;
2721 /* Find out what it takes to encode the serial number. */
2733 /* Helper function for outputting the serial number of a symbol, output as
2734 a variant of leb128 (see dwarf2 documentation) which could be called
2735 beb128. Using a helper function and recursion simplifies debugging. */
2738 mmo_beb128_out (abfd, serno, marker)
2744 mmo_beb128_out (abfd, serno >> 7, 0);
2745 mmo_write_byte (abfd, marker | (serno & 0x7f));
2748 /* Serialize a trie. */
2751 mmo_internal_3_dump (abfd, trie)
2753 struct mmo_symbol_trie *trie;
2755 bfd_byte control = 0;
2761 control |= MMO3_LEFT;
2764 control |= MMO3_MIDDLE;
2767 control |= MMO3_RIGHT;
2769 if (trie->sym.name != NULL)
2771 /* Encode the symbol type and length of value bytes. */
2772 if (trie->sym.sym_type == mmo_reg_sym)
2773 control |= MMO3_REGQUAL_BITS;
2774 else if (trie->sym.sym_type == mmo_undef_sym)
2775 control |= MMO3_UNDEF;
2778 bfd_vma value = trie->sym.value;
2780 /* Coded in 1..8 following bytes. */
2781 if (trie->sym.sym_type == mmo_data_sym)
2783 control |= MMO3_DATA;
2784 value -= (bfd_vma) 0x20 << 56;
2796 /* The control byte is output before recursing. */
2797 mmo_write_byte (abfd, control);
2799 mmo_internal_3_dump (abfd, trie->left);
2801 if (control & MMO3_SYMBITS)
2803 mmo_write_byte (abfd, trie->symchar);
2805 if (trie->sym.name != NULL)
2807 if (trie->sym.sym_type == mmo_reg_sym)
2808 mmo_write_byte (abfd, trie->sym.value);
2809 else if (trie->sym.sym_type == mmo_undef_sym)
2811 mmo_write_byte (abfd, 0);
2812 mmo_write_byte (abfd, 0);
2816 bfd_vma value = trie->sym.value;
2818 bfd_byte byte_n = control & 15;
2820 /* Coded in 1..8 following bytes. Note that the value is
2821 shifted out big-endian. */
2822 if (trie->sym.sym_type == mmo_data_sym)
2824 value -= (bfd_vma) 0x20 << 56;
2830 mmo_write_byte (abfd, (value >> ((byte_n - 1) * 8)) & 0xff);
2833 while (byte_n != 0);
2836 mmo_beb128_out (abfd, trie->sym.serno, 128);
2838 mmo_internal_3_dump (abfd, trie->middle);
2840 mmo_internal_3_dump (abfd, trie->right);
2843 /* Write symbols in mmo format. Also write the lop_end terminator. */
2846 mmo_write_symbols_and_terminator (abfd)
2849 int count = bfd_get_symcount (abfd);
2850 asymbol *maintable[2];
2852 asymbol **orig_table = bfd_get_outsymbols (abfd);
2854 struct mmo_symbol_trie root;
2859 /* Create a symbol for "Main". */
2860 asymbol *fakemain = bfd_make_empty_symbol (abfd);
2862 fakemain->flags = BSF_GLOBAL;
2863 fakemain->value = bfd_get_start_address (abfd);
2864 fakemain->name = MMIX_START_SYMBOL_NAME;
2865 fakemain->section = bfd_abs_section_ptr;
2866 maintable[0] = fakemain;
2867 maintable[1] = NULL;
2869 memset (&root, 0, sizeof (root));
2871 /* Make all symbols take a left turn. */
2872 root.symchar = 0xff;
2874 /* There must always be a ":Main", so we'll add one if there are no
2875 symbols. Make sure we have room for it. */
2876 table = bfd_alloc (abfd, (count + 1) * sizeof (asymbol *));
2880 memcpy (table, orig_table, count * sizeof (asymbol *));
2882 /* Move :Main (if there is one) to the first position. This is
2883 necessary to get the same layout of the trie-tree when linking as
2884 when objcopying the result as in the objcopy.exp test "simple objcopy
2885 of executable". It also automatically takes care of assigning serial
2886 number 1 to :Main (as is mandatory). */
2887 for (i = 0; i < count; i++)
2888 if (table[i] != NULL
2889 && strcmp (table[i]->name, MMIX_START_SYMBOL_NAME) == 0
2890 && (table[i]->flags & (BSF_DEBUGGING|BSF_GLOBAL)) == BSF_GLOBAL)
2892 asymbol *mainsym = table[i];
2893 memcpy (table + 1, orig_table, i * sizeof (asymbol *));
2896 /* Check that the value assigned to :Main is the same as the entry
2897 address. The default linker script asserts this. This is as
2898 good a place as any to check this consistency. */
2900 + mainsym->section->output_section->vma
2901 + mainsym->section->output_offset)
2902 != bfd_get_start_address (abfd))
2904 /* Arbitrary buffer to hold the printable representation of a
2907 char vmas_start[40];
2908 bfd_vma vma_start = bfd_get_start_address (abfd);
2910 sprintf_vma (vmas_main, mainsym->value);
2911 sprintf_vma (vmas_start, vma_start);
2913 (*_bfd_error_handler)
2914 (_("%s: Bad symbol definition: `Main' set to %s rather\
2915 than the start address %s\n"),
2916 bfd_get_filename (abfd), vmas_main, vmas_start);
2917 bfd_set_error (bfd_error_bad_value);
2922 if (i == count && count != 0)
2924 /* When there are symbols, there must be a :Main. There was no
2925 :Main, so we need to add it manually. */
2926 memcpy (table + 1, orig_table, count * sizeof (asymbol *));
2927 table[0] = fakemain;
2931 for (i = 0, serno = 1; i < count && table[i] != NULL; i++)
2933 asymbol *s = table[i];
2935 /* It's not enough to consult bfd_is_local_label, since it does not
2936 mean "local" in the sense of linkable-and-observable-after-link.
2937 Let's just check the BSF_GLOBAL flag.
2939 Also, don't export symbols with characters not in the allowed set. */
2940 if ((s->flags & (BSF_DEBUGGING|BSF_GLOBAL)) == BSF_GLOBAL
2942 valid_mmo_symbol_character_set) == strlen (s->name))
2944 struct mmo_symbol sym;
2945 memset (&sym, 0, sizeof (sym));
2950 + s->section->output_section->vma
2951 + s->section->output_offset;
2953 if (bfd_is_und_section (s->section))
2954 sym.sym_type = mmo_undef_sym;
2955 else if (strcmp (s->section->name, MMO_DATA_SECTION_NAME) == 0
2956 /* The encoding of data symbols require that the "rest"
2957 of the value fits in 6 bytes, so the upper two bytes
2958 must be 0x2000. All other symbols get to be the
2960 && (sym.value >> 48) == 0x2000)
2961 sym.sym_type = mmo_data_sym;
2962 else if (strcmp (s->section->name, MMIX_REG_SECTION_NAME) == 0)
2963 sym.sym_type = mmo_reg_sym;
2964 else if (strcmp (s->section->name,
2965 MMIX_REG_CONTENTS_SECTION_NAME) == 0)
2967 sym.sym_type = mmo_reg_sym;
2971 sym.sym_type = mmo_abs_sym;
2973 /* FIXME: We assume the order of the received symbols is an
2974 ordered mapping of the serial numbers. This is not
2975 necessarily true if we e.g. objcopy a mmo file to another and
2976 there are gaps in the numbering. Not sure if this can
2977 happen. Not sure what to do. */
2978 sym.serno = serno++;
2980 if (! mmo_internal_add_3_sym (abfd, &root, &sym))
2985 /* Change the root node to be a ":"-prefix. */
2987 root.middle = root.left;
2991 /* We have to find out if we can fit the whole symbol table in the mmo
2992 symtab. It would be bad to assume we can always fit it in 262144
2993 bytes. If we can't, just leave the Main symbol. */
2994 trie_len = (mmo_internal_3_length (abfd, &root) + 3)/4;
2996 if (trie_len > 0xffff)
2998 /* Test this code by using a lower limit in the test above and check
2999 that the single "Main" symbol is emitted and handled properly.
3000 There's no specific test-case. */
3001 struct mmo_symbol sym;
3003 (*_bfd_error_handler)
3004 (_("%s: warning: symbol table too large for mmo, larger than 65535\
3005 32-bit words: %d. Only `Main' will be emitted.\n"),
3006 bfd_get_filename (abfd), trie_len);
3008 memset (&sym, 0, sizeof (sym));
3009 sym.sym_type = mmo_abs_sym;
3010 sym.name = MMIX_START_SYMBOL_NAME;
3012 sym.value = bfd_get_start_address (abfd);
3014 /* Then patch up a symbol table to be just the ":Main" symbol. */
3015 memset (&root, 0, sizeof (root));
3016 root.left = root.middle;
3017 root.symchar = 0xff;
3021 if (! mmo_internal_add_3_sym (abfd, &root, &sym))
3025 root.middle = root.left;
3029 trie_len = (mmo_internal_3_length (abfd, &root) + 3)/4;
3032 /* Reset the written-bytes counter. */
3033 abfd->tdata.mmo_data->byte_no = 0;
3035 /* Put out the lop_stab mark. */
3036 bfd_put_32 (abfd, (LOP << 24) | (LOP_STAB << 16), buf);
3037 if (bfd_bwrite (buf, 4, abfd) != 4)
3040 /* Dump out symbols. */
3041 mmo_internal_3_dump (abfd, &root);
3043 if (trie_len != (abfd->tdata.mmo_data->byte_no + 3)/4)
3045 /* I haven't seen this trig. It seems no use claiming this case
3046 isn't debugged and abort if we get here. Instead emit a
3047 diagnostic and fail "normally". */
3048 (*_bfd_error_handler)
3049 (_("%s: internal error, symbol table changed size from %d to %d\
3051 bfd_get_filename (abfd), trie_len,
3052 (abfd->tdata.mmo_data->byte_no + 3)/4);
3053 bfd_set_error (bfd_error_bad_value);
3057 /* Dump out remaining bytes in the buffer and handle I/O errors by
3058 propagating errors. */
3059 if ((abfd->tdata.mmo_data->byte_no % 4) != 0
3060 || abfd->tdata.mmo_data->have_error)
3062 memset (abfd->tdata.mmo_data->buf + (abfd->tdata.mmo_data->byte_no % 4),
3063 0, 4 - (abfd->tdata.mmo_data->byte_no % 4));
3065 if (abfd->tdata.mmo_data->have_error
3066 || bfd_bwrite (abfd->tdata.mmo_data->buf, 4, abfd) != 4)
3070 bfd_put_32 (abfd, (LOP << 24) | (LOP_END << 16) | trie_len, buf);
3071 return bfd_bwrite (buf, 4, abfd) == 4;
3074 /* Write section unless it is the register contents section. For that, we
3075 instead store the section in the supplied pointer. This function is
3076 used through bfd_map_over_sections. */
3079 mmo_write_section_unless_reg_contents (abfd, sec, p)
3084 struct mmo_write_sec_info *infop = (struct mmo_write_sec_info *) p;
3086 if (! infop->retval)
3089 if (strcmp (sec->name, MMIX_REG_CONTENTS_SECTION_NAME) == 0)
3091 infop->reg_section = sec;
3095 /* Exclude the convenience register section. */
3096 if (strcmp (sec->name, MMIX_REG_SECTION_NAME) == 0)
3098 if (bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS)
3100 /* Make sure it hasn't got contents. It seems impossible to
3101 make it carry contents, so we don't have a test-case for
3103 (*_bfd_error_handler)
3104 (_("%s: internal error, internal register section %s had\
3106 bfd_get_filename (abfd), sec->name);
3107 bfd_set_error (bfd_error_bad_value);
3108 infop->retval = false;
3115 infop->retval = mmo_internal_write_section (abfd, sec);
3118 /* Do the actual output of a file. Assumes mmo_set_section_contents is
3122 mmo_write_object_contents (abfd)
3125 struct mmo_write_sec_info wsecinfo;
3127 /* First, there are a few words of preamble. */
3128 if (! mmo_internal_write_header (abfd))
3131 wsecinfo.reg_section = NULL;
3132 wsecinfo.retval = true;
3134 bfd_map_over_sections (abfd, mmo_write_section_unless_reg_contents,
3137 if (! wsecinfo.retval)
3140 if (wsecinfo.reg_section != NULL)
3142 asection *sec = wsecinfo.reg_section;
3143 unsigned int z = (unsigned int) (sec->vma / 8);
3145 /* Registers 0..31 must not be global. Do sanity check on the "vma"
3146 of the register contents section and check that it corresponds to
3147 the length of the section. */
3148 if (z < 32 || z >= 255 || (sec->vma & 7) != 0
3149 || sec->vma != 256 * 8 - sec->_raw_size - 8)
3151 bfd_set_error (bfd_error_bad_value);
3153 if (sec->_raw_size == 0)
3154 /* There must always be at least one such register. */
3155 (*_bfd_error_handler)
3156 (_("%s: no initialized registers; section length 0\n"),
3157 bfd_get_filename (abfd));
3158 else if (sec->vma > (256 - 32) * 8)
3159 /* Provide better error message for the case of too many
3160 global registers. */
3161 (*_bfd_error_handler)
3162 (_("%s: too many initialized registers; section length %ld\n"),
3163 bfd_get_filename (abfd),
3164 (long) sec->_raw_size);
3166 (*_bfd_error_handler)
3167 (_("%s: invalid start address for initialized registers of\
3168 length %ld: 0x%lx%08lx\n"),
3169 bfd_get_filename (abfd),
3170 (long) sec->_raw_size,
3171 (unsigned long) (sec->vma >> 32), (unsigned long) (sec->vma));
3176 if (! mmo_internal_write_post (abfd, z, sec))
3180 if (! mmo_internal_write_post (abfd, 255, NULL))
3183 return mmo_write_symbols_and_terminator (abfd);
3186 /* Return the size of a NULL pointer, so we support linking in an mmo
3190 mmo_get_reloc_upper_bound (abfd, sec)
3191 bfd *abfd ATTRIBUTE_UNUSED;
3192 asection *sec ATTRIBUTE_UNUSED;
3194 return sizeof (PTR);
3197 /* Similarly canonicalize relocs to empty, filling in the terminating NULL
3201 mmo_canonicalize_reloc (abfd, section, relptr, symbols)
3202 bfd *abfd ATTRIBUTE_UNUSED;
3203 sec_ptr section ATTRIBUTE_UNUSED;
3205 asymbol **symbols ATTRIBUTE_UNUSED;
3211 /* If there's anything in particular in a mmo bfd that we want to free,
3212 make this a real function. Only do this if you see major memory
3213 thrashing; zealous free:ing will cause unwanted behavior, especially if
3214 you "free" memory allocated with "bfd_alloc", or even "bfd_release" a
3215 block allocated with "bfd_alloc"; they're really allocated from an
3216 obstack, and we don't know what was allocated there since this
3217 particular allocation. */
3219 #define mmo_close_and_cleanup _bfd_generic_close_and_cleanup
3220 #define mmo_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
3222 /* Perhaps we need to adjust this one; mmo labels (originally) without a
3223 leading ':' might more appropriately be called local. */
3224 #define mmo_bfd_is_local_label_name bfd_generic_is_local_label_name
3226 /* Is this one really used or defined by anyone? */
3227 #define mmo_get_lineno _bfd_nosymbols_get_lineno
3229 /* FIXME: We can do better on this one, if we have a dwarf2 .debug_line
3230 section or if MMO line numbers are implemented. */
3231 #define mmo_find_nearest_line _bfd_nosymbols_find_nearest_line
3232 #define mmo_make_empty_symbol _bfd_generic_make_empty_symbol
3233 #define mmo_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
3234 #define mmo_read_minisymbols _bfd_generic_read_minisymbols
3235 #define mmo_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
3237 #define mmo_get_section_contents_in_window \
3238 _bfd_generic_get_section_contents_in_window
3239 #define mmo_bfd_get_relocated_section_contents \
3240 bfd_generic_get_relocated_section_contents
3241 #define mmo_bfd_gc_sections bfd_generic_gc_sections
3242 #define mmo_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
3243 #define mmo_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
3244 #define mmo_bfd_link_add_symbols _bfd_generic_link_add_symbols
3245 #define mmo_bfd_link_just_syms _bfd_generic_link_just_syms
3246 #define mmo_bfd_final_link _bfd_generic_final_link
3247 #define mmo_bfd_link_split_section _bfd_generic_link_split_section
3249 /* Strictly speaking, only MMIX uses this restricted format, but let's not
3250 stop anybody from shooting themselves in the foot. */
3251 #define mmo_set_arch_mach bfd_default_set_arch_mach
3252 #define mmo_bfd_relax_section bfd_generic_relax_section
3253 #define mmo_bfd_merge_sections bfd_generic_merge_sections
3254 #define mmo_bfd_discard_group bfd_generic_discard_group
3256 /* objcopy will be upset if we return -1 from bfd_get_reloc_upper_bound by
3257 using BFD_JUMP_TABLE_RELOCS (_bfd_norelocs) rather than 0. FIXME: Most
3258 likely a bug in the _bfd_norelocs definition.
3260 On the other hand, we smuggle in an mmo object (because setting up ELF
3261 is too cumbersome) when linking (from other formats, presumably ELF) to
3262 represent the g255 entry. We need to link that object, so need to say
3263 it has no relocs. Upper bound for the size of the relocation table is
3264 the size of a NULL pointer, and we support "canonicalization" for that
3266 #define mmo_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
3268 /* We want to copy time of creation, otherwise we'd use
3269 BFD_JUMP_TABLE_COPY (_bfd_generic). */
3270 #define mmo_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
3271 #define mmo_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
3272 #define mmo_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
3273 #define mmo_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
3274 #define mmo_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
3276 const bfd_target bfd_mmo_vec =
3279 bfd_target_mmo_flavour,
3280 BFD_ENDIAN_BIG, /* target byte order */
3281 BFD_ENDIAN_BIG, /* target headers byte order */
3283 /* FIXME: Might need adjustments. */
3284 (HAS_RELOC | EXEC_P | /* object flags */
3285 HAS_LINENO | HAS_DEBUG |
3286 HAS_SYMS | HAS_LOCALS | WP_TEXT),
3288 /* FIXME: Might need adjustments. */
3289 (SEC_CODE | SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
3290 | SEC_READONLY | SEC_EXCLUDE | SEC_DEBUGGING | SEC_IN_MEMORY),
3292 0, /* leading underscore */
3293 ' ', /* ar_pad_char */
3294 16, /* ar_max_namelen */
3295 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
3296 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
3297 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
3298 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
3299 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
3300 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
3304 mmo_object_p, /* bfd_check_format */
3314 { /* bfd_write_contents */
3316 mmo_write_object_contents,
3321 BFD_JUMP_TABLE_GENERIC (mmo),
3322 BFD_JUMP_TABLE_COPY (mmo),
3323 BFD_JUMP_TABLE_CORE (_bfd_nocore),
3324 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
3325 BFD_JUMP_TABLE_SYMBOLS (mmo),
3326 /* We have to provide a valid method for getting relocs, returning zero,
3327 so we can't say BFD_JUMP_TABLE_RELOCS (_bfd_norelocs). */
3328 BFD_JUMP_TABLE_RELOCS (mmo),
3329 BFD_JUMP_TABLE_WRITE (mmo),
3330 BFD_JUMP_TABLE_LINK (mmo),
3331 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),