Implement Microsoft-compatible mangling for decomposition declarations.

[epastor]

Summary

Match cl.exe's mangling for decomposition declarations.

Decomposition declarations are considered to be anonymous structs, and use the same convention as for anonymous struct/union declarations.

Naming confirmed to match https://godbolt.org/z/K2osJa

[thakis]

Does this pass ninja check-clang? If so, can you add a test for the new mangling, based on the manglings in the godbolt example? See clang/test/CodeGenCXX/mangle-ms-* for many examples; a new file mangle-ms-cxx20.cpp might be appropriate here. You can run bin/llvm-lit -vv clang/test/CodeGenCXX/foo.cpp to run a single lit test for iterating on the local test.

[thakis]

ps: Thanks for the patch, this is great :)

pps: Since this uses struct mangling, llvm-undname can already demangle these names, right?

[epastor]

• Add testing for the new deprecation declarations mangling

[epastor]

The change passes ninja check-clang - and I've added a test per your suggestions. Thanks!

As for llvm-undname: it works reasonably well, but these are anonymous names. It successfully recognizes $S1, etc. as the "name", though!

[thakis]

Thanks!

Re llvm-undname: That seems to match behavior of MSVC's undname, so I'd say that's all good :)

cfe/trunk/include/clang/AST/Mangle.h

private:
   virtual void anchor();
 
   ASTContext &Context;
   DiagnosticsEngine &Diags;
   const ManglerKind Kind;
 
   llvm::DenseMap<const BlockDecl*, unsigned> GlobalBlockIds;
   llvm::DenseMap<const BlockDecl*, unsigned> LocalBlockIds;
-  llvm::DenseMap<const TagDecl*, uint64_t> AnonStructIds;
+  llvm::DenseMap<const NamedDecl*, uint64_t> AnonStructIds;
 
 public:
   ManglerKind getKind() const { return Kind; }
 
   explicit MangleContext(ASTContext &Context,
                          DiagnosticsEngine &Diags,
                          ManglerKind Kind)
       : Context(Context), Diags(Diags), Kind(Kind) {}
public:
   unsigned getBlockId(const BlockDecl *BD, bool Local) {
     llvm::DenseMap<const BlockDecl *, unsigned> &BlockIds
       = Local? LocalBlockIds : GlobalBlockIds;
     std::pair<llvm::DenseMap<const BlockDecl *, unsigned>::iterator, bool>
       Result = BlockIds.insert(std::make_pair(BD, BlockIds.size()));
     return Result.first->second;
   }
 
-  uint64_t getAnonymousStructId(const TagDecl *TD) {
-    std::pair<llvm::DenseMap<const TagDecl *, uint64_t>::iterator, bool>
-        Result = AnonStructIds.insert(std::make_pair(TD, AnonStructIds.size()));
+  uint64_t getAnonymousStructId(const NamedDecl *D) {
+    std::pair<llvm::DenseMap<const NamedDecl *, uint64_t>::iterator, bool>
+        Result = AnonStructIds.insert(std::make_pair(D, AnonStructIds.size()));
     return Result.first->second;
   }
 
   /// @name Mangler Entry Points
   /// @{
 
   bool shouldMangleDeclName(const NamedDecl *D);
   virtual bool shouldMangleCXXName(const NamedDecl *D) = 0;

cfe/trunk/lib/AST/MicrosoftMangle.cpp

case DeclarationName::Identifier: {
       if (const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(ND)) {
         if (NS->isAnonymousNamespace()) {
           Out << "?A0x" << Context.getAnonymousNamespaceHash() << '@';
           break;
         }
       }
 
       if (const DecompositionDecl *DD = dyn_cast<DecompositionDecl>(ND)) {
-        // FIXME: Invented mangling for decomposition declarations:
-        //   [X,Y,Z]
-        // where X,Y,Z are the names of the bindings.
-        llvm::SmallString<128> Name("[");
-        for (auto *BD : DD->bindings()) {
-          if (Name.size() > 1)
-            Name += ',';
-          Name += BD->getDeclName().getAsIdentifierInfo()->getName();
-        }
-        Name += ']';
+        // Decomposition declarations are considered anonymous, and get
+        // numbered with a $S prefix.
+        llvm::SmallString<64> Name("$S");
+        // Get a unique id for the anonymous struct.
+        Name += llvm::utostr(Context.getAnonymousStructId(DD) + 1);
         mangleSourceName(Name);
         break;
       }
 
       if (const VarDecl *VD = dyn_cast<VarDecl>(ND)) {
         // We must have an anonymous union or struct declaration.
         const CXXRecordDecl *RD = VD->getType()->getAsCXXRecordDecl();
         assert(RD && "expected variable decl to have a record type");

cfe/trunk/test/CodeGenCXX/mangle-ms-cxx17.cpp

+// RUN: %clang_cc1 -std=c++1z -fms-extensions -emit-llvm %s -o - -triple=i386-pc-win32 -fms-compatibility-version=19.10 | FileCheck -allow-deprecated-dag-overlap %s --check-prefix=CHECK --check-prefix=MSVC2017
+// RUN: %clang_cc1 -std=c++1z -fms-extensions -emit-llvm %s -o - -triple=i386-pc-win32 -fms-compatibility-version=19.00 | FileCheck -allow-deprecated-dag-overlap %s --check-prefix=CHECK --check-prefix=MSVC2015
+
+struct S {
+    int x;
+    double y;
+};
+S f();
+
+// CHECK-DAG: "?$S1@@3US@@B"
+const auto [x0, y0] = f();
+// CHECK-DAG: "?$S2@@3US@@B"
+const auto [x1, y1] = f();
+
+static union {
+int a;
+double b;
+};
+
+// CHECK-DAG: "?$S4@@3US@@B"
+const auto [x2, y2] = f();