Regen some old tests; NFC

[goldstein.w.n]

Summary

Just so we can make future changes with update_llc_test_checks.py

[RKSimon]

llvm/test/CodeGen/ARM/sub-cmp-peephole.ll

4

These need cleaning up - duplicate RUN, and I think you can have a common CHECK prefix as well

; RUN: llc < %s -mtriple=arm-apple-darwin | FileCheck %s --check-prefixes=CHECK,V7
; RUN: llc < %s -mtriple=armv8-none-linux-gnueabi | FileCheck %s --check-prefixes=CHECK,V8

87

remove these

[goldstein.w.n]

Rebase + put before isKnownNonZero patch

[RKSimon]

llvm/test/CodeGen/ARM/sub-cmp-peephole.ll

8

Where has the V7 coverage gone?

[goldstein.w.n]

llvm/test/CodeGen/ARM/sub-cmp-peephole.ll

8

Where has the V7 coverage gone?

I think there is a bug somewhere. -mtriple=arm-apple-darwin simply does not generate automatic checks. Guess drop this one from regen and update it by hand in the known-non-zero patch?

[goldstein.w.n]

Rebase

[RKSimon]

llvm/test/CodeGen/ARM/sub-cmp-peephole.ll

8

Sure, or update it manually here (remove the extra RUN etc.) - as long as you remove the NOTE from the top then it should be fine.

[craig.topper]

llvm/test/CodeGen/ARM/sub-cmp-peephole.ll

8

I wonder if the triple should be armv7-apple-darwin which has an override in get_run_handler llvm/utils/UpdateTestChecks/asm.py. That override defines the regular expression to convert between IR function name and assembly function name.

[RKSimon]

llvm/test/CodeGen/ARM/sub-cmp-peephole.ll

8

Probably - in which case we need to add the original arm-apple-darwin RUN line back again to retain coverage and we still can't auto generate it :)

[RKSimon]

llvm/test/CodeGen/ARM/sub-cmp-peephole.ll

4

There's nothing darwin specific - so I think using this should be fine:

; RUN: llc < %s -mtriple=arm-none | FileCheck %s
; RUN: llc < %s -mtriple=armv7-none-linux-gnueabi | FileCheck %s --check-prefixes=V78,V7
; RUN: llc < %s -mtriple=armv8-none-linux-gnueabi | FileCheck %s -check-prefixes=V78,V8

@dmgreen Any comments?

[dmgreen]

llvm/test/CodeGen/ARM/sub-cmp-peephole.ll

4

Yeah, that sounds OK to me.

[goldstein.w.n]

Update target so tests autogen

[goldstein.w.n]

n/a

[dmgreen]

Thanks. LGTM

[RKSimon]

LGTM cheers

[goldstein.w.n]

Rebase

[goldstein.w.n]

rebase

[goldstein.w.n]

Since the motivating patch was abandoned, abandoning this.

llvm/test/CodeGen/AArch64/cmp-const-max.ll

+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --version 2
 ; RUN: llc -verify-machineinstrs -aarch64-enable-atomic-cfg-tidy=0 < %s -mtriple=aarch64-none-eabihf -fast-isel=false | FileCheck %s
 
 
 define i32 @ule_64_max(i64 %p) {
-entry:
 ; CHECK-LABEL: ule_64_max:
-; CHECK: cmn x0, #1
-; CHECK: b.hi [[RET_ZERO:.LBB[0-9]+_[0-9]+]]
+; CHECK:       // %bb.0: // %entry
+; CHECK-NEXT:    cmn x0, #1
+; CHECK-NEXT:    b.hi .LBB0_2
+; CHECK-NEXT:  // %bb.1: // %ret_one
+; CHECK-NEXT:    mov w0, #1 // =0x1
+; CHECK-NEXT:    ret
+; CHECK-NEXT:  .LBB0_2: // %ret_zero
+; CHECK-NEXT:    mov w0, wzr
+; CHECK-NEXT:    ret
+entry:
   %cmp = icmp ule i64 %p, 18446744073709551615 ; 0xffffffffffffffff
   br i1 %cmp, label %ret_one, label %ret_zero
 
 ret_one:
   ret i32 1
 
 ret_zero:
-; CHECK: [[RET_ZERO]]:
-; CHECK-NEXT: mov w0, wzr
   ret i32 0
 }
 
 define i32 @ugt_64_max(i64 %p) {
-entry:
 ; CHECK-LABEL: ugt_64_max:
-; CHECK: cmn x0, #1
-; CHECK: b.ls [[RET_ZERO:.LBB[0-9]+_[0-9]+]]
+; CHECK:       // %bb.0: // %entry
+; CHECK-NEXT:    cmn x0, #1
+; CHECK-NEXT:    b.ls .LBB1_2
+; CHECK-NEXT:  // %bb.1: // %ret_one
+; CHECK-NEXT:    mov w0, #1 // =0x1
+; CHECK-NEXT:    ret
+; CHECK-NEXT:  .LBB1_2: // %ret_zero
+; CHECK-NEXT:    mov w0, wzr
+; CHECK-NEXT:    ret
+entry:
   %cmp = icmp ugt i64 %p, 18446744073709551615 ; 0xffffffffffffffff
   br i1 %cmp, label %ret_one, label %ret_zero
 
 ret_one:
   ret i32 1
 
 ret_zero:
-; CHECK: [[RET_ZERO]]:
-; CHECK-NEXT: mov w0, wzr
   ret i32 0
 }

llvm/test/CodeGen/ARM/sub-cmp-peephole.ll

+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --version 2
 ; RUN: llc < %s -mtriple=arm-apple-darwin | FileCheck %s
 ; RUN: llc < %s -mtriple=arm-apple-darwin | FileCheck %s --check-prefix=V7
 ; RUN: llc < %s -mtriple=armv8-none-linux-gnueabi | FileCheck %s -check-prefix=V8
 
 
 define i32 @f(i32 %a, i32 %b) nounwind ssp {
+; V8-LABEL: f:
+; V8:       @ %bb.0: @ %entry
+; V8-NEXT:    subs r0, r0, r1
+; V8-NEXT:    movle r0, #0
+; V8-NEXT:    bx lr
 entry:
-; CHECK-LABEL: f:
-; CHECK: subs
-; CHECK-NOT: cmp
   %cmp = icmp sgt i32 %a, %b
   %sub = sub nsw i32 %a, %b
   %sub. = select i1 %cmp, i32 %sub, i32 0
   ret i32 %sub.
 }
 
 define i32 @g(i32 %a, i32 %b) nounwind ssp {
+; V8-LABEL: g:
+; V8:       @ %bb.0: @ %entry
+; V8-NEXT:    subs r0, r1, r0
+; V8-NEXT:    movle r0, #0
+; V8-NEXT:    bx lr
 entry:
-; CHECK-LABEL: g:
-; CHECK: subs
-; CHECK-NOT: cmp
   %cmp = icmp slt i32 %a, %b
   %sub = sub nsw i32 %b, %a
   %sub. = select i1 %cmp, i32 %sub, i32 0
   ret i32 %sub.
 }
 
 define i32 @h(i32 %a, i32 %b) nounwind ssp {
+; V8-LABEL: h:
+; V8:       @ %bb.0: @ %entry
+; V8-NEXT:    subs r0, r0, #3
+; V8-NEXT:    movle r0, r1
+; V8-NEXT:    bx lr
 entry:
-; CHECK-LABEL: h:
-; CHECK: subs
-; CHECK-NOT: cmp
   %cmp = icmp sgt i32 %a, 3
   %sub = sub nsw i32 %a, 3
   %sub. = select i1 %cmp, i32 %sub, i32 %b
   ret i32 %sub.
 }
 
 ; rdar://11725965
 define i32 @i(i32 %a, i32 %b) nounwind readnone ssp {
+; V8-LABEL: i:
+; V8:       @ %bb.0: @ %entry
+; V8-NEXT:    subs r0, r1, r0
+; V8-NEXT:    movls r0, #0
+; V8-NEXT:    bx lr
 entry:
-; CHECK-LABEL: i:
-; CHECK: subs
-; CHECK-NOT: cmp
   %cmp = icmp ult i32 %a, %b
   %sub = sub i32 %b, %a
   %sub. = select i1 %cmp, i32 %sub, i32 0
   ret i32 %sub.
 }
 ; If CPSR is live-out, we can't remove cmp if there exists
 ; a swapped sub.
 define i32 @j(i32 %a, i32 %b) nounwind {
+; V8-LABEL: j:
+; V8:       @ %bb.0: @ %entry
+; V8-NEXT:    subs r1, r0, r1
+; V8-NEXT:    movlt r0, r1
+; V8-NEXT:    movne r0, r1
+; V8-NEXT:    bx lr
 entry:
-; CHECK-LABEL: j:
-; CHECK: sub
-; CHECK: cmp
   %cmp = icmp eq i32 %b, %a
   %sub = sub nsw i32 %a, %b
   br i1 %cmp, label %if.then, label %if.else
 
 if.then:
   %cmp2 = icmp sgt i32 %b, %a
   %sel = select i1 %cmp2, i32 %sub, i32 %a
   ret i32 %sel
 
 if.else:
   ret i32 %sub
 }
 
 ; If the sub/rsb instruction is predicated, we can't use the flags.
 ; <rdar://problem/12263428>
 ; Test case from MultiSource/Benchmarks/Ptrdist/bc/number.s
 ; CHECK: bc_raise
 ; CHECK: rsbeq
 ; CHECK: cmp
 define i32 @bc_raise(i1 %cond) nounwind ssp {
+; V8-LABEL: bc_raise:
+; V8:       @ %bb.0: @ %entry
+; V8-NEXT:    mov r1, #1
+; V8-NEXT:    tst r0, #1
+; V8-NEXT:    bic r1, r1, r0
+; V8-NEXT:    mov r0, #23
+; V8-NEXT:    rsbeq r1, r1, #0
+; V8-NEXT:    cmp r1, #0
+; V8-NEXT:    movweq r0, #17
+; V8-NEXT:    bx lr
 entry:
   %val.2.i = select i1 %cond, i32 0, i32 1
   %sub.i = sub nsw i32 0, %val.2.i
   %retval.0.i = select i1 %cond, i32 %val.2.i, i32 %sub.i
   %cmp1 = icmp eq i32 %retval.0.i, 0
   br i1 %cmp1, label %land.lhs.true, label %if.end11
 
 land.lhs.true:                                    ; preds = %num2long.exit
   ret i32 17
 
 if.end11:                                         ; preds = %num2long.exit
   ret i32 23
 }
 
 ; When considering the producer of cmp's src as the subsuming instruction,
 ; only consider that when the comparison is to 0.
 define i32 @cmp_src_nonzero(i32 %a, i32 %b, i32 %x, i32 %y) {
+; V8-LABEL: cmp_src_nonzero:
+; V8:       @ %bb.0: @ %entry
+; V8-NEXT:    sub r0, r0, r1
+; V8-NEXT:    cmp r0, #17
+; V8-NEXT:    movne r2, r3
+; V8-NEXT:    mov r0, r2
+; V8-NEXT:    bx lr
 entry:
-; CHECK-LABEL: cmp_src_nonzero:
-; CHECK: sub
-; CHECK: cmp
   %sub = sub i32 %a, %b
   %cmp = icmp eq i32 %sub, 17
   %ret = select i1 %cmp, i32 %x, i32 %y
   ret i32 %ret
 }
 
 define float @float_sel(i32 %a, i32 %b, float %x, float %y) {
-entry:
-; CHECK-LABEL: float_sel:
-; CHECK-NOT: cmp
 ; V8-LABEL: float_sel:
-; V8-NOT: cmp
-; V8: vseleq.f32
+; V8:       @ %bb.0: @ %entry
+; V8-NEXT:    vmov s0, r3
+; V8-NEXT:    subs r0, r0, r1
+; V8-NEXT:    vmov s2, r2
+; V8-NEXT:    vseleq.f32 s0, s2, s0
+; V8-NEXT:    vmov r0, s0
+; V8-NEXT:    bx lr
+entry:
   %sub = sub i32 %a, %b
   %cmp = icmp eq i32 %sub, 0
   %ret = select i1 %cmp, float %x, float %y
   ret float %ret
 }
 
 define double @double_sel(i32 %a, i32 %b, double %x, double %y) {
-entry:
-; CHECK-LABEL: double_sel:
-; CHECK-NOT: cmp
 ; V8-LABEL: double_sel:
-; V8-NOT: cmp
-; V8: vseleq.f64
+; V8:       @ %bb.0: @ %entry
+; V8-NEXT:    vldr d16, [sp]
+; V8-NEXT:    vmov d17, r2, r3
+; V8-NEXT:    subs r0, r0, r1
+; V8-NEXT:    vseleq.f64 d16, d17, d16
+; V8-NEXT:    vmov r0, r1, d16
+; V8-NEXT:    bx lr
+entry:
   %sub = sub i32 %a, %b
   %cmp = icmp eq i32 %sub, 0
   %ret = select i1 %cmp, double %x, double %y
   ret double %ret
 }
 
 @t = common global i32 0
 define double @double_sub(i32 %a, i32 %b, double %x, double %y) {
-entry:
-; CHECK-LABEL: double_sub:
-; CHECK: subs
-; CHECK-NOT: cmp
 ; V8-LABEL: double_sub:
-; V8: vsel
+; V8:       @ %bb.0: @ %entry
+; V8-NEXT:    vldr d16, [sp]
+; V8-NEXT:    cmp r0, r1
+; V8-NEXT:    vmov d17, r2, r3
+; V8-NEXT:    sub r0, r0, r1
+; V8-NEXT:    vselgt.f64 d16, d17, d16
+; V8-NEXT:    movw r1, :lower16:t
+; V8-NEXT:    vmov r2, r3, d16
+; V8-NEXT:    movt r1, :upper16:t
+; V8-NEXT:    str r0, [r1]
+; V8-NEXT:    mov r0, r2
+; V8-NEXT:    mov r1, r3
+; V8-NEXT:    bx lr
+entry:
   %cmp = icmp sgt i32 %a, %b
   %sub = sub i32 %a, %b
   store i32 %sub, ptr @t
   %ret = select i1 %cmp, double %x, double %y
   ret double %ret
 }
 
 define double @double_sub_swap(i32 %a, i32 %b, double %x, double %y) {
-entry:
-; V7-LABEL: double_sub_swap:
-; V7-NOT: cmp
-; V7: subs
 ; V8-LABEL: double_sub_swap:
-; V8-NOT: subs
-; V8: cmp
-; V8: vsel
+; V8:       @ %bb.0: @ %entry
+; V8-NEXT:    vldr d16, [sp]
+; V8-NEXT:    cmp r1, r0
+; V8-NEXT:    vmov d17, r2, r3
+; V8-NEXT:    sub r0, r1, r0
+; V8-NEXT:    vselge.f64 d16, d16, d17
+; V8-NEXT:    movw r1, :lower16:t
+; V8-NEXT:    vmov r2, r3, d16
+; V8-NEXT:    movt r1, :upper16:t
+; V8-NEXT:    str r0, [r1]
+; V8-NEXT:    mov r0, r2
+; V8-NEXT:    mov r1, r3
+; V8-NEXT:    bx lr
+entry:
   %cmp = icmp sgt i32 %a, %b
   %sub = sub i32 %b, %a
   %ret = select i1 %cmp, double %x, double %y
   store i32 %sub, ptr @t
   ret double %ret
 }
 
 declare void @abort()
 declare void @exit(i32)
 
 ; If the comparison uses the V bit (signed overflow/underflow), we can't
 ; omit the comparison.
 define i32 @cmp_slt0(i32 %a, i32 %b, i32 %x, i32 %y) {
+; V8-LABEL: cmp_slt0:
+; V8:       @ %bb.0: @ %entry
+; V8-NEXT:    .save {r11, lr}
+; V8-NEXT:    push {r11, lr}
+; V8-NEXT:    movw r0, :lower16:t
+; V8-NEXT:    movt r0, :upper16:t
+; V8-NEXT:    ldr r0, [r0]
+; V8-NEXT:    sub r0, r0, #17
+; V8-NEXT:    cmn r0, #1
+; V8-NEXT:    ble .LBB11_2
+; V8-NEXT:  @ %bb.1: @ %if.else
+; V8-NEXT:    mov r0, #0
+; V8-NEXT:    bl exit
+; V8-NEXT:  .LBB11_2: @ %if.then
+; V8-NEXT:    bl abort
 entry:
-; CHECK-LABEL: cmp_slt0
-; CHECK: sub
-; CHECK: cmn
-; CHECK: ble
   %load = load i32, ptr @t, align 4
   %sub = sub i32 %load, 17
   %cmp = icmp slt i32 %sub, 0
   br i1 %cmp, label %if.then, label %if.else
 
 if.then:
   call void @abort()
   unreachable
 
 if.else:
   call void @exit(i32 0)
   unreachable
 }
 
 ; Same for the C bit. (Note the ult X, 0 is trivially
 ; false, so the DAG combiner may or may not optimize it).
 define i32 @cmp_ult0(i32 %a, i32 %b, i32 %x, i32 %y) {
+; V8-LABEL: cmp_ult0:
+; V8:       @ %bb.0: @ %entry
+; V8-NEXT:    .save {r11, lr}
+; V8-NEXT:    push {r11, lr}
+; V8-NEXT:    movw r0, :lower16:t
+; V8-NEXT:    movt r0, :upper16:t
+; V8-NEXT:    ldr r0, [r0]
+; V8-NEXT:    sub r0, r0, #17
+; V8-NEXT:    cmp r0, #0
+; V8-NEXT:    bhs .LBB12_2
+; V8-NEXT:  @ %bb.1: @ %if.then
+; V8-NEXT:    bl abort
+; V8-NEXT:  .LBB12_2: @ %if.else
+; V8-NEXT:    mov r0, #0
+; V8-NEXT:    bl exit
 entry:
-; CHECK-LABEL: cmp_ult0
-; CHECK: sub
-; CHECK: cmp
-; CHECK: bhs
   %load = load i32, ptr @t, align 4
   %sub = sub i32 %load, 17
   %cmp = icmp ult i32 %sub, 0
   br i1 %cmp, label %if.then, label %if.else
 
 if.then:
   call void @abort()
   unreachable
 
 if.else:
   call void @exit(i32 0)
   unreachable
 }
+;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
+; CHECK: {{.*}}
+; V7: {{.*}}

llvm/test/CodeGen/SystemZ/int-cmp-46.ll

+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --version 2
 ; Test the use of TEST UNDER MASK for 32-bit operations.
 ;
 ; RUN: llc < %s -mtriple=s390x-linux-gnu -mcpu=z196 | FileCheck %s
 
 @g = global i32 0
 
 ; Check the lowest useful TMLL value.
 define void @f1(i32 %a) {
 ; CHECK-LABEL: f1:
-; CHECK: tmll %r2, 1
-; CHECK: ber %r14
-; CHECK: br %r14
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    tmll %r2, 1
+; CHECK-NEXT:    ber %r14
+; CHECK-NEXT:  .LBB0_1: # %store
+; CHECK-NEXT:    lgrl %r1, g@GOT
+; CHECK-NEXT:    mvhi 0(%r1), 1
+; CHECK-NEXT:    br %r14
 entry:
   %and = and i32 %a, 1
   %cmp = icmp eq i32 %and, 0
   br i1 %cmp, label %exit, label %store
 
 store:
   store i32 1, ptr@g
   br label %exit
 
 exit:
   ret void
 }
 
 ; Check the high end of the TMLL range.
 define void @f2(i32 %a) {
 ; CHECK-LABEL: f2:
-; CHECK: tmll %r2, 65535
-; CHECK: bner %r14
-; CHECK: br %r14
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    tmll %r2, 65535
+; CHECK-NEXT:    bner %r14
+; CHECK-NEXT:  .LBB1_1: # %store
+; CHECK-NEXT:    lgrl %r1, g@GOT
+; CHECK-NEXT:    mvhi 0(%r1), 1
+; CHECK-NEXT:    br %r14
 entry:
   %and = and i32 %a, 65535
   %cmp = icmp ne i32 %and, 0
   br i1 %cmp, label %exit, label %store
 
 store:
   store i32 1, ptr@g
   br label %exit
 
 exit:
   ret void
 }
 
 ; Check the lowest useful TMLH value, which is the next value up.
 define void @f3(i32 %a) {
 ; CHECK-LABEL: f3:
-; CHECK: tmlh %r2, 1
-; CHECK: bner %r14
-; CHECK: br %r14
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    tmlh %r2, 1
+; CHECK-NEXT:    bner %r14
+; CHECK-NEXT:  .LBB2_1: # %store
+; CHECK-NEXT:    lgrl %r1, g@GOT
+; CHECK-NEXT:    mvhi 0(%r1), 1
+; CHECK-NEXT:    br %r14
 entry:
   %and = and i32 %a, 65536
   %cmp = icmp ne i32 %and, 0
   br i1 %cmp, label %exit, label %store
 
 store:
   store i32 1, ptr@g
   br label %exit
 
 exit:
   ret void
 }
 
 ; Check the next value up again, which cannot use TM.
 define void @f4(i32 %a) {
 ; CHECK-LABEL: f4:
-; CHECK-NOT: {{tm[lh].}}
-; CHECK: br %r14
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    nilh %r2, 65534
+; CHECK-NEXT:    cibe %r2, 0, 0(%r14)
+; CHECK-NEXT:  .LBB3_1: # %store
+; CHECK-NEXT:    lgrl %r1, g@GOT
+; CHECK-NEXT:    mvhi 0(%r1), 1
+; CHECK-NEXT:    br %r14
 entry:
   %and = and i32 %a, 4294901759
   %cmp = icmp eq i32 %and, 0
   br i1 %cmp, label %exit, label %store
 
 store:
   store i32 1, ptr@g
   br label %exit
 
 exit:
   ret void
 }
 
 ; Check the high end of the TMLH range.
 define void @f5(i32 %a) {
 ; CHECK-LABEL: f5:
-; CHECK: tmlh %r2, 65535
-; CHECK: ber %r14
-; CHECK: br %r14
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    tmlh %r2, 65535
+; CHECK-NEXT:    ber %r14
+; CHECK-NEXT:  .LBB4_1: # %store
+; CHECK-NEXT:    lgrl %r1, g@GOT
+; CHECK-NEXT:    mvhi 0(%r1), 1
+; CHECK-NEXT:    br %r14
 entry:
   %and = and i32 %a, 4294901760
   %cmp = icmp eq i32 %and, 0
   br i1 %cmp, label %exit, label %store
 
 store:
   store i32 1, ptr@g
   br label %exit
 
 exit:
   ret void
 }
 
 ; Check that we can use TMLL for LT comparisons that are equivalent to
 ; an equality comparison with zero.
 define void @f6(i32 %a) {
 ; CHECK-LABEL: f6:
-; CHECK: tmll %r2, 240
-; CHECK: ber %r14
-; CHECK: br %r14
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    tmll %r2, 240
+; CHECK-NEXT:    ber %r14
+; CHECK-NEXT:  .LBB5_1: # %store
+; CHECK-NEXT:    lgrl %r1, g@GOT
+; CHECK-NEXT:    mvhi 0(%r1), 1
+; CHECK-NEXT:    br %r14
 entry:
   %and = and i32 %a, 240
   %cmp = icmp slt i32 %and, 16
   br i1 %cmp, label %exit, label %store
 
 store:
   store i32 1, ptr@g
   br label %exit
 
 exit:
   ret void
 }
 
 ; ...same again with LE.
 define void @f7(i32 %a) {
 ; CHECK-LABEL: f7:
-; CHECK: tmll %r2, 240
-; CHECK: ber %r14
-; CHECK: br %r14
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    tmll %r2, 240
+; CHECK-NEXT:    ber %r14
+; CHECK-NEXT:  .LBB6_1: # %store
+; CHECK-NEXT:    lgrl %r1, g@GOT
+; CHECK-NEXT:    mvhi 0(%r1), 1
+; CHECK-NEXT:    br %r14
 entry:
   %and = and i32 %a, 240
   %cmp = icmp sle i32 %and, 15
   br i1 %cmp, label %exit, label %store
 
 store:
   store i32 1, ptr@g
   br label %exit
 
 exit:
   ret void
 }
 
 ; Check that we can use TMLL for GE comparisons that are equivalent to
 ; an inequality comparison with zero.
 define void @f8(i32 %a) {
 ; CHECK-LABEL: f8:
-; CHECK: tmll %r2, 240
-; CHECK: bner %r14
-; CHECK: br %r14
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    tmll %r2, 240
+; CHECK-NEXT:    bner %r14
+; CHECK-NEXT:  .LBB7_1: # %store
+; CHECK-NEXT:    lgrl %r1, g@GOT
+; CHECK-NEXT:    mvhi 0(%r1), 1
+; CHECK-NEXT:    br %r14
 entry:
   %and = and i32 %a, 240
   %cmp = icmp uge i32 %and, 16
   br i1 %cmp, label %exit, label %store
 
 store:
   store i32 1, ptr@g
   br label %exit
 
 exit:
   ret void
 }
 
 ; ...same again with GT.
 define void @f9(i32 %a) {
 ; CHECK-LABEL: f9:
-; CHECK: tmll %r2, 240
-; CHECK: bner %r14
-; CHECK: br %r14
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    tmll %r2, 240
+; CHECK-NEXT:    bner %r14
+; CHECK-NEXT:  .LBB8_1: # %store
+; CHECK-NEXT:    lgrl %r1, g@GOT
+; CHECK-NEXT:    mvhi 0(%r1), 1
+; CHECK-NEXT:    br %r14
 entry:
   %and = and i32 %a, 240
   %cmp = icmp ugt i32 %and, 15
   br i1 %cmp, label %exit, label %store
 
 store:
   store i32 1, ptr@g
   br label %exit
 
 exit:
   ret void
 }
 
 ; Check that we can use TMLL for LT comparisons that effectively
 ; test whether the top bit is clear.
 define void @f10(i32 %a) {
 ; CHECK-LABEL: f10:
-; CHECK: tmll %r2, 35
-; CHECK: bler %r14
-; CHECK: br %r14
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    tmll %r2, 35
+; CHECK-NEXT:    bler %r14
+; CHECK-NEXT:  .LBB9_1: # %store
+; CHECK-NEXT:    lgrl %r1, g@GOT
+; CHECK-NEXT:    mvhi 0(%r1), 1
+; CHECK-NEXT:    br %r14
 entry:
   %and = and i32 %a, 35
   %cmp = icmp ult i32 %and, 8
   br i1 %cmp, label %exit, label %store
 
 store:
   store i32 1, ptr@g
   br label %exit
 
 exit:
   ret void
 }
 
 ; ...same again with LE.
 define void @f11(i32 %a) {
 ; CHECK-LABEL: f11:
-; CHECK: tmll %r2, 35
-; CHECK: bler %r14
-; CHECK: br %r14
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    tmll %r2, 35
+; CHECK-NEXT:    bler %r14
+; CHECK-NEXT:  .LBB10_1: # %store
+; CHECK-NEXT:    lgrl %r1, g@GOT
+; CHECK-NEXT:    mvhi 0(%r1), 1
+; CHECK-NEXT:    br %r14
 entry:
   %and = and i32 %a, 35
   %cmp = icmp ule i32 %and, 31
   br i1 %cmp, label %exit, label %store
 
 store:
   store i32 1, ptr@g
   br label %exit
 
 exit:
   ret void
 }
 
 ; Check that we can use TMLL for GE comparisons that effectively test
 ; whether the top bit is set.
 define void @f12(i32 %a) {
 ; CHECK-LABEL: f12:
-; CHECK: tmll %r2, 140
-; CHECK: bnler %r14
-; CHECK: br %r14
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    tmll %r2, 140
+; CHECK-NEXT:    bnler %r14
+; CHECK-NEXT:  .LBB11_1: # %store
+; CHECK-NEXT:    lgrl %r1, g@GOT
+; CHECK-NEXT:    mvhi 0(%r1), 1
+; CHECK-NEXT:    br %r14
 entry:
   %and = and i32 %a, 140
   %cmp = icmp uge i32 %and, 128
   br i1 %cmp, label %exit, label %store
 
 store:
   store i32 1, ptr@g
   br label %exit
 
 exit:
   ret void
 }
 
 ; ...same again for GT.
 define void @f13(i32 %a) {
 ; CHECK-LABEL: f13:
-; CHECK: tmll %r2, 140
-; CHECK: bnler %r14
-; CHECK: br %r14
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    tmll %r2, 140
+; CHECK-NEXT:    bnler %r14
+; CHECK-NEXT:  .LBB12_1: # %store
+; CHECK-NEXT:    lgrl %r1, g@GOT
+; CHECK-NEXT:    mvhi 0(%r1), 1
+; CHECK-NEXT:    br %r14
 entry:
   %and = and i32 %a, 140
   %cmp = icmp ugt i32 %and, 126
   br i1 %cmp, label %exit, label %store
 
 store:
   store i32 1, ptr@g
   br label %exit
 
 exit:
   ret void
 }
 
 ; Check that we can use TMLL for equality comparisons with the mask.
 define void @f14(i32 %a) {
 ; CHECK-LABEL: f14:
-; CHECK: tmll %r2, 101
-; CHECK: bor %r14
-; CHECK: br %r14
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    tmll %r2, 101
+; CHECK-NEXT:    bor %r14
+; CHECK-NEXT:  .LBB13_1: # %store
+; CHECK-NEXT:    lgrl %r1, g@GOT
+; CHECK-NEXT:    mvhi 0(%r1), 1
+; CHECK-NEXT:    br %r14
 entry:
   %and = and i32 %a, 101
   %cmp = icmp eq i32 %and, 101
   br i1 %cmp, label %exit, label %store
 
 store:
   store i32 1, ptr@g
   br label %exit
 
 exit:
   ret void
 }
 
 ; Check that we can use TMLL for inequality comparisons with the mask.
 define void @f15(i32 %a) {
 ; CHECK-LABEL: f15:
-; CHECK: tmll %r2, 65519
-; CHECK: bnor %r14
-; CHECK: br %r14
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    tmll %r2, 65519
+; CHECK-NEXT:    bnor %r14
+; CHECK-NEXT:  .LBB14_1: # %store
+; CHECK-NEXT:    lgrl %r1, g@GOT
+; CHECK-NEXT:    mvhi 0(%r1), 1
+; CHECK-NEXT:    br %r14
 entry:
   %and = and i32 %a, 65519
   %cmp = icmp ne i32 %and, 65519
   br i1 %cmp, label %exit, label %store
 
 store:
   store i32 1, ptr@g
   br label %exit
 
 exit:
   ret void
 }
 
 ; Check that we can use TMLL for LT comparisons that are equivalent
 ; to inequality comparisons with the mask.
 define void @f16(i32 %a) {
 ; CHECK-LABEL: f16:
-; CHECK: tmll %r2, 130
-; CHECK: bnor %r14
-; CHECK: br %r14
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    tmll %r2, 130
+; CHECK-NEXT:    bnor %r14
+; CHECK-NEXT:  .LBB15_1: # %store
+; CHECK-NEXT:    lgrl %r1, g@GOT
+; CHECK-NEXT:    mvhi 0(%r1), 1
+; CHECK-NEXT:    br %r14
 entry:
   %and = and i32 %a, 130
   %cmp = icmp ult i32 %and, 129
   br i1 %cmp, label %exit, label %store
 
 store:
   store i32 1, ptr@g
   br label %exit
 
 exit:
   ret void
 }
 
 ; ...same again with LE.
 define void @f17(i32 %a) {
 ; CHECK-LABEL: f17:
-; CHECK: tmll %r2, 130
-; CHECK: bnor %r14
-; CHECK: br %r14
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    tmll %r2, 130
+; CHECK-NEXT:    bnor %r14
+; CHECK-NEXT:  .LBB16_1: # %store
+; CHECK-NEXT:    lgrl %r1, g@GOT
+; CHECK-NEXT:    mvhi 0(%r1), 1
+; CHECK-NEXT:    br %r14
 entry:
   %and = and i32 %a, 130
   %cmp = icmp ule i32 %and, 128
   br i1 %cmp, label %exit, label %store
 
 store:
   store i32 1, ptr@g
   br label %exit
 
 exit:
   ret void
 }
 
 ; Check that we can use TMLL for GE comparisons that are equivalent
 ; to equality comparisons with the mask.
 define void @f18(i32 %a) {
 ; CHECK-LABEL: f18:
-; CHECK: tmll %r2, 194
-; CHECK: bor %r14
-; CHECK: br %r14
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    tmll %r2, 194
+; CHECK-NEXT:    bor %r14
+; CHECK-NEXT:  .LBB17_1: # %store
+; CHECK-NEXT:    lgrl %r1, g@GOT
+; CHECK-NEXT:    mvhi 0(%r1), 1
+; CHECK-NEXT:    br %r14
 entry:
   %and = and i32 %a, 194
   %cmp = icmp uge i32 %and, 193
   br i1 %cmp, label %exit, label %store
 
 store:
   store i32 1, ptr@g
   br label %exit
 
 exit:
   ret void
 }
 
 ; ...same again for GT.
 define void @f19(i32 %a) {
 ; CHECK-LABEL: f19:
-; CHECK: tmll %r2, 194
-; CHECK: bor %r14
-; CHECK: br %r14
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    tmll %r2, 194
+; CHECK-NEXT:    bor %r14
+; CHECK-NEXT:  .LBB18_1: # %store
+; CHECK-NEXT:    lgrl %r1, g@GOT
+; CHECK-NEXT:    mvhi 0(%r1), 1
+; CHECK-NEXT:    br %r14
 entry:
   %and = and i32 %a, 194
   %cmp = icmp ugt i32 %and, 192
   br i1 %cmp, label %exit, label %store
 
 store:
   store i32 1, ptr@g
   br label %exit
 
 exit:
   ret void
 }
 
 ; Check that we can use TMLL for equality comparisons for the low bit
 ; when the mask has two bits.
 define void @f20(i32 %a) {
 ; CHECK-LABEL: f20:
-; CHECK: tmll %r2, 20
-; CHECK: blr %r14
-; CHECK: br %r14
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    tmll %r2, 20
+; CHECK-NEXT:    blr %r14
+; CHECK-NEXT:  .LBB19_1: # %store
+; CHECK-NEXT:    lgrl %r1, g@GOT
+; CHECK-NEXT:    mvhi 0(%r1), 1
+; CHECK-NEXT:    br %r14
 entry:
   %and = and i32 %a, 20
   %cmp = icmp eq i32 %and, 4
   br i1 %cmp, label %exit, label %store
 
 store:
   store i32 1, ptr@g
   br label %exit
 
 exit:
   ret void
 }
 
 ; Check that we can use TMLL for inequality comparisons for the low bit
 ; when the mask has two bits.
 define void @f21(i32 %a) {
 ; CHECK-LABEL: f21:
-; CHECK: tmll %r2, 20
-; CHECK: bnlr %r14
-; CHECK: br %r14
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    tmll %r2, 20
+; CHECK-NEXT:    bnlr %r14
+; CHECK-NEXT:  .LBB20_1: # %store
+; CHECK-NEXT:    lgrl %r1, g@GOT
+; CHECK-NEXT:    mvhi 0(%r1), 1
+; CHECK-NEXT:    br %r14
 entry:
   %and = and i32 %a, 20
   %cmp = icmp ne i32 %and, 4
   br i1 %cmp, label %exit, label %store
 
 store:
   store i32 1, ptr@g
   br label %exit
 
 exit:
   ret void
 }
 
 ; Check that we can use TMLL for equality comparisons for the high bit
 ; when the mask has two bits.
 define void @f22(i32 %a) {
 ; CHECK-LABEL: f22:
-; CHECK: tmll %r2, 20
-; CHECK: bhr %r14
-; CHECK: br %r14
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    tmll %r2, 20
+; CHECK-NEXT:    bhr %r14
+; CHECK-NEXT:  .LBB21_1: # %store
+; CHECK-NEXT:    lgrl %r1, g@GOT
+; CHECK-NEXT:    mvhi 0(%r1), 1
+; CHECK-NEXT:    br %r14
 entry:
   %and = and i32 %a, 20
   %cmp = icmp eq i32 %and, 16
   br i1 %cmp, label %exit, label %store
 
 store:
   store i32 1, ptr@g
   br label %exit
 
 exit:
   ret void
 }
 
 ; Check that we can use TMLL for inequality comparisons for the high bit
 ; when the mask has two bits.
 define void @f23(i32 %a) {
 ; CHECK-LABEL: f23:
-; CHECK: tmll %r2, 20
-; CHECK: bnhr %r14
-; CHECK: br %r14
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    tmll %r2, 20
+; CHECK-NEXT:    bnhr %r14
+; CHECK-NEXT:  .LBB22_1: # %store
+; CHECK-NEXT:    lgrl %r1, g@GOT
+; CHECK-NEXT:    mvhi 0(%r1), 1
+; CHECK-NEXT:    br %r14
 entry:
   %and = and i32 %a, 20
   %cmp = icmp ne i32 %and, 16
   br i1 %cmp, label %exit, label %store
 
 store:
   store i32 1, ptr@g
   br label %exit
 
 exit:
   ret void
 }
 
 ; Check that we can fold an SHL into a TMxx mask.
 define void @f24(i32 %a) {
 ; CHECK-LABEL: f24:
-; CHECK: tmll %r2, 255
-; CHECK: bner %r14
-; CHECK: br %r14
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    tmll %r2, 255
+; CHECK-NEXT:    bner %r14
+; CHECK-NEXT:  .LBB23_1: # %store
+; CHECK-NEXT:    lgrl %r1, g@GOT
+; CHECK-NEXT:    mvhi 0(%r1), 1
+; CHECK-NEXT:    br %r14
 entry:
   %shl = shl i32 %a, 12
   %and = and i32 %shl, 1044480
   %cmp = icmp ne i32 %and, 0
   br i1 %cmp, label %exit, label %store
 
 store:
   store i32 1, ptr@g
   br label %exit
 
 exit:
   ret void
 }
 
 ; Check that we can fold an SHR into a TMxx mask.
 define void @f25(i32 %a) {
 ; CHECK-LABEL: f25:
-; CHECK: tmlh %r2, 512
-; CHECK: bner %r14
-; CHECK: br %r14
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    tmlh %r2, 512
+; CHECK-NEXT:    bner %r14
+; CHECK-NEXT:  .LBB24_1: # %store
+; CHECK-NEXT:    lgrl %r1, g@GOT
+; CHECK-NEXT:    mvhi 0(%r1), 1
+; CHECK-NEXT:    br %r14
 entry:
   %shr = lshr i32 %a, 25
   %and = and i32 %shr, 1
   %cmp = icmp ne i32 %and, 0
   br i1 %cmp, label %exit, label %store
 
 store:
   store i32 1, ptr@g
   br label %exit
 
 exit:
   ret void
 }

llvm/test/CodeGen/X86/2012-08-17-legalizer-crash.ll

+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --version 2
 ; RUN: llc < %s | FileCheck %s
 ; Check that an overly large immediate created by SROA doesn't crash the
 ; legalizer.
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.8.0"
 
 %struct._GtkSheetRow = type { ptr, i32, i32, i32, %struct._GtkSheetButton, i32, i32 }
 %struct._GtkSheetButton = type { i32, ptr, i32, ptr, i32 }
 
 @a = common global ptr null, align 8
 
 define void @fn1() nounwind uwtable ssp {
+; CHECK-LABEL: fn1:
+; CHECK:       ## %bb.0: ## %entry
+; CHECK-NEXT:    pushq %rbx
+; CHECK-NEXT:    .cfi_def_cfa_offset 16
+; CHECK-NEXT:    .cfi_offset %rbx, -16
+; CHECK-NEXT:    movq _a@GOTPCREL(%rip), %rax
+; CHECK-NEXT:    movq (%rax), %rax
+; CHECK-NEXT:    movq 64(%rax), %rcx
+; CHECK-NEXT:    xorl %edx, %edx
+; CHECK-NEXT:    movabsq $4294967296, %rsi ## imm = 0x100000000
+; CHECK-NEXT:    cmpq %rsi, %rcx
+; CHECK-NEXT:    movl $0, %esi
+; CHECK-NEXT:    sbbq %rsi, %rsi
+; CHECK-NEXT:    movl $0, %esi
+; CHECK-NEXT:    sbbq %rsi, %rsi
+; CHECK-NEXT:    movl $0, %esi
+; CHECK-NEXT:    sbbq %rsi, %rsi
+; CHECK-NEXT:    movl $0, %esi
+; CHECK-NEXT:    sbbq %rsi, %rsi
+; CHECK-NEXT:    movl $0, %esi
+; CHECK-NEXT:    sbbq %rsi, %rsi
+; CHECK-NEXT:    movl $0, %esi
+; CHECK-NEXT:    sbbq %rsi, %rsi
+; CHECK-NEXT:    sbbq %rdx, %rdx
+; CHECK-NEXT:    jb LBB0_2
+; CHECK-NEXT:  ## %bb.1: ## %if.then
+; CHECK-NEXT:    movq 56(%rax), %rdx
+; CHECK-NEXT:    movq 48(%rax), %rsi
+; CHECK-NEXT:    movq 40(%rax), %rdi
+; CHECK-NEXT:    movq 32(%rax), %r8
+; CHECK-NEXT:    movq 24(%rax), %r9
+; CHECK-NEXT:    movq 16(%rax), %r10
+; CHECK-NEXT:    movq (%rax), %r11
+; CHECK-NEXT:    movq 8(%rax), %rbx
+; CHECK-NEXT:    movq %r11, (%rax)
+; CHECK-NEXT:    movq %rbx, 8(%rax)
+; CHECK-NEXT:    movq %r10, 16(%rax)
+; CHECK-NEXT:    movq %r9, 24(%rax)
+; CHECK-NEXT:    movq %r8, 32(%rax)
+; CHECK-NEXT:    movq %rdi, 40(%rax)
+; CHECK-NEXT:    movq %rsi, 48(%rax)
+; CHECK-NEXT:    movq %rdx, 56(%rax)
+; CHECK-NEXT:    movq %rcx, 64(%rax)
+; CHECK-NEXT:  LBB0_2: ## %if.end
+; CHECK-NEXT:    popq %rbx
+; CHECK-NEXT:    retq
 entry:
   %0 = load ptr, ptr @a, align 8
   %srcval2 = load i576, ptr %0, align 8
   %tobool = icmp ugt i576 %srcval2, 57586096570152913699974892898380567793532123114264532903689671329431521032595044740083720782129802971518987656109067457577065805510327036019308994315074097345724415
   br i1 %tobool, label %if.then, label %if.end
 
 if.then:                                          ; preds = %entry
   store i576 %srcval2, ptr %0, align 8
   br label %if.end
 
 if.end:                                           ; preds = %if.then, %entry
   ret void
 
-; CHECK-LABEL: fn1:
-; CHECK: jb
 }