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