blob: 57ad40819fbc45165c69926f82b4a2378a6ccf65 [file] [log] [blame]
//===- DebugLinesSubsection.cpp -------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "llvm/DebugInfo/CodeView/DebugLinesSubsection.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/DebugInfo/CodeView/CodeView.h"
#include "llvm/DebugInfo/CodeView/CodeViewError.h"
#include "llvm/DebugInfo/CodeView/DebugChecksumsSubsection.h"
#include "llvm/Support/BinaryStreamReader.h"
#include "llvm/Support/BinaryStreamWriter.h"
#include "llvm/Support/Error.h"
#include <cassert>
#include <cstdint>
using namespace llvm;
using namespace llvm::codeview;
Error LineColumnExtractor::operator()(BinaryStreamRef Stream, uint32_t &Len,
LineColumnEntry &Item) {
const LineBlockFragmentHeader *BlockHeader;
BinaryStreamReader Reader(Stream);
if (auto EC = Reader.readObject(BlockHeader))
return EC;
bool HasColumn = Header->Flags & uint16_t(LF_HaveColumns);
uint32_t LineInfoSize =
BlockHeader->NumLines *
(sizeof(LineNumberEntry) + (HasColumn ? sizeof(ColumnNumberEntry) : 0));
if (BlockHeader->BlockSize < sizeof(LineBlockFragmentHeader))
return make_error<CodeViewError>(cv_error_code::corrupt_record,
"Invalid line block record size");
uint32_t Size = BlockHeader->BlockSize - sizeof(LineBlockFragmentHeader);
if (LineInfoSize > Size)
return make_error<CodeViewError>(cv_error_code::corrupt_record,
"Invalid line block record size");
// The value recorded in BlockHeader->BlockSize includes the size of
// LineBlockFragmentHeader.
Len = BlockHeader->BlockSize;
Item.NameIndex = BlockHeader->NameIndex;
if (auto EC = Reader.readArray(Item.LineNumbers, BlockHeader->NumLines))
return EC;
if (HasColumn) {
if (auto EC = Reader.readArray(Item.Columns, BlockHeader->NumLines))
return EC;
}
return Error::success();
}
DebugLinesSubsectionRef::DebugLinesSubsectionRef()
: DebugSubsectionRef(DebugSubsectionKind::Lines) {}
Error DebugLinesSubsectionRef::initialize(BinaryStreamReader Reader) {
if (auto EC = Reader.readObject(Header))
return EC;
LinesAndColumns.getExtractor().Header = Header;
if (auto EC = Reader.readArray(LinesAndColumns, Reader.bytesRemaining()))
return EC;
return Error::success();
}
bool DebugLinesSubsectionRef::hasColumnInfo() const {
return !!(Header->Flags & LF_HaveColumns);
}
DebugLinesSubsection::DebugLinesSubsection(DebugChecksumsSubsection &Checksums,
DebugStringTableSubsection &Strings)
: DebugSubsection(DebugSubsectionKind::Lines), Checksums(Checksums) {}
void DebugLinesSubsection::createBlock(StringRef FileName) {
uint32_t Offset = Checksums.mapChecksumOffset(FileName);
Blocks.emplace_back(Offset);
}
void DebugLinesSubsection::addLineInfo(uint32_t Offset, const LineInfo &Line) {
Block &B = Blocks.back();
LineNumberEntry LNE;
LNE.Flags = Line.getRawData();
LNE.Offset = Offset;
B.Lines.push_back(LNE);
}
void DebugLinesSubsection::addLineAndColumnInfo(uint32_t Offset,
const LineInfo &Line,
uint32_t ColStart,
uint32_t ColEnd) {
Block &B = Blocks.back();
assert(B.Lines.size() == B.Columns.size());
addLineInfo(Offset, Line);
ColumnNumberEntry CNE;
CNE.StartColumn = ColStart;
CNE.EndColumn = ColEnd;
B.Columns.push_back(CNE);
}
Error DebugLinesSubsection::commit(BinaryStreamWriter &Writer) const {
LineFragmentHeader Header;
Header.CodeSize = CodeSize;
Header.Flags = hasColumnInfo() ? LF_HaveColumns : 0;
Header.RelocOffset = RelocOffset;
Header.RelocSegment = RelocSegment;
if (auto EC = Writer.writeObject(Header))
return EC;
for (const auto &B : Blocks) {
LineBlockFragmentHeader BlockHeader;
assert(B.Lines.size() == B.Columns.size() || B.Columns.empty());
BlockHeader.NumLines = B.Lines.size();
BlockHeader.BlockSize = sizeof(LineBlockFragmentHeader);
BlockHeader.BlockSize += BlockHeader.NumLines * sizeof(LineNumberEntry);
if (hasColumnInfo())
BlockHeader.BlockSize += BlockHeader.NumLines * sizeof(ColumnNumberEntry);
BlockHeader.NameIndex = B.ChecksumBufferOffset;
if (auto EC = Writer.writeObject(BlockHeader))
return EC;
if (auto EC = Writer.writeArray(makeArrayRef(B.Lines)))
return EC;
if (hasColumnInfo()) {
if (auto EC = Writer.writeArray(makeArrayRef(B.Columns)))
return EC;
}
}
return Error::success();
}
uint32_t DebugLinesSubsection::calculateSerializedSize() const {
uint32_t Size = sizeof(LineFragmentHeader);
for (const auto &B : Blocks) {
Size += sizeof(LineBlockFragmentHeader);
Size += B.Lines.size() * sizeof(LineNumberEntry);
if (hasColumnInfo())
Size += B.Columns.size() * sizeof(ColumnNumberEntry);
}
return Size;
}
void DebugLinesSubsection::setRelocationAddress(uint16_t Segment,
uint32_t Offset) {
RelocOffset = Offset;
RelocSegment = Segment;
}
void DebugLinesSubsection::setCodeSize(uint32_t Size) { CodeSize = Size; }
void DebugLinesSubsection::setFlags(LineFlags Flags) { this->Flags = Flags; }
bool DebugLinesSubsection::hasColumnInfo() const {
return Flags & LF_HaveColumns;
}