Rework tests

- cover more cases in integration
- do all size-limit testing in one test
- check calls and returns are attributed to the right scopes

Author: jsgf

tests/codegen-llvm/annotate-moves/annotate-moves-disabled.rs

@@ -1,4 +1,9 @@
 //@ compile-flags: -Z annotate-moves=8 -Copt-level=0 -g
+//
+// This test verifies that function call and return instructions use the correct debug scopes
+// when passing/returning large values. The actual move/copy operations may be annotated,
+// but the CALL and RETURN instructions themselves should reference the source location,
+// NOT have an inlinedAt scope pointing to compiler_move/compiler_copy.
 
 #![crate_type = "lib"]
 
@@ -7,27 +12,103 @@ pub struct LargeStruct {
     pub data: [u64; 20], // 160 bytes
 }
 
-// This test verifies that when passing arguments to functions, the actual CALL instruction
-// does not have the compiler_move debug scope, even though the argument itself might be
-// annotated with compiler_move in MIR.
-//
-// Note: On most ABIs, large structs are passed by pointer even when written as "by value",
-// so there may not be an actual memcpy operation to attach compiler_move to. This test
-// mainly verifies that IF debug info is emitted, the call itself uses the source location.
+#[derive(Clone, Copy)]
+pub struct MediumStruct {
+    pub data: [u64; 5], // 40 bytes
+}
+
+pub struct SmallStruct {
+    pub x: u32, // 4 bytes
+}
+
+// ============================================================================
+// Test 1: Single argument call
+// ============================================================================
+
+// CHECK-LABEL: call_arg_scope::test_call_with_single_arg
+pub fn test_call_with_single_arg(s: LargeStruct) {
+    // CHECK: call void @llvm.memcpy{{.*}}, !dbg ![[#CALL1_ARG_LOC:]]
+    // CHECK: call {{.*}}@{{.*}}helper_single{{.*}}({{.*}}), !dbg ![[#CALL1_LOC:]]
+    helper_single(s);
+}
+
+#[inline(never)]
+fn helper_single(_s: LargeStruct) {}
+
+// ============================================================================
+// Test 2: Multiple arguments of different types
+// ============================================================================
+
+// CHECK-LABEL: call_arg_scope::test_call_with_multiple_args
+pub fn test_call_with_multiple_args(large: LargeStruct, medium: MediumStruct, small: SmallStruct) {
+    // CHECK: call void @llvm.memcpy{{.*}}, !dbg ![[#CALL2_ARG1_LOC:]]
+    // CHECK: call void @llvm.memcpy{{.*}}, !dbg ![[#CALL2_ARG2_LOC:]]
+    // CHECK: call {{.*}}@{{.*}}helper_multiple{{.*}}({{.*}}), !dbg ![[#CALL2_LOC:]]
+    helper_multiple(large, medium, small);
+}
+
+#[inline(never)]
+fn helper_multiple(_l: LargeStruct, _m: MediumStruct, _s: SmallStruct) {}
+
+// ============================================================================
+// Test 3: Return value
+// ============================================================================
 
-// CHECK-LABEL: call_arg_scope::test_call_with_move
-pub fn test_call_with_move(s: LargeStruct) {
-    // The key test: the call instruction should reference the source line (line 22),
-    // NOT a compiler_move scope.
-    helper(s);
+// CHECK-LABEL: call_arg_scope::test_return_large_value
+pub fn test_return_large_value() -> LargeStruct {
+    let s = LargeStruct { data: [42; 20] };
+    // CHECK: ret {{.*}}, !dbg ![[#RET1_LOC:]]
+    s
 }
 
-// Find the call instruction and verify its debug location
-// CHECK: call {{.*}}@{{.*}}helper{{.*}}({{.*}}), !dbg ![[CALL_LOC:[0-9]+]]
+// ============================================================================
+// Test 4: Calling a function that returns a large value
+// ============================================================================
 
-// Verify that the call's debug location points to line 22 (the actual source line)
-// and NOT to a scope with inlinedAt referencing compiler_move
-// CHECK: ![[CALL_LOC]] = !DILocation(line: 22,
+// CHECK-LABEL: call_arg_scope::test_call_returning_large
+pub fn test_call_returning_large() {
+    // CHECK: call {{.*}}@{{.*}}make_large_struct{{.*}}({{.*}}), !dbg ![[#CALL3_LOC:]]
+    let _result = make_large_struct();
+}
 
 #[inline(never)]
-fn helper(_s: LargeStruct) {}
+fn make_large_struct() -> LargeStruct {
+    LargeStruct { data: [1; 20] }
+}
+
+// ============================================================================
+// Test 5: Mixed scenario - passing and returning large values
+// ============================================================================
+
+// CHECK-LABEL: call_arg_scope::test_mixed_call
+pub fn test_mixed_call(input: LargeStruct) -> LargeStruct {
+    // CHECK: call {{.*}}@{{.*}}transform_large{{.*}}({{.*}}), !dbg ![[#CALL4_LOC:]]
+    transform_large(input)
+}
+
+#[inline(never)]
+fn transform_large(mut s: LargeStruct) -> LargeStruct {
+    s.data[0] += 1;
+    s
+}
+
+// CHECK-DAG: ![[#CALL1_ARG_LOC]] = !DILocation({{.*}}scope: ![[#CALL1_ARG_SCOPE:]]
+// CHECK-DAG: ![[#CALL1_ARG_SCOPE]] = {{(distinct )?}}!DISubprogram(name: "compiler_copy<call_arg_scope::LargeStruct, 160>"
+// CHECK-DAG: ![[#CALL1_LOC]] = !DILocation({{.*}}scope: ![[#CALL1_SCOPE:]]
+// CHECK-DAG: ![[#CALL1_SCOPE]] = {{(distinct )?}}!DISubprogram(name: "test_call_with_single_arg"
+
+// CHECK-DAG: ![[#CALL2_ARG1_LOC]] = !DILocation({{.*}}scope: ![[#CALL2_ARG1_SCOPE:]]
+// CHECK-DAG: ![[#CALL2_ARG1_SCOPE]] = {{(distinct )?}}!DISubprogram(name: "compiler_copy<call_arg_scope::LargeStruct, 160>"
+// CHECK-DAG: ![[#CALL2_ARG2_LOC]] = !DILocation({{.*}}scope: ![[#CALL2_ARG2_SCOPE:]]
+// CHECK-DAG: ![[#CALL2_ARG2_SCOPE]] = {{(distinct )?}}!DISubprogram(name: "compiler_copy<call_arg_scope::MediumStruct, 40>"
+// CHECK-DAG: ![[#CALL2_LOC]] = !DILocation({{.*}}scope: ![[#CALL2_SCOPE:]]
+// CHECK-DAG: ![[#CALL2_SCOPE]] = {{(distinct )?}}!DISubprogram(name: "test_call_with_multiple_args"
+
+// CHECK-DAG: ![[#CALL3_LOC]] = !DILocation({{.*}}scope: ![[#CALL3_SCOPE:]]
+// CHECK-DAG: ![[#CALL3_SCOPE]] = {{(distinct )?}}!DISubprogram(name: "test_call_returning_large"
+
+// CHECK-DAG: ![[#CALL4_LOC]] = !DILocation({{.*}}scope: ![[#CALL4_SCOPE:]]
+// CHECK-DAG: ![[#CALL4_SCOPE]] = {{(distinct )?}}!DISubprogram(name: "test_mixed_call"
+
+// CHECK-DAG: ![[#RET1_LOC]] = !DILocation({{.*}}scope: ![[#RET1_SCOPE:]]
+// CHECK-DAG: ![[#RET1_SCOPE]] = {{(distinct )?}}!DISubprogram(name: "test_return_large_value"