lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionSourceCode.cpp

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