[Damangle] convert rustDemangle to use std::string_view

[nickdesaulniers]

Summary

I was doing this API conversion to use std::string_view top-down in
D149104, but this exposed issues in individual demanglers that needed to
get fixed first. There's no issue with the conversion for the Rust
demangler, so convert it first.

[nickdesaulniers]

lldb/source/Core/Mangled.cpp

263

oh, I meant to remove this now that I provide operator std::string_view() on class ConstString.

[nickdesaulniers]

• remove GetStringRef call

[MaskRay]

lldb/include/lldb/Utility/ConstString.h

186

Perhaps I find the previous comment not useful as well Implicitly convert \class ConstString instances to \class StringRef.

If we want to emphasize that they are implicit conversions instead of explicit conversions (https://en.cppreference.com/w/cpp/language/cast_operator), a single comment // Implicit conversion functions. should suffice, covering all conversion functions.

@JDevlieghere @labath

[nickdesaulniers]

• update llvm-rust-demangle-fuzzer.cpp call site

[nickdesaulniers]

• rebase, reformat for presubmit tests

[nickdesaulniers]

• update comments as per @MaskRay

[nickdesaulniers]

• rebase for presubmits

[MaskRay]

llvm/lib/Demangle/RustDemangle.cpp

150

I see that this patch drops if (MangledName == nullptr) (D101444). This is a right direction.

[nickdesaulniers]

• rebase on top of D149675 (I wasn't sure which would land first)

lldb/include/lldb/Utility/ConstString.h

 //===-- ConstString.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 LLDB_UTILITY_CONSTSTRING_H
 #define LLDB_UTILITY_CONSTSTRING_H
 
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/FormatVariadic.h"
 
 #include <cstddef>
+#include <string_view>
 
 namespace lldb_private {
 class Stream;
 }
 namespace llvm {
 class raw_ostream;
 }
 
public:
   ///
   /// \return \b true if this object is not equal to \a rhs, false otherwise.
   bool operator!=(const char *rhs) const { return !(*this == rhs); }
 
   bool operator<(ConstString rhs) const;
 
   // Implicitly convert \class ConstString instances to \class StringRef.
   operator llvm::StringRef() const { return GetStringRef(); }
+  // Implicitly convert \class ConstString instances to \calss std::string_view.
+  operator std::string_view() const { return std::string_view(m_string, GetLength()); }
 
   /// Get the string value as a C string.
   ///
   /// Get the value of the contained string as a NULL terminated C string
   /// value.
   ///
   /// If \a value_if_empty is nullptr, then nullptr will be returned.
   ///

lldb/source/Core/Mangled.cpp

 #include "lldb/lldb-enumerations.h"
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Demangle/Demangle.h"
 #include "llvm/Support/Compiler.h"
 
 #include <mutex>
 #include <string>
+#include <string_view>
 #include <utility>
 
 #include <cstdlib>
 #include <cstring>
 using namespace lldb_private;
 
 static inline bool cstring_is_mangled(llvm::StringRef s) {
   return Mangled::GetManglingScheme(s) != Mangled::eManglingSchemeNone;
if (demangled_cstr)
       LLDB_LOGF(log, "demangled itanium: %s -> \"%s\"", M, demangled_cstr);
     else
       LLDB_LOGF(log, "demangled itanium: %s -> error: failed to demangle", M);
   }
 
   return demangled_cstr;
 }
 
-static char *GetRustV0DemangledStr(const char *M) {
+static char *GetRustV0DemangledStr(std::string_view M) {
   char *demangled_cstr = llvm::rustDemangle(M);
 
   if (Log *log = GetLog(LLDBLog::Demangle)) {
     if (demangled_cstr && demangled_cstr[0])
       LLDB_LOG(log, "demangled rustv0: {0} -> \"{1}\"", M, demangled_cstr);
     else
       LLDB_LOG(log, "demangled rustv0: {0} -> error: failed to demangle", M);
   }
if (mangling_scheme != eManglingSchemeNone &&
       case eManglingSchemeMSVC:
         demangled_name = GetMSVCDemangledStr(mangled_name);
         break;
       case eManglingSchemeItanium: {
         demangled_name = GetItaniumDemangledStr(mangled_name);
         break;
       }
       case eManglingSchemeRustV0:
-        demangled_name = GetRustV0DemangledStr(mangled_name);
+        demangled_name = GetRustV0DemangledStr(m_mangled);
         break;
       case eManglingSchemeD:
         demangled_name = GetDLangDemangledStr(mangled_name);
         break;
       case eManglingSchemeNone:
         llvm_unreachable("eManglingSchemeNone was handled already");
       }
       if (demangled_name) {

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 <string_view>
 
 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.
 ///

 /// If n_read is non-null and demangling was successful, it receives how many
 /// bytes of the input string were consumed.
 /// 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, int *status,
                         MSDemangleFlags Flags = MSDF_None);
 
 // Demangles a Rust v0 mangled symbol.
-char *rustDemangle(const char *MangledName);
+char *rustDemangle(std::string_view MangledName);
 
 // Demangles a D mangled symbol.
 char *dlangDemangle(const char *MangledName);
 
 /// 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

llvm/lib/Demangle/Demangle.cpp

 }
 
 bool llvm::nonMicrosoftDemangle(std::string_view MangledName,
                                 std::string &Result) {
   char *Demangled = nullptr;
   if (isItaniumEncoding(MangledName.data()))
     Demangled = itaniumDemangle(MangledName);
   else if (isRustEncoding(MangledName.data()))
-    Demangled = rustDemangle(MangledName.data());
+    Demangled = rustDemangle(MangledName);
   else if (isDLangEncoding(MangledName.data()))
     Demangled = dlangDemangle(MangledName.data());
 
   if (!Demangled)
     return false;
 
   Result = Demangled;
   std::free(Demangled);
   return true;
 }

llvm/lib/Demangle/RustDemangle.cpp

 #include "llvm/Demangle/StringViewExtras.h"
 #include "llvm/Demangle/Utility.h"
 
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <cstring>
 #include <limits>
+#include <string_view>
 
 using namespace llvm;
 
 using llvm::itanium_demangle::OutputBuffer;
 using llvm::itanium_demangle::ScopedOverride;
+using llvm::itanium_demangle::starts_with;
 
 namespace {
 
 struct Identifier {
   std::string_view Name;
   bool Punycode;
 
   bool empty() const { return Name.empty(); }
private:
   bool consumeIf(char Prefix);
 
   bool addAssign(uint64_t &A, uint64_t B);
   bool mulAssign(uint64_t &A, uint64_t B);
 };
 
 } // namespace
 
-char *llvm::rustDemangle(const char *MangledName) {
-  if (MangledName == nullptr)
-    return nullptr;
-
+char *llvm::rustDemangle(std::string_view MangledName) {
   // Return early if mangled name doesn't look like a Rust symbol.
-  std::string_view Mangled(MangledName);
-  if (!llvm::itanium_demangle::starts_with(Mangled, "_R"))
+  if (MangledName.empty() || !starts_with(MangledName, "_R"))
     return nullptr;
 
   Demangler D;
-  if (!D.demangle(Mangled)) {
+  if (!D.demangle(MangledName)) {
     std::free(D.Output.getBuffer());
     return nullptr;
   }
 
   D.Output += '\0';
 
   return D.Output.getBuffer();
 }

 // <symbol-name> = "_R" <path> [<instantiating-crate>]
 bool Demangler::demangle(std::string_view Mangled) {
   Position = 0;
   Error = false;
   Print = true;
   RecursionLevel = 0;
   BoundLifetimes = 0;
 
-  if (!llvm::itanium_demangle::starts_with(Mangled, "_R")) {
+  if (!starts_with(Mangled, "_R")) {
     Error = true;
     return false;
   }
   Mangled.remove_prefix(2);
   size_t Dot = Mangled.find('.');
   Input = Dot == std::string_view::npos ? Mangled : Mangled.substr(0, Dot);
 
   demanglePath(IsInType::No);

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

 //===--- llvm-demangle-fuzzer.cpp - Fuzzer for the Rust 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);
-  char *Demangled = llvm::rustDemangle(NullTerminatedString.c_str());
+  char *Demangled = llvm::rustDemangle(NullTerminatedString);
   std::free(Demangled);
   return 0;
 }