lukechilds
/
ethminer
mirror of https://github.com/lukechilds/ethminer.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Revert "Initial commit for etc" 

Moving evmcc work to another branch. This reverts commit 0ae8abdc7a.
cl-refactor
Paweł Bylica 10 years ago
parent
0ae8abdc7a
commit
2050af26f8
5 changed files with 0 additions and 244 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 5
      CMakeLists.txt
  2. 49
      etc/CMakeLists.txt
  3. 1
      etc/bytecode/kv.evm
  4. 179
      etc/etc.cpp
  5. 10
      etc/lll/kv.lll

5
CMakeLists.txt
View File

@ -374,11 +374,6 @@ if (NOT LANGUAGES)
endif()
endif()
if(ETC)
add_subdirectory(etc)
endif()
set(CMAKE_INCLUDE_CURRENT_DIR ON)
set(SRC_LIST BuildInfo.h)

49
etc/CMakeLists.txt
View File

@ -1,49 +0,0 @@
cmake_policy(SET CMP0015 NEW)
aux_source_directory(. SRC_LIST)
include_directories(..)
set(EXECUTABLE etc)
add_executable(${EXECUTABLE} ${SRC_LIST})
target_link_libraries(${EXECUTABLE} evmface)
target_link_libraries(${EXECUTABLE} devcore)
if ("${TARGET_PLATFORM}" STREQUAL "w64")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static-libgcc -static-libstdc++")
target_link_libraries(${EXECUTABLE} gcc)
target_link_libraries(${EXECUTABLE} gdi32)
target_link_libraries(${EXECUTABLE} ws2_32)
target_link_libraries(${EXECUTABLE} mswsock)
target_link_libraries(${EXECUTABLE} shlwapi)
target_link_libraries(${EXECUTABLE} iphlpapi)
target_link_libraries(${EXECUTABLE} boost_thread_win32-mt-s)
set(CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS)
elseif (UNIX)
else ()
find_package(Threads REQUIRED)
target_link_libraries(${EXECUTABLE} ${CMAKE_THREAD_LIBS_INIT})
endif ()
# LLVM specific commands
find_package(LLVM REQUIRED CONFIG)
message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION}")
message(STATUS "Using LLVMConfig.cmake in: ${LLVM_DIR}")
include_directories(${LLVM_INCLUDE_DIRS})
add_definitions(${LLVM_DEFINITIONS})
llvm_map_components_to_libnames(llvm_libs support core irreader)
target_link_libraries(etc ${llvm_libs})
# end of LLVM specific commands
install( TARGETS ${EXECUTABLE} DESTINATION bin )
cmake_policy(SET CMP0015 NEW)

1
etc/bytecode/kv.evm
View File

@ -1 +0,0 @@
33604557602a8060106000396000f200604556330e0f602a59366080530a0f602a59602060805301356080533557604060805301608054600958

179
etc/etc.cpp
View File

@ -1,179 +0,0 @@
#include <llvm/IR/IRBuilder.h>
#include <llvm/IR/Module.h>
#include <libdevcore/Common.h>
#include <libdevcore/CommonIO.h>
#include <libevmface/Instruction.h>
#include <boost/algorithm/string.hpp>
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
using namespace dev;
class EVMCCompiler
{
private:
struct
{
llvm::Type* word8;
llvm::Type* word8ptr;
llvm::Type* word256;
llvm::Type* word256ptr;
llvm::Type* word256arr;
llvm::Type* size;
} Types;
public:
EVMCCompiler()
{
auto& context = llvm::getGlobalContext();
Types.word8 = llvm::Type::getInt8Ty(context);
Types.word8ptr = llvm::Type::getInt8PtrTy(context);
Types.word256 = llvm::Type::getIntNTy(context, 256);
Types.word256ptr = Types.word256->getPointerTo();
Types.word256arr = llvm::ArrayType::get(Types.word256, 100);
Types.size = llvm::Type::getInt64Ty(context);
}
void compile(const bytes& bytecode)
{
using namespace llvm;
auto& context = getGlobalContext();
Module* module = new 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 stack = new GlobalVariable(*module, Types.word256arr, false,
GlobalValue::LinkageTypes::PrivateLinkage,
ConstantAggregateZero::get(Types.word256arr), "stack");
auto stackTop = new GlobalVariable(*module, Types.size, false,
GlobalValue::LinkageTypes::PrivateLinkage,
ConstantInt::get(Types.size, 0), "stackTop");
// Create value for void* malloc(size_t)
std::vector<Type*> mallocArgTypes = { Types.size };
Value* mallocVal = Function::Create(FunctionType::get(Types.word8ptr, mallocArgTypes, false),
GlobalValue::LinkageTypes::ExternalLinkage, "malloc", module);
// Create main function
FunctionType* funcType = FunctionType::get(llvm::Type::getInt32Ty(context), false);
Function* mainFunc = Function::Create(funcType, Function::ExternalLinkage, "main", module);
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);
/*
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);
*/
builder.CreateRet(ConstantInt::get(Type::getInt32Ty(context), 0));
module->dump();
}
};
void show_usage()
{
std::cerr << "usage: evmcc (-b|-c|-d)+ <inputfile.bc>\n";
}
int main(int argc, char** argv)
{
std::string input_file;
bool opt_dissassemble = false;
bool opt_show_bytes = false;
bool opt_compile = false;
bool opt_unknown = false;
for (int i = 1; i < argc; i++)
{
std::string option = argv[i];
if (option == "-b")
{
opt_show_bytes = true;
}
else if (option == "-c")
{
opt_compile = true;
}
else if (option == "-d")
{
opt_dissassemble = true;
}
else if (option[0] != '-' && input_file.empty())
{
input_file = option;
}
else
{
opt_unknown = true;
break;
}
}
if (opt_unknown ||
input_file.empty() ||
(!opt_show_bytes && !opt_compile && !opt_dissassemble))
{
show_usage();
exit(1);
}
std::ifstream ifs(input_file);
if (!ifs.is_open())
{
std::cerr << "cannot open file " << input_file << std::endl;
exit(1);
}
std::string src((std::istreambuf_iterator<char>(ifs)),
(std::istreambuf_iterator<char>()));
boost::algorithm::trim(src);
bytes bytecode = fromHex(src);
if (opt_show_bytes)
{
std::cout << dev::memDump(bytecode) << std::endl;
}
if (opt_dissassemble)
{
std::string assembly = eth::disassemble(bytecode);
std::cout << assembly << std::endl;
}
if (opt_compile)
{
EVMCCompiler().compile(bytecode);
}
return 0;
}

10
etc/lll/kv.lll
View File

@ -1,10 +0,0 @@
{
[[69]] (caller)
(return 0 (lll
(when (= (caller) @@69)
(for {} (< @i (calldatasize)) [i](+ @i 64)
[[ (calldataload @i) ]] (calldataload (+ @i 32))
)
)
0))
}
Write Preview
Loading…
Cancel
Save