IRGen: Add ResilienceExpansion parameter to TypeInfo::isKnownEmpty(), NFC

In a few places, we have to be careful about the distinction between
"empty in this resilience domain" versus "empty in all resilience
domains". Make callers think about this by adding a parameter instead
of relying on them to check isFixedSize() as necessary first.

While making this change I noticed that the code for checking if
types are empty when computing extra inhabitants of structs and enums
might be slightly wrong in the face of resilience; I will revisit
this later.

Author: slavapestov

lib/IRGen/FixedTypeInfo.h

@@ -72,7 +72,9 @@ class FixedTypeInfo : public TypeInfo {
   static bool isFixed() { return true; }
 
   /// Whether this type is known to be empty.
-  bool isKnownEmpty() const { return StorageSize.isZero(); }
+  bool isKnownEmpty(ResilienceExpansion expansion) const {
+    return (isFixedSize(expansion) && StorageSize.isZero());
+  }
 
   ContainedAddress allocateStack(IRGenFunction &IGF, SILType T,
                                  const llvm::Twine &name) const override;

lib/IRGen/GenClass.cpp

@@ -402,7 +402,7 @@ OwnedAddress irgen::projectPhysicalClassMemberAddress(IRGenFunction &IGF,
                                                       VarDecl *field) {
   // If the field is empty, its address doesn't matter.
   auto &fieldTI = IGF.getTypeInfo(fieldType);
-  if (fieldTI.isKnownEmpty()) {
+  if (fieldTI.isKnownEmpty(ResilienceExpansion::Maximal)) {
     return OwnedAddress(fieldTI.getUndefAddress(), base);
   }
 

lib/IRGen/GenEnum.cpp

@@ -2625,7 +2625,7 @@ namespace {
       auto &payloadTI = getFixedPayloadTypeInfo();
       unsigned totalSize
         = cast<FixedTypeInfo>(TI)->getFixedSize().getValueInBits();
-      if (payloadTI.isKnownEmpty())
+      if (payloadTI.isKnownEmpty(ResilienceExpansion::Maximal))
         return APInt::getAllOnesValue(totalSize);
       auto baseMask =
         getFixedPayloadTypeInfo().getFixedExtraInhabitantMask(IGM);
@@ -2666,7 +2666,7 @@ namespace {
       auto &payloadTI = getFixedPayloadTypeInfo();
       ClusteredBitVector extraInhabitantsMask;
 
-      if (!payloadTI.isKnownEmpty())
+      if (!payloadTI.isKnownEmpty(ResilienceExpansion::Maximal))
         extraInhabitantsMask =
           getBitVectorFromAPInt(payloadTI.getFixedExtraInhabitantMask(IGM));
       // Extend to include the extra tag bits, which are always significant.
@@ -4699,9 +4699,7 @@ EnumImplStrategy *EnumImplStrategy::get(TypeConverter &TC,
     // If the payload is empty, turn the case into a no-payload case, but
     // only if case numbering remains unchanged from all resilience domains
     // that can see the enum.
-    if (origArgTI->isFixedSize(accessScope) &&
-        isa<LoadableTypeInfo>(origArgTI) &&
-        cast<LoadableTypeInfo>(origArgTI)->isKnownEmpty()) {
+    if (origArgTI->isKnownEmpty(accessScope)) {
       elementsWithNoPayload.push_back({elt, nullptr, nullptr});
     } else {
       // *Now* apply the substitutions and get the type info for the instance's

lib/IRGen/GenFunc.cpp

@@ -144,7 +144,7 @@ static void addDereferenceableAttributeToBuilder(IRGenModule &IGM,
                                                  const TypeInfo &ti) {
   // The addresses of empty values are undefined, so we can't safely mark them
   // dereferenceable.
-  if (ti.isKnownEmpty())
+  if (ti.isKnownEmpty(ResilienceExpansion::Maximal))
     return;
 
   // If we know the type to have a fixed nonempty size, then the pointer is

lib/IRGen/GenHeap.cpp

@@ -1482,7 +1482,7 @@ const TypeInfo *TypeConverter::convertBoxType(SILBoxType *T) {
   auto &fixedTI = cast<FixedTypeInfo>(eltTI);
 
   // For empty types, we don't really need to allocate anything.
-  if (fixedTI.isKnownEmpty()) {
+  if (fixedTI.isKnownEmpty(ResilienceExpansion::Maximal)) {
     if (!EmptyBoxTI)
       EmptyBoxTI = new EmptyBoxTypeInfo(IGM);
     return EmptyBoxTI;

lib/IRGen/GenInit.cpp

@@ -35,8 +35,9 @@ using namespace irgen;
 Address IRGenModule::emitSILGlobalVariable(SILGlobalVariable *var) {
   auto &ti = getTypeInfo(var->getLoweredType());
 
-  // If the variable is empty, don't actually emit it; just return undef.
-  if (ti.isFixedSize(ResilienceExpansion::Minimal) && ti.isKnownEmpty())
+  // If the variable is empty in all resilience domains, don't actually emit it;
+  // just return undef.
+  if (ti.isKnownEmpty(ResilienceExpansion::Minimal))
     return ti.getUndefAddress();
 
   /// Get the global variable.
@@ -55,7 +56,7 @@ Address IRGenModule::emitSILGlobalVariable(SILGlobalVariable *var) {
 ContainedAddress FixedTypeInfo::allocateStack(IRGenFunction &IGF, SILType T,
                                               const Twine &name) const {
   // If the type is known to be empty, don't actually allocate anything.
-  if (isKnownEmpty()) {
+  if (isKnownEmpty(ResilienceExpansion::Maximal)) {
     auto addr = getUndefAddress();
     return { addr, addr };
   }
@@ -69,7 +70,7 @@ ContainedAddress FixedTypeInfo::allocateStack(IRGenFunction &IGF, SILType T,
 
 void FixedTypeInfo::deallocateStack(IRGenFunction &IGF, Address addr,
                                     SILType T) const {
-  if (isKnownEmpty())
+  if (isKnownEmpty(ResilienceExpansion::Maximal))
     return;
   IGF.Builder.CreateLifetimeEnd(addr, getFixedSize());
 }

lib/IRGen/GenStruct.cpp

@@ -200,7 +200,7 @@ namespace {
         = cast<FixedTypeInfo>(asImpl().getFields()[0].getTypeInfo());
       auto targetSize = asImpl().getFixedSize().getValueInBits();
 
-      if (fieldTI.isKnownEmpty())
+      if (fieldTI.isKnownEmpty(ResilienceExpansion::Maximal))
         return APInt(targetSize, 0);
 
       APInt fieldMask = fieldTI.getFixedExtraInhabitantMask(IGM);

lib/IRGen/GenTuple.cpp

@@ -149,7 +149,7 @@ namespace {
         = cast<FixedTypeInfo>(asImpl().getFields()[0].getTypeInfo());
       auto size = asImpl().getFixedSize().getValueInBits();
 
-      if (fieldTI.isKnownEmpty())
+      if (fieldTI.isKnownEmpty(ResilienceExpansion::Maximal))
         return APInt(size, 0);
 
       APInt firstMask = fieldTI.getFixedExtraInhabitantMask(IGM);

lib/IRGen/GenType.cpp

@@ -354,9 +354,9 @@ Address TypeInfo::getUndefAddress() const {
 }
 
 /// Whether this type is known to be empty.
-bool TypeInfo::isKnownEmpty() const {
+bool TypeInfo::isKnownEmpty(ResilienceExpansion expansion) const {
   if (auto fixed = dyn_cast<FixedTypeInfo>(this))
-    return fixed->isKnownEmpty();
+    return fixed->isKnownEmpty(expansion);
   return false;
 }
 

lib/IRGen/IRGenSIL.cpp

@@ -1633,9 +1633,9 @@ void IRGenSILFunction::visitGlobalAddrInst(GlobalAddrInst *i) {
   assert(loweredTy == i->getType().getObjectType());
   auto &ti = getTypeInfo(loweredTy);
 
-  // If the variable is universally fixed-size and known to be empty, don't
+  // If the variable is empty in all resilience domains, don't
   // actually emit a symbol for the global at all, just return undef.
-  if (ti.isFixedSize(ResilienceExpansion::Minimal) && ti.isKnownEmpty()) {
+  if (ti.isKnownEmpty(ResilienceExpansion::Minimal)) {
     setLoweredAddress(SILValue(i, 0), ti.getUndefAddress());
     return;
   }
@@ -4287,7 +4287,7 @@ void IRGenSILFunction::visitInitExistentialAddrInst(swift::InitExistentialAddrIn
   // Project down to the destination fixed-size buffer.
   Address address = [&]{
     // If the type is provably empty, we're done.
-    if (srcTI.isKnownEmpty()) {
+    if (srcTI.isKnownEmpty(ResilienceExpansion::Maximal)) {
       assert(packing == FixedPacking::OffsetZero);
       return buffer;
     }

lib/IRGen/StructLayout.cpp

@@ -213,7 +213,7 @@ bool StructLayoutBuilder::addFields(llvm::MutableArrayRef<ElementLayout> elts,
     IsKnownAlwaysFixedSize &= eltTI.isFixedSize(ResilienceExpansion::Minimal);
 
     // If the element type is empty, it adds nothing.
-    if (eltTI.isKnownEmpty()) {
+    if (eltTI.isKnownEmpty(ResilienceExpansion::Maximal)) {
       addEmptyElement(elt);
     } else {
       // Anything else we do at least potentially adds storage requirements.

lib/IRGen/TypeInfo.h

@@ -150,7 +150,7 @@ class TypeInfo {
   bool isComplete() const { return !StorageAlignment.isZero(); }
 
   /// Whether this type is known to be empty.
-  bool isKnownEmpty() const;
+  bool isKnownEmpty(ResilienceExpansion expansion) const;
 
   /// Whether this type is known to be POD, i.e. to not require any
   /// particular action on copy or destroy.