CommandObjectDisassemble.cpp revision e1f50b9df1299f6b9181b5ac2699ed4a3ad38a59 
1//===-- CommandObjectDisassemble.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 "CommandObjectDisassemble.h"
11
12// C Includes
13// C++ Includes
14// Other libraries and framework includes
15// Project includes
16#include "lldb/Core/AddressRange.h"
17#include "lldb/Interpreter/Args.h"
18#include "lldb/Interpreter/CommandCompletions.h"
19#include "lldb/Interpreter/CommandInterpreter.h"
20#include "lldb/Interpreter/CommandReturnObject.h"
21#include "lldb/Core/Disassembler.h"
22#include "lldb/Interpreter/Options.h"
23#include "lldb/Core/SourceManager.h"
24#include "lldb/Target/StackFrame.h"
25#include "lldb/Symbol/Symbol.h"
26#include "lldb/Target/Process.h"
27#include "lldb/Target/Target.h"
28
29#define DEFAULT_DISASM_BYTE_SIZE 32
30#define DEFAULT_DISASM_NUM_INS  4
31
32using namespace lldb;
33using namespace lldb_private;
34
35CommandObjectDisassemble::CommandOptions::CommandOptions (CommandInterpreter &interpreter) :
36    Options(interpreter),
37    num_lines_context(0),
38    num_instructions (0),
39    func_name(),
40    start_addr(),
41    end_addr (),
42    at_pc (false),
43    frame_line (false),
44    plugin_name (),
45    arch()
46{
47    OptionParsingStarting();
48}
49
50CommandObjectDisassemble::CommandOptions::~CommandOptions ()
51{
52}
53
54Error
55CommandObjectDisassemble::CommandOptions::SetOptionValue (uint32_t option_idx, const char *option_arg)
56{
57    Error error;
58
59    char short_option = (char) m_getopt_table[option_idx].val;
60
61    bool success;
62
63    switch (short_option)
64    {
65    case 'm':
66        show_mixed = true;
67        break;
68
69    case 'C':
70        num_lines_context = Args::StringToUInt32(option_arg, 0, 0, &success);
71        if (!success)
72            error.SetErrorStringWithFormat ("Invalid num context lines string: \"%s\".\n", option_arg);
73        break;
74
75    case 'c':
76        num_instructions = Args::StringToUInt32(option_arg, 0, 0, &success);
77        if (!success)
78            error.SetErrorStringWithFormat ("Invalid num of instructions string: \"%s\".\n", option_arg);
79        break;
80
81    case 'b':
82        show_bytes = true;
83        break;
84
85    case 's':
86        start_addr = Args::StringToUInt64(option_arg, LLDB_INVALID_ADDRESS, 0);
87        if (start_addr == LLDB_INVALID_ADDRESS)
88            start_addr = Args::StringToUInt64(option_arg, LLDB_INVALID_ADDRESS, 16);
89
90        if (start_addr == LLDB_INVALID_ADDRESS)
91            error.SetErrorStringWithFormat ("Invalid start address string '%s'.\n", option_arg);
92        break;
93    case 'e':
94        end_addr = Args::StringToUInt64(option_arg, LLDB_INVALID_ADDRESS, 0);
95        if (end_addr == LLDB_INVALID_ADDRESS)
96            end_addr = Args::StringToUInt64(option_arg, LLDB_INVALID_ADDRESS, 16);
97
98        if (end_addr == LLDB_INVALID_ADDRESS)
99            error.SetErrorStringWithFormat ("Invalid end address string '%s'.\n", option_arg);
100        break;
101
102    case 'n':
103        func_name.assign (option_arg);
104        break;
105
106    case 'p':
107        at_pc = true;
108        break;
109
110    case 'l':
111        frame_line = true;
112        // Disassemble the current source line kind of implies showing mixed
113        // source code context.
114        show_mixed = true;
115        break;
116
117    case 'P':
118        plugin_name.assign (option_arg);
119        break;
120
121    case 'r':
122        raw = true;
123        break;
124
125    case 'f':
126        // The default action is to disassemble the function for the current frame.
127        // There's no need to set any flag.
128        break;
129
130    case 'a':
131            arch.SetTriple (option_arg, m_interpreter.GetPlatform (true).get());
132        break;
133
134    default:
135        error.SetErrorStringWithFormat("Unrecognized short option '%c'.\n", short_option);
136        break;
137    }
138
139    return error;
140}
141
142void
143CommandObjectDisassemble::CommandOptions::OptionParsingStarting ()
144{
145    show_mixed = false;
146    show_bytes = false;
147    num_lines_context = 0;
148    num_instructions = 0;
149    func_name.clear();
150    at_pc = false;
151    frame_line = false;
152    start_addr = LLDB_INVALID_ADDRESS;
153    end_addr = LLDB_INVALID_ADDRESS;
154    raw = false;
155    plugin_name.clear();
156    arch.Clear();
157}
158
159const OptionDefinition*
160CommandObjectDisassemble::CommandOptions::GetDefinitions ()
161{
162    return g_option_table;
163}
164
165OptionDefinition
166CommandObjectDisassemble::CommandOptions::g_option_table[] =
167{
168{ LLDB_OPT_SET_ALL  , false , "bytes",          'b', no_argument        , NULL, 0, eArgTypeNone,        "Show opcode bytes when disassembling."},
169{ LLDB_OPT_SET_ALL  , false , "context",        'C', required_argument  , NULL, 0, eArgTypeNumLines,    "Number of context lines of source to show."},
170{ LLDB_OPT_SET_ALL  , false , "mixed",          'm', no_argument        , NULL, 0, eArgTypeNone,        "Enable mixed source and assembly display."},
171{ LLDB_OPT_SET_ALL  , false , "raw",            'r', no_argument        , NULL, 0, eArgTypeNone,        "Print raw disassembly with no symbol information."},
172{ LLDB_OPT_SET_ALL  , false , "plugin",         'P', required_argument  , NULL, 0, eArgTypePlugin,      "Name of the disassembler plugin you want to use."},
173{ LLDB_OPT_SET_ALL  , false , "arch",           'a', required_argument  , NULL, 0, eArgTypeArchitecture,"Specify the architecture to use from cross disassembly."},
174{ LLDB_OPT_SET_1 |
175  LLDB_OPT_SET_2    , true  , "start-address" , 's', required_argument  , NULL, 0, eArgTypeStartAddress,"Address at which to start disassembling."},
176{ LLDB_OPT_SET_1    , false , "end-address"  ,  'e', required_argument  , NULL, 0, eArgTypeEndAddress,  "Address at which to end disassembling."},
177{ LLDB_OPT_SET_2 |
178  LLDB_OPT_SET_3 |
179  LLDB_OPT_SET_4 |
180  LLDB_OPT_SET_5    , false , "count",          'c', required_argument  , NULL, 0, eArgTypeNumLines,    "Number of instructions to display."},
181{ LLDB_OPT_SET_3    , true  , "name",           'n', required_argument  , NULL, CommandCompletions::eSymbolCompletion, eArgTypeFunctionName,             "Disassemble entire contents of the given function name."},
182{ LLDB_OPT_SET_4    , true  , "frame",          'f', no_argument        , NULL, 0, eArgTypeNone,        "Disassemble from the start of the current frame's function."},
183{ LLDB_OPT_SET_5    , true  , "pc",             'p', no_argument        , NULL, 0, eArgTypeNone,        "Disassemble around the current pc."},
184{ LLDB_OPT_SET_6    , true  , "line",           'l', no_argument        , NULL, 0, eArgTypeNone,        "Disassemble the current frame's current source line instructions if there debug line table information, else disasemble around the pc."},
185{ 0                 , false , NULL,             0,   0                  , NULL, 0, eArgTypeNone,        NULL }
186};
187
188
189
190//-------------------------------------------------------------------------
191// CommandObjectDisassemble
192//-------------------------------------------------------------------------
193
194CommandObjectDisassemble::CommandObjectDisassemble (CommandInterpreter &interpreter) :
195    CommandObject (interpreter,
196                   "disassemble",
197                   "Disassemble bytes in the current function, or elsewhere in the executable program as specified by the user.",
198                   "disassemble [<cmd-options>]"),
199    m_options (interpreter)
200{
201}
202
203CommandObjectDisassemble::~CommandObjectDisassemble()
204{
205}
206
207bool
208CommandObjectDisassemble::Execute
209(
210    Args& command,
211    CommandReturnObject &result
212)
213{
214    Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
215    if (target == NULL)
216    {
217        result.AppendError ("invalid target, create a debug target using the 'target create' command");
218        result.SetStatus (eReturnStatusFailed);
219        return false;
220    }
221    if (!m_options.arch.IsValid())
222        m_options.arch = target->GetArchitecture();
223
224    if (!m_options.arch.IsValid())
225    {
226        result.AppendError ("use the --arch option or set the target architecure to disassemble");
227        result.SetStatus (eReturnStatusFailed);
228        return false;
229    }
230
231    const char *plugin_name = m_options.GetPluginName ();
232    Disassembler *disassembler = Disassembler::FindPlugin(m_options.arch, plugin_name);
233
234    if (disassembler == NULL)
235    {
236        if (plugin_name)
237            result.AppendErrorWithFormat ("Unable to find Disassembler plug-in named '%s' that supports the '%s' architecture.\n",
238                                          plugin_name,
239                                          m_options.arch.GetArchitectureName());
240        else
241            result.AppendErrorWithFormat ("Unable to find Disassembler plug-in for the '%s' architecture.\n",
242                                          m_options.arch.GetArchitectureName());
243        result.SetStatus (eReturnStatusFailed);
244        return false;
245    }
246
247    result.SetStatus (eReturnStatusSuccessFinishResult);
248
249    if (command.GetArgumentCount() != 0)
250    {
251        result.AppendErrorWithFormat ("\"disassemble\" arguments are specified as options.\n");
252        GetOptions()->GenerateOptionUsage (result.GetErrorStream(), this);
253        result.SetStatus (eReturnStatusFailed);
254        return false;
255    }
256
257    if (m_options.show_mixed && m_options.num_lines_context == 0)
258        m_options.num_lines_context = 1;
259
260    ExecutionContext exe_ctx(m_interpreter.GetExecutionContext());
261
262    if (!m_options.func_name.empty())
263    {
264        ConstString name(m_options.func_name.c_str());
265
266        if (Disassembler::Disassemble (m_interpreter.GetDebugger(),
267                                       m_options.arch,
268                                       plugin_name,
269                                       exe_ctx,
270                                       name,
271                                       NULL,    // Module *
272                                       m_options.num_instructions,
273                                       m_options.show_mixed ? m_options.num_lines_context : 0,
274                                       m_options.show_bytes,
275                                       m_options.raw,
276                                       result.GetOutputStream()))
277        {
278            result.SetStatus (eReturnStatusSuccessFinishResult);
279        }
280        else
281        {
282            result.AppendErrorWithFormat ("Unable to find symbol with name '%s'.\n", name.GetCString());
283            result.SetStatus (eReturnStatusFailed);
284        }
285    }
286    else
287    {
288        AddressRange range;
289        if (m_options.frame_line)
290        {
291            LineEntry pc_line_entry (exe_ctx.frame->GetSymbolContext(eSymbolContextLineEntry).line_entry);
292            if (pc_line_entry.IsValid())
293            {
294                range = pc_line_entry.range;
295            }
296            else
297            {
298                m_options.at_pc = true; // No line entry, so just disassemble around the current pc
299                m_options.show_mixed = false;
300            }
301        }
302
303        // Did the "m_options.frame_line" find a valid range already? If so
304        // skip the rest...
305        if (range.GetByteSize() == 0)
306        {
307            if (m_options.at_pc)
308            {
309                if (exe_ctx.frame == NULL)
310                {
311                    result.AppendError ("Cannot disassemble around the current PC without a selected frame.\n");
312                    result.SetStatus (eReturnStatusFailed);
313                    return false;
314                }
315                range.GetBaseAddress() = exe_ctx.frame->GetFrameCodeAddress();
316                if (m_options.num_instructions == 0)
317                {
318                    // Disassembling at the PC always disassembles some number of instructions (not the whole function).
319                    m_options.num_instructions = DEFAULT_DISASM_NUM_INS;
320                }
321            }
322            else
323            {
324                range.GetBaseAddress().SetOffset (m_options.start_addr);
325                if (range.GetBaseAddress().IsValid())
326                {
327                    if (m_options.end_addr != LLDB_INVALID_ADDRESS)
328                    {
329                        if (m_options.end_addr <= m_options.start_addr)
330                        {
331                            result.AppendErrorWithFormat ("End address before start address.\n");
332                            result.SetStatus (eReturnStatusFailed);
333                            return false;
334                        }
335                        range.SetByteSize (m_options.end_addr - m_options.start_addr);
336                    }
337                }
338            }
339        }
340
341        if (m_options.num_instructions != 0)
342        {
343            if (!range.GetBaseAddress().IsValid())
344            {
345                // The default action is to disassemble the current frame function.
346                if (exe_ctx.frame)
347                {
348                    SymbolContext sc(exe_ctx.frame->GetSymbolContext(eSymbolContextFunction | eSymbolContextSymbol));
349                    if (sc.function)
350                        range.GetBaseAddress() = sc.function->GetAddressRange().GetBaseAddress();
351                    else if (sc.symbol && sc.symbol->GetAddressRangePtr())
352                        range.GetBaseAddress() = sc.symbol->GetAddressRangePtr()->GetBaseAddress();
353                    else
354                        range.GetBaseAddress() = exe_ctx.frame->GetFrameCodeAddress();
355                }
356
357                if (!range.GetBaseAddress().IsValid())
358                {
359                    result.AppendError ("invalid frame");
360                    result.SetStatus (eReturnStatusFailed);
361                    return false;
362                }
363            }
364
365            if (Disassembler::Disassemble (m_interpreter.GetDebugger(),
366                                           m_options.arch,
367                                           plugin_name,
368                                           exe_ctx,
369                                           range.GetBaseAddress(),
370                                           m_options.num_instructions,
371                                           m_options.show_mixed ? m_options.num_lines_context : 0,
372                                           m_options.show_bytes,
373                                           m_options.raw,
374                                           result.GetOutputStream()))
375            {
376                result.SetStatus (eReturnStatusSuccessFinishResult);
377            }
378            else
379            {
380                result.AppendErrorWithFormat ("Failed to disassemble memory at 0x%8.8llx.\n", m_options.start_addr);
381                result.SetStatus (eReturnStatusFailed);
382            }
383        }
384        else
385        {
386            if (!range.GetBaseAddress().IsValid())
387            {
388                // The default action is to disassemble the current frame function.
389                if (exe_ctx.frame)
390                {
391                    SymbolContext sc(exe_ctx.frame->GetSymbolContext(eSymbolContextFunction | eSymbolContextSymbol));
392                    if (sc.function)
393                        range = sc.function->GetAddressRange();
394                    else if (sc.symbol && sc.symbol->GetAddressRangePtr())
395                        range = *sc.symbol->GetAddressRangePtr();
396                    else
397                        range.GetBaseAddress() = exe_ctx.frame->GetFrameCodeAddress();
398                }
399                else
400                {
401                    result.AppendError ("invalid frame");
402                    result.SetStatus (eReturnStatusFailed);
403                    return false;
404                }
405            }
406            if (range.GetByteSize() == 0)
407                range.SetByteSize(DEFAULT_DISASM_BYTE_SIZE);
408
409            if (Disassembler::Disassemble (m_interpreter.GetDebugger(),
410                                           m_options.arch,
411                                           plugin_name,
412                                           exe_ctx,
413                                           range,
414                                           m_options.num_instructions,
415                                           m_options.show_mixed ? m_options.num_lines_context : 0,
416                                           m_options.show_bytes,
417                                           m_options.raw,
418                                           result.GetOutputStream()))
419            {
420                result.SetStatus (eReturnStatusSuccessFinishResult);
421            }
422            else
423            {
424                result.AppendErrorWithFormat ("Failed to disassemble memory at 0x%8.8llx.\n", m_options.start_addr);
425                result.SetStatus (eReturnStatusFailed);
426            }
427        }
428    }
429
430    return result.Succeeded();
431}
432