mirror of
https://github.com/ethereum/go-ethereum.git
synced 2026-07-19 19:30:44 +00:00
initial implementation of memory
This commit is contained in:
artur-zawlocki
parent
d8430db13c
commit
68f15f91a0
4 changed files with 182 additions and 33 deletions
|
|
@ -3,6 +3,7 @@
|
|||
|
||||
#include <llvm/IR/IRBuilder.h>
|
||||
|
||||
#include "Memory.h"
|
||||
#include "Stack.h"
|
||||
|
||||
namespace evmcc
|
||||
|
|
@ -41,24 +42,6 @@ std::unique_ptr<llvm::Module> Compiler::compile(const dev::bytes& bytecode)
|
|||
auto module = std::make_unique<Module>("main", context);
|
||||
IRBuilder<> builder(context);
|
||||
|
||||
// Create globals for memory, memory size, stack and stack top
|
||||
auto memory = new GlobalVariable(*module, Types.word8ptr, false,
|
||||
GlobalValue::LinkageTypes::PrivateLinkage,
|
||||
Constant::getNullValue(Types.word8ptr), "memory");
|
||||
auto memSize = new GlobalVariable(*module, Types.size, false,
|
||||
GlobalValue::LinkageTypes::PrivateLinkage,
|
||||
ConstantInt::get(Types.size, 0), "memsize");
|
||||
auto stack2 = new GlobalVariable(*module, Types.word256arr, false,
|
||||
GlobalValue::LinkageTypes::PrivateLinkage,
|
||||
ConstantAggregateZero::get(Types.word256arr), "stack");
|
||||
auto stackTop2 = new GlobalVariable(*module, Types.size, false,
|
||||
GlobalValue::LinkageTypes::PrivateLinkage,
|
||||
ConstantInt::get(Types.size, 0), "stackTop");
|
||||
|
||||
// Create value for void* malloc(size_t)
|
||||
auto mallocVal = Function::Create(FunctionType::get(Types.word8ptr, { Types.size }, false),
|
||||
GlobalValue::LinkageTypes::ExternalLinkage, "malloc", module.get());
|
||||
|
||||
// Create main function
|
||||
FunctionType* funcType = FunctionType::get(llvm::Type::getInt32Ty(context), false);
|
||||
Function* mainFunc = Function::Create(funcType, Function::ExternalLinkage, "main", module.get());
|
||||
|
|
@ -66,13 +49,9 @@ std::unique_ptr<llvm::Module> Compiler::compile(const dev::bytes& bytecode)
|
|||
BasicBlock* entryBlock = BasicBlock::Create(context, "entry", mainFunc);
|
||||
builder.SetInsertPoint(entryBlock);
|
||||
|
||||
// Initialize memory with call to malloc, update memsize
|
||||
std::vector<Value*> mallocMemArgs = { ConstantInt::get(Types.size, 100) };
|
||||
auto mallocMemCall = builder.CreateCall(mallocVal, mallocMemArgs, "malloc_mem");
|
||||
builder.CreateStore(mallocMemCall, memory);
|
||||
builder.CreateStore(ConstantInt::get(Types.size, 100), memSize);
|
||||
|
||||
auto stack = Stack(builder, module.get());
|
||||
auto memory = Memory(builder, module.get());
|
||||
|
||||
uint64_t words[] = { 1, 2, 3, 4 };
|
||||
auto val = llvm::APInt(256, 4, words);
|
||||
|
|
@ -83,20 +62,19 @@ std::unique_ptr<llvm::Module> Compiler::compile(const dev::bytes& bytecode)
|
|||
|
||||
auto top = stack.top();
|
||||
stack.push(top); // dup
|
||||
|
||||
stack.pop();
|
||||
|
||||
auto index = ConstantInt::get(Types.word256, 123);
|
||||
memory.storeWord(index, c);
|
||||
|
||||
/*
|
||||
std::vector<Value*> mallocStackArgs = { ConstantInt::get(sizeTy, 200) };
|
||||
auto mallocStackCall = builder.CreateCall(mallocVal, mallocStackArgs, "malloc_stack");
|
||||
auto mallocCast = builder.CreatePointerBitCastOrAddrSpaceCast(mallocStackCall, int256ptr);
|
||||
builder.CreateStore(mallocCast, stackVal);
|
||||
*/
|
||||
memory.dump(123, 123+32);
|
||||
|
||||
builder.CreateRet(ConstantInt::get(Type::getInt32Ty(context), 13));
|
||||
auto index2 = ConstantInt::get(Types.word256, 123 + 16);
|
||||
auto byte = memory.loadByte(index2);
|
||||
auto result = builder.CreateZExt(byte, builder.getInt32Ty());
|
||||
builder.CreateRet(result); // should return 3
|
||||
|
||||
return module;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -18,4 +18,4 @@ public:
|
|||
|
||||
};
|
||||
|
||||
}
|
||||
}
|
||||
|
|
|
|||
145
evmcc/Memory.cpp
Normal file
145
evmcc/Memory.cpp
Normal file
|
|
@ -0,0 +1,145 @@
|
|||
#include "Memory.h"
|
||||
|
||||
#include <vector>
|
||||
#include <iostream>
|
||||
#include <iomanip>
|
||||
#include <cstdint>
|
||||
#include <cassert>
|
||||
|
||||
#include <llvm/IR/Function.h>
|
||||
|
||||
#include <libdevcore/Common.h>
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#define EXPORT __declspec(dllexport)
|
||||
#else
|
||||
#define EXPORT
|
||||
#endif
|
||||
|
||||
namespace evmcc
|
||||
{
|
||||
|
||||
struct i256
|
||||
{
|
||||
uint64_t a;
|
||||
uint64_t b;
|
||||
uint64_t c;
|
||||
uint64_t d;
|
||||
};
|
||||
static_assert(sizeof(i256) == 32, "Wrong i256 size");
|
||||
|
||||
using MemoryImpl = dev::bytes;
|
||||
|
||||
|
||||
Memory::Memory(llvm::IRBuilder<>& _builder, llvm::Module* _module)
|
||||
: m_builder(_builder)
|
||||
{
|
||||
auto memoryCreate = llvm::Function::Create(llvm::FunctionType::get(m_builder.getVoidTy(), false),
|
||||
llvm::GlobalValue::LinkageTypes::ExternalLinkage,
|
||||
"evmccrt_memory_create", _module);
|
||||
m_builder.CreateCall(memoryCreate);
|
||||
|
||||
|
||||
auto memRequireTy = llvm::FunctionType::get(m_builder.getInt8PtrTy(), m_builder.getInt64Ty(), false);
|
||||
m_memRequire = llvm::Function::Create(memRequireTy,
|
||||
llvm::GlobalValue::LinkageTypes::ExternalLinkage,
|
||||
"evmccrt_memory_require", _module);
|
||||
|
||||
auto i64Ty = m_builder.getInt64Ty();
|
||||
std::vector<llvm::Type*> argTypes = {i64Ty, i64Ty};
|
||||
auto dumpTy = llvm::FunctionType::get(m_builder.getVoidTy(), llvm::ArrayRef<llvm::Type*>(argTypes), false);
|
||||
m_memDump = llvm::Function::Create(dumpTy, llvm::GlobalValue::LinkageTypes::ExternalLinkage,
|
||||
"evmccrt_memory_dump", _module);
|
||||
}
|
||||
|
||||
|
||||
llvm::Value* Memory::loadByte(llvm::Value* _addr)
|
||||
{
|
||||
// trunc _addr (an i256) to i64 index and use it to index the memory
|
||||
auto index = m_builder.CreateTrunc(_addr, m_builder.getInt64Ty(), "index");
|
||||
|
||||
// load from evmccrt_memory_require()[index]
|
||||
auto base = m_builder.CreateCall(m_memRequire, index, "base");
|
||||
auto ptr = m_builder.CreateGEP(base, index, "ptr");
|
||||
auto byte = m_builder.CreateLoad(ptr, "byte");
|
||||
return byte;
|
||||
}
|
||||
|
||||
void Memory::storeWord(llvm::Value* _addr, llvm::Value* _word)
|
||||
{
|
||||
auto index = m_builder.CreateTrunc(_addr, m_builder.getInt64Ty(), "index");
|
||||
auto index32 = m_builder.CreateAdd(index, llvm::ConstantInt::get(m_builder.getInt64Ty(), 32), "index32");
|
||||
|
||||
auto base = m_builder.CreateCall(m_memRequire, index32, "base");
|
||||
auto ptr = m_builder.CreateGEP(base, index, "ptr");
|
||||
|
||||
auto i256ptrTy = m_builder.getIntNTy(256)->getPointerTo();
|
||||
auto wordPtr = m_builder.CreateBitCast(ptr, i256ptrTy, "wordptr");
|
||||
m_builder.CreateStore(_word, wordPtr);
|
||||
}
|
||||
|
||||
void Memory::storeByte(llvm::Value* _addr, llvm::Value* _byte)
|
||||
{
|
||||
auto index = m_builder.CreateTrunc(_addr, m_builder.getInt64Ty(), "index");
|
||||
|
||||
auto base = m_builder.CreateCall(m_memRequire, index, "base");
|
||||
auto ptr = m_builder.CreateGEP(base, index, "ptr");
|
||||
m_builder.CreateStore(_byte, ptr);
|
||||
}
|
||||
|
||||
void Memory::dump(uint64_t _begin, uint64_t _end)
|
||||
{
|
||||
auto beginVal = llvm::ConstantInt::get(m_builder.getInt64Ty(), _begin);
|
||||
auto endVal = llvm::ConstantInt::get(m_builder.getInt64Ty(), _end);
|
||||
|
||||
std::vector<llvm::Value*> args = {beginVal, endVal};
|
||||
m_builder.CreateCall(m_memDump, llvm::ArrayRef<llvm::Value*>(args));
|
||||
}
|
||||
|
||||
} // namespace evmcc
|
||||
|
||||
extern "C"
|
||||
{
|
||||
using namespace evmcc;
|
||||
|
||||
EXPORT MemoryImpl* evmccrt_memory;
|
||||
|
||||
EXPORT void evmccrt_memory_create(void)
|
||||
{
|
||||
evmccrt_memory = new MemoryImpl(1);
|
||||
std::cerr << "MEMORY: create(), initial size = " << evmccrt_memory->size()
|
||||
<< std::endl;
|
||||
}
|
||||
|
||||
// Resizes memory to contain at least _size bytes and returns the base address.
|
||||
EXPORT void* evmccrt_memory_require(uint64_t _size)
|
||||
{
|
||||
std::cerr << "MEMORY: require(), current size = " << evmccrt_memory->size()
|
||||
<< ", required size = " << _size
|
||||
<< std::endl;
|
||||
|
||||
if (evmccrt_memory->size() < _size)
|
||||
evmccrt_memory->resize(_size);
|
||||
|
||||
return &(*evmccrt_memory)[0];
|
||||
}
|
||||
|
||||
EXPORT void evmccrt_memory_dump(uint64_t _begin, uint64_t _end)
|
||||
{
|
||||
std::cerr << "Memory dump from " << std::hex << _begin << " to " << std::hex << _end << ":";
|
||||
if (_end <= _begin)
|
||||
return;
|
||||
|
||||
_begin = _begin / 16 * 16;
|
||||
for (size_t i = _begin; i < _end; i++)
|
||||
{
|
||||
if ((i - _begin) % 16 == 0)
|
||||
std::cerr << '\n' << std::dec << i << ": ";
|
||||
|
||||
uint8_t b = (*evmccrt_memory)[i];
|
||||
std::cerr << std::hex << std::setw(2) << static_cast<int>(b) << ' ';
|
||||
}
|
||||
std::cerr << std::endl;
|
||||
}
|
||||
|
||||
} // extern "C"
|
||||
26
evmcc/Memory.h
Normal file
26
evmcc/Memory.h
Normal file
|
|
@ -0,0 +1,26 @@
|
|||
#pragma once
|
||||
|
||||
#include <llvm/IR/IRBuilder.h>
|
||||
|
||||
namespace evmcc
|
||||
{
|
||||
|
||||
class Memory
|
||||
{
|
||||
public:
|
||||
Memory(llvm::IRBuilder<>& _builder, llvm::Module* _module);
|
||||
|
||||
llvm::Value* loadByte(llvm::Value* _addr);
|
||||
void storeWord(llvm::Value* _addr, llvm::Value* _word);
|
||||
void storeByte(llvm::Value* _addr, llvm::Value* _byte);
|
||||
|
||||
void dump(uint64_t _begin, uint64_t _end);
|
||||
|
||||
private:
|
||||
llvm::IRBuilder<>& m_builder;
|
||||
|
||||
llvm::Function* m_memRequire;
|
||||
llvm::Function* m_memDump;
|
||||
};
|
||||
|
||||
}
|
||||
Loading…
Reference in a new issue