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/StreamFile.h" 16 #include "lldb/Core/Value.h" 17 #include "lldb/Symbol/TypeList.h" 18 #include "lldb/Symbol/TypeSystem.h" 19 #include "lldb/Target/ABI.h" 20 #include "lldb/Target/Process.h" 21 #include "lldb/Target/RegisterContext.h" 22 #include "lldb/Target/SectionLoadList.h" 23 #include "lldb/Target/Target.h" 24 #include "lldb/Target/Thread.h" 25 #include "lldb/Target/ThreadPlan.h" 26 #include "lldb/Utility/DataBufferHeap.h" 27 #include "lldb/Utility/DataExtractor.h" 28 #include "lldb/Utility/LLDBLog.h" 29 #include "lldb/Utility/Log.h" 30 #include "lldb/Utility/State.h" 31 32 using namespace lldb; 33 using namespace lldb_private; 34 35 #pragma mark ThreadPlanTracer 36 37 ThreadPlanTracer::ThreadPlanTracer(Thread &thread, lldb::StreamSP &stream_sp) 38 : m_process(*thread.GetProcess().get()), m_tid(thread.GetID()), 39 m_enabled(false), m_stream_sp(stream_sp), m_thread(nullptr) {} 40 41 ThreadPlanTracer::ThreadPlanTracer(Thread &thread) 42 : m_process(*thread.GetProcess().get()), m_tid(thread.GetID()), 43 m_enabled(false), m_stream_sp(), m_thread(nullptr) {} 44 45 Stream *ThreadPlanTracer::GetLogStream() { 46 if (m_stream_sp) 47 return m_stream_sp.get(); 48 else { 49 TargetSP target_sp(GetThread().CalculateTarget()); 50 if (target_sp) 51 return &(target_sp->GetDebugger().GetOutputStream()); 52 } 53 return nullptr; 54 } 55 56 Thread &ThreadPlanTracer::GetThread() { 57 if (m_thread) 58 return *m_thread; 59 60 ThreadSP thread_sp = m_process.GetThreadList().FindThreadByID(m_tid); 61 m_thread = thread_sp.get(); 62 return *m_thread; 63 } 64 void ThreadPlanTracer::Log() { 65 SymbolContext sc; 66 bool show_frame_index = false; 67 bool show_fullpaths = false; 68 69 Stream *stream = GetLogStream(); 70 if (stream) { 71 GetThread().GetStackFrameAtIndex(0)->Dump(stream, show_frame_index, 72 show_fullpaths); 73 stream->Printf("\n"); 74 stream->Flush(); 75 } 76 } 77 78 bool ThreadPlanTracer::TracerExplainsStop() { 79 if (m_enabled) { 80 lldb::StopInfoSP stop_info = GetThread().GetStopInfo(); 81 return (stop_info->GetStopReason() == eStopReasonTrace); 82 } else 83 return false; 84 } 85 86 #pragma mark ThreadPlanAssemblyTracer 87 88 ThreadPlanAssemblyTracer::ThreadPlanAssemblyTracer(Thread &thread, 89 lldb::StreamSP &stream_sp) 90 : ThreadPlanTracer(thread, stream_sp), m_disassembler_sp(), m_intptr_type(), 91 m_register_values() {} 92 93 ThreadPlanAssemblyTracer::ThreadPlanAssemblyTracer(Thread &thread) 94 : ThreadPlanTracer(thread), m_disassembler_sp(), m_intptr_type(), 95 m_register_values() {} 96 97 Disassembler *ThreadPlanAssemblyTracer::GetDisassembler() { 98 if (!m_disassembler_sp) 99 m_disassembler_sp = Disassembler::FindPlugin( 100 m_process.GetTarget().GetArchitecture(), nullptr, nullptr); 101 return m_disassembler_sp.get(); 102 } 103 104 TypeFromUser ThreadPlanAssemblyTracer::GetIntPointerType() { 105 if (!m_intptr_type.IsValid()) { 106 if (auto target_sp = m_process.CalculateTarget()) { 107 auto type_system_or_err = 108 target_sp->GetScratchTypeSystemForLanguage(eLanguageTypeC); 109 if (auto err = type_system_or_err.takeError()) { 110 LLDB_LOG_ERROR(GetLog(LLDBLog::Types), std::move(err), 111 "Unable to get integer pointer type from TypeSystem"); 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