[UpdateCCTestChecks] Include generated functions if asked

[greened]

Summary

Add the --include-generated-funcs option to update_cc_test_checks.py so that any
functions created by the compiler that don't exist in the source will also be
checked.

We need to maintain the output order of generated function checks so that
CHECK-LABEL works properly. To do so, maintain a list of functions output for
each prefix in the order they are output. Use this list to output checks for
generated functions in the proper order.

[greened]

Do we have any tests for these tools? I vaguely recall some discussion about tests but I couldn't find any. I'd like to add tests for this feature if the infrastructure is already there.

[MaskRay]

In D83004#2126719, @greened wrote:

Do we have any tests for these tools? I vaguely recall some discussion about tests but I couldn't find any. I'd like to add tests for this feature if the infrastructure is already there.

Yes. See clang/test/utils/update_cc_test_checks/ (thanks to @arichardson)

[greened]

In D83004#2126792, @MaskRay wrote:

In D83004#2126719, @greened wrote:

Do we have any tests for these tools? I vaguely recall some discussion about tests but I couldn't find any. I'd like to add tests for this feature if the infrastructure is already there.

Yes. See clang/test/utils/update_cc_test_checks/ (thanks to @arichardson)

Ah, didn't think to look under clang since the tool lives under llvm. Thanks!

[jdoerfert]

This is great! Just a few days ago I added a TODO in one of the tests I created asking for this: D82722 :)

Will this work for all test scripts?

Will this make the prefix_exclusions logic obsolete?

llvm/utils/update_cc_test_checks.py

133

I think this should go into common.py (after D78618). I would also make this the default but OK.

[greened]

Fixed various bugs, added tests.

This now has two modes because generated function output can't be ordered with respect to source file functions. When clang generates functions it can sometimes output original source functions in a different (non-source) order so checks can't be placed next to their definitions in the source file.

I don't particularly like this mode dichotomy but unifying it would necessitate updating a whole lot of clang tests.

[greened]

llvm/utils/update_cc_test_checks.py

133

Yes I suppose it should in case opt and friends generate functions. I hadn't considered that use-case.

While I would like to make it default unfortunately it would require updating a bunch of the existing clang tests which doesn't seem too friendly. See the patch update comment for details.

[greened]

In D83004#2129362, @jdoerfert wrote:

This is great! Just a few days ago I added a TODO in one of the tests I created asking for this: D82722 :)

Glad to help!

Will this work for all test scripts?

Obviously right now it's only enabled for clang but it should be straightforward to add to the other test scripts. Al the infrastructure is there, the various drivers just have to use it.

Will this make the prefix_exclusions logic obsolete?

Yeah, I think it might.

[greened]

In D83004#2134303, @greened wrote:

I don't particularly like this mode dichotomy but unifying it would necessitate updating a whole lot of clang tests.

Axtually that's not strictly true, It would just change the tests singificantly when they are updated for some other reason. Whether that is reasonable is something we should discuss.

[greened]

llvm/utils/update_cc_test_checks.py

133

Just realized it wouldn't necessarily require regeneration of tests, it would just cause regenerated tests to change a lot when they are eventually regenerated. We should discuss as to whether that's acceptable. I think for now this should be non-default to at least get the functionality in without disturbing existing users and then we can discuss a separate change to make it default.

It's also possible we could change how clang orders functions. I discovered there's a difference in clang 10 vs. 11 in the order functions are output when OpenMP outlining happens. clang 10 seems to preserve the source order of functions and clang 11 does not. Perhaps that needs to be fixed as I don't know whether that change was intentional or not.

[jdoerfert]

llvm/utils/update_cc_test_checks.py

133

Best case, without the option the original behavior is preserved. Is that not the case?

[greened]

llvm/utils/update_cc_test_checks.py

133

That's right. I was referring to making this behavior default. If we do that, we could clean up the script code a bit but it would mean clang tests would change pretty dramatically when they are regenerated. If we fix the clang output, the test changes wouldn't be so dramatic.

The way clang is behaving now, I would expect any tests that use -fopenmp, have multiple functions with OpenMP regions and use function prototypes for some of those functions would break given clang's reordering of function definitions. Perhaps we don't have any tests like that though.

[jdoerfert]

llvm/utils/update_cc_test_checks.py

133

We (almost) do not have OpenMP tests with autogenerated test lines. Partially, because we do not test new functions. I would really like this to be available for OpenMP, both in _cc_ and IR tests. If people can opt out of this, especially if the default is "off", the ordering is not a problem (IMHO). With UTC_ARGS we also remember the choice so I really don't see the downside to this being in the common part for all scripts.

[greened]

llvm/utils/update_cc_test_checks.py

133

I agree it can be in the common part. I'll move it there and will leave it off by default so it doesn't disturb existing tests.

[greened]

Updated to move the option into common.py. Also had to rework the output loop to account for differences between python 2 and 3.

[jdoerfert]

LGTM. Thanks for the generalization. We'll add update_test support next for the opt case, e.g., for D83635.

llvm/utils/update_cc_test_checks.py

308

This is all unfortunate but at least for OpenMP not easily changeable. Let's go with this.

[jdoerfert]

Due to D82995 I realized we should have a test of this in llvm/test/tools/UpdateTestChecks as well.

[jdoerfert]

reverse ping?

[greened]

In D83004#2250897, @jdoerfert wrote:

reverse ping?

Heh. Getting back to this now.

[greened]

In D83004#2168427, @jdoerfert wrote:

Due to D82995 I realized we should have a test of this in llvm/test/tools/UpdateTestChecks as well.

Do you mean a test for recognizing the option in common.py? I'm not sure what you're asking for here.

[jdoerfert]

In D83004#2274573, @greened wrote:

In D83004#2168427, @jdoerfert wrote:

Due to D82995 I realized we should have a test of this in llvm/test/tools/UpdateTestChecks as well.

Do you mean a test for recognizing the option in common.py? I'm not sure what you're asking for here.

The function is recognized in common.py, right? Can't you run the update_test_check.py it with that option now? If so, we could have a test for it, using, for example, hot-cold splitting or attributor with the -attributor-allow-deep-wrappers and a linkonce_odr function that is called.

[greened]

In D83004#2274687, @jdoerfert wrote:

Do you mean a test for recognizing the option in common.py? I'm not sure what you're asking for here.

The function is recognized in common.py, right? Can't you run the update_test_check.py it with that option now? If so, we could have a test for it, using, for example, hot-cold splitting or attributor with the -attributor-allow-deep-wrappers and a linkonce_odr function that is called.

Makes sense. I'll work on it.

[arichardson]

Maybe add another test that checks for the @__cxx_global_var_init() constructor function?
E.g. something like this:

int init_func(int arg) {
    return arg + 1;
}

int my_global = init_func(2);

llvm/utils/update_cc_test_checks.py

276–280

This should avoid a few update() calls. Not that performance really matters here.

[arichardson]

llvm/utils/update_cc_test_checks.py

308

How difficult would it be to only use this behaviour if the normal one fails?

If we encounter a function that's not in the source code we just append the check lines for the generate function where we last added checks. And if we then see a function where the order doesn't match the source order fall back to just emitting all checks at the end of the file?

[greened]

Enhanced update_test_checks.py to honor --include-generated-funcs and added tests. For fun, did the same for update_llc_test_checks.py. The latter doesn't have complete coverage for all architectures because the machine outliner doesn't run on every backend. I didn't look further into this but we can do so later if desired.

[jdoerfert]

This works for me. @arichardson you want to continue the review or should we take this and if needed improve upon it in subsequent patches?

[greened]

Refactored to pull out most of the --include-generated-funcs processing into common.py.

[greened]

In D83004#2278681, @arichardson wrote:

Maybe add another test that checks for the @__cxx_global_var_init() constructor function?
E.g. something like this:

int init_func(int arg) {
    return arg + 1;
}

int my_global = init_func(2);

Can you explain what this would test beyond the provided OpenMP tests? Remember, the tests are for the update tool itself, not to test that the compiler is doing the right thing.

[greened]

llvm/utils/update_cc_test_checks.py

276–280

This should avoid a few update() calls. Not that performance really matters here.

Wouldn't it iterate over the prefix list twice? In any event, I was trying to follow existing style and wanted to rewrite as little existing code as possible.

308

How difficult would it be to only use this behaviour if the normal one fails?

If we encounter a function that's not in the source code we just append the check lines for the generate function where we last added checks. And if we then see a function where the order doesn't match the source order fall back to just emitting all checks at the end of the file?

The problem is that this loop is driven by lines as they appear in the source file and uses a dictionary to look up the tool output for that function. Because of this checks will *always* be placed in the source before each function and there is no way to tell if the checks you're adding are from out-of-order tool output. Changing this would be a complete rewrite of the algorithm, which I wanted to avoid for this enhancement. Of course we can always rewrite it later but I think that is best done as a separate change.

The other two tools use a similar algorithm. In fact it *may* be possible to further refactor this code to share the check output driver. But again, that involves changing existing code and is best left to a separate change I think.

[greened]

Fix one inadvertent change to the original algorithm in update_test_checks.py. This line:

output_lines.append(input_line)

had an extra rstrip in it compared to the original. It was probably an innocuous change but fixing this makes the diff a bit cleaner.

[arichardson]

I think this approach seems fine, just a few very minor comments inlines.

In D83004#2280363, @greened wrote:

In D83004#2278681, @arichardson wrote:

Maybe add another test that checks for the @__cxx_global_var_init() constructor function?
E.g. something like this:

int init_func(int arg) {
    return arg + 1;
}

int my_global = init_func(2);

Can you explain what this would test beyond the provided OpenMP tests? Remember, the tests are for the update tool itself, not to test that the compiler is doing the right thing.

It wouldn't add anything in terms of test coverage, I was just thinking of an example where the generated function is (at least currently) always inserted at the same location.

llvm/utils/UpdateTestChecks/common.py

439

I found this function a bit difficult to parse due to not knowing what finder does. Maybe something like get_arg_to_check ?

llvm/utils/update_cc_test_checks.py

308

Yes, I think the current approach is fine since it will only affect new tests that add --include-generated-funcs. In the future I think it would be nice if this flag could be passed to existing tests that don't have any generated functions and keep the output stable (other than the UTC_ARGS).

313

This is currently always true, but I guess adding it doesn't do any harm.

320

Since we're writing the output to a C/C++ file we need to use // comments.

llvm/utils/update_llc_test_checks.py

14

seems unused?

[thakis]

llvm/utils/UpdateTestChecks/common.py

476

LLVM still supports Python 2.7. This breaks devs and bots still using 2.7. Please fix :)

[chill]

Some tests started failing: http://lab.llvm.org:8011/builders/llvm-clang-x86_64-expensive-checks-ubuntu/builds/9071

[dmajor]

The expensive-checks bots have been red for several days. Could you please take a look or revert?

riscv_generated_funcs.test:

*** Bad machine code: MBB exits via unconditional fall-through but ends with a barrier instruction! ***
- function:    check_boundaries
- basic block: %bb.4  (0x5653e22035b8)
LLVM ERROR: Found 1 machine code errors.

http://lab.llvm.org:8011/builders/llvm-clang-x86_64-expensive-checks-ubuntu/builds/9171/steps/test-check-all/logs/FAIL%3A%20LLVM%3A%3Ariscv_generated_funcs.test

[greened]

In D83004#2287851, @dmajor wrote:

The expensive-checks bots have been red for several days. Could you please take a look or revert?

Working on it...

[greened]

In D83004#2290157, @greened wrote:

In D83004#2287851, @dmajor wrote:

The expensive-checks bots have been red for several days. Could you please take a look or revert?

Working on it...

I've removed this test as it seems to expose a bug in MachineOutliner for RISCV. Since that's not at all related to this change it made the most sense to me to just remove the test.

[jdoerfert]

Looking back at this I'm not so sure if it was beneficial to divert from the generic behavior and print each function for each prefix.
Having a function only in one run line but not the other should work perfectly fine as long as the two run lines have at least one prefix the other doesn't have.

clang/test/utils/update_cc_test_checks/Inputs/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
+
+const int size = 1024*1024*32;
+
+double A[size];
+
+void foo(void);
+
+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;
+  }
+}

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
+// 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);
+
+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;
+  }
+}
+// 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]]
+// 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]]
+// NOOMP:       for.end:
+// NOOMP-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* @1, i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* @.omp_outlined. to void (i32*, i32*, ...)*))
+// OMP-NEXT:    ret void
+//
+//
+// 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:    [[DOTOMP_STRIDE:%.*]] = alloca i32, align 4
+// OMP-NEXT:    [[DOTOMP_IS_LAST:%.*]] = alloca i32, align 4
+// OMP-NEXT:    [[I:%.*]] = alloca i32, align 4
+// 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:    store i32 0, i32* [[DOTOMP_LB]], align 4
+// OMP-NEXT:    store i32 33554431, i32* [[DOTOMP_UB]], align 4
+// OMP-NEXT:    store i32 1, i32* [[DOTOMP_STRIDE]], align 4
+// OMP-NEXT:    store i32 0, i32* [[DOTOMP_IS_LAST]], align 4
+// OMP-NEXT:    [[TMP0:%.*]] = load i32*, i32** [[DOTGLOBAL_TID__ADDR]], align 8
+// OMP-NEXT:    [[TMP1:%.*]] = load i32, i32* [[TMP0]], align 4
+// OMP-NEXT:    call void @__kmpc_for_static_init_4(%struct.ident_t* @0, i32 [[TMP1]], i32 34, i32* [[DOTOMP_IS_LAST]], i32* [[DOTOMP_LB]], i32* [[DOTOMP_UB]], i32* [[DOTOMP_STRIDE]], i32 1, i32 1)
+// OMP-NEXT:    [[TMP2:%.*]] = load i32, i32* [[DOTOMP_UB]], align 4
+// OMP-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[TMP2]], 33554431
+// OMP-NEXT:    br i1 [[CMP]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
+// OMP:       cond.true:
+// OMP-NEXT:    br label [[COND_END:%.*]]
+// OMP:       cond.false:
+// OMP-NEXT:    [[TMP3:%.*]] = load i32, i32* [[DOTOMP_UB]], align 4
+// OMP-NEXT:    br label [[COND_END]]
+// OMP:       cond.end:
+// OMP-NEXT:    [[COND:%.*]] = phi i32 [ 33554431, [[COND_TRUE]] ], [ [[TMP3]], [[COND_FALSE]] ]
+// OMP-NEXT:    store i32 [[COND]], i32* [[DOTOMP_UB]], align 4
+// OMP-NEXT:    [[TMP4:%.*]] = load i32, i32* [[DOTOMP_LB]], align 4
+// OMP-NEXT:    store i32 [[TMP4]], i32* [[DOTOMP_IV]], align 4
+// OMP-NEXT:    br label [[OMP_INNER_FOR_COND:%.*]]
+// OMP:       omp.inner.for.cond:
+// OMP-NEXT:    [[TMP5:%.*]] = load i32, i32* [[DOTOMP_IV]], align 4
+// OMP-NEXT:    [[TMP6:%.*]] = load i32, i32* [[DOTOMP_UB]], align 4
+// OMP-NEXT:    [[CMP1:%.*]] = icmp sle i32 [[TMP5]], [[TMP6]]
+// OMP-NEXT:    br i1 [[CMP1]], label [[OMP_INNER_FOR_BODY:%.*]], label [[OMP_INNER_FOR_END:%.*]]
+// OMP:       omp.inner.for.body:
+// OMP-NEXT:    [[TMP7:%.*]] = load i32, i32* [[DOTOMP_IV]], align 4
+// OMP-NEXT:    [[MUL:%.*]] = mul nsw i32 [[TMP7]], 1
+// OMP-NEXT:    [[ADD:%.*]] = add nsw i32 0, [[MUL]]
+// OMP-NEXT:    store i32 [[ADD]], i32* [[I]], align 4
+// OMP-NEXT:    [[TMP8:%.*]] = load i32, i32* [[I]], align 4
+// OMP-NEXT:    [[IDXPROM:%.*]] = sext i32 [[TMP8]] to i64
+// OMP-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [33554432 x double], [33554432 x double]* @A, i64 0, i64 [[IDXPROM]]
+// OMP-NEXT:    store double 1.000000e+00, double* [[ARRAYIDX]], align 8
+// OMP-NEXT:    br label [[OMP_BODY_CONTINUE:%.*]]
+// OMP:       omp.body.continue:
+// OMP-NEXT:    br label [[OMP_INNER_FOR_INC:%.*]]
+// OMP:       omp.inner.for.inc:
+// OMP-NEXT:    [[TMP9:%.*]] = load i32, i32* [[DOTOMP_IV]], 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* @0, i32 [[TMP1]])
+// OMP-NEXT:    ret 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* @1, i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* @.omp_outlined..1 to void (i32*, i32*, ...)*))
+// OMP-NEXT:    call void @foo()
+// OMP-NEXT:    ret i32 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:    [[DOTOMP_STRIDE:%.*]] = alloca i32, align 4
+// OMP-NEXT:    [[DOTOMP_IS_LAST:%.*]] = alloca i32, align 4
+// OMP-NEXT:    [[I:%.*]] = alloca i32, align 4
+// 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:    store i32 0, i32* [[DOTOMP_LB]], align 4
+// OMP-NEXT:    store i32 33554431, i32* [[DOTOMP_UB]], align 4
+// OMP-NEXT:    store i32 1, i32* [[DOTOMP_STRIDE]], align 4
+// OMP-NEXT:    store i32 0, i32* [[DOTOMP_IS_LAST]], align 4
+// OMP-NEXT:    [[TMP0:%.*]] = load i32*, i32** [[DOTGLOBAL_TID__ADDR]], align 8
+// OMP-NEXT:    [[TMP1:%.*]] = load i32, i32* [[TMP0]], align 4
+// OMP-NEXT:    call void @__kmpc_for_static_init_4(%struct.ident_t* @0, i32 [[TMP1]], i32 34, i32* [[DOTOMP_IS_LAST]], i32* [[DOTOMP_LB]], i32* [[DOTOMP_UB]], i32* [[DOTOMP_STRIDE]], i32 1, i32 1)
+// OMP-NEXT:    [[TMP2:%.*]] = load i32, i32* [[DOTOMP_UB]], align 4
+// OMP-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[TMP2]], 33554431
+// OMP-NEXT:    br i1 [[CMP]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
+// OMP:       cond.true:
+// OMP-NEXT:    br label [[COND_END:%.*]]
+// OMP:       cond.false:
+// OMP-NEXT:    [[TMP3:%.*]] = load i32, i32* [[DOTOMP_UB]], align 4
+// OMP-NEXT:    br label [[COND_END]]
+// OMP:       cond.end:
+// OMP-NEXT:    [[COND:%.*]] = phi i32 [ 33554431, [[COND_TRUE]] ], [ [[TMP3]], [[COND_FALSE]] ]
+// OMP-NEXT:    store i32 [[COND]], i32* [[DOTOMP_UB]], align 4
+// OMP-NEXT:    [[TMP4:%.*]] = load i32, i32* [[DOTOMP_LB]], align 4
+// OMP-NEXT:    store i32 [[TMP4]], i32* [[DOTOMP_IV]], align 4
+// OMP-NEXT:    br label [[OMP_INNER_FOR_COND:%.*]]
+// OMP:       omp.inner.for.cond:
+// OMP-NEXT:    [[TMP5:%.*]] = load i32, i32* [[DOTOMP_IV]], align 4
+// OMP-NEXT:    [[TMP6:%.*]] = load i32, i32* [[DOTOMP_UB]], align 4
+// OMP-NEXT:    [[CMP1:%.*]] = icmp sle i32 [[TMP5]], [[TMP6]]
+// OMP-NEXT:    br i1 [[CMP1]], label [[OMP_INNER_FOR_BODY:%.*]], label [[OMP_INNER_FOR_END:%.*]]
+// OMP:       omp.inner.for.body:
+// OMP-NEXT:    [[TMP7:%.*]] = load i32, i32* [[DOTOMP_IV]], align 4
+// OMP-NEXT:    [[MUL:%.*]] = mul nsw i32 [[TMP7]], 1
+// OMP-NEXT:    [[ADD:%.*]] = add nsw i32 0, [[MUL]]
+// OMP-NEXT:    store i32 [[ADD]], i32* [[I]], align 4
+// OMP-NEXT:    [[TMP8:%.*]] = load i32, i32* [[I]], align 4
+// OMP-NEXT:    [[IDXPROM:%.*]] = sext i32 [[TMP8]] to i64
+// OMP-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [33554432 x double], [33554432 x double]* @A, i64 0, i64 [[IDXPROM]]
+// OMP-NEXT:    store double 0.000000e+00, double* [[ARRAYIDX]], align 8
+// OMP-NEXT:    br label [[OMP_BODY_CONTINUE:%.*]]
+// OMP:       omp.body.continue:
+// OMP-NEXT:    br label [[OMP_INNER_FOR_INC:%.*]]
+// OMP:       omp.inner.for.inc:
+// OMP-NEXT:    [[TMP9:%.*]] = load i32, i32* [[DOTOMP_IV]], 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* @0, i32 [[TMP1]])
+// OMP-NEXT:    ret void
+//

clang/test/utils/update_cc_test_checks/Inputs/generated-funcs.c.no-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
+
+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* @1, i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* @.omp_outlined..1 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]]
+// 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;
+}
+
+// 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* @1, i32 0, void (i32*, i32*, ...)* bitcast (void (i32*, i32*)* @.omp_outlined. 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]]
+// 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;
+  }
+}

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

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

llvm/utils/UpdateTestChecks/asm.py

triples = {
       'hexagon': 'hexagon',
   }
   for prefix, triple in triples.items():
     if march.startswith(prefix):
       return triple
   print("Cannot find a triple. Assume 'x86'", file=sys.stderr)
   return 'x86'
 
-def build_function_body_dictionary_for_triple(args, raw_tool_output, triple, prefixes, func_dict):
+def build_function_body_dictionary_for_triple(args, raw_tool_output, triple,
+                                              prefixes, func_dict, func_order):
   target_handlers = {
       'i686': (scrub_asm_x86, ASM_FUNCTION_X86_RE),
       'x86': (scrub_asm_x86, ASM_FUNCTION_X86_RE),
       'i386': (scrub_asm_x86, ASM_FUNCTION_X86_RE),
       'aarch64': (scrub_asm_arm_eabi, ASM_FUNCTION_AARCH64_RE),
       'aarch64-apple-darwin': (scrub_asm_arm_eabi, ASM_FUNCTION_AARCH64_DARWIN_RE),
       'hexagon': (scrub_asm_hexagon, ASM_FUNCTION_HEXAGON_RE),
       'r600': (scrub_asm_amdgpu, ASM_FUNCTION_AMDGPU_RE),
if triple.startswith(prefix) and len(prefix) > len(best_prefix):
       best_prefix = prefix
 
   if handler is None:
     raise KeyError('Triple %r is not supported' % (triple))
 
   scrubber, function_re = handler
   common.build_function_body_dictionary(
           function_re, scrubber, [args], raw_tool_output, prefixes,
-          func_dict, args.verbose, False)
+          func_dict, func_order, args.verbose, False)
 
 ##### Generator of assembly CHECK lines
 
 def add_asm_checks(output_lines, comment_marker, prefix_list, func_dict, func_name):
   # Label format is based on ASM string.
   check_label_format = '{} %s-LABEL: %s%s:'.format(comment_marker)
   common.add_checks(output_lines, comment_marker, prefix_list, func_dict, func_name, check_label_format, True, False)

llvm/utils/UpdateTestChecks/common.py

def is_same_except_arg_names(self, extrascrub, args_and_sig):
     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
 
-def build_function_body_dictionary(function_re, scrubber, scrubber_args, raw_tool_output, prefixes, func_dict, verbose, record_args):
+def build_function_body_dictionary(function_re, scrubber, scrubber_args, raw_tool_output, prefixes, func_dict, func_order, verbose, record_args):
   for m in function_re.finditer(raw_tool_output):
     if not m:
       continue
     func = m.group('func')
     body = m.group('body')
     # Determine if we print arguments, the opening brace, or nothing after the function name
     if record_args and 'args_and_sig' in m.groupdict():
         args_and_sig = scrub_body(m.group('args_and_sig').strip())
for prefix in prefixes:
         else:
           if prefix == prefixes[-1]:
             warn('Found conflicting asm under the same prefix: %r!' % (prefix,))
           else:
             func_dict[prefix][func] = None
             continue
 
       func_dict[prefix][func] = function_body(scrubbed_body, scrubbed_extra, args_and_sig)
+      func_order[prefix].append(func)
 
 ##### Generator of LLVM IR CHECK lines
 
 SCRUB_IR_COMMENT_RE = re.compile(r'\s*;.*')
 
 # Match things that look at identifiers, but only if they are followed by
 # spaces, commas, paren, or end of the string
 IR_VALUE_RE = re.compile(r'(\s+)%([\w.-]+?)([,\s\(\)]|\Z)')

 
 
 def check_for_command(line, parser, args, argv):
     cmd_m = UTC_ARGS_CMD.match(line)
     if cmd_m:
         cmd = cmd_m.group('cmd').strip().split(' ')
         argv = argv + cmd
         args = parser.parse_args(filter(lambda arg: arg not in args.tests, argv))
     return args, argv

llvm/utils/update_cc_test_checks.py

def config():
   parser.add_argument(
       '--functions', nargs='+', help='A list of function name regexes. '
       'If specified, update CHECK lines for functions matching at least one regex')
   parser.add_argument(
       '--x86_extra_scrub', action='store_true',
       help='Use more regex for x86 matching to reduce diffs between various subtargets')
   parser.add_argument('--function-signature', action='store_true',
                       help='Keep function signature information around for the check line')
+  parser.add_argument('--include-generated-funcs', action='store_true',
+                      help='Output checks for functions not in source')
   parser.add_argument('tests', nargs='+')
   args = common.parse_commandline_args(parser)
   args.clang_args = shlex.split(args.clang_args or '')
 
   if args.clang is None:
     if args.llvm_bin is None:
       args.clang = 'clang'
     else:
if not distutils.spawn.find_executable(args.opt):
     # Many uses of this tool will not need an opt binary, because it's only
     # needed for updating a test that runs clang | opt | FileCheck. So we
     # defer this error message until we find that opt is actually needed.
     args.opt = None
 
   return args
 
 
-def get_function_body(args, filename, clang_args, extra_commands, prefixes, triple_in_cmd, func_dict):
+def get_function_body(args, filename, clang_args, extra_commands, prefixes,
+                      triple_in_cmd, func_dict, func_order):
   # TODO Clean up duplication of asm/common build_function_body_dictionary
   # Invoke external tool and extract function bodies.
   raw_tool_output = common.invoke_tool(args.clang, clang_args, filename)
   for extra_command in extra_commands:
     extra_args = shlex.split(extra_command)
     with tempfile.NamedTemporaryFile() as f:
       f.write(raw_tool_output.encode())
       f.flush()
       if extra_args[0] == 'opt':
         if args.opt is None:
           print(filename, 'needs to run opt. '
                 'Please specify --llvm-bin or --opt', file=sys.stderr)
           sys.exit(1)
         extra_args[0] = args.opt
       raw_tool_output = common.invoke_tool(extra_args[0],
                                            extra_args[1:], f.name)
   if '-emit-llvm' in clang_args:
     common.build_function_body_dictionary(
             common.OPT_FUNCTION_RE, common.scrub_body, [],
-            raw_tool_output, prefixes, func_dict, args.verbose, args.function_signature)
+            raw_tool_output, prefixes, func_dict, func_order, args.verbose,
+            args.function_signature)
   else:
     print('The clang command line should include -emit-llvm as asm tests '
           'are discouraged in Clang testsuite.', file=sys.stderr)
     sys.exit(1)
 
 
 def main():
   args = config()
with open(filename, 'r+') as f:
         if not (m and m.group(1) in prefix_set) and line != '//\n':
           input_lines.append(line)
       f.seek(0)
       f.writelines(input_lines)
       f.truncate()
 
     # Execute clang, generate LLVM IR, and extract functions.
     func_dict = {}
+    func_order = {}
     for p in run_list:
       prefixes = p[0]
       for prefix in prefixes:
         func_dict.update({prefix: dict()})
+        func_order.update({prefix: []})
     for prefixes, clang_args, extra_commands, triple_in_cmd in run_list:
       common.debug('Extracted clang cmd: clang {}'.format(clang_args))
       common.debug('Extracted FileCheck prefixes: {}'.format(prefixes))
 
-      get_function_body(args, filename, clang_args, extra_commands, prefixes, triple_in_cmd, func_dict)
+      get_function_body(args, filename, clang_args, extra_commands, prefixes,
+                        triple_in_cmd, func_dict, func_order)
 
       # Invoke clang -Xclang -ast-dump=json to get mapping from start lines to
       # mangled names. Forward all clang args for now.
       for k, v in get_line2spell_and_mangled(args, clang_args).items():
         line2spell_and_mangled_list[k].append(v)
 
     output_lines = [autogenerated_note]
+
+    if args.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.
+
+      # 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
+      # put them at the end.  So the first thing to do is dump out the source
+      # lines.
+      for idx, line in enumerate(input_lines):
+        # Discard any previous script advertising.
+        if line.startswith(ADVERT):
+          continue
+        output_lines.append(line.rstrip('\n'))
+
+      # Now generate all the checks.
+      added = set()
+      for prefix, funcs in func_order.items():
+        for func in funcs:
+          if added:
+            output_lines.append('//')
+          added.add(func)
+
+          # The add_*_checks routines expect a run list whose items are tuples
+          # that have a list of prefixes as their first element and tool command
+          # args string as their second element.  They output checks for each
+          # prefix in the list of prefixes.  By doing so, it implicitly assumes
+          # that for each function every run line will generate something for
+          # that function.  That is not the case for generated functions as some
+          # run lines might not generate them (e.g. -fopenmp vs. no -fopenmp).
+          #
+          # Therefore, pass just the prefix we're interested in.  This has the
+          # effect of generating all of the checks for functions of a single
+          # prefix before moving on to the next prefix.  So checks are ordered
+          # by prefix instead of by function as for "normal" functions.
+          if '-emit-llvm' in clang_args:
+            common.add_ir_checks(output_lines, '//', [([prefix], clang_args)],
+                                 func_dict, func, False,
+                                 args.function_signature)
+          else:
+            asm.add_asm_checks(output_lines, '//', [([prefix], clang_args)],
+                               func_dict, func)
+    else:
+      # Normal mode.  Put checks before each source function.
       for idx, line in enumerate(input_lines):
         # Discard any previous script advertising.
         if line.startswith(ADVERT):
           continue
         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):
               if added:
                 output_lines.append('//')
               added.add(mangled)
-            common.add_ir_checks(output_lines, '//', run_list, func_dict, mangled,
-                                 False, args.function_signature)
+              common.add_ir_checks(output_lines, '//', run_list, func_dict,
+                                   mangled, False, args.function_signature)
         output_lines.append(line.rstrip('\n'))
 
-
+    # Update the test file.
     common.debug('Writing %d lines to %s...' % (len(output_lines), filename))
     with open(filename, '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_llc_test_checks.py

 #!/usr/bin/env python3
 
 """A test case update script.
 
 This script is a utility to update LLVM 'llc' based test cases with new
 FileCheck patterns. It can either update all of the tests in the file or
 a single test function.
 """
 
 from __future__ import print_function
 
 import argparse
 import glob
 import os         # Used to advertise this file's name ("autogenerated_note").
 import string
 import subprocess
 import sys
 import re
 
 from UpdateTestChecks import asm, common
 
 ADVERT = ' NOTE: Assertions have been autogenerated by '
if test.endswith('.mir'):
       comment_sym = '#'
       check_indent = '  '
     else:
       comment_sym = ';'
       check_indent = ''
     autogenerated_note = (comment_sym + ADVERT + 'utils/' + script_name)
 
     func_dict = {}
+    func_order = {}
     for p in run_list:
       prefixes = p[0]
       for prefix in prefixes:
         func_dict.update({prefix: dict()})
+        func_order.update({prefix: []})
     for prefixes, llc_args, triple_in_cmd, march_in_cmd in run_list:
       common.debug('Extracted LLC cmd:', llc_tool, llc_args)
       common.debug('Extracted FileCheck prefixes:', str(prefixes))
 
       raw_tool_output = common.invoke_tool(args.llc_binary or llc_tool,
                                            llc_args, test)
       triple = triple_in_cmd or triple_in_ir
       if not triple:
         triple = asm.get_triple_from_march(march_in_cmd)
 
       asm.build_function_body_dictionary_for_triple(args, raw_tool_output,
-          triple, prefixes, func_dict)
+          triple, prefixes, func_dict, func_order)
 
     is_in_function = False
     is_in_function_start = False
     func_name = None
     prefix_set = set([prefix for p in run_list for prefix in p[0]])
     common.debug('Rewriting FileCheck prefixes:', str(prefix_set))
     output_lines = []
     output_lines.append(autogenerated_note)

llvm/utils/update_test_checks.py

for l in run_lines:
       if not check_prefixes:
         check_prefixes = ['CHECK']
 
       # FIXME: We should use multiple check prefixes to common check lines. For
       # now, we just ignore all but the last.
       prefix_list.append((check_prefixes, tool_cmd_args))
 
     func_dict = {}
+    func_order = {}
     for prefixes, _ in prefix_list:
       for prefix in prefixes:
         func_dict.update({prefix: dict()})
+        func_order.update({prefix: []})
     for prefixes, opt_args in prefix_list:
       common.debug('Extracted opt cmd: ' + opt_basename + ' ' + opt_args)
       common.debug('Extracted FileCheck prefixes: ' + str(prefixes))
 
       raw_tool_output = common.invoke_tool(args.opt_binary, opt_args, test)
       common.build_function_body_dictionary(
               common.OPT_FUNCTION_RE, common.scrub_body, [],
-              raw_tool_output, prefixes, func_dict, args.verbose,
+              raw_tool_output, prefixes, func_dict, func_order, args.verbose,
               args.function_signature)
 
     is_in_function = False
     is_in_function_start = False
     prefix_set = set([prefix for prefixes, _ in prefix_list for prefix in prefixes])
     common.debug('Rewriting FileCheck prefixes:', str(prefix_set))
     output_lines = []
     output_lines.append(test_autogenerated_note)