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