1 //===-- UserExpression.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 "lldb/Host/Config.h" 10 11 #include <cstdio> 12 #if HAVE_SYS_TYPES_H 13 #include <sys/types.h> 14 #endif 15 16 #include <cstdlib> 17 #include <map> 18 #include <string> 19 20 #include "lldb/Core/Module.h" 21 #include "lldb/Core/StreamFile.h" 22 #include "lldb/Core/ValueObjectConstResult.h" 23 #include "lldb/Expression/DiagnosticManager.h" 24 #include "lldb/Expression/ExpressionVariable.h" 25 #include "lldb/Expression/IRExecutionUnit.h" 26 #include "lldb/Expression/IRInterpreter.h" 27 #include "lldb/Expression/Materializer.h" 28 #include "lldb/Expression/UserExpression.h" 29 #include "lldb/Host/HostInfo.h" 30 #include "lldb/Symbol/Block.h" 31 #include "lldb/Symbol/Function.h" 32 #include "lldb/Symbol/ObjectFile.h" 33 #include "lldb/Symbol/SymbolVendor.h" 34 #include "lldb/Symbol/Type.h" 35 #include "lldb/Symbol/TypeSystem.h" 36 #include "lldb/Symbol/VariableList.h" 37 #include "lldb/Target/ExecutionContext.h" 38 #include "lldb/Target/Process.h" 39 #include "lldb/Target/StackFrame.h" 40 #include "lldb/Target/Target.h" 41 #include "lldb/Target/ThreadPlan.h" 42 #include "lldb/Target/ThreadPlanCallUserExpression.h" 43 #include "lldb/Utility/ConstString.h" 44 #include "lldb/Utility/Log.h" 45 #include "lldb/Utility/StreamString.h" 46 47 using namespace lldb_private; 48 49 char UserExpression::ID; 50 51 UserExpression::UserExpression(ExecutionContextScope &exe_scope, 52 llvm::StringRef expr, llvm::StringRef prefix, 53 lldb::LanguageType language, 54 ResultType desired_type, 55 const EvaluateExpressionOptions &options) 56 : Expression(exe_scope), m_expr_text(std::string(expr)), 57 m_expr_prefix(std::string(prefix)), m_language(language), 58 m_desired_type(desired_type), m_options(options) {} 59 60 UserExpression::~UserExpression() = default; 61 62 void UserExpression::InstallContext(ExecutionContext &exe_ctx) { 63 m_jit_process_wp = exe_ctx.GetProcessSP(); 64 65 lldb::StackFrameSP frame_sp = exe_ctx.GetFrameSP(); 66 67 if (frame_sp) 68 m_address = frame_sp->GetFrameCodeAddress(); 69 } 70 71 bool UserExpression::LockAndCheckContext(ExecutionContext &exe_ctx, 72 lldb::TargetSP &target_sp, 73 lldb::ProcessSP &process_sp, 74 lldb::StackFrameSP &frame_sp) { 75 lldb::ProcessSP expected_process_sp = m_jit_process_wp.lock(); 76 process_sp = exe_ctx.GetProcessSP(); 77 78 if (process_sp != expected_process_sp) 79 return false; 80 81 process_sp = exe_ctx.GetProcessSP(); 82 target_sp = exe_ctx.GetTargetSP(); 83 frame_sp = exe_ctx.GetFrameSP(); 84 85 if (m_address.IsValid()) { 86 if (!frame_sp) 87 return false; 88 return (Address::CompareLoadAddress(m_address, 89 frame_sp->GetFrameCodeAddress(), 90 target_sp.get()) == 0); 91 } 92 93 return true; 94 } 95 96 bool UserExpression::MatchesContext(ExecutionContext &exe_ctx) { 97 lldb::TargetSP target_sp; 98 lldb::ProcessSP process_sp; 99 lldb::StackFrameSP frame_sp; 100 101 return LockAndCheckContext(exe_ctx, target_sp, process_sp, frame_sp); 102 } 103 104 lldb::addr_t UserExpression::GetObjectPointer(lldb::StackFrameSP frame_sp, 105 ConstString &object_name, 106 Status &err) { 107 err.Clear(); 108 109 if (!frame_sp) { 110 err.SetErrorStringWithFormat( 111 "Couldn't load '%s' because the context is incomplete", 112 object_name.AsCString()); 113 return LLDB_INVALID_ADDRESS; 114 } 115 116 lldb::VariableSP var_sp; 117 lldb::ValueObjectSP valobj_sp; 118 119 valobj_sp = frame_sp->GetValueForVariableExpressionPath( 120 object_name.GetStringRef(), lldb::eNoDynamicValues, 121 StackFrame::eExpressionPathOptionCheckPtrVsMember | 122 StackFrame::eExpressionPathOptionsNoFragileObjcIvar | 123 StackFrame::eExpressionPathOptionsNoSyntheticChildren | 124 StackFrame::eExpressionPathOptionsNoSyntheticArrayRange, 125 var_sp, err); 126 127 if (!err.Success() || !valobj_sp.get()) 128 return LLDB_INVALID_ADDRESS; 129 130 lldb::addr_t ret = valobj_sp->GetValueAsUnsigned(LLDB_INVALID_ADDRESS); 131 132 if (ret == LLDB_INVALID_ADDRESS) { 133 err.SetErrorStringWithFormat( 134 "Couldn't load '%s' because its value couldn't be evaluated", 135 object_name.AsCString()); 136 return LLDB_INVALID_ADDRESS; 137 } 138 139 return ret; 140 } 141 142 lldb::ExpressionResults 143 UserExpression::Evaluate(ExecutionContext &exe_ctx, 144 const EvaluateExpressionOptions &options, 145 llvm::StringRef expr, llvm::StringRef prefix, 146 lldb::ValueObjectSP &result_valobj_sp, Status &error, 147 std::string *fixed_expression, ValueObject *ctx_obj) { 148 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EXPRESSIONS | 149 LIBLLDB_LOG_STEP)); 150 151 if (ctx_obj) { 152 static unsigned const ctx_type_mask = 153 lldb::TypeFlags::eTypeIsClass | lldb::TypeFlags::eTypeIsStructUnion; 154 if (!(ctx_obj->GetTypeInfo() & ctx_type_mask)) { 155 LLDB_LOG(log, "== [UserExpression::Evaluate] Passed a context object of " 156 "an invalid type, can't run expressions."); 157 error.SetErrorString("a context object of an invalid type passed"); 158 return lldb::eExpressionSetupError; 159 } 160 } 161 162 lldb_private::ExecutionPolicy execution_policy = options.GetExecutionPolicy(); 163 lldb::LanguageType language = options.GetLanguage(); 164 const ResultType desired_type = options.DoesCoerceToId() 165 ? UserExpression::eResultTypeId 166 : UserExpression::eResultTypeAny; 167 lldb::ExpressionResults execution_results = lldb::eExpressionSetupError; 168 169 Target *target = exe_ctx.GetTargetPtr(); 170 if (!target) { 171 LLDB_LOG(log, "== [UserExpression::Evaluate] Passed a NULL target, can't " 172 "run expressions."); 173 error.SetErrorString("expression passed a null target"); 174 return lldb::eExpressionSetupError; 175 } 176 177 Process *process = exe_ctx.GetProcessPtr(); 178 179 if (process == nullptr || process->GetState() != lldb::eStateStopped) { 180 if (execution_policy == eExecutionPolicyAlways) { 181 LLDB_LOG(log, "== [UserExpression::Evaluate] Expression may not run, but " 182 "is not constant =="); 183 184 error.SetErrorString("expression needed to run but couldn't"); 185 186 return execution_results; 187 } 188 } 189 190 // Explicitly force the IR interpreter to evaluate the expression when the 191 // there is no process that supports running the expression for us. Don't 192 // change the execution policy if we have the special top-level policy that 193 // doesn't contain any expression and there is nothing to interpret. 194 if (execution_policy != eExecutionPolicyTopLevel && 195 (process == nullptr || !process->CanJIT())) 196 execution_policy = eExecutionPolicyNever; 197 198 // We need to set the expression execution thread here, turns out parse can 199 // call functions in the process of looking up symbols, which will escape the 200 // context set by exe_ctx passed to Execute. 201 lldb::ThreadSP thread_sp = exe_ctx.GetThreadSP(); 202 ThreadList::ExpressionExecutionThreadPusher execution_thread_pusher( 203 thread_sp); 204 205 llvm::StringRef full_prefix; 206 llvm::StringRef option_prefix(options.GetPrefix()); 207 std::string full_prefix_storage; 208 if (!prefix.empty() && !option_prefix.empty()) { 209 full_prefix_storage = std::string(prefix); 210 full_prefix_storage.append(std::string(option_prefix)); 211 full_prefix = full_prefix_storage; 212 } else if (!prefix.empty()) 213 full_prefix = prefix; 214 else 215 full_prefix = option_prefix; 216 217 // If the language was not specified in the expression command, set it to the 218 // language in the target's properties if specified, else default to the 219 // langage for the frame. 220 if (language == lldb::eLanguageTypeUnknown) { 221 if (target->GetLanguage() != lldb::eLanguageTypeUnknown) 222 language = target->GetLanguage(); 223 else if (StackFrame *frame = exe_ctx.GetFramePtr()) 224 language = frame->GetLanguage(); 225 } 226 227 lldb::UserExpressionSP user_expression_sp( 228 target->GetUserExpressionForLanguage(expr, full_prefix, language, 229 desired_type, options, ctx_obj, 230 error)); 231 if (error.Fail()) { 232 LLDB_LOG(log, "== [UserExpression::Evaluate] Getting expression: {0} ==", 233 error.AsCString()); 234 return lldb::eExpressionSetupError; 235 } 236 237 LLDB_LOG(log, "== [UserExpression::Evaluate] Parsing expression {0} ==", 238 expr.str()); 239 240 const bool keep_expression_in_memory = true; 241 const bool generate_debug_info = options.GetGenerateDebugInfo(); 242 243 if (options.InvokeCancelCallback(lldb::eExpressionEvaluationParse)) { 244 error.SetErrorString("expression interrupted by callback before parse"); 245 result_valobj_sp = ValueObjectConstResult::Create( 246 exe_ctx.GetBestExecutionContextScope(), error); 247 return lldb::eExpressionInterrupted; 248 } 249 250 DiagnosticManager diagnostic_manager; 251 252 bool parse_success = 253 user_expression_sp->Parse(diagnostic_manager, exe_ctx, execution_policy, 254 keep_expression_in_memory, generate_debug_info); 255 256 // Calculate the fixed expression always, since we need it for errors. 257 std::string tmp_fixed_expression; 258 if (fixed_expression == nullptr) 259 fixed_expression = &tmp_fixed_expression; 260 261 const char *fixed_text = user_expression_sp->GetFixedText(); 262 if (fixed_text != nullptr) 263 fixed_expression->append(fixed_text); 264 265 // If there is a fixed expression, try to parse it: 266 if (!parse_success) { 267 // Delete the expression that failed to parse before attempting to parse 268 // the next expression. 269 user_expression_sp.reset(); 270 271 execution_results = lldb::eExpressionParseError; 272 if (fixed_expression && !fixed_expression->empty() && 273 options.GetAutoApplyFixIts()) { 274 const uint64_t max_fix_retries = options.GetRetriesWithFixIts(); 275 for (uint64_t i = 0; i < max_fix_retries; ++i) { 276 // Try parsing the fixed expression. 277 lldb::UserExpressionSP fixed_expression_sp( 278 target->GetUserExpressionForLanguage( 279 fixed_expression->c_str(), full_prefix, language, desired_type, 280 options, ctx_obj, error)); 281 DiagnosticManager fixed_diagnostic_manager; 282 parse_success = fixed_expression_sp->Parse( 283 fixed_diagnostic_manager, exe_ctx, execution_policy, 284 keep_expression_in_memory, generate_debug_info); 285 if (parse_success) { 286 diagnostic_manager.Clear(); 287 user_expression_sp = fixed_expression_sp; 288 break; 289 } else { 290 // The fixed expression also didn't parse. Let's check for any new 291 // Fix-Its we could try. 292 if (fixed_expression_sp->GetFixedText()) { 293 *fixed_expression = fixed_expression_sp->GetFixedText(); 294 } else { 295 // Fixed expression didn't compile without a fixit, don't retry and 296 // don't tell the user about it. 297 fixed_expression->clear(); 298 break; 299 } 300 } 301 } 302 } 303 304 if (!parse_success) { 305 std::string msg; 306 { 307 llvm::raw_string_ostream os(msg); 308 os << "expression failed to parse:\n"; 309 if (!diagnostic_manager.Diagnostics().empty()) 310 os << diagnostic_manager.GetString(); 311 else 312 os << "unknown error"; 313 if (target->GetEnableNotifyAboutFixIts() && fixed_expression && 314 !fixed_expression->empty()) 315 os << "\nfixed expression suggested:\n " << *fixed_expression; 316 } 317 error.SetExpressionError(execution_results, msg.c_str()); 318 } 319 } 320 321 if (parse_success) { 322 lldb::ExpressionVariableSP expr_result; 323 324 if (execution_policy == eExecutionPolicyNever && 325 !user_expression_sp->CanInterpret()) { 326 LLDB_LOG(log, "== [UserExpression::Evaluate] Expression may not run, but " 327 "is not constant =="); 328 329 if (!diagnostic_manager.Diagnostics().size()) 330 error.SetExpressionError(lldb::eExpressionSetupError, 331 "expression needed to run but couldn't"); 332 } else if (execution_policy == eExecutionPolicyTopLevel) { 333 error.SetError(UserExpression::kNoResult, lldb::eErrorTypeGeneric); 334 return lldb::eExpressionCompleted; 335 } else { 336 if (options.InvokeCancelCallback(lldb::eExpressionEvaluationExecution)) { 337 error.SetExpressionError( 338 lldb::eExpressionInterrupted, 339 "expression interrupted by callback before execution"); 340 result_valobj_sp = ValueObjectConstResult::Create( 341 exe_ctx.GetBestExecutionContextScope(), error); 342 return lldb::eExpressionInterrupted; 343 } 344 345 diagnostic_manager.Clear(); 346 347 LLDB_LOG(log, "== [UserExpression::Evaluate] Executing expression =="); 348 349 execution_results = 350 user_expression_sp->Execute(diagnostic_manager, exe_ctx, options, 351 user_expression_sp, expr_result); 352 353 if (execution_results != lldb::eExpressionCompleted) { 354 LLDB_LOG(log, "== [UserExpression::Evaluate] Execution completed " 355 "abnormally =="); 356 357 if (!diagnostic_manager.Diagnostics().size()) 358 error.SetExpressionError( 359 execution_results, "expression failed to execute, unknown error"); 360 else 361 error.SetExpressionError(execution_results, 362 diagnostic_manager.GetString().c_str()); 363 } else { 364 if (expr_result) { 365 result_valobj_sp = expr_result->GetValueObject(); 366 result_valobj_sp->SetPreferredDisplayLanguage(language); 367 368 LLDB_LOG(log, 369 "== [UserExpression::Evaluate] Execution completed " 370 "normally with result {0} ==", 371 result_valobj_sp->GetValueAsCString()); 372 } else { 373 LLDB_LOG(log, "== [UserExpression::Evaluate] Execution completed " 374 "normally with no result =="); 375 376 error.SetError(UserExpression::kNoResult, lldb::eErrorTypeGeneric); 377 } 378 } 379 } 380 } 381 382 if (options.InvokeCancelCallback(lldb::eExpressionEvaluationComplete)) { 383 error.SetExpressionError( 384 lldb::eExpressionInterrupted, 385 "expression interrupted by callback after complete"); 386 return lldb::eExpressionInterrupted; 387 } 388 389 if (result_valobj_sp.get() == nullptr) { 390 result_valobj_sp = ValueObjectConstResult::Create( 391 exe_ctx.GetBestExecutionContextScope(), error); 392 } 393 394 return execution_results; 395 } 396 397 lldb::ExpressionResults 398 UserExpression::Execute(DiagnosticManager &diagnostic_manager, 399 ExecutionContext &exe_ctx, 400 const EvaluateExpressionOptions &options, 401 lldb::UserExpressionSP &shared_ptr_to_me, 402 lldb::ExpressionVariableSP &result_var) { 403 lldb::ExpressionResults expr_result = DoExecute( 404 diagnostic_manager, exe_ctx, options, shared_ptr_to_me, result_var); 405 Target *target = exe_ctx.GetTargetPtr(); 406 if (options.GetResultIsInternal() && result_var && target) { 407 if (auto *persistent_state = 408 target->GetPersistentExpressionStateForLanguage(m_language)) 409 persistent_state->RemovePersistentVariable(result_var); 410 } 411 return expr_result; 412 } 413