//@ compile-flags: -Copt-level=3 -g -Zverify-llvm-ir -Zmerge-functions=disabled
//@ revisions: CODEGEN OPTIMIZED
//@[CODEGEN] compile-flags: -Cno-prepopulate-passes
//@ only-64bit
// ignore-tidy-linelength

#![crate_type = "lib"]
#![feature(repr_simd, rustc_attrs)]

// The pass mode is direct and the backend represent is scalar.
type Scalar = i32; // scalar(i32)
type Scalar_Ref = &'static i32; // scalar(ptr)

// The pass modes are pair and the backend represents are scalar pair.
type Tuple_Scalar_Scalar = (i32, i32);
struct Tuple_Ref_Scalar(&'static i32, i32);
struct Tuple_ArrayRef_Scalar(&'static [i32; 16], i32); // pair(ptr, i32)
impl Default for Tuple_ArrayRef_Scalar {
    fn default() -> Tuple_ArrayRef_Scalar {
        Tuple_ArrayRef_Scalar(&[0; 16], 0)
    }
}
struct Tuple_Scalar_ArrayRef(i32, &'static [i32; 16]); // pair(i32, ptr)
impl Default for Tuple_Scalar_ArrayRef {
    fn default() -> Tuple_Scalar_ArrayRef {
        Tuple_Scalar_ArrayRef(0, &[0; 16])
    }
}
// The pass mode is indirect and the backend represent is memory.
type Tuple_SliceRef_Scalar = (&'static [i32], i32);

// The pass mode is pair and the backend represent is scalar pair.
type SliceRef = &'static [i32]; // pair(ptr, i32)
// The pass mode is indirect and the backend represent is memory.
type Array = [i32; 16];
// The pass mode is direct and the backend represent is scalar.
type ArrayRef = &'static [i32; 16];

// The pass mode is indirect and the backend represent is memory.
type Typle_i32_i64_i8 = (i32, i64, i8);
// The pass mode is indirect and the backend represent is memory.
#[repr(C)]
struct Aggregate_i32_Array_i8(i32, &'static [i32; 16], i8);

type ZST = ();

impl Default for Aggregate_i32_Array_i8 {
    fn default() -> Aggregate_i32_Array_i8 {
        Aggregate_i32_Array_i8(0, &[0; 16], 0)
    }
}
// The pass mode is cast and the backend represent is scalar.
#[derive(Default)]
struct Aggregate_4xi8(i8, i8, i8, i8); // scalar(i32)

// The pass mode is indirect and the backend represent is simd vector.
#[repr(simd)]
struct Simd_i32x4([i32; 4]);

unsafe extern "Rust" {
    #[rustc_nounwind]
    safe fn opaque_fn();
    #[rustc_nounwind]
    safe fn opaque_ptr(_: *const core::ffi::c_void);
}

#[inline(never)]
#[rustc_nounwind]
fn opaque_use<T>(p: &T) {
    opaque_ptr(&raw const p as *const _);
}

#[inline(never)]
#[rustc_nounwind]
fn opaque_read<T: Default>() -> T {
    core::hint::black_box(T::default())
}

#[unsafe(no_mangle)]
fn local_var() {
    // CHECK-LABEL: define{{( dso_local)?}} void @local_var
    let local_var_scalar: Scalar = opaque_read();
    opaque_use(&local_var_scalar);
    let dead_local_var_scalar: Scalar = opaque_read();
    let local_var_aggregate_4xi8: Aggregate_4xi8 = opaque_read();
    opaque_use(&local_var_aggregate_4xi8);
    let local_var_aggregate_i32_array_i8: Aggregate_i32_Array_i8 = opaque_read();
    opaque_use(&local_var_aggregate_i32_array_i8);
    // CHECK: call void @opaque_fn()
    opaque_fn();
    // CHECK-NEXT: #dbg_value(ptr %local_var_scalar, [[ref_local_var_scalar:![0-9]+]], !DIExpression()
    let ref_local_var_scalar = &local_var_scalar;
    // CHECK-NEXT: #dbg_value(ptr poison, [[ref_dead_local_var_scalar:![0-9]+]], !DIExpression()
    let ref_dead_local_var_scalar = &dead_local_var_scalar;
    // CHECK-NEXT: #dbg_value(ptr %local_var_aggregate_4xi8, [[ref_local_var_aggregate_4xi8:![0-9]+]], !DIExpression()
    let ref_local_var_aggregate_4xi8 = &local_var_aggregate_4xi8;
    // CHECK-NEXT: #dbg_value(ptr %local_var_aggregate_4xi8, [[ref_0_local_var_aggregate_4xi8:![0-9]+]], !DIExpression()
    let ref_0_local_var_aggregate_4xi8 = &local_var_aggregate_4xi8.0;
    // CHECK-NEXT: #dbg_value(ptr %local_var_aggregate_4xi8, [[ref_2_local_var_aggregate_4xi8:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 2, DW_OP_stack_value)
    let ref_2_local_var_aggregate_4xi8 = &local_var_aggregate_4xi8.2;
    // This introduces an extra load instruction.
    // CHECK-NEXT: #dbg_value(ptr poison, [[ref_1_1_local_var_aggregate_i32_array_i8:![0-9]+]], !DIExpression()
    let ref_1_1_local_var_aggregate_i32_array_i8 = &local_var_aggregate_i32_array_i8.1[1];
    // CHECK-NEXT: #dbg_value(ptr %local_var_aggregate_i32_array_i8, [[ref_2_local_var_aggregate_i32_array_i8:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 16, DW_OP_stack_value)
    let ref_2_local_var_aggregate_i32_array_i8 = &local_var_aggregate_i32_array_i8.2;
    // CHECK: call void @opaque_fn()
    opaque_fn();
}

#[unsafe(no_mangle)]
fn zst(zst: ZST, zst_ref: &ZST) {
    // CHECK-LABEL: define{{( dso_local)?}} void @zst
    // CHECK: call void @opaque_fn()
    opaque_fn();
    // CHECK-NEXT: #dbg_value(ptr poison, [[ref_zst:![0-9]+]], !DIExpression()
    let ref_zst = &zst;
    // CHECK-NEXT: #dbg_value(ptr poison, [[ref_zst_ref:![0-9]+]], !DIExpression()
    let ref_zst_ref = &zst_ref;
    // CHECK: call void @opaque_fn()
    opaque_fn();
}

// It only makes sense if the argument is a reference and it refer to projections.
#[unsafe(no_mangle)]
fn direct(
    scalar: Scalar,
    scalar_ref: Scalar_Ref,
    array_ref: ArrayRef,
    aggregate_4xi8_ref: &Aggregate_4xi8,
) {
    // CHECK-LABEL: define{{( dso_local)?}} void @direct
    // CHECK: call void @opaque_fn()
    opaque_fn();
    // CHECK-NEXT: #dbg_value(ptr poison, [[ref_scalar:![0-9]+]], !DIExpression()
    let ref_scalar = &scalar;
    // CHECK-NEXT: #dbg_value(ptr poison, [[ref_scalar_ref:![0-9]+]], !DIExpression()
    let ref_scalar_ref = &scalar_ref;
    // CHECK-NEXT: #dbg_value(ptr %array_ref, [[ref_0_array_ref:![0-9]+]], !DIExpression()
    let ref_0_array_ref = &array_ref[0];
    // CHECK-NEXT: #dbg_value(ptr %array_ref, [[ref_1_array_ref:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 4, DW_OP_stack_value)
    let ref_1_array_ref = &array_ref[1];
    // CHECK-NEXT: #dbg_value(ptr %aggregate_4xi8_ref, [[ref_1_aggregate_4xi8_ref:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 1, DW_OP_stack_value)
    let ref_1_aggregate_4xi8_ref = &aggregate_4xi8_ref.1;
    // CHECK: call void @opaque_fn()
    opaque_fn();
}

// Arguments are passed through registers, the final values are poison.
#[unsafe(no_mangle)]
fn cast(aggregate_4xi8: Aggregate_4xi8) {
    // CHECK-LABEL: define{{( dso_local)?}} void @cast(i32 %0)
    // CHECK: call void @opaque_fn()
    opaque_fn();
    // The temporary allocated variable is eliminated.
    // CODEGEN-NEXT: #dbg_value(ptr %aggregate_4xi8, [[ref_aggregate_4xi8:![0-9]+]], !DIExpression()
    // OPTIMIZED-NEXT: #dbg_value(ptr undef, [[ref_aggregate_4xi8:![0-9]+]], !DIExpression()
    let ref_aggregate_4xi8 = &aggregate_4xi8;
    // CODEGEN-NEXT: #dbg_value(ptr %aggregate_4xi8, [[ref_0_aggregate_4xi8:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 1, DW_OP_stack_value)
    // OPTIMIZED-NEXT: #dbg_value(ptr undef, [[ref_0_aggregate_4xi8:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 1, DW_OP_stack_value)
    let ref_0_aggregate_4xi8 = &aggregate_4xi8.1;
    // CHECK: call void @opaque_fn()
    opaque_fn();
}

// Arguments are passed indirectly via a pointer.
// The reference of argument is the pointer itself.
#[unsafe(no_mangle)]
fn indirect(
    tuple_sliceref_scalar: Tuple_SliceRef_Scalar,
    array: Array,
    typle_i32_i64_i8: Typle_i32_i64_i8,
    simd_i32x4: Simd_i32x4,
) {
    // CHECK-LABEL: define{{( dso_local)?}} void @indirect
    // CHECK-SAME: (ptr{{.*}} %tuple_sliceref_scalar, ptr{{.*}} %array, ptr{{.*}} %typle_i32_i64_i8, ptr{{.*}} %simd_i32x4)
    // CHECK: call void @opaque_fn()
    opaque_fn();
    // CHECK-NEXT: #dbg_value(ptr %tuple_sliceref_scalar, [[ref_tuple_sliceref_scalar:![0-9]+]], !DIExpression()
    let ref_tuple_sliceref_scalar = &tuple_sliceref_scalar;
    // CHECK-NEXT: #dbg_value(ptr %tuple_sliceref_scalar, [[ref_1_tuple_sliceref_scalar:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 16, DW_OP_stack_value)
    let ref_1_tuple_sliceref_scalar = &tuple_sliceref_scalar.1;
    // CHECK-NEXT: #dbg_value(ptr %array, [[ref_1_array:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 4, DW_OP_stack_value)
    let ref_1_array = &array[1];
    // CHECK-NEXT: #dbg_value(ptr %typle_i32_i64_i8, [[ref_1_typle_i32_i64_i8:![0-9]+]], !DIExpression()
    let ref_1_typle_i32_i64_i8 = &typle_i32_i64_i8.1;
    // CHECK-NEXT: #dbg_value(ptr %simd_i32x4, [[ref_simd_i32x4:![0-9]+]], !DIExpression()
    let ref_simd_i32x4 = &simd_i32x4;
    // CHECK: call void @opaque_fn()
    opaque_fn();
}

// They are different MIR statements, but they have the same LLVM IR statement due to the ABI of arguments.
// Both `direct_ref` and `indirect_byval` are passed as a pointer here.
#[unsafe(no_mangle)]
fn direct_ref_and_indirect(
    direct_ref: &Aggregate_i32_Array_i8,
    indirect_byval: Aggregate_i32_Array_i8,
) {
    // CHECK-LABEL: define{{( dso_local)?}} void @direct_ref_and_indirect
    // CHECK-SAME: (ptr{{.*}} %direct_ref, ptr{{.*}} %indirect_byval)
    // CHECK: call void @opaque_fn()
    opaque_fn();
    // CHECK-NEXT: #dbg_value(ptr poison, [[ref_direct_ref:![0-9]+]], !DIExpression()
    let ref_direct_ref: &&Aggregate_i32_Array_i8 = &direct_ref;
    // CHECK-NEXT: #dbg_value(ptr %direct_ref, [[ref_1_direct_ref:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 8, DW_OP_stack_value)
    let ref_1_direct_ref = &direct_ref.1;
    // CHECK-NEXT: #dbg_value(ptr %indirect_byval, [[ref_indirect_byval:![0-9]+]], !DIExpression()
    let ref_indirect_byval: &Aggregate_i32_Array_i8 = &indirect_byval;
    // CHECK-NEXT: #dbg_value(ptr %indirect_byval, [[ref_1_indirect_byval:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 8, DW_OP_stack_value)
    let ref_1_indirect_byval = &indirect_byval.1;
    // CHECK: call void @opaque_fn()
    opaque_fn();
}

#[unsafe(no_mangle)]
fn pair(
    tuple_scalar_scalar: Tuple_Scalar_Scalar,
    tuple_ref_scalar: Tuple_Ref_Scalar,
    tuple_arrayref_scalar: Tuple_ArrayRef_Scalar,
    tuple_scalar_arrayref: Tuple_Scalar_ArrayRef,
    sliceref: SliceRef,
) {
    // CHECK-LABEL: define{{( dso_local)?}} void @pair
    // CHECK: call void @opaque_fn()
    opaque_fn();
    // CHECK-NEXT: #dbg_value(ptr poison, [[ref_0_tuple_scalar_scalar:![0-9]+]], !DIExpression()
    let ref_0_tuple_scalar_scalar = &tuple_scalar_scalar.0;
    // CHECK-NEXT: #dbg_value(ptr poison, [[ref_0_tuple_ref_scalar:![0-9]+]], !DIExpression()
    let ref_0_tuple_ref_scalar = &tuple_ref_scalar.0;
    // CHECK-NEXT: #dbg_value(ptr poison, [[ref_1_tuple_ref_scalar:![0-9]+]], !DIExpression()
    let ref_1_tuple_ref_scalar = &tuple_ref_scalar.1;
    // CHECK-NEXT: #dbg_value(ptr poison, [[ref_0_tuple_arrayref_scalar:![0-9]+]], !DIExpression()
    let ref_0_tuple_arrayref_scalar = &tuple_arrayref_scalar.0;
    // CHECK-NEXT: #dbg_value(ptr poison, [[ref_1_tuple_arrayref_scalar:![0-9]+]], !DIExpression()
    let ref_1_tuple_arrayref_scalar = &tuple_arrayref_scalar.1;
    // FIXME: This can be a valid value.
    // CHECK-NEXT: #dbg_value(ptr poison, [[ref_0_1_tuple_arrayref_scalar:![0-9]+]], !DIExpression()
    let ref_0_1_tuple_arrayref_scalar = &tuple_arrayref_scalar.0[1];
    // FIXME: This can be a valid value.
    // CHECK-NEXT: #dbg_value(ptr poison, [[ref_1_1_tuple_scalar_arrayref:![0-9]+]], !DIExpression()
    let ref_1_1_tuple_scalar_arrayref = &tuple_scalar_arrayref.1[1];
    // CHECK: #dbg_value(ptr %sliceref.0, [[ref_1_sliceref:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 4, DW_OP_stack_value)
    let ref_1_sliceref = &sliceref[1];
    // CHECK: call void @opaque_fn()
    opaque_fn();
}

#[repr(C)]
#[derive(Clone, Copy)]
pub struct Foo(i32, i64, i32);

#[repr(C)]
pub struct Bar<'a> {
    a: i32,
    b: i64,
    foo: &'a Foo,
}

#[unsafe(no_mangle)]
pub fn dead_first(dead_first_foo: &Foo) -> &i32 {
    // CHECK-LABEL: def {{.*}} ptr @dead_first
    // CHECK-SAME: (ptr {{.*}} [[ARG_dead_first_foo:%.*]])
    // CODEGEN: #dbg_declare(ptr %dead_first_foo.dbg.spill, [[ARG_dead_first_foo:![0-9]+]], !DIExpression()
    // OPTIMIZED: #dbg_value(ptr %dead_first_foo, [[ARG_dead_first_foo:![0-9]+]], !DIExpression()
    // CHECK: #dbg_value(ptr %dead_first_foo, [[VAR_dead_first_v0:![0-9]+]], !DIExpression()
    // CHECK: %dead_first_v0 = getelementptr{{.*}} i8, ptr %dead_first_foo, i64 16
    // CODEGEN: #dbg_declare(ptr %dead_first_v0.dbg.spill, [[VAR_dead_first_v0]], !DIExpression()
    // OPTIMIZED: #dbg_value(ptr %dead_first_v0, [[VAR_dead_first_v0]], !DIExpression()
    let mut dead_first_v0 = &dead_first_foo.0;
    dead_first_v0 = &dead_first_foo.2;
    dead_first_v0
}

#[unsafe(no_mangle)]
pub fn fragment(fragment_v1: Foo, mut fragment_v2: Foo) -> Foo {
    // CHECK-LABEL: define{{( dso_local)?}} void @fragment
    // CHECK-SAME: (ptr {{.*}}, ptr {{.*}} [[ARG_fragment_v1:%.*]], ptr {{.*}} [[ARG_fragment_v2:%.*]])
    // CHECK: #dbg_declare(ptr [[ARG_fragment_v1]]
    // CHECK-NEXT: #dbg_declare(ptr [[ARG_fragment_v2]]
    // CHECK-NEXT: #dbg_value(ptr [[ARG_fragment_v2]], [[VAR_fragment_f:![0-9]+]], !DIExpression(DW_OP_LLVM_fragment, 0, 64)
    // CHECK-NEXT: #dbg_value(ptr [[ARG_fragment_v1]], [[VAR_fragment_f:![0-9]+]], !DIExpression(DW_OP_LLVM_fragment, 64, 64)
    let fragment_f = || {
        fragment_v2 = fragment_v1;
    };
    fragment_v2 = fragment_v1;
    fragment_v2
}

#[unsafe(no_mangle)]
pub fn deref(bar: Bar) -> i32 {
    // CHECK-LABEL: define{{.*}} i32 @deref
    // We are unable to represent dereference within this expression.
    // CHECK: #dbg_value(ptr poison, [[VAR_deref_dead:![0-9]+]], !DIExpression()
    let deref_dead = &bar.foo.2;
    bar.a
}

#[unsafe(no_mangle)]
fn index(slice: &[i32; 4], idx: usize) -> i32 {
    // CHECK-LABEL: define{{.*}} i32 @index
    // CHECK: call void @opaque_fn()
    opaque_fn();
    // CHECK: #dbg_value(ptr poison, [[VAR_index_from_var:![0-9]+]], !DIExpression()
    let index_from_var = &slice[idx];
    // CHECK: #dbg_value(ptr %slice, [[VAR_const_index_from_start:![0-9]+]], !DIExpression()
    // CHECK-NEXT: #dbg_value(ptr poison, [[VAR_const_index_from_end:![0-9]+]], !DIExpression()
    let [ref const_index_from_start, .., ref const_index_from_end] = slice[..] else {
        return 0;
    };
    slice[0]
}

// CHECK-DAG: [[ref_local_var_scalar]] = !DILocalVariable(name: "ref_local_var_scalar"
// CHECK-DAG: [[ref_dead_local_var_scalar]] = !DILocalVariable(name: "ref_dead_local_var_scalar"
// CHECK-DAG: [[ref_local_var_aggregate_4xi8]] = !DILocalVariable(name: "ref_local_var_aggregate_4xi8"
// CHECK-DAG: [[ref_0_local_var_aggregate_4xi8]] = !DILocalVariable(name: "ref_0_local_var_aggregate_4xi8"
// CHECK-DAG: [[ref_2_local_var_aggregate_4xi8]] = !DILocalVariable(name: "ref_2_local_var_aggregate_4xi8"
// CHECK-DAG: [[ref_1_1_local_var_aggregate_i32_array_i8]] = !DILocalVariable(name: "ref_1_1_local_var_aggregate_i32_array_i8"
// CHECK-DAG: [[ref_2_local_var_aggregate_i32_array_i8]] = !DILocalVariable(name: "ref_2_local_var_aggregate_i32_array_i8"

// CHECK-DAG: [[ref_zst]] = !DILocalVariable(name: "ref_zst"
// CHECK-DAG: [[ref_zst_ref]] = !DILocalVariable(name: "ref_zst_ref"

// CHECK-DAG: [[ref_scalar]] = !DILocalVariable(name: "ref_scalar"
// CHECK-DAG: [[ref_scalar_ref]] = !DILocalVariable(name: "ref_scalar_ref"
// CHECK-DAG: [[ref_0_array_ref]] = !DILocalVariable(name: "ref_0_array_ref"
// CHECK-DAG: [[ref_1_array_ref]] = !DILocalVariable(name: "ref_1_array_ref"
// CHECK-DAG: [[ref_1_aggregate_4xi8_ref]] = !DILocalVariable(name: "ref_1_aggregate_4xi8_ref"

// CHECK-DAG: [[ref_aggregate_4xi8]] = !DILocalVariable(name: "ref_aggregate_4xi8"
// CHECK-DAG: [[ref_0_aggregate_4xi8]] = !DILocalVariable(name: "ref_0_aggregate_4xi8"

// CHECK-DAG: [[ref_tuple_sliceref_scalar]] = !DILocalVariable(name: "ref_tuple_sliceref_scalar"
// CHECK-DAG: [[ref_1_tuple_sliceref_scalar]] = !DILocalVariable(name: "ref_1_tuple_sliceref_scalar"
// CHECK-DAG: [[ref_1_array]] = !DILocalVariable(name: "ref_1_array"
// CHECK-DAG: [[ref_1_typle_i32_i64_i8]] = !DILocalVariable(name: "ref_1_typle_i32_i64_i8"
// CHECK-DAG: [[ref_simd_i32x4]] = !DILocalVariable(name: "ref_simd_i32x4"

// CHECK-DAG: [[ref_direct_ref]] = !DILocalVariable(name: "ref_direct_ref"
// CHECK-DAG: [[ref_1_direct_ref]] = !DILocalVariable(name: "ref_1_direct_ref"
// CHECK-DAG: [[ref_indirect_byval]] = !DILocalVariable(name: "ref_indirect_byval"
// CHECK-DAG: [[ref_1_indirect_byval]] = !DILocalVariable(name: "ref_1_indirect_byval"

// CHECK-DAG: [[ref_0_tuple_scalar_scalar]] = !DILocalVariable(name: "ref_0_tuple_scalar_scalar"
// CHECK-DAG: [[ref_0_tuple_ref_scalar]] = !DILocalVariable(name: "ref_0_tuple_ref_scalar"
// CHECK-DAG: [[ref_1_tuple_ref_scalar]] = !DILocalVariable(name: "ref_1_tuple_ref_scalar"
// CHECK-DAG: [[ref_0_tuple_arrayref_scalar]] = !DILocalVariable(name: "ref_0_tuple_arrayref_scalar"
// CHECK-DAG: [[ref_1_tuple_arrayref_scalar]] = !DILocalVariable(name: "ref_1_tuple_arrayref_scalar"
// CHECK-DAG: [[ref_0_1_tuple_arrayref_scalar]] = !DILocalVariable(name: "ref_0_1_tuple_arrayref_scalar"
// CHECK-DAG: [[ref_1_1_tuple_scalar_arrayref]] = !DILocalVariable(name: "ref_1_1_tuple_scalar_arrayref"
// CHECK-DAG: [[ref_1_sliceref]] = !DILocalVariable(name: "ref_1_sliceref"

// CHECK-DAG: [[ARG_dead_first_foo]] = !DILocalVariable(name: "dead_first_foo"
// CHECK-DAG: [[VAR_dead_first_v0]] = !DILocalVariable(name: "dead_first_v0"

// CHECK-DAG: [[VAR_fragment_f]] = !DILocalVariable(name: "fragment_f"

// CHECK-DAG: [[VAR_deref_dead]] = !DILocalVariable(name: "deref_dead"

// CHECK-DAG: [[VAR_index_from_var]] = !DILocalVariable(name: "index_from_var"
// CHECK-DAG: [[VAR_const_index_from_start]] = !DILocalVariable(name: "const_index_from_start"
// CHECK-DAG: [[VAR_const_index_from_end]] = !DILocalVariable(name: "const_index_from_end"