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_and_read (abfd, bfdsec->size,
 456                                                   bfdsec->size);
 457           if (!bfdsec->contents)
 458             goto error_return;
 459         }
 460
 461       vma += bfdsec->size;
 462     }
 463
 464   /* Make sure we're at actual EOF.  There's no indication in the
 465      WebAssembly format of how long the file is supposed to be.  */
 466   if (error)
 467     goto error_return;
 468
 469   return TRUE;
 470
 471  error_return:
 472   return FALSE;
 473 }
 474
 475 /* Put a numbered section ASECT of ABFD into the table of numbered
 476    sections pointed to by FSARG.  */
 477
 478 static void
 479 wasm_register_section (bfd *abfd ATTRIBUTE_UNUSED,
 480                        asection *asect,
 481                        void *fsarg)
 482 {
 483   sec_ptr *numbered_sections = fsarg;
 484   int idx = wasm_section_name_to_code (asect->name);
 485
 486   if (idx == 0)
 487     return;
 488
 489   numbered_sections[idx] = asect;
 490 }
 491
 492 struct compute_section_arg
 493 {
 494   bfd_vma pos;
 495   bfd_boolean failed;
 496 };
 497
 498 /* Compute the file position of ABFD's section ASECT.  FSARG is a
 499    pointer to the current file position.
 500
 501    We allow section names of the form .wasm.id to encode the numbered
 502    section with ID id, if it exists; otherwise, a custom section with
 503    ID "id" is produced.  Arbitrary section names are for sections that
 504    are assumed already to contain a section header; those are appended
 505    to the WebAssembly module verbatim.  */
 506
 507 static void
 508 wasm_compute_custom_section_file_position (bfd *abfd,
 509                                            sec_ptr asect,
 510                                            void *fsarg)
 511 {
 512   struct compute_section_arg *fs = fsarg;
 513   int idx;
 514
 515   if (fs->failed)
 516     return;
 517
 518   idx = wasm_section_name_to_code (asect->name);
 519
 520   if (idx != 0)
 521     return;
 522
 523   if (CONST_STRNEQ (asect->name, WASM_SECTION_PREFIX))
 524     {
 525       const char *name = asect->name + strlen (WASM_SECTION_PREFIX);
 526       bfd_size_type payload_len = asect->size;
 527       bfd_size_type name_len = strlen (name);
 528       bfd_size_type nl = name_len;
 529
 530       payload_len += name_len;
 531
 532       do
 533         {
 534           payload_len++;
 535           nl >>= 7;
 536         }
 537       while (nl);
 538
 539       bfd_seek (abfd, fs->pos, SEEK_SET);
 540       if (! wasm_write_uleb128 (abfd, 0)
 541           || ! wasm_write_uleb128 (abfd, payload_len)
 542           || ! wasm_write_uleb128 (abfd, name_len)
 543           || bfd_bwrite (name, name_len, abfd) != name_len)
 544         goto error_return;
 545       fs->pos = asect->filepos = bfd_tell (abfd);
 546     }
 547   else
 548     {
 549       asect->filepos = fs->pos;
 550     }
 551
 552
 553   fs->pos += asect->size;
 554   return;
 555
 556  error_return:
 557   fs->failed = TRUE;
 558 }
 559
 560 /* Compute the file positions for the sections of ABFD.  Currently,
 561    this writes all numbered sections first, in order, then all custom
 562    sections, in section order.
 563
 564    The spec says that the numbered sections must appear in order of
 565    their ids, but custom sections can appear in any position and any
 566    order, and more than once. FIXME: support that.  */
 567
 568 static bfd_boolean
 569 wasm_compute_section_file_positions (bfd *abfd)
 570 {
 571   bfd_byte magic[SIZEOF_WASM_MAGIC] = WASM_MAGIC;
 572   bfd_byte vers[SIZEOF_WASM_VERSION] = WASM_VERSION;
 573   sec_ptr numbered_sections[WASM_NUMBERED_SECTIONS];
 574   struct compute_section_arg fs;
 575   unsigned int i;
 576
 577   bfd_seek (abfd, (bfd_vma) 0, SEEK_SET);
 578
 579   if (bfd_bwrite (magic, sizeof (magic), abfd) != (sizeof magic)
 580       || bfd_bwrite (vers, sizeof (vers), abfd) != sizeof (vers))
 581     return FALSE;
 582
 583   for (i = 0; i < WASM_NUMBERED_SECTIONS; i++)
 584     numbered_sections[i] = NULL;
 585
 586   bfd_map_over_sections (abfd, wasm_register_section, numbered_sections);
 587
 588   fs.pos = bfd_tell (abfd);
 589   for (i = 0; i < WASM_NUMBERED_SECTIONS; i++)
 590     {
 591       sec_ptr sec = numbered_sections[i];
 592       bfd_size_type size;
 593
 594       if (! sec)
 595         continue;
 596       size = sec->size;
 597       if (bfd_seek (abfd, fs.pos, SEEK_SET) != 0)
 598         return FALSE;
 599       if (! wasm_write_uleb128 (abfd, i)
 600           || ! wasm_write_uleb128 (abfd, size))
 601         return FALSE;
 602       fs.pos = sec->filepos = bfd_tell (abfd);
 603       fs.pos += size;
 604     }
 605
 606   fs.failed = FALSE;
 607
 608   bfd_map_over_sections (abfd, wasm_compute_custom_section_file_position, &fs);
 609
 610   if (fs.failed)
 611     return FALSE;
 612
 613   abfd->output_has_begun = TRUE;
 614
 615   return TRUE;
 616 }
 617
 618 static bfd_boolean
 619 wasm_set_section_contents (bfd *abfd,
 620                            sec_ptr section,
 621                            const void *location,
 622                            file_ptr offset,
 623                            bfd_size_type count)
 624 {
 625   if (count == 0)
 626     return TRUE;
 627
 628   if (! abfd->output_has_begun
 629       && ! wasm_compute_section_file_positions (abfd))
 630     return FALSE;
 631
 632   if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
 633       || bfd_bwrite (location, count, abfd) != count)
 634     return FALSE;
 635
 636   return TRUE;
 637 }
 638
 639 static bfd_boolean
 640 wasm_write_object_contents (bfd* abfd)
 641 {
 642   bfd_byte magic[] = WASM_MAGIC;
 643   bfd_byte vers[] = WASM_VERSION;
 644
 645   if (bfd_seek (abfd, 0, SEEK_SET) != 0)
 646     return FALSE;
 647
 648   if (bfd_bwrite (magic, sizeof (magic), abfd) != sizeof (magic)
 649       || bfd_bwrite (vers, sizeof (vers), abfd) != sizeof (vers))
 650     return FALSE;
 651
 652   return TRUE;
 653 }
 654
 655 static bfd_boolean
 656 wasm_mkobject (bfd *abfd)
 657 {
 658   tdata_type *tdata = (tdata_type *) bfd_alloc (abfd, sizeof (tdata_type));
 659
 660   if (! tdata)
 661     return FALSE;
 662
 663   tdata->symbols = NULL;
 664   tdata->symcount = 0;
 665
 666   abfd->tdata.any = tdata;
 667
 668   return TRUE;
 669 }
 670
 671 static long
 672 wasm_get_symtab_upper_bound (bfd *abfd)
 673 {
 674   tdata_type *tdata = abfd->tdata.any;
 675
 676   return (tdata->symcount + 1) * (sizeof (asymbol *));
 677 }
 678
 679 static long
 680 wasm_canonicalize_symtab (bfd *abfd, asymbol **alocation)
 681 {
 682   tdata_type *tdata = abfd->tdata.any;
 683   size_t i;
 684
 685   for (i = 0; i < tdata->symcount; i++)
 686     alocation[i] = &tdata->symbols[i];
 687   alocation[i] = NULL;
 688
 689   return tdata->symcount;
 690 }
 691
 692 static asymbol *
 693 wasm_make_empty_symbol (bfd *abfd)
 694 {
 695   size_t amt = sizeof (asymbol);
 696   asymbol *new_symbol = (asymbol *) bfd_zalloc (abfd, amt);
 697
 698   if (! new_symbol)
 699     return NULL;
 700   new_symbol->the_bfd = abfd;
 701   return new_symbol;
 702 }
 703
 704 static void
 705 wasm_print_symbol (bfd *abfd,
 706                    void * filep,
 707                    asymbol *symbol,
 708                    bfd_print_symbol_type how)
 709 {
 710   FILE *file = (FILE *) filep;
 711
 712   switch (how)
 713     {
 714     case bfd_print_symbol_name:
 715       fprintf (file, "%s", symbol->name);
 716       break;
 717
 718     default:
 719       bfd_print_symbol_vandf (abfd, filep, symbol);
 720       fprintf (file, " %-5s %s", symbol->section->name, symbol->name);
 721     }
 722 }
 723
 724 static void
 725 wasm_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
 726                       asymbol *symbol,
 727                       symbol_info *ret)
 728 {
 729   bfd_symbol_info (symbol, ret);
 730 }
 731
 732 /* Check whether ABFD is a WebAssembly module; if so, scan it.  */
 733
 734 static bfd_cleanup
 735 wasm_object_p (bfd *abfd)
 736 {
 737   bfd_boolean error;
 738   asection *s;
 739
 740   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
 741     return NULL;
 742
 743   if (!wasm_read_header (abfd, &error))
 744     {
 745       bfd_set_error (bfd_error_wrong_format);
 746       return NULL;
 747     }
 748
 749   if (!wasm_mkobject (abfd))
 750     return NULL;
 751
 752   if (!wasm_scan (abfd)
 753       || !bfd_default_set_arch_mach (abfd, bfd_arch_wasm32, 0))
 754     {
 755       bfd_release (abfd, abfd->tdata.any);
 756       abfd->tdata.any = NULL;
 757       return NULL;
 758     }
 759
 760   s = bfd_get_section_by_name (abfd, WASM_NAME_SECTION);
 761   if (s != NULL && wasm_scan_name_function_section (abfd, s))
 762     abfd->flags |= HAS_SYMS;
 763
 764   return _bfd_no_cleanup;
 765 }
 766
 767 /* BFD_JUMP_TABLE_WRITE */
 768 #define wasm_set_arch_mach                _bfd_generic_set_arch_mach
 769
 770 /* BFD_JUMP_TABLE_SYMBOLS */
 771 #define wasm_get_symbol_version_string    _bfd_nosymbols_get_symbol_version_string
 772 #define wasm_bfd_is_local_label_name       bfd_generic_is_local_label_name
 773 #define wasm_bfd_is_target_special_symbol _bfd_bool_bfd_asymbol_false
 774 #define wasm_get_lineno                   _bfd_nosymbols_get_lineno
 775 #define wasm_find_nearest_line            _bfd_nosymbols_find_nearest_line
 776 #define wasm_find_line                    _bfd_nosymbols_find_line
 777 #define wasm_find_inliner_info            _bfd_nosymbols_find_inliner_info
 778 #define wasm_bfd_make_debug_symbol        _bfd_nosymbols_bfd_make_debug_symbol
 779 #define wasm_read_minisymbols             _bfd_generic_read_minisymbols
 780 #define wasm_minisymbol_to_symbol         _bfd_generic_minisymbol_to_symbol
 781
 782 const bfd_target wasm_vec =
 783 {
 784   "wasm",                       /* Name.  */
 785   bfd_target_unknown_flavour,
 786   BFD_ENDIAN_LITTLE,
 787   BFD_ENDIAN_LITTLE,
 788   (HAS_SYMS | WP_TEXT),         /* Object flags.  */
 789   (SEC_CODE | SEC_DATA | SEC_HAS_CONTENTS), /* Section flags.  */
 790   0,                            /* Leading underscore.  */
 791   ' ',                          /* AR_pad_char.  */
 792   255,                          /* AR_max_namelen.  */
 793   0,                            /* Match priority.  */
 794   /* Routines to byte-swap various sized integers from the data sections.  */
 795   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 796   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 797   bfd_getl16, bfd_getl_signed_16, bfd_putl16,
 798
 799   /* Routines to byte-swap various sized integers from the file headers.  */
 800   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 801   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 802   bfd_getl16, bfd_getl_signed_16, bfd_putl16,
 803
 804   {
 805     _bfd_dummy_target,
 806     wasm_object_p,              /* bfd_check_format.  */
 807     _bfd_dummy_target,
 808     _bfd_dummy_target,
 809   },
 810   {
 811     _bfd_bool_bfd_false_error,
 812     wasm_mkobject,
 813     _bfd_generic_mkarchive,
 814     _bfd_bool_bfd_false_error,
 815   },
 816   {                             /* bfd_write_contents.  */
 817     _bfd_bool_bfd_false_error,
 818     wasm_write_object_contents,
 819     _bfd_write_archive_contents,
 820     _bfd_bool_bfd_false_error,
 821   },
 822
 823   BFD_JUMP_TABLE_GENERIC (_bfd_generic),
 824   BFD_JUMP_TABLE_COPY (_bfd_generic),
 825   BFD_JUMP_TABLE_CORE (_bfd_nocore),
 826   BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
 827   BFD_JUMP_TABLE_SYMBOLS (wasm),
 828   BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
 829   BFD_JUMP_TABLE_WRITE (wasm),
 830   BFD_JUMP_TABLE_LINK (_bfd_nolink),
 831   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 832
 833   NULL,
 834
 835   NULL,
 836 };