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