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