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