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