LLDB mainline
RichManglingContext.cpp
Go to the documentation of this file.
1//===-- RichManglingContext.cpp -------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
11
12#include "llvm/ADT/StringRef.h"
13
14using namespace lldb;
15using namespace lldb_private;
16
17// RichManglingContext
22
24 // If we want to support parsers for other languages some day, we need a
25 // switch here to delete the correct parser type.
28 m_cxx_method_parser.reset();
29 }
30}
31
34
35 assert(new_provider != None && "Only reset to a valid provider");
36 m_provider = new_provider;
37}
38
40 bool err = m_ipd.partialDemangle(mangled.GetCString());
41 if (!err) {
43 }
44
45 if (Log *log = GetLog(LLDBLog::Demangle)) {
46 if (!err) {
48 LLDB_LOG(log, "demangled itanium: {0} -> \"{1}\"", mangled, m_ipd_buf);
49 } else {
50 LLDB_LOG(log, "demangled itanium: {0} -> error: failed to demangle",
51 mangled);
52 }
53 }
54
55 return !err; // true == success
56}
57
60 if (!lang)
61 return false;
63 m_cxx_method_parser = lang->GetMethodName(demangled);
64 return true;
65}
66
68 assert(m_provider != None && "Initialize a provider first");
69 switch (m_provider) {
71 return m_ipd.isCtorOrDtor();
72 case PluginCxxLanguage: {
73 // We can only check for destructors here.
74 auto base_name = m_cxx_method_parser->GetBasename();
75 return base_name.starts_with("~");
76 }
77 case None:
78 return false;
79 }
80 llvm_unreachable("Fully covered switch above!");
81}
82
83llvm::StringRef RichManglingContext::processIPDStrResult(char *ipd_res,
84 size_t res_size) {
85 // Error case: Clear the buffer.
86 if (LLVM_UNLIKELY(ipd_res == nullptr)) {
87 assert(res_size == m_ipd_buf_size &&
88 "Failed IPD queries keep the original size in the N parameter");
89
90 m_ipd_buf[0] = '\0';
91 return llvm::StringRef(m_ipd_buf, 0);
92 }
93
94 // IPD's res_size includes null terminator.
95 assert(ipd_res[res_size - 1] == '\0' &&
96 "IPD returns null-terminated strings and we rely on that");
97
98 // Update buffer/size on realloc.
99 if (LLVM_UNLIKELY(ipd_res != m_ipd_buf || res_size > m_ipd_buf_size)) {
100 m_ipd_buf = ipd_res; // std::realloc freed or reused the old buffer.
101 m_ipd_buf_size = res_size; // May actually be bigger, but we can't know.
102
103 if (Log *log = GetLog(LLDBLog::Demangle))
104 LLDB_LOG(log, "ItaniumPartialDemangler Realloc: new buffer size is {0}",
106 }
107
108 // 99% case: Just remember the string length.
109 return llvm::StringRef(m_ipd_buf, res_size - 1);
110}
111
113 assert(m_provider != None && "Initialize a provider first");
114 switch (m_provider) {
116 auto n = m_ipd_buf_size;
117 auto buf = m_ipd.getFunctionBaseName(m_ipd_buf, &n);
118 return processIPDStrResult(buf, n);
119 }
121 return m_cxx_method_parser->GetBasename();
122 case None:
123 return {};
124 }
125 llvm_unreachable("Fully covered switch above!");
126}
127
129 assert(m_provider != None && "Initialize a provider first");
130 switch (m_provider) {
132 auto n = m_ipd_buf_size;
133 auto buf = m_ipd.getFunctionDeclContextName(m_ipd_buf, &n);
134 return processIPDStrResult(buf, n);
135 }
137 return m_cxx_method_parser->GetContext();
138 case None:
139 return {};
140 }
141 llvm_unreachable("Fully covered switch above!");
142}
143
145 assert(m_provider != None && "Initialize a provider first");
146 switch (m_provider) {
148 auto n = m_ipd_buf_size;
149 auto buf = m_ipd.finishDemangle(m_ipd_buf, &n);
150 return processIPDStrResult(buf, n);
151 }
153 return m_cxx_method_parser->GetFullName().GetStringRef();
154 case None:
155 return {};
156 }
157 llvm_unreachable("Fully covered switch above!");
158}
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
Definition Log.h:369
A uniqued constant string class.
Definition ConstString.h:40
const char * GetCString() const
Get the string value as a C string.
static Language * FindPlugin(lldb::LanguageType language)
Definition Language.cpp:84
llvm::StringRef ParseFunctionDeclContextName()
Get the context name for a function.
llvm::StringRef ParseFunctionBaseName()
Get the base name of a function.
void ResetProvider(InfoProvider new_provider)
Clean up memory and set a new info provider for this instance.
bool FromItaniumName(ConstString mangled)
Use the ItaniumPartialDemangler to obtain rich mangling information from the given mangled name.
char * m_ipd_buf
Note: m_ipd_buf is a raw pointer due to being resized by realloc via ItaniumPartialDemangler.
llvm::StringRef processIPDStrResult(char *ipd_res, size_t res_len)
Uniform handling of string buffers for ItaniumPartialDemangler.
std::unique_ptr< Language::MethodName > m_cxx_method_parser
bool FromCxxMethodName(ConstString demangled)
Use the legacy language parser implementation to obtain rich mangling information from the given dema...
void ResetCxxMethodParser()
Clean up memory when using PluginCxxLanguage.
InfoProvider m_provider
Selects the rich mangling info provider.
llvm::StringRef ParseFullName()
Get the entire demangled name.
llvm::ItaniumPartialDemangler m_ipd
Members for ItaniumPartialDemangler.
bool IsCtorOrDtor() const
If this symbol describes a constructor or destructor.
A class that represents a running process on the host machine.
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition Log.h:332
@ eLanguageTypeC_plus_plus
ISO C++:1998.