; CHECK: store i64 2
; CHECK: load
-; CHECK; store i64 1
+; CHECK: store i64 1
store i64 2, i64* %ptr.64, align 8
%r = load i64, i64* %either_ptr.64, align 8
; CHECK-NEXT: ldr [[BLOCKBASE:x[0-9]+]], {{\[}}[[ADDR]]]
; CHECK-NEXT: ldrb [[BLOCKVAL1:w[0-9]+]], {{\[}}[[BLOCKBASE]], w0, sxtw]
; CHECK-NEXT: ldrb [[BLOCKVAL2:w[0-9]+]], {{\[}}[[BLOCKBASE]], w1, sxtw]
-; CHECK-NEXT cmp [[BLOCKVAL1]], [[BLOCKVAL2]]
-; CHECK-NEXT b.ne
+; CHECK-NEXT: cmp [[BLOCKVAL1]], [[BLOCKVAL2]]
+; CHECK-NEXT: b.ne
; Next BB
; CHECK: add [[BLOCKBASE2:x[0-9]+]], [[BLOCKBASE]], w1, sxtw
; CHECK-NEXT: add [[BLOCKBASE1:x[0-9]+]], [[BLOCKBASE]], w0, sxtw
%cnt = tail call i32 @llvm.ctpop.i32(i32 %x)
ret i32 %cnt
; CHECK-LABEL: cnt32:
-; CHECK-NOT 16b
+; CHECK-NOT: 16b
; CHECK: ret
}
%cnt = tail call i64 @llvm.ctpop.i64(i64 %x)
ret i64 %cnt
; CHECK-LABEL: cnt64:
-; CHECK-NOT 16b
+; CHECK-NOT: 16b
; CHECK: ret
}
; ...
; CHECK-NOT: add sp,
; CHECK: vpop {d6, d7, d8, d9}
-; CHECKL pop {r[[GLOBREG]], pc}
+; CHECK: pop {r[[GLOBREG]], pc}
; iOS uses aligned NEON stores here, which is convenient since we
; want to make sure that works too.
declare void @bar(<4 x i32>)
-; CHECK-LABEL @foo
+; CHECK-LABEL: @foo
define void @foo(<4 x i32> %a) {
; CHECK: st.param.v4.b32
tail call void @bar(<4 x i32> %a)
}
; CHECK-LABEL: @main
-; CHECK-DAG li 4, 0
+; CHECK-DAG: li 4, 0
; CHECK-DAG: crxor 6, 6, 6
; CHECK: bl printf
%shr2 = lshr i32 %mul, 5
ret i32 %shr2
-; CHECK-LABEL @foo
+; CHECK-LABEL: @foo
; CHECK-NOT: rldicl 3, {{[0-9]+}}, 0, 32
; CHECK: blr
}
%or = or i32 %shr, %shl
ret i32 %or
-; CHECK-LABEL @test6
+; CHECK-LABEL: @test6
; CHECK-NOT: rldicl 3, {{[0-9]+}}, 0, 32
; CHECK: blr
}
%cond = select i1 %cmp, i32 %a, i32 %b
ret i32 %cond
-; CHECK-LABEL @min
+; CHECK-LABEL: @min
; CHECK-NOT: rldicl 3, {{[0-9]+}}, 0, 32
; CHECK: blr
}
%div = sdiv i32 %a, 8
ret i32 %div
-; CHECK-LABEL @foo4
+; CHECK-LABEL: @foo4
; CHECK: srawi [[REG1:[0-9]+]], 3, 3
; CHECK: addze [[REG2:[0-9]+]], [[REG1]]
; CHECK: extsw 3, [[REG2]]
%div = sdiv i64 %a, 8
ret i64 %div
-; CHECK-LABEL @foo8
+; CHECK-LABEL: @foo8
; CHECK: sradi [[REG1:[0-9]+]], 3, 3
; CHECK: addze 3, [[REG1]]
; CHECK: blr
-; CHECK-32-LABEL @foo8
+; CHECK-32-LABEL: @foo8
; CHECK-32-NOT: sradi
; CHECK-32: blr
}
; CHECK: neg 3, [[REG2]]
; CHECK: blr
-; CHECK-32-LABEL @foo8n
+; CHECK-32-LABEL: @foo8n
; CHECK-32-NOT: sradi
; CHECK-32: blr
}
%result = add <1 x i128> %x, <i128 1>
ret <1 x i128> %result
; CHECK-LABEL: @increment_by_one
-; CHECK vadduqm 2, 2, 3
+; CHECK: vadduqm 2, 2, 3
}
define <1 x i128> @increment_by_val(<1 x i128> %x, i128 %val) nounwind {
%result = sub <1 x i128> %x, <i128 1>
ret <1 x i128> %result
; CHECK-LABEL: @decrement_by_one
-; CHECK vsubuqm 2, 2, 3
+; CHECK: vsubuqm 2, 2, 3
}
define <1 x i128> @decrement_by_val(<1 x i128> %x, i128 %val) nounwind {
%result = sub <1 x i128> %x, %tmpvec2
ret <1 x i128> %result
; CHECK-LABEL: @decrement_by_val
-; CHECK vsubuqm 2, 2, 3
+; CHECK: vsubuqm 2, 2, 3
}
declare <1 x i128> @llvm.ppc.altivec.vaddeuqm(<1 x i128> %x,
; CHECK: .note.gc
; CHECK-NEXT: .align 8
; safe point count
-; CHECK .short 1
-; CHECK .long .Ltmp0
+; CHECK: .short 1
+; CHECK: .long .Ltmp0
; stack frame size (in words)
-; CHECK .short -1
+; CHECK: .short -1
; stack arity (arguments on the stack)
-; CHECK .short 0
+; CHECK: .short 0
; live root count
-; CHECK .short 0
+; CHECK: .short 0
; CHECK-LABEL: @_Dmain
; CHECK: load i8, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i32 0, i32 0)
-; CHECK ret
+; CHECK: ret
define fastcc i32 @_Dmain(%"char[][]" %unnamed) {
entry:
%tmp = getelementptr [7 x i8], [7 x i8]* @.str, i32 0, i32 0 ; <i8*> [#uses=1]
; CHECK-LABEL: test1:
; %arg lives in xmm0 and it shouldn't be redefined until it is used in the FMA.
-; CHECK-NOT {{.*}}, %xmm0
+; CHECK-NOT: {{.*}}, %xmm0
; %addr lives in rdi.
; %addr2 lives in rsi.
; CHECK: vmovss (%rsi), [[ADDR2:%xmm[0-9]+]]
; CHECK-NOT: , [[CPY1]]
; CHECK: punpcklbw [[CPY2]], [[CPY2]]
; CHECK-NEXT: punpckhwd [[CPY2]], [[CPY2]]
-; CHECK-NEXT pslld $31, [[CPY2]]
+; CHECK-NEXT: pslld $31, [[CPY2]]
; Check that CPY1 is not redefined.
; CHECK-NOT: , [[CPY1]]
; CHECK: punpcklbw [[CPY1]], [[CPY1]]
; CHECK-NEXT: punpcklwd [[CPY1]], [[CPY1]]
-; CHECK-NEXT pslld $31, [[CPY1]]
+; CHECK-NEXT: pslld $31, [[CPY1]]
define <16 x float> @foo(<16 x float> %x) {
bb:
%v3 = icmp slt <16 x i32> undef, zeroinitializer
normal_return:
; CHECK-LABEL: %normal_return
; CHECK: cmoveq {{.*}}[[REGVAL2]]{{.*}}
- ; CHECK retq
+ ; CHECK: retq
%a1 = phi i64 addrspace(1)* [%val1.relocated, %left.relocs], [%val3.relocated, %right.relocs]
%a2 = phi i64 addrspace(1)* [%val2.relocated_left, %left.relocs], [%val2.relocated_right, %right.relocs]
%ret = select i1 %cond, i64 addrspace(1)* %a1, i64 addrspace(1)* %a2
Check ObjC specific accelerators.
CHECK: .apple_objc contents:
CHECK: Name{{.*}}"TestInterface"
-CHECK-NOT Name
+CHECK-NOT: Name
CHECK: {Atom[0]: [[READONLY]]}
CHECK: {Atom[0]: [[ASSIGN]]}
CHECK: {Atom[0]: [[SETASSIGN]]}
//CHECK-V8: vqrdmlsh.f32 q3, q4, q5
//CHECK-V8: ^
//CHECK-V8: error: invalid operand for instruction
-//CHECK-V8 vqrdmlsh.f64 d3, d5, d5
+//CHECK-V8: vqrdmlsh.f64 d3, d5, d5
//CHECK-V8: ^
vqrdmlah.s16 d0, d1, d2
ifcc4 %eax, %ecx ## test
ifcc4 %ecx, %eax ## test
-// CHECK-NOT movl
+// CHECK-NOT: movl
// CHECK: subl $1, %esp
.set cc,0
ifcc movl, %esp, %ebp
ifcc4 %eax %ecx ## test
ifcc4 %ecx, %eax ## test
-// CHECK-NOT movl
+// CHECK-NOT: movl
// CHECK: subl $1, %esp
.set cc,0
ifcc movl %esp, %ebp
; Convert to setne int %X, 12
%c = icmp ne i32 %A, 12 ; <i1> [#uses=1]
ret i1 %c
-; CHECK-LABEL @test1(
+; CHECK-LABEL: @test1(
; CHECK: %c = icmp ne i32 %X, 12
; CHECK: ret i1 %c
}
; Convert to setne int %X, %Y
%c = icmp ne i32 %A, %B ; <i1> [#uses=1]
ret i1 %c
-; CHECK-LABEL @test2(
+; CHECK-LABEL: @test2(
; CHECK: %c = icmp ne i32 %X, %Y
; CHECK: ret i1 %c
}
; CHECK-LABEL: @test19(
; CHECK-NEXT: icmp eq i32 %x, 1
; CHECK-NEXT: zext i1 %{{.*}} to i32
-; CHECK-NEXT ret i32
+; CHECK-NEXT: ret i32
}
define i32 @test20(i32 %x) {
%D = and i39 %V, 274877906943
%R = or i39 %B, %D
ret i39 %R
-; CHECK-LABEL @test1
+; CHECK-LABEL: @test1
; CHECK-NEXT: and {{.*}}, -274877906944
; CHECK-NEXT: add
; CHECK-NEXT: ret
%D = and i399 %V, 274877906943
%R = or i399 %B, %D
ret i399 %R
-; CHECK-LABEL @test2
+; CHECK-LABEL: @test2
; CHECK-NEXT: and {{.*}}, 18446742974197923840
; CHECK-NEXT: add
; CHECK-NEXT: ret
define i1 @cmp_no_range(i8*, i8*) {
; CHECK-LABEL: @cmp_no_range
-; CHECK-NEXT %v1 = load i8, i8* %0
-; CHECK-NEXT %v2 = load i8, i8* %1
-; CHECK-NEXT %out = icmp eq i8 %v1, %v2
-; CHECK-NEXT ret i1 %out
+; CHECK-NEXT: %v1 = load i8, i8* %0
+; CHECK-NEXT: %v2 = load i8, i8* %1
+; CHECK-NEXT: %out = icmp eq i8 %v1, %v2
+; CHECK-NEXT: ret i1 %out
%v1 = load i8, i8* %0
%v2 = load i8, i8* %1
%out = icmp eq i8 %v1, %v2
; The two va_arg instructions depend on the memory/context, are therfore not
; identical and the sub should not be optimized to 0 by reassociate.
;
-; CHECK-LABEL @func(
+; CHECK-LABEL: @func(
; ...
; CHECK: %v0 = va_arg i8** %varargs, i32
; CHECK: %v1 = va_arg i8** %varargs, i32
; CHECK: phi i8 addrspace(1)*
; CHECK-DAG: %outer-loop ]
; CHECK-DAG: [ %arg2.relocated, %inner-loop ]
-; CHECKL phi i8 addrspace(1)*
+; CHECK: phi i8 addrspace(1)*
; CHECK-DAG: %outer-loop ]
; CHECK-DAG: [ %arg1.relocated, %inner-loop ]
; CHECK: gc.statepoint
declare void @ctor(%struct.X*)
define void @test10(%struct.X* noalias sret %agg.result, i1 zeroext %b) {
-; CHECK-LABEL @test10
+; CHECK-LABEL: @test10
entry:
%x = alloca %struct.X, align 8
br i1 %b, label %if.then, label %if.end
CHECK: DW_AT_location [DW_FORM_data4] (0x00000025)
CHECK: DW_TAG_lexical_block [14] *
CHECK: DW_AT_low_pc [DW_FORM_addr] (0x0000000100000f94)
-CHECK DW_AT_high_pc [DW_FORM_addr] (0x0000000100000fa7)
+CHECK: DW_AT_high_pc [DW_FORM_addr] (0x0000000100000fa7)
CHECK: DW_TAG_inlined_subroutine [15]
CHECK: DW_AT_abstract_origin [DW_FORM_ref4] (cu + 0x009a => {0x000001d4} "inc")
CHECK: DW_AT_ranges [DW_FORM_data4] (0x00000000