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