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 9 #include "ClangExpressionSourceCode.h" 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 17 #include "Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h" 18 #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h" 19 #include "lldb/Symbol/Block.h" 20 #include "lldb/Symbol/CompileUnit.h" 21 #include "lldb/Symbol/DebugMacros.h" 22 #include "lldb/Symbol/TypeSystem.h" 23 #include "lldb/Symbol/VariableList.h" 24 #include "lldb/Target/ExecutionContext.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" 29 #include "lldb/Utility/StreamString.h" 30 31 using namespace lldb_private; 32 33 #define PREFIX_NAME "<lldb wrapper prefix>" 34 #define SUFFIX_NAME "<lldb wrapper suffix>" 35 36 const llvm::StringRef ClangExpressionSourceCode::g_prefix_file_name = PREFIX_NAME; 37 38 const char *ClangExpressionSourceCode::g_expression_prefix = 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 77 const char *ClangExpressionSourceCode::g_expression_suffix = 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 ¤t_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()) { 147 case DebugMacroEntry::DEFINE: 148 if (state.IsValidEntry(entry.GetLineNumber())) 149 stream.Printf("#define %s\n", entry.GetMacroString().AsCString()); 150 else 151 return; 152 break; 153 case DebugMacroEntry::UNDEF: 154 if (state.IsValidEntry(entry.GetLineNumber())) 155 stream.Printf("#undef %s\n", entry.GetMacroString().AsCString()); 156 else 157 return; 158 break; 159 case DebugMacroEntry::START_FILE: 160 line = entry.GetLineNumber(); 161 if (state.IsValidEntry(line)) 162 state.StartFile(entry.GetFileSpec(comp_unit)); 163 else 164 return; 165 break; 166 case DebugMacroEntry::END_FILE: 167 state.EndFile(); 168 break; 169 case DebugMacroEntry::INDIRECT: 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 179 lldb_private::ClangExpressionSourceCode::ClangExpressionSourceCode( 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"; 187 m_end_marker = g_expression_suffix; 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 268 void ClangExpressionSourceCode::AddLocalVariableDecls( 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 || 288 m_wrap_kind == WrapKind::ObjCStaticMethod; 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 299 bool ClangExpressionSourceCode::GetText( 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 static ConstString g_platform_ios_simulator("ios-simulator"); 315 if (platform_sp->GetPluginName() == g_platform_ios_simulator) { 316 target_specific_defines = "typedef bool BOOL;\n"; 317 } 318 } 319 } 320 321 auto *persistent_vars = llvm::cast<ClangPersistentVariables>( 322 target->GetPersistentExpressionStateForLanguage(lldb::eLanguageTypeC)); 323 std::shared_ptr<ClangModulesDeclVendor> decl_vendor = 324 persistent_vars->GetClangModulesDeclVendor(); 325 if (decl_vendor) { 326 const ClangModulesDeclVendor::ModuleVector &hand_imported_modules = 327 persistent_vars->GetHandLoadedClangModules(); 328 ClangModulesDeclVendor::ModuleVector modules_for_macros; 329 330 for (ClangModulesDeclVendor::ModuleID module : hand_imported_modules) { 331 modules_for_macros.push_back(module); 332 } 333 334 if (target->GetEnableAutoImportClangModules()) { 335 if (StackFrame *frame = exe_ctx.GetFramePtr()) { 336 if (Block *block = frame->GetFrameBlock()) { 337 SymbolContext sc; 338 339 block->CalculateSymbolContext(&sc); 340 341 if (sc.comp_unit) { 342 StreamString error_stream; 343 344 decl_vendor->AddModulesForCompileUnit( 345 *sc.comp_unit, modules_for_macros, error_stream); 346 } 347 } 348 } 349 } 350 351 decl_vendor->ForEachMacro( 352 modules_for_macros, 353 [&module_macros_stream](llvm::StringRef token, 354 llvm::StringRef expansion) -> bool { 355 // Check if the macro hasn't already been defined in the 356 // g_expression_prefix (which defines a few builtin macros). 357 module_macros_stream << "#ifndef " << token << "\n"; 358 module_macros_stream << expansion << "\n"; 359 module_macros_stream << "#endif\n"; 360 return false; 361 }); 362 } 363 } 364 365 StreamString debug_macros_stream; 366 StreamString lldb_local_var_decls; 367 if (StackFrame *frame = exe_ctx.GetFramePtr()) { 368 const SymbolContext &sc = frame->GetSymbolContext( 369 lldb::eSymbolContextCompUnit | lldb::eSymbolContextLineEntry); 370 371 if (sc.comp_unit && sc.line_entry.IsValid()) { 372 DebugMacros *dm = sc.comp_unit->GetDebugMacros(); 373 if (dm) { 374 AddMacroState state(sc.line_entry.file, sc.line_entry.line); 375 AddMacros(dm, sc.comp_unit, state, debug_macros_stream); 376 } 377 } 378 379 if (add_locals) 380 if (target->GetInjectLocalVariables(&exe_ctx)) { 381 lldb::VariableListSP var_list_sp = 382 frame->GetInScopeVariableList(false, true); 383 AddLocalVariableDecls(var_list_sp, lldb_local_var_decls, 384 force_add_all_locals ? "" : m_body); 385 } 386 } 387 388 if (m_wrap) { 389 // Generate a list of @import statements that will import the specified 390 // module into our expression. 391 std::string module_imports; 392 for (const std::string &module : modules) { 393 module_imports.append("@import "); 394 module_imports.append(module); 395 module_imports.append(";\n"); 396 } 397 398 StreamString wrap_stream; 399 400 wrap_stream.Printf("%s\n%s\n%s\n%s\n%s\n", g_expression_prefix, 401 module_macros.c_str(), debug_macros_stream.GetData(), 402 target_specific_defines, m_prefix.c_str()); 403 404 // First construct a tagged form of the user expression so we can find it 405 // later: 406 std::string tagged_body; 407 tagged_body.append(m_start_marker); 408 tagged_body.append(m_body); 409 tagged_body.append(m_end_marker); 410 411 switch (m_wrap_kind) { 412 case WrapKind::Function: 413 wrap_stream.Printf("%s" 414 "void \n" 415 "%s(void *$__lldb_arg) \n" 416 "{ \n" 417 " %s; \n" 418 "%s" 419 "} \n", 420 module_imports.c_str(), m_name.c_str(), 421 lldb_local_var_decls.GetData(), tagged_body.c_str()); 422 break; 423 case WrapKind::CppMemberFunction: 424 wrap_stream.Printf("%s" 425 "void \n" 426 "$__lldb_class::%s(void *$__lldb_arg) \n" 427 "{ \n" 428 " %s; \n" 429 "%s" 430 "} \n", 431 module_imports.c_str(), m_name.c_str(), 432 lldb_local_var_decls.GetData(), tagged_body.c_str()); 433 break; 434 case WrapKind::ObjCInstanceMethod: 435 wrap_stream.Printf( 436 "%s" 437 "@interface $__lldb_objc_class ($__lldb_category) \n" 438 "-(void)%s:(void *)$__lldb_arg; \n" 439 "@end \n" 440 "@implementation $__lldb_objc_class ($__lldb_category) \n" 441 "-(void)%s:(void *)$__lldb_arg \n" 442 "{ \n" 443 " %s; \n" 444 "%s" 445 "} \n" 446 "@end \n", 447 module_imports.c_str(), m_name.c_str(), m_name.c_str(), 448 lldb_local_var_decls.GetData(), tagged_body.c_str()); 449 break; 450 451 case WrapKind::ObjCStaticMethod: 452 wrap_stream.Printf( 453 "%s" 454 "@interface $__lldb_objc_class ($__lldb_category) \n" 455 "+(void)%s:(void *)$__lldb_arg; \n" 456 "@end \n" 457 "@implementation $__lldb_objc_class ($__lldb_category) \n" 458 "+(void)%s:(void *)$__lldb_arg \n" 459 "{ \n" 460 " %s; \n" 461 "%s" 462 "} \n" 463 "@end \n", 464 module_imports.c_str(), m_name.c_str(), m_name.c_str(), 465 lldb_local_var_decls.GetData(), tagged_body.c_str()); 466 break; 467 } 468 469 text = std::string(wrap_stream.GetString()); 470 } else { 471 text.append(m_body); 472 } 473 474 return true; 475 } 476 477 bool ClangExpressionSourceCode::GetOriginalBodyBounds( 478 std::string transformed_text, size_t &start_loc, size_t &end_loc) { 479 start_loc = transformed_text.find(m_start_marker); 480 if (start_loc == std::string::npos) 481 return false; 482 start_loc += m_start_marker.size(); 483 end_loc = transformed_text.find(m_end_marker); 484 return end_loc != std::string::npos; 485 } 486