*** This commit represents a complete reformatting of the LLDB source code

*** to conform to clang-format’s LLVM style.  This kind of mass change has
*** two obvious implications:

Firstly, merging this particular commit into a downstream fork may be a huge
effort.  Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit.  The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):

    find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
    find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;

The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.

Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit.  There are alternatives available that will attempt
to look through this change and find the appropriate prior commit.  YMMV.

llvm-svn: 280751

2 files changed, 1302 insertions, 1537 deletions

diff --git a/lldb/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp b/lldb/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp
index e581168ae6b..8d6be243be8 100644
--- a/lldb/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp
+++ b/lldb/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp
@@ -23,9 +23,9 @@
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
-#include "llvm/Support/ScopedPrinter.h"
 
 // Other libraries and framework includes
 #include "DisassemblerLLVMC.h"
@@ -40,1551 +40,1336 @@
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/SectionLoadList.h"
-#include "lldb/Target/Target.h"
 #include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Target.h"
 
 #include "lldb/Core/RegularExpression.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-class InstructionLLVMC : public lldb_private::Instruction
-{
+class InstructionLLVMC : public lldb_private::Instruction {
 public:
-    InstructionLLVMC (DisassemblerLLVMC &disasm,
-                      const lldb_private::Address &address,
-                      AddressClass addr_class) :
-        Instruction (address, addr_class),
-        m_disasm_wp (std::static_pointer_cast<DisassemblerLLVMC>(disasm.shared_from_this())),
-        m_does_branch (eLazyBoolCalculate),
-        m_has_delay_slot (eLazyBoolCalculate),
-        m_is_call (eLazyBoolCalculate),
-        m_is_valid (false),
-        m_using_file_addr (false)
-    {
+  InstructionLLVMC(DisassemblerLLVMC &disasm,
+                   const lldb_private::Address &address,
+                   AddressClass addr_class)
+      : Instruction(address, addr_class),
+        m_disasm_wp(std::static_pointer_cast<DisassemblerLLVMC>(
+            disasm.shared_from_this())),
+        m_does_branch(eLazyBoolCalculate), m_has_delay_slot(eLazyBoolCalculate),
+        m_is_call(eLazyBoolCalculate), m_is_valid(false),
+        m_using_file_addr(false) {}
+
+  ~InstructionLLVMC() override = default;
+
+  bool DoesBranch() override {
+    if (m_does_branch == eLazyBoolCalculate) {
+      std::shared_ptr<DisassemblerLLVMC> disasm_sp(GetDisassembler());
+      if (disasm_sp) {
+        disasm_sp->Lock(this, NULL);
+        DataExtractor data;
+        if (m_opcode.GetData(data)) {
+          bool is_alternate_isa;
+          lldb::addr_t pc = m_address.GetFileAddress();
+
+          DisassemblerLLVMC::LLVMCDisassembler *mc_disasm_ptr =
+              GetDisasmToUse(is_alternate_isa);
+          const uint8_t *opcode_data = data.GetDataStart();
+          const size_t opcode_data_len = data.GetByteSize();
+          llvm::MCInst inst;
+          const size_t inst_size =
+              mc_disasm_ptr->GetMCInst(opcode_data, opcode_data_len, pc, inst);
+          // Be conservative, if we didn't understand the instruction, say it
+          // might branch...
+          if (inst_size == 0)
+            m_does_branch = eLazyBoolYes;
+          else {
+            const bool can_branch = mc_disasm_ptr->CanBranch(inst);
+            if (can_branch)
+              m_does_branch = eLazyBoolYes;
+            else
+              m_does_branch = eLazyBoolNo;
+          }
+        }
+        disasm_sp->Unlock();
+      }
     }
-
-    ~InstructionLLVMC() override = default;
-
-    bool
-    DoesBranch() override
-    {
-        if (m_does_branch == eLazyBoolCalculate)
-        {
-            std::shared_ptr<DisassemblerLLVMC> disasm_sp(GetDisassembler());
-            if (disasm_sp)
-            {
-                disasm_sp->Lock(this, NULL);
-                DataExtractor data;
-                if (m_opcode.GetData(data))
-                {
-                    bool is_alternate_isa;
-                    lldb::addr_t pc = m_address.GetFileAddress();
-
-                    DisassemblerLLVMC::LLVMCDisassembler *mc_disasm_ptr = GetDisasmToUse (is_alternate_isa);
-                    const uint8_t *opcode_data = data.GetDataStart();
-                    const size_t opcode_data_len = data.GetByteSize();
-                    llvm::MCInst inst;
-                    const size_t inst_size = mc_disasm_ptr->GetMCInst (opcode_data,
-                                                                       opcode_data_len,
-                                                                       pc,
-                                                                       inst);
-                    // Be conservative, if we didn't understand the instruction, say it might branch...
-                    if (inst_size == 0)
-                        m_does_branch = eLazyBoolYes;
-                    else
-                    {
-                        const bool can_branch = mc_disasm_ptr->CanBranch(inst);
-                        if (can_branch)
-                            m_does_branch = eLazyBoolYes;
-                        else
-                            m_does_branch = eLazyBoolNo;
-                    }
-                }
-                disasm_sp->Unlock();
-            }
+    return m_does_branch == eLazyBoolYes;
+  }
+
+  bool HasDelaySlot() override {
+    if (m_has_delay_slot == eLazyBoolCalculate) {
+      std::shared_ptr<DisassemblerLLVMC> disasm_sp(GetDisassembler());
+      if (disasm_sp) {
+        disasm_sp->Lock(this, NULL);
+        DataExtractor data;
+        if (m_opcode.GetData(data)) {
+          bool is_alternate_isa;
+          lldb::addr_t pc = m_address.GetFileAddress();
+
+          DisassemblerLLVMC::LLVMCDisassembler *mc_disasm_ptr =
+              GetDisasmToUse(is_alternate_isa);
+          const uint8_t *opcode_data = data.GetDataStart();
+          const size_t opcode_data_len = data.GetByteSize();
+          llvm::MCInst inst;
+          const size_t inst_size =
+              mc_disasm_ptr->GetMCInst(opcode_data, opcode_data_len, pc, inst);
+          // if we didn't understand the instruction, say it doesn't have a
+          // delay slot...
+          if (inst_size == 0)
+            m_has_delay_slot = eLazyBoolNo;
+          else {
+            const bool has_delay_slot = mc_disasm_ptr->HasDelaySlot(inst);
+            if (has_delay_slot)
+              m_has_delay_slot = eLazyBoolYes;
+            else
+              m_has_delay_slot = eLazyBoolNo;
+          }
         }
-        return m_does_branch == eLazyBoolYes;
+        disasm_sp->Unlock();
+      }
     }
-
-    bool
-    HasDelaySlot() override
-    {
-        if (m_has_delay_slot == eLazyBoolCalculate)
-        {
-            std::shared_ptr<DisassemblerLLVMC> disasm_sp(GetDisassembler());
-            if (disasm_sp)
-            {
-                disasm_sp->Lock(this, NULL);
-                DataExtractor data;
-                if (m_opcode.GetData(data))
-                {
-                    bool is_alternate_isa;
-                    lldb::addr_t pc = m_address.GetFileAddress();
-
-                    DisassemblerLLVMC::LLVMCDisassembler *mc_disasm_ptr = GetDisasmToUse (is_alternate_isa);
-                    const uint8_t *opcode_data = data.GetDataStart();
-                    const size_t opcode_data_len = data.GetByteSize();
-                    llvm::MCInst inst;
-                    const size_t inst_size = mc_disasm_ptr->GetMCInst (opcode_data,
-                                                                       opcode_data_len,
-                                                                       pc,
-                                                                       inst);
-                    // if we didn't understand the instruction, say it doesn't have a delay slot...
-                    if (inst_size == 0)
-                        m_has_delay_slot = eLazyBoolNo;
-                    else
-                    {
-                        const bool has_delay_slot = mc_disasm_ptr->HasDelaySlot(inst);
-                        if (has_delay_slot)
-                            m_has_delay_slot = eLazyBoolYes;
-                        else
-                            m_has_delay_slot = eLazyBoolNo;
-                    }
-                }
-                disasm_sp->Unlock();
-            }
+    return m_has_delay_slot == eLazyBoolYes;
+  }
+
+  DisassemblerLLVMC::LLVMCDisassembler *GetDisasmToUse(bool &is_alternate_isa) {
+    is_alternate_isa = false;
+    std::shared_ptr<DisassemblerLLVMC> disasm_sp(GetDisassembler());
+    if (disasm_sp) {
+      if (disasm_sp->m_alternate_disasm_ap.get() != NULL) {
+        const AddressClass address_class = GetAddressClass();
+
+        if (address_class == eAddressClassCodeAlternateISA) {
+          is_alternate_isa = true;
+          return disasm_sp->m_alternate_disasm_ap.get();
         }
-        return m_has_delay_slot == eLazyBoolYes;
+      }
+      return disasm_sp->m_disasm_ap.get();
     }
+    return nullptr;
+  }
+
+  size_t Decode(const lldb_private::Disassembler &disassembler,
+                const lldb_private::DataExtractor &data,
+                lldb::offset_t data_offset) override {
+    // All we have to do is read the opcode which can be easy for some
+    // architectures
+    bool got_op = false;
+    std::shared_ptr<DisassemblerLLVMC> disasm_sp(GetDisassembler());
+    if (disasm_sp) {
+      const ArchSpec &arch = disasm_sp->GetArchitecture();
+      const lldb::ByteOrder byte_order = data.GetByteOrder();
+
+      const uint32_t min_op_byte_size = arch.GetMinimumOpcodeByteSize();
+      const uint32_t max_op_byte_size = arch.GetMaximumOpcodeByteSize();
+      if (min_op_byte_size == max_op_byte_size) {
+        // Fixed size instructions, just read that amount of data.
+        if (!data.ValidOffsetForDataOfSize(data_offset, min_op_byte_size))
+          return false;
+
+        switch (min_op_byte_size) {
+        case 1:
+          m_opcode.SetOpcode8(data.GetU8(&data_offset), byte_order);
+          got_op = true;
+          break;
+
+        case 2:
+          m_opcode.SetOpcode16(data.GetU16(&data_offset), byte_order);
+          got_op = true;
+          break;
+
+        case 4:
+          m_opcode.SetOpcode32(data.GetU32(&data_offset), byte_order);
+          got_op = true;
+          break;
+
+        case 8:
+          m_opcode.SetOpcode64(data.GetU64(&data_offset), byte_order);
+          got_op = true;
+          break;
 
-    DisassemblerLLVMC::LLVMCDisassembler *
-    GetDisasmToUse (bool &is_alternate_isa)
-    {
-        is_alternate_isa = false;
-        std::shared_ptr<DisassemblerLLVMC> disasm_sp(GetDisassembler());
-        if (disasm_sp)
-        {
-            if (disasm_sp->m_alternate_disasm_ap.get() != NULL)
-            {
-                const AddressClass address_class = GetAddressClass ();
-
-                if (address_class == eAddressClassCodeAlternateISA)
-                {
-                    is_alternate_isa = true;
-                    return disasm_sp->m_alternate_disasm_ap.get();
-                }
+        default:
+          m_opcode.SetOpcodeBytes(data.PeekData(data_offset, min_op_byte_size),
+                                  min_op_byte_size);
+          got_op = true;
+          break;
+        }
+      }
+      if (!got_op) {
+        bool is_alternate_isa = false;
+        DisassemblerLLVMC::LLVMCDisassembler *mc_disasm_ptr =
+            GetDisasmToUse(is_alternate_isa);
+
+        const llvm::Triple::ArchType machine = arch.GetMachine();
+        if (machine == llvm::Triple::arm || machine == llvm::Triple::thumb) {
+          if (machine == llvm::Triple::thumb || is_alternate_isa) {
+            uint32_t thumb_opcode = data.GetU16(&data_offset);
+            if ((thumb_opcode & 0xe000) != 0xe000 ||
+                ((thumb_opcode & 0x1800u) == 0)) {
+              m_opcode.SetOpcode16(thumb_opcode, byte_order);
+              m_is_valid = true;
+            } else {
+              thumb_opcode <<= 16;
+              thumb_opcode |= data.GetU16(&data_offset);
+              m_opcode.SetOpcode16_2(thumb_opcode, byte_order);
+              m_is_valid = true;
             }
-            return disasm_sp->m_disasm_ap.get();
+          } else {
+            m_opcode.SetOpcode32(data.GetU32(&data_offset), byte_order);
+            m_is_valid = true;
+          }
+        } else {
+          // The opcode isn't evenly sized, so we need to actually use the llvm
+          // disassembler to parse it and get the size.
+          uint8_t *opcode_data =
+              const_cast<uint8_t *>(data.PeekData(data_offset, 1));
+          const size_t opcode_data_len = data.BytesLeft(data_offset);
+          const addr_t pc = m_address.GetFileAddress();
+          llvm::MCInst inst;
+
+          disasm_sp->Lock(this, NULL);
+          const size_t inst_size =
+              mc_disasm_ptr->GetMCInst(opcode_data, opcode_data_len, pc, inst);
+          disasm_sp->Unlock();
+          if (inst_size == 0)
+            m_opcode.Clear();
+          else {
+            m_opcode.SetOpcodeBytes(opcode_data, inst_size);
+            m_is_valid = true;
+          }
         }
-        return nullptr;
+      }
+      return m_opcode.GetByteSize();
     }
+    return 0;
+  }
+
+  void AppendComment(std::string &description) {
+    if (m_comment.empty())
+      m_comment.swap(description);
+    else {
+      m_comment.append(", ");
+      m_comment.append(description);
+    }
+  }
 
-    size_t
-    Decode(const lldb_private::Disassembler &disassembler,
-           const lldb_private::DataExtractor &data,
-           lldb::offset_t data_offset) override
-    {
-        // All we have to do is read the opcode which can be easy for some
-        // architectures
-        bool got_op = false;
-        std::shared_ptr<DisassemblerLLVMC> disasm_sp(GetDisassembler());
-        if (disasm_sp)
-        {
-            const ArchSpec &arch = disasm_sp->GetArchitecture();
-            const lldb::ByteOrder byte_order = data.GetByteOrder();
-
-            const uint32_t min_op_byte_size = arch.GetMinimumOpcodeByteSize();
-            const uint32_t max_op_byte_size = arch.GetMaximumOpcodeByteSize();
-            if (min_op_byte_size == max_op_byte_size)
-            {
-                // Fixed size instructions, just read that amount of data.
-                if (!data.ValidOffsetForDataOfSize(data_offset, min_op_byte_size))
-                    return false;
-
-                switch (min_op_byte_size)
-                {
-                    case 1:
-                        m_opcode.SetOpcode8  (data.GetU8  (&data_offset), byte_order);
-                        got_op = true;
-                        break;
-
-                    case 2:
-                        m_opcode.SetOpcode16 (data.GetU16 (&data_offset), byte_order);
-                        got_op = true;
-                        break;
-
-                    case 4:
-                        m_opcode.SetOpcode32 (data.GetU32 (&data_offset), byte_order);
-                        got_op = true;
-                        break;
-
-                    case 8:
-                        m_opcode.SetOpcode64 (data.GetU64 (&data_offset), byte_order);
-                        got_op = true;
-                        break;
-
-                    default:
-                        m_opcode.SetOpcodeBytes(data.PeekData(data_offset, min_op_byte_size), min_op_byte_size);
-                        got_op = true;
-                        break;
-                }
-            }
-            if (!got_op)
-            {
-                bool is_alternate_isa = false;
-                DisassemblerLLVMC::LLVMCDisassembler *mc_disasm_ptr = GetDisasmToUse (is_alternate_isa);
-
-                const llvm::Triple::ArchType machine = arch.GetMachine();
-                if (machine == llvm::Triple::arm || machine == llvm::Triple::thumb)
-                {
-                    if (machine == llvm::Triple::thumb || is_alternate_isa)
-                    {
-                        uint32_t thumb_opcode = data.GetU16(&data_offset);
-                        if ((thumb_opcode & 0xe000) != 0xe000 || ((thumb_opcode & 0x1800u) == 0))
-                        {
-                            m_opcode.SetOpcode16 (thumb_opcode, byte_order);
-                            m_is_valid = true;
-                        }
-                        else
-                        {
-                            thumb_opcode <<= 16;
-                            thumb_opcode |= data.GetU16(&data_offset);
-                            m_opcode.SetOpcode16_2 (thumb_opcode, byte_order);
-                            m_is_valid = true;
-                        }
-                    }
-                    else
-                    {
-                        m_opcode.SetOpcode32 (data.GetU32(&data_offset), byte_order);
-                        m_is_valid = true;
-                    }
-                }
-                else
-                {
-                    // The opcode isn't evenly sized, so we need to actually use the llvm
-                    // disassembler to parse it and get the size.
-                    uint8_t *opcode_data = const_cast<uint8_t *>(data.PeekData (data_offset, 1));
-                    const size_t opcode_data_len = data.BytesLeft(data_offset);
-                    const addr_t pc = m_address.GetFileAddress();
-                    llvm::MCInst inst;
-
-                    disasm_sp->Lock(this, NULL);
-                    const size_t inst_size = mc_disasm_ptr->GetMCInst(opcode_data,
-                                                                      opcode_data_len,
-                                                                      pc,
-                                                                      inst);
-                    disasm_sp->Unlock();
-                    if (inst_size == 0)
-                        m_opcode.Clear();
-                    else
-                    {
-                        m_opcode.SetOpcodeBytes(opcode_data, inst_size);
-                        m_is_valid = true;
-                    }
-                }
+  void CalculateMnemonicOperandsAndComment(
+      const lldb_private::ExecutionContext *exe_ctx) override {
+    DataExtractor data;
+    const AddressClass address_class = GetAddressClass();
+
+    if (m_opcode.GetData(data)) {
+      std::string out_string;
+      std::string comment_string;
+
+      std::shared_ptr<DisassemblerLLVMC> disasm_sp(GetDisassembler());
+      if (disasm_sp) {
+        DisassemblerLLVMC::LLVMCDisassembler *mc_disasm_ptr;
+
+        if (address_class == eAddressClassCodeAlternateISA)
+          mc_disasm_ptr = disasm_sp->m_alternate_disasm_ap.get();
+        else
+          mc_disasm_ptr = disasm_sp->m_disasm_ap.get();
+
+        lldb::addr_t pc = m_address.GetFileAddress();
+        m_using_file_addr = true;
+
+        const bool data_from_file = disasm_sp->m_data_from_file;
+        bool use_hex_immediates = true;
+        Disassembler::HexImmediateStyle hex_style = Disassembler::eHexStyleC;
+
+        if (exe_ctx) {
+          Target *target = exe_ctx->GetTargetPtr();
+          if (target) {
+            use_hex_immediates = target->GetUseHexImmediates();
+            hex_style = target->GetHexImmediateStyle();
+
+            if (!data_from_file) {
+              const lldb::addr_t load_addr = m_address.GetLoadAddress(target);
+              if (load_addr != LLDB_INVALID_ADDRESS) {
+                pc = load_addr;
+                m_using_file_addr = false;
+              }
             }
-            return m_opcode.GetByteSize();
+          }
         }
-        return 0;
-    }
 
-    void
-    AppendComment (std::string &description)
-    {
-        if (m_comment.empty())
-            m_comment.swap (description);
-        else
-        {
-            m_comment.append(", ");
-            m_comment.append(description);
+        disasm_sp->Lock(this, exe_ctx);
+
+        const uint8_t *opcode_data = data.GetDataStart();
+        const size_t opcode_data_len = data.GetByteSize();
+        llvm::MCInst inst;
+        size_t inst_size =
+            mc_disasm_ptr->GetMCInst(opcode_data, opcode_data_len, pc, inst);
+
+        if (inst_size > 0) {
+          mc_disasm_ptr->SetStyle(use_hex_immediates, hex_style);
+          mc_disasm_ptr->PrintMCInst(inst, out_string, comment_string);
+
+          if (!comment_string.empty()) {
+            AppendComment(comment_string);
+          }
         }
-    }
 
-    void
-    CalculateMnemonicOperandsAndComment(const lldb_private::ExecutionContext *exe_ctx) override
-    {
-        DataExtractor data;
-        const AddressClass address_class = GetAddressClass ();
-
-        if (m_opcode.GetData(data))
-        {
-            std::string out_string;
-            std::string comment_string;
-
-            std::shared_ptr<DisassemblerLLVMC> disasm_sp(GetDisassembler());
-            if (disasm_sp)
-            {
-                DisassemblerLLVMC::LLVMCDisassembler *mc_disasm_ptr;
-
-                if (address_class == eAddressClassCodeAlternateISA)
-                    mc_disasm_ptr = disasm_sp->m_alternate_disasm_ap.get();
-                else
-                    mc_disasm_ptr = disasm_sp->m_disasm_ap.get();
-
-                lldb::addr_t pc = m_address.GetFileAddress();
-                m_using_file_addr = true;
-
-                const bool data_from_file = disasm_sp->m_data_from_file;
-                bool use_hex_immediates = true;
-                Disassembler::HexImmediateStyle hex_style = Disassembler::eHexStyleC;
-
-                if (exe_ctx)
-                {
-                    Target *target = exe_ctx->GetTargetPtr();
-                    if (target)
-                    {
-                        use_hex_immediates = target->GetUseHexImmediates();
-                        hex_style = target->GetHexImmediateStyle();
-
-                        if (!data_from_file)
-                        {
-                            const lldb::addr_t load_addr = m_address.GetLoadAddress(target);
-                            if (load_addr != LLDB_INVALID_ADDRESS)
-                            {
-                                pc = load_addr;
-                                m_using_file_addr = false;
-                            }
-                        }
-                    }
-                }
-
-                disasm_sp->Lock(this, exe_ctx);
-
-                const uint8_t *opcode_data = data.GetDataStart();
-                const size_t opcode_data_len = data.GetByteSize();
-                llvm::MCInst inst;
-                size_t inst_size = mc_disasm_ptr->GetMCInst (opcode_data,
-                                                             opcode_data_len,
-                                                             pc,
-                                                             inst);
-
-                if (inst_size > 0)
-                {
-                    mc_disasm_ptr->SetStyle(use_hex_immediates, hex_style);
-                    mc_disasm_ptr->PrintMCInst(inst, out_string, comment_string);
-                    
-                    if (!comment_string.empty())
-                    {
-                        AppendComment(comment_string);
-                    }
-                }
-
-                disasm_sp->Unlock();
-
-                if (inst_size == 0)
-                {
-                    m_comment.assign ("unknown opcode");
-                    inst_size = m_opcode.GetByteSize();
-                    StreamString mnemonic_strm;
-                    lldb::offset_t offset = 0;
-                    lldb::ByteOrder byte_order = data.GetByteOrder();
-                    switch (inst_size)
-                    {
-                        case 1:
-                            {
-                                const uint8_t uval8 = data.GetU8 (&offset);
-                                m_opcode.SetOpcode8 (uval8, byte_order);
-                                m_opcode_name.assign (".byte");
-                                mnemonic_strm.Printf("0x%2.2x", uval8);
-                            }
-                            break;
-                        case 2:
-                            {
-                                const uint16_t uval16 = data.GetU16(&offset);
-                                m_opcode.SetOpcode16(uval16, byte_order);
-                                m_opcode_name.assign (".short");
-                                mnemonic_strm.Printf("0x%4.4x", uval16);
-                            }
-                            break;
-                        case 4:
-                            {
-                                const uint32_t uval32 = data.GetU32(&offset);
-                                m_opcode.SetOpcode32(uval32, byte_order);
-                                m_opcode_name.assign (".long");
-                                mnemonic_strm.Printf("0x%8.8x", uval32);
-                            }
-                            break;
-                        case 8:
-                            {
-                                const uint64_t uval64 = data.GetU64(&offset);
-                                m_opcode.SetOpcode64(uval64, byte_order);
-                                m_opcode_name.assign (".quad");
-                                mnemonic_strm.Printf("0x%16.16" PRIx64, uval64);
-                            }
-                            break;
-                        default:
-                            if (inst_size == 0)
-                                return;
-                            else
-                            {
-                                const uint8_t *bytes = data.PeekData(offset, inst_size);
-                                if (bytes == NULL)
-                                    return;
-                                m_opcode_name.assign (".byte");
-                                m_opcode.SetOpcodeBytes(bytes, inst_size);
-                                mnemonic_strm.Printf("0x%2.2x", bytes[0]);
-                                for (uint32_t i=1; i<inst_size; ++i)
-                                    mnemonic_strm.Printf(" 0x%2.2x", bytes[i]);
-                            }
-                            break;
-                    }
-                    m_mnemonics.swap(mnemonic_strm.GetString());
-                    return;
-                }
-                else
-                {
-                    if (m_does_branch == eLazyBoolCalculate)
-                    {
-                        const bool can_branch = mc_disasm_ptr->CanBranch(inst);
-                        if (can_branch)
-                            m_does_branch = eLazyBoolYes;
-                        else
-                            m_does_branch = eLazyBoolNo;
-
-                    }
-                }
-
-                static RegularExpression s_regex("[ \t]*([^ ^\t]+)[ \t]*([^ ^\t].*)?");
-
-                RegularExpression::Match matches(3);
-
-                if (s_regex.Execute(out_string.c_str(), &matches))
-                {
-                    matches.GetMatchAtIndex(out_string.c_str(), 1, m_opcode_name);
-                    matches.GetMatchAtIndex(out_string.c_str(), 2, m_mnemonics);
-                }
+        disasm_sp->Unlock();
+
+        if (inst_size == 0) {
+          m_comment.assign("unknown opcode");
+          inst_size = m_opcode.GetByteSize();
+          StreamString mnemonic_strm;
+          lldb::offset_t offset = 0;
+          lldb::ByteOrder byte_order = data.GetByteOrder();
+          switch (inst_size) {
+          case 1: {
+            const uint8_t uval8 = data.GetU8(&offset);
+            m_opcode.SetOpcode8(uval8, byte_order);
+            m_opcode_name.assign(".byte");
+            mnemonic_strm.Printf("0x%2.2x", uval8);
+          } break;
+          case 2: {
+            const uint16_t uval16 = data.GetU16(&offset);
+            m_opcode.SetOpcode16(uval16, byte_order);
+            m_opcode_name.assign(".short");
+            mnemonic_strm.Printf("0x%4.4x", uval16);
+          } break;
+          case 4: {
+            const uint32_t uval32 = data.GetU32(&offset);
+            m_opcode.SetOpcode32(uval32, byte_order);
+            m_opcode_name.assign(".long");
+            mnemonic_strm.Printf("0x%8.8x", uval32);
+          } break;
+          case 8: {
+            const uint64_t uval64 = data.GetU64(&offset);
+            m_opcode.SetOpcode64(uval64, byte_order);
+            m_opcode_name.assign(".quad");
+            mnemonic_strm.Printf("0x%16.16" PRIx64, uval64);
+          } break;
+          default:
+            if (inst_size == 0)
+              return;
+            else {
+              const uint8_t *bytes = data.PeekData(offset, inst_size);
+              if (bytes == NULL)
+                return;
+              m_opcode_name.assign(".byte");
+              m_opcode.SetOpcodeBytes(bytes, inst_size);
+              mnemonic_strm.Printf("0x%2.2x", bytes[0]);
+              for (uint32_t i = 1; i < inst_size; ++i)
+                mnemonic_strm.Printf(" 0x%2.2x", bytes[i]);
             }
+            break;
+          }
+          m_mnemonics.swap(mnemonic_strm.GetString());
+          return;
+        } else {
+          if (m_does_branch == eLazyBoolCalculate) {
+            const bool can_branch = mc_disasm_ptr->CanBranch(inst);
+            if (can_branch)
+              m_does_branch = eLazyBoolYes;
+            else
+              m_does_branch = eLazyBoolNo;
+          }
         }
-    }
 
-    bool
-    IsValid () const
-    {
-        return m_is_valid;
-    }
+        static RegularExpression s_regex("[ \t]*([^ ^\t]+)[ \t]*([^ ^\t].*)?");
 
-    bool
-    UsingFileAddress() const
-    {
-        return m_using_file_addr;
-    }
-    size_t
-    GetByteSize () const
-    {
-        return m_opcode.GetByteSize();
-    }
+        RegularExpression::Match matches(3);
 
-    std::shared_ptr<DisassemblerLLVMC>
-    GetDisassembler ()
-    {
-        return m_disasm_wp.lock();
-    }
-    
-    static llvm::StringRef::const_iterator
-    ConsumeWhitespace(llvm::StringRef::const_iterator osi, llvm::StringRef::const_iterator ose)
-    {
-        while (osi != ose)
-        {
-            switch (*osi) {
-            default:
-                return osi;
-            case ' ': case '\t':
-                break;
-            }
-            ++osi;
+        if (s_regex.Execute(out_string.c_str(), &matches)) {
+          matches.GetMatchAtIndex(out_string.c_str(), 1, m_opcode_name);
+          matches.GetMatchAtIndex(out_string.c_str(), 2, m_mnemonics);
         }
-        
-        return osi;
-    }
-    
-    static std::pair<bool, llvm::StringRef::const_iterator>
-    ConsumeChar(llvm::StringRef::const_iterator osi, const char c, llvm::StringRef::const_iterator ose)
-    {
-        bool found = false;
-        
-        osi = ConsumeWhitespace(osi, ose);
-        if (osi != ose && *osi == c)
-        {
-            found = true;
-            ++osi;
-        }
-        
-        return std::make_pair(found, osi);
+      }
     }
-    
-    static std::pair<Operand, llvm::StringRef::const_iterator>
-    ParseRegisterName(llvm::StringRef::const_iterator osi, llvm::StringRef::const_iterator ose)
-    {
-        Operand ret;
-        ret.m_type = Operand::Type::Register;
-        std::string str;
-        
-        osi = ConsumeWhitespace(osi, ose);
-        
-        while (osi != ose)
-        {
-            if (*osi >= '0' && *osi <= '9')
-            {
-                if (str.empty())
-                {
-                    return std::make_pair(Operand(), osi);
-                }
-                else
-                {
-                    str.push_back(*osi);
-                }
-            }
-            else if (*osi >= 'a' && *osi <= 'z')
-            {
-                str.push_back(*osi);
-            }
-            else
-            {
-                switch (*osi)
-                {
-                default:
-                    if (str.empty())
-                    {
-                        return std::make_pair(Operand(), osi);
-                    }
-                    else
-                    {
-                        ret.m_register = ConstString(str);
-                        return std::make_pair(ret, osi);
-                    }
-                case '%':
-                    if (!str.empty())
-                    {
-                        return std::make_pair(Operand(), osi);
-                    }
-                    break;
-                }
-            }
-            ++osi;
-        }
-    
-        ret.m_register = ConstString(str);
-        return std::make_pair(ret, osi);
+  }
+
+  bool IsValid() const { return m_is_valid; }
+
+  bool UsingFileAddress() const { return m_using_file_addr; }
+  size_t GetByteSize() const { return m_opcode.GetByteSize(); }
+
+  std::shared_ptr<DisassemblerLLVMC> GetDisassembler() {
+    return m_disasm_wp.lock();
+  }
+
+  static llvm::StringRef::const_iterator
+  ConsumeWhitespace(llvm::StringRef::const_iterator osi,
+                    llvm::StringRef::const_iterator ose) {
+    while (osi != ose) {
+      switch (*osi) {
+      default:
+        return osi;
+      case ' ':
+      case '\t':
+        break;
+      }
+      ++osi;
     }
-    
-    static std::pair<Operand, llvm::StringRef::const_iterator>
-    ParseImmediate(llvm::StringRef::const_iterator osi, llvm::StringRef::const_iterator ose)
-    {
-        Operand ret;
-        ret.m_type = Operand::Type::Immediate;
-        std::string str;
-        bool is_hex = false;
-        
-        osi = ConsumeWhitespace(osi, ose);
-        
-        while (osi != ose)
-        {
-            if (*osi >= '0' && *osi <= '9')
-            {
-                str.push_back(*osi);
-            }
-            else if (*osi >= 'a' && *osi <= 'f')
-            {
-                if (is_hex)
-                {
-                    str.push_back(*osi);
-                }
-                else
-                {
-                    return std::make_pair(Operand(), osi);
-                }
-            }
-            else
-            {
-                switch (*osi)
-                {
-                default:
-                    if (str.empty())
-                    {
-                        return std::make_pair(Operand(), osi);
-                    }
-                    else
-                    {
-                        ret.m_immediate = strtoull(str.c_str(), nullptr, 0);
-                        return std::make_pair(ret, osi);
-                    }
-                case 'x':
-                    if (!str.compare("0"))
-                    {
-                        is_hex = true;
-                        str.push_back(*osi);
-                    }
-                    else
-                    {
-                        return std::make_pair(Operand(), osi);
-                    }
-                    break;
-                case '#': case '$':
-                    if (!str.empty())
-                    {
-                        return std::make_pair(Operand(), osi);
-                    }
-                    break;
-                case '-':
-                    if (str.empty())
-                    {
-                        ret.m_negative = true;
-                    }
-                    else
-                    {
-                        return std::make_pair(Operand(), osi);
-                    }
-                }
-            }
-            ++osi;
-        }
-        
-        ret.m_immediate = strtoull(str.c_str(), nullptr, 0);
-        return std::make_pair(ret, osi);
+
+    return osi;
+  }
+
+  static std::pair<bool, llvm::StringRef::const_iterator>
+  ConsumeChar(llvm::StringRef::const_iterator osi, const char c,
+              llvm::StringRef::const_iterator ose) {
+    bool found = false;
+
+    osi = ConsumeWhitespace(osi, ose);
+    if (osi != ose && *osi == c) {
+      found = true;
+      ++osi;
     }
 
-    // -0x5(%rax,%rax,2)
-    static std::pair<Operand, llvm::StringRef::const_iterator>
-    ParseIntelIndexedAccess (llvm::StringRef::const_iterator osi, llvm::StringRef::const_iterator ose)
-    {
-        std::pair<Operand, llvm::StringRef::const_iterator> offset_and_iterator = ParseImmediate(osi, ose);
-        if (offset_and_iterator.first.IsValid())
-        {
-            osi = offset_and_iterator.second;
-        }
-        
-        bool found = false;
-        std::tie(found, osi) = ConsumeChar(osi, '(', ose);
-        if (!found)
-        {
-            return std::make_pair(Operand(), osi);
-        }
-        
-        std::pair<Operand, llvm::StringRef::const_iterator> base_and_iterator = ParseRegisterName(osi, ose);
-        if (base_and_iterator.first.IsValid())
-        {
-            osi = base_and_iterator.second;
-        }
-        else
-        {
-            return std::make_pair(Operand(), osi);
-        }
-        
-        std::tie(found, osi) = ConsumeChar(osi, ',', ose);
-        if (!found)
-        {
-            return std::make_pair(Operand(), osi);
-        }
-        
-        std::pair<Operand, llvm::StringRef::const_iterator> index_and_iterator = ParseRegisterName(osi, ose);
-        if (index_and_iterator.first.IsValid())
-        {
-            osi = index_and_iterator.second;
-        }
-        else
-        {
-            return std::make_pair(Operand(), osi);
-        }
-        
-        std::tie(found, osi) = ConsumeChar(osi, ',', ose);
-        if (!found)
-        {
-            return std::make_pair(Operand(), osi);
-        }
+    return std::make_pair(found, osi);
+  }
+
+  static std::pair<Operand, llvm::StringRef::const_iterator>
+  ParseRegisterName(llvm::StringRef::const_iterator osi,
+                    llvm::StringRef::const_iterator ose) {
+    Operand ret;
+    ret.m_type = Operand::Type::Register;
+    std::string str;
 
-        std::pair<Operand, llvm::StringRef::const_iterator> multiplier_and_iterator = ParseImmediate(osi, ose);
-        if (index_and_iterator.first.IsValid())
-        {
-            osi = index_and_iterator.second;
+    osi = ConsumeWhitespace(osi, ose);
+
+    while (osi != ose) {
+      if (*osi >= '0' && *osi <= '9') {
+        if (str.empty()) {
+          return std::make_pair(Operand(), osi);
+        } else {
+          str.push_back(*osi);
         }
-        else
-        {
+      } else if (*osi >= 'a' && *osi <= 'z') {
+        str.push_back(*osi);
+      } else {
+        switch (*osi) {
+        default:
+          if (str.empty()) {
             return std::make_pair(Operand(), osi);
-        }
-        
-        std::tie(found, osi) = ConsumeChar(osi, ')', ose);
-        if (!found)
-        {
+          } else {
+            ret.m_register = ConstString(str);
+            return std::make_pair(ret, osi);
+          }
+        case '%':
+          if (!str.empty()) {
             return std::make_pair(Operand(), osi);
+          }
+          break;
         }
-        
-        Operand product;
-        product.m_type = Operand::Type::Product;
-        product.m_children.push_back(index_and_iterator.first);
-        product.m_children.push_back(multiplier_and_iterator.first);
-        
-        Operand index;
-        index.m_type = Operand::Type::Sum;
-        index.m_children.push_back(base_and_iterator.first);
-        index.m_children.push_back(product);
-        
-        if (offset_and_iterator.first.IsValid())
-        {
-            Operand offset;
-            offset.m_type = Operand::Type::Sum;
-            offset.m_children.push_back(offset_and_iterator.first);
-            offset.m_children.push_back(index);
-            
-            Operand deref;
-            deref.m_type = Operand::Type::Dereference;
-            deref.m_children.push_back(offset);
-            return std::make_pair(deref, osi);
-        }
-        else
-        {
-            Operand deref;
-            deref.m_type = Operand::Type::Dereference;
-            deref.m_children.push_back(index);
-            return std::make_pair(deref, osi);
-        }
+      }
+      ++osi;
     }
-    
-    // -0x10(%rbp)
-    static std::pair<Operand, llvm::StringRef::const_iterator>
-    ParseIntelDerefAccess (llvm::StringRef::const_iterator osi, llvm::StringRef::const_iterator ose)
-    {
-        std::pair<Operand, llvm::StringRef::const_iterator> offset_and_iterator = ParseImmediate(osi, ose);
-        if (offset_and_iterator.first.IsValid())
-        {
-            osi = offset_and_iterator.second;
-        }
-        
-        bool found = false;
-        std::tie(found, osi) = ConsumeChar(osi, '(', ose);
-        if (!found)
-        {
-            return std::make_pair(Operand(), osi);
-        }
-        
-        std::pair<Operand, llvm::StringRef::const_iterator> base_and_iterator = ParseRegisterName(osi, ose);
-        if (base_and_iterator.first.IsValid())
-        {
-            osi = base_and_iterator.second;
-        }
-        else
-        {
-            return std::make_pair(Operand(), osi);
-        }
-        
-        std::tie(found, osi) = ConsumeChar(osi, ')', ose);
-        if (!found)
-        {
-            return std::make_pair(Operand(), osi);
-        }
-        
-        if (offset_and_iterator.first.IsValid())
-        {
-            Operand offset;
-            offset.m_type = Operand::Type::Sum;
-            offset.m_children.push_back(offset_and_iterator.first);
-            offset.m_children.push_back(base_and_iterator.first);
-            
-            Operand deref;
-            deref.m_type = Operand::Type::Dereference;
-            deref.m_children.push_back(offset);
-            return std::make_pair(deref, osi);
-        }
-        else
-        {
-            Operand deref;
-            deref.m_type = Operand::Type::Dereference;
-            deref.m_children.push_back(base_and_iterator.first);
-            return std::make_pair(deref, osi);
+
+    ret.m_register = ConstString(str);
+    return std::make_pair(ret, osi);
+  }
+
+  static std::pair<Operand, llvm::StringRef::const_iterator>
+  ParseImmediate(llvm::StringRef::const_iterator osi,
+                 llvm::StringRef::const_iterator ose) {
+    Operand ret;
+    ret.m_type = Operand::Type::Immediate;
+    std::string str;
+    bool is_hex = false;
+
+    osi = ConsumeWhitespace(osi, ose);
+
+    while (osi != ose) {
+      if (*osi >= '0' && *osi <= '9') {
+        str.push_back(*osi);
+      } else if (*osi >= 'a' && *osi <= 'f') {
+        if (is_hex) {
+          str.push_back(*osi);
+        } else {
+          return std::make_pair(Operand(), osi);
         }
-    }
-    
-    // [sp, #8]!
-    static std::pair<Operand, llvm::StringRef::const_iterator>
-    ParseARMOffsetAccess (llvm::StringRef::const_iterator osi, llvm::StringRef::const_iterator ose)
-    {
-        bool found = false;
-        std::tie(found, osi) = ConsumeChar(osi, '[', ose);
-        if (!found)
-        {
+      } else {
+        switch (*osi) {
+        default:
+          if (str.empty()) {
             return std::make_pair(Operand(), osi);
-        }
-        
-        std::pair<Operand, llvm::StringRef::const_iterator> base_and_iterator = ParseRegisterName(osi, ose);
-        if (base_and_iterator.first.IsValid())
-        {
-            osi = base_and_iterator.second;
-        }
-        else
-        {
+          } else {
+            ret.m_immediate = strtoull(str.c_str(), nullptr, 0);
+            return std::make_pair(ret, osi);
+          }
+        case 'x':
+          if (!str.compare("0")) {
+            is_hex = true;
+            str.push_back(*osi);
+          } else {
             return std::make_pair(Operand(), osi);
-        }
-        
-        std::tie(found, osi) = ConsumeChar(osi, ',', ose);
-        if (!found)
-        {
+          }
+          break;
+        case '#':
+        case '$':
+          if (!str.empty()) {
             return std::make_pair(Operand(), osi);
-        }
-        
-        std::pair<Operand, llvm::StringRef::const_iterator> offset_and_iterator = ParseImmediate(osi, ose);
-        if (offset_and_iterator.first.IsValid())
-        {
-            osi = offset_and_iterator.second;
-        }
-        
-        std::tie(found, osi) = ConsumeChar(osi, ']', ose);
-        if (!found)
-        {
+          }
+          break;
+        case '-':
+          if (str.empty()) {
+            ret.m_negative = true;
+          } else {
             return std::make_pair(Operand(), osi);
+          }
         }
-        
-        Operand offset;
-        offset.m_type = Operand::Type::Sum;
-        offset.m_children.push_back(offset_and_iterator.first);
-        offset.m_children.push_back(base_and_iterator.first);
-        
-        Operand deref;
-        deref.m_type = Operand::Type::Dereference;
-        deref.m_children.push_back(offset);
-        return std::make_pair(deref, osi);
+      }
+      ++osi;
     }
-    
-    // [sp]
-    static std::pair<Operand, llvm::StringRef::const_iterator>
-    ParseARMDerefAccess (llvm::StringRef::const_iterator osi, llvm::StringRef::const_iterator ose)
-    {
-        bool found = false;
-        std::tie(found, osi) = ConsumeChar(osi, '[', ose);
-        if (!found)
-        {
-            return std::make_pair(Operand(), osi);
-        }
-        
-        std::pair<Operand, llvm::StringRef::const_iterator> base_and_iterator = ParseRegisterName(osi, ose);
-        if (base_and_iterator.first.IsValid())
-        {
-            osi = base_and_iterator.second;
-        }
-        else
-        {
-            return std::make_pair(Operand(), osi);
-        }
-        
-        std::tie(found, osi) = ConsumeChar(osi, ']', ose);
-        if (!found)
-        {
-            return std::make_pair(Operand(), osi);
-        }
-        
-        Operand deref;
-        deref.m_type = Operand::Type::Dereference;
-        deref.m_children.push_back(base_and_iterator.first);
-        return std::make_pair(deref, osi);
+
+    ret.m_immediate = strtoull(str.c_str(), nullptr, 0);
+    return std::make_pair(ret, osi);
+  }
+
+  // -0x5(%rax,%rax,2)
+  static std::pair<Operand, llvm::StringRef::const_iterator>
+  ParseIntelIndexedAccess(llvm::StringRef::const_iterator osi,
+                          llvm::StringRef::const_iterator ose) {
+    std::pair<Operand, llvm::StringRef::const_iterator> offset_and_iterator =
+        ParseImmediate(osi, ose);
+    if (offset_and_iterator.first.IsValid()) {
+      osi = offset_and_iterator.second;
     }
-    
-    static void
-    DumpOperand(const Operand &op, Stream &s)
-    {
-        switch (op.m_type)
-        {
-        case Operand::Type::Dereference:
-            s.PutCString("*");
-            DumpOperand(op.m_children[0], s);
-            break;
-        case Operand::Type::Immediate:
-            if (op.m_negative)
-            {
-                s.PutCString("-");
-            }
-            s.PutCString(llvm::to_string(op.m_immediate).c_str());
-            break;
-        case Operand::Type::Invalid:
-            s.PutCString("Invalid");
-            break;
-        case Operand::Type::Product:
-            s.PutCString("(");
-            DumpOperand(op.m_children[0], s);
-            s.PutCString("*");
-            DumpOperand(op.m_children[1], s);
-            s.PutCString(")");
-            break;
-        case Operand::Type::Register:
-            s.PutCString(op.m_register.AsCString());
-            break;
-        case Operand::Type::Sum:
-            s.PutCString("(");
-            DumpOperand(op.m_children[0], s);
-            s.PutCString("+");
-            DumpOperand(op.m_children[1], s);
-            s.PutCString(")");
-            break;
-        }
+
+    bool found = false;
+    std::tie(found, osi) = ConsumeChar(osi, '(', ose);
+    if (!found) {
+      return std::make_pair(Operand(), osi);
     }
-    
-    bool
-    ParseOperands (llvm::SmallVectorImpl<Instruction::Operand> &operands) override
-    {
-        const char *operands_string = GetOperands(nullptr);
-        
-        if (!operands_string)
-        {
-            return false;
-        }
-        
-        llvm::StringRef operands_ref(operands_string);
-        
-        llvm::StringRef::const_iterator osi = operands_ref.begin();
-        llvm::StringRef::const_iterator ose = operands_ref.end();
-        
-        while (osi != ose)
-        {
-            Operand operand;
-            llvm::StringRef::const_iterator iter;
-            
-            if ((std::tie(operand, iter) = ParseIntelIndexedAccess(osi, ose), operand.IsValid()) ||
-                (std::tie(operand, iter) = ParseIntelDerefAccess(osi, ose), operand.IsValid()) ||
-                (std::tie(operand, iter) = ParseARMOffsetAccess(osi, ose), operand.IsValid()) ||
-                (std::tie(operand, iter) = ParseARMDerefAccess(osi, ose), operand.IsValid()) ||
-                (std::tie(operand, iter) = ParseRegisterName(osi, ose), operand.IsValid()) ||
-                (std::tie(operand, iter) = ParseImmediate(osi, ose), operand.IsValid()))
-            {
-                osi = iter;
-                operands.push_back(operand);
-            }
-            else
-            {
-                return false;
-            }
-            
-            std::pair<bool, llvm::StringRef::const_iterator> found_and_iter = ConsumeChar(osi, ',', ose);
-            if (found_and_iter.first)
-            {
-                osi = found_and_iter.second;
-            }
-            
-            osi = ConsumeWhitespace(osi, ose);
-        }
-        
-        DisassemblerSP disasm_sp = m_disasm_wp.lock();
-        
-        if (disasm_sp && operands.size() > 1)
-        {
-            // TODO tie this into the MC Disassembler's notion of clobbers.
-            switch (disasm_sp->GetArchitecture().GetMachine())
-            {
-            default:
-                break;
-            case llvm::Triple::x86:
-            case llvm::Triple::x86_64:
-                operands[operands.size() - 1].m_clobbered = true;
-                break;
-            case llvm::Triple::arm:
-                operands[0].m_clobbered = true;
-                break;
-            }
-        }
-        
-        if (Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS))
-        {
-            StreamString ss;
-            
-            ss.Printf("[%s] expands to %zu operands:\n", operands_string, operands.size());
-            for (const Operand &operand : operands) {
-                ss.PutCString("  ");
-                DumpOperand(operand, ss);
-                ss.PutCString("\n");
-            }
-            
-            log->PutCString(ss.GetData());
-        }
-        
-        return true;
+
+    std::pair<Operand, llvm::StringRef::const_iterator> base_and_iterator =
+        ParseRegisterName(osi, ose);
+    if (base_and_iterator.first.IsValid()) {
+      osi = base_and_iterator.second;
+    } else {
+      return std::make_pair(Operand(), osi);
     }
-    
-    bool
-    IsCall () override
-    {
-        if (m_is_call == eLazyBoolCalculate)
-        {
-            std::shared_ptr<DisassemblerLLVMC> disasm_sp(GetDisassembler());
-            if (disasm_sp)
-            {
-                disasm_sp->Lock(this, NULL);
-                DataExtractor data;
-                if (m_opcode.GetData(data))
-                {
-                    bool is_alternate_isa;
-                    lldb::addr_t pc = m_address.GetFileAddress();
-                    
-                    DisassemblerLLVMC::LLVMCDisassembler *mc_disasm_ptr = GetDisasmToUse (is_alternate_isa);
-                    const uint8_t *opcode_data = data.GetDataStart();
-                    const size_t opcode_data_len = data.GetByteSize();
-                    llvm::MCInst inst;
-                    const size_t inst_size = mc_disasm_ptr->GetMCInst (opcode_data,
-                                                                       opcode_data_len,
-                                                                       pc,
-                                                                       inst);
-                    if (inst_size == 0)
-                    {
-                        m_is_call = eLazyBoolNo;
-                    }
-                    else
-                    {
-                        if (mc_disasm_ptr->IsCall(inst))
-                            m_is_call = eLazyBoolYes;
-                        else
-                            m_is_call = eLazyBoolNo;
-                    }
-                }
-                disasm_sp->Unlock();
-            }
-        }
-        return m_is_call == eLazyBoolYes;
+
+    std::tie(found, osi) = ConsumeChar(osi, ',', ose);
+    if (!found) {
+      return std::make_pair(Operand(), osi);
     }
-    
-protected:
 
-    std::weak_ptr<DisassemblerLLVMC> m_disasm_wp;
-    LazyBool                m_does_branch;
-    LazyBool                m_has_delay_slot;
-    LazyBool                m_is_call;
-    bool                    m_is_valid;
-    bool                    m_using_file_addr;
-};
+    std::pair<Operand, llvm::StringRef::const_iterator> index_and_iterator =
+        ParseRegisterName(osi, ose);
+    if (index_and_iterator.first.IsValid()) {
+      osi = index_and_iterator.second;
+    } else {
+      return std::make_pair(Operand(), osi);
+    }
 
-DisassemblerLLVMC::LLVMCDisassembler::LLVMCDisassembler (const char *triple, const char *cpu, const char *features_str, unsigned flavor, DisassemblerLLVMC &owner):
-    m_is_valid(true)
-{
-    std::string Error;
-    const llvm::Target *curr_target = llvm::TargetRegistry::lookupTarget(triple, Error);
-    if (!curr_target)
-    {
-        m_is_valid = false;
-        return;
+    std::tie(found, osi) = ConsumeChar(osi, ',', ose);
+    if (!found) {
+      return std::make_pair(Operand(), osi);
     }
 
-    m_instr_info_ap.reset(curr_target->createMCInstrInfo());
-    m_reg_info_ap.reset (curr_target->createMCRegInfo(triple));
+    std::pair<Operand, llvm::StringRef::const_iterator>
+        multiplier_and_iterator = ParseImmediate(osi, ose);
+    if (index_and_iterator.first.IsValid()) {
+      osi = index_and_iterator.second;
+    } else {
+      return std::make_pair(Operand(), osi);
+    }
 
-    m_subtarget_info_ap.reset(curr_target->createMCSubtargetInfo(triple, cpu,
-                                                                features_str));
+    std::tie(found, osi) = ConsumeChar(osi, ')', ose);
+    if (!found) {
+      return std::make_pair(Operand(), osi);
+    }
 
-    std::unique_ptr<llvm::MCRegisterInfo> reg_info(curr_target->createMCRegInfo(triple));
-    m_asm_info_ap.reset(curr_target->createMCAsmInfo(*reg_info, triple));
+    Operand product;
+    product.m_type = Operand::Type::Product;
+    product.m_children.push_back(index_and_iterator.first);
+    product.m_children.push_back(multiplier_and_iterator.first);
+
+    Operand index;
+    index.m_type = Operand::Type::Sum;
+    index.m_children.push_back(base_and_iterator.first);
+    index.m_children.push_back(product);
+
+    if (offset_and_iterator.first.IsValid()) {
+      Operand offset;
+      offset.m_type = Operand::Type::Sum;
+      offset.m_children.push_back(offset_and_iterator.first);
+      offset.m_children.push_back(index);
+
+      Operand deref;
+      deref.m_type = Operand::Type::Dereference;
+      deref.m_children.push_back(offset);
+      return std::make_pair(deref, osi);
+    } else {
+      Operand deref;
+      deref.m_type = Operand::Type::Dereference;
+      deref.m_children.push_back(index);
+      return std::make_pair(deref, osi);
+    }
+  }
+
+  // -0x10(%rbp)
+  static std::pair<Operand, llvm::StringRef::const_iterator>
+  ParseIntelDerefAccess(llvm::StringRef::const_iterator osi,
+                        llvm::StringRef::const_iterator ose) {
+    std::pair<Operand, llvm::StringRef::const_iterator> offset_and_iterator =
+        ParseImmediate(osi, ose);
+    if (offset_and_iterator.first.IsValid()) {
+      osi = offset_and_iterator.second;
+    }
 
-    if (m_instr_info_ap.get() == NULL || m_reg_info_ap.get() == NULL || m_subtarget_info_ap.get() == NULL || m_asm_info_ap.get() == NULL)
-    {
-        m_is_valid = false;
-        return;
+    bool found = false;
+    std::tie(found, osi) = ConsumeChar(osi, '(', ose);
+    if (!found) {
+      return std::make_pair(Operand(), osi);
     }
 
-    m_context_ap.reset(new llvm::MCContext(m_asm_info_ap.get(), m_reg_info_ap.get(), 0));
+    std::pair<Operand, llvm::StringRef::const_iterator> base_and_iterator =
+        ParseRegisterName(osi, ose);
+    if (base_and_iterator.first.IsValid()) {
+      osi = base_and_iterator.second;
+    } else {
+      return std::make_pair(Operand(), osi);
+    }
 
-    m_disasm_ap.reset(curr_target->createMCDisassembler(*m_subtarget_info_ap.get(), *m_context_ap.get()));
-    if (m_disasm_ap.get() && m_context_ap.get())
-    {
-        std::unique_ptr<llvm::MCRelocationInfo> RelInfo(curr_target->createMCRelocationInfo(triple, *m_context_ap.get()));
-        if (!RelInfo)
-        {
-            m_is_valid = false;
-            return;
-        }
-        std::unique_ptr<llvm::MCSymbolizer> symbolizer_up(curr_target->createMCSymbolizer(triple, NULL,
-                       DisassemblerLLVMC::SymbolLookupCallback,
-                       (void *) &owner,
-                       m_context_ap.get(), std::move(RelInfo)));
-        m_disasm_ap->setSymbolizer(std::move(symbolizer_up));
+    std::tie(found, osi) = ConsumeChar(osi, ')', ose);
+    if (!found) {
+      return std::make_pair(Operand(), osi);
+    }
 
+    if (offset_and_iterator.first.IsValid()) {
+      Operand offset;
+      offset.m_type = Operand::Type::Sum;
+      offset.m_children.push_back(offset_and_iterator.first);
+      offset.m_children.push_back(base_and_iterator.first);
+
+      Operand deref;
+      deref.m_type = Operand::Type::Dereference;
+      deref.m_children.push_back(offset);
+      return std::make_pair(deref, osi);
+    } else {
+      Operand deref;
+      deref.m_type = Operand::Type::Dereference;
+      deref.m_children.push_back(base_and_iterator.first);
+      return std::make_pair(deref, osi);
+    }
+  }
+
+  // [sp, #8]!
+  static std::pair<Operand, llvm::StringRef::const_iterator>
+  ParseARMOffsetAccess(llvm::StringRef::const_iterator osi,
+                       llvm::StringRef::const_iterator ose) {
+    bool found = false;
+    std::tie(found, osi) = ConsumeChar(osi, '[', ose);
+    if (!found) {
+      return std::make_pair(Operand(), osi);
+    }
 
-        unsigned asm_printer_variant;
-        if (flavor == ~0U)
-            asm_printer_variant = m_asm_info_ap->getAssemblerDialect();
-        else
-        {
-            asm_printer_variant = flavor;
-        }
+    std::pair<Operand, llvm::StringRef::const_iterator> base_and_iterator =
+        ParseRegisterName(osi, ose);
+    if (base_and_iterator.first.IsValid()) {
+      osi = base_and_iterator.second;
+    } else {
+      return std::make_pair(Operand(), osi);
+    }
 
-        m_instr_printer_ap.reset(curr_target->createMCInstPrinter(llvm::Triple{triple},
-                                                                  asm_printer_variant,
-                                                                  *m_asm_info_ap.get(),
-                                                                  *m_instr_info_ap.get(),
-                                                                  *m_reg_info_ap.get()));
-        if (m_instr_printer_ap.get() == NULL)
-        {
-            m_disasm_ap.reset();
-            m_is_valid = false;
-        }
+    std::tie(found, osi) = ConsumeChar(osi, ',', ose);
+    if (!found) {
+      return std::make_pair(Operand(), osi);
     }
-    else
-        m_is_valid = false;
-}
 
-DisassemblerLLVMC::LLVMCDisassembler::~LLVMCDisassembler() = default;
+    std::pair<Operand, llvm::StringRef::const_iterator> offset_and_iterator =
+        ParseImmediate(osi, ose);
+    if (offset_and_iterator.first.IsValid()) {
+      osi = offset_and_iterator.second;
+    }
 
-uint64_t
-DisassemblerLLVMC::LLVMCDisassembler::GetMCInst (const uint8_t *opcode_data,
-                                                 size_t opcode_data_len,
-                                                 lldb::addr_t pc,
-                                                 llvm::MCInst &mc_inst)
-{
-    llvm::ArrayRef<uint8_t> data(opcode_data, opcode_data_len);
-    llvm::MCDisassembler::DecodeStatus status;
-
-    uint64_t new_inst_size;
-    status = m_disasm_ap->getInstruction(mc_inst,
-                                         new_inst_size,
-                                         data,
-                                         pc,
-                                         llvm::nulls(),
-                                         llvm::nulls());
-    if (status == llvm::MCDisassembler::Success)
-        return new_inst_size;
-    else
-        return 0;
-}
+    std::tie(found, osi) = ConsumeChar(osi, ']', ose);
+    if (!found) {
+      return std::make_pair(Operand(), osi);
+    }
 
-void
-DisassemblerLLVMC::LLVMCDisassembler::PrintMCInst (llvm::MCInst &mc_inst,
-                                                   std::string &inst_string,
-                                                   std::string &comments_string)
-{
-    llvm::raw_string_ostream inst_stream(inst_string);
-    llvm::raw_string_ostream comments_stream(comments_string);
-
-    m_instr_printer_ap->setCommentStream(comments_stream);
-    m_instr_printer_ap->printInst (&mc_inst, inst_stream, llvm::StringRef(), *m_subtarget_info_ap);
-    m_instr_printer_ap->setCommentStream(llvm::nulls());
-    comments_stream.flush();
-    
-    static std::string g_newlines("\r\n");
-    
-    for (size_t newline_pos = 0; (newline_pos = comments_string.find_first_of(g_newlines, newline_pos)) != comments_string.npos; /**/)
-    {
-        comments_string.replace(comments_string.begin() + newline_pos, comments_string.begin() + newline_pos + 1, 1, ' ');
+    Operand offset;
+    offset.m_type = Operand::Type::Sum;
+    offset.m_children.push_back(offset_and_iterator.first);
+    offset.m_children.push_back(base_and_iterator.first);
+
+    Operand deref;
+    deref.m_type = Operand::Type::Dereference;
+    deref.m_children.push_back(offset);
+    return std::make_pair(deref, osi);
+  }
+
+  // [sp]
+  static std::pair<Operand, llvm::StringRef::const_iterator>
+  ParseARMDerefAccess(llvm::StringRef::const_iterator osi,
+                      llvm::StringRef::const_iterator ose) {
+    bool found = false;
+    std::tie(found, osi) = ConsumeChar(osi, '[', ose);
+    if (!found) {
+      return std::make_pair(Operand(), osi);
     }
-}
 
-void
-DisassemblerLLVMC::LLVMCDisassembler::SetStyle (bool use_hex_immed, HexImmediateStyle hex_style)
-{
-    m_instr_printer_ap->setPrintImmHex(use_hex_immed);
-    switch(hex_style)
-    {
-    case eHexStyleC:      m_instr_printer_ap->setPrintHexStyle(llvm::HexStyle::C); break;
-    case eHexStyleAsm:    m_instr_printer_ap->setPrintHexStyle(llvm::HexStyle::Asm); break;
+    std::pair<Operand, llvm::StringRef::const_iterator> base_and_iterator =
+        ParseRegisterName(osi, ose);
+    if (base_and_iterator.first.IsValid()) {
+      osi = base_and_iterator.second;
+    } else {
+      return std::make_pair(Operand(), osi);
     }
-}
 
-bool
-DisassemblerLLVMC::LLVMCDisassembler::CanBranch (llvm::MCInst &mc_inst)
-{
-    return m_instr_info_ap->get(mc_inst.getOpcode()).mayAffectControlFlow(mc_inst, *m_reg_info_ap.get());
-}
+    std::tie(found, osi) = ConsumeChar(osi, ']', ose);
+    if (!found) {
+      return std::make_pair(Operand(), osi);
+    }
 
-bool
-DisassemblerLLVMC::LLVMCDisassembler::HasDelaySlot (llvm::MCInst &mc_inst)
-{
-    return m_instr_info_ap->get(mc_inst.getOpcode()).hasDelaySlot();
-}
+    Operand deref;
+    deref.m_type = Operand::Type::Dereference;
+    deref.m_children.push_back(base_and_iterator.first);
+    return std::make_pair(deref, osi);
+  }
+
+  static void DumpOperand(const Operand &op, Stream &s) {
+    switch (op.m_type) {
+    case Operand::Type::Dereference:
+      s.PutCString("*");
+      DumpOperand(op.m_children[0], s);
+      break;
+    case Operand::Type::Immediate:
+      if (op.m_negative) {
+        s.PutCString("-");
+      }
+      s.PutCString(llvm::to_string(op.m_immediate).c_str());
+      break;
+    case Operand::Type::Invalid:
+      s.PutCString("Invalid");
+      break;
+    case Operand::Type::Product:
+      s.PutCString("(");
+      DumpOperand(op.m_children[0], s);
+      s.PutCString("*");
+      DumpOperand(op.m_children[1], s);
+      s.PutCString(")");
+      break;
+    case Operand::Type::Register:
+      s.PutCString(op.m_register.AsCString());
+      break;
+    case Operand::Type::Sum:
+      s.PutCString("(");
+      DumpOperand(op.m_children[0], s);
+      s.PutCString("+");
+      DumpOperand(op.m_children[1], s);
+      s.PutCString(")");
+      break;
+    }
+  }
 
-bool
-DisassemblerLLVMC::LLVMCDisassembler::IsCall (llvm::MCInst &mc_inst)
-{
-    return m_instr_info_ap->get(mc_inst.getOpcode()).isCall();
-}
+  bool ParseOperands(
+      llvm::SmallVectorImpl<Instruction::Operand> &operands) override {
+    const char *operands_string = GetOperands(nullptr);
 
-DisassemblerLLVMC::DisassemblerLLVMC (const ArchSpec &arch, const char *flavor_string) :
-    Disassembler(arch, flavor_string),
-    m_exe_ctx (NULL),
-    m_inst (NULL),
-    m_data_from_file (false)
-{
-    if (!FlavorValidForArchSpec (arch, m_flavor.c_str()))
-    {
-        m_flavor.assign("default");
+    if (!operands_string) {
+      return false;
     }
 
-    unsigned flavor = ~0U;
-    llvm::Triple triple = arch.GetTriple();
+    llvm::StringRef operands_ref(operands_string);
+
+    llvm::StringRef::const_iterator osi = operands_ref.begin();
+    llvm::StringRef::const_iterator ose = operands_ref.end();
+
+    while (osi != ose) {
+      Operand operand;
+      llvm::StringRef::const_iterator iter;
+
+      if ((std::tie(operand, iter) = ParseIntelIndexedAccess(osi, ose),
+           operand.IsValid()) ||
+          (std::tie(operand, iter) = ParseIntelDerefAccess(osi, ose),
+           operand.IsValid()) ||
+          (std::tie(operand, iter) = ParseARMOffsetAccess(osi, ose),
+           operand.IsValid()) ||
+          (std::tie(operand, iter) = ParseARMDerefAccess(osi, ose),
+           operand.IsValid()) ||
+          (std::tie(operand, iter) = ParseRegisterName(osi, ose),
+           operand.IsValid()) ||
+          (std::tie(operand, iter) = ParseImmediate(osi, ose),
+           operand.IsValid())) {
+        osi = iter;
+        operands.push_back(operand);
+      } else {
+        return false;
+      }
+
+      std::pair<bool, llvm::StringRef::const_iterator> found_and_iter =
+          ConsumeChar(osi, ',', ose);
+      if (found_and_iter.first) {
+        osi = found_and_iter.second;
+      }
 
-    // So far the only supported flavor is "intel" on x86.  The base class will set this
-    // correctly coming in.
-    if (triple.getArch() == llvm::Triple::x86 || triple.getArch() == llvm::Triple::x86_64)
-    {
-        if (m_flavor == "intel")
-        {
-            flavor = 1;
-        }
-        else if (m_flavor == "att")
-        {
-            flavor = 0;
-        }
+      osi = ConsumeWhitespace(osi, ose);
     }
 
-    ArchSpec thumb_arch(arch);
-    if (triple.getArch() == llvm::Triple::arm)
-    {
-        std::string thumb_arch_name (thumb_arch.GetTriple().getArchName().str());
-        // Replace "arm" with "thumb" so we get all thumb variants correct
-        if (thumb_arch_name.size() > 3)
-        {
-            thumb_arch_name.erase(0,3);
-            thumb_arch_name.insert(0, "thumb");
-        }
-        else
-        {
-            thumb_arch_name = "thumbv8.2a";
-        }
-        thumb_arch.GetTriple().setArchName(llvm::StringRef(thumb_arch_name.c_str()));
+    DisassemblerSP disasm_sp = m_disasm_wp.lock();
+
+    if (disasm_sp && operands.size() > 1) {
+      // TODO tie this into the MC Disassembler's notion of clobbers.
+      switch (disasm_sp->GetArchitecture().GetMachine()) {
+      default:
+        break;
+      case llvm::Triple::x86:
+      case llvm::Triple::x86_64:
+        operands[operands.size() - 1].m_clobbered = true;
+        break;
+      case llvm::Triple::arm:
+        operands[0].m_clobbered = true;
+        break;
+      }
     }
 
-    // If no sub architecture specified then use the most recent arm architecture so the
-    // disassembler will return all instruction. Without it we will see a lot of unknow opcode
-    // in case the code uses instructions which are not available in the oldest arm version
-    // (used when no sub architecture is specified)
-    if (triple.getArch() == llvm::Triple::arm && triple.getSubArch() == llvm::Triple::NoSubArch)
-        triple.setArchName("armv8.2a");
+    if (Log *log =
+            lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)) {
+      StreamString ss;
 
-    const char *triple_str = triple.getTriple().c_str();
+      ss.Printf("[%s] expands to %zu operands:\n", operands_string,
+                operands.size());
+      for (const Operand &operand : operands) {
+        ss.PutCString("  ");
+        DumpOperand(operand, ss);
+        ss.PutCString("\n");
+      }
 
-    // ARM Cortex M0-M7 devices only execute thumb instructions
-    if (arch.IsAlwaysThumbInstructions ())
-    {
-        triple_str = thumb_arch.GetTriple().getTriple().c_str();
+      log->PutCString(ss.GetData());
     }
 
-    const char *cpu = "";
-    
-    switch (arch.GetCore())
-    {
-        case ArchSpec::eCore_mips32:
-        case ArchSpec::eCore_mips32el:
-            cpu = "mips32"; break;
-        case ArchSpec::eCore_mips32r2:
-        case ArchSpec::eCore_mips32r2el:
-            cpu = "mips32r2"; break;
-        case ArchSpec::eCore_mips32r3:
-        case ArchSpec::eCore_mips32r3el:
-            cpu = "mips32r3"; break;
-        case ArchSpec::eCore_mips32r5:
-        case ArchSpec::eCore_mips32r5el:
-            cpu = "mips32r5"; break;
-        case ArchSpec::eCore_mips32r6:
-        case ArchSpec::eCore_mips32r6el:
-            cpu = "mips32r6"; break;
-        case ArchSpec::eCore_mips64:
-        case ArchSpec::eCore_mips64el:
-            cpu = "mips64"; break;
-        case ArchSpec::eCore_mips64r2:
-        case ArchSpec::eCore_mips64r2el:
-            cpu = "mips64r2"; break;
-        case ArchSpec::eCore_mips64r3:
-        case ArchSpec::eCore_mips64r3el:
-            cpu = "mips64r3"; break;
-        case ArchSpec::eCore_mips64r5:
-        case ArchSpec::eCore_mips64r5el:
-            cpu = "mips64r5"; break;
-        case ArchSpec::eCore_mips64r6:
-        case ArchSpec::eCore_mips64r6el:
-            cpu = "mips64r6"; break;
-        default:
-            cpu = ""; break;
+    return true;
+  }
+
+  bool IsCall() override {
+    if (m_is_call == eLazyBoolCalculate) {
+      std::shared_ptr<DisassemblerLLVMC> disasm_sp(GetDisassembler());
+      if (disasm_sp) {
+        disasm_sp->Lock(this, NULL);
+        DataExtractor data;
+        if (m_opcode.GetData(data)) {
+          bool is_alternate_isa;
+          lldb::addr_t pc = m_address.GetFileAddress();
+
+          DisassemblerLLVMC::LLVMCDisassembler *mc_disasm_ptr =
+              GetDisasmToUse(is_alternate_isa);
+          const uint8_t *opcode_data = data.GetDataStart();
+          const size_t opcode_data_len = data.GetByteSize();
+          llvm::MCInst inst;
+          const size_t inst_size =
+              mc_disasm_ptr->GetMCInst(opcode_data, opcode_data_len, pc, inst);
+          if (inst_size == 0) {
+            m_is_call = eLazyBoolNo;
+          } else {
+            if (mc_disasm_ptr->IsCall(inst))
+              m_is_call = eLazyBoolYes;
+            else
+              m_is_call = eLazyBoolNo;
+          }
+        }
+        disasm_sp->Unlock();
+      }
     }
+    return m_is_call == eLazyBoolYes;
+  }
 
-    std::string features_str = "";
-    if (triple.getArch() == llvm::Triple::mips || triple.getArch() == llvm::Triple::mipsel
-        || triple.getArch() == llvm::Triple::mips64 || triple.getArch() == llvm::Triple::mips64el)
-    {
-        uint32_t arch_flags = arch.GetFlags ();
-        if (arch_flags & ArchSpec::eMIPSAse_msa)
-            features_str += "+msa,";
-        if (arch_flags & ArchSpec::eMIPSAse_dsp)
-            features_str += "+dsp,";
-        if (arch_flags & ArchSpec::eMIPSAse_dspr2)
-            features_str += "+dspr2,";
+protected:
+  std::weak_ptr<DisassemblerLLVMC> m_disasm_wp;
+  LazyBool m_does_branch;
+  LazyBool m_has_delay_slot;
+  LazyBool m_is_call;
+  bool m_is_valid;
+  bool m_using_file_addr;
+};
+
+DisassemblerLLVMC::LLVMCDisassembler::LLVMCDisassembler(
+    const char *triple, const char *cpu, const char *features_str,
+    unsigned flavor, DisassemblerLLVMC &owner)
+    : m_is_valid(true) {
+  std::string Error;
+  const llvm::Target *curr_target =
+      llvm::TargetRegistry::lookupTarget(triple, Error);
+  if (!curr_target) {
+    m_is_valid = false;
+    return;
+  }
+
+  m_instr_info_ap.reset(curr_target->createMCInstrInfo());
+  m_reg_info_ap.reset(curr_target->createMCRegInfo(triple));
+
+  m_subtarget_info_ap.reset(
+      curr_target->createMCSubtargetInfo(triple, cpu, features_str));
+
+  std::unique_ptr<llvm::MCRegisterInfo> reg_info(
+      curr_target->createMCRegInfo(triple));
+  m_asm_info_ap.reset(curr_target->createMCAsmInfo(*reg_info, triple));
+
+  if (m_instr_info_ap.get() == NULL || m_reg_info_ap.get() == NULL ||
+      m_subtarget_info_ap.get() == NULL || m_asm_info_ap.get() == NULL) {
+    m_is_valid = false;
+    return;
+  }
+
+  m_context_ap.reset(
+      new llvm::MCContext(m_asm_info_ap.get(), m_reg_info_ap.get(), 0));
+
+  m_disasm_ap.reset(curr_target->createMCDisassembler(
+      *m_subtarget_info_ap.get(), *m_context_ap.get()));
+  if (m_disasm_ap.get() && m_context_ap.get()) {
+    std::unique_ptr<llvm::MCRelocationInfo> RelInfo(
+        curr_target->createMCRelocationInfo(triple, *m_context_ap.get()));
+    if (!RelInfo) {
+      m_is_valid = false;
+      return;
     }
-    
-    m_disasm_ap.reset (new LLVMCDisassembler(triple_str, cpu, features_str.c_str(), flavor, *this));
-    if (!m_disasm_ap->IsValid())
-    {
-        // We use m_disasm_ap.get() to tell whether we are valid or not, so if this isn't good for some reason,
-        // we reset it, and then we won't be valid and FindPlugin will fail and we won't get used.
-        m_disasm_ap.reset();
+    std::unique_ptr<llvm::MCSymbolizer> symbolizer_up(
+        curr_target->createMCSymbolizer(
+            triple, NULL, DisassemblerLLVMC::SymbolLookupCallback,
+            (void *)&owner, m_context_ap.get(), std::move(RelInfo)));
+    m_disasm_ap->setSymbolizer(std::move(symbolizer_up));
+
+    unsigned asm_printer_variant;
+    if (flavor == ~0U)
+      asm_printer_variant = m_asm_info_ap->getAssemblerDialect();
+    else {
+      asm_printer_variant = flavor;
     }
 
-    llvm::Triple::ArchType llvm_arch = triple.getArch();
-
-    // For arm CPUs that can execute arm or thumb instructions, also create a thumb instruction disassembler.
-    if (llvm_arch == llvm::Triple::arm)
-    {
-        std::string thumb_triple(thumb_arch.GetTriple().getTriple());
-        m_alternate_disasm_ap.reset(new LLVMCDisassembler(thumb_triple.c_str(), "", "", flavor, *this));
-        if (!m_alternate_disasm_ap->IsValid())
-        {
-            m_disasm_ap.reset();
-            m_alternate_disasm_ap.reset();
-        }
+    m_instr_printer_ap.reset(curr_target->createMCInstPrinter(
+        llvm::Triple{triple}, asm_printer_variant, *m_asm_info_ap.get(),
+        *m_instr_info_ap.get(), *m_reg_info_ap.get()));
+    if (m_instr_printer_ap.get() == NULL) {
+      m_disasm_ap.reset();
+      m_is_valid = false;
     }
-    else if (llvm_arch == llvm::Triple::mips
-            || llvm_arch == llvm::Triple::mipsel
-            || llvm_arch == llvm::Triple::mips64
-            || llvm_arch == llvm::Triple::mips64el)
-    {
-        /* Create alternate disassembler for MIPS16 and microMIPS */
-        uint32_t arch_flags = arch.GetFlags ();
-        if (arch_flags & ArchSpec::eMIPSAse_mips16)
-            features_str += "+mips16,";
-        else if (arch_flags & ArchSpec::eMIPSAse_micromips)
-            features_str += "+micromips,";
-
-        m_alternate_disasm_ap.reset(new LLVMCDisassembler (triple_str, cpu, features_str.c_str(), flavor, *this));
-        if (!m_alternate_disasm_ap->IsValid())
-        {
-            m_disasm_ap.reset();
-            m_alternate_disasm_ap.reset();
-        }
+  } else
+    m_is_valid = false;
+}
+
+DisassemblerLLVMC::LLVMCDisassembler::~LLVMCDisassembler() = default;
+
+uint64_t DisassemblerLLVMC::LLVMCDisassembler::GetMCInst(
+    const uint8_t *opcode_data, size_t opcode_data_len, lldb::addr_t pc,
+    llvm::MCInst &mc_inst) {
+  llvm::ArrayRef<uint8_t> data(opcode_data, opcode_data_len);
+  llvm::MCDisassembler::DecodeStatus status;
+
+  uint64_t new_inst_size;
+  status = m_disasm_ap->getInstruction(mc_inst, new_inst_size, data, pc,
+                                       llvm::nulls(), llvm::nulls());
+  if (status == llvm::MCDisassembler::Success)
+    return new_inst_size;
+  else
+    return 0;
+}
+
+void DisassemblerLLVMC::LLVMCDisassembler::PrintMCInst(
+    llvm::MCInst &mc_inst, std::string &inst_string,
+    std::string &comments_string) {
+  llvm::raw_string_ostream inst_stream(inst_string);
+  llvm::raw_string_ostream comments_stream(comments_string);
+
+  m_instr_printer_ap->setCommentStream(comments_stream);
+  m_instr_printer_ap->printInst(&mc_inst, inst_stream, llvm::StringRef(),
+                                *m_subtarget_info_ap);
+  m_instr_printer_ap->setCommentStream(llvm::nulls());
+  comments_stream.flush();
+
+  static std::string g_newlines("\r\n");
+
+  for (size_t newline_pos = 0;
+       (newline_pos = comments_string.find_first_of(g_newlines, newline_pos)) !=
+       comments_string.npos;
+       /**/) {
+    comments_string.replace(comments_string.begin() + newline_pos,
+                            comments_string.begin() + newline_pos + 1, 1, ' ');
+  }
+}
+
+void DisassemblerLLVMC::LLVMCDisassembler::SetStyle(
+    bool use_hex_immed, HexImmediateStyle hex_style) {
+  m_instr_printer_ap->setPrintImmHex(use_hex_immed);
+  switch (hex_style) {
+  case eHexStyleC:
+    m_instr_printer_ap->setPrintHexStyle(llvm::HexStyle::C);
+    break;
+  case eHexStyleAsm:
+    m_instr_printer_ap->setPrintHexStyle(llvm::HexStyle::Asm);
+    break;
+  }
+}
+
+bool DisassemblerLLVMC::LLVMCDisassembler::CanBranch(llvm::MCInst &mc_inst) {
+  return m_instr_info_ap->get(mc_inst.getOpcode())
+      .mayAffectControlFlow(mc_inst, *m_reg_info_ap.get());
+}
+
+bool DisassemblerLLVMC::LLVMCDisassembler::HasDelaySlot(llvm::MCInst &mc_inst) {
+  return m_instr_info_ap->get(mc_inst.getOpcode()).hasDelaySlot();
+}
+
+bool DisassemblerLLVMC::LLVMCDisassembler::IsCall(llvm::MCInst &mc_inst) {
+  return m_instr_info_ap->get(mc_inst.getOpcode()).isCall();
+}
+
+DisassemblerLLVMC::DisassemblerLLVMC(const ArchSpec &arch,
+                                     const char *flavor_string)
+    : Disassembler(arch, flavor_string), m_exe_ctx(NULL), m_inst(NULL),
+      m_data_from_file(false) {
+  if (!FlavorValidForArchSpec(arch, m_flavor.c_str())) {
+    m_flavor.assign("default");
+  }
+
+  unsigned flavor = ~0U;
+  llvm::Triple triple = arch.GetTriple();
+
+  // So far the only supported flavor is "intel" on x86.  The base class will
+  // set this
+  // correctly coming in.
+  if (triple.getArch() == llvm::Triple::x86 ||
+      triple.getArch() == llvm::Triple::x86_64) {
+    if (m_flavor == "intel") {
+      flavor = 1;
+    } else if (m_flavor == "att") {
+      flavor = 0;
+    }
+  }
+
+  ArchSpec thumb_arch(arch);
+  if (triple.getArch() == llvm::Triple::arm) {
+    std::string thumb_arch_name(thumb_arch.GetTriple().getArchName().str());
+    // Replace "arm" with "thumb" so we get all thumb variants correct
+    if (thumb_arch_name.size() > 3) {
+      thumb_arch_name.erase(0, 3);
+      thumb_arch_name.insert(0, "thumb");
+    } else {
+      thumb_arch_name = "thumbv8.2a";
+    }
+    thumb_arch.GetTriple().setArchName(
+        llvm::StringRef(thumb_arch_name.c_str()));
+  }
+
+  // If no sub architecture specified then use the most recent arm architecture
+  // so the
+  // disassembler will return all instruction. Without it we will see a lot of
+  // unknow opcode
+  // in case the code uses instructions which are not available in the oldest
+  // arm version
+  // (used when no sub architecture is specified)
+  if (triple.getArch() == llvm::Triple::arm &&
+      triple.getSubArch() == llvm::Triple::NoSubArch)
+    triple.setArchName("armv8.2a");
+
+  const char *triple_str = triple.getTriple().c_str();
+
+  // ARM Cortex M0-M7 devices only execute thumb instructions
+  if (arch.IsAlwaysThumbInstructions()) {
+    triple_str = thumb_arch.GetTriple().getTriple().c_str();
+  }
+
+  const char *cpu = "";
+
+  switch (arch.GetCore()) {
+  case ArchSpec::eCore_mips32:
+  case ArchSpec::eCore_mips32el:
+    cpu = "mips32";
+    break;
+  case ArchSpec::eCore_mips32r2:
+  case ArchSpec::eCore_mips32r2el:
+    cpu = "mips32r2";
+    break;
+  case ArchSpec::eCore_mips32r3:
+  case ArchSpec::eCore_mips32r3el:
+    cpu = "mips32r3";
+    break;
+  case ArchSpec::eCore_mips32r5:
+  case ArchSpec::eCore_mips32r5el:
+    cpu = "mips32r5";
+    break;
+  case ArchSpec::eCore_mips32r6:
+  case ArchSpec::eCore_mips32r6el:
+    cpu = "mips32r6";
+    break;
+  case ArchSpec::eCore_mips64:
+  case ArchSpec::eCore_mips64el:
+    cpu = "mips64";
+    break;
+  case ArchSpec::eCore_mips64r2:
+  case ArchSpec::eCore_mips64r2el:
+    cpu = "mips64r2";
+    break;
+  case ArchSpec::eCore_mips64r3:
+  case ArchSpec::eCore_mips64r3el:
+    cpu = "mips64r3";
+    break;
+  case ArchSpec::eCore_mips64r5:
+  case ArchSpec::eCore_mips64r5el:
+    cpu = "mips64r5";
+    break;
+  case ArchSpec::eCore_mips64r6:
+  case ArchSpec::eCore_mips64r6el:
+    cpu = "mips64r6";
+    break;
+  default:
+    cpu = "";
+    break;
+  }
+
+  std::string features_str = "";
+  if (triple.getArch() == llvm::Triple::mips ||
+      triple.getArch() == llvm::Triple::mipsel ||
+      triple.getArch() == llvm::Triple::mips64 ||
+      triple.getArch() == llvm::Triple::mips64el) {
+    uint32_t arch_flags = arch.GetFlags();
+    if (arch_flags & ArchSpec::eMIPSAse_msa)
+      features_str += "+msa,";
+    if (arch_flags & ArchSpec::eMIPSAse_dsp)
+      features_str += "+dsp,";
+    if (arch_flags & ArchSpec::eMIPSAse_dspr2)
+      features_str += "+dspr2,";
+  }
+
+  m_disasm_ap.reset(new LLVMCDisassembler(triple_str, cpu, features_str.c_str(),
+                                          flavor, *this));
+  if (!m_disasm_ap->IsValid()) {
+    // We use m_disasm_ap.get() to tell whether we are valid or not, so if this
+    // isn't good for some reason,
+    // we reset it, and then we won't be valid and FindPlugin will fail and we
+    // won't get used.
+    m_disasm_ap.reset();
+  }
+
+  llvm::Triple::ArchType llvm_arch = triple.getArch();
+
+  // For arm CPUs that can execute arm or thumb instructions, also create a
+  // thumb instruction disassembler.
+  if (llvm_arch == llvm::Triple::arm) {
+    std::string thumb_triple(thumb_arch.GetTriple().getTriple());
+    m_alternate_disasm_ap.reset(
+        new LLVMCDisassembler(thumb_triple.c_str(), "", "", flavor, *this));
+    if (!m_alternate_disasm_ap->IsValid()) {
+      m_disasm_ap.reset();
+      m_alternate_disasm_ap.reset();
+    }
+  } else if (llvm_arch == llvm::Triple::mips ||
+             llvm_arch == llvm::Triple::mipsel ||
+             llvm_arch == llvm::Triple::mips64 ||
+             llvm_arch == llvm::Triple::mips64el) {
+    /* Create alternate disassembler for MIPS16 and microMIPS */
+    uint32_t arch_flags = arch.GetFlags();
+    if (arch_flags & ArchSpec::eMIPSAse_mips16)
+      features_str += "+mips16,";
+    else if (arch_flags & ArchSpec::eMIPSAse_micromips)
+      features_str += "+micromips,";
+
+    m_alternate_disasm_ap.reset(new LLVMCDisassembler(
+        triple_str, cpu, features_str.c_str(), flavor, *this));
+    if (!m_alternate_disasm_ap->IsValid()) {
+      m_disasm_ap.reset();
+      m_alternate_disasm_ap.reset();
     }
+  }
 }
 
 DisassemblerLLVMC::~DisassemblerLLVMC() = default;
 
-Disassembler *
-DisassemblerLLVMC::CreateInstance (const ArchSpec &arch, const char *flavor)
-{
-    if (arch.GetTriple().getArch() != llvm::Triple::UnknownArch)
-    {
-        std::unique_ptr<DisassemblerLLVMC> disasm_ap (new DisassemblerLLVMC(arch, flavor));
+Disassembler *DisassemblerLLVMC::CreateInstance(const ArchSpec &arch,
+                                                const char *flavor) {
+  if (arch.GetTriple().getArch() != llvm::Triple::UnknownArch) {
+    std::unique_ptr<DisassemblerLLVMC> disasm_ap(
+        new DisassemblerLLVMC(arch, flavor));
 
-        if (disasm_ap.get() && disasm_ap->IsValid())
-            return disasm_ap.release();
-    }
-    return NULL;
+    if (disasm_ap.get() && disasm_ap->IsValid())
+      return disasm_ap.release();
+  }
+  return NULL;
 }
 
-size_t
-DisassemblerLLVMC::DecodeInstructions (const Address &base_addr,
-                                       const DataExtractor& data,
-                                       lldb::offset_t data_offset,
-                                       size_t num_instructions,
-                                       bool append,
-                                       bool data_from_file)
-{
-    if (!append)
-        m_instruction_list.Clear();
+size_t DisassemblerLLVMC::DecodeInstructions(const Address &base_addr,
+                                             const DataExtractor &data,
+                                             lldb::offset_t data_offset,
+                                             size_t num_instructions,
+                                             bool append, bool data_from_file) {
+  if (!append)
+    m_instruction_list.Clear();
 
-    if (!IsValid())
-        return 0;
+  if (!IsValid())
+    return 0;
 
-    m_data_from_file = data_from_file;
-    uint32_t data_cursor = data_offset;
-    const size_t data_byte_size = data.GetByteSize();
-    uint32_t instructions_parsed = 0;
-    Address inst_addr(base_addr);
+  m_data_from_file = data_from_file;
+  uint32_t data_cursor = data_offset;
+  const size_t data_byte_size = data.GetByteSize();
+  uint32_t instructions_parsed = 0;
+  Address inst_addr(base_addr);
 
-    while (data_cursor < data_byte_size && instructions_parsed < num_instructions)
-    {
+  while (data_cursor < data_byte_size &&
+         instructions_parsed < num_instructions) {
 
-        AddressClass address_class = eAddressClassCode;
+    AddressClass address_class = eAddressClassCode;
 
-        if (m_alternate_disasm_ap.get() != NULL)
-            address_class = inst_addr.GetAddressClass ();
+    if (m_alternate_disasm_ap.get() != NULL)
+      address_class = inst_addr.GetAddressClass();
 
-        InstructionSP inst_sp(new InstructionLLVMC(*this,
-                                                   inst_addr,
-                                                   address_class));
+    InstructionSP inst_sp(
+        new InstructionLLVMC(*this, inst_addr, address_class));
 
-        if (!inst_sp)
-            break;
+    if (!inst_sp)
+      break;
 
-        uint32_t inst_size = inst_sp->Decode(*this, data, data_cursor);
+    uint32_t inst_size = inst_sp->Decode(*this, data, data_cursor);
 
-        if (inst_size == 0)
-            break;
+    if (inst_size == 0)
+      break;
 
-        m_instruction_list.Append(inst_sp);
-        data_cursor += inst_size;
-        inst_addr.Slide(inst_size);
-        instructions_parsed++;
-    }
+    m_instruction_list.Append(inst_sp);
+    data_cursor += inst_size;
+    inst_addr.Slide(inst_size);
+    instructions_parsed++;
+  }
 
-    return data_cursor - data_offset;
+  return data_cursor - data_offset;
 }
 
-void
-DisassemblerLLVMC::Initialize()
-{
-    PluginManager::RegisterPlugin (GetPluginNameStatic(),
-                                   "Disassembler that uses LLVM MC to disassemble i386, x86_64, ARM, and ARM64.",
-                                   CreateInstance);
-
-    llvm::InitializeAllTargetInfos();
-    llvm::InitializeAllTargetMCs();
-    llvm::InitializeAllAsmParsers();
-    llvm::InitializeAllDisassemblers();
-}
+void DisassemblerLLVMC::Initialize() {
+  PluginManager::RegisterPlugin(GetPluginNameStatic(),
+                                "Disassembler that uses LLVM MC to disassemble "
+                                "i386, x86_64, ARM, and ARM64.",
+                                CreateInstance);
 
-void
-DisassemblerLLVMC::Terminate()
-{
-    PluginManager::UnregisterPlugin (CreateInstance);
+  llvm::InitializeAllTargetInfos();
+  llvm::InitializeAllTargetMCs();
+  llvm::InitializeAllAsmParsers();
+  llvm::InitializeAllDisassemblers();
 }
 
+void DisassemblerLLVMC::Terminate() {
+  PluginManager::UnregisterPlugin(CreateInstance);
+}
 
-ConstString
-DisassemblerLLVMC::GetPluginNameStatic()
-{
-    static ConstString g_name("llvm-mc");
-    return g_name;
+ConstString DisassemblerLLVMC::GetPluginNameStatic() {
+  static ConstString g_name("llvm-mc");
+  return g_name;
 }
 
-int DisassemblerLLVMC::OpInfoCallback (void *disassembler,
-                                       uint64_t pc,
-                                       uint64_t offset,
-                                       uint64_t size,
-                                       int tag_type,
-                                       void *tag_bug)
-{
-    return static_cast<DisassemblerLLVMC*>(disassembler)->OpInfo (pc,
-                                                                  offset,
-                                                                  size,
-                                                                  tag_type,
-                                                                  tag_bug);
+int DisassemblerLLVMC::OpInfoCallback(void *disassembler, uint64_t pc,
+                                      uint64_t offset, uint64_t size,
+                                      int tag_type, void *tag_bug) {
+  return static_cast<DisassemblerLLVMC *>(disassembler)
+      ->OpInfo(pc, offset, size, tag_type, tag_bug);
 }
 
-const char *DisassemblerLLVMC::SymbolLookupCallback (void *disassembler,
-                                                     uint64_t value,
-                                                     uint64_t *type,
-                                                     uint64_t pc,
-                                                     const char **name)
-{
-    return static_cast<DisassemblerLLVMC*>(disassembler)->SymbolLookup(value,
-                                                                       type,
-                                                                       pc,
-                                                                       name);
+const char *DisassemblerLLVMC::SymbolLookupCallback(void *disassembler,
+                                                    uint64_t value,
+                                                    uint64_t *type, uint64_t pc,
+                                                    const char **name) {
+  return static_cast<DisassemblerLLVMC *>(disassembler)
+      ->SymbolLookup(value, type, pc, name);
 }
 
-bool
-DisassemblerLLVMC::FlavorValidForArchSpec (const lldb_private::ArchSpec &arch, const char *flavor)
-{
-    llvm::Triple triple = arch.GetTriple();
-    if (flavor == NULL || strcmp (flavor, "default") == 0)
-        return true;
-
-    if (triple.getArch() == llvm::Triple::x86 || triple.getArch() == llvm::Triple::x86_64)
-    {
-        if (strcmp (flavor, "intel") == 0 || strcmp (flavor, "att") == 0)
-            return true;
-        else
-            return false;
-    }
+bool DisassemblerLLVMC::FlavorValidForArchSpec(
+    const lldb_private::ArchSpec &arch, const char *flavor) {
+  llvm::Triple triple = arch.GetTriple();
+  if (flavor == NULL || strcmp(flavor, "default") == 0)
+    return true;
+
+  if (triple.getArch() == llvm::Triple::x86 ||
+      triple.getArch() == llvm::Triple::x86_64) {
+    if (strcmp(flavor, "intel") == 0 || strcmp(flavor, "att") == 0)
+      return true;
     else
-        return false;
+      return false;
+  } else
+    return false;
 }
 
-int DisassemblerLLVMC::OpInfo (uint64_t PC,
-                               uint64_t Offset,
-                               uint64_t Size,
-                               int tag_type,
-                               void *tag_bug)
-{
-    switch (tag_type)
-    {
-    default:
-        break;
-    case 1:
-        memset (tag_bug, 0, sizeof(::LLVMOpInfo1));
-        break;
-    }
-    return 0;
+int DisassemblerLLVMC::OpInfo(uint64_t PC, uint64_t Offset, uint64_t Size,
+                              int tag_type, void *tag_bug) {
+  switch (tag_type) {
+  default:
+    break;
+  case 1:
+    memset(tag_bug, 0, sizeof(::LLVMOpInfo1));
+    break;
+  }
+  return 0;
 }
 
-const char *DisassemblerLLVMC::SymbolLookup (uint64_t value,
-                                             uint64_t *type_ptr,
-                                             uint64_t pc,
-                                             const char **name)
-{
-    if (*type_ptr)
-    {
-        if (m_exe_ctx && m_inst)
-        {
-            //std::string remove_this_prior_to_checkin;
-            Target *target = m_exe_ctx ? m_exe_ctx->GetTargetPtr() : NULL;
-            Address value_so_addr;
-            Address pc_so_addr;
-            if (m_inst->UsingFileAddress())
-            {
-                ModuleSP module_sp(m_inst->GetAddress().GetModule());
-                if (module_sp)
-                {
-                    module_sp->ResolveFileAddress(value, value_so_addr);
-                    module_sp->ResolveFileAddress(pc, pc_so_addr);
-                }
-            }
-            else if (target && !target->GetSectionLoadList().IsEmpty())
-            {
-                target->GetSectionLoadList().ResolveLoadAddress(value, value_so_addr);
-                target->GetSectionLoadList().ResolveLoadAddress(pc, pc_so_addr);
-            }
+const char *DisassemblerLLVMC::SymbolLookup(uint64_t value, uint64_t *type_ptr,
+                                            uint64_t pc, const char **name) {
+  if (*type_ptr) {
+    if (m_exe_ctx && m_inst) {
+      // std::string remove_this_prior_to_checkin;
+      Target *target = m_exe_ctx ? m_exe_ctx->GetTargetPtr() : NULL;
+      Address value_so_addr;
+      Address pc_so_addr;
+      if (m_inst->UsingFileAddress()) {
+        ModuleSP module_sp(m_inst->GetAddress().GetModule());
+        if (module_sp) {
+          module_sp->ResolveFileAddress(value, value_so_addr);
+          module_sp->ResolveFileAddress(pc, pc_so_addr);
+        }
+      } else if (target && !target->GetSectionLoadList().IsEmpty()) {
+        target->GetSectionLoadList().ResolveLoadAddress(value, value_so_addr);
+        target->GetSectionLoadList().ResolveLoadAddress(pc, pc_so_addr);
+      }
+
+      SymbolContext sym_ctx;
+      const uint32_t resolve_scope =
+          eSymbolContextFunction | eSymbolContextSymbol;
+      if (pc_so_addr.IsValid() && pc_so_addr.GetModule()) {
+        pc_so_addr.GetModule()->ResolveSymbolContextForAddress(
+            pc_so_addr, resolve_scope, sym_ctx);
+      }
+
+      if (value_so_addr.IsValid() && value_so_addr.GetSection()) {
+        StreamString ss;
+
+        bool format_omitting_current_func_name = false;
+        if (sym_ctx.symbol || sym_ctx.function) {
+          AddressRange range;
+          if (sym_ctx.GetAddressRange(resolve_scope, 0, false, range) &&
+              range.GetBaseAddress().IsValid() &&
+              range.ContainsLoadAddress(value_so_addr, target)) {
+            format_omitting_current_func_name = true;
+          }
+        }
 
-            SymbolContext sym_ctx;
-            const uint32_t resolve_scope = eSymbolContextFunction | eSymbolContextSymbol;
-            if (pc_so_addr.IsValid() && pc_so_addr.GetModule())
-            {
-                pc_so_addr.GetModule()->ResolveSymbolContextForAddress (pc_so_addr, resolve_scope, sym_ctx);
-            }
+        // If the "value" address (the target address we're symbolicating)
+        // is inside the same SymbolContext as the current instruction pc
+        // (pc_so_addr), don't print the full function name - just print it
+        // with DumpStyleNoFunctionName style, e.g. "<+36>".
+        if (format_omitting_current_func_name) {
+          value_so_addr.Dump(&ss, target, Address::DumpStyleNoFunctionName,
+                             Address::DumpStyleSectionNameOffset);
+        } else {
+          value_so_addr.Dump(
+              &ss, target,
+              Address::DumpStyleResolvedDescriptionNoFunctionArguments,
+              Address::DumpStyleSectionNameOffset);
+        }
 
-            if (value_so_addr.IsValid() && value_so_addr.GetSection())
-            {
-                StreamString ss;
-
-                bool format_omitting_current_func_name = false;
-                if (sym_ctx.symbol || sym_ctx.function)
-                {
-                    AddressRange range;
-                    if (sym_ctx.GetAddressRange (resolve_scope, 0, false, range) 
-                        && range.GetBaseAddress().IsValid() 
-                        && range.ContainsLoadAddress (value_so_addr, target))
-                    {
-                        format_omitting_current_func_name = true;
-                    }
-                }
-                
-                // If the "value" address (the target address we're symbolicating)
-                // is inside the same SymbolContext as the current instruction pc
-                // (pc_so_addr), don't print the full function name - just print it
-                // with DumpStyleNoFunctionName style, e.g. "<+36>".
-                if (format_omitting_current_func_name)
-                {
-                    value_so_addr.Dump (&ss,
-                                        target,
-                                        Address::DumpStyleNoFunctionName,
-                                        Address::DumpStyleSectionNameOffset);
-                }
-                else
-                {
-                    value_so_addr.Dump (&ss,
-                                        target,
-                                        Address::DumpStyleResolvedDescriptionNoFunctionArguments,
-                                        Address::DumpStyleSectionNameOffset);
-                }
-
-                if (!ss.GetString().empty())
-                {
-                    // If Address::Dump returned a multi-line description, most commonly seen when we
-                    // have multiple levels of inlined functions at an address, only show the first line.
-                    std::string &str(ss.GetString());
-                    size_t first_eol_char = str.find_first_of ("\r\n");
-                    if (first_eol_char != std::string::npos)
-                    {
-                        str.erase (first_eol_char);
-                    }
-                    m_inst->AppendComment(ss.GetString());
-                }
-            }
+        if (!ss.GetString().empty()) {
+          // If Address::Dump returned a multi-line description, most commonly
+          // seen when we
+          // have multiple levels of inlined functions at an address, only show
+          // the first line.
+          std::string &str(ss.GetString());
+          size_t first_eol_char = str.find_first_of("\r\n");
+          if (first_eol_char != std::string::npos) {
+            str.erase(first_eol_char);
+          }
+          m_inst->AppendComment(ss.GetString());
         }
+      }
     }
+  }
 
-    *type_ptr = LLVMDisassembler_ReferenceType_InOut_None;
-    *name = NULL;
-    return NULL;
+  *type_ptr = LLVMDisassembler_ReferenceType_InOut_None;
+  *name = NULL;
+  return NULL;
 }
 
 //------------------------------------------------------------------
 // PluginInterface protocol
 //------------------------------------------------------------------
-ConstString
-DisassemblerLLVMC::GetPluginName()
-{
-    return GetPluginNameStatic();
-}
+ConstString DisassemblerLLVMC::GetPluginName() { return GetPluginNameStatic(); }
 
-uint32_t
-DisassemblerLLVMC::GetPluginVersion()
-{
-    return 1;
-}
+uint32_t DisassemblerLLVMC::GetPluginVersion() { return 1; }
diff --git a/lldb/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.h b/lldb/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.h
index f2f54d39399..26bed7ee0d7 100644
--- a/lldb/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.h
+++ b/lldb/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.h
@@ -25,148 +25,128 @@
 #include "lldb/Core/PluginManager.h"
 
 // Opaque references to C++ Objects in LLVM's MC.
-namespace llvm
-{
-    class MCContext;
-    class MCInst;
-    class MCInstrInfo;
-    class MCRegisterInfo;
-    class MCDisassembler;
-    class MCInstPrinter;
-    class MCAsmInfo;
-    class MCSubtargetInfo;
+namespace llvm {
+class MCContext;
+class MCInst;
+class MCInstrInfo;
+class MCRegisterInfo;
+class MCDisassembler;
+class MCInstPrinter;
+class MCAsmInfo;
+class MCSubtargetInfo;
 } // namespace llvm
 
 class InstructionLLVMC;
 
-class DisassemblerLLVMC : public lldb_private::Disassembler
-{
-    // Since we need to make two actual MC Disassemblers for ARM (ARM & THUMB), and there's a bit of goo to set up and own
-    // in the MC disassembler world, I added this class to manage the actual disassemblers.
-    class LLVMCDisassembler
-    {
-    public:
-        LLVMCDisassembler (const char *triple, const char *cpu, const char *features_str, unsigned flavor, DisassemblerLLVMC &owner);
-
-        ~LLVMCDisassembler();
-
-        uint64_t GetMCInst (const uint8_t *opcode_data, size_t opcode_data_len, lldb::addr_t pc, llvm::MCInst &mc_inst);
-        void PrintMCInst (llvm::MCInst &mc_inst, std::string &inst_string, std::string &comments_string);
-        void     SetStyle (bool use_hex_immed, HexImmediateStyle hex_style);
-        bool     CanBranch (llvm::MCInst &mc_inst);
-        bool     HasDelaySlot (llvm::MCInst &mc_inst);
-        bool     IsCall (llvm::MCInst &mc_inst);
-        bool     IsValid()
-        {
-            return m_is_valid;
-        }
-
-    private:
-        bool                                     m_is_valid;
-        std::unique_ptr<llvm::MCContext>         m_context_ap;
-        std::unique_ptr<llvm::MCAsmInfo>         m_asm_info_ap;
-        std::unique_ptr<llvm::MCSubtargetInfo>   m_subtarget_info_ap;
-        std::unique_ptr<llvm::MCInstrInfo>       m_instr_info_ap;
-        std::unique_ptr<llvm::MCRegisterInfo>    m_reg_info_ap;
-        std::unique_ptr<llvm::MCInstPrinter>     m_instr_printer_ap;
-        std::unique_ptr<llvm::MCDisassembler>    m_disasm_ap;
-    };
+class DisassemblerLLVMC : public lldb_private::Disassembler {
+  // Since we need to make two actual MC Disassemblers for ARM (ARM & THUMB),
+  // and there's a bit of goo to set up and own
+  // in the MC disassembler world, I added this class to manage the actual
+  // disassemblers.
+  class LLVMCDisassembler {
+  public:
+    LLVMCDisassembler(const char *triple, const char *cpu,
+                      const char *features_str, unsigned flavor,
+                      DisassemblerLLVMC &owner);
+
+    ~LLVMCDisassembler();
+
+    uint64_t GetMCInst(const uint8_t *opcode_data, size_t opcode_data_len,
+                       lldb::addr_t pc, llvm::MCInst &mc_inst);
+    void PrintMCInst(llvm::MCInst &mc_inst, std::string &inst_string,
+                     std::string &comments_string);
+    void SetStyle(bool use_hex_immed, HexImmediateStyle hex_style);
+    bool CanBranch(llvm::MCInst &mc_inst);
+    bool HasDelaySlot(llvm::MCInst &mc_inst);
+    bool IsCall(llvm::MCInst &mc_inst);
+    bool IsValid() { return m_is_valid; }
+
+  private:
+    bool m_is_valid;
+    std::unique_ptr<llvm::MCContext> m_context_ap;
+    std::unique_ptr<llvm::MCAsmInfo> m_asm_info_ap;
+    std::unique_ptr<llvm::MCSubtargetInfo> m_subtarget_info_ap;
+    std::unique_ptr<llvm::MCInstrInfo> m_instr_info_ap;
+    std::unique_ptr<llvm::MCRegisterInfo> m_reg_info_ap;
+    std::unique_ptr<llvm::MCInstPrinter> m_instr_printer_ap;
+    std::unique_ptr<llvm::MCDisassembler> m_disasm_ap;
+  };
 
 public:
-    DisassemblerLLVMC(const lldb_private::ArchSpec &arch, const char *flavor /* = NULL */);
+  DisassemblerLLVMC(const lldb_private::ArchSpec &arch,
+                    const char *flavor /* = NULL */);
 
-    ~DisassemblerLLVMC() override;
+  ~DisassemblerLLVMC() override;
 
-    //------------------------------------------------------------------
-    // Static Functions
-    //------------------------------------------------------------------
-    static void
-    Initialize();
+  //------------------------------------------------------------------
+  // Static Functions
+  //------------------------------------------------------------------
+  static void Initialize();
 
-    static void
-    Terminate();
+  static void Terminate();
 
-    static lldb_private::ConstString
-    GetPluginNameStatic();
+  static lldb_private::ConstString GetPluginNameStatic();
 
-    static lldb_private::Disassembler *
-    CreateInstance(const lldb_private::ArchSpec &arch, const char *flavor);
+  static lldb_private::Disassembler *
+  CreateInstance(const lldb_private::ArchSpec &arch, const char *flavor);
 
-    size_t
-    DecodeInstructions(const lldb_private::Address &base_addr,
-                       const lldb_private::DataExtractor& data,
-                       lldb::offset_t data_offset,
-                       size_t num_instructions,
-                       bool append,
-                       bool data_from_file) override;
+  size_t DecodeInstructions(const lldb_private::Address &base_addr,
+                            const lldb_private::DataExtractor &data,
+                            lldb::offset_t data_offset, size_t num_instructions,
+                            bool append, bool data_from_file) override;
 
-    //------------------------------------------------------------------
-    // PluginInterface protocol
-    //------------------------------------------------------------------
-    lldb_private::ConstString
-    GetPluginName() override;
+  //------------------------------------------------------------------
+  // PluginInterface protocol
+  //------------------------------------------------------------------
+  lldb_private::ConstString GetPluginName() override;
 
-    uint32_t
-    GetPluginVersion() override;
+  uint32_t GetPluginVersion() override;
 
 protected:
-    friend class InstructionLLVMC;
-
-    bool
-    FlavorValidForArchSpec(const lldb_private::ArchSpec &arch, const char *flavor) override;
-
-    bool
-    IsValid()
-    {
-        return (m_disasm_ap.get() != NULL && m_disasm_ap->IsValid());
-    }
-
-    int OpInfo(uint64_t PC,
-               uint64_t Offset,
-               uint64_t Size,
-               int TagType,
-               void *TagBug);
-
-    const char *SymbolLookup (uint64_t ReferenceValue,
-                              uint64_t *ReferenceType,
-                              uint64_t ReferencePC,
-                              const char **ReferenceName);
-
-    static int OpInfoCallback (void *DisInfo,
-                               uint64_t PC,
-                               uint64_t Offset,
-                               uint64_t Size,
-                               int TagType,
-                               void *TagBug);
-
-    static const char *SymbolLookupCallback(void *DisInfo,
-                                            uint64_t ReferenceValue,
-                                            uint64_t *ReferenceType,
-                                            uint64_t ReferencePC,
-                                            const char **ReferenceName);
-
-    void Lock(InstructionLLVMC *inst,
-              const lldb_private::ExecutionContext *exe_ctx)
-    {
-        m_mutex.lock();
-        m_inst = inst;
-        m_exe_ctx = exe_ctx;
-    }
-
-    void Unlock()
-    {
-        m_inst = NULL;
-        m_exe_ctx = NULL;
-        m_mutex.unlock();
-    }
-
-    const lldb_private::ExecutionContext *m_exe_ctx;
-    InstructionLLVMC *m_inst;
-    std::mutex m_mutex;
-    bool m_data_from_file;
-
-    std::unique_ptr<LLVMCDisassembler> m_disasm_ap;
-    std::unique_ptr<LLVMCDisassembler> m_alternate_disasm_ap;
+  friend class InstructionLLVMC;
+
+  bool FlavorValidForArchSpec(const lldb_private::ArchSpec &arch,
+                              const char *flavor) override;
+
+  bool IsValid() {
+    return (m_disasm_ap.get() != NULL && m_disasm_ap->IsValid());
+  }
+
+  int OpInfo(uint64_t PC, uint64_t Offset, uint64_t Size, int TagType,
+             void *TagBug);
+
+  const char *SymbolLookup(uint64_t ReferenceValue, uint64_t *ReferenceType,
+                           uint64_t ReferencePC, const char **ReferenceName);
+
+  static int OpInfoCallback(void *DisInfo, uint64_t PC, uint64_t Offset,
+                            uint64_t Size, int TagType, void *TagBug);
+
+  static const char *SymbolLookupCallback(void *DisInfo,
+                                          uint64_t ReferenceValue,
+                                          uint64_t *ReferenceType,
+                                          uint64_t ReferencePC,
+                                          const char **ReferenceName);
+
+  void Lock(InstructionLLVMC *inst,
+            const lldb_private::ExecutionContext *exe_ctx) {
+    m_mutex.lock();
+    m_inst = inst;
+    m_exe_ctx = exe_ctx;
+  }
+
+  void Unlock() {
+    m_inst = NULL;
+    m_exe_ctx = NULL;
+    m_mutex.unlock();
+  }
+
+  const lldb_private::ExecutionContext *m_exe_ctx;
+  InstructionLLVMC *m_inst;
+  std::mutex m_mutex;
+  bool m_data_from_file;
+
+  std::unique_ptr<LLVMCDisassembler> m_disasm_ap;
+  std::unique_ptr<LLVMCDisassembler> m_alternate_disasm_ap;
 };
 
 #endif // liblldb_DisassemblerLLVM_h_