Factor out (private) helper

Author: MacDue

llvm/include/llvm/CodeGen/BasicTTIImpl.h

@@ -286,6 +286,64 @@ class BasicTTIImplBase : public TargetTransformInfoImplCRTPBase<T> {
     return false;
   }
 
+  /// Several intrinsics struct-ret (including llvm.sincos[pi] and llvm.modf)
+  /// can be lowered to a vector library call (for certain VFs). The vector
+  /// library functions correspond to the scalar calls (e.g. sincos or modf),
+  /// which unlike the intrinsic return values via output pointers. This helper
+  /// checks if a vector call exists for the given intrinsic, and returns the
+  /// cost, which includes the cost of the mask (if required), and the loads for
+  /// values returned via output pointers. \p LC is the scalar libcall and
+  /// \p CallRetElementIndex (optional) is the struct element which is mapped to
+  /// the call return value. If std::nullopt is returned, the no vector library
+  /// call is available, so the intrinsic should be assigned the default cost
+  /// (e.g. scalarization).
+  std::optional<InstructionCost> getMultipleResultIntrinsicVectorLibCallCost(
+      const IntrinsicCostAttributes &ICA, TTI::TargetCostKind CostKind,
+      RTLIB::Libcall LC, std::optional<unsigned> CallRetElementIndex = {}) {
+    Type *RetTy = ICA.getReturnType();
+    // Vector variants of the intrinsic can be mapped to a vector library call.
+    auto const *LibInfo = ICA.getLibInfo();
+    if (!LibInfo || !isa<StructType>(RetTy) ||
+        !isVectorizedStructTy(cast<StructType>(RetTy)))
+      return std::nullopt;
+
+    // Find associated libcall.
+    const char *LCName = getTLI()->getLibcallName(LC);
+    if (!LC || !LCName)
+      return std::nullopt;
+
+    // Search for a corresponding vector variant.
+    LLVMContext &Ctx = RetTy->getContext();
+    ElementCount VF = getVectorizedTypeVF(RetTy);
+    VecDesc const *VD = nullptr;
+    for (bool Masked : {false, true}) {
+      if ((VD = LibInfo->getVectorMappingInfo(LCName, VF, Masked)))
+        break;
+    }
+    if (!VD)
+      return std::nullopt;
+
+    // Cost the call + mask.
+    auto Cost =
+        thisT()->getCallInstrCost(nullptr, RetTy, ICA.getArgTypes(), CostKind);
+    if (VD->isMasked())
+      Cost += thisT()->getShuffleCost(
+          TargetTransformInfo::SK_Broadcast,
+          VectorType::get(IntegerType::getInt1Ty(Ctx), VF), {}, CostKind, 0,
+          nullptr, {});
+
+    // Lowering to a library call (with output pointers) may require us to emit
+    // reloads for the results.
+    for (auto [Idx, VectorTy] : enumerate(getContainedTypes(RetTy))) {
+      if (Idx == CallRetElementIndex)
+        continue;
+      Cost += thisT()->getMemoryOpCost(
+          Instruction::Load, VectorTy,
+          thisT()->getDataLayout().getABITypeAlign(VectorTy), 0, CostKind);
+    }
+    return Cost;
+  }
+
 protected:
   explicit BasicTTIImplBase(const TargetMachine *TM, const DataLayout &DL)
       : BaseT(DL) {}
@@ -1999,47 +2057,14 @@ class BasicTTIImplBase : public TargetTransformInfoImplCRTPBase<T> {
     case Intrinsic::experimental_vector_match:
       return thisT()->getTypeBasedIntrinsicInstrCost(ICA, CostKind);
     case Intrinsic::sincos: {
-      // Vector variants of llvm.sincos can be mapped to a vector library call.
-      auto const *LibInfo = ICA.getLibInfo();
-      if (!LibInfo || !isVectorizedTy(RetTy))
-        break;
-
-      // Find associated libcall.
-      VectorType *VectorTy = cast<VectorType>(getContainedTypes(RetTy).front());
-      EVT VT = getTLI()->getValueType(DL, VectorTy);
-      RTLIB::Libcall LC = RTLIB::getSINCOS(VT.getVectorElementType());
-      const char *LCName = getTLI()->getLibcallName(LC);
-      if (!LC || !LCName)
-        break;
-
-      // Search for a corresponding vector variant.
-      LLVMContext &Ctx = RetTy->getContext();
-      auto VF = getVectorizedTypeVF(RetTy);
-      VecDesc const *VD = nullptr;
-      for (bool Masked : {false, true}) {
-        if ((VD = LibInfo->getVectorMappingInfo(LCName, VF, Masked)))
-          break;
-      }
-      if (!VD)
-        break;
-
-      // Cost the call + mask.
-      auto Cost = thisT()->getCallInstrCost(nullptr, RetTy, ICA.getArgTypes(),
-                                            CostKind);
-      if (VD->isMasked())
-        Cost += thisT()->getShuffleCost(
-            TargetTransformInfo::SK_Broadcast,
-            VectorType::get(IntegerType::getInt1Ty(Ctx), VF), {}, CostKind, 0,
-            nullptr, {});
-
-      // Lowering to a sincos library call (with output pointers) may require us
-      // to emit reloads for the results.
-      Cost +=
-          thisT()->getMemoryOpCost(
-              Instruction::Load, VectorTy,
-              thisT()->getDataLayout().getABITypeAlign(VectorTy), 0, CostKind) *
-          2;
-      return Cost;
+      Type *Ty = getContainedTypes(RetTy).front();
+      EVT VT = getTLI()->getValueType(DL, Ty);
+      RTLIB::Libcall LC = RTLIB::getSINCOS(VT.getScalarType());
+      if (auto Cost =
+              getMultipleResultIntrinsicVectorLibCallCost(ICA, CostKind, LC))
+        return *Cost;
+      // Otherwise, fallback to default scalarization cost.
+      break;
     }
     }