lldb/source/API/SBInstructionList.cpp

   1 //===-- SBInstructionList.cpp -----------------------------------*- C++ -*-===//
   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 "SBReproducerPrivate.h"
  11 #include "lldb/API/SBAddress.h"
  12 #include "lldb/API/SBInstruction.h"
  13 #include "lldb/API/SBStream.h"
  14 #include "lldb/API/SBFile.h"
  15 #include "lldb/Core/Disassembler.h"
  16 #include "lldb/Core/Module.h"
  17 #include "lldb/Core/StreamFile.h"
  18 #include "lldb/Symbol/SymbolContext.h"
  19 #include "lldb/Utility/Stream.h"
  20
  21 using namespace lldb;
  22 using namespace lldb_private;
  23
  24 SBInstructionList::SBInstructionList() : m_opaque_sp() {
  25   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBInstructionList);
  26 }
  27
  28 SBInstructionList::SBInstructionList(const SBInstructionList &rhs)
  29     : m_opaque_sp(rhs.m_opaque_sp) {
  30   LLDB_RECORD_CONSTRUCTOR(SBInstructionList, (const lldb::SBInstructionList &),
  31                           rhs);
  32 }
  33
  34 const SBInstructionList &SBInstructionList::
  35 operator=(const SBInstructionList &rhs) {
  36   LLDB_RECORD_METHOD(
  37       const lldb::SBInstructionList &,
  38       SBInstructionList, operator=,(const lldb::SBInstructionList &), rhs);
  39
  40   if (this != &rhs)
  41     m_opaque_sp = rhs.m_opaque_sp;
  42   return LLDB_RECORD_RESULT(*this);
  43 }
  44
  45 SBInstructionList::~SBInstructionList() {}
  46
  47 bool SBInstructionList::IsValid() const {
  48   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInstructionList, IsValid);
  49   return this->operator bool();
  50 }
  51 SBInstructionList::operator bool() const {
  52   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInstructionList, operator bool);
  53
  54   return m_opaque_sp.get() != nullptr;
  55 }
  56
  57 size_t SBInstructionList::GetSize() {
  58   LLDB_RECORD_METHOD_NO_ARGS(size_t, SBInstructionList, GetSize);
  59
  60   if (m_opaque_sp)
  61     return m_opaque_sp->GetInstructionList().GetSize();
  62   return 0;
  63 }
  64
  65 SBInstruction SBInstructionList::GetInstructionAtIndex(uint32_t idx) {
  66   LLDB_RECORD_METHOD(lldb::SBInstruction, SBInstructionList,
  67                      GetInstructionAtIndex, (uint32_t), idx);
  68
  69   SBInstruction inst;
  70   if (m_opaque_sp && idx < m_opaque_sp->GetInstructionList().GetSize())
  71     inst.SetOpaque(
  72         m_opaque_sp,
  73         m_opaque_sp->GetInstructionList().GetInstructionAtIndex(idx));
  74   return LLDB_RECORD_RESULT(inst);
  75 }
  76
  77 size_t SBInstructionList::GetInstructionsCount(const SBAddress &start,
  78                                                const SBAddress &end,
  79                                                bool canSetBreakpoint) {
  80   LLDB_RECORD_METHOD(size_t, SBInstructionList, GetInstructionsCount,
  81                      (const lldb::SBAddress &, const lldb::SBAddress &, bool),
  82                      start, end, canSetBreakpoint);
  83
  84   size_t num_instructions = GetSize();
  85   size_t i = 0;
  86   SBAddress addr;
  87   size_t lower_index = 0;
  88   size_t upper_index = 0;
  89   size_t instructions_to_skip = 0;
  90   for (i = 0; i < num_instructions; ++i) {
  91     addr = GetInstructionAtIndex(i).GetAddress();
  92     if (start == addr)
  93       lower_index = i;
  94     if (end == addr)
  95       upper_index = i;
  96   }
  97   if (canSetBreakpoint)
  98     for (i = lower_index; i <= upper_index; ++i) {
  99       SBInstruction insn = GetInstructionAtIndex(i);
 100       if (!insn.CanSetBreakpoint())
 101         ++instructions_to_skip;
 102     }
 103   return upper_index - lower_index - instructions_to_skip;
 104 }
 105
 106 void SBInstructionList::Clear() {
 107   LLDB_RECORD_METHOD_NO_ARGS(void, SBInstructionList, Clear);
 108
 109   m_opaque_sp.reset();
 110 }
 111
 112 void SBInstructionList::AppendInstruction(SBInstruction insn) {
 113   LLDB_RECORD_METHOD(void, SBInstructionList, AppendInstruction,
 114                      (lldb::SBInstruction), insn);
 115 }
 116
 117 void SBInstructionList::SetDisassembler(const lldb::DisassemblerSP &opaque_sp) {
 118   m_opaque_sp = opaque_sp;
 119 }
 120
 121 void SBInstructionList::Print(FILE *out) {
 122   LLDB_RECORD_METHOD(void, SBInstructionList, Print, (FILE *), out);
 123   if (out == nullptr)
 124     return;
 125   StreamFile stream(out, false);
 126   GetDescription(stream);
 127 }
 128
 129 void SBInstructionList::Print(SBFile out) {
 130   LLDB_RECORD_METHOD(void, SBInstructionList, Print, (SBFile), out);
 131   if (!out.IsValid())
 132     return;
 133   StreamFile stream(out.m_opaque_sp);
 134   GetDescription(stream);
 135 }
 136
 137 void SBInstructionList::Print(FileSP out_sp) {
 138   LLDB_RECORD_METHOD(void, SBInstructionList, Print, (FileSP), out_sp);
 139   if (!out_sp || !out_sp->IsValid())
 140     return;
 141   StreamFile stream(out_sp);
 142   GetDescription(stream);
 143 }
 144
 145 bool SBInstructionList::GetDescription(lldb::SBStream &stream) {
 146   LLDB_RECORD_METHOD(bool, SBInstructionList, GetDescription,
 147                      (lldb::SBStream &), stream);
 148   return GetDescription(stream.ref());
 149 }
 150
 151 bool SBInstructionList::GetDescription(Stream &sref) {
 152
 153   if (m_opaque_sp) {
 154     size_t num_instructions = GetSize();
 155     if (num_instructions) {
 156       // Call the ref() to make sure a stream is created if one deesn't exist
 157       // already inside description...
 158       const uint32_t max_opcode_byte_size =
 159           m_opaque_sp->GetInstructionList().GetMaxOpcocdeByteSize();
 160       FormatEntity::Entry format;
 161       FormatEntity::Parse("${addr}: ", format);
 162       SymbolContext sc;
 163       SymbolContext prev_sc;
 164       for (size_t i = 0; i < num_instructions; ++i) {
 165         Instruction *inst =
 166             m_opaque_sp->GetInstructionList().GetInstructionAtIndex(i).get();
 167         if (inst == nullptr)
 168           break;
 169
 170         const Address &addr = inst->GetAddress();
 171         prev_sc = sc;
 172         ModuleSP module_sp(addr.GetModule());
 173         if (module_sp) {
 174           module_sp->ResolveSymbolContextForAddress(
 175               addr, eSymbolContextEverything, sc);
 176         }
 177
 178         inst->Dump(&sref, max_opcode_byte_size, true, false, nullptr, &sc,
 179                    &prev_sc, &format, 0);
 180         sref.EOL();
 181       }
 182       return true;
 183     }
 184   }
 185   return false;
 186 }
 187
 188 bool SBInstructionList::DumpEmulationForAllInstructions(const char *triple) {
 189   LLDB_RECORD_METHOD(bool, SBInstructionList, DumpEmulationForAllInstructions,
 190                      (const char *), triple);
 191
 192   if (m_opaque_sp) {
 193     size_t len = GetSize();
 194     for (size_t i = 0; i < len; ++i) {
 195       if (!GetInstructionAtIndex((uint32_t)i).DumpEmulation(triple))
 196         return false;
 197     }
 198   }
 199   return true;
 200 }
 201
 202 namespace lldb_private {
 203 namespace repro {
 204
 205 template <>
 206 void RegisterMethods<SBInstructionList>(Registry &R) {
 207   LLDB_REGISTER_CONSTRUCTOR(SBInstructionList, ());
 208   LLDB_REGISTER_CONSTRUCTOR(SBInstructionList,
 209                             (const lldb::SBInstructionList &));
 210   LLDB_REGISTER_METHOD(
 211       const lldb::SBInstructionList &,
 212       SBInstructionList, operator=,(const lldb::SBInstructionList &));
 213   LLDB_REGISTER_METHOD_CONST(bool, SBInstructionList, IsValid, ());
 214   LLDB_REGISTER_METHOD_CONST(bool, SBInstructionList, operator bool, ());
 215   LLDB_REGISTER_METHOD(size_t, SBInstructionList, GetSize, ());
 216   LLDB_REGISTER_METHOD(lldb::SBInstruction, SBInstructionList,
 217                        GetInstructionAtIndex, (uint32_t));
 218   LLDB_REGISTER_METHOD(
 219       size_t, SBInstructionList, GetInstructionsCount,
 220       (const lldb::SBAddress &, const lldb::SBAddress &, bool));
 221   LLDB_REGISTER_METHOD(void, SBInstructionList, Clear, ());
 222   LLDB_REGISTER_METHOD(void, SBInstructionList, AppendInstruction,
 223                        (lldb::SBInstruction));
 224   LLDB_REGISTER_METHOD(void, SBInstructionList, Print, (FILE *));
 225   LLDB_REGISTER_METHOD(void, SBInstructionList, Print, (SBFile));
 226   LLDB_REGISTER_METHOD(void, SBInstructionList, Print, (FileSP));
 227   LLDB_REGISTER_METHOD(bool, SBInstructionList, GetDescription,
 228                        (lldb::SBStream &));
 229   LLDB_REGISTER_METHOD(bool, SBInstructionList,
 230                        DumpEmulationForAllInstructions, (const char *));
 231 }
 232
 233 }
 234 }