bfd/wasm-module.c

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