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
parseType(StringRef Type)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
parseHeapType(StringRef Type)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
parseBlockType(StringRef Type)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
parseMVT(StringRef Type)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.
anyTypeToString(unsigned Type)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
typeToString(wasm::ValType Type)104 const char *WebAssembly::typeToString(wasm::ValType Type) {
105 return anyTypeToString(static_cast<unsigned>(Type));
106 }
107
typeListToString(ArrayRef<wasm::ValType> List)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
signatureToString(const wasm::WasmSignature * Sig)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
toValType(MVT Type)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