---

yaml
---
r: 59101
b: refs/heads/incoming
c: 2a9a4a8
h: refs/heads/master
i:
  59099: f3b1b17
v: v3

Author: alexcrichton

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c50a9d5b664478e533ba1d1d353213d70c8ad589
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/incoming: a9f21326062b0b455aebd2459e8406b03a048a26
+refs/heads/incoming: 2a9a4a81e15fbd8146ce8fe5842c46ad615cbcf6
 refs/heads/dist-snap: 00dbbd01c2aee72982b3e0f9511ae1d4428c3ba9
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/src/driver/driver.rs

@@ -8,9 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#[no_core];
-extern mod core(vers = "0.7-pre");
-
 #[cfg(rustpkg)]
 extern mod this(name = "rustpkg", vers = "0.7-pre");
 

branches/incoming/src/libcore/unstable/intrinsics.rs

@@ -19,16 +19,6 @@ pub extern "rust-intrinsic" {
     pub fn atomic_cxchg(dst: &mut int, old: int, src: int) -> int;
     pub fn atomic_cxchg_acq(dst: &mut int, old: int, src: int) -> int;
     pub fn atomic_cxchg_rel(dst: &mut int, old: int, src: int) -> int;
-    
-    #[cfg(not(stage0))]
-    pub fn atomic_load(src: &int) -> int;
-    #[cfg(not(stage0))]
-    pub fn atomic_load_acq(src: &int) -> int;
-    
-    #[cfg(not(stage0))]
-    pub fn atomic_store(dst: &mut int, val: int);
-    #[cfg(not(stage0))]
-    pub fn atomic_store_rel(dst: &mut int, val: int);
 
     pub fn atomic_xchg(dst: &mut int, src: int) -> int;
     pub fn atomic_xchg_acq(dst: &mut int, src: int) -> int;

branches/incoming/src/librust/rust.rc

@@ -20,6 +20,11 @@
 #[license = "MIT/ASL2"];
 #[crate_type = "lib"];
 
+extern mod rustpkg(vers = "0.7-pre");
+extern mod rustdoc(vers = "0.7-pre");
+extern mod rusti(vers = "0.7-pre");
+extern mod rustc(vers = "0.7-pre");
+
 use core::run;
 
 enum ValidUsage {
@@ -36,13 +41,13 @@ impl ValidUsage {
 }
 
 enum Action<'self> {
-    Exec(&'self str),
-    Call(&'self fn(args: &[~str]) -> ValidUsage)
+    Call(&'self fn(args: &[~str]) -> ValidUsage),
+    CallMain(&'static str, &'self fn()),
 }
 
 enum UsageSource<'self> {
-    UsgExec(&'self str),
-    UsgStr(&'self str)
+    UsgStr(&'self str),
+    UsgCall(&'self fn()),
 }
 
 struct Command<'self> {
@@ -55,9 +60,9 @@ struct Command<'self> {
 static commands: &'static [Command<'static>] = &[
     Command{
         cmd: "build",
-        action: Exec("rustc"),
+        action: CallMain("rustc", rustc::main),
         usage_line: "compile rust source files",
-        usage_full: UsgExec("rustc --help")
+        usage_full: UsgCall(rustc_help),
     },
     Command{
         cmd: "run",
@@ -81,21 +86,21 @@ static commands: &'static [Command<'static>] = &[
     },
     Command{
         cmd: "doc",
-        action: Exec("rustdoc"),
+        action: CallMain("rustdoc", rustdoc::main),
         usage_line: "generate documentation from doc comments",
-        usage_full: UsgExec("rustdoc --help")
+        usage_full: UsgCall(rustdoc::config::usage),
     },
     Command{
         cmd: "pkg",
-        action: Exec("rustpkg"),
+        action: CallMain("rustpkg", rustpkg::main),
         usage_line: "download, build, install rust packages",
-        usage_full: UsgExec("rustpkg --help")
+        usage_full: UsgCall(rustpkg::usage::general),
     },
     Command{
         cmd: "sketch",
-        action: Exec("rusti"),
+        action: CallMain("rusti", rusti::main),
         usage_line: "run a rust interpreter",
-        usage_full: UsgStr("\nUsage:\trusti")
+        usage_full: UsgStr("\nUsage:\trusti"),
     },
     Command{
         cmd: "help",
@@ -109,6 +114,10 @@ static commands: &'static [Command<'static>] = &[
     }
 ];
 
+fn rustc_help() {
+    rustc::usage(copy os::args()[0])
+}
+
 fn find_cmd(command_string: &str) -> Option<Command> {
     do commands.find |command| {
         command.cmd == command_string
@@ -120,20 +129,14 @@ fn cmd_help(args: &[~str]) -> ValidUsage {
         match find_cmd(command_string) {
             Some(command) => {
                 match command.action {
-                    Exec(s) => io::println(fmt!(
+                    CallMain(prog, _) => io::println(fmt!(
                         "The %s command is an alias for the %s program.",
-                        command.cmd, s)),
+                        command.cmd, prog)),
                     _       => ()
                 }
                 match command.usage_full {
-                    UsgStr(msg)          => io::println(fmt!("%s\n", msg)),
-                    UsgExec(commandline) => {
-                        let mut words = ~[];
-                        for str::each_word(commandline) |word| { words.push(word.to_owned()) }
-                        let words = words;
-                        let (prog, args) = (words.head(), words.tail());
-                        run::run_program(*prog, args);
-                    }
+                    UsgStr(msg) => io::println(fmt!("%s\n", msg)),
+                    UsgCall(f)  => f(),
                 }
                 Valid
             },
@@ -151,50 +154,40 @@ fn cmd_test(args: &[~str]) -> ValidUsage {
     match args {
         [filename] => {
             let test_exec = Path(filename).filestem().unwrap() + "test~";
-            if run::run_program("rustc", [
-                ~"--test",
-                filename.to_owned(),
-                ~"-o",
-                test_exec.to_owned()
-            ]) == 0 {
-                run::run_program(~"./" + test_exec, []);
-            }
+            invoke("rustc", &[~"--test", filename.to_owned(),
+                              ~"-o", test_exec.to_owned()], rustc::main);
+            run::run_program(~"./" + test_exec, []);
             Valid
         }
-        _          => Invalid
+        _ => Invalid
     }
 }
 
 fn cmd_run(args: &[~str]) -> ValidUsage {
     match args {
         [filename, ..prog_args] => {
             let exec = Path(filename).filestem().unwrap() + "~";
-            if run::run_program("rustc", [
-                filename.to_owned(),
-                ~"-o",
-                exec.to_owned()
-            ]) == 0 {
-                run::run_program(~"./"+exec, prog_args);
-            }
+            invoke("rustc", &[filename.to_owned(), ~"-o", exec.to_owned()],
+                   rustc::main);
+            run::run_program(~"./"+exec, prog_args);
             Valid
         }
-        _          => Invalid
+        _ => Invalid
     }
 }
 
+fn invoke(prog: &str, args: &[~str], f: &fn()) {
+    let mut osargs = ~[prog.to_owned()];
+    osargs.push_all_move(args.to_owned());
+    os::set_args(osargs);
+    f();
+}
+
 fn do_command(command: &Command, args: &[~str]) -> ValidUsage {
     match command.action {
         Call(f) => f(args),
-        Exec(commandline) => {
-            let mut words = ~[];
-            for str::each_word(commandline) |word| { words.push(word.to_owned()) }
-            let words = words;
-            let (prog, prog_args) = (words.head(), words.tail());
-            let exitstatus = run::run_program(
-                *prog,
-                vec::append(vec::to_owned(prog_args), args)
-            );
-            os::set_exit_status(exitstatus);
+        CallMain(prog, f) => {
+            invoke(prog, args, f);
             Valid
         }
     }
@@ -232,11 +225,9 @@ pub fn main() {
     let args = os_args.tail();
 
     if !args.is_empty() {
-        for commands.each |command| {
-            if command.cmd == *args.head() {
-                let result = do_command(command, args.tail());
-                if result.is_valid() { return; }
-            }
+        for find_cmd(*args.head()).each |command| {
+            let result = do_command(command, args.tail());
+            if result.is_valid() { return; }
         }
     }
 

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

@@ -1339,16 +1339,13 @@ pub mod llvm {
                                     PointerVal: ValueRef) -> ValueRef;
         #[fast_ffi]
         pub unsafe fn LLVMBuildLoad(B: BuilderRef,
-                                    PointerVal: ValueRef,
-                                    Name: *c_char)
-                                 -> ValueRef;
-
+                                PointerVal: ValueRef,
+                                Name: *c_char)
+                             -> ValueRef;
         #[fast_ffi]
         pub unsafe fn LLVMBuildStore(B: BuilderRef,
                                      Val: ValueRef,
-                                     Ptr: ValueRef)
-                                  -> ValueRef;
-
+                                     Ptr: ValueRef) -> ValueRef;
         #[fast_ffi]
         pub unsafe fn LLVMBuildGEP(B: BuilderRef,
                                Pointer: ValueRef,
@@ -1564,17 +1561,6 @@ pub mod llvm {
                                        Name: *c_char) -> ValueRef;
 
         /* Atomic Operations */
-        pub unsafe fn LLVMBuildAtomicLoad(B: BuilderRef,
-                                          PointerVal: ValueRef,
-                                          Order: AtomicOrdering)
-                                       -> ValueRef;
-
-        pub unsafe fn LLVMBuildAtomicStore(B: BuilderRef,
-                                           Val: ValueRef,
-                                           Ptr: ValueRef,
-                                           Order: AtomicOrdering)
-                                        -> ValueRef;
-        
         pub unsafe fn LLVMBuildAtomicCmpXchg(B: BuilderRef,
                                              LHS: ValueRef,
                                              CMP: ValueRef,

branches/incoming/src/librustc/middle/trans/build.rs

@@ -537,21 +537,6 @@ pub fn Load(cx: block, PointerVal: ValueRef) -> ValueRef {
     }
 }
 
-pub fn AtomicLoad(cx: block, PointerVal: ValueRef, order: AtomicOrdering) -> ValueRef {
-    unsafe {
-        let ccx = cx.fcx.ccx;
-        if cx.unreachable {
-            let ty = val_ty(PointerVal);
-            let eltty = if llvm::LLVMGetTypeKind(ty) == lib::llvm::Array {
-                llvm::LLVMGetElementType(ty) } else { ccx.int_type };
-            return llvm::LLVMGetUndef(eltty);
-        }
-        count_insn(cx, "load.atomic");
-        return llvm::LLVMBuildAtomicLoad(B(cx), PointerVal, order);
-    }
-}
-
-
 pub fn LoadRangeAssert(cx: block, PointerVal: ValueRef, lo: c_ulonglong,
                        hi: c_ulonglong, signed: lib::llvm::Bool) -> ValueRef {
     let value = Load(cx, PointerVal);
@@ -582,17 +567,6 @@ pub fn Store(cx: block, Val: ValueRef, Ptr: ValueRef) {
     }
 }
 
-pub fn AtomicStore(cx: block, Val: ValueRef, Ptr: ValueRef, order: AtomicOrdering) {
-    unsafe {
-        if cx.unreachable { return; }
-        debug!("Store %s -> %s",
-               val_str(cx.ccx().tn, Val),
-               val_str(cx.ccx().tn, Ptr));
-        count_insn(cx, "store.atomic");
-        llvm::LLVMBuildAtomicStore(B(cx), Val, Ptr, order);
-    }
-}
-
 pub fn GEP(cx: block, Pointer: ValueRef, Indices: &[ValueRef]) -> ValueRef {
     unsafe {
         if cx.unreachable { return llvm::LLVMGetUndef(T_ptr(T_nil())); }

branches/incoming/src/librustc/middle/trans/foreign.rs

@@ -592,30 +592,6 @@ pub fn trans_intrinsic(ccx: @CrateContext,
                                     Release);
             Store(bcx, old, fcx.llretptr.get());
         }
-        ~"atomic_load" => {
-            let old = AtomicLoad(bcx,
-                                 get_param(decl, first_real_arg),
-                                 SequentiallyConsistent);
-            Store(bcx, old, fcx.llretptr.get());
-        }
-        ~"atomic_load_acq" => {
-            let old = AtomicLoad(bcx,
-                                 get_param(decl, first_real_arg),
-                                 Acquire);
-            Store(bcx, old, fcx.llretptr.get());
-        }
-        ~"atomic_store" => {
-            AtomicStore(bcx,
-                        get_param(decl, first_real_arg + 1u),
-                        get_param(decl, first_real_arg),
-                        SequentiallyConsistent);
-        }
-        ~"atomic_store_rel" => {
-            AtomicStore(bcx,
-                        get_param(decl, first_real_arg + 1u),
-                        get_param(decl, first_real_arg),
-                        Release);
-        }
         ~"atomic_xchg" => {
             let old = AtomicRMW(bcx, Xchg,
                                 get_param(decl, first_real_arg),

branches/incoming/src/librustc/middle/trans/type_use.rs

@@ -124,9 +124,7 @@ pub fn type_uses_for(ccx: @CrateContext, fn_id: def_id, n_tps: uint)
                 ~"get_tydesc" | ~"needs_drop" => use_tydesc,
 
                 ~"atomic_cxchg"    | ~"atomic_cxchg_acq"|
-                ~"atomic_cxchg_rel"| ~"atomic_load"     |
-                ~"atomic_load_acq" | ~"atomic_store"    |
-                ~"atomic_store_rel"| ~"atomic_xchg"     |
+                ~"atomic_cxchg_rel"| ~"atomic_xchg"     |
                 ~"atomic_xadd"     | ~"atomic_xsub"     |
                 ~"atomic_xchg_acq" | ~"atomic_xadd_acq" |
                 ~"atomic_xsub_acq" | ~"atomic_xchg_rel" |

branches/incoming/src/librustc/middle/typeck/check/mod.rs

@@ -3486,25 +3486,6 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
          ],
          ty::mk_int())
       }
-      ~"atomic_load"     | ~"atomic_load_acq" => {
-        (0,
-         ~[
-            arg(ty::mk_imm_rptr(tcx,
-                            ty::re_bound(ty::br_anon(0)),
-                            ty::mk_int()))
-         ],
-        ty::mk_int())
-      }
-      ~"atomic_store"    | ~"atomic_store_rel" => {
-        (0,
-         ~[
-            arg(ty::mk_mut_rptr(tcx,
-                                ty::re_bound(ty::br_anon(0)),
-                                ty::mk_int())),
-            arg(ty::mk_int())
-         ],
-         ty::mk_nil())
-      }
       ~"atomic_xchg"     | ~"atomic_xadd"     | ~"atomic_xsub"     |
       ~"atomic_xchg_acq" | ~"atomic_xadd_acq" | ~"atomic_xsub_acq" |
       ~"atomic_xchg_rel" | ~"atomic_xadd_rel" | ~"atomic_xsub_rel" => {

branches/incoming/src/librustpkg/rustpkg.rc

@@ -42,12 +42,13 @@ use context::Ctx;
 
 mod conditions;
 mod context;
-mod usage;
 mod path_util;
 mod tests;
 mod util;
 mod workspace;
 
+pub mod usage;
+
 /// A PkgScript represents user-supplied custom logic for
 /// special build hooks. This only exists for packages with
 /// an explicit package script.