cerc-io/solidity
15
0
Fork 0
mirror of https://github.com/ethereum/solidity synced 2023-10-03 13:03:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Define wasm::Type enum and use it for import parameters and result

Browse Source
This commit is contained in:
Kamil Śliwak 2020-06-11 00:54:12 +02:00
parent d7f29a33b9
commit 840ff40263
7 changed files with 53 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
libyul/backends/wasm/BinaryTransform.cpp
View File

@ -25,6 +25,7 @@
#include <boost/range/adaptor/reversed.hpp> #include <boost/range/adaptor/reversed.hpp>
#include <boost/range/adaptor/map.hpp> #include <boost/range/adaptor/map.hpp>
#include <boost/range/adaptor/transformed.hpp>
using namespace std; using namespace std;
using namespace solidity; using namespace solidity;
@ -475,7 +476,7 @@ BinaryTransform::Type BinaryTransform::typeOf(FunctionImport const& _import)
{ {
return { return {
encodeTypes(_import.paramTypes), encodeTypes(_import.paramTypes),
encodeTypes(_import.returnType ? vector<string>(1, *_import.returnType) : vector<string>()) encodeTypes(_import.returnType ? vector<wasm::Type>(1, *_import.returnType) : vector<wasm::Type>())
}; };
} }
@ -483,26 +484,26 @@ BinaryTransform::Type BinaryTransform::typeOf(FunctionDefinition const& _funDef)
{ {
return { return {
encodeTypes(vector<string>(_funDef.parameterNames.size(), "i64")), encodeTypes(vector<wasm::Type>(_funDef.parameterNames.size(), wasm::Type::i64)),
encodeTypes(vector<string>(_funDef.returns ? 1 : 0, "i64")) encodeTypes(vector<wasm::Type>(_funDef.returns ? 1 : 0, wasm::Type::i64))
}; };
} }
uint8_t BinaryTransform::encodeType(string const& _typeName) uint8_t BinaryTransform::encodeType(wasm::Type _type)
{ {
if (_typeName == "i32") if (_type == wasm::Type::i32)
return uint8_t(ValueType::I32); return uint8_t(ValueType::I32);
else if (_typeName == "i64") else if (_type == wasm::Type::i64)
return uint8_t(ValueType::I64); return uint8_t(ValueType::I64);
else else
yulAssert(false, ""); yulAssert(false, "");
return 0; return 0;
} }
vector<uint8_t> BinaryTransform::encodeTypes(vector<string> const& _typeNames) vector<uint8_t> BinaryTransform::encodeTypes(vector<wasm::Type> const& _types)
{ {
vector<uint8_t> result; vector<uint8_t> result;
for (auto const& t: _typeNames) for (wasm::Type t: _types)
result.emplace_back(encodeType(t)); result.emplace_back(encodeType(t));
return result; return result;
} }

4
libyul/backends/wasm/BinaryTransform.h
View File

@ -71,8 +71,8 @@ private:
static Type typeOf(wasm::FunctionImport const& _import); static Type typeOf(wasm::FunctionImport const& _import);
static Type typeOf(wasm::FunctionDefinition const& _funDef); static Type typeOf(wasm::FunctionDefinition const& _funDef);
static uint8_t encodeType(std::string const& _typeName); static uint8_t encodeType(wasm::Type _type);
static std::vector<uint8_t> encodeTypes(std::vector<std::string> const& _typeNames); static std::vector<uint8_t> encodeTypes(std::vector<wasm::Type> const& _types);
static std::map<Type, std::vector<std::string>> typeToFunctionMap( static std::map<Type, std::vector<std::string>> typeToFunctionMap(
std::vector<wasm::FunctionImport> const& _imports, std::vector<wasm::FunctionImport> const& _imports,

16
libyul/backends/wasm/TextTransform.cpp
View File

@ -20,6 +20,8 @@
#include <libyul/backends/wasm/TextTransform.h> #include <libyul/backends/wasm/TextTransform.h>
#include <libyul/Exceptions.h>
#include <libsolutil/StringUtils.h> #include <libsolutil/StringUtils.h>
#include <boost/algorithm/string/join.hpp> #include <boost/algorithm/string/join.hpp>
@ -44,9 +46,9 @@ string TextTransform::run(wasm::Module const& _module)
{ {
ret += " (import \"" + imp.module + "\" \"" + imp.externalName + "\" (func $" + imp.internalName; ret += " (import \"" + imp.module + "\" \"" + imp.externalName + "\" (func $" + imp.internalName;
if (!imp.paramTypes.empty()) if (!imp.paramTypes.empty())
ret += " (param" + joinHumanReadablePrefixed(imp.paramTypes, " ", " ") + ")"; ret += " (param" + joinHumanReadablePrefixed(imp.paramTypes | boost::adaptors::transformed(encodeType), " ", " ") + ")";
if (imp.returnType) if (imp.returnType)
ret += " (result " + *imp.returnType + ")"; ret += " (result " + encodeType(*imp.returnType) + ")";
ret += "))\n"; ret += "))\n";
} }
@ -193,3 +195,13 @@ string TextTransform::joinTransformed(vector<wasm::Expression> const& _expressio
} }
return ret; return ret;
} }
string TextTransform::encodeType(wasm::Type _type)
{
if (_type == wasm::Type::i32)
return "i32";
else if (_type == wasm::Type::i64)
return "i64";
else
yulAssert(false, "Invalid wasm type");
}

2
libyul/backends/wasm/TextTransform.h
View File

@ -63,6 +63,8 @@ private:
std::vector<wasm::Expression> const& _expressions, std::vector<wasm::Expression> const& _expressions,
char _separator = ' ' char _separator = ' '
); );
static std::string encodeType(wasm::Type _type);
}; };
} }

10
libyul/backends/wasm/WasmAST.h
View File

@ -30,6 +30,12 @@
namespace solidity::yul::wasm namespace solidity::yul::wasm
{ {
enum class Type
{
i32,
i64,
};
struct Literal; struct Literal;
struct StringLiteral; struct StringLiteral;
struct LocalVariable; struct LocalVariable;
@ -76,8 +82,8 @@ struct FunctionImport {
std::string module; std::string module;
std::string externalName; std::string externalName;
std::string internalName; std::string internalName;
std::vector<std::string> paramTypes; std::vector<Type> paramTypes;
std::optional<std::string> returnType; std::optional<Type> returnType;
}; };
struct FunctionDefinition struct FunctionDefinition

22
libyul/backends/wasm/WasmCodeTransform.cpp
View File

@ -127,10 +127,10 @@ wasm::Expression WasmCodeTransform::operator()(FunctionCall const& _call)
builtin->name.str().substr(4), builtin->name.str().substr(4),
builtin->name.str(), builtin->name.str(),
{}, {},
builtin->returns.empty() ? nullopt : make_optional<string>(builtin->returns.front().str()) builtin->returns.empty() ? nullopt : make_optional<wasm::Type>(translatedType(builtin->returns.front()))
}; };
for (auto const& param: builtin->parameters) for (auto const& param: builtin->parameters)
imp.paramTypes.emplace_back(param.str()); imp.paramTypes.emplace_back(translatedType(param));
m_functionsToImport[builtin->name] = std::move(imp); m_functionsToImport[builtin->name] = std::move(imp);
} }
typeConversionNeeded = true; typeConversionNeeded = true;
@ -361,14 +361,14 @@ wasm::Expression WasmCodeTransform::injectTypeConversionIfNeeded(wasm::FunctionC
{ {
wasm::FunctionImport const& import = m_functionsToImport.at(YulString{_call.functionName}); wasm::FunctionImport const& import = m_functionsToImport.at(YulString{_call.functionName});
for (size_t i = 0; i < _call.arguments.size(); ++i) for (size_t i = 0; i < _call.arguments.size(); ++i)
if (import.paramTypes.at(i) == "i32") if (import.paramTypes.at(i) == wasm::Type::i32)
_call.arguments[i] = wasm::BuiltinCall{"i32.wrap_i64", make_vector<wasm::Expression>(std::move(_call.arguments[i]))}; _call.arguments[i] = wasm::BuiltinCall{"i32.wrap_i64", make_vector<wasm::Expression>(std::move(_call.arguments[i]))};
else else
yulAssert(import.paramTypes.at(i) == "i64", "Unknown type " + import.paramTypes.at(i)); yulAssert(import.paramTypes.at(i) == wasm::Type::i64, "Invalid Wasm type");
if (import.returnType && *import.returnType != "i64") if (import.returnType && *import.returnType != wasm::Type::i64)
{ {
yulAssert(*import.returnType == "i32", "Invalid type " + *import.returnType); yulAssert(*import.returnType == wasm::Type::i32, "Invalid Wasm type");
return wasm::BuiltinCall{"i64.extend_i32_u", make_vector<wasm::Expression>(std::move(_call))}; return wasm::BuiltinCall{"i64.extend_i32_u", make_vector<wasm::Expression>(std::move(_call))};
} }
return {std::move(_call)}; return {std::move(_call)};
@ -403,3 +403,13 @@ void WasmCodeTransform::allocateGlobals(size_t _amount)
m_nameDispenser.newName("global_"_yulstring).str() m_nameDispenser.newName("global_"_yulstring).str()
}); });
} }
wasm::Type WasmCodeTransform::translatedType(yul::Type _yulType)
{
if (_yulType == "i32"_yulstring)
return wasm::Type::i32;
else if (_yulType == "i64"_yulstring)
return wasm::Type::i64;
else
yulAssert(false, "This Yul type does not have a corresponding type in Wasm.");
}

2
libyul/backends/wasm/WasmCodeTransform.h
View File

@ -89,6 +89,8 @@ private:
/// Makes sure that there are at least @a _amount global variables. /// Makes sure that there are at least @a _amount global variables.
void allocateGlobals(size_t _amount); void allocateGlobals(size_t _amount);
static wasm::Type translatedType(yul::Type _yulType);
Dialect const& m_dialect; Dialect const& m_dialect;
NameDispenser m_nameDispenser; NameDispenser m_nameDispenser;