Use constructor explicitly

Author: arcbbb

llvm/include/llvm/CodeGen/BasicTTIImpl.h

@@ -1606,7 +1606,9 @@ class BasicTTIImplBase : public TargetTransformInfoImplCRTPBase<T> {
     unsigned IID = Opcode == Instruction::Load ? Intrinsic::masked_gather
                                                : Intrinsic::masked_scatter;
     return thisT()->getGatherScatterOpCost(
-        {IID, DataTy, Ptr, VariableMask, Alignment, I}, CostKind);
+        MemIntrinsicCostAttributes(IID, DataTy, Ptr, VariableMask, Alignment,
+                                   I),
+        CostKind);
   }
 
   InstructionCost getInterleavedMemoryOpCost(
@@ -1833,8 +1835,9 @@ class BasicTTIImplBase : public TargetTransformInfoImplCRTPBase<T> {
           Alignment = VPI->getPointerAlignment().valueOrOne();
         bool VarMask = isa<Constant>(ICA.getArgs()[2]);
         return thisT()->getGatherScatterOpCost(
-            {ICA.getID(), ICA.getArgTypes()[0], ICA.getArgs()[1], VarMask,
-             Alignment, nullptr},
+            MemIntrinsicCostAttributes(ICA.getID(), ICA.getArgTypes()[0],
+                                       ICA.getArgs()[1], VarMask, Alignment,
+                                       nullptr),
             CostKind);
       }
       if (ICA.getID() == Intrinsic::vp_gather) {
@@ -1850,8 +1853,9 @@ class BasicTTIImplBase : public TargetTransformInfoImplCRTPBase<T> {
           Alignment = VPI->getPointerAlignment().valueOrOne();
         bool VarMask = isa<Constant>(ICA.getArgs()[1]);
         return thisT()->getGatherScatterOpCost(
-            {ICA.getID(), ICA.getReturnType(), ICA.getArgs()[0], VarMask,
-             Alignment, nullptr},
+            MemIntrinsicCostAttributes(ICA.getID(), ICA.getReturnType(),
+                                       ICA.getArgs()[0], VarMask, Alignment,
+                                       nullptr),
             CostKind);
       }
 
@@ -1958,15 +1962,18 @@ class BasicTTIImplBase : public TargetTransformInfoImplCRTPBase<T> {
       bool VarMask = !isa<Constant>(Mask);
       Align Alignment = I->getParamAlign(1).valueOrOne();
       return thisT()->getGatherScatterOpCost(
-          {IID, ICA.getArgTypes()[0], Args[1], VarMask, Alignment, I},
+          MemIntrinsicCostAttributes(IID, ICA.getArgTypes()[0], Args[1],
+                                     VarMask, Alignment, I),
           CostKind);
     }
     case Intrinsic::masked_gather: {
       const Value *Mask = Args[1];
       bool VarMask = !isa<Constant>(Mask);
       Align Alignment = I->getParamAlign(0).valueOrOne();
       return thisT()->getGatherScatterOpCost(
-          {IID, RetTy, Args[0], VarMask, Alignment, I}, CostKind);
+          MemIntrinsicCostAttributes(IID, RetTy, Args[0], VarMask, Alignment,
+                                     I),
+          CostKind);
     }
     case Intrinsic::masked_compressstore: {
       const Value *Data = Args[0];

llvm/lib/Transforms/Vectorize/LoopVectorize.cpp

@@ -5318,7 +5318,8 @@ LoopVectorizationCostModel::getGatherScatterCost(Instruction *I,
                      : Intrinsic::masked_scatter;
   return TTI.getAddressComputationCost(PtrTy, nullptr, nullptr, CostKind) +
          TTI.getGatherScatterOpCost(
-             {IID, VectorTy, Ptr, Legal->isMaskRequired(I), Alignment, I},
+             MemIntrinsicCostAttributes(IID, VectorTy, Ptr,
+                                        Legal->isMaskRequired(I), Alignment, I),
              CostKind);
 }
 

llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp

@@ -7189,10 +7189,11 @@ BoUpSLP::LoadsState BoUpSLP::canVectorizeLoads(
         ScalarGEPCost;
     // The cost of masked gather.
     InstructionCost MaskedGatherCost =
-        TTI.getGatherScatterOpCost({Intrinsic::masked_gather, VecTy,
-                                    cast<LoadInst>(VL0)->getPointerOperand(),
-                                    /*VariableMask=*/false, CommonAlignment},
-                                   CostKind) +
+        TTI.getGatherScatterOpCost(
+            MemIntrinsicCostAttributes(Intrinsic::masked_gather, VecTy,
+                                       cast<LoadInst>(VL0)->getPointerOperand(),
+                                       /*VariableMask=*/false, CommonAlignment),
+            CostKind) +
         (ProfitableGatherPointers ? 0 : VectorGEPCost);
     InstructionCost GatherCost =
         getScalarizationOverhead(TTI, ScalarTy, VecTy, DemandedElts,
@@ -7315,12 +7316,13 @@ BoUpSLP::LoadsState BoUpSLP::canVectorizeLoads(
                                         {}, CostKind);
           break;
         case LoadsState::ScatterVectorize:
-          VecLdCost +=
-              TTI.getGatherScatterOpCost(
-                  {Intrinsic::masked_gather, SubVecTy, LI0->getPointerOperand(),
-                   /*VariableMask=*/false, CommonAlignment},
-                  CostKind) +
-              VectorGEPCost;
+          VecLdCost += TTI.getGatherScatterOpCost(
+                           MemIntrinsicCostAttributes(
+                               Intrinsic::masked_gather, SubVecTy,
+                               LI0->getPointerOperand(),
+                               /*VariableMask=*/false, CommonAlignment),
+                           CostKind) +
+                       VectorGEPCost;
           break;
         case LoadsState::Gather:
           // Gathers are already calculated - ignore.
@@ -15126,8 +15128,9 @@ BoUpSLP::getEntryCost(const TreeEntry *E, ArrayRef<Value *> VectorizedVals,
         Align CommonAlignment =
             computeCommonAlignment<LoadInst>(UniqueValues.getArrayRef());
         VecLdCost = TTI->getGatherScatterOpCost(
-            {Intrinsic::masked_gather, VecTy, LI0->getPointerOperand(),
-             /*VariableMask=*/false, CommonAlignment},
+            MemIntrinsicCostAttributes(Intrinsic::masked_gather, VecTy,
+                                       LI0->getPointerOperand(),
+                                       /*VariableMask=*/false, CommonAlignment),
             CostKind);
         break;
       }

llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp

@@ -3591,7 +3591,9 @@ InstructionCost VPWidenMemoryRecipe::computeCost(ElementCount VF,
     return Ctx.TTI.getAddressComputationCost(PtrTy, nullptr, nullptr,
                                              Ctx.CostKind) +
            Ctx.TTI.getGatherScatterOpCost(
-               {IID, Ty, Ptr, IsMasked, Alignment, &Ingredient}, Ctx.CostKind);
+               MemIntrinsicCostAttributes(IID, Ty, Ptr, IsMasked, Alignment,
+                                          &Ingredient),
+               Ctx.CostKind);
   }
 
   InstructionCost Cost = 0;