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