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
;
252 if (strcmp (asect
->name
, WASM_NAME_SECTION
) != 0)
256 end
= asect
->contents
+ asect
->size
;
263 bfd_byte subsection_code
= *p
++;
264 if (subsection_code
== WASM_FUNCTION_SUBSECTION
)
267 /* subsection_code is documented to be a varuint7, meaning that
268 it has to be a single byte in the 0 - 127 range. If it isn't,
269 the spec must have changed underneath us, so give up. */
270 if (subsection_code
& 0x80)
273 READ_LEB128 (payload_size
, p
, end
);
275 if (p
> p
+ payload_size
)
284 READ_LEB128 (payload_size
, p
, end
);
286 if (p
> p
+ payload_size
)
289 if (p
+ payload_size
> end
)
292 end
= p
+ payload_size
;
294 READ_LEB128 (symcount
, p
, end
);
296 /* Sanity check: each symbol has at least two bytes. */
297 if (symcount
> payload_size
/2)
300 tdata
->symcount
= symcount
;
302 space_function_index
= bfd_make_section_with_flags
303 (abfd
, WASM_SECTION_FUNCTION_INDEX
, SEC_READONLY
| SEC_CODE
);
305 if (! space_function_index
)
306 space_function_index
= bfd_get_section_by_name (abfd
, WASM_SECTION_FUNCTION_INDEX
);
308 if (! space_function_index
)
311 symbols
= bfd_zalloc (abfd
, tdata
->symcount
* sizeof (asymbol
));
315 for (symcount
= 0; p
< end
&& symcount
< tdata
->symcount
; symcount
++)
322 READ_LEB128 (idx
, p
, end
);
323 READ_LEB128 (len
, p
, end
);
325 if (p
+ len
< p
|| p
+ len
> end
)
328 name
= bfd_zalloc (abfd
, len
+ 1);
332 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
;
354 bfd_release (abfd
, (void *)symbols
[--symcount
].name
);
355 bfd_release (abfd
, symbols
);
359 /* Read a byte from ABFD and return it, or EOF for EOF or error.
360 Set ERRORPTR on non-EOF error. */
363 wasm_read_byte (bfd
*abfd
, bfd_boolean
*errorptr
)
367 if (bfd_bread (&byte
, (bfd_size_type
) 1, abfd
) != 1)
369 if (bfd_get_error () != bfd_error_file_truncated
)
377 /* Scan the wasm module ABFD, creating sections and symbols.
378 Return TRUE on success. */
381 wasm_scan (bfd
*abfd
)
383 bfd_boolean error
= FALSE
;
384 /* Fake VMAs for now. Choose 0x80000000 as base to avoid clashes
385 with actual data addresses. */
386 bfd_vma vma
= 0x80000000;
388 unsigned int bytes_read
;
392 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
395 if (! wasm_read_header (abfd
, &error
))
398 while ((section_code
= wasm_read_byte (abfd
, &error
)) != EOF
)
400 if (section_code
!= 0)
402 const char *sname
= wasm_section_code_to_name (section_code
);
407 name
= strdup (sname
);
408 bfdsec
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
415 bfdsec
->size
= wasm_read_leb128 (abfd
, &error
, &bytes_read
, FALSE
);
418 bfdsec
->filepos
= bfd_tell (abfd
);
419 bfdsec
->alignment_power
= 0;
424 file_ptr section_start
;
426 char *prefix
= WASM_SECTION_PREFIX
;
430 payload_len
= wasm_read_leb128 (abfd
, &error
, &bytes_read
, FALSE
);
433 section_start
= bfd_tell (abfd
);
434 namelen
= wasm_read_leb128 (abfd
, &error
, &bytes_read
, FALSE
);
435 if (error
|| namelen
> payload_len
)
437 name
= bfd_zmalloc (namelen
+ strlen (prefix
) + 1);
441 ret
= sprintf (p
, "%s", prefix
);
442 if (ret
< 0 || (bfd_vma
) ret
!= strlen (prefix
))
445 if (bfd_bread (p
, namelen
, abfd
) != namelen
)
448 bfdsec
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
455 bfdsec
->filepos
= bfd_tell (abfd
);
456 bfdsec
->size
= section_start
+ payload_len
- bfdsec
->filepos
;
457 bfdsec
->alignment_power
= 0;
460 if (bfdsec
->size
!= 0)
462 bfdsec
->contents
= bfd_zalloc (abfd
, bfdsec
->size
);
463 if (! bfdsec
->contents
)
466 if (bfd_bread (bfdsec
->contents
, bfdsec
->size
, abfd
) != bfdsec
->size
)
473 /* Make sure we're at actual EOF. There's no indication in the
474 WebAssembly format of how long the file is supposed to be. */
484 for (bfdsec
= abfd
->sections
; bfdsec
; bfdsec
= bfdsec
->next
)
485 free ((void *) bfdsec
->name
);
490 /* Put a numbered section ASECT of ABFD into the table of numbered
491 sections pointed to by FSARG. */
494 wasm_register_section (bfd
*abfd ATTRIBUTE_UNUSED
,
498 sec_ptr
*numbered_sections
= fsarg
;
499 int idx
= wasm_section_name_to_code (asect
->name
);
504 numbered_sections
[idx
] = asect
;
507 struct compute_section_arg
513 /* Compute the file position of ABFD's section ASECT. FSARG is a
514 pointer to the current file position.
516 We allow section names of the form .wasm.id to encode the numbered
517 section with ID id, if it exists; otherwise, a custom section with
518 ID "id" is produced. Arbitrary section names are for sections that
519 are assumed already to contain a section header; those are appended
520 to the WebAssembly module verbatim. */
523 wasm_compute_custom_section_file_position (bfd
*abfd
,
527 struct compute_section_arg
*fs
= fsarg
;
533 idx
= wasm_section_name_to_code (asect
->name
);
538 if (CONST_STRNEQ (asect
->name
, WASM_SECTION_PREFIX
))
540 const char *name
= asect
->name
+ strlen (WASM_SECTION_PREFIX
);
541 bfd_size_type payload_len
= asect
->size
;
542 bfd_size_type name_len
= strlen (name
);
543 bfd_size_type nl
= name_len
;
545 payload_len
+= name_len
;
554 bfd_seek (abfd
, fs
->pos
, SEEK_SET
);
555 if (! wasm_write_uleb128 (abfd
, 0)
556 || ! wasm_write_uleb128 (abfd
, payload_len
)
557 || ! wasm_write_uleb128 (abfd
, name_len
)
558 || bfd_bwrite (name
, name_len
, abfd
) != name_len
)
560 fs
->pos
= asect
->filepos
= bfd_tell (abfd
);
564 asect
->filepos
= fs
->pos
;
568 fs
->pos
+= asect
->size
;
575 /* Compute the file positions for the sections of ABFD. Currently,
576 this writes all numbered sections first, in order, then all custom
577 sections, in section order.
579 The spec says that the numbered sections must appear in order of
580 their ids, but custom sections can appear in any position and any
581 order, and more than once. FIXME: support that. */
584 wasm_compute_section_file_positions (bfd
*abfd
)
586 bfd_byte magic
[SIZEOF_WASM_MAGIC
] = WASM_MAGIC
;
587 bfd_byte vers
[SIZEOF_WASM_VERSION
] = WASM_VERSION
;
588 sec_ptr numbered_sections
[WASM_NUMBERED_SECTIONS
];
589 struct compute_section_arg fs
;
592 bfd_seek (abfd
, (bfd_vma
) 0, SEEK_SET
);
594 if (bfd_bwrite (magic
, sizeof (magic
), abfd
) != (sizeof magic
)
595 || bfd_bwrite (vers
, sizeof (vers
), abfd
) != sizeof (vers
))
598 for (i
= 0; i
< WASM_NUMBERED_SECTIONS
; i
++)
599 numbered_sections
[i
] = NULL
;
601 bfd_map_over_sections (abfd
, wasm_register_section
, numbered_sections
);
603 fs
.pos
= bfd_tell (abfd
);
604 for (i
= 0; i
< WASM_NUMBERED_SECTIONS
; i
++)
606 sec_ptr sec
= numbered_sections
[i
];
612 if (bfd_seek (abfd
, fs
.pos
, SEEK_SET
) != 0)
614 if (! wasm_write_uleb128 (abfd
, i
)
615 || ! wasm_write_uleb128 (abfd
, size
))
617 fs
.pos
= sec
->filepos
= bfd_tell (abfd
);
623 bfd_map_over_sections (abfd
, wasm_compute_custom_section_file_position
, &fs
);
628 abfd
->output_has_begun
= TRUE
;
634 wasm_set_section_contents (bfd
*abfd
,
636 const void *location
,
643 if (! abfd
->output_has_begun
644 && ! wasm_compute_section_file_positions (abfd
))
647 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0
648 || bfd_bwrite (location
, count
, abfd
) != count
)
655 wasm_write_object_contents (bfd
* abfd
)
657 bfd_byte magic
[] = WASM_MAGIC
;
658 bfd_byte vers
[] = WASM_VERSION
;
660 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0)
663 if (bfd_bwrite (magic
, sizeof (magic
), abfd
) != sizeof (magic
)
664 || bfd_bwrite (vers
, sizeof (vers
), abfd
) != sizeof (vers
))
671 wasm_mkobject (bfd
*abfd
)
673 tdata_type
*tdata
= (tdata_type
*) bfd_alloc (abfd
, sizeof (tdata_type
));
678 tdata
->symbols
= NULL
;
681 abfd
->tdata
.any
= tdata
;
687 wasm_get_symtab_upper_bound (bfd
*abfd
)
689 tdata_type
*tdata
= abfd
->tdata
.any
;
691 return (tdata
->symcount
+ 1) * (sizeof (asymbol
*));
695 wasm_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
697 tdata_type
*tdata
= abfd
->tdata
.any
;
700 for (i
= 0; i
< tdata
->symcount
; i
++)
701 alocation
[i
] = &tdata
->symbols
[i
];
704 return tdata
->symcount
;
708 wasm_make_empty_symbol (bfd
*abfd
)
710 bfd_size_type amt
= sizeof (asymbol
);
711 asymbol
*new_symbol
= (asymbol
*) bfd_zalloc (abfd
, amt
);
715 new_symbol
->the_bfd
= abfd
;
720 wasm_print_symbol (bfd
*abfd
,
723 bfd_print_symbol_type how
)
725 FILE *file
= (FILE *) filep
;
729 case bfd_print_symbol_name
:
730 fprintf (file
, "%s", symbol
->name
);
734 bfd_print_symbol_vandf (abfd
, filep
, symbol
);
735 fprintf (file
, " %-5s %s", symbol
->section
->name
, symbol
->name
);
740 wasm_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
744 bfd_symbol_info (symbol
, ret
);
747 /* Check whether ABFD is a WebAssembly module; if so, scan it. */
749 static const bfd_target
*
750 wasm_object_p (bfd
*abfd
)
754 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
757 if (! wasm_read_header (abfd
, &error
))
759 bfd_set_error (bfd_error_wrong_format
);
763 if (! wasm_mkobject (abfd
) || ! wasm_scan (abfd
))
766 if (! bfd_default_set_arch_mach (abfd
, bfd_arch_wasm32
, 0))
769 if (wasm_scan_name_function_section (abfd
, bfd_get_section_by_name (abfd
, WASM_NAME_SECTION
)))
770 abfd
->flags
|= HAS_SYMS
;
775 /* BFD_JUMP_TABLE_WRITE */
776 #define wasm_set_arch_mach _bfd_generic_set_arch_mach
778 /* BFD_JUMP_TABLE_SYMBOLS */
779 #define wasm_get_symbol_version_string _bfd_nosymbols_get_symbol_version_string
780 #define wasm_bfd_is_local_label_name bfd_generic_is_local_label_name
781 #define wasm_bfd_is_target_special_symbol _bfd_bool_bfd_asymbol_false
782 #define wasm_get_lineno _bfd_nosymbols_get_lineno
783 #define wasm_find_nearest_line _bfd_nosymbols_find_nearest_line
784 #define wasm_find_line _bfd_nosymbols_find_line
785 #define wasm_find_inliner_info _bfd_nosymbols_find_inliner_info
786 #define wasm_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
787 #define wasm_read_minisymbols _bfd_generic_read_minisymbols
788 #define wasm_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
790 const bfd_target wasm_vec
=
793 bfd_target_unknown_flavour
,
796 (HAS_SYMS
| WP_TEXT
), /* Object flags. */
797 (SEC_CODE
| SEC_DATA
| SEC_HAS_CONTENTS
), /* Section flags. */
798 0, /* Leading underscore. */
799 ' ', /* AR_pad_char. */
800 255, /* AR_max_namelen. */
801 0, /* Match priority. */
802 /* Routines to byte-swap various sized integers from the data sections. */
803 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
804 bfd_getl32
, bfd_getl_signed_32
, bfd_putl32
,
805 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
,
807 /* Routines to byte-swap various sized integers from the file headers. */
808 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
809 bfd_getl32
, bfd_getl_signed_32
, bfd_putl32
,
810 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
,
814 wasm_object_p
, /* bfd_check_format. */
819 _bfd_bool_bfd_false_error
,
821 _bfd_generic_mkarchive
,
822 _bfd_bool_bfd_false_error
,
824 { /* bfd_write_contents. */
825 _bfd_bool_bfd_false_error
,
826 wasm_write_object_contents
,
827 _bfd_write_archive_contents
,
828 _bfd_bool_bfd_false_error
,
831 BFD_JUMP_TABLE_GENERIC (_bfd_generic
),
832 BFD_JUMP_TABLE_COPY (_bfd_generic
),
833 BFD_JUMP_TABLE_CORE (_bfd_nocore
),
834 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive
),
835 BFD_JUMP_TABLE_SYMBOLS (wasm
),
836 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs
),
837 BFD_JUMP_TABLE_WRITE (wasm
),
838 BFD_JUMP_TABLE_LINK (_bfd_nolink
),
839 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic
),