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. */
30 #include "libiberty.h"
32 #include "wasm-module.h"
42 bfd_size_type symcount
;
45 static const char * const wasm_numbered_sections
[] =
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"),
61 #define WASM_NUMBERED_SECTIONS ARRAY_SIZE (wasm_numbered_sections)
63 /* Resolve SECTION_CODE to a section name if there is one, NULL
67 wasm_section_code_to_name (bfd_byte section_code
)
69 if (section_code
< WASM_NUMBERED_SECTIONS
)
70 return wasm_numbered_sections
[section_code
];
75 /* Translate section name NAME to a section code, or 0 if it's a
79 wasm_section_name_to_code (const char *name
)
83 for (i
= 1; i
< WASM_NUMBERED_SECTIONS
; i
++)
84 if (strcmp (name
, wasm_numbered_sections
[i
]) == 0)
90 /* WebAssembly LEB128 integers are sufficiently like DWARF LEB128
91 integers that we use _bfd_safe_read_leb128, but there are two
94 - WebAssembly requires a 32-bit value to be encoded in at most 5
96 - _bfd_safe_read_leb128 accepts incomplete LEB128 encodings at the
97 end of the buffer, while these are invalid in WebAssembly.
99 Those differences mean that we will accept some files that are
100 invalid WebAssembly. */
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. */
108 wasm_read_leb128 (bfd
*abfd
,
110 unsigned int *length_return
,
114 unsigned int num_read
= 0;
115 unsigned int shift
= 0;
116 unsigned char byte
= 0;
117 unsigned char lost
, mask
;
120 while (bfd_bread (&byte
, 1, abfd
) == 1)
124 if (shift
< CHAR_BIT
* sizeof (result
))
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
);
138 if ((lost
& mask
) != (sign
&& (bfd_signed_vma
) result
< 0 ? mask
: 0))
141 if ((byte
& 0x80) == 0)
144 if (sign
&& shift
< CHAR_BIT
* sizeof (result
) && (byte
& 0x40))
145 result
|= -((bfd_vma
) 1 << shift
);
150 if (length_return
!= NULL
)
151 *length_return
= num_read
;
152 if (error_return
!= NULL
)
153 *error_return
= status
!= 0;
158 /* Encode an integer V as LEB128 and write it to ABFD, return TRUE on
162 wasm_write_uleb128 (bfd
*abfd
, bfd_vma v
)
166 bfd_byte c
= v
& 0x7f;
172 if (bfd_bwrite (&c
, 1, abfd
) != 1)
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) \
185 unsigned int length_read; \
186 (x) = _bfd_safe_read_leb128 (abfd, (p), &length_read, \
188 (p) += length_read; \
189 if (length_read == 0) \
194 /* Verify the magic number at the beginning of a WebAssembly module
195 ABFD, setting ERRORPTR if there's a mismatch. */
198 wasm_read_magic (bfd
*abfd
, bool *errorptr
)
200 bfd_byte magic_const
[SIZEOF_WASM_MAGIC
] = WASM_MAGIC
;
201 bfd_byte magic
[SIZEOF_WASM_MAGIC
];
203 if (bfd_bread (magic
, sizeof (magic
), abfd
) == sizeof (magic
)
204 && memcmp (magic
, magic_const
, sizeof (magic
)) == 0)
211 /* Read the version number from ABFD, returning TRUE if it's a supported
212 version. Set ERRORPTR otherwise. */
215 wasm_read_version (bfd
*abfd
, bool *errorptr
)
217 bfd_byte vers_const
[SIZEOF_WASM_VERSION
] = WASM_VERSION
;
218 bfd_byte vers
[SIZEOF_WASM_VERSION
];
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)
230 /* Read the WebAssembly header (magic number plus version number) from
231 ABFD, setting ERRORPTR to TRUE if there is a mismatch. */
234 wasm_read_header (bfd
*abfd
, bool *errorptr
)
236 if (! wasm_read_magic (abfd
, errorptr
))
239 if (! wasm_read_version (abfd
, errorptr
))
245 /* Scan the "function" subsection of the "name" section ASECT in the
246 wasm module ABFD. Create symbols. Return TRUE on success. */
249 wasm_scan_name_function_section (bfd
*abfd
, sec_ptr asect
)
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
;
261 end
= asect
->contents
+ asect
->size
;
268 bfd_byte subsection_code
= *p
++;
269 if (subsection_code
== WASM_FUNCTION_SUBSECTION
)
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)
278 READ_LEB128 (payload_size
, p
, end
);
280 if (payload_size
> (size_t) (end
- p
))
289 READ_LEB128 (payload_size
, p
, end
);
291 if (payload_size
> (size_t) (end
- p
))
294 end
= p
+ payload_size
;
296 READ_LEB128 (symcount
, p
, end
);
298 /* Sanity check: each symbol has at least two bytes. */
299 if (symcount
> payload_size
/ 2)
302 tdata
->symcount
= symcount
;
305 = bfd_make_section_with_flags (abfd
, WASM_SECTION_FUNCTION_INDEX
,
306 SEC_READONLY
| SEC_CODE
);
308 if (!space_function_index
)
310 = bfd_get_section_by_name (abfd
, WASM_SECTION_FUNCTION_INDEX
);
312 if (!space_function_index
)
315 if (_bfd_mul_overflow (tdata
->symcount
, sizeof (asymbol
), &amt
))
317 bfd_set_error (bfd_error_file_too_big
);
320 symbols
= bfd_alloc (abfd
, amt
);
324 for (symcount
= 0; p
< end
&& symcount
< tdata
->symcount
; symcount
++)
331 READ_LEB128 (idx
, p
, end
);
332 READ_LEB128 (len
, p
, end
);
334 if (len
> (size_t) (end
- p
))
337 name
= bfd_alloc (abfd
, len
+ 1);
341 memcpy (name
, p
, len
);
345 sym
= &symbols
[symcount
];
349 sym
->flags
= BSF_GLOBAL
| BSF_FUNCTION
;
350 sym
->section
= space_function_index
;
354 if (symcount
< tdata
->symcount
)
357 tdata
->symbols
= symbols
;
358 abfd
->symcount
= symcount
;
363 bfd_release (abfd
, symbols
);
367 /* Read a byte from ABFD and return it, or EOF for EOF or error.
368 Set ERRORPTR on non-EOF error. */
371 wasm_read_byte (bfd
*abfd
, bool *errorptr
)
375 if (bfd_bread (&byte
, (bfd_size_type
) 1, abfd
) != 1)
377 if (bfd_get_error () != bfd_error_file_truncated
)
385 /* Scan the wasm module ABFD, creating sections and symbols.
386 Return TRUE on success. */
389 wasm_scan (bfd
*abfd
)
392 /* Fake VMAs for now. Choose 0x80000000 as base to avoid clashes
393 with actual data addresses. */
394 bfd_vma vma
= 0x80000000;
396 unsigned int bytes_read
;
399 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
402 if (!wasm_read_header (abfd
, &error
))
405 while ((section_code
= wasm_read_byte (abfd
, &error
)) != EOF
)
407 if (section_code
!= 0)
409 const char *sname
= wasm_section_code_to_name (section_code
);
414 bfdsec
= bfd_make_section_anyway_with_flags (abfd
, sname
,
419 bfdsec
->size
= wasm_read_leb128 (abfd
, &error
, &bytes_read
, false);
428 char *prefix
= WASM_SECTION_PREFIX
;
429 size_t prefixlen
= strlen (prefix
);
432 payload_len
= wasm_read_leb128 (abfd
, &error
, &bytes_read
, false);
435 namelen
= wasm_read_leb128 (abfd
, &error
, &bytes_read
, false);
436 if (error
|| bytes_read
> payload_len
437 || namelen
> payload_len
- bytes_read
)
439 payload_len
-= namelen
+ bytes_read
;
440 filesize
= bfd_get_file_size (abfd
);
441 if (filesize
!= 0 && namelen
> filesize
)
443 bfd_set_error (bfd_error_file_truncated
);
446 name
= bfd_alloc (abfd
, namelen
+ prefixlen
+ 1);
449 memcpy (name
, prefix
, prefixlen
);
450 if (bfd_bread (name
+ prefixlen
, namelen
, abfd
) != namelen
)
452 name
[prefixlen
+ namelen
] = 0;
454 bfdsec
= bfd_make_section_anyway_with_flags (abfd
, name
,
459 bfdsec
->size
= payload_len
;
464 bfdsec
->alignment_power
= 0;
465 bfdsec
->filepos
= bfd_tell (abfd
);
466 if (bfdsec
->size
!= 0)
468 bfdsec
->contents
= _bfd_alloc_and_read (abfd
, bfdsec
->size
,
470 if (!bfdsec
->contents
)
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. */
488 /* Put a numbered section ASECT of ABFD into the table of numbered
489 sections pointed to by FSARG. */
492 wasm_register_section (bfd
*abfd ATTRIBUTE_UNUSED
,
496 sec_ptr
*numbered_sections
= fsarg
;
497 int idx
= wasm_section_name_to_code (asect
->name
);
502 numbered_sections
[idx
] = asect
;
505 struct compute_section_arg
511 /* Compute the file position of ABFD's section ASECT. FSARG is a
512 pointer to the current file position.
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. */
521 wasm_compute_custom_section_file_position (bfd
*abfd
,
525 struct compute_section_arg
*fs
= fsarg
;
531 idx
= wasm_section_name_to_code (asect
->name
);
536 if (startswith (asect
->name
, WASM_SECTION_PREFIX
))
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
;
543 payload_len
+= name_len
;
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
)
558 fs
->pos
= asect
->filepos
= bfd_tell (abfd
);
562 asect
->filepos
= fs
->pos
;
566 fs
->pos
+= asect
->size
;
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.
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. */
582 wasm_compute_section_file_positions (bfd
*abfd
)
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
;
590 bfd_seek (abfd
, (bfd_vma
) 0, SEEK_SET
);
592 if (bfd_bwrite (magic
, sizeof (magic
), abfd
) != (sizeof magic
)
593 || bfd_bwrite (vers
, sizeof (vers
), abfd
) != sizeof (vers
))
596 for (i
= 0; i
< WASM_NUMBERED_SECTIONS
; i
++)
597 numbered_sections
[i
] = NULL
;
599 bfd_map_over_sections (abfd
, wasm_register_section
, numbered_sections
);
601 fs
.pos
= bfd_tell (abfd
);
602 for (i
= 0; i
< WASM_NUMBERED_SECTIONS
; i
++)
604 sec_ptr sec
= numbered_sections
[i
];
610 if (bfd_seek (abfd
, fs
.pos
, SEEK_SET
) != 0)
612 if (! wasm_write_uleb128 (abfd
, i
)
613 || ! wasm_write_uleb128 (abfd
, size
))
615 fs
.pos
= sec
->filepos
= bfd_tell (abfd
);
621 bfd_map_over_sections (abfd
, wasm_compute_custom_section_file_position
, &fs
);
626 abfd
->output_has_begun
= true;
632 wasm_set_section_contents (bfd
*abfd
,
634 const void *location
,
641 if (! abfd
->output_has_begun
642 && ! wasm_compute_section_file_positions (abfd
))
645 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0
646 || bfd_bwrite (location
, count
, abfd
) != count
)
653 wasm_write_object_contents (bfd
* abfd
)
655 bfd_byte magic
[] = WASM_MAGIC
;
656 bfd_byte vers
[] = WASM_VERSION
;
658 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0)
661 if (bfd_bwrite (magic
, sizeof (magic
), abfd
) != sizeof (magic
)
662 || bfd_bwrite (vers
, sizeof (vers
), abfd
) != sizeof (vers
))
669 wasm_mkobject (bfd
*abfd
)
671 tdata_type
*tdata
= (tdata_type
*) bfd_alloc (abfd
, sizeof (tdata_type
));
676 tdata
->symbols
= NULL
;
679 abfd
->tdata
.any
= tdata
;
685 wasm_get_symtab_upper_bound (bfd
*abfd
)
687 tdata_type
*tdata
= abfd
->tdata
.any
;
689 return (tdata
->symcount
+ 1) * (sizeof (asymbol
*));
693 wasm_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
695 tdata_type
*tdata
= abfd
->tdata
.any
;
698 for (i
= 0; i
< tdata
->symcount
; i
++)
699 alocation
[i
] = &tdata
->symbols
[i
];
702 return tdata
->symcount
;
706 wasm_make_empty_symbol (bfd
*abfd
)
708 size_t amt
= sizeof (asymbol
);
709 asymbol
*new_symbol
= (asymbol
*) bfd_zalloc (abfd
, amt
);
713 new_symbol
->the_bfd
= abfd
;
718 wasm_print_symbol (bfd
*abfd
,
721 bfd_print_symbol_type how
)
723 FILE *file
= (FILE *) filep
;
727 case bfd_print_symbol_name
:
728 fprintf (file
, "%s", symbol
->name
);
732 bfd_print_symbol_vandf (abfd
, filep
, symbol
);
733 fprintf (file
, " %-5s %s", symbol
->section
->name
, symbol
->name
);
738 wasm_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
742 bfd_symbol_info (symbol
, ret
);
745 /* Check whether ABFD is a WebAssembly module; if so, scan it. */
748 wasm_object_p (bfd
*abfd
)
753 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
756 if (!wasm_read_header (abfd
, &error
))
758 bfd_set_error (bfd_error_wrong_format
);
762 if (!wasm_mkobject (abfd
))
765 if (!wasm_scan (abfd
)
766 || !bfd_default_set_arch_mach (abfd
, bfd_arch_wasm32
, 0))
768 bfd_release (abfd
, abfd
->tdata
.any
);
769 abfd
->tdata
.any
= NULL
;
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
;
777 return _bfd_no_cleanup
;
780 /* BFD_JUMP_TABLE_WRITE */
781 #define wasm_set_arch_mach _bfd_generic_set_arch_mach
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
795 const bfd_target wasm_vec
=
798 bfd_target_unknown_flavour
,
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
,
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
,
820 wasm_object_p
, /* bfd_check_format. */
825 _bfd_bool_bfd_false_error
,
827 _bfd_generic_mkarchive
,
828 _bfd_bool_bfd_false_error
,
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
,
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
),