[demangler] Add ItaniumPartialDemangler::isCtorOrDtor

[MaskRay]

Summary

This feature can be used to implement gold compatible --icf=safe in LLD, which is used in some Android and Chrome builds.

In C++, ctors and dtors are not allowed to be taken addresses. This
property is exploited by gold --icf=safe to fold only ctors and dtors.
We don't need to be very precise here to catch all the cases,
false negatives would not hurt.

[MaskRay]

format

[erik.pilkington]

Hi, thanks for working on this! This looks pretty good, I just have a few minor comments...

lib/Demangle/ItaniumDemangle.cpp

5268–5269

Seems kinda strange to talk about LLD here, this isn't necessarily a LLD-specific function. Maybe just say that false negatives are possible?

We don't even need to conservatively allow false-negatives here though, it would be straightforward to exactly match all constructor/destructors, right? You just need to add AbiTagAttr and StdQualifiedName to your loop below.

5271

No reason to include DtorName or QualifiedName, those can only appear in expressions (via an <unresolved-name>) so they should be unreachable.

[MaskRay]

Catch StdQualifiedName and AbiTagAttr

[MaskRay]

lib/Demangle/ItaniumDemangle.cpp

5271

Done.

Thanks. I see, these cases are covered by getFunctionBaseName above.

[MaskRay]

don't change QualifiedName

[MaskRay]

.

[erik.pilkington]

LGTM, thanks!

[pcc]

Are you planning to use this for anything aside from D47249 which was
abandoned?

Peter

include/llvm/Demangle/Demangle.h

struct ItaniumPartialDemangler {
   /// Get the parameters for this function.
   char *getFunctionParameters(char *Buf, size_t *N) const;
   char *getFunctionReturnType(char *Buf, size_t *N) const;
 
   /// If this function has any any cv or reference qualifiers. These imply that
   /// the function is a non-static member function.
   bool hasFunctionQualifiers() const;
 
+  /// If this symbol describes a constructor or destructor.
+  bool isCtorOrDtor() const;
+
   /// If this symbol describes a function.
   bool isFunction() const;
 
   /// If this symbol describes a variable.
   bool isData() const;
 
   /// If this symbol is a <special-name>. These are generally implicitly
   /// generated by the implementation, such as vtables and typeinfo names.
   bool isSpecialName() const;
 
   ~ItaniumPartialDemangler();
 private:
   void *RootNode;
   void *Context;
 };
 } // namespace llvm

lib/Demangle/ItaniumDemangle.cpp

struct LocalName : Node {
 
   void printLeft(OutputStream &S) const override {
     Encoding->print(S);
     S += "::";
     Entity->print(S);
   }
 };
 
-class QualifiedName final : public Node {
+struct QualifiedName final : Node {
   // qualifier::name
-  const Node *Qualifier;
-  const Node *Name;
+  Node *Qualifier;
+  Node *Name;
 
-public:
   QualifiedName(Node* Qualifier_, Node* Name_)
       : Node(KQualifiedName), Qualifier(Qualifier_), Name(Name_) {}
 
   StringView getBaseName() const override { return Name->getBaseName(); }
 
   void printLeft(OutputStream &S) const override {
     Qualifier->print(S);
     S += "::";

 bool ItaniumPartialDemangler::hasFunctionQualifiers() const {
   assert(RootNode != nullptr && "must call partialDemangle()");
   if (!isFunction())
     return false;
   auto *E = static_cast<FunctionEncoding *>(RootNode);
   return E->getCVQuals() != QualNone || E->getRefQual() != FrefQualNone;
 }
 
+bool ItaniumPartialDemangler::isCtorOrDtor() const {
+  Node *N = static_cast<Node *>(RootNode);
+  // ctors and dtors are eligible in LLD --icf=safe, it is fine if some are not
+  // recognized as ctor or dtor (false negatives).
+  while (N) {
+    switch (N->getKind()) {
+    default:
+      return false;
+    case Node::KCtorDtorName:
+    case Node::KDtorName:
+      return true;
+    case Node::KFunctionEncoding:
+      N = static_cast<FunctionEncoding *>(N)->getName();
+      break;
+    case Node::KLocalName:
+      N = static_cast<LocalName *>(N)->Entity;
+      break;
+    case Node::KNameWithTemplateArgs:
+      N = static_cast<NameWithTemplateArgs *>(N)->Name;
+      break;
+    case Node::KNestedName:
+      N = static_cast<NestedName *>(N)->Name;
+      break;
+    case Node::KQualifiedName:
+      N = static_cast<QualifiedName *>(N)->Name;
+      break;
+    }
+  }
+  return false;
+}
+
 bool ItaniumPartialDemangler::isFunction() const {
   assert(RootNode != nullptr && "must call partialDemangle()");
   return static_cast<Node *>(RootNode)->getKind() == Node::KFunctionEncoding;
 }
 
 bool ItaniumPartialDemangler::isSpecialName() const {
   assert(RootNode != nullptr && "must call partialDemangle()");
   auto K = static_cast<Node *>(RootNode)->getKind();
   return K == Node::KSpecialName || K == Node::KCtorVtableSpecialName;
 }
 
 bool ItaniumPartialDemangler::isData() const {
   return !isFunction() && !isSpecialName();
 }
 
 }

unittests/Demangle/PartialDemangleTest.cpp

TEST(PartialDemangleTest, TestNameMeta) {
   EXPECT_FALSE(Demangler.isFunction());
 
   EXPECT_FALSE(Demangler.partialDemangle("_ZN1aDC1a1b1cEE"));
   EXPECT_FALSE(Demangler.isFunction());
   EXPECT_FALSE(Demangler.isSpecialName());
   EXPECT_TRUE(Demangler.isData());
 }
 
+TEST(PartialDemanglerTest, TestCtorOrDtor) {
+  static const char *Pos[] = {
+      "_ZN1AC1Ev",       // A::A()
+      "_ZN1AC1IiEET_",   // A::A<int>(int)
+      "_ZN1AD2Ev",       // A::~A()
+      "_ZN1BIiEC1IcEET_" // B<int>::B<char>(char)
+  };
+  static const char *Neg[] = {
+      "_Z1fv",
+      "_ZN1A1gIiEEvT_", // void A::g<int>(int)
+  };
+
+  llvm::ItaniumPartialDemangler D;
+  for (const char *N : Pos) {
+    EXPECT_FALSE(D.partialDemangle(N));
+    EXPECT_TRUE(D.isCtorOrDtor());
+  }
+  for (const char *N : Neg) {
+    EXPECT_FALSE(D.partialDemangle(N));
+    EXPECT_FALSE(D.isCtorOrDtor());
+  }
+}
+
 TEST(PartialDemanglerTest, TestMisc) {
   llvm::ItaniumPartialDemangler D1, D2;
 
   EXPECT_FALSE(D1.partialDemangle("_Z1fv"));
   EXPECT_FALSE(D2.partialDemangle("_Z1g"));
   std::swap(D1, D2);
   EXPECT_FALSE(D1.isFunction());
   EXPECT_TRUE(D2.isFunction());
 
   EXPECT_TRUE(D1.partialDemangle("Not a mangled name!"));
 
 }