Use IGM.getMaximalTypeExpansionContext() in more places

Author: aschwaighofer

lib/IRGen/GenClass.cpp

@@ -501,21 +501,20 @@ Address IRGenFunction::emitByteOffsetGEP(llvm::Value *base,
 }
 
 /// Emit a field l-value by applying the given offset to the given base.
-static OwnedAddress emitAddressAtOffset(TypeExpansionContext context,
-                                        IRGenFunction &IGF, SILType baseType,
+static OwnedAddress emitAddressAtOffset(IRGenFunction &IGF, SILType baseType,
                                         llvm::Value *base, llvm::Value *offset,
                                         VarDecl *field) {
-  auto &fieldTI = IGF.getTypeInfo(
-      baseType.getFieldType(field, IGF.getSILModule(), context));
+  auto &fieldTI = IGF.getTypeInfo(baseType.getFieldType(
+      field, IGF.getSILModule(), IGF.IGM.getMaximalTypeExpansionContext()));
   auto addr = IGF.emitByteOffsetGEP(base, offset, fieldTI,
                               base->getName() + "." + field->getName().str());
   return OwnedAddress(addr, base);
 }
 
 llvm::Constant *irgen::tryEmitConstantClassFragilePhysicalMemberOffset(
-    TypeExpansionContext context, IRGenModule &IGM, SILType baseType,
-    VarDecl *field) {
-  auto fieldType = baseType.getFieldType(field, IGM.getSILModule(), context);
+    IRGenModule &IGM, SILType baseType, VarDecl *field) {
+  auto fieldType = baseType.getFieldType(field, IGM.getSILModule(),
+                                         IGM.getMaximalTypeExpansionContext());
   // If the field is empty, its address doesn't matter.
   auto &fieldTI = IGM.getTypeInfo(fieldType);
   if (fieldTI.isKnownEmpty(ResilienceExpansion::Maximal)) {
@@ -571,9 +570,11 @@ irgen::getClassLayoutWithTailElems(IRGenModule &IGM, SILType classType,
   return ClassTI.createLayoutWithTailElems(IGM, classType, tailTypes);
 }
 
-OwnedAddress irgen::projectPhysicalClassMemberAddress(
-    TypeExpansionContext context, IRGenFunction &IGF, llvm::Value *base,
-    SILType baseType, SILType fieldType, VarDecl *field) {
+OwnedAddress irgen::projectPhysicalClassMemberAddress(IRGenFunction &IGF,
+                                                      llvm::Value *base,
+                                                      SILType baseType,
+                                                      SILType fieldType,
+                                                      VarDecl *field) {
   // If the field is empty, its address doesn't matter.
   auto &fieldTI = IGF.getTypeInfo(fieldType);
   if (fieldTI.isKnownEmpty(ResilienceExpansion::Maximal)) {
@@ -603,13 +604,13 @@ OwnedAddress irgen::projectPhysicalClassMemberAddress(
   case FieldAccess::NonConstantDirect: {
     Address offsetA = IGF.IGM.getAddrOfFieldOffset(field, NotForDefinition);
     auto offset = IGF.Builder.CreateLoad(offsetA, "offset");
-    return emitAddressAtOffset(context, IGF, baseType, base, offset, field);
+    return emitAddressAtOffset(IGF, baseType, base, offset, field);
   }
 
   case FieldAccess::ConstantIndirect: {
     auto metadata = emitHeapMetadataRefForHeapObject(IGF, base, baseType);
     auto offset = emitClassFieldOffset(IGF, baseClass, field, metadata);
-    return emitAddressAtOffset(context, IGF, baseType, base, offset, field);
+    return emitAddressAtOffset(IGF, baseType, base, offset, field);
   }
   }
   llvm_unreachable("bad field-access strategy");

lib/IRGen/GenClass.h

@@ -52,7 +52,7 @@ namespace irgen {
   enum class FieldAccess : uint8_t;
 
   OwnedAddress projectPhysicalClassMemberAddress(
-      TypeExpansionContext context, IRGenFunction &IGF, llvm::Value *base,
+      IRGenFunction &IGF, llvm::Value *base,
       SILType baseType, SILType fieldType, VarDecl *field);
 
   /// Return a strategy for accessing the given stored class property.
@@ -179,8 +179,7 @@ namespace irgen {
   /// Emit the constant fragile offset of the given property inside an instance
   /// of the class.
   llvm::Constant *tryEmitConstantClassFragilePhysicalMemberOffset(
-      TypeExpansionContext context, IRGenModule &IGM, SILType baseType,
-      VarDecl *field);
+      IRGenModule &IGM, SILType baseType, VarDecl *field);
 
   FieldAccess getClassFieldAccess(IRGenModule &IGM,
                                   SILType baseType,

lib/IRGen/GenKeyPath.cpp

@@ -791,7 +791,7 @@ emitKeyPathComponent(IRGenModule &IGM,
       case FieldAccess::ConstantDirect: {
         // Known constant fixed offset.
         auto offset = tryEmitConstantClassFragilePhysicalMemberOffset(
-            TypeExpansionContext::minimal(), IGM, loweredClassTy, property);
+            IGM, loweredClassTy, property);
         assert(offset && "no constant offset for ConstantDirect field?!");
         addFixedOffset(/*struct*/ false, property->isLet(), offset);
         break;

lib/IRGen/GenProto.cpp

@@ -3185,11 +3185,9 @@ void irgen::expandTrailingWitnessSignature(IRGenModule &IGM,
   out.push_back(IGM.WitnessTablePtrTy);
 }
 
-FunctionPointer
-irgen::emitWitnessMethodValue(TypeExpansionContext expansionContext,
-                              IRGenFunction &IGF,
-                              llvm::Value *wtable,
-                              SILDeclRef member) {
+FunctionPointer irgen::emitWitnessMethodValue(IRGenFunction &IGF,
+                                              llvm::Value *wtable,
+                                              SILDeclRef member) {
   auto *fn = cast<AbstractFunctionDecl>(member.getDecl());
   auto proto = cast<ProtocolDecl>(fn->getDeclContext());
 
@@ -3202,8 +3200,8 @@ irgen::emitWitnessMethodValue(TypeExpansionContext expansionContext,
     emitInvariantLoadOfOpaqueWitness(IGF, wtable,
                                      index.forProtocolWitnessTable());
 
-  auto fnType =
-      IGF.IGM.getSILTypes().getConstantFunctionType(expansionContext, member);
+  auto fnType = IGF.IGM.getSILTypes().getConstantFunctionType(
+      IGF.IGM.getMaximalTypeExpansionContext(), member);
   Signature signature = IGF.IGM.getSignature(fnType);
   witnessFnPtr = IGF.Builder.CreateBitCast(witnessFnPtr,
                                            signature.getType()->getPointerTo());
@@ -3212,13 +3210,12 @@ irgen::emitWitnessMethodValue(TypeExpansionContext expansionContext,
 }
 
 FunctionPointer irgen::emitWitnessMethodValue(
-    TypeExpansionContext expansionContext, IRGenFunction &IGF, CanType baseTy,
-    llvm::Value **baseMetadataCache, SILDeclRef member,
-    ProtocolConformanceRef conformance) {
+    IRGenFunction &IGF, CanType baseTy, llvm::Value **baseMetadataCache,
+    SILDeclRef member, ProtocolConformanceRef conformance) {
   llvm::Value *wtable = emitWitnessTableRef(IGF, baseTy, baseMetadataCache,
                                             conformance);
 
-  return emitWitnessMethodValue(expansionContext, IGF, wtable, member);
+  return emitWitnessMethodValue(IGF, wtable, member);
 }
 
 llvm::Value *irgen::computeResilientWitnessTableIndex(

lib/IRGen/GenProto.h

@@ -58,15 +58,13 @@ namespace irgen {
 
   /// Extract the method pointer from the given witness table
   /// as a function value.
-  FunctionPointer emitWitnessMethodValue(TypeExpansionContext context,
-                                         IRGenFunction &IGF,
+  FunctionPointer emitWitnessMethodValue(IRGenFunction &IGF,
                                          llvm::Value *wtable,
                                          SILDeclRef member);
 
   /// Extract the method pointer from an archetype's witness table
   /// as a function value.
-  FunctionPointer emitWitnessMethodValue(TypeExpansionContext context,
-                                         IRGenFunction &IGF, CanType baseTy,
+  FunctionPointer emitWitnessMethodValue(IRGenFunction &IGF, CanType baseTy,
                                          llvm::Value **baseMetadataCache,
                                          SILDeclRef member,
                                          ProtocolConformanceRef conformance);

lib/IRGen/GenThunk.cpp

@@ -36,8 +36,7 @@ using namespace irgen;
 
 /// Find the entry point for a method dispatch thunk.
 llvm::Function *
-IRGenModule::getAddrOfDispatchThunk(TypeExpansionContext context,
-                                    SILDeclRef declRef,
+IRGenModule::getAddrOfDispatchThunk(SILDeclRef declRef,
                                     ForDefinition_t forDefinition) {
   LinkEntity entity = LinkEntity::forDispatchThunk(declRef);
 
@@ -47,7 +46,8 @@ IRGenModule::getAddrOfDispatchThunk(TypeExpansionContext context,
     return entry;
   }
 
-  auto fnType = getSILModule().Types.getConstantFunctionType(context, declRef);
+  auto fnType = getSILModule().Types.getConstantFunctionType(
+      getMaximalTypeExpansionContext(), declRef);
   Signature signature = getSignature(fnType);
   LinkInfo link = LinkInfo::get(*this, entity, forDefinition);
 
@@ -56,7 +56,7 @@ IRGenModule::getAddrOfDispatchThunk(TypeExpansionContext context,
 }
 
 static FunctionPointer lookupMethod(IRGenFunction &IGF, SILDeclRef declRef) {
-  auto expansionContext = TypeExpansionContext::minimal();
+  auto expansionContext = IGF.IGM.getMaximalTypeExpansionContext();
   auto *decl = cast<AbstractFunctionDecl>(declRef.getDecl());
 
   // Protocol case.
@@ -65,7 +65,7 @@ static FunctionPointer lookupMethod(IRGenFunction &IGF, SILDeclRef declRef) {
     llvm::Value *wtable = (IGF.CurFn->arg_end() - 1);
 
     // Find the witness we're interested in.
-    return emitWitnessMethodValue(expansionContext, IGF, wtable, declRef);
+    return emitWitnessMethodValue(IGF, wtable, declRef);
   }
 
   // Class case.
@@ -99,8 +99,7 @@ static FunctionPointer lookupMethod(IRGenFunction &IGF, SILDeclRef declRef) {
 }
 
 void IRGenModule::emitDispatchThunk(SILDeclRef declRef) {
-  auto *f = getAddrOfDispatchThunk(TypeExpansionContext::minimal(), declRef,
-                                   ForDefinition);
+  auto *f = getAddrOfDispatchThunk(declRef, ForDefinition);
 
   IRGenFunction IGF(*this, f);
 

lib/IRGen/IRGenModule.h

@@ -1256,8 +1256,7 @@ private:                            \
   /// Cast the given constant to i8*.
   llvm::Constant *getOpaquePtr(llvm::Constant *pointer);
 
-  llvm::Function *getAddrOfDispatchThunk(TypeExpansionContext context,
-                                         SILDeclRef declRef,
+  llvm::Function *getAddrOfDispatchThunk(SILDeclRef declRef,
                                          ForDefinition_t forDefinition);
   void emitDispatchThunk(SILDeclRef declRef);
 

lib/IRGen/IRGenSIL.cpp

@@ -3623,9 +3623,8 @@ void IRGenSILFunction::visitRefElementAddrInst(swift::RefElementAddrInst *i) {
   llvm::Value *value = base.claimNext();
 
   SILType baseTy = i->getOperand()->getType();
-  Address field = projectPhysicalClassMemberAddress(
-                      TypeExpansionContext(*i->getFunction()), *this, value,
-                      baseTy, i->getType(), i->getField())
+  Address field = projectPhysicalClassMemberAddress(*this, value, baseTy,
+                                                    i->getType(), i->getField())
                       .getAddress();
   setLoweredAddress(i, field);
 }
@@ -5468,8 +5467,7 @@ void IRGenSILFunction::visitWitnessMethodInst(swift::WitnessMethodInst *i) {
 
   if (IGM.isResilient(conformance.getRequirement(),
                       ResilienceExpansion::Maximal)) {
-    auto *fnPtr = IGM.getAddrOfDispatchThunk(
-        IGM.getMaximalTypeExpansionContext(), member, NotForDefinition);
+    auto *fnPtr = IGM.getAddrOfDispatchThunk(member, NotForDefinition);
     auto fnType = IGM.getSILTypes().getConstantFunctionType(
         IGM.getMaximalTypeExpansionContext(), member);
     auto sig = IGM.getSignature(fnType);
@@ -5482,9 +5480,8 @@ void IRGenSILFunction::visitWitnessMethodInst(swift::WitnessMethodInst *i) {
   // It would be nice if this weren't discarded.
   llvm::Value *baseMetadataCache = nullptr;
 
-  auto fn =
-      emitWitnessMethodValue(TypeExpansionContext(*i->getFunction()), *this,
-                             baseTy, &baseMetadataCache, member, conformance);
+  auto fn = emitWitnessMethodValue(*this, baseTy, &baseMetadataCache, member,
+                                   conformance);
 
   setLoweredFunctionPointer(i, fn);
 }
@@ -5668,8 +5665,7 @@ void IRGenSILFunction::visitClassMethodInst(swift::ClassMethodInst *i) {
   auto *classDecl = cast<ClassDecl>(method.getDecl()->getDeclContext());
   if (IGM.hasResilientMetadata(classDecl,
                                ResilienceExpansion::Maximal)) {
-    auto *fnPtr = IGM.getAddrOfDispatchThunk(TypeExpansionContext(*CurSILFn),
-                                             method, NotForDefinition);
+    auto *fnPtr = IGM.getAddrOfDispatchThunk(method, NotForDefinition);
     auto sig = IGM.getSignature(methodType);
     FunctionPointer fn(fnPtr, sig);