def rbdiag(args):
'''Diagnoses FastR builtins
-v Verbose output including the list of unimplemented specializations
-n Ignore RNull as an argument type
-m Ignore RMissing as an argument type
--sweep Performs the 'chimney-sweeping'. The sample combination selection method is determined automatically.
--sweep-lite Performs the 'chimney-sweeping'. The diagonal sample selection method is used.
--sweep-total Performs the 'chimney-sweeping'. The total sample selection method is used.
If no builtin is specified, all registered builtins are diagnosed.
Examples:
mx rbdiag
mx rbdiag colSums colMeans -v
mx rbdiag scan -m -n
mx rbdiag colSums --sweep
'''
cp = mx.classpath('com.oracle.truffle.r.nodes.test')
setREnvironment()
os.environ["FASTR_TESTGEN_GNUR"] = "internal"
# this should work for Linux and Mac:
os.environ["TZDIR"] = "/usr/share/zoneinfo/"
mx.run_java(['-cp', cp, 'com.oracle.truffle.r.nodes.test.RBuiltinDiagnostics'] + args)
def _find_classes_by_annotated_methods(annotations, suite):
"""
Scan distributions from binary suite dependencies for classes contain at least one method
with an annotation from 'annotations' and return a dictionary from fully qualified class
names to the distribution containing the class.
"""
binarySuiteDists = [d for d in mx.dependencies(opt_limit_to_suite=True) if d.isJARDistribution() and
isinstance(d.suite, mx.BinarySuite) and (not suite or suite == d.suite)]
if len(binarySuiteDists) != 0:
# Ensure Java support class is built
mx.build(['--dependencies', 'com.oracle.mxtool.junit'])
# Create map from jar file to the binary suite distribution defining it
jars = {d.classpath_repr() : d for d in binarySuiteDists}
cp = mx.classpath(['com.oracle.mxtool.junit'] + [d.name for d in binarySuiteDists])
out = mx.OutputCapture()
mx.run_java(['-cp', cp] + ['com.oracle.mxtool.junit.FindClassesByAnnotatedMethods'] + annotations + jars.keys(), out=out)
candidates = {}
for line in out.data.strip().split('\n'):
name, jar = line.split(' ')
# Record class name to the binary suite distribution containing it
candidates[name] = jars[jar]
return candidates
return {}
def jacocoreport(args):
"""create a JaCoCo coverage report
Creates the report from the 'jacoco.exec' file in the current directory.
Default output directory is 'coverage', but an alternative can be provided as an argument."""
jacocoreport = mx.library("JACOCOREPORT", True)
out = 'coverage'
if len(args) == 1:
out = args[0]
elif len(args) > 1:
mx.abort('jacocoreport takes only one argument : an output directory')
includes = list(_jacoco_includes)
for p in mx.projects():
projsetting = getattr(p, 'jacoco', '')
if projsetting == 'include' or projsetting == '':
includes.append(p.name)
includedirs = set()
for p in mx.projects():
projsetting = getattr(p, 'jacoco', '')
if projsetting == 'exclude':
continue
for include in includes:
if include in p.dir:
includedirs.add(p.dir)
for i in includedirs:
bindir = i + '/bin'
mx.ensure_dir_exists(bindir)
mx.run_java(['-jar', jacocoreport.get_path(True), '--in', 'jacoco.exec', '--out', out] + sorted(includedirs))
def test(args):
"""run some or all of the Maxine tests
The Maxine sources include a variety of tests that can be run by a
special launcher. These include JUnit tests, VM micro tests, certain
benchmark suites and output comparison tests, amongst others.
Use "mx test -help" to see what other options this command accepts."""
maxineTesterDir = join(_maxine_home, 'maxine-tester')
if isdir(maxineTesterDir):
for root, _, files in os.walk(maxineTesterDir):
for name in files:
if name.rsplit(', ', 1) in ['stdout', 'stderr', 'passed', 'failed', 'command']:
os.remove(join(root, name))
else:
os.mkdir(maxineTesterDir)
class Tee:
def __init__(self, f):
self.f = f
def eat(self, line):
mx.log(line.rstrip())
self.f.write(line)
console = join(maxineTesterDir, 'console')
with open(console, 'w', 0) as f:
tee = Tee(f)
java = mx.java()
mx.run_java(['-cp', sanitized_classpath(), 'test.com.sun.max.vm.MaxineTester', '-output-dir=maxine-tester',
'-graal-jar=' + mx.distribution('GRAAL').path,
'-refvm=' + java.java, '-refvm-args=' + ' '.join(java.java_args)] + args, out=tee.eat, err=subprocess.STDOUT)
def sl(args):
"""run an SL program"""
vmArgs, slArgs = mx.extract_VM_args(args)
mx.run_java(
vmArgs
+ ["-cp", mx.classpath(["TRUFFLE_API", "com.oracle.truffle.sl"]), "com.oracle.truffle.sl.SLLanguage"]
+ slArgs
)
def sldebug(args):
"""run a simple command line debugger for the Simple Language"""
vmArgs, slArgs = mx.extract_VM_args(args, useDoubleDash=True)
mx.run_java(
vmArgs
+ ["-cp", mx.classpath("com.oracle.truffle.sl.tools"), "com.oracle.truffle.sl.tools.debug.SLREPL"]
+ slArgs
)
def view(args):
"""browse the boot image under the Inspector
Browse a Maxine boot image under the Inspector.
Use "mx view -help" to see what the Inspector options are."""
mx.run_java(['-cp', mx.classpath(), 'com.sun.max.ins.MaxineInspector', '-vmdir=' + _vmdir, '-mode=image'] + args)
def rbcheck(args):
'''check FastR builtins against GnuR'''
parser = ArgumentParser(prog='mx rbcheck')
parser.add_argument('--check-internal', action='store_const', const='--check-internal', help='check .Internal functions')
parser.add_argument('--unknown-to-gnur', action='store_const', const='--unknown-to-gnur', help='list builtins not in GnuR FUNCTAB')
parser.add_argument('--todo', action='store_const', const='--todo', help='show unimplemented')
parser.add_argument('--no-eval-args', action='store_const', const='--no-eval-args', help='list functions that do not evaluate their args')
parser.add_argument('--visibility', action='store_const', const='--visibility', help='list visibility specification')
parser.add_argument('--printGnuRFunctions', action='store', help='ask GnuR to "print" value of functions')
parser.add_argument('--packageBase', action='store', help='directory to be recursively scanned for R sources (used to get frequencies for builtins)')
parser.add_argument('--interactive', action='store_const', const='--interactive', help='interactive querying of the word frequencies')
args = parser.parse_args(args)
class_map = mx.project('com.oracle.truffle.r.nodes').find_classes_with_matching_source_line(None, lambda line: "@RBuiltin" in line, True)
classes = []
for className, path in class_map.iteritems():
classNameX = className.split("$")[0] if '$' in className else className
if not classNameX.endswith('Factory'):
classes.append([className, path])
class_map = mx.project('com.oracle.truffle.r.nodes.builtin').find_classes_with_matching_source_line(None, lambda line: "@RBuiltin" in line, True)
for className, path in class_map.iteritems():
classNameX = className.split("$")[0] if '$' in className else className
if not classNameX.endswith('Factory'):
classes.append([className, path])
(_, testfile) = tempfile.mkstemp(".classes", "mx")
os.close(_)
with open(testfile, 'w') as f:
for c in classes:
f.write(c[0] + ',' + c[1][0] + '\n')
analyzeArgs = []
if args.check_internal:
analyzeArgs.append(args.check_internal)
if args.unknown_to_gnur:
analyzeArgs.append(args.unknown_to_gnur)
if args.todo:
analyzeArgs.append(args.todo)
if args.no_eval_args:
analyzeArgs.append(args.no_eval_args)
if args.visibility:
analyzeArgs.append(args.visibility)
if args.interactive:
analyzeArgs.append(args.interactive)
if args.printGnuRFunctions:
analyzeArgs.append('--printGnuRFunctions')
analyzeArgs.append(args.printGnuRFunctions)
if args.packageBase:
analyzeArgs.append('--packageBase')
analyzeArgs.append(args.packageBase)
analyzeArgs.append(testfile)
cp = mx.classpath('com.oracle.truffle.r.test')
mx.run_java(['-cp', cp, 'com.oracle.truffle.r.test.tools.AnalyzeRBuiltin'] + analyzeArgs)
def ruby_command(args):
"""runs Ruby"""
vmArgs, rubyArgs = extractArguments(args)
classpath = mx.classpath(['TRUFFLE_API', 'RUBY']).split(':')
truffle_api, classpath = classpath[0], classpath[1:]
assert os.path.basename(truffle_api) == "truffle-api.jar"
vmArgs += ['-Xbootclasspath/p:' + truffle_api]
vmArgs += ['-cp', ':'.join(classpath)]
vmArgs += ['org.jruby.Main', '-X+T']
env = setup_jruby_home()
mx.run_java(vmArgs + rubyArgs, env=env)
def nm(args):
"""print the contents of a boot image
Print the contents of a boot image in a textual form.
If not specified, the following path will be used for the boot image file:
{0}
Use "mx nm -help" to see what other options this command accepts."""
mx.run_java(['-cp', mx.classpath(), 'com.sun.max.vm.hosted.BootImagePrinter'] + args + [join(_vmdir, 'maxine.vm')])
def jol(args):
"""Java Object Layout"""
joljar = mx.library('JOL_INTERNALS').get_path(resolve=True)
candidates = mx.findclass(args, logToConsole=False, matcher=lambda s, classname: s == classname or classname.endswith('.' + s) or classname.endswith('$' + s))
if len(candidates) > 0:
candidates = mx.select_items(sorted(candidates))
else:
# mx.findclass can be mistaken, don't give up yet
candidates = args
mx.run_java(['-javaagent:' + joljar, '-cp', os.pathsep.join([mx.classpath(jdk=mx.get_jdk()), joljar]), "org.openjdk.jol.MainObjectInternals"] + candidates)
def build(self):
antlr4 = None
for lib in _suite.libs:
if lib.name == "ANTLR4_MAIN":
antlr4 = lib
assert antlr4
antlr4jar = antlr4.classpath_repr()
out = join(_suite.dir, self.subject.outputDir)
src = join(_suite.dir, self.subject.sourceDir)
for grammar in self.subject.grammars:
pkg = os.path.dirname(grammar).replace('/', '.')
mx.run_java(['-jar', antlr4jar, '-o', out, '-package', pkg, grammar], cwd=src)
def objecttree(args):
"""print the causality spanning-tree of the object graph in the boot image
The causality spanning-tree allows one to audit the boot image with respect
to why any given object is in the image. This is useful when trying to reduce
the size of the image.
This tool requires an input *.tree file which is produced by specifying the
-tree option when building the boot image.
Use "mx objecttree -help" to see what other options this command accepts."""
mx.run_java(['-cp', mx.classpath(), 'com.sun.max.vm.hosted.BootImageObjectTree', '-in=' + join(_vmdir, 'maxine.object.tree')] + args)
def olc(args):
"""offline compile a list of methods
See Patterns below for a description of the format expected for "patterns..."
The output traced by this command is not guaranteed to be the same as the output
for a compilation performed at runtime. The code produced by a compiler is sensitive
to the compilation context such as what classes have been resolved etc.
Use "mx olc -help" to see what other options this command accepts.
--- Patterns ---
{0}"""
mx.run_java(['-cp', mx.classpath(), 'com.oracle.max.vm.ext.maxri.Compile'] + args)
def verify(args):
"""verifies a set of methods using the Maxine bytecode verifier
Run the Maxine verifier over a set of specified methods available
on the class path. To extend the class path, use one of the global
"--cp-pfx" or "--cp-sfx" options.
See Patterns below for a description of the format expected for "patterns..."
Use "mx verify -help" to see what other options this command accepts.
--- Patterns ---
{0}"""
mx.run_java(['-cp', mx.classpath(), 'test.com.sun.max.vm.verifier.CommandLineVerifier'] + args)
def rbcheck(args):
'''Checks FastR builtins against GnuR
gnur-only: GnuR builtins not implemented in FastR (i.e. TODO list).
fastr-only: FastR builtins not implemented in GnuR
both-diff: implemented in both GnuR and FastR, but with difference
in signature (e.g. visibility)
both: implemented in both GnuR and FastR with matching signature
If the option --filter is not given, shows all groups.
Multiple groups can be combined: e.g. "--filter gnur-only,fastr-only"'''
cp = mx.classpath('com.oracle.truffle.r.test')
args.append("--suite-path")
args.append(mx.primary_suite().dir)
mx.run_java(['-cp', cp, 'com.oracle.truffle.r.test.tools.RBuiltinCheck'] + args)
def _sigtest_generate(args, suite=None, projects=None):
"""run sigtest generator for Java projects with API"""
sigtestlib = mx.library('SIGTEST').get_path(resolve=True)
nonTestProjects = [p for p in mx.projects() if _should_test_project(p)]
if not nonTestProjects:
return 0
javaCompliance = max([p.javaCompliance for p in nonTestProjects])
for p in nonTestProjects:
sigtestResults = p.dir + os.sep + 'snapshot.sigtest'
jdk = mx.get_jdk(javaCompliance)
cmd = [
'-cp',
mx._cygpathU2W(sigtestlib),
'com.sun.tdk.signaturetest.Setup',
'-Static',
'-FileName',
sigtestResults,
'-ClassPath',
mx.classpath(p, jdk=jdk) + os.pathsep + jdk.bootclasspath(),
]
if args.human:
cmd.append('-H')
for pkg in mx._find_packages(p):
cmd = cmd + ['-PackageWithoutSubpackages', pkg]
exitcode = mx.run_java(cmd,
nonZeroIsFatal=False,
jdk=mx.get_jdk(javaCompliance))
if exitcode != 95:
mx.abort('Exit code was ' + str(exitcode) + ' while generating ' +
sigtestResults)
if not exists(sigtestResults):
mx.abort('Cannot generate ' + sigtestResults)
mx.log("Sigtest snapshot generated to " + sigtestResults)
return 0
def runLLVM(args=None, out=None, get_classpath_options=getClasspathOptions):
"""uses Sulong to execute a LLVM IR file"""
vmArgs, sulongArgs = truffle_extract_VM_args(args)
dists = []
if "tools" in (s.name for s in mx.suites()):
dists.append('CHROMEINSPECTOR')
return mx.run_java(getCommonOptions(False) + vmArgs + get_classpath_options(dists) + ["com.oracle.truffle.llvm.launcher.LLVMLauncher"] + sulongArgs, out=out)
def js(args, nonZeroIsFatal=True, out=None, err=None, cwd=None):
"""Run the REPL or a JavaScript program with Graal.js"""
return mx.run_java(graaljs_cmd_line(args),
nonZeroIsFatal=nonZeroIsFatal,
out=out,
err=err,
cwd=cwd)
def runLLVM(args=None, out=None, err=None, timeout=None, nonZeroIsFatal=True, get_classpath_options=getClasspathOptions):
"""run lli via the legacy mx java launcher (instead of via the current GraalVM)"""
vmArgs, sulongArgs = truffle_extract_VM_args(args)
dists = []
if "tools" in (s.name for s in mx.suites()):
dists.append('CHROMEINSPECTOR')
return mx.run_java(getCommonOptions(False) + vmArgs + get_classpath_options(dists) + ["com.oracle.truffle.llvm.launcher.LLVMLauncher"] + sulongArgs, timeout=timeout, nonZeroIsFatal=nonZeroIsFatal, out=out, err=err)
def run_grid_server(args, **kwargs):
vmArgs = mx.get_runtime_jvm_args(['GRID_DEVICE_REMOTE_SERVER'],
jdk=get_default_jdk())
vmArgs.append(
'com.oracle.truffle.r.library.fastrGrid.device.remote.server.RemoteDeviceServer'
)
return mx.run_java(vmArgs + args, jdk=get_default_jdk(), **kwargs)
def runAMD64(args=None, out=None):
"""uses vmx86 to execute a Linux/x86_64 ELF binary"""
vmArgs, vmx86Args = truffle_extract_VM_args(args)
return mx.run_java(
getCommonOptions(False) + vmArgs + getClasspathOptions() +
['org.graalvm.vm.x86.launcher.AMD64Launcher'] + vmx86Args,
out=out)
def runTrcview(args=None, out=None):
"""GUI tool to inspect execution traces"""
vmArgs, trcviewArgs = truffle_extract_VM_args(args)
return mx.run_java(
getCommonOptions(False) + vmArgs + getTrcviewClasspathOptions() +
['org.graalvm.vm.x86.trcview.ui.MainWindow'] + trcviewArgs,
out=out)
def runTrcdump(args=None, out=None):
"""CLI tool to convert binary execution traces to ascii format"""
vmArgs, trcviewArgs = truffle_extract_VM_args(args)
return mx.run_java(getCommonOptions(False) + vmArgs +
getTrcviewClasspathOptions() +
['org.graalvm.vm.x86.trcview.TextDump'] + trcviewArgs,
out=out)
def runTrchk(args=None, out=None):
"""Verify binary execution traces by replaying them on the host CPU"""
vmArgs, trchkArgs = truffle_extract_VM_args(args)
return mx.run_java(getCommonOptions(False) + vmArgs +
getEmu86ClasspathOptions() +
['org.graalvm.vm.x86.emu.Verify86'] + trchkArgs,
out=out)
def rbcheck(args):
'''Checks FastR builtins against GnuR
gnur-only: GnuR builtins not implemented in FastR (i.e. TODO list).
fastr-only: FastR builtins not implemented in GnuR
both-diff: implemented in both GnuR and FastR, but with difference
in signature (e.g. visibility)
both: implemented in both GnuR and FastR with matching signature
If the option --filter is not given, shows all groups.
Multiple groups can be combined: e.g. "--filter gnur-only,fastr-only"'''
vmArgs = mx.get_runtime_jvm_args('com.oracle.truffle.r.test')
args.append("--suite-path")
args.append(mx.primary_suite().dir)
vmArgs += ['com.oracle.truffle.r.test.tools.RBuiltinCheck']
mx.run_java(vmArgs + args)
def runLLVM(args=None, out=None):
"""uses Sulong to execute a LLVM IR file"""
vmArgs, sulongArgs = truffle_extract_VM_args(args)
return mx.run_java(
getCommonOptions(False) + vmArgs + getClasspathOptions() +
["com.oracle.truffle.llvm.launcher.LLVMLauncher"] + sulongArgs,
out=out)
def _run_test_suite(location, library_names, custom_args, default_vm_args, max_heap, stack_size, main_class, nonZeroIsFatal, cwd):
_fetch_test_suite(location, library_names)
_vm_args, _prog_args = parse_js_args(custom_args)
_vm_args = _append_default_js_vm_args(vm_args=_vm_args, max_heap=max_heap, stack_size=stack_size)
_cp = mx.classpath(['TRUFFLE_JS_TESTS'] + (['tools:CHROMEINSPECTOR', 'tools:TRUFFLE_PROFILER'] if mx.suite('tools', fatalIfMissing=False) is not None else []))
_vm_args = ['-ea', '-esa', '-cp', _cp] + default_vm_args + _vm_args
return mx.run_java(_vm_args + [main_class] + _prog_args, nonZeroIsFatal=nonZeroIsFatal, cwd=cwd)
def _junit_r_harness(args, vmArgs, junitArgs):
# always pass the directory where the expected output file should reside
runlistener_arg = 'expected=' + _test_srcdir()
# there should not be any unparsed arguments at this stage
if args.remainder:
mx.abort('unexpected arguments: ' + str(args.remainder).strip('[]') + '; did you forget --tests')
def add_arg_separator():
# can't update in Python 2.7
arg = runlistener_arg
if len(arg) > 0:
arg += ','
return arg
if args.gen_fastr_output:
runlistener_arg = add_arg_separator()
runlistener_arg += 'gen-fastr=' + args.gen_fastr_output
if args.check_expected_output:
args.gen_expected_output = True
runlistener_arg = add_arg_separator()
runlistener_arg += 'check-expected'
if args.gen_expected_output:
runlistener_arg = add_arg_separator()
runlistener_arg += 'gen-expected'
if args.keep_trailing_whitespace:
runlistener_arg = add_arg_separator()
runlistener_arg += 'keep-trailing-whitespace'
if args.gen_expected_quiet:
runlistener_arg = add_arg_separator()
runlistener_arg += 'gen-expected-quiet'
if args.gen_diff_output:
runlistener_arg = add_arg_separator()
runlistener_arg += 'gen-diff=' + args.gen_diff_output
# if args.test_methods:
# runlistener_arg = add_arg_separator()
# runlistener_arg = 'test-methods=' + args.test_methods
# use a custom junit.RunListener
runlistener = 'com.oracle.truffle.r.test.TestBase$RunListener'
if len(runlistener_arg) > 0:
runlistener += ':' + runlistener_arg
junitArgs += ['--runlistener', runlistener]
# on some systems a large Java stack seems necessary
vmArgs += ['-Xss12m']
vmArgs += _graal_options(nocompile=True)
setREnvironment()
jdk = args.jdk
if not jdk:
jdk = get_default_jdk()
vmArgs = _sanitize_vmArgs(jdk, vmArgs)
return mx.run_java(vmArgs + junitArgs, nonZeroIsFatal=False, jdk=jdk)
def do_run_r(args, command, extraVmArgs=None, jdk=None, nonZeroIsFatal=True):
'''
This is the basic function that runs a FastR process, where args have already been parsed.
Args:
args: a list of command arguments
command: e.g. 'R', implicitly defines the entry class (can be None for AOT)
extraVmArgs: additional vm arguments
jdk: jdk (an mx.JDKConfig instance) to use
nonZeroIsFatal: whether to terminate the execution run fails
By default a non-zero return code will cause an mx.abort, unless nonZeroIsFatal=False
The assumption is that the VM is already built and available.
'''
setREnvironment()
if not jdk:
jdk = get_default_jdk()
vmArgs = ['-cp', mx.classpath(_r_command_project)]
vmArgs += _graal_options()
if extraVmArgs is None or not '-da' in extraVmArgs:
# unless explicitly disabled we enable assertion checking
vmArgs += ['-ea', '-esa']
if extraVmArgs:
vmArgs += extraVmArgs
vmArgs = _sanitize_vmArgs(jdk, vmArgs)
if command:
vmArgs.append(_command_class_dict[command.lower()])
return mx.run_java(vmArgs + args, nonZeroIsFatal=nonZeroIsFatal, jdk=jdk)
def jackpot(args, suite=None, nonZeroIsFatal=False):
"""run Jackpot 3.0 against non-test Java projects"""
jackpotHome = mx.get_env('JACKPOT_HOME', None)
if jackpotHome:
jackpotJar = join(jackpotHome, 'jackpot.jar')
else:
jackpotJar = mx.library('JACKPOT').get_path(resolve=True)
assert exists(jackpotJar)
if suite is None:
suite = mx.primary_suite()
nonTestProjects = [p for p in mx.projects() if _should_test_project(p)]
if not nonTestProjects:
return 0
groups = []
for p in nonTestProjects:
javacClasspath = []
deps = []
p.walk_deps(visit=lambda dep, edge: deps.append(dep)
if dep.isLibrary() or dep.isJavaProject() else None)
annotationProcessorOnlyDeps = []
if len(p.annotation_processors()) > 0:
for apDep in p.annotation_processors():
if not apDep in deps:
deps.append(apDep)
annotationProcessorOnlyDeps.append(apDep)
for dep in deps:
if dep == p:
continue
if dep in annotationProcessorOnlyDeps:
continue
javacClasspath.append(dep.classpath_repr(resolve=True))
sourceLevel = min(p.javaCompliance.value, 9)
groups = groups + [
'--group', "--classpath " + mx._separatedCygpathU2W(
_escape_string(os.pathsep.join(javacClasspath))) +
" --source " + str(sourceLevel) + " " +
" ".join([_escape_string(d) for d in p.source_dirs()])
]
cmd = [
'-classpath',
mx._cygpathU2W(jackpotJar),
'org.netbeans.modules.jackpot30.cmdline.Main'
]
cmd = cmd + ['--fail-on-warnings', '--progress'] + args + groups
jdk = mx.get_jdk(mx.JavaCompliance("8"),
cancel='cannot run Jackpot',
purpose="run Jackpot")
if jdk is None:
mx.warn('Skipping Jackpot since JDK 8 is not available')
return 0
else:
return mx.run_java(cmd, nonZeroIsFatal=nonZeroIsFatal, jdk=jdk)
def _junit_r_harness(args, vmArgs, junitArgs):
# always pass the directory where the expected output file should reside
runlistener_arg = 'expected=' + _test_srcdir()
# there should not be any unparsed arguments at this stage
if args.remainder:
mx.abort('unexpected arguments: ' + str(args.remainder).strip('[]') + '; did you forget --tests')
def add_arg_separator():
# can't update in Python 2.7
arg = runlistener_arg
if len(arg) > 0:
arg += ','
return arg
if args.gen_fastr_output:
runlistener_arg = add_arg_separator()
runlistener_arg += 'gen-fastr=' + args.gen_fastr_output
if args.check_expected_output:
args.gen_expected_output = True
runlistener_arg = add_arg_separator()
runlistener_arg += 'check-expected'
if args.gen_expected_output:
runlistener_arg = add_arg_separator()
runlistener_arg += 'gen-expected'
if args.keep_trailing_whitespace:
runlistener_arg = add_arg_separator()
runlistener_arg += 'keep-trailing-whitespace'
if args.gen_expected_quiet:
runlistener_arg = add_arg_separator()
runlistener_arg += 'gen-expected-quiet'
if args.gen_diff_output:
runlistener_arg = add_arg_separator()
runlistener_arg += 'gen-diff=' + args.gen_diff_output
# if args.test_methods:
# runlistener_arg = add_arg_separator()
# runlistener_arg = 'test-methods=' + args.test_methods
# use a custom junit.RunListener
runlistener = 'com.oracle.truffle.r.test.TestBase$RunListener'
if len(runlistener_arg) > 0:
runlistener += ':' + runlistener_arg
junitArgs += ['--runlistener', runlistener]
# suppress Truffle compilation by using a high threshold
vmArgs += ['-Dgraal.TruffleCompilationThreshold=100000']
# on some systems a large Java stack seems necessary
vmArgs += ['-Xss12m']
if _mx_jvmci:
vmArgs += ['-Dgraal.InliningDepthError=500', '-Dgraal.EscapeAnalysisIterations=3', '-XX:JVMCINMethodSizeLimit=1000000', '-Xmx5G']
setREnvironment()
jdk = get_default_jdk()
return mx.run_java(vmArgs + junitArgs, nonZeroIsFatal=False, jdk=jdk)
def do_run_python(args, extra_vm_args=None, env=None, jdk=None, **kwargs):
if not env:
env = os.environ
check_vm_env = env.get('GRAALPYTHON_MUST_USE_GRAAL', False)
if check_vm_env:
if check_vm_env == '1':
check_vm(must_be_jvmci=True)
elif check_vm_env == '0':
check_vm()
dists = ['GRAALPYTHON', 'TRUFFLE_NFI', 'SULONG']
env["PYTHONUSERBASE"] = mx_subst.path_substitutions.substitute(
"<path:PYTHON_USERBASE>")
vm_args, graalpython_args = mx.extract_VM_args(args,
useDoubleDash=True,
defaultAllVMArgs=False)
graalpython_args, additional_dists = _extract_graalpython_internal_options(
graalpython_args)
dists += additional_dists
if mx.suite("sulong-managed", fatalIfMissing=False):
dists.append('SULONG_MANAGED')
# Try eagerly to include tools for convenience when running Python
if not mx.suite("tools", fatalIfMissing=False):
SUITE.import_suite("tools",
version=None,
urlinfos=None,
in_subdir=True)
if mx.suite("tools", fatalIfMissing=False):
if os.path.exists(
mx.suite("tools").dependency("CHROMEINSPECTOR").path):
# CHROMEINSPECTOR was built, put it on the classpath
dists.append('CHROMEINSPECTOR')
graalpython_args.insert(0, "--llvm.enableLVI=true")
else:
mx.logv(
"CHROMEINSPECTOR was not built, not including it automatically"
)
graalpython_args.insert(0, '--experimental-options=true')
graalpython_args.insert(1, '-ensure-capi')
vm_args += mx.get_runtime_jvm_args(dists, jdk=jdk)
if not jdk:
jdk = get_jdk()
# default: assertion checking is enabled
if extra_vm_args is None or '-da' not in extra_vm_args:
vm_args += ['-ea', '-esa']
if extra_vm_args:
vm_args += extra_vm_args
vm_args.append("com.oracle.graal.python.shell.GraalPythonMain")
return mx.run_java(vm_args + graalpython_args, jdk=jdk, env=env, **kwargs)
def objecttree(args):
"""print the causality spanning-tree of the object graph in the boot image
The causality spanning-tree allows one to audit the boot image with respect
to why any given object is in the image. This is useful when trying to reduce
the size of the image.
This tool requires an input *.tree file which is produced by specifying the
-tree option when building the boot image.
Use "mx objecttree -help" to see what other options this command accepts."""
mx.run_java([
'-cp',
mx.classpath(), 'com.sun.max.vm.hosted.BootImageObjectTree', '-in=' +
join(_vmdir, 'maxine.object.tree')
] + args)
def optionsgen(args):
"""(re)generate Java source for Graal Options"""
return mx.run_java([
'-cp',
mx.classpath('com.oracle.max.vm.ext.graal'),
'com.oracle.max.vm.ext.graal.hosted.MaxGraalOptionsGenerator'
])
def hcfdis(args):
"""disassemble HexCodeFiles embedded in text files
Run a tool over the input files to convert all embedded HexCodeFiles
to a disassembled format."""
parser = ArgumentParser(prog='mx hcfdis')
parser.add_argument('-m', '--map', help='address to symbol map applied to disassembler output')
parser.add_argument('files', nargs=REMAINDER, metavar='files...')
args = parser.parse_args(args)
path = mx.library('HCFDIS').get_path(resolve=True)
mx.run_java(['-cp', path, 'com.oracle.max.hcfdis.HexCodeFileDis'] + args.files)
if args.map is not None:
addressRE = re.compile(r'0[xX]([A-Fa-f0-9]+)')
with open(args.map) as fp:
lines = fp.read().splitlines()
symbols = dict()
for l in lines:
addressAndSymbol = l.split(' ', 1)
if len(addressAndSymbol) == 2:
address, symbol = addressAndSymbol
if address.startswith('0x'):
address = long(address, 16)
symbols[address] = symbol
for f in args.files:
with open(f) as fp:
lines = fp.read().splitlines()
updated = False
for i in range(0, len(lines)):
l = lines[i]
for m in addressRE.finditer(l):
sval = m.group(0)
val = long(sval, 16)
sym = symbols.get(val)
if sym:
l = l.replace(sval, sym)
updated = True
lines[i] = l
if updated:
mx.log('updating ' + f)
with open('new_' + f, "w") as fp:
for l in lines:
print >> fp, l
def _find_classes_by_annotated_methods(annotations, dists, jdk=None):
if len(dists) == 0:
return {}
candidates = {}
# Create map from jar file to the binary suite distribution defining it
jarsToDists = {d.classpath_repr(): d for d in dists}
primarySuite = mx.primary_suite()
cachesDir = None
jarsToParse = []
if primarySuite and primarySuite != mx._mx_suite:
cachesDir = mx.ensure_dir_exists(
join(primarySuite.get_output_root(), 'unittest'))
for d in dists:
jar = d.classpath_repr()
testclasses = _read_cached_testclasses(cachesDir, jar)
if testclasses is not None:
for classname in testclasses:
candidates[classname] = jarsToDists[jar]
else:
jarsToParse.append(jar)
if jarsToParse:
# Ensure Java support class is built
mx.build(['--no-daemon', '--dependencies', 'com.oracle.mxtool.junit'])
cp = mx.classpath(['com.oracle.mxtool.junit'] + jarsToDists.values(),
jdk=jdk)
out = mx.LinesOutputCapture()
mx.run_java([
'-cp', cp, 'com.oracle.mxtool.junit.FindClassesByAnnotatedMethods'
] + annotations + jarsToParse,
out=out,
addDefaultArgs=False)
for line in out.lines:
parts = line.split(' ')
jar = parts[0]
testclasses = parts[1:] if len(parts) > 1 else []
if cachesDir:
_write_cached_testclasses(cachesDir, jar, testclasses)
for classname in testclasses:
candidates[classname] = jarsToDists[jar]
return candidates
def t1xgen(args):
"""(re)generate content in T1XTemplateSource.java
Run T1XTemplateGenerator.java to generate the auto-generated templates in T1XTemplateSource.java.
The exit code is non-zero if the auto-generated part of T1XTemplateSource.java was modified."""
return mx.run_java(['-cp', mx.classpath('com.oracle.max.vm.ext.t1x'), 'com.oracle.max.vm.ext.t1x.T1XTemplateGenerator'])
def loggen(args):
"""(re)generate Java source for VMLogger interfaces
Run VMLoggerGenerator.java to update the Auto implementations of @VMLoggerInterface interfaces.
The exit code is non-zero if a Java source file was modified."""
return mx.run_java(['-cp', mx.classpath('com.oracle.max.vm'), 'com.sun.max.vm.log.hosted.VMLoggerGenerator'])
def nashorn(args, nonZeroIsFatal=True, out=None, err=None, cwd=None):
"""Run the REPL or a JavaScript program with Nashorn"""
return mx.run_java(_js_cmd_line(args,
main_class='jdk.nashorn.tools.Shell'),
nonZeroIsFatal=nonZeroIsFatal,
out=out,
err=err,
cwd=cwd)
def hcfdis(args):
"""disassemble HexCodeFiles embedded in text files
Run a tool over the input files to convert all embedded HexCodeFiles
to a disassembled format."""
parser = ArgumentParser(prog='mx hcfdis')
parser.add_argument('-m', '--map', help='address to symbol map applied to disassembler output')
parser.add_argument('files', nargs=REMAINDER, metavar='files...')
args = parser.parse_args(args)
path = mx.library('HCFDIS').get_path(resolve=True)
mx.run_java(['-cp', path, 'com.oracle.max.hcfdis.HexCodeFileDis'] + args.files)
if args.map is not None:
addressRE = re.compile(r'0[xX]([A-Fa-f0-9]+)')
with open(args.map) as fp:
lines = fp.read().splitlines()
symbols = dict()
for l in lines:
addressAndSymbol = l.split(' ', 1)
if len(addressAndSymbol) == 2:
address, symbol = addressAndSymbol
if address.startswith('0x'):
address = long(address, 16)
symbols[address] = symbol
for f in args.files:
with open(f) as fp:
lines = fp.read().splitlines()
updated = False
for i in range(0, len(lines)):
l = lines[i]
for m in addressRE.finditer(l):
sval = m.group(0)
val = long(sval, 16)
sym = symbols.get(val)
if sym:
l = l.replace(sval, sym)
updated = True
lines[i] = l
if updated:
mx.log('updating ' + f)
with open('new_' + f, "w") as fp:
for l in lines:
print >> fp, l
def loggen(args):
"""(re)generate Java source for VMLogger interfaces
Run VMLoggerGenerator.java to update the Auto implementations of @VMLoggerInterface interfaces.
The exit code is non-zero if a Java source file was modified."""
return mx.run_java(['-cp', mx.classpath('com.oracle.max.vm'), 'com.sun.max.vm.log.hosted.VMLoggerGenerator'])
def rbdiag(args):
'''Diagnoses FastR builtins
-v Verbose output including the list of unimplemented specializations
-n Ignore RNull as an argument type
-m Ignore RMissing as an argument type
If no builtin is specified, all registered builtins are diagnosed.
Examples:
mx rbdiag
mx rbdiag colSums colMeans -v
mx rbdiag scan -m -n
'''
cp = mx.classpath('com.oracle.truffle.r.nodes.test')
mx.run_java(['-cp', cp, 'com.oracle.truffle.r.nodes.test.RBuiltinDiagnostics'] + args)
def t1xgen(args):
"""(re)generate content in T1XTemplateSource.java
Run T1XTemplateGenerator.java to generate the auto-generated templates in T1XTemplateSource.java.
The exit code is non-zero if the auto-generated part of T1XTemplateSource.java was modified."""
return mx.run_java(['-cp', mx.classpath('com.oracle.max.vm.ext.t1x'), 'com.oracle.max.vm.ext.t1x.T1XTemplateGenerator'])
def jackpot(args, suite=None, nonZeroIsFatal=False):
"""run Jackpot 11.1 against non-test Java projects"""
jackpotHome = mx.get_env('JACKPOT_HOME', None)
if jackpotHome:
jackpotJar = join(jackpotHome, 'jackpot.jar')
else:
jackpotJar = mx.library('JACKPOT').get_path(resolve=True)
assert exists(jackpotJar)
if suite is None:
suite = mx.primary_suite()
nonTestProjects = [p for p in mx.projects() if _should_test_project(p)]
if not nonTestProjects:
return 0
groups = []
for p in nonTestProjects:
javacClasspath = []
deps = []
p.walk_deps(visit=lambda dep, edge: deps.append(dep) if dep.isLibrary() or dep.isJavaProject() else None)
annotationProcessorOnlyDeps = []
if len(p.annotation_processors()) > 0:
for apDep in p.annotation_processors():
if not apDep in deps:
deps.append(apDep)
annotationProcessorOnlyDeps.append(apDep)
for dep in deps:
if dep == p:
continue
if dep in annotationProcessorOnlyDeps:
continue
javacClasspath.append(dep.classpath_repr(resolve=True))
sourceLevel = min(p.javaCompliance.value, 9)
groups = groups + ['--group', "--classpath " + mx._separatedCygpathU2W(_escape_string(os.pathsep.join(javacClasspath))) + " --source " + str(sourceLevel) + " " + " ".join([_escape_string(d) for d in p.source_dirs()])]
cmd = ['--add-exports=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED', '--add-opens=java.base/java.net=ALL-UNNAMED', '--add-opens=java.desktop/sun.awt=ALL-UNNAMED']
cmd = cmd + ['-classpath', mx._cygpathU2W(jackpotJar), 'org.netbeans.modules.jackpot30.cmdline.Main']
jackCmd = ['--fail-on-warnings', '--progress'] + args + groups
jdk = mx.get_jdk(mx.JavaCompliance("11+"), cancel='cannot run Jackpot', purpose="run Jackpot")
if jdk is None:
mx.warn('Skipping Jackpot since JDK 11+ is not available')
return 0
else:
with tempfile.NamedTemporaryFile(mode='w', suffix='.jackpot') as f:
for c in jackCmd:
print(c, file=f)
f.flush()
ret = mx.run_java(cmd + ['@' + f.name], nonZeroIsFatal=nonZeroIsFatal, jdk=jdk)
if ret != 0:
mx.warn('To simulate the failure execute `mx -p {0} jackpot`.'.format(suite.dir))
mx.warn('To fix the error automatically try `mx -p {0} jackpot --apply`'.format(suite.dir))
return ret
def webserver(args):
"""start or bundle a simple webserver with a web site"""
parser = ArgumentParser(
prog='mx webserver',
description='Start a webserver to serve the site at root or '
'bundle the site along with the server into an executable jar.')
parser.add_argument(
'-a',
'--archive',
help=
'instead of starting the server, create an executable jar in <path> '
'containing the server and the site at root such that `java -jar <path>` will start a server '
'for the site and open a browser at its root.',
metavar='<path>')
parser.add_argument('-p',
'--port',
help='local port on which the server should listen',
metavar='<num>')
parser.add_argument(
'--no-browse',
help='do not open default web browser on the served site',
action='store_true')
parser.add_argument('root', metavar='root')
args = parser.parse_args(args)
project = 'com.oracle.mxtool.webserver'
mainClass = project + '.WebServer'
mx.build(['--no-daemon', '--dependencies', project])
coreCp = mx.classpath([project])
jdk = mx.get_jdk(tag='default')
java_args = mx.get_runtime_jvm_args(project, coreCp, jdk=jdk)
java_args += [mainClass]
if args.archive:
java_args.append('--archive=' + args.archive)
if args.port:
java_args.append('--port=' + args.port)
if args.no_browse:
java_args.append('--no-browse')
java_args.append(args.root)
mx.run_java(java_args, jdk=jdk)
def runLLVM(args=None):
"""uses Sulong to execute a LLVM IR file"""
vmArgs, sulongArgs = truffle_extract_VM_args(args)
return mx.run_java(getCommonOptions() + vmArgs + [
'-XX:-UseJVMCIClassLoader', '-cp',
mx.classpath(['com.oracle.truffle.llvm']),
"com.oracle.truffle.llvm.LLVM"
] + sulongArgs,
jdk=mx.get_jdk(tag='jvmci'))
def runPlainAST(args=None,
out=None,
get_classpath_options=getClasspathOptions):
dists = ["TruffleCourse"]
return mx.run_java(get_classpath_options(dists) +
["-XX:+EnableJVMCI", "-XX:+UseJVMCICompiler"] + args +
["org.truffle.cs.samples.PlainAST.PlainAST"],
out=out,
jdk=mx.get_jdk())
def olc(args):
"""offline compile a list of methods
See Patterns below for a description of the format expected for "patterns..."
The output traced by this command is not guaranteed to be the same as the output
for a compilation performed at runtime. The code produced by a compiler is sensitive
to the compilation context such as what classes have been resolved etc.
Use "mx olc -help" to see what other options this command accepts.
--- Patterns ---
{0}"""
mx.run_java([
'-ea', '-esa', '-cp',
mx.classpath(), 'com.oracle.max.vm.ext.maxri.Compile'
] + args)
def create_parser(grammar_project, grammar_package, grammar_name, copyright_template, args=None, out=None):
"""create the DSL expression parser using antlr"""
grammar_dir = mx.project(grammar_project).source_dirs()[0] + "/" + grammar_package.replace(".", "/") + "/"
mx.run_java(mx.get_runtime_jvm_args(['ANTLR4_COMPLETE']) + ["org.antlr.v4.Tool", "-package", grammar_package, "-no-listener"] + args + [grammar_dir + grammar_name + ".g4"], out=out)
for filename in [grammar_dir + grammar_name + "Lexer.java", grammar_dir + grammar_name + "Parser.java"]:
with open(filename, 'r') as content_file:
content = content_file.read()
# remove first line
content = "\n".join(content.split("\n")[1:])
# modify SuppressWarnings to remove useless entries
content = PTRN_SUPPRESS_WARNINGS.sub('@SuppressWarnings("all")', content)
# remove useless casts
content = PTRN_LOCALCTXT_CAST.sub('_localctx', content)
content = PTRN_TOKEN_CAST.sub('_errHandler.recoverInline(this)', content)
# add copyright header
content = copyright_template.format(content)
with open(filename, 'w') as content_file:
content_file.write(content)
def verify(args):
"""verifies a set of methods using the Maxine bytecode verifier
Run the Maxine verifier over a set of specified methods available
on the class path. To extend the class path, use one of the global
"--cp-pfx" or "--cp-sfx" options.
See Patterns below for a description of the format expected for "patterns..."
Use "mx verify -help" to see what other options this command accepts.
--- Patterns ---
{0}"""
mx.run_java([
'-cp',
mx.classpath(), 'test.com.sun.max.vm.verifier.CommandLineVerifier'
] + args)
def create_parser(grammar_project, grammar_package, grammar_name, copyright_template, args=None, out=None):
"""create the DSL expression parser using antlr"""
grammar_dir = os.path.join(mx.project(grammar_project).source_dirs()[0], *grammar_package.split(".")) + os.path.sep
mx.run_java(mx.get_runtime_jvm_args(['ANTLR4_COMPLETE']) + ["org.antlr.v4.Tool", "-package", grammar_package, "-no-listener"] + args + [grammar_dir + grammar_name + ".g4"], out=out)
for filename in [grammar_dir + grammar_name + "Lexer.java", grammar_dir + grammar_name + "Parser.java"]:
with open(filename, 'r') as content_file:
content = content_file.read()
# remove first line
content = "\n".join(content.split("\n")[1:])
# modify SuppressWarnings to remove useless entries
content = PTRN_SUPPRESS_WARNINGS.sub('@SuppressWarnings("all")', content)
# remove useless casts
content = PTRN_LOCALCTXT_CAST.sub('_localctx', content)
content = PTRN_TOKEN_CAST.sub('_errHandler.recoverInline(this)', content)
# add copyright header
content = copyright_template.format(content)
with open(filename, 'w') as content_file:
content_file.write(content)
def findbugs(args, fbArgs=None, suite=None, projects=None):
"""run FindBugs against non-test Java projects"""
findBugsHome = mx.get_env('FINDBUGS_HOME', None)
if suite is None:
suite = mx._primary_suite
if findBugsHome:
findbugsJar = join(findBugsHome, 'lib', 'findbugs.jar')
else:
findbugsLib = join(mx._mx_suite.get_output_root(), 'findbugs-3.0.0')
if not exists(findbugsLib):
tmp = tempfile.mkdtemp(prefix='findbugs-download-tmp',
dir=mx._mx_suite.dir)
try:
findbugsDist = mx.library('FINDBUGS_DIST').get_path(
resolve=True)
with zipfile.ZipFile(findbugsDist) as zf:
candidates = [
e for e in zf.namelist()
if e.endswith('/lib/findbugs.jar')
]
assert len(candidates) == 1, candidates
libDirInZip = os.path.dirname(candidates[0])
zf.extractall(tmp)
shutil.copytree(join(tmp, libDirInZip), findbugsLib)
finally:
shutil.rmtree(tmp)
findbugsJar = join(findbugsLib, 'findbugs.jar')
assert exists(findbugsJar)
nonTestProjects = [p for p in mx.projects() if _should_test_project(p)]
if not nonTestProjects:
return 0
outputDirs = map(mx._cygpathU2W, [p.output_dir() for p in nonTestProjects])
javaCompliance = max([p.javaCompliance for p in nonTestProjects])
jdk = mx.get_jdk(javaCompliance)
if jdk.javaCompliance >= "1.9":
mx.log('FindBugs does not yet support JDK9 - skipping')
return 0
findbugsResults = join(suite.dir, 'findbugs.results')
if fbArgs is None:
fbArgs = defaultFindbugsArgs()
cmd = ['-jar', mx._cygpathU2W(findbugsJar)] + fbArgs
cmd = cmd + [
'-auxclasspath',
mx._separatedCygpathU2W(
mx.classpath([p.name
for p in nonTestProjects], jdk=jdk)), '-output',
mx._cygpathU2W(findbugsResults), '-exitcode'
] + args + outputDirs
exitcode = mx.run_java(cmd, nonZeroIsFatal=False, jdk=jdk)
if exitcode != 0:
with open(findbugsResults) as fp:
mx.log(fp.read())
os.unlink(findbugsResults)
return exitcode
def do_run_python(args, extra_vm_args=None, env=None, jdk=None, **kwargs):
if not env:
env = os.environ
check_vm_env = env.get('GRAALPYTHON_MUST_USE_GRAAL', False)
if check_vm_env:
if check_vm_env == '1':
check_vm(must_be_jvmci=True)
elif check_vm_env == '0':
check_vm()
dists = ['GRAALPYTHON']
vm_args, graalpython_args = mx.extract_VM_args(args, useDoubleDash=True, defaultAllVMArgs=False)
internal_graalpython_args, graalpython_args, additional_dists = _extract_graalpython_internal_options(graalpython_args)
dists += additional_dists
if '--python.WithJavaStacktrace' not in graalpython_args:
graalpython_args.insert(0, '--python.WithJavaStacktrace')
if _sulong:
dists.append('SULONG')
if mx.suite("sulong-managed", fatalIfMissing=False):
dists.append('SULONG_MANAGED')
vm_args.append(mx_subst.path_substitutions.substitute('-Dpolyglot.llvm.libraryPath=<path:SULONG_LIBS>:<path:SULONG_MANAGED_LIBS>'))
else:
vm_args.append(mx_subst.path_substitutions.substitute('-Dpolyglot.llvm.libraryPath=<path:SULONG_LIBS>'))
# Try eagerly to include tools on Tim's computer
if not mx.suite("/tools", fatalIfMissing=False):
def _is_user(user, home=None):
if home:
return os.environ.get("USER") == user and os.environ.get(home)
return os.environ.get("USER") == user
if _is_user("tim", "MAGLEV_HOME") or _is_user("cbasca") or _is_user("fa"):
_suite.import_suite("tools", version=None, urlinfos=None, in_subdir=True)
dists.append('CHROMEINSPECTOR')
if _sulong:
vm_args.append("-Dpolyglot.llvm.enableLVI=true")
vm_args += mx.get_runtime_jvm_args(dists, jdk=jdk)
vm_args += internal_graalpython_args
if not jdk:
jdk = get_jdk()
# default: assertion checking is enabled
if extra_vm_args is None or '-da' not in extra_vm_args:
vm_args += ['-ea', '-esa']
if extra_vm_args:
vm_args += extra_vm_args
vm_args.append("com.oracle.graal.python.shell.GraalPythonMain")
return mx.run_java(vm_args + graalpython_args, jdk=jdk, **kwargs)
def jnigen(args):
"""(re)generate Java source for native function interfaces (i.e. JNI, JMM, VM)
Run JniFunctionsGenerator.java to update the methods in [Jni|JMM|VM]Functions.java
by adding a prologue and epilogue to the @VM_ENTRY_POINT annotated methods in
[Jni|JMM|VM]FunctionsSource.java.
The exit code is non-zero if a Java source file was modified."""
return mx.run_java(['-cp', mx.classpath('com.oracle.max.vm'), 'com.sun.max.vm.jni.JniFunctionsGenerator'])
def jvmtigen(args):
"""(re)generate Java source for JVMTI native function interfaces
Run JniFunctionsGenerator.java to update the methods in JVMTIFunctions.java
by adding a prologue and epilogue to the @VM_ENTRY_POINT annotated methods in
JVMTIFunctionsSource.java.
The exit code is non-zero if a Java source file was modified."""
return mx.run_java(['-cp', mx.classpath('com.oracle.max.vm.ext.jvmti'), 'com.sun.max.vm.ext.jvmti.JVMTIFunctionsGenerator'])
def runLLVM(args=None, out=None):
"""uses Sulong to execute a LLVM IR file"""
vmArgs, sulongArgsWithLibs = truffle_extract_VM_args(args)
sulongArgs = []
libNames = []
for arg in sulongArgsWithLibs:
if arg.startswith('-l'):
libNames.append(arg)
else:
sulongArgs.append(arg)
return mx.run_java(getCommonOptions(libNames) + vmArgs + getClasspathOptions() + ['-XX:-UseJVMCIClassLoader', "com.oracle.truffle.llvm.LLVM"] + sulongArgs, out=out, jdk=mx.get_jdk(tag='jvmci'))
def rcmplib(args):
'''compare FastR library R sources against GnuR'''
parser = ArgumentParser(prog='mx rcmplib')
parser.add_argument('--gnurhome', action='store', help='path to GnuR sources', required=True)
parser.add_argument('--package', action='store', help='package to check', default="base")
parser.add_argument('--paths', action='store_true', help='print full paths of files that differ')
parser.add_argument('--diffapp', action='store', help='diff application', default="diff")
args = parser.parse_args(args)
cmpArgs = []
cmpArgs.append("--gnurhome")
cmpArgs.append(args.gnurhome)
cmpArgs.append("--package")
cmpArgs.append(args.package)
if args.paths:
cmpArgs.append("--paths")
cmpArgs.append("--diffapp")
cmpArgs.append(args.diffapp)
cp = mx.classpath([pcp.name for pcp in mx.projects_opt_limit_to_suites()])
mx.run_java(['-cp', cp, 'com.oracle.truffle.r.test.tools.cmpr.CompareLibR'] + cmpArgs)
def _find_classes_by_annotated_methods(annotations, dists, jdk=None):
if len(dists) == 0:
return {}
candidates = {}
# Create map from jar file to the binary suite distribution defining it
jarsToDists = {d.classpath_repr(): d for d in dists}
primarySuite = mx.primary_suite()
cachesDir = None
jarsToParse = []
if primarySuite and primarySuite != mx._mx_suite:
cachesDir = mx.ensure_dir_exists(join(primarySuite.get_output_root(), 'unittest'))
for d in dists:
jar = d.classpath_repr()
testclasses = _read_cached_testclasses(cachesDir, jar)
if testclasses is not None:
for classname in testclasses:
candidates[classname] = jarsToDists[jar]
else:
jarsToParse.append(jar)
if jarsToParse:
# Ensure Java support class is built
mx.build(['--no-daemon', '--dependencies', 'com.oracle.mxtool.junit'])
cp = mx.classpath(['com.oracle.mxtool.junit'] + jarsToDists.values(), jdk=jdk)
out = mx.LinesOutputCapture()
mx.run_java(['-cp', cp, 'com.oracle.mxtool.junit.FindClassesByAnnotatedMethods'] + annotations + jarsToParse, out=out, addDefaultArgs=False)
for line in out.lines:
parts = line.split(' ')
jar = parts[0]
testclasses = parts[1:] if len(parts) > 1 else []
if cachesDir:
_write_cached_testclasses(cachesDir, jar, testclasses)
for classname in testclasses:
candidates[classname] = jarsToDists[jar]
return candidates
def _sigtest_check(checktype, args, suite=None, projects=None):
"""run sigtest against Java projects with API"""
sigtestlib = mx.library('SIGTEST').get_path(resolve=True)
nonTestProjects = [p for p in mx.projects() if _should_test_project(p)]
if not nonTestProjects:
return 1
javaCompliance = max([p.javaCompliance for p in nonTestProjects])
class OutputCapture:
def __init__(self):
self.data = ""
def __call__(self, data):
self.data += data
failed = None
for p in nonTestProjects:
sigtestResults = p.dir + os.sep + 'snapshot.sigtest'
if not os.path.exists(sigtestResults):
continue
jdk = mx.get_jdk(javaCompliance)
cmd = ['-cp', mx._cygpathU2W(sigtestlib), 'com.sun.tdk.signaturetest.SignatureTest',
'-Static', '-Mode', 'bin', '-FileName', sigtestResults,
'-ClassPath', mx.classpath(p, jdk=jdk) + os.pathsep + jdk.bootclasspath(),
]
if checktype != 'all':
cmd.append('-b')
for pkg in mx._find_packages(p):
cmd = cmd + ['-PackageWithoutSubpackages', pkg]
out = OutputCapture()
print 'Checking ' + checktype + ' signature changes against ' + sigtestResults
exitcode = mx.run_java(cmd, nonZeroIsFatal=False, jdk=mx.get_jdk(javaCompliance), out=out, err=out)
mx.ensure_dir_exists(p.get_output_root())
with open(p.get_output_root() + os.path.sep + 'sigtest-junit.xml', 'w') as f:
f.write('<?xml version="1.0" encoding="UTF-8" ?>\n')
f.write('<testsuite tests="1" name="' + p.name + '.sigtest.' + checktype + '">\n')
f.write('<testcase classname="' + p.name + '" name="sigtest.' + checktype + '">\n')
if exitcode != 95:
print out.data
failed = sigtestResults
f.write('<failure type="SignatureCheck"><![CDATA[\n')
f.write(out.data)
f.write(']]></failure>')
else:
f.write('<system-err><![CDATA[\n')
f.write(out.data)
f.write(']]></system-err>')
f.write('</testcase>\n')
f.write('</testsuite>\n')
if failed:
mx.abort('Signature error in ' + failed)
else:
print 'OK.'
return 0