def do_llvm_link(self):
logger.info('do_llvm_link')
tool = path.join(self._get_llvm_path(), 'llvm-link')
args = [tool]
args.extend(['-o', str(self.file_ll)])
args.extend(map(str, self.get_ll_files()))
myprocess.run_process(args)
def build_binary(self, tag, binary_name):
source_folder = self.binary_source_folder(tag, binary_name)
golang = dependencies.get_module_by_key("golang")
golang_env = golang.get_env()
myprocess.run_process(['go', 'build'],
cwd=source_folder,
env=golang_env)
def _do_llvm_opt(self):
logger.info("_do_llvm_opt")
tool = path.join(self._get_llvm_path(), "opt")
args = [
tool, "-std-link-opts", "-Oz", "-polly", self.file_bc, "-o",
self.file_bc
]
myprocess.run_process(args)
def _should_skip(self, overwrite):
if overwrite:
return False
try:
myprocess.run_process(["rustc", "--version"], env=self.get_env())
return True
except:
return False
def _do_llc(self):
logger.info("_do_llc")
tool = path.join(self._get_llvm_path(), "llc")
args = [tool]
if self.options.get("optimized", False):
args.append("-O3")
else:
args.append("-O0")
args.extend(["-filetype=obj", self.file_ll, "-o", self.file_o])
myprocess.run_process(args)
def _do_wasm_ld(self):
logger.info("_do_wasm_ld")
tool = path.join(self._get_llvm_path(), "wasm-ld")
args = [
tool, "--entry", "main", "--demangle", "--no-gc-sections",
"--export-all", "--allow-undefined", "--verbose", self.file_o,
"-o",
self.get_file_wasm()
]
myprocess.run_process(args)
def _do_clang(self):
logger.info("_do_clang")
tool = path.join(self._get_llvm_path(), "clang-9")
args = [
tool,
"-cc1", "-emit-llvm",
"-triple=wasm32-unknown-unknown-wasm",
]
if self.options.get("optimized", False):
args.append("-Ofast")
else:
args.append("-O0")
args.append(str(self.unit))
myprocess.run_process(args)
def do_llc(self):
logger.info('do_llc')
tool = path.join(self._get_llvm_path(), 'llc')
args = [tool]
if self.options.get('optimized', False):
args.append('-O3')
else:
args.append('-O0')
args.append('-filetype=obj')
args.append(str(self.file_ll))
args.extend(['-o', str(self.file_o)])
myprocess.run_process(args)
def _emit_funcions(self):
logger.info("_emit_funcions")
tool = self._get_soll_path()
args = [tool, "-action", "EmitFuncSig", str(self.unit)]
output = myprocess.run_process(args)
utils.write_file(self.file_functions, output)
def _emit_LLVM(self):
logger.info("_emit_LLVM")
tool = self._get_soll_path()
args = [tool, "-action", "EmitLLVM", str(self.unit)]
output = myprocess.run_process(args)
utils.write_file(self.file_ll, output)
def _do_wasm(self):
logger.info("_do_wasm")
tool = path.join(self._get_llvm_path(), "wasm-ld")
args = [
tool, "--no-entry",
str(self.file_o), "-o",
self.find_file_globally("*.cpp").with_suffix(".wasm"),
"--strip-all", f"--allow-undefined", "--demangle"
]
if self.options.get("verbose", False):
args.append("--verbose")
for export in self.build_configuration.exports:
args.append(f"-export={export}")
myprocess.run_process(args)
def do_clang(self):
logger.info('do_clang')
tool = path.join(self._get_llvm_path(), 'clang-9')
args = [
tool,
'-cc1',
'-emit-llvm',
'-triple=wasm32-unknown-unknown-wasm',
]
if self.options.get('optimized', False):
args.append('-Ofast')
else:
args.append('-O0')
args.extend(map(str, self.get_source_files()))
myprocess.run_process(args)
def do_wasm(self):
logger.info('do_wasm')
tool = path.join(self._get_llvm_path(), 'wasm-ld')
args = [
tool, '--no-entry',
str(self.file_o), '-o', self.file_output, '--strip-all',
'-allow-undefined'
]
if self.options.get('verbose', False):
args.append('--verbose')
logger.info('exported functions:')
for export in self.get_exported_functions():
logger.info(f'\t{export}')
args.append(f'-export={export}')
myprocess.run_process(args)
def run_tests(self, tests_directory: str, wildcard: str = ""):
arwentools = cast(StandaloneModule,
dependencies.get_module_by_key("arwentools"))
tool_env = arwentools.get_env()
tool = path.join(arwentools.get_parent_directory(), "mandos-test")
test_folder = path.join(self.directory, tests_directory)
if not wildcard:
args = [tool, test_folder]
myprocess.run_process(args, env=tool_env)
else:
pattern = path.join(test_folder, wildcard)
test_files = glob.glob(pattern)
for test_file in test_files:
print("Run test for:", test_file)
args = [tool, test_file]
myprocess.run_process(args, env=tool_env)
def build_binaries(testnet_config: TestnetConfiguration):
golang = dependencies.get_module_by_key("golang")
golang_env = golang.get_env()
myprocess.run_process(['go', 'env'], env=golang_env)
logger.info("Building seednode...")
seednode_folder = testnet_config.node_source() / "cmd" / "seednode"
myprocess.run_process(['go', 'build'], cwd=seednode_folder, env=golang_env)
logger.info("Building node...")
node_folder = testnet_config.node_source() / "cmd" / "node"
myprocess.run_process(['go', 'build'], cwd=node_folder, env=golang_env)
logger.info("Building arwen...")
node_folder_root = testnet_config.node_source()
env = dict(golang_env)
env["ARWEN_PATH"] = node_folder
myprocess.run_process(['make', 'arwen'], cwd=node_folder_root, env=env)
logger.info("Building proxy...")
proxy_folder = testnet_config.proxy_source() / "cmd" / "proxy"
myprocess.run_process(['go', 'build'], cwd=proxy_folder, env=golang_env)
# Now copy the binaries to the testnet folder
arwen_version = _get_arwen_version(testnet_config)
libwasmer_path = path.join(
golang.get_gopath(),
f"pkg/mod/github.com/!elrond!network/arwen-wasm-vm@{arwen_version}/wasmer/libwasmer_darwin_amd64.dylib"
)
shutil.copy(seednode_folder / "seednode", testnet_config.seednode_folder())
if workstation.get_platform() == "osx":
shutil.copy(libwasmer_path, testnet_config.seednode_folder())
for destination in testnet_config.all_nodes_folders():
shutil.copy(node_folder / "node", destination)
shutil.copy(node_folder / "arwen", destination)
if workstation.get_platform() == "osx":
shutil.copy(libwasmer_path, destination)
shutil.copy(proxy_folder / "proxy", testnet_config.proxy_folder())
if workstation.get_platform() == "osx":
shutil.copy(libwasmer_path, testnet_config.proxy_folder())
def sign_message_with_bls_key(message, seed):
dependencies.install_module("mcl_signer")
tool = path.join(dependencies.get_module_directory("mcl_signer"), "signer")
try:
signed_message = myprocess.run_process([tool, message, seed],
dump_to_stdout=False)
return signed_message
except Exception:
raise CannotSignMessageWithBLSKey()
def run_tests(self, tests_directory, wildcard=None):
testrunner_module = dependencies.get_module_by_key("arwentools")
tool_directory = testrunner_module.get_directory()
tool_env = testrunner_module.get_env()
tool = path.join(tool_directory, "test")
test_folder = path.join(self.directory, tests_directory)
if not wildcard:
args = [tool, test_folder]
myprocess.run_process(args, env=tool_env)
else:
pattern = path.join(test_folder, wildcard)
test_files = glob.glob(pattern)
for test_file in test_files:
print("Run test for:", test_file)
args = [tool, test_file]
myprocess.run_process(args, env=tool_env)
def is_installed(self, tag: str):
try:
myprocess.run_process(["rustc", "--version"], env=self.get_env())
return True
except Exception:
return False
def _do_llvm_link(self):
logger.info("_do_llvm_link")
tool = path.join(self._get_llvm_path(), "llvm-link")
args = [tool, self.file_ll, self.file_main_ll, "-o", self.file_bc]
myprocess.run_process(args)
def _do_llc(self):
logger.info("_do_llc")
tool = path.join(self._get_llvm_path(), "llc")
args = [tool, "-O3", "-filetype=obj", self.file_bc, "-o", self.file_o]
myprocess.run_process(args)
