[CodeGen][WIP] Avoid generating Record layouts for pointee types

[teemperor]

Summary

This is a WIP patch that tries to avoid creating a RecordLayout in Clang and instead just emit an opaque structure type
as if we only had a forward declarations. The main motivation for this patch is actually just supporting a use case in LLDB
where laying out types can be very expensive as it usually triggers parsing of debug information.

The changes in this patch can be summarized as:

• CodeGenTypes::ConvertRecordDeclType (and related funcs) have a new parameter that tells us if we need the definition. It's currently only set to false for Clang pointer types.
• There are a few new places where I added (temporary) calls to ConvertTypeForMem() on some pointee types. The reason is that the code after is usually creating GEP instructions where we need a non-opaque source type. We can't do this automatically from the GEP factory methods as they would need to know the clang::Type to automatically do this (and they only have the llvm::Type that can't be mapped back to a clang::Type from what I can see, but that might be incorrect).
• A few test that needed to be adjusted as they relied on e.g. Foo *x to be enough to force Foo to be laid out/emitted.

There are still about a dozen more tests failing but from what I can see they all just need to be adjusted to force specific types to be emitted. I'll fix those up once there is consensus that this patch is going in the right direction.

Some benchmarks: I did a stage2 build of LLVM+Clang with my patch and those are the stats:

current ToT Clang:
2232421 - total amount of struct types created
  94911 - of which are opaque struct types

with this patch:
1715074 - total amount of struct types created (-23%)
 173127 - of which are opaque struct types (+82%)

I built a part of Clang (the last 300 source files in the compile_commands.json) and the average time on my 64 core machine changes like this (as per hyperfine):

Benchmark #1: parallel --progress -j63 -a ToT-clang
  Time (mean ± σ):     27.703 s ±  0.168 s    [User: 1434.619 s, System: 66.687 s]
  Range (min … max):   27.459 s … 27.891 s    10 runs
 
Benchmark #2: parallel --progress -j63 -a with-patch
  Time (mean ± σ):     27.439 s ±  0.111 s    [User: 1427.739 s, System: 66.220 s]
  Range (min … max):   27.300 s … 27.625 s    10 runs
 
Summary
  'parallel --progress -j63 -a with-patch' ran
    1.01 ± 0.01 times faster than 'parallel --progress -j63 -a ToT-clang'

[teemperor]

I'm mostly putting this up to get some early feedback if anyone sees a problem with using opaque types here (e.g. it breaks some optimizations, etc.). If it does, it would still be nice if we could at least make this happen on some opt-in bases as it would be very beneficial for improving the performance of LLDB.

llvm/include/llvm/IR/Instructions.h

1176

)This change and the one below slipped in by accident, that was more of a debugging help that I wanted to put up as a separate patch.)

[dblaikie]

Notion seems plausible - though if there's some way to refactor so there's less need for manual insertion/maintenance of calls to ConvertTypeForMem that'd be good/important. I don't think there'd be anything fundamentally wrong with this approach - though checking some workloads to see if you can get bit identical results (eg: does some interesting binaries (including a clang selfhost) built with/without this patch compile to exactly the same file?) would probably be a good place to start to check the soundness.

[rjmccall]

I have no problem with breaking LLVM analyses that rely on record types being filled in when they don't need to be. I've been consistently telling people for years that they shouldn't be relying on IR types for things like that.

I would stick with the frontend terminology of a "complete" type, though. And you might consider adding a function to CGT which completes a type, both for clarity and so that you can fast-path the common case where you've already got a sized type.

You can probably rip out the UpdateCompletedType logic when you're done.

clang/include/clang/AST/Type.h

static void Profile(llvm::FoldingSetNodeID &ID, QualType BaseType,
     ID.AddInteger((unsigned)UKind);
   }
 };
 
 class TagType : public Type {
   friend class ASTReader;
   template <class T> friend class serialization::AbstractTypeReader;
 
+protected:
   /// Stores the TagDecl associated with this type. The decl may point to any
   /// TagDecl that declares the entity.
   TagDecl *decl;
 
 protected:
   TagType(TypeClass TC, const TagDecl *D, QualType can);
 
 public:
protected:
 
   explicit RecordType(const RecordDecl *D)
       : TagType(Record, reinterpret_cast<const TagDecl*>(D), QualType()) {}
   explicit RecordType(TypeClass TC, RecordDecl *D)
       : TagType(TC, reinterpret_cast<const TagDecl*>(D), QualType()) {}
 
 public:
   RecordDecl *getDecl() const {
     return reinterpret_cast<RecordDecl*>(TagType::getDecl());
   }
 
+  /// Returns one of the RecordDecls that declare this RecordType.
+  RecordDecl *getAnyDecl() const {
+    return reinterpret_cast<RecordDecl*>(decl);
+  }
+
   /// Recursively check all fields in the record for const-ness. If any field
   /// is declared const, return true. Otherwise, return false.
   bool hasConstFields() const;
 
   bool isSugared() const { return false; }
   QualType desugar() const { return QualType(this, 0); }
 
   static bool classof(const Type *T) { return T->getTypeClass() == Record; }

clang/lib/CodeGen/CGExpr.cpp

static Address emitArraySubscriptGEP(CodeGenFunction &CGF, Address addr,
                                      const Expr *Base = nullptr,
                                      const llvm::Twine &name = "arrayidx") {
   // All the indices except that last must be zero.
 #ifndef NDEBUG
   for (auto idx : indices.drop_back())
     assert(isa<llvm::ConstantInt>(idx) &&
            cast<llvm::ConstantInt>(idx)->isZero());
 #endif
+  // Size needed for pointer arithmethic.
+  CGF.ConvertTypeForMem(eltType);
 
   // Determine the element size of the statically-sized base.  This is
   // the thing that the indices are expressed in terms of.
   if (auto vla = CGF.getContext().getAsVariableArrayType(eltType)) {
     eltType = getFixedSizeElementType(CGF.getContext(), vla);
   }
 
   // We can use that to compute the best alignment of the element.

clang/lib/CodeGen/CGExprCXX.cpp

return CGF.CGM.getCXXABI().EmitTypeid(CGF, SrcRecordTy, ThisPtr,
                                         StdTypeInfoPtrTy);
 }
 
 llvm::Value *CodeGenFunction::EmitCXXTypeidExpr(const CXXTypeidExpr *E) {
   llvm::Type *StdTypeInfoPtrTy =
     ConvertType(E->getType())->getPointerTo();
 
   if (E->isTypeOperand()) {
+    // Just to get tests passing which expect the struct type to be complete.
+    ConvertTypeForMem(E->getTypeOperand(getContext()));
     llvm::Constant *TypeInfo =
         CGM.GetAddrOfRTTIDescriptor(E->getTypeOperand(getContext()));
     return Builder.CreateBitCast(TypeInfo, StdTypeInfoPtrTy);
   }
 
   // C++ [expr.typeid]p2:
   //   When typeid is applied to a glvalue expression whose type is a
   //   polymorphic class type, the result refers to a std::type_info object

clang/lib/CodeGen/CGExprScalar.cpp

// Most common case by far: integer increment.
     } else {
       llvm::Value *amt = llvm::ConstantInt::get(value->getType(), amount, true);
       value = Builder.CreateAdd(value, amt, isInc ? "inc" : "dec");
     }
 
   // Next most common: pointer increment.
   } else if (const PointerType *ptr = type->getAs<PointerType>()) {
     QualType type = ptr->getPointeeType();
+    // Size required for pointer arithmetic.
+    CGF.ConvertTypeForMem(type);
 
     // VLA types don't have constant size.
     if (const VariableArrayType *vla
           = CGF.getContext().getAsVariableArrayType(type)) {
       llvm::Value *numElts = CGF.getVLASize(vla).NumElts;
       if (!isInc) numElts = Builder.CreateNSWNeg(numElts, "vla.negsize");
       if (CGF.getLangOpts().isSignedOverflowDefined())
         value = Builder.CreateGEP(value->getType()->getPointerElementType(),
CGF.EmitBoundsCheck(op.E, pointerOperand, index, indexOperand->getType(),
                         /*Accessed*/ false);
 
   const PointerType *pointerType
     = pointerOperand->getType()->getAs<PointerType>();
   if (!pointerType) {
     QualType objectType = pointerOperand->getType()
                                         ->castAs<ObjCObjectPointerType>()
                                         ->getPointeeType();
+    // Size needed for pointer arithmetic.
+    CGF.ConvertTypeForMem(objectType);
     llvm::Value *objectSize
       = CGF.CGM.getSize(CGF.getContext().getTypeSizeInChars(objectType));
 
     index = CGF.Builder.CreateMul(index, objectSize);
 
     Value *result = CGF.Builder.CreateBitCast(pointer, CGF.VoidPtrTy);
     result = CGF.Builder.CreateGEP(CGF.Int8Ty, result, index, "add.ptr");
     return CGF.Builder.CreateBitCast(result, pointer->getType());
   }
 
   QualType elementType = pointerType->getPointeeType();
+  // Size needed for pointer arithmetic.
+  CGF.ConvertTypeForMem(elementType);
   if (const VariableArrayType *vla
         = CGF.getContext().getAsVariableArrayType(elementType)) {
     // The element count here is the total number of non-VLA elements.
     llvm::Value *numElements = CGF.getVLASize(vla).NumElts;
 
     // Effectively, the multiply by the VLA size is part of the GEP.
     // GEP indexes are signed, and scaling an index isn't permitted to
     // signed-overflow, so we use the same semantics for our explicit

clang/lib/CodeGen/CGOpenMPRuntime.cpp

static void EmitOMPAggregateReduction(
   Address RHSAddr = CGF.GetAddrOfLocalVar(RHSVar);
 
   // Drill down to the base element type on both arrays.
   const ArrayType *ArrayTy = Type->getAsArrayTypeUnsafe();
   llvm::Value *NumElements = CGF.emitArrayLength(ArrayTy, ElementTy, LHSAddr);
 
   llvm::Value *RHSBegin = RHSAddr.getPointer();
   llvm::Value *LHSBegin = LHSAddr.getPointer();
+  // Ensure sie for CreateGEP below.
+  CGF.ConvertTypeForMem(LHSVar->getType());
   // Cast from pointer to array type to pointer to single element.
   llvm::Value *LHSEnd =
       CGF.Builder.CreateGEP(LHSAddr.getElementType(), LHSBegin, NumElements);
   // The basic structure here is a while-do loop.
   llvm::BasicBlock *BodyBB = CGF.createBasicBlock("omp.arraycpy.body");
   llvm::BasicBlock *DoneBB = CGF.createBasicBlock("omp.arraycpy.done");
   llvm::Value *IsEmpty =
       CGF.Builder.CreateICmpEQ(LHSBegin, LHSEnd, "omp.arraycpy.isempty");
void CGOpenMPRuntime::emitUserDefinedMapper(const OMPDeclareMapperDecl *D,
   CGM.getCXXABI().getMangleContext().mangleTypeName(Ty, Out);
   std::string Name = getName({"omp_mapper", TyStr, D->getName()});
   auto *Fn = llvm::Function::Create(FnTy, llvm::GlobalValue::InternalLinkage,
                                     Name, &CGM.getModule());
   CGM.SetInternalFunctionAttributes(GlobalDecl(), Fn, FnInfo);
   Fn->removeFnAttr(llvm::Attribute::OptimizeNone);
   // Start the mapper function code generation.
   CodeGenFunction MapperCGF(CGM);
+  MapperCGF.ConvertTypeForMem(Ty);
   MapperCGF.StartFunction(GlobalDecl(), C.VoidTy, Fn, FnInfo, Args, Loc, Loc);
   // Compute the starting and end addresses of array elements.
   llvm::Value *Size = MapperCGF.EmitLoadOfScalar(
       MapperCGF.GetAddrOfLocalVar(&SizeArg), /*Volatile=*/false,
       C.getPointerType(Int64Ty), Loc);
   // Prepare common arguments for array initiation and deletion.
   llvm::Value *Handle = MapperCGF.EmitLoadOfScalar(
       MapperCGF.GetAddrOfLocalVar(&HandleArg),

clang/lib/CodeGen/CodeGenTypes.h

public:
   /// Convert clang calling convention to LLVM callilng convention.
   unsigned ClangCallConvToLLVMCallConv(CallingConv CC);
 
   /// Derives the 'this' type for codegen purposes, i.e. ignoring method CVR
   /// qualification.
   CanQualType DeriveThisType(const CXXRecordDecl *RD, const CXXMethodDecl *MD);
 
   /// ConvertType - Convert type T into a llvm::Type.
-  llvm::Type *ConvertType(QualType T);
+  llvm::Type *ConvertType(QualType T, bool RequireSize = true);
 
   /// ConvertTypeForMem - Convert type T into a llvm::Type.  This differs from
   /// ConvertType in that it is used to convert to the memory representation for
   /// a type.  For example, the scalar representation for _Bool is i1, but the
   /// memory representation is usually i8 or i32, depending on the target.
-  llvm::Type *ConvertTypeForMem(QualType T, bool ForBitField = false);
+  llvm::Type *ConvertTypeForMem(QualType T, bool ForBitField = false, bool RequireSize = true);
 
   /// GetFunctionType - Get the LLVM function type for \arg Info.
   llvm::FunctionType *GetFunctionType(const CGFunctionInfo &Info);
 
   llvm::FunctionType *GetFunctionType(GlobalDecl GD);
 
   /// isFuncTypeConvertible - Utility to check whether a function type can
   /// be converted to an LLVM type (i.e. doesn't depend on an incomplete tag
public:
   /// addRecordTypeName - Compute a name from the given record decl with an
   /// optional suffix and name the given LLVM type using it.
   void addRecordTypeName(const RecordDecl *RD, llvm::StructType *Ty,
                          StringRef suffix);
 
 
 public:  // These are internal details of CGT that shouldn't be used externally.
   /// ConvertRecordDeclType - Lay out a tagged decl type like struct or union.
-  llvm::StructType *ConvertRecordDeclType(const RecordDecl *TD);
+  llvm::StructType *ConvertRecordDeclType(const RecordDecl *TD, bool RequireSize = true);
 
   /// getExpandedTypes - Expand the type \arg Ty into the LLVM
   /// argument types it would be passed as. See ABIArgInfo::Expand.
   void getExpandedTypes(QualType Ty,
                         SmallVectorImpl<llvm::Type *>::iterator &TI);
 
   /// IsZeroInitializable - Return whether a type can be
   /// zero-initialized (in the C++ sense) with an LLVM zeroinitializer.

clang/lib/CodeGen/CodeGenTypes.cpp

void CodeGenTypes::addRecordTypeName(const RecordDecl *RD,
 
   Ty->setName(OS.str());
 }
 
 /// ConvertTypeForMem - Convert type T into a llvm::Type.  This differs from
 /// ConvertType in that it is used to convert to the memory representation for
 /// a type.  For example, the scalar representation for _Bool is i1, but the
 /// memory representation is usually i8 or i32, depending on the target.
-llvm::Type *CodeGenTypes::ConvertTypeForMem(QualType T, bool ForBitField) {
+llvm::Type *CodeGenTypes::ConvertTypeForMem(QualType T, bool ForBitField, bool RequireSize) {
   if (T->isConstantMatrixType()) {
     const Type *Ty = Context.getCanonicalType(T).getTypePtr();
     const ConstantMatrixType *MT = cast<ConstantMatrixType>(Ty);
     return llvm::ArrayType::get(ConvertType(MT->getElementType()),
                                 MT->getNumRows() * MT->getNumColumns());
   }
 
-  llvm::Type *R = ConvertType(T);
+  llvm::Type *R = ConvertType(T, RequireSize);
 
   // If this is a bool type, or an ExtIntType in a bitfield representation,
   // map this integer to the target-specified size.
   if ((ForBitField && T->isExtIntType()) ||
       (!T->isExtIntType() && R->isIntegerTy(1)))
     return llvm::IntegerType::get(getLLVMContext(),
                                   (unsigned)Context.getTypeSize(T));
 
llvm::Type *CodeGenTypes::ConvertFunctionTypeInternal(QualType QFT) {
 
   if (RecordsBeingLaidOut.empty())
     while (!DeferredRecords.empty())
       ConvertRecordDeclType(DeferredRecords.pop_back_val());
   return ResultType;
 }
 
 /// ConvertType - Convert the specified type to its LLVM form.
-llvm::Type *CodeGenTypes::ConvertType(QualType T) {
+llvm::Type *CodeGenTypes::ConvertType(QualType T, bool RequireSize) {
   T = Context.getCanonicalType(T);
 
   const Type *Ty = T.getTypePtr();
 
   // For the device-side compilation, CUDA device builtin surface/texture types
   // may be represented in different types.
   if (Context.getLangOpts().CUDAIsDevice) {
     if (T->isCUDADeviceBuiltinSurfaceType()) {
       if (auto *Ty = CGM.getTargetCodeGenInfo()
                          .getCUDADeviceBuiltinSurfaceDeviceType())
         return Ty;
     } else if (T->isCUDADeviceBuiltinTextureType()) {
       if (auto *Ty = CGM.getTargetCodeGenInfo()
                          .getCUDADeviceBuiltinTextureDeviceType())
         return Ty;
     }
   }
 
   // RecordTypes are cached and processed specially.
   if (const RecordType *RT = dyn_cast<RecordType>(Ty))
-    return ConvertRecordDeclType(RT->getDecl());
+    return ConvertRecordDeclType(RT->getAnyDecl(), RequireSize);
 
   // See if type is already cached.
   llvm::DenseMap<const Type *, llvm::Type *>::iterator TCI = TypeCache.find(Ty);
   // If type is found in map then use it. Otherwise, convert type T.
   if (TCI != TypeCache.end())
     return TCI->second;
 
   // If we don't have it in the cache, convert it now.
case Type::RValueReference: {
     llvm::Type *PointeeType = ConvertTypeForMem(ETy);
     unsigned AS = Context.getTargetAddressSpace(ETy);
     ResultType = llvm::PointerType::get(PointeeType, AS);
     break;
   }
   case Type::Pointer: {
     const PointerType *PTy = cast<PointerType>(Ty);
     QualType ETy = PTy->getPointeeType();
-    llvm::Type *PointeeType = ConvertTypeForMem(ETy);
+    llvm::Type *PointeeType = ConvertTypeForMem(ETy, false, false);
     if (PointeeType->isVoidTy())
       PointeeType = llvm::Type::getInt8Ty(getLLVMContext());
 
     unsigned AS = PointeeType->isFunctionTy()
                       ? getDataLayout().getProgramAddressSpace()
                       : Context.getTargetAddressSpace(ETy);
 
     ResultType = llvm::PointerType::get(PointeeType, AS);
bool CodeGenModule::isPaddedAtomicType(QualType type) {
   return isPaddedAtomicType(type->castAs<AtomicType>());
 }
 
 bool CodeGenModule::isPaddedAtomicType(const AtomicType *type) {
   return Context.getTypeSize(type) != Context.getTypeSize(type->getValueType());
 }
 
 /// ConvertRecordDeclType - Lay out a tagged decl type like struct or union.
-llvm::StructType *CodeGenTypes::ConvertRecordDeclType(const RecordDecl *RD) {
+llvm::StructType *CodeGenTypes::ConvertRecordDeclType(const RecordDecl *RD, bool RequireSize) {
   // TagDecl's are not necessarily unique, instead use the (clang)
   // type connected to the decl.
   const Type *Key = Context.getTagDeclType(RD).getTypePtr();
 
   llvm::StructType *&Entry = RecordDeclTypes[Key];
 
   // If we don't have a StructType at all yet, create the forward declaration.
   if (!Entry) {
     Entry = llvm::StructType::create(getLLVMContext());
     addRecordTypeName(RD, Entry, "");
   }
   llvm::StructType *Ty = Entry;
 
+  // If the size of the type isn't required, then nothing left to do.
+  // FIXME: Implicit records are always emitted as a many parts of CodeGen
+  // expect internal builtin records such as kmp_depend_info_t, __va_list etc.
+  // to be laid out.
+  if (!RequireSize && !RD->isImplicit())
+    return Ty;
+
+  RD = RD->getDefinition();
+
   // If this is still a forward declaration, or the LLVM type is already
   // complete, there's nothing more to do.
-  RD = RD->getDefinition();
   if (!RD || !RD->isCompleteDefinition() || !Ty->isOpaque())
     return Ty;
 
   // If converting this type would cause us to infinitely loop, don't do it!
   if (!isSafeToConvert(RD, *this)) {
     DeferredRecords.push_back(RD);
     return Ty;
   }

clang/test/CodeGen/c11atomics.c

 struct ptr {
     struct elem *ptr;
 };
 // CHECK-DAG: %struct.ptr = type { %struct.elem* }
 
 struct elem {
     _Atomic(struct ptr) link;
 };
-// CHECK-DAG: %struct.elem = type { %struct.ptr }
+// CHECK-DAG: %struct.elem = type opaque
 
 struct ptr object;
 // CHECK-DAG: @object ={{.*}} global %struct.ptr zeroinitializer
 
 // CHECK-DAG: @testStructGlobal ={{.*}} global {{.*}} { i16 1, i16 2, i16 3, i16 4 }
 // CHECK-DAG: @testPromotedStructGlobal ={{.*}} global {{.*}} { %{{.*}} { i16 1, i16 2, i16 3 }, [2 x i8] zeroinitializer }
 
 

clang/test/CodeGenCXX/class-layout.cpp

 // RUN: %clang_cc1 %s -triple x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s
 
 // An extra byte should be allocated for an empty class.
 namespace Test1 {
   // CHECK: %"struct.Test1::A" = type { i8 }
-  struct A { } *a;
+  struct A { } a;
 }
 
 namespace Test2 {
   // No need to add tail padding here.
   // CHECK: %"struct.Test2::A" = type { i8*, i32 }
-  struct A { void *a; int b; } *a;
+  struct A { void *a; int b; } a;
 }
 
 namespace Test3 {
   // C should have a vtable pointer.
   // CHECK: %"struct.Test3::A" = type <{ i32 (...)**, i32, [4 x i8] }>
-  struct A { virtual void f(); int a; } *a;
+  struct A { virtual void f(); int a; } a;
 }
 
 namespace Test4 {
   // Test from PR5589.
   // CHECK: %"struct.Test4::B" = type { %"struct.Test4::A", i16, double }
   // CHECK: %"struct.Test4::A" = type { i32, i8, float }
   struct A {
     int a;
     char c;
     float b;
   };
   struct B : public A {
     short d;
     double e;
-  } *b;
+  } b;
 }
 
 namespace Test5 {
   struct A {
     virtual void f();
     char a;
   };
 
   // CHECK: %"struct.Test5::B" = type {  %"struct.Test5::A.base", i8, i8, [5 x i8] }
   struct B : A {
     char b : 1;
     char c;
-  } *b;
+  } b;
 }
 
 // PR10912: don't crash
 namespace Test6 {
   template <typename T> class A {
     // If T is complete, IR-gen will want to translate it recursively
     // when translating T*.
     T *foo;

 
 // <rdar://problem/11324125>: Make sure this doesn't crash.  (It's okay
 // if we start rejecting it at some point.)
 namespace Test7 {
   #pragma pack (1)
   class A {};
   // CHECK: %"class.Test7::B" = type <{ i32 (...)**, %"class.Test7::A" }>
   class B {
+  public:
      virtual ~B();
+  private:
      A a;
   };
-  B* b;
+  B b;
   #pragma pack ()
 }
 
 // Shouldn't crash.
 namespace Test8 {
   struct A {};
   struct D { int a; };
   struct B : virtual D, A { };
   struct C : B, A { void f() {} };
   C c;
 }

clang/test/CodeGenCXX/pr18962.cpp

 
 void
 fn2(C *) {
 }
 
 // We end up using an opaque type for 'append' to avoid circular references.
 // CHECK: %class.A = type { {}* }
 // CHECK: %class.C = type <{ %class.D*, %class.B, [3 x i8] }>
-// CHECK: %class.D = type { %class.C.base, [3 x i8] }
-// CHECK: %class.C.base = type <{ %class.D*, %class.B }>
+// CHECK: %class.D = type opaque
 // CHECK: %class.B = type { i8 }

clang/test/CodeGenCXX/warn-padded-packed.cpp

 
 struct S27 { // expected-warning {{padding size of 'S27' with 7 bits to alignment boundary}}
   unsigned char a : 1;
   unsigned char b : 8;
 } __attribute__((packed));
 
 
 // The warnings are emitted when the layout of the structs is computed, so we have to use them.
-void f(S1*, S2*, S3*, S4*, S5*, S6*, S7*, S8*, S9*, S10*, S11*, S12*, S13*,
-       S14*, S15*, S16*, S17*, S18*, S19*, S20*, S21*, S22*, S23*, S24*, S25*,
-       S26*, S27*){}
+void f(S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13,
+       S14, S15, S16, S17, S18, S19, S20, S21, S22, S23, S24, S25,
+       S26, S27){}

llvm/include/llvm/IR/Instructions.h

GetElementPtrInst::GetElementPtrInst(Type *PointeeType, Value *Ptr,
                                      Instruction *InsertBefore)
     : Instruction(getGEPReturnType(PointeeType, Ptr, IdxList), GetElementPtr,
                   OperandTraits<GetElementPtrInst>::op_end(this) - Values,
                   Values, InsertBefore),
       SourceElementType(PointeeType),
       ResultElementType(getIndexedType(PointeeType, IdxList)) {
   assert(cast<PointerType>(getType()->getScalarType())
              ->isOpaqueOrPointeeTypeMatches(ResultElementType));
+  assert(PointeeType->isSized());
   init(Ptr, IdxList, NameStr);
 }
 
 GetElementPtrInst::GetElementPtrInst(Type *PointeeType, Value *Ptr,
                                      ArrayRef<Value *> IdxList, unsigned Values,
                                      const Twine &NameStr,
                                      BasicBlock *InsertAtEnd)
     : Instruction(getGEPReturnType(PointeeType, Ptr, IdxList), GetElementPtr,
                   OperandTraits<GetElementPtrInst>::op_end(this) - Values,
                   Values, InsertAtEnd),
       SourceElementType(PointeeType),
       ResultElementType(getIndexedType(PointeeType, IdxList)) {
   assert(cast<PointerType>(getType()->getScalarType())
              ->isOpaqueOrPointeeTypeMatches(ResultElementType));
+  assert(PointeeType->isSized());
   init(Ptr, IdxList, NameStr);
 }
 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GetElementPtrInst, Value)
 
 //===----------------------------------------------------------------------===//
 //                               ICmpInst Class
 //===----------------------------------------------------------------------===//