/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\

|*                                                                            *|

|* Global Instruction Selector for the ARM target                             *|

|*                                                                            *|

|* Automatically generated file, do not edit!                                 *|

|*                                                                            *|

\*===----------------------------------------------------------------------===*/

#ifdef GET_GLOBALISEL_PREDICATE_BITSET

const unsigned MAX_SUBTARGET_PREDICATES = 85;

using PredicateBitset = llvm::Bitset<MAX_SUBTARGET_PREDICATES>;

#endif // ifdef GET_GLOBALISEL_PREDICATE_BITSET

#ifdef GET_GLOBALISEL_TEMPORARIES_DECL

  mutable MatcherState State;

  typedef ComplexRendererFns(ARMInstructionSelector::*ComplexMatcherMemFn)(MachineOperand &) const;

  typedef void(ARMInstructionSelector::*CustomRendererFn)(MachineInstrBuilder &, const MachineInstr &, int) const;

  const ExecInfoTy<PredicateBitset, ComplexMatcherMemFn, CustomRendererFn> ExecInfo;

  static ARMInstructionSelector::ComplexMatcherMemFn ComplexPredicateFns[];

  static ARMInstructionSelector::CustomRendererFn CustomRenderers[];

  bool testImmPredicate_I64(unsigned PredicateID, int64_t Imm) const override;

  bool testImmPredicate_APInt(unsigned PredicateID, const APInt &Imm) const override;

  bool testImmPredicate_APFloat(unsigned PredicateID, const APFloat &Imm) const override;

  const uint8_t *getMatchTable() const override;

  bool testMIPredicate_MI(unsigned PredicateID, const MachineInstr &MI, const MatcherState &State) const override;

  bool testSimplePredicate(unsigned PredicateID) const override;

  void runCustomAction(unsigned FnID, const MatcherState &State, NewMIVector &OutMIs) const override;

#endif // ifdef GET_GLOBALISEL_TEMPORARIES_DECL

#ifdef GET_GLOBALISEL_TEMPORARIES_INIT

, State(0),

ExecInfo(TypeObjects, NumTypeObjects, FeatureBitsets, ComplexPredicateFns, CustomRenderers)

#endif // ifdef GET_GLOBALISEL_TEMPORARIES_INIT

#ifdef GET_GLOBALISEL_IMPL

// LLT Objects.

enum {

  GILLT_s16,

  GILLT_s32,

  GILLT_s64,

  GILLT_v2s1,

  GILLT_v2s32,

  GILLT_v2s64,

  GILLT_v4s1,

  GILLT_v4s16,

  GILLT_v4s32,

  GILLT_v4s64,

  GILLT_v8s1,

  GILLT_v8s8,

  GILLT_v8s16,

  GILLT_v8s64,

  GILLT_v16s1,

  GILLT_v16s8,

};

const static size_t NumTypeObjects = 16;

const static LLT TypeObjects[] = {

  LLT::scalar(16),

  LLT::scalar(32),

  LLT::scalar(64),

  LLT::vector(ElementCount::getFixed(2), 1),

  LLT::vector(ElementCount::getFixed(2), 32),

  LLT::vector(ElementCount::getFixed(2), 64),

  LLT::vector(ElementCount::getFixed(4), 1),

  LLT::vector(ElementCount::getFixed(4), 16),

  LLT::vector(ElementCount::getFixed(4), 32),

  LLT::vector(ElementCount::getFixed(4), 64),

  LLT::vector(ElementCount::getFixed(8), 1),

  LLT::vector(ElementCount::getFixed(8), 8),

  LLT::vector(ElementCount::getFixed(8), 16),

  LLT::vector(ElementCount::getFixed(8), 64),

  LLT::vector(ElementCount::getFixed(16), 1),

  LLT::vector(ElementCount::getFixed(16), 8),

};

// Bits for subtarget features that participate in instruction matching.

enum SubtargetFeatureBits : uint8_t {

  Feature_NoHonorSignDependentRoundingBit = 76,

  Feature_HasV4TBit = 6,

  Feature_NoV4TBit = 7,

  Feature_HasV5TBit = 13,

  Feature_NoV5TBit = 67,

  Feature_HasV5TEBit = 11,

  Feature_HasV6Bit = 0,

  Feature_NoV6Bit = 9,

  Feature_HasV6MBit = 28,

  Feature_HasV8MBaselineBit = 35,

  Feature_HasV8_1MMainlineBit = 41,

  Feature_HasMVEIntBit = 65,

  Feature_HasMVEFloatBit = 66,

  Feature_HasCDEBit = 84,

  Feature_HasFPRegsBit = 42,

  Feature_HasFPRegs16Bit = 43,

  Feature_HasNoFPRegs16Bit = 75,

  Feature_HasFPRegs64Bit = 52,

  Feature_HasV6T2Bit = 8,

  Feature_HasV6KBit = 18,

  Feature_HasV7Bit = 3,

  Feature_HasV8Bit = 56,

  Feature_PreV8Bit = 19,

  Feature_HasV8_1aBit = 78,

  Feature_HasV8_3aBit = 79,

  Feature_NoVFPBit = 22,

  Feature_HasVFP2Bit = 21,

  Feature_HasVFP3Bit = 53,

  Feature_HasVFP4Bit = 50,

  Feature_HasDPVFPBit = 44,

  Feature_HasFPARMv8Bit = 47,

  Feature_HasNEONBit = 54,

  Feature_HasSHA2Bit = 63,

  Feature_HasAESBit = 55,

  Feature_HasDotProdBit = 57,

  Feature_HasCRCBit = 14,

  Feature_HasLOBBit = 40,

  Feature_HasFP16Bit = 62,

  Feature_HasFullFP16Bit = 46,

  Feature_HasBF16Bit = 64,

  Feature_HasMatMulInt8Bit = 58,

  Feature_HasDivideInThumbBit = 37,

  Feature_HasDivideInARMBit = 12,

  Feature_HasDSPBit = 36,

  Feature_HasDBBit = 15,

  Feature_HasV7ClrexBit = 17,

  Feature_HasAcquireReleaseBit = 16,

  Feature_HasMPBit = 2,

  Feature_Has8MSecExtBit = 29,

  Feature_HasZCZBit = 59,

  Feature_UseNEONForFPBit = 82,

  Feature_DontUseNEONForFPBit = 45,

  Feature_IsThumbBit = 26,

  Feature_IsThumb1OnlyBit = 27,

  Feature_IsThumb2Bit = 34,

  Feature_IsNotMClassBit = 38,

  Feature_IsARMBit = 1,

  Feature_IsWindowsBit = 30,

  Feature_IsNotWindowsBit = 31,

  Feature_IsReadTPTPIDRURWBit = 70,

  Feature_IsReadTPTPIDRUROBit = 71,

  Feature_IsReadTPTPIDRPRWBit = 72,

  Feature_IsReadTPSoftBit = 20,

  Feature_UseNaClTrapBit = 4,

  Feature_DontUseNaClTrapBit = 5,

  Feature_UseMovtBit = 39,

  Feature_DontUseMovtBit = 23,

  Feature_UseMovtInPicBit = 24,

  Feature_DontUseMovtInPicBit = 25,

  Feature_UseFPVMLxBit = 49,

  Feature_SLSBLRMitigationBit = 69,

  Feature_NoSLSBLRMitigationBit = 68,

  Feature_UseMulOpsBit = 10,

  Feature_UseFusedMACBit = 51,

  Feature_HasFastVGETLNi32Bit = 60,

  Feature_HasSlowVGETLNi32Bit = 80,

  Feature_HasFastVDUP32Bit = 61,

  Feature_HasSlowVDUP32Bit = 81,

  Feature_UseVMOVSRBit = 48,

  Feature_DontUseVMOVSRBit = 83,

  Feature_IsLEBit = 74,

  Feature_IsBEBit = 77,

  Feature_GenExecuteOnlyBit = 33,

  Feature_DontGenExecuteOnlyBit = 32,

  Feature_GenT1ExecuteOnlyBit = 73,

};

PredicateBitset ARMInstructionSelector::

computeAvailableModuleFeatures(const ARMSubtarget *Subtarget) const {

  PredicateBitset Features;

  if (!TM.Options.HonorSignDependentRoundingFPMath())

    Features.set(Feature_NoHonorSignDependentRoundingBit);

  if (Subtarget->hasV4TOps())

    Features.set(Feature_HasV4TBit);

  if (!Subtarget->hasV4TOps())

    Features.set(Feature_NoV4TBit);

  if (Subtarget->hasV5TOps())

    Features.set(Feature_HasV5TBit);

  if (!Subtarget->hasV5TOps())

    Features.set(Feature_NoV5TBit);

  if (Subtarget->hasV5TEOps())

    Features.set(Feature_HasV5TEBit);

  if (Subtarget->hasV6Ops())

    Features.set(Feature_HasV6Bit);

  if (!Subtarget->hasV6Ops())

    Features.set(Feature_NoV6Bit);

  if (Subtarget->hasV6MOps())

    Features.set(Feature_HasV6MBit);

  if (Subtarget->hasV8MBaselineOps())

    Features.set(Feature_HasV8MBaselineBit);

  if (Subtarget->hasV8_1MMainlineOps())

    Features.set(Feature_HasV8_1MMainlineBit);

  if (Subtarget->hasMVEIntegerOps())

    Features.set(Feature_HasMVEIntBit);

  if (Subtarget->hasMVEFloatOps())

    Features.set(Feature_HasMVEFloatBit);

  if (Subtarget->hasCDEOps())

    Features.set(Feature_HasCDEBit);

  if (Subtarget->hasFPRegs())

    Features.set(Feature_HasFPRegsBit);

  if (Subtarget->hasFPRegs16())

    Features.set(Feature_HasFPRegs16Bit);

  if (!Subtarget->hasFPRegs16())

    Features.set(Feature_HasNoFPRegs16Bit);

  if (Subtarget->hasFPRegs64())

    Features.set(Feature_HasFPRegs64Bit);

  if (Subtarget->hasV6T2Ops())

    Features.set(Feature_HasV6T2Bit);

  if (Subtarget->hasV6KOps())

    Features.set(Feature_HasV6KBit);

  if (Subtarget->hasV7Ops())

    Features.set(Feature_HasV7Bit);

  if (Subtarget->hasV8Ops())

    Features.set(Feature_HasV8Bit);

  if (!Subtarget->hasV8Ops())

    Features.set(Feature_PreV8Bit);

  if (Subtarget->hasV8_1aOps())

    Features.set(Feature_HasV8_1aBit);

  if (Subtarget->hasV8_3aOps())

    Features.set(Feature_HasV8_3aBit);

  if (!Subtarget->hasVFP2Base())

    Features.set(Feature_NoVFPBit);

  if (Subtarget->hasVFP2Base())

    Features.set(Feature_HasVFP2Bit);

  if (Subtarget->hasVFP3Base())

    Features.set(Feature_HasVFP3Bit);

  if (Subtarget->hasVFP4Base())

    Features.set(Feature_HasVFP4Bit);

  if (Subtarget->hasFP64())

    Features.set(Feature_HasDPVFPBit);

  if (Subtarget->hasFPARMv8Base())

    Features.set(Feature_HasFPARMv8Bit);

  if (Subtarget->hasNEON())

    Features.set(Feature_HasNEONBit);

  if (Subtarget->hasSHA2())

    Features.set(Feature_HasSHA2Bit);

  if (Subtarget->hasAES())

    Features.set(Feature_HasAESBit);

  if (Subtarget->hasDotProd())

    Features.set(Feature_HasDotProdBit);

  if (Subtarget->hasCRC())

    Features.set(Feature_HasCRCBit);

  if (Subtarget->hasLOB())

    Features.set(Feature_HasLOBBit);

  if (Subtarget->hasFP16())

    Features.set(Feature_HasFP16Bit);

  if (Subtarget->hasFullFP16())

    Features.set(Feature_HasFullFP16Bit);

  if (Subtarget->hasBF16())

    Features.set(Feature_HasBF16Bit);

  if (Subtarget->hasMatMulInt8())

    Features.set(Feature_HasMatMulInt8Bit);

  if (Subtarget->hasDivideInThumbMode())

    Features.set(Feature_HasDivideInThumbBit);

  if (Subtarget->hasDivideInARMMode())

    Features.set(Feature_HasDivideInARMBit);

  if (Subtarget->hasDSP())

    Features.set(Feature_HasDSPBit);

  if (Subtarget->hasDataBarrier())

    Features.set(Feature_HasDBBit);

  if (Subtarget->hasV7Clrex())

    Features.set(Feature_HasV7ClrexBit);

  if (Subtarget->hasAcquireRelease())

    Features.set(Feature_HasAcquireReleaseBit);

  if (Subtarget->hasMPExtension())

    Features.set(Feature_HasMPBit);

  if (Subtarget->has8MSecExt())

    Features.set(Feature_Has8MSecExtBit);

  if (Subtarget->hasZeroCycleZeroing())

    Features.set(Feature_HasZCZBit);

  if (Subtarget->useNEONForSinglePrecisionFP())

    Features.set(Feature_UseNEONForFPBit);

  if (!Subtarget->useNEONForSinglePrecisionFP())

    Features.set(Feature_DontUseNEONForFPBit);

  if (Subtarget->isThumb())

    Features.set(Feature_IsThumbBit);

  if (Subtarget->isThumb1Only())

    Features.set(Feature_IsThumb1OnlyBit);

  if (Subtarget->isThumb2())

    Features.set(Feature_IsThumb2Bit);

  if (!Subtarget->isMClass())

    Features.set(Feature_IsNotMClassBit);

  if (!Subtarget->isThumb())

    Features.set(Feature_IsARMBit);

  if (Subtarget->isTargetWindows())

    Features.set(Feature_IsWindowsBit);

  if (!Subtarget->isTargetWindows())

    Features.set(Feature_IsNotWindowsBit);

  if (Subtarget->isReadTPTPIDRURW())

    Features.set(Feature_IsReadTPTPIDRURWBit);

  if (Subtarget->isReadTPTPIDRURO())

    Features.set(Feature_IsReadTPTPIDRUROBit);

  if (Subtarget->isReadTPTPIDRPRW())

    Features.set(Feature_IsReadTPTPIDRPRWBit);

  if (Subtarget->isReadTPSoft())

    Features.set(Feature_IsReadTPSoftBit);

  if (Subtarget->useNaClTrap())

    Features.set(Feature_UseNaClTrapBit);

  if (!Subtarget->useNaClTrap())

    Features.set(Feature_DontUseNaClTrapBit);

  if (Subtarget->useMulOps())

    Features.set(Feature_UseMulOpsBit);

  if (TM.Options.AllowFPOpFusion ==  FPOpFusion::Fast && Subtarget->useFPVFMx())

    Features.set(Feature_UseFusedMACBit);

  if (!Subtarget->hasSlowVGETLNi32())

    Features.set(Feature_HasFastVGETLNi32Bit);

  if (Subtarget->hasSlowVGETLNi32())

    Features.set(Feature_HasSlowVGETLNi32Bit);

  if (!Subtarget->hasSlowVDUP32())

    Features.set(Feature_HasFastVDUP32Bit);

  if (Subtarget->hasSlowVDUP32())

    Features.set(Feature_HasSlowVDUP32Bit);

  if (Subtarget->preferVMOVSR() ||!Subtarget->useNEONForSinglePrecisionFP())

    Features.set(Feature_UseVMOVSRBit);

  if (!Subtarget->preferVMOVSR() &&Subtarget->useNEONForSinglePrecisionFP())

    Features.set(Feature_DontUseVMOVSRBit);

  if (Subtarget->genExecuteOnly())

    Features.set(Feature_GenExecuteOnlyBit);

  if (!Subtarget->genExecuteOnly())

    Features.set(Feature_DontGenExecuteOnlyBit);

  if (Subtarget->genExecuteOnly() && Subtarget->isThumb1Only() && !Subtarget->hasV8MBaselineOps())

    Features.set(Feature_GenT1ExecuteOnlyBit);

  return Features;

}

void ARMInstructionSelector::setupGeneratedPerFunctionState(MachineFunction &MF) {

  AvailableFunctionFeatures = computeAvailableFunctionFeatures((const ARMSubtarget *)&MF.getSubtarget(), &MF);

}

PredicateBitset ARMInstructionSelector::

computeAvailableFunctionFeatures(const ARMSubtarget *Subtarget, const MachineFunction *MF) const {

  PredicateBitset Features;

  if (Subtarget->useMovt())

    Features.set(Feature_UseMovtBit);

  if (!Subtarget->useMovt())

    Features.set(Feature_DontUseMovtBit);

  if (Subtarget->useMovt() && Subtarget->allowPositionIndependentMovt())

    Features.set(Feature_UseMovtInPicBit);

  if (!Subtarget->useMovt() || !Subtarget->allowPositionIndependentMovt())

    Features.set(Feature_DontUseMovtInPicBit);

  if (((Subtarget->useFPVMLx() &&  TM.Options.AllowFPOpFusion != FPOpFusion::Fast) ||Subtarget->hasMinSize()))

    Features.set(Feature_UseFPVMLxBit);

  if ( MF->getSubtarget<ARMSubtarget>().hardenSlsBlr() )

    Features.set(Feature_SLSBLRMitigationBit);

  if ( !MF->getSubtarget<ARMSubtarget>().hardenSlsBlr() )

    Features.set(Feature_NoSLSBLRMitigationBit);

  if (MF->getDataLayout().isLittleEndian())

    Features.set(Feature_IsLEBit);

  if (MF->getDataLayout().isBigEndian())

    Features.set(Feature_IsBEBit);

  return Features;

}

// Feature bitsets.

enum {

  GIFBS_Invalid,

  GIFBS_HasDotProd,

  GIFBS_HasFP16,

  GIFBS_HasFPARMv8,

  GIFBS_HasFPRegs,

  GIFBS_HasFullFP16,

  GIFBS_HasMVEFloat,

  GIFBS_HasMVEInt,

  GIFBS_HasMatMulInt8,

  GIFBS_HasNEON,

  GIFBS_HasVFP2,

  GIFBS_HasVFP3,

  GIFBS_HasVFP4,

  GIFBS_IsARM,

  GIFBS_IsThumb,

  GIFBS_IsThumb2,

  GIFBS_NoHonorSignDependentRounding,

  GIFBS_DontUseNEONForFP_HasVFP2,

  GIFBS_DontUseVMOVSR_HasNEON,

  GIFBS_Has8MSecExt_IsThumb,

  GIFBS_HasAES_HasV8,

  GIFBS_HasBF16_HasNEON,

  GIFBS_HasCRC_IsARM,

  GIFBS_HasCRC_IsThumb2,

  GIFBS_HasDB_IsARM,

  GIFBS_HasDB_IsThumb,

  GIFBS_HasDPVFP_HasFPARMv8,

  GIFBS_HasDPVFP_HasVFP2,

  GIFBS_HasDPVFP_HasVFP3,

  GIFBS_HasDPVFP_HasVFP4,

  GIFBS_HasDPVFP_NoHonorSignDependentRounding,

  GIFBS_HasDSP_IsThumb2,

  GIFBS_HasDivideInARM_IsARM,

  GIFBS_HasFP16_HasNEON,

  GIFBS_HasFPARMv8_HasNEON,

  GIFBS_HasFPRegs_HasFastVGETLNi32,

  GIFBS_HasFPRegs_UseVMOVSR,

  GIFBS_HasFullFP16_HasNEON,

  GIFBS_HasMVEInt_HasV8_1MMainline,

  GIFBS_HasMVEInt_IsBE,

  GIFBS_HasMVEInt_IsLE,

  GIFBS_HasNEON_HasV8,

  GIFBS_HasNEON_HasV8_1a,

  GIFBS_HasNEON_HasV8_3a,

  GIFBS_HasNEON_HasVFP4,

  GIFBS_HasNEON_IsBE,

  GIFBS_HasNEON_IsLE,

  GIFBS_HasNEON_UseNEONForFP,

  GIFBS_HasSHA2_HasV8,

  GIFBS_HasV5T_IsARM,

  GIFBS_HasV5TE_IsARM,

  GIFBS_HasV6_IsARM,

  GIFBS_HasV6K_IsARM,

  GIFBS_HasV6M_IsThumb,

  GIFBS_HasV6T2_IsARM,

  GIFBS_HasV7_IsARM,

  GIFBS_HasV7Clrex_IsThumb,

  GIFBS_HasV8MBaseline_IsThumb,

  GIFBS_IsARM_NoV6,

  GIFBS_IsARM_PreV8,

  GIFBS_IsThumb_IsThumb1Only,

  GIFBS_IsThumb_IsWindows,

  GIFBS_IsThumb_UseMovt,

  GIFBS_IsThumb2_PreV8,

  GIFBS_IsThumb2_UseMulOps,

  GIFBS_DontUseMovt_GenExecuteOnly_IsThumb1Only,

  GIFBS_HasDSP_IsThumb2_UseMulOps,

  GIFBS_HasDivideInThumb_HasV8MBaseline_IsThumb,

  GIFBS_HasFPARMv8_HasFullFP16_HasNEON,

  GIFBS_HasFullFP16_HasNEON_HasV8,

  GIFBS_HasFullFP16_HasNEON_HasV8_3a,

  GIFBS_HasFullFP16_HasNEON_UseFPVMLx,

  GIFBS_HasFullFP16_HasNEON_UseFusedMAC,

  GIFBS_HasLOB_HasV8_1MMainline_IsThumb2,

  GIFBS_HasNEON_UseFPVMLx_UseNEONForFP,

  GIFBS_HasV5TE_IsARM_UseMulOps,

  GIFBS_HasV6_IsARM_UseMulOps,

  GIFBS_HasV6_IsThumb_IsThumb1Only,

  GIFBS_HasV6T2_IsARM_UseMulOps,

  GIFBS_HasVFP4_UseFusedMAC_UseNEONForFP,

  GIFBS_IsARM_NoV6_UseMulOps,

};

constexpr static PredicateBitset FeatureBitsets[] {

  {}, // GIFBS_Invalid

  {Feature_HasDotProdBit, },

  {Feature_HasFP16Bit, },

  {Feature_HasFPARMv8Bit, },

  {Feature_HasFPRegsBit, },

  {Feature_HasFullFP16Bit, },

  {Feature_HasMVEFloatBit, },

  {Feature_HasMVEIntBit, },

  {Feature_HasMatMulInt8Bit, },

  {Feature_HasNEONBit, },

  {Feature_HasVFP2Bit, },

  {Feature_HasVFP3Bit, },

  {Feature_HasVFP4Bit, },

  {Feature_IsARMBit, },

  {Feature_IsThumbBit, },

  {Feature_IsThumb2Bit, },

  {Feature_NoHonorSignDependentRoundingBit, },

  {Feature_DontUseNEONForFPBit, Feature_HasVFP2Bit, },

  {Feature_DontUseVMOVSRBit, Feature_HasNEONBit, },

  {Feature_Has8MSecExtBit, Feature_IsThumbBit, },

  {Feature_HasAESBit, Feature_HasV8Bit, },

  {Feature_HasBF16Bit, Feature_HasNEONBit, },

  {Feature_HasCRCBit, Feature_IsARMBit, },

  {Feature_HasCRCBit, Feature_IsThumb2Bit, },

  {Feature_HasDBBit, Feature_IsARMBit, },

  {Feature_HasDBBit, Feature_IsThumbBit, },

  {Feature_HasDPVFPBit, Feature_HasFPARMv8Bit, },

  {Feature_HasDPVFPBit, Feature_HasVFP2Bit, },

  {Feature_HasDPVFPBit, Feature_HasVFP3Bit, },

  {Feature_HasDPVFPBit, Feature_HasVFP4Bit, },

  {Feature_HasDPVFPBit, Feature_NoHonorSignDependentRoundingBit, },

  {Feature_HasDSPBit, Feature_IsThumb2Bit, },

  {Feature_HasDivideInARMBit, Feature_IsARMBit, },

  {Feature_HasFP16Bit, Feature_HasNEONBit, },

  {Feature_HasFPARMv8Bit, Feature_HasNEONBit, },

  {Feature_HasFPRegsBit, Feature_HasFastVGETLNi32Bit, },

  {Feature_HasFPRegsBit, Feature_UseVMOVSRBit, },

  {Feature_HasFullFP16Bit, Feature_HasNEONBit, },

  {Feature_HasMVEIntBit, Feature_HasV8_1MMainlineBit, },

  {Feature_HasMVEIntBit, Feature_IsBEBit, },

  {Feature_HasMVEIntBit, Feature_IsLEBit, },

  {Feature_HasNEONBit, Feature_HasV8Bit, },

  {Feature_HasNEONBit, Feature_HasV8_1aBit, },

  {Feature_HasNEONBit, Feature_HasV8_3aBit, },

  {Feature_HasNEONBit, Feature_HasVFP4Bit, },

  {Feature_HasNEONBit, Feature_IsBEBit, },

  {Feature_HasNEONBit, Feature_IsLEBit, },

  {Feature_HasNEONBit, Feature_UseNEONForFPBit, },

  {Feature_HasSHA2Bit, Feature_HasV8Bit, },

  {Feature_HasV5TBit, Feature_IsARMBit, },

  {Feature_HasV5TEBit, Feature_IsARMBit, },

  {Feature_HasV6Bit, Feature_IsARMBit, },

  {Feature_HasV6KBit, Feature_IsARMBit, },

  {Feature_HasV6MBit, Feature_IsThumbBit, },

  {Feature_HasV6T2Bit, Feature_IsARMBit, },

  {Feature_HasV7Bit, Feature_IsARMBit, },

  {Feature_HasV7ClrexBit, Feature_IsThumbBit, },

  {Feature_HasV8MBaselineBit, Feature_IsThumbBit, },

  {Feature_IsARMBit, Feature_NoV6Bit, },

  {Feature_IsARMBit, Feature_PreV8Bit, },

  {Feature_IsThumbBit, Feature_IsThumb1OnlyBit, },

  {Feature_IsThumbBit, Feature_IsWindowsBit, },

  {Feature_IsThumbBit, Feature_UseMovtBit, },

  {Feature_IsThumb2Bit, Feature_PreV8Bit, },

  {Feature_IsThumb2Bit, Feature_UseMulOpsBit, },

  {Feature_DontUseMovtBit, Feature_GenExecuteOnlyBit, Feature_IsThumb1OnlyBit, },

  {Feature_HasDSPBit, Feature_IsThumb2Bit, Feature_UseMulOpsBit, },

  {Feature_HasDivideInThumbBit, Feature_HasV8MBaselineBit, Feature_IsThumbBit, },

  {Feature_HasFPARMv8Bit, Feature_HasFullFP16Bit, Feature_HasNEONBit, },

  {Feature_HasFullFP16Bit, Feature_HasNEONBit, Feature_HasV8Bit, },

  {Feature_HasFullFP16Bit, Feature_HasNEONBit, Feature_HasV8_3aBit, },

  {Feature_HasFullFP16Bit, Feature_HasNEONBit, Feature_UseFPVMLxBit, },

  {Feature_HasFullFP16Bit, Feature_HasNEONBit, Feature_UseFusedMACBit, },

  {Feature_HasLOBBit, Feature_HasV8_1MMainlineBit, Feature_IsThumb2Bit, },

  {Feature_HasNEONBit, Feature_UseFPVMLxBit, Feature_UseNEONForFPBit, },

  {Feature_HasV5TEBit, Feature_IsARMBit, Feature_UseMulOpsBit, },

  {Feature_HasV6Bit, Feature_IsARMBit, Feature_UseMulOpsBit, },

  {Feature_HasV6Bit, Feature_IsThumbBit, Feature_IsThumb1OnlyBit, },

  {Feature_HasV6T2Bit, Feature_IsARMBit, Feature_UseMulOpsBit, },

  {Feature_HasVFP4Bit, Feature_UseFusedMACBit, Feature_UseNEONForFPBit, },

  {Feature_IsARMBit, Feature_NoV6Bit, Feature_UseMulOpsBit, },

};

// ComplexPattern predicates.

enum {

  GICP_Invalid,

};

// See constructor for table contents

ARMInstructionSelector::ComplexMatcherMemFn

ARMInstructionSelector::ComplexPredicateFns[] = {

  nullptr, // GICP_Invalid

};

// PatFrag predicates.

enum {

  GICXXPred_MI_Predicate_bf_inv_mask_imm = GICXXPred_Invalid + 1,

  GICXXPred_MI_Predicate_vfp_f32imm,

  GICXXPred_MI_Predicate_vfp_f64imm,

};

bool ARMInstructionSelector::testMIPredicate_MI(unsigned PredicateID, const MachineInstr & MI, const MatcherState &State) const {

  const MachineFunction &MF = *MI.getParent()->getParent();

  const MachineRegisterInfo &MRI = MF.getRegInfo();

  const auto &Operands = State.RecordedOperands;

  (void)Operands;

  (void)MRI;

  switch (PredicateID) {

  case GICXXPred_MI_Predicate_bf_inv_mask_imm: {

        // There's better methods of implementing this check. IntImmLeaf<> would be

        // equivalent and have less boilerplate but we need a test for C++

        // predicates and this one causes new rules to be imported into GlobalISel

        // without requiring additional features first.

        const auto &MO = MI.getOperand(1);

        if (!MO.isCImm())

          return false;

        return ARM::isBitFieldInvertedMask(MO.getCImm()->getZExtValue());

    llvm_unreachable("bf_inv_mask_imm should have returned");

  }

  case GICXXPred_MI_Predicate_vfp_f32imm: {

          const auto &MO = MI.getOperand(1);

          if (!MO.isFPImm())

            return false;

          return ARM_AM::getFP32Imm(MO.getFPImm()->getValueAPF()) != -1;

    llvm_unreachable("vfp_f32imm should have returned");

  }

  case GICXXPred_MI_Predicate_vfp_f64imm: {

          const auto &MO = MI.getOperand(1);

          if (!MO.isFPImm())

            return false;

          return ARM_AM::getFP64Imm(MO.getFPImm()->getValueAPF()) != -1;

    llvm_unreachable("vfp_f64imm should have returned");

  }

  }

  llvm_unreachable("Unknown predicate");

  return false;

}

// PatFrag predicates.

enum {

  GICXXPred_I64_Predicate_VectorIndex8 = GICXXPred_Invalid + 1,

  GICXXPred_I64_Predicate_VectorIndex16,

  GICXXPred_I64_Predicate_VectorIndex32,

  GICXXPred_I64_Predicate_VectorIndex64,

  GICXXPred_I64_Predicate_asr_imm,

  GICXXPred_I64_Predicate_imm0_7,

  GICXXPred_I64_Predicate_imm0_15,

  GICXXPred_I64_Predicate_imm0_31,

  GICXXPred_I64_Predicate_imm0_32,

  GICXXPred_I64_Predicate_imm0_63,

  GICXXPred_I64_Predicate_imm0_239,

  GICXXPred_I64_Predicate_imm0_255,

  GICXXPred_I64_Predicate_imm0_255_expr,

  GICXXPred_I64_Predicate_imm0_4095,

  GICXXPred_I64_Predicate_imm0_65535,

  GICXXPred_I64_Predicate_imm0_65535_expr,

  GICXXPred_I64_Predicate_imm0_65535_neg,

  GICXXPred_I64_Predicate_imm1_7,

  GICXXPred_I64_Predicate_imm1_15,

  GICXXPred_I64_Predicate_imm1_16,

  GICXXPred_I64_Predicate_imm1_31,

  GICXXPred_I64_Predicate_imm8,

  GICXXPred_I64_Predicate_imm8_255,

  GICXXPred_I64_Predicate_imm8_or_16,

  GICXXPred_I64_Predicate_imm16,

  GICXXPred_I64_Predicate_imm16_31,

  GICXXPred_I64_Predicate_imm24b,

  GICXXPred_I64_Predicate_imm32,

  GICXXPred_I64_Predicate_imm256_510,

  GICXXPred_I64_Predicate_imm_3b,

  GICXXPred_I64_Predicate_imm_4b,

  GICXXPred_I64_Predicate_imm_6b,

  GICXXPred_I64_Predicate_imm_7b,

  GICXXPred_I64_Predicate_imm_9b,

  GICXXPred_I64_Predicate_imm_11b,

  GICXXPred_I64_Predicate_imm_12b,

  GICXXPred_I64_Predicate_imm_13b,

  GICXXPred_I64_Predicate_imm_even,

  GICXXPred_I64_Predicate_imm_odd,

  GICXXPred_I64_Predicate_long_shift,

  GICXXPred_I64_Predicate_mod_imm,

  GICXXPred_I64_Predicate_pkh_asr_amt,

  GICXXPred_I64_Predicate_pkh_lsl_amt,

  GICXXPred_I64_Predicate_shr_imm8,

  GICXXPred_I64_Predicate_shr_imm16,

  GICXXPred_I64_Predicate_shr_imm32,

  GICXXPred_I64_Predicate_shr_imm64,

  GICXXPred_I64_Predicate_t2_so_imm,

  GICXXPred_I64_Predicate_t2_so_imm_neg,

};

bool ARMInstructionSelector::testImmPredicate_I64(unsigned PredicateID, int64_t Imm) const {

  switch (PredicateID) {

  case GICXXPred_I64_Predicate_VectorIndex8: {

      return ((uint64_t)Imm) < 8;

  }

  case GICXXPred_I64_Predicate_VectorIndex16: {

      return ((uint64_t)Imm) < 4;

  }

  case GICXXPred_I64_Predicate_VectorIndex32: {

      return ((uint64_t)Imm) < 2;

  }

  case GICXXPred_I64_Predicate_VectorIndex64: {

      return ((uint64_t)Imm) < 1;

  }

  case GICXXPred_I64_Predicate_asr_imm: {

     return Imm > 0 && Imm <= 32; 

  }

  case GICXXPred_I64_Predicate_imm0_7: {

      return Imm >= 0 && Imm < 8;

  }

  case GICXXPred_I64_Predicate_imm0_15: {

      return Imm >= 0 && Imm < 16;

  }

  case GICXXPred_I64_Predicate_imm0_31: {

      return Imm >= 0 && Imm < 32;

  }

  case GICXXPred_I64_Predicate_imm0_32: {

      return Imm >= 0 && Imm < 33;

  }

  case GICXXPred_I64_Predicate_imm0_63: {

      return Imm >= 0 && Imm < 64;

  }

  case GICXXPred_I64_Predicate_imm0_239: {

     return Imm >= 0 && Imm < 240; 

  }

  case GICXXPred_I64_Predicate_imm0_255: {

     return Imm >= 0 && Imm < 256; 

  }

  case GICXXPred_I64_Predicate_imm0_255_expr: {

     return Imm >= 0 && Imm < 256; 

  }

  case GICXXPred_I64_Predicate_imm0_4095: {

      return Imm >= 0 && Imm < 4096;

  }

  case GICXXPred_I64_Predicate_imm0_65535: {

      return Imm >= 0 && Imm < 65536;

  }

  case GICXXPred_I64_Predicate_imm0_65535_expr: {

      return Imm >= 0 && Imm < 65536;

  }

  case GICXXPred_I64_Predicate_imm0_65535_neg: {

      return -Imm >= 0 && -Imm < 65536;

  }

  case GICXXPred_I64_Predicate_imm1_7: {

     return Imm > 0 && Imm < 8; 

  }

  case GICXXPred_I64_Predicate_imm1_15: {

     return Imm > 0 && Imm < 16; 

  }

  case GICXXPred_I64_Predicate_imm1_16: {

        return Imm > 0 && Imm <= 16;

  }

  case GICXXPred_I64_Predicate_imm1_31: {

     return Imm > 0 && Imm < 32; 

  }

  case GICXXPred_I64_Predicate_imm8: {

     return Imm == 8; 

  }

  case GICXXPred_I64_Predicate_imm8_255: {

      return Imm >= 8 && Imm < 256;

  }

  case GICXXPred_I64_Predicate_imm8_or_16: {

     return Imm == 8 || Imm == 16;

  }

  case GICXXPred_I64_Predicate_imm16: {

     return Imm == 16; 

  }

  case GICXXPred_I64_Predicate_imm16_31: {

      return (int32_t)Imm >= 16 && (int32_t)Imm < 32;

  }

  case GICXXPred_I64_Predicate_imm24b: {

      return Imm >= 0 && Imm <= 0xffffff;

  }

  case GICXXPred_I64_Predicate_imm32: {

     return Imm == 32; 

  }

  case GICXXPred_I64_Predicate_imm256_510: {

      return Imm >= 256 && Imm < 511;

  }

  case GICXXPred_I64_Predicate_imm_3b: {

    { return Imm >= 0 && Imm < (1 << 3); }

    llvm_unreachable("imm_3b should have returned");

  }

  case GICXXPred_I64_Predicate_imm_4b: {

    { return Imm >= 0 && Imm < (1 << 4); }

    llvm_unreachable("imm_4b should have returned");

  }

  case GICXXPred_I64_Predicate_imm_6b: {

    { return Imm >= 0 && Imm < (1 << 6); }

    llvm_unreachable("imm_6b should have returned");

  }

  case GICXXPred_I64_Predicate_imm_7b: {

    { return Imm >= 0 && Imm < (1 << 7); }

    llvm_unreachable("imm_7b should have returned");

  }

  case GICXXPred_I64_Predicate_imm_9b: {

    { return Imm >= 0 && Imm < (1 << 9); }

    llvm_unreachable("imm_9b should have returned");

  }

  case GICXXPred_I64_Predicate_imm_11b: {

    { return Imm >= 0 && Imm < (1 << 11); }

    llvm_unreachable("imm_11b should have returned");

  }

  case GICXXPred_I64_Predicate_imm_12b: {

    { return Imm >= 0 && Imm < (1 << 12); }

    llvm_unreachable("imm_12b should have returned");

  }

  case GICXXPred_I64_Predicate_imm_13b: {

    { return Imm >= 0 && Imm < (1 << 13); }

    llvm_unreachable("imm_13b should have returned");

  }

  case GICXXPred_I64_Predicate_imm_even: {

     return (Imm & 1) == 0; 

  }

  case GICXXPred_I64_Predicate_imm_odd: {

     return (Imm & 1) == 1; 

  }

  case GICXXPred_I64_Predicate_long_shift: {

     return Imm > 0 && Imm <= 32; 

  }

  case GICXXPred_I64_Predicate_mod_imm: {

        return ARM_AM::getSOImmVal(Imm) != -1;

  }

  case GICXXPred_I64_Predicate_pkh_asr_amt: {

     return Imm > 0 && Imm <= 32; 

  }

  case GICXXPred_I64_Predicate_pkh_lsl_amt: {

     return Imm >= 0 && Imm < 32; 

  }

  case GICXXPred_I64_Predicate_shr_imm8: {

     return Imm > 0 && Imm <= 8; 

  }

  case GICXXPred_I64_Predicate_shr_imm16: {

     return Imm > 0 && Imm <= 16; 

  }

  case GICXXPred_I64_Predicate_shr_imm32: {

     return Imm > 0 && Imm <= 32; 

  }

  case GICXXPred_I64_Predicate_shr_imm64: {

     return Imm > 0 && Imm <= 64; 

  }

  case GICXXPred_I64_Predicate_t2_so_imm: {

        return ARM_AM::getT2SOImmVal(Imm) != -1;

  }

  case GICXXPred_I64_Predicate_t2_so_imm_neg: {

      return Imm && ARM_AM::getT2SOImmVal(-(uint32_t)Imm) != -1;

  }

  }

  llvm_unreachable("Unknown predicate");

  return false;

}

// PatFrag predicates.

bool ARMInstructionSelector::testImmPredicate_APFloat(unsigned PredicateID, const APFloat & Imm) const {

  llvm_unreachable("Unknown predicate");

  return false;

}

// PatFrag predicates.

enum {

  GICXXPred_APInt_Predicate_arm_i32imm = GICXXPred_Invalid + 1,

};

bool ARMInstructionSelector::testImmPredicate_APInt(unsigned PredicateID, const APInt & Imm) const {

  switch (PredicateID) {

  case GICXXPred_APInt_Predicate_arm_i32imm: {

      if (Subtarget->useMovt())

        return true;

      if (ARM_AM::isSOImmTwoPartVal(Imm.getZExtValue()))

        return true;

      return ARM_AM::isSOImmTwoPartValNeg(Imm.getZExtValue());

    llvm_unreachable("arm_i32imm should have returned");

  }

  }

  llvm_unreachable("Unknown predicate");

  return false;

}

bool ARMInstructionSelector::testSimplePredicate(unsigned) const {

    llvm_unreachable("ARMInstructionSelector does not support simple predicates!");

  return false;

}

// Custom renderers.

enum {

  GICR_Invalid,

  GICR_renderVFPF32Imm,

  GICR_renderVFPF64Imm,

};

ARMInstructionSelector::CustomRendererFn

ARMInstructionSelector::CustomRenderers[] = {

  nullptr, // GICR_Invalid

  &ARMInstructionSelector::renderVFPF32Imm,

  &ARMInstructionSelector::renderVFPF64Imm,

};

bool ARMInstructionSelector::selectImpl(MachineInstr &I, CodeGenCoverage &CoverageInfo) const {

  const PredicateBitset AvailableFeatures = getAvailableFeatures();

  MachineIRBuilder B(I);

  State.MIs.clear();

  State.MIs.push_back(&I);

  if (executeMatchTable(*this, State, ExecInfo, B, getMatchTable(), TII, MF->getRegInfo(), TRI, RBI, AvailableFeatures, &CoverageInfo)) {

    return true;

  }

  return false;

}

void ARMInstructionSelector::runCustomAction(unsigned, const MatcherState&, NewMIVector &) const {

    llvm_unreachable("ARMInstructionSelector does not support custom C++ actions!");

}

#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__

#define GIMT_Encode2(Val) uint8_t(Val), uint8_t((uint16_t)Val >> 8)

#define GIMT_Encode4(Val) uint8_t(Val), uint8_t((uint32_t)Val >> 8), uint8_t((uint32_t)Val >> 16), uint8_t((uint32_t)Val >> 24)

#define GIMT_Encode8(Val) uint8_t(Val), uint8_t((uint64_t)Val >> 8), uint8_t((uint64_t)Val >> 16), uint8_t((uint64_t)Val >> 24),  uint8_t((uint64_t)Val >> 32), uint8_t((uint64_t)Val >> 40), uint8_t((uint64_t)Val >> 48), uint8_t((uint64_t)Val >> 56)

#else

#define GIMT_Encode2(Val) uint8_t((uint16_t)Val >> 8), uint8_t(Val)

#define GIMT_Encode4(Val) uint8_t((uint32_t)Val >> 24), uint8_t((uint32_t)Val >> 16), uint8_t((uint32_t)Val >> 8), uint8_t(Val)

#define GIMT_Encode8(Val) uint8_t((uint64_t)Val >> 56), uint8_t((uint64_t)Val >> 48), uint8_t((uint64_t)Val >> 40), uint8_t((uint64_t)Val >> 32),  uint8_t((uint64_t)Val >> 24), uint8_t((uint64_t)Val >> 16), uint8_t((uint64_t)Val >> 8), uint8_t(Val)

#endif

const uint8_t *ARMInstructionSelector::getMatchTable() const {

  constexpr static uint8_t MatchTable0[] = {

    GIM_SwitchOpcode, /*MI*/0, /*[*/GIMT_Encode2(47), GIMT_Encode2(269), /*)*//*default:*//*Label 74*/ GIMT_Encode4(157540),

    /*TargetOpcode::G_ADD*//*Label 0*/ GIMT_Encode4(898),

    /*TargetOpcode::G_SUB*//*Label 1*/ GIMT_Encode4(10663),

    /*TargetOpcode::G_MUL*//*Label 2*/ GIMT_Encode4(14339),

    /*TargetOpcode::G_SDIV*//*Label 3*/ GIMT_Encode4(15397),

    /*TargetOpcode::G_UDIV*//*Label 4*/ GIMT_Encode4(15522), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0),

    /*TargetOpcode::G_AND*//*Label 5*/ GIMT_Encode4(15647),

    /*TargetOpcode::G_OR*//*Label 6*/ GIMT_Encode4(19058),

    /*TargetOpcode::G_XOR*//*Label 7*/ GIMT_Encode4(25513), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0),

    /*TargetOpcode::G_CONCAT_VECTORS*//*Label 8*/ GIMT_Encode4(27380), GIMT_Encode4(0), GIMT_Encode4(0),

    /*TargetOpcode::G_BITCAST*//*Label 9*/ GIMT_Encode4(27889), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0),

    /*TargetOpcode::G_INTRINSIC_TRUNC*//*Label 10*/ GIMT_Encode4(41273),

    /*TargetOpcode::G_INTRINSIC_ROUND*//*Label 11*/ GIMT_Encode4(41620), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0),

    /*TargetOpcode::G_SEXTLOAD*//*Label 12*/ GIMT_Encode4(41913), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0),

    /*TargetOpcode::G_FENCE*//*Label 13*/ GIMT_Encode4(42088), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0),

    /*TargetOpcode::G_INTRINSIC*//*Label 14*/ GIMT_Encode4(42114),

    /*TargetOpcode::G_INTRINSIC_W_SIDE_EFFECTS*//*Label 15*/ GIMT_Encode4(112629), GIMT_Encode4(0), GIMT_Encode4(0),

    /*TargetOpcode::G_ANYEXT*//*Label 16*/ GIMT_Encode4(122223),

    /*TargetOpcode::G_TRUNC*//*Label 17*/ GIMT_Encode4(122414),

    /*TargetOpcode::G_CONSTANT*//*Label 18*/ GIMT_Encode4(122605),

    /*TargetOpcode::G_FCONSTANT*//*Label 19*/ GIMT_Encode4(122891), GIMT_Encode4(0), GIMT_Encode4(0),

    /*TargetOpcode::G_SEXT*//*Label 20*/ GIMT_Encode4(123001), GIMT_Encode4(0),

    /*TargetOpcode::G_ZEXT*//*Label 21*/ GIMT_Encode4(123192),

    /*TargetOpcode::G_SHL*//*Label 22*/ GIMT_Encode4(123845),

    /*TargetOpcode::G_LSHR*//*Label 23*/ GIMT_Encode4(123980),

    /*TargetOpcode::G_ASHR*//*Label 24*/ GIMT_Encode4(124052), GIMT_Encode4(0), GIMT_Encode4(0),

    /*TargetOpcode::G_ROTR*//*Label 25*/ GIMT_Encode4(124317), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0),

    /*TargetOpcode::G_UMULH*//*Label 26*/ GIMT_Encode4(124644),

    /*TargetOpcode::G_SMULH*//*Label 27*/ GIMT_Encode4(124931),

    /*TargetOpcode::G_UADDSAT*//*Label 28*/ GIMT_Encode4(125367),

    /*TargetOpcode::G_SADDSAT*//*Label 29*/ GIMT_Encode4(126165),

    /*TargetOpcode::G_USUBSAT*//*Label 30*/ GIMT_Encode4(127724),

    /*TargetOpcode::G_SSUBSAT*//*Label 31*/ GIMT_Encode4(128522), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0),

    /*TargetOpcode::G_FADD*//*Label 32*/ GIMT_Encode4(129761),

    /*TargetOpcode::G_FSUB*//*Label 33*/ GIMT_Encode4(132278),

    /*TargetOpcode::G_FMUL*//*Label 34*/ GIMT_Encode4(134131),

    /*TargetOpcode::G_FMA*//*Label 35*/ GIMT_Encode4(135288), GIMT_Encode4(0),

    /*TargetOpcode::G_FDIV*//*Label 36*/ GIMT_Encode4(137492), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0), GIMT_Encode4(0),

    /*TargetOpcode::G_FNEG*//*Label 37*/ GIMT_Encode4(137702),

    /*TargetOpcode::G_FPEXT*//*Label 38*/ GIMT_Encode4(139435),

    /*TargetOpcode::G_FPTRUNC*//*Label 39*/ GIMT_Encode4(139705),

    /*TargetOpcode::G_FPTOSI*//*Label 40*/ GIMT_Encode4(140015),