Mangling: Use 'Tw' to mangle back deployment thunks.

Author: tshortli

docs/ABI/Mangling.rst

@@ -223,6 +223,7 @@ types where the metadata itself has unknown layout.)
   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 ::= global 'Tw'                 // back deployment thunk
   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.
   global ::= type 'TC'                   // continuation prototype (not actually used for real symbols)

include/swift/AST/ASTMangler.h

@@ -105,7 +105,8 @@ class ASTMangler : public Mangler {
     ObjCAsSwiftThunk,
     DistributedThunk,
     DistributedAccessor,
-    AccessibleFunctionRecord
+    AccessibleFunctionRecord,
+    BackDeployedThunk,
   };
 
   ASTMangler(bool DWARFMangling = false)

include/swift/Demangling/DemangleNodes.def

@@ -332,6 +332,7 @@ NODE(CompileTimeConst)
 
 // Added in Swift 5.7
 NODE(OpaqueReturnTypeIndexed)
+NODE(BackDeployed)
 
 #undef CONTEXT_NODE
 #undef NODE

lib/AST/ASTMangler.cpp

@@ -857,6 +857,9 @@ void ASTMangler::appendSymbolKind(SymbolKind SKind) {
     case SymbolKind::DistributedThunk: return appendOperator("TE");
     case SymbolKind::DistributedAccessor: return appendOperator("TF");
     case SymbolKind::AccessibleFunctionRecord: return appendOperator("HF");
+    // FIXME(backDeploy): Check whether mangling needs to be extended since
+    // the available thunk mangling names are almost exhausted.
+    case SymbolKind::BackDeployedThunk: return appendOperator("Tw");
   }
 }
 

lib/Demangling/Demangler.cpp

@@ -2395,6 +2395,7 @@ NodePointer Demangler::demangleThunkOrSpecialization() {
     case 'X': return createNode(Node::Kind::DynamicallyReplaceableFunctionVar);
     case 'x': return createNode(Node::Kind::DynamicallyReplaceableFunctionKey);
     case 'I': return createNode(Node::Kind::DynamicallyReplaceableFunctionImpl);
+    case 'w': return createNode(Node::Kind::BackDeployed);
     case 'Y':
     case 'Q': {
       NodePointer discriminator = demangleIndexAsNode();

lib/Demangling/NodePrinter.cpp

@@ -591,6 +591,7 @@ class NodePrinter {
     case Node::Kind::AsyncAwaitResumePartialFunction:
     case Node::Kind::AsyncSuspendResumePartialFunction:
     case Node::Kind::AccessibleFunctionRecord:
+    case Node::Kind::BackDeployed:
       return false;
     }
     printer_unreachable("bad node kind");
@@ -2050,6 +2051,11 @@ NodePointer NodePrinter::print(NodePointer Node, unsigned depth,
       Printer << "dynamically replaceable variable for ";
     }
     return nullptr;
+  case Node::Kind::BackDeployed:
+    if (!Options.ShortenThunk) {
+      Printer << "back deployment thunk for ";
+    }
+    return nullptr;
   case Node::Kind::ProtocolSymbolicReference:
     Printer << "protocol symbolic reference 0x";
     Printer.writeHex(Node->getIndex());

lib/Demangling/OldRemangler.cpp

@@ -2800,3 +2800,8 @@ ManglingError Remangler::mangleAccessibleFunctionRecord(Node *node,
   Buffer << "HF";
   return ManglingError::Success;
 }
+
+ManglingError Remangler::mangleBackDeployed(Node *node, unsigned depth) {
+  Buffer << "Tw";
+  return ManglingError::Success;
+}

lib/Demangling/Remangler.cpp

@@ -3407,6 +3407,11 @@ ManglingError Remangler::mangleAccessibleFunctionRecord(Node *node,
   return ManglingError::Success;
 }
 
+ManglingError Remangler::mangleBackDeployed(Node *node, unsigned depth) {
+  Buffer << "Tw";
+  return ManglingError::Success;
+}
+
 } // anonymous namespace
 
 /// The top-level interface to the remangler.

lib/SIL/IR/SILDeclRef.cpp

@@ -874,6 +874,8 @@ std::string SILDeclRef::mangle(ManglingKind MKind) const {
         SKind = ASTMangler::SymbolKind::ObjCAsSwiftThunk;
       } else if (isDistributedThunk()) {
         SKind = ASTMangler::SymbolKind::DistributedThunk;
+      } else if (isBackDeployedThunk()) {
+        SKind = ASTMangler::SymbolKind::BackDeployedThunk;
       }
       break;
     case SILDeclRef::ManglingKind::DynamicThunk: