LCOV - code coverage report
Current view: top level - lib/Support - BinaryStreamWriter.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 35 36 97.2 %
Date: 2018-09-23 13:06:45 Functions: 10 10 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- BinaryStreamWriter.cpp - Writes objects to a BinaryStream ----------===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : 
      10             : #include "llvm/Support/BinaryStreamWriter.h"
      11             : 
      12             : #include "llvm/Support/BinaryStreamError.h"
      13             : #include "llvm/Support/BinaryStreamReader.h"
      14             : #include "llvm/Support/BinaryStreamRef.h"
      15             : 
      16             : using namespace llvm;
      17             : 
      18        2204 : BinaryStreamWriter::BinaryStreamWriter(WritableBinaryStreamRef Ref)
      19        2204 :     : Stream(Ref) {}
      20             : 
      21        2593 : BinaryStreamWriter::BinaryStreamWriter(WritableBinaryStream &Stream)
      22        2593 :     : Stream(Stream) {}
      23             : 
      24        2658 : BinaryStreamWriter::BinaryStreamWriter(MutableArrayRef<uint8_t> Data,
      25        2658 :                                        llvm::support::endianness Endian)
      26        2658 :     : Stream(Data, Endian) {}
      27             : 
      28       78434 : Error BinaryStreamWriter::writeBytes(ArrayRef<uint8_t> Buffer) {
      29      156868 :   if (auto EC = Stream.writeBytes(Offset, Buffer))
      30             :     return EC;
      31       78422 :   Offset += Buffer.size();
      32             :   return Error::success();
      33             : }
      34             : 
      35       10526 : Error BinaryStreamWriter::writeCString(StringRef Str) {
      36       21052 :   if (auto EC = writeFixedString(Str))
      37             :     return EC;
      38       10526 :   if (auto EC = writeObject('\0'))
      39             :     return EC;
      40             : 
      41             :   return Error::success();
      42             : }
      43             : 
      44       10656 : Error BinaryStreamWriter::writeFixedString(StringRef Str) {
      45             : 
      46       10656 :   return writeBytes(arrayRefFromStringRef(Str));
      47             : }
      48             : 
      49         575 : Error BinaryStreamWriter::writeStreamRef(BinaryStreamRef Ref) {
      50         575 :   return writeStreamRef(Ref, Ref.getLength());
      51             : }
      52             : 
      53         575 : Error BinaryStreamWriter::writeStreamRef(BinaryStreamRef Ref, uint32_t Length) {
      54        1150 :   BinaryStreamReader SrcReader(Ref.slice(0, Length));
      55             :   // This is a bit tricky.  If we just call readBytes, we are requiring that it
      56             :   // return us the entire stream as a contiguous buffer.  There is no guarantee
      57             :   // this can be satisfied by returning a reference straight from the buffer, as
      58             :   // an implementation may not store all data in a single contiguous buffer.  So
      59             :   // we iterate over each contiguous chunk, writing each one in succession.
      60        1987 :   while (SrcReader.bytesRemaining() > 0) {
      61        1412 :     ArrayRef<uint8_t> Chunk;
      62        2824 :     if (auto EC = SrcReader.readLongestContiguousChunk(Chunk))
      63             :       return EC;
      64        2824 :     if (auto EC = writeBytes(Chunk))
      65             :       return EC;
      66             :   }
      67             :   return Error::success();
      68             : }
      69             : 
      70             : std::pair<BinaryStreamWriter, BinaryStreamWriter>
      71         792 : BinaryStreamWriter::split(uint32_t Off) const {
      72             :   assert(getLength() >= Off);
      73             : 
      74         792 :   WritableBinaryStreamRef First = Stream.drop_front(Offset);
      75             : 
      76         792 :   WritableBinaryStreamRef Second = First.drop_front(Off);
      77        1584 :   First = First.keep_front(Off);
      78        1584 :   BinaryStreamWriter W1{First};
      79        1584 :   BinaryStreamWriter W2{Second};
      80         792 :   return std::make_pair(W1, W2);
      81             : }
      82             : 
      83        2095 : Error BinaryStreamWriter::padToAlignment(uint32_t Align) {
      84        4190 :   uint32_t NewOffset = alignTo(Offset, Align);
      85        2095 :   if (NewOffset > getLength())
      86           0 :     return make_error<BinaryStreamError>(stream_error_code::stream_too_short);
      87        3672 :   while (Offset < NewOffset)
      88        3154 :     if (auto EC = writeInteger('\0'))
      89             :       return EC;
      90             :   return Error::success();
      91             : }

Generated by: LCOV version 1.13