bfd/wasm-module.c

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