def build(self): source_dir = self.subject.getSourceDir() output_dir = self.subject.getOutputDir() if not wabt_dir: mx.abort( "No WABT_DIR specified - the source programs will not be compiled to .wasm." ) wat2wasm_cmd = os.path.join(wabt_dir, "wat2wasm") mx.log("Building files from the source dir: " + source_dir) for root, filename in self.subject.getProgramSources(): subdir = os.path.relpath(root, self.subject.getSourceDir()) mx.ensure_dir_exists(os.path.join(output_dir, subdir)) basename = remove_extension(filename) source_path = os.path.join(root, filename) output_wasm_path = os.path.join(output_dir, subdir, basename + ".wasm") output_wat_path = os.path.join(output_dir, subdir, basename + ".wat") timestamped_source = mx.TimeStampFile(source_path) timestamped_output = mx.TimeStampFile(output_wasm_path) must_rebuild = timestamped_source.isNewerThan( timestamped_output) or not timestamped_output.exists() if must_rebuild: build_cmd_line = [wat2wasm_cmd ] + [source_path, "-o", output_wasm_path] if mx.run(build_cmd_line, nonZeroIsFatal=False) != 0: mx.abort("Could not build the wasm binary of '" + filename + "' with wat2wasm.") shutil.copyfile(source_path, output_wat_path)
def clean(self, forBuild=False): if forBuild: output_dir = self.subject.getOutputDir() for root, filename in self.subject.getProgramSources(): output_wasm = mx.TimeStampFile(os.path.join(output_dir, remove_extension(filename) + ".wasm")) if mx.TimeStampFile(os.path.join(root, filename)).isNewerThan(output_wasm): mx.logv(str(output_wasm) + " is older than " + os.path.join(root, filename) + ", removing.") os.remove(output_wasm.path) else: mx.rmtree(self.subject.output_dir(), ignore_errors=True)
def _need_configure(self): source_dir = self.subject.source_dirs()[0] cmake_lists = os.path.join(source_dir, "CMakeLists.txt") guard_file = self.guard_file() cmake_config = self.subject.cmake_config() if not os.path.exists(guard_file): return True, "No CMake configuration found - reconfigure" if os.path.exists(cmake_lists) and mx.TimeStampFile(cmake_lists).isNewerThan(mx.TimeStampFile(guard_file)): return True, cmake_lists + " is newer than the configuration - reconfigure" with open(guard_file, 'r') as fp: if fp.read() != self._guard_data(source_dir, cmake_config): return True, "CMake configuration changed - reconfigure" return False, None
def _netbeansinit_suite(args, jdks, suite, refreshOnly=False, buildProcessorJars=True): netbeans_dir = mx.ensure_dir_exists(suite.get_mx_output_dir()) configZip = mx.TimeStampFile(join(netbeans_dir, 'netbeans-config.zip')) configLibsZip = join(netbeans_dir, 'netbeans-config-libs.zip') if refreshOnly and not configZip.exists(): return if mx_ideconfig._check_ide_timestamp(suite, configZip, 'netbeans'): mx.logv('[NetBeans configurations are up to date - skipping]') return files = [] libFiles = [] for p in suite.projects: if not p.isJavaProject(): continue if exists(join(p.dir, 'plugin.xml')): # eclipse plugin project continue includedInDists = [d for d in suite.dists if p in d.archived_deps()] _netbeansinit_project(p, jdks, files, libFiles, includedInDists) mx_ideconfig._zip_files(files, suite.dir, configZip.path) mx_ideconfig._zip_files(libFiles, suite.dir, configLibsZip)
def _newest(path): """ Computes the newest timestamp for `path`. This is simply the timestamp of `path` if it is a file. Otherwise, it's the timestamp of the newest file in the `path` directory. """ ts = mx.TimeStampFile(path) if isdir(path): for dirpath, _, filenames in os.walk(path): for filename in filenames: if filename.endswith('.class') and filename not in ( 'module-info.class', 'package-info.class'): file_ts = mx.TimeStampFile(join(dirpath, filename)) if file_ts.isNewerThan(ts): ts = file_ts return ts
def needsBuild(self, newestInput): if not exists(self.jvm_args_file): return (True, self.jvm_args_file + " does not exist") jvm_args = mx.TimeStampFile(self.jvm_args_file) # Depends on mx.truffleruby/env which can change which suites are binary if exists(self.mx_env) and jvm_args.isOlderThan(self.mx_env): return (True, self.jvm_args_file + " is older than " + self.mx_env) # and on suite.py which can change dependencies and the classpath if jvm_args.isOlderThan(self.suite_py): return (True, self.jvm_args_file + " is older than " + self.suite_py) # and on this file which can change the list of distributions for the classpath if jvm_args.isOlderThan(self.mx_truffleruby): return (True, self.jvm_args_file + " is older than " + self.mx_truffleruby) if sys.platform.startswith('darwin'): return (mx.TimeStampFile(self.launcher).isOlderThan(self.binary), self.launcher) else: return (not exists(self.launcher), self.launcher)
def needsBuild(self, newestInput): is_needed, reason = super(GraalWasmSourceFileTask, self).needsBuild(newestInput) if is_needed: return True, reason tsNewestSource = mx.TimeStampFile.newest([os.path.join(root, f) for root, f in self.subject.getSources()]) for result in self.subject.getResults(): tsResult = mx.TimeStampFile(result) if tsResult.isOlderThan(tsNewestSource): return (True, "File " + result + " is older than the newest source file " + str(tsNewestSource)) return (False, "Build outputs are up-to-date.")
def needsBuild(self, newestInput): sup = super(GraalVmSymLinksBuildTask, self).needsBuild(newestInput) if sup[0]: return sup if mx.get_os() != 'windows': for src, dest in self.subject.links: if not os.path.lexists(dest): return True, '{} does not exist'.format(dest) link_file = mx.TimeStampFile(dest, False) if newestInput and link_file.isOlderThan(newestInput): return True, '{} is older than {}'.format(dest, newestInput) if src != os.readlink(dest): return True, '{} points to the wrong file'.format(dest) return False, None
def _build_aot_images(benchmarks): print('---------------- BEGIN BUILDING AOT IMAGES ----------------') output_dir = mx.join(_suite.get_output_root(), 'bin') mx.ensure_dir_exists(output_dir) for bench_name, bench in benchmarks.items(): witness = mx.TimeStampFile(mx.join(output_dir, bench_name)) if not witness.exists() or witness.isOlderThan(bench.src_file): cmd = [ jdk.aot_image, '-cp', bench.classpath, '-H:Name={}'.format(bench_name), '-H:Class={}'.format(bench.class_file) ] cmd.extend(bench.build_args) print(' '.join(cmd)) mx.run(cmd, cwd=output_dir) print('---------------- END BUILDING AOT IMAGES ----------------')
def _read_cached_testclasses(cachesDir, jar): """ Reads the cached list of test classes in `jar`. :param str cachesDir: directory containing files with cached test lists :return: the cached list of test classes in `jar` or None if the cache doesn't exist or is out of date """ cache = join(cachesDir, basename(jar) + '.testclasses') if exists(cache) and mx.TimeStampFile(cache).isNewerThan(jar): # Only use the cached result if the source jar is older than the cache file try: with open(cache) as fp: return [line.strip() for line in fp.readlines()] except IOError as e: mx.warn('Error reading from ' + cache + ': ' + str(e)) return None
def _build_aot_images(project, benchmarks): print('---------------- BEGIN BUILDING AOT IMAGES ----------------') output_dir = project.output_dir() class_files = {} for bench in benchmarks: bench_class, (bench_src, _) = project.find_classes_with_annotations( None, ['@AOTBench("{}")'.format(bench)]).popitem() class_files[bench] = bench_class witness = mx.TimeStampFile(mx.join(output_dir, bench)) if not witness.exists() or witness.isOlderThan(bench_src): cmd = [ jdk.aot_image, '-cp', '.', '-H:Name={}'.format(bench), '-H:Class={}'.format(bench_class) ] cmd.extend(benchmarks[bench][1]) print(' '.join(cmd)) mx.run(cmd, cwd=output_dir) print('---------------- END BUILDING AOT IMAGES ----------------') return class_files
def _read_cached_testclasses(cachesDir, jar, jdk): """ Reads the cached list of test classes in `jar`. :param str cachesDir: directory containing files with cached test lists :param JDKConfig jdk: the JDK for which the cached list of classes must be found :return: the cached list of test classes in `jar` or None if the cache doesn't exist or is out of date """ jdkVersion = '.jdk' + str(jdk.javaCompliance) cache = join(cachesDir, basename(jar) + jdkVersion + '.testclasses') if exists(cache) and mx.TimeStampFile(cache).isNewerThan(jar): # Only use the cached result if the source jar is older than the cache file try: with open(cache) as fp: return [line.strip() for line in fp.readlines()] except IOError as e: mx.warn('Error reading from ' + cache + ': ' + str(e)) return None
def _netbeansinit_suite(args, suite, refreshOnly=False, buildProcessorJars=True): mxOutputDir = mx.ensure_dir_exists(suite.get_mx_output_dir()) configZip = mx.TimeStampFile(join(mxOutputDir, 'netbeans-config.zip')) configLibsZip = join(mxOutputDir, 'eclipse-config-libs.zip') if refreshOnly and not configZip.exists(): return if mx_ideconfig._check_ide_timestamp(suite, configZip, 'netbeans'): mx.logv('[NetBeans configurations are up to date - skipping]') return files = [] libFiles = [] jdks = set() for p in suite.projects: if not p.isJavaProject(): continue if exists(join(p.dir, 'plugin.xml')): # eclipse plugin project continue includedInDists = [d for d in suite.dists if p in d.archived_deps()] _netbeansinit_project(p, jdks, files, libFiles, includedInDists) mx.log('If using NetBeans:') # http://stackoverflow.com/questions/24720665/cant-resolve-jdk-internal-package mx.log( ' 1. Edit etc/netbeans.conf in your NetBeans installation and modify netbeans_default_options variable to include "-J-DCachingArchiveProvider.disableCtSym=true"' ) mx.log( ' 2. Ensure that the following platform(s) are defined (Tools -> Java Platforms):' ) for jdk in jdks: mx.log(' JDK_' + str(jdk.version)) mx.log( ' 3. Open/create a Project Group for the directory containing the projects (File -> Project Group -> New Group... -> Folder of Projects)' ) mx_ideconfig._zip_files(files, suite.dir, configZip.path) mx_ideconfig._zip_files(libFiles, suite.dir, configLibsZip)
def get_library_as_module(dep, jdk): """ Converts a (modular or non-modular) jar library to a module descriptor. :param Library dep: a library dependency :param JDKConfig jdk: a JDK with a version >= 9 that can be used to describe the module :return: a module descriptor """ assert dep.isLibrary() def is_valid_module_name(name): identRE = re.compile(r"^[A-Za-z][A-Za-z0-9]*$") return all(identRE.match(ident) for ident in name.split('.')) if hasattr(dep, 'moduleName'): moduleName = dep.moduleName else: moduleName = jdk.get_automatic_module_name(dep.path) if not is_valid_module_name(moduleName): mx.abort( "Invalid identifier in automatic module name derived for library {}: {} (path: {})" .format(dep.name, moduleName, dep.path)) dep.moduleName = moduleName modulesDir = mx.ensure_dir_exists( join(mx.primary_suite().get_output_root(), 'modules')) cache = join(modulesDir, moduleName + '.desc') fullpath = dep.get_path(resolve=True) save = False if not exists(cache) or mx.TimeStampFile(fullpath).isNewerThan( cache) or mx.TimeStampFile(__file__).isNewerThan(cache): out = mx.LinesOutputCapture() rc = mx.run([ jdk.java, '--module-path', fullpath, '--describe-module', moduleName ], out=out, err=out, nonZeroIsFatal=False) lines = out.lines if rc != 0: mx.abort( "java --describe-module {} failed. Please verify the moduleName attribute of {}.\n{}" .format(moduleName, dep.name, "\n".join(lines))) save = True else: with open(cache) as fp: lines = fp.read().splitlines() assert lines and lines[0].startswith(moduleName), (dep.name, moduleName, lines) accepted_modifiers = set(['transitive']) requires = {} exports = {} provides = {} uses = set() packages = set() for line in lines[1:]: parts = line.strip().split() assert len(parts) >= 2, '>>>' + line + '<<<' if parts[0:2] == ['qualified', 'exports']: parts = parts[1:] a = parts[0] if a == 'requires': module = parts[1] modifiers = parts[2:] requires[module] = set(m for m in modifiers if m in accepted_modifiers) elif a == 'exports': source = parts[1] if len(parts) > 2: assert parts[2] == 'to' targets = parts[3:] else: targets = [] exports[source] = targets elif a == 'uses': uses.update(parts[1:]) elif a == 'contains': packages.update(parts[1:]) elif a == 'provides': assert len(parts) >= 4 and parts[2] == 'with' service = parts[1] providers = parts[3:] provides.setdefault(service, []).extend(providers) else: mx.abort('Cannot parse module descriptor line: ' + str(parts)) packages.update(exports.keys()) if save: try: with open(cache, 'w') as fp: fp.write('\n'.join(lines) + '\n') except IOError as e: mx.warn('Error writing to ' + cache + ': ' + str(e)) os.remove(cache) return JavaModuleDescriptor(moduleName, exports, requires, uses, provides, packages, jarpath=fullpath)
def build(self): source_dir = self.subject.getSourceDir() output_dir = self.subject.getOutputDir() if not emcc_dir: mx.abort("No EMCC_DIR specified - the source programs will not be compiled to .wasm.") emcc_cmd = os.path.join(emcc_dir, "emcc") gcc_cmd = os.path.join(gcc_dir, "gcc") if mx.run([emcc_cmd, "-v"], nonZeroIsFatal=False) != 0: mx.abort("Could not check the emcc version.") if mx.run([gcc_cmd, "--version"], nonZeroIsFatal=False) != 0: mx.abort("Could not check the gcc version.") if not wabt_dir: mx.abort("Set WABT_DIR if you want the binary to include .wat files.") mx.log("Building files from the source dir: " + source_dir) cc_flags = ["-O3", "-g2"] include_flags = [] disable_test_api_flags = ["-DDISABLE_TEST_API"] if hasattr(self.project, "includeset"): include_flags = ["-I", os.path.join(_suite.dir, "includes", self.project.includeset)] emcc_flags = cc_flags if self.project.isBenchmarkProject(): emcc_flags = emcc_flags + ["-s", "EXPORTED_FUNCTIONS=" + str(benchmark_methods).replace("'", "\"") + ""] subdir_program_names = defaultdict(lambda: []) for root, filename in self.subject.getProgramSources(): subdir = os.path.relpath(root, self.subject.getSourceDir()) mx.ensure_dir_exists(os.path.join(output_dir, subdir)) basename = remove_extension(filename) source_path = os.path.join(root, filename) output_wasm_path = os.path.join(output_dir, subdir, basename + ".wasm") timestampedSource = mx.TimeStampFile(source_path) timestampedOutput = mx.TimeStampFile(output_wasm_path) mustRebuild = timestampedSource.isNewerThan(timestampedOutput) or not timestampedOutput.exists() # Step 1: build the .wasm binary. if mustRebuild: if filename.endswith(".c"): # Step 1a: compile with the JS file, and store as files for running Node, if necessary. output_js_path = os.path.join(output_dir, subdir, basename + ".js") build_cmd_line = [emcc_cmd] + emcc_flags + disable_test_api_flags + [source_path, "-o", output_js_path] + include_flags if mx.run(build_cmd_line, nonZeroIsFatal=False) != 0: mx.abort("Could not build the JS output of " + filename + " with emcc.") if self.subject.isBenchmarkProject(): node_dir = os.path.join(output_dir, subdir, NODE_BENCH_DIR) mx.ensure_dir_exists(node_dir) shutil.copyfile(output_js_path, os.path.join(node_dir, basename + ".js")) shutil.copyfile(output_wasm_path, os.path.join(node_dir, basename + ".wasm")) # Step 1b: extract the relevant information out of the JS file, and record it into an initialization file. init_info = self.extractInitialization(output_js_path) with open(os.path.join(output_dir, subdir, basename + ".init"), "w") as f: f.write(init_info) # Step 1c: compile to just a .wasm file, to avoid name mangling. build_cmd_line = [emcc_cmd] + emcc_flags + ["-s", "ERROR_ON_UNDEFINED_SYMBOLS=0"] + [source_path, "-o", output_wasm_path] + include_flags if mx.run(build_cmd_line, nonZeroIsFatal=False) != 0: mx.abort("Could not build the wasm-only output of " + filename + " with emcc.") elif filename.endswith(".wat"): # Step 1: compile the .wat file to .wasm. wat2wasm_cmd = os.path.join(wabt_dir, "wat2wasm") build_cmd_line = [wat2wasm_cmd, "-o", output_wasm_path, source_path] if mx.run(build_cmd_line, nonZeroIsFatal=False) != 0: mx.abort("Could not translate " + filename + " to binary format.") else: mx.logv("skipping, file is up-to-date: " + source_path) # Step 2: copy the result file if it exists. result_path = os.path.join(root, basename + ".result") if os.path.isfile(result_path): result_output_path = os.path.join(output_dir, subdir, basename + ".result") shutil.copyfile(result_path, result_output_path) # Step 3: copy the opts file if it exists. opts_path = os.path.join(root, basename + ".opts") if os.path.isfile(opts_path): opts_output_path = os.path.join(output_dir, subdir, basename + ".opts") shutil.copyfile(opts_path, opts_output_path) output_wat_path = os.path.join(output_dir, subdir, basename + ".wat") if mustRebuild: if filename.endswith(".c"): # Step 4: produce the .wat files, for easier debugging. wasm2wat_cmd = os.path.join(wabt_dir, "wasm2wat") if mx.run([wasm2wat_cmd, "-o", output_wat_path, output_wasm_path], nonZeroIsFatal=False) != 0: mx.abort("Could not compile .wat file for " + filename) elif filename.endswith(".wat"): # Step 4: copy the .wat file, for easier debugging. wat_path = os.path.join(root, basename + ".wat") shutil.copyfile(wat_path, output_wat_path) # Step 5: if this is a benchmark project, create native binaries too. if mustRebuild: mx.ensure_dir_exists(os.path.join(output_dir, subdir, NATIVE_BENCH_DIR)) if filename.endswith(".c"): output_path = os.path.join(output_dir, subdir, NATIVE_BENCH_DIR, mx.exe_suffix(basename)) link_flags = ["-lm"] gcc_cmd_line = [gcc_cmd] + cc_flags + disable_test_api_flags + [source_path, "-o", output_path] + include_flags + link_flags if mx.run(gcc_cmd_line, nonZeroIsFatal=False) != 0: mx.abort("Could not build the native binary of " + filename + ".") os.chmod(output_path, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR) elif filename.endswith(".wat"): mx.warn("The .wat files are not translated to native binaries: " + filename) # Remember the source name. subdir_program_names[subdir].append(basename) for subdir in subdir_program_names: with open(os.path.join(output_dir, subdir, "wasm_test_index"), "w") as f: for name in subdir_program_names[subdir]: f.write(name) f.write("\n")
def _update_JVMCI_library(): """ Updates the "path" and "sha1" attributes of the "JVMCI" library to refer to a jvmci.jar created from the JVMCI classes in JDK9. """ suiteDict = _suite.suiteDict jvmciLib = suiteDict['libraries']['JVMCI'] d = join(_suite.get_output_root(), abspath(_jdk.home)[1:]) path = join(d, 'jvmci.jar') explodedModule = join(_jdk.home, 'modules', 'jdk.vm.ci') if exists(explodedModule): jarInputs = {} newestJarInput = None for root, _, files in os.walk(explodedModule): relpath = root[len(explodedModule) + 1:] for f in files: arcname = join(relpath, f).replace(os.sep, '/') jarInput = join(root, f) jarInputs[arcname] = jarInput t = mx.TimeStampFile(jarInput) if newestJarInput is None or t.isNewerThan(newestJarInput): newestJarInput = t if not exists(path) or newestJarInput.isNewerThan(path): with mx.Archiver(path, kind='zip') as arc: for arcname, jarInput in jarInputs.iteritems(): with open(jarInput, 'rb') as fp: contents = fp.read() arc.zf.writestr(arcname, contents) else: # Use the jdk.internal.jimage utility since it's the only way # to partially read .jimage files as the JDK9 jimage tool # does not support partial extraction. bootmodules = join(_jdk.home, 'lib', 'modules', 'bootmodules.jimage') if not exists(bootmodules): mx.abort('Could not find JVMCI classes at ' + bootmodules + ' or ' + explodedModule) if not exists(path) or mx.TimeStampFile(bootmodules).isNewerThan(path): mx.ensure_dir_exists(d) javaSource = join(d, 'ExtractJVMCI.java') with open(javaSource, 'w') as fp: print >> fp, """import java.io.FileOutputStream; import java.util.jar.JarEntry; import java.util.jar.JarOutputStream; import jdk.internal.jimage.BasicImageReader; public class ExtractJVMCI { public static void main(String[] args) throws Exception { BasicImageReader image = BasicImageReader.open(args[0]); String[] names = image.getEntryNames(); if (names.length == 0) { return; } try (JarOutputStream jos = new JarOutputStream(new FileOutputStream(args[1]))) { for (String name : names) { if (name.startsWith("/jdk.vm.ci/")) { String ename = name.substring("/jdk.vm.ci/".length()); JarEntry je = new JarEntry(ename); jos.putNextEntry(je); jos.write(image.getResource(name)); jos.closeEntry(); } } } } } """ mx.run([_jdk.javac, '-d', d, javaSource]) mx.run([_jdk.java, '-cp', d, 'ExtractJVMCI', bootmodules, path]) if not exists(path): mx.abort('Could not find the JVMCI classes in ' + bootmodules) jvmciLib['path'] = path jvmciLib['sha1'] = mx.sha1OfFile(path)
def newestOutput(self): return mx.TimeStampFile( native_image_path(self.subject.native_image_root))
def build(self): source_dir = self.subject.getSourceDir() output_dir = self.subject.getOutputDir() if not emcc_dir: mx.abort( "No EMCC_DIR specified - the source programs will not be compiled to .wasm." ) emcc_cmd = os.path.join(emcc_dir, "emcc") gcc_cmd = os.path.join(gcc_dir, "gcc") if mx.run([emcc_cmd, "-v"], nonZeroIsFatal=False) != 0: mx.abort("Could not check the emcc version.") if mx.run([gcc_cmd, "--version"], nonZeroIsFatal=False) != 0: mx.abort("Could not check the gcc version.") if not wabt_dir: mx.abort( "Set WABT_DIR if you want the binary to include .wat files.") mx.log("Building files from the source dir: " + source_dir) cc_flags = ["-g2", "-O3"] include_flags = [] if hasattr(self.project, "includeset"): include_flags = [ "-I", os.path.join(_suite.dir, "includes", self.project.includeset) ] emcc_flags = [ "-s", "EXIT_RUNTIME=1", "-s", "STANDALONE_WASM", "-s", "WASM_BIGINT" ] + cc_flags if self.project.isBenchmarkProject(): emcc_flags = emcc_flags + [ "-s", "EXPORTED_FUNCTIONS=" + str(self.benchmark_methods()).replace("'", "\"") + "" ] subdir_program_names = defaultdict(lambda: []) for root, filename in self.subject.getProgramSources(): if filename.startswith("_"): # Ignore files starting with an underscore continue subdir = os.path.relpath(root, self.subject.getSourceDir()) mx.ensure_dir_exists(os.path.join(output_dir, subdir)) basename = remove_extension(filename) source_path = os.path.join(root, filename) output_wasm_path = os.path.join(output_dir, subdir, basename + ".wasm") output_js_path = os.path.join(output_dir, subdir, basename + ".js") timestampedSource = mx.TimeStampFile(source_path) timestampedOutput = mx.TimeStampFile(output_wasm_path) mustRebuild = timestampedSource.isNewerThan( timestampedOutput) or not timestampedOutput.exists() # Step 1: build the .wasm binary. if mustRebuild: if filename.endswith(".c"): # This generates both a js file and a wasm file. # See https://github.com/emscripten-core/emscripten/wiki/WebAssembly-Standalone build_cmd_line = [emcc_cmd] + emcc_flags + [ source_path, "-o", output_js_path ] + include_flags if mx.run(build_cmd_line, nonZeroIsFatal=False) != 0: mx.abort("Could not build the wasm-only output of " + filename + " with emcc.") elif filename.endswith(".wat"): # Step 1: compile the .wat file to .wasm. wat2wasm_cmd = os.path.join(wabt_dir, "wat2wasm") build_cmd_line = [ wat2wasm_cmd, "-o", output_wasm_path, source_path ] if mx.run(build_cmd_line, nonZeroIsFatal=False) != 0: mx.abort("Could not translate " + filename + " to binary format.") elif filename.endswith(".wasm"): shutil.copyfile(source_path, output_wasm_path) else: mx.logv("skipping, file is up-to-date: " + source_path) # Step 2: copy the result file if it exists. result_path = os.path.join(root, basename + ".result") if os.path.isfile(result_path): result_output_path = os.path.join(output_dir, subdir, basename + ".result") shutil.copyfile(result_path, result_output_path) # Step 3: copy the opts file if it exists. opts_path = os.path.join(root, basename + ".opts") if os.path.isfile(opts_path): opts_output_path = os.path.join(output_dir, subdir, basename + ".opts") shutil.copyfile(opts_path, opts_output_path) output_wat_path = os.path.join(output_dir, subdir, basename + ".wat") if mustRebuild: if filename.endswith(".c"): # Step 4: produce the .wat files, for easier debugging. wasm2wat_cmd = os.path.join(wabt_dir, "wasm2wat") if mx.run([ wasm2wat_cmd, "-o", output_wat_path, output_wasm_path ], nonZeroIsFatal=False) != 0: mx.abort("Could not compile .wat file for " + filename) elif filename.endswith(".wat"): # Step 4: copy the .wat file, for easier debugging. wat_path = os.path.join(root, basename + ".wat") shutil.copyfile(wat_path, output_wat_path) # Step 5: if this is a benchmark project, create native binaries too. if mustRebuild: if filename.endswith(".c"): mx.ensure_dir_exists( os.path.join(output_dir, subdir, NATIVE_BENCH_DIR)) output_path = os.path.join(output_dir, subdir, NATIVE_BENCH_DIR, mx.exe_suffix(basename)) link_flags = ["-lm"] gcc_cmd_line = [gcc_cmd] + cc_flags + [ source_path, "-o", output_path ] + include_flags + link_flags if mx.run(gcc_cmd_line, nonZeroIsFatal=False) != 0: mx.abort("Could not build the native binary of " + filename + ".") os.chmod(output_path, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR) elif filename.endswith(".wat"): mx.warn( "The .wat files are not translated to native binaries: " + filename) # Remember the source name. subdir_program_names[subdir].append(basename) for subdir in subdir_program_names: with open(os.path.join(output_dir, subdir, "wasm_test_index"), "w") as f: for name in subdir_program_names[subdir]: f.write(name) f.write("\n")
def needsBuild(self, newestInput): if sys.platform.startswith('darwin'): return (mx.TimeStampFile(self.launcher).isOlderThan(self.binary), self.launcher) else: return (not exists(self.launcher), self.launcher)
def newestOutput(self): return mx.TimeStampFile(self.subject.image_file())