[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.

libcxxabi/src/demangle/ItaniumDemangle.h

public:
 
   void printLeft(OutputBuffer &OB) const override {
     OB += Kind;
     OB += ' ';
     Child->print(OB);
   }
 };
 
+class TransformedType : public Node {
+  std::string_view Transform;
+  Node *BaseType;
+public:
+  TransformedType(std::string_view 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;
   std::string_view Tag;
 
   AbiTagAttr(Node *Base_, std::string_view Tag_)
       : Node(KAbiTagAttr, Base_->RHSComponentCache, Base_->ArrayCache,
              Base_->FunctionCache),
         Base(Base_), Tag(Tag_) {}
Node *AbstractManglingParser<Derived, Alloc>::parseType() {
   case 'u': {
     ++First;
     std::string_view 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");

libcxxabi/src/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/include/llvm/Demangle/ItaniumDemangle.h

public:
 
   void printLeft(OutputBuffer &OB) const override {
     OB += Kind;
     OB += ' ';
     Child->print(OB);
   }
 };
 
+class TransformedType : public Node {
+  std::string_view Transform;
+  Node *BaseType;
+public:
+  TransformedType(std::string_view 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;
   std::string_view Tag;
 
   AbiTagAttr(Node *Base_, std::string_view Tag_)
       : Node(KAbiTagAttr, Base_->RHSComponentCache, Base_->ArrayCache,
              Base_->FunctionCache),
         Base(Base_), Tag(Tag_) {}
Node *AbstractManglingParser<Derived, Alloc>::parseType() {
   case 'u': {
     ++First;
     std::string_view 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)