llvm-project/lldb/source/Plugins/Process/minidump/MinidumpParser.cpp

157 lines
4.8 KiB
C++

//===-- MinidumpParser.cpp ---------------------------------------*- C++
//-*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// Project includes
#include "MinidumpParser.h"
// Other libraries and framework includes
// C includes
// C++ includes
using namespace lldb_private;
using namespace minidump;
llvm::Optional<MinidumpParser>
MinidumpParser::Create(const lldb::DataBufferSP &data_buf_sp) {
if (data_buf_sp->GetByteSize() < sizeof(MinidumpHeader)) {
return llvm::None;
}
llvm::ArrayRef<uint8_t> header_data(data_buf_sp->GetBytes(),
sizeof(MinidumpHeader));
const MinidumpHeader *header = MinidumpHeader::Parse(header_data);
if (header == nullptr) {
return llvm::None;
}
lldb::offset_t directory_list_offset = header->stream_directory_rva;
// check if there is enough data for the parsing of the directory list
if ((directory_list_offset +
sizeof(MinidumpDirectory) * header->streams_count) >
data_buf_sp->GetByteSize()) {
return llvm::None;
}
const MinidumpDirectory *directory = nullptr;
Error error;
llvm::ArrayRef<uint8_t> directory_data(
data_buf_sp->GetBytes() + directory_list_offset,
sizeof(MinidumpDirectory) * header->streams_count);
llvm::DenseMap<uint32_t, MinidumpLocationDescriptor> directory_map;
for (uint32_t i = 0; i < header->streams_count; ++i) {
error = consumeObject(directory_data, directory);
if (error.Fail()) {
return llvm::None;
}
directory_map[static_cast<const uint32_t>(directory->stream_type)] =
directory->location;
}
MinidumpParser parser(data_buf_sp, header, directory_map);
return llvm::Optional<MinidumpParser>(parser);
}
MinidumpParser::MinidumpParser(
const lldb::DataBufferSP &data_buf_sp, const MinidumpHeader *header,
const llvm::DenseMap<uint32_t, MinidumpLocationDescriptor> &directory_map)
: m_data_sp(data_buf_sp), m_header(header), m_directory_map(directory_map) {
}
lldb::offset_t MinidumpParser::GetByteSize() {
return m_data_sp->GetByteSize();
}
llvm::Optional<llvm::ArrayRef<uint8_t>>
MinidumpParser::GetStream(MinidumpStreamType stream_type) {
auto iter = m_directory_map.find(static_cast<uint32_t>(stream_type));
if (iter == m_directory_map.end())
return llvm::None;
// check if there is enough data
if (iter->second.rva + iter->second.data_size > m_data_sp->GetByteSize())
return llvm::None;
llvm::ArrayRef<uint8_t> arr_ref(m_data_sp->GetBytes() + iter->second.rva,
iter->second.data_size);
return llvm::Optional<llvm::ArrayRef<uint8_t>>(arr_ref);
}
llvm::Optional<std::vector<const MinidumpThread *>>
MinidumpParser::GetThreads() {
llvm::Optional<llvm::ArrayRef<uint8_t>> data =
GetStream(MinidumpStreamType::ThreadList);
if (!data)
return llvm::None;
return MinidumpThread::ParseThreadList(data.getValue());
}
const MinidumpSystemInfo *MinidumpParser::GetSystemInfo() {
llvm::Optional<llvm::ArrayRef<uint8_t>> data =
GetStream(MinidumpStreamType::SystemInfo);
if (!data)
return nullptr;
return MinidumpSystemInfo::Parse(data.getValue());
}
ArchSpec MinidumpParser::GetArchitecture() {
ArchSpec arch_spec;
arch_spec.GetTriple().setOS(llvm::Triple::OSType::UnknownOS);
arch_spec.GetTriple().setVendor(llvm::Triple::VendorType::UnknownVendor);
arch_spec.GetTriple().setArch(llvm::Triple::ArchType::UnknownArch);
// TODO should we add the OS type here, or somewhere else ?
const MinidumpSystemInfo *system_info = GetSystemInfo();
if (!system_info)
return arch_spec;
// TODO what to do about big endiand flavors of arm ?
// TODO set the arm subarch stuff if the minidump has info about it
const MinidumpCPUArchitecture arch =
static_cast<const MinidumpCPUArchitecture>(
static_cast<const uint32_t>(system_info->processor_arch));
switch (arch) {
case MinidumpCPUArchitecture::X86:
arch_spec.GetTriple().setArch(llvm::Triple::ArchType::x86);
break;
case MinidumpCPUArchitecture::AMD64:
arch_spec.GetTriple().setArch(llvm::Triple::ArchType::x86_64);
break;
case MinidumpCPUArchitecture::ARM:
arch_spec.GetTriple().setArch(llvm::Triple::ArchType::arm);
break;
case MinidumpCPUArchitecture::ARM64:
arch_spec.GetTriple().setArch(llvm::Triple::ArchType::aarch64);
break;
default:
break;
}
return arch_spec;
}
const MinidumpMiscInfo *MinidumpParser::GetMiscInfo() {
llvm::Optional<llvm::ArrayRef<uint8_t>> data =
GetStream(MinidumpStreamType::MiscInfo);
if (!data)
return nullptr;
return MinidumpMiscInfo::Parse(data.getValue());
}