Subzero: switch from llvm-objdump to objdump for lit tests (for LLVM merge)

tests_lit/llvm2ice_tests/8bit.pnacl.ll

 ; This tries to be a comprehensive test of i8 operations.
 
-; RUN: %p2i -i %s --args -O2 --verbose none \
-; RUN:   | llvm-mc -triple=i686-none-nacl -filetype=obj \
-; RUN:   | llvm-objdump -d --symbolize -x86-asm-syntax=intel - | FileCheck %s
-; RUN: %p2i -i %s --args -Om1 --verbose none \
-; RUN:   | llvm-mc -triple=i686-none-nacl -filetype=obj \
-; RUN:   | llvm-objdump -d --symbolize -x86-asm-syntax=intel - | FileCheck %s
+; RUN: %p2i --assemble --disassemble -i %s --args -O2 --verbose none \
+; RUN:   | FileCheck %s
+; RUN: %p2i --assemble --disassemble -i %s --args -Om1 --verbose none \
+; RUN:   | FileCheck %s
 
 define internal i32 @add8Bit(i32 %a, i32 %b) {
 entry:
   %a_8 = trunc i32 %a to i8
   %b_8 = trunc i32 %b to i8
   %add = add i8 %b_8, %a_8
   %ret = zext i8 %add to i32
   ret i32 %ret
 }
 ; CHECK-LABEL: add8Bit
@@ skipping 32 matching lines @@
 
 define internal i32 @mul8Bit(i32 %a, i32 %b) {
 entry:
   %a_8 = trunc i32 %a to i8
   %b_8 = trunc i32 %b to i8
   %mul = mul i8 %b_8, %a_8
   %ret = zext i8 %mul to i32
   ret i32 %ret
 }
 ; CHECK-LABEL: mul8Bit
-; CHECK: mul {{[abcd]l|byte ptr}}
+; CHECK: mul {{[abcd]l|BYTE PTR}}
 
 define internal i32 @mul8BitConst(i32 %a) {
 entry:
   %a_8 = trunc i32 %a to i8
   %mul = mul i8 %a_8, 56
   %ret = zext i8 %mul to i32
   ret i32 %ret
 }
 ; CHECK-LABEL: mul8BitConst
 ; 8-bit imul only accepts r/m, not imm
-; CHECK: mov {{.*}}, 56
-; CHECK: mul {{[abcd]l|byte ptr}}
+; CHECK: mov {{.*}},0x38
+; CHECK: mul {{[abcd]l|BYTE PTR}}
 
 define internal i32 @udiv8Bit(i32 %a, i32 %b) {
 entry:
   %a_8 = trunc i32 %a to i8
   %b_8 = trunc i32 %b to i8
   %udiv = udiv i8 %b_8, %a_8
   %ret = zext i8 %udiv to i32
   ret i32 %ret
 }
 ; CHECK-LABEL: udiv8Bit
-; CHECK: div {{[abcd]l|byte ptr}}
+; CHECK: div {{[abcd]l|BYTE PTR}}
 
 define internal i32 @udiv8BitConst(i32 %a) {
 entry:
   %a_8 = trunc i32 %a to i8
   %udiv = udiv i8 %a_8, 123
   %ret = zext i8 %udiv to i32
   ret i32 %ret
 }
 ; CHECK-LABEL: udiv8BitConst
-; CHECK: div {{[abcd]l|byte ptr}}
+; CHECK: div {{[abcd]l|BYTE PTR}}
 
 define internal i32 @urem8Bit(i32 %a, i32 %b) {
 entry:
   %a_8 = trunc i32 %a to i8
   %b_8 = trunc i32 %b to i8
   %urem = urem i8 %b_8, %a_8
   %ret = zext i8 %urem to i32
   ret i32 %ret
 }
 ; CHECK-LABEL: urem8Bit
-; CHECK: div {{[abcd]l|byte ptr}}
+; CHECK: div {{[abcd]l|BYTE PTR}}
 
 define internal i32 @urem8BitConst(i32 %a) {
 entry:
   %a_8 = trunc i32 %a to i8
   %urem = urem i8 %a_8, 123
   %ret = zext i8 %urem to i32
   ret i32 %ret
 }
 ; CHECK-LABEL: urem8BitConst
-; CHECK: div {{[abcd]l|byte ptr}}
+; CHECK: div {{[abcd]l|BYTE PTR}}
 
 
 define internal i32 @sdiv8Bit(i32 %a, i32 %b) {
 entry:
   %a_8 = trunc i32 %a to i8
   %b_8 = trunc i32 %b to i8
   %sdiv = sdiv i8 %b_8, %a_8
   %ret = zext i8 %sdiv to i32
   ret i32 %ret
 }
 ; CHECK-LABEL: sdiv8Bit
-; CHECK: idiv {{[abcd]l|byte ptr}}
+; CHECK: idiv {{[abcd]l|BYTE PTR}}
 
 define internal i32 @sdiv8BitConst(i32 %a) {
 entry:
   %a_8 = trunc i32 %a to i8
   %sdiv = sdiv i8 %a_8, 123
   %ret = zext i8 %sdiv to i32
   ret i32 %ret
 }
 ; CHECK-LABEL: sdiv8BitConst
-; CHECK: idiv {{[abcd]l|byte ptr}}
+; CHECK: idiv {{[abcd]l|BYTE PTR}}
 
 define internal i32 @srem8Bit(i32 %a, i32 %b) {
 entry:
   %a_8 = trunc i32 %a to i8
   %b_8 = trunc i32 %b to i8
   %srem = srem i8 %b_8, %a_8
   %ret = zext i8 %srem to i32
   ret i32 %ret
 }
 ; CHECK-LABEL: srem8Bit
-; CHECK: idiv {{[abcd]l|byte ptr}}
+; CHECK: idiv {{[abcd]l|BYTE PTR}}
 
 define internal i32 @srem8BitConst(i32 %a) {
 entry:
   %a_8 = trunc i32 %a to i8
   %srem = srem i8 %a_8, 123
   %ret = zext i8 %srem to i32
   ret i32 %ret
 }
 ; CHECK-LABEL: srem8BitConst
-; CHECK: idiv {{[abcd]l|byte ptr}}
+; CHECK: idiv {{[abcd]l|BYTE PTR}}
 
 define internal i32 @shl8Bit(i32 %a, i32 %b) {
 entry:
   %a_8 = trunc i32 %a to i8
   %b_8 = trunc i32 %b to i8
   %shl = shl i8 %b_8, %a_8
   %ret = zext i8 %shl to i32
   ret i32 %ret
 }
 ; CHECK-LABEL: shl8Bit
-; CHECK: shl {{[abd]l|byte ptr}}, cl
+; CHECK: shl {{[abd]l|BYTE PTR}},cl
 
 define internal i32 @shl8BitConst(i32 %a, i32 %b) {
 entry:
   %a_8 = trunc i32 %a to i8
   %shl = shl i8 %a_8, 6
   %ret = zext i8 %shl to i32
   ret i32 %ret
 }
 ; CHECK-LABEL: shl8BitConst
-; CHECK: shl {{[abcd]l|byte ptr}}, 6
+; CHECK: shl {{[abcd]l|BYTE PTR}},0x6
 
 define internal i32 @lshr8Bit(i32 %a, i32 %b) {
 entry:
   %a_8 = trunc i32 %a to i8
   %b_8 = trunc i32 %b to i8
   %lshr = lshr i8 %b_8, %a_8
   %ret = zext i8 %lshr to i32
   ret i32 %ret
 }
 ; CHECK-LABEL: lshr8Bit
-; CHECK: shr {{[abd]l|byte ptr}}, cl
+; CHECK: shr {{[abd]l|BYTE PTR}},cl
 
 define internal i32 @lshr8BitConst(i32 %a, i32 %b) {
 entry:
   %a_8 = trunc i32 %a to i8
   %lshr = lshr i8 %a_8, 6
   %ret = zext i8 %lshr to i32
   ret i32 %ret
 }
 ; CHECK-LABEL: lshr8BitConst
-; CHECK: shr {{[abcd]l|byte ptr}}, 6
+; CHECK: shr {{[abcd]l|BYTE PTR}},0x6
 
 define internal i32 @ashr8Bit(i32 %a, i32 %b) {
 entry:
   %a_8 = trunc i32 %a to i8
   %b_8 = trunc i32 %b to i8
   %ashr = ashr i8 %b_8, %a_8
   %ret = zext i8 %ashr to i32
   ret i32 %ret
 }
 ; CHECK-LABEL: ashr8Bit
-; CHECK: sar {{[abd]l|byte ptr}}, cl
+; CHECK: sar {{[abd]l|BYTE PTR}},cl
 
 define internal i32 @ashr8BitConst(i32 %a, i32 %b) {
 entry:
   %a_8 = trunc i32 %a to i8
   %ashr = ashr i8 %a_8, 6
   %ret = zext i8 %ashr to i32
   ret i32 %ret
 }
 ; CHECK-LABEL: ashr8BitConst
-; CHECK: sar {{[abcd]l|byte ptr}}, 6
+; CHECK: sar {{[abcd]l|BYTE PTR}},0x6
 
 define internal i32 @icmp8Bit(i32 %a, i32 %b) {
 entry:
   %a_8 = trunc i32 %a to i8
   %b_8 = trunc i32 %b to i8
   %icmp = icmp ne i8 %b_8, %a_8
   %ret = zext i1 %icmp to i32
   ret i32 %ret
 }
 ; CHECK-LABEL: icmp8Bit
-; CHECK: cmp {{[abcd]l|byte ptr}}
+; CHECK: cmp {{[abcd]l|BYTE PTR}}
 
 define internal i32 @icmp8BitConst(i32 %a) {
 entry:
   %a_8 = trunc i32 %a to i8
   %icmp = icmp ne i8 %a_8, 123
   %ret = zext i1 %icmp to i32
   ret i32 %ret
 }
 ; CHECK-LABEL: icmp8BitConst
-; CHECK: cmp {{[abcd]l|byte ptr}}
+; CHECK: cmp {{[abcd]l|BYTE PTR}}
 
 define internal i32 @icmp8BitConstSwapped(i32 %a) {
 entry:
   %a_8 = trunc i32 %a to i8
   %icmp = icmp ne i8 123, %a_8
   %ret = zext i1 %icmp to i32
   ret i32 %ret
 }
 ; CHECK-LABEL: icmp8BitConstSwapped
-; CHECK: cmp {{[abcd]l|byte ptr}}
+; CHECK: cmp {{[abcd]l|BYTE PTR}}
 
 define internal i32 @icmp8BitMem(i32 %a, i32 %b_iptr) {
 entry:
   %a_8 = trunc i32 %a to i8
   %bptr = inttoptr i32 %b_iptr to i8*
   %b_8 = load i8* %bptr, align 1
   %icmp = icmp ne i8 %b_8, %a_8
   %ret = zext i1 %icmp to i32
   ret i32 %ret
 }
 ; CHECK-LABEL: icmp8BitMem
-; CHECK: cmp {{[abcd]l|byte ptr}}
+; CHECK: cmp {{[abcd]l|BYTE PTR}}
 
 define internal i32 @icmp8BitMemSwapped(i32 %a, i32 %b_iptr) {
 entry:
   %a_8 = trunc i32 %a to i8
   %bptr = inttoptr i32 %b_iptr to i8*
   %b_8 = load i8* %bptr, align 1
   %icmp = icmp ne i8 %a_8, %b_8
   %ret = zext i1 %icmp to i32
   ret i32 %ret
 }
 ; CHECK-LABEL: icmp8BitMemSwapped
-; CHECK: cmp {{[abcd]l|byte ptr}}
+; CHECK: cmp {{[abcd]l|BYTE PTR}}
 
 define internal i32 @selectI8Var(i32 %a, i32 %b) {
 entry:
   %a_8 = trunc i32 %a to i8
   %b_8 = trunc i32 %b to i8
   %cmp = icmp slt i8 %a_8, %b_8
   %ret = select i1 %cmp, i8 %a_8, i8 %b_8
   %ret_ext = zext i8 %ret to i32
   ret i32 %ret_ext
 }
@@ skipping 30 matching lines @@
   %merge4 = phi i8 [ %trunc3, %entry ], [ %trunc8_8, %next ]
   %res1 = select i1 %merge1, i8 %merge2, i8 %merge3
   %res2 = select i1 %merge1, i8 %merge4, i8 %merge5
   %res1_2 = select i1 %merge1, i8 %res1, i8 %res2
   %res123 = select i1 %merge1, i8 %merge6, i8 %res1_2
   %result = zext i8 %res123 to i32
   ret i32 %result
 }
 ; CHECK-LABEL: testPhi8
 ; This assumes there will be some copy from an 8-bit register / stack slot.
-; CHECK-DAG: mov {{.*}}, {{[a-d]}}l
-; CHECK-DAG: mov {{.*}}, byte ptr
-; CHECK-DAG: mov byte ptr {{.*}}
+; CHECK-DAG: mov {{.*}},{{[a-d]}}l
+; CHECK-DAG: mov {{.*}},BYTE PTR
+; CHECK-DAG: mov BYTE PTR {{.*}}
 
 @global8 = internal global [1 x i8] c"\01", align 4
 
 define i32 @load_i8(i32 %addr_arg) {
 entry:
   %addr = inttoptr i32 %addr_arg to i8*
   %ret = load i8* %addr, align 1
   %ret_ext = zext i8 %ret to i32
   ret i32 %ret_ext
 }
 ; CHECK-LABEL: load_i8
-; CHECK: mov {{[a-d]l}}, byte ptr
+; CHECK: mov {{[a-d]l}},BYTE PTR
 
 define i32 @load_i8_global(i32 %addr_arg) {
 entry:
   %addr = bitcast [1 x i8]* @global8 to i8*
   %ret = load i8* %addr, align 1
   %ret_ext = zext i8 %ret to i32
   ret i32 %ret_ext
 }
 ; CHECK-LABEL: load_i8_global
-; CHECK: mov {{[a-d]l}}, byte ptr
+; CHECK: mov {{[a-d]l}},BYTE PTR
 
 define void @store_i8(i32 %addr_arg, i32 %val) {
 entry:
   %val_trunc = trunc i32 %val to i8
   %addr = inttoptr i32 %addr_arg to i8*
   store i8 %val_trunc, i8* %addr, align 1
   ret void
 }
 ; CHECK-LABEL: store_i8
-; CHECK: mov byte ptr {{.*}}, {{[a-d]l}}
+; CHECK: mov BYTE PTR {{.*}},{{[a-d]l}}
 
 define void @store_i8_const(i32 %addr_arg) {
 entry:
   %addr = inttoptr i32 %addr_arg to i8*
   store i8 123, i8* %addr, align 1
   ret void
 }
 ; CHECK-LABEL: store_i8_const
-; CHECK: mov byte ptr {{.*}}, 123
+; CHECK: mov BYTE PTR {{.*}},0x7b