lldb/source/API/SBInstructionList.cpp

   1 //===-- SBInstructionList.cpp ---------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "lldb/API/SBInstructionList.h"
  10 #include "lldb/API/SBAddress.h"
  11 #include "lldb/API/SBFile.h"
  12 #include "lldb/API/SBInstruction.h"
  13 #include "lldb/API/SBStream.h"
  14 #include "lldb/Core/Disassembler.h"
  15 #include "lldb/Core/Module.h"
  16 #include "lldb/Host/StreamFile.h"
  17 #include "lldb/Symbol/SymbolContext.h"
  18 #include "lldb/Utility/Instrumentation.h"
  19 #include "lldb/Utility/Stream.h"
  20
  21 using namespace lldb;
  22 using namespace lldb_private;
  23
  24 SBInstructionList::SBInstructionList() { LLDB_INSTRUMENT_VA(this); }
  25
  26 SBInstructionList::SBInstructionList(const SBInstructionList &rhs)
  27     : m_opaque_sp(rhs.m_opaque_sp) {
  28   LLDB_INSTRUMENT_VA(this, rhs);
  29 }
  30
  31 const SBInstructionList &SBInstructionList::
  32 operator=(const SBInstructionList &rhs) {
  33   LLDB_INSTRUMENT_VA(this, rhs);
  34
  35   if (this != &rhs)
  36     m_opaque_sp = rhs.m_opaque_sp;
  37   return *this;
  38 }
  39
  40 SBInstructionList::~SBInstructionList() = default;
  41
  42 bool SBInstructionList::IsValid() const {
  43   LLDB_INSTRUMENT_VA(this);
  44   return this->operator bool();
  45 }
  46 SBInstructionList::operator bool() const {
  47   LLDB_INSTRUMENT_VA(this);
  48
  49   return m_opaque_sp.get() != nullptr;
  50 }
  51
  52 size_t SBInstructionList::GetSize() {
  53   LLDB_INSTRUMENT_VA(this);
  54
  55   if (m_opaque_sp)
  56     return m_opaque_sp->GetInstructionList().GetSize();
  57   return 0;
  58 }
  59
  60 SBInstruction SBInstructionList::GetInstructionAtIndex(uint32_t idx) {
  61   LLDB_INSTRUMENT_VA(this, idx);
  62
  63   SBInstruction inst;
  64   if (m_opaque_sp && idx < m_opaque_sp->GetInstructionList().GetSize())
  65     inst.SetOpaque(
  66         m_opaque_sp,
  67         m_opaque_sp->GetInstructionList().GetInstructionAtIndex(idx));
  68   return inst;
  69 }
  70
  71 size_t SBInstructionList::GetInstructionsCount(const SBAddress &start,
  72                                                const SBAddress &end,
  73                                                bool canSetBreakpoint) {
  74   LLDB_INSTRUMENT_VA(this, start, end, canSetBreakpoint);
  75
  76   size_t num_instructions = GetSize();
  77   size_t i = 0;
  78   SBAddress addr;
  79   size_t lower_index = 0;
  80   size_t upper_index = 0;
  81   size_t instructions_to_skip = 0;
  82   for (i = 0; i < num_instructions; ++i) {
  83     addr = GetInstructionAtIndex(i).GetAddress();
  84     if (start == addr)
  85       lower_index = i;
  86     if (end == addr)
  87       upper_index = i;
  88   }
  89   if (canSetBreakpoint)
  90     for (i = lower_index; i <= upper_index; ++i) {
  91       SBInstruction insn = GetInstructionAtIndex(i);
  92       if (!insn.CanSetBreakpoint())
  93         ++instructions_to_skip;
  94     }
  95   return upper_index - lower_index - instructions_to_skip;
  96 }
  97
  98 void SBInstructionList::Clear() {
  99   LLDB_INSTRUMENT_VA(this);
 100
 101   m_opaque_sp.reset();
 102 }
 103
 104 void SBInstructionList::AppendInstruction(SBInstruction insn) {
 105   LLDB_INSTRUMENT_VA(this, insn);
 106 }
 107
 108 void SBInstructionList::SetDisassembler(const lldb::DisassemblerSP &opaque_sp) {
 109   m_opaque_sp = opaque_sp;
 110 }
 111
 112 void SBInstructionList::Print(FILE *out) {
 113   LLDB_INSTRUMENT_VA(this, out);
 114   if (out == nullptr)
 115     return;
 116   StreamFile stream(out, false);
 117   GetDescription(stream);
 118 }
 119
 120 void SBInstructionList::Print(SBFile out) {
 121   LLDB_INSTRUMENT_VA(this, out);
 122   if (!out.IsValid())
 123     return;
 124   StreamFile stream(out.m_opaque_sp);
 125   GetDescription(stream);
 126 }
 127
 128 void SBInstructionList::Print(FileSP out_sp) {
 129   LLDB_INSTRUMENT_VA(this, out_sp);
 130   if (!out_sp || !out_sp->IsValid())
 131     return;
 132   StreamFile stream(out_sp);
 133   GetDescription(stream);
 134 }
 135
 136 bool SBInstructionList::GetDescription(lldb::SBStream &stream) {
 137   LLDB_INSTRUMENT_VA(this, stream);
 138   return GetDescription(stream.ref());
 139 }
 140
 141 bool SBInstructionList::GetDescription(Stream &sref) {
 142
 143   if (m_opaque_sp) {
 144     size_t num_instructions = GetSize();
 145     if (num_instructions) {
 146       // Call the ref() to make sure a stream is created if one deesn't exist
 147       // already inside description...
 148       const uint32_t max_opcode_byte_size =
 149           m_opaque_sp->GetInstructionList().GetMaxOpcocdeByteSize();
 150       FormatEntity::Entry format;
 151       FormatEntity::Parse("${addr}: ", format);
 152       SymbolContext sc;
 153       SymbolContext prev_sc;
 154       for (size_t i = 0; i < num_instructions; ++i) {
 155         Instruction *inst =
 156             m_opaque_sp->GetInstructionList().GetInstructionAtIndex(i).get();
 157         if (inst == nullptr)
 158           break;
 159
 160         const Address &addr = inst->GetAddress();
 161         prev_sc = sc;
 162         ModuleSP module_sp(addr.GetModule());
 163         if (module_sp) {
 164           module_sp->ResolveSymbolContextForAddress(
 165               addr, eSymbolContextEverything, sc);
 166         }
 167
 168         inst->Dump(&sref, max_opcode_byte_size, true, false,
 169                    /*show_control_flow_kind=*/false, nullptr, &sc, &prev_sc,
 170                    &format, 0);
 171         sref.EOL();
 172       }
 173       return true;
 174     }
 175   }
 176   return false;
 177 }
 178
 179 bool SBInstructionList::DumpEmulationForAllInstructions(const char *triple) {
 180   LLDB_INSTRUMENT_VA(this, triple);
 181
 182   if (m_opaque_sp) {
 183     size_t len = GetSize();
 184     for (size_t i = 0; i < len; ++i) {
 185       if (!GetInstructionAtIndex((uint32_t)i).DumpEmulation(triple))
 186         return false;
 187     }
 188   }
 189   return true;
 190 }