| //@ 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-file-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 noundef %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" |