compute_100 target

Author: brandonros

.gitignore

@@ -3,3 +3,5 @@ book
 **/.vscode
 .devcontainer
 .codex
+rustc-ice-*.txt
+.nix-driver-libs

crates/nvvm/src/lib.rs

@@ -448,6 +448,14 @@ impl NvvmArch {
         self.capability_value() % 10
     }
 
+    /// Whether this target uses NVVM's modern IR dialect rather than the legacy LLVM 7 dialect.
+    ///
+    /// CUDA 13.2 documents the modern dialect as Blackwell-and-later only, which begins at
+    /// `compute_100`.
+    pub fn uses_modern_ir_dialect(&self) -> bool {
+        self.capability_value() >= 100
+    }
+
     /// Get the target feature string (e.g., "compute_50" for `Compute50`, "compute_90a" for
     /// `Compute90a`).
     pub fn target_feature(&self) -> &'static str {

crates/rustc_codegen_nvvm/rustc_llvm_wrapper/RustWrapper.cpp

@@ -284,7 +284,11 @@ static Attribute::AttrKind fromRust(LLVMRustAttribute Kind)
   case SExt:
     return Attribute::SExt;
   case StructRet:
+#if LLVM_VERSION_MAJOR >= 19
+    report_fatal_error("StructRet not supported without a type on LLVM 19+");
+#else
     return Attribute::StructRet;
+#endif
   case UWTable:
     return Attribute::UWTable;
   case ZExt:
@@ -422,6 +426,41 @@ extern "C" void LLVMRustAddFunctionAttribute(LLVMValueRef Fn, unsigned Index,
 #endif
 }
 
+extern "C" void LLVMRustAddFunctionAttributeWithType(LLVMValueRef Fn, unsigned Index,
+                                                     LLVMRustAttribute RustAttr,
+                                                     LLVMTypeRef Ty)
+{
+#if LLVM_VERSION_MAJOR >= 19
+  Function *A = unwrap<Function>(Fn);
+  LLVMContext &Ctx = A->getContext();
+  AttrBuilder B(Ctx);
+  if (RustAttr == StructRet) {
+    B.addStructRetAttr(unwrap(Ty));
+  } else if (RustAttr == ByVal) {
+    B.addByValAttr(unwrap(Ty));
+  } else {
+    B.addAttribute(Attribute::get(Ctx, fromRust(RustAttr)));
+  }
+  A->setAttributes(A->getAttributes().addAttributesAtIndex(Ctx, Index, B));
+#else
+  Function *A = unwrap<Function>(Fn);
+  Attribute Attr;
+  if (RustAttr == StructRet) {
+    Attr = Attribute::getWithStructRetType(A->getContext(), unwrap(Ty));
+  } else if (RustAttr == ByVal) {
+    Attr = Attribute::getWithByValType(A->getContext(), unwrap(Ty));
+  } else {
+    Attr = Attribute::get(A->getContext(), fromRust(RustAttr));
+  }
+  AttrBuilder B(Attr);
+#if LLVM_VERSION_GE(5, 0)
+  A->addAttributes(Index, B);
+#else
+  A->addAttributes(Index, AttributeSet::get(A->getContext(), Index, B));
+#endif
+#endif
+}
+
 extern "C" void LLVMRustAddAlignmentAttr(LLVMValueRef Fn,
                                          unsigned Index,
                                          uint32_t Bytes)

crates/rustc_codegen_nvvm/src/abi.rs

@@ -144,9 +144,9 @@ impl ArgAttributesExt for ArgAttributes {
                     llvm::LLVMRustAddDereferenceableOrNullAttr(llfn, idx.as_uint(), deref);
                 }
                 regular -= ArgAttribute::NonNull;
-            }
-            if let Some(align) = self.pointee_align {
-                llvm::LLVMRustAddAlignmentAttr(llfn, idx.as_uint(), align.bytes() as u32);
+                if let Some(align) = self.pointee_align {
+                    llvm::LLVMRustAddAlignmentAttr(llfn, idx.as_uint(), align.bytes() as u32);
+                }
             }
             regular.for_each_kind(|attr| attr.apply_llfn(idx, llfn));
             // TODO(RDambrosio016): Apply mutable noalias once we upgrade to LLVM 13
@@ -182,13 +182,13 @@ impl ArgAttributesExt for ArgAttributes {
                     );
                 }
                 regular -= ArgAttribute::NonNull;
-            }
-            if let Some(align) = self.pointee_align {
-                llvm::LLVMRustAddAlignmentCallSiteAttr(
-                    callsite,
-                    idx.as_uint(),
-                    align.bytes() as u32,
-                );
+                if let Some(align) = self.pointee_align {
+                    llvm::LLVMRustAddAlignmentCallSiteAttr(
+                        callsite,
+                        idx.as_uint(),
+                        align.bytes() as u32,
+                    );
+                }
             }
             regular.for_each_kind(|attr| attr.apply_callsite(idx, callsite));
             match self.arg_ext {
@@ -443,6 +443,13 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
             } => {
                 assert!(!on_stack);
                 let i = apply(attrs);
+                #[cfg(feature = "llvm19")]
+                llvm::Attribute::StructRet.apply_llfn_with_type(
+                    llvm::AttributePlace::Argument(i),
+                    llfn,
+                    self.ret.memory_ty(cx),
+                );
+                #[cfg(not(feature = "llvm19"))]
                 llvm::Attribute::StructRet.apply_llfn(llvm::AttributePlace::Argument(i), llfn);
             }
             _ => {}

crates/rustc_codegen_nvvm/src/llvm.rs

@@ -97,6 +97,11 @@ impl Attribute {
         unsafe { LLVMRustAddFunctionAttribute(llfn, idx.as_uint(), *self) }
     }
 
+    #[cfg(feature = "llvm19")]
+    pub fn apply_llfn_with_type(&self, idx: AttributePlace, llfn: &Value, ty: &Type) {
+        unsafe { LLVMRustAddFunctionAttributeWithType(llfn, idx.as_uint(), *self, ty) }
+    }
+
     pub fn apply_callsite(&self, idx: AttributePlace, callsite: &Value) {
         unsafe { LLVMRustAddCallSiteAttribute(callsite, idx.as_uint(), *self) }
     }
@@ -1624,6 +1629,13 @@ unsafe extern "C" {
     pub(crate) fn LLVMSetFunctionCallConv(Fn: &Value, CC: c_uint);
     pub(crate) fn LLVMRustAddAlignmentAttr(Fn: &Value, index: c_uint, bytes: u32);
     pub(crate) fn LLVMRustAddFunctionAttribute(Fn: &Value, index: c_uint, attr: Attribute);
+    #[cfg(feature = "llvm19")]
+    pub(crate) fn LLVMRustAddFunctionAttributeWithType(
+        Fn: &Value,
+        index: c_uint,
+        attr: Attribute,
+        ty: &Type,
+    );
     pub(crate) fn LLVMRustAddFunctionAttrStringValue(
         Fn: &Value,
         index: c_uint,

crates/rustc_codegen_nvvm/src/nvvm.rs

@@ -43,6 +43,23 @@ impl Display for CodegenErr {
     }
 }
 
+#[cfg(feature = "llvm19")]
+fn is_known_nvvm_verify_false_negative(log: &str) -> bool {
+    log.contains("Producer: 'LLVM19")
+        && log.contains("Reader: 'LLVM 7.0.1'")
+        && log.contains("parse Invalid value")
+}
+
+fn selected_arch(args: &CodegenArgs) -> NvvmArch {
+    args.nvvm_options
+        .iter()
+        .find_map(|opt| match opt {
+            NvvmOption::Arch(arch) => Some(*arch),
+            _ => None,
+        })
+        .unwrap_or_default()
+}
+
 /// Take a list of bitcode module bytes and their names and codegen it
 /// into PTX bytes. The final PTX *should* be utf8, but just to be on the safe side
 /// it returns a vector of bytes.
@@ -56,6 +73,12 @@ pub fn codegen_bitcode_modules(
     llcx: &Context,
 ) -> Result<Vec<u8>, CodegenErr> {
     debug!("Codegenning bitcode to PTX");
+    let target_arch = selected_arch(args);
+    debug!(
+        "selected NVVM target arch: {} (modern dialect: {})",
+        target_arch,
+        target_arch.uses_modern_ir_dialect()
+    );
 
     // Make sure the nvvm version is high enough so users don't get confusing compilation errors.
     let (major, minor) = nvvm::ir_version();
@@ -116,19 +139,32 @@ pub fn codegen_bitcode_modules(
     let verification_res = prog.verify();
     if verification_res.is_err() {
         let log = prog.compiler_log().unwrap().unwrap_or_default();
-        let footer = "If you plan to submit a bug report please re-run the codegen with `RUSTFLAGS=\"--emit=llvm-ir\" and include the .ll file corresponding to the .o file mentioned in the log";
-        panic!(
-            "Malformed NVVM IR program rejected by libnvvm, dumping verifier log:\n\n{log}\n\n{footer}"
-        );
+        #[cfg(feature = "llvm19")]
+        if target_arch.uses_modern_ir_dialect() && is_known_nvvm_verify_false_negative(&log) {
+            sess.dcx().warn(
+                "libnvvm verification rejected LLVM 19 bitcode with the known legacy-reader message; proceeding to compilation anyway on the llvm19 path"
+            );
+        } else {
+            let footer = "If you plan to submit a bug report please re-run the codegen with `RUSTFLAGS=\"--emit=llvm-ir\" and include the .ll file corresponding to the .o file mentioned in the log";
+            panic!(
+                "Malformed NVVM IR program rejected by libnvvm, dumping verifier log:\n\n{log}\n\n{footer}"
+            );
+        }
+        #[cfg(not(feature = "llvm19"))]
+        {
+            let footer = "If you plan to submit a bug report please re-run the codegen with `RUSTFLAGS=\"--emit=llvm-ir\" and include the .ll file corresponding to the .o file mentioned in the log";
+            panic!(
+                "Malformed NVVM IR program rejected by libnvvm, dumping verifier log:\n\n{log}\n\n{footer}"
+            );
+        }
     }
 
     let res = match prog.compile(&args.nvvm_options) {
         Ok(b) => b,
         Err(error) => {
             let log = prog.compiler_log().unwrap().unwrap_or_default();
-            // this should never happen, if it does, something went really bad or its a bug on libnvvm's end
             panic!(
-                "libnvvm returned an error that was not previously caught by the verifier: {error:?} {log:?}"
+                "libnvvm compilation failed: {error:?}\n\n{log}"
             );
         }
     };

examples/vecadd/build.rs

@@ -1,7 +1,17 @@
 use std::env;
 use std::path;
+use std::str::FromStr;
 
-use cuda_builder::CudaBuilder;
+use cuda_builder::{CudaBuilder, NvvmArch};
+
+fn selected_arch() -> NvvmArch {
+    match env::var("RUST_CUDA_TARGET_ARCH") {
+        Ok(value) => NvvmArch::from_str(&value)
+            .unwrap_or_else(|_| panic!("unknown RUST_CUDA_TARGET_ARCH value: {value}")),
+        Err(_) if env::var_os("LLVM_CONFIG_19").is_some() => NvvmArch::Compute100,
+        Err(_) => NvvmArch::default(),
+    }
+}
 
 fn main() {
     // On Windows, nanorand's entropy uses SystemFunction036 (RtlGenRandom) from advapi32.
@@ -14,15 +24,30 @@ fn main() {
     println!("cargo::rerun-if-changed=kernels");
     println!("cargo::rerun-if-env-changed=RUST_CUDA_DUMP_FINAL_MODULE");
     println!("cargo::rerun-if-env-changed=RUST_CUDA_EMIT_LLVM_IR");
+    println!("cargo::rerun-if-env-changed=RUST_CUDA_TARGET_ARCH");
+    println!("cargo::rerun-if-env-changed=LLVM_CONFIG_19");
 
     let out_path = path::PathBuf::from(env::var("OUT_DIR").unwrap());
     let manifest_dir = path::PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
 
     let dump_final_module = env::var_os("RUST_CUDA_DUMP_FINAL_MODULE").is_some();
     let emit_llvm_ir = env::var_os("RUST_CUDA_EMIT_LLVM_IR").is_some();
+    let arch = selected_arch();
+
+    println!("cargo:warning=vecadd target arch: {}", arch.target_feature());
+    if arch.uses_modern_ir_dialect() {
+        println!(
+            "cargo:warning=vecadd expects the modern NVVM IR dialect on this target; use this path for LLVM 19 validation"
+        );
+    } else {
+        println!(
+            "cargo:warning=vecadd expects the legacy LLVM 7 NVVM dialect on this target, even if LLVM_CONFIG_19 is set"
+        );
+    }
 
     let mut builder = CudaBuilder::new(manifest_dir.join("kernels"));
     builder = builder.copy_to(out_path.join("kernels.ptx"));
+    builder = builder.arch(arch);
 
     if dump_final_module {
         builder = builder.final_module_path(out_path.join("final-module.ll"));

flake.nix

@@ -14,6 +14,8 @@
       };
       lib = pkgs.lib;
       cudaRoot = "/usr/local/cuda-13.2";
+      driverLibDir = "/usr/lib/x86_64-linux-gnu";
+      driverLibPath = "${driverLibDir}/libcuda.so.1";
       llvm19 = pkgs.llvmPackages_19;
       llvm19Bin = lib.getBin llvm19.llvm;
       llvm19Dev = lib.getDev llvm19.llvm;
@@ -69,12 +71,19 @@
         LIBCLANG_PATH = "${lib.getLib llvm19.libclang}/lib";
 
         shellHook = ''
+          driver_shim_dir="$PWD/.nix-driver-libs"
+          mkdir -p "$driver_shim_dir"
+          if [ -e "${driverLibPath}" ]; then
+            ln -sf "${driverLibPath}" "$driver_shim_dir/libcuda.so.1"
+          fi
+
           export PATH="${llvm19CompatTools}/bin:${llvm19Bin}/bin:${llvm19Dev}/bin:${cudaRoot}/bin:${cudaRoot}/nvvm/bin:$PATH"
-          export LD_LIBRARY_PATH="${cudaRoot}/nvvm/lib64:${cudaRoot}/lib64:${pkgs.ncurses.out}/lib:${pkgs.libxml2.out}/lib:${pkgs.zlib.out}/lib:${pkgs.stdenv.cc.cc.lib}/lib''${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
+          export LD_LIBRARY_PATH="$driver_shim_dir:${cudaRoot}/nvvm/lib64:${cudaRoot}/lib64:${pkgs.ncurses.out}/lib:${pkgs.libxml2.out}/lib:${pkgs.zlib.out}/lib:${pkgs.stdenv.cc.cc.lib}/lib''${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
 
           echo "rust-cuda llvm19 shell"
           echo "  CUDA_HOME=$CUDA_HOME"
           echo "  LLVM_CONFIG_19=$LLVM_CONFIG_19"
+          echo "  NVIDIA_DRIVER_LIB=$driver_shim_dir/libcuda.so.1"
         '';
       };
     };