use std::fs::File;
use cranelift::prelude::{
    types::{self, Type},
    Value,
};
use cranelift_codegen::{
    ir::{
        AbiParam, Block, ExtFuncData, ExternalName, Function, InstBuilder, Signature,
        UserExternalName, UserFuncName,
    },
    isa::CallConv,
    settings::{self, Flags},
};
use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext};
use cranelift_module::{Linkage, Module};
use cranelift_object::{ObjectBuilder, ObjectModule};

fn main() {
    // Cranelift setup.
    let flags = Flags::new(settings::builder());
    let mut object_module = {
        let isa = cranelift_native::builder()
            .expect("Error getting native ISA")
            .finish(flags)
            .unwrap();
        let obj_builder =
            ObjectBuilder::new(isa, "program", cranelift_module::default_libcall_names()).unwrap();
        ObjectModule::new(obj_builder)
    };
    let mut builder_ctx = FunctionBuilderContext::new();

    // Some repeating patterns used in both fn0 and fn1.
    fn make_sig(params: &[Type], returns: &[Type]) -> Signature {
        let mut sig = Signature::new(CallConv::SystemV);
        sig.params = params.iter().map(|&t| AbiParam::new(t)).collect();
        sig.returns = returns.iter().map(|&t| AbiParam::new(t)).collect();
        sig
    }
    fn init_entry_block(builder: &mut FunctionBuilder) -> Block {
        let block = builder.create_block();
        builder.append_block_params_for_function_params(block);
        builder.switch_to_block(block);
        builder.seal_block(block);
        block
    }

    // Function `succ(i32) -> i32`.
    // fn 0:0
    let sig0 = make_sig(&[types::I32], &[types::I32]);
    {
        let func_id = object_module
            .declare_function("succ", Linkage::Export, &sig0)
            .unwrap();
        let mut func = Function::with_name_signature(UserFuncName::user(0, 0), sig0.clone());
        let mut builder = FunctionBuilder::new(&mut func, &mut builder_ctx);

        let entry_block = init_entry_block(&mut builder);
        let arg0 = builder.block_params(entry_block)[0];
        let val = builder.ins().iadd_imm(arg0, 1);
        builder.ins().return_(&[val]);
        builder.finalize();
        println!("{}", func);
        object_module
            .define_function(func_id, &mut cranelift_codegen::Context::for_function(func))
            .unwrap();
        func_id
    };

    // Function `main() -> i32`.
    // fn 0:1
    let sig1 = make_sig(&[], &[types::I32]);
    {
        let func_id = object_module
            .declare_function("main", Linkage::Export, &sig1)
            .unwrap();
        let mut func = Function::with_name_signature(UserFuncName::user(0, 1), sig1);
        let mut builder = FunctionBuilder::new(&mut func, &mut builder_ctx);

        // Import fn0.
        let fn0_ref = {
            let sig_ref = builder.import_signature(sig0);
            let name_ref = builder
                .func
                .declare_imported_user_function(UserExternalName::new(0, 1));
            builder.import_function(ExtFuncData {
                name: ExternalName::user(name_ref),
                signature: sig_ref,
                colocated: false,
            })
        };

        init_entry_block(&mut builder);
        let x = builder.ins().iconst(types::I32, 0);
        // This call instruction causes the generated code to segfault:
        let call_inst = builder.ins().call(fn0_ref, &[x]);
        let &call_result: &Value = builder
            .inst_results(call_inst)
            .iter()
            .next()
            .unwrap()
            .into();
        builder.ins().return_(&[call_result]);
        // Commenting the above and uncomment this line does not segfault:
        // builder.ins().return_(&[x]);
        builder.finalize();

        println!("{}", func);
        object_module
            .define_function(func_id, &mut cranelift_codegen::Context::for_function(func))
            .unwrap();
        func_id
    };

    let obj_prod = object_module.finish();
    let bytes = obj_prod.emit().unwrap();
    write_bytes_to_path("program.o", &bytes).unwrap();
}

fn write_bytes_to_path(path: &str, buf: &[u8]) -> std::io::Result<()> {
    let mut file = File::create(path)?;
    std::io::Write::write_all(&mut file, buf)
}

        isa.set("sign_return_address", "false").unwrap();

        let mut isa = cranelift_native::builder()
            .expect("Error getting native ISA");
        isa.set("sign_return_address", "false").unwrap();
        let isa = isa
            .finish(flags)
            .unwrap();

    let mut flags_builder = settings::builder();
    flags_builder.enable("is_pic").unwrap();
    let flags = Flags::new(flags_builder);

ld: warning: -no_pie is deprecated when targeting new OS versions
ld: warning: -no_pie ignored for arm64

m1@ab850359-a1b4-4fa7-85ab-da6c63f0c56d clif-test % ld -arch arm64 -macos_version_min 14.0.0 program.o
ld: dynamic executables or dylibs must link with libSystem.dylib for architecture arm64

m1@ab850359-a1b4-4fa7-85ab-da6c63f0c56d clif-test % clang -fuse-ld=lld -v ./program.o
Homebrew clang version 15.0.7
Target: arm64-apple-darwin23.1.0
Thread model: posix
InstalledDir: /opt/homebrew/opt/llvm@15/bin
 "/opt/homebrew/opt/llvm@15/bin/ld64.lld" -demangle -dynamic -arch arm64 -platform_version macos 14.0.0 14.0.0 -syslibroot /Library/Developer/CommandLineTools/SDKs/MacOSX14.sdk -o a.out ./program.o -lSystem /opt/homebrew/Cellar/llvm@15/15.0.7/lib/clang/15.0.7/lib/darwin/libclang_rt.osx.a
m1@ab850359-a1b4-4fa7-85ab-da6c63f0c56d clif-test % ./a.out
m1@ab850359-a1b4-4fa7-85ab-da6c63f0c56d clif-test %