Merge pull request swiftlang#77115 from kubamracek/embedded-mangling-prefix

[Mangling] [NFC] Prepare for a new mangling prefix for Embedded Swift: $e

Author: kubamracek

docs/ABI/Mangling.rst

@@ -12,6 +12,7 @@ Mangling
   mangled-name ::= '@__swiftmacro_' global // Swift mangling for filenames
   mangled-name ::= '_T0' global // Swift 4.0
   mangled-name ::= '$S' global  // Swift 4.2
+  mangled-name ::= '$e' global  // Embedded Swift (unstable)
 
 All Swift-mangled names begin with a common prefix. Since Swift 4.0, the
 compiler has used variations of the mangling described in this document, though

docs/EmbeddedSwift/ABI.md

@@ -12,6 +12,10 @@ The ABI of code generated by Embedded Swift is not currently stable. For a concr
 
 Similarly, do not mix Embedded Swift code with full Swift code, as the ABIs are different. Details are described in the following sections.
 
+## Symbol mangling under Embedded Swift
+
+Since Swift 5.0, the stable ABI mangling schema uses the `$s` prefix on all Swift symbols. Because Embedded Swift's ABI differs from the stable ABI, and furthermore because it's not expected to be stable, Embedded Swift uses a `$e` mangling prefix. The logic and structure of the mangling stays the same, the only difference is the prefix.
+
 ## Calling convention of Embedded Swift
 
 As of today, Embedded Swift has identical calling convention to full Swift. However, this does not need to continue in the future, and there should not be expectations that the ABI of Embedded Swift is compatible with full Swift.

include/swift/AST/ASTDemangler.h

@@ -22,6 +22,7 @@
 #ifndef SWIFT_AST_ASTDEMANGLER_H
 #define SWIFT_AST_ASTDEMANGLER_H
 
+#include "swift/AST/ASTContext.h"
 #include "swift/AST/Types.h"
 #include "swift/Demangling/Demangler.h"
 #include "swift/Demangling/NamespaceMacros.h"
@@ -53,6 +54,7 @@ TypeDecl *getTypeDeclForUSR(ASTContext &ctx,
 /// just finds and builds things in the AST.
 class ASTBuilder {
   ASTContext &Ctx;
+  Mangle::ManglingFlavor ManglingFlavor;
   Demangle::NodeFactory Factory;
 
   /// The notional context in which we're writing and type-checking code.
@@ -97,8 +99,11 @@ class ASTBuilder {
 
   static constexpr bool needsToPrecomputeParentGenericContextShapes = false;
 
-  explicit ASTBuilder(ASTContext &ctx, GenericSignature genericSig)
-    : Ctx(ctx) {
+  explicit ASTBuilder(ASTContext &ctx, GenericSignature genericSig) : Ctx(ctx) {
+    ManglingFlavor = ctx.LangOpts.hasFeature(Feature::Embedded)
+                 ? Mangle::ManglingFlavor::Embedded
+                 : Mangle::ManglingFlavor::Default;
+
     for (auto *paramTy : genericSig.getGenericParams()) {
       if (paramTy->isParameterPack())
         ParameterPacks.emplace_back(paramTy->getDepth(), paramTy->getIndex());
@@ -112,6 +117,7 @@ class ASTBuilder {
   }
 
   ASTContext &getASTContext() { return Ctx; }
+  Mangle::ManglingFlavor getManglingFlavor() { return ManglingFlavor; }
   DeclContext *getNotionalDC();
 
   Demangle::NodeFactory &getNodeFactory() { return Factory; }

include/swift/AST/ASTMangler.h

@@ -13,6 +13,7 @@
 #ifndef SWIFT_AST_ASTMANGLER_H
 #define SWIFT_AST_ASTMANGLER_H
 
+#include "swift/AST/ASTContext.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/FreestandingMacroExpansion.h"
 #include "swift/AST/SILThunkKind.h"
@@ -44,6 +45,9 @@ enum class DestructorKind {
 /// The mangler for AST declarations.
 class ASTMangler : public Mangler {
 protected:
+#if 0 // STAGING
+  const ASTContext &Context;
+#endif
   ModuleDecl *Mod = nullptr;
 
   /// Optimize out protocol names if a type only conforms to one protocol.
@@ -185,6 +189,7 @@ class ASTMangler : public Mangler {
     HasSymbolQuery,
   };
 
+  // STAGING: legacy constructor for LLDB
   /// lldb overrides the defaulted argument to 'true'.
   ASTMangler(bool DWARFMangling = false) {
     if (DWARFMangling) {
@@ -193,6 +198,24 @@ class ASTMangler : public Mangler {
     }
   }
 
+  /// lldb overrides the defaulted argument to 'true'.
+  ASTMangler(const ASTContext &Ctx, bool DWARFMangling = false) : ASTMangler(DWARFMangling) {}
+
+#if 0
+  /// lldb overrides the defaulted argument to 'true'.
+  ASTMangler(const ASTContext &Ctx, bool DWARFMangling = false) : Context(Ctx) {
+    if (DWARFMangling) {
+      DWARFMangling = true;
+      RespectOriginallyDefinedIn = false;
+    }
+    Flavor = Ctx.LangOpts.hasFeature(Feature::Embedded)
+                 ? ManglingFlavor::Embedded
+                 : ManglingFlavor::Default;
+  }
+
+  const ASTContext &getASTContext() { return Context; }
+#endif
+
   void addTypeSubstitution(Type type, GenericSignature sig) {
     type = dropProtocolsFromAssociatedTypes(type, sig);
     addSubstitution(type.getPointer());

include/swift/Basic/Mangler.h

@@ -13,6 +13,7 @@
 #ifndef SWIFT_BASIC_MANGLER_H
 #define SWIFT_BASIC_MANGLER_H
 
+#include "swift/Demangling/ManglingFlavor.h"
 #include "swift/Demangling/ManglingUtils.h"
 #include "swift/Demangling/NamespaceMacros.h"
 #include "swift/Basic/Debug.h"
@@ -70,6 +71,8 @@ class Mangler {
 
   size_t MaxNumWords = 26;
 
+  ManglingFlavor Flavor = ManglingFlavor::Default;
+
   /// If enabled, non-ASCII names are encoded in modified Punycode.
   bool UsePunycode = true;
 
@@ -135,7 +138,7 @@ class Mangler {
   void finalize(llvm::raw_ostream &stream);
 
   /// Verify that demangling and remangling works.
-  static void verify(StringRef mangledName);
+  static void verify(StringRef mangledName, ManglingFlavor Flavor);
 
   SWIFT_DEBUG_DUMP;
 

include/swift/Demangling/Demangle.h

@@ -20,6 +20,7 @@
 #define SWIFT_DEMANGLING_DEMANGLE_H
 
 #include "swift/Demangling/Errors.h"
+#include "swift/Demangling/ManglingFlavor.h"
 #include "swift/Demangling/NamespaceMacros.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Compiler.h"
@@ -673,24 +674,27 @@ class [[nodiscard]] ManglingErrorOr {
 };
 
 /// Remangle a demangled parse tree.
-ManglingErrorOr<std::string> mangleNode(NodePointer root);
+ManglingErrorOr<std::string>
+mangleNode(NodePointer root,
+           Mangle::ManglingFlavor Flavor = Mangle::ManglingFlavor::Default);
 
-using SymbolicResolver =
-  llvm::function_ref<Demangle::NodePointer (SymbolicReferenceKind,
-                                            const void *)>;
+using SymbolicResolver = llvm::function_ref<Demangle::NodePointer(
+    SymbolicReferenceKind, const void *)>;
 
 /// Remangle a demangled parse tree, using a callback to resolve
 /// symbolic references.
-ManglingErrorOr<std::string> mangleNode(NodePointer root, SymbolicResolver resolver);
+ManglingErrorOr<std::string>
+mangleNode(NodePointer root, SymbolicResolver resolver,
+           Mangle::ManglingFlavor Flavor = Mangle::ManglingFlavor::Default);
 
 /// Remangle a demangled parse tree, using a callback to resolve
 /// symbolic references.
 ///
 /// The returned string is owned by \p Factory. This means \p Factory must stay
 /// alive as long as the returned string is used.
-ManglingErrorOr<llvm::StringRef> mangleNode(NodePointer root,
-                                            SymbolicResolver resolver,
-                                            NodeFactory &Factory);
+ManglingErrorOr<llvm::StringRef>
+mangleNode(NodePointer root, SymbolicResolver resolver, NodeFactory &Factory,
+           Mangle::ManglingFlavor Flavor = Mangle::ManglingFlavor::Default);
 
 /// Remangle in the old mangling scheme.
 ///
@@ -810,9 +814,9 @@ llvm::StringRef makeSymbolicMangledNameStringRef(const char *base);
 
 /// Produce the mangled name for the nominal type descriptor of a type
 /// referenced by its module and type name.
-std::string mangledNameForTypeMetadataAccessor(llvm::StringRef moduleName,
-                                               llvm::StringRef typeName,
-                                               Node::Kind typeKind);
+std::string mangledNameForTypeMetadataAccessor(
+    llvm::StringRef moduleName, llvm::StringRef typeName, Node::Kind typeKind,
+    Mangle::ManglingFlavor Flavor = Mangle::ManglingFlavor::Default);
 
 SWIFT_END_INLINE_NAMESPACE
 } // end namespace Demangle

include/swift/Demangling/Demangler.h

@@ -20,6 +20,7 @@
 #define SWIFT_DEMANGLING_DEMANGLER_H
 
 #include "swift/Demangling/Demangle.h"
+#include "swift/Demangling/ManglingFlavor.h"
 #include "swift/Demangling/NamespaceMacros.h"
 
 //#define NODE_FACTORY_DEBUGGING
@@ -405,6 +406,8 @@ class Demangler : public NodeFactory {
   /// as part of the name.
   bool IsOldFunctionTypeMangling = false;
 
+  Mangle::ManglingFlavor Flavor = Mangle::ManglingFlavor::Default;
+
   Vector<NodePointer> NodeStack;
   Vector<NodePointer> Substitutions;
 

include/swift/Demangling/ManglingFlavor.h

@@ -0,0 +1,36 @@
+//===--- ManglingFlavor.h - Swift name mangling -----------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2024 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_DEMANGLING_MANGLINGFLAVOR_H
+#define SWIFT_DEMANGLING_MANGLINGFLAVOR_H
+
+#include "swift/Demangling/NamespaceMacros.h"
+
+#include <cstdint>
+
+namespace swift {
+namespace Mangle {
+SWIFT_BEGIN_INLINE_NAMESPACE
+
+/// Which mangling style and prefix to use.
+enum class ManglingFlavor: uint8_t {
+  /// Default mangling with the ABI stable $s prefix
+  Default,
+  /// Embedded Swift's mangling with $e prefix
+  Embedded,
+};
+
+SWIFT_END_INLINE_NAMESPACE
+} // end namespace Mangle
+} // end namespace swift
+
+#endif // SWIFT_DEMANGLING_MANGLINGFLAVOR_H

include/swift/Demangling/ManglingMacros.h

@@ -22,11 +22,13 @@ _Pragma("clang diagnostic push")
 _Pragma("clang diagnostic ignored \"-Wdollar-in-identifier-extension\"")
 #endif
 #define MANGLING_PREFIX $s
+#define MANGLING_PREFIX_EMBEDDED $e
 #if defined(__clang__)
 _Pragma("clang diagnostic pop")
 #endif
 
 #define MANGLING_PREFIX_STR MANGLE_AS_STRING(MANGLING_PREFIX)
+#define MANGLING_PREFIX_EMBEDDED_STR MANGLE_AS_STRING(MANGLING_PREFIX_EMBEDDED)
 
 // The following macros help to create symbol manglings. They can be used
 // if a mangled name is needed at compile-time, e.g. for variable names in the

include/swift/Demangling/TypeDecoder.h

@@ -720,7 +720,7 @@ class TypeDecoder {
       return decodeMangledType(genericArgs->getChild(0), depth + 1);
     }
     case NodeKind::BuiltinTypeName: {
-      auto mangling = Demangle::mangleNode(Node);
+      auto mangling = Demangle::mangleNode(Node, Builder.getManglingFlavor());
       if (!mangling.isSuccess()) {
         return MAKE_NODE_TYPE_ERROR(Node,
                                     "failed to mangle node (%d:%u)",