Merge pull request swiftlang#23004 from slavapestov/sil-resilience-expansion-plumbing

Continue plumbing resilience expansion through SIL type lowering

Author: slavapestov

include/swift/SIL/OptimizationRemark.h

@@ -50,7 +50,8 @@ struct Argument {
   Argument(StringRef Key, unsigned long long N);
 
   Argument(StringRef Key, SILFunction *F);
-  Argument(StringRef Key, SILType *Ty);
+  Argument(StringRef Key, SILType Ty);
+  Argument(StringRef Key, CanType Ty);
 };
 
 /// Shorthand to insert named-value pairs.

include/swift/SIL/SILBuilder.h

@@ -918,8 +918,10 @@ class SILBuilder {
   } \
   Copy##Name##ValueInst *createCopy##Name##Value(SILLocation Loc, \
                                                  SILValue operand) { \
+    auto type = getFunction().getLoweredType( \
+      operand->getType().getASTType().getReferenceStorageReferent()); \
     return insert(new (getModule()) \
-      Copy##Name##ValueInst(getSILDebugLocation(Loc), operand, getModule())); \
+      Copy##Name##ValueInst(getSILDebugLocation(Loc), operand, type)); \
   }
 #define SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, ...) \
   NEVER_LOADABLE_CHECKED_REF_STORAGE(Name, "...") \

include/swift/SIL/SILFunction.h

@@ -38,6 +38,11 @@ class SILModule;
 class SILFunctionBuilder;
 class SILProfiler;
 
+namespace Lowering {
+class TypeLowering;
+class AbstractionPattern;
+}
+
 enum IsBare_t { IsNotBare, IsBare };
 enum IsTransparent_t { IsNotTransparent, IsTransparent };
 enum Inline_t { InlineDefault, NoInline, AlwaysInline };
@@ -464,6 +469,19 @@ class SILFunction
             : ResilienceExpansion::Maximal);
   }
 
+  const Lowering::TypeLowering &
+  getTypeLowering(Lowering::AbstractionPattern orig, Type subst);
+
+  const Lowering::TypeLowering &getTypeLowering(Type t) const;
+
+  SILType getLoweredType(Lowering::AbstractionPattern orig, Type subst) const;
+
+  SILType getLoweredType(Type t) const;
+
+  SILType getLoweredLoadableType(Type t) const;
+
+  const Lowering::TypeLowering &getTypeLowering(SILType type) const;
+
   /// Returns true if this function has a calling convention that has a self
   /// argument.
   bool hasSelfParam() const {

include/swift/SIL/SILInstruction.h

@@ -6328,9 +6328,8 @@ class Copy##Name##ValueInst \
                                   SingleValueInstruction> { \
   friend class SILBuilder; \
   Copy##Name##ValueInst(SILDebugLocation DebugLoc, SILValue operand, \
-                       SILModule &M) \
-      : UnaryInstructionBase(DebugLoc, operand, \
-                             operand->getType().getReferentType(M)) {} \
+                        SILType type) \
+      : UnaryInstructionBase(DebugLoc, operand, type) {} \
 };
 #include "swift/AST/ReferenceStorage.def"
 

include/swift/SIL/SILModule.h

@@ -598,7 +598,10 @@ class SILModule {
 
   /// Can value operations (copies and destroys) on the given lowered type
   /// be performed in this module?
-  bool isTypeABIAccessible(SILType type);
+  // FIXME: Expansion
+  bool isTypeABIAccessible(SILType type,
+                           ResilienceExpansion forExpansion
+                             = ResilienceExpansion::Minimal);
 
   /// Can type metadata for the given formal type be fetched in
   /// the given module?

include/swift/SIL/SILType.h

@@ -477,12 +477,6 @@ class SILType {
   /// representation. Class existentials do not always qualify.
   bool isHeapObjectReferenceType() const;
 
-  /// Return the SILType corresponding to the underlying type of the given
-  /// metatype type.
-  ///
-  /// *NOTE* Only call on SILTypes for metatype types.
-  SILType getMetatypeInstanceType(SILModule& M) const;
-
   /// Returns true if this SILType is an aggregate that contains \p Ty
   bool aggregateContainsRecord(SILType Ty, SILModule &SILMod) const;
 
@@ -501,10 +495,6 @@ class SILType {
 
   /// Returns true if this is the AnyObject SILType;
   bool isAnyObject() const { return getASTType()->isAnyObject(); }
-
-  /// Returns the underlying referent SILType of an @sil_unowned or @sil_weak
-  /// Type.
-  SILType getReferentType(SILModule &M) const;
 
   /// Returns a SILType with any archetypes mapped out of context.
   SILType mapTypeOutOfContext() const;

include/swift/SIL/TypeLowering.h

@@ -769,13 +769,16 @@ class TypeConverter {
                                ResilienceExpansion::Minimal);
 
   // Returns the lowered SIL type for a Swift type.
-  SILType getLoweredType(Type t) {
-    return getTypeLowering(t, ResilienceExpansion::Minimal).getLoweredType();
+  SILType getLoweredType(Type t, ResilienceExpansion forExpansion
+                           = ResilienceExpansion::Minimal) {
+    return getTypeLowering(t, forExpansion).getLoweredType();
   }
 
   // Returns the lowered SIL type for a Swift type.
-  SILType getLoweredType(AbstractionPattern origType, Type substType) {
-    return getTypeLowering(origType, substType, ResilienceExpansion::Minimal)
+  SILType getLoweredType(AbstractionPattern origType, Type substType,
+                         ResilienceExpansion forExpansion =
+                           ResilienceExpansion::Minimal) {
+    return getTypeLowering(origType, substType, forExpansion)
       .getLoweredType();
   }
 

include/swift/SILOptimizer/Utils/Devirtualize.h

@@ -44,7 +44,7 @@ class Emitter;
 /// \p Subs a container to be used for storing the set of subclasses
 void getAllSubclasses(ClassHierarchyAnalysis *CHA,
                       ClassDecl *CD,
-                      SILType ClassType,
+                      CanType ClassType,
                       SILModule &M,
                       ClassHierarchyAnalysis::ClassList &Subs);
 
@@ -69,18 +69,19 @@ ApplySite tryDevirtualizeApply(ApplySite AI,
                                ClassHierarchyAnalysis *CHA,
                                OptRemark::Emitter *ORE = nullptr);
 bool canDevirtualizeApply(FullApplySite AI, ClassHierarchyAnalysis *CHA);
-bool isNominalTypeWithUnboundGenericParameters(SILType Ty, SILModule &M);
-bool canDevirtualizeClassMethod(FullApplySite AI, SILType ClassInstanceType,
+bool canDevirtualizeClassMethod(FullApplySite AI, ClassDecl *CD,
                                 OptRemark::Emitter *ORE = nullptr,
                                 bool isEffectivelyFinalMethod = false);
-SILFunction *getTargetClassMethod(SILModule &M, SILType ClassOrMetatypeType,
+SILFunction *getTargetClassMethod(SILModule &M, ClassDecl *CD,
                                   MethodInst *MI);
+CanType getSelfInstanceType(CanType ClassOrMetatypeType);
 
 /// Devirtualize the given apply site, which is known to be devirtualizable.
 ///
 /// The caller must call deleteDevirtualizedApply on the original apply site.
 FullApplySite devirtualizeClassMethod(FullApplySite AI,
                                       SILValue ClassInstance,
+                                      ClassDecl *CD,
                                       OptRemark::Emitter *ORE);
 
 /// Attempt to devirtualize the given apply site, which is known to be
@@ -89,7 +90,9 @@ FullApplySite devirtualizeClassMethod(FullApplySite AI,
 /// If this succeeds, the caller must call deleteDevirtualizedApply on
 /// the original apply site.
 FullApplySite
-tryDevirtualizeClassMethod(FullApplySite AI, SILValue ClassInstance,
+tryDevirtualizeClassMethod(FullApplySite AI,
+                           SILValue ClassInstance,
+                           ClassDecl *CD,
                            OptRemark::Emitter *ORE,
                            bool isEffectivelyFinalMethod = false);
 

include/swift/SILOptimizer/Utils/Local.h

@@ -522,11 +522,6 @@ bool simplifyUsers(SingleValueInstruction *I);
 /// without a significant increase to code size.
 bool shouldExpand(SILModule &Module, SILType Ty);
 
-/// Check if a given type is a simple type, i.e. a builtin
-/// integer or floating point type or a struct/tuple whose members
-/// are of simple types.
-bool isSimpleType(SILType SILTy, SILModule& Module);
-
 /// Check if the value of V is computed by means of a simple initialization.
 /// Store the actual SILValue into \p Val and the reversed list of instructions
 /// initializing it in \p Insns.

lib/IRGen/GenType.cpp

@@ -1456,7 +1456,7 @@ llvm::PointerType *IRGenModule::getStoragePointerTypeForLowered(CanType T) {
 }
 
 llvm::Type *IRGenModule::getStorageTypeForUnlowered(Type subst) {
-  return getStorageType(getSILTypes().getLoweredType(subst));
+  return getStorageType(getLoweredType(subst));
 }
 
 llvm::Type *IRGenModule::getStorageType(SILType T) {
@@ -1486,7 +1486,7 @@ IRGenModule::getTypeInfoForUnlowered(AbstractionPattern orig, Type subst) {
 /// have yet undergone SIL type lowering.
 const TypeInfo &
 IRGenModule::getTypeInfoForUnlowered(AbstractionPattern orig, CanType subst) {
-  return getTypeInfo(getSILTypes().getLoweredType(orig, subst));
+  return getTypeInfo(getLoweredType(orig, subst));
 }
 
 /// Get the fragile type information for the given type, which is known