[Utils] Check for generated functions inline if possible

[jdoerfert]

Summary

With D83004 we allowed to check for generated functions. However, since
those might be generated in various places we did simply check for all
functions in the end. Furthermore, this prevented us from reusing check
prefixes across run lines. For every run line we checked for all functions
regardless if the functions were equal across prefixes.

To reduce the number of check lines we now allow to reuse them across
run lines. That is, we can have prefixes that span multiple run lines
even when we check for generated functions. This will only reduce the
run lines if we can find a total order of the generated functions
though. The check lines for generated functions are placed in-between
check lines of existing functions or at the end, as necessary.

The IR update script needs adjusts similar to the CC one.

[ggeorgakoudis]

clang/test/utils/update_cc_test_checks/Inputs/generated-funcs.c.generated.expected

232

The checks for the outlined function are missing?

clang/test/utils/update_cc_test_checks/Inputs/lots-of-generated-funcs.c.lots-of-generated.expected

9

Checks for .ompu_outlined. are missing

48

Checks for .omp_outlined..3 are missing

87

Checks for .omp_outlined..6 are missing

[jdoerfert]

Skip duplicates in the line2spell_and_mangled_list as that causes functions to be missed.

clang/test/utils/update_cc_test_checks/Inputs/generated-funcs.c.generated.expected

232

Good catch. It turns out functions that showed up in line2spell_and_mangled_list multiple times confused the script. I needed to skip duplicates. Fixed now.

clang/test/utils/update_cc_test_checks/Inputs/lots-of-generated-funcs.c.lots-of-generated.expected

9

same as above :)

[jdoerfert]

This doesn't work properly yet :(
When I run this on the OpenMP tests I get sometimes a total order where there should be none.

clang/test/utils/update_cc_test_checks/Inputs/generated-funcs-regex.c.expected

 // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --include-generated-funcs --replace-value-regex "__([a-z]+)_offloading_[a-z0-9]+_[a-z0-9]+_(.*)_l[0-9]+" "somevar_[a-z0-9]+_"
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fopenmp %s -emit-llvm -o - | FileCheck %s
 
 void __test_offloading_42_abcdef_bar_l123();
 void use(int);
 
-void foo(int a)
-{
-    #pragma omp target
-        use(a);
-
-    __test_offloading_42_abcdef_bar_l123();
-    int somevar_abc123_;
-}
 // CHECK-LABEL: @foo(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[A_ADDR:%.*]] = alloca i32, align 4
 // CHECK-NEXT:    [[A_CASTED:%.*]] = alloca i64, align 8
 // CHECK-NEXT:    %{{somevar_[a-z0-9]+_}} = alloca i32, align 4
 // CHECK-NEXT:    store i32 [[A:%.*]], i32* [[A_ADDR]], align 4
 // CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* [[A_ADDR]], align 4
 // CHECK-NEXT:    [[CONV:%.*]] = bitcast i64* [[A_CASTED]] to i32*
 // CHECK-NEXT:    store i32 [[TMP0]], i32* [[CONV]], align 4
 // CHECK-NEXT:    [[TMP1:%.*]] = load i64, i64* [[A_CASTED]], align 8
 // CHECK-NEXT:    call void @{{__omp_offloading_[a-z0-9]+_[a-z0-9]+_foo_l[0-9]+}}(i64 [[TMP1]]) #[[ATTR3:[0-9]+]]
 // CHECK-NEXT:    call void (...) @{{__test_offloading_[a-z0-9]+_[a-z0-9]+_bar_l[0-9]+}}()
 // CHECK-NEXT:    ret void
 //
-//
+void foo(int a)
+{
+    #pragma omp target
+        use(a);
+
+    __test_offloading_42_abcdef_bar_l123();
+    int somevar_abc123_;
+}
 // CHECK-LABEL: @{{__omp_offloading_[a-z0-9]+_[a-z0-9]+_foo_l[0-9]+}}(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[A_ADDR:%.*]] = alloca i64, align 8
 // CHECK-NEXT:    store i64 [[A:%.*]], i64* [[A_ADDR]], align 8
 // CHECK-NEXT:    [[CONV:%.*]] = bitcast i64* [[A_ADDR]] to i32*
 // CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* [[CONV]], align 8
 // CHECK-NEXT:    call void @use(i32 [[TMP0]])
 // CHECK-NEXT:    ret void
 //

clang/test/utils/update_cc_test_checks/Inputs/generated-funcs.c.generated.expected

 // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --include-generated-funcs
 // Check that the CHECK lines are generated for clang-generated functions
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fopenmp %s -emit-llvm -o - | FileCheck --check-prefix=OMP %s
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu %s -emit-llvm -o - | FileCheck --check-prefix=NOOMP %s
 
 const int size = 1024 * 1024 * 32;
 
 double A[size];
 
 void foo(void);
 
+// OMP-LABEL: @main(
+// OMP-NEXT:  entry:
+// OMP-NEXT:    [[RETVAL:%.*]] = alloca i32, align 4
+// OMP-NEXT:    [[I:%.*]] = alloca i32, align 4
+// OMP-NEXT:    store i32 0, i32* [[RETVAL]], align 4
+// OMP-NEXT:    store i32 0, i32* [[I]], align 4
+// OMP-NEXT:    call void (%struct.ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call(%struct.ident_t* @[[GLOB2:[0-9]+]], i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* @.omp_outlined. to void (i32*, i32*, ...)*))
+// OMP-NEXT:    call void @foo()
+// OMP-NEXT:    ret i32 0
+//
+// NOOMP-LABEL: @main(
+// NOOMP-NEXT:  entry:
+// NOOMP-NEXT:    [[RETVAL:%.*]] = alloca i32, align 4
+// NOOMP-NEXT:    [[I:%.*]] = alloca i32, align 4
+// NOOMP-NEXT:    store i32 0, i32* [[RETVAL]], align 4
+// NOOMP-NEXT:    store i32 0, i32* [[I]], align 4
+// NOOMP-NEXT:    store i32 0, i32* [[I]], align 4
+// NOOMP-NEXT:    br label [[FOR_COND:%.*]]
+// NOOMP:       for.cond:
+// NOOMP-NEXT:    [[TMP0:%.*]] = load i32, i32* [[I]], align 4
+// NOOMP-NEXT:    [[CMP:%.*]] = icmp slt i32 [[TMP0]], 33554432
+// NOOMP-NEXT:    br i1 [[CMP]], label [[FOR_BODY:%.*]], label [[FOR_END:%.*]]
+// NOOMP:       for.body:
+// NOOMP-NEXT:    [[TMP1:%.*]] = load i32, i32* [[I]], align 4
+// NOOMP-NEXT:    [[IDXPROM:%.*]] = sext i32 [[TMP1]] to i64
+// NOOMP-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [33554432 x double], [33554432 x double]* @A, i64 0, i64 [[IDXPROM]]
+// NOOMP-NEXT:    store double 0.000000e+00, double* [[ARRAYIDX]], align 8
+// NOOMP-NEXT:    br label [[FOR_INC:%.*]]
+// NOOMP:       for.inc:
+// NOOMP-NEXT:    [[TMP2:%.*]] = load i32, i32* [[I]], align 4
+// NOOMP-NEXT:    [[INC:%.*]] = add nsw i32 [[TMP2]], 1
+// NOOMP-NEXT:    store i32 [[INC]], i32* [[I]], align 4
+// NOOMP-NEXT:    br label [[FOR_COND]], !llvm.loop [[LOOP2:![0-9]+]]
+// NOOMP:       for.end:
+// NOOMP-NEXT:    call void @foo()
+// NOOMP-NEXT:    ret i32 0
+//
 int main() {
   int i = 0;
 
 #pragma omp parallel for
   for (i = 0; i < size; ++i) {
     A[i] = 0.0;
   }
 
   foo();
 
   return 0;
 }
 
-void foo(void) {
-  int i = 0;
-
-#pragma omp parallel for
-  for (i = 0; i < size; ++i) {
-    A[i] = 1.0;
-  }
-}
-// OMP-LABEL: @main(
-// OMP-NEXT:  entry:
-// OMP-NEXT:    [[RETVAL:%.*]] = alloca i32, align 4
-// OMP-NEXT:    [[I:%.*]] = alloca i32, align 4
-// OMP-NEXT:    store i32 0, i32* [[RETVAL]], align 4
-// OMP-NEXT:    store i32 0, i32* [[I]], align 4
-// OMP-NEXT:    call void (%struct.ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call(%struct.ident_t* @[[GLOB2:[0-9]+]], i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* @.omp_outlined. to void (i32*, i32*, ...)*))
-// OMP-NEXT:    call void @foo()
-// OMP-NEXT:    ret i32 0
-//
-//
 // OMP-LABEL: @.omp_outlined.(
 // OMP-NEXT:  entry:
 // OMP-NEXT:    [[DOTGLOBAL_TID__ADDR:%.*]] = alloca i32*, align 8
 // OMP-NEXT:    [[DOTBOUND_TID__ADDR:%.*]] = alloca i32*, align 8
 // OMP-NEXT:    [[DOTOMP_IV:%.*]] = alloca i32, align 4
 // OMP-NEXT:    [[TMP:%.*]] = alloca i32, align 4
 // OMP-NEXT:    [[DOTOMP_LB:%.*]] = alloca i32, align 4
 // OMP-NEXT:    [[DOTOMP_UB:%.*]] = alloca i32, align 4

 // OMP-NEXT:    store i32 [[ADD2]], i32* [[DOTOMP_IV]], align 4
 // OMP-NEXT:    br label [[OMP_INNER_FOR_COND]]
 // OMP:       omp.inner.for.end:
 // OMP-NEXT:    br label [[OMP_LOOP_EXIT:%.*]]
 // OMP:       omp.loop.exit:
 // OMP-NEXT:    call void @__kmpc_for_static_fini(%struct.ident_t* @[[GLOB1]], i32 [[TMP1]])
 // OMP-NEXT:    ret void
 //
-//
 // OMP-LABEL: @foo(
 // OMP-NEXT:  entry:
 // OMP-NEXT:    [[I:%.*]] = alloca i32, align 4
 // OMP-NEXT:    store i32 0, i32* [[I]], align 4
 // OMP-NEXT:    call void (%struct.ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call(%struct.ident_t* @[[GLOB2]], i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* @.omp_outlined..1 to void (i32*, i32*, ...)*))
 // OMP-NEXT:    ret void
 //
+// NOOMP-LABEL: @foo(
+// NOOMP-NEXT:  entry:
+// NOOMP-NEXT:    [[I:%.*]] = alloca i32, align 4
+// NOOMP-NEXT:    store i32 0, i32* [[I]], align 4
+// NOOMP-NEXT:    store i32 0, i32* [[I]], align 4
+// NOOMP-NEXT:    br label [[FOR_COND:%.*]]
+// NOOMP:       for.cond:
+// NOOMP-NEXT:    [[TMP0:%.*]] = load i32, i32* [[I]], align 4
+// NOOMP-NEXT:    [[CMP:%.*]] = icmp slt i32 [[TMP0]], 33554432
+// NOOMP-NEXT:    br i1 [[CMP]], label [[FOR_BODY:%.*]], label [[FOR_END:%.*]]
+// NOOMP:       for.body:
+// NOOMP-NEXT:    [[TMP1:%.*]] = load i32, i32* [[I]], align 4
+// NOOMP-NEXT:    [[IDXPROM:%.*]] = sext i32 [[TMP1]] to i64
+// NOOMP-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [33554432 x double], [33554432 x double]* @A, i64 0, i64 [[IDXPROM]]
+// NOOMP-NEXT:    store double 1.000000e+00, double* [[ARRAYIDX]], align 8
+// NOOMP-NEXT:    br label [[FOR_INC:%.*]]
+// NOOMP:       for.inc:
+// NOOMP-NEXT:    [[TMP2:%.*]] = load i32, i32* [[I]], align 4
+// NOOMP-NEXT:    [[INC:%.*]] = add nsw i32 [[TMP2]], 1
+// NOOMP-NEXT:    store i32 [[INC]], i32* [[I]], align 4
+// NOOMP-NEXT:    br label [[FOR_COND]], !llvm.loop [[LOOP4:![0-9]+]]
+// NOOMP:       for.end:
+// NOOMP-NEXT:    ret void
 //
+void foo(void) {
+  int i = 0;
+
+#pragma omp parallel for
+  for (i = 0; i < size; ++i) {
+    A[i] = 1.0;
+  }
+}
 // OMP-LABEL: @.omp_outlined..1(
 // OMP-NEXT:  entry:
 // OMP-NEXT:    [[DOTGLOBAL_TID__ADDR:%.*]] = alloca i32*, align 8
 // OMP-NEXT:    [[DOTBOUND_TID__ADDR:%.*]] = alloca i32*, align 8
 // OMP-NEXT:    [[DOTOMP_IV:%.*]] = alloca i32, align 4
 // OMP-NEXT:    [[TMP:%.*]] = alloca i32, align 4
 // OMP-NEXT:    [[DOTOMP_LB:%.*]] = alloca i32, align 4
 // OMP-NEXT:    [[DOTOMP_UB:%.*]] = alloca i32, align 4

 // OMP-NEXT:    [[ADD2:%.*]] = add nsw i32 [[TMP9]], 1
 // OMP-NEXT:    store i32 [[ADD2]], i32* [[DOTOMP_IV]], align 4
 // OMP-NEXT:    br label [[OMP_INNER_FOR_COND]]
 // OMP:       omp.inner.for.end:
 // OMP-NEXT:    br label [[OMP_LOOP_EXIT:%.*]]
 // OMP:       omp.loop.exit:
 // OMP-NEXT:    call void @__kmpc_for_static_fini(%struct.ident_t* @[[GLOB1]], i32 [[TMP1]])
 // OMP-NEXT:    ret void
 //
-//
-// NOOMP-LABEL: @main(
-// NOOMP-NEXT:  entry:
-// NOOMP-NEXT:    [[RETVAL:%.*]] = alloca i32, align 4
-// NOOMP-NEXT:    [[I:%.*]] = alloca i32, align 4
-// NOOMP-NEXT:    store i32 0, i32* [[RETVAL]], align 4
-// NOOMP-NEXT:    store i32 0, i32* [[I]], align 4
-// NOOMP-NEXT:    store i32 0, i32* [[I]], align 4
-// NOOMP-NEXT:    br label [[FOR_COND:%.*]]
-// NOOMP:       for.cond:
-// NOOMP-NEXT:    [[TMP0:%.*]] = load i32, i32* [[I]], align 4
-// NOOMP-NEXT:    [[CMP:%.*]] = icmp slt i32 [[TMP0]], 33554432
-// NOOMP-NEXT:    br i1 [[CMP]], label [[FOR_BODY:%.*]], label [[FOR_END:%.*]]
-// NOOMP:       for.body:
-// NOOMP-NEXT:    [[TMP1:%.*]] = load i32, i32* [[I]], align 4
-// NOOMP-NEXT:    [[IDXPROM:%.*]] = sext i32 [[TMP1]] to i64
-// NOOMP-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [33554432 x double], [33554432 x double]* @A, i64 0, i64 [[IDXPROM]]
-// NOOMP-NEXT:    store double 0.000000e+00, double* [[ARRAYIDX]], align 8
-// NOOMP-NEXT:    br label [[FOR_INC:%.*]]
-// NOOMP:       for.inc:
-// NOOMP-NEXT:    [[TMP2:%.*]] = load i32, i32* [[I]], align 4
-// NOOMP-NEXT:    [[INC:%.*]] = add nsw i32 [[TMP2]], 1
-// NOOMP-NEXT:    store i32 [[INC]], i32* [[I]], align 4
-// NOOMP-NEXT:    br label [[FOR_COND]], !llvm.loop [[LOOP2:![0-9]+]]
-// NOOMP:       for.end:
-// NOOMP-NEXT:    call void @foo()
-// NOOMP-NEXT:    ret i32 0
-//
-//
-// NOOMP-LABEL: @foo(
-// NOOMP-NEXT:  entry:
-// NOOMP-NEXT:    [[I:%.*]] = alloca i32, align 4
-// NOOMP-NEXT:    store i32 0, i32* [[I]], align 4
-// NOOMP-NEXT:    store i32 0, i32* [[I]], align 4
-// NOOMP-NEXT:    br label [[FOR_COND:%.*]]
-// NOOMP:       for.cond:
-// NOOMP-NEXT:    [[TMP0:%.*]] = load i32, i32* [[I]], align 4
-// NOOMP-NEXT:    [[CMP:%.*]] = icmp slt i32 [[TMP0]], 33554432
-// NOOMP-NEXT:    br i1 [[CMP]], label [[FOR_BODY:%.*]], label [[FOR_END:%.*]]
-// NOOMP:       for.body:
-// NOOMP-NEXT:    [[TMP1:%.*]] = load i32, i32* [[I]], align 4
-// NOOMP-NEXT:    [[IDXPROM:%.*]] = sext i32 [[TMP1]] to i64
-// NOOMP-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [33554432 x double], [33554432 x double]* @A, i64 0, i64 [[IDXPROM]]
-// NOOMP-NEXT:    store double 1.000000e+00, double* [[ARRAYIDX]], align 8
-// NOOMP-NEXT:    br label [[FOR_INC:%.*]]
-// NOOMP:       for.inc:
-// NOOMP-NEXT:    [[TMP2:%.*]] = load i32, i32* [[I]], align 4
-// NOOMP-NEXT:    [[INC:%.*]] = add nsw i32 [[TMP2]], 1
-// NOOMP-NEXT:    store i32 [[INC]], i32* [[I]], align 4
-// NOOMP-NEXT:    br label [[FOR_COND]], !llvm.loop [[LOOP4:![0-9]+]]
-// NOOMP:       for.end:
-// NOOMP-NEXT:    ret void
-//

clang/test/utils/update_cc_test_checks/Inputs/lots-of-generated-funcs.c

+// Check that the CHECK lines are generated for clang-generated functions
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fopenmp %s -emit-llvm -o - | FileCheck --check-prefix=OMP %s
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu %s -emit-llvm -o - | FileCheck --check-prefix=NOOMP %s
+
+void t0() {
+  #pragma omp parallel
+  {
+  }
+  #pragma omp parallel
+  {
+  }
+  #pragma omp parallel
+  {
+  }
+}
+
+void t1() {
+  #pragma omp parallel
+  {
+  }
+  #pragma omp parallel
+  {
+  }
+  #pragma omp parallel
+  {
+  }
+}
+
+void t2() {
+  #pragma omp parallel
+  {
+  }
+  #pragma omp parallel
+  {
+  }
+  #pragma omp parallel
+  {
+  }
+}

clang/test/utils/update_cc_test_checks/Inputs/lots-of-generated-funcs.c.lots-of-generated.expected

+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --include-generated-funcs
+// Check that the CHECK lines are generated for clang-generated functions
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fopenmp %s -emit-llvm -o - | FileCheck --check-prefix=OMP %s
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu %s -emit-llvm -o - | FileCheck --check-prefix=NOOMP %s
+
+// OMP-LABEL: @t0(
+// OMP-NEXT:  entry:
+// OMP-NEXT:    call void (%struct.ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call(%struct.ident_t* @[[GLOB1:[0-9]+]], i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* @.omp_outlined. to void (i32*, i32*, ...)*))
+// OMP-NEXT:    call void (%struct.ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call(%struct.ident_t* @[[GLOB1]], i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* @.omp_outlined..1 to void (i32*, i32*, ...)*))
+// OMP-NEXT:    call void (%struct.ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call(%struct.ident_t* @[[GLOB1]], i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* @.omp_outlined..2 to void (i32*, i32*, ...)*))
+// OMP-NEXT:    ret void
+//
+// NOOMP-LABEL: @t0(
+// NOOMP-NEXT:  entry:
+// NOOMP-NEXT:    ret void
+//
+void t0() {
+  #pragma omp parallel
+  {
+  }
+  #pragma omp parallel
+  {
+  }
+  #pragma omp parallel
+  {
+  }
+}
+
+// OMP-LABEL: @.omp_outlined.(
+// OMP-NEXT:  entry:
+// OMP-NEXT:    [[DOTGLOBAL_TID__ADDR:%.*]] = alloca i32*, align 8
+// OMP-NEXT:    [[DOTBOUND_TID__ADDR:%.*]] = alloca i32*, align 8
+// OMP-NEXT:    store i32* [[DOTGLOBAL_TID_:%.*]], i32** [[DOTGLOBAL_TID__ADDR]], align 8
+// OMP-NEXT:    store i32* [[DOTBOUND_TID_:%.*]], i32** [[DOTBOUND_TID__ADDR]], align 8
+// OMP-NEXT:    ret void
+//
+// OMP-LABEL: @.omp_outlined..1(
+// OMP-NEXT:  entry:
+// OMP-NEXT:    [[DOTGLOBAL_TID__ADDR:%.*]] = alloca i32*, align 8
+// OMP-NEXT:    [[DOTBOUND_TID__ADDR:%.*]] = alloca i32*, align 8
+// OMP-NEXT:    store i32* [[DOTGLOBAL_TID_:%.*]], i32** [[DOTGLOBAL_TID__ADDR]], align 8
+// OMP-NEXT:    store i32* [[DOTBOUND_TID_:%.*]], i32** [[DOTBOUND_TID__ADDR]], align 8
+// OMP-NEXT:    ret void
+//
+// OMP-LABEL: @.omp_outlined..2(
+// OMP-NEXT:  entry:
+// OMP-NEXT:    [[DOTGLOBAL_TID__ADDR:%.*]] = alloca i32*, align 8
+// OMP-NEXT:    [[DOTBOUND_TID__ADDR:%.*]] = alloca i32*, align 8
+// OMP-NEXT:    store i32* [[DOTGLOBAL_TID_:%.*]], i32** [[DOTGLOBAL_TID__ADDR]], align 8
+// OMP-NEXT:    store i32* [[DOTBOUND_TID_:%.*]], i32** [[DOTBOUND_TID__ADDR]], align 8
+// OMP-NEXT:    ret void
+//
+// OMP-LABEL: @t1(
+// OMP-NEXT:  entry:
+// OMP-NEXT:    call void (%struct.ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call(%struct.ident_t* @[[GLOB1]], i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* @.omp_outlined..3 to void (i32*, i32*, ...)*))
+// OMP-NEXT:    call void (%struct.ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call(%struct.ident_t* @[[GLOB1]], i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* @.omp_outlined..4 to void (i32*, i32*, ...)*))
+// OMP-NEXT:    call void (%struct.ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call(%struct.ident_t* @[[GLOB1]], i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* @.omp_outlined..5 to void (i32*, i32*, ...)*))
+// OMP-NEXT:    ret void
+//
+// NOOMP-LABEL: @t1(
+// NOOMP-NEXT:  entry:
+// NOOMP-NEXT:    ret void
+//
+void t1() {
+  #pragma omp parallel
+  {
+  }
+  #pragma omp parallel
+  {
+  }
+  #pragma omp parallel
+  {
+  }
+}
+
+// OMP-LABEL: @.omp_outlined..3(
+// OMP-NEXT:  entry:
+// OMP-NEXT:    [[DOTGLOBAL_TID__ADDR:%.*]] = alloca i32*, align 8
+// OMP-NEXT:    [[DOTBOUND_TID__ADDR:%.*]] = alloca i32*, align 8
+// OMP-NEXT:    store i32* [[DOTGLOBAL_TID_:%.*]], i32** [[DOTGLOBAL_TID__ADDR]], align 8
+// OMP-NEXT:    store i32* [[DOTBOUND_TID_:%.*]], i32** [[DOTBOUND_TID__ADDR]], align 8
+// OMP-NEXT:    ret void
+//
+// OMP-LABEL: @.omp_outlined..4(
+// OMP-NEXT:  entry:
+// OMP-NEXT:    [[DOTGLOBAL_TID__ADDR:%.*]] = alloca i32*, align 8
+// OMP-NEXT:    [[DOTBOUND_TID__ADDR:%.*]] = alloca i32*, align 8
+// OMP-NEXT:    store i32* [[DOTGLOBAL_TID_:%.*]], i32** [[DOTGLOBAL_TID__ADDR]], align 8
+// OMP-NEXT:    store i32* [[DOTBOUND_TID_:%.*]], i32** [[DOTBOUND_TID__ADDR]], align 8
+// OMP-NEXT:    ret void
+//
+// OMP-LABEL: @.omp_outlined..5(
+// OMP-NEXT:  entry:
+// OMP-NEXT:    [[DOTGLOBAL_TID__ADDR:%.*]] = alloca i32*, align 8
+// OMP-NEXT:    [[DOTBOUND_TID__ADDR:%.*]] = alloca i32*, align 8
+// OMP-NEXT:    store i32* [[DOTGLOBAL_TID_:%.*]], i32** [[DOTGLOBAL_TID__ADDR]], align 8
+// OMP-NEXT:    store i32* [[DOTBOUND_TID_:%.*]], i32** [[DOTBOUND_TID__ADDR]], align 8
+// OMP-NEXT:    ret void
+//
+// OMP-LABEL: @t2(
+// OMP-NEXT:  entry:
+// OMP-NEXT:    call void (%struct.ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call(%struct.ident_t* @[[GLOB1]], i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* @.omp_outlined..6 to void (i32*, i32*, ...)*))
+// OMP-NEXT:    call void (%struct.ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call(%struct.ident_t* @[[GLOB1]], i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* @.omp_outlined..7 to void (i32*, i32*, ...)*))
+// OMP-NEXT:    call void (%struct.ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call(%struct.ident_t* @[[GLOB1]], i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* @.omp_outlined..8 to void (i32*, i32*, ...)*))
+// OMP-NEXT:    ret void
+//
+// NOOMP-LABEL: @t2(
+// NOOMP-NEXT:  entry:
+// NOOMP-NEXT:    ret void
+//
+void t2() {
+  #pragma omp parallel
+  {
+  }
+  #pragma omp parallel
+  {
+  }
+  #pragma omp parallel
+  {
+  }
+}
+// OMP-LABEL: @.omp_outlined..6(
+// OMP-NEXT:  entry:
+// OMP-NEXT:    [[DOTGLOBAL_TID__ADDR:%.*]] = alloca i32*, align 8
+// OMP-NEXT:    [[DOTBOUND_TID__ADDR:%.*]] = alloca i32*, align 8
+// OMP-NEXT:    store i32* [[DOTGLOBAL_TID_:%.*]], i32** [[DOTGLOBAL_TID__ADDR]], align 8
+// OMP-NEXT:    store i32* [[DOTBOUND_TID_:%.*]], i32** [[DOTBOUND_TID__ADDR]], align 8
+// OMP-NEXT:    ret void
+//
+// OMP-LABEL: @.omp_outlined..7(
+// OMP-NEXT:  entry:
+// OMP-NEXT:    [[DOTGLOBAL_TID__ADDR:%.*]] = alloca i32*, align 8
+// OMP-NEXT:    [[DOTBOUND_TID__ADDR:%.*]] = alloca i32*, align 8
+// OMP-NEXT:    store i32* [[DOTGLOBAL_TID_:%.*]], i32** [[DOTGLOBAL_TID__ADDR]], align 8
+// OMP-NEXT:    store i32* [[DOTBOUND_TID_:%.*]], i32** [[DOTBOUND_TID__ADDR]], align 8
+// OMP-NEXT:    ret void
+//
+// OMP-LABEL: @.omp_outlined..8(
+// OMP-NEXT:  entry:
+// OMP-NEXT:    [[DOTGLOBAL_TID__ADDR:%.*]] = alloca i32*, align 8
+// OMP-NEXT:    [[DOTBOUND_TID__ADDR:%.*]] = alloca i32*, align 8
+// OMP-NEXT:    store i32* [[DOTGLOBAL_TID_:%.*]], i32** [[DOTGLOBAL_TID__ADDR]], align 8
+// OMP-NEXT:    store i32* [[DOTBOUND_TID_:%.*]], i32** [[DOTBOUND_TID__ADDR]], align 8
+// OMP-NEXT:    ret void
+//

clang/test/utils/update_cc_test_checks/Inputs/lots-of-generated-funcs.c.no-lots-of-generated.expected

+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
+// Check that the CHECK lines are generated for clang-generated functions
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fopenmp %s -emit-llvm -o - | FileCheck --check-prefix=OMP %s
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu %s -emit-llvm -o - | FileCheck --check-prefix=NOOMP %s
+
+// OMP-LABEL: @t0(
+// OMP-NEXT:  entry:
+// OMP-NEXT:    call void (%struct.ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call(%struct.ident_t* @[[GLOB1:[0-9]+]], i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* @.omp_outlined. to void (i32*, i32*, ...)*))
+// OMP-NEXT:    call void (%struct.ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call(%struct.ident_t* @[[GLOB1]], i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* @.omp_outlined..1 to void (i32*, i32*, ...)*))
+// OMP-NEXT:    call void (%struct.ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call(%struct.ident_t* @[[GLOB1]], i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* @.omp_outlined..2 to void (i32*, i32*, ...)*))
+// OMP-NEXT:    ret void
+//
+// NOOMP-LABEL: @t0(
+// NOOMP-NEXT:  entry:
+// NOOMP-NEXT:    ret void
+//
+void t0() {
+  #pragma omp parallel
+  {
+  }
+  #pragma omp parallel
+  {
+  }
+  #pragma omp parallel
+  {
+  }
+}
+
+// OMP-LABEL: @t1(
+// OMP-NEXT:  entry:
+// OMP-NEXT:    call void (%struct.ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call(%struct.ident_t* @[[GLOB1]], i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* @.omp_outlined..3 to void (i32*, i32*, ...)*))
+// OMP-NEXT:    call void (%struct.ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call(%struct.ident_t* @[[GLOB1]], i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* @.omp_outlined..4 to void (i32*, i32*, ...)*))
+// OMP-NEXT:    call void (%struct.ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call(%struct.ident_t* @[[GLOB1]], i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* @.omp_outlined..5 to void (i32*, i32*, ...)*))
+// OMP-NEXT:    ret void
+//
+// NOOMP-LABEL: @t1(
+// NOOMP-NEXT:  entry:
+// NOOMP-NEXT:    ret void
+//
+void t1() {
+  #pragma omp parallel
+  {
+  }
+  #pragma omp parallel
+  {
+  }
+  #pragma omp parallel
+  {
+  }
+}
+
+// OMP-LABEL: @t2(
+// OMP-NEXT:  entry:
+// OMP-NEXT:    call void (%struct.ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call(%struct.ident_t* @[[GLOB1]], i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* @.omp_outlined..6 to void (i32*, i32*, ...)*))
+// OMP-NEXT:    call void (%struct.ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call(%struct.ident_t* @[[GLOB1]], i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* @.omp_outlined..7 to void (i32*, i32*, ...)*))
+// OMP-NEXT:    call void (%struct.ident_t*, i32, void (i32*, i32*, ...)*, ...) @__kmpc_fork_call(%struct.ident_t* @[[GLOB1]], i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* @.omp_outlined..8 to void (i32*, i32*, ...)*))
+// OMP-NEXT:    ret void
+//
+// NOOMP-LABEL: @t2(
+// NOOMP-NEXT:  entry:
+// NOOMP-NEXT:    ret void
+//
+void t2() {
+  #pragma omp parallel
+  {
+  }
+  #pragma omp parallel
+  {
+  }
+  #pragma omp parallel
+  {
+  }
+}

clang/test/utils/update_cc_test_checks/lots-of-generated-funcs.test

+## Test that CHECK lines are generated for clang-generated functions
+
+# RUN: cp %S/Inputs/lots-of-generated-funcs.c %t-lots-of-generated.c && %update_cc_test_checks --include-generated-funcs %t-lots-of-generated.c
+# RUN: diff -u %S/Inputs/lots-of-generated-funcs.c.lots-of-generated.expected %t-lots-of-generated.c
+# RUN: cp %S/Inputs/lots-of-generated-funcs.c %t-no-lots-of-generated.c && %update_cc_test_checks %t-no-lots-of-generated.c
+# RUN: diff -u %S/Inputs/lots-of-generated-funcs.c.no-lots-of-generated.expected %t-no-lots-of-generated.c
+
+## Check that re-running update_cc_test_checks doesn't change the output
+# RUN: %update_cc_test_checks --include-generated-funcs %t-lots-of-generated.c
+# RUN: diff -u %S/Inputs/lots-of-generated-funcs.c.lots-of-generated.expected %t-lots-of-generated.c
+# RUN: %update_cc_test_checks %t-no-lots-of-generated.c
+# RUN: diff -u %S/Inputs/lots-of-generated-funcs.c.no-lots-of-generated.expected %t-no-lots-of-generated.c

llvm/utils/UpdateTestChecks/common.py

def is_same_except_arg_names(self, extrascrub, args_and_sig, attrs):
     es1 = IR_VALUE_RE.sub(repl_arg_names, extrascrub)
     es0 = SCRUB_IR_COMMENT_RE.sub(r'', es0)
     es1 = SCRUB_IR_COMMENT_RE.sub(r'', es1)
     return es0 == es1
 
   def __str__(self):
     return self.scrub
 
+# Try to put all functions into a total order, this might not work if two run
+# lines generated the functions in a different order.
+def get_total_function_order(prefix_list, func_order):
+  total_order = []
+  for prefix_item in prefix_list:
+    prefixes = prefix_item[0]
+    for prefix in prefixes:
+        for func in func_order[prefix]:
+            total_idx = 0
+            if func in total_order:
+                idx = total_order.index(func)
+                if idx < total_idx:
+                    return None
+                total_idx = idx + 1
+            else:
+                total_order.append(func)
+  return total_order
+
 class FunctionTestBuilder:
   def __init__(self, run_list, flags, scrubber_args):
     self._verbose = flags.verbose
     self._record_args = flags.function_signature
     self._check_attributes = flags.check_attributes
     self._scrubber_args = scrubber_args
     # Strip double-quotes if input was read by UTC_ARGS
     self._replace_value_regex = list(map(lambda x: x.strip('"'), flags.replace_value_regex))
for m in function_re.finditer(raw_tool_output):
           warn('Unsupported analysis mode: %r!' % (analysis,))
       if func.startswith('stress'):
         # We only use the last line of the function body for stress tests.
         scrubbed_body = '\n'.join(scrubbed_body.splitlines()[-1:])
       if self._verbose:
         print('Processing function: ' + func, file=sys.stderr)
         for l in scrubbed_body.splitlines():
           print('  ' + l, file=sys.stderr)
-      for prefix in prefixes:
-        if func in self._func_dict[prefix]:
-          if (self._func_dict[prefix][func] is None or
-              str(self._func_dict[prefix][func]) != scrubbed_body or
-              self._func_dict[prefix][func].args_and_sig != args_and_sig or
-                  self._func_dict[prefix][func].attrs != attrs):
-            if (self._func_dict[prefix][func] is not None and
-                self._func_dict[prefix][func].is_same_except_arg_names(
-                scrubbed_extra,
-                args_and_sig,
-                attrs)):
-              self._func_dict[prefix][func].scrub = scrubbed_extra
-              self._func_dict[prefix][func].args_and_sig = args_and_sig
-              continue
-            else:
-              # This means a previous RUN line produced a body for this function
-              # that is different from the one produced by this current RUN line,
-              # so the body can't be common accross RUN lines. We use None to
-              # indicate that.
-              self._func_dict[prefix][func] = None
-              continue
 
+      for prefix in prefixes:
         # Replace function names matching the regex.
         for regex in self._replace_value_regex:
           # Pattern that matches capture groups in the regex in leftmost order.
           group_regex = re.compile('\(.*?\)')
           # Replace function name with regex.
           match = re.match(regex, func)
           if match:
             func_repl = regex
             # Replace any capture groups with their matched strings.
             for g in match.groups():
               func_repl = group_regex.sub(re.escape(g), func_repl, count=1)
             func = re.sub(func_repl, '{{' + func_repl + '}}', func)
 
           # Replace all calls to regex matching functions.
           matches = re.finditer(regex, scrubbed_body)
           for match in matches:
             func_repl = regex
             # Replace any capture groups with their matched strings.
             for g in match.groups():
                 func_repl = group_regex.sub(re.escape(g), func_repl, count=1)
             # Substitute function call names that match the regex with the same
             # capture groups set.
             scrubbed_body = re.sub(func_repl, '{{' + func_repl + '}}', scrubbed_body)
 
+        if func in self._func_dict[prefix]:
+          if (self._func_dict[prefix][func] is None or
+              str(self._func_dict[prefix][func]) != scrubbed_body or
+              self._func_dict[prefix][func].args_and_sig != args_and_sig or
+                  self._func_dict[prefix][func].attrs != attrs):
+            if (self._func_dict[prefix][func] is not None and
+                self._func_dict[prefix][func].is_same_except_arg_names(
+                scrubbed_extra,
+                args_and_sig,
+                attrs)):
+              self._func_dict[prefix][func].scrub = scrubbed_extra
+              self._func_dict[prefix][func].args_and_sig = args_and_sig
+              continue
+            else:
+              # This means a previous RUN line produced a body for this function
+              # that is different from the one produced by this current RUN line,
+              # so the body can't be common across RUN lines. We use None to
+              # indicate that.
+              self._func_dict[prefix][func] = None
+              continue
+
         self._func_dict[prefix][func] = function_body(
             scrubbed_body, scrubbed_extra, args_and_sig, attrs)
         self._func_order[prefix].append(func)
 
   def _get_failed_prefixes(self):
     # This returns the list of those prefixes that failed to match any function,
     # because there were conflicting bodies produced by different RUN lines, in
     # all instances of the prefix. Effectively, this prefix is unused and should

llvm/utils/update_cc_test_checks.py

for ti in common.itertests(initial_args.tests, parser, 'utils/' + script_name,
     global_vars_seen_dict = {}
     prefix_set = set([prefix for p in filecheck_run_list for prefix in p[0]])
     output_lines = []
 
     include_generated_funcs = common.find_arg_in_test(ti,
                                                       lambda args: ti.args.include_generated_funcs,
                                                       '--include-generated-funcs',
                                                       True)
+    total_function_order = common.get_total_function_order(filecheck_run_list, builder.func_order())
 
-    if include_generated_funcs:
+    if include_generated_funcs and not total_function_order:
       # Generate the appropriate checks for each function.  We need to emit
       # these in the order according to the generated output so that CHECK-LABEL
       # works properly.  func_order provides that.
 
       # It turns out that when clang generates functions (for example, with
       # -fopenmp), it can sometimes cause functions to be re-ordered in the
       # output, even functions that exist in the source file.  Therefore we
       # can't insert check lines before each source function and instead have to
if include_generated_funcs and not total_function_order:
                              prefixes,
                              func_dict, func)
 
       common.add_checks_at_end(output_lines, filecheck_run_list, builder.func_order(),
                                '//', lambda my_output_lines, prefixes, func:
                                check_generator(my_output_lines,
                                                prefixes, func))
     else:
-      # Normal mode.  Put checks before each source function.
-      for line_info in ti.iterlines(output_lines):
-        idx = line_info.line_number
-        line = line_info.line
-        args = line_info.args
-        include_line = True
-        m = common.CHECK_RE.match(line)
-        if m and m.group(1) in prefix_set:
-          continue  # Don't append the existing CHECK lines
-        if idx in line2spell_and_mangled_list:
-          added = set()
-          for spell, mangled in line2spell_and_mangled_list[idx]:
-            # One line may contain multiple function declarations.
-            # Skip if the mangled name has been added before.
-            # The line number may come from an included file,
-            # we simply require the spelling name to appear on the line
-            # to exclude functions from other files.
-            if mangled in added or spell not in line:
-              continue
-            if args.functions is None or any(re.search(regex, spell) for regex in args.functions):
-              last_line = output_lines[-1].strip()
-              while last_line == '//':
-                # Remove the comment line since we will generate a new  comment
-                # line as part of common.add_ir_checks()
-                output_lines.pop()
-                last_line = output_lines[-1].strip()
-              if added:
-                output_lines.append('//')
-              added.add(mangled)
-              common.add_ir_checks(output_lines, '//', filecheck_run_list, func_dict, mangled,
-                                   False, args.function_signature, global_vars_seen_dict)
-              if line.rstrip('\n') == '//':
-                include_line = False
+      trailing_functions = []
+      # If we might have generated functions we need to place them in the right position now,
+      # trailing ones are kept separate though.
+      if include_generated_funcs:
+        seen_mangled = set()
+        total_order_idx = 0
+        for line in line2spell_and_mangled_list.keys():
+          to_be_added = []
+          for spell, mangled in line2spell_and_mangled_list[line]:
+            if mangled not in total_function_order or mangled in seen_mangled:
+              continue
+            seen_mangled.add(mangled)
+
+            # Figure out where this existing function is in the total order. All functions we
+            # skipped are inserted before this one.
+            index = total_function_order.index(mangled)
+            while total_order_idx < index:
+              to_be_added.append(total_function_order[total_order_idx])
+              total_order_idx += 1
+            # Account for the function itself (spell, mangled)
+            total_order_idx += 1
+          # Reverse the order to match total order again before we insert the functions
+          # in the current line.
+          to_be_added.reverse()
+          for tba in to_be_added:
+            line2spell_and_mangled_list[line].insert(0, ('', tba))
+
+        # All functions we have not handled yet are added to the end.
+        while total_order_idx < len(total_function_order):
+          func = total_function_order[total_order_idx]
+          trailing_functions.append(func)
+          total_order_idx += 1
+
+      def handle_functions_on_line(output_lines, line, args, spell, mangled, added, include_line):
+        if mangled in added or (spell and spell not in line):
+          return
 
+      # Normal mode.  Put checks before each source function.
+      for line_info in ti.iterlines(output_lines):
+        idx = line_info.line_number
+        line = line_info.line
+        args = line_info.args
+        include_line = True
+        m = common.CHECK_RE.match(line)
+        if m and m.group(1) in prefix_set:
+          continue  # Don't append the existing CHECK lines
+        if idx in line2spell_and_mangled_list:
+          added = set()
+          for spell, mangled in line2spell_and_mangled_list[idx]:
+            handle_functions_on_line(output_lines, line, args, spell, mangled, added, include_line)
+
         if include_line:
           output_lines.append(line.rstrip('\n'))
 
+      # After we inserted check lines in the original program we append all check lines for functions
+      # that were generated after the existing ones.
+      added = set()
+      for func in trailing_functions:
+          handle_functions_on_line(output_lines, func, args, func, func, added, include_line)
+
     common.debug('Writing %d lines to %s...' % (len(output_lines), ti.path))
     with open(ti.path, 'wb') as f:
       f.writelines(['{}\n'.format(l).encode('utf-8') for l in output_lines])
 
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main())

llvm/utils/update_test_checks.py

for ti in common.itertests(initial_args.tests, parser,
     common.debug('Rewriting FileCheck prefixes:', str(prefix_set))
     output_lines = []
 
     include_generated_funcs = common.find_arg_in_test(ti,
                                                       lambda args: ti.args.include_generated_funcs,
                                                       '--include-generated-funcs',
                                                       True)
 
+    # TODO: use common.get_total_function_order to avoid adding new functions at the end but
+    #       instead place them in order between existing ones. See the CC script.
+
     if include_generated_funcs:
       # Generate the appropriate checks for each function.  We need to emit
       # these in the order according to the generated output so that CHECK-LABEL
       # works properly.  func_order provides that.
 
       # We can't predict where various passes might insert functions so we can't
       # be sure the input function order is maintained.  Therefore, first spit
       # out all the source lines.