/* Opcode printing code for the WebAssembly target
  Copyright (C) 2017-2024 Free Software Foundation, Inc.

  This file is part of libopcodes.

  This library is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 3 of the License, or
  (at your option) any later version.

  It is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  MA 02110-1301, USA.  */

#include "sysdep.h"
#include "disassemble.h"
#include "opintl.h"
#include "safe-ctype.h"
#include "floatformat.h"
#include "libiberty.h"
#include "elf-bfd.h"
#include "elf/internal.h"
#include "elf/wasm32.h"
#include <stdint.h>

#include <limits.h>
#ifndef CHAR_BIT
#define CHAR_BIT 8
#endif

/* Type names for blocks and signatures.  */
#define BLOCK_TYPE_NONE              0x40
#define BLOCK_TYPE_I32               0x7f
#define BLOCK_TYPE_I64               0x7e
#define BLOCK_TYPE_F32               0x7d
#define BLOCK_TYPE_F64               0x7c

enum wasm_class
{
 wasm_typed,
 wasm_special,
 wasm_break,
 wasm_break_if,
 wasm_break_table,
 wasm_return,
 wasm_call,
 wasm_call_import,
 wasm_call_indirect,
 wasm_get_local,
 wasm_set_local,
 wasm_tee_local,
 wasm_drop,
 wasm_constant_i32,
 wasm_constant_i64,
 wasm_constant_f32,
 wasm_constant_f64,
 wasm_unary,
 wasm_binary,
 wasm_conv,
 wasm_load,
 wasm_store,
 wasm_select,
 wasm_relational,
 wasm_eqz,
 wasm_current_memory,
 wasm_grow_memory,
 wasm_signature
};

struct wasm32_private_data
{
 bool print_registers;
 bool print_well_known_globals;

 /* Limit valid symbols to those with a given prefix.  */
 const char *section_prefix;
};

typedef struct
{
 const char *name;
 const char *description;
} wasm32_options_t;

static const wasm32_options_t options[] =
{
 { "registers", N_("Disassemble \"register\" names") },
 { "globals",   N_("Name well-known globals") },
};

#define WASM_OPCODE(opcode, name, intype, outtype, clas, signedness)     \
 { name, wasm_ ## clas, opcode },

struct wasm32_opcode_s
{
 const char *name;
 enum wasm_class clas;
 unsigned char opcode;
} wasm32_opcodes[] =
{
#include "opcode/wasm.h"
 { NULL, 0, 0 }
};

/* Parse the disassembler options in OPTS and initialize INFO.  */

static void
parse_wasm32_disassembler_options (struct disassemble_info *info,
                                  const char *opts)
{
 struct wasm32_private_data *private = info->private_data;

 while (opts != NULL)
   {
     if (startswith (opts, "registers"))
       private->print_registers = true;
     else if (startswith (opts, "globals"))
       private->print_well_known_globals = true;

     opts = strchr (opts, ',');
     if (opts)
       opts++;
   }
}

/* Check whether SYM is valid.  Special-case absolute symbols, which
  are unhelpful to print, and arguments to a "call" insn, which we
  want to be in a section matching a given prefix.  */

static bool
wasm32_symbol_is_valid (asymbol *sym,
                       struct disassemble_info *info)
{
 struct wasm32_private_data *private_data = info->private_data;

 if (sym == NULL)
   return false;

 if (strcmp(sym->section->name, "*ABS*") == 0)
   return false;

 if (private_data && private_data->section_prefix != NULL
     && strncmp (sym->section->name, private_data->section_prefix,
                 strlen (private_data->section_prefix)))
   return false;

 return true;
}

/* Initialize the disassembler structures for INFO.  */

void
disassemble_init_wasm32 (struct disassemble_info *info)
{
 if (info->private_data == NULL)
   {
     static struct wasm32_private_data private;

     private.print_registers = false;
     private.print_well_known_globals = false;
     private.section_prefix = NULL;

     info->private_data = &private;
   }

 if (info->disassembler_options)
   {
     parse_wasm32_disassembler_options (info, info->disassembler_options);

     info->disassembler_options = NULL;
   }

 info->symbol_is_valid = wasm32_symbol_is_valid;
}

/* Read an LEB128-encoded integer from INFO at address PC, reading one
  byte at a time.  Set ERROR_RETURN if no complete integer could be
  read, LENGTH_RETURN to the number oof bytes read (including bytes
  in incomplete numbers).  SIGN means interpret the number as
  SLEB128.  Unfortunately, this is a duplicate of wasm-module.c's
  wasm_read_leb128 ().  */

static uint64_t
wasm_read_leb128 (bfd_vma pc,
                 struct disassemble_info *info,
                 bool *error_return,
                 unsigned int *length_return,
                 bool sign)
{
 uint64_t result = 0;
 unsigned int num_read = 0;
 unsigned int shift = 0;
 unsigned char byte = 0;
 unsigned char lost, mask;
 int status = 1;

 while (info->read_memory_func (pc + num_read, &byte, 1, info) == 0)
   {
     num_read++;

     if (shift < CHAR_BIT * sizeof (result))
       {
         result |= ((uint64_t) (byte & 0x7f)) << shift;
         /* These bits overflowed.  */
         lost = byte ^ (result >> shift);
         /* And this is the mask of possible overflow bits.  */
         mask = 0x7f ^ ((uint64_t) 0x7f << shift >> shift);
         shift += 7;
       }
     else
       {
         lost = byte;
         mask = 0x7f;
       }
     if ((lost & mask) != (sign && (int64_t) result < 0 ? mask : 0))
       status |= 2;

     if ((byte & 0x80) == 0)
       {
         status &= ~1;
         if (sign && shift < CHAR_BIT * sizeof (result) && (byte & 0x40))
           result |= -((uint64_t) 1 << shift);
         break;
       }
   }

 if (length_return != NULL)
   *length_return = num_read;
 if (error_return != NULL)
   *error_return = status != 0;

 return result;
}

/* Read a 32-bit IEEE float from PC using INFO, convert it to a host
  double, and store it at VALUE.  */

static int
read_f32 (double *value, bfd_vma pc, struct disassemble_info *info)
{
 bfd_byte buf[4];

 if (info->read_memory_func (pc, buf, sizeof (buf), info))
   return -1;

 floatformat_to_double (&floatformat_ieee_single_little, buf,
                        value);

 return sizeof (buf);
}

/* Read a 64-bit IEEE float from PC using INFO, convert it to a host
  double, and store it at VALUE.  */

static int
read_f64 (double *value, bfd_vma pc, struct disassemble_info *info)
{
 bfd_byte buf[8];

 if (info->read_memory_func (pc, buf, sizeof (buf), info))
   return -1;

 floatformat_to_double (&floatformat_ieee_double_little, buf,
                        value);

 return sizeof (buf);
}

/* Main disassembly routine.  Disassemble insn at PC using INFO.  */

int
print_insn_wasm32 (bfd_vma pc, struct disassemble_info *info)
{
 unsigned char opcode;
 struct wasm32_opcode_s *op;
 bfd_byte buffer[16];
 void *stream = info->stream;
 fprintf_ftype prin = info->fprintf_func;
 struct wasm32_private_data *private_data = info->private_data;
 uint64_t val;
 int len;
 unsigned int bytes_read;
 bool error;

 if (info->read_memory_func (pc, buffer, 1, info))
   return -1;

 opcode = buffer[0];

 for (op = wasm32_opcodes; op->name; op++)
   if (op->opcode == opcode)
     break;

 if (!op->name)
   {
     prin (stream, "\t.byte 0x%02x\n", buffer[0]);
     return 1;
   }

 len = 1;

 prin (stream, "\t");
 prin (stream, "%s", op->name);

 if (op->clas == wasm_typed)
   {
     val = wasm_read_leb128 (pc + len, info, &error, &bytes_read, false);
     if (error)
       return -1;
     len += bytes_read;
     switch (val)
       {
       case BLOCK_TYPE_NONE:
         prin (stream, "[]");
         break;
       case BLOCK_TYPE_I32:
         prin (stream, "[i]");
         break;
       case BLOCK_TYPE_I64:
         prin (stream, "[l]");
         break;
       case BLOCK_TYPE_F32:
         prin (stream, "[f]");
         break;
       case BLOCK_TYPE_F64:
         prin (stream, "[d]");
         break;
       default:
         return -1;
       }
   }

 switch (op->clas)
   {
   case wasm_special:
   case wasm_eqz:
   case wasm_binary:
   case wasm_unary:
   case wasm_conv:
   case wasm_relational:
   case wasm_drop:
   case wasm_signature:
   case wasm_call_import:
   case wasm_typed:
   case wasm_select:
     break;

   case wasm_break_table:
     {
       uint32_t target_count, i;
       val = wasm_read_leb128 (pc + len, info, &error, &bytes_read,
                               false);
       target_count = val;
       if (error || target_count != val || target_count == (uint32_t) -1)
         return -1;
       len += bytes_read;
       prin (stream, " %u", target_count);
       for (i = 0; i < target_count + 1; i++)
         {
           uint32_t target;
           val = wasm_read_leb128 (pc + len, info, &error, &bytes_read,
                                   false);
           target = val;
           if (error || target != val)
             return -1;
           len += bytes_read;
           prin (stream, " %u", target);
         }
     }
     break;

   case wasm_break:
   case wasm_break_if:
     {
       uint32_t depth;
       val = wasm_read_leb128 (pc + len, info, &error, &bytes_read,
                               false);
       depth = val;
       if (error || depth != val)
         return -1;
       len += bytes_read;
       prin (stream, " %u", depth);
     }
     break;

   case wasm_return:
     break;

   case wasm_constant_i32:
   case wasm_constant_i64:
     val = wasm_read_leb128 (pc + len, info, &error, &bytes_read, true);
     if (error)
       return -1;
     len += bytes_read;
     prin (stream, " %" PRId64, val);
     break;

   case wasm_constant_f32:
     {
       double fconstant;
       int ret;
       /* This appears to be the best we can do, even though we're
          using host doubles for WebAssembly floats.  */
       ret = read_f32 (&fconstant, pc + len, info);
       if (ret < 0)
         return -1;
       len += ret;
       prin (stream, " %.9g", fconstant);
     }
     break;

   case wasm_constant_f64:
     {
       double fconstant;
       int ret;
       ret = read_f64 (&fconstant, pc + len, info);
       if (ret < 0)
         return -1;
       len += ret;
       prin (stream, " %.17g", fconstant);
     }
     break;

   case wasm_call:
     {
       uint32_t function_index;
       val = wasm_read_leb128 (pc + len, info, &error, &bytes_read,
                               false);
       function_index = val;
       if (error || function_index != val)
         return -1;
       len += bytes_read;
       prin (stream, " ");
       private_data->section_prefix = ".space.function_index";
       (*info->print_address_func) ((bfd_vma) function_index, info);
       private_data->section_prefix = NULL;
     }
     break;

   case wasm_call_indirect:
     {
       uint32_t type_index, xtra_index;
       val = wasm_read_leb128 (pc + len, info, &error, &bytes_read,
                               false);
       type_index = val;
       if (error || type_index != val)
         return -1;
       len += bytes_read;
       prin (stream, " %u", type_index);
       val = wasm_read_leb128 (pc + len, info, &error, &bytes_read,
                               false);
       xtra_index = val;
       if (error || xtra_index != val)
         return -1;
       len += bytes_read;
       prin (stream, " %u", xtra_index);
     }
     break;

   case wasm_get_local:
   case wasm_set_local:
   case wasm_tee_local:
     {
       uint32_t local_index;
       val = wasm_read_leb128 (pc + len, info, &error, &bytes_read,
                               false);
       local_index = val;
       if (error || local_index != val)
         return -1;
       len += bytes_read;
       prin (stream, " %u", local_index);
       if (strcmp (op->name + 4, "local") == 0)
         {
           static const char *locals[] =
             {
               "$dpc", "$sp1", "$r0", "$r1", "$rpc", "$pc0",
               "$rp", "$fp", "$sp",
               "$r2", "$r3", "$r4", "$r5", "$r6", "$r7",
               "$i0", "$i1", "$i2", "$i3", "$i4", "$i5", "$i6", "$i7",
               "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
             };
           if (private_data->print_registers
               && local_index < ARRAY_SIZE (locals))
             prin (stream, " <%s>", locals[local_index]);
         }
       else
         {
           static const char *globals[] =
             {
               "$got", "$plt", "$gpo"
             };
           if (private_data->print_well_known_globals
               && local_index < ARRAY_SIZE (globals))
             prin (stream, " <%s>", globals[local_index]);
         }
     }
     break;

   case wasm_grow_memory:
   case wasm_current_memory:
     {
       uint32_t reserved_size;
       val = wasm_read_leb128 (pc + len, info, &error, &bytes_read,
                               false);
       reserved_size = val;
       if (error || reserved_size != val)
         return -1;
       len += bytes_read;
       prin (stream, " %u", reserved_size);
     }
     break;

   case wasm_load:
   case wasm_store:
     {
       uint32_t flags, offset;
       val = wasm_read_leb128 (pc + len, info, &error, &bytes_read,
                               false);
       flags = val;
       if (error || flags != val)
         return -1;
       len += bytes_read;
       val = wasm_read_leb128 (pc + len, info, &error, &bytes_read,
                               false);
       offset = val;
       if (error || offset != val)
         return -1;
       len += bytes_read;
       prin (stream, " a=%u %u", flags, offset);
     }
     break;
   }
 return len;
}

/* Print valid disassembler options to STREAM.  */

void
print_wasm32_disassembler_options (FILE *stream)
{
 unsigned int i, max_len = 0;

 fprintf (stream, _("\
The following WebAssembly-specific disassembler options are supported for use\n\
with the -M switch:\n"));

 for (i = 0; i < ARRAY_SIZE (options); i++)
   {
     unsigned int len = strlen (options[i].name);

     if (max_len < len)
       max_len = len;
   }

 for (i = 0, max_len++; i < ARRAY_SIZE (options); i++)
   fprintf (stream, "  %s%*c %s\n",
            options[i].name,
            (int)(max_len - strlen (options[i].name)), ' ',
            _(options[i].description));
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.