address Tex's PR comments

Author: farzonl

llvm/include/llvm/Analysis/VectorUtils.h

@@ -154,6 +154,11 @@ bool isVectorIntrinsicWithScalarOpAtArg(Intrinsic::ID ID,
 /// the operand at index \p OpdIdx, or on the return type if \p OpdIdx is -1.
 bool isVectorIntrinsicWithOverloadTypeAtArg(Intrinsic::ID ID, int OpdIdx);
 
+/// Identifies if the vector form of the intrinsic that returns a struct is
+/// overloaded at the struct element index \p RetIdx.
+bool isVectorIntrinsicWithStructReturnOverloadAtField(Intrinsic::ID ID,
+                                                      int RetIdx);
+
 /// Returns intrinsic ID for call.
 /// For the input call instruction it finds mapping intrinsic and returns
 /// its intrinsic ID, in case it does not found it return not_intrinsic.

llvm/lib/Analysis/VectorUtils.cpp

@@ -152,6 +152,16 @@ bool llvm::isVectorIntrinsicWithOverloadTypeAtArg(Intrinsic::ID ID,
   }
 }
 
+bool llvm::isVectorIntrinsicWithStructReturnOverloadAtField(Intrinsic::ID ID,
+                                                            int RetIdx) {
+  switch (ID) {
+  case Intrinsic::frexp:
+    return RetIdx == 0 || RetIdx == 1;
+  default:
+    return RetIdx == 0;
+  }
+}
+
 /// Returns intrinsic ID for call.
 /// For the input call instruction it finds mapping intrinsic and returns
 /// its ID, in case it does not found it return not_intrinsic.

llvm/lib/Transforms/Scalar/Scalarizer.cpp

@@ -700,9 +700,9 @@ bool ScalarizerVisitor::isTriviallyScalarizable(Intrinsic::ID ID) {
 /// element if possible for the intrinsic.
 bool ScalarizerVisitor::splitCall(CallInst &CI) {
   Type *CallType = CI.getType();
-  bool AreAllMatchingVectors = isStructOfMatchingFixedVectors(CallType);
+  bool AreAllVectorsOfMatchingSize = isStructOfMatchingFixedVectors(CallType);
   std::optional<VectorSplit> VS;
-  if (AreAllMatchingVectors)
+  if (AreAllVectorsOfMatchingSize)
     VS = getVectorSplit(CallType->getContainedType(0));
   else
     VS = getVectorSplit(CallType);
@@ -730,19 +730,17 @@ bool ScalarizerVisitor::splitCall(CallInst &CI) {
   if (isVectorIntrinsicWithOverloadTypeAtArg(ID, -1))
     Tys.push_back(VS->SplitTy);
 
-  if (AreAllMatchingVectors) {
-    Type *PrevType = CallType->getContainedType(0);
+  if (AreAllVectorsOfMatchingSize) {
     for (unsigned I = 1; I < CallType->getNumContainedTypes(); I++) {
-      Type *CurrType = cast<FixedVectorType>(CallType->getContainedType(I));
-      if (PrevType != CurrType) {
-        std::optional<VectorSplit> CurrVS = getVectorSplit(CurrType);
+      if (isVectorIntrinsicWithStructReturnOverloadAtField(ID, I)) {
+        std::optional<VectorSplit> CurrVS = getVectorSplit(
+            cast<FixedVectorType>(CallType->getContainedType(I)));
         // This case does not seem to happen, but it is possible for
         // VectorSplit.NumPacked >= NumElems. If that happens a VectorSplit
         // is not returned and we will bailout of handling this call.
         if (!CurrVS)
           return false;
         Tys.push_back(CurrVS->SplitTy);
-        PrevType = CurrType;
       }
     }
   }