1 /* BFD back-end for mmo objects (MMIX-specific object-format).
2 Copyright (C) 2001-2021 Free Software Foundation, Inc.
3 Written by Hans-Peter Nilsson (hp@bitrange.com).
4 Infrastructure and other bits originally copied from srec.c and
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
29 The mmo object format is used exclusively together with Professor
30 Donald E.@: Knuth's educational 64-bit processor MMIX. The simulator
31 @command{mmix} which is available at
32 @url{http://mmix.cs.hm.edu/src/index.html}
33 understands this format. That package also includes a combined
34 assembler and linker called @command{mmixal}. The mmo format has
35 no advantages feature-wise compared to e.g. ELF. It is a simple
36 non-relocatable object format with no support for archives or
37 debugging information, except for symbol value information and
38 line numbers (which is not yet implemented in BFD). See
39 @url{http://mmix.cs.hm.edu/} for more
40 information about MMIX. The ELF format is used for intermediate
41 object files in the BFD implementation.
43 @c We want to xref the symbol table node. A feature in "chew"
44 @c requires that "commands" do not contain spaces in the
45 @c arguments. Hence the hyphen in "Symbol-table".
49 @* mmo section mapping::
53 File layout, Symbol-table, mmo, mmo
57 The mmo file contents is not partitioned into named sections as
58 with e.g.@: ELF. Memory areas is formed by specifying the
59 location of the data that follows. Only the memory area
60 @samp{0x0000@dots{}00} to @samp{0x01ff@dots{}ff} is executable, so
61 it is used for code (and constants) and the area
62 @samp{0x2000@dots{}00} to @samp{0x20ff@dots{}ff} is used for
63 writable data. @xref{mmo section mapping}.
65 There is provision for specifying ``special data'' of 65536
66 different types. We use type 80 (decimal), arbitrarily chosen the
67 same as the ELF <<e_machine>> number for MMIX, filling it with
68 section information normally found in ELF objects. @xref{mmo
71 Contents is entered as 32-bit words, xor:ed over previous
72 contents, always zero-initialized. A word that starts with the
73 byte @samp{0x98} forms a command called a @samp{lopcode}, where
74 the next byte distinguished between the thirteen lopcodes. The
75 two remaining bytes, called the @samp{Y} and @samp{Z} fields, or
76 the @samp{YZ} field (a 16-bit big-endian number), are used for
77 various purposes different for each lopcode. As documented in
78 @url{http://mmix.cs.hm.edu/doc/mmixal.pdf},
83 0x98000001. The next word is contents, regardless of whether it
84 starts with 0x98 or not.
87 0x9801YYZZ, where @samp{Z} is 1 or 2. This is a location
88 directive, setting the location for the next data to the next
89 32-bit word (for @math{Z = 1}) or 64-bit word (for @math{Z = 2}),
90 plus @math{Y * 2^56}. Normally @samp{Y} is 0 for the text segment
91 and 2 for the data segment. Beware that the low bits of non-
92 tetrabyte-aligned values are silently discarded when being
93 automatically incremented and when storing contents (in contrast
94 to e.g. its use as current location when followed by lop_fixo
95 et al before the next possibly-quoted tetrabyte contents).
98 0x9802YYZZ. Increase the current location by @samp{YZ} bytes.
101 0x9803YYZZ, where @samp{Z} is 1 or 2. Store the current location
102 as 64 bits into the location pointed to by the next 32-bit
103 (@math{Z = 1}) or 64-bit (@math{Z = 2}) word, plus @math{Y *
107 0x9804YYZZ. @samp{YZ} is stored into the current location plus
111 0x980500ZZ. @samp{Z} is 16 or 24. A value @samp{L} derived from
112 the following 32-bit word are used in a manner similar to
113 @samp{YZ} in lop_fixr: it is xor:ed into the current location
114 minus @math{4 * L}. The first byte of the word is 0 or 1. If it
115 is 1, then @math{L = (@var{lowest 24 bits of word}) - 2^Z}, if 0,
116 then @math{L = (@var{lowest 24 bits of word})}.
119 0x9806YYZZ. @samp{Y} is the file number, @samp{Z} is count of
120 32-bit words. Set the file number to @samp{Y} and the line
121 counter to 0. The next @math{Z * 4} bytes contain the file name,
122 padded with zeros if the count is not a multiple of four. The
123 same @samp{Y} may occur multiple times, but @samp{Z} must be 0 for
124 all but the first occurrence.
127 0x9807YYZZ. @samp{YZ} is the line number. Together with
128 lop_file, it forms the source location for the next 32-bit word.
129 Note that for each non-lopcode 32-bit word, line numbers are
130 assumed incremented by one.
133 0x9808YYZZ. @samp{YZ} is the type number. Data until the next
134 lopcode other than lop_quote forms special data of type @samp{YZ}.
135 @xref{mmo section mapping}.
137 Other types than 80, (or type 80 with a content that does not
138 parse) is stored in sections named <<.MMIX.spec_data.@var{n}>>
139 where @var{n} is the @samp{YZ}-type. The flags for such a
140 sections say not to allocate or load the data. The vma is 0.
141 Contents of multiple occurrences of special data @var{n} is
142 concatenated to the data of the previous lop_spec @var{n}s. The
143 location in data or code at which the lop_spec occurred is lost.
146 0x980901ZZ. The first lopcode in a file. The @samp{Z} field forms the
147 length of header information in 32-bit words, where the first word
148 tells the time in seconds since @samp{00:00:00 GMT Jan 1 1970}.
151 0x980a00ZZ. @math{Z > 32}. This lopcode follows after all
152 content-generating lopcodes in a program. The @samp{Z} field
153 denotes the value of @samp{rG} at the beginning of the program.
154 The following @math{256 - Z} big-endian 64-bit words are loaded
155 into global registers @samp{$G} @dots{} @samp{$255}.
158 0x980b0000. The next-to-last lopcode in a program. Must follow
159 immediately after the lop_post lopcode and its data. After this
160 lopcode follows all symbols in a compressed format
161 (@pxref{Symbol-table}).
164 0x980cYYZZ. The last lopcode in a program. It must follow the
165 lop_stab lopcode and its data. The @samp{YZ} field contains the
166 number of 32-bit words of symbol table information after the
167 preceding lop_stab lopcode.
170 Note that the lopcode "fixups"; <<lop_fixr>>, <<lop_fixrx>> and
171 <<lop_fixo>> are not generated by BFD, but are handled. They are
172 generated by <<mmixal>>.
175 This trivial one-label, one-instruction file:
179 can be represented this way in mmo:
181 | 0x98090101 - lop_pre, one 32-bit word with timestamp.
183 | 0x98010002 - lop_loc, text segment, using a 64-bit address.
184 | Note that mmixal does not emit this for the file above.
185 | 0x00000000 - Address, high 32 bits.
186 | 0x00000000 - Address, low 32 bits.
187 | 0x98060002 - lop_file, 2 32-bit words for file-name.
188 | 0x74657374 - "test"
189 | 0x2e730000 - ".s\0\0"
190 | 0x98070001 - lop_line, line 1.
191 | 0x00010203 - TRAP 1,2,3
192 | 0x980a00ff - lop_post, setting $255 to 0.
195 | 0x980b0000 - lop_stab for ":Main" = 0, serial 1.
196 | 0x203a4040 @xref{Symbol-table}.
201 | 0x980c0005 - lop_end; symbol table contained five 32-bit words. */
206 #include "libiberty.h"
207 #include "elf/mmix.h"
208 #include "opcode/mmix.h"
225 #define LOP_QUOTE_NEXT ((LOP << 24) | (LOP_QUOTE << 16) | 1)
226 #define SPEC_DATA_SECTION 80
227 #define LOP_SPEC_SECTION \
228 ((LOP << 24) | (LOP_SPEC << 16) | SPEC_DATA_SECTION)
230 /* Must be a power of two. If you change this to be >= 64k, you need a
231 new test-case; the ld test b-loc64k.d touches chunk-size problem areas. */
232 #define MMO_SEC_CONTENTS_CHUNK_SIZE (1 << 15)
234 /* An arbitrary number for the maximum length section name size. */
235 #define MAX_SECTION_NAME_SIZE (1024 * 1024)
237 /* A quite arbitrary number for the maximum length section size. */
238 #define MAX_ARTIFICIAL_SECTION_SIZE (1024 * 1024 * 1024)
240 #define MMO3_WCHAR 0x80
241 #define MMO3_LEFT 0x40
242 #define MMO3_MIDDLE 0x20
243 #define MMO3_RIGHT 0x10
244 #define MMO3_TYPEBITS 0xf
245 #define MMO3_REGQUAL_BITS 0xf
248 #define MMO3_SYMBITS 0x2f
250 /* Put these everywhere in new code. */
251 #define FATAL_DEBUG \
252 _bfd_abort (__FILE__, __LINE__, \
253 "Internal: Non-debugged code (test-case missing)")
255 #define BAD_CASE(x) \
256 _bfd_abort (__FILE__, __LINE__, \
259 enum mmo_sym_type
{ mmo_reg_sym
, mmo_undef_sym
, mmo_data_sym
, mmo_abs_sym
};
261 /* When scanning the mmo file, a linked list of mmo_symbol
262 structures is built to represent the symbol table (if there is
267 struct mmo_symbol
*next
;
270 enum mmo_sym_type sym_type
;
274 struct mmo_data_list_struct
276 struct mmo_data_list_struct
*next
;
279 bfd_size_type allocated_size
;
283 typedef struct mmo_data_list_struct mmo_data_list_type
;
285 struct mmo_symbol_trie
287 struct mmo_symbol_trie
*left
;
288 struct mmo_symbol_trie
*right
;
289 struct mmo_symbol_trie
*middle
;
293 /* A zero name means there's nothing here. */
294 struct mmo_symbol sym
;
297 /* The mmo tdata information. */
299 struct mmo_data_struct
301 struct mmo_symbol
*symbols
;
302 struct mmo_symbol
*symtail
;
305 /* File representation of time (NULL) when this file was created. */
308 /* When we're reading bytes recursively, check this occasionally.
309 Also holds write errors. */
312 /* Max symbol length that may appear in the lop_stab table. Note that
313 this table might just hold a subset of symbols for not-really large
314 programs, as it can only be 65536 * 4 bytes large. */
315 int max_symbol_length
;
317 /* Here's the symbol we build in lop_stab. */
318 char *lop_stab_symbol
;
320 /* Index into lop_stab_symbol for the next character when parsing the
321 symbol information. */
324 /* When creating arbitrary sections, we need to count section numbers. */
327 /* When writing or reading byte-wise, we need to count the bytes
328 within a 32-bit word. */
331 /* We also need a buffer to hold the bytes we count reading or writing. */
334 /* Whether we've calculated symbol consistency requirement yet. We do this
335 when-needed, which must be at some time after all section
336 contents is known. */
337 bool symbol_consistency_override_calculated
;
339 /* Whether to consistency-check symbol values, in particular "Main". */
340 bool ignore_symbol_consistency
;
343 typedef struct mmo_data_struct tdata_type
;
345 struct mmo_section_data_struct
347 mmo_data_list_type
*head
;
348 mmo_data_list_type
*tail
;
351 #define mmo_section_data(sec) \
352 ((struct mmo_section_data_struct *) (sec)->used_by_bfd)
354 /* These structures are used in bfd_map_over_sections constructs. */
356 /* Used when writing out sections; all but the register contents section
357 which is stored in reg_section. */
358 struct mmo_write_sec_info
360 asection
*reg_section
;
364 /* Used when trying to find a section corresponding to addr. */
365 struct mmo_find_sec_info
371 static bool mmo_bfd_copy_private_bfd_data (bfd
*, bfd
*);
372 static void mmo_write_section_unless_reg_contents (bfd
*, asection
*, void *);
373 static void mmo_find_sec_w_addr (bfd
*, asection
*, void *);
374 static void mmo_find_sec_w_addr_grow (bfd
*, asection
*, void *);
375 static asection
*mmo_make_section (bfd
*, const char *);
376 static void mmo_get_symbol_info (bfd
*, asymbol
*, symbol_info
*);
377 static void mmo_print_symbol (bfd
*, void *, asymbol
*,
378 bfd_print_symbol_type
);
379 static void mmo_init (void);
380 static bool mmo_mkobject (bfd
*);
381 static bool mmo_scan (bfd
*);
382 static asection
*mmo_decide_section (bfd
*, bfd_vma
);
383 static asection
*mmo_get_generic_spec_data_section (bfd
*, int);
384 static asection
*mmo_get_spec_section (bfd
*, int);
385 static bfd_byte
*mmo_get_loc (asection
*, bfd_vma
, int);
386 static bfd_cleanup
mmo_object_p (bfd
*);
387 static void mmo_map_set_sizes (bfd
*, asection
*, void *);
388 static bool mmo_get_symbols (bfd
*);
389 static bool mmo_create_symbol (bfd
*, const char *, bfd_vma
,
390 enum mmo_sym_type
, unsigned int);
391 static bool mmo_get_section_contents (bfd
*, asection
*, void *,
392 file_ptr
, bfd_size_type
);
393 static long mmo_get_symtab_upper_bound (bfd
*);
394 static long mmo_canonicalize_symtab (bfd
*, asymbol
**);
395 static void mmo_get_symbol_info (bfd
*, asymbol
*, symbol_info
*);
396 static void mmo_print_symbol (bfd
*, void *, asymbol
*,
397 bfd_print_symbol_type
);
398 static bool mmo_set_section_contents (bfd
*, sec_ptr
, const void *,
399 file_ptr
, bfd_size_type
);
400 static int mmo_sizeof_headers (bfd
*, struct bfd_link_info
*);
401 static bool mmo_internal_write_header (bfd
*);
402 static bool mmo_internal_write_post (bfd
*, int, asection
*);
403 static bool mmo_internal_add_3_sym (bfd
*, struct mmo_symbol_trie
*,
404 const struct mmo_symbol
*);
405 static unsigned int mmo_internal_3_length (bfd
*, struct mmo_symbol_trie
*);
406 static void mmo_internal_3_dump (bfd
*, struct mmo_symbol_trie
*);
407 static void mmo_beb128_out (bfd
*, int, int);
408 static bool mmo_internal_write_section (bfd
*, asection
*);
409 static void mmo_write_tetra (bfd
*, unsigned int);
410 static void mmo_write_tetra_raw (bfd
*, unsigned int);
411 static void mmo_write_octa (bfd
*, bfd_vma
);
412 static void mmo_write_octa_raw (bfd
*, bfd_vma
);
413 static bool mmo_write_chunk (bfd
*, const bfd_byte
*, unsigned int);
414 static bool mmo_flush_chunk (bfd
*);
415 static bool mmo_write_loc_chunk (bfd
*, bfd_vma
, const bfd_byte
*,
416 unsigned int, bfd_vma
*);
417 static bool mmo_write_chunk_list (bfd
*, mmo_data_list_type
*);
418 static bool mmo_write_loc_chunk_list (bfd
*, mmo_data_list_type
*);
419 static bool mmo_write_symbols_and_terminator (bfd
*);
420 static flagword
mmo_sec_flags_from_bfd_flags (flagword
);
421 static flagword
bfd_sec_flags_from_mmo_flags (flagword
);
422 static bfd_byte
mmo_get_byte (bfd
*);
423 static void mmo_write_byte (bfd
*, bfd_byte
);
424 static bool mmo_new_section_hook (bfd
*, asection
*);
425 static int mmo_sort_mmo_symbols (const void *, const void *);
426 static bool mmo_write_object_contents (bfd
*);
427 static bool mmo_write_section_description (bfd
*, asection
*);
428 static bool mmo_has_leading_or_trailing_zero_tetra_p (bfd
*, asection
*);
431 valid_mmo_symbol_character_set
[] =
433 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
434 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
435 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
436 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
437 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
438 ':', '_', 126, 127, 128, 129,
439 130, 131, 132, 133, 134, 135, 136, 137, 138, 139,
440 140, 141, 142, 143, 144, 145, 146, 147, 148, 149,
441 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
442 160, 161, 162, 163, 164, 165, 166, 167, 168, 169,
443 170, 171, 172, 173, 174, 175, 176, 177, 178, 179,
444 180, 181, 182, 183, 184, 185, 186, 187, 188, 189,
445 190, 191, 192, 193, 194, 195, 196, 197, 198, 199,
446 200, 201, 202, 203, 204, 205, 206, 207, 208, 209,
447 210, 211, 212, 213, 214, 215, 216, 217, 218, 219,
448 220, 221, 222, 223, 224, 225, 226, 227, 228, 229,
449 230, 231, 232, 233, 234, 235, 236, 237, 238, 239,
450 240, 241, 242, 243, 244, 245, 246, 247, 248, 249,
451 250, 251, 252, 253, 254, 255,
456 /* Get section SECNAME or create one if it doesn't exist. When creating
457 one, new memory for the name is allocated. */
460 mmo_make_section (bfd
*abfd
, const char *secname
)
462 asection
*sec
= bfd_get_section_by_name (abfd
, secname
);
466 char *newsecname
= strdup (secname
);
468 if (newsecname
== NULL
)
471 /* xgettext:c-format */
472 (_("%pB: no core to allocate section name %s"),
474 bfd_set_error (bfd_error_system_call
);
477 sec
= bfd_make_section (abfd
, newsecname
);
483 /* Nothing to do, but keep as a placeholder if we need it.
484 Note that state that might differ between bfd:s must not be initialized
485 here, nor must it be static. Add it to tdata information instead. */
490 static bool inited
= false;
497 /* Check whether an existing file is an mmo file. */
500 mmo_object_p (bfd
*abfd
)
507 if (bfd_stat (abfd
, &statbuf
) < 0
508 || bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
509 || bfd_bread (b
, 4, abfd
) != 4)
512 /* All mmo files are a multiple of four bytes long.
513 Only recognize version one. */
514 if ((statbuf
.st_size
% 4) != 0
515 || b
[0] != LOP
|| b
[1] != LOP_PRE
|| b
[2] != 1)
518 /* Get the last 32-bit word. */
519 if (bfd_seek (abfd
, (file_ptr
) statbuf
.st_size
- 4, SEEK_SET
) != 0
520 || bfd_bread (b
, 4, abfd
) != 4)
523 /* Check if the file ends in a lop_end lopcode. */
524 if (b
[0] != LOP
|| b
[1] != LOP_END
|| ! mmo_mkobject (abfd
))
527 /* Compute an upper bound on the max symbol length. Not really
528 important as all of the symbol information can only be 256k. */
529 abfd
->tdata
.mmo_data
->max_symbol_length
= (b
[2] * 256 + b
[3]) * 4;
530 abfd
->tdata
.mmo_data
->lop_stab_symbol
531 = bfd_malloc (abfd
->tdata
.mmo_data
->max_symbol_length
+ 1);
533 if (abfd
->tdata
.mmo_data
->lop_stab_symbol
== NULL
)
536 /* xgettext:c-format */
537 (_("%pB: no core to allocate a symbol %d bytes long"),
538 abfd
, abfd
->tdata
.mmo_data
->max_symbol_length
);
542 /* Read in everything. */
543 if (! mmo_scan (abfd
))
544 goto bad_format_free
;
546 if (abfd
->symcount
> 0)
547 abfd
->flags
|= HAS_SYMS
;
549 /* You'll have to tweak this if you want to use this format for other
550 arches (not recommended due to its small-size limitations). Look at
551 the ELF format for how to make it target-generic. */
552 if (! bfd_default_set_arch_mach (abfd
, bfd_arch_mmix
, 0))
553 goto bad_format_free
;
555 return _bfd_no_cleanup
;
558 free (abfd
->tdata
.mmo_data
->lop_stab_symbol
);
560 bfd_set_error (bfd_error_wrong_format
);
565 /* Set up the mmo tdata information. */
568 mmo_mkobject (bfd
*abfd
)
572 if (abfd
->tdata
.mmo_data
== NULL
)
576 /* All fields are zero-initialized, so we don't have to explicitly
578 tdata_type
*tdata
= (tdata_type
*) bfd_zalloc (abfd
, sizeof (tdata_type
));
582 created
= time (NULL
);
583 bfd_put_32 (abfd
, created
, tdata
->created
);
585 abfd
->tdata
.mmo_data
= tdata
;
592 mmo_section_has_contents (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *p ATTRIBUTE_UNUSED
)
594 /* The point is to match what --extract-symbols does (well, negated). */
595 return bfd_section_size (sec
) != 0;
598 /* Find out whether we should omit symbol consistency checks for this
599 bfd and cache the value.
601 This function must only be called when all section contents is
602 known. However, calculating symbol consistency at the time the
603 private BFD data is initialized is too late for some uses. */
606 mmo_ignore_symbol_consistency (bfd
*abfd
)
608 if (!abfd
->tdata
.mmo_data
->symbol_consistency_override_calculated
)
610 abfd
->tdata
.mmo_data
->ignore_symbol_consistency
=
611 bfd_sections_find_if (abfd
, mmo_section_has_contents
, NULL
) == NULL
;
613 abfd
->tdata
.mmo_data
->symbol_consistency_override_calculated
= true;
616 return abfd
->tdata
.mmo_data
->ignore_symbol_consistency
;
620 mmo_bfd_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
622 if (bfd_get_flavour (ibfd
) != bfd_target_mmo_flavour
623 || bfd_get_flavour (obfd
) != bfd_target_mmo_flavour
)
626 /* Copy the time the copied-from file was created. If people want the
627 time the file was last *modified*, they have that in the normal file
629 memcpy (obfd
->tdata
.mmo_data
->created
, ibfd
->tdata
.mmo_data
->created
,
630 sizeof (obfd
->tdata
.mmo_data
->created
));
634 /* Helper functions for mmo_decide_section, used through
635 bfd_map_over_sections. */
638 mmo_find_sec_w_addr (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *p
)
640 struct mmo_find_sec_info
*infop
= (struct mmo_find_sec_info
*) p
;
641 bfd_vma vma
= bfd_section_vma (sec
);
643 /* Ignore sections that aren't loaded. */
644 if ((bfd_section_flags (sec
) & (SEC_LOAD
| SEC_ALLOC
))
645 != (SEC_LOAD
| SEC_ALLOC
))
648 if (infop
->addr
>= vma
&& infop
->addr
< vma
+ sec
->size
)
653 mmo_find_sec_w_addr_grow (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *p
)
655 struct mmo_find_sec_info
*infop
= (struct mmo_find_sec_info
*) p
;
656 bfd_vma vma
= bfd_section_vma (sec
);
658 /* Ignore sections that aren't loaded. */
659 if ((bfd_section_flags (sec
) & (SEC_LOAD
| SEC_ALLOC
))
660 != (SEC_LOAD
| SEC_ALLOC
))
663 if (infop
->addr
>= vma
&& infop
->addr
< vma
+ MAX_ARTIFICIAL_SECTION_SIZE
)
667 /* Find a section that corresponds to a VMA. Automatically create .text
668 or .data and set current section to it, depending on what vma. If we
669 can't deduce a section, make one up as ".MMIX.sec.N", where N is an
670 increasing number. */
673 mmo_decide_section (bfd
*abfd
, bfd_vma vma
)
675 asection
*sec
= NULL
;
676 char sec_name
[sizeof (".MMIX.sec.") + 20];
677 struct mmo_find_sec_info info
;
682 /* First see if there's a section that would match exactly. */
683 bfd_map_over_sections (abfd
, mmo_find_sec_w_addr
, &info
);
685 if (info
.sec
!= NULL
)
688 /* If there's no such section, try and expand one of the existing ones,
689 up to a limit. Make sure we have .text and .data before we try that;
690 create them corresponding to expected addresses and set flags to make
691 them match the "loaded and with contents" expectation. */
692 if ((vma
>> 56) == 0)
694 sec
= bfd_make_section_old_way (abfd
, MMO_TEXT_SECTION_NAME
);
699 if (!sec
->user_set_vma
&& !bfd_set_section_vma (sec
, vma
))
702 if (!bfd_set_section_flags (sec
, (bfd_section_flags (sec
)
703 | SEC_CODE
| SEC_LOAD
| SEC_ALLOC
)))
706 else if ((vma
>> 56) == 0x20)
708 sec
= bfd_make_section_old_way (abfd
, MMO_DATA_SECTION_NAME
);
713 if (!sec
->user_set_vma
&& !bfd_set_section_vma (sec
, vma
))
716 if (!bfd_set_section_flags (sec
, (bfd_section_flags (sec
)
717 | SEC_LOAD
| SEC_ALLOC
)))
721 bfd_map_over_sections (abfd
, mmo_find_sec_w_addr_grow
, &info
);
723 if (info
.sec
!= NULL
)
726 /* If there's still no suitable section, make a new one. */
727 sprintf (sec_name
, ".MMIX.sec.%d", abfd
->tdata
.mmo_data
->sec_no
++);
728 sec
= mmo_make_section (abfd
, sec_name
);
730 if (!sec
->user_set_vma
&& !bfd_set_section_vma (sec
, vma
))
733 if (!bfd_set_section_flags (sec
, (bfd_section_flags (sec
)
734 | SEC_LOAD
| SEC_ALLOC
)))
739 /* Xor in a 64-bit value VALUE at VMA. */
741 static inline bfd_byte
*
742 mmo_xore_64 (asection
*sec
, bfd_vma vma
, bfd_vma value
)
744 bfd_byte
*loc
= mmo_get_loc (sec
, vma
, 8);
747 bfd_vma prev
= bfd_get_64 (sec
->owner
, loc
);
750 bfd_put_64 (sec
->owner
, value
, loc
);
755 /* Xor in a 32-bit value VALUE at VMA. */
757 static inline bfd_byte
*
758 mmo_xore_32 (asection
*sec
, bfd_vma vma
, unsigned int value
)
760 bfd_byte
*loc
= mmo_get_loc (sec
, vma
, 4);
763 unsigned int prev
= bfd_get_32 (sec
->owner
, loc
);
766 bfd_put_32 (sec
->owner
, value
, loc
);
771 /* Xor in a 16-bit value VALUE at VMA. */
773 static inline bfd_byte
*
774 mmo_xore_16 (asection
*sec
, bfd_vma vma
, unsigned int value
)
776 bfd_byte
*loc
= mmo_get_loc (sec
, vma
, 2);
779 unsigned int prev
= bfd_get_16 (sec
->owner
, loc
);
782 bfd_put_16 (sec
->owner
, value
, loc
);
787 /* Write a 32-bit word to output file, no lop_quote generated. */
790 mmo_write_tetra_raw (bfd
*abfd
, unsigned int value
)
794 bfd_put_32 (abfd
, value
, buf
);
796 if (bfd_bwrite (buf
, 4, abfd
) != 4)
797 abfd
->tdata
.mmo_data
->have_error
= true;
800 /* Write a 32-bit word to output file; lop_quote if necessary. */
803 mmo_write_tetra (bfd
*abfd
, unsigned int value
)
805 if (((value
>> 24) & 0xff) == LOP
)
806 mmo_write_tetra_raw (abfd
, LOP_QUOTE_NEXT
);
808 mmo_write_tetra_raw (abfd
, value
);
811 /* Write a 64-bit word to output file, perhaps with lop_quoting. */
814 mmo_write_octa (bfd
*abfd
, bfd_vma value
)
816 mmo_write_tetra (abfd
, (unsigned int) (value
>> 32));
817 mmo_write_tetra (abfd
, (unsigned int) value
);
820 /* Write a 64-bit word to output file, without lop_quoting. */
823 mmo_write_octa_raw (bfd
*abfd
, bfd_vma value
)
825 mmo_write_tetra_raw (abfd
, (unsigned int) (value
>> 32));
826 mmo_write_tetra_raw (abfd
, (unsigned int) value
);
829 /* Write quoted contents. Intended to be called multiple times in
830 sequence, followed by a call to mmo_flush_chunk. */
833 mmo_write_chunk (bfd
*abfd
, const bfd_byte
*loc
, unsigned int len
)
836 struct mmo_data_struct
*mmop
= abfd
->tdata
.mmo_data
;
838 /* Fill up a tetra from bytes remaining from a previous chunk. */
839 if (mmop
->byte_no
!= 0)
841 while (mmop
->byte_no
< 4 && len
!= 0)
843 mmop
->buf
[mmop
->byte_no
++] = *loc
++;
847 if (mmop
->byte_no
== 4)
849 mmo_write_tetra (abfd
, bfd_get_32 (abfd
, mmop
->buf
));
857 mmo_write_tetra_raw (abfd
, LOP_QUOTE_NEXT
);
860 && ! mmop
->have_error
861 && 4 == bfd_bwrite (loc
, 4, abfd
));
869 /* We must have flushed a previous remainder if we get one from
871 BFD_ASSERT (mmop
->byte_no
== 0);
872 memcpy (mmop
->buf
, loc
, len
);
877 mmop
->have_error
= true;
881 /* Flush remaining bytes, from a previous mmo_write_chunk, zero-padded to
885 mmo_flush_chunk (bfd
*abfd
)
887 if (abfd
->tdata
.mmo_data
->byte_no
!= 0)
889 memset (abfd
->tdata
.mmo_data
->buf
+ abfd
->tdata
.mmo_data
->byte_no
,
890 0, 4 - abfd
->tdata
.mmo_data
->byte_no
);
891 mmo_write_tetra (abfd
,
892 bfd_get_32 (abfd
, abfd
->tdata
.mmo_data
->buf
));
893 abfd
->tdata
.mmo_data
->byte_no
= 0;
896 return ! abfd
->tdata
.mmo_data
->have_error
;
899 /* Same, but from a list. */
902 mmo_write_chunk_list (bfd
*abfd
, mmo_data_list_type
*datap
)
904 for (; datap
!= NULL
; datap
= datap
->next
)
905 if (! mmo_write_chunk (abfd
, datap
->data
, datap
->size
))
908 return mmo_flush_chunk (abfd
);
911 /* Write a lop_loc and some contents. A caller needs to call
912 mmo_flush_chunk after calling this function. The location is only
913 output if different than *LAST_VMAP, which is updated after this call. */
916 mmo_write_loc_chunk (bfd
*abfd
, bfd_vma vma
, const bfd_byte
*loc
,
917 unsigned int len
, bfd_vma
*last_vmap
)
919 /* Find an initial and trailing section of zero (aligned) tetras; we don't
920 need to write out zeros. FIXME: When we do this, we should emit
921 section size and address specifiers, else objcopy can't always perform
922 an identity translation. Only do this if we *don't* have left-over
923 data from a previous write (and will not add any) or else the vma of
924 this chunk is *not* the next address, because then data isn't
925 tetrabyte-aligned and we're concatenating to that left-over data. */
928 && (abfd
->tdata
.mmo_data
->byte_no
== 0 || vma
!= *last_vmap
))
930 while (len
> 4 && bfd_get_32 (abfd
, loc
) == 0)
938 while (len
> 4 && bfd_get_32 (abfd
, loc
+ len
- 4) == 0)
942 /* Only write out the location if it's different than the one the caller
943 (supposedly) previously handled, accounting for omitted leading zeros. */
944 if (vma
!= *last_vmap
)
946 /* We might be in the middle of a sequence. */
947 mmo_flush_chunk (abfd
);
949 /* This should not happen during normal usage, but can presumably
950 happen with an erroneous linker-script, so handle gracefully.
951 Avoid Knuth-specific terms in the message, such as "tetrabyte".
952 Note that this function will get non-4-multiple lengths and
953 unaligned vmas but those come in tuples (mostly pairs) and are
954 continuous (i.e. the if-condition above false) and they are
955 group-wise aligned. */
959 /* xgettext:c-format */
960 (_("%pB: attempt to emit contents at non-multiple-of-4"
961 " address %#" PRIx64
""),
962 abfd
, (uint64_t) vma
);
963 bfd_set_error (bfd_error_bad_value
);
967 /* We always write the location as 64 bits; no use saving bytes
969 mmo_write_tetra_raw (abfd
, (LOP
<< 24) | (LOP_LOC
<< 16) | 2);
970 mmo_write_octa_raw (abfd
, vma
);
973 /* Update to reflect end of this chunk, with trailing zeros omitted. */
974 *last_vmap
= vma
+ len
;
976 return (! abfd
->tdata
.mmo_data
->have_error
977 && mmo_write_chunk (abfd
, loc
, len
));
980 /* Same, but from a list. */
983 mmo_write_loc_chunk_list (bfd
*abfd
, mmo_data_list_type
*datap
)
985 /* Get an address different than the address of the first chunk. */
986 bfd_vma last_vma
= datap
? datap
->where
- 1 : 0;
988 for (; datap
!= NULL
; datap
= datap
->next
)
989 if (! mmo_write_loc_chunk (abfd
, datap
->where
, datap
->data
, datap
->size
,
993 return mmo_flush_chunk (abfd
);
996 /* Make a .MMIX.spec_data.N section. */
999 mmo_get_generic_spec_data_section (bfd
*abfd
, int spec_data_number
)
1002 char secname
[sizeof (MMIX_OTHER_SPEC_SECTION_PREFIX
) + 20]
1003 = MMIX_OTHER_SPEC_SECTION_PREFIX
;
1005 sprintf (secname
+ strlen (MMIX_OTHER_SPEC_SECTION_PREFIX
),
1006 "%d", spec_data_number
);
1008 sec
= mmo_make_section (abfd
, secname
);
1013 /* Make a special section for SPEC_DATA_NUMBER. If it is the one we use
1014 ourselves, parse some of its data to get at the section name. */
1017 mmo_get_spec_section (bfd
*abfd
, int spec_data_number
)
1022 unsigned int secname_length
;
1024 bfd_vma section_length
;
1025 bfd_vma section_vma
;
1026 mmo_data_list_type
*loc
;
1030 /* If this isn't the "special" special data, then make a placeholder
1032 if (spec_data_number
!= SPEC_DATA_SECTION
)
1033 return mmo_get_generic_spec_data_section (abfd
, spec_data_number
);
1035 /* Seek back to this position if there was a format error. */
1036 orig_pos
= bfd_tell (abfd
);
1038 /* Read the length (in 32-bit words). */
1039 if (bfd_bread (buf
, 4, abfd
) != 4)
1044 if (buf
[1] != LOP_QUOTE
)
1047 if (bfd_bread (buf
, 4, abfd
) != 4)
1051 /* We don't care to keep the name length accurate. It's
1053 secname_length
= bfd_get_32 (abfd
, buf
) * 4;
1055 /* Check section name length for sanity. */
1056 if (secname_length
> MAX_SECTION_NAME_SIZE
)
1059 /* This should be free'd regardless if a section is created. */
1060 secname
= bfd_malloc (secname_length
+ 1);
1061 secname
[secname_length
] = 0;
1063 for (i
= 0; i
< secname_length
/ 4; i
++)
1065 if (bfd_bread (secname
+ i
* 4, 4, abfd
) != 4)
1066 goto format_error_free
;
1068 if (secname
[i
* 4] == (char) LOP
)
1070 /* A bit of overkill, but we handle char 0x98 in a section name,
1071 and recognize misparsing. */
1072 if (secname
[i
* 4 + 1] != LOP_QUOTE
1073 || bfd_bread (secname
+ i
* 4, 4, abfd
) != 4)
1074 /* Whoops. We thought this was a name, and now we found a
1075 non-lop_quote lopcode before we parsed the whole length of
1076 the name. Signal end-of-file in the same manner. */
1077 goto format_error_free
;
1081 /* Get the section flags. */
1082 if (bfd_bread (buf
, 4, abfd
) != 4
1084 && (buf
[1] != LOP_QUOTE
|| bfd_bread (buf
, 4, abfd
) != 4)))
1085 goto format_error_free
;
1087 flags
= bfd_get_32 (abfd
, buf
);
1089 /* Get the section length. */
1090 if (bfd_bread (buf
, 4, abfd
) != 4
1092 && (buf
[1] != LOP_QUOTE
|| bfd_bread (buf
, 4, abfd
) != 4)))
1093 goto format_error_free
;
1095 section_length
= (bfd_vma
) bfd_get_32 (abfd
, buf
) << 32;
1097 /* That's the first, high-part. Now get the low part. */
1099 if (bfd_bread (buf
, 4, abfd
) != 4
1101 && (buf
[1] != LOP_QUOTE
|| bfd_bread (buf
, 4, abfd
) != 4)))
1102 goto format_error_free
;
1104 section_length
|= (bfd_vma
) bfd_get_32 (abfd
, buf
);
1106 /* Check the section length for sanity. */
1107 if (section_length
> MAX_ARTIFICIAL_SECTION_SIZE
)
1108 goto format_error_free
;
1110 /* Get the section VMA. */
1111 if (bfd_bread (buf
, 4, abfd
) != 4
1113 && (buf
[1] != LOP_QUOTE
|| bfd_bread (buf
, 4, abfd
) != 4)))
1114 goto format_error_free
;
1116 section_vma
= (bfd_vma
) bfd_get_32 (abfd
, buf
) << 32;
1118 /* That's the first, high-part. Now get the low part. */
1119 if (bfd_bread (buf
, 4, abfd
) != 4
1121 && (buf
[1] != LOP_QUOTE
|| bfd_bread (buf
, 4, abfd
) != 4)))
1122 goto format_error_free
;
1124 section_vma
|= (bfd_vma
) bfd_get_32 (abfd
, buf
);
1126 sec
= mmo_make_section (abfd
, secname
);
1131 /* We allocate a buffer here for the advertised size, with head room for
1132 tetrabyte alignment. */
1133 loc
= bfd_zmalloc (section_length
+ 3
1134 + sizeof (struct mmo_data_list_struct
));
1138 /* Use a TETRA-rounded size for the allocated buffer; we set the
1139 "visible" section size below. */
1140 loc
->size
= (section_length
+ 3) & ~3;
1142 /* Add in the section flags we found to those bfd entered during this
1143 process and set the contents. */
1144 if (!bfd_set_section_flags (sec
,
1145 (bfd_sec_flags_from_mmo_flags (flags
)
1146 | bfd_section_flags (sec
)
1147 | (section_length
!= 0 ? SEC_HAS_CONTENTS
: 0)))
1148 || !bfd_set_section_size (sec
, sec
->size
+ section_length
)
1149 /* Set VMA only for the first occurrence. */
1150 || (!sec
->user_set_vma
&& !bfd_set_section_vma (sec
, section_vma
)))
1152 /* If we get an error for any of the calls above, signal more than
1153 just a format error for the spec section. */
1158 if (mmo_section_data (sec
)->tail
!= NULL
)
1159 mmo_section_data (sec
)->tail
->next
= loc
;
1161 mmo_section_data (sec
)->head
= loc
;
1162 mmo_section_data (sec
)->tail
= loc
;
1163 loc
->where
= section_vma
;
1170 if (bfd_seek (abfd
, orig_pos
, SEEK_SET
) != 0)
1173 return mmo_get_generic_spec_data_section (abfd
, spec_data_number
);
1176 /* Read a byte, but read from file in multiples of 32-bit words. */
1179 mmo_get_byte (bfd
*abfd
)
1183 if (abfd
->tdata
.mmo_data
->byte_no
== 0)
1185 if (! abfd
->tdata
.mmo_data
->have_error
1186 && bfd_bread (abfd
->tdata
.mmo_data
->buf
, 4, abfd
) != 4)
1188 abfd
->tdata
.mmo_data
->have_error
= true;
1190 /* A value somewhat safe against tripping on some inconsistency
1191 when mopping up after this error. */
1196 retval
= abfd
->tdata
.mmo_data
->buf
[abfd
->tdata
.mmo_data
->byte_no
];
1197 abfd
->tdata
.mmo_data
->byte_no
= (abfd
->tdata
.mmo_data
->byte_no
+ 1) % 4;
1202 /* Write a byte, in multiples of 32-bit words. */
1205 mmo_write_byte (bfd
*abfd
, bfd_byte value
)
1207 abfd
->tdata
.mmo_data
->buf
[(abfd
->tdata
.mmo_data
->byte_no
++ % 4)] = value
;
1208 if ((abfd
->tdata
.mmo_data
->byte_no
% 4) == 0)
1210 if (! abfd
->tdata
.mmo_data
->have_error
1211 && bfd_bwrite (abfd
->tdata
.mmo_data
->buf
, 4, abfd
) != 4)
1212 abfd
->tdata
.mmo_data
->have_error
= true;
1216 /* Create a symbol. */
1219 mmo_create_symbol (bfd
*abfd
, const char *symname
, bfd_vma addr
, enum
1220 mmo_sym_type sym_type
, unsigned int serno
)
1222 struct mmo_symbol
*n
;
1224 n
= (struct mmo_symbol
*) bfd_alloc (abfd
, sizeof (struct mmo_symbol
));
1228 n
->name
= bfd_alloc (abfd
, strlen (symname
) + 1);
1229 if (n
->name
== NULL
)
1232 strcpy (n
->name
, symname
);
1235 n
->sym_type
= sym_type
;
1238 if (abfd
->tdata
.mmo_data
->symbols
== NULL
)
1239 abfd
->tdata
.mmo_data
->symbols
= n
;
1241 abfd
->tdata
.mmo_data
->symtail
->next
= n
;
1242 abfd
->tdata
.mmo_data
->symtail
= n
;
1247 /* Check that :Main equals the last octa of the .MMIX.reg_contents
1248 section, as it's the one place we're sure to pass when reading a mmo
1249 object. For written objects, we do it while setting the symbol
1251 if (strcmp (symname
, MMIX_START_SYMBOL_NAME
) == 0
1252 && bfd_get_start_address (abfd
) != addr
1253 && !mmo_ignore_symbol_consistency (abfd
))
1256 (_("%pB: invalid mmo file: initialization value for $255"
1257 " is not `Main'\n"),
1259 bfd_set_error (bfd_error_bad_value
);
1266 /* Read in symbols. */
1269 mmo_get_symbols (bfd
*abfd
)
1273 Symbol-table, mmo section mapping, File layout, mmo
1277 From mmixal.w (or really, the generated mmixal.tex) in the
1278 MMIXware package which also contains the @command{mmix} simulator:
1279 ``Symbols are stored and retrieved by means of a @samp{ternary
1280 search trie}, following ideas of Bentley and Sedgewick. (See
1281 ACM--SIAM Symp.@: on Discrete Algorithms @samp{8} (1997), 360--369;
1282 R.@:Sedgewick, @samp{Algorithms in C} (Reading, Mass.@:
1283 Addison--Wesley, 1998), @samp{15.4}.) Each trie node stores a
1284 character, and there are branches to subtries for the cases where
1285 a given character is less than, equal to, or greater than the
1286 character in the trie. There also is a pointer to a symbol table
1287 entry if a symbol ends at the current node.''
1289 So it's a tree encoded as a stream of bytes. The stream of bytes
1290 acts on a single virtual global symbol, adding and removing
1291 characters and signalling complete symbol points. Here, we read
1292 the stream and create symbols at the completion points.
1294 First, there's a control byte <<m>>. If any of the listed bits
1295 in <<m>> is nonzero, we execute what stands at the right, in
1299 | 0x40 - Traverse left trie.
1300 | (Read a new command byte and recurse.)
1303 | 0x2f - Read the next byte as a character and store it in the
1304 | current character position; increment character position.
1305 | Test the bits of <<m>>:
1308 | 0x80 - The character is 16-bit (so read another byte,
1309 | merge into current character.
1312 | 0xf - We have a complete symbol; parse the type, value
1313 | and serial number and do what should be done
1314 | with a symbol. The type and length information
1315 | is in j = (m & 0xf).
1317 | (MMO3_REGQUAL_BITS)
1318 | j == 0xf: A register variable. The following
1319 | byte tells which register.
1320 | j <= 8: An absolute symbol. Read j bytes as the
1321 | big-endian number the symbol equals.
1322 | A j = 2 with two zero bytes denotes an
1324 | j > 8: As with j <= 8, but add (0x20 << 56)
1325 | to the value in the following j - 8
1328 | Then comes the serial number, as a variant of
1329 | uleb128, but better named ubeb128:
1330 | Read bytes and shift the previous value left 7
1331 | (multiply by 128). Add in the new byte, repeat
1332 | until a byte has bit 7 set. The serial number
1333 | is the computed value minus 128.
1336 | 0x20 - Traverse middle trie. (Read a new command byte
1337 | and recurse.) Decrement character position.
1340 | 0x10 - Traverse right trie. (Read a new command byte and
1343 Let's look again at the <<lop_stab>> for the trivial file
1344 (@pxref{File layout}).
1346 | 0x980b0000 - lop_stab for ":Main" = 0, serial 1.
1353 This forms the trivial trie (note that the path between ``:'' and
1354 ``M'' is redundant):
1365 | 016e "n" is the last character in a full symbol, and
1366 | with a value represented in one byte.
1367 | 00 The value is 0.
1368 | 81 The serial number is 1. */
1370 bfd_byte m
= mmo_get_byte (abfd
);
1372 /* Check first if we have a bad hair day. */
1373 if (abfd
->tdata
.mmo_data
->have_error
)
1377 /* Traverse left trie. */
1378 mmo_get_symbols (abfd
);
1380 if (m
& MMO3_SYMBITS
)
1382 bfd_byte c
= mmo_get_byte (abfd
);
1383 bfd_byte j
= m
& MMO3_TYPEBITS
;
1385 enum mmo_sym_type sym_type
;
1386 unsigned int serno
= 0;
1391 bfd_byte c2
= mmo_get_byte (abfd
);
1393 /* A two-byte character. We can't grok this, but neither can
1394 mmotype, for other cases than the second byte being zero. */
1398 abfd
->tdata
.mmo_data
->lop_stab_symbol
1399 [abfd
->tdata
.mmo_data
->symbol_position
] = 0;
1402 /* xgettext:c-format */
1403 (_("%pB: unsupported wide character sequence"
1404 " 0x%02X 0x%02X after symbol name starting with `%s'\n"),
1405 abfd
, c
, c2
, abfd
->tdata
.mmo_data
->lop_stab_symbol
);
1406 bfd_set_error (bfd_error_bad_value
);
1407 abfd
->tdata
.mmo_data
->have_error
= true;
1414 abfd
->tdata
.mmo_data
->lop_stab_symbol
[abfd
->tdata
.mmo_data
->symbol_position
++] = c
;
1415 abfd
->tdata
.mmo_data
->lop_stab_symbol
[abfd
->tdata
.mmo_data
->symbol_position
] = 0;
1417 if (j
& MMO3_REGQUAL_BITS
)
1419 if (j
== MMO3_REGQUAL_BITS
)
1421 sym_type
= mmo_reg_sym
;
1422 addr
= mmo_get_byte (abfd
);
1428 for (i
= 0; i
< j
; i
++)
1429 addr
= (addr
<< 8) + mmo_get_byte (abfd
);
1431 if (addr
== 0 && j
== MMO3_UNDEF
)
1432 sym_type
= mmo_undef_sym
;
1434 sym_type
= mmo_abs_sym
;
1440 for (i
= MMO3_DATA
; i
< j
; i
++)
1441 addr
= (addr
<< 8) + mmo_get_byte (abfd
);
1443 addr
+= (bfd_vma
) 0x20 << 56;
1444 sym_type
= mmo_data_sym
;
1447 /* Get the serial number. */
1450 k
= mmo_get_byte (abfd
);
1451 serno
= (serno
<< 7) + k
;
1456 /* Got it. Now enter it. Skip a leading ":". */
1457 if (! abfd
->tdata
.mmo_data
->have_error
1458 && ! mmo_create_symbol (abfd
,
1459 abfd
->tdata
.mmo_data
->lop_stab_symbol
1461 addr
, sym_type
, serno
))
1462 abfd
->tdata
.mmo_data
->have_error
= true;
1465 if (m
& MMO3_MIDDLE
)
1466 /* Traverse middle trie. */
1467 mmo_get_symbols (abfd
);
1469 abfd
->tdata
.mmo_data
->symbol_position
--;
1473 /* Traverse right trie. */
1474 mmo_get_symbols (abfd
);
1476 return ! abfd
->tdata
.mmo_data
->have_error
;
1479 /* Get the location of memory area [VMA..VMA + SIZE - 1], which we think
1480 is in section SEC. Adjust and reallocate zero-initialized contents.
1481 If there's new contents, allocate to the next multiple of
1482 MMO_SEC_CONTENTS_CHUNK_SIZE. */
1485 mmo_get_loc (asection
*sec
, bfd_vma vma
, int size
)
1487 bfd_size_type allocated_size
;
1488 struct mmo_section_data_struct
*sdatap
= mmo_section_data (sec
);
1489 struct mmo_data_list_struct
*datap
= sdatap
->head
;
1490 struct mmo_data_list_struct
*entry
;
1492 /* First search the list to see if we have the requested chunk in one
1493 piece, or perhaps if we have a suitable chunk with room to fit. */
1494 for (; datap
!= NULL
; datap
= datap
->next
)
1496 if (datap
->where
<= vma
1497 && datap
->where
+ datap
->size
>= vma
+ size
)
1498 return datap
->data
+ vma
- datap
->where
;
1499 else if (datap
->where
<= vma
1500 && datap
->where
+ datap
->allocated_size
>= vma
+ size
1501 /* Only munch on the "allocated size" if it does not
1502 overlap the next chunk. */
1503 && (datap
->next
== NULL
|| datap
->next
->where
>= vma
+ size
))
1505 /* There was room allocated, but the size wasn't set to include
1507 datap
->size
+= (vma
+ size
) - (datap
->where
+ datap
->size
);
1509 /* Update the section size. This happens only if we update the
1510 32-bit-aligned chunk size. Callers that have
1511 non-32-bit-aligned sections should do all allocation and
1512 size-setting by themselves or at least set the section size
1513 after the last allocating call to this function. */
1514 if (vma
+ size
> sec
->vma
+ sec
->size
)
1515 sec
->size
+= (vma
+ size
) - (sec
->vma
+ sec
->size
);
1517 return datap
->data
+ vma
- datap
->where
;
1521 /* Not found; allocate a new block. First check in case we get a
1522 request for a size split up over several blocks; we'll have to return
1523 NULL for those cases, requesting the caller to split up the request.
1524 Requests with an address aligned on MMO_SEC_CONTENTS_CHUNK_SIZE bytes and
1525 for no more than MMO_SEC_CONTENTS_CHUNK_SIZE will always get resolved. */
1527 for (datap
= sdatap
->head
; datap
!= NULL
; datap
= datap
->next
)
1528 if ((datap
->where
<= vma
&& datap
->where
+ datap
->size
> vma
)
1529 || (datap
->where
< vma
+ size
1530 && datap
->where
+ datap
->size
>= vma
+ size
))
1534 = (size
+ MMO_SEC_CONTENTS_CHUNK_SIZE
- 1) & ~(MMO_SEC_CONTENTS_CHUNK_SIZE
- 1);
1535 entry
= (mmo_data_list_type
*)
1536 bfd_zalloc (sec
->owner
, sizeof (mmo_data_list_type
) + allocated_size
);
1541 entry
->allocated_size
= allocated_size
;
1543 datap
= sdatap
->head
;
1545 /* Sort the records by address. Optimize for the common case of adding
1546 a record to the end of the list. */
1547 if (sdatap
->tail
!= NULL
&& entry
->where
>= sdatap
->tail
->where
)
1549 sdatap
->tail
->next
= entry
;
1551 sdatap
->tail
= entry
;
1555 mmo_data_list_type
**look
;
1556 for (look
= &sdatap
->head
;
1557 *look
!= NULL
&& (*look
)->where
< entry
->where
;
1558 look
= &(*look
)->next
)
1560 entry
->next
= *look
;
1562 if (entry
->next
== NULL
)
1564 sdatap
->tail
= entry
;
1566 /* We get here for the first time (at other times too) for this
1567 section. Say we have contents. */
1568 if (!bfd_set_section_flags (sec
, (bfd_section_flags (sec
)
1569 | SEC_HAS_CONTENTS
)))
1574 /* Update the section size. This happens only when we add contents and
1575 re-size as we go. The section size will then be aligned to 32 bits. */
1576 if (vma
+ size
> sec
->vma
+ sec
->size
)
1577 sec
->size
+= (vma
+ size
) - (sec
->vma
+ sec
->size
);
1581 /* Set sizes once we've read in all sections. */
1584 mmo_map_set_sizes (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
,
1585 void *ignored ATTRIBUTE_UNUSED
)
1587 sec
->lma
= sec
->vma
;
1590 /* Read the mmo file and turn it into sections. */
1593 mmo_scan (bfd
*abfd
)
1596 unsigned int lineno
= 1;
1599 asection
*sec
= NULL
;
1600 asection
*non_spec_sec
= NULL
;
1601 bfd_vma non_spec_vma
= 0;
1602 bfd_size_type nbytes_read
= 0;
1603 /* Buffer with room to read a 64-bit value. */
1605 file_ptr stab_loc
= -1;
1606 char *file_names
[256];
1609 memset (file_names
, 0, sizeof (file_names
));
1611 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
1614 while ((nbytes_read
= bfd_bread (buf
, 4, abfd
)) == 4)
1618 unsigned int y
= bfd_get_8 (abfd
, buf
+ 2);
1619 unsigned int z
= bfd_get_8 (abfd
, buf
+ 3);
1621 /* Change back to the original section for lopcodes other
1622 than LOP_QUOTE that comes after a LOP_SPEC. */
1623 if ((buf
[1] != LOP_QUOTE
|| y
!= 0 || z
!= 1)
1624 && non_spec_sec
!= NULL
)
1628 non_spec_sec
= NULL
;
1635 /* xgettext:c-format */
1636 (_("%pB: invalid mmo file: unsupported lopcode `%d'\n"),
1638 bfd_set_error (bfd_error_bad_value
);
1642 /* Quote the next 32-bit word. */
1643 if (y
!= 0 || z
!= 1)
1646 /* xgettext:c-format */
1647 (_("%pB: invalid mmo file: expected YZ = 1"
1648 " got YZ = %d for lop_quote\n"),
1650 bfd_set_error (bfd_error_bad_value
);
1653 if (bfd_bread (buf
, 4, abfd
) != 4)
1658 sec
= bfd_make_section_old_way (abfd
, MMO_TEXT_SECTION_NAME
);
1659 if (!mmo_xore_32 (sec
, vma
, bfd_get_32 (abfd
, buf
)))
1661 bfd_set_error (bfd_error_bad_value
);
1669 /* Set vma (and section). */
1670 vma
= (bfd_vma
) y
<< 56;
1673 /* Get a 32-bit value. */
1674 if (bfd_bread (buf
, 4, abfd
) != 4)
1677 vma
+= bfd_get_32 (abfd
, buf
);
1681 /* Get a 64-bit value. */
1682 if (bfd_bread (buf
, 8, abfd
) != 8)
1685 vma
+= bfd_get_64 (abfd
, buf
);
1690 /* xgettext:c-format */
1691 (_("%pB: invalid mmo file: expected z = 1 or z = 2,"
1692 " got z = %d for lop_loc\n"),
1694 bfd_set_error (bfd_error_bad_value
);
1698 /* When we decide which section the data goes into, we might
1699 create the section. If that happens, make sure the VMA at
1700 creation time is tetra-aligned. */
1701 sec
= mmo_decide_section (abfd
, vma
& ~3);
1707 /* Move forward within the same section. */
1710 sec
= mmo_decide_section (abfd
, vma
);
1716 /* A fixup: Store the current vma somewhere. Position using
1717 same format as LOP_LOC. */
1719 bfd_vma p
= (bfd_vma
) y
<< 56;
1724 /* Get a 32-bit value. */
1725 if (bfd_bread (buf
, 4, abfd
) != 4)
1728 p
+= bfd_get_32 (abfd
, buf
);
1732 /* Get a 64-bit value. */
1733 if (bfd_bread (buf
, 8, abfd
) != 8)
1736 p
+= bfd_get_64 (abfd
, buf
);
1741 /* xgettext:c-format */
1742 (_("%pB: invalid mmo file: expected z = 1 or z = 2,"
1743 " got z = %d for lop_fixo\n"),
1745 bfd_set_error (bfd_error_bad_value
);
1749 /* The section where we store this address might be a
1750 different one than the current section. */
1751 fixosec
= mmo_decide_section (abfd
, p
);
1752 if (fixosec
== NULL
)
1754 if (!mmo_xore_64 (fixosec
, p
, vma
))
1756 bfd_set_error (bfd_error_bad_value
);
1763 /* A fixup: Store YZ of this lopcode into YZ at vma - 4 * yz. */
1765 unsigned int yz
= (y
* 256 + z
);
1766 bfd_vma p
= vma
+ 2 - 4 * yz
;
1767 asection
*fixrsec
= mmo_decide_section (abfd
, p
);
1768 if (fixrsec
== NULL
)
1770 if (!mmo_xore_16 (fixrsec
, p
, yz
))
1772 bfd_set_error (bfd_error_bad_value
);
1779 /* A fixup, similar to lop_fixr, but taking larger numbers
1780 and can change branches into the opposite direction
1790 /* xgettext:c-format */
1791 (_("%pB: invalid mmo file: expected y = 0,"
1792 " got y = %d for lop_fixrx\n"),
1794 bfd_set_error (bfd_error_bad_value
);
1798 if (z
!= 16 && z
!= 24)
1801 /* xgettext:c-format */
1802 (_("%pB: invalid mmo file: expected z = 16 or z = 24,"
1803 " got z = %d for lop_fixrx\n"),
1805 bfd_set_error (bfd_error_bad_value
);
1809 /* Get the next 32-bit value. */
1810 if (bfd_bread (buf
, 4, abfd
) != 4)
1813 delta
= bfd_get_32 (abfd
, buf
);
1815 /* Do an, ehm, involved calculation for the location of
1816 the fixup. See mmixal documentation for a verbose
1817 explanation. We follow it verbosely here for the
1820 p
= vma
- 4 * delta
;
1821 else if (buf
[0] == 1)
1822 p
= vma
- 4 * ((delta
& 0xffffff) - (1 << z
));
1826 /* xgettext:c-format */
1827 (_("%pB: invalid mmo file: leading byte of operand word"
1828 " must be 0 or 1, got %d for lop_fixrx\n"),
1830 bfd_set_error (bfd_error_bad_value
);
1834 fixrsec
= mmo_decide_section (abfd
, vma
);
1835 if (fixrsec
== NULL
)
1837 if (!mmo_xore_32 (fixrsec
, p
, delta
))
1839 bfd_set_error (bfd_error_bad_value
);
1846 /* Set current file and perhaps the file name. Reset line
1850 char *fname
= bfd_malloc (z
* 4 + 1);
1855 /* xgettext:c-format */
1856 (_("%pB: cannot allocate file name for file number %d,"
1858 abfd
, y
, z
* 4 + 1);
1859 bfd_set_error (bfd_error_system_call
);
1865 for (i
= 0; i
< z
; i
++)
1867 if (bfd_bread (fname
+ i
* 4, 4, abfd
) != 4)
1874 if (file_names
[y
] != NULL
)
1877 /* xgettext:c-format */
1878 (_("%pB: invalid mmo file: file number %d `%s',"
1879 " was already entered as `%s'\n"),
1880 abfd
, y
, fname
, file_names
[y
]);
1881 bfd_set_error (bfd_error_bad_value
);
1885 file_names
[y
] = fname
;
1888 if (file_names
[y
] == NULL
)
1891 /* xgettext:c-format */
1892 (_("%pB: invalid mmo file: file name for number %d"
1893 " was not specified before use\n"),
1895 bfd_set_error (bfd_error_bad_value
);
1903 /* Set line number. */
1904 lineno
= y
* 256 + z
;
1905 /* FIXME: Create a sequence of mmo-specific line number
1906 entries for each section, then translate into canonical
1911 /* Special data follows until the next non-lop_quote
1915 sec
= mmo_get_spec_section (abfd
, y
* 256 + z
);
1924 /* We ignore header information, except we read in the
1925 creation time from the first 32-bit word with the time
1926 in seconds since era. */
1928 && bfd_bread (abfd
->tdata
.mmo_data
->created
, 4,
1932 for (i
= 1; i
< z
; i
++)
1933 if (bfd_bread (buf
, 4, abfd
) != 4)
1939 /* This tells of the contents of registers $Z..$255 at
1940 startup. We make a section out of it, with VMA = Z * 8,
1941 but only if Z != 255 or the contents is non-zero. */
1946 bfd_vma startaddr_octa
;
1948 /* Read first octaword outside loop to simplify logic when
1949 excluding the Z == 255, octa == 0 case. */
1950 if (bfd_bread (buf
, 8, abfd
) != 8)
1953 first_octa
= bfd_get_64 (abfd
, buf
);
1955 /* Don't emit contents for the trivial case which is
1956 always present; $255 pointing to Main. */
1960 = bfd_make_section_old_way (abfd
,
1961 MMIX_REG_CONTENTS_SECTION_NAME
);
1962 rsec
->flags
|= SEC_LINKER_CREATED
;
1964 loc
= mmo_get_loc (rsec
, z
* 8, (255 - z
) * 8);
1967 bfd_set_error (bfd_error_bad_value
);
1970 bfd_put_64 (abfd
, first_octa
, loc
);
1972 for (i
= z
+ 1; i
< 255; i
++)
1974 if (bfd_bread (loc
+ (i
- z
) * 8, 8, abfd
) != 8)
1978 /* Read out the last octabyte, and use it to set the
1980 if (bfd_bread (buf
, 8, abfd
) != 8)
1983 startaddr_octa
= bfd_get_64 (abfd
, buf
);
1986 startaddr_octa
= first_octa
;
1988 if (! bfd_set_start_address (abfd
, startaddr_octa
))
1990 /* Currently this can't fail, but this should handle
1992 bfd_set_error (bfd_error_bad_value
);
1999 /* We read in the symbols now, not later. */
2000 if (y
!= 0 || z
!= 0)
2003 /* xgettext:c-format */
2004 (_("%pB: invalid mmo file: fields y and z of lop_stab"
2005 " non-zero, y: %d, z: %d\n"),
2007 bfd_set_error (bfd_error_bad_value
);
2011 /* Save the location, so we can check that YZ in the LOP_END
2013 stab_loc
= bfd_tell (abfd
);
2015 /* It's not said that an MMO can be without symbols (though
2016 mmixal will refuse to assemble files without Main), but
2017 it seems it would still be a valid mmo-file, so allow it.
2018 We detect the absence of a symbol area in that the upper
2019 limit is computed (from the lop_end YZ field) as 0.
2020 Don't call mmo_get_symbols; it can only detect the end of
2021 a valid symbol trie, not the absence of one. */
2022 if (abfd
->tdata
.mmo_data
->max_symbol_length
!= 0
2023 && ! mmo_get_symbols (abfd
))
2029 /* This must be the last 32-bit word in an mmo file.
2031 struct stat statbuf
;
2032 file_ptr curpos
= bfd_tell (abfd
);
2034 if (bfd_stat (abfd
, &statbuf
) < 0)
2037 if (statbuf
.st_size
!= curpos
)
2040 /* xgettext:c-format */
2041 (_("%pB: invalid mmo file: lop_end not last item in"
2044 bfd_set_error (bfd_error_bad_value
);
2048 /* Check that the YZ field is right. Subtract the size of
2049 this LOP_END in the calculation; YZ does not include
2051 if ((long) (y
* 256 + z
) * 4 != (curpos
- stab_loc
) - 4)
2054 /* xgettext:c-format */
2055 (_("%pB: invalid mmo file: YZ of lop_end (%ld)"
2056 " not equal to the number of tetras to the preceding"
2057 " lop_stab (%ld)\n"),
2058 abfd
, (long) (y
* 256 + z
),
2059 (long) (curpos
- stab_loc
- 4)/4);
2060 bfd_set_error (bfd_error_bad_value
);
2064 bfd_map_over_sections (abfd
, mmo_map_set_sizes
, NULL
);
2071 /* This wasn't a lopcode, so store it in the current section. */
2073 sec
= bfd_make_section_old_way (abfd
, MMO_TEXT_SECTION_NAME
);
2074 if (!mmo_xore_32 (sec
, vma
& ~3, bfd_get_32 (abfd
, buf
)))
2076 bfd_set_error (bfd_error_bad_value
);
2085 /* We know this file is a multiple of four bytes (checked in
2086 mmo_object_p), so if we got something other than 0, this was a bad
2087 file (although it's more likely we'll get 0 in that case too).
2088 If we got end-of-file, then there was no lop_stab, so the file has
2091 if (nbytes_read
!= 0)
2092 bfd_set_error (bfd_error_system_call
);
2094 bfd_set_error (bfd_error_bad_value
);
2099 /* Mark the .text and .data section with their normal attribute if they
2100 contain anything. This is not redundant wrt. mmo_decide_section,
2101 since that code might never execute, and conversely the alloc+code
2102 section flags must be set then. */
2103 sec
= bfd_get_section_by_name (abfd
, MMO_TEXT_SECTION_NAME
);
2105 && (bfd_section_flags (sec
) & SEC_HAS_CONTENTS
)
2106 && !bfd_set_section_flags (sec
, (bfd_section_flags (sec
)
2107 | SEC_ALLOC
| SEC_LOAD
| SEC_CODE
)))
2110 sec
= bfd_get_section_by_name (abfd
, MMO_DATA_SECTION_NAME
);
2112 && (bfd_section_flags (sec
) & SEC_HAS_CONTENTS
)
2113 && !bfd_set_section_flags (sec
, (bfd_section_flags (sec
)
2114 | SEC_ALLOC
| SEC_LOAD
| SEC_DATA
)))
2117 /* Free whatever resources we took. */
2118 for (i
= 0; i
< sizeof (file_names
) / sizeof (file_names
[0]); i
++)
2119 free (file_names
[i
]);
2123 /* A hook to set up object file dependent section information. For mmo,
2124 we point out the shape of allocated section contents. */
2127 mmo_new_section_hook (bfd
*abfd
, asection
*newsect
)
2129 if (!newsect
->used_by_bfd
)
2131 /* We zero-fill all fields and assume NULL is represented by an all
2132 zero-bit pattern. */
2133 newsect
->used_by_bfd
2134 = bfd_zalloc (abfd
, sizeof (struct mmo_section_data_struct
));
2135 if (!newsect
->used_by_bfd
)
2139 /* Always align to at least 32-bit words. */
2140 newsect
->alignment_power
= 2;
2141 return _bfd_generic_new_section_hook (abfd
, newsect
);
2144 /* We already have section contents loaded for sections that have
2148 mmo_get_section_contents (bfd
*abfd ATTRIBUTE_UNUSED
,
2152 bfd_size_type bytes_to_do
)
2154 /* Iterate over diminishing chunk sizes, copying contents, like
2155 mmo_set_section_contents. */
2158 /* A minor song-and-dance to make sure we're not bitten by the
2159 distant possibility of the cast from bfd_vma to int making the
2160 chunk zero-sized. */
2162 = (int) bytes_to_do
!= 0 ? bytes_to_do
: MMO_SEC_CONTENTS_CHUNK_SIZE
;
2166 loc
= mmo_get_loc (sec
, sec
->vma
+ offset
, chunk_size
);
2167 while (loc
== NULL
&& (chunk_size
/= 2) != 0);
2169 if (chunk_size
== 0)
2172 memcpy (location
, loc
, chunk_size
);
2174 location
= (bfd_byte
*) location
+ chunk_size
;
2175 bytes_to_do
-= chunk_size
;
2176 offset
+= chunk_size
;
2181 /* Return the amount of memory needed to read the symbol table. */
2184 mmo_get_symtab_upper_bound (bfd
*abfd
)
2186 return (abfd
->symcount
+ 1) * sizeof (asymbol
*);
2189 /* Sort mmo symbols by serial number. */
2192 mmo_sort_mmo_symbols (const void *arg1
, const void *arg2
)
2194 const struct mmo_symbol
*sym1
= *(const struct mmo_symbol
**) arg1
;
2195 const struct mmo_symbol
*sym2
= *(const struct mmo_symbol
**) arg2
;
2197 /* Sort by serial number first. */
2198 if (sym1
->serno
< sym2
->serno
)
2200 else if (sym1
->serno
> sym2
->serno
)
2203 /* Then sort by address of the table entries. */
2204 return ((const char *) arg1
- (const char *) arg2
);
2207 /* Translate the symbol table. */
2210 mmo_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
2212 unsigned int symcount
= bfd_get_symcount (abfd
);
2216 csymbols
= abfd
->tdata
.mmo_data
->csymbols
;
2217 if (csymbols
== NULL
&& symcount
!= 0)
2220 struct mmo_symbol
*s
;
2221 struct mmo_symbol
**msp
;
2223 /* First we store the symbols into the table we'll return, then we
2224 qsort it on the serial number, with secondary on the address of
2225 the symbol, to preserve order if there would be non-unique serial
2227 for (s
= abfd
->tdata
.mmo_data
->symbols
,
2228 msp
= (struct mmo_symbol
**) alocation
;
2235 qsort (alocation
, symcount
, sizeof (struct mmo_symbol
*),
2236 mmo_sort_mmo_symbols
);
2238 csymbols
= (asymbol
*) bfd_alloc (abfd
, symcount
* sizeof (asymbol
));
2239 if (csymbols
== NULL
)
2241 abfd
->tdata
.mmo_data
->csymbols
= csymbols
;
2243 for (msp
= (struct mmo_symbol
**) alocation
, c
= csymbols
;
2250 c
->value
= s
->value
;
2251 c
->flags
= BSF_GLOBAL
;
2253 if (s
->sym_type
== mmo_data_sym
)
2256 = bfd_get_section_by_name (abfd
, MMO_DATA_SECTION_NAME
);
2258 if (c
->section
== NULL
)
2259 c
->section
= bfd_abs_section_ptr
;
2261 c
->value
-= c
->section
->vma
;
2263 else if (s
->sym_type
== mmo_undef_sym
)
2264 c
->section
= bfd_und_section_ptr
;
2265 else if (s
->sym_type
== mmo_reg_sym
)
2268 = bfd_make_section_old_way (abfd
, MMIX_REG_SECTION_NAME
);
2269 c
->section
->flags
|= SEC_LINKER_CREATED
;
2274 = bfd_get_section_by_name (abfd
, MMO_TEXT_SECTION_NAME
);
2278 && c
->value
>= textsec
->vma
2279 && c
->value
<= textsec
->vma
+ textsec
->size
)
2281 c
->section
= textsec
;
2282 c
->value
-= c
->section
->vma
;
2284 /* In mmo, symbol types depend on the VMA. Therefore, if
2285 the data section isn't within the usual bounds, its
2286 symbols are marked as absolute. Correct that. This
2287 means we can't have absolute symbols with values matching
2288 data section addresses, but we also can't have with
2289 absolute symbols with values matching text section
2290 addresses. For such needs, use the ELF format. */
2292 = bfd_get_section_by_name (abfd
,
2293 MMO_DATA_SECTION_NAME
))
2295 && c
->value
>= datasec
->vma
2296 && c
->value
<= datasec
->vma
+ datasec
->size
)
2298 c
->section
= datasec
;
2299 c
->value
-= c
->section
->vma
;
2302 c
->section
= bfd_abs_section_ptr
;
2309 /* Last, overwrite the incoming table with the right-type entries. */
2310 for (i
= 0; i
< symcount
; i
++)
2311 *alocation
++ = csymbols
++;
2317 /* Get information about a symbol. */
2320 mmo_get_symbol_info (bfd
*ignore_abfd ATTRIBUTE_UNUSED
,
2321 asymbol
*symbol
, symbol_info
*ret
)
2323 bfd_symbol_info (symbol
, ret
);
2327 mmo_print_symbol (bfd
*abfd
, void *afile
, asymbol
*symbol
,
2328 bfd_print_symbol_type how
)
2330 FILE *file
= (FILE *) afile
;
2334 case bfd_print_symbol_name
:
2335 fprintf (file
, "%s", symbol
->name
);
2338 bfd_print_symbol_vandf (abfd
, file
, symbol
);
2340 fprintf (file
, " %-5s %s",
2341 symbol
->section
->name
,
2346 /* We can't map a file directly into executable code, so the
2347 size of header information is irrelevant. */
2350 mmo_sizeof_headers (bfd
*abfd ATTRIBUTE_UNUSED
,
2351 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
2356 /* Write the (section-neutral) file preamble. */
2359 mmo_internal_write_header (bfd
*abfd
)
2361 const char lop_pre_bfd
[] = { LOP
, LOP_PRE
, 1, 1};
2363 if (bfd_bwrite (lop_pre_bfd
, 4, abfd
) != 4)
2366 /* Copy creation time of original file. */
2367 if (bfd_bwrite (abfd
->tdata
.mmo_data
->created
, 4, abfd
) != 4)
2373 /* Write the LOP_POST record, with global register initializations.
2374 Z is the Z field of the LOP_POST, corresponding to 255 - number of
2375 registers at DATA. The Z = 255 field is filled in with the
2379 mmo_internal_write_post (bfd
*abfd
, int z
, asection
*sec
)
2383 mmo_write_tetra_raw (abfd
, (LOP
<< 24) | (LOP_POST
<< 16) | z
);
2385 for (i
= z
; i
< 255; i
++)
2387 bfd_byte
*data
= mmo_get_loc (sec
, i
* 8, 8);
2389 if (bfd_bwrite (data
, 8, abfd
) != 8)
2393 /* For Z == $255, we always emit the start location; supposedly Main,
2394 but we have it handy at bfd_get_start_address. If we're called with
2395 Z == 255, don't assume DATA is valid. */
2396 bfd_put_64 (abfd
, bfd_get_start_address (abfd
), buf
);
2398 return ! abfd
->tdata
.mmo_data
->have_error
&& bfd_bwrite (buf
, 8, abfd
) == 8;
2401 /* Translate to and from BFD flags. This is to make sure that we don't
2402 get bitten by BFD flag number changes. */
2405 mmo_sec_flags_from_bfd_flags (flagword flags
)
2407 flagword oflags
= 0;
2409 if (flags
& SEC_ALLOC
)
2410 oflags
|= MMO_SEC_ALLOC
;
2411 if (flags
& SEC_LOAD
)
2412 oflags
|= MMO_SEC_LOAD
;
2413 if (flags
& SEC_RELOC
)
2414 oflags
|= MMO_SEC_RELOC
;
2415 if (flags
& SEC_READONLY
)
2416 oflags
|= MMO_SEC_READONLY
;
2417 if (flags
& SEC_CODE
)
2418 oflags
|= MMO_SEC_CODE
;
2419 if (flags
& SEC_DATA
)
2420 oflags
|= MMO_SEC_DATA
;
2421 if (flags
& SEC_NEVER_LOAD
)
2422 oflags
|= MMO_SEC_NEVER_LOAD
;
2423 if (flags
& SEC_IS_COMMON
)
2424 oflags
|= MMO_SEC_IS_COMMON
;
2425 if (flags
& SEC_DEBUGGING
)
2426 oflags
|= MMO_SEC_DEBUGGING
;
2432 bfd_sec_flags_from_mmo_flags (flagword flags
)
2434 flagword oflags
= 0;
2436 if (flags
& MMO_SEC_ALLOC
)
2437 oflags
|= SEC_ALLOC
;
2438 if (flags
& MMO_SEC_LOAD
)
2440 if (flags
& MMO_SEC_RELOC
)
2441 oflags
|= SEC_RELOC
;
2442 if (flags
& MMO_SEC_READONLY
)
2443 oflags
|= SEC_READONLY
;
2444 if (flags
& MMO_SEC_CODE
)
2446 if (flags
& MMO_SEC_DATA
)
2448 if (flags
& MMO_SEC_NEVER_LOAD
)
2449 oflags
|= SEC_NEVER_LOAD
;
2450 if (flags
& MMO_SEC_IS_COMMON
)
2451 oflags
|= SEC_IS_COMMON
;
2452 if (flags
& MMO_SEC_DEBUGGING
)
2453 oflags
|= SEC_DEBUGGING
;
2458 /* Return TRUE iff the leading or trailing tetrabyte in SEC is defined and
2462 mmo_has_leading_or_trailing_zero_tetra_p (bfd
*abfd
, asection
*sec
)
2464 bfd_vma secaddr
= bfd_section_vma (sec
);
2469 if (bfd_get_32 (abfd
, mmo_get_loc (sec
, secaddr
, 4)) == 0
2470 && bfd_get_32 (abfd
,
2471 mmo_get_loc (sec
, secaddr
+ sec
->size
- 4, 4)) == 0)
2477 /* Write a section. */
2480 mmo_internal_write_section (bfd
*abfd
, asection
*sec
)
2482 /* We do it differently depending on what section this is:
2484 ".text": Output, prepended by information about the first source file
2485 (not yet implemented.)
2489 (".MMIX.reg_contents": Not handled here.)
2491 Anything else: Output inside a lop_spec 80, in the format described
2494 if (strcmp (sec
->name
, MMO_TEXT_SECTION_NAME
) == 0)
2496 bfd_vma secaddr
= bfd_section_vma (sec
);
2498 /* Because leading and trailing zeros are omitted in output, we need to
2499 specify the section boundaries so they're correct when the file
2500 is read in again. That's also the case if this section is
2501 specified as not within its usual boundaries or alignments. */
2503 && (secaddr
+ sec
->size
>= (bfd_vma
) 1 << 56
2504 || (secaddr
& 3) != 0
2505 || (sec
->size
& 3) != 0
2506 || mmo_has_leading_or_trailing_zero_tetra_p (abfd
, sec
)))
2508 if (!mmo_write_section_description (abfd
, sec
))
2512 /* FIXME: Output source file name and line number. */
2513 return mmo_write_loc_chunk_list (abfd
, mmo_section_data (sec
)->head
);
2515 else if (strcmp (sec
->name
, MMO_DATA_SECTION_NAME
) == 0)
2517 bfd_vma secaddr
= bfd_section_vma (sec
);
2519 /* Same goes as for MMO_TEXT_SECTION_NAME above. */
2521 && (secaddr
< (bfd_vma
) 0x20 << 56
2522 || secaddr
+ sec
->size
>= (bfd_vma
) 0x21 << 56
2523 || (secaddr
& 3) != 0
2524 || (sec
->size
& 3) != 0
2525 || mmo_has_leading_or_trailing_zero_tetra_p (abfd
, sec
)))
2527 if (!mmo_write_section_description (abfd
, sec
))
2531 return mmo_write_loc_chunk_list (abfd
, mmo_section_data (sec
)->head
);
2533 else if (strcmp (sec
->name
, MMIX_REG_CONTENTS_SECTION_NAME
) == 0)
2534 /* Not handled here. */
2536 /* This would normally be an abort call since this can't happen, but
2537 we don't do that. */
2538 bfd_set_error (bfd_error_bad_value
);
2541 else if (startswith (sec
->name
, MMIX_OTHER_SPEC_SECTION_PREFIX
))
2543 int n
= atoi (sec
->name
+ strlen (MMIX_OTHER_SPEC_SECTION_PREFIX
));
2545 mmo_write_tetra_raw (abfd
, (LOP
<< 24) | (LOP_SPEC
<< 16) | n
);
2546 return (! abfd
->tdata
.mmo_data
->have_error
2547 && mmo_write_chunk_list (abfd
, mmo_section_data (sec
)->head
));
2549 /* Ignore sections that are just allocated or empty; we write out
2551 else if ((bfd_section_flags (sec
) & SEC_HAS_CONTENTS
) != 0
2554 if (!mmo_write_section_description (abfd
, sec
))
2557 /* Writing a LOP_LOC ends the LOP_SPEC data, and makes data actually
2559 if (bfd_section_flags (sec
) & SEC_LOAD
)
2560 return (! abfd
->tdata
.mmo_data
->have_error
2561 && mmo_write_loc_chunk_list (abfd
,
2562 mmo_section_data (sec
)->head
));
2563 return (! abfd
->tdata
.mmo_data
->have_error
2564 && mmo_write_chunk_list (abfd
, mmo_section_data (sec
)->head
));
2567 /* Some section without contents. */
2571 /* Write the description of a section, extended-mmo-style. */
2574 mmo_write_section_description (bfd
*abfd
, asection
*sec
)
2576 /* Keep the following document-comment formatted the way it is. */
2579 mmo section mapping, , Symbol-table, mmo
2583 The implementation in BFD uses special data type 80 (decimal) to
2584 encapsulate and describe named sections, containing e.g.@: debug
2585 information. If needed, any datum in the encapsulation will be
2586 quoted using lop_quote. First comes a 32-bit word holding the
2587 number of 32-bit words containing the zero-terminated zero-padded
2588 segment name. After the name there's a 32-bit word holding flags
2589 describing the section type. Then comes a 64-bit big-endian word
2590 with the section length (in bytes), then another with the section
2591 start address. Depending on the type of section, the contents
2592 might follow, zero-padded to 32-bit boundary. For a loadable
2593 section (such as data or code), the contents might follow at some
2594 later point, not necessarily immediately, as a lop_loc with the
2595 same start address as in the section description, followed by the
2596 contents. This in effect forms a descriptor that must be emitted
2597 before the actual contents. Sections described this way must not
2600 For areas that don't have such descriptors, synthetic sections are
2601 formed by BFD. Consecutive contents in the two memory areas
2602 @samp{0x0000@dots{}00} to @samp{0x01ff@dots{}ff} and
2603 @samp{0x2000@dots{}00} to @samp{0x20ff@dots{}ff} are entered in
2604 sections named <<.text>> and <<.data>> respectively. If an area
2605 is not otherwise described, but would together with a neighboring
2606 lower area be less than @samp{0x40000000} bytes long, it is joined
2607 with the lower area and the gap is zero-filled. For other cases,
2608 a new section is formed, named <<.MMIX.sec.@var{n}>>. Here,
2609 @var{n} is a number, a running count through the mmo file,
2613 A loadable section specified as:
2615 | .section secname,"ax"
2616 | TETRA 1,2,3,4,-1,-2009
2619 and linked to address @samp{0x4}, is represented by the sequence:
2621 | 0x98080050 - lop_spec 80
2622 | 0x00000002 - two 32-bit words for the section name
2623 | 0x7365636e - "secn"
2624 | 0x616d6500 - "ame\0"
2625 | 0x00000033 - flags CODE, READONLY, LOAD, ALLOC
2626 | 0x00000000 - high 32 bits of section length
2627 | 0x0000001c - section length is 28 bytes; 6 * 4 + 1 + alignment to 32 bits
2628 | 0x00000000 - high 32 bits of section address
2629 | 0x00000004 - section address is 4
2630 | 0x98010002 - 64 bits with address of following data
2631 | 0x00000000 - high 32 bits of address
2632 | 0x00000004 - low 32 bits: data starts at address 4
2638 | 0xfffff827 - -2009
2639 | 0x50000000 - 80 as a byte, padded with zeros.
2641 Note that the lop_spec wrapping does not include the section
2642 contents. Compare this to a non-loaded section specified as:
2645 | TETRA 200001,100002
2648 This, when linked to address @samp{0x200000000000001c}, is
2651 | 0x98080050 - lop_spec 80
2652 | 0x00000002 - two 32-bit words for the section name
2653 | 0x7365636e - "thir"
2654 | 0x616d6500 - "dsec"
2655 | 0x00000010 - flag READONLY
2656 | 0x00000000 - high 32 bits of section length
2657 | 0x0000000c - section length is 12 bytes; 2 * 4 + 2 + alignment to 32 bits
2658 | 0x20000000 - high 32 bits of address
2659 | 0x0000001c - low 32 bits of address 0x200000000000001c
2660 | 0x00030d41 - 200001
2661 | 0x000186a2 - 100002
2662 | 0x26280000 - 38, 40 as bytes, padded with zeros
2664 For the latter example, the section contents must not be
2665 loaded in memory, and is therefore specified as part of the
2666 special data. The address is usually unimportant but might
2667 provide information for e.g.@: the DWARF 2 debugging format. */
2669 mmo_write_tetra_raw (abfd
, LOP_SPEC_SECTION
);
2670 mmo_write_tetra (abfd
, (strlen (sec
->name
) + 3) / 4);
2671 mmo_write_chunk (abfd
, (bfd_byte
*) sec
->name
, strlen (sec
->name
));
2672 mmo_flush_chunk (abfd
);
2673 /* FIXME: We can get debug sections (.debug_line & Co.) with a section
2674 flag still having SEC_RELOC set. Investigate. This might be true
2675 for all alien sections; perhaps mmo.em should clear that flag. Might
2676 be related to weak references. */
2677 mmo_write_tetra (abfd
,
2678 mmo_sec_flags_from_bfd_flags (bfd_section_flags (sec
)));
2679 mmo_write_octa (abfd
, sec
->size
);
2680 mmo_write_octa (abfd
, bfd_section_vma (sec
));
2684 /* We save up all data before output. */
2687 mmo_set_section_contents (bfd
*abfd ATTRIBUTE_UNUSED
, sec_ptr sec
,
2688 const void *location
, file_ptr offset
,
2689 bfd_size_type bytes_to_do
)
2691 /* Iterate over diminishing chunk sizes, copying contents. */
2694 /* A minor song-and-dance to make sure we're not bitten by the
2695 distant possibility of the cast from bfd_vma to int making the
2696 chunk zero-sized. */
2698 = (int) bytes_to_do
!= 0 ? bytes_to_do
: MMO_SEC_CONTENTS_CHUNK_SIZE
;
2702 loc
= mmo_get_loc (sec
, sec
->vma
+ offset
, chunk_size
);
2703 while (loc
== NULL
&& (chunk_size
/= 2) != 0);
2705 if (chunk_size
== 0)
2708 memcpy (loc
, location
, chunk_size
);
2710 location
= (bfd_byte
*) location
+ chunk_size
;
2711 bytes_to_do
-= chunk_size
;
2712 offset
+= chunk_size
;
2717 /* Add a symbol to a trie-tree. */
2720 mmo_internal_add_3_sym (bfd
*abfd
, struct mmo_symbol_trie
*rootp
,
2721 const struct mmo_symbol
*symp
)
2723 const char *name
= symp
->name
;
2724 struct mmo_symbol_trie
*trie
= rootp
;
2725 struct mmo_symbol_trie
**triep
= NULL
;
2727 while (*name
&& trie
!= NULL
)
2729 if (*name
< trie
->symchar
)
2731 triep
= &trie
->left
;
2734 else if (*name
> trie
->symchar
)
2736 triep
= &trie
->right
;
2739 else if (*name
== trie
->symchar
)
2741 triep
= &trie
->middle
;
2744 /* Make sure "trie" points to where we should fill in the
2745 current symbol whenever we've iterated through "name". We
2746 would lose the right position if we encounter "foobar" then
2749 trie
= trie
->middle
;
2755 /* Create middle branches for the rest of the characters. */
2756 trie
= bfd_zalloc (abfd
, sizeof (struct mmo_symbol_trie
));
2758 trie
->symchar
= *name
++;
2759 triep
= &trie
->middle
;
2762 /* We discover a duplicate symbol rather late in the process, but still;
2763 we discover it and bail out. */
2764 if (trie
->sym
.name
!= NULL
)
2767 /* xgettext:c-format */
2768 (_("%pB: invalid symbol table: duplicate symbol `%s'\n"),
2769 abfd
, trie
->sym
.name
);
2770 bfd_set_error (bfd_error_bad_value
);
2774 memcpy (&trie
->sym
, symp
, sizeof *symp
);
2778 /* Find out the length of the serialized version of a trie in bytes. */
2781 mmo_internal_3_length (bfd
*abfd
, struct mmo_symbol_trie
*trie
)
2783 /* First, one for the control byte. */
2784 unsigned int length
= 1;
2789 /* Add in the recursion to the left. */
2790 length
+= mmo_internal_3_length (abfd
, trie
->left
);
2792 /* Add in the middle trie and the character. */
2793 length
+= 1 + mmo_internal_3_length (abfd
, trie
->middle
);
2795 /* Add in the recursion to the right. */
2796 length
+= mmo_internal_3_length (abfd
, trie
->right
);
2798 /* Add in bytes for the symbol (if this is an endnode). */
2799 if (trie
->sym
.name
!= NULL
)
2801 unsigned int serno
= trie
->sym
.serno
;
2803 /* First what it takes to encode the value. */
2804 if (trie
->sym
.sym_type
== mmo_reg_sym
)
2806 else if (trie
->sym
.sym_type
== mmo_undef_sym
)
2810 bfd_vma value
= trie
->sym
.value
;
2812 /* Coded in one to eight following bytes. */
2813 if (trie
->sym
.sym_type
== mmo_data_sym
)
2814 value
-= (bfd_vma
) 0x20 << 56;
2824 /* Find out what it takes to encode the serial number. */
2836 /* Helper function for outputting the serial number of a symbol, output as
2837 a variant of leb128 (see dwarf2 documentation) which could be called
2838 beb128. Using a helper function and recursion simplifies debugging. */
2841 mmo_beb128_out (bfd
*abfd
, int serno
, int marker
)
2844 mmo_beb128_out (abfd
, serno
>> 7, 0);
2845 mmo_write_byte (abfd
, marker
| (serno
& 0x7f));
2848 /* Serialize a trie. */
2851 mmo_internal_3_dump (bfd
*abfd
, struct mmo_symbol_trie
*trie
)
2853 bfd_byte control
= 0;
2859 control
|= MMO3_LEFT
;
2862 control
|= MMO3_MIDDLE
;
2865 control
|= MMO3_RIGHT
;
2867 if (trie
->sym
.name
!= NULL
)
2869 /* Encode the symbol type and length of value bytes. */
2870 if (trie
->sym
.sym_type
== mmo_reg_sym
)
2871 control
|= MMO3_REGQUAL_BITS
;
2872 else if (trie
->sym
.sym_type
== mmo_undef_sym
)
2873 control
|= MMO3_UNDEF
;
2876 bfd_vma value
= trie
->sym
.value
;
2878 /* Coded in 1..8 following bytes. */
2879 if (trie
->sym
.sym_type
== mmo_data_sym
)
2881 control
|= MMO3_DATA
;
2882 value
-= (bfd_vma
) 0x20 << 56;
2894 /* The control byte is output before recursing. */
2895 mmo_write_byte (abfd
, control
);
2897 mmo_internal_3_dump (abfd
, trie
->left
);
2899 if (control
& MMO3_SYMBITS
)
2901 mmo_write_byte (abfd
, trie
->symchar
);
2903 if (trie
->sym
.name
!= NULL
)
2905 if (trie
->sym
.sym_type
== mmo_reg_sym
)
2906 mmo_write_byte (abfd
, trie
->sym
.value
);
2907 else if (trie
->sym
.sym_type
== mmo_undef_sym
)
2909 mmo_write_byte (abfd
, 0);
2910 mmo_write_byte (abfd
, 0);
2914 bfd_vma value
= trie
->sym
.value
;
2916 bfd_byte byte_n
= control
& 15;
2918 /* Coded in 1..8 following bytes. Note that the value is
2919 shifted out big-endian. */
2920 if (trie
->sym
.sym_type
== mmo_data_sym
)
2922 value
-= (bfd_vma
) 0x20 << 56;
2928 mmo_write_byte (abfd
, (value
>> ((byte_n
- 1) * 8)) & 0xff);
2931 while (byte_n
!= 0);
2934 mmo_beb128_out (abfd
, trie
->sym
.serno
, 128);
2936 mmo_internal_3_dump (abfd
, trie
->middle
);
2938 mmo_internal_3_dump (abfd
, trie
->right
);
2941 /* Write symbols in mmo format. Also write the lop_end terminator. */
2944 mmo_write_symbols_and_terminator (bfd
*abfd
)
2946 int count
= bfd_get_symcount (abfd
);
2948 asymbol
**orig_table
= bfd_get_outsymbols (abfd
);
2950 struct mmo_symbol_trie root
;
2955 /* Create a symbol for "Main". */
2956 asymbol
*fakemain
= bfd_make_empty_symbol (abfd
);
2958 fakemain
->flags
= BSF_GLOBAL
;
2959 fakemain
->value
= bfd_get_start_address (abfd
);
2960 fakemain
->name
= MMIX_START_SYMBOL_NAME
;
2961 fakemain
->section
= bfd_abs_section_ptr
;
2963 memset (&root
, 0, sizeof (root
));
2965 /* Make all symbols take a left turn. */
2966 root
.symchar
= 0xff;
2968 /* There must always be a ":Main", so we'll add one if there are no
2969 symbols. Make sure we have room for it. */
2970 table
= bfd_alloc (abfd
, (count
+ 1) * sizeof (asymbol
*));
2975 memcpy (table
, orig_table
, count
* sizeof (asymbol
*));
2977 /* Move :Main (if there is one) to the first position. This is
2978 necessary to get the same layout of the trie-tree when linking as
2979 when objcopying the result as in the objcopy.exp test "simple objcopy
2980 of executable". It also automatically takes care of assigning serial
2981 number 1 to :Main (as is mandatory). */
2982 for (i
= 0; i
< count
; i
++)
2983 if (table
[i
] != NULL
2984 && strcmp (table
[i
]->name
, MMIX_START_SYMBOL_NAME
) == 0
2985 && (table
[i
]->flags
& (BSF_DEBUGGING
|BSF_GLOBAL
)) == BSF_GLOBAL
)
2987 asymbol
*mainsym
= table
[i
];
2990 + mainsym
->section
->output_section
->vma
2991 + mainsym
->section
->output_offset
);
2992 memcpy (table
+ 1, orig_table
, i
* sizeof (asymbol
*));
2995 /* Check that the value assigned to :Main is the same as the entry
2996 address. The default linker script asserts this. This is as
2997 good a place as any to check this consistency. */
2998 if (mainvalue
!= bfd_get_start_address (abfd
)
2999 && !mmo_ignore_symbol_consistency (abfd
))
3001 /* Arbitrary buffer to hold the printable representation of a
3004 char vmas_start
[40];
3005 bfd_vma vma_start
= bfd_get_start_address (abfd
);
3007 sprintf_vma (vmas_main
, mainvalue
);
3008 sprintf_vma (vmas_start
, vma_start
);
3011 /* xgettext:c-format */
3012 (_("%pB: bad symbol definition: `Main' set to %s rather"
3013 " than the start address %s\n"),
3014 abfd
, vmas_main
, vmas_start
);
3015 bfd_set_error (bfd_error_bad_value
);
3020 if (i
== count
&& count
!= 0)
3022 /* When there are symbols, there must be a :Main. There was no
3023 :Main, so we need to add it manually. */
3024 memcpy (table
+ 1, orig_table
, count
* sizeof (asymbol
*));
3025 table
[0] = fakemain
;
3029 /* Don't bother inspecting symbols in plugin dummy objects; their
3030 symbols aren't fully inspectable. */
3031 if ((abfd
->flags
& BFD_PLUGIN
) == 0)
3033 for (i
= 0, serno
= 1; i
< count
&& table
[i
] != NULL
; i
++)
3035 asymbol
*s
= table
[i
];
3037 /* It's not enough to consult bfd_is_local_label, since it does not
3038 mean "local" in the sense of linkable-and-observable-after-link.
3039 Let's just check the BSF_GLOBAL flag.
3041 Also, don't export symbols with characters not in the
3043 if ((s
->flags
& (BSF_DEBUGGING
|BSF_GLOBAL
)) == BSF_GLOBAL
3045 valid_mmo_symbol_character_set
) == strlen (s
->name
))
3047 struct mmo_symbol sym
;
3048 memset (&sym
, 0, sizeof (sym
));
3050 /* Need to strip const here; strdup:ing would leak and the
3051 existing string must be safe to reuse. */
3052 sym
.name
= (char *) s
->name
;
3055 + s
->section
->output_section
->vma
3056 + s
->section
->output_offset
;
3058 if (bfd_is_und_section (s
->section
))
3059 sym
.sym_type
= mmo_undef_sym
;
3060 else if (strcmp (s
->section
->name
, MMO_DATA_SECTION_NAME
) == 0
3061 /* The encoding of data symbols require that the "rest"
3062 of the value fits in 6 bytes, so the upper two bytes
3063 must be 0x2000. All other symbols get to be the
3065 && (sym
.value
>> 48) == 0x2000)
3066 sym
.sym_type
= mmo_data_sym
;
3067 else if (strcmp (s
->section
->name
, MMIX_REG_SECTION_NAME
) == 0)
3068 sym
.sym_type
= mmo_reg_sym
;
3069 else if (strcmp (s
->section
->name
,
3070 MMIX_REG_CONTENTS_SECTION_NAME
) == 0)
3072 sym
.sym_type
= mmo_reg_sym
;
3076 sym
.sym_type
= mmo_abs_sym
;
3078 /* FIXME: We assume the order of the received symbols is an
3079 ordered mapping of the serial numbers. This is not
3080 necessarily true if we e.g. objcopy a mmo file to another and
3081 there are gaps in the numbering. Not sure if this can
3082 happen. Not sure what to do. */
3083 sym
.serno
= serno
++;
3085 if (! mmo_internal_add_3_sym (abfd
, &root
, &sym
))
3091 /* Change the root node to be a ":"-prefix. */
3093 root
.middle
= root
.left
;
3097 /* We have to find out if we can fit the whole symbol table in the mmo
3098 symtab. It would be bad to assume we can always fit it in 262144
3099 bytes. If we can't, just leave the Main symbol. */
3100 trie_len
= (mmo_internal_3_length (abfd
, &root
) + 3)/4;
3102 if (trie_len
> 0xffff)
3104 /* Test this code by using a lower limit in the test above and check
3105 that the single "Main" symbol is emitted and handled properly.
3106 There's no specific test-case. */
3107 struct mmo_symbol sym
;
3110 /* xgettext:c-format */
3111 (_("%pB: warning: symbol table too large for mmo, larger than 65535"
3112 " 32-bit words: %d. Only `Main' will be emitted.\n"),
3115 memset (&sym
, 0, sizeof (sym
));
3116 sym
.sym_type
= mmo_abs_sym
;
3117 sym
.name
= MMIX_START_SYMBOL_NAME
;
3119 sym
.value
= bfd_get_start_address (abfd
);
3121 /* Then patch up a symbol table to be just the ":Main" symbol. */
3122 memset (&root
, 0, sizeof (root
));
3123 root
.left
= root
.middle
;
3124 root
.symchar
= 0xff;
3128 if (! mmo_internal_add_3_sym (abfd
, &root
, &sym
))
3132 root
.middle
= root
.left
;
3136 trie_len
= (mmo_internal_3_length (abfd
, &root
) + 3)/4;
3139 /* Reset the written-bytes counter. */
3140 abfd
->tdata
.mmo_data
->byte_no
= 0;
3142 /* Put out the lop_stab mark. */
3143 bfd_put_32 (abfd
, (LOP
<< 24) | (LOP_STAB
<< 16), buf
);
3144 if (bfd_bwrite (buf
, 4, abfd
) != 4)
3147 /* Dump out symbols. */
3148 mmo_internal_3_dump (abfd
, &root
);
3150 if (trie_len
!= (abfd
->tdata
.mmo_data
->byte_no
+ 3)/4)
3152 /* I haven't seen this trig. It seems no use claiming this case
3153 isn't debugged and abort if we get here. Instead emit a
3154 diagnostic and fail "normally". */
3156 /* xgettext:c-format */
3157 (_("%pB: internal error, symbol table changed size from %d to %d"
3160 (abfd
->tdata
.mmo_data
->byte_no
+ 3)/4);
3161 bfd_set_error (bfd_error_bad_value
);
3165 /* Dump out remaining bytes in the buffer and handle I/O errors by
3166 propagating errors. */
3167 if ((abfd
->tdata
.mmo_data
->byte_no
% 4) != 0
3168 || abfd
->tdata
.mmo_data
->have_error
)
3170 memset (abfd
->tdata
.mmo_data
->buf
+ (abfd
->tdata
.mmo_data
->byte_no
% 4),
3171 0, 4 - (abfd
->tdata
.mmo_data
->byte_no
% 4));
3173 if (abfd
->tdata
.mmo_data
->have_error
3174 || bfd_bwrite (abfd
->tdata
.mmo_data
->buf
, 4, abfd
) != 4)
3178 bfd_put_32 (abfd
, (LOP
<< 24) | (LOP_END
<< 16) | trie_len
, buf
);
3179 return bfd_bwrite (buf
, 4, abfd
) == 4;
3182 /* Write section unless it is the register contents section. For that, we
3183 instead store the section in the supplied pointer. This function is
3184 used through bfd_map_over_sections. */
3187 mmo_write_section_unless_reg_contents (bfd
*abfd
, asection
*sec
, void *p
)
3189 struct mmo_write_sec_info
*infop
= (struct mmo_write_sec_info
*) p
;
3191 if (! infop
->retval
)
3194 if (strcmp (sec
->name
, MMIX_REG_CONTENTS_SECTION_NAME
) == 0)
3196 infop
->reg_section
= sec
;
3200 /* Exclude the convenience register section. */
3201 if (strcmp (sec
->name
, MMIX_REG_SECTION_NAME
) == 0)
3203 if (bfd_section_flags (sec
) & SEC_HAS_CONTENTS
)
3205 /* Make sure it hasn't got contents. It seems impossible to
3206 make it carry contents, so we don't have a test-case for
3209 /* xgettext:c-format */
3210 (_("%pB: internal error, internal register section %pA had"
3213 bfd_set_error (bfd_error_bad_value
);
3214 infop
->retval
= false;
3221 infop
->retval
= mmo_internal_write_section (abfd
, sec
);
3224 /* Do the actual output of a file. Assumes mmo_set_section_contents is
3228 mmo_write_object_contents (bfd
*abfd
)
3230 struct mmo_write_sec_info wsecinfo
;
3232 /* First, there are a few words of preamble. */
3233 if (! mmo_internal_write_header (abfd
))
3236 wsecinfo
.reg_section
= NULL
;
3237 wsecinfo
.retval
= true;
3239 bfd_map_over_sections (abfd
, mmo_write_section_unless_reg_contents
,
3242 if (! wsecinfo
.retval
)
3245 if (wsecinfo
.reg_section
!= NULL
)
3247 asection
*sec
= wsecinfo
.reg_section
;
3248 unsigned int z
= (unsigned int) (sec
->vma
/ 8);
3250 /* Registers 0..31 must not be global. Do sanity check on the "vma"
3251 of the register contents section and check that it corresponds to
3252 the length of the section. */
3253 if (z
< 32 || z
>= 255 || (sec
->vma
& 7) != 0
3254 || sec
->vma
!= 256 * 8 - sec
->size
- 8)
3256 bfd_set_error (bfd_error_bad_value
);
3259 /* There must always be at least one such register. */
3261 (_("%pB: no initialized registers; section length 0\n"),
3263 else if (sec
->vma
> (256 - 32) * 8)
3264 /* Provide better error message for the case of too many
3265 global registers. */
3267 /* xgettext:c-format */
3268 (_("%pB: too many initialized registers; section length %" PRId64
),
3269 abfd
, (int64_t) sec
->size
);
3272 /* xgettext:c-format */
3273 (_("%pB: invalid start address for initialized registers of"
3274 " length %" PRId64
": %#" PRIx64
),
3275 abfd
, (int64_t) sec
->size
, (uint64_t) sec
->vma
);
3280 if (! mmo_internal_write_post (abfd
, z
, sec
))
3284 if (! mmo_internal_write_post (abfd
, 255, NULL
))
3287 return mmo_write_symbols_and_terminator (abfd
);
3290 /* If there's anything in particular in a mmo bfd that we want to free,
3291 make this a real function. Only do this if you see major memory
3292 thrashing; zealous free:ing will cause unwanted behavior, especially if
3293 you "free" memory allocated with "bfd_alloc", or even "bfd_release" a
3294 block allocated with "bfd_alloc"; they're really allocated from an
3295 obstack, and we don't know what was allocated there since this
3296 particular allocation. */
3298 #define mmo_close_and_cleanup _bfd_generic_close_and_cleanup
3299 #define mmo_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
3301 /* Perhaps we need to adjust this one; mmo labels (originally) without a
3302 leading ':' might more appropriately be called local. */
3303 #define mmo_bfd_is_local_label_name bfd_generic_is_local_label_name
3304 #define mmo_bfd_is_target_special_symbol _bfd_bool_bfd_asymbol_false
3306 #define mmo_get_symbol_version_string \
3307 _bfd_nosymbols_get_symbol_version_string
3309 /* Is this one really used or defined by anyone? */
3310 #define mmo_get_lineno _bfd_nosymbols_get_lineno
3312 /* FIXME: We can do better on this one, if we have a dwarf2 .debug_line
3313 section or if MMO line numbers are implemented. */
3314 #define mmo_find_nearest_line _bfd_nosymbols_find_nearest_line
3315 #define mmo_find_line _bfd_nosymbols_find_line
3316 #define mmo_find_inliner_info _bfd_nosymbols_find_inliner_info
3317 #define mmo_make_empty_symbol _bfd_generic_make_empty_symbol
3318 #define mmo_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
3319 #define mmo_read_minisymbols _bfd_generic_read_minisymbols
3320 #define mmo_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
3322 #define mmo_get_section_contents_in_window \
3323 _bfd_generic_get_section_contents_in_window
3324 #define mmo_bfd_get_relocated_section_contents \
3325 bfd_generic_get_relocated_section_contents
3326 #define mmo_bfd_gc_sections bfd_generic_gc_sections
3327 #define mmo_bfd_lookup_section_flags bfd_generic_lookup_section_flags
3328 #define mmo_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
3329 #define mmo_bfd_link_add_symbols _bfd_generic_link_add_symbols
3330 #define mmo_bfd_link_just_syms _bfd_generic_link_just_syms
3331 #define mmo_bfd_copy_link_hash_symbol_type \
3332 _bfd_generic_copy_link_hash_symbol_type
3333 #define mmo_bfd_final_link _bfd_generic_final_link
3334 #define mmo_bfd_link_split_section _bfd_generic_link_split_section
3335 #define mmo_bfd_link_check_relocs _bfd_generic_link_check_relocs
3337 /* Strictly speaking, only MMIX uses this restricted format, but let's not
3338 stop anybody from shooting themselves in the foot. */
3339 #define mmo_set_arch_mach bfd_default_set_arch_mach
3340 #define mmo_bfd_relax_section bfd_generic_relax_section
3341 #define mmo_bfd_merge_sections bfd_generic_merge_sections
3342 #define mmo_bfd_is_group_section bfd_generic_is_group_section
3343 #define mmo_bfd_group_name bfd_generic_group_name
3344 #define mmo_bfd_discard_group bfd_generic_discard_group
3345 #define mmo_section_already_linked \
3346 _bfd_generic_section_already_linked
3347 #define mmo_bfd_define_common_symbol bfd_generic_define_common_symbol
3348 #define mmo_bfd_link_hide_symbol _bfd_generic_link_hide_symbol
3349 #define mmo_bfd_define_start_stop bfd_generic_define_start_stop
3351 /* We want to copy time of creation, otherwise we'd use
3352 BFD_JUMP_TABLE_COPY (_bfd_generic). */
3353 #define mmo_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
3354 #define mmo_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
3355 #define mmo_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
3356 #define mmo_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
3357 #define mmo_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
3358 #define mmo_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
3360 const bfd_target mmix_mmo_vec
=
3363 bfd_target_mmo_flavour
,
3364 BFD_ENDIAN_BIG
, /* target byte order */
3365 BFD_ENDIAN_BIG
, /* target headers byte order */
3367 /* FIXME: Might need adjustments. */
3368 (HAS_RELOC
| EXEC_P
| /* object flags */
3369 HAS_LINENO
| HAS_DEBUG
|
3370 HAS_SYMS
| HAS_LOCALS
| WP_TEXT
),
3372 /* FIXME: Might need adjustments. */
3373 (SEC_CODE
| SEC_DATA
| SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
3374 | SEC_READONLY
| SEC_EXCLUDE
| SEC_DEBUGGING
| SEC_IN_MEMORY
),
3376 0, /* leading underscore */
3377 ' ', /* ar_pad_char */
3378 16, /* ar_max_namelen */
3379 0, /* match priority. */
3380 TARGET_KEEP_UNUSED_SECTION_SYMBOLS
, /* keep unused section symbols. */
3381 bfd_getb64
, bfd_getb_signed_64
, bfd_putb64
,
3382 bfd_getb32
, bfd_getb_signed_32
, bfd_putb32
,
3383 bfd_getb16
, bfd_getb_signed_16
, bfd_putb16
, /* data */
3384 bfd_getb64
, bfd_getb_signed_64
, bfd_putb64
,
3385 bfd_getb32
, bfd_getb_signed_32
, bfd_putb32
,
3386 bfd_getb16
, bfd_getb_signed_16
, bfd_putb16
, /* hdrs */
3390 mmo_object_p
, /* bfd_check_format */
3395 _bfd_bool_bfd_false_error
,
3397 _bfd_bool_bfd_false_error
,
3398 _bfd_bool_bfd_false_error
,
3400 { /* bfd_write_contents */
3401 _bfd_bool_bfd_false_error
,
3402 mmo_write_object_contents
,
3403 _bfd_bool_bfd_false_error
,
3404 _bfd_bool_bfd_false_error
,
3407 BFD_JUMP_TABLE_GENERIC (mmo
),
3408 BFD_JUMP_TABLE_COPY (mmo
),
3409 BFD_JUMP_TABLE_CORE (_bfd_nocore
),
3410 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive
),
3411 BFD_JUMP_TABLE_SYMBOLS (mmo
),
3412 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs
),
3413 BFD_JUMP_TABLE_WRITE (mmo
),
3414 BFD_JUMP_TABLE_LINK (mmo
),
3415 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic
),