1 //===-- ExpressionSourceCode.cpp --------------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "lldb/Expression/ExpressionSourceCode.h"
11 
12 #include "Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h"
13 #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
14 #include "lldb/Symbol/Block.h"
15 #include "lldb/Symbol/CompileUnit.h"
16 #include "lldb/Symbol/DebugMacros.h"
17 #include "lldb/Symbol/TypeSystem.h"
18 #include "lldb/Symbol/VariableList.h"
19 #include "lldb/Target/ExecutionContext.h"
20 #include "lldb/Target/Language.h"
21 #include "lldb/Target/Platform.h"
22 #include "lldb/Target/StackFrame.h"
23 #include "lldb/Target/Target.h"
24 #include "lldb/Utility/StreamString.h"
25 
26 using namespace lldb_private;
27 
28 const char *ExpressionSourceCode::g_expression_prefix = R"(
29 #ifndef NULL
30 #define NULL (__null)
31 #endif
32 #ifndef Nil
33 #define Nil (__null)
34 #endif
35 #ifndef nil
36 #define nil (__null)
37 #endif
38 #ifndef YES
39 #define YES ((BOOL)1)
40 #endif
41 #ifndef NO
42 #define NO ((BOOL)0)
43 #endif
44 typedef __INT8_TYPE__ int8_t;
45 typedef __UINT8_TYPE__ uint8_t;
46 typedef __INT16_TYPE__ int16_t;
47 typedef __UINT16_TYPE__ uint16_t;
48 typedef __INT32_TYPE__ int32_t;
49 typedef __UINT32_TYPE__ uint32_t;
50 typedef __INT64_TYPE__ int64_t;
51 typedef __UINT64_TYPE__ uint64_t;
52 typedef __INTPTR_TYPE__ intptr_t;
53 typedef __UINTPTR_TYPE__ uintptr_t;
54 typedef __SIZE_TYPE__ size_t;
55 typedef __PTRDIFF_TYPE__ ptrdiff_t;
56 typedef unsigned short unichar;
57 extern "C"
58 {
59     int printf(const char * __restrict, ...);
60 }
61 )";
62 
63 static const char *c_start_marker = "    /*LLDB_BODY_START*/\n    ";
64 static const char *c_end_marker = ";\n    /*LLDB_BODY_END*/\n";
65 
66 namespace {
67 
68 class AddMacroState {
69   enum State {
70     CURRENT_FILE_NOT_YET_PUSHED,
71     CURRENT_FILE_PUSHED,
72     CURRENT_FILE_POPPED
73   };
74 
75 public:
76   AddMacroState(const FileSpec &current_file, const uint32_t current_file_line)
77       : m_state(CURRENT_FILE_NOT_YET_PUSHED), m_current_file(current_file),
78         m_current_file_line(current_file_line) {}
79 
80   void StartFile(const FileSpec &file) {
81     m_file_stack.push_back(file);
82     if (file == m_current_file)
83       m_state = CURRENT_FILE_PUSHED;
84   }
85 
86   void EndFile() {
87     if (m_file_stack.size() == 0)
88       return;
89 
90     FileSpec old_top = m_file_stack.back();
91     m_file_stack.pop_back();
92     if (old_top == m_current_file)
93       m_state = CURRENT_FILE_POPPED;
94   }
95 
96   // An entry is valid if it occurs before the current line in the current
97   // file.
98   bool IsValidEntry(uint32_t line) {
99     switch (m_state) {
100     case CURRENT_FILE_NOT_YET_PUSHED:
101       return true;
102     case CURRENT_FILE_PUSHED:
103       // If we are in file included in the current file, the entry should be
104       // added.
105       if (m_file_stack.back() != m_current_file)
106         return true;
107 
108       return line < m_current_file_line;
109     default:
110       return false;
111     }
112   }
113 
114 private:
115   std::vector<FileSpec> m_file_stack;
116   State m_state;
117   FileSpec m_current_file;
118   uint32_t m_current_file_line;
119 };
120 
121 } // anonymous namespace
122 
123 static void AddMacros(const DebugMacros *dm, CompileUnit *comp_unit,
124                       AddMacroState &state, StreamString &stream) {
125   if (dm == nullptr)
126     return;
127 
128   for (size_t i = 0; i < dm->GetNumMacroEntries(); i++) {
129     const DebugMacroEntry &entry = dm->GetMacroEntryAtIndex(i);
130     uint32_t line;
131 
132     switch (entry.GetType()) {
133     case DebugMacroEntry::DEFINE:
134       if (state.IsValidEntry(entry.GetLineNumber()))
135         stream.Printf("#define %s\n", entry.GetMacroString().AsCString());
136       else
137         return;
138       break;
139     case DebugMacroEntry::UNDEF:
140       if (state.IsValidEntry(entry.GetLineNumber()))
141         stream.Printf("#undef %s\n", entry.GetMacroString().AsCString());
142       else
143         return;
144       break;
145     case DebugMacroEntry::START_FILE:
146       line = entry.GetLineNumber();
147       if (state.IsValidEntry(line))
148         state.StartFile(entry.GetFileSpec(comp_unit));
149       else
150         return;
151       break;
152     case DebugMacroEntry::END_FILE:
153       state.EndFile();
154       break;
155     case DebugMacroEntry::INDIRECT:
156       AddMacros(entry.GetIndirectDebugMacros(), comp_unit, state, stream);
157       break;
158     default:
159       // This is an unknown/invalid entry. Ignore.
160       break;
161     }
162   }
163 }
164 
165 static void AddLocalVariableDecls(const lldb::VariableListSP &var_list_sp,
166                                   StreamString &stream) {
167   for (size_t i = 0; i < var_list_sp->GetSize(); i++) {
168     lldb::VariableSP var_sp = var_list_sp->GetVariableAtIndex(i);
169 
170     ConstString var_name = var_sp->GetName();
171     if (!var_name || var_name == ConstString("this") ||
172         var_name == ConstString(".block_descriptor"))
173       continue;
174 
175     stream.Printf("using $__lldb_local_vars::%s;\n", var_name.AsCString());
176   }
177 }
178 
179 bool ExpressionSourceCode::GetText(std::string &text,
180                                    lldb::LanguageType wrapping_language,
181                                    bool static_method,
182                                    ExecutionContext &exe_ctx) const {
183   const char *target_specific_defines = "typedef signed char BOOL;\n";
184   std::string module_macros;
185 
186   Target *target = exe_ctx.GetTargetPtr();
187   if (target) {
188     if (target->GetArchitecture().GetMachine() == llvm::Triple::aarch64) {
189       target_specific_defines = "typedef bool BOOL;\n";
190     }
191     if (target->GetArchitecture().GetMachine() == llvm::Triple::x86_64) {
192       if (lldb::PlatformSP platform_sp = target->GetPlatform()) {
193         static ConstString g_platform_ios_simulator("ios-simulator");
194         if (platform_sp->GetPluginName() == g_platform_ios_simulator) {
195           target_specific_defines = "typedef bool BOOL;\n";
196         }
197       }
198     }
199 
200     if (ClangModulesDeclVendor *decl_vendor =
201             target->GetClangModulesDeclVendor()) {
202       ClangPersistentVariables *persistent_vars =
203           llvm::cast<ClangPersistentVariables>(
204               target->GetPersistentExpressionStateForLanguage(
205                   lldb::eLanguageTypeC));
206       const ClangModulesDeclVendor::ModuleVector &hand_imported_modules =
207           persistent_vars->GetHandLoadedClangModules();
208       ClangModulesDeclVendor::ModuleVector modules_for_macros;
209 
210       for (ClangModulesDeclVendor::ModuleID module : hand_imported_modules) {
211         modules_for_macros.push_back(module);
212       }
213 
214       if (target->GetEnableAutoImportClangModules()) {
215         if (StackFrame *frame = exe_ctx.GetFramePtr()) {
216           if (Block *block = frame->GetFrameBlock()) {
217             SymbolContext sc;
218 
219             block->CalculateSymbolContext(&sc);
220 
221             if (sc.comp_unit) {
222               StreamString error_stream;
223 
224               decl_vendor->AddModulesForCompileUnit(
225                   *sc.comp_unit, modules_for_macros, error_stream);
226             }
227           }
228         }
229       }
230 
231       decl_vendor->ForEachMacro(
232           modules_for_macros,
233           [&module_macros](const std::string &expansion) -> bool {
234             module_macros.append(expansion);
235             module_macros.append("\n");
236             return false;
237           });
238     }
239   }
240 
241   StreamString debug_macros_stream;
242   StreamString lldb_local_var_decls;
243   if (StackFrame *frame = exe_ctx.GetFramePtr()) {
244     const SymbolContext &sc = frame->GetSymbolContext(
245         lldb::eSymbolContextCompUnit | lldb::eSymbolContextLineEntry);
246 
247     if (sc.comp_unit && sc.line_entry.IsValid()) {
248       DebugMacros *dm = sc.comp_unit->GetDebugMacros();
249       if (dm) {
250         AddMacroState state(sc.line_entry.file, sc.line_entry.line);
251         AddMacros(dm, sc.comp_unit, state, debug_macros_stream);
252       }
253     }
254 
255     ConstString object_name;
256     if (Language::LanguageIsCPlusPlus(frame->GetLanguage())) {
257       if (target->GetInjectLocalVariables(&exe_ctx)) {
258         lldb::VariableListSP var_list_sp =
259             frame->GetInScopeVariableList(false, true);
260         AddLocalVariableDecls(var_list_sp, lldb_local_var_decls);
261       }
262     }
263   }
264 
265   if (m_wrap) {
266     switch (wrapping_language) {
267     default:
268       return false;
269     case lldb::eLanguageTypeC:
270     case lldb::eLanguageTypeC_plus_plus:
271     case lldb::eLanguageTypeObjC:
272       break;
273     }
274 
275     StreamString wrap_stream;
276 
277     wrap_stream.Printf("%s\n%s\n%s\n%s\n%s\n", module_macros.c_str(),
278                        debug_macros_stream.GetData(), g_expression_prefix,
279                        target_specific_defines, m_prefix.c_str());
280 
281     // First construct a tagged form of the user expression so we can find it
282     // later:
283     std::string tagged_body;
284     switch (wrapping_language) {
285     default:
286       tagged_body = m_body;
287       break;
288     case lldb::eLanguageTypeC:
289     case lldb::eLanguageTypeC_plus_plus:
290     case lldb::eLanguageTypeObjC:
291       tagged_body.append(c_start_marker);
292       tagged_body.append(m_body);
293       tagged_body.append(c_end_marker);
294       break;
295     }
296     switch (wrapping_language) {
297     default:
298       break;
299     case lldb::eLanguageTypeC:
300       wrap_stream.Printf("void                           \n"
301                          "%s(void *$__lldb_arg)          \n"
302                          "{                              \n"
303                          "    %s;                        \n"
304                          "%s"
305                          "}                              \n",
306                          m_name.c_str(), lldb_local_var_decls.GetData(),
307                          tagged_body.c_str());
308       break;
309     case lldb::eLanguageTypeC_plus_plus:
310       wrap_stream.Printf("void                                   \n"
311                          "$__lldb_class::%s(void *$__lldb_arg)   \n"
312                          "{                                      \n"
313                          "    %s;                                \n"
314                          "%s"
315                          "}                                      \n",
316                          m_name.c_str(), lldb_local_var_decls.GetData(),
317                          tagged_body.c_str());
318       break;
319     case lldb::eLanguageTypeObjC:
320       if (static_method) {
321         wrap_stream.Printf(
322             "@interface $__lldb_objc_class ($__lldb_category)        \n"
323             "+(void)%s:(void *)$__lldb_arg;                          \n"
324             "@end                                                    \n"
325             "@implementation $__lldb_objc_class ($__lldb_category)   \n"
326             "+(void)%s:(void *)$__lldb_arg                           \n"
327             "{                                                       \n"
328             "%s"
329             "}                                                       \n"
330             "@end                                                    \n",
331             m_name.c_str(), m_name.c_str(), tagged_body.c_str());
332       } else {
333         wrap_stream.Printf(
334             "@interface $__lldb_objc_class ($__lldb_category)       \n"
335             "-(void)%s:(void *)$__lldb_arg;                         \n"
336             "@end                                                   \n"
337             "@implementation $__lldb_objc_class ($__lldb_category)  \n"
338             "-(void)%s:(void *)$__lldb_arg                          \n"
339             "{                                                      \n"
340             "%s"
341             "}                                                      \n"
342             "@end                                                   \n",
343             m_name.c_str(), m_name.c_str(), tagged_body.c_str());
344       }
345       break;
346     }
347 
348     text = wrap_stream.GetString();
349   } else {
350     text.append(m_body);
351   }
352 
353   return true;
354 }
355 
356 bool ExpressionSourceCode::GetOriginalBodyBounds(
357     std::string transformed_text, lldb::LanguageType wrapping_language,
358     size_t &start_loc, size_t &end_loc) {
359   const char *start_marker;
360   const char *end_marker;
361 
362   switch (wrapping_language) {
363   default:
364     return false;
365   case lldb::eLanguageTypeC:
366   case lldb::eLanguageTypeC_plus_plus:
367   case lldb::eLanguageTypeObjC:
368     start_marker = c_start_marker;
369     end_marker = c_end_marker;
370     break;
371   }
372 
373   start_loc = transformed_text.find(start_marker);
374   if (start_loc == std::string::npos)
375     return false;
376   start_loc += strlen(start_marker);
377   end_loc = transformed_text.find(end_marker);
378   return end_loc != std::string::npos;
379 }
380