support sm_100 and llvm v19

Author: brandonros

.devcontainer.json

@@ -17,4 +17,4 @@
   "features": {
     "ghcr.io/devcontainers/features/git:1": {}
   }
-}
+}

.gitignore

@@ -2,4 +2,4 @@ book
 /target
 Cargo.lock
 **/.vscode
-.devcontainer
+.devcontainer

container/ubuntu22-cuda12/Dockerfile

@@ -1,4 +1,4 @@
-FROM nvidia/cuda:12.8.1-cudnn-devel-ubuntu22.04
+FROM nvidia/cuda:12.9.0-cudnn-devel-ubuntu22.04
 
 RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get -qq -y install \
     build-essential \

container/ubuntu24-cuda12/Dockerfile

@@ -1,4 +1,4 @@
-FROM nvidia/cuda:12.8.1-cudnn-devel-ubuntu24.04
+FROM nvidia/cuda:12.9.0-cudnn-devel-ubuntu24.04
 
 RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get -qq -y install \
     build-essential \

crates/cuda_std/src/cfg.rs

@@ -16,6 +16,11 @@ pub enum ComputeCapability {
     Compute72,
     Compute75,
     Compute80,
+    Compute86,
+    Compute87,
+    Compute89,
+    Compute90,
+    Compute100
 }
 
 impl ComputeCapability {
@@ -42,6 +47,11 @@ impl ComputeCapability {
             "720" => ComputeCapability::Compute72,
             "750" => ComputeCapability::Compute75,
             "800" => ComputeCapability::Compute80,
+            "860" => ComputeCapability::Compute86,  // Ampere (RTX 30 series, A100)
+            "870" => ComputeCapability::Compute87,  // Ampere (Jetson AGX Orin)
+            "890" => ComputeCapability::Compute89,  // Ada Lovelace (RTX 40 series)
+            "900" => ComputeCapability::Compute90,  // Hopper (H100)
+            "1000" => ComputeCapability::Compute100, // Blackwell (RTX 50 series, H200, B100)
             _ => panic!("CUDA_ARCH had an invalid value"),
         }
     }

crates/cust/src/module.rs

@@ -56,6 +56,10 @@ pub enum JitTarget {
     Compute75 = 75,
     Compute80 = 80,
     Compute86 = 86,
+    Compute87 = 87,
+    Compute89 = 89,
+    Compute90 = 90,
+    Compute100 = 100,
 }
 
 /// How to handle cases where a loaded module's data does not contain an exact match for the

crates/nvvm/src/lib.rs

@@ -4,7 +4,6 @@ use std::{
     ffi::{CStr, CString},
     fmt::Display,
     mem::MaybeUninit,
-    ptr::null_mut,
     str::FromStr,
 };
 
@@ -255,6 +254,11 @@ impl FromStr for NvvmOption {
                     "72" => NvvmArch::Compute72,
                     "75" => NvvmArch::Compute75,
                     "80" => NvvmArch::Compute80,
+                    "86" => NvvmArch::Compute86,
+                    "87" => NvvmArch::Compute87,
+                    "89" => NvvmArch::Compute89,
+                    "90" => NvvmArch::Compute90,
+                    "100" => NvvmArch::Compute100,
                     _ => return Err("unknown arch"),
                 };
                 Self::Arch(arch)
@@ -279,6 +283,11 @@ pub enum NvvmArch {
     Compute72,
     Compute75,
     Compute80,
+    Compute86,
+    Compute87,
+    Compute89,
+    Compute90,
+    Compute100,
 }
 
 impl Display for NvvmArch {
@@ -403,8 +412,21 @@ impl NvvmProgram {
 
     /// Verify the program without actually compiling it. In the case of invalid IR, you can find
     /// more detailed error info by calling [`compiler_log`](Self::compiler_log).
-    pub fn verify(&self) -> Result<(), NvvmError> {
-        unsafe { nvvm_sys::nvvmVerifyProgram(self.raw, 0, null_mut()).to_result() }
+    pub fn verify(&self, options: &[NvvmOption]) -> Result<(), NvvmError> {
+        let option_strings: Vec<_> = options.iter().map(|opt| opt.to_string()).collect();
+        let option_cstrings: Vec<_> = option_strings.iter()
+            .map(|s| std::ffi::CString::new(s.as_str()).unwrap())
+            .collect();
+        let mut option_ptrs: Vec<_> = option_cstrings.iter()
+            .map(|cs| cs.as_ptr())
+            .collect();
+        unsafe { 
+            nvvm_sys::nvvmVerifyProgram(
+                self.raw, 
+                option_ptrs.len() as i32, 
+                option_ptrs.as_mut_ptr()
+            ).to_result() 
+        }
     }
 }
 
@@ -433,6 +455,11 @@ mod tests {
             "-arch=compute_72",
             "-arch=compute_75",
             "-arch=compute_80",
+            "-arch=compute_86",
+            "-arch=compute_87",
+            "-arch=compute_89",
+            "-arch=compute_90",
+            "-arch=compute_100",
             "-ftz=1",
             "-prec-sqrt=0",
             "-prec-div=0",
@@ -454,6 +481,11 @@ mod tests {
             Arch(Compute72),
             Arch(Compute75),
             Arch(Compute80),
+            Arch(Compute86),
+            Arch(Compute87),
+            Arch(Compute89),
+            Arch(Compute90),
+            Arch(Compute100),
             Ftz,
             FastSqrt,
             FastDiv,

crates/rustc_codegen_nvvm/build.rs

@@ -143,11 +143,45 @@ pub fn tracked_env_var_os<K: AsRef<OsStr> + Display>(key: K) -> Option<OsString>
     env::var_os(key)
 }
 
+fn run_llvm_as() {
+    // Check if libintrinsics.ll exists
+    let libintrinsics_path = Path::new("libintrinsics.ll");
+    if !libintrinsics_path.exists() {
+        fail("libintrinsics.ll not found");
+    }
+    
+    println!("cargo:rerun-if-changed=libintrinsics.ll");
+    
+    let mut cmd = Command::new("llvm-as");
+    cmd.arg("libintrinsics.ll");
+    
+    let output = match cmd.stderr(Stdio::inherit()).output() {
+        Ok(status) => status,
+        Err(e) => fail(&format!(
+            "failed to execute llvm-as: {:?}\nerror: {}",
+            cmd, e
+        )),
+    };
+    
+    if !output.status.success() {
+        fail(&format!(
+            "llvm-as failed: {:?}\nstatus: {}",
+            cmd, output.status
+        ));
+    }
+}
+
 fn rustc_llvm_build() {
     let target = env::var("TARGET").expect("TARGET was not set");
     let llvm_config = find_llvm_config(&target);
 
-    let required_components = &["ipo", "bitreader", "bitwriter", "lto", "nvptx"];
+    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<_>>();
@@ -165,6 +199,9 @@ fn rustc_llvm_build() {
         println!("cargo:rustc-cfg=llvm_component=\"{}\"", component);
     }
 
+    // Run llvm-as on libintrinsics.ll
+    run_llvm_as();
+
     // Link in our own LLVM shims, compiled with the same flags as LLVM
     let mut cmd = Command::new(&llvm_config);
     cmd.arg("--cxxflags");

crates/rustc_codegen_nvvm/libintrinsics.bc

@@ -5,7 +5,7 @@
 ; if you update this make sure to update libintrinsics.bc by running llvm-as (make sure you are using llvm-7 or it won't work when
 ; loaded into libnvvm).
 source_filename = "libintrinsics"
-target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-n16:32:64"
+target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-i128:128:128-f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-n16:32:64-a:8:8"
 target triple = "nvptx64-nvidia-cuda"
 
 ; thread ----

crates/rustc_codegen_nvvm/libintrinsics.ll

@@ -0,0 +1,49 @@
+#ifndef INCLUDED_RUSTC_LLVM_LLVMWRAPPER_H
+#define INCLUDED_RUSTC_LLVM_LLVMWRAPPER_H
+
+#include "SuppressLLVMWarnings.h"
+
+#include "llvm/Config/llvm-config.h"  // LLVM_VERSION_MAJOR, LLVM_VERSION_MINOR
+#include "llvm/Support/raw_ostream.h" // llvm::raw_ostream
+#include <cstddef>                    // size_t etc
+#include <cstdint>                    // uint64_t etc
+
+#define LLVM_VERSION_GE(major, minor)                                          \
+  (LLVM_VERSION_MAJOR > (major) ||                                             \
+   LLVM_VERSION_MAJOR == (major) && LLVM_VERSION_MINOR >= (minor))
+
+#define LLVM_VERSION_LT(major, minor) (!LLVM_VERSION_GE((major), (minor)))
+
+extern "C" void LLVMRustSetLastError(const char *);
+
+enum class LLVMRustResult { Success, Failure };
+
+typedef struct OpaqueRustString *RustStringRef;
+typedef struct LLVMOpaqueTwine *LLVMTwineRef;
+typedef struct LLVMOpaqueSMDiagnostic *LLVMSMDiagnosticRef;
+
+extern "C" void LLVMRustStringWriteImpl(RustStringRef buf,
+                                        const char *slice_ptr,
+                                        size_t slice_len);
+
+class RawRustStringOstream : public llvm::raw_ostream {
+  RustStringRef Str;
+  uint64_t Pos;
+
+  void write_impl(const char *Ptr, size_t Size) override {
+    LLVMRustStringWriteImpl(Str, Ptr, Size);
+    Pos += Size;
+  }
+
+  uint64_t current_pos() const override { return Pos; }
+
+public:
+  explicit RawRustStringOstream(RustStringRef Str) : Str(Str), Pos(0) {}
+
+  ~RawRustStringOstream() {
+    // LLVM requires this.
+    flush();
+  }
+};
+
+#endif // INCLUDED_RUSTC_LLVM_LLVMWRAPPER_H