256-bit arithmetic implemented via calls to boost::multiprecision library.

[#79450108]

evmcc/test/arith/div.evm

@@ -0,0 +1 @@
+60027ffedcba9876543210fedcba9876543210fedcba9876543210fedcba98765432100460005460206000f2

evmcc/test/arith/div.lll

@@ -0,0 +1,10 @@
+(asm 
+0x2
+0xfedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210
+DIV
+0
+MSTORE
+32
+0
+RETURN 
+)

evmcc/test/arith/mul.evm

@@ -0,0 +1 @@
+7001234567890abcdef0fedcba09876543217001234567890abcdef0fedcba09876543217001234567890abcdef0fedcba0987654321020260005460206000f2

evmcc/test/arith/mul.lll

@@ -0,0 +1,13 @@
+(asm 
+0x1234567890abcdef0fedcba0987654321
+0x1234567890abcdef0fedcba0987654321
+0x1234567890abcdef0fedcba0987654321
+MUL
+MUL
+0
+MSTORE
+32
+0
+RETURN 
+;; 47d0817e4167b1eb4f9fc722b133ef9d7d9a6fb4c2c1c442d000107a5e419561
+)

libevmjit/Arith256.cpp

@@ -0,0 +1,118 @@
+#include "Arith256.h"
+#include "Runtime.h"
+#include "Type.h"
+
+#include <llvm/IR/Function.h>
+
+#include <libdevcore/Common.h>
+
+namespace dev
+{
+namespace eth
+{
+namespace jit
+{
+
+Arith256::Arith256(llvm::IRBuilder<>& _builder) :
+	CompilerHelper(_builder)
+{
+	using namespace llvm;
+
+	m_result = m_builder.CreateAlloca(Type::i256, nullptr, "arith.result");
+	m_arg1 = m_builder.CreateAlloca(Type::i256, nullptr, "arith.arg1");
+	m_arg2 = m_builder.CreateAlloca(Type::i256, nullptr, "arith.arg2");
+
+	using Linkage = GlobalValue::LinkageTypes;
+
+	llvm::Type* argTypes[] = {Type::WordPtr, Type::WordPtr, Type::WordPtr};
+	m_mul = Function::Create(FunctionType::get(Type::Void, argTypes, false), Linkage::ExternalLinkage, "arith_mul", getModule());
+	m_div = Function::Create(FunctionType::get(Type::Void, argTypes, false), Linkage::ExternalLinkage, "arith_div", getModule());
+	m_mod = Function::Create(FunctionType::get(Type::Void, argTypes, false), Linkage::ExternalLinkage, "arith_mod", getModule());
+	m_sdiv = Function::Create(FunctionType::get(Type::Void, argTypes, false), Linkage::ExternalLinkage, "arith_sdiv", getModule());
+	m_smod = Function::Create(FunctionType::get(Type::Void, argTypes, false), Linkage::ExternalLinkage, "arith_smod", getModule());
+}
+
+Arith256::~Arith256()
+{}
+
+llvm::Value* Arith256::binaryOp(llvm::Function* _op, llvm::Value* _arg1, llvm::Value* _arg2)
+{
+	m_builder.CreateStore(_arg1, m_arg1);
+	m_builder.CreateStore(_arg2, m_arg2);
+	m_builder.CreateCall3(_op, m_arg1, m_arg2, m_result);
+	return m_builder.CreateLoad(m_result);
+}
+
+llvm::Value* Arith256::mul(llvm::Value* _arg1, llvm::Value* _arg2)
+{
+	return binaryOp(m_mul, _arg1, _arg2);
+}
+
+llvm::Value* Arith256::div(llvm::Value* _arg1, llvm::Value* _arg2)
+{
+	return binaryOp(m_div, _arg1, _arg2);
+}
+
+llvm::Value* Arith256::mod(llvm::Value* _arg1, llvm::Value* _arg2)
+{
+	return binaryOp(m_mod, _arg1, _arg2);
+}
+
+llvm::Value* Arith256::sdiv(llvm::Value* _arg1, llvm::Value* _arg2)
+{
+	return binaryOp(m_sdiv, _arg1, _arg2);
+}
+
+llvm::Value* Arith256::smod(llvm::Value* _arg1, llvm::Value* _arg2)
+{
+	return binaryOp(m_smod, _arg1, _arg2);
+}
+
+}
+}
+}
+
+
+extern "C"
+{
+
+using namespace dev::eth::jit;
+
+EXPORT void arith_mul(i256* _arg1, i256* _arg2, i256* _result)
+{
+	dev::u256 arg1 = llvm2eth(*_arg1);
+	dev::u256 arg2 = llvm2eth(*_arg2);
+	*_result = eth2llvm(arg1 * arg2);
+}
+
+EXPORT void arith_div(i256* _arg1, i256* _arg2, i256* _result)
+{
+	dev::u256 arg1 = llvm2eth(*_arg1);
+	dev::u256 arg2 = llvm2eth(*_arg2);
+	*_result = eth2llvm(arg2 == 0 ? arg2 : arg1 / arg2);
+}
+
+EXPORT void arith_mod(i256* _arg1, i256* _arg2, i256* _result)
+{
+	dev::u256 arg1 = llvm2eth(*_arg1);
+	dev::u256 arg2 = llvm2eth(*_arg2);
+	*_result = eth2llvm(arg2 == 0 ? arg2 : arg1 % arg2);
+}
+
+EXPORT void arith_sdiv(i256* _arg1, i256* _arg2, i256* _result)
+{
+	dev::u256 arg1 = llvm2eth(*_arg1);
+	dev::u256 arg2 = llvm2eth(*_arg2);
+	*_result = eth2llvm(arg2 == 0 ? arg2 : dev::s2u(dev::u2s(arg1) / dev::u2s(arg2)));
+}
+
+EXPORT void arith_smod(i256* _arg1, i256* _arg2, i256* _result)
+{
+	dev::u256 arg1 = llvm2eth(*_arg1);
+	dev::u256 arg2 = llvm2eth(*_arg2);
+	*_result = eth2llvm(arg2 == 0 ? arg2 : dev::s2u(dev::u2s(arg1) % dev::u2s(arg2)));
+}
+
+}
+
+

libevmjit/Arith256.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include "CompilerHelper.h"
+
+namespace dev
+{
+namespace eth
+{
+namespace jit
+{
+
+class Arith256 : public CompilerHelper
+{
+public:
+	Arith256(llvm::IRBuilder<>& _builder);
+	virtual ~Arith256();
+
+	llvm::Value* mul(llvm::Value* _arg1, llvm::Value* _arg2);
+	llvm::Value* div(llvm::Value* _arg1, llvm::Value* _arg2);
+	llvm::Value* mod(llvm::Value* _arg1, llvm::Value* _arg2);
+	llvm::Value* sdiv(llvm::Value* _arg1, llvm::Value* _arg2);
+	llvm::Value* smod(llvm::Value* _arg1, llvm::Value* _arg2);
+
+private:
+	llvm::Value* binaryOp(llvm::Function* _op, llvm::Value* _arg1, llvm::Value* _arg2);
+
+	llvm::Function* m_mul;
+	llvm::Function* m_div;
+	llvm::Function* m_mod;
+	llvm::Function* m_sdiv;
+	llvm::Function* m_smod;
+
+	llvm::Value* m_arg1;
+	llvm::Value* m_arg2;
+	llvm::Value* m_result;
+};
+
+
+}
+}
+}