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 "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() = default; 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 } 235