| //===-- IntelPTDecoder.cpp --------------------------------------*- C++ -*-===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "IntelPTDecoder.h" |
| |
| #include "llvm/Support/MemoryBuffer.h" |
| |
| #include "lldb/Core/Module.h" |
| #include "lldb/Core/Section.h" |
| #include "lldb/Target/Target.h" |
| #include "lldb/Target/ThreadTrace.h" |
| |
| using namespace lldb; |
| using namespace lldb_private; |
| using namespace lldb_private::trace_intel_pt; |
| using namespace llvm; |
| |
| /// Move the decoder forward to the next synchronization point (i.e. next PSB |
| /// packet). |
| /// |
| /// Once the decoder is at that sync. point, it can start decoding instructions. |
| /// |
| /// \return |
| /// A negative number with the libipt error if we couldn't synchronize. |
| /// Otherwise, a positive number with the synchronization status will be |
| /// returned. |
| static int FindNextSynchronizationPoint(pt_insn_decoder &decoder) { |
| // Try to sync the decoder. If it fails, then get |
| // the decoder_offset and try to sync again from |
| // the next synchronization point. If the |
| // new_decoder_offset is same as decoder_offset |
| // then we can't move to the next synchronization |
| // point. Otherwise, keep resyncing until either |
| // end of trace stream (eos) is reached or |
| // pt_insn_sync_forward() passes. |
| int errcode = pt_insn_sync_forward(&decoder); |
| |
| if (errcode != -pte_eos && errcode < 0) { |
| uint64_t decoder_offset = 0; |
| int errcode_off = pt_insn_get_offset(&decoder, &decoder_offset); |
| if (errcode_off >= 0) { // we could get the offset |
| while (true) { |
| errcode = pt_insn_sync_forward(&decoder); |
| if (errcode >= 0 || errcode == -pte_eos) |
| break; |
| |
| uint64_t new_decoder_offset = 0; |
| errcode_off = pt_insn_get_offset(&decoder, &new_decoder_offset); |
| if (errcode_off < 0) |
| break; // We can't further synchronize. |
| else if (new_decoder_offset <= decoder_offset) { |
| // We tried resyncing the decoder and |
| // decoder didn't make any progress because |
| // the offset didn't change. We will not |
| // make any progress further. Hence, |
| // stopping in this situation. |
| break; |
| } |
| // We'll try again starting from a new offset. |
| decoder_offset = new_decoder_offset; |
| } |
| } |
| } |
| |
| return errcode; |
| } |
| |
| /// Before querying instructions, we need to query the events associated that |
| /// instruction e.g. timing events like ptev_tick, or paging events like |
| /// ptev_paging. |
| /// |
| /// \return |
| /// 0 if there were no errors processing the events, or a negative libipt |
| /// error code in case of errors. |
| static int ProcessPTEvents(pt_insn_decoder &decoder, int errcode) { |
| while (errcode & pts_event_pending) { |
| pt_event event; |
| errcode = pt_insn_event(&decoder, &event, sizeof(event)); |
| if (errcode < 0) |
| return errcode; |
| } |
| return 0; |
| }; |
| |
| /// Decode all the instructions from a configured decoder. |
| /// The decoding flow is based on |
| /// https://github.com/intel/libipt/blob/master/doc/howto_libipt.md#the-instruction-flow-decode-loop |
| /// but with some relaxation to allow for gaps in the trace. |
| /// |
| /// Error codes returned by libipt while decoding are: |
| /// - negative: actual errors |
| /// - positive or zero: not an error, but a list of bits signaling the status of |
| /// the decoder |
| /// |
| /// \param[in] decoder |
| /// A configured libipt \a pt_insn_decoder. |
| /// |
| /// \return |
| /// The decoded instructions. |
| static std::vector<IntelPTInstruction> |
| DecodeInstructions(pt_insn_decoder &decoder) { |
| std::vector<IntelPTInstruction> instructions; |
| |
| while (true) { |
| int errcode = FindNextSynchronizationPoint(decoder); |
| if (errcode == -pte_eos) |
| break; |
| |
| if (errcode < 0) { |
| instructions.emplace_back(make_error<IntelPTError>(errcode)); |
| break; |
| } |
| |
| // We have synchronized, so we can start decoding |
| // instructions and events. |
| while (true) { |
| errcode = ProcessPTEvents(decoder, errcode); |
| if (errcode < 0) { |
| instructions.emplace_back(make_error<IntelPTError>(errcode)); |
| break; |
| } |
| pt_insn insn; |
| |
| errcode = pt_insn_next(&decoder, &insn, sizeof(insn)); |
| if (errcode == -pte_eos) |
| break; |
| |
| if (errcode < 0) { |
| instructions.emplace_back(make_error<IntelPTError>(errcode, insn.ip)); |
| break; |
| } |
| |
| instructions.emplace_back(insn); |
| } |
| } |
| |
| return instructions; |
| } |
| |
| /// Callback used by libipt for reading the process memory. |
| /// |
| /// More information can be found in |
| /// https://github.com/intel/libipt/blob/master/doc/man/pt_image_set_callback.3.md |
| static int ReadProcessMemory(uint8_t *buffer, size_t size, |
| const pt_asid * /* unused */, uint64_t pc, |
| void *context) { |
| Process *process = static_cast<Process *>(context); |
| |
| Status error; |
| int bytes_read = process->ReadMemory(pc, buffer, size, error); |
| if (error.Fail()) |
| return -pte_nomap; |
| return bytes_read; |
| } |
| |
| static std::vector<IntelPTInstruction> makeInstructionListFromError(Error err) { |
| std::vector<IntelPTInstruction> instructions; |
| instructions.emplace_back(std::move(err)); |
| return instructions; |
| } |
| |
| static std::vector<IntelPTInstruction> |
| CreateDecoderAndDecode(Process &process, const pt_cpu &pt_cpu, |
| const FileSpec &trace_file) { |
| ErrorOr<std::unique_ptr<MemoryBuffer>> trace_or_error = |
| MemoryBuffer::getFile(trace_file.GetPath()); |
| if (std::error_code err = trace_or_error.getError()) |
| return makeInstructionListFromError(errorCodeToError(err)); |
| |
| MemoryBuffer &trace = **trace_or_error; |
| |
| pt_config config; |
| pt_config_init(&config); |
| config.cpu = pt_cpu; |
| |
| if (int errcode = pt_cpu_errata(&config.errata, &config.cpu)) |
| return makeInstructionListFromError(make_error<IntelPTError>(errcode)); |
| |
| // The libipt library does not modify the trace buffer, hence the following |
| // cast is safe. |
| config.begin = |
| reinterpret_cast<uint8_t *>(const_cast<char *>(trace.getBufferStart())); |
| config.end = |
| reinterpret_cast<uint8_t *>(const_cast<char *>(trace.getBufferEnd())); |
| |
| pt_insn_decoder *decoder = pt_insn_alloc_decoder(&config); |
| if (!decoder) |
| return makeInstructionListFromError(make_error<IntelPTError>(-pte_nomem)); |
| |
| pt_image *image = pt_insn_get_image(decoder); |
| |
| int errcode = pt_image_set_callback(image, ReadProcessMemory, &process); |
| assert(errcode == 0); |
| (void)errcode; |
| |
| std::vector<IntelPTInstruction> instructions = DecodeInstructions(*decoder); |
| |
| pt_insn_free_decoder(decoder); |
| return instructions; |
| } |
| |
| const DecodedThread &ThreadTraceDecoder::Decode() { |
| if (!m_decoded_thread.hasValue()) { |
| m_decoded_thread = DecodedThread( |
| CreateDecoderAndDecode(*m_trace_thread->GetProcess(), m_pt_cpu, |
| m_trace_thread->GetTraceFile())); |
| } |
| |
| return *m_decoded_thread; |
| } |