1 //===-- ThreadPlanTracer.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 <cstring> 10 11 #include "lldb/Core/Debugger.h" 12 #include "lldb/Core/Disassembler.h" 13 #include "lldb/Core/DumpRegisterValue.h" 14 #include "lldb/Core/Module.h" 15 #include "lldb/Core/Value.h" 16 #include "lldb/Symbol/TypeList.h" 17 #include "lldb/Symbol/TypeSystem.h" 18 #include "lldb/Target/ABI.h" 19 #include "lldb/Target/Process.h" 20 #include "lldb/Target/RegisterContext.h" 21 #include "lldb/Target/SectionLoadList.h" 22 #include "lldb/Target/Target.h" 23 #include "lldb/Target/Thread.h" 24 #include "lldb/Target/ThreadPlan.h" 25 #include "lldb/Utility/DataBufferHeap.h" 26 #include "lldb/Utility/DataExtractor.h" 27 #include "lldb/Utility/LLDBLog.h" 28 #include "lldb/Utility/Log.h" 29 #include "lldb/Utility/State.h" 30 31 using namespace lldb; 32 using namespace lldb_private; 33 34 #pragma mark ThreadPlanTracer 35 36 ThreadPlanTracer::ThreadPlanTracer(Thread &thread, lldb::StreamSP &stream_sp) 37 : m_process(*thread.GetProcess().get()), m_tid(thread.GetID()), 38 m_enabled(false), m_stream_sp(stream_sp), m_thread(nullptr) {} 39 40 ThreadPlanTracer::ThreadPlanTracer(Thread &thread) 41 : m_process(*thread.GetProcess().get()), m_tid(thread.GetID()), 42 m_enabled(false), m_stream_sp(), m_thread(nullptr) {} 43 44 Stream *ThreadPlanTracer::GetLogStream() { 45 if (m_stream_sp) 46 return m_stream_sp.get(); 47 else { 48 TargetSP target_sp(GetThread().CalculateTarget()); 49 if (target_sp) 50 return &(target_sp->GetDebugger().GetOutputStream()); 51 } 52 return nullptr; 53 } 54 55 Thread &ThreadPlanTracer::GetThread() { 56 if (m_thread) 57 return *m_thread; 58 59 ThreadSP thread_sp = m_process.GetThreadList().FindThreadByID(m_tid); 60 m_thread = thread_sp.get(); 61 return *m_thread; 62 } 63 void ThreadPlanTracer::Log() { 64 SymbolContext sc; 65 bool show_frame_index = false; 66 bool show_fullpaths = false; 67 68 Stream *stream = GetLogStream(); 69 if (stream) { 70 GetThread().GetStackFrameAtIndex(0)->Dump(stream, show_frame_index, 71 show_fullpaths); 72 stream->Printf("\n"); 73 stream->Flush(); 74 } 75 } 76 77 bool ThreadPlanTracer::TracerExplainsStop() { 78 if (m_enabled) { 79 lldb::StopInfoSP stop_info = GetThread().GetStopInfo(); 80 return (stop_info->GetStopReason() == eStopReasonTrace); 81 } else 82 return false; 83 } 84 85 #pragma mark ThreadPlanAssemblyTracer 86 87 ThreadPlanAssemblyTracer::ThreadPlanAssemblyTracer(Thread &thread, 88 lldb::StreamSP &stream_sp) 89 : ThreadPlanTracer(thread, stream_sp), m_disassembler_sp(), m_intptr_type(), 90 m_register_values() {} 91 92 ThreadPlanAssemblyTracer::ThreadPlanAssemblyTracer(Thread &thread) 93 : ThreadPlanTracer(thread), m_disassembler_sp(), m_intptr_type(), 94 m_register_values() {} 95 96 Disassembler *ThreadPlanAssemblyTracer::GetDisassembler() { 97 if (!m_disassembler_sp) 98 m_disassembler_sp = Disassembler::FindPlugin( 99 m_process.GetTarget().GetArchitecture(), nullptr, nullptr); 100 return m_disassembler_sp.get(); 101 } 102 103 TypeFromUser ThreadPlanAssemblyTracer::GetIntPointerType() { 104 if (!m_intptr_type.IsValid()) { 105 if (auto target_sp = m_process.CalculateTarget()) { 106 auto type_system_or_err = 107 target_sp->GetScratchTypeSystemForLanguage(eLanguageTypeC); 108 if (auto err = type_system_or_err.takeError()) { 109 LLDB_LOG_ERROR( 110 GetLog(LLDBLog::Types), std::move(err), 111 "Unable to get integer pointer type from TypeSystem: {0}"); 112 } else { 113 if (auto ts = *type_system_or_err) 114 m_intptr_type = TypeFromUser(ts->GetBuiltinTypeForEncodingAndBitSize( 115 eEncodingUint, 116 target_sp->GetArchitecture().GetAddressByteSize() * 8)); 117 } 118 } 119 } 120 return m_intptr_type; 121 } 122 123 ThreadPlanAssemblyTracer::~ThreadPlanAssemblyTracer() = default; 124 125 void ThreadPlanAssemblyTracer::TracingStarted() { 126 } 127 128 void ThreadPlanAssemblyTracer::TracingEnded() { m_register_values.clear(); } 129 130 void ThreadPlanAssemblyTracer::Log() { 131 Stream *stream = GetLogStream(); 132 133 if (!stream) 134 return; 135 136 RegisterContext *reg_ctx = GetThread().GetRegisterContext().get(); 137 138 lldb::addr_t pc = reg_ctx->GetPC(); 139 Address pc_addr; 140 bool addr_valid = false; 141 uint8_t buffer[16] = {0}; // Must be big enough for any single instruction 142 addr_valid = m_process.GetTarget().GetSectionLoadList().ResolveLoadAddress( 143 pc, pc_addr); 144 145 pc_addr.Dump(stream, &GetThread(), Address::DumpStyleResolvedDescription, 146 Address::DumpStyleModuleWithFileAddress); 147 stream->PutCString(" "); 148 149 Disassembler *disassembler = GetDisassembler(); 150 if (disassembler) { 151 Status err; 152 m_process.ReadMemory(pc, buffer, sizeof(buffer), err); 153 154 if (err.Success()) { 155 DataExtractor extractor(buffer, sizeof(buffer), m_process.GetByteOrder(), 156 m_process.GetAddressByteSize()); 157 158 bool data_from_file = false; 159 if (addr_valid) 160 disassembler->DecodeInstructions(pc_addr, extractor, 0, 1, false, 161 data_from_file); 162 else 163 disassembler->DecodeInstructions(Address(pc), extractor, 0, 1, false, 164 data_from_file); 165 166 InstructionList &instruction_list = disassembler->GetInstructionList(); 167 const uint32_t max_opcode_byte_size = 168 instruction_list.GetMaxOpcocdeByteSize(); 169 170 if (instruction_list.GetSize()) { 171 const bool show_bytes = true; 172 const bool show_address = true; 173 const bool show_control_flow_kind = true; 174 Instruction *instruction = 175 instruction_list.GetInstructionAtIndex(0).get(); 176 const FormatEntity::Entry *disassemble_format = 177 m_process.GetTarget().GetDebugger().GetDisassemblyFormat(); 178 instruction->Dump(stream, max_opcode_byte_size, show_address, 179 show_bytes, show_control_flow_kind, nullptr, nullptr, 180 nullptr, disassemble_format, 0); 181 } 182 } 183 } 184 185 const ABI *abi = m_process.GetABI().get(); 186 TypeFromUser intptr_type = GetIntPointerType(); 187 188 if (abi && intptr_type.IsValid()) { 189 ValueList value_list; 190 const int num_args = 1; 191 192 for (int arg_index = 0; arg_index < num_args; ++arg_index) { 193 Value value; 194 value.SetValueType(Value::ValueType::Scalar); 195 value.SetCompilerType(intptr_type); 196 value_list.PushValue(value); 197 } 198 199 if (abi->GetArgumentValues(GetThread(), value_list)) { 200 for (int arg_index = 0; arg_index < num_args; ++arg_index) { 201 stream->Printf( 202 "\n\targ[%d]=%llx", arg_index, 203 value_list.GetValueAtIndex(arg_index)->GetScalar().ULongLong()); 204 205 if (arg_index + 1 < num_args) 206 stream->PutCString(", "); 207 } 208 } 209 } 210 211 if (m_register_values.empty()) { 212 RegisterContext *reg_ctx = GetThread().GetRegisterContext().get(); 213 m_register_values.resize(reg_ctx->GetRegisterCount()); 214 } 215 216 RegisterValue reg_value; 217 for (uint32_t reg_num = 0, num_registers = reg_ctx->GetRegisterCount(); 218 reg_num < num_registers; ++reg_num) { 219 const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoAtIndex(reg_num); 220 if (reg_ctx->ReadRegister(reg_info, reg_value)) { 221 assert(reg_num < m_register_values.size()); 222 if (m_register_values[reg_num].GetType() == RegisterValue::eTypeInvalid || 223 reg_value != m_register_values[reg_num]) { 224 if (reg_value.GetType() != RegisterValue::eTypeInvalid) { 225 stream->PutCString("\n\t"); 226 DumpRegisterValue(reg_value, *stream, *reg_info, true, false, 227 eFormatDefault); 228 } 229 } 230 m_register_values[reg_num] = reg_value; 231 } 232 } 233 stream->EOL(); 234 stream->Flush(); 235 } 236