[Demangle] demangle builtin type transformations

[HerrCai0907]

Summary

Fixed: https://github.com/llvm/llvm-project/issues/62127
https://reviews.llvm.org/D116203 introduced several compiler builtin
equivalents of the unary type traits. In some cases (e.g. template) those
builtin will be dependent and need to be mangle.
This patch add the check for u{builtin}I{type}E to demangle it.

[HerrCai0907]

update

[HerrCai0907]

add test

[HerrCai0907]

port change to libcxx

[shafik]

Adding who I think are additional relevant reviewers.

[erichkeane]

Your test showed up as a 'binary' file? Also, I don't have code ownership in the demangler, so hopefully someone else can come along.

[cjdb]

In D148465#4273886, @erichkeane wrote:

Your test showed up as a 'binary' file? Also, I don't have code ownership in the demangler, so hopefully someone else can come along.

This happened to me too. I think Phabricator assumes anything over a certain number of lines is a binary file regardless of its contents.

[HerrCai0907]

rebase

[shafik]

Can you please add a link to the github issue in the description and can this change be tested?

[HerrCai0907]

can this change be tested?

Test case is in https://reviews.llvm.org/F27268964$30119

[aaron.ballman]

Thank you for working on this! The changes seem reasonable to me, but I'd love to hear from @rjmccall as Itanium ABI owner too.

[aaron.ballman]

(Should this probably have a release note?)

[cor3ntin]

@rjmccall Ping!

[rjmccall]

Ah, I didn't see that this was waiting on me. I'm not much of an expert in the demangler, but at a glance, this looks right.

[HerrCai0907]

replace StringView with std::string_view

[HerrCai0907]

replaced with https://github.com/llvm/llvm-project/pull/65902

[cor3ntin]

While new reviews should be on Github, we prefer finishing existing reviews here so that we do not lose all the history of changes and conversations.

llvm/include/llvm/Demangle/ItaniumDemangle.h

public:
 
   void printLeft(OutputBuffer &OB) const override {
     OB += Kind;
     OB += ' ';
     Child->print(OB);
   }
 };
 
+class TransformedType : public Node {
+  StringView Transform;
+  Node *BaseType;
+public:
+  TransformedType(StringView Transform_, Node *BaseType_)
+      : Node(KTransformedType), Transform(Transform_), BaseType(BaseType_) {}
+
+  template<typename Fn> void match(Fn F) const { F(Transform, BaseType); }
+
+  void printLeft(OutputBuffer &OB) const override {
+    OB += Transform;
+    OB += '(';
+    BaseType->print(OB);
+    OB += ')';
+  }
+};
+
 struct AbiTagAttr : Node {
   Node *Base;
   StringView Tag;
 
   AbiTagAttr(Node *Base_, StringView Tag_)
       : Node(KAbiTagAttr, Base_->RHSComponentCache, Base_->ArrayCache,
              Base_->FunctionCache),
         Base(Base_), Tag(Tag_) {}
Node *AbstractManglingParser<Derived, Alloc>::parseType() {
   case 'u': {
     ++First;
     StringView Res = parseBareSourceName();
     if (Res.empty())
       return nullptr;
     // Typically, <builtin-type>s are not considered substitution candidates,
     // but the exception to that exception is vendor extended types (Itanium C++
     // ABI 5.9.1).
+    if (consumeIf('I')) {
+      Node *BaseType = parseType();
+      if (BaseType == nullptr)
+        return nullptr;
+      if (!consumeIf('E'))
+        return nullptr;
+      Result = make<TransformedType>(Res, BaseType);
+    } else
       Result = make<NameType>(Res);
     break;
   }
   case 'D':
     switch (look(1)) {
     //                ::= Dd   # IEEE 754r decimal floating point (64 bits)
     case 'd':
       First += 2;
       return make<NameType>("decimal64");

llvm/include/llvm/Demangle/ItaniumNodes.def

 
 NODE(NodeArrayNode)
 NODE(DotSuffix)
 NODE(VendorExtQualType)
 NODE(QualType)
 NODE(ConversionOperatorType)
 NODE(PostfixQualifiedType)
 NODE(ElaboratedTypeSpefType)
+NODE(TransformedType)
 NODE(NameType)
 NODE(AbiTagAttr)
 NODE(EnableIfAttr)
 NODE(ObjCProtoName)
 NODE(PointerType)
 NODE(ReferenceType)
 NODE(PointerToMemberType)
 NODE(ArrayType)

llvm/unittests/Demangle/ItaniumDemangleTest.cpp

 #undef NOMATCHER
 
 void Visitor() {
 #define NODE(X) Visit(static_cast<const itanium_demangle::X *>(nullptr));
 #include "llvm/Demangle/ItaniumNodes.def"
 }
 } // namespace NodeMatcher
 
+static std::string toString(OutputBuffer &OB) {
+  StringView SV = OB;
+  return {SV.begin(), SV.end()};
+}
+
 // Verify Operator table is ordered
 TEST(ItaniumDemangle, OperatorOrdering) {
   struct TestParser : AbstractManglingParser<TestParser, TestAllocator> {};
   for (const auto *Op = &TestParser::Ops[0];
        Op != &TestParser::Ops[TestParser::NumOps - 1]; Op++)
     ASSERT_LT(Op[0], Op[1]);
 }
 
struct TestParser : AbstractManglingParser<TestParser, TestAllocator> {
     }
   };
 
   TestParser Parser("_Z1fIiEjl");
   ASSERT_NE(nullptr, Parser.parse());
   EXPECT_THAT(Parser.Types, testing::ElementsAre('i', 'j', 'l'));
 }
 
-static std::string toString(OutputBuffer &OB) {
-  StringView SV = OB;
-  return {SV.begin(), SV.end()};
+TEST(ItaniumDemangle, TransformedType) {
+  struct TestParser : AbstractManglingParser<TestParser, TestAllocator> {
+    std::vector<std::string> Types;
+    TestParser(const char *Str)
+        : AbstractManglingParser(Str, Str + strlen(Str)) {}
+    Node *parseType() {
+      Node *N = AbstractManglingParser<TestParser, TestAllocator>::parseType();
+      OutputBuffer OB;
+      N->print(OB);
+      Types.push_back(toString(OB));
+      return N;
+    }
+  };
+
+  TestParser Parser("_Z2f5IiEvu7__decayIT_E");
+  ASSERT_NE(nullptr, Parser.parse());
+  EXPECT_THAT(Parser.Types,
+              testing::ElementsAre("int", "void", "__decay(int)"));
 }
 
 TEST(ItaniumDemangle, HalfType) {
   struct TestParser : AbstractManglingParser<TestParser, TestAllocator> {
     std::vector<std::string> Types;
 
     TestParser(const char *Str)
         : AbstractManglingParser(Str, Str + strlen(Str)) {}