bfd/wasm-module.c

   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   size_t amt;
 249
 250   p = asect->contents;
 251   end = asect->contents + asect->size;
 252
 253   if (!p)
 254     return FALSE;
 255
 256   while (p < end)
 257     {
 258       bfd_byte subsection_code = *p++;
 259       if (subsection_code == WASM_FUNCTION_SUBSECTION)
 260         break;
 261
 262       /* subsection_code is documented to be a varuint7, meaning that
 263          it has to be a single byte in the 0 - 127 range.  If it isn't,
 264          the spec must have changed underneath us, so give up.  */
 265       if (subsection_code & 0x80)
 266         return FALSE;
 267
 268       READ_LEB128 (payload_size, p, end);
 269
 270       if (payload_size > (size_t) (end - p))
 271         return FALSE;
 272
 273       p += payload_size;
 274     }
 275
 276   if (p >= end)
 277     return FALSE;
 278
 279   READ_LEB128 (payload_size, p, end);
 280
 281   if (payload_size > (size_t) (end - p))
 282     return FALSE;
 283
 284   end = p + payload_size;
 285
 286   READ_LEB128 (symcount, p, end);
 287
 288   /* Sanity check: each symbol has at least two bytes.  */
 289   if (symcount > payload_size / 2)
 290     return FALSE;
 291
 292   tdata->symcount = symcount;
 293
 294   space_function_index
 295     = bfd_make_section_with_flags (abfd, WASM_SECTION_FUNCTION_INDEX,
 296                                    SEC_READONLY | SEC_CODE);
 297
 298   if (!space_function_index)
 299     space_function_index
 300       = bfd_get_section_by_name (abfd, WASM_SECTION_FUNCTION_INDEX);
 301
 302   if (!space_function_index)
 303     return FALSE;
 304
 305   if (_bfd_mul_overflow (tdata->symcount, sizeof (asymbol), &amt))
 306     {
 307       bfd_set_error (bfd_error_file_too_big);
 308       return FALSE;
 309     }
 310   symbols = bfd_alloc (abfd, amt);
 311   if (!symbols)
 312     return FALSE;
 313
 314   for (symcount = 0; p < end && symcount < tdata->symcount; symcount++)
 315     {
 316       bfd_vma idx;
 317       bfd_vma len;
 318       char *name;
 319       asymbol *sym;
 320
 321       READ_LEB128 (idx, p, end);
 322       READ_LEB128 (len, p, end);
 323
 324       if (len > (size_t) (end - p))
 325         goto error_return;
 326
 327       name = bfd_alloc (abfd, len + 1);
 328       if (!name)
 329         goto error_return;
 330
 331       memcpy (name, p, len);
 332       name[len] = 0;
 333       p += len;
 334
 335       sym = &symbols[symcount];
 336       sym->the_bfd = abfd;
 337       sym->name = name;
 338       sym->value = idx;
 339       sym->flags = BSF_GLOBAL | BSF_FUNCTION;
 340       sym->section = space_function_index;
 341       sym->udata.p = NULL;
 342     }
 343
 344   if (symcount < tdata->symcount)
 345     goto error_return;
 346
 347   tdata->symbols = symbols;
 348   abfd->symcount = symcount;
 349
 350   return TRUE;
 351
 352  error_return:
 353   bfd_release (abfd, symbols);
 354   return FALSE;
 355 }
 356
 357 /* Read a byte from ABFD and return it, or EOF for EOF or error.
 358    Set ERRORPTR on non-EOF error.  */
 359
 360 static int
 361 wasm_read_byte (bfd *abfd, bfd_boolean *errorptr)
 362 {
 363   bfd_byte byte;
 364
 365   if (bfd_bread (&byte, (bfd_size_type) 1, abfd) != 1)
 366     {
 367       if (bfd_get_error () != bfd_error_file_truncated)
 368         *errorptr = TRUE;
 369       return EOF;
 370     }
 371
 372   return byte;
 373 }
 374
 375 /* Scan the wasm module ABFD, creating sections and symbols.
 376    Return TRUE on success.  */
 377
 378 static bfd_boolean
 379 wasm_scan (bfd *abfd)
 380 {
 381   bfd_boolean error = FALSE;
 382   /* Fake VMAs for now. Choose 0x80000000 as base to avoid clashes
 383      with actual data addresses.  */
 384   bfd_vma vma = 0x80000000;
 385   int section_code;
 386   unsigned int bytes_read;
 387   asection *bfdsec;
 388
 389   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
 390     goto error_return;
 391
 392   if (!wasm_read_header (abfd, &error))
 393     goto error_return;
 394
 395   while ((section_code = wasm_read_byte (abfd, &error)) != EOF)
 396     {
 397       if (section_code != 0)
 398         {
 399           const char *sname = wasm_section_code_to_name (section_code);
 400
 401           if (!sname)
 402             goto error_return;
 403
 404           bfdsec = bfd_make_section_anyway_with_flags (abfd, sname,
 405                                                        SEC_HAS_CONTENTS);
 406           if (bfdsec == NULL)
 407             goto error_return;
 408
 409           bfdsec->vma = vma;
 410           bfdsec->lma = vma;
 411           bfdsec->size = wasm_read_leb128 (abfd, &error, &bytes_read, FALSE);
 412           if (error)
 413             goto error_return;
 414           bfdsec->filepos = bfd_tell (abfd);
 415           bfdsec->alignment_power = 0;
 416         }
 417       else
 418         {
 419           bfd_vma payload_len;
 420           file_ptr section_start;
 421           bfd_vma namelen;
 422           char *name;
 423           char *prefix = WASM_SECTION_PREFIX;
 424           size_t prefixlen = strlen (prefix);
 425
 426           payload_len = wasm_read_leb128 (abfd, &error, &bytes_read, FALSE);
 427           if (error)
 428             goto error_return;
 429           section_start = bfd_tell (abfd);
 430           namelen = wasm_read_leb128 (abfd, &error, &bytes_read, FALSE);
 431           if (error || namelen > payload_len)
 432             goto error_return;
 433           name = bfd_alloc (abfd, namelen + prefixlen + 1);
 434           if (!name)
 435             goto error_return;
 436           memcpy (name, prefix, prefixlen);
 437           if (bfd_bread (name + prefixlen, namelen, abfd) != namelen)
 438             goto error_return;
 439           name[prefixlen + namelen] = 0;
 440
 441           bfdsec = bfd_make_section_anyway_with_flags (abfd, name,
 442                                                        SEC_HAS_CONTENTS);
 443           if (bfdsec == NULL)
 444             goto error_return;
 445
 446           bfdsec->vma = vma;
 447           bfdsec->lma = vma;
 448           bfdsec->filepos = bfd_tell (abfd);
 449           bfdsec->size = section_start + payload_len - bfdsec->filepos;
 450           bfdsec->alignment_power = 0;
 451         }
 452
 453       if (bfdsec->size != 0)
 454         {
 455           bfdsec->contents = bfd_alloc (abfd, bfdsec->size);
 456           if (!bfdsec->contents)
 457             goto error_return;
 458
 459           if (bfd_bread (bfdsec->contents, bfdsec->size, abfd) != bfdsec->size)
 460             goto error_return;
 461         }
 462
 463       vma += bfdsec->size;
 464     }
 465
 466   /* Make sure we're at actual EOF.  There's no indication in the
 467      WebAssembly format of how long the file is supposed to be.  */
 468   if (error)
 469     goto error_return;
 470
 471   return TRUE;
 472
 473  error_return:
 474   return FALSE;
 475 }
 476
 477 /* Put a numbered section ASECT of ABFD into the table of numbered
 478    sections pointed to by FSARG.  */
 479
 480 static void
 481 wasm_register_section (bfd *abfd ATTRIBUTE_UNUSED,
 482                        asection *asect,
 483                        void *fsarg)
 484 {
 485   sec_ptr *numbered_sections = fsarg;
 486   int idx = wasm_section_name_to_code (asect->name);
 487
 488   if (idx == 0)
 489     return;
 490
 491   numbered_sections[idx] = asect;
 492 }
 493
 494 struct compute_section_arg
 495 {
 496   bfd_vma pos;
 497   bfd_boolean failed;
 498 };
 499
 500 /* Compute the file position of ABFD's section ASECT.  FSARG is a
 501    pointer to the current file position.
 502
 503    We allow section names of the form .wasm.id to encode the numbered
 504    section with ID id, if it exists; otherwise, a custom section with
 505    ID "id" is produced.  Arbitrary section names are for sections that
 506    are assumed already to contain a section header; those are appended
 507    to the WebAssembly module verbatim.  */
 508
 509 static void
 510 wasm_compute_custom_section_file_position (bfd *abfd,
 511                                            sec_ptr asect,
 512                                            void *fsarg)
 513 {
 514   struct compute_section_arg *fs = fsarg;
 515   int idx;
 516
 517   if (fs->failed)
 518     return;
 519
 520   idx = wasm_section_name_to_code (asect->name);
 521
 522   if (idx != 0)
 523     return;
 524
 525   if (CONST_STRNEQ (asect->name, WASM_SECTION_PREFIX))
 526     {
 527       const char *name = asect->name + strlen (WASM_SECTION_PREFIX);
 528       bfd_size_type payload_len = asect->size;
 529       bfd_size_type name_len = strlen (name);
 530       bfd_size_type nl = name_len;
 531
 532       payload_len += name_len;
 533
 534       do
 535         {
 536           payload_len++;
 537           nl >>= 7;
 538         }
 539       while (nl);
 540
 541       bfd_seek (abfd, fs->pos, SEEK_SET);
 542       if (! wasm_write_uleb128 (abfd, 0)
 543           || ! wasm_write_uleb128 (abfd, payload_len)
 544           || ! wasm_write_uleb128 (abfd, name_len)
 545           || bfd_bwrite (name, name_len, abfd) != name_len)
 546         goto error_return;
 547       fs->pos = asect->filepos = bfd_tell (abfd);
 548     }
 549   else
 550     {
 551       asect->filepos = fs->pos;
 552     }
 553
 554
 555   fs->pos += asect->size;
 556   return;
 557
 558  error_return:
 559   fs->failed = TRUE;
 560 }
 561
 562 /* Compute the file positions for the sections of ABFD.  Currently,
 563    this writes all numbered sections first, in order, then all custom
 564    sections, in section order.
 565
 566    The spec says that the numbered sections must appear in order of
 567    their ids, but custom sections can appear in any position and any
 568    order, and more than once. FIXME: support that.  */
 569
 570 static bfd_boolean
 571 wasm_compute_section_file_positions (bfd *abfd)
 572 {
 573   bfd_byte magic[SIZEOF_WASM_MAGIC] = WASM_MAGIC;
 574   bfd_byte vers[SIZEOF_WASM_VERSION] = WASM_VERSION;
 575   sec_ptr numbered_sections[WASM_NUMBERED_SECTIONS];
 576   struct compute_section_arg fs;
 577   unsigned int i;
 578
 579   bfd_seek (abfd, (bfd_vma) 0, SEEK_SET);
 580
 581   if (bfd_bwrite (magic, sizeof (magic), abfd) != (sizeof magic)
 582       || bfd_bwrite (vers, sizeof (vers), abfd) != sizeof (vers))
 583     return FALSE;
 584
 585   for (i = 0; i < WASM_NUMBERED_SECTIONS; i++)
 586     numbered_sections[i] = NULL;
 587
 588   bfd_map_over_sections (abfd, wasm_register_section, numbered_sections);
 589
 590   fs.pos = bfd_tell (abfd);
 591   for (i = 0; i < WASM_NUMBERED_SECTIONS; i++)
 592     {
 593       sec_ptr sec = numbered_sections[i];
 594       bfd_size_type size;
 595
 596       if (! sec)
 597         continue;
 598       size = sec->size;
 599       if (bfd_seek (abfd, fs.pos, SEEK_SET) != 0)
 600         return FALSE;
 601       if (! wasm_write_uleb128 (abfd, i)
 602           || ! wasm_write_uleb128 (abfd, size))
 603         return FALSE;
 604       fs.pos = sec->filepos = bfd_tell (abfd);
 605       fs.pos += size;
 606     }
 607
 608   fs.failed = FALSE;
 609
 610   bfd_map_over_sections (abfd, wasm_compute_custom_section_file_position, &fs);
 611
 612   if (fs.failed)
 613     return FALSE;
 614
 615   abfd->output_has_begun = TRUE;
 616
 617   return TRUE;
 618 }
 619
 620 static bfd_boolean
 621 wasm_set_section_contents (bfd *abfd,
 622                            sec_ptr section,
 623                            const void *location,
 624                            file_ptr offset,
 625                            bfd_size_type count)
 626 {
 627   if (count == 0)
 628     return TRUE;
 629
 630   if (! abfd->output_has_begun
 631       && ! wasm_compute_section_file_positions (abfd))
 632     return FALSE;
 633
 634   if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
 635       || bfd_bwrite (location, count, abfd) != count)
 636     return FALSE;
 637
 638   return TRUE;
 639 }
 640
 641 static bfd_boolean
 642 wasm_write_object_contents (bfd* abfd)
 643 {
 644   bfd_byte magic[] = WASM_MAGIC;
 645   bfd_byte vers[] = WASM_VERSION;
 646
 647   if (bfd_seek (abfd, 0, SEEK_SET) != 0)
 648     return FALSE;
 649
 650   if (bfd_bwrite (magic, sizeof (magic), abfd) != sizeof (magic)
 651       || bfd_bwrite (vers, sizeof (vers), abfd) != sizeof (vers))
 652     return FALSE;
 653
 654   return TRUE;
 655 }
 656
 657 static bfd_boolean
 658 wasm_mkobject (bfd *abfd)
 659 {
 660   tdata_type *tdata = (tdata_type *) bfd_alloc (abfd, sizeof (tdata_type));
 661
 662   if (! tdata)
 663     return FALSE;
 664
 665   tdata->symbols = NULL;
 666   tdata->symcount = 0;
 667
 668   abfd->tdata.any = tdata;
 669
 670   return TRUE;
 671 }
 672
 673 static long
 674 wasm_get_symtab_upper_bound (bfd *abfd)
 675 {
 676   tdata_type *tdata = abfd->tdata.any;
 677
 678   return (tdata->symcount + 1) * (sizeof (asymbol *));
 679 }
 680
 681 static long
 682 wasm_canonicalize_symtab (bfd *abfd, asymbol **alocation)
 683 {
 684   tdata_type *tdata = abfd->tdata.any;
 685   size_t i;
 686
 687   for (i = 0; i < tdata->symcount; i++)
 688     alocation[i] = &tdata->symbols[i];
 689   alocation[i] = NULL;
 690
 691   return tdata->symcount;
 692 }
 693
 694 static asymbol *
 695 wasm_make_empty_symbol (bfd *abfd)
 696 {
 697   size_t amt = sizeof (asymbol);
 698   asymbol *new_symbol = (asymbol *) bfd_zalloc (abfd, amt);
 699
 700   if (! new_symbol)
 701     return NULL;
 702   new_symbol->the_bfd = abfd;
 703   return new_symbol;
 704 }
 705
 706 static void
 707 wasm_print_symbol (bfd *abfd,
 708                    void * filep,
 709                    asymbol *symbol,
 710                    bfd_print_symbol_type how)
 711 {
 712   FILE *file = (FILE *) filep;
 713
 714   switch (how)
 715     {
 716     case bfd_print_symbol_name:
 717       fprintf (file, "%s", symbol->name);
 718       break;
 719
 720     default:
 721       bfd_print_symbol_vandf (abfd, filep, symbol);
 722       fprintf (file, " %-5s %s", symbol->section->name, symbol->name);
 723     }
 724 }
 725
 726 static void
 727 wasm_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
 728                       asymbol *symbol,
 729                       symbol_info *ret)
 730 {
 731   bfd_symbol_info (symbol, ret);
 732 }
 733
 734 /* Check whether ABFD is a WebAssembly module; if so, scan it.  */
 735
 736 static const bfd_target *
 737 wasm_object_p (bfd *abfd)
 738 {
 739   bfd_boolean error;
 740   asection *s;
 741
 742   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
 743     return NULL;
 744
 745   if (!wasm_read_header (abfd, &error))
 746     {
 747       bfd_set_error (bfd_error_wrong_format);
 748       return NULL;
 749     }
 750
 751   if (!wasm_mkobject (abfd))
 752     return NULL;
 753
 754   if (!wasm_scan (abfd)
 755       || !bfd_default_set_arch_mach (abfd, bfd_arch_wasm32, 0))
 756     {
 757       bfd_release (abfd, abfd->tdata.any);
 758       abfd->tdata.any = NULL;
 759       return NULL;
 760     }
 761
 762   s = bfd_get_section_by_name (abfd, WASM_NAME_SECTION);
 763   if (s != NULL && wasm_scan_name_function_section (abfd, s))
 764     abfd->flags |= HAS_SYMS;
 765
 766   return abfd->xvec;
 767 }
 768
 769 /* BFD_JUMP_TABLE_WRITE */
 770 #define wasm_set_arch_mach                _bfd_generic_set_arch_mach
 771
 772 /* BFD_JUMP_TABLE_SYMBOLS */
 773 #define wasm_get_symbol_version_string    _bfd_nosymbols_get_symbol_version_string
 774 #define wasm_bfd_is_local_label_name       bfd_generic_is_local_label_name
 775 #define wasm_bfd_is_target_special_symbol _bfd_bool_bfd_asymbol_false
 776 #define wasm_get_lineno                   _bfd_nosymbols_get_lineno
 777 #define wasm_find_nearest_line            _bfd_nosymbols_find_nearest_line
 778 #define wasm_find_line                    _bfd_nosymbols_find_line
 779 #define wasm_find_inliner_info            _bfd_nosymbols_find_inliner_info
 780 #define wasm_bfd_make_debug_symbol        _bfd_nosymbols_bfd_make_debug_symbol
 781 #define wasm_read_minisymbols             _bfd_generic_read_minisymbols
 782 #define wasm_minisymbol_to_symbol         _bfd_generic_minisymbol_to_symbol
 783
 784 const bfd_target wasm_vec =
 785 {
 786   "wasm",                       /* Name.  */
 787   bfd_target_unknown_flavour,
 788   BFD_ENDIAN_LITTLE,
 789   BFD_ENDIAN_LITTLE,
 790   (HAS_SYMS | WP_TEXT),         /* Object flags.  */
 791   (SEC_CODE | SEC_DATA | SEC_HAS_CONTENTS), /* Section flags.  */
 792   0,                            /* Leading underscore.  */
 793   ' ',                          /* AR_pad_char.  */
 794   255,                          /* AR_max_namelen.  */
 795   0,                            /* Match priority.  */
 796   /* Routines to byte-swap various sized integers from the data sections.  */
 797   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 798   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 799   bfd_getl16, bfd_getl_signed_16, bfd_putl16,
 800
 801   /* Routines to byte-swap various sized integers from the file headers.  */
 802   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 803   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 804   bfd_getl16, bfd_getl_signed_16, bfd_putl16,
 805
 806   {
 807     _bfd_dummy_target,
 808     wasm_object_p,              /* bfd_check_format.  */
 809     _bfd_dummy_target,
 810     _bfd_dummy_target,
 811   },
 812   {
 813     _bfd_bool_bfd_false_error,
 814     wasm_mkobject,
 815     _bfd_generic_mkarchive,
 816     _bfd_bool_bfd_false_error,
 817   },
 818   {                             /* bfd_write_contents.  */
 819     _bfd_bool_bfd_false_error,
 820     wasm_write_object_contents,
 821     _bfd_write_archive_contents,
 822     _bfd_bool_bfd_false_error,
 823   },
 824
 825   BFD_JUMP_TABLE_GENERIC (_bfd_generic),
 826   BFD_JUMP_TABLE_COPY (_bfd_generic),
 827   BFD_JUMP_TABLE_CORE (_bfd_nocore),
 828   BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
 829   BFD_JUMP_TABLE_SYMBOLS (wasm),
 830   BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
 831   BFD_JUMP_TABLE_WRITE (wasm),
 832   BFD_JUMP_TABLE_LINK (_bfd_nolink),
 833   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 834
 835   NULL,
 836
 837   NULL,
 838 };