contrib/llvm/tools/lldb/source/Core/Disassembler.cpp

   1 //===-- Disassembler.cpp ----------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/Core/Disassembler.h"
  11
  12 #include "lldb/Core/AddressRange.h" // for AddressRange
  13 #include "lldb/Core/Debugger.h"
  14 #include "lldb/Core/EmulateInstruction.h"
  15 #include "lldb/Core/Mangled.h" // for Mangled, Mangled...
  16 #include "lldb/Core/Module.h"
  17 #include "lldb/Core/ModuleList.h" // for ModuleList
  18 #include "lldb/Core/PluginManager.h"
  19 #include "lldb/Core/SourceManager.h" // for SourceManager
  20 #include "lldb/Core/Timer.h"
  21 #include "lldb/Host/FileSystem.h"
  22 #include "lldb/Interpreter/OptionValue.h"
  23 #include "lldb/Interpreter/OptionValueArray.h"
  24 #include "lldb/Interpreter/OptionValueDictionary.h"
  25 #include "lldb/Interpreter/OptionValueRegex.h"
  26 #include "lldb/Interpreter/OptionValueString.h"
  27 #include "lldb/Interpreter/OptionValueUInt64.h"
  28 #include "lldb/Symbol/Function.h"
  29 #include "lldb/Symbol/Symbol.h"        // for Symbol
  30 #include "lldb/Symbol/SymbolContext.h" // for SymbolContext
  31 #include "lldb/Target/ExecutionContext.h"
  32 #include "lldb/Target/SectionLoadList.h"
  33 #include "lldb/Target/StackFrame.h"
  34 #include "lldb/Target/Target.h"
  35 #include "lldb/Target/Thread.h" // for Thread
  36 #include "lldb/Utility/DataBufferHeap.h"
  37 #include "lldb/Utility/DataExtractor.h"
  38 #include "lldb/Utility/Error.h"
  39 #include "lldb/Utility/RegularExpression.h"
  40 #include "lldb/Utility/Stream.h"            // for Stream
  41 #include "lldb/Utility/StreamString.h"      // for StreamString
  42 #include "lldb/lldb-private-enumerations.h" // for InstructionType:...
  43 #include "lldb/lldb-private-interfaces.h"   // for DisassemblerCrea...
  44 #include "lldb/lldb-private-types.h"        // for RegisterInfo
  45 #include "llvm/ADT/Triple.h"                // for Triple, Triple::...
  46 #include "llvm/Support/Compiler.h"          // for LLVM_PRETTY_FUNC...
  47
  48 #include <cstdint> // for uint32_t, UINT32...
  49 #include <cstring>
  50 #include <utility> // for pair
  51
  52 #include <assert.h> // for assert
  53
  54 #define DEFAULT_DISASM_BYTE_SIZE 32
  55
  56 using namespace lldb;
  57 using namespace lldb_private;
  58
  59 DisassemblerSP Disassembler::FindPlugin(const ArchSpec &arch,
  60                                         const char *flavor,
  61                                         const char *plugin_name) {
  62   Timer scoped_timer(LLVM_PRETTY_FUNCTION,
  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
  99     // we only support flavors on x86 & 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,
 111     // try and resolve it to something
 112     Target *target = exe_ctx.GetTargetPtr();
 113     if (target) {
 114       if (target->GetSectionLoadList().IsEmpty()) {
 115         target->GetImages().ResolveFileAddress(addr.GetOffset(), resolved_addr);
 116       } else {
 117         target->GetSectionLoadList().ResolveLoadAddress(addr.GetOffset(),
 118                                                         resolved_addr);
 119       }
 120       // We weren't able to resolve the address, just treat it as a
 121       // raw address
 122       if (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                                const 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
 290 Disassembler::SourceLine
 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       Error 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 =
 384       disasm_ptr->GetInstructionList().GetMaxOpcocdeByteSize();
 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 =
 406         exe_ctx.GetTargetRef().GetDebugger().GetDisassemblyFormat();
 407   } else {
 408     FormatEntity::Parse("${addr}: ", format);
 409     disassembly_format = &format;
 410   }
 411
 412   // First pass: step through the list of instructions,
 413   // find how long the initial addresses strings are, insert padding
 414   // in the second pass so the opcodes all line up nicely.
 415
 416   // Also build up the source line mapping if this is mixed source & assembly
 417   // mode.
 418   // Calculate the source line for each assembly instruction (eliding inlined
 419   // functions
 420   // which the user wants to skip).
 421
 422   std::map<FileSpec, std::set<uint32_t>> source_lines_seen;
 423   Symbol *previous_symbol = nullptr;
 424
 425   size_t address_text_size = 0;
 426   for (size_t i = 0; i < num_instructions_found; ++i) {
 427     Instruction *inst =
 428         disasm_ptr->GetInstructionList().GetInstructionAtIndex(i).get();
 429     if (inst) {
 430       const Address &addr = inst->GetAddress();
 431       ModuleSP module_sp(addr.GetModule());
 432       if (module_sp) {
 433         const uint32_t resolve_mask = eSymbolContextFunction |
 434                                       eSymbolContextSymbol |
 435                                       eSymbolContextLineEntry;
 436         uint32_t resolved_mask =
 437             module_sp->ResolveSymbolContextForAddress(addr, resolve_mask, sc);
 438         if (resolved_mask) {
 439           StreamString strmstr;
 440           Debugger::FormatDisassemblerAddress(disassembly_format, &sc, nullptr,
 441                                               &exe_ctx, &addr, strmstr);
 442           size_t cur_line = strmstr.GetSizeOfLastLine();
 443           if (cur_line > address_text_size)
 444             address_text_size = cur_line;
 445
 446           // Add entries to our "source_lines_seen" map+set which list which
 447           // sources lines occur in this disassembly session.  We will print
 448           // lines of context around a source line, but we don't want to print
 449           // a source line that has a line table entry of its own - we'll leave
 450           // that source line to be printed when it actually occurs in the
 451           // disassembly.
 452
 453           if (mixed_source_and_assembly && sc.line_entry.IsValid()) {
 454             if (sc.symbol != previous_symbol) {
 455               SourceLine decl_line = GetFunctionDeclLineEntry(sc);
 456               if (ElideMixedSourceAndDisassemblyLine(exe_ctx, sc, decl_line) ==
 457                   false)
 458                 AddLineToSourceLineTables(decl_line, source_lines_seen);
 459             }
 460             if (sc.line_entry.IsValid()) {
 461               SourceLine this_line;
 462               this_line.file = sc.line_entry.file;
 463               this_line.line = sc.line_entry.line;
 464               this_line.column = sc.line_entry.column;
 465               if (ElideMixedSourceAndDisassemblyLine(exe_ctx, sc, this_line) ==
 466                   false)
 467                 AddLineToSourceLineTables(this_line, source_lines_seen);
 468             }
 469           }
 470         }
 471         sc.Clear(false);
 472       }
 473     }
 474   }
 475
 476   previous_symbol = nullptr;
 477   SourceLine previous_line;
 478   for (size_t i = 0; i < num_instructions_found; ++i) {
 479     Instruction *inst =
 480         disasm_ptr->GetInstructionList().GetInstructionAtIndex(i).get();
 481
 482     if (inst) {
 483       const Address &addr = inst->GetAddress();
 484       const bool inst_is_at_pc = pc_addr_ptr && addr == *pc_addr_ptr;
 485       SourceLinesToDisplay source_lines_to_display;
 486
 487       prev_sc = sc;
 488
 489       ModuleSP module_sp(addr.GetModule());
 490       if (module_sp) {
 491         uint32_t resolved_mask = module_sp->ResolveSymbolContextForAddress(
 492             addr, eSymbolContextEverything, sc);
 493         if (resolved_mask) {
 494           if (mixed_source_and_assembly) {
 495
 496             // If we've started a new function (non-inlined), print all of the
 497             // source lines from the
 498             // function declaration until the first line table entry - typically
 499             // the opening curly brace of
 500             // the function.
 501             if (previous_symbol != sc.symbol) {
 502               // The default disassembly format puts an extra blank line between
 503               // functions - so
 504               // when we're displaying the source context for a function, we
 505               // don't want to add
 506               // a blank line after the source context or we'll end up with two
 507               // of them.
 508               if (previous_symbol != nullptr)
 509                 source_lines_to_display.print_source_context_end_eol = false;
 510
 511               previous_symbol = sc.symbol;
 512               if (sc.function && sc.line_entry.IsValid()) {
 513                 LineEntry prologue_end_line = sc.line_entry;
 514                 if (ElideMixedSourceAndDisassemblyLine(
 515                         exe_ctx, sc, prologue_end_line) == false) {
 516                   FileSpec func_decl_file;
 517                   uint32_t func_decl_line;
 518                   sc.function->GetStartLineSourceInfo(func_decl_file,
 519                                                       func_decl_line);
 520                   if (func_decl_file == prologue_end_line.file ||
 521                       func_decl_file == prologue_end_line.original_file) {
 522                     // Add all the lines between the function declaration
 523                     // and the first non-prologue source line to the list
 524                     // of lines to print.
 525                     for (uint32_t lineno = func_decl_line;
 526                          lineno <= prologue_end_line.line; lineno++) {
 527                       SourceLine this_line;
 528                       this_line.file = func_decl_file;
 529                       this_line.line = lineno;
 530                       source_lines_to_display.lines.push_back(this_line);
 531                     }
 532                     // Mark the last line as the "current" one.  Usually
 533                     // this is the open curly brace.
 534                     if (source_lines_to_display.lines.size() > 0)
 535                       source_lines_to_display.current_source_line =
 536                           source_lines_to_display.lines.size() - 1;
 537                   }
 538                 }
 539               }
 540               sc.GetAddressRange(scope, 0, use_inline_block_range,
 541                                  current_source_line_range);
 542             }
 543
 544             // If we've left a previous source line's address range, print a new
 545             // source line
 546             if (!current_source_line_range.ContainsFileAddress(addr)) {
 547               sc.GetAddressRange(scope, 0, use_inline_block_range,
 548                                  current_source_line_range);
 549
 550               if (sc != prev_sc && sc.comp_unit && sc.line_entry.IsValid()) {
 551                 SourceLine this_line;
 552                 this_line.file = sc.line_entry.file;
 553                 this_line.line = sc.line_entry.line;
 554
 555                 if (ElideMixedSourceAndDisassemblyLine(exe_ctx, sc,
 556                                                        this_line) == false) {
 557                   // Only print this source line if it is different from the
 558                   // last source line we printed.  There may have been inlined
 559                   // functions between these lines that we elided, resulting in
 560                   // the same line being printed twice in a row for a contiguous
 561                   // block of assembly instructions.
 562                   if (this_line != previous_line) {
 563
 564                     std::vector<uint32_t> previous_lines;
 565                     for (uint32_t i = 0;
 566                          i < num_mixed_context_lines &&
 567                          (this_line.line - num_mixed_context_lines) > 0;
 568                          i++) {
 569                       uint32_t line =
 570                           this_line.line - num_mixed_context_lines + i;
 571                       auto pos = source_lines_seen.find(this_line.file);
 572                       if (pos != source_lines_seen.end()) {
 573                         if (pos->second.count(line) == 1) {
 574                           previous_lines.clear();
 575                         } else {
 576                           previous_lines.push_back(line);
 577                         }
 578                       }
 579                     }
 580                     for (size_t i = 0; i < previous_lines.size(); i++) {
 581                       SourceLine previous_line;
 582                       previous_line.file = this_line.file;
 583                       previous_line.line = previous_lines[i];
 584                       auto pos = source_lines_seen.find(previous_line.file);
 585                       if (pos != source_lines_seen.end()) {
 586                         pos->second.insert(previous_line.line);
 587                       }
 588                       source_lines_to_display.lines.push_back(previous_line);
 589                     }
 590
 591                     source_lines_to_display.lines.push_back(this_line);
 592                     source_lines_to_display.current_source_line =
 593                         source_lines_to_display.lines.size() - 1;
 594
 595                     for (uint32_t i = 0; i < num_mixed_context_lines; i++) {
 596                       SourceLine next_line;
 597                       next_line.file = this_line.file;
 598                       next_line.line = this_line.line + i + 1;
 599                       auto pos = source_lines_seen.find(next_line.file);
 600                       if (pos != source_lines_seen.end()) {
 601                         if (pos->second.count(next_line.line) == 1)
 602                           break;
 603                         pos->second.insert(next_line.line);
 604                       }
 605                       source_lines_to_display.lines.push_back(next_line);
 606                     }
 607                   }
 608                   previous_line = this_line;
 609                 }
 610               }
 611             }
 612           }
 613         } else {
 614           sc.Clear(true);
 615         }
 616       }
 617
 618       if (source_lines_to_display.lines.size() > 0) {
 619         strm.EOL();
 620         for (size_t idx = 0; idx < source_lines_to_display.lines.size();
 621              idx++) {
 622           SourceLine ln = source_lines_to_display.lines[idx];
 623           const char *line_highlight = "";
 624           if (inst_is_at_pc && (options & eOptionMarkPCSourceLine)) {
 625             line_highlight = "->";
 626           } else if (idx == source_lines_to_display.current_source_line) {
 627             line_highlight = "**";
 628           }
 629           source_manager.DisplaySourceLinesWithLineNumbers(
 630               ln.file, ln.line, ln.column, 0, 0, line_highlight, &strm);
 631         }
 632         if (source_lines_to_display.print_source_context_end_eol)
 633           strm.EOL();
 634       }
 635
 636       const bool show_bytes = (options & eOptionShowBytes) != 0;
 637       inst->Dump(&strm, max_opcode_byte_size, true, show_bytes, &exe_ctx, &sc,
 638                  &prev_sc, nullptr, address_text_size);
 639       strm.EOL();
 640     } else {
 641       break;
 642     }
 643   }
 644
 645   return true;
 646 }
 647
 648 bool Disassembler::Disassemble(Debugger &debugger, const ArchSpec &arch,
 649                                const char *plugin_name, const char *flavor,
 650                                const ExecutionContext &exe_ctx,
 651                                uint32_t num_instructions,
 652                                bool mixed_source_and_assembly,
 653                                uint32_t num_mixed_context_lines,
 654                                uint32_t options, Stream &strm) {
 655   AddressRange range;
 656   StackFrame *frame = exe_ctx.GetFramePtr();
 657   if (frame) {
 658     SymbolContext sc(
 659         frame->GetSymbolContext(eSymbolContextFunction | eSymbolContextSymbol));
 660     if (sc.function) {
 661       range = sc.function->GetAddressRange();
 662     } else if (sc.symbol && sc.symbol->ValueIsAddress()) {
 663       range.GetBaseAddress() = sc.symbol->GetAddressRef();
 664       range.SetByteSize(sc.symbol->GetByteSize());
 665     } else {
 666       range.GetBaseAddress() = frame->GetFrameCodeAddress();
 667     }
 668
 669     if (range.GetBaseAddress().IsValid() && range.GetByteSize() == 0)
 670       range.SetByteSize(DEFAULT_DISASM_BYTE_SIZE);
 671   }
 672
 673   return Disassemble(debugger, arch, plugin_name, flavor, exe_ctx, range,
 674                      num_instructions, mixed_source_and_assembly,
 675                      num_mixed_context_lines, options, strm);
 676 }
 677
 678 Instruction::Instruction(const Address &address, AddressClass addr_class)
 679     : m_address(address), m_address_class(addr_class), m_opcode(),
 680       m_calculated_strings(false) {}
 681
 682 Instruction::~Instruction() = default;
 683
 684 AddressClass Instruction::GetAddressClass() {
 685   if (m_address_class == eAddressClassInvalid)
 686     m_address_class = m_address.GetAddressClass();
 687   return m_address_class;
 688 }
 689
 690 void Instruction::Dump(lldb_private::Stream *s, uint32_t max_opcode_byte_size,
 691                        bool show_address, bool show_bytes,
 692                        const ExecutionContext *exe_ctx,
 693                        const SymbolContext *sym_ctx,
 694                        const SymbolContext *prev_sym_ctx,
 695                        const FormatEntity::Entry *disassembly_addr_format,
 696                        size_t max_address_text_size) {
 697   size_t opcode_column_width = 7;
 698   const size_t operand_column_width = 25;
 699
 700   CalculateMnemonicOperandsAndCommentIfNeeded(exe_ctx);
 701
 702   StreamString ss;
 703
 704   if (show_address) {
 705     Debugger::FormatDisassemblerAddress(disassembly_addr_format, sym_ctx,
 706                                         prev_sym_ctx, exe_ctx, &m_address, ss);
 707     ss.FillLastLineToColumn(max_address_text_size, ' ');
 708   }
 709
 710   if (show_bytes) {
 711     if (m_opcode.GetType() == Opcode::eTypeBytes) {
 712       // x86_64 and i386 are the only ones that use bytes right now so
 713       // pad out the byte dump to be able to always show 15 bytes (3 chars each)
 714       // plus a space
 715       if (max_opcode_byte_size > 0)
 716         m_opcode.Dump(&ss, max_opcode_byte_size * 3 + 1);
 717       else
 718         m_opcode.Dump(&ss, 15 * 3 + 1);
 719     } else {
 720       // Else, we have ARM or MIPS which can show up to a uint32_t
 721       // 0x00000000 (10 spaces) plus two for padding...
 722       if (max_opcode_byte_size > 0)
 723         m_opcode.Dump(&ss, max_opcode_byte_size * 3 + 1);
 724       else
 725         m_opcode.Dump(&ss, 12);
 726     }
 727   }
 728
 729   const size_t opcode_pos = ss.GetSizeOfLastLine();
 730
 731   // The default opcode size of 7 characters is plenty for most architectures
 732   // but some like arm can pull out the occasional vqrshrun.s16.  We won't get
 733   // consistent column spacing in these cases, unfortunately.
 734   if (m_opcode_name.length() >= opcode_column_width) {
 735     opcode_column_width = m_opcode_name.length() + 1;
 736   }
 737
 738   ss.PutCString(m_opcode_name);
 739   ss.FillLastLineToColumn(opcode_pos + opcode_column_width, ' ');
 740   ss.PutCString(m_mnemonics);
 741
 742   if (!m_comment.empty()) {
 743     ss.FillLastLineToColumn(
 744         opcode_pos + opcode_column_width + operand_column_width, ' ');
 745     ss.PutCString(" ; ");
 746     ss.PutCString(m_comment);
 747   }
 748   s->PutCString(ss.GetString());
 749 }
 750
 751 bool Instruction::DumpEmulation(const ArchSpec &arch) {
 752   std::unique_ptr<EmulateInstruction> insn_emulator_ap(
 753       EmulateInstruction::FindPlugin(arch, eInstructionTypeAny, nullptr));
 754   if (insn_emulator_ap) {
 755     insn_emulator_ap->SetInstruction(GetOpcode(), GetAddress(), nullptr);
 756     return insn_emulator_ap->EvaluateInstruction(0);
 757   }
 758
 759   return false;
 760 }
 761
 762 bool Instruction::HasDelaySlot() {
 763   // Default is false.
 764   return false;
 765 }
 766
 767 OptionValueSP Instruction::ReadArray(FILE *in_file, Stream *out_stream,
 768                                      OptionValue::Type data_type) {
 769   bool done = false;
 770   char buffer[1024];
 771
 772   auto option_value_sp = std::make_shared<OptionValueArray>(1u << data_type);
 773
 774   int idx = 0;
 775   while (!done) {
 776     if (!fgets(buffer, 1023, in_file)) {
 777       out_stream->Printf(
 778           "Instruction::ReadArray:  Error reading file (fgets).\n");
 779       option_value_sp.reset();
 780       return option_value_sp;
 781     }
 782
 783     std::string line(buffer);
 784
 785     size_t len = line.size();
 786     if (line[len - 1] == '\n') {
 787       line[len - 1] = '\0';
 788       line.resize(len - 1);
 789     }
 790
 791     if ((line.size() == 1) && line[0] == ']') {
 792       done = true;
 793       line.clear();
 794     }
 795
 796     if (!line.empty()) {
 797       std::string value;
 798       static RegularExpression g_reg_exp(
 799           llvm::StringRef("^[ \t]*([^ \t]+)[ \t]*$"));
 800       RegularExpression::Match regex_match(1);
 801       bool reg_exp_success = g_reg_exp.Execute(line, &regex_match);
 802       if (reg_exp_success)
 803         regex_match.GetMatchAtIndex(line.c_str(), 1, value);
 804       else
 805         value = line;
 806
 807       OptionValueSP data_value_sp;
 808       switch (data_type) {
 809       case OptionValue::eTypeUInt64:
 810         data_value_sp = std::make_shared<OptionValueUInt64>(0, 0);
 811         data_value_sp->SetValueFromString(value);
 812         break;
 813       // Other types can be added later as needed.
 814       default:
 815         data_value_sp = std::make_shared<OptionValueString>(value.c_str(), "");
 816         break;
 817       }
 818
 819       option_value_sp->GetAsArray()->InsertValue(idx, data_value_sp);
 820       ++idx;
 821     }
 822   }
 823
 824   return option_value_sp;
 825 }
 826
 827 OptionValueSP Instruction::ReadDictionary(FILE *in_file, Stream *out_stream) {
 828   bool done = false;
 829   char buffer[1024];
 830
 831   auto option_value_sp = std::make_shared<OptionValueDictionary>();
 832   static ConstString encoding_key("data_encoding");
 833   OptionValue::Type data_type = OptionValue::eTypeInvalid;
 834
 835   while (!done) {
 836     // Read the next line in the file
 837     if (!fgets(buffer, 1023, in_file)) {
 838       out_stream->Printf(
 839           "Instruction::ReadDictionary: Error reading file (fgets).\n");
 840       option_value_sp.reset();
 841       return option_value_sp;
 842     }
 843
 844     // Check to see if the line contains the end-of-dictionary marker ("}")
 845     std::string line(buffer);
 846
 847     size_t len = line.size();
 848     if (line[len - 1] == '\n') {
 849       line[len - 1] = '\0';
 850       line.resize(len - 1);
 851     }
 852
 853     if ((line.size() == 1) && (line[0] == '}')) {
 854       done = true;
 855       line.clear();
 856     }
 857
 858     // Try to find a key-value pair in the current line and add it to the
 859     // dictionary.
 860     if (!line.empty()) {
 861       static RegularExpression g_reg_exp(llvm::StringRef(
 862           "^[ \t]*([a-zA-Z_][a-zA-Z0-9_]*)[ \t]*=[ \t]*(.*)[ \t]*$"));
 863       RegularExpression::Match regex_match(2);
 864
 865       bool reg_exp_success = g_reg_exp.Execute(line, &regex_match);
 866       std::string key;
 867       std::string value;
 868       if (reg_exp_success) {
 869         regex_match.GetMatchAtIndex(line.c_str(), 1, key);
 870         regex_match.GetMatchAtIndex(line.c_str(), 2, value);
 871       } else {
 872         out_stream->Printf("Instruction::ReadDictionary: Failure executing "
 873                            "regular expression.\n");
 874         option_value_sp.reset();
 875         return option_value_sp;
 876       }
 877
 878       ConstString const_key(key.c_str());
 879       // Check value to see if it's the start of an array or dictionary.
 880
 881       lldb::OptionValueSP value_sp;
 882       assert(value.empty() == false);
 883       assert(key.empty() == false);
 884
 885       if (value[0] == '{') {
 886         assert(value.size() == 1);
 887         // value is a dictionary
 888         value_sp = ReadDictionary(in_file, out_stream);
 889         if (!value_sp) {
 890           option_value_sp.reset();
 891           return option_value_sp;
 892         }
 893       } else if (value[0] == '[') {
 894         assert(value.size() == 1);
 895         // value is an array
 896         value_sp = ReadArray(in_file, out_stream, data_type);
 897         if (!value_sp) {
 898           option_value_sp.reset();
 899           return option_value_sp;
 900         }
 901         // We've used the data_type to read an array; re-set the type to Invalid
 902         data_type = OptionValue::eTypeInvalid;
 903       } else if ((value[0] == '0') && (value[1] == 'x')) {
 904         value_sp = std::make_shared<OptionValueUInt64>(0, 0);
 905         value_sp->SetValueFromString(value);
 906       } else {
 907         size_t len = value.size();
 908         if ((value[0] == '"') && (value[len - 1] == '"'))
 909           value = value.substr(1, len - 2);
 910         value_sp = std::make_shared<OptionValueString>(value.c_str(), "");
 911       }
 912
 913       if (const_key == encoding_key) {
 914         // A 'data_encoding=..." is NOT a normal key-value pair; it is meta-data
 915         // indicating the
 916         // data type of an upcoming array (usually the next bit of data to be
 917         // read in).
 918         if (strcmp(value.c_str(), "uint32_t") == 0)
 919           data_type = OptionValue::eTypeUInt64;
 920       } else
 921         option_value_sp->GetAsDictionary()->SetValueForKey(const_key, value_sp,
 922                                                            false);
 923     }
 924   }
 925
 926   return option_value_sp;
 927 }
 928
 929 bool Instruction::TestEmulation(Stream *out_stream, const char *file_name) {
 930   if (!out_stream)
 931     return false;
 932
 933   if (!file_name) {
 934     out_stream->Printf("Instruction::TestEmulation:  Missing file_name.");
 935     return false;
 936   }
 937   FILE *test_file = FileSystem::Fopen(file_name, "r");
 938   if (!test_file) {
 939     out_stream->Printf(
 940         "Instruction::TestEmulation: Attempt to open test file failed.");
 941     return false;
 942   }
 943
 944   char buffer[256];
 945   if (!fgets(buffer, 255, test_file)) {
 946     out_stream->Printf(
 947         "Instruction::TestEmulation: Error reading first line of test file.\n");
 948     fclose(test_file);
 949     return false;
 950   }
 951
 952   if (strncmp(buffer, "InstructionEmulationState={", 27) != 0) {
 953     out_stream->Printf("Instructin::TestEmulation: Test file does not contain "
 954                        "emulation state dictionary\n");
 955     fclose(test_file);
 956     return false;
 957   }
 958
 959   // Read all the test information from the test file into an
 960   // OptionValueDictionary.
 961
 962   OptionValueSP data_dictionary_sp(ReadDictionary(test_file, out_stream));
 963   if (!data_dictionary_sp) {
 964     out_stream->Printf(
 965         "Instruction::TestEmulation:  Error reading Dictionary Object.\n");
 966     fclose(test_file);
 967     return false;
 968   }
 969
 970   fclose(test_file);
 971
 972   OptionValueDictionary *data_dictionary =
 973       data_dictionary_sp->GetAsDictionary();
 974   static ConstString description_key("assembly_string");
 975   static ConstString triple_key("triple");
 976
 977   OptionValueSP value_sp = data_dictionary->GetValueForKey(description_key);
 978
 979   if (!value_sp) {
 980     out_stream->Printf("Instruction::TestEmulation:  Test file does not "
 981                        "contain description string.\n");
 982     return false;
 983   }
 984
 985   SetDescription(value_sp->GetStringValue());
 986
 987   value_sp = data_dictionary->GetValueForKey(triple_key);
 988   if (!value_sp) {
 989     out_stream->Printf(
 990         "Instruction::TestEmulation: Test file does not contain triple.\n");
 991     return false;
 992   }
 993
 994   ArchSpec arch;
 995   arch.SetTriple(llvm::Triple(value_sp->GetStringValue()));
 996
 997   bool success = false;
 998   std::unique_ptr<EmulateInstruction> insn_emulator_ap(
 999       EmulateInstruction::FindPlugin(arch, eInstructionTypeAny, nullptr));
1000   if (insn_emulator_ap)
1001     success =
1002         insn_emulator_ap->TestEmulation(out_stream, arch, data_dictionary);
1003
1004   if (success)
1005     out_stream->Printf("Emulation test succeeded.");
1006   else
1007     out_stream->Printf("Emulation test failed.");
1008
1009   return success;
1010 }
1011
1012 bool Instruction::Emulate(
1013     const ArchSpec &arch, uint32_t evaluate_options, void *baton,
1014     EmulateInstruction::ReadMemoryCallback read_mem_callback,
1015     EmulateInstruction::WriteMemoryCallback write_mem_callback,
1016     EmulateInstruction::ReadRegisterCallback read_reg_callback,
1017     EmulateInstruction::WriteRegisterCallback write_reg_callback) {
1018   std::unique_ptr<EmulateInstruction> insn_emulator_ap(
1019       EmulateInstruction::FindPlugin(arch, eInstructionTypeAny, nullptr));
1020   if (insn_emulator_ap) {
1021     insn_emulator_ap->SetBaton(baton);
1022     insn_emulator_ap->SetCallbacks(read_mem_callback, write_mem_callback,
1023                                    read_reg_callback, write_reg_callback);
1024     insn_emulator_ap->SetInstruction(GetOpcode(), GetAddress(), nullptr);
1025     return insn_emulator_ap->EvaluateInstruction(evaluate_options);
1026   }
1027
1028   return false;
1029 }
1030
1031 uint32_t Instruction::GetData(DataExtractor &data) {
1032   return m_opcode.GetData(data);
1033 }
1034
1035 InstructionList::InstructionList() : m_instructions() {}
1036
1037 InstructionList::~InstructionList() = default;
1038
1039 size_t InstructionList::GetSize() const { return m_instructions.size(); }
1040
1041 uint32_t InstructionList::GetMaxOpcocdeByteSize() const {
1042   uint32_t max_inst_size = 0;
1043   collection::const_iterator pos, end;
1044   for (pos = m_instructions.begin(), end = m_instructions.end(); pos != end;
1045        ++pos) {
1046     uint32_t inst_size = (*pos)->GetOpcode().GetByteSize();
1047     if (max_inst_size < inst_size)
1048       max_inst_size = inst_size;
1049   }
1050   return max_inst_size;
1051 }
1052
1053 InstructionSP InstructionList::GetInstructionAtIndex(size_t idx) const {
1054   InstructionSP inst_sp;
1055   if (idx < m_instructions.size())
1056     inst_sp = m_instructions[idx];
1057   return inst_sp;
1058 }
1059
1060 void InstructionList::Dump(Stream *s, bool show_address, bool show_bytes,
1061                            const ExecutionContext *exe_ctx) {
1062   const uint32_t max_opcode_byte_size = GetMaxOpcocdeByteSize();
1063   collection::const_iterator pos, begin, end;
1064
1065   const FormatEntity::Entry *disassembly_format = nullptr;
1066   FormatEntity::Entry format;
1067   if (exe_ctx && exe_ctx->HasTargetScope()) {
1068     disassembly_format =
1069         exe_ctx->GetTargetRef().GetDebugger().GetDisassemblyFormat();
1070   } else {
1071     FormatEntity::Parse("${addr}: ", format);
1072     disassembly_format = &format;
1073   }
1074
1075   for (begin = m_instructions.begin(), end = m_instructions.end(), pos = begin;
1076        pos != end; ++pos) {
1077     if (pos != begin)
1078       s->EOL();
1079     (*pos)->Dump(s, max_opcode_byte_size, show_address, show_bytes, exe_ctx,
1080                  nullptr, nullptr, disassembly_format, 0);
1081   }
1082 }
1083
1084 void InstructionList::Clear() { m_instructions.clear(); }
1085
1086 void InstructionList::Append(lldb::InstructionSP &inst_sp) {
1087   if (inst_sp)
1088     m_instructions.push_back(inst_sp);
1089 }
1090
1091 uint32_t
1092 InstructionList::GetIndexOfNextBranchInstruction(uint32_t start,
1093                                                  Target &target) const {
1094   size_t num_instructions = m_instructions.size();
1095
1096   uint32_t next_branch = UINT32_MAX;
1097   size_t i;
1098   for (i = start; i < num_instructions; i++) {
1099     if (m_instructions[i]->DoesBranch()) {
1100       next_branch = i;
1101       break;
1102     }
1103   }
1104
1105   // Hexagon needs the first instruction of the packet with the branch.
1106   // Go backwards until we find an instruction marked end-of-packet, or
1107   // until we hit start.
1108   if (target.GetArchitecture().GetTriple().getArch() == llvm::Triple::hexagon) {
1109     // If we didn't find a branch, find the last packet start.
1110     if (next_branch == UINT32_MAX) {
1111       i = num_instructions - 1;
1112     }
1113
1114     while (i > start) {
1115       --i;
1116
1117       Error error;
1118       uint32_t inst_bytes;
1119       bool prefer_file_cache = false; // Read from process if process is running
1120       lldb::addr_t load_addr = LLDB_INVALID_ADDRESS;
1121       target.ReadMemory(m_instructions[i]->GetAddress(), prefer_file_cache,
1122                         &inst_bytes, sizeof(inst_bytes), error, &load_addr);
1123       // If we have an error reading memory, return start
1124       if (!error.Success())
1125         return start;
1126       // check if this is the last instruction in a packet
1127       // bits 15:14 will be 11b or 00b for a duplex
1128       if (((inst_bytes & 0xC000) == 0xC000) ||
1129           ((inst_bytes & 0xC000) == 0x0000)) {
1130         // instruction after this should be the start of next packet
1131         next_branch = i + 1;
1132         break;
1133       }
1134     }
1135
1136     if (next_branch == UINT32_MAX) {
1137       // We couldn't find the previous packet, so return start
1138       next_branch = start;
1139     }
1140   }
1141   return next_branch;
1142 }
1143
1144 uint32_t
1145 InstructionList::GetIndexOfInstructionAtAddress(const Address &address) {
1146   size_t num_instructions = m_instructions.size();
1147   uint32_t index = UINT32_MAX;
1148   for (size_t i = 0; i < num_instructions; i++) {
1149     if (m_instructions[i]->GetAddress() == address) {
1150       index = i;
1151       break;
1152     }
1153   }
1154   return index;
1155 }
1156
1157 uint32_t
1158 InstructionList::GetIndexOfInstructionAtLoadAddress(lldb::addr_t load_addr,
1159                                                     Target &target) {
1160   Address address;
1161   address.SetLoadAddress(load_addr, &target);
1162   return GetIndexOfInstructionAtAddress(address);
1163 }
1164
1165 size_t Disassembler::ParseInstructions(const ExecutionContext *exe_ctx,
1166                                        const AddressRange &range,
1167                                        Stream *error_strm_ptr,
1168                                        bool prefer_file_cache) {
1169   if (exe_ctx) {
1170     Target *target = exe_ctx->GetTargetPtr();
1171     const addr_t byte_size = range.GetByteSize();
1172     if (target == nullptr || byte_size == 0 ||
1173         !range.GetBaseAddress().IsValid())
1174       return 0;
1175
1176     auto data_sp = std::make_shared<DataBufferHeap>(byte_size, '\0');
1177
1178     Error error;
1179     lldb::addr_t load_addr = LLDB_INVALID_ADDRESS;
1180     const size_t bytes_read = target->ReadMemory(
1181         range.GetBaseAddress(), prefer_file_cache, data_sp->GetBytes(),
1182         data_sp->GetByteSize(), error, &load_addr);
1183
1184     if (bytes_read > 0) {
1185       if (bytes_read != data_sp->GetByteSize())
1186         data_sp->SetByteSize(bytes_read);
1187       DataExtractor data(data_sp, m_arch.GetByteOrder(),
1188                          m_arch.GetAddressByteSize());
1189       const bool data_from_file = load_addr == LLDB_INVALID_ADDRESS;
1190       return DecodeInstructions(range.GetBaseAddress(), data, 0, UINT32_MAX,
1191                                 false, data_from_file);
1192     } else if (error_strm_ptr) {
1193       const char *error_cstr = error.AsCString();
1194       if (error_cstr) {
1195         error_strm_ptr->Printf("error: %s\n", error_cstr);
1196       }
1197     }
1198   } else if (error_strm_ptr) {
1199     error_strm_ptr->PutCString("error: invalid execution context\n");
1200   }
1201   return 0;
1202 }
1203
1204 size_t Disassembler::ParseInstructions(const ExecutionContext *exe_ctx,
1205                                        const Address &start,
1206                                        uint32_t num_instructions,
1207                                        bool prefer_file_cache) {
1208   m_instruction_list.Clear();
1209
1210   if (exe_ctx == nullptr || num_instructions == 0 || !start.IsValid())
1211     return 0;
1212
1213   Target *target = exe_ctx->GetTargetPtr();
1214   // Calculate the max buffer size we will need in order to disassemble
1215   const addr_t byte_size = num_instructions * m_arch.GetMaximumOpcodeByteSize();
1216
1217   if (target == nullptr || byte_size == 0)
1218     return 0;
1219
1220   DataBufferHeap *heap_buffer = new DataBufferHeap(byte_size, '\0');
1221   DataBufferSP data_sp(heap_buffer);
1222
1223   Error error;
1224   lldb::addr_t load_addr = LLDB_INVALID_ADDRESS;
1225   const size_t bytes_read =
1226       target->ReadMemory(start, prefer_file_cache, heap_buffer->GetBytes(),
1227                          byte_size, error, &load_addr);
1228
1229   const bool data_from_file = load_addr == LLDB_INVALID_ADDRESS;
1230
1231   if (bytes_read == 0)
1232     return 0;
1233   DataExtractor data(data_sp, m_arch.GetByteOrder(),
1234                      m_arch.GetAddressByteSize());
1235
1236   const bool append_instructions = true;
1237   DecodeInstructions(start, data, 0, num_instructions, append_instructions,
1238                      data_from_file);
1239
1240   return m_instruction_list.GetSize();
1241 }
1242
1243 //----------------------------------------------------------------------
1244 // Disassembler copy constructor
1245 //----------------------------------------------------------------------
1246 Disassembler::Disassembler(const ArchSpec &arch, const char *flavor)
1247     : m_arch(arch), m_instruction_list(), m_base_addr(LLDB_INVALID_ADDRESS),
1248       m_flavor() {
1249   if (flavor == nullptr)
1250     m_flavor.assign("default");
1251   else
1252     m_flavor.assign(flavor);
1253
1254   // If this is an arm variant that can only include thumb (T16, T32)
1255   // instructions, force the arch triple to be "thumbv.." instead of
1256   // "armv..."
1257   if (arch.IsAlwaysThumbInstructions()) {
1258     std::string thumb_arch_name(arch.GetTriple().getArchName().str());
1259     // Replace "arm" with "thumb" so we get all thumb variants correct
1260     if (thumb_arch_name.size() > 3) {
1261       thumb_arch_name.erase(0, 3);
1262       thumb_arch_name.insert(0, "thumb");
1263     }
1264     m_arch.SetTriple(thumb_arch_name.c_str());
1265   }
1266 }
1267
1268 Disassembler::~Disassembler() = default;
1269
1270 InstructionList &Disassembler::GetInstructionList() {
1271   return m_instruction_list;
1272 }
1273
1274 const InstructionList &Disassembler::GetInstructionList() const {
1275   return m_instruction_list;
1276 }
1277
1278 //----------------------------------------------------------------------
1279 // Class PseudoInstruction
1280 //----------------------------------------------------------------------
1281
1282 PseudoInstruction::PseudoInstruction()
1283     : Instruction(Address(), eAddressClassUnknown), m_description() {}
1284
1285 PseudoInstruction::~PseudoInstruction() = default;
1286
1287 bool PseudoInstruction::DoesBranch() {
1288   // This is NOT a valid question for a pseudo instruction.
1289   return false;
1290 }
1291
1292 bool PseudoInstruction::HasDelaySlot() {
1293   // This is NOT a valid question for a pseudo instruction.
1294   return false;
1295 }
1296
1297 size_t PseudoInstruction::Decode(const lldb_private::Disassembler &disassembler,
1298                                  const lldb_private::DataExtractor &data,
1299                                  lldb::offset_t data_offset) {
1300   return m_opcode.GetByteSize();
1301 }
1302
1303 void PseudoInstruction::SetOpcode(size_t opcode_size, void *opcode_data) {
1304   if (!opcode_data)
1305     return;
1306
1307   switch (opcode_size) {
1308   case 8: {
1309     uint8_t value8 = *((uint8_t *)opcode_data);
1310     m_opcode.SetOpcode8(value8, eByteOrderInvalid);
1311     break;
1312   }
1313   case 16: {
1314     uint16_t value16 = *((uint16_t *)opcode_data);
1315     m_opcode.SetOpcode16(value16, eByteOrderInvalid);
1316     break;
1317   }
1318   case 32: {
1319     uint32_t value32 = *((uint32_t *)opcode_data);
1320     m_opcode.SetOpcode32(value32, eByteOrderInvalid);
1321     break;
1322   }
1323   case 64: {
1324     uint64_t value64 = *((uint64_t *)opcode_data);
1325     m_opcode.SetOpcode64(value64, eByteOrderInvalid);
1326     break;
1327   }
1328   default:
1329     break;
1330   }
1331 }
1332
1333 void PseudoInstruction::SetDescription(llvm::StringRef description) {
1334   m_description = description;
1335 }
1336
1337 Instruction::Operand Instruction::Operand::BuildRegister(ConstString &r) {
1338   Operand ret;
1339   ret.m_type = Type::Register;
1340   ret.m_register = r;
1341   return ret;
1342 }
1343
1344 Instruction::Operand Instruction::Operand::BuildImmediate(lldb::addr_t imm,
1345                                                           bool neg) {
1346   Operand ret;
1347   ret.m_type = Type::Immediate;
1348   ret.m_immediate = imm;
1349   ret.m_negative = neg;
1350   return ret;
1351 }
1352
1353 Instruction::Operand Instruction::Operand::BuildImmediate(int64_t imm) {
1354   Operand ret;
1355   ret.m_type = Type::Immediate;
1356   if (imm < 0) {
1357     ret.m_immediate = -imm;
1358     ret.m_negative = true;
1359   } else {
1360     ret.m_immediate = imm;
1361     ret.m_negative = false;
1362   }
1363   return ret;
1364 }
1365
1366 Instruction::Operand
1367 Instruction::Operand::BuildDereference(const Operand &ref) {
1368   Operand ret;
1369   ret.m_type = Type::Dereference;
1370   ret.m_children = {ref};
1371   return ret;
1372 }
1373
1374 Instruction::Operand Instruction::Operand::BuildSum(const Operand &lhs,
1375                                                     const Operand &rhs) {
1376   Operand ret;
1377   ret.m_type = Type::Sum;
1378   ret.m_children = {lhs, rhs};
1379   return ret;
1380 }
1381
1382 Instruction::Operand Instruction::Operand::BuildProduct(const Operand &lhs,
1383                                                         const Operand &rhs) {
1384   Operand ret;
1385   ret.m_type = Type::Product;
1386   ret.m_children = {lhs, rhs};
1387   return ret;
1388 }
1389
1390 std::function<bool(const Instruction::Operand &)>
1391 lldb_private::OperandMatchers::MatchBinaryOp(
1392     std::function<bool(const Instruction::Operand &)> base,
1393     std::function<bool(const Instruction::Operand &)> left,
1394     std::function<bool(const Instruction::Operand &)> right) {
1395   return [base, left, right](const Instruction::Operand &op) -> bool {
1396     return (base(op) && op.m_children.size() == 2 &&
1397             ((left(op.m_children[0]) && right(op.m_children[1])) ||
1398              (left(op.m_children[1]) && right(op.m_children[0]))));
1399   };
1400 }
1401
1402 std::function<bool(const Instruction::Operand &)>
1403 lldb_private::OperandMatchers::MatchUnaryOp(
1404     std::function<bool(const Instruction::Operand &)> base,
1405     std::function<bool(const Instruction::Operand &)> child) {
1406   return [base, child](const Instruction::Operand &op) -> bool {
1407     return (base(op) && op.m_children.size() == 1 && child(op.m_children[0]));
1408   };
1409 }
1410
1411 std::function<bool(const Instruction::Operand &)>
1412 lldb_private::OperandMatchers::MatchRegOp(const RegisterInfo &info) {
1413   return [&info](const Instruction::Operand &op) {
1414     return (op.m_type == Instruction::Operand::Type::Register &&
1415             (op.m_register == ConstString(info.name) ||
1416              op.m_register == ConstString(info.alt_name)));
1417   };
1418 }
1419
1420 std::function<bool(const Instruction::Operand &)>
1421 lldb_private::OperandMatchers::FetchRegOp(ConstString &reg) {
1422   return [&reg](const Instruction::Operand &op) {
1423     if (op.m_type != Instruction::Operand::Type::Register) {
1424       return false;
1425     }
1426     reg = op.m_register;
1427     return true;
1428   };
1429 }
1430
1431 std::function<bool(const Instruction::Operand &)>
1432 lldb_private::OperandMatchers::MatchImmOp(int64_t imm) {
1433   return [imm](const Instruction::Operand &op) {
1434     return (op.m_type == Instruction::Operand::Type::Immediate &&
1435             ((op.m_negative && op.m_immediate == (uint64_t)-imm) ||
1436              (!op.m_negative && op.m_immediate == (uint64_t)imm)));
1437   };
1438 }
1439
1440 std::function<bool(const Instruction::Operand &)>
1441 lldb_private::OperandMatchers::FetchImmOp(int64_t &imm) {
1442   return [&imm](const Instruction::Operand &op) {
1443     if (op.m_type != Instruction::Operand::Type::Immediate) {
1444       return false;
1445     }
1446     if (op.m_negative) {
1447       imm = -((int64_t)op.m_immediate);
1448     } else {
1449       imm = ((int64_t)op.m_immediate);
1450     }
1451     return true;
1452   };
1453 }
1454
1455 std::function<bool(const Instruction::Operand &)>
1456 lldb_private::OperandMatchers::MatchOpType(Instruction::Operand::Type type) {
1457   return [type](const Instruction::Operand &op) { return op.m_type == type; };
1458 }
1459