BitcastBuffer.cpp

//===-------------------- Bitcastbuffer.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 "BitcastBuffer.h"
#include "llvm/ADT/STLExtras.h"

using namespace clang;
using namespace clang::interp;

/// Returns the value of the bit in the given sequence of bytes.
static inline bool bitof(const std::byte *B, Bits BitIndex) {
  return (B[BitIndex.roundToBytes()] &
          (std::byte{1} << BitIndex.getOffsetInByte())) != std::byte{0};
}

void BitcastBuffer::pushData(const std::byte *In, Bits BitOffset, Bits BitWidth,
                             Endian TargetEndianness) {
  for (unsigned It = 0; It != BitWidth.getQuantity(); ++It) {
    bool BitValue = bitof(In, Bits(It));
    if (!BitValue)
      continue;

    Bits DstBit;
    if (TargetEndianness == Endian::Little)
      DstBit = BitOffset + Bits(It);
    else
      DstBit = size() - BitOffset - BitWidth + Bits(It);

    size_t DstByte = DstBit.roundToBytes();
    Data[DstByte] |= std::byte{1} << DstBit.getOffsetInByte();
  }
}

std::unique_ptr<std::byte[]>
BitcastBuffer::copyBits(Bits BitOffset, Bits BitWidth, Bits FullBitWidth,
                        Endian TargetEndianness) const {
  assert(BitWidth.getQuantity() <= FullBitWidth.getQuantity());
  assert(FullBitWidth.isFullByte());
  auto Out = std::make_unique<std::byte[]>(FullBitWidth.roundToBytes());

  for (unsigned It = 0; It != BitWidth.getQuantity(); ++It) {
    Bits BitIndex;
    if (TargetEndianness == Endian::Little)
      BitIndex = BitOffset + Bits(It);
    else
      BitIndex = size() - BitWidth - BitOffset + Bits(It);

    bool BitValue = bitof(Data.get(), BitIndex);
    if (!BitValue)
      continue;

    Bits DstBit = Bits(It);
    size_t DstByte = DstBit.roundToBytes();
    Out[DstByte] |= std::byte{1} << DstBit.getOffsetInByte();
  }

  return Out;
}

bool BitcastBuffer::allInitialized() const {
  return rangeInitialized(Bits::zero(), FinalBitSize);
}

void BitcastBuffer::markInitialized(Bits Offset, Bits Length) {
  if (Length.isZero())
    return;

  BitRange Element(Offset, Offset + Length - Bits(1));
  if (InitializedBits.empty()) {
    InitializedBits.push_back(Element);
    return;
  }

  assert(InitializedBits.size() >= 1);
  // Common case of just appending.
  Bits End = InitializedBits.back().End;
  if (End <= Offset) {
    // Merge this range with the last one.
    // In the best-case scenario, this means we only ever have
    // one single bit range covering all bits.
    if (End == (Offset - Bits(1))) {
      InitializedBits.back().End = Element.End;
      return;
    }

    // Otherwise, we can simply append.
    InitializedBits.push_back(Element);
  } else {
    // Insert sorted.
    auto It = llvm::upper_bound(InitializedBits, Element);
    InitializedBits.insert(It, Element);
  }

#ifndef NDEBUG
  // Ensure ranges are sorted and non-overlapping.
  assert(llvm::is_sorted(InitializedBits));
  for (unsigned I = 1; I != InitializedBits.size(); ++I) {
    [[maybe_unused]] auto Prev = InitializedBits[I - 1];
    [[maybe_unused]] auto Cur = InitializedBits[I];
    assert(Prev.End.N < Cur.Start.N);
  }
#endif
}

bool BitcastBuffer::rangeInitialized(Bits Offset, Bits Length) const {
  if (Length.isZero())
    return true;

  BitRange Range(Offset, Offset + Length - Bits(1));
  Bits Sum;
  bool FoundStart = false;
  for (BitRange BR : InitializedBits) {
    if (FoundStart) {
      if (BR.contains(Range.End)) {
        Sum += (Range.End - BR.Start + Bits(1));
        break;
      }

      // Else, BR is completely inside Range.
      Sum += BR.size();
    }
    if (BR.contains(Range.Start)) {
      Sum += (BR.End - Range.Start + Bits(1));
      FoundStart = true;
    }
  }

  // Note that Sum can be larger than Range, e.g. when Range is fully
  // contained in one range.
  return Sum >= Range.size();
}

#if 0
  template<typename T>
  static std::string hex(T t) {
    std::stringstream stream;
    stream << std::hex << (int)t;
    return std::string(stream.str());
  }


  void BitcastBuffer::dump(bool AsHex = true) const {
    llvm::errs() << "LSB\n  ";
    unsigned LineLength = 0;
    for (unsigned I = 0; I != (FinalBitSize / 8); ++I) {
      std::byte B = Data[I];
      if (AsHex) {
        std::stringstream stream;
        stream << std::hex << (int)B;
        llvm::errs() << stream.str();
        LineLength += stream.str().size() + 1;
      } else {
        llvm::errs() << std::bitset<8>((int)B).to_string();
        LineLength += 8 + 1;
        // llvm::errs() << (int)B;
      }
      llvm::errs() << ' ';
    }
    llvm::errs() << '\n';

    for (unsigned I = 0; I != LineLength; ++I)
      llvm::errs() << ' ';
    llvm::errs() << "MSB\n";
  }
#endif