forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-07-19 03:10:48 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Merge branch 'develop-evmcc' of https://github.com/imapp-pl/ethereum into develop-evmcc

Browse source
This commit is contained in:
Paweł Bylica 2014-10-01 16:48:26 +02:00
commit d073af7754
5 changed files with 119 additions and 23 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

31
evmcc/Compiler.cpp
View file

@ -252,6 +252,37 @@ std::unique_ptr<llvm::Module> Compiler::compile(const dev::bytes& bytecode)
break;
}
case Instruction::MLOAD:
{
auto addr = stack.pop();
auto word = memory.loadWord(addr);
stack.push(word);
break;
}
case Instruction::MSTORE:
{
auto addr = stack.pop();
auto word = stack.pop();
memory.storeWord(addr, word);
break;
}
case Instruction::MSTORE8:
{
auto addr = stack.pop();
auto word = stack.pop();
memory.storeByte(addr, word);
break;
}
case Instruction::MSIZE:
{
auto word = memory.getSize();
stack.push(word);
break;
}
case Instruction::SLOAD:
{
auto index = stack.pop();

86
evmcc/Memory.cpp
View file

@ -27,18 +27,25 @@ 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),
auto voidTy = m_builder.getVoidTy();
auto i64Ty = m_builder.getInt64Ty();
auto memoryCreate = llvm::Function::Create(llvm::FunctionType::get(voidTy, 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);
auto memRequireTy = llvm::FunctionType::get(m_builder.getInt8PtrTy(), i64Ty, false);
m_memRequire = llvm::Function::Create(memRequireTy,
llvm::GlobalValue::LinkageTypes::ExternalLinkage,
"evmccrt_memory_require", _module);
auto i64Ty = m_builder.getInt64Ty();
auto memSizeTy = llvm::FunctionType::get(i64Ty, false);
m_memSize = llvm::Function::Create(memSizeTy,
llvm::GlobalValue::LinkageTypes::ExternalLinkage,
"evmccrt_memory_size", _module);
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,
@ -46,42 +53,63 @@ Memory::Memory(llvm::IRBuilder<>& _builder, llvm::Module* _module)
}
llvm::Value* Memory::loadByte(llvm::Value* _addr)
llvm::Value* Memory::loadWord(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");
auto index = m_builder.CreateTrunc(_addr, m_builder.getInt64Ty(), "mem.index");
auto index31 = m_builder.CreateAdd(index, llvm::ConstantInt::get(m_builder.getInt64Ty(), 31), "mem.index.31");
// load from evmccrt_memory_require()[index]
auto base = m_builder.CreateCall(m_memRequire, index, "base");
auto base = m_builder.CreateCall(m_memRequire, index31, "base");
auto ptr = m_builder.CreateGEP(base, index, "ptr");
auto byte = m_builder.CreateLoad(ptr, "byte");
auto i256ptrTy = m_builder.getIntNTy(256)->getPointerTo();
auto wordPtr = m_builder.CreateBitCast(ptr, i256ptrTy, "wordptr");
auto byte = m_builder.CreateLoad(wordPtr, "word");
dump(0);
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 index = m_builder.CreateTrunc(_addr, m_builder.getInt64Ty(), "mem.index");
auto index31 = m_builder.CreateAdd(index, llvm::ConstantInt::get(m_builder.getInt64Ty(), 31), "mem.index31");
auto base = m_builder.CreateCall(m_memRequire, index32, "base");
auto base = m_builder.CreateCall(m_memRequire, index31, "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);
dump(0);
}
void Memory::storeByte(llvm::Value* _addr, llvm::Value* _byte)
void Memory::storeByte(llvm::Value* _addr, llvm::Value* _word)
{
auto byte = m_builder.CreateTrunc(_word, m_builder.getInt8Ty(), "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);
m_builder.CreateStore(byte, ptr);
dump(0);
}
llvm::Value* Memory::getSize()
{
auto size = m_builder.CreateCall(m_memSize, "mem.size");
auto word = m_builder.CreateZExt(size, m_builder.getIntNTy(256), "mem.wsize");
return word;
}
void Memory::dump(uint64_t _begin, uint64_t _end)
{
if (getenv("EVMCC_DEBUG_MEMORY") == nullptr)
return;
auto beginVal = llvm::ConstantInt::get(m_builder.getInt64Ty(), _begin);
auto endVal = llvm::ConstantInt::get(m_builder.getInt64Ty(), _end);
@ -99,27 +127,43 @@ static MemoryImpl* evmccrt_memory;
EXPORT void evmccrt_memory_create(void)
{
evmccrt_memory = new MemoryImpl(1);
evmccrt_memory = new MemoryImpl();
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)
// Resizes memory to contain at least _index + 1 bytes and returns the base address.
EXPORT uint8_t* evmccrt_memory_require(uint64_t _index)
{
std::cerr << "MEMORY: require(), current size = " << evmccrt_memory->size()
<< ", required size = " << _size
<< std::endl;
uint64_t requiredSize = (_index / 32 + 1) * 32;
if (evmccrt_memory->size() < _size)
evmccrt_memory->resize(_size);
if (evmccrt_memory->size() < requiredSize)
{
std::cerr << "MEMORY: current size: " << std::dec
<< evmccrt_memory->size() << " bytes, required size: "
<< requiredSize << " bytes"
<< std::endl;
evmccrt_memory->resize(requiredSize);
}
return evmccrt_memory->data();
}
EXPORT uint64_t evmccrt_memory_size()
{
return evmccrt_memory->size() / 32;
}
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 == 0)
_end = evmccrt_memory->size();
std::cerr << "MEMORY: active size: " << std::dec
<< evmccrt_memory_size() << " words\n";
std::cerr << "MEMORY: dump from " << std::dec
<< _begin << " to " << _end << ":";
if (_end <= _begin)
return;

6
evmcc/Memory.h
View file

@ -10,17 +10,19 @@ class Memory
public:
Memory(llvm::IRBuilder<>& _builder, llvm::Module* _module);
llvm::Value* loadByte(llvm::Value* _addr);
llvm::Value* loadWord(llvm::Value* _addr);
void storeWord(llvm::Value* _addr, llvm::Value* _word);
void storeByte(llvm::Value* _addr, llvm::Value* _byte);
llvm::Value* getSize();
void dump(uint64_t _begin, uint64_t _end);
void dump(uint64_t _begin, uint64_t _end = 0);
private:
llvm::IRBuilder<>& m_builder;
llvm::Function* m_memRequire;
llvm::Function* m_memDump;
llvm::Function* m_memSize;
};
}

1
evmcc/bytecode/memtest1.evm Normal file
View file

@ -0,0 +1 @@
6002600055600360015560005360015301600254

18
evmcc/lll/memtest1.lll Normal file
View file

@ -0,0 +1,18 @@
(asm ;; []
2
0
MSTORE8 ;; [02]
3
1
MSTORE8 ;; [02 03]
0
MLOAD ;; [2 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
1
MLOAD ;; [2 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
;; 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
ADD
2
MSTORE ;; [2 3 5 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
;; 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
)