CommandObjectFrame.cpp revision 368f8226b1f75fbb4758748fafcee70f18fc248e 
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            if (variable_list)
444            {
445                if (command.GetArgumentCount() > 0)
446                {
447                    VariableList regex_var_list;
448
449                    // If we have any args to the variable command, we will make
450                    // variable objects from them...
451                    for (idx = 0; (name_cstr = command.GetArgumentAtIndex(idx)) != NULL; ++idx)
452                    {
453                        uint32_t ptr_depth = m_varobj_options.ptr_depth;
454
455                        if (m_option_variable.use_regex)
456                        {
457                            const uint32_t regex_start_index = regex_var_list.GetSize();
458                            RegularExpression regex (name_cstr);
459                            if (regex.Compile(name_cstr))
460                            {
461                                size_t num_matches = 0;
462                                const size_t num_new_regex_vars = variable_list->AppendVariablesIfUnique(regex,
463                                                                                                         regex_var_list,
464                                                                                                         num_matches);
465                                if (num_new_regex_vars > 0)
466                                {
467                                    for (uint32_t regex_idx = regex_start_index, end_index = regex_var_list.GetSize();
468                                         regex_idx < end_index;
469                                         ++regex_idx)
470                                    {
471                                        var_sp = regex_var_list.GetVariableAtIndex (regex_idx);
472                                        if (var_sp)
473                                        {
474                                            valobj_sp = exe_ctx.frame->GetValueObjectForFrameVariable (var_sp, m_varobj_options.use_dynamic);
475                                            if (valobj_sp)
476                                            {
477                                                if (m_option_variable.format != eFormatDefault)
478                                                    valobj_sp->SetFormat (m_option_variable.format);
479
480                                                if (m_option_variable.show_decl && var_sp->GetDeclaration ().GetFile())
481                                                {
482                                                    var_sp->GetDeclaration ().DumpStopContext (&s, false);
483                                                    s.PutCString (": ");
484                                                }
485
486                                                ValueObject::DumpValueObject (result.GetOutputStream(),
487                                                                              valobj_sp.get(),
488                                                                              var_sp->GetName().AsCString(),
489                                                                              m_varobj_options.ptr_depth,
490                                                                              0,
491                                                                              m_varobj_options.max_depth,
492                                                                              m_varobj_options.show_types,
493                                                                              m_varobj_options.show_location,
494                                                                              m_varobj_options.use_objc,
495                                                                              m_varobj_options.use_dynamic,
496                                                                              false,
497                                                                              m_varobj_options.flat_output);
498                                            }
499                                        }
500                                    }
501                                }
502                                else if (num_matches == 0)
503                                {
504                                    result.GetErrorStream().Printf ("error: no variables matched the regular expression '%s'.\n", name_cstr);
505                                }
506                            }
507                            else
508                            {
509                                char regex_error[1024];
510                                if (regex.GetErrorAsCString(regex_error, sizeof(regex_error)))
511                                    result.GetErrorStream().Printf ("error: %s\n", regex_error);
512                                else
513                                    result.GetErrorStream().Printf ("error: unkown regex error when compiling '%s'\n", name_cstr);
514                            }
515                        }
516                        else
517                        {
518                            Error error;
519                            uint32_t expr_path_options = StackFrame::eExpressionPathOptionCheckPtrVsMember;
520                            lldb::VariableSP var_sp;
521                            valobj_sp = exe_ctx.frame->GetValueForVariableExpressionPath (name_cstr,
522                                                                                          m_varobj_options.use_dynamic,
523                                                                                          expr_path_options,
524                                                                                          var_sp,
525                                                                                          error);
526                            if (valobj_sp)
527                            {
528                                if (m_option_variable.format != eFormatDefault)
529                                    valobj_sp->SetFormat (m_option_variable.format);
530                                if (m_option_variable.show_decl && var_sp && var_sp->GetDeclaration ().GetFile())
531                                {
532                                    var_sp->GetDeclaration ().DumpStopContext (&s, false);
533                                    s.PutCString (": ");
534                                }
535                                ValueObject::DumpValueObject (result.GetOutputStream(),
536                                                              valobj_sp.get(),
537                                                              valobj_sp->GetParent() ? name_cstr : NULL,
538                                                              ptr_depth,
539                                                              0,
540                                                              m_varobj_options.max_depth,
541                                                              m_varobj_options.show_types,
542                                                              m_varobj_options.show_location,
543                                                              m_varobj_options.use_objc,
544                                                              m_varobj_options.use_dynamic,
545                                                              false,
546                                                              m_varobj_options.flat_output);
547                            }
548                            else
549                            {
550                                const char *error_cstr = error.AsCString(NULL);
551                                if (error_cstr)
552                                    result.GetErrorStream().Printf("error: %s\n", error_cstr);
553                                else
554                                    result.GetErrorStream().Printf ("error: unable to find any variable expression path that matches '%s'\n", name_cstr);
555                            }
556                        }
557                    }
558                }
559                else
560                {
561                    const uint32_t num_variables = variable_list->GetSize();
562
563                    if (num_variables > 0)
564                    {
565                        for (uint32_t i=0; i<num_variables; i++)
566                        {
567                            var_sp = variable_list->GetVariableAtIndex(i);
568
569                            bool dump_variable = true;
570
571                            switch (var_sp->GetScope())
572                            {
573                            case eValueTypeVariableGlobal:
574                                dump_variable = m_option_variable.show_globals;
575                                if (dump_variable && m_option_variable.show_scope)
576                                    s.PutCString("GLOBAL: ");
577                                break;
578
579                            case eValueTypeVariableStatic:
580                                dump_variable = m_option_variable.show_globals;
581                                if (dump_variable && m_option_variable.show_scope)
582                                    s.PutCString("STATIC: ");
583                                break;
584
585                            case eValueTypeVariableArgument:
586                                dump_variable = m_option_variable.show_args;
587                                if (dump_variable && m_option_variable.show_scope)
588                                    s.PutCString("   ARG: ");
589                                break;
590
591                            case eValueTypeVariableLocal:
592                                dump_variable = m_option_variable.show_locals;
593                                if (dump_variable && m_option_variable.show_scope)
594                                    s.PutCString(" LOCAL: ");
595                                break;
596
597                            default:
598                                break;
599                            }
600
601                            if (dump_variable)
602                            {
603
604                                // Use the variable object code to make sure we are
605                                // using the same APIs as the the public API will be
606                                // using...
607                                valobj_sp = exe_ctx.frame->GetValueObjectForFrameVariable (var_sp,
608                                                                                           m_varobj_options.use_dynamic);
609                                if (valobj_sp)
610                                {
611                                    if (m_option_variable.format != eFormatDefault)
612                                        valobj_sp->SetFormat (m_option_variable.format);
613
614                                    // When dumping all variables, don't print any variables
615                                    // that are not in scope to avoid extra unneeded output
616                                    if (valobj_sp->IsInScope ())
617                                    {
618                                        if (m_option_variable.show_decl && var_sp->GetDeclaration ().GetFile())
619                                        {
620                                            var_sp->GetDeclaration ().DumpStopContext (&s, false);
621                                            s.PutCString (": ");
622                                        }
623                                        ValueObject::DumpValueObject (result.GetOutputStream(),
624                                                                      valobj_sp.get(),
625                                                                      name_cstr,
626                                                                      m_varobj_options.ptr_depth,
627                                                                      0,
628                                                                      m_varobj_options.max_depth,
629                                                                      m_varobj_options.show_types,
630                                                                      m_varobj_options.show_location,
631                                                                      m_varobj_options.use_objc,
632                                                                      m_varobj_options.use_dynamic,
633                                                                      false,
634                                                                      m_varobj_options.flat_output);
635                                    }
636                                }
637                            }
638                        }
639                    }
640                }
641                result.SetStatus (eReturnStatusSuccessFinishResult);
642            }
643        }
644        return result.Succeeded();
645    }
646protected:
647
648    OptionGroupOptions m_option_group;
649    OptionGroupVariable m_option_variable;
650    OptionGroupValueObjectDisplay m_varobj_options;
651};
652
653
654#pragma mark CommandObjectMultiwordFrame
655
656//-------------------------------------------------------------------------
657// CommandObjectMultiwordFrame
658//-------------------------------------------------------------------------
659
660CommandObjectMultiwordFrame::CommandObjectMultiwordFrame (CommandInterpreter &interpreter) :
661    CommandObjectMultiword (interpreter,
662                            "frame",
663                            "A set of commands for operating on the current thread's frames.",
664                            "frame <subcommand> [<subcommand-options>]")
665{
666    LoadSubCommand ("info",   CommandObjectSP (new CommandObjectFrameInfo (interpreter)));
667    LoadSubCommand ("select", CommandObjectSP (new CommandObjectFrameSelect (interpreter)));
668    LoadSubCommand ("variable", CommandObjectSP (new CommandObjectFrameVariable (interpreter)));
669}
670
671CommandObjectMultiwordFrame::~CommandObjectMultiwordFrame ()
672{
673}
674
675