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