return false;
Diags.Report(*Loc, diag::warn_fe_frame_larger_than)
- << D.getStackSize()
- << D.getStackLimit()
- << llvm::demangle(D.getFunction().getName().str());
+ << D.getStackSize() << D.getStackLimit()
+ << llvm::demangle(D.getFunction().getName());
return true;
}
Diags.Report(*Loc, DiagID)
<< D.getResourceName() << D.getResourceSize() << D.getResourceLimit()
- << llvm::demangle(D.getFunction().getName().str());
+ << llvm::demangle(D.getFunction().getName());
return true;
}
Diags.Report(LocCookie, D.getSeverity() == DiagnosticSeverity::DS_Error
? diag::err_fe_backend_error_attr
: diag::warn_fe_backend_warning_attr)
- << llvm::demangle(D.getFunctionName().str()) << D.getNote();
+ << llvm::demangle(D.getFunctionName()) << D.getNote();
}
void BackendConsumer::MisExpectDiagHandler(
StringRef demangleInput = prefixless;
if (ctx.config.machine == I386)
demangleInput.consume_front("_");
- std::string demangled = demangle(demangleInput.str());
+ std::string demangled = demangle(demangleInput);
if (demangled != demangleInput)
- return prefix + demangle(demangleInput.str());
+ return prefix + demangled;
return (prefix + prefixless).str();
}
return std::string(symName);
if (canBeVersioned(*sym)) {
StringRef name = sym->getName();
size_t pos = name.find('@');
+ std::string substr;
if (pos == std::string::npos)
- demangled = demangle(name.str());
- else if (pos + 1 == name.size() || name[pos + 1] == '@')
- demangled = demangle(name.substr(0, pos).str());
- else
- demangled =
- (demangle(name.substr(0, pos).str()) + name.substr(pos)).str();
+ demangled = demangle(name);
+ else if (pos + 1 == name.size() || name[pos + 1] == '@') {
+ substr = name.substr(0, pos);
+ demangled = demangle(substr);
+ } else {
+ substr = name.substr(0, pos);
+ demangled = (demangle(substr) + name.substr(pos)).str();
+ }
(*demangledSyms)[demangled].push_back(sym);
}
}
// Returns a symbol for an error message.
static std::string maybeDemangleSymbol(StringRef symName) {
- if (elf::config->demangle)
- return demangle(symName.str());
- return symName.str();
+ return elf::config->demangle ? demangle(symName.str()) : symName.str();
}
std::string lld::toString(const elf::Symbol &sym) {
static std::string maybeDemangleSymbol(StringRef symName) {
if (config->demangle) {
symName.consume_front("_");
- return demangle(symName.str());
+ return demangle(symName);
}
return symName.str();
}
if (name == "__main_argc_argv")
return "main";
if (wasm::config->demangle)
- return demangle(name.str());
+ return demangle(name);
return name.str();
}
Other Changes
-------------
+* ``llvm::demangle`` now takes a ``std::string_view`` rather than a
+ ``const std::string&``. Be careful passing temporaries into
+ ``llvm::demangle`` that don't outlive the expression using
+ ``llvm::demangle``.
+
External Open Source Projects Using LLVM 15
===========================================
#include <cstddef>
#include <string>
+#include <string_view>
namespace llvm {
/// This is a llvm local version of __cxa_demangle. Other than the name and
/// \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);
// We don't have a way to see if the symbol is compiler generated. Use
// the linkage name, to detect `scalar deleting destructor' functions.
- std::string DemangledSymbol = demangle(std::string(LinkageName));
+ std::string DemangledSymbol = demangle(LinkageName);
if (DemangledSymbol.find("scalar deleting dtor") != std::string::npos) {
Function->setIsArtificial();
} else {
//===----------------------------------------------------------------------===//
#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 (char *Demangled = microsoftDemangle(S, nullptr, nullptr)) {
Result = Demangled;
std::free(Demangled);
- return Result;
+ } else {
+ Result = MangledName;
}
+ return Result;
+}
- return MangledName;
+static bool isItaniumEncoding(std::string_view S) {
+ return starts_with(S, "_Z") || starts_with(S, "___Z");
}
+static bool isRustEncoding(std::string_view S) { return starts_with(S, "_R"); }
+
+static bool isDLangEncoding(std::string_view S) { return starts_with(S, "_D"); }
+
bool llvm::nonMicrosoftDemangle(const char *MangledName, std::string &Result) {
char *Demangled = nullptr;
if (isItaniumEncoding(MangledName))
}
void DiagnosticInfoDontCall::print(DiagnosticPrinter &DP) const {
- DP << "call to " << demangle(getFunctionName().str())
- << " marked \"dontcall-";
+ DP << "call to " << demangle(getFunctionName()) << " marked \"dontcall-";
if (getSeverity() == DiagnosticSeverity::DS_Error)
DP << "error\"";
else
Expected<StringRef> SymName = SI->getName();
if (!SymName)
return SymName.takeError();
- if (Demangle)
- Fmt << demangle(std::string(*SymName));
- else
- Fmt << *SymName;
+ Fmt << (Demangle ? demangle(*SymName) : *SymName);
}
} else {
Fmt << "*ABS*";
if (!SymNameOrErr)
return SymNameOrErr.takeError();
- std::string SymName = (*SymNameOrErr).str();
- if (Demangle)
- SymName = demangle(SymName);
-
+ std::string SymName =
+ Demangle ? demangle(*SymNameOrErr) : SymNameOrErr->str();
if (SymbolDescription)
SymName = getXCOFFSymbolDescription(createSymbolInfo(Obj, *SymI), SymName);
if (Demangle) {
// Fetch the demangled names and store them locally.
for (const SymbolInfoTy &Symbol : SymbolsHere)
- DemangledSymNamesHere.push_back(demangle(Symbol.Name.str()));
+ DemangledSymNamesHere.push_back(demangle(Symbol.Name));
// Now we've finished modifying that vector, it's safe to make
// a vector of StringRefs pointing into it.
SymNamesHere.insert(SymNamesHere.begin(), DemangledSymNamesHere.begin(),
if (TargetSym != nullptr) {
uint64_t TargetAddress = TargetSym->Addr;
uint64_t Disp = Target - TargetAddress;
- std::string TargetName = TargetSym->Name.str();
- if (Demangle)
- TargetName = demangle(TargetName);
+ std::string TargetName = Demangle ? demangle(TargetSym->Name)
+ : TargetSym->Name.str();
*TargetOS << " <";
if (!Disp) {
if (NameOrErr) {
outs() << " (csect:";
- std::string SymName(NameOrErr.get());
-
- if (Demangle)
- SymName = demangle(SymName);
+ std::string SymName =
+ Demangle ? demangle(*NameOrErr) : NameOrErr->str();
if (SymbolDescription)
SymName = getXCOFFSymbolDescription(createSymbolInfo(O, *SymRef),
outs() << " .hidden";
}
- std::string SymName(Name);
- if (Demangle)
- SymName = demangle(SymName);
-
+ std::string SymName = Demangle ? demangle(Name) : Name.str();
if (O.isXCOFF() && SymbolDescription)
SymName = getXCOFFSymbolDescription(createSymbolInfo(O, Symbol), SymName);
}
static std::string maybeDemangle(StringRef Name) {
- return opts::Demangle ? demangle(std::string(Name)) : Name.str();
+ return opts::Demangle ? demangle(Name) : Name.str();
}
template <typename ELFT>
std::string OutputName = "'";
OutputName += Name;
OutputName += "'";
- std::string DemangledName(demangle(Name.str()));
+ std::string DemangledName(demangle(Name));
if (Name != DemangledName) {
OutputName += " aka ";
OutputName += DemangledName;