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
;
250 end
= asect
->contents
+ asect
->size
;
257 bfd_byte subsection_code
= *p
++;
258 if (subsection_code
== WASM_FUNCTION_SUBSECTION
)
261 /* subsection_code is documented to be a varuint7, meaning that
262 it has to be a single byte in the 0 - 127 range. If it isn't,
263 the spec must have changed underneath us, so give up. */
264 if (subsection_code
& 0x80)
267 READ_LEB128 (payload_size
, p
, end
);
269 if (payload_size
> (size_t) (end
- p
))
278 READ_LEB128 (payload_size
, p
, end
);
280 if (payload_size
> (size_t) (end
- p
))
283 end
= p
+ payload_size
;
285 READ_LEB128 (symcount
, p
, end
);
287 /* Sanity check: each symbol has at least two bytes. */
288 if (symcount
> payload_size
/ 2)
291 tdata
->symcount
= symcount
;
294 = bfd_make_section_with_flags (abfd
, WASM_SECTION_FUNCTION_INDEX
,
295 SEC_READONLY
| SEC_CODE
);
297 if (!space_function_index
)
299 = bfd_get_section_by_name (abfd
, WASM_SECTION_FUNCTION_INDEX
);
301 if (!space_function_index
)
304 symbols
= bfd_alloc2 (abfd
, tdata
->symcount
, sizeof (asymbol
));
308 for (symcount
= 0; p
< end
&& symcount
< tdata
->symcount
; symcount
++)
315 READ_LEB128 (idx
, p
, end
);
316 READ_LEB128 (len
, p
, end
);
318 if (len
> (size_t) (end
- p
))
321 name
= bfd_alloc (abfd
, len
+ 1);
325 memcpy (name
, p
, len
);
329 sym
= &symbols
[symcount
];
333 sym
->flags
= BSF_GLOBAL
| BSF_FUNCTION
;
334 sym
->section
= space_function_index
;
338 if (symcount
< tdata
->symcount
)
341 tdata
->symbols
= symbols
;
342 abfd
->symcount
= symcount
;
347 bfd_release (abfd
, symbols
);
351 /* Read a byte from ABFD and return it, or EOF for EOF or error.
352 Set ERRORPTR on non-EOF error. */
355 wasm_read_byte (bfd
*abfd
, bfd_boolean
*errorptr
)
359 if (bfd_bread (&byte
, (bfd_size_type
) 1, abfd
) != 1)
361 if (bfd_get_error () != bfd_error_file_truncated
)
369 /* Scan the wasm module ABFD, creating sections and symbols.
370 Return TRUE on success. */
373 wasm_scan (bfd
*abfd
)
375 bfd_boolean error
= FALSE
;
376 /* Fake VMAs for now. Choose 0x80000000 as base to avoid clashes
377 with actual data addresses. */
378 bfd_vma vma
= 0x80000000;
380 unsigned int bytes_read
;
383 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
386 if (!wasm_read_header (abfd
, &error
))
389 while ((section_code
= wasm_read_byte (abfd
, &error
)) != EOF
)
391 if (section_code
!= 0)
393 const char *sname
= wasm_section_code_to_name (section_code
);
398 bfdsec
= bfd_make_section_anyway_with_flags (abfd
, sname
,
405 bfdsec
->size
= wasm_read_leb128 (abfd
, &error
, &bytes_read
, FALSE
);
408 bfdsec
->filepos
= bfd_tell (abfd
);
409 bfdsec
->alignment_power
= 0;
414 file_ptr section_start
;
417 char *prefix
= WASM_SECTION_PREFIX
;
418 size_t prefixlen
= strlen (prefix
);
420 payload_len
= wasm_read_leb128 (abfd
, &error
, &bytes_read
, FALSE
);
423 section_start
= bfd_tell (abfd
);
424 namelen
= wasm_read_leb128 (abfd
, &error
, &bytes_read
, FALSE
);
425 if (error
|| namelen
> payload_len
)
427 name
= bfd_alloc (abfd
, namelen
+ prefixlen
+ 1);
430 memcpy (name
, prefix
, prefixlen
);
431 if (bfd_bread (name
+ prefixlen
, namelen
, abfd
) != namelen
)
433 name
[prefixlen
+ namelen
] = 0;
435 bfdsec
= bfd_make_section_anyway_with_flags (abfd
, name
,
442 bfdsec
->filepos
= bfd_tell (abfd
);
443 bfdsec
->size
= section_start
+ payload_len
- bfdsec
->filepos
;
444 bfdsec
->alignment_power
= 0;
447 if (bfdsec
->size
!= 0)
449 bfdsec
->contents
= bfd_alloc (abfd
, bfdsec
->size
);
450 if (!bfdsec
->contents
)
453 if (bfd_bread (bfdsec
->contents
, bfdsec
->size
, abfd
) != bfdsec
->size
)
460 /* Make sure we're at actual EOF. There's no indication in the
461 WebAssembly format of how long the file is supposed to be. */
471 /* Put a numbered section ASECT of ABFD into the table of numbered
472 sections pointed to by FSARG. */
475 wasm_register_section (bfd
*abfd ATTRIBUTE_UNUSED
,
479 sec_ptr
*numbered_sections
= fsarg
;
480 int idx
= wasm_section_name_to_code (asect
->name
);
485 numbered_sections
[idx
] = asect
;
488 struct compute_section_arg
494 /* Compute the file position of ABFD's section ASECT. FSARG is a
495 pointer to the current file position.
497 We allow section names of the form .wasm.id to encode the numbered
498 section with ID id, if it exists; otherwise, a custom section with
499 ID "id" is produced. Arbitrary section names are for sections that
500 are assumed already to contain a section header; those are appended
501 to the WebAssembly module verbatim. */
504 wasm_compute_custom_section_file_position (bfd
*abfd
,
508 struct compute_section_arg
*fs
= fsarg
;
514 idx
= wasm_section_name_to_code (asect
->name
);
519 if (CONST_STRNEQ (asect
->name
, WASM_SECTION_PREFIX
))
521 const char *name
= asect
->name
+ strlen (WASM_SECTION_PREFIX
);
522 bfd_size_type payload_len
= asect
->size
;
523 bfd_size_type name_len
= strlen (name
);
524 bfd_size_type nl
= name_len
;
526 payload_len
+= name_len
;
535 bfd_seek (abfd
, fs
->pos
, SEEK_SET
);
536 if (! wasm_write_uleb128 (abfd
, 0)
537 || ! wasm_write_uleb128 (abfd
, payload_len
)
538 || ! wasm_write_uleb128 (abfd
, name_len
)
539 || bfd_bwrite (name
, name_len
, abfd
) != name_len
)
541 fs
->pos
= asect
->filepos
= bfd_tell (abfd
);
545 asect
->filepos
= fs
->pos
;
549 fs
->pos
+= asect
->size
;
556 /* Compute the file positions for the sections of ABFD. Currently,
557 this writes all numbered sections first, in order, then all custom
558 sections, in section order.
560 The spec says that the numbered sections must appear in order of
561 their ids, but custom sections can appear in any position and any
562 order, and more than once. FIXME: support that. */
565 wasm_compute_section_file_positions (bfd
*abfd
)
567 bfd_byte magic
[SIZEOF_WASM_MAGIC
] = WASM_MAGIC
;
568 bfd_byte vers
[SIZEOF_WASM_VERSION
] = WASM_VERSION
;
569 sec_ptr numbered_sections
[WASM_NUMBERED_SECTIONS
];
570 struct compute_section_arg fs
;
573 bfd_seek (abfd
, (bfd_vma
) 0, SEEK_SET
);
575 if (bfd_bwrite (magic
, sizeof (magic
), abfd
) != (sizeof magic
)
576 || bfd_bwrite (vers
, sizeof (vers
), abfd
) != sizeof (vers
))
579 for (i
= 0; i
< WASM_NUMBERED_SECTIONS
; i
++)
580 numbered_sections
[i
] = NULL
;
582 bfd_map_over_sections (abfd
, wasm_register_section
, numbered_sections
);
584 fs
.pos
= bfd_tell (abfd
);
585 for (i
= 0; i
< WASM_NUMBERED_SECTIONS
; i
++)
587 sec_ptr sec
= numbered_sections
[i
];
593 if (bfd_seek (abfd
, fs
.pos
, SEEK_SET
) != 0)
595 if (! wasm_write_uleb128 (abfd
, i
)
596 || ! wasm_write_uleb128 (abfd
, size
))
598 fs
.pos
= sec
->filepos
= bfd_tell (abfd
);
604 bfd_map_over_sections (abfd
, wasm_compute_custom_section_file_position
, &fs
);
609 abfd
->output_has_begun
= TRUE
;
615 wasm_set_section_contents (bfd
*abfd
,
617 const void *location
,
624 if (! abfd
->output_has_begun
625 && ! wasm_compute_section_file_positions (abfd
))
628 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0
629 || bfd_bwrite (location
, count
, abfd
) != count
)
636 wasm_write_object_contents (bfd
* abfd
)
638 bfd_byte magic
[] = WASM_MAGIC
;
639 bfd_byte vers
[] = WASM_VERSION
;
641 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0)
644 if (bfd_bwrite (magic
, sizeof (magic
), abfd
) != sizeof (magic
)
645 || bfd_bwrite (vers
, sizeof (vers
), abfd
) != sizeof (vers
))
652 wasm_mkobject (bfd
*abfd
)
654 tdata_type
*tdata
= (tdata_type
*) bfd_alloc (abfd
, sizeof (tdata_type
));
659 tdata
->symbols
= NULL
;
662 abfd
->tdata
.any
= tdata
;
668 wasm_get_symtab_upper_bound (bfd
*abfd
)
670 tdata_type
*tdata
= abfd
->tdata
.any
;
672 return (tdata
->symcount
+ 1) * (sizeof (asymbol
*));
676 wasm_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
678 tdata_type
*tdata
= abfd
->tdata
.any
;
681 for (i
= 0; i
< tdata
->symcount
; i
++)
682 alocation
[i
] = &tdata
->symbols
[i
];
685 return tdata
->symcount
;
689 wasm_make_empty_symbol (bfd
*abfd
)
691 bfd_size_type amt
= sizeof (asymbol
);
692 asymbol
*new_symbol
= (asymbol
*) bfd_zalloc (abfd
, amt
);
696 new_symbol
->the_bfd
= abfd
;
701 wasm_print_symbol (bfd
*abfd
,
704 bfd_print_symbol_type how
)
706 FILE *file
= (FILE *) filep
;
710 case bfd_print_symbol_name
:
711 fprintf (file
, "%s", symbol
->name
);
715 bfd_print_symbol_vandf (abfd
, filep
, symbol
);
716 fprintf (file
, " %-5s %s", symbol
->section
->name
, symbol
->name
);
721 wasm_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
725 bfd_symbol_info (symbol
, ret
);
728 /* Check whether ABFD is a WebAssembly module; if so, scan it. */
730 static const bfd_target
*
731 wasm_object_p (bfd
*abfd
)
736 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
739 if (!wasm_read_header (abfd
, &error
))
741 bfd_set_error (bfd_error_wrong_format
);
745 if (!wasm_mkobject (abfd
))
748 if (!wasm_scan (abfd
)
749 || !bfd_default_set_arch_mach (abfd
, bfd_arch_wasm32
, 0))
751 bfd_release (abfd
, abfd
->tdata
.any
);
752 abfd
->tdata
.any
= NULL
;
756 s
= bfd_get_section_by_name (abfd
, WASM_NAME_SECTION
);
757 if (s
!= NULL
&& wasm_scan_name_function_section (abfd
, s
))
758 abfd
->flags
|= HAS_SYMS
;
763 /* BFD_JUMP_TABLE_WRITE */
764 #define wasm_set_arch_mach _bfd_generic_set_arch_mach
766 /* BFD_JUMP_TABLE_SYMBOLS */
767 #define wasm_get_symbol_version_string _bfd_nosymbols_get_symbol_version_string
768 #define wasm_bfd_is_local_label_name bfd_generic_is_local_label_name
769 #define wasm_bfd_is_target_special_symbol _bfd_bool_bfd_asymbol_false
770 #define wasm_get_lineno _bfd_nosymbols_get_lineno
771 #define wasm_find_nearest_line _bfd_nosymbols_find_nearest_line
772 #define wasm_find_line _bfd_nosymbols_find_line
773 #define wasm_find_inliner_info _bfd_nosymbols_find_inliner_info
774 #define wasm_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
775 #define wasm_read_minisymbols _bfd_generic_read_minisymbols
776 #define wasm_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
778 const bfd_target wasm_vec
=
781 bfd_target_unknown_flavour
,
784 (HAS_SYMS
| WP_TEXT
), /* Object flags. */
785 (SEC_CODE
| SEC_DATA
| SEC_HAS_CONTENTS
), /* Section flags. */
786 0, /* Leading underscore. */
787 ' ', /* AR_pad_char. */
788 255, /* AR_max_namelen. */
789 0, /* Match priority. */
790 /* Routines to byte-swap various sized integers from the data sections. */
791 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
792 bfd_getl32
, bfd_getl_signed_32
, bfd_putl32
,
793 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
,
795 /* Routines to byte-swap various sized integers from the file headers. */
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
,
802 wasm_object_p
, /* bfd_check_format. */
807 _bfd_bool_bfd_false_error
,
809 _bfd_generic_mkarchive
,
810 _bfd_bool_bfd_false_error
,
812 { /* bfd_write_contents. */
813 _bfd_bool_bfd_false_error
,
814 wasm_write_object_contents
,
815 _bfd_write_archive_contents
,
816 _bfd_bool_bfd_false_error
,
819 BFD_JUMP_TABLE_GENERIC (_bfd_generic
),
820 BFD_JUMP_TABLE_COPY (_bfd_generic
),
821 BFD_JUMP_TABLE_CORE (_bfd_nocore
),
822 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive
),
823 BFD_JUMP_TABLE_SYMBOLS (wasm
),
824 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs
),
825 BFD_JUMP_TABLE_WRITE (wasm
),
826 BFD_JUMP_TABLE_LINK (_bfd_nolink
),
827 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic
),