LLDB  mainline
ClangExpressionSourceCode.cpp
Go to the documentation of this file.
1 //===-- ClangExpressionSourceCode.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 
10 
11 #include "clang/Basic/CharInfo.h"
12 #include "clang/Basic/FileManager.h"
13 #include "clang/Basic/SourceManager.h"
14 #include "clang/Lex/Lexer.h"
15 #include "llvm/ADT/StringRef.h"
16 
19 #include "lldb/Symbol/Block.h"
22 #include "lldb/Symbol/TypeSystem.h"
25 #include "lldb/Target/Language.h"
26 #include "lldb/Target/Platform.h"
27 #include "lldb/Target/StackFrame.h"
28 #include "lldb/Target/Target.h"
30 
31 using namespace lldb_private;
32 
33 #define PREFIX_NAME "<lldb wrapper prefix>"
34 #define SUFFIX_NAME "<lldb wrapper suffix>"
35 
37 
39 "#line 1 \"" PREFIX_NAME R"("
40 #ifndef offsetof
41 #define offsetof(t, d) __builtin_offsetof(t, d)
42 #endif
43 #ifndef NULL
44 #define NULL (__null)
45 #endif
46 #ifndef Nil
47 #define Nil (__null)
48 #endif
49 #ifndef nil
50 #define nil (__null)
51 #endif
52 #ifndef YES
53 #define YES ((BOOL)1)
54 #endif
55 #ifndef NO
56 #define NO ((BOOL)0)
57 #endif
58 typedef __INT8_TYPE__ int8_t;
59 typedef __UINT8_TYPE__ uint8_t;
60 typedef __INT16_TYPE__ int16_t;
61 typedef __UINT16_TYPE__ uint16_t;
62 typedef __INT32_TYPE__ int32_t;
63 typedef __UINT32_TYPE__ uint32_t;
64 typedef __INT64_TYPE__ int64_t;
65 typedef __UINT64_TYPE__ uint64_t;
66 typedef __INTPTR_TYPE__ intptr_t;
67 typedef __UINTPTR_TYPE__ uintptr_t;
68 typedef __SIZE_TYPE__ size_t;
69 typedef __PTRDIFF_TYPE__ ptrdiff_t;
70 typedef unsigned short unichar;
71 extern "C"
72 {
73  int printf(const char * __restrict, ...);
74 }
75 )";
76 
78  "\n;\n#line 1 \"" SUFFIX_NAME "\"\n";
79 
80 namespace {
81 
82 class AddMacroState {
83  enum State {
84  CURRENT_FILE_NOT_YET_PUSHED,
85  CURRENT_FILE_PUSHED,
86  CURRENT_FILE_POPPED
87  };
88 
89 public:
90  AddMacroState(const FileSpec &current_file, const uint32_t current_file_line)
91  : m_state(CURRENT_FILE_NOT_YET_PUSHED), m_current_file(current_file),
92  m_current_file_line(current_file_line) {}
93 
94  void StartFile(const FileSpec &file) {
95  m_file_stack.push_back(file);
96  if (file == m_current_file)
97  m_state = CURRENT_FILE_PUSHED;
98  }
99 
100  void EndFile() {
101  if (m_file_stack.size() == 0)
102  return;
103 
104  FileSpec old_top = m_file_stack.back();
105  m_file_stack.pop_back();
106  if (old_top == m_current_file)
107  m_state = CURRENT_FILE_POPPED;
108  }
109 
110  // An entry is valid if it occurs before the current line in the current
111  // file.
112  bool IsValidEntry(uint32_t line) {
113  switch (m_state) {
114  case CURRENT_FILE_NOT_YET_PUSHED:
115  return true;
116  case CURRENT_FILE_PUSHED:
117  // If we are in file included in the current file, the entry should be
118  // added.
119  if (m_file_stack.back() != m_current_file)
120  return true;
121 
122  return line < m_current_file_line;
123  default:
124  return false;
125  }
126  }
127 
128 private:
129  std::vector<FileSpec> m_file_stack;
130  State m_state;
131  FileSpec m_current_file;
132  uint32_t m_current_file_line;
133 };
134 
135 } // anonymous namespace
136 
137 static void AddMacros(const DebugMacros *dm, CompileUnit *comp_unit,
138  AddMacroState &state, StreamString &stream) {
139  if (dm == nullptr)
140  return;
141 
142  for (size_t i = 0; i < dm->GetNumMacroEntries(); i++) {
143  const DebugMacroEntry &entry = dm->GetMacroEntryAtIndex(i);
144  uint32_t line;
145 
146  switch (entry.GetType()) {
148  if (state.IsValidEntry(entry.GetLineNumber()))
149  stream.Printf("#define %s\n", entry.GetMacroString().AsCString());
150  else
151  return;
152  break;
154  if (state.IsValidEntry(entry.GetLineNumber()))
155  stream.Printf("#undef %s\n", entry.GetMacroString().AsCString());
156  else
157  return;
158  break;
160  line = entry.GetLineNumber();
161  if (state.IsValidEntry(line))
162  state.StartFile(entry.GetFileSpec(comp_unit));
163  else
164  return;
165  break;
167  state.EndFile();
168  break;
170  AddMacros(entry.GetIndirectDebugMacros(), comp_unit, state, stream);
171  break;
172  default:
173  // This is an unknown/invalid entry. Ignore.
174  break;
175  }
176  }
177 }
178 
180  llvm::StringRef filename, llvm::StringRef name, llvm::StringRef prefix,
181  llvm::StringRef body, Wrapping wrap, WrapKind wrap_kind)
182  : ExpressionSourceCode(name, prefix, body, wrap), m_wrap_kind(wrap_kind) {
183  // Use #line markers to pretend that we have a single-line source file
184  // containing only the user expression. This will hide our wrapper code
185  // from the user when we render diagnostics with Clang.
186  m_start_marker = "#line 1 \"" + filename.str() + "\"\n";
188 }
189 
190 namespace {
191 /// Allows checking if a token is contained in a given expression.
192 class TokenVerifier {
193  /// The tokens we found in the expression.
194  llvm::StringSet<> m_tokens;
195 
196 public:
197  TokenVerifier(std::string body);
198  /// Returns true iff the given expression body contained a token with the
199  /// given content.
200  bool hasToken(llvm::StringRef token) const {
201  return m_tokens.find(token) != m_tokens.end();
202  }
203 };
204 } // namespace
205 
206 TokenVerifier::TokenVerifier(std::string body) {
207  using namespace clang;
208 
209  // We only care about tokens and not their original source locations. If we
210  // move the whole expression to only be in one line we can simplify the
211  // following code that extracts the token contents.
212  std::replace(body.begin(), body.end(), '\n', ' ');
213  std::replace(body.begin(), body.end(), '\r', ' ');
214 
215  FileSystemOptions file_opts;
216  FileManager file_mgr(file_opts,
217  FileSystem::Instance().GetVirtualFileSystem());
218 
219  // Let's build the actual source code Clang needs and setup some utility
220  // objects.
221  llvm::IntrusiveRefCntPtr<DiagnosticIDs> diag_ids(new DiagnosticIDs());
222  llvm::IntrusiveRefCntPtr<DiagnosticOptions> diags_opts(
223  new DiagnosticOptions());
224  DiagnosticsEngine diags(diag_ids, diags_opts);
225  clang::SourceManager SM(diags, file_mgr);
226  auto buf = llvm::MemoryBuffer::getMemBuffer(body);
227 
228  FileID FID = SM.createFileID(buf->getMemBufferRef());
229 
230  // Let's just enable the latest ObjC and C++ which should get most tokens
231  // right.
232  LangOptions Opts;
233  Opts.ObjC = true;
234  Opts.DollarIdents = true;
235  Opts.CPlusPlus17 = true;
236  Opts.LineComment = true;
237 
238  Lexer lex(FID, buf->getMemBufferRef(), SM, Opts);
239 
240  Token token;
241  bool exit = false;
242  while (!exit) {
243  // Returns true if this is the last token we get from the lexer.
244  exit = lex.LexFromRawLexer(token);
245 
246  // Extract the column number which we need to extract the token content.
247  // Our expression is just one line, so we don't need to handle any line
248  // numbers here.
249  bool invalid = false;
250  unsigned start = SM.getSpellingColumnNumber(token.getLocation(), &invalid);
251  if (invalid)
252  continue;
253  // Column numbers start at 1, but indexes in our string start at 0.
254  --start;
255 
256  // Annotations don't have a length, so let's skip them.
257  if (token.isAnnotation())
258  continue;
259 
260  // Extract the token string from our source code and store it.
261  std::string token_str = body.substr(start, token.getLength());
262  if (token_str.empty())
263  continue;
264  m_tokens.insert(token_str);
265  }
266 }
267 
269  const lldb::VariableListSP &var_list_sp, StreamString &stream,
270  const std::string &expr) const {
271  TokenVerifier tokens(expr);
272 
273  for (size_t i = 0; i < var_list_sp->GetSize(); i++) {
274  lldb::VariableSP var_sp = var_list_sp->GetVariableAtIndex(i);
275 
276  ConstString var_name = var_sp->GetName();
277 
278 
279  // We can check for .block_descriptor w/o checking for langauge since this
280  // is not a valid identifier in either C or C++.
281  if (!var_name || var_name == ".block_descriptor")
282  continue;
283 
284  if (!expr.empty() && !tokens.hasToken(var_name.GetStringRef()))
285  continue;
286 
287  const bool is_objc = m_wrap_kind == WrapKind::ObjCInstanceMethod ||
289  if ((var_name == "self" || var_name == "_cmd") && is_objc)
290  continue;
291 
292  if (var_name == "this" && m_wrap_kind == WrapKind::CppMemberFunction)
293  continue;
294 
295  stream.Printf("using $__lldb_local_vars::%s;\n", var_name.AsCString());
296  }
297 }
298 
300  std::string &text, ExecutionContext &exe_ctx, bool add_locals,
301  bool force_add_all_locals, llvm::ArrayRef<std::string> modules) const {
302  const char *target_specific_defines = "typedef signed char BOOL;\n";
303  std::string module_macros;
304  llvm::raw_string_ostream module_macros_stream(module_macros);
305 
306  Target *target = exe_ctx.GetTargetPtr();
307  if (target) {
308  if (target->GetArchitecture().GetMachine() == llvm::Triple::aarch64 ||
309  target->GetArchitecture().GetMachine() == llvm::Triple::aarch64_32) {
310  target_specific_defines = "typedef bool BOOL;\n";
311  }
312  if (target->GetArchitecture().GetMachine() == llvm::Triple::x86_64) {
313  if (lldb::PlatformSP platform_sp = target->GetPlatform()) {
314  if (platform_sp->GetPluginName() == "ios-simulator") {
315  target_specific_defines = "typedef bool BOOL;\n";
316  }
317  }
318  }
319 
320  auto *persistent_vars = llvm::cast<ClangPersistentVariables>(
322  std::shared_ptr<ClangModulesDeclVendor> decl_vendor =
323  persistent_vars->GetClangModulesDeclVendor();
324  if (decl_vendor) {
325  const ClangModulesDeclVendor::ModuleVector &hand_imported_modules =
326  persistent_vars->GetHandLoadedClangModules();
327  ClangModulesDeclVendor::ModuleVector modules_for_macros;
328 
329  for (ClangModulesDeclVendor::ModuleID module : hand_imported_modules) {
330  modules_for_macros.push_back(module);
331  }
332 
333  if (target->GetEnableAutoImportClangModules()) {
334  if (StackFrame *frame = exe_ctx.GetFramePtr()) {
335  if (Block *block = frame->GetFrameBlock()) {
336  SymbolContext sc;
337 
338  block->CalculateSymbolContext(&sc);
339 
340  if (sc.comp_unit) {
341  StreamString error_stream;
342 
343  decl_vendor->AddModulesForCompileUnit(
344  *sc.comp_unit, modules_for_macros, error_stream);
345  }
346  }
347  }
348  }
349 
350  decl_vendor->ForEachMacro(
351  modules_for_macros,
352  [&module_macros_stream](llvm::StringRef token,
353  llvm::StringRef expansion) -> bool {
354  // Check if the macro hasn't already been defined in the
355  // g_expression_prefix (which defines a few builtin macros).
356  module_macros_stream << "#ifndef " << token << "\n";
357  module_macros_stream << expansion << "\n";
358  module_macros_stream << "#endif\n";
359  return false;
360  });
361  }
362  }
363 
364  StreamString debug_macros_stream;
365  StreamString lldb_local_var_decls;
366  if (StackFrame *frame = exe_ctx.GetFramePtr()) {
367  const SymbolContext &sc = frame->GetSymbolContext(
368  lldb::eSymbolContextCompUnit | lldb::eSymbolContextLineEntry);
369 
370  if (sc.comp_unit && sc.line_entry.IsValid()) {
372  if (dm) {
373  AddMacroState state(sc.line_entry.file, sc.line_entry.line);
374  AddMacros(dm, sc.comp_unit, state, debug_macros_stream);
375  }
376  }
377 
378  if (add_locals)
379  if (target->GetInjectLocalVariables(&exe_ctx)) {
380  lldb::VariableListSP var_list_sp =
381  frame->GetInScopeVariableList(false, true);
382  AddLocalVariableDecls(var_list_sp, lldb_local_var_decls,
383  force_add_all_locals ? "" : m_body);
384  }
385  }
386 
387  if (m_wrap) {
388  // Generate a list of @import statements that will import the specified
389  // module into our expression.
390  std::string module_imports;
391  for (const std::string &module : modules) {
392  module_imports.append("@import ");
393  module_imports.append(module);
394  module_imports.append(";\n");
395  }
396 
397  StreamString wrap_stream;
398 
399  wrap_stream.Printf("%s\n%s\n%s\n%s\n%s\n", g_expression_prefix,
400  module_macros.c_str(), debug_macros_stream.GetData(),
401  target_specific_defines, m_prefix.c_str());
402 
403  // First construct a tagged form of the user expression so we can find it
404  // later:
405  std::string tagged_body;
406  tagged_body.append(m_start_marker);
407  tagged_body.append(m_body);
408  tagged_body.append(m_end_marker);
409 
410  switch (m_wrap_kind) {
411  case WrapKind::Function:
412  wrap_stream.Printf("%s"
413  "void \n"
414  "%s(void *$__lldb_arg) \n"
415  "{ \n"
416  " %s; \n"
417  "%s"
418  "} \n",
419  module_imports.c_str(), m_name.c_str(),
420  lldb_local_var_decls.GetData(), tagged_body.c_str());
421  break;
423  wrap_stream.Printf("%s"
424  "void \n"
425  "$__lldb_class::%s(void *$__lldb_arg) \n"
426  "{ \n"
427  " %s; \n"
428  "%s"
429  "} \n",
430  module_imports.c_str(), m_name.c_str(),
431  lldb_local_var_decls.GetData(), tagged_body.c_str());
432  break;
434  wrap_stream.Printf(
435  "%s"
436  "@interface $__lldb_objc_class ($__lldb_category) \n"
437  "-(void)%s:(void *)$__lldb_arg; \n"
438  "@end \n"
439  "@implementation $__lldb_objc_class ($__lldb_category) \n"
440  "-(void)%s:(void *)$__lldb_arg \n"
441  "{ \n"
442  " %s; \n"
443  "%s"
444  "} \n"
445  "@end \n",
446  module_imports.c_str(), m_name.c_str(), m_name.c_str(),
447  lldb_local_var_decls.GetData(), tagged_body.c_str());
448  break;
449 
451  wrap_stream.Printf(
452  "%s"
453  "@interface $__lldb_objc_class ($__lldb_category) \n"
454  "+(void)%s:(void *)$__lldb_arg; \n"
455  "@end \n"
456  "@implementation $__lldb_objc_class ($__lldb_category) \n"
457  "+(void)%s:(void *)$__lldb_arg \n"
458  "{ \n"
459  " %s; \n"
460  "%s"
461  "} \n"
462  "@end \n",
463  module_imports.c_str(), m_name.c_str(), m_name.c_str(),
464  lldb_local_var_decls.GetData(), tagged_body.c_str());
465  break;
466  }
467 
468  text = std::string(wrap_stream.GetString());
469  } else {
470  text.append(m_body);
471  }
472 
473  return true;
474 }
475 
477  std::string transformed_text, size_t &start_loc, size_t &end_loc) {
478  start_loc = transformed_text.find(m_start_marker);
479  if (start_loc == std::string::npos)
480  return false;
481  start_loc += m_start_marker.size();
482  end_loc = transformed_text.find(m_end_marker);
483  return end_loc != std::string::npos;
484 }
Block.h
lldb_private::ClangExpressionSourceCode::WrapKind::ObjCInstanceMethod
@ ObjCInstanceMethod
Wrapped in an instance Objective-C method.
lldb_private::ExecutionContext
Definition: ExecutionContext.h:292
lldb_private::SymbolContext::comp_unit
CompileUnit * comp_unit
The CompileUnit for a given query.
Definition: SymbolContext.h:319
ClangExpressionSourceCode.h
lldb_private::LineEntry::file
FileSpec file
The source file, possibly mapped by the target.source-map setting.
Definition: LineEntry.h:140
lldb_private::ClangExpressionSourceCode::WrapKind::CppMemberFunction
@ CppMemberFunction
Wrapped in a non-static member function of a C++ class.
ClangModulesDeclVendor.h
lldb_private::ArchSpec::GetMachine
llvm::Triple::ArchType GetMachine() const
Returns a machine family for the current architecture.
Definition: ArchSpec.cpp:667
CompileUnit.h
lldb_private::LineEntry::IsValid
bool IsValid() const
Check if a line entry object is valid.
Definition: LineEntry.cpp:46
lldb_private::ClangExpressionSourceCode::AddLocalVariableDecls
void AddLocalVariableDecls(const lldb::VariableListSP &var_list_sp, StreamString &stream, const std::string &expr) const
Definition: ClangExpressionSourceCode.cpp:268
lldb_private::DebugMacros
Definition: DebugMacros.h:71
lldb_private::ClangExpressionSourceCode::g_expression_suffix
static const char * g_expression_suffix
Definition: ClangExpressionSourceCode.h:30
lldb_private::ClangExpressionSourceCode::m_end_marker
std::string m_end_marker
String marking the end of the user expression.
Definition: ClangExpressionSourceCode.h:88
lldb_private::ClangExpressionSourceCode::g_prefix_file_name
static const llvm::StringRef g_prefix_file_name
The file name we use for the wrapper code that we inject before the user expression.
Definition: ClangExpressionSourceCode.h:28
lldb_private::TargetProperties::GetInjectLocalVariables
bool GetInjectLocalVariables(ExecutionContext *exe_ctx) const
Definition: Target.cpp:3786
lldb_private::ClangExpressionSourceCode::m_start_marker
std::string m_start_marker
String marking the start of the user expression.
Definition: ClangExpressionSourceCode.h:86
lldb_private::ClangExpressionSourceCode::g_expression_prefix
static const char * g_expression_prefix
Definition: ClangExpressionSourceCode.h:29
lldb_private::ExecutionContext::GetFramePtr
StackFrame * GetFramePtr() const
Returns a pointer to the frame object.
Definition: ExecutionContext.h:408
lldb_private::ConstString::AsCString
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:193
StackFrame.h
lldb_private::ClangExpressionSourceCode::GetText
bool GetText(std::string &text, ExecutionContext &exe_ctx, bool add_locals, bool force_add_all_locals, llvm::ArrayRef< std::string > modules) const
Generates the source code that will evaluate the expression.
Definition: ClangExpressionSourceCode.cpp:299
Language.h
lldb_private::ExpressionSourceCode::m_name
std::string m_name
Definition: ExpressionSourceCode.h:38
lldb_private::DebugMacroEntry::GetIndirectDebugMacros
DebugMacros * GetIndirectDebugMacros() const
Definition: DebugMacros.h:54
lldb_private::SymbolContext
Definition: SymbolContext.h:33
lldb_private::Target
Definition: Target.h:450
lldb_private::StreamString::GetString
llvm::StringRef GetString() const
Definition: StreamString.cpp:51
lldb_private::CompileUnit
Definition: CompileUnit.h:38
lldb_private::CompileUnit::GetDebugMacros
DebugMacros * GetDebugMacros()
Definition: CompileUnit.cpp:188
Target.h
lldb_private::DebugMacros::GetMacroEntryAtIndex
DebugMacroEntry GetMacroEntryAtIndex(const size_t index) const
Definition: DebugMacros.h:83
lldb_private::Target::GetPlatform
lldb::PlatformSP GetPlatform()
Definition: Target.h:1341
lldb_private::ExpressionSourceCode::m_prefix
std::string m_prefix
Definition: ExpressionSourceCode.h:39
Platform.h
lldb_private::FileSpec
Definition: FileSpec.h:56
lldb_private::DebugMacroEntry::GetType
EntryType GetType() const
Definition: DebugMacros.h:46
AddMacros
static void AddMacros(const DebugMacros *dm, CompileUnit *comp_unit, AddMacroState &state, StreamString &stream)
Definition: ClangExpressionSourceCode.cpp:137
lldb_private::ConstString::GetStringRef
llvm::StringRef GetStringRef() const
Get the string value as a llvm::StringRef.
Definition: ConstString.h:202
lldb_private::ClangModulesDeclVendor::ModuleVector
std::vector< ModuleID > ModuleVector
Definition: ClangModulesDeclVendor.h:37
lldb_private::ClangExpressionSourceCode::GetOriginalBodyBounds
bool GetOriginalBodyBounds(std::string transformed_text, size_t &start_loc, size_t &end_loc)
Definition: ClangExpressionSourceCode.cpp:476
lldb_private::StreamString::GetData
const char * GetData() const
Definition: StreamString.h:43
StreamString.h
ClangPersistentVariables.h
lldb_private::ClangExpressionSourceCode::ClangExpressionSourceCode
ClangExpressionSourceCode(llvm::StringRef filename, llvm::StringRef name, llvm::StringRef prefix, llvm::StringRef body, Wrapping wrap, WrapKind wrap_kind)
Definition: ClangExpressionSourceCode.cpp:179
lldb_private::DebugMacroEntry
Definition: DebugMacros.h:24
lldb_private::ConstString
Definition: ConstString.h:40
lldb_private::DebugMacroEntry::INDIRECT
@ INDIRECT
Definition: DebugMacros.h:27
lldb_private::StreamString
Definition: StreamString.h:23
lldb_private::ClangModulesDeclVendor::ModuleID
uintptr_t ModuleID
Definition: ClangModulesDeclVendor.h:36
lldb_private::DebugMacroEntry::START_FILE
@ START_FILE
Definition: DebugMacros.h:27
lldb_private::DebugMacroEntry::DEFINE
@ DEFINE
Definition: DebugMacros.h:27
lldb_private::Target::GetPersistentExpressionStateForLanguage
PersistentExpressionState * GetPersistentExpressionStateForLanguage(lldb::LanguageType language)
Definition: Target.cpp:2261
string
string(SUBSTRING ${p} 10 -1 pStripped) if($
Definition: Plugins/CMakeLists.txt:40
TypeSystem.h
lldb_private::ClangExpressionSourceCode::WrapKind
WrapKind
The possible ways an expression can be wrapped.
Definition: ClangExpressionSourceCode.h:33
VariableList.h
lldb_private::DebugMacroEntry::GetLineNumber
uint64_t GetLineNumber() const
Definition: DebugMacros.h:48
lldb_private::LineEntry::line
uint32_t line
The source line number, or zero if there is no line number information.
Definition: LineEntry.h:143
lldb_private::ExpressionSourceCode::Wrapping
Wrapping
Definition: ExpressionSourceCode.h:22
lldb_private::DebugMacroEntry::END_FILE
@ END_FILE
Definition: DebugMacros.h:27
lldb_private::ExpressionSourceCode
Definition: ExpressionSourceCode.h:20
lldb_private::Target::GetArchitecture
const ArchSpec & GetArchitecture() const
Definition: Target.h:966
lldb_private::Block
Definition: Block.h:41
lldb_private::TargetProperties::GetEnableAutoImportClangModules
bool GetEnableAutoImportClangModules() const
Definition: Target.cpp:4067
uint32_t
SUFFIX_NAME
#define SUFFIX_NAME
Definition: ClangExpressionSourceCode.cpp:34
lldb_private::ExpressionSourceCode::m_wrap
Wrapping m_wrap
Definition: ExpressionSourceCode.h:41
clang
Definition: ASTResultSynthesizer.h:15
lldb_private::Stream::Printf
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:107
lldb_private::ClangExpressionSourceCode::WrapKind::Function
@ Function
Wrapped in a non-member function.
lldb_private::FileSystem::Instance
static FileSystem & Instance()
Definition: common/FileSystem.cpp:45
lldb_private::ClangExpressionSourceCode::WrapKind::ObjCStaticMethod
@ ObjCStaticMethod
Wrapped in a static Objective-C method.
lldb::eLanguageTypeC
@ eLanguageTypeC
Non-standardized C, such as K&R.
Definition: lldb-enumerations.h:439
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::DebugMacros::GetNumMacroEntries
size_t GetNumMacroEntries() const
Definition: DebugMacros.h:81
lldb_private::ExpressionSourceCode::m_body
std::string m_body
Definition: ExpressionSourceCode.h:40
DebugMacros.h
lldb_private::SymbolContext::line_entry
LineEntry line_entry
The LineEntry for a given query.
Definition: SymbolContext.h:322
lldb_private::DebugMacroEntry::UNDEF
@ UNDEF
Definition: DebugMacros.h:27
lldb_private::ClangExpressionSourceCode::m_wrap_kind
const WrapKind m_wrap_kind
How the expression has been wrapped.
Definition: ClangExpressionSourceCode.h:90
lldb_private::StackFrame
Definition: StackFrame.h:40
lldb_private::ExecutionContext::GetTargetPtr
Target * GetTargetPtr() const
Returns a pointer to the target object.
Definition: ExecutionContext.cpp:200
ExecutionContext.h
PREFIX_NAME
#define PREFIX_NAME
Definition: ClangExpressionSourceCode.cpp:33
lldb_private::DebugMacroEntry::GetFileSpec
const FileSpec & GetFileSpec(CompileUnit *comp_unit) const
Definition: DebugMacros.cpp:25
lldb_private::DebugMacroEntry::GetMacroString
ConstString GetMacroString() const
Definition: DebugMacros.h:50