1 /* Opcode printing code for the WebAssembly target
2 Copyright (C) 2017-2021 Free Software Foundation, Inc.
4 This file is part of libopcodes.
6 This library is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 It is distributed in the hope that it will be useful, but WITHOUT
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
14 License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
22 #include "disassemble.h"
24 #include "safe-ctype.h"
25 #include "floatformat.h"
26 #include "libiberty.h"
28 #include "elf/internal.h"
29 #include "elf/wasm32.h"
39 /* Type names for blocks and signatures. */
40 #define BLOCK_TYPE_NONE 0x40
41 #define BLOCK_TYPE_I32 0x7f
42 #define BLOCK_TYPE_I64 0x7e
43 #define BLOCK_TYPE_F32 0x7d
44 #define BLOCK_TYPE_F64 0x7c
78 struct wasm32_private_data
81 bool print_well_known_globals
;
83 /* Limit valid symbols to those with a given prefix. */
84 const char *section_prefix
;
90 const char *description
;
93 static const wasm32_options_t options
[] =
95 { "registers", N_("Disassemble \"register\" names") },
96 { "globals", N_("Name well-known globals") },
99 #define WASM_OPCODE(opcode, name, intype, outtype, clas, signedness) \
100 { name, wasm_ ## clas, opcode },
102 struct wasm32_opcode_s
105 enum wasm_class clas
;
106 unsigned char opcode
;
109 #include "opcode/wasm.h"
113 /* Parse the disassembler options in OPTS and initialize INFO. */
116 parse_wasm32_disassembler_options (struct disassemble_info
*info
,
119 struct wasm32_private_data
*private = info
->private_data
;
123 if (startswith (opts
, "registers"))
124 private->print_registers
= true;
125 else if (startswith (opts
, "globals"))
126 private->print_well_known_globals
= true;
128 opts
= strchr (opts
, ',');
134 /* Check whether SYM is valid. Special-case absolute symbols, which
135 are unhelpful to print, and arguments to a "call" insn, which we
136 want to be in a section matching a given prefix. */
139 wasm32_symbol_is_valid (asymbol
*sym
,
140 struct disassemble_info
*info
)
142 struct wasm32_private_data
*private_data
= info
->private_data
;
147 if (strcmp(sym
->section
->name
, "*ABS*") == 0)
150 if (private_data
&& private_data
->section_prefix
!= NULL
151 && strncmp (sym
->section
->name
, private_data
->section_prefix
,
152 strlen (private_data
->section_prefix
)))
158 /* Initialize the disassembler structures for INFO. */
161 disassemble_init_wasm32 (struct disassemble_info
*info
)
163 if (info
->private_data
== NULL
)
165 static struct wasm32_private_data
private;
167 private.print_registers
= false;
168 private.print_well_known_globals
= false;
169 private.section_prefix
= NULL
;
171 info
->private_data
= &private;
174 if (info
->disassembler_options
)
176 parse_wasm32_disassembler_options (info
, info
->disassembler_options
);
178 info
->disassembler_options
= NULL
;
181 info
->symbol_is_valid
= wasm32_symbol_is_valid
;
184 /* Read an LEB128-encoded integer from INFO at address PC, reading one
185 byte at a time. Set ERROR_RETURN if no complete integer could be
186 read, LENGTH_RETURN to the number oof bytes read (including bytes
187 in incomplete numbers). SIGN means interpret the number as
188 SLEB128. Unfortunately, this is a duplicate of wasm-module.c's
189 wasm_read_leb128 (). */
192 wasm_read_leb128 (bfd_vma pc
,
193 struct disassemble_info
*info
,
195 unsigned int *length_return
,
199 unsigned int num_read
= 0;
200 unsigned int shift
= 0;
201 unsigned char byte
= 0;
202 unsigned char lost
, mask
;
205 while (info
->read_memory_func (pc
+ num_read
, &byte
, 1, info
) == 0)
209 if (shift
< CHAR_BIT
* sizeof (result
))
211 result
|= ((uint64_t) (byte
& 0x7f)) << shift
;
212 /* These bits overflowed. */
213 lost
= byte
^ (result
>> shift
);
214 /* And this is the mask of possible overflow bits. */
215 mask
= 0x7f ^ ((uint64_t) 0x7f << shift
>> shift
);
223 if ((lost
& mask
) != (sign
&& (int64_t) result
< 0 ? mask
: 0))
226 if ((byte
& 0x80) == 0)
229 if (sign
&& shift
< CHAR_BIT
* sizeof (result
) && (byte
& 0x40))
230 result
|= -((uint64_t) 1 << shift
);
235 if (length_return
!= NULL
)
236 *length_return
= num_read
;
237 if (error_return
!= NULL
)
238 *error_return
= status
!= 0;
243 /* Read a 32-bit IEEE float from PC using INFO, convert it to a host
244 double, and store it at VALUE. */
247 read_f32 (double *value
, bfd_vma pc
, struct disassemble_info
*info
)
251 if (info
->read_memory_func (pc
, buf
, sizeof (buf
), info
))
254 floatformat_to_double (&floatformat_ieee_single_little
, buf
,
260 /* Read a 64-bit IEEE float from PC using INFO, convert it to a host
261 double, and store it at VALUE. */
264 read_f64 (double *value
, bfd_vma pc
, struct disassemble_info
*info
)
268 if (info
->read_memory_func (pc
, buf
, sizeof (buf
), info
))
271 floatformat_to_double (&floatformat_ieee_double_little
, buf
,
277 /* Main disassembly routine. Disassemble insn at PC using INFO. */
280 print_insn_wasm32 (bfd_vma pc
, struct disassemble_info
*info
)
282 unsigned char opcode
;
283 struct wasm32_opcode_s
*op
;
285 void *stream
= info
->stream
;
286 fprintf_ftype prin
= info
->fprintf_func
;
287 struct wasm32_private_data
*private_data
= info
->private_data
;
290 unsigned int bytes_read
;
293 if (info
->read_memory_func (pc
, buffer
, 1, info
))
298 for (op
= wasm32_opcodes
; op
->name
; op
++)
299 if (op
->opcode
== opcode
)
304 prin (stream
, "\t.byte 0x%02x\n", buffer
[0]);
311 prin (stream
, "%s", op
->name
);
313 if (op
->clas
== wasm_typed
)
315 val
= wasm_read_leb128 (pc
+ len
, info
, &error
, &bytes_read
, false);
321 case BLOCK_TYPE_NONE
:
325 prin (stream
, "[i]");
328 prin (stream
, "[l]");
331 prin (stream
, "[f]");
334 prin (stream
, "[d]");
348 case wasm_relational
:
351 case wasm_call_import
:
356 case wasm_break_table
:
358 uint32_t target_count
, i
;
359 val
= wasm_read_leb128 (pc
+ len
, info
, &error
, &bytes_read
,
362 if (error
|| target_count
!= val
|| target_count
== (uint32_t) -1)
365 prin (stream
, " %u", target_count
);
366 for (i
= 0; i
< target_count
+ 1; i
++)
369 val
= wasm_read_leb128 (pc
+ len
, info
, &error
, &bytes_read
,
372 if (error
|| target
!= val
)
375 prin (stream
, " %u", target
);
384 val
= wasm_read_leb128 (pc
+ len
, info
, &error
, &bytes_read
,
387 if (error
|| depth
!= val
)
390 prin (stream
, " %u", depth
);
397 case wasm_constant_i32
:
398 case wasm_constant_i64
:
399 val
= wasm_read_leb128 (pc
+ len
, info
, &error
, &bytes_read
, true);
403 prin (stream
, " %" PRId64
, val
);
406 case wasm_constant_f32
:
410 /* This appears to be the best we can do, even though we're
411 using host doubles for WebAssembly floats. */
412 ret
= read_f32 (&fconstant
, pc
+ len
, info
);
416 prin (stream
, " %.9g", fconstant
);
420 case wasm_constant_f64
:
424 ret
= read_f64 (&fconstant
, pc
+ len
, info
);
428 prin (stream
, " %.17g", fconstant
);
434 uint32_t function_index
;
435 val
= wasm_read_leb128 (pc
+ len
, info
, &error
, &bytes_read
,
437 function_index
= val
;
438 if (error
|| function_index
!= val
)
442 private_data
->section_prefix
= ".space.function_index";
443 (*info
->print_address_func
) ((bfd_vma
) function_index
, info
);
444 private_data
->section_prefix
= NULL
;
448 case wasm_call_indirect
:
450 uint32_t type_index
, xtra_index
;
451 val
= wasm_read_leb128 (pc
+ len
, info
, &error
, &bytes_read
,
454 if (error
|| type_index
!= val
)
457 prin (stream
, " %u", type_index
);
458 val
= wasm_read_leb128 (pc
+ len
, info
, &error
, &bytes_read
,
461 if (error
|| xtra_index
!= val
)
464 prin (stream
, " %u", xtra_index
);
472 uint32_t local_index
;
473 val
= wasm_read_leb128 (pc
+ len
, info
, &error
, &bytes_read
,
476 if (error
|| local_index
!= val
)
479 prin (stream
, " %u", local_index
);
480 if (strcmp (op
->name
+ 4, "local") == 0)
482 static const char *locals
[] =
484 "$dpc", "$sp1", "$r0", "$r1", "$rpc", "$pc0",
486 "$r2", "$r3", "$r4", "$r5", "$r6", "$r7",
487 "$i0", "$i1", "$i2", "$i3", "$i4", "$i5", "$i6", "$i7",
488 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
490 if (private_data
->print_registers
491 && local_index
< ARRAY_SIZE (locals
))
492 prin (stream
, " <%s>", locals
[local_index
]);
496 static const char *globals
[] =
498 "$got", "$plt", "$gpo"
500 if (private_data
->print_well_known_globals
501 && local_index
< ARRAY_SIZE (globals
))
502 prin (stream
, " <%s>", globals
[local_index
]);
507 case wasm_grow_memory
:
508 case wasm_current_memory
:
510 uint32_t reserved_size
;
511 val
= wasm_read_leb128 (pc
+ len
, info
, &error
, &bytes_read
,
514 if (error
|| reserved_size
!= val
)
517 prin (stream
, " %u", reserved_size
);
524 uint32_t flags
, offset
;
525 val
= wasm_read_leb128 (pc
+ len
, info
, &error
, &bytes_read
,
528 if (error
|| flags
!= val
)
531 val
= wasm_read_leb128 (pc
+ len
, info
, &error
, &bytes_read
,
534 if (error
|| offset
!= val
)
537 prin (stream
, " a=%u %u", flags
, offset
);
544 /* Print valid disassembler options to STREAM. */
547 print_wasm32_disassembler_options (FILE *stream
)
549 unsigned int i
, max_len
= 0;
551 fprintf (stream
, _("\
552 The following WebAssembly-specific disassembler options are supported for use\n\
553 with the -M switch:\n"));
555 for (i
= 0; i
< ARRAY_SIZE (options
); i
++)
557 unsigned int len
= strlen (options
[i
].name
);
563 for (i
= 0, max_len
++; i
< ARRAY_SIZE (options
); i
++)
564 fprintf (stream
, " %s%*c %s\n",
566 (int)(max_len
- strlen (options
[i
].name
)), ' ',
567 _(options
[i
].description
));