Add initial tests for update_{llc,cc}_test_checks.py

[arichardson]

Summary

This commit adds two basic tests for these update script to validate that
they still work as expected. In the future we could extend these tests
whenever new features are added to avoid introducing regressions.

I am not sure this is the best approach for testing, but it did allow me to find a python2.7 compat issue that I introduced in D70432.
If this approach seems fine, I'll also add a basic test for the remaining update scripts.

[xbolva00]

Happy to see this! We should definitelly have such test suite.

[jdoerfert]

Thanks for working on this.

Two general questions, but it generally looks fine to me:

Why do we have the extra input folders that contain all files?
Could you add the same for the opt script?

llvm/test/tools/UpdateTestChecks/update_cc_tests/mangled_names.test

31 ↗

(On Diff #230856)

Are these (EMPTY lines) auto generated?

[xbolva00]

maybe diffing with reference output file is enough?

checks for checks are kinda weird imho.

[MaskRay]

llvm/test/tools/UpdateTestChecks/lit.local.cfg

19

Use " when nested ' is used to reduce escaping.

llvm/test/tools/UpdateTestChecks/update_cc_tests/Inputs/mangled_names.c

12 ↗

(On Diff #230856)

Remove trailing empty lines.

llvm/test/tools/UpdateTestChecks/update_cc_tests/mangled_names.test

54 ↗

(On Diff #230856)

Remove trailing empty line.

llvm/test/tools/UpdateTestChecks/update_llc_tests/basic.test

4 ↗

(On Diff #230856)

Delete -f. It is not needed.

I get another idea. We can probably use sed to delete # lines in %s and feed that to %update_llc_test_checks.

[arichardson]

Address comments

Use diff -u against an expected output instead of lots of CHECK-LINES with awkward escaping.
Since we are using the lit internal shell this should work everywhere.

llvm/test/tools/UpdateTestChecks/update_cc_tests/mangled_names.test

31 ↗

(On Diff #230856)

No, I added them manually. All the regex escaping is quite awkward so I've now gone with the diff suggestion.

[arichardson]

llvm/test/tools/UpdateTestChecks/update_cc_test_checks/mangled_names.test

15

Note: this check fails without D70890

[jdoerfert]

I have two minor comments, neither is blocking. @MaskRay @xbolva00, please review and accept without waiting for me, I'm fine with this.

• We still have the "inputs" folder in which everything lives. I could see the '.ll' and '.ll.expected' to live in their but why the tests?
• The --function-signatures test has manual check lines. We should probably move to a '.expected' file as well here.

llvm/test/tools/UpdateTestChecks/update_test_checks/basic.test

45

Shouldn't we have multiple .expected files instead? I see myself struggle with the escaping already.

[xbolva00]

In D70660#1764915, @arichardson wrote:

Address comments

Use diff -u against an expected output instead of lots of CHECK-LINES with awkward escaping.
Since we are using the lit internal shell this should work everywhere.

Cool! Thanks.

[arichardson]

In D70660#1765478, @jdoerfert wrote:

I have two minor comments, neither is blocking. @MaskRay @xbolva00, please review and accept without waiting for me, I'm fine with this.

• We still have the "inputs" folder in which everything lives. I could see the '.ll' and '.ll.expected' to live in their but why the tests?

Only the .ll and .ll.expected is in the Inputs folder. The .test shouldn't be.
I could also move the .expected out of the inputs folder which would make some of the check lines simpler since I can just use diff -u %t.ll %s.expected then.

• The --function-signatures test has manual check lines. We should probably move to a '.expected' file as well here.

I am happy to move to a separate .expected file for the --function-signatures test. What do you think @MaskRay @xbolva00 ?

llvm/test/tools/UpdateTestChecks/update_test_checks/basic.test

45

Since these files are quite small I guess that would be fine. I agree that the escaping is ugly.

The only benefit of having the manual check lines is that it shows the difference between the two files but that can also be seen by comparing the <test>.expected with a <test>.funcsig.expected

[jdoerfert]

LGTM with two comments. (You can commit with the appropriate changes.)

In D70660#1765563, @arichardson wrote:

In D70660#1765478, @jdoerfert wrote:

• We still have the "inputs" folder in which everything lives. I could see the '.ll' and '.ll.expected' to live in their but why the tests?

Only the .ll and .ll.expected is in the Inputs folder. The .test shouldn't be.

1. I mean that is what I want but the current version looks different.

I am happy to move to a separate .expected

2. Please do.

llvm/test/tools/UpdateTestChecks/update_test_checks/basic.test

45

I'd prefer a new file.

[MaskRay]

llvm/test/tools/UpdateTestChecks/lit.local.cfg

7

What's the status of Python 3 compatibility of lit? Can we skip the tests if the legacy Python 2 is used?

49

'\'' -> "'"

Why isn't this shell_quote?

[arichardson]

llvm/test/tools/UpdateTestChecks/lit.local.cfg

7

lit works with python3. However, the default is still to run lit with python2.7 and I would like these tests to always run rather than only for those who configure LLVM with DPYTHON_EXECUTABLE=/usr/bin/python3

49

Will fix, I added this line before realizing that I needed more things to be quoted.

[arichardson]

• Use separate .expected files for the --function-signature tests
• address comments

[merge_guards_bot]

clang-format: pass.

Build artifacts: console-log.txt, diff.json

[thakis]

Looks like the test fails on macOS: http://45.33.8.238/mac/4235/step_11.txt

^ Sorry, please ignore that part. I'm still looking if the failure isn't my fault with the bot setup. I meant to delete this after I wrote the py3 question.

llvm/test/tools/UpdateTestChecks/lit.local.cfg

49

Nothing in this patch seems to use this as far as I can tell? Do you need this?

[arichardson]

llvm/test/tools/UpdateTestChecks/lit.local.cfg

49

Yes indeed it is not needed anymore. In an initial version of the patch I used %python3 to invoke update_cc_test_checks.py Does this cause issues for you?
If so feel free to delete.

[thakis]

llvm/test/tools/UpdateTestChecks/lit.local.cfg

49

I finally had time to look into why this is failing on one of my machines. If python3 isn't on the path, then the update_cc_test_checks substitution isn't getting added, and RUN: %update_cc_test_checks in the test tries to literally run %update_cc_test_checks (which of course fails).

So a possible fix is to add REQUIRES: python3to the test.

It seems a bit strange to me to only run some tests if py3 is around, though. Environment-dependent tests like this make analyzing failures more difficult. What stops these tests from running with Py3?

(ps: It'd be nice if add_update_script_substition would expect that the name already contains a leading % instead of adding it. That makes it much easier to grep for %update_cc_test_checks and see where it's supposed to be set.)

[thakis]

I added a REQUIRES: line (and did the greppability suggestion) in cc802ea67beb66. I'd be interested in ways to make these tests not depend on py3 though.

[arichardson]

In D70660#1786330, @thakis wrote:

I added a REQUIRES: line (and did the greppability suggestion) in cc802ea67beb66. I'd be interested in ways to make these tests not depend on py3 though.

We should be able to use sys.executable instead if its python3.
I'm not sure how much longer python 2 will be used by default for running tests. Once that changes we can use sys.executable unconditionally.

[rnk]

I reverted the update_cc_* part of this patch in 287307a0c60b68099d5f9dd22ac1db2a42593533. Testing for python3 on PATH and assuming that it's going to work with no way for the user to disable the tests from cmake doesn't seem like a great approach. This essentially creates a test suite dependency on py3, and IIRC on llvm-dev we agreed we don't want that, we want to be able to check out, build, & test llvm without py3.

I would prefer that this reland as something that uses config.python_executable with a check for python 3 in cmake.

llvm/test/tools/UpdateTestChecks/lit.local.cfg

+import os
+
+import lit.formats
+import lit.util
+
+# python 2.7 backwards compatibility
+try:
+    from shlex import quote as shell_quote
+except ImportError:
+    from pipes import quote as shell_quote
+
+
+def add_update_script_substition(name, python_exe=config.python_executable,
+                                 extra_args=''):
+    script_path = os.path.join(config.llvm_src_root, 'utils', name + '.py')
+    assert os.path.isfile(script_path)
+    config.substitutions.append(
+        ('%' + name, "'%s' %s %s" % (python_exe, script_path, extra_args)))
+
+
+config.test_format = lit.formats.ShTest(execute_external=False)
+config.suffixes = ['.test']
+
+llc_path = os.path.join(config.llvm_tools_dir, 'llc')
+if os.path.isfile(llc_path):
+    config.available_features.add('llc-binary')
+    llc_arg = '--llc-binary ' + shell_quote(llc_path)
+    add_update_script_substition('update_llc_test_checks', extra_args=llc_arg)
+    add_update_script_substition('update_mir_test_checks', extra_args=llc_arg)
+
+opt_path = os.path.join(config.llvm_tools_dir, 'opt')
+if os.path.isfile(opt_path):
+    config.available_features.add('opt-binary')
+    opt_arg = '--opt-binary ' + shell_quote(opt_path)
+    add_update_script_substition('update_test_checks', extra_args=opt_arg)
+    add_update_script_substition('update_analyze_test_checks',
+                                 extra_args=opt_arg)
+
+llvm_mca_path = os.path.join(config.llvm_tools_dir, 'llvm-mca')
+if os.path.isfile(llvm_mca_path):
+    config.available_features.add('llvm-mca-binary')
+    mca_arg = '--llvm-mca-binary ' + shell_quote(llvm_mca_path)
+    add_update_script_substition('update_test_checks', extra_args=mca_arg)
+
+# update_cc_test_checks requires python3
+py3_exe = lit.util.which('python3')
+if py3_exe:
+    config.substitutions.append(('%python3', shell_quote(py3_exe)))
+    config.available_features.add('python3')
+
+clang_path = os.path.join(config.llvm_tools_dir, 'clang')
+if os.path.isfile(clang_path):
+    config.available_features.add('clang-binary')
+    if py3_exe:
+        # XXX: or use --llvm-bin?
+        extra_args = '--clang ' + shell_quote(clang_path)
+        if os.path.isfile(opt_path):
+            extra_args += ' --opt ' + shell_quote(opt_path)
+        add_update_script_substition('update_cc_test_checks',
+                                     python_exe=py3_exe,
+                                     extra_args=extra_args)

llvm/test/tools/UpdateTestChecks/update_cc_test_checks/Inputs/mangled_names.c

+// Example input for update_cc_test_checks
+// RUN: %clang_cc1 -triple=x86_64-unknown-linux-gnu -emit-llvm -o - %s | FileCheck %s
+
+long test(long a, int b) {
+  return a + b;
+}
+
+// A function with a mangled name
+__attribute__((overloadable)) long test(long a, int b, int c) {
+  return a + b + c;
+}

llvm/test/tools/UpdateTestChecks/update_cc_test_checks/Inputs/mangled_names.c.expected

+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
+// Example input for update_cc_test_checks
+// RUN: %clang_cc1 -triple=x86_64-unknown-linux-gnu -emit-llvm -o - %s | FileCheck %s
+
+// CHECK-LABEL: @test(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[A_ADDR:%.*]] = alloca i64, align 8
+// CHECK-NEXT:    [[B_ADDR:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    store i64 [[A:%.*]], i64* [[A_ADDR]], align 8
+// CHECK-NEXT:    store i32 [[B:%.*]], i32* [[B_ADDR]], align 4
+// CHECK-NEXT:    [[TMP0:%.*]] = load i64, i64* [[A_ADDR]], align 8
+// CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* [[B_ADDR]], align 4
+// CHECK-NEXT:    [[CONV:%.*]] = sext i32 [[TMP1]] to i64
+// CHECK-NEXT:    [[ADD:%.*]] = add nsw i64 [[TMP0]], [[CONV]]
+// CHECK-NEXT:    ret i64 [[ADD]]
+//
+long test(long a, int b) {
+  return a + b;
+}
+
+// A function with a mangled name
+// CHECK-LABEL: @_Z4testlii(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[A_ADDR:%.*]] = alloca i64, align 8
+// CHECK-NEXT:    [[B_ADDR:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    [[C_ADDR:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    store i64 [[A:%.*]], i64* [[A_ADDR]], align 8
+// CHECK-NEXT:    store i32 [[B:%.*]], i32* [[B_ADDR]], align 4
+// CHECK-NEXT:    store i32 [[C:%.*]], i32* [[C_ADDR]], align 4
+// CHECK-NEXT:    [[TMP0:%.*]] = load i64, i64* [[A_ADDR]], align 8
+// CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* [[B_ADDR]], align 4
+// CHECK-NEXT:    [[CONV:%.*]] = sext i32 [[TMP1]] to i64
+// CHECK-NEXT:    [[ADD:%.*]] = add nsw i64 [[TMP0]], [[CONV]]
+// CHECK-NEXT:    [[TMP2:%.*]] = load i32, i32* [[C_ADDR]], align 4
+// CHECK-NEXT:    [[CONV1:%.*]] = sext i32 [[TMP2]] to i64
+// CHECK-NEXT:    [[ADD2:%.*]] = add nsw i64 [[ADD]], [[CONV1]]
+// CHECK-NEXT:    ret i64 [[ADD2]]
+//
+__attribute__((overloadable)) long test(long a, int b, int c) {
+  return a + b + c;
+}

llvm/test/tools/UpdateTestChecks/update_cc_test_checks/Inputs/mangled_names.c.funcsig.expected

+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
+// Example input for update_cc_test_checks
+// RUN: %clang_cc1 -triple=x86_64-unknown-linux-gnu -emit-llvm -o - %s | FileCheck %s
+
+// CHECK-LABEL: define {{[^@]+}}@test
+// CHECK-SAME: (i64 [[A:%.*]], i32 [[B:%.*]]) #0
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[A_ADDR:%.*]] = alloca i64, align 8
+// CHECK-NEXT:    [[B_ADDR:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    store i64 [[A:%.*]], i64* [[A_ADDR]], align 8
+// CHECK-NEXT:    store i32 [[B:%.*]], i32* [[B_ADDR]], align 4
+// CHECK-NEXT:    [[TMP0:%.*]] = load i64, i64* [[A_ADDR]], align 8
+// CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* [[B_ADDR]], align 4
+// CHECK-NEXT:    [[CONV:%.*]] = sext i32 [[TMP1]] to i64
+// CHECK-NEXT:    [[ADD:%.*]] = add nsw i64 [[TMP0]], [[CONV]]
+// CHECK-NEXT:    ret i64 [[ADD]]
+//
+long test(long a, int b) {
+  return a + b;
+}
+
+// A function with a mangled name
+// CHECK-LABEL: define {{[^@]+}}@_Z4testlii
+// CHECK-SAME: (i64 [[A:%.*]], i32 [[B:%.*]], i32 [[C:%.*]]) #0
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[A_ADDR:%.*]] = alloca i64, align 8
+// CHECK-NEXT:    [[B_ADDR:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    [[C_ADDR:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    store i64 [[A:%.*]], i64* [[A_ADDR]], align 8
+// CHECK-NEXT:    store i32 [[B:%.*]], i32* [[B_ADDR]], align 4
+// CHECK-NEXT:    store i32 [[C:%.*]], i32* [[C_ADDR]], align 4
+// CHECK-NEXT:    [[TMP0:%.*]] = load i64, i64* [[A_ADDR]], align 8
+// CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* [[B_ADDR]], align 4
+// CHECK-NEXT:    [[CONV:%.*]] = sext i32 [[TMP1]] to i64
+// CHECK-NEXT:    [[ADD:%.*]] = add nsw i64 [[TMP0]], [[CONV]]
+// CHECK-NEXT:    [[TMP2:%.*]] = load i32, i32* [[C_ADDR]], align 4
+// CHECK-NEXT:    [[CONV1:%.*]] = sext i32 [[TMP2]] to i64
+// CHECK-NEXT:    [[ADD2:%.*]] = add nsw i64 [[ADD]], [[CONV1]]
+// CHECK-NEXT:    ret i64 [[ADD2]]
+//
+__attribute__((overloadable)) long test(long a, int b, int c) {
+  return a + b + c;
+}

llvm/test/tools/UpdateTestChecks/update_cc_test_checks/lit.local.cfg

+# These tests require clang.
+if 'clang-binary' not in config.available_features:
+    config.unsupported = True

llvm/test/tools/UpdateTestChecks/update_cc_test_checks/mangled_names.test

+## Basic test checking that update_cc_test_checks.py works as expected for
+## functions with mangled names
+# RUN: cp -f %S/Inputs/mangled_names.c %t.c && %update_cc_test_checks -v %t.c
+# RUN: diff -u %t.c %S/Inputs/mangled_names.c.expected
+## Check that running the script again does not change the result:
+# RUN: %update_cc_test_checks -v %t.c
+# RUN: diff -u %t.c %S/Inputs/mangled_names.c.expected
+## Also try the --function-signature flag
+# RUN: %update_cc_test_checks %t.c --function-signature
+# RUN: diff -u %t.c %S/Inputs/mangled_names.c.funcsig.expected
+## Verify that running without the --function-signature flag removes the -SAME: lines:
+# RUN: %update_cc_test_checks %t.c
+# RUN: diff -u %t.c %S/Inputs/mangled_names.c.expected

llvm/test/tools/UpdateTestChecks/update_llc_test_checks/Inputs/basic.ll

+; Example input for update_llc_test_checks (taken from CodeGen/X86/iabs.ll)
+; RUN: llc < %s -mtriple=i686-unknown-unknown | FileCheck %s --check-prefix=X86 --check-prefix=X86-NO-CMOV
+; RUN: llc < %s -mtriple=i686-unknown-unknown -mattr=+cmov | FileCheck %s --check-prefix=X86 --check-prefix=X86-CMOV
+; RUN: llc < %s -mtriple=x86_64-unknown-unknown | FileCheck %s --check-prefix=X64
+
+define i8 @test_i8(i8 %a) nounwind {
+  %tmp1neg = sub i8 0, %a
+  %b = icmp sgt i8 %a, -1
+  %abs = select i1 %b, i8 %a, i8 %tmp1neg
+  ret i8 %abs
+}
+
+define i16 @test_i16(i16 %a) nounwind {
+  %tmp1neg = sub i16 0, %a
+  %b = icmp sgt i16 %a, -1
+  %abs = select i1 %b, i16 %a, i16 %tmp1neg
+  ret i16 %abs
+}
+
+define i32 @test_i32(i32 %a) nounwind {
+  %tmp1neg = sub i32 0, %a
+  %b = icmp sgt i32 %a, -1
+  %abs = select i1 %b, i32 %a, i32 %tmp1neg
+  ret i32 %abs
+}
+
+define i64 @test_i64(i64 %a) nounwind {
+  %tmp1neg = sub i64 0, %a
+  %b = icmp sgt i64 %a, -1
+  %abs = select i1 %b, i64 %a, i64 %tmp1neg
+  ret i64 %abs
+}

llvm/test/tools/UpdateTestChecks/update_llc_test_checks/Inputs/basic.ll.expected

+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+; Example input for update_llc_test_checks (taken from CodeGen/X86/iabs.ll)
+; RUN: llc < %s -mtriple=i686-unknown-unknown | FileCheck %s --check-prefix=X86 --check-prefix=X86-NO-CMOV
+; RUN: llc < %s -mtriple=i686-unknown-unknown -mattr=+cmov | FileCheck %s --check-prefix=X86 --check-prefix=X86-CMOV
+; RUN: llc < %s -mtriple=x86_64-unknown-unknown | FileCheck %s --check-prefix=X64
+
+define i8 @test_i8(i8 %a) nounwind {
+; X86-LABEL: test_i8:
+; X86:       # %bb.0:
+; X86-NEXT:    movb {{[0-9]+}}(%esp), %al
+; X86-NEXT:    movl %eax, %ecx
+; X86-NEXT:    sarb $7, %cl
+; X86-NEXT:    addb %cl, %al
+; X86-NEXT:    xorb %cl, %al
+; X86-NEXT:    retl
+;
+; X64-LABEL: test_i8:
+; X64:       # %bb.0:
+; X64-NEXT:    # kill: def $edi killed $edi def $rdi
+; X64-NEXT:    movl %edi, %ecx
+; X64-NEXT:    sarb $7, %cl
+; X64-NEXT:    leal (%rdi,%rcx), %eax
+; X64-NEXT:    xorb %cl, %al
+; X64-NEXT:    # kill: def $al killed $al killed $eax
+; X64-NEXT:    retq
+  %tmp1neg = sub i8 0, %a
+  %b = icmp sgt i8 %a, -1
+  %abs = select i1 %b, i8 %a, i8 %tmp1neg
+  ret i8 %abs
+}
+
+define i16 @test_i16(i16 %a) nounwind {
+; X86-NO-CMOV-LABEL: test_i16:
+; X86-NO-CMOV:       # %bb.0:
+; X86-NO-CMOV-NEXT:    movswl {{[0-9]+}}(%esp), %eax
+; X86-NO-CMOV-NEXT:    movl %eax, %ecx
+; X86-NO-CMOV-NEXT:    sarl $15, %ecx
+; X86-NO-CMOV-NEXT:    addl %ecx, %eax
+; X86-NO-CMOV-NEXT:    xorl %ecx, %eax
+; X86-NO-CMOV-NEXT:    # kill: def $ax killed $ax killed $eax
+; X86-NO-CMOV-NEXT:    retl
+;
+; X86-CMOV-LABEL: test_i16:
+; X86-CMOV:       # %bb.0:
+; X86-CMOV-NEXT:    movzwl {{[0-9]+}}(%esp), %ecx
+; X86-CMOV-NEXT:    movl %ecx, %eax
+; X86-CMOV-NEXT:    negw %ax
+; X86-CMOV-NEXT:    cmovlw %cx, %ax
+; X86-CMOV-NEXT:    retl
+;
+; X64-LABEL: test_i16:
+; X64:       # %bb.0:
+; X64-NEXT:    movl %edi, %eax
+; X64-NEXT:    negw %ax
+; X64-NEXT:    cmovlw %di, %ax
+; X64-NEXT:    retq
+  %tmp1neg = sub i16 0, %a
+  %b = icmp sgt i16 %a, -1
+  %abs = select i1 %b, i16 %a, i16 %tmp1neg
+  ret i16 %abs
+}
+
+define i32 @test_i32(i32 %a) nounwind {
+; X86-NO-CMOV-LABEL: test_i32:
+; X86-NO-CMOV:       # %bb.0:
+; X86-NO-CMOV-NEXT:    movl {{[0-9]+}}(%esp), %eax
+; X86-NO-CMOV-NEXT:    movl %eax, %ecx
+; X86-NO-CMOV-NEXT:    sarl $31, %ecx
+; X86-NO-CMOV-NEXT:    addl %ecx, %eax
+; X86-NO-CMOV-NEXT:    xorl %ecx, %eax
+; X86-NO-CMOV-NEXT:    retl
+;
+; X86-CMOV-LABEL: test_i32:
+; X86-CMOV:       # %bb.0:
+; X86-CMOV-NEXT:    movl {{[0-9]+}}(%esp), %ecx
+; X86-CMOV-NEXT:    movl %ecx, %eax
+; X86-CMOV-NEXT:    negl %eax
+; X86-CMOV-NEXT:    cmovll %ecx, %eax
+; X86-CMOV-NEXT:    retl
+;
+; X64-LABEL: test_i32:
+; X64:       # %bb.0:
+; X64-NEXT:    movl %edi, %eax
+; X64-NEXT:    negl %eax
+; X64-NEXT:    cmovll %edi, %eax
+; X64-NEXT:    retq
+  %tmp1neg = sub i32 0, %a
+  %b = icmp sgt i32 %a, -1
+  %abs = select i1 %b, i32 %a, i32 %tmp1neg
+  ret i32 %abs
+}
+
+define i64 @test_i64(i64 %a) nounwind {
+; X86-LABEL: test_i64:
+; X86:       # %bb.0:
+; X86-NEXT:    movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT:    movl %edx, %ecx
+; X86-NEXT:    sarl $31, %ecx
+; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
+; X86-NEXT:    addl %ecx, %eax
+; X86-NEXT:    adcl %ecx, %edx
+; X86-NEXT:    xorl %ecx, %edx
+; X86-NEXT:    xorl %ecx, %eax
+; X86-NEXT:    retl
+;
+; X64-LABEL: test_i64:
+; X64:       # %bb.0:
+; X64-NEXT:    movq %rdi, %rax
+; X64-NEXT:    negq %rax
+; X64-NEXT:    cmovlq %rdi, %rax
+; X64-NEXT:    retq
+  %tmp1neg = sub i64 0, %a
+  %b = icmp sgt i64 %a, -1
+  %abs = select i1 %b, i64 %a, i64 %tmp1neg
+  ret i64 %abs
+}

llvm/test/tools/UpdateTestChecks/update_llc_test_checks/basic.test

+# REQUIRES: x86-registered-target
+## Basic test checking that update_llc_test_checks.py can update a file with multiple check prefixes
+
+# RUN: cp -f %S/Inputs/basic.ll %t.ll && %update_llc_test_checks %t.ll
+# RUN: diff -u %S/Inputs/basic.ll.expected %t.ll
+## The flags --x86_scrub_rip and --extra_scrub should have any effect for this
+## test. Check the output is identical.
+# RUN: cp -f %S/Inputs/basic.ll %t.ll &&  %update_llc_test_checks --extra_scrub %t.ll
+# RUN: diff -u %S/Inputs/basic.ll.expected %t.ll
+# RUN: cp -f %S/Inputs/basic.ll %t.ll &&  %update_llc_test_checks --x86_scrub_rip %t.ll
+# RUN: diff -u %S/Inputs/basic.ll.expected %t.ll
+## Finally, run the script on an already updated file and verify that all previous
+## CHECK lines are removed.
+# RUN: %update_llc_test_checks %t.ll
+# RUN: diff -u %S/Inputs/basic.ll.expected %t.ll

llvm/test/tools/UpdateTestChecks/update_llc_test_checks/lit.local.cfg

+# These tests require llc.
+if 'llc-binary' not in config.available_features:
+    config.unsupported = True

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/basic.ll

+; Example input for update_llc_test_checks (taken from test/Transforms/InstSimplify/add.ll)
+; RUN: opt < %s -instsimplify -S | FileCheck %s
+
+define i32 @common_sub_operand(i32 %X, i32 %Y) {
+; CHECK-LABEL: @common_sub_operand(
+; CHECK-NEXT:    ret i32 [[X:%.*]]
+;
+  %Z = sub i32 %X, %Y
+  %Q = add i32 %Z, %Y
+  ret i32 %Q
+}
+
+define i32 @negated_operand(i32 %x) {
+; CHECK-LABEL: @negated_operand(
+; CHECK-NEXT:    ret i32 0
+;
+  %negx = sub i32 0, %x
+  %r = add i32 %negx, %x
+  ret i32 %r
+}
+
+define <2 x i32> @negated_operand_commute_vec(<2 x i32> %x) {
+; CHECK-LABEL: @negated_operand_commute_vec(
+; CHECK-NEXT:    ret <2 x i32> zeroinitializer
+;
+  %negx = sub <2 x i32> zeroinitializer, %x
+  %r = add <2 x i32> %x, %negx
+  ret <2 x i32> %r
+}
+
+define i8 @knownnegation(i8 %x, i8 %y) {
+; CHECK-LABEL: @knownnegation(
+; CHECK-NEXT:    ret i8 0
+;
+  %xy = sub i8 %x, %y
+  %yx = sub i8 %y, %x
+  %r = add i8 %xy, %yx
+  ret i8 %r
+}
+
+define <2 x i8> @knownnegation_commute_vec(<2 x i8> %x, <2 x i8> %y) {
+; CHECK-LABEL: @knownnegation_commute_vec(
+; CHECK-NEXT:    ret <2 x i8> zeroinitializer
+;
+  %xy = sub <2 x i8> %x, %y
+  %yx = sub <2 x i8> %y, %x
+  %r = add <2 x i8> %yx, %xy
+  ret <2 x i8> %r
+}

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/basic.ll.expected

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; Example input for update_llc_test_checks (taken from test/Transforms/InstSimplify/add.ll)
+; RUN: opt < %s -instsimplify -S | FileCheck %s
+
+define i32 @common_sub_operand(i32 %X, i32 %Y) {
+; CHECK-LABEL: @common_sub_operand(
+; CHECK-NEXT:    ret i32 [[X:%.*]]
+;
+  %Z = sub i32 %X, %Y
+  %Q = add i32 %Z, %Y
+  ret i32 %Q
+}
+
+define i32 @negated_operand(i32 %x) {
+; CHECK-LABEL: @negated_operand(
+; CHECK-NEXT:    ret i32 0
+;
+  %negx = sub i32 0, %x
+  %r = add i32 %negx, %x
+  ret i32 %r
+}
+
+define <2 x i32> @negated_operand_commute_vec(<2 x i32> %x) {
+; CHECK-LABEL: @negated_operand_commute_vec(
+; CHECK-NEXT:    ret <2 x i32> zeroinitializer
+;
+  %negx = sub <2 x i32> zeroinitializer, %x
+  %r = add <2 x i32> %x, %negx
+  ret <2 x i32> %r
+}
+
+define i8 @knownnegation(i8 %x, i8 %y) {
+; CHECK-LABEL: @knownnegation(
+; CHECK-NEXT:    ret i8 0
+;
+  %xy = sub i8 %x, %y
+  %yx = sub i8 %y, %x
+  %r = add i8 %xy, %yx
+  ret i8 %r
+}
+
+define <2 x i8> @knownnegation_commute_vec(<2 x i8> %x, <2 x i8> %y) {
+; CHECK-LABEL: @knownnegation_commute_vec(
+; CHECK-NEXT:    ret <2 x i8> zeroinitializer
+;
+  %xy = sub <2 x i8> %x, %y
+  %yx = sub <2 x i8> %y, %x
+  %r = add <2 x i8> %yx, %xy
+  ret <2 x i8> %r
+}

llvm/test/tools/UpdateTestChecks/update_test_checks/Inputs/basic.ll.funcsig.expected

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; Example input for update_llc_test_checks (taken from test/Transforms/InstSimplify/add.ll)
+; RUN: opt < %s -instsimplify -S | FileCheck %s
+
+define i32 @common_sub_operand(i32 %X, i32 %Y) {
+; CHECK-LABEL: define {{[^@]+}}@common_sub_operand
+; CHECK-SAME: (i32 [[X:%.*]], i32 [[Y:%.*]])
+; CHECK-NEXT:    ret i32 [[X:%.*]]
+;
+  %Z = sub i32 %X, %Y
+  %Q = add i32 %Z, %Y
+  ret i32 %Q
+}
+
+define i32 @negated_operand(i32 %x) {
+; CHECK-LABEL: define {{[^@]+}}@negated_operand
+; CHECK-SAME: (i32 [[X:%.*]])
+; CHECK-NEXT:    ret i32 0
+;
+  %negx = sub i32 0, %x
+  %r = add i32 %negx, %x
+  ret i32 %r
+}
+
+define <2 x i32> @negated_operand_commute_vec(<2 x i32> %x) {
+; CHECK-LABEL: define {{[^@]+}}@negated_operand_commute_vec
+; CHECK-SAME: (<2 x i32> [[X:%.*]])
+; CHECK-NEXT:    ret <2 x i32> zeroinitializer
+;
+  %negx = sub <2 x i32> zeroinitializer, %x
+  %r = add <2 x i32> %x, %negx
+  ret <2 x i32> %r
+}
+
+define i8 @knownnegation(i8 %x, i8 %y) {
+; CHECK-LABEL: define {{[^@]+}}@knownnegation
+; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]])
+; CHECK-NEXT:    ret i8 0
+;
+  %xy = sub i8 %x, %y
+  %yx = sub i8 %y, %x
+  %r = add i8 %xy, %yx
+  ret i8 %r
+}
+
+define <2 x i8> @knownnegation_commute_vec(<2 x i8> %x, <2 x i8> %y) {
+; CHECK-LABEL: define {{[^@]+}}@knownnegation_commute_vec
+; CHECK-SAME: (<2 x i8> [[X:%.*]], <2 x i8> [[Y:%.*]])
+; CHECK-NEXT:    ret <2 x i8> zeroinitializer
+;
+  %xy = sub <2 x i8> %x, %y
+  %yx = sub <2 x i8> %y, %x
+  %r = add <2 x i8> %yx, %xy
+  ret <2 x i8> %r
+}

llvm/test/tools/UpdateTestChecks/update_test_checks/basic.test

+# REQUIRES: x86-registered-target
+## Basic test checking that update_test_checks.py works correctly
+# RUN: cp -f %S/Inputs/basic.ll %t.ll && %update_test_checks %t.ll
+# RUN: diff -u %t.ll %S/Inputs/basic.ll.expected
+## Check that running the script again does not change the result:
+# RUN: %update_test_checks %t.ll
+# RUN: diff -u %t.ll %S/Inputs/basic.ll.expected
+## Also try the --function-signature flag
+# RUN: %update_test_checks %t.ll --function-signature
+# RUN: diff -u %t.ll %S/Inputs/basic.ll.funcsig.expected
+## Verify that running without the --function-signature flag removes the -SAME: lines:
+# RUN: %update_test_checks %t.ll
+# RUN: diff -u %t.ll %S/Inputs/basic.ll.expected

llvm/test/tools/UpdateTestChecks/update_test_checks/lit.local.cfg

+# These tests require llc.
+if 'opt-binary' not in config.available_features:
+    config.unsupported = True