def build_transpiler(args): cargo = get_cmd_or_die("cargo") build_flags = ["build", "--features", "llvm-static"] if not args.debug: build_flags.append("--release") llvm_config = os.path.join(c.LLVM_BLD, "bin/llvm-config") assert os.path.isfile(llvm_config), "missing binary: " + llvm_config if on_mac(): llvm_system_libs = "-lz -lcurses -lm -lxml2" else: # linux llvm_system_libs = "-lz -lrt -ltinfo -ldl -lpthread -lm" llvm_libdir = os.path.join(c.LLVM_BLD, "lib") # log how we run `cargo build` to aid troubleshooting, IDE setup, etc. msg = "invoking cargo build as\ncd {} && \\\n".format(c.C2RUST_DIR) msg += "LLVM_CONFIG_PATH={} \\\n".format(llvm_config) msg += "LLVM_SYSTEM_LIBS='{}' \\\n".format(llvm_system_libs) msg += "C2RUST_AST_EXPORTER_LIB_DIR={} \\\n".format(llvm_libdir) msg += " cargo +{} ".format(c.CUSTOM_RUST_NAME) msg += " ".join(build_flags) logging.debug(msg) with pb.local.cwd(c.C2RUST_DIR): with pb.local.env(LLVM_CONFIG_PATH=llvm_config, LLVM_SYSTEM_LIBS=llvm_system_libs, C2RUST_AST_EXPORTER_LIB_DIR=llvm_libdir): # build with custom rust toolchain invoke(cargo, "+" + c.CUSTOM_RUST_NAME, *build_flags)
def gen_cc_db(self): with pb.local.cwd(self.repo_dir): invoke(make, ['clean']) invoke(intercept_build, *self.ib_cmd) self.cc_db = build_path(self.repo_dir, 'compile_commands.json', is_dir=False)
def build_clang_plugin(args: str) -> None: """ run cmake as needed to generate ninja buildfiles. then run ninja. """ ninja = get_cmd_or_die("ninja") # Possible values are Release, Debug, RelWithDebInfo and MinSizeRel build_type = "Debug" if args.debug else "RelWithDebInfo" ninja_build_file = os.path.join(c.CLANG_XCHECK_PLUGIN_BLD, "build.ninja") with pb.local.cwd(c.CLANG_XCHECK_PLUGIN_BLD): if os.path.isfile(ninja_build_file): prev_build_type = get_ninja_build_type(ninja_build_file) run_cmake = prev_build_type != build_type else: run_cmake = True if run_cmake: cmake = get_cmd_or_die("cmake") max_link_jobs = est_parallel_link_jobs() cargs = ["-G", "Ninja", c.CLANG_XCHECK_PLUGIN_SRC, "-DLLVM_DIR={}/lib/cmake/llvm".format(c.LLVM_BLD), "-DClang_DIR={}/lib/cmake/clang".format(c.LLVM_BLD), "-DLLVM_EXTERNAL_LIT={}/bin/llvm-lit".format(c.LLVM_BLD), "-DCMAKE_BUILD_TYPE=" + build_type, "-DBUILD_SHARED_LIBS=1", "-DLLVM_PARALLEL_LINK_JOBS={}".format(max_link_jobs)] invoke(cmake[cargs]) else: logging.debug("found existing ninja.build, not running cmake") invoke(ninja)
def test_lua(args: argparse.Namespace) -> bool: """ download lua, compile lua with bear to create a compiler command database, and use it to drive the transpiler. """ if not os.path.isfile(os.path.join(c.DEPS_DIR, LUA_ARCHIVE)): with pb.local.cwd(c.DEPS_DIR): download_archive(LUA_URL, LUA_ARCHIVE) if not os.path.isdir(LUA_SRC): with pb.local.cwd(c.DEPS_DIR): invoke_quietly(TAR, "xf", LUA_ARCHIVE) # unconditionally compile lua since we don't know if # cc_db was generated from the environment we're in. build_dir = os.path.join(LUA_SRC, "build") rmtree(build_dir, ignore_errors=True) os.mkdir(build_dir) with pb.local.cwd(build_dir), pb.local.env(CC="clang"): invoke(CMAKE['-DCMAKE_EXPORT_COMPILE_COMMANDS=1', LUA_SRC]) invoke(MAKE[JOBS]) cc_db_file = os.path.join(LUA_SRC, "build", c.CC_DB_JSON) if not os.path.isfile(cc_db_file): die("missing " + cc_db_file, errno.ENOENT) with open(cc_db_file) as cc_db: return transpile_files(cc_db, args.jobs, None, False, args.verbose)
def gen_cc_db(self): # Without --disable-static, libtool builds two copies of many source # files. We can't handle that, so we disable that behavior here. self.autotools(['--disable-static']) with pb.local.cwd(self.repo_dir): invoke(make, ['clean']) invoke(intercept_build, *self.ib_cmd)
def _test_minimal(code_snippet: str) -> bool: ast_expo = get_cmd_or_die(c.AST_EXPO) ast_impo = get_cmd_or_die(c.AST_IMPO) tempdir = tempfile.gettempdir() cfile = os.path.join(tempdir, "test.c") with open(cfile, 'w') as fh: fh.write(code_snippet) # avoid warnings about missing compiler flags, not strictly required cc_json = os.path.join(tempdir, "compile_commands.json") with open(cc_json, 'w') as fh: fh.write(minimal_cc_db) cborfile = cfile + '.cbor' invoke(ast_expo[cfile]) ld_lib_path = get_rust_toolchain_libpath() # don't overwrite existing ld lib path if any... if 'LD_LIBRARY_PATH' in pb.local.env: ld_lib_path += ':' + pb.local.env['LD_LIBRARY_PATH'] args = [] args += ['--ddump-untyped-clang-ast'] args += [cborfile] # import ast with pb.local.env(RUST_BACKTRACE='1', LD_LIBRARY_PATH=ld_lib_path): invoke(ast_impo, args) return True # if we get this far, test passed
def test(self): # testname -> input_file tests = { "xmllint": ['test/bigname.xml'], "runtest": [], "testapi": [], "testSAX": [], "testURI": ['test/bigname.xml'], "testdict": [], "testHTML": ['test/HTML/html5_enc.html'], "testC14N": ['--', '--with-comments', 'test/c14n/with-comments/example-7.xml'], "testchar": [], "testRelax": ['test/bigname.xml'], "testXPath": ['test/bigname.xml'], "testModule": [], "testlimits": [], # "testReader", Not working at the moment "testRegexp": ['test/regexp'], "testrecurse": [], "testSchemas": ['test/schemas/all_0.xsd'], "testThreads": [], "testAutomata": ['test/automata/po'], } for test, input_file in tests.items(): with pb.local.cwd(self.rust_src): example_args = ['run', '--example', test] example_args.extend(input_file) invoke(cargo, *example_args)
def _main(): setup_logging() logging.debug("args: %s", " ".join(sys.argv)) # FIXME: allow env/cli override of LLVM_SRC and LLVM_BLD # FIXME: check that cmake and ninja are installed # FIXME: option to build LLVM/Clang from master? args = _parse_args() if args.clean_all: logging.info("cleaning all dependencies and previous built files") shutil.rmtree(c.LLVM_SRC, ignore_errors=True) shutil.rmtree(c.LLVM_BLD, ignore_errors=True) shutil.rmtree(c.BUILD_DIR, ignore_errors=True) shutil.rmtree(c.AST_EXPO_PRJ_DIR, ignore_errors=True) cargo = get_cmd_or_die("cargo") with pb.local.cwd(c.ROOT_DIR): invoke(cargo, "clean") ensure_dir(c.LLVM_BLD) ensure_dir(c.BUILD_DIR) git_ignore_dir(c.BUILD_DIR) download_llvm_sources() configure_and_build_llvm(args) build_transpiler(args) print_success_msg(args)
def test_clang_cross_checks(): ninja = get_cmd_or_die("ninja") logging.info("entering %s", c.CLANG_XCHECK_PLUGIN_BLD) with pb.local.cwd(c.CLANG_XCHECK_PLUGIN_BLD): # FIXME: do we really need to clean before every test run??? invoke(ninja, ["clean"]) invoke(ninja, ["check-cross-checks"])
def _main(): setup_logging() logging.debug("args: %s", " ".join(sys.argv)) # FIXME: allow env/cli override of LLVM_SRC, LLVM_VER, and LLVM_BLD # FIXME: check that cmake and ninja are installed # FIXME: option to build LLVM/Clang from master? # earlier plumbum versions are missing features such as TEE if pb.__version__ < c.MIN_PLUMBUM_VERSION: err = "locally installed version {} of plumbum is too old.\n" \ .format(pb.__version__) err += "please upgrade plumbum to version {} or later." \ .format(c.MIN_PLUMBUM_VERSION) die(err) args = _parse_args() # prerequisites if not have_rust_toolchain(c.CUSTOM_RUST_NAME): die("missing rust toolchain: " + c.CUSTOM_RUST_NAME, errno.ENOENT) # clang 3.6.0 is known to work; 3.4.0 known to not work. ensure_clang_version([3, 6, 0]) if args.clean_all: logging.info("cleaning all dependencies and previous built files") shutil.rmtree(c.LLVM_SRC, ignore_errors=True) shutil.rmtree(c.LLVM_BLD, ignore_errors=True) shutil.rmtree(c.DEPS_DIR, ignore_errors=True) shutil.rmtree(c.AST_EXPO_PRJ_DIR, ignore_errors=True) cargo = get_cmd_or_die("cargo") with pb.local.cwd(c.ROOT_DIR): invoke(cargo, "clean") ensure_dir(c.LLVM_BLD) ensure_dir(c.DEPS_DIR) git_ignore_dir(c.DEPS_DIR) download_llvm_sources() update_cmakelists() configure_and_build_llvm(args) build_transpiler(args) # print a helpful message on how to run c2rust bin directly c2rust_bin_path = 'target/debug/c2rust' if args.debug \ else 'target/release/c2rust' c2rust_bin_path = os.path.join(c.ROOT_DIR, c2rust_bin_path) # if os.path.curdir abs_curdir = os.path.abspath(os.path.curdir) common_path = os.path.commonpath([abs_curdir, c2rust_bin_path]) if common_path != "/": c2rust_bin_path = "." + c2rust_bin_path[len(common_path):] print("success! you may now run", c2rust_bin_path)
def test_rust_cross_checks(): rustup = get_cmd_or_die("rustup") rust_proj_path = os.path.join(c.CROSS_CHECKS_DIR, "rust-checks") logging.info("entering %s", rust_proj_path) with pb.local.cwd(rust_proj_path): invoke(rustup, ["run", c.CUSTOM_RUST_NAME, "cargo", "clean"]) args = ["run", c.CUSTOM_RUST_NAME, "cargo", "test"] invoke(rustup, *args)
def build_transpiler(args): nice = get_cmd_or_die("nice") cargo = get_cmd_or_die("cargo") if need_cargo_clean(args): invoke(cargo, "clean") build_flags = [ "-n", "19", str(cargo), "build", "--features", "llvm-static" ] if not args.debug: build_flags.append("--release") if args.verbose: build_flags.append("-vv") llvm_config = os.path.join(c.LLVM_BLD, "bin/llvm-config") assert os.path.isfile(llvm_config), "missing binary: " + llvm_config if on_mac(): llvm_system_libs = "-lz -lcurses -lm -lxml2" else: # linux llvm_system_libs = "-lz -lrt -ltinfo -ldl -lpthread -lm" llvm_libdir = os.path.join(c.LLVM_BLD, "lib") # log how we run `cargo build` to aid troubleshooting, IDE setup, etc. msg = "invoking cargo build as\ncd {} && \\\n".format(c.C2RUST_DIR) msg += "LIBCURL_NO_PKG_CONFIG=1\\\n" msg += "ZLIB_NO_PKG_CONFIG=1\\\n" msg += "LLVM_CONFIG_PATH={} \\\n".format(llvm_config) msg += "LLVM_SYSTEM_LIBS='{}' \\\n".format(llvm_system_libs) msg += "C2RUST_AST_EXPORTER_LIB_DIR={} \\\n".format(llvm_libdir) msg += " cargo" msg += " ".join(build_flags) logging.debug(msg) # NOTE: the `curl-rust` and `libz-sys` crates use the `pkg_config` # crate to locate the system libraries they wrap. This causes # `pkg_config` to add `/usr/lib` to `rustc`s library search path # which means that our `cargo` invocation picks up the system # libraries even when we're trying to link against libs we built. # https://docs.rs/pkg-config/0.3.14/pkg_config/ with pb.local.cwd(c.C2RUST_DIR): with pb.local.env(LIBCURL_NO_PKG_CONFIG=1, ZLIB_NO_PKG_CONFIG=1, LLVM_CONFIG_PATH=llvm_config, LLVM_SYSTEM_LIBS=llvm_system_libs, C2RUST_AST_EXPORTER_LIB_DIR=llvm_libdir): invoke(nice, *build_flags)
def build_ast_importer(debug: bool): cargo = get_cmd_or_die("cargo") build_flags = ["build"] if not debug: build_flags.append("--release") with pb.local.cwd(os.path.join(c.ROOT_DIR, "ast-importer")): # use different target dirs for different hosts target_dir = "target." + platform.node() with pb.local.env(CARGO_TARGET_DIR=target_dir): # build with custom rust toolchain invoke(cargo, "+" + c.CUSTOM_RUST_NAME, *build_flags)
def checkout_and_build_libclevrbuf(): """ NOTE: we don't need libclevrbuf if we simply pass `--features "xcheck-with-dlsym"` in the `runtime/` dir. """ make = get_cmd_or_die("make") if not os.path.isdir(c.LIBCLEVRBUF_DIR): update_or_init_submodule(c.REMON_SUBMOD_DIR) if not os.path.isfile(os.path.join(c.LIBCLEVRBUF_DIR, "libclevrbuf.so")): with pb.local.cwd(c.LIBCLEVRBUF_DIR): invoke(make, "lib")
def _main(): setup_logging() logging.debug("args: %s", " ".join(sys.argv)) # FIXME: allow env/cli override of LLVM_SRC and LLVM_BLD # FIXME: check that cmake and ninja are installed # FIXME: option to build LLVM/Clang from master? # earlier plumbum versions are missing features such as TEE if pb.__version__ < c.MIN_PLUMBUM_VERSION: err = "locally installed version {} of plumbum is too old.\n" \ .format(pb.__version__) err += "please upgrade plumbum to version {} or later." \ .format(c.MIN_PLUMBUM_VERSION) die(err) args = _parse_args() # prerequisites if not have_rust_toolchain(c.CUSTOM_RUST_NAME): die("missing rust toolchain: " + c.CUSTOM_RUST_NAME, errno.ENOENT) # clang 3.6.0 is known to work; 3.4.0 known to not work. ensure_clang_version([3, 6, 0]) if args.clean_all: logging.info("cleaning all dependencies and previous built files") shutil.rmtree(c.LLVM_SRC, ignore_errors=True) shutil.rmtree(c.LLVM_BLD, ignore_errors=True) shutil.rmtree(c.BUILD_DIR, ignore_errors=True) shutil.rmtree(c.AST_EXPO_PRJ_DIR, ignore_errors=True) cargo = get_cmd_or_die("cargo") with pb.local.cwd(c.ROOT_DIR): invoke(cargo, "clean") ensure_dir(c.LLVM_BLD) ensure_dir(c.BUILD_DIR) git_ignore_dir(c.BUILD_DIR) download_llvm_sources() update_cmakelists() configure_and_build_llvm(args) build_transpiler(args) print_success_msg(args)
def _invoke(self, cmd, dry_run=None): if dry_run is None: dry_run = self.dry_run print(cmd) result = True if not dry_run: result = invoke(cmd) print() return result
def build_transpiler(args): nice = get_cmd_or_die("nice") cargo = get_cmd_or_die("cargo") if need_cargo_clean(args): invoke(cargo, "clean") build_flags = [ "-n", "19", str(cargo), "build", "--features", "llvm-static" ] if not args.debug: build_flags.append("--release") if args.verbose: build_flags.append("-vv") llvm_config = os.path.join(c.LLVM_BLD, "bin/llvm-config") assert os.path.isfile(llvm_config), \ "expected llvm_config at " + llvm_config if on_mac(): llvm_system_libs = "-lz -lcurses -lm -lxml2" else: # linux llvm_system_libs = "-lz -lrt -ltinfo -ldl -lpthread -lm" llvm_libdir = os.path.join(c.LLVM_BLD, "lib") # NOTE: the `curl-rust` and `libz-sys` crates use the `pkg_config` # crate to locate the system libraries they wrap. This causes # `pkg_config` to add `/usr/lib` to `rustc`s library search path # which means that our `cargo` invocation picks up the system # libraries even when we're trying to link against libs we built. # https://docs.rs/pkg-config/0.3.14/pkg_config/ with pb.local.cwd(c.C2RUST_DIR): with pb.local.env(LIBCURL_NO_PKG_CONFIG=1, ZLIB_NO_PKG_CONFIG=1, LLVM_CONFIG_PATH=llvm_config, LLVM_LIB_DIR=llvm_libdir, LLVM_SYSTEM_LIBS=llvm_system_libs): invoke(nice, *build_flags)
def configure_and_build_llvm(args: str) -> None: """ run cmake as needed to generate ninja buildfiles. then run ninja. """ ninja = get_cmd_or_die("ninja") # Possible values are Release, Debug, RelWithDebInfo and MinSizeRel build_type = "Debug" if args.debug else "RelWithDebInfo" ninja_build_file = os.path.join(c.LLVM_BLD, "build.ninja") with pb.local.cwd(c.LLVM_BLD): if os.path.isfile(ninja_build_file): prev_build_type = get_ninja_build_type(ninja_build_file) run_cmake = prev_build_type != build_type else: run_cmake = True if run_cmake: cmake = get_cmd_or_die("cmake") max_link_jobs = est_parallel_link_jobs() assertions = "1" if args.assertions else "0" cargs = ["-G", "Ninja", c.LLVM_SRC, "-Wno-dev", "-DCMAKE_C_COMPILER=clang", "-DCMAKE_CXX_COMPILER=clang++", "-DCMAKE_BUILD_TYPE=" + build_type, "-DLLVM_ENABLE_ASSERTIONS=" + assertions, "-DCMAKE_EXPORT_COMPILE_COMMANDS=1", "-DLLVM_TARGETS_TO_BUILD=X86", "-DLLVM_INCLUDE_UTILS=1", "-DLLVM_BUILD_UTILS=1", "-DBUILD_SHARED_LIBS=1", "-DLLVM_PARALLEL_LINK_JOBS={}".format(max_link_jobs), "-DTINYCBOR_PREFIX={}".format(c.CBOR_PREFIX)] invoke(cmake[cargs]) else: logging.debug("found existing ninja.build, not running cmake") ninja_args = ['ast-exporter'] ninja_args += ['FileCheck', 'count', 'not'] if args.with_clang: ninja_args.append('clang') invoke(ninja, *ninja_args)
def test_ruby(args: argparse.Namespace) -> bool: if on_mac(): die("transpiling ruby on mac is not supported.") if not os.path.isfile(os.path.join(c.DEPS_DIR, RUBY_ARCHIVE)): with pb.local.cwd(c.DEPS_DIR): download_archive(RUBY_URL, RUBY_ARCHIVE) invoke_quietly(TAR, "xf", RUBY_ARCHIVE) cc_db_file = os.path.join(RUBY_SRC, c.CC_DB_JSON) # unconditionally compile ruby since we don't know if # cc_db was generated from the environment we're in. with pb.local.cwd(RUBY_SRC), pb.local.env(CC="clang", cflags="-w"): configure = pb.local.get("./configure") invoke(configure) invoke(BEAR[MAKE[JOBS]]) if not os.path.isfile(cc_db_file): die("missing " + cc_db_file, errno.ENOENT) with open(cc_db_file) as cc_db: return transpile_files(cc_db, args.jobs, None, False, args.verbose)
def build_clang_plugin(args: str) -> None: """ run cmake as needed to generate ninja buildfiles. then run ninja. """ cargo = get_cmd_or_die("cargo") config_capi_src_dir = os.path.join(c.CROSS_CHECKS_DIR, "rust-checks", "config-capi") cargo_target_dir = os.path.join(c.CLANG_XCHECK_PLUGIN_BLD, "config-capi-target") config_lib_path = os.path.join(cargo_target_dir, "debug" if args.debug else "release", "libc2rust_xcheck_config_capi.a") with pb.local.cwd(config_capi_src_dir): cargo_args = ["build", "--package", "c2rust-xcheck-config-capi"] if not args.debug: cargo_args.append("--release") with pb.local.env(CARGO_TARGET_DIR=cargo_target_dir): invoke(cargo[cargo_args]) ninja = get_cmd_or_die("ninja") # Possible values are Release, Debug, RelWithDebInfo and MinSizeRel build_type = "Debug" if args.debug else "RelWithDebInfo" ninja_build_file = os.path.join(c.CLANG_XCHECK_PLUGIN_BLD, "build.ninja") with pb.local.cwd(c.CLANG_XCHECK_PLUGIN_BLD): if os.path.isfile(ninja_build_file): prev_build_type = get_ninja_build_type(ninja_build_file) run_cmake = prev_build_type != build_type else: run_cmake = True if run_cmake: cmake = get_cmd_or_die("cmake") max_link_jobs = est_parallel_link_jobs() cargs = [ "-G", "Ninja", c.CLANG_XCHECK_PLUGIN_SRC, "-DXCHECK_CONFIG_LIB={}".format(config_lib_path), "-DCMAKE_BUILD_TYPE=" + build_type, "-DBUILD_SHARED_LIBS=1", "-DLLVM_PARALLEL_LINK_JOBS={}".format(max_link_jobs) ] if args.with_c2rust_clang: cargs.extend([ "-DLLVM_DIR={}/lib/cmake/llvm".format(c.LLVM_BLD), "-DClang_DIR={}/lib/cmake/clang".format(c.LLVM_BLD), "-DLLVM_EXTERNAL_LIT={}/bin/llvm-lit".format(c.LLVM_BLD) ]) else: # Some distros, e.g., Arch, Ubuntu, ship llvm-lit as /usr/bin/lit cargs.append("-DLLVM_EXTERNAL_LIT={}".format(pb.local['lit'])) invoke(cmake[cargs]) else: logging.debug("found existing ninja.build, not running cmake") invoke(ninja)
def test(self): rm = get_cmd_or_die('rm') ln = get_cmd_or_die('ln') for N in (1, 4): test = 'example{}'.format(N) with pb.local.cwd(self.repo_dir): invoke(rm, ['-rf', self.rust_src]) self._transpile_example(test) with pb.local.cwd(self.rust_src): # Create a link to the example data files invoke(ln, ['-sf', build_path(self.repo_dir, 'example', True)]) invoke(cargo, ['run'])
def test_json_c(args: argparse.Namespace) -> bool: if not os.path.isfile(os.path.join(c.DEPS_DIR, JSON_C_ARCHIVE)): with pb.local.cwd(c.DEPS_DIR): download_archive(JSON_C_URL, JSON_C_ARCHIVE) invoke_quietly(TAR, "xf", JSON_C_ARCHIVE) cc_db_file = os.path.join(JSON_C_SRC, c.CC_DB_JSON) # unconditionally compile json-c since we don't know if # cc_db was generated from the environment we're in. with pb.local.cwd(JSON_C_SRC), pb.local.env(CC="clang"): if os.path.isfile('Makefile'): invoke(MAKE['clean']) configure = pb.local.get("./configure") invoke(configure) invoke(BEAR[MAKE[JOBS]]) if not os.path.isfile(cc_db_file): die("missing " + cc_db_file, errno.ENOENT) return transpile(cc_db_file)
def configure_and_build_llvm(args) -> None: """ run cmake as needed to generate ninja buildfiles. then run ninja. """ # Possible values are Release, Debug, RelWithDebInfo and MinSizeRel build_type = "Debug" if args.debug else "RelWithDebInfo" ninja_build_file = os.path.join(c.LLVM_BLD, "build.ninja") with pb.local.cwd(c.LLVM_BLD): if os.path.isfile(ninja_build_file) and not args.xcode: prev_build_type = get_ninja_build_type(ninja_build_file) run_cmake = prev_build_type != build_type else: run_cmake = True if run_cmake: cmake = get_cmd_or_die("cmake") max_link_jobs = est_parallel_link_jobs() assertions = "1" if args.assertions else "0" cargs = ["-G", "Ninja", c.LLVM_SRC, "-Wno-dev", "-DCMAKE_INSTALL_PREFIX=" + c.LLVM_INSTALL, "-DCMAKE_BUILD_TYPE=" + build_type, "-DLLVM_PARALLEL_LINK_JOBS={}".format(max_link_jobs), "-DLLVM_ENABLE_ASSERTIONS=" + assertions, "-DCMAKE_EXPORT_COMPILE_COMMANDS=1", "-DLLVM_TARGETS_TO_BUILD=host"] invoke(cmake[cargs]) # NOTE: we only generate Xcode project files for IDE support # and don't build with them since the cargo build.rs files # rely on cmake to build native code. if args.xcode: cargs[1] = "Xcode" # output Xcode project files in a separate dir ensure_dir(c.AST_EXPO_PRJ_DIR) with pb.local.cwd(c.AST_EXPO_PRJ_DIR): invoke(cmake[cargs]) else: logging.debug("found existing ninja.build, not running cmake") # if args.xcode: # xcodebuild = get_cmd_or_die("xcodebuild") # xc_conf_args = ['-configuration', build_type] # xc_args = xc_conf_args + ['-target', 'llvm-config'] # invoke(xcodebuild, *xc_args) # xc_args = xc_conf_args + ['-target', 'c2rust-ast-exporter'] # invoke(xcodebuild, *xc_args) # We must install headers here so our clang tool can reference # compiler-internal headers such as stddef.h. This reference is # relative to LLVM_INSTALL/bin, which MUST exist for the relative # reference to be valid. To force this, we also install llvm-config, # since we are building and using it for other purposes. nice = get_cmd_or_die("nice") ninja = get_cmd_or_die("ninja") nice_args = [ '-n', '19', str(ninja), 'clangAST', 'clangFrontend', 'clangTooling', 'clangBasic', 'clangASTMatchers', 'clangParse', 'clangSerialization', 'clangSema', 'clangEdit', 'clangAnalysis', 'clangDriver', 'clangFormat', 'clangToolingCore', 'clangRewrite', 'clangLex', 'LLVMMC', 'LLVMMCParser', 'LLVMDemangle', 'LLVMSupport', 'LLVMOption', 'LLVMBinaryFormat', 'LLVMCore', 'LLVMBitReader', 'LLVMProfileData', 'llvm-config', 'install-clang-headers', 'install-compiler-rt-headers', 'FileCheck', 'count', 'not'] (major, _minor, _point) = c.LLVM_VER.split(".") major = int(major) if major >= 7 and major < 10: nice_args += [ 'LLVMDebugInfoMSF', 'LLVMDebugInfoCodeView'] if major > 8: nice_args.append("install-clang-resource-headers") if major == 9: nice_args += [ 'LLVMBitstreamReader', 'LLVMRemarks'] if major >= 10: nice_args.append("LLVMFrontendOpenMP") if args.with_clang: nice_args.append('clang') invoke(nice, *nice_args) # Make sure install/bin exists so that we can create a relative path # using it in AstExporter.cpp os.makedirs(os.path.join(c.LLVM_INSTALL, 'bin'), exist_ok=True)
def build_libfakechecks(): make = get_cmd_or_die("make") if not os.path.isfile(os.path.join(c.LIBFAKECHECKS_DIR, "libfakechecks.so")): with pb.local.cwd(c.LIBFAKECHECKS_DIR): invoke(make, "all")
def build(self): with pb.local.cwd(self.repo_dir): invoke(rustc, *self.build_flags)
def init_submodule(self): if self.args.regex_examples.fullmatch(self.project_name): print_blue("Initializing {}...".format(self.project_name)) with pb.local.cwd(self.example_dir): invoke(git, ['submodule', 'update', '--init', 'repo'])
def deinit_submodule(self): if self.args.regex_examples.fullmatch( self.project_name) and self.args.deinit: print_blue("Deinitializing {}...".format(self.project_name)) with pb.local.cwd(self.example_dir): invoke(git, ['submodule', 'deinit', 'repo', '-f'])
def autotools(self, configure_args=[]): with pb.local.cwd(self.repo_dir): invoke(pb.local['./autogen.sh']) with pb.local.env(CFLAGS="-g -O0"): invoke(pb.local['./configure'], configure_args)
def configure_and_build_llvm(args) -> None: """ run cmake as needed to generate ninja buildfiles. then run ninja. """ # Possible values are Release, Debug, RelWithDebInfo and MinSizeRel build_type = "Debug" if args.debug else "RelWithDebInfo" ninja_build_file = os.path.join(c.LLVM_BLD, "build.ninja") with pb.local.cwd(c.LLVM_BLD): if os.path.isfile(ninja_build_file) and not args.xcode: prev_build_type = get_ninja_build_type(ninja_build_file) run_cmake = prev_build_type != build_type else: run_cmake = True if run_cmake: cmake = get_cmd_or_die("cmake") clang = get_cmd_or_die("clang") clangpp = get_cmd_or_die("clang++") max_link_jobs = est_parallel_link_jobs() assertions = "1" if args.assertions else "0" ast_ext_dir = "-DLLVM_EXTERNAL_C2RUST_AST_EXPORTER_SOURCE_DIR={}" ast_ext_dir = ast_ext_dir.format(c.AST_EXPO_SRC_DIR) cargs = ["-G", "Ninja", c.LLVM_SRC, "-Wno-dev", "-DCMAKE_C_COMPILER={}".format(clang), "-DCMAKE_CXX_COMPILER={}".format(clangpp), "-DCMAKE_INSTALL_PREFIX=" + c.LLVM_INSTALL, "-DCMAKE_BUILD_TYPE=" + build_type, "-DLLVM_PARALLEL_LINK_JOBS={}".format(max_link_jobs), "-DLLVM_ENABLE_ASSERTIONS=" + assertions, "-DCMAKE_EXPORT_COMPILE_COMMANDS=1", # required to build LLVM 8 on Debian Jessie "-DLLVM_TEMPORARILY_ALLOW_OLD_TOOLCHAIN=1", ast_ext_dir] if on_x86(): # speed up builds on x86 hosts cargs.append("-DLLVM_TARGETS_TO_BUILD=X86") invoke(cmake[cargs]) # NOTE: we only generate Xcode project files for IDE support # and don't build with them since the cargo build.rs files # rely on cmake to build native code. if args.xcode: cargs[1] = "Xcode" # output Xcode project files in a separate dir ensure_dir(c.AST_EXPO_PRJ_DIR) with pb.local.cwd(c.AST_EXPO_PRJ_DIR): invoke(cmake[cargs]) else: logging.debug("found existing ninja.build, not running cmake") # if args.xcode: # xcodebuild = get_cmd_or_die("xcodebuild") # xc_conf_args = ['-configuration', build_type] # xc_args = xc_conf_args + ['-target', 'llvm-config'] # invoke(xcodebuild, *xc_args) # xc_args = xc_conf_args + ['-target', 'c2rust-ast-exporter'] # invoke(xcodebuild, *xc_args) # We must install headers here so our clang tool can reference # compiler-internal headers such as stddef.h. This reference is # relative to LLVM_INSTALL/bin, which MUST exist for the relative # reference to be valid. To force this, we also install llvm-config, # since we are building and using it for other purposes. ninja = get_cmd_or_die("ninja") ninja_args = ['c2rust-ast-exporter', 'clangAstExporter', 'llvm-config', 'install-clang-headers', 'FileCheck', 'count', 'not'] if args.with_clang: ninja_args.append('clang') invoke(ninja, *ninja_args) # Make sure install/bin exists so that we can create a relative path # using it in AstExporter.cpp os.makedirs(os.path.join(c.LLVM_INSTALL, 'bin'), exist_ok=True)
def build(self): with pb.local.cwd(self.rust_src): invoke(cargo, ['build', '-j{}'.format(NUM_JOBS)])