[SystemZ] Add decimal floating-point instructions

This adds assembler / disassembler support for the decimal
floating-point instructions.  Since LLVM does not yet have
support for decimal float types, these cannot be used for
codegen at this point.

llvm-svn: 304203

llvm/lib/Target/SystemZ/SystemZ.td

@@ -55,6 +55,7 @@ include "SystemZInstrInfo.td"
 include "SystemZInstrVector.td"
 include "SystemZInstrFP.td"
 include "SystemZInstrHFP.td"
+include "SystemZInstrDFP.td"
 
 def SystemZInstrInfo : InstrInfo {}
 

llvm/lib/Target/SystemZ/SystemZFeatures.td

@@ -115,12 +115,18 @@ def FeatureTransactionalExecution : SystemZFeature<
   "Assume that the transactional-execution facility is installed"
 >;
 
+def FeatureDFPZonedConversion : SystemZFeature<
+  "dfp-zoned-conversion", "DFPZonedConversion",
+  "Assume that the DFP zoned-conversion facility is installed"
+>;
+
 def Arch10NewFeatures : SystemZFeatureList<[
     FeatureExecutionHint,
     FeatureLoadAndTrap,
     FeatureMiscellaneousExtensions,
     FeatureProcessorAssist,
-    FeatureTransactionalExecution
+    FeatureTransactionalExecution,
+    FeatureDFPZonedConversion
 ]>;
 
 //===----------------------------------------------------------------------===//
@@ -144,6 +150,11 @@ def FeatureMessageSecurityAssist5 : SystemZFeature<
   "Assume that the message-security-assist extension facility 5 is installed"
 >;
 
+def FeatureDFPPackedConversion : SystemZFeature<
+  "dfp-packed-conversion", "DFPPackedConversion",
+  "Assume that the DFP packed-conversion facility is installed"
+>;
+
 def FeatureVector : SystemZFeature<
   "vector", "Vector",
   "Assume that the vectory facility is installed"
@@ -154,6 +165,7 @@ def Arch11NewFeatures : SystemZFeatureList<[
     FeatureLoadAndZeroRightmostByte,
     FeatureLoadStoreOnCond2,
     FeatureMessageSecurityAssist5,
+    FeatureDFPPackedConversion,
     FeatureVector
 ]>;
 

llvm/lib/Target/SystemZ/SystemZInstrDFP.td

@@ -0,0 +1,231 @@
+//==- SystemZInstrDFP.td - Floating-point SystemZ instructions -*- tblgen-*-==//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// The instructions in this file implement SystemZ decimal floating-point
+// arithmetic.  These instructions are inot currently used for code generation,
+// are provided for use with the assembler and disassembler only.  If LLVM
+// ever supports decimal floating-point types (_Decimal64 etc.), they can
+// also be used for code generation for those types.
+//
+//===----------------------------------------------------------------------===//
+
+//===----------------------------------------------------------------------===//
+// Move instructions
+//===----------------------------------------------------------------------===//
+
+// Load and test.
+let Defs = [CC] in {
+  def LTDTR : UnaryRRE<"ltdtr", 0xB3D6, null_frag, FP64,  FP64>;
+  def LTXTR : UnaryRRE<"ltxtr", 0xB3DE, null_frag, FP128, FP128>;
+}
+
+
+//===----------------------------------------------------------------------===//
+// Conversion instructions
+//===----------------------------------------------------------------------===//
+
+// Convert floating-point values to narrower representations.  The destination
+// of LDXTR is a 128-bit value, but only the first register of the pair is used.
+def LEDTR : TernaryRRFe<"ledtr", 0xB3D5, FP32,  FP64>;
+def LDXTR : TernaryRRFe<"ldxtr", 0xB3DD, FP128, FP128>;
+
+// Extend floating-point values to wider representations.
+def LDETR : BinaryRRFd<"ldetr", 0xB3D4, FP64,  FP32>;
+def LXDTR : BinaryRRFd<"lxdtr", 0xB3DC, FP128, FP64>;
+
+// Convert a signed integer value to a floating-point one.
+def CDGTR : UnaryRRE<"cdgtr", 0xB3F1, null_frag, FP64,  GR64>;
+def CXGTR : UnaryRRE<"cxgtr", 0xB3F9, null_frag, FP128, GR64>;
+let Predicates = [FeatureFPExtension] in {
+  def CDGTRA : TernaryRRFe<"cdgtra", 0xB3F1, FP64,  GR64>;
+  def CXGTRA : TernaryRRFe<"cxgtra", 0xB3F9, FP128, GR64>;
+  def CDFTR : TernaryRRFe<"cdftr", 0xB951, FP64,  GR32>;
+  def CXFTR : TernaryRRFe<"cxftr", 0xB959, FP128, GR32>;
+}
+
+// Convert an unsigned integer value to a floating-point one.
+let Predicates = [FeatureFPExtension] in {
+  def CDLGTR : TernaryRRFe<"cdlgtr", 0xB952, FP64,  GR64>;
+  def CXLGTR : TernaryRRFe<"cxlgtr", 0xB95A, FP128, GR64>;
+  def CDLFTR : TernaryRRFe<"cdlftr", 0xB953, FP64,  GR32>;
+  def CXLFTR : TernaryRRFe<"cxlftr", 0xB95B, FP128, GR32>;
+}
+
+// Convert a floating-point value to a signed integer value.
+let Defs = [CC] in {
+  def CGDTR : BinaryRRFe<"cgdtr", 0xB3E1, GR64, FP64>;
+  def CGXTR : BinaryRRFe<"cgxtr", 0xB3E9, GR64, FP128>;
+  let Predicates = [FeatureFPExtension] in {
+    def CGDTRA : TernaryRRFe<"cgdtra", 0xB3E1, GR64, FP64>;
+    def CGXTRA : TernaryRRFe<"cgxtra", 0xB3E9, GR64, FP128>;
+    def CFDTR : TernaryRRFe<"cfdtr", 0xB941, GR32, FP64>;
+    def CFXTR : TernaryRRFe<"cfxtr", 0xB949, GR32, FP128>;
+  }
+}
+
+// Convert a floating-point value to an unsigned integer value.
+let Defs = [CC] in {
+  let Predicates = [FeatureFPExtension] in {
+    def CLGDTR : TernaryRRFe<"clgdtr", 0xB942, GR64, FP64>;
+    def CLGXTR : TernaryRRFe<"clgxtr", 0xB94A, GR64, FP128>;
+    def CLFDTR : TernaryRRFe<"clfdtr", 0xB943, GR32, FP64>;
+    def CLFXTR : TernaryRRFe<"clfxtr", 0xB94B, GR32, FP128>;
+  }
+}
+
+// Convert a packed value to a floating-point one.
+def CDSTR : UnaryRRE<"cdstr", 0xB3F3, null_frag, FP64,  GR64>;
+def CXSTR : UnaryRRE<"cxstr", 0xB3FB, null_frag, FP128, GR128>;
+def CDUTR : UnaryRRE<"cdutr", 0xB3F2, null_frag, FP64,  GR64>;
+def CXUTR : UnaryRRE<"cxutr", 0xB3FA, null_frag, FP128, GR128>;
+
+// Convert a floating-point value to a packed value.
+def CSDTR : BinaryRRFd<"csdtr", 0xB3E3, GR64,  FP64>;
+def CSXTR : BinaryRRFd<"csxtr", 0xB3EB, GR128, FP128>;
+def CUDTR : UnaryRRE<"cudtr", 0xB3E2, null_frag, GR64,  FP64>;
+def CUXTR : UnaryRRE<"cuxtr", 0xB3EA, null_frag, GR128, FP128>;
+
+// Convert from/to memory values in the zoned format.
+let Predicates = [FeatureDFPZonedConversion] in {
+  def CDZT : BinaryRSL<"cdzt", 0xEDAA, FP64>;
+  def CXZT : BinaryRSL<"cxzt", 0xEDAB, FP128>;
+  def CZDT : StoreBinaryRSL<"czdt", 0xEDA8, FP64>;
+  def CZXT : StoreBinaryRSL<"czxt", 0xEDA9, FP128>;
+}
+
+// Convert from/to memory values in the packed format.
+let Predicates = [FeatureDFPPackedConversion] in {
+  def CDPT : BinaryRSL<"cdpt", 0xEDAE, FP64>;
+  def CXPT : BinaryRSL<"cxpt", 0xEDAF, FP128>;
+  def CPDT : StoreBinaryRSL<"cpdt", 0xEDAC, FP64>;
+  def CPXT : StoreBinaryRSL<"cpxt", 0xEDAD, FP128>;
+}
+
+// Perform floating-point operation.
+let Defs = [CC, R1L, F0Q], Uses = [R0L, F4Q] in
+  def PFPO : SideEffectInherentE<"pfpo", 0x010A>;
+
+
+//===----------------------------------------------------------------------===//
+// Unary arithmetic
+//===----------------------------------------------------------------------===//
+
+// Round to an integer, with the second operand (M3) specifying the rounding
+// mode.  M4 can be set to 4 to suppress detection of inexact conditions.
+def FIDTR : TernaryRRFe<"fidtr", 0xB3D7, FP64,  FP64>;
+def FIXTR : TernaryRRFe<"fixtr", 0xB3DF, FP128, FP128>;
+
+// Extract biased exponent.
+def EEDTR : UnaryRRE<"eedtr", 0xB3E5, null_frag, FP64,  FP64>;
+def EEXTR : UnaryRRE<"eextr", 0xB3ED, null_frag, FP128, FP128>;
+
+// Extract significance.
+def ESDTR : UnaryRRE<"esdtr", 0xB3E7, null_frag, FP64,  FP64>;
+def ESXTR : UnaryRRE<"esxtr", 0xB3EF, null_frag, FP128, FP128>;
+
+
+//===----------------------------------------------------------------------===//
+// Binary arithmetic
+//===----------------------------------------------------------------------===//
+
+// Addition.
+let Defs = [CC] in {
+  let isCommutable = 1 in {
+    def ADTR : BinaryRRFa<"adtr", 0xB3D2, null_frag, FP64,  FP64,  FP64>;
+    def AXTR : BinaryRRFa<"axtr", 0xB3DA, null_frag, FP128, FP128, FP128>;
+  }
+  let Predicates = [FeatureFPExtension] in {
+    def ADTRA : TernaryRRFa<"adtra", 0xB3D2, FP64,  FP64,  FP64>;
+    def AXTRA : TernaryRRFa<"axtra", 0xB3DA, FP128, FP128, FP128>;
+  }
+}
+
+// Subtraction.
+let Defs = [CC] in {
+  def SDTR : BinaryRRFa<"sdtr", 0xB3D3, null_frag, FP64,  FP64,  FP64>;
+  def SXTR : BinaryRRFa<"sxtr", 0xB3DB, null_frag, FP128, FP128, FP128>;
+  let Predicates = [FeatureFPExtension] in {
+    def SDTRA : TernaryRRFa<"sdtra", 0xB3D3, FP64,  FP64,  FP64>;
+    def SXTRA : TernaryRRFa<"sxtra", 0xB3DB, FP128, FP128, FP128>;
+  }
+}
+
+// Multiplication.
+let isCommutable = 1 in {
+  def MDTR : BinaryRRFa<"mdtr", 0xB3D0, null_frag, FP64,  FP64,  FP64>;
+  def MXTR : BinaryRRFa<"mxtr", 0xB3D8, null_frag, FP128, FP128, FP128>;
+}
+let Predicates = [FeatureFPExtension] in {
+  def MDTRA : TernaryRRFa<"mdtra", 0xB3D0, FP64,  FP64,  FP64>;
+  def MXTRA : TernaryRRFa<"mxtra", 0xB3D8, FP128, FP128, FP128>;
+}
+
+// Division.
+def DDTR : BinaryRRFa<"ddtr", 0xB3D1, null_frag, FP64,  FP64,  FP64>;
+def DXTR : BinaryRRFa<"dxtr", 0xB3D9, null_frag, FP128, FP128, FP128>;
+let Predicates = [FeatureFPExtension] in {
+  def DDTRA : TernaryRRFa<"ddtra", 0xB3D1, FP64,  FP64,  FP64>;
+  def DXTRA : TernaryRRFa<"dxtra", 0xB3D9, FP128, FP128, FP128>;
+}
+
+// Quantize.
+def QADTR : TernaryRRFb<"qadtr", 0xB3F5, FP64,  FP64,  FP64>;
+def QAXTR : TernaryRRFb<"qaxtr", 0xB3FD, FP128, FP128, FP128>;
+
+// Reround.
+def RRDTR : TernaryRRFb<"rrdtr", 0xB3F7, FP64,  FP64,  FP64>;
+def RRXTR : TernaryRRFb<"rrxtr", 0xB3FF, FP128, FP128, FP128>;
+
+// Shift significand left/right.
+def SLDT : BinaryRXF<"sldt", 0xED40, null_frag, FP64,  FP64,  null_frag, 0>;
+def SLXT : BinaryRXF<"slxt", 0xED48, null_frag, FP128, FP128, null_frag, 0>;
+def SRDT : BinaryRXF<"srdt", 0xED41, null_frag, FP64,  FP64,  null_frag, 0>;
+def SRXT : BinaryRXF<"srxt", 0xED49, null_frag, FP128, FP128, null_frag, 0>;
+
+// Insert biased exponent.
+def IEDTR : BinaryRRFb<"iedtr", 0xB3F6, null_frag, FP64,  FP64,   FP64>;
+def IEXTR : BinaryRRFb<"iextr", 0xB3FE, null_frag, FP128, FP128, FP128>;
+
+
+//===----------------------------------------------------------------------===//
+// Comparisons
+//===----------------------------------------------------------------------===//
+
+// Compare.
+let Defs = [CC] in {
+  def CDTR : CompareRRE<"cdtr", 0xB3E4, null_frag, FP64,  FP64>;
+  def CXTR : CompareRRE<"cxtr", 0xB3EC, null_frag, FP128, FP128>;
+}
+
+// Compare and signal.
+let Defs = [CC] in {
+  def KDTR : CompareRRE<"kdtr", 0xB3E0, null_frag, FP64,  FP64>;
+  def KXTR : CompareRRE<"kxtr", 0xB3E8, null_frag, FP128, FP128>;
+}
+
+// Compare biased exponent.
+let Defs = [CC] in {
+  def CEDTR : CompareRRE<"cedtr", 0xB3F4, null_frag, FP64,  FP64>;
+  def CEXTR : CompareRRE<"cextr", 0xB3FC, null_frag, FP128, FP128>;
+}
+
+// Test Data Class.
+let Defs = [CC] in {
+  def TDCET : TestRXE<"tdcet", 0xED50, null_frag, FP32>;
+  def TDCDT : TestRXE<"tdcdt", 0xED54, null_frag, FP64>;
+  def TDCXT : TestRXE<"tdcxt", 0xED58, null_frag, FP128>;
+}
+
+// Test Data Group.
+let Defs = [CC] in {
+  def TDGET : TestRXE<"tdget", 0xED51, null_frag, FP32>;
+  def TDGDT : TestRXE<"tdgdt", 0xED55, null_frag, FP64>;
+  def TDGXT : TestRXE<"tdgxt", 0xED59, null_frag, FP128>;
+}
+

llvm/lib/Target/SystemZ/SystemZInstrFormats.td

@@ -527,6 +527,22 @@ class InstRRFc<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
   let Inst{3-0}   = R2;
 }
 
+class InstRRFd<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
+  : InstSystemZ<4, outs, ins, asmstr, pattern> {
+  field bits<32> Inst;
+  field bits<32> SoftFail = 0;
+
+  bits<4> R1;
+  bits<4> R2;
+  bits<4> M4;
+
+  let Inst{31-16} = op;
+  let Inst{15-12} = 0;
+  let Inst{11-8}  = M4;
+  let Inst{7-4}   = R1;
+  let Inst{3-0}   = R2;
+}
+
 class InstRRFe<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
   : InstSystemZ<4, outs, ins, asmstr, pattern> {
   field bits<32> Inst;
@@ -725,6 +741,22 @@ class InstRSLa<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
   let Inst{7-0}   = op{7-0};
 }
 
+class InstRSLb<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
+  : InstSystemZ<6, outs, ins, asmstr, pattern> {
+  field bits<48> Inst;
+  field bits<48> SoftFail = 0;
+
+  bits<4> R1;
+  bits<24> BDL2;
+  bits<4> M3;
+
+  let Inst{47-40} = op{15-8};
+  let Inst{39-16} = BDL2;
+  let Inst{15-12} = R1;
+  let Inst{11-8}  = M3;
+  let Inst{7-0}   = op{7-0};
+}
+
 class InstRSYa<bits<16> op, dag outs, dag ins, string asmstr, list<dag> pattern>
   : InstSystemZ<6, outs, ins, asmstr, pattern> {
   field bits<48> Inst;
@@ -2817,6 +2849,11 @@ multiclass BinaryMemRRFcOpt<string mnemonic, bits<16> opcode,
   def Opt : UnaryMemRRFc<mnemonic, opcode, cls1, cls2>;
 }
 
+class BinaryRRFd<string mnemonic, bits<16> opcode, RegisterOperand cls1,
+                RegisterOperand cls2>
+  : InstRRFd<opcode, (outs cls1:$R1), (ins cls2:$R2, imm32zx4:$M4),
+             mnemonic#"\t$R1, $R2, $M4", []>;
+
 class BinaryRRFe<string mnemonic, bits<16> opcode, RegisterOperand cls1,
                 RegisterOperand cls2>
   : InstRRFe<opcode, (outs cls1:$R1), (ins imm32zx4:$M3, cls2:$R2),
@@ -2967,6 +3004,13 @@ multiclass BinaryRSAndK<string mnemonic, bits<8> opcode1, bits<16> opcode2,
   }
 }
 
+class BinaryRSL<string mnemonic, bits<16> opcode, RegisterOperand cls>
+  : InstRSLb<opcode, (outs cls:$R1),
+             (ins bdladdr12onlylen8:$BDL2, imm32zx4:$M3),
+             mnemonic#"\t$R1, $BDL2, $M3", []> {
+  let mayLoad = 1;
+}
+
 class BinaryRX<string mnemonic, bits<8> opcode, SDPatternOperator operator,
                RegisterOperand cls, SDPatternOperator load, bits<5> bytes,
                AddressingMode mode = bdxaddr12only>
@@ -3315,6 +3359,13 @@ multiclass StoreBinaryRSPair<string mnemonic, bits<8> rsOpcode,
   }
 }
 
+class StoreBinaryRSL<string mnemonic, bits<16> opcode, RegisterOperand cls>
+  : InstRSLb<opcode, (outs),
+             (ins cls:$R1, bdladdr12onlylen8:$BDL2, imm32zx4:$M3),
+             mnemonic#"\t$R1, $BDL2, $M3", []> {
+  let mayStore = 1;
+}
+
 class StoreBinaryVRV<string mnemonic, bits<16> opcode, bits<5> bytes,
                      Immediate index>
   : InstVRV<opcode, (outs), (ins VR128:$V1, bdvaddr12only:$VBD2, index:$M3),
@@ -3602,6 +3653,12 @@ class SideEffectTernarySSF<string mnemonic, bits<12> opcode,
             (ins bdaddr12only:$BD1, bdaddr12only:$BD2, cls:$R3),
             mnemonic#"\t$BD1, $BD2, $R3", []>;
 
+class TernaryRRFa<string mnemonic, bits<16> opcode,
+                 RegisterOperand cls1, RegisterOperand cls2,
+                 RegisterOperand cls3>
+  : InstRRFa<opcode, (outs cls1:$R1), (ins cls2:$R2, cls3:$R3, imm32zx4:$M4),
+             mnemonic#"\t$R1, $R2, $R3, $M4", []>;
+
 class TernaryRRFb<string mnemonic, bits<16> opcode,
                   RegisterOperand cls1, RegisterOperand cls2,
                   RegisterOperand cls3>

llvm/lib/Target/SystemZ/SystemZScheduleZ13.td

@@ -1016,6 +1016,130 @@ def : InstRW<[VecXsPm, Lat4], (instregex "C(E|D)R$")>;
 def : InstRW<[VecDF, VecDF, Lat20, GroupAlone], (instregex "CXR$")>;
 
 
+// ------------------------ Decimal floating point -------------------------- //
+
+//===----------------------------------------------------------------------===//
+// DFP: Move instructions
+//===----------------------------------------------------------------------===//
+
+// Load and Test
+def : InstRW<[VecDF], (instregex "LTDTR$")>;
+def : InstRW<[VecDF2, VecDF2, Lat11, GroupAlone], (instregex "LTXTR$")>;
+
+//===----------------------------------------------------------------------===//
+// DFP: Conversion instructions
+//===----------------------------------------------------------------------===//
+
+// Load rounded
+def : InstRW<[VecDF, Lat15], (instregex "LEDTR$")>;
+def : InstRW<[VecDF, VecDF, Lat20], (instregex "LDXTR$")>;
+
+// Load lengthened
+def : InstRW<[VecDF], (instregex "LDETR$")>;
+def : InstRW<[VecDF2, VecDF2, Lat11, GroupAlone], (instregex "LXDTR$")>;
+
+// Convert from fixed / logical
+def : InstRW<[FXb, VecDF, Lat30, BeginGroup], (instregex "CD(F|G)TR(A)?$")>;
+def : InstRW<[FXb, VecDF2, VecDF2, Lat30, GroupAlone], (instregex "CX(F|G)TR(A)?$")>;
+def : InstRW<[FXb, VecDF, Lat30, BeginGroup], (instregex "CDL(F|G)TR$")>;
+def : InstRW<[FXb, VecDF2, VecDF2, Lat30, GroupAlone], (instregex "CXL(F|G)TR$")>;
+
+// Convert to fixed / logical
+def : InstRW<[FXb, VecDF, Lat30, BeginGroup], (instregex "C(F|G)DTR(A)?$")>;
+def : InstRW<[FXb, VecDF, VecDF, Lat30, BeginGroup], (instregex "C(F|G)XTR(A)?$")>;
+def : InstRW<[FXb, VecDF, Lat30, BeginGroup], (instregex "CL(F|G)DTR$")>;
+def : InstRW<[FXb, VecDF, VecDF, Lat30, BeginGroup], (instregex "CL(F|G)XTR$")>;
+
+// Convert from / to signed / unsigned packed
+def : InstRW<[FXb, VecDF, Lat9, BeginGroup], (instregex "CD(S|U)TR$")>;
+def : InstRW<[FXb, FXb, VecDF2, VecDF2, Lat15, GroupAlone], (instregex "CX(S|U)TR$")>;
+def : InstRW<[FXb, VecDF, Lat12, BeginGroup], (instregex "C(S|U)DTR$")>;
+def : InstRW<[FXb, FXb, VecDF2, VecDF2, Lat15, BeginGroup], (instregex "C(S|U)XTR$")>;
+
+// Convert from / to zoned
+def : InstRW<[LSU, VecDF, Lat11, BeginGroup], (instregex "CDZT$")>;
+def : InstRW<[LSU, LSU, VecDF2, VecDF2, Lat15, GroupAlone], (instregex "CXZT$")>;
+def : InstRW<[FXb, LSU, VecDF, Lat11, BeginGroup], (instregex "CZDT$")>;
+def : InstRW<[FXb, LSU, VecDF, VecDF, Lat15, GroupAlone], (instregex "CZXT$")>;
+
+// Convert from / to packed
+def : InstRW<[LSU, VecDF, Lat11, BeginGroup], (instregex "CDPT$")>;
+def : InstRW<[LSU, LSU, VecDF2, VecDF2, Lat15, GroupAlone], (instregex "CXPT$")>;
+def : InstRW<[FXb, LSU, VecDF, Lat11, BeginGroup], (instregex "CPDT$")>;
+def : InstRW<[FXb, LSU, VecDF, VecDF, Lat15, GroupAlone], (instregex "CPXT$")>;
+
+// Perform floating-point operation
+def : InstRW<[LSU, Lat30, GroupAlone], (instregex "PFPO$")>;
+
+//===----------------------------------------------------------------------===//
+// DFP: Unary arithmetic
+//===----------------------------------------------------------------------===//
+
+// Load FP integer
+def : InstRW<[VecDF], (instregex "FIDTR$")>;
+def : InstRW<[VecDF2, VecDF2, Lat11, GroupAlone], (instregex "FIXTR$")>;
+
+// Extract biased exponent
+def : InstRW<[FXb, VecDF, Lat12, BeginGroup], (instregex "EEDTR$")>;
+def : InstRW<[FXb, VecDF, Lat12, BeginGroup], (instregex "EEXTR$")>;
+
+// Extract significance
+def : InstRW<[FXb, VecDF, Lat12, BeginGroup], (instregex "ESDTR$")>;
+def : InstRW<[FXb, VecDF, VecDF, Lat15, BeginGroup], (instregex "ESXTR$")>;
+
+//===----------------------------------------------------------------------===//
+// DFP: Binary arithmetic
+//===----------------------------------------------------------------------===//
+
+// Addition
+def : InstRW<[VecDF], (instregex "ADTR(A)?$")>;
+def : InstRW<[VecDF2, VecDF2, Lat11, GroupAlone], (instregex "AXTR(A)?$")>;
+
+// Subtraction
+def : InstRW<[VecDF], (instregex "SDTR(A)?$")>;
+def : InstRW<[VecDF2, VecDF2, Lat11, GroupAlone], (instregex "SXTR(A)?$")>;
+
+// Multiply
+def : InstRW<[VecDF, Lat30], (instregex "MDTR(A)?$")>;
+def : InstRW<[VecDF2, VecDF2, Lat30, GroupAlone], (instregex "MXTR(A)?$")>;
+
+// Division
+def : InstRW<[VecDF, Lat30], (instregex "DDTR(A)?$")>;
+def : InstRW<[VecDF2, VecDF2, Lat30, GroupAlone], (instregex "DXTR(A)?$")>;
+
+// Quantize
+def : InstRW<[VecDF], (instregex "QADTR$")>;
+def : InstRW<[VecDF2, VecDF2, Lat11, GroupAlone], (instregex "QAXTR$")>;
+
+// Reround
+def : InstRW<[FXb, VecDF, Lat11], (instregex "RRDTR$")>;
+def : InstRW<[FXb, VecDF2, VecDF2, Lat15, GroupAlone], (instregex "RRXTR$")>;
+
+// Shift significand left/right
+def : InstRW<[LSU, VecDF, Lat11], (instregex "S(L|R)DT$")>;
+def : InstRW<[LSU, VecDF2, VecDF2, Lat15, GroupAlone], (instregex "S(L|R)XT$")>;
+
+// Insert biased exponent
+def : InstRW<[FXb, VecDF, Lat11], (instregex "IEDTR$")>;
+def : InstRW<[FXb, VecDF2, VecDF2, Lat15, GroupAlone], (instregex "IEXTR$")>;
+
+//===----------------------------------------------------------------------===//
+// DFP: Comparisons
+//===----------------------------------------------------------------------===//
+
+// Compare
+def : InstRW<[VecDF], (instregex "(K|C)DTR$")>;
+def : InstRW<[VecDF, VecDF, Lat11, GroupAlone], (instregex "(K|C)XTR$")>;
+
+// Compare biased exponent
+def : InstRW<[VecDF], (instregex "CEDTR$")>;
+def : InstRW<[VecDF], (instregex "CEXTR$")>;
+
+// Test Data Class/Group
+def : InstRW<[LSU, VecDF, Lat11], (instregex "TD(C|G)(E|D)T$")>;
+def : InstRW<[LSU, VecDF2, VecDF2, Lat15, GroupAlone], (instregex "TD(C|G)XT$")>;
+
+
 // --------------------------------- Vector --------------------------------- //
 
 //===----------------------------------------------------------------------===//

llvm/lib/Target/SystemZ/SystemZScheduleZ196.td

@@ -946,5 +946,117 @@ def : InstRW<[FPU, LSU, Lat12], (instregex "C(E|D)$")>;
 def : InstRW<[FPU], (instregex "C(E|D)R$")>;
 def : InstRW<[FPU, FPU, Lat15], (instregex "CXR$")>;
 
+
+// ------------------------ Decimal floating point -------------------------- //
+
+//===----------------------------------------------------------------------===//
+// DFP: Move instructions
+//===----------------------------------------------------------------------===//
+
+// Load and Test
+def : InstRW<[DFU, Lat20], (instregex "LTDTR$")>;
+def : InstRW<[DFU2, DFU2, Lat20, GroupAlone], (instregex "LTXTR$")>;
+
+//===----------------------------------------------------------------------===//
+// DFP: Conversion instructions
+//===----------------------------------------------------------------------===//
+
+// Load rounded
+def : InstRW<[DFU, Lat30], (instregex "LEDTR$")>;
+def : InstRW<[DFU, DFU, Lat30], (instregex "LDXTR$")>;
+
+// Load lengthened
+def : InstRW<[DFU, Lat20], (instregex "LDETR$")>;
+def : InstRW<[DFU2, DFU2, Lat20, GroupAlone], (instregex "LXDTR$")>;
+
+// Convert from fixed / logical
+def : InstRW<[FXU, DFU, Lat30, GroupAlone], (instregex "CD(F|G)TR(A)?$")>;
+def : InstRW<[FXU, DFU2, DFU2, Lat30, GroupAlone], (instregex "CX(F|G)TR(A)?$")>;
+def : InstRW<[FXU, DFU, Lat11, GroupAlone], (instregex "CDL(F|G)TR$")>;
+def : InstRW<[FXU, DFU2, DFU2, Lat11, GroupAlone], (instregex "CXL(F|G)TR$")>;
+
+// Convert to fixed / logical
+def : InstRW<[FXU, DFU, Lat30, GroupAlone], (instregex "C(F|G)DTR(A)?$")>;
+def : InstRW<[FXU, DFU, DFU, Lat30, GroupAlone], (instregex "C(F|G)XTR(A)?$")>;
+def : InstRW<[FXU, DFU, Lat30, GroupAlone], (instregex "CL(F|G)DTR$")>;
+def : InstRW<[FXU, DFU, DFU, Lat30, GroupAlone], (instregex "CL(F|G)XTR$")>;
+
+// Convert from / to signed / unsigned packed
+def : InstRW<[FXU, DFU, Lat12, GroupAlone], (instregex "CD(S|U)TR$")>;
+def : InstRW<[FXU, FXU, DFU2, DFU2, Lat20, GroupAlone], (instregex "CX(S|U)TR$")>;
+def : InstRW<[FXU, DFU, Lat12, GroupAlone], (instregex "C(S|U)DTR$")>;
+def : InstRW<[FXU, FXU, DFU2, DFU2, Lat20, GroupAlone], (instregex "C(S|U)XTR$")>;
+
+// Perform floating-point operation
+def : InstRW<[LSU, Lat30, GroupAlone], (instregex "PFPO$")>;
+
+//===----------------------------------------------------------------------===//
+// DFP: Unary arithmetic
+//===----------------------------------------------------------------------===//
+
+// Load FP integer
+def : InstRW<[DFU, Lat20], (instregex "FIDTR$")>;
+def : InstRW<[DFU2, DFU2, Lat20, GroupAlone], (instregex "FIXTR$")>;
+
+// Extract biased exponent
+def : InstRW<[FXU, DFU, Lat15, GroupAlone], (instregex "EEDTR$")>;
+def : InstRW<[FXU, DFU, Lat15, GroupAlone], (instregex "EEXTR$")>;
+
+// Extract significance
+def : InstRW<[FXU, DFU, Lat15, GroupAlone], (instregex "ESDTR$")>;
+def : InstRW<[FXU, DFU, DFU, Lat20, GroupAlone], (instregex "ESXTR$")>;
+
+//===----------------------------------------------------------------------===//
+// DFP: Binary arithmetic
+//===----------------------------------------------------------------------===//
+
+// Addition
+def : InstRW<[DFU, Lat30], (instregex "ADTR(A)?$")>;
+def : InstRW<[DFU2, DFU2, Lat30, GroupAlone], (instregex "AXTR(A)?$")>;
+
+// Subtraction
+def : InstRW<[DFU, Lat30], (instregex "SDTR(A)?$")>;
+def : InstRW<[DFU2, DFU2, Lat30, GroupAlone], (instregex "SXTR(A)?$")>;
+
+// Multiply
+def : InstRW<[DFU, Lat30], (instregex "MDTR(A)?$")>;
+def : InstRW<[DFU2, DFU2, Lat30, GroupAlone], (instregex "MXTR(A)?$")>;
+
+// Division
+def : InstRW<[DFU, Lat30], (instregex "DDTR(A)?$")>;
+def : InstRW<[DFU2, DFU2, Lat30, GroupAlone], (instregex "DXTR(A)?$")>;
+
+// Quantize
+def : InstRW<[DFU, Lat30], (instregex "QADTR$")>;
+def : InstRW<[DFU2, DFU2, Lat30, GroupAlone], (instregex "QAXTR$")>;
+
+// Reround
+def : InstRW<[FXU, DFU, Lat30], (instregex "RRDTR$")>;
+def : InstRW<[FXU, DFU2, DFU2, Lat30, GroupAlone], (instregex "RRXTR$")>;
+
+// Shift significand left/right
+def : InstRW<[LSU, DFU, Lat11], (instregex "S(L|R)DT$")>;
+def : InstRW<[LSU, DFU2, DFU2, Lat15, GroupAlone], (instregex "S(L|R)XT$")>;
+
+// Insert biased exponent
+def : InstRW<[FXU, DFU, Lat11], (instregex "IEDTR$")>;
+def : InstRW<[FXU, DFU2, DFU2, Lat15, GroupAlone], (instregex "IEXTR$")>;
+
+//===----------------------------------------------------------------------===//
+// DFP: Comparisons
+//===----------------------------------------------------------------------===//
+
+// Compare
+def : InstRW<[DFU, Lat11], (instregex "(K|C)DTR$")>;
+def : InstRW<[DFU, DFU, Lat15, GroupAlone], (instregex "(K|C)XTR$")>;
+
+// Compare biased exponent
+def : InstRW<[DFU, Lat8], (instregex "CEDTR$")>;
+def : InstRW<[DFU, Lat9], (instregex "CEXTR$")>;
+
+// Test Data Class/Group
+def : InstRW<[LSU, DFU, Lat15], (instregex "TD(C|G)(E|D)T$")>;
+def : InstRW<[LSU, DFU2, DFU2, Lat15, GroupAlone], (instregex "TD(C|G)XT$")>;
+
 }
 

llvm/lib/Target/SystemZ/SystemZScheduleZEC12.td

@@ -984,5 +984,123 @@ def : InstRW<[FPU, LSU, Lat12], (instregex "C(E|D)$")>;
 def : InstRW<[FPU], (instregex "C(E|D)R$")>;
 def : InstRW<[FPU, FPU, Lat15], (instregex "CXR$")>;
 
+
+// ------------------------ Decimal floating point -------------------------- //
+
+//===----------------------------------------------------------------------===//
+// DFP: Move instructions
+//===----------------------------------------------------------------------===//
+
+// Load and Test
+def : InstRW<[DFU, Lat20], (instregex "LTDTR$")>;
+def : InstRW<[DFU2, DFU2, Lat20, GroupAlone], (instregex "LTXTR$")>;
+
+//===----------------------------------------------------------------------===//
+// DFP: Conversion instructions
+//===----------------------------------------------------------------------===//
+
+// Load rounded
+def : InstRW<[DFU, Lat30], (instregex "LEDTR$")>;
+def : InstRW<[DFU, DFU, Lat30], (instregex "LDXTR$")>;
+
+// Load lengthened
+def : InstRW<[DFU, Lat20], (instregex "LDETR$")>;
+def : InstRW<[DFU2, DFU2, Lat20, GroupAlone], (instregex "LXDTR$")>;
+
+// Convert from fixed / logical
+def : InstRW<[FXU, DFU, Lat30, GroupAlone], (instregex "CD(F|G)TR(A)?$")>;
+def : InstRW<[FXU, DFU2, DFU2, Lat30, GroupAlone], (instregex "CX(F|G)TR(A)?$")>;
+def : InstRW<[FXU, DFU, Lat11, GroupAlone], (instregex "CDL(F|G)TR$")>;
+def : InstRW<[FXU, DFU2, DFU2, Lat11, GroupAlone], (instregex "CXL(F|G)TR$")>;
+
+// Convert to fixed / logical
+def : InstRW<[FXU, DFU, Lat30, GroupAlone], (instregex "C(F|G)DTR(A)?$")>;
+def : InstRW<[FXU, DFU, DFU, Lat30, GroupAlone], (instregex "C(F|G)XTR(A)?$")>;
+def : InstRW<[FXU, DFU, Lat30, GroupAlone], (instregex "CL(F|G)DTR$")>;
+def : InstRW<[FXU, DFU, DFU, Lat30, GroupAlone], (instregex "CL(F|G)XTR$")>;
+
+// Convert from / to signed / unsigned packed
+def : InstRW<[FXU, DFU, Lat12, GroupAlone], (instregex "CD(S|U)TR$")>;
+def : InstRW<[FXU, FXU, DFU2, DFU2, Lat20, GroupAlone], (instregex "CX(S|U)TR$")>;
+def : InstRW<[FXU, DFU, Lat12, GroupAlone], (instregex "C(S|U)DTR$")>;
+def : InstRW<[FXU, FXU, DFU2, DFU2, Lat20, GroupAlone], (instregex "C(S|U)XTR$")>;
+
+// Convert from / to zoned
+def : InstRW<[LSU, DFU2, Lat7, GroupAlone], (instregex "CDZT$")>;
+def : InstRW<[LSU, LSU, DFU2, DFU2, Lat10, GroupAlone], (instregex "CXZT$")>;
+def : InstRW<[FXU, LSU, DFU, Lat11, GroupAlone], (instregex "CZDT$")>;
+def : InstRW<[FXU, LSU, DFU, DFU, Lat15, GroupAlone], (instregex "CZXT$")>;
+
+// Perform floating-point operation
+def : InstRW<[LSU, Lat30, GroupAlone], (instregex "PFPO$")>;
+
+//===----------------------------------------------------------------------===//
+// DFP: Unary arithmetic
+//===----------------------------------------------------------------------===//
+
+// Load FP integer
+def : InstRW<[DFU, Lat20], (instregex "FIDTR$")>;
+def : InstRW<[DFU2, DFU2, Lat20, GroupAlone], (instregex "FIXTR$")>;
+
+// Extract biased exponent
+def : InstRW<[FXU, DFU, Lat15, GroupAlone], (instregex "EEDTR$")>;
+def : InstRW<[FXU, DFU, Lat15, GroupAlone], (instregex "EEXTR$")>;
+
+// Extract significance
+def : InstRW<[FXU, DFU, Lat15, GroupAlone], (instregex "ESDTR$")>;
+def : InstRW<[FXU, DFU, DFU, Lat20, GroupAlone], (instregex "ESXTR$")>;
+
+//===----------------------------------------------------------------------===//
+// DFP: Binary arithmetic
+//===----------------------------------------------------------------------===//
+
+// Addition
+def : InstRW<[DFU, Lat30], (instregex "ADTR(A)?$")>;
+def : InstRW<[DFU2, DFU2, Lat30, GroupAlone], (instregex "AXTR(A)?$")>;
+
+// Subtraction
+def : InstRW<[DFU, Lat30], (instregex "SDTR(A)?$")>;
+def : InstRW<[DFU2, DFU2, Lat30, GroupAlone], (instregex "SXTR(A)?$")>;
+
+// Multiply
+def : InstRW<[DFU, Lat30], (instregex "MDTR(A)?$")>;
+def : InstRW<[DFU2, DFU2, Lat30, GroupAlone], (instregex "MXTR(A)?$")>;
+
+// Division
+def : InstRW<[DFU, Lat30], (instregex "DDTR(A)?$")>;
+def : InstRW<[DFU2, DFU2, Lat30, GroupAlone], (instregex "DXTR(A)?$")>;
+
+// Quantize
+def : InstRW<[DFU, Lat30], (instregex "QADTR$")>;
+def : InstRW<[DFU2, DFU2, Lat30, GroupAlone], (instregex "QAXTR$")>;
+
+// Reround
+def : InstRW<[FXU, DFU, Lat30], (instregex "RRDTR$")>;
+def : InstRW<[FXU, DFU2, DFU2, Lat30, GroupAlone], (instregex "RRXTR$")>;
+
+// Shift significand left/right
+def : InstRW<[LSU, DFU, Lat11], (instregex "S(L|R)DT$")>;
+def : InstRW<[LSU, DFU2, DFU2, Lat15, GroupAlone], (instregex "S(L|R)XT$")>;
+
+// Insert biased exponent
+def : InstRW<[FXU, DFU, Lat11], (instregex "IEDTR$")>;
+def : InstRW<[FXU, DFU2, DFU2, Lat15, GroupAlone], (instregex "IEXTR$")>;
+
+//===----------------------------------------------------------------------===//
+// DFP: Comparisons
+//===----------------------------------------------------------------------===//
+
+// Compare
+def : InstRW<[DFU, Lat11], (instregex "(K|C)DTR$")>;
+def : InstRW<[DFU, DFU, Lat15, GroupAlone], (instregex "(K|C)XTR$")>;
+
+// Compare biased exponent
+def : InstRW<[DFU, Lat8], (instregex "CEDTR$")>;
+def : InstRW<[DFU, Lat9], (instregex "CEXTR$")>;
+
+// Test Data Class/Group
+def : InstRW<[LSU, DFU, Lat15], (instregex "TD(C|G)(E|D)T$")>;
+def : InstRW<[LSU, DFU2, DFU2, Lat15, GroupAlone], (instregex "TD(C|G)XT$")>;
+
 }
 

llvm/lib/Target/SystemZ/SystemZSubtarget.cpp

@@ -42,8 +42,10 @@ SystemZSubtarget::SystemZSubtarget(const Triple &TT, const std::string &CPU,
       HasMiscellaneousExtensions(false),
       HasExecutionHint(false), HasLoadAndTrap(false),
       HasTransactionalExecution(false), HasProcessorAssist(false),
+      HasDFPZonedConversion(false),
       HasVector(false), HasLoadStoreOnCond2(false),
       HasLoadAndZeroRightmostByte(false), HasMessageSecurityAssist5(false),
+      HasDFPPackedConversion(false),
       TargetTriple(TT), InstrInfo(initializeSubtargetDependencies(CPU, FS)),
       TLInfo(TM, *this), TSInfo(), FrameLowering() {}
 

llvm/lib/Target/SystemZ/SystemZSubtarget.h

@@ -47,10 +47,12 @@ protected:
   bool HasLoadAndTrap;
   bool HasTransactionalExecution;
   bool HasProcessorAssist;
+  bool HasDFPZonedConversion;
   bool HasVector;
   bool HasLoadStoreOnCond2;
   bool HasLoadAndZeroRightmostByte;
   bool HasMessageSecurityAssist5;
+  bool HasDFPPackedConversion;
 
 private:
   Triple TargetTriple;
@@ -133,6 +135,9 @@ public:
   // Return true if the target has the processor-assist facility.
   bool hasProcessorAssist() const { return HasProcessorAssist; }
 
+  // Return true if the target has the DFP zoned-conversion facility.
+  bool hasDFPZonedConversion() const { return HasDFPZonedConversion; }
+
   // Return true if the target has the load-and-zero-rightmost-byte facility.
   bool hasLoadAndZeroRightmostByte() const {
     return HasLoadAndZeroRightmostByte;
@@ -142,6 +147,9 @@ public:
   // extension facility 5.
   bool hasMessageSecurityAssist5() const { return HasMessageSecurityAssist5; }
 
+  // Return true if the target has the DFP packed-conversion facility.
+  bool hasDFPPackedConversion() const { return HasDFPPackedConversion; }
+
   // Return true if the target has the vector facility.
   bool hasVector() const { return HasVector; }
 

llvm/test/MC/Disassembler/SystemZ/insns-z13.txt

@@ -2,6 +2,114 @@
 # RUN: llvm-mc --disassemble %s -triple=s390x-linux-gnu -mcpu=z13 \
 # RUN:   | FileCheck %s
 
+# CHECK: cdpt %f0, 0(1), 0
+0xed 0x00 0x00 0x00 0x00 0xae
+
+# CHECK: cdpt %f15, 0(1), 0
+0xed 0x00 0x00 0x00 0xf0 0xae
+
+# CHECK: cdpt %f0, 0(1), 15
+0xed 0x00 0x00 0x00 0x0f 0xae
+
+# CHECK: cdpt %f0, 0(1,%r1), 0
+0xed 0x00 0x10 0x00 0x00 0xae
+
+# CHECK: cdpt %f0, 0(1,%r15), 0
+0xed 0x00 0xf0 0x00 0x00 0xae
+
+# CHECK: cdpt %f0, 4095(1,%r1), 0
+0xed 0x00 0x1f 0xff 0x00 0xae
+
+# CHECK: cdpt %f0, 4095(1,%r15), 0
+0xed 0x00 0xff 0xff 0x00 0xae
+
+# CHECK: cdpt %f0, 0(256,%r1), 0
+0xed 0xff 0x10 0x00 0x00 0xae
+
+# CHECK: cdpt %f0, 0(256,%r15), 0
+0xed 0xff 0xf0 0x00 0x00 0xae
+
+# CHECK: cpdt %f0, 0(1), 0
+0xed 0x00 0x00 0x00 0x00 0xac
+
+# CHECK: cpdt %f15, 0(1), 0
+0xed 0x00 0x00 0x00 0xf0 0xac
+
+# CHECK: cpdt %f0, 0(1), 15
+0xed 0x00 0x00 0x00 0x0f 0xac
+
+# CHECK: cpdt %f0, 0(1,%r1), 0
+0xed 0x00 0x10 0x00 0x00 0xac
+
+# CHECK: cpdt %f0, 0(1,%r15), 0
+0xed 0x00 0xf0 0x00 0x00 0xac
+
+# CHECK: cpdt %f0, 4095(1,%r1), 0
+0xed 0x00 0x1f 0xff 0x00 0xac
+
+# CHECK: cpdt %f0, 4095(1,%r15), 0
+0xed 0x00 0xff 0xff 0x00 0xac
+
+# CHECK: cpdt %f0, 0(256,%r1), 0
+0xed 0xff 0x10 0x00 0x00 0xac
+
+# CHECK: cpdt %f0, 0(256,%r15), 0
+0xed 0xff 0xf0 0x00 0x00 0xac
+
+# CHECK: cpxt %f0, 0(1), 0
+0xed 0x00 0x00 0x00 0x00 0xad
+
+# CHECK: cpxt %f13, 0(1), 0
+0xed 0x00 0x00 0x00 0xd0 0xad
+
+# CHECK: cpxt %f0, 0(1), 15
+0xed 0x00 0x00 0x00 0x0f 0xad
+
+# CHECK: cpxt %f0, 0(1,%r1), 0
+0xed 0x00 0x10 0x00 0x00 0xad
+
+# CHECK: cpxt %f0, 0(1,%r15), 0
+0xed 0x00 0xf0 0x00 0x00 0xad
+
+# CHECK: cpxt %f0, 4095(1,%r1), 0
+0xed 0x00 0x1f 0xff 0x00 0xad
+
+# CHECK: cpxt %f0, 4095(1,%r15), 0
+0xed 0x00 0xff 0xff 0x00 0xad
+
+# CHECK: cpxt %f0, 0(256,%r1), 0
+0xed 0xff 0x10 0x00 0x00 0xad
+
+# CHECK: cpxt %f0, 0(256,%r15), 0
+0xed 0xff 0xf0 0x00 0x00 0xad
+
+# CHECK: cxpt %f0, 0(1), 0
+0xed 0x00 0x00 0x00 0x00 0xaf
+
+# CHECK: cxpt %f13, 0(1), 0
+0xed 0x00 0x00 0x00 0xd0 0xaf
+
+# CHECK: cxpt %f0, 0(1), 15
+0xed 0x00 0x00 0x00 0x0f 0xaf
+
+# CHECK: cxpt %f0, 0(1,%r1), 0
+0xed 0x00 0x10 0x00 0x00 0xaf
+
+# CHECK: cxpt %f0, 0(1,%r15), 0
+0xed 0x00 0xf0 0x00 0x00 0xaf
+
+# CHECK: cxpt %f0, 4095(1,%r1), 0
+0xed 0x00 0x1f 0xff 0x00 0xaf
+
+# CHECK: cxpt %f0, 4095(1,%r15), 0
+0xed 0x00 0xff 0xff 0x00 0xaf
+
+# CHECK: cxpt %f0, 0(256,%r1), 0
+0xed 0xff 0x10 0x00 0x00 0xaf
+
+# CHECK: cxpt %f0, 0(256,%r15), 0
+0xed 0xff 0xf0 0x00 0x00 0xaf
+
 # CHECK: lcbb %r0, 0, 0
 0xe7 0x00 0x00 0x00 0x00 0x27
 

llvm/test/MC/SystemZ/insn-bad-z13.s

@@ -4,6 +4,152 @@
 # RUN: not llvm-mc -triple s390x-linux-gnu -mcpu=arch11 < %s 2> %t
 # RUN: FileCheck < %t %s
 
+#CHECK: error: invalid operand
+#CHECK: cdpt	%f0, 0(1), -1
+#CHECK: error: invalid operand
+#CHECK: cdpt	%f0, 0(1), 16
+#CHECK: error: missing length in address
+#CHECK: cdpt	%f0, 0, 0
+#CHECK: error: missing length in address
+#CHECK: cdpt	%f0, 0(%r1), 0
+#CHECK: error: invalid operand
+#CHECK: cdpt	%f0, 0(0,%r1), 0
+#CHECK: error: invalid operand
+#CHECK: cdpt	%f0, 0(257,%r1), 0
+#CHECK: error: invalid operand
+#CHECK: cdpt	%f0, -1(1,%r1), 0
+#CHECK: error: invalid operand
+#CHECK: cdpt	%f0, 4096(1,%r1), 0
+#CHECK: error: %r0 used in an address
+#CHECK: cdpt	%f0, 0(1,%r0), 0
+#CHECK: error: invalid use of indexed addressing
+#CHECK: cdpt	%f0, 0(%r1,%r2), 0
+#CHECK: error: unknown token in expression
+#CHECK: cdpt	%f0, 0(-), 0
+
+	cdpt	%f0, 0(1), -1
+	cdpt	%f0, 0(1), 16
+	cdpt	%f0, 0, 0
+	cdpt	%f0, 0(%r1), 0
+	cdpt	%f0, 0(0,%r1), 0
+	cdpt	%f0, 0(257,%r1), 0
+	cdpt	%f0, -1(1,%r1), 0
+	cdpt	%f0, 4096(1,%r1), 0
+	cdpt	%f0, 0(1,%r0), 0
+	cdpt	%f0, 0(%r1,%r2), 0
+	cdpt	%f0, 0(-), 0
+
+#CHECK: error: invalid operand
+#CHECK: cpdt	%f0, 0(1), -1
+#CHECK: error: invalid operand
+#CHECK: cpdt	%f0, 0(1), 16
+#CHECK: error: missing length in address
+#CHECK: cpdt	%f0, 0, 0
+#CHECK: error: missing length in address
+#CHECK: cpdt	%f0, 0(%r1), 0
+#CHECK: error: invalid operand
+#CHECK: cpdt	%f0, 0(0,%r1), 0
+#CHECK: error: invalid operand
+#CHECK: cpdt	%f0, 0(257,%r1), 0
+#CHECK: error: invalid operand
+#CHECK: cpdt	%f0, -1(1,%r1), 0
+#CHECK: error: invalid operand
+#CHECK: cpdt	%f0, 4096(1,%r1), 0
+#CHECK: error: %r0 used in an address
+#CHECK: cpdt	%f0, 0(1,%r0), 0
+#CHECK: error: invalid use of indexed addressing
+#CHECK: cpdt	%f0, 0(%r1,%r2), 0
+#CHECK: error: unknown token in expression
+#CHECK: cpdt	%f0, 0(-), 0
+
+	cpdt	%f0, 0(1), -1
+	cpdt	%f0, 0(1), 16
+	cpdt	%f0, 0, 0
+	cpdt	%f0, 0(%r1), 0
+	cpdt	%f0, 0(0,%r1), 0
+	cpdt	%f0, 0(257,%r1), 0
+	cpdt	%f0, -1(1,%r1), 0
+	cpdt	%f0, 4096(1,%r1), 0
+	cpdt	%f0, 0(1,%r0), 0
+	cpdt	%f0, 0(%r1,%r2), 0
+	cpdt	%f0, 0(-), 0
+
+#CHECK: error: invalid operand
+#CHECK: cpxt	%f0, 0(1), -1
+#CHECK: error: invalid operand
+#CHECK: cpxt	%f0, 0(1), 16
+#CHECK: error: missing length in address
+#CHECK: cpxt	%f0, 0, 0
+#CHECK: error: missing length in address
+#CHECK: cpxt	%f0, 0(%r1), 0
+#CHECK: error: invalid operand
+#CHECK: cpxt	%f0, 0(0,%r1), 0
+#CHECK: error: invalid operand
+#CHECK: cpxt	%f0, 0(257,%r1), 0
+#CHECK: error: invalid operand
+#CHECK: cpxt	%f0, -1(1,%r1), 0
+#CHECK: error: invalid operand
+#CHECK: cpxt	%f0, 4096(1,%r1), 0
+#CHECK: error: %r0 used in an address
+#CHECK: cpxt	%f0, 0(1,%r0), 0
+#CHECK: error: invalid use of indexed addressing
+#CHECK: cpxt	%f0, 0(%r1,%r2), 0
+#CHECK: error: unknown token in expression
+#CHECK: cpxt	%f0, 0(-), 0
+#CHECK: error: invalid register pair
+#CHECK: cpxt	%f15, 0(1), 0
+
+	cpxt	%f0, 0(1), -1
+	cpxt	%f0, 0(1), 16
+	cpxt	%f0, 0, 0
+	cpxt	%f0, 0(%r1), 0
+	cpxt	%f0, 0(0,%r1), 0
+	cpxt	%f0, 0(257,%r1), 0
+	cpxt	%f0, -1(1,%r1), 0
+	cpxt	%f0, 4096(1,%r1), 0
+	cpxt	%f0, 0(1,%r0), 0
+	cpxt	%f0, 0(%r1,%r2), 0
+	cpxt	%f0, 0(-), 0
+	cpxt	%f15, 0(1), 0
+
+#CHECK: error: invalid operand
+#CHECK: cxpt	%f0, 0(1), -1
+#CHECK: error: invalid operand
+#CHECK: cxpt	%f0, 0(1), 16
+#CHECK: error: missing length in address
+#CHECK: cxpt	%f0, 0, 0
+#CHECK: error: missing length in address
+#CHECK: cxpt	%f0, 0(%r1), 0
+#CHECK: error: invalid operand
+#CHECK: cxpt	%f0, 0(0,%r1), 0
+#CHECK: error: invalid operand
+#CHECK: cxpt	%f0, 0(257,%r1), 0
+#CHECK: error: invalid operand
+#CHECK: cxpt	%f0, -1(1,%r1), 0
+#CHECK: error: invalid operand
+#CHECK: cxpt	%f0, 4096(1,%r1), 0
+#CHECK: error: %r0 used in an address
+#CHECK: cxpt	%f0, 0(1,%r0), 0
+#CHECK: error: invalid use of indexed addressing
+#CHECK: cxpt	%f0, 0(%r1,%r2), 0
+#CHECK: error: unknown token in expression
+#CHECK: cxpt	%f0, 0(-), 0
+#CHECK: error: invalid register pair
+#CHECK: cxpt	%f15, 0(1), 0
+
+	cxpt	%f0, 0(1), -1
+	cxpt	%f0, 0(1), 16
+	cxpt	%f0, 0, 0
+	cxpt	%f0, 0(%r1), 0
+	cxpt	%f0, 0(0,%r1), 0
+	cxpt	%f0, 0(257,%r1), 0
+	cxpt	%f0, -1(1,%r1), 0
+	cxpt	%f0, 4096(1,%r1), 0
+	cxpt	%f0, 0(1,%r0), 0
+	cxpt	%f0, 0(%r1,%r2), 0
+	cxpt	%f0, 0(-), 0
+	cxpt	%f15, 0(1), 0
+
 #CHECK: error: invalid operand
 #CHECK: lcbb	%r0, 0, -1
 #CHECK: error: invalid operand

llvm/test/MC/SystemZ/insn-bad-z196.s

@@ -4,6 +4,14 @@
 # RUN: not llvm-mc -triple s390x-linux-gnu -mcpu=arch9 < %s 2> %t
 # RUN: FileCheck < %t %s
 
+#CHECK: error: invalid operand
+#CHECK: adtra	%f0, %f0, %f0, -1
+#CHECK: error: invalid operand
+#CHECK: adtra	%f0, %f0, %f0, 16
+
+	adtra	%f0, %f0, %f0, -1
+	adtra	%f0, %f0, %f0, 16
+
 #CHECK: error: invalid operand
 #CHECK: aghik	%r0, %r1, -32769
 #CHECK: error: invalid operand
@@ -34,6 +42,23 @@
 	aih	%r0, (-1 << 31) - 1
 	aih	%r0, (1 << 31)
 
+#CHECK: error: invalid operand
+#CHECK: axtra	%f0, %f0, %f0, -1
+#CHECK: error: invalid operand
+#CHECK: axtra	%f0, %f0, %f0, 16
+#CHECK: error: invalid register pair
+#CHECK: axtra	%f0, %f0, %f2, 0
+#CHECK: error: invalid register pair
+#CHECK: axtra	%f0, %f2, %f0, 0
+#CHECK: error: invalid register pair
+#CHECK: axtra	%f2, %f0, %f0, 0
+
+	axtra	%f0, %f0, %f0, -1
+	axtra	%f0, %f0, %f0, 16
+	axtra	%f0, %f0, %f2, 0
+	axtra	%f0, %f2, %f0, 0
+	axtra	%f2, %f0, %f0, 0
+
 #CHECK: error: instruction requires: execution-hint
 #CHECK: bpp	0, 0, 0
 
@@ -72,6 +97,20 @@
 	cdfbra	%f0, -1, %r0, 0
 	cdfbra	%f0, 16, %r0, 0
 
+#CHECK: error: invalid operand
+#CHECK: cdftr	%f0, 0, %r0, -1
+#CHECK: error: invalid operand
+#CHECK: cdftr	%f0, 0, %r0, 16
+#CHECK: error: invalid operand
+#CHECK: cdftr	%f0, -1, %r0, 0
+#CHECK: error: invalid operand
+#CHECK: cdftr	%f0, 16, %r0, 0
+
+	cdftr	%f0, 0, %r0, -1
+	cdftr	%f0, 0, %r0, 16
+	cdftr	%f0, -1, %r0, 0
+	cdftr	%f0, 16, %r0, 0
+
 #CHECK: error: invalid operand
 #CHECK: cdgbra	%f0, 0, %r0, -1
 #CHECK: error: invalid operand
@@ -86,6 +125,20 @@
 	cdgbra	%f0, -1, %r0, 0
 	cdgbra	%f0, 16, %r0, 0
 
+#CHECK: error: invalid operand
+#CHECK: cdgtra	%f0, 0, %r0, -1
+#CHECK: error: invalid operand
+#CHECK: cdgtra	%f0, 0, %r0, 16
+#CHECK: error: invalid operand
+#CHECK: cdgtra	%f0, -1, %r0, 0
+#CHECK: error: invalid operand
+#CHECK: cdgtra	%f0, 16, %r0, 0
+
+	cdgtra	%f0, 0, %r0, -1
+	cdgtra	%f0, 0, %r0, 16
+	cdgtra	%f0, -1, %r0, 0
+	cdgtra	%f0, 16, %r0, 0
+
 #CHECK: error: invalid operand
 #CHECK: cdlfbr	%f0, 0, %r0, -1
 #CHECK: error: invalid operand
@@ -100,6 +153,25 @@
 	cdlfbr	%f0, -1, %r0, 0
 	cdlfbr	%f0, 16, %r0, 0
 
+#CHECK: error: invalid operand
+#CHECK: cdlftr	%f0, 0, %r0, -1
+#CHECK: error: invalid operand
+#CHECK: cdlftr	%f0, 0, %r0, 16
+#CHECK: error: invalid operand
+#CHECK: cdlftr	%f0, -1, %r0, 0
+#CHECK: error: invalid operand
+#CHECK: cdlftr	%f0, 16, %r0, 0
+
+	cdlftr	%f0, 0, %r0, -1
+	cdlftr	%f0, 0, %r0, 16
+	cdlftr	%f0, -1, %r0, 0
+	cdlftr	%f0, 16, %r0, 0
+
+#CHECK: error: instruction requires: dfp-zoned-conversion
+#CHECK: cdzt	%f0, 0(1), 0
+
+	cdzt	%f0, 0(1), 0
+
 #CHECK: error: invalid operand
 #CHECK: cdlgbr	%f0, 0, %r0, -1
 #CHECK: error: invalid operand
@@ -114,6 +186,20 @@
 	cdlgbr	%f0, -1, %r0, 0
 	cdlgbr	%f0, 16, %r0, 0
 
+#CHECK: error: invalid operand
+#CHECK: cdlgtr	%f0, 0, %r0, -1
+#CHECK: error: invalid operand
+#CHECK: cdlgtr	%f0, 0, %r0, 16
+#CHECK: error: invalid operand
+#CHECK: cdlgtr	%f0, -1, %r0, 0
+#CHECK: error: invalid operand
+#CHECK: cdlgtr	%f0, 16, %r0, 0
+
+	cdlgtr	%f0, 0, %r0, -1
+	cdlgtr	%f0, 0, %r0, 16
+	cdlgtr	%f0, -1, %r0, 0
+	cdlgtr	%f0, 16, %r0, 0
+
 #CHECK: error: invalid operand
 #CHECK: cefbra	%f0, 0, %r0, -1
 #CHECK: error: invalid operand
@@ -184,6 +270,20 @@
 	cfdbra	%r0, -1, %f0, 0
 	cfdbra	%r0, 16, %f0, 0
 
+#CHECK: error: invalid operand
+#CHECK: cfdtr	%r0, 0, %f0, -1
+#CHECK: error: invalid operand
+#CHECK: cfdtr	%r0, 0, %f0, 16
+#CHECK: error: invalid operand
+#CHECK: cfdtr	%r0, -1, %f0, 0
+#CHECK: error: invalid operand
+#CHECK: cfdtr	%r0, 16, %f0, 0
+
+	cfdtr	%r0, 0, %f0, -1
+	cfdtr	%r0, 0, %f0, 16
+	cfdtr	%r0, -1, %f0, 0
+	cfdtr	%r0, 16, %f0, 0
+
 #CHECK: error: invalid operand
 #CHECK: cfebra	%r0, 0, %f0, -1
 #CHECK: error: invalid operand
@@ -215,6 +315,23 @@
 	cfxbra	%r0, 16, %f0, 0
 	cfxbra	%r0, 0, %f14, 0
 
+#CHECK: error: invalid operand
+#CHECK: cfxtr	%r0, 0, %f0, -1
+#CHECK: error: invalid operand
+#CHECK: cfxtr	%r0, 0, %f0, 16
+#CHECK: error: invalid operand
+#CHECK: cfxtr	%r0, -1, %f0, 0
+#CHECK: error: invalid operand
+#CHECK: cfxtr	%r0, 16, %f0, 0
+#CHECK: error: invalid register pair
+#CHECK: cfxtr	%r0, 0, %f14, 0
+
+	cfxtr	%r0, 0, %f0, -1
+	cfxtr	%r0, 0, %f0, 16
+	cfxtr	%r0, -1, %f0, 0
+	cfxtr	%r0, 16, %f0, 0
+	cfxtr	%r0, 0, %f14, 0
+
 #CHECK: error: invalid operand
 #CHECK: cgdbra	%r0, 0, %f0, -1
 #CHECK: error: invalid operand
@@ -229,6 +346,20 @@
 	cgdbra	%r0, -1, %f0, 0
 	cgdbra	%r0, 16, %f0, 0
 
+#CHECK: error: invalid operand
+#CHECK: cgdtra	%r0, 0, %f0, -1
+#CHECK: error: invalid operand
+#CHECK: cgdtra	%r0, 0, %f0, 16
+#CHECK: error: invalid operand
+#CHECK: cgdtra	%r0, -1, %f0, 0
+#CHECK: error: invalid operand
+#CHECK: cgdtra	%r0, 16, %f0, 0
+
+	cgdtra	%r0, 0, %f0, -1
+	cgdtra	%r0, 0, %f0, 16
+	cgdtra	%r0, -1, %f0, 0
+	cgdtra	%r0, 16, %f0, 0
+
 #CHECK: error: invalid operand
 #CHECK: cgebra	%r0, 0, %f0, -1
 #CHECK: error: invalid operand
@@ -260,6 +391,23 @@
 	cgxbra	%r0, 16, %f0, 0
 	cgxbra	%r0, 0, %f14, 0
 
+#CHECK: error: invalid operand
+#CHECK: cgxtra	%r0, 0, %f0, -1
+#CHECK: error: invalid operand
+#CHECK: cgxtra	%r0, 0, %f0, 16
+#CHECK: error: invalid operand
+#CHECK: cgxtra	%r0, -1, %f0, 0
+#CHECK: error: invalid operand
+#CHECK: cgxtra	%r0, 16, %f0, 0
+#CHECK: error: invalid register pair
+#CHECK: cgxtra	%r0, 0, %f14, 0
+
+	cgxtra	%r0, 0, %f0, -1
+	cgxtra	%r0, 0, %f0, 16
+	cgxtra	%r0, -1, %f0, 0
+	cgxtra	%r0, 16, %f0, 0
+	cgxtra	%r0, 0, %f14, 0
+
 #CHECK: error: invalid operand
 #CHECK: chf	%r0, -524289
 #CHECK: error: invalid operand
@@ -290,6 +438,20 @@
 	clfdbr	%r0, -1, %f0, 0
 	clfdbr	%r0, 16, %f0, 0
 
+#CHECK: error: invalid operand
+#CHECK: clfdtr	%r0, 0, %f0, -1
+#CHECK: error: invalid operand
+#CHECK: clfdtr	%r0, 0, %f0, 16
+#CHECK: error: invalid operand
+#CHECK: clfdtr	%r0, -1, %f0, 0
+#CHECK: error: invalid operand
+#CHECK: clfdtr	%r0, 16, %f0, 0
+
+	clfdtr	%r0, 0, %f0, -1
+	clfdtr	%r0, 0, %f0, 16
+	clfdtr	%r0, -1, %f0, 0
+	clfdtr	%r0, 16, %f0, 0
+
 #CHECK: error: invalid operand
 #CHECK: clfebr	%r0, 0, %f0, -1
 #CHECK: error: invalid operand
@@ -321,6 +483,23 @@
 	clfxbr	%r0, 16, %f0, 0
 	clfxbr	%r0, 0, %f14, 0
 
+#CHECK: error: invalid operand
+#CHECK: clfxtr	%r0, 0, %f0, -1
+#CHECK: error: invalid operand
+#CHECK: clfxtr	%r0, 0, %f0, 16
+#CHECK: error: invalid operand
+#CHECK: clfxtr	%r0, -1, %f0, 0
+#CHECK: error: invalid operand
+#CHECK: clfxtr	%r0, 16, %f0, 0
+#CHECK: error: invalid register pair
+#CHECK: clfxtr	%r0, 0, %f14, 0
+
+	clfxtr	%r0, 0, %f0, -1
+	clfxtr	%r0, 0, %f0, 16
+	clfxtr	%r0, -1, %f0, 0
+	clfxtr	%r0, 16, %f0, 0
+	clfxtr	%r0, 0, %f14, 0
+
 #CHECK: error: invalid operand
 #CHECK: clgdbr	%r0, 0, %f0, -1
 #CHECK: error: invalid operand
@@ -335,6 +514,20 @@
 	clgdbr	%r0, -1, %f0, 0
 	clgdbr	%r0, 16, %f0, 0
 
+#CHECK: error: invalid operand
+#CHECK: clgdtr	%r0, 0, %f0, -1
+#CHECK: error: invalid operand
+#CHECK: clgdtr	%r0, 0, %f0, 16
+#CHECK: error: invalid operand
+#CHECK: clgdtr	%r0, -1, %f0, 0
+#CHECK: error: invalid operand
+#CHECK: clgdtr	%r0, 16, %f0, 0
+
+	clgdtr	%r0, 0, %f0, -1
+	clgdtr	%r0, 0, %f0, 16
+	clgdtr	%r0, -1, %f0, 0
+	clgdtr	%r0, 16, %f0, 0
+
 #CHECK: error: invalid operand
 #CHECK: clgebr	%r0, 0, %f0, -1
 #CHECK: error: invalid operand
@@ -366,6 +559,23 @@
 	clgxbr	%r0, 16, %f0, 0
 	clgxbr	%r0, 0, %f14, 0
 
+#CHECK: error: invalid operand
+#CHECK: clgxtr	%r0, 0, %f0, -1
+#CHECK: error: invalid operand
+#CHECK: clgxtr	%r0, 0, %f0, 16
+#CHECK: error: invalid operand
+#CHECK: clgxtr	%r0, -1, %f0, 0
+#CHECK: error: invalid operand
+#CHECK: clgxtr	%r0, 16, %f0, 0
+#CHECK: error: invalid register pair
+#CHECK: clgxtr	%r0, 0, %f14, 0
+
+	clgxtr	%r0, 0, %f0, -1
+	clgxtr	%r0, 0, %f0, 16
+	clgxtr	%r0, -1, %f0, 0
+	clgxtr	%r0, 16, %f0, 0
+	clgxtr	%r0, 0, %f14, 0
+
 #CHECK: error: invalid operand
 #CHECK: clhf	%r0, -524289
 #CHECK: error: invalid operand
@@ -399,6 +609,23 @@
 	cxfbra	%f0, 16, %r0, 0
 	cxfbra	%f2, 0, %r0, 0
 
+#CHECK: error: invalid operand
+#CHECK: cxftr	%f0, 0, %r0, -1
+#CHECK: error: invalid operand
+#CHECK: cxftr	%f0, 0, %r0, 16
+#CHECK: error: invalid operand
+#CHECK: cxftr	%f0, -1, %r0, 0
+#CHECK: error: invalid operand
+#CHECK: cxftr	%f0, 16, %r0, 0
+#CHECK: error: invalid register pair
+#CHECK: cxftr	%f2, 0, %r0, 0
+
+	cxftr	%f0, 0, %r0, -1
+	cxftr	%f0, 0, %r0, 16
+	cxftr	%f0, -1, %r0, 0
+	cxftr	%f0, 16, %r0, 0
+	cxftr	%f2, 0, %r0, 0
+
 #CHECK: error: invalid operand
 #CHECK: cxgbra	%f0, 0, %r0, -1
 #CHECK: error: invalid operand
@@ -416,6 +643,23 @@
 	cxgbra	%f0, 16, %r0, 0
 	cxgbra	%f2, 0, %r0, 0
 
+#CHECK: error: invalid operand
+#CHECK: cxgtra	%f0, 0, %r0, -1
+#CHECK: error: invalid operand
+#CHECK: cxgtra	%f0, 0, %r0, 16
+#CHECK: error: invalid operand
+#CHECK: cxgtra	%f0, -1, %r0, 0
+#CHECK: error: invalid operand
+#CHECK: cxgtra	%f0, 16, %r0, 0
+#CHECK: error: invalid register pair
+#CHECK: cxgtra	%f2, 0, %r0, 0
+
+	cxgtra	%f0, 0, %r0, -1
+	cxgtra	%f0, 0, %r0, 16
+	cxgtra	%f0, -1, %r0, 0
+	cxgtra	%f0, 16, %r0, 0
+	cxgtra	%f2, 0, %r0, 0
+
 #CHECK: error: invalid operand
 #CHECK: cxlfbr	%f0, 0, %r0, -1
 #CHECK: error: invalid operand
@@ -433,6 +677,23 @@
 	cxlfbr	%f0, 16, %r0, 0
 	cxlfbr	%f2, 0, %r0, 0
 
+#CHECK: error: invalid operand
+#CHECK: cxlftr	%f0, 0, %r0, -1
+#CHECK: error: invalid operand
+#CHECK: cxlftr	%f0, 0, %r0, 16
+#CHECK: error: invalid operand
+#CHECK: cxlftr	%f0, -1, %r0, 0
+#CHECK: error: invalid operand
+#CHECK: cxlftr	%f0, 16, %r0, 0
+#CHECK: error: invalid register pair
+#CHECK: cxlftr	%f2, 0, %r0, 0
+
+	cxlftr	%f0, 0, %r0, -1
+	cxlftr	%f0, 0, %r0, 16
+	cxlftr	%f0, -1, %r0, 0
+	cxlftr	%f0, 16, %r0, 0
+	cxlftr	%f2, 0, %r0, 0
+
 #CHECK: error: invalid operand
 #CHECK: cxlgbr	%f0, 0, %r0, -1
 #CHECK: error: invalid operand
@@ -450,6 +711,63 @@
 	cxlgbr	%f0, 16, %r0, 0
 	cxlgbr	%f2, 0, %r0, 0
 
+#CHECK: error: invalid operand
+#CHECK: cxlgtr	%f0, 0, %r0, -1
+#CHECK: error: invalid operand
+#CHECK: cxlgtr	%f0, 0, %r0, 16
+#CHECK: error: invalid operand
+#CHECK: cxlgtr	%f0, -1, %r0, 0
+#CHECK: error: invalid operand
+#CHECK: cxlgtr	%f0, 16, %r0, 0
+#CHECK: error: invalid register pair
+#CHECK: cxlgtr	%f2, 0, %r0, 0
+
+	cxlgtr	%f0, 0, %r0, -1
+	cxlgtr	%f0, 0, %r0, 16
+	cxlgtr	%f0, -1, %r0, 0
+	cxlgtr	%f0, 16, %r0, 0
+	cxlgtr	%f2, 0, %r0, 0
+
+#CHECK: error: instruction requires: dfp-zoned-conversion
+#CHECK: cxzt	%f0, 0(1), 0
+
+	cxzt	%f0, 0(1), 0
+
+#CHECK: error: instruction requires: dfp-zoned-conversion
+#CHECK: czdt	%f0, 0(1), 0
+
+	czdt	%f0, 0(1), 0
+
+#CHECK: error: instruction requires: dfp-zoned-conversion
+#CHECK: czxt	%f0, 0(1), 0
+
+	czxt	%f0, 0(1), 0
+
+#CHECK: error: invalid operand
+#CHECK: ddtra	%f0, %f0, %f0, -1
+#CHECK: error: invalid operand
+#CHECK: ddtra	%f0, %f0, %f0, 16
+
+	ddtra	%f0, %f0, %f0, -1
+	ddtra	%f0, %f0, %f0, 16
+
+#CHECK: error: invalid operand
+#CHECK: dxtra	%f0, %f0, %f0, -1
+#CHECK: error: invalid operand
+#CHECK: dxtra	%f0, %f0, %f0, 16
+#CHECK: error: invalid register pair
+#CHECK: dxtra	%f0, %f0, %f2, 0
+#CHECK: error: invalid register pair
+#CHECK: dxtra	%f0, %f2, %f0, 0
+#CHECK: error: invalid register pair
+#CHECK: dxtra	%f2, %f0, %f0, 0
+
+	dxtra	%f0, %f0, %f0, -1
+	dxtra	%f0, %f0, %f0, 16
+	dxtra	%f0, %f0, %f2, 0
+	dxtra	%f0, %f2, %f0, 0
+	dxtra	%f2, %f0, %f0, 0
+
 #CHECK: error: instruction requires: transactional-execution
 #CHECK: etnd	%r7
 
@@ -824,6 +1142,31 @@
 	lpdg	%r2, 0(%r1), -1(%r15)
 	lpdg	%r2, 0(%r1), 4096(%r15)
 
+#CHECK: error: invalid operand
+#CHECK: mdtra	%f0, %f0, %f0, -1
+#CHECK: error: invalid operand
+#CHECK: mdtra	%f0, %f0, %f0, 16
+
+	mdtra	%f0, %f0, %f0, -1
+	mdtra	%f0, %f0, %f0, 16
+
+#CHECK: error: invalid operand
+#CHECK: mxtra	%f0, %f0, %f0, -1
+#CHECK: error: invalid operand
+#CHECK: mxtra	%f0, %f0, %f0, 16
+#CHECK: error: invalid register pair
+#CHECK: mxtra	%f0, %f0, %f2, 0
+#CHECK: error: invalid register pair
+#CHECK: mxtra	%f0, %f2, %f0, 0
+#CHECK: error: invalid register pair
+#CHECK: mxtra	%f2, %f0, %f0, 0
+
+	mxtra	%f0, %f0, %f0, -1
+	mxtra	%f0, %f0, %f0, 16
+	mxtra	%f0, %f0, %f2, 0
+	mxtra	%f0, %f2, %f0, 0
+	mxtra	%f2, %f0, %f0, 0
+
 #CHECK: error: instruction requires: execution-hint
 #CHECK: niai	0, 0
 
@@ -884,6 +1227,14 @@
 	risblg	%r0,%r0,-1,0,0
 	risblg	%r0,%r0,256,0,0
 
+#CHECK: error: invalid operand
+#CHECK: sdtra	%f0, %f0, %f0, -1
+#CHECK: error: invalid operand
+#CHECK: sdtra	%f0, %f0, %f0, 16
+
+	sdtra	%f0, %f0, %f0, -1
+	sdtra	%f0, %f0, %f0, 16
+
 #CHECK: error: invalid operand
 #CHECK: slak	%r0,%r0,-524289
 #CHECK: error: invalid operand
@@ -1009,6 +1360,23 @@
 	stocg	%r0,524288,1
 	stocg	%r0,0(%r1,%r2),1
 
+#CHECK: error: invalid operand
+#CHECK: sxtra	%f0, %f0, %f0, -1
+#CHECK: error: invalid operand
+#CHECK: sxtra	%f0, %f0, %f0, 16
+#CHECK: error: invalid register pair
+#CHECK: sxtra	%f0, %f0, %f2, 0
+#CHECK: error: invalid register pair
+#CHECK: sxtra	%f0, %f2, %f0, 0
+#CHECK: error: invalid register pair
+#CHECK: sxtra	%f2, %f0, %f0, 0
+
+	sxtra	%f0, %f0, %f0, -1
+	sxtra	%f0, %f0, %f0, 16
+	sxtra	%f0, %f0, %f2, 0
+	sxtra	%f0, %f2, %f0, 0
+	sxtra	%f2, %f0, %f0, 0
+
 #CHECK: error: instruction requires: transactional-execution
 #CHECK: tabort	4095(%r1)
 

llvm/test/MC/SystemZ/insn-bad-zEC12.s

@@ -62,6 +62,46 @@
 	bprp	0, 0, 1
 	bprp	0, 0, 0x1000000
 
+#CHECK: error: instruction requires: dfp-packed-conversion
+#CHECK: cdpt	%f0, 0(1), 0
+
+	cdpt	%f0, 0(1), 0
+
+#CHECK: error: invalid operand
+#CHECK: cdzt	%f0, 0(1), -1
+#CHECK: error: invalid operand
+#CHECK: cdzt	%f0, 0(1), 16
+#CHECK: error: missing length in address
+#CHECK: cdzt	%f0, 0, 0
+#CHECK: error: missing length in address
+#CHECK: cdzt	%f0, 0(%r1), 0
+#CHECK: error: invalid operand
+#CHECK: cdzt	%f0, 0(0,%r1), 0
+#CHECK: error: invalid operand
+#CHECK: cdzt	%f0, 0(257,%r1), 0
+#CHECK: error: invalid operand
+#CHECK: cdzt	%f0, -1(1,%r1), 0
+#CHECK: error: invalid operand
+#CHECK: cdzt	%f0, 4096(1,%r1), 0
+#CHECK: error: %r0 used in an address
+#CHECK: cdzt	%f0, 0(1,%r0), 0
+#CHECK: error: invalid use of indexed addressing
+#CHECK: cdzt	%f0, 0(%r1,%r2), 0
+#CHECK: error: unknown token in expression
+#CHECK: cdzt	%f0, 0(-), 0
+
+	cdzt	%f0, 0(1), -1
+	cdzt	%f0, 0(1), 16
+	cdzt	%f0, 0, 0
+	cdzt	%f0, 0(%r1), 0
+	cdzt	%f0, 0(0,%r1), 0
+	cdzt	%f0, 0(257,%r1), 0
+	cdzt	%f0, -1(1,%r1), 0
+	cdzt	%f0, 4096(1,%r1), 0
+	cdzt	%f0, 0(1,%r0), 0
+	cdzt	%f0, 0(%r1,%r2), 0
+	cdzt	%f0, 0(-), 0
+
 #CHECK: error: invalid operand
 #CHECK: clgt	%r0, -1, 0
 #CHECK: error: invalid operand
@@ -112,6 +152,132 @@
         cltno   %r0, 0
         clto    %r0, 0
 
+#CHECK: error: instruction requires: dfp-packed-conversion
+#CHECK: cpdt	%f0, 0(1), 0
+
+	cpdt	%f0, 0(1), 0
+
+#CHECK: error: instruction requires: dfp-packed-conversion
+#CHECK: cpxt	%f0, 0(1), 0
+
+	cpxt	%f0, 0(1), 0
+
+#CHECK: error: instruction requires: dfp-packed-conversion
+#CHECK: cxpt	%f0, 0(1), 0
+
+	cxpt	%f0, 0(1), 0
+
+#CHECK: error: invalid operand
+#CHECK: cxzt	%f0, 0(1), -1
+#CHECK: error: invalid operand
+#CHECK: cxzt	%f0, 0(1), 16
+#CHECK: error: missing length in address
+#CHECK: cxzt	%f0, 0, 0
+#CHECK: error: missing length in address
+#CHECK: cxzt	%f0, 0(%r1), 0
+#CHECK: error: invalid operand
+#CHECK: cxzt	%f0, 0(0,%r1), 0
+#CHECK: error: invalid operand
+#CHECK: cxzt	%f0, 0(257,%r1), 0
+#CHECK: error: invalid operand
+#CHECK: cxzt	%f0, -1(1,%r1), 0
+#CHECK: error: invalid operand
+#CHECK: cxzt	%f0, 4096(1,%r1), 0
+#CHECK: error: %r0 used in an address
+#CHECK: cxzt	%f0, 0(1,%r0), 0
+#CHECK: error: invalid use of indexed addressing
+#CHECK: cxzt	%f0, 0(%r1,%r2), 0
+#CHECK: error: unknown token in expression
+#CHECK: cxzt	%f0, 0(-), 0
+#CHECK: error: invalid register pair
+#CHECK: cxzt	%f15, 0(1), 0
+
+	cxzt	%f0, 0(1), -1
+	cxzt	%f0, 0(1), 16
+	cxzt	%f0, 0, 0
+	cxzt	%f0, 0(%r1), 0
+	cxzt	%f0, 0(0,%r1), 0
+	cxzt	%f0, 0(257,%r1), 0
+	cxzt	%f0, -1(1,%r1), 0
+	cxzt	%f0, 4096(1,%r1), 0
+	cxzt	%f0, 0(1,%r0), 0
+	cxzt	%f0, 0(%r1,%r2), 0
+	cxzt	%f0, 0(-), 0
+	cxzt	%f15, 0(1), 0
+
+#CHECK: error: invalid operand
+#CHECK: czdt	%f0, 0(1), -1
+#CHECK: error: invalid operand
+#CHECK: czdt	%f0, 0(1), 16
+#CHECK: error: missing length in address
+#CHECK: czdt	%f0, 0, 0
+#CHECK: error: missing length in address
+#CHECK: czdt	%f0, 0(%r1), 0
+#CHECK: error: invalid operand
+#CHECK: czdt	%f0, 0(0,%r1), 0
+#CHECK: error: invalid operand
+#CHECK: czdt	%f0, 0(257,%r1), 0
+#CHECK: error: invalid operand
+#CHECK: czdt	%f0, -1(1,%r1), 0
+#CHECK: error: invalid operand
+#CHECK: czdt	%f0, 4096(1,%r1), 0
+#CHECK: error: %r0 used in an address
+#CHECK: czdt	%f0, 0(1,%r0), 0
+#CHECK: error: invalid use of indexed addressing
+#CHECK: czdt	%f0, 0(%r1,%r2), 0
+#CHECK: error: unknown token in expression
+#CHECK: czdt	%f0, 0(-), 0
+
+	czdt	%f0, 0(1), -1
+	czdt	%f0, 0(1), 16
+	czdt	%f0, 0, 0
+	czdt	%f0, 0(%r1), 0
+	czdt	%f0, 0(0,%r1), 0
+	czdt	%f0, 0(257,%r1), 0
+	czdt	%f0, -1(1,%r1), 0
+	czdt	%f0, 4096(1,%r1), 0
+	czdt	%f0, 0(1,%r0), 0
+	czdt	%f0, 0(%r1,%r2), 0
+	czdt	%f0, 0(-), 0
+
+#CHECK: error: invalid operand
+#CHECK: czxt	%f0, 0(1), -1
+#CHECK: error: invalid operand
+#CHECK: czxt	%f0, 0(1), 16
+#CHECK: error: missing length in address
+#CHECK: czxt	%f0, 0, 0
+#CHECK: error: missing length in address
+#CHECK: czxt	%f0, 0(%r1), 0
+#CHECK: error: invalid operand
+#CHECK: czxt	%f0, 0(0,%r1), 0
+#CHECK: error: invalid operand
+#CHECK: czxt	%f0, 0(257,%r1), 0
+#CHECK: error: invalid operand
+#CHECK: czxt	%f0, -1(1,%r1), 0
+#CHECK: error: invalid operand
+#CHECK: czxt	%f0, 4096(1,%r1), 0
+#CHECK: error: %r0 used in an address
+#CHECK: czxt	%f0, 0(1,%r0), 0
+#CHECK: error: invalid use of indexed addressing
+#CHECK: czxt	%f0, 0(%r1,%r2), 0
+#CHECK: error: unknown token in expression
+#CHECK: czxt	%f0, 0(-), 0
+#CHECK: error: invalid register pair
+#CHECK: czxt	%f15, 0(1), 0
+
+	czxt	%f0, 0(1), -1
+	czxt	%f0, 0(1), 16
+	czxt	%f0, 0, 0
+	czxt	%f0, 0(%r1), 0
+	czxt	%f0, 0(0,%r1), 0
+	czxt	%f0, 0(257,%r1), 0
+	czxt	%f0, -1(1,%r1), 0
+	czxt	%f0, 4096(1,%r1), 0
+	czxt	%f0, 0(1,%r0), 0
+	czxt	%f0, 0(%r1,%r2), 0
+	czxt	%f0, 0(-), 0
+	czxt	%f15, 0(1), 0
+
 #CHECK: error: invalid operand
 #CHECK: lat	%r0, -524289
 #CHECK: error: invalid operand

llvm/test/MC/SystemZ/insn-bad.s

@@ -28,6 +28,11 @@
 	adb	%f0, -1
 	adb	%f0, 4096
 
+#CHECK: error: instruction requires: fp-extension
+#CHECK: adtra	%f0, %f0, %f0, 0
+
+	adtra	%f0, %f0, %f0, 0
+
 #CHECK: error: invalid operand
 #CHECK: ae	%f0, -1
 #CHECK: error: invalid operand
@@ -376,6 +381,22 @@
 	axr	%f0, %f2
 	axr	%f2, %f0
 
+#CHECK: error: invalid register pair
+#CHECK: axtr	%f0, %f0, %f2
+#CHECK: error: invalid register pair
+#CHECK: axtr	%f0, %f2, %f0
+#CHECK: error: invalid register pair
+#CHECK: axtr	%f2, %f0, %f0
+
+	axtr	%f0, %f0, %f2
+	axtr	%f0, %f2, %f0
+	axtr	%f2, %f0, %f0
+
+#CHECK: error: instruction requires: fp-extension
+#CHECK: axtra	%f0, %f0, %f0, 0
+
+	axtra	%f0, %f0, %f0, 0
+
 #CHECK: error: invalid operand
 #CHECK: ay	%r0, -524289
 #CHECK: error: invalid operand
@@ -672,21 +693,41 @@
 
 	cdfbra	%f0, 0, %r0, 0
 
+#CHECK: error: instruction requires: fp-extension
+#CHECK: cdftr	%f0, 0, %r0, 0
+
+	cdftr	%f0, 0, %r0, 0
+
 #CHECK: error: instruction requires: fp-extension
 #CHECK: cdgbra	%f0, 0, %r0, 0
 
 	cdgbra	%f0, 0, %r0, 0
 
+#CHECK: error: instruction requires: fp-extension
+#CHECK: cdgtra	%f0, 0, %r0, 0
+
+	cdgtra	%f0, 0, %r0, 0
+
 #CHECK: error: instruction requires: fp-extension
 #CHECK: cdlfbr	%f0, 0, %r0, 0
 
 	cdlfbr	%f0, 0, %r0, 0
 
+#CHECK: error: instruction requires: fp-extension
+#CHECK: cdlftr	%f0, 0, %r0, 0
+
+	cdlftr	%f0, 0, %r0, 0
+
 #CHECK: error: instruction requires: fp-extension
 #CHECK: cdlgbr	%f0, 0, %r0, 0
 
 	cdlgbr	%f0, 0, %r0, 0
 
+#CHECK: error: instruction requires: fp-extension
+#CHECK: cdlgtr	%f0, 0, %r0, 0
+
+	cdlgtr	%f0, 0, %r0, 0
+
 #CHECK: error: invalid register pair
 #CHECK: cds	%r1, %r0, 0
 #CHECK: error: invalid register pair
@@ -774,6 +815,14 @@
 
 	celgbr	%f0, 0, %r0, 0
 
+#CHECK: error: invalid register pair
+#CHECK: cextr	%f0, %f2
+#CHECK: error: invalid register pair
+#CHECK: cextr	%f2, %f0
+
+	cextr	%f0, %f2
+	cextr	%f2, %f0
+
 #CHECK: error: invalid operand
 #CHECK: cfc	-1
 #CHECK: error: invalid operand
@@ -798,6 +847,11 @@
 
 	cfdbra	%r0, 0, %f0, 0
 
+#CHECK: error: instruction requires: fp-extension
+#CHECK: cfdtr	%r0, 0, %f0, 0
+
+	cfdtr	%r0, 0, %f0, 0
+
 #CHECK: error: invalid operand
 #CHECK: cfebr	%r0, -1, %f0
 #CHECK: error: invalid operand
@@ -835,6 +889,11 @@
 
 	cfxbra	%r0, 0, %f0, 0
 
+#CHECK: error: instruction requires: fp-extension
+#CHECK: cfxtr	%r0, 0, %f0, 0
+
+	cfxtr	%r0, 0, %f0, 0
+
 #CHECK: error: invalid operand
 #CHECK: cfxr	%r0, -1, %f0
 #CHECK: error: invalid operand
@@ -867,6 +926,19 @@
 
 	cgdbra	%r0, 0, %f0, 0
 
+#CHECK: error: invalid operand
+#CHECK: cgdtr	%r0, -1, %f0
+#CHECK: error: invalid operand
+#CHECK: cgdtr	%r0, 16, %f0
+
+	cgdtr	%r0, -1, %f0
+	cgdtr	%r0, 16, %f0
+
+#CHECK: error: instruction requires: fp-extension
+#CHECK: cgdtra	%r0, 0, %f0, 0
+
+	cgdtra	%r0, 0, %f0, 0
+
 #CHECK: error: invalid operand
 #CHECK: cgebr	%r0, -1, %f0
 #CHECK: error: invalid operand
@@ -1064,6 +1136,22 @@
 
 	cgxbra	%r0, 0, %f0, 0
 
+#CHECK: error: invalid operand
+#CHECK: cgxtr	%r0, -1, %f0
+#CHECK: error: invalid operand
+#CHECK: cgxtr	%r0, 16, %f0
+#CHECK: error: invalid register pair
+#CHECK: cgxtr	%r0, 0, %f2
+
+	cgxtr	%r0, -1, %f0
+	cgxtr	%r0, 16, %f0
+	cgxtr	%r0, 0, %f2
+
+#CHECK: error: instruction requires: fp-extension
+#CHECK: cgxtra	%r0, 0, %f0, 0
+
+	cgxtra	%r0, 0, %f0, 0
+
 #CHECK: error: invalid operand
 #CHECK: cgxr	%r0, -1, %f0
 #CHECK: error: invalid operand
@@ -1302,6 +1390,11 @@
 
 	clfdbr	%r0, 0, %f0, 0
 
+#CHECK: error: instruction requires: fp-extension
+#CHECK: clfdtr	%r0, 0, %f0, 0
+
+	clfdtr	%r0, 0, %f0, 0
+
 #CHECK: error: instruction requires: fp-extension
 #CHECK: clfebr	%r0, 0, %f0, 0
 
@@ -1351,6 +1444,11 @@
 
 	clfxbr	%r0, 0, %f0, 0
 
+#CHECK: error: instruction requires: fp-extension
+#CHECK: clfxtr	%r0, 0, %f0, 0
+
+	clfxtr	%r0, 0, %f0, 0
+
 #CHECK: error: invalid operand
 #CHECK: clg	%r0, -524289
 #CHECK: error: invalid operand
@@ -1364,6 +1462,11 @@
 
 	clgdbr	%r0, 0, %f0, 0
 
+#CHECK: error: instruction requires: fp-extension
+#CHECK: clgdtr	%r0, 0, %f0, 0
+
+	clgdtr	%r0, 0, %f0, 0
+
 #CHECK: error: instruction requires: fp-extension
 #CHECK: clgebr	%r0, 0, %f0, 0
 
@@ -1515,6 +1618,11 @@
 
 	clgxbr	%r0, 0, %f0, 0
 
+#CHECK: error: instruction requires: fp-extension
+#CHECK: clgxtr	%r0, 0, %f0, 0
+
+	clgxtr	%r0, 0, %f0, 0
+
 #CHECK: error: instruction requires: high-word
 #CHECK: clhf	%r0, 0
 
@@ -1830,6 +1938,14 @@
 	cs	%r0, %r0, 4096
 	cs	%r0, %r0, 0(%r1,%r2)
 
+#CHECK: error: invalid operand
+#CHECK: csdtr	%r0, %f0, -1
+#CHECK: error: invalid operand
+#CHECK: csdtr	%r0, %f0, 16
+
+	csdtr	%r0, %f0, -1
+	csdtr	%r0, %f0, 16
+
 #CHECK: error: invalid operand
 #CHECK: csg	%r0, %r0, -524289
 #CHECK: error: invalid operand
@@ -1858,6 +1974,20 @@
         csst	0(%r1), -1(%r15), %r2
         csst	0(%r1), 4096(%r15), %r2
 
+#CHECK: error: invalid operand
+#CHECK: csxtr	%r0, %f0, -1
+#CHECK: error: invalid operand
+#CHECK: csxtr	%r0, %f0, 16
+#CHECK: error: invalid register pair
+#CHECK: csxtr	%r0, %f2, 0
+#CHECK: error: invalid register pair
+#CHECK: csxtr	%r1, %f0, 0
+
+	csxtr	%r0, %f0, -1
+	csxtr	%r0, %f0, 16
+	csxtr	%r0, %f2, 0
+	csxtr	%r1, %f0, 0
+
 #CHECK: error: invalid operand
 #CHECK: csy	%r0, %r0, -524289
 #CHECK: error: invalid operand
@@ -1977,6 +2107,14 @@
 	cuutf	%r2, %r4, -1
 	cuutf	%r2, %r4, 16
 
+#CHECK: error: invalid register pair
+#CHECK: cuxtr	%r0, %f2
+#CHECK: error: invalid register pair
+#CHECK: cuxtr	%r1, %f0
+
+	cuxtr	%r0, %f2
+	cuxtr	%r1, %f0
+
 #CHECK: error: invalid operand
 #CHECK: cvb	%r0, -1
 #CHECK: error: invalid operand
@@ -2043,6 +2181,11 @@
 
 	cxfbra	%f0, 0, %r0, 0
 
+#CHECK: error: instruction requires: fp-extension
+#CHECK: cxftr	%f0, 0, %r0, 0
+
+	cxftr	%f0, 0, %r0, 0
+
 #CHECK: error: invalid register pair
 #CHECK: cxfr	%f2, %r0
 
@@ -2063,16 +2206,36 @@
 
 	cxgr	%f2, %r0
 
+#CHECK: error: invalid register pair
+#CHECK: cxgtr	%f2, %r0
+
+	cxgtr	%f2, %r0
+
+#CHECK: error: instruction requires: fp-extension
+#CHECK: cxgtra	%f0, 0, %r0, 0
+
+	cxgtra	%f0, 0, %r0, 0
+
 #CHECK: error: instruction requires: fp-extension
 #CHECK: cxlfbr	%f0, 0, %r0, 0
 
 	cxlfbr	%f0, 0, %r0, 0
 
+#CHECK: error: instruction requires: fp-extension
+#CHECK: cxlftr	%f0, 0, %r0, 0
+
+	cxlftr	%f0, 0, %r0, 0
+
 #CHECK: error: instruction requires: fp-extension
 #CHECK: cxlgbr	%f0, 0, %r0, 0
 
 	cxlgbr	%f0, 0, %r0, 0
 
+#CHECK: error: instruction requires: fp-extension
+#CHECK: cxlgtr	%f0, 0, %r0, 0
+
+	cxlgtr	%f0, 0, %r0, 0
+
 #CHECK: error: invalid register pair
 #CHECK: cxr	%f0, %f2
 #CHECK: error: invalid register pair
@@ -2081,6 +2244,30 @@
 	cxr	%f0, %f2
 	cxr	%f2, %f0
 
+#CHECK: error: invalid register pair
+#CHECK: cxstr	%f0, %r1
+#CHECK: error: invalid register pair
+#CHECK: cxstr	%f2, %r0
+
+	cxstr	%f0, %r1
+	cxstr	%f2, %r0
+
+#CHECK: error: invalid register pair
+#CHECK: cxtr	%f0, %f2
+#CHECK: error: invalid register pair
+#CHECK: cxtr	%f2, %f0
+
+	cxtr	%f0, %f2
+	cxtr	%f2, %f0
+
+#CHECK: error: invalid register pair
+#CHECK: cxutr	%f0, %r1
+#CHECK: error: invalid register pair
+#CHECK: cxutr	%f2, %r0
+
+	cxutr	%f0, %r1
+	cxutr	%f2, %r0
+
 #CHECK: error: invalid operand
 #CHECK: cy	%r0, -524289
 #CHECK: error: invalid operand
@@ -2116,6 +2303,11 @@
 	ddb	%f0, -1
 	ddb	%f0, 4096
 
+#CHECK: error: instruction requires: fp-extension
+#CHECK: ddtra	%f0, %f0, %f0, 0
+
+	ddtra	%f0, %f0, %f0, 0
+
 #CHECK: error: invalid operand
 #CHECK: de	%f0, -1
 #CHECK: error: invalid operand
@@ -2286,6 +2478,22 @@
 	dxr	%f0, %f2
 	dxr	%f2, %f0
 
+#CHECK: error: invalid register pair
+#CHECK: dxtr	%f0, %f0, %f2
+#CHECK: error: invalid register pair
+#CHECK: dxtr	%f0, %f2, %f0
+#CHECK: error: invalid register pair
+#CHECK: dxtr	%f2, %f0, %f0
+
+	dxtr	%f0, %f0, %f2
+	dxtr	%f0, %f2, %f0
+	dxtr	%f2, %f0, %f0
+
+#CHECK: error: instruction requires: fp-extension
+#CHECK: dxtra	%f0, %f0, %f0, 0
+
+	dxtra	%f0, %f0, %f0, 0
+
 #CHECK: error: invalid operand
 #CHECK: ecag	%r0, %r0, -524289
 #CHECK: error: invalid operand
@@ -2402,6 +2610,22 @@
 	edmk	0(1,%r2), 0(%r1,%r2)
 	edmk	0(-), 0
 
+#CHECK: error: invalid register pair
+#CHECK: eextr	%f0, %f2
+#CHECK: error: invalid register pair
+#CHECK: eextr	%f2, %f0
+
+	eextr	%f0, %f2
+	eextr	%f2, %f0
+
+#CHECK: error: invalid register pair
+#CHECK: esxtr	%f0, %f2
+#CHECK: error: invalid register pair
+#CHECK: esxtr	%f2, %f0
+
+	esxtr	%f0, %f2
+	esxtr	%f2, %f0
+
 #CHECK: error: invalid operand
 #CHECK: ex      %r0, -1
 #CHECK: error: invalid operand
@@ -2423,6 +2647,20 @@
 
 	fidbra	%f0, 0, %f0, 0
 
+#CHECK: error: invalid operand
+#CHECK: fidtr	%f0, 0, %f0, -1
+#CHECK: error: invalid operand
+#CHECK: fidtr	%f0, 0, %f0, 16
+#CHECK: error: invalid operand
+#CHECK: fidtr	%f0, -1, %f0, 0
+#CHECK: error: invalid operand
+#CHECK: fidtr	%f0, 16, %f0, 0
+
+	fidtr	%f0, 0, %f0, -1
+	fidtr	%f0, 0, %f0, 16
+	fidtr	%f0, -1, %f0, 0
+	fidtr	%f0, 16, %f0, 0
+
 #CHECK: error: invalid operand
 #CHECK: fiebr	%f0, -1, %f0
 #CHECK: error: invalid operand
@@ -2463,6 +2701,26 @@
 	fixr	%f0, %f2
 	fixr	%f2, %f0
 
+#CHECK: error: invalid operand
+#CHECK: fixtr	%f0, 0, %f0, -1
+#CHECK: error: invalid operand
+#CHECK: fixtr	%f0, 0, %f0, 16
+#CHECK: error: invalid operand
+#CHECK: fixtr	%f0, -1, %f0, 0
+#CHECK: error: invalid operand
+#CHECK: fixtr	%f0, 16, %f0, 0
+#CHECK: error: invalid register pair
+#CHECK: fixtr	%f0, 0, %f2, 0
+#CHECK: error: invalid register pair
+#CHECK: fixtr	%f2, 0, %f0, 0
+
+	fixtr	%f0, 0, %f0, -1
+	fixtr	%f0, 0, %f0, 16
+	fixtr	%f0, -1, %f0, 0
+	fixtr	%f0, 16, %f0, 0
+	fixtr	%f0, 0, %f2, 0
+	fixtr	%f2, 0, %f0, 0
+
 #CHECK: error: invalid register pair
 #CHECK: flogr	%r1, %r0
 
@@ -2526,6 +2784,17 @@
 	icy	%r0, -524289
 	icy	%r0, 524288
 
+#CHECK: error: invalid register pair
+#CHECK: iextr	%f0, %f0, %f2
+#CHECK: error: invalid register pair
+#CHECK: iextr	%f0, %f2, %f0
+#CHECK: error: invalid register pair
+#CHECK: iextr	%f2, %f0, %f0
+
+	iextr	%f0, %f0, %f2
+	iextr	%f0, %f2, %f0
+	iextr	%f2, %f0, %f0
+
 #CHECK: error: invalid operand
 #CHECK: iihf	%r0, -1
 #CHECK: error: invalid operand
@@ -2644,6 +2913,14 @@
 	kxbr	%f0, %f2
 	kxbr	%f2, %f0
 
+#CHECK: error: invalid register pair
+#CHECK: kxtr	%f0, %f2
+#CHECK: error: invalid register pair
+#CHECK: kxtr	%f2, %f0
+
+	kxtr	%f0, %f2
+	kxtr	%f2, %f0
+
 #CHECK: error: invalid operand
 #CHECK: l	%r0, -1
 #CHECK: error: invalid operand
@@ -2802,6 +3079,14 @@
 	ldeb	%f0, -1
 	ldeb	%f0, 4096
 
+#CHECK: error: invalid operand
+#CHECK: ldetr	%f0, %f0, -1
+#CHECK: error: invalid operand
+#CHECK: ldetr	%f0, %f0, 16
+
+	ldetr	%f0, %f0, -1
+	ldetr	%f0, %f0, 16
+
 #CHECK: error: invalid register pair
 #CHECK: ldxbr	%f0, %f2
 #CHECK: error: invalid register pair
@@ -2820,6 +3105,26 @@
 
 	ldxr	%f0, %f2
 
+#CHECK: error: invalid operand
+#CHECK: ldxtr	%f0, 0, %f0, -1
+#CHECK: error: invalid operand
+#CHECK: ldxtr	%f0, 0, %f0, 16
+#CHECK: error: invalid operand
+#CHECK: ldxtr	%f0, -1, %f0, 0
+#CHECK: error: invalid operand
+#CHECK: ldxtr	%f0, 16, %f0, 0
+#CHECK: error: invalid register pair
+#CHECK: ldxtr	%f0, 0, %f2, 0
+#CHECK: error: invalid register pair
+#CHECK: ldxtr	%f2, 0, %f0, 0
+
+	ldxtr	%f0, 0, %f0, -1
+	ldxtr	%f0, 0, %f0, 16
+	ldxtr	%f0, -1, %f0, 0
+	ldxtr	%f0, 16, %f0, 0
+	ldxtr	%f0, 0, %f2, 0
+	ldxtr	%f2, 0, %f0, 0
+
 #CHECK: error: invalid operand
 #CHECK: ldy	%f0, -524289
 #CHECK: error: invalid operand
@@ -2841,6 +3146,20 @@
 
 	ledbra	%f0, 0, %f0, 0
 
+#CHECK: error: invalid operand
+#CHECK: ledtr	%f0, 0, %f0, -1
+#CHECK: error: invalid operand
+#CHECK: ledtr	%f0, 0, %f0, 16
+#CHECK: error: invalid operand
+#CHECK: ledtr	%f0, -1, %f0, 0
+#CHECK: error: invalid operand
+#CHECK: ledtr	%f0, 16, %f0, 0
+
+	ledtr	%f0, 0, %f0, -1
+	ledtr	%f0, 0, %f0, 16
+	ledtr	%f0, -1, %f0, 0
+	ledtr	%f0, 16, %f0, 0
+
 #CHECK: error: invalid register pair
 #CHECK: lexbr	%f0, %f2
 #CHECK: error: invalid register pair
@@ -3365,6 +3684,14 @@
 	ltxr	%f0, %f14
 	ltxr	%f14, %f0
 
+#CHECK: error: invalid register pair
+#CHECK: ltxtr	%f0, %f14
+#CHECK: error: invalid register pair
+#CHECK: ltxtr	%f14, %f0
+
+	ltxtr	%f0, %f14
+	ltxtr	%f14, %f0
+
 #CHECK: error: invalid operand
 #CHECK: lxd	%f0, -1
 #CHECK: error: invalid operand
@@ -3397,6 +3724,17 @@
 
 	lxdr	%f2, %f0
 
+#CHECK: error: invalid operand
+#CHECK: lxdtr	%f0, %f0, -1
+#CHECK: error: invalid operand
+#CHECK: lxdtr	%f0, %f0, 16
+#CHECK: error: invalid register pair
+#CHECK: lxdtr	%f2, %f0, 0
+
+	lxdtr	%f0, %f0, -1
+	lxdtr	%f0, %f0, 16
+	lxdtr	%f2, %f0, 0
+
 #CHECK: error: invalid operand
 #CHECK: lxe	%f0, -1
 #CHECK: error: invalid operand
@@ -3574,6 +3912,11 @@
 	mdeb	%f0, -1
 	mdeb	%f0, 4096
 
+#CHECK: error: instruction requires: fp-extension
+#CHECK: mdtra	%f0, %f0, %f0, 0
+
+	mdtra	%f0, %f0, %f0, 0
+
 #CHECK: error: invalid operand
 #CHECK: me	%f0, -1
 #CHECK: error: invalid operand
@@ -4244,6 +4587,22 @@
 	mxr	%f0, %f2
 	mxr	%f2, %f0
 
+#CHECK: error: invalid register pair
+#CHECK: mxtr	%f0, %f0, %f2
+#CHECK: error: invalid register pair
+#CHECK: mxtr	%f0, %f2, %f0
+#CHECK: error: invalid register pair
+#CHECK: mxtr	%f2, %f0, %f0
+
+	mxtr	%f0, %f0, %f2
+	mxtr	%f0, %f2, %f0
+	mxtr	%f2, %f0, %f0
+
+#CHECK: error: instruction requires: fp-extension
+#CHECK: mxtra	%f0, %f0, %f0, 0
+
+	mxtra	%f0, %f0, %f0, 0
+
 #CHECK: error: invalid operand
 #CHECK: my	%f0, %f0, -1
 #CHECK: error: invalid operand
@@ -4802,6 +5161,31 @@
 #CHECK: pr    %r0
         pr    %r0
 
+#CHECK: error: invalid operand
+#CHECK: qadtr	%f0, %f0, %f0, -1
+#CHECK: error: invalid operand
+#CHECK: qadtr	%f0, %f0, %f0, 16
+
+	qadtr	%f0, %f0, %f0, -1
+	qadtr	%f0, %f0, %f0, 16
+
+#CHECK: error: invalid operand
+#CHECK: qaxtr	%f0, %f0, %f0, -1
+#CHECK: error: invalid operand
+#CHECK: qaxtr	%f0, %f0, %f0, 16
+#CHECK: error: invalid register pair
+#CHECK: qaxtr	%f0, %f0, %f2, 0
+#CHECK: error: invalid register pair
+#CHECK: qaxtr	%f0, %f2, %f0, 0
+#CHECK: error: invalid register pair
+#CHECK: qaxtr	%f2, %f0, %f0, 0
+
+	qaxtr	%f0, %f0, %f0, -1
+	qaxtr	%f0, %f0, %f0, 16
+	qaxtr	%f0, %f0, %f2, 0
+	qaxtr	%f0, %f2, %f0, 0
+	qaxtr	%f2, %f0, %f0, 0
+
 #CHECK: error: invalid operand
 #CHECK: risbg	%r0,%r0,0,0,-1
 #CHECK: error: invalid operand
@@ -4900,6 +5284,31 @@
 	rosbg	%r0,%r0,-1,0,0
 	rosbg	%r0,%r0,256,0,0
 
+#CHECK: error: invalid operand
+#CHECK: rrdtr	%f0, %f0, %f0, -1
+#CHECK: error: invalid operand
+#CHECK: rrdtr	%f0, %f0, %f0, 16
+
+	rrdtr	%f0, %f0, %f0, -1
+	rrdtr	%f0, %f0, %f0, 16
+
+#CHECK: error: invalid operand
+#CHECK: rrxtr	%f0, %f0, %f0, -1
+#CHECK: error: invalid operand
+#CHECK: rrxtr	%f0, %f0, %f0, 16
+#CHECK: error: invalid register pair
+#CHECK: rrxtr	%f0, %f0, %f2, 0
+#CHECK: error: invalid register pair
+#CHECK: rrxtr	%f0, %f2, %f0, 0
+#CHECK: error: invalid register pair
+#CHECK: rrxtr	%f2, %f0, %f0, 0
+
+	rrxtr	%f0, %f0, %f0, -1
+	rrxtr	%f0, %f0, %f0, 16
+	rrxtr	%f0, %f0, %f2, 0
+	rrxtr	%f0, %f2, %f0, 0
+	rrxtr	%f2, %f0, %f0, 0
+
 #CHECK: error: invalid operand
 #CHECK: rxsbg	%r0,%r0,0,0,-1
 #CHECK: error: invalid operand
@@ -4944,6 +5353,11 @@
 	sdb	%f0, -1
 	sdb	%f0, 4096
 
+#CHECK: error: instruction requires: fp-extension
+#CHECK: sdtra	%f0, %f0, %f0, 0
+
+	sdtra	%f0, %f0, %f0, 0
+
 #CHECK: error: invalid operand
 #CHECK: se	%f0, -1
 #CHECK: error: invalid operand
@@ -5088,6 +5502,14 @@
 	sldl	%r0,0(%r0)
 	sldl	%r0,0(%r1,%r2)
 
+#CHECK: error: invalid operand
+#CHECK: sldt	%f0, %f0, -1
+#CHECK: error: invalid operand
+#CHECK: sldt	%f0, %f0, 4096
+
+	sldt	%f0, %f0, -1
+	sldt	%f0, %f0, 4096
+
 #CHECK: error: invalid operand
 #CHECK: slfi	%r0, -1
 #CHECK: error: invalid operand
@@ -5163,6 +5585,20 @@
 
 	slrk	%r2,%r3,%r4
 
+#CHECK: error: invalid operand
+#CHECK: slxt	%f0, %f0, -1
+#CHECK: error: invalid operand
+#CHECK: slxt	%f0, %f0, 4096
+#CHECK: error: invalid register pair
+#CHECK: slxt	%f0, %f2, 0
+#CHECK: error: invalid register pair
+#CHECK: slxt	%f2, %f0, 0
+
+	slxt	%f0, %f0, -1
+	slxt	%f0, %f0, 4096
+	slxt	%f0, %f2, 0
+	slxt	%f2, %f0, 0
+
 #CHECK: error: invalid operand
 #CHECK: sly	%r0, -524289
 #CHECK: error: invalid operand
@@ -5339,6 +5775,14 @@
 	srdl	%r0,0(%r0)
 	srdl	%r0,0(%r1,%r2)
 
+#CHECK: error: invalid operand
+#CHECK: srdt	%f0, %f0, -1
+#CHECK: error: invalid operand
+#CHECK: srdt	%f0, %f0, 4096
+
+	srdt	%f0, %f0, -1
+	srdt	%f0, %f0, 4096
+
 #CHECK: error: instruction requires: distinct-ops
 #CHECK: srk	%r2,%r3,%r4
 
@@ -5454,6 +5898,20 @@
 	srp	0(1), 0, 16
 	srp	0(-), 0, 0
 
+#CHECK: error: invalid operand
+#CHECK: srxt	%f0, %f0, -1
+#CHECK: error: invalid operand
+#CHECK: srxt	%f0, %f0, 4096
+#CHECK: error: invalid register pair
+#CHECK: srxt	%f0, %f2, 0
+#CHECK: error: invalid register pair
+#CHECK: srxt	%f2, %f0, 0
+
+	srxt	%f0, %f0, -1
+	srxt	%f0, %f0, 4096
+	srxt	%f0, %f2, 0
+	srxt	%f2, %f0, 0
+
 #CHECK: error: invalid operand
 #CHECK: st	%r0, -1
 #CHECK: error: invalid operand
@@ -5788,6 +6246,22 @@
 	sxr	%f0, %f2
 	sxr	%f2, %f0
 
+#CHECK: error: invalid register pair
+#CHECK: sxtr	%f0, %f0, %f2
+#CHECK: error: invalid register pair
+#CHECK: sxtr	%f0, %f2, %f0
+#CHECK: error: invalid register pair
+#CHECK: sxtr	%f2, %f0, %f0
+
+	sxtr	%f0, %f0, %f2
+	sxtr	%f0, %f2, %f0
+	sxtr	%f2, %f0, %f0
+
+#CHECK: error: instruction requires: fp-extension
+#CHECK: sxtra	%f0, %f0, %f0, 0
+
+	sxtra	%f0, %f0, %f0, 0
+
 #CHECK: error: invalid operand
 #CHECK: sy	%r0, -524289
 #CHECK: error: invalid operand
@@ -5836,6 +6310,60 @@
 	tcxb	%f0, -1
 	tcxb	%f0, 4096
 
+#CHECK: error: invalid operand
+#CHECK: tdcdt	%f0, -1
+#CHECK: error: invalid operand
+#CHECK: tdcdt	%f0, 4096
+
+	tdcdt	%f0, -1
+	tdcdt	%f0, 4096
+
+#CHECK: error: invalid operand
+#CHECK: tdcet	%f0, -1
+#CHECK: error: invalid operand
+#CHECK: tdcet	%f0, 4096
+
+	tdcet	%f0, -1
+	tdcet	%f0, 4096
+
+#CHECK: error: invalid operand
+#CHECK: tdcxt	%f0, -1
+#CHECK: error: invalid operand
+#CHECK: tdcxt	%f0, 4096
+#CHECK: error: invalid register pair
+#CHECK: tdcxt	%f2, 0
+
+	tdcxt	%f0, -1
+	tdcxt	%f0, 4096
+	tdcxt	%f2, 0
+
+#CHECK: error: invalid operand
+#CHECK: tdgdt	%f0, -1
+#CHECK: error: invalid operand
+#CHECK: tdgdt	%f0, 4096
+
+	tdgdt	%f0, -1
+	tdgdt	%f0, 4096
+
+#CHECK: error: invalid operand
+#CHECK: tdget	%f0, -1
+#CHECK: error: invalid operand
+#CHECK: tdget	%f0, 4096
+
+	tdget	%f0, -1
+	tdget	%f0, 4096
+
+#CHECK: error: invalid operand
+#CHECK: tdgxt	%f0, -1
+#CHECK: error: invalid operand
+#CHECK: tdgxt	%f0, 4096
+#CHECK: error: invalid register pair
+#CHECK: tdgxt	%f2, 0
+
+	tdgxt	%f0, -1
+	tdgxt	%f0, 4096
+	tdgxt	%f2, 0
+
 #CHECK: error: invalid operand
 #CHECK: tm	-1, 0
 #CHECK: error: invalid operand

llvm/test/MC/SystemZ/insn-good-z13.s

@@ -4,6 +4,86 @@
 # RUN: llvm-mc -triple s390x-linux-gnu -mcpu=arch11 -show-encoding %s \
 # RUN:   | FileCheck %s
 
+#CHECK: cdpt	%f0, 0(1), 0                # encoding: [0xed,0x00,0x00,0x00,0x00,0xae]
+#CHECK: cdpt	%f15, 0(1), 0               # encoding: [0xed,0x00,0x00,0x00,0xf0,0xae]
+#CHECK: cdpt	%f0, 0(1), 15               # encoding: [0xed,0x00,0x00,0x00,0x0f,0xae]
+#CHECK: cdpt	%f0, 0(1,%r1), 0            # encoding: [0xed,0x00,0x10,0x00,0x00,0xae]
+#CHECK: cdpt	%f0, 0(1,%r15), 0           # encoding: [0xed,0x00,0xf0,0x00,0x00,0xae]
+#CHECK: cdpt	%f0, 4095(1,%r1), 0         # encoding: [0xed,0x00,0x1f,0xff,0x00,0xae]
+#CHECK: cdpt	%f0, 4095(1,%r15), 0        # encoding: [0xed,0x00,0xff,0xff,0x00,0xae]
+#CHECK: cdpt	%f0, 0(256,%r1), 0          # encoding: [0xed,0xff,0x10,0x00,0x00,0xae]
+#CHECK: cdpt	%f0, 0(256,%r15), 0         # encoding: [0xed,0xff,0xf0,0x00,0x00,0xae]
+
+	cdpt	%f0, 0(1), 0
+	cdpt	%f15, 0(1), 0
+	cdpt	%f0, 0(1), 15
+	cdpt	%f0, 0(1,%r1), 0
+	cdpt	%f0, 0(1,%r15), 0
+	cdpt	%f0, 4095(1,%r1), 0
+	cdpt	%f0, 4095(1,%r15), 0
+	cdpt	%f0, 0(256,%r1), 0
+	cdpt	%f0, 0(256,%r15), 0
+
+#CHECK: cpdt	%f0, 0(1), 0                # encoding: [0xed,0x00,0x00,0x00,0x00,0xac]
+#CHECK: cpdt	%f15, 0(1), 0               # encoding: [0xed,0x00,0x00,0x00,0xf0,0xac]
+#CHECK: cpdt	%f0, 0(1), 15               # encoding: [0xed,0x00,0x00,0x00,0x0f,0xac]
+#CHECK: cpdt	%f0, 0(1,%r1), 0            # encoding: [0xed,0x00,0x10,0x00,0x00,0xac]
+#CHECK: cpdt	%f0, 0(1,%r15), 0           # encoding: [0xed,0x00,0xf0,0x00,0x00,0xac]
+#CHECK: cpdt	%f0, 4095(1,%r1), 0         # encoding: [0xed,0x00,0x1f,0xff,0x00,0xac]
+#CHECK: cpdt	%f0, 4095(1,%r15), 0        # encoding: [0xed,0x00,0xff,0xff,0x00,0xac]
+#CHECK: cpdt	%f0, 0(256,%r1), 0          # encoding: [0xed,0xff,0x10,0x00,0x00,0xac]
+#CHECK: cpdt	%f0, 0(256,%r15), 0         # encoding: [0xed,0xff,0xf0,0x00,0x00,0xac]
+
+	cpdt	%f0, 0(1), 0
+	cpdt	%f15, 0(1), 0
+	cpdt	%f0, 0(1), 15
+	cpdt	%f0, 0(1,%r1), 0
+	cpdt	%f0, 0(1,%r15), 0
+	cpdt	%f0, 4095(1,%r1), 0
+	cpdt	%f0, 4095(1,%r15), 0
+	cpdt	%f0, 0(256,%r1), 0
+	cpdt	%f0, 0(256,%r15), 0
+
+#CHECK: cpxt	%f0, 0(1), 0                # encoding: [0xed,0x00,0x00,0x00,0x00,0xad]
+#CHECK: cpxt	%f13, 0(1), 0               # encoding: [0xed,0x00,0x00,0x00,0xd0,0xad]
+#CHECK: cpxt	%f0, 0(1), 15               # encoding: [0xed,0x00,0x00,0x00,0x0f,0xad]
+#CHECK: cpxt	%f0, 0(1,%r1), 0            # encoding: [0xed,0x00,0x10,0x00,0x00,0xad]
+#CHECK: cpxt	%f0, 0(1,%r15), 0           # encoding: [0xed,0x00,0xf0,0x00,0x00,0xad]
+#CHECK: cpxt	%f0, 4095(1,%r1), 0         # encoding: [0xed,0x00,0x1f,0xff,0x00,0xad]
+#CHECK: cpxt	%f0, 4095(1,%r15), 0        # encoding: [0xed,0x00,0xff,0xff,0x00,0xad]
+#CHECK: cpxt	%f0, 0(256,%r1), 0          # encoding: [0xed,0xff,0x10,0x00,0x00,0xad]
+#CHECK: cpxt	%f0, 0(256,%r15), 0         # encoding: [0xed,0xff,0xf0,0x00,0x00,0xad]
+
+	cpxt	%f0, 0(1), 0
+	cpxt	%f13, 0(1), 0
+	cpxt	%f0, 0(1), 15
+	cpxt	%f0, 0(1,%r1), 0
+	cpxt	%f0, 0(1,%r15), 0
+	cpxt	%f0, 4095(1,%r1), 0
+	cpxt	%f0, 4095(1,%r15), 0
+	cpxt	%f0, 0(256,%r1), 0
+	cpxt	%f0, 0(256,%r15), 0
+
+#CHECK: cxpt	%f0, 0(1), 0                # encoding: [0xed,0x00,0x00,0x00,0x00,0xaf]
+#CHECK: cxpt	%f13, 0(1), 0               # encoding: [0xed,0x00,0x00,0x00,0xd0,0xaf]
+#CHECK: cxpt	%f0, 0(1), 15               # encoding: [0xed,0x00,0x00,0x00,0x0f,0xaf]
+#CHECK: cxpt	%f0, 0(1,%r1), 0            # encoding: [0xed,0x00,0x10,0x00,0x00,0xaf]
+#CHECK: cxpt	%f0, 0(1,%r15), 0           # encoding: [0xed,0x00,0xf0,0x00,0x00,0xaf]
+#CHECK: cxpt	%f0, 4095(1,%r1), 0         # encoding: [0xed,0x00,0x1f,0xff,0x00,0xaf]
+#CHECK: cxpt	%f0, 4095(1,%r15), 0        # encoding: [0xed,0x00,0xff,0xff,0x00,0xaf]
+#CHECK: cxpt	%f0, 0(256,%r1), 0          # encoding: [0xed,0xff,0x10,0x00,0x00,0xaf]
+#CHECK: cxpt	%f0, 0(256,%r15), 0         # encoding: [0xed,0xff,0xf0,0x00,0x00,0xaf]
+
+	cxpt	%f0, 0(1), 0
+	cxpt	%f13, 0(1), 0
+	cxpt	%f0, 0(1), 15
+	cxpt	%f0, 0(1,%r1), 0
+	cxpt	%f0, 0(1,%r15), 0
+	cxpt	%f0, 4095(1,%r1), 0
+	cxpt	%f0, 4095(1,%r15), 0
+	cxpt	%f0, 0(256,%r1), 0
+	cxpt	%f0, 0(256,%r15), 0
+
 #CHECK: lcbb    %r0, 0, 0               # encoding: [0xe7,0x00,0x00,0x00,0x00,0x27]
 #CHECK: lcbb    %r0, 0, 15              # encoding: [0xe7,0x00,0x00,0x00,0xf0,0x27]
 #CHECK: lcbb    %r0, 4095, 0            # encoding: [0xe7,0x00,0x0f,0xff,0x00,0x27]

llvm/test/MC/SystemZ/insn-good-z196.s

@@ -2,6 +2,20 @@
 # RUN: llvm-mc -triple s390x-linux-gnu -mcpu=z196 -show-encoding %s | FileCheck %s
 # RUN: llvm-mc -triple s390x-linux-gnu -mcpu=arch9 -show-encoding %s | FileCheck %s
 
+#CHECK: adtra	%f0, %f0, %f0, 0        # encoding: [0xb3,0xd2,0x00,0x00]
+#CHECK: adtra	%f0, %f0, %f0, 15       # encoding: [0xb3,0xd2,0x0f,0x00]
+#CHECK: adtra	%f0, %f0, %f15, 0       # encoding: [0xb3,0xd2,0xf0,0x00]
+#CHECK: adtra	%f0, %f15, %f0, 0       # encoding: [0xb3,0xd2,0x00,0x0f]
+#CHECK: adtra	%f15, %f0, %f0, 0       # encoding: [0xb3,0xd2,0x00,0xf0]
+#CHECK: adtra	%f7, %f8, %f9, 10       # encoding: [0xb3,0xd2,0x9a,0x78]
+
+	adtra	%f0, %f0, %f0, 0
+	adtra	%f0, %f0, %f0, 15
+	adtra	%f0, %f0, %f15, 0
+	adtra	%f0, %f15, %f0, 0
+	adtra	%f15, %f0, %f0, 0
+	adtra	%f7, %f8, %f9, 10
+
 #CHECK: aghik	%r0, %r0, -32768        # encoding: [0xec,0x00,0x80,0x00,0x00,0xd9]
 #CHECK: aghik	%r0, %r0, -1            # encoding: [0xec,0x00,0xff,0xff,0x00,0xd9]
 #CHECK: aghik	%r0, %r0, 0             # encoding: [0xec,0x00,0x00,0x00,0x00,0xd9]
@@ -136,6 +150,20 @@
 	ark	%r15,%r0,%r0
 	ark	%r7,%r8,%r9
 
+#CHECK: axtra	%f0, %f0, %f0, 0        # encoding: [0xb3,0xda,0x00,0x00]
+#CHECK: axtra	%f0, %f0, %f0, 15       # encoding: [0xb3,0xda,0x0f,0x00]
+#CHECK: axtra	%f0, %f0, %f13, 0       # encoding: [0xb3,0xda,0xd0,0x00]
+#CHECK: axtra	%f0, %f13, %f0, 0       # encoding: [0xb3,0xda,0x00,0x0d]
+#CHECK: axtra	%f13, %f0, %f0, 0       # encoding: [0xb3,0xda,0x00,0xd0]
+#CHECK: axtra	%f8, %f8, %f8, 8        # encoding: [0xb3,0xda,0x88,0x88]
+
+	axtra	%f0, %f0, %f0, 0
+	axtra	%f0, %f0, %f0, 15
+	axtra	%f0, %f0, %f13, 0
+	axtra	%f0, %f13, %f0, 0
+	axtra	%f13, %f0, %f0, 0
+	axtra	%f8, %f8, %f8, 8
+
 #CHECK: brcth	%r0, .[[LAB:L.*]]-4294967296 # encoding: [0xcc,0x06,A,A,A,A]
 #CHECK:  fixup A - offset: 2, value: (.[[LAB]]-4294967296)+2, kind: FK_390_PC32DBL
 	brcth	%r0, -0x100000000
@@ -187,6 +215,20 @@
 	cdfbra	%f4, 5, %r6, 7
 	cdfbra	%f15, 0, %r0, 0
 
+#CHECK: cdftr	%f0, 0, %r0, 0          # encoding: [0xb9,0x51,0x00,0x00]
+#CHECK: cdftr	%f0, 0, %r0, 15         # encoding: [0xb9,0x51,0x0f,0x00]
+#CHECK: cdftr	%f0, 0, %r15, 0         # encoding: [0xb9,0x51,0x00,0x0f]
+#CHECK: cdftr	%f0, 15, %r0, 0         # encoding: [0xb9,0x51,0xf0,0x00]
+#CHECK: cdftr	%f4, 5, %r6, 7          # encoding: [0xb9,0x51,0x57,0x46]
+#CHECK: cdftr	%f15, 0, %r0, 0         # encoding: [0xb9,0x51,0x00,0xf0]
+
+	cdftr	%f0, 0, %r0, 0
+	cdftr	%f0, 0, %r0, 15
+	cdftr	%f0, 0, %r15, 0
+	cdftr	%f0, 15, %r0, 0
+	cdftr	%f4, 5, %r6, 7
+	cdftr	%f15, 0, %r0, 0
+
 #CHECK: cdgbra	%f0, 0, %r0, 0          # encoding: [0xb3,0xa5,0x00,0x00]
 #CHECK: cdgbra	%f0, 0, %r0, 15         # encoding: [0xb3,0xa5,0x0f,0x00]
 #CHECK: cdgbra	%f0, 0, %r15, 0         # encoding: [0xb3,0xa5,0x00,0x0f]
@@ -201,6 +243,20 @@
 	cdgbra	%f4, 5, %r6, 7
 	cdgbra	%f15, 0, %r0, 0
 
+#CHECK: cdgtra	%f0, 0, %r0, 0          # encoding: [0xb3,0xf1,0x00,0x00]
+#CHECK: cdgtra	%f0, 0, %r0, 15         # encoding: [0xb3,0xf1,0x0f,0x00]
+#CHECK: cdgtra	%f0, 0, %r15, 0         # encoding: [0xb3,0xf1,0x00,0x0f]
+#CHECK: cdgtra	%f0, 15, %r0, 0         # encoding: [0xb3,0xf1,0xf0,0x00]
+#CHECK: cdgtra	%f4, 5, %r6, 7          # encoding: [0xb3,0xf1,0x57,0x46]
+#CHECK: cdgtra	%f15, 0, %r0, 0         # encoding: [0xb3,0xf1,0x00,0xf0]
+
+	cdgtra	%f0, 0, %r0, 0
+	cdgtra	%f0, 0, %r0, 15
+	cdgtra	%f0, 0, %r15, 0
+	cdgtra	%f0, 15, %r0, 0
+	cdgtra	%f4, 5, %r6, 7
+	cdgtra	%f15, 0, %r0, 0
+
 #CHECK: cdlfbr	%f0, 0, %r0, 0          # encoding: [0xb3,0x91,0x00,0x00]
 #CHECK: cdlfbr	%f0, 0, %r0, 15         # encoding: [0xb3,0x91,0x0f,0x00]
 #CHECK: cdlfbr	%f0, 0, %r15, 0         # encoding: [0xb3,0x91,0x00,0x0f]
@@ -215,6 +271,20 @@
 	cdlfbr	%f4, 5, %r6, 7
 	cdlfbr	%f15, 0, %r0, 0
 
+#CHECK: cdlftr	%f0, 0, %r0, 0          # encoding: [0xb9,0x53,0x00,0x00]
+#CHECK: cdlftr	%f0, 0, %r0, 15         # encoding: [0xb9,0x53,0x0f,0x00]
+#CHECK: cdlftr	%f0, 0, %r15, 0         # encoding: [0xb9,0x53,0x00,0x0f]
+#CHECK: cdlftr	%f0, 15, %r0, 0         # encoding: [0xb9,0x53,0xf0,0x00]
+#CHECK: cdlftr	%f4, 5, %r6, 7          # encoding: [0xb9,0x53,0x57,0x46]
+#CHECK: cdlftr	%f15, 0, %r0, 0         # encoding: [0xb9,0x53,0x00,0xf0]
+
+	cdlftr	%f0, 0, %r0, 0
+	cdlftr	%f0, 0, %r0, 15
+	cdlftr	%f0, 0, %r15, 0
+	cdlftr	%f0, 15, %r0, 0
+	cdlftr	%f4, 5, %r6, 7
+	cdlftr	%f15, 0, %r0, 0
+
 #CHECK: cdlgbr	%f0, 0, %r0, 0          # encoding: [0xb3,0xa1,0x00,0x00]
 #CHECK: cdlgbr	%f0, 0, %r0, 15         # encoding: [0xb3,0xa1,0x0f,0x00]
 #CHECK: cdlgbr	%f0, 0, %r15, 0         # encoding: [0xb3,0xa1,0x00,0x0f]
@@ -229,6 +299,20 @@
 	cdlgbr	%f4, 5, %r6, 7
 	cdlgbr	%f15, 0, %r0, 0
 
+#CHECK: cdlgtr	%f0, 0, %r0, 0          # encoding: [0xb9,0x52,0x00,0x00]
+#CHECK: cdlgtr	%f0, 0, %r0, 15         # encoding: [0xb9,0x52,0x0f,0x00]
+#CHECK: cdlgtr	%f0, 0, %r15, 0         # encoding: [0xb9,0x52,0x00,0x0f]
+#CHECK: cdlgtr	%f0, 15, %r0, 0         # encoding: [0xb9,0x52,0xf0,0x00]
+#CHECK: cdlgtr	%f4, 5, %r6, 7          # encoding: [0xb9,0x52,0x57,0x46]
+#CHECK: cdlgtr	%f15, 0, %r0, 0         # encoding: [0xb9,0x52,0x00,0xf0]
+
+	cdlgtr	%f0, 0, %r0, 0
+	cdlgtr	%f0, 0, %r0, 15
+	cdlgtr	%f0, 0, %r15, 0
+	cdlgtr	%f0, 15, %r0, 0
+	cdlgtr	%f4, 5, %r6, 7
+	cdlgtr	%f15, 0, %r0, 0
+
 #CHECK: cefbra	%f0, 0, %r0, 0          # encoding: [0xb3,0x94,0x00,0x00]
 #CHECK: cefbra	%f0, 0, %r0, 15         # encoding: [0xb3,0x94,0x0f,0x00]
 #CHECK: cefbra	%f0, 0, %r15, 0         # encoding: [0xb3,0x94,0x00,0x0f]
@@ -299,6 +383,20 @@
 	cfdbra	%r4, 5, %f6, 7
 	cfdbra	%r15, 0, %f0, 0
 
+#CHECK: cfdtr	%r0, 0, %f0, 0          # encoding: [0xb9,0x41,0x00,0x00]
+#CHECK: cfdtr	%r0, 0, %f0, 15         # encoding: [0xb9,0x41,0x0f,0x00]
+#CHECK: cfdtr	%r0, 0, %f15, 0         # encoding: [0xb9,0x41,0x00,0x0f]
+#CHECK: cfdtr	%r0, 15, %f0, 0         # encoding: [0xb9,0x41,0xf0,0x00]
+#CHECK: cfdtr	%r4, 5, %f6, 7          # encoding: [0xb9,0x41,0x57,0x46]
+#CHECK: cfdtr	%r15, 0, %f0, 0         # encoding: [0xb9,0x41,0x00,0xf0]
+
+	cfdtr	%r0, 0, %f0, 0
+	cfdtr	%r0, 0, %f0, 15
+	cfdtr	%r0, 0, %f15, 0
+	cfdtr	%r0, 15, %f0, 0
+	cfdtr	%r4, 5, %f6, 7
+	cfdtr	%r15, 0, %f0, 0
+
 #CHECK: cfebra	%r0, 0, %f0, 0          # encoding: [0xb3,0x98,0x00,0x00]
 #CHECK: cfebra	%r0, 0, %f0, 15         # encoding: [0xb3,0x98,0x0f,0x00]
 #CHECK: cfebra	%r0, 0, %f15, 0         # encoding: [0xb3,0x98,0x00,0x0f]
@@ -327,6 +425,20 @@
 	cfxbra	%r7, 5, %f8, 9
 	cfxbra	%r15, 0, %f0, 0
 
+#CHECK: cfxtr	%r0, 0, %f0, 0          # encoding: [0xb9,0x49,0x00,0x00]
+#CHECK: cfxtr	%r0, 0, %f0, 15         # encoding: [0xb9,0x49,0x0f,0x00]
+#CHECK: cfxtr	%r0, 0, %f13, 0         # encoding: [0xb9,0x49,0x00,0x0d]
+#CHECK: cfxtr	%r0, 15, %f0, 0         # encoding: [0xb9,0x49,0xf0,0x00]
+#CHECK: cfxtr	%r7, 5, %f8, 9          # encoding: [0xb9,0x49,0x59,0x78]
+#CHECK: cfxtr	%r15, 0, %f0, 0         # encoding: [0xb9,0x49,0x00,0xf0]
+
+	cfxtr	%r0, 0, %f0, 0
+	cfxtr	%r0, 0, %f0, 15
+	cfxtr	%r0, 0, %f13, 0
+	cfxtr	%r0, 15, %f0, 0
+	cfxtr	%r7, 5, %f8, 9
+	cfxtr	%r15, 0, %f0, 0
+
 #CHECK: cgdbra	%r0, 0, %f0, 0          # encoding: [0xb3,0xa9,0x00,0x00]
 #CHECK: cgdbra	%r0, 0, %f0, 15         # encoding: [0xb3,0xa9,0x0f,0x00]
 #CHECK: cgdbra	%r0, 0, %f15, 0         # encoding: [0xb3,0xa9,0x00,0x0f]
@@ -341,6 +453,20 @@
 	cgdbra	%r4, 5, %f6, 7
 	cgdbra	%r15, 0, %f0, 0
 
+#CHECK: cgdtra	%r0, 0, %f0, 0          # encoding: [0xb3,0xe1,0x00,0x00]
+#CHECK: cgdtra	%r0, 0, %f0, 15         # encoding: [0xb3,0xe1,0x0f,0x00]
+#CHECK: cgdtra	%r0, 0, %f15, 0         # encoding: [0xb3,0xe1,0x00,0x0f]
+#CHECK: cgdtra	%r0, 15, %f0, 0         # encoding: [0xb3,0xe1,0xf0,0x00]
+#CHECK: cgdtra	%r4, 5, %f6, 7          # encoding: [0xb3,0xe1,0x57,0x46]
+#CHECK: cgdtra	%r15, 0, %f0, 0         # encoding: [0xb3,0xe1,0x00,0xf0]
+
+	cgdtra	%r0, 0, %f0, 0
+	cgdtra	%r0, 0, %f0, 15
+	cgdtra	%r0, 0, %f15, 0
+	cgdtra	%r0, 15, %f0, 0
+	cgdtra	%r4, 5, %f6, 7
+	cgdtra	%r15, 0, %f0, 0
+
 #CHECK: cgebra	%r0, 0, %f0, 0          # encoding: [0xb3,0xa8,0x00,0x00]
 #CHECK: cgebra	%r0, 0, %f0, 15         # encoding: [0xb3,0xa8,0x0f,0x00]
 #CHECK: cgebra	%r0, 0, %f15, 0         # encoding: [0xb3,0xa8,0x00,0x0f]
@@ -369,6 +495,20 @@
 	cgxbra	%r7, 5, %f8, 9
 	cgxbra	%r15, 0, %f0, 0
 
+#CHECK: cgxtra	%r0, 0, %f0, 0          # encoding: [0xb3,0xe9,0x00,0x00]
+#CHECK: cgxtra	%r0, 0, %f0, 15         # encoding: [0xb3,0xe9,0x0f,0x00]
+#CHECK: cgxtra	%r0, 0, %f13, 0         # encoding: [0xb3,0xe9,0x00,0x0d]
+#CHECK: cgxtra	%r0, 15, %f0, 0         # encoding: [0xb3,0xe9,0xf0,0x00]
+#CHECK: cgxtra	%r7, 5, %f8, 9          # encoding: [0xb3,0xe9,0x59,0x78]
+#CHECK: cgxtra	%r15, 0, %f0, 0         # encoding: [0xb3,0xe9,0x00,0xf0]
+
+	cgxtra	%r0, 0, %f0, 0
+	cgxtra	%r0, 0, %f0, 15
+	cgxtra	%r0, 0, %f13, 0
+	cgxtra	%r0, 15, %f0, 0
+	cgxtra	%r7, 5, %f8, 9
+	cgxtra	%r15, 0, %f0, 0
+
 #CHECK: chf	%r0, -524288            # encoding: [0xe3,0x00,0x00,0x00,0x80,0xcd]
 #CHECK: chf	%r0, -1                 # encoding: [0xe3,0x00,0x0f,0xff,0xff,0xcd]
 #CHECK: chf	%r0, 0                  # encoding: [0xe3,0x00,0x00,0x00,0x00,0xcd]
@@ -419,6 +559,20 @@
 	clfdbr	%r4, 5, %f6, 7
 	clfdbr	%r15, 0, %f0, 0
 
+#CHECK: clfdtr	%r0, 0, %f0, 0          # encoding: [0xb9,0x43,0x00,0x00]
+#CHECK: clfdtr	%r0, 0, %f0, 15         # encoding: [0xb9,0x43,0x0f,0x00]
+#CHECK: clfdtr	%r0, 0, %f15, 0         # encoding: [0xb9,0x43,0x00,0x0f]
+#CHECK: clfdtr	%r0, 15, %f0, 0         # encoding: [0xb9,0x43,0xf0,0x00]
+#CHECK: clfdtr	%r4, 5, %f6, 7          # encoding: [0xb9,0x43,0x57,0x46]
+#CHECK: clfdtr	%r15, 0, %f0, 0         # encoding: [0xb9,0x43,0x00,0xf0]
+
+	clfdtr	%r0, 0, %f0, 0
+	clfdtr	%r0, 0, %f0, 15
+	clfdtr	%r0, 0, %f15, 0
+	clfdtr	%r0, 15, %f0, 0
+	clfdtr	%r4, 5, %f6, 7
+	clfdtr	%r15, 0, %f0, 0
+
 #CHECK: clfebr	%r0, 0, %f0, 0          # encoding: [0xb3,0x9c,0x00,0x00]
 #CHECK: clfebr	%r0, 0, %f0, 15         # encoding: [0xb3,0x9c,0x0f,0x00]
 #CHECK: clfebr	%r0, 0, %f15, 0         # encoding: [0xb3,0x9c,0x00,0x0f]
@@ -447,6 +601,20 @@
 	clfxbr	%r7, 5, %f8, 9
 	clfxbr	%r15, 0, %f0, 0
 
+#CHECK: clfxtr	%r0, 0, %f0, 0          # encoding: [0xb9,0x4b,0x00,0x00]
+#CHECK: clfxtr	%r0, 0, %f0, 15         # encoding: [0xb9,0x4b,0x0f,0x00]
+#CHECK: clfxtr	%r0, 0, %f13, 0         # encoding: [0xb9,0x4b,0x00,0x0d]
+#CHECK: clfxtr	%r0, 15, %f0, 0         # encoding: [0xb9,0x4b,0xf0,0x00]
+#CHECK: clfxtr	%r7, 5, %f8, 9          # encoding: [0xb9,0x4b,0x59,0x78]
+#CHECK: clfxtr	%r15, 0, %f0, 0         # encoding: [0xb9,0x4b,0x00,0xf0]
+
+	clfxtr	%r0, 0, %f0, 0
+	clfxtr	%r0, 0, %f0, 15
+	clfxtr	%r0, 0, %f13, 0
+	clfxtr	%r0, 15, %f0, 0
+	clfxtr	%r7, 5, %f8, 9
+	clfxtr	%r15, 0, %f0, 0
+
 #CHECK: clgdbr	%r0, 0, %f0, 0          # encoding: [0xb3,0xad,0x00,0x00]
 #CHECK: clgdbr	%r0, 0, %f0, 15         # encoding: [0xb3,0xad,0x0f,0x00]
 #CHECK: clgdbr	%r0, 0, %f15, 0         # encoding: [0xb3,0xad,0x00,0x0f]
@@ -461,6 +629,20 @@
 	clgdbr	%r4, 5, %f6, 7
 	clgdbr	%r15, 0, %f0, 0
 
+#CHECK: clgdtr	%r0, 0, %f0, 0          # encoding: [0xb9,0x42,0x00,0x00]
+#CHECK: clgdtr	%r0, 0, %f0, 15         # encoding: [0xb9,0x42,0x0f,0x00]
+#CHECK: clgdtr	%r0, 0, %f15, 0         # encoding: [0xb9,0x42,0x00,0x0f]
+#CHECK: clgdtr	%r0, 15, %f0, 0         # encoding: [0xb9,0x42,0xf0,0x00]
+#CHECK: clgdtr	%r4, 5, %f6, 7          # encoding: [0xb9,0x42,0x57,0x46]
+#CHECK: clgdtr	%r15, 0, %f0, 0         # encoding: [0xb9,0x42,0x00,0xf0]
+
+	clgdtr	%r0, 0, %f0, 0
+	clgdtr	%r0, 0, %f0, 15
+	clgdtr	%r0, 0, %f15, 0
+	clgdtr	%r0, 15, %f0, 0
+	clgdtr	%r4, 5, %f6, 7
+	clgdtr	%r15, 0, %f0, 0
+
 #CHECK: clgebr	%r0, 0, %f0, 0          # encoding: [0xb3,0xac,0x00,0x00]
 #CHECK: clgebr	%r0, 0, %f0, 15         # encoding: [0xb3,0xac,0x0f,0x00]
 #CHECK: clgebr	%r0, 0, %f15, 0         # encoding: [0xb3,0xac,0x00,0x0f]
@@ -489,6 +671,20 @@
 	clgxbr	%r7, 5, %f8, 9
 	clgxbr	%r15, 0, %f0, 0
 
+#CHECK: clgxtr	%r0, 0, %f0, 0          # encoding: [0xb9,0x4a,0x00,0x00]
+#CHECK: clgxtr	%r0, 0, %f0, 15         # encoding: [0xb9,0x4a,0x0f,0x00]
+#CHECK: clgxtr	%r0, 0, %f13, 0         # encoding: [0xb9,0x4a,0x00,0x0d]
+#CHECK: clgxtr	%r0, 15, %f0, 0         # encoding: [0xb9,0x4a,0xf0,0x00]
+#CHECK: clgxtr	%r7, 5, %f8, 9          # encoding: [0xb9,0x4a,0x59,0x78]
+#CHECK: clgxtr	%r15, 0, %f0, 0         # encoding: [0xb9,0x4a,0x00,0xf0]
+
+	clgxtr	%r0, 0, %f0, 0
+	clgxtr	%r0, 0, %f0, 15
+	clgxtr	%r0, 0, %f13, 0
+	clgxtr	%r0, 15, %f0, 0
+	clgxtr	%r7, 5, %f8, 9
+	clgxtr	%r15, 0, %f0, 0
+
 #CHECK: clhf	%r0, -524288            # encoding: [0xe3,0x00,0x00,0x00,0x80,0xcf]
 #CHECK: clhf	%r0, -1                 # encoding: [0xe3,0x00,0x0f,0xff,0xff,0xcf]
 #CHECK: clhf	%r0, 0                  # encoding: [0xe3,0x00,0x00,0x00,0x00,0xcf]
@@ -535,6 +731,20 @@
 	cxfbra	%f4, 5, %r9, 10
 	cxfbra	%f13, 0, %r0, 0
 
+#CHECK: cxftr	%f0, 0, %r0, 0          # encoding: [0xb9,0x59,0x00,0x00]
+#CHECK: cxftr	%f0, 0, %r0, 15         # encoding: [0xb9,0x59,0x0f,0x00]
+#CHECK: cxftr	%f0, 0, %r15, 0         # encoding: [0xb9,0x59,0x00,0x0f]
+#CHECK: cxftr	%f0, 15, %r0, 0         # encoding: [0xb9,0x59,0xf0,0x00]
+#CHECK: cxftr	%f4, 5, %r9, 10         # encoding: [0xb9,0x59,0x5a,0x49]
+#CHECK: cxftr	%f13, 0, %r0, 0         # encoding: [0xb9,0x59,0x00,0xd0]
+
+	cxftr	%f0, 0, %r0, 0
+	cxftr	%f0, 0, %r0, 15
+	cxftr	%f0, 0, %r15, 0
+	cxftr	%f0, 15, %r0, 0
+	cxftr	%f4, 5, %r9, 10
+	cxftr	%f13, 0, %r0, 0
+
 #CHECK: cxgbra	%f0, 0, %r0, 0          # encoding: [0xb3,0xa6,0x00,0x00]
 #CHECK: cxgbra	%f0, 0, %r0, 15         # encoding: [0xb3,0xa6,0x0f,0x00]
 #CHECK: cxgbra	%f0, 0, %r15, 0         # encoding: [0xb3,0xa6,0x00,0x0f]
@@ -549,6 +759,20 @@
 	cxgbra	%f4, 5, %r9, 10
 	cxgbra	%f13, 0, %r0, 0
 
+#CHECK: cxgtra	%f0, 0, %r0, 0          # encoding: [0xb3,0xf9,0x00,0x00]
+#CHECK: cxgtra	%f0, 0, %r0, 15         # encoding: [0xb3,0xf9,0x0f,0x00]
+#CHECK: cxgtra	%f0, 0, %r15, 0         # encoding: [0xb3,0xf9,0x00,0x0f]
+#CHECK: cxgtra	%f0, 15, %r0, 0         # encoding: [0xb3,0xf9,0xf0,0x00]
+#CHECK: cxgtra	%f4, 5, %r9, 10         # encoding: [0xb3,0xf9,0x5a,0x49]
+#CHECK: cxgtra	%f13, 0, %r0, 0         # encoding: [0xb3,0xf9,0x00,0xd0]
+
+	cxgtra	%f0, 0, %r0, 0
+	cxgtra	%f0, 0, %r0, 15
+	cxgtra	%f0, 0, %r15, 0
+	cxgtra	%f0, 15, %r0, 0
+	cxgtra	%f4, 5, %r9, 10
+	cxgtra	%f13, 0, %r0, 0
+
 #CHECK: cxlfbr	%f0, 0, %r0, 0          # encoding: [0xb3,0x92,0x00,0x00]
 #CHECK: cxlfbr	%f0, 0, %r0, 15         # encoding: [0xb3,0x92,0x0f,0x00]
 #CHECK: cxlfbr	%f0, 0, %r15, 0         # encoding: [0xb3,0x92,0x00,0x0f]
@@ -563,6 +787,20 @@
 	cxlfbr	%f4, 5, %r9, 10
 	cxlfbr	%f13, 0, %r0, 0
 
+#CHECK: cxlftr	%f0, 0, %r0, 0          # encoding: [0xb9,0x5b,0x00,0x00]
+#CHECK: cxlftr	%f0, 0, %r0, 15         # encoding: [0xb9,0x5b,0x0f,0x00]
+#CHECK: cxlftr	%f0, 0, %r15, 0         # encoding: [0xb9,0x5b,0x00,0x0f]
+#CHECK: cxlftr	%f0, 15, %r0, 0         # encoding: [0xb9,0x5b,0xf0,0x00]
+#CHECK: cxlftr	%f4, 5, %r9, 10         # encoding: [0xb9,0x5b,0x5a,0x49]
+#CHECK: cxlftr	%f13, 0, %r0, 0         # encoding: [0xb9,0x5b,0x00,0xd0]
+
+	cxlftr	%f0, 0, %r0, 0
+	cxlftr	%f0, 0, %r0, 15
+	cxlftr	%f0, 0, %r15, 0
+	cxlftr	%f0, 15, %r0, 0
+	cxlftr	%f4, 5, %r9, 10
+	cxlftr	%f13, 0, %r0, 0
+
 #CHECK: cxlgbr	%f0, 0, %r0, 0          # encoding: [0xb3,0xa2,0x00,0x00]
 #CHECK: cxlgbr	%f0, 0, %r0, 15         # encoding: [0xb3,0xa2,0x0f,0x00]
 #CHECK: cxlgbr	%f0, 0, %r15, 0         # encoding: [0xb3,0xa2,0x00,0x0f]
@@ -577,6 +815,48 @@
 	cxlgbr	%f4, 5, %r9, 10
 	cxlgbr	%f13, 0, %r0, 0
 
+#CHECK: cxlgtr	%f0, 0, %r0, 0          # encoding: [0xb9,0x5a,0x00,0x00]
+#CHECK: cxlgtr	%f0, 0, %r0, 15         # encoding: [0xb9,0x5a,0x0f,0x00]
+#CHECK: cxlgtr	%f0, 0, %r15, 0         # encoding: [0xb9,0x5a,0x00,0x0f]
+#CHECK: cxlgtr	%f0, 15, %r0, 0         # encoding: [0xb9,0x5a,0xf0,0x00]
+#CHECK: cxlgtr	%f4, 5, %r9, 10         # encoding: [0xb9,0x5a,0x5a,0x49]
+#CHECK: cxlgtr	%f13, 0, %r0, 0         # encoding: [0xb9,0x5a,0x00,0xd0]
+
+	cxlgtr	%f0, 0, %r0, 0
+	cxlgtr	%f0, 0, %r0, 15
+	cxlgtr	%f0, 0, %r15, 0
+	cxlgtr	%f0, 15, %r0, 0
+	cxlgtr	%f4, 5, %r9, 10
+	cxlgtr	%f13, 0, %r0, 0
+
+#CHECK: ddtra	%f0, %f0, %f0, 0        # encoding: [0xb3,0xd1,0x00,0x00]
+#CHECK: ddtra	%f0, %f0, %f0, 15       # encoding: [0xb3,0xd1,0x0f,0x00]
+#CHECK: ddtra	%f0, %f0, %f15, 0       # encoding: [0xb3,0xd1,0xf0,0x00]
+#CHECK: ddtra	%f0, %f15, %f0, 0       # encoding: [0xb3,0xd1,0x00,0x0f]
+#CHECK: ddtra	%f15, %f0, %f0, 0       # encoding: [0xb3,0xd1,0x00,0xf0]
+#CHECK: ddtra	%f7, %f8, %f9, 10       # encoding: [0xb3,0xd1,0x9a,0x78]
+
+	ddtra	%f0, %f0, %f0, 0
+	ddtra	%f0, %f0, %f0, 15
+	ddtra	%f0, %f0, %f15, 0
+	ddtra	%f0, %f15, %f0, 0
+	ddtra	%f15, %f0, %f0, 0
+	ddtra	%f7, %f8, %f9, 10
+
+#CHECK: dxtra	%f0, %f0, %f0, 0        # encoding: [0xb3,0xd9,0x00,0x00]
+#CHECK: dxtra	%f0, %f0, %f0, 15       # encoding: [0xb3,0xd9,0x0f,0x00]
+#CHECK: dxtra	%f0, %f0, %f13, 0       # encoding: [0xb3,0xd9,0xd0,0x00]
+#CHECK: dxtra	%f0, %f13, %f0, 0       # encoding: [0xb3,0xd9,0x00,0x0d]
+#CHECK: dxtra	%f13, %f0, %f0, 0       # encoding: [0xb3,0xd9,0x00,0xd0]
+#CHECK: dxtra	%f8, %f8, %f8, 8        # encoding: [0xb3,0xd9,0x88,0x88]
+
+	dxtra	%f0, %f0, %f0, 0
+	dxtra	%f0, %f0, %f0, 15
+	dxtra	%f0, %f0, %f13, 0
+	dxtra	%f0, %f13, %f0, 0
+	dxtra	%f13, %f0, %f0, 0
+	dxtra	%f8, %f8, %f8, 8
+
 #CHECK: fidbra	%f0, 0, %f0, 0          # encoding: [0xb3,0x5f,0x00,0x00]
 #CHECK: fidbra	%f0, 0, %f0, 15         # encoding: [0xb3,0x5f,0x0f,0x00]
 #CHECK: fidbra	%f0, 0, %f15, 0         # encoding: [0xb3,0x5f,0x00,0x0f]
@@ -1285,6 +1565,34 @@
 	lpdg	%r2, 0(%r1), 1(%r15)
 	lpdg	%r2, 0(%r1), 4095(%r15)
 
+#CHECK: mdtra	%f0, %f0, %f0, 0        # encoding: [0xb3,0xd0,0x00,0x00]
+#CHECK: mdtra	%f0, %f0, %f0, 15       # encoding: [0xb3,0xd0,0x0f,0x00]
+#CHECK: mdtra	%f0, %f0, %f15, 0       # encoding: [0xb3,0xd0,0xf0,0x00]
+#CHECK: mdtra	%f0, %f15, %f0, 0       # encoding: [0xb3,0xd0,0x00,0x0f]
+#CHECK: mdtra	%f15, %f0, %f0, 0       # encoding: [0xb3,0xd0,0x00,0xf0]
+#CHECK: mdtra	%f7, %f8, %f9, 10       # encoding: [0xb3,0xd0,0x9a,0x78]
+
+	mdtra	%f0, %f0, %f0, 0
+	mdtra	%f0, %f0, %f0, 15
+	mdtra	%f0, %f0, %f15, 0
+	mdtra	%f0, %f15, %f0, 0
+	mdtra	%f15, %f0, %f0, 0
+	mdtra	%f7, %f8, %f9, 10
+
+#CHECK: mxtra	%f0, %f0, %f0, 0        # encoding: [0xb3,0xd8,0x00,0x00]
+#CHECK: mxtra	%f0, %f0, %f0, 15       # encoding: [0xb3,0xd8,0x0f,0x00]
+#CHECK: mxtra	%f0, %f0, %f13, 0       # encoding: [0xb3,0xd8,0xd0,0x00]
+#CHECK: mxtra	%f0, %f13, %f0, 0       # encoding: [0xb3,0xd8,0x00,0x0d]
+#CHECK: mxtra	%f13, %f0, %f0, 0       # encoding: [0xb3,0xd8,0x00,0xd0]
+#CHECK: mxtra	%f8, %f8, %f8, 8        # encoding: [0xb3,0xd8,0x88,0x88]
+
+	mxtra	%f0, %f0, %f0, 0
+	mxtra	%f0, %f0, %f0, 15
+	mxtra	%f0, %f0, %f13, 0
+	mxtra	%f0, %f13, %f0, 0
+	mxtra	%f13, %f0, %f0, 0
+	mxtra	%f8, %f8, %f8, 8
+
 #CHECK: ngrk	%r0, %r0, %r0           # encoding: [0xb9,0xe4,0x00,0x00]
 #CHECK: ngrk	%r0, %r0, %r15          # encoding: [0xb9,0xe4,0xf0,0x00]
 #CHECK: ngrk	%r0, %r15, %r0          # encoding: [0xb9,0xe4,0x00,0x0f]
@@ -1379,6 +1687,20 @@
 	risblg	%r15,%r0,0,0,0
 	risblg	%r4,%r5,6,7,8
 
+#CHECK: sdtra	%f0, %f0, %f0, 0        # encoding: [0xb3,0xd3,0x00,0x00]
+#CHECK: sdtra	%f0, %f0, %f0, 15       # encoding: [0xb3,0xd3,0x0f,0x00]
+#CHECK: sdtra	%f0, %f0, %f15, 0       # encoding: [0xb3,0xd3,0xf0,0x00]
+#CHECK: sdtra	%f0, %f15, %f0, 0       # encoding: [0xb3,0xd3,0x00,0x0f]
+#CHECK: sdtra	%f15, %f0, %f0, 0       # encoding: [0xb3,0xd3,0x00,0xf0]
+#CHECK: sdtra	%f7, %f8, %f9, 10       # encoding: [0xb3,0xd3,0x9a,0x78]
+
+	sdtra	%f0, %f0, %f0, 0
+	sdtra	%f0, %f0, %f0, 15
+	sdtra	%f0, %f0, %f15, 0
+	sdtra	%f0, %f15, %f0, 0
+	sdtra	%f15, %f0, %f0, 0
+	sdtra	%f7, %f8, %f9, 10
+
 #CHECK: sgrk	%r0, %r0, %r0           # encoding: [0xb9,0xe9,0x00,0x00]
 #CHECK: sgrk	%r0, %r0, %r15          # encoding: [0xb9,0xe9,0xf0,0x00]
 #CHECK: sgrk	%r0, %r15, %r0          # encoding: [0xb9,0xe9,0x00,0x0f]
@@ -1731,6 +2053,20 @@
 	stocgnp  %r1,2(%r3)
 	stocgno  %r1,2(%r3)
 
+#CHECK: sxtra	%f0, %f0, %f0, 0        # encoding: [0xb3,0xdb,0x00,0x00]
+#CHECK: sxtra	%f0, %f0, %f0, 15       # encoding: [0xb3,0xdb,0x0f,0x00]
+#CHECK: sxtra	%f0, %f0, %f13, 0       # encoding: [0xb3,0xdb,0xd0,0x00]
+#CHECK: sxtra	%f0, %f13, %f0, 0       # encoding: [0xb3,0xdb,0x00,0x0d]
+#CHECK: sxtra	%f13, %f0, %f0, 0       # encoding: [0xb3,0xdb,0x00,0xd0]
+#CHECK: sxtra	%f8, %f8, %f8, 8        # encoding: [0xb3,0xdb,0x88,0x88]
+
+	sxtra	%f0, %f0, %f0, 0
+	sxtra	%f0, %f0, %f0, 15
+	sxtra	%f0, %f0, %f13, 0
+	sxtra	%f0, %f13, %f0, 0
+	sxtra	%f13, %f0, %f0, 0
+	sxtra	%f8, %f8, %f8, 8
+
 #CHECK: xgrk	%r0, %r0, %r0           # encoding: [0xb9,0xe7,0x00,0x00]
 #CHECK: xgrk	%r0, %r0, %r15          # encoding: [0xb9,0xe7,0xf0,0x00]
 #CHECK: xgrk	%r0, %r15, %r0          # encoding: [0xb9,0xe7,0x00,0x0f]

llvm/test/MC/SystemZ/insn-good-zEC12.s

@@ -114,6 +114,26 @@
 	bprp	8, branch, target@plt
 	bprp	9, branch@plt, target@plt
 
+#CHECK: cdzt	%f0, 0(1), 0                # encoding: [0xed,0x00,0x00,0x00,0x00,0xaa]
+#CHECK: cdzt	%f15, 0(1), 0               # encoding: [0xed,0x00,0x00,0x00,0xf0,0xaa]
+#CHECK: cdzt	%f0, 0(1), 15               # encoding: [0xed,0x00,0x00,0x00,0x0f,0xaa]
+#CHECK: cdzt	%f0, 0(1,%r1), 0            # encoding: [0xed,0x00,0x10,0x00,0x00,0xaa]
+#CHECK: cdzt	%f0, 0(1,%r15), 0           # encoding: [0xed,0x00,0xf0,0x00,0x00,0xaa]
+#CHECK: cdzt	%f0, 4095(1,%r1), 0         # encoding: [0xed,0x00,0x1f,0xff,0x00,0xaa]
+#CHECK: cdzt	%f0, 4095(1,%r15), 0        # encoding: [0xed,0x00,0xff,0xff,0x00,0xaa]
+#CHECK: cdzt	%f0, 0(256,%r1), 0          # encoding: [0xed,0xff,0x10,0x00,0x00,0xaa]
+#CHECK: cdzt	%f0, 0(256,%r15), 0         # encoding: [0xed,0xff,0xf0,0x00,0x00,0xaa]
+
+	cdzt	%f0, 0(1), 0
+	cdzt	%f15, 0(1), 0
+	cdzt	%f0, 0(1), 15
+	cdzt	%f0, 0(1,%r1), 0
+	cdzt	%f0, 0(1,%r15), 0
+	cdzt	%f0, 4095(1,%r1), 0
+	cdzt	%f0, 4095(1,%r15), 0
+	cdzt	%f0, 0(256,%r1), 0
+	cdzt	%f0, 0(256,%r15), 0
+
 #CHECK: clt	%r0, 12, -524288            # encoding: [0xeb,0x0c,0x00,0x00,0x80,0x23]
 #CHECK: clt	%r0, 12, -1                 # encoding: [0xeb,0x0c,0x0f,0xff,0xff,0x23]
 #CHECK: clt	%r0, 12, 0                  # encoding: [0xeb,0x0c,0x00,0x00,0x00,0x23]
@@ -178,6 +198,66 @@
 	clgtnl	%r0, 0(%r15)
 	clgtnh	%r0, 0(%r15)
 
+#CHECK: cxzt	%f0, 0(1), 0                # encoding: [0xed,0x00,0x00,0x00,0x00,0xab]
+#CHECK: cxzt	%f13, 0(1), 0               # encoding: [0xed,0x00,0x00,0x00,0xd0,0xab]
+#CHECK: cxzt	%f0, 0(1), 15               # encoding: [0xed,0x00,0x00,0x00,0x0f,0xab]
+#CHECK: cxzt	%f0, 0(1,%r1), 0            # encoding: [0xed,0x00,0x10,0x00,0x00,0xab]
+#CHECK: cxzt	%f0, 0(1,%r15), 0           # encoding: [0xed,0x00,0xf0,0x00,0x00,0xab]
+#CHECK: cxzt	%f0, 4095(1,%r1), 0         # encoding: [0xed,0x00,0x1f,0xff,0x00,0xab]
+#CHECK: cxzt	%f0, 4095(1,%r15), 0        # encoding: [0xed,0x00,0xff,0xff,0x00,0xab]
+#CHECK: cxzt	%f0, 0(256,%r1), 0          # encoding: [0xed,0xff,0x10,0x00,0x00,0xab]
+#CHECK: cxzt	%f0, 0(256,%r15), 0         # encoding: [0xed,0xff,0xf0,0x00,0x00,0xab]
+
+	cxzt	%f0, 0(1), 0
+	cxzt	%f13, 0(1), 0
+	cxzt	%f0, 0(1), 15
+	cxzt	%f0, 0(1,%r1), 0
+	cxzt	%f0, 0(1,%r15), 0
+	cxzt	%f0, 4095(1,%r1), 0
+	cxzt	%f0, 4095(1,%r15), 0
+	cxzt	%f0, 0(256,%r1), 0
+	cxzt	%f0, 0(256,%r15), 0
+
+#CHECK: czdt	%f0, 0(1), 0                # encoding: [0xed,0x00,0x00,0x00,0x00,0xa8]
+#CHECK: czdt	%f15, 0(1), 0               # encoding: [0xed,0x00,0x00,0x00,0xf0,0xa8]
+#CHECK: czdt	%f0, 0(1), 15               # encoding: [0xed,0x00,0x00,0x00,0x0f,0xa8]
+#CHECK: czdt	%f0, 0(1,%r1), 0            # encoding: [0xed,0x00,0x10,0x00,0x00,0xa8]
+#CHECK: czdt	%f0, 0(1,%r15), 0           # encoding: [0xed,0x00,0xf0,0x00,0x00,0xa8]
+#CHECK: czdt	%f0, 4095(1,%r1), 0         # encoding: [0xed,0x00,0x1f,0xff,0x00,0xa8]
+#CHECK: czdt	%f0, 4095(1,%r15), 0        # encoding: [0xed,0x00,0xff,0xff,0x00,0xa8]
+#CHECK: czdt	%f0, 0(256,%r1), 0          # encoding: [0xed,0xff,0x10,0x00,0x00,0xa8]
+#CHECK: czdt	%f0, 0(256,%r15), 0         # encoding: [0xed,0xff,0xf0,0x00,0x00,0xa8]
+
+	czdt	%f0, 0(1), 0
+	czdt	%f15, 0(1), 0
+	czdt	%f0, 0(1), 15
+	czdt	%f0, 0(1,%r1), 0
+	czdt	%f0, 0(1,%r15), 0
+	czdt	%f0, 4095(1,%r1), 0
+	czdt	%f0, 4095(1,%r15), 0
+	czdt	%f0, 0(256,%r1), 0
+	czdt	%f0, 0(256,%r15), 0
+
+#CHECK: czxt	%f0, 0(1), 0                # encoding: [0xed,0x00,0x00,0x00,0x00,0xa9]
+#CHECK: czxt	%f13, 0(1), 0               # encoding: [0xed,0x00,0x00,0x00,0xd0,0xa9]
+#CHECK: czxt	%f0, 0(1), 15               # encoding: [0xed,0x00,0x00,0x00,0x0f,0xa9]
+#CHECK: czxt	%f0, 0(1,%r1), 0            # encoding: [0xed,0x00,0x10,0x00,0x00,0xa9]
+#CHECK: czxt	%f0, 0(1,%r15), 0           # encoding: [0xed,0x00,0xf0,0x00,0x00,0xa9]
+#CHECK: czxt	%f0, 4095(1,%r1), 0         # encoding: [0xed,0x00,0x1f,0xff,0x00,0xa9]
+#CHECK: czxt	%f0, 4095(1,%r15), 0        # encoding: [0xed,0x00,0xff,0xff,0x00,0xa9]
+#CHECK: czxt	%f0, 0(256,%r1), 0          # encoding: [0xed,0xff,0x10,0x00,0x00,0xa9]
+#CHECK: czxt	%f0, 0(256,%r15), 0         # encoding: [0xed,0xff,0xf0,0x00,0x00,0xa9]
+
+	czxt	%f0, 0(1), 0
+	czxt	%f13, 0(1), 0
+	czxt	%f0, 0(1), 15
+	czxt	%f0, 0(1,%r1), 0
+	czxt	%f0, 0(1,%r15), 0
+	czxt	%f0, 4095(1,%r1), 0
+	czxt	%f0, 4095(1,%r15), 0
+	czxt	%f0, 0(256,%r1), 0
+	czxt	%f0, 0(256,%r15), 0
+
 #CHECK: etnd	%r0                     # encoding: [0xb2,0xec,0x00,0x00]
 #CHECK: etnd	%r15                    # encoding: [0xb2,0xec,0x00,0xf0]
 #CHECK: etnd	%r7                     # encoding: [0xb2,0xec,0x00,0x70]

llvm/test/MC/SystemZ/insn-good.s

@@ -69,6 +69,18 @@
 	adr	%f7, %f8
 	adr	%f15, %f0
 
+#CHECK: adtr	%f0, %f0, %f0           # encoding: [0xb3,0xd2,0x00,0x00]
+#CHECK: adtr	%f0, %f0, %f15          # encoding: [0xb3,0xd2,0xf0,0x00]
+#CHECK: adtr	%f0, %f15, %f0          # encoding: [0xb3,0xd2,0x00,0x0f]
+#CHECK: adtr	%f15, %f0, %f0          # encoding: [0xb3,0xd2,0x00,0xf0]
+#CHECK: adtr	%f7, %f8, %f9           # encoding: [0xb3,0xd2,0x90,0x78]
+
+	adtr	%f0, %f0, %f0
+	adtr	%f0, %f0, %f15
+	adtr	%f0, %f15, %f0
+	adtr	%f15, %f0, %f0
+	adtr	%f7, %f8, %f9
+
 #CHECK: ae	%f0, 0                  # encoding: [0x7a,0x00,0x00,0x00]
 #CHECK: ae	%f0, 4095               # encoding: [0x7a,0x00,0x0f,0xff]
 #CHECK: ae	%f0, 0(%r1)             # encoding: [0x7a,0x00,0x10,0x00]
@@ -695,6 +707,18 @@
 	axr	%f8, %f8
 	axr	%f13, %f0
 
+#CHECK: axtr	%f0, %f0, %f0           # encoding: [0xb3,0xda,0x00,0x00]
+#CHECK: axtr	%f0, %f0, %f13          # encoding: [0xb3,0xda,0xd0,0x00]
+#CHECK: axtr	%f0, %f13, %f0          # encoding: [0xb3,0xda,0x00,0x0d]
+#CHECK: axtr	%f13, %f0, %f0          # encoding: [0xb3,0xda,0x00,0xd0]
+#CHECK: axtr	%f8, %f8, %f8           # encoding: [0xb3,0xda,0x80,0x88]
+
+	axtr	%f0, %f0, %f0
+	axtr	%f0, %f0, %f13
+	axtr	%f0, %f13, %f0
+	axtr	%f13, %f0, %f0
+	axtr	%f8, %f8, %f8
+
 #CHECK: ay	%r0, -524288            # encoding: [0xe3,0x00,0x00,0x00,0x80,0x5a]
 #CHECK: ay	%r0, -1                 # encoding: [0xe3,0x00,0x0f,0xff,0xff,0x5a]
 #CHECK: ay	%r0, 0                  # encoding: [0xe3,0x00,0x00,0x00,0x00,0x5a]
@@ -2089,6 +2113,18 @@
 	cdgr	%f7, %r8
 	cdgr	%f15, %r15
 
+#CHECK: cdgtr	%f0, %r0                # encoding: [0xb3,0xf1,0x00,0x00]
+#CHECK: cdgtr	%f0, %r15               # encoding: [0xb3,0xf1,0x00,0x0f]
+#CHECK: cdgtr	%f15, %r0               # encoding: [0xb3,0xf1,0x00,0xf0]
+#CHECK: cdgtr	%f7, %r8                # encoding: [0xb3,0xf1,0x00,0x78]
+#CHECK: cdgtr	%f15, %r15              # encoding: [0xb3,0xf1,0x00,0xff]
+
+	cdgtr	%f0, %r0
+	cdgtr	%f0, %r15
+	cdgtr	%f15, %r0
+	cdgtr	%f7, %r8
+	cdgtr	%f15, %r15
+
 #CHECK: cdr	%f0, %f0                # encoding: [0x29,0x00]
 #CHECK: cdr	%f0, %f15               # encoding: [0x29,0x0f]
 #CHECK: cdr	%f7, %f8                # encoding: [0x29,0x78]
@@ -2141,6 +2177,18 @@
 	cdsg	%r0, %r14, 0
 	cdsg	%r14, %r0, 0
 
+#CHECK: cdstr	%f0, %r0                # encoding: [0xb3,0xf3,0x00,0x00]
+#CHECK: cdstr	%f0, %r15               # encoding: [0xb3,0xf3,0x00,0x0f]
+#CHECK: cdstr	%f15, %r0               # encoding: [0xb3,0xf3,0x00,0xf0]
+#CHECK: cdstr	%f7, %r8                # encoding: [0xb3,0xf3,0x00,0x78]
+#CHECK: cdstr	%f15, %r15              # encoding: [0xb3,0xf3,0x00,0xff]
+
+	cdstr	%f0, %r0
+	cdstr	%f0, %r15
+	cdstr	%f15, %r0
+	cdstr	%f7, %r8
+	cdstr	%f15, %r15
+
 #CHECK: cdsy	%r0, %r0, -524288       # encoding: [0xeb,0x00,0x00,0x00,0x80,0x31]
 #CHECK: cdsy	%r0, %r0, -1            # encoding: [0xeb,0x00,0x0f,0xff,0xff,0x31]
 #CHECK: cdsy	%r0, %r0, 0             # encoding: [0xeb,0x00,0x00,0x00,0x00,0x31]
@@ -2165,6 +2213,28 @@
 	cdsy	%r0, %r14, 0
 	cdsy	%r14, %r0, 0
 
+#CHECK: cdtr	%f0, %f0                # encoding: [0xb3,0xe4,0x00,0x00]
+#CHECK: cdtr	%f0, %f15               # encoding: [0xb3,0xe4,0x00,0x0f]
+#CHECK: cdtr	%f7, %f8                # encoding: [0xb3,0xe4,0x00,0x78]
+#CHECK: cdtr	%f15, %f0               # encoding: [0xb3,0xe4,0x00,0xf0]
+
+	cdtr	%f0, %f0
+	cdtr	%f0, %f15
+	cdtr	%f7, %f8
+	cdtr	%f15, %f0
+
+#CHECK: cdutr	%f0, %r0                # encoding: [0xb3,0xf2,0x00,0x00]
+#CHECK: cdutr	%f0, %r15               # encoding: [0xb3,0xf2,0x00,0x0f]
+#CHECK: cdutr	%f15, %r0               # encoding: [0xb3,0xf2,0x00,0xf0]
+#CHECK: cdutr	%f7, %r8                # encoding: [0xb3,0xf2,0x00,0x78]
+#CHECK: cdutr	%f15, %r15              # encoding: [0xb3,0xf2,0x00,0xff]
+
+	cdutr	%f0, %r0
+	cdutr	%f0, %r15
+	cdutr	%f15, %r0
+	cdutr	%f7, %r8
+	cdutr	%f15, %r15
+
 #CHECK: ce	%f0, 0                  # encoding: [0x79,0x00,0x00,0x00]
 #CHECK: ce	%f0, 4095               # encoding: [0x79,0x00,0x0f,0xff]
 #CHECK: ce	%f0, 0(%r1)             # encoding: [0x79,0x00,0x10,0x00]
@@ -2207,6 +2277,16 @@
 	cebr	%f7, %f8
 	cebr	%f15, %f0
 
+#CHECK: cedtr	%f0, %f0                # encoding: [0xb3,0xf4,0x00,0x00]
+#CHECK: cedtr	%f0, %f15               # encoding: [0xb3,0xf4,0x00,0x0f]
+#CHECK: cedtr	%f7, %f8                # encoding: [0xb3,0xf4,0x00,0x78]
+#CHECK: cedtr	%f15, %f0               # encoding: [0xb3,0xf4,0x00,0xf0]
+
+	cedtr	%f0, %f0
+	cedtr	%f0, %f15
+	cedtr	%f7, %f8
+	cedtr	%f15, %f0
+
 #CHECK: cefbr	%f0, %r0                # encoding: [0xb3,0x94,0x00,0x00]
 #CHECK: cefbr	%f0, %r15               # encoding: [0xb3,0x94,0x00,0x0f]
 #CHECK: cefbr	%f15, %r0               # encoding: [0xb3,0x94,0x00,0xf0]
@@ -2265,6 +2345,16 @@
 	cer	%f7, %f8
 	cer	%f15, %f0
 
+#CHECK: cextr	%f0, %f0                # encoding: [0xb3,0xfc,0x00,0x00]
+#CHECK: cextr	%f0, %f13               # encoding: [0xb3,0xfc,0x00,0x0d]
+#CHECK: cextr	%f8, %f8                # encoding: [0xb3,0xfc,0x00,0x88]
+#CHECK: cextr	%f13, %f0               # encoding: [0xb3,0xfc,0x00,0xd0]
+
+	cextr	%f0, %f0
+	cextr	%f0, %f13
+	cextr	%f8, %f8
+	cextr	%f13, %f0
+
 #CHECK: cfc	0                       # encoding: [0xb2,0x1a,0x00,0x00]
 #CHECK: cfc	0(%r1)                  # encoding: [0xb2,0x1a,0x10,0x00]
 #CHECK: cfc	0(%r15)                 # encoding: [0xb2,0x1a,0xf0,0x00]
@@ -2411,6 +2501,18 @@
 	cgdr	%r4, 5, %f6
 	cgdr	%r15, 0, %f0
 
+#CHECK: cgdtr	%r0, 0, %f0             # encoding: [0xb3,0xe1,0x00,0x00]
+#CHECK: cgdtr	%r0, 0, %f15            # encoding: [0xb3,0xe1,0x00,0x0f]
+#CHECK: cgdtr	%r0, 15, %f0            # encoding: [0xb3,0xe1,0xf0,0x00]
+#CHECK: cgdtr	%r4, 5, %f6             # encoding: [0xb3,0xe1,0x50,0x46]
+#CHECK: cgdtr	%r15, 0, %f0            # encoding: [0xb3,0xe1,0x00,0xf0]
+
+	cgdtr	%r0, 0, %f0
+	cgdtr	%r0, 0, %f15
+	cgdtr	%r0, 15, %f0
+	cgdtr	%r4, 5, %f6
+	cgdtr	%r15, 0, %f0
+
 #CHECK: cgebr	%r0, 0, %f0             # encoding: [0xb3,0xa8,0x00,0x00]
 #CHECK: cgebr	%r0, 0, %f15            # encoding: [0xb3,0xa8,0x00,0x0f]
 #CHECK: cgebr	%r0, 15, %f0            # encoding: [0xb3,0xa8,0xf0,0x00]
@@ -3349,6 +3451,18 @@
 	cgxr	%r4, 5, %f8
 	cgxr	%r15, 0, %f0
 
+#CHECK: cgxtr	%r0, 0, %f0             # encoding: [0xb3,0xe9,0x00,0x00]
+#CHECK: cgxtr	%r0, 0, %f13            # encoding: [0xb3,0xe9,0x00,0x0d]
+#CHECK: cgxtr	%r0, 15, %f0            # encoding: [0xb3,0xe9,0xf0,0x00]
+#CHECK: cgxtr	%r4, 5, %f8             # encoding: [0xb3,0xe9,0x50,0x48]
+#CHECK: cgxtr	%r15, 0, %f0            # encoding: [0xb3,0xe9,0x00,0xf0]
+
+	cgxtr	%r0, 0, %f0
+	cgxtr	%r0, 0, %f13
+	cgxtr	%r0, 15, %f0
+	cgxtr	%r4, 5, %f8
+	cgxtr	%r15, 0, %f0
+
 #CHECK: ch	%r0, 0                  # encoding: [0x49,0x00,0x00,0x00]
 #CHECK: ch	%r0, 4095               # encoding: [0x49,0x00,0x0f,0xff]
 #CHECK: ch	%r0, 0(%r1)             # encoding: [0x49,0x00,0x10,0x00]
@@ -6143,6 +6257,18 @@
 	cs	%r0, %r15, 0
 	cs	%r15, %r0, 0
 
+#CHECK: csdtr	%r0, %f0, 0             # encoding: [0xb3,0xe3,0x00,0x00]
+#CHECK: csdtr	%r0, %f15, 0            # encoding: [0xb3,0xe3,0x00,0x0f]
+#CHECK: csdtr	%r0, %f0, 15            # encoding: [0xb3,0xe3,0x0f,0x00]
+#CHECK: csdtr	%r4, %f5, 6             # encoding: [0xb3,0xe3,0x06,0x45]
+#CHECK: csdtr	%r15, %f0, 0            # encoding: [0xb3,0xe3,0x00,0xf0]
+
+	csdtr	%r0, %f0, 0
+	csdtr	%r0, %f15, 0
+	csdtr	%r0, %f0, 15
+	csdtr	%r4, %f5, 6
+	csdtr	%r15, %f0, 0
+
 #CHECK: csg	%r0, %r0, -524288       # encoding: [0xeb,0x00,0x00,0x00,0x80,0x30]
 #CHECK: csg	%r0, %r0, -1            # encoding: [0xeb,0x00,0x0f,0xff,0xff,0x30]
 #CHECK: csg	%r0, %r0, 0             # encoding: [0xeb,0x00,0x00,0x00,0x00,0x30]
@@ -6181,6 +6307,18 @@
         csst	0(%r1), 1(%r15), %r2
         csst	0(%r1), 4095(%r15), %r2
 
+#CHECK: csxtr	%r0, %f0, 0             # encoding: [0xb3,0xeb,0x00,0x00]
+#CHECK: csxtr	%r0, %f13, 0            # encoding: [0xb3,0xeb,0x00,0x0d]
+#CHECK: csxtr	%r0, %f0, 15            # encoding: [0xb3,0xeb,0x0f,0x00]
+#CHECK: csxtr	%r4, %f5, 6             # encoding: [0xb3,0xeb,0x06,0x45]
+#CHECK: csxtr	%r14, %f0, 0            # encoding: [0xb3,0xeb,0x00,0xe0]
+
+	csxtr	%r0, %f0, 0
+	csxtr	%r0, %f13, 0
+	csxtr	%r0, %f0, 15
+	csxtr	%r4, %f5, 6
+	csxtr	%r14, %f0, 0
+
 #CHECK: csy	%r0, %r0, -524288       # encoding: [0xeb,0x00,0x00,0x00,0x80,0x14]
 #CHECK: csy	%r0, %r0, -1            # encoding: [0xeb,0x00,0x0f,0xff,0xff,0x14]
 #CHECK: csy	%r0, %r0, 0             # encoding: [0xeb,0x00,0x00,0x00,0x00,0x14]
@@ -6281,6 +6419,18 @@
 	cu42	%r14, %r0
 	cu42	%r6, %r8
 
+#CHECK: cudtr	%r0, %f0                # encoding: [0xb3,0xe2,0x00,0x00]
+#CHECK: cudtr	%r0, %f15               # encoding: [0xb3,0xe2,0x00,0x0f]
+#CHECK: cudtr	%r15, %f0               # encoding: [0xb3,0xe2,0x00,0xf0]
+#CHECK: cudtr	%r7, %f8                # encoding: [0xb3,0xe2,0x00,0x78]
+#CHECK: cudtr	%r15, %f15              # encoding: [0xb3,0xe2,0x00,0xff]
+
+	cudtr	%r0, %f0
+	cudtr	%r0, %f15
+	cudtr	%r15, %f0
+	cudtr	%r7, %f8
+	cudtr	%r15, %f15
+
 #CHECK: cuse	%r0, %r8                # encoding: [0xb2,0x57,0x00,0x08]
 #CHECK: cuse	%r0, %r14               # encoding: [0xb2,0x57,0x00,0x0e]
 #CHECK: cuse	%r14, %r0               # encoding: [0xb2,0x57,0x00,0xe0]
@@ -6319,6 +6469,18 @@
 	cuutf	%r4, %r12, 0
 	cuutf	%r4, %r12, 15
 
+#CHECK: cuxtr	%r0, %f0                # encoding: [0xb3,0xea,0x00,0x00]
+#CHECK: cuxtr	%r0, %f13               # encoding: [0xb3,0xea,0x00,0x0d]
+#CHECK: cuxtr	%r14, %f0               # encoding: [0xb3,0xea,0x00,0xe0]
+#CHECK: cuxtr	%r6, %f8                # encoding: [0xb3,0xea,0x00,0x68]
+#CHECK: cuxtr	%r14, %f13              # encoding: [0xb3,0xea,0x00,0xed]
+
+	cuxtr	%r0, %f0
+	cuxtr	%r0, %f13
+	cuxtr	%r14, %f0
+	cuxtr	%r6, %f8
+	cuxtr	%r14, %f13
+
 #CHECK: cvb	%r0, 0                  # encoding: [0x4f,0x00,0x00,0x00]
 #CHECK: cvb	%r0, 4095               # encoding: [0x4f,0x00,0x0f,0xff]
 #CHECK: cvb	%r0, 0(%r1)             # encoding: [0x4f,0x00,0x10,0x00]
@@ -6497,6 +6659,18 @@
 	cxgr	%f8, %r7
 	cxgr	%f13, %r15
 
+#CHECK: cxgtr	%f0, %r0                # encoding: [0xb3,0xf9,0x00,0x00]
+#CHECK: cxgtr	%f0, %r15               # encoding: [0xb3,0xf9,0x00,0x0f]
+#CHECK: cxgtr	%f13, %r0               # encoding: [0xb3,0xf9,0x00,0xd0]
+#CHECK: cxgtr	%f8, %r7                # encoding: [0xb3,0xf9,0x00,0x87]
+#CHECK: cxgtr	%f13, %r15              # encoding: [0xb3,0xf9,0x00,0xdf]
+
+	cxgtr	%f0, %r0
+	cxgtr	%f0, %r15
+	cxgtr	%f13, %r0
+	cxgtr	%f8, %r7
+	cxgtr	%f13, %r15
+
 #CHECK: cxr	%f0, %f0                # encoding: [0xb3,0x69,0x00,0x00]
 #CHECK: cxr	%f0, %f13               # encoding: [0xb3,0x69,0x00,0x0d]
 #CHECK: cxr	%f8, %f8                # encoding: [0xb3,0x69,0x00,0x88]
@@ -6507,6 +6681,40 @@
 	cxr	%f8, %f8
 	cxr	%f13, %f0
 
+#CHECK: cxstr	%f0, %r0                # encoding: [0xb3,0xfb,0x00,0x00]
+#CHECK: cxstr	%f0, %r14               # encoding: [0xb3,0xfb,0x00,0x0e]
+#CHECK: cxstr	%f13, %r0               # encoding: [0xb3,0xfb,0x00,0xd0]
+#CHECK: cxstr	%f8, %r6                # encoding: [0xb3,0xfb,0x00,0x86]
+#CHECK: cxstr	%f13, %r14              # encoding: [0xb3,0xfb,0x00,0xde]
+
+	cxstr	%f0, %r0
+	cxstr	%f0, %r14
+	cxstr	%f13, %r0
+	cxstr	%f8, %r6
+	cxstr	%f13, %r14
+
+#CHECK: cxtr	%f0, %f0                # encoding: [0xb3,0xec,0x00,0x00]
+#CHECK: cxtr	%f0, %f13               # encoding: [0xb3,0xec,0x00,0x0d]
+#CHECK: cxtr	%f8, %f8                # encoding: [0xb3,0xec,0x00,0x88]
+#CHECK: cxtr	%f13, %f0               # encoding: [0xb3,0xec,0x00,0xd0]
+
+	cxtr	%f0, %f0
+	cxtr	%f0, %f13
+	cxtr	%f8, %f8
+	cxtr	%f13, %f0
+
+#CHECK: cxutr	%f0, %r0                # encoding: [0xb3,0xfa,0x00,0x00]
+#CHECK: cxutr	%f0, %r14               # encoding: [0xb3,0xfa,0x00,0x0e]
+#CHECK: cxutr	%f13, %r0               # encoding: [0xb3,0xfa,0x00,0xd0]
+#CHECK: cxutr	%f8, %r6                # encoding: [0xb3,0xfa,0x00,0x86]
+#CHECK: cxutr	%f13, %r14              # encoding: [0xb3,0xfa,0x00,0xde]
+
+	cxutr	%f0, %r0
+	cxutr	%f0, %r14
+	cxutr	%f13, %r0
+	cxutr	%f8, %r6
+	cxutr	%f13, %r14
+
 #CHECK: cy	%r0, -524288            # encoding: [0xe3,0x00,0x00,0x00,0x80,0x59]
 #CHECK: cy	%r0, -1                 # encoding: [0xe3,0x00,0x0f,0xff,0xff,0x59]
 #CHECK: cy	%r0, 0                  # encoding: [0xe3,0x00,0x00,0x00,0x00,0x59]
@@ -6597,6 +6805,18 @@
 	ddr	%f7, %f8
 	ddr	%f15, %f0
 
+#CHECK: ddtr	%f0, %f0, %f0           # encoding: [0xb3,0xd1,0x00,0x00]
+#CHECK: ddtr	%f0, %f0, %f15          # encoding: [0xb3,0xd1,0xf0,0x00]
+#CHECK: ddtr	%f0, %f15, %f0          # encoding: [0xb3,0xd1,0x00,0x0f]
+#CHECK: ddtr	%f15, %f0, %f0          # encoding: [0xb3,0xd1,0x00,0xf0]
+#CHECK: ddtr	%f7, %f8, %f9           # encoding: [0xb3,0xd1,0x90,0x78]
+
+	ddtr	%f0, %f0, %f0
+	ddtr	%f0, %f0, %f15
+	ddtr	%f0, %f15, %f0
+	ddtr	%f15, %f0, %f0
+	ddtr	%f7, %f8, %f9
+
 #CHECK: de	%f0, 0                  # encoding: [0x7d,0x00,0x00,0x00]
 #CHECK: de	%f0, 4095               # encoding: [0x7d,0x00,0x0f,0xff]
 #CHECK: de	%f0, 0(%r1)             # encoding: [0x7d,0x00,0x10,0x00]
@@ -6865,6 +7085,18 @@
 	dxr	%f8, %f8
 	dxr	%f13, %f0
 
+#CHECK: dxtr	%f0, %f0, %f0           # encoding: [0xb3,0xd9,0x00,0x00]
+#CHECK: dxtr	%f0, %f0, %f13          # encoding: [0xb3,0xd9,0xd0,0x00]
+#CHECK: dxtr	%f0, %f13, %f0          # encoding: [0xb3,0xd9,0x00,0x0d]
+#CHECK: dxtr	%f13, %f0, %f0          # encoding: [0xb3,0xd9,0x00,0xd0]
+#CHECK: dxtr	%f8, %f8, %f8           # encoding: [0xb3,0xd9,0x80,0x88]
+
+	dxtr	%f0, %f0, %f0
+	dxtr	%f0, %f0, %f13
+	dxtr	%f0, %f13, %f0
+	dxtr	%f13, %f0, %f0
+	dxtr	%f8, %f8, %f8
+
 #CHECK: ear	%r0, %a0                # encoding: [0xb2,0x4f,0x00,0x00]
 #CHECK: ear	%r0, %a15               # encoding: [0xb2,0x4f,0x00,0x0f]
 #CHECK: ear	%r15, %a0               # encoding: [0xb2,0x4f,0x00,0xf0]
@@ -6971,6 +7203,26 @@
 	edmk	0(256,%r1), 0
 	edmk	0(256,%r15), 0
 
+#CHECK: eedtr	%f0, %f9                # encoding: [0xb3,0xe5,0x00,0x09]
+#CHECK: eedtr	%f0, %f15               # encoding: [0xb3,0xe5,0x00,0x0f]
+#CHECK: eedtr	%f15, %f0               # encoding: [0xb3,0xe5,0x00,0xf0]
+#CHECK: eedtr	%f15, %f9               # encoding: [0xb3,0xe5,0x00,0xf9]
+
+	eedtr	%f0,%f9
+	eedtr	%f0,%f15
+	eedtr	%f15,%f0
+	eedtr	%f15,%f9
+
+#CHECK: eextr	%f0, %f8                # encoding: [0xb3,0xed,0x00,0x08]
+#CHECK: eextr	%f0, %f13               # encoding: [0xb3,0xed,0x00,0x0d]
+#CHECK: eextr	%f13, %f0               # encoding: [0xb3,0xed,0x00,0xd0]
+#CHECK: eextr	%f13, %f9               # encoding: [0xb3,0xed,0x00,0xd9]
+
+	eextr	%f0,%f8
+	eextr	%f0,%f13
+	eextr	%f13,%f0
+	eextr	%f13,%f9
+
 #CHECK: efpc	%r0                     # encoding: [0xb3,0x8c,0x00,0x00]
 #CHECK: efpc	%r1                     # encoding: [0xb3,0x8c,0x00,0x10]
 #CHECK: efpc	%r15                    # encoding: [0xb3,0x8c,0x00,0xf0]
@@ -6989,6 +7241,26 @@
 	epsw	%r15, %r0
 	epsw	%r15, %r8
 
+#CHECK: esdtr	%f0, %f9                # encoding: [0xb3,0xe7,0x00,0x09]
+#CHECK: esdtr	%f0, %f15               # encoding: [0xb3,0xe7,0x00,0x0f]
+#CHECK: esdtr	%f15, %f0               # encoding: [0xb3,0xe7,0x00,0xf0]
+#CHECK: esdtr	%f15, %f9               # encoding: [0xb3,0xe7,0x00,0xf9]
+
+	esdtr	%f0,%f9
+	esdtr	%f0,%f15
+	esdtr	%f15,%f0
+	esdtr	%f15,%f9
+
+#CHECK: esxtr	%f0, %f8                # encoding: [0xb3,0xef,0x00,0x08]
+#CHECK: esxtr	%f0, %f13               # encoding: [0xb3,0xef,0x00,0x0d]
+#CHECK: esxtr	%f13, %f0               # encoding: [0xb3,0xef,0x00,0xd0]
+#CHECK: esxtr	%f13, %f9               # encoding: [0xb3,0xef,0x00,0xd9]
+
+	esxtr	%f0,%f8
+	esxtr	%f0,%f13
+	esxtr	%f13,%f0
+	esxtr	%f13,%f9
+
 #CHECK: ex	%r0, 0                  # encoding: [0x44,0x00,0x00,0x00]
 #CHECK: ex	%r0, 4095               # encoding: [0x44,0x00,0x0f,0xff]
 #CHECK: ex	%r0, 0(%r1)             # encoding: [0x44,0x00,0x10,0x00]
@@ -7064,6 +7336,20 @@
 	fidr	%f4, %f6
 	fidr	%f15, %f0
 
+#CHECK: fidtr	%f0, 0, %f0, 0          # encoding: [0xb3,0xd7,0x00,0x00]
+#CHECK: fidtr	%f0, 0, %f0, 15         # encoding: [0xb3,0xd7,0x0f,0x00]
+#CHECK: fidtr	%f0, 0, %f15, 0         # encoding: [0xb3,0xd7,0x00,0x0f]
+#CHECK: fidtr	%f0, 15, %f0, 0         # encoding: [0xb3,0xd7,0xf0,0x00]
+#CHECK: fidtr	%f4, 5, %f6, 7          # encoding: [0xb3,0xd7,0x57,0x46]
+#CHECK: fidtr	%f15, 0, %f0, 0         # encoding: [0xb3,0xd7,0x00,0xf0]
+
+	fidtr	%f0, 0, %f0, 0
+	fidtr	%f0, 0, %f0, 15
+	fidtr	%f0, 0, %f15, 0
+	fidtr	%f0, 15, %f0, 0
+	fidtr	%f4, 5, %f6, 7
+	fidtr	%f15, 0, %f0, 0
+
 #CHECK: fiebr	%f0, 0, %f0             # encoding: [0xb3,0x57,0x00,0x00]
 #CHECK: fiebr	%f0, 0, %f15            # encoding: [0xb3,0x57,0x00,0x0f]
 #CHECK: fiebr	%f0, 15, %f0            # encoding: [0xb3,0x57,0xf0,0x00]
@@ -7108,6 +7394,20 @@
 	fixr	%f4, %f8
 	fixr	%f13, %f0
 
+#CHECK: fixtr	%f0, 0, %f0, 0          # encoding: [0xb3,0xdf,0x00,0x00]
+#CHECK: fixtr	%f0, 0, %f0, 15         # encoding: [0xb3,0xdf,0x0f,0x00]
+#CHECK: fixtr	%f0, 0, %f13, 0         # encoding: [0xb3,0xdf,0x00,0x0d]
+#CHECK: fixtr	%f0, 15, %f0, 0         # encoding: [0xb3,0xdf,0xf0,0x00]
+#CHECK: fixtr	%f4, 5, %f8, 9          # encoding: [0xb3,0xdf,0x59,0x48]
+#CHECK: fixtr	%f13, 0, %f0, 0         # encoding: [0xb3,0xdf,0x00,0xd0]
+
+	fixtr	%f0, 0, %f0, 0
+	fixtr	%f0, 0, %f0, 15
+	fixtr	%f0, 0, %f13, 0
+	fixtr	%f0, 15, %f0, 0
+	fixtr	%f4, 5, %f8, 9
+	fixtr	%f13, 0, %f0, 0
+
 #CHECK: flogr	%r0, %r0                # encoding: [0xb9,0x83,0x00,0x00]
 #CHECK: flogr	%r0, %r15               # encoding: [0xb9,0x83,0x00,0x0f]
 #CHECK: flogr	%r10, %r9               # encoding: [0xb9,0x83,0x00,0xa9]
@@ -7236,6 +7536,34 @@
 	icy	%r0, 524287(%r15,%r1)
 	icy	%r15, 0
 
+#CHECK: iedtr	%f0, %f0, %f0           # encoding: [0xb3,0xf6,0x00,0x00]
+#CHECK: iedtr	%f0, %f0, %f15          # encoding: [0xb3,0xf6,0x00,0x0f]
+#CHECK: iedtr	%f0, %f15, %f0          # encoding: [0xb3,0xf6,0xf0,0x00]
+#CHECK: iedtr	%f15, %f0, %f0          # encoding: [0xb3,0xf6,0x00,0xf0]
+#CHECK: iedtr	%f1, %f2, %f3           # encoding: [0xb3,0xf6,0x20,0x13]
+#CHECK: iedtr	%f15, %f15, %f15        # encoding: [0xb3,0xf6,0xf0,0xff]
+
+	iedtr	%f0, %f0, %f0
+	iedtr	%f0, %f0, %f15
+	iedtr	%f0, %f15, %f0
+	iedtr	%f15, %f0, %f0
+	iedtr	%f1, %f2, %f3
+	iedtr	%f15, %f15, %f15
+
+#CHECK: iextr	%f0, %f0, %f0           # encoding: [0xb3,0xfe,0x00,0x00]
+#CHECK: iextr	%f0, %f0, %f13          # encoding: [0xb3,0xfe,0x00,0x0d]
+#CHECK: iextr	%f0, %f13, %f0          # encoding: [0xb3,0xfe,0xd0,0x00]
+#CHECK: iextr	%f13, %f0, %f0          # encoding: [0xb3,0xfe,0x00,0xd0]
+#CHECK: iextr	%f1, %f8, %f4           # encoding: [0xb3,0xfe,0x80,0x14]
+#CHECK: iextr	%f13, %f13, %f13        # encoding: [0xb3,0xfe,0xd0,0xdd]
+
+	iextr	%f0, %f0, %f0
+	iextr	%f0, %f0, %f13
+	iextr	%f0, %f13, %f0
+	iextr	%f13, %f0, %f0
+	iextr	%f1, %f8, %f4
+	iextr	%f13, %f13, %f13
+
 #CHECK: iihf	%r0, 0                  # encoding: [0xc0,0x08,0x00,0x00,0x00,0x00]
 #CHECK: iihf	%r0, 4294967295         # encoding: [0xc0,0x08,0xff,0xff,0xff,0xff]
 #CHECK: iihf	%r15, 0                 # encoding: [0xc0,0xf8,0x00,0x00,0x00,0x00]
@@ -7326,6 +7654,16 @@
 	kdbr	%f7, %f8
 	kdbr	%f15, %f0
 
+#CHECK: kdtr	%f0, %f0                # encoding: [0xb3,0xe0,0x00,0x00]
+#CHECK: kdtr	%f0, %f15               # encoding: [0xb3,0xe0,0x00,0x0f]
+#CHECK: kdtr	%f7, %f8                # encoding: [0xb3,0xe0,0x00,0x78]
+#CHECK: kdtr	%f15, %f0               # encoding: [0xb3,0xe0,0x00,0xf0]
+
+	kdtr	%f0, %f0
+	kdtr	%f0, %f15
+	kdtr	%f7, %f8
+	kdtr	%f15, %f0
+
 #CHECK: keb	%f0, 0                  # encoding: [0xed,0x00,0x00,0x00,0x00,0x08]
 #CHECK: keb	%f0, 4095               # encoding: [0xed,0x00,0x0f,0xff,0x00,0x08]
 #CHECK: keb	%f0, 0(%r1)             # encoding: [0xed,0x00,0x10,0x00,0x00,0x08]
@@ -7412,6 +7750,16 @@
 	kxbr	%f8, %f8
 	kxbr	%f13, %f0
 
+#CHECK: kxtr	%f0, %f0                # encoding: [0xb3,0xe8,0x00,0x00]
+#CHECK: kxtr	%f0, %f13               # encoding: [0xb3,0xe8,0x00,0x0d]
+#CHECK: kxtr	%f8, %f8                # encoding: [0xb3,0xe8,0x00,0x88]
+#CHECK: kxtr	%f13, %f0               # encoding: [0xb3,0xe8,0x00,0xd0]
+
+	kxtr	%f0, %f0
+	kxtr	%f0, %f13
+	kxtr	%f8, %f8
+	kxtr	%f13, %f0
+
 #CHECK: l	%r0, 0                  # encoding: [0x58,0x00,0x00,0x00]
 #CHECK: l	%r0, 4095               # encoding: [0x58,0x00,0x0f,0xff]
 #CHECK: l	%r0, 0(%r1)             # encoding: [0x58,0x00,0x10,0x00]
@@ -7775,6 +8123,16 @@
 	lder	%f7, %f8
 	lder	%f15, %f0
 
+#CHECK: ldetr	%f0, %f0, 15            # encoding: [0xb3,0xd4,0x0f,0x00]
+#CHECK: ldetr	%f0, %f15, 0            # encoding: [0xb3,0xd4,0x00,0x0f]
+#CHECK: ldetr	%f7, %f8, 9             # encoding: [0xb3,0xd4,0x09,0x78]
+#CHECK: ldetr	%f15, %f0, 0            # encoding: [0xb3,0xd4,0x00,0xf0]
+
+	ldetr	%f0, %f0, 15
+	ldetr	%f0, %f15, 0
+	ldetr	%f7, %f8, 9
+	ldetr	%f15, %f0, 0
+
 #CHECK: ldgr	%f0, %r0                # encoding: [0xb3,0xc1,0x00,0x00]
 #CHECK: ldgr	%f0, %r15               # encoding: [0xb3,0xc1,0x00,0x0f]
 #CHECK: ldgr	%f15, %r0               # encoding: [0xb3,0xc1,0x00,0xf0]
@@ -7821,6 +8179,20 @@
 	ldxr	%f15, %f0
 	ldxr	%f15, %f13
 
+#CHECK: ldxtr	%f0, 0, %f0, 0          # encoding: [0xb3,0xdd,0x00,0x00]
+#CHECK: ldxtr	%f0, 0, %f0, 15         # encoding: [0xb3,0xdd,0x0f,0x00]
+#CHECK: ldxtr	%f0, 0, %f13, 0         # encoding: [0xb3,0xdd,0x00,0x0d]
+#CHECK: ldxtr	%f0, 15, %f0, 0         # encoding: [0xb3,0xdd,0xf0,0x00]
+#CHECK: ldxtr	%f4, 5, %f8, 9          # encoding: [0xb3,0xdd,0x59,0x48]
+#CHECK: ldxtr	%f13, 0, %f0, 0         # encoding: [0xb3,0xdd,0x00,0xd0]
+
+	ldxtr	%f0, 0, %f0, 0
+	ldxtr	%f0, 0, %f0, 15
+	ldxtr	%f0, 0, %f13, 0
+	ldxtr	%f0, 15, %f0, 0
+	ldxtr	%f4, 5, %f8, 9
+	ldxtr	%f13, 0, %f0, 0
+
 #CHECK: ldy	%f0, -524288            # encoding: [0xed,0x00,0x00,0x00,0x80,0x65]
 #CHECK: ldy	%f0, -1                 # encoding: [0xed,0x00,0x0f,0xff,0xff,0x65]
 #CHECK: ldy	%f0, 0                  # encoding: [0xed,0x00,0x00,0x00,0x00,0x65]
@@ -7883,6 +8255,20 @@
 	ledr	%f15, %f0
 	ledr	%f15, %f15
 
+#CHECK: ledtr	%f0, 0, %f0, 0          # encoding: [0xb3,0xd5,0x00,0x00]
+#CHECK: ledtr	%f0, 0, %f0, 15         # encoding: [0xb3,0xd5,0x0f,0x00]
+#CHECK: ledtr	%f0, 0, %f15, 0         # encoding: [0xb3,0xd5,0x00,0x0f]
+#CHECK: ledtr	%f0, 15, %f0, 0         # encoding: [0xb3,0xd5,0xf0,0x00]
+#CHECK: ledtr	%f4, 5, %f6, 7          # encoding: [0xb3,0xd5,0x57,0x46]
+#CHECK: ledtr	%f15, 0, %f0, 0         # encoding: [0xb3,0xd5,0x00,0xf0]
+
+	ledtr	%f0, 0, %f0, 0
+	ledtr	%f0, 0, %f0, 15
+	ledtr	%f0, 0, %f15, 0
+	ledtr	%f0, 15, %f0, 0
+	ledtr	%f4, 5, %f6, 7
+	ledtr	%f15, 0, %f0, 0
+
 #CHECK: ler	%f0, %f9                # encoding: [0x38,0x09]
 #CHECK: ler	%f0, %f15               # encoding: [0x38,0x0f]
 #CHECK: ler	%f15, %f0               # encoding: [0x38,0xf0]
@@ -9220,6 +9606,16 @@
 	ltdr	%f15,%f0
 	ltdr	%f15,%f9
 
+#CHECK: ltdtr	%f0, %f9                # encoding: [0xb3,0xd6,0x00,0x09]
+#CHECK: ltdtr	%f0, %f15               # encoding: [0xb3,0xd6,0x00,0x0f]
+#CHECK: ltdtr	%f15, %f0               # encoding: [0xb3,0xd6,0x00,0xf0]
+#CHECK: ltdtr	%f15, %f9               # encoding: [0xb3,0xd6,0x00,0xf9]
+
+	ltdtr	%f0,%f9
+	ltdtr	%f0,%f15
+	ltdtr	%f15,%f0
+	ltdtr	%f15,%f9
+
 #CHECK: ltebr	%f0, %f9                # encoding: [0xb3,0x02,0x00,0x09]
 #CHECK: ltebr	%f0, %f15               # encoding: [0xb3,0x02,0x00,0x0f]
 #CHECK: ltebr	%f15, %f0               # encoding: [0xb3,0x02,0x00,0xf0]
@@ -9334,6 +9730,16 @@
 	ltxr	%f13,%f0
 	ltxr	%f13,%f9
 
+#CHECK: ltxtr	%f0, %f9                # encoding: [0xb3,0xde,0x00,0x09]
+#CHECK: ltxtr	%f0, %f13               # encoding: [0xb3,0xde,0x00,0x0d]
+#CHECK: ltxtr	%f13, %f0               # encoding: [0xb3,0xde,0x00,0xd0]
+#CHECK: ltxtr	%f13, %f9               # encoding: [0xb3,0xde,0x00,0xd9]
+
+	ltxtr	%f0,%f9
+	ltxtr	%f0,%f13
+	ltxtr	%f13,%f0
+	ltxtr	%f13,%f9
+
 #CHECK: lxd	%f0, 4095               # encoding: [0xed,0x00,0x0f,0xff,0x00,0x25]
 #CHECK: lxd	%f0, 0(%r1)             # encoding: [0xed,0x00,0x10,0x00,0x00,0x25]
 #CHECK: lxd	%f0, 0(%r15)            # encoding: [0xed,0x00,0xf0,0x00,0x00,0x25]
@@ -9384,6 +9790,16 @@
 	lxdr	%f13,%f0
 	lxdr	%f13,%f15
 
+#CHECK: lxdtr	%f0, %f0, 15            # encoding: [0xb3,0xdc,0x0f,0x00]
+#CHECK: lxdtr	%f0, %f15, 0            # encoding: [0xb3,0xdc,0x00,0x0f]
+#CHECK: lxdtr	%f5, %f8, 9             # encoding: [0xb3,0xdc,0x09,0x58]
+#CHECK: lxdtr	%f13, %f0, 0            # encoding: [0xb3,0xdc,0x00,0xd0]
+
+	lxdtr	%f0, %f0, 15
+	lxdtr	%f0, %f15, 0
+	lxdtr	%f5, %f8, 9
+	lxdtr	%f13, %f0, 0
+
 #CHECK: lxe	%f0, 4095               # encoding: [0xed,0x00,0x0f,0xff,0x00,0x26]
 #CHECK: lxe	%f0, 0(%r1)             # encoding: [0xed,0x00,0x10,0x00,0x00,0x26]
 #CHECK: lxe	%f0, 0(%r15)            # encoding: [0xed,0x00,0xf0,0x00,0x00,0x26]
@@ -9864,6 +10280,18 @@
 	mdr	%f7, %f8
 	mdr	%f15, %f0
 
+#CHECK: mdtr	%f0, %f0, %f0           # encoding: [0xb3,0xd0,0x00,0x00]
+#CHECK: mdtr	%f0, %f0, %f15          # encoding: [0xb3,0xd0,0xf0,0x00]
+#CHECK: mdtr	%f0, %f15, %f0          # encoding: [0xb3,0xd0,0x00,0x0f]
+#CHECK: mdtr	%f15, %f0, %f0          # encoding: [0xb3,0xd0,0x00,0xf0]
+#CHECK: mdtr	%f7, %f8, %f9           # encoding: [0xb3,0xd0,0x90,0x78]
+
+	mdtr	%f0, %f0, %f0
+	mdtr	%f0, %f0, %f15
+	mdtr	%f0, %f15, %f0
+	mdtr	%f15, %f0, %f0
+	mdtr	%f7, %f8, %f9
+
 #CHECK: me	%f0, 0                  # encoding: [0x7c,0x00,0x00,0x00]
 #CHECK: me	%f0, 4095               # encoding: [0x7c,0x00,0x0f,0xff]
 #CHECK: me	%f0, 0(%r1)             # encoding: [0x7c,0x00,0x10,0x00]
@@ -10812,6 +11240,18 @@
 	mxr	%f8, %f5
 	mxr	%f13, %f13
 
+#CHECK: mxtr	%f0, %f0, %f0           # encoding: [0xb3,0xd8,0x00,0x00]
+#CHECK: mxtr	%f0, %f0, %f13          # encoding: [0xb3,0xd8,0xd0,0x00]
+#CHECK: mxtr	%f0, %f13, %f0          # encoding: [0xb3,0xd8,0x00,0x0d]
+#CHECK: mxtr	%f13, %f0, %f0          # encoding: [0xb3,0xd8,0x00,0xd0]
+#CHECK: mxtr	%f8, %f8, %f8           # encoding: [0xb3,0xd8,0x80,0x88]
+
+	mxtr	%f0, %f0, %f0
+	mxtr	%f0, %f0, %f13
+	mxtr	%f0, %f13, %f0
+	mxtr	%f13, %f0, %f0
+	mxtr	%f8, %f8, %f8
+
 #CHECK: my	%f0, %f0, 0             # encoding: [0xed,0x00,0x00,0x00,0x00,0x3b]
 #CHECK: my	%f0, %f0, 4095          # encoding: [0xed,0x00,0x0f,0xff,0x00,0x3b]
 #CHECK: my	%f0, %f0, 0(%r1)        # encoding: [0xed,0x00,0x10,0x00,0x00,0x3b]
@@ -11409,6 +11849,9 @@
 	pfdrl	7, frob@PLT
 	pfdrl	8, frob@PLT
 
+#CHECK: pfpo                            # encoding: [0x01,0x0a]
+        pfpo
+
 #CHECK: pka	0, 0(1)                 # encoding: [0xe9,0x00,0x00,0x00,0x00,0x00]
 #CHECK: pka	0, 0(1,%r1)             # encoding: [0xe9,0x00,0x00,0x00,0x10,0x00]
 #CHECK: pka	0, 0(1,%r15)            # encoding: [0xe9,0x00,0x00,0x00,0xf0,0x00]
@@ -11478,6 +11921,34 @@
 #CHECK: pr                              # encoding: [0x01,0x01]
         pr
 
+#CHECK: qadtr	%f0, %f0, %f0, 0        # encoding: [0xb3,0xf5,0x00,0x00]
+#CHECK: qadtr	%f0, %f0, %f0, 15       # encoding: [0xb3,0xf5,0x0f,0x00]
+#CHECK: qadtr	%f0, %f0, %f15, 0       # encoding: [0xb3,0xf5,0x00,0x0f]
+#CHECK: qadtr	%f0, %f15, %f0, 0       # encoding: [0xb3,0xf5,0xf0,0x00]
+#CHECK: qadtr	%f4, %f5, %f6, 7        # encoding: [0xb3,0xf5,0x57,0x46]
+#CHECK: qadtr	%f15, %f0, %f0, 0       # encoding: [0xb3,0xf5,0x00,0xf0]
+
+	qadtr	%f0, %f0, %f0, 0
+	qadtr	%f0, %f0, %f0, 15
+	qadtr	%f0, %f0, %f15, 0
+	qadtr	%f0, %f15, %f0, 0
+	qadtr	%f4, %f5, %f6, 7
+	qadtr	%f15, %f0, %f0, 0
+
+#CHECK: qaxtr	%f0, %f0, %f0, 0        # encoding: [0xb3,0xfd,0x00,0x00]
+#CHECK: qaxtr	%f0, %f0, %f0, 15       # encoding: [0xb3,0xfd,0x0f,0x00]
+#CHECK: qaxtr	%f0, %f0, %f13, 0       # encoding: [0xb3,0xfd,0x00,0x0d]
+#CHECK: qaxtr	%f0, %f13, %f0, 0       # encoding: [0xb3,0xfd,0xd0,0x00]
+#CHECK: qaxtr	%f8, %f8, %f8, 8        # encoding: [0xb3,0xfd,0x88,0x88]
+#CHECK: qaxtr	%f13, %f0, %f0, 0       # encoding: [0xb3,0xfd,0x00,0xd0]
+
+	qaxtr	%f0, %f0, %f0, 0
+	qaxtr	%f0, %f0, %f0, 15
+	qaxtr	%f0, %f0, %f13, 0
+	qaxtr	%f0, %f13, %f0, 0
+	qaxtr	%f8, %f8, %f8, 8
+	qaxtr	%f13, %f0, %f0, 0
+
 #CHECK: risbg	%r0, %r0, 0, 0, 0       # encoding: [0xec,0x00,0x00,0x00,0x00,0x55]
 #CHECK: risbg	%r0, %r0, 0, 0, 63      # encoding: [0xec,0x00,0x00,0x00,0x3f,0x55]
 #CHECK: risbg	%r0, %r0, 0, 255, 0     # encoding: [0xec,0x00,0x00,0xff,0x00,0x55]
@@ -11578,6 +12049,34 @@
 	rosbg	%r15,%r0,0,0,0
 	rosbg	%r4,%r5,6,7,8
 
+#CHECK: rrdtr	%f0, %f0, %f0, 0        # encoding: [0xb3,0xf7,0x00,0x00]
+#CHECK: rrdtr	%f0, %f0, %f0, 15       # encoding: [0xb3,0xf7,0x0f,0x00]
+#CHECK: rrdtr	%f0, %f0, %f15, 0       # encoding: [0xb3,0xf7,0x00,0x0f]
+#CHECK: rrdtr	%f0, %f15, %f0, 0       # encoding: [0xb3,0xf7,0xf0,0x00]
+#CHECK: rrdtr	%f4, %f5, %f6, 7        # encoding: [0xb3,0xf7,0x57,0x46]
+#CHECK: rrdtr	%f15, %f0, %f0, 0       # encoding: [0xb3,0xf7,0x00,0xf0]
+
+	rrdtr	%f0, %f0, %f0, 0
+	rrdtr	%f0, %f0, %f0, 15
+	rrdtr	%f0, %f0, %f15, 0
+	rrdtr	%f0, %f15, %f0, 0
+	rrdtr	%f4, %f5, %f6, 7
+	rrdtr	%f15, %f0, %f0, 0
+
+#CHECK: rrxtr	%f0, %f0, %f0, 0        # encoding: [0xb3,0xff,0x00,0x00]
+#CHECK: rrxtr	%f0, %f0, %f0, 15       # encoding: [0xb3,0xff,0x0f,0x00]
+#CHECK: rrxtr	%f0, %f0, %f13, 0       # encoding: [0xb3,0xff,0x00,0x0d]
+#CHECK: rrxtr	%f0, %f13, %f0, 0       # encoding: [0xb3,0xff,0xd0,0x00]
+#CHECK: rrxtr	%f8, %f8, %f8, 8        # encoding: [0xb3,0xff,0x88,0x88]
+#CHECK: rrxtr	%f13, %f0, %f0, 0       # encoding: [0xb3,0xff,0x00,0xd0]
+
+	rrxtr	%f0, %f0, %f0, 0
+	rrxtr	%f0, %f0, %f0, 15
+	rrxtr	%f0, %f0, %f13, 0
+	rrxtr	%f0, %f13, %f0, 0
+	rrxtr	%f8, %f8, %f8, 8
+	rrxtr	%f13, %f0, %f0, 0
+
 #CHECK: rxsbg	%r0, %r0, 0, 0, 0       # encoding: [0xec,0x00,0x00,0x00,0x00,0x57]
 #CHECK: rxsbg	%r0, %r0, 0, 0, 63      # encoding: [0xec,0x00,0x00,0x00,0x3f,0x57]
 #CHECK: rxsbg	%r0, %r0, 0, 255, 0     # encoding: [0xec,0x00,0x00,0xff,0x00,0x57]
@@ -11682,6 +12181,18 @@
 	sdr	%f7, %f8
 	sdr	%f15, %f0
 
+#CHECK: sdtr	%f0, %f0, %f0           # encoding: [0xb3,0xd3,0x00,0x00]
+#CHECK: sdtr	%f0, %f0, %f15          # encoding: [0xb3,0xd3,0xf0,0x00]
+#CHECK: sdtr	%f0, %f15, %f0          # encoding: [0xb3,0xd3,0x00,0x0f]
+#CHECK: sdtr	%f15, %f0, %f0          # encoding: [0xb3,0xd3,0x00,0xf0]
+#CHECK: sdtr	%f7, %f8, %f9           # encoding: [0xb3,0xd3,0x90,0x78]
+
+	sdtr	%f0, %f0, %f0
+	sdtr	%f0, %f0, %f15
+	sdtr	%f0, %f15, %f0
+	sdtr	%f15, %f0, %f0
+	sdtr	%f7, %f8, %f9
+
 #CHECK: se	%f0, 0                  # encoding: [0x7b,0x00,0x00,0x00]
 #CHECK: se	%f0, 4095               # encoding: [0x7b,0x00,0x0f,0xff]
 #CHECK: se	%f0, 0(%r1)             # encoding: [0x7b,0x00,0x10,0x00]
@@ -12012,6 +12523,26 @@
 	sldl	%r0,4095(%r1)
 	sldl	%r0,4095(%r15)
 
+#CHECK: sldt	%f0, %f0, 0             # encoding: [0xed,0x00,0x00,0x00,0x00,0x40]
+#CHECK: sldt	%f0, %f0, 4095          # encoding: [0xed,0x00,0x0f,0xff,0x00,0x40]
+#CHECK: sldt	%f0, %f0, 0(%r1)        # encoding: [0xed,0x00,0x10,0x00,0x00,0x40]
+#CHECK: sldt	%f0, %f0, 0(%r15)       # encoding: [0xed,0x00,0xf0,0x00,0x00,0x40]
+#CHECK: sldt	%f0, %f0, 4095(%r1,%r15) # encoding: [0xed,0x01,0xff,0xff,0x00,0x40]
+#CHECK: sldt	%f0, %f0, 4095(%r15,%r1) # encoding: [0xed,0x0f,0x1f,0xff,0x00,0x40]
+#CHECK: sldt	%f0, %f15, 0            # encoding: [0xed,0xf0,0x00,0x00,0x00,0x40]
+#CHECK: sldt	%f15, %f0, 0            # encoding: [0xed,0x00,0x00,0x00,0xf0,0x40]
+#CHECK: sldt	%f15, %f15, 0           # encoding: [0xed,0xf0,0x00,0x00,0xf0,0x40]
+
+	sldt	%f0, %f0, 0
+	sldt	%f0, %f0, 4095
+	sldt	%f0, %f0, 0(%r1)
+	sldt	%f0, %f0, 0(%r15)
+	sldt	%f0, %f0, 4095(%r1,%r15)
+	sldt	%f0, %f0, 4095(%r15,%r1)
+	sldt	%f0, %f15, 0
+	sldt	%f15, %f0, 0
+	sldt	%f15, %f15, 0
+
 #CHECK: slfi	%r0, 0                  # encoding: [0xc2,0x05,0x00,0x00,0x00,0x00]
 #CHECK: slfi	%r0, 4294967295         # encoding: [0xc2,0x05,0xff,0xff,0xff,0xff]
 #CHECK: slfi	%r15, 0                 # encoding: [0xc2,0xf5,0x00,0x00,0x00,0x00]
@@ -12146,6 +12677,26 @@
 	slr	%r15,%r0
 	slr	%r7,%r8
 
+#CHECK: slxt	%f0, %f0, 0             # encoding: [0xed,0x00,0x00,0x00,0x00,0x48]
+#CHECK: slxt	%f0, %f0, 4095          # encoding: [0xed,0x00,0x0f,0xff,0x00,0x48]
+#CHECK: slxt	%f0, %f0, 0(%r1)        # encoding: [0xed,0x00,0x10,0x00,0x00,0x48]
+#CHECK: slxt	%f0, %f0, 0(%r15)       # encoding: [0xed,0x00,0xf0,0x00,0x00,0x48]
+#CHECK: slxt	%f0, %f0, 4095(%r1,%r15) # encoding: [0xed,0x01,0xff,0xff,0x00,0x48]
+#CHECK: slxt	%f0, %f0, 4095(%r15,%r1) # encoding: [0xed,0x0f,0x1f,0xff,0x00,0x48]
+#CHECK: slxt	%f0, %f13, 0            # encoding: [0xed,0xd0,0x00,0x00,0x00,0x48]
+#CHECK: slxt	%f13, %f0, 0            # encoding: [0xed,0x00,0x00,0x00,0xd0,0x48]
+#CHECK: slxt	%f13, %f13, 0           # encoding: [0xed,0xd0,0x00,0x00,0xd0,0x48]
+
+	slxt	%f0, %f0, 0
+	slxt	%f0, %f0, 4095
+	slxt	%f0, %f0, 0(%r1)
+	slxt	%f0, %f0, 0(%r15)
+	slxt	%f0, %f0, 4095(%r1,%r15)
+	slxt	%f0, %f0, 4095(%r15,%r1)
+	slxt	%f0, %f13, 0
+	slxt	%f13, %f0, 0
+	slxt	%f13, %f13, 0
+
 #CHECK: sly	%r0, -524288            # encoding: [0xe3,0x00,0x00,0x00,0x80,0x5f]
 #CHECK: sly	%r0, -1                 # encoding: [0xe3,0x00,0x0f,0xff,0xff,0x5f]
 #CHECK: sly	%r0, 0                  # encoding: [0xe3,0x00,0x00,0x00,0x00,0x5f]
@@ -12420,6 +12971,26 @@
 	srdl	%r0,4095(%r1)
 	srdl	%r0,4095(%r15)
 
+#CHECK: srdt	%f0, %f0, 0             # encoding: [0xed,0x00,0x00,0x00,0x00,0x41]
+#CHECK: srdt	%f0, %f0, 4095          # encoding: [0xed,0x00,0x0f,0xff,0x00,0x41]
+#CHECK: srdt	%f0, %f0, 0(%r1)        # encoding: [0xed,0x00,0x10,0x00,0x00,0x41]
+#CHECK: srdt	%f0, %f0, 0(%r15)       # encoding: [0xed,0x00,0xf0,0x00,0x00,0x41]
+#CHECK: srdt	%f0, %f0, 4095(%r1,%r15) # encoding: [0xed,0x01,0xff,0xff,0x00,0x41]
+#CHECK: srdt	%f0, %f0, 4095(%r15,%r1) # encoding: [0xed,0x0f,0x1f,0xff,0x00,0x41]
+#CHECK: srdt	%f0, %f15, 0            # encoding: [0xed,0xf0,0x00,0x00,0x00,0x41]
+#CHECK: srdt	%f15, %f0, 0            # encoding: [0xed,0x00,0x00,0x00,0xf0,0x41]
+#CHECK: srdt	%f15, %f15, 0           # encoding: [0xed,0xf0,0x00,0x00,0xf0,0x41]
+
+	srdt	%f0, %f0, 0
+	srdt	%f0, %f0, 4095
+	srdt	%f0, %f0, 0(%r1)
+	srdt	%f0, %f0, 0(%r15)
+	srdt	%f0, %f0, 4095(%r1,%r15)
+	srdt	%f0, %f0, 4095(%r15,%r1)
+	srdt	%f0, %f15, 0
+	srdt	%f15, %f0, 0
+	srdt	%f15, %f15, 0
+
 #CHECK: srl	%r0, 0                  # encoding: [0x88,0x00,0x00,0x00]
 #CHECK: srl	%r7, 0                  # encoding: [0x88,0x70,0x00,0x00]
 #CHECK: srl	%r15, 0                 # encoding: [0x88,0xf0,0x00,0x00]
@@ -12540,6 +13111,26 @@
 	srstu	%r15,%r0
 	srstu	%r7,%r8
 
+#CHECK: srxt	%f0, %f0, 0             # encoding: [0xed,0x00,0x00,0x00,0x00,0x49]
+#CHECK: srxt	%f0, %f0, 4095          # encoding: [0xed,0x00,0x0f,0xff,0x00,0x49]
+#CHECK: srxt	%f0, %f0, 0(%r1)        # encoding: [0xed,0x00,0x10,0x00,0x00,0x49]
+#CHECK: srxt	%f0, %f0, 0(%r15)       # encoding: [0xed,0x00,0xf0,0x00,0x00,0x49]
+#CHECK: srxt	%f0, %f0, 4095(%r1,%r15) # encoding: [0xed,0x01,0xff,0xff,0x00,0x49]
+#CHECK: srxt	%f0, %f0, 4095(%r15,%r1) # encoding: [0xed,0x0f,0x1f,0xff,0x00,0x49]
+#CHECK: srxt	%f0, %f13, 0            # encoding: [0xed,0xd0,0x00,0x00,0x00,0x49]
+#CHECK: srxt	%f13, %f0, 0            # encoding: [0xed,0x00,0x00,0x00,0xd0,0x49]
+#CHECK: srxt	%f13, %f13, 0           # encoding: [0xed,0xd0,0x00,0x00,0xd0,0x49]
+
+	srxt	%f0, %f0, 0
+	srxt	%f0, %f0, 4095
+	srxt	%f0, %f0, 0(%r1)
+	srxt	%f0, %f0, 0(%r15)
+	srxt	%f0, %f0, 4095(%r1,%r15)
+	srxt	%f0, %f0, 4095(%r15,%r1)
+	srxt	%f0, %f13, 0
+	srxt	%f13, %f0, 0
+	srxt	%f13, %f13, 0
+
 #CHECK: st	%r0, 0                  # encoding: [0x50,0x00,0x00,0x00]
 #CHECK: st	%r0, 4095               # encoding: [0x50,0x00,0x0f,0xff]
 #CHECK: st	%r0, 0(%r1)             # encoding: [0x50,0x00,0x10,0x00]
@@ -13341,6 +13932,18 @@
 	sxr	%f8, %f8
 	sxr	%f13, %f0
 
+#CHECK: sxtr	%f0, %f0, %f0           # encoding: [0xb3,0xdb,0x00,0x00]
+#CHECK: sxtr	%f0, %f0, %f13          # encoding: [0xb3,0xdb,0xd0,0x00]
+#CHECK: sxtr	%f0, %f13, %f0          # encoding: [0xb3,0xdb,0x00,0x0d]
+#CHECK: sxtr	%f13, %f0, %f0          # encoding: [0xb3,0xdb,0x00,0xd0]
+#CHECK: sxtr	%f8, %f8, %f8           # encoding: [0xb3,0xdb,0x80,0x88]
+
+	sxtr	%f0, %f0, %f0
+	sxtr	%f0, %f0, %f13
+	sxtr	%f0, %f13, %f0
+	sxtr	%f13, %f0, %f0
+	sxtr	%f8, %f8, %f8
+
 #CHECK: sy	%r0, -524288            # encoding: [0xe3,0x00,0x00,0x00,0x80,0x5b]
 #CHECK: sy	%r0, -1                 # encoding: [0xe3,0x00,0x0f,0xff,0xff,0x5b]
 #CHECK: sy	%r0, 0                  # encoding: [0xe3,0x00,0x00,0x00,0x00,0x5b]
@@ -13439,6 +14042,102 @@
 	tcxb	%f0, 4095(%r15,%r1)
 	tcxb	%f13, 0
 
+#CHECK: tdcdt	%f0, 0                  # encoding: [0xed,0x00,0x00,0x00,0x00,0x54]
+#CHECK: tdcdt	%f0, 4095               # encoding: [0xed,0x00,0x0f,0xff,0x00,0x54]
+#CHECK: tdcdt	%f0, 0(%r1)             # encoding: [0xed,0x00,0x10,0x00,0x00,0x54]
+#CHECK: tdcdt	%f0, 0(%r15)            # encoding: [0xed,0x00,0xf0,0x00,0x00,0x54]
+#CHECK: tdcdt	%f0, 4095(%r1,%r15)     # encoding: [0xed,0x01,0xff,0xff,0x00,0x54]
+#CHECK: tdcdt	%f0, 4095(%r15,%r1)     # encoding: [0xed,0x0f,0x1f,0xff,0x00,0x54]
+#CHECK: tdcdt	%f15, 0                 # encoding: [0xed,0xf0,0x00,0x00,0x00,0x54]
+
+	tdcdt	%f0, 0
+	tdcdt	%f0, 4095
+	tdcdt	%f0, 0(%r1)
+	tdcdt	%f0, 0(%r15)
+	tdcdt	%f0, 4095(%r1,%r15)
+	tdcdt	%f0, 4095(%r15,%r1)
+	tdcdt	%f15, 0
+
+#CHECK: tdcet	%f0, 0                  # encoding: [0xed,0x00,0x00,0x00,0x00,0x50]
+#CHECK: tdcet	%f0, 4095               # encoding: [0xed,0x00,0x0f,0xff,0x00,0x50]
+#CHECK: tdcet	%f0, 0(%r1)             # encoding: [0xed,0x00,0x10,0x00,0x00,0x50]
+#CHECK: tdcet	%f0, 0(%r15)            # encoding: [0xed,0x00,0xf0,0x00,0x00,0x50]
+#CHECK: tdcet	%f0, 4095(%r1,%r15)     # encoding: [0xed,0x01,0xff,0xff,0x00,0x50]
+#CHECK: tdcet	%f0, 4095(%r15,%r1)     # encoding: [0xed,0x0f,0x1f,0xff,0x00,0x50]
+#CHECK: tdcet	%f15, 0                 # encoding: [0xed,0xf0,0x00,0x00,0x00,0x50]
+
+	tdcet	%f0, 0
+	tdcet	%f0, 4095
+	tdcet	%f0, 0(%r1)
+	tdcet	%f0, 0(%r15)
+	tdcet	%f0, 4095(%r1,%r15)
+	tdcet	%f0, 4095(%r15,%r1)
+	tdcet	%f15, 0
+
+#CHECK: tdcxt	%f0, 0                  # encoding: [0xed,0x00,0x00,0x00,0x00,0x58]
+#CHECK: tdcxt	%f0, 4095               # encoding: [0xed,0x00,0x0f,0xff,0x00,0x58]
+#CHECK: tdcxt	%f0, 0(%r1)             # encoding: [0xed,0x00,0x10,0x00,0x00,0x58]
+#CHECK: tdcxt	%f0, 0(%r15)            # encoding: [0xed,0x00,0xf0,0x00,0x00,0x58]
+#CHECK: tdcxt	%f0, 4095(%r1,%r15)     # encoding: [0xed,0x01,0xff,0xff,0x00,0x58]
+#CHECK: tdcxt	%f0, 4095(%r15,%r1)     # encoding: [0xed,0x0f,0x1f,0xff,0x00,0x58]
+#CHECK: tdcxt	%f13, 0                 # encoding: [0xed,0xd0,0x00,0x00,0x00,0x58]
+
+	tdcxt	%f0, 0
+	tdcxt	%f0, 4095
+	tdcxt	%f0, 0(%r1)
+	tdcxt	%f0, 0(%r15)
+	tdcxt	%f0, 4095(%r1,%r15)
+	tdcxt	%f0, 4095(%r15,%r1)
+	tdcxt	%f13, 0
+
+#CHECK: tdgdt	%f0, 0                  # encoding: [0xed,0x00,0x00,0x00,0x00,0x55]
+#CHECK: tdgdt	%f0, 4095               # encoding: [0xed,0x00,0x0f,0xff,0x00,0x55]
+#CHECK: tdgdt	%f0, 0(%r1)             # encoding: [0xed,0x00,0x10,0x00,0x00,0x55]
+#CHECK: tdgdt	%f0, 0(%r15)            # encoding: [0xed,0x00,0xf0,0x00,0x00,0x55]
+#CHECK: tdgdt	%f0, 4095(%r1,%r15)     # encoding: [0xed,0x01,0xff,0xff,0x00,0x55]
+#CHECK: tdgdt	%f0, 4095(%r15,%r1)     # encoding: [0xed,0x0f,0x1f,0xff,0x00,0x55]
+#CHECK: tdgdt	%f15, 0                 # encoding: [0xed,0xf0,0x00,0x00,0x00,0x55]
+
+	tdgdt	%f0, 0
+	tdgdt	%f0, 4095
+	tdgdt	%f0, 0(%r1)
+	tdgdt	%f0, 0(%r15)
+	tdgdt	%f0, 4095(%r1,%r15)
+	tdgdt	%f0, 4095(%r15,%r1)
+	tdgdt	%f15, 0
+
+#CHECK: tdget	%f0, 0                  # encoding: [0xed,0x00,0x00,0x00,0x00,0x51]
+#CHECK: tdget	%f0, 4095               # encoding: [0xed,0x00,0x0f,0xff,0x00,0x51]
+#CHECK: tdget	%f0, 0(%r1)             # encoding: [0xed,0x00,0x10,0x00,0x00,0x51]
+#CHECK: tdget	%f0, 0(%r15)            # encoding: [0xed,0x00,0xf0,0x00,0x00,0x51]
+#CHECK: tdget	%f0, 4095(%r1,%r15)     # encoding: [0xed,0x01,0xff,0xff,0x00,0x51]
+#CHECK: tdget	%f0, 4095(%r15,%r1)     # encoding: [0xed,0x0f,0x1f,0xff,0x00,0x51]
+#CHECK: tdget	%f15, 0                 # encoding: [0xed,0xf0,0x00,0x00,0x00,0x51]
+
+	tdget	%f0, 0
+	tdget	%f0, 4095
+	tdget	%f0, 0(%r1)
+	tdget	%f0, 0(%r15)
+	tdget	%f0, 4095(%r1,%r15)
+	tdget	%f0, 4095(%r15,%r1)
+	tdget	%f15, 0
+
+#CHECK: tdgxt	%f0, 0                  # encoding: [0xed,0x00,0x00,0x00,0x00,0x59]
+#CHECK: tdgxt	%f0, 4095               # encoding: [0xed,0x00,0x0f,0xff,0x00,0x59]
+#CHECK: tdgxt	%f0, 0(%r1)             # encoding: [0xed,0x00,0x10,0x00,0x00,0x59]
+#CHECK: tdgxt	%f0, 0(%r15)            # encoding: [0xed,0x00,0xf0,0x00,0x00,0x59]
+#CHECK: tdgxt	%f0, 4095(%r1,%r15)     # encoding: [0xed,0x01,0xff,0xff,0x00,0x59]
+#CHECK: tdgxt	%f0, 4095(%r15,%r1)     # encoding: [0xed,0x0f,0x1f,0xff,0x00,0x59]
+#CHECK: tdgxt	%f13, 0                 # encoding: [0xed,0xd0,0x00,0x00,0x00,0x59]
+
+	tdgxt	%f0, 0
+	tdgxt	%f0, 4095
+	tdgxt	%f0, 0(%r1)
+	tdgxt	%f0, 0(%r15)
+	tdgxt	%f0, 4095(%r1,%r15)
+	tdgxt	%f0, 4095(%r15,%r1)
+	tdgxt	%f13, 0
+
 #CHECK: thder	%f0, %f9                # encoding: [0xb3,0x58,0x00,0x09]
 #CHECK: thder	%f0, %f15               # encoding: [0xb3,0x58,0x00,0x0f]
 #CHECK: thder	%f15, %f0               # encoding: [0xb3,0x58,0x00,0xf0]