[demangler] Support the new Rust mangling scheme (v0)

[tmiasko]

Summary

This patch implements a demangling support for symbols using new Rust
mangling scheme (v0).

The Rust is currently migrating to this new scheme. The progress is
tracked in https://github.com/rust-lang/rust/issues/60705.

• The v0 mangling scheme uses "_R" as a prefix, which makes it easy to distinguish it from other mangling schemes.

• The public API is modeled after __cxa_demangle / llvm::itaniumDemangle, since potential candidates for further integration use those.

• The llvm-cxxfilt is extended to support Rust mangling and used to test the implementation.

References (specification and relevant parts of implementation in Rust):

• https://rust-lang.github.io/rfcs/2603-rust-symbol-name-mangling-v0.html
• https://github.com/rust-lang/rust/pull/57967
• https://github.com/rust-lang/rust/pull/77554

[tmiasko]

...

[jhenderson]

If you are looking for a full review of this, try adding specific people as reviewers who have worked on the demangling library. It would also make sense to split this change up into lots of small parts. For example, you could implement a small subset of the Rust demangling scheme, in a first patch, and expand on it in a series of subsequent patches. That'll make each patch easier to review. Connecting it up to llvm-cxxfilt could also be a separate patch from implementing the demangling code.

llvm/test/tools/llvm-cxxfilt/rust.test

1 ↗

(On Diff #335675)

llvm-cxxfilt tool tests are not the place to test the full library functionality. - that should be tested in the unittests. This test should contain just enough to cover the behaviour implemented in llvm-cxxfilt itself.

[dblaikie]

In D99981#2701057, @jhenderson wrote:

If you are looking for a full review of this, try adding specific people as reviewers who have worked on the demangling library. It would also make sense to split this change up into lots of small parts. For example, you could implement a small subset of the Rust demangling scheme, in a first patch, and expand on it in a series of subsequent patches. That'll make each patch easier to review. Connecting it up to llvm-cxxfilt could also be a separate patch from implementing the demangling code.

+1 to all that - incremental patches would probably help here

llvm/test/tools/llvm-cxxfilt/rust.test

1 ↗

(On Diff #335675)

I'd disagree here - generally if there's a fairly simple/thin wrapper around a library, we do test it via lit/command line tests rather than unit tests. And that seems to be how llvm-cxxfilt/Demangle is tested currently (most cases seem to be tested in llvm/test/tools/llvm-cxxfilt, some in llvm/test/Demangle (using llvm-cxxfilt), but not much is tested in llvm/unittests/Demangle.

[jhenderson]

llvm/test/tools/llvm-cxxfilt/rust.test

1 ↗

(On Diff #335675)

Not sure I agree with that characterisation. With the exception of the abitag.test test in tools/llvm-cxxfilt, the tests are all primarily testing llvm-cxxfilt level functionality (indirectly some exercise parts of the demangling code too, but I think that's not their purpose).

I don't mind if it makes sense to test things at a lit level, but they should at least be in llvm/test/Demangle. That being said, a unit test invocation for this should simpler than writing a lit test. See for example DemangleTest.cpp, where each case is a single line - a lit test case would require at least two process executions (llvm-cxxfilt and FileCheck), and a FileCheck CHECK pattern, so will inevitably longer. Anecdotally, I also feel like it would be easier to make mistakes in the lit test, although that could be resolved relatively easily by using the right FileCheck flags.

[dblaikie]

llvm/test/tools/llvm-cxxfilt/rust.test

1 ↗

(On Diff #335675)

Taking a more detailed look - only looking at itanium manglings since I know how to grep for them easily enough (_Z):

unittests/Demangle/DemangleTest.cpp: 5 mangled names/demanglings
unittests/Demangle/ItaniumDemangleTest.cpp: 1 (presumably a test of API syntax/ergonomics, not of the demangling algorithm)
unittests/Demangle/PartialDemangleTest.cpp: 38 - this is an API designed for novel programmatic use (we use it inside Google for rewriting certain mangled names efficiently for profile matching when core library symbol names change for whatever reason)
test/Demangle: Only contain Microsoft demangling test cases (using llvm-undname, the MS equivalent of llvm-cxxfilt)
test/tools/llvm-cxxfilt: 56 (well, more, since several tests have more than one mangled name per line) mangled names

And especially llvm/test/tools/llvm-cxxfilt/delimiters.test seems to be the most comprehensive piece of demangler algorithm testing, for instance.

The first testing when the library was introduced was done with llvm-cxxfilt ( rGb940b66c6032096d40dfd1859e2598749a30378c ), not a unit test (& that test was initially in llvm/test/Demangle, though it got moved to llvm/tools/llvm-cxxfilt in rG7091820a969ed3503806e28dae371d1b11a9da6d )

This is generally true of LLVM testing - if there's a convenient command line wrapper around the functionality, then lit testing tends to be the focus. (see symbolizer, dwarfdump, objdump, etc)

[jhenderson]

llvm/test/tools/llvm-cxxfilt/rust.test

1 ↗

(On Diff #335675)

We could go back and forth on this a while, I feel.

delimiters.test may have multiple manglings, but the demangling behaviour isn't what's being tested in that test. The purpose of that test is to ensure that the right non-alphanumeric characters act as a delimiter between two character sequences for llvm-cxxfilt's demangling process (see rG5cd5f8f2563395f8767f94604eb4c4bea8dcbea0 where it was introduced). Note that actually it's the same very simple mangled name that is demangled in every case. This behaviour is entirely within the llvm-cxxfilt tool code, not the library code.

There are similar stories for most of the other tests in tools/llvm-cxxfilt too. In general, it looks like there is very little dedicated testing of the Itanium demangler code, which is probably part of the problem here.

In other GNU binutils replacements, we try to ensure tests that are testing the underlying library code are in test/<library name> rather than test/tool/<tool name>. It's not perfect, but it has been a goal. The idea is that developers of a library that is used by multliple tools can find the tests for that library without having to go through potentially multiple different test/tool/ directories. It also helps the test directory structure reflect the llvm code structure better. Example: if I made a change to a Support class, I'd usually add my test to test/Support, if unit tests aren't viable.

This is generally true of LLVM testing - if there's a convenient command line wrapper around the functionality, then lit testing tends to be the focus. (see symbolizer, dwarfdump, objdump, etc)

If I understand it correctly, this is partly for legacy reasons - unit tests haven't been around in LLVM for all that long, so people use what they are used to. It's also because it's often easier to write the lit test than it is to get the setup right for a unit test, which is perfectly reasonable to me. That being said, I'm not opposed to using lit tests instead of unit tests, if the developer prefers (as long as the lit tests are in the right place), although it's worth pointing out that if this patch were to be split up, llvm-cxxfilt support would probably belong in a separate patch, and therefore testing would HAVE to be put into the unit tests.

Maybe I'm not reflecting the wider LLVM view? Should this be brought up on llvm-dev?

[dblaikie]

Figured I'd move this out of line (so it isn't narrowed to half the screen width):

We could go back and forth on this a while, I feel.

delimiters.test may have multiple manglings, but the demangling behaviour isn't what's being tested in that test. The purpose of that test is to ensure that the right non-alphanumeric characters act as a delimiter between two character sequences for llvm-cxxfilt's demangling process (see rG5cd5f8f2563395f8767f94604eb4c4bea8dcbea0 where it was introduced). Note that actually it's the same very simple mangled name that is demangled in every case. This behaviour is entirely within the llvm-cxxfilt tool code, not the library code.

Fair point - sorry I missed that detail.

There are similar stories for most of the other tests in tools/llvm-cxxfilt too. In general, it looks like there is very little dedicated testing of the Itanium demangler code, which is probably part of the problem here.

Yep

In other GNU binutils replacements, we try to ensure tests that are testing the underlying library code are in test/<library name> rather than test/tool/<tool name>. It's not perfect, but it has been a goal. The idea is that developers of a library that is used by multliple tools can find the tests for that library without having to go through potentially multiple different test/tool/ directories. It also helps the test directory structure reflect the llvm code structure better. Example: if I made a change to a Support class, I'd usually add my test to test/Support, if unit tests aren't viable.

Yep, with you there with regard to putting tests in the right directory. (except the last bit, as I'm more "unit tests when lit tests aren't viable (including significant ambiguity - if the functionality is used in a bunch of different places/ways)")

This is generally true of LLVM testing - if there's a convenient command line wrapper around the functionality, then lit testing tends to be the focus. (see symbolizer, dwarfdump, objdump, etc)

If I understand it correctly, this is partly for legacy reasons - unit tests haven't been around in LLVM for all that long, so people use what they are used to.

It was/is a fairly intentional choice (in part Chris Lattner was not a fan of unit tests in general (one of the funnier examples: https://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20130819/185033.html )) - unit tests for code that has a lot of out-of-tree API usage, or just a lot of varied usage internally (like ADTs, in both counts) is worth unit testing. But something with a fairly specific use case/pretty thin mapping to a command line tool (like optimizations - the opt tool testing of middle end optimizations, symbolizing - llvm-symbolizer's such a basic wrapper around that functionality that we test the interesting parts of the algorithm that way and only use unit tests for the interesting parts of the API usage)

I mean, the gunit code & has been in-tree since 2008, so it's not exactly new.

It's also because it's often easier to write the lit test than it is to get the setup right for a unit test, which is perfectly reasonable to me. That being said, I'm not opposed to using lit tests instead of unit tests, if the developer prefers (as long as the lit tests are in the right place),

I have slightly stronger feelings that this is a community norm that I think is good to reinforce/encourage as a matter of uniformity across the project.

Fair point about where the tests go - they do get a bit chaotic - llvm-symbolizer/libDebugInfoDWARF symbolizing functionality tests are split pretty well between llvm/test/DebugInfo and llvm/test/tools/llvm-symbolizer. Not the end of the world, but good to try to improve consistency in this regard.

although it's worth pointing out that if this patch were to be split up, llvm-cxxfilt support would probably belong in a separate patch, and therefore testing would HAVE to be put into the unit tests.

Actually I'd favor splitting it the other way - adding the llvm-cxxfilt support first (with a no-op or trivial example working) then adding new demangling functionality in incremental patches adding more lit tests to it. It's not uncommon to add features to command line tools (like llvm-symbolizer) partly to exercise an otherwise API-only feature

Maybe I'm not reflecting the wider LLVM view?

That's my take on it/why I chimed in.

Should this be brought up on llvm-dev?

If you like - I think the source tree and kinds of test we mostly write on a regular basis shows the norms here.

[tmiasko]

Reduce scope of changes

Remove punycode support.
Remove fuzzer.
Remove llvm::Demangle integration.
Move tests to llvm/test/Demangle.

[jhenderson]

In D99981#2713815, @dblaikie wrote:

Yep, with you there with regard to putting tests in the right directory. (except the last bit, as I'm more "unit tests when lit tests aren't viable (including significant ambiguity - if the functionality is used in a bunch of different places/ways)")

Fair enough.

If I understand it correctly, this is partly for legacy reasons - unit tests haven't been around in LLVM for all that long, so people use what they are used to.

It was/is a fairly intentional choice (in part Chris Lattner was not a fan of unit tests in general (one of the funnier examples: https://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20130819/185033.html )) - unit tests for code that has a lot of out-of-tree API usage, or just a lot of varied usage internally (like ADTs, in both counts) is worth unit testing. But something with a fairly specific use case/pretty thin mapping to a command line tool (like optimizations - the opt tool testing of middle end optimizations, symbolizing - llvm-symbolizer's such a basic wrapper around that functionality that we test the interesting parts of the algorithm that way and only use unit tests for the interesting parts of the API usage)

I mean, the gunit code & has been in-tree since 2008, so it's not exactly new.

Guess I didn't understand correctly! Thanks.

Actually I'd favor splitting it the other way - adding the llvm-cxxfilt support first (with a no-op or trivial example working) then adding new demangling functionality in incremental patches adding more lit tests to it. It's not uncommon to add features to command line tools (like llvm-symbolizer) partly to exercise an otherwise API-only feature

Fine by me.

@tmiasko, I think the minimal functionality @dblaikie is suggesting would be something like implementing the bare minimal support for demangling something like _RC3foo (assuming that's a valid mangling). That allows you to have the llvm-cxxfilt code and a test file in place. Then in multiple subsequent patches, you gradually expand the functionality to cover other manglings.

llvm/lib/Demangle/RustDemangle.cpp

25–29

FWIW, I don't think there's a way to test this block without unit-testing, but I'm fine if the bulk wants to be in the lit tests. Same goes with a number of the other potential failure paths.

[dblaikie]

In D99981#2716079, @jhenderson wrote:

In D99981#2713815, @dblaikie wrote:

Yep, with you there with regard to putting tests in the right directory. (except the last bit, as I'm more "unit tests when lit tests aren't viable (including significant ambiguity - if the functionality is used in a bunch of different places/ways)")

Fair enough.

If I understand it correctly, this is partly for legacy reasons - unit tests haven't been around in LLVM for all that long, so people use what they are used to.

It was/is a fairly intentional choice (in part Chris Lattner was not a fan of unit tests in general (one of the funnier examples: https://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20130819/185033.html )) - unit tests for code that has a lot of out-of-tree API usage, or just a lot of varied usage internally (like ADTs, in both counts) is worth unit testing. But something with a fairly specific use case/pretty thin mapping to a command line tool (like optimizations - the opt tool testing of middle end optimizations, symbolizing - llvm-symbolizer's such a basic wrapper around that functionality that we test the interesting parts of the algorithm that way and only use unit tests for the interesting parts of the API usage)

I mean, the gunit code & has been in-tree since 2008, so it's not exactly new.

Guess I didn't understand correctly! Thanks.

Actually I'd favor splitting it the other way - adding the llvm-cxxfilt support first (with a no-op or trivial example working) then adding new demangling functionality in incremental patches adding more lit tests to it. It's not uncommon to add features to command line tools (like llvm-symbolizer) partly to exercise an otherwise API-only feature

Fine by me.

@tmiasko, I think the minimal functionality @dblaikie is suggesting would be something like implementing the bare minimal support for demangling something like _RC3foo (assuming that's a valid mangling). That allows you to have the llvm-cxxfilt code and a test file in place. Then in multiple subsequent patches, you gradually expand the functionality to cover other manglings.

Yep, something along those lines.

llvm/lib/Demangle/RustDemangle.cpp

25–29

Yeah, API usage issues like this should be exercised by a unit test.

Though I wonder if it might be simpler to not support this and instead assert that the parameters are non-null as needed, rather than that the caller would get some error handling result.

[tmiasko]

Thanks for suggestions @dblaikie, @jhenderson. I will create a separate preparatory patch that should be easier to a review.

llvm/lib/Demangle/RustDemangle.cpp

25–29

The main motivation behind the current API choice was to facilitate further integration. Places where I would like to eventually support Rust demangling use itaniumDemangle for the most part, so I settled on the same API. The microsoftDemangle has similar API as well.

This API does unfortunately require a bit of extra code and unit tests to cover it (tests are in RustDemangleTest.cpp).

[dblaikie]

llvm/lib/Demangle/RustDemangle.cpp

25–29

Ah, fair enough.

The existing API also has some quirky memory management which is unfortunate (passing in malloc'd memory and reallocing, etc, internally) - but such is life.

[tmiasko]

For the record, support for Rust mangling scheme landed in:

• D101444
• D101821
• D101823
• D102142
• D102179
• D102518
• D102524
• D102549
• D102571
• D102573
• D102578
• D102579
• D102580
• D102581
• D102729
• D103151
• D103361
• D103364
• D103459
• D103460
• D103847
• D103848
• D104340
• D104358

With the only remaining part being a support for non-ASCII identifiers in D104366.

Thanks for review David!

[dblaikie]

In D99981#2837256, @tmiasko wrote:

For the record, support for Rust mangling scheme landed in:

• D101444
• D101821
• D101823
• D102142
• D102179
• D102518
• D102524
• D102549
• D102571
• D102573
• D102578
• D102579
• D102580
• D102581
• D102729
• D103151
• D103361
• D103364
• D103459
• D103460
• D103847
• D103848
• D104340
• D104358

With the only remaining part being a support for non-ASCII identifiers in D104366.

Thanks for review David!

Awesome - thanks for your patience/all the patches & tests. I do have D104366 in my queue, it's just taking me a while longer to get the time to focus on it and understand punycode encoding enough to check over the implementation, etc.

llvm/include/llvm/Demangle/Demangle.h

 /// *n_buf stores the size of buf on input if buf is non-nullptr, and it
 /// receives the size of the demangled string on output if n_buf is not nullptr.
 /// status receives one of the demangle_ enum entries above if it's not nullptr.
 /// Flags controls various details of the demangled representation.
 char *microsoftDemangle(const char *mangled_name, size_t *n_read,
                         char *buf, size_t *n_buf,
                         int *status, MSDemangleFlags Flags = MSDF_None);
 
+// Demangles a Rust v0 mangled symbol. The API follows that of __cxa_demangle.
+char *rustDemangle(const char *MangledName, char *Buf, size_t *N, int *Status);
+
 /// Attempt to demangle a string using different demangling schemes.
 /// The function uses heuristics to determine which demangling scheme to use.
 /// \param MangledName - reference to string to demangle.
 /// \returns - the demangled string, or a copy of the input string if no
 /// demangling occurred.
 std::string demangle(const std::string &MangledName);
 
 /// "Partial" demangler. This supports demangling a string into an AST

llvm/include/llvm/Demangle/RustDemangle.h

+//===--- RustDemangle.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_RUSTDEMANGLE_H
+#define LLVM_DEMANGLE_RUSTDEMANGLE_H
+
+#include "llvm/Demangle/DemangleConfig.h"
+#include "llvm/Demangle/StringView.h"
+#include "llvm/Demangle/Utility.h"
+
+namespace llvm {
+namespace rust_demangle {
+
+using llvm::itanium_demangle::OutputStream;
+using llvm::itanium_demangle::StringView;
+
+struct Identifier {
+  StringView Name;
+  bool Punycode;
+
+  bool empty() const { return Name.empty(); }
+};
+
+class Demangler {
+  // Enables more verbose output that includes crate hashes and const types.
+  const bool Verbose;
+
+  // Maximum recursion level, used to avoid stack overflow.
+  const size_t MaxRecursionLevel;
+  size_t RecursionLevel;
+
+  // Input string that is being demangled (without "_R" prefix if any).
+  StringView Input;
+  // Position in the input string.
+  size_t Position;
+
+  size_t BoundLifetimes;
+
+  // When true print methods append the output to the Demangled string.
+  // When false the output is suppressed.
+  bool Print;
+
+  // True if an error occurred.
+  bool Error;
+
+public:
+  // Demangled output.
+  OutputStream Output;
+
+  Demangler(bool Verbose_ = false, size_t MaxRecursionLevel_ = 500);
+
+  bool demangle(const char *Mangled, size_t MangledLen);
+
+private:
+  bool demanglePath(bool InValue, bool LeaveOpen = false);
+  void demangleImplPath(bool InValue);
+  void demangleType();
+  void demangleFnSig();
+  void demangleBinder();
+  void demangleDynTrait();
+  void demangleGenericArg();
+  void demangleConst();
+  void demangleConstInt(const bool IsSigned);
+  void demangleConstBool();
+  void demangleConstChar();
+
+  template <typename Callable> void demangleBackRef(Callable Demangler) {
+    const uint64_t BackRef = parseBase62Number();
+    if (Error || BackRef >= Position) {
+      Error = true;
+      return;
+    }
+
+    if (!Print)
+      return;
+
+    const size_t SavedPosition = Position;
+    Position = BackRef;
+    Demangler();
+    Position = SavedPosition;
+  }
+
+  template <typename Callable> void withBinder(Callable Demangler) {
+    const auto SavedBoundLifetimes = BoundLifetimes;
+    demangleBinder();
+    Demangler();
+    BoundLifetimes = SavedBoundLifetimes;
+  }
+
+  template <typename Callable>
+  void withPrint(const bool NewPrint, Callable Demangler) {
+    const auto SavedPrint = Print;
+    Print = NewPrint;
+    Demangler();
+    Print = SavedPrint;
+  }
+
+  Identifier parseIdentifier();
+  uint64_t parseHexNumber(StringView &HexDigits);
+  uint64_t parseOptionalBase62Number(char Tag);
+  uint64_t parseBase62Number();
+  uint64_t parseDecimalNumber();
+
+  void printLifetime(const uint64_t Index);
+  void printDecimalNumber(uint64_t N);
+  void printHexNumber(uint64_t N);
+  void printIdentifier(Identifier Ident);
+
+  void print(StringView S) {
+    if (Error || !Print)
+      return;
+
+    Output += S;
+  }
+
+  void printChar(char C) {
+    if (Error || !Print)
+      return;
+
+    Output += C;
+  }
+
+  bool consumeIf(char Prefix) {
+    if (Error || Position >= Input.size() || Input[Position] != Prefix)
+      return false;
+
+    Position += 1;
+    return true;
+  }
+
+  char consume() {
+    if (Error || Position >= Input.size()) {
+      Error = true;
+      return 0;
+    }
+
+    return Input[Position++];
+  }
+
+  char look() const {
+    if (Error || Position >= Input.size())
+      return 0;
+
+    return Input[Position];
+  }
+};
+
+} // namespace rust_demangle
+} // namespace llvm
+
+#endif

llvm/lib/Demangle/CMakeLists.txt

 add_llvm_component_library(LLVMDemangle
   Demangle.cpp
   ItaniumDemangle.cpp
   MicrosoftDemangle.cpp
   MicrosoftDemangleNodes.cpp
+  RustDemangle.cpp
 
   ADDITIONAL_HEADER_DIRS
   "${LLVM_MAIN_INCLUDE_DIR}/llvm/Demangle"
 
 )

llvm/lib/Demangle/RustDemangle.cpp

+//===--- RustDemangle.cpp ---------------------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines a demangler for Rust v0 mangled symbols.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Demangle/RustDemangle.h"
+#include "llvm/Demangle/Demangle.h"
+
+#include <cassert>
+#include <cstring>
+#include <limits>
+
+using namespace llvm;
+using namespace rust_demangle;
+
+char *llvm::rustDemangle(const char *MangledName, char *Buf, size_t *N,
+                         int *Status) {
+  if (MangledName == nullptr || (Buf != nullptr && N == nullptr)) {
+    if (Status != nullptr)
+      *Status = demangle_invalid_args;
+    return nullptr;
+  }
+
+  // Return early if mangled name doesn't look like a Rust symbol.
+  if (MangledName[0] != '_' || MangledName[1] != 'R') {
+    if (Status != nullptr)
+      *Status = demangle_invalid_mangled_name;
+    return nullptr;
+  }
+
+  Demangler D;
+  // The user provided buffer cannot be used as an output stream since
+  // demangling could fail and in that case the user provided buffer must not
+  // be reallocated.
+  if (!initializeOutputStream(nullptr, nullptr, D.Output, 1024)) {
+    if (Status != nullptr)
+      *Status = demangle_memory_alloc_failure;
+    return nullptr;
+  }
+
+  if (!D.demangle(MangledName, strlen(MangledName))) {
+    if (Status != nullptr)
+      *Status = demangle_invalid_mangled_name;
+    std::free(D.Output.getBuffer());
+    return nullptr;
+  }
+
+  D.Output += '\0';
+  char *Demangled = D.Output.getBuffer();
+  const size_t DemangledLen = D.Output.getCurrentPosition();
+
+  if (Buf != nullptr) {
+    if (DemangledLen <= *N) {
+      std::memcpy(Buf, Demangled, DemangledLen);
+      std::free(Demangled);
+      Demangled = Buf;
+    } else {
+      std::free(Buf);
+    }
+  }
+
+  if (N != nullptr)
+    *N = DemangledLen;
+
+  if (Status != nullptr)
+    *Status = demangle_success;
+
+  return Demangled;
+}
+
+Demangler::Demangler(bool Verbose_, size_t MaxRecursionLevel_)
+    : Verbose(Verbose_), MaxRecursionLevel(MaxRecursionLevel_) {}
+
+static inline bool isDigit(const char C) { return '0' <= C && C <= '9'; }
+
+static inline bool isLower(const char C) { return 'a' <= C && C <= 'z'; }
+
+static inline bool isUpper(const char C) { return 'A' <= C && C <= 'Z'; }
+
+static inline bool isBasic(const char C) {
+  return isDigit(C) || isLower(C) || isUpper(C) || C == '_';
+}
+
+/// Returns true if C starts a <path>.
+static inline bool isPath(const char C) {
+  switch (C) {
+  case 'C':
+  case 'M':
+  case 'X':
+  case 'Y':
+  case 'N':
+  case 'I':
+  case 'B':
+    return true;
+  default:
+    return false;
+  }
+}
+
+// Parses Rust v0 mangled symbol. Returns true when successful, and false
+// otherwise. The demangled symbol is stored in Output field. It is
+// responsibility of the caller to free the memory behind the output stream.
+//
+// <symbol-name> = "_R" [<decimal-number>] <path> [<instantiating-crate>]
+bool Demangler::demangle(const char *Mangled, size_t MangledLength) {
+  Input = StringView(Mangled, MangledLength);
+  Position = 0;
+  Error = false;
+  Print = true;
+  BoundLifetimes = 0;
+  RecursionLevel = 0;
+
+  // Back references are relative to the end of "_R" prefix. Remove the prefix
+  // from the input to avoid having to adjust back references later on.
+  if (!Input.consumeFront("_R")) {
+    Error = true;
+    return false;
+  }
+
+  // A presence of a version number indicates a mangling we do not support yet.
+  if (isDigit(look())) {
+    Error = true;
+    return false;
+  }
+
+  demanglePath(true /* InValue */);
+
+  if (isPath(look()))
+    withPrint(false, [&] { demanglePath(false /* InValue */); });
+
+  // An extension allowing an arbitrary dot suffix.
+  if (consumeIf('.')) {
+    const auto Suffix = Input.substr(Position);
+    Position += Suffix.size();
+    print(" (");
+    print(Suffix);
+    print(")");
+  }
+
+  if (Position != Input.size())
+    Error = true;
+
+  return !Error;
+}
+
+// Demangles a path. InValue indicates that the path is inside a value
+// namespace, where it may need to be formatter differently. LeaveOpen will
+// omit a closing `>` after generic arguments. Return value indicates whether
+// generics arguments have been left open.
+//
+// <path> = "C" <identifier>               // crate root
+//        | "M" <impl-path> <type>         // <T> (inherent impl)
+//        | "X" <impl-path> <type> <path>  // <T as Trait> (trait impl)
+//        | "Y" <type> <path>              // <T as Trait> (trait definition)
+//        | "N" <ns> <path> <identifier>   // ...::ident (nested path)
+//        | "I" <path> {<generic-arg>} "E" // ...<T, U> (generic args)
+//        | <backref>
+// <identifier> = [<disambiguator>] <undisambiguated-identifier>
+bool Demangler::demanglePath(bool InValue, bool LeaveOpen) {
+  if (Error || RecursionLevel >= MaxRecursionLevel) {
+    Error = true;
+    return false;
+  }
+  RecursionLevel += 1;
+  bool IsOpen = false;
+
+  switch (consume()) {
+  case 'C': {
+    const uint64_t Disambiguator = parseOptionalBase62Number('s');
+    Identifier Ident = parseIdentifier();
+    printIdentifier(Ident);
+    if (Verbose) {
+      print("[");
+      printHexNumber(Disambiguator);
+      print("]");
+    }
+    break;
+  }
+  case 'M': {
+    withPrint(false, [&] { demangleImplPath(InValue); });
+    print("<");
+    demangleType();
+    print(">");
+    break;
+  }
+  case 'X': {
+    withPrint(false, [&] { demangleImplPath(InValue); });
+    print("<");
+    demangleType();
+    print(" as ");
+    demanglePath(false /* InValue */);
+    print(">");
+    break;
+  }
+  case 'Y':
+    print("<");
+    demangleType();
+    print(" as ");
+    demanglePath(false /* InValue */);
+    print(">");
+    break;
+  case 'N': {
+    const char NS = consume();
+    if (!isLower(NS) && !isUpper(NS)) {
+      Error = true;
+      break;
+    }
+    demanglePath(InValue);
+
+    const uint64_t Disambiguator = parseOptionalBase62Number('s');
+    Identifier Ident = parseIdentifier();
+
+    if (isUpper(NS)) {
+      // Special namespaces.
+      print("::{");
+      if (NS == 'C')
+        print("closure");
+      else if (NS == 'S')
+        print("shim");
+      else
+        printChar(NS);
+
+      if (!Ident.empty()) {
+        print(":");
+        printIdentifier(Ident);
+      }
+      printChar('#');
+      printDecimalNumber(Disambiguator);
+      print("}");
+    } else {
+      // Implementation internal disambiguation category. Namespace is
+      // omitted from the output.
+      if (!Ident.empty()) {
+        print("::");
+        printIdentifier(Ident);
+      }
+    }
+    break;
+  }
+  case 'I': {
+    demanglePath(InValue);
+
+    if (InValue)
+      print("::");
+
+    print("<");
+    for (size_t I = 0; !Error && !consumeIf('E'); ++I) {
+      if (I >= 1)
+        print(", ");
+      demangleGenericArg();
+    }
+    if (LeaveOpen)
+      IsOpen = true;
+    else
+      print(">");
+    break;
+  }
+  case 'B':
+    demangleBackRef([&] { IsOpen = demanglePath(InValue, LeaveOpen); });
+    break;
+  default:
+    Error = true;
+    break;
+  }
+
+  RecursionLevel -= 1;
+  return IsOpen;
+}
+
+// <impl-path> = [<disambiguator>] <path>
+// <disambiguator> = "s" <base-62-number>
+void Demangler::demangleImplPath(bool InValue) {
+  parseOptionalBase62Number('s');
+  demanglePath(InValue);
+}
+
+// <undisambiguated-identifier> = ["u"] <decimal-number> ["_"] <bytes>
+Identifier Demangler::parseIdentifier() {
+  const bool Punycode = consumeIf('u');
+  const uint64_t Bytes = parseDecimalNumber();
+  consumeIf('_');
+
+  if (Error || Bytes > Input.size() - Position) {
+    Error = true;
+    return {};
+  }
+  const StringView S(Input.begin() + Position, Bytes);
+  Position += Bytes;
+
+  for (const char C : S) {
+    if (!isBasic(C)) {
+      Error = true;
+      return {};
+    }
+  }
+
+  return {S, Punycode};
+}
+
+static const char *parseBasicType(char C) {
+  switch (C) {
+  case 'a':
+    return "i8";
+  case 'b':
+    return "bool";
+  case 'c':
+    return "char";
+  case 'd':
+    return "f64";
+  case 'e':
+    return "str";
+  case 'f':
+    return "f32";
+  case 'h':
+    return "u8";
+  case 'i':
+    return "isize";
+  case 'j':
+    return "usize";
+  case 'l':
+    return "i32";
+  case 'm':
+    return "u32";
+  case 'n':
+    return "i128";
+  case 'o':
+    return "u128";
+  case 's':
+    return "i16";
+  case 't':
+    return "u16";
+  case 'u':
+    return "()";
+  case 'v':
+    return "...";
+  case 'x':
+    return "i64";
+  case 'y':
+    return "u64";
+  case 'z':
+    return "!";
+  case 'p':
+    return "_";
+  default:
+    return nullptr;
+  }
+}
+
+// <type> = | <basic-type>
+//          | <path>                      // named type
+//          | "A" <type> <const>          // [T; N]
+//          | "S" <type>                  // [T]
+//          | "T" {<type>} "E"            // (T1, T2, T3, ...)
+//          | "R" [<lifetime>] <type>     // &T
+//          | "Q" [<lifetime>] <type>     // &mut T
+//          | "P" <type>                  // *const T
+//          | "O" <type>                  // *mut T
+//          | "F" <fn-sig>                // fn(...) -> ...
+//          | "D" <dyn-bounds> <lifetime> // dyn Trait<Assoc = X> + Send + 'a
+//          | <backref>                   // backref
+void Demangler::demangleType() {
+  if (Error || RecursionLevel >= MaxRecursionLevel) {
+    Error = true;
+    return;
+  }
+  RecursionLevel += 1;
+
+  const char C = consume();
+  if (const char *BasicType = parseBasicType(C)) {
+    print(BasicType);
+  } else {
+    switch (C) {
+    case 'A':
+      print("[");
+      demangleType();
+      print("; ");
+      demangleConst();
+      print("]");
+      break;
+    case 'S':
+      print("[");
+      demangleType();
+      print("]");
+      break;
+    case 'T': {
+      print("(");
+      size_t I = 0;
+      for (; !Error && !consumeIf('E'); ++I) {
+        if (I > 0)
+          print(", ");
+        demangleType();
+      }
+      if (I == 1)
+        print(",");
+      print(")");
+      break;
+    }
+    case 'R':
+      print("&");
+      if (consumeIf('L')) {
+        if (const auto Lifetime = parseBase62Number()) {
+          printLifetime(Lifetime);
+          print(" ");
+        }
+      }
+      demangleType();
+      break;
+    case 'Q':
+      print("&");
+      if (consumeIf('L')) {
+        if (const auto Lifetime = parseBase62Number()) {
+          printLifetime(Lifetime);
+          print(" ");
+        }
+      }
+      print("mut ");
+      demangleType();
+      break;
+    case 'P':
+      print("*const ");
+      demangleType();
+      break;
+    case 'O':
+      print("*mut ");
+      demangleType();
+      break;
+    case 'F':
+      demangleFnSig();
+      break;
+    case 'D': {
+      print("dyn ");
+      withBinder([&] {
+        for (size_t I = 0; !Error && !consumeIf('E'); ++I) {
+          if (I > 0)
+            print(" + ");
+          demangleDynTrait();
+        }
+      });
+      if (consumeIf('L')) {
+        if (const auto Lifetime = parseBase62Number()) {
+          print(" + ");
+          printLifetime(Lifetime);
+        }
+      } else {
+        Error = true;
+      }
+      break;
+    }
+    case 'B':
+      demangleBackRef([&] { demangleType(); });
+      break;
+    case 'C':
+    case 'M':
+    case 'X':
+    case 'N':
+    case 'I':
+      Position -= 1;
+      demanglePath(false /* InValue */);
+      break;
+    default:
+      Error = true;
+      break;
+    }
+  }
+
+  RecursionLevel -= 1;
+}
+
+// <fn-sig> := [<binder>] ["U"] ["K" <abi>] {<type>} "E" <type>
+// <abi> = "C"
+//       | <undisambiguated-identifier>
+void Demangler::demangleFnSig() {
+  withBinder([&] {
+    const bool IsUnsafe = consumeIf('U');
+    if (IsUnsafe)
+      print("unsafe ");
+
+    if (consumeIf('K')) {
+      print("extern \"");
+      if (consumeIf('C')) {
+        print("C");
+      } else {
+        const size_t Start = Output.getCurrentPosition();
+        printIdentifier(parseIdentifier());
+        const size_t End = Output.getCurrentPosition();
+
+        // When mangling ABI "-" is replaced by "_".
+        char *Buffer = Output.getBuffer();
+        for (size_t I = Start; I != End; ++I)
+          if (Buffer[I] == '_')
+            Buffer[I] = '-';
+      }
+      print("\" ");
+    }
+
+    print("fn(");
+    for (size_t I = 0; !Error && !consumeIf('E'); ++I) {
+      if (I > 0)
+        print(", ");
+      demangleType();
+    }
+    print(")");
+
+    if (consumeIf('u')) {
+      // Omit the unit type from the output.
+    } else {
+      print(" -> ");
+      demangleType();
+    }
+  });
+}
+
+// Demangles optional binder and updates the number of bound lifetimes.
+//
+// <binder> = ["G" <base-62-number>]
+void Demangler::demangleBinder() {
+  const uint64_t Binder = parseOptionalBase62Number('G');
+  if (Error || Binder == 0)
+    return;
+
+  // Use the input size as a weak upper bound on the total number of bound
+  // lifetimes. Inputs exceeding the bound are invalid while at the same time
+  // generating excessive amounts of demangled output.
+  if (Binder >= Input.size() - BoundLifetimes) {
+    Error = true;
+    return;
+  }
+
+  print("for<");
+  for (size_t I = 0; I != Binder; ++I) {
+    BoundLifetimes += 1;
+    if (I > 0)
+      print(", ");
+    printLifetime(1);
+  }
+  print("> ");
+}
+
+// <dyn-trait> = <path> {<dyn-trait-assoc-binding>}
+// <dyn-trait-assoc-binding> = "p" <undisambiguated-identifier> <type>
+void Demangler::demangleDynTrait() {
+  bool IsOpen = demanglePath(false /* InValue */, true /* LeaveOpen */);
+  while (!Error && consumeIf('p')) {
+    if (!IsOpen) {
+      IsOpen = true;
+      print("<");
+    } else {
+      print(", ");
+    }
+    printIdentifier(parseIdentifier());
+    print(" = ");
+    demangleType();
+  }
+  if (IsOpen)
+    print(">");
+}
+
+// <generic-arg> = <lifetime>
+//               | <type>
+//               | "K" <const>
+// <lifetime> = "L" <base-62-number>
+void Demangler::demangleGenericArg() {
+  if (consumeIf('L'))
+    printLifetime(parseBase62Number());
+  else if (consumeIf('K'))
+    demangleConst();
+  else
+    demangleType();
+}
+
+// <const> = <type> <const-data>
+//         | "p"                 // placeholder
+//         | <backref>
+// <const-data> = ["n"] {<hex-digit>} "_"
+void Demangler::demangleConst() {
+  if (Error || RecursionLevel >= MaxRecursionLevel) {
+    Error = true;
+    return;
+  }
+  RecursionLevel += 1;
+
+  const char Type = consume();
+  switch (Type) {
+  case 'a': // i8
+  case 's': // i16
+  case 'l': // i32
+  case 'x': // i64
+  case 'n': // i128
+  case 'i': // isize
+    demangleConstInt(true /*IsSigned*/);
+    break;
+  case 'h': // u8
+  case 't': // u16
+  case 'm': // u32
+  case 'y': // u64
+  case 'o': // u128
+  case 'j': // usize
+    demangleConstInt(false /*IsSigned*/);
+    break;
+  case 'b': // bool
+    demangleConstBool();
+    break;
+  case 'c': // char
+    demangleConstChar();
+    break;
+  case 'p': // placeholder
+    print("_");
+    break;
+  case 'B':
+    demangleBackRef([&] { demangleConst(); });
+    break;
+  default:
+    Error = true;
+    break;
+  }
+
+  const char *BasicType = parseBasicType(Type);
+  if (Verbose && BasicType != nullptr && Type != 'p') {
+    print(": ");
+    print(BasicType);
+  }
+
+  RecursionLevel -= 1;
+}
+
+void Demangler::demangleConstInt(const bool IsSigned) {
+  const bool IsNegative = IsSigned && consumeIf('n');
+  StringView HexDigits;
+  const uint64_t Value = parseHexNumber(HexDigits);
+
+  if (IsNegative)
+    print("-");
+
+  if (HexDigits.size() < 16) {
+    printDecimalNumber(Value);
+  } else {
+    print("0x");
+    print(HexDigits);
+  }
+}
+
+void Demangler::demangleConstBool() {
+  StringView HexDigits;
+  parseHexNumber(HexDigits);
+
+  if (HexDigits == "0")
+    print("false");
+  else if (HexDigits == "1")
+    print("true");
+  else
+    Error = true;
+}
+
+void Demangler::demangleConstChar() {
+  StringView HexDigits;
+  const uint64_t Value = parseHexNumber(HexDigits);
+
+  if (Error || HexDigits.size() > 8) {
+    Error = true;
+    return;
+  }
+
+  print("'");
+  switch (Value) {
+  case '\t':
+    print(R"(\t)");
+    break;
+  case '\r':
+    print(R"(\r)");
+    break;
+  case '\n':
+    print(R"(\n)");
+    break;
+  case '\\':
+    print(R"(\\)");
+    break;
+  case '"':
+    print(R"(")");
+    break;
+  case '\'':
+    print(R"(\')");
+    break;
+  default:
+    if (' ' <= Value && Value <= '~') {
+      printChar(Value);
+    } else {
+      print(R"(\u{)");
+      printHexNumber(Value);
+      print("}");
+    }
+    break;
+  }
+  print("'");
+}
+
+// Parses hexadecimal number with 0-9 a-f as a digits. Returns value and
+// stores hex digits in HexDigits. Overflow is not considered to be an
+// error, so check the length of hex digits (<= 16), before using the
+// returned value.
+//
+// <hex-number> = {<0-9a-f>} "_"
+uint64_t Demangler::parseHexNumber(StringView &HexDigits) {
+  const size_t Start = Position;
+  uint64_t Value = 0;
+
+  while (!Error && !consumeIf('_')) {
+    const char C = consume();
+    Value *= 16;
+    if (isDigit(C))
+      Value += C - '0';
+    else if ('a' <= C && C <= 'f')
+      Value += 10 + (C - 'a');
+    else
+      Error = true;
+  }
+
+  if (Error) {
+    Value = 0;
+    HexDigits = StringView();
+    return Value;
+  }
+
+  assert(Start < Position);
+  const size_t N = Position - 1 - Start;
+  HexDigits = StringView(Input.begin() + Start, +N);
+  return Value;
+}
+
+// Parses optional base 62 number. The presence of a number is determined
+// using Tag. Returns 0 when tag is absent and value + 1 otherwise.
+uint64_t Demangler::parseOptionalBase62Number(char Tag) {
+  if (!consumeIf(Tag))
+    return 0;
+
+  const uint64_t N = parseBase62Number();
+  if (Error || N == std::numeric_limits<uint64_t>::max()) {
+    Error = true;
+    return 0;
+  }
+  return N + 1;
+}
+
+// Parses base 62 number with 0-9 a-z A-Z as digits. Number is terminated by
+// "_". All values are offset by 1, so that "_" encodes 0, "0_" encodes 1,
+// "1_" encodes 2, etc.
+//
+// <base-62-number> = {<0-9a-zA-Z>} "_"
+uint64_t Demangler::parseBase62Number() {
+  uint64_t Value = 0;
+  if (consumeIf('_')) {
+    return Value;
+  }
+
+  const uint64_t Max = std::numeric_limits<uint64_t>::max();
+  while (true) {
+    uint64_t Digit;
+    const char C = consume();
+
+    if (C == '_') {
+      break;
+    } else if (isDigit(C)) {
+      Digit = C - '0';
+    } else if (isLower(C)) {
+      Digit = 10 + (C - 'a');
+    } else if (isUpper(C)) {
+      Digit = 10 + 26 + (C - 'A');
+    } else {
+      Error = true;
+      return 0;
+    }
+
+    if (Value > (Max - Digit) / 62) {
+      Error = true;
+      return 0;
+    }
+    Value = Value * 62 + Digit;
+  }
+
+  if (Value > Max - 1) {
+    Error = true;
+    return 0;
+  }
+  Value += 1;
+
+  return Value;
+}
+
+// Parses a decimal number that had been encoded without any leading zeros.
+//
+// <decimal-number> = "0"
+//                  | <1-9> {<0-9>}
+uint64_t Demangler::parseDecimalNumber() {
+  const char C = look();
+  if (!isDigit(C)) {
+    Error = true;
+    return 0;
+  }
+
+  if (C == '0') {
+    consume();
+    return 0;
+  }
+
+  const uint64_t Max = std::numeric_limits<uint64_t>::max();
+  uint64_t Value = 0u;
+
+  while (isDigit(look())) {
+    if (Value > Max / 10) {
+      Error = true;
+      return 0;
+    }
+    Value *= 10;
+
+    const uint64_t D = consume() - '0';
+    if (Value > Max - D) {
+      Error = true;
+      return 0;
+    }
+    Value += D;
+  }
+
+  return Value;
+}
+
+// Prints the lifetime. An index 0 always represents an erased lifetime.
+// Indices starting from 1, are De Bruijn indices, referring to higher-ranked
+// lifetimes bound by one of the enclosing binders.
+void Demangler::printLifetime(const uint64_t Index) {
+  if (Index == 0) {
+    print("'_");
+    return;
+  }
+
+  if (Index - 1 >= BoundLifetimes) {
+    Error = true;
+    return;
+  }
+
+  const uint64_t Depth = BoundLifetimes - Index;
+  printChar('\'');
+  if (Depth < 26) {
+    printChar('a' + Depth);
+  } else {
+    printChar('t');
+    printDecimalNumber(Depth - 26);
+  }
+}
+
+void Demangler::printDecimalNumber(uint64_t N) {
+  if (Error || !Print)
+    return;
+
+  Output << N;
+}
+
+void Demangler::printHexNumber(uint64_t N) {
+  if (Error || !Print)
+    return;
+
+  const size_t Start = Output.getCurrentPosition();
+  do {
+    const uint64_t D = N % 16;
+    N /= 16;
+    printChar(D < 10 ? '0' + D : 'a' + (D - 10));
+  } while (N != 0);
+
+  const size_t End = Output.getCurrentPosition();
+  std::reverse(Output.getBuffer() + Start, Output.getBuffer() + End);
+}
+
+void Demangler::printIdentifier(Identifier Ident) {
+  if (Error || !Print)
+    return;
+
+  if (Ident.Punycode) {
+    Error = true;
+  } else {
+    print(Ident.Name);
+  }
+}

llvm/test/Demangle/rust.test

+RUN: llvm-cxxfilt -n  < %s | FileCheck --match-full-lines %s
+
+CHECK: a::main
+       _RNvC1a4main
+
+CHECK: xyz::main
+       _RNvC3xyz4mainCsabc_3xyz
+
+CHECK: foo::bar
+       _RNvC3foo3barB2_
+
+; Inherent impl
+
+CHECK: <p::X>::new
+       _RNvMC1pNtB2_1X3new
+
+; Trait impl
+
+CHECK: <p::X as core::default::Default>::default
+       _RNvXC1pNtB2_1XNtNtC4core7default7Default7default
+
+; Trait definition
+
+CHECK: <u32 as p::Display>::display
+       _RNvYmNtC1p7Display7display
+
+; Closure namespace
+
+CHECK: ns::x::{closure#0}::f
+       _RNvNCNvC2ns1x01f
+
+CHECK: ns::y::{closure#1}::f
+       _RNvNCNvC2ns1ys_01f
+
+; Shim namespace
+
+CHECK: <ns::shim::{closure#0} as core::FnOnce<()>>::call_once::{shim:vtable#0}
+       _RNSNvYNCNvC2ns4shim0INtC4core6FnOnceuE9call_once6vtable
+
+; Internal namespace (not show)
+
+CHECK: ns::z::f
+       _RNvNaNvC2ns1z01f
+
+; Invalid namespace
+
+CHECK: _RNvN_NvC2ns1i01f
+       _RNvN_NvC2ns1i01f
+
+; Basic types
+
+CHECK: b::basic::<i8>
+       _RINvC1b5basicaE
+
+CHECK: b::basic::<bool>
+       _RINvC1b5basicbE
+
+CHECK: b::basic::<char>
+       _RINvC1b5basiccE
+
+CHECK: b::basic::<f64>
+       _RINvC1b5basicdE
+
+CHECK: b::basic::<str>
+       _RINvC1b5basiceE
+
+CHECK: b::basic::<f32>
+       _RINvC1b5basicfE
+
+CHECK: b::basic::<u8>
+       _RINvC1b5basichE
+
+CHECK: b::basic::<isize>
+       _RINvC1b5basiciE
+
+CHECK: b::basic::<usize>
+       _RINvC1b5basicjE
+
+CHECK: b::basic::<i32>
+       _RINvC1b5basiclE
+
+CHECK: b::basic::<u32>
+       _RINvC1b5basicmE
+
+CHECK: b::basic::<i128>
+       _RINvC1b5basicnE
+
+CHECK: b::basic::<u128>
+       _RINvC1b5basicoE
+
+CHECK: b::basic::<i16>
+       _RINvC1b5basicsE
+
+CHECK: b::basic::<u16>
+       _RINvC1b5basictE
+
+CHECK: b::basic::<()>
+       _RINvC1b5basicuE
+
+CHECK: b::basic::<...>
+       _RINvC1b5basicvE
+
+CHECK: b::basic::<i64>
+       _RINvC1b5basicxE
+
+CHECK: b::basic::<u64>
+       _RINvC1b5basicyE
+
+CHECK: b::basic::<!>
+       _RINvC1b5basiczE
+
+CHECK: b::basic::<_>
+       _RINvC1b5basicpE
+
+; Complex types
+
+CHECK: c::types::<[u8; _]>
+       _RINvC1c5typesAhpE
+
+CHECK: c::types::<[u8; 10]>
+       _RINvC1c5typesAhha_E
+
+CHECK: c::types::<[u8]>
+       _RINvC1c5typesShE
+
+CHECK: c::types::<()>
+       _RINvC1c5typesTEE
+
+CHECK: c::types::<(u8,)>
+       _RINvC1c5typesThEE
+
+CHECK: c::types::<(u8, u8)>
+       _RINvC1c5typesThhEE
+
+CHECK: c::types::<(u8, u8, u8)>
+       _RINvC1c5typesThhhEE
+
+CHECK: c::types::<&u8>
+       _RINvC1c5typesRhE
+
+CHECK: c::types::<&u8>
+       _RINvC1c5typesRL_hE
+
+CHECK: c::types::<&mut u8>
+       _RINvC1c5typesQhE
+
+CHECK: c::types::<&mut u8>
+       _RINvC1c5typesQL_hE
+
+CHECK: c::types::<*const u8>
+       _RINvC1c5typesPhE
+
+CHECK: c::types::<*mut u8>
+       _RINvC1c5typesOhE
+
+; Function signatures
+
+CHECK: f::fns::<fn() -> i64>
+       _RINvC1f3fnsFExE
+
+CHECK: f::fns::<fn()>
+       _RINvC1f3fnsFEuE
+
+CHECK: f::fns::<unsafe fn()>
+       _RINvC1f3fnsFUEuE
+
+CHECK: f::fns::<unsafe extern "C" fn()>
+       _RINvC1f3fnsFUKCEuE
+
+CHECK: f::fns::<extern "C" fn()>
+       _RINvC1f3fnsFKCEuE
+
+CHECK: f::fns::<extern "cdecl" fn()>
+       _RINvC1f3fnsFK5cdeclEuE
+
+CHECK: f::fns::<extern "C-cmse-nonsecure-call" fn()>
+       _RINvC1f3fnsFK21C_cmse_nonsecure_callEuE
+
+; Dyn traits
+
+CHECK: d::trait::<dyn core::marker::Send>
+       _RINvC1d5traitDNtNtC4core6marker4SendEL_E
+
+CHECK: d::trait::<dyn d::A + core::marker::Send>
+       _RINvC1d5traitDNtB2_1ANtNtC4core6marker4SendEL_E
+         01234
+
+CHECK: d::trait::<&dyn core::ops::function::Fn<(u32,), Output = i32>>
+       _RINvC1d5traitRDINtNtNtCsa_4core3ops8function2FnTmEEp6OutputlEL_E
+
+CHECK: d::trait::<&dyn for<'a, 'b> core::ops::function::Fn<(&'a [u8], &'b ()), Output = ()>>
+       _RINvC1d5traitRDG0_INtNtNtC4core3ops8function2FnTRL1_ShRL0_uEEp6OutputuEL_E
+
+CHECK: d::trait::<for<'a> fn(&'a ()) -> &'a dyn d::Parse<'a, 'a> + 'a>
+       _RINvC1d5traitFG_RL0_uERL0_DINtB2_5ParseL0_L0_EEL0_E
+
+CHECK: d::trait::<for<'a> fn(&'a dyn for<'b> core::ops::function::FnOnce<(&'b u8,), Output = &'b u8> + 'a) -> &'a u8>
+       _RINvCsbDqzXfLQacH_1d5traitFG_RL0_DG_INtNtNtCs3p84KrD9aKt_4core3ops8function6FnOnceTRL0_hEEp6OutputRL0_hEL0_ERL0_hEB2_
+
+; Bool constants
+
+CHECK: k::Bool::<false>
+       _RINvC1k4BoolKb0_E
+
+CHECK: k::Bool::<true>
+       _RINvC1k4BoolKb1_E
+
+; Integer constants
+
+CHECK: k::xy::<0>
+       _RINvC1k2xyKa0_E
+
+CHECK: k::xy::<1>
+       _RINvC1k2xyKa1_E
+
+CHECK: k::xy::<-2>
+       _RINvC1k2xyKan2_E
+
+CHECK: k::xy::<-10>
+       _RINvC1k2xyKana_E
+
+CHECK: k::xy::<127>
+       _RINvC1k2xyKa7f_E
+
+CHECK: k::xy::<0x123456789abcdef00>
+       _RINvC1k2xyKo123456789abcdef00_E
+
+; Char constants
+
+CHECK: k::a::<'a'>
+       _RINvC1k1aKc61_E
+
+CHECK: k::a::<'"'>
+       _RINvC1k1aKc22_E
+
+CHECK: k::escape::<'\t'>
+       _RINvC1k6escapeKc9_E
+
+CHECK: k::escape::<'\r'>
+       _RINvC1k6escapeKcd_E
+
+CHECK: k::escape::<'\n'>
+       _RINvC1k6escapeKca_E
+
+CHECK: k::escape::<'\\'>
+       _RINvC1k6escapeKc5c_E
+
+CHECK: k::escape::<'\''>
+       _RINvC1k6escapeKc27_E
+
+CHECK: k::snake::<'\u{1f40d}'>
+       _RINvC1k5snakeKc1f40d_E
+
+; Binders
+
+CHECK: e::bind::<for<'a> fn(&'a u8)>
+       _RINvC1e4bindFG_RL0_hEuE
+
+CHECK: e::bind::<for<'a> fn(&'a u8) -> for<'b> fn(&'a u16, &'b mut u32)>
+       _RINvC1e4bindFG_RL0_hEFG_RL1_tQL0_mEuE
+
+CHECK: e::bind::<for<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l, 'm, 'n, 'o, 'p, 'q, 'r, 's, 't, 'u, 'v, 'w, 'x, 'y, 'z, 't0, 't1, 't2, 't3> fn(&'a &'b &'c &'d &'e &'f &'g &'h &'i &'j &'k &'l &'m &'n &'o &'p &'q &'r &'s &'t &'u &'v &'w &'x &'y &'z &'t0 &'t1 &'t2 &'t3 ())>
+       _RINvCs21hi0yVfW1J_1e4bindFGs_RLt_RLs_RLr_RLq_RLp_RLo_RLn_RLm_RLl_RLk_RLj_RLi_RLh_RLg_RLf_RLe_RLd_RLc_RLb_RLa_RL9_RL8_RL7_RL6_RL5_RL4_RL3_RL2_RL1_RL0_uEuEB2_
+
+; Backreferences
+
+CHECK: abc::f::<(i32, i32, i32), (i32, i32, i32)>
+       _RINvC3abc1fTlllEB9_E
+         01234567890
+
+CHECK: abc::f::<((i32, i32, i32), (i32, i32, i32)), ((i32, i32, i32), (i32, i32, i32))>
+       _RINvC3abc1fTTlllEBa_EB9_E
+         01234567890
+
+; Dot-suffix
+
+CHECK: dot::convert (llvm.10622374130885708379)
+       _RNvC3dot7convertB3_.llvm.10622374130885708379
+
+CHECK: dot::test (0.0)
+       _RNvC3dot4testB3_.0.0
+
+; Unsupported / invalid version
+
+CHECK: _R0NvC1a4main
+       _R0NvC1a4main
+
+CHECK: _R1NvC1a4main
+       _R1NvC1a4main
+
+CHECK: _R199999999999999999999999999NvC1a4main
+       _R199999999999999999999999999NvC1a4main
+
+; Early EOF
+
+CHECK: _RNvC
+       _RNvC
+
+CHECK: _RNvC1a5main
+       _RNvC1a5main
+
+CHECK: _RNvC1a20abc
+       _RNvC1a20abc
+
+; Unbound lifetimes
+
+CHECK: _RINvC1z1fRL0_hE
+       _RINvC1z1fRL0_hE
+
+CHECK: _RINvC1z1fRL1_hE
+       _RINvC1z1fRL1_hE
+
+CHECK: _RINvC1z1fRL10000_hE
+       _RINvC1z1fRL10000_hE
+
+CHECK: _RINvC1z1fRL99999_hE
+       _RINvC1z1fRL99999_hE
+
+; Invalid backreferences
+
+CHECK: _RB__B0
+       _RB__B0
+
+CHECK: _RB_RMRX
+       _RB_RMRX
+
+CHECK: _RNvNvB_1a1b1c
+       _RNvNvB_1a1b1c
+
+CHECK: _RINvCshGpAVYOtgW1_1a1fTlllEB_EB2_
+       _RINvCshGpAVYOtgW1_1a1fTlllEB_EB2_
+
+; Overabundance of bound lifetimes
+
+CHECK: _RYSSFGFFF_EuC1a
+       _RYSSFGFFF_EuC1a
+
+CHECK: _RYSSFFGF0FFFF_RIIIIIIIIIIIIIR
+       _RYSSFFGF0FFFF_RIIIIIIIIIIIIIR
+
+CHECK: _RYSSFFFG0FFFF_RIIIIIIIIIIIIIIIIIIIIIIIIIIIIISIII3MYAmR
+       _RYSSFFFG0FFFF_RIIIIIIIIIIIIIIIIIIIIIIIIIIIIISIII3MYAmR

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

if (Types ||
     Undecorated = itaniumDemangle(DecoratedStr, nullptr, nullptr, &Status);
 
   if (!Undecorated &&
       (DecoratedLength > 6 && strncmp(DecoratedStr, "__imp_", 6) == 0)) {
     Prefix = "import thunk for ";
     Undecorated = itaniumDemangle(DecoratedStr + 6, nullptr, nullptr, &Status);
   }
 
+  if (!Undecorated &&
+      (DecoratedLength >= 2 && strncmp(DecoratedStr, "_R", 2) == 0)) {
+    Undecorated = rustDemangle(DecoratedStr, nullptr, nullptr, &Status);
+  }
+
   std::string Result(Undecorated ? Prefix + Undecorated : Mangled);
   free(Undecorated);
   return Result;
 }
 
 // Split 'Source' on any character that fails to pass 'IsLegalChar'.  The
 // returned vector consists of pairs where 'first' is the delimited word, and
 // 'second' are the delimiters following that word.

llvm/unittests/Demangle/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Demangle
   Support
 )
 
 add_llvm_unittest(DemangleTests
   DemangleTest.cpp
   ItaniumDemangleTest.cpp
   PartialDemangleTest.cpp
+  RustDemangleTest.cpp
 )

llvm/unittests/Demangle/RustDemangleTest.cpp

+//===------------------ RustDemangleTest.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 "gtest/gtest.h"
+
+#include <cstdlib>
+
+TEST(RustDemangle, Success) {
+  char *Demangled =
+      llvm::rustDemangle("_RNvC1a4main", nullptr, nullptr, nullptr);
+  EXPECT_STREQ(Demangled, "a::main");
+  std::free(Demangled);
+
+  // With status.
+  int Status = 0;
+  Demangled = llvm::rustDemangle("_RNvC1a4main", nullptr, nullptr, &Status);
+  EXPECT_EQ(Status, llvm::demangle_success);
+  EXPECT_STREQ(Demangled, "a::main");
+  std::free(Demangled);
+
+  // With status and length.
+  size_t N = 0;
+  Demangled = llvm::rustDemangle("_RNvC1a4main", nullptr, &N, &Status);
+  EXPECT_EQ(Status, llvm::demangle_success);
+  EXPECT_EQ(N, 8u);
+  EXPECT_STREQ(Demangled, "a::main");
+  std::free(Demangled);
+}
+
+TEST(RustDemangle, Invalid) {
+  int Status = 0;
+  char *Demangled = nullptr;
+
+  // Invalid prefix.
+  Demangled = llvm::rustDemangle("_ABCDEF", nullptr, nullptr, &Status);
+  EXPECT_EQ(Status, llvm::demangle_invalid_mangled_name);
+  EXPECT_EQ(Demangled, nullptr);
+
+  // Correct prefix but still invalid.
+  Demangled = llvm::rustDemangle("_RRR", nullptr, nullptr, &Status);
+  EXPECT_EQ(Status, llvm::demangle_invalid_mangled_name);
+  EXPECT_EQ(Demangled, nullptr);
+}
+
+TEST(RustDemangle, OutputBufferWithoutLength) {
+  char *Buffer = static_cast<char *>(std::malloc(1024));
+  ASSERT_NE(Buffer, nullptr);
+
+  int Status = 0;
+  char *Demangled =
+      llvm::rustDemangle("_RNvC1a4main", Buffer, nullptr, &Status);
+
+  EXPECT_EQ(Status, llvm::demangle_invalid_args);
+  EXPECT_EQ(Demangled, nullptr);
+  std::free(Buffer);
+}
+
+TEST(RustDemangle, OutputBuffer) {
+  size_t N = 1024;
+  char *Buffer = static_cast<char *>(std::malloc(N));
+  ASSERT_NE(Buffer, nullptr);
+
+  int Status = 0;
+  char *Demangled = llvm::rustDemangle("_RNvC1a4main", Buffer, &N, &Status);
+
+  EXPECT_EQ(Status, llvm::demangle_success);
+  EXPECT_EQ(Demangled, Buffer);
+  EXPECT_STREQ(Demangled, "a::main");
+  std::free(Demangled);
+}
+
+TEST(RustDemangle, SmallOutputBuffer) {
+  size_t N = 1;
+  char *Buffer = static_cast<char *>(std::malloc(N));
+  ASSERT_NE(Buffer, nullptr);
+
+  int Status = 0;
+  char *Demangled = llvm::rustDemangle("_RNvC1a4main", Buffer, &N, &Status);
+
+  EXPECT_EQ(Status, llvm::demangle_success);
+  EXPECT_STREQ(Demangled, "a::main");
+  std::free(Demangled);
+}