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_and_read (abfd
, bfdsec
->size
,
457 if (!bfdsec
->contents
)
464 /* Make sure we're at actual EOF. There's no indication in the
465 WebAssembly format of how long the file is supposed to be. */
475 /* Put a numbered section ASECT of ABFD into the table of numbered
476 sections pointed to by FSARG. */
479 wasm_register_section (bfd
*abfd ATTRIBUTE_UNUSED
,
483 sec_ptr
*numbered_sections
= fsarg
;
484 int idx
= wasm_section_name_to_code (asect
->name
);
489 numbered_sections
[idx
] = asect
;
492 struct compute_section_arg
498 /* Compute the file position of ABFD's section ASECT. FSARG is a
499 pointer to the current file position.
501 We allow section names of the form .wasm.id to encode the numbered
502 section with ID id, if it exists; otherwise, a custom section with
503 ID "id" is produced. Arbitrary section names are for sections that
504 are assumed already to contain a section header; those are appended
505 to the WebAssembly module verbatim. */
508 wasm_compute_custom_section_file_position (bfd
*abfd
,
512 struct compute_section_arg
*fs
= fsarg
;
518 idx
= wasm_section_name_to_code (asect
->name
);
523 if (CONST_STRNEQ (asect
->name
, WASM_SECTION_PREFIX
))
525 const char *name
= asect
->name
+ strlen (WASM_SECTION_PREFIX
);
526 bfd_size_type payload_len
= asect
->size
;
527 bfd_size_type name_len
= strlen (name
);
528 bfd_size_type nl
= name_len
;
530 payload_len
+= name_len
;
539 bfd_seek (abfd
, fs
->pos
, SEEK_SET
);
540 if (! wasm_write_uleb128 (abfd
, 0)
541 || ! wasm_write_uleb128 (abfd
, payload_len
)
542 || ! wasm_write_uleb128 (abfd
, name_len
)
543 || bfd_bwrite (name
, name_len
, abfd
) != name_len
)
545 fs
->pos
= asect
->filepos
= bfd_tell (abfd
);
549 asect
->filepos
= fs
->pos
;
553 fs
->pos
+= asect
->size
;
560 /* Compute the file positions for the sections of ABFD. Currently,
561 this writes all numbered sections first, in order, then all custom
562 sections, in section order.
564 The spec says that the numbered sections must appear in order of
565 their ids, but custom sections can appear in any position and any
566 order, and more than once. FIXME: support that. */
569 wasm_compute_section_file_positions (bfd
*abfd
)
571 bfd_byte magic
[SIZEOF_WASM_MAGIC
] = WASM_MAGIC
;
572 bfd_byte vers
[SIZEOF_WASM_VERSION
] = WASM_VERSION
;
573 sec_ptr numbered_sections
[WASM_NUMBERED_SECTIONS
];
574 struct compute_section_arg fs
;
577 bfd_seek (abfd
, (bfd_vma
) 0, SEEK_SET
);
579 if (bfd_bwrite (magic
, sizeof (magic
), abfd
) != (sizeof magic
)
580 || bfd_bwrite (vers
, sizeof (vers
), abfd
) != sizeof (vers
))
583 for (i
= 0; i
< WASM_NUMBERED_SECTIONS
; i
++)
584 numbered_sections
[i
] = NULL
;
586 bfd_map_over_sections (abfd
, wasm_register_section
, numbered_sections
);
588 fs
.pos
= bfd_tell (abfd
);
589 for (i
= 0; i
< WASM_NUMBERED_SECTIONS
; i
++)
591 sec_ptr sec
= numbered_sections
[i
];
597 if (bfd_seek (abfd
, fs
.pos
, SEEK_SET
) != 0)
599 if (! wasm_write_uleb128 (abfd
, i
)
600 || ! wasm_write_uleb128 (abfd
, size
))
602 fs
.pos
= sec
->filepos
= bfd_tell (abfd
);
608 bfd_map_over_sections (abfd
, wasm_compute_custom_section_file_position
, &fs
);
613 abfd
->output_has_begun
= TRUE
;
619 wasm_set_section_contents (bfd
*abfd
,
621 const void *location
,
628 if (! abfd
->output_has_begun
629 && ! wasm_compute_section_file_positions (abfd
))
632 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0
633 || bfd_bwrite (location
, count
, abfd
) != count
)
640 wasm_write_object_contents (bfd
* abfd
)
642 bfd_byte magic
[] = WASM_MAGIC
;
643 bfd_byte vers
[] = WASM_VERSION
;
645 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0)
648 if (bfd_bwrite (magic
, sizeof (magic
), abfd
) != sizeof (magic
)
649 || bfd_bwrite (vers
, sizeof (vers
), abfd
) != sizeof (vers
))
656 wasm_mkobject (bfd
*abfd
)
658 tdata_type
*tdata
= (tdata_type
*) bfd_alloc (abfd
, sizeof (tdata_type
));
663 tdata
->symbols
= NULL
;
666 abfd
->tdata
.any
= tdata
;
672 wasm_get_symtab_upper_bound (bfd
*abfd
)
674 tdata_type
*tdata
= abfd
->tdata
.any
;
676 return (tdata
->symcount
+ 1) * (sizeof (asymbol
*));
680 wasm_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
682 tdata_type
*tdata
= abfd
->tdata
.any
;
685 for (i
= 0; i
< tdata
->symcount
; i
++)
686 alocation
[i
] = &tdata
->symbols
[i
];
689 return tdata
->symcount
;
693 wasm_make_empty_symbol (bfd
*abfd
)
695 size_t amt
= sizeof (asymbol
);
696 asymbol
*new_symbol
= (asymbol
*) bfd_zalloc (abfd
, amt
);
700 new_symbol
->the_bfd
= abfd
;
705 wasm_print_symbol (bfd
*abfd
,
708 bfd_print_symbol_type how
)
710 FILE *file
= (FILE *) filep
;
714 case bfd_print_symbol_name
:
715 fprintf (file
, "%s", symbol
->name
);
719 bfd_print_symbol_vandf (abfd
, filep
, symbol
);
720 fprintf (file
, " %-5s %s", symbol
->section
->name
, symbol
->name
);
725 wasm_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
729 bfd_symbol_info (symbol
, ret
);
732 /* Check whether ABFD is a WebAssembly module; if so, scan it. */
734 static const bfd_target
*
735 wasm_object_p (bfd
*abfd
)
740 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
743 if (!wasm_read_header (abfd
, &error
))
745 bfd_set_error (bfd_error_wrong_format
);
749 if (!wasm_mkobject (abfd
))
752 if (!wasm_scan (abfd
)
753 || !bfd_default_set_arch_mach (abfd
, bfd_arch_wasm32
, 0))
755 bfd_release (abfd
, abfd
->tdata
.any
);
756 abfd
->tdata
.any
= NULL
;
760 s
= bfd_get_section_by_name (abfd
, WASM_NAME_SECTION
);
761 if (s
!= NULL
&& wasm_scan_name_function_section (abfd
, s
))
762 abfd
->flags
|= HAS_SYMS
;
767 /* BFD_JUMP_TABLE_WRITE */
768 #define wasm_set_arch_mach _bfd_generic_set_arch_mach
770 /* BFD_JUMP_TABLE_SYMBOLS */
771 #define wasm_get_symbol_version_string _bfd_nosymbols_get_symbol_version_string
772 #define wasm_bfd_is_local_label_name bfd_generic_is_local_label_name
773 #define wasm_bfd_is_target_special_symbol _bfd_bool_bfd_asymbol_false
774 #define wasm_get_lineno _bfd_nosymbols_get_lineno
775 #define wasm_find_nearest_line _bfd_nosymbols_find_nearest_line
776 #define wasm_find_line _bfd_nosymbols_find_line
777 #define wasm_find_inliner_info _bfd_nosymbols_find_inliner_info
778 #define wasm_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
779 #define wasm_read_minisymbols _bfd_generic_read_minisymbols
780 #define wasm_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
782 const bfd_target wasm_vec
=
785 bfd_target_unknown_flavour
,
788 (HAS_SYMS
| WP_TEXT
), /* Object flags. */
789 (SEC_CODE
| SEC_DATA
| SEC_HAS_CONTENTS
), /* Section flags. */
790 0, /* Leading underscore. */
791 ' ', /* AR_pad_char. */
792 255, /* AR_max_namelen. */
793 0, /* Match priority. */
794 /* Routines to byte-swap various sized integers from the data sections. */
795 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
796 bfd_getl32
, bfd_getl_signed_32
, bfd_putl32
,
797 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
,
799 /* Routines to byte-swap various sized integers from the file headers. */
800 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
801 bfd_getl32
, bfd_getl_signed_32
, bfd_putl32
,
802 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
,
806 wasm_object_p
, /* bfd_check_format. */
811 _bfd_bool_bfd_false_error
,
813 _bfd_generic_mkarchive
,
814 _bfd_bool_bfd_false_error
,
816 { /* bfd_write_contents. */
817 _bfd_bool_bfd_false_error
,
818 wasm_write_object_contents
,
819 _bfd_write_archive_contents
,
820 _bfd_bool_bfd_false_error
,
823 BFD_JUMP_TABLE_GENERIC (_bfd_generic
),
824 BFD_JUMP_TABLE_COPY (_bfd_generic
),
825 BFD_JUMP_TABLE_CORE (_bfd_nocore
),
826 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive
),
827 BFD_JUMP_TABLE_SYMBOLS (wasm
),
828 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs
),
829 BFD_JUMP_TABLE_WRITE (wasm
),
830 BFD_JUMP_TABLE_LINK (_bfd_nolink
),
831 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic
),