[Codegen][ReplaceWithVecLib] Fix pow intrinsics in ReplaceWithVecLib pass

[ttjost]

Summary

This patch fixes the replacement of pow intrinsics
by its vector library implementation.

Function Intrinsic::getName was being called with
a wrong set of arguments. This prevented TargetLibraryInfo
from getting the right name for the vectorized version of pow
for different library implementations.

[ttjost]

Bot failed for some tests. This new update fixes them.

[ttjost]

Fixes assert in Debug mode.

llvm/lib/CodeGen/ReplaceWithVeclib.cpp

static bool replaceWithCallToVeclib(const TargetLibraryInfo &TLI,
   if (IntrinsicID == Intrinsic::not_intrinsic) {
     // Replacement is only performed for intrinsic functions
     return false;
   }
 
   // Convert vector arguments to scalar type and check that
   // all vector operands have identical vector width.
   ElementCount VF = ElementCount::getFixed(0);
-  SmallVector<Type *> ScalarTypes;
+  Type *ScalarType = nullptr;
   for (auto Arg : enumerate(CI.args())) {
     auto *ArgType = Arg.value()->getType();
     // Vector calls to intrinsics can still have
     // scalar operands for specific arguments.
     if (hasVectorInstrinsicScalarOpd(IntrinsicID, Arg.index())) {
-      ScalarTypes.push_back(ArgType);
+      ScalarType = ArgType;
     } else {
       // The argument in this place should be a vector if
       // this is a call to a vector intrinsic.
       auto *VectorArgTy = dyn_cast<VectorType>(ArgType);
       if (!VectorArgTy) {
         // The argument is not a vector, do not perform
         // the replacement.
         return false;
       }
       ElementCount NumElements = VectorArgTy->getElementCount();
       if (NumElements.isScalable()) {
         // The current implementation does not support
         // scalable vectors.
         return false;
       }
       if (VF.isNonZero() && VF != NumElements) {
         // The different arguments differ in vector size.
         return false;
       } else {
         VF = NumElements;
       }
-      ScalarTypes.push_back(VectorArgTy->getElementType());
+      ScalarType = VectorArgTy->getElementType();
     }
   }
 
   // Try to reconstruct the name for the scalar version of this
   // intrinsic using the intrinsic ID and the argument types
   // converted to scalar above.
   std::string ScalarName;
   if (Intrinsic::isOverloaded(IntrinsicID)) {
-    ScalarName = Intrinsic::getName(IntrinsicID, ScalarTypes, CI.getModule());
+    if (ScalarType)
+      ScalarName =
+          Intrinsic::getName(IntrinsicID, {ScalarType}, CI.getModule());
+    else
+      ScalarName = Intrinsic::getName(IntrinsicID, {}, CI.getModule());
   } else {
     ScalarName = Intrinsic::getName(IntrinsicID).str();
   }
 
   if (!TLI.isFunctionVectorizable(ScalarName)) {
     // The TargetLibraryInfo does not contain a vectorized version of
     // the scalar function.
     return false;

llvm/test/CodeGen/Generic/replace-intrinsics-with-veclib.ll

 ; ACCELERATE-NEXT:    ret <4 x float> [[TMP1]]
 ;
   %call = call <4 x float> @llvm.exp.v4f32(<4 x float> %in)
   ret <4 x float> %call
 }
 
 declare <4 x float> @llvm.exp.v4f32(<4 x float>) #0
 
+define <4 x double> @pow_v4(<4 x double> %F, <4 x double> %power) {
+; SVML-LABEL: define {{[^@]+}}@pow_v4
+; SVML-SAME: (<4 x double> [[F:%.*]], <4 x double> [[POWER:%.*]]) {
+; SVML-NEXT:    [[TMP1:%.*]] = call <4 x double> @__svml_pow4(<4 x double> [[F]], <4 x double> [[POWER]])
+; SVML-NEXT:    ret <4 x double> [[TMP1]]
+;
+; LIBMVEC-X86-LABEL: define {{[^@]+}}@pow_v4
+; LIBMVEC-X86-SAME: (<4 x double> [[F:%.*]], <4 x double> [[POWER:%.*]]) {
+; LIBMVEC-X86-NEXT:    [[TMP1:%.*]] = call <4 x double> @_ZGVdN4vv_pow(<4 x double> [[F]], <4 x double> [[POWER]])
+; LIBMVEC-X86-NEXT:    ret <4 x double> [[TMP1]]
+;
+; MASSV-LABEL: define {{[^@]+}}@pow_v4
+; MASSV-SAME: (<4 x double> [[F:%.*]], <4 x double> [[POWER:%.*]]) {
+; MASSV-NEXT:    [[CALL:%.*]] = call <4 x double> @llvm.pow.v4f64(<4 x double> [[F]], <4 x double> [[POWER]])
+; MASSV-NEXT:    ret <4 x double> [[CALL]]
+;
+; ACCELERATE-LABEL: define {{[^@]+}}@pow_v4
+; ACCELERATE-SAME: (<4 x double> [[F:%.*]], <4 x double> [[POWER:%.*]]) {
+; ACCELERATE-NEXT:    [[CALL:%.*]] = call <4 x double> @llvm.pow.v4f64(<4 x double> [[F]], <4 x double> [[POWER]])
+; ACCELERATE-NEXT:    ret <4 x double> [[CALL]]
+;
+  %call = call <4 x double> @llvm.pow.v4f64(<4 x double> %F, <4 x double> %power)
+  ret <4 x double> %call
+}
+
+declare <4 x double> @llvm.pow.v4f64(<4 x double>, <4 x double>) #0
+
+define <4 x float> @pow_f32(<4 x float> %F, <4 x float> %power) {
+; SVML-LABEL: define {{[^@]+}}@pow_f32
+; SVML-SAME: (<4 x float> [[F:%.*]], <4 x float> [[POWER:%.*]]) {
+; SVML-NEXT:    [[TMP1:%.*]] = call <4 x float> @__svml_powf4(<4 x float> [[F]], <4 x float> [[POWER]])
+; SVML-NEXT:    ret <4 x float> [[TMP1]]
+;
+; LIBMVEC-X86-LABEL: define {{[^@]+}}@pow_f32
+; LIBMVEC-X86-SAME: (<4 x float> [[F:%.*]], <4 x float> [[POWER:%.*]]) {
+; LIBMVEC-X86-NEXT:    [[TMP1:%.*]] = call <4 x float> @_ZGVbN4vv_powf(<4 x float> [[F]], <4 x float> [[POWER]])
+; LIBMVEC-X86-NEXT:    ret <4 x float> [[TMP1]]
+;
+; MASSV-LABEL: define {{[^@]+}}@pow_f32
+; MASSV-SAME: (<4 x float> [[F:%.*]], <4 x float> [[POWER:%.*]]) {
+; MASSV-NEXT:    [[TMP1:%.*]] = call <4 x float> @__powf4(<4 x float> [[F]], <4 x float> [[POWER]])
+; MASSV-NEXT:    ret <4 x float> [[TMP1]]
+;
+; ACCELERATE-LABEL: define {{[^@]+}}@pow_f32
+; ACCELERATE-SAME: (<4 x float> [[F:%.*]], <4 x float> [[POWER:%.*]]) {
+; ACCELERATE-NEXT:    [[TMP1:%.*]] = call <4 x float> @llvm.pow.v4f32(<4 x float> [[F]], <4 x float> [[POWER]])
+; ACCELERATE-NEXT:    ret <4 x float> [[TMP1]]
+;
+  %call = call <4 x float> @llvm.pow.v4f32(<4 x float> %F, <4 x float> %power)
+  ret <4 x float> %call
+}
+
+declare <4 x float> @llvm.pow.v4f32(<4 x float>, <4 x float>) #0
+
 ; No replacement should take place for non-vector intrinsic.
 define double @exp_f64(double %in) {
 ; COMMON-LABEL: define {{[^@]+}}@exp_f64
 ; COMMON-SAME: (double [[IN:%.*]]) {
 ; COMMON-NEXT:    [[CALL:%.*]] = call double @llvm.exp.f64(double [[IN]])
 ; COMMON-NEXT:    ret double [[CALL]]
 ;
   %call = call double @llvm.exp.f64(double %in)