Function codegen_bitcode_modules

crates/rustc_codegen_nvvm/src/nvvm.rs:52–137

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. Note that this will implicitly try to find libdevice and add it, so don't do that step before this. It will fatal error if it cannot find it.

(
    opts: &[NvvmOption],
    sess: &Session,
    modules: Vec<Vec<u8>>,
    llcx: &Context,
)

/// Note that this will implicitly try to find libdevice and add it, so don't do that
/// step before this. It will fatal error if it cannot find it.
pub fn codegen_bitcode_modules(
    opts: &[NvvmOption],
    sess: &Session,
    modules: Vec<Vec<u8>>,
    llcx: &Context,
) -> Result<Vec<u8>, CodegenErr> {
    debug!("Codegenning bitcode to PTX");

    // make sure the nvvm version is high enough so users don't get confusing compilation errors.
    let (major, minor) = nvvm::ir_version();

    if minor < 6 || major < 1 {
        sess.fatal("rustc_codegen_nvvm requires at least libnvvm 1.6 (CUDA 11.2)");
    }

    // first, create the nvvm program we will add modules to.
    let prog = NvvmProgram::new()?;

    let module = merge_llvm_modules(modules, llcx);
    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);

    prog.add_module(buf.data(), "merged".to_string())?;

    let libdevice = if let Some(bc) = find_libdevice() {
        bc
    } else {
        // i would put a more helpful error here, but to actually use the codegen
        // it needs to find libnvvm before this, and libdevice is in the nvvm directory
        // so if it can find libnvvm there is almost no way it can't find libdevice.
        sess.fatal("Could not find the libdevice library (libdevice.10.bc) in the CUDA directory")
    };

    prog.add_lazy_module(&libdevice, "libdevice".to_string())?;
    prog.add_lazy_module(LIBINTRINSICS, "libintrinsics".to_string())?;

    // for now, while the codegen is young, we always run verification on the program.