AST: Introduce Builtin.RawUnsafeContinuation type

slavapestov · slavapestov · commit 1a89813bf5bb · 2020-12-01T20:03:22.000-05:00
This is otherwise identical to Builtin.RawPointer, but has the spare
bits of a heap object pointer.
diff --git a/docs/ABI/Mangling.rst b/docs/ABI/Mangling.rst
@@ -498,6 +498,7 @@ Types
   type ::= 'BO'                              // Builtin.UnknownObject (no longer a distinct type, but still used for AnyObject)
   type ::= 'Bo'                              // Builtin.NativeObject
   type ::= 'Bp'                              // Builtin.RawPointer
+  type ::= 'Bc'                              // Builtin.RawUnsafeContinuation
   type ::= 'Bt'                              // Builtin.SILToken
   type ::= type 'Bv' NATURAL '_'             // Builtin.Vec<n>x<type>
   type ::= 'Bw'                              // Builtin.Word
diff --git a/include/swift/AST/ASTContext.h b/include/swift/AST/ASTContext.h
@@ -751,6 +751,7 @@ class ASTContext final {
   const CanType TheNativeObjectType;      /// Builtin.NativeObject
   const CanType TheBridgeObjectType;      /// Builtin.BridgeObject
   const CanType TheRawPointerType;        /// Builtin.RawPointer
+  const CanType TheRawUnsafeContinuationType; /// Builtin.RawUnsafeContinuation
   const CanType TheUnsafeValueBufferType; /// Builtin.UnsafeValueBuffer
   const CanType TheSILTokenType;          /// Builtin.SILToken
   const CanType TheIntegerLiteralType;    /// Builtin.IntegerLiteralType
diff --git a/include/swift/AST/TypeDifferenceVisitor.h b/include/swift/AST/TypeDifferenceVisitor.h
@@ -113,6 +113,7 @@ class CanTypeDifferenceVisitor : public CanTypePairVisitor<Impl, bool> {
   }
   SINGLETON_TYPE(BuiltinIntegerLiteralType)
   SINGLETON_TYPE(BuiltinRawPointerType)
+  SINGLETON_TYPE(BuiltinRawUnsafeContinuationType)
   SINGLETON_TYPE(BuiltinNativeObjectType)
   SINGLETON_TYPE(BuiltinBridgeObjectType)
   SINGLETON_TYPE(BuiltinUnsafeValueBufferType)
diff --git a/include/swift/AST/TypeMatcher.h b/include/swift/AST/TypeMatcher.h
@@ -105,6 +105,7 @@ class TypeMatcher {
     TRIVIAL_CASE(BuiltinIntegerLiteralType)
     TRIVIAL_CASE(BuiltinFloatType)
     TRIVIAL_CASE(BuiltinRawPointerType)
+    TRIVIAL_CASE(BuiltinRawUnsafeContinuationType)
     TRIVIAL_CASE(BuiltinNativeObjectType)
     TRIVIAL_CASE(BuiltinBridgeObjectType)
     TRIVIAL_CASE(BuiltinUnsafeValueBufferType)
diff --git a/include/swift/AST/TypeNodes.def b/include/swift/AST/TypeNodes.def
@@ -97,6 +97,7 @@ ABSTRACT_TYPE(Builtin, Type)
     TYPE_RANGE(AnyBuiltinInteger, BuiltinInteger, BuiltinIntegerLiteral)
   BUILTIN_TYPE(BuiltinFloat, BuiltinType)
   BUILTIN_TYPE(BuiltinRawPointer, BuiltinType)
+  BUILTIN_TYPE(BuiltinRawUnsafeContinuation, BuiltinType)
   BUILTIN_TYPE(BuiltinNativeObject, BuiltinType)
   BUILTIN_TYPE(BuiltinBridgeObject, BuiltinType)
   BUILTIN_TYPE(BuiltinUnsafeValueBuffer, BuiltinType)
diff --git a/include/swift/AST/Types.h b/include/swift/AST/Types.h
@@ -1391,6 +1391,20 @@ class BuiltinRawPointerType : public BuiltinType {
 };
 DEFINE_EMPTY_CAN_TYPE_WRAPPER(BuiltinRawPointerType, BuiltinType);
 
+/// BuiltinRawContinuationType - The builtin raw unsafe continuation type.
+/// This pointer is completely unmanaged, but is lowered with the same
+/// spare bits as an opaque object-pointer type.
+class BuiltinRawUnsafeContinuationType : public BuiltinType {
+  friend class ASTContext;
+  BuiltinRawUnsafeContinuationType(const ASTContext &C)
+    : BuiltinType(TypeKind::BuiltinRawUnsafeContinuation, C) {}
+public:
+  static bool classof(const TypeBase *T) {
+    return T->getKind() == TypeKind::BuiltinRawUnsafeContinuation;
+  }
+};
+DEFINE_EMPTY_CAN_TYPE_WRAPPER(BuiltinRawUnsafeContinuationType, BuiltinType);
+
 /// BuiltinNativeObjectType - The builtin opaque object-pointer type.
 /// Useful for keeping an object alive when it is otherwise being
 /// manipulated via an unsafe pointer type.
diff --git a/include/swift/Strings.h b/include/swift/Strings.h
@@ -110,6 +110,9 @@ constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_BRIDGEOBJECT = {
 /// The name of the Builtin type for RawPointer
 constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_RAWPOINTER = {
     "Builtin.RawPointer"};
+/// The name of the Builtin type for RawUnsafeContinuation
+constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_RAWUNSAFECONTINUATION = {
+    "Builtin.RawUnsafeContinuation"};
 /// The name of the Builtin type for UnsafeValueBuffer
 constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_UNSAFEVALUEBUFFER =
     {"Builtin.UnsafeValueBuffer"};
diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp
@@ -595,6 +595,8 @@ ASTContext::ASTContext(LangOptions &langOpts, TypeCheckerOptions &typeckOpts,
                            BuiltinBridgeObjectType(*this)),
     TheRawPointerType(new (*this, AllocationArena::Permanent)
                         BuiltinRawPointerType(*this)),
+    TheRawUnsafeContinuationType(new (*this, AllocationArena::Permanent)
+                                 BuiltinRawUnsafeContinuationType(*this)),
     TheUnsafeValueBufferType(new (*this, AllocationArena::Permanent)
                                BuiltinUnsafeValueBufferType(*this)),
     TheSILTokenType(new (*this, AllocationArena::Permanent)
diff --git a/lib/AST/ASTDumper.cpp b/lib/AST/ASTDumper.cpp
@@ -3561,6 +3561,7 @@ namespace {
 
     TRIVIAL_TYPE_PRINTER(BuiltinIntegerLiteral, builtin_integer_literal)
     TRIVIAL_TYPE_PRINTER(BuiltinRawPointer, builtin_raw_pointer)
+    TRIVIAL_TYPE_PRINTER(BuiltinRawUnsafeContinuation, builtin_raw_unsafe_continuation)
     TRIVIAL_TYPE_PRINTER(BuiltinNativeObject, builtin_native_object)
     TRIVIAL_TYPE_PRINTER(BuiltinBridgeObject, builtin_bridge_object)
     TRIVIAL_TYPE_PRINTER(BuiltinUnsafeValueBuffer, builtin_unsafe_value_buffer)
diff --git a/lib/AST/ASTMangler.cpp b/lib/AST/ASTMangler.cpp
@@ -975,6 +975,8 @@ void ASTMangler::appendType(Type type, const ValueDecl *forDecl) {
       return appendOperator("BI");
     case TypeKind::BuiltinRawPointer:
       return appendOperator("Bp");
+    case TypeKind::BuiltinRawUnsafeContinuation:
+      return appendOperator("Bc");
     case TypeKind::BuiltinNativeObject:
       return appendOperator("Bo");
     case TypeKind::BuiltinBridgeObject:
diff --git a/lib/AST/ASTPrinter.cpp b/lib/AST/ASTPrinter.cpp
@@ -3853,6 +3853,7 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     Printer << buffer;                                                         \
   }
   ASTPRINTER_PRINT_BUILTINTYPE(BuiltinRawPointerType)
+  ASTPRINTER_PRINT_BUILTINTYPE(BuiltinRawUnsafeContinuationType)
   ASTPRINTER_PRINT_BUILTINTYPE(BuiltinNativeObjectType)
   ASTPRINTER_PRINT_BUILTINTYPE(BuiltinBridgeObjectType)
   ASTPRINTER_PRINT_BUILTINTYPE(BuiltinUnsafeValueBufferType)
diff --git a/lib/AST/Builtins.cpp b/lib/AST/Builtins.cpp
@@ -78,6 +78,8 @@ Type swift::getBuiltinType(ASTContext &Context, StringRef Name) {
 
   if (Name == "RawPointer")
     return Context.TheRawPointerType;
+  if (Name == "RawUnsafeContinuation")
+    return Context.TheRawUnsafeContinuationType;
   if (Name == "NativeObject")
     return Context.TheNativeObjectType;
   if (Name == "BridgeObject")
@@ -2628,6 +2630,9 @@ StringRef BuiltinType::getTypeName(SmallVectorImpl<char> &result,
   case BuiltinTypeKind::BuiltinRawPointer:
     printer << MAYBE_GET_NAMESPACED_BUILTIN(BUILTIN_TYPE_NAME_RAWPOINTER);
     break;
+  case BuiltinTypeKind::BuiltinRawUnsafeContinuation:
+    printer << MAYBE_GET_NAMESPACED_BUILTIN(BUILTIN_TYPE_NAME_RAWUNSAFECONTINUATION);
+    break;
   case BuiltinTypeKind::BuiltinNativeObject:
     printer << MAYBE_GET_NAMESPACED_BUILTIN(BUILTIN_TYPE_NAME_NATIVEOBJECT);
     break;
diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
@@ -208,6 +208,7 @@ bool CanType::isReferenceTypeImpl(CanType type, const GenericSignatureImpl *sig,
   case TypeKind::BuiltinIntegerLiteral:
   case TypeKind::BuiltinFloat:
   case TypeKind::BuiltinRawPointer:
+  case TypeKind::BuiltinRawUnsafeContinuation:
   case TypeKind::BuiltinUnsafeValueBuffer:
   case TypeKind::BuiltinVector:
   case TypeKind::Tuple:
@@ -5003,6 +5004,7 @@ ReferenceCounting TypeBase::getReferenceCounting() {
   case TypeKind::BuiltinIntegerLiteral:
   case TypeKind::BuiltinFloat:
   case TypeKind::BuiltinRawPointer:
+  case TypeKind::BuiltinRawUnsafeContinuation:
   case TypeKind::BuiltinUnsafeValueBuffer:
   case TypeKind::BuiltinVector:
   case TypeKind::Tuple:
diff --git a/lib/Demangling/Demangler.cpp b/lib/Demangling/Demangler.cpp
@@ -1179,6 +1179,10 @@ NodePointer Demangler::demangleBuiltinType() {
       Ty = createNode(Node::Kind::BuiltinTypeName,
                                BUILTIN_TYPE_NAME_RAWPOINTER);
       break;
+    case 'c':
+      Ty = createNode(Node::Kind::BuiltinTypeName,
+                               BUILTIN_TYPE_NAME_RAWUNSAFECONTINUATION);
+      break;
     case 't':
       Ty = createNode(Node::Kind::BuiltinTypeName, BUILTIN_TYPE_NAME_SILTOKEN);
       break;
diff --git a/lib/Demangling/Remangler.cpp b/lib/Demangling/Remangler.cpp
@@ -743,6 +743,8 @@ void Remangler::mangleBuiltinTypeName(Node *node) {
     Buffer << 'o';
   } else if (text == BUILTIN_TYPE_NAME_RAWPOINTER) {
     Buffer << 'p';
+  } else if (text == BUILTIN_TYPE_NAME_RAWUNSAFECONTINUATION) {
+    Buffer << 'c';
   } else if (text == BUILTIN_TYPE_NAME_SILTOKEN) {
     Buffer << 't';
   } else if (text == BUILTIN_TYPE_NAME_INTLITERAL) {
diff --git a/lib/IRGen/GenType.cpp b/lib/IRGen/GenType.cpp
@@ -1009,11 +1009,10 @@ namespace {
   class RawPointerTypeInfo final :
     public PODSingleScalarTypeInfo<RawPointerTypeInfo, LoadableTypeInfo> {
   public:
-    RawPointerTypeInfo(llvm::Type *storage, Size size, Alignment align)
-      : PODSingleScalarTypeInfo(
-          storage, size,
-          SpareBitVector::getConstant(size.getValueInBits(), false),
-          align) {}
+    RawPointerTypeInfo(llvm::Type *storage,
+                       Size size, SpareBitVector spareBits,
+                       Alignment align)
+      : PODSingleScalarTypeInfo(storage, size, spareBits, align) {}
 
     bool mayHaveExtraInhabitants(IRGenModule &IGM) const override {
       return true;
@@ -1555,14 +1554,32 @@ const LoadableTypeInfo &IRGenModule::getRawPointerTypeInfo() {
 
 const LoadableTypeInfo &TypeConverter::getRawPointerTypeInfo() {
   if (RawPointerTI) return *RawPointerTI;
-  RawPointerTI = new RawPointerTypeInfo(IGM.Int8PtrTy,
-                                        IGM.getPointerSize(),
+  auto size = IGM.getPointerSize();
+  auto spareBits = SpareBitVector::getConstant(size.getValueInBits(), false);
+  RawPointerTI = new RawPointerTypeInfo(IGM.Int8PtrTy, size,
+                                        std::move(spareBits),
                                         IGM.getPointerAlignment());
   RawPointerTI->NextConverted = FirstType;
   FirstType = RawPointerTI;
   return *RawPointerTI;
 }
 
+const LoadableTypeInfo &IRGenModule::getRawUnsafeContinuationTypeInfo() {
+  return Types.getRawUnsafeContinuationTypeInfo();
+}
+
+const LoadableTypeInfo &TypeConverter::getRawUnsafeContinuationTypeInfo() {
+  if (RawUnsafeContinuationTI) return *RawUnsafeContinuationTI;
+  auto spareBits = IGM.getHeapObjectSpareBits();
+  RawUnsafeContinuationTI = new RawPointerTypeInfo(IGM.Int8PtrTy,
+                                                   IGM.getPointerSize(),
+                                                   std::move(spareBits),
+                                                   IGM.getPointerAlignment());
+  RawUnsafeContinuationTI->NextConverted = FirstType;
+  FirstType = RawUnsafeContinuationTI;
+  return *RawUnsafeContinuationTI;
+}
+
 const LoadableTypeInfo &TypeConverter::getEmptyTypeInfo() {
   if (EmptyTI) return *EmptyTI;
   EmptyTI = new EmptyTypeInfo(IGM.Int8Ty);
@@ -1967,6 +1984,8 @@ const TypeInfo *TypeConverter::convertType(CanType ty) {
                            getFixedBufferAlignment(IGM));
   case TypeKind::BuiltinRawPointer:
     return &getRawPointerTypeInfo();
+  case TypeKind::BuiltinRawUnsafeContinuation:
+    return &getRawUnsafeContinuationTypeInfo();
   case TypeKind::BuiltinIntegerLiteral:
     return &getIntegerLiteralTypeInfo();
   case TypeKind::BuiltinFloat:
diff --git a/lib/IRGen/GenType.h b/lib/IRGen/GenType.h
@@ -103,6 +103,7 @@ class TypeConverter {
   const LoadableTypeInfo *UnknownObjectTI = nullptr;
   const LoadableTypeInfo *BridgeObjectTI = nullptr;
   const LoadableTypeInfo *RawPointerTI = nullptr;
+  const LoadableTypeInfo *RawUnsafeContinuationTI = nullptr;
   const LoadableTypeInfo *WitnessTablePtrTI = nullptr;
   const TypeInfo *TypeMetadataPtrTI = nullptr;
   const TypeInfo *SwiftContextPtrTI = nullptr;
@@ -183,6 +184,7 @@ class TypeConverter {
   const LoadableTypeInfo &getUnknownObjectTypeInfo();
   const LoadableTypeInfo &getBridgeObjectTypeInfo();
   const LoadableTypeInfo &getRawPointerTypeInfo();
+  const LoadableTypeInfo &getRawUnsafeContinuationTypeInfo();
   const TypeInfo &getTypeMetadataPtrTypeInfo();
   const TypeInfo &getSwiftContextPtrTypeInfo();
   const TypeInfo &getTaskContinuationFunctionPtrTypeInfo();
diff --git a/lib/IRGen/IRGenDebugInfo.cpp b/lib/IRGen/IRGenDebugInfo.cpp
@@ -1326,6 +1326,13 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
                                         MangledName);
     }
 
+    case TypeKind::BuiltinRawUnsafeContinuation: {
+      unsigned PtrSize = CI.getTargetInfo().getPointerWidth(0);
+      return DBuilder.createPointerType(nullptr, PtrSize, 0,
+                                        /* DWARFAddressSpace */ None,
+                                        MangledName);
+    }
+
     case TypeKind::DynamicSelf: {
       // Self. We don't have a way to represent instancetype in DWARF,
       // so we emit the static type instead. This is similar to what we
diff --git a/lib/IRGen/IRGenModule.h b/lib/IRGen/IRGenModule.h
@@ -908,6 +908,7 @@ class IRGenModule {
   const LoadableTypeInfo &getUnknownObjectTypeInfo();
   const LoadableTypeInfo &getBridgeObjectTypeInfo();
   const LoadableTypeInfo &getRawPointerTypeInfo();
+  const LoadableTypeInfo &getRawUnsafeContinuationTypeInfo();
   llvm::Type *getStorageTypeForUnlowered(Type T);
   llvm::Type *getStorageTypeForLowered(CanType T);
   llvm::Type *getStorageType(SILType T);
diff --git a/lib/IRGen/MetadataRequest.cpp b/lib/IRGen/MetadataRequest.cpp
@@ -1297,6 +1297,12 @@ namespace {
       return emitDirectMetadataRef(type);
     }
 
+    MetadataResponse
+    visitBuiltinRawUnsafeContinuationType(CanBuiltinRawUnsafeContinuationType type,
+                                          DynamicMetadataRequest request) {
+      return emitDirectMetadataRef(type);
+    }
+
     MetadataResponse
     visitBuiltinFloatType(CanBuiltinFloatType type,
                           DynamicMetadataRequest request) {
diff --git a/lib/SIL/IR/TypeLowering.cpp b/lib/SIL/IR/TypeLowering.cpp
@@ -243,6 +243,7 @@ namespace {
     IMPL(BuiltinIntegerLiteral, Trivial)
     IMPL(BuiltinFloat, Trivial)
     IMPL(BuiltinRawPointer, Trivial)
+    IMPL(BuiltinRawUnsafeContinuation, Trivial)
     IMPL(BuiltinNativeObject, Reference)
     IMPL(BuiltinBridgeObject, Reference)
     IMPL(BuiltinVector, Trivial)

Original file line number	Diff line number	Diff line change
`@@ -113,6 +113,7 @@ class CanTypeDifferenceVisitor : public CanTypePairVisitor<Impl, bool> {`
`113`	`113`	`}`
`114`	`114`	`SINGLETON_TYPE(BuiltinIntegerLiteralType)`
`115`	`115`	`SINGLETON_TYPE(BuiltinRawPointerType)`
	`116`	`+ SINGLETON_TYPE(BuiltinRawUnsafeContinuationType)`
`116`	`117`	`SINGLETON_TYPE(BuiltinNativeObjectType)`
`117`	`118`	`SINGLETON_TYPE(BuiltinBridgeObjectType)`
`118`	`119`	`SINGLETON_TYPE(BuiltinUnsafeValueBufferType)`