[SVE] Make CompositeType not inherit from Type

[ctetreau]

Summary

This patch is a work in progress

Make CompositeType not inherit from Type. Instead, Vecotr, Array, and
Struct Types directly inherit from Type. This is in preparation for the
introduction of distinct Fixed and Scalable Vector Types

[ctetreau]

Cleaned up code, resolved clang-format lints

[efriedma]

It's possible to mess with the way "cast<>" actually casts values by specializing the function template in question. That, plus an appropriate classof implementations, should allow you to avoid the whole CompositeType::get thing. See, for example, https://github.com/llvm/llvm-project/blob/8cf76e913b867a98a9843aa1b3d782632ed5d930/clang/include/clang/AST/DeclBase.h#L2490 .

That said, both CompositeType and SequentialType are pretty useless. CompositeType especially: really, code dealing with it wants to answer one of two question: "is it legal to GEP index into this type", or "is it legal to extractvalue index into this type". I tried to quickly throw together a patch to get rid of CompositeType, and it was roughly 100 lines changed. I'll post something soon.

clang/lib/CodeGen/CGDecl.cpp

 
 /// Replace all padding bytes in a given constant with either a pattern byte or
 /// 0x00.
 static llvm::Constant *constWithPadding(CodeGenModule &CGM, IsPattern isPattern,
                                         llvm::Constant *constant) {
   llvm::Type *OrigTy = constant->getType();
   if (const auto STy = dyn_cast<llvm::StructType>(OrigTy))
     return constStructWithPadding(CGM, isPattern, STy, constant);
-  if (auto *STy = dyn_cast<llvm::SequentialType>(OrigTy)) {
+  if (auto *STy = dyn_cast_or_null<llvm::SequentialType>(
+          llvm::CompositeType::get(OrigTy, false))) {
     llvm::SmallVector<llvm::Constant *, 8> Values;
     unsigned Size = STy->getNumElements();
     if (!Size)
       return constant;
     llvm::Type *ElemTy = STy->getElementType();
     bool ZeroInitializer = constant->isZeroValue();
     llvm::Constant *OpValue, *PaddedOp;
     if (ZeroInitializer) {

clang/lib/CodeGen/CGExprConstant.cpp

bool ConstantAggregateBuilder::split(size_t Index, CharUnits Hint) {
   NaturalLayout = false;
   llvm::Constant *C = Elems[Index];
   CharUnits Offset = Offsets[Index];
 
   if (auto *CA = dyn_cast<llvm::ConstantAggregate>(C)) {
     replace(Elems, Index, Index + 1,
             llvm::map_range(llvm::seq(0u, CA->getNumOperands()),
                             [&](unsigned Op) { return CA->getOperand(Op); }));
-    if (auto *Seq = dyn_cast<llvm::SequentialType>(CA->getType())) {
+    if (auto *Seq = dyn_cast_or_null<llvm::SequentialType>(
+            llvm::CompositeType::get(CA->getType(), false))) {
       // Array or vector.
       CharUnits ElemSize = getSize(Seq->getElementType());
       replace(
           Offsets, Index, Index + 1,
           llvm::map_range(llvm::seq(0u, CA->getNumOperands()),
                           [&](unsigned Op) { return Offset + Op * ElemSize; }));
     } else {
       // Must be a struct.

clang/unittests/CodeGen/CodeGenExternalTest.cpp

if (FunctionDecl *fd = dyn_cast<FunctionDecl>(decl)) {
         // Check convertTypeForMemory
         llvm::Type *llvmTy = CodeGen::convertTypeForMemory(CGM, qType);
         ASSERT_TRUE(llvmTy != NULL);
         if (DebugThisTest) {
           llvmTy->print(dbgs(), true);
           dbgs() << "\n";
         }
 
-        llvm::CompositeType* structTy = dyn_cast<CompositeType>(llvmTy);
+        llvm::CompositeType *structTy = CompositeType::get(llvmTy, false);
         ASSERT_TRUE(structTy != NULL);
 
         // Check getLLVMFieldNumber
         FieldDecl *xField = NULL;
         FieldDecl *yField = NULL;
         FieldDecl *zField = NULL;
 
         for (auto field : rd->fields()) {

llvm/include/llvm/IR/Constants.h

public:
   /// Return a Constant for a specified index's element.
   /// Note that this has to compute a new constant to return, so it isn't as
   /// efficient as getElementAsInteger/Float/Double.
   Constant *getElementAsConstant(unsigned i) const;
 
   /// Specialize the getType() method to always return a SequentialType, which
   /// reduces the amount of casting needed in parts of the compiler.
   inline SequentialType *getType() const {
-    return cast<SequentialType>(Value::getType());
+    return cast<SequentialType>(CompositeType::get(Value::getType()));
   }
 
   /// Return the element type of the array/vector.
   Type *getElementType() const;
 
   /// Return the number of elements in the array or vector.
   unsigned getNumElements() const;
 

llvm/include/llvm/IR/DerivedTypes.h

public:
   explicit operator bool() { return Callee; }
 
 private:
   FunctionType *FnTy = nullptr;
   Value *Callee = nullptr;
 };
 
 /// Common super class of ArrayType, StructType and VectorType.
-class CompositeType : public Type {
+class CompositeType {
+public:
+  enum class TypeID {
+    StructTyID, ///< Structures
+    ArrayTyID,  ///< Arrays
+    VectorTyID  ///< SIMD 'packed' format, or other vector type
+  };
+
+  TypeID fromTypeID(Type::TypeID ID) {
+    switch (ID) {
+    case Type::ArrayTyID:
+      return TypeID::ArrayTyID;
+    case Type::StructTyID:
+      return TypeID::StructTyID;
+    case Type::VectorTyID:
+      return TypeID::VectorTyID;
+    default:
+      llvm_unreachable("Invalid TypeID for conversion from base TypeID");
+    }
+  }
+
 protected:
-  explicit CompositeType(LLVMContext &C, TypeID tid) : Type(C, tid) {}
+  explicit CompositeType(Type::TypeID tid) : ID(fromTypeID(tid)) {}
 
 public:
   /// Given an index value into the type, return the type of the element.
   Type *getTypeAtIndex(const Value *V) const;
   Type *getTypeAtIndex(unsigned Idx) const;
   bool indexValid(const Value *V) const;
   bool indexValid(unsigned Idx) const;
 
-  /// Methods for support type inquiry through isa, cast, and dyn_cast.
-  static bool classof(const Type *T) {
-    return T->getTypeID() == ArrayTyID ||
-           T->getTypeID() == StructTyID ||
-           T->getTypeID() == VectorTyID;
+  /// Convert from a CompositeType to a Type
+  Type *from();
+
+  TypeID getTypeID() const { return ID; }
+
+  /// Returns true if the given type is a Composite Type
+  static bool is(const Type *TY) {
+    return TY->getTypeID() == Type::ArrayTyID ||
+           TY->getTypeID() == Type::VectorTyID ||
+           TY->getTypeID() == Type::StructTyID;
   }
+
+  /// Convert a Type pointer to a Composite type pointer. This behaves like
+  /// cast<T> if infallible = true, and behaves like dyn_cast<T> if
+  /// infallible = false.
+  ///
+  /// Alternatively you call CompositeType::get(TY, CompositeType::is(TY))
+  /// to get the dyn_cast<T> behavior and CompositeType::get(TY) to get the
+  /// cast<T> behavior.
+  static CompositeType *get(Type *TY, bool infallible = true);
+
+private:
+  TypeID ID;
 };
 
 /// Class to represent struct types. There are two different kinds of struct
 /// types: Literal structs and Identified structs.
 ///
 /// Literal struct types (e.g. { i32, i32 }) are uniqued structurally, and must
 /// always have a body when created.  You can get one of these by using one of
 /// the StructType::get() forms.
 ///
 /// Identified structs (e.g. %foo or %42) may optionally have a name and are not
 /// uniqued.  The names for identified structs are managed at the LLVMContext
 /// level, so there can only be a single identified struct with a given name in
 /// a particular LLVMContext.  Identified structs may also optionally be opaque
 /// (have no body specified).  You get one of these by using one of the
 /// StructType::create() forms.
 ///
 /// Independent of what kind of struct you have, the body of a struct type are
 /// laid out in memory consecutively with the elements directly one after the
 /// other (if the struct is packed) or (if not packed) with padding between the
 /// elements as defined by DataLayout (which is required to match what the code
 /// generator for a target expects).
 ///
-class StructType : public CompositeType {
-  StructType(LLVMContext &C) : CompositeType(C, StructTyID) {}
+class StructType : public Type, public CompositeType {
+  StructType(LLVMContext &C) : Type(C, StructTyID), CompositeType(StructTyID) {}
 
   enum {
     /// This is the contents of the SubClassData field.
     SCDB_HasBody = 1,
     SCDB_Packed = 2,
     SCDB_IsLiteral = 4,
     SCDB_IsSized = 8
   };
Type *getElementType(unsigned N) const {
     assert(N < NumContainedTys && "Element number out of range!");
     return ContainedTys[N];
   }
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast.
   static bool classof(const Type *T) {
     return T->getTypeID() == StructTyID;
   }
+
+  static bool classof(const CompositeType *T) {
+    return T->getTypeID() == CompositeType::TypeID::StructTyID;
+  }
 };
 
 StringRef Type::getStructName() const {
   return cast<StructType>(this)->getName();
 }
 
 unsigned Type::getStructNumElements() const {
   return cast<StructType>(this)->getNumElements();

 /// for use of SIMD instructions. SequentialType holds the common features of
 /// both, which stem from the fact that both lay their components out in memory
 /// identically.
 class SequentialType : public CompositeType {
   Type *ContainedType;               ///< Storage for the single contained type.
   uint64_t NumElements;
 
 protected:
-  SequentialType(TypeID TID, Type *ElType, uint64_t NumElements)
-    : CompositeType(ElType->getContext(), TID), ContainedType(ElType),
-      NumElements(NumElements) {
-    ContainedTys = &ContainedType;
-    NumContainedTys = 1;
-  }
+  SequentialType(Type::TypeID TID, Type *ElType, uint64_t NumElements)
+      : CompositeType(TID), ContainedType(ElType), NumElements(NumElements) {}
 
 public:
   SequentialType(const SequentialType &) = delete;
   SequentialType &operator=(const SequentialType &) = delete;
 
   /// For scalable vectors, this will return the minimum number of elements
   /// in the vector.
   uint64_t getNumElements() const { return NumElements; }
   Type *getElementType() const { return ContainedType; }
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast.
-  static bool classof(const Type *T) {
-    return T->getTypeID() == ArrayTyID || T->getTypeID() == VectorTyID;
+  static bool classof(const CompositeType *T) {
+    return T->getTypeID() == TypeID::ArrayTyID ||
+           T->getTypeID() == TypeID::VectorTyID;
   }
 };
 
 /// Class to represent array types.
-class ArrayType : public SequentialType {
+class ArrayType : public Type, public SequentialType {
   ArrayType(Type *ElType, uint64_t NumEl);
 
 public:
   ArrayType(const ArrayType &) = delete;
   ArrayType &operator=(const ArrayType &) = delete;
 
   /// This static method is the primary way to construct an ArrayType
   static ArrayType *get(Type *ElementType, uint64_t NumElements);
 
   /// Return true if the specified type is valid as a element type.
   static bool isValidElementType(Type *ElemTy);
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast.
   static bool classof(const Type *T) {
     return T->getTypeID() == ArrayTyID;
   }
+
+  static bool classof(const CompositeType *T) {
+    return T->getTypeID() == CompositeType::TypeID::ArrayTyID;
+  }
 };
 
 uint64_t Type::getArrayNumElements() const {
   return cast<ArrayType>(this)->getNumElements();
 }
 
 /// Class to represent vector types.
-class VectorType : public SequentialType {
+class VectorType : public Type, public SequentialType {
   /// A fully specified VectorType is of the form <vscale x n x Ty>. 'n' is the
   /// minimum number of elements of type Ty contained within the vector, and
   /// 'vscale x' indicates that the total element count is an integer multiple
   /// of 'n', where the multiple is either guaranteed to be one, or is
   /// statically unknown at compile time.
   ///
   /// If the multiple is known to be 1, then the extra term is discarded in
   /// textual IR:
public:
   unsigned getBitWidth() const {
     return getNumElements() * getElementType()->getPrimitiveSizeInBits();
   }
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast.
   static bool classof(const Type *T) {
     return T->getTypeID() == VectorTyID;
   }
+
+  static bool classof(const CompositeType *T) {
+    return T->getTypeID() == CompositeType::TypeID::VectorTyID;
+  }
 };
 
 unsigned Type::getVectorNumElements() const {
   return cast<VectorType>(this)->getNumElements();
 }
 
 bool Type::getVectorIsScalable() const {
   return cast<VectorType>(this)->isScalable();

llvm/include/llvm/IR/GetElementPtrTypeIterator.h

Type *getIndexedType() const {
         return T;
       return CurTy.get<StructType *>()->getTypeAtIndex(getOperand());
     }
 
     Value *getOperand() const { return const_cast<Value *>(&**OpIt); }
 
     generic_gep_type_iterator& operator++() {   // Preincrement
       Type *Ty = getIndexedType();
-      if (auto *STy = dyn_cast<SequentialType>(Ty)) {
+      if (auto *STy = dyn_cast<SequentialType>(CompositeType::get(Ty))) {
         CurTy = STy->getElementType();
         NumElements = STy->getNumElements();
       } else
         CurTy = dyn_cast<StructType>(Ty);
       ++OpIt;
       return *this;
     }
 

llvm/lib/Analysis/BasicAliasAnalysis.cpp

if (!isa<ArrayType>(GetElementPtrInst::getIndexedType(
       return MayAlias;
     IntermediateIndices.push_back(GEP1->getOperand(i + 1));
   }
 
   auto *Ty = GetElementPtrInst::getIndexedType(
     GEP1->getSourceElementType(), IntermediateIndices);
   StructType *LastIndexedStruct = dyn_cast<StructType>(Ty);
 
-  if (isa<SequentialType>(Ty)) {
+  if (isa_and_nonnull<SequentialType>(CompositeType::get(Ty, false))) {
     // We know that:
     // - both GEPs begin indexing from the exact same pointer;
     // - the last indices in both GEPs are constants, indexing into a sequential
     //   type (array or pointer);
     // - both GEPs only index through arrays prior to that.
     //
     // Because array indices greater than the number of elements are valid in
     // GEPs, unless we know the intermediate indices are identical between
     // GEP1 and GEP2 we cannot guarantee that the last indexed arrays don't
     // partially overlap. We also need to check that the loaded size matches
     // the element size, otherwise we could still have overlap.
-    const uint64_t ElementSize =
-        DL.getTypeStoreSize(cast<SequentialType>(Ty)->getElementType());
+    const uint64_t ElementSize = DL.getTypeStoreSize(
+        cast<SequentialType>(CompositeType::get(Ty))->getElementType());
     if (V1Size != ElementSize || V2Size != ElementSize)
       return MayAlias;
 
     for (unsigned i = 0, e = GEP1->getNumIndices() - 1; i != e; ++i)
       if (GEP1->getOperand(i + 1) != GEP2->getOperand(i + 1))
         return MayAlias;
 
     // Now we know that the array/pointer that GEP1 indexes into and that

llvm/lib/Analysis/ConstantFolding.cpp

if (!Ty->isStructTy()) {
         if (!NewIdxs.empty())
           break;
 
         Ty = SrcElemTy;
 
         // Only handle pointers to sized types, not pointers to functions.
         if (!Ty->isSized())
           return nullptr;
-      } else if (auto *ATy = dyn_cast<SequentialType>(Ty)) {
+      } else if (auto *ATy = dyn_cast<SequentialType>(CompositeType::get(Ty))) {
         Ty = ATy->getElementType();
       } else {
         // We've reached some non-indexable type.
         break;
       }
 
       // Determine which element of the array the offset points into.
       APInt ElemSize(BitWidth, DL.getTypeAllocSize(Ty));

llvm/lib/Analysis/ScalarEvolution.cpp

if (StructType *STy = dyn_cast<StructType>(CurTy)) {
 
       // Add the field offset to the running total offset.
       TotalOffset = getAddExpr(TotalOffset, FieldOffset);
 
       // Update CurTy to the type of the field at Index.
       CurTy = STy->getTypeAtIndex(Index);
     } else {
       // Update CurTy to its element type.
-      CurTy = cast<SequentialType>(CurTy)->getElementType();
+      CurTy = cast<SequentialType>(CompositeType::get(CurTy))->getElementType();
       // For an array, add the element offset, explicitly scaled.
       const SCEV *ElementSize = getSizeOfExpr(IntIdxTy, CurTy);
       // Getelementptr indices are signed.
       IndexExpr = getTruncateOrSignExtend(IndexExpr, IntIdxTy);
 
       // Multiply the index by the element size to compute the element offset.
       const SCEV *LocalOffset = getMulExpr(IndexExpr, ElementSize, Wrap);
 

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

case bitc::CST_CODE_CSTRING: { // CSTRING: [values]
       V = ConstantDataArray::getString(Context, Elts,
                                        BitCode == bitc::CST_CODE_CSTRING);
       break;
     }
     case bitc::CST_CODE_DATA: {// DATA: [n x value]
       if (Record.empty())
         return error("Invalid record");
 
-      Type *EltTy = cast<SequentialType>(CurTy)->getElementType();
+      Type *EltTy =
+          cast<SequentialType>(CompositeType::get(CurTy))->getElementType();
       if (EltTy->isIntegerTy(8)) {
         SmallVector<uint8_t, 16> Elts(Record.begin(), Record.end());
         if (isa<VectorType>(CurTy))
           V = ConstantDataVector::get(Context, Elts);
         else
           V = ConstantDataArray::get(Context, Elts);
       } else if (EltTy->isIntegerTy(16)) {
         SmallVector<uint16_t, 16> Elts(Record.begin(), Record.end());

llvm/lib/CodeGen/Analysis.cpp

static bool advanceToNextLeafType(SmallVectorImpl<CompositeType *> &SubTypes,
   if (Path.empty())
     return false;
 
   // We know there's *some* valid leaf now, so march back down the tree picking
   // out the left-most element at each node.
   ++Path.back();
   Type *DeeperType = SubTypes.back()->getTypeAtIndex(Path.back());
   while (DeeperType->isAggregateType()) {
-    CompositeType *CT = cast<CompositeType>(DeeperType);
+    CompositeType *CT = CompositeType::get(DeeperType);
     if (!indexReallyValid(CT, 0))
       return true;
 
     SubTypes.push_back(CT);
     Path.push_back(0);
 
     DeeperType = CT->getTypeAtIndex(0U);
   }

 /// i32 in that type.
 static bool firstRealType(Type *Next,
                           SmallVectorImpl<CompositeType *> &SubTypes,
                           SmallVectorImpl<unsigned> &Path) {
   // First initialise the iterator components to the first "leaf" node
   // (i.e. node with no valid sub-type at any index, so {} does count as a leaf
   // despite nominally being an aggregate).
   while (Next->isAggregateType() &&
-         indexReallyValid(cast<CompositeType>(Next), 0)) {
-    SubTypes.push_back(cast<CompositeType>(Next));
+         indexReallyValid(CompositeType::get(Next), 0)) {
+    SubTypes.push_back(CompositeType::get(Next));
     Path.push_back(0);
-    Next = cast<CompositeType>(Next)->getTypeAtIndex(0U);
+    Next = CompositeType::get(Next)->getTypeAtIndex(0U);
   }
 
   // If there's no Path now, Next was originally scalar already (or empty
   // leaf). We're done.
   if (Path.empty())
     return true;
 
   // Otherwise, use normal iteration to keep looking through the tree until we

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

 }
 
 static void emitGlobalConstantDataSequential(const DataLayout &DL,
                                              const ConstantDataSequential *CDS,
                                              AsmPrinter &AP) {
   // See if we can aggregate this into a .fill, if so, emit it as such.
   int Value = isRepeatedByteSequence(CDS, DL);
   if (Value != -1) {
-    uint64_t Bytes = DL.getTypeAllocSize(CDS->getType());
+    uint64_t Bytes = DL.getTypeAllocSize(CDS->getType()->from());
     // Don't emit a 1-byte object as a .fill.
     if (Bytes > 1)
       return AP.OutStreamer->emitFill(Bytes, Value);
   }
 
   // If this can be emitted with .ascii/.asciz, emit it as such.
   if (CDS->isString())
     return AP.OutStreamer->emitBytes(CDS->getAsString());
for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) {
                                    ElementByteSize);
     }
   } else {
     Type *ET = CDS->getElementType();
     for (unsigned I = 0, E = CDS->getNumElements(); I != E; ++I)
       emitGlobalConstantFP(CDS->getElementAsAPFloat(I), ET, AP);
   }
 
-  unsigned Size = DL.getTypeAllocSize(CDS->getType());
+  unsigned Size = DL.getTypeAllocSize(CDS->getType()->from());
   unsigned EmittedSize = DL.getTypeAllocSize(CDS->getType()->getElementType()) *
                         CDS->getNumElements();
   assert(EmittedSize <= Size && "Size cannot be less than EmittedSize!");
   if (unsigned Padding = Size - EmittedSize)
     AP.OutStreamer->emitZeros(Padding);
 }
 
 static void emitGlobalConstantArray(const DataLayout &DL,

llvm/lib/FuzzMutate/Operations.cpp

for (int I = 0, E = STy->getNumElements(); I < E; ++I)
       makeConstantsWithType(STy->getTypeAtIndex(I), Result);
     return Result;
   };
   return {Pred, Make};
 }
 
 static SourcePred validInsertValueIndex() {
   auto Pred = [](ArrayRef<Value *> Cur, const Value *V) {
-    auto *CTy = cast<CompositeType>(Cur[0]->getType());
+    auto *CTy = CompositeType::get(Cur[0]->getType());
     if (auto *CI = dyn_cast<ConstantInt>(V))
       if (CI->getBitWidth() == 32 &&
           CTy->getTypeAtIndex(CI->getZExtValue()) == Cur[1]->getType())
         return true;
     return false;
   };
   auto Make = [](ArrayRef<Value *> Cur, ArrayRef<Type *> Ts) {
     std::vector<Constant *> Result;
     auto *Int32Ty = Type::getInt32Ty(Cur[0]->getContext());
-    auto *CTy = cast<CompositeType>(Cur[0]->getType());
-    for (int I = 0, E = getAggregateNumElements(CTy); I < E; ++I)
+    auto *CTy = CompositeType::get(Cur[0]->getType());
+    for (int I = 0, E = getAggregateNumElements(Cur[0]->getType()); I < E; ++I)
       if (CTy->getTypeAtIndex(I) == Cur[1]->getType())
         Result.push_back(ConstantInt::get(Int32Ty, I));
     return Result;
   };
   return {Pred, Make};
 }
 
 OpDescriptor llvm::fuzzerop::insertValueDescriptor(unsigned Weight) {

llvm/lib/IR/ConstantFold.cpp

if (PointerType *DPTy = dyn_cast<PointerType>(DestTy))
           Constant::getNullValue(Type::getInt32Ty(DPTy->getContext()));
         IdxList.push_back(Zero);
         Type *ElTy = PTy->getElementType();
         while (ElTy != DPTy->getElementType()) {
           if (StructType *STy = dyn_cast<StructType>(ElTy)) {
             if (STy->getNumElements() == 0) break;
             ElTy = STy->getElementType(0);
             IdxList.push_back(Zero);
-          } else if (SequentialType *STy =
-                     dyn_cast<SequentialType>(ElTy)) {
+          } else if (SequentialType *STy = dyn_cast_or_null<SequentialType>(
+                         CompositeType::get(ElTy, false))) {
             ElTy = STy->getElementType();
             IdxList.push_back(Zero);
           } else {
             break;
           }
         }
 
         if (ElTy == DPTy->getElementType())
Constant *llvm::ConstantFoldInsertValueInstruction(Constant *Agg,
   // Base case: no indices, so replace the entire value.
   if (Idxs.empty())
     return Val;
 
   unsigned NumElts;
   if (StructType *ST = dyn_cast<StructType>(Agg->getType()))
     NumElts = ST->getNumElements();
   else
-    NumElts = cast<SequentialType>(Agg->getType())->getNumElements();
+    NumElts = cast<SequentialType>(CompositeType::get(Agg->getType()))
+                  ->getNumElements();
 
   SmallVector<Constant*, 32> Result;
   for (unsigned i = 0; i != NumElts; ++i) {
     Constant *C = Agg->getAggregateElement(i);
     if (!C) return nullptr;
 
     if (Idxs[0] == i)
       C = ConstantFoldInsertValueInstruction(C, Val, Idxs.slice(1));
Constant *llvm::ConstantFoldGetElementPtr(Type *PointeeTy, Constant *C,
   // notional array or vector bounds. If so, try to determine if they can be
   // factored out into preceding dimensions.
   SmallVector<Constant *, 8> NewIdxs;
   Type *Ty = PointeeTy;
   Type *Prev = C->getType();
   bool Unknown =
       !isa<ConstantInt>(Idxs[0]) && !isa<ConstantDataVector>(Idxs[0]);
   for (unsigned i = 1, e = Idxs.size(); i != e;
-       Prev = Ty, Ty = cast<CompositeType>(Ty)->getTypeAtIndex(Idxs[i]), ++i) {
+       Prev = Ty, Ty = CompositeType::get(Ty)->getTypeAtIndex(Idxs[i]), ++i) {
     if (!isa<ConstantInt>(Idxs[i]) && !isa<ConstantDataVector>(Idxs[i])) {
       // We don't know if it's in range or not.
       Unknown = true;
       continue;
     }
     if (!isa<ConstantInt>(Idxs[i - 1]) && !isa<ConstantDataVector>(Idxs[i - 1]))
       // Skip if the type of the previous index is not supported.
       continue;
     if (InRangeIndex && i == *InRangeIndex + 1) {
       // If an index is marked inrange, we cannot apply this canonicalization to
       // the following index, as that will cause the inrange index to point to
       // the wrong element.
       continue;
     }
     if (isa<StructType>(Ty)) {
       // The verify makes sure that GEPs into a struct are in range.
       continue;
     }
-    auto *STy = cast<SequentialType>(Ty);
+    auto *STy = cast<SequentialType>(CompositeType::get(Ty));
     if (isa<VectorType>(STy)) {
       // There can be awkward padding in after a non-power of two vector.
       Unknown = true;
       continue;
     }
     if (ConstantInt *CI = dyn_cast<ConstantInt>(Idxs[i])) {
       if (isIndexInRangeOfArrayType(STy->getNumElements(), CI))
         // It's in range, skip to the next index.
if (isa<StructType>(Prev)) {
       // so we can't do anything about it.
       Unknown = true;
       continue;
     }
     // It's out of range, but we can factor it into the prior
     // dimension.
     NewIdxs.resize(Idxs.size());
     // Determine the number of elements in our sequential type.
-    uint64_t NumElements = STy->getArrayNumElements();
+    uint64_t NumElements = STy->getNumElements();
 
     // Expand the current index or the previous index to a vector from a scalar
     // if necessary.
     Constant *CurrIdx = cast<Constant>(Idxs[i]);
     auto *PrevIdx =
         NewIdxs[i - 1] ? NewIdxs[i - 1] : cast<Constant>(Idxs[i - 1]);
     bool IsCurrIdxVector = CurrIdx->getType()->isVectorTy();
     bool IsPrevIdxVector = PrevIdx->getType()->isVectorTy();

llvm/lib/IR/Constants.cpp

Constant *ConstantAggregateZero::getSequentialElement() const {
   return Constant::getNullValue(getType()->getSequentialElementType());
 }
 
 Constant *ConstantAggregateZero::getStructElement(unsigned Elt) const {
   return Constant::getNullValue(getType()->getStructElementType(Elt));
 }
 
 Constant *ConstantAggregateZero::getElementValue(Constant *C) const {
-  if (isa<SequentialType>(getType()))
+  if (isa_and_nonnull<SequentialType>(CompositeType::get(getType(), false)))
     return getSequentialElement();
   return getStructElement(cast<ConstantInt>(C)->getZExtValue());
 }
 
 Constant *ConstantAggregateZero::getElementValue(unsigned Idx) const {
-  if (isa<SequentialType>(getType()))
+  if (isa_and_nonnull<SequentialType>(CompositeType::get(getType(), false)))
     return getSequentialElement();
   return getStructElement(Idx);
 }
 
 unsigned ConstantAggregateZero::getNumElements() const {
   Type *Ty = getType();
   if (auto *AT = dyn_cast<ArrayType>(Ty))
     return AT->getNumElements();
UndefValue *UndefValue::getSequentialElement() const {
   return UndefValue::get(getType()->getSequentialElementType());
 }
 
 UndefValue *UndefValue::getStructElement(unsigned Elt) const {
   return UndefValue::get(getType()->getStructElementType(Elt));
 }
 
 UndefValue *UndefValue::getElementValue(Constant *C) const {
-  if (isa<SequentialType>(getType()))
+  if (isa_and_nonnull<SequentialType>(CompositeType::get(getType(), false)))
     return getSequentialElement();
   return getStructElement(cast<ConstantInt>(C)->getZExtValue());
 }
 
 UndefValue *UndefValue::getElementValue(unsigned Idx) const {
-  if (isa<SequentialType>(getType()))
+  if (isa_and_nonnull<SequentialType>(CompositeType::get(getType(), false)))
     return getSequentialElement();
   return getStructElement(Idx);
 }
 
 unsigned UndefValue::getNumElements() const {
   Type *Ty = getType();
-  if (auto *ST = dyn_cast<SequentialType>(Ty))
+  if (auto *ST = dyn_cast<SequentialType>(CompositeType::get(Ty)))
     return ST->getNumElements();
   return Ty->getStructNumElements();
 }
 
 //===----------------------------------------------------------------------===//
 //                            ConstantXXX Classes
 //===----------------------------------------------------------------------===//
 
else if (CFP->getType()->isDoubleTy())
       return getFPSequenceIfElementsMatch<SequenceTy, uint64_t>(V);
   }
 
   return nullptr;
 }
 
 ConstantAggregate::ConstantAggregate(CompositeType *T, ValueTy VT,
                                      ArrayRef<Constant *> V)
-    : Constant(T, VT, OperandTraits<ConstantAggregate>::op_end(this) - V.size(),
+    : Constant(T->from(), VT,
+               OperandTraits<ConstantAggregate>::op_end(this) - V.size(),
                V.size()) {
   llvm::copy(V, op_begin());
 
   // Check that types match, unless this is an opaque struct.
   if (auto *ST = dyn_cast<StructType>(T))
     if (ST->isOpaque())
       return;
   for (unsigned I = 0, E = V.size(); I != E; ++I)
case 64:
       return true;
     default: break;
     }
   }
   return false;
 }
 
 unsigned ConstantDataSequential::getNumElements() const {
-  if (ArrayType *AT = dyn_cast<ArrayType>(getType()))
-    return AT->getNumElements();
-  return getType()->getVectorNumElements();
+  return getType()->getNumElements();
 }
 
 
 uint64_t ConstantDataSequential::getElementByteSize() const {
   return getElementType()->getPrimitiveSizeInBits()/8;
 }
 
 /// Return the start of the specified element.
Constant *ConstantDataSequential::getImpl(StringRef Elements, Type *Ty) {
 
   // The bucket can point to a linked list of different CDS's that have the same
   // body but different types.  For example, 0,0,0,1 could be a 4 element array
   // of i8, or a 1-element array of i32.  They'll both end up in the same
   /// StringMap bucket, linked up by their Next pointers.  Walk the list.
   ConstantDataSequential **Entry = &Slot.second;
   for (ConstantDataSequential *Node = *Entry; Node;
        Entry = &Node->Next, Node = *Entry)
-    if (Node->getType() == Ty)
+    if (Node->getType()->from() == Ty)
       return Node;
 
   // Okay, we didn't get a hit.  Create a node of the right class, link it in,
   // and return it.
   if (isa<ArrayType>(Ty))
     return *Entry = new ConstantDataArray(Ty, Slot.first().data());
 
   assert(isa<VectorType>(Ty));
   return *Entry = new ConstantDataVector(Ty, Slot.first().data());
 }
 
 void ConstantDataSequential::destroyConstantImpl() {
   // Remove the constant from the StringMap.
-  StringMap<ConstantDataSequential*> &CDSConstants =
-    getType()->getContext().pImpl->CDSConstants;
+  StringMap<ConstantDataSequential *> &CDSConstants =
+      getType()->from()->getContext().pImpl->CDSConstants;
 
   StringMap<ConstantDataSequential*>::iterator Slot =
     CDSConstants.find(getRawDataValues());
 
   assert(Slot != CDSConstants.end() && "CDS not found in uniquing table");
 
   ConstantDataSequential **Entry = &Slot->getValue();
 

llvm/lib/IR/Core.cpp

 LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount) {
   return wrap(VectorType::get(unwrap(ElementType), ElementCount));
 }
 
 LLVMTypeRef LLVMGetElementType(LLVMTypeRef WrappedTy) {
   auto *Ty = unwrap<Type>(WrappedTy);
   if (auto *PTy = dyn_cast<PointerType>(Ty))
     return wrap(PTy->getElementType());
-  return wrap(cast<SequentialType>(Ty)->getElementType());
+  return wrap(cast<SequentialType>(CompositeType::get(Ty))->getElementType());
 }
 
 unsigned LLVMGetNumContainedTypes(LLVMTypeRef Tp) {
     return unwrap(Tp)->getNumContainedTypes();
 }
 
 unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy) {
   return unwrap<ArrayType>(ArrayTy)->getNumElements();

llvm/lib/IR/Instructions.cpp

static Type *getIndexedTypeInternal(Type *Agg, ArrayRef<IndexTy> IdxList) {
 
   // If there is at least one index, the top level type must be sized, otherwise
   // it cannot be 'stepped over'.
   if (!Agg->isSized())
     return nullptr;
 
   unsigned CurIdx = 1;
   for (; CurIdx != IdxList.size(); ++CurIdx) {
-    CompositeType *CT = dyn_cast<CompositeType>(Agg);
-    if (!CT || CT->isPointerTy()) return nullptr;
+    CompositeType *CT = CompositeType::get(Agg, false);
+    if (!CT)
+      return nullptr;
     IndexTy Index = IdxList[CurIdx];
     if (!CT->indexValid(Index)) return nullptr;
     Agg = CT->getTypeAtIndex(Index);
   }
   return CurIdx == IdxList.size() ? Agg : nullptr;
 }
 
 Type *GetElementPtrInst::getIndexedType(Type *Ty, ArrayRef<Value *> IdxList) {
if (0 <= SubIndex && SubIndex + (int)Mask.size() <= NumSrcElts) {
     Index = SubIndex;
     return true;
   }
   return false;
 }
 
 bool ShuffleVectorInst::isIdentityWithPadding() const {
   int NumOpElts = Op<0>()->getType()->getVectorNumElements();
-  int NumMaskElts = getType()->getVectorNumElements();
+  int NumMaskElts = getType()->getNumElements();
   if (NumMaskElts <= NumOpElts)
     return false;
 
   // The first part of the mask must choose elements from exactly 1 source op.
   SmallVector<int, 16> Mask = getShuffleMask();
   if (!isIdentityMaskImpl(Mask, NumOpElts))
     return false;
 
   // All extending must be with undef elements.
   for (int i = NumOpElts; i < NumMaskElts; ++i)
     if (Mask[i] != -1)
       return false;
 
   return true;
 }
 
 bool ShuffleVectorInst::isIdentityWithExtract() const {
   int NumOpElts = Op<0>()->getType()->getVectorNumElements();
-  int NumMaskElts = getType()->getVectorNumElements();
+  int NumMaskElts = getType()->getNumElements();
   if (NumMaskElts >= NumOpElts)
     return false;
 
   return isIdentityMaskImpl(getShuffleMask(), NumOpElts);
 }
 
 bool ShuffleVectorInst::isConcat() const {
   // Vector concatenation is differentiated from identity with padding.
   if (isa<UndefValue>(Op<0>()) || isa<UndefValue>(Op<1>()))
     return false;
 
   int NumOpElts = Op<0>()->getType()->getVectorNumElements();
-  int NumMaskElts = getType()->getVectorNumElements();
+  int NumMaskElts = getType()->getNumElements();
   if (NumMaskElts != NumOpElts * 2)
     return false;
 
   // Use the mask length rather than the operands' vector lengths here. We
   // already know that the shuffle returns a vector twice as long as the inputs,
   // and neither of the inputs are undef vectors. If the mask picks consecutive
   // elements from both inputs, then this is a concatenation of the inputs.
   return isIdentityMaskImpl(getShuffleMask(), NumMaskElts);
for (unsigned Index : Idxs) {
     } else if (StructType *ST = dyn_cast<StructType>(Agg)) {
       if (Index >= ST->getNumElements())
         return nullptr;
     } else {
       // Not a valid type to index into.
       return nullptr;
     }
 
-    Agg = cast<CompositeType>(Agg)->getTypeAtIndex(Index);
+    Agg = CompositeType::get(Agg)->getTypeAtIndex(Index);
   }
   return const_cast<Type*>(Agg);
 }
 
 //===----------------------------------------------------------------------===//
 //                             UnaryOperator Class
 //===----------------------------------------------------------------------===//
 

llvm/lib/IR/Type.cpp

 
 bool CompositeType::indexValid(unsigned Idx) const {
   if (auto *STy = dyn_cast<StructType>(this))
     return Idx < STy->getNumElements();
   // Sequential types can be indexed by any integer.
   return true;
 }
 
+CompositeType *CompositeType::get(Type *TY, bool infallible) {
+  if (auto *Retval = dyn_cast<ArrayType>(TY))
+    return Retval;
+  if (auto *Retval = dyn_cast<StructType>(TY))
+    return Retval;
+  if (auto *Retval = dyn_cast<VectorType>(TY))
+    return Retval;
+
+  assert(!infallible && "Invalid conversion from Type to CompositeType");
+
+  return nullptr;
+}
+
+Type *CompositeType::from() {
+  switch (ID) {
+  case TypeID::ArrayTyID:
+    return cast<ArrayType>(this);
+  case TypeID::VectorTyID:
+    return cast<VectorType>(this);
+  case TypeID::StructTyID:
+    return cast<StructType>(this);
+  default:
+    llvm_unreachable("CompositeType is not a valid type");
+  }
+}
+
 //===----------------------------------------------------------------------===//
 //                           ArrayType Implementation
 //===----------------------------------------------------------------------===//
 
 ArrayType::ArrayType(Type *ElType, uint64_t NumEl)
-  : SequentialType(ArrayTyID, ElType, NumEl) {}
+    : Type(ElType->getContext(), ArrayTyID),
+      SequentialType(ArrayTyID, ElType, NumEl) {
+  ContainedTys = &ElType;
+  NumContainedTys = 1;
+}
 
 ArrayType *ArrayType::get(Type *ElementType, uint64_t NumElements) {
   assert(isValidElementType(ElementType) && "Invalid type for array element!");
 
   LLVMContextImpl *pImpl = ElementType->getContext().pImpl;
   ArrayType *&Entry =
     pImpl->ArrayTypes[std::make_pair(ElementType, NumElements)];
 
return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() &&
          !ElemTy->isTokenTy();
 }
 
 //===----------------------------------------------------------------------===//
 //                          VectorType Implementation
 //===----------------------------------------------------------------------===//
 
 VectorType::VectorType(Type *ElType, ElementCount EC)
-  : SequentialType(VectorTyID, ElType, EC.Min), Scalable(EC.Scalable) {}
+    : Type(ElType->getContext(), VectorTyID),
+      SequentialType(VectorTyID, ElType, EC.Min), Scalable(EC.Scalable) {
+  ContainedTys = &ElType;
+  NumContainedTys = 1;
+}
 
 VectorType *VectorType::get(Type *ElementType, ElementCount EC) {
   assert(EC.Min > 0 && "#Elements of a VectorType must be greater than 0");
   assert(isValidElementType(ElementType) && "Element type of a VectorType must "
                                             "be an integer, floating point, or "
                                             "pointer type.");
 
   LLVMContextImpl *pImpl = ElementType->getContext().pImpl;

llvm/lib/Linker/IRMover.cpp

bool TypeMapTy::areTypesIsomorphic(Type *DstTy, Type *SrcTy) {
   } else if (FunctionType *FT = dyn_cast<FunctionType>(DstTy)) {
     if (FT->isVarArg() != cast<FunctionType>(SrcTy)->isVarArg())
       return false;
   } else if (StructType *DSTy = dyn_cast<StructType>(DstTy)) {
     StructType *SSTy = cast<StructType>(SrcTy);
     if (DSTy->isLiteral() != SSTy->isLiteral() ||
         DSTy->isPacked() != SSTy->isPacked())
       return false;
-  } else if (auto *DSeqTy = dyn_cast<SequentialType>(DstTy)) {
+  } else if (auto *DSeqTy = dyn_cast_or_null<SequentialType>(
+                 CompositeType::get(DstTy, false))) {
     if (DSeqTy->getNumElements() !=
-        cast<SequentialType>(SrcTy)->getNumElements())
+        cast<SequentialType>(CompositeType::get(SrcTy))->getNumElements())
       return false;
   }
 
   // Otherwise, we speculate that these two types will line up and recursively
   // check the subelements.
   Entry = DstTy;
   SpeculativeTypes.push_back(SrcTy);
 

llvm/lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp

 static bool tryPromoteAllocaToVector(AllocaInst *Alloca) {
 
   if (DisablePromoteAllocaToVector) {
     LLVM_DEBUG(dbgs() << "  Promotion alloca to vector is disabled\n");
     return false;
   }
 
   Type *AT = Alloca->getAllocatedType();
-  SequentialType *AllocaTy = dyn_cast<SequentialType>(AT);
+  SequentialType *AllocaTy =
+      dyn_cast_or_null<SequentialType>(CompositeType::get(AT, false));
 
   LLVM_DEBUG(dbgs() << "Alloca candidate for vectorization\n");
 
   // FIXME: There is no reason why we can't support larger arrays, we
   // are just being conservative for now.
   // FIXME: We also reject alloca's of the form [ 2 x [ 2 x i32 ]] or equivalent. Potentially these
   // could also be promoted but we don't currently handle this case
   if (!AllocaTy ||

llvm/lib/Target/ARM/ARMISelLowering.cpp

case Intrinsic::arm_neon_vst1x4: {
     // volatile stores with NEON intrinsics not supported
     Info.flags = MachineMemOperand::MOStore;
     return true;
   }
   case Intrinsic::arm_mve_vld2q:
   case Intrinsic::arm_mve_vld4q: {
     Info.opc = ISD::INTRINSIC_W_CHAIN;
     // Conservatively set memVT to the entire set of vectors loaded.
-    Type *VecTy = cast<CompositeType>(I.getType())->getTypeAtIndex(1);
+    Type *VecTy = CompositeType::get(I.getType())->getTypeAtIndex(1);
     unsigned Factor = Intrinsic == Intrinsic::arm_mve_vld2q ? 2 : 4;
     Info.memVT = EVT::getVectorVT(VecTy->getContext(), MVT::i64, Factor * 2);
     Info.ptrVal = I.getArgOperand(0);
     Info.offset = 0;
     Info.align = Align(VecTy->getScalarSizeInBits() / 8);
     // volatile loads with MVE intrinsics not supported
     Info.flags = MachineMemOperand::MOLoad;
     return true;

llvm/lib/Target/Hexagon/HexagonCommonGEP.cpp

struct GepNode {
     friend raw_ostream &operator<< (raw_ostream &OS, const GepNode &GN);
   };
 
   Type *next_type(Type *Ty, Value *Idx) {
     if (auto *PTy = dyn_cast<PointerType>(Ty))
       return PTy->getElementType();
     // Advance the type.
     if (!Ty->isStructTy()) {
-      Type *NexTy = cast<SequentialType>(Ty)->getElementType();
+      Type *NexTy =
+          cast<SequentialType>(CompositeType::get(Ty))->getElementType();
       return NexTy;
     }
     // Otherwise it is a struct type.
     ConstantInt *CI = dyn_cast<ConstantInt>(Idx);
     assert(CI && "Struct type with non-constant index");
     int64_t i = CI->getValue().getSExtValue();
     Type *NextTy = cast<StructType>(Ty)->getElementType(i);
     return NextTy;

llvm/lib/Transforms/IPO/ArgumentPromotion.cpp

for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E;
               Type *IdxTy =
                   (ElTy->isStructTy() ? Type::getInt32Ty(F->getContext())
                                       : Type::getInt64Ty(F->getContext()));
               Ops.push_back(ConstantInt::get(IdxTy, II));
               // Keep track of the type we're currently indexing.
               if (auto *ElPTy = dyn_cast<PointerType>(ElTy))
                 ElTy = ElPTy->getElementType();
               else
-                ElTy = cast<CompositeType>(ElTy)->getTypeAtIndex(II);
+                ElTy = CompositeType::get(ElTy)->getTypeAtIndex(II);
             }
             // And create a GEP to extract those indices.
             V = IRB.CreateGEP(ArgIndex.first, V, Ops, V->getName() + ".idx");
             Ops.clear();
           }
           // Since we're replacing a load make sure we take the alignment
           // of the previous load.
           LoadInst *newLoad =
bool ArgumentPromotionPass::isDenselyPacked(Type *type, const DataLayout &DL) {
   if (!type->isSized())
     return false;
 
   // If the alloc size is not equal to the storage size, then there are padding
   // bytes. For x86_fp80 on x86-64, size: 80 alloc size: 128.
   if (DL.getTypeSizeInBits(type) != DL.getTypeAllocSizeInBits(type))
     return false;
 
-  if (!isa<CompositeType>(type))
+  if (!CompositeType::is(type))
     return true;
 
   // For homogenous sequential types, check for padding within members.
-  if (SequentialType *seqTy = dyn_cast<SequentialType>(type))
+  if (SequentialType *seqTy =
+          dyn_cast<SequentialType>(CompositeType::get(type)))
     return isDenselyPacked(seqTy->getElementType(), DL);
 
   // Check for padding within and between elements of a struct.
   StructType *StructTy = cast<StructType>(type);
   const StructLayout *Layout = DL.getStructLayout(StructTy);
   uint64_t StartPos = 0;
   for (unsigned i = 0, E = StructTy->getNumElements(); i < E; ++i) {
     Type *ElTy = StructTy->getElementType(i);

llvm/lib/Transforms/IPO/GlobalOpt.cpp

static bool isLeakCheckerRoot(GlobalVariable *GV) {
   unsigned Limit = 20;
   do {
     Type *Ty = Types.pop_back_val();
     switch (Ty->getTypeID()) {
       default: break;
       case Type::PointerTyID: return true;
       case Type::ArrayTyID:
       case Type::VectorTyID: {
-        SequentialType *STy = cast<SequentialType>(Ty);
+        SequentialType *STy = cast<SequentialType>(CompositeType::get(Ty));
         Types.push_back(STy->getElementType());
         break;
       }
       case Type::StructTyID: {
         StructType *STy = cast<StructType>(Ty);
         if (STy->isOpaque()) return true;
         for (StructType::element_iterator I = STy->element_begin(),
                  E = STy->element_end(); I != E; ++I) {
           Type *InnerTy = *I;
           if (isa<PointerType>(InnerTy)) return true;
-          if (isa<CompositeType>(InnerTy))
+          if (CompositeType::is(InnerTy))
             Types.push_back(InnerTy);
         }
         break;
       }
     }
     if (--Limit == 0) return true;
   } while (!Types.empty());
   return false;
static bool GlobalUsersSafeToSRA(GlobalValue *GV) {
   return true;
 }
 
 static bool CanDoGlobalSRA(GlobalVariable *GV) {
   Constant *Init = GV->getInitializer();
 
   if (isa<StructType>(Init->getType())) {
     // nothing to check
-  } else if (SequentialType *STy = dyn_cast<SequentialType>(Init->getType())) {
+  } else if (SequentialType *STy = dyn_cast_or_null<SequentialType>(
+                 CompositeType::get(Init->getType(), false))) {
     if (STy->getNumElements() > 16 && GV->hasNUsesOrMore(16))
       return false; // It's not worth it.
   } else
     return false;
 
   return GlobalUsersSafeToSRA(GV);
 }
 
for (User *GEP : GV->users()) {
     unsigned ElementIdx = cast<ConstantInt>(GEP->getOperand(2))->getZExtValue();
     if (NewGlobals.count(ElementIdx) == 1)
       continue; // we`ve already created replacement variable
     assert(NewGlobals.count(ElementIdx) == 0);
 
     Type *ElTy = nullptr;
     if (StructType *STy = dyn_cast<StructType>(Ty))
       ElTy = STy->getElementType(ElementIdx);
-    else if (SequentialType *STy = dyn_cast<SequentialType>(Ty))
+    else if (SequentialType *STy = dyn_cast_or_null<SequentialType>(
+                 CompositeType::get(Ty, false)))
       ElTy = STy->getElementType();
     assert(ElTy);
 
     Constant *In = Init->getAggregateElement(ElementIdx);
     assert(In && "Couldn't get element of initializer?");
 
     GlobalVariable *NGV = new GlobalVariable(
         ElTy, false, GlobalVariable::InternalLinkage, In,
if (StructType *STy = dyn_cast<StructType>(Ty)) {
           Align(DL.getABITypeAlignment(STy->getElementType(ElementIdx))))
         NGV->setAlignment(NewAlign);
 
       // Copy over the debug info for the variable.
       uint64_t Size = DL.getTypeAllocSizeInBits(NGV->getValueType());
       uint64_t FragmentOffsetInBits = Layout.getElementOffsetInBits(ElementIdx);
       transferSRADebugInfo(GV, NGV, FragmentOffsetInBits, Size,
                            STy->getNumElements());
-    } else if (SequentialType *STy = dyn_cast<SequentialType>(Ty)) {
+    } else if (SequentialType *STy = dyn_cast_or_null<SequentialType>(
+                   CompositeType::get(Ty, false))) {
       uint64_t EltSize = DL.getTypeAllocSize(ElTy);
       Align EltAlign(DL.getABITypeAlignment(ElTy));
       uint64_t FragmentSizeInBits = DL.getTypeAllocSizeInBits(ElTy);
 
       // Calculate the known alignment of the field.  If the original aggregate
       // had 256 byte alignment for example, something might depend on that:
       // propagate info to each field.
       Align NewAlign(MinAlign(StartAlignment, EltSize * ElementIdx));
if (StructType *STy = dyn_cast<StructType>(Init->getType())) {
     assert(Idx < STy->getNumElements() && "Struct index out of range!");
     Elts[Idx] = EvaluateStoreInto(Elts[Idx], Val, Addr, OpNo+1);
 
     // Return the modified struct.
     return ConstantStruct::get(STy, Elts);
   }
 
   ConstantInt *CI = cast<ConstantInt>(Addr->getOperand(OpNo));
-  SequentialType *InitTy = cast<SequentialType>(Init->getType());
+  SequentialType *InitTy =
+      cast<SequentialType>(CompositeType::get(Init->getType()));
   uint64_t NumElts = InitTy->getNumElements();
 
   // Break up the array into elements.
   for (uint64_t i = 0, e = NumElts; i != e; ++i)
     Elts.push_back(Init->getAggregateElement(i));
 
   assert(CI->getZExtValue() < NumElts);
   Elts[CI->getZExtValue()] =
if (Update) {
         return;
       // Need to clear and set up cache for new initializer.
       CurrentGV = GV;
       Elts.clear();
       unsigned NumElts;
       if (auto *STy = dyn_cast<StructType>(Ty))
         NumElts = STy->getNumElements();
       else
-        NumElts = cast<SequentialType>(Ty)->getNumElements();
+        NumElts =
+            cast<SequentialType>(CompositeType::get(Ty))->getNumElements();
       for (unsigned i = 0, e = NumElts; i != e; ++i)
         Elts.push_back(Init->getAggregateElement(i));
     }
   };
 
   for (auto CEPair : SimpleCEs) {
     ConstantExpr *GEP = CEPair.first;
     Constant *Val = CEPair.second;

llvm/lib/Transforms/IPO/StripSymbols.cpp

static void RemoveDeadConstant(Constant *C) {
   for (Value *Op : C->operands())
     if (OnlyUsedBy(Op, C))
       Operands.insert(cast<Constant>(Op));
   if (GlobalVariable *GV = dyn_cast<GlobalVariable>(C)) {
     if (!GV->hasLocalLinkage()) return;   // Don't delete non-static globals.
     GV->eraseFromParent();
   }
   else if (!isa<Function>(C))
-    if (isa<CompositeType>(C->getType()))
+    if (CompositeType::is(C->getType()))
       C->destroyConstant();
 
   // If the constant referenced anything, see if we can delete it as well.
   for (Constant *O : Operands)
     RemoveDeadConstant(O);
 }
 
 // Strip the symbol table of its names.

llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp

Type *PointeeType =
         cast<PointerType>(Src->getType()->getScalarType())->getElementType();
     if (!PointeeType->isSized())
       return nullptr;
 
     // If the source and destination are pointers, and this cast is equivalent
     // to a getelementptr X, 0, 0, 0...  turn it into the appropriate gep.
     // This can enhance SROA and other transforms that want type-safe pointers.
     unsigned NumZeros = 0;
-    while (SrcElTy != DstElTy &&
-           isa<CompositeType>(SrcElTy) && !SrcElTy->isPointerTy() &&
+    while (SrcElTy != DstElTy && CompositeType::is(SrcElTy) &&
+           !SrcElTy->isPointerTy() &&
            SrcElTy->getNumContainedTypes() /* not "{}" */) {
-      SrcElTy = cast<CompositeType>(SrcElTy)->getTypeAtIndex(0U);
+      SrcElTy = CompositeType::get(SrcElTy)->getTypeAtIndex(0U);
       ++NumZeros;
     }
 
     // If we found a path from the src to dest, create the getelementptr now.
     if (SrcElTy == DstElTy) {
       SmallVector<Value *, 8> Idxs(NumZeros + 1, Builder.getInt32(0));
       GetElementPtrInst *GEP =
           GetElementPtrInst::Create(SrcPTy->getElementType(), Src, Idxs);

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

for (auto I = PN->op_begin()+1, E = PN->op_end(); I !=E; ++I) {
             return nullptr;
           }
         }
 
         // Sink down a layer of the type for the next iteration.
         if (J > 0) {
           if (J == 1) {
             CurTy = Op1->getSourceElementType();
-          } else if (auto *CT = dyn_cast<CompositeType>(CurTy)) {
+          } else if (auto *CT = CompositeType::get(CurTy, false)) {
             CurTy = CT->getTypeAtIndex(Op1->getOperand(J));
           } else {
             CurTy = nullptr;
           }
         }
       }
     }
 

llvm/lib/Transforms/Scalar/SROA.cpp

 static Type *getTypePartition(const DataLayout &DL, Type *Ty, uint64_t Offset,
                               uint64_t Size) {
   if (Offset == 0 && DL.getTypeAllocSize(Ty) == Size)
     return stripAggregateTypeWrapping(DL, Ty);
   if (Offset > DL.getTypeAllocSize(Ty) ||
       (DL.getTypeAllocSize(Ty) - Offset) < Size)
     return nullptr;
 
-  if (SequentialType *SeqTy = dyn_cast<SequentialType>(Ty)) {
+  if (SequentialType *SeqTy =
+          dyn_cast_or_null<SequentialType>(CompositeType::get(Ty, false))) {
     Type *ElementTy = SeqTy->getElementType();
     uint64_t ElementSize = DL.getTypeAllocSize(ElementTy);
     uint64_t NumSkippedElements = Offset / ElementSize;
     if (NumSkippedElements >= SeqTy->getNumElements())
       return nullptr;
     Offset -= NumSkippedElements * ElementSize;
 
     // First check if we need to recurse.

llvm/lib/Transforms/Utils/FunctionComparator.cpp

for (unsigned i = 0, e = FTyL->getNumParams(); i != e; ++i) {
       if (int Res = cmpTypes(FTyL->getParamType(i), FTyR->getParamType(i)))
         return Res;
     }
     return 0;
   }
 
   case Type::ArrayTyID:
   case Type::VectorTyID: {
-    auto *STyL = cast<SequentialType>(TyL);
-    auto *STyR = cast<SequentialType>(TyR);
+    auto *STyL = cast<SequentialType>(CompositeType::get(TyL));
+    auto *STyR = cast<SequentialType>(CompositeType::get(TyR));
     if (STyL->getNumElements() != STyR->getNumElements())
       return cmpNumbers(STyL->getNumElements(), STyR->getNumElements());
     return cmpTypes(STyL->getElementType(), STyR->getElementType());
   }
   }
 }
 
 // Determine whether the two operations are the same except that pointer-to-A

llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp

default:
       return;
   }
 }
 
 unsigned BoUpSLP::canMapToVector(Type *T, const DataLayout &DL) const {
   unsigned N = 1;
   Type *EltTy = T;
 
-  while (isa<CompositeType>(EltTy)) {
+  while (CompositeType::is(EltTy)) {
     if (auto *ST = dyn_cast<StructType>(EltTy)) {
       // Check that struct is homogeneous.
       for (const auto *Ty : ST->elements())
         if (Ty != *ST->element_begin())
           return 0;
       N *= ST->getNumElements();
       EltTy = *ST->element_begin();
     } else {
-      auto *SeqT = cast<SequentialType>(EltTy);
+      auto *SeqT = cast<SequentialType>(CompositeType::get(EltTy));
       N *= SeqT->getNumElements();
       EltTy = SeqT->getElementType();
     }
   }
 
   if (!isValidElementType(EltTy))
     return 0;
   uint64_t VTSize = DL.getTypeStoreSizeInBits(VectorType::get(EltTy, N));