Merge pull request swiftlang#35103 from nate-chandler/concurrency/irgen/rdar72336407

nate-chandler · web-flow · commit 253099a1ce43 · 2020-12-16T06:14:35.000-08:00
[IRGen] Corrected mangling of AsyncFunctionPointers.
diff --git a/docs/ABI/Mangling.rst b/docs/ABI/Mangling.rst
@@ -207,6 +207,7 @@ types where the metadata itself has unknown layout.)
   global ::= global 'TD'                 // dynamic dispatch thunk
   global ::= global 'Td'                 // direct method reference thunk
   global ::= global 'TI'                 // implementation of a dynamic_replaceable function
+  global :== global 'Tu'                 // async function pointer of a function
   global ::= global 'TX'                 // function pointer of a dynamic_replaceable function
   global ::= entity entity 'TV'          // vtable override thunk, derived followed by base
   global ::= type label-list? 'D'        // type mangling for the debugger with label list for function types.
diff --git a/include/swift/Demangling/DemangleNodes.def b/include/swift/Demangling/DemangleNodes.def
@@ -306,5 +306,8 @@ NODE(GlobalVariableOnceToken)
 NODE(GlobalVariableOnceDeclList)
 NODE(CanonicalPrespecializedGenericTypeCachingOnceToken)
 
+// Added in Swift 5.5
+NODE(AsyncFunctionPointer)
+
 #undef CONTEXT_NODE
 #undef NODE
diff --git a/lib/Demangling/Demangler.cpp b/lib/Demangling/Demangler.cpp
@@ -122,6 +122,7 @@ bool swift::Demangle::isFunctionAttr(Node::Kind kind) {
     case Node::Kind::DynamicallyReplaceableFunctionImpl:
     case Node::Kind::DynamicallyReplaceableFunctionKey:
     case Node::Kind::DynamicallyReplaceableFunctionVar:
+    case Node::Kind::AsyncFunctionPointer:
       return true;
     default:
       return false;
@@ -2477,6 +2478,7 @@ NodePointer Demangler::popProtocolConformance() {
         return nullptr;
       return createNode(Node::Kind::OutlinedBridgedMethod, Params);
     }
+    case 'u': return createNode(Node::Kind::AsyncFunctionPointer);
     default:
       return nullptr;
   }
diff --git a/lib/Demangling/NodePrinter.cpp b/lib/Demangling/NodePrinter.cpp
@@ -564,6 +564,7 @@ class NodePrinter {
     case Node::Kind::GlobalVariableOnceFunction:
     case Node::Kind::GlobalVariableOnceToken:
     case Node::Kind::CanonicalPrespecializedGenericTypeCachingOnceToken:
+    case Node::Kind::AsyncFunctionPointer:
       return false;
     }
     printer_unreachable("bad node kind");
@@ -2552,6 +2553,9 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
                "metadata for ";
     print(Node->getChild(0));
     return nullptr;
+  case Node::Kind::AsyncFunctionPointer:
+    Printer << "async function pointer to ";
+    return nullptr;
   }
   printer_unreachable("bad node kind!");
 }
diff --git a/lib/Demangling/OldRemangler.cpp b/lib/Demangling/OldRemangler.cpp
@@ -816,6 +816,10 @@ void Remangler::mangleDefaultArgumentInitializer(Node *node,
   mangleNamedEntity(node, 'I', "A", ctx);
 }
 
+void Remangler::mangleAsyncFunctionPointer(Node *node) {
+  Buffer << "Tu";
+}
+
 void Remangler::mangleDeallocator(Node *node, EntityContext &ctx) {
   mangleSimpleEntity(node, 'F', "D", ctx);
 }
diff --git a/lib/Demangling/Remangler.cpp b/lib/Demangling/Remangler.cpp
@@ -837,6 +837,10 @@ void Remangler::mangleDefaultArgumentInitializer(Node *node) {
   mangleChildNode(node, 1);
 }
 
+void Remangler::mangleAsyncFunctionPointer(Node *node) {
+  Buffer << "Tu";
+}
+
 void Remangler::mangleDependentAssociatedTypeRef(Node *node) {
   mangleIdentifier(node->getFirstChild());
   if (node->getNumChildren() > 1)
@@ -1384,6 +1388,7 @@ void Remangler::mangleGlobal(Node *node) {
       case Node::Kind::DynamicallyReplaceableFunctionKey:
       case Node::Kind::DynamicallyReplaceableFunctionImpl:
       case Node::Kind::DynamicallyReplaceableFunctionVar:
+      case Node::Kind::AsyncFunctionPointer:
         mangleInReverseOrder = true;
         break;
       default:
diff --git a/lib/IRGen/Linking.cpp b/lib/IRGen/Linking.cpp
@@ -432,13 +432,13 @@ std::string LinkEntity::mangleAsString() const {
          getSILDifferentiabilityWitness()->getConfig()});
   case Kind::AsyncFunctionPointer: {
     std::string Result(getSILFunction()->getName());
-    Result.append("AD");
+    Result.append("Tu");
     return Result;
   }
   case Kind::AsyncFunctionPointerAST: {
     std::string Result;
     Result = mangler.mangleEntity(getDecl());
-    Result.append("AD");
+    Result.append("Tu");
     return Result;
   }
   }
diff --git a/test/Demangle/Inputs/manglings.txt b/test/Demangle/Inputs/manglings.txt
@@ -371,3 +371,4 @@ $s7example1fyyYF -> example.f() async -> ()
 $s7example1fyyYKF -> example.f() async throws -> ()
 $s4main20receiveInstantiationyySo34__CxxTemplateInst12MagicWrapperIiEVzF ---> main.receiveInstantiation(inout __C.__CxxTemplateInst12MagicWrapperIiE) -> ()
 $s4main19returnInstantiationSo34__CxxTemplateInst12MagicWrapperIiEVyF ---> main.returnInstantiation() -> __C.__CxxTemplateInst12MagicWrapperIiE
+$s4main6testityyYFTu ---> async function pointer to main.testit() async -> ()
diff --git a/test/IRGen/async/run-call-classinstance-int64-to-void.sil b/test/IRGen/async/run-call-classinstance-int64-to-void.sil
@@ -29,7 +29,7 @@ class S {
   init()
 }
 
-// CHECK-LL: @classinstanceSInt64ToVoidAD =
+// CHECK-LL: @classinstanceSInt64ToVoidTu =
 // CHECK-LL: define hidden swiftcc void @classinstanceSInt64ToVoid(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]+}} {
 sil hidden @classinstanceSInt64ToVoid : $@async @convention(method) (Int64, @guaranteed S) -> () {
 bb0(%int : $Int64, %instance : $S):
diff --git a/test/IRGen/async/run-call-classinstance-void-to-void.sil b/test/IRGen/async/run-call-classinstance-void-to-void.sil
@@ -29,7 +29,7 @@ class S {
   init()
 }
 
-// CHECK-LL: @classinstanceSVoidToVoidAD =
+// CHECK-LL: @classinstanceSVoidToVoidTu =
 // CHECK-LL: define hidden swiftcc void @classinstanceSVoidToVoid(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]*}} {
 sil hidden @classinstanceSVoidToVoid : $@async @convention(method) (@guaranteed S) -> () {
 bb0(%instance : $S):
diff --git a/test/IRGen/async/run-call-existential-to-void.sil b/test/IRGen/async/run-call-existential-to-void.sil
@@ -37,7 +37,7 @@ bb0(%int : $Int64, %S_type : $@thin S.Type):
   return %instance : $S
 }
 
-// CHECK-LL: @existentialToVoidAD =
+// CHECK-LL: @existentialToVoidTu =
 // CHECK-LL: define hidden swiftcc void @existentialToVoid(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]*}} {
 sil hidden @existentialToVoid : $@async @convention(thin) (@in_guaranteed P) -> () {
 bb0(%existential : $*P):
diff --git a/test/IRGen/async/run-call-generic-to-generic.sil b/test/IRGen/async/run-call-generic-to-generic.sil
@@ -19,7 +19,7 @@ import _Concurrency
 
 sil public_external @printInt64 : $@convention(thin) (Int64) -> ()
 
-// CHECK-LL: @genericToGenericAD =
+// CHECK-LL: @genericToGenericTu =
 // CHECK-LL: define hidden swiftcc void @genericToGeneric(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]*}} {
 sil hidden @genericToGeneric : $@async @convention(thin) <T> (@in_guaranteed T) -> @out T {
 bb0(%out : $*T, %in : $*T):
diff --git a/test/IRGen/async/run-call-generic-to-void.sil b/test/IRGen/async/run-call-generic-to-void.sil
@@ -19,7 +19,7 @@ import _Concurrency
 
 sil public_external @printGeneric : $@convention(thin) <T> (@in_guaranteed T) -> ()
 
-// CHECK-LL: @genericToVoidAD =
+// CHECK-LL: @genericToVoidTu =
 // CHECK-LL: define hidden swiftcc void @genericToVoid(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]*}} {
 sil hidden @genericToVoid : $@async @convention(thin) <T> (@in_guaranteed T) -> () {
 bb0(%instance : $*T):
diff --git a/test/IRGen/async/run-call-genericEquatable-x2-to-bool.sil b/test/IRGen/async/run-call-genericEquatable-x2-to-bool.sil
@@ -19,7 +19,7 @@ import _Concurrency
 
 sil public_external @printBool : $@convention(thin) (Bool) -> ()
 
-// CHECK-LL: @genericEquatableAndGenericEquatableToBoolAD =
+// CHECK-LL: @genericEquatableAndGenericEquatableToBoolTu =
 // CHECK-LL: define hidden swiftcc void @genericEquatableAndGenericEquatableToBool(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]*}} {
 sil hidden @genericEquatableAndGenericEquatableToBool : $@async @convention(thin) <T where T : Equatable> (@in_guaranteed T, @in_guaranteed T) -> Bool {
 bb0(%0 : $*T, %1 : $*T):
diff --git a/test/IRGen/async/run-call-int64-and-int64-to-void.sil b/test/IRGen/async/run-call-int64-and-int64-to-void.sil
@@ -19,7 +19,7 @@ import _Concurrency
 
 sil public_external @printInt64 : $@convention(thin) (Int64) -> ()
 
-// CHECK-LL: @int64AndInt64ToVoidAD =
+// CHECK-LL: @int64AndInt64ToVoidTu =
 // CHECK-LL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @int64AndInt64ToVoid(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]*}} {
 sil @int64AndInt64ToVoid : $@async @convention(thin) (Int64, Int64) -> () {
 entry(%int1: $Int64, %int2: $Int64):
diff --git a/test/IRGen/async/run-call-int64-to-void.sil b/test/IRGen/async/run-call-int64-to-void.sil
@@ -19,7 +19,7 @@ import _Concurrency
 
 sil public_external @printInt64 : $@convention(thin) (Int64) -> ()
 
-// CHECK-LL: @int64ToVoidAD =
+// CHECK-LL: @int64ToVoidTu =
 // CHECK-LL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @int64ToVoid(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]*}} {
 sil @int64ToVoid : $@async @convention(thin) (Int64) -> () {
 entry(%int: $Int64):
diff --git a/test/IRGen/async/run-call-protocolextension_instance-void-to-int64.sil b/test/IRGen/async/run-call-protocolextension_instance-void-to-int64.sil
@@ -33,7 +33,7 @@ struct I : P {
   init(int: Int64)
 }
 
-// CHECK-LL: @callPrintMeAD =
+// CHECK-LL: @callPrintMeTu =
 // CHECK-LL: define hidden swiftcc void @callPrintMe(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]*}} {
 sil hidden @callPrintMe : $@async @convention(method) <Self where Self : P> (@in_guaranteed Self) -> Int64 {
 bb0(%self : $*Self):
diff --git a/test/IRGen/async/run-call-protocolwitness_instance-void-to-int64.sil b/test/IRGen/async/run-call-protocolwitness_instance-void-to-int64.sil
@@ -29,7 +29,7 @@ struct I : P {
   init(int: Int64)
 }
 
-// CHECK-LL: @I_printMeAD =
+// CHECK-LL: @I_printMeTu =
 // CHECK-LL-LABEL: define hidden swiftcc void @I_printMe(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]*}} {
 sil hidden @I_printMe : $@async @convention(method) (I) -> Int64 {
 bb0(%self : $I):
diff --git a/test/IRGen/async/run-call-struct_five_bools-to-void.sil b/test/IRGen/async/run-call-struct_five_bools-to-void.sil
@@ -27,7 +27,7 @@ struct Pack {
   public let e: Bool
 }
 
-// CHECK-LL: @test_caseAD =
+// CHECK-LL: @test_caseTu =
 
 sil @structPackToVoid : $@async @convention(thin) (Pack) -> () {
 entry(%pack : $Pack):
diff --git a/test/IRGen/async/run-call-structinstance-int64-to-void.sil b/test/IRGen/async/run-call-structinstance-int64-to-void.sil
@@ -25,7 +25,7 @@ struct S {
   init(storage: Int64)
 }
 
-// CHECK-LL: @structinstanceSInt64ToVoidAD =
+// CHECK-LL: @structinstanceSInt64ToVoidTu =
 // CHECK-LL: define hidden swiftcc void @structinstanceSInt64ToVoid(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]*}} {
 sil hidden @structinstanceSInt64ToVoid : $@async @convention(method) (Int64, S) -> () {
 bb0(%int : $Int64, %self : $S):
diff --git a/test/IRGen/async/run-call-void-throws-to-int-throwing.sil b/test/IRGen/async/run-call-void-throws-to-int-throwing.sil
@@ -99,7 +99,7 @@ bb5:
   br bb2
 }
 
-// CHECK-LL: @voidThrowsToIntAD =
+// CHECK-LL: @voidThrowsToIntTu =
 // CHECK-LL: define hidden swiftcc void @voidThrowsToInt(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]*}} {
 sil hidden @voidThrowsToInt : $@async @convention(thin) () -> (Int, @error Error) {
 bb0:
diff --git a/test/IRGen/async/run-call-void-throws-to-int-throwing_call-async-nothrow_call-sync-throw.sil b/test/IRGen/async/run-call-void-throws-to-int-throwing_call-async-nothrow_call-sync-throw.sil
@@ -98,7 +98,7 @@ bb5:
   br bb2
 }
 
-// CHECK-LL: @voidThrowsToIntAD =
+// CHECK-LL: @voidThrowsToIntTu =
 // CHECK-LL: define hidden swiftcc void @voidThrowsToInt(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]*}} {
 sil hidden @voidThrowsToInt : $@async @convention(thin) () -> (Int64, @error Error) {
 entry:
diff --git a/test/IRGen/async/run-call-void-throws-to-int-throwing_call-async-throw.sil b/test/IRGen/async/run-call-void-throws-to-int-throwing_call-async-throw.sil
@@ -99,7 +99,7 @@ bb5:
   br bb2
 }
 
-// CHECK-LL: @voidThrowsToIntAD =
+// CHECK-LL: @voidThrowsToIntTu =
 // CHECK-LL: define hidden swiftcc void @voidThrowsToInt(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]*}} {
 sil hidden @voidThrowsToInt : $@async @convention(thin) () -> (Int, @error Error) {
 bb0:
diff --git a/test/IRGen/async/run-call-void-throws-to-int-throwing_call-sync-nothrow_call-async-throw.sil b/test/IRGen/async/run-call-void-throws-to-int-throwing_call-sync-nothrow_call-async-throw.sil
@@ -99,7 +99,7 @@ bb5:
   br bb2
 }
 
-// CHECK-LL: @voidThrowsToIntAD =
+// CHECK-LL: @voidThrowsToIntTu =
 // CHECK-LL: define hidden swiftcc void @voidThrowsToInt(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]*}} {
 sil hidden @voidThrowsToInt : $@async @convention(thin) () -> (Int64, @error Error) {
 entry:
diff --git a/test/IRGen/async/run-call-void-throws-to-int-throwing_call-sync-throw.sil b/test/IRGen/async/run-call-void-throws-to-int-throwing_call-sync-throw.sil
@@ -100,7 +100,7 @@ bb5:
   br bb2
 }
 
-// CHECK-LL: @voidThrowsToIntAD =
+// CHECK-LL: @voidThrowsToIntTu =
 // CHECK-LL: define hidden swiftcc void @voidThrowsToInt(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]*}} {
 sil hidden @voidThrowsToInt : $@async @convention(thin) () -> (Int, @error Error) {
 bb0:
diff --git a/test/IRGen/async/run-call-void-to-existential.sil b/test/IRGen/async/run-call-void-to-existential.sil
@@ -36,7 +36,7 @@ bb0(%int : $Int64, %S_type : $@thin S.Type):
   return %instance : $S
 }
 
-// CHECK-LL: @voidToExistentialAD =
+// CHECK-LL: @voidToExistentialTu =
 // CHECK-LL: define hidden swiftcc void @voidToExistential(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]*}} {
 sil hidden @voidToExistential : $@async @convention(thin) () -> @out P {
 bb0(%out : $*P):
diff --git a/test/IRGen/async/run-call-void-to-int64-and-int64.sil b/test/IRGen/async/run-call-void-to-int64-and-int64.sil
@@ -19,7 +19,7 @@ import _Concurrency
 
 sil public_external @printInt64 : $@convention(thin) (Int64) -> ()
 
-// CHECK-LL: @voidToInt64AndInt64AD =
+// CHECK-LL: @voidToInt64AndInt64Tu =
 // CHECK-LL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @voidToInt64AndInt64(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]*}} {
 sil @voidToInt64AndInt64 : $@async @convention(thin) () -> (Int64, Int64) {
   %int_literal1 = integer_literal $Builtin.Int64, 42
diff --git a/test/IRGen/async/run-call-void-to-int64.sil b/test/IRGen/async/run-call-void-to-int64.sil
@@ -19,7 +19,7 @@ import _Concurrency
 
 sil public_external @printInt64 : $@convention(thin) (Int64) -> ()
 
-// CHECK-LL: @voidToInt64AD =
+// CHECK-LL: @voidToInt64Tu =
 // CHECK-LL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @voidToInt64(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]*}} {
 sil @voidToInt64 : $@async @convention(thin) () -> (Int64) {
   %int_literal = integer_literal $Builtin.Int64, 42
diff --git a/test/IRGen/async/run-call-void-to-struct_large.sil b/test/IRGen/async/run-call-void-to-struct_large.sil
@@ -101,7 +101,7 @@ bb0(%0 : $@thin Big.Type):
   return %62 : $Big
 }
 
-// CHECK-LL: @getBigAD =
+// CHECK-LL: @getBigTu =
 // CHECK-LL: define hidden swiftcc void @getBig(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]*}} {
 sil hidden @getBig : $@async @convention(thin) () -> Big {
 bb0:
diff --git a/test/IRGen/async/run-call_generic-protocolwitness_instance-generic-to-int64-and-generic.sil b/test/IRGen/async/run-call_generic-protocolwitness_instance-generic-to-int64-and-generic.sil
@@ -45,7 +45,7 @@ bb0(%out_addr : $*T, %in_addr : $*T, %self : $I):
   return %value : $Int64
 }
 
-// CHECK-LL: @I_P_printMeAD =
+// CHECK-LL: @I_P_printMeTu =
 // CHECK-LL: define internal swiftcc void @I_P_printMe(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]*}} {
 sil private [transparent] [thunk] @I_P_printMe : $@convention(witness_method: P) @async <τ_0_0> (@in_guaranteed τ_0_0, @in_guaranteed I) -> (Int64, @out τ_0_0) {
 bb0(%out_addr : $*τ_0_0, %in_addr : $*τ_0_0, %self_addr : $*I):
diff --git a/test/IRGen/async/run-call_generic-protocolwitness_instance-void-to-int64.sil b/test/IRGen/async/run-call_generic-protocolwitness_instance-void-to-int64.sil
@@ -29,8 +29,8 @@ struct I : P {
   init(int: Int64)
 }
 
-// CHECK-LL: @I_printMeAD =
-// CHECK-LL: @I_P_printMeAD =
+// CHECK-LL: @I_printMeTu =
+// CHECK-LL: @I_P_printMeTu =
 
 // CHECK-LL-LABEL: define hidden swiftcc void @I_printMe(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]*}} {
 sil hidden @I_printMe : $@async @convention(method) (I) -> Int64 {
diff --git a/test/IRGen/async/run-partialapply-capture-class-to-void.sil b/test/IRGen/async/run-partialapply-capture-class-to-void.sil
@@ -57,7 +57,7 @@ sil_vtable S {
   #S.deinit!deallocator: @S_deallocating_deinit
 }
 
-// CHECK-LL: @classinstanceSToVoidAD =
+// CHECK-LL: @classinstanceSToVoidTu =
 // CHECK-LL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @classinstanceSToVoid(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]*}} {
 sil @classinstanceSToVoid : $@async @convention(thin) (@owned S) -> () {
 entry(%c : $S):
diff --git a/test/IRGen/async/run-partialapply-capture-inout-generic-and-in-generic-to-generic.sil b/test/IRGen/async/run-partialapply-capture-inout-generic-and-in-generic-to-generic.sil
@@ -19,7 +19,7 @@ import _Concurrency
 sil public_external @printGeneric : $@convention(thin) <T> (@in_guaranteed T) -> ()
 sil public_external @printInt64 : $@convention(thin) (Int64) -> ()
 
-// CHECK-LL: @inGenericAndInoutGenericToGenericAD =
+// CHECK-LL: @inGenericAndInoutGenericToGenericTu =
 // CHECK-LL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @inGenericAndInoutGenericToGeneric(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]*}} {
 // CHECK-LL: define internal swiftcc void @"$s017inGenericAndInoutb2ToB0TA"(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]*}} {
 sil @inGenericAndInoutGenericToGeneric : $@async @convention(thin) <T> (@in T, @inout T) -> @out T {
diff --git a/test/IRGen/async/run-partialapply-capture-int64-int64-throws-to-int64.sil b/test/IRGen/async/run-partialapply-capture-int64-int64-throws-to-int64.sil
@@ -45,7 +45,7 @@ exit:
   return %out : $()
 }
 
-// CHECK-LL: @closureAD =
+// CHECK-LL: @closureTu =
 // CHECK-LL: define internal swiftcc void @closure(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]*}}
 // CHECK-LL: define internal swiftcc void @"$s7closureTA"(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]*}}
 sil hidden @createPartialApply : $@async @convention(thin) (Int64) -> @owned @async @callee_guaranteed (Int64) -> (Int64, @error Error) {
diff --git a/test/IRGen/async/run-partialapply-capture-int64-int64-to-int64.sil b/test/IRGen/async/run-partialapply-capture-int64-int64-to-int64.sil
@@ -36,7 +36,7 @@ bb0:
   return %result : $()
 }
 
-// CHECK-LL: @closureAD =
+// CHECK-LL: @closureTu =
 // CHECK-LL: define internal swiftcc void @closure(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]*}}
 // CHECK-LL: define internal swiftcc void @"$s7closureTA"(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]*}}
 sil hidden @createPartialApply : $@async @convention(thin) (Int64) -> @owned @async @callee_guaranteed (Int64) -> Int64 {
diff --git a/test/IRGen/async/run-partialapply-capture-struct_classinstance_classinstance-and-int64-to-int64.sil b/test/IRGen/async/run-partialapply-capture-struct_classinstance_classinstance-and-int64-to-int64.sil
@@ -61,7 +61,7 @@ sil_vtable C {
 
 struct S { var x: C, y: C }
 
-// CHECK-LL: @structClassInstanceClassInstanceAndInt64ToInt64AD =
+// CHECK-LL: @structClassInstanceClassInstanceAndInt64ToInt64Tu =
 // CHECK-LL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @structClassInstanceClassInstanceAndInt64ToInt64(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]*}} {
 // CHECK-LL: define internal swiftcc void @"$s019structClassInstancebc10AndInt64ToE0TA"(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]*}} {
 sil @structClassInstanceClassInstanceAndInt64ToInt64 : $@async @convention(thin) (Int64, @guaranteed S) -> Int64 {
diff --git a/test/IRGen/async/run-partialapply-capture-structgeneric_classinstance_to_struct_and_error.sil b/test/IRGen/async/run-partialapply-capture-structgeneric_classinstance_to_struct_and_error.sil
@@ -39,8 +39,8 @@ entry(%value : $A2<A3>):
   return %result : $()
 }
 
-// CHECK-LL: @amethodAD =
-// CHECK-LL: @repoAD =
+// CHECK-LL: @amethodTu =
+// CHECK-LL: @repoTu =
 
 // CHECK-LL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @amethod(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]*}} {
 sil @amethod : $@async @convention(method) (@in_guaranteed A2<A3>) -> (@owned A1, @error Error) {
diff --git a/test/IRGen/async/run-partialapply-capture-type_structgeneric_polymorphic_constrained-to-void.sil b/test/IRGen/async/run-partialapply-capture-type_structgeneric_polymorphic_constrained-to-void.sil
@@ -32,7 +32,7 @@ sil_witness_table <T> BaseProducer<T> : Q module main {
 public class WeakBox<T> {}
 sil_vtable WeakBox {}
 
-// CHECK-LL: @takingQAD =
+// CHECK-LL: @takingQTu =
 // CHECK-LL: define hidden swiftcc void @takingQ(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]*}} {
 sil hidden @takingQ : $@async @convention(thin) <τ_0_0 where  τ_0_0 : Q> (@owned WeakBox<τ_0_0>) -> () {
 entry(%box : $WeakBox<τ_0_0>):
diff --git a/test/TBD/async-function-pointer.swift b/test/TBD/async-function-pointer.swift
@@ -1,7 +1,7 @@
 // REQUIRES: VENDOR=apple 
 // RUN: %target-swift-frontend -emit-ir %s -enable-experimental-concurrency -validate-tbd-against-ir=all -module-name test | %FileCheck %s
 
-// CHECK: @"$s4test6testityyYFAD" = hidden global %swift.async_func_pointer
+// CHECK: @"$s4test6testityyYFTu" = hidden global %swift.async_func_pointer
 
 @asyncHandler
 public func testit() { }

Original file line number	Diff line number	Diff line change
`@@ -564,6 +564,7 @@ class NodePrinter {`
`564`	`564`	`case Node::Kind::GlobalVariableOnceFunction:`
`565`	`565`	`case Node::Kind::GlobalVariableOnceToken:`
`566`	`566`	`case Node::Kind::CanonicalPrespecializedGenericTypeCachingOnceToken:`
	`567`	`+ case Node::Kind::AsyncFunctionPointer:`
`567`	`568`	`return false;`
`568`	`569`	`}`
`569`	`570`	`printer_unreachable("bad node kind");`
`@@ -2552,6 +2553,9 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {`
`2552`	`2553`	`"metadata for ";`
`2553`	`2554`	`print(Node->getChild(0));`
`2554`	`2555`	`return nullptr;`
	`2556`	`+ case Node::Kind::AsyncFunctionPointer:`
	`2557`	`+ Printer << "async function pointer to ";`
	`2558`	`+ return nullptr;`
`2555`	`2559`	`}`
`2556`	`2560`	`printer_unreachable("bad node kind!");`
`2557`	`2561`	`}`
Original file line number	Diff line number	Diff line change
`@@ -816,6 +816,10 @@ void Remangler::mangleDefaultArgumentInitializer(Node *node,`
`816`	`816`	`mangleNamedEntity(node, 'I', "A", ctx);`
`817`	`817`	`}`
`818`	`818`
	`819`	`+void Remangler::mangleAsyncFunctionPointer(Node *node) {`
	`820`	`+ Buffer << "Tu";`
	`821`	`+}`
	`822`	`+`
`819`	`823`	`void Remangler::mangleDeallocator(Node *node, EntityContext &ctx) {`
`820`	`824`	`mangleSimpleEntity(node, 'F', "D", ctx);`
`821`	`825`	`}`
Original file line number	Diff line number	Diff line change
`@@ -432,13 +432,13 @@ std::string LinkEntity::mangleAsString() const {`
`432`	`432`	`getSILDifferentiabilityWitness()->getConfig()});`
`433`	`433`	`case Kind::AsyncFunctionPointer: {`
`434`	`434`	`std::string Result(getSILFunction()->getName());`
`435`		`- Result.append("AD");`
	`435`	`+ Result.append("Tu");`
`436`	`436`	`return Result;`
`437`	`437`	`}`
`438`	`438`	`case Kind::AsyncFunctionPointerAST: {`
`439`	`439`	`std::string Result;`
`440`	`440`	`Result = mangler.mangleEntity(getDecl());`
`441`		`- Result.append("AD");`
	`441`	`+ Result.append("Tu");`
`442`	`442`	`return Result;`
`443`	`443`	`}`
`444`	`444`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ class S {`
`29`	`29`	`init()`
`30`	`30`	`}`
`31`	`31`
`32`		`-// CHECK-LL: @classinstanceSInt64ToVoidAD =`
	`32`	`+// CHECK-LL: @classinstanceSInt64ToVoidTu =`
`33`	`33`	`// CHECK-LL: define hidden swiftcc void @classinstanceSInt64ToVoid(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]+}} {`
`34`	`34`	`sil hidden @classinstanceSInt64ToVoid : $@async @convention(method) (Int64, @guaranteed S) -> () {`
`35`	`35`	`bb0(%int : $Int64, %instance : $S):`