---

yaml
---
r: 209341
b: refs/heads/auto
c: d957e04
h: refs/heads/master
i:
  209339: 5f8a852
v: v3

Author: eddyb

[refs]

@@ -10,7 +10,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: f56782ab9c8d0f64b9a714cc24d925a81ac3211b
+refs/heads/auto: d957e04d0160953d73112dbfb9a6ee3e01d7653b
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/mk/tests.mk

@@ -581,6 +581,10 @@ ifeq ($(CFG_LLDB),)
 CTEST_DISABLE_debuginfo-lldb = "no lldb found"
 endif
 
+ifeq ($(CFG_CLANG),)
+CTEST_DISABLE_codegen = "no clang found"
+endif
+
 ifneq ($(CFG_OSTYPE),apple-darwin)
 CTEST_DISABLE_debuginfo-lldb = "lldb tests are only run on darwin"
 endif
@@ -641,6 +645,7 @@ CTEST_COMMON_ARGS$(1)-T-$(2)-H-$(3) := \
         --run-lib-path $$(TLIB$(1)_T_$(2)_H_$(3)) \
         --rustc-path $$(HBIN$(1)_H_$(3))/rustc$$(X_$(3)) \
         --rustdoc-path $$(HBIN$(1)_H_$(3))/rustdoc$$(X_$(3)) \
+        --clang-path $(if $(CFG_CLANG),$(CFG_CLANG),clang) \
         --llvm-bin-path $(CFG_LLVM_INST_DIR_$(CFG_BUILD))/bin \
         --aux-base $$(S)src/test/auxiliary/ \
         --stage-id stage$(1)-$(2) \

branches/auto/src/compiletest/common.rs

@@ -80,6 +80,9 @@ pub struct Config {
     // The python executable
     pub python: String,
 
+    // The clang executable
+    pub clang_path: Option<PathBuf>,
+
     // The llvm binaries path
     pub llvm_bin_path: Option<PathBuf>,
 

branches/auto/src/compiletest/compiletest.rs

@@ -33,7 +33,7 @@ use std::fs;
 use std::path::{Path, PathBuf};
 use getopts::{optopt, optflag, reqopt};
 use common::Config;
-use common::{Pretty, DebugInfoGdb, DebugInfoLldb};
+use common::{Pretty, DebugInfoGdb, DebugInfoLldb, Codegen};
 use util::logv;
 
 pub mod procsrv;
@@ -63,6 +63,7 @@ pub fn parse_config(args: Vec<String> ) -> Config {
           reqopt("", "rustc-path", "path to rustc to use for compiling", "PATH"),
           reqopt("", "rustdoc-path", "path to rustdoc to use for compiling", "PATH"),
           reqopt("", "python", "path to python to use for doc tests", "PATH"),
+          optopt("", "clang-path", "path to  executable for codegen tests", "PATH"),
           optopt("", "valgrind-path", "path to Valgrind executable for Valgrind tests", "PROGRAM"),
           optflag("", "force-valgrind", "fail if Valgrind tests cannot be run under Valgrind"),
           optopt("", "llvm-bin-path", "path to directory holding llvm binaries", "DIR"),
@@ -132,6 +133,7 @@ pub fn parse_config(args: Vec<String> ) -> Config {
         rustc_path: opt_path(matches, "rustc-path"),
         rustdoc_path: opt_path(matches, "rustdoc-path"),
         python: matches.opt_str("python").unwrap(),
+        clang_path: matches.opt_str("clang-path").map(|s| PathBuf::from(&s)),
         valgrind_path: matches.opt_str("valgrind-path"),
         force_valgrind: matches.opt_present("force-valgrind"),
         llvm_bin_path: matches.opt_str("llvm-bin-path").map(|s| PathBuf::from(&s)),
@@ -282,7 +284,13 @@ pub fn make_tests(config: &Config) -> Vec<test::TestDescAndFn> {
         let file = file.unwrap().path();
         debug!("inspecting file {:?}", file.display());
         if is_test(config, &file) {
-            tests.push(make_test(config, &file))
+            let t = make_test(config, &file, || {
+                match config.mode {
+                    Codegen => make_metrics_test_closure(config, &file),
+                    _ => make_test_closure(config, &file)
+                }
+            });
+            tests.push(t)
         }
     }
     tests
@@ -315,15 +323,16 @@ pub fn is_test(config: &Config, testfile: &Path) -> bool {
     return valid;
 }
 
-pub fn make_test(config: &Config, testfile: &Path) -> test::TestDescAndFn
+pub fn make_test<F>(config: &Config, testfile: &Path, f: F) -> test::TestDescAndFn where
+    F: FnOnce() -> test::TestFn,
 {
     test::TestDescAndFn {
         desc: test::TestDesc {
             name: make_test_name(config, testfile),
             ignore: header::is_test_ignored(config, testfile),
             should_panic: test::ShouldPanic::No,
         },
-        testfn: make_test_closure(config, &testfile),
+        testfn: f(),
     }
 }
 
@@ -348,6 +357,14 @@ pub fn make_test_closure(config: &Config, testfile: &Path) -> test::TestFn {
     }))
 }
 
+pub fn make_metrics_test_closure(config: &Config, testfile: &Path) -> test::TestFn {
+    let config = (*config).clone();
+    let testfile = testfile.to_path_buf();
+    test::DynMetricFn(box move |mm: &mut test::MetricMap| {
+        runtest::run_metrics(config, &testfile, mm)
+    })
+}
+
 fn extract_gdb_version(full_version_line: Option<String>) -> Option<String> {
     match full_version_line {
         Some(ref full_version_line)

branches/auto/src/compiletest/runtest.rs

@@ -28,6 +28,8 @@ use std::iter::repeat;
 use std::net::TcpStream;
 use std::path::{Path, PathBuf};
 use std::process::{Command, Output, ExitStatus};
+use std::str;
+use test::MetricMap;
 
 pub fn run(config: Config, testfile: &Path) {
     match &*config.target {
@@ -41,6 +43,11 @@ pub fn run(config: Config, testfile: &Path) {
         _=> { }
     }
 
+    let mut _mm = MetricMap::new();
+    run_metrics(config, testfile, &mut _mm);
+}
+
+pub fn run_metrics(config: Config, testfile: &Path, mm: &mut MetricMap) {
     if config.verbose {
         // We're going to be dumping a lot of info. Start on a new line.
         print!("\n\n");
@@ -57,7 +64,7 @@ pub fn run(config: Config, testfile: &Path) {
         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),
+        Codegen => run_codegen_test(&config, &props, &testfile, mm),
         Rustdoc => run_rustdoc_test(&config, &props, &testfile),
     }
 }
@@ -1678,15 +1685,26 @@ fn _arm_push_aux_shared_library(config: &Config, testfile: &Path) {
     }
 }
 
-// codegen tests (using FileCheck)
+// codegen tests (vs. clang)
+
+fn append_suffix_to_stem(p: &Path, suffix: &str) -> PathBuf {
+    if suffix.is_empty() {
+        p.to_path_buf()
+    } else {
+        let mut stem = p.file_stem().unwrap().to_os_string();
+        stem.push("-");
+        stem.push(suffix);
+        p.with_file_name(&stem)
+    }
+}
 
-fn compile_test_and_save_ir(config: &Config, props: &TestProps,
+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.to_str().unwrap().to_string());
-    let llvm_args = vec!("--emit=llvm-ir".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,
@@ -1699,34 +1717,121 @@ fn compile_test_and_save_ir(config: &Config, props: &TestProps,
     compose_and_run_compiler(config, props, testfile, args, None)
 }
 
-fn check_ir_with_filecheck(config: &Config, testfile: &Path) -> ProcRes {
-    let irfile = output_base_name(config, testfile).with_extension("ll");
-    let prog = config.llvm_bin_path.as_ref().unwrap().join("FileCheck");
+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().to_str().unwrap().to_string(),
+        args: vec!("-c".to_string(),
+                   "-emit-llvm".to_string(),
+                   "-o".to_string(),
+                   bitcodefile.to_str().unwrap().to_string(),
+                   testcc.to_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.to_str().unwrap().to_string(),
-        args: vec!(format!("-input-file={}", irfile.to_str().unwrap()),
-                   testfile.to_str().unwrap().to_string())
+        args: vec!(format!("-func={}", fname),
+                   format!("-o={}", extracted_bc.to_str().unwrap()),
+                   bitcodefile.to_str().unwrap().to_string())
     };
     compose_and_run(config, testfile, proc_args, Vec::new(), "", None, None)
 }
 
-fn run_codegen_test(config: &Config, props: &TestProps, testfile: &Path) {
+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.to_str().unwrap().to_string(),
+        args: vec!(format!("-o={}", extracted_ll.to_str().unwrap()),
+                   extracted_bc.to_str().unwrap().to_string())
+    };
+    compose_and_run(config, testfile, proc_args, Vec::new(), "", None, None)
+}
+
+
+fn count_extracted_lines(p: &Path) -> usize {
+    let mut x = Vec::new();
+    File::open(&p.with_extension("ll")).unwrap().read_to_end(&mut x).unwrap();
+    let x = str::from_utf8(&x).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");
     }
 
-    let mut proc_res = compile_test_and_save_ir(config, props, testfile);
+    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 = check_ir_with_filecheck(config, testfile);
+    proc_res = extract_function_from_bitcode(config, props, "test", testfile, "clang");
     if !proc_res.status.success() {
-        fatal_proc_rec("verification with 'FileCheck' failed",
+        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);
 }
 
 fn charset() -> &'static str {

branches/auto/src/doc/trpl/macros.md

@@ -478,7 +478,7 @@ There are additional rules regarding the next token after a metavariable:
 
 * `expr` variables may only be followed by one of: `=> , ;`
 * `ty` and `path` variables may only be followed by one of: `=> , : = > as`
-* `pat` variables may only be followed by one of: `=> , = if in`
+* `pat` variables may only be followed by one of: `=> , =`
 * Other variables may be followed by any token.
 
 These rules provide some flexibility for Rust’s syntax to evolve without