Fixups

Author: MacDue

llvm/include/llvm/IR/StructWideningUtils.h

@@ -1,4 +1,4 @@
-//===--- StructWideningUtils.h - Utils for widening/narrowing struct types ===//
+//===--- StructWideningUtils.h - Utils for vectorizing struct types -------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -19,15 +19,15 @@ inline bool isUnpackedStructLiteral(StructType *StructTy) {
 
 /// A helper for converting structs of scalar types to structs of vector types.
 /// Note: Only unpacked literal struct types are supported.
-Type *toWideStructTy(StructType *StructTy, ElementCount EC);
+Type *toVectorizedStructTy(StructType *StructTy, ElementCount EC);
 
 /// A helper for converting structs of vector types to structs of scalar types.
 /// Note: Only unpacked literal struct types are supported.
-Type *toNarrowStructTy(StructType *StructTy);
+Type *toScalarizedStructTy(StructType *StructTy);
 
 /// Returns true if `StructTy` is an unpacked literal struct where all elements
 /// are vectors of matching element count. This does not include empty structs.
-bool isWideStructTy(StructType *StructTy);
+bool isVectorizedStructTy(StructType *StructTy);
 
 } // namespace llvm
 

llvm/include/llvm/IR/VectorUtils.h

@@ -27,31 +27,31 @@ inline Type *ToVectorTy(Type *Scalar, unsigned VF) {
   return ToVectorTy(Scalar, ElementCount::getFixed(VF));
 }
 
-/// A helper for converting to wider (vector) types. For scalar types, this is
+/// A helper for converting to vectorized types. For scalar types, this is
 /// equivalent to calling `ToVectorTy`. For struct types, this returns a new
 /// struct where each element type has been widened to a vector type. Note: Only
 /// unpacked literal struct types are supported.
-inline Type *ToWideTy(Type *Ty, ElementCount EC) {
+inline Type *toVectorizedTy(Type *Ty, ElementCount EC) {
   if (StructType *StructTy = dyn_cast<StructType>(Ty))
-    return toWideStructTy(StructTy, EC);
+    return toVectorizedStructTy(StructTy, EC);
   return ToVectorTy(Ty, EC);
 }
 
-/// A helper for converting wide types to narrow (non-vector) types. For vector
-/// types, this is equivalent to calling .getScalarType(). For struct types,
-/// this returns a new struct where each element type has been converted to a
-/// scalar type. Note: Only unpacked literal struct types are supported.
-inline Type *ToNarrowTy(Type *Ty) {
+/// A helper for converting vectorized types to scalarized (non-vector) types.
+/// For vector types, this is equivalent to calling .getScalarType(). For struct
+/// types, this returns a new struct where each element type has been converted
+/// to a scalar type. Note: Only unpacked literal struct types are supported.
+inline Type *toScalarizedTy(Type *Ty) {
   if (StructType *StructTy = dyn_cast<StructType>(Ty))
-    return toNarrowStructTy(StructTy);
+    return toScalarizedStructTy(StructTy);
   return Ty->getScalarType();
 }
 
 /// Returns true if `Ty` is a vector type or a struct of vector types where all
 /// vector types share the same VF.
-inline bool isWideTy(Type *Ty) {
+inline bool isVectorizedTy(Type *Ty) {
   if (StructType *StructTy = dyn_cast<StructType>(Ty))
-    return isWideStructTy(StructTy);
+    return isVectorizedStructTy(StructTy);
   return Ty->isVectorTy();
 }
 
@@ -63,9 +63,9 @@ inline ArrayRef<Type *> getContainedTypes(Type *const &Ty) {
   return ArrayRef<Type *>(&Ty, 1);
 }
 
-/// Returns the number of vector elements for a widened type.
-inline ElementCount getWideTypeVF(Type *Ty) {
-  assert(isWideTy(Ty) && "expected widened type");
+/// Returns the number of vector elements for a vectorized type.
+inline ElementCount getVectorizedTypeVF(Type *Ty) {
+  assert(isVectorizedTy(Ty) && "expected widened type");
   return cast<VectorType>(getContainedTypes(Ty).front())->getElementCount();
 }
 

llvm/lib/IR/StructWideningUtils.cpp

@@ -1,4 +1,4 @@
-//===- StructWideningUtils.cpp - Utils for widening/narrowing struct types ===//
+//===- StructWideningUtils.cpp - Utils for vectorizing struct types------- ===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -14,7 +14,7 @@ using namespace llvm;
 
 /// A helper for converting structs of scalar types to structs of vector types.
 /// Note: Only unpacked literal struct types are supported.
-Type *llvm::toWideStructTy(StructType *StructTy, ElementCount EC) {
+Type *llvm::toVectorizedStructTy(StructType *StructTy, ElementCount EC) {
   if (EC.isScalar())
     return StructTy;
   assert(isUnpackedStructLiteral(StructTy) &&
@@ -30,7 +30,7 @@ Type *llvm::toWideStructTy(StructType *StructTy, ElementCount EC) {
 
 /// A helper for converting structs of vector types to structs of scalar types.
 /// Note: Only unpacked literal struct types are supported.
-Type *llvm::toNarrowStructTy(StructType *StructTy) {
+Type *llvm::toScalarizedStructTy(StructType *StructTy) {
   assert(isUnpackedStructLiteral(StructTy) &&
          "expected unpacked struct literal");
   return StructType::get(
@@ -42,7 +42,7 @@ Type *llvm::toNarrowStructTy(StructType *StructTy) {
 
 /// Returns true if `StructTy` is an unpacked literal struct where all elements
 /// are vectors of matching element count. This does not include empty structs.
-bool llvm::isWideStructTy(StructType *StructTy) {
+bool llvm::isVectorizedStructTy(StructType *StructTy) {
   if (!isUnpackedStructLiteral(StructTy))
     return false;
   auto ElemTys = StructTy->elements();

llvm/lib/IR/VFABIDemangler.cpp

@@ -575,7 +575,7 @@ FunctionType *VFABI::createFunctionType(const VFInfo &Info,
 
   auto *RetTy = ScalarFTy->getReturnType();
   if (!RetTy->isVoidTy())
-    RetTy = ToWideTy(RetTy, VF);
+    RetTy = toVectorizedTy(RetTy, VF);
   return FunctionType::get(RetTy, VecTypes, false);
 }
 

llvm/unittests/IR/VectorUtilsTest.cpp

@@ -17,7 +17,7 @@ namespace {
 
 class VectorUtilsTest : public ::testing::Test {};
 
-TEST(VectorUtilsTest, TestToWideTy) {
+TEST(VectorUtilsTest, TestToVectorizedTy) {
   LLVMContext C;
 
   Type *ITy = Type::getInt32Ty(C);
@@ -28,15 +28,15 @@ TEST(VectorUtilsTest, TestToWideTy) {
 
   for (ElementCount VF :
        {ElementCount::getFixed(4), ElementCount::getScalable(2)}) {
-    Type *IntVec = ToWideTy(ITy, VF);
+    Type *IntVec = toVectorizedTy(ITy, VF);
     EXPECT_TRUE(isa<VectorType>(IntVec));
     EXPECT_EQ(IntVec, VectorType::get(ITy, VF));
 
-    Type *FloatVec = ToWideTy(FTy, VF);
+    Type *FloatVec = toVectorizedTy(FTy, VF);
     EXPECT_TRUE(isa<VectorType>(FloatVec));
     EXPECT_EQ(FloatVec, VectorType::get(FTy, VF));
 
-    Type *WideHomogeneousStructTy = ToWideTy(HomogeneousStructTy, VF);
+    Type *WideHomogeneousStructTy = toVectorizedTy(HomogeneousStructTy, VF);
     EXPECT_TRUE(isa<StructType>(WideHomogeneousStructTy));
     EXPECT_TRUE(
         cast<StructType>(WideHomogeneousStructTy)->containsHomogeneousTypes());
@@ -45,24 +45,24 @@ TEST(VectorUtilsTest, TestToWideTy) {
     EXPECT_TRUE(cast<StructType>(WideHomogeneousStructTy)->getElementType(0) ==
                 VectorType::get(FTy, VF));
 
-    Type *WideMixedStructTy = ToWideTy(MixedStructTy, VF);
+    Type *WideMixedStructTy = toVectorizedTy(MixedStructTy, VF);
     EXPECT_TRUE(isa<StructType>(WideMixedStructTy));
     EXPECT_TRUE(cast<StructType>(WideMixedStructTy)->getNumElements() == 2);
     EXPECT_TRUE(cast<StructType>(WideMixedStructTy)->getElementType(0) ==
                 VectorType::get(FTy, VF));
     EXPECT_TRUE(cast<StructType>(WideMixedStructTy)->getElementType(1) ==
                 VectorType::get(ITy, VF));
 
-    EXPECT_EQ(ToWideTy(VoidTy, VF), VoidTy);
+    EXPECT_EQ(toVectorizedTy(VoidTy, VF), VoidTy);
   }
 
   ElementCount ScalarVF = ElementCount::getFixed(1);
   for (Type *Ty : {ITy, FTy, HomogeneousStructTy, MixedStructTy, VoidTy}) {
-    EXPECT_EQ(ToWideTy(Ty, ScalarVF), Ty);
+    EXPECT_EQ(toVectorizedTy(Ty, ScalarVF), Ty);
   }
 }
 
-TEST(VectorUtilsTest, TestToNarrowTy) {
+TEST(VectorUtilsTest, TestToScalarizedTy) {
   LLVMContext C;
 
   Type *ITy = Type::getInt32Ty(C);
@@ -74,8 +74,8 @@ TEST(VectorUtilsTest, TestToNarrowTy) {
   for (ElementCount VF : {ElementCount::getFixed(1), ElementCount::getFixed(4),
                           ElementCount::getScalable(2)}) {
     for (Type *Ty : {ITy, FTy, HomogeneousStructTy, MixedStructTy, VoidTy}) {
-      // ToNarrowTy should be the inverse of ToWideTy.
-      EXPECT_EQ(ToNarrowTy(ToWideTy(Ty, VF)), Ty);
+      // toScalarizedTy should be the inverse of toVectorizedTy.
+      EXPECT_EQ(toScalarizedTy(toVectorizedTy(Ty, VF)), Ty);
     };
   }
 }
@@ -97,40 +97,40 @@ TEST(VectorUtilsTest, TestGetContainedTypes) {
   EXPECT_EQ(getContainedTypes(MixedStructTy), ArrayRef<Type *>({FTy, ITy}));
 }
 
-TEST(VectorUtilsTest, TestIsWideTy) {
+TEST(VectorUtilsTest, TestIsVectorizedTy) {
   LLVMContext C;
 
   Type *ITy = Type::getInt32Ty(C);
   Type *FTy = Type::getFloatTy(C);
   Type *NarrowStruct = StructType::get(FTy, ITy);
   Type *VoidTy = Type::getVoidTy(C);
 
-  EXPECT_FALSE(isWideTy(ITy));
-  EXPECT_FALSE(isWideTy(NarrowStruct));
-  EXPECT_FALSE(isWideTy(VoidTy));
+  EXPECT_FALSE(isVectorizedTy(ITy));
+  EXPECT_FALSE(isVectorizedTy(NarrowStruct));
+  EXPECT_FALSE(isVectorizedTy(VoidTy));
 
   ElementCount VF = ElementCount::getFixed(4);
-  EXPECT_TRUE(isWideTy(ToWideTy(ITy, VF)));
-  EXPECT_TRUE(isWideTy(ToWideTy(NarrowStruct, VF)));
+  EXPECT_TRUE(isVectorizedTy(toVectorizedTy(ITy, VF)));
+  EXPECT_TRUE(isVectorizedTy(toVectorizedTy(NarrowStruct, VF)));
 
   Type *MixedVFStruct =
       StructType::get(VectorType::get(ITy, ElementCount::getFixed(2)),
                       VectorType::get(ITy, ElementCount::getFixed(4)));
-  EXPECT_FALSE(isWideTy(MixedVFStruct));
+  EXPECT_FALSE(isVectorizedTy(MixedVFStruct));
 
   // Currently only literals types are considered wide.
   Type *NamedWideStruct = StructType::create("Named", VectorType::get(ITy, VF),
                                              VectorType::get(ITy, VF));
-  EXPECT_FALSE(isWideTy(NamedWideStruct));
+  EXPECT_FALSE(isVectorizedTy(NamedWideStruct));
 
   // Currently only unpacked types are considered wide.
   Type *PackedWideStruct = StructType::get(
       C, ArrayRef<Type *>{VectorType::get(ITy, VF), VectorType::get(ITy, VF)},
       /*isPacked=*/true);
-  EXPECT_FALSE(isWideTy(PackedWideStruct));
+  EXPECT_FALSE(isVectorizedTy(PackedWideStruct));
 }
 
-TEST(VectorUtilsTest, TestGetWideTypeVF) {
+TEST(VectorUtilsTest, TestGetVectorizedTypeVF) {
   LLVMContext C;
 
   Type *ITy = Type::getInt32Ty(C);
@@ -141,7 +141,7 @@ TEST(VectorUtilsTest, TestGetWideTypeVF) {
   for (ElementCount VF :
        {ElementCount::getFixed(4), ElementCount::getScalable(2)}) {
     for (Type *Ty : {ITy, FTy, HomogeneousStructTy, MixedStructTy}) {
-      EXPECT_EQ(getWideTypeVF(ToWideTy(Ty, VF)), VF);
+      EXPECT_EQ(getVectorizedTypeVF(toVectorizedTy(Ty, VF)), VF);
     };
   }
 }