review comments

- change code pattern to avoid calling TTI if we don't have a target
specific intrinsics
  - change type from unsigned to int

Author: inbelic

llvm/include/llvm/Analysis/TargetTransformInfo.h

@@ -897,8 +897,7 @@ class TargetTransformInfo {
                                           unsigned ScalarOpdIdx) const;
 
   bool isVectorIntrinsicWithOverloadTypeAtArg(Intrinsic::ID ID,
-                                              unsigned ScalarOpdIdx,
-                                              bool Default) const;
+                                              int ScalarOpdIdx) const;
 
   /// Estimate the overhead of scalarizing an instruction. Insert and Extract
   /// are set if the demanded result elements need to be inserted and/or
@@ -1974,8 +1973,7 @@ class TargetTransformInfo::Concept {
   virtual bool isTargetIntrinsicWithScalarOpAtArg(Intrinsic::ID ID,
                                                   unsigned ScalarOpdIdx) = 0;
   virtual bool isVectorIntrinsicWithOverloadTypeAtArg(Intrinsic::ID ID,
-                                                      unsigned ScalarOpdIdx,
-                                                      bool Default) = 0;
+                                                      int ScalarOpdIdx) = 0;
   virtual InstructionCost getScalarizationOverhead(VectorType *Ty,
                                                    const APInt &DemandedElts,
                                                    bool Insert, bool Extract,
@@ -2538,10 +2536,8 @@ class TargetTransformInfo::Model final : public TargetTransformInfo::Concept {
   }
 
   bool isVectorIntrinsicWithOverloadTypeAtArg(Intrinsic::ID ID,
-                                              unsigned ScalarOpdIdx,
-                                              bool Default) override {
-    return Impl.isVectorIntrinsicWithOverloadTypeAtArg(ID, ScalarOpdIdx,
-                                                       Default);
+                                              int ScalarOpdIdx) override {
+    return Impl.isVectorIntrinsicWithOverloadTypeAtArg(ID, ScalarOpdIdx);
   }
 
   InstructionCost getScalarizationOverhead(VectorType *Ty,

llvm/include/llvm/Analysis/TargetTransformInfoImpl.h

@@ -393,9 +393,8 @@ class TargetTransformInfoImplBase {
   }
 
   bool isVectorIntrinsicWithOverloadTypeAtArg(Intrinsic::ID ID,
-                                              unsigned ScalarOpdIdx,
-                                              bool Default) const {
-    return Default;
+                                              int ScalarOpdIdx) const {
+    return ScalarOpdIdx == -1;
   }
 
   InstructionCost getScalarizationOverhead(VectorType *Ty,

llvm/include/llvm/CodeGen/BasicTTIImpl.h

@@ -799,9 +799,8 @@ class BasicTTIImplBase : public TargetTransformInfoImplCRTPBase<T> {
   }
 
   bool isVectorIntrinsicWithOverloadTypeAtArg(Intrinsic::ID ID,
-                                              unsigned ScalarOpdIdx,
-                                              bool Default) const {
-    return Default;
+                                              int ScalarOpdIdx) const {
+    return ScalarOpdIdx == -1;
   }
 
   /// Helper wrapper for the DemandedElts variant of getScalarizationOverhead.

llvm/lib/Analysis/TargetTransformInfo.cpp

@@ -613,9 +613,8 @@ bool TargetTransformInfo::isTargetIntrinsicWithScalarOpAtArg(
 }
 
 bool TargetTransformInfo::isVectorIntrinsicWithOverloadTypeAtArg(
-    Intrinsic::ID ID, unsigned ScalarOpdIdx, bool Default) const {
-  return TTIImpl->isVectorIntrinsicWithOverloadTypeAtArg(ID, ScalarOpdIdx,
-                                                         Default);
+    Intrinsic::ID ID, int ScalarOpdIdx) const {
+  return TTIImpl->isVectorIntrinsicWithOverloadTypeAtArg(ID, ScalarOpdIdx);
 }
 
 InstructionCost TargetTransformInfo::getScalarizationOverhead(

llvm/lib/Target/DirectX/DirectXTargetTransformInfo.cpp

@@ -25,11 +25,11 @@ bool DirectXTTIImpl::isTargetIntrinsicWithScalarOpAtArg(Intrinsic::ID ID,
   }
 }
 
-bool DirectXTTIImpl::isVectorIntrinsicWithOverloadTypeAtArg(
-    Intrinsic::ID ID, unsigned ScalarOpdIdx, bool Default) {
+bool DirectXTTIImpl::isVectorIntrinsicWithOverloadTypeAtArg(Intrinsic::ID ID,
+                                                            int ScalarOpdIdx) {
   switch (ID) {
   default:
-    return Default;
+    return ScalarOpdIdx == -1;
   }
 }
 

llvm/lib/Target/DirectX/DirectXTargetTransformInfo.h

@@ -38,8 +38,7 @@ class DirectXTTIImpl : public BasicTTIImplBase<DirectXTTIImpl> {
   bool isTargetIntrinsicWithScalarOpAtArg(Intrinsic::ID ID,
                                           unsigned ScalarOpdIdx);
   bool isVectorIntrinsicWithOverloadTypeAtArg(Intrinsic::ID ID,
-                                              unsigned ScalarOpdIdx,
-                                              bool Default);
+                                              int ScalarOpdIdx);
 };
 } // namespace llvm
 

llvm/lib/Transforms/Scalar/Scalarizer.cpp

@@ -280,6 +280,7 @@ class ScalarizerVisitor : public InstVisitor<ScalarizerVisitor, bool> {
   bool visit(Function &F);
 
   bool isTriviallyScalarizable(Intrinsic::ID ID);
+  bool isIntrinsicWithOverloadTypeAtArg(Intrinsic::ID ID, int ScalarOpdIdx);
 
   // InstVisitor methods.  They return true if the instruction was scalarized,
   // false if nothing changed.
@@ -696,6 +697,13 @@ bool ScalarizerVisitor::isTriviallyScalarizable(Intrinsic::ID ID) {
          TTI->isTargetIntrinsicTriviallyScalarizable(ID);
 }
 
+bool ScalarizerVisitor::isIntrinsicWithOverloadTypeAtArg(Intrinsic::ID ID,
+                                                         int ScalarOpdIdx) {
+  return Intrinsic::isTargetIntrinsic(ID)
+             ? TTI->isVectorIntrinsicWithOverloadTypeAtArg(ID, ScalarOpdIdx)
+             : isVectorIntrinsicWithOverloadTypeAtArg(ID, ScalarOpdIdx);
+}
+
 /// If a call to a vector typed intrinsic function, split into a scalar call per
 /// element if possible for the intrinsic.
 bool ScalarizerVisitor::splitCall(CallInst &CI) {
@@ -727,8 +735,7 @@ bool ScalarizerVisitor::splitCall(CallInst &CI) {
 
   SmallVector<llvm::Type *, 3> Tys;
   // Add return type if intrinsic is overloaded on it.
-  if (TTI->isVectorIntrinsicWithOverloadTypeAtArg(
-          ID, -1, isVectorIntrinsicWithOverloadTypeAtArg(ID, -1)))
+  if (isIntrinsicWithOverloadTypeAtArg(ID, -1))
     Tys.push_back(VS->SplitTy);
 
   if (AreAllVectorsOfMatchingSize) {
@@ -768,15 +775,13 @@ bool ScalarizerVisitor::splitCall(CallInst &CI) {
       }
 
       Scattered[I] = scatter(&CI, OpI, *OpVS);
-      if (TTI->isVectorIntrinsicWithOverloadTypeAtArg(
-              ID, I, isVectorIntrinsicWithOverloadTypeAtArg(ID, I))) {
+      if (isIntrinsicWithOverloadTypeAtArg(ID, I)) {
         OverloadIdx[I] = Tys.size();
         Tys.push_back(OpVS->SplitTy);
       }
     } else {
       ScalarOperands[I] = OpI;
-      if (TTI->isVectorIntrinsicWithOverloadTypeAtArg(
-              ID, I, isVectorIntrinsicWithOverloadTypeAtArg(ID, I)))
+      if (isIntrinsicWithOverloadTypeAtArg(ID, I))
         Tys.push_back(OpI->getType());
     }
   }