LLDB  mainline
Disassembler.cpp
Go to the documentation of this file.
1 //===-- Disassembler.cpp ----------------------------------------*- C++ -*-===//
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 
10 
11 #include "lldb/Core/AddressRange.h"
12 #include "lldb/Core/Debugger.h"
14 #include "lldb/Core/Mangled.h"
15 #include "lldb/Core/Module.h"
16 #include "lldb/Core/ModuleList.h"
19 #include "lldb/Host/FileSystem.h"
26 #include "lldb/Symbol/Function.h"
27 #include "lldb/Symbol/Symbol.h"
31 #include "lldb/Target/StackFrame.h"
32 #include "lldb/Target/Target.h"
33 #include "lldb/Target/Thread.h"
37 #include "lldb/Utility/Status.h"
38 #include "lldb/Utility/Stream.h"
40 #include "lldb/Utility/Timer.h"
44 #include "llvm/ADT/Triple.h"
45 #include "llvm/Support/Compiler.h"
46 
47 #include <cstdint>
48 #include <cstring>
49 #include <utility>
50 
51 #include <assert.h>
52 
53 #define DEFAULT_DISASM_BYTE_SIZE 32
54 
55 using namespace lldb;
56 using namespace lldb_private;
57 
58 DisassemblerSP Disassembler::FindPlugin(const ArchSpec &arch,
59  const char *flavor,
60  const char *plugin_name) {
61  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
62  Timer scoped_timer(func_cat,
63  "Disassembler::FindPlugin (arch = %s, plugin_name = %s)",
64  arch.GetArchitectureName(), plugin_name);
65 
66  DisassemblerCreateInstance create_callback = nullptr;
67 
68  if (plugin_name) {
69  ConstString const_plugin_name(plugin_name);
70  create_callback = PluginManager::GetDisassemblerCreateCallbackForPluginName(
71  const_plugin_name);
72  if (create_callback) {
73  DisassemblerSP disassembler_sp(create_callback(arch, flavor));
74 
75  if (disassembler_sp)
76  return disassembler_sp;
77  }
78  } else {
79  for (uint32_t idx = 0;
80  (create_callback = PluginManager::GetDisassemblerCreateCallbackAtIndex(
81  idx)) != nullptr;
82  ++idx) {
83  DisassemblerSP disassembler_sp(create_callback(arch, flavor));
84 
85  if (disassembler_sp)
86  return disassembler_sp;
87  }
88  }
89  return DisassemblerSP();
90 }
91 
92 DisassemblerSP Disassembler::FindPluginForTarget(const TargetSP target_sp,
93  const ArchSpec &arch,
94  const char *flavor,
95  const char *plugin_name) {
96  if (target_sp && flavor == nullptr) {
97  // FIXME - we don't have the mechanism in place to do per-architecture
98  // settings. But since we know that for now we only support flavors on x86
99  // & x86_64,
100  if (arch.GetTriple().getArch() == llvm::Triple::x86 ||
101  arch.GetTriple().getArch() == llvm::Triple::x86_64)
102  flavor = target_sp->GetDisassemblyFlavor();
103  }
104  return FindPlugin(arch, flavor, plugin_name);
105 }
106 
107 static void ResolveAddress(const ExecutionContext &exe_ctx, const Address &addr,
108  Address &resolved_addr) {
109  if (!addr.IsSectionOffset()) {
110  // If we weren't passed in a section offset address range, try and resolve
111  // it to something
112  Target *target = exe_ctx.GetTargetPtr();
113  if (target) {
114  bool is_resolved =
115  target->GetSectionLoadList().IsEmpty() ?
116  target->GetImages().ResolveFileAddress(addr.GetOffset(),
117  resolved_addr) :
119  resolved_addr);
120 
121  // We weren't able to resolve the address, just treat it as a raw address
122  if (is_resolved && resolved_addr.IsValid())
123  return;
124  }
125  }
126  resolved_addr = addr;
127 }
128 
129 size_t Disassembler::Disassemble(Debugger &debugger, const ArchSpec &arch,
130  const char *plugin_name, const char *flavor,
131  const ExecutionContext &exe_ctx,
132  SymbolContextList &sc_list,
133  uint32_t num_instructions,
134  bool mixed_source_and_assembly,
135  uint32_t num_mixed_context_lines,
136  uint32_t options, Stream &strm) {
137  size_t success_count = 0;
138  const size_t count = sc_list.GetSize();
139  SymbolContext sc;
140  AddressRange range;
141  const uint32_t scope =
142  eSymbolContextBlock | eSymbolContextFunction | eSymbolContextSymbol;
143  const bool use_inline_block_range = true;
144  for (size_t i = 0; i < count; ++i) {
145  if (!sc_list.GetContextAtIndex(i, sc))
146  break;
147  for (uint32_t range_idx = 0;
148  sc.GetAddressRange(scope, range_idx, use_inline_block_range, range);
149  ++range_idx) {
150  if (Disassemble(debugger, arch, plugin_name, flavor, exe_ctx, range,
151  num_instructions, mixed_source_and_assembly,
152  num_mixed_context_lines, options, strm)) {
153  ++success_count;
154  strm.EOL();
155  }
156  }
157  }
158  return success_count;
159 }
160 
161 bool Disassembler::Disassemble(Debugger &debugger, const ArchSpec &arch,
162  const char *plugin_name, const char *flavor,
163  const ExecutionContext &exe_ctx,
164  ConstString name, Module *module,
165  uint32_t num_instructions,
166  bool mixed_source_and_assembly,
167  uint32_t num_mixed_context_lines,
168  uint32_t options, Stream &strm) {
169  SymbolContextList sc_list;
170  if (name) {
171  const bool include_symbols = true;
172  const bool include_inlines = true;
173  if (module) {
174  module->FindFunctions(name, nullptr, eFunctionNameTypeAuto,
175  include_symbols, include_inlines, true, sc_list);
176  } else if (exe_ctx.GetTargetPtr()) {
177  exe_ctx.GetTargetPtr()->GetImages().FindFunctions(
178  name, eFunctionNameTypeAuto, include_symbols, include_inlines, false,
179  sc_list);
180  }
181  }
182 
183  if (sc_list.GetSize()) {
184  return Disassemble(debugger, arch, plugin_name, flavor, exe_ctx, sc_list,
185  num_instructions, mixed_source_and_assembly,
186  num_mixed_context_lines, options, strm);
187  }
188  return false;
189 }
190 
191 lldb::DisassemblerSP Disassembler::DisassembleRange(
192  const ArchSpec &arch, const char *plugin_name, const char *flavor,
193  const ExecutionContext &exe_ctx, const AddressRange &range,
194  bool prefer_file_cache) {
195  lldb::DisassemblerSP disasm_sp;
196  if (range.GetByteSize() > 0 && range.GetBaseAddress().IsValid()) {
197  disasm_sp = Disassembler::FindPluginForTarget(exe_ctx.GetTargetSP(), arch,
198  flavor, plugin_name);
199 
200  if (disasm_sp) {
201  size_t bytes_disassembled = disasm_sp->ParseInstructions(
202  &exe_ctx, range, nullptr, prefer_file_cache);
203  if (bytes_disassembled == 0)
204  disasm_sp.reset();
205  }
206  }
207  return disasm_sp;
208 }
209 
210 lldb::DisassemblerSP
211 Disassembler::DisassembleBytes(const ArchSpec &arch, const char *plugin_name,
212  const char *flavor, const Address &start,
213  const void *src, size_t src_len,
214  uint32_t num_instructions, bool data_from_file) {
215  lldb::DisassemblerSP disasm_sp;
216 
217  if (src) {
218  disasm_sp = Disassembler::FindPlugin(arch, flavor, plugin_name);
219 
220  if (disasm_sp) {
221  DataExtractor data(src, src_len, arch.GetByteOrder(),
222  arch.GetAddressByteSize());
223 
224  (void)disasm_sp->DecodeInstructions(start, data, 0, num_instructions,
225  false, data_from_file);
226  }
227  }
228 
229  return disasm_sp;
230 }
231 
232 bool Disassembler::Disassemble(Debugger &debugger, const ArchSpec &arch,
233  const char *plugin_name, const char *flavor,
234  const ExecutionContext &exe_ctx,
235  const AddressRange &disasm_range,
236  uint32_t num_instructions,
237  bool mixed_source_and_assembly,
238  uint32_t num_mixed_context_lines,
239  uint32_t options, Stream &strm) {
240  if (disasm_range.GetByteSize()) {
241  lldb::DisassemblerSP disasm_sp(Disassembler::FindPluginForTarget(
242  exe_ctx.GetTargetSP(), arch, flavor, plugin_name));
243 
244  if (disasm_sp) {
245  AddressRange range;
246  ResolveAddress(exe_ctx, disasm_range.GetBaseAddress(),
247  range.GetBaseAddress());
248  range.SetByteSize(disasm_range.GetByteSize());
249  const bool prefer_file_cache = false;
250  size_t bytes_disassembled = disasm_sp->ParseInstructions(
251  &exe_ctx, range, &strm, prefer_file_cache);
252  if (bytes_disassembled == 0)
253  return false;
254 
255  return PrintInstructions(disasm_sp.get(), debugger, arch, exe_ctx,
256  num_instructions, mixed_source_and_assembly,
257  num_mixed_context_lines, options, strm);
258  }
259  }
260  return false;
261 }
262 
263 bool Disassembler::Disassemble(Debugger &debugger, const ArchSpec &arch,
264  const char *plugin_name, const char *flavor,
265  const ExecutionContext &exe_ctx,
266  const Address &start_address,
267  uint32_t num_instructions,
268  bool mixed_source_and_assembly,
269  uint32_t num_mixed_context_lines,
270  uint32_t options, Stream &strm) {
271  if (num_instructions > 0) {
272  lldb::DisassemblerSP disasm_sp(Disassembler::FindPluginForTarget(
273  exe_ctx.GetTargetSP(), arch, flavor, plugin_name));
274  if (disasm_sp) {
275  Address addr;
276  ResolveAddress(exe_ctx, start_address, addr);
277  const bool prefer_file_cache = false;
278  size_t bytes_disassembled = disasm_sp->ParseInstructions(
279  &exe_ctx, addr, num_instructions, prefer_file_cache);
280  if (bytes_disassembled == 0)
281  return false;
282  return PrintInstructions(disasm_sp.get(), debugger, arch, exe_ctx,
283  num_instructions, mixed_source_and_assembly,
284  num_mixed_context_lines, options, strm);
285  }
286  }
287  return false;
288 }
289 
291 Disassembler::GetFunctionDeclLineEntry(const SymbolContext &sc) {
292  SourceLine decl_line;
293  if (sc.function && sc.line_entry.IsValid()) {
294  LineEntry prologue_end_line = sc.line_entry;
295  FileSpec func_decl_file;
296  uint32_t func_decl_line;
297  sc.function->GetStartLineSourceInfo(func_decl_file, func_decl_line);
298  if (func_decl_file == prologue_end_line.file ||
299  func_decl_file == prologue_end_line.original_file) {
300  decl_line.file = func_decl_file;
301  decl_line.line = func_decl_line;
302  // TODO do we care about column on these entries? If so, we need to
303  // plumb that through GetStartLineSourceInfo.
304  decl_line.column = 0;
305  }
306  }
307  return decl_line;
308 }
309 
310 void Disassembler::AddLineToSourceLineTables(
311  SourceLine &line,
312  std::map<FileSpec, std::set<uint32_t>> &source_lines_seen) {
313  if (line.IsValid()) {
314  auto source_lines_seen_pos = source_lines_seen.find(line.file);
315  if (source_lines_seen_pos == source_lines_seen.end()) {
316  std::set<uint32_t> lines;
317  lines.insert(line.line);
318  source_lines_seen.emplace(line.file, lines);
319  } else {
320  source_lines_seen_pos->second.insert(line.line);
321  }
322  }
323 }
324 
325 bool Disassembler::ElideMixedSourceAndDisassemblyLine(
326  const ExecutionContext &exe_ctx, const SymbolContext &sc,
327  SourceLine &line) {
328 
329  // TODO: should we also check target.process.thread.step-avoid-libraries ?
330 
331  const RegularExpression *avoid_regex = nullptr;
332 
333  // Skip any line #0 entries - they are implementation details
334  if (line.line == 0)
335  return false;
336 
337  ThreadSP thread_sp = exe_ctx.GetThreadSP();
338  if (thread_sp) {
339  avoid_regex = thread_sp->GetSymbolsToAvoidRegexp();
340  } else {
341  TargetSP target_sp = exe_ctx.GetTargetSP();
342  if (target_sp) {
343  Status error;
344  OptionValueSP value_sp = target_sp->GetDebugger().GetPropertyValue(
345  &exe_ctx, "target.process.thread.step-avoid-regexp", false, error);
346  if (value_sp && value_sp->GetType() == OptionValue::eTypeRegex) {
347  OptionValueRegex *re = value_sp->GetAsRegex();
348  if (re) {
349  avoid_regex = re->GetCurrentValue();
350  }
351  }
352  }
353  }
354  if (avoid_regex && sc.symbol != nullptr) {
355  const char *function_name =
356  sc.GetFunctionName(Mangled::ePreferDemangledWithoutArguments)
357  .GetCString();
358  if (function_name) {
359  RegularExpression::Match regex_match(1);
360  if (avoid_regex->Execute(function_name, &regex_match)) {
361  // skip this source line
362  return true;
363  }
364  }
365  }
366  // don't skip this source line
367  return false;
368 }
369 
370 bool Disassembler::PrintInstructions(Disassembler *disasm_ptr,
371  Debugger &debugger, const ArchSpec &arch,
372  const ExecutionContext &exe_ctx,
373  uint32_t num_instructions,
374  bool mixed_source_and_assembly,
375  uint32_t num_mixed_context_lines,
376  uint32_t options, Stream &strm) {
377  // We got some things disassembled...
378  size_t num_instructions_found = disasm_ptr->GetInstructionList().GetSize();
379 
380  if (num_instructions > 0 && num_instructions < num_instructions_found)
381  num_instructions_found = num_instructions;
382 
383  const uint32_t max_opcode_byte_size =
385  SymbolContext sc;
386  SymbolContext prev_sc;
387  AddressRange current_source_line_range;
388  const Address *pc_addr_ptr = nullptr;
389  StackFrame *frame = exe_ctx.GetFramePtr();
390 
391  TargetSP target_sp(exe_ctx.GetTargetSP());
392  SourceManager &source_manager =
393  target_sp ? target_sp->GetSourceManager() : debugger.GetSourceManager();
394 
395  if (frame) {
396  pc_addr_ptr = &frame->GetFrameCodeAddress();
397  }
398  const uint32_t scope =
399  eSymbolContextLineEntry | eSymbolContextFunction | eSymbolContextSymbol;
400  const bool use_inline_block_range = false;
401 
402  const FormatEntity::Entry *disassembly_format = nullptr;
403  FormatEntity::Entry format;
404  if (exe_ctx.HasTargetScope()) {
405  disassembly_format =
407  } else {
408  FormatEntity::Parse("${addr}: ", format);
409  disassembly_format = &format;
410  }
411 
412  // First pass: step through the list of instructions, find how long the
413  // initial addresses strings are, insert padding in the second pass so the
414  // opcodes all line up nicely.
415 
416  // Also build up the source line mapping if this is mixed source & assembly
417  // mode. Calculate the source line for each assembly instruction (eliding
418  // inlined functions which the user wants to skip).
419 
420  std::map<FileSpec, std::set<uint32_t>> source_lines_seen;
421  Symbol *previous_symbol = nullptr;
422 
423  size_t address_text_size = 0;
424  for (size_t i = 0; i < num_instructions_found; ++i) {
425  Instruction *inst =
426  disasm_ptr->GetInstructionList().GetInstructionAtIndex(i).get();
427  if (inst) {
428  const Address &addr = inst->GetAddress();
429  ModuleSP module_sp(addr.GetModule());
430  if (module_sp) {
431  const SymbolContextItem resolve_mask = eSymbolContextFunction |
432  eSymbolContextSymbol |
433  eSymbolContextLineEntry;
434  uint32_t resolved_mask =
435  module_sp->ResolveSymbolContextForAddress(addr, resolve_mask, sc);
436  if (resolved_mask) {
437  StreamString strmstr;
438  Debugger::FormatDisassemblerAddress(disassembly_format, &sc, nullptr,
439  &exe_ctx, &addr, strmstr);
440  size_t cur_line = strmstr.GetSizeOfLastLine();
441  if (cur_line > address_text_size)
442  address_text_size = cur_line;
443 
444  // Add entries to our "source_lines_seen" map+set which list which
445  // sources lines occur in this disassembly session. We will print
446  // lines of context around a source line, but we don't want to print
447  // a source line that has a line table entry of its own - we'll leave
448  // that source line to be printed when it actually occurs in the
449  // disassembly.
450 
451  if (mixed_source_and_assembly && sc.line_entry.IsValid()) {
452  if (sc.symbol != previous_symbol) {
453  SourceLine decl_line = GetFunctionDeclLineEntry(sc);
454  if (!ElideMixedSourceAndDisassemblyLine(exe_ctx, sc, decl_line))
455  AddLineToSourceLineTables(decl_line, source_lines_seen);
456  }
457  if (sc.line_entry.IsValid()) {
458  SourceLine this_line;
459  this_line.file = sc.line_entry.file;
460  this_line.line = sc.line_entry.line;
461  this_line.column = sc.line_entry.column;
462  if (!ElideMixedSourceAndDisassemblyLine(exe_ctx, sc, this_line))
463  AddLineToSourceLineTables(this_line, source_lines_seen);
464  }
465  }
466  }
467  sc.Clear(false);
468  }
469  }
470  }
471 
472  previous_symbol = nullptr;
473  SourceLine previous_line;
474  for (size_t i = 0; i < num_instructions_found; ++i) {
475  Instruction *inst =
476  disasm_ptr->GetInstructionList().GetInstructionAtIndex(i).get();
477 
478  if (inst) {
479  const Address &addr = inst->GetAddress();
480  const bool inst_is_at_pc = pc_addr_ptr && addr == *pc_addr_ptr;
481  SourceLinesToDisplay source_lines_to_display;
482 
483  prev_sc = sc;
484 
485  ModuleSP module_sp(addr.GetModule());
486  if (module_sp) {
487  uint32_t resolved_mask = module_sp->ResolveSymbolContextForAddress(
488  addr, eSymbolContextEverything, sc);
489  if (resolved_mask) {
490  if (mixed_source_and_assembly) {
491 
492  // If we've started a new function (non-inlined), print all of the
493  // source lines from the function declaration until the first line
494  // table entry - typically the opening curly brace of the function.
495  if (previous_symbol != sc.symbol) {
496  // The default disassembly format puts an extra blank line
497  // between functions - so when we're displaying the source
498  // context for a function, we don't want to add a blank line
499  // after the source context or we'll end up with two of them.
500  if (previous_symbol != nullptr)
501  source_lines_to_display.print_source_context_end_eol = false;
502 
503  previous_symbol = sc.symbol;
504  if (sc.function && sc.line_entry.IsValid()) {
505  LineEntry prologue_end_line = sc.line_entry;
506  if (!ElideMixedSourceAndDisassemblyLine(exe_ctx, sc,
507  prologue_end_line)) {
508  FileSpec func_decl_file;
509  uint32_t func_decl_line;
510  sc.function->GetStartLineSourceInfo(func_decl_file,
511  func_decl_line);
512  if (func_decl_file == prologue_end_line.file ||
513  func_decl_file == prologue_end_line.original_file) {
514  // Add all the lines between the function declaration and
515  // the first non-prologue source line to the list of lines
516  // to print.
517  for (uint32_t lineno = func_decl_line;
518  lineno <= prologue_end_line.line; lineno++) {
519  SourceLine this_line;
520  this_line.file = func_decl_file;
521  this_line.line = lineno;
522  source_lines_to_display.lines.push_back(this_line);
523  }
524  // Mark the last line as the "current" one. Usually this
525  // is the open curly brace.
526  if (source_lines_to_display.lines.size() > 0)
527  source_lines_to_display.current_source_line =
528  source_lines_to_display.lines.size() - 1;
529  }
530  }
531  }
532  sc.GetAddressRange(scope, 0, use_inline_block_range,
533  current_source_line_range);
534  }
535 
536  // If we've left a previous source line's address range, print a
537  // new source line
538  if (!current_source_line_range.ContainsFileAddress(addr)) {
539  sc.GetAddressRange(scope, 0, use_inline_block_range,
540  current_source_line_range);
541 
542  if (sc != prev_sc && sc.comp_unit && sc.line_entry.IsValid()) {
543  SourceLine this_line;
544  this_line.file = sc.line_entry.file;
545  this_line.line = sc.line_entry.line;
546 
547  if (!ElideMixedSourceAndDisassemblyLine(exe_ctx, sc,
548  this_line)) {
549  // Only print this source line if it is different from the
550  // last source line we printed. There may have been inlined
551  // functions between these lines that we elided, resulting in
552  // the same line being printed twice in a row for a
553  // contiguous block of assembly instructions.
554  if (this_line != previous_line) {
555 
556  std::vector<uint32_t> previous_lines;
557  for (uint32_t i = 0;
558  i < num_mixed_context_lines &&
559  (this_line.line - num_mixed_context_lines) > 0;
560  i++) {
561  uint32_t line =
562  this_line.line - num_mixed_context_lines + i;
563  auto pos = source_lines_seen.find(this_line.file);
564  if (pos != source_lines_seen.end()) {
565  if (pos->second.count(line) == 1) {
566  previous_lines.clear();
567  } else {
568  previous_lines.push_back(line);
569  }
570  }
571  }
572  for (size_t i = 0; i < previous_lines.size(); i++) {
573  SourceLine previous_line;
574  previous_line.file = this_line.file;
575  previous_line.line = previous_lines[i];
576  auto pos = source_lines_seen.find(previous_line.file);
577  if (pos != source_lines_seen.end()) {
578  pos->second.insert(previous_line.line);
579  }
580  source_lines_to_display.lines.push_back(previous_line);
581  }
582 
583  source_lines_to_display.lines.push_back(this_line);
584  source_lines_to_display.current_source_line =
585  source_lines_to_display.lines.size() - 1;
586 
587  for (uint32_t i = 0; i < num_mixed_context_lines; i++) {
588  SourceLine next_line;
589  next_line.file = this_line.file;
590  next_line.line = this_line.line + i + 1;
591  auto pos = source_lines_seen.find(next_line.file);
592  if (pos != source_lines_seen.end()) {
593  if (pos->second.count(next_line.line) == 1)
594  break;
595  pos->second.insert(next_line.line);
596  }
597  source_lines_to_display.lines.push_back(next_line);
598  }
599  }
600  previous_line = this_line;
601  }
602  }
603  }
604  }
605  } else {
606  sc.Clear(true);
607  }
608  }
609 
610  if (source_lines_to_display.lines.size() > 0) {
611  strm.EOL();
612  for (size_t idx = 0; idx < source_lines_to_display.lines.size();
613  idx++) {
614  SourceLine ln = source_lines_to_display.lines[idx];
615  const char *line_highlight = "";
616  if (inst_is_at_pc && (options & eOptionMarkPCSourceLine)) {
617  line_highlight = "->";
618  } else if (idx == source_lines_to_display.current_source_line) {
619  line_highlight = "**";
620  }
621  source_manager.DisplaySourceLinesWithLineNumbers(
622  ln.file, ln.line, ln.column, 0, 0, line_highlight, &strm);
623  }
624  if (source_lines_to_display.print_source_context_end_eol)
625  strm.EOL();
626  }
627 
628  const bool show_bytes = (options & eOptionShowBytes) != 0;
629  inst->Dump(&strm, max_opcode_byte_size, true, show_bytes, &exe_ctx, &sc,
630  &prev_sc, nullptr, address_text_size);
631  strm.EOL();
632  } else {
633  break;
634  }
635  }
636 
637  return true;
638 }
639 
640 bool Disassembler::Disassemble(Debugger &debugger, const ArchSpec &arch,
641  const char *plugin_name, const char *flavor,
642  const ExecutionContext &exe_ctx,
643  uint32_t num_instructions,
644  bool mixed_source_and_assembly,
645  uint32_t num_mixed_context_lines,
646  uint32_t options, Stream &strm) {
647  AddressRange range;
648  StackFrame *frame = exe_ctx.GetFramePtr();
649  if (frame) {
650  SymbolContext sc(
651  frame->GetSymbolContext(eSymbolContextFunction | eSymbolContextSymbol));
652  if (sc.function) {
653  range = sc.function->GetAddressRange();
654  } else if (sc.symbol && sc.symbol->ValueIsAddress()) {
655  range.GetBaseAddress() = sc.symbol->GetAddressRef();
656  range.SetByteSize(sc.symbol->GetByteSize());
657  } else {
658  range.GetBaseAddress() = frame->GetFrameCodeAddress();
659  }
660 
661  if (range.GetBaseAddress().IsValid() && range.GetByteSize() == 0)
663  }
664 
665  return Disassemble(debugger, arch, plugin_name, flavor, exe_ctx, range,
666  num_instructions, mixed_source_and_assembly,
667  num_mixed_context_lines, options, strm);
668 }
669 
670 Instruction::Instruction(const Address &address, AddressClass addr_class)
671  : m_address(address), m_address_class(addr_class), m_opcode(),
672  m_calculated_strings(false) {}
673 
674 Instruction::~Instruction() = default;
675 
677  if (m_address_class == AddressClass::eInvalid)
678  m_address_class = m_address.GetAddressClass();
679  return m_address_class;
680 }
681 
682 void Instruction::Dump(lldb_private::Stream *s, uint32_t max_opcode_byte_size,
683  bool show_address, bool show_bytes,
684  const ExecutionContext *exe_ctx,
685  const SymbolContext *sym_ctx,
686  const SymbolContext *prev_sym_ctx,
687  const FormatEntity::Entry *disassembly_addr_format,
688  size_t max_address_text_size) {
689  size_t opcode_column_width = 7;
690  const size_t operand_column_width = 25;
691 
693 
694  StreamString ss;
695 
696  if (show_address) {
697  Debugger::FormatDisassemblerAddress(disassembly_addr_format, sym_ctx,
698  prev_sym_ctx, exe_ctx, &m_address, ss);
699  ss.FillLastLineToColumn(max_address_text_size, ' ');
700  }
701 
702  if (show_bytes) {
704  // x86_64 and i386 are the only ones that use bytes right now so pad out
705  // the byte dump to be able to always show 15 bytes (3 chars each) plus a
706  // space
707  if (max_opcode_byte_size > 0)
708  m_opcode.Dump(&ss, max_opcode_byte_size * 3 + 1);
709  else
710  m_opcode.Dump(&ss, 15 * 3 + 1);
711  } else {
712  // Else, we have ARM or MIPS which can show up to a uint32_t 0x00000000
713  // (10 spaces) plus two for padding...
714  if (max_opcode_byte_size > 0)
715  m_opcode.Dump(&ss, max_opcode_byte_size * 3 + 1);
716  else
717  m_opcode.Dump(&ss, 12);
718  }
719  }
720 
721  const size_t opcode_pos = ss.GetSizeOfLastLine();
722 
723  // The default opcode size of 7 characters is plenty for most architectures
724  // but some like arm can pull out the occasional vqrshrun.s16. We won't get
725  // consistent column spacing in these cases, unfortunately.
726  if (m_opcode_name.length() >= opcode_column_width) {
727  opcode_column_width = m_opcode_name.length() + 1;
728  }
729 
731  ss.FillLastLineToColumn(opcode_pos + opcode_column_width, ' ');
733 
734  if (!m_comment.empty()) {
736  opcode_pos + opcode_column_width + operand_column_width, ' ');
737  ss.PutCString(" ; ");
738  ss.PutCString(m_comment);
739  }
740  s->PutCString(ss.GetString());
741 }
742 
744  std::unique_ptr<EmulateInstruction> insn_emulator_up(
746  if (insn_emulator_up) {
747  insn_emulator_up->SetInstruction(GetOpcode(), GetAddress(), nullptr);
748  return insn_emulator_up->EvaluateInstruction(0);
749  }
750 
751  return false;
752 }
753 
755  return !HasDelaySlot();
756 }
757 
759  // Default is false.
760  return false;
761 }
762 
763 OptionValueSP Instruction::ReadArray(FILE *in_file, Stream *out_stream,
764  OptionValue::Type data_type) {
765  bool done = false;
766  char buffer[1024];
767 
768  auto option_value_sp = std::make_shared<OptionValueArray>(1u << data_type);
769 
770  int idx = 0;
771  while (!done) {
772  if (!fgets(buffer, 1023, in_file)) {
773  out_stream->Printf(
774  "Instruction::ReadArray: Error reading file (fgets).\n");
775  option_value_sp.reset();
776  return option_value_sp;
777  }
778 
779  std::string line(buffer);
780 
781  size_t len = line.size();
782  if (line[len - 1] == '\n') {
783  line[len - 1] = '\0';
784  line.resize(len - 1);
785  }
786 
787  if ((line.size() == 1) && line[0] == ']') {
788  done = true;
789  line.clear();
790  }
791 
792  if (!line.empty()) {
793  std::string value;
794  static RegularExpression g_reg_exp(
795  llvm::StringRef("^[ \t]*([^ \t]+)[ \t]*$"));
796  RegularExpression::Match regex_match(1);
797  bool reg_exp_success = g_reg_exp.Execute(line, &regex_match);
798  if (reg_exp_success)
799  regex_match.GetMatchAtIndex(line.c_str(), 1, value);
800  else
801  value = line;
802 
803  OptionValueSP data_value_sp;
804  switch (data_type) {
806  data_value_sp = std::make_shared<OptionValueUInt64>(0, 0);
807  data_value_sp->SetValueFromString(value);
808  break;
809  // Other types can be added later as needed.
810  default:
811  data_value_sp = std::make_shared<OptionValueString>(value.c_str(), "");
812  break;
813  }
814 
815  option_value_sp->GetAsArray()->InsertValue(idx, data_value_sp);
816  ++idx;
817  }
818  }
819 
820  return option_value_sp;
821 }
822 
823 OptionValueSP Instruction::ReadDictionary(FILE *in_file, Stream *out_stream) {
824  bool done = false;
825  char buffer[1024];
826 
827  auto option_value_sp = std::make_shared<OptionValueDictionary>();
828  static ConstString encoding_key("data_encoding");
830 
831  while (!done) {
832  // Read the next line in the file
833  if (!fgets(buffer, 1023, in_file)) {
834  out_stream->Printf(
835  "Instruction::ReadDictionary: Error reading file (fgets).\n");
836  option_value_sp.reset();
837  return option_value_sp;
838  }
839 
840  // Check to see if the line contains the end-of-dictionary marker ("}")
841  std::string line(buffer);
842 
843  size_t len = line.size();
844  if (line[len - 1] == '\n') {
845  line[len - 1] = '\0';
846  line.resize(len - 1);
847  }
848 
849  if ((line.size() == 1) && (line[0] == '}')) {
850  done = true;
851  line.clear();
852  }
853 
854  // Try to find a key-value pair in the current line and add it to the
855  // dictionary.
856  if (!line.empty()) {
857  static RegularExpression g_reg_exp(llvm::StringRef(
858  "^[ \t]*([a-zA-Z_][a-zA-Z0-9_]*)[ \t]*=[ \t]*(.*)[ \t]*$"));
859  RegularExpression::Match regex_match(2);
860 
861  bool reg_exp_success = g_reg_exp.Execute(line, &regex_match);
862  std::string key;
863  std::string value;
864  if (reg_exp_success) {
865  regex_match.GetMatchAtIndex(line.c_str(), 1, key);
866  regex_match.GetMatchAtIndex(line.c_str(), 2, value);
867  } else {
868  out_stream->Printf("Instruction::ReadDictionary: Failure executing "
869  "regular expression.\n");
870  option_value_sp.reset();
871  return option_value_sp;
872  }
873 
874  ConstString const_key(key.c_str());
875  // Check value to see if it's the start of an array or dictionary.
876 
877  lldb::OptionValueSP value_sp;
878  assert(value.empty() == false);
879  assert(key.empty() == false);
880 
881  if (value[0] == '{') {
882  assert(value.size() == 1);
883  // value is a dictionary
884  value_sp = ReadDictionary(in_file, out_stream);
885  if (!value_sp) {
886  option_value_sp.reset();
887  return option_value_sp;
888  }
889  } else if (value[0] == '[') {
890  assert(value.size() == 1);
891  // value is an array
892  value_sp = ReadArray(in_file, out_stream, data_type);
893  if (!value_sp) {
894  option_value_sp.reset();
895  return option_value_sp;
896  }
897  // We've used the data_type to read an array; re-set the type to
898  // Invalid
899  data_type = OptionValue::eTypeInvalid;
900  } else if ((value[0] == '0') && (value[1] == 'x')) {
901  value_sp = std::make_shared<OptionValueUInt64>(0, 0);
902  value_sp->SetValueFromString(value);
903  } else {
904  size_t len = value.size();
905  if ((value[0] == '"') && (value[len - 1] == '"'))
906  value = value.substr(1, len - 2);
907  value_sp = std::make_shared<OptionValueString>(value.c_str(), "");
908  }
909 
910  if (const_key == encoding_key) {
911  // A 'data_encoding=..." is NOT a normal key-value pair; it is meta-data
912  // indicating the
913  // data type of an upcoming array (usually the next bit of data to be
914  // read in).
915  if (strcmp(value.c_str(), "uint32_t") == 0)
916  data_type = OptionValue::eTypeUInt64;
917  } else
918  option_value_sp->GetAsDictionary()->SetValueForKey(const_key, value_sp,
919  false);
920  }
921  }
922 
923  return option_value_sp;
924 }
925 
926 bool Instruction::TestEmulation(Stream *out_stream, const char *file_name) {
927  if (!out_stream)
928  return false;
929 
930  if (!file_name) {
931  out_stream->Printf("Instruction::TestEmulation: Missing file_name.");
932  return false;
933  }
934  FILE *test_file = FileSystem::Instance().Fopen(file_name, "r");
935  if (!test_file) {
936  out_stream->Printf(
937  "Instruction::TestEmulation: Attempt to open test file failed.");
938  return false;
939  }
940 
941  char buffer[256];
942  if (!fgets(buffer, 255, test_file)) {
943  out_stream->Printf(
944  "Instruction::TestEmulation: Error reading first line of test file.\n");
945  fclose(test_file);
946  return false;
947  }
948 
949  if (strncmp(buffer, "InstructionEmulationState={", 27) != 0) {
950  out_stream->Printf("Instructin::TestEmulation: Test file does not contain "
951  "emulation state dictionary\n");
952  fclose(test_file);
953  return false;
954  }
955 
956  // Read all the test information from the test file into an
957  // OptionValueDictionary.
958 
959  OptionValueSP data_dictionary_sp(ReadDictionary(test_file, out_stream));
960  if (!data_dictionary_sp) {
961  out_stream->Printf(
962  "Instruction::TestEmulation: Error reading Dictionary Object.\n");
963  fclose(test_file);
964  return false;
965  }
966 
967  fclose(test_file);
968 
969  OptionValueDictionary *data_dictionary =
970  data_dictionary_sp->GetAsDictionary();
971  static ConstString description_key("assembly_string");
972  static ConstString triple_key("triple");
973 
974  OptionValueSP value_sp = data_dictionary->GetValueForKey(description_key);
975 
976  if (!value_sp) {
977  out_stream->Printf("Instruction::TestEmulation: Test file does not "
978  "contain description string.\n");
979  return false;
980  }
981 
982  SetDescription(value_sp->GetStringValue());
983 
984  value_sp = data_dictionary->GetValueForKey(triple_key);
985  if (!value_sp) {
986  out_stream->Printf(
987  "Instruction::TestEmulation: Test file does not contain triple.\n");
988  return false;
989  }
990 
991  ArchSpec arch;
992  arch.SetTriple(llvm::Triple(value_sp->GetStringValue()));
993 
994  bool success = false;
995  std::unique_ptr<EmulateInstruction> insn_emulator_up(
997  if (insn_emulator_up)
998  success =
999  insn_emulator_up->TestEmulation(out_stream, arch, data_dictionary);
1000 
1001  if (success)
1002  out_stream->Printf("Emulation test succeeded.");
1003  else
1004  out_stream->Printf("Emulation test failed.");
1005 
1006  return success;
1007 }
1008 
1010  const ArchSpec &arch, uint32_t evaluate_options, void *baton,
1011  EmulateInstruction::ReadMemoryCallback read_mem_callback,
1012  EmulateInstruction::WriteMemoryCallback write_mem_callback,
1013  EmulateInstruction::ReadRegisterCallback read_reg_callback,
1014  EmulateInstruction::WriteRegisterCallback write_reg_callback) {
1015  std::unique_ptr<EmulateInstruction> insn_emulator_up(
1017  if (insn_emulator_up) {
1018  insn_emulator_up->SetBaton(baton);
1019  insn_emulator_up->SetCallbacks(read_mem_callback, write_mem_callback,
1020  read_reg_callback, write_reg_callback);
1021  insn_emulator_up->SetInstruction(GetOpcode(), GetAddress(), nullptr);
1022  return insn_emulator_up->EvaluateInstruction(evaluate_options);
1023  }
1024 
1025  return false;
1026 }
1027 
1029  return m_opcode.GetData(data);
1030 }
1031 
1032 InstructionList::InstructionList() : m_instructions() {}
1033 
1035 
1036 size_t InstructionList::GetSize() const { return m_instructions.size(); }
1037 
1039  uint32_t max_inst_size = 0;
1040  collection::const_iterator pos, end;
1041  for (pos = m_instructions.begin(), end = m_instructions.end(); pos != end;
1042  ++pos) {
1043  uint32_t inst_size = (*pos)->GetOpcode().GetByteSize();
1044  if (max_inst_size < inst_size)
1045  max_inst_size = inst_size;
1046  }
1047  return max_inst_size;
1048 }
1049 
1050 InstructionSP InstructionList::GetInstructionAtIndex(size_t idx) const {
1051  InstructionSP inst_sp;
1052  if (idx < m_instructions.size())
1053  inst_sp = m_instructions[idx];
1054  return inst_sp;
1055 }
1056 
1057 void InstructionList::Dump(Stream *s, bool show_address, bool show_bytes,
1058  const ExecutionContext *exe_ctx) {
1059  const uint32_t max_opcode_byte_size = GetMaxOpcocdeByteSize();
1060  collection::const_iterator pos, begin, end;
1061 
1062  const FormatEntity::Entry *disassembly_format = nullptr;
1063  FormatEntity::Entry format;
1064  if (exe_ctx && exe_ctx->HasTargetScope()) {
1065  disassembly_format =
1067  } else {
1068  FormatEntity::Parse("${addr}: ", format);
1069  disassembly_format = &format;
1070  }
1071 
1072  for (begin = m_instructions.begin(), end = m_instructions.end(), pos = begin;
1073  pos != end; ++pos) {
1074  if (pos != begin)
1075  s->EOL();
1076  (*pos)->Dump(s, max_opcode_byte_size, show_address, show_bytes, exe_ctx,
1077  nullptr, nullptr, disassembly_format, 0);
1078  }
1079 }
1080 
1081 void InstructionList::Clear() { m_instructions.clear(); }
1082 
1083 void InstructionList::Append(lldb::InstructionSP &inst_sp) {
1084  if (inst_sp)
1085  m_instructions.push_back(inst_sp);
1086 }
1087 
1088 uint32_t
1090  Target &target) const {
1091  size_t num_instructions = m_instructions.size();
1092 
1093  uint32_t next_branch = UINT32_MAX;
1094  size_t i;
1095  for (i = start; i < num_instructions; i++) {
1096  if (m_instructions[i]->DoesBranch()) {
1097  next_branch = i;
1098  break;
1099  }
1100  }
1101 
1102  // Hexagon needs the first instruction of the packet with the branch. Go
1103  // backwards until we find an instruction marked end-of-packet, or until we
1104  // hit start.
1105  if (target.GetArchitecture().GetTriple().getArch() == llvm::Triple::hexagon) {
1106  // If we didn't find a branch, find the last packet start.
1107  if (next_branch == UINT32_MAX) {
1108  i = num_instructions - 1;
1109  }
1110 
1111  while (i > start) {
1112  --i;
1113 
1114  Status error;
1115  uint32_t inst_bytes;
1116  bool prefer_file_cache = false; // Read from process if process is running
1117  lldb::addr_t load_addr = LLDB_INVALID_ADDRESS;
1118  target.ReadMemory(m_instructions[i]->GetAddress(), prefer_file_cache,
1119  &inst_bytes, sizeof(inst_bytes), error, &load_addr);
1120  // If we have an error reading memory, return start
1121  if (!error.Success())
1122  return start;
1123  // check if this is the last instruction in a packet bits 15:14 will be
1124  // 11b or 00b for a duplex
1125  if (((inst_bytes & 0xC000) == 0xC000) ||
1126  ((inst_bytes & 0xC000) == 0x0000)) {
1127  // instruction after this should be the start of next packet
1128  next_branch = i + 1;
1129  break;
1130  }
1131  }
1132 
1133  if (next_branch == UINT32_MAX) {
1134  // We couldn't find the previous packet, so return start
1135  next_branch = start;
1136  }
1137  }
1138  return next_branch;
1139 }
1140 
1141 uint32_t
1143  size_t num_instructions = m_instructions.size();
1144  uint32_t index = UINT32_MAX;
1145  for (size_t i = 0; i < num_instructions; i++) {
1146  if (m_instructions[i]->GetAddress() == address) {
1147  index = i;
1148  break;
1149  }
1150  }
1151  return index;
1152 }
1153 
1154 uint32_t
1156  Target &target) {
1157  Address address;
1158  address.SetLoadAddress(load_addr, &target);
1159  return GetIndexOfInstructionAtAddress(address);
1160 }
1161 
1163  const AddressRange &range,
1164  Stream *error_strm_ptr,
1165  bool prefer_file_cache) {
1166  if (exe_ctx) {
1167  Target *target = exe_ctx->GetTargetPtr();
1168  const addr_t byte_size = range.GetByteSize();
1169  if (target == nullptr || byte_size == 0 ||
1170  !range.GetBaseAddress().IsValid())
1171  return 0;
1172 
1173  auto data_sp = std::make_shared<DataBufferHeap>(byte_size, '\0');
1174 
1175  Status error;
1176  lldb::addr_t load_addr = LLDB_INVALID_ADDRESS;
1177  const size_t bytes_read = target->ReadMemory(
1178  range.GetBaseAddress(), prefer_file_cache, data_sp->GetBytes(),
1179  data_sp->GetByteSize(), error, &load_addr);
1180 
1181  if (bytes_read > 0) {
1182  if (bytes_read != data_sp->GetByteSize())
1183  data_sp->SetByteSize(bytes_read);
1184  DataExtractor data(data_sp, m_arch.GetByteOrder(),
1185  m_arch.GetAddressByteSize());
1186  const bool data_from_file = load_addr == LLDB_INVALID_ADDRESS;
1187  return DecodeInstructions(range.GetBaseAddress(), data, 0, UINT32_MAX,
1188  false, data_from_file);
1189  } else if (error_strm_ptr) {
1190  const char *error_cstr = error.AsCString();
1191  if (error_cstr) {
1192  error_strm_ptr->Printf("error: %s\n", error_cstr);
1193  }
1194  }
1195  } else if (error_strm_ptr) {
1196  error_strm_ptr->PutCString("error: invalid execution context\n");
1197  }
1198  return 0;
1199 }
1200 
1202  const Address &start,
1203  uint32_t num_instructions,
1204  bool prefer_file_cache) {
1205  m_instruction_list.Clear();
1206 
1207  if (exe_ctx == nullptr || num_instructions == 0 || !start.IsValid())
1208  return 0;
1209 
1210  Target *target = exe_ctx->GetTargetPtr();
1211  // Calculate the max buffer size we will need in order to disassemble
1212  const addr_t byte_size = num_instructions * m_arch.GetMaximumOpcodeByteSize();
1213 
1214  if (target == nullptr || byte_size == 0)
1215  return 0;
1216 
1217  DataBufferHeap *heap_buffer = new DataBufferHeap(byte_size, '\0');
1218  DataBufferSP data_sp(heap_buffer);
1219 
1220  Status error;
1221  lldb::addr_t load_addr = LLDB_INVALID_ADDRESS;
1222  const size_t bytes_read =
1223  target->ReadMemory(start, prefer_file_cache, heap_buffer->GetBytes(),
1224  byte_size, error, &load_addr);
1225 
1226  const bool data_from_file = load_addr == LLDB_INVALID_ADDRESS;
1227 
1228  if (bytes_read == 0)
1229  return 0;
1230  DataExtractor data(data_sp, m_arch.GetByteOrder(),
1231  m_arch.GetAddressByteSize());
1232 
1233  const bool append_instructions = true;
1234  DecodeInstructions(start, data, 0, num_instructions, append_instructions,
1235  data_from_file);
1236 
1237  return m_instruction_list.GetSize();
1238 }
1239 
1240 // Disassembler copy constructor
1241 Disassembler::Disassembler(const ArchSpec &arch, const char *flavor)
1242  : m_arch(arch), m_instruction_list(), m_base_addr(LLDB_INVALID_ADDRESS),
1243  m_flavor() {
1244  if (flavor == nullptr)
1245  m_flavor.assign("default");
1246  else
1247  m_flavor.assign(flavor);
1248 
1249  // If this is an arm variant that can only include thumb (T16, T32)
1250  // instructions, force the arch triple to be "thumbv.." instead of "armv..."
1251  if (arch.IsAlwaysThumbInstructions()) {
1252  std::string thumb_arch_name(arch.GetTriple().getArchName().str());
1253  // Replace "arm" with "thumb" so we get all thumb variants correct
1254  if (thumb_arch_name.size() > 3) {
1255  thumb_arch_name.erase(0, 3);
1256  thumb_arch_name.insert(0, "thumb");
1257  }
1258  m_arch.SetTriple(thumb_arch_name.c_str());
1259  }
1260 }
1261 
1262 Disassembler::~Disassembler() = default;
1263 
1265  return m_instruction_list;
1266 }
1267 
1269  return m_instruction_list;
1270 }
1271 
1272 // Class PseudoInstruction
1273 
1275  : Instruction(Address(), AddressClass::eUnknown), m_description() {}
1276 
1278 
1280  // This is NOT a valid question for a pseudo instruction.
1281  return false;
1282 }
1283 
1285  // This is NOT a valid question for a pseudo instruction.
1286  return false;
1287 }
1288 
1290  const lldb_private::DataExtractor &data,
1291  lldb::offset_t data_offset) {
1292  return m_opcode.GetByteSize();
1293 }
1294 
1295 void PseudoInstruction::SetOpcode(size_t opcode_size, void *opcode_data) {
1296  if (!opcode_data)
1297  return;
1298 
1299  switch (opcode_size) {
1300  case 8: {
1301  uint8_t value8 = *((uint8_t *)opcode_data);
1303  break;
1304  }
1305  case 16: {
1306  uint16_t value16 = *((uint16_t *)opcode_data);
1308  break;
1309  }
1310  case 32: {
1311  uint32_t value32 = *((uint32_t *)opcode_data);
1313  break;
1314  }
1315  case 64: {
1316  uint64_t value64 = *((uint64_t *)opcode_data);
1318  break;
1319  }
1320  default:
1321  break;
1322  }
1323 }
1324 
1325 void PseudoInstruction::SetDescription(llvm::StringRef description) {
1326  m_description = description;
1327 }
1328 
1330  Operand ret;
1331  ret.m_type = Type::Register;
1332  ret.m_register = r;
1333  return ret;
1334 }
1335 
1337  bool neg) {
1338  Operand ret;
1339  ret.m_type = Type::Immediate;
1340  ret.m_immediate = imm;
1341  ret.m_negative = neg;
1342  return ret;
1343 }
1344 
1346  Operand ret;
1347  ret.m_type = Type::Immediate;
1348  if (imm < 0) {
1349  ret.m_immediate = -imm;
1350  ret.m_negative = true;
1351  } else {
1352  ret.m_immediate = imm;
1353  ret.m_negative = false;
1354  }
1355  return ret;
1356 }
1357 
1360  Operand ret;
1361  ret.m_type = Type::Dereference;
1362  ret.m_children = {ref};
1363  return ret;
1364 }
1365 
1367  const Operand &rhs) {
1368  Operand ret;
1369  ret.m_type = Type::Sum;
1370  ret.m_children = {lhs, rhs};
1371  return ret;
1372 }
1373 
1375  const Operand &rhs) {
1376  Operand ret;
1377  ret.m_type = Type::Product;
1378  ret.m_children = {lhs, rhs};
1379  return ret;
1380 }
1381 
1382 std::function<bool(const Instruction::Operand &)>
1384  std::function<bool(const Instruction::Operand &)> base,
1385  std::function<bool(const Instruction::Operand &)> left,
1386  std::function<bool(const Instruction::Operand &)> right) {
1387  return [base, left, right](const Instruction::Operand &op) -> bool {
1388  return (base(op) && op.m_children.size() == 2 &&
1389  ((left(op.m_children[0]) && right(op.m_children[1])) ||
1390  (left(op.m_children[1]) && right(op.m_children[0]))));
1391  };
1392 }
1393 
1394 std::function<bool(const Instruction::Operand &)>
1396  std::function<bool(const Instruction::Operand &)> base,
1397  std::function<bool(const Instruction::Operand &)> child) {
1398  return [base, child](const Instruction::Operand &op) -> bool {
1399  return (base(op) && op.m_children.size() == 1 && child(op.m_children[0]));
1400  };
1401 }
1402 
1403 std::function<bool(const Instruction::Operand &)>
1404 lldb_private::OperandMatchers::MatchRegOp(const RegisterInfo &info) {
1405  return [&info](const Instruction::Operand &op) {
1406  return (op.m_type == Instruction::Operand::Type::Register &&
1407  (op.m_register == ConstString(info.name) ||
1408  op.m_register == ConstString(info.alt_name)));
1409  };
1410 }
1411 
1412 std::function<bool(const Instruction::Operand &)>
1414  return [&reg](const Instruction::Operand &op) {
1415  if (op.m_type != Instruction::Operand::Type::Register) {
1416  return false;
1417  }
1418  reg = op.m_register;
1419  return true;
1420  };
1421 }
1422 
1423 std::function<bool(const Instruction::Operand &)>
1425  return [imm](const Instruction::Operand &op) {
1426  return (op.m_type == Instruction::Operand::Type::Immediate &&
1427  ((op.m_negative && op.m_immediate == (uint64_t)-imm) ||
1428  (!op.m_negative && op.m_immediate == (uint64_t)imm)));
1429  };
1430 }
1431 
1432 std::function<bool(const Instruction::Operand &)>
1434  return [&imm](const Instruction::Operand &op) {
1435  if (op.m_type != Instruction::Operand::Type::Immediate) {
1436  return false;
1437  }
1438  if (op.m_negative) {
1439  imm = -((int64_t)op.m_immediate);
1440  } else {
1441  imm = ((int64_t)op.m_immediate);
1442  }
1443  return true;
1444  };
1445 }
1446 
1447 std::function<bool(const Instruction::Operand &)>
1449  return [type](const Instruction::Operand &op) { return op.m_type == type; };
1450 }
A class to manage flag bits.
Definition: Debugger.h:82
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Definition: Stream.cpp:61
A line table entry class.
Definition: LineEntry.h:20
const lldb::ThreadSP & GetThreadSP() const
Get accessor to get the thread shared pointer.
bool IsSectionOffset() const
Check if an address is section offset.
Definition: Address.h:330
An data extractor class.
Definition: DataExtractor.h:47
bool HasTargetScope() const
Returns true the ExecutionContext object contains a valid target.
ConstString GetFunctionName(Mangled::NamePreference preference=Mangled::ePreferDemangled) const
Find a name of the innermost function for the symbol context.
Defines a list of symbol context objects.
Enumerations for broadcasting.
Definition: SBLaunchInfo.h:14
void SetOpcode16(uint16_t inst, lldb::ByteOrder order)
Definition: Opcode.h:164
lldb::addr_t GetByteSize() const
Get accessor for the byte size of this range.
Definition: AddressRange.h:232
const ArchSpec & GetArchitecture() const
Definition: Target.h:941
bool DumpEmulation(const ArchSpec &arch)
bool SetTriple(const llvm::Triple &triple)
Architecture triple setter.
Definition: ArchSpec.cpp:797
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
FileSpec original_file
The original source file, from debug info.
Definition: LineEntry.h:153
Defines a symbol context baton that can be handed other debug core functions.
Definition: SymbolContext.h:33
static Status Parse(const llvm::StringRef &format, Entry &entry)
uint32_t GetAddressByteSize() const
Returns the size in bytes of an address of the current architecture.
Definition: ArchSpec.cpp:742
const lldb::TargetSP & GetTargetSP() const
Get accessor to get the target shared pointer.
uint32_t GetIndexOfInstructionAtLoadAddress(lldb::addr_t load_addr, Target &target)
virtual void Dump(Stream *s, uint32_t max_opcode_byte_size, bool show_address, bool show_bytes, const ExecutionContext *exe_ctx, const SymbolContext *sym_ctx, const SymbolContext *prev_sym_ctx, const FormatEntity::Entry *disassembly_addr_format, size_t max_address_text_size)
Dump the text representation of this Instruction to a Stream.
bool IsValid() const
Check if a line entry object is valid.
Definition: LineEntry.cpp:47
size_t(* WriteMemoryCallback)(EmulateInstruction *instruction, void *baton, const Context &context, lldb::addr_t addr, const void *dst, size_t length)
bool ResolveFileAddress(lldb::addr_t vm_addr, Address &so_addr) const
Definition: ModuleList.cpp:649
lldb::OptionValueSP ReadDictionary(FILE *in_file, Stream *out_stream)
bool Emulate(const ArchSpec &arch, uint32_t evaluate_options, void *baton, EmulateInstruction::ReadMemoryCallback read_mem_callback, EmulateInstruction::WriteMemoryCallback write_mem_calback, EmulateInstruction::ReadRegisterCallback read_reg_callback, EmulateInstruction::WriteRegisterCallback write_reg_callback)
enum lldb_private::Instruction::Operand::Type m_type
bool ContainsFileAddress(const Address &so_addr) const
Check if a section offset address is contained in this range.
const RegularExpression * GetCurrentValue() const
A file utility class.
Definition: FileSpec.h:55
"lldb/Utility/RegularExpression.h" A C++ wrapper class for regex.
An architecture specification class.
Definition: ArchSpec.h:32
A timer class that simplifies common timing metrics.
Definition: Timer.h:23
CompileUnit * comp_unit
The CompileUnit for a given query.
uint32_t GetData(DataExtractor &data) const
Definition: Opcode.cpp:81
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
bool IsAlwaysThumbInstructions() const
Detect whether this architecture uses thumb code exclusively.
Definition: ArchSpec.cpp:1428
InstructionList m_instruction_list
Definition: Disassembler.h:536
bool SetLoadAddress(lldb::addr_t load_addr, Target *target, bool allow_section_end=false)
Set the address to represent load_addr.
Definition: Address.cpp:998
static FileSystem & Instance()
uint32_t GetData(DataExtractor &data)
uint32_t GetIndexOfNextBranchInstruction(uint32_t start, Target &target) const
StackFrame * GetFramePtr() const
Returns a pointer to the frame object.
Symbol * symbol
The Symbol for a given query.
A subclass of DataBuffer that stores a data buffer on the heap.
llvm::Triple & GetTriple()
Architecture triple accessor.
Definition: ArchSpec.h:431
std::vector< Operand > m_children
Definition: Disassembler.h:209
uint32_t GetSize() const
Get accessor for a symbol context list size.
void SetDescription(llvm::StringRef description) override
const SymbolContext & GetSymbolContext(lldb::SymbolContextItem resolve_scope)
Provide a SymbolContext for this StackFrame&#39;s current pc value.
Definition: StackFrame.cpp:267
Function * function
The Function for a given query.
lldb::addr_t GetOffset() const
Get the section relative offset value.
Definition: Address.h:317
const char * GetArchitectureName() const
Returns a static string representing the current architecture.
Definition: ArchSpec.cpp:591
#define UINT32_MAX
Definition: lldb-defines.h:31
std::function< bool(const Instruction::Operand &)> MatchUnaryOp(std::function< bool(const Instruction::Operand &)> base, std::function< bool(const Instruction::Operand &)> child)
Definition: Disassembler.h:266
AddressClass GetAddressClass() const
Definition: Address.cpp:983
Target * GetTargetPtr() const
Returns a pointer to the target object.
#define LLDB_INVALID_ADDRESS
Invalid value definitions.
Definition: lldb-defines.h:85
bool GetMatchAtIndex(llvm::StringRef s, uint32_t idx, std::string &match_str) const
lldb::OptionValueSP ReadArray(FILE *in_file, Stream *out_stream, OptionValue::Type data_type)
size_t(* ReadMemoryCallback)(EmulateInstruction *instruction, void *baton, const Context &context, lldb::addr_t addr, void *dst, size_t length)
const Opcode & GetOpcode() const
Definition: Disassembler.h:196
void SetOpcode8(uint8_t inst, lldb::ByteOrder order)
Definition: Opcode.h:158
Node * Parse(llvm::StringRef expr, llvm::BumpPtrAllocator &alloc)
Parse the given postfix expression.
void FillLastLineToColumn(uint32_t column, char fill_char)
uint64_t offset_t
Definition: lldb-types.h:87
std::function< bool(const Instruction::Operand &)> FetchRegOp(ConstString &reg)
Definition: Disassembler.h:272
virtual void SetDescription(llvm::StringRef)
Definition: Disassembler.h:178
void Clear(bool clear_target)
Clear the object&#39;s state.
uint16_t column
The column number of the source line, or zero if there is no column information.
Definition: LineEntry.h:156
size_t EOL()
Output and End of Line character to the stream.
Definition: Stream.cpp:127
std::function< bool(const Instruction::Operand &)> MatchBinaryOp(std::function< bool(const Instruction::Operand &)> base, std::function< bool(const Instruction::Operand &)> left, std::function< bool(const Instruction::Operand &)> right)
Definition: Disassembler.h:261
SectionLoadList & GetSectionLoadList()
Definition: Target.h:1012
A class that describes an executable image and its associated object and symbol files.
Definition: Module.h:109
OptionValueDictionary * GetAsDictionary()
std::function< bool(const Instruction::Operand &)> MatchOpType(Instruction::Operand::Type type)
Definition: Disassembler.h:279
static Operand BuildImmediate(lldb::addr_t imm, bool neg)
FILE * Fopen(const char *path, const char *mode)
Wraps ::fopen in a platform-independent way.
void GetStartLineSourceInfo(FileSpec &source_file, uint32_t &line_no)
Find the file and line number of the source location of the start of the function.
Definition: Function.cpp:194
static EmulateInstruction * FindPlugin(const ArchSpec &arch, InstructionType supported_inst_type, const char *plugin_name)
uint32_t GetIndexOfInstructionAtAddress(const Address &addr)
llvm::StringRef GetString() const
bool ResolveLoadAddress(lldb::addr_t load_addr, Address &so_addr, bool allow_section_end=false) const
FileSpec file
The source file, possibly mapped by the target.source-map setting.
Definition: LineEntry.h:151
void SetOpcode64(uint64_t inst, lldb::ByteOrder order)
Definition: Opcode.h:182
uint32_t line
The source line number, or zero if there is no line number information.
Definition: LineEntry.h:154
lldb::ByteOrder GetByteOrder() const
Returns the byte order for the architecture specification.
Definition: ArchSpec.cpp:788
int Dump(Stream *s, uint32_t min_byte_width)
Definition: Opcode.cpp:24
const FormatEntity::Entry * GetDisassemblyFormat() const
Definition: Debugger.cpp:377
static Operand BuildDereference(const Operand &ref)
void CalculateMnemonicOperandsAndCommentIfNeeded(const ExecutionContext *exe_ctx)
Definition: Disassembler.h:251
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:106
static Operand BuildProduct(const Operand &lhs, const Operand &rhs)
bool Success() const
Test for success condition.
Definition: Status.cpp:287
virtual bool TestEmulation(Stream *stream, const char *test_file_name)
size_t GetSizeOfLastLine() const
std::function< bool(const Instruction::Operand &)> FetchImmOp(int64_t &imm)
Definition: Disassembler.h:276
void SetOpcode32(uint32_t inst, lldb::ByteOrder order)
Definition: Opcode.h:176
bool IsValid() const
Check if the object state is valid.
Definition: Address.h:343
A section + offset based address class.
Definition: Address.h:80
void Append(lldb::InstructionSP &inst_sp)
InstructionList & GetInstructionList()
uint32_t GetByteSize() const
Definition: Opcode.h:207
SourceManager & GetSourceManager()
Definition: Debugger.cpp:1302
bool GetContextAtIndex(size_t idx, SymbolContext &sc) const
Get accessor for a symbol context at index idx.
const ModuleList & GetImages() const
Get accessor for the images for this process.
Definition: Target.h:899
#define DEFAULT_DISASM_BYTE_SIZE
uint32_t GetMaxOpcocdeByteSize() const
size_t ReadMemory(const Address &addr, bool prefer_file_cache, void *dst, size_t dst_len, Status &error, lldb::addr_t *load_addr_ptr=nullptr)
Definition: Target.cpp:1761
std::function< bool(const Instruction::Operand &)> MatchRegOp(const RegisterInfo &info)
Definition: Disassembler.h:270
lldb::InstructionSP GetInstructionAtIndex(size_t idx) const
std::function< bool(const Instruction::Operand &)> MatchImmOp(int64_t imm)
Definition: Disassembler.h:274
bool(* WriteRegisterCallback)(EmulateInstruction *instruction, void *baton, const Context &context, const RegisterInfo *reg_info, const RegisterValue &reg_value)
AddressClass GetAddressClass()
uint64_t addr_t
Definition: lldb-types.h:83
static Operand BuildSum(const Operand &lhs, const Operand &rhs)
size_t Decode(const Disassembler &disassembler, const DataExtractor &data, lldb::offset_t data_offset) override
static Operand BuildRegister(ConstString &r)
A uniqued constant string class.
Definition: ConstString.h:38
lldb::ModuleSP GetModule() const
Get accessor for the module for this address.
Definition: Address.cpp:264
const char * GetCString() const
Get the string value as a C string.
Definition: ConstString.h:247
bool Execute(llvm::StringRef string, Match *match=nullptr) const
Executes a regular expression.
Target & GetTargetRef() const
Returns a reference to the target object.
LineEntry line_entry
The LineEntry for a given query.
Definition: SBAddress.h:15
size_t ParseInstructions(const ExecutionContext *exe_ctx, const AddressRange &range, Stream *error_strm_ptr, bool prefer_file_cache)
size_t FindFunctions(ConstString name, const CompilerDeclContext *parent_decl_ctx, lldb::FunctionNameType name_type_mask, bool symbols_ok, bool inlines_ok, bool append, SymbolContextList &sc_list)
Find functions by name.
bool GetAddressRange(uint32_t scope, uint32_t range_idx, bool use_inline_block_range, AddressRange &range) const
Get the address range contained within a symbol context.
uint8_t * GetBytes() override
static void ResolveAddress(const ExecutionContext &exe_ctx, const Address &addr, Address &resolved_addr)
Address & GetBaseAddress()
Get accessor for the base address of the range.
Definition: AddressRange.h:220
size_t FindFunctions(ConstString name, lldb::FunctionNameType name_type_mask, bool include_symbols, bool include_inlines, bool append, SymbolContextList &sc_list) const
OptionValueRegex * GetAsRegex()
Opcode::Type GetType() const
Definition: Opcode.h:78
A section + offset based address range class.
Definition: AddressRange.h:32
void SetOpcode(size_t opcode_size, void *opcode_data)
const Address & GetAddress() const
Definition: Disassembler.h:84
bool(* ReadRegisterCallback)(EmulateInstruction *instruction, void *baton, const RegisterInfo *reg_info, RegisterValue &reg_value)
void Dump(Stream *s, bool show_address, bool show_bytes, const ExecutionContext *exe_ctx)
This base class provides an interface to stack frames.
Definition: StackFrame.h:40
Debugger & GetDebugger()
Definition: Target.h:974
const Address & GetFrameCodeAddress()
Get an Address for the current pc value in this StackFrame.
Definition: StackFrame.cpp:181
lldb::OptionValueSP GetValueForKey(ConstString key) const
static bool FormatDisassemblerAddress(const FormatEntity::Entry *format, const SymbolContext *sc, const SymbolContext *prev_sc, const ExecutionContext *exe_ctx, const Address *addr, Stream &s)
Definition: Debugger.cpp:1193
An error handling class.
Definition: Status.h:44
Disassembler(const ArchSpec &arch, const char *flavor)
void SetByteSize(lldb::addr_t byte_size)
Set accessor for the byte size of this range.
Definition: AddressRange.h:248