Home | History | Annotate | Line # | Download | only in Utils 
      1 //===-- WebAssemblyTypeUtilities.cpp - WebAssembly Type Utility Functions -===//
      2 //
      3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
      4 // See https://llvm.org/LICENSE.txt for license information.
      5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
      6 //
      7 //===----------------------------------------------------------------------===//
      8 ///
      9 /// \file
     10 /// This file implements several utility functions for WebAssembly type parsing.
     11 ///
     12 //===----------------------------------------------------------------------===//
     13 
     14 #include "WebAssemblyTypeUtilities.h"
     15 #include "llvm/ADT/StringSwitch.h"
     16 
     17 using namespace llvm;
     18 
     19 Optional<wasm::ValType> WebAssembly::parseType(StringRef Type) {
     20   // FIXME: can't use StringSwitch because wasm::ValType doesn't have a
     21   // "invalid" value.
     22   if (Type == "i32")
     23     return wasm::ValType::I32;
     24   if (Type == "i64")
     25     return wasm::ValType::I64;
     26   if (Type == "f32")
     27     return wasm::ValType::F32;
     28   if (Type == "f64")
     29     return wasm::ValType::F64;
     30   if (Type == "v128" || Type == "i8x16" || Type == "i16x8" || Type == "i32x4" ||
     31       Type == "i64x2" || Type == "f32x4" || Type == "f64x2")
     32     return wasm::ValType::V128;
     33   if (Type == "funcref")
     34     return wasm::ValType::FUNCREF;
     35   if (Type == "externref")
     36     return wasm::ValType::EXTERNREF;
     37   return Optional<wasm::ValType>();
     38 }
     39 
     40 WebAssembly::HeapType WebAssembly::parseHeapType(StringRef Type) {
     41   return StringSwitch<WebAssembly::HeapType>(Type)
     42       .Case("extern", WebAssembly::HeapType::Externref)
     43       .Case("func", WebAssembly::HeapType::Funcref)
     44       .Default(WebAssembly::HeapType::Invalid);
     45 }
     46 
     47 WebAssembly::BlockType WebAssembly::parseBlockType(StringRef Type) {
     48   // Multivalue block types are handled separately in parseSignature
     49   return StringSwitch<WebAssembly::BlockType>(Type)
     50       .Case("i32", WebAssembly::BlockType::I32)
     51       .Case("i64", WebAssembly::BlockType::I64)
     52       .Case("f32", WebAssembly::BlockType::F32)
     53       .Case("f64", WebAssembly::BlockType::F64)
     54       .Case("v128", WebAssembly::BlockType::V128)
     55       .Case("funcref", WebAssembly::BlockType::Funcref)
     56       .Case("externref", WebAssembly::BlockType::Externref)
     57       .Case("void", WebAssembly::BlockType::Void)
     58       .Default(WebAssembly::BlockType::Invalid);
     59 }
     60 
     61 MVT WebAssembly::parseMVT(StringRef Type) {
     62   return StringSwitch<MVT>(Type)
     63       .Case("i32", MVT::i32)
     64       .Case("i64", MVT::i64)
     65       .Case("f32", MVT::f32)
     66       .Case("f64", MVT::f64)
     67       .Case("i64", MVT::i64)
     68       .Case("v16i8", MVT::v16i8)
     69       .Case("v8i16", MVT::v8i16)
     70       .Case("v4i32", MVT::v4i32)
     71       .Case("v2i64", MVT::v2i64)
     72       .Case("funcref", MVT::funcref)
     73       .Case("externref", MVT::externref)
     74       .Default(MVT::INVALID_SIMPLE_VALUE_TYPE);
     75 }
     76 
     77 // We have various enums representing a subset of these types, use this
     78 // function to convert any of them to text.
     79 const char *WebAssembly::anyTypeToString(unsigned Type) {
     80   switch (Type) {
     81   case wasm::WASM_TYPE_I32:
     82     return "i32";
     83   case wasm::WASM_TYPE_I64:
     84     return "i64";
     85   case wasm::WASM_TYPE_F32:
     86     return "f32";
     87   case wasm::WASM_TYPE_F64:
     88     return "f64";
     89   case wasm::WASM_TYPE_V128:
     90     return "v128";
     91   case wasm::WASM_TYPE_FUNCREF:
     92     return "funcref";
     93   case wasm::WASM_TYPE_EXTERNREF:
     94     return "externref";
     95   case wasm::WASM_TYPE_FUNC:
     96     return "func";
     97   case wasm::WASM_TYPE_NORESULT:
     98     return "void";
     99   default:
    100     return "invalid_type";
    101   }
    102 }
    103 
    104 const char *WebAssembly::typeToString(wasm::ValType Type) {
    105   return anyTypeToString(static_cast<unsigned>(Type));
    106 }
    107 
    108 std::string WebAssembly::typeListToString(ArrayRef<wasm::ValType> List) {
    109   std::string S;
    110   for (const auto &Type : List) {
    111     if (&Type != &List[0])
    112       S += ", ";
    113     S += WebAssembly::typeToString(Type);
    114   }
    115   return S;
    116 }
    117 
    118 std::string WebAssembly::signatureToString(const wasm::WasmSignature *Sig) {
    119   std::string S("(");
    120   S += typeListToString(Sig->Params);
    121   S += ") -> (";
    122   S += typeListToString(Sig->Returns);
    123   S += ")";
    124   return S;
    125 }
    126 
    127 wasm::ValType WebAssembly::toValType(MVT Type) {
    128   switch (Type.SimpleTy) {
    129   case MVT::i32:
    130     return wasm::ValType::I32;
    131   case MVT::i64:
    132     return wasm::ValType::I64;
    133   case MVT::f32:
    134     return wasm::ValType::F32;
    135   case MVT::f64:
    136     return wasm::ValType::F64;
    137   case MVT::v16i8:
    138   case MVT::v8i16:
    139   case MVT::v4i32:
    140   case MVT::v2i64:
    141   case MVT::v4f32:
    142   case MVT::v2f64:
    143     return wasm::ValType::V128;
    144   case MVT::funcref:
    145     return wasm::ValType::FUNCREF;
    146   case MVT::externref:
    147     return wasm::ValType::EXTERNREF;
    148   default:
    149     llvm_unreachable("unexpected type");
    150   }
    151 }
    152