llvm-project

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

9
#include "lldb/Core/RichManglingContext.h"
10
#include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
11
#include "lldb/Utility/LLDBLog.h"
12

13
#include "llvm/ADT/StringRef.h"
14

15
using namespace lldb;
16
using namespace lldb_private;
17

18
// RichManglingContext
19
RichManglingContext::~RichManglingContext() {
20
  std::free(m_ipd_buf);
21
  ResetCxxMethodParser();
22
}
23

24
void RichManglingContext::ResetCxxMethodParser() {
25
  // If we want to support parsers for other languages some day, we need a
26
  // switch here to delete the correct parser type.
27
  if (m_cxx_method_parser.has_value()) {
28
    assert(m_provider == PluginCxxLanguage);
29
    delete get<CPlusPlusLanguage::MethodName>(m_cxx_method_parser);
30
    m_cxx_method_parser.reset();
31
  }
32
}
33

34
void RichManglingContext::ResetProvider(InfoProvider new_provider) {
35
  ResetCxxMethodParser();
36

37
  assert(new_provider != None && "Only reset to a valid provider");
38
  m_provider = new_provider;
39
}
40

41
bool RichManglingContext::FromItaniumName(ConstString mangled) {
42
  bool err = m_ipd.partialDemangle(mangled.GetCString());
43
  if (!err) {
44
    ResetProvider(ItaniumPartialDemangler);
45
  }
46

47
  if (Log *log = GetLog(LLDBLog::Demangle)) {
48
    if (!err) {
49
      ParseFullName();
50
      LLDB_LOG(log, "demangled itanium: {0} -> \"{1}\"", mangled, m_ipd_buf);
51
    } else {
52
      LLDB_LOG(log, "demangled itanium: {0} -> error: failed to demangle",
53
               mangled);
54
    }
55
  }
56

57
  return !err; // true == success
58
}
59

60
bool RichManglingContext::FromCxxMethodName(ConstString demangled) {
61
  ResetProvider(PluginCxxLanguage);
62
  m_cxx_method_parser = new CPlusPlusLanguage::MethodName(demangled);
63
  return true;
64
}
65

66
bool RichManglingContext::IsCtorOrDtor() const {
67
  assert(m_provider != None && "Initialize a provider first");
68
  switch (m_provider) {
69
  case ItaniumPartialDemangler:
70
    return m_ipd.isCtorOrDtor();
71
  case PluginCxxLanguage: {
72
    // We can only check for destructors here.
73
    auto base_name =
74
        get<CPlusPlusLanguage::MethodName>(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

83
llvm::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}",
105
               m_ipd_buf_size);
106
  }
107

108
  // 99% case: Just remember the string length.
109
  return llvm::StringRef(m_ipd_buf, res_size - 1);
110
}
111

112
llvm::StringRef RichManglingContext::ParseFunctionBaseName() {
113
  assert(m_provider != None && "Initialize a provider first");
114
  switch (m_provider) {
115
  case ItaniumPartialDemangler: {
116
    auto n = m_ipd_buf_size;
117
    auto buf = m_ipd.getFunctionBaseName(m_ipd_buf, &n);
118
    return processIPDStrResult(buf, n);
119
  }
120
  case PluginCxxLanguage:
121
    return get<CPlusPlusLanguage::MethodName>(m_cxx_method_parser)
122
        ->GetBasename();
123
  case None:
124
    return {};
125
  }
126
  llvm_unreachable("Fully covered switch above!");
127
}
128

129
llvm::StringRef RichManglingContext::ParseFunctionDeclContextName() {
130
  assert(m_provider != None && "Initialize a provider first");
131
  switch (m_provider) {
132
  case ItaniumPartialDemangler: {
133
    auto n = m_ipd_buf_size;
134
    auto buf = m_ipd.getFunctionDeclContextName(m_ipd_buf, &n);
135
    return processIPDStrResult(buf, n);
136
  }
137
  case PluginCxxLanguage:
138
    return get<CPlusPlusLanguage::MethodName>(m_cxx_method_parser)
139
        ->GetContext();
140
  case None:
141
    return {};
142
  }
143
  llvm_unreachable("Fully covered switch above!");
144
}
145

146
llvm::StringRef RichManglingContext::ParseFullName() {
147
  assert(m_provider != None && "Initialize a provider first");
148
  switch (m_provider) {
149
  case ItaniumPartialDemangler: {
150
    auto n = m_ipd_buf_size;
151
    auto buf = m_ipd.finishDemangle(m_ipd_buf, &n);
152
    return processIPDStrResult(buf, n);
153
  }
154
  case PluginCxxLanguage:
155
    return get<CPlusPlusLanguage::MethodName>(m_cxx_method_parser)
156
        ->GetFullName()
157
        .GetStringRef();
158
  case None:
159
    return {};
160
  }
161
  llvm_unreachable("Fully covered switch above!");
162
}
163