LLVM error: {}

Strategy: try-catch

Validate before calling

// Validate object files before archive creation to prevent LLVM symbol-read failures
use std::path::Path;
use std::fs;

fn validate_object_files(objects: &[&str]) -> Result<(), String> {
    for obj in objects {
        let path = Path::new(obj);
        let metadata = fs::metadata(path)
            .map_err(|e| format!("Cannot stat {}: {}", obj, e))?;
        if metadata.len() == 0 {
            return Err(format!("Object file {} is empty", obj));
        }
        // Read magic bytes to verify it is a valid object or bitcode file
        let mut buf = [0u8; 4];
        use std::io::Read;
        let mut f = fs::File::open(path)
            .map_err(|e| format!("Cannot open {}: {}", obj, e))?;
        f.read_exact(&mut buf)
            .map_err(|e| format!("Cannot read header of {}: {}", obj, e))?;
        let is_elf = &buf[..4] == b"\x7fELF";
        let is_coff = matches!(buf[0], 0x4d | 0x64) && matches!(buf[1], 0x5a | 0x83);
        let is_bitcode = &buf == b"BC\xc0\xde" || &buf == &[0xDE, 0xCE, 0x17, 0x0B];
        let is_macho = matches!(buf[0], 0xFE | 0xCF | 0xCE) || buf[0] == 0xCA;
        if !(is_elf || is_coff || is_bitcode || is_macho) {
            return Err(format!("{} is not a recognized object/bitcode file (magic: {:?})", obj, buf));
        }
    }
    Ok(())
}

Try / catch

// The LLVM archive error surfaces as io::Error via get_llvm_object_symbols callback.
// Catch it at the linking/archive step:
use std::io;

fn build_archive(objects: &[String], output: &str) -> Result<(), String> {
    // rustc_codegn_ssa returns io::Result from archive building
    match archive_write(objects, output) {
        Ok(()) => Ok(()),
        Err(ref e) if e.to_string().contains("LLVM error") => {
            // The LLVM symbol reader failed. Common causes:
            // - corrupted or truncated object file
            // - object produced by a newer LLVM version
            // - disk full during archive write
            eprintln!("LLVM archive error: {}", e);

            // For bitcode files, LLVM errors are non-fatal (the linker may handle them)
            // For other object types, clean up the partial archive and retry
            let _ = std::fs::remove_file(output);

            // Retry with verbose diagnostics
            match archive_write(objects, output) {
                Ok(()) => Ok(()),
                Err(e2) => Err(format!(
                    "Archive write failed after retry: {}. \
                     Run cargo clean and rebuild.",
                    e2
                )),
            }
        }
        Err(e) => Err(e.to_string()),
    }
}

// Placeholder for the actual archive builder call
fn archive_write(_objects: &[String], _output: &str) -> Result<(), io::Error> {
    Ok(())
}

Prevention

• Run cargo clean before rebuilding if you see intermittent LLVM archive errors — stale .rlib/.a artifacts from a different toolchain version are a common cause
• Verify object files are not truncated or corrupt: use file --mime-type on .o files before linking
• Ensure sufficient disk space with df -h before large archive builds — LLVM writes the archive atomically and fails if the disk fills mid-write
• Avoid concurrent cargo invocations writing to the same target/ directory — use separate CARGO_TARGET_DIR per job
• Pin a stable LLVM/rustc version for your toolchain — object format changes between major LLVM releases can cause symbol-read failures
• For bitcode-only archives (.rlib with -C lto), the error is non-fatal and can be safely ignored if your final linker uses a compatible LLVM version