1 /* BFD back-end for WebAssembly modules. 2 Copyright (C) 2017-2020 Free Software Foundation, Inc. 3 4 Based on srec.c, mmo.c, and binary.c 5 6 This file is part of BFD, the Binary File Descriptor library. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 21 MA 02110-1301, USA. */ 22 23 /* The WebAssembly module format is a simple object file format 24 including up to 11 numbered sections, plus any number of named 25 "custom" sections. It is described at: 26 https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md. */ 27 28 #include "sysdep.h" 29 #include "alloca-conf.h" 30 #include "bfd.h" 31 #include <limits.h> 32 #include "libiberty.h" 33 #include "libbfd.h" 34 #include "wasm-module.h" 35 36 typedef struct 37 { 38 asymbol * symbols; 39 bfd_size_type symcount; 40 } tdata_type; 41 42 static const char * const wasm_numbered_sections[] = 43 { 44 NULL, /* Custom section, different layout. */ 45 WASM_SECTION ( 1, "type"), 46 WASM_SECTION ( 2, "import"), 47 WASM_SECTION ( 3, "function"), 48 WASM_SECTION ( 4, "table"), 49 WASM_SECTION ( 5, "memory"), 50 WASM_SECTION ( 6, "global"), 51 WASM_SECTION ( 7, "export"), 52 WASM_SECTION ( 8, "start"), 53 WASM_SECTION ( 9, "element"), 54 WASM_SECTION (10, "code"), 55 WASM_SECTION (11, "data"), 56 }; 57 58 #define WASM_NUMBERED_SECTIONS ARRAY_SIZE (wasm_numbered_sections) 59 60 /* Resolve SECTION_CODE to a section name if there is one, NULL 61 otherwise. */ 62 63 static const char * 64 wasm_section_code_to_name (bfd_byte section_code) 65 { 66 if (section_code < WASM_NUMBERED_SECTIONS) 67 return wasm_numbered_sections[section_code]; 68 69 return NULL; 70 } 71 72 /* Translate section name NAME to a section code, or 0 if it's a 73 custom name. */ 74 75 static unsigned int 76 wasm_section_name_to_code (const char *name) 77 { 78 unsigned i; 79 80 for (i = 1; i < WASM_NUMBERED_SECTIONS; i++) 81 if (strcmp (name, wasm_numbered_sections[i]) == 0) 82 return i; 83 84 return 0; 85 } 86 87 /* WebAssembly LEB128 integers are sufficiently like DWARF LEB128 88 integers that we use _bfd_safe_read_leb128, but there are two 89 points of difference: 90 91 - WebAssembly requires a 32-bit value to be encoded in at most 5 92 bytes, etc. 93 - _bfd_safe_read_leb128 accepts incomplete LEB128 encodings at the 94 end of the buffer, while these are invalid in WebAssembly. 95 96 Those differences mean that we will accept some files that are 97 invalid WebAssembly. */ 98 99 /* Read an LEB128-encoded integer from ABFD's I/O stream, reading one 100 byte at a time. Set ERROR_RETURN if no complete integer could be 101 read, LENGTH_RETURN to the number of bytes read (including bytes in 102 incomplete numbers). SIGN means interpret the number as SLEB128. */ 103 104 static bfd_vma 105 wasm_read_leb128 (bfd * abfd, 106 bfd_boolean * error_return, 107 unsigned int * length_return, 108 bfd_boolean sign) 109 { 110 bfd_vma result = 0; 111 unsigned int num_read = 0; 112 unsigned int shift = 0; 113 unsigned char byte = 0; 114 int status = 1; 115 116 while (bfd_bread (&byte, 1, abfd) == 1) 117 { 118 num_read++; 119 120 if (shift < sizeof (result) * 8) 121 { 122 result |= ((bfd_vma) (byte & 0x7f)) << shift; 123 if ((result >> shift) != (byte & 0x7f)) 124 /* Overflow. */ 125 status |= 2; 126 shift += 7; 127 } 128 else if ((byte & 0x7f) != 0) 129 status |= 2; 130 131 if ((byte & 0x80) == 0) 132 { 133 status &= ~1; 134 if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40)) 135 result |= -((bfd_vma) 1 << shift); 136 break; 137 } 138 } 139 140 if (length_return != NULL) 141 *length_return = num_read; 142 if (error_return != NULL) 143 *error_return = status != 0; 144 145 return result; 146 } 147 148 /* Encode an integer V as LEB128 and write it to ABFD, return TRUE on 149 success. */ 150 151 static bfd_boolean 152 wasm_write_uleb128 (bfd *abfd, bfd_vma v) 153 { 154 do 155 { 156 bfd_byte c = v & 0x7f; 157 v >>= 7; 158 159 if (v) 160 c |= 0x80; 161 162 if (bfd_bwrite (&c, 1, abfd) != 1) 163 return FALSE; 164 } 165 while (v); 166 167 return TRUE; 168 } 169 170 /* Read the LEB128 integer at P, saving it to X; at end of buffer, 171 jump to error_return. */ 172 #define READ_LEB128(x, p, end) \ 173 do \ 174 { \ 175 unsigned int length_read; \ 176 (x) = _bfd_safe_read_leb128 (abfd, (p), &length_read, \ 177 FALSE, (end)); \ 178 (p) += length_read; \ 179 if (length_read == 0) \ 180 goto error_return; \ 181 } \ 182 while (0) 183 184 /* Verify the magic number at the beginning of a WebAssembly module 185 ABFD, setting ERRORPTR if there's a mismatch. */ 186 187 static bfd_boolean 188 wasm_read_magic (bfd *abfd, bfd_boolean *errorptr) 189 { 190 bfd_byte magic_const[SIZEOF_WASM_MAGIC] = WASM_MAGIC; 191 bfd_byte magic[SIZEOF_WASM_MAGIC]; 192 193 if (bfd_bread (magic, sizeof (magic), abfd) == sizeof (magic) 194 && memcmp (magic, magic_const, sizeof (magic)) == 0) 195 return TRUE; 196 197 *errorptr = TRUE; 198 return FALSE; 199 } 200 201 /* Read the version number from ABFD, returning TRUE if it's a supported 202 version. Set ERRORPTR otherwise. */ 203 204 static bfd_boolean 205 wasm_read_version (bfd *abfd, bfd_boolean *errorptr) 206 { 207 bfd_byte vers_const[SIZEOF_WASM_VERSION] = WASM_VERSION; 208 bfd_byte vers[SIZEOF_WASM_VERSION]; 209 210 if (bfd_bread (vers, sizeof (vers), abfd) == sizeof (vers) 211 /* Don't attempt to parse newer versions, which are likely to 212 require code changes. */ 213 && memcmp (vers, vers_const, sizeof (vers)) == 0) 214 return TRUE; 215 216 *errorptr = TRUE; 217 return FALSE; 218 } 219 220 /* Read the WebAssembly header (magic number plus version number) from 221 ABFD, setting ERRORPTR to TRUE if there is a mismatch. */ 222 223 static bfd_boolean 224 wasm_read_header (bfd *abfd, bfd_boolean *errorptr) 225 { 226 if (! wasm_read_magic (abfd, errorptr)) 227 return FALSE; 228 229 if (! wasm_read_version (abfd, errorptr)) 230 return FALSE; 231 232 return TRUE; 233 } 234 235 /* Scan the "function" subsection of the "name" section ASECT in the 236 wasm module ABFD. Create symbols. Return TRUE on success. */ 237 238 static bfd_boolean 239 wasm_scan_name_function_section (bfd *abfd, sec_ptr asect) 240 { 241 bfd_byte *p; 242 bfd_byte *end; 243 bfd_vma payload_size; 244 bfd_vma symcount = 0; 245 tdata_type *tdata = abfd->tdata.any; 246 asymbol *symbols = NULL; 247 sec_ptr space_function_index; 248 249 p = asect->contents; 250 end = asect->contents + asect->size; 251 252 if (!p) 253 return FALSE; 254 255 while (p < end) 256 { 257 bfd_byte subsection_code = *p++; 258 if (subsection_code == WASM_FUNCTION_SUBSECTION) 259 break; 260 261 /* subsection_code is documented to be a varuint7, meaning that 262 it has to be a single byte in the 0 - 127 range. If it isn't, 263 the spec must have changed underneath us, so give up. */ 264 if (subsection_code & 0x80) 265 return FALSE; 266 267 READ_LEB128 (payload_size, p, end); 268 269 if (payload_size > (size_t) (end - p)) 270 return FALSE; 271 272 p += payload_size; 273 } 274 275 if (p >= end) 276 return FALSE; 277 278 READ_LEB128 (payload_size, p, end); 279 280 if (payload_size > (size_t) (end - p)) 281 return FALSE; 282 283 end = p + payload_size; 284 285 READ_LEB128 (symcount, p, end); 286 287 /* Sanity check: each symbol has at least two bytes. */ 288 if (symcount > payload_size / 2) 289 return FALSE; 290 291 tdata->symcount = symcount; 292 293 space_function_index 294 = bfd_make_section_with_flags (abfd, WASM_SECTION_FUNCTION_INDEX, 295 SEC_READONLY | SEC_CODE); 296 297 if (!space_function_index) 298 space_function_index 299 = bfd_get_section_by_name (abfd, WASM_SECTION_FUNCTION_INDEX); 300 301 if (!space_function_index) 302 return FALSE; 303 304 symbols = bfd_alloc2 (abfd, tdata->symcount, sizeof (asymbol)); 305 if (!symbols) 306 return FALSE; 307 308 for (symcount = 0; p < end && symcount < tdata->symcount; symcount++) 309 { 310 bfd_vma idx; 311 bfd_vma len; 312 char *name; 313 asymbol *sym; 314 315 READ_LEB128 (idx, p, end); 316 READ_LEB128 (len, p, end); 317 318 if (len > (size_t) (end - p)) 319 goto error_return; 320 321 name = bfd_alloc (abfd, len + 1); 322 if (!name) 323 goto error_return; 324 325 memcpy (name, p, len); 326 name[len] = 0; 327 p += len; 328 329 sym = &symbols[symcount]; 330 sym->the_bfd = abfd; 331 sym->name = name; 332 sym->value = idx; 333 sym->flags = BSF_GLOBAL | BSF_FUNCTION; 334 sym->section = space_function_index; 335 sym->udata.p = NULL; 336 } 337 338 if (symcount < tdata->symcount) 339 goto error_return; 340 341 tdata->symbols = symbols; 342 abfd->symcount = symcount; 343 344 return TRUE; 345 346 error_return: 347 bfd_release (abfd, symbols); 348 return FALSE; 349 } 350 351 /* Read a byte from ABFD and return it, or EOF for EOF or error. 352 Set ERRORPTR on non-EOF error. */ 353 354 static int 355 wasm_read_byte (bfd *abfd, bfd_boolean *errorptr) 356 { 357 bfd_byte byte; 358 359 if (bfd_bread (&byte, (bfd_size_type) 1, abfd) != 1) 360 { 361 if (bfd_get_error () != bfd_error_file_truncated) 362 *errorptr = TRUE; 363 return EOF; 364 } 365 366 return byte; 367 } 368 369 /* Scan the wasm module ABFD, creating sections and symbols. 370 Return TRUE on success. */ 371 372 static bfd_boolean 373 wasm_scan (bfd *abfd) 374 { 375 bfd_boolean error = FALSE; 376 /* Fake VMAs for now. Choose 0x80000000 as base to avoid clashes 377 with actual data addresses. */ 378 bfd_vma vma = 0x80000000; 379 int section_code; 380 unsigned int bytes_read; 381 asection *bfdsec; 382 383 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) 384 goto error_return; 385 386 if (!wasm_read_header (abfd, &error)) 387 goto error_return; 388 389 while ((section_code = wasm_read_byte (abfd, &error)) != EOF) 390 { 391 if (section_code != 0) 392 { 393 const char *sname = wasm_section_code_to_name (section_code); 394 395 if (!sname) 396 goto error_return; 397 398 bfdsec = bfd_make_section_anyway_with_flags (abfd, sname, 399 SEC_HAS_CONTENTS); 400 if (bfdsec == NULL) 401 goto error_return; 402 403 bfdsec->vma = vma; 404 bfdsec->lma = vma; 405 bfdsec->size = wasm_read_leb128 (abfd, &error, &bytes_read, FALSE); 406 if (error) 407 goto error_return; 408 bfdsec->filepos = bfd_tell (abfd); 409 bfdsec->alignment_power = 0; 410 } 411 else 412 { 413 bfd_vma payload_len; 414 file_ptr section_start; 415 bfd_vma namelen; 416 char *name; 417 char *prefix = WASM_SECTION_PREFIX; 418 size_t prefixlen = strlen (prefix); 419 420 payload_len = wasm_read_leb128 (abfd, &error, &bytes_read, FALSE); 421 if (error) 422 goto error_return; 423 section_start = bfd_tell (abfd); 424 namelen = wasm_read_leb128 (abfd, &error, &bytes_read, FALSE); 425 if (error || namelen > payload_len) 426 goto error_return; 427 name = bfd_alloc (abfd, namelen + prefixlen + 1); 428 if (!name) 429 goto error_return; 430 memcpy (name, prefix, prefixlen); 431 if (bfd_bread (name + prefixlen, namelen, abfd) != namelen) 432 goto error_return; 433 name[prefixlen + namelen] = 0; 434 435 bfdsec = bfd_make_section_anyway_with_flags (abfd, name, 436 SEC_HAS_CONTENTS); 437 if (bfdsec == NULL) 438 goto error_return; 439 440 bfdsec->vma = vma; 441 bfdsec->lma = vma; 442 bfdsec->filepos = bfd_tell (abfd); 443 bfdsec->size = section_start + payload_len - bfdsec->filepos; 444 bfdsec->alignment_power = 0; 445 } 446 447 if (bfdsec->size != 0) 448 { 449 bfdsec->contents = bfd_alloc (abfd, bfdsec->size); 450 if (!bfdsec->contents) 451 goto error_return; 452 453 if (bfd_bread (bfdsec->contents, bfdsec->size, abfd) != bfdsec->size) 454 goto error_return; 455 } 456 457 vma += bfdsec->size; 458 } 459 460 /* Make sure we're at actual EOF. There's no indication in the 461 WebAssembly format of how long the file is supposed to be. */ 462 if (error) 463 goto error_return; 464 465 return TRUE; 466 467 error_return: 468 return FALSE; 469 } 470 471 /* Put a numbered section ASECT of ABFD into the table of numbered 472 sections pointed to by FSARG. */ 473 474 static void 475 wasm_register_section (bfd *abfd ATTRIBUTE_UNUSED, 476 asection *asect, 477 void *fsarg) 478 { 479 sec_ptr *numbered_sections = fsarg; 480 int idx = wasm_section_name_to_code (asect->name); 481 482 if (idx == 0) 483 return; 484 485 numbered_sections[idx] = asect; 486 } 487 488 struct compute_section_arg 489 { 490 bfd_vma pos; 491 bfd_boolean failed; 492 }; 493 494 /* Compute the file position of ABFD's section ASECT. FSARG is a 495 pointer to the current file position. 496 497 We allow section names of the form .wasm.id to encode the numbered 498 section with ID id, if it exists; otherwise, a custom section with 499 ID "id" is produced. Arbitrary section names are for sections that 500 are assumed already to contain a section header; those are appended 501 to the WebAssembly module verbatim. */ 502 503 static void 504 wasm_compute_custom_section_file_position (bfd *abfd, 505 sec_ptr asect, 506 void *fsarg) 507 { 508 struct compute_section_arg *fs = fsarg; 509 int idx; 510 511 if (fs->failed) 512 return; 513 514 idx = wasm_section_name_to_code (asect->name); 515 516 if (idx != 0) 517 return; 518 519 if (CONST_STRNEQ (asect->name, WASM_SECTION_PREFIX)) 520 { 521 const char *name = asect->name + strlen (WASM_SECTION_PREFIX); 522 bfd_size_type payload_len = asect->size; 523 bfd_size_type name_len = strlen (name); 524 bfd_size_type nl = name_len; 525 526 payload_len += name_len; 527 528 do 529 { 530 payload_len++; 531 nl >>= 7; 532 } 533 while (nl); 534 535 bfd_seek (abfd, fs->pos, SEEK_SET); 536 if (! wasm_write_uleb128 (abfd, 0) 537 || ! wasm_write_uleb128 (abfd, payload_len) 538 || ! wasm_write_uleb128 (abfd, name_len) 539 || bfd_bwrite (name, name_len, abfd) != name_len) 540 goto error_return; 541 fs->pos = asect->filepos = bfd_tell (abfd); 542 } 543 else 544 { 545 asect->filepos = fs->pos; 546 } 547 548 549 fs->pos += asect->size; 550 return; 551 552 error_return: 553 fs->failed = TRUE; 554 } 555 556 /* Compute the file positions for the sections of ABFD. Currently, 557 this writes all numbered sections first, in order, then all custom 558 sections, in section order. 559 560 The spec says that the numbered sections must appear in order of 561 their ids, but custom sections can appear in any position and any 562 order, and more than once. FIXME: support that. */ 563 564 static bfd_boolean 565 wasm_compute_section_file_positions (bfd *abfd) 566 { 567 bfd_byte magic[SIZEOF_WASM_MAGIC] = WASM_MAGIC; 568 bfd_byte vers[SIZEOF_WASM_VERSION] = WASM_VERSION; 569 sec_ptr numbered_sections[WASM_NUMBERED_SECTIONS]; 570 struct compute_section_arg fs; 571 unsigned int i; 572 573 bfd_seek (abfd, (bfd_vma) 0, SEEK_SET); 574 575 if (bfd_bwrite (magic, sizeof (magic), abfd) != (sizeof magic) 576 || bfd_bwrite (vers, sizeof (vers), abfd) != sizeof (vers)) 577 return FALSE; 578 579 for (i = 0; i < WASM_NUMBERED_SECTIONS; i++) 580 numbered_sections[i] = NULL; 581 582 bfd_map_over_sections (abfd, wasm_register_section, numbered_sections); 583 584 fs.pos = bfd_tell (abfd); 585 for (i = 0; i < WASM_NUMBERED_SECTIONS; i++) 586 { 587 sec_ptr sec = numbered_sections[i]; 588 bfd_size_type size; 589 590 if (! sec) 591 continue; 592 size = sec->size; 593 if (bfd_seek (abfd, fs.pos, SEEK_SET) != 0) 594 return FALSE; 595 if (! wasm_write_uleb128 (abfd, i) 596 || ! wasm_write_uleb128 (abfd, size)) 597 return FALSE; 598 fs.pos = sec->filepos = bfd_tell (abfd); 599 fs.pos += size; 600 } 601 602 fs.failed = FALSE; 603 604 bfd_map_over_sections (abfd, wasm_compute_custom_section_file_position, &fs); 605 606 if (fs.failed) 607 return FALSE; 608 609 abfd->output_has_begun = TRUE; 610 611 return TRUE; 612 } 613 614 static bfd_boolean 615 wasm_set_section_contents (bfd *abfd, 616 sec_ptr section, 617 const void *location, 618 file_ptr offset, 619 bfd_size_type count) 620 { 621 if (count == 0) 622 return TRUE; 623 624 if (! abfd->output_has_begun 625 && ! wasm_compute_section_file_positions (abfd)) 626 return FALSE; 627 628 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0 629 || bfd_bwrite (location, count, abfd) != count) 630 return FALSE; 631 632 return TRUE; 633 } 634 635 static bfd_boolean 636 wasm_write_object_contents (bfd* abfd) 637 { 638 bfd_byte magic[] = WASM_MAGIC; 639 bfd_byte vers[] = WASM_VERSION; 640 641 if (bfd_seek (abfd, 0, SEEK_SET) != 0) 642 return FALSE; 643 644 if (bfd_bwrite (magic, sizeof (magic), abfd) != sizeof (magic) 645 || bfd_bwrite (vers, sizeof (vers), abfd) != sizeof (vers)) 646 return FALSE; 647 648 return TRUE; 649 } 650 651 static bfd_boolean 652 wasm_mkobject (bfd *abfd) 653 { 654 tdata_type *tdata = (tdata_type *) bfd_alloc (abfd, sizeof (tdata_type)); 655 656 if (! tdata) 657 return FALSE; 658 659 tdata->symbols = NULL; 660 tdata->symcount = 0; 661 662 abfd->tdata.any = tdata; 663 664 return TRUE; 665 } 666 667 static long 668 wasm_get_symtab_upper_bound (bfd *abfd) 669 { 670 tdata_type *tdata = abfd->tdata.any; 671 672 return (tdata->symcount + 1) * (sizeof (asymbol *)); 673 } 674 675 static long 676 wasm_canonicalize_symtab (bfd *abfd, asymbol **alocation) 677 { 678 tdata_type *tdata = abfd->tdata.any; 679 size_t i; 680 681 for (i = 0; i < tdata->symcount; i++) 682 alocation[i] = &tdata->symbols[i]; 683 alocation[i] = NULL; 684 685 return tdata->symcount; 686 } 687 688 static asymbol * 689 wasm_make_empty_symbol (bfd *abfd) 690 { 691 bfd_size_type amt = sizeof (asymbol); 692 asymbol *new_symbol = (asymbol *) bfd_zalloc (abfd, amt); 693 694 if (! new_symbol) 695 return NULL; 696 new_symbol->the_bfd = abfd; 697 return new_symbol; 698 } 699 700 static void 701 wasm_print_symbol (bfd *abfd, 702 void * filep, 703 asymbol *symbol, 704 bfd_print_symbol_type how) 705 { 706 FILE *file = (FILE *) filep; 707 708 switch (how) 709 { 710 case bfd_print_symbol_name: 711 fprintf (file, "%s", symbol->name); 712 break; 713 714 default: 715 bfd_print_symbol_vandf (abfd, filep, symbol); 716 fprintf (file, " %-5s %s", symbol->section->name, symbol->name); 717 } 718 } 719 720 static void 721 wasm_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED, 722 asymbol *symbol, 723 symbol_info *ret) 724 { 725 bfd_symbol_info (symbol, ret); 726 } 727 728 /* Check whether ABFD is a WebAssembly module; if so, scan it. */ 729 730 static const bfd_target * 731 wasm_object_p (bfd *abfd) 732 { 733 bfd_boolean error; 734 asection *s; 735 736 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) 737 return NULL; 738 739 if (!wasm_read_header (abfd, &error)) 740 { 741 bfd_set_error (bfd_error_wrong_format); 742 return NULL; 743 } 744 745 if (!wasm_mkobject (abfd)) 746 return NULL; 747 748 if (!wasm_scan (abfd) 749 || !bfd_default_set_arch_mach (abfd, bfd_arch_wasm32, 0)) 750 { 751 bfd_release (abfd, abfd->tdata.any); 752 abfd->tdata.any = NULL; 753 return NULL; 754 } 755 756 s = bfd_get_section_by_name (abfd, WASM_NAME_SECTION); 757 if (s != NULL && wasm_scan_name_function_section (abfd, s)) 758 abfd->flags |= HAS_SYMS; 759 760 return abfd->xvec; 761 } 762 763 /* BFD_JUMP_TABLE_WRITE */ 764 #define wasm_set_arch_mach _bfd_generic_set_arch_mach 765 766 /* BFD_JUMP_TABLE_SYMBOLS */ 767 #define wasm_get_symbol_version_string _bfd_nosymbols_get_symbol_version_string 768 #define wasm_bfd_is_local_label_name bfd_generic_is_local_label_name 769 #define wasm_bfd_is_target_special_symbol _bfd_bool_bfd_asymbol_false 770 #define wasm_get_lineno _bfd_nosymbols_get_lineno 771 #define wasm_find_nearest_line _bfd_nosymbols_find_nearest_line 772 #define wasm_find_line _bfd_nosymbols_find_line 773 #define wasm_find_inliner_info _bfd_nosymbols_find_inliner_info 774 #define wasm_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol 775 #define wasm_read_minisymbols _bfd_generic_read_minisymbols 776 #define wasm_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol 777 778 const bfd_target wasm_vec = 779 { 780 "wasm", /* Name. */ 781 bfd_target_unknown_flavour, 782 BFD_ENDIAN_LITTLE, 783 BFD_ENDIAN_LITTLE, 784 (HAS_SYMS | WP_TEXT), /* Object flags. */ 785 (SEC_CODE | SEC_DATA | SEC_HAS_CONTENTS), /* Section flags. */ 786 0, /* Leading underscore. */ 787 ' ', /* AR_pad_char. */ 788 255, /* AR_max_namelen. */ 789 0, /* Match priority. */ 790 /* Routines to byte-swap various sized integers from the data sections. */ 791 bfd_getl64, bfd_getl_signed_64, bfd_putl64, 792 bfd_getl32, bfd_getl_signed_32, bfd_putl32, 793 bfd_getl16, bfd_getl_signed_16, bfd_putl16, 794 795 /* Routines to byte-swap various sized integers from the file headers. */ 796 bfd_getl64, bfd_getl_signed_64, bfd_putl64, 797 bfd_getl32, bfd_getl_signed_32, bfd_putl32, 798 bfd_getl16, bfd_getl_signed_16, bfd_putl16, 799 800 { 801 _bfd_dummy_target, 802 wasm_object_p, /* bfd_check_format. */ 803 _bfd_dummy_target, 804 _bfd_dummy_target, 805 }, 806 { 807 _bfd_bool_bfd_false_error, 808 wasm_mkobject, 809 _bfd_generic_mkarchive, 810 _bfd_bool_bfd_false_error, 811 }, 812 { /* bfd_write_contents. */ 813 _bfd_bool_bfd_false_error, 814 wasm_write_object_contents, 815 _bfd_write_archive_contents, 816 _bfd_bool_bfd_false_error, 817 }, 818 819 BFD_JUMP_TABLE_GENERIC (_bfd_generic), 820 BFD_JUMP_TABLE_COPY (_bfd_generic), 821 BFD_JUMP_TABLE_CORE (_bfd_nocore), 822 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive), 823 BFD_JUMP_TABLE_SYMBOLS (wasm), 824 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs), 825 BFD_JUMP_TABLE_WRITE (wasm), 826 BFD_JUMP_TABLE_LINK (_bfd_nolink), 827 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), 828 829 NULL, 830 831 NULL, 832 }; 833