1 //===-- CommandObjectExpression.cpp -----------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "CommandObjectExpression.h" 11 12 // C Includes 13 // C++ Includes 14 // Other libraries and framework includes 15 // Project includes 16 #include "lldb/Interpreter/Args.h" 17 #include "lldb/Core/Value.h" 18 #include "lldb/Core/InputReader.h" 19 #include "lldb/Core/ValueObjectVariable.h" 20 #include "lldb/Expression/ClangExpressionVariable.h" 21 #include "lldb/Expression/ClangUserExpression.h" 22 #include "lldb/Expression/ClangFunction.h" 23 #include "lldb/Expression/DWARFExpression.h" 24 #include "lldb/Host/Host.h" 25 #include "lldb/Core/Debugger.h" 26 #include "lldb/Interpreter/CommandInterpreter.h" 27 #include "lldb/Interpreter/CommandReturnObject.h" 28 #include "lldb/Target/ObjCLanguageRuntime.h" 29 #include "lldb/Symbol/ObjectFile.h" 30 #include "lldb/Symbol/Variable.h" 31 #include "lldb/Target/Process.h" 32 #include "lldb/Target/StackFrame.h" 33 #include "lldb/Target/Target.h" 34 #include "lldb/Target/Thread.h" 35 #include "llvm/ADT/StringRef.h" 36 37 using namespace lldb; 38 using namespace lldb_private; 39 40 CommandObjectExpression::CommandOptions::CommandOptions (CommandInterpreter &interpreter) : 41 Options(interpreter) 42 { 43 // Keep only one place to reset the values to their defaults 44 OptionParsingStarting(); 45 } 46 47 48 CommandObjectExpression::CommandOptions::~CommandOptions () 49 { 50 } 51 52 Error 53 CommandObjectExpression::CommandOptions::SetOptionValue (uint32_t option_idx, const char *option_arg) 54 { 55 Error error; 56 57 char short_option = (char) m_getopt_table[option_idx].val; 58 59 switch (short_option) 60 { 61 //case 'l': 62 //if (language.SetLanguageFromCString (option_arg) == false) 63 //{ 64 // error.SetErrorStringWithFormat("Invalid language option argument '%s'.\n", option_arg); 65 //} 66 //break; 67 68 case 'g': 69 debug = true; 70 break; 71 72 case 'f': 73 error = Args::StringToFormat(option_arg, format, NULL); 74 break; 75 76 case 'o': 77 print_object = true; 78 break; 79 80 case 'd': 81 { 82 bool success; 83 bool result; 84 result = Args::StringToBoolean(option_arg, true, &success); 85 if (!success) 86 error.SetErrorStringWithFormat("Invalid dynamic value setting: \"%s\".\n", option_arg); 87 else 88 { 89 if (result) 90 use_dynamic = eLazyBoolYes; 91 else 92 use_dynamic = eLazyBoolNo; 93 } 94 } 95 break; 96 97 case 'u': 98 bool success; 99 unwind_on_error = Args::StringToBoolean(option_arg, true, &success); 100 if (!success) 101 error.SetErrorStringWithFormat("Could not convert \"%s\" to a boolean value.", option_arg); 102 break; 103 104 default: 105 error.SetErrorStringWithFormat("Invalid short option character '%c'.\n", short_option); 106 break; 107 } 108 109 return error; 110 } 111 112 void 113 CommandObjectExpression::CommandOptions::OptionParsingStarting () 114 { 115 //language.Clear(); 116 debug = false; 117 format = eFormatDefault; 118 print_object = false; 119 use_dynamic = eLazyBoolCalculate; 120 unwind_on_error = true; 121 show_types = true; 122 show_summary = true; 123 } 124 125 const OptionDefinition* 126 CommandObjectExpression::CommandOptions::GetDefinitions () 127 { 128 return g_option_table; 129 } 130 131 CommandObjectExpression::CommandObjectExpression (CommandInterpreter &interpreter) : 132 CommandObject (interpreter, 133 "expression", 134 "Evaluate a C/ObjC/C++ expression in the current program context, using variables currently in scope.", 135 NULL), 136 m_options (interpreter), 137 m_expr_line_count (0), 138 m_expr_lines () 139 { 140 SetHelpLong( 141 "Examples: \n\ 142 \n\ 143 expr my_struct->a = my_array[3] \n\ 144 expr -f bin -- (index * 8) + 5 \n\ 145 expr char c[] = \"foo\"; c[0]\n"); 146 147 CommandArgumentEntry arg; 148 CommandArgumentData expression_arg; 149 150 // Define the first (and only) variant of this arg. 151 expression_arg.arg_type = eArgTypeExpression; 152 expression_arg.arg_repetition = eArgRepeatPlain; 153 154 // There is only one variant this argument could be; put it into the argument entry. 155 arg.push_back (expression_arg); 156 157 // Push the data for the first argument into the m_arguments vector. 158 m_arguments.push_back (arg); 159 } 160 161 CommandObjectExpression::~CommandObjectExpression () 162 { 163 } 164 165 Options * 166 CommandObjectExpression::GetOptions () 167 { 168 return &m_options; 169 } 170 171 172 bool 173 CommandObjectExpression::Execute 174 ( 175 Args& command, 176 CommandReturnObject &result 177 ) 178 { 179 return false; 180 } 181 182 183 size_t 184 CommandObjectExpression::MultiLineExpressionCallback 185 ( 186 void *baton, 187 InputReader &reader, 188 lldb::InputReaderAction notification, 189 const char *bytes, 190 size_t bytes_len 191 ) 192 { 193 CommandObjectExpression *cmd_object_expr = (CommandObjectExpression *) baton; 194 bool batch_mode = reader.GetDebugger().GetCommandInterpreter().GetBatchCommandMode(); 195 196 switch (notification) 197 { 198 case eInputReaderActivate: 199 if (!batch_mode) 200 { 201 StreamSP async_strm_sp(reader.GetDebugger().GetAsyncOutputStream()); 202 if (async_strm_sp) 203 { 204 async_strm_sp->PutCString("Enter expressions, then terminate with an empty line to evaluate:\n"); 205 async_strm_sp->Flush(); 206 } 207 } 208 // Fall through 209 case eInputReaderReactivate: 210 break; 211 212 case eInputReaderDeactivate: 213 break; 214 215 case eInputReaderAsynchronousOutputWritten: 216 break; 217 218 case eInputReaderGotToken: 219 ++cmd_object_expr->m_expr_line_count; 220 if (bytes && bytes_len) 221 { 222 cmd_object_expr->m_expr_lines.append (bytes, bytes_len + 1); 223 } 224 225 if (bytes_len == 0) 226 reader.SetIsDone(true); 227 break; 228 229 case eInputReaderInterrupt: 230 cmd_object_expr->m_expr_lines.clear(); 231 reader.SetIsDone (true); 232 if (!batch_mode) 233 { 234 StreamSP async_strm_sp (reader.GetDebugger().GetAsyncOutputStream()); 235 if (async_strm_sp) 236 { 237 async_strm_sp->PutCString("Expression evaluation cancelled.\n"); 238 async_strm_sp->Flush(); 239 } 240 } 241 break; 242 243 case eInputReaderEndOfFile: 244 reader.SetIsDone (true); 245 break; 246 247 case eInputReaderDone: 248 if (cmd_object_expr->m_expr_lines.size() > 0) 249 { 250 StreamSP output_stream = reader.GetDebugger().GetAsyncOutputStream(); 251 StreamSP error_stream = reader.GetDebugger().GetAsyncErrorStream(); 252 cmd_object_expr->EvaluateExpression (cmd_object_expr->m_expr_lines.c_str(), 253 output_stream.get(), 254 error_stream.get()); 255 output_stream->Flush(); 256 error_stream->Flush(); 257 } 258 break; 259 } 260 261 return bytes_len; 262 } 263 264 bool 265 CommandObjectExpression::EvaluateExpression 266 ( 267 const char *expr, 268 Stream *output_stream, 269 Stream *error_stream, 270 CommandReturnObject *result 271 ) 272 { 273 if (m_exe_ctx.target) 274 { 275 lldb::ValueObjectSP result_valobj_sp; 276 277 ExecutionResults exe_results; 278 279 bool keep_in_memory = true; 280 lldb::DynamicValueType use_dynamic; 281 // If use dynamic is not set, get it from the target: 282 switch (m_options.use_dynamic) 283 { 284 case eLazyBoolCalculate: 285 use_dynamic = m_exe_ctx.target->GetPreferDynamicValue(); 286 break; 287 case eLazyBoolYes: 288 use_dynamic = lldb::eDynamicCanRunTarget; 289 break; 290 case eLazyBoolNo: 291 use_dynamic = lldb::eNoDynamicValues; 292 break; 293 } 294 295 exe_results = m_exe_ctx.target->EvaluateExpression(expr, m_exe_ctx.frame, m_options.unwind_on_error, keep_in_memory, use_dynamic, result_valobj_sp); 296 297 if (exe_results == eExecutionInterrupted && !m_options.unwind_on_error) 298 { 299 uint32_t start_frame = 0; 300 uint32_t num_frames = 1; 301 uint32_t num_frames_with_source = 0; 302 if (m_exe_ctx.thread) 303 { 304 m_exe_ctx.thread->GetStatus (result->GetOutputStream(), 305 start_frame, 306 num_frames, 307 num_frames_with_source); 308 } 309 else if (m_exe_ctx.process) 310 { 311 bool only_threads_with_stop_reason = true; 312 m_exe_ctx.process->GetThreadStatus (result->GetOutputStream(), 313 only_threads_with_stop_reason, 314 start_frame, 315 num_frames, 316 num_frames_with_source); 317 } 318 } 319 320 if (result_valobj_sp) 321 { 322 if (result_valobj_sp->GetError().Success()) 323 { 324 if (m_options.format != eFormatDefault) 325 result_valobj_sp->SetFormat (m_options.format); 326 327 ValueObject::DumpValueObject (*(output_stream), 328 result_valobj_sp.get(), // Variable object to dump 329 result_valobj_sp->GetName().GetCString(),// Root object name 330 0, // Pointer depth to traverse (zero means stop at pointers) 331 0, // Current depth, this is the top most, so zero... 332 UINT32_MAX, // Max depth to go when dumping concrete types, dump everything... 333 m_options.show_types, // Show types when dumping? 334 false, // Show locations of variables, no since this is a host address which we don't care to see 335 m_options.print_object, // Print the objective C object? 336 use_dynamic, 337 true, // Use synthetic children if available 338 true, // Scope is already checked. Const results are always in scope. 339 false, // Don't flatten output 340 0, // Always use summaries (you might want an option --no-summary like there is for frame variable) 341 false); // Do not show more children than settings allow 342 if (result) 343 result->SetStatus (eReturnStatusSuccessFinishResult); 344 } 345 else 346 { 347 if (result_valobj_sp->GetError().GetError() == ClangUserExpression::kNoResult) 348 { 349 error_stream->PutCString("<no result>\n"); 350 351 if (result) 352 result->SetStatus (eReturnStatusSuccessFinishResult); 353 } 354 else 355 { 356 const char *error_cstr = result_valobj_sp->GetError().AsCString(); 357 if (error_cstr && error_cstr[0]) 358 { 359 int error_cstr_len = strlen (error_cstr); 360 const bool ends_with_newline = error_cstr[error_cstr_len - 1] == '\n'; 361 if (strstr(error_cstr, "error:") != error_cstr) 362 error_stream->PutCString ("error: "); 363 error_stream->Write(error_cstr, error_cstr_len); 364 if (!ends_with_newline) 365 error_stream->EOL(); 366 } 367 else 368 { 369 error_stream->PutCString ("error: unknown error\n"); 370 } 371 372 if (result) 373 result->SetStatus (eReturnStatusFailed); 374 } 375 } 376 } 377 } 378 else 379 { 380 error_stream->Printf ("error: invalid execution context for expression\n"); 381 return false; 382 } 383 384 return true; 385 } 386 387 bool 388 CommandObjectExpression::ExecuteRawCommandString 389 ( 390 const char *command, 391 CommandReturnObject &result 392 ) 393 { 394 m_exe_ctx = m_interpreter.GetExecutionContext(); 395 396 m_options.NotifyOptionParsingStarting(); 397 398 const char * expr = NULL; 399 400 if (command[0] == '\0') 401 { 402 m_expr_lines.clear(); 403 m_expr_line_count = 0; 404 405 InputReaderSP reader_sp (new InputReader(m_interpreter.GetDebugger())); 406 if (reader_sp) 407 { 408 Error err (reader_sp->Initialize (CommandObjectExpression::MultiLineExpressionCallback, 409 this, // baton 410 eInputReaderGranularityLine, // token size, to pass to callback function 411 NULL, // end token 412 NULL, // prompt 413 true)); // echo input 414 if (err.Success()) 415 { 416 m_interpreter.GetDebugger().PushInputReader (reader_sp); 417 result.SetStatus (eReturnStatusSuccessFinishNoResult); 418 } 419 else 420 { 421 result.AppendError (err.AsCString()); 422 result.SetStatus (eReturnStatusFailed); 423 } 424 } 425 else 426 { 427 result.AppendError("out of memory"); 428 result.SetStatus (eReturnStatusFailed); 429 } 430 return result.Succeeded(); 431 } 432 433 if (command[0] == '-') 434 { 435 // We have some options and these options MUST end with --. 436 const char *end_options = NULL; 437 const char *s = command; 438 while (s && s[0]) 439 { 440 end_options = ::strstr (s, "--"); 441 if (end_options) 442 { 443 end_options += 2; // Get past the "--" 444 if (::isspace (end_options[0])) 445 { 446 expr = end_options; 447 while (::isspace (*expr)) 448 ++expr; 449 break; 450 } 451 } 452 s = end_options; 453 } 454 455 if (end_options) 456 { 457 Args args (command, end_options - command); 458 if (!ParseOptions (args, result)) 459 return false; 460 461 Error error (m_options.NotifyOptionParsingFinished()); 462 if (error.Fail()) 463 { 464 result.AppendError (error.AsCString()); 465 result.SetStatus (eReturnStatusFailed); 466 return false; 467 } 468 } 469 } 470 471 if (expr == NULL) 472 expr = command; 473 474 if (EvaluateExpression (expr, &(result.GetOutputStream()), &(result.GetErrorStream()), &result)) 475 return true; 476 477 result.SetStatus (eReturnStatusFailed); 478 return false; 479 } 480 481 OptionDefinition 482 CommandObjectExpression::CommandOptions::g_option_table[] = 483 { 484 //{ LLDB_OPT_SET_ALL, false, "language", 'l', required_argument, NULL, 0, "[c|c++|objc|objc++]", "Sets the language to use when parsing the expression."}, 485 //{ LLDB_OPT_SET_1, false, "format", 'f', required_argument, NULL, 0, "[ [bool|b] | [bin] | [char|c] | [oct|o] | [dec|i|d|u] | [hex|x] | [float|f] | [cstr|s] ]", "Specify the format that the expression output should use."}, 486 { LLDB_OPT_SET_1, false, "format", 'f', required_argument, NULL, 0, eArgTypeExprFormat, "Specify the format that the expression output should use."}, 487 { LLDB_OPT_SET_2, false, "object-description", 'o', no_argument, NULL, 0, eArgTypeNone, "Print the object description of the value resulting from the expression."}, 488 { LLDB_OPT_SET_2, false, "dynamic-value", 'd', required_argument, NULL, 0, eArgTypeBoolean, "Upcast the value resulting from the expression to its dynamic type if available."}, 489 { LLDB_OPT_SET_ALL, false, "unwind-on-error", 'u', required_argument, NULL, 0, eArgTypeBoolean, "Clean up program state if the expression causes a crash, breakpoint hit or signal."}, 490 { LLDB_OPT_SET_ALL, false, "debug", 'g', no_argument, NULL, 0, eArgTypeNone, "Enable verbose debug logging of the expression parsing and evaluation."}, 491 { LLDB_OPT_SET_ALL, false, "use-ir", 'i', no_argument, NULL, 0, eArgTypeNone, "[Temporary] Instructs the expression evaluator to use IR instead of ASTs."}, 492 { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL } 493 }; 494 495