[IRGen] Centralize alignment/default type information in LinkEntity.

Simplify calls to getAddrOfLLVMVariableOrGOTEquivalent() and
getAddrOfLLVMVariable() by moving the computation of the alignment and
default type into LinkEntity.

Co-authored-by: Joe Groff <[email protected]>
(cherry picked from commit 602b38e)

Author: DougGregor

include/swift/IRGen/Linking.h

@@ -32,6 +32,7 @@ class Triple;
 namespace swift {
 namespace irgen {
 class IRGenModule;
+class Alignment;
 
 /// Determine if the triple uses the DLL storage.
 bool useDllStorage(const llvm::Triple &triple);
@@ -947,6 +948,17 @@ class LinkEntity {
 
     return getDecl()->isWeakImported(module);
   }
+  
+  /// Return the source file whose codegen should trigger emission of this
+  /// link entity, if one can be identified.
+  const SourceFile *getSourceFileForEmission() const;
+  
+  /// Get the preferred alignment for the definition of this entity.
+  Alignment getAlignment(IRGenModule &IGM) const;
+  
+  /// Get the default LLVM type to use for forward declarations of this
+  /// entity.
+  llvm::Type *getDefaultDeclarationType(IRGenModule &IGM) const;
 #undef LINKENTITY_GET_FIELD
 #undef LINKENTITY_SET_FIELD
 };

lib/IRGen/GenDecl.cpp

@@ -1554,19 +1554,16 @@ namespace {
 
       // The class containing the base method.
       auto *baseClass = cast<ClassDecl>(baseRef.getDecl()->getDeclContext());
+      IGM.IRGen.noteUseOfTypeContextDescriptor(baseClass, DontRequireMetadata);
       auto baseClassEntity = LinkEntity::forNominalTypeDescriptor(baseClass);
       auto baseClassDescriptor =
-        IGM.getAddrOfLLVMVariableOrGOTEquivalent(
-          baseClassEntity, IGM.getPointerAlignment(),
-          IGM.Int8Ty);
+        IGM.getAddrOfLLVMVariableOrGOTEquivalent(baseClassEntity);
       descriptor.addRelativeAddress(baseClassDescriptor);
 
       // The base method.
       auto baseMethodEntity = LinkEntity::forMethodDescriptor(baseRef);
       auto baseMethodDescriptor =
-        IGM.getAddrOfLLVMVariableOrGOTEquivalent(
-          baseMethodEntity, Alignment(4),
-          IGM.MethodDescriptorStructTy);
+        IGM.getAddrOfLLVMVariableOrGOTEquivalent(baseMethodEntity);
       descriptor.addRelativeAddress(baseMethodDescriptor);
 
       // The implementation of the override.
@@ -1716,9 +1713,8 @@ IRGenModule::getAddrOfSharedContextDescriptor(LinkEntity entity,
     }
   }
 
-  return getAddrOfLLVMVariable(entity, Alignment(4),
+  return getAddrOfLLVMVariable(entity,
                                definition,
-                               TypeContextDescriptorTy,
                                DebugTypeInfo());
 }
 

lib/IRGen/GenMeta.cpp

@@ -2091,8 +2091,7 @@ namespace {
       // Relative reference to the protocol descriptor.
       auto protocol = Conformance->getProtocol();
       auto descriptorRef = IGM.getAddrOfLLVMVariableOrGOTEquivalent(
-                    LinkEntity::forProtocolDescriptor(protocol),
-                    IGM.getPointerAlignment(), IGM.ProtocolDescriptorStructTy);
+                                   LinkEntity::forProtocolDescriptor(protocol));
       B.addRelativeAddress(descriptorRef);
     }
 
@@ -2185,8 +2184,7 @@ namespace {
           auto assocType = entry.getAssociatedTypeWitness().Requirement;
           auto assocTypeDescriptor =
             IGM.getAddrOfLLVMVariableOrGOTEquivalent(
-              LinkEntity::forAssociatedTypeDescriptor(assocType),
-              Alignment(4), IGM.ProtocolRequirementStructTy);
+              LinkEntity::forAssociatedTypeDescriptor(assocType));
           B.addRelativeAddress(assocTypeDescriptor);
         } else if (entry.getKind() == SILWitnessTable::AssociatedTypeProtocol) {
           // Associated conformance descriptor.
@@ -2198,16 +2196,14 @@ namespace {
                                   witness.Protocol);
           auto assocConformanceDescriptor =
             IGM.getAddrOfLLVMVariableOrGOTEquivalent(
-              LinkEntity::forAssociatedConformanceDescriptor(requirement),
-              Alignment(4), IGM.ProtocolRequirementStructTy);
+              LinkEntity::forAssociatedConformanceDescriptor(requirement));
           B.addRelativeAddress(assocConformanceDescriptor);
         } else if (entry.getKind() == SILWitnessTable::Method) {
           // Method descriptor.
           auto declRef = entry.getMethodWitness().Requirement;
           auto requirement =
             IGM.getAddrOfLLVMVariableOrGOTEquivalent(
-              LinkEntity::forMethodDescriptor(declRef),
-              Alignment(4), IGM.ProtocolRequirementStructTy);
+              LinkEntity::forMethodDescriptor(declRef));
           B.addRelativeAddress(requirement);
         } else {
           // Not part of the resilient witness table.

lib/IRGen/GenProto.cpp

@@ -129,8 +129,7 @@ IRGenModule::getAddrOfMethodDescriptor(SILDeclRef declRef,
   assert(declRef.getOverriddenWitnessTableEntry() == declRef &&
          "Overriding protocol requirements do not have method descriptors");
   LinkEntity entity = LinkEntity::forMethodDescriptor(declRef);
-  return getAddrOfLLVMVariable(entity, Alignment(4), forDefinition,
-                               MethodDescriptorStructTy, DebugTypeInfo());
+  return getAddrOfLLVMVariable(entity, forDefinition, DebugTypeInfo());
 }
 
 /// Fetch the method lookup function for a resilient class.

lib/IRGen/GenThunk.cpp

@@ -1298,7 +1298,8 @@ private:                            \
                                                ForDefinition_t forDefinition);
   llvm::Constant *getAddrOfWitnessTable(const NormalProtocolConformance *C,
                                       ConstantInit definition = ConstantInit());
-  llvm::Constant *getAddrOfWitnessTablePattern(const NormalProtocolConformance *C,
+  llvm::Constant *getAddrOfWitnessTablePattern(
+                                      const NormalProtocolConformance *C,
                                       ConstantInit definition = ConstantInit());
 
   llvm::Constant *
@@ -1321,8 +1322,7 @@ private:                            \
   GenericEnvironment *getGenericEnvironment();
 
   ConstantReference
-  getAddrOfLLVMVariableOrGOTEquivalent(LinkEntity entity, Alignment alignment,
-       llvm::Type *defaultType,
+  getAddrOfLLVMVariableOrGOTEquivalent(LinkEntity entity,
        ConstantReference::Directness forceIndirect = ConstantReference::Direct);
 
   llvm::Constant *
@@ -1356,21 +1356,17 @@ private:                            \
                                    llvm::function_ref<void()> emit);
 
   llvm::Constant *getAddrOfLLVMVariable(LinkEntity entity,
-                                        Alignment alignment,
                                         ConstantInit definition,
-                                        llvm::Type *defaultType,
-                                        DebugTypeInfo debugType);
+                                        DebugTypeInfo debugType,
+                                        llvm::Type *overrideDeclType = nullptr);
   llvm::Constant *getAddrOfLLVMVariable(LinkEntity entity,
-                                        Alignment alignment,
                                         ForDefinition_t forDefinition,
-                                        llvm::Type *defaultType,
                                         DebugTypeInfo debugType);
   ConstantReference getAddrOfLLVMVariable(LinkEntity entity,
-                                        Alignment alignment,
                                         ConstantInit definition,
-                                        llvm::Type *defaultType,
                                         DebugTypeInfo debugType,
-                                        SymbolReferenceKind refKind);
+                                        SymbolReferenceKind refKind,
+                                        llvm::Type *overrideDeclType = nullptr);
 
   void emitLazyPrivateDefinitions();
   void addRuntimeResolvableType(NominalTypeDecl *nominal);

lib/IRGen/IRGenModule.h

@@ -645,3 +645,238 @@ bool LinkEntity::isAvailableExternally(IRGenModule &IGM) const {
   }
   llvm_unreachable("bad link entity kind");
 }
+
+llvm::Type *LinkEntity::getDefaultDeclarationType(IRGenModule &IGM) const {
+  switch (getKind()) {
+  case Kind::ModuleDescriptor:
+  case Kind::ExtensionDescriptor:
+  case Kind::AnonymousDescriptor:
+  case Kind::NominalTypeDescriptor:
+  case Kind::PropertyDescriptor:
+    return IGM.TypeContextDescriptorTy;
+  case Kind::ProtocolDescriptor:
+    return IGM.ProtocolDescriptorStructTy;
+  case Kind::AssociatedTypeDescriptor:
+  case Kind::AssociatedConformanceDescriptor:
+  case Kind::ProtocolRequirementsBaseDescriptor:
+    return IGM.ProtocolRequirementStructTy;
+  case Kind::ProtocolConformanceDescriptor:
+    return IGM.ProtocolConformanceDescriptorTy;
+  case Kind::ObjCClassRef:
+    return IGM.ObjCClassPtrTy;
+  case Kind::ObjCClass:
+  case Kind::ObjCMetaclass:
+  case Kind::SwiftMetaclassStub:
+    return IGM.ObjCClassStructTy;
+  case Kind::TypeMetadataLazyCacheVariable:
+    return IGM.TypeMetadataPtrTy;
+  case Kind::TypeMetadataSingletonInitializationCache:
+    // TODO: put a cache variable on IGM
+    return llvm::StructType::get(IGM.getLLVMContext(),
+                                 {IGM.TypeMetadataPtrTy, IGM.Int8PtrTy});
+  case Kind::TypeMetadata:
+    switch (getMetadataAddress()) {
+    case TypeMetadataAddress::FullMetadata:
+      if (getType().getClassOrBoundGenericClass())
+        return IGM.FullHeapMetadataStructTy;
+      else
+        return IGM.FullTypeMetadataStructTy;
+    case TypeMetadataAddress::AddressPoint:
+      return IGM.TypeMetadataStructTy;
+    }
+    
+  case Kind::TypeMetadataPattern:
+    // TODO: Use a real type?
+    return IGM.Int8Ty;
+    
+  case Kind::ClassMetadataBaseOffset:
+    // TODO: put a cache variable on IGM
+    return llvm::StructType::get(IGM.getLLVMContext(), {
+      IGM.SizeTy,  // Immediate members offset
+      IGM.Int32Ty, // Negative size in words
+      IGM.Int32Ty  // Positive size in words
+    });
+    
+  case Kind::TypeMetadataInstantiationCache:
+    // TODO: put a cache variable on IGM
+    return llvm::ArrayType::get(IGM.Int8PtrTy,
+                                NumGenericMetadataPrivateDataWords);
+  case Kind::ReflectionBuiltinDescriptor:
+  case Kind::ReflectionFieldDescriptor:
+  case Kind::ReflectionAssociatedTypeDescriptor:
+    return IGM.FieldDescriptorTy;
+  case Kind::ValueWitnessTable:
+  case Kind::DirectProtocolWitnessTable:
+  case Kind::ProtocolWitnessTablePattern:
+    return IGM.WitnessTableTy;
+  case Kind::FieldOffset:
+    return IGM.SizeTy;
+  case Kind::EnumCase:
+    return IGM.Int32Ty;
+  case Kind::ProtocolWitnessTableLazyCacheVariable:
+    return IGM.WitnessTablePtrTy;
+  case Kind::SILFunction:
+    return IGM.FunctionPtrTy->getPointerTo();
+  case Kind::MethodDescriptor:
+  case Kind::MethodDescriptorInitializer:
+  case Kind::MethodDescriptorAllocator:
+    return IGM.MethodDescriptorStructTy;
+    
+  default:
+    llvm_unreachable("declaration LLVM type not specified");
+  }
+}
+
+Alignment LinkEntity::getAlignment(IRGenModule &IGM) const {
+  switch (getKind()) {
+  case Kind::ModuleDescriptor:
+  case Kind::ExtensionDescriptor:
+  case Kind::AnonymousDescriptor:
+  case Kind::NominalTypeDescriptor:
+  case Kind::ProtocolDescriptor:
+  case Kind::AssociatedTypeDescriptor:
+  case Kind::AssociatedConformanceDescriptor:
+  case Kind::ProtocolConformanceDescriptor:
+  case Kind::ProtocolRequirementsBaseDescriptor:
+  case Kind::ReflectionBuiltinDescriptor:
+  case Kind::ReflectionFieldDescriptor:
+  case Kind::ReflectionAssociatedTypeDescriptor:
+  case Kind::PropertyDescriptor:
+  case Kind::EnumCase:
+  case Kind::MethodDescriptor:
+  case Kind::MethodDescriptorInitializer:
+  case Kind::MethodDescriptorAllocator:
+    return Alignment(4);
+  case Kind::ObjCClassRef:
+  case Kind::ObjCClass:
+  case Kind::TypeMetadataLazyCacheVariable:
+  case Kind::TypeMetadataSingletonInitializationCache:
+  case Kind::TypeMetadata:
+  case Kind::TypeMetadataPattern:
+  case Kind::ClassMetadataBaseOffset:
+  case Kind::TypeMetadataInstantiationCache:
+  case Kind::ValueWitnessTable:
+  case Kind::FieldOffset:
+  case Kind::ProtocolWitnessTableLazyCacheVariable:
+  case Kind::DirectProtocolWitnessTable:
+  case Kind::ProtocolWitnessTablePattern:
+  case Kind::ObjCMetaclass:
+  case Kind::SwiftMetaclassStub:
+    return IGM.getPointerAlignment();
+  case Kind::SILFunction:
+    return Alignment(1);
+  default:
+    llvm_unreachable("alignment not specified");
+  }
+}
+
+const SourceFile *LinkEntity::getSourceFileForEmission() const {
+  const SourceFile *sf;
+  
+  // Shared-linkage entities don't get emitted with any particular file.
+  if (hasSharedVisibility(getLinkage(NotForDefinition)))
+    return nullptr;
+  
+  auto getSourceFileForDeclContext =
+  [](const DeclContext *dc) -> const SourceFile * {
+    if (!dc)
+      return nullptr;
+    return dc->getParentSourceFile();
+  };
+  
+  switch (getKind()) {
+  case Kind::DispatchThunk:
+  case Kind::DispatchThunkInitializer:
+  case Kind::DispatchThunkAllocator:
+  case Kind::MethodDescriptor:
+  case Kind::MethodDescriptorInitializer:
+  case Kind::MethodDescriptorAllocator:
+  case Kind::MethodLookupFunction:
+  case Kind::EnumCase:
+  case Kind::FieldOffset:
+  case Kind::ObjCClass:
+  case Kind::ObjCMetaclass:
+  case Kind::SwiftMetaclassStub:
+  case Kind::ClassMetadataBaseOffset:
+  case Kind::PropertyDescriptor:
+  case Kind::NominalTypeDescriptor:
+  case Kind::TypeMetadataPattern:
+  case Kind::TypeMetadataInstantiationCache:
+  case Kind::TypeMetadataInstantiationFunction:
+  case Kind::TypeMetadataSingletonInitializationCache:
+  case Kind::TypeMetadataCompletionFunction:
+  case Kind::ProtocolDescriptor:
+  case Kind::ProtocolRequirementsBaseDescriptor:
+  case Kind::AssociatedTypeDescriptor:
+  case Kind::AssociatedConformanceDescriptor:
+  case Kind::DefaultAssociatedConformanceAccessor:
+    sf = getSourceFileForDeclContext(getDecl()->getDeclContext());
+    if (!sf)
+      return nullptr;
+    break;
+  
+  case Kind::SILFunction:
+    sf = getSourceFileForDeclContext(getSILFunction()->getDeclContext());
+    if (!sf)
+      return nullptr;
+    break;
+  
+  case Kind::SILGlobalVariable:
+    if (auto decl = getSILGlobalVariable()->getDecl()) {
+      sf = getSourceFileForDeclContext(decl->getDeclContext());
+      if (!sf)
+        return nullptr;
+    } else {
+      return nullptr;
+    }
+    break;
+    
+  case Kind::DirectProtocolWitnessTable:
+  case Kind::ProtocolWitnessTablePattern:
+  case Kind::ProtocolWitnessTableAccessFunction:
+  case Kind::GenericProtocolWitnessTableInstantiationFunction:
+  case Kind::AssociatedTypeWitnessTableAccessFunction:
+  case Kind::ReflectionAssociatedTypeDescriptor:
+  case Kind::ProtocolConformanceDescriptor:
+  case Kind::ProtocolWitnessTableLazyCacheVariable:
+  case Kind::ProtocolWitnessTableLazyAccessFunction:
+    sf = getSourceFileForDeclContext(
+      getProtocolConformance()->getRootNormalConformance()->getDeclContext());
+    if (!sf)
+      return nullptr;
+    break;
+    
+  case Kind::TypeMetadata: {
+    auto ty = getType();
+    // Only fully concrete nominal type metadata gets emitted eagerly.
+    auto nom = ty->getAnyNominal();
+    if (!nom || nom->isGenericContext())
+      return nullptr;
+    
+    sf = getSourceFileForDeclContext(nom);
+    if (!sf)
+      return nullptr;
+    break;
+  }
+
+  // Always shared linkage
+  case Kind::ModuleDescriptor:
+  case Kind::ExtensionDescriptor:
+  case Kind::AnonymousDescriptor:
+  case Kind::ObjCClassRef:
+  case Kind::TypeMetadataAccessFunction:
+  case Kind::TypeMetadataLazyCacheVariable:
+  case Kind::ForeignTypeMetadataCandidate:
+    return nullptr;
+
+  // TODO
+  case Kind::CoroutineContinuationPrototype:
+  case Kind::ReflectionFieldDescriptor:
+  case Kind::ReflectionBuiltinDescriptor:
+  case Kind::ValueWitness:
+  case Kind::ValueWitnessTable:
+    return nullptr;
+  }
+  
+  return sf;
+}