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 "bfd.h"
  30 #include "libiberty.h"
  31 #include "libbfd.h"
  32 #include "wasm-module.h"
  33
  34 #include <limits.h>
  35 #ifndef CHAR_BIT
  36 #define CHAR_BIT 8
  37 #endif
  38
  39 typedef struct
  40 {
  41   asymbol *      symbols;
  42   bfd_size_type  symcount;
  43 } tdata_type;
  44
  45 static const char * const wasm_numbered_sections[] =
  46 {
  47   NULL, /* Custom section, different layout.  */
  48   WASM_SECTION ( 1, "type"),
  49   WASM_SECTION ( 2, "import"),
  50   WASM_SECTION ( 3, "function"),
  51   WASM_SECTION ( 4, "table"),
  52   WASM_SECTION ( 5, "memory"),
  53   WASM_SECTION ( 6, "global"),
  54   WASM_SECTION ( 7, "export"),
  55   WASM_SECTION ( 8, "start"),
  56   WASM_SECTION ( 9, "element"),
  57   WASM_SECTION (10, "code"),
  58   WASM_SECTION (11, "data"),
  59 };
  60
  61 #define WASM_NUMBERED_SECTIONS ARRAY_SIZE (wasm_numbered_sections)
  62
  63 /* Resolve SECTION_CODE to a section name if there is one, NULL
  64    otherwise.  */
  65
  66 static const char *
  67 wasm_section_code_to_name (bfd_byte section_code)
  68 {
  69   if (section_code < WASM_NUMBERED_SECTIONS)
  70     return wasm_numbered_sections[section_code];
  71
  72   return NULL;
  73 }
  74
  75 /* Translate section name NAME to a section code, or 0 if it's a
  76    custom name.  */
  77
  78 static unsigned int
  79 wasm_section_name_to_code (const char *name)
  80 {
  81   unsigned i;
  82
  83   for (i = 1; i < WASM_NUMBERED_SECTIONS; i++)
  84     if (strcmp (name, wasm_numbered_sections[i]) == 0)
  85       return i;
  86
  87   return 0;
  88 }
  89
  90 /* WebAssembly LEB128 integers are sufficiently like DWARF LEB128
  91    integers that we use _bfd_safe_read_leb128, but there are two
  92    points of difference:
  93
  94    - WebAssembly requires a 32-bit value to be encoded in at most 5
  95      bytes, etc.
  96    - _bfd_safe_read_leb128 accepts incomplete LEB128 encodings at the
  97      end of the buffer, while these are invalid in WebAssembly.
  98
  99    Those differences mean that we will accept some files that are
 100    invalid WebAssembly.  */
 101
 102 /* Read an LEB128-encoded integer from ABFD's I/O stream, reading one
 103    byte at a time.  Set ERROR_RETURN if no complete integer could be
 104    read, LENGTH_RETURN to the number of bytes read (including bytes in
 105    incomplete numbers).  SIGN means interpret the number as SLEB128. */
 106
 107 static bfd_vma
 108 wasm_read_leb128 (bfd *abfd,
 109                   bool *error_return,
 110                   unsigned int *length_return,
 111                   bool sign)
 112 {
 113   bfd_vma result = 0;
 114   unsigned int num_read = 0;
 115   unsigned int shift = 0;
 116   unsigned char byte = 0;
 117   unsigned char lost, mask;
 118   int status = 1;
 119
 120   while (bfd_bread (&byte, 1, abfd) == 1)
 121     {
 122       num_read++;
 123
 124       if (shift < CHAR_BIT * sizeof (result))
 125         {
 126           result |= ((bfd_vma) (byte & 0x7f)) << shift;
 127           /* These bits overflowed.  */
 128           lost = byte ^ (result >> shift);
 129           /* And this is the mask of possible overflow bits.  */
 130           mask = 0x7f ^ ((bfd_vma) 0x7f << shift >> shift);
 131           shift += 7;
 132         }
 133       else
 134         {
 135           lost = byte;
 136           mask = 0x7f;
 137         }
 138       if ((lost & mask) != (sign && (bfd_signed_vma) result < 0 ? mask : 0))
 139         status |= 2;
 140
 141       if ((byte & 0x80) == 0)
 142         {
 143           status &= ~1;
 144           if (sign && shift < CHAR_BIT * sizeof (result) && (byte & 0x40))
 145             result |= -((bfd_vma) 1 << shift);
 146           break;
 147         }
 148     }
 149
 150   if (length_return != NULL)
 151     *length_return = num_read;
 152   if (error_return != NULL)
 153     *error_return = status != 0;
 154
 155   return result;
 156 }
 157
 158 /* Encode an integer V as LEB128 and write it to ABFD, return TRUE on
 159    success.  */
 160
 161 static bool
 162 wasm_write_uleb128 (bfd *abfd, bfd_vma v)
 163 {
 164   do
 165     {
 166       bfd_byte c = v & 0x7f;
 167       v >>= 7;
 168
 169       if (v)
 170         c |= 0x80;
 171
 172       if (bfd_bwrite (&c, 1, abfd) != 1)
 173         return false;
 174     }
 175   while (v);
 176
 177   return true;
 178 }
 179
 180 /* Read the LEB128 integer at P, saving it to X; at end of buffer,
 181    jump to error_return.  */
 182 #define READ_LEB128(x, p, end)                                          \
 183   do                                                                    \
 184     {                                                                   \
 185       if ((p) >= (end))                                                 \
 186         goto error_return;                                              \
 187       (x) = _bfd_safe_read_leb128 (abfd, &(p), false, (end));           \
 188     }                                                                   \
 189   while (0)
 190
 191 /* Verify the magic number at the beginning of a WebAssembly module
 192    ABFD, setting ERRORPTR if there's a mismatch.  */
 193
 194 static bool
 195 wasm_read_magic (bfd *abfd, bool *errorptr)
 196 {
 197   bfd_byte magic_const[SIZEOF_WASM_MAGIC] = WASM_MAGIC;
 198   bfd_byte magic[SIZEOF_WASM_MAGIC];
 199
 200   if (bfd_bread (magic, sizeof (magic), abfd) == sizeof (magic)
 201       && memcmp (magic, magic_const, sizeof (magic)) == 0)
 202     return true;
 203
 204   *errorptr = true;
 205   return false;
 206 }
 207
 208 /* Read the version number from ABFD, returning TRUE if it's a supported
 209    version. Set ERRORPTR otherwise.  */
 210
 211 static bool
 212 wasm_read_version (bfd *abfd, bool *errorptr)
 213 {
 214   bfd_byte vers_const[SIZEOF_WASM_VERSION] = WASM_VERSION;
 215   bfd_byte vers[SIZEOF_WASM_VERSION];
 216
 217   if (bfd_bread (vers, sizeof (vers), abfd) == sizeof (vers)
 218       /* Don't attempt to parse newer versions, which are likely to
 219          require code changes.  */
 220       && memcmp (vers, vers_const, sizeof (vers)) == 0)
 221     return true;
 222
 223   *errorptr = true;
 224   return false;
 225 }
 226
 227 /* Read the WebAssembly header (magic number plus version number) from
 228    ABFD, setting ERRORPTR to TRUE if there is a mismatch.  */
 229
 230 static bool
 231 wasm_read_header (bfd *abfd, bool *errorptr)
 232 {
 233   if (! wasm_read_magic (abfd, errorptr))
 234     return false;
 235
 236   if (! wasm_read_version (abfd, errorptr))
 237     return false;
 238
 239   return true;
 240 }
 241
 242 /* Scan the "function" subsection of the "name" section ASECT in the
 243    wasm module ABFD. Create symbols. Return TRUE on success.  */
 244
 245 static bool
 246 wasm_scan_name_function_section (bfd *abfd, sec_ptr asect)
 247 {
 248   bfd_byte *p;
 249   bfd_byte *end;
 250   bfd_vma payload_size;
 251   bfd_vma symcount = 0;
 252   tdata_type *tdata = abfd->tdata.any;
 253   asymbol *symbols = NULL;
 254   sec_ptr space_function_index;
 255   size_t amt;
 256
 257   p = asect->contents;
 258   end = asect->contents + asect->size;
 259
 260   if (!p)
 261     return false;
 262
 263   while (p < end)
 264     {
 265       bfd_byte subsection_code = *p++;
 266       if (subsection_code == WASM_FUNCTION_SUBSECTION)
 267         break;
 268
 269       /* subsection_code is documented to be a varuint7, meaning that
 270          it has to be a single byte in the 0 - 127 range.  If it isn't,
 271          the spec must have changed underneath us, so give up.  */
 272       if (subsection_code & 0x80)
 273         return false;
 274
 275       READ_LEB128 (payload_size, p, end);
 276
 277       if (payload_size > (size_t) (end - p))
 278         return false;
 279
 280       p += payload_size;
 281     }
 282
 283   if (p >= end)
 284     return false;
 285
 286   READ_LEB128 (payload_size, p, end);
 287
 288   if (payload_size > (size_t) (end - p))
 289     return false;
 290
 291   end = p + payload_size;
 292
 293   READ_LEB128 (symcount, p, end);
 294
 295   /* Sanity check: each symbol has at least two bytes.  */
 296   if (symcount > payload_size / 2)
 297     return false;
 298
 299   tdata->symcount = symcount;
 300
 301   space_function_index
 302     = bfd_make_section_with_flags (abfd, WASM_SECTION_FUNCTION_INDEX,
 303                                    SEC_READONLY | SEC_CODE);
 304
 305   if (!space_function_index)
 306     space_function_index
 307       = bfd_get_section_by_name (abfd, WASM_SECTION_FUNCTION_INDEX);
 308
 309   if (!space_function_index)
 310     return false;
 311
 312   if (_bfd_mul_overflow (tdata->symcount, sizeof (asymbol), &amt))
 313     {
 314       bfd_set_error (bfd_error_file_too_big);
 315       return false;
 316     }
 317   symbols = bfd_alloc (abfd, amt);
 318   if (!symbols)
 319     return false;
 320
 321   for (symcount = 0; p < end && symcount < tdata->symcount; symcount++)
 322     {
 323       bfd_vma idx;
 324       bfd_vma len;
 325       char *name;
 326       asymbol *sym;
 327
 328       READ_LEB128 (idx, p, end);
 329       READ_LEB128 (len, p, end);
 330
 331       if (len > (size_t) (end - p))
 332         goto error_return;
 333
 334       name = bfd_alloc (abfd, len + 1);
 335       if (!name)
 336         goto error_return;
 337
 338       memcpy (name, p, len);
 339       name[len] = 0;
 340       p += len;
 341
 342       sym = &symbols[symcount];
 343       sym->the_bfd = abfd;
 344       sym->name = name;
 345       sym->value = idx;
 346       sym->flags = BSF_GLOBAL | BSF_FUNCTION;
 347       sym->section = space_function_index;
 348       sym->udata.p = NULL;
 349     }
 350
 351   if (symcount < tdata->symcount)
 352     goto error_return;
 353
 354   tdata->symbols = symbols;
 355   abfd->symcount = symcount;
 356
 357   return true;
 358
 359  error_return:
 360   bfd_release (abfd, symbols);
 361   return false;
 362 }
 363
 364 /* Read a byte from ABFD and return it, or EOF for EOF or error.
 365    Set ERRORPTR on non-EOF error.  */
 366
 367 static int
 368 wasm_read_byte (bfd *abfd, bool *errorptr)
 369 {
 370   bfd_byte byte;
 371
 372   if (bfd_bread (&byte, (bfd_size_type) 1, abfd) != 1)
 373     {
 374       if (bfd_get_error () != bfd_error_file_truncated)
 375         *errorptr = true;
 376       return EOF;
 377     }
 378
 379   return byte;
 380 }
 381
 382 /* Scan the wasm module ABFD, creating sections and symbols.
 383    Return TRUE on success.  */
 384
 385 static bool
 386 wasm_scan (bfd *abfd)
 387 {
 388   bool error = false;
 389   /* Fake VMAs for now. Choose 0x80000000 as base to avoid clashes
 390      with actual data addresses.  */
 391   bfd_vma vma = 0x80000000;
 392   int section_code;
 393   unsigned int bytes_read;
 394   asection *bfdsec;
 395
 396   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
 397     goto error_return;
 398
 399   if (!wasm_read_header (abfd, &error))
 400     goto error_return;
 401
 402   while ((section_code = wasm_read_byte (abfd, &error)) != EOF)
 403     {
 404       if (section_code != 0)
 405         {
 406           const char *sname = wasm_section_code_to_name (section_code);
 407
 408           if (!sname)
 409             goto error_return;
 410
 411           bfdsec = bfd_make_section_anyway_with_flags (abfd, sname,
 412                                                        SEC_HAS_CONTENTS);
 413           if (bfdsec == NULL)
 414             goto error_return;
 415
 416           bfdsec->size = wasm_read_leb128 (abfd, &error, &bytes_read, false);
 417           if (error)
 418             goto error_return;
 419         }
 420       else
 421         {
 422           bfd_vma payload_len;
 423           bfd_vma namelen;
 424           char *name;
 425           char *prefix = WASM_SECTION_PREFIX;
 426           size_t prefixlen = strlen (prefix);
 427           ufile_ptr filesize;
 428
 429           payload_len = wasm_read_leb128 (abfd, &error, &bytes_read, false);
 430           if (error)
 431             goto error_return;
 432           namelen = wasm_read_leb128 (abfd, &error, &bytes_read, false);
 433           if (error || bytes_read > payload_len
 434               || namelen > payload_len - bytes_read)
 435             goto error_return;
 436           payload_len -= namelen + bytes_read;
 437           filesize = bfd_get_file_size (abfd);
 438           if (filesize != 0 && namelen > filesize)
 439             {
 440               bfd_set_error (bfd_error_file_truncated);
 441               return false;
 442             }
 443           name = bfd_alloc (abfd, namelen + prefixlen + 1);
 444           if (!name)
 445             goto error_return;
 446           memcpy (name, prefix, prefixlen);
 447           if (bfd_bread (name + prefixlen, namelen, abfd) != namelen)
 448             goto error_return;
 449           name[prefixlen + namelen] = 0;
 450
 451           bfdsec = bfd_make_section_anyway_with_flags (abfd, name,
 452                                                        SEC_HAS_CONTENTS);
 453           if (bfdsec == NULL)
 454             goto error_return;
 455
 456           bfdsec->size = payload_len;
 457         }
 458
 459       bfdsec->vma = vma;
 460       bfdsec->lma = vma;
 461       bfdsec->alignment_power = 0;
 462       bfdsec->filepos = bfd_tell (abfd);
 463       if (bfdsec->size != 0)
 464         {
 465           bfdsec->contents = _bfd_alloc_and_read (abfd, bfdsec->size,
 466                                                   bfdsec->size);
 467           if (!bfdsec->contents)
 468             goto error_return;
 469         }
 470
 471       vma += bfdsec->size;
 472     }
 473
 474   /* Make sure we're at actual EOF.  There's no indication in the
 475      WebAssembly format of how long the file is supposed to be.  */
 476   if (error)
 477     goto error_return;
 478
 479   return true;
 480
 481  error_return:
 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 idx = wasm_section_name_to_code (asect->name);
 495
 496   if (idx == 0)
 497     return;
 498
 499   numbered_sections[idx] = asect;
 500 }
 501
 502 struct compute_section_arg
 503 {
 504   bfd_vma pos;
 505   bool 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 idx;
 524
 525   if (fs->failed)
 526     return;
 527
 528   idx = wasm_section_name_to_code (asect->name);
 529
 530   if (idx != 0)
 531     return;
 532
 533   if (startswith (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 bool
 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 bool
 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 bool
 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 bool
 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   size_t 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 bfd_cleanup
 745 wasm_object_p (bfd *abfd)
 746 {
 747   bool error;
 748   asection *s;
 749
 750   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
 751     return NULL;
 752
 753   if (!wasm_read_header (abfd, &error))
 754     {
 755       bfd_set_error (bfd_error_wrong_format);
 756       return NULL;
 757     }
 758
 759   if (!wasm_mkobject (abfd))
 760     return NULL;
 761
 762   if (!wasm_scan (abfd)
 763       || !bfd_default_set_arch_mach (abfd, bfd_arch_wasm32, 0))
 764     {
 765       bfd_release (abfd, abfd->tdata.any);
 766       abfd->tdata.any = NULL;
 767       return NULL;
 768     }
 769
 770   s = bfd_get_section_by_name (abfd, WASM_NAME_SECTION);
 771   if (s != NULL && wasm_scan_name_function_section (abfd, s))
 772     abfd->flags |= HAS_SYMS;
 773
 774   return _bfd_no_cleanup;
 775 }
 776
 777 /* BFD_JUMP_TABLE_WRITE */
 778 #define wasm_set_arch_mach                _bfd_generic_set_arch_mach
 779
 780 /* BFD_JUMP_TABLE_SYMBOLS */
 781 #define wasm_get_symbol_version_string    _bfd_nosymbols_get_symbol_version_string
 782 #define wasm_bfd_is_local_label_name       bfd_generic_is_local_label_name
 783 #define wasm_bfd_is_target_special_symbol _bfd_bool_bfd_asymbol_false
 784 #define wasm_get_lineno                   _bfd_nosymbols_get_lineno
 785 #define wasm_find_nearest_line            _bfd_nosymbols_find_nearest_line
 786 #define wasm_find_line                    _bfd_nosymbols_find_line
 787 #define wasm_find_inliner_info            _bfd_nosymbols_find_inliner_info
 788 #define wasm_bfd_make_debug_symbol        _bfd_nosymbols_bfd_make_debug_symbol
 789 #define wasm_read_minisymbols             _bfd_generic_read_minisymbols
 790 #define wasm_minisymbol_to_symbol         _bfd_generic_minisymbol_to_symbol
 791
 792 const bfd_target wasm_vec =
 793 {
 794   "wasm",                       /* Name.  */
 795   bfd_target_unknown_flavour,
 796   BFD_ENDIAN_LITTLE,
 797   BFD_ENDIAN_LITTLE,
 798   (HAS_SYMS | WP_TEXT),         /* Object flags.  */
 799   (SEC_CODE | SEC_DATA | SEC_HAS_CONTENTS), /* Section flags.  */
 800   0,                            /* Leading underscore.  */
 801   ' ',                          /* AR_pad_char.  */
 802   255,                          /* AR_max_namelen.  */
 803   0,                            /* Match priority.  */
 804   TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols.  */
 805   /* Routines to byte-swap various sized integers from the data sections.  */
 806   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 807   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 808   bfd_getl16, bfd_getl_signed_16, bfd_putl16,
 809
 810   /* Routines to byte-swap various sized integers from the file headers.  */
 811   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 812   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 813   bfd_getl16, bfd_getl_signed_16, bfd_putl16,
 814
 815   {
 816     _bfd_dummy_target,
 817     wasm_object_p,              /* bfd_check_format.  */
 818     _bfd_dummy_target,
 819     _bfd_dummy_target,
 820   },
 821   {
 822     _bfd_bool_bfd_false_error,
 823     wasm_mkobject,
 824     _bfd_generic_mkarchive,
 825     _bfd_bool_bfd_false_error,
 826   },
 827   {                             /* bfd_write_contents.  */
 828     _bfd_bool_bfd_false_error,
 829     wasm_write_object_contents,
 830     _bfd_write_archive_contents,
 831     _bfd_bool_bfd_false_error,
 832   },
 833
 834   BFD_JUMP_TABLE_GENERIC (_bfd_generic),
 835   BFD_JUMP_TABLE_COPY (_bfd_generic),
 836   BFD_JUMP_TABLE_CORE (_bfd_nocore),
 837   BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
 838   BFD_JUMP_TABLE_SYMBOLS (wasm),
 839   BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
 840   BFD_JUMP_TABLE_WRITE (wasm),
 841   BFD_JUMP_TABLE_LINK (_bfd_nolink),
 842   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 843
 844   NULL,
 845
 846   NULL,
 847 };