1 //===-- CommandObjectFrame.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 "CommandObjectFrame.h" 11 12 // C Includes 13 // C++ Includes 14 #include <string> 15 // Other libraries and framework includes 16 // Project includes 17 #include "lldb/Core/Debugger.h" 18 #include "lldb/Core/Module.h" 19 #include "lldb/Core/StreamFile.h" 20 #include "lldb/Core/StreamString.h" 21 #include "lldb/Core/Timer.h" 22 #include "lldb/Core/Value.h" 23 #include "lldb/Core/ValueObject.h" 24 #include "lldb/Core/ValueObjectVariable.h" 25 #include "lldb/DataFormatters/DataVisualization.h" 26 #include "lldb/DataFormatters/ValueObjectPrinter.h" 27 #include "lldb/Host/Host.h" 28 #include "lldb/Host/StringConvert.h" 29 #include "lldb/Interpreter/Args.h" 30 #include "lldb/Interpreter/CommandInterpreter.h" 31 #include "lldb/Interpreter/CommandReturnObject.h" 32 #include "lldb/Interpreter/Options.h" 33 #include "lldb/Interpreter/OptionGroupFormat.h" 34 #include "lldb/Interpreter/OptionGroupValueObjectDisplay.h" 35 #include "lldb/Interpreter/OptionGroupVariable.h" 36 #include "lldb/Symbol/CompilerType.h" 37 #include "lldb/Symbol/ClangASTContext.h" 38 #include "lldb/Symbol/Function.h" 39 #include "lldb/Symbol/ObjectFile.h" 40 #include "lldb/Symbol/SymbolContext.h" 41 #include "lldb/Symbol/Type.h" 42 #include "lldb/Symbol/Variable.h" 43 #include "lldb/Symbol/VariableList.h" 44 #include "lldb/Target/Process.h" 45 #include "lldb/Target/StackFrame.h" 46 #include "lldb/Target/Thread.h" 47 #include "lldb/Target/Target.h" 48 49 using namespace lldb; 50 using namespace lldb_private; 51 52 #pragma mark CommandObjectFrameInfo 53 54 //------------------------------------------------------------------------- 55 // CommandObjectFrameInfo 56 //------------------------------------------------------------------------- 57 58 class CommandObjectFrameInfo : public CommandObjectParsed 59 { 60 public: 61 62 CommandObjectFrameInfo (CommandInterpreter &interpreter) : 63 CommandObjectParsed (interpreter, 64 "frame info", 65 "List information about the currently selected frame in the current thread.", 66 "frame info", 67 eCommandRequiresFrame | 68 eCommandTryTargetAPILock | 69 eCommandProcessMustBeLaunched | 70 eCommandProcessMustBePaused ) 71 { 72 } 73 74 ~CommandObjectFrameInfo () override 75 { 76 } 77 78 protected: 79 bool 80 DoExecute (Args& command, CommandReturnObject &result) override 81 { 82 m_exe_ctx.GetFrameRef().DumpUsingSettingsFormat (&result.GetOutputStream()); 83 result.SetStatus (eReturnStatusSuccessFinishResult); 84 return result.Succeeded(); 85 } 86 }; 87 88 #pragma mark CommandObjectFrameSelect 89 90 //------------------------------------------------------------------------- 91 // CommandObjectFrameSelect 92 //------------------------------------------------------------------------- 93 94 class CommandObjectFrameSelect : public CommandObjectParsed 95 { 96 public: 97 98 class CommandOptions : public Options 99 { 100 public: 101 102 CommandOptions (CommandInterpreter &interpreter) : 103 Options(interpreter) 104 { 105 OptionParsingStarting (); 106 } 107 108 ~CommandOptions () override 109 { 110 } 111 112 Error 113 SetOptionValue (uint32_t option_idx, const char *option_arg) override 114 { 115 Error error; 116 bool success = false; 117 const int short_option = m_getopt_table[option_idx].val; 118 switch (short_option) 119 { 120 case 'r': 121 relative_frame_offset = StringConvert::ToSInt32 (option_arg, INT32_MIN, 0, &success); 122 if (!success) 123 error.SetErrorStringWithFormat ("invalid frame offset argument '%s'", option_arg); 124 break; 125 126 default: 127 error.SetErrorStringWithFormat ("invalid short option character '%c'", short_option); 128 break; 129 } 130 131 return error; 132 } 133 134 void 135 OptionParsingStarting () override 136 { 137 relative_frame_offset = INT32_MIN; 138 } 139 140 const OptionDefinition* 141 GetDefinitions () override 142 { 143 return g_option_table; 144 } 145 146 // Options table: Required for subclasses of Options. 147 148 static OptionDefinition g_option_table[]; 149 int32_t relative_frame_offset; 150 }; 151 152 CommandObjectFrameSelect (CommandInterpreter &interpreter) : 153 CommandObjectParsed (interpreter, 154 "frame select", 155 "Select a frame by index from within the current thread and make it the current frame.", 156 NULL, 157 eCommandRequiresThread | 158 eCommandTryTargetAPILock | 159 eCommandProcessMustBeLaunched | 160 eCommandProcessMustBePaused ), 161 m_options (interpreter) 162 { 163 CommandArgumentEntry arg; 164 CommandArgumentData index_arg; 165 166 // Define the first (and only) variant of this arg. 167 index_arg.arg_type = eArgTypeFrameIndex; 168 index_arg.arg_repetition = eArgRepeatOptional; 169 170 // There is only one variant this argument could be; put it into the argument entry. 171 arg.push_back (index_arg); 172 173 // Push the data for the first argument into the m_arguments vector. 174 m_arguments.push_back (arg); 175 } 176 177 ~CommandObjectFrameSelect () override 178 { 179 } 180 181 Options * 182 GetOptions () override 183 { 184 return &m_options; 185 } 186 187 188 protected: 189 bool 190 DoExecute (Args& command, CommandReturnObject &result) override 191 { 192 // No need to check "thread" for validity as eCommandRequiresThread ensures it is valid 193 Thread *thread = m_exe_ctx.GetThreadPtr(); 194 195 uint32_t frame_idx = UINT32_MAX; 196 if (m_options.relative_frame_offset != INT32_MIN) 197 { 198 // The one and only argument is a signed relative frame index 199 frame_idx = thread->GetSelectedFrameIndex (); 200 if (frame_idx == UINT32_MAX) 201 frame_idx = 0; 202 203 if (m_options.relative_frame_offset < 0) 204 { 205 if (static_cast<int32_t>(frame_idx) >= -m_options.relative_frame_offset) 206 frame_idx += m_options.relative_frame_offset; 207 else 208 { 209 if (frame_idx == 0) 210 { 211 //If you are already at the bottom of the stack, then just warn and don't reset the frame. 212 result.AppendError("Already at the bottom of the stack"); 213 result.SetStatus(eReturnStatusFailed); 214 return false; 215 } 216 else 217 frame_idx = 0; 218 } 219 } 220 else if (m_options.relative_frame_offset > 0) 221 { 222 // I don't want "up 20" where "20" takes you past the top of the stack to produce 223 // an error, but rather to just go to the top. So I have to count the stack here... 224 const uint32_t num_frames = thread->GetStackFrameCount(); 225 if (static_cast<int32_t>(num_frames - frame_idx) > m_options.relative_frame_offset) 226 frame_idx += m_options.relative_frame_offset; 227 else 228 { 229 if (frame_idx == num_frames - 1) 230 { 231 //If we are already at the top of the stack, just warn and don't reset the frame. 232 result.AppendError("Already at the top of the stack"); 233 result.SetStatus(eReturnStatusFailed); 234 return false; 235 } 236 else 237 frame_idx = num_frames - 1; 238 } 239 } 240 } 241 else 242 { 243 if (command.GetArgumentCount() == 1) 244 { 245 const char *frame_idx_cstr = command.GetArgumentAtIndex(0); 246 bool success = false; 247 frame_idx = StringConvert::ToUInt32 (frame_idx_cstr, UINT32_MAX, 0, &success); 248 if (!success) 249 { 250 result.AppendErrorWithFormat ("invalid frame index argument '%s'", frame_idx_cstr); 251 result.SetStatus (eReturnStatusFailed); 252 return false; 253 } 254 } 255 else if (command.GetArgumentCount() == 0) 256 { 257 frame_idx = thread->GetSelectedFrameIndex (); 258 if (frame_idx == UINT32_MAX) 259 { 260 frame_idx = 0; 261 } 262 } 263 else 264 { 265 result.AppendErrorWithFormat ("too many arguments; expected frame-index, saw '%s'.\n", 266 command.GetArgumentAtIndex(0)); 267 m_options.GenerateOptionUsage (result.GetErrorStream(), this); 268 return false; 269 } 270 } 271 272 bool success = thread->SetSelectedFrameByIndexNoisily (frame_idx, result.GetOutputStream()); 273 if (success) 274 { 275 m_exe_ctx.SetFrameSP(thread->GetSelectedFrame ()); 276 result.SetStatus (eReturnStatusSuccessFinishResult); 277 } 278 else 279 { 280 result.AppendErrorWithFormat ("Frame index (%u) out of range.\n", frame_idx); 281 result.SetStatus (eReturnStatusFailed); 282 } 283 284 return result.Succeeded(); 285 } 286 protected: 287 288 CommandOptions m_options; 289 }; 290 291 OptionDefinition 292 CommandObjectFrameSelect::CommandOptions::g_option_table[] = 293 { 294 { LLDB_OPT_SET_1, false, "relative", 'r', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeOffset, "A relative frame index offset from the current frame index."}, 295 { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL } 296 }; 297 298 #pragma mark CommandObjectFrameVariable 299 //---------------------------------------------------------------------- 300 // List images with associated information 301 //---------------------------------------------------------------------- 302 class CommandObjectFrameVariable : public CommandObjectParsed 303 { 304 public: 305 306 CommandObjectFrameVariable (CommandInterpreter &interpreter) : 307 CommandObjectParsed (interpreter, 308 "frame variable", 309 "Show frame variables. All argument and local variables " 310 "that are in scope will be shown when no arguments are given. " 311 "If any arguments are specified, they can be names of " 312 "argument, local, file static and file global variables. " 313 "Children of aggregate variables can be specified such as " 314 "'var->child.x'.", 315 NULL, 316 eCommandRequiresFrame | 317 eCommandTryTargetAPILock | 318 eCommandProcessMustBeLaunched | 319 eCommandProcessMustBePaused | 320 eCommandRequiresProcess), 321 m_option_group (interpreter), 322 m_option_variable(true), // Include the frame specific options by passing "true" 323 m_option_format (eFormatDefault), 324 m_varobj_options() 325 { 326 CommandArgumentEntry arg; 327 CommandArgumentData var_name_arg; 328 329 // Define the first (and only) variant of this arg. 330 var_name_arg.arg_type = eArgTypeVarName; 331 var_name_arg.arg_repetition = eArgRepeatStar; 332 333 // There is only one variant this argument could be; put it into the argument entry. 334 arg.push_back (var_name_arg); 335 336 // Push the data for the first argument into the m_arguments vector. 337 m_arguments.push_back (arg); 338 339 m_option_group.Append (&m_option_variable, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); 340 m_option_group.Append (&m_option_format, OptionGroupFormat::OPTION_GROUP_FORMAT | OptionGroupFormat::OPTION_GROUP_GDB_FMT, LLDB_OPT_SET_1); 341 m_option_group.Append (&m_varobj_options, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); 342 m_option_group.Finalize(); 343 } 344 345 ~CommandObjectFrameVariable () override 346 { 347 } 348 349 Options * 350 GetOptions () override 351 { 352 return &m_option_group; 353 } 354 355 356 int 357 HandleArgumentCompletion (Args &input, 358 int &cursor_index, 359 int &cursor_char_position, 360 OptionElementVector &opt_element_vector, 361 int match_start_point, 362 int max_return_elements, 363 bool &word_complete, 364 StringList &matches) override 365 { 366 // Arguments are the standard source file completer. 367 std::string completion_str (input.GetArgumentAtIndex(cursor_index)); 368 completion_str.erase (cursor_char_position); 369 370 CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter, 371 CommandCompletions::eVariablePathCompletion, 372 completion_str.c_str(), 373 match_start_point, 374 max_return_elements, 375 NULL, 376 word_complete, 377 matches); 378 return matches.GetSize(); 379 } 380 381 protected: 382 bool 383 DoExecute (Args& command, CommandReturnObject &result) override 384 { 385 // No need to check "frame" for validity as eCommandRequiresFrame ensures it is valid 386 StackFrame *frame = m_exe_ctx.GetFramePtr(); 387 388 Stream &s = result.GetOutputStream(); 389 390 bool get_file_globals = true; 391 392 // Be careful about the stack frame, if any summary formatter runs code, it might clear the StackFrameList 393 // for the thread. So hold onto a shared pointer to the frame so it stays alive. 394 395 VariableList *variable_list = frame->GetVariableList (get_file_globals); 396 397 VariableSP var_sp; 398 ValueObjectSP valobj_sp; 399 400 const char *name_cstr = NULL; 401 size_t idx; 402 403 TypeSummaryImplSP summary_format_sp; 404 if (!m_option_variable.summary.IsCurrentValueEmpty()) 405 DataVisualization::NamedSummaryFormats::GetSummaryFormat(ConstString(m_option_variable.summary.GetCurrentValue()), summary_format_sp); 406 else if (!m_option_variable.summary_string.IsCurrentValueEmpty()) 407 summary_format_sp.reset(new StringSummaryFormat(TypeSummaryImpl::Flags(),m_option_variable.summary_string.GetCurrentValue())); 408 409 DumpValueObjectOptions options(m_varobj_options.GetAsDumpOptions(eLanguageRuntimeDescriptionDisplayVerbosityFull,eFormatDefault,summary_format_sp)); 410 411 const SymbolContext& sym_ctx = frame->GetSymbolContext(eSymbolContextFunction); 412 if (sym_ctx.function && sym_ctx.function->IsTopLevelFunction()) 413 m_option_variable.show_globals = true; 414 415 if (variable_list) 416 { 417 const Format format = m_option_format.GetFormat(); 418 options.SetFormat(format); 419 420 if (command.GetArgumentCount() > 0) 421 { 422 VariableList regex_var_list; 423 424 // If we have any args to the variable command, we will make 425 // variable objects from them... 426 for (idx = 0; (name_cstr = command.GetArgumentAtIndex(idx)) != NULL; ++idx) 427 { 428 if (m_option_variable.use_regex) 429 { 430 const size_t regex_start_index = regex_var_list.GetSize(); 431 RegularExpression regex (name_cstr); 432 if (regex.Compile(name_cstr)) 433 { 434 size_t num_matches = 0; 435 const size_t num_new_regex_vars = variable_list->AppendVariablesIfUnique(regex, 436 regex_var_list, 437 num_matches); 438 if (num_new_regex_vars > 0) 439 { 440 for (size_t regex_idx = regex_start_index, end_index = regex_var_list.GetSize(); 441 regex_idx < end_index; 442 ++regex_idx) 443 { 444 var_sp = regex_var_list.GetVariableAtIndex (regex_idx); 445 if (var_sp) 446 { 447 valobj_sp = frame->GetValueObjectForFrameVariable (var_sp, m_varobj_options.use_dynamic); 448 if (valobj_sp) 449 { 450 // if (format != eFormatDefault) 451 // valobj_sp->SetFormat (format); 452 453 if (m_option_variable.show_decl && var_sp->GetDeclaration ().GetFile()) 454 { 455 bool show_fullpaths = false; 456 bool show_module = true; 457 if (var_sp->DumpDeclaration(&s, show_fullpaths, show_module)) 458 s.PutCString (": "); 459 } 460 valobj_sp->Dump(result.GetOutputStream(),options); 461 } 462 } 463 } 464 } 465 else if (num_matches == 0) 466 { 467 result.GetErrorStream().Printf ("error: no variables matched the regular expression '%s'.\n", name_cstr); 468 } 469 } 470 else 471 { 472 char regex_error[1024]; 473 if (regex.GetErrorAsCString(regex_error, sizeof(regex_error))) 474 result.GetErrorStream().Printf ("error: %s\n", regex_error); 475 else 476 result.GetErrorStream().Printf ("error: unknown regex error when compiling '%s'\n", name_cstr); 477 } 478 } 479 else // No regex, either exact variable names or variable expressions. 480 { 481 Error error; 482 uint32_t expr_path_options = StackFrame::eExpressionPathOptionCheckPtrVsMember | 483 StackFrame::eExpressionPathOptionsAllowDirectIVarAccess | 484 StackFrame::eExpressionPathOptionsInspectAnonymousUnions; 485 lldb::VariableSP var_sp; 486 valobj_sp = frame->GetValueForVariableExpressionPath (name_cstr, 487 m_varobj_options.use_dynamic, 488 expr_path_options, 489 var_sp, 490 error); 491 if (valobj_sp) 492 { 493 // if (format != eFormatDefault) 494 // valobj_sp->SetFormat (format); 495 if (m_option_variable.show_decl && var_sp && var_sp->GetDeclaration ().GetFile()) 496 { 497 var_sp->GetDeclaration ().DumpStopContext (&s, false); 498 s.PutCString (": "); 499 } 500 501 options.SetFormat(format); 502 options.SetVariableFormatDisplayLanguage(valobj_sp->GetPreferredDisplayLanguage()); 503 504 Stream &output_stream = result.GetOutputStream(); 505 options.SetRootValueObjectName(valobj_sp->GetParent() ? name_cstr : NULL); 506 valobj_sp->Dump(output_stream,options); 507 } 508 else 509 { 510 const char *error_cstr = error.AsCString(NULL); 511 if (error_cstr) 512 result.GetErrorStream().Printf("error: %s\n", error_cstr); 513 else 514 result.GetErrorStream().Printf ("error: unable to find any variable expression path that matches '%s'\n", name_cstr); 515 } 516 } 517 } 518 } 519 else // No command arg specified. Use variable_list, instead. 520 { 521 const size_t num_variables = variable_list->GetSize(); 522 if (num_variables > 0) 523 { 524 for (size_t i=0; i<num_variables; i++) 525 { 526 var_sp = variable_list->GetVariableAtIndex(i); 527 bool dump_variable = true; 528 std::string scope_string; 529 switch (var_sp->GetScope()) 530 { 531 case eValueTypeVariableGlobal: 532 dump_variable = m_option_variable.show_globals; 533 if (dump_variable && m_option_variable.show_scope) 534 scope_string = "GLOBAL: "; 535 break; 536 537 case eValueTypeVariableStatic: 538 dump_variable = m_option_variable.show_globals; 539 if (dump_variable && m_option_variable.show_scope) 540 scope_string = "STATIC: "; 541 break; 542 543 case eValueTypeVariableArgument: 544 dump_variable = m_option_variable.show_args; 545 if (dump_variable && m_option_variable.show_scope) 546 scope_string = " ARG: "; 547 break; 548 549 case eValueTypeVariableLocal: 550 dump_variable = m_option_variable.show_locals; 551 if (dump_variable && m_option_variable.show_scope) 552 scope_string = " LOCAL: "; 553 break; 554 555 default: 556 break; 557 } 558 559 if (dump_variable) 560 { 561 // Use the variable object code to make sure we are 562 // using the same APIs as the public API will be 563 // using... 564 valobj_sp = frame->GetValueObjectForFrameVariable (var_sp, 565 m_varobj_options.use_dynamic); 566 if (valobj_sp) 567 { 568 // if (format != eFormatDefault) 569 // valobj_sp->SetFormat (format); 570 571 // When dumping all variables, don't print any variables 572 // that are not in scope to avoid extra unneeded output 573 if (valobj_sp->IsInScope ()) 574 { 575 if (false == valobj_sp->GetTargetSP()->GetDisplayRuntimeSupportValues() && 576 true == valobj_sp->IsRuntimeSupportValue()) 577 continue; 578 579 if (!scope_string.empty()) 580 s.PutCString(scope_string.c_str()); 581 582 if (m_option_variable.show_decl && var_sp->GetDeclaration ().GetFile()) 583 { 584 var_sp->GetDeclaration ().DumpStopContext (&s, false); 585 s.PutCString (": "); 586 } 587 588 options.SetFormat(format); 589 options.SetVariableFormatDisplayLanguage(valobj_sp->GetPreferredDisplayLanguage()); 590 options.SetRootValueObjectName(name_cstr); 591 valobj_sp->Dump(result.GetOutputStream(),options); 592 } 593 } 594 } 595 } 596 } 597 } 598 result.SetStatus (eReturnStatusSuccessFinishResult); 599 } 600 601 if (m_interpreter.TruncationWarningNecessary()) 602 { 603 result.GetOutputStream().Printf(m_interpreter.TruncationWarningText(), 604 m_cmd_name.c_str()); 605 m_interpreter.TruncationWarningGiven(); 606 } 607 608 return result.Succeeded(); 609 } 610 protected: 611 612 OptionGroupOptions m_option_group; 613 OptionGroupVariable m_option_variable; 614 OptionGroupFormat m_option_format; 615 OptionGroupValueObjectDisplay m_varobj_options; 616 }; 617 618 619 #pragma mark CommandObjectMultiwordFrame 620 621 //------------------------------------------------------------------------- 622 // CommandObjectMultiwordFrame 623 //------------------------------------------------------------------------- 624 625 CommandObjectMultiwordFrame::CommandObjectMultiwordFrame (CommandInterpreter &interpreter) : 626 CommandObjectMultiword (interpreter, 627 "frame", 628 "A set of commands for operating on the current thread's frames.", 629 "frame <subcommand> [<subcommand-options>]") 630 { 631 LoadSubCommand ("info", CommandObjectSP (new CommandObjectFrameInfo (interpreter))); 632 LoadSubCommand ("select", CommandObjectSP (new CommandObjectFrameSelect (interpreter))); 633 LoadSubCommand ("variable", CommandObjectSP (new CommandObjectFrameVariable (interpreter))); 634 } 635 636 CommandObjectMultiwordFrame::~CommandObjectMultiwordFrame () 637 { 638 } 639 640