llvm-ir 0.11.3

use either::Either;
use itertools::Itertools;
use llvm_ir::function::{FunctionAttribute, ParameterAttribute};
use llvm_ir::instruction;
use llvm_ir::module::{Alignment, Endianness, Mangling, PointerLayout};
use llvm_ir::terminator;
use llvm_ir::types::{FPType, NamedStructDef, Typed};
use llvm_ir::HasDebugLoc;
use llvm_ir::{
    Constant, ConstantRef, Instruction, IntPredicate, Module, Name, Operand, Terminator, Type,
};
#[cfg(feature = "llvm-16-or-greater")]
use llvm_ir::function::MemoryEffect;
use std::convert::TryInto;
use std::path::{Path, PathBuf};

fn init_logging() {
    // capture log messages with test harness
    let _ = env_logger::builder().is_test(true).try_init();
}

const BC_DIR: &str = "tests/basic_bc/";

// Test against bitcode compiled with the same version of LLVM
fn llvm_bc_dir() -> PathBuf {
    if cfg!(feature = "llvm-9") {
        Path::new(BC_DIR).join("llvm9")
    } else if cfg!(feature = "llvm-10") {
        Path::new(BC_DIR).join("llvm10")
    } else if cfg!(feature = "llvm-11") {
        Path::new(BC_DIR).join("llvm11")
    } else if cfg!(feature = "llvm-12") {
        Path::new(BC_DIR).join("llvm12")
    } else if cfg!(feature = "llvm-13") {
        Path::new(BC_DIR).join("llvm13")
    } else if cfg!(feature = "llvm-14") {
        Path::new(BC_DIR).join("llvm14")
    } else if cfg!(feature = "llvm-15") {
        Path::new(BC_DIR).join("llvm15")
    } else if cfg!(feature = "llvm-16") {
        Path::new(BC_DIR).join("llvm16")
    } else if cfg!(feature = "llvm-17") {
        Path::new(BC_DIR).join("llvm17")
    } else if cfg!(feature = "llvm-18") {
        Path::new(BC_DIR).join("llvm18")
    } else if cfg!(feature = "llvm-19") {
        Path::new(BC_DIR).join("llvm19")
    } else {
        unimplemented!("new llvm version?")
    }
}

// Test against bitcode compiled with the same version of LLVM
fn cxx_llvm_bc_dir() -> PathBuf {
    if cfg!(feature = "llvm-9") {
        Path::new(BC_DIR).join("cxx-llvm9")
    } else if cfg!(feature = "llvm-10") {
        Path::new(BC_DIR).join("cxx-llvm10")
    } else if cfg!(feature = "llvm-11") {
        Path::new(BC_DIR).join("cxx-llvm11")
    } else if cfg!(feature = "llvm-12") {
        Path::new(BC_DIR).join("cxx-llvm12")
    } else if cfg!(feature = "llvm-13") {
        Path::new(BC_DIR).join("cxx-llvm13")
    } else if cfg!(feature = "llvm-14") {
        Path::new(BC_DIR).join("cxx-llvm14")
    } else if cfg!(feature = "llvm-15") {
        Path::new(BC_DIR).join("cxx-llvm15")
    } else if cfg!(feature = "llvm-16") {
        Path::new(BC_DIR).join("cxx-llvm16")
    } else if cfg!(feature = "llvm-17") {
        Path::new(BC_DIR).join("cxx-llvm17")
    } else if cfg!(feature = "llvm-18") {
        Path::new(BC_DIR).join("cxx-llvm18")
    } else if cfg!(feature = "llvm-19") {
        Path::new(BC_DIR).join("cxx-llvm19")
    } else {
        unimplemented!("new llvm version?")
    }
}

fn rust_bc_dir() -> PathBuf {
    Path::new(BC_DIR).join("rust")
}

#[test]
fn hellobc() {
    init_logging();
    let path = llvm_bc_dir().join("hello.bc");
    let module = Module::from_bc_path(&path).expect("Failed to parse module");
    assert_eq!(&module.name, &path.to_str().unwrap());
    assert_eq!(module.source_file_name, "hello.c");
    #[cfg(feature = "llvm-10-or-lower")]
    assert_eq!(
        module.target_triple,
        Some("x86_64-apple-macosx10.16.0".into())
    );
    #[cfg(any(feature = "llvm-11", feature = "llvm-12", feature = "llvm-13"))]
    assert_eq!(
        module.target_triple,
        Some("x86_64-apple-macosx11.0.0".into())
    );
    #[cfg(feature = "llvm-14-or-greater")]
    assert_eq!(
        module.target_triple,
        Some("x86_64-apple-macosx12.0.0".into())
    );
    assert_eq!(module.functions.len(), 1);
    let func = &module.functions[0];
    assert_eq!(func.name, "main");
    assert_eq!(func.parameters.len(), 0);
    assert_eq!(func.is_var_arg, false);
    assert_eq!(func.return_type, module.types.int(32));
    assert_eq!(func.basic_blocks.len(), 1);
    let bb = &func.basic_blocks[0];
    assert_eq!(bb.name, Name::Number(0));
    assert_eq!(bb.instrs.len(), 0);
    let ret: &terminator::Ret = &bb
        .term
        .clone()
        .try_into()
        .unwrap_or_else(|_| panic!("Terminator should be a Ret but is {:?}", &bb.term));
    assert_eq!(
        ret.return_operand,
        Some(Operand::ConstantOperand(ConstantRef::new(Constant::Int {
            bits: 32,
            value: 0
        })))
    );
    assert_eq!(&ret.to_string(), "ret i32 0");

    // this file was compiled without debuginfo, so nothing should have a debugloc
    assert_eq!(func.debugloc, None);
    assert_eq!(ret.debugloc, None);
}

// this test relates to the version of the file compiled with debuginfo
#[test]
fn hellobcg() {
    init_logging();
    let path = llvm_bc_dir().join("hello.bc-g");
    let module = Module::from_bc_path(&path).expect("Failed to parse module");
    assert_eq!(&module.name, &path.to_str().unwrap());
    assert_eq!(module.source_file_name, "hello.c");
    let debug_filename = "hello.c";
    let debug_directory_suffix = "/tests/basic_bc";

    let func = &module.functions[0];
    assert_eq!(func.name, "main");
    let debugloc = func
        .get_debug_loc()
        .as_ref()
        .expect("Expected main() to have a debugloc");
    assert_eq!(debugloc.line, 3);
    assert_eq!(debugloc.col, None);
    assert_eq!(debugloc.filename, debug_filename);
    assert!(debugloc.directory.as_ref().expect("directory should exist").ends_with(debug_directory_suffix));

    let bb = &func.basic_blocks[0];
    let ret: &terminator::Ret = &bb
        .term
        .clone()
        .try_into()
        .unwrap_or_else(|_| panic!("Terminator should be a Ret but is {:?}", &bb.term));
    let debugloc = ret
        .get_debug_loc()
        .as_ref()
        .expect("expected the Ret to have a debugloc");
    assert_eq!(debugloc.line, 4);
    assert_eq!(debugloc.col, Some(3));
    assert_eq!(debugloc.filename, debug_filename);
    assert!(debugloc.directory.as_ref().expect("directory should exist").ends_with(debug_directory_suffix));
    assert_eq!(&ret.to_string(), "ret i32 0 (with debugloc)");
}

#[test]
#[allow(clippy::cognitive_complexity)]
fn loopbc() {
    init_logging();
    let path = llvm_bc_dir().join("loop.bc");
    let module = Module::from_bc_path(&path).expect("Failed to parse module");

    // get function and check info on it
    assert_eq!(module.functions.len(), 1);
    let func = &module.functions[0];
    assert_eq!(func.name, "loop");
    assert_eq!(func.parameters.len(), 2);
    assert_eq!(func.is_var_arg, false);
    assert_eq!(func.return_type, module.types.void());
    assert_eq!(
        module.type_of(func),
        module.types.func_type(
            module.types.void(),
            vec![module.types.i32(), module.types.i32()],
            false,
        )
    );
    assert_eq!(module.get_func_by_name("loop"), Some(func));

    // get parameters and check info on them
    let param0 = &func.parameters[0];
    let param1 = &func.parameters[1];
    assert_eq!(param0.name, Name::Number(0));
    assert_eq!(param1.name, Name::Number(1));
    assert_eq!(param0.ty, module.types.i32());
    assert_eq!(param1.ty, module.types.i32());
    assert_eq!(module.type_of(param0), module.types.i32());
    assert_eq!(module.type_of(param1), module.types.i32());

    // get basic blocks and check their names
    // different LLVM versions end up with different numbers of basic blocks for this function
    #[cfg(feature = "llvm-9-or-lower")]
    let bbs = {
        assert_eq!(func.basic_blocks.len(), 6);
        let bb2 = &func.basic_blocks[0];
        let bb7 = &func.basic_blocks[1];
        let bb10 = &func.basic_blocks[2];
        let bb14 = &func.basic_blocks[3];
        let bb19 = &func.basic_blocks[4];
        let bb22 = &func.basic_blocks[5];
        assert_eq!(bb2.name, Name::Number(2));
        assert_eq!(bb7.name, Name::Number(7));
        assert_eq!(bb10.name, Name::Number(10));
        assert_eq!(bb14.name, Name::Number(14));
        assert_eq!(bb19.name, Name::Number(19));
        assert_eq!(bb22.name, Name::Number(22));
        assert_eq!(func.get_bb_by_name(&Name::Number(2)), Some(bb2));
        assert_eq!(func.get_bb_by_name(&Name::Number(19)), Some(bb19));
        vec![bb2, bb7, bb10, bb14, bb19, bb22]
    };
    #[cfg(feature = "llvm-10")]
    let bbs = {
        assert_eq!(func.basic_blocks.len(), 4);
        let bb2 = &func.basic_blocks[0];
        let bb7 = &func.basic_blocks[1];
        let bb12 = &func.basic_blocks[2];
        let bb21 = &func.basic_blocks[3];
        assert_eq!(bb2.name, Name::Number(2));
        assert_eq!(bb7.name, Name::Number(7));
        assert_eq!(bb12.name, Name::Number(12));
        assert_eq!(bb21.name, Name::Number(21));
        assert_eq!(func.get_bb_by_name(&Name::Number(2)), Some(bb2));
        assert_eq!(func.get_bb_by_name(&Name::Number(12)), Some(bb12));
        vec![bb2, bb7, bb12, bb21]
    };
    #[cfg(feature = "llvm-11")]
    let bbs = {
        assert_eq!(func.basic_blocks.len(), 4);
        let bb2 = &func.basic_blocks[0];
        let bb7 = &func.basic_blocks[1];
        let bb14 = &func.basic_blocks[2];
        let bb24 = &func.basic_blocks[3];
        assert_eq!(bb2.name, Name::Number(2));
        assert_eq!(bb7.name, Name::Number(7));
        assert_eq!(bb14.name, Name::Number(14));
        assert_eq!(bb24.name, Name::Number(24));
        assert_eq!(func.get_bb_by_name(&Name::Number(2)), Some(bb2));
        assert_eq!(func.get_bb_by_name(&Name::Number(14)), Some(bb14));
        vec![bb2, bb7, bb14, bb24]
    };
    #[cfg(feature = "llvm-12")]
    let bbs = {
        assert_eq!(func.basic_blocks.len(), 8); // LLVM 12+ seems to do some unrolling in this example that previous LLVMs didn't
        let bb2 = &func.basic_blocks[0];
        let bb7 = &func.basic_blocks[1];
        let bb12 = &func.basic_blocks[2];
        let bb17 = &func.basic_blocks[3];
        let bb19 = &func.basic_blocks[4];
        let bb47 = &func.basic_blocks[7];
        // actually have 8 BBs, but we only use the first five and the last one
        assert_eq!(bb2.name, Name::Number(2));
        assert_eq!(bb7.name, Name::Number(7));
        assert_eq!(bb12.name, Name::Number(12));
        assert_eq!(bb17.name, Name::Number(17));
        assert_eq!(bb19.name, Name::Number(19));
        assert_eq!(bb47.name, Name::Number(47));
        vec![bb2, bb7, bb12, bb17, bb19, bb47]
    };
    #[cfg(feature = "llvm-13")]
    let bbs = {
        assert_eq!(func.basic_blocks.len(), 9);
        let bb2 = &func.basic_blocks[0];
        let bb6 = &func.basic_blocks[1];
        let bb12 = &func.basic_blocks[3];
        let bb17 = &func.basic_blocks[4];
        let bb19 = &func.basic_blocks[5];
        let bb47 = &func.basic_blocks[8];
        // actually have 9 BBs, but we only use these selected 6
        assert_eq!(bb2.name, Name::Number(2));
        assert_eq!(bb6.name, Name::Number(6));
        assert_eq!(bb12.name, Name::Number(12));
        assert_eq!(bb17.name, Name::Number(17));
        assert_eq!(bb19.name, Name::Number(19));
        assert_eq!(bb47.name, Name::Number(47));
        vec![bb2, bb6, bb12, bb17, bb19, bb47]
    };
    #[cfg(feature = "llvm-14")]
    let bbs = {
        assert_eq!(func.basic_blocks.len(), 8);
        let bb2 = &func.basic_blocks[0];
        let bb7 = &func.basic_blocks[1];
        let bb11 = &func.basic_blocks[2];
        let bb16 = &func.basic_blocks[3];
        let bb18 = &func.basic_blocks[4];
        let bb46 = &func.basic_blocks[7];
        // actually have 8 BBs, but we only use the first five and the last one
        assert_eq!(bb2.name, Name::Number(2));
        assert_eq!(bb7.name, Name::Number(7));
        assert_eq!(bb11.name, Name::Number(11));
        assert_eq!(bb16.name, Name::Number(16));
        assert_eq!(bb18.name, Name::Number(18));
        assert_eq!(bb46.name, Name::Number(46));
        vec![bb2, bb7, bb11, bb16, bb18, bb46]
    };
    #[cfg(all(feature = "llvm-15-or-greater", feature = "llvm-17-or-lower"))]
    let bbs = {
        assert_eq!(func.basic_blocks.len(), 8);
        let bb2 = &func.basic_blocks[0];
        let bb7 = &func.basic_blocks[1];
        let bb11 = &func.basic_blocks[2];
        let bb16 = &func.basic_blocks[3];
        let bb18 = &func.basic_blocks[4];
        let bb46 = &func.basic_blocks[7];
        // actually have 8 BBs, but we only use the first five and the last one
        assert_eq!(bb2.name, Name::Number(2));
        assert_eq!(bb7.name, Name::Number(6));
        assert_eq!(bb11.name, Name::Number(9));
        assert_eq!(bb16.name, Name::Number(14));
        assert_eq!(bb18.name, Name::Number(16));
        assert_eq!(bb46.name, Name::Number(44));
        vec![bb2, bb7, bb11, bb16, bb18, bb46]
    };
    #[cfg(feature = "llvm-18-or-greater")]
    let bbs = {
        assert_eq!(func.basic_blocks.len(), 8);
        let bb2 = &func.basic_blocks[0];
        let bb7 = &func.basic_blocks[1];
        let bb11 = &func.basic_blocks[2];
        let bb16 = &func.basic_blocks[3];
        let bb18 = &func.basic_blocks[4];
        let bb46 = &func.basic_blocks[7];
        // Some extra optimization removes a few instructions in Clang 18,
        // c.f. Clang 17
        assert_eq!(bb2.name, Name::Number(2));
        assert_eq!(bb7.name, Name::Number(6));
        assert_eq!(bb11.name, Name::Number(9));
        assert_eq!(bb16.name, Name::Number(14));
        assert_eq!(bb18.name, Name::Number(16));
        assert_eq!(bb46.name, Name::Number(41));
        vec![bb2, bb7, bb11, bb16, bb18, bb46]
    };

    // check details about the instructions in basic block %2
    let alloca: &instruction::Alloca = &bbs[0].instrs[0]
        .clone()
        .try_into()
        .expect("Should be an alloca");
    assert_eq!(alloca.dest, Name::Number(3));
    let allocated_type = module.types.array_of(module.types.i32(), 10);
    assert_eq!(alloca.allocated_type, allocated_type);
    assert_eq!(
        alloca.num_elements,
        Operand::ConstantOperand(ConstantRef::new(Constant::Int { bits: 32, value: 1 })) // One element, which is an array of 10 elements. Not 10 elements, each of which are i32.
    );
    assert_eq!(alloca.alignment, 16);
    #[cfg(feature = "llvm-14-or-lower")]
    assert_eq!(
        module.type_of(alloca),
        module.types.pointer_to(allocated_type.clone()),
    );
    #[cfg(feature = "llvm-15-or-greater")]
    assert_eq!(module.type_of(alloca), module.types.pointer());
    assert_eq!(module.type_of(&alloca.num_elements), module.types.i32());
    assert_eq!(&alloca.to_string(), "%3 = alloca [10 x i32], align 16");
    #[cfg(feature = "llvm-14-or-lower")] // LLVM 15+ does not require bitcasts in this function
    {
        let bitcast: &instruction::BitCast = &bbs[0].instrs[1]
            .clone()
            .try_into()
            .expect("Should be a bitcast");
        assert_eq!(bitcast.dest, Name::Number(4));
        assert_eq!(bitcast.to_type, module.types.pointer_to(module.types.i8()));
        assert_eq!(
            bitcast.operand,
            Operand::LocalOperand {
                name: Name::Number(3),
                ty: module.types.pointer_to(allocated_type.clone())
            }
        );
        assert_eq!(
            module.type_of(bitcast),
            module.types.pointer_to(module.types.i8())
        );
        assert_eq!(
            module.type_of(&bitcast.operand),
            module.types.pointer_to(allocated_type.clone())
        );
        assert_eq!(&bitcast.to_string(), "%4 = bitcast [10 x i32]* %3 to i8*");
    }
    #[cfg(feature = "llvm-14-or-lower")]
    let lifetimestart: &instruction::Call = &bbs[0].instrs[2]
        .clone()
        .try_into()
        .expect("Should be a call");
    #[cfg(feature = "llvm-15-or-greater")]
    let lifetimestart: &instruction::Call = &bbs[0].instrs[1]
        .clone()
        .try_into()
        .expect("Should be a call");
    if let Either::Right(Operand::ConstantOperand(cref)) = &lifetimestart.function {
        if let Constant::GlobalReference { ref name, ref ty } = cref.as_ref() {
            assert!(matches!(
                module.type_of(&lifetimestart.function).as_ref(),
                Type::PointerType { .. }
            )); // lifetimestart.function should be a constant function pointer
            #[cfg(feature = "llvm-14-or-lower")]
            assert_eq!(*name, Name::from("llvm.lifetime.start.p0i8"));
            #[cfg(feature = "llvm-15-or-greater")]
            assert_eq!(*name, Name::from("llvm.lifetime.start.p0"));
            if let Type::FuncType {
                result_type,
                param_types,
                is_var_arg,
            } = ty.as_ref()
            {
                assert_eq!(result_type, &module.types.void());
                assert_eq!(
                    param_types,
                    &vec![
                        module.types.i64(),
                        #[cfg(feature = "llvm-14-or-lower")]
                        module.types.pointer_to(module.types.i8()),
                        #[cfg(feature = "llvm-15-or-greater")]
                        module.types.pointer(),
                    ]
                );
                assert_eq!(*is_var_arg, false);
            } else {
                panic!("lifetimestart.function has unexpected type {:?}", ty);
            }
        } else {
            panic!(
                "lifetimestart.function not a GlobalReference as expected; it is actually another kind of Constant: {:?}",
                cref
            );
        }
    } else {
        panic!(
            "lifetimestart.function not a GlobalReference as expected; it is actually {:?}",
            &lifetimestart.function
        );
    }
    let arg0 = &lifetimestart
        .arguments
        .get(0)
        .expect("Expected an argument 0");
    let arg1 = &lifetimestart
        .arguments
        .get(1)
        .expect("Expected an argument 1");
    assert_eq!(
        arg0.0,
        Operand::ConstantOperand(ConstantRef::new(Constant::Int {
            bits: 64,
            value: 40
        }))
    );
    #[cfg(feature = "llvm-14-or-lower")]
    let arg1_expected_name = Name::Number(4);
    #[cfg(feature = "llvm-15-or-greater")]
    let arg1_expected_name = Name::Number(3);
    #[cfg(feature = "llvm-14-or-lower")]
    let arg1_expected_ty = module.types.pointer_to(module.types.i8());
    #[cfg(feature = "llvm-15-or-greater")]
    let arg1_expected_ty = module.types.pointer();
    assert_eq!(
        arg1.0,
        Operand::LocalOperand {
            name: arg1_expected_name,
            ty: arg1_expected_ty,
        }
    );
    assert_eq!(arg0.1, vec![]); // should have no parameter attributes
    assert_eq!(arg1.1.len(), 1); // should have one parameter attribute
    assert_eq!(lifetimestart.dest, None);
    #[cfg(feature = "llvm-14-or-lower")]
    let expected_fmt = "call @llvm.lifetime.start.p0i8(i64 40, i8* %4)";
    #[cfg(feature = "llvm-15-or-greater")]
    let expected_fmt = "call @llvm.lifetime.start.p0(i64 40, ptr %3)";
    assert_eq!(&lifetimestart.to_string(), expected_fmt);
    #[cfg(feature = "llvm-14-or-lower")]
    let memset: &instruction::Call = &bbs[0].instrs[3]
        .clone()
        .try_into()
        .expect("Should be a call");
    #[cfg(feature = "llvm-15-or-greater")]
    let memset: &instruction::Call = &bbs[0].instrs[2]
        .clone()
        .try_into()
        .expect("Should be a call");
    if let Either::Right(Operand::ConstantOperand(cref)) = &memset.function {
        if let Constant::GlobalReference { ref name, ref ty } = cref.as_ref() {
            #[cfg(feature = "llvm-14-or-lower")]
            assert_eq!(*name, Name::from("llvm.memset.p0i8.i64"));
            #[cfg(feature = "llvm-15-or-greater")]
            assert_eq!(*name, Name::from("llvm.memset.p0.i64"));
            if let Type::FuncType {
                result_type,
                param_types,
                is_var_arg,
            } = ty.as_ref()
            {
                assert_eq!(result_type, &module.types.void());
                assert_eq!(
                    param_types,
                    &vec![
                        #[cfg(feature = "llvm-14-or-lower")]
                        module.types.pointer_to(module.types.i8()),
                        #[cfg(feature = "llvm-15-or-greater")]
                        module.types.pointer(),
                        module.types.i8(),
                        module.types.i64(),
                        module.types.bool()
                    ]
                );
                assert_eq!(*is_var_arg, false);
            } else {
                panic!("memset.function has unexpected type {:?}", ty);
            }
        } else {
            panic!(
                "memset.function not a GlobalReference as expected; it is actually another kind of Constant: {:?}",
                cref
            );
        }
    } else {
        panic!(
            "memset.function not a GlobalReference as expected; it is actually {:?}",
            memset.function
        );
    }
    assert_eq!(memset.arguments.len(), 4);
    #[cfg(feature = "llvm-14-or-lower")]
    let memset_arg0_expected_name = Name::Number(4);
    #[cfg(feature = "llvm-15-or-greater")]
    let memset_arg0_expected_name = Name::Number(3);
    #[cfg(feature = "llvm-14-or-lower")]
    let memset_arg0_expected_ty = module.types.pointer_to(module.types.i8());
    #[cfg(feature = "llvm-15-or-greater")]
    let memset_arg0_expected_ty = module.types.pointer();
    assert_eq!(
        memset.arguments[0].0,
        Operand::LocalOperand {
            name: memset_arg0_expected_name,
            ty: memset_arg0_expected_ty,
        }
    );
    assert_eq!(
        memset.arguments[1].0,
        Operand::ConstantOperand(ConstantRef::new(Constant::Int { bits: 8, value: 0 }))
    );
    assert_eq!(
        memset.arguments[2].0,
        Operand::ConstantOperand(ConstantRef::new(Constant::Int {
            bits: 64,
            value: 40
        }))
    );
    assert_eq!(
        memset.arguments[3].0,
        Operand::ConstantOperand(ConstantRef::new(Constant::Int { bits: 1, value: 1 }))
    );
    assert_eq!(memset.arguments[0].1.len(), 2); // should have two parameter attributes
    #[cfg(feature = "llvm-14-or-lower")]
    let expected_fmt = "call @llvm.memset.p0i8.i64(i8* %4, i8 0, i64 40, i1 true)";
    #[cfg(feature = "llvm-15-or-greater")]
    let expected_fmt = "call @llvm.memset.p0.i64(ptr %3, i8 0, i64 40, i1 true)";
    assert_eq!(&memset.to_string(), expected_fmt);
    #[cfg(feature = "llvm-12-or-lower")]
    {
        let add: &instruction::Add = &bbs[0].instrs[4]
            .clone()
            .try_into()
            .expect("Should be an add");
        assert_eq!(
            add.operand0,
            Operand::LocalOperand {
                name: Name::Number(1),
                ty: module.types.i32()
            }
        );
        assert_eq!(
            add.operand1,
            Operand::ConstantOperand(ConstantRef::new(Constant::Int {
                bits: 32,
                value: 0x0000_0000_FFFF_FFFF
            }))
        );
        assert_eq!(add.dest, Name::Number(5));
        assert_eq!(module.type_of(add), module.types.i32());
        assert_eq!(&add.to_string(), "%5 = add i32 %1, i32 -1");
    }
    #[cfg(feature = "llvm-13")]
    {
        let add: &instruction::Add = &bbs[1].instrs[0]
            .clone()
            .try_into()
            .expect("Should be an add");
        assert_eq!(
            add.operand0,
            Operand::LocalOperand {
                name: Name::Number(0),
                ty: module.types.i32()
            }
        );
        assert_eq!(
            add.operand1,
            Operand::ConstantOperand(ConstantRef::new(Constant::Int { bits: 32, value: 3 }))
        );
        assert_eq!(add.dest, Name::Number(7));
        assert_eq!(module.type_of(add), module.types.i32());
        assert_eq!(&add.to_string(), "%7 = add i32 %0, i32 3");
    }
    #[cfg(feature = "llvm-14-or-greater")]
    {
        let add: &instruction::Add = &bbs[1].instrs[0]
            .clone()
            .try_into()
            .expect("Should be an add");
        assert_eq!(
            add.operand0,
            Operand::LocalOperand {
                name: Name::Number(0),
                ty: module.types.i32()
            }
        );
        assert_eq!(
            add.operand1,
            Operand::ConstantOperand(ConstantRef::new(Constant::Int { bits: 32, value: 3 }))
        );
        #[cfg(feature = "llvm-14-or-lower")]
        assert_eq!(add.dest, Name::Number(8));
        #[cfg(feature = "llvm-15-or-greater")]
        assert_eq!(add.dest, Name::Number(7));
        assert_eq!(module.type_of(add), module.types.i32());
        #[cfg(feature = "llvm-17-or-greater")]
        assert_eq!(add.nuw, false);
        #[cfg(feature = "llvm-17-or-greater")]
        assert_eq!(add.nsw, true);
        #[cfg(feature = "llvm-14-or-lower")]
        assert_eq!(&add.to_string(), "%8 = add i32 %0, i32 3");
        #[cfg(any(feature = "llvm-15", feature = "llvm-16"))]
        assert_eq!(&add.to_string(), "%7 = add i32 %0, i32 3");
        #[cfg(feature = "llvm-17-or-greater")]
        assert_eq!(&add.to_string(), "%7 = add nsw i32 %0, i32 3");
    }
    #[cfg(feature = "llvm-12-or-lower")]
    {
        let icmp: &instruction::ICmp = &bbs[0].instrs[5]
            .clone()
            .try_into()
            .expect("Should be an icmp");
        assert_eq!(icmp.predicate, IntPredicate::ULT);
        assert_eq!(
            icmp.operand0,
            Operand::LocalOperand {
                name: Name::Number(5),
                ty: module.types.i32()
            }
        );
        assert_eq!(
            icmp.operand1,
            Operand::ConstantOperand(ConstantRef::new(Constant::Int {
                bits: 32,
                value: 10
            }))
        );
        assert_eq!(module.type_of(icmp), module.types.bool());
        assert_eq!(&icmp.to_string(), "%6 = icmp ult i32 %5, i32 10");
    }
    #[cfg(feature = "llvm-13")]
    {
        let icmp: &instruction::ICmp = &bbs[0].instrs[4]
            .clone()
            .try_into()
            .expect("Should be an icmp");
        assert_eq!(icmp.predicate, IntPredicate::SLT);
        assert_eq!(
            icmp.operand0,
            Operand::LocalOperand {
                name: Name::Number(1),
                ty: module.types.i32()
            }
        );
        assert_eq!(
            icmp.operand1,
            Operand::ConstantOperand(ConstantRef::new(Constant::Int {
                bits: 32,
                value: 11
            }))
        );
        assert_eq!(module.type_of(icmp), module.types.bool());
        assert_eq!(&icmp.to_string(), "%5 = icmp slt i32 %1, i32 11");
    }
    #[cfg(feature = "llvm-14-or-greater")]
    {
        #[cfg(feature = "llvm-14-or-lower")]
        let icmp: &instruction::ICmp = &bbs[0].instrs[5]
            .clone()
            .try_into()
            .expect("Should be an icmp");
        #[cfg(feature = "llvm-15-or-greater")]
        let icmp: &instruction::ICmp = &bbs[0].instrs[4]
            .clone()
            .try_into()
            .expect("Should be an icmp");
        assert_eq!(icmp.predicate, IntPredicate::ULT);
        #[cfg(feature = "llvm-14-or-lower")]
        assert_eq!(
            icmp.operand0,
            Operand::LocalOperand {
                name: Name::Number(5),
                ty: module.types.i32()
            }
        );
        #[cfg(feature = "llvm-15-or-greater")]
        assert_eq!(
            icmp.operand0,
            Operand::LocalOperand {
                name: Name::Number(4),
                ty: module.types.i32()
            }
        );
        assert_eq!(
            icmp.operand1,
            Operand::ConstantOperand(ConstantRef::new(Constant::Int {
                bits: 32,
                value: 10
            }))
        );
        assert_eq!(module.type_of(icmp), module.types.bool());
        #[cfg(feature = "llvm-14-or-lower")]
        assert_eq!(&icmp.to_string(), "%6 = icmp ult i32 %5, i32 10");
        #[cfg(feature = "llvm-15-or-greater")]
        assert_eq!(&icmp.to_string(), "%5 = icmp ult i32 %4, i32 10");
    }

    let condbr: &terminator::CondBr = &bbs[0].term.clone().try_into().expect("Should be a condbr");
    #[cfg(feature = "llvm-12-or-lower")]
    let expected_condition_op = Name::Number(6);
    #[cfg(feature = "llvm-13")]
    let expected_condition_op = Name::Number(5);
    #[cfg(feature = "llvm-14")]
    let expected_condition_op = Name::Number(6);
    #[cfg(feature = "llvm-15-or-greater")]
    let expected_condition_op = Name::Number(5);
    assert_eq!(
        condbr.condition,
        Operand::LocalOperand {
            name: expected_condition_op.clone(),
            ty: module.types.bool()
        }
    );
    #[cfg(feature = "llvm-12-or-lower")]
    let expected_true_dest = Name::Number(7);
    #[cfg(feature = "llvm-13")]
    let expected_true_dest = Name::Number(6);
    #[cfg(feature = "llvm-14")]
    let expected_true_dest = Name::Number(7);
    #[cfg(feature = "llvm-15-or-greater")]
    let expected_true_dest = Name::Number(6);
    assert_eq!(condbr.true_dest, expected_true_dest);
    let expected_false_dest = if cfg!(feature = "llvm-9-or-lower") {
        Name::Number(22)
    } else if cfg!(feature = "llvm-10") {
        Name::Number(21)
    } else if cfg!(feature = "llvm-11") {
        Name::Number(24)
    } else if cfg!(feature = "llvm-12") || cfg!(feature = "llvm-13") {
        Name::Number(47)
    } else if cfg!(feature = "llvm-14") {
        Name::Number(46)
    } else if cfg!(all(feature = "llvm-15-or-greater", feature = "llvm-17-or-lower")) {
        Name::Number(44)
    } else {
        Name::Number(41)
    };
    assert_eq!(condbr.false_dest, expected_false_dest);
    assert_eq!(module.type_of(condbr), module.types.void());
    assert_eq!(
        &condbr.to_string(),
        &format!(
            "br i1 {}, label {}, label {}",
            expected_condition_op, expected_true_dest, expected_false_dest,
        ),
    );

    // check details about certain instructions in basic block %7
    // not sure why LLVM 10+ puts a ZExt here instead of SExt. Maybe it can prove it's equivalent?
    // in LLVM 12+, the ZExt is in a different block
    #[cfg(feature = "llvm-9-or-lower")]
    let ext: &instruction::SExt = &bbs[1].instrs[1]
        .clone()
        .try_into()
        .expect("Should be a SExt");
    #[cfg(feature = "llvm-10")]
    let ext: &instruction::ZExt = &bbs[1].instrs[1]
        .clone()
        .try_into()
        .expect("Should be a ZExt");
    #[cfg(feature = "llvm-11")]
    let ext: &instruction::ZExt = &bbs[1].instrs[3]
        .clone()
        .try_into()
        .expect("Should be a ZExt");
    #[cfg(feature = "llvm-12-or-greater")]
    let ext: &instruction::ZExt = &bbs[2].instrs[0]
        .clone()
        .try_into()
        .expect("Should be a ZExt");
    let ext_input = if cfg!(feature = "llvm-10-or-lower") {
        Name::Number(1)
    } else if cfg!(any(feature = "llvm-11", feature = "llvm-12")) {
        Name::Number(10)
    } else {
        Name::Number(1)
    };
    let ext_dest = if cfg!(feature = "llvm-10-or-lower") {
        Name::Number(9)
    } else if cfg!(feature = "llvm-11") {
        Name::Number(11)
    } else if cfg!(feature = "llvm-12") || cfg!(feature = "llvm-13") {
        Name::Number(13)
    } else if cfg!(feature = "llvm-14") {
        Name::Number(12)
    } else {
        Name::Number(10)
    };
    assert_eq!(
        ext.operand,
        Operand::LocalOperand {
            name: ext_input,
            ty: module.types.i32()
        }
    );
    assert_eq!(ext.to_type, module.types.i64());
    assert_eq!(ext.dest, ext_dest);
    assert_eq!(module.type_of(ext), module.types.i64());
    #[cfg(feature = "llvm-9-or-lower")]
    assert_eq!(&ext.to_string(), "%9 = sext i32 %1 to i64");
    #[cfg(feature = "llvm-10")]
    assert_eq!(&ext.to_string(), "%9 = zext i32 %1 to i64");
    #[cfg(feature = "llvm-11")]
    assert_eq!(&ext.to_string(), "%11 = zext i32 %10 to i64");
    #[cfg(feature = "llvm-12")]
    assert_eq!(&ext.to_string(), "%13 = zext i32 %10 to i64");
    #[cfg(feature = "llvm-13")]
    assert_eq!(&ext.to_string(), "%13 = zext i32 %1 to i64");
    #[cfg(feature = "llvm-14")]
    assert_eq!(&ext.to_string(), "%12 = zext i32 %1 to i64");
    #[cfg(feature = "llvm-15-or-greater")]
    assert_eq!(&ext.to_string(), "%10 = zext i32 %1 to i64");
    #[cfg(feature = "llvm-9-or-lower")]
    {
        // LLVM 10 and 11 don't have a Br in this function
        let br: &terminator::Br = &bbs[1].term.clone().try_into().expect("Should be a Br");
        assert_eq!(br.dest, Name::Number(10));
        assert_eq!(&br.to_string(), "br label %10");
    }
    #[cfg(feature = "llvm-12-or-greater")]
    {
        let br: &terminator::Br = &bbs[3].term.clone().try_into().expect("Should be a Br");
        #[cfg(any(feature = "llvm-12", feature = "llvm-13"))]
        {
            assert_eq!(br.dest, Name::Number(19));
            assert_eq!(&br.to_string(), "br label %19");
        }
        #[cfg(feature = "llvm-14")]
        {
            assert_eq!(br.dest, Name::Number(18));
            assert_eq!(&br.to_string(), "br label %18");
        }
        #[cfg(feature = "llvm-15-or-greater")]
        {
            assert_eq!(br.dest, Name::Number(16));
            assert_eq!(&br.to_string(), "br label %16");
        }
    }

    // check details about certain instructions in basic block %10 (LLVM 9-) / %12 (LLVM 10) / %14 (LLVM 11) / %19 (LLVM 12+)
    #[cfg(feature = "llvm-11-or-lower")]
    let phi: &instruction::Phi = &bbs[2].instrs[0]
        .clone()
        .try_into()
        .expect("Should be a Phi");
    #[cfg(feature = "llvm-12-or-greater")]
    let phi: &instruction::Phi = &bbs[4].instrs[0]
        .clone()
        .try_into()
        .expect("Should be a Phi");
    let phi_dest = if cfg!(feature = "llvm-9-or-lower") {
        Name::Number(11)
    } else if cfg!(feature = "llvm-10") {
        Name::Number(13)
    } else if cfg!(feature = "llvm-11") {
        Name::Number(15)
    } else if cfg!(any(feature = "llvm-12", feature = "llvm-13")) {
        Name::Number(20)
    } else if cfg!(feature = "llvm-14") {
        Name::Number(19)
    } else {
        Name::Number(17)
    };
    assert_eq!(phi.dest, phi_dest);
    assert_eq!(phi.to_type, module.types.i64());
    #[cfg(feature = "llvm-9-or-lower")]
    assert_eq!(
        phi.incoming_values,
        vec![
            (
                Operand::ConstantOperand(ConstantRef::new(Constant::Int { bits: 64, value: 0 })),
                Name::Number(7)
            ),
            (
                Operand::LocalOperand {
                    name: Name::Number(20),
                    ty: module.types.i64()
                },
                Name::Number(19)
            ),
        ]
    );
    #[cfg(feature = "llvm-10")]
    assert_eq!(
        phi.incoming_values,
        vec![
            (
                Operand::LocalOperand {
                    name: Name::Number(19),
                    ty: module.types.i64()
                },
                Name::Number(12)
            ),
            (
                Operand::ConstantOperand(ConstantRef::new(Constant::Int { bits: 64, value: 1 })),
                Name::Number(7)
            ),
        ]
    );
    #[cfg(feature = "llvm-11")]
    assert_eq!(
        phi.incoming_values,
        vec![
            (
                Operand::LocalOperand {
                    name: Name::Number(22),
                    ty: module.types.i64()
                },
                Name::Number(14)
            ),
            (
                Operand::ConstantOperand(ConstantRef::new(Constant::Int { bits: 64, value: 1 })),
                Name::Number(7)
            ),
        ]
    );
    #[cfg(any(feature = "llvm-12", feature = "llvm-13"))]
    assert_eq!(
        phi.incoming_values,
        vec![
            (
                Operand::ConstantOperand(ConstantRef::new(Constant::Int { bits: 64, value: 1 })),
                Name::Number(17)
            ),
            (
                Operand::LocalOperand {
                    name: Name::Number(34),
                    ty: module.types.i64()
                },
                Name::Number(19)
            ),
        ]
    );
    #[cfg(feature = "llvm-14")]
    assert_eq!(
        phi.incoming_values,
        vec![
            (
                Operand::ConstantOperand(ConstantRef::new(Constant::Int { bits: 64, value: 1 })),
                Name::Number(16)
            ),
            (
                Operand::LocalOperand {
                    name: Name::Number(33),
                    ty: module.types.i64()
                },
                Name::Number(18)
            ),
        ]
    );
    #[cfg(all(feature = "llvm-15-or-greater", feature = "llvm-17-or-lower"))]
    assert_eq!(
        phi.incoming_values,
        vec![
            (
                Operand::ConstantOperand(ConstantRef::new(Constant::Int { bits: 64, value: 1 })),
                Name::Number(14)
            ),
            (
                Operand::LocalOperand {
                    name: Name::Number(31),
                    ty: module.types.i64()
                },
                Name::Number(16)
            ),
        ]
    );
    #[cfg(feature = "llvm-18-or-greater")]
    assert_eq!(
        phi.incoming_values,
        vec![
            (
                Operand::ConstantOperand(ConstantRef::new(Constant::Int { bits: 64, value: 1 })),
                Name::Number(14)
            ),
            (
                Operand::LocalOperand {
                    name: Name::Number(29),
                    ty: module.types.i64()
                },
                Name::Number(16)
            ),
        ]
    );
    #[cfg(feature = "llvm-9-or-lower")]
    assert_eq!(
        &phi.to_string(),
        "%11 = phi i64 [ i64 0, %7 ], [ i64 %20, %19 ]"
    );
    #[cfg(feature = "llvm-10")]
    assert_eq!(
        &phi.to_string(),
        "%13 = phi i64 [ i64 %19, %12 ], [ i64 1, %7 ]"
    );
    #[cfg(feature = "llvm-11")]
    assert_eq!(
        &phi.to_string(),
        "%15 = phi i64 [ i64 %22, %14 ], [ i64 1, %7 ]"
    );
    #[cfg(any(feature = "llvm-12", feature = "llvm-13"))]
    assert_eq!(
        &phi.to_string(),
        "%20 = phi i64 [ i64 1, %17 ], [ i64 %34, %19 ]"
    );
    #[cfg(feature = "llvm-14")]
    assert_eq!(
        &phi.to_string(),
        "%19 = phi i64 [ i64 1, %16 ], [ i64 %33, %18 ]"
    );
    #[cfg(all(feature = "llvm-15-or-greater", feature = "llvm-17-or-lower"))]
    assert_eq!(
        &phi.to_string(),
        "%17 = phi i64 [ i64 1, %14 ], [ i64 %31, %16 ]"
    );
    #[cfg(feature = "llvm-18-or-greater")]
    assert_eq!(
        &phi.to_string(),
        "%17 = phi i64 [ i64 1, %14 ], [ i64 %29, %16 ]"
    );

    #[cfg(feature = "llvm-11-or-lower")]
    let gep: &instruction::GetElementPtr = &bbs[2].instrs[1]
        .clone()
        .try_into()
        .expect("Should be a gep");
    #[cfg(feature = "llvm-12-or-greater")]
    let gep: &instruction::GetElementPtr = &bbs[4].instrs[2]
        .clone()
        .try_into()
        .expect("Should be a gep");
    #[cfg(feature = "llvm-14-or-lower")]
    let gep_addr_expected_ty = module.types.pointer_to(allocated_type.clone());
    #[cfg(feature = "llvm-15-or-greater")]
    let gep_addr_expected_ty = module.types.pointer();
    assert_eq!(
        gep.address,
        Operand::LocalOperand {
            name: Name::Number(3),
            ty: gep_addr_expected_ty,
        }
    );
    let gep_dest = if cfg!(feature = "llvm-9-or-lower") {
        Name::Number(12)
    } else if cfg!(feature = "llvm-10") {
        Name::Number(14)
    } else if cfg!(feature = "llvm-11") {
        Name::Number(16)
    } else if cfg!(feature = "llvm-12") || cfg!(feature = "llvm-13") {
        Name::Number(22)
    } else if cfg!(feature = "llvm-14") {
        Name::Number(21)
    } else {
        Name::Number(19)
    };
    assert_eq!(gep.dest, gep_dest);
    assert_eq!(gep.in_bounds, true);
    let index = if cfg!(feature = "llvm-9-or-lower") {
        Name::Number(11)
    } else if cfg!(feature = "llvm-10") {
        Name::Number(13)
    } else if cfg!(feature = "llvm-11") {
        Name::Number(15)
    } else if cfg!(feature = "llvm-12") || cfg!(feature = "llvm-13") {
        Name::Number(20)
    } else if cfg!(feature = "llvm-14") {
        Name::Number(19)
    } else {
        Name::Number(17)
    };
    assert_eq!(
        gep.indices,
        vec![
            Operand::ConstantOperand(ConstantRef::new(Constant::Int { bits: 64, value: 0 })),
            Operand::LocalOperand {
                name: index,
                ty: module.types.i64()
            },
        ]
    );
    #[cfg(feature = "llvm-14-or-lower")]
    assert_eq!(
        module.type_of(gep),
        module.types.pointer_to(module.types.i32())
    );
    #[cfg(feature = "llvm-15-or-greater")]
    assert_eq!(module.type_of(gep), module.types.pointer());
    #[cfg(feature = "llvm-9-or-lower")]
    assert_eq!(
        &gep.to_string(),
        "%12 = getelementptr inbounds [10 x i32]* %3, i64 0, i64 %11"
    );
    #[cfg(feature = "llvm-10")]
    assert_eq!(
        &gep.to_string(),
        "%14 = getelementptr inbounds [10 x i32]* %3, i64 0, i64 %13"
    );
    #[cfg(feature = "llvm-11")]
    assert_eq!(
        &gep.to_string(),
        "%16 = getelementptr inbounds [10 x i32]* %3, i64 0, i64 %15"
    );
    #[cfg(any(feature = "llvm-12", feature = "llvm-13"))]
    assert_eq!(
        &gep.to_string(),
        "%22 = getelementptr inbounds [10 x i32]* %3, i64 0, i64 %20"
    );
    #[cfg(feature = "llvm-14")]
    assert_eq!(
        &gep.to_string(),
        "%21 = getelementptr inbounds [10 x i32]* %3, i64 0, i64 %19"
    );
    #[cfg(feature = "llvm-15-or-greater")]
    assert_eq!(
        &gep.to_string(),
        "%19 = getelementptr inbounds ptr %3, i64 0, i64 %17"
    );
    #[cfg(feature = "llvm-11-or-lower")]
    let store_inst = &bbs[2].instrs[2];
    #[cfg(feature = "llvm-12-or-greater")]
    let store_inst = &bbs[4].instrs[3];
    let store: &instruction::Store = &store_inst.clone().try_into().expect("Should be a store");
    let address = if cfg!(feature = "llvm-9-or-lower") {
        Name::Number(12)
    } else if cfg!(feature = "llvm-10") {
        Name::Number(14)
    } else if cfg!(feature = "llvm-11") {
        Name::Number(16)
    } else if cfg!(feature = "llvm-12") || cfg!(feature = "llvm-13") {
        Name::Number(22)
    } else if cfg!(feature = "llvm-14") {
        Name::Number(21)
    } else {
        Name::Number(19)
    };
    #[cfg(feature = "llvm-14-or-lower")]
    let address_ty = module.types.pointer_to(module.types.i32());
    #[cfg(feature = "llvm-15-or-greater")]
    let address_ty = module.types.pointer();
    assert_eq!(
        store.address,
        Operand::LocalOperand {
            name: address,
            ty: address_ty,
        }
    );
    #[cfg(feature = "llvm-12-or-lower")]
    assert_eq!(
        store.value,
        Operand::LocalOperand {
            name: Name::Number(8),
            ty: module.types.i32()
        }
    );
    #[cfg(feature = "llvm-13")]
    assert_eq!(
        store.value,
        Operand::LocalOperand {
            name: Name::Number(7),
            ty: module.types.i32()
        }
    );
    #[cfg(feature = "llvm-14")]
    assert_eq!(
        store.value,
        Operand::LocalOperand {
            name: Name::Number(8),
            ty: module.types.i32()
        }
    );
    #[cfg(feature = "llvm-15-or-greater")]
    assert_eq!(
        store.value,
        Operand::LocalOperand {
            name: Name::Number(7),
            ty: module.types.i32()
        }
    );
    assert_eq!(store.volatile, true);
    assert_eq!(store.alignment, 4);
    assert_eq!(module.type_of(store), module.types.void());
    assert_eq!(store_inst.is_atomic(), false);
    #[cfg(feature = "llvm-9-or-lower")]
    assert_eq!(
        &store.to_string(),
        "store volatile i32 %8, i32* %12, align 4"
    );
    #[cfg(feature = "llvm-10")]
    assert_eq!(
        &store.to_string(),
        "store volatile i32 %8, i32* %14, align 4"
    );
    #[cfg(feature = "llvm-11")]
    assert_eq!(
        &store.to_string(),
        "store volatile i32 %8, i32* %16, align 4"
    );
    #[cfg(feature = "llvm-12")]
    assert_eq!(
        &store.to_string(),
        "store volatile i32 %8, i32* %22, align 4"
    );
    #[cfg(feature = "llvm-13")]
    assert_eq!(
        &store.to_string(),
        "store volatile i32 %7, i32* %22, align 4"
    );
    #[cfg(feature = "llvm-14")]
    assert_eq!(
        &store.to_string(),
        "store volatile i32 %8, i32* %21, align 4"
    );
    #[cfg(feature = "llvm-15-or-greater")]
    assert_eq!(
        &store.to_string(),
        "store volatile i32 %7, ptr %19, align 4"
    );

    // and finally other instructions of types we haven't seen yet
    let load_inst: &Instruction = if cfg!(feature = "llvm-9-or-lower") {
        &bbs[3].instrs[2]
    } else if cfg!(feature = "llvm-10") {
        &bbs[2].instrs[5]
    } else if cfg!(feature = "llvm-11") {
        &bbs[2].instrs[6]
    } else if cfg!(all(feature = "llvm-12-or-greater", feature = "llvm-17-or-lower")) {
        &bbs[4].instrs[7]
    }
    else {
        // Clang 18 removes some instructions in the loop body c.f. Clang 17
        &bbs[4].instrs[6]
    };
    let load: &instruction::Load = &load_inst.clone().try_into().expect("Should be a load");
    let load_addr = if cfg!(feature = "llvm-10-or-lower") {
        Name::Number(16)
    } else if cfg!(feature = "llvm-11") {
        Name::Number(19)
    } else if cfg!(feature = "llvm-12") || cfg!(feature = "llvm-13") {
        Name::Number(25)
    } else if cfg!(feature = "llvm-14") {
        Name::Number(24)
    } else if cfg!(all(feature = "llvm-14-or-greater", feature = "llvm-17-or-lower")) {
        Name::Number(22)
    } else {
        Name::Number(21)
    };
    #[cfg(feature = "llvm-14-or-lower")]
    let load_addr_expected_ty = module.types.pointer_to(module.types.i32());
    #[cfg(feature = "llvm-15-or-greater")]
    let load_addr_expected_ty = module.types.pointer();
    assert_eq!(
        load.address,
        Operand::LocalOperand {
            name: load_addr,
            ty: load_addr_expected_ty,
        }
    );
    #[cfg(feature = "llvm-10-or-lower")]
    assert_eq!(load.dest, Name::Number(17));
    #[cfg(feature = "llvm-11")]
    assert_eq!(load.dest, Name::Number(20));
    #[cfg(any(feature = "llvm-12", feature = "llvm-13"))]
    assert_eq!(load.dest, Name::Number(26));
    #[cfg(feature = "llvm-14")]
    assert_eq!(load.dest, Name::Number(25));
    #[cfg(all(feature = "llvm-15-or-greater", feature = "llvm-17-or-lower"))]
    assert_eq!(load.dest, Name::Number(23));
    #[cfg(feature = "llvm-18-or-greater")]
    assert_eq!(load.dest, Name::Number(22));

    assert_eq!(load.volatile, true);
    assert_eq!(load.alignment, 4);
    assert_eq!(module.type_of(load), module.types.i32());
    assert_eq!(load_inst.is_atomic(), false);
    #[cfg(feature = "llvm-10-or-lower")]
    assert_eq!(&load.to_string(), "%17 = load volatile i32* %16, align 4");
    #[cfg(feature = "llvm-11")]
    assert_eq!(&load.to_string(), "%20 = load volatile i32* %19, align 4");
    #[cfg(any(feature = "llvm-12", feature = "llvm-13"))]
    assert_eq!(&load.to_string(), "%26 = load volatile i32* %25, align 4");
    #[cfg(feature = "llvm-14")]
    assert_eq!(&load.to_string(), "%25 = load volatile i32* %24, align 4");
    #[cfg(all(feature = "llvm-15-or-greater", feature = "llvm-17-or-lower"))]
    assert_eq!(
        &load.to_string(),
        "%23 = load volatile i32, ptr %22, align 4"
    );
    #[cfg(feature = "llvm-18-or-greater")]
    assert_eq!(
        &load.to_string(),
        "%22 = load volatile i32, ptr %21, align 4"
    );
    let ret: &Terminator = if cfg!(feature = "llvm-9-or-lower") {
        &bbs[5].term
    } else if cfg!(feature = "llvm-10") || cfg!(feature = "llvm-11") {
        &bbs[3].term
    } else {
        &bbs[5].term
    };
    let ret: &terminator::Ret = &ret.clone().try_into().expect("Should be a ret");
    assert_eq!(ret.return_operand, None);
    assert_eq!(module.type_of(ret), module.types.void());
    assert_eq!(&ret.to_string(), "ret void");
}

#[test]
fn switchbc() {
    init_logging();
    let path = llvm_bc_dir().join("switch.bc");
    let module = Module::from_bc_path(&path).expect("Failed to parse module");
    assert_eq!(module.functions.len(), 1);
    let func = &module.functions[0];
    assert_eq!(func.name, "has_a_switch");
    let bb = &func.basic_blocks[0];
    let switch: &terminator::Switch = &bb.term.clone().try_into().expect("Should be a switch");
    assert_eq!(
        switch.operand,
        Operand::LocalOperand {
            name: Name::Number(0),
            ty: module.types.i32()
        }
    );
    assert_eq!(switch.dests.len(), 9);
    assert_eq!(
        switch.dests[0],
        (
            ConstantRef::new(Constant::Int { bits: 32, value: 0 }),
            Name::Number(12)
        )
    );
    assert_eq!(
        switch.dests[1],
        (
            ConstantRef::new(Constant::Int { bits: 32, value: 1 }),
            Name::Number(2)
        )
    );
    assert_eq!(
        switch.dests[2],
        (
            ConstantRef::new(Constant::Int {
                bits: 32,
                value: 13
            }),
            Name::Number(3)
        )
    );
    assert_eq!(
        switch.dests[3],
        (
            ConstantRef::new(Constant::Int {
                bits: 32,
                value: 26
            }),
            Name::Number(4)
        )
    );
    assert_eq!(
        switch.dests[4],
        (
            ConstantRef::new(Constant::Int {
                bits: 32,
                value: 33
            }),
            Name::Number(5)
        )
    );
    assert_eq!(
        switch.dests[5],
        (
            ConstantRef::new(Constant::Int {
                bits: 32,
                value: 142
            }),
            Name::Number(6)
        )
    );
    assert_eq!(
        switch.dests[6],
        (
            ConstantRef::new(Constant::Int {
                bits: 32,
                value: 1678
            }),
            Name::Number(7)
        )
    );
    assert_eq!(
        switch.dests[7],
        (
            ConstantRef::new(Constant::Int {
                bits: 32,
                value: 88
            }),
            Name::Number(8)
        )
    );
    assert_eq!(
        switch.dests[8],
        (
            ConstantRef::new(Constant::Int {
                bits: 32,
                value: 101
            }),
            Name::Number(9)
        )
    );
    assert_eq!(switch.default_dest, Name::Number(10));
    assert_eq!(
        &switch.to_string(),
        "switch i32 %0, label %10 [ i32 0, label %12; i32 1, label %2; i32 13, label %3; i32 26, label %4; i32 33, label %5; i32 142, label %6; i32 1678, label %7; i32 88, label %8; i32 101, label %9; ]",
    );

    let phibb = &func
        .get_bb_by_name(&Name::Number(12))
        .expect("Failed to find bb %12");
    let phi: &instruction::Phi = &phibb.instrs[0].clone().try_into().expect("Should be a phi");
    assert_eq!(phi.incoming_values.len(), 10);
    assert_eq!(
        &phi.to_string(),
        "%13 = phi i32 [ i32 -1, %10 ], [ i32 -3, %9 ], [ i32 0, %8 ], [ i32 77, %7 ], [ i32 -33, %6 ], [ i32 1, %5 ], [ i32 -5, %4 ], [ i32 -7, %3 ], [ i32 5, %2 ], [ i32 3, %1 ]",
    );

    assert_eq!(
        module.get_func_decl_by_name("has_a_switch"),
        None,
        "has_a_switch should be a defined function, not a decl"
    );
    let decl = module
        .get_func_decl_by_name("puts")
        .expect("there should be a puts declaration");
    assert_eq!(decl.name, "puts");
    assert_eq!(decl.return_type, module.types.i32());
    assert_eq!(decl.parameters.len(), 1);
    #[cfg(feature = "llvm-14-or-lower")]
    let param_0_expected_ty = module.types.pointer_to(module.types.i8());
    #[cfg(feature = "llvm-15-or-greater")]
    let param_0_expected_ty = module.types.pointer();
    assert_eq!(module.type_of(&decl.parameters[0]), param_0_expected_ty,);
}

#[test]
fn variablesbc() {
    init_logging();
    let path = llvm_bc_dir().join("variables.bc");
    let module = Module::from_bc_path(&path).expect("Failed to parse module");
    assert_eq!(module.global_vars.len(), 1);
    let var = &module.global_vars[0];
    assert_eq!(var.name, Name::from("global"));
    assert_eq!(var.is_constant, false);
    #[cfg(feature = "llvm-14-or-lower")]
    assert_eq!(var.ty, module.types.pointer_to(module.types.i32()));
    #[cfg(feature = "llvm-15-or-greater")]
    assert_eq!(var.ty, module.types.pointer());
    assert_eq!(
        var.initializer,
        Some(ConstantRef::new(Constant::Int { bits: 32, value: 5 }))
    );
    assert_eq!(var.alignment, 4);
    assert!(var.get_debug_loc().is_none()); // this file was compiled without debuginfo

    assert_eq!(module.functions.len(), 1);
    let func = &module.functions[0];
    assert_eq!(func.name, "variables");
    let bb = &func.basic_blocks[0];
    let store: &instruction::Store = &bb.instrs[2].clone().try_into().expect("Should be a store");
    #[cfg(feature = "llvm-14-or-lower")]
    let store_addr_expected_ty = module.types.pointer_to(module.types.i32());
    #[cfg(feature = "llvm-15-or-greater")]
    let store_addr_expected_ty = module.types.pointer();
    assert_eq!(
        store.address,
        Operand::LocalOperand {
            name: Name::Number(3),
            ty: store_addr_expected_ty,
        }
    );
    assert_eq!(module.type_of(store), module.types.void());
    #[cfg(feature = "llvm-14-or-lower")]
    let expected_fmt = "store volatile i32 %0, i32* %3, align 4";
    #[cfg(feature = "llvm-15-or-greater")]
    let expected_fmt = "store volatile i32 %0, ptr %3, align 4";
    assert_eq!(&store.to_string(), expected_fmt);
    #[cfg(feature = "llvm-14-or-lower")]
    let load: &instruction::Load = &bb.instrs[8].clone().try_into().expect("Should be a load");
    #[cfg(feature = "llvm-15-or-greater")]
    let load: &instruction::Load = &bb.instrs[6].clone().try_into().expect("Should be a load");
    #[cfg(feature = "llvm-14-or-lower")]
    let load_addr_expected_ty = module.types.pointer_to(module.types.i32());
    #[cfg(feature = "llvm-15-or-greater")]
    let load_addr_expected_ty = module.types.pointer();
    assert_eq!(
        load.address,
        Operand::LocalOperand {
            name: Name::Number(4),
            ty: load_addr_expected_ty,
        }
    );
    assert_eq!(module.type_of(load), module.types.i32());
    #[cfg(feature = "llvm-14-or-lower")]
    let expected_fmt = "%8 = load volatile i32* %4, align 4";
    #[cfg(feature = "llvm-15-or-greater")]
    let expected_fmt = "%6 = load volatile i32, ptr %4, align 4";
    assert_eq!(&load.to_string(), expected_fmt);
    #[cfg(feature = "llvm-14-or-lower")]
    let global_load: &instruction::Load =
        &bb.instrs[14].clone().try_into().expect("Should be a load");
    #[cfg(feature = "llvm-15-or-greater")]
    let global_load: &instruction::Load =
        &bb.instrs[12].clone().try_into().expect("Should be a load");
    assert_eq!(
        global_load.address,
        Operand::ConstantOperand(ConstantRef::new(Constant::GlobalReference {
            name: Name::from("global"),
            ty: module.types.i32()
        }))
    );
    assert_eq!(module.type_of(global_load), module.types.i32());
    #[cfg(feature = "llvm-14-or-lower")]
    let expected_fmt = "%12 = load volatile i32* @global, align 4";
    #[cfg(feature = "llvm-15-or-greater")]
    let expected_fmt = "%10 = load volatile i32, ptr @global, align 4";
    assert_eq!(&global_load.to_string(), expected_fmt);
    #[cfg(feature = "llvm-14-or-lower")]
    let global_store: &instruction::Store =
        &bb.instrs[16].clone().try_into().expect("Should be a store");
    #[cfg(feature = "llvm-15-or-greater")]
    let global_store: &instruction::Store =
        &bb.instrs[14].clone().try_into().expect("Should be a store");
    assert_eq!(
        global_store.address,
        Operand::ConstantOperand(ConstantRef::new(Constant::GlobalReference {
            name: Name::from("global"),
            ty: module.types.i32()
        }))
    );
    assert_eq!(module.type_of(global_store), module.types.void());
    #[cfg(feature = "llvm-14-or-lower")]
    let expected_fmt = "store volatile i32 %13, i32* @global, align 4";
    #[cfg(feature = "llvm-15-or-greater")]
    let expected_fmt = "store volatile i32 %11, ptr @global, align 4";
    assert_eq!(&global_store.to_string(), expected_fmt);

    assert_eq!(
        module.get_func_decl_by_name("variables"),
        None,
        "variables should be a defined function, not a decl"
    );
    let decl = module
        .get_func_decl_by_name("malloc")
        .expect("there should be a malloc declaration");
    assert_eq!(decl.name, "malloc");
    #[cfg(feature = "llvm-14-or-lower")]
    assert_eq!(decl.return_type, module.types.pointer_to(module.types.i8()));
    #[cfg(feature = "llvm-15-or-greater")]
    assert_eq!(decl.return_type, module.types.pointer());
    assert!(decl
        .return_attributes
        .contains(&ParameterAttribute::NoAlias));
    assert_eq!(decl.parameters.len(), 1);
    assert_eq!(module.type_of(&decl.parameters[0]), module.types.i64());
    #[cfg(feature = "llvm-12-or-lower")]
    assert_eq!(decl.parameters[0].attributes, vec![]);
    #[cfg(feature = "llvm-13-or-greater")]
    assert_eq!(
        decl.parameters[0].attributes,
        vec![ParameterAttribute::NoUndef]
    );
}

// this test relates to the version of the file compiled with debuginfo
#[test]
fn variablesbcg() {
    init_logging();
    let path = llvm_bc_dir().join("variables.bc-g");
    let module = Module::from_bc_path(&path).expect("Failed to parse module");
    let debug_filename = "variables.c";
    let debug_directory_suffix = "/tests/basic_bc";

    // really all we want to check is the debugloc of the global variable.
    // other debuginfo stuff is covered in other tests
    assert_eq!(module.global_vars.len(), 1);
    let var = &module.global_vars[0];
    assert_eq!(var.name, Name::from("global"));
    let debugloc = var
        .get_debug_loc()
        .as_ref()
        .expect("expected the global to have a debugloc");
    assert_eq!(debugloc.line, 5);
    assert_eq!(debugloc.col, None); // only `Instruction`s and `Terminator`s get column numbers
    assert_eq!(debugloc.filename, debug_filename);
    assert!(debugloc.directory.as_ref().expect("directory should exist").ends_with(debug_directory_suffix));
}

/// this test checks for regression on issue #4
#[test]
fn issue4() {
    init_logging();
    let path = llvm_bc_dir().join("issue_4.bc");
    let module = Module::from_bc_path(&path).expect("Failed to parse module");
    assert_eq!(module.functions.len(), 1);
    let func = &module.functions[0];

    // not part of issue 4 proper, but let's check that we have the correct number of function attributes
    let expected_num_function_attributes = if cfg!(feature = "llvm-9") {
        22
    } else if cfg!(feature = "llvm-10") || cfg!(feature = "llvm-11") {
        // LLVM 10+ seems to have combined the two attributes
        // "no-frame-pointer-elim=true" and "no-frame-pointer-elim-non-leaf"
        // into a single attribute, "frame-pointer=all"
        21
    } else if cfg!(feature = "llvm-12") {
        // LLVM 12+ adds "willreturn"
        22
    } else if cfg!(feature = "llvm-13") || cfg!(feature = "llvm-14") {
        // LLVM 13+ adds "mustprogress" and "nosync"
        // LLVM 13+ removes the following string attributes:
        //   "disable-tail-calls=false"
        //   "less-precise-fpmad=false"
        //   "no-infs-fp-math=false"
        //   "no-jump-tables=false"
        //   "no-nans-fp-math=false"
        //   "no-signed-zeroes-fp-math=false"
        //   "unsafe-fp-math=false"
        //   "use-soft-float=false"
        // for a net of -6 attributes
        16
    } else if cfg!(feature = "llvm-15") {
        // LLVM 15+ adds "argmemonly"
        17
    } else if cfg!(feature = "llvm-16-or-greater") {
        // LLVM 16+ merges "argmemonly", "inaccessiblememonly", etc. into a single memory attribute
        // See https://discourse.llvm.org/t/rfc-unify-memory-effect-attributes/65579/20
        16
    } else {
        panic!("Shouldn't reach this")
    };
    assert_eq!(
        func.function_attributes.len(),
        expected_num_function_attributes,
        "Expected {} function attributes but have {}: {:?}",
        expected_num_function_attributes,
        func.function_attributes.len(),
        func.function_attributes
    );
    // and that all but 6 of them are StringAttributes (7 for LLVM 12; 9 for LLVM 13/14; 10 for LLVM 15+)
    let expected_num_enum_attrs = if cfg!(feature = "llvm-11-or-lower") {
        6
    } else if cfg!(feature = "llvm-12") {
        7 // adds "willreturn"
    } else if cfg!(feature = "llvm-13") || cfg!(feature = "llvm-14") {
        9 // adds "mustprogress" and "nosync"
    } else if cfg!(feature = "llvm-15") {
        10 // adds "argmemonly"
    } else if cfg!(feature = "llvm-16-or-greater") {
        9 // new "memory" attribute combines "argmemonly" and related attributes
    } else {
        unreachable!("Shouldn't reach this")
    };
    let string_attrs = func.function_attributes.iter().filter(|attr| {
        if let FunctionAttribute::StringAttribute { .. } = attr {
            true
        } else {
            false
        }
    });
    assert_eq!(
        string_attrs.count(),
        expected_num_function_attributes - expected_num_enum_attrs
    );

    // now check that the first parameter has 3 attributes (4 in LLVM 11/12/13, 5 in LLVM 14) and the second parameter has 0
    assert_eq!(func.parameters.len(), 2);
    let first_param_attrs = &func.parameters[0].attributes;
    #[cfg(feature = "llvm-10-or-lower")]
    assert_eq!(first_param_attrs.len(), 3);
    #[cfg(any(feature = "llvm-11", feature = "llvm-12", feature = "llvm-13"))]
    assert_eq!(first_param_attrs.len(), 4);
    #[cfg(all(feature = "llvm-14-or-greater", feature = "llvm-17-or-lower"))]
    assert_eq!(first_param_attrs.len(), 5);
    #[cfg(feature = "llvm-18-or-greater")]
    assert_eq!(first_param_attrs.len(), 7); // Clang 18 adds dead_on_unwind and writable
    let second_param_attrs = &func.parameters[1].attributes;
    #[cfg(feature = "llvm-13-or-lower")]
    assert_eq!(second_param_attrs.len(), 0);
    #[cfg(feature = "llvm-14-or-greater")]
    assert_eq!(second_param_attrs.len(), 1); // LLVM 14+ adds 'noundef' to the second param

    // and that one of the parameter attributes is SRet
    #[cfg(feature = "llvm-11-or-lower")]
    let is_sret = |attr: &ParameterAttribute| match attr {
        ParameterAttribute::SRet => true,
        _ => false,
    };
    #[cfg(feature = "llvm-12-or-greater")]
    let is_sret = |attr: &ParameterAttribute| match attr {
        ParameterAttribute::SRet(_) => true,
        _ => false,
    };
    assert!(first_param_attrs.iter().any(is_sret));
}

/// This test checks for regression on issue 42
#[cfg(feature = "llvm-14-or-greater")]
#[test]
fn issue42() {
    init_logging();
    let path = Path::new(BC_DIR).join("issue-42.ll");
    let _ = Module::from_ir_path(&path).expect("Failed to parse module");
    // just check the module parses without errors
}

/// This test checks for regression on issue 57
#[cfg(feature = "llvm-16-or-greater")] // although the issue probably affects all of our supported versions (IFunc has existed since at least LLVM 8), the provided bitcode was produced with LLVM 16
#[test]
fn issue57() {
    init_logging();
    let path = Path::new(BC_DIR).join("ifunc_minimal.ll");
    let module = Module::from_ir_path(&path).expect("Failed to parse module");
    let ifunc = module.get_global_ifunc_by_name(&Name::from("__libc_strstr")).expect("failed to find global ifunc");
    assert_eq!(ifunc.ty, module.types.pointer());
    match ifunc.resolver_fn.as_ref() {
        Constant::GlobalReference { name, ty } => {
            assert_eq!(name, &Name::from("__libc_strstr_ifunc"));
            assert_eq!(ty, &module.types.func_type(module.types.pointer(), vec![], false));
        }
        _ => panic!("expected a GlobalReference"),
    }

    let path = Path::new(BC_DIR).join("strstr.o.bc");
    let _ = Module::from_bc_path(&path).expect("Failed to parse module");
    // just check the module parses without errors
}

#[test]
fn rustbc() {
    // This tests against the checked-in rust.bc, which was generated from the checked-in rust.rs with rustc 1.39.0
    init_logging();
    let path = rust_bc_dir().join("rust.bc");
    let module = Module::from_bc_path(&path).expect("Failed to parse module");
    let func = module
        .get_func_by_name("_ZN4rust9rust_loop17h3ed0672b8cf44eb1E")
        .expect("Failed to find function");

    assert_eq!(func.parameters.len(), 3);
    assert_eq!(func.parameters[0].name, Name::from("a"));
    assert_eq!(func.parameters[1].name, Name::from("b"));
    assert_eq!(func.parameters[2].name, Name::from("v"));
    assert_eq!(func.parameters[0].ty, module.types.i64());
    assert_eq!(func.parameters[1].ty, module.types.i64());
    #[cfg(feature = "llvm-14-or-lower")]
    assert_eq!(
        func.parameters[2].ty,
        module
            .types
            .pointer_to(module.types.named_struct("alloc::vec::Vec<isize>"))
    );
    #[cfg(feature = "llvm-15-or-greater")]
    assert_eq!(func.parameters[2].ty, module.types.pointer());

    let startbb = func
        .get_bb_by_name(&Name::from("start"))
        .expect("Failed to find bb 'start'");
    let alloca_iter: &instruction::Alloca = &startbb.instrs[5]
        .clone()
        .try_into()
        .expect("Should be an alloca");
    assert_eq!(alloca_iter.dest, Name::from("iter"));
    #[cfg(feature = "llvm-14-or-lower")]
    let expected_fmt = "%iter = alloca { i64*, i64* }, align 8";
    #[cfg(feature = "llvm-15-or-greater")]
    let expected_fmt = "%iter = alloca { ptr, ptr }, align 8";
    assert_eq!(&alloca_iter.to_string(), expected_fmt);
    let alloca_sum: &instruction::Alloca = &startbb.instrs[6]
        .clone()
        .try_into()
        .expect("Should be an alloca");
    assert_eq!(alloca_sum.dest, Name::from("sum"));
    assert_eq!(&alloca_sum.to_string(), "%sum = alloca i64, align 8");
    let store: &instruction::Store = &startbb.instrs[7]
        .clone()
        .try_into()
        .expect("Should be a store");
    #[cfg(feature = "llvm-14-or-lower")]
    let store_addr_expected_ty = module.types.pointer_to(module.types.i64());
    #[cfg(feature = "llvm-15-or-greater")]
    let store_addr_expected_ty = module.types.pointer();
    assert_eq!(
        store.address,
        Operand::LocalOperand {
            name: Name::from("sum"),
            ty: store_addr_expected_ty,
        }
    );
    #[cfg(feature = "llvm-14-or-lower")]
    let expected_fmt = "store i64 0, i64* %sum, align 8";
    #[cfg(feature = "llvm-15-or-greater")]
    let expected_fmt = "store i64 0, ptr %sum, align 8";
    assert_eq!(&store.to_string(), expected_fmt);
    let call: &instruction::Call = &startbb.instrs[8]
        .clone()
        .try_into()
        .expect("Should be a call");
    #[cfg(feature = "llvm-14-or-lower")]
    let param_type = module
        .types
        .pointer_to(module.types.named_struct("alloc::vec::Vec<isize>"));
    #[cfg(feature = "llvm-15-or-greater")]
    let param_type = module.types.pointer();
    let ret_type = module.types.struct_of(
        vec![
            #[cfg(feature = "llvm-14-or-lower")]
            module
                .types
                .pointer_to(module.types.array_of(module.types.i64(), 0)),
            #[cfg(feature = "llvm-15-or-greater")]
            module.types.pointer(),
            module.types.i64(),
        ],
        false,
    );
    if let Either::Right(Operand::ConstantOperand(cref)) = &call.function {
        if let Constant::GlobalReference { ref name, ref ty } = cref.as_ref() {
            assert_eq!(name, &Name::from("_ZN68_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$core..ops..deref..Deref$GT$5deref17h378128d7d9378466E"));
            match ty.as_ref() {
                Type::FuncType {
                    result_type,
                    param_types,
                    is_var_arg,
                } => {
                    assert_eq!(result_type, &ret_type);
                    assert_eq!(&param_types[0], &param_type);
                    assert_eq!(*is_var_arg, false);
                },
                _ => panic!("Expected called global to have FuncType, but got {:?}", ty),
            }
            assert_eq!(module.type_of(call), ret_type);
        } else {
            panic!(
                "call.function not a GlobalReference as expected; it is actually another kind of Constant: {:?}",
                cref
            );
        }
    } else {
        panic!(
            "call.function not a GlobalReference as expected; it is actually {:?}",
            call.function
        );
    }
    assert_eq!(call.arguments.len(), 1);
    assert_eq!(
        call.arguments[0].0,
        Operand::LocalOperand {
            name: Name::from("v"),
            ty: param_type,
        }
    );
    assert_eq!(call.dest, Some(Name::Number(0)));
    #[cfg(feature = "llvm-14-or-lower")]
    let expected_fmt = "%0 = call @_ZN68_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$core..ops..deref..Deref$GT$5deref17h378128d7d9378466E(%alloc::vec::Vec<isize>* %v)";
    #[cfg(feature = "llvm-15-or-greater")]
    let expected_fmt = "%0 = call @_ZN68_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$core..ops..deref..Deref$GT$5deref17h378128d7d9378466E(ptr %v)";
    assert_eq!(&call.to_string(), expected_fmt);

    // this file was compiled without debuginfo, so nothing should have a debugloc
    assert!(func.get_debug_loc().is_none());
    assert!(alloca_iter.get_debug_loc().is_none());
    assert!(alloca_sum.get_debug_loc().is_none());
    assert!(store.get_debug_loc().is_none());
    assert!(call.get_debug_loc().is_none());
}

// this test relates to the version of the file compiled with debuginfo
#[test]
fn rustbcg() {
    init_logging();
    let path = rust_bc_dir().join("rust.bc-g");
    let module = Module::from_bc_path(&path).expect("Failed to parse module");
    let debug_filename = "rust.rs";
    let debug_directory_suffix = "/tests/basic_bc";

    let func = module
        .get_func_by_name("_ZN4rust9rust_loop17h3ed0672b8cf44eb1E")
        .expect("Failed to find function");
    let debugloc = func
        .get_debug_loc()
        .as_ref()
        .expect("Expected function to have a debugloc");
    assert_eq!(debugloc.line, 3);
    assert_eq!(debugloc.col, None);
    assert_eq!(debugloc.filename, debug_filename);
    assert!(debugloc.directory.as_ref().expect("directory should exist").ends_with(debug_directory_suffix));

    let startbb = func
        .get_bb_by_name(&Name::from("start"))
        .expect("Failed to find bb 'start'");

    // the first 17 instructions in the function should not have debuglocs - they are just setting up the stack frame
    for i in 0..17 {
        assert!(startbb.instrs[i].get_debug_loc().is_none());
    }

    #[cfg(feature = "llvm-18-or-lower")]
    const EXPECTED_STORE_INSTRUCTION_INDEX : usize = 31;
    #[cfg(feature = "llvm-19-or-greater")]
    const EXPECTED_STORE_INSTRUCTION_INDEX : usize = 19;

    #[cfg(feature = "llvm-18-or-lower")]
    const EXPECTED_CALL_INSTRUCTION_INDEX : usize = 33;
    #[cfg(feature = "llvm-19-or-greater")]
    const EXPECTED_CALL_INSTRUCTION_INDEX : usize = 21;

    let store_debugloc = startbb.instrs[EXPECTED_STORE_INSTRUCTION_INDEX]
        .get_debug_loc()
        .as_ref()
        .expect("Expected this store to have a debugloc");
    assert_eq!(store_debugloc.line, 4);
    assert_eq!(store_debugloc.col, Some(18));
    assert_eq!(store_debugloc.filename, debug_filename);
    assert!(debugloc.directory.as_ref().expect("directory should exist").ends_with(debug_directory_suffix));
    #[cfg(feature = "llvm-14-or-lower")]
    let expected_fmt = "store i64 0, i64* %sum, align 8 (with debugloc)";
    #[cfg(feature = "llvm-15-or-greater")]
    let expected_fmt = "store i64 0, ptr %sum, align 8 (with debugloc)";
    assert_eq!(&startbb.instrs[EXPECTED_STORE_INSTRUCTION_INDEX].to_string(), expected_fmt);
    let call_debugloc = startbb.instrs[EXPECTED_CALL_INSTRUCTION_INDEX]
        .get_debug_loc()
        .as_ref()
        .expect("Expected this call to have a debugloc");
    assert_eq!(call_debugloc.line, 5);
    assert_eq!(call_debugloc.col, Some(13));
    assert_eq!(call_debugloc.filename, debug_filename);
    assert!(debugloc.directory.as_ref().expect("directory should exist").ends_with(debug_directory_suffix));
    #[cfg(feature = "llvm-14-or-lower")]
    let expected_fmt = "%4 = call @_ZN68_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$core..ops..deref..Deref$GT$5deref17h378128d7d9378466E(%alloc::vec::Vec<isize>* %3) (with debugloc)";
    #[cfg(feature = "llvm-15-or-greater")]
    let expected_fmt = "%4 = call @_ZN68_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$core..ops..deref..Deref$GT$5deref17h378128d7d9378466E(ptr %3) (with debugloc)";
    assert_eq!(&startbb.instrs[EXPECTED_CALL_INSTRUCTION_INDEX].to_string(), expected_fmt);
}

#[test]
fn simple_linked_list() {
    init_logging();
    let path = llvm_bc_dir().join("linkedlist.bc");
    let module = Module::from_bc_path(&path).expect("Failed to parse module");

    let struct_name: String = "struct.SimpleLinkedList".into();
    let structty = module.types.named_struct(&struct_name);
    match structty.as_ref() {
        Type::NamedStructType { name } => {
            assert_eq!(name, &struct_name);
        },
        ty => panic!(
            "Expected {} to be NamedStructType, but got {:?}",
            struct_name, ty
        ),
    }
    let structty_inner = match module.types.named_struct_def(&struct_name) {
        None => panic!(
            "Failed to find {} with module.types.named_struct_def(); have names {:?}",
            struct_name,
            module.types.all_struct_names().collect::<Vec<_>>()
        ),
        Some(NamedStructDef::Opaque) => panic!("{} should not be an opaque type", struct_name),
        Some(NamedStructDef::Defined(ty)) => ty,
    };
    if let Type::StructType { element_types, .. } = structty_inner.as_ref() {
        assert_eq!(element_types.len(), 2);
        assert_eq!(element_types[0], module.types.i32());
        #[cfg(feature = "llvm-14-or-lower")]
        if let Type::PointerType { pointee_type, .. } = element_types[1].as_ref() {
            if let Type::NamedStructType { name } = pointee_type.as_ref() {
                assert_eq!(name, &struct_name);
            } else {
                panic!(
                    "Expected pointee type to be a NamedStructType, got {:?}",
                    pointee_type
                );
            }
        } else {
            panic!(
                "Expected inner type to be a PointerType, got {:?}",
                element_types[1]
            );
        }
        #[cfg(feature = "llvm-15-or-greater")]
        assert!(matches!(
            element_types[1].as_ref(),
            Type::PointerType { .. }
        ));
    } else {
        panic!(
            "Expected {} to be a StructType, got {:?}",
            struct_name, structty
        );
    }

    let func = module
        .get_func_by_name("simple_linked_list")
        .expect("Failed to find function");
    let alloca: &instruction::Alloca = &func.basic_blocks[0].instrs[1]
        .clone()
        .try_into()
        .expect("Should be an alloca");
    if let Type::NamedStructType { name } = alloca.allocated_type.as_ref() {
        assert_eq!(name, &struct_name);
    } else {
        panic!(
            "Expected alloca.allocated_type to be a NamedStructType, got {:?}",
            alloca.allocated_type
        );
    }
    assert_eq!(
        &alloca.to_string(),
        "%3 = alloca %struct.SimpleLinkedList, align 8"
    );

    // LLVM 15 has no need for the SomeOpaqueStruct due to opaque pointer types
    #[cfg(feature = "llvm-14-or-lower")]
    {
        let struct_name: String = "struct.SomeOpaqueStruct".into();
        let structty = module.types.named_struct(&struct_name);
        match structty.as_ref() {
            Type::NamedStructType { name } => {
                assert_eq!(name, &struct_name);
            },
            ty => panic!(
                "Expected {} to be a NamedStructType, but got {:?}",
                struct_name, ty
            ),
        }
        match module.types.named_struct_def(&struct_name) {
            None => panic!(
                "Failed to find {} with module.types.named_struct_def(); have names {:?}",
                struct_name,
                module.types.all_struct_names().collect::<Vec<_>>()
            ),
            Some(NamedStructDef::Opaque) => (),
            Some(NamedStructDef::Defined(def)) => panic!(
                "{} should be an opaque type; got def {:?}",
                struct_name, def
            ),
        }
    }

    let func = module
        .get_func_by_name("takes_opaque_struct")
        .expect("Failed to find function");
    let paramty = &func.parameters[0].ty;
    #[cfg(feature = "llvm-14-or-lower")]
    match paramty.as_ref() {
        Type::PointerType { pointee_type, .. } => match pointee_type.as_ref() {
            Type::NamedStructType { name } => {
                assert_eq!(name, "struct.SomeOpaqueStruct");
            },
            ty => panic!(
                "Expected parameter type to be pointer to named struct, but got pointer to {:?}",
                ty
            ),
        },
        _ => panic!(
            "Expected parameter type to be pointer type, but got {:?}",
            paramty
        ),
    };
    #[cfg(feature = "llvm-15-or-greater")]
    assert!(matches!(paramty.as_ref(), Type::PointerType { .. }));
}

// this test relates to the version of the file compiled with debuginfo
#[test]
fn simple_linked_list_g() {
    init_logging();
    let path = llvm_bc_dir().join("linkedlist.bc-g");
    let module = Module::from_bc_path(&path).expect("Failed to parse module");
    let debug_filename = "linkedlist.c";
    let debug_directory_suffix = "/tests/basic_bc";

    let func = module
        .get_func_by_name("simple_linked_list")
        .expect("Failed to find function");
    let debugloc = func
        .get_debug_loc()
        .as_ref()
        .expect("expected simple_linked_list to have a debugloc");
    assert_eq!(debugloc.line, 8);
    assert_eq!(debugloc.col, None);
    assert_eq!(debugloc.filename, debug_filename);
    assert!(debugloc.directory.as_ref().expect("directory should exist").ends_with(debug_directory_suffix));

    // the first seven instructions shouldn't have debuglocs - they are just setting up the stack frame
    for i in 0..7 {
        assert!(func.basic_blocks[0].instrs[i].get_debug_loc().is_none());
    }

    // As of LLVM 19, debug info is now metadata instead of intrinsics
    #[cfg(feature = "llvm-18-or-lower")]
    {
        // the eighth instruction should have a debugloc
        let debugloc = func.basic_blocks[0].instrs[7]
            .get_debug_loc()
            .as_ref()
            .expect("expected this instruction to have a debugloc");
        assert_eq!(debugloc.line, 8);
        assert_eq!(debugloc.col, Some(28));
        assert_eq!(debugloc.filename, debug_filename);
        assert!(debugloc.directory.as_ref().expect("directory should exist").ends_with(debug_directory_suffix));
        assert_eq!(
            &func.basic_blocks[0].instrs[7].to_string(),
            "call @llvm.dbg.declare(<metadata>, <metadata>, <metadata>) (with debugloc)",
        );
    }

    // the tenth instruction should have a different debugloc
    let debugloc = func.basic_blocks[0].instrs[9]
        .get_debug_loc()
        .as_ref()
        .expect("expected this instruction to have a debugloc");
    assert_eq!(debugloc.line, 9);
    assert_eq!(debugloc.col, Some(34));
    assert_eq!(debugloc.filename, debug_filename);
    assert!(debugloc.directory.as_ref().expect("directory should exist").ends_with(debug_directory_suffix));

    #[cfg(feature = "llvm-14-or-lower")]
    let expected_fmt =
        "%8 = getelementptr inbounds %struct.SimpleLinkedList* %3, i32 0, i32 0 (with debugloc)";
    #[cfg(all(feature = "llvm-15-or-greater", feature = "llvm-18-or-lower"))]
    let expected_fmt = "%8 = getelementptr inbounds ptr %3, i32 0, i32 0 (with debugloc)";
    #[cfg(feature = "llvm-19-or-greater")]
    let expected_fmt = "store i32 %9, ptr %8, align 8 (with debugloc)";

    assert_eq!(&func.basic_blocks[0].instrs[9].to_string(), expected_fmt);
}

#[test]
fn indirectly_recursive_type() {
    init_logging();
    let path = llvm_bc_dir().join("linkedlist.bc");
    let module = Module::from_bc_path(&path).expect("Failed to parse module");

    let struct_name_a: String = "struct.NodeA".into();
    let aty = module.types.named_struct(&struct_name_a);
    match aty.as_ref() {
        Type::NamedStructType { name } => {
            assert_eq!(name, &struct_name_a);
        },
        ty => panic!(
            "Expected {} to be a NamedStructType, but got {:?}",
            struct_name_a, ty
        ),
    }
    let aty_inner = match module.types.named_struct_def(&struct_name_a) {
        None => panic!(
            "Failed to find {} with module.types.named_struct_def(); have names {:?}",
            struct_name_a,
            module.types.all_struct_names().collect::<Vec<_>>()
        ),
        Some(NamedStructDef::Opaque) => panic!("{} should not be an opaque type", &struct_name_a),
        Some(NamedStructDef::Defined(ty)) => ty,
    };
    let struct_name_b: String = "struct.NodeB".into();
    let bty = module.types.named_struct(&struct_name_b);
    match bty.as_ref() {
        Type::NamedStructType { name } => {
            assert_eq!(name, &struct_name_b);
        },
        ty => panic!(
            "Expected {} to be a NamedStructType, but got {:?}",
            struct_name_b, ty
        ),
    }
    let bty_inner = match module.types.named_struct_def(&struct_name_b) {
        None => panic!(
            "Failed to find {} with module.types.named_struct_def(); have names {:?}",
            struct_name_b,
            module.types.all_struct_names().collect::<Vec<_>>()
        ),
        Some(NamedStructDef::Opaque) => panic!("{} should not be an opaque type", &struct_name_b),
        Some(NamedStructDef::Defined(ty)) => ty,
    };
    if let Type::StructType { element_types, .. } = aty_inner.as_ref() {
        assert_eq!(element_types.len(), 2);
        assert_eq!(element_types[0], module.types.i32());
        #[cfg(feature = "llvm-14-or-lower")]
        if let Type::PointerType { pointee_type, .. } = element_types[1].as_ref() {
            if let Type::NamedStructType { name } = pointee_type.as_ref() {
                assert_eq!(name, &struct_name_b);
            } else {
                panic!(
                    "Expected pointee type to be a NamedStructType, got {:?}",
                    pointee_type.as_ref()
                );
            }
        } else {
            panic!(
                "Expected inner type to be a PointerType, got {:?}",
                element_types[1]
            );
        }
        #[cfg(feature = "llvm-15-or-greater")]
        assert!(matches!(
            element_types[1].as_ref(),
            Type::PointerType { .. }
        ));
    } else {
        panic!(
            "Expected NodeA inner type to be a StructType, got {:?}",
            aty
        );
    }
    if let Type::StructType { element_types, .. } = bty_inner.as_ref() {
        assert_eq!(element_types.len(), 2);
        assert_eq!(element_types[0], module.types.i32());
        #[cfg(feature = "llvm-14-or-lower")]
        if let Type::PointerType { pointee_type, .. } = element_types[1].as_ref() {
            if let Type::NamedStructType { name } = pointee_type.as_ref() {
                assert_eq!(name, &struct_name_a);
            } else {
                panic!(
                    "Expected pointee type to be a NamedStructType, got {:?}",
                    pointee_type.as_ref()
                );
            }
        } else {
            panic!(
                "Expected inner type to be a PointerType, got {:?}",
                element_types[1]
            );
        }
        #[cfg(feature = "llvm-15-or-greater")]
        assert!(matches!(
            element_types[1].as_ref(),
            Type::PointerType { .. }
        ));
    } else {
        panic!(
            "Expected NodeB inner type to be a StructType, got {:?}",
            bty
        );
    }

    let func = module
        .get_func_by_name("indirectly_recursive_type")
        .expect("Failed to find function");
    let alloca_a: &instruction::Alloca = &func.basic_blocks[0].instrs[1]
        .clone()
        .try_into()
        .expect("Should be an alloca");
    let alloca_b: &instruction::Alloca = &func.basic_blocks[0].instrs[2]
        .clone()
        .try_into()
        .expect("Should be an alloca");
    if let Type::NamedStructType { name } = alloca_a.allocated_type.as_ref() {
        assert_eq!(name, &struct_name_a);
    } else {
        panic!(
            "Expected alloca_a.allocated_type to be a NamedStructType, got {:?}",
            alloca_a.allocated_type
        );
    }
    if let Type::NamedStructType { name } = alloca_b.allocated_type.as_ref() {
        assert_eq!(name, &struct_name_b);
    } else {
        panic!(
            "Expected alloca_b.allocated_type to be a NamedStructType, got {:?}",
            alloca_b.allocated_type
        );
    }
    assert_eq!(&alloca_a.to_string(), "%3 = alloca %struct.NodeA, align 8");
    assert_eq!(&alloca_b.to_string(), "%4 = alloca %struct.NodeB, align 8");
}

#[test]
fn param_and_func_attributes() {
    let _ = env_logger::builder().is_test(true).try_init(); // capture log messages with test harness
    let path = llvm_bc_dir().join("param_and_func_attributes.ll.bc");
    let module = Module::from_bc_path(&path).expect("Failed to parse module");

    // Return attributes
    let zeroext_fn = module.get_func_by_name("f.zeroext").unwrap();
    assert_eq!(zeroext_fn.return_attributes.len(), 1);
    assert_eq!(zeroext_fn.return_attributes[0], ParameterAttribute::ZeroExt);
    let signext_fn = module.get_func_by_name("f.signext").unwrap();
    assert_eq!(signext_fn.return_attributes.len(), 1);
    assert_eq!(signext_fn.return_attributes[0], ParameterAttribute::SignExt);
    let inreg_fn = module.get_func_by_name("f.inreg").unwrap();
    assert_eq!(inreg_fn.return_attributes.len(), 1);
    assert_eq!(inreg_fn.return_attributes[0], ParameterAttribute::InReg);
    let noalias_fn = module.get_func_by_name("f.noalias").unwrap();
    assert_eq!(noalias_fn.return_attributes.len(), 1);
    assert_eq!(noalias_fn.return_attributes[0], ParameterAttribute::NoAlias);
    let nonnull_fn = module.get_func_by_name("f.nonnull").unwrap();
    assert_eq!(nonnull_fn.return_attributes.len(), 1);
    assert_eq!(nonnull_fn.return_attributes[0], ParameterAttribute::NonNull);
    let deref4_fn = module.get_func_by_name("f.dereferenceable4").unwrap();
    assert_eq!(deref4_fn.return_attributes.len(), 1);
    assert_eq!(
        deref4_fn.return_attributes[0],
        ParameterAttribute::Dereferenceable(4)
    );
    let deref8_fn = module.get_func_by_name("f.dereferenceable8").unwrap();
    assert_eq!(deref8_fn.return_attributes.len(), 1);
    assert_eq!(
        deref8_fn.return_attributes[0],
        ParameterAttribute::Dereferenceable(8)
    );
    let deref4ornull_fn = module
        .get_func_by_name("f.dereferenceable4_or_null")
        .unwrap();
    assert_eq!(deref4ornull_fn.return_attributes.len(), 1);
    assert_eq!(
        deref4ornull_fn.return_attributes[0],
        ParameterAttribute::DereferenceableOrNull(4)
    );
    let deref8ornull_fn = module
        .get_func_by_name("f.dereferenceable8_or_null")
        .unwrap();
    assert_eq!(deref8ornull_fn.return_attributes.len(), 1);
    assert_eq!(
        deref8ornull_fn.return_attributes[0],
        ParameterAttribute::DereferenceableOrNull(8)
    );

    // Parameter attributes
    let f = module.get_func_by_name("f.param.zeroext").unwrap();
    assert_eq!(f.parameters.len(), 1);
    let param = &f.parameters[0];
    assert_eq!(param.attributes.len(), 1);
    assert_eq!(param.attributes[0], ParameterAttribute::ZeroExt);
    let f = module.get_func_by_name("f.param.signext").unwrap();
    assert_eq!(f.parameters.len(), 1);
    let param = &f.parameters[0];
    assert_eq!(param.attributes.len(), 1);
    assert_eq!(param.attributes[0], ParameterAttribute::SignExt);
    let f = module.get_func_by_name("f.param.inreg").unwrap();
    assert_eq!(f.parameters.len(), 1);
    let param = &f.parameters[0];
    assert_eq!(param.attributes.len(), 1);
    assert_eq!(param.attributes[0], ParameterAttribute::InReg);
    let f = module.get_func_by_name("f.param.byval").unwrap();
    assert_eq!(f.parameters.len(), 1);
    let param = &f.parameters[0];
    assert_eq!(param.attributes.len(), 1);
    #[cfg(feature = "llvm-11-or-lower")]
    assert_eq!(param.attributes[0], ParameterAttribute::UnknownAttribute);
    #[cfg(feature = "llvm-12-or-greater")]
    match &param.attributes[0] {
        ParameterAttribute::ByVal(ty) => match ty.as_ref() {
            Type::StructType {
                element_types,
                is_packed: false,
            } => {
                assert_eq!(element_types.len(), 2);
            },
            ty => panic!("Expected a StructType with is_packed=false, got {:?}", ty),
        },
        attr => panic!("Expected a ByVal, got {:?}", attr),
    }
    let f = module.get_func_by_name("f.param.inalloca").unwrap();
    assert_eq!(f.parameters.len(), 1);
    let param = &f.parameters[0];
    assert_eq!(param.attributes.len(), 1);
    #[cfg(feature = "llvm-12-or-lower")]
    assert_eq!(param.attributes[0], ParameterAttribute::InAlloca);
    #[cfg(feature = "llvm-13-or-greater")]
    match &param.attributes[0] {
        ParameterAttribute::InAlloca(ty) => match ty.as_ref() {
            Type::IntegerType { bits: 8 } => {},
            ty => panic!("Expected i8, got {:?}", ty),
        },
        attr => panic!("Expected an InAlloca, got {:?}", attr),
    }
    let f = module.get_func_by_name("f.param.sret").unwrap();
    assert_eq!(f.parameters.len(), 1);
    let param = &f.parameters[0];
    assert_eq!(param.attributes.len(), 1);
    #[cfg(feature = "llvm-11-or-lower")]
    assert_eq!(param.attributes[0], ParameterAttribute::SRet);
    #[cfg(feature = "llvm-12-or-greater")]
    match &param.attributes[0] {
        ParameterAttribute::SRet(ty) => match ty.as_ref() {
            Type::IntegerType { bits: 8 } => {},
            ty => panic!("Expected i8, got {:?}", ty),
        },
        attr => panic!("Expected an SRet, got {:?}", attr),
    }
    let f = module.get_func_by_name("f.param.noalias").unwrap();
    assert_eq!(f.parameters.len(), 1);
    let param = &f.parameters[0];
    assert_eq!(param.attributes.len(), 1);
    assert_eq!(param.attributes[0], ParameterAttribute::NoAlias);
    let f = module.get_func_by_name("f.param.nocapture").unwrap();
    assert_eq!(f.parameters.len(), 1);
    let param = &f.parameters[0];
    assert_eq!(param.attributes.len(), 1);
    assert_eq!(param.attributes[0], ParameterAttribute::NoCapture);
    let f = module.get_func_by_name("f.param.nest").unwrap();
    assert_eq!(f.parameters.len(), 1);
    let param = &f.parameters[0];
    assert_eq!(param.attributes.len(), 1);
    assert_eq!(param.attributes[0], ParameterAttribute::Nest);
    let f = module.get_func_by_name("f.param.returned").unwrap();
    assert_eq!(f.parameters.len(), 1);
    let param = &f.parameters[0];
    assert_eq!(param.attributes.len(), 1);
    assert_eq!(param.attributes[0], ParameterAttribute::Returned);
    let f = module.get_func_by_name("f.param.nonnull").unwrap();
    assert_eq!(f.parameters.len(), 1);
    let param = &f.parameters[0];
    assert_eq!(param.attributes.len(), 1);
    assert_eq!(param.attributes[0], ParameterAttribute::NonNull);
    let f = module.get_func_by_name("f.param.dereferenceable").unwrap();
    assert_eq!(f.parameters.len(), 1);
    let param = &f.parameters[0];
    assert_eq!(param.attributes.len(), 1);
    assert_eq!(param.attributes[0], ParameterAttribute::Dereferenceable(4));
    let f = module
        .get_func_by_name("f.param.dereferenceable_or_null")
        .unwrap();
    assert_eq!(f.parameters.len(), 1);
    let param = &f.parameters[0];
    assert_eq!(param.attributes.len(), 1);
    assert_eq!(
        param.attributes[0],
        ParameterAttribute::DereferenceableOrNull(4)
    );

    // Function attributes
    let f = module.get_func_by_name("f.alignstack4").unwrap();
    assert_eq!(f.function_attributes.len(), 1);
    assert_eq!(f.function_attributes[0], FunctionAttribute::AlignStack(4));
    let f = module.get_func_by_name("f.alignstack8").unwrap();
    assert_eq!(f.function_attributes.len(), 1);
    assert_eq!(f.function_attributes[0], FunctionAttribute::AlignStack(8));
    let f = module.get_func_by_name("f.alwaysinline").unwrap();
    assert_eq!(f.function_attributes.len(), 1);
    assert_eq!(f.function_attributes[0], FunctionAttribute::AlwaysInline);
    let f = module.get_func_by_name("f.cold").unwrap();
    assert_eq!(f.function_attributes.len(), 1);
    assert_eq!(f.function_attributes[0], FunctionAttribute::Cold);
    let f = module.get_func_by_name("f.convergent").unwrap();
    assert_eq!(f.function_attributes.len(), 1);
    assert_eq!(f.function_attributes[0], FunctionAttribute::Convergent);
    let f = module.get_func_by_name("f.inlinehint").unwrap();
    assert_eq!(f.function_attributes.len(), 1);
    assert_eq!(f.function_attributes[0], FunctionAttribute::InlineHint);
    let f = module.get_func_by_name("f.jumptable").unwrap();
    assert_eq!(f.function_attributes.len(), 1);
    assert_eq!(f.function_attributes[0], FunctionAttribute::JumpTable);
    let f = module.get_func_by_name("f.minsize").unwrap();
    assert_eq!(f.function_attributes.len(), 1);
    assert_eq!(f.function_attributes[0], FunctionAttribute::MinimizeSize);
    let f = module.get_func_by_name("f.naked").unwrap();
    assert_eq!(f.function_attributes.len(), 1);
    assert_eq!(f.function_attributes[0], FunctionAttribute::Naked);
    let f = module.get_func_by_name("f.nobuiltin").unwrap();
    assert_eq!(f.function_attributes.len(), 1);
    assert_eq!(f.function_attributes[0], FunctionAttribute::NoBuiltin);
    let f = module.get_func_by_name("f.noduplicate").unwrap();
    assert_eq!(f.function_attributes.len(), 1);
    assert_eq!(f.function_attributes[0], FunctionAttribute::NoDuplicate);
    let f = module.get_func_by_name("f.noimplicitfloat").unwrap();
    assert_eq!(f.function_attributes.len(), 1);
    assert_eq!(f.function_attributes[0], FunctionAttribute::NoImplicitFloat);
    let f = module.get_func_by_name("f.nonlazybind").unwrap();
    assert_eq!(f.function_attributes.len(), 1);
    assert_eq!(f.function_attributes[0], FunctionAttribute::NonLazyBind);
    let f = module.get_func_by_name("f.noredzone").unwrap();
    assert_eq!(f.function_attributes.len(), 1);
    assert_eq!(f.function_attributes[0], FunctionAttribute::NoRedZone);
    let f = module.get_func_by_name("f.noreturn").unwrap();
    assert_eq!(f.function_attributes.len(), 1);
    assert_eq!(f.function_attributes[0], FunctionAttribute::NoReturn);
    let f = module.get_func_by_name("f.nounwind").unwrap();
    assert_eq!(f.function_attributes.len(), 1);
    assert_eq!(f.function_attributes[0], FunctionAttribute::NoUnwind);
    let f = module.get_func_by_name("f.optnone").unwrap();
    assert_eq!(f.function_attributes.len(), 2);
    assert_eq!(f.function_attributes[0], FunctionAttribute::NoInline);
    assert_eq!(f.function_attributes[1], FunctionAttribute::OptNone);
    let f = module.get_func_by_name("f.optsize").unwrap();
    assert_eq!(f.function_attributes.len(), 1);
    assert_eq!(f.function_attributes[0], FunctionAttribute::OptSize);
    let f = module.get_func_by_name("f.readnone").unwrap();
    assert_eq!(f.function_attributes.len(), 1);

    // LLVM 16 no longer has the ReadNone attribute
    #[cfg(feature="llvm-15-or-lower")]
    assert_eq!(f.function_attributes[0], FunctionAttribute::ReadNone);

    let f = module.get_func_by_name("f.readonly").unwrap();
    assert_eq!(f.function_attributes.len(), 1);

    // LLVM 16 no longer has the ReadOnly attribute
    #[cfg(feature="llvm-15-or-lower")]
    assert_eq!(f.function_attributes[0], FunctionAttribute::ReadOnly);

    let f = module.get_func_by_name("f.returns_twice").unwrap();
    assert_eq!(f.function_attributes.len(), 1);
    assert_eq!(f.function_attributes[0], FunctionAttribute::ReturnsTwice);
    let f = module.get_func_by_name("f.safestack").unwrap();
    assert_eq!(f.function_attributes.len(), 1);
    assert_eq!(f.function_attributes[0], FunctionAttribute::SafeStack);
    let f = module.get_func_by_name("f.sanitize_address").unwrap();
    assert_eq!(f.function_attributes.len(), 1);
    assert_eq!(f.function_attributes[0], FunctionAttribute::SanitizeAddress);
    let f = module.get_func_by_name("f.sanitize_memory").unwrap();
    assert_eq!(f.function_attributes.len(), 1);
    assert_eq!(f.function_attributes[0], FunctionAttribute::SanitizeMemory);
    let f = module.get_func_by_name("f.sanitize_thread").unwrap();
    assert_eq!(f.function_attributes.len(), 1);
    assert_eq!(f.function_attributes[0], FunctionAttribute::SanitizeThread);
    let f = module.get_func_by_name("f.ssp").unwrap();
    assert_eq!(f.function_attributes.len(), 1);
    assert_eq!(f.function_attributes[0], FunctionAttribute::StackProtect);
    let f = module.get_func_by_name("f.sspreq").unwrap();
    assert_eq!(f.function_attributes.len(), 1);
    assert_eq!(f.function_attributes[0], FunctionAttribute::StackProtectReq);
    let f = module.get_func_by_name("f.sspstrong").unwrap();
    assert_eq!(f.function_attributes.len(), 1);
    assert_eq!(
        f.function_attributes[0],
        FunctionAttribute::StackProtectStrong
    );
    let f = module.get_func_by_name("f.thunk").unwrap();
    assert_eq!(f.function_attributes.len(), 1);
    assert_eq!(
        f.function_attributes[0],
        FunctionAttribute::StringAttribute {
            kind: "thunk".into(),
            value: "".into()
        }
    );
    let f = module.get_func_by_name("f.uwtable").unwrap();
    assert_eq!(f.function_attributes.len(), 1);
    assert_eq!(f.function_attributes[0], FunctionAttribute::UWTable);
    let f = module.get_func_by_name("f.kvpair").unwrap();
    assert_eq!(f.function_attributes.len(), 1);
    assert_eq!(
        f.function_attributes[0],
        FunctionAttribute::StringAttribute {
            kind: "cpu".into(),
            value: "cortex-a8".into()
        }
    );
    let f = module.get_func_by_name("f.norecurse").unwrap();
    assert_eq!(f.function_attributes.len(), 1);
    assert_eq!(f.function_attributes[0], FunctionAttribute::NoRecurse);
    let f = module.get_func_by_name("f.inaccessiblememonly").unwrap();
    assert_eq!(f.function_attributes.len(), 1);

    // LLVM 16 no longer has InaccessibleMemOnly attribute
    #[cfg(feature="llvm-15-or-lower")]
    assert_eq!(
        f.function_attributes[0],
        FunctionAttribute::InaccessibleMemOnly
    );

    let f = module
        .get_func_by_name("f.inaccessiblemem_or_argmemonly")
        .unwrap();
    assert_eq!(f.function_attributes.len(), 1);

    // LLVM 16 no longer has InaccessibleMemOrArgMemOnly attribute
    #[cfg(feature="llvm-15-or-lower")]
    assert_eq!(
        f.function_attributes[0],
        FunctionAttribute::InaccessibleMemOrArgMemOnly
    );

    let f = module.get_func_by_name("f.strictfp").unwrap();
    assert_eq!(f.function_attributes.len(), 1);
    assert_eq!(f.function_attributes[0], FunctionAttribute::StrictFP);

    // Test the memory(...) attribute that's in LLVM 16+
    #[cfg(feature = "llvm-16-or-greater")]
    {
        let f = module.get_func_by_name("f.default_none").unwrap();
        assert_eq!(f.function_attributes.len(), 1);
        assert_eq!(f.function_attributes[0], FunctionAttribute::Memory {
            default: MemoryEffect::None,
            argmem: MemoryEffect::None,
            inaccessible_mem: MemoryEffect::None
        });

        let f = module.get_func_by_name("f.default_read").unwrap();
        assert_eq!(f.function_attributes.len(), 1);
        assert_eq!(f.function_attributes[0], FunctionAttribute::Memory {
            default: MemoryEffect::Read,
            argmem: MemoryEffect::Read,
            inaccessible_mem: MemoryEffect::Read
        });

        let f = module.get_func_by_name("f.default_write").unwrap();
        assert_eq!(f.function_attributes.len(), 1);
        assert_eq!(f.function_attributes[0], FunctionAttribute::Memory {
            default: MemoryEffect::Write,
            argmem: MemoryEffect::Write,
            inaccessible_mem: MemoryEffect::Write
        });

        let f = module.get_func_by_name("f.default_readwrite").unwrap();
        assert_eq!(f.function_attributes.len(), 1);
        assert_eq!(f.function_attributes[0], FunctionAttribute::Memory {
            default: MemoryEffect::ReadWrite,
            argmem: MemoryEffect::ReadWrite,
            inaccessible_mem: MemoryEffect::ReadWrite
        });

        let f = module.get_func_by_name("f.default_none_arg_readwrite").unwrap();
        assert_eq!(f.function_attributes.len(), 1);
        assert_eq!(f.function_attributes[0], FunctionAttribute::Memory {
            default: MemoryEffect::None,
            argmem: MemoryEffect::ReadWrite,
            inaccessible_mem: MemoryEffect::None
        });

        let f = module.get_func_by_name("f.default_readwrite_arg_none").unwrap();
        assert_eq!(f.function_attributes.len(), 1);
        assert_eq!(f.function_attributes[0], FunctionAttribute::Memory {
            default: MemoryEffect::ReadWrite,
            argmem: MemoryEffect::None,
            inaccessible_mem: MemoryEffect::ReadWrite
        });

        let f = module.get_func_by_name("f.arg_read").unwrap();
        assert_eq!(f.function_attributes.len(), 1);
        assert_eq!(f.function_attributes[0], FunctionAttribute::Memory {
            default: MemoryEffect::None,
            argmem: MemoryEffect::Read,
            inaccessible_mem: MemoryEffect::None
        });

        let f = module.get_func_by_name("f.inaccessiblemem_read").unwrap();
        assert_eq!(f.function_attributes.len(), 1);
        assert_eq!(f.function_attributes[0], FunctionAttribute::Memory {
            default: MemoryEffect::None,
            argmem: MemoryEffect::None,
            inaccessible_mem: MemoryEffect::Read
        });

        let f = module.get_func_by_name("f.default_read_inaccessiblemem_write_arg_none").unwrap();
        assert_eq!(f.function_attributes.len(), 1);
        assert_eq!(f.function_attributes[0], FunctionAttribute::Memory {
            default: MemoryEffect::Read,
            argmem: MemoryEffect::None,
            inaccessible_mem: MemoryEffect::Write
        });
    }
}

#[cfg(feature = "llvm-11-or-greater")]
#[test]
fn float_types() {
    init_logging();
    let path = llvm_bc_dir().join("float_types.bc");
    let module = Module::from_bc_path(&path).expect("Failed to parse module");

    let f = module.get_func_by_name("takes_half").unwrap();
    assert_eq!(
        module.type_of(f.parameters.get(0).unwrap()),
        module.types.fp(FPType::Half)
    );
    let f = module.get_func_by_name("takes_bfloat").unwrap();
    assert_eq!(
        module.type_of(f.parameters.get(0).unwrap()),
        module.types.fp(FPType::BFloat)
    );
    let f = module.get_func_by_name("takes_float").unwrap();
    assert_eq!(
        module.type_of(f.parameters.get(0).unwrap()),
        module.types.fp(FPType::Single)
    );
    let f = module.get_func_by_name("takes_double").unwrap();
    assert_eq!(
        module.type_of(f.parameters.get(0).unwrap()),
        module.types.fp(FPType::Double)
    );
    let f = module.get_func_by_name("takes_fp128").unwrap();
    assert_eq!(
        module.type_of(f.parameters.get(0).unwrap()),
        module.types.fp(FPType::FP128)
    );
    let f = module.get_func_by_name("takes_x86_fp80").unwrap();
    assert_eq!(
        module.type_of(f.parameters.get(0).unwrap()),
        module.types.fp(FPType::X86_FP80)
    );
    let f = module.get_func_by_name("takes_ppc_fp128").unwrap();
    assert_eq!(
        module.type_of(f.parameters.get(0).unwrap()),
        module.types.fp(FPType::PPC_FP128)
    );

    let f = module.get_func_by_name("returns_half").unwrap();
    #[cfg(feature = "llvm-14-or-lower")]
    assert_eq!(
        f.return_type,
        module.types.pointer_to(module.types.fp(FPType::Half))
    );
    #[cfg(feature = "llvm-15-or-greater")]
    assert_eq!(f.return_type, module.types.pointer());
    let f = module.get_func_by_name("returns_bfloat").unwrap();
    #[cfg(feature = "llvm-14-or-lower")]
    assert_eq!(
        f.return_type,
        module.types.pointer_to(module.types.fp(FPType::BFloat))
    );
    #[cfg(feature = "llvm-15-or-greater")]
    assert_eq!(f.return_type, module.types.pointer());
    let f = module.get_func_by_name("returns_float").unwrap();
    #[cfg(feature = "llvm-14-or-lower")]
    assert_eq!(
        f.return_type,
        module.types.pointer_to(module.types.fp(FPType::Single))
    );
    #[cfg(feature = "llvm-15-or-greater")]
    assert_eq!(f.return_type, module.types.pointer());
    let f = module.get_func_by_name("returns_double").unwrap();
    #[cfg(feature = "llvm-14-or-lower")]
    assert_eq!(
        f.return_type,
        module.types.pointer_to(module.types.fp(FPType::Double))
    );
    #[cfg(feature = "llvm-15-or-greater")]
    assert_eq!(f.return_type, module.types.pointer());
    let f = module.get_func_by_name("returns_fp128").unwrap();
    #[cfg(feature = "llvm-14-or-lower")]
    assert_eq!(
        f.return_type,
        module.types.pointer_to(module.types.fp(FPType::FP128))
    );
    #[cfg(feature = "llvm-15-or-greater")]
    assert_eq!(f.return_type, module.types.pointer());
    let f = module.get_func_by_name("returns_x86_fp80").unwrap();
    #[cfg(feature = "llvm-14-or-lower")]
    assert_eq!(
        f.return_type,
        module.types.pointer_to(module.types.fp(FPType::X86_FP80))
    );
    #[cfg(feature = "llvm-15-or-greater")]
    assert_eq!(f.return_type, module.types.pointer());
    let f = module.get_func_by_name("returns_ppc_fp128").unwrap();
    #[cfg(feature = "llvm-14-or-lower")]
    assert_eq!(
        f.return_type,
        module.types.pointer_to(module.types.fp(FPType::PPC_FP128))
    );
    #[cfg(feature = "llvm-15-or-greater")]
    assert_eq!(f.return_type, module.types.pointer());
}

#[test]
fn datalayouts() {
    init_logging();
    let path = llvm_bc_dir().join("hello.bc");
    let module = Module::from_bc_path(&path).expect("Failed to parse module");
    let data_layout = &module.data_layout;

    // Data layout changed from Clang 17 to 18, even w/ an explicit --target=x86_64-apple-macosx12.0.0
    #[cfg(feature = "llvm-18-or-greater")]
    {
        assert_eq!(
            &data_layout.layout_str,
            "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"
        );
        assert_eq!(&data_layout.endianness, &Endianness::LittleEndian);
        assert_eq!(&data_layout.mangling, &Some(Mangling::MachO));
        assert_eq!(
            data_layout.alignments.ptr_alignment(270),
            &PointerLayout {
                size: 32,
                alignment: Alignment { abi: 32, pref: 32 },
                index_size: 32
            }
        );
        assert_eq!(
            data_layout.alignments.ptr_alignment(271),
            &PointerLayout {
                size: 32,
                alignment: Alignment { abi: 32, pref: 32 },
                index_size: 32
            }
        );
        assert_eq!(
            data_layout.alignments.ptr_alignment(272),
            &PointerLayout {
                size: 64,
                alignment: Alignment { abi: 64, pref: 64 },
                index_size: 64
            }
        );
        assert_eq!(
            data_layout.alignments.ptr_alignment(0),
            &PointerLayout {
                size: 64,
                alignment: Alignment { abi: 64, pref: 64 },
                index_size: 64
            }
        );
        assert_eq!(
            data_layout.alignments.ptr_alignment(33),
            &PointerLayout {
                size: 64,
                alignment: Alignment { abi: 64, pref: 64 },
                index_size: 64
            }
        );
        assert_eq!(
            data_layout.alignments.int_alignment(64),
            &Alignment { abi: 64, pref: 64 }
        );
        assert_eq!(
            data_layout.alignments.int_alignment(7),
            &Alignment { abi: 8, pref: 8 }
        );
        assert_eq!(
            data_layout.alignments.int_alignment(26),
            &Alignment { abi: 32, pref: 32 }
        );
        assert_eq!(
            data_layout.alignments.int_alignment(123456),
            &Alignment { abi: 128, pref: 128 }
        );
        assert_eq!(
            data_layout.alignments.fp_alignment(FPType::Double),
            &Alignment { abi: 64, pref: 64 }
        );
        assert_eq!(
            data_layout.alignments.fp_alignment(FPType::X86_FP80),
            &Alignment {
                abi: 128,
                pref: 128
            }
        );
        assert_eq!(
            data_layout
                .native_int_widths
                .as_ref()
                .unwrap()
                .iter()
                .copied()
                .sorted()
                .collect::<Vec<_>>(),
            vec![8, 16, 32, 64]
        );
        assert_eq!(data_layout.stack_alignment, Some(128));
    }

    #[cfg(all(feature = "llvm-10-or-greater", feature = "llvm-17-or-lower"))]
    {
        assert_eq!(
            &data_layout.layout_str,
            "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
        );
        assert_eq!(&data_layout.endianness, &Endianness::LittleEndian);
        assert_eq!(&data_layout.mangling, &Some(Mangling::MachO));
        assert_eq!(
            data_layout.alignments.ptr_alignment(270),
            &PointerLayout {
                size: 32,
                alignment: Alignment { abi: 32, pref: 32 },
                index_size: 32
            }
        );
        assert_eq!(
            data_layout.alignments.ptr_alignment(271),
            &PointerLayout {
                size: 32,
                alignment: Alignment { abi: 32, pref: 32 },
                index_size: 32
            }
        );
        assert_eq!(
            data_layout.alignments.ptr_alignment(272),
            &PointerLayout {
                size: 64,
                alignment: Alignment { abi: 64, pref: 64 },
                index_size: 64
            }
        );
        assert_eq!(
            data_layout.alignments.ptr_alignment(0),
            &PointerLayout {
                size: 64,
                alignment: Alignment { abi: 64, pref: 64 },
                index_size: 64
            }
        );
        assert_eq!(
            data_layout.alignments.ptr_alignment(33),
            &PointerLayout {
                size: 64,
                alignment: Alignment { abi: 64, pref: 64 },
                index_size: 64
            }
        );
        assert_eq!(
            data_layout.alignments.int_alignment(64),
            &Alignment { abi: 64, pref: 64 }
        );
        assert_eq!(
            data_layout.alignments.int_alignment(7),
            &Alignment { abi: 8, pref: 8 }
        );
        assert_eq!(
            data_layout.alignments.int_alignment(26),
            &Alignment { abi: 32, pref: 32 }
        );
        assert_eq!(
            data_layout.alignments.int_alignment(123456),
            &Alignment { abi: 64, pref: 64 }
        );
        assert_eq!(
            data_layout.alignments.fp_alignment(FPType::Double),
            &Alignment { abi: 64, pref: 64 }
        );
        assert_eq!(
            data_layout.alignments.fp_alignment(FPType::X86_FP80),
            &Alignment {
                abi: 128,
                pref: 128
            }
        );
        assert_eq!(
            data_layout
                .native_int_widths
                .as_ref()
                .unwrap()
                .iter()
                .copied()
                .sorted()
                .collect::<Vec<_>>(),
            vec![8, 16, 32, 64]
        );
        assert_eq!(data_layout.stack_alignment, Some(128));
    }
    #[cfg(feature = "llvm-9-or-lower")]
    {
        assert_eq!(
            &data_layout.layout_str,
            "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
        );
        assert_eq!(&data_layout.endianness, &Endianness::LittleEndian);
        assert_eq!(&data_layout.mangling, &Some(Mangling::MachO));
        assert_eq!(
            data_layout.alignments.ptr_alignment(0),
            &PointerLayout {
                size: 64,
                alignment: Alignment { abi: 64, pref: 64 },
                index_size: 64
            }
        );
        assert_eq!(
            data_layout.alignments.ptr_alignment(33),
            &PointerLayout {
                size: 64,
                alignment: Alignment { abi: 64, pref: 64 },
                index_size: 64
            }
        );
        assert_eq!(
            data_layout.alignments.int_alignment(64),
            &Alignment { abi: 64, pref: 64 }
        );
        assert_eq!(
            data_layout.alignments.int_alignment(7),
            &Alignment { abi: 8, pref: 8 }
        );
        assert_eq!(
            data_layout.alignments.int_alignment(26),
            &Alignment { abi: 32, pref: 32 }
        );
        assert_eq!(
            data_layout.alignments.int_alignment(123456),
            &Alignment { abi: 64, pref: 64 }
        );
        assert_eq!(
            data_layout.alignments.fp_alignment(FPType::Double),
            &Alignment { abi: 64, pref: 64 }
        );
        assert_eq!(
            data_layout.alignments.fp_alignment(FPType::X86_FP80),
            &Alignment {
                abi: 128,
                pref: 128
            }
        );
        assert_eq!(
            data_layout
                .native_int_widths
                .as_ref()
                .unwrap()
                .iter()
                .copied()
                .sorted()
                .collect::<Vec<_>>(),
            vec![8, 16, 32, 64]
        );
        assert_eq!(data_layout.stack_alignment, Some(128));
    }

    assert_eq!(
        data_layout.alignments.type_alignment(&module.types.int(26)),
        &Alignment { abi: 32, pref: 32 }
    );
    #[cfg(feature = "llvm-14-or-lower")]
    assert_eq!(
        data_layout
            .alignments
            .type_alignment(&module.types.pointer_in_addr_space(module.types.int(32), 2)),
        &Alignment { abi: 64, pref: 64 }
    );
    #[cfg(feature = "llvm-15-or-greater")]
    assert_eq!(
        data_layout
            .alignments
            .type_alignment(&module.types.pointer_in_addr_space(2)),
        &Alignment { abi: 64, pref: 64 }
    );
    #[cfg(feature = "llvm-14-or-lower")]
    assert_eq!(
        data_layout
            .alignments
            .type_alignment(&module.types.pointer_to(module.types.func_type(
                module.types.void(),
                vec![],
                false
            ))),
        &Alignment { abi: 64, pref: 64 }
    );
}

#[test]
fn throw() {
    let _ = env_logger::builder().is_test(true).try_init(); // capture log messages with test harness
    let path = cxx_llvm_bc_dir().join("throw.bc");
    let module = Module::from_bc_path(&path).expect("Failed to parse module");

    // See https://github.com/cdisselkoen/llvm-ir/pull/30
    for func in module.functions {
        for block in func.basic_blocks {
            if let Terminator::Invoke(i) = block.term {
                i.get_type(&module.types);
            }
        }
    }
}

/*
#[test]
fn fences() {
    init_logging();
    let path = llvm_bc_dir().join("fences.ll.bc");
    let module = Module::from_bc_path(&path).expect("Failed to parse module");
    let f = module.get_func_by_name("fences").unwrap();
    let block = &f.basic_blocks[0];
    let seq_cst: &instruction::Fence = &block.instrs[0].clone().try_into().expect("Should be a fence");
    assert_eq!(seq_cst.atomicity.mem_ordering, MemoryOrdering::SequentiallyConsistent);
    let acq: &instruction::Fence = &block.instrs[1].clone().try_into().expect("Should be a fence");
    assert_eq!(acq.atomicity.mem_ordering, MemoryOrdering::Acquire);
    let rel: &instruction::Fence = &block.instrs[2].clone().try_into().expect("Should be a fence");
    assert_eq!(rel.atomicity.mem_ordering, MemoryOrdering::Release);
    let acq_rel: &instruction::Fence = &block.instrs[3].clone().try_into().expect("Should be a fence");
    assert_eq!(acq_rel.atomicity.mem_ordering, MemoryOrdering::AcquireRelease);
    let syncscope: &instruction::Fence = &block.instrs[4].clone().try_into().expect("Should be a fence");
    assert_eq!(syncscope.atomicity.mem_ordering, MemoryOrdering::SequentiallyConsistent);
    assert_eq!(syncscope.atomicity.synch_scope, SynchronizationScope::SingleThread);
}
*/

#[test]
fn parseir() -> Result<(), Box<dyn std::error::Error>> {
    let ir = "define void @f() { ret void }";

    let module = Module::from_ir_str(ir)?;
    assert_eq!(module.functions.len(), 1);
    let func = &module.functions[0];
    assert_eq!(func.name, "f");
    assert_eq!(func.parameters.len(), 0);
    assert_eq!(func.is_var_arg, false);
    assert_eq!(func.return_type, module.types.void());
    assert_eq!(func.basic_blocks.len(), 1);
    let bb = &func.basic_blocks[0];
    assert_eq!(bb.name, Name::Number(0));
    assert_eq!(bb.instrs.len(), 0);
    let ret: &terminator::Ret = &bb
        .term
        .clone()
        .try_into()
        .unwrap_or_else(|_| panic!("Terminator should be a Ret but is {:?}", &bb.term));
    assert_eq!(
        ret.return_operand,
        None
    );
    assert_eq!(&ret.to_string(), "ret void");

    // this file was compiled without debuginfo, so nothing should have a debugloc
    assert_eq!(func.debugloc, None);
    assert_eq!(ret.debugloc, None);
    Ok(())
}