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