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 const bfd_target *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 const bfd_target * 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 abfd->xvec; 560 561 bad_format_free: 562 free (abfd->tdata.mmo_data->lop_stab_symbol); 563 bad_format: 564 bfd_set_error (bfd_error_wrong_format); 565 bad_final: 566 return NULL; 567 } 568 569 /* Set up the mmo tdata information. */ 570 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 = bfd_make_section_old_way (abfd, MMO_TEXT_SECTION_NAME); 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 mmo_xore_32 (sec, vma, bfd_get_32 (abfd, buf)); 1650 vma += 4; 1651 lineno++; 1652 break; 1653 1654 case LOP_LOC: 1655 /* Set vma (and section). */ 1656 vma = (bfd_vma) y << 56; 1657 if (z == 1) 1658 { 1659 /* Get a 32-bit value. */ 1660 if (bfd_bread (buf, 4, abfd) != 4) 1661 goto error_return; 1662 1663 vma += bfd_get_32 (abfd, buf); 1664 } 1665 else if (z == 2) 1666 { 1667 /* Get a 64-bit value. */ 1668 if (bfd_bread (buf, 8, abfd) != 8) 1669 goto error_return; 1670 1671 vma += bfd_get_64 (abfd, buf); 1672 } 1673 else 1674 { 1675 _bfd_error_handler 1676 /* xgettext:c-format */ 1677 (_("%pB: invalid mmo file: expected z = 1 or z = 2," 1678 " got z = %d for lop_loc\n"), 1679 abfd, z); 1680 bfd_set_error (bfd_error_bad_value); 1681 goto error_return; 1682 } 1683 1684 /* When we decide which section the data goes into, we might 1685 create the section. If that happens, make sure the VMA at 1686 creation time is tetra-aligned. */ 1687 sec = mmo_decide_section (abfd, vma & ~3); 1688 if (sec == NULL) 1689 goto error_return; 1690 break; 1691 1692 case LOP_SKIP: 1693 /* Move forward within the same section. */ 1694 vma += y * 256 + z; 1695 1696 sec = mmo_decide_section (abfd, vma); 1697 if (sec == NULL) 1698 goto error_return; 1699 break; 1700 1701 case LOP_FIXO: 1702 /* A fixup: Store the current vma somewhere. Position using 1703 same format as LOP_LOC. */ 1704 { 1705 bfd_vma p = (bfd_vma) y << 56; 1706 asection *fixosec; 1707 1708 if (z == 1) 1709 { 1710 /* Get a 32-bit value. */ 1711 if (bfd_bread (buf, 4, abfd) != 4) 1712 goto error_return; 1713 1714 p += bfd_get_32 (abfd, buf); 1715 } 1716 else if (z == 2) 1717 { 1718 /* Get a 64-bit value. */ 1719 if (bfd_bread (buf, 8, abfd) != 8) 1720 goto error_return; 1721 1722 p += bfd_get_64 (abfd, buf); 1723 } 1724 else 1725 { 1726 _bfd_error_handler 1727 /* xgettext:c-format */ 1728 (_("%pB: invalid mmo file: expected z = 1 or z = 2," 1729 " got z = %d for lop_fixo\n"), 1730 abfd, z); 1731 bfd_set_error (bfd_error_bad_value); 1732 goto error_return; 1733 } 1734 1735 /* The section where we store this address might be a 1736 different one than the current section. */ 1737 fixosec = mmo_decide_section (abfd, p); 1738 if (fixosec == NULL) 1739 goto error_return; 1740 mmo_xore_64 (fixosec, p, vma); 1741 } 1742 break; 1743 1744 case LOP_FIXR: 1745 /* A fixup: Store YZ of this lopcode into YZ at vma - 4 * yz. */ 1746 { 1747 unsigned int yz = (y * 256 + z); 1748 bfd_vma p = vma + 2 - 4 * yz; 1749 asection *fixrsec = mmo_decide_section (abfd, p); 1750 if (fixrsec == NULL) 1751 goto error_return; 1752 mmo_xore_16 (fixrsec, p, yz); 1753 } 1754 break; 1755 1756 case LOP_FIXRX: 1757 /* A fixup, similar to lop_fixr, but taking larger numbers 1758 and can change branches into the opposite direction 1759 (gasp!). */ 1760 { 1761 bfd_vma delta; 1762 bfd_vma p; 1763 asection *fixrsec; 1764 1765 if (y != 0) 1766 { 1767 _bfd_error_handler 1768 /* xgettext:c-format */ 1769 (_("%pB: invalid mmo file: expected y = 0," 1770 " got y = %d for lop_fixrx\n"), 1771 abfd, y); 1772 bfd_set_error (bfd_error_bad_value); 1773 goto error_return; 1774 } 1775 1776 if (z != 16 && z != 24) 1777 { 1778 _bfd_error_handler 1779 /* xgettext:c-format */ 1780 (_("%pB: invalid mmo file: expected z = 16 or z = 24," 1781 " got z = %d for lop_fixrx\n"), 1782 abfd, z); 1783 bfd_set_error (bfd_error_bad_value); 1784 goto error_return; 1785 } 1786 1787 /* Get the next 32-bit value. */ 1788 if (bfd_bread (buf, 4, abfd) != 4) 1789 goto error_return; 1790 1791 delta = bfd_get_32 (abfd, buf); 1792 1793 /* Do an, ehm, involved calculation for the location of 1794 the fixup. See mmixal documentation for a verbose 1795 explanation. We follow it verbosely here for the 1796 readers delight. */ 1797 if (buf[0] == 0) 1798 p = vma - 4 * delta; 1799 else if (buf[0] == 1) 1800 p = vma - 4 * ((delta & 0xffffff) - (1 << z)); 1801 else 1802 { 1803 _bfd_error_handler 1804 /* xgettext:c-format */ 1805 (_("%pB: invalid mmo file: leading byte of operand word" 1806 " must be 0 or 1, got %d for lop_fixrx\n"), 1807 abfd, buf[0]); 1808 bfd_set_error (bfd_error_bad_value); 1809 goto error_return; 1810 } 1811 1812 fixrsec = mmo_decide_section (abfd, vma); 1813 if (fixrsec == NULL) 1814 goto error_return; 1815 mmo_xore_32 (fixrsec, p, delta); 1816 } 1817 break; 1818 1819 case LOP_FILE: 1820 /* Set current file and perhaps the file name. Reset line 1821 number. */ 1822 if (z != 0) 1823 { 1824 char *fname = bfd_malloc (z * 4 + 1); 1825 1826 if (fname == NULL) 1827 { 1828 _bfd_error_handler 1829 /* xgettext:c-format */ 1830 (_("%pB: cannot allocate file name for file number %d," 1831 " %d bytes\n"), 1832 abfd, y, z * 4 + 1); 1833 bfd_set_error (bfd_error_system_call); 1834 goto error_return; 1835 } 1836 1837 fname[z * 4] = 0; 1838 1839 for (i = 0; i < z; i++) 1840 { 1841 if (bfd_bread (fname + i * 4, 4, abfd) != 4) 1842 { 1843 free (fname); 1844 goto error_return; 1845 } 1846 } 1847 1848 if (file_names[y] != NULL) 1849 { 1850 _bfd_error_handler 1851 /* xgettext:c-format */ 1852 (_("%pB: invalid mmo file: file number %d `%s'," 1853 " was already entered as `%s'\n"), 1854 abfd, y, fname, file_names[y]); 1855 bfd_set_error (bfd_error_bad_value); 1856 goto error_return; 1857 } 1858 1859 file_names[y] = fname; 1860 } 1861 1862 if (file_names[y] == NULL) 1863 { 1864 _bfd_error_handler 1865 /* xgettext:c-format */ 1866 (_("%pB: invalid mmo file: file name for number %d" 1867 " was not specified before use\n"), 1868 abfd, y); 1869 bfd_set_error (bfd_error_bad_value); 1870 goto error_return; 1871 } 1872 1873 lineno = 0; 1874 break; 1875 1876 case LOP_LINE: 1877 /* Set line number. */ 1878 lineno = y * 256 + z; 1879 /* FIXME: Create a sequence of mmo-specific line number 1880 entries for each section, then translate into canonical 1881 format. */ 1882 break; 1883 1884 case LOP_SPEC: 1885 /* Special data follows until the next non-lop_quote 1886 lopcode. */ 1887 non_spec_sec = sec; 1888 non_spec_vma = vma; 1889 sec = mmo_get_spec_section (abfd, y * 256 + z); 1890 if (sec == NULL) 1891 goto error_return; 1892 1893 vma = sec->vma; 1894 break; 1895 1896 case LOP_PRE: 1897 { 1898 /* We ignore header information, except we read in the 1899 creation time from the first 32-bit word with the time 1900 in seconds since era. */ 1901 if (z >= 1 1902 && bfd_bread (abfd->tdata.mmo_data->created, 4, 1903 abfd) != 4) 1904 goto error_return; 1905 1906 for (i = 1; i < z; i++) 1907 if (bfd_bread (buf, 4, abfd) != 4) 1908 goto error_return; 1909 } 1910 break; 1911 1912 case LOP_POST: 1913 /* This tells of the contents of registers $Z..$255 at 1914 startup. We make a section out of it, with VMA = Z * 8, 1915 but only if Z != 255 or the contents is non-zero. */ 1916 { 1917 asection *rsec; 1918 bfd_byte *loc; 1919 bfd_vma first_octa; 1920 bfd_vma startaddr_octa; 1921 1922 /* Read first octaword outside loop to simplify logic when 1923 excluding the Z == 255, octa == 0 case. */ 1924 if (bfd_bread (buf, 8, abfd) != 8) 1925 goto error_return; 1926 1927 first_octa = bfd_get_64 (abfd, buf); 1928 1929 /* Don't emit contents for the trivial case which is 1930 always present; $255 pointing to Main. */ 1931 if (z != 255) 1932 { 1933 rsec 1934 = bfd_make_section_old_way (abfd, 1935 MMIX_REG_CONTENTS_SECTION_NAME); 1936 rsec->flags |= SEC_LINKER_CREATED; 1937 rsec->vma = z * 8; 1938 loc = mmo_get_loc (rsec, z * 8, (255 - z) * 8); 1939 bfd_put_64 (abfd, first_octa, loc); 1940 1941 for (i = z + 1; i < 255; i++) 1942 { 1943 if (bfd_bread (loc + (i - z) * 8, 8, abfd) != 8) 1944 goto error_return; 1945 } 1946 1947 /* Read out the last octabyte, and use it to set the 1948 start address. */ 1949 if (bfd_bread (buf, 8, abfd) != 8) 1950 goto error_return; 1951 1952 startaddr_octa = bfd_get_64 (abfd, buf); 1953 } 1954 else 1955 startaddr_octa = first_octa; 1956 1957 if (! bfd_set_start_address (abfd, startaddr_octa)) 1958 { 1959 /* Currently this can't fail, but this should handle 1960 future failures. */ 1961 bfd_set_error (bfd_error_bad_value); 1962 goto error_return; 1963 } 1964 } 1965 break; 1966 1967 case LOP_STAB: 1968 /* We read in the symbols now, not later. */ 1969 if (y != 0 || z != 0) 1970 { 1971 _bfd_error_handler 1972 /* xgettext:c-format */ 1973 (_("%pB: invalid mmo file: fields y and z of lop_stab" 1974 " non-zero, y: %d, z: %d\n"), 1975 abfd, y, z); 1976 bfd_set_error (bfd_error_bad_value); 1977 goto error_return; 1978 } 1979 1980 /* Save the location, so we can check that YZ in the LOP_END 1981 is correct. */ 1982 stab_loc = bfd_tell (abfd); 1983 1984 /* It's not said that an MMO can be without symbols (though 1985 mmixal will refuse to assemble files without Main), but 1986 it seems it would still be a valid mmo-file, so allow it. 1987 We detect the absence of a symbol area in that the upper 1988 limit is computed (from the lop_end YZ field) as 0. 1989 Don't call mmo_get_symbols; it can only detect the end of 1990 a valid symbol trie, not the absence of one. */ 1991 if (abfd->tdata.mmo_data->max_symbol_length != 0 1992 && ! mmo_get_symbols (abfd)) 1993 goto error_return; 1994 break; 1995 1996 case LOP_END: 1997 { 1998 /* This must be the last 32-bit word in an mmo file. 1999 Let's find out. */ 2000 struct stat statbuf; 2001 file_ptr curpos = bfd_tell (abfd); 2002 2003 if (bfd_stat (abfd, &statbuf) < 0) 2004 goto error_return; 2005 2006 if (statbuf.st_size != curpos) 2007 { 2008 _bfd_error_handler 2009 /* xgettext:c-format */ 2010 (_("%pB: invalid mmo file: lop_end not last item in" 2011 " file\n"), 2012 abfd); 2013 bfd_set_error (bfd_error_bad_value); 2014 goto error_return; 2015 } 2016 2017 /* Check that the YZ field is right. Subtract the size of 2018 this LOP_END in the calculation; YZ does not include 2019 it. */ 2020 if ((long) (y * 256 + z) * 4 != (curpos - stab_loc) - 4) 2021 { 2022 _bfd_error_handler 2023 /* xgettext:c-format */ 2024 (_("%pB: invalid mmo file: YZ of lop_end (%ld)" 2025 " not equal to the number of tetras to the preceding" 2026 " lop_stab (%ld)\n"), 2027 abfd, (long) (y * 256 + z), 2028 (long) (curpos - stab_loc - 4)/4); 2029 bfd_set_error (bfd_error_bad_value); 2030 goto error_return; 2031 } 2032 2033 bfd_map_over_sections (abfd, mmo_map_set_sizes, NULL); 2034 goto done; 2035 } 2036 } 2037 } 2038 else 2039 { 2040 /* This wasn't a lopcode, so store it in the current section. */ 2041 mmo_xore_32 (sec, vma & ~3, bfd_get_32 (abfd, buf)); 2042 vma += 4; 2043 vma &= ~3; 2044 lineno++; 2045 } 2046 } 2047 2048 /* We know this file is a multiple of four bytes (checked in 2049 mmo_object_p), so if we got something other than 0, this was a bad 2050 file (although it's more likely we'll get 0 in that case too). 2051 If we got end-of-file, then there was no lop_stab, so the file has 2052 invalid format. */ 2053 2054 if (nbytes_read != 0) 2055 bfd_set_error (bfd_error_system_call); 2056 else 2057 bfd_set_error (bfd_error_bad_value); 2058 2059 error_return: 2060 error = TRUE; 2061 done: 2062 /* Mark the .text and .data section with their normal attribute if they 2063 contain anything. This is not redundant wrt. mmo_decide_section, 2064 since that code might never execute, and conversely the alloc+code 2065 section flags must be set then. */ 2066 sec = bfd_get_section_by_name (abfd, MMO_TEXT_SECTION_NAME); 2067 if (sec != NULL 2068 && (bfd_section_flags (sec) & SEC_HAS_CONTENTS) 2069 && !bfd_set_section_flags (sec, (bfd_section_flags (sec) 2070 | SEC_ALLOC | SEC_LOAD | SEC_CODE))) 2071 error = TRUE; 2072 2073 sec = bfd_get_section_by_name (abfd, MMO_DATA_SECTION_NAME); 2074 if (sec != NULL 2075 && (bfd_section_flags (sec) & SEC_HAS_CONTENTS) 2076 && !bfd_set_section_flags (sec, (bfd_section_flags (sec) 2077 | SEC_ALLOC | SEC_LOAD))) 2078 error = TRUE; 2079 2080 /* Free whatever resources we took. */ 2081 for (i = 0; i < sizeof (file_names) / sizeof (file_names[0]); i++) 2082 if (file_names[i]) 2083 free (file_names[i]); 2084 return ! error; 2085 } 2086 2087 /* A hook to set up object file dependent section information. For mmo, 2088 we point out the shape of allocated section contents. */ 2089 2090 static bfd_boolean 2091 mmo_new_section_hook (bfd *abfd, asection *newsect) 2092 { 2093 if (!newsect->used_by_bfd) 2094 { 2095 /* We zero-fill all fields and assume NULL is represented by an all 2096 zero-bit pattern. */ 2097 newsect->used_by_bfd 2098 = bfd_zalloc (abfd, sizeof (struct mmo_section_data_struct)); 2099 if (!newsect->used_by_bfd) 2100 return FALSE; 2101 } 2102 2103 /* Always align to at least 32-bit words. */ 2104 newsect->alignment_power = 2; 2105 return _bfd_generic_new_section_hook (abfd, newsect); 2106 } 2107 2108 /* We already have section contents loaded for sections that have 2109 contents. */ 2110 2111 static bfd_boolean 2112 mmo_get_section_contents (bfd *abfd ATTRIBUTE_UNUSED, 2113 asection *sec, 2114 void * location, 2115 file_ptr offset, 2116 bfd_size_type bytes_to_do) 2117 { 2118 /* Iterate over diminishing chunk sizes, copying contents, like 2119 mmo_set_section_contents. */ 2120 while (bytes_to_do) 2121 { 2122 /* A minor song-and-dance to make sure we're not bitten by the 2123 distant possibility of the cast from bfd_vma to int making the 2124 chunk zero-sized. */ 2125 int chunk_size 2126 = (int) bytes_to_do != 0 ? bytes_to_do : MMO_SEC_CONTENTS_CHUNK_SIZE; 2127 bfd_byte *loc; 2128 2129 do 2130 loc = mmo_get_loc (sec, sec->vma + offset, chunk_size); 2131 while (loc == NULL && (chunk_size /= 2) != 0); 2132 2133 if (chunk_size == 0) 2134 return FALSE; 2135 2136 memcpy (location, loc, chunk_size); 2137 2138 location = (bfd_byte *) location + chunk_size; 2139 bytes_to_do -= chunk_size; 2140 offset += chunk_size; 2141 } 2142 return TRUE; 2143 } 2144 2145 /* Return the amount of memory needed to read the symbol table. */ 2146 2147 static long 2148 mmo_get_symtab_upper_bound (bfd *abfd) 2149 { 2150 return (abfd->symcount + 1) * sizeof (asymbol *); 2151 } 2152 2153 /* Sort mmo symbols by serial number. */ 2154 2155 static int 2156 mmo_sort_mmo_symbols (const void *arg1, const void *arg2) 2157 { 2158 const struct mmo_symbol *sym1 = *(const struct mmo_symbol **) arg1; 2159 const struct mmo_symbol *sym2 = *(const struct mmo_symbol **) arg2; 2160 2161 /* Sort by serial number first. */ 2162 if (sym1->serno < sym2->serno) 2163 return -1; 2164 else if (sym1->serno > sym2->serno) 2165 return 1; 2166 2167 /* Then sort by address of the table entries. */ 2168 return ((const char *) arg1 - (const char *) arg2); 2169 } 2170 2171 /* Translate the symbol table. */ 2172 2173 static long 2174 mmo_canonicalize_symtab (bfd *abfd, asymbol **alocation) 2175 { 2176 unsigned int symcount = bfd_get_symcount (abfd); 2177 asymbol *csymbols; 2178 unsigned int i; 2179 2180 csymbols = abfd->tdata.mmo_data->csymbols; 2181 if (csymbols == NULL && symcount != 0) 2182 { 2183 asymbol *c; 2184 struct mmo_symbol *s; 2185 struct mmo_symbol **msp; 2186 2187 /* First we store the symbols into the table we'll return, then we 2188 qsort it on the serial number, with secondary on the address of 2189 the symbol, to preserve order if there would be non-unique serial 2190 numbers. */ 2191 for (s = abfd->tdata.mmo_data->symbols, 2192 msp = (struct mmo_symbol **) alocation; 2193 s != NULL; 2194 s = s->next, ++msp) 2195 *msp = s; 2196 2197 *msp = NULL; 2198 2199 qsort (alocation, symcount, sizeof (struct mmo_symbol *), 2200 mmo_sort_mmo_symbols); 2201 2202 csymbols = (asymbol *) bfd_alloc (abfd, symcount * sizeof (asymbol)); 2203 if (csymbols == NULL) 2204 return -1; 2205 abfd->tdata.mmo_data->csymbols = csymbols; 2206 2207 for (msp = (struct mmo_symbol **) alocation, c = csymbols; 2208 *msp != NULL; 2209 msp++, ++c) 2210 { 2211 s = *msp; 2212 c->the_bfd = abfd; 2213 c->name = s->name; 2214 c->value = s->value; 2215 c->flags = BSF_GLOBAL; 2216 2217 if (s->sym_type == mmo_data_sym) 2218 { 2219 c->section 2220 = bfd_get_section_by_name (abfd, MMO_DATA_SECTION_NAME); 2221 2222 if (c->section == NULL) 2223 c->section = bfd_abs_section_ptr; 2224 else 2225 c->value -= c->section->vma; 2226 } 2227 else if (s->sym_type == mmo_undef_sym) 2228 c->section = bfd_und_section_ptr; 2229 else if (s->sym_type == mmo_reg_sym) 2230 { 2231 c->section 2232 = bfd_make_section_old_way (abfd, MMIX_REG_SECTION_NAME); 2233 c->section->flags |= SEC_LINKER_CREATED; 2234 } 2235 else 2236 { 2237 asection *textsec 2238 = bfd_get_section_by_name (abfd, MMO_TEXT_SECTION_NAME); 2239 asection *datasec; 2240 2241 if (textsec != NULL 2242 && c->value >= textsec->vma 2243 && c->value <= textsec->vma + textsec->size) 2244 { 2245 c->section = textsec; 2246 c->value -= c->section->vma; 2247 } 2248 /* In mmo, symbol types depend on the VMA. Therefore, if 2249 the data section isn't within the usual bounds, its 2250 symbols are marked as absolute. Correct that. This 2251 means we can't have absolute symbols with values matching 2252 data section addresses, but we also can't have with 2253 absolute symbols with values matching text section 2254 addresses. For such needs, use the ELF format. */ 2255 else if ((datasec 2256 = bfd_get_section_by_name (abfd, 2257 MMO_DATA_SECTION_NAME)) 2258 != NULL 2259 && c->value >= datasec->vma 2260 && c->value <= datasec->vma + datasec->size) 2261 { 2262 c->section = datasec; 2263 c->value -= c->section->vma; 2264 } 2265 else 2266 c->section = bfd_abs_section_ptr; 2267 } 2268 2269 c->udata.p = NULL; 2270 } 2271 } 2272 2273 /* Last, overwrite the incoming table with the right-type entries. */ 2274 for (i = 0; i < symcount; i++) 2275 *alocation++ = csymbols++; 2276 *alocation = NULL; 2277 2278 return symcount; 2279 } 2280 2281 /* Get information about a symbol. */ 2282 2283 static void 2284 mmo_get_symbol_info (bfd *ignore_abfd ATTRIBUTE_UNUSED, 2285 asymbol *symbol, symbol_info *ret) 2286 { 2287 bfd_symbol_info (symbol, ret); 2288 } 2289 2290 static void 2291 mmo_print_symbol (bfd *abfd, void *afile, asymbol *symbol, 2292 bfd_print_symbol_type how) 2293 { 2294 FILE *file = (FILE *) afile; 2295 2296 switch (how) 2297 { 2298 case bfd_print_symbol_name: 2299 fprintf (file, "%s", symbol->name); 2300 break; 2301 default: 2302 bfd_print_symbol_vandf (abfd, file, symbol); 2303 2304 fprintf (file, " %-5s %s", 2305 symbol->section->name, 2306 symbol->name); 2307 } 2308 } 2309 2310 /* We can't map a file directly into executable code, so the 2311 size of header information is irrelevant. */ 2312 2313 static int 2314 mmo_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED, 2315 struct bfd_link_info *info ATTRIBUTE_UNUSED) 2316 { 2317 return 0; 2318 } 2319 2320 /* Write the (section-neutral) file preamble. */ 2321 2322 static bfd_boolean 2323 mmo_internal_write_header (bfd *abfd) 2324 { 2325 const char lop_pre_bfd[] = { LOP, LOP_PRE, 1, 1}; 2326 2327 if (bfd_bwrite (lop_pre_bfd, 4, abfd) != 4) 2328 return FALSE; 2329 2330 /* Copy creation time of original file. */ 2331 if (bfd_bwrite (abfd->tdata.mmo_data->created, 4, abfd) != 4) 2332 return FALSE; 2333 2334 return TRUE; 2335 } 2336 2337 /* Write the LOP_POST record, with global register initializations. 2338 Z is the Z field of the LOP_POST, corresponding to 255 - number of 2339 registers at DATA. The Z = 255 field is filled in with the 2340 start-address. */ 2341 2342 static bfd_boolean 2343 mmo_internal_write_post (bfd *abfd, int z, asection *sec) 2344 { 2345 int i; 2346 bfd_byte buf[8]; 2347 mmo_write_tetra_raw (abfd, (LOP << 24) | (LOP_POST << 16) | z); 2348 2349 for (i = z; i < 255; i++) 2350 { 2351 bfd_byte *data = mmo_get_loc (sec, i * 8, 8); 2352 2353 if (bfd_bwrite (data, 8, abfd) != 8) 2354 return FALSE; 2355 } 2356 2357 /* For Z == $255, we always emit the start location; supposedly Main, 2358 but we have it handy at bfd_get_start_address. If we're called with 2359 Z == 255, don't assume DATA is valid. */ 2360 bfd_put_64 (abfd, bfd_get_start_address (abfd), buf); 2361 2362 return ! abfd->tdata.mmo_data->have_error && bfd_bwrite (buf, 8, abfd) == 8; 2363 } 2364 2365 /* Translate to and from BFD flags. This is to make sure that we don't 2366 get bitten by BFD flag number changes. */ 2367 2368 static flagword 2369 mmo_sec_flags_from_bfd_flags (flagword flags) 2370 { 2371 flagword oflags = 0; 2372 2373 if (flags & SEC_ALLOC) 2374 oflags |= MMO_SEC_ALLOC; 2375 if (flags & SEC_LOAD) 2376 oflags |= MMO_SEC_LOAD; 2377 if (flags & SEC_RELOC) 2378 oflags |= MMO_SEC_RELOC; 2379 if (flags & SEC_READONLY) 2380 oflags |= MMO_SEC_READONLY; 2381 if (flags & SEC_CODE) 2382 oflags |= MMO_SEC_CODE; 2383 if (flags & SEC_DATA) 2384 oflags |= MMO_SEC_DATA; 2385 if (flags & SEC_NEVER_LOAD) 2386 oflags |= MMO_SEC_NEVER_LOAD; 2387 if (flags & SEC_IS_COMMON) 2388 oflags |= MMO_SEC_IS_COMMON; 2389 if (flags & SEC_DEBUGGING) 2390 oflags |= MMO_SEC_DEBUGGING; 2391 2392 return oflags; 2393 } 2394 2395 static flagword 2396 bfd_sec_flags_from_mmo_flags (flagword flags) 2397 { 2398 flagword oflags = 0; 2399 2400 if (flags & MMO_SEC_ALLOC) 2401 oflags |= SEC_ALLOC; 2402 if (flags & MMO_SEC_LOAD) 2403 oflags |= SEC_LOAD; 2404 if (flags & MMO_SEC_RELOC) 2405 oflags |= SEC_RELOC; 2406 if (flags & MMO_SEC_READONLY) 2407 oflags |= SEC_READONLY; 2408 if (flags & MMO_SEC_CODE) 2409 oflags |= SEC_CODE; 2410 if (flags & MMO_SEC_DATA) 2411 oflags |= SEC_DATA; 2412 if (flags & MMO_SEC_NEVER_LOAD) 2413 oflags |= SEC_NEVER_LOAD; 2414 if (flags & MMO_SEC_IS_COMMON) 2415 oflags |= SEC_IS_COMMON; 2416 if (flags & MMO_SEC_DEBUGGING) 2417 oflags |= SEC_DEBUGGING; 2418 2419 return oflags; 2420 } 2421 2422 /* Return TRUE iff the leading or trailing tetrabyte in SEC is defined and 2423 is 0. */ 2424 2425 static bfd_boolean 2426 mmo_has_leading_or_trailing_zero_tetra_p (bfd *abfd, asection *sec) 2427 { 2428 bfd_vma secaddr = bfd_section_vma (sec); 2429 2430 if (sec->size < 4) 2431 return FALSE; 2432 2433 if (bfd_get_32 (abfd, mmo_get_loc (sec, secaddr, 4)) == 0 2434 && bfd_get_32 (abfd, 2435 mmo_get_loc (sec, secaddr + sec->size - 4, 4)) == 0) 2436 return TRUE; 2437 2438 return FALSE; 2439 } 2440 2441 /* Write a section. */ 2442 2443 static bfd_boolean 2444 mmo_internal_write_section (bfd *abfd, asection *sec) 2445 { 2446 /* We do it differently depending on what section this is: 2447 2448 ".text": Output, prepended by information about the first source file 2449 (not yet implemented.) 2450 2451 ".data": Output. 2452 2453 (".MMIX.reg_contents": Not handled here.) 2454 2455 Anything else: Output inside a lop_spec 80, in the format described 2456 above. */ 2457 2458 if (strcmp (sec->name, MMO_TEXT_SECTION_NAME) == 0) 2459 { 2460 bfd_vma secaddr = bfd_section_vma (sec); 2461 2462 /* Because leading and trailing zeros are omitted in output, we need to 2463 specify the section boundaries so they're correct when the file 2464 is read in again. That's also the case if this section is 2465 specified as not within its usual boundaries or alignments. */ 2466 if (sec->size != 0 2467 && (secaddr + sec->size >= (bfd_vma) 1 << 56 2468 || (secaddr & 3) != 0 2469 || (sec->size & 3) != 0 2470 || mmo_has_leading_or_trailing_zero_tetra_p (abfd, sec))) 2471 { 2472 if (!mmo_write_section_description (abfd, sec)) 2473 return FALSE; 2474 } 2475 2476 /* FIXME: Output source file name and line number. */ 2477 return mmo_write_loc_chunk_list (abfd, mmo_section_data (sec)->head); 2478 } 2479 else if (strcmp (sec->name, MMO_DATA_SECTION_NAME) == 0) 2480 { 2481 bfd_vma secaddr = bfd_section_vma (sec); 2482 2483 /* Same goes as for MMO_TEXT_SECTION_NAME above. */ 2484 if (sec->size != 0 2485 && (secaddr < (bfd_vma) 0x20 << 56 2486 || secaddr + sec->size >= (bfd_vma) 0x21 << 56 2487 || (secaddr & 3) != 0 2488 || (sec->size & 3) != 0 2489 || mmo_has_leading_or_trailing_zero_tetra_p (abfd, sec))) 2490 { 2491 if (!mmo_write_section_description (abfd, sec)) 2492 return FALSE; 2493 } 2494 2495 return mmo_write_loc_chunk_list (abfd, mmo_section_data (sec)->head); 2496 } 2497 else if (strcmp (sec->name, MMIX_REG_CONTENTS_SECTION_NAME) == 0) 2498 /* Not handled here. */ 2499 { 2500 /* This would normally be an abort call since this can't happen, but 2501 we don't do that. */ 2502 bfd_set_error (bfd_error_bad_value); 2503 return FALSE; 2504 } 2505 else if (CONST_STRNEQ (sec->name, MMIX_OTHER_SPEC_SECTION_PREFIX)) 2506 { 2507 int n = atoi (sec->name + strlen (MMIX_OTHER_SPEC_SECTION_PREFIX)); 2508 2509 mmo_write_tetra_raw (abfd, (LOP << 24) | (LOP_SPEC << 16) | n); 2510 return (! abfd->tdata.mmo_data->have_error 2511 && mmo_write_chunk_list (abfd, mmo_section_data (sec)->head)); 2512 } 2513 /* Ignore sections that are just allocated or empty; we write out 2514 _contents_ here. */ 2515 else if ((bfd_section_flags (sec) & SEC_HAS_CONTENTS) != 0 2516 && sec->size != 0) 2517 { 2518 if (!mmo_write_section_description (abfd, sec)) 2519 return FALSE; 2520 2521 /* Writing a LOP_LOC ends the LOP_SPEC data, and makes data actually 2522 loaded. */ 2523 if (bfd_section_flags (sec) & SEC_LOAD) 2524 return (! abfd->tdata.mmo_data->have_error 2525 && mmo_write_loc_chunk_list (abfd, 2526 mmo_section_data (sec)->head)); 2527 return (! abfd->tdata.mmo_data->have_error 2528 && mmo_write_chunk_list (abfd, mmo_section_data (sec)->head)); 2529 } 2530 2531 /* Some section without contents. */ 2532 return TRUE; 2533 } 2534 2535 /* Write the description of a section, extended-mmo-style. */ 2536 2537 static bfd_boolean 2538 mmo_write_section_description (bfd *abfd, asection *sec) 2539 { 2540 /* Keep the following document-comment formatted the way it is. */ 2541 /* 2542 INODE 2543 mmo section mapping, , Symbol-table, mmo 2544 SUBSECTION 2545 mmo section mapping 2546 2547 The implementation in BFD uses special data type 80 (decimal) to 2548 encapsulate and describe named sections, containing e.g.@: debug 2549 information. If needed, any datum in the encapsulation will be 2550 quoted using lop_quote. First comes a 32-bit word holding the 2551 number of 32-bit words containing the zero-terminated zero-padded 2552 segment name. After the name there's a 32-bit word holding flags 2553 describing the section type. Then comes a 64-bit big-endian word 2554 with the section length (in bytes), then another with the section 2555 start address. Depending on the type of section, the contents 2556 might follow, zero-padded to 32-bit boundary. For a loadable 2557 section (such as data or code), the contents might follow at some 2558 later point, not necessarily immediately, as a lop_loc with the 2559 same start address as in the section description, followed by the 2560 contents. This in effect forms a descriptor that must be emitted 2561 before the actual contents. Sections described this way must not 2562 overlap. 2563 2564 For areas that don't have such descriptors, synthetic sections are 2565 formed by BFD. Consecutive contents in the two memory areas 2566 @samp{0x0000@dots{}00} to @samp{0x01ff@dots{}ff} and 2567 @samp{0x2000@dots{}00} to @samp{0x20ff@dots{}ff} are entered in 2568 sections named <<.text>> and <<.data>> respectively. If an area 2569 is not otherwise described, but would together with a neighboring 2570 lower area be less than @samp{0x40000000} bytes long, it is joined 2571 with the lower area and the gap is zero-filled. For other cases, 2572 a new section is formed, named <<.MMIX.sec.@var{n}>>. Here, 2573 @var{n} is a number, a running count through the mmo file, 2574 starting at 0. 2575 2576 EXAMPLE 2577 A loadable section specified as: 2578 2579 | .section secname,"ax" 2580 | TETRA 1,2,3,4,-1,-2009 2581 | BYTE 80 2582 2583 and linked to address @samp{0x4}, is represented by the sequence: 2584 2585 | 0x98080050 - lop_spec 80 2586 | 0x00000002 - two 32-bit words for the section name 2587 | 0x7365636e - "secn" 2588 | 0x616d6500 - "ame\0" 2589 | 0x00000033 - flags CODE, READONLY, LOAD, ALLOC 2590 | 0x00000000 - high 32 bits of section length 2591 | 0x0000001c - section length is 28 bytes; 6 * 4 + 1 + alignment to 32 bits 2592 | 0x00000000 - high 32 bits of section address 2593 | 0x00000004 - section address is 4 2594 | 0x98010002 - 64 bits with address of following data 2595 | 0x00000000 - high 32 bits of address 2596 | 0x00000004 - low 32 bits: data starts at address 4 2597 | 0x00000001 - 1 2598 | 0x00000002 - 2 2599 | 0x00000003 - 3 2600 | 0x00000004 - 4 2601 | 0xffffffff - -1 2602 | 0xfffff827 - -2009 2603 | 0x50000000 - 80 as a byte, padded with zeros. 2604 2605 Note that the lop_spec wrapping does not include the section 2606 contents. Compare this to a non-loaded section specified as: 2607 2608 | .section thirdsec 2609 | TETRA 200001,100002 2610 | BYTE 38,40 2611 2612 This, when linked to address @samp{0x200000000000001c}, is 2613 represented by: 2614 2615 | 0x98080050 - lop_spec 80 2616 | 0x00000002 - two 32-bit words for the section name 2617 | 0x7365636e - "thir" 2618 | 0x616d6500 - "dsec" 2619 | 0x00000010 - flag READONLY 2620 | 0x00000000 - high 32 bits of section length 2621 | 0x0000000c - section length is 12 bytes; 2 * 4 + 2 + alignment to 32 bits 2622 | 0x20000000 - high 32 bits of address 2623 | 0x0000001c - low 32 bits of address 0x200000000000001c 2624 | 0x00030d41 - 200001 2625 | 0x000186a2 - 100002 2626 | 0x26280000 - 38, 40 as bytes, padded with zeros 2627 2628 For the latter example, the section contents must not be 2629 loaded in memory, and is therefore specified as part of the 2630 special data. The address is usually unimportant but might 2631 provide information for e.g.@: the DWARF 2 debugging format. */ 2632 2633 mmo_write_tetra_raw (abfd, LOP_SPEC_SECTION); 2634 mmo_write_tetra (abfd, (strlen (sec->name) + 3) / 4); 2635 mmo_write_chunk (abfd, (bfd_byte *) sec->name, strlen (sec->name)); 2636 mmo_flush_chunk (abfd); 2637 /* FIXME: We can get debug sections (.debug_line & Co.) with a section 2638 flag still having SEC_RELOC set. Investigate. This might be true 2639 for all alien sections; perhaps mmo.em should clear that flag. Might 2640 be related to weak references. */ 2641 mmo_write_tetra (abfd, 2642 mmo_sec_flags_from_bfd_flags (bfd_section_flags (sec))); 2643 mmo_write_octa (abfd, sec->size); 2644 mmo_write_octa (abfd, bfd_section_vma (sec)); 2645 return TRUE; 2646 } 2647 2648 /* We save up all data before output. */ 2649 2650 static bfd_boolean 2651 mmo_set_section_contents (bfd *abfd ATTRIBUTE_UNUSED, sec_ptr sec, 2652 const void *location, file_ptr offset, 2653 bfd_size_type bytes_to_do) 2654 { 2655 /* Iterate over diminishing chunk sizes, copying contents. */ 2656 while (bytes_to_do) 2657 { 2658 /* A minor song-and-dance to make sure we're not bitten by the 2659 distant possibility of the cast from bfd_vma to int making the 2660 chunk zero-sized. */ 2661 int chunk_size 2662 = (int) bytes_to_do != 0 ? bytes_to_do : MMO_SEC_CONTENTS_CHUNK_SIZE; 2663 bfd_byte *loc; 2664 2665 do 2666 loc = mmo_get_loc (sec, sec->vma + offset, chunk_size); 2667 while (loc == NULL && (chunk_size /= 2) != 0); 2668 2669 if (chunk_size == 0) 2670 return FALSE; 2671 2672 memcpy (loc, location, chunk_size); 2673 2674 location = (bfd_byte *) location + chunk_size; 2675 bytes_to_do -= chunk_size; 2676 offset += chunk_size; 2677 } 2678 return TRUE; 2679 } 2680 2681 /* Add a symbol to a trie-tree. */ 2682 2683 static bfd_boolean 2684 mmo_internal_add_3_sym (bfd *abfd, struct mmo_symbol_trie *rootp, 2685 const struct mmo_symbol *symp) 2686 { 2687 const char *name = symp->name; 2688 struct mmo_symbol_trie *trie = rootp; 2689 struct mmo_symbol_trie **triep = NULL; 2690 2691 while (*name && trie != NULL) 2692 { 2693 if (*name < trie->symchar) 2694 { 2695 triep = &trie->left; 2696 trie = trie->left; 2697 } 2698 else if (*name > trie->symchar) 2699 { 2700 triep = &trie->right; 2701 trie = trie->right; 2702 } 2703 else if (*name == trie->symchar) 2704 { 2705 triep = &trie->middle; 2706 name++; 2707 2708 /* Make sure "trie" points to where we should fill in the 2709 current symbol whenever we've iterated through "name". We 2710 would lose the right position if we encounter "foobar" then 2711 "foo". */ 2712 if (*name) 2713 trie = trie->middle; 2714 } 2715 } 2716 2717 while (*name != 0) 2718 { 2719 /* Create middle branches for the rest of the characters. */ 2720 trie = bfd_zalloc (abfd, sizeof (struct mmo_symbol_trie)); 2721 *triep = trie; 2722 trie->symchar = *name++; 2723 triep = &trie->middle; 2724 } 2725 2726 /* We discover a duplicate symbol rather late in the process, but still; 2727 we discover it and bail out. */ 2728 if (trie->sym.name != NULL) 2729 { 2730 _bfd_error_handler 2731 /* xgettext:c-format */ 2732 (_("%pB: invalid symbol table: duplicate symbol `%s'\n"), 2733 abfd, trie->sym.name); 2734 bfd_set_error (bfd_error_bad_value); 2735 return FALSE; 2736 } 2737 2738 memcpy (&trie->sym, symp, sizeof *symp); 2739 return TRUE; 2740 } 2741 2742 /* Find out the length of the serialized version of a trie in bytes. */ 2743 2744 static unsigned int 2745 mmo_internal_3_length (bfd *abfd, struct mmo_symbol_trie *trie) 2746 { 2747 /* First, one for the control byte. */ 2748 unsigned int length = 1; 2749 2750 if (trie == NULL) 2751 return 0; 2752 2753 /* Add in the recursion to the left. */ 2754 length += mmo_internal_3_length (abfd, trie->left); 2755 2756 /* Add in the middle trie and the character. */ 2757 length += 1 + mmo_internal_3_length (abfd, trie->middle); 2758 2759 /* Add in the recursion to the right. */ 2760 length += mmo_internal_3_length (abfd, trie->right); 2761 2762 /* Add in bytes for the symbol (if this is an endnode). */ 2763 if (trie->sym.name != NULL) 2764 { 2765 unsigned int serno = trie->sym.serno; 2766 2767 /* First what it takes to encode the value. */ 2768 if (trie->sym.sym_type == mmo_reg_sym) 2769 length++; 2770 else if (trie->sym.sym_type == mmo_undef_sym) 2771 length += 2; 2772 else 2773 { 2774 bfd_vma value = trie->sym.value; 2775 2776 /* Coded in one to eight following bytes. */ 2777 if (trie->sym.sym_type == mmo_data_sym) 2778 value -= (bfd_vma) 0x20 << 56; 2779 2780 do 2781 { 2782 value >>= 8; 2783 length++; 2784 } 2785 while (value != 0); 2786 } 2787 2788 /* Find out what it takes to encode the serial number. */ 2789 do 2790 { 2791 serno >>= 7; 2792 length++; 2793 } 2794 while (serno != 0); 2795 } 2796 2797 return length; 2798 } 2799 2800 /* Helper function for outputting the serial number of a symbol, output as 2801 a variant of leb128 (see dwarf2 documentation) which could be called 2802 beb128. Using a helper function and recursion simplifies debugging. */ 2803 2804 static void 2805 mmo_beb128_out (bfd *abfd, int serno, int marker) 2806 { 2807 if (serno & ~0x7f) 2808 mmo_beb128_out (abfd, serno >> 7, 0); 2809 mmo_write_byte (abfd, marker | (serno & 0x7f)); 2810 } 2811 2812 /* Serialize a trie. */ 2813 2814 static void 2815 mmo_internal_3_dump (bfd *abfd, struct mmo_symbol_trie *trie) 2816 { 2817 bfd_byte control = 0; 2818 2819 if (trie == NULL) 2820 return; 2821 2822 if (trie->left) 2823 control |= MMO3_LEFT; 2824 2825 if (trie->middle) 2826 control |= MMO3_MIDDLE; 2827 2828 if (trie->right) 2829 control |= MMO3_RIGHT; 2830 2831 if (trie->sym.name != NULL) 2832 { 2833 /* Encode the symbol type and length of value bytes. */ 2834 if (trie->sym.sym_type == mmo_reg_sym) 2835 control |= MMO3_REGQUAL_BITS; 2836 else if (trie->sym.sym_type == mmo_undef_sym) 2837 control |= MMO3_UNDEF; 2838 else 2839 { 2840 bfd_vma value = trie->sym.value; 2841 2842 /* Coded in 1..8 following bytes. */ 2843 if (trie->sym.sym_type == mmo_data_sym) 2844 { 2845 control |= MMO3_DATA; 2846 value -= (bfd_vma) 0x20 << 56; 2847 } 2848 2849 do 2850 { 2851 value >>= 8; 2852 control++; 2853 } 2854 while (value != 0); 2855 } 2856 } 2857 2858 /* The control byte is output before recursing. */ 2859 mmo_write_byte (abfd, control); 2860 2861 mmo_internal_3_dump (abfd, trie->left); 2862 2863 if (control & MMO3_SYMBITS) 2864 { 2865 mmo_write_byte (abfd, trie->symchar); 2866 2867 if (trie->sym.name != NULL) 2868 { 2869 if (trie->sym.sym_type == mmo_reg_sym) 2870 mmo_write_byte (abfd, trie->sym.value); 2871 else if (trie->sym.sym_type == mmo_undef_sym) 2872 { 2873 mmo_write_byte (abfd, 0); 2874 mmo_write_byte (abfd, 0); 2875 } 2876 else 2877 { 2878 bfd_vma value = trie->sym.value; 2879 2880 bfd_byte byte_n = control & 15; 2881 2882 /* Coded in 1..8 following bytes. Note that the value is 2883 shifted out big-endian. */ 2884 if (trie->sym.sym_type == mmo_data_sym) 2885 { 2886 value -= (bfd_vma) 0x20 << 56; 2887 byte_n -= 8; 2888 } 2889 2890 do 2891 { 2892 mmo_write_byte (abfd, (value >> ((byte_n - 1) * 8)) & 0xff); 2893 byte_n--; 2894 } 2895 while (byte_n != 0); 2896 } 2897 2898 mmo_beb128_out (abfd, trie->sym.serno, 128); 2899 } 2900 mmo_internal_3_dump (abfd, trie->middle); 2901 } 2902 mmo_internal_3_dump (abfd, trie->right); 2903 } 2904 2905 /* Write symbols in mmo format. Also write the lop_end terminator. */ 2906 2907 static bfd_boolean 2908 mmo_write_symbols_and_terminator (bfd *abfd) 2909 { 2910 int count = bfd_get_symcount (abfd); 2911 asymbol **table; 2912 asymbol **orig_table = bfd_get_outsymbols (abfd); 2913 int serno; 2914 struct mmo_symbol_trie root; 2915 int trie_len; 2916 int i; 2917 bfd_byte buf[4]; 2918 2919 /* Create a symbol for "Main". */ 2920 asymbol *fakemain = bfd_make_empty_symbol (abfd); 2921 2922 fakemain->flags = BSF_GLOBAL; 2923 fakemain->value = bfd_get_start_address (abfd); 2924 fakemain->name = MMIX_START_SYMBOL_NAME; 2925 fakemain->section = bfd_abs_section_ptr; 2926 2927 memset (&root, 0, sizeof (root)); 2928 2929 /* Make all symbols take a left turn. */ 2930 root.symchar = 0xff; 2931 2932 /* There must always be a ":Main", so we'll add one if there are no 2933 symbols. Make sure we have room for it. */ 2934 table = bfd_alloc (abfd, (count + 1) * sizeof (asymbol *)); 2935 if (table == NULL) 2936 return FALSE; 2937 2938 memcpy (table, orig_table, count * sizeof (asymbol *)); 2939 2940 /* Move :Main (if there is one) to the first position. This is 2941 necessary to get the same layout of the trie-tree when linking as 2942 when objcopying the result as in the objcopy.exp test "simple objcopy 2943 of executable". It also automatically takes care of assigning serial 2944 number 1 to :Main (as is mandatory). */ 2945 for (i = 0; i < count; i++) 2946 if (table[i] != NULL 2947 && strcmp (table[i]->name, MMIX_START_SYMBOL_NAME) == 0 2948 && (table[i]->flags & (BSF_DEBUGGING|BSF_GLOBAL)) == BSF_GLOBAL) 2949 { 2950 asymbol *mainsym = table[i]; 2951 bfd_vma mainvalue 2952 = (mainsym->value 2953 + mainsym->section->output_section->vma 2954 + mainsym->section->output_offset); 2955 memcpy (table + 1, orig_table, i * sizeof (asymbol *)); 2956 table[0] = mainsym; 2957 2958 /* Check that the value assigned to :Main is the same as the entry 2959 address. The default linker script asserts this. This is as 2960 good a place as any to check this consistency. */ 2961 if (mainvalue != bfd_get_start_address (abfd) 2962 && !mmo_ignore_symbol_consistency (abfd)) 2963 { 2964 /* Arbitrary buffer to hold the printable representation of a 2965 vma. */ 2966 char vmas_main[40]; 2967 char vmas_start[40]; 2968 bfd_vma vma_start = bfd_get_start_address (abfd); 2969 2970 sprintf_vma (vmas_main, mainvalue); 2971 sprintf_vma (vmas_start, vma_start); 2972 2973 _bfd_error_handler 2974 /* xgettext:c-format */ 2975 (_("%pB: bad symbol definition: `Main' set to %s rather" 2976 " than the start address %s\n"), 2977 abfd, vmas_main, vmas_start); 2978 bfd_set_error (bfd_error_bad_value); 2979 return FALSE; 2980 } 2981 break; 2982 } 2983 if (i == count && count != 0) 2984 { 2985 /* When there are symbols, there must be a :Main. There was no 2986 :Main, so we need to add it manually. */ 2987 memcpy (table + 1, orig_table, count * sizeof (asymbol *)); 2988 table[0] = fakemain; 2989 count++; 2990 } 2991 2992 /* Don't bother inspecting symbols in plugin dummy objects; their 2993 symbols aren't fully inspectable. */ 2994 if ((abfd->flags & BFD_PLUGIN) == 0) 2995 { 2996 for (i = 0, serno = 1; i < count && table[i] != NULL; i++) 2997 { 2998 asymbol *s = table[i]; 2999 3000 /* It's not enough to consult bfd_is_local_label, since it does not 3001 mean "local" in the sense of linkable-and-observable-after-link. 3002 Let's just check the BSF_GLOBAL flag. 3003 3004 Also, don't export symbols with characters not in the 3005 allowed set. */ 3006 if ((s->flags & (BSF_DEBUGGING|BSF_GLOBAL)) == BSF_GLOBAL 3007 && strspn (s->name, 3008 valid_mmo_symbol_character_set) == strlen (s->name)) 3009 { 3010 struct mmo_symbol sym; 3011 memset (&sym, 0, sizeof (sym)); 3012 3013 /* Need to strip const here; strdup:ing would leak and the 3014 existing string must be safe to reuse. */ 3015 sym.name = (char *) s->name; 3016 sym.value = 3017 s->value 3018 + s->section->output_section->vma 3019 + s->section->output_offset; 3020 3021 if (bfd_is_und_section (s->section)) 3022 sym.sym_type = mmo_undef_sym; 3023 else if (strcmp (s->section->name, MMO_DATA_SECTION_NAME) == 0 3024 /* The encoding of data symbols require that the "rest" 3025 of the value fits in 6 bytes, so the upper two bytes 3026 must be 0x2000. All other symbols get to be the 3027 absolute type. */ 3028 && (sym.value >> 48) == 0x2000) 3029 sym.sym_type = mmo_data_sym; 3030 else if (strcmp (s->section->name, MMIX_REG_SECTION_NAME) == 0) 3031 sym.sym_type = mmo_reg_sym; 3032 else if (strcmp (s->section->name, 3033 MMIX_REG_CONTENTS_SECTION_NAME) == 0) 3034 { 3035 sym.sym_type = mmo_reg_sym; 3036 sym.value /= 8; 3037 } 3038 else 3039 sym.sym_type = mmo_abs_sym; 3040 3041 /* FIXME: We assume the order of the received symbols is an 3042 ordered mapping of the serial numbers. This is not 3043 necessarily true if we e.g. objcopy a mmo file to another and 3044 there are gaps in the numbering. Not sure if this can 3045 happen. Not sure what to do. */ 3046 sym.serno = serno++; 3047 3048 if (! mmo_internal_add_3_sym (abfd, &root, &sym)) 3049 return FALSE; 3050 } 3051 } 3052 } 3053 3054 /* Change the root node to be a ":"-prefix. */ 3055 root.symchar = ':'; 3056 root.middle = root.left; 3057 root.right = NULL; 3058 root.left = NULL; 3059 3060 /* We have to find out if we can fit the whole symbol table in the mmo 3061 symtab. It would be bad to assume we can always fit it in 262144 3062 bytes. If we can't, just leave the Main symbol. */ 3063 trie_len = (mmo_internal_3_length (abfd, &root) + 3)/4; 3064 3065 if (trie_len > 0xffff) 3066 { 3067 /* Test this code by using a lower limit in the test above and check 3068 that the single "Main" symbol is emitted and handled properly. 3069 There's no specific test-case. */ 3070 struct mmo_symbol sym; 3071 3072 _bfd_error_handler 3073 /* xgettext:c-format */ 3074 (_("%pB: warning: symbol table too large for mmo, larger than 65535" 3075 " 32-bit words: %d. Only `Main' will be emitted.\n"), 3076 abfd, trie_len); 3077 3078 memset (&sym, 0, sizeof (sym)); 3079 sym.sym_type = mmo_abs_sym; 3080 sym.name = MMIX_START_SYMBOL_NAME; 3081 sym.serno = 1; 3082 sym.value = bfd_get_start_address (abfd); 3083 3084 /* Then patch up a symbol table to be just the ":Main" symbol. */ 3085 memset (&root, 0, sizeof (root)); 3086 root.left = root.middle; 3087 root.symchar = 0xff; 3088 root.middle = NULL; 3089 root.right = NULL; 3090 3091 if (! mmo_internal_add_3_sym (abfd, &root, &sym)) 3092 return FALSE; 3093 3094 root.symchar = ':'; 3095 root.middle = root.left; 3096 root.right = NULL; 3097 root.left = NULL; 3098 3099 trie_len = (mmo_internal_3_length (abfd, &root) + 3)/4; 3100 } 3101 3102 /* Reset the written-bytes counter. */ 3103 abfd->tdata.mmo_data->byte_no = 0; 3104 3105 /* Put out the lop_stab mark. */ 3106 bfd_put_32 (abfd, (LOP << 24) | (LOP_STAB << 16), buf); 3107 if (bfd_bwrite (buf, 4, abfd) != 4) 3108 return FALSE; 3109 3110 /* Dump out symbols. */ 3111 mmo_internal_3_dump (abfd, &root); 3112 3113 if (trie_len != (abfd->tdata.mmo_data->byte_no + 3)/4) 3114 { 3115 /* I haven't seen this trig. It seems no use claiming this case 3116 isn't debugged and abort if we get here. Instead emit a 3117 diagnostic and fail "normally". */ 3118 _bfd_error_handler 3119 /* xgettext:c-format */ 3120 (_("%pB: internal error, symbol table changed size from %d to %d" 3121 " words\n"), 3122 abfd, trie_len, 3123 (abfd->tdata.mmo_data->byte_no + 3)/4); 3124 bfd_set_error (bfd_error_bad_value); 3125 return FALSE; 3126 } 3127 3128 /* Dump out remaining bytes in the buffer and handle I/O errors by 3129 propagating errors. */ 3130 if ((abfd->tdata.mmo_data->byte_no % 4) != 0 3131 || abfd->tdata.mmo_data->have_error) 3132 { 3133 memset (abfd->tdata.mmo_data->buf + (abfd->tdata.mmo_data->byte_no % 4), 3134 0, 4 - (abfd->tdata.mmo_data->byte_no % 4)); 3135 3136 if (abfd->tdata.mmo_data->have_error 3137 || bfd_bwrite (abfd->tdata.mmo_data->buf, 4, abfd) != 4) 3138 return FALSE; 3139 } 3140 3141 bfd_put_32 (abfd, (LOP << 24) | (LOP_END << 16) | trie_len, buf); 3142 return bfd_bwrite (buf, 4, abfd) == 4; 3143 } 3144 3145 /* Write section unless it is the register contents section. For that, we 3146 instead store the section in the supplied pointer. This function is 3147 used through bfd_map_over_sections. */ 3148 3149 static void 3150 mmo_write_section_unless_reg_contents (bfd *abfd, asection *sec, void *p) 3151 { 3152 struct mmo_write_sec_info *infop = (struct mmo_write_sec_info *) p; 3153 3154 if (! infop->retval) 3155 return; 3156 3157 if (strcmp (sec->name, MMIX_REG_CONTENTS_SECTION_NAME) == 0) 3158 { 3159 infop->reg_section = sec; 3160 return; 3161 } 3162 3163 /* Exclude the convenience register section. */ 3164 if (strcmp (sec->name, MMIX_REG_SECTION_NAME) == 0) 3165 { 3166 if (bfd_section_flags (sec) & SEC_HAS_CONTENTS) 3167 { 3168 /* Make sure it hasn't got contents. It seems impossible to 3169 make it carry contents, so we don't have a test-case for 3170 this. */ 3171 _bfd_error_handler 3172 /* xgettext:c-format */ 3173 (_("%pB: internal error, internal register section %pA had" 3174 " contents\n"), 3175 abfd, sec); 3176 bfd_set_error (bfd_error_bad_value); 3177 infop->retval = FALSE; 3178 return; 3179 } 3180 3181 return; 3182 } 3183 3184 infop->retval = mmo_internal_write_section (abfd, sec); 3185 } 3186 3187 /* Do the actual output of a file. Assumes mmo_set_section_contents is 3188 already called. */ 3189 3190 static bfd_boolean 3191 mmo_write_object_contents (bfd *abfd) 3192 { 3193 struct mmo_write_sec_info wsecinfo; 3194 3195 /* First, there are a few words of preamble. */ 3196 if (! mmo_internal_write_header (abfd)) 3197 return FALSE; 3198 3199 wsecinfo.reg_section = NULL; 3200 wsecinfo.retval = TRUE; 3201 3202 bfd_map_over_sections (abfd, mmo_write_section_unless_reg_contents, 3203 &wsecinfo); 3204 3205 if (! wsecinfo.retval) 3206 return FALSE; 3207 3208 if (wsecinfo.reg_section != NULL) 3209 { 3210 asection *sec = wsecinfo.reg_section; 3211 unsigned int z = (unsigned int) (sec->vma / 8); 3212 3213 /* Registers 0..31 must not be global. Do sanity check on the "vma" 3214 of the register contents section and check that it corresponds to 3215 the length of the section. */ 3216 if (z < 32 || z >= 255 || (sec->vma & 7) != 0 3217 || sec->vma != 256 * 8 - sec->size - 8) 3218 { 3219 bfd_set_error (bfd_error_bad_value); 3220 3221 if (sec->size == 0) 3222 /* There must always be at least one such register. */ 3223 _bfd_error_handler 3224 (_("%pB: no initialized registers; section length 0\n"), 3225 abfd); 3226 else if (sec->vma > (256 - 32) * 8) 3227 /* Provide better error message for the case of too many 3228 global registers. */ 3229 _bfd_error_handler 3230 /* xgettext:c-format */ 3231 (_("%pB: too many initialized registers; section length %" PRId64), 3232 abfd, (int64_t) sec->size); 3233 else 3234 _bfd_error_handler 3235 /* xgettext:c-format */ 3236 (_("%pB: invalid start address for initialized registers of" 3237 " length %" PRId64 ": %#" PRIx64), 3238 abfd, (int64_t) sec->size, (uint64_t) sec->vma); 3239 3240 return FALSE; 3241 } 3242 3243 if (! mmo_internal_write_post (abfd, z, sec)) 3244 return FALSE; 3245 } 3246 else 3247 if (! mmo_internal_write_post (abfd, 255, NULL)) 3248 return FALSE; 3249 3250 return mmo_write_symbols_and_terminator (abfd); 3251 } 3252 3253 /* If there's anything in particular in a mmo bfd that we want to free, 3254 make this a real function. Only do this if you see major memory 3255 thrashing; zealous free:ing will cause unwanted behavior, especially if 3256 you "free" memory allocated with "bfd_alloc", or even "bfd_release" a 3257 block allocated with "bfd_alloc"; they're really allocated from an 3258 obstack, and we don't know what was allocated there since this 3259 particular allocation. */ 3260 3261 #define mmo_close_and_cleanup _bfd_generic_close_and_cleanup 3262 #define mmo_bfd_free_cached_info _bfd_generic_bfd_free_cached_info 3263 3264 /* Perhaps we need to adjust this one; mmo labels (originally) without a 3265 leading ':' might more appropriately be called local. */ 3266 #define mmo_bfd_is_local_label_name bfd_generic_is_local_label_name 3267 #define mmo_bfd_is_target_special_symbol _bfd_bool_bfd_asymbol_false 3268 3269 #define mmo_get_symbol_version_string \ 3270 _bfd_nosymbols_get_symbol_version_string 3271 3272 /* Is this one really used or defined by anyone? */ 3273 #define mmo_get_lineno _bfd_nosymbols_get_lineno 3274 3275 /* FIXME: We can do better on this one, if we have a dwarf2 .debug_line 3276 section or if MMO line numbers are implemented. */ 3277 #define mmo_find_nearest_line _bfd_nosymbols_find_nearest_line 3278 #define mmo_find_line _bfd_nosymbols_find_line 3279 #define mmo_find_inliner_info _bfd_nosymbols_find_inliner_info 3280 #define mmo_make_empty_symbol _bfd_generic_make_empty_symbol 3281 #define mmo_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol 3282 #define mmo_read_minisymbols _bfd_generic_read_minisymbols 3283 #define mmo_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol 3284 3285 #define mmo_get_section_contents_in_window \ 3286 _bfd_generic_get_section_contents_in_window 3287 #define mmo_bfd_get_relocated_section_contents \ 3288 bfd_generic_get_relocated_section_contents 3289 #define mmo_bfd_gc_sections bfd_generic_gc_sections 3290 #define mmo_bfd_lookup_section_flags bfd_generic_lookup_section_flags 3291 #define mmo_bfd_link_hash_table_create _bfd_generic_link_hash_table_create 3292 #define mmo_bfd_link_add_symbols _bfd_generic_link_add_symbols 3293 #define mmo_bfd_link_just_syms _bfd_generic_link_just_syms 3294 #define mmo_bfd_copy_link_hash_symbol_type \ 3295 _bfd_generic_copy_link_hash_symbol_type 3296 #define mmo_bfd_final_link _bfd_generic_final_link 3297 #define mmo_bfd_link_split_section _bfd_generic_link_split_section 3298 #define mmo_bfd_link_check_relocs _bfd_generic_link_check_relocs 3299 3300 /* Strictly speaking, only MMIX uses this restricted format, but let's not 3301 stop anybody from shooting themselves in the foot. */ 3302 #define mmo_set_arch_mach bfd_default_set_arch_mach 3303 #define mmo_bfd_relax_section bfd_generic_relax_section 3304 #define mmo_bfd_merge_sections bfd_generic_merge_sections 3305 #define mmo_bfd_is_group_section bfd_generic_is_group_section 3306 #define mmo_bfd_group_name bfd_generic_group_name 3307 #define mmo_bfd_discard_group bfd_generic_discard_group 3308 #define mmo_section_already_linked \ 3309 _bfd_generic_section_already_linked 3310 #define mmo_bfd_define_common_symbol bfd_generic_define_common_symbol 3311 #define mmo_bfd_link_hide_symbol _bfd_generic_link_hide_symbol 3312 #define mmo_bfd_define_start_stop bfd_generic_define_start_stop 3313 3314 /* We want to copy time of creation, otherwise we'd use 3315 BFD_JUMP_TABLE_COPY (_bfd_generic). */ 3316 #define mmo_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data 3317 #define mmo_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data 3318 #define mmo_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data 3319 #define mmo_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data 3320 #define mmo_bfd_set_private_flags _bfd_generic_bfd_set_private_flags 3321 #define mmo_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data 3322 3323 const bfd_target mmix_mmo_vec = 3324 { 3325 "mmo", /* name */ 3326 bfd_target_mmo_flavour, 3327 BFD_ENDIAN_BIG, /* target byte order */ 3328 BFD_ENDIAN_BIG, /* target headers byte order */ 3329 3330 /* FIXME: Might need adjustments. */ 3331 (HAS_RELOC | EXEC_P | /* object flags */ 3332 HAS_LINENO | HAS_DEBUG | 3333 HAS_SYMS | HAS_LOCALS | WP_TEXT), 3334 3335 /* FIXME: Might need adjustments. */ 3336 (SEC_CODE | SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD 3337 | SEC_READONLY | SEC_EXCLUDE | SEC_DEBUGGING | SEC_IN_MEMORY), 3338 /* section flags */ 3339 0, /* leading underscore */ 3340 ' ', /* ar_pad_char */ 3341 16, /* ar_max_namelen */ 3342 0, /* match priority. */ 3343 bfd_getb64, bfd_getb_signed_64, bfd_putb64, 3344 bfd_getb32, bfd_getb_signed_32, bfd_putb32, 3345 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */ 3346 bfd_getb64, bfd_getb_signed_64, bfd_putb64, 3347 bfd_getb32, bfd_getb_signed_32, bfd_putb32, 3348 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */ 3349 3350 { 3351 _bfd_dummy_target, 3352 mmo_object_p, /* bfd_check_format */ 3353 _bfd_dummy_target, 3354 _bfd_dummy_target, 3355 }, 3356 { 3357 _bfd_bool_bfd_false_error, 3358 mmo_mkobject, 3359 _bfd_bool_bfd_false_error, 3360 _bfd_bool_bfd_false_error, 3361 }, 3362 { /* bfd_write_contents */ 3363 _bfd_bool_bfd_false_error, 3364 mmo_write_object_contents, 3365 _bfd_bool_bfd_false_error, 3366 _bfd_bool_bfd_false_error, 3367 }, 3368 3369 BFD_JUMP_TABLE_GENERIC (mmo), 3370 BFD_JUMP_TABLE_COPY (mmo), 3371 BFD_JUMP_TABLE_CORE (_bfd_nocore), 3372 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive), 3373 BFD_JUMP_TABLE_SYMBOLS (mmo), 3374 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs), 3375 BFD_JUMP_TABLE_WRITE (mmo), 3376 BFD_JUMP_TABLE_LINK (mmo), 3377 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), 3378 3379 NULL, 3380 3381 NULL 3382 }; 3383