1767 lines
62 KiB
Rust
1767 lines
62 KiB
Rust
// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
|
|
// file at the top-level directory of this distribution and at
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
use self::TargetLocation::*;
|
|
|
|
use common::Config;
|
|
use common::{CompileFail, Pretty, RunFail, RunPass, RunPassValgrind, DebugInfoGdb};
|
|
use common::{Codegen, DebugInfoLldb};
|
|
use errors;
|
|
use header::TestProps;
|
|
use header;
|
|
use procsrv;
|
|
use util::logv;
|
|
#[cfg(target_os = "windows")]
|
|
use util;
|
|
|
|
#[cfg(target_os = "windows")]
|
|
use std::ascii::AsciiExt;
|
|
use std::old_io::File;
|
|
use std::old_io::fs::PathExtensions;
|
|
use std::old_io::fs;
|
|
use std::old_io::net::tcp;
|
|
use std::old_io::process::ProcessExit;
|
|
use std::old_io::process;
|
|
use std::old_io::timer;
|
|
use std::old_io;
|
|
use std::os;
|
|
use std::iter::repeat;
|
|
use std::str;
|
|
use std::string::String;
|
|
use std::thread::Thread;
|
|
use std::time::Duration;
|
|
use test::MetricMap;
|
|
|
|
pub fn run(config: Config, testfile: String) {
|
|
match config.target.as_slice() {
|
|
|
|
"arm-linux-androideabi" => {
|
|
if !config.adb_device_status {
|
|
panic!("android device not available");
|
|
}
|
|
}
|
|
|
|
_=> { }
|
|
}
|
|
|
|
let mut _mm = MetricMap::new();
|
|
run_metrics(config, testfile, &mut _mm);
|
|
}
|
|
|
|
pub fn run_metrics(config: Config, testfile: String, mm: &mut MetricMap) {
|
|
if config.verbose {
|
|
// We're going to be dumping a lot of info. Start on a new line.
|
|
print!("\n\n");
|
|
}
|
|
let testfile = Path::new(testfile);
|
|
debug!("running {:?}", testfile.display());
|
|
let props = header::load_props(&testfile);
|
|
debug!("loaded props");
|
|
match config.mode {
|
|
CompileFail => run_cfail_test(&config, &props, &testfile),
|
|
RunFail => run_rfail_test(&config, &props, &testfile),
|
|
RunPass => run_rpass_test(&config, &props, &testfile),
|
|
RunPassValgrind => run_valgrind_test(&config, &props, &testfile),
|
|
Pretty => run_pretty_test(&config, &props, &testfile),
|
|
DebugInfoGdb => run_debuginfo_gdb_test(&config, &props, &testfile),
|
|
DebugInfoLldb => run_debuginfo_lldb_test(&config, &props, &testfile),
|
|
Codegen => run_codegen_test(&config, &props, &testfile, mm),
|
|
}
|
|
}
|
|
|
|
fn get_output(props: &TestProps, proc_res: &ProcRes) -> String {
|
|
if props.check_stdout {
|
|
format!("{}{}", proc_res.stdout, proc_res.stderr)
|
|
} else {
|
|
proc_res.stderr.clone()
|
|
}
|
|
}
|
|
|
|
fn run_cfail_test(config: &Config, props: &TestProps, testfile: &Path) {
|
|
let proc_res = compile_test(config, props, testfile);
|
|
|
|
if proc_res.status.success() {
|
|
fatal_proc_rec("compile-fail test compiled successfully!",
|
|
&proc_res);
|
|
}
|
|
|
|
check_correct_failure_status(&proc_res);
|
|
|
|
if proc_res.status.success() {
|
|
fatal("process did not return an error status");
|
|
}
|
|
|
|
let output_to_check = get_output(props, &proc_res);
|
|
let expected_errors = errors::load_errors(testfile);
|
|
if !expected_errors.is_empty() {
|
|
if !props.error_patterns.is_empty() {
|
|
fatal("both error pattern and expected errors specified");
|
|
}
|
|
check_expected_errors(expected_errors, testfile, &proc_res);
|
|
} else {
|
|
check_error_patterns(props, testfile, output_to_check.as_slice(), &proc_res);
|
|
}
|
|
check_no_compiler_crash(&proc_res);
|
|
check_forbid_output(props, output_to_check.as_slice(), &proc_res);
|
|
}
|
|
|
|
fn run_rfail_test(config: &Config, props: &TestProps, testfile: &Path) {
|
|
let proc_res = if !config.jit {
|
|
let proc_res = compile_test(config, props, testfile);
|
|
|
|
if !proc_res.status.success() {
|
|
fatal_proc_rec("compilation failed!", &proc_res);
|
|
}
|
|
|
|
exec_compiled_test(config, props, testfile)
|
|
} else {
|
|
jit_test(config, props, testfile)
|
|
};
|
|
|
|
// The value our Makefile configures valgrind to return on failure
|
|
static VALGRIND_ERR: int = 100;
|
|
if proc_res.status.matches_exit_status(VALGRIND_ERR) {
|
|
fatal_proc_rec("run-fail test isn't valgrind-clean!", &proc_res);
|
|
}
|
|
|
|
let output_to_check = get_output(props, &proc_res);
|
|
check_correct_failure_status(&proc_res);
|
|
check_error_patterns(props, testfile, output_to_check.as_slice(), &proc_res);
|
|
}
|
|
|
|
fn check_correct_failure_status(proc_res: &ProcRes) {
|
|
// The value the rust runtime returns on failure
|
|
static RUST_ERR: int = 101;
|
|
if !proc_res.status.matches_exit_status(RUST_ERR) {
|
|
fatal_proc_rec(
|
|
format!("failure produced the wrong error: {:?}",
|
|
proc_res.status).as_slice(),
|
|
proc_res);
|
|
}
|
|
}
|
|
|
|
fn run_rpass_test(config: &Config, props: &TestProps, testfile: &Path) {
|
|
if !config.jit {
|
|
let mut proc_res = compile_test(config, props, testfile);
|
|
|
|
if !proc_res.status.success() {
|
|
fatal_proc_rec("compilation failed!", &proc_res);
|
|
}
|
|
|
|
proc_res = exec_compiled_test(config, props, testfile);
|
|
|
|
if !proc_res.status.success() {
|
|
fatal_proc_rec("test run failed!", &proc_res);
|
|
}
|
|
} else {
|
|
let proc_res = jit_test(config, props, testfile);
|
|
|
|
if !proc_res.status.success() {
|
|
fatal_proc_rec("jit failed!", &proc_res);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn run_valgrind_test(config: &Config, props: &TestProps, testfile: &Path) {
|
|
if config.valgrind_path.is_none() {
|
|
assert!(!config.force_valgrind);
|
|
return run_rpass_test(config, props, testfile);
|
|
}
|
|
|
|
let mut proc_res = compile_test(config, props, testfile);
|
|
|
|
if !proc_res.status.success() {
|
|
fatal_proc_rec("compilation failed!", &proc_res);
|
|
}
|
|
|
|
let mut new_config = config.clone();
|
|
new_config.runtool = new_config.valgrind_path.clone();
|
|
proc_res = exec_compiled_test(&new_config, props, testfile);
|
|
|
|
if !proc_res.status.success() {
|
|
fatal_proc_rec("test run failed!", &proc_res);
|
|
}
|
|
}
|
|
|
|
fn run_pretty_test(config: &Config, props: &TestProps, testfile: &Path) {
|
|
if props.pp_exact.is_some() {
|
|
logv(config, "testing for exact pretty-printing".to_string());
|
|
} else {
|
|
logv(config, "testing for converging pretty-printing".to_string());
|
|
}
|
|
|
|
let rounds =
|
|
match props.pp_exact { Some(_) => 1, None => 2 };
|
|
|
|
let src = File::open(testfile).read_to_end().unwrap();
|
|
let src = String::from_utf8(src.clone()).unwrap();
|
|
let mut srcs = vec!(src);
|
|
|
|
let mut round = 0;
|
|
while round < rounds {
|
|
logv(config, format!("pretty-printing round {}", round));
|
|
let proc_res = print_source(config,
|
|
props,
|
|
testfile,
|
|
srcs[round].to_string(),
|
|
props.pretty_mode.as_slice());
|
|
|
|
if !proc_res.status.success() {
|
|
fatal_proc_rec(format!("pretty-printing failed in round {}",
|
|
round).as_slice(),
|
|
&proc_res);
|
|
}
|
|
|
|
let ProcRes{ stdout, .. } = proc_res;
|
|
srcs.push(stdout);
|
|
round += 1;
|
|
}
|
|
|
|
let mut expected = match props.pp_exact {
|
|
Some(ref file) => {
|
|
let filepath = testfile.dir_path().join(file);
|
|
let s = File::open(&filepath).read_to_end().unwrap();
|
|
String::from_utf8(s).unwrap()
|
|
}
|
|
None => { srcs[srcs.len() - 2u].clone() }
|
|
};
|
|
let mut actual = srcs[srcs.len() - 1u].clone();
|
|
|
|
if props.pp_exact.is_some() {
|
|
// Now we have to care about line endings
|
|
let cr = "\r".to_string();
|
|
actual = actual.replace(cr.as_slice(), "").to_string();
|
|
expected = expected.replace(cr.as_slice(), "").to_string();
|
|
}
|
|
|
|
compare_source(expected.as_slice(), actual.as_slice());
|
|
|
|
// If we're only making sure that the output matches then just stop here
|
|
if props.pretty_compare_only { return; }
|
|
|
|
// Finally, let's make sure it actually appears to remain valid code
|
|
let proc_res = typecheck_source(config, props, testfile, actual);
|
|
|
|
if !proc_res.status.success() {
|
|
fatal_proc_rec("pretty-printed source does not typecheck", &proc_res);
|
|
}
|
|
if props.no_pretty_expanded { return }
|
|
|
|
// additionally, run `--pretty expanded` and try to build it.
|
|
let proc_res = print_source(config, props, testfile, srcs[round].clone(), "expanded");
|
|
if !proc_res.status.success() {
|
|
fatal_proc_rec("pretty-printing (expanded) failed", &proc_res);
|
|
}
|
|
|
|
let ProcRes{ stdout: expanded_src, .. } = proc_res;
|
|
let proc_res = typecheck_source(config, props, testfile, expanded_src);
|
|
if !proc_res.status.success() {
|
|
fatal_proc_rec("pretty-printed source (expanded) does not typecheck",
|
|
&proc_res);
|
|
}
|
|
|
|
return;
|
|
|
|
fn print_source(config: &Config,
|
|
props: &TestProps,
|
|
testfile: &Path,
|
|
src: String,
|
|
pretty_type: &str) -> ProcRes {
|
|
let aux_dir = aux_output_dir_name(config, testfile);
|
|
compose_and_run(config,
|
|
testfile,
|
|
make_pp_args(config,
|
|
props,
|
|
testfile,
|
|
pretty_type.to_string()),
|
|
props.exec_env.clone(),
|
|
config.compile_lib_path.as_slice(),
|
|
Some(aux_dir.as_str().unwrap()),
|
|
Some(src))
|
|
}
|
|
|
|
fn make_pp_args(config: &Config,
|
|
props: &TestProps,
|
|
testfile: &Path,
|
|
pretty_type: String) -> ProcArgs {
|
|
let aux_dir = aux_output_dir_name(config, testfile);
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
let mut args = vec!("-".to_string(),
|
|
"-Zunstable-options".to_string(),
|
|
"--pretty".to_string(),
|
|
pretty_type,
|
|
format!("--target={}", config.target),
|
|
"-L".to_string(),
|
|
aux_dir.as_str().unwrap().to_string());
|
|
args.extend(split_maybe_args(&config.target_rustcflags).into_iter());
|
|
args.extend(split_maybe_args(&props.compile_flags).into_iter());
|
|
return ProcArgs {
|
|
prog: config.rustc_path.as_str().unwrap().to_string(),
|
|
args: args,
|
|
};
|
|
}
|
|
|
|
fn compare_source(expected: &str, actual: &str) {
|
|
if expected != actual {
|
|
error("pretty-printed source does not match expected source");
|
|
println!("\n\
|
|
expected:\n\
|
|
------------------------------------------\n\
|
|
{}\n\
|
|
------------------------------------------\n\
|
|
actual:\n\
|
|
------------------------------------------\n\
|
|
{}\n\
|
|
------------------------------------------\n\
|
|
\n",
|
|
expected, actual);
|
|
panic!();
|
|
}
|
|
}
|
|
|
|
fn typecheck_source(config: &Config, props: &TestProps,
|
|
testfile: &Path, src: String) -> ProcRes {
|
|
let args = make_typecheck_args(config, props, testfile);
|
|
compose_and_run_compiler(config, props, testfile, args, Some(src))
|
|
}
|
|
|
|
fn make_typecheck_args(config: &Config, props: &TestProps, testfile: &Path) -> ProcArgs {
|
|
let aux_dir = aux_output_dir_name(config, testfile);
|
|
let target = if props.force_host {
|
|
config.host.as_slice()
|
|
} else {
|
|
config.target.as_slice()
|
|
};
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
let mut args = vec!("-".to_string(),
|
|
"-Zno-trans".to_string(),
|
|
"--crate-type=lib".to_string(),
|
|
format!("--target={}", target),
|
|
"-L".to_string(),
|
|
config.build_base.as_str().unwrap().to_string(),
|
|
"-L".to_string(),
|
|
aux_dir.as_str().unwrap().to_string());
|
|
args.extend(split_maybe_args(&config.target_rustcflags).into_iter());
|
|
args.extend(split_maybe_args(&props.compile_flags).into_iter());
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
return ProcArgs {
|
|
prog: config.rustc_path.as_str().unwrap().to_string(),
|
|
args: args,
|
|
};
|
|
}
|
|
}
|
|
|
|
fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
|
|
let mut config = Config {
|
|
target_rustcflags: cleanup_debug_info_options(&config.target_rustcflags),
|
|
host_rustcflags: cleanup_debug_info_options(&config.host_rustcflags),
|
|
.. config.clone()
|
|
};
|
|
|
|
let config = &mut config;
|
|
let DebuggerCommands {
|
|
commands,
|
|
check_lines,
|
|
breakpoint_lines
|
|
} = parse_debugger_commands(testfile, "gdb");
|
|
let mut cmds = commands.connect("\n");
|
|
|
|
// compile test file (it should have 'compile-flags:-g' in the header)
|
|
let compiler_run_result = compile_test(config, props, testfile);
|
|
if !compiler_run_result.status.success() {
|
|
fatal_proc_rec("compilation failed!", &compiler_run_result);
|
|
}
|
|
|
|
let exe_file = make_exe_name(config, testfile);
|
|
|
|
let debugger_run_result;
|
|
match config.target.as_slice() {
|
|
"arm-linux-androideabi" => {
|
|
|
|
cmds = cmds.replace("run", "continue").to_string();
|
|
|
|
// write debugger script
|
|
let script_str = ["set charset UTF-8".to_string(),
|
|
format!("file {}", exe_file.as_str().unwrap()
|
|
.to_string()),
|
|
"target remote :5039".to_string(),
|
|
cmds,
|
|
"quit".to_string()].connect("\n");
|
|
debug!("script_str = {}", script_str);
|
|
dump_output_file(config,
|
|
testfile,
|
|
script_str.as_slice(),
|
|
"debugger.script");
|
|
|
|
|
|
procsrv::run("",
|
|
config.adb_path.as_slice(),
|
|
None,
|
|
&[
|
|
"push".to_string(),
|
|
exe_file.as_str().unwrap().to_string(),
|
|
config.adb_test_dir.clone()
|
|
],
|
|
vec!(("".to_string(), "".to_string())),
|
|
Some("".to_string()))
|
|
.expect(format!("failed to exec `{:?}`", config.adb_path).as_slice());
|
|
|
|
procsrv::run("",
|
|
config.adb_path.as_slice(),
|
|
None,
|
|
&[
|
|
"forward".to_string(),
|
|
"tcp:5039".to_string(),
|
|
"tcp:5039".to_string()
|
|
],
|
|
vec!(("".to_string(), "".to_string())),
|
|
Some("".to_string()))
|
|
.expect(format!("failed to exec `{:?}`", config.adb_path).as_slice());
|
|
|
|
let adb_arg = format!("export LD_LIBRARY_PATH={}; \
|
|
gdbserver :5039 {}/{}",
|
|
config.adb_test_dir.clone(),
|
|
config.adb_test_dir.clone(),
|
|
str::from_utf8(
|
|
exe_file.filename()
|
|
.unwrap()).unwrap());
|
|
|
|
let mut process = procsrv::run_background("",
|
|
config.adb_path
|
|
.as_slice(),
|
|
None,
|
|
&[
|
|
"shell".to_string(),
|
|
adb_arg.clone()
|
|
],
|
|
vec!(("".to_string(),
|
|
"".to_string())),
|
|
Some("".to_string()))
|
|
.expect(format!("failed to exec `{:?}`", config.adb_path).as_slice());
|
|
loop {
|
|
//waiting 1 second for gdbserver start
|
|
timer::sleep(Duration::milliseconds(1000));
|
|
let result = Thread::scoped(move || {
|
|
tcp::TcpStream::connect("127.0.0.1:5039").unwrap();
|
|
}).join();
|
|
if result.is_err() {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
|
|
let tool_path = match config.android_cross_path.as_str() {
|
|
Some(x) => x.to_string(),
|
|
None => fatal("cannot find android cross path")
|
|
};
|
|
|
|
let debugger_script = make_out_name(config, testfile, "debugger.script");
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
let debugger_opts =
|
|
vec!("-quiet".to_string(),
|
|
"-batch".to_string(),
|
|
"-nx".to_string(),
|
|
format!("-command={}", debugger_script.as_str().unwrap()));
|
|
|
|
let mut gdb_path = tool_path;
|
|
gdb_path.push_str("/bin/arm-linux-androideabi-gdb");
|
|
let procsrv::Result {
|
|
out,
|
|
err,
|
|
status
|
|
} = procsrv::run("",
|
|
gdb_path.as_slice(),
|
|
None,
|
|
debugger_opts.as_slice(),
|
|
vec!(("".to_string(), "".to_string())),
|
|
None)
|
|
.expect(format!("failed to exec `{:?}`", gdb_path).as_slice());
|
|
let cmdline = {
|
|
let cmdline = make_cmdline("",
|
|
"arm-linux-androideabi-gdb",
|
|
debugger_opts.as_slice());
|
|
logv(config, format!("executing {}", cmdline));
|
|
cmdline
|
|
};
|
|
|
|
debugger_run_result = ProcRes {
|
|
status: status,
|
|
stdout: out,
|
|
stderr: err,
|
|
cmdline: cmdline
|
|
};
|
|
process.signal_kill().unwrap();
|
|
}
|
|
|
|
_=> {
|
|
let rust_src_root = find_rust_src_root(config)
|
|
.expect("Could not find Rust source root");
|
|
let rust_pp_module_rel_path = Path::new("./src/etc");
|
|
let rust_pp_module_abs_path = rust_src_root.join(rust_pp_module_rel_path)
|
|
.as_str()
|
|
.unwrap()
|
|
.to_string();
|
|
// write debugger script
|
|
let mut script_str = String::with_capacity(2048);
|
|
|
|
script_str.push_str("set charset UTF-8\n");
|
|
script_str.push_str("show version\n");
|
|
|
|
match config.gdb_version {
|
|
Some(ref version) => {
|
|
println!("NOTE: compiletest thinks it is using GDB version {}",
|
|
version.as_slice());
|
|
|
|
if header::gdb_version_to_int(version.as_slice()) >
|
|
header::gdb_version_to_int("7.4") {
|
|
// Add the directory containing the pretty printers to
|
|
// GDB's script auto loading safe path
|
|
script_str.push_str(
|
|
format!("add-auto-load-safe-path {}\n",
|
|
rust_pp_module_abs_path.replace("\\", "\\\\").as_slice())
|
|
.as_slice());
|
|
}
|
|
}
|
|
_ => {
|
|
println!("NOTE: compiletest does not know which version of \
|
|
GDB it is using");
|
|
}
|
|
}
|
|
|
|
// The following line actually doesn't have to do anything with
|
|
// pretty printing, it just tells GDB to print values on one line:
|
|
script_str.push_str("set print pretty off\n");
|
|
|
|
// Add the pretty printer directory to GDB's source-file search path
|
|
script_str.push_str(&format!("directory {}\n", rust_pp_module_abs_path)[]);
|
|
|
|
// Load the target executable
|
|
script_str.push_str(&format!("file {}\n",
|
|
exe_file.as_str().unwrap().replace("\\", "\\\\"))[]);
|
|
|
|
// Add line breakpoints
|
|
for line in breakpoint_lines.iter() {
|
|
script_str.push_str(&format!("break '{}':{}\n",
|
|
testfile.filename_display(),
|
|
*line)[]);
|
|
}
|
|
|
|
script_str.push_str(cmds.as_slice());
|
|
script_str.push_str("quit\n");
|
|
|
|
debug!("script_str = {}", script_str);
|
|
dump_output_file(config,
|
|
testfile,
|
|
script_str.as_slice(),
|
|
"debugger.script");
|
|
|
|
// run debugger script with gdb
|
|
#[cfg(windows)]
|
|
fn debugger() -> String {
|
|
"gdb.exe".to_string()
|
|
}
|
|
#[cfg(unix)]
|
|
fn debugger() -> String {
|
|
"gdb".to_string()
|
|
}
|
|
|
|
let debugger_script = make_out_name(config, testfile, "debugger.script");
|
|
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
let debugger_opts =
|
|
vec!("-quiet".to_string(),
|
|
"-batch".to_string(),
|
|
"-nx".to_string(),
|
|
format!("-command={}", debugger_script.as_str().unwrap()));
|
|
|
|
let proc_args = ProcArgs {
|
|
prog: debugger(),
|
|
args: debugger_opts,
|
|
};
|
|
|
|
let environment = vec![("PYTHONPATH".to_string(), rust_pp_module_abs_path)];
|
|
|
|
debugger_run_result = compose_and_run(config,
|
|
testfile,
|
|
proc_args,
|
|
environment,
|
|
config.run_lib_path.as_slice(),
|
|
None,
|
|
None);
|
|
}
|
|
}
|
|
|
|
if !debugger_run_result.status.success() {
|
|
fatal("gdb failed to execute");
|
|
}
|
|
|
|
check_debugger_output(&debugger_run_result, check_lines.as_slice());
|
|
}
|
|
|
|
fn find_rust_src_root(config: &Config) -> Option<Path> {
|
|
let mut path = config.src_base.clone();
|
|
let path_postfix = Path::new("src/etc/lldb_batchmode.py");
|
|
|
|
while path.pop() {
|
|
if path.join(&path_postfix).is_file() {
|
|
return Some(path);
|
|
}
|
|
}
|
|
|
|
return None;
|
|
}
|
|
|
|
fn run_debuginfo_lldb_test(config: &Config, props: &TestProps, testfile: &Path) {
|
|
use std::old_io::process::{Command, ProcessOutput};
|
|
|
|
if config.lldb_python_dir.is_none() {
|
|
fatal("Can't run LLDB test because LLDB's python path is not set.");
|
|
}
|
|
|
|
let mut config = Config {
|
|
target_rustcflags: cleanup_debug_info_options(&config.target_rustcflags),
|
|
host_rustcflags: cleanup_debug_info_options(&config.host_rustcflags),
|
|
.. config.clone()
|
|
};
|
|
|
|
let config = &mut config;
|
|
|
|
// compile test file (it should have 'compile-flags:-g' in the header)
|
|
let compile_result = compile_test(config, props, testfile);
|
|
if !compile_result.status.success() {
|
|
fatal_proc_rec("compilation failed!", &compile_result);
|
|
}
|
|
|
|
let exe_file = make_exe_name(config, testfile);
|
|
|
|
match config.lldb_version {
|
|
Some(ref version) => {
|
|
println!("NOTE: compiletest thinks it is using LLDB version {}",
|
|
version.as_slice());
|
|
}
|
|
_ => {
|
|
println!("NOTE: compiletest does not know which version of \
|
|
LLDB it is using");
|
|
}
|
|
}
|
|
|
|
// Parse debugger commands etc from test files
|
|
let DebuggerCommands {
|
|
commands,
|
|
check_lines,
|
|
breakpoint_lines,
|
|
..
|
|
} = parse_debugger_commands(testfile, "lldb");
|
|
|
|
// Write debugger script:
|
|
// We don't want to hang when calling `quit` while the process is still running
|
|
let mut script_str = String::from_str("settings set auto-confirm true\n");
|
|
|
|
// Make LLDB emit its version, so we have it documented in the test output
|
|
script_str.push_str("version\n");
|
|
|
|
// Switch LLDB into "Rust mode"
|
|
let rust_src_root = find_rust_src_root(config)
|
|
.expect("Could not find Rust source root");
|
|
let rust_pp_module_rel_path = Path::new("./src/etc/lldb_rust_formatters.py");
|
|
let rust_pp_module_abs_path = rust_src_root.join(rust_pp_module_rel_path)
|
|
.as_str()
|
|
.unwrap()
|
|
.to_string();
|
|
|
|
script_str.push_str(&format!("command script import {}\n", &rust_pp_module_abs_path[])[]);
|
|
script_str.push_str("type summary add --no-value ");
|
|
script_str.push_str("--python-function lldb_rust_formatters.print_val ");
|
|
script_str.push_str("-x \".*\" --category Rust\n");
|
|
script_str.push_str("type category enable Rust\n");
|
|
|
|
// Set breakpoints on every line that contains the string "#break"
|
|
for line in breakpoint_lines.iter() {
|
|
script_str.push_str(format!("breakpoint set --line {}\n",
|
|
line).as_slice());
|
|
}
|
|
|
|
// Append the other commands
|
|
for line in commands.iter() {
|
|
script_str.push_str(line.as_slice());
|
|
script_str.push_str("\n");
|
|
}
|
|
|
|
// Finally, quit the debugger
|
|
script_str.push_str("quit\n");
|
|
|
|
// Write the script into a file
|
|
debug!("script_str = {}", script_str);
|
|
dump_output_file(config,
|
|
testfile,
|
|
script_str.as_slice(),
|
|
"debugger.script");
|
|
let debugger_script = make_out_name(config, testfile, "debugger.script");
|
|
|
|
// Let LLDB execute the script via lldb_batchmode.py
|
|
let debugger_run_result = run_lldb(config,
|
|
&exe_file,
|
|
&debugger_script,
|
|
&rust_src_root);
|
|
|
|
if !debugger_run_result.status.success() {
|
|
fatal_proc_rec("Error while running LLDB", &debugger_run_result);
|
|
}
|
|
|
|
check_debugger_output(&debugger_run_result, check_lines.as_slice());
|
|
|
|
fn run_lldb(config: &Config,
|
|
test_executable: &Path,
|
|
debugger_script: &Path,
|
|
rust_src_root: &Path)
|
|
-> ProcRes {
|
|
// Prepare the lldb_batchmode which executes the debugger script
|
|
let lldb_script_path = rust_src_root.join(Path::new("./src/etc/lldb_batchmode.py"));
|
|
|
|
let mut cmd = Command::new("python");
|
|
cmd.arg(lldb_script_path)
|
|
.arg(test_executable)
|
|
.arg(debugger_script)
|
|
.env_set_all(&[("PYTHONPATH", config.lldb_python_dir.clone().unwrap().as_slice())]);
|
|
|
|
let (status, out, err) = match cmd.spawn() {
|
|
Ok(process) => {
|
|
let ProcessOutput { status, output, error } =
|
|
process.wait_with_output().unwrap();
|
|
|
|
(status,
|
|
String::from_utf8(output).unwrap(),
|
|
String::from_utf8(error).unwrap())
|
|
},
|
|
Err(e) => {
|
|
fatal(format!("Failed to setup Python process for \
|
|
LLDB script: {}", e).as_slice())
|
|
}
|
|
};
|
|
|
|
dump_output(config, test_executable, out.as_slice(), err.as_slice());
|
|
return ProcRes {
|
|
status: status,
|
|
stdout: out,
|
|
stderr: err,
|
|
cmdline: format!("{:?}", cmd)
|
|
};
|
|
}
|
|
}
|
|
|
|
struct DebuggerCommands {
|
|
commands: Vec<String>,
|
|
check_lines: Vec<String>,
|
|
breakpoint_lines: Vec<uint>,
|
|
}
|
|
|
|
fn parse_debugger_commands(file_path: &Path, debugger_prefix: &str)
|
|
-> DebuggerCommands {
|
|
use std::old_io::{BufferedReader, File};
|
|
|
|
let command_directive = format!("{}-command", debugger_prefix);
|
|
let check_directive = format!("{}-check", debugger_prefix);
|
|
|
|
let mut breakpoint_lines = vec!();
|
|
let mut commands = vec!();
|
|
let mut check_lines = vec!();
|
|
let mut counter = 1;
|
|
let mut reader = BufferedReader::new(File::open(file_path).unwrap());
|
|
for line in reader.lines() {
|
|
match line {
|
|
Ok(line) => {
|
|
if line.contains("#break") {
|
|
breakpoint_lines.push(counter);
|
|
}
|
|
|
|
header::parse_name_value_directive(
|
|
line.as_slice(),
|
|
command_directive.as_slice()).map(|cmd| {
|
|
commands.push(cmd)
|
|
});
|
|
|
|
header::parse_name_value_directive(
|
|
line.as_slice(),
|
|
check_directive.as_slice()).map(|cmd| {
|
|
check_lines.push(cmd)
|
|
});
|
|
}
|
|
Err(e) => {
|
|
fatal(format!("Error while parsing debugger commands: {}",
|
|
e).as_slice())
|
|
}
|
|
}
|
|
counter += 1;
|
|
}
|
|
|
|
DebuggerCommands {
|
|
commands: commands,
|
|
check_lines: check_lines,
|
|
breakpoint_lines: breakpoint_lines,
|
|
}
|
|
}
|
|
|
|
fn cleanup_debug_info_options(options: &Option<String>) -> Option<String> {
|
|
if options.is_none() {
|
|
return None;
|
|
}
|
|
|
|
// Remove options that are either unwanted (-O) or may lead to duplicates due to RUSTFLAGS.
|
|
let options_to_remove = [
|
|
"-O".to_string(),
|
|
"-g".to_string(),
|
|
"--debuginfo".to_string()
|
|
];
|
|
let new_options =
|
|
split_maybe_args(options).into_iter()
|
|
.filter(|x| !options_to_remove.contains(x))
|
|
.collect::<Vec<String>>()
|
|
.connect(" ");
|
|
Some(new_options)
|
|
}
|
|
|
|
fn check_debugger_output(debugger_run_result: &ProcRes, check_lines: &[String]) {
|
|
let num_check_lines = check_lines.len();
|
|
if num_check_lines > 0 {
|
|
// Allow check lines to leave parts unspecified (e.g., uninitialized
|
|
// bits in the wrong case of an enum) with the notation "[...]".
|
|
let check_fragments: Vec<Vec<String>> =
|
|
check_lines.iter().map(|s| {
|
|
s.as_slice()
|
|
.trim()
|
|
.split_str("[...]")
|
|
.map(|x| x.to_string())
|
|
.collect()
|
|
}).collect();
|
|
// check if each line in props.check_lines appears in the
|
|
// output (in order)
|
|
let mut i = 0u;
|
|
for line in debugger_run_result.stdout.lines() {
|
|
let mut rest = line.trim();
|
|
let mut first = true;
|
|
let mut failed = false;
|
|
for frag in check_fragments[i].iter() {
|
|
let found = if first {
|
|
if rest.starts_with(frag.as_slice()) {
|
|
Some(0)
|
|
} else {
|
|
None
|
|
}
|
|
} else {
|
|
rest.find_str(frag.as_slice())
|
|
};
|
|
match found {
|
|
None => {
|
|
failed = true;
|
|
break;
|
|
}
|
|
Some(i) => {
|
|
rest = &rest[(i + frag.len())..];
|
|
}
|
|
}
|
|
first = false;
|
|
}
|
|
if !failed && rest.len() == 0 {
|
|
i += 1u;
|
|
}
|
|
if i == num_check_lines {
|
|
// all lines checked
|
|
break;
|
|
}
|
|
}
|
|
if i != num_check_lines {
|
|
fatal_proc_rec(format!("line not found in debugger output: {}",
|
|
check_lines.get(i).unwrap()).as_slice(),
|
|
debugger_run_result);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn check_error_patterns(props: &TestProps,
|
|
testfile: &Path,
|
|
output_to_check: &str,
|
|
proc_res: &ProcRes) {
|
|
if props.error_patterns.is_empty() {
|
|
fatal(format!("no error pattern specified in {:?}",
|
|
testfile.display()).as_slice());
|
|
}
|
|
let mut next_err_idx = 0u;
|
|
let mut next_err_pat = &props.error_patterns[next_err_idx];
|
|
let mut done = false;
|
|
for line in output_to_check.lines() {
|
|
if line.contains(next_err_pat.as_slice()) {
|
|
debug!("found error pattern {}", next_err_pat);
|
|
next_err_idx += 1u;
|
|
if next_err_idx == props.error_patterns.len() {
|
|
debug!("found all error patterns");
|
|
done = true;
|
|
break;
|
|
}
|
|
next_err_pat = &props.error_patterns[next_err_idx];
|
|
}
|
|
}
|
|
if done { return; }
|
|
|
|
let missing_patterns = &props.error_patterns[next_err_idx..];
|
|
if missing_patterns.len() == 1u {
|
|
fatal_proc_rec(format!("error pattern '{}' not found!",
|
|
missing_patterns[0]).as_slice(),
|
|
proc_res);
|
|
} else {
|
|
for pattern in missing_patterns.iter() {
|
|
error(format!("error pattern '{}' not found!",
|
|
*pattern).as_slice());
|
|
}
|
|
fatal_proc_rec("multiple error patterns not found", proc_res);
|
|
}
|
|
}
|
|
|
|
fn check_no_compiler_crash(proc_res: &ProcRes) {
|
|
for line in proc_res.stderr.lines() {
|
|
if line.starts_with("error: internal compiler error:") {
|
|
fatal_proc_rec("compiler encountered internal error",
|
|
proc_res);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn check_forbid_output(props: &TestProps,
|
|
output_to_check: &str,
|
|
proc_res: &ProcRes) {
|
|
for pat in props.forbid_output.iter() {
|
|
if output_to_check.contains(pat.as_slice()) {
|
|
fatal_proc_rec("forbidden pattern found in compiler output", proc_res);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> ,
|
|
testfile: &Path,
|
|
proc_res: &ProcRes) {
|
|
|
|
// true if we found the error in question
|
|
let mut found_flags: Vec<_> = repeat(false).take(expected_errors.len()).collect();
|
|
|
|
if proc_res.status.success() {
|
|
fatal("process did not return an error status");
|
|
}
|
|
|
|
let prefixes = expected_errors.iter().map(|ee| {
|
|
format!("{}:{}:", testfile.display(), ee.line)
|
|
}).collect::<Vec<String> >();
|
|
|
|
#[cfg(windows)]
|
|
fn prefix_matches( line : &str, prefix : &str ) -> bool {
|
|
line.to_ascii_lowercase().starts_with(prefix.to_ascii_lowercase().as_slice())
|
|
}
|
|
|
|
#[cfg(unix)]
|
|
fn prefix_matches( line : &str, prefix : &str ) -> bool {
|
|
line.starts_with( prefix )
|
|
}
|
|
|
|
// A multi-line error will have followup lines which will always
|
|
// start with one of these strings.
|
|
fn continuation( line: &str) -> bool {
|
|
line.starts_with(" expected") ||
|
|
line.starts_with(" found") ||
|
|
// 1234
|
|
// Should have 4 spaces: see issue 18946
|
|
line.starts_with("(")
|
|
}
|
|
|
|
// Scan and extract our error/warning messages,
|
|
// which look like:
|
|
// filename:line1:col1: line2:col2: *error:* msg
|
|
// filename:line1:col1: line2:col2: *warning:* msg
|
|
// where line1:col1: is the starting point, line2:col2:
|
|
// is the ending point, and * represents ANSI color codes.
|
|
for line in proc_res.stderr.lines() {
|
|
let mut was_expected = false;
|
|
for (i, ee) in expected_errors.iter().enumerate() {
|
|
if !found_flags[i] {
|
|
debug!("prefix={} ee.kind={} ee.msg={} line={}",
|
|
prefixes[i].as_slice(),
|
|
ee.kind,
|
|
ee.msg,
|
|
line);
|
|
if (prefix_matches(line, prefixes[i].as_slice()) || continuation(line)) &&
|
|
line.contains(ee.kind.as_slice()) &&
|
|
line.contains(ee.msg.as_slice()) {
|
|
found_flags[i] = true;
|
|
was_expected = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// ignore this msg which gets printed at the end
|
|
if line.contains("aborting due to") {
|
|
was_expected = true;
|
|
}
|
|
|
|
if !was_expected && is_compiler_error_or_warning(line) {
|
|
fatal_proc_rec(format!("unexpected compiler error or warning: '{}'",
|
|
line).as_slice(),
|
|
proc_res);
|
|
}
|
|
}
|
|
|
|
for (i, &flag) in found_flags.iter().enumerate() {
|
|
if !flag {
|
|
let ee = &expected_errors[i];
|
|
fatal_proc_rec(format!("expected {} on line {} not found: {}",
|
|
ee.kind, ee.line, ee.msg).as_slice(),
|
|
proc_res);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn is_compiler_error_or_warning(line: &str) -> bool {
|
|
let mut i = 0u;
|
|
return
|
|
scan_until_char(line, ':', &mut i) &&
|
|
scan_char(line, ':', &mut i) &&
|
|
scan_integer(line, &mut i) &&
|
|
scan_char(line, ':', &mut i) &&
|
|
scan_integer(line, &mut i) &&
|
|
scan_char(line, ':', &mut i) &&
|
|
scan_char(line, ' ', &mut i) &&
|
|
scan_integer(line, &mut i) &&
|
|
scan_char(line, ':', &mut i) &&
|
|
scan_integer(line, &mut i) &&
|
|
scan_char(line, ' ', &mut i) &&
|
|
(scan_string(line, "error", &mut i) ||
|
|
scan_string(line, "warning", &mut i));
|
|
}
|
|
|
|
fn scan_until_char(haystack: &str, needle: char, idx: &mut uint) -> bool {
|
|
if *idx >= haystack.len() {
|
|
return false;
|
|
}
|
|
let opt = haystack[(*idx)..].find(needle);
|
|
if opt.is_none() {
|
|
return false;
|
|
}
|
|
*idx = opt.unwrap();
|
|
return true;
|
|
}
|
|
|
|
fn scan_char(haystack: &str, needle: char, idx: &mut uint) -> bool {
|
|
if *idx >= haystack.len() {
|
|
return false;
|
|
}
|
|
let range = haystack.char_range_at(*idx);
|
|
if range.ch != needle {
|
|
return false;
|
|
}
|
|
*idx = range.next;
|
|
return true;
|
|
}
|
|
|
|
fn scan_integer(haystack: &str, idx: &mut uint) -> bool {
|
|
let mut i = *idx;
|
|
while i < haystack.len() {
|
|
let range = haystack.char_range_at(i);
|
|
if range.ch < '0' || '9' < range.ch {
|
|
break;
|
|
}
|
|
i = range.next;
|
|
}
|
|
if i == *idx {
|
|
return false;
|
|
}
|
|
*idx = i;
|
|
return true;
|
|
}
|
|
|
|
fn scan_string(haystack: &str, needle: &str, idx: &mut uint) -> bool {
|
|
let mut haystack_i = *idx;
|
|
let mut needle_i = 0u;
|
|
while needle_i < needle.len() {
|
|
if haystack_i >= haystack.len() {
|
|
return false;
|
|
}
|
|
let range = haystack.char_range_at(haystack_i);
|
|
haystack_i = range.next;
|
|
if !scan_char(needle, range.ch, &mut needle_i) {
|
|
return false;
|
|
}
|
|
}
|
|
*idx = haystack_i;
|
|
return true;
|
|
}
|
|
|
|
struct ProcArgs {
|
|
prog: String,
|
|
args: Vec<String>,
|
|
}
|
|
|
|
struct ProcRes {
|
|
status: ProcessExit,
|
|
stdout: String,
|
|
stderr: String,
|
|
cmdline: String,
|
|
}
|
|
|
|
fn compile_test(config: &Config, props: &TestProps,
|
|
testfile: &Path) -> ProcRes {
|
|
compile_test_(config, props, testfile, &[])
|
|
}
|
|
|
|
fn jit_test(config: &Config, props: &TestProps, testfile: &Path) -> ProcRes {
|
|
compile_test_(config, props, testfile, &["--jit".to_string()])
|
|
}
|
|
|
|
fn compile_test_(config: &Config, props: &TestProps,
|
|
testfile: &Path, extra_args: &[String]) -> ProcRes {
|
|
let aux_dir = aux_output_dir_name(config, testfile);
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
let mut link_args = vec!("-L".to_string(),
|
|
aux_dir.as_str().unwrap().to_string());
|
|
link_args.extend(extra_args.iter().map(|s| s.clone()));
|
|
let args = make_compile_args(config,
|
|
props,
|
|
link_args,
|
|
|a, b| TargetLocation::ThisFile(make_exe_name(a, b)), testfile);
|
|
compose_and_run_compiler(config, props, testfile, args, None)
|
|
}
|
|
|
|
fn exec_compiled_test(config: &Config, props: &TestProps,
|
|
testfile: &Path) -> ProcRes {
|
|
|
|
let env = props.exec_env.clone();
|
|
|
|
match config.target.as_slice() {
|
|
|
|
"arm-linux-androideabi" => {
|
|
_arm_exec_compiled_test(config, props, testfile, env)
|
|
}
|
|
|
|
_=> {
|
|
let aux_dir = aux_output_dir_name(config, testfile);
|
|
compose_and_run(config,
|
|
testfile,
|
|
make_run_args(config, props, testfile),
|
|
env,
|
|
config.run_lib_path.as_slice(),
|
|
Some(aux_dir.as_str().unwrap()),
|
|
None)
|
|
}
|
|
}
|
|
}
|
|
|
|
fn compose_and_run_compiler(
|
|
config: &Config,
|
|
props: &TestProps,
|
|
testfile: &Path,
|
|
args: ProcArgs,
|
|
input: Option<String>) -> ProcRes {
|
|
|
|
if !props.aux_builds.is_empty() {
|
|
ensure_dir(&aux_output_dir_name(config, testfile));
|
|
}
|
|
|
|
let aux_dir = aux_output_dir_name(config, testfile);
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
let extra_link_args = vec!("-L".to_string(), aux_dir.as_str().unwrap().to_string());
|
|
|
|
for rel_ab in props.aux_builds.iter() {
|
|
let abs_ab = config.aux_base.join(rel_ab.as_slice());
|
|
let aux_props = header::load_props(&abs_ab);
|
|
let mut crate_type = if aux_props.no_prefer_dynamic {
|
|
Vec::new()
|
|
} else {
|
|
vec!("--crate-type=dylib".to_string())
|
|
};
|
|
crate_type.extend(extra_link_args.clone().into_iter());
|
|
let aux_args =
|
|
make_compile_args(config,
|
|
&aux_props,
|
|
crate_type,
|
|
|a,b| {
|
|
let f = make_lib_name(a, b, testfile);
|
|
TargetLocation::ThisDirectory(f.dir_path())
|
|
},
|
|
&abs_ab);
|
|
let auxres = compose_and_run(config,
|
|
&abs_ab,
|
|
aux_args,
|
|
Vec::new(),
|
|
config.compile_lib_path.as_slice(),
|
|
Some(aux_dir.as_str().unwrap()),
|
|
None);
|
|
if !auxres.status.success() {
|
|
fatal_proc_rec(
|
|
format!("auxiliary build of {:?} failed to compile: ",
|
|
abs_ab.display()).as_slice(),
|
|
&auxres);
|
|
}
|
|
|
|
match config.target.as_slice() {
|
|
"arm-linux-androideabi" => {
|
|
_arm_push_aux_shared_library(config, testfile);
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
compose_and_run(config,
|
|
testfile,
|
|
args,
|
|
Vec::new(),
|
|
config.compile_lib_path.as_slice(),
|
|
Some(aux_dir.as_str().unwrap()),
|
|
input)
|
|
}
|
|
|
|
fn ensure_dir(path: &Path) {
|
|
if path.is_dir() { return; }
|
|
fs::mkdir(path, old_io::USER_RWX).unwrap();
|
|
}
|
|
|
|
fn compose_and_run(config: &Config, testfile: &Path,
|
|
ProcArgs{ args, prog }: ProcArgs,
|
|
procenv: Vec<(String, String)> ,
|
|
lib_path: &str,
|
|
aux_path: Option<&str>,
|
|
input: Option<String>) -> ProcRes {
|
|
return program_output(config, testfile, lib_path,
|
|
prog, aux_path, args, procenv, input);
|
|
}
|
|
|
|
enum TargetLocation {
|
|
ThisFile(Path),
|
|
ThisDirectory(Path),
|
|
}
|
|
|
|
fn make_compile_args<F>(config: &Config,
|
|
props: &TestProps,
|
|
extras: Vec<String> ,
|
|
xform: F,
|
|
testfile: &Path)
|
|
-> ProcArgs where
|
|
F: FnOnce(&Config, &Path) -> TargetLocation,
|
|
{
|
|
let xform_file = xform(config, testfile);
|
|
let target = if props.force_host {
|
|
config.host.as_slice()
|
|
} else {
|
|
config.target.as_slice()
|
|
};
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
let mut args = vec!(testfile.as_str().unwrap().to_string(),
|
|
"-L".to_string(),
|
|
config.build_base.as_str().unwrap().to_string(),
|
|
format!("--target={}", target));
|
|
args.push_all(extras.as_slice());
|
|
if !props.no_prefer_dynamic {
|
|
args.push("-C".to_string());
|
|
args.push("prefer-dynamic".to_string());
|
|
}
|
|
let path = match xform_file {
|
|
TargetLocation::ThisFile(path) => {
|
|
args.push("-o".to_string());
|
|
path
|
|
}
|
|
TargetLocation::ThisDirectory(path) => {
|
|
args.push("--out-dir".to_string());
|
|
path
|
|
}
|
|
};
|
|
args.push(path.as_str().unwrap().to_string());
|
|
if props.force_host {
|
|
args.extend(split_maybe_args(&config.host_rustcflags).into_iter());
|
|
} else {
|
|
args.extend(split_maybe_args(&config.target_rustcflags).into_iter());
|
|
}
|
|
args.extend(split_maybe_args(&props.compile_flags).into_iter());
|
|
return ProcArgs {
|
|
prog: config.rustc_path.as_str().unwrap().to_string(),
|
|
args: args,
|
|
};
|
|
}
|
|
|
|
fn make_lib_name(config: &Config, auxfile: &Path, testfile: &Path) -> Path {
|
|
// what we return here is not particularly important, as it
|
|
// happens; rustc ignores everything except for the directory.
|
|
let auxname = output_testname(auxfile);
|
|
aux_output_dir_name(config, testfile).join(&auxname)
|
|
}
|
|
|
|
fn make_exe_name(config: &Config, testfile: &Path) -> Path {
|
|
let mut f = output_base_name(config, testfile);
|
|
if !os::consts::EXE_SUFFIX.is_empty() {
|
|
let mut fname = f.filename().unwrap().to_vec();
|
|
fname.extend(os::consts::EXE_SUFFIX.bytes());
|
|
f.set_filename(fname);
|
|
}
|
|
f
|
|
}
|
|
|
|
fn make_run_args(config: &Config, props: &TestProps, testfile: &Path) ->
|
|
ProcArgs {
|
|
// If we've got another tool to run under (valgrind),
|
|
// then split apart its command
|
|
let mut args = split_maybe_args(&config.runtool);
|
|
let exe_file = make_exe_name(config, testfile);
|
|
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
args.push(exe_file.as_str().unwrap().to_string());
|
|
|
|
// Add the arguments in the run_flags directive
|
|
args.extend(split_maybe_args(&props.run_flags).into_iter());
|
|
|
|
let prog = args.remove(0);
|
|
return ProcArgs {
|
|
prog: prog,
|
|
args: args,
|
|
};
|
|
}
|
|
|
|
fn split_maybe_args(argstr: &Option<String>) -> Vec<String> {
|
|
match *argstr {
|
|
Some(ref s) => {
|
|
s.as_slice()
|
|
.split(' ')
|
|
.filter_map(|s| {
|
|
if s.chars().all(|c| c.is_whitespace()) {
|
|
None
|
|
} else {
|
|
Some(s.to_string())
|
|
}
|
|
}).collect()
|
|
}
|
|
None => Vec::new()
|
|
}
|
|
}
|
|
|
|
fn program_output(config: &Config, testfile: &Path, lib_path: &str, prog: String,
|
|
aux_path: Option<&str>, args: Vec<String>,
|
|
env: Vec<(String, String)>,
|
|
input: Option<String>) -> ProcRes {
|
|
let cmdline =
|
|
{
|
|
let cmdline = make_cmdline(lib_path,
|
|
prog.as_slice(),
|
|
args.as_slice());
|
|
logv(config, format!("executing {}", cmdline));
|
|
cmdline
|
|
};
|
|
let procsrv::Result {
|
|
out,
|
|
err,
|
|
status
|
|
} = procsrv::run(lib_path,
|
|
prog.as_slice(),
|
|
aux_path,
|
|
args.as_slice(),
|
|
env,
|
|
input).expect(format!("failed to exec `{}`", prog).as_slice());
|
|
dump_output(config, testfile, out.as_slice(), err.as_slice());
|
|
return ProcRes {
|
|
status: status,
|
|
stdout: out,
|
|
stderr: err,
|
|
cmdline: cmdline,
|
|
};
|
|
}
|
|
|
|
// Linux and mac don't require adjusting the library search path
|
|
#[cfg(unix)]
|
|
fn make_cmdline(_libpath: &str, prog: &str, args: &[String]) -> String {
|
|
format!("{} {}", prog, args.connect(" "))
|
|
}
|
|
|
|
#[cfg(windows)]
|
|
fn make_cmdline(libpath: &str, prog: &str, args: &[String]) -> String {
|
|
|
|
// Build the LD_LIBRARY_PATH variable as it would be seen on the command line
|
|
// for diagnostic purposes
|
|
fn lib_path_cmd_prefix(path: &str) -> String {
|
|
format!("{}=\"{}\"", util::lib_path_env_var(), util::make_new_path(path))
|
|
}
|
|
|
|
format!("{} {} {}", lib_path_cmd_prefix(libpath), prog, args.connect(" "))
|
|
}
|
|
|
|
fn dump_output(config: &Config, testfile: &Path, out: &str, err: &str) {
|
|
dump_output_file(config, testfile, out, "out");
|
|
dump_output_file(config, testfile, err, "err");
|
|
maybe_dump_to_stdout(config, out, err);
|
|
}
|
|
|
|
fn dump_output_file(config: &Config, testfile: &Path,
|
|
out: &str, extension: &str) {
|
|
let outfile = make_out_name(config, testfile, extension);
|
|
File::create(&outfile).write_all(out.as_bytes()).unwrap();
|
|
}
|
|
|
|
fn make_out_name(config: &Config, testfile: &Path, extension: &str) -> Path {
|
|
output_base_name(config, testfile).with_extension(extension)
|
|
}
|
|
|
|
fn aux_output_dir_name(config: &Config, testfile: &Path) -> Path {
|
|
let f = output_base_name(config, testfile);
|
|
let mut fname = f.filename().unwrap().to_vec();
|
|
fname.extend("libaux".bytes());
|
|
f.with_filename(fname)
|
|
}
|
|
|
|
fn output_testname(testfile: &Path) -> Path {
|
|
Path::new(testfile.filestem().unwrap())
|
|
}
|
|
|
|
fn output_base_name(config: &Config, testfile: &Path) -> Path {
|
|
config.build_base
|
|
.join(&output_testname(testfile))
|
|
.with_extension(config.stage_id.as_slice())
|
|
}
|
|
|
|
fn maybe_dump_to_stdout(config: &Config, out: &str, err: &str) {
|
|
if config.verbose {
|
|
println!("------{}------------------------------", "stdout");
|
|
println!("{}", out);
|
|
println!("------{}------------------------------", "stderr");
|
|
println!("{}", err);
|
|
println!("------------------------------------------");
|
|
}
|
|
}
|
|
|
|
fn error(err: &str) { println!("\nerror: {}", err); }
|
|
|
|
fn fatal(err: &str) -> ! { error(err); panic!(); }
|
|
|
|
fn fatal_proc_rec(err: &str, proc_res: &ProcRes) -> ! {
|
|
print!("\n\
|
|
error: {}\n\
|
|
status: {}\n\
|
|
command: {}\n\
|
|
stdout:\n\
|
|
------------------------------------------\n\
|
|
{}\n\
|
|
------------------------------------------\n\
|
|
stderr:\n\
|
|
------------------------------------------\n\
|
|
{}\n\
|
|
------------------------------------------\n\
|
|
\n",
|
|
err, proc_res.status, proc_res.cmdline, proc_res.stdout,
|
|
proc_res.stderr);
|
|
panic!();
|
|
}
|
|
|
|
fn _arm_exec_compiled_test(config: &Config,
|
|
props: &TestProps,
|
|
testfile: &Path,
|
|
env: Vec<(String, String)>)
|
|
-> ProcRes {
|
|
let args = make_run_args(config, props, testfile);
|
|
let cmdline = make_cmdline("",
|
|
args.prog.as_slice(),
|
|
args.args.as_slice());
|
|
|
|
// get bare program string
|
|
let mut tvec: Vec<String> = args.prog
|
|
.as_slice()
|
|
.split('/')
|
|
.map(|ts| ts.to_string())
|
|
.collect();
|
|
let prog_short = tvec.pop().unwrap();
|
|
|
|
// copy to target
|
|
let copy_result = procsrv::run("",
|
|
config.adb_path.as_slice(),
|
|
None,
|
|
&[
|
|
"push".to_string(),
|
|
args.prog.clone(),
|
|
config.adb_test_dir.clone()
|
|
],
|
|
vec!(("".to_string(), "".to_string())),
|
|
Some("".to_string()))
|
|
.expect(format!("failed to exec `{}`", config.adb_path).as_slice());
|
|
|
|
if config.verbose {
|
|
println!("push ({}) {} {} {}",
|
|
config.target,
|
|
args.prog,
|
|
copy_result.out,
|
|
copy_result.err);
|
|
}
|
|
|
|
logv(config, format!("executing ({}) {}", config.target, cmdline));
|
|
|
|
let mut runargs = Vec::new();
|
|
|
|
// run test via adb_run_wrapper
|
|
runargs.push("shell".to_string());
|
|
for (key, val) in env.into_iter() {
|
|
runargs.push(format!("{}={}", key, val));
|
|
}
|
|
runargs.push(format!("{}/adb_run_wrapper.sh", config.adb_test_dir));
|
|
runargs.push(format!("{}", config.adb_test_dir));
|
|
runargs.push(format!("{}", prog_short));
|
|
|
|
for tv in args.args.iter() {
|
|
runargs.push(tv.to_string());
|
|
}
|
|
procsrv::run("",
|
|
config.adb_path.as_slice(),
|
|
None,
|
|
runargs.as_slice(),
|
|
vec!(("".to_string(), "".to_string())), Some("".to_string()))
|
|
.expect(format!("failed to exec `{}`", config.adb_path).as_slice());
|
|
|
|
// get exitcode of result
|
|
runargs = Vec::new();
|
|
runargs.push("shell".to_string());
|
|
runargs.push("cat".to_string());
|
|
runargs.push(format!("{}/{}.exitcode", config.adb_test_dir, prog_short));
|
|
|
|
let procsrv::Result{ out: exitcode_out, err: _, status: _ } =
|
|
procsrv::run("",
|
|
config.adb_path.as_slice(),
|
|
None,
|
|
runargs.as_slice(),
|
|
vec!(("".to_string(), "".to_string())),
|
|
Some("".to_string()))
|
|
.expect(format!("failed to exec `{}`", config.adb_path).as_slice());
|
|
|
|
let mut exitcode: int = 0;
|
|
for c in exitcode_out.chars() {
|
|
if !c.is_numeric() { break; }
|
|
exitcode = exitcode * 10 + match c {
|
|
'0' ... '9' => c as int - ('0' as int),
|
|
_ => 101,
|
|
}
|
|
}
|
|
|
|
// get stdout of result
|
|
runargs = Vec::new();
|
|
runargs.push("shell".to_string());
|
|
runargs.push("cat".to_string());
|
|
runargs.push(format!("{}/{}.stdout", config.adb_test_dir, prog_short));
|
|
|
|
let procsrv::Result{ out: stdout_out, err: _, status: _ } =
|
|
procsrv::run("",
|
|
config.adb_path.as_slice(),
|
|
None,
|
|
runargs.as_slice(),
|
|
vec!(("".to_string(), "".to_string())),
|
|
Some("".to_string()))
|
|
.expect(format!("failed to exec `{}`", config.adb_path).as_slice());
|
|
|
|
// get stderr of result
|
|
runargs = Vec::new();
|
|
runargs.push("shell".to_string());
|
|
runargs.push("cat".to_string());
|
|
runargs.push(format!("{}/{}.stderr", config.adb_test_dir, prog_short));
|
|
|
|
let procsrv::Result{ out: stderr_out, err: _, status: _ } =
|
|
procsrv::run("",
|
|
config.adb_path.as_slice(),
|
|
None,
|
|
runargs.as_slice(),
|
|
vec!(("".to_string(), "".to_string())),
|
|
Some("".to_string()))
|
|
.expect(format!("failed to exec `{}`", config.adb_path).as_slice());
|
|
|
|
dump_output(config,
|
|
testfile,
|
|
stdout_out.as_slice(),
|
|
stderr_out.as_slice());
|
|
|
|
ProcRes {
|
|
status: process::ProcessExit::ExitStatus(exitcode),
|
|
stdout: stdout_out,
|
|
stderr: stderr_out,
|
|
cmdline: cmdline
|
|
}
|
|
}
|
|
|
|
fn _arm_push_aux_shared_library(config: &Config, testfile: &Path) {
|
|
let tdir = aux_output_dir_name(config, testfile);
|
|
|
|
let dirs = fs::readdir(&tdir).unwrap();
|
|
for file in dirs.iter() {
|
|
if file.extension_str() == Some("so") {
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
let copy_result = procsrv::run("",
|
|
config.adb_path.as_slice(),
|
|
None,
|
|
&[
|
|
"push".to_string(),
|
|
file.as_str()
|
|
.unwrap()
|
|
.to_string(),
|
|
config.adb_test_dir.to_string()
|
|
],
|
|
vec!(("".to_string(),
|
|
"".to_string())),
|
|
Some("".to_string()))
|
|
.expect(format!("failed to exec `{}`", config.adb_path).as_slice());
|
|
|
|
if config.verbose {
|
|
println!("push ({}) {:?} {} {}",
|
|
config.target, file.display(),
|
|
copy_result.out, copy_result.err);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// codegen tests (vs. clang)
|
|
|
|
fn append_suffix_to_stem(p: &Path, suffix: &str) -> Path {
|
|
if suffix.len() == 0 {
|
|
(*p).clone()
|
|
} else {
|
|
let mut stem = p.filestem().unwrap().to_vec();
|
|
stem.extend("-".bytes());
|
|
stem.extend(suffix.bytes());
|
|
p.with_filename(stem)
|
|
}
|
|
}
|
|
|
|
fn compile_test_and_save_bitcode(config: &Config, props: &TestProps,
|
|
testfile: &Path) -> ProcRes {
|
|
let aux_dir = aux_output_dir_name(config, testfile);
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
let mut link_args = vec!("-L".to_string(),
|
|
aux_dir.as_str().unwrap().to_string());
|
|
let llvm_args = vec!("--emit=llvm-bc,obj".to_string(),
|
|
"--crate-type=lib".to_string());
|
|
link_args.extend(llvm_args.into_iter());
|
|
let args = make_compile_args(config,
|
|
props,
|
|
link_args,
|
|
|a, b| TargetLocation::ThisDirectory(
|
|
output_base_name(a, b).dir_path()),
|
|
testfile);
|
|
compose_and_run_compiler(config, props, testfile, args, None)
|
|
}
|
|
|
|
fn compile_cc_with_clang_and_save_bitcode(config: &Config, _props: &TestProps,
|
|
testfile: &Path) -> ProcRes {
|
|
let bitcodefile = output_base_name(config, testfile).with_extension("bc");
|
|
let bitcodefile = append_suffix_to_stem(&bitcodefile, "clang");
|
|
let testcc = testfile.with_extension("cc");
|
|
let proc_args = ProcArgs {
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
prog: config.clang_path.as_ref().unwrap().as_str().unwrap().to_string(),
|
|
args: vec!("-c".to_string(),
|
|
"-emit-llvm".to_string(),
|
|
"-o".to_string(),
|
|
bitcodefile.as_str().unwrap().to_string(),
|
|
testcc.as_str().unwrap().to_string())
|
|
};
|
|
compose_and_run(config, testfile, proc_args, Vec::new(), "", None, None)
|
|
}
|
|
|
|
fn extract_function_from_bitcode(config: &Config, _props: &TestProps,
|
|
fname: &str, testfile: &Path,
|
|
suffix: &str) -> ProcRes {
|
|
let bitcodefile = output_base_name(config, testfile).with_extension("bc");
|
|
let bitcodefile = append_suffix_to_stem(&bitcodefile, suffix);
|
|
let extracted_bc = append_suffix_to_stem(&bitcodefile, "extract");
|
|
let prog = config.llvm_bin_path.as_ref().unwrap().join("llvm-extract");
|
|
let proc_args = ProcArgs {
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
prog: prog.as_str().unwrap().to_string(),
|
|
args: vec!(format!("-func={}", fname),
|
|
format!("-o={}", extracted_bc.as_str().unwrap()),
|
|
bitcodefile.as_str().unwrap().to_string())
|
|
};
|
|
compose_and_run(config, testfile, proc_args, Vec::new(), "", None, None)
|
|
}
|
|
|
|
fn disassemble_extract(config: &Config, _props: &TestProps,
|
|
testfile: &Path, suffix: &str) -> ProcRes {
|
|
let bitcodefile = output_base_name(config, testfile).with_extension("bc");
|
|
let bitcodefile = append_suffix_to_stem(&bitcodefile, suffix);
|
|
let extracted_bc = append_suffix_to_stem(&bitcodefile, "extract");
|
|
let extracted_ll = extracted_bc.with_extension("ll");
|
|
let prog = config.llvm_bin_path.as_ref().unwrap().join("llvm-dis");
|
|
let proc_args = ProcArgs {
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
prog: prog.as_str().unwrap().to_string(),
|
|
args: vec!(format!("-o={}", extracted_ll.as_str().unwrap()),
|
|
extracted_bc.as_str().unwrap().to_string())
|
|
};
|
|
compose_and_run(config, testfile, proc_args, Vec::new(), "", None, None)
|
|
}
|
|
|
|
|
|
fn count_extracted_lines(p: &Path) -> uint {
|
|
let x = File::open(&p.with_extension("ll")).read_to_end().unwrap();
|
|
let x = str::from_utf8(x.as_slice()).unwrap();
|
|
x.lines().count()
|
|
}
|
|
|
|
|
|
fn run_codegen_test(config: &Config, props: &TestProps,
|
|
testfile: &Path, mm: &mut MetricMap) {
|
|
|
|
if config.llvm_bin_path.is_none() {
|
|
fatal("missing --llvm-bin-path");
|
|
}
|
|
|
|
if config.clang_path.is_none() {
|
|
fatal("missing --clang-path");
|
|
}
|
|
|
|
let mut proc_res = compile_test_and_save_bitcode(config, props, testfile);
|
|
if !proc_res.status.success() {
|
|
fatal_proc_rec("compilation failed!", &proc_res);
|
|
}
|
|
|
|
proc_res = extract_function_from_bitcode(config, props, "test", testfile, "");
|
|
if !proc_res.status.success() {
|
|
fatal_proc_rec("extracting 'test' function failed",
|
|
&proc_res);
|
|
}
|
|
|
|
proc_res = disassemble_extract(config, props, testfile, "");
|
|
if !proc_res.status.success() {
|
|
fatal_proc_rec("disassembling extract failed", &proc_res);
|
|
}
|
|
|
|
|
|
let mut proc_res = compile_cc_with_clang_and_save_bitcode(config, props, testfile);
|
|
if !proc_res.status.success() {
|
|
fatal_proc_rec("compilation failed!", &proc_res);
|
|
}
|
|
|
|
proc_res = extract_function_from_bitcode(config, props, "test", testfile, "clang");
|
|
if !proc_res.status.success() {
|
|
fatal_proc_rec("extracting 'test' function failed",
|
|
&proc_res);
|
|
}
|
|
|
|
proc_res = disassemble_extract(config, props, testfile, "clang");
|
|
if !proc_res.status.success() {
|
|
fatal_proc_rec("disassembling extract failed", &proc_res);
|
|
}
|
|
|
|
let base = output_base_name(config, testfile);
|
|
let base_extract = append_suffix_to_stem(&base, "extract");
|
|
|
|
let base_clang = append_suffix_to_stem(&base, "clang");
|
|
let base_clang_extract = append_suffix_to_stem(&base_clang, "extract");
|
|
|
|
let base_lines = count_extracted_lines(&base_extract);
|
|
let clang_lines = count_extracted_lines(&base_clang_extract);
|
|
|
|
mm.insert_metric("clang-codegen-ratio",
|
|
(base_lines as f64) / (clang_lines as f64),
|
|
0.001);
|
|
}
|