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