---

yaml
---
r: 145251
b: refs/heads/try2
c: cb7756a
h: refs/heads/master
i:
  145249: 18ebdfa
  145247: 9563cea
v: v3

Author: alexcrichton

[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: 36cc41481c788e8d781e24908dcf30120797ed8d
+refs/heads/try2: cb7756a81d3cbc48e79ffaa1a1f9d4934b581166
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/librustc/middle/trans/base.rs

@@ -2388,12 +2388,38 @@ pub fn create_entry_wrapper(ccx: @mut CrateContext,
     let et = ccx.sess.entry_type.unwrap();
     match et {
         session::EntryMain => {
-            create_entry_fn(ccx, main_llfn, true);
+            let llfn = create_main(ccx, main_llfn);
+            create_entry_fn(ccx, llfn, true);
         }
         session::EntryStart => create_entry_fn(ccx, main_llfn, false),
         session::EntryNone => {}    // Do nothing.
     }
 
+    fn create_main(ccx: @mut CrateContext, main_llfn: ValueRef) -> ValueRef {
+        let nt = ty::mk_nil();
+        let llfty = type_of_rust_fn(ccx, [], nt);
+        let llfdecl = decl_fn(ccx.llmod, "_rust_main",
+                              lib::llvm::CCallConv, llfty);
+
+        let fcx = new_fn_ctxt(ccx, ~[], llfdecl, nt, None);
+
+        // the args vector built in create_entry_fn will need
+        // be updated if this assertion starts to fail.
+        assert!(!fcx.caller_expects_out_pointer);
+
+        let bcx = fcx.entry_bcx.unwrap();
+        // Call main.
+        let llenvarg = unsafe {
+            let env_arg = fcx.env_arg_pos();
+            llvm::LLVMGetParam(llfdecl, env_arg as c_uint)
+        };
+        let args = ~[llenvarg];
+        Call(bcx, main_llfn, args, []);
+
+        finish_fn(fcx, bcx);
+        return llfdecl;
+    }
+
     fn create_entry_fn(ccx: @mut CrateContext,
                        rust_main: ValueRef,
                        use_start_lang_item: bool) {

branches/try2/src/librustpkg/api.rs

@@ -12,7 +12,6 @@ use context::*;
 use crate::*;
 use package_id::*;
 use package_source::*;
-use target::*;
 use version::Version;
 use workcache_support::*;
 
@@ -64,40 +63,56 @@ pub fn new_workcache_context(p: &Path) -> workcache::Context {
 pub fn build_lib(sysroot: Path, root: Path, name: ~str, version: Version,
                  lib: Path) {
     let cx = default_context(sysroot);
-    let pkg_src = PkgSrc {
-            workspace: root.clone(),
-            start_dir: root.push("src").push(name),
-            id: PkgId{ version: version, ..PkgId::new(name)},
-            // n.b. This assumes the package only has one crate
-            libs: ~[mk_crate(lib)],
+    let subroot = root.clone();
+    let subversion = version.clone();
+    let sublib = lib.clone();
+    do cx.workcache_context.with_prep(name) |prep| {
+        let pkg_src = PkgSrc {
+            workspace: subroot.clone(),
+            start_dir: subroot.push("src").push(name),
+            id: PkgId{ version: subversion.clone(), ..PkgId::new(name)},
+            libs: ~[mk_crate(sublib.clone())],
             mains: ~[],
             tests: ~[],
             benchs: ~[]
         };
-    pkg_src.build(&cx, ~[]);
+        pkg_src.declare_inputs(prep);
+        let subcx = cx.clone();
+        let subsrc = pkg_src.clone();
+        do prep.exec |exec| {
+            subsrc.build(exec, &subcx.clone(), ~[]);
+        }
+    };
 }
 
 pub fn build_exe(sysroot: Path, root: Path, name: ~str, version: Version,
                  main: Path) {
     let cx = default_context(sysroot);
-    let pkg_src = PkgSrc {
-        workspace: root.clone(),
-        start_dir: root.push("src").push(name),
-        id: PkgId{ version: version, ..PkgId::new(name)},
-        libs: ~[],
-        // n.b. This assumes the package only has one crate
-        mains: ~[mk_crate(main)],
-        tests: ~[],
-        benchs: ~[]
-    };
-
-    pkg_src.build(&cx, ~[]);
+    let subroot = root.clone();
+    let submain = main.clone();
+    do cx.workcache_context.with_prep(name) |prep| {
+        let pkg_src = PkgSrc {
+            workspace: subroot.clone(),
+            start_dir: subroot.push("src").push(name),
+            id: PkgId{ version: version.clone(), ..PkgId::new(name)},
+            libs: ~[],
+            mains: ~[mk_crate(submain.clone())],
+            tests: ~[],
+            benchs: ~[]
+        };
+        pkg_src.declare_inputs(prep);
+        let subsrc = pkg_src.clone();
+        let subcx = cx.clone();
+        do prep.exec |exec| {
+            subsrc.clone().build(exec, &subcx.clone(), ~[]);
+        }
+    }
 }
 
 pub fn install_pkg(sysroot: Path, workspace: Path, name: ~str, version: Version) {
     let cx = default_context(sysroot);
     let pkgid = PkgId{ version: version, ..PkgId::new(name)};
-    cx.install(PkgSrc::new(workspace, false, pkgid), &Everything);
+    cx.install(PkgSrc::new(workspace, false, pkgid));
 }
 
 fn mk_crate(p: Path) -> Crate {

branches/try2/src/librustpkg/exit_codes.rs

@@ -108,12 +108,6 @@ impl PkgId {
         }
     }
 
-    // This is the workcache function name for the *installed*
-    // binaries for this package (as opposed to the built ones,
-    // which are per-crate).
-    pub fn install_tag(&self) -> ~str {
-        fmt!("install(%s)", self.to_str())
-    }
 }
 
 struct Prefixes {

branches/try2/src/librustpkg/package_id.rs

@@ -22,7 +22,6 @@ use path_util::{find_dir_using_rust_path_hack, default_workspace, make_dir_rwx_r
 use util::compile_crate;
 use workspace::is_workspace;
 use workcache_support;
-use workcache_support::crate_tag;
 use extra::workcache;
 
 // An enumeration of the unpacked source of a package workspace.
@@ -232,7 +231,7 @@ impl PkgSrc {
         p.filestem().map_default(false, |p| { p == &self.id.short_name.as_slice() })
     }
 
-    pub fn push_crate(cs: &mut ~[Crate], prefix: uint, p: &Path) {
+    fn push_crate(cs: &mut ~[Crate], prefix: uint, p: &Path) {
         assert!(p.components.len() > prefix);
         let mut sub = Path("");
         for c in p.components.slice(prefix, p.components.len()).iter() {
@@ -287,6 +286,7 @@ impl PkgSrc {
 
     fn build_crates(&self,
                     ctx: &BuildContext,
+                    exec: &mut workcache::Exec,
                     destination_dir: &Path,
                     crates: &[Crate],
                     cfgs: &[~str],
@@ -297,40 +297,25 @@ impl PkgSrc {
             let path_str = path.to_str();
             let cfgs = crate.cfgs + cfgs;
 
-            do ctx.workcache_context.with_prep(crate_tag(&path)) |prep| {
-                debug!("Building crate %s, declaring it as an input", path.to_str());
-                prep.declare_input("file", path.to_str(),
-                                   workcache_support::digest_file_with_date(&path));
-                let subpath = path.clone();
-                let subcfgs = cfgs.clone();
-                let subpath_str = path_str.clone();
-                let subcx = ctx.clone();
-                let id = self.id.clone();
-                let sub_dir = destination_dir.clone();
-                let sub_flags = crate.flags.clone();
-                do prep.exec |exec| {
-                    let result = compile_crate(&subcx,
-                                               exec,
-                                               &id,
-                                               &subpath,
-                                               &sub_dir,
-                                               sub_flags,
-                                               subcfgs,
-                                               false,
-                                               what).to_str();
-                    debug!("Result of compiling %s was %s", subpath_str, result);
-                    result
-                }
-            };
+            let result =
+                // compile_crate should return the path of the output artifact
+                compile_crate(ctx,
+                              exec,
+                              &self.id,
+                              &path,
+                              destination_dir,
+                              crate.flags,
+                              cfgs,
+                              false,
+                              what).to_str();
+            debug!("Result of compiling %s was %s", path_str, result);
         }
     }
 
     /// Declare all the crate files in the package source as inputs
-    /// (to the package)
     pub fn declare_inputs(&self, prep: &mut workcache::Prep) {
         let to_do = ~[self.libs.clone(), self.mains.clone(),
                       self.tests.clone(), self.benchs.clone()];
-        debug!("In declare inputs, self = %s", self.to_str());
         for cs in to_do.iter() {
             for c in cs.iter() {
                 let path = self.start_dir.push_rel(&c.file).normalize();
@@ -345,6 +330,7 @@ impl PkgSrc {
     // It would be better if build returned a Path, but then Path would have to derive
     // Encodable.
     pub fn build(&self,
+                 exec: &mut workcache::Exec,
                  build_context: &BuildContext,
                  cfgs: ~[~str]) -> ~str {
         use conditions::not_a_workspace::cond;
@@ -374,23 +360,13 @@ impl PkgSrc {
         let benchs = self.benchs.clone();
         debug!("Building libs in %s, destination = %s",
                destination_workspace.to_str(), destination_workspace.to_str());
-        self.build_crates(build_context, &destination_workspace, libs, cfgs, Lib);
+        self.build_crates(build_context, exec, &destination_workspace, libs, cfgs, Lib);
         debug!("Building mains");
-        self.build_crates(build_context, &destination_workspace, mains, cfgs, Main);
+        self.build_crates(build_context, exec, &destination_workspace, mains, cfgs, Main);
         debug!("Building tests");
-        self.build_crates(build_context, &destination_workspace, tests, cfgs, Test);
+        self.build_crates(build_context, exec, &destination_workspace, tests, cfgs, Test);
         debug!("Building benches");
-        self.build_crates(build_context, &destination_workspace, benchs, cfgs, Bench);
+        self.build_crates(build_context, exec, &destination_workspace, benchs, cfgs, Bench);
         destination_workspace.to_str()
     }
-
-    /// Debugging
-    pub fn dump_crates(&self) {
-        let crate_sets = [&self.libs, &self.mains, &self.tests, &self.benchs];
-        for crate_set in crate_sets.iter() {
-            for c in crate_set.iter() {
-                debug!("Built crate: %s", c.file.to_str())
-            }
-        }
-    }
 }