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