Initial commit

Author: denzp

.gitignore

@@ -0,0 +1,5 @@
+/target
+**/*.rs.bk
+Cargo.lock
+
+src/llvm_gen.rs

.travis.yml

@@ -0,0 +1,28 @@
+language: rust
+cache: cargo
+
+matrix:
+  include:
+    - os: linux
+      rust: nightly
+
+    - os: linux
+      rust: stable
+
+    - os: osx
+      rust: nightly
+
+    - os: osx
+      rust: stable
+
+script:
+  - cargo check
+  - cargo test
+
+branches:
+  only:
+    - master
+
+notifications:
+  email:
+    on_success: never

Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "rustc-llvm-proxy"
+version = "0.1.0"
+authors = ["Denys Zariaiev <denys.zariaiev@gmail.com>"]
+
+[dependencies]
+libloading = "0.5"
+lazy_static = "1.0"
+failure = "0.1"
+libc = "0.2"
+
+[dependencies.llvm-sys]
+git = "https://github.com/denzp/llvm-sys.rs.git"
+features = ["no-llvm-linking"]
+
+[build-dependencies]
+cargo_metadata = "0.6"
+failure = "0.1"
+quote = "0.6"
+
+[build-dependencies.syn]
+version = "0.14"
+features = ["full", "extra-traits"] # TODO: remove extra-traits

build.rs

@@ -0,0 +1,165 @@
+extern crate cargo_metadata;
+extern crate quote;
+extern crate syn;
+
+#[macro_use]
+extern crate failure;
+
+fn main() {
+    println!("cargo:rerun-if-changed=build.rs");
+    println!("cargo:rerun-if-changed=src/llvm_gen.rs");
+
+    llvm::Generator::default()
+        .parse_llvm_sys_crate()
+        .expect("Unable to parse 'llvm-sys' crate")
+        .write_declarations("src/llvm_gen.rs")
+        .expect("Unable to write generated LLVM declarations");
+}
+
+#[derive(Debug)]
+struct Declaration {
+    name: String,
+    args: String,
+    ret_ty: String,
+}
+
+mod llvm {
+    use std::fs::File;
+    use std::io::{Read, Write};
+    use std::path::{Path, PathBuf};
+
+    use cargo_metadata::metadata_deps;
+    use failure::Error;
+    use quote::ToTokens;
+    use syn::{parse_file, Abi, ForeignItem, Item, ItemForeignMod, ReturnType};
+
+    use super::*;
+
+    const LLVM_SOURCES: &[&str] = &[
+        "core.rs",
+        "linker.rs",
+        "bit_reader.rs",
+        "bit_writer.rs",
+        "target.rs",
+        "target_machine.rs",
+        "transforms/ipo.rs",
+        "transforms/pass_manager_builder.rs",
+        "transforms/scalar.rs",
+        "transforms/vectorize.rs",
+    ];
+
+    #[derive(Default)]
+    pub struct Generator {
+        declarations: Vec<Declaration>,
+    }
+
+    impl Generator {
+        pub fn parse_llvm_sys_crate(mut self) -> Result<Self, Error> {
+            let llvm_src_path = self.get_llvm_sys_crate_path()?;
+
+            for file in LLVM_SOURCES {
+                let path = llvm_src_path.join(file);
+                let mut declarations = self.extract_file_declarations(&path)?;
+
+                self.declarations.append(&mut declarations);
+            }
+
+            Ok(self)
+        }
+
+        pub fn write_declarations(self, path: &str) -> Result<(), Error> {
+            let mut file = File::create(path)?;
+
+            for decl in self.declarations {
+                writeln!(
+                    file,
+                    "create_proxy!({}; {}; {});",
+                    decl.name, decl.ret_ty, decl.args
+                );
+            }
+
+            Ok(())
+        }
+
+        fn get_llvm_sys_crate_path(&self) -> Result<PathBuf, Error> {
+            let metadata = metadata_deps(None, true)
+                .map_err(|_| format_err!("Unable to get crate metadata"))?;
+
+            let llvm_dependency = metadata
+                .packages
+                .into_iter()
+                .find(|item| item.name == "llvm-sys")
+                .ok_or(format_err!(
+                    "Unable to find 'llvm-sys' in the crate metadata"
+                ))?;
+
+            let llvm_lib_rs_path = PathBuf::from(
+                llvm_dependency
+                    .targets
+                    .into_iter()
+                    .find(|item| item.name == "llvm-sys")
+                    .ok_or(format_err!(
+                        "Unable to find lib target for 'llvm-sys' crate"
+                    ))?.src_path,
+            );
+
+            Ok(llvm_lib_rs_path.parent().unwrap().into())
+        }
+
+        fn extract_file_declarations(&self, path: &Path) -> Result<Vec<Declaration>, Error> {
+            let mut file = File::open(path)
+                .map_err(|_| format_err!("Unable to open file: {}", path.to_str().unwrap()))?;
+
+            let mut content = String::new();
+            file.read_to_string(&mut content)?;
+
+            let ast = parse_file(&content)?;
+
+            Ok(ast.items.iter().fold(vec![], |mut list, item| match item {
+                Item::ForeignMod(ref item) if item.abi.is_c() => {
+                    list.append(&mut self.extract_foreign_mod_declarations(item));
+                    list
+                }
+
+                _ => list,
+            }))
+        }
+
+        fn extract_foreign_mod_declarations(&self, item: &ItemForeignMod) -> Vec<Declaration> {
+            item.items.iter().fold(vec![], |mut list, item| match item {
+                ForeignItem::Fn(ref item) => {
+                    let ret_ty = match item.decl.output {
+                        ReturnType::Default => "()".into(),
+                        ReturnType::Type(_, ref ty) => ty.into_token_stream().to_string(),
+                    };
+
+                    list.push(Declaration {
+                        name: item.ident.to_string(),
+                        args: item.decl.inputs.clone().into_token_stream().to_string(),
+                        ret_ty,
+                    });
+
+                    list
+                }
+
+                _ => list,
+            })
+        }
+    }
+
+    trait AbiExt {
+        fn is_c(&self) -> bool;
+    }
+
+    impl AbiExt for Abi {
+        fn is_c(&self) -> bool {
+            let abi_name = self
+                .name
+                .as_ref()
+                .map(|item| item.value())
+                .unwrap_or(String::new());
+
+            abi_name == "C"
+        }
+    }
+}

src/lib.rs

@@ -0,0 +1,65 @@
+#![deny(warnings)]
+#![allow(non_snake_case)]
+
+#[macro_use]
+extern crate lazy_static;
+#[macro_use]
+extern crate failure;
+
+extern crate libc;
+extern crate libloading as lib;
+extern crate llvm_sys;
+
+use lib::Library;
+
+mod path;
+use path::find_lib_path;
+
+lazy_static! {
+    static ref SHARED_LIB: Library = {
+        let lib_path = match find_lib_path() {
+            Ok(path) => path,
+
+            Err(error) => {
+                eprintln!("{}", error);
+                panic!();
+            }
+        };
+
+        match Library::new(lib_path) {
+            Ok(path) => path,
+
+            Err(error) => {
+                eprintln!("Unable to open LLVM shared lib: {}", error);
+                panic!();
+            }
+        }
+    };
+}
+
+pub mod proxy {
+    use super::SHARED_LIB;
+
+    use llvm_sys::prelude::*;
+    use llvm_sys::target::*;
+    use llvm_sys::target_machine::*;
+    use llvm_sys::transforms::pass_manager_builder::*;
+    use llvm_sys::*;
+
+    macro_rules! create_proxy {
+        ($name:ident ; $ret_ty:ty ; $($arg:ident : $arg_ty:ty),*) => {
+            #[no_mangle]
+            pub unsafe extern "C" fn $name($($arg: $arg_ty),*) -> $ret_ty {
+                let entrypoint = {
+                    *SHARED_LIB
+                        .get::<unsafe extern "C" fn($($arg: $arg_ty),*) -> $ret_ty>(stringify!($name).as_bytes())
+                        .unwrap()
+                };
+
+                entrypoint($($arg),*)
+            }
+        };
+    }
+
+    include!("llvm_gen.rs");
+}

src/path.rs

@@ -0,0 +1,106 @@
+use std::env;
+use std::path::PathBuf;
+use std::process::Command;
+
+use failure::Error;
+
+pub fn find_lib_path() -> Result<PathBuf, Error> {
+    let paths = collect_possible_paths()?;
+
+    if paths.len() == 0 {
+        bail!("Unable to find possible LLVM shared lib locations.");
+    }
+
+    for path in &paths {
+        if path.join("librustc_codegen_llvm-llvm.so").exists() {
+            return Ok(path.join("librustc_codegen_llvm-llvm.so"));
+        }
+
+        if path.join("librustc_codegen_llvm-llvm.dll").exists() {
+            return Ok(path.join("librustc_codegen_llvm-llvm.dll"));
+        }
+    }
+
+    bail!(
+        "Unable to find LLVM shared lib in possible locations:\n- {}",
+        paths
+            .into_iter()
+            .map(|item| item.to_str().unwrap().to_owned())
+            .collect::<Vec<_>>()
+            .join("\n- ")
+    );
+}
+
+fn collect_possible_paths() -> Result<Vec<PathBuf>, Error> {
+    let mut paths = vec![];
+
+    if let Ok(rustup_home) = env::var("RUSTUP_HOME") {
+        let rustup_home = PathBuf::from(rustup_home);
+        let rustup_toolchain = env::var("RUSTUP_TOOLCHAIN")?;
+        let rustup_arch = extract_arch(&rustup_toolchain);
+
+        paths.push(
+            rustup_home
+                .join("toolchains")
+                .join(&rustup_toolchain)
+                .join("lib/rustlib")
+                .join(rustup_arch)
+                .join("codegen-backends"),
+        );
+    }
+
+    if let Ok(lib_paths) = env::var("LD_LIBRARY_PATH") {
+        for item in lib_paths.split(":") {
+            let mut possible_path = PathBuf::from(item);
+            possible_path.pop();
+
+            let possible_toolchain = possible_path.file_name().unwrap();
+            let possible_arch = extract_arch(possible_toolchain.to_str().unwrap());
+
+            paths.push(
+                possible_path
+                    .join("lib/rustlib")
+                    .join(possible_arch)
+                    .join("codegen-backends"),
+            );
+        }
+    }
+
+    if let Ok(cargo) = env::var("CARGO") {
+        let mut cargo_path = PathBuf::from(cargo);
+        cargo_path.pop();
+        cargo_path.pop();
+
+        let toolchain = cargo_path.file_name().unwrap();
+        let arch = extract_arch(toolchain.to_str().unwrap());
+
+        paths.push(
+            cargo_path
+                .join("lib/rustlib")
+                .join(arch)
+                .join("codegen-backends"),
+        );
+    }
+
+    if let Ok(output) = Command::new("rustup").args(&["which", "rustc"]).output() {
+        let mut rustc_path = PathBuf::from(String::from_utf8_lossy(&output.stdout).trim());
+        rustc_path.pop();
+        rustc_path.pop();
+
+        let toolchain = rustc_path.file_name().unwrap();
+        let arch = extract_arch(toolchain.to_str().unwrap());
+
+        paths.push(
+            rustc_path
+                .join("lib/rustlib")
+                .join(arch)
+                .join("codegen-backends"),
+        );
+    }
+
+    Ok(paths)
+}
+
+fn extract_arch(toolchain: &str) -> String {
+    toolchain.split('-').skip(1).collect::<Vec<_>>().join("-")
+}