reland: [Demangle] make llvm::demangle take std::string_view rather than const std::string&

[nickdesaulniers]

Summary

As suggested by @erichkeane in
https://reviews.llvm.org/D141451#inline-1429549

There's potential for a lot more cleanups around these APIs. This is
just a start.

Callers need to be more careful about sub-expressions producing strings
that don't outlast the expression using llvm::demangle. Add a
release note.

[nickdesaulniers]

oh, I can clean up all of the callers of llvm::demangle now, too. Did I do that last week, as a separate patch? Let me see...

[MaskRay]

llvm/lib/Demangle/Demangle.cpp

39

LLVM Coding Style prefers static to an anonymous namespace.

[nickdesaulniers]

• prefer static linkage to anonymous namespace
• add release notes
• update most callsites

[MaskRay]

lld/ELF/Symbols.cpp

50 ↗

(On Diff #516580)

return demangle(symName.str());

perhaps return demangle(symName); works as well?

[nickdesaulniers]

lld/COFF/Symbols.cpp

43 ↗

(On Diff #516580)

probably should just be return prefix + demangled;

lld/ELF/Symbols.cpp

50 ↗

(On Diff #516580)

perhaps return demangle(symName); works as well?

I saw test failures with that change. I can keep it as is; wasn't sure if it's worth making this more obvious...

llvm/docs/ReleaseNotes.rst

291 ↗

(On Diff #516580)

expression

[nickdesaulniers]

• fix typos
• simplify maybeDemangleSymbol in lld COFF
• restore maybeDemangleSymbol

[nickdesaulniers]

bumping for review

[MaskRay]

Looks great!

llvm/docs/ReleaseNotes.rst

289 ↗

(On Diff #516582)

The text wrapping appears to use a very small set textwidth (neovim)?

[nickdesaulniers]

Thanks for the review!

llvm/docs/ReleaseNotes.rst

289 ↗

(On Diff #516582)

No, just me manually correcting it; otherwise we have a line ending like <backtick><backtic>const
which looks odd to me. I don't think it matters for rendering restructured text either way.

[nickdesaulniers]

Looks like this is causing a regression in lld/test/wasm/why-extract.s when -DLLVM_ENABLE_EXPENSIVE_CHECKS=ON is enabled. I'm looking into it and hoping to fix forward by EOD.

[nickdesaulniers]

In D149104#4313210, @nickdesaulniers wrote:

Looks like this is causing a regression in lld/test/wasm/why-extract.s when -DLLVM_ENABLE_EXPENSIVE_CHECKS=ON is enabled. I'm looking into it and hoping to fix forward by EOD.

Fixup: https://reviews.llvm.org/D149675

[nickdesaulniers]

• rebase

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

 // 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
 /// demangling occurred.
-std::string demangle(const std::string &MangledName);
+std::string demangle(const std::string_view MangledName);
 
 bool nonMicrosoftDemangle(const char *MangledName, std::string &Result);
 
 /// "Partial" demangler. This supports demangling a string into an AST
 /// (typically an intermediate stage in itaniumDemangle) and querying certain
 /// properties or partially printing the demangled name.
 struct ItaniumPartialDemangler {
   ItaniumPartialDemangler();

llvm/lib/Demangle/Demangle.cpp

 //===-- Demangle.cpp - Common demangling functions ------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file This file contains definitions of common demangling functions.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Demangle/Demangle.h"
+#include "llvm/Demangle/StringViewExtras.h"
 #include <cstdlib>
-#include <cstring>
 
-static bool isItaniumEncoding(const char *S) {
-  // Itanium encoding requires 1 or 3 leading underscores, followed by 'Z'.
-  return std::strncmp(S, "_Z", 2) == 0 || std::strncmp(S, "___Z", 4) == 0;
-}
-
-static bool isRustEncoding(const char *S) { return S[0] == '_' && S[1] == 'R'; }
-
-static bool isDLangEncoding(const std::string &MangledName) {
-  return MangledName.size() >= 2 && MangledName[0] == '_' &&
-         MangledName[1] == 'D';
-}
+using llvm::itanium_demangle::starts_with;
 
-std::string llvm::demangle(const std::string &MangledName) {
+std::string llvm::demangle(const std::string_view MangledName) {
   std::string Result;
-  const char *S = MangledName.c_str();
+  const char *S = MangledName.data();
 
   if (nonMicrosoftDemangle(S, Result))
     return Result;
 
   if (S[0] == '_' && nonMicrosoftDemangle(S + 1, Result))
     return Result;
 
   if (char *Demangled = microsoftDemangle(S, nullptr, nullptr)) {
     Result = Demangled;
     std::free(Demangled);
-    return Result;
-  }
+  } else {
+    Result = MangledName;
+  }
 
-  return MangledName;
+namespace {
+bool isItaniumEncoding(std::string_view S) {
+  return starts_with(S, "_Z") || starts_with(S, "___Z");
 }
 
+bool isRustEncoding(std::string_view S) { return starts_with(S, "_R"); }
+
+bool isDLangEncoding(std::string_view S) { return starts_with(S, "_D"); }
+} // namespace
+
 bool llvm::nonMicrosoftDemangle(const char *MangledName, std::string &Result) {
   char *Demangled = nullptr;
   if (isItaniumEncoding(MangledName))
     Demangled = itaniumDemangle(MangledName, nullptr, nullptr, nullptr);
   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;
 }