1 /* BFD back-end for WebAssembly modules.
2 Copyright (C) 2017-2020 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"
32 #include "libiberty.h"
34 #include "wasm-module.h"
39 bfd_size_type symcount
;
42 static const char * const wasm_numbered_sections
[] =
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"),
58 #define WASM_NUMBERED_SECTIONS ARRAY_SIZE (wasm_numbered_sections)
60 /* Resolve SECTION_CODE to a section name if there is one, NULL
64 wasm_section_code_to_name (bfd_byte section_code
)
66 if (section_code
< WASM_NUMBERED_SECTIONS
)
67 return wasm_numbered_sections
[section_code
];
72 /* Translate section name NAME to a section code, or 0 if it's a
76 wasm_section_name_to_code (const char *name
)
80 for (i
= 1; i
< WASM_NUMBERED_SECTIONS
; i
++)
81 if (strcmp (name
, wasm_numbered_sections
[i
]) == 0)
87 /* WebAssembly LEB128 integers are sufficiently like DWARF LEB128
88 integers that we use _bfd_safe_read_leb128, but there are two
91 - WebAssembly requires a 32-bit value to be encoded in at most 5
93 - _bfd_safe_read_leb128 accepts incomplete LEB128 encodings at the
94 end of the buffer, while these are invalid in WebAssembly.
96 Those differences mean that we will accept some files that are
97 invalid WebAssembly. */
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. */
105 wasm_read_leb128 (bfd
* abfd
,
106 bfd_boolean
* error_return
,
107 unsigned int * length_return
,
111 unsigned int num_read
= 0;
112 unsigned int shift
= 0;
113 unsigned char byte
= 0;
116 while (bfd_bread (&byte
, 1, abfd
) == 1)
120 if (shift
< sizeof (result
) * 8)
122 result
|= ((bfd_vma
) (byte
& 0x7f)) << shift
;
123 if ((result
>> shift
) != (byte
& 0x7f))
128 else if ((byte
& 0x7f) != 0)
131 if ((byte
& 0x80) == 0)
134 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
135 result
|= -((bfd_vma
) 1 << shift
);
140 if (length_return
!= NULL
)
141 *length_return
= num_read
;
142 if (error_return
!= NULL
)
143 *error_return
= status
!= 0;
148 /* Encode an integer V as LEB128 and write it to ABFD, return TRUE on
152 wasm_write_uleb128 (bfd
*abfd
, bfd_vma v
)
156 bfd_byte c
= v
& 0x7f;
162 if (bfd_bwrite (&c
, 1, abfd
) != 1)
170 /* Read the LEB128 integer at P, saving it to X; at end of buffer,
171 jump to error_return. */
172 #define READ_LEB128(x, p, end) \
175 unsigned int length_read; \
176 (x) = _bfd_safe_read_leb128 (abfd, (p), &length_read, \
178 (p) += length_read; \
179 if (length_read == 0) \
184 /* Verify the magic number at the beginning of a WebAssembly module
185 ABFD, setting ERRORPTR if there's a mismatch. */
188 wasm_read_magic (bfd
*abfd
, bfd_boolean
*errorptr
)
190 bfd_byte magic_const
[SIZEOF_WASM_MAGIC
] = WASM_MAGIC
;
191 bfd_byte magic
[SIZEOF_WASM_MAGIC
];
193 if (bfd_bread (magic
, sizeof (magic
), abfd
) == sizeof (magic
)
194 && memcmp (magic
, magic_const
, sizeof (magic
)) == 0)
201 /* Read the version number from ABFD, returning TRUE if it's a supported
202 version. Set ERRORPTR otherwise. */
205 wasm_read_version (bfd
*abfd
, bfd_boolean
*errorptr
)
207 bfd_byte vers_const
[SIZEOF_WASM_VERSION
] = WASM_VERSION
;
208 bfd_byte vers
[SIZEOF_WASM_VERSION
];
210 if (bfd_bread (vers
, sizeof (vers
), abfd
) == sizeof (vers
)
211 /* Don't attempt to parse newer versions, which are likely to
212 require code changes. */
213 && memcmp (vers
, vers_const
, sizeof (vers
)) == 0)
220 /* Read the WebAssembly header (magic number plus version number) from
221 ABFD, setting ERRORPTR to TRUE if there is a mismatch. */
224 wasm_read_header (bfd
*abfd
, bfd_boolean
*errorptr
)
226 if (! wasm_read_magic (abfd
, errorptr
))
229 if (! wasm_read_version (abfd
, errorptr
))
235 /* Scan the "function" subsection of the "name" section ASECT in the
236 wasm module ABFD. Create symbols. Return TRUE on success. */
239 wasm_scan_name_function_section (bfd
*abfd
, sec_ptr asect
)
243 bfd_vma payload_size
;
244 bfd_vma symcount
= 0;
245 tdata_type
*tdata
= abfd
->tdata
.any
;
246 asymbol
*symbols
= NULL
;
247 sec_ptr space_function_index
;
251 end
= asect
->contents
+ asect
->size
;
258 bfd_byte subsection_code
= *p
++;
259 if (subsection_code
== WASM_FUNCTION_SUBSECTION
)
262 /* subsection_code is documented to be a varuint7, meaning that
263 it has to be a single byte in the 0 - 127 range. If it isn't,
264 the spec must have changed underneath us, so give up. */
265 if (subsection_code
& 0x80)
268 READ_LEB128 (payload_size
, p
, end
);
270 if (payload_size
> (size_t) (end
- p
))
279 READ_LEB128 (payload_size
, p
, end
);
281 if (payload_size
> (size_t) (end
- p
))
284 end
= p
+ payload_size
;
286 READ_LEB128 (symcount
, p
, end
);
288 /* Sanity check: each symbol has at least two bytes. */
289 if (symcount
> payload_size
/ 2)
292 tdata
->symcount
= symcount
;
295 = bfd_make_section_with_flags (abfd
, WASM_SECTION_FUNCTION_INDEX
,
296 SEC_READONLY
| SEC_CODE
);
298 if (!space_function_index
)
300 = bfd_get_section_by_name (abfd
, WASM_SECTION_FUNCTION_INDEX
);
302 if (!space_function_index
)
305 if (_bfd_mul_overflow (tdata
->symcount
, sizeof (asymbol
), &amt
))
307 bfd_set_error (bfd_error_file_too_big
);
310 symbols
= bfd_alloc (abfd
, amt
);
314 for (symcount
= 0; p
< end
&& symcount
< tdata
->symcount
; symcount
++)
321 READ_LEB128 (idx
, p
, end
);
322 READ_LEB128 (len
, p
, end
);
324 if (len
> (size_t) (end
- p
))
327 name
= bfd_alloc (abfd
, len
+ 1);
331 memcpy (name
, p
, len
);
335 sym
= &symbols
[symcount
];
339 sym
->flags
= BSF_GLOBAL
| BSF_FUNCTION
;
340 sym
->section
= space_function_index
;
344 if (symcount
< tdata
->symcount
)
347 tdata
->symbols
= symbols
;
348 abfd
->symcount
= symcount
;
353 bfd_release (abfd
, symbols
);
357 /* Read a byte from ABFD and return it, or EOF for EOF or error.
358 Set ERRORPTR on non-EOF error. */
361 wasm_read_byte (bfd
*abfd
, bfd_boolean
*errorptr
)
365 if (bfd_bread (&byte
, (bfd_size_type
) 1, abfd
) != 1)
367 if (bfd_get_error () != bfd_error_file_truncated
)
375 /* Scan the wasm module ABFD, creating sections and symbols.
376 Return TRUE on success. */
379 wasm_scan (bfd
*abfd
)
381 bfd_boolean error
= FALSE
;
382 /* Fake VMAs for now. Choose 0x80000000 as base to avoid clashes
383 with actual data addresses. */
384 bfd_vma vma
= 0x80000000;
386 unsigned int bytes_read
;
389 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
392 if (!wasm_read_header (abfd
, &error
))
395 while ((section_code
= wasm_read_byte (abfd
, &error
)) != EOF
)
397 if (section_code
!= 0)
399 const char *sname
= wasm_section_code_to_name (section_code
);
404 bfdsec
= bfd_make_section_anyway_with_flags (abfd
, sname
,
411 bfdsec
->size
= wasm_read_leb128 (abfd
, &error
, &bytes_read
, FALSE
);
414 bfdsec
->filepos
= bfd_tell (abfd
);
415 bfdsec
->alignment_power
= 0;
420 file_ptr section_start
;
423 char *prefix
= WASM_SECTION_PREFIX
;
424 size_t prefixlen
= strlen (prefix
);
426 payload_len
= wasm_read_leb128 (abfd
, &error
, &bytes_read
, FALSE
);
429 section_start
= bfd_tell (abfd
);
430 namelen
= wasm_read_leb128 (abfd
, &error
, &bytes_read
, FALSE
);
431 if (error
|| namelen
> payload_len
)
433 name
= bfd_alloc (abfd
, namelen
+ prefixlen
+ 1);
436 memcpy (name
, prefix
, prefixlen
);
437 if (bfd_bread (name
+ prefixlen
, namelen
, abfd
) != namelen
)
439 name
[prefixlen
+ namelen
] = 0;
441 bfdsec
= bfd_make_section_anyway_with_flags (abfd
, name
,
448 bfdsec
->filepos
= bfd_tell (abfd
);
449 bfdsec
->size
= section_start
+ payload_len
- bfdsec
->filepos
;
450 bfdsec
->alignment_power
= 0;
453 if (bfdsec
->size
!= 0)
455 bfdsec
->contents
= bfd_alloc (abfd
, bfdsec
->size
);
456 if (!bfdsec
->contents
)
459 if (bfd_bread (bfdsec
->contents
, bfdsec
->size
, abfd
) != bfdsec
->size
)
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. */
477 /* Put a numbered section ASECT of ABFD into the table of numbered
478 sections pointed to by FSARG. */
481 wasm_register_section (bfd
*abfd ATTRIBUTE_UNUSED
,
485 sec_ptr
*numbered_sections
= fsarg
;
486 int idx
= wasm_section_name_to_code (asect
->name
);
491 numbered_sections
[idx
] = asect
;
494 struct compute_section_arg
500 /* Compute the file position of ABFD's section ASECT. FSARG is a
501 pointer to the current file position.
503 We allow section names of the form .wasm.id to encode the numbered
504 section with ID id, if it exists; otherwise, a custom section with
505 ID "id" is produced. Arbitrary section names are for sections that
506 are assumed already to contain a section header; those are appended
507 to the WebAssembly module verbatim. */
510 wasm_compute_custom_section_file_position (bfd
*abfd
,
514 struct compute_section_arg
*fs
= fsarg
;
520 idx
= wasm_section_name_to_code (asect
->name
);
525 if (CONST_STRNEQ (asect
->name
, WASM_SECTION_PREFIX
))
527 const char *name
= asect
->name
+ strlen (WASM_SECTION_PREFIX
);
528 bfd_size_type payload_len
= asect
->size
;
529 bfd_size_type name_len
= strlen (name
);
530 bfd_size_type nl
= name_len
;
532 payload_len
+= name_len
;
541 bfd_seek (abfd
, fs
->pos
, SEEK_SET
);
542 if (! wasm_write_uleb128 (abfd
, 0)
543 || ! wasm_write_uleb128 (abfd
, payload_len
)
544 || ! wasm_write_uleb128 (abfd
, name_len
)
545 || bfd_bwrite (name
, name_len
, abfd
) != name_len
)
547 fs
->pos
= asect
->filepos
= bfd_tell (abfd
);
551 asect
->filepos
= fs
->pos
;
555 fs
->pos
+= asect
->size
;
562 /* Compute the file positions for the sections of ABFD. Currently,
563 this writes all numbered sections first, in order, then all custom
564 sections, in section order.
566 The spec says that the numbered sections must appear in order of
567 their ids, but custom sections can appear in any position and any
568 order, and more than once. FIXME: support that. */
571 wasm_compute_section_file_positions (bfd
*abfd
)
573 bfd_byte magic
[SIZEOF_WASM_MAGIC
] = WASM_MAGIC
;
574 bfd_byte vers
[SIZEOF_WASM_VERSION
] = WASM_VERSION
;
575 sec_ptr numbered_sections
[WASM_NUMBERED_SECTIONS
];
576 struct compute_section_arg fs
;
579 bfd_seek (abfd
, (bfd_vma
) 0, SEEK_SET
);
581 if (bfd_bwrite (magic
, sizeof (magic
), abfd
) != (sizeof magic
)
582 || bfd_bwrite (vers
, sizeof (vers
), abfd
) != sizeof (vers
))
585 for (i
= 0; i
< WASM_NUMBERED_SECTIONS
; i
++)
586 numbered_sections
[i
] = NULL
;
588 bfd_map_over_sections (abfd
, wasm_register_section
, numbered_sections
);
590 fs
.pos
= bfd_tell (abfd
);
591 for (i
= 0; i
< WASM_NUMBERED_SECTIONS
; i
++)
593 sec_ptr sec
= numbered_sections
[i
];
599 if (bfd_seek (abfd
, fs
.pos
, SEEK_SET
) != 0)
601 if (! wasm_write_uleb128 (abfd
, i
)
602 || ! wasm_write_uleb128 (abfd
, size
))
604 fs
.pos
= sec
->filepos
= bfd_tell (abfd
);
610 bfd_map_over_sections (abfd
, wasm_compute_custom_section_file_position
, &fs
);
615 abfd
->output_has_begun
= TRUE
;
621 wasm_set_section_contents (bfd
*abfd
,
623 const void *location
,
630 if (! abfd
->output_has_begun
631 && ! wasm_compute_section_file_positions (abfd
))
634 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0
635 || bfd_bwrite (location
, count
, abfd
) != count
)
642 wasm_write_object_contents (bfd
* abfd
)
644 bfd_byte magic
[] = WASM_MAGIC
;
645 bfd_byte vers
[] = WASM_VERSION
;
647 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0)
650 if (bfd_bwrite (magic
, sizeof (magic
), abfd
) != sizeof (magic
)
651 || bfd_bwrite (vers
, sizeof (vers
), abfd
) != sizeof (vers
))
658 wasm_mkobject (bfd
*abfd
)
660 tdata_type
*tdata
= (tdata_type
*) bfd_alloc (abfd
, sizeof (tdata_type
));
665 tdata
->symbols
= NULL
;
668 abfd
->tdata
.any
= tdata
;
674 wasm_get_symtab_upper_bound (bfd
*abfd
)
676 tdata_type
*tdata
= abfd
->tdata
.any
;
678 return (tdata
->symcount
+ 1) * (sizeof (asymbol
*));
682 wasm_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
684 tdata_type
*tdata
= abfd
->tdata
.any
;
687 for (i
= 0; i
< tdata
->symcount
; i
++)
688 alocation
[i
] = &tdata
->symbols
[i
];
691 return tdata
->symcount
;
695 wasm_make_empty_symbol (bfd
*abfd
)
697 size_t amt
= sizeof (asymbol
);
698 asymbol
*new_symbol
= (asymbol
*) bfd_zalloc (abfd
, amt
);
702 new_symbol
->the_bfd
= abfd
;
707 wasm_print_symbol (bfd
*abfd
,
710 bfd_print_symbol_type how
)
712 FILE *file
= (FILE *) filep
;
716 case bfd_print_symbol_name
:
717 fprintf (file
, "%s", symbol
->name
);
721 bfd_print_symbol_vandf (abfd
, filep
, symbol
);
722 fprintf (file
, " %-5s %s", symbol
->section
->name
, symbol
->name
);
727 wasm_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
731 bfd_symbol_info (symbol
, ret
);
734 /* Check whether ABFD is a WebAssembly module; if so, scan it. */
736 static const bfd_target
*
737 wasm_object_p (bfd
*abfd
)
742 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
745 if (!wasm_read_header (abfd
, &error
))
747 bfd_set_error (bfd_error_wrong_format
);
751 if (!wasm_mkobject (abfd
))
754 if (!wasm_scan (abfd
)
755 || !bfd_default_set_arch_mach (abfd
, bfd_arch_wasm32
, 0))
757 bfd_release (abfd
, abfd
->tdata
.any
);
758 abfd
->tdata
.any
= NULL
;
762 s
= bfd_get_section_by_name (abfd
, WASM_NAME_SECTION
);
763 if (s
!= NULL
&& wasm_scan_name_function_section (abfd
, s
))
764 abfd
->flags
|= HAS_SYMS
;
769 /* BFD_JUMP_TABLE_WRITE */
770 #define wasm_set_arch_mach _bfd_generic_set_arch_mach
772 /* BFD_JUMP_TABLE_SYMBOLS */
773 #define wasm_get_symbol_version_string _bfd_nosymbols_get_symbol_version_string
774 #define wasm_bfd_is_local_label_name bfd_generic_is_local_label_name
775 #define wasm_bfd_is_target_special_symbol _bfd_bool_bfd_asymbol_false
776 #define wasm_get_lineno _bfd_nosymbols_get_lineno
777 #define wasm_find_nearest_line _bfd_nosymbols_find_nearest_line
778 #define wasm_find_line _bfd_nosymbols_find_line
779 #define wasm_find_inliner_info _bfd_nosymbols_find_inliner_info
780 #define wasm_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
781 #define wasm_read_minisymbols _bfd_generic_read_minisymbols
782 #define wasm_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
784 const bfd_target wasm_vec
=
787 bfd_target_unknown_flavour
,
790 (HAS_SYMS
| WP_TEXT
), /* Object flags. */
791 (SEC_CODE
| SEC_DATA
| SEC_HAS_CONTENTS
), /* Section flags. */
792 0, /* Leading underscore. */
793 ' ', /* AR_pad_char. */
794 255, /* AR_max_namelen. */
795 0, /* Match priority. */
796 /* Routines to byte-swap various sized integers from the data sections. */
797 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
798 bfd_getl32
, bfd_getl_signed_32
, bfd_putl32
,
799 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
,
801 /* Routines to byte-swap various sized integers from the file headers. */
802 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
803 bfd_getl32
, bfd_getl_signed_32
, bfd_putl32
,
804 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
,
808 wasm_object_p
, /* bfd_check_format. */
813 _bfd_bool_bfd_false_error
,
815 _bfd_generic_mkarchive
,
816 _bfd_bool_bfd_false_error
,
818 { /* bfd_write_contents. */
819 _bfd_bool_bfd_false_error
,
820 wasm_write_object_contents
,
821 _bfd_write_archive_contents
,
822 _bfd_bool_bfd_false_error
,
825 BFD_JUMP_TABLE_GENERIC (_bfd_generic
),
826 BFD_JUMP_TABLE_COPY (_bfd_generic
),
827 BFD_JUMP_TABLE_CORE (_bfd_nocore
),
828 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive
),
829 BFD_JUMP_TABLE_SYMBOLS (wasm
),
830 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs
),
831 BFD_JUMP_TABLE_WRITE (wasm
),
832 BFD_JUMP_TABLE_LINK (_bfd_nolink
),
833 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic
),