---

yaml
---
r: 151034
b: refs/heads/try2
c: fe47202
h: refs/heads/master
v: v3

Author: brendanzab

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 696f16ec2e54e8563702b1cdbbaaa1877562aa60
+refs/heads/try2: fe472020347d8eeb727f3a31e9cdc7268bb579f6
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/configure

@@ -388,7 +388,6 @@ opt ccache 0 "invoke gcc/clang via ccache to reuse object files between builds"
 opt local-rust 0 "use an installed rustc rather than downloading a snapshot"
 opt pax-flags 0 "apply PaX flags to rustc binaries (required for GRSecurity/PaX-patched kernels)"
 opt inject-std-version 1 "inject the current compiler version of libstd into programs"
-opt llvm-static-stdcpp 0 "statically link to libstdc++ for LLVM"
 opt rpath 1 "build rpaths into rustc itself"
 opt nightly 0 "build nightly packages"
 opt verify-install 1 "verify installed binaries work"
@@ -580,32 +579,26 @@ then
         CFG_ENABLE_CLANG=1
         putvar CFG_ENABLE_CLANG
     else
-        if [ $("$CFG_GCC" --version 2>&1 | grep -c ' 4\.[0-6]') -ne 0 ]; then
-            step_msg "older GCC found, using clang instead"
-            CFG_ENABLE_CLANG=1
-            putvar CFG_ENABLE_CLANG
-        else
-            # on OS X, with xcode 5 and newer, certain developers may have
-            # cc, gcc and g++ point to a  mixture of clang and gcc
-            # if so, this will create very strange build errors
-            # this last stanza is to detect some such problems and save the future rust
-            # contributor some time solving that issue.
-            # this detection could be generalized to other OSes aside from OS X
-            # but the issue seems most likely to happen on OS X
-
-            chk_cc () {
-                $1 --version 2> /dev/null | grep -q $2
-            }
-            # check that gcc, cc and g++ all point to the same compiler.
-            # note that for xcode 5, g++ points to clang, not clang++
-            if !((chk_cc gcc clang  && chk_cc g++ clang) ||
-                (chk_cc gcc gcc  &&( chk_cc g++ g++ || chk g++ gcc))) then
-                err "the gcc and g++ in your path point to different compilers.
-    Check which versions are in your path with  cc --version and g++ --version.
-    To resolve this problem, either fix your PATH  or run configure with --enable-clang"
-            fi
-
+        # on OS X, with xcode 5 and newer, certain developers may have
+        # cc, gcc and g++ point to a  mixture of clang and gcc
+        # if so, this will create very strange build errors
+        # this last stanza is to detect some such problems and save the future rust
+        # contributor some time solving that issue.
+        # this detection could be generalized to other OSes aside from OS X
+        # but the issue seems most likely to happen on OS X
+
+        chk_cc () {
+            $1 --version 2> /dev/null | grep -q $2
+        }
+        # check that gcc, cc and g++ all point to the same compiler.
+        # note that for xcode 5, g++ points to clang, not clang++
+        if !((chk_cc gcc clang  && chk_cc g++ clang) ||
+            (chk_cc gcc gcc  &&( chk_cc g++ g++ || chk g++ gcc))) then
+            err "the gcc and g++ in your path point to different compilers.
+Check which versions are in your path with  cc --version and g++ --version.
+To resolve this problem, either fix your PATH  or run configure with --enable-clang"
         fi
+
     fi
 fi
 
@@ -928,6 +921,10 @@ do
         LLVM_OPTS="$LLVM_OPTS --disable-terminfo"
         # Try to have LLVM pull in as few dependencies as possible (#9397)
         LLVM_OPTS="$LLVM_OPTS --disable-zlib --disable-libffi"
+        # LLVM says it needs a "new" clang/gcc, but we seem to get by ok with
+        # older versions on the bots. Get by for a little longer by asking it to
+        # not do version detection
+        LLVM_OPTS="$LLVM_OPTS --disable-compiler-version-checks"
 
         # Use win32 native thread/lock apis instead of pthread wrapper.
         # (llvm's configure tries to find pthread first, so we have to disable it explicitly.)
@@ -945,15 +942,13 @@ do
 
             LLVM_CXX_64="ccache clang++ -Qunused-arguments"
             LLVM_CC_64="ccache clang -Qunused-arguments"
-            LLVM_OPTS="$LLVM_OPTS --enable-libcpp"
             ;;
             ("clang")
             LLVM_CXX_32="clang++ -m32 -Qunused-arguments"
             LLVM_CC_32="clang -m32 -Qunused-arguments"
 
             LLVM_CXX_64="clang++ -Qunused-arguments"
             LLVM_CC_64="clang -Qunused-arguments"
-            LLVM_OPTS="$LLVM_OPTS --enable-libcpp"
             ;;
             ("ccache gcc")
             LLVM_CXX_32="ccache g++ -m32"

branches/try2/mk/llvm.mk

@@ -42,25 +42,16 @@ $$(LLVM_STAMP_$(1)): $(S)src/rustllvm/llvm-auto-clean-trigger
 	@$$(call E, make: done cleaning llvm)
 	touch $$@
 
-ifeq ($$(CFG_ENABLE_LLVM_STATIC_STDCPP),1)
-LLVM_STDCPP_LOCATION_$(1) = $$(shell $$(CC_$(1)) $$(CFG_GCCISH_CFLAGS_$(1)) \
-					-print-file-name=libstdc++.a)
-else
-LLVM_STDCPP_LOCATION_$(1) =
-endif
-
 endef
 
 $(foreach host,$(CFG_HOST), \
- $(eval $(call DEF_LLVM_RULES,$(host))))
+    $(eval LLVM_CONFIGS := $(LLVM_CONFIGS) $(LLVM_CONFIG_$(host))))
 
 $(foreach host,$(CFG_HOST), \
- $(eval LLVM_CONFIGS := $(LLVM_CONFIGS) $(LLVM_CONFIG_$(host))))
+ $(eval $(call DEF_LLVM_RULES,$(host))))
 
 $(S)src/librustc/lib/llvmdeps.rs: \
 		    $(LLVM_CONFIGS) \
-		    $(S)src/etc/mklldeps.py \
-		    $(MKFILE_DEPS)
+		    $(S)src/etc/mklldeps.py
 	$(Q)$(CFG_PYTHON) $(S)src/etc/mklldeps.py \
-		"$@" "$(LLVM_COMPONENTS)" "$(CFG_ENABLE_LLVM_STATIC_STDCPP)" \
-		$(LLVM_CONFIGS)
+	    "$@" "$(LLVM_COMPONENTS)" $(LLVM_CONFIGS)

branches/try2/mk/platform.mk

@@ -542,17 +542,14 @@ ifdef CFG_CCACHE_BASEDIR
   export CCACHE_BASEDIR
 endif
 
-FIND_COMPILER = $(word 1,$(1:ccache=))
-
 define CFG_MAKE_TOOLCHAIN
   # Prepend the tools with their prefix if cross compiling
   ifneq ($(CFG_BUILD),$(1))
 	CC_$(1)=$(CROSS_PREFIX_$(1))$(CC_$(1))
 	CXX_$(1)=$(CROSS_PREFIX_$(1))$(CXX_$(1))
 	CPP_$(1)=$(CROSS_PREFIX_$(1))$(CPP_$(1))
 	AR_$(1)=$(CROSS_PREFIX_$(1))$(AR_$(1))
-	RUSTC_CROSS_FLAGS_$(1)=-C linker=$$(call FIND_COMPILER,$$(CXX_$(1))) \
-	    -C ar=$$(call FIND_COMPILER,$$(AR_$(1))) $(RUSTC_CROSS_FLAGS_$(1))
+	RUSTC_CROSS_FLAGS_$(1)=-C linker=$$(CXX_$(1)) -C ar=$$(AR_$(1)) $(RUSTC_CROSS_FLAGS_$(1))
 
 	RUSTC_FLAGS_$(1)=$$(RUSTC_CROSS_FLAGS_$(1)) $(RUSTC_FLAGS_$(1))
   endif

branches/try2/mk/target.mk

@@ -83,7 +83,6 @@ $$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$(4):				    \
 		$$(WFLAGS_ST$(1)) \
 		-L "$$(RT_OUTPUT_DIR_$(2))" \
 		-L "$$(LLVM_LIBDIR_$(2))" \
-		-L "$$(dir $$(LLVM_STDCPP_LOCATION_$(2)))" \
 		--out-dir $$(@D) $$<
 	@touch $$@
 	$$(call LIST_ALL_OLD_GLOB_MATCHES,\

branches/try2/src/compiletest/compiletest.rs

@@ -93,7 +93,7 @@ pub fn parse_config(args: Vec<~str> ) -> config {
     assert!(!args.is_empty());
     let argv0 = (*args.get(0)).clone();
     let args_ = args.tail();
-    if *args.get(1) == "-h".to_owned() || *args.get(1) == "--help".to_owned() {
+    if *args.get(1) == ~"-h" || *args.get(1) == ~"--help" {
         let message = format!("Usage: {} [OPTIONS] [TESTNAME...]", argv0);
         println!("{}", getopts::usage(message, groups.as_slice()));
         println!("");
@@ -181,7 +181,7 @@ pub fn log_config(config: &config) {
     logv(c, format!("adb_test_dir: {}", config.adb_test_dir));
     logv(c, format!("adb_device_status: {}", config.adb_device_status));
     match config.test_shard {
-        None => logv(c, "test_shard: (all)".to_owned()),
+        None => logv(c, ~"test_shard: (all)"),
         Some((a,b)) => logv(c, format!("test_shard: {}.{}", a, b))
     }
     logv(c, format!("verbose: {}", config.verbose));
@@ -199,7 +199,7 @@ pub fn opt_str<'a>(maybestr: &'a Option<~str>) -> &'a str {
 }
 
 pub fn opt_str2(maybestr: Option<~str>) -> ~str {
-    match maybestr { None => "(none)".to_owned(), Some(s) => { s } }
+    match maybestr { None => ~"(none)", Some(s) => { s } }
 }
 
 pub fn str_mode(s: ~str) -> mode {
@@ -216,17 +216,17 @@ pub fn str_mode(s: ~str) -> mode {
 
 pub fn mode_str(mode: mode) -> ~str {
     match mode {
-      mode_compile_fail => "compile-fail".to_owned(),
-      mode_run_fail => "run-fail".to_owned(),
-      mode_run_pass => "run-pass".to_owned(),
-      mode_pretty => "pretty".to_owned(),
-      mode_debug_info => "debug-info".to_owned(),
-      mode_codegen => "codegen".to_owned(),
+      mode_compile_fail => ~"compile-fail",
+      mode_run_fail => ~"run-fail",
+      mode_run_pass => ~"run-pass",
+      mode_pretty => ~"pretty",
+      mode_debug_info => ~"debug-info",
+      mode_codegen => ~"codegen",
     }
 }
 
 pub fn run_tests(config: &config) {
-    if config.target == "arm-linux-androideabi".to_owned() {
+    if config.target == ~"arm-linux-androideabi" {
         match config.mode{
             mode_debug_info => {
                 println!("arm-linux-androideabi debug-info \
@@ -296,10 +296,10 @@ pub fn is_test(config: &config, testfile: &Path) -> bool {
     // Pretty-printer does not work with .rc files yet
     let valid_extensions =
         match config.mode {
-          mode_pretty => vec!(".rs".to_owned()),
-          _ => vec!(".rc".to_owned(), ".rs".to_owned())
+          mode_pretty => vec!(~".rs"),
+          _ => vec!(~".rc", ~".rs")
         };
-    let invalid_prefixes = vec!(".".to_owned(), "#".to_owned(), "~".to_owned());
+    let invalid_prefixes = vec!(~".", ~"#", ~"~");
     let name = testfile.filename_str().unwrap();
 
     let mut valid = false;

branches/try2/src/compiletest/errors.rs

@@ -31,7 +31,7 @@ pub fn load_errors(testfile: &Path) -> Vec<ExpectedError> {
 
 fn parse_expected(line_num: uint, line: ~str) -> Vec<ExpectedError> {
     let line = line.trim();
-    let error_tag = "//~".to_owned();
+    let error_tag = ~"//~";
     let mut idx;
     match line.find_str(error_tag) {
       None => return Vec::new(),

branches/try2/src/compiletest/header.rs

@@ -17,8 +17,6 @@ pub struct TestProps {
     pub error_patterns: Vec<~str> ,
     // Extra flags to pass to the compiler
     pub compile_flags: Option<~str>,
-    // Extra flags to pass when the compiled code is run (such as --bench)
-    pub run_flags: Option<~str>,
     // If present, the name of a file that this test should match when
     // pretty-printed
     pub pp_exact: Option<Path>,
@@ -44,7 +42,6 @@ pub fn load_props(testfile: &Path) -> TestProps {
     let mut aux_builds = Vec::new();
     let mut exec_env = Vec::new();
     let mut compile_flags = None;
-    let mut run_flags = None;
     let mut pp_exact = None;
     let mut debugger_cmds = Vec::new();
     let mut check_lines = Vec::new();
@@ -61,10 +58,6 @@ pub fn load_props(testfile: &Path) -> TestProps {
             compile_flags = parse_compile_flags(ln);
         }
 
-        if run_flags.is_none() {
-            run_flags = parse_run_flags(ln);
-        }
-
         if pp_exact.is_none() {
             pp_exact = parse_pp_exact(ln, testfile);
         }
@@ -103,11 +96,9 @@ pub fn load_props(testfile: &Path) -> TestProps {
 
         true
     });
-
-    TestProps {
+    return TestProps {
         error_patterns: error_patterns,
         compile_flags: compile_flags,
-        run_flags: run_flags,
         pp_exact: pp_exact,
         aux_builds: aux_builds,
         exec_env: exec_env,
@@ -116,15 +107,15 @@ pub fn load_props(testfile: &Path) -> TestProps {
         force_host: force_host,
         check_stdout: check_stdout,
         no_prefer_dynamic: no_prefer_dynamic,
-    }
+    };
 }
 
 pub fn is_test_ignored(config: &config, testfile: &Path) -> bool {
     fn ignore_target(config: &config) -> ~str {
-        "ignore-".to_owned() + util::get_os(config.target)
+        ~"ignore-" + util::get_os(config.target)
     }
     fn ignore_stage(config: &config) -> ~str {
-        "ignore-".to_owned() + config.stage_id.split('-').next().unwrap()
+        ~"ignore-" + config.stage_id.split('-').next().unwrap()
     }
 
     let val = iter_header(testfile, |ln| {
@@ -158,27 +149,23 @@ fn iter_header(testfile: &Path, it: |&str| -> bool) -> bool {
 }
 
 fn parse_error_pattern(line: &str) -> Option<~str> {
-    parse_name_value_directive(line, "error-pattern".to_owned())
+    parse_name_value_directive(line, ~"error-pattern")
 }
 
 fn parse_aux_build(line: &str) -> Option<~str> {
-    parse_name_value_directive(line, "aux-build".to_owned())
+    parse_name_value_directive(line, ~"aux-build")
 }
 
 fn parse_compile_flags(line: &str) -> Option<~str> {
-    parse_name_value_directive(line, "compile-flags".to_owned())
-}
-
-fn parse_run_flags(line: &str) -> Option<~str> {
-    parse_name_value_directive(line, ~"run-flags")
+    parse_name_value_directive(line, ~"compile-flags")
 }
 
 fn parse_debugger_cmd(line: &str) -> Option<~str> {
-    parse_name_value_directive(line, "debugger".to_owned())
+    parse_name_value_directive(line, ~"debugger")
 }
 
 fn parse_check_line(line: &str) -> Option<~str> {
-    parse_name_value_directive(line, "check".to_owned())
+    parse_name_value_directive(line, ~"check")
 }
 
 fn parse_force_host(line: &str) -> bool {
@@ -194,12 +181,12 @@ fn parse_no_prefer_dynamic(line: &str) -> bool {
 }
 
 fn parse_exec_env(line: &str) -> Option<(~str, ~str)> {
-    parse_name_value_directive(line, "exec-env".to_owned()).map(|nv| {
+    parse_name_value_directive(line, ~"exec-env").map(|nv| {
         // nv is either FOO or FOO=BAR
         let mut strs: Vec<~str> = nv.splitn('=', 1).map(|s| s.to_owned()).collect();
 
         match strs.len() {
-          1u => (strs.pop().unwrap(), "".to_owned()),
+          1u => (strs.pop().unwrap(), ~""),
           2u => {
               let end = strs.pop().unwrap();
               (strs.pop().unwrap(), end)
@@ -210,7 +197,7 @@ fn parse_exec_env(line: &str) -> Option<(~str, ~str)> {
 }
 
 fn parse_pp_exact(line: &str, testfile: &Path) -> Option<Path> {
-    match parse_name_value_directive(line, "pp-exact".to_owned()) {
+    match parse_name_value_directive(line, ~"pp-exact") {
       Some(s) => Some(Path::new(s)),
       None => {
         if parse_name_directive(line, "pp-exact") {

branches/try2/src/compiletest/procsrv.rs

@@ -29,7 +29,7 @@ fn target_env(lib_path: &str, prog: &str) -> Vec<(~str, ~str)> {
         (k, new_v)
     }).collect();
     if prog.ends_with("rustc.exe") {
-        new_env.push(("RUST_THREADS".to_owned(), "1".to_owned()));
+        new_env.push((~"RUST_THREADS", ~"1"));
     }
     return new_env;
 }
@@ -49,7 +49,7 @@ fn target_env(lib_path: &str, prog: &str) -> Vec<(~str,~str)> {
     };
     let prev = match env.iter().position(|&(ref k, _)| k.as_slice() == var) {
         Some(i) => env.remove(i).unwrap().val1(),
-        None => "".to_owned(),
+        None => ~"",
     };
     env.push((var.to_owned(), if prev.is_empty() {
         lib_path + ":" + aux_path