Merge pull request #37540 from adrian-prantl/76973844

 Debug Info: Distinguish between types of unknown size and types with …

Author: adrian-prantl

lib/IRGen/DebugTypeInfo.cpp

@@ -24,9 +24,9 @@
 using namespace swift;
 using namespace irgen;
 
-DebugTypeInfo::DebugTypeInfo(swift::Type Ty, llvm::Type *StorageTy, Size size,
-                             Alignment align, bool HasDefaultAlignment,
-                             bool IsMetadata)
+DebugTypeInfo::DebugTypeInfo(swift::Type Ty, llvm::Type *StorageTy,
+                             Optional<Size> size, Alignment align,
+                             bool HasDefaultAlignment, bool IsMetadata)
     : Type(Ty.getPointer()), StorageType(StorageTy), size(size), align(align),
       DefaultAlignment(HasDefaultAlignment), IsMetadataType(IsMetadata) {
   assert(align.getValue() != 0);
@@ -43,14 +43,10 @@ static bool hasDefaultAlignment(swift::Type Ty) {
 
 DebugTypeInfo DebugTypeInfo::getFromTypeInfo(swift::Type Ty,
                                              const TypeInfo &Info) {
-  Size size;
+  Optional<Size> size;
   if (Info.isFixedSize()) {
     const FixedTypeInfo &FixTy = *cast<const FixedTypeInfo>(&Info);
     size = FixTy.getFixedSize();
-  } else {
-    // FIXME: Handle NonFixedTypeInfo here or assert that we won't
-    // encounter one.
-    size = Size(0);
   }
   assert(Info.getStorageType() && "StorageType is a nullptr");
   return DebugTypeInfo(Ty.getPointer(), Info.getStorageType(), size,
@@ -160,10 +156,12 @@ TypeDecl *DebugTypeInfo::getDecl() const {
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 LLVM_DUMP_METHOD void DebugTypeInfo::dump() const {
-  llvm::errs() << "[Size " << size.getValue() << " Alignment "
-               << align.getValue() << "] ";
-
+  llvm::errs() << "[";
+  if (size)
+    llvm::errs() << "Size " << size->getValue() << " ";
+  llvm::errs() << "Alignment " << align.getValue() << "] ";
   getType()->dump(llvm::errs());
+
   if (StorageType) {
     llvm::errs() << "StorageType=";
     StorageType->dump();

lib/IRGen/DebugTypeInfo.h

@@ -36,22 +36,23 @@ class TypeInfo;
 /// This data structure holds everything needed to emit debug info
 /// for a type.
 class DebugTypeInfo {
+protected:
   /// The type we need to emit may be different from the type
   /// mentioned in the Decl, for example, stripped of qualifiers.
   TypeBase *Type = nullptr;
   /// Needed to determine the size of basic types and to determine
   /// the storage type for undefined variables.
   llvm::Type *StorageType = nullptr;
-  Size size = Size(0);
-  Alignment align = Alignment();
+  Optional<Size> size;
+  Alignment align;
   bool DefaultAlignment = true;
   bool IsMetadataType = false;
 
 public:
   DebugTypeInfo() = default;
-  DebugTypeInfo(swift::Type Ty, llvm::Type *StorageTy, Size SizeInBytes,
-                Alignment AlignInBytes, bool HasDefaultAlignment,
-                bool IsMetadataType);
+  DebugTypeInfo(swift::Type Ty, llvm::Type *StorageTy,
+                Optional<Size> SizeInBytes, Alignment AlignInBytes,
+                bool HasDefaultAlignment, bool IsMetadataType);
 
   /// Create type for a local variable.
   static DebugTypeInfo getLocalVariable(VarDecl *Decl,
@@ -92,24 +93,44 @@ class DebugTypeInfo {
   }
 
   llvm::Type *getStorageType() const {
-    assert((StorageType || size.isZero()) &&
-           "only defined types may have a size");
+    if (size && size->isZero())
+      assert(StorageType && "only defined types may have a size");
     return StorageType;
   }
-  Size getSize() const { return size; }
+  Optional<Size> getSize() const { return size; }
   void setSize(Size NewSize) { size = NewSize; }
   Alignment getAlignment() const { return align; }
   bool isNull() const { return Type == nullptr; }
   bool isForwardDecl() const { return StorageType == nullptr; }
   bool isMetadataType() const { return IsMetadataType; }
   bool hasDefaultAlignment() const { return DefaultAlignment; }
-  
+
   bool operator==(DebugTypeInfo T) const;
   bool operator!=(DebugTypeInfo T) const;
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   LLVM_DUMP_METHOD void dump() const;
 #endif
 };
+
+/// A DebugTypeInfo with a defined size (that may be 0).
+class CompletedDebugTypeInfo : public DebugTypeInfo {
+  CompletedDebugTypeInfo(DebugTypeInfo DbgTy) : DebugTypeInfo(DbgTy) {}
+public:
+  static Optional<CompletedDebugTypeInfo> get(DebugTypeInfo DbgTy) {
+    if (!DbgTy.getSize())
+      return {};
+    return CompletedDebugTypeInfo(DbgTy);
+  }
+
+  static Optional<CompletedDebugTypeInfo>
+  getFromTypeInfo(swift::Type Ty, const TypeInfo &Info) {
+    return CompletedDebugTypeInfo::get(
+        DebugTypeInfo::getFromTypeInfo(Ty, Info));
+  }
+
+  Size::int_type getSizeValue() const { return size.getValue().getValue(); }
+};
+
 }
 }