bfd/wasm-module.c

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