[MIPS][CodeGen][NFC] Use ArrayRef in TargetLowering functions

[Miss_Grape]

ping

[Miss_Grape]

ping

llvm/lib/Target/Mips/MipsISelLowering.cpp

MipsTargetLowering::MipsTargetLowering(const MipsTargetMachine &TM,
   // The cmp.cond.fmt instruction in MIPS32r6/MIPS64r6 uses 0 and -1 like MSA
   // does. Integer booleans still use 0 and 1.
   if (Subtarget.hasMips32r6())
     setBooleanContents(ZeroOrOneBooleanContent,
                        ZeroOrNegativeOneBooleanContent);
 
   // Load extented operations for i1 types must be promoted
   for (MVT VT : MVT::integer_valuetypes()) {
-    setLoadExtAction(ISD::EXTLOAD,  VT, MVT::i1,  Promote);
-    setLoadExtAction(ISD::ZEXTLOAD, VT, MVT::i1,  Promote);
-    setLoadExtAction(ISD::SEXTLOAD, VT, MVT::i1,  Promote);
+    setLoadExtAction({ISD::EXTLOAD, ISD::ZEXTLOAD, ISD::SEXTLOAD}, VT, MVT::i1,
+                     Promote);
   }
 
   // MIPS doesn't have extending float->double load/store.  Set LoadExtAction
   // for f32, f16
   for (MVT VT : MVT::fp_valuetypes()) {
     setLoadExtAction(ISD::EXTLOAD, VT, MVT::f32, Expand);
     setLoadExtAction(ISD::EXTLOAD, VT, MVT::f16, Expand);
   }
MipsTargetLowering::MipsTargetLowering(const MipsTargetMachine &TM,
   // Used by legalize types to correctly generate the setcc result.
   // Without this, every float setcc comes with a AND/OR with the result,
   // we don't want this, since the fpcmp result goes to a flag register,
   // which is used implicitly by brcond and select operations.
   AddPromotedToType(ISD::SETCC, MVT::i1, MVT::i32);
 
   // Mips Custom Operations
   setOperationAction(ISD::BR_JT,              MVT::Other, Expand);
-  setOperationAction(ISD::GlobalAddress,      MVT::i32,   Custom);
-  setOperationAction(ISD::BlockAddress,       MVT::i32,   Custom);
-  setOperationAction(ISD::GlobalTLSAddress,   MVT::i32,   Custom);
-  setOperationAction(ISD::JumpTable,          MVT::i32,   Custom);
-  setOperationAction(ISD::ConstantPool,       MVT::i32,   Custom);
-  setOperationAction(ISD::SELECT,             MVT::f32,   Custom);
-  setOperationAction(ISD::SELECT,             MVT::f64,   Custom);
-  setOperationAction(ISD::SELECT,             MVT::i32,   Custom);
-  setOperationAction(ISD::SETCC,              MVT::f32,   Custom);
-  setOperationAction(ISD::SETCC,              MVT::f64,   Custom);
-  setOperationAction(ISD::BRCOND,             MVT::Other, Custom);
-  setOperationAction(ISD::FCOPYSIGN,          MVT::f32,   Custom);
-  setOperationAction(ISD::FCOPYSIGN,          MVT::f64,   Custom);
-  setOperationAction(ISD::FP_TO_SINT,         MVT::i32,   Custom);
+  setOperationAction({ISD::GlobalAddress, ISD::BlockAddress,
+                      ISD::GlobalTLSAddress, ISD::JumpTable, ISD::ConstantPool,
+                      ISD::SELECT, ISD::FP_TO_SINT},
+                     MVT::i32, Custom);
+  setOperationAction({ISD::SELECT, ISD::SETCC, ISD::FCOPYSIGN},
+                     {MVT::f32, MVT::f64}, Custom);
+  setOperationAction(ISD::BRCOND, MVT::Other, Custom);
 
   if (!(TM.Options.NoNaNsFPMath || Subtarget.inAbs2008Mode())) {
-    setOperationAction(ISD::FABS, MVT::f32, Custom);
-    setOperationAction(ISD::FABS, MVT::f64, Custom);
+    setOperationAction(ISD::FABS, {MVT::f32, MVT::f64}, Custom);
   }
 
   if (Subtarget.isGP64bit()) {
-    setOperationAction(ISD::GlobalAddress,      MVT::i64,   Custom);
-    setOperationAction(ISD::BlockAddress,       MVT::i64,   Custom);
-    setOperationAction(ISD::GlobalTLSAddress,   MVT::i64,   Custom);
-    setOperationAction(ISD::JumpTable,          MVT::i64,   Custom);
-    setOperationAction(ISD::ConstantPool,       MVT::i64,   Custom);
-    setOperationAction(ISD::SELECT,             MVT::i64,   Custom);
-    setOperationAction(ISD::LOAD,               MVT::i64,   Custom);
-    setOperationAction(ISD::STORE,              MVT::i64,   Custom);
-    setOperationAction(ISD::FP_TO_SINT,         MVT::i64,   Custom);
-    setOperationAction(ISD::SHL_PARTS,          MVT::i64,   Custom);
-    setOperationAction(ISD::SRA_PARTS,          MVT::i64,   Custom);
-    setOperationAction(ISD::SRL_PARTS,          MVT::i64,   Custom);
+    setOperationAction(
+        {
+            ISD::GlobalAddress,
+            ISD::BlockAddress,
+            ISD::GlobalTLSAddress,
+            ISD::JumpTable,
+            ISD::ConstantPool,
+            ISD::SELECT,
+            ISD::LOAD,
+            ISD::STORE,
+            ISD::FP_TO_SINT,
+            ISD::SHL_PARTS,
+            ISD::SRA_PARTS,
+            ISD::SRL_PARTS,
+        },
+        MVT::i64, Custom);
   }
 
   if (!Subtarget.isGP64bit()) {
-    setOperationAction(ISD::SHL_PARTS,          MVT::i32,   Custom);
-    setOperationAction(ISD::SRA_PARTS,          MVT::i32,   Custom);
-    setOperationAction(ISD::SRL_PARTS,          MVT::i32,   Custom);
+    setOperationAction({ISD::SHL_PARTS, ISD::SRA_PARTS, ISD::SRL_PARTS},
+                       MVT::i32, Custom);
   }
 
   setOperationAction(ISD::EH_DWARF_CFA,         MVT::i32,   Custom);
   if (Subtarget.isGP64bit())
     setOperationAction(ISD::EH_DWARF_CFA,       MVT::i64,   Custom);
 
-  setOperationAction(ISD::SDIV, MVT::i32, Expand);
-  setOperationAction(ISD::SREM, MVT::i32, Expand);
-  setOperationAction(ISD::UDIV, MVT::i32, Expand);
-  setOperationAction(ISD::UREM, MVT::i32, Expand);
-  setOperationAction(ISD::SDIV, MVT::i64, Expand);
-  setOperationAction(ISD::SREM, MVT::i64, Expand);
-  setOperationAction(ISD::UDIV, MVT::i64, Expand);
-  setOperationAction(ISD::UREM, MVT::i64, Expand);
+  setOperationAction({ISD::SDIV, ISD::SREM, ISD::UDIV, ISD::UREM},
+                     {MVT::i32, MVT::i64}, Expand);
 
   // Operations not directly supported by Mips.
-  setOperationAction(ISD::BR_CC,             MVT::f32,   Expand);
-  setOperationAction(ISD::BR_CC,             MVT::f64,   Expand);
-  setOperationAction(ISD::BR_CC,             MVT::i32,   Expand);
-  setOperationAction(ISD::BR_CC,             MVT::i64,   Expand);
-  setOperationAction(ISD::SELECT_CC,         MVT::i32,   Expand);
-  setOperationAction(ISD::SELECT_CC,         MVT::i64,   Expand);
-  setOperationAction(ISD::SELECT_CC,         MVT::f32,   Expand);
-  setOperationAction(ISD::SELECT_CC,         MVT::f64,   Expand);
-  setOperationAction(ISD::UINT_TO_FP,        MVT::i32,   Expand);
-  setOperationAction(ISD::UINT_TO_FP,        MVT::i64,   Expand);
-  setOperationAction(ISD::FP_TO_UINT,        MVT::i32,   Expand);
-  setOperationAction(ISD::FP_TO_UINT,        MVT::i64,   Expand);
+  setOperationAction({ISD::BR_CC, ISD::SELECT_CC},
+                     {MVT::f32, MVT::f64, MVT::i32, MVT::i64}, Expand);
+  setOperationAction({ISD::UINT_TO_FP, ISD::FP_TO_UINT}, {MVT::i32, MVT::i64},
+                     Expand);
   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i1,    Expand);
   if (Subtarget.hasCnMips()) {
-    setOperationAction(ISD::CTPOP,           MVT::i32,   Legal);
-    setOperationAction(ISD::CTPOP,           MVT::i64,   Legal);
+    setOperationAction(ISD::CTPOP, {MVT::i32, MVT::i64}, Legal);
   } else {
-    setOperationAction(ISD::CTPOP,           MVT::i32,   Expand);
-    setOperationAction(ISD::CTPOP,           MVT::i64,   Expand);
+    setOperationAction(ISD::CTPOP, {MVT::i32, MVT::i64}, Expand);
   }
-  setOperationAction(ISD::CTTZ,              MVT::i32,   Expand);
-  setOperationAction(ISD::CTTZ,              MVT::i64,   Expand);
-  setOperationAction(ISD::ROTL,              MVT::i32,   Expand);
-  setOperationAction(ISD::ROTL,              MVT::i64,   Expand);
-  setOperationAction(ISD::DYNAMIC_STACKALLOC, MVT::i32,  Expand);
-  setOperationAction(ISD::DYNAMIC_STACKALLOC, MVT::i64,  Expand);
+  setOperationAction({ISD::CTTZ, ISD::ROTL, ISD::DYNAMIC_STACKALLOC},
+                     {MVT::i32, MVT::i64}, Expand);
 
   if (!Subtarget.hasMips32r2())
     setOperationAction(ISD::ROTR, MVT::i32,   Expand);
 
   if (!Subtarget.hasMips64r2())
     setOperationAction(ISD::ROTR, MVT::i64,   Expand);
 
-  setOperationAction(ISD::FSIN,              MVT::f32,   Expand);
-  setOperationAction(ISD::FSIN,              MVT::f64,   Expand);
-  setOperationAction(ISD::FCOS,              MVT::f32,   Expand);
-  setOperationAction(ISD::FCOS,              MVT::f64,   Expand);
-  setOperationAction(ISD::FSINCOS,           MVT::f32,   Expand);
-  setOperationAction(ISD::FSINCOS,           MVT::f64,   Expand);
-  setOperationAction(ISD::FPOW,              MVT::f32,   Expand);
-  setOperationAction(ISD::FPOW,              MVT::f64,   Expand);
-  setOperationAction(ISD::FLOG,              MVT::f32,   Expand);
-  setOperationAction(ISD::FLOG2,             MVT::f32,   Expand);
-  setOperationAction(ISD::FLOG10,            MVT::f32,   Expand);
-  setOperationAction(ISD::FEXP,              MVT::f32,   Expand);
-  setOperationAction(ISD::FMA,               MVT::f32,   Expand);
-  setOperationAction(ISD::FMA,               MVT::f64,   Expand);
-  setOperationAction(ISD::FREM,              MVT::f32,   Expand);
-  setOperationAction(ISD::FREM,              MVT::f64,   Expand);
+  setOperationAction({ISD::FSIN, ISD::FCOS, ISD::FSINCOS, ISD::FSINCOS,
+                      ISD::FPOW, ISD::FMA, ISD::FREM},
+                     {MVT::f32, MVT::f64}, Expand);
+  setOperationAction({ISD::FLOG, ISD::FLOG2, ISD::FLOG10, ISD::FEXP}, MVT::f32,
+                     Expand);
 
   // Lower f16 conversion operations into library calls
-  setOperationAction(ISD::FP16_TO_FP,        MVT::f32,   Expand);
-  setOperationAction(ISD::FP_TO_FP16,        MVT::f32,   Expand);
-  setOperationAction(ISD::FP16_TO_FP,        MVT::f64,   Expand);
-  setOperationAction(ISD::FP_TO_FP16,        MVT::f64,   Expand);
+  setOperationAction({ISD::FP16_TO_FP, ISD::FP_TO_FP16}, {MVT::f32, MVT::f64},
+                     Expand);
 
   setOperationAction(ISD::EH_RETURN, MVT::Other, Custom);
 
-  setOperationAction(ISD::VASTART,           MVT::Other, Custom);
-  setOperationAction(ISD::VAARG,             MVT::Other, Custom);
-  setOperationAction(ISD::VACOPY,            MVT::Other, Expand);
-  setOperationAction(ISD::VAEND,             MVT::Other, Expand);
+  setOperationAction({ISD::VASTART, ISD::VAARG}, MVT::Other, Custom);
+  setOperationAction({ISD::VACOPY, ISD::VAEND}, MVT::Other, Expand);
 
   // Use the default for now
-  setOperationAction(ISD::STACKSAVE,         MVT::Other, Expand);
-  setOperationAction(ISD::STACKRESTORE,      MVT::Other, Expand);
+  setOperationAction({ISD::STACKSAVE, ISD::STACKRESTORE}, MVT::Other, Expand);
 
   if (!Subtarget.isGP64bit()) {
-    setOperationAction(ISD::ATOMIC_LOAD,     MVT::i64,   Expand);
-    setOperationAction(ISD::ATOMIC_STORE,    MVT::i64,   Expand);
+    setOperationAction({ISD::ATOMIC_LOAD, ISD::ATOMIC_STORE}, MVT::i64, Expand);
   }
 
   if (!Subtarget.hasMips32r2()) {
-    setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i8,  Expand);
-    setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i16, Expand);
+    setOperationAction(ISD::SIGN_EXTEND_INREG, {MVT::i8, MVT::i16}, Expand);
   }
 
   // MIPS16 lacks MIPS32's clz and clo instructions.
   if (!Subtarget.hasMips32() || Subtarget.inMips16Mode())
     setOperationAction(ISD::CTLZ, MVT::i32, Expand);
   if (!Subtarget.hasMips64())
     setOperationAction(ISD::CTLZ, MVT::i64, Expand);
 
   if (!Subtarget.hasMips32r2())
     setOperationAction(ISD::BSWAP, MVT::i32, Expand);
   if (!Subtarget.hasMips64r2())
     setOperationAction(ISD::BSWAP, MVT::i64, Expand);
 
   if (Subtarget.isGP64bit()) {
-    setLoadExtAction(ISD::SEXTLOAD, MVT::i64, MVT::i32, Custom);
-    setLoadExtAction(ISD::ZEXTLOAD, MVT::i64, MVT::i32, Custom);
-    setLoadExtAction(ISD::EXTLOAD, MVT::i64, MVT::i32, Custom);
+    setLoadExtAction({ISD::SEXTLOAD, ISD::ZEXTLOAD, ISD::EXTLOAD}, MVT::i64,
+                     MVT::i32, Custom);
     setTruncStoreAction(MVT::i64, MVT::i32, Custom);
   }
 
   setOperationAction(ISD::TRAP, MVT::Other, Legal);
 
   setTargetDAGCombine({ISD::SDIVREM, ISD::UDIVREM, ISD::SELECT, ISD::AND,
                        ISD::OR, ISD::ADD, ISD::SUB, ISD::AssertZext, ISD::SHL});
 
   if (ABI.IsO32()) {
     // These libcalls are not available in 32-bit.
-    setLibcallName(RTLIB::SHL_I128, nullptr);
-    setLibcallName(RTLIB::SRL_I128, nullptr);
-    setLibcallName(RTLIB::SRA_I128, nullptr);
-    setLibcallName(RTLIB::MUL_I128, nullptr);
-    setLibcallName(RTLIB::MULO_I64, nullptr);
-    setLibcallName(RTLIB::MULO_I128, nullptr);
+    setLibcallName({RTLIB::SHL_I128, RTLIB::SRL_I128, RTLIB::SRA_I128,
+                    RTLIB::MUL_I128, RTLIB::MULO_I64, RTLIB::MULO_I128},
+                   nullptr);
   }
 
   setMinFunctionAlignment(Subtarget.isGP64bit() ? Align(8) : Align(4));
 
   // The arguments on the stack are defined in terms of 4-byte slots on O32
   // and 8-byte slots on N32/N64.
   setMinStackArgumentAlignment((ABI.IsN32() || ABI.IsN64()) ? Align(8)
                                                             : Align(4));