(wip) Feat: fix debug info generation on opt=3

Author: RDambrosio016

crates/cuda_builder/src/lib.rs

@@ -117,6 +117,7 @@ pub struct CudaBuilder {
     ///
     /// `true` by default.
     pub override_libm: bool,
+    pub debug: bool,
 }
 
 impl CudaBuilder {
@@ -136,9 +137,15 @@ impl CudaBuilder {
             emit: None,
             optix: false,
             override_libm: true,
+            debug: false,
         }
     }
 
+    pub fn debug(mut self, debug: bool) -> Self {
+        self.debug = debug;
+        self
+    }
+
     /// Whether to compile the gpu crate for release.
     pub fn release(mut self, release: bool) -> Self {
         self.release = release;
@@ -378,6 +385,11 @@ fn invoke_rustc(builder: &CudaBuilder) -> Result<PathBuf, CudaBuilderError> {
         llvm_args.push("--override-libm".to_string());
     }
 
+    if builder.debug {
+        rustflags.push("-Cdebuginfo=1".to_string());
+        llvm_args.push("-generate-line-info".to_string());
+    }
+
     let llvm_args = llvm_args.join(" ");
     if !llvm_args.is_empty() {
         rustflags.push(["-Cllvm-args=", &llvm_args].concat());

crates/rustc_codegen_nvvm/src/back.rs

@@ -128,6 +128,35 @@ pub fn target_machine_factory(
     })
 }
 
+pub extern "C" fn demangle_callback(
+    input_ptr: *const c_char,
+    input_len: size_t,
+    output_ptr: *mut c_char,
+    output_len: size_t,
+) -> size_t {
+    let input = unsafe { slice::from_raw_parts(input_ptr as *const u8, input_len as usize) };
+
+    let input = match std::str::from_utf8(input) {
+        Ok(s) => s,
+        Err(_) => return 0,
+    };
+
+    let output = unsafe { slice::from_raw_parts_mut(output_ptr as *mut u8, output_len as usize) };
+    let mut cursor = io::Cursor::new(output);
+
+    let demangled = match rustc_demangle::try_demangle(input) {
+        Ok(d) => d,
+        Err(_) => return 0,
+    };
+
+    if write!(cursor, "{:#}", demangled).is_err() {
+        // Possible only if provided buffer is not big enough
+        return 0;
+    }
+
+    cursor.position() as size_t
+}
+
 /// Compile a single module (in an nvvm context this means getting the llvm bitcode out of it)
 pub(crate) unsafe fn codegen(
     cgcx: &CodegenContext<NvvmCodegenBackend>,
@@ -168,37 +197,6 @@ pub(crate) unsafe fn codegen(
             .temp_path(OutputType::LlvmAssembly, module_name);
         let out_c = path_to_c_string(&out);
 
-        extern "C" fn demangle_callback(
-            input_ptr: *const c_char,
-            input_len: size_t,
-            output_ptr: *mut c_char,
-            output_len: size_t,
-        ) -> size_t {
-            let input =
-                unsafe { slice::from_raw_parts(input_ptr as *const u8, input_len as usize) };
-
-            let input = match std::str::from_utf8(input) {
-                Ok(s) => s,
-                Err(_) => return 0,
-            };
-
-            let output =
-                unsafe { slice::from_raw_parts_mut(output_ptr as *mut u8, output_len as usize) };
-            let mut cursor = io::Cursor::new(output);
-
-            let demangled = match rustc_demangle::try_demangle(input) {
-                Ok(d) => d,
-                Err(_) => return 0,
-            };
-
-            if write!(cursor, "{:#}", demangled).is_err() {
-                // Possible only if provided buffer is not big enough
-                return 0;
-            }
-
-            cursor.position() as size_t
-        }
-
         let result = llvm::LLVMRustPrintModule(llmod, out_c.as_ptr(), demangle_callback);
 
         result.into_result().map_err(|()| {

crates/rustc_codegen_nvvm/src/llvm.rs

@@ -17,7 +17,7 @@
 // in case we need them in the future for things like debug info or LTO.
 #![allow(dead_code)]
 
-use libc::{c_char, c_uint, size_t};
+use libc::{c_char, c_uint, c_void, size_t};
 use libc::{c_int, c_ulonglong};
 use std::ffi::{CStr, CString};
 use std::fmt;
@@ -1849,6 +1849,12 @@ extern "C" {
         len: usize,
         out_len: &mut usize,
     ) -> *const u8;
+    pub(crate) fn LLVMRustThinLTOGetDICompileUnit(
+        M: &Module,
+        CU1: &mut *mut c_void,
+        CU2: &mut *mut c_void,
+    );
+    pub(crate) fn LLVMRustThinLTOPatchDICompileUnit(M: &Module, CU: *mut c_void);
 
     pub(crate) fn LLVMRustAddDereferenceableAttr(Fn: &Value, index: c_uint, bytes: u64);
     pub(crate) fn LLVMRustAddDereferenceableOrNullAttr(Fn: &Value, index: c_uint, bytes: u64);

crates/rustc_codegen_nvvm/src/nvvm.rs

@@ -6,12 +6,12 @@ use crate::lto::ThinBuffer;
 use find_cuda_helper::find_cuda_root;
 use nvvm::*;
 use rustc_codegen_ssa::traits::ThinBufferMethods;
-use rustc_session::Session;
+use rustc_session::{config::DebugInfo, Session};
 use std::ffi::OsStr;
 use std::fmt::Display;
-use std::fs;
 use std::marker::PhantomData;
 use std::path::Path;
+use std::{fs, ptr};
 use tracing::debug;
 
 // see libintrinsics.ll on what this is.
@@ -71,6 +71,24 @@ pub fn codegen_bitcode_modules(
     unsafe {
         internalize_pass(module, llcx);
         dce_pass(module);
+
+        if sess.opts.debuginfo != DebugInfo::None {
+            cleanup_dicompileunit(module);
+        }
+
+        let (dbg_major, dbg_minor) = nvvm::dbg_version();
+
+        // needed for debug info or else nvvm complains about ir version mismatch for some
+        // reason. It works if you don't use debug info though...
+        let ty_i32 = LLVMInt32TypeInContext(llcx);
+        let major = LLVMConstInt(ty_i32, major as u64, False);
+        let minor = LLVMConstInt(ty_i32, minor as u64, False);
+        let dbg_major = LLVMConstInt(ty_i32, dbg_major as u64, False);
+        let dbg_minor = LLVMConstInt(ty_i32, dbg_minor as u64, False);
+        let vals = vec![major, minor, dbg_major, dbg_minor];
+        let node = LLVMMDNodeInContext(llcx, vals.as_ptr(), vals.len() as u32);
+
+        LLVMAddNamedMetadataOperand(module, "nvvmir.version\0".as_ptr().cast(), node);
     }
     let buf = ThinBuffer::new(module);
 
@@ -106,9 +124,12 @@ pub fn codegen_bitcode_modules(
 
     let res = match prog.compile(opts) {
         Ok(b) => b,
-        Err(_) => {
+        Err(error) => {
             // 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");
+            panic!(
+                "libnvvm returned an error that was not previously caught by the verifier: {:?}",
+                error
+            );
         }
     };
 
@@ -131,6 +152,13 @@ pub fn find_libdevice() -> Option<Vec<u8>> {
     }
 }
 
+unsafe fn cleanup_dicompileunit(module: &Module) {
+    let mut cu1 = ptr::null_mut();
+    let mut cu2 = ptr::null_mut();
+    LLVMRustThinLTOGetDICompileUnit(module, &mut cu1, &mut cu2);
+    LLVMRustThinLTOPatchDICompileUnit(module, cu1);
+}
+
 // Merging and DCE (dead code elimination) logic. Inspired a lot by rust-ptx-linker.
 //
 // This works in a couple of steps starting from the bitcode of every single module (crate), then: