1 /* BFD back-end for WebAssembly modules.
2 Copyright (C) 2017-2021 Free Software Foundation, Inc.
4 Based on srec.c, mmo.c, and binary.c
6 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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. */
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. */
29 #include "alloca-conf.h"
31 #include "libiberty.h"
33 #include "wasm-module.h"
45 bfd_size_type symcount
;
48 static const char * const wasm_numbered_sections
[] =
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"),
64 #define WASM_NUMBERED_SECTIONS ARRAY_SIZE (wasm_numbered_sections)
66 /* Resolve SECTION_CODE to a section name if there is one, NULL
70 wasm_section_code_to_name (bfd_byte section_code
)
72 if (section_code
< WASM_NUMBERED_SECTIONS
)
73 return wasm_numbered_sections
[section_code
];
78 /* Translate section name NAME to a section code, or 0 if it's a
82 wasm_section_name_to_code (const char *name
)
86 for (i
= 1; i
< WASM_NUMBERED_SECTIONS
; i
++)
87 if (strcmp (name
, wasm_numbered_sections
[i
]) == 0)
93 /* WebAssembly LEB128 integers are sufficiently like DWARF LEB128
94 integers that we use _bfd_safe_read_leb128, but there are two
97 - WebAssembly requires a 32-bit value to be encoded in at most 5
99 - _bfd_safe_read_leb128 accepts incomplete LEB128 encodings at the
100 end of the buffer, while these are invalid in WebAssembly.
102 Those differences mean that we will accept some files that are
103 invalid WebAssembly. */
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. */
111 wasm_read_leb128 (bfd
* abfd
,
112 bfd_boolean
* error_return
,
113 unsigned int * length_return
,
117 unsigned int num_read
= 0;
118 unsigned int shift
= 0;
119 unsigned char byte
= 0;
120 unsigned char lost
, mask
;
123 while (bfd_bread (&byte
, 1, abfd
) == 1)
127 if (shift
< CHAR_BIT
* sizeof (result
))
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
);
141 if ((lost
& mask
) != (sign
&& (bfd_signed_vma
) result
< 0 ? mask
: 0))
144 if ((byte
& 0x80) == 0)
147 if (sign
&& shift
< CHAR_BIT
* sizeof (result
) && (byte
& 0x40))
148 result
|= -((bfd_vma
) 1 << shift
);
153 if (length_return
!= NULL
)
154 *length_return
= num_read
;
155 if (error_return
!= NULL
)
156 *error_return
= status
!= 0;
161 /* Encode an integer V as LEB128 and write it to ABFD, return TRUE on
165 wasm_write_uleb128 (bfd
*abfd
, bfd_vma v
)
169 bfd_byte c
= v
& 0x7f;
175 if (bfd_bwrite (&c
, 1, abfd
) != 1)
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) \
188 unsigned int length_read; \
189 (x) = _bfd_safe_read_leb128 (abfd, (p), &length_read, \
191 (p) += length_read; \
192 if (length_read == 0) \
197 /* Verify the magic number at the beginning of a WebAssembly module
198 ABFD, setting ERRORPTR if there's a mismatch. */
201 wasm_read_magic (bfd
*abfd
, bfd_boolean
*errorptr
)
203 bfd_byte magic_const
[SIZEOF_WASM_MAGIC
] = WASM_MAGIC
;
204 bfd_byte magic
[SIZEOF_WASM_MAGIC
];
206 if (bfd_bread (magic
, sizeof (magic
), abfd
) == sizeof (magic
)
207 && memcmp (magic
, magic_const
, sizeof (magic
)) == 0)
214 /* Read the version number from ABFD, returning TRUE if it's a supported
215 version. Set ERRORPTR otherwise. */
218 wasm_read_version (bfd
*abfd
, bfd_boolean
*errorptr
)
220 bfd_byte vers_const
[SIZEOF_WASM_VERSION
] = WASM_VERSION
;
221 bfd_byte vers
[SIZEOF_WASM_VERSION
];
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)
233 /* Read the WebAssembly header (magic number plus version number) from
234 ABFD, setting ERRORPTR to TRUE if there is a mismatch. */
237 wasm_read_header (bfd
*abfd
, bfd_boolean
*errorptr
)
239 if (! wasm_read_magic (abfd
, errorptr
))
242 if (! wasm_read_version (abfd
, errorptr
))
248 /* Scan the "function" subsection of the "name" section ASECT in the
249 wasm module ABFD. Create symbols. Return TRUE on success. */
252 wasm_scan_name_function_section (bfd
*abfd
, sec_ptr asect
)
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
;
264 end
= asect
->contents
+ asect
->size
;
271 bfd_byte subsection_code
= *p
++;
272 if (subsection_code
== WASM_FUNCTION_SUBSECTION
)
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)
281 READ_LEB128 (payload_size
, p
, end
);
283 if (payload_size
> (size_t) (end
- p
))
292 READ_LEB128 (payload_size
, p
, end
);
294 if (payload_size
> (size_t) (end
- p
))
297 end
= p
+ payload_size
;
299 READ_LEB128 (symcount
, p
, end
);
301 /* Sanity check: each symbol has at least two bytes. */
302 if (symcount
> payload_size
/ 2)
305 tdata
->symcount
= symcount
;
308 = bfd_make_section_with_flags (abfd
, WASM_SECTION_FUNCTION_INDEX
,
309 SEC_READONLY
| SEC_CODE
);
311 if (!space_function_index
)
313 = bfd_get_section_by_name (abfd
, WASM_SECTION_FUNCTION_INDEX
);
315 if (!space_function_index
)
318 if (_bfd_mul_overflow (tdata
->symcount
, sizeof (asymbol
), &amt
))
320 bfd_set_error (bfd_error_file_too_big
);
323 symbols
= bfd_alloc (abfd
, amt
);
327 for (symcount
= 0; p
< end
&& symcount
< tdata
->symcount
; symcount
++)
334 READ_LEB128 (idx
, p
, end
);
335 READ_LEB128 (len
, p
, end
);
337 if (len
> (size_t) (end
- p
))
340 name
= bfd_alloc (abfd
, len
+ 1);
344 memcpy (name
, p
, len
);
348 sym
= &symbols
[symcount
];
352 sym
->flags
= BSF_GLOBAL
| BSF_FUNCTION
;
353 sym
->section
= space_function_index
;
357 if (symcount
< tdata
->symcount
)
360 tdata
->symbols
= symbols
;
361 abfd
->symcount
= symcount
;
366 bfd_release (abfd
, symbols
);
370 /* Read a byte from ABFD and return it, or EOF for EOF or error.
371 Set ERRORPTR on non-EOF error. */
374 wasm_read_byte (bfd
*abfd
, bfd_boolean
*errorptr
)
378 if (bfd_bread (&byte
, (bfd_size_type
) 1, abfd
) != 1)
380 if (bfd_get_error () != bfd_error_file_truncated
)
388 /* Scan the wasm module ABFD, creating sections and symbols.
389 Return TRUE on success. */
392 wasm_scan (bfd
*abfd
)
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;
399 unsigned int bytes_read
;
402 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
405 if (!wasm_read_header (abfd
, &error
))
408 while ((section_code
= wasm_read_byte (abfd
, &error
)) != EOF
)
410 if (section_code
!= 0)
412 const char *sname
= wasm_section_code_to_name (section_code
);
417 bfdsec
= bfd_make_section_anyway_with_flags (abfd
, sname
,
422 bfdsec
->size
= wasm_read_leb128 (abfd
, &error
, &bytes_read
, FALSE
);
431 char *prefix
= WASM_SECTION_PREFIX
;
432 size_t prefixlen
= strlen (prefix
);
435 payload_len
= wasm_read_leb128 (abfd
, &error
, &bytes_read
, FALSE
);
438 namelen
= wasm_read_leb128 (abfd
, &error
, &bytes_read
, FALSE
);
439 if (error
|| bytes_read
> payload_len
440 || namelen
> payload_len
- bytes_read
)
442 payload_len
-= namelen
+ bytes_read
;
443 filesize
= bfd_get_file_size (abfd
);
444 if (filesize
!= 0 && namelen
> filesize
)
446 bfd_set_error (bfd_error_file_truncated
);
449 name
= bfd_alloc (abfd
, namelen
+ prefixlen
+ 1);
452 memcpy (name
, prefix
, prefixlen
);
453 if (bfd_bread (name
+ prefixlen
, namelen
, abfd
) != namelen
)
455 name
[prefixlen
+ namelen
] = 0;
457 bfdsec
= bfd_make_section_anyway_with_flags (abfd
, name
,
462 bfdsec
->size
= payload_len
;
467 bfdsec
->alignment_power
= 0;
468 bfdsec
->filepos
= bfd_tell (abfd
);
469 if (bfdsec
->size
!= 0)
471 bfdsec
->contents
= _bfd_alloc_and_read (abfd
, bfdsec
->size
,
473 if (!bfdsec
->contents
)
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. */
491 /* Put a numbered section ASECT of ABFD into the table of numbered
492 sections pointed to by FSARG. */
495 wasm_register_section (bfd
*abfd ATTRIBUTE_UNUSED
,
499 sec_ptr
*numbered_sections
= fsarg
;
500 int idx
= wasm_section_name_to_code (asect
->name
);
505 numbered_sections
[idx
] = asect
;
508 struct compute_section_arg
514 /* Compute the file position of ABFD's section ASECT. FSARG is a
515 pointer to the current file position.
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. */
524 wasm_compute_custom_section_file_position (bfd
*abfd
,
528 struct compute_section_arg
*fs
= fsarg
;
534 idx
= wasm_section_name_to_code (asect
->name
);
539 if (startswith (asect
->name
, WASM_SECTION_PREFIX
))
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
;
546 payload_len
+= name_len
;
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
)
561 fs
->pos
= asect
->filepos
= bfd_tell (abfd
);
565 asect
->filepos
= fs
->pos
;
569 fs
->pos
+= asect
->size
;
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.
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. */
585 wasm_compute_section_file_positions (bfd
*abfd
)
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
;
593 bfd_seek (abfd
, (bfd_vma
) 0, SEEK_SET
);
595 if (bfd_bwrite (magic
, sizeof (magic
), abfd
) != (sizeof magic
)
596 || bfd_bwrite (vers
, sizeof (vers
), abfd
) != sizeof (vers
))
599 for (i
= 0; i
< WASM_NUMBERED_SECTIONS
; i
++)
600 numbered_sections
[i
] = NULL
;
602 bfd_map_over_sections (abfd
, wasm_register_section
, numbered_sections
);
604 fs
.pos
= bfd_tell (abfd
);
605 for (i
= 0; i
< WASM_NUMBERED_SECTIONS
; i
++)
607 sec_ptr sec
= numbered_sections
[i
];
613 if (bfd_seek (abfd
, fs
.pos
, SEEK_SET
) != 0)
615 if (! wasm_write_uleb128 (abfd
, i
)
616 || ! wasm_write_uleb128 (abfd
, size
))
618 fs
.pos
= sec
->filepos
= bfd_tell (abfd
);
624 bfd_map_over_sections (abfd
, wasm_compute_custom_section_file_position
, &fs
);
629 abfd
->output_has_begun
= TRUE
;
635 wasm_set_section_contents (bfd
*abfd
,
637 const void *location
,
644 if (! abfd
->output_has_begun
645 && ! wasm_compute_section_file_positions (abfd
))
648 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0
649 || bfd_bwrite (location
, count
, abfd
) != count
)
656 wasm_write_object_contents (bfd
* abfd
)
658 bfd_byte magic
[] = WASM_MAGIC
;
659 bfd_byte vers
[] = WASM_VERSION
;
661 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0)
664 if (bfd_bwrite (magic
, sizeof (magic
), abfd
) != sizeof (magic
)
665 || bfd_bwrite (vers
, sizeof (vers
), abfd
) != sizeof (vers
))
672 wasm_mkobject (bfd
*abfd
)
674 tdata_type
*tdata
= (tdata_type
*) bfd_alloc (abfd
, sizeof (tdata_type
));
679 tdata
->symbols
= NULL
;
682 abfd
->tdata
.any
= tdata
;
688 wasm_get_symtab_upper_bound (bfd
*abfd
)
690 tdata_type
*tdata
= abfd
->tdata
.any
;
692 return (tdata
->symcount
+ 1) * (sizeof (asymbol
*));
696 wasm_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
698 tdata_type
*tdata
= abfd
->tdata
.any
;
701 for (i
= 0; i
< tdata
->symcount
; i
++)
702 alocation
[i
] = &tdata
->symbols
[i
];
705 return tdata
->symcount
;
709 wasm_make_empty_symbol (bfd
*abfd
)
711 size_t amt
= sizeof (asymbol
);
712 asymbol
*new_symbol
= (asymbol
*) bfd_zalloc (abfd
, amt
);
716 new_symbol
->the_bfd
= abfd
;
721 wasm_print_symbol (bfd
*abfd
,
724 bfd_print_symbol_type how
)
726 FILE *file
= (FILE *) filep
;
730 case bfd_print_symbol_name
:
731 fprintf (file
, "%s", symbol
->name
);
735 bfd_print_symbol_vandf (abfd
, filep
, symbol
);
736 fprintf (file
, " %-5s %s", symbol
->section
->name
, symbol
->name
);
741 wasm_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
745 bfd_symbol_info (symbol
, ret
);
748 /* Check whether ABFD is a WebAssembly module; if so, scan it. */
751 wasm_object_p (bfd
*abfd
)
756 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
759 if (!wasm_read_header (abfd
, &error
))
761 bfd_set_error (bfd_error_wrong_format
);
765 if (!wasm_mkobject (abfd
))
768 if (!wasm_scan (abfd
)
769 || !bfd_default_set_arch_mach (abfd
, bfd_arch_wasm32
, 0))
771 bfd_release (abfd
, abfd
->tdata
.any
);
772 abfd
->tdata
.any
= NULL
;
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
;
780 return _bfd_no_cleanup
;
783 /* BFD_JUMP_TABLE_WRITE */
784 #define wasm_set_arch_mach _bfd_generic_set_arch_mach
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
798 const bfd_target wasm_vec
=
801 bfd_target_unknown_flavour
,
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
,
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
,
823 wasm_object_p
, /* bfd_check_format. */
828 _bfd_bool_bfd_false_error
,
830 _bfd_generic_mkarchive
,
831 _bfd_bool_bfd_false_error
,
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
,
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
),