1 //===-- CommandObjectDisassemble.cpp --------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "CommandObjectDisassemble.h"
10 #include "lldb/Core/AddressRange.h"
11 #include "lldb/Core/Disassembler.h"
12 #include "lldb/Core/Module.h"
13 #include "lldb/Host/OptionParser.h"
14 #include "lldb/Interpreter/CommandInterpreter.h"
15 #include "lldb/Interpreter/CommandReturnObject.h"
16 #include "lldb/Interpreter/OptionArgParser.h"
17 #include "lldb/Interpreter/Options.h"
18 #include "lldb/Symbol/Function.h"
19 #include "lldb/Symbol/Symbol.h"
20 #include "lldb/Target/SectionLoadList.h"
21 #include "lldb/Target/StackFrame.h"
22 #include "lldb/Target/Target.h"
23 
24 static constexpr unsigned default_disasm_byte_size = 32;
25 static constexpr unsigned default_disasm_num_ins = 4;
26 
27 using namespace lldb;
28 using namespace lldb_private;
29 
30 #define LLDB_OPTIONS_disassemble
31 #include "CommandOptions.inc"
32 
33 CommandObjectDisassemble::CommandOptions::CommandOptions() {
34   OptionParsingStarting(nullptr);
35 }
36 
37 CommandObjectDisassemble::CommandOptions::~CommandOptions() = default;
38 
39 Status CommandObjectDisassemble::CommandOptions::SetOptionValue(
40     uint32_t option_idx, llvm::StringRef option_arg,
41     ExecutionContext *execution_context) {
42   Status error;
43 
44   const int short_option = m_getopt_table[option_idx].val;
45 
46   switch (short_option) {
47   case 'm':
48     show_mixed = true;
49     break;
50 
51   case 'C':
52     if (option_arg.getAsInteger(0, num_lines_context))
53       error.SetErrorStringWithFormat("invalid num context lines string: \"%s\"",
54                                      option_arg.str().c_str());
55     break;
56 
57   case 'c':
58     if (option_arg.getAsInteger(0, num_instructions))
59       error.SetErrorStringWithFormat(
60           "invalid num of instructions string: \"%s\"",
61           option_arg.str().c_str());
62     break;
63 
64   case 'b':
65     show_bytes = true;
66     break;
67 
68   case 's': {
69     start_addr = OptionArgParser::ToAddress(execution_context, option_arg,
70                                             LLDB_INVALID_ADDRESS, &error);
71     if (start_addr != LLDB_INVALID_ADDRESS)
72       some_location_specified = true;
73   } break;
74   case 'e': {
75     end_addr = OptionArgParser::ToAddress(execution_context, option_arg,
76                                           LLDB_INVALID_ADDRESS, &error);
77     if (end_addr != LLDB_INVALID_ADDRESS)
78       some_location_specified = true;
79   } break;
80 
81   case 'n':
82     func_name.assign(std::string(option_arg));
83     some_location_specified = true;
84     break;
85 
86   case 'p':
87     at_pc = true;
88     some_location_specified = true;
89     break;
90 
91   case 'l':
92     frame_line = true;
93     // Disassemble the current source line kind of implies showing mixed source
94     // code context.
95     show_mixed = true;
96     some_location_specified = true;
97     break;
98 
99   case 'P':
100     plugin_name.assign(std::string(option_arg));
101     break;
102 
103   case 'F': {
104     TargetSP target_sp =
105         execution_context ? execution_context->GetTargetSP() : TargetSP();
106     if (target_sp && (target_sp->GetArchitecture().GetTriple().getArch() ==
107                           llvm::Triple::x86 ||
108                       target_sp->GetArchitecture().GetTriple().getArch() ==
109                           llvm::Triple::x86_64)) {
110       flavor_string.assign(std::string(option_arg));
111     } else
112       error.SetErrorStringWithFormat("Disassembler flavors are currently only "
113                                      "supported for x86 and x86_64 targets.");
114     break;
115   }
116 
117   case 'r':
118     raw = true;
119     break;
120 
121   case 'f':
122     current_function = true;
123     some_location_specified = true;
124     break;
125 
126   case 'A':
127     if (execution_context) {
128       const auto &target_sp = execution_context->GetTargetSP();
129       auto platform_ptr = target_sp ? target_sp->GetPlatform().get() : nullptr;
130       arch = Platform::GetAugmentedArchSpec(platform_ptr, option_arg);
131     }
132     break;
133 
134   case 'a': {
135     symbol_containing_addr = OptionArgParser::ToAddress(
136         execution_context, option_arg, LLDB_INVALID_ADDRESS, &error);
137     if (symbol_containing_addr != LLDB_INVALID_ADDRESS) {
138       some_location_specified = true;
139     }
140   } break;
141 
142   case '\x01':
143     force = true;
144     break;
145 
146   default:
147     llvm_unreachable("Unimplemented option");
148   }
149 
150   return error;
151 }
152 
153 void CommandObjectDisassemble::CommandOptions::OptionParsingStarting(
154     ExecutionContext *execution_context) {
155   show_mixed = false;
156   show_bytes = false;
157   num_lines_context = 0;
158   num_instructions = 0;
159   func_name.clear();
160   current_function = false;
161   at_pc = false;
162   frame_line = false;
163   start_addr = LLDB_INVALID_ADDRESS;
164   end_addr = LLDB_INVALID_ADDRESS;
165   symbol_containing_addr = LLDB_INVALID_ADDRESS;
166   raw = false;
167   plugin_name.clear();
168 
169   Target *target =
170       execution_context ? execution_context->GetTargetPtr() : nullptr;
171 
172   // This is a hack till we get the ability to specify features based on
173   // architecture.  For now GetDisassemblyFlavor is really only valid for x86
174   // (and for the llvm assembler plugin, but I'm papering over that since that
175   // is the only disassembler plugin we have...
176   if (target) {
177     if (target->GetArchitecture().GetTriple().getArch() == llvm::Triple::x86 ||
178         target->GetArchitecture().GetTriple().getArch() ==
179             llvm::Triple::x86_64) {
180       flavor_string.assign(target->GetDisassemblyFlavor());
181     } else
182       flavor_string.assign("default");
183 
184   } else
185     flavor_string.assign("default");
186 
187   arch.Clear();
188   some_location_specified = false;
189   force = false;
190 }
191 
192 Status CommandObjectDisassemble::CommandOptions::OptionParsingFinished(
193     ExecutionContext *execution_context) {
194   if (!some_location_specified)
195     current_function = true;
196   return Status();
197 }
198 
199 llvm::ArrayRef<OptionDefinition>
200 CommandObjectDisassemble::CommandOptions::GetDefinitions() {
201   return llvm::makeArrayRef(g_disassemble_options);
202 }
203 
204 // CommandObjectDisassemble
205 
206 CommandObjectDisassemble::CommandObjectDisassemble(
207     CommandInterpreter &interpreter)
208     : CommandObjectParsed(
209           interpreter, "disassemble",
210           "Disassemble specified instructions in the current target.  "
211           "Defaults to the current function for the current thread and "
212           "stack frame.",
213           "disassemble [<cmd-options>]", eCommandRequiresTarget),
214       m_options() {}
215 
216 CommandObjectDisassemble::~CommandObjectDisassemble() = default;
217 
218 llvm::Error CommandObjectDisassemble::CheckRangeSize(const AddressRange &range,
219                                                      llvm::StringRef what) {
220   if (m_options.num_instructions > 0 || m_options.force ||
221       range.GetByteSize() < GetDebugger().GetStopDisassemblyMaxSize())
222     return llvm::Error::success();
223   StreamString msg;
224   msg << "Not disassembling " << what << " because it is very large ";
225   range.Dump(&msg, &GetSelectedTarget(), Address::DumpStyleLoadAddress,
226              Address::DumpStyleFileAddress);
227   msg << ". To disassemble specify an instruction count limit, start/stop "
228          "addresses or use the --force option.";
229   return llvm::createStringError(llvm::inconvertibleErrorCode(),
230                                  msg.GetString());
231 }
232 
233 llvm::Expected<std::vector<AddressRange>>
234 CommandObjectDisassemble::GetContainingAddressRanges() {
235   std::vector<AddressRange> ranges;
236   const auto &get_range = [&](Address addr) {
237     ModuleSP module_sp(addr.GetModule());
238     SymbolContext sc;
239     bool resolve_tail_call_address = true;
240     addr.GetModule()->ResolveSymbolContextForAddress(
241         addr, eSymbolContextEverything, sc, resolve_tail_call_address);
242     if (sc.function || sc.symbol) {
243       AddressRange range;
244       sc.GetAddressRange(eSymbolContextFunction | eSymbolContextSymbol, 0,
245                          false, range);
246       ranges.push_back(range);
247     }
248   };
249 
250   Target &target = GetSelectedTarget();
251   if (!target.GetSectionLoadList().IsEmpty()) {
252     Address symbol_containing_address;
253     if (target.GetSectionLoadList().ResolveLoadAddress(
254             m_options.symbol_containing_addr, symbol_containing_address)) {
255       get_range(symbol_containing_address);
256     }
257   } else {
258     for (lldb::ModuleSP module_sp : target.GetImages().Modules()) {
259       Address file_address;
260       if (module_sp->ResolveFileAddress(m_options.symbol_containing_addr,
261                                         file_address)) {
262         get_range(file_address);
263       }
264     }
265   }
266 
267   if (ranges.empty()) {
268     return llvm::createStringError(
269         llvm::inconvertibleErrorCode(),
270         "Could not find function bounds for address 0x%" PRIx64,
271         m_options.symbol_containing_addr);
272   }
273 
274   if (llvm::Error err = CheckRangeSize(ranges[0], "the function"))
275     return std::move(err);
276   return ranges;
277 }
278 
279 llvm::Expected<std::vector<AddressRange>>
280 CommandObjectDisassemble::GetCurrentFunctionRanges() {
281   StackFrame *frame = m_exe_ctx.GetFramePtr();
282   if (!frame) {
283     return llvm::createStringError(llvm::inconvertibleErrorCode(),
284                                    "Cannot disassemble around the current "
285                                    "function without a selected frame.\n");
286   }
287   SymbolContext sc(
288       frame->GetSymbolContext(eSymbolContextFunction | eSymbolContextSymbol));
289   AddressRange range;
290   if (sc.function)
291     range = sc.function->GetAddressRange();
292   else if (sc.symbol && sc.symbol->ValueIsAddress()) {
293     range = {sc.symbol->GetAddress(), sc.symbol->GetByteSize()};
294   } else
295     range = {frame->GetFrameCodeAddress(), default_disasm_byte_size};
296 
297   if (llvm::Error err = CheckRangeSize(range, "the current function"))
298     return std::move(err);
299   return std::vector<AddressRange>{range};
300 }
301 
302 llvm::Expected<std::vector<AddressRange>>
303 CommandObjectDisassemble::GetCurrentLineRanges() {
304   StackFrame *frame = m_exe_ctx.GetFramePtr();
305   if (!frame) {
306     return llvm::createStringError(llvm::inconvertibleErrorCode(),
307                                    "Cannot disassemble around the current "
308                                    "line without a selected frame.\n");
309   }
310 
311   LineEntry pc_line_entry(
312       frame->GetSymbolContext(eSymbolContextLineEntry).line_entry);
313   if (pc_line_entry.IsValid())
314     return std::vector<AddressRange>{pc_line_entry.range};
315 
316   // No line entry, so just disassemble around the current pc
317   m_options.show_mixed = false;
318   return GetPCRanges();
319 }
320 
321 llvm::Expected<std::vector<AddressRange>>
322 CommandObjectDisassemble::GetNameRanges(CommandReturnObject &result) {
323   ConstString name(m_options.func_name.c_str());
324 
325   ModuleFunctionSearchOptions function_options;
326   function_options.include_symbols = true;
327   function_options.include_inlines = true;
328 
329   // Find functions matching the given name.
330   SymbolContextList sc_list;
331   GetSelectedTarget().GetImages().FindFunctions(name, eFunctionNameTypeAuto,
332                                                 function_options, sc_list);
333 
334   std::vector<AddressRange> ranges;
335   llvm::Error range_errs = llvm::Error::success();
336   AddressRange range;
337   const uint32_t scope =
338       eSymbolContextBlock | eSymbolContextFunction | eSymbolContextSymbol;
339   const bool use_inline_block_range = true;
340   for (SymbolContext sc : sc_list.SymbolContexts()) {
341     for (uint32_t range_idx = 0;
342          sc.GetAddressRange(scope, range_idx, use_inline_block_range, range);
343          ++range_idx) {
344       if (llvm::Error err = CheckRangeSize(range, "a range"))
345         range_errs = joinErrors(std::move(range_errs), std::move(err));
346       else
347         ranges.push_back(range);
348     }
349   }
350   if (ranges.empty()) {
351     if (range_errs)
352       return std::move(range_errs);
353     return llvm::createStringError(llvm::inconvertibleErrorCode(),
354                                    "Unable to find symbol with name '%s'.\n",
355                                    name.GetCString());
356   }
357   if (range_errs)
358     result.AppendWarning(toString(std::move(range_errs)));
359   return ranges;
360 }
361 
362 llvm::Expected<std::vector<AddressRange>>
363 CommandObjectDisassemble::GetPCRanges() {
364   StackFrame *frame = m_exe_ctx.GetFramePtr();
365   if (!frame) {
366     return llvm::createStringError(llvm::inconvertibleErrorCode(),
367                                    "Cannot disassemble around the current "
368                                    "PC without a selected frame.\n");
369   }
370 
371   if (m_options.num_instructions == 0) {
372     // Disassembling at the PC always disassembles some number of
373     // instructions (not the whole function).
374     m_options.num_instructions = default_disasm_num_ins;
375   }
376   return std::vector<AddressRange>{{frame->GetFrameCodeAddress(), 0}};
377 }
378 
379 llvm::Expected<std::vector<AddressRange>>
380 CommandObjectDisassemble::GetStartEndAddressRanges() {
381   addr_t size = 0;
382   if (m_options.end_addr != LLDB_INVALID_ADDRESS) {
383     if (m_options.end_addr <= m_options.start_addr) {
384       return llvm::createStringError(llvm::inconvertibleErrorCode(),
385                                      "End address before start address.");
386     }
387     size = m_options.end_addr - m_options.start_addr;
388   }
389   return std::vector<AddressRange>{{Address(m_options.start_addr), size}};
390 }
391 
392 llvm::Expected<std::vector<AddressRange>>
393 CommandObjectDisassemble::GetRangesForSelectedMode(
394     CommandReturnObject &result) {
395   if (m_options.symbol_containing_addr != LLDB_INVALID_ADDRESS)
396     return CommandObjectDisassemble::GetContainingAddressRanges();
397   if (m_options.current_function)
398     return CommandObjectDisassemble::GetCurrentFunctionRanges();
399   if (m_options.frame_line)
400     return CommandObjectDisassemble::GetCurrentLineRanges();
401   if (!m_options.func_name.empty())
402     return CommandObjectDisassemble::GetNameRanges(result);
403   if (m_options.start_addr != LLDB_INVALID_ADDRESS)
404     return CommandObjectDisassemble::GetStartEndAddressRanges();
405   return CommandObjectDisassemble::GetPCRanges();
406 }
407 
408 bool CommandObjectDisassemble::DoExecute(Args &command,
409                                          CommandReturnObject &result) {
410   Target *target = &GetSelectedTarget();
411 
412   if (!m_options.arch.IsValid())
413     m_options.arch = target->GetArchitecture();
414 
415   if (!m_options.arch.IsValid()) {
416     result.AppendError(
417         "use the --arch option or set the target architecture to disassemble");
418     return false;
419   }
420 
421   const char *plugin_name = m_options.GetPluginName();
422   const char *flavor_string = m_options.GetFlavorString();
423 
424   DisassemblerSP disassembler =
425       Disassembler::FindPlugin(m_options.arch, flavor_string, plugin_name);
426 
427   if (!disassembler) {
428     if (plugin_name) {
429       result.AppendErrorWithFormat(
430           "Unable to find Disassembler plug-in named '%s' that supports the "
431           "'%s' architecture.\n",
432           plugin_name, m_options.arch.GetArchitectureName());
433     } else
434       result.AppendErrorWithFormat(
435           "Unable to find Disassembler plug-in for the '%s' architecture.\n",
436           m_options.arch.GetArchitectureName());
437     return false;
438   } else if (flavor_string != nullptr && !disassembler->FlavorValidForArchSpec(
439                                              m_options.arch, flavor_string))
440     result.AppendWarningWithFormat(
441         "invalid disassembler flavor \"%s\", using default.\n", flavor_string);
442 
443   result.SetStatus(eReturnStatusSuccessFinishResult);
444 
445   if (!command.empty()) {
446     result.AppendErrorWithFormat(
447         "\"disassemble\" arguments are specified as options.\n");
448     const int terminal_width =
449         GetCommandInterpreter().GetDebugger().GetTerminalWidth();
450     GetOptions()->GenerateOptionUsage(result.GetErrorStream(), this,
451                                       terminal_width);
452     return false;
453   }
454 
455   if (m_options.show_mixed && m_options.num_lines_context == 0)
456     m_options.num_lines_context = 2;
457 
458   // Always show the PC in the disassembly
459   uint32_t options = Disassembler::eOptionMarkPCAddress;
460 
461   // Mark the source line for the current PC only if we are doing mixed source
462   // and assembly
463   if (m_options.show_mixed)
464     options |= Disassembler::eOptionMarkPCSourceLine;
465 
466   if (m_options.show_bytes)
467     options |= Disassembler::eOptionShowBytes;
468 
469   if (m_options.raw)
470     options |= Disassembler::eOptionRawOuput;
471 
472   llvm::Expected<std::vector<AddressRange>> ranges =
473       GetRangesForSelectedMode(result);
474   if (!ranges) {
475     result.AppendError(toString(ranges.takeError()));
476     return result.Succeeded();
477   }
478 
479   bool print_sc_header = ranges->size() > 1;
480   for (AddressRange cur_range : *ranges) {
481     Disassembler::Limit limit;
482     if (m_options.num_instructions == 0) {
483       limit = {Disassembler::Limit::Bytes, cur_range.GetByteSize()};
484       if (limit.value == 0)
485         limit.value = default_disasm_byte_size;
486     } else {
487       limit = {Disassembler::Limit::Instructions, m_options.num_instructions};
488     }
489     if (Disassembler::Disassemble(
490             GetDebugger(), m_options.arch, plugin_name, flavor_string,
491             m_exe_ctx, cur_range.GetBaseAddress(), limit, m_options.show_mixed,
492             m_options.show_mixed ? m_options.num_lines_context : 0, options,
493             result.GetOutputStream())) {
494       result.SetStatus(eReturnStatusSuccessFinishResult);
495     } else {
496       if (m_options.symbol_containing_addr != LLDB_INVALID_ADDRESS) {
497         result.AppendErrorWithFormat(
498             "Failed to disassemble memory in function at 0x%8.8" PRIx64 ".\n",
499             m_options.symbol_containing_addr);
500       } else {
501         result.AppendErrorWithFormat(
502             "Failed to disassemble memory at 0x%8.8" PRIx64 ".\n",
503             cur_range.GetBaseAddress().GetLoadAddress(target));
504       }
505     }
506     if (print_sc_header)
507       result.GetOutputStream() << "\n";
508   }
509 
510   return result.Succeeded();
511 }
512