LLVM support for vector quad bit permute and gather instructions through builtins
[oota-llvm.git] / test / MC / PowerPC / ppc64-encoding-ext.s
index b555f775c73da403c4975570bd759dbde995dfaf..143a30606f066daeff7a45b82275b9feb1de89a0 100644 (file)
 # CHECK-LE: beqlr 7                         # encoding: [0x20,0x00,0x9e,0x4d]
             beqlr cr7
 
-# CHECK-BE: bclr 12, 0, 0                   # encoding: [0x4d,0x80,0x00,0x20]
-# CHECK-LE: bclr 12, 0, 0                   # encoding: [0x20,0x00,0x80,0x4d]
+# CHECK-BE: bclr 12, 0                      # encoding: [0x4d,0x80,0x00,0x20]
+# CHECK-LE: bclr 12, 0                      # encoding: [0x20,0x00,0x80,0x4d]
             btlr 4*cr0+lt
-# CHECK-BE: bclr 12, 1, 0                   # encoding: [0x4d,0x81,0x00,0x20]
-# CHECK-LE: bclr 12, 1, 0                   # encoding: [0x20,0x00,0x81,0x4d]
+# CHECK-BE: bclr 12, 1                      # encoding: [0x4d,0x81,0x00,0x20]
+# CHECK-LE: bclr 12, 1                      # encoding: [0x20,0x00,0x81,0x4d]
             btlr 4*cr0+gt
-# CHECK-BE: bclr 12, 2, 0                   # encoding: [0x4d,0x82,0x00,0x20]
-# CHECK-LE: bclr 12, 2, 0                   # encoding: [0x20,0x00,0x82,0x4d]
+# CHECK-BE: bclr 12, 2                      # encoding: [0x4d,0x82,0x00,0x20]
+# CHECK-LE: bclr 12, 2                      # encoding: [0x20,0x00,0x82,0x4d]
             btlr 4*cr0+eq
-# CHECK-BE: bclr 12, 3, 0                   # encoding: [0x4d,0x83,0x00,0x20]
-# CHECK-LE: bclr 12, 3, 0                   # encoding: [0x20,0x00,0x83,0x4d]
+# CHECK-BE: bclr 12, 3                      # encoding: [0x4d,0x83,0x00,0x20]
+# CHECK-LE: bclr 12, 3                      # encoding: [0x20,0x00,0x83,0x4d]
             btlr 4*cr0+so
-# CHECK-BE: bclr 12, 3, 0                   # encoding: [0x4d,0x83,0x00,0x20]
-# CHECK-LE: bclr 12, 3, 0                   # encoding: [0x20,0x00,0x83,0x4d]
+# CHECK-BE: bclr 12, 3                      # encoding: [0x4d,0x83,0x00,0x20]
+# CHECK-LE: bclr 12, 3                      # encoding: [0x20,0x00,0x83,0x4d]
             btlr 4*cr0+un
-# CHECK-BE: bclr 12, 4, 0                   # encoding: [0x4d,0x84,0x00,0x20]
-# CHECK-LE: bclr 12, 4, 0                   # encoding: [0x20,0x00,0x84,0x4d]
+# CHECK-BE: bclr 12, 4                      # encoding: [0x4d,0x84,0x00,0x20]
+# CHECK-LE: bclr 12, 4                      # encoding: [0x20,0x00,0x84,0x4d]
             btlr 4*cr1+lt
-# CHECK-BE: bclr 12, 5, 0                   # encoding: [0x4d,0x85,0x00,0x20]
-# CHECK-LE: bclr 12, 5, 0                   # encoding: [0x20,0x00,0x85,0x4d]
+# CHECK-BE: bclr 12, 5                      # encoding: [0x4d,0x85,0x00,0x20]
+# CHECK-LE: bclr 12, 5                      # encoding: [0x20,0x00,0x85,0x4d]
             btlr 4*cr1+gt
-# CHECK-BE: bclr 12, 6, 0                   # encoding: [0x4d,0x86,0x00,0x20]
-# CHECK-LE: bclr 12, 6, 0                   # encoding: [0x20,0x00,0x86,0x4d]
+# CHECK-BE: bclr 12, 6                      # encoding: [0x4d,0x86,0x00,0x20]
+# CHECK-LE: bclr 12, 6                      # encoding: [0x20,0x00,0x86,0x4d]
             btlr 4*cr1+eq
-# CHECK-BE: bclr 12, 7, 0                   # encoding: [0x4d,0x87,0x00,0x20]
-# CHECK-LE: bclr 12, 7, 0                   # encoding: [0x20,0x00,0x87,0x4d]
+# CHECK-BE: bclr 12, 7                      # encoding: [0x4d,0x87,0x00,0x20]
+# CHECK-LE: bclr 12, 7                      # encoding: [0x20,0x00,0x87,0x4d]
             btlr 4*cr1+so
-# CHECK-BE: bclr 12, 7, 0                   # encoding: [0x4d,0x87,0x00,0x20]
-# CHECK-LE: bclr 12, 7, 0                   # encoding: [0x20,0x00,0x87,0x4d]
+# CHECK-BE: bclr 12, 7                      # encoding: [0x4d,0x87,0x00,0x20]
+# CHECK-LE: bclr 12, 7                      # encoding: [0x20,0x00,0x87,0x4d]
             btlr 4*cr1+un
-# CHECK-BE: bclr 12, 8, 0                   # encoding: [0x4d,0x88,0x00,0x20]
-# CHECK-LE: bclr 12, 8, 0                   # encoding: [0x20,0x00,0x88,0x4d]
+# CHECK-BE: bclr 12, 8                      # encoding: [0x4d,0x88,0x00,0x20]
+# CHECK-LE: bclr 12, 8                      # encoding: [0x20,0x00,0x88,0x4d]
             btlr 4*cr2+lt
-# CHECK-BE: bclr 12, 9, 0                   # encoding: [0x4d,0x89,0x00,0x20]
-# CHECK-LE: bclr 12, 9, 0                   # encoding: [0x20,0x00,0x89,0x4d]
+# CHECK-BE: bclr 12, 9                      # encoding: [0x4d,0x89,0x00,0x20]
+# CHECK-LE: bclr 12, 9                      # encoding: [0x20,0x00,0x89,0x4d]
             btlr 4*cr2+gt
-# CHECK-BE: bclr 12, 10, 0                  # encoding: [0x4d,0x8a,0x00,0x20]
-# CHECK-LE: bclr 12, 10, 0                  # encoding: [0x20,0x00,0x8a,0x4d]
+# CHECK-BE: bclr 12, 10                     # encoding: [0x4d,0x8a,0x00,0x20]
+# CHECK-LE: bclr 12, 10                     # encoding: [0x20,0x00,0x8a,0x4d]
             btlr 4*cr2+eq
-# CHECK-BE: bclr 12, 11, 0                  # encoding: [0x4d,0x8b,0x00,0x20]
-# CHECK-LE: bclr 12, 11, 0                  # encoding: [0x20,0x00,0x8b,0x4d]
+# CHECK-BE: bclr 12, 11                     # encoding: [0x4d,0x8b,0x00,0x20]
+# CHECK-LE: bclr 12, 11                     # encoding: [0x20,0x00,0x8b,0x4d]
             btlr 4*cr2+so
-# CHECK-BE: bclr 12, 11, 0                  # encoding: [0x4d,0x8b,0x00,0x20]
-# CHECK-LE: bclr 12, 11, 0                  # encoding: [0x20,0x00,0x8b,0x4d]
+# CHECK-BE: bclr 12, 11                     # encoding: [0x4d,0x8b,0x00,0x20]
+# CHECK-LE: bclr 12, 11                     # encoding: [0x20,0x00,0x8b,0x4d]
             btlr 4*cr2+un
-# CHECK-BE: bclr 12, 12, 0                  # encoding: [0x4d,0x8c,0x00,0x20]
-# CHECK-LE: bclr 12, 12, 0                  # encoding: [0x20,0x00,0x8c,0x4d]
+# CHECK-BE: bclr 12, 12                     # encoding: [0x4d,0x8c,0x00,0x20]
+# CHECK-LE: bclr 12, 12                     # encoding: [0x20,0x00,0x8c,0x4d]
             btlr 4*cr3+lt
-# CHECK-BE: bclr 12, 13, 0                  # encoding: [0x4d,0x8d,0x00,0x20]
-# CHECK-LE: bclr 12, 13, 0                  # encoding: [0x20,0x00,0x8d,0x4d]
+# CHECK-BE: bclr 12, 13                     # encoding: [0x4d,0x8d,0x00,0x20]
+# CHECK-LE: bclr 12, 13                     # encoding: [0x20,0x00,0x8d,0x4d]
             btlr 4*cr3+gt
-# CHECK-BE: bclr 12, 14, 0                  # encoding: [0x4d,0x8e,0x00,0x20]
-# CHECK-LE: bclr 12, 14, 0                  # encoding: [0x20,0x00,0x8e,0x4d]
+# CHECK-BE: bclr 12, 14                     # encoding: [0x4d,0x8e,0x00,0x20]
+# CHECK-LE: bclr 12, 14                     # encoding: [0x20,0x00,0x8e,0x4d]
             btlr 4*cr3+eq
-# CHECK-BE: bclr 12, 15, 0                  # encoding: [0x4d,0x8f,0x00,0x20]
-# CHECK-LE: bclr 12, 15, 0                  # encoding: [0x20,0x00,0x8f,0x4d]
+# CHECK-BE: bclr 12, 15                     # encoding: [0x4d,0x8f,0x00,0x20]
+# CHECK-LE: bclr 12, 15                     # encoding: [0x20,0x00,0x8f,0x4d]
             btlr 4*cr3+so
-# CHECK-BE: bclr 12, 15, 0                  # encoding: [0x4d,0x8f,0x00,0x20]
-# CHECK-LE: bclr 12, 15, 0                  # encoding: [0x20,0x00,0x8f,0x4d]
+# CHECK-BE: bclr 12, 15                     # encoding: [0x4d,0x8f,0x00,0x20]
+# CHECK-LE: bclr 12, 15                     # encoding: [0x20,0x00,0x8f,0x4d]
             btlr 4*cr3+un
-# CHECK-BE: bclr 12, 16, 0                  # encoding: [0x4d,0x90,0x00,0x20]
-# CHECK-LE: bclr 12, 16, 0                  # encoding: [0x20,0x00,0x90,0x4d]
+# CHECK-BE: bclr 12, 16                     # encoding: [0x4d,0x90,0x00,0x20]
+# CHECK-LE: bclr 12, 16                     # encoding: [0x20,0x00,0x90,0x4d]
             btlr 4*cr4+lt
-# CHECK-BE: bclr 12, 17, 0                  # encoding: [0x4d,0x91,0x00,0x20]
-# CHECK-LE: bclr 12, 17, 0                  # encoding: [0x20,0x00,0x91,0x4d]
+# CHECK-BE: bclr 12, 17                     # encoding: [0x4d,0x91,0x00,0x20]
+# CHECK-LE: bclr 12, 17                     # encoding: [0x20,0x00,0x91,0x4d]
             btlr 4*cr4+gt
-# CHECK-BE: bclr 12, 18, 0                  # encoding: [0x4d,0x92,0x00,0x20]
-# CHECK-LE: bclr 12, 18, 0                  # encoding: [0x20,0x00,0x92,0x4d]
+# CHECK-BE: bclr 12, 18                     # encoding: [0x4d,0x92,0x00,0x20]
+# CHECK-LE: bclr 12, 18                     # encoding: [0x20,0x00,0x92,0x4d]
             btlr 4*cr4+eq
-# CHECK-BE: bclr 12, 19, 0                  # encoding: [0x4d,0x93,0x00,0x20]
-# CHECK-LE: bclr 12, 19, 0                  # encoding: [0x20,0x00,0x93,0x4d]
+# CHECK-BE: bclr 12, 19                     # encoding: [0x4d,0x93,0x00,0x20]
+# CHECK-LE: bclr 12, 19                     # encoding: [0x20,0x00,0x93,0x4d]
             btlr 4*cr4+so
-# CHECK-BE: bclr 12, 19, 0                  # encoding: [0x4d,0x93,0x00,0x20]
-# CHECK-LE: bclr 12, 19, 0                  # encoding: [0x20,0x00,0x93,0x4d]
+# CHECK-BE: bclr 12, 19                     # encoding: [0x4d,0x93,0x00,0x20]
+# CHECK-LE: bclr 12, 19                     # encoding: [0x20,0x00,0x93,0x4d]
             btlr 4*cr4+un
-# CHECK-BE: bclr 12, 20, 0                  # encoding: [0x4d,0x94,0x00,0x20]
-# CHECK-LE: bclr 12, 20, 0                  # encoding: [0x20,0x00,0x94,0x4d]
+# CHECK-BE: bclr 12, 20                     # encoding: [0x4d,0x94,0x00,0x20]
+# CHECK-LE: bclr 12, 20                     # encoding: [0x20,0x00,0x94,0x4d]
             btlr 4*cr5+lt
-# CHECK-BE: bclr 12, 21, 0                  # encoding: [0x4d,0x95,0x00,0x20]
-# CHECK-LE: bclr 12, 21, 0                  # encoding: [0x20,0x00,0x95,0x4d]
+# CHECK-BE: bclr 12, 21                     # encoding: [0x4d,0x95,0x00,0x20]
+# CHECK-LE: bclr 12, 21                     # encoding: [0x20,0x00,0x95,0x4d]
             btlr 4*cr5+gt
-# CHECK-BE: bclr 12, 22, 0                  # encoding: [0x4d,0x96,0x00,0x20]
-# CHECK-LE: bclr 12, 22, 0                  # encoding: [0x20,0x00,0x96,0x4d]
+# CHECK-BE: bclr 12, 22                     # encoding: [0x4d,0x96,0x00,0x20]
+# CHECK-LE: bclr 12, 22                     # encoding: [0x20,0x00,0x96,0x4d]
             btlr 4*cr5+eq
-# CHECK-BE: bclr 12, 23, 0                  # encoding: [0x4d,0x97,0x00,0x20]
-# CHECK-LE: bclr 12, 23, 0                  # encoding: [0x20,0x00,0x97,0x4d]
+# CHECK-BE: bclr 12, 23                     # encoding: [0x4d,0x97,0x00,0x20]
+# CHECK-LE: bclr 12, 23                     # encoding: [0x20,0x00,0x97,0x4d]
             btlr 4*cr5+so
-# CHECK-BE: bclr 12, 23, 0                  # encoding: [0x4d,0x97,0x00,0x20]
-# CHECK-LE: bclr 12, 23, 0                  # encoding: [0x20,0x00,0x97,0x4d]
+# CHECK-BE: bclr 12, 23                     # encoding: [0x4d,0x97,0x00,0x20]
+# CHECK-LE: bclr 12, 23                     # encoding: [0x20,0x00,0x97,0x4d]
             btlr 4*cr5+un
-# CHECK-BE: bclr 12, 24, 0                  # encoding: [0x4d,0x98,0x00,0x20]
-# CHECK-LE: bclr 12, 24, 0                  # encoding: [0x20,0x00,0x98,0x4d]
+# CHECK-BE: bclr 12, 24                     # encoding: [0x4d,0x98,0x00,0x20]
+# CHECK-LE: bclr 12, 24                     # encoding: [0x20,0x00,0x98,0x4d]
             btlr 4*cr6+lt
-# CHECK-BE: bclr 12, 25, 0                  # encoding: [0x4d,0x99,0x00,0x20]
-# CHECK-LE: bclr 12, 25, 0                  # encoding: [0x20,0x00,0x99,0x4d]
+# CHECK-BE: bclr 12, 25                     # encoding: [0x4d,0x99,0x00,0x20]
+# CHECK-LE: bclr 12, 25                     # encoding: [0x20,0x00,0x99,0x4d]
             btlr 4*cr6+gt
-# CHECK-BE: bclr 12, 26, 0                  # encoding: [0x4d,0x9a,0x00,0x20]
-# CHECK-LE: bclr 12, 26, 0                  # encoding: [0x20,0x00,0x9a,0x4d]
+# CHECK-BE: bclr 12, 26                     # encoding: [0x4d,0x9a,0x00,0x20]
+# CHECK-LE: bclr 12, 26                     # encoding: [0x20,0x00,0x9a,0x4d]
             btlr 4*cr6+eq
-# CHECK-BE: bclr 12, 27, 0                  # encoding: [0x4d,0x9b,0x00,0x20]
-# CHECK-LE: bclr 12, 27, 0                  # encoding: [0x20,0x00,0x9b,0x4d]
+# CHECK-BE: bclr 12, 27                     # encoding: [0x4d,0x9b,0x00,0x20]
+# CHECK-LE: bclr 12, 27                     # encoding: [0x20,0x00,0x9b,0x4d]
             btlr 4*cr6+so
-# CHECK-BE: bclr 12, 27, 0                  # encoding: [0x4d,0x9b,0x00,0x20]
-# CHECK-LE: bclr 12, 27, 0                  # encoding: [0x20,0x00,0x9b,0x4d]
+# CHECK-BE: bclr 12, 27                     # encoding: [0x4d,0x9b,0x00,0x20]
+# CHECK-LE: bclr 12, 27                     # encoding: [0x20,0x00,0x9b,0x4d]
             btlr 4*cr6+un
-# CHECK-BE: bclr 12, 28, 0                  # encoding: [0x4d,0x9c,0x00,0x20]
-# CHECK-LE: bclr 12, 28, 0                  # encoding: [0x20,0x00,0x9c,0x4d]
+# CHECK-BE: bclr 12, 28                     # encoding: [0x4d,0x9c,0x00,0x20]
+# CHECK-LE: bclr 12, 28                     # encoding: [0x20,0x00,0x9c,0x4d]
             btlr 4*cr7+lt
-# CHECK-BE: bclr 12, 29, 0                  # encoding: [0x4d,0x9d,0x00,0x20]
-# CHECK-LE: bclr 12, 29, 0                  # encoding: [0x20,0x00,0x9d,0x4d]
+# CHECK-BE: bclr 12, 29                     # encoding: [0x4d,0x9d,0x00,0x20]
+# CHECK-LE: bclr 12, 29                     # encoding: [0x20,0x00,0x9d,0x4d]
             btlr 4*cr7+gt
-# CHECK-BE: bclr 12, 30, 0                  # encoding: [0x4d,0x9e,0x00,0x20]
-# CHECK-LE: bclr 12, 30, 0                  # encoding: [0x20,0x00,0x9e,0x4d]
+# CHECK-BE: bclr 12, 30                     # encoding: [0x4d,0x9e,0x00,0x20]
+# CHECK-LE: bclr 12, 30                     # encoding: [0x20,0x00,0x9e,0x4d]
             btlr 4*cr7+eq
-# CHECK-BE: bclr 12, 31, 0                  # encoding: [0x4d,0x9f,0x00,0x20]
-# CHECK-LE: bclr 12, 31, 0                  # encoding: [0x20,0x00,0x9f,0x4d]
+# CHECK-BE: bclr 12, 31                     # encoding: [0x4d,0x9f,0x00,0x20]
+# CHECK-LE: bclr 12, 31                     # encoding: [0x20,0x00,0x9f,0x4d]
             btlr 4*cr7+so
-# CHECK-BE: bclr 12, 31, 0                  # encoding: [0x4d,0x9f,0x00,0x20]
-# CHECK-LE: bclr 12, 31, 0                  # encoding: [0x20,0x00,0x9f,0x4d]
+# CHECK-BE: bclr 12, 31                     # encoding: [0x4d,0x9f,0x00,0x20]
+# CHECK-LE: bclr 12, 31                     # encoding: [0x20,0x00,0x9f,0x4d]
             btlr 4*cr7+un
 
 # Branch mnemonics
 # CHECK-LE: bctrl                           # encoding: [0x21,0x04,0x80,0x4e]
             bctrl
 
-# CHECK-BE: bc 12, 2, target                # encoding: [0x41,0x82,A,0bAAAAAA00]
-# CHECK-LE: bc 12, 2, target                # encoding: [0bAAAAAA00,A,0x82,0x41]
+# CHECK-BE: bt 2, target                    # encoding: [0x41,0x82,A,0bAAAAAA00]
+# CHECK-LE: bt 2, target                    # encoding: [0bAAAAAA00,A,0x82,0x41]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
             bt 2, target
-# CHECK-BE: bca 12, 2, target               # encoding: [0x41,0x82,A,0bAAAAAA10]
-# CHECK-LE: bca 12, 2, target               # encoding: [0bAAAAAA10,A,0x82,0x41]
+# CHECK-BE: bta 2, target                   # encoding: [0x41,0x82,A,0bAAAAAA10]
+# CHECK-LE: bta 2, target                   # encoding: [0bAAAAAA10,A,0x82,0x41]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
             bta 2, target
-# CHECK-BE: bclr 12, 2, 0                   # encoding: [0x4d,0x82,0x00,0x20]
-# CHECK-LE: bclr 12, 2, 0                   # encoding: [0x20,0x00,0x82,0x4d]
+# CHECK-BE: bclr 12, 2                      # encoding: [0x4d,0x82,0x00,0x20]
+# CHECK-LE: bclr 12, 2                      # encoding: [0x20,0x00,0x82,0x4d]
             btlr 2
-# CHECK-BE: bcctr 12, 2, 0                  # encoding: [0x4d,0x82,0x04,0x20]
-# CHECK-LE: bcctr 12, 2, 0                  # encoding: [0x20,0x04,0x82,0x4d]
+# CHECK-BE: bcctr 12, 2                     # encoding: [0x4d,0x82,0x04,0x20]
+# CHECK-LE: bcctr 12, 2                     # encoding: [0x20,0x04,0x82,0x4d]
             btctr 2
-# CHECK-BE: bcl 12, 2, target               # encoding: [0x41,0x82,A,0bAAAAAA01]
-# CHECK-LE: bcl 12, 2, target               # encoding: [0bAAAAAA01,A,0x82,0x41]
+# CHECK-BE: btl 2, target                   # encoding: [0x41,0x82,A,0bAAAAAA01]
+# CHECK-LE: btl 2, target                   # encoding: [0bAAAAAA01,A,0x82,0x41]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
             btl 2, target
-# CHECK-BE: bcla 12, 2, target              # encoding: [0x41,0x82,A,0bAAAAAA11]
-# CHECK-LE: bcla 12, 2, target              # encoding: [0bAAAAAA11,A,0x82,0x41]
+# CHECK-BE: btla 2, target                  # encoding: [0x41,0x82,A,0bAAAAAA11]
+# CHECK-LE: btla 2, target                  # encoding: [0bAAAAAA11,A,0x82,0x41]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
             btla 2, target
-# CHECK-BE: bclrl 12, 2, 0                  # encoding: [0x4d,0x82,0x00,0x21]
-# CHECK-LE: bclrl 12, 2, 0                  # encoding: [0x21,0x00,0x82,0x4d]
+# CHECK-BE: bclrl 12, 2                     # encoding: [0x4d,0x82,0x00,0x21]
+# CHECK-LE: bclrl 12, 2                     # encoding: [0x21,0x00,0x82,0x4d]
             btlrl 2
-# CHECK-BE: bcctrl 12, 2, 0                 # encoding: [0x4d,0x82,0x04,0x21]
-# CHECK-LE: bcctrl 12, 2, 0                 # encoding: [0x21,0x04,0x82,0x4d]
+# CHECK-BE: bcctrl 12, 2                    # encoding: [0x4d,0x82,0x04,0x21]
+# CHECK-LE: bcctrl 12, 2                    # encoding: [0x21,0x04,0x82,0x4d]
             btctrl 2
 
-# CHECK-BE: bc 15, 2, target                # encoding: [0x41,0xe2,A,0bAAAAAA00]
-# CHECK-LE: bc 15, 2, target                # encoding: [0bAAAAAA00,A,0xe2,0x41]
+# CHECK-BE: bt+ 2, target                   # encoding: [0x41,0xe2,A,0bAAAAAA00]
+# CHECK-LE: bt+ 2, target                   # encoding: [0bAAAAAA00,A,0xe2,0x41]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
             bt+ 2, target
-# CHECK-BE: bca 15, 2, target               # encoding: [0x41,0xe2,A,0bAAAAAA10]
-# CHECK-LE: bca 15, 2, target               # encoding: [0bAAAAAA10,A,0xe2,0x41]
+# CHECK-BE: bta+ 2, target                  # encoding: [0x41,0xe2,A,0bAAAAAA10]
+# CHECK-LE: bta+ 2, target                  # encoding: [0bAAAAAA10,A,0xe2,0x41]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
             bta+ 2, target
-# CHECK-BE: bclr 15, 2, 0                   # encoding: [0x4d,0xe2,0x00,0x20]
-# CHECK-LE: bclr 15, 2, 0                   # encoding: [0x20,0x00,0xe2,0x4d]
+# CHECK-BE: bclr 15, 2                      # encoding: [0x4d,0xe2,0x00,0x20]
+# CHECK-LE: bclr 15, 2                      # encoding: [0x20,0x00,0xe2,0x4d]
             btlr+ 2
-# CHECK-BE: bcctr 15, 2, 0                  # encoding: [0x4d,0xe2,0x04,0x20]
-# CHECK-LE: bcctr 15, 2, 0                  # encoding: [0x20,0x04,0xe2,0x4d]
+# CHECK-BE: bcctr 15, 2                     # encoding: [0x4d,0xe2,0x04,0x20]
+# CHECK-LE: bcctr 15, 2                     # encoding: [0x20,0x04,0xe2,0x4d]
             btctr+ 2
-# CHECK-BE: bcl 15, 2, target               # encoding: [0x41,0xe2,A,0bAAAAAA01]
-# CHECK-LE: bcl 15, 2, target               # encoding: [0bAAAAAA01,A,0xe2,0x41]
+# CHECK-BE: btl+ 2, target                  # encoding: [0x41,0xe2,A,0bAAAAAA01]
+# CHECK-LE: btl+ 2, target                  # encoding: [0bAAAAAA01,A,0xe2,0x41]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
             btl+ 2, target
-# CHECK-BE: bcla 15, 2, target              # encoding: [0x41,0xe2,A,0bAAAAAA11]
-# CHECK-LE: bcla 15, 2, target              # encoding: [0bAAAAAA11,A,0xe2,0x41]
+# CHECK-BE: btla+ 2, target                 # encoding: [0x41,0xe2,A,0bAAAAAA11]
+# CHECK-LE: btla+ 2, target                 # encoding: [0bAAAAAA11,A,0xe2,0x41]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
             btla+ 2, target
-# CHECK-BE: bclrl 15, 2, 0                  # encoding: [0x4d,0xe2,0x00,0x21]
-# CHECK-LE: bclrl 15, 2, 0                  # encoding: [0x21,0x00,0xe2,0x4d]
+# CHECK-BE: bclrl 15, 2                     # encoding: [0x4d,0xe2,0x00,0x21]
+# CHECK-LE: bclrl 15, 2                     # encoding: [0x21,0x00,0xe2,0x4d]
             btlrl+ 2
-# CHECK-BE: bcctrl 15, 2, 0                 # encoding: [0x4d,0xe2,0x04,0x21]
-# CHECK-LE: bcctrl 15, 2, 0                 # encoding: [0x21,0x04,0xe2,0x4d]
+# CHECK-BE: bcctrl 15, 2                    # encoding: [0x4d,0xe2,0x04,0x21]
+# CHECK-LE: bcctrl 15, 2                    # encoding: [0x21,0x04,0xe2,0x4d]
             btctrl+ 2
 
-# CHECK-BE: bc 14, 2, target                # encoding: [0x41,0xc2,A,0bAAAAAA00]
-# CHECK-LE: bc 14, 2, target                # encoding: [0bAAAAAA00,A,0xc2,0x41]
+# CHECK-BE: bt- 2, target                   # encoding: [0x41,0xc2,A,0bAAAAAA00]
+# CHECK-LE: bt- 2, target                   # encoding: [0bAAAAAA00,A,0xc2,0x41]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
             bt- 2, target
-# CHECK-BE: bca 14, 2, target               # encoding: [0x41,0xc2,A,0bAAAAAA10]
-# CHECK-LE: bca 14, 2, target               # encoding: [0bAAAAAA10,A,0xc2,0x41]
+# CHECK-BE: bta- 2, target                  # encoding: [0x41,0xc2,A,0bAAAAAA10]
+# CHECK-LE: bta- 2, target                  # encoding: [0bAAAAAA10,A,0xc2,0x41]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
             bta- 2, target
-# CHECK-BE: bclr 14, 2, 0                   # encoding: [0x4d,0xc2,0x00,0x20]
-# CHECK-LE: bclr 14, 2, 0                   # encoding: [0x20,0x00,0xc2,0x4d]
+# CHECK-BE: bclr 14, 2                      # encoding: [0x4d,0xc2,0x00,0x20]
+# CHECK-LE: bclr 14, 2                      # encoding: [0x20,0x00,0xc2,0x4d]
             btlr- 2
-# CHECK-BE: bcctr 14, 2, 0                  # encoding: [0x4d,0xc2,0x04,0x20]
-# CHECK-LE: bcctr 14, 2, 0                  # encoding: [0x20,0x04,0xc2,0x4d]
+# CHECK-BE: bcctr 14, 2                     # encoding: [0x4d,0xc2,0x04,0x20]
+# CHECK-LE: bcctr 14, 2                     # encoding: [0x20,0x04,0xc2,0x4d]
             btctr- 2
-# CHECK-BE: bcl 14, 2, target               # encoding: [0x41,0xc2,A,0bAAAAAA01]
-# CHECK-LE: bcl 14, 2, target               # encoding: [0bAAAAAA01,A,0xc2,0x41]
+# CHECK-BE: btl- 2, target                  # encoding: [0x41,0xc2,A,0bAAAAAA01]
+# CHECK-LE: btl- 2, target                  # encoding: [0bAAAAAA01,A,0xc2,0x41]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
             btl- 2, target
-# CHECK-BE: bcla 14, 2, target              # encoding: [0x41,0xc2,A,0bAAAAAA11]
-# CHECK-LE: bcla 14, 2, target              # encoding: [0bAAAAAA11,A,0xc2,0x41]
+# CHECK-BE: btla- 2, target                 # encoding: [0x41,0xc2,A,0bAAAAAA11]
+# CHECK-LE: btla- 2, target                 # encoding: [0bAAAAAA11,A,0xc2,0x41]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
             btla- 2, target
-# CHECK-BE: bclrl 14, 2, 0                  # encoding: [0x4d,0xc2,0x00,0x21]
-# CHECK-LE: bclrl 14, 2, 0                  # encoding: [0x21,0x00,0xc2,0x4d]
+# CHECK-BE: bclrl 14, 2                     # encoding: [0x4d,0xc2,0x00,0x21]
+# CHECK-LE: bclrl 14, 2                     # encoding: [0x21,0x00,0xc2,0x4d]
             btlrl- 2
-# CHECK-BE: bcctrl 14, 2, 0                 # encoding: [0x4d,0xc2,0x04,0x21]
-# CHECK-LE: bcctrl 14, 2, 0                 # encoding: [0x21,0x04,0xc2,0x4d]
+# CHECK-BE: bcctrl 14, 2                    # encoding: [0x4d,0xc2,0x04,0x21]
+# CHECK-LE: bcctrl 14, 2                    # encoding: [0x21,0x04,0xc2,0x4d]
             btctrl- 2
 
-# CHECK-BE: bc 4, 2, target                 # encoding: [0x40,0x82,A,0bAAAAAA00]
-# CHECK-LE: bc 4, 2, target                 # encoding: [0bAAAAAA00,A,0x82,0x40]
+# CHECK-BE: bf 2, target                    # encoding: [0x40,0x82,A,0bAAAAAA00]
+# CHECK-LE: bf 2, target                    # encoding: [0bAAAAAA00,A,0x82,0x40]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
             bf 2, target
-# CHECK-BE: bca 4, 2, target                # encoding: [0x40,0x82,A,0bAAAAAA10]
-# CHECK-LE: bca 4, 2, target                # encoding: [0bAAAAAA10,A,0x82,0x40]
+# CHECK-BE: bfa 2, target                   # encoding: [0x40,0x82,A,0bAAAAAA10]
+# CHECK-LE: bfa 2, target                   # encoding: [0bAAAAAA10,A,0x82,0x40]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
             bfa 2, target
-# CHECK-BE: bclr 4, 2, 0                    # encoding: [0x4c,0x82,0x00,0x20]
-# CHECK-LE: bclr 4, 2, 0                    # encoding: [0x20,0x00,0x82,0x4c]
+# CHECK-BE: bclr 4, 2                       # encoding: [0x4c,0x82,0x00,0x20]
+# CHECK-LE: bclr 4, 2                       # encoding: [0x20,0x00,0x82,0x4c]
             bflr 2
-# CHECK-BE: bcctr 4, 2, 0                   # encoding: [0x4c,0x82,0x04,0x20]
-# CHECK-LE: bcctr 4, 2, 0                   # encoding: [0x20,0x04,0x82,0x4c]
+# CHECK-BE: bcctr 4, 2                      # encoding: [0x4c,0x82,0x04,0x20]
+# CHECK-LE: bcctr 4, 2                      # encoding: [0x20,0x04,0x82,0x4c]
             bfctr 2
-# CHECK-BE: bcl 4, 2, target                # encoding: [0x40,0x82,A,0bAAAAAA01]
-# CHECK-LE: bcl 4, 2, target                # encoding: [0bAAAAAA01,A,0x82,0x40]
+# CHECK-BE: bfl 2, target                   # encoding: [0x40,0x82,A,0bAAAAAA01]
+# CHECK-LE: bfl 2, target                   # encoding: [0bAAAAAA01,A,0x82,0x40]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
             bfl 2, target
-# CHECK-BE: bcla 4, 2, target               # encoding: [0x40,0x82,A,0bAAAAAA11]
-# CHECK-LE: bcla 4, 2, target               # encoding: [0bAAAAAA11,A,0x82,0x40]
+# CHECK-BE: bfla 2, target                  # encoding: [0x40,0x82,A,0bAAAAAA11]
+# CHECK-LE: bfla 2, target                  # encoding: [0bAAAAAA11,A,0x82,0x40]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
             bfla 2, target
-# CHECK-BE: bclrl 4, 2, 0                   # encoding: [0x4c,0x82,0x00,0x21]
-# CHECK-LE: bclrl 4, 2, 0                   # encoding: [0x21,0x00,0x82,0x4c]
+# CHECK-BE: bclrl 4, 2                      # encoding: [0x4c,0x82,0x00,0x21]
+# CHECK-LE: bclrl 4, 2                      # encoding: [0x21,0x00,0x82,0x4c]
             bflrl 2
-# CHECK-BE: bcctrl 4, 2, 0                  # encoding: [0x4c,0x82,0x04,0x21]
-# CHECK-LE: bcctrl 4, 2, 0                  # encoding: [0x21,0x04,0x82,0x4c]
+# CHECK-BE: bcctrl 4, 2                     # encoding: [0x4c,0x82,0x04,0x21]
+# CHECK-LE: bcctrl 4, 2                     # encoding: [0x21,0x04,0x82,0x4c]
             bfctrl 2
 
-# CHECK-BE: bc 7, 2, target                 # encoding: [0x40,0xe2,A,0bAAAAAA00]
-# CHECK-LE: bc 7, 2, target                 # encoding: [0bAAAAAA00,A,0xe2,0x40]
+# CHECK-BE: bf+ 2, target                   # encoding: [0x40,0xe2,A,0bAAAAAA00]
+# CHECK-LE: bf+ 2, target                   # encoding: [0bAAAAAA00,A,0xe2,0x40]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
             bf+ 2, target
-# CHECK-BE: bca 7, 2, target                # encoding: [0x40,0xe2,A,0bAAAAAA10]
-# CHECK-LE: bca 7, 2, target                # encoding: [0bAAAAAA10,A,0xe2,0x40]
+# CHECK-BE: bfa+ 2, target                  # encoding: [0x40,0xe2,A,0bAAAAAA10]
+# CHECK-LE: bfa+ 2, target                  # encoding: [0bAAAAAA10,A,0xe2,0x40]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
             bfa+ 2, target
-# CHECK-BE: bclr 7, 2, 0                    # encoding: [0x4c,0xe2,0x00,0x20]
-# CHECK-LE: bclr 7, 2, 0                    # encoding: [0x20,0x00,0xe2,0x4c]
+# CHECK-BE: bclr 7, 2                       # encoding: [0x4c,0xe2,0x00,0x20]
+# CHECK-LE: bclr 7, 2                       # encoding: [0x20,0x00,0xe2,0x4c]
             bflr+ 2
-# CHECK-BE: bcctr 7, 2, 0                   # encoding: [0x4c,0xe2,0x04,0x20]
-# CHECK-LE: bcctr 7, 2, 0                   # encoding: [0x20,0x04,0xe2,0x4c]
+# CHECK-BE: bcctr 7, 2                      # encoding: [0x4c,0xe2,0x04,0x20]
+# CHECK-LE: bcctr 7, 2                      # encoding: [0x20,0x04,0xe2,0x4c]
             bfctr+ 2
-# CHECK-BE: bcl 7, 2, target                # encoding: [0x40,0xe2,A,0bAAAAAA01]
-# CHECK-LE: bcl 7, 2, target                # encoding: [0bAAAAAA01,A,0xe2,0x40]
+# CHECK-BE: bfl+ 2, target                  # encoding: [0x40,0xe2,A,0bAAAAAA01]
+# CHECK-LE: bfl+ 2, target                  # encoding: [0bAAAAAA01,A,0xe2,0x40]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
             bfl+ 2, target
-# CHECK-BE: bcla 7, 2, target               # encoding: [0x40,0xe2,A,0bAAAAAA11]
-# CHECK-LE: bcla 7, 2, target               # encoding: [0bAAAAAA11,A,0xe2,0x40]
+# CHECK-BE: bfla+ 2, target                 # encoding: [0x40,0xe2,A,0bAAAAAA11]
+# CHECK-LE: bfla+ 2, target                 # encoding: [0bAAAAAA11,A,0xe2,0x40]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
             bfla+ 2, target
-# CHECK-BE: bclrl 7, 2, 0                   # encoding: [0x4c,0xe2,0x00,0x21]
-# CHECK-LE: bclrl 7, 2, 0                   # encoding: [0x21,0x00,0xe2,0x4c]
+# CHECK-BE: bclrl 7, 2                      # encoding: [0x4c,0xe2,0x00,0x21]
+# CHECK-LE: bclrl 7, 2                      # encoding: [0x21,0x00,0xe2,0x4c]
             bflrl+ 2
-# CHECK-BE: bcctrl 7, 2, 0                  # encoding: [0x4c,0xe2,0x04,0x21]
-# CHECK-LE: bcctrl 7, 2, 0                  # encoding: [0x21,0x04,0xe2,0x4c]
+# CHECK-BE: bcctrl 7, 2                     # encoding: [0x4c,0xe2,0x04,0x21]
+# CHECK-LE: bcctrl 7, 2                     # encoding: [0x21,0x04,0xe2,0x4c]
             bfctrl+ 2
 
-# CHECK-BE: bc 6, 2, target                 # encoding: [0x40,0xc2,A,0bAAAAAA00]
-# CHECK-LE: bc 6, 2, target                 # encoding: [0bAAAAAA00,A,0xc2,0x40]
+# CHECK-BE: bf- 2, target                   # encoding: [0x40,0xc2,A,0bAAAAAA00]
+# CHECK-LE: bf- 2, target                   # encoding: [0bAAAAAA00,A,0xc2,0x40]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
             bf- 2, target
-# CHECK-BE: bca 6, 2, target                # encoding: [0x40,0xc2,A,0bAAAAAA10]
-# CHECK-LE: bca 6, 2, target                # encoding: [0bAAAAAA10,A,0xc2,0x40]
+# CHECK-BE: bfa- 2, target                  # encoding: [0x40,0xc2,A,0bAAAAAA10]
+# CHECK-LE: bfa- 2, target                  # encoding: [0bAAAAAA10,A,0xc2,0x40]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
             bfa- 2, target
-# CHECK-BE: bclr 6, 2, 0                    # encoding: [0x4c,0xc2,0x00,0x20]
-# CHECK-LE: bclr 6, 2, 0                    # encoding: [0x20,0x00,0xc2,0x4c]
+# CHECK-BE: bclr 6, 2                       # encoding: [0x4c,0xc2,0x00,0x20]
+# CHECK-LE: bclr 6, 2                       # encoding: [0x20,0x00,0xc2,0x4c]
             bflr- 2
-# CHECK-BE: bcctr 6, 2, 0                   # encoding: [0x4c,0xc2,0x04,0x20]
-# CHECK-LE: bcctr 6, 2, 0                   # encoding: [0x20,0x04,0xc2,0x4c]
+# CHECK-BE: bcctr 6, 2                      # encoding: [0x4c,0xc2,0x04,0x20]
+# CHECK-LE: bcctr 6, 2                      # encoding: [0x20,0x04,0xc2,0x4c]
             bfctr- 2
-# CHECK-BE: bcl 6, 2, target                # encoding: [0x40,0xc2,A,0bAAAAAA01]
-# CHECK-LE: bcl 6, 2, target                # encoding: [0bAAAAAA01,A,0xc2,0x40]
+# CHECK-BE: bfl- 2, target                  # encoding: [0x40,0xc2,A,0bAAAAAA01]
+# CHECK-LE: bfl- 2, target                  # encoding: [0bAAAAAA01,A,0xc2,0x40]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
             bfl- 2, target
-# CHECK-BE: bcla 6, 2, target               # encoding: [0x40,0xc2,A,0bAAAAAA11]
-# CHECK-LE: bcla 6, 2, target               # encoding: [0bAAAAAA11,A,0xc2,0x40]
+# CHECK-BE: bfla- 2, target                 # encoding: [0x40,0xc2,A,0bAAAAAA11]
+# CHECK-LE: bfla- 2, target                 # encoding: [0bAAAAAA11,A,0xc2,0x40]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
             bfla- 2, target
-# CHECK-BE: bclrl 6, 2, 0                   # encoding: [0x4c,0xc2,0x00,0x21]
-# CHECK-LE: bclrl 6, 2, 0                   # encoding: [0x21,0x00,0xc2,0x4c]
+# CHECK-BE: bclrl 6, 2                      # encoding: [0x4c,0xc2,0x00,0x21]
+# CHECK-LE: bclrl 6, 2                      # encoding: [0x21,0x00,0xc2,0x4c]
             bflrl- 2
-# CHECK-BE: bcctrl 6, 2, 0                  # encoding: [0x4c,0xc2,0x04,0x21]
-# CHECK-LE: bcctrl 6, 2, 0                  # encoding: [0x21,0x04,0xc2,0x4c]
+# CHECK-BE: bcctrl 6, 2                     # encoding: [0x4c,0xc2,0x04,0x21]
+# CHECK-LE: bcctrl 6, 2                     # encoding: [0x21,0x04,0xc2,0x4c]
             bfctrl- 2
 
 # CHECK-BE: bdnz target                     # encoding: [0x42,0x00,A,0bAAAAAA00]
 # CHECK-LE: bdnzlrl-                        # encoding: [0x21,0x00,0x00,0x4f]
             bdnzlrl-
 
-# CHECK-BE: bc 8, 2, target                 # encoding: [0x41,0x02,A,0bAAAAAA00]
-# CHECK-LE: bc 8, 2, target                 # encoding: [0bAAAAAA00,A,0x02,0x41]
+# CHECK-BE: bdnzt 2, target                 # encoding: [0x41,0x02,A,0bAAAAAA00]
+# CHECK-LE: bdnzt 2, target                 # encoding: [0bAAAAAA00,A,0x02,0x41]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
             bdnzt 2, target
-# CHECK-BE: bca 8, 2, target                # encoding: [0x41,0x02,A,0bAAAAAA10]
-# CHECK-LE: bca 8, 2, target                # encoding: [0bAAAAAA10,A,0x02,0x41]
+# CHECK-BE: bdnzta 2, target                # encoding: [0x41,0x02,A,0bAAAAAA10]
+# CHECK-LE: bdnzta 2, target                # encoding: [0bAAAAAA10,A,0x02,0x41]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
             bdnzta 2, target
-# CHECK-BE: bclr 8, 2, 0                    # encoding: [0x4d,0x02,0x00,0x20]
-# CHECK-LE: bclr 8, 2, 0                    # encoding: [0x20,0x00,0x02,0x4d]
+# CHECK-BE: bclr 8, 2                       # encoding: [0x4d,0x02,0x00,0x20]
+# CHECK-LE: bclr 8, 2                       # encoding: [0x20,0x00,0x02,0x4d]
             bdnztlr 2
-# CHECK-BE: bcl 8, 2, target                # encoding: [0x41,0x02,A,0bAAAAAA01]
-# CHECK-LE: bcl 8, 2, target                # encoding: [0bAAAAAA01,A,0x02,0x41]
+# CHECK-BE: bdnztl 2, target                # encoding: [0x41,0x02,A,0bAAAAAA01]
+# CHECK-LE: bdnztl 2, target                # encoding: [0bAAAAAA01,A,0x02,0x41]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
             bdnztl 2, target
-# CHECK-BE: bcla 8, 2, target               # encoding: [0x41,0x02,A,0bAAAAAA11]
-# CHECK-LE: bcla 8, 2, target               # encoding: [0bAAAAAA11,A,0x02,0x41]
+# CHECK-BE: bdnztla 2, target               # encoding: [0x41,0x02,A,0bAAAAAA11]
+# CHECK-LE: bdnztla 2, target               # encoding: [0bAAAAAA11,A,0x02,0x41]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
             bdnztla 2, target
-# CHECK-BE: bclrl 8, 2, 0                   # encoding: [0x4d,0x02,0x00,0x21]
-# CHECK-LE: bclrl 8, 2, 0                   # encoding: [0x21,0x00,0x02,0x4d]
+# CHECK-BE: bclrl 8, 2                      # encoding: [0x4d,0x02,0x00,0x21]
+# CHECK-LE: bclrl 8, 2                      # encoding: [0x21,0x00,0x02,0x4d]
             bdnztlrl 2
 
-# CHECK-BE: bc 0, 2, target                 # encoding: [0x40,0x02,A,0bAAAAAA00]
-# CHECK-LE: bc 0, 2, target                 # encoding: [0bAAAAAA00,A,0x02,0x40]
+# CHECK-BE: bdnzf 2, target                 # encoding: [0x40,0x02,A,0bAAAAAA00]
+# CHECK-LE: bdnzf 2, target                 # encoding: [0bAAAAAA00,A,0x02,0x40]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
             bdnzf 2, target
-# CHECK-BE: bca 0, 2, target                # encoding: [0x40,0x02,A,0bAAAAAA10]
-# CHECK-LE: bca 0, 2, target                # encoding: [0bAAAAAA10,A,0x02,0x40]
+# CHECK-BE: bdnzfa 2, target                # encoding: [0x40,0x02,A,0bAAAAAA10]
+# CHECK-LE: bdnzfa 2, target                # encoding: [0bAAAAAA10,A,0x02,0x40]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
             bdnzfa 2, target
-# CHECK-BE: bclr 0, 2, 0                    # encoding: [0x4c,0x02,0x00,0x20]
-# CHECK-LE: bclr 0, 2, 0                    # encoding: [0x20,0x00,0x02,0x4c]
+# CHECK-BE: bclr 0, 2                       # encoding: [0x4c,0x02,0x00,0x20]
+# CHECK-LE: bclr 0, 2                       # encoding: [0x20,0x00,0x02,0x4c]
             bdnzflr 2
-# CHECK-BE: bcl 0, 2, target                # encoding: [0x40,0x02,A,0bAAAAAA01]
-# CHECK-LE: bcl 0, 2, target                # encoding: [0bAAAAAA01,A,0x02,0x40]
+# CHECK-BE: bdnzfl 2, target                # encoding: [0x40,0x02,A,0bAAAAAA01]
+# CHECK-LE: bdnzfl 2, target                # encoding: [0bAAAAAA01,A,0x02,0x40]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
             bdnzfl 2, target
-# CHECK-BE: bcla 0, 2, target               # encoding: [0x40,0x02,A,0bAAAAAA11]
-# CHECK-LE: bcla 0, 2, target               # encoding: [0bAAAAAA11,A,0x02,0x40]
+# CHECK-BE: bdnzfla 2, target               # encoding: [0x40,0x02,A,0bAAAAAA11]
+# CHECK-LE: bdnzfla 2, target               # encoding: [0bAAAAAA11,A,0x02,0x40]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
             bdnzfla 2, target
-# CHECK-BE: bclrl 0, 2, 0                   # encoding: [0x4c,0x02,0x00,0x21]
-# CHECK-LE: bclrl 0, 2, 0                   # encoding: [0x21,0x00,0x02,0x4c]
+# CHECK-BE: bclrl 0, 2                      # encoding: [0x4c,0x02,0x00,0x21]
+# CHECK-LE: bclrl 0, 2                      # encoding: [0x21,0x00,0x02,0x4c]
             bdnzflrl 2
 
 # CHECK-BE: bdz target                      # encoding: [0x42,0x40,A,0bAAAAAA00]
 # CHECK-LE: bdzlrl-                         # encoding: [0x21,0x00,0x40,0x4f]
             bdzlrl-
 
-# CHECK-BE: bc 10, 2, target                # encoding: [0x41,0x42,A,0bAAAAAA00]
-# CHECK-LE: bc 10, 2, target                # encoding: [0bAAAAAA00,A,0x42,0x41]
+# CHECK-BE: bdzt 2, target                  # encoding: [0x41,0x42,A,0bAAAAAA00]
+# CHECK-LE: bdzt 2, target                  # encoding: [0bAAAAAA00,A,0x42,0x41]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
             bdzt 2, target
-# CHECK-BE: bca 10, 2, target               # encoding: [0x41,0x42,A,0bAAAAAA10]
-# CHECK-LE: bca 10, 2, target               # encoding: [0bAAAAAA10,A,0x42,0x41]
+# CHECK-BE: bdzta 2, target                 # encoding: [0x41,0x42,A,0bAAAAAA10]
+# CHECK-LE: bdzta 2, target                 # encoding: [0bAAAAAA10,A,0x42,0x41]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
             bdzta 2, target
-# CHECK-BE: bclr 10, 2, 0                   # encoding: [0x4d,0x42,0x00,0x20]
-# CHECK-LE: bclr 10, 2, 0                   # encoding: [0x20,0x00,0x42,0x4d]
+# CHECK-BE: bclr 10, 2                      # encoding: [0x4d,0x42,0x00,0x20]
+# CHECK-LE: bclr 10, 2                      # encoding: [0x20,0x00,0x42,0x4d]
             bdztlr 2
-# CHECK-BE: bcl 10, 2, target               # encoding: [0x41,0x42,A,0bAAAAAA01]
-# CHECK-LE: bcl 10, 2, target               # encoding: [0bAAAAAA01,A,0x42,0x41]
+# CHECK-BE: bdztl 2, target                 # encoding: [0x41,0x42,A,0bAAAAAA01]
+# CHECK-LE: bdztl 2, target                 # encoding: [0bAAAAAA01,A,0x42,0x41]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
             bdztl 2, target
-# CHECK-BE: bcla 10, 2, target              # encoding: [0x41,0x42,A,0bAAAAAA11]
-# CHECK-LE: bcla 10, 2, target              # encoding: [0bAAAAAA11,A,0x42,0x41]
+# CHECK-BE: bdztla 2, target                # encoding: [0x41,0x42,A,0bAAAAAA11]
+# CHECK-LE: bdztla 2, target                # encoding: [0bAAAAAA11,A,0x42,0x41]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
             bdztla 2, target
-# CHECK-BE: bclrl 10, 2, 0                  # encoding: [0x4d,0x42,0x00,0x21]
-# CHECK-LE: bclrl 10, 2, 0                  # encoding: [0x21,0x00,0x42,0x4d]
+# CHECK-BE: bclrl 10, 2                     # encoding: [0x4d,0x42,0x00,0x21]
+# CHECK-LE: bclrl 10, 2                     # encoding: [0x21,0x00,0x42,0x4d]
             bdztlrl 2
 
-# CHECK-BE: bc 2, 2, target                 # encoding: [0x40,0x42,A,0bAAAAAA00]
-# CHECK-LE: bc 2, 2, target                 # encoding: [0bAAAAAA00,A,0x42,0x40]
+# CHECK-BE: bdzf 2, target                  # encoding: [0x40,0x42,A,0bAAAAAA00]
+# CHECK-LE: bdzf 2, target                  # encoding: [0bAAAAAA00,A,0x42,0x40]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
             bdzf 2, target
-# CHECK-BE: bca 2, 2, target                # encoding: [0x40,0x42,A,0bAAAAAA10]
-# CHECK-LE: bca 2, 2, target                # encoding: [0bAAAAAA10,A,0x42,0x40]
+# CHECK-BE: bdzfa 2, target                 # encoding: [0x40,0x42,A,0bAAAAAA10]
+# CHECK-LE: bdzfa 2, target                 # encoding: [0bAAAAAA10,A,0x42,0x40]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
             bdzfa 2, target
-# CHECK-BE: bclr 2, 2, 0                    # encoding: [0x4c,0x42,0x00,0x20]
-# CHECK-LE: bclr 2, 2, 0                    # encoding: [0x20,0x00,0x42,0x4c]
+# CHECK-BE: bclr 2, 2                       # encoding: [0x4c,0x42,0x00,0x20]
+# CHECK-LE: bclr 2, 2                       # encoding: [0x20,0x00,0x42,0x4c]
             bdzflr 2
-# CHECK-BE: bcl 2, 2, target                # encoding: [0x40,0x42,A,0bAAAAAA01]
-# CHECK-LE: bcl 2, 2, target                # encoding: [0bAAAAAA01,A,0x42,0x40]
+# CHECK-BE: bdzfl 2, target                 # encoding: [0x40,0x42,A,0bAAAAAA01]
+# CHECK-LE: bdzfl 2, target                 # encoding: [0bAAAAAA01,A,0x42,0x40]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14
             bdzfl 2, target
-# CHECK-BE: bcla 2, 2, target               # encoding: [0x40,0x42,A,0bAAAAAA11]
-# CHECK-LE: bcla 2, 2, target               # encoding: [0bAAAAAA11,A,0x42,0x40]
+# CHECK-BE: bdzfla 2, target                # encoding: [0x40,0x42,A,0bAAAAAA11]
+# CHECK-LE: bdzfla 2, target                # encoding: [0bAAAAAA11,A,0x42,0x40]
 # CHECK-BE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
 # CHECK-LE-NEXT:                            #   fixup A - offset: 0, value: target, kind: fixup_ppc_brcond14abs
             bdzfla 2, target
-# CHECK-BE: bclrl 2, 2, 0                   # encoding: [0x4c,0x42,0x00,0x21]
-# CHECK-LE: bclrl 2, 2, 0                   # encoding: [0x21,0x00,0x42,0x4c]
+# CHECK-BE: bclrl 2, 2                      # encoding: [0x4c,0x42,0x00,0x21]
+# CHECK-LE: bclrl 2, 2                      # encoding: [0x21,0x00,0x42,0x4c]
             bdzflrl 2
 
 # CHECK-BE: blt 2, target                   # encoding: [0x41,0x88,A,0bAAAAAA00]
 
 # Condition register logical mnemonics
 
-# CHECK-BE: creqv 2, 2, 2                   # encoding: [0x4c,0x42,0x12,0x42]
-# CHECK-LE: creqv 2, 2, 2                   # encoding: [0x42,0x12,0x42,0x4c]
+# CHECK-BE: crset 2                         # encoding: [0x4c,0x42,0x12,0x42]
+# CHECK-LE: crset 2                         # encoding: [0x42,0x12,0x42,0x4c]
             crset 2
-# CHECK-BE: crxor 2, 2, 2                   # encoding: [0x4c,0x42,0x11,0x82]
-# CHECK-LE: crxor 2, 2, 2                   # encoding: [0x82,0x11,0x42,0x4c]
+# CHECK-BE: crclr 2                         # encoding: [0x4c,0x42,0x11,0x82]
+# CHECK-LE: crclr 2                         # encoding: [0x82,0x11,0x42,0x4c]
             crclr 2
-# CHECK-BE: cror 2, 3, 3                    # encoding: [0x4c,0x43,0x1b,0x82]
-# CHECK-LE: cror 2, 3, 3                    # encoding: [0x82,0x1b,0x43,0x4c]
+# CHECK-BE: crmove 2, 3                     # encoding: [0x4c,0x43,0x1b,0x82]
+# CHECK-LE: crmove 2, 3                     # encoding: [0x82,0x1b,0x43,0x4c]
             crmove 2, 3
-# CHECK-BE: crnor 2, 3, 3                   # encoding: [0x4c,0x43,0x18,0x42]
-# CHECK-LE: crnor 2, 3, 3                   # encoding: [0x42,0x18,0x43,0x4c]
+# CHECK-BE: crnot 2, 3                      # encoding: [0x4c,0x43,0x18,0x42]
+# CHECK-LE: crnot 2, 3                      # encoding: [0x42,0x18,0x43,0x4c]
             crnot 2, 3
 
 # Subtract mnemonics
 # CHECK-LE: addic. 2, 3, -128               # encoding: [0x80,0xff,0x43,0x34]
             subic. 2, 3, 128
 
-# CHECK-BE: subf 2, 4, 3                    # encoding: [0x7c,0x44,0x18,0x50]
-# CHECK-LE: subf 2, 4, 3                    # encoding: [0x50,0x18,0x44,0x7c]
+# CHECK-BE: sub 2, 3, 4                     # encoding: [0x7c,0x44,0x18,0x50]
+# CHECK-LE: sub 2, 3, 4                     # encoding: [0x50,0x18,0x44,0x7c]
             sub 2, 3, 4
-# CHECK-BE: subf. 2, 4, 3                   # encoding: [0x7c,0x44,0x18,0x51]
-# CHECK-LE: subf. 2, 4, 3                   # encoding: [0x51,0x18,0x44,0x7c]
+# CHECK-BE: sub. 2, 3, 4                    # encoding: [0x7c,0x44,0x18,0x51]
+# CHECK-LE: sub. 2, 3, 4                    # encoding: [0x51,0x18,0x44,0x7c]
             sub. 2, 3, 4
-# CHECK-BE: subfc 2, 4, 3                   # encoding: [0x7c,0x44,0x18,0x10]
-# CHECK-LE: subfc 2, 4, 3                   # encoding: [0x10,0x18,0x44,0x7c]
+# CHECK-BE: subc 2, 3, 4                    # encoding: [0x7c,0x44,0x18,0x10]
+# CHECK-LE: subc 2, 3, 4                    # encoding: [0x10,0x18,0x44,0x7c]
             subc 2, 3, 4
-# CHECK-BE: subfc. 2, 4, 3                  # encoding: [0x7c,0x44,0x18,0x11]
-# CHECK-LE: subfc. 2, 4, 3                  # encoding: [0x11,0x18,0x44,0x7c]
+# CHECK-BE: subc. 2, 3, 4                   # encoding: [0x7c,0x44,0x18,0x11]
+# CHECK-LE: subc. 2, 3, 4                   # encoding: [0x11,0x18,0x44,0x7c]
             subc. 2, 3, 4
 
 # Compare mnemonics
 # CHECK-BE: cmpdi 2, 3, 128                 # encoding: [0x2d,0x23,0x00,0x80]
 # CHECK-LE: cmpdi 2, 3, 128                 # encoding: [0x80,0x00,0x23,0x2d]
             cmpdi 2, 3, 128
-# CHECK-BE: cmpdi 0, 3, 128                 # encoding: [0x2c,0x23,0x00,0x80]
-# CHECK-LE: cmpdi 0, 3, 128                 # encoding: [0x80,0x00,0x23,0x2c]
+# CHECK-BE: cmpdi 3, 128                    # encoding: [0x2c,0x23,0x00,0x80]
+# CHECK-LE: cmpdi 3, 128                    # encoding: [0x80,0x00,0x23,0x2c]
             cmpdi 3, 128
 # CHECK-BE: cmpd 2, 3, 4                    # encoding: [0x7d,0x23,0x20,0x00]
 # CHECK-LE: cmpd 2, 3, 4                    # encoding: [0x00,0x20,0x23,0x7d]
             cmpd 2, 3, 4
-# CHECK-BE: cmpd 0, 3, 4                    # encoding: [0x7c,0x23,0x20,0x00]
-# CHECK-LE: cmpd 0, 3, 4                    # encoding: [0x00,0x20,0x23,0x7c]
+# CHECK-BE: cmpd 3, 4                       # encoding: [0x7c,0x23,0x20,0x00]
+# CHECK-LE: cmpd 3, 4                       # encoding: [0x00,0x20,0x23,0x7c]
             cmpd 3, 4
 # CHECK-BE: cmpldi 2, 3, 128                # encoding: [0x29,0x23,0x00,0x80]
 # CHECK-LE: cmpldi 2, 3, 128                # encoding: [0x80,0x00,0x23,0x29]
             cmpldi 2, 3, 128
-# CHECK-BE: cmpldi 0, 3, 128                # encoding: [0x28,0x23,0x00,0x80]
-# CHECK-LE: cmpldi 0, 3, 128                # encoding: [0x80,0x00,0x23,0x28]
+# CHECK-BE: cmpldi 3, 128                   # encoding: [0x28,0x23,0x00,0x80]
+# CHECK-LE: cmpldi 3, 128                   # encoding: [0x80,0x00,0x23,0x28]
             cmpldi 3, 128
 # CHECK-BE: cmpld 2, 3, 4                   # encoding: [0x7d,0x23,0x20,0x40]
 # CHECK-LE: cmpld 2, 3, 4                   # encoding: [0x40,0x20,0x23,0x7d]
             cmpld 2, 3, 4
-# CHECK-BE: cmpld 0, 3, 4                   # encoding: [0x7c,0x23,0x20,0x40]
-# CHECK-LE: cmpld 0, 3, 4                   # encoding: [0x40,0x20,0x23,0x7c]
+# CHECK-BE: cmpld 3, 4                      # encoding: [0x7c,0x23,0x20,0x40]
+# CHECK-LE: cmpld 3, 4                      # encoding: [0x40,0x20,0x23,0x7c]
             cmpld 3, 4
 
 # CHECK-BE: cmpwi 2, 3, 128                 # encoding: [0x2d,0x03,0x00,0x80]
 # CHECK-LE: cmpwi 2, 3, 128                 # encoding: [0x80,0x00,0x03,0x2d]
             cmpwi 2, 3, 128
-# CHECK-BE: cmpwi 0, 3, 128                 # encoding: [0x2c,0x03,0x00,0x80]
-# CHECK-LE: cmpwi 0, 3, 128                 # encoding: [0x80,0x00,0x03,0x2c]
+# CHECK-BE: cmpwi 3, 128                    # encoding: [0x2c,0x03,0x00,0x80]
+# CHECK-LE: cmpwi 3, 128                    # encoding: [0x80,0x00,0x03,0x2c]
             cmpwi 3, 128
 # CHECK-BE: cmpw 2, 3, 4                    # encoding: [0x7d,0x03,0x20,0x00]
 # CHECK-LE: cmpw 2, 3, 4                    # encoding: [0x00,0x20,0x03,0x7d]
             cmpw 2, 3, 4
-# CHECK-BE: cmpw 0, 3, 4                    # encoding: [0x7c,0x03,0x20,0x00]
-# CHECK-LE: cmpw 0, 3, 4                    # encoding: [0x00,0x20,0x03,0x7c]
+# CHECK-BE: cmpw 3, 4                       # encoding: [0x7c,0x03,0x20,0x00]
+# CHECK-LE: cmpw 3, 4                       # encoding: [0x00,0x20,0x03,0x7c]
             cmpw 3, 4
 # CHECK-BE: cmplwi 2, 3, 128                # encoding: [0x29,0x03,0x00,0x80]
 # CHECK-LE: cmplwi 2, 3, 128                # encoding: [0x80,0x00,0x03,0x29]
             cmplwi 2, 3, 128
-# CHECK-BE: cmplwi 0, 3, 128                # encoding: [0x28,0x03,0x00,0x80]
-# CHECK-LE: cmplwi 0, 3, 128                # encoding: [0x80,0x00,0x03,0x28]
+# CHECK-BE: cmplwi 3, 128                   # encoding: [0x28,0x03,0x00,0x80]
+# CHECK-LE: cmplwi 3, 128                   # encoding: [0x80,0x00,0x03,0x28]
             cmplwi 3, 128
 # CHECK-BE: cmplw 2, 3, 4                   # encoding: [0x7d,0x03,0x20,0x40]
 # CHECK-LE: cmplw 2, 3, 4                   # encoding: [0x40,0x20,0x03,0x7d]
             cmplw 2, 3, 4
-# CHECK-BE: cmplw 0, 3, 4                   # encoding: [0x7c,0x03,0x20,0x40]
-# CHECK-LE: cmplw 0, 3, 4                   # encoding: [0x40,0x20,0x03,0x7c]
+# CHECK-BE: cmplw 3, 4                      # encoding: [0x7c,0x03,0x20,0x40]
+# CHECK-LE: cmplw 3, 4                      # encoding: [0x40,0x20,0x03,0x7c]
             cmplw 3, 4
 
 # Trap mnemonics
 
-# CHECK-BE: twi 16, 3, 4                    # encoding: [0x0e,0x03,0x00,0x04]
-# CHECK-LE: twi 16, 3, 4                    # encoding: [0x04,0x00,0x03,0x0e]
+# CHECK-BE: twlti 3, 4                      # encoding: [0x0e,0x03,0x00,0x04]
+# CHECK-LE: twlti 3, 4                      # encoding: [0x04,0x00,0x03,0x0e]
             twlti 3, 4
-# CHECK-BE: tw 16, 3, 4                     # encoding: [0x7e,0x03,0x20,0x08]
-# CHECK-LE: tw 16, 3, 4                     # encoding: [0x08,0x20,0x03,0x7e]
+# CHECK-BE: twlt 3, 4                       # encoding: [0x7e,0x03,0x20,0x08]
+# CHECK-LE: twlt 3, 4                       # encoding: [0x08,0x20,0x03,0x7e]
             twlt 3, 4
-# CHECK-BE: tdi 16, 3, 4                    # encoding: [0x0a,0x03,0x00,0x04]
-# CHECK-LE: tdi 16, 3, 4                    # encoding: [0x04,0x00,0x03,0x0a]
+# CHECK-BE: tdlti 3, 4                      # encoding: [0x0a,0x03,0x00,0x04]
+# CHECK-LE: tdlti 3, 4                      # encoding: [0x04,0x00,0x03,0x0a]
             tdlti 3, 4
-# CHECK-BE: td 16, 3, 4                     # encoding: [0x7e,0x03,0x20,0x88]
-# CHECK-LE: td 16, 3, 4                     # encoding: [0x88,0x20,0x03,0x7e]
+# CHECK-BE: tdlt 3, 4                       # encoding: [0x7e,0x03,0x20,0x88]
+# CHECK-LE: tdlt 3, 4                       # encoding: [0x88,0x20,0x03,0x7e]
             tdlt 3, 4
 
 # CHECK-BE: twi 20, 3, 4                    # encoding: [0x0e,0x83,0x00,0x04]
 # CHECK-LE: td 20, 3, 4                     # encoding: [0x88,0x20,0x83,0x7e]
             tdle 3, 4
 
-# CHECK-BE: twi 4, 3, 4                     # encoding: [0x0c,0x83,0x00,0x04]
-# CHECK-LE: twi 4, 3, 4                     # encoding: [0x04,0x00,0x83,0x0c]
+# CHECK-BE: tweqi 3, 4                      # encoding: [0x0c,0x83,0x00,0x04]
+# CHECK-LE: tweqi 3, 4                      # encoding: [0x04,0x00,0x83,0x0c]
             tweqi 3, 4
-# CHECK-BE: tw 4, 3, 4                      # encoding: [0x7c,0x83,0x20,0x08]
-# CHECK-LE: tw 4, 3, 4                      # encoding: [0x08,0x20,0x83,0x7c]
+# CHECK-BE: tweq 3, 4                       # encoding: [0x7c,0x83,0x20,0x08]
+# CHECK-LE: tweq 3, 4                       # encoding: [0x08,0x20,0x83,0x7c]
             tweq 3, 4
-# CHECK-BE: tdi 4, 3, 4                     # encoding: [0x08,0x83,0x00,0x04]
-# CHECK-LE: tdi 4, 3, 4                     # encoding: [0x04,0x00,0x83,0x08]
+# CHECK-BE: tdeqi 3, 4                      # encoding: [0x08,0x83,0x00,0x04]
+# CHECK-LE: tdeqi 3, 4                      # encoding: [0x04,0x00,0x83,0x08]
             tdeqi 3, 4
-# CHECK-BE: td 4, 3, 4                      # encoding: [0x7c,0x83,0x20,0x88]
-# CHECK-LE: td 4, 3, 4                      # encoding: [0x88,0x20,0x83,0x7c]
+# CHECK-BE: tdeq 3, 4                       # encoding: [0x7c,0x83,0x20,0x88]
+# CHECK-LE: tdeq 3, 4                       # encoding: [0x88,0x20,0x83,0x7c]
             tdeq 3, 4
 
 # CHECK-BE: twi 12, 3, 4                    # encoding: [0x0d,0x83,0x00,0x04]
 # CHECK-LE: td 12, 3, 4                     # encoding: [0x88,0x20,0x83,0x7d]
             tdge 3, 4
 
-# CHECK-BE: twi 8, 3, 4                     # encoding: [0x0d,0x03,0x00,0x04]
-# CHECK-LE: twi 8, 3, 4                     # encoding: [0x04,0x00,0x03,0x0d]
+# CHECK-BE: twgti 3, 4                      # encoding: [0x0d,0x03,0x00,0x04]
+# CHECK-LE: twgti 3, 4                      # encoding: [0x04,0x00,0x03,0x0d]
             twgti 3, 4
-# CHECK-BE: tw 8, 3, 4                      # encoding: [0x7d,0x03,0x20,0x08]
-# CHECK-LE: tw 8, 3, 4                      # encoding: [0x08,0x20,0x03,0x7d]
+# CHECK-BE: twgt 3, 4                       # encoding: [0x7d,0x03,0x20,0x08]
+# CHECK-LE: twgt 3, 4                       # encoding: [0x08,0x20,0x03,0x7d]
             twgt 3, 4
-# CHECK-BE: tdi 8, 3, 4                     # encoding: [0x09,0x03,0x00,0x04]
-# CHECK-LE: tdi 8, 3, 4                     # encoding: [0x04,0x00,0x03,0x09]
+# CHECK-BE: tdgti 3, 4                      # encoding: [0x09,0x03,0x00,0x04]
+# CHECK-LE: tdgti 3, 4                      # encoding: [0x04,0x00,0x03,0x09]
             tdgti 3, 4
-# CHECK-BE: td 8, 3, 4                      # encoding: [0x7d,0x03,0x20,0x88]
-# CHECK-LE: td 8, 3, 4                      # encoding: [0x88,0x20,0x03,0x7d]
+# CHECK-BE: tdgt 3, 4                       # encoding: [0x7d,0x03,0x20,0x88]
+# CHECK-LE: tdgt 3, 4                       # encoding: [0x88,0x20,0x03,0x7d]
             tdgt 3, 4
 
 # CHECK-BE: twi 12, 3, 4                    # encoding: [0x0d,0x83,0x00,0x04]
 # CHECK-LE: td 12, 3, 4                     # encoding: [0x88,0x20,0x83,0x7d]
             tdnl 3, 4
 
-# CHECK-BE: twi 24, 3, 4                    # encoding: [0x0f,0x03,0x00,0x04]
-# CHECK-LE: twi 24, 3, 4                    # encoding: [0x04,0x00,0x03,0x0f]
+# CHECK-BE: twnei 3, 4                      # encoding: [0x0f,0x03,0x00,0x04]
+# CHECK-LE: twnei 3, 4                      # encoding: [0x04,0x00,0x03,0x0f]
             twnei 3, 4
-# CHECK-BE: tw 24, 3, 4                     # encoding: [0x7f,0x03,0x20,0x08]
-# CHECK-LE: tw 24, 3, 4                     # encoding: [0x08,0x20,0x03,0x7f]
+# CHECK-BE: twne 3, 4                       # encoding: [0x7f,0x03,0x20,0x08]
+# CHECK-LE: twne 3, 4                       # encoding: [0x08,0x20,0x03,0x7f]
             twne 3, 4
-# CHECK-BE: tdi 24, 3, 4                    # encoding: [0x0b,0x03,0x00,0x04]
-# CHECK-LE: tdi 24, 3, 4                    # encoding: [0x04,0x00,0x03,0x0b]
+# CHECK-BE: tdnei 3, 4                      # encoding: [0x0b,0x03,0x00,0x04]
+# CHECK-LE: tdnei 3, 4                      # encoding: [0x04,0x00,0x03,0x0b]
             tdnei 3, 4
-# CHECK-BE: td 24, 3, 4                     # encoding: [0x7f,0x03,0x20,0x88]
-# CHECK-LE: td 24, 3, 4                     # encoding: [0x88,0x20,0x03,0x7f]
+# CHECK-BE: tdne 3, 4                       # encoding: [0x7f,0x03,0x20,0x88]
+# CHECK-LE: tdne 3, 4                       # encoding: [0x88,0x20,0x03,0x7f]
             tdne 3, 4
 
 # CHECK-BE: twi 20, 3, 4                    # encoding: [0x0e,0x83,0x00,0x04]
 # CHECK-LE: td 20, 3, 4                     # encoding: [0x88,0x20,0x83,0x7e]
             tdng 3, 4
 
-# CHECK-BE: twi 2, 3, 4                     # encoding: [0x0c,0x43,0x00,0x04]
-# CHECK-LE: twi 2, 3, 4                     # encoding: [0x04,0x00,0x43,0x0c]
+# CHECK-BE: twllti 3, 4                     # encoding: [0x0c,0x43,0x00,0x04]
+# CHECK-LE: twllti 3, 4                     # encoding: [0x04,0x00,0x43,0x0c]
             twllti 3, 4
-# CHECK-BE: tw 2, 3, 4                      # encoding: [0x7c,0x43,0x20,0x08]
-# CHECK-LE: tw 2, 3, 4                      # encoding: [0x08,0x20,0x43,0x7c]
+# CHECK-BE: twllt 3, 4                      # encoding: [0x7c,0x43,0x20,0x08]
+# CHECK-LE: twllt 3, 4                      # encoding: [0x08,0x20,0x43,0x7c]
             twllt 3, 4
-# CHECK-BE: tdi 2, 3, 4                     # encoding: [0x08,0x43,0x00,0x04]
-# CHECK-LE: tdi 2, 3, 4                     # encoding: [0x04,0x00,0x43,0x08]
+# CHECK-BE: tdllti 3, 4                     # encoding: [0x08,0x43,0x00,0x04]
+# CHECK-LE: tdllti 3, 4                     # encoding: [0x04,0x00,0x43,0x08]
             tdllti 3, 4
-# CHECK-BE: td 2, 3, 4                      # encoding: [0x7c,0x43,0x20,0x88]
-# CHECK-LE: td 2, 3, 4                      # encoding: [0x88,0x20,0x43,0x7c]
+# CHECK-BE: tdllt 3, 4                      # encoding: [0x7c,0x43,0x20,0x88]
+# CHECK-LE: tdllt 3, 4                      # encoding: [0x88,0x20,0x43,0x7c]
             tdllt 3, 4
 
 # CHECK-BE: twi 6, 3, 4                     # encoding: [0x0c,0xc3,0x00,0x04]
 # CHECK-LE: td 5, 3, 4                      # encoding: [0x88,0x20,0xa3,0x7c]
             tdlge 3, 4
 
-# CHECK-BE: twi 1, 3, 4                     # encoding: [0x0c,0x23,0x00,0x04]
-# CHECK-LE: twi 1, 3, 4                     # encoding: [0x04,0x00,0x23,0x0c]
+# CHECK-BE: twlgti 3, 4                     # encoding: [0x0c,0x23,0x00,0x04]
+# CHECK-LE: twlgti 3, 4                     # encoding: [0x04,0x00,0x23,0x0c]
             twlgti 3, 4
-# CHECK-BE: tw 1, 3, 4                      # encoding: [0x7c,0x23,0x20,0x08]
-# CHECK-LE: tw 1, 3, 4                      # encoding: [0x08,0x20,0x23,0x7c]
+# CHECK-BE: twlgt 3, 4                      # encoding: [0x7c,0x23,0x20,0x08]
+# CHECK-LE: twlgt 3, 4                      # encoding: [0x08,0x20,0x23,0x7c]
             twlgt 3, 4
-# CHECK-BE: tdi 1, 3, 4                     # encoding: [0x08,0x23,0x00,0x04]
-# CHECK-LE: tdi 1, 3, 4                     # encoding: [0x04,0x00,0x23,0x08]
+# CHECK-BE: tdlgti 3, 4                     # encoding: [0x08,0x23,0x00,0x04]
+# CHECK-LE: tdlgti 3, 4                     # encoding: [0x04,0x00,0x23,0x08]
             tdlgti 3, 4
-# CHECK-BE: td 1, 3, 4                      # encoding: [0x7c,0x23,0x20,0x88]
-# CHECK-LE: td 1, 3, 4                      # encoding: [0x88,0x20,0x23,0x7c]
+# CHECK-BE: tdlgt 3, 4                      # encoding: [0x7c,0x23,0x20,0x88]
+# CHECK-LE: tdlgt 3, 4                      # encoding: [0x88,0x20,0x23,0x7c]
             tdlgt 3, 4
 
 # CHECK-BE: twi 5, 3, 4                     # encoding: [0x0c,0xa3,0x00,0x04]
 # CHECK-LE: td 6, 3, 4                      # encoding: [0x88,0x20,0xc3,0x7c]
             tdlng 3, 4
 
-# CHECK-BE: twi 31, 3, 4                    # encoding: [0x0f,0xe3,0x00,0x04]
-# CHECK-LE: twi 31, 3, 4                    # encoding: [0x04,0x00,0xe3,0x0f]
+# CHECK-BE: twui 3, 4                       # encoding: [0x0f,0xe3,0x00,0x04]
+# CHECK-LE: twui 3, 4                       # encoding: [0x04,0x00,0xe3,0x0f]
             twui 3, 4
-# CHECK-BE: tw 31, 3, 4                     # encoding: [0x7f,0xe3,0x20,0x08]
-# CHECK-LE: tw 31, 3, 4                     # encoding: [0x08,0x20,0xe3,0x7f]
+# CHECK-BE: twu 3, 4                        # encoding: [0x7f,0xe3,0x20,0x08]
+# CHECK-LE: twu 3, 4                        # encoding: [0x08,0x20,0xe3,0x7f]
             twu 3, 4
-# CHECK-BE: tdi 31, 3, 4                    # encoding: [0x0b,0xe3,0x00,0x04]
-# CHECK-LE: tdi 31, 3, 4                    # encoding: [0x04,0x00,0xe3,0x0b]
+# CHECK-BE: tdui 3, 4                       # encoding: [0x0b,0xe3,0x00,0x04]
+# CHECK-LE: tdui 3, 4                       # encoding: [0x04,0x00,0xe3,0x0b]
             tdui 3, 4
-# CHECK-BE: td 31, 3, 4                     # encoding: [0x7f,0xe3,0x20,0x88]
-# CHECK-LE: td 31, 3, 4                     # encoding: [0x88,0x20,0xe3,0x7f]
+# CHECK-BE: tdu 3, 4                         # encoding: [0x7f,0xe3,0x20,0x88]
+# CHECK-LE: tdu 3, 4                         # encoding: [0x88,0x20,0xe3,0x7f]
             tdu 3, 4
 
 # CHECK-BE: trap                            # encoding: [0x7f,0xe0,0x00,0x08]
 # CHECK-BE: rldimi. 2, 3, 55, 5             # encoding: [0x78,0x62,0xb9,0x4f]
 # CHECK-LE: rldimi. 2, 3, 55, 5             # encoding: [0x4f,0xb9,0x62,0x78]
             insrdi. 2, 3, 4, 5
-# CHECK-BE: rldicl 2, 3, 4, 0               # encoding: [0x78,0x62,0x20,0x00]
-# CHECK-LE: rldicl 2, 3, 4, 0               # encoding: [0x00,0x20,0x62,0x78]
+# CHECK-BE: rotldi 2, 3, 4                  # encoding: [0x78,0x62,0x20,0x00]
+# CHECK-LE: rotldi 2, 3, 4                  # encoding: [0x00,0x20,0x62,0x78]
             rotldi 2, 3, 4
-# CHECK-BE: rldicl. 2, 3, 4, 0              # encoding: [0x78,0x62,0x20,0x01]
-# CHECK-LE: rldicl. 2, 3, 4, 0              # encoding: [0x01,0x20,0x62,0x78]
+# CHECK-BE: rotldi. 2, 3, 4                 # encoding: [0x78,0x62,0x20,0x01]
+# CHECK-LE: rotldi. 2, 3, 4                 # encoding: [0x01,0x20,0x62,0x78]
             rotldi. 2, 3, 4
-# CHECK-BE: rldicl 2, 3, 60, 0              # encoding: [0x78,0x62,0xe0,0x02]
-# CHECK-LE: rldicl 2, 3, 60, 0              # encoding: [0x02,0xe0,0x62,0x78]
+# CHECK-BE: rotldi 2, 3, 60                 # encoding: [0x78,0x62,0xe0,0x02]
+# CHECK-LE: rotldi 2, 3, 60                 # encoding: [0x02,0xe0,0x62,0x78]
             rotrdi 2, 3, 4
-# CHECK-BE: rldicl. 2, 3, 60, 0             # encoding: [0x78,0x62,0xe0,0x03]
-# CHECK-LE: rldicl. 2, 3, 60, 0             # encoding: [0x03,0xe0,0x62,0x78]
+# CHECK-BE: rotldi. 2, 3, 60                # encoding: [0x78,0x62,0xe0,0x03]
+# CHECK-LE: rotldi. 2, 3, 60                # encoding: [0x03,0xe0,0x62,0x78]
             rotrdi. 2, 3, 4
-# CHECK-BE: rldcl 2, 3, 4, 0                # encoding: [0x78,0x62,0x20,0x10]
-# CHECK-LE: rldcl 2, 3, 4, 0                # encoding: [0x10,0x20,0x62,0x78]
+# CHECK-BE: rotld 2, 3, 4                   # encoding: [0x78,0x62,0x20,0x10]
+# CHECK-LE: rotld 2, 3, 4                   # encoding: [0x10,0x20,0x62,0x78]
             rotld 2, 3, 4
-# CHECK-BE: rldcl. 2, 3, 4, 0               # encoding: [0x78,0x62,0x20,0x11]
-# CHECK-LE: rldcl. 2, 3, 4, 0               # encoding: [0x11,0x20,0x62,0x78]
+# CHECK-BE: rotld. 2, 3, 4                  # encoding: [0x78,0x62,0x20,0x11]
+# CHECK-LE: rotld. 2, 3, 4                  # encoding: [0x11,0x20,0x62,0x78]
             rotld. 2, 3, 4
 # CHECK-BE: sldi 2, 3, 4                    # encoding: [0x78,0x62,0x26,0xe4]
 # CHECK-LE: sldi 2, 3, 4                    # encoding: [0xe4,0x26,0x62,0x78]
 # CHECK-BE: rldicl. 2, 3, 60, 4             # encoding: [0x78,0x62,0xe1,0x03]
 # CHECK-LE: rldicl. 2, 3, 60, 4             # encoding: [0x03,0xe1,0x62,0x78]
             srdi. 2, 3, 4
-# CHECK-BE: rldicl 2, 3, 0, 4               # encoding: [0x78,0x62,0x01,0x00]
-# CHECK-LE: rldicl 2, 3, 0, 4               # encoding: [0x00,0x01,0x62,0x78]
+# CHECK-BE: clrldi 2, 3, 4                  # encoding: [0x78,0x62,0x01,0x00]
+# CHECK-LE: clrldi 2, 3, 4                  # encoding: [0x00,0x01,0x62,0x78]
             clrldi 2, 3, 4
-# CHECK-BE: rldicl. 2, 3, 0, 4              # encoding: [0x78,0x62,0x01,0x01]
-# CHECK-LE: rldicl. 2, 3, 0, 4              # encoding: [0x01,0x01,0x62,0x78]
+# CHECK-BE: clrldi. 2, 3, 4                 # encoding: [0x78,0x62,0x01,0x01]
+# CHECK-LE: clrldi. 2, 3, 4                 # encoding: [0x01,0x01,0x62,0x78]
             clrldi. 2, 3, 4
 # CHECK-BE: rldicr 2, 3, 0, 59              # encoding: [0x78,0x62,0x06,0xe4]
 # CHECK-LE: rldicr 2, 3, 0, 59              # encoding: [0xe4,0x06,0x62,0x78]
 # CHECK-BE: rlwimi. 2, 3, 23, 5, 8          # encoding: [0x50,0x62,0xb9,0x51]
 # CHECK-LE: rlwimi. 2, 3, 23, 5, 8          # encoding: [0x51,0xb9,0x62,0x50]
             insrwi. 2, 3, 4, 5
-# CHECK-BE: rlwinm 2, 3, 4, 0, 31           # encoding: [0x54,0x62,0x20,0x3e]
-# CHECK-LE: rlwinm 2, 3, 4, 0, 31           # encoding: [0x3e,0x20,0x62,0x54]
+# CHECK-BE: rotlwi 2, 3, 4                  # encoding: [0x54,0x62,0x20,0x3e]
+# CHECK-LE: rotlwi 2, 3, 4                  # encoding: [0x3e,0x20,0x62,0x54]
             rotlwi 2, 3, 4
-# CHECK-BE: rlwinm. 2, 3, 4, 0, 31          # encoding: [0x54,0x62,0x20,0x3f]
-# CHECK-LE: rlwinm. 2, 3, 4, 0, 31          # encoding: [0x3f,0x20,0x62,0x54]
+# CHECK-BE: rotlwi. 2, 3, 4                 # encoding: [0x54,0x62,0x20,0x3f]
+# CHECK-LE: rotlwi. 2, 3, 4                 # encoding: [0x3f,0x20,0x62,0x54]
             rotlwi. 2, 3, 4
-# CHECK-BE: rlwinm 2, 3, 28, 0, 31          # encoding: [0x54,0x62,0xe0,0x3e]
-# CHECK-LE: rlwinm 2, 3, 28, 0, 31          # encoding: [0x3e,0xe0,0x62,0x54]
+# CHECK-BE: rotlwi 2, 3, 28                 # encoding: [0x54,0x62,0xe0,0x3e]
+# CHECK-LE: rotlwi 2, 3, 28                 # encoding: [0x3e,0xe0,0x62,0x54]
             rotrwi 2, 3, 4
-# CHECK-BE: rlwinm. 2, 3, 28, 0, 31         # encoding: [0x54,0x62,0xe0,0x3f]
-# CHECK-LE: rlwinm. 2, 3, 28, 0, 31         # encoding: [0x3f,0xe0,0x62,0x54]
+# CHECK-BE: rotlwi. 2, 3, 28                # encoding: [0x54,0x62,0xe0,0x3f]
+# CHECK-LE: rotlwi. 2, 3, 28                # encoding: [0x3f,0xe0,0x62,0x54]
             rotrwi. 2, 3, 4
-# CHECK-BE: rlwnm 2, 3, 4, 0, 31            # encoding: [0x5c,0x62,0x20,0x3e]
-# CHECK-LE: rlwnm 2, 3, 4, 0, 31            # encoding: [0x3e,0x20,0x62,0x5c]
+# CHECK-BE: rotlw 2, 3, 4                   # encoding: [0x5c,0x62,0x20,0x3e]
+# CHECK-LE: rotlw 2, 3, 4                   # encoding: [0x3e,0x20,0x62,0x5c]
             rotlw 2, 3, 4
-# CHECK-BE: rlwnm. 2, 3, 4, 0, 31           # encoding: [0x5c,0x62,0x20,0x3f]
-# CHECK-LE: rlwnm. 2, 3, 4, 0, 31           # encoding: [0x3f,0x20,0x62,0x5c]
+# CHECK-BE: rotlw. 2, 3, 4                  # encoding: [0x5c,0x62,0x20,0x3f]
+# CHECK-LE: rotlw. 2, 3, 4                  # encoding: [0x3f,0x20,0x62,0x5c]
             rotlw. 2, 3, 4
 # CHECK-BE: slwi 2, 3, 4                    # encoding: [0x54,0x62,0x20,0x36]
 # CHECK-LE: slwi 2, 3, 4                    # encoding: [0x36,0x20,0x62,0x54]
 # CHECK-BE: rlwinm. 2, 3, 28, 4, 31         # encoding: [0x54,0x62,0xe1,0x3f]
 # CHECK-LE: rlwinm. 2, 3, 28, 4, 31         # encoding: [0x3f,0xe1,0x62,0x54]
             srwi. 2, 3, 4
-# CHECK-BE: rlwinm 2, 3, 0, 4, 31           # encoding: [0x54,0x62,0x01,0x3e]
-# CHECK-LE: rlwinm 2, 3, 0, 4, 31           # encoding: [0x3e,0x01,0x62,0x54]
+# CHECK-BE: clrlwi 2, 3, 4                  # encoding: [0x54,0x62,0x01,0x3e]
+# CHECK-LE: clrlwi 2, 3, 4                  # encoding: [0x3e,0x01,0x62,0x54]
             clrlwi 2, 3, 4
-# CHECK-BE: rlwinm. 2, 3, 0, 4, 31          # encoding: [0x54,0x62,0x01,0x3f]
-# CHECK-LE: rlwinm. 2, 3, 0, 4, 31          # encoding: [0x3f,0x01,0x62,0x54]
+# CHECK-BE: clrlwi. 2, 3, 4                 # encoding: [0x54,0x62,0x01,0x3f]
+# CHECK-LE: clrlwi. 2, 3, 4                 # encoding: [0x3f,0x01,0x62,0x54]
             clrlwi. 2, 3, 4
 # CHECK-BE: rlwinm 2, 3, 0, 0, 27           # encoding: [0x54,0x62,0x00,0x36]
 # CHECK-LE: rlwinm 2, 3, 0, 0, 27           # encoding: [0x36,0x00,0x62,0x54]
 
 # Move to/from special purpose register mnemonics
 
-# CHECK-BE: mtspr 1, 2                      # encoding: [0x7c,0x41,0x03,0xa6]
-# CHECK-LE: mtspr 1, 2                      # encoding: [0xa6,0x03,0x41,0x7c]
+# CHECK-BE: mtxer 2                         # encoding: [0x7c,0x41,0x03,0xa6]
+# CHECK-LE: mtxer 2                         # encoding: [0xa6,0x03,0x41,0x7c]
             mtxer 2
-# CHECK-BE: mfspr 2, 1                      # encoding: [0x7c,0x41,0x02,0xa6]
-# CHECK-LE: mfspr 2, 1                      # encoding: [0xa6,0x02,0x41,0x7c]
+# CHECK-BE: mfxer 2                         # encoding: [0x7c,0x41,0x02,0xa6]
+# CHECK-LE: mfxer 2                         # encoding: [0xa6,0x02,0x41,0x7c]
             mfxer 2
-# CHECK-BE: mtspr 17, 2                     # encoding: [0x7c,0x51,0x03,0xa6]
-# CHECK-LE: mtspr 17, 2                     # encoding: [0xa6,0x03,0x51,0x7c]
+# CHECK-BE: mfrtcu 2                        # encoding: [0x7c,0x44,0x02,0xa6]
+# CHECK-LE: mfrtcu 2                        # encoding: [0xa6,0x02,0x44,0x7c]
+            mfrtcu 2
+# CHECK-BE: mfrtcl 2                        # encoding: [0x7c,0x45,0x02,0xa6]
+# CHECK-LE: mfrtcl 2                        # encoding: [0xa6,0x02,0x45,0x7c]
+            mfrtcl 2
+# CHECK-BE: mtdscr 2                        # encoding: [0x7c,0x51,0x03,0xa6]
+# CHECK-LE: mtdscr 2                        # encoding: [0xa6,0x03,0x51,0x7c]
             mtdscr 2
-# CHECK-BE: mfspr 2, 17                     # encoding: [0x7c,0x51,0x02,0xa6]
-# CHECK-LE: mfspr 2, 17                     # encoding: [0xa6,0x02,0x51,0x7c]
+# CHECK-BE: mfdscr 2                        # encoding: [0x7c,0x51,0x02,0xa6]
+# CHECK-LE: mfdscr 2                        # encoding: [0xa6,0x02,0x51,0x7c]
             mfdscr 2
-# CHECK-BE: mtspr 18, 2                     # encoding: [0x7c,0x52,0x03,0xa6]
-# CHECK-LE: mtspr 18, 2                     # encoding: [0xa6,0x03,0x52,0x7c]
+# CHECK-BE: mtdsisr 2                       # encoding: [0x7c,0x52,0x03,0xa6]
+# CHECK-LE: mtdsisr 2                       # encoding: [0xa6,0x03,0x52,0x7c]
             mtdsisr 2
-# CHECK-BE: mfspr 2, 18                     # encoding: [0x7c,0x52,0x02,0xa6]
-# CHECK-LE: mfspr 2, 18                     # encoding: [0xa6,0x02,0x52,0x7c]
+# CHECK-BE: mfdsisr 2                       # encoding: [0x7c,0x52,0x02,0xa6]
+# CHECK-LE: mfdsisr 2                       # encoding: [0xa6,0x02,0x52,0x7c]
             mfdsisr 2
-# CHECK-BE: mtspr 19, 2                     # encoding: [0x7c,0x53,0x03,0xa6]
-# CHECK-LE: mtspr 19, 2                     # encoding: [0xa6,0x03,0x53,0x7c]
+# CHECK-BE: mtdar 2                         # encoding: [0x7c,0x53,0x03,0xa6]
+# CHECK-LE: mtdar 2                         # encoding: [0xa6,0x03,0x53,0x7c]
             mtdar 2
-# CHECK-BE: mfspr 2, 19                     # encoding: [0x7c,0x53,0x02,0xa6]
-# CHECK-LE: mfspr 2, 19                     # encoding: [0xa6,0x02,0x53,0x7c]
+# CHECK-BE: mfdar 2                         # encoding: [0x7c,0x53,0x02,0xa6]
+# CHECK-LE: mfdar 2                         # encoding: [0xa6,0x02,0x53,0x7c]
             mfdar 2
 # CHECK-BE: mtspr 22, 2                     # encoding: [0x7c,0x56,0x03,0xa6]
 # CHECK-LE: mtspr 22, 2                     # encoding: [0xa6,0x03,0x56,0x7c]
 # CHECK-BE: mfspr 2, 27                     # encoding: [0x7c,0x5b,0x02,0xa6]
 # CHECK-LE: mfspr 2, 27                     # encoding: [0xa6,0x02,0x5b,0x7c]
             mfsrr1 2
-# CHECK-BE: mtspr 28, 2                     # encoding: [0x7c,0x5c,0x03,0xa6]
-# CHECK-LE: mtspr 28, 2                     # encoding: [0xa6,0x03,0x5c,0x7c]
+# CHECK-BE: mtcfar 2                        # encoding: [0x7c,0x5c,0x03,0xa6]
+# CHECK-LE: mtcfar 2                        # encoding: [0xa6,0x03,0x5c,0x7c]
             mtcfar 2
-# CHECK-BE: mfspr 2, 28                     # encoding: [0x7c,0x5c,0x02,0xa6]
-# CHECK-LE: mfspr 2, 28                     # encoding: [0xa6,0x02,0x5c,0x7c]
+# CHECK-BE: mfcfar 2                        # encoding: [0x7c,0x5c,0x02,0xa6]
+# CHECK-LE: mfcfar 2                        # encoding: [0xa6,0x02,0x5c,0x7c]
             mfcfar 2
-# CHECK-BE: mtspr 29, 2                     # encoding: [0x7c,0x5d,0x03,0xa6]
-# CHECK-LE: mtspr 29, 2                     # encoding: [0xa6,0x03,0x5d,0x7c]
+# CHECK-BE: mtamr 2                         # encoding: [0x7c,0x5d,0x03,0xa6]
+# CHECK-LE: mtamr 2                         # encoding: [0xa6,0x03,0x5d,0x7c]
             mtamr 2
-# CHECK-BE: mfspr 2, 29                     # encoding: [0x7c,0x5d,0x02,0xa6]
-# CHECK-LE: mfspr 2, 29                     # encoding: [0xa6,0x02,0x5d,0x7c]
+# CHECK-BE: mfamr 2                         # encoding: [0x7c,0x5d,0x02,0xa6]
+# CHECK-LE: mfamr 2                         # encoding: [0xa6,0x02,0x5d,0x7c]
             mfamr 2
+# CHECK-BE: mtpid 2                         # encoding: [0x7c,0x50,0x0b,0xa6]
+# CHECK-LE: mtpid 2                         # encoding: [0xa6,0x0b,0x50,0x7c]
+            mtpid 2
+# CHECK-BE: mfpid 2                         # encoding: [0x7c,0x50,0x0a,0xa6]
+# CHECK-LE: mfpid 2                         # encoding: [0xa6,0x0a,0x50,0x7c]
+            mfpid 2
 # CHECK-BE: mtlr 2                          # encoding: [0x7c,0x48,0x03,0xa6]
 # CHECK-LE: mtlr 2                          # encoding: [0xa6,0x03,0x48,0x7c]
             mtlr 2
 # CHECK-BE: nop                             # encoding: [0x60,0x00,0x00,0x00]
 # CHECK-LE: nop                             # encoding: [0x00,0x00,0x00,0x60]
             nop
-# CHECK-BE: xori 0, 0, 0                    # encoding: [0x68,0x00,0x00,0x00]
-# CHECK-LE: xori 0, 0, 0                    # encoding: [0x00,0x00,0x00,0x68]
+# CHECK-BE: xnop                            # encoding: [0x68,0x00,0x00,0x00]
+# CHECK-LE: xnop                            # encoding: [0x00,0x00,0x00,0x68]
             xnop
 # CHECK-BE: li 2, 128                       # encoding: [0x38,0x40,0x00,0x80]
 # CHECK-LE: li 2, 128                       # encoding: [0x80,0x00,0x40,0x38]
 # CHECK-BE: mr 2, 3                         # encoding: [0x7c,0x62,0x1b,0x78]
 # CHECK-LE: mr 2, 3                         # encoding: [0x78,0x1b,0x62,0x7c]
             mr 2, 3
-# CHECK-BE: or. 2, 3, 3                     # encoding: [0x7c,0x62,0x1b,0x79]
-# CHECK-LE: or. 2, 3, 3                     # encoding: [0x79,0x1b,0x62,0x7c]
+# CHECK-BE: mr. 2, 3                        # encoding: [0x7c,0x62,0x1b,0x79]
+# CHECK-LE: mr. 2, 3                        # encoding: [0x79,0x1b,0x62,0x7c]
             mr. 2, 3
-# CHECK-BE: nor 2, 3, 3                     # encoding: [0x7c,0x62,0x18,0xf8]
-# CHECK-LE: nor 2, 3, 3                     # encoding: [0xf8,0x18,0x62,0x7c]
+# CHECK-BE: not 2, 3                        # encoding: [0x7c,0x62,0x18,0xf8]
+# CHECK-LE: not 2, 3                        # encoding: [0xf8,0x18,0x62,0x7c]
             not 2, 3
-# CHECK-BE: nor. 2, 3, 3                    # encoding: [0x7c,0x62,0x18,0xf9]
-# CHECK-LE: nor. 2, 3, 3                    # encoding: [0xf9,0x18,0x62,0x7c]
+# CHECK-BE: not. 2, 3                       # encoding: [0x7c,0x62,0x18,0xf9]
+# CHECK-LE: not. 2, 3                       # encoding: [0xf9,0x18,0x62,0x7c]
             not. 2, 3
-# CHECK-BE: mtcrf 255, 2                    # encoding: [0x7c,0x4f,0xf1,0x20]
-# CHECK-LE: mtcrf 255, 2                    # encoding: [0x20,0xf1,0x4f,0x7c]
+# CHECK-BE: mtcr 2                          # encoding: [0x7c,0x4f,0xf1,0x20]
+# CHECK-LE: mtcr 2                          # encoding: [0x20,0xf1,0x4f,0x7c]
             mtcr 2
 
+# CHECK-BE: mfspr 4, 272                    # encoding: [0x7c,0x90,0x42,0xa6]
+# CHECK-LE: mfspr 4, 272                    # encoding: [0xa6,0x42,0x90,0x7c]
+            mfsprg %r4, 0
+
+# CHECK-BE: mfspr 4, 273                    # encoding: [0x7c,0x91,0x42,0xa6]
+# CHECK-LE: mfspr 4, 273                    # encoding: [0xa6,0x42,0x91,0x7c]
+            mfsprg %r4, 1
+
+# CHECK-BE: mfspr 4, 274                    # encoding: [0x7c,0x92,0x42,0xa6]
+# CHECK-LE: mfspr 4, 274                    # encoding: [0xa6,0x42,0x92,0x7c]
+            mfsprg %r4, 2
+
+# CHECK-BE: mfspr 4, 275                    # encoding: [0x7c,0x93,0x42,0xa6]
+# CHECK-LE: mfspr 4, 275                    # encoding: [0xa6,0x42,0x93,0x7c]
+            mfsprg %r4, 3
+
+# CHECK-BE: mfspr 2, 272                    # encoding: [0x7c,0x50,0x42,0xa6]
+# CHECK-LE: mfspr 2, 272                    # encoding: [0xa6,0x42,0x50,0x7c]
+            mfsprg0 %r2
+# CHECK-BE: mfspr 2, 273                    # encoding: [0x7c,0x51,0x42,0xa6]
+# CHECK-LE: mfspr 2, 273                    # encoding: [0xa6,0x42,0x51,0x7c]
+            mfsprg1 %r2
+# CHECK-BE: mfspr 2, 274                    # encoding: [0x7c,0x52,0x42,0xa6]
+# CHECK-LE: mfspr 2, 274                    # encoding: [0xa6,0x42,0x52,0x7c]
+            mfsprg2 %r2
+# CHECK-BE: mfspr 2, 275                    # encoding: [0x7c,0x53,0x42,0xa6]
+# CHECK-LE: mfspr 2, 275                    # encoding: [0xa6,0x42,0x53,0x7c]
+            mfsprg3 %r2
+
+# CHECK-BE: mtspr 272, 4                    # encoding: [0x7c,0x90,0x43,0xa6]
+# CHECK-LE: mtspr 272, 4                    # encoding: [0xa6,0x43,0x90,0x7c]
+            mtsprg 0, %r4
+
+# CHECK-BE: mtspr 273, 4                    # encoding: [0x7c,0x91,0x43,0xa6]
+# CHECK-LE: mtspr 273, 4                    # encoding: [0xa6,0x43,0x91,0x7c]
+            mtsprg 1, %r4
+
+# CHECK-BE: mtspr 274, 4                    # encoding: [0x7c,0x92,0x43,0xa6]
+# CHECK-LE: mtspr 274, 4                    # encoding: [0xa6,0x43,0x92,0x7c]
+            mtsprg 2, %r4
+
+# CHECK-BE: mtspr 275, 4                    # encoding: [0x7c,0x93,0x43,0xa6]
+# CHECK-LE: mtspr 275, 4                    # encoding: [0xa6,0x43,0x93,0x7c]
+            mtsprg 3, %r4
+
+# CHECK-BE: mtspr 272, 4                    # encoding: [0x7c,0x90,0x43,0xa6]
+# CHECK-LE: mtspr 272, 4                    # encoding: [0xa6,0x43,0x90,0x7c]
+            mtsprg0 %r4
+
+# CHECK-BE: mtspr 273, 4                    # encoding: [0x7c,0x91,0x43,0xa6]
+# CHECK-LE: mtspr 273, 4                    # encoding: [0xa6,0x43,0x91,0x7c]
+            mtsprg1 %r4
+
+# CHECK-BE: mtspr 274, 4                    # encoding: [0x7c,0x92,0x43,0xa6]
+# CHECK-LE: mtspr 274, 4                    # encoding: [0xa6,0x43,0x92,0x7c]
+            mtsprg2 %r4
+
+# CHECK-BE: mtspr 275, 4                    # encoding: [0x7c,0x93,0x43,0xa6]
+# CHECK-LE: mtspr 275, 4                    # encoding: [0xa6,0x43,0x93,0x7c]
+            mtsprg3 %r4
+
+# Altivec Data Stream instruction:
+# CHECK-BE: dss 3                            # encoding: [0x7c,0x60,0x06,0x6c]
+# CHECK-LE: dss 3                            # encoding: [0x6c,0x06,0x60,0x7c]
+            dss 3
+# CHECK-BE: dssall                           # encoding: [0x7e,0x00,0x06,0x6c]
+# CHECK-LE: dssall                           # encoding: [0x6c,0x06,0x00,0x7e]
+            dssall
+# CHECK-BE: dst 12, 11, 3                    # encoding: [0x7c,0x6c,0x5a,0xac]
+# CHECK-LE: dst 12, 11, 3                    # encoding: [0xac,0x5a,0x6c,0x7c]
+            dst %r12, %r11, 3
+# CHECK-BE: dstt 12, 11, 3                   # encoding: [0x7e,0x6c,0x5a,0xac]
+# CHECK-LE: dstt 12, 11, 3                   # encoding: [0xac,0x5a,0x6c,0x7e]
+            dstt %r12, %r11, 3
+# CHECK-BE: dstst 12, 11, 3                  # encoding: [0x7c,0x6c,0x5a,0xec]
+# CHECK-LE: dstst 12, 11, 3                  # encoding: [0xec,0x5a,0x6c,0x7c]
+            dstst %r12, %r11, 3
+# CHECK-BE: dststt 12, 11, 3                 # encoding: [0x7e,0x6c,0x5a,0xec]
+# CHECK-LE: dststt 12, 11, 3                 # encoding: [0xec,0x5a,0x6c,0x7e]
+            dststt %r12, %r11, 3
+
+# CHECK-BE: tlbia                            # encoding: [0x7c,0x00,0x02,0xe4]
+# CHECK-LE: tlbia                            # encoding: [0xe4,0x02,0x00,0x7c]
+            tlbia
+
+# CHECK-BE: lswi 8, 6, 7                     # encoding: [0x7d,0x06,0x3c,0xaa]
+# CHECK-LE: lswi 8, 6, 7                     # encoding: [0xaa,0x3c,0x06,0x7d]
+            lswi %r8, %r6, 7
+# CHECK-BE: stswi 8, 6, 7                    # encoding: [0x7d,0x06,0x3d,0xaa]
+# CHECK-LE: stswi 8, 6, 7                    # encoding: [0xaa,0x3d,0x06,0x7d]
+            stswi %r8, %r6, 7
+
+# CHECK-BE: rfid                             # encoding: [0x4c,0x00,0x00,0x24]
+# CHECK-LE: rfid                             # encoding: [0x24,0x00,0x00,0x4c]
+            rfid
+
+# CHECK-BE: mfasr 2                          # encoding: [0x7c,0x58,0x42,0xa6]
+# CHECK-LE: mfasr 2                          # encoding: [0xa6,0x42,0x58,0x7c]
+            mfasr 2
+# CHECK-BE: mtspr 280, 2                     # encoding: [0x7c,0x58,0x43,0xa6]
+# CHECK-LE: mtspr 280, 2                     # encoding: [0xa6,0x43,0x58,0x7c]
+            mtasr 2
+
+# Load and Store Caching Inhibited Instructions
+# CHECK-BE: lbzcix 21, 5, 7                  # encoding: [0x7e,0xa5,0x3e,0xaa]
+# CHECK-LE: lbzcix 21, 5, 7                  # encoding: [0xaa,0x3e,0xa5,0x7e]
+            lbzcix 21, 5, 7
+# CHECK-BE: lhzcix 21, 5, 7                  # encoding: [0x7e,0xa5,0x3e,0x6a]
+# CHECK-LE: lhzcix 21, 5, 7                  # encoding: [0x6a,0x3e,0xa5,0x7e]
+            lhzcix 21, 5, 7
+# CHECK-BE: lwzcix 21, 5, 7                  # encoding: [0x7e,0xa5,0x3e,0x2a]
+# CHECK-LE: lwzcix 21, 5, 7                  # encoding: [0x2a,0x3e,0xa5,0x7e]
+            lwzcix 21, 5, 7
+# CHECK-BE: ldcix  21, 5, 7                  # encoding: [0x7e,0xa5,0x3e,0xea]
+# CHECK-LE: ldcix  21, 5, 7                  # encoding: [0xea,0x3e,0xa5,0x7e]
+            ldcix  21, 5, 7
+            
+# CHECK-BE: stbcix 21, 5, 7                  # encoding: [0x7e,0xa5,0x3f,0xaa]
+# CHECK-LE: stbcix 21, 5, 7                  # encoding: [0xaa,0x3f,0xa5,0x7e]
+            stbcix 21, 5, 7
+# CHECK-BE: sthcix 21, 5, 7                  # encoding: [0x7e,0xa5,0x3f,0x6a]
+# CHECK-LE: sthcix 21, 5, 7                  # encoding: [0x6a,0x3f,0xa5,0x7e]
+            sthcix 21, 5, 7
+# CHECK-BE: stwcix 21, 5, 7                  # encoding: [0x7e,0xa5,0x3f,0x2a]
+# CHECK-LE: stwcix 21, 5, 7                  # encoding: [0x2a,0x3f,0xa5,0x7e]
+            stwcix 21, 5, 7
+# CHECK-BE: stdcix 21, 5, 7                  # encoding: [0x7e,0xa5,0x3f,0xea]
+# CHECK-LE: stdcix 21, 5, 7                  # encoding: [0xea,0x3f,0xa5,0x7e]
+            stdcix 21, 5, 7
+
+# Processor-Specific Instructions
+# CHECK-BE: attn                             # encoding: [0x00,0x00,0x02,0x00]
+# CHECK-LE: attn                             # encoding: [0x00,0x02,0x00,0x00]
+            attn
+