[clang][bytecode] Handle bitcasts involving bitfields

Author: tbaederr

clang/lib/AST/ByteCode/BitcastBuffer.cpp

@@ -0,0 +1,88 @@
+//===-------------------- 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"
+
+using namespace clang;
+using namespace clang::interp;
+
+void BitcastBuffer::pushData(const std::byte *In, size_t BitOffset,
+                             size_t BitWidth, Endian TargetEndianness) {
+  for (unsigned It = 0; It != BitWidth; ++It) {
+    bool BitValue = bitof(In, It);
+    if (!BitValue)
+      continue;
+
+    unsigned DstBit;
+    if (TargetEndianness == Endian::Little)
+      DstBit = BitOffset + It;
+    else
+      DstBit = size() - BitOffset - BitWidth + It;
+
+    unsigned DstByte = (DstBit / 8);
+    Data[DstByte] |= std::byte{1} << (DstBit % 8);
+  }
+}
+
+std::unique_ptr<std::byte[]>
+BitcastBuffer::copyBits(unsigned BitOffset, unsigned BitWidth,
+                        unsigned FullBitWidth, Endian TargetEndianness) const {
+  assert(BitWidth <= FullBitWidth);
+  assert(fullByte(FullBitWidth));
+  auto Out = std::make_unique<std::byte[]>(FullBitWidth / 8);
+
+  for (unsigned It = 0; It != BitWidth; ++It) {
+    unsigned BitIndex;
+    if (TargetEndianness == Endian::Little)
+      BitIndex = BitOffset + It;
+    else
+      BitIndex = size() - BitWidth - BitOffset + It;
+
+    bool BitValue = bitof(Data.get(), BitIndex);
+    if (!BitValue)
+      continue;
+    unsigned DstBit = It;
+    unsigned DstByte = (DstBit / 8);
+    Out[DstByte] |= std::byte{1} << (DstBit % 8);
+  }
+
+  return Out;
+}
+
+#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

clang/lib/AST/ByteCode/BitcastBuffer.h

@@ -0,0 +1,67 @@
+//===--------------------- BitcastBuffer.h ----------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+#ifndef LLVM_CLANG_AST_INTERP_BITCAST_BUFFER_H
+#define LLVM_CLANG_AST_INTERP_BITCAST_BUFFER_H
+
+#include <cassert>
+#include <cstddef>
+#include <memory>
+
+namespace clang {
+namespace interp {
+
+enum class Endian { Little, Big };
+
+/// Returns the value of the bit in the given sequence of bytes.
+static inline bool bitof(const std::byte *B, unsigned BitIndex) {
+  return (B[BitIndex / 8] & (std::byte{1} << (BitIndex % 8))) != std::byte{0};
+}
+
+/// Returns whether \p N is a full byte offset or size.
+static inline bool fullByte(unsigned N) { return N % 8 == 0; }
+
+/// Track what bits have been initialized to known values and which ones
+/// have indeterminate value.
+/// All offsets are in bits.
+struct BitcastBuffer {
+  size_t FinalBitSize = 0;
+  std::unique_ptr<std::byte[]> Data;
+
+  BitcastBuffer(size_t FinalBitSize) : FinalBitSize(FinalBitSize) {
+    assert(fullByte(FinalBitSize));
+    unsigned ByteSize = FinalBitSize / 8;
+    Data = std::make_unique<std::byte[]>(ByteSize);
+  }
+
+  /// Returns the buffer size in bits.
+  size_t size() const { return FinalBitSize; }
+
+  /// Returns \c true if all bits in the buffer have been initialized.
+  bool allInitialized() const {
+    // FIXME: Implement.
+    return true;
+  }
+
+  /// Push \p BitWidth bits at \p BitOffset from \p In into the buffer.
+  /// \p TargetEndianness is the endianness of the target we're compiling for.
+  /// \p In must hold at least \p BitWidth many bits.
+  void pushData(const std::byte *In, size_t BitOffset, size_t BitWidth,
+                Endian TargetEndianness);
+
+  /// Copy \p BitWidth bits at offset \p BitOffset from the buffer.
+  /// \p TargetEndianness is the endianness of the target we're compiling for.
+  ///
+  /// The returned output holds exactly (\p FullBitWidth / 8) bytes.
+  std::unique_ptr<std::byte[]> copyBits(unsigned BitOffset, unsigned BitWidth,
+                                        unsigned FullBitWidth,
+                                        Endian TargetEndianness) const;
+};
+
+} // namespace interp
+} // namespace clang
+#endif

clang/lib/AST/ByteCode/Boolean.h

@@ -82,9 +82,7 @@ class Boolean final {
   Boolean truncate(unsigned TruncBits) const { return *this; }
 
   static Boolean bitcastFromMemory(const std::byte *Buff, unsigned BitWidth) {
-    // Boolean width is currently always 8 for all supported targets. If this
-    // changes we need to get the bool width from the target info.
-    assert(BitWidth == 8);
+    // Just load the first byte.
     bool Val = static_cast<bool>(*Buff);
     return Boolean(Val);
   }

clang/lib/AST/ByteCode/Integral.h

@@ -181,6 +181,7 @@ template <unsigned Bits, bool Signed> class Integral final {
   }
 
   Integral truncate(unsigned TruncBits) const {
+    assert(TruncBits >= 1);
     if (TruncBits >= Bits)
       return *this;
     const ReprT BitMask = (ReprT(1) << ReprT(TruncBits)) - 1;