529 lines · 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-exception6//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 35using namespace lldb_private;36 37#define PREFIX_NAME "<lldb wrapper prefix>"38#define SUFFIX_NAME "<lldb wrapper suffix>"39 40const llvm::StringRef ClangExpressionSourceCode::g_prefix_file_name = PREFIX_NAME;41 42const char *ClangExpressionSourceCode::g_expression_prefix =43"#line 1 \"" PREFIX_NAME R"("44#ifndef offsetof45#define offsetof(t, d) __builtin_offsetof(t, d)46#endif47#ifndef NULL48#define NULL (__null)49#endif50#ifndef Nil51#define Nil (__null)52#endif53#ifndef nil54#define nil (__null)55#endif56#ifndef YES57#define YES ((BOOL)1)58#endif59#ifndef NO60#define NO ((BOOL)0)61#endif62typedef __INT8_TYPE__ int8_t;63typedef __UINT8_TYPE__ uint8_t;64typedef __INT16_TYPE__ int16_t;65typedef __UINT16_TYPE__ uint16_t;66typedef __INT32_TYPE__ int32_t;67typedef __UINT32_TYPE__ uint32_t;68typedef __INT64_TYPE__ int64_t;69typedef __UINT64_TYPE__ uint64_t;70typedef __INTPTR_TYPE__ intptr_t;71typedef __UINTPTR_TYPE__ uintptr_t;72typedef __SIZE_TYPE__ size_t;73typedef __PTRDIFF_TYPE__ ptrdiff_t;74typedef unsigned short unichar;75extern "C"76{77 int printf(const char * __restrict, ...);78}79)";80 81const char *ClangExpressionSourceCode::g_expression_suffix =82 "\n;\n#line 1 \"" SUFFIX_NAME "\"\n";83 84namespace {85 86class AddMacroState {87 enum State {88 CURRENT_FILE_NOT_YET_PUSHED,89 CURRENT_FILE_PUSHED,90 CURRENT_FILE_POPPED91 };92 93public:94 AddMacroState(const FileSpec ¤t_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 current114 // 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 be121 // 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 131private: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 namespace139 140static 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 the146 // Clang instance which parses the user expression. The Clang diagnostics147 // caused by this are not useful for the user as the source code here is148 // 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 else165 return;166 break;167 case DebugMacroEntry::UNDEF:168 if (state.IsValidEntry(entry.GetLineNumber()))169 stream.Printf("#undef %s\n", entry.GetMacroString().AsCString());170 else171 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 else178 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 193lldb_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 file198 // containing only the user expression. This will hide our wrapper code199 // 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 204namespace {205/// Allows checking if a token is contained in a given expression.206class TokenVerifier {207 /// The tokens we found in the expression.208 llvm::StringSet<> m_tokens;209 210public:211 TokenVerifier(std::string body);212 /// Returns true iff the given expression body contained a token with the213 /// 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 the221// expression (tokenized by 'verifier').222//223// If no 'this' capture exists, generate no using declarations. Instead224// capture lookups will get resolved by the same mechanism as class member225// variable lookup. That's because Clang generates an unnamed structure226// representing the lambda closure whose members are the captured variables.227void 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->GetNumChildrenIgnoringErrors();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} // namespace247 248TokenVerifier::TokenVerifier(std::string body) {249 using namespace clang;250 251 // We only care about tokens and not their original source locations. If we252 // move the whole expression to only be in one line we can simplify the253 // following code that extracts the token contents.254 llvm::replace(body, '\n', ' ');255 llvm::replace(body, '\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 utility262 // objects.263 DiagnosticOptions diags_opts;264 DiagnosticsEngine diags(DiagnosticIDs::create(), diags_opts);265 clang::SourceManager SM(diags, file_mgr);266 auto buf = llvm::MemoryBuffer::getMemBuffer(body);267 268 FileID FID = SM.createFileID(buf->getMemBufferRef());269 270 // Let's just enable the latest ObjC and C++ which should get most tokens271 // right.272 LangOptions Opts;273 Opts.ObjC = true;274 Opts.DollarIdents = true;275 Opts.CPlusPlus20 = true;276 Opts.LineComment = true;277 278 Lexer lex(FID, buf->getMemBufferRef(), SM, Opts);279 280 Token token;281 bool exit = false;282 while (!exit) {283 // Returns true if this is the last token we get from the lexer.284 exit = lex.LexFromRawLexer(token);285 286 // Extract the column number which we need to extract the token content.287 // Our expression is just one line, so we don't need to handle any line288 // numbers here.289 bool invalid = false;290 unsigned start = SM.getSpellingColumnNumber(token.getLocation(), &invalid);291 if (invalid)292 continue;293 // Column numbers start at 1, but indexes in our string start at 0.294 --start;295 296 // Annotations don't have a length, so let's skip them.297 if (token.isAnnotation())298 continue;299 300 // Extract the token string from our source code and store it.301 std::string token_str = body.substr(start, token.getLength());302 if (token_str.empty())303 continue;304 m_tokens.insert(token_str);305 }306}307 308void ClangExpressionSourceCode::AddLocalVariableDecls(StreamString &stream,309 const std::string &expr,310 StackFrame *frame) const {311 assert(frame);312 TokenVerifier tokens(expr);313 314 lldb::VariableListSP var_list_sp = frame->GetInScopeVariableList(false, true);315 316 for (size_t i = 0; i < var_list_sp->GetSize(); i++) {317 lldb::VariableSP var_sp = var_list_sp->GetVariableAtIndex(i);318 319 ConstString var_name = var_sp->GetName();320 321 if (var_name == "this" && m_wrap_kind == WrapKind::CppMemberFunction) {322 AddLambdaCaptureDecls(stream, frame, tokens);323 324 continue;325 }326 327 // We can check for .block_descriptor w/o checking for langauge since this328 // is not a valid identifier in either C or C++.329 if (!var_name || var_name == ".block_descriptor")330 continue;331 332 if (!expr.empty() && !tokens.hasToken(var_name.GetStringRef()))333 continue;334 335 const bool is_objc = m_wrap_kind == WrapKind::ObjCInstanceMethod ||336 m_wrap_kind == WrapKind::ObjCStaticMethod;337 if ((var_name == "self" || var_name == "_cmd") && is_objc)338 continue;339 340 stream.Printf("using $__lldb_local_vars::%s;\n", var_name.AsCString());341 }342}343 344bool ClangExpressionSourceCode::GetText(345 std::string &text, ExecutionContext &exe_ctx, bool add_locals,346 bool force_add_all_locals, llvm::ArrayRef<std::string> modules) const {347 const char *target_specific_defines = "typedef signed char BOOL;\n";348 std::string module_macros;349 llvm::raw_string_ostream module_macros_stream(module_macros);350 351 Target *target = exe_ctx.GetTargetPtr();352 if (target) {353 if (target->GetArchitecture().GetMachine() == llvm::Triple::aarch64 ||354 target->GetArchitecture().GetMachine() == llvm::Triple::aarch64_32) {355 target_specific_defines = "typedef bool BOOL;\n";356 }357 if (target->GetArchitecture().GetMachine() == llvm::Triple::x86_64) {358 if (lldb::PlatformSP platform_sp = target->GetPlatform()) {359 if (platform_sp->GetPluginName() == "ios-simulator") {360 target_specific_defines = "typedef bool BOOL;\n";361 }362 }363 }364 365 auto *persistent_vars = llvm::cast<ClangPersistentVariables>(366 target->GetPersistentExpressionStateForLanguage(lldb::eLanguageTypeC));367 std::shared_ptr<ClangModulesDeclVendor> decl_vendor =368 persistent_vars->GetClangModulesDeclVendor();369 if (decl_vendor) {370 const ClangModulesDeclVendor::ModuleVector &hand_imported_modules =371 persistent_vars->GetHandLoadedClangModules();372 ClangModulesDeclVendor::ModuleVector modules_for_macros;373 374 for (ClangModulesDeclVendor::ModuleID module : hand_imported_modules) {375 modules_for_macros.push_back(module);376 }377 378 if (target->GetEnableAutoImportClangModules()) {379 if (StackFrame *frame = exe_ctx.GetFramePtr()) {380 if (Block *block = frame->GetFrameBlock()) {381 SymbolContext sc;382 383 block->CalculateSymbolContext(&sc);384 385 if (sc.comp_unit) {386 if (auto err = decl_vendor->AddModulesForCompileUnit(387 *sc.comp_unit, modules_for_macros))388 LLDB_LOG_ERROR(389 GetLog(LLDBLog::Expressions), std::move(err),390 "Error while loading hand-imported modules:\n{0}");391 }392 }393 }394 }395 396 decl_vendor->ForEachMacro(397 modules_for_macros,398 [&module_macros_stream](llvm::StringRef token,399 llvm::StringRef expansion) -> bool {400 // Check if the macro hasn't already been defined in the401 // g_expression_prefix (which defines a few builtin macros).402 module_macros_stream << "#ifndef " << token << "\n";403 module_macros_stream << expansion << "\n";404 module_macros_stream << "#endif\n";405 return false;406 });407 }408 }409 410 StreamString debug_macros_stream;411 StreamString lldb_local_var_decls;412 if (StackFrame *frame = exe_ctx.GetFramePtr()) {413 const SymbolContext &sc = frame->GetSymbolContext(414 lldb::eSymbolContextCompUnit | lldb::eSymbolContextLineEntry);415 416 if (sc.comp_unit && sc.line_entry.IsValid()) {417 DebugMacros *dm = sc.comp_unit->GetDebugMacros();418 if (dm) {419 AddMacroState state(sc.line_entry.GetFile(), sc.line_entry.line);420 AddMacros(dm, sc.comp_unit, state, debug_macros_stream);421 }422 }423 424 if (add_locals)425 if (target->GetInjectLocalVariables(&exe_ctx)) {426 AddLocalVariableDecls(lldb_local_var_decls,427 force_add_all_locals ? "" : m_body, frame);428 }429 }430 431 if (m_wrap) {432 // Generate a list of @import statements that will import the specified433 // module into our expression.434 std::string module_imports;435 for (const std::string &module : modules) {436 module_imports.append("@import ");437 module_imports.append(module);438 module_imports.append(";\n");439 }440 441 StreamString wrap_stream;442 443 wrap_stream.Printf("%s\n%s\n%s\n%s\n%s\n", g_expression_prefix,444 module_macros.c_str(), debug_macros_stream.GetData(),445 target_specific_defines, m_prefix.c_str());446 447 // First construct a tagged form of the user expression so we can find it448 // later:449 std::string tagged_body;450 tagged_body.append(m_start_marker);451 tagged_body.append(m_body);452 tagged_body.append(m_end_marker);453 454 switch (m_wrap_kind) {455 case WrapKind::Function:456 wrap_stream.Printf("%s"457 "void \n"458 "%s(void *$__lldb_arg) \n"459 "{ \n"460 " %s; \n"461 "%s"462 "} \n",463 module_imports.c_str(), m_name.c_str(),464 lldb_local_var_decls.GetData(), tagged_body.c_str());465 break;466 case WrapKind::CppMemberFunction:467 wrap_stream.Printf("%s"468 "void \n"469 "$__lldb_class::%s(void *$__lldb_arg) \n"470 "{ \n"471 " %s; \n"472 "%s"473 "} \n",474 module_imports.c_str(), m_name.c_str(),475 lldb_local_var_decls.GetData(), tagged_body.c_str());476 break;477 case WrapKind::ObjCInstanceMethod:478 wrap_stream.Printf(479 "%s"480 "@interface $__lldb_objc_class ($__lldb_category) \n"481 "-(void)%s:(void *)$__lldb_arg; \n"482 "@end \n"483 "@implementation $__lldb_objc_class ($__lldb_category) \n"484 "-(void)%s:(void *)$__lldb_arg \n"485 "{ \n"486 " %s; \n"487 "%s"488 "} \n"489 "@end \n",490 module_imports.c_str(), m_name.c_str(), m_name.c_str(),491 lldb_local_var_decls.GetData(), tagged_body.c_str());492 break;493 494 case WrapKind::ObjCStaticMethod:495 wrap_stream.Printf(496 "%s"497 "@interface $__lldb_objc_class ($__lldb_category) \n"498 "+(void)%s:(void *)$__lldb_arg; \n"499 "@end \n"500 "@implementation $__lldb_objc_class ($__lldb_category) \n"501 "+(void)%s:(void *)$__lldb_arg \n"502 "{ \n"503 " %s; \n"504 "%s"505 "} \n"506 "@end \n",507 module_imports.c_str(), m_name.c_str(), m_name.c_str(),508 lldb_local_var_decls.GetData(), tagged_body.c_str());509 break;510 }511 512 text = std::string(wrap_stream.GetString());513 } else {514 text.append(m_body);515 }516 517 return true;518}519 520bool ClangExpressionSourceCode::GetOriginalBodyBounds(521 std::string transformed_text, size_t &start_loc, size_t &end_loc) {522 start_loc = transformed_text.find(m_start_marker);523 if (start_loc == std::string::npos)524 return false;525 start_loc += m_start_marker.size();526 end_loc = transformed_text.find(m_end_marker);527 return end_loc != std::string::npos;528}529