[WIP] Add specs for data layout

build/main.rs

@@ -1,6 +1,7 @@
 extern crate git2;
 
-use std::io::fs::PathExtensions;
+use std::io::TempDir;
+use std::io::fs::{File, PathExtensions};
 use std::io::process;
 
 fn main() {
@@ -11,39 +12,29 @@ fn main() {
     clone_rust(&rust_dir);
 
     println!("Compiling libcore");
-    if !out_dir.join("core.ll").exists() {
-        compile(&rust_dir.join("src").join("libcore").join("lib.rs"), &out_dir);
-    }
+    compile(&rust_dir.join("src").join("libcore").join("lib.rs"), &out_dir);
 
     println!("Compiling liblibc");
-    if !out_dir.join("libc.ll").exists() {
-        compile(&rust_dir.join("src").join("liblibc").join("lib.rs"), &out_dir);
-    }
-
+    compile(&rust_dir.join("src").join("liblibc").join("lib.rs"), &out_dir);
+
     println!("Compiling liballoc");
-    if !out_dir.join("alloc.ll").exists() {
-        compile(&rust_dir.join("src").join("liballoc").join("lib.rs"), &out_dir);
-    }
-
-    println!("Compiling libcollections");
-    if !out_dir.join("collections.ll").exists() {
-        compile(&rust_dir.join("src").join("libcollections").join("lib.rs"), &out_dir);
-    }
+    compile(&rust_dir.join("src").join("liballoc").join("lib.rs"), &out_dir);
 
     println!("Compiling libunicode");
-    if !out_dir.join("unicode.ll").exists() {
-        compile(&rust_dir.join("src").join("libunicode").join("lib.rs"), &out_dir);
-    }
+    compile(&rust_dir.join("src").join("libunicode").join("lib.rs"), &out_dir);
+
+    println!("Compiling libcollections");
+    compile(&rust_dir.join("src").join("libcollections").join("lib.rs"), &out_dir);
 
     println!("Compiling librand");
-    if !out_dir.join("rand.ll").exists() {
-        compile(&rust_dir.join("src").join("librand").join("lib.rs"), &out_dir);
-    }
+    compile(&rust_dir.join("src").join("librand").join("lib.rs"), &out_dir);
+
+    /*println!("Compiling rustrt");
+    File::create(&out_dir.join("rustrt.rs")).write_str("#![no_std]\n#![crate_name = \"rust_builtin\"]\n#![crate_type = \"staticlib\"]\n").unwrap();
+    compile(&out_dir.join("rustrt.rs"), &out_dir);
 
     println!("Compiling libstd");
-    if !out_dir.join("std.ll").exists() {
-        compile(&rust_dir.join("src").join("libstd").join("lib.rs"), &out_dir);
-    }
+    compile(&rust_dir.join("src").join("libstd").join("lib.rs"), &out_dir);*/
 }
 
 fn clone_rust(path: &Path) -> git2::Repository {
@@ -65,11 +56,21 @@ fn clone_rust(path: &Path) -> git2::Repository {
 }
 
 fn compile(krate: &Path, out_dir: &Path) {
+    let cwd = TempDir::new("cargo-emscripten-compilation").unwrap();
+    std::io::fs::copy(&Path::new(std::os::getenv("CARGO_MANIFEST_DIR").unwrap()).join("specs-build.json"),
+                      &cwd.path().join("emscripten.json")).unwrap();
+
     let mut command = process::Command::new("rustc");
     command.arg(krate);
     command.arg("--out-dir").arg(out_dir);
-    command.arg("--emit=llvm-ir");
-
+    command.arg("-L").arg(out_dir);
+    command.arg("--target").arg("emscripten.json");
+    command.cwd(cwd.path());
+
+    let mut ir_command = command.clone();
+    ir_command.arg("--emit=llvm-ir");
+
+    exec(ir_command);
     exec(command);
 }
 

specs-build.json

@@ -0,0 +1,12 @@
+{
+  "data-layout": "e-p:32:32-i64:64-v128:32:128-n32-S128",
+  "llvm-target": "i686-unknown-linux-gnu",
+  "target-endian": "little",
+  "target-word-size": "32",
+  "arch": "x86",
+  "os": "linux",
+  "morestack": false,
+  "dynamic-linking": true,
+  "executables": true,
+  "no-compiler-rt": true
+}

specs-target.json

@@ -0,0 +1,12 @@
+{
+  "data-layout": "e-p:32:32-i64:64-v128:32:128-n32-S128",
+  "llvm-target": "i686-unknown-linux-gnu",
+  "target-endian": "little",
+  "target-word-size": "32",
+  "arch": "x86",
+  "os": "emscripten",
+  "morestack": false,
+  "dynamic-linking": true,
+  "executables": true,
+  "no-compiler-rt": true
+}

src/lib.rs

@@ -9,6 +9,7 @@ extern crate regex;
 use cargo::ops::{ExecEngine, CommandPrototype};
 use cargo::util::{mod, CargoResult, ProcessError, ProcessBuilder};
 
+use std::io::TempDir;
 use std::io::fs::{File, PathExtensions};
 use std::io::process::ProcessOutput;
 
@@ -32,16 +33,35 @@ impl ExecEngine for EmscriptenEngine {
 fn exec(command: CommandPrototype, with_output: bool, engine: &EmscriptenEngine)
         -> Result<Option<ProcessOutput>, ProcessError>
 {
+    let build_dir = TempDir::new("cargo-emscripten").unwrap();
+
+    // finding out dir
+    let out_dir = command.get_args().windows(2)
+                            .filter_map(|args| {
+                                if args[0].as_str() == Some("--out-dir") {
+                                    Some(args[1].as_str().unwrap().to_string())
+                                } else {
+                                    None
+                                }
+                            })
+                            .next().unwrap();
+
+    // writing `specs.json` in the out dir
+    File::create(&build_dir.path().join("emscripten.json")).write(include_bytes!("../specs-target.json")).unwrap();
+
+    // writing libstd in the target directory
+    let (libs_ll, libs_rlib) = std_inc::write_std(&Path::new(build_dir.path()));
+
     // if we don't find `--crate-type bin`, returning immediatly
-    if command.get_args().windows(2)
+    /*if command.get_args().windows(2)
                          .find(|&args| {
                              args[0].as_str() == Some("--crate-type") &&
                              args[1].as_str() == Some("bin")
                          }).is_none()
     {
         let p = command.into_process_builder().unwrap();
         return do_exec(p, with_output);
-    }
+    }*/
 
     // finding crate name
     let crate_name = command.get_args().windows(2)
@@ -54,17 +74,6 @@ fn exec(command: CommandPrototype, with_output: bool, engine: &EmscriptenEngine)
                             })
                             .next().unwrap();
 
-    // finding out dir
-    let out_dir = command.get_args().windows(2)
-                            .filter_map(|args| {
-                                if args[0].as_str() == Some("--out-dir") {
-                                    Some(args[1].as_str().unwrap().to_string())
-                                } else {
-                                    None
-                                }
-                            })
-                            .next().unwrap();
-
     // executing compiler
     {
         let mut new_command = CommandPrototype::new(command.get_type().clone()).unwrap();
@@ -74,9 +83,19 @@ fn exec(command: CommandPrototype, with_output: bool, engine: &EmscriptenEngine)
         for (key, val) in command.get_envs().iter() {
             new_command = new_command.env(key.as_slice(), val.as_ref().map(|v| v.as_bytes_no_nul()));
         }
-        new_command = new_command.cwd(command.get_cwd().clone());
+        //new_command = new_command.cwd(command.get_cwd().clone());
+
+        new_command = new_command.arg("--emit=llvm-ir,dep-info");
+        new_command = new_command.arg("--target").arg("emscripten.json");
+        new_command = new_command.cwd(build_dir.path().clone());
+
+        for (name, path) in libs_rlib.into_iter() {
+            new_command = new_command.arg("--extern").arg(format!("{}={}", name, path.as_str().unwrap()));
+        }
+
+        // TODO: shouldn't be necessary with the "--extern" commands
+        new_command = new_command.arg("-L").arg(build_dir.path());
 
-        let new_command = new_command.arg("--emit=llvm-ir,dep-info");
         try!(do_exec(new_command.into_process_builder().unwrap(), with_output));
     }
 
@@ -94,12 +113,13 @@ fn exec(command: CommandPrototype, with_output: bool, engine: &EmscriptenEngine)
         let mut process = util::process(emcc).unwrap();
         process = process.arg(ll_output_file);
 
-        for lib in libstd.into_iter() {
+        for lib in libs_ll.into_iter() {
             process = process.arg(lib);
         }
 
         process = process.arg("-lGL").arg("-lSDL").arg("-s").arg("USE_SDL=2");
         process = process.arg("-o").arg(format!("{}/{}.html", out_dir, crate_name));
+        process = process.cwd(build_dir.path().clone());
         process
     };
 

src/std_inc.rs

@@ -7,20 +7,34 @@ static LIBRAND: &'static [u8] = include_bytes!(concat!(env!("OUT_DIR"), "/rand.l
 static LIBSTD: &'static [u8] = include_bytes!(concat!(env!("OUT_DIR"), "/std.ll"));
 static LIBUNICODE: &'static [u8] = include_bytes!(concat!(env!("OUT_DIR"), "/unicode.ll"));
 
-pub fn write_std(path: &Path) -> Vec<Path> {
+pub fn write_std(path: &Path) -> (Vec<Path>, Vec<(&'static str, Path)>) {
     File::create(&path.join("collections.ll")).write(LIBCOLLECTIONS).unwrap();
     File::create(&path.join("core.ll")).write(LIBCORE).unwrap();
     File::create(&path.join("libc.ll")).write(LIBLIBC).unwrap();
     File::create(&path.join("rand.ll")).write(LIBRAND).unwrap();
     File::create(&path.join("std.ll")).write(LIBSTD).unwrap();
     File::create(&path.join("unicode.ll")).write(LIBUNICODE).unwrap();
 
-    vec![
-        path.join("collections.ll"),
-        path.join("core.ll"),
-        path.join("libc.ll"),
-        path.join("rand.ll"),
-        path.join("std.ll"),
-        path.join("unicode.ll"),
-    ]
+    File::create(&path.join("libcollections.rlib")).write(
+                include_bytes!(concat!(env!("OUT_DIR"), "/libcollections.rlib"))).unwrap();
+    File::create(&path.join("libcore.rlib")).write(
+                include_bytes!(concat!(env!("OUT_DIR"), "/libcore.rlib"))).unwrap();
+    File::create(&path.join("liblibc.rlib")).write(
+                include_bytes!(concat!(env!("OUT_DIR"), "/liblibc.rlib"))).unwrap();
+
+    (
+        vec![
+            path.join("collections.ll"),
+            path.join("core.ll"),
+            path.join("libc.ll"),
+            path.join("rand.ll"),
+            path.join("std.ll"),
+            path.join("unicode.ll"),
+        ],
+        vec![
+            ("collections", path.join("libcollections.rlib")),
+            ("core", path.join("libcore.rlib")),
+            ("libc", path.join("liblibc.rlib"))
+        ]
+    )
 }