[clang][Interp] Implement bitcasts (WIP)

[tbaeder]

Summary

This implements bitcasts by traversing the pointer fields at interpretation-time, copying them into a buffer and then either creating a new primitive value from the buffer, or traversing the destination pointer and reading the field values from that buffer.

This is a bit non-idiomatic to the new interpreter since we do so much work at interpretation time instead of doing it at compile-time.
I can imagine ways to change this, but it would require bytecode instructions that are rather awkward, I think. So this is my attempt at
doing it this way instead.

It's also missing all the eligibility checks for bitcasts of course.
I have also not tested this on a big-endian host, which I definitely need to do (is the bit rotation needed if the host is BE and the target is BE?).

I'll try to leave a few comments in the diff.

[tbaeder]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

92

One of the problems here is that right now, all diagnostics are emitted during interpretation time.

clang/lib/AST/Interp/Interp.h

1456

This is a variable sized array. That needs to go of course, but is the best way to heap allocate? Or can we actually use alloca in clang code?

clang/lib/AST/Interp/InterpBuiltin.cpp

33

This needs to be renamed obviously, but I was wondering if this already exists somewhere in the llvm/clang codebase...

81

Same here, I feel like this should already be available?

[tbaeder]

Ping

[tbaeder]

Ping

[tbaeder]

Ping

[tbaeder]

Ping

[tbaeder]

Ping

[tbaeder]

Ping

[tbaeder]

Ping

[aaron.ballman]

In D144943#4334500, @tbaeder wrote:

Pig

🐷

clang/lib/AST/Interp/ByteCodeExprGen.cpp

74

Member pointer types? Unions? volatile-qualified types? There's quite a few restrictions here for constexpr contexts.

87

We returned earlier if ToType is an array, so this comment is a bit suspicious.

92

Didn't we early return in this case as well?

101

All the same restrictions for ToType apply to FromType: http://eel.is/c++draft/bit.cast#3

clang/lib/AST/Interp/Integral.h

179

Consistency with below.

clang/lib/AST/Interp/Interp.h

1456

We usually go with:

std::vector<std::byte> Buff(BuffSize);
if (!DoBitCast(S, FromPtr, Buff.data(), BuffSize))
  return false;

clang/lib/AST/Interp/InterpBuiltin.cpp

33

I'm not aware of one, but perhaps this exists in LLVM somewhere?

35

We should probably be consistent about using size_t in this class so there's no chance of size conversion between types.

81

See https://github.com/llvm/llvm-project/blob/main/llvm/include/llvm/Support/SwapByteOrder.h

[aaron.ballman]

There's still quite a few unaddressed comments, FWIW.

clang/lib/AST/Interp/Boolean.h

113

[aaron.ballman]

Making it clear that there's more work here.

[tbaeder]

Yes, FWIW I looked into this again last week and noticed a few unsolved problems as well. I'll post a comment once I consider it ready for actual review.

[tbaeder]

I'm gonna close this, since the new approach is too different.

clang/lib/AST/Interp/Boolean.h

from(Integral<SrcBits, SrcSign> Value) {
     return Boolean(!Value.isZero());
   }
 
   template <bool SrcSign>
   static Boolean from(Integral<0, SrcSign> Value) {
     return Boolean(!Value.isZero());
   }
 
+  static Boolean bitcastFromMemory(const std::byte *Buff) {
+    bool Val = static_cast<bool>(*Buff);
+    return Boolean(Val);
+  }
+
+  void bitcastToMemory(std::byte *Buff) { std::memcpy(Buff, &V, sizeof(V)); }
+
   static Boolean zero() { return from(false); }
 
   template <typename T>
   static Boolean from(T Value, unsigned NumBits) {
     return Boolean(Value);
   }
 
   static bool inRange(int64_t Value, unsigned NumBits) {

clang/lib/AST/Interp/ByteCodeExprGen.h

if (FPO.getRoundingMode() == llvm::RoundingMode::Dynamic)
       return llvm::RoundingMode::NearestTiesToEven;
 
     return FPO.getRoundingMode();
   }
 
   bool emitRecordDestruction(const Descriptor *Desc);
   bool emitDerivedToBaseCasts(const RecordType *DerivedType,
                               const RecordType *BaseType, const Expr *E);
+  bool emitBuiltinBitCast(const CastExpr *E);
 
 protected:
   /// Variable to storage mapping.
   llvm::DenseMap<const ValueDecl *, Scope::Local> Locals;
 
   /// OpaqueValueExpr to location mapping.
   llvm::DenseMap<const OpaqueValueExpr *, unsigned> OpaqueExprs;
 

clang/lib/AST/Interp/ByteCodeExprGen.cpp

private:
   /// Old discard flag to restore.
   bool OldDiscardResult;
 };
 
 } // namespace interp
 } // namespace clang
 
 template <class Emitter>
+bool ByteCodeExprGen<Emitter>::emitBuiltinBitCast(const CastExpr *E) {
+  const Expr *SubExpr = E->getSubExpr();
+  QualType FromType = SubExpr->getType();
+  QualType ToType = E->getType();
+
+  // A few invariants. These are invalid for bitcasts.
+  // FIXME: Diagnostics.
+  if (ToType->isArrayType() || ToType->isPointerType())
+    return false;
+
+  assert(!ToType->isReferenceType());
+
+  // Get a pointer to the value-to-cast on the stack.
+  if (!this->visit(SubExpr))
+    return false;
+
+  std::optional<PrimType> FromT = classify(FromType);
+  std::optional<PrimType> ToT = classify(ToType);
+
+  if (!ToT) {
+    // Conversion to an array or record type.
+    return this->emitBitCastPtr(E);
+  }
+
+  // FIXME: Diagnostics.
+  if (*ToT == PT_Ptr)
+    return false;
+
+  assert(ToT);
+  // Source and dest type are the same, just emit a load.
+  if (FromT && *FromT == ToT)
+    return this->emitLoad(*ToT, E);
+
+  // Conversion to a primitive type. FromType can be another
+  // primitive type, or a record/array.
+  //
+  // Same thing for floats, but we need the target
+  // semantics here.
+  if (*ToT == PT_Float) {
+    const auto *TargetSemantics = &Ctx.getFloatSemantics(ToType);
+    return this->emitBitCastFP(TargetSemantics, E);
+  }
+
+  return this->emitBitCast(*ToT, E);
+}
+
+template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitCastExpr(const CastExpr *CE) {
   auto *SubExpr = CE->getSubExpr();
   switch (CE->getCastKind()) {
 
   case CK_LValueToRValue: {
     return dereference(
         CE->getSubExpr(), DerefKind::Read,
         [](PrimType) {
           // Value loaded - nothing to do here.
           return true;
         },
         [this, CE](PrimType T) {
           // Pointer on stack - dereference it.
           if (!this->emitLoadPop(T, CE))
             return false;
           return DiscardResult ? this->emitPop(T, CE) : true;
         });
   }
 
+  case CK_LValueToRValueBitCast:
+    return this->emitBuiltinBitCast(CE);
+
   case CK_UncheckedDerivedToBase:
   case CK_DerivedToBase: {
     if (!this->visit(SubExpr))
       return false;
 
     return this->emitDerivedToBaseCasts(getRecordTy(SubExpr->getType()),
                                         getRecordTy(CE->getType()), CE);
   }
bool ByteCodeExprGen<Emitter>::VisitCastExpr(const CastExpr *CE) {
 
   case CK_ArrayToPointerDecay:
   case CK_AtomicToNonAtomic:
   case CK_ConstructorConversion:
   case CK_FunctionToPointerDecay:
   case CK_NonAtomicToAtomic:
   case CK_NoOp:
   case CK_UserDefinedConversion:
+  case CK_BitCast:
     return this->visit(SubExpr);
 
   case CK_IntegralToBoolean:
   case CK_IntegralCast: {
     std::optional<PrimType> FromT = classify(SubExpr->getType());
     std::optional<PrimType> ToT = classify(CE->getType());
     if (!FromT || !ToT)
       return false;
if (const auto CtorExpr = dyn_cast<CXXConstructExpr>(Initializer)) {
     // RVO functions expect a pointer to initialize on the stack.
     // Dup our existing pointer so it has its own copy to use.
     if (!this->emitDupPtr(Initializer))
       return false;
 
     return this->visit(CE);
   } else if (const auto *DIE = dyn_cast<CXXDefaultInitExpr>(Initializer)) {
     return this->visitInitializer(DIE->getExpr());
+  } else if (const auto *BBCE = dyn_cast<BuiltinBitCastExpr>(Initializer)) {
+    return this->visit(BBCE);
   } else if (const auto *CE = dyn_cast<CastExpr>(Initializer)) {
     return this->visitInitializer(CE->getSubExpr());
   } else if (const auto *CE = dyn_cast<CXXBindTemporaryExpr>(Initializer)) {
     return this->visitInitializer(CE->getSubExpr());
   } else if (const auto *ACO =
                  dyn_cast<AbstractConditionalOperator>(Initializer)) {
     return this->visitConditional(
         ACO, [this](const Expr *E) { return this->visitRecordInitializer(E); });

clang/lib/AST/Interp/Descriptor.h

public:
 
   /// Returns the number of elements stored in the block.
   unsigned getNumElems() const {
     return Size == UnknownSizeMark ? 0 : (getSize() / getElemSize());
   }
 
   /// Checks if the descriptor is of an array of primitives.
   bool isPrimitiveArray() const { return IsArray && !ElemDesc; }
+  /// Checks if the descriptor is of an array of composites.
+  bool isCompositeArray() const { return IsArray && ElemDesc; }
   /// Checks if the descriptor is of an array of zero size.
   bool isZeroSizeArray() const { return Size == 0; }
   /// Checks if the descriptor is of an array of unknown size.
   bool isUnknownSizeArray() const { return Size == UnknownSizeMark; }
 
   /// Checks if the descriptor is of a primitive.
   bool isPrimitive() const { return !IsArray && !ElemRecord; }
 

clang/lib/AST/Interp/Floating.h

static APFloat::opStatus fromIntegral(APSInt Val,
                                         llvm::RoundingMode RM,
                                         Floating &Result) {
     APFloat F = APFloat(Sem);
     APFloat::opStatus Status = F.convertFromAPInt(Val, Val.isSigned(), RM);
     Result = Floating(F);
     return Status;
   }
 
+  static Floating bitcastFromMemory(const std::byte *Buff,
+                                    const llvm::fltSemantics &Sem) {
+    size_t Size = APFloat::semanticsSizeInBits(Sem);
+    llvm::APInt API(Size, true);
+    llvm::LoadIntFromMemory(API, (const uint8_t *)Buff, Size / 8);
+
+    return Floating(APFloat(Sem, API));
+  }
+
+  void bitcastToMemory(std::byte *Buff) {
+    llvm::APInt API = F.bitcastToAPInt();
+    llvm::StoreIntToMemory(API, (uint8_t *)Buff, bitWidth() / 8);
+  }
+
   // -------
 
   static APFloat::opStatus add(const Floating &A, const Floating &B,
                                llvm::RoundingMode RM, Floating *R) {
     *R = Floating(A.F);
     return R->F.add(B.F, RM);
   }
 

clang/lib/AST/Interp/Integral.h

public:
   }
 
   static Integral zero() { return from(0); }
 
   template <typename T> static Integral from(T Value, unsigned NumBits) {
     return Integral(Value);
   }
 
+  static Integral bitcastFromMemory(const std::byte *Buff) {
+    ReprT V;
+
+    std::memcpy(&V, Buff, sizeof(ReprT));
+    return Integral(V);
+  }
+
+  void bitcastToMemory(std::byte *Buff) const {
+    std::memcpy(Buff, &V, sizeof(ReprT));
+  }
+
   static bool inRange(int64_t Value, unsigned NumBits) {
     return CheckRange<ReprT, Min, Max>(Value);
   }
 
   static bool increment(Integral A, Integral *R) {
     return add(A, Integral(ReprT(1)), A.bitWidth(), R);
   }
 

clang/lib/AST/Interp/Interp.h

 bool CheckFloatResult(InterpState &S, CodePtr OpPC, APFloat::opStatus Status);
 
 /// Interpreter entry point.
 bool Interpret(InterpState &S, APValue &Result);
 
 /// Interpret a builtin function.
 bool InterpretBuiltin(InterpState &S, CodePtr &PC, unsigned BuiltinID);
 
+/// Perform a bitcast of all fields of P into Buff. This performs the
+/// actions of a __builtin_bit_cast expression when the target type
+/// is primitive.
+bool DoBitCast(InterpState &S, const Pointer &P, std::byte *Buff,
+               size_t BuffSize);
+
+/// Perform a bitcast of all fields of P into the fields of DestPtr.
+/// This performs the actions of a __builtin_bit_cast expression when
+/// the target type is a composite type.
+bool DoBitCastToPtr(InterpState &S, const Pointer &P, Pointer &DestPtr);
+
 enum class ArithOp { Add, Sub };
 
 //===----------------------------------------------------------------------===//
 // Returning values
 //===----------------------------------------------------------------------===//
 
 template <PrimType Name, bool Builtin = false,
           class T = typename PrimConv<Name>::T>

 
 template <PrimType TIn, PrimType TOut> bool Cast(InterpState &S, CodePtr OpPC) {
   using T = typename PrimConv<TIn>::T;
   using U = typename PrimConv<TOut>::T;
   S.Stk.push<U>(U::from(S.Stk.pop<T>()));
   return true;
 }
 
+template <PrimType Name, class ToT = typename PrimConv<Name>::T>
+bool BitCast(InterpState &S, CodePtr OpPC) {
+  const Pointer &FromPtr = S.Stk.pop<Pointer>();
+
+  constexpr size_t BuffSize = primSize<Name>();
+  std::byte Buff[BuffSize];
+
+  if (!DoBitCast(S, FromPtr, Buff, BuffSize))
+    return false;
+
+  S.Stk.push<ToT>(ToT::bitcastFromMemory(Buff));
+  return true;
+}
+
+/// 1) Pops a pointer from the stack
+/// 2) Peeks a pointer
+/// 3) Bitcasts the contents of the first pointer to the
+///   fields of the second pointer.
+inline bool BitCastPtr(InterpState &S, CodePtr OpPC) {
+  const Pointer &FromPtr = S.Stk.pop<Pointer>();
+  Pointer &ToPtr = S.Stk.peek<Pointer>();
+
+  if (!DoBitCastToPtr(S, FromPtr, ToPtr))
+    return false;
+
+  return true;
+}
+
+/// Bitcast TO a float.
+inline bool BitCastFP(InterpState &S, CodePtr OpPC,
+                      const llvm::fltSemantics *Sem) {
+  const Pointer &FromPtr = S.Stk.pop<Pointer>();
+
+  size_t BuffSize = APFloat::semanticsSizeInBits(*Sem) / 8;
+  std::vector<std::byte> Buff(BuffSize);
+
+  if (!DoBitCast(S, FromPtr, Buff.data(), BuffSize))
+    return false;
+
+  S.Stk.push<Floating>(Floating::bitcastFromMemory(Buff.data(), *Sem));
+  return true;
+}
+
 /// 1) Pops a Floating from the stack.
 /// 2) Pushes a new floating on the stack that uses the given semantics.
 /// Not templated, so implemented in Interp.cpp.
 bool CastFP(InterpState &S, CodePtr OpPC, const llvm::fltSemantics *Sem,
             llvm::RoundingMode RM);
 
 template <PrimType Name, class T = typename PrimConv<Name>::T>
 bool CastIntegralFloating(InterpState &S, CodePtr OpPC,

clang/lib/AST/Interp/InterpBuiltin.cpp

 //===--- InterpBuiltin.cpp - Interpreter for the constexpr VM ---*- 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 "Boolean.h"
 #include "Interp.h"
 #include "PrimType.h"
 #include "clang/Basic/Builtins.h"
+#include "clang/Basic/TargetInfo.h"
 
 namespace clang {
 namespace interp {
 
 bool InterpretBuiltin(InterpState &S, CodePtr &PC, unsigned BuiltinID) {
   APValue Dummy;
 
   switch (BuiltinID) {
   case Builtin::BI__builtin_is_constant_evaluated:
     S.Stk.push<Boolean>(Boolean::from(S.inConstantContext()));
     return Ret<PT_Bool, true>(S, PC, Dummy);
   case Builtin::BI__builtin_assume:
     return RetVoid<true>(S, PC, Dummy);
   default:
     return false;
   }
 
   return false;
 }
 
+struct Foo {
+  std::byte *Buff;
+  size_t Offset;
+  size_t BuffSize;
+  bool BigEndian;
+
+  constexpr Foo(std::byte *Buff, size_t BuffSize, bool BigEndian)
+      : Buff(Buff), Offset(0), BuffSize(BuffSize), BigEndian(BigEndian) {}
+
+  std::byte *getBytesAndAdvance(size_t N) {
+    size_t OldOffset = Offset;
+    Offset += N;
+
+    assert(OldOffset < BuffSize);
+
+    if (BigEndian) {
+      return Buff + BuffSize - OldOffset - N;
+    }
+
+    // Little Endian target.
+    return Buff + OldOffset;
+  }
+};
+
+bool DoBitCast(InterpState &S, const Pointer &P, std::byte *Buff,
+               size_t BuffSize) {
+  Foo F(Buff, BuffSize, S.getCtx().getTargetInfo().isBigEndian());
+
+  P.enumerateFields(S.getContext(), [&](const Pointer &Ptr, PrimType Ty) {
+    if (Ty == PT_Float) {
+      Floating &Val = Ptr.deref<Floating>();
+      std::byte *M = F.getBytesAndAdvance(Val.bitWidth() / 8);
+      Val.bitcastToMemory(M);
+      return;
+    }
+
+    BITCAST_TYPE_SWITCH(Ty, {
+      T Val = Ptr.deref<T>();
+      unsigned SizeInBytes = Val.bitWidth() / 8;
+      std::byte *M = F.getBytesAndAdvance(SizeInBytes);
+      Val.bitcastToMemory(M);
+    });
+  });
+
+  return true;
+}
+
+/// Rotate things around for big endian targets.
+static void swapBytes(std::byte *M, size_t N) {
+  for (size_t I = 0; I != (N / 2); ++I)
+    std::swap(M[I], M[N - 1 - I]);
+}
+
+bool DoBitCastToPtr(InterpState &S, const Pointer &P, Pointer &DestPtr) {
+  const Context &Ctx = S.getContext();
+  bool BigEndian = S.getCtx().getTargetInfo().isBigEndian();
+
+  std::vector<std::byte> Data;
+  P.enumerateFields(Ctx, [&](const Pointer &P, PrimType Ty) {
+    BITCAST_TYPE_SWITCH(Ty, {
+      T Val = P.deref<T>();
+      unsigned SizeInBytes = Val.bitWidth() / 8;
+      unsigned Offset = Data.size();
+      Data.resize(Data.size() + SizeInBytes);
+      Val.bitcastToMemory(Data.data() + Offset);
+
+      if (BigEndian)
+        swapBytes(Data.data() + Offset, SizeInBytes);
+    });
+  });
+
+  unsigned Offset = 0;
+  DestPtr.enumerateFields(Ctx, [&](const Pointer &P, PrimType Ty) {
+    if (Ty == PT_Float) {
+      const auto &Sem = Ctx.getASTContext().getFloatTypeSemantics(
+          P.getFieldDesc()->getType());
+      size_t Size = APFloat::semanticsSizeInBits(Sem) / 8;
+
+      std::byte *M = Data.data() + Offset;
+
+      if (BigEndian)
+        swapBytes(M, Size);
+      P.deref<Floating>() = Floating::bitcastFromMemory(M, Sem);
+      Offset += Size;
+      return;
+    }
+
+    BITCAST_TYPE_SWITCH(Ty, {
+      T &Val = P.deref<T>();
+
+      size_t Size = Val.bitWidth() / 8;
+      std::byte *M = Data.data() + Offset;
+      if (BigEndian)
+        swapBytes(M, Size);
+
+      Val = T::bitcastFromMemory(M);
+      P.initialize();
+      Offset += Size;
+    });
+  });
+  return true;
+}
+
 } // namespace interp
 } // namespace clang

clang/lib/AST/Interp/Opcodes.td

def ToCastTypeClass : TypeClass {
   let Types = [Uint8, Sint8, Uint16, Sint16, Uint32, Sint32, Uint64, Sint64, Bool];
 }
 
 def Cast: Opcode {
   let Types = [FromCastTypeClass, ToCastTypeClass];
   let HasGroup = 1;
 }
 
+def BitCastTypeClass : TypeClass {
+  let Types = [Uint8, Sint8, Uint16, Sint16, Uint32, Sint32, Uint64, Sint64, Bool];
+}
+
+def BitCast : Opcode {
+  let Types = [BitCastTypeClass];
+  let HasGroup = 1;
+}
+
+def BitCastPtr : Opcode;
+
+def BitCastFP : Opcode {
+  let Types = [];
+  let Args = [ArgFltSemantics];
+}
+
 def CastFP : Opcode {
   let Types = [];
   let Args = [ArgFltSemantics, ArgRoundingMode];
 }
 
 // Cast an integer to a floating type
 def CastIntegralFloating : Opcode {
   let Types = [AluTypeClass];

clang/lib/AST/Interp/Pointer.h

 /// ▼                              ▼
 /// ┌───────┬────────────┬─────────┬────────────────────────────┐
 /// │ Block │ InlineDesc │ InitMap │ Actual Data                │
 /// └───────┴────────────┴─────────┴────────────────────────────┘
 ///                      ▲
 ///                      │
 ///                      │
 ///                     Base
+using DataFunc = llvm::function_ref<void(const Pointer &P, PrimType Ty)>;
 class Pointer {
 private:
   static constexpr unsigned PastEndMark = ~0u;
   static constexpr unsigned RootPtrMark = ~0u;
 
 public:
   Pointer() {}
   Pointer(Block *B);
public:
 
   /// Initializes a field.
   void initialize() const;
   /// Activats a field.
   void activate() const;
   /// Deactivates an entire strurcutre.
   void deactivate() const;
 
+  /// Calls F for all fields in this Pointer.
+  void enumerateFields(const Context &Ctx, DataFunc F) const;
+
   /// Checks if two pointers are comparable.
   static bool hasSameBase(const Pointer &A, const Pointer &B);
   /// Checks if two pointers can be subtracted.
   static bool hasSameArray(const Pointer &A, const Pointer &B);
 
   /// Prints the pointer.
   void print(llvm::raw_ostream &OS) const {
     OS << Pointee << " {" << Base << ", " << Offset << ", ";

clang/lib/AST/Interp/Pointer.cpp

for (unsigned I = 0; I != R->getNumBases(); ++I) {
       Result.getStructBase(I) = BasePtr.toRValue(Ctx);
     }
   }
 
   // TODO: Arrays
 
   return Result;
 }
+
+static void enumerateData(const Pointer &P, const Context &Ctx, DataFunc F) {
+  const Descriptor *FieldDesc = P.getFieldDesc();
+  assert(FieldDesc);
+
+  // Primitives.
+  if (FieldDesc->isPrimitive()) {
+    F(P, *Ctx.classify(FieldDesc->getType()));
+    return;
+  }
+
+  // Primitive arrays.
+  if (FieldDesc->isPrimitiveArray()) {
+    QualType ElemType =
+        FieldDesc->getType()->getAsArrayTypeUnsafe()->getElementType();
+    PrimType ElemT = *Ctx.classify(ElemType);
+    for (unsigned I = 0; I != FieldDesc->getNumElems(); ++I) {
+      F(P.atIndex(I), ElemT);
+    }
+    return;
+  }
+
+  // Composite arrays.
+  if (FieldDesc->isCompositeArray()) {
+    for (unsigned I = 0; I != FieldDesc->getNumElems(); ++I)
+      enumerateData(P.atIndex(I).narrow(), Ctx, F);
+    return;
+  }
+
+  // Records.
+  if (FieldDesc->isRecord()) {
+    const Record *R = FieldDesc->ElemRecord;
+    for (unsigned I = 0; I != R->getNumBases(); ++I) {
+      Pointer Elem = P.atField(R->getBase(I)->Offset);
+      enumerateData(Elem, Ctx, F);
+    }
+    // TODO: Virtual bases?
+
+    for (unsigned I = 0; I != R->getNumFields(); ++I) {
+      Pointer Elem = P.atField(R->getField(I)->Offset);
+      enumerateData(Elem, Ctx, F);
+    }
+    return;
+  }
+
+  llvm_unreachable("Unhandled data type");
+}
+
+void Pointer::enumerateFields(const Context &Ctx, DataFunc F) const {
+  enumerateData(*this, Ctx, F);
+}

clang/lib/AST/Interp/PrimType.h

 template <> struct PrimConv<PT_Ptr> { using T = Pointer; };
 template <> struct PrimConv<PT_FnPtr> {
   using T = FunctionPointer;
 };
 
 /// Returns the size of a primitive type in bytes.
 size_t primSize(PrimType Type);
 
+template <PrimType PrimT> constexpr size_t primSize() {
+  return sizeof(typename PrimConv<PrimT>::T);
+}
+
 /// Aligns a size to the pointer alignment.
 constexpr size_t align(size_t Size) {
   return ((Size + alignof(void *) - 1) / alignof(void *)) * alignof(void *);
 }
 
 constexpr bool aligned(uintptr_t Value) { return Value == align(Value); }
 static_assert(aligned(sizeof(void *)));
 
switch (Expr) {                                                            \
       TYPE_SWITCH_CASE(PT_Sint64, B)                                           \
       TYPE_SWITCH_CASE(PT_Uint64, B)                                           \
       TYPE_SWITCH_CASE(PT_Float, B)                                            \
       TYPE_SWITCH_CASE(PT_Bool, B)                                             \
       TYPE_SWITCH_CASE(PT_Ptr, B)                                              \
       TYPE_SWITCH_CASE(PT_FnPtr, B)                                            \
     }                                                                          \
   } while (0)
+
+#define BITCAST_TYPE_SWITCH(Expr, B)                                           \
+  do {                                                                         \
+    switch (Expr) {                                                            \
+      TYPE_SWITCH_CASE(PT_Sint8, B)                                            \
+      TYPE_SWITCH_CASE(PT_Uint8, B)                                            \
+      TYPE_SWITCH_CASE(PT_Sint16, B)                                           \
+      TYPE_SWITCH_CASE(PT_Uint16, B)                                           \
+      TYPE_SWITCH_CASE(PT_Sint32, B)                                           \
+      TYPE_SWITCH_CASE(PT_Uint32, B)                                           \
+      TYPE_SWITCH_CASE(PT_Sint64, B)                                           \
+      TYPE_SWITCH_CASE(PT_Uint64, B)                                           \
+      TYPE_SWITCH_CASE(PT_Bool, B)                                             \
+    default:                                                                   \
+      llvm_unreachable("Unhandled bitcast type");                              \
+    }                                                                          \
+  } while (0)
+
 #define COMPOSITE_TYPE_SWITCH(Expr, B, D)                                      \
   do {                                                                         \
     switch (Expr) {                                                            \
       TYPE_SWITCH_CASE(PT_Ptr, B)                                              \
       default: { D; break; }                                                   \
     }                                                                          \
   } while (0)
 #endif

clang/test/AST/Interp/builtin-bit-cast.cpp

+// RUN: %clang_cc1 -fexperimental-new-constant-interpreter -verify -std=c++2a -fsyntax-only %s
+// RUN: %clang_cc1 -verify=ref -std=c++2a -fsyntax-only %s
+// RUN: %clang_cc1 -verify -std=c++2a -fsyntax-only -triple aarch64_be-linux-gnu -fexperimental-new-constant-interpreter %s
+// RUN: %clang_cc1 -verify -std=c++2a -fsyntax-only -triple aarch64_be-linux-gnu -fexperimental-new-constant-interpreter %s
+
+
+/// ref-no-diagnostics
+
+
+/// FIXME: This is a version of clang/test/SemaCXX/builtin-bit-cast.cpp with
+///   the currently supported subset of operations. They should *all* be
+///   supported though.
+
+
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#  define LITTLE_END 1
+#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+#  define LITTLE_END 0
+#else
+#  error "huh?"
+#endif
+
+template <class T, class V> struct is_same {
+  static constexpr bool value = false;
+};
+template <class T> struct is_same<T, T> {
+  static constexpr bool value = true;
+};
+
+static_assert(sizeof(int) == 4);
+static_assert(sizeof(long long) == 8);
+
+template <class To, class From>
+constexpr To bit_cast(const From &from) {
+  static_assert(sizeof(To) == sizeof(From));
+  return __builtin_bit_cast(To, from);
+}
+
+template <class Intermediate, class Init>
+constexpr bool round_trip(const Init &init) {
+  return bit_cast<Init>(bit_cast<Intermediate>(init)) == init;
+}
+
+static_assert(round_trip<unsigned>((int)-1));
+static_assert(round_trip<unsigned>((int)0x12345678));
+static_assert(round_trip<unsigned>((int)0x87654321));
+static_assert(round_trip<unsigned>((int)0x0C05FEFE));
+static_assert(round_trip<float>((int)0x0C05FEFE));
+
+constexpr unsigned char input[] = {0xCA, 0xFE, 0xBA, 0xBE};
+constexpr unsigned expected = LITTLE_END ? 0xBEBAFECA : 0xCAFEBABE;
+static_assert(bit_cast<unsigned>(input) == expected);
+
+constexpr short S[] = {10, 20};
+constexpr int I = __builtin_bit_cast(int, S);
+static_assert(I == (LITTLE_END ? 1310730 : 655380));
+
+
+struct int_splicer {
+  unsigned x;
+  unsigned y;
+
+  constexpr int_splicer() : x(1), y(2) {}
+  constexpr int_splicer(unsigned x, unsigned y) : x(x), y(y) {}
+
+  constexpr bool operator==(const int_splicer &other) const {
+    return other.x == x && other.y == y;
+  }
+};
+
+constexpr int_splicer splice(0x0C05FEFE, 0xCAFEBABE);
+
+static_assert(bit_cast<unsigned long long>(splice) == (LITTLE_END
+                                                           ? 0xCAFEBABE0C05FEFE
+                                                           : 0x0C05FEFECAFEBABE));
+
+constexpr int_splicer IS = bit_cast<int_splicer>(0xCAFEBABE0C05FEFE);
+static_assert(bit_cast<int_splicer>(0xCAFEBABE0C05FEFE).x == (LITTLE_END
+                                                                  ? 0x0C05FEFE
+                                                                  : 0xCAFEBABE));
+
+static_assert(round_trip<unsigned long long>(splice));
+static_assert(round_trip<long long>(splice));
+
+struct base2 {
+};
+
+struct base3 {
+  unsigned z;
+  constexpr base3() : z(3) {}
+};
+
+struct bases : int_splicer, base2, base3 {
+  unsigned doublez;
+  constexpr bases() : doublez(4) {}
+};
+
+struct tuple4 {
+  unsigned x, y, z, doublez;
+
+  constexpr bool operator==(tuple4 const &other) const {
+    return x == other.x && y == other.y &&
+           z == other.z && doublez == other.doublez;
+  }
+};
+constexpr bases b;// = {{1, 2}, {}, {3}, 4};
+constexpr tuple4 t4 = bit_cast<tuple4>(b);
+
+// Regardless of endianness, this should hold:
+static_assert(t4.x == 1);
+static_assert(t4.y == 2);
+static_assert(t4.z == 3);
+static_assert(t4.doublez == 4);
+//static_assert(t4 == tuple4{1, 2, 3, 4});
+static_assert(round_trip<tuple4>(b));
+
+
+namespace WithBases {
+  struct Base {
+    char A[3] = {1,2,3};
+  };
+
+  struct A : Base {
+    char B = 12;
+  };
+
+  constexpr A a;
+  constexpr unsigned I = __builtin_bit_cast(unsigned, a);
+  static_assert(I == (LITTLE_END ? 201523713 : 16909068));
+};
+
+
+namespace test_array_fill {
+  constexpr unsigned char a[4] = {1, 2};
+  constexpr unsigned int i = bit_cast<unsigned int>(a);
+  static_assert(i == (LITTLE_END ? 0x00000201 : 0x01020000));
+}
+
+namespace Another {
+  constexpr char C[] = {1,2,3,4};
+  struct F{ short a; short b; };
+  constexpr F f = __builtin_bit_cast(F, C);
+
+#if LITTLE_END
+  static_assert(f.a == 513);
+  static_assert(f.b == 1027);
+#else
+  static_assert(f.a == 258);
+  static_assert(f.b == 772);
+#endif
+}
+
+
+namespace FloatToDouble {
+  constexpr float F1[] = {1.0f, 2.0f};
+  constexpr double D1 = __builtin_bit_cast(double, F1);
+  static_assert(D1 > 0);
+};
+
+
+namespace array_members {
+  struct S {
+    int ar[3];
+
+    constexpr bool operator==(const S &rhs) {
+      return ar[0] == rhs.ar[0] && ar[1] == rhs.ar[1] && ar[2] == rhs.ar[2];
+    }
+  };
+
+  struct G {
+    int a, b, c;
+
+    constexpr bool operator==(const G &rhs) {
+      return a == rhs.a && b == rhs.b && c == rhs.c;
+    }
+  };
+
+  constexpr S s{{1, 2, 3}};
+  constexpr G g = bit_cast<G>(s);
+  static_assert(g.a == 1 && g.b == 2 && g.c == 3);
+
+  static_assert(round_trip<G>(s));
+  static_assert(round_trip<S>(g));
+}
+
+namespace CompositeArrays {
+  struct F {
+    int a;
+    int b;
+  };
+
+  static_assert(sizeof(long) == 2 * sizeof(int));
+
+  constexpr F ff[] = {{1,2}};
+  constexpr long L = __builtin_bit_cast(long, ff);
+
+#if LITTLE_END
+  static_assert(L == 8589934593);
+#else
+  static_assert(L == 4294967298);
+#endif
+}
+
+typedef decltype(nullptr) nullptr_t;
+
+/// FIXME: This works in the current interpreter, but it's weird and GCC
+///   rejects it as well.
+constexpr int test_from_nullptr_pass = (__builtin_bit_cast(unsigned char[8], nullptr), 0); // expected-error {{must be initialized by a constant expression}}
+
+/// FIXME: The current interpreter allows bitcasting to nullptr_t, but
+///   GCC does not.
+constexpr int test_to_nullptr() {
+  nullptr_t npt = __builtin_bit_cast(nullptr_t, 0ul);
+
+  struct indet_mem {
+    unsigned char data[sizeof(void *)];
+  };
+  indet_mem im = __builtin_bit_cast(indet_mem, nullptr);
+  nullptr_t npt2 = __builtin_bit_cast(nullptr_t, im);
+
+  return 0;
+}
+
+constexpr int ttn = test_to_nullptr(); // expected-error {{must be initialized by a constant expression}}
+
+
+
+

clang/test/AST/Interp/literals.cpp

 static_assert(~e == -1, "");
 
 
 constexpr int m = 10;
 constexpr const int *p = &m;
 static_assert(p != nullptr, "");
 static_assert(*p == 10, "");
 
+constexpr const void *cp = (void *)p;
+// FIXME: This should be an error in the new interpreter.
+constexpr const int *pm = (int*)cp; // ref-error {{ must be initialized by a constant expression}} \
+                                    // ref-note {{cast from 'const void *' is not allowed}}
+
 constexpr const int* getIntPointer() {
   return &m;
 }
 static_assert(getIntPointer() == &m, "");
 static_assert(*getIntPointer() == 10, "");
 
 constexpr int gimme(int k) {
   return k;