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