---

yaml
---
r: 85999
b: refs/heads/dist-snap
c: ba5f101
h: refs/heads/master
i:
  85997: d43647b
  85995: f42d827
  85991: f0567b5
  85983: 6642fa3
v: v3

Author: luqmana

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 0983ebe5310d4eb6d289f636f7ed0536c08bbc0e
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 6655b3c4620714e1a043be3b47f581719cefa12d
+refs/heads/dist-snap: ba5f101fa9fd426d673868ebb903a709528a66d1
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libextra/json.rs

@@ -1,4 +1,4 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -1164,9 +1164,6 @@ impl Ord for Json {
             }
         }
     }
-    fn le(&self, other: &Json) -> bool { !(*other).lt(&(*self)) }
-    fn ge(&self, other: &Json) -> bool { !(*self).lt(other) }
-    fn gt(&self, other: &Json) -> bool { (*other).lt(&(*self))  }
 }
 
 /// A trait for converting values to JSON

branches/dist-snap/src/libextra/semver.rs

@@ -1,4 +1,4 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -37,18 +37,6 @@ impl cmp::Ord for Identifier {
             (&AlphaNumeric(_), _) => false
         }
     }
-    #[inline]
-    fn le(&self, other: &Identifier) -> bool {
-        ! (other < self)
-    }
-    #[inline]
-    fn gt(&self, other: &Identifier) -> bool {
-        other < self
-    }
-    #[inline]
-    fn ge(&self, other: &Identifier) -> bool {
-        ! (self < other)
-    }
 }
 
 impl ToStr for Identifier {

branches/dist-snap/src/librustc/back/link.rs

@@ -216,7 +216,7 @@ pub mod write {
     use lib;
 
     use std::c_str::ToCStr;
-    use std::libc::c_uint;
+    use std::libc::{c_uint, c_int};
     use std::path::Path;
     use std::run;
     use std::str;
@@ -257,17 +257,7 @@ pub mod write {
                 }
             }
 
-            // Copy what clan does by turning on loop vectorization at O2 and
-            // slp vectorization at O3
-            let vectorize_loop = !sess.no_vectorize_loops() &&
-                                 (sess.opts.optimize == session::Default ||
-                                  sess.opts.optimize == session::Aggressive);
-            let vectorize_slp = !sess.no_vectorize_slp() &&
-                                sess.opts.optimize == session::Aggressive;
-            llvm::LLVMRustSetLLVMOptions(sess.print_llvm_passes(),
-                                         vectorize_loop,
-                                         vectorize_slp,
-                                         sess.time_llvm_passes());
+            configure_llvm(sess);
 
             let OptLevel = match sess.opts.optimize {
               session::No => lib::llvm::CodeGenLevelNone,
@@ -293,12 +283,9 @@ pub mod write {
             // Create the two optimizing pass managers. These mirror what clang
             // does, and are by populated by LLVM's default PassManagerBuilder.
             // Each manager has a different set of passes, but they also share
-            // some common passes. Each one is initialized with the analyis
-            // passes the target requires, and then further passes are added.
+            // some common passes.
             let fpm = llvm::LLVMCreateFunctionPassManagerForModule(llmod);
             let mpm = llvm::LLVMCreatePassManager();
-            llvm::LLVMRustAddAnalysisPasses(tm, fpm, llmod);
-            llvm::LLVMRustAddAnalysisPasses(tm, mpm, llmod);
 
             // If we're verifying or linting, add them to the function pass
             // manager.
@@ -308,32 +295,11 @@ pub mod write {
             if !sess.no_verify() { assert!(addpass("verify")); }
             if sess.lint_llvm()  { assert!(addpass("lint"));   }
 
-            // Create the PassManagerBuilder for LLVM. We configure it with
-            // reasonable defaults and prepare it to actually populate the pass
-            // manager.
-            let builder = llvm::LLVMPassManagerBuilderCreate();
-            match sess.opts.optimize {
-                session::No => {
-                    // Don't add lifetime intrinsics add O0
-                    llvm::LLVMRustAddAlwaysInlinePass(builder, false);
-                }
-                // numeric values copied from clang
-                session::Less => {
-                    llvm::LLVMPassManagerBuilderUseInlinerWithThreshold(builder,
-                                                                        225);
-                }
-                session::Default | session::Aggressive => {
-                    llvm::LLVMPassManagerBuilderUseInlinerWithThreshold(builder,
-                                                                        275);
-                }
+            if !sess.no_prepopulate_passes() {
+                llvm::LLVMRustAddAnalysisPasses(tm, fpm, llmod);
+                llvm::LLVMRustAddAnalysisPasses(tm, mpm, llmod);
+                populate_llvm_passess(fpm, mpm, llmod, OptLevel);
             }
-            llvm::LLVMPassManagerBuilderSetOptLevel(builder, OptLevel as c_uint);
-            llvm::LLVMRustAddBuilderLibraryInfo(builder, llmod);
-
-            // Use the builder to populate the function/module pass managers.
-            llvm::LLVMPassManagerBuilderPopulateFunctionPassManager(builder, fpm);
-            llvm::LLVMPassManagerBuilderPopulateModulePassManager(builder, mpm);
-            llvm::LLVMPassManagerBuilderDispose(builder);
 
             for pass in sess.opts.custom_passes.iter() {
                 do pass.with_c_str |s| {
@@ -424,6 +390,74 @@ pub mod write {
             sess.abort_if_errors();
         }
     }
+
+    unsafe fn configure_llvm(sess: Session) {
+        // Copy what clan does by turning on loop vectorization at O2 and
+        // slp vectorization at O3
+        let vectorize_loop = !sess.no_vectorize_loops() &&
+                             (sess.opts.optimize == session::Default ||
+                              sess.opts.optimize == session::Aggressive);
+        let vectorize_slp = !sess.no_vectorize_slp() &&
+                            sess.opts.optimize == session::Aggressive;
+
+        let mut llvm_c_strs = ~[];
+        let mut llvm_args = ~[];
+        let add = |arg: &str| {
+            let s = arg.to_c_str();
+            llvm_args.push(s.with_ref(|p| p));
+            llvm_c_strs.push(s);
+        };
+        add("rustc"); // fake program name
+        add("-arm-enable-ehabi");
+        add("-arm-enable-ehabi-descriptors");
+        if vectorize_loop { add("-vectorize-loops"); }
+        if vectorize_slp  { add("-vectorize-slp");   }
+        if sess.time_llvm_passes() { add("-time-passes"); }
+        if sess.print_llvm_passes() { add("-debug-pass=Structure"); }
+
+        for arg in sess.opts.llvm_args.iter() {
+            add(*arg);
+        }
+
+        do llvm_args.as_imm_buf |p, len| {
+            llvm::LLVMRustSetLLVMOptions(len as c_int, p);
+        }
+    }
+
+    unsafe fn populate_llvm_passess(fpm: lib::llvm::PassManagerRef,
+                                    mpm: lib::llvm::PassManagerRef,
+                                    llmod: ModuleRef,
+                                    opt: lib::llvm::CodeGenOptLevel) {
+        // Create the PassManagerBuilder for LLVM. We configure it with
+        // reasonable defaults and prepare it to actually populate the pass
+        // manager.
+        let builder = llvm::LLVMPassManagerBuilderCreate();
+        match opt {
+            lib::llvm::CodeGenLevelNone => {
+                // Don't add lifetime intrinsics add O0
+                llvm::LLVMRustAddAlwaysInlinePass(builder, false);
+            }
+            lib::llvm::CodeGenLevelLess => {
+                llvm::LLVMRustAddAlwaysInlinePass(builder, true);
+            }
+            // numeric values copied from clang
+            lib::llvm::CodeGenLevelDefault => {
+                llvm::LLVMPassManagerBuilderUseInlinerWithThreshold(builder,
+                                                                    225);
+            }
+            lib::llvm::CodeGenLevelAggressive => {
+                llvm::LLVMPassManagerBuilderUseInlinerWithThreshold(builder,
+                                                                    275);
+            }
+        }
+        llvm::LLVMPassManagerBuilderSetOptLevel(builder, opt as c_uint);
+        llvm::LLVMRustAddBuilderLibraryInfo(builder, llmod);
+
+        // Use the builder to populate the function/module pass managers.
+        llvm::LLVMPassManagerBuilderPopulateFunctionPassManager(builder, fpm);
+        llvm::LLVMPassManagerBuilderPopulateModulePassManager(builder, mpm);
+        llvm::LLVMPassManagerBuilderDispose(builder);
+    }
 }
 
 

branches/dist-snap/src/librustc/driver/driver.rs

@@ -737,13 +737,22 @@ pub fn build_session_options(binary: @str,
             }).collect()
         }
     };
+    let llvm_args = match getopts::opt_maybe_str(matches, "llvm-args") {
+        None => ~[],
+        Some(s) => {
+            s.split_iter(|c: char| c == ' ' || c == ',').map(|s| {
+                s.trim().to_owned()
+            }).collect()
+        }
+    };
 
     let sopts = @session::options {
         crate_type: crate_type,
         is_static: statik,
         gc: gc,
         optimize: opt_level,
         custom_passes: custom_passes,
+        llvm_args: llvm_args,
         debuginfo: debuginfo,
         extra_debuginfo: extra_debuginfo,
         lint_opts: lint_opts,
@@ -851,6 +860,8 @@ pub fn optgroups() -> ~[getopts::groups::OptGroup] {
                         Appends to the default list of passes to run for the \
                         specified current optimization level. A value of \
                         \"list\" will list all of the available passes", "NAMES"),
+  optopt("", "llvm-args", "A list of arguments to pass to llvm, comma \
+                           separated", "ARGS"),
   optopt( "",  "out-dir",
                         "Write output to compiler-chosen filename
                           in <dir>", "DIR"),

branches/dist-snap/src/librustc/driver/session.rs

@@ -79,6 +79,7 @@ pub static once_fns:                uint = 1 << 26;
 pub static print_llvm_passes:       uint = 1 << 27;
 pub static no_vectorize_loops:      uint = 1 << 28;
 pub static no_vectorize_slp:        uint = 1 << 29;
+pub static no_prepopulate_passes:   uint = 1 << 30;
 
 pub fn debugging_opts_map() -> ~[(~str, ~str, uint)] {
     ~[(~"verbose", ~"in general, enable more debug printouts", verbose),
@@ -126,6 +127,10 @@ pub fn debugging_opts_map() -> ~[(~str, ~str, uint)] {
      (~"print-llvm-passes",
       ~"Prints the llvm optimization passes being run",
       print_llvm_passes),
+     (~"no-prepopulate-passes",
+      ~"Don't pre-populate the pass managers with a list of passes, only use \
+        the passes from --passes",
+      no_prepopulate_passes),
      (~"no-vectorize-loops",
       ~"Don't run the loop vectorization optimization passes",
       no_vectorize_loops),
@@ -152,6 +157,7 @@ pub struct options {
     gc: bool,
     optimize: OptLevel,
     custom_passes: ~[~str],
+    llvm_args: ~[~str],
     debuginfo: bool,
     extra_debuginfo: bool,
     lint_opts: ~[(lint::lint, lint::level)],
@@ -320,6 +326,9 @@ impl Session_ {
     pub fn print_llvm_passes(@self) -> bool {
         self.debugging_opt(print_llvm_passes)
     }
+    pub fn no_prepopulate_passes(@self) -> bool {
+        self.debugging_opt(no_prepopulate_passes)
+    }
     pub fn no_vectorize_loops(@self) -> bool {
         self.debugging_opt(no_vectorize_loops)
     }
@@ -351,6 +360,7 @@ pub fn basic_options() -> @options {
         gc: false,
         optimize: No,
         custom_passes: ~[],
+        llvm_args: ~[],
         debuginfo: false,
         extra_debuginfo: false,
         lint_opts: ~[],

branches/dist-snap/src/librustc/lib/llvm.rs

@@ -191,6 +191,7 @@ pub enum AsmDialect {
     AD_Intel = 1
 }
 
+#[deriving(Eq)]
 pub enum CodeGenOptLevel {
     CodeGenLevelNone = 0,
     CodeGenLevelLess = 1,
@@ -2123,10 +2124,7 @@ pub mod llvm {
         pub fn LLVMRustPrintModule(PM: PassManagerRef,
                                    M: ModuleRef,
                                    Output: *c_char);
-        pub fn LLVMRustSetLLVMOptions(PrintPasses: bool,
-                                      VectorizeLoops: bool,
-                                      VectorizeSLP: bool,
-                                      TimePasses: bool);
+        pub fn LLVMRustSetLLVMOptions(Argc: c_int, Argv: **c_char);
         pub fn LLVMRustPrintPasses();
         pub fn LLVMRustSetNormalizedTarget(M: ModuleRef, triple: *c_char);
         pub fn LLVMRustAddAlwaysInlinePass(P: PassManagerBuilderRef,

branches/dist-snap/src/librustc/middle/kind.rs

@@ -129,7 +129,7 @@ fn check_impl_of_trait(cx: Context, it: @item, trait_ref: &trait_ref, self_type:
 
     // If this trait has builtin-kind supertraits, meet them.
     let self_ty: ty::t = ty::node_id_to_type(cx.tcx, it.id);
-    error!("checking impl with self type %?", ty::get(self_ty).sty);
+    debug!("checking impl with self type %?", ty::get(self_ty).sty);
     do check_builtin_bounds(cx, self_ty, trait_def.bounds) |missing| {
         cx.tcx.sess.span_err(self_type.span,
             fmt!("the type `%s', which does not fulfill `%s`, cannot implement this \

branches/dist-snap/src/librustc/middle/trans/base.rs

@@ -2453,10 +2453,16 @@ pub fn item_path(ccx: &CrateContext, id: &ast::NodeId) -> path {
 }
 
 fn exported_name(ccx: @mut CrateContext, path: path, ty: ty::t, attrs: &[ast::Attribute]) -> ~str {
-    if attr::contains_name(attrs, "no_mangle") {
-        path_elt_to_str(*path.last(), token::get_ident_interner())
-    } else {
-        mangle_exported_name(ccx, path, ty)
+    match attr::first_attr_value_str_by_name(attrs, "export_name") {
+        // Use provided name
+        Some(name) => name.to_owned(),
+
+        // Don't mangle
+        _ if attr::contains_name(attrs, "no_mangle")
+            => path_elt_to_str(*path.last(), token::get_ident_interner()),
+
+        // Usual name mangling
+        _ => mangle_exported_name(ccx, path, ty)
     }
 }
 

branches/dist-snap/src/librustc/middle/trans/reflect.rs

@@ -252,8 +252,8 @@ impl Reflector {
               let tcx = bcx.ccx().tcx;
               let fields = ty::struct_fields(tcx, did, substs);
 
-              let extra = ~[self.c_slice(ty_to_str(tcx, t).to_managed()),
-                            self.c_uint(fields.len())] + self.c_size_and_align(t);
+              let extra = ~[self.c_uint(fields.len())]
+                  + self.c_size_and_align(t);
               do self.bracketed("class", extra) |this| {
                   for (i, field) in fields.iter().enumerate() {
                       let extra = ~[this.c_uint(i),