---

yaml
---
r: 50798
b: refs/heads/try
c: 01e1798
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 5f13e9ccc2e3328d4cd8ca49f84e6840dd998346
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: f7a2371c176663d59062ec5158f39faecba45768
-refs/heads/try: 3fac7cce8fb3fb50328e2c2051532361d7d25aaf
+refs/heads/try: 01e179840fe57c9d2a574613b0cafce756520894
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/compiletest/runtest.rs

@@ -208,18 +208,19 @@ actual:\n\
                         testfile: &Path, src: ~str) -> ProcRes {
         compose_and_run_compiler(
             config, props, testfile,
-            make_typecheck_args(config, testfile),
+            make_typecheck_args(config, props, testfile),
             Some(src))
     }
 
-    fn make_typecheck_args(config: config, testfile: &Path) -> ProcArgs {
+    fn make_typecheck_args(config: config, props: TestProps, testfile: &Path) -> ProcArgs {
         let prog = config.rustc_path;
         let mut args = ~[~"-",
                          ~"--no-trans", ~"--lib",
                          ~"-L", config.build_base.to_str(),
                          ~"-L",
                          aux_output_dir_name(config, testfile).to_str()];
         args += split_maybe_args(config.rustcflags);
+        args += split_maybe_args(props.compile_flags);
         return ProcArgs {prog: prog.to_str(), args: args};
     }
 }

branches/try/src/libcore/libc.rs

@@ -1221,9 +1221,8 @@ pub mod funcs {
         #[nolink]
         #[abi = "cdecl"]
         pub mod fcntl {
+            use libc::types::os::arch::c95::{c_int, c_char};
             pub extern {
-                use libc::types::os::arch::c95::{c_int, c_char};
-
                 #[link_name = "_open"]
                 unsafe fn open(path: *c_char, oflag: c_int, mode: c_int)
                             -> c_int;
@@ -1562,11 +1561,11 @@ pub mod funcs {
     #[cfg(target_os = "macos")]
     #[cfg(target_os = "freebsd")]
     pub mod bsd44 {
+        use libc::types::common::c95::{c_void};
+        use libc::types::os::arch::c95::{c_char, c_int, c_uint, size_t};
+
         #[abi = "cdecl"]
         pub extern {
-            use libc::types::common::c95::{c_void};
-            use libc::types::os::arch::c95::{c_char, c_int, c_uint, size_t};
-
             unsafe fn sysctl(name: *c_int, namelen: c_uint,
                       oldp: *mut c_void, oldlenp: *mut size_t,
                       newp: *c_void, newlen: size_t) -> c_int;

branches/try/src/libcore/rt/env.rs

@@ -44,4 +44,4 @@ pub fn get() -> &Environment {
 
 extern {
     fn rust_get_rt_env() -> &Environment;
-}
+}

branches/try/src/libcore/rt/sched.rs

@@ -70,7 +70,7 @@ enum CleanupJob {
 
 pub impl Scheduler {
 
-    static fn new(event_loop: ~EventLoopObject) -> Scheduler {
+    static pub fn new(event_loop: ~EventLoopObject) -> Scheduler {
         Scheduler {
             event_loop: event_loop,
             task_queue: WorkQueue::new(),
@@ -296,7 +296,7 @@ pub struct Task {
 }
 
 impl Task {
-    static fn new(stack_pool: &mut StackPool, start: ~fn()) -> Task {
+    static pub fn new(stack_pool: &mut StackPool, start: ~fn()) -> Task {
         // XXX: Putting main into a ~ so it's a thin pointer and can
         // be passed to the spawn function.  Another unfortunate
         // allocation

branches/try/src/libcore/rt/stack.rs

@@ -37,8 +37,7 @@ pub impl StackSegment {
 pub struct StackPool(());
 
 impl StackPool {
-
-    static fn new() -> StackPool { StackPool(()) }
+    static pub fn new() -> StackPool { StackPool(()) }
 
     fn take_segment(&self, min_size: uint) -> StackSegment {
         StackSegment::new(min_size)

branches/try/src/libcore/rt/thread.rs

@@ -20,7 +20,7 @@ struct Thread {
 }
 
 impl Thread {
-    static fn start(main: ~fn()) -> Thread {
+    static pub fn start(main: ~fn()) -> Thread {
         fn substart(main: &fn()) -> *raw_thread {
             unsafe { rust_raw_thread_start(&main) }
         }

branches/try/src/libcore/task/rt.rs

@@ -30,7 +30,7 @@ pub type rust_task = libc::c_void;
 #[allow(non_camel_case_types)] // runtime type
 pub type rust_closure = libc::c_void;
 
-extern {
+pub extern {
     #[rust_stack]
     fn rust_task_yield(task: *rust_task) -> bool;
 

branches/try/src/librustc/back/link.rs

@@ -167,15 +167,18 @@ pub mod write {
     use back::link::{output_type_assembly, output_type_bitcode};
     use back::link::{output_type_exe, output_type_llvm_assembly};
     use back::link::{output_type_object};
+    use back::link::output_type;
     use driver::session::Session;
     use driver::session;
     use lib::llvm::llvm;
     use lib::llvm::{False, True, ModuleRef, mk_pass_manager, mk_target_data};
     use lib;
 
+    use core::prelude::*;
     use core::libc::{c_char, c_int, c_uint};
     use core::path::Path;
     use core::str;
+    use core::run;
 
     pub fn is_object_or_assembly_or_exe(ot: output_type) -> bool {
         if ot == output_type_assembly || ot == output_type_object ||
@@ -185,12 +188,14 @@ pub mod write {
         return false;
     }
 
-    pub fn run_passes(sess: Session, llmod: ModuleRef, output: &Path) {
+    pub fn run_passes(sess: Session, llmod: ModuleRef,
+            output_type: output_type, output: &Path) {
         unsafe {
             let opts = sess.opts;
             if sess.time_llvm_passes() { llvm::LLVMRustEnableTimePasses(); }
             let mut pm = mk_pass_manager();
-            let td = mk_target_data(sess.targ_cfg.target_strs.data_layout);
+            let td = mk_target_data(
+                /*bad*/copy sess.targ_cfg.target_strs.data_layout);
             llvm::LLVMAddTargetData(td.lltd, pm.llpm);
             // FIXME (#2812): run the linter here also, once there are llvm-c
             // bindings for it.
@@ -200,7 +205,7 @@ pub mod write {
 
 
             if opts.save_temps {
-                match opts.output_type {
+                match output_type {
                   output_type_bitcode => {
                     if opts.optimize != session::No {
                         let filename = output.with_filetype("no-opt.bc");
@@ -261,7 +266,7 @@ pub mod write {
                 llvm::LLVMPassManagerBuilderDispose(MPMB);
             }
             if !sess.no_verify() { llvm::LLVMAddVerifierPass(pm.llpm); }
-            if is_object_or_assembly_or_exe(opts.output_type) || opts.jit {
+            if is_object_or_assembly_or_exe(output_type) || opts.jit {
                 let LLVMOptNone       = 0 as c_int; // -O0
                 let LLVMOptLess       = 1 as c_int; // -O1
                 let LLVMOptDefault    = 2 as c_int; // -O2, -Os
@@ -289,8 +294,8 @@ pub mod write {
                 }
 
                 let mut FileType;
-                if opts.output_type == output_type_object ||
-                       opts.output_type == output_type_exe {
+                if output_type == output_type_object ||
+                       output_type == output_type_exe {
                    FileType = lib::llvm::ObjectFile;
                 } else { FileType = lib::llvm::AssemblyFile; }
                 // Write optimized bitcode if --save-temps was on.
@@ -306,7 +311,7 @@ pub mod write {
                     pm = mk_pass_manager();
                     // Save the assembly file if -S is used
 
-                    if opts.output_type == output_type_assembly {
+                    if output_type == output_type_assembly {
                         let _: () = str::as_c_str(
                             sess.targ_cfg.target_strs.target_triple,
                             |buf_t| {
@@ -327,8 +332,8 @@ pub mod write {
 
                     // Save the object file for -c or --save-temps alone
                     // This .o is needed when an exe is built
-                    if opts.output_type == output_type_object ||
-                           opts.output_type == output_type_exe {
+                    if output_type == output_type_object ||
+                           output_type == output_type_exe {
                         let _: () = str::as_c_str(
                             sess.targ_cfg.target_strs.target_triple,
                             |buf_t| {
@@ -374,7 +379,7 @@ pub mod write {
                 return;
             }
 
-            if opts.output_type == output_type_llvm_assembly {
+            if output_type == output_type_llvm_assembly {
                 // Given options "-S --emit-llvm": output LLVM assembly
                 str::as_c_str(output.to_str(), |buf_o| {
                     llvm::LLVMRustAddPrintModulePass(pm.llpm, llmod, buf_o)});
@@ -390,6 +395,34 @@ pub mod write {
             if sess.time_llvm_passes() { llvm::LLVMRustPrintPassTimings(); }
         }
     }
+
+    pub fn run_ndk(sess: Session, assembly: &Path, object: &Path) {
+        let cc_prog: ~str = match &sess.opts.android_cross_path {
+            &Some(copy path) => {
+                fmt!("%s/bin/arm-linux-androideabi-gcc", path)
+            }
+            &None => {
+                sess.fatal(~"need Android NDK path for building \
+                             (--android-cross-path)")
+            }
+        };
+        let mut cc_args = ~[];
+        cc_args.push(~"-c");
+        cc_args.push(~"-o");
+        cc_args.push(object.to_str());
+        cc_args.push(assembly.to_str());
+
+        let prog = run::program_output(cc_prog, cc_args);
+
+        if prog.status != 0 {
+            sess.err(fmt!("building with `%s` failed with code %d",
+                        cc_prog, prog.status));
+            sess.note(fmt!("%s arguments: %s",
+                        cc_prog, str::connect(cc_args, ~" ")));
+            sess.note(prog.err + prog.out);
+            sess.abort_if_errors();
+        }
+    }
 }
 
 
@@ -833,9 +866,8 @@ pub fn link_binary(sess: Session,
     // to be found at compile time so it is still entirely up to outside
     // forces to make sure that library can be found at runtime.
 
-    for sess.opts.addl_lib_search_paths.each |path| {
-        cc_args.push(~"-L" + path.to_str());
-    }
+    let addl_paths = /*bad*/copy sess.opts.addl_lib_search_paths;
+    for addl_paths.each |path| { cc_args.push(~"-L" + path.to_str()); }
 
     // The names of the extern libraries
     let used_libs = cstore::get_used_libraries(cstore);

branches/try/src/librustc/back/rpath.rs

@@ -45,8 +45,8 @@ pub fn get_rpath_flags(sess: session::Session, out_filename: &Path)
     // where rustrt is and we know every rust program needs it
     let libs = vec::append_one(libs, get_sysroot_absolute_rt_lib(sess));
 
-    let rpaths = get_rpaths(os, &sysroot, output, libs,
-                            sess.opts.target_triple);
+    let target_triple = /*bad*/copy sess.opts.target_triple;
+    let rpaths = get_rpaths(os, &sysroot, output, libs, target_triple);
     rpaths_to_flags(rpaths)
 }
 
@@ -140,8 +140,8 @@ pub fn get_relative_to(abs1: &Path, abs2: &Path) -> Path {
     let abs2 = abs2.normalize();
     debug!("finding relative path from %s to %s",
            abs1.to_str(), abs2.to_str());
-    let split1: &[~str] = abs1.components;
-    let split2: &[~str] = abs2.components;
+    let split1 = /*bad*/copy abs1.components;
+    let split2 = /*bad*/copy abs2.components;
     let len1 = vec::len(split1);
     let len2 = vec::len(split2);
     fail_unless!(len1 > 0);

branches/try/src/librustc/driver/driver.rs

@@ -132,12 +132,15 @@ pub fn build_configuration(sess: Session, +argv0: ~str, input: input) ->
 }
 
 // Convert strings provided as --cfg [cfgspec] into a crate_cfg
-fn parse_cfgspecs(+cfgspecs: ~[~str],
+fn parse_cfgspecs(cfgspecs: ~[~str],
                   demitter: diagnostic::Emitter) -> ast::crate_cfg {
-    do vec::map_consume(cfgspecs) |s| {
+    let mut meta = ~[];
+    for cfgspecs.each |s| {
         let sess = parse::new_parse_sess(Some(demitter));
-        parse::parse_meta_from_source_str(~"cfgspec", @s, ~[], sess)
+        let m = parse::parse_meta_from_source_str(~"cfgspec", @/*bad*/ copy *s, ~[], sess);
+        meta.push(m)
     }
+    return meta;
 }
 
 pub enum input {
@@ -320,9 +323,23 @@ pub fn compile_rest(sess: Session, cfg: ast::crate_cfg,
 
     };
 
-    time(time_passes, ~"LLVM passes", ||
-        link::write::run_passes(sess, llmod,
+    // NOTE: Android hack
+    if sess.targ_cfg.arch == session::arch_arm &&
+            (sess.opts.output_type == link::output_type_object ||
+             sess.opts.output_type == link::output_type_exe) {
+        let output_type = link::output_type_assembly;
+        let obj_filename = outputs.obj_filename.with_filetype("s");
+
+        time(time_passes, ~"LLVM passes", ||
+            link::write::run_passes(sess, llmod, output_type,
+                            &obj_filename));
+
+        link::write::run_ndk(sess, &obj_filename, &outputs.obj_filename);
+    } else {
+        time(time_passes, ~"LLVM passes", ||
+            link::write::run_passes(sess, llmod, sess.opts.output_type,
                                 &outputs.obj_filename));
+    }
 
     let stop_after_codegen =
         sess.opts.output_type != link::output_type_exe ||
@@ -563,9 +580,9 @@ pub fn build_session_options(+binary: ~str,
     let debug_map = session::debugging_opts_map();
     for debug_flags.each |debug_flag| {
         let mut this_bit = 0u;
-        for debug_map.each |tuple| {
-            let (name, bit) = match *tuple { (ref a, _, b) => (a, b) };
-            if name == debug_flag { this_bit = bit; break; }
+        for debug_map.each |pair| {
+            let (name, _, bit) = /*bad*/copy *pair;
+            if name == *debug_flag { this_bit = bit; break; }
         }
         if this_bit == 0u {
             early_error(demitter, fmt!("unknown debug flag: %s", *debug_flag))
@@ -630,7 +647,7 @@ pub fn build_session_options(+binary: ~str,
     let target =
         match target_opt {
             None => host_triple(),
-            Some(s) => s
+            Some(ref s) => (/*bad*/copy *s)
         };
 
     let addl_lib_search_paths =

branches/try/src/librustc/front/config.rs

@@ -185,18 +185,19 @@ pub fn metas_in_cfg(cfg: ast::crate_cfg,
     // Pull the inner meta_items from the #[cfg(meta_item, ...)]  attributes,
     // so we can match against them. This is the list of configurations for
     // which the item is valid
-    let cfg_metas =
-        vec::concat(
-            vec::filter_map(cfg_metas, |i| attr::get_meta_item_list(i)));
-
-    let has_cfg_metas = vec::len(cfg_metas) > 0u;
-    if !has_cfg_metas { return true; }
-
-    for cfg_metas.each |cfg_mi| {
-        if attr::contains(cfg, *cfg_mi) { return true; }
-    }
-
-    return false;
+    let cfg_metas = vec::filter_map(cfg_metas, |i| attr::get_meta_item_list(i));
+
+    if cfg_metas.all(|c| c.is_empty()) { return true; }
+
+    cfg_metas.any(|cfg_meta| {
+        cfg_meta.all(|cfg_mi| {
+            match cfg_mi.node {
+                ast::meta_list(s, ref it) if *s == ~"not"
+                    => it.all(|mi| !attr::contains(cfg, *mi)),
+                _ => attr::contains(cfg, *cfg_mi)
+            }
+        })
+    })
 }
 
 

branches/try/src/librustc/lib/llvm.rs

@@ -1647,7 +1647,7 @@ pub struct TargetData {
     dtor: @target_data_res
 }
 
-pub fn mk_target_data(string_rep: &str) -> TargetData {
+pub fn mk_target_data(string_rep: ~str) -> TargetData {
     let lltd =
         str::as_c_str(string_rep, |buf| unsafe {
             llvm::LLVMCreateTargetData(buf)