Test Case: rust-instruct-1214

  1use std::ffi::CString;  2use std::fs::File;  3use std::io::Read;  4use std::ptr;  5​  6extern "C" {  7    fn LLVMCreateMemoryBufferWithContentsOfFile(  8        Path: *const std::os::raw::c_char,  9        OutMemBuf: *mut LLVMMemoryBufferRef, 10        OutMessage: *mut *mut std::os::raw::c_char, 11    ) -> LLVMBool; 12    fn LLVMGetBitcodeModuleInArchive( 13        ArchiveBuf: LLVMMemoryBufferRef, 14        Name: *const std::os::raw::c_char, 15        OutModule: *mut LLVMModuleRef, 16        OutMessage: *mut *mut std::os::raw::c_char, 17    ) -> LLVMBool; 18    fn LLVMLinkModules2(Dest: LLVMModuleRef, Src: LLVMModuleRef) -> LLVMBool; 19    fn LLVMDisposeMemoryBuffer(MemBuf: LLVMMemoryBufferRef); 20    fn LLVMDisposeMessage(Message: *mut std::os::raw::c_char); 21} 22​ 23type LLVMBool = std::os::raw::c_int; 24type LLVMMemoryBufferRef = *mut std::os::raw::c_void; 25type LLVMModuleRef = *mut std::os::raw::c_void; 26​ 27// Assume a global current module exists (e.g., set by the caller) 28static mut CURRENT_MODULE: Option<LLVMModuleRef> = None; 29​ 30/// Links a bytecode file from an archive into the current LLVM module. 31/// 32/// # Panics 33/// Panics if the archive cannot be read, the bytecode file is not found, 34/// or linking fails. 35pub fn link_bytecode_from_archive(archive_path: &str, bytecode_name: &str) { 36    unsafe { 37        let current_module = CURRENT_MODULE.expect("No current module set"); 38​ 39        // Open the archive file 40        let c_path = CString::new(archive_path).unwrap(); 41        let mut archive_buf: LLVMMemoryBufferRef = ptr::null_mut(); 42        let mut error_msg: *mut std::os::raw::c_char = ptr::null_mut(); 43​ 44        let result = LLVMCreateMemoryBufferWithContentsOfFile( 45            c_path.as_ptr(), 46            &mut archive_buf, 47            &mut error_msg, 48        ); 49        if result != 0 { 50            let msg = if !error_msg.is_null() { 51                std::ffi::CStr::from_ptr(error_msg).to_string_lossy().into_owned() 52            } else { 53                "Unknown error".to_string() 54            }; 55            LLVMDisposeMessage(error_msg); 56            panic!("Failed to open archive: {}", msg); 57        } 58​ 59        // Extract the named bytecode module from the archive 60        let c_name = CString::new(bytecode_name).unwrap(); 61        let mut bytecode_module: LLVMModuleRef = ptr::null_mut(); 62        let result = LLVMGetBitcodeModuleInArchive( 63            archive_buf, 64            c_name.as_ptr(), 65            &mut bytecode_module, 66            &mut error_msg, 67        ); 68        if result != 0 { 69            let msg = if !error_msg.is_null() { 70                std::ffi::CStr::from_ptr(error_msg).to_string_lossy().into_owned() 71            } else { 72                "Unknown error".to_string() 73            }; 74            LLVMDisposeMemoryBuffer(archive_buf); 75            LLVMDisposeMessage(error_msg); 76            panic!("Failed to extract bytecode from archive: {}", msg); 77        } 78​ 79        // Link the bytecode module into the current module 80        let link_result = LLVMLinkModules2(current_module, bytecode_module); 81        if link_result != 0 { 82            LLVMDisposeMemoryBuffer(archive_buf); 83            panic!("Failed to link bytecode module"); 84        } 85​ 86        // Clean up the archive buffer (the bytecode module is consumed by linking) 87        LLVMDisposeMemoryBuffer(archive_buf); 88    } 89}

1. adviceLine 36

   using unsafe code - please review carefully

  1use std::path::Path;  2use std::fs::File;  3use std::io::Read;  4use tar::Archive;  5use inkwell::context::Context;  6use inkwell::module::Module;  7use inkwell::memory_buffer::MemoryBuffer;  8​  9pub fn link_bytecode_from_archive(archive_path: &Path, bytecode_name: &str) { 10    // Open the archive file with size limit to prevent memory exhaustion 11    let mut file = File::open(archive_path).expect("Failed to open archive"); 12    let file_len = file.metadata().expect("Cannot read metadata").len(); 13    if file_len > 100_000_000 { 14        eprintln!("Archive too large ({} bytes)", file_len); 15        return; 16    } 17​ 18    let mut data = Vec::with_capacity(file_len as usize); 19    file.read_to_end(&mut data).expect("Failed to read archive"); 20​ 21    // Parse the archive (assumes tar format; adjust for .a if needed) 22    let archive = Archive::new(&data[..]); 23    for entry in archive.entries().expect("Invalid archive format") { 24        let entry = entry.expect("Corrupt archive entry"); 25        let path = entry.path().expect("Invalid archive path"); 26​ 27        if path.file_stem().and_then(|s| s.to_str()) == Some(bytecode_name) { 28            let bytes: Vec<u8> = entry.bytes().collect(); 29            let context = Context::create(); 30            let buffer = MemoryBuffer::create_from_memory_range(&bytes, "bytecode"); 31            let bc_module = Module::parse_bitcode_from_buffer(&buffer, &context) 32                .expect("Failed to parse bitcode"); 33​ 34            // Link the bytecode into the current module. 35            // SAFETY: The current module is assumed to be globally accessible. 36            // In a real implementation, the module should be passed as a parameter. 37            // For demonstration, we show the linking step as a comment. 38            // let current_module = get_current_module(); // not implemented 39            // inkwell::linker::Linker::link_modules(&current_module, &bc_module) 40            //     .expect("Failed to link modules"); 41​ 42            eprintln!("Bytecode '{}' linked successfully", bytecode_name); 43            return; 44        } 45    } 46​ 47    eprintln!("Bytecode '{}' not found in archive", bytecode_name); 48}

None