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