Convert lit tests to check disassembled assembly.

tests_lit/llvm2ice_tests/64bit.pnacl.ll

 ; This tries to be a comprehensive test of i64 operations, in
 ; particular the patterns for lowering i64 operations into constituent
 ; i32 operations on x86-32.
 
-; RUN: %llvm2ice -O2 --verbose none %s | FileCheck %s
-; RUN: %llvm2ice -Om1 --verbose none %s | FileCheck --check-prefix=OPTM1 %s
+; TODO(jvoung): remove -ffunction-sections. Sadly... diassembling some
+; "ret" within a section are broken in llvm-objdump for LLVM 3.4, and 3.5.
+; It was only fixed in 3.6.

[jvoung (off chromium), 2014/08/28 17:31:07]

Okay, I think the reason such a sad bug existed for so long is that usually
Linux, etc. would align function starts.  If you do align the function starts,
then the ret will disassemble correctly, as well as the nop padding that follows
it.

So, I think I'll send out a separate CL to align function starts, since NaCl
also aligns function starts. Then I'll remove these hacks.

[jvoung (off chromium), 2014/08/29 00:51:20]

Done.

+; TODO(jvoung): fix extra "CALLTARGETS" run. The llvm-objdump symbolizer
+; doesn't know how to symbolize non-section-local functions.
+; The newer LLVM 3.6 one does work, but watch out for other bugs.
+
 ; RUN: %llvm2ice -O2 --verbose none %s \
-; RUN:     | llvm-mc -triple=i686-none-nacl -x86-asm-syntax=intel -filetype=obj
-; RUN: %llvm2ice -Om1 --verbose none %s \
-; RUN:     | llvm-mc -triple=i686-none-nacl -x86-asm-syntax=intel -filetype=obj
+; RUN:   | FileCheck --check-prefix=CALLTARGETS %s
+; RUN: %llvm2ice -O2 --verbose none -ffunction-sections %s \
+; RUN:   | llvm-mc -triple=i686-none-nacl -x86-asm-syntax=intel -filetype=obj \
+; RUN:   | llvm-objdump -d --symbolize -x86-asm-syntax=intel - | FileCheck %s
+; RUN: %llvm2ice -Om1 --verbose none -ffunction-sections %s \
+; RUN:   | llvm-mc -triple=i686-none-nacl -x86-asm-syntax=intel -filetype=obj \
+; RUN:   | llvm-objdump -d --symbolize -x86-asm-syntax=intel - \
+; RUN:   | FileCheck --check-prefix=OPTM1 %s
 ; RUN: %llvm2ice --verbose none %s | FileCheck --check-prefix=ERRORS %s
 ; RUN: %llvm2iceinsts %s | %szdiff %s | FileCheck --check-prefix=DUMP %s
 ; RUN: %llvm2iceinsts --pnacl %s | %szdiff %s \
 ; RUN:                           | FileCheck --check-prefix=DUMP %s
 
 @__init_array_start = internal constant [0 x i8] zeroinitializer, align 4
 @__fini_array_start = internal constant [0 x i8] zeroinitializer, align 4
 @__tls_template_start = internal constant [0 x i8] zeroinitializer, align 8
 @__tls_template_alignment = internal constant [4 x i8] c"\01\00\00\00", align 4
 
 define internal i32 @ignore64BitArg(i64 %a, i32 %b, i64 %c) {
 entry:
   ret i32 %b
 }
 
 define internal i32 @pass64BitArg(i64 %a, i64 %b, i64 %c, i64 %d, i64 %e, i64 %f) {
 entry:
   %call = call i32 @ignore64BitArgNoInline(i64 %a, i32 123, i64 %b)
   %call1 = call i32 @ignore64BitArgNoInline(i64 %c, i32 123, i64 %d)
   %call2 = call i32 @ignore64BitArgNoInline(i64 %e, i32 123, i64 %f)
   %add = add i32 %call1, %call
   %add3 = add i32 %add, %call2
   ret i32 %add3
 }
 ; CHECK-LABEL: pass64BitArg
 ; CHECK:      sub     esp
-; CHECK:      mov     dword ptr [esp+4]
+; CHECK:      mov     dword ptr [esp + 4]
 ; CHECK:      mov     dword ptr [esp]
-; CHECK:      mov     dword ptr [esp+8], 123
-; CHECK:      mov     dword ptr [esp+16]
-; CHECK:      mov     dword ptr [esp+12]
-; CHECK:      call    ignore64BitArgNoInline
-; CHECK       sub     esp

[Jim Stichnoth, 2014/08/28 20:19:23]

Even though this line was wrong ("CHECK" instead of "CHECK:"), did it miss being
converted to the new format?

[jvoung (off chromium), 2014/08/29 00:51:20]

Oops, must have accidentally overwritten it with the new CALLTARGETS line.
Fixed.

-; CHECK:      mov     dword ptr [esp+4]
+; CHECK:      mov     dword ptr [esp + 8], 123
+; CHECK:      mov     dword ptr [esp + 16]
+; CHECK:      mov     dword ptr [esp + 12]
+; CHECK:      call    -4
+; CALLTARGETS-LABEL: pass64BitArg

[Jim Stichnoth, 2014/08/28 20:19:23]

Would it be clearer to move this -LABEL up with the CHECK-LABEL?

[jvoung (off chromium), 2014/08/29 00:51:20]

Done.

[Jim Stichnoth, 2014/08/29 16:40:49]

Thanks.  I should have said that this comment applies to pretty much all
CALLTARGETS-LABEL instances in all files. :)

[jvoung (off chromium), 2014/08/29 19:27:48]

Done.

+; CALLTARGETS: call ignore64BitArgNoInline
+; CHECK:      mov     dword ptr [esp + 4]
 ; CHECK:      mov     dword ptr [esp]
-; CHECK:      mov     dword ptr [esp+8], 123
-; CHECK:      mov     dword ptr [esp+16]
-; CHECK:      mov     dword ptr [esp+12]
-; CHECK:      call    ignore64BitArgNoInline
+; CHECK:      mov     dword ptr [esp + 8], 123
+; CHECK:      mov     dword ptr [esp + 16]
+; CHECK:      mov     dword ptr [esp + 12]
+; CHECK:      call    -4
+; CALLTARGETS: call ignore64BitArgNoInline
 ; CHECK:      sub     esp
-; CHECK:      mov     dword ptr [esp+4]
+; CHECK:      mov     dword ptr [esp + 4]
 ; CHECK:      mov     dword ptr [esp]
-; CHECK:      mov     dword ptr [esp+8], 123
-; CHECK:      mov     dword ptr [esp+16]
-; CHECK:      mov     dword ptr [esp+12]
-; CHECK:      call    ignore64BitArgNoInline
+; CHECK:      mov     dword ptr [esp + 8], 123
+; CHECK:      mov     dword ptr [esp + 16]
+; CHECK:      mov     dword ptr [esp + 12]
+; CHECK:      call    -4
+; CALLTARGETS: call ignore64BitArgNoInline
 ;
 ; OPTM1-LABEL: pass64BitArg
 ; OPTM1:      sub     esp
-; OPTM1:      mov     dword ptr [esp+4]
+; OPTM1:      mov     dword ptr [esp + 4]
 ; OPTM1:      mov     dword ptr [esp]
-; OPTM1:      mov     dword ptr [esp+8], 123
-; OPTM1:      mov     dword ptr [esp+16]
-; OPTM1:      mov     dword ptr [esp+12]
-; OPTM1:      call    ignore64BitArgNoInline
-; OPTM1       sub     esp
-; OPTM1:      mov     dword ptr [esp+4]
+; OPTM1:      mov     dword ptr [esp + 8], 123
+; OPTM1:      mov     dword ptr [esp + 16]
+; OPTM1:      mov     dword ptr [esp + 12]
+; OPTM1:      call    -4
+; OPTM1:      sub     esp
+; OPTM1:      mov     dword ptr [esp + 4]
 ; OPTM1:      mov     dword ptr [esp]
-; OPTM1:      mov     dword ptr [esp+8], 123
-; OPTM1:      mov     dword ptr [esp+16]
-; OPTM1:      mov     dword ptr [esp+12]
-; OPTM1:      call    ignore64BitArgNoInline
+; OPTM1:      mov     dword ptr [esp + 8], 123
+; OPTM1:      mov     dword ptr [esp + 16]
+; OPTM1:      mov     dword ptr [esp + 12]
+; OPTM1:      call    -4
 ; OPTM1:      sub     esp
-; OPTM1:      mov     dword ptr [esp+4]
+; OPTM1:      mov     dword ptr [esp + 4]
 ; OPTM1:      mov     dword ptr [esp]
-; OPTM1:      mov     dword ptr [esp+8], 123
-; OPTM1:      mov     dword ptr [esp+16]
-; OPTM1:      mov     dword ptr [esp+12]
-; OPTM1:      call    ignore64BitArgNoInline
+; OPTM1:      mov     dword ptr [esp + 8], 123
+; OPTM1:      mov     dword ptr [esp + 16]
+; OPTM1:      mov     dword ptr [esp + 12]
+; OPTM1:      call    -4
 
 declare i32 @ignore64BitArgNoInline(i64, i32, i64)
 
 define internal i32 @pass64BitConstArg(i64 %a, i64 %b) {
 entry:
   %call = call i32 @ignore64BitArgNoInline(i64 %a, i32 123, i64 -2401053092306725256)
   ret i32 %call
 }
 ; CHECK-LABEL: pass64BitConstArg
 ; CHECK:      sub     esp
-; CHECK:      mov     dword ptr [esp+4]
+; CHECK:      mov     dword ptr [esp + 4]
 ; CHECK-NEXT: mov     dword ptr [esp]
-; CHECK-NEXT: mov     dword ptr [esp+8], 123
-; CHECK-NEXT: mov     dword ptr [esp+16], 3735928559
-; CHECK-NEXT: mov     dword ptr [esp+12], 305419896
-; CHECK-NEXT: call    ignore64BitArgNoInline
+; CHECK-NEXT: mov     dword ptr [esp + 8], 123
+; Bundle padding added by -triple=i686-none-nacl.

[Jim Stichnoth, 2014/08/28 20:19:23]

It would be nice if there were a way to match "zero or more" consecutive nop
instructions, but I don't know how...

[jvoung (off chromium), 2014/08/29 00:51:20]

Acknowledged. Not sure how either =(

+; CHECK-NEXT: nop
+; CHECK-NEXT: mov     dword ptr [esp + 16], 3735928559
+; CHECK-NEXT: mov     dword ptr [esp + 12], 305419896
+; CHECK-NEXT: call    -4
+; CALLTARGETS-LABEL: pass64BitConstArg
+; CALLTARGETS: call ignore64BitArgNoInline
 ;
 ; OPTM1-LABEL: pass64BitConstArg
 ; OPTM1:      sub     esp
-; OPTM1:      mov     dword ptr [esp+4]
+; OPTM1:      mov     dword ptr [esp + 4]
 ; OPTM1-NEXT: mov     dword ptr [esp]
-; OPTM1-NEXT: mov     dword ptr [esp+8], 123
-; OPTM1-NEXT: mov     dword ptr [esp+16], 3735928559
-; OPTM1-NEXT: mov     dword ptr [esp+12], 305419896
-; OPTM1-NEXT: call    ignore64BitArgNoInline
+; OPTM1-NEXT: mov     dword ptr [esp + 8], 123
+; Bundle padding added by -triple=i686-none-nacl.
+; OPTM1-NEXT: nop
+; OPTM1-NEXT: mov     dword ptr [esp + 16], 3735928559
+; OPTM1-NEXT: mov     dword ptr [esp + 12], 305419896
+; OPTM1-NEXT: call    -4
 
 define internal i64 @return64BitArg(i64 %a) {
 entry:
   ret i64 %a
 }
 ; CHECK-LABEL: return64BitArg
-; CHECK: mov     {{.*}}, dword ptr [esp+4]
-; CHECK: mov     {{.*}}, dword ptr [esp+8]
+; CHECK: mov     {{.*}}, dword ptr [esp + 4]
+; CHECK: mov     {{.*}}, dword ptr [esp + 8]
 ; CHECK: ret
 ;
 ; OPTM1-LABEL: return64BitArg
-; OPTM1: mov     {{.*}}, dword ptr [esp+4]
-; OPTM1: mov     {{.*}}, dword ptr [esp+8]
+; OPTM1: mov     {{.*}}, dword ptr [esp + 4]
+; OPTM1: mov     {{.*}}, dword ptr [esp + 8]
 ; OPTM1: ret
 
 define internal i64 @return64BitConst() {
 entry:
   ret i64 -2401053092306725256
 }
 ; CHECK-LABEL: return64BitConst
 ; CHECK: mov     eax, 305419896
 ; CHECK: mov     edx, 3735928559
 ; CHECK: ret
@@ skipping 104 matching lines @@
 ; OPTM1: add
 ; OPTM1: add
 ; OPTM1: ret
 
 define internal i64 @div64BitSigned(i64 %a, i64 %b) {
 entry:
   %div = sdiv i64 %a, %b
   ret i64 %div
 }
 ; CHECK-LABEL: div64BitSigned
-; CHECK: call    __divdi3
+; CHECK: call    -4
 ; CHECK: ret
+; CALLTARGETS-LABEL: div64BitSigned
+; CALLTARGETS: call __divdi3
 ;
 ; OPTM1-LABEL: div64BitSigned
-; OPTM1: call    __divdi3
+; OPTM1: call    -4
 ; OPTM1: ret
 
 define internal i64 @div64BitSignedConst(i64 %a) {
 entry:
   %div = sdiv i64 %a, 12345678901234
   ret i64 %div
 }
 ; CHECK-LABEL: div64BitSignedConst
-; CHECK: mov     dword ptr [esp+12], 2874
-; CHECK: mov     dword ptr [esp+8],  1942892530
-; CHECK: call    __divdi3
+; CHECK: mov     dword ptr [esp + 12], 2874
+; CHECK: mov     dword ptr [esp + 8],  1942892530
+; CHECK: call    -4
 ; CHECK: ret
+; CALLTARGETS-LABEL: div64BitSignedConst
+; CALLTARGETS: call __divdi3
 ;
 ; OPTM1-LABEL: div64BitSignedConst
-; OPTM1: mov     dword ptr [esp+12], 2874
-; OPTM1: mov     dword ptr [esp+8],  1942892530
-; OPTM1: call    __divdi3
+; OPTM1: mov     dword ptr [esp + 12], 2874
+; OPTM1: mov     dword ptr [esp + 8],  1942892530
+; OPTM1: call    -4
 ; OPTM1: ret
 
 define internal i64 @div64BitUnsigned(i64 %a, i64 %b) {
 entry:
   %div = udiv i64 %a, %b
   ret i64 %div
 }
 ; CHECK-LABEL: div64BitUnsigned
-; CHECK: call    __udivdi3
+; CHECK: call    -4
 ; CHECK: ret
+; CALLTARGETS-LABEL: div64BitUnsigned
+; CALLTARGETS: call __udivdi3
 ;
 ; OPTM1-LABEL: div64BitUnsigned
-; OPTM1: call    __udivdi3
+; OPTM1: call    -4
 ; OPTM1: ret
 
 define internal i64 @rem64BitSigned(i64 %a, i64 %b) {
 entry:
   %rem = srem i64 %a, %b
   ret i64 %rem
 }
 ; CHECK-LABEL: rem64BitSigned
-; CHECK: call    __moddi3
+; CHECK: call    -4
 ; CHECK: ret
+; CALLTARGETS-LABEL: rem64BitSigned
+; CALLTARGETS: call __moddi3
 ;
 ; OPTM1-LABEL: rem64BitSigned
-; OPTM1: call    __moddi3
+; OPTM1: call    -4
 ; OPTM1: ret
 
 define internal i64 @rem64BitUnsigned(i64 %a, i64 %b) {
 entry:
   %rem = urem i64 %a, %b
   ret i64 %rem
 }
 ; CHECK-LABEL: rem64BitUnsigned
-; CHECK: call    __umoddi3
+; CHECK: call    -4
 ; CHECK: ret
+; CALLTARGETS-LABEL: rem64BitUnsigned
+; CALLTARGETS: call __umoddi3
 ;
 ; OPTM1-LABEL: rem64BitUnsigned
-; OPTM1: call    __umoddi3
+; OPTM1: call    -4
 ; OPTM1: ret
 
 define internal i64 @shl64BitSigned(i64 %a, i64 %b) {
 entry:
   %shl = shl i64 %a, %b
   ret i64 %shl
 }
 ; CHECK-LABEL: shl64BitSigned
 ; CHECK: shld
 ; CHECK: shl e
@@ skipping 136 matching lines @@
 ; OPTM1-LABEL: xor64BitUnsigned
 ; OPTM1: xor
 ; OPTM1: xor
 
 define internal i32 @trunc64To32Signed(i64 %a) {
 entry:
   %conv = trunc i64 %a to i32
   ret i32 %conv
 }
 ; CHECK-LABEL: trunc64To32Signed
-; CHECK: mov     eax, dword ptr [esp+4]
+; CHECK: mov     eax, dword ptr [esp + 4]
 ; CHECK-NEXT: ret
 ;
 ; OPTM1-LABEL: trunc64To32Signed
-; OPTM1: mov     eax, dword ptr [esp+
+; OPTM1: mov     eax, dword ptr [esp +
 ; OPTM1: ret
 
 define internal i32 @trunc64To16Signed(i64 %a) {
 entry:
   %conv = trunc i64 %a to i16
   %conv.ret_ext = sext i16 %conv to i32
   ret i32 %conv.ret_ext
 }
 ; CHECK-LABEL: trunc64To16Signed
-; CHECK:      mov     eax, dword ptr [esp+4]
+; CHECK:      mov     eax, dword ptr [esp + 4]
 ; CHECK-NEXT: movsx  eax, ax
 ; CHECK-NEXT: ret
 ;
 ; OPTM1-LABEL: trunc64To16Signed
-; OPTM1:      mov     eax, dword ptr [esp+
+; OPTM1:      mov     eax, dword ptr [esp +
 ; OPTM1: movsx  eax,
 ; OPTM1: ret
 
 define internal i32 @trunc64To8Signed(i64 %a) {
 entry:
   %conv = trunc i64 %a to i8
   %conv.ret_ext = sext i8 %conv to i32
   ret i32 %conv.ret_ext
 }
 ; CHECK-LABEL: trunc64To8Signed
-; CHECK:      mov     eax, dword ptr [esp+4]
+; CHECK:      mov     eax, dword ptr [esp + 4]
 ; CHECK-NEXT: movsx  eax, al
 ; CHECK-NEXT: ret
 ;
 ; OPTM1-LABEL: trunc64To8Signed
-; OPTM1:      mov     eax, dword ptr [esp+
+; OPTM1:      mov     eax, dword ptr [esp +
 ; OPTM1: movsx  eax,
 ; OPTM1: ret
 
 define internal i32 @trunc64To32SignedConst() {
 entry:
   %conv = trunc i64 12345678901234 to i32
   ret i32 %conv
 }
 ; CHECK-LABEL: trunc64To32SignedConst
 ; CHECK: mov eax, 1942892530
@@ skipping 14 matching lines @@
 ; OPTM1-LABEL: trunc64To16SignedConst
 ; OPTM1: mov eax, 1942892530
 ; OPTM1: movsx eax,
 
 define internal i32 @trunc64To32Unsigned(i64 %a) {
 entry:
   %conv = trunc i64 %a to i32
   ret i32 %conv
 }
 ; CHECK-LABEL: trunc64To32Unsigned
-; CHECK: mov     eax, dword ptr [esp+4]
+; CHECK: mov     eax, dword ptr [esp + 4]
 ; CHECK-NEXT: ret
 ;
 ; OPTM1-LABEL: trunc64To32Unsigned
-; OPTM1: mov     eax, dword ptr [esp+
+; OPTM1: mov     eax, dword ptr [esp +
 ; OPTM1: ret
 
 define internal i32 @trunc64To16Unsigned(i64 %a) {
 entry:
   %conv = trunc i64 %a to i16
   %conv.ret_ext = zext i16 %conv to i32
   ret i32 %conv.ret_ext
 }
 ; CHECK-LABEL: trunc64To16Unsigned
-; CHECK:      mov     eax, dword ptr [esp+4]
+; CHECK:      mov     eax, dword ptr [esp + 4]
 ; CHECK-NEXT: movzx  eax, ax
 ; CHECK-NEXT: ret
 ;
 ; OPTM1-LABEL: trunc64To16Unsigned
-; OPTM1:      mov     eax, dword ptr [esp+
+; OPTM1:      mov     eax, dword ptr [esp +
 ; OPTM1: movzx  eax,
 ; OPTM1: ret
 
 define internal i32 @trunc64To8Unsigned(i64 %a) {
 entry:
   %conv = trunc i64 %a to i8
   %conv.ret_ext = zext i8 %conv to i32
   ret i32 %conv.ret_ext
 }
 ; CHECK-LABEL: trunc64To8Unsigned
-; CHECK:      mov     eax, dword ptr [esp+4]
+; CHECK:      mov     eax, dword ptr [esp + 4]
 ; CHECK-NEXT: movzx  eax, al
 ; CHECK-NEXT: ret
 ;
 ; OPTM1-LABEL: trunc64To8Unsigned
-; OPTM1:      mov     eax, dword ptr [esp+
+; OPTM1: mov    eax, dword ptr [esp +
 ; OPTM1: movzx  eax,
 ; OPTM1: ret
 
 define internal i32 @trunc64To1(i64 %a) {
 entry:
 ;  %tobool = icmp ne i64 %a, 0
   %tobool = trunc i64 %a to i1
   %tobool.ret_ext = zext i1 %tobool to i32
   ret i32 %tobool.ret_ext
 }
 ; CHECK-LABEL: trunc64To1
-; CHECK:      mov     eax, dword ptr [esp+4]
+; CHECK:      mov     eax, dword ptr [esp + 4]
 ; CHECK:      and     eax, 1
 ; CHECK-NEXT: ret
 ;
 ; OPTM1-LABEL: trunc64To1
-; OPTM1:      mov     eax, dword ptr [esp+
+; OPTM1:      mov     eax, dword ptr [esp +
 ; OPTM1:      and     eax, 1
 ; OPTM1: ret
 
 define internal i64 @sext32To64(i32 %a) {
 entry:
   %conv = sext i32 %a to i64
   ret i64 %conv
 }
 ; CHECK-LABEL: sext32To64
 ; CHECK: mov
@@ skipping 508 matching lines @@
 ; OPTM1: cmp
 ; OPTM1: jbe
 
 define internal i64 @load64(i32 %a) {
 entry:
   %__1 = inttoptr i32 %a to i64*
   %v0 = load i64* %__1, align 1
   ret i64 %v0
 }
 ; CHECK-LABEL: load64
-; CHECK: mov e[[REGISTER:[a-z]+]], dword ptr [esp+4]
+; CHECK: mov e[[REGISTER:[a-z]+]], dword ptr [esp + 4]
 ; CHECK-NEXT: mov {{.*}}, dword ptr [e[[REGISTER]]]
-; CHECK-NEXT: mov {{.*}}, dword ptr [e[[REGISTER]]+4]
+; CHECK-NEXT: mov {{.*}}, dword ptr [e[[REGISTER]] + 4]
 ;
 ; OPTM1-LABEL: load64
 ; OPTM1: mov e{{..}}, dword ptr [e{{..}}]
-; OPTM1: mov e{{..}}, dword ptr [e{{..}}+4]
+; OPTM1: mov e{{..}}, dword ptr [e{{..}} + 4]
 
 define internal void @store64(i32 %a, i64 %value) {
 entry:
   %__2 = inttoptr i32 %a to i64*
   store i64 %value, i64* %__2, align 1
   ret void
 }
 ; CHECK-LABEL: store64
-; CHECK: mov e[[REGISTER:[a-z]+]], dword ptr [esp+4]
-; CHECK: mov dword ptr [e[[REGISTER]]+4],
+; CHECK: mov e[[REGISTER:[a-z]+]], dword ptr [esp + 4]
+; CHECK: mov dword ptr [e[[REGISTER]] + 4],
 ; CHECK: mov dword ptr [e[[REGISTER]]],
 ;
 ; OPTM1-LABEL: store64
-; OPTM1: mov dword ptr [e[[REGISTER:[a-z]+]]+4],
+; OPTM1: mov dword ptr [e[[REGISTER:[a-z]+]] + 4],
 ; OPTM1: mov dword ptr [e[[REGISTER]]],
 
 define internal void @store64Const(i32 %a) {
 entry:
   %a.asptr = inttoptr i32 %a to i64*
   store i64 -2401053092306725256, i64* %a.asptr, align 1
   ret void
 }
 ; CHECK-LABEL: store64Const
-; CHECK: mov e[[REGISTER:[a-z]+]], dword ptr [esp+4]
-; CHECK: mov dword ptr [e[[REGISTER]]+4], 3735928559
+; CHECK: mov e[[REGISTER:[a-z]+]], dword ptr [esp + 4]
+; CHECK: mov dword ptr [e[[REGISTER]] + 4], 3735928559
 ; CHECK: mov dword ptr [e[[REGISTER]]], 305419896
 ;
 ; OPTM1-LABEL: store64Const
-; OPTM1: mov dword ptr [e[[REGISTER:[a-z]+]]+4], 3735928559
+; OPTM1: mov dword ptr [e[[REGISTER:[a-z]+]] + 4], 3735928559
 ; OPTM1: mov dword ptr [e[[REGISTER]]], 305419896
 
 define internal i64 @select64VarVar(i64 %a, i64 %b) {
 entry:
   %cmp = icmp ult i64 %a, %b
   %cond = select i1 %cmp, i64 %a, i64 %b
   ret i64 %cond
 }
 ; CHECK-LABEL: select64VarVar
 ; CHECK: cmp
@@ skipping 110 matching lines @@
 }
 ; The following checks are not strictly necessary since one of the RUN
 ; lines actually runs the output through the assembler.
 ; CHECK-LABEL: icmpLt64Imm
 ; CHECK-NOT: cmp {{[0-9]+}},
 ; OPTM1-LABEL: icmpLt64Imm
 ; OPTM1-NOT: cmp {{[0-9]+}},
 
 ; ERRORS-NOT: ICE translation error
 ; DUMP-NOT: SZ