[Demangle] Add support for D floating-point literal values

[ljmf00]

Summary

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

llvm/lib/Demangle/DLangDemangle.cpp

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 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
+  ///
+  /// \see https://dlang.org/spec/abi.html#Value
+  const char *parseReal(OutputString *Decl, const char *Mangled);
+
   /// Extract and demangle any 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
   /// \param Type mangled type character in which the type should be
   ///             represented as, if needed
   ///
const char *Demangler::parseValue(OutputString *Decl, const char *Mangled,
   case '5':
   case '6':
   case '7':
   case '8':
   case '9':
     Mangled = parseInteger(Decl, Mangled, Type);
     break;
 
+  // Real value
+  case 'e':
+    Mangled++;
+    Mangled = parseReal(Decl, Mangled);
+    break;
+
+  // Complex value
+  case 'c':
+    Mangled++;
+    Mangled = parseReal(Decl, Mangled);
+    Decl->append('+');
+    if (Mangled == nullptr || *Mangled != 'c')
+      return nullptr;
+    Mangled++;
+    Mangled = parseReal(Decl, Mangled);
+    Decl->append('i');
+    break;
+
   default:
     return nullptr;
   }
 
   return Mangled;
 }
 
 const char *Demangler::parseInteger(OutputString *Decl, const char *Mangled,
case 'm': /* ulong */
       Decl->append("uL");
       break;
     }
   }
 
   return Mangled;
 }
 
+const char *Demangler::parseReal(OutputString *Decl, const char *Mangled) {
+  // Handle NAN and +-INF
+  if (strncmp(Mangled, "NAN", 3) == 0) {
+    Decl->append("NaN");
+    Mangled += 3;
+    return Mangled;
+  }
+
+  if (strncmp(Mangled, "INF", 3) == 0) {
+    Decl->append("Inf");
+    Mangled += 3;
+    return Mangled;
+  }
+
+  if (strncmp(Mangled, "NINF", 4) == 0) {
+    Decl->append("-Inf");
+    Mangled += 4;
+    return Mangled;
+  }
+
+  // Hexadecimal prefix and leading bit
+  if (*Mangled == 'N') {
+    Decl->append('-');
+    Mangled++;
+  }
+
+  if (!std::isxdigit(*Mangled))
+    return nullptr;
+
+  Decl->append("0x");
+  Decl->append(Mangled, 1);
+  Decl->append('.');
+  Mangled++;
+
+  // Significand
+  while (std::isxdigit(*Mangled)) {
+    Decl->append(Mangled, 1);
+    Mangled++;
+  }
+
+  // Exponent
+  if (*Mangled != 'P')
+    return nullptr;
+
+  Decl->append('p');
+  Mangled++;
+
+  if (*Mangled == 'N') {
+    Decl->append('-');
+    Mangled++;
+  }
+
+  while (std::isdigit(*Mangled)) {
+    Decl->append(Mangled, 1);
+    Mangled++;
+  }
+
+  return Mangled;
+}
+
 Demangler::Demangler(const char *Mangled)
     : Str(Mangled), LastBackref(strlen(Mangled)) {}
 
 const char *Demangler::parseMangle(OutputString *Decl) {
   return parseMangle(Decl, this->Str);
 }
 
 char *llvm::dlangDemangle(const char *MangledName) {

llvm/unittests/Demangle/DLangDemangleTest.cpp

ExpectedVal ExpectedArray[] = {
       {"_D8demangle15__T4testVmN123Zv", "demangle.test!(-123uL)"},
       {"_D8demangle13__T4testVbi1Zv", "demangle.test!(true)"},
       {"_D8demangle13__T4testVbi0Zv", "demangle.test!(false)"},
       {"_D8demangle14__T4testVai10Zv", "demangle.test!('\\x0a')"},
       {"_D8demangle14__T4testVai32Zv", "demangle.test!(' ')"},
       {"_D8demangle14__T4testVai65Zv", "demangle.test!('A')"},
       {"_D8demangle15__T4testVai126Zv", "demangle.test!('~')"},
       {"_D8demangle16__T4testVui1000Zv", "demangle.test!('\\u03e8')"},
-      {"_D8demangle18__T4testVwi100000Zv", "demangle.test!('\\U000186a0')"}
+      {"_D8demangle18__T4testVwi100000Zv", "demangle.test!('\\U000186a0')"},
+      {"_D8demangle17__T4testVde0A8P6Zv", "demangle.test!(0x0.A8p6)"},
+      {"_D8demangle16__T4testVdeA8P2Zv", "demangle.test!(0xA.8p2)"},
+      {"_D8demangle18__T4testVdeN0A8P6Zv", "demangle.test!(-0x0.A8p6)"},
+      {"_D8demangle31__T4testVde0F6E978D4FDF3B646P7Zv",
+       "demangle.test!(0x0.F6E978D4FDF3B646p7)"},
+      {"_D8demangle15__T4testVdeNANZv", "demangle.test!(NaN)"},
+      {"_D8demangle15__T4testVdeINFZv", "demangle.test!(Inf)"},
+      {"_D8demangle16__T4testVdeNINFZv", "demangle.test!(-Inf)"},
+      {"_D8demangle23__T4testVfe0FFFFFFP128Zv",
+       "demangle.test!(0x0.FFFFFFp128)"},
+      {"_D8demangle32__T4testVde0FFFFFFFFFFFFF8P1024Zv",
+       "demangle.test!(0x0.FFFFFFFFFFFFF8p1024)"},
+      {"_D8demangle19__T4testVfe08PN125Zv", "demangle.test!(0x0.8p-125)"},
+      {"_D8demangle20__T4testVde08PN1021Zv", "demangle.test!(0x0.8p-1021)"},
+      {"_D8demangle51__T4testVrc0C4CCCCCCCCCCCCCDP4c0B666666666666666P6Zv",
+       "demangle.test!(0x0.C4CCCCCCCCCCCCCDp4+0x0.B666666666666666p6i)"},
+      {"_D8demangle52__T4testVrcN0C4CCCCCCCCCCCCCDP4c0B666666666666666P6Zv",
+       "demangle.test!(-0x0.C4CCCCCCCCCCCCCDp4+0x0.B666666666666666p6i)"},
+      {"_D8demangle91__"
+       "T4testVde000111222333444555666777888999AAABBBCCCDDDEEEFFFP0001112223334"
+       "44555666777888999Zv",
+       "demangle.test!(0x0."
+       "00111222333444555666777888999AAABBBCCCDDDEEEFFFp00011122233344455566677"
+       "7888999)"}
   };
 
   for (ExpectedVal Val : ExpectedArray) {
     char *Demangled = llvm::dlangDemangle(Val.Mangled);
     EXPECT_STREQ(Demangled, Val.Expected);
     std::free(Demangled);
   }
 }