contrib/llvm/tools/lldb/source/API/SBInstructionList.cpp

   1 //===-- SBInstructionList.cpp -----------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/API/SBInstructionList.h"
  11 #include "lldb/API/SBInstruction.h"
  12 #include "lldb/API/SBAddress.h"
  13 #include "lldb/API/SBStream.h"
  14 #include "lldb/Core/Disassembler.h"
  15 #include "lldb/Core/Module.h"
  16 #include "lldb/Symbol/SymbolContext.h"
  17 #include "lldb/Utility/Stream.h"
  18
  19 using namespace lldb;
  20 using namespace lldb_private;
  21
  22 SBInstructionList::SBInstructionList() : m_opaque_sp() {}
  23
  24 SBInstructionList::SBInstructionList(const SBInstructionList &rhs)
  25     : m_opaque_sp(rhs.m_opaque_sp) {}
  26
  27 const SBInstructionList &SBInstructionList::
  28 operator=(const SBInstructionList &rhs) {
  29   if (this != &rhs)
  30     m_opaque_sp = rhs.m_opaque_sp;
  31   return *this;
  32 }
  33
  34 SBInstructionList::~SBInstructionList() {}
  35
  36 bool SBInstructionList::IsValid() const { return m_opaque_sp.get() != NULL; }
  37
  38 size_t SBInstructionList::GetSize() {
  39   if (m_opaque_sp)
  40     return m_opaque_sp->GetInstructionList().GetSize();
  41   return 0;
  42 }
  43
  44 SBInstruction SBInstructionList::GetInstructionAtIndex(uint32_t idx) {
  45   SBInstruction inst;
  46   if (m_opaque_sp && idx < m_opaque_sp->GetInstructionList().GetSize())
  47     inst.SetOpaque(
  48         m_opaque_sp,
  49         m_opaque_sp->GetInstructionList().GetInstructionAtIndex(idx));
  50   return inst;
  51 }
  52
  53 size_t SBInstructionList::GetInstructionsCount(const SBAddress &start,
  54                                               const SBAddress &end,
  55                                               bool canSetBreakpoint) {
  56   size_t num_instructions = GetSize();
  57   size_t i = 0;
  58   SBAddress addr;
  59   size_t lower_index = 0;
  60   size_t upper_index = 0;
  61   size_t instructions_to_skip = 0;
  62   for (i = 0; i < num_instructions; ++i) {
  63     addr = GetInstructionAtIndex(i).GetAddress();
  64     if (start == addr)
  65       lower_index = i;
  66     if (end == addr)
  67       upper_index = i;
  68   }
  69   if (canSetBreakpoint)
  70     for (i = lower_index; i <= upper_index; ++i) {
  71       SBInstruction insn = GetInstructionAtIndex(i);
  72       if (!insn.CanSetBreakpoint())
  73         ++instructions_to_skip;
  74     }
  75   return upper_index - lower_index - instructions_to_skip;
  76 }
  77
  78 void SBInstructionList::Clear() { m_opaque_sp.reset(); }
  79
  80 void SBInstructionList::AppendInstruction(SBInstruction insn) {}
  81
  82 void SBInstructionList::SetDisassembler(const lldb::DisassemblerSP &opaque_sp) {
  83   m_opaque_sp = opaque_sp;
  84 }
  85
  86 void SBInstructionList::Print(FILE *out) {
  87   if (out == NULL)
  88     return;
  89 }
  90
  91 bool SBInstructionList::GetDescription(lldb::SBStream &description) {
  92   if (m_opaque_sp) {
  93     size_t num_instructions = GetSize();
  94     if (num_instructions) {
  95       // Call the ref() to make sure a stream is created if one deesn't exist
  96       // already inside description...
  97       Stream &sref = description.ref();
  98       const uint32_t max_opcode_byte_size =
  99           m_opaque_sp->GetInstructionList().GetMaxOpcocdeByteSize();
 100       FormatEntity::Entry format;
 101       FormatEntity::Parse("${addr}: ", format);
 102       SymbolContext sc;
 103       SymbolContext prev_sc;
 104       for (size_t i = 0; i < num_instructions; ++i) {
 105         Instruction *inst =
 106             m_opaque_sp->GetInstructionList().GetInstructionAtIndex(i).get();
 107         if (inst == NULL)
 108           break;
 109
 110         const Address &addr = inst->GetAddress();
 111         prev_sc = sc;
 112         ModuleSP module_sp(addr.GetModule());
 113         if (module_sp) {
 114           module_sp->ResolveSymbolContextForAddress(
 115               addr, eSymbolContextEverything, sc);
 116         }
 117
 118         inst->Dump(&sref, max_opcode_byte_size, true, false, NULL, &sc,
 119                    &prev_sc, &format, 0);
 120         sref.EOL();
 121       }
 122       return true;
 123     }
 124   }
 125   return false;
 126 }
 127
 128 bool SBInstructionList::DumpEmulationForAllInstructions(const char *triple) {
 129   if (m_opaque_sp) {
 130     size_t len = GetSize();
 131     for (size_t i = 0; i < len; ++i) {
 132       if (!GetInstructionAtIndex((uint32_t)i).DumpEmulation(triple))
 133         return false;
 134     }
 135   }
 136   return true;
 137 }