nac3/nac3core/src/codegen/llvm_intrinsics.rs

use crate::codegen::CodeGenContext;
use inkwell::context::Context;
use inkwell::intrinsics::Intrinsic;
use inkwell::types::AnyTypeEnum::IntType;
use inkwell::types::FloatType;
use inkwell::values::{BasicValueEnum, CallSiteValue, FloatValue, IntValue, PointerValue};
use inkwell::AddressSpace;
use itertools::Either;

/// Returns the string representation for the floating-point type `ft` when used in intrinsic
/// functions.
fn get_float_intrinsic_repr(ctx: &Context, ft: FloatType) -> &'static str {
    // Standard LLVM floating-point types
    if ft == ctx.f16_type() {
        return "f16";
    }
    if ft == ctx.f32_type() {
        return "f32";
    }
    if ft == ctx.f64_type() {
        return "f64";
    }
    if ft == ctx.f128_type() {
        return "f128";
    }

    // Non-standard floating-point types
    if ft == ctx.x86_f80_type() {
        return "f80";
    }
    if ft == ctx.ppc_f128_type() {
        return "ppcf128";
    }

    unreachable!()
}

/// Invokes the [`llvm.stacksave`](https://llvm.org/docs/LangRef.html#llvm-stacksave-intrinsic)
/// intrinsic.
pub fn call_stacksave<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    name: Option<&str>,
) -> PointerValue<'ctx> {
    const FN_NAME: &str = "llvm.stacksave";

    let intrinsic_fn = Intrinsic::find(FN_NAME)
        .and_then(|intrinsic| intrinsic.get_declaration(&ctx.module, &[]))
        .unwrap();

    ctx.builder
        .build_call(intrinsic_fn, &[], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_pointer_value))
        .map(Either::unwrap_left)
        .unwrap()
}

/// Invokes the
/// [`llvm.stackrestore`](https://llvm.org/docs/LangRef.html#llvm-stackrestore-intrinsic) intrinsic.
///
/// - `ptr`: The pointer storing the address to restore the stack to.
pub fn call_stackrestore<'ctx>(ctx: &CodeGenContext<'ctx, '_>, ptr: PointerValue<'ctx>) {
    const FN_NAME: &str = "llvm.stackrestore";

    /*
        SEE https://github.com/TheDan64/inkwell/issues/496

        We want `llvm.stackrestore`, but the following would generate `llvm.stackrestore.p0i8`.
        ```ignore
        let intrinsic_fn = Intrinsic::find(FN_NAME)
            .and_then(|intrinsic| intrinsic.get_declaration(&ctx.module, &[llvm_p0i8.into()]))
            .unwrap();
        ```

        Temp workaround by manually declaring the intrinsic with the correct function name instead.
    */
    let intrinsic_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
        let llvm_void = ctx.ctx.void_type();
        let llvm_i8 = ctx.ctx.i8_type();
        let llvm_p0i8 = llvm_i8.ptr_type(AddressSpace::default());
        let fn_type = llvm_void.fn_type(&[llvm_p0i8.into()], false);

        ctx.module.add_function(FN_NAME, fn_type, None)
    });

    ctx.builder.build_call(intrinsic_fn, &[ptr.into()], "").unwrap();
}

/// Invokes the [`llvm.memcpy`](https://llvm.org/docs/LangRef.html#llvm-memcpy-intrinsic) intrinsic.
///
/// * `dest` - The pointer to the destination. Must be a pointer to an integer type.
/// * `src` - The pointer to the source. Must be a pointer to an integer type.
/// * `len` - The number of bytes to copy.
/// * `is_volatile` - Whether the `memcpy` operation should be `volatile`.
pub fn call_memcpy<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    dest: PointerValue<'ctx>,
    src: PointerValue<'ctx>,
    len: IntValue<'ctx>,
    is_volatile: IntValue<'ctx>,
) {
    const FN_NAME: &str = "llvm.memcpy";

    debug_assert!(dest.get_type().get_element_type().is_int_type());
    debug_assert!(src.get_type().get_element_type().is_int_type());
    debug_assert_eq!(
        dest.get_type().get_element_type().into_int_type().get_bit_width(),
        src.get_type().get_element_type().into_int_type().get_bit_width(),
    );
    debug_assert!(matches!(len.get_type().get_bit_width(), 32 | 64));
    debug_assert_eq!(is_volatile.get_type().get_bit_width(), 1);

    let llvm_dest_t = dest.get_type();
    let llvm_src_t = src.get_type();
    let llvm_len_t = len.get_type();

    let intrinsic_fn = Intrinsic::find(FN_NAME)
        .and_then(|intrinsic| {
            intrinsic.get_declaration(
                &ctx.module,
                &[llvm_dest_t.into(), llvm_src_t.into(), llvm_len_t.into()],
            )
        })
        .unwrap();

    ctx.builder
        .build_call(intrinsic_fn, &[dest.into(), src.into(), len.into(), is_volatile.into()], "")
        .unwrap();
}

/// Invokes the `llvm.memcpy` intrinsic.
///
/// Unlike [`call_memcpy`], this function accepts any type of pointer value. If `dest` or `src` is
/// not a pointer to an integer, the pointer(s) will be cast to `i8*` before invoking `memcpy`.
pub fn call_memcpy_generic<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    dest: PointerValue<'ctx>,
    src: PointerValue<'ctx>,
    len: IntValue<'ctx>,
    is_volatile: IntValue<'ctx>,
) {
    let llvm_i8 = ctx.ctx.i8_type();
    let llvm_p0i8 = llvm_i8.ptr_type(AddressSpace::default());

    let dest_elem_t = dest.get_type().get_element_type();
    let src_elem_t = src.get_type().get_element_type();

    let dest = if matches!(dest_elem_t, IntType(t) if t.get_bit_width() == 8) {
        dest
    } else {
        ctx.builder
            .build_bitcast(dest, llvm_p0i8, "")
            .map(BasicValueEnum::into_pointer_value)
            .unwrap()
    };
    let src = if matches!(src_elem_t, IntType(t) if t.get_bit_width() == 8) {
        src
    } else {
        ctx.builder
            .build_bitcast(src, llvm_p0i8, "")
            .map(BasicValueEnum::into_pointer_value)
            .unwrap()
    };

    call_memcpy(ctx, dest, src, len, is_volatile);
}

/// Macro to geneate llvm intrinsic build call.
///
/// Arguments:
/// * `$ctx:ident`: Reference to the current Code Generation Context
/// * `$name:ident`: Optional name to be assigned to the llvm build call (Option<&str>)
/// * `$llvm_name:literal`: Name of underlying llvm intrinsic function
/// * `$map_fn:ident`: Function from `BasicValueEnum` to be applied on `BasicValue` (`BasicValue` -> Function Return Type)
/// Use `into_int_value` for Integer return type and `into_float_value` for Float return type
/// * `$llvm_ty:ident`: Type of first operand
/// * `,($val:ident)*`: Comma separated list of operands
macro_rules! helper_generate_llvm_intrinsic_fn_call {
    ($ctx:ident, $name:ident, $llvm_name:literal, $map_fn:ident, $llvm_ty:ident $(,$val:ident)*) => {{
        const FN_NAME: &str = concat!("llvm.", $llvm_name);
        let intrinsic_fn = Intrinsic::find(FN_NAME).and_then(|intrinsic| intrinsic.get_declaration(&$ctx.module, &[$llvm_ty.into()])).unwrap();
        $ctx.builder.build_call(intrinsic_fn, &[$($val.into()),*],  $name.unwrap_or_default()).map(CallSiteValue::try_as_basic_value).map(|v| v.map_left(BasicValueEnum::$map_fn)).map(Either::unwrap_left).unwrap()
    }};
}

/// Macro to conveniently generate llvm intrinsic function call with [`helper_generate_llvm_intrinsic_fn_call`].
///
/// Arguments:
/// * `float/int`: Indicates the return type and argument type of the function
/// * `$fn_name:ident`: The identifier of the rust function to be generated
/// * `$llvm_name:literal`: Name of underlying llvm intrinsic function
/// Omit "llvm." prefix from the function name i.e. use ceil instead of llvm.ceil
/// * `$val:ident`: The operand for unary operations
/// * `$val1:ident`, `$val2:ident`: The operands for binary operations
macro_rules! generate_llvm_intrinsic_fn_call {
    ("float", $fn_name:ident, $llvm_name:literal, $val:ident) => {
        #[doc = concat!("Invokes the [`", stringify!($llvm_name), "`](https://llvm.org/docs/LangRef.html#llvm-", stringify!($llvm_name), "-intrinsic) intrinsic." )]
        pub fn $fn_name<'ctx> (
            ctx: &CodeGenContext<'ctx, '_>,
            $val: FloatValue<'ctx>,
            name: Option<&str>,
        ) -> FloatValue<'ctx> {
            let llvm_ty = $val.get_type();
            helper_generate_llvm_intrinsic_fn_call!(ctx, name, $llvm_name, into_float_value, llvm_ty, $val)
        }
    };
    ("float", $fn_name:ident, $llvm_name:literal, $val1:ident, $val2:ident) => {
        #[doc = concat!("Invokes the [`", stringify!($llvm_name), "`](https://llvm.org/docs/LangRef.html#llvm-", stringify!($llvm_name), "-intrinsic) intrinsic." )]
        pub fn $fn_name<'ctx> (
            ctx: &CodeGenContext<'ctx, '_>,
            $val1: FloatValue<'ctx>,
            $val2: FloatValue<'ctx>,
            name: Option<&str>,
        ) -> FloatValue<'ctx> {
            debug_assert_eq!($val1.get_type(), $val2.get_type());
            let llvm_ty = $val1.get_type();
            helper_generate_llvm_intrinsic_fn_call!(ctx, name, $llvm_name, into_float_value, llvm_ty, $val1, $val2)
        }
    };
    ("int", $fn_name:ident, $llvm_name:literal, $val1:ident, $val2:ident) => {
        #[doc = concat!("Invokes the [`", stringify!($llvm_name), "`](https://llvm.org/docs/LangRef.html#llvm-", stringify!($llvm_name), "-intrinsic) intrinsic." )]
        pub fn $fn_name<'ctx> (
            ctx: &CodeGenContext<'ctx, '_>,
            $val1: IntValue<'ctx>,
            $val2: IntValue<'ctx>,
            name: Option<&str>,
        ) -> IntValue<'ctx> {
            debug_assert_eq!($val1.get_type().get_bit_width(), $val2.get_type().get_bit_width());
            let llvm_ty = $val1.get_type();
            helper_generate_llvm_intrinsic_fn_call!(ctx, name, $llvm_name, into_int_value, llvm_ty, $val1, $val2)
        }
    };
}

/// Invokes the [`llvm.abs`](https://llvm.org/docs/LangRef.html#llvm-abs-intrinsic) intrinsic.
///
/// * `src` - The value for which the absolute value is to be returned.
/// * `is_int_min_poison` - Whether `poison` is to be returned if `src` is `INT_MIN`.
pub fn call_int_abs<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    src: IntValue<'ctx>,
    is_int_min_poison: IntValue<'ctx>,
    name: Option<&str>,
) -> IntValue<'ctx> {
    debug_assert_eq!(is_int_min_poison.get_type().get_bit_width(), 1);
    debug_assert!(is_int_min_poison.is_const());

    let src_type = src.get_type();
    helper_generate_llvm_intrinsic_fn_call!(
        ctx,
        name,
        "abs",
        into_int_value,
        src_type,
        src,
        is_int_min_poison
    )
}

generate_llvm_intrinsic_fn_call!("int", call_int_smax, "smax", a, b);
generate_llvm_intrinsic_fn_call!("int", call_int_smin, "smin", a, b);
generate_llvm_intrinsic_fn_call!("int", call_int_umax, "umax", a, b);
generate_llvm_intrinsic_fn_call!("int", call_int_umin, "umin", a, b);
generate_llvm_intrinsic_fn_call!("int", call_expect, "expect", val, expected_val);

generate_llvm_intrinsic_fn_call!("float", call_float_sqrt, "sqrt", val);
generate_llvm_intrinsic_fn_call!("float", call_float_sin, "sin", val);
generate_llvm_intrinsic_fn_call!("float", call_float_cos, "cos", val);
generate_llvm_intrinsic_fn_call!("float", call_float_pow, "pow", val, power);
generate_llvm_intrinsic_fn_call!("float", call_float_exp, "exp", val);
generate_llvm_intrinsic_fn_call!("float", call_float_exp2, "exp2", val);
generate_llvm_intrinsic_fn_call!("float", call_float_log, "log", val);
generate_llvm_intrinsic_fn_call!("float", call_float_log10, "log10", val);
generate_llvm_intrinsic_fn_call!("float", call_float_log2, "log2", val);
generate_llvm_intrinsic_fn_call!("float", call_float_fabs, "fabs", src);
generate_llvm_intrinsic_fn_call!("float", call_float_minnum, "minnum", val, power);
generate_llvm_intrinsic_fn_call!("float", call_float_maxnum, "maxnum", val, power);
generate_llvm_intrinsic_fn_call!("float", call_float_copysign, "copysign", mag, sgn);
generate_llvm_intrinsic_fn_call!("float", call_float_floor, "floor", val);
generate_llvm_intrinsic_fn_call!("float", call_float_ceil, "ceil", val);
generate_llvm_intrinsic_fn_call!("float", call_float_round, "round", val);
generate_llvm_intrinsic_fn_call!("float", call_float_rint, "rint", val);

/// Invokes the [`llvm.powi`](https://llvm.org/docs/LangRef.html#llvm-powi-intrinsic) intrinsic.
pub fn call_float_powi<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    val: FloatValue<'ctx>,
    power: IntValue<'ctx>,
    name: Option<&str>,
) -> FloatValue<'ctx> {
    const FN_NAME: &str = "llvm.powi";

    let llvm_val_t = val.get_type();
    let llvm_power_t = power.get_type();

    let intrinsic_fn = Intrinsic::find(FN_NAME)
        .and_then(|intrinsic| {
            intrinsic.get_declaration(&ctx.module, &[llvm_val_t.into(), llvm_power_t.into()])
        })
        .unwrap();

    ctx.builder
        .build_call(intrinsic_fn, &[val.into(), power.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
}