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