fix merge

Author: anderslanglands

crates/find_cuda_helper/src/lib.rs

@@ -135,3 +135,24 @@ pub fn find_optix_root() -> Option<PathBuf> {
         .or_else(|| env::var("OPTIX_ROOT_DIR").ok())
         .map(PathBuf::from)
 }
+
+#[cfg(target_os = "windows")]
+pub fn find_libnvvm_bin_dir() -> String {
+    find_cuda_root()
+        .expect("Failed to find CUDA ROOT, make sure the CUDA SDK is installed and CUDA_PATH or CUDA_ROOT are set!")
+        .join("nvvm")
+        .join("lib")
+        .join("x64")
+        .to_string_lossy()
+        .into_owned()
+}
+
+#[cfg(target_os = "linux")]
+pub fn find_libnvvm_bin_dir() -> String {
+    find_cuda_root()
+        .expect("Failed to find CUDA ROOT, make sure the CUDA SDK is installed and CUDA_PATH or CUDA_ROOT are set!")
+        .join("nvvm")
+        .join("lib64")
+        .to_string_lossy()
+        .into_owned()
+}

crates/nvvm/build.rs

@@ -1,26 +1,6 @@
-use find_cuda_helper::find_cuda_root;
-
-#[cfg(target_os = "windows")]
-fn lib_search_path() -> String {
-    find_cuda_root()
-        .expect("Failed to find CUDA ROOT, make sure the CUDA SDK is installed and CUDA_PATH or CUDA_ROOT are set!")
-        .join("nvvm")
-        .join("lib")
-        .join("x64")
-        .to_string_lossy()
-        .into_owned()
-}
-
-#[cfg(target_os = "linux")]
-fn lib_search_path() -> String {
-    format!("{}/nvvm/lib64", std::env::var("CUDA_ROOT").unwrap())
-}
-
-fn libnvvm_build() {
-    println!("cargo:rustc-link-search={}", lib_search_path());
-    println!("cargo:rustc-link-lib=dylib=nvvm");
-}
+use find_cuda_helper::find_libnvvm_bin_dir;
 
 fn main() {
-    libnvvm_build()
+    println!("cargo:rustc-link-search={}", find_libnvvm_bin_dir());
+    println!("cargo:rustc-link-lib=dylib=nvvm");
 }

crates/optix_sys/build.rs

@@ -12,6 +12,7 @@ fn main() {
         "Unable to find the OptiX SDK, make sure you installed it and
     that OPTIX_ROOT or OPTIX_ROOT_DIR are set",
     );
+
     optix_include = optix_include.join("include");
 
     let mut cuda_include = find_cuda_root().expect(

crates/rustc_codegen_nvvm/Cargo.toml

@@ -23,6 +23,9 @@ rustc_codegen_nvvm_macros = { version = "0.1", path = "../rustc_codegen_nvvm_mac
 [build-dependencies]
 build-helper = "0.1.1"
 cc = { version = "1.0", features = ["parallel"] }
+xz = "0.1.0"
+tar = "0.4.37"
+curl = "0.4.40"
 
 [package.metadata.rust-analyzer]
 rustc_private = true

crates/rustc_codegen_nvvm/build.rs

@@ -6,6 +6,15 @@ use std::{
     process::{Command, Stdio},
 };
 
+use curl::easy::Easy;
+use tar::Archive;
+use xz::read::XzDecoder;
+
+static PREBUILT_LLVM_URL: &str =
+    "https://github.com/RDambrosio016/rustc_codegen_nvvm-llvm/releases/download/LLVM-7.1.0/";
+
+static REQUIRED_MAJOR_LLVM_VERSION: u8 = 7;
+
 fn main() {
     rustc_llvm_build();
 
@@ -40,6 +49,74 @@ pub fn output(cmd: &mut Command) -> String {
     String::from_utf8(output.stdout).unwrap()
 }
 
+fn target_to_llvm_prebuilt(target: &str) -> String {
+    let base = match target {
+        "x86_64-pc-windows-msvc" => "windows-x86_64",
+        "x86_64-unknown-linux-gnu" => "linux-x86_64",
+        _ => panic!("Unsupported target with no matching prebuilt LLVM: `{}`, install LLVM and set LLVM_CONFIG", target)
+    };
+    format!("{}.tar.xz", base)
+}
+
+fn find_llvm_config(target: &str) -> PathBuf {
+    // first, if LLVM_CONFIG is set then see if its llvm version if 7.x, if so, use that.
+    let config_env = tracked_env_var_os("LLVM_CONFIG");
+    // if LLVM_CONFIG is not set, try using llvm-config as a normal app in PATH.
+    let path_to_try = config_env.unwrap_or_else(|| "llvm-config".into());
+
+    // if USE_PREBUILT_LLVM is set to 1 then download prebuilt llvm without trying llvm-config
+    if tracked_env_var_os("USE_PREBUILT_LLVM") != Some("1".into()) {
+        let cmd = Command::new(&path_to_try).arg("--version").output();
+
+        if let Ok(out) = cmd {
+            let version = String::from_utf8(out.stdout).unwrap();
+            if version.starts_with(&REQUIRED_MAJOR_LLVM_VERSION.to_string()) {
+                return PathBuf::from(path_to_try);
+            }
+        }
+    }
+
+    // otherwise, download prebuilt LLVM.
+    println!("cargo:warning=LLVM not found, downloading prebuilt LLVM");
+    let mut url = tracked_env_var_os("PREBUILT_LLVM_URL")
+        .map(|x| x.to_string_lossy().to_string())
+        .unwrap_or_else(|| PREBUILT_LLVM_URL.to_string());
+
+    let prebuilt_name = target_to_llvm_prebuilt(target);
+    url = format!("{}{}", url, prebuilt_name);
+
+    let out = env::var("OUT_DIR").expect("OUT_DIR was not set");
+    let mut easy = Easy::new();
+
+    easy.url(&url).unwrap();
+    let _redirect = easy.follow_location(true).unwrap();
+    let mut xz_encoded = Vec::with_capacity(20_000_000); // 20mb
+    {
+        let mut transfer = easy.transfer();
+        transfer
+            .write_function(|data| {
+                xz_encoded.extend_from_slice(data);
+                Ok(data.len())
+            })
+            .expect("Failed to download prebuilt LLVM");
+        transfer
+            .perform()
+            .expect("Failed to download prebuilt LLVM");
+    }
+
+    let decompressor = XzDecoder::new(xz_encoded.as_slice());
+    let mut ar = Archive::new(decompressor);
+
+    ar.unpack(&out).expect("Failed to unpack LLVM to LLVM dir");
+    let out_path = PathBuf::from(out).join(prebuilt_name.strip_suffix(".tar.xz").unwrap());
+
+    println!("cargo:rerun-if-changed={}", out_path.display());
+
+    out_path
+        .join("bin")
+        .join(format!("llvm-config{}", std::env::consts::EXE_SUFFIX))
+}
+
 fn detect_llvm_link() -> (&'static str, &'static str) {
     // Force the link mode we want, preferring static by default, but
     // possibly overridden by `configure --enable-llvm-link-shared`.
@@ -57,62 +134,13 @@ pub fn tracked_env_var_os<K: AsRef<OsStr> + Display>(key: K) -> Option<OsString>
 
 fn rustc_llvm_build() {
     let target = env::var("TARGET").expect("TARGET was not set");
-    let llvm_config = tracked_env_var_os("LLVM_CONFIG")
-        .map(|x| Some(PathBuf::from(x)))
-        .unwrap_or_else(|| {
-            if let Some(dir) = tracked_env_var_os("CARGO_TARGET_DIR").map(PathBuf::from) {
-                let to_test = dir
-                    .parent()
-                    .unwrap()
-                    .parent()
-                    .unwrap()
-                    .join(&target)
-                    .join("llvm/bin/llvm-config");
-                if Command::new(&to_test).output().is_ok() {
-                    return Some(to_test);
-                }
-            }
-            None
-        });
+    let llvm_config = find_llvm_config(&target);
 
-    if let Some(llvm_config) = &llvm_config {
-        println!("cargo:rerun-if-changed={}", llvm_config.display());
-    }
-    let llvm_config = llvm_config.unwrap_or_else(|| PathBuf::from("llvm-config"));
-
-    let optional_components = &[
-        "x86",
-        "arm",
-        "aarch64",
-        "amdgpu",
-        "avr",
-        "mips",
-        "powerpc",
-        "systemz",
-        "jsbackend",
-        "webassembly",
-        "msp430",
-        "sparc",
-        "nvptx",
-        "hexagon",
-        "riscv",
-        "bpf",
-    ];
-
-    let required_components = &[
-        "ipo",
-        "bitreader",
-        "bitwriter",
-        "linker",
-        "asmparser",
-        "lto",
-        "coverage",
-        "instrumentation",
-    ];
+    let required_components = &["ipo", "bitreader", "bitwriter", "lto", "nvptx"];
 
     let components = output(Command::new(&llvm_config).arg("--components"));
     let mut components = components.split_whitespace().collect::<Vec<_>>();
-    components.retain(|c| optional_components.contains(c) || required_components.contains(c));
+    components.retain(|c| required_components.contains(c));
 
     for component in required_components {
         if !components.contains(component) {
@@ -134,6 +162,16 @@ fn rustc_llvm_build() {
         if flag.starts_with("-flto") {
             continue;
         }
+        // ignore flags that aren't supported in gcc 8
+        if flag == "-Wcovered-switch-default" {
+            continue;
+        }
+        if flag == "-Wstring-conversion" {
+            continue;
+        }
+        if flag == "-Werror=unguarded-availability-new" {
+            continue;
+        }
 
         cfg.flag(flag);
     }
@@ -151,7 +189,7 @@ fn rustc_llvm_build() {
     build_helper::rerun_if_changed(Path::new("rustc_llvm_wrapper"));
     cfg.file("rustc_llvm_wrapper/RustWrapper.cpp")
         .file("rustc_llvm_wrapper/PassWrapper.cpp")
-        .include("rustc_llvm_wrapper/rustllvm.h")
+        .include("rustc_llvm_wrapper")
         .cpp(true)
         .cpp_link_stdlib(None) // we handle this below
         .compile("llvm-wrapper");
@@ -209,7 +247,7 @@ fn rustc_llvm_build() {
 
     // Link in the system libraries that LLVM depends on
     #[cfg(not(target_os = "windows"))]
-    link_llvm_system_libs(&llvm_config);
+    link_llvm_system_libs(&llvm_config, required_components);
 
     // LLVM ldflags
     //
@@ -298,10 +336,14 @@ fn rustc_llvm_build() {
 }
 
 #[cfg(not(target_os = "windows"))]
-fn link_llvm_system_libs(llvm_config: &Path) {
+fn link_llvm_system_libs(llvm_config: &Path, components: &[&str]) {
     let mut cmd = Command::new(&llvm_config);
     cmd.arg("--system-libs");
 
+    for comp in components {
+        cmd.arg(comp);
+    }
+
     for lib in output(&mut cmd).split_whitespace() {
         let name = if let Some(stripped) = lib.strip_prefix("-l") {
             stripped

crates/rustc_codegen_nvvm/rustc_llvm_wrapper/RustWrapper.cpp

@@ -187,9 +187,22 @@ extern "C" LLVMValueRef LLVMRustGetOrInsertFunction(LLVMModuleRef M,
 }
 
 extern "C" LLVMValueRef
-LLVMRustGetOrInsertGlobal(LLVMModuleRef M, const char *Name, LLVMTypeRef Ty)
-{
+LLVMRustGetOrInsertGlobal(LLVMModuleRef M, const char *Name, LLVMTypeRef Ty, unsigned AddressSpace)
+{
+  // Module *Mod = unwrap(M);
+  // GlobalVariable *GV = dyn_cast_or_null<GlobalVariable>(Mod->getNamedValue(Name));
+  // if (!GV)
+  // {
+  //   GV = new GlobalVariable(unwrap(Ty), false, GlobalValue::ExternalLinkage,
+  //                           nullptr, Name, GlobalValue::NotThreadLocal, AddressSpace);
+  // }
+  // Type *GVTy = GV->getType();
+  // PointerType *PTy = PointerType::get(unwrap(Ty), GVTy->getPointerAddressSpace());
+  // if (GVTy != PTy)
+  //   return wrap(ConstantExpr::getBitCast(GV, PTy));
+
   return wrap(unwrap(M)->getOrInsertGlobal(Name, unwrap(Ty)));
+  // return wrap(GV);
 }
 
 extern "C" LLVMTypeRef LLVMRustMetadataTypeInContext(LLVMContextRef C)

crates/rustc_codegen_nvvm/src/abi.rs

@@ -11,7 +11,7 @@ use rustc_codegen_ssa::{traits::*, MemFlags};
 use rustc_middle::bug;
 use rustc_middle::ty::layout::LayoutOf;
 pub use rustc_middle::ty::layout::{FAT_PTR_ADDR, FAT_PTR_EXTRA};
-use rustc_middle::ty::{Ty, TyCtxt};
+use rustc_middle::ty::{Ty, TyCtxt, TyKind};
 pub use rustc_target::abi::call::*;
 use rustc_target::abi::call::{CastTarget, Reg, RegKind};
 use rustc_target::abi::{self, HasDataLayout, Int};
@@ -27,20 +27,27 @@ pub(crate) fn readjust_fn_abi<'tcx>(
         return fn_abi;
     }
     let readjust_arg_abi = |arg: &ArgAbi<'tcx, Ty<'tcx>>| {
-        let mut arg = ArgAbi::new(&tcx, arg.layout, |_, _, _| ArgAttributes::new());
+        let mut arg = ArgAbi {
+            layout: arg.layout,
+            mode: arg.mode,
+            pad: arg.pad,
+        };
 
         // ignore zsts
         if arg.layout.is_zst() {
             arg.mode = PassMode::Ignore;
         }
 
-        // this should never happen since rustc has always passed slices as pairs for years but we override it just to make sure.
-        // if rustc suddenly changes this we are in for a world of segfaults so if you are a rustc dev reading this, please dont, thanks :)
-        if arg.layout.ty.is_slice() && !matches!(arg.mode, PassMode::Pair { .. }) {
-            arg.mode = PassMode::Pair(ArgAttributes::new(), ArgAttributes::new());
+        if let TyKind::Ref(_, ty, _) = arg.layout.ty.kind() {
+            if matches!(ty.kind(), TyKind::Slice(_)) {
+                let mut ptr_attrs = ArgAttributes::new();
+                if let PassMode::Indirect { attrs, .. } = arg.mode {
+                    ptr_attrs.regular = attrs.regular;
+                }
+                arg.mode = PassMode::Pair(ptr_attrs, ArgAttributes::new());
+            }
         }
 
-        // same as in slice's case
         if arg.layout.ty.is_array() && !matches!(arg.mode, PassMode::Direct { .. }) {
             arg.mode = PassMode::Direct(ArgAttributes::new());
         }