bfd/wasm-module.c

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