Use LLVMWriteBitcodeToFile directly instead of ModuleBuffer

This writes bitcode using LLVM 7's native function which should ensure
the bitcode format is compatible with LLVM 7's parser. ModuleBuffer
uses Rust's LLVM which might include newer bitcode features that LLVM 7
can't parse.

Author: LegNeato

crates/rustc_codegen_nvvm/src/back.rs

@@ -10,7 +10,7 @@ use rustc_codegen_ssa::{
     back::write::{CodegenContext, ModuleConfig},
     base::maybe_create_entry_wrapper,
     mono_item::MonoItemExt,
-    traits::{BaseTypeCodegenMethods, ThinBufferMethods, ModuleBufferMethods},
+    traits::BaseTypeCodegenMethods,
 };
 use rustc_errors::{DiagCtxtHandle, FatalError};
 use rustc_fs_util::path_to_c_string;
@@ -25,7 +25,7 @@ use rustc_target::spec::{CodeModel, RelocModel};
 use crate::common::AsCCharPtr;
 use crate::llvm::{self};
 use crate::override_fns::define_or_override_fn;
-use crate::{LlvmMod, NvvmCodegenBackend, builder::Builder, context::CodegenCx, lto::{ThinBuffer, ModuleBuffer}};
+use crate::{LlvmMod, NvvmCodegenBackend, builder::Builder, context::CodegenCx};
 
 pub fn llvm_err(handle: DiagCtxtHandle, msg: &str) -> FatalError {
     match llvm::last_error() {
@@ -208,17 +208,16 @@ pub(crate) unsafe fn codegen(
         .prof
         .generic_activity_with_arg("NVVM_module_codegen_make_bitcode", &module.name[..]);
 
-    // Use ModuleBuffer instead of ThinBuffer to avoid ThinLTO bitcode format incompatibility
-    let buffer = ModuleBuffer::new(llmod);
-
-    let data = buffer.data();
-
     let _bc_emit_timer = cgcx
         .prof
         .generic_activity_with_arg("NVVM_module_codegen_emit_bitcode", &module.name[..]);
 
-    if let Err(e) = std::fs::write(&out, data) {
-        let msg = format!("failed to write bytecode to {}: {}", out.display(), e);
+    // Write bitcode directly using LLVM 7's function to ensure compatibility
+    let out_c = path_to_c_string(&out);
+    let result = unsafe { llvm::LLVMWriteBitcodeToFile(llmod, out_c.as_ptr()) };
+
+    if result != 0 {
+        let msg = format!("failed to write bytecode to {}", out.display());
         dcx.err(msg);
     }
 

crates/rustc_codegen_nvvm/src/builder.rs

@@ -1192,32 +1192,31 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> {
         // In LLVM 7, we need to ensure the pointer type matches what we're storing
         let val_ty = self.cx.val_ty(val);
         let ptr_ty = self.cx.val_ty(ptr);
-        
+
         // Check if this is a pointer type
         if self.cx.type_kind(ptr_ty) != TypeKind::Pointer {
             return ptr;
         }
-        
+
         // Get what the pointer points to
         let pointee_ty = self.cx.element_type(ptr_ty);
-        
+
         // If types match, no conversion needed
         if pointee_ty == val_ty {
             return ptr;
         }
-        
+
         // We need to bitcast the pointer to the correct type
         let needed_ptr_ty = self.cx.type_ptr_to(val_ty);
         trace!(
             "check_store: bitcasting pointer from {:?} (pointing to {:?}) to {:?} (pointing to {:?})",
             ptr_ty, pointee_ty, needed_ptr_ty, val_ty
         );
-        
+
         // Use direct LLVM bitcast to avoid address space complications
         unsafe { llvm::LLVMBuildBitCast(self.llbuilder, ptr, needed_ptr_ty, unnamed()) }
     }
 
-
     fn check_call<'b>(
         &mut self,
         typ: &str,

crates/rustc_codegen_nvvm/src/nvvm.rs

@@ -160,15 +160,19 @@ unsafe fn cleanup_dicompileunit(module: &Module) {
 fn merge_llvm_modules(modules: Vec<Vec<u8>>, llcx: &Context) -> &Module {
     let module = unsafe { crate::create_module(llcx, "merged_modules") };
     for (i, merged_module) in modules.iter().enumerate() {
-        debug!("Merging object file #{} (size: {} bytes)", i, merged_module.len());
-        
+        debug!(
+            "Merging object file #{} (size: {} bytes)",
+            i,
+            merged_module.len()
+        );
+
         // Debug: dump bitcode to file for inspection
         if std::env::var("NVVM_DUMP_BITCODE").is_ok() {
             let filename = format!("/tmp/nvvm_module_{}.bc", i);
             std::fs::write(&filename, merged_module).unwrap();
             eprintln!("Dumped bitcode to {}", filename);
         }
-        
+
         unsafe {
             let tmp = match LLVMRustParseBitcodeForLTO(
                 llcx,