1 /* BFD back-end for WebAssembly modules.
2 Copyright (C) 2017-2023 Free Software Foundation, Inc.
3
4 Based on srec.c, mmo.c, and binary.c
5
6 This file is part of BFD, the Binary File Descriptor library.
7
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.
12
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.
17
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. */
22
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. */
27
28 #include "sysdep.h"
29 #include "bfd.h"
30 #include "libiberty.h"
31 #include "libbfd.h"
32 #include "wasm-module.h"
33
34 #include <limits.h>
35 #ifndef CHAR_BIT
36 #define CHAR_BIT 8
37 #endif
38
39 typedef struct
40 {
41 asymbol * symbols;
42 bfd_size_type symcount;
43 } tdata_type;
44
45 static const char * const wasm_numbered_sections[] =
46 {
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"),
59 };
60
61 #define WASM_NUMBERED_SECTIONS ARRAY_SIZE (wasm_numbered_sections)
62
63 /* Resolve SECTION_CODE to a section name if there is one, NULL
64 otherwise. */
65
66 static const char *
67 wasm_section_code_to_name (bfd_byte section_code)
68 {
69 if (section_code < WASM_NUMBERED_SECTIONS)
70 return wasm_numbered_sections[section_code];
71
72 return NULL;
73 }
74
75 /* Translate section name NAME to a section code, or 0 if it's a
76 custom name. */
77
78 static unsigned int
79 wasm_section_name_to_code (const char *name)
80 {
81 unsigned i;
82
83 for (i = 1; i < WASM_NUMBERED_SECTIONS; i++)
84 if (strcmp (name, wasm_numbered_sections[i]) == 0)
85 return i;
86
87 return 0;
88 }
89
90 /* WebAssembly LEB128 integers are sufficiently like DWARF LEB128
91 integers that we use _bfd_safe_read_leb128, but there are two
92 points of difference:
93
94 - WebAssembly requires a 32-bit value to be encoded in at most 5
95 bytes, etc.
96 - _bfd_safe_read_leb128 accepts incomplete LEB128 encodings at the
97 end of the buffer, while these are invalid in WebAssembly.
98
99 Those differences mean that we will accept some files that are
100 invalid WebAssembly. */
101
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. */
106
107 static bfd_vma
108 wasm_read_leb128 (bfd *abfd,
109 bool *error_return,
110 unsigned int *length_return,
111 bool sign)
112 {
113 bfd_vma result = 0;
114 unsigned int num_read = 0;
115 unsigned int shift = 0;
116 unsigned char byte = 0;
117 unsigned char lost, mask;
118 int status = 1;
119
120 while (bfd_bread (&byte, 1, abfd) == 1)
121 {
122 num_read++;
123
124 if (shift < CHAR_BIT * sizeof (result))
125 {
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);
131 shift += 7;
132 }
133 else
134 {
135 lost = byte;
136 mask = 0x7f;
137 }
138 if ((lost & mask) != (sign && (bfd_signed_vma) result < 0 ? mask : 0))
139 status |= 2;
140
141 if ((byte & 0x80) == 0)
142 {
143 status &= ~1;
144 if (sign && shift < CHAR_BIT * sizeof (result) && (byte & 0x40))
145 result |= -((bfd_vma) 1 << shift);
146 break;
147 }
148 }
149
150 if (length_return != NULL)
151 *length_return = num_read;
152 if (error_return != NULL)
153 *error_return = status != 0;
154
155 return result;
156 }
157
158 /* Encode an integer V as LEB128 and write it to ABFD, return TRUE on
159 success. */
160
161 static bool
162 wasm_write_uleb128 (bfd *abfd, bfd_vma v)
163 {
164 do
165 {
166 bfd_byte c = v & 0x7f;
167 v >>= 7;
168
169 if (v)
170 c |= 0x80;
171
172 if (bfd_bwrite (&c, 1, abfd) != 1)
173 return false;
174 }
175 while (v);
176
177 return true;
178 }
179
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) \
183 do \
184 { \
185 if ((p) >= (end)) \
186 goto error_return; \
187 (x) = _bfd_safe_read_leb128 (abfd, &(p), false, (end)); \
188 } \
189 while (0)
190
191 /* Verify the magic number at the beginning of a WebAssembly module
192 ABFD, setting ERRORPTR if there's a mismatch. */
193
194 static bool
195 wasm_read_magic (bfd *abfd, bool *errorptr)
196 {
197 bfd_byte magic_const[SIZEOF_WASM_MAGIC] = WASM_MAGIC;
198 bfd_byte magic[SIZEOF_WASM_MAGIC];
199
200 if (bfd_bread (magic, sizeof (magic), abfd) == sizeof (magic)
201 && memcmp (magic, magic_const, sizeof (magic)) == 0)
202 return true;
203
204 *errorptr = true;
205 return false;
206 }
207
208 /* Read the version number from ABFD, returning TRUE if it's a supported
209 version. Set ERRORPTR otherwise. */
210
211 static bool
212 wasm_read_version (bfd *abfd, bool *errorptr)
213 {
214 bfd_byte vers_const[SIZEOF_WASM_VERSION] = WASM_VERSION;
215 bfd_byte vers[SIZEOF_WASM_VERSION];
216
217 if (bfd_bread (vers, sizeof (vers), abfd) == sizeof (vers)
218 /* Don't attempt to parse newer versions, which are likely to
219 require code changes. */
220 && memcmp (vers, vers_const, sizeof (vers)) == 0)
221 return true;
222
223 *errorptr = true;
224 return false;
225 }
226
227 /* Read the WebAssembly header (magic number plus version number) from
228 ABFD, setting ERRORPTR to TRUE if there is a mismatch. */
229
230 static bool
231 wasm_read_header (bfd *abfd, bool *errorptr)
232 {
233 if (! wasm_read_magic (abfd, errorptr))
234 return false;
235
236 if (! wasm_read_version (abfd, errorptr))
237 return false;
238
239 return true;
240 }
241
242 /* Scan the "function" subsection of the "name" section ASECT in the
243 wasm module ABFD. Create symbols. Return TRUE on success. */
244
245 static bool
246 wasm_scan_name_function_section (bfd *abfd, sec_ptr asect)
247 {
248 bfd_byte *p;
249 bfd_byte *end;
250 bfd_vma payload_size;
251 bfd_vma symcount = 0;
252 tdata_type *tdata = abfd->tdata.any;
253 asymbol *symbols = NULL;
254 sec_ptr space_function_index;
255 size_t amt;
256
257 p = asect->contents;
258 end = asect->contents + asect->size;
259
260 if (!p)
261 return false;
262
263 while (p < end)
264 {
265 bfd_byte subsection_code = *p++;
266 if (subsection_code == WASM_FUNCTION_SUBSECTION)
267 break;
268
269 /* subsection_code is documented to be a varuint7, meaning that
270 it has to be a single byte in the 0 - 127 range. If it isn't,
271 the spec must have changed underneath us, so give up. */
272 if (subsection_code & 0x80)
273 return false;
274
275 READ_LEB128 (payload_size, p, end);
276
277 if (payload_size > (size_t) (end - p))
278 return false;
279
280 p += payload_size;
281 }
282
283 if (p >= end)
284 return false;
285
286 READ_LEB128 (payload_size, p, end);
287
288 if (payload_size > (size_t) (end - p))
289 return false;
290
291 end = p + payload_size;
292
293 READ_LEB128 (symcount, p, end);
294
295 /* Sanity check: each symbol has at least two bytes. */
296 if (symcount > payload_size / 2)
297 return false;
298
299 tdata->symcount = symcount;
300
301 space_function_index
302 = bfd_make_section_with_flags (abfd, WASM_SECTION_FUNCTION_INDEX,
303 SEC_READONLY | SEC_CODE);
304
305 if (!space_function_index)
306 space_function_index
307 = bfd_get_section_by_name (abfd, WASM_SECTION_FUNCTION_INDEX);
308
309 if (!space_function_index)
310 return false;
311
312 if (_bfd_mul_overflow (tdata->symcount, sizeof (asymbol), &amt))
313 {
314 bfd_set_error (bfd_error_file_too_big);
315 return false;
316 }
317 symbols = bfd_alloc (abfd, amt);
318 if (!symbols)
319 return false;
320
321 for (symcount = 0; p < end && symcount < tdata->symcount; symcount++)
322 {
323 bfd_vma idx;
324 bfd_vma len;
325 char *name;
326 asymbol *sym;
327
328 READ_LEB128 (idx, p, end);
329 READ_LEB128 (len, p, end);
330
331 if (len > (size_t) (end - p))
332 goto error_return;
333
334 name = bfd_alloc (abfd, len + 1);
335 if (!name)
336 goto error_return;
337
338 memcpy (name, p, len);
339 name[len] = 0;
340 p += len;
341
342 sym = &symbols[symcount];
343 sym->the_bfd = abfd;
344 sym->name = name;
345 sym->value = idx;
346 sym->flags = BSF_GLOBAL | BSF_FUNCTION;
347 sym->section = space_function_index;
348 sym->udata.p = NULL;
349 }
350
351 if (symcount < tdata->symcount)
352 goto error_return;
353
354 tdata->symbols = symbols;
355 abfd->symcount = symcount;
356
357 return true;
358
359 error_return:
360 if (symbols)
361 bfd_release (abfd, symbols);
362 tdata->symcount = 0;
363 return false;
364 }
365
366 /* Read a byte from ABFD and return it, or EOF for EOF or error.
367 Set ERRORPTR on non-EOF error. */
368
369 static int
370 wasm_read_byte (bfd *abfd, bool *errorptr)
371 {
372 bfd_byte byte;
373
374 if (bfd_bread (&byte, (bfd_size_type) 1, abfd) != 1)
375 {
376 if (bfd_get_error () != bfd_error_file_truncated)
377 *errorptr = true;
378 return EOF;
379 }
380
381 return byte;
382 }
383
384 /* Scan the wasm module ABFD, creating sections and symbols.
385 Return TRUE on success. */
386
387 static bool
388 wasm_scan (bfd *abfd)
389 {
390 bool error = false;
391 /* Fake VMAs for now. Choose 0x80000000 as base to avoid clashes
392 with actual data addresses. */
393 bfd_vma vma = 0x80000000;
394 int section_code;
395 unsigned int bytes_read;
396 asection *bfdsec;
397
398 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
399 goto error_return;
400
401 if (!wasm_read_header (abfd, &error))
402 goto error_return;
403
404 while ((section_code = wasm_read_byte (abfd, &error)) != EOF)
405 {
406 if (section_code != 0)
407 {
408 const char *sname = wasm_section_code_to_name (section_code);
409
410 if (!sname)
411 goto error_return;
412
413 bfdsec = bfd_make_section_anyway_with_flags (abfd, sname,
414 SEC_HAS_CONTENTS);
415 if (bfdsec == NULL)
416 goto error_return;
417
418 bfdsec->size = wasm_read_leb128 (abfd, &error, &bytes_read, false);
419 if (error)
420 goto error_return;
421 }
422 else
423 {
424 bfd_vma payload_len;
425 bfd_vma namelen;
426 char *name;
427 char *prefix = WASM_SECTION_PREFIX;
428 size_t prefixlen = strlen (prefix);
429 ufile_ptr filesize;
430
431 payload_len = wasm_read_leb128 (abfd, &error, &bytes_read, false);
432 if (error)
433 goto error_return;
434 namelen = wasm_read_leb128 (abfd, &error, &bytes_read, false);
435 if (error || bytes_read > payload_len
436 || namelen > payload_len - bytes_read)
437 goto error_return;
438 payload_len -= namelen + bytes_read;
439 filesize = bfd_get_file_size (abfd);
440 if (filesize != 0 && namelen > filesize)
441 {
442 bfd_set_error (bfd_error_file_truncated);
443 return false;
444 }
445 name = bfd_alloc (abfd, namelen + prefixlen + 1);
446 if (!name)
447 goto error_return;
448 memcpy (name, prefix, prefixlen);
449 if (bfd_bread (name + prefixlen, namelen, abfd) != namelen)
450 goto error_return;
451 name[prefixlen + namelen] = 0;
452
453 bfdsec = bfd_make_section_anyway_with_flags (abfd, name,
454 SEC_HAS_CONTENTS);
455 if (bfdsec == NULL)
456 goto error_return;
457
458 bfdsec->size = payload_len;
459 }
460
461 bfdsec->vma = vma;
462 bfdsec->lma = vma;
463 bfdsec->alignment_power = 0;
464 bfdsec->filepos = bfd_tell (abfd);
465 if (bfdsec->size != 0)
466 {
467 bfdsec->contents = _bfd_alloc_and_read (abfd, bfdsec->size,
468 bfdsec->size);
469 if (!bfdsec->contents)
470 goto error_return;
471 }
472
473 vma += bfdsec->size;
474 }
475
476 /* Make sure we're at actual EOF. There's no indication in the
477 WebAssembly format of how long the file is supposed to be. */
478 if (error)
479 goto error_return;
480
481 return true;
482
483 error_return:
484 return false;
485 }
486
487 /* Put a numbered section ASECT of ABFD into the table of numbered
488 sections pointed to by FSARG. */
489
490 static void
491 wasm_register_section (bfd *abfd ATTRIBUTE_UNUSED,
492 asection *asect,
493 void *fsarg)
494 {
495 sec_ptr *numbered_sections = fsarg;
496 int idx = wasm_section_name_to_code (asect->name);
497
498 if (idx == 0)
499 return;
500
501 numbered_sections[idx] = asect;
502 }
503
504 struct compute_section_arg
505 {
506 bfd_vma pos;
507 bool failed;
508 };
509
510 /* Compute the file position of ABFD's section ASECT. FSARG is a
511 pointer to the current file position.
512
513 We allow section names of the form .wasm.id to encode the numbered
514 section with ID id, if it exists; otherwise, a custom section with
515 ID "id" is produced. Arbitrary section names are for sections that
516 are assumed already to contain a section header; those are appended
517 to the WebAssembly module verbatim. */
518
519 static void
520 wasm_compute_custom_section_file_position (bfd *abfd,
521 sec_ptr asect,
522 void *fsarg)
523 {
524 struct compute_section_arg *fs = fsarg;
525 int idx;
526
527 if (fs->failed)
528 return;
529
530 idx = wasm_section_name_to_code (asect->name);
531
532 if (idx != 0)
533 return;
534
535 if (startswith (asect->name, WASM_SECTION_PREFIX))
536 {
537 const char *name = asect->name + strlen (WASM_SECTION_PREFIX);
538 bfd_size_type payload_len = asect->size;
539 bfd_size_type name_len = strlen (name);
540 bfd_size_type nl = name_len;
541
542 payload_len += name_len;
543
544 do
545 {
546 payload_len++;
547 nl >>= 7;
548 }
549 while (nl);
550
551 bfd_seek (abfd, fs->pos, SEEK_SET);
552 if (! wasm_write_uleb128 (abfd, 0)
553 || ! wasm_write_uleb128 (abfd, payload_len)
554 || ! wasm_write_uleb128 (abfd, name_len)
555 || bfd_bwrite (name, name_len, abfd) != name_len)
556 goto error_return;
557 fs->pos = asect->filepos = bfd_tell (abfd);
558 }
559 else
560 {
561 asect->filepos = fs->pos;
562 }
563
564
565 fs->pos += asect->size;
566 return;
567
568 error_return:
569 fs->failed = true;
570 }
571
572 /* Compute the file positions for the sections of ABFD. Currently,
573 this writes all numbered sections first, in order, then all custom
574 sections, in section order.
575
576 The spec says that the numbered sections must appear in order of
577 their ids, but custom sections can appear in any position and any
578 order, and more than once. FIXME: support that. */
579
580 static bool
581 wasm_compute_section_file_positions (bfd *abfd)
582 {
583 bfd_byte magic[SIZEOF_WASM_MAGIC] = WASM_MAGIC;
584 bfd_byte vers[SIZEOF_WASM_VERSION] = WASM_VERSION;
585 sec_ptr numbered_sections[WASM_NUMBERED_SECTIONS];
586 struct compute_section_arg fs;
587 unsigned int i;
588
589 bfd_seek (abfd, (bfd_vma) 0, SEEK_SET);
590
591 if (bfd_bwrite (magic, sizeof (magic), abfd) != (sizeof magic)
592 || bfd_bwrite (vers, sizeof (vers), abfd) != sizeof (vers))
593 return false;
594
595 for (i = 0; i < WASM_NUMBERED_SECTIONS; i++)
596 numbered_sections[i] = NULL;
597
598 bfd_map_over_sections (abfd, wasm_register_section, numbered_sections);
599
600 fs.pos = bfd_tell (abfd);
601 for (i = 0; i < WASM_NUMBERED_SECTIONS; i++)
602 {
603 sec_ptr sec = numbered_sections[i];
604 bfd_size_type size;
605
606 if (! sec)
607 continue;
608 size = sec->size;
609 if (bfd_seek (abfd, fs.pos, SEEK_SET) != 0)
610 return false;
611 if (! wasm_write_uleb128 (abfd, i)
612 || ! wasm_write_uleb128 (abfd, size))
613 return false;
614 fs.pos = sec->filepos = bfd_tell (abfd);
615 fs.pos += size;
616 }
617
618 fs.failed = false;
619
620 bfd_map_over_sections (abfd, wasm_compute_custom_section_file_position, &fs);
621
622 if (fs.failed)
623 return false;
624
625 abfd->output_has_begun = true;
626
627 return true;
628 }
629
630 static bool
631 wasm_set_section_contents (bfd *abfd,
632 sec_ptr section,
633 const void *location,
634 file_ptr offset,
635 bfd_size_type count)
636 {
637 if (count == 0)
638 return true;
639
640 if (! abfd->output_has_begun
641 && ! wasm_compute_section_file_positions (abfd))
642 return false;
643
644 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
645 || bfd_bwrite (location, count, abfd) != count)
646 return false;
647
648 return true;
649 }
650
651 static bool
652 wasm_write_object_contents (bfd* abfd)
653 {
654 bfd_byte magic[] = WASM_MAGIC;
655 bfd_byte vers[] = WASM_VERSION;
656
657 if (bfd_seek (abfd, 0, SEEK_SET) != 0)
658 return false;
659
660 if (bfd_bwrite (magic, sizeof (magic), abfd) != sizeof (magic)
661 || bfd_bwrite (vers, sizeof (vers), abfd) != sizeof (vers))
662 return false;
663
664 return true;
665 }
666
667 static bool
668 wasm_mkobject (bfd *abfd)
669 {
670 tdata_type *tdata = (tdata_type *) bfd_alloc (abfd, sizeof (tdata_type));
671
672 if (! tdata)
673 return false;
674
675 tdata->symbols = NULL;
676 tdata->symcount = 0;
677
678 abfd->tdata.any = tdata;
679
680 return true;
681 }
682
683 static long
684 wasm_get_symtab_upper_bound (bfd *abfd)
685 {
686 tdata_type *tdata = abfd->tdata.any;
687
688 return (tdata->symcount + 1) * (sizeof (asymbol *));
689 }
690
691 static long
692 wasm_canonicalize_symtab (bfd *abfd, asymbol **alocation)
693 {
694 tdata_type *tdata = abfd->tdata.any;
695 size_t i;
696
697 for (i = 0; i < tdata->symcount; i++)
698 alocation[i] = &tdata->symbols[i];
699 alocation[i] = NULL;
700
701 return tdata->symcount;
702 }
703
704 static asymbol *
705 wasm_make_empty_symbol (bfd *abfd)
706 {
707 size_t amt = sizeof (asymbol);
708 asymbol *new_symbol = (asymbol *) bfd_zalloc (abfd, amt);
709
710 if (! new_symbol)
711 return NULL;
712 new_symbol->the_bfd = abfd;
713 return new_symbol;
714 }
715
716 static void
717 wasm_print_symbol (bfd *abfd,
718 void * filep,
719 asymbol *symbol,
720 bfd_print_symbol_type how)
721 {
722 FILE *file = (FILE *) filep;
723
724 switch (how)
725 {
726 case bfd_print_symbol_name:
727 fprintf (file, "%s", symbol->name);
728 break;
729
730 default:
731 bfd_print_symbol_vandf (abfd, filep, symbol);
732 fprintf (file, " %-5s %s", symbol->section->name, symbol->name);
733 }
734 }
735
736 static void
737 wasm_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
738 asymbol *symbol,
739 symbol_info *ret)
740 {
741 bfd_symbol_info (symbol, ret);
742 }
743
744 /* Check whether ABFD is a WebAssembly module; if so, scan it. */
745
746 static bfd_cleanup
747 wasm_object_p (bfd *abfd)
748 {
749 bool error;
750 asection *s;
751
752 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
753 return NULL;
754
755 if (!wasm_read_header (abfd, &error))
756 {
757 bfd_set_error (bfd_error_wrong_format);
758 return NULL;
759 }
760
761 if (!wasm_mkobject (abfd))
762 return NULL;
763
764 if (!wasm_scan (abfd)
765 || !bfd_default_set_arch_mach (abfd, bfd_arch_wasm32, 0))
766 {
767 bfd_release (abfd, abfd->tdata.any);
768 abfd->tdata.any = NULL;
769 return NULL;
770 }
771
772 s = bfd_get_section_by_name (abfd, WASM_NAME_SECTION);
773 if (s != NULL && wasm_scan_name_function_section (abfd, s))
774 abfd->flags |= HAS_SYMS;
775
776 return _bfd_no_cleanup;
777 }
778
779 /* BFD_JUMP_TABLE_WRITE */
780 #define wasm_set_arch_mach _bfd_generic_set_arch_mach
781
782 /* BFD_JUMP_TABLE_SYMBOLS */
783 #define wasm_get_symbol_version_string _bfd_nosymbols_get_symbol_version_string
784 #define wasm_bfd_is_local_label_name bfd_generic_is_local_label_name
785 #define wasm_bfd_is_target_special_symbol _bfd_bool_bfd_asymbol_false
786 #define wasm_get_lineno _bfd_nosymbols_get_lineno
787 #define wasm_find_nearest_line _bfd_nosymbols_find_nearest_line
788 #define wasm_find_nearest_line_with_alt _bfd_nosymbols_find_nearest_line_with_alt
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
794
795 const bfd_target wasm_vec =
796 {
797 "wasm", /* Name. */
798 bfd_target_unknown_flavour,
799 BFD_ENDIAN_LITTLE,
800 BFD_ENDIAN_LITTLE,
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,
812
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,
817
818 {
819 _bfd_dummy_target,
820 wasm_object_p, /* bfd_check_format. */
821 _bfd_dummy_target,
822 _bfd_dummy_target,
823 },
824 {
825 _bfd_bool_bfd_false_error,
826 wasm_mkobject,
827 _bfd_generic_mkarchive,
828 _bfd_bool_bfd_false_error,
829 },
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,
835 },
836
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),
846
847 NULL,
848
849 NULL,
850 };