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