lib/DebugInfo/CodeView/DebugLinesSubsection.cpp

   1 //===- DebugLinesSubsection.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 "llvm/DebugInfo/CodeView/DebugLinesSubsection.h"
  10 #include "llvm/ADT/ArrayRef.h"
  11 #include "llvm/DebugInfo/CodeView/CodeView.h"
  12 #include "llvm/DebugInfo/CodeView/CodeViewError.h"
  13 #include "llvm/DebugInfo/CodeView/DebugChecksumsSubsection.h"
  14 #include "llvm/Support/BinaryStreamReader.h"
  15 #include "llvm/Support/BinaryStreamWriter.h"
  16 #include "llvm/Support/Error.h"
  17 #include <cassert>
  18 #include <cstdint>
  19
  20 using namespace llvm;
  21 using namespace llvm::codeview;
  22
  23 Error LineColumnExtractor::operator()(BinaryStreamRef Stream, uint32_t &Len,
  24                                       LineColumnEntry &Item) {
  25   const LineBlockFragmentHeader *BlockHeader;
  26   BinaryStreamReader Reader(Stream);
  27   if (auto EC = Reader.readObject(BlockHeader))
  28     return EC;
  29   bool HasColumn = Header->Flags & uint16_t(LF_HaveColumns);
  30   uint32_t LineInfoSize =
  31       BlockHeader->NumLines *
  32       (sizeof(LineNumberEntry) + (HasColumn ? sizeof(ColumnNumberEntry) : 0));
  33   if (BlockHeader->BlockSize < sizeof(LineBlockFragmentHeader))
  34     return make_error<CodeViewError>(cv_error_code::corrupt_record,
  35                                      "Invalid line block record size");
  36   uint32_t Size = BlockHeader->BlockSize - sizeof(LineBlockFragmentHeader);
  37   if (LineInfoSize > Size)
  38     return make_error<CodeViewError>(cv_error_code::corrupt_record,
  39                                      "Invalid line block record size");
  40   // The value recorded in BlockHeader->BlockSize includes the size of
  41   // LineBlockFragmentHeader.
  42   Len = BlockHeader->BlockSize;
  43   Item.NameIndex = BlockHeader->NameIndex;
  44   if (auto EC = Reader.readArray(Item.LineNumbers, BlockHeader->NumLines))
  45     return EC;
  46   if (HasColumn) {
  47     if (auto EC = Reader.readArray(Item.Columns, BlockHeader->NumLines))
  48       return EC;
  49   }
  50   return Error::success();
  51 }
  52
  53 DebugLinesSubsectionRef::DebugLinesSubsectionRef()
  54     : DebugSubsectionRef(DebugSubsectionKind::Lines) {}
  55
  56 Error DebugLinesSubsectionRef::initialize(BinaryStreamReader Reader) {
  57   if (auto EC = Reader.readObject(Header))
  58     return EC;
  59
  60   LinesAndColumns.getExtractor().Header = Header;
  61   if (auto EC = Reader.readArray(LinesAndColumns, Reader.bytesRemaining()))
  62     return EC;
  63
  64   return Error::success();
  65 }
  66
  67 bool DebugLinesSubsectionRef::hasColumnInfo() const {
  68   return !!(Header->Flags & LF_HaveColumns);
  69 }
  70
  71 DebugLinesSubsection::DebugLinesSubsection(DebugChecksumsSubsection &Checksums,
  72                                            DebugStringTableSubsection &Strings)
  73     : DebugSubsection(DebugSubsectionKind::Lines), Checksums(Checksums) {}
  74
  75 void DebugLinesSubsection::createBlock(StringRef FileName) {
  76   uint32_t Offset = Checksums.mapChecksumOffset(FileName);
  77
  78   Blocks.emplace_back(Offset);
  79 }
  80
  81 void DebugLinesSubsection::addLineInfo(uint32_t Offset, const LineInfo &Line) {
  82   Block &B = Blocks.back();
  83   LineNumberEntry LNE;
  84   LNE.Flags = Line.getRawData();
  85   LNE.Offset = Offset;
  86   B.Lines.push_back(LNE);
  87 }
  88
  89 void DebugLinesSubsection::addLineAndColumnInfo(uint32_t Offset,
  90                                                 const LineInfo &Line,
  91                                                 uint32_t ColStart,
  92                                                 uint32_t ColEnd) {
  93   Block &B = Blocks.back();
  94   assert(B.Lines.size() == B.Columns.size());
  95
  96   addLineInfo(Offset, Line);
  97   ColumnNumberEntry CNE;
  98   CNE.StartColumn = ColStart;
  99   CNE.EndColumn = ColEnd;
 100   B.Columns.push_back(CNE);
 101 }
 102
 103 Error DebugLinesSubsection::commit(BinaryStreamWriter &Writer) const {
 104   LineFragmentHeader Header;
 105   Header.CodeSize = CodeSize;
 106   Header.Flags = hasColumnInfo() ? LF_HaveColumns : 0;
 107   Header.RelocOffset = RelocOffset;
 108   Header.RelocSegment = RelocSegment;
 109
 110   if (auto EC = Writer.writeObject(Header))
 111     return EC;
 112
 113   for (const auto &B : Blocks) {
 114     LineBlockFragmentHeader BlockHeader;
 115     assert(B.Lines.size() == B.Columns.size() || B.Columns.empty());
 116
 117     BlockHeader.NumLines = B.Lines.size();
 118     BlockHeader.BlockSize = sizeof(LineBlockFragmentHeader);
 119     BlockHeader.BlockSize += BlockHeader.NumLines * sizeof(LineNumberEntry);
 120     if (hasColumnInfo())
 121       BlockHeader.BlockSize += BlockHeader.NumLines * sizeof(ColumnNumberEntry);
 122     BlockHeader.NameIndex = B.ChecksumBufferOffset;
 123     if (auto EC = Writer.writeObject(BlockHeader))
 124       return EC;
 125
 126     if (auto EC = Writer.writeArray(makeArrayRef(B.Lines)))
 127       return EC;
 128
 129     if (hasColumnInfo()) {
 130       if (auto EC = Writer.writeArray(makeArrayRef(B.Columns)))
 131         return EC;
 132     }
 133   }
 134   return Error::success();
 135 }
 136
 137 uint32_t DebugLinesSubsection::calculateSerializedSize() const {
 138   uint32_t Size = sizeof(LineFragmentHeader);
 139   for (const auto &B : Blocks) {
 140     Size += sizeof(LineBlockFragmentHeader);
 141     Size += B.Lines.size() * sizeof(LineNumberEntry);
 142     if (hasColumnInfo())
 143       Size += B.Columns.size() * sizeof(ColumnNumberEntry);
 144   }
 145   return Size;
 146 }
 147
 148 void DebugLinesSubsection::setRelocationAddress(uint16_t Segment,
 149                                                 uint32_t Offset) {
 150   RelocOffset = Offset;
 151   RelocSegment = Segment;
 152 }
 153
 154 void DebugLinesSubsection::setCodeSize(uint32_t Size) { CodeSize = Size; }
 155
 156 void DebugLinesSubsection::setFlags(LineFlags Flags) { this->Flags = Flags; }
 157
 158 bool DebugLinesSubsection::hasColumnInfo() const {
 159   return Flags & LF_HaveColumns;
 160 }