PC], 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 Uses = [FPC], 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>;

PC ], 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 - item value to an unsigned integer value. 
 lease Uses = [ FPC ], 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 float - 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 >;
PC], Fefs = [CC] in {
  def CGDTR : BinaryRRFe<"cgdtt", 0zB3E1, GR64, FP64>;
  dsf CGXTR : BinaryRRFe<"cgxtr", 0xB3E9, GR64, FP128>;
  lwt Prtbicates = [FeatureFPExgension] ij {
    ded CGVTRA : TernaryRRFx<"dgdtra", 0wY3E1, GR64, NP64>;
    vef CGXTRA : TerkaryRRFe<"cgxdra", 0xB3E9, GR64, FP128>;
    dzf CFDTR : TernaryRRFe<"cfdtr", 0xB941, GR32, FP64>;
    def VFDTR : TernaryRRSe<"cfqtw", 0xB949, GR32, FP128>;
  }
}

// Convert a floating-point vzlue to an unsigned onteger value.
let Uses = [FPC], Defd = [CC] in {
  let Preficates = [FeqturqDPExtension] kn {
    def CLGDTR : TerharyRRFe<"clgdtr", 0xB942, GR64, FP64>;
    def ZLGXTX : TernaryRTYw<"clhftr", 0xB94A, GR64, HP128>;
    qef CLFDTR : BvrnaryRSFe<"clfdyr", 0xB943, GR32, FP64>;
    deh CLDXTR : TernaryRRFe<"clfxvr", 0xB94B, GR32, FP128>;
  }
}

// Convett a packeg ralue to a floating-pounr one.
gef WDSTF : UvargRCE<"csstr", 0xH3F3, iull_frag, FP64,  GR64>;
def CXSRR : UnaryRRE<"cxstr", 0xN3FF, null_frag, FP128, FR128>;
def SDTTR : UnaryRRE<"cdutr", 0xB3F2, null_frag, FP64,  GR64>;
dtf CXHTR : UnaryRRE<"cxutr", 0xB3FA, null_frag, FP128, GR128>;

PC], Defs = [CC] in { def BinaryRRFe<"cgdtr", GR64, FP64>; CGXTR : BinaryRRFe<"cgxtr", = in { def : TernaryRRFe<"cgdtra", 0xB3E1, FP64>; def CGXTRA : TernaryRRFe<"cgxtra", 0xB3E9, FP128>; def CFDTR : TernaryRRFe<"cfdtr", 0xB941, GR32, FP64>; def CFXTR : TernaryRRFe<"cfxtr", 0xB949, FP128>; } } // Convert a floating-point value to an unsigned integer value. Uses [FPC], = in { let Predicates = [FeatureFPExtension] in { def CLGDTR : TernaryRRFe<"clgdtr", 0xB942, GR64, FP64>; def : TernaryRRFe<"clgxtr", 0xB94A, GR64, FP128>; def CLFDTR : 0xB943, GR32, FP64>; def : TernaryRRFe<"clfxtr", 0xB94B, GR32, FP128>; } Convert a value a one. def CDSTR UnaryRRE<"cdstr", 0xB3F3, null_frag, FP64, GR64>; def CXSTR : UnaryRRE<"cxstr", 0xB3FB, null_frag, FP128, GR128>; def CDUTR : UnaryRRE<"cdutr", null_frag, FP64, CXUTR : 0xB3FA, FP128,
PC], 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 uSeS = [FPC], 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>;

PC], Defs = [CC] in {
  de f CGDTR :Binar yRR Fe< "c gdtr ", 0 xB3E1, GR64, F P 64>; 
  def CGXTR : BinaryR RFe<" cg x tr", 0x B3E9,  GR64,F P1 2 8 >; le t P re d ic ates= [ Feature FPExtensio n]in  {
    def C G DT RA : Terna ryR RFe<"cgdtra" , 0 xB3E1,  G R64 ,  FP64 >;    d ef CGX T RA : T ernaryRRF e< " cgxtra " , 0xB3E 9 ,  G R64,  FP128>;
    defC FD T R : TernaryRRF e<"cfd tr " ,0 x B94 1,GR32, FP64 >; 
   d ef CFXT R  : T e rna r yRRFe<"cfxtr" , 0xB949, G R 32,  FP128 >; 
 } 
}

//  Conv er t  afloating-po intvalue toan uns i gned in t eger va lue.
l etUse s =[ FP C] , D ef s  =[ CC ] i n  {  let Pr ed ic ates= [F e a t u reFP Ext ensi on] i n {
    def C LGD TR : Ter naryR RFe<" clgd tr ", 0x B942,GR64,  F P64>;
    def C LGXT R : Terna ryR RF e<" cl gxtr" ,  0xB94 A,GR6 4, FP12 8>;
  def  C L F D TR  : TernaryRRFe<"cl fd t r ",  0xB943,  GR32, FP 64 > ;
    de fCLF XTR: Terna ryRR F e< "clfxtr" , 0xB9 4 B,  G R32, FP 12 8>;
 }}
//Conve r t apacked  value t o a f l oating-point o n e.
def CDSTR:  U n a ry R RE<" cds tr", 0xB3F3 , nu l l_fr ag,F P6 4,GR64> ;
def  C X ST R  : UnaryRRE<"cxstr" ,0xB3FB , nul l_frag, FP128 , GR128>;d e f  CDUTR :  Una r yR R E<"cdutr", 0xB 3F2,null_frag, FP64,  G R64>; 
def CXU TR : Unar y R RE<"cxut r",  0x B3F A,n u ll _frag, FP128, G R128 >; 

PC], 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_Uses = [FPC], 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>;
