WIP: Add error handling to demangle API

[thieta]

Summary

As discussed in https://reviews.llvm.org/D138595 - the current demangler API
can't really report more detailed errors. This is an attempt to implement
that using std::optional and std::error_code

[thieta]

@dblaikie @jhenderson This is an attempt to implement the API discussed in the other Diff using std::error_code and std::optional. Let me know what you think before I convert the rest of the methods to have similar error handling.

I also think the demangle() and nonMicrosoftDemangle() should probably follow the same API if we decide this is what we want.

[dblaikie]

llvm/lib/Demangle/Demangle.cpp

76–79

Part of what I was hoping for was that we wouldn't need an explicit isItaniumEncoding check, even inside the implementation - that Demangler::parse could produce that as a separate error result if it parsed something without the desired prefix. Would that be possible?

[jhenderson]

llvm/include/llvm/Demangle/Demangle.h

27

I generally support the use of enum class, but the enums are generally being cast to an int, so maybe that's a sign that this should just be a plain enum?

28

Nit: comments should end with "." (here and below).

53

Nit: capitalization here is inconsistent.

FWIW, the LLVM coding standards state for warning and error messages to a) start with a lower case letter, and b) not to end with a period. Whether that applies in this context is debatable.

66

I'd just overload the function name, rather than appending "WithError". The fact that it takes a std::error_code reference indicates that it will do something to that field, and it's then similar to e.g. how std::filesystem overloads function.

llvm/lib/Demangle/Demangle.cpp

76–79

Not sure if this is what @dblaikie is suggesting, but it seems to me that you could have the underlying demangling code set a status of "NotThisFormat" or similar if it encounters something with the wrong prefix type. This would enable calling code to know whether to try the next format, or just stop. That might not work so well in the face of type demangling though.

[jhenderson]

Oh, and just to mention that this week is my last week working before a 6 week break, so I may not have the time to review/comment much more on this.

[thieta]

llvm/include/llvm/Demangle/Demangle.h

27

Ideally we should change the api to not return a int status from the demangling function instead using DemangleError() - as I noted in my other comment, I was trying to preserve the old API because I thought it was wide-spread. But that doesn't seem to be the case, so I might end up just fixing that instead of making this a normal int.

53

Hmm seems like it should apply here, I will make it consistent.

66

Agreed.

llvm/lib/Demangle/Demangle.cpp

76–79

We can do that - but it becomes a little more complex and we probably need to audit all the places where the demangling functions are used now in that case.

itaninumDemangle() calls: AbstractManglingParser::parse() which returns nullptr if there is any errors, but have no status reports here.

So we could either:

1. change the AbstractManglingParser API to return the error_code from there instead. This seems possible since it's only used internally in the itaniumDemangler - it's not exposed from there (wonder why the implementation lives in a header in that case). The function also seems to be aware when it's not starting with __Z (or rather it tries to find *Z and we can probably return InvalidFormat if it doesn't). We could change this and either keep the current itaniumDemangle() function which will change the error_code to the current status int.
2. change itaniumDemangle() to do something similar to what isItaniumEncoding does. but this seems to just move the responsibility for it.

I was going to say that it's harder to change the API of itaniumDemangle since it's used "everywhere" - but that doesn't seem to be true - searching for it only seems to happen in 10 places:

https://github.com/search?q=repo%3Allvm%2Fllvm-project+itaniumDemangle%28+language%3AC%2B%2B&type=code&l=C%2B%2B

I am going to give it a try to move the logic to AbstractManglingParser to return a error_code instead and see if it can work.

[thieta]

In D139298#3973355, @jhenderson wrote:

Oh, and just to mention that this week is my last week working before a 6 week break, so I may not have the time to review/comment much more on this.

Enjoy your vacation!

[thieta]

rebased and implemented some of the suggestions.

[thieta]

Hi - I finally got around to picking this one up again. This is rebased, passing all tests and now we pass the std::error_code directly to the API and changed all the callers to itaniumDemangle() and changed most of the places to actually check the error_code instead of the return const char*.

What do you guys think about this API change? If we like this in general, I can start changing the other demangle calls, either as part of this diff or in separate diffs per demangle API.

[thieta]

llvm/include/llvm/Demangle/Demangle.h

53

I missed this - but will fix in the next revision of the patch.

llvm/tools/llvm-undname/llvm-undname.cpp

80

just a temp change until I do the microsoftDemangle api.

[MaskRay]

Adding std::error_code looks good.

This is an attempt to implement that using std::optional and std::error_code

I don't see std::optional in the patch :)

llvm/include/llvm/Demangle/Demangle.h

53

If there isn't a precedent, as mentioned, no-capitalization is preferred (https://llvm.org/docs/CodingStandards.html#error-and-warning-messages).

Also, no-capitalization makes the message easily composable with a function that appends a prefix.

[dblaikie]

Could make the error_code out parameter optional (take by pointer, populate if non-null, have a null default parameter value) - then callers who don't benefit from/care about the specific type can continue using the null pointer result signal?

llvm/lib/ProfileData/ItaniumManglingCanonicalizer.cpp

290–296

This could be changed to parse, check the error and then do the make<NameType>(StringView thing if the parse failed as invalid, maybe? (potentially in a follow-up commit)

[jhenderson]

llvm/unittests/Demangle/DemangleTest.cpp

38

Here and below, can you use EXPECT_EQ(E, DemangleError::Success) (or equivalent)? This provides nicer error messages since it gives the actual value if the two aren't the same.

41

The comment seems to be wrapped a bit early too?

Also applies below.

llvm/include/llvm/Demangle/Demangle.h

 //===--- Demangle.h ---------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEMANGLE_DEMANGLE_H
 #define LLVM_DEMANGLE_DEMANGLE_H
 
 #include <cstddef>
 #include <string>
+#include <system_error>
 
 namespace llvm {
 /// This is a llvm local version of __cxa_demangle. Other than the name and
 /// being in the llvm namespace it is identical.
 ///
 /// The mangled_name is demangled into buf and returned. If the buffer is not
 /// large enough, realloc is used to expand it.
 ///
 /// The *status will be set to a value from the following enumeration
-enum : int {
-  demangle_unknown_error = -4,
-  demangle_invalid_args = -3,
-  demangle_invalid_mangled_name = -2,
-  demangle_memory_alloc_failure = -1,
-  demangle_success = 0,
+
+const std::error_category &demangleCategory();
+
+enum class DemangleError {
+  InvalidFormat = -5, // When a specific demangler can't handle this string
+  Unknown = -4,
+  InvalidArgs = -3, // Null args or other problems with input
+  InvalidMangledName =
+      -2, // Looks like a mangled string we can handle, but can't
+  MemoryAllocFailure = -1, // Any allocation failure.
+  Success = 0,
 };
 
+class DemangleErrorCategory : public std::error_category {
+public:
+  const char *name() const noexcept override { return "llvm.demangle"; }
+  std::string message(int EV) const override {
+    switch (static_cast<llvm::DemangleError>(EV)) {
+    case llvm::DemangleError::InvalidFormat:
+      return "Invalid mangled format.";
+    case llvm::DemangleError::InvalidArgs:
+      return "Invalid arguments.";
+    case llvm::DemangleError::InvalidMangledName:
+      return "Invalid mangled name.";
+    case llvm::DemangleError::MemoryAllocFailure:
+      return "Failed to allocate memory.";
+    case llvm::DemangleError::Unknown:
+      return "Unknown error.";
+    case llvm::DemangleError::Success:
+      return "success.";
+    }
+  };
+
+  bool equivalent(const std::error_code &E, int DE) const noexcept override {
+    return *this == E.category() && static_cast<int>(E.value()) == DE;
+  }
+};
+
+inline std::error_code make_error_code(llvm::DemangleError Err) {
+  return std::error_code(static_cast<int>(Err), llvm::demangleCategory());
+}
+
+char *itaniumDemangle(const char *M, std::error_code &E);
+
 char *itaniumDemangle(const char *mangled_name, char *buf, size_t *n,
-                      int *status);
+                      std::error_code &Err);
 
 enum MSDemangleFlags {
   MSDF_None = 0,
   MSDF_DumpBackrefs = 1 << 0,
   MSDF_NoAccessSpecifier = 1 << 1,
   MSDF_NoCallingConvention = 1 << 2,
   MSDF_NoReturnType = 1 << 3,
   MSDF_NoMemberType = 1 << 4,
struct ItaniumPartialDemangler {
   ~ItaniumPartialDemangler();
 
 private:
   void *RootNode;
   void *Context;
 };
 } // namespace llvm
 
+namespace std {
+template <> struct is_error_code_enum<llvm::DemangleError> : std::true_type {};
+} // namespace std
+
 #endif

llvm/include/llvm/Demangle/ItaniumDemangle.h

 //===----------------------------------------------------------------------===//
 
 #ifndef DEMANGLE_ITANIUMDEMANGLE_H
 #define DEMANGLE_ITANIUMDEMANGLE_H
 
 #include "DemangleConfig.h"
 #include "StringView.h"
 #include "Utility.h"
+#include "Demangle.h"
 #include <algorithm>
 #include <cassert>
 #include <cctype>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <limits>
 #include <new>
 #include <type_traits>
 #include <utility>
+#include <system_error>
 
 DEMANGLE_NAMESPACE_BEGIN
 
 template <class T, size_t N> class PODSmallVector {
   static_assert(std::is_trivial_v<T>, "T is required to be a trivial type");
 
   T *First = nullptr;
   T *Last = nullptr;
template <typename Derived, typename Alloc> struct AbstractManglingParser {
   /// Parse the <unresolved-name> production.
   Node *parseUnresolvedName(bool Global);
   Node *parseSimpleId();
   Node *parseBaseUnresolvedName();
   Node *parseUnresolvedType();
   Node *parseDestructorName();
 
   /// Top-level entry point into the parser.
-  Node *parse();
+  Node *parse(std::error_code& Err);
 };
 
 const char* parse_discriminator(const char* first, const char* last);
 
 // <name> ::= <nested-name> // N
 //        ::= <local-name> # See Scope Encoding below  // Z
 //        ::= <unscoped-template-name> <template-args>
 //        ::= <unscoped-name>

 }
 
 // <mangled-name> ::= _Z <encoding>
 //                ::= <type>
 // extension      ::= ___Z <encoding> _block_invoke
 // extension      ::= ___Z <encoding> _block_invoke<decimal-digit>+
 // extension      ::= ___Z <encoding> _block_invoke_<decimal-digit>+
 template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parse() {
+Node *AbstractManglingParser<Derived, Alloc>::parse(std::error_code& Err) {
   if (consumeIf("_Z") || consumeIf("__Z")) {
     Node *Encoding = getDerived().parseEncoding();
-    if (Encoding == nullptr)
+    if (Encoding == nullptr) {
+      Err = make_error_code(DemangleError::InvalidMangledName);
       return nullptr;
+    }
     if (look() == '.') {
       Encoding = make<DotSuffix>(Encoding, StringView(First, Last));
       First = Last;
     }
-    if (numLeft() != 0)
+    if (numLeft() != 0) {
+      Err = make_error_code(DemangleError::InvalidMangledName);
       return nullptr;
+    }
     return Encoding;
   }
 
   if (consumeIf("___Z") || consumeIf("____Z")) {
     Node *Encoding = getDerived().parseEncoding();
-    if (Encoding == nullptr || !consumeIf("_block_invoke"))
+    if (Encoding == nullptr || !consumeIf("_block_invoke")) {
+      Err = make_error_code(DemangleError::InvalidMangledName);
       return nullptr;
+    }
     bool RequireNumber = consumeIf('_');
-    if (parseNumber().empty() && RequireNumber)
+    if (parseNumber().empty() && RequireNumber) {
+      Err = make_error_code(DemangleError::InvalidMangledName);
       return nullptr;
+    }
     if (look() == '.')
       First = Last;
-    if (numLeft() != 0)
+    if (numLeft() != 0) {
+      Err = make_error_code(DemangleError::InvalidMangledName);
       return nullptr;
+    }
     return make<SpecialName>("invocation function for block in ", Encoding);
   }
 
   Node *Ty = getDerived().parseType();
-  if (numLeft() != 0)
+  if (numLeft() != 0) {
+    Err = make_error_code(DemangleError::InvalidFormat);
     return nullptr;
+  }
   return Ty;
 }
 
 template <typename Alloc>
 struct ManglingParser : AbstractManglingParser<ManglingParser<Alloc>, Alloc> {
   using AbstractManglingParser<ManglingParser<Alloc>,
                                Alloc>::AbstractManglingParser;
 };
 
 DEMANGLE_NAMESPACE_END
 
 #endif // DEMANGLE_ITANIUMDEMANGLE_H

llvm/lib/Demangle/Demangle.cpp

if (char *Demangled =
     return Result;
   }
 
   return MangledName;
 }
 
 bool llvm::nonMicrosoftDemangle(const char *MangledName, std::string &Result) {
   char *Demangled = nullptr;
+  std::error_code E;
   if (isItaniumEncoding(MangledName))
-    Demangled = itaniumDemangle(MangledName, nullptr, nullptr, nullptr);
+    Demangled = itaniumDemangle(MangledName, nullptr, nullptr, E);
   else if (isRustEncoding(MangledName))
     Demangled = rustDemangle(MangledName);
   else if (isDLangEncoding(MangledName))
     Demangled = dlangDemangle(MangledName);
 
   if (!Demangled)
     return false;
 
   Result = Demangled;
   std::free(Demangled);
   return true;
 }
+
+const std::error_category &llvm::demangleCategory() {
+  static llvm::DemangleErrorCategory E;
+  return E;
+}

llvm/lib/Demangle/ItaniumDemangle.cpp

 
 //===----------------------------------------------------------------------===//
 // Code beyond this point should not be synchronized with libc++abi.
 //===----------------------------------------------------------------------===//
 
 using Demangler = itanium_demangle::ManglingParser<DefaultAllocator>;
 
 char *llvm::itaniumDemangle(const char *MangledName, char *Buf,
-                            size_t *N, int *Status) {
+                            size_t *N, std::error_code& Err) {
   if (MangledName == nullptr || (Buf != nullptr && N == nullptr)) {
-    if (Status)
-      *Status = demangle_invalid_args;
+    Err = make_error_code(DemangleError::InvalidArgs);
     return nullptr;
   }
 
-  int InternalStatus = demangle_success;
   Demangler Parser(MangledName, MangledName + std::strlen(MangledName));
-  Node *AST = Parser.parse();
+  std::error_code InternalE = make_error_code(DemangleError::Success);
+  Node *AST = Parser.parse(InternalE);
 
-  if (AST == nullptr)
-    InternalStatus = demangle_invalid_mangled_name;
-  else {
+  if (AST != nullptr) {
     OutputBuffer OB(Buf, N);
     assert(Parser.ForwardTemplateRefs.empty());
     AST->print(OB);
     OB += '\0';
     if (N != nullptr)
       *N = OB.getCurrentPosition();
     Buf = OB.getBuffer();
   }
 
-  if (Status)
-    *Status = InternalStatus;
-  return InternalStatus == demangle_success ? Buf : nullptr;
+  Err = InternalE;
+  return Err == DemangleError::Success ? Buf : nullptr;
+}
+
+char *llvm::itaniumDemangle(const char *M, std::error_code &E) {
+  return itaniumDemangle(M, nullptr, nullptr, E);
 }
 
 ItaniumPartialDemangler::ItaniumPartialDemangler()
     : RootNode(nullptr), Context(new Demangler{nullptr, nullptr}) {}
 
 ItaniumPartialDemangler::~ItaniumPartialDemangler() {
   delete static_cast<Demangler *>(Context);
 }
operator=(ItaniumPartialDemangler &&Other) {
   return *this;
 }
 
 // Demangle MangledName into an AST, storing it into this->RootNode.
 bool ItaniumPartialDemangler::partialDemangle(const char *MangledName) {
   Demangler *Parser = static_cast<Demangler *>(Context);
   size_t Len = std::strlen(MangledName);
   Parser->reset(MangledName, MangledName + Len);
-  RootNode = Parser->parse();
+  std::error_code E;
+  RootNode = Parser->parse(E);
   return RootNode == nullptr;
 }
 
 static char *printNode(const Node *RootNode, char *Buf, size_t *N) {
   OutputBuffer OB(Buf, N);
   RootNode->print(OB);
   OB += '\0';
   if (N != nullptr)

llvm/lib/Demangle/MicrosoftDemangle.cpp

if (Flags & MSDF_NoAccessSpecifier)
     OF = OutputFlags(OF | OF_NoAccessSpecifier);
   if (Flags & MSDF_NoReturnType)
     OF = OutputFlags(OF | OF_NoReturnType);
   if (Flags & MSDF_NoMemberType)
     OF = OutputFlags(OF | OF_NoMemberType);
   if (Flags & MSDF_NoVariableType)
     OF = OutputFlags(OF | OF_NoVariableType);
 
-  int InternalStatus = demangle_success;
+  int InternalStatus = (int)DemangleError::Success;
   if (D.Error)
-    InternalStatus = demangle_invalid_mangled_name;
+    InternalStatus = (int)DemangleError::InvalidMangledName;
   else {
     OutputBuffer OB(Buf, N);
     AST->output(OB, OF);
     OB += '\0';
     if (N != nullptr)
       *N = OB.getCurrentPosition();
     Buf = OB.getBuffer();
   }
 
   if (Status)
     *Status = InternalStatus;
-  return InternalStatus == demangle_success ? Buf : nullptr;
+  return InternalStatus == (int)DemangleError::Success ? Buf : nullptr;
 }

llvm/lib/ProfileData/GCOV.cpp

 // GCOVFunction implementation.
 
 StringRef GCOVFunction::getName(bool demangle) const {
   if (!demangle)
     return Name;
   if (demangled.empty()) {
     do {
       if (Name.startswith("_Z")) {
-        int status = 0;
+        std::error_code E;
         // Name is guaranteed to be NUL-terminated.
-        char *res = itaniumDemangle(Name.data(), nullptr, nullptr, &status);
-        if (status == 0) {
+        char *res = itaniumDemangle(Name.data(), nullptr, nullptr, E);
+        if (E == DemangleError::Success) {
           demangled = res;
           free(res);
           break;
         }
       }
       demangled = Name;
     } while (false);
   }

llvm/lib/ProfileData/ItaniumManglingCanonicalizer.cpp

parseMaybeMangledName(CanonicalizingDemangler &Demangler, StringRef Mangling,
   Demangler.ASTAllocator.setCreateNewNodes(CreateNewNodes);
   Demangler.reset(Mangling.begin(), Mangling.end());
   // Attempt demangling only for names that look like C++ mangled names.
   // Otherwise, treat them as extern "C" names. We permit the latter to
   // be remapped by (eg)
   //   encoding 6memcpy 7memmove
   // consistent with how they are encoded as local-names inside a C++ mangling.
   Node *N;
+  std::error_code E;
   if (Mangling.startswith("_Z") || Mangling.startswith("__Z") ||
       Mangling.startswith("___Z") || Mangling.startswith("____Z"))
-    N = Demangler.parse();
+    N = Demangler.parse(E);
   else
     N = Demangler.make<itanium_demangle::NameType>(
         StringView(Mangling.data(), Mangling.size()));
   return reinterpret_cast<ItaniumManglingCanonicalizer::Key>(N);
 }
 
 ItaniumManglingCanonicalizer::Key
 ItaniumManglingCanonicalizer::canonicalize(StringRef Mangling) {
   return parseMaybeMangledName(P->Demangler, Mangling, true);
 }
 
 ItaniumManglingCanonicalizer::Key
 ItaniumManglingCanonicalizer::lookup(StringRef Mangling) {
   return parseMaybeMangledName(P->Demangler, Mangling, false);
 }

llvm/lib/Support/Unix/Signals.inc

for (int i = 0; i < depth; ++i) {
     else
       OS << format(" %-*s", width, name + 1);
 
     OS << format(" %#0*lx", (int)(sizeof(void *) * 2) + 2,
                  (unsigned long)StackTrace[i]);
 
     if (dlinfo.dli_sname != nullptr) {
       OS << ' ';
-      int res;
-      char *d = itaniumDemangle(dlinfo.dli_sname, nullptr, nullptr, &res);
-      if (!d)
+      std::error_code E;
+      char *d = itaniumDemangle(dlinfo.dli_sname, nullptr, nullptr, E);
+      if (E != DemangleError::Success)
         OS << dlinfo.dli_sname;
       else
         OS << d;
       free(d);
 
       OS << format(" + %tu", (static_cast<const char *>(StackTrace[i]) -
                               static_cast<const char *>(dlinfo.dli_saddr)));
     }

llvm/tools/llvm-cxxfilt/llvm-cxxfilt.cpp

if (DecoratedStr[0] == '_')
       ++DecoratedStr;
 
   std::string Result;
   if (nonMicrosoftDemangle(DecoratedStr, Result))
     return Result;
 
   std::string Prefix;
   char *Undecorated = nullptr;
+  std::error_code E;
 
   if (Types)
-    Undecorated = itaniumDemangle(DecoratedStr, nullptr, nullptr, nullptr);
+    Undecorated = itaniumDemangle(DecoratedStr, E);
 
   if (!Undecorated && strncmp(DecoratedStr, "__imp_", 6) == 0) {
     Prefix = "import thunk for ";
-    Undecorated = itaniumDemangle(DecoratedStr + 6, nullptr, nullptr, nullptr);
+    Undecorated = itaniumDemangle(DecoratedStr + 6, E);
   }
 
   Result = Undecorated ? Prefix + Undecorated : Mangled;
   free(Undecorated);
   return Result;
 }
 
 // Split 'Source' on any character that fails to pass 'IsLegalChar'.  The

llvm/tools/llvm-itanium-demangle-fuzzer/llvm-itanium-demangle-fuzzer.cpp

 //===--- llvm-demangle-fuzzer.cpp - Fuzzer for the Itanium Demangler ------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Demangle/Demangle.h"
 
 #include <cstdint>
 #include <cstdlib>
 #include <string>
 
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
   std::string NullTerminatedString((const char *)Data, Size);
-  int status = 0;
-  if (char *demangle = llvm::itaniumDemangle(NullTerminatedString.c_str(), nullptr,
-                                         nullptr, &status))
+  std::error_code E;
+  if (char *demangle = llvm::itaniumDemangle(NullTerminatedString.c_str(), E))
     free(demangle);
 
   return 0;
 }

llvm/tools/llvm-objdump/MachODump.cpp

if (*ReferenceType == LLVMDisassembler_ReferenceType_In_Branch) {
     *ReferenceName = GuessIndirectSymbol(ReferenceValue, info);
     if (*ReferenceName != nullptr) {
       method_reference(info, ReferenceType, ReferenceName);
       if (*ReferenceType != LLVMDisassembler_ReferenceType_Out_Objc_Message)
         *ReferenceType = LLVMDisassembler_ReferenceType_Out_SymbolStub;
     } else if (SymbolName != nullptr && strncmp(SymbolName, "__Z", 3) == 0) {
       if (info->demangled_name != nullptr)
         free(info->demangled_name);
-      int status;
+      std::error_code E;
       info->demangled_name =
-          itaniumDemangle(SymbolName + 1, nullptr, nullptr, &status);
+          itaniumDemangle(SymbolName + 1, E);
       if (info->demangled_name != nullptr) {
         *ReferenceName = info->demangled_name;
         *ReferenceType = LLVMDisassembler_ReferenceType_DeMangled_Name;
       } else
         *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None;
     } else
       *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None;
   } else if (*ReferenceType == LLVMDisassembler_ReferenceType_In_PCrel_Load) {
else if (info->O->getArch() == Triple::aarch64 &&
             *ReferenceType == LLVMDisassembler_ReferenceType_In_ARM64_ADR)) {
     *ReferenceName =
         GuessLiteralPointer(ReferenceValue, ReferencePC, ReferenceType, info);
     if (*ReferenceName == nullptr)
       *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None;
   } else if (SymbolName != nullptr && strncmp(SymbolName, "__Z", 3) == 0) {
     if (info->demangled_name != nullptr)
       free(info->demangled_name);
-    int status;
+    std::error_code E;
     info->demangled_name =
-        itaniumDemangle(SymbolName + 1, nullptr, nullptr, &status);
+        itaniumDemangle(SymbolName + 1, E);
     if (info->demangled_name != nullptr) {
       *ReferenceName = info->demangled_name;
       *ReferenceType = LLVMDisassembler_ReferenceType_DeMangled_Name;
     }
   }
   else {
     *ReferenceName = nullptr;
     *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None;

llvm/tools/llvm-opt-report/OptReport.cpp

for (line_iterator LI(*Buf.get(), false); LI != line_iterator(); ++LI) {
           for (const auto &FuncName : FuncNameSet) {
             if (FirstFunc)
               FirstFunc = false;
             else
               OS << ", ";
 
             bool Printed = false;
             if (!NoDemangle) {
-              int Status = 0;
+              std::error_code E;
               char *Demangled =
-                itaniumDemangle(FuncName.c_str(), nullptr, nullptr, &Status);
-              if (Demangled && Status == 0) {
+                itaniumDemangle(FuncName.c_str(), E);
+              if (Demangled && E == DemangleError::Success) {
                 OS << Demangled;
                 Printed = true;
               }
 
               if (Demangled)
                 std::free(Demangled);
             }
 

llvm/tools/llvm-undname/llvm-undname.cpp

static bool msDemangle(const std::string &S) {
   if (NoMemberType)
     Flags = MSDemangleFlags(Flags | MSDF_NoMemberType);
   if (NoVariableType)
     Flags = MSDemangleFlags(Flags | MSDF_NoVariableType);
 
   size_t NRead;
   char *ResultBuf =
       microsoftDemangle(S.c_str(), &NRead, nullptr, nullptr, &Status, Flags);
-  if (Status == llvm::demangle_success) {
+  if (Status == 0) {
     outs() << ResultBuf << "\n";
     outs().flush();
     if (WarnTrailing && NRead < S.size())
       WithColor::warning() << "trailing characters: " << S.c_str() + NRead
                            << "\n";
   } else {
     WithColor::error() << "Invalid mangled name\n";
   }
   std::free(ResultBuf);
-  return Status == llvm::demangle_success;
+  return Status == 0;
 }
 
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
 
   cl::HideUnrelatedOptions({&UndNameCategory, &getColorCategory()});
   cl::ParseCommandLineOptions(argc, argv, "llvm-undname\n");
 

llvm/unittests/Demangle/DemangleTest.cpp

 //===-- DemangleTest.cpp --------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Demangle/Demangle.h"
 #include "gmock/gmock.h"
+#include <system_error>
 
 using namespace llvm;
 
 TEST(Demangle, demangleTest) {
   EXPECT_EQ(demangle("_"), "_");
   EXPECT_EQ(demangle("_Z3fooi"), "foo(int)");
   EXPECT_EQ(demangle("__Z3fooi"), "foo(int)");
   EXPECT_EQ(demangle("___Z3fooi_block_invoke"),
             "invocation function for block in foo(int)");
   EXPECT_EQ(demangle("____Z3fooi_block_invoke"),
             "invocation function for block in foo(int)");
   EXPECT_EQ(demangle("?foo@@YAXH@Z"), "void __cdecl foo(int)");
   EXPECT_EQ(demangle("foo"), "foo");
   EXPECT_EQ(demangle("_RNvC3foo3bar"), "foo::bar");
   EXPECT_EQ(demangle("__RNvC3foo3bar"), "foo::bar");
   EXPECT_EQ(demangle("_Dmain"), "D main");
 
   // Regression test for demangling of optional template-args for vendor
   // extended type qualifier (https://bugs.llvm.org/show_bug.cgi?id=48009)
   EXPECT_EQ(demangle("_Z3fooILi79EEbU7_ExtIntIXT_EEi"),
             "bool foo<79>(int _ExtInt<79>)");
 }
+
+TEST(Demangle, demangleWithError) {
+  std::error_code E;
+  EXPECT_TRUE(itaniumDemangle("_Z3fooi", E));
+  EXPECT_TRUE(E == DemangleError::Success);
+
+  // A string that shouldn't be handled by this demangler
+  // should return InvaildFormat
+  EXPECT_FALSE(itaniumDemangle("_", E));
+  EXPECT_TRUE(E == DemangleError::InvalidFormat);
+
+  // A string that should be handled by this demangler
+  // but is broken should return InvalidMangledNamed
+  EXPECT_FALSE(itaniumDemangle("_Z3fooBroken@Y", E));
+  EXPECT_TRUE(E == DemangleError::InvalidMangledName);
+}

llvm/unittests/Demangle/ItaniumDemangleTest.cpp

struct TestParser : AbstractManglingParser<TestParser, TestAllocator> {
 
     Node *parseType() {
       Types.push_back(*First);
       return AbstractManglingParser<TestParser, TestAllocator>::parseType();
     }
   };
 
   TestParser Parser("_Z1fIiEjl");
-  ASSERT_NE(nullptr, Parser.parse());
+  std::error_code E;
+  ASSERT_NE(nullptr, Parser.parse(E));
   EXPECT_THAT(Parser.Types, testing::ElementsAre('i', 'j', 'l'));
 }
 
 static std::string toString(OutputBuffer &OB) {
   StringView SV = OB;
   return {SV.begin(), SV.end()};
 }
 
Node *parseType() {
         Types.push_back(toString(OB));
       std::free(OB.getBuffer());
       return N;
     }
   };
 
   // void f(A<_Float16>, _Float16);
   TestParser Parser("_Z1f1AIDF16_EDF16_");
-  ASSERT_NE(nullptr, Parser.parse());
+  std::error_code E;
+  ASSERT_NE(nullptr, Parser.parse(E));
   EXPECT_THAT(Parser.Types, testing::ElementsAre("_Float16", "A", "_Float16"));
 }