[Demangle] Add support for D string literals

[ljmf00]

Summary

Signed-off-by: Luís Ferreira <[e-mail]>

llvm/lib/Demangle/DLangDemangle.cpp

private:
   ///
   /// \return the remaining string on success or nullptr on failure
   ///
   /// \note A result larger than UINT_MAX is considered a failure
   ///
   /// \see https://dlang.org/spec/abi.html#Number
   const char *decodeNumber(const char *Mangled, unsigned long *Ret);
 
+  /// Extract the hex-digit from a given string
+  ///
+  /// \param Mangled string to extract the hex-digit
+  /// \param Ret assigned result value
+  ///
+  /// \return the remaining string on success or nullptr on failure.
+  ///
+  /// \see https://dlang.org/spec/abi.html#HexDigits
+  const char *decodeHexdigit(const char *Mangled, char *Ret);
+
   /// Extract the back reference position from a given string
   ///
   /// \param Mangled string to extract the back reference position
   /// \param Ret assigned result value
   ///
   /// \return the remaining string on success or nullptr on failure
   ///
   /// \note a result <= 0 is a failure
private:
   /// \param Type mangled type character in which the type should be
   ///             represented as
   ///
   /// \return the remaining string on success or nullptr on failure
   ///
   /// \see https://dlang.org/spec/abi.html#Value
   const char *parseInteger(OutputString *Decl, const char *Mangled, char Type);
 
+  /// Extract and demangle a string value from a given mangled symbol append it
+  /// to the output string
+  ///
+  /// \param Decl output buffer to write the demangled name
+  /// \param Mangled mangled symbol to be demangled
+  ///
+  /// \return the remaining string on success or nullptr on failure
+  ///
+  /// \see https://dlang.org/spec/abi.html#Value
+  const char *parseString(OutputString *Decl, const char *Mangled);
+
   /// Extract and demangle a floating-point value from a given mangled symbol
   /// append it to the output string
   ///
   /// \param Decl output buffer to write the demangled name
   /// \param Mangled mangled symbol to be demangled
   ///
   /// \return the remaining string on success or nullptr on failure
   ///
const char *Demangler::decodeNumber(const char *Mangled, unsigned long *Ret) {
 
   if (*Mangled == '\0')
     return nullptr;
 
   *Ret = Val;
   return Mangled;
 }
 
+const char *Demangler::decodeHexdigit(const char *Mangled, char *Ret) {
+  char C;
+
+  // Return nullptr if trying to extract something that isn't a hexdigit
+  if (Mangled == nullptr || !std::isxdigit(Mangled[0]) ||
+      !std::isxdigit(Mangled[1]))
+    return nullptr;
+
+  C = Mangled[0];
+  if (!std::isdigit(C))
+    *Ret = C - (std::isupper(C) ? 'A' : 'a') + 10;
+  else
+    *Ret = C - '0';
+
+  C = Mangled[1];
+  if (!std::isdigit(C))
+    *Ret = (*Ret << 4) | (C - (std::isupper(C) ? 'A' : 'a') + 10);
+  else
+    *Ret = (*Ret << 4) | (C - '0');
+
+  Mangled += 2;
+
+  return Mangled;
+}
+
 bool Demangler::isCallConvention(const char *Mangled) {
   switch (*Mangled) {
   case 'F':
   case 'U':
   case 'V':
   case 'W':
   case 'R':
   case 'Y':
case 'c':
     Decl->append('+');
     if (Mangled == nullptr || *Mangled != 'c')
       return nullptr;
     Mangled++;
     Mangled = parseReal(Decl, Mangled);
     Decl->append('i');
     break;
 
+  // String values
+  case 'a': /* UTF8 */
+  case 'w': /* UTF16 */
+  case 'd': /* UTF32 */
+    Mangled = parseString(Decl, Mangled);
+    break;
+
   default:
     return nullptr;
   }
 
   return Mangled;
 }
 
+const char *Demangler::parseString(OutputString *Decl, const char *Mangled) {
+  char Type = *Mangled;
+  unsigned long Len;
+
+  Mangled++;
+  Mangled = decodeNumber(Mangled, &Len);
+  if (Mangled == nullptr || *Mangled != '_')
+    return nullptr;
+
+  Mangled++;
+  Decl->append('\"');
+  while (Len--) {
+    char Val;
+    const char *Endptr = decodeHexdigit(Mangled, &Val);
+
+    if (Endptr == nullptr)
+      return nullptr;
+
+    /* Sanitize white and non-printable characters.  */
+    switch (Val) {
+    case ' ':
+      Decl->append(' ');
+      break;
+    case '\t':
+      Decl->append("\\t");
+      break;
+    case '\n':
+      Decl->append("\\n");
+      break;
+    case '\r':
+      Decl->append("\\r");
+      break;
+    case '\f':
+      Decl->append("\\f");
+      break;
+    case '\v':
+      Decl->append("\\v");
+      break;
+
+    default:
+      if (std::isprint(Val))
+        Decl->append(Val);
+      else {
+        Decl->append("\\x");
+        Decl->append(Mangled, 2);
+      }
+    }
+
+    Mangled = Endptr;
+  }
+  Decl->append('\"');
+
+  if (Type != 'a')
+    Decl->append(Type);
+
+  return Mangled;
+}
+
 const char *Demangler::parseInteger(OutputString *Decl, const char *Mangled,
                                     char Type) {
   if (Type == 'a' || Type == 'u' || Type == 'w') {
     // Parse character value
     char Value[20];
     int Pos = sizeof(Value);
     int Width = 0;
     unsigned long Val;

llvm/unittests/Demangle/DLangDemangleTest.cpp

ExpectedVal ExpectedArray[] = {
        "demangle.test!(0x0.C4CCCCCCCCCCCCCDp4+0x0.B666666666666666p6i)"},
       {"_D8demangle52__T4testVrcN0C4CCCCCCCCCCCCCDP4c0B666666666666666P6Zv",
        "demangle.test!(-0x0.C4CCCCCCCCCCCCCDp4+0x0.B666666666666666p6i)"},
       {"_D8demangle91__"
        "T4testVde000111222333444555666777888999AAABBBCCCDDDEEEFFFP0001112223334"
        "44555666777888999Zv",
        "demangle.test!(0x0."
        "00111222333444555666777888999AAABBBCCCDDDEEEFFFp00011122233344455566677"
-       "7888999)"}
+       "7888999)"},
+      {"_D8demangle22__T4testVG3ua3_616263Zv", "demangle.test!(\"abc\")"},
+      {"_D8demangle22__T4testVG3ud3_616263Zv", "demangle.test!(\"abc\"d)"},
+      {"_D8demangle22__T4testVG3uw3_616263Zv", "demangle.test!(\"abc\"w)"},
+      {"_D8demangle16__T4testVAyaa0_Zv", "demangle.test!(\"\")"},
+      {"_D8demangle32__T4testVAyaa8_20090a0d0c0b00ffZv",
+       "demangle.test!(\" \\t\\n\\r\\f\\v\\x00\\xff\")"}
   };
 
   for (ExpectedVal Val : ExpectedArray) {
     char *Demangled = llvm::dlangDemangle(Val.Mangled);
     EXPECT_STREQ(Demangled, Val.Expected);
     std::free(Demangled);
   }
 }