[clang][AST] ASTNameGenerator: A refactoring of CodegenNameGeneratorImpl (NFC).

This is a NFC refactor move of CodegenNameGeneratorImpl from clang::Index to
clang:AST (and rename to ASTNameGenerator). The purpose is to make the
highlevel mangling code more reusable inside of clang (say in places like clang
FrontendAction). This does not affect anything in CodegenNameGenerator, except
that CodegenNameGenerator will now use ASTNameGenerator (in AST).

Differential Revision: https://reviews.llvm.org/D63535

llvm-svn: 363878

1 files changed, 183 insertions, 0 deletions

diff --git a/clang/lib/AST/Mangle.cpp b/clang/lib/AST/Mangle.cpp
index 03ebf98a7f1..ec3b6868a3f 100644
--- a/clang/lib/AST/Mangle.cpp
+++ b/clang/lib/AST/Mangle.cpp
@@ -17,10 +17,12 @@
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/Mangle.h"
+#include "clang/AST/VTableBuilder.h"
 #include "clang/Basic/ABI.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/IR/Mangler.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 
@@ -280,3 +282,184 @@ void MangleContext::mangleObjCMethodName(const ObjCMethodDecl *MD,
   mangleObjCMethodNameWithoutSize(MD, OS);
   Out << OS.str().size() << OS.str();
 }
+
+ASTNameGenerator::ASTNameGenerator(ASTContext &Ctx)
+    : MC(Ctx.createMangleContext()), DL(Ctx.getTargetInfo().getDataLayout()) {}
+
+bool ASTNameGenerator::writeName(const Decl *D, raw_ostream &OS) {
+  // First apply frontend mangling.
+  SmallString<128> FrontendBuf;
+  llvm::raw_svector_ostream FrontendBufOS(FrontendBuf);
+  if (auto *FD = dyn_cast<FunctionDecl>(D)) {
+    if (FD->isDependentContext())
+      return true;
+    if (writeFuncOrVarName(FD, FrontendBufOS))
+      return true;
+  } else if (auto *VD = dyn_cast<VarDecl>(D)) {
+    if (writeFuncOrVarName(VD, FrontendBufOS))
+      return true;
+  } else if (auto *MD = dyn_cast<ObjCMethodDecl>(D)) {
+    MC->mangleObjCMethodNameWithoutSize(MD, OS);
+    return false;
+  } else if (auto *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
+    writeObjCClassName(ID, FrontendBufOS);
+  } else {
+    return true;
+  }
+
+  // Now apply backend mangling.
+  llvm::Mangler::getNameWithPrefix(OS, FrontendBufOS.str(), DL);
+  return false;
+}
+
+std::string ASTNameGenerator::getName(const Decl *D) {
+  std::string Name;
+  {
+    llvm::raw_string_ostream OS(Name);
+    writeName(D, OS);
+  }
+  return Name;
+}
+
+enum ObjCKind {
+  ObjCClass,
+  ObjCMetaclass,
+};
+
+static StringRef getClassSymbolPrefix(ObjCKind Kind,
+                                      const ASTContext &Context) {
+  if (Context.getLangOpts().ObjCRuntime.isGNUFamily())
+    return Kind == ObjCMetaclass ? "_OBJC_METACLASS_" : "_OBJC_CLASS_";
+  return Kind == ObjCMetaclass ? "OBJC_METACLASS_$_" : "OBJC_CLASS_$_";
+}
+
+std::vector<std::string>
+ASTNameGenerator::getAllManglings(const ObjCContainerDecl *OCD) {
+  StringRef ClassName;
+  if (const auto *OID = dyn_cast<ObjCInterfaceDecl>(OCD))
+    ClassName = OID->getObjCRuntimeNameAsString();
+  else if (const auto *OID = dyn_cast<ObjCImplementationDecl>(OCD))
+    ClassName = OID->getObjCRuntimeNameAsString();
+
+  if (ClassName.empty())
+    return {};
+
+  auto Mangle = [&](ObjCKind Kind, StringRef ClassName) -> std::string {
+    SmallString<40> Mangled;
+    auto Prefix = getClassSymbolPrefix(Kind, OCD->getASTContext());
+    llvm::Mangler::getNameWithPrefix(Mangled, Prefix + ClassName, DL);
+    return Mangled.str();
+  };
+
+  return {
+      Mangle(ObjCClass, ClassName),
+      Mangle(ObjCMetaclass, ClassName),
+  };
+}
+
+std::vector<std::string> ASTNameGenerator::getAllManglings(const Decl *D) {
+  if (const auto *OCD = dyn_cast<ObjCContainerDecl>(D))
+    return getAllManglings(OCD);
+
+  if (!(isa<CXXRecordDecl>(D) || isa<CXXMethodDecl>(D)))
+    return {};
+
+  const NamedDecl *ND = cast<NamedDecl>(D);
+
+  ASTContext &Ctx = ND->getASTContext();
+  std::unique_ptr<MangleContext> M(Ctx.createMangleContext());
+
+  std::vector<std::string> Manglings;
+
+  auto hasDefaultCXXMethodCC = [](ASTContext &C, const CXXMethodDecl *MD) {
+    auto DefaultCC = C.getDefaultCallingConvention(/*IsVariadic=*/false,
+                                                   /*IsCSSMethod=*/true);
+    auto CC = MD->getType()->getAs<FunctionProtoType>()->getCallConv();
+    return CC == DefaultCC;
+  };
+
+  if (const auto *CD = dyn_cast_or_null<CXXConstructorDecl>(ND)) {
+    Manglings.emplace_back(getMangledStructor(CD, Ctor_Base));
+
+    if (Ctx.getTargetInfo().getCXXABI().isItaniumFamily())
+      if (!CD->getParent()->isAbstract())
+        Manglings.emplace_back(getMangledStructor(CD, Ctor_Complete));
+
+    if (Ctx.getTargetInfo().getCXXABI().isMicrosoft())
+      if (CD->hasAttr<DLLExportAttr>() && CD->isDefaultConstructor())
+        if (!(hasDefaultCXXMethodCC(Ctx, CD) && CD->getNumParams() == 0))
+          Manglings.emplace_back(getMangledStructor(CD, Ctor_DefaultClosure));
+  } else if (const auto *DD = dyn_cast_or_null<CXXDestructorDecl>(ND)) {
+    Manglings.emplace_back(getMangledStructor(DD, Dtor_Base));
+    if (Ctx.getTargetInfo().getCXXABI().isItaniumFamily()) {
+      Manglings.emplace_back(getMangledStructor(DD, Dtor_Complete));
+      if (DD->isVirtual())
+        Manglings.emplace_back(getMangledStructor(DD, Dtor_Deleting));
+    }
+  } else if (const auto *MD = dyn_cast_or_null<CXXMethodDecl>(ND)) {
+    Manglings.emplace_back(getName(ND));
+    if (MD->isVirtual())
+      if (const auto *TIV = Ctx.getVTableContext()->getThunkInfo(MD))
+        for (const auto &T : *TIV)
+          Manglings.emplace_back(getMangledThunk(MD, T));
+  }
+
+  return Manglings;
+}
+
+bool ASTNameGenerator::writeFuncOrVarName(const NamedDecl *D, raw_ostream &OS) {
+  if (MC->shouldMangleDeclName(D)) {
+    if (const auto *CtorD = dyn_cast<CXXConstructorDecl>(D))
+      MC->mangleCXXCtor(CtorD, Ctor_Complete, OS);
+    else if (const auto *DtorD = dyn_cast<CXXDestructorDecl>(D))
+      MC->mangleCXXDtor(DtorD, Dtor_Complete, OS);
+    else
+      MC->mangleName(D, OS);
+    return false;
+  } else {
+    IdentifierInfo *II = D->getIdentifier();
+    if (!II)
+      return true;
+    OS << II->getName();
+    return false;
+  }
+}
+
+void ASTNameGenerator::writeObjCClassName(const ObjCInterfaceDecl *D,
+                                          raw_ostream &OS) {
+  OS << getClassSymbolPrefix(ObjCClass, D->getASTContext());
+  OS << D->getObjCRuntimeNameAsString();
+}
+
+std::string ASTNameGenerator::getMangledStructor(const NamedDecl *ND,
+                                                 unsigned StructorType) {
+  std::string FrontendBuf;
+  llvm::raw_string_ostream FOS(FrontendBuf);
+
+  if (const auto *CD = dyn_cast_or_null<CXXConstructorDecl>(ND))
+    MC->mangleCXXCtor(CD, static_cast<CXXCtorType>(StructorType), FOS);
+  else if (const auto *DD = dyn_cast_or_null<CXXDestructorDecl>(ND))
+    MC->mangleCXXDtor(DD, static_cast<CXXDtorType>(StructorType), FOS);
+
+  std::string BackendBuf;
+  llvm::raw_string_ostream BOS(BackendBuf);
+
+  llvm::Mangler::getNameWithPrefix(BOS, FOS.str(), DL);
+
+  return BOS.str();
+}
+
+std::string ASTNameGenerator::getMangledThunk(const CXXMethodDecl *MD,
+                                              const ThunkInfo &T) {
+  std::string FrontendBuf;
+  llvm::raw_string_ostream FOS(FrontendBuf);
+
+  MC->mangleThunk(MD, T, FOS);
+
+  std::string BackendBuf;
+  llvm::raw_string_ostream BOS(BackendBuf);
+
+  llvm::Mangler::getNameWithPrefix(BOS, FOS.str(), DL);
+
+  return BOS.str();
+}