TypeLowering: add a recursive property to check if a type contains a RawPointer

This is needed for the new escape analysis

Author: eeckstein

SwiftCompilerSources/Sources/SIL/Type.swift

@@ -27,6 +27,10 @@ public struct Type : CustomStringConvertible, CustomReflectable {
     return SILType_isReferenceCounted(bridged, function.bridged) != 0
   }
 
+  public func isNonTrivialOrContainsRawPointer(in function: Function) -> Bool {
+    return SILType_isNonTrivialOrContainsRawPointer(bridged, function.bridged) != 0
+  }
+
   public var isNominal: Bool { SILType_isNominal(bridged) != 0 }
   public var isClass: Bool { SILType_isClass(bridged) != 0 }
   public var isStruct: Bool { SILType_isStruct(bridged) != 0 }

include/swift/SIL/SILBridging.h

@@ -219,6 +219,7 @@ BridgedStringRef SILType_debugDescription(BridgedType);
 SwiftInt SILType_isAddress(BridgedType);
 SwiftInt SILType_isTrivial(BridgedType, BridgedFunction);
 SwiftInt SILType_isReferenceCounted(BridgedType type, BridgedFunction);
+SwiftInt SILType_isNonTrivialOrContainsRawPointer(BridgedType, BridgedFunction);
 SwiftInt SILType_isNominal(BridgedType type);
 SwiftInt SILType_isClass(BridgedType type);
 SwiftInt SILType_isStruct(BridgedType type);

include/swift/SIL/SILType.h

@@ -308,6 +308,15 @@ class SILType {
   /// even though they are technically trivial.
   bool isTrivial(const SILFunction &F) const;
 
+  /// True if the type is the Builtin.RawPointer or a struct/tuple/enum which
+  /// contains a Builtin.RawPointer.
+  /// Returns false for types for which this property is not known, e.g. generic
+  /// types.
+  bool isOrContainsRawPointer(const SILFunction &F) const;
+
+  /// An efficient implementation of `!isTrivial() && isOrContainsRawPointer()`.
+  bool isNonTrivialOrContainsRawPointer(const SILFunction &F) const;
+
   /// True if the type is an empty tuple or an empty struct or a tuple or
   /// struct containing only empty types.
   bool isEmpty(const SILFunction &F) const;

include/swift/SIL/TypeLowering.h

@@ -98,6 +98,15 @@ enum IsTrivial_t : bool {
   IsTrivial = true
 };
 
+/// Is a lowered SIL type the Builtin.RawPointer or a struct/tuple/enum which
+/// contains a Builtin.RawPointer?
+/// HasRawPointer is true only for types that are known to contain
+/// Builtin.RawPointer. It is not assumed true for generic or resilient types.
+enum HasRawPointer_t : bool {
+  DoesNotHaveRawPointer = false,
+  HasRawPointer = true
+};
+
 /// Is a lowered SIL type fixed-ABI?  That is, can the current context
 /// assign it a fixed size and alignment and perform value operations on it
 /// (such as copies, destroys, constructions, and projections) without
@@ -172,6 +181,7 @@ class TypeLowering {
       ResilientFlag              = 1 << 3,
       TypeExpansionSensitiveFlag = 1 << 4,
       InfiniteFlag               = 1 << 5,
+      HasRawPointerFlag          = 1 << 6,
     };
 
     uint8_t Flags;
@@ -184,12 +194,14 @@ class TypeLowering {
         IsTrivial_t isTrivial, IsFixedABI_t isFixedABI,
         IsAddressOnly_t isAddressOnly, IsResilient_t isResilient,
         IsTypeExpansionSensitive_t isTypeExpansionSensitive =
-            IsNotTypeExpansionSensitive)
+            IsNotTypeExpansionSensitive,
+        HasRawPointer_t hasRawPointer = DoesNotHaveRawPointer)
         : Flags((isTrivial ? 0U : NonTrivialFlag) |
                 (isFixedABI ? 0U : NonFixedABIFlag) |
                 (isAddressOnly ? AddressOnlyFlag : 0U) |
                 (isResilient ? ResilientFlag : 0U) |
-                (isTypeExpansionSensitive ? TypeExpansionSensitiveFlag : 0U)) {}
+                (isTypeExpansionSensitive ? TypeExpansionSensitiveFlag : 0U) |
+                (hasRawPointer ? HasRawPointerFlag : 0U)) {}
 
     constexpr bool operator==(RecursiveProperties p) const {
       return Flags == p.Flags;
@@ -199,6 +211,11 @@ class TypeLowering {
       return {IsTrivial, IsFixedABI, IsNotAddressOnly, IsNotResilient};
     }
 
+    static constexpr RecursiveProperties forRawPointer() {
+      return {IsTrivial, IsFixedABI, IsNotAddressOnly, IsNotResilient,
+              IsNotTypeExpansionSensitive, HasRawPointer};
+    }
+
     static constexpr RecursiveProperties forReference() {
       return {IsNotTrivial, IsFixedABI, IsNotAddressOnly, IsNotResilient};
     }
@@ -219,6 +236,9 @@ class TypeLowering {
     IsTrivial_t isTrivial() const {
       return IsTrivial_t((Flags & NonTrivialFlag) == 0);
     }
+    IsTrivial_t isOrContainsRawPointer() const {
+      return IsTrivial_t((Flags & HasRawPointerFlag) != 0);
+    }
     IsFixedABI_t isFixedABI() const {
       return IsFixedABI_t((Flags & NonFixedABIFlag) == 0);
     }
@@ -315,6 +335,10 @@ class TypeLowering {
     return Properties.isTrivial();
   }
 
+  bool isOrContainsRawPointer() const {
+    return Properties.isOrContainsRawPointer();
+  }
+  
   /// Returns true if the type is a scalar reference-counted reference, which
   /// can be retained and released.
   bool isReferenceCounted() const {

lib/SIL/IR/SILType.cpp

@@ -108,6 +108,17 @@ bool SILType::isTrivial(const SILFunction &F) const {
   return F.getTypeLowering(contextType).isTrivial();
 }
 
+bool SILType::isOrContainsRawPointer(const SILFunction &F) const {
+  auto contextType = hasTypeParameter() ? F.mapTypeIntoContext(*this) : *this;
+  return F.getTypeLowering(contextType).isOrContainsRawPointer();
+}
+
+bool SILType::isNonTrivialOrContainsRawPointer(const SILFunction &F) const {
+  auto contextType = hasTypeParameter() ? F.mapTypeIntoContext(*this) : *this;
+  const TypeLowering &tyLowering = F.getTypeLowering(contextType);
+  return !tyLowering.isTrivial() || tyLowering.isOrContainsRawPointer();
+}
+
 bool SILType::isEmpty(const SILFunction &F) const {
   // Infinite types are never empty.
   if (F.getTypeLowering(*this).getRecursiveProperties().isInfinite()) {

lib/SIL/IR/TypeLowering.cpp

@@ -244,7 +244,6 @@ namespace {
     IMPL(BuiltinInteger, Trivial)
     IMPL(BuiltinIntegerLiteral, Trivial)
     IMPL(BuiltinFloat, Trivial)
-    IMPL(BuiltinRawPointer, Trivial)
     IMPL(BuiltinRawUnsafeContinuation, Trivial)
     IMPL(BuiltinJob, Trivial)
     IMPL(BuiltinExecutor, Trivial)
@@ -259,6 +258,14 @@ namespace {
 
 #undef IMPL
 
+    RetTy visitBuiltinRawPointerType(CanBuiltinRawPointerType type,
+                                     AbstractionPattern orig,
+                                     IsTypeExpansionSensitive_t isSensitive) {
+      RecursiveProperties props = mergeIsTypeExpansionSensitive(isSensitive,
+                                          RecursiveProperties::forRawPointer());
+      return asImpl().handleTrivial(type, props);
+    }
+
     RetTy visitBuiltinUnsafeValueBufferType(
                                          CanBuiltinUnsafeValueBufferType type,
                                          AbstractionPattern origType,

lib/SIL/Utils/SILBridging.cpp

@@ -371,6 +371,12 @@ SwiftInt SILType_isReferenceCounted(BridgedType type, BridgedFunction function)
   return castToSILType(type).isReferenceCounted(f->getModule()) ? 1 : 0;
 }
 
+SwiftInt SILType_isNonTrivialOrContainsRawPointer(BridgedType type,
+                                                  BridgedFunction function) {
+  SILFunction *f = castToFunction(function);
+  return castToSILType(type).isNonTrivialOrContainsRawPointer(*f);
+}
+
 SwiftInt SILType_isNominal(BridgedType type) {
   return castToSILType(type).getNominalOrBoundGenericNominal() ? 1 : 0;
 }