Handle BitCast and BitCastFP opcodes the same

Author: tbaederr

clang/lib/AST/Interp/ByteCodeExprGen.cpp

@@ -117,23 +117,18 @@ bool ByteCodeExprGen<Emitter>::emitBuiltinBitCast(const CastExpr *E) {
 
   assert(ToT);
 
+  const llvm::fltSemantics *TargetSemantics = nullptr;
+  if (ToT == PT_Float)
+    TargetSemantics = &Ctx.getFloatSemantics(ToType);
+
   // 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);
-    CharUnits FloatSize = Ctx.getASTContext().getTypeSizeInChars(ToType);
-    return this->emitBitCastFP(TargetSemantics, FloatSize.getQuantity(), E);
-  }
-
   bool ToTypeIsUChar = (ToType->isSpecificBuiltinType(BuiltinType::UChar) ||
                         ToType->isSpecificBuiltinType(BuiltinType::Char_U));
   uint32_t ResultBitWidth = std::max(Ctx.getBitWidth(ToType), 8u);
 
   if (!this->emitBitCast(*ToT, ToTypeIsUChar || ToType->isStdByteType(),
-                         ResultBitWidth, E))
+                         ResultBitWidth, TargetSemantics, E))
     return false;
 
   if (DiscardResult)

clang/lib/AST/Interp/Interp.h

@@ -1578,7 +1578,8 @@ template <PrimType TIn, PrimType TOut> bool Cast(InterpState &S, CodePtr OpPC) {
 
 template <PrimType Name, class ToT = typename PrimConv<Name>::T>
 bool BitCast(InterpState &S, CodePtr OpPC, bool TargetIsUCharOrByte,
-             uint32_t ResultBitWidth) {
+             uint32_t ResultBitWidth, const llvm::fltSemantics *Sem) {
+  assert(ResultBitWidth > 0);
   const Pointer &FromPtr = S.Stk.pop<Pointer>();
 
   size_t BuffSize = ResultBitWidth / 8;
@@ -1591,27 +1592,13 @@ bool BitCast(InterpState &S, CodePtr OpPC, bool TargetIsUCharOrByte,
   if (!CheckBitcast(S, OpPC, HasIndeterminateBits, TargetIsUCharOrByte))
     return false;
 
-  S.Stk.push<ToT>(ToT::bitcastFromMemory(Buff.data(), ResultBitWidth));
-  return true;
-}
-
-/// Bitcast TO a float.
-inline bool BitCastFP(InterpState &S, CodePtr OpPC,
-                      const llvm::fltSemantics *Sem, uint32_t TargetSize) {
-  const Pointer &FromPtr = S.Stk.pop<Pointer>();
-
-  std::vector<std::byte> Buff(TargetSize);
-  bool HasIndeterminateBits = false;
-
-  if (!DoBitCast(S, OpPC, FromPtr, Buff.data(), TargetSize,
-                 HasIndeterminateBits))
-    return false;
-
-  if (!CheckBitcast(S, OpPC, HasIndeterminateBits,
-                    /*TargetIsUCharOrByte=*/false))
-    return false;
-
-  S.Stk.push<Floating>(Floating::bitcastFromMemory(Buff.data(), *Sem));
+  if constexpr (std::is_same_v<ToT, Floating>) {
+    assert(Sem);
+    S.Stk.push<Floating>(Floating::bitcastFromMemory(Buff.data(), *Sem));
+  } else {
+    assert(!Sem);
+    S.Stk.push<ToT>(ToT::bitcastFromMemory(Buff.data(), ResultBitWidth));
+  }
   return true;
 }
 

clang/lib/AST/Interp/Opcodes.td

@@ -586,22 +586,17 @@ def Cast: Opcode {
 }
 
 def BitCastTypeClass : TypeClass {
-  let Types = [Uint8, Sint8, Uint16, Sint16, Uint32, Sint32, Uint64, Sint64, IntAP, IntAPS, Bool];
+  let Types = [Uint8, Sint8, Uint16, Sint16, Uint32, Sint32, Uint64, Sint64, IntAP, IntAPS, Bool, Float];
 }
 
 def BitCast : Opcode {
   let Types = [BitCastTypeClass];
   let HasGroup = 1;
-  let Args = [ArgBool, ArgUint32];
+  let Args = [ArgBool, ArgUint32, ArgFltSemantics];
 }
 
 def BitCastPtr : Opcode;
 
-def BitCastFP : Opcode {
-  let Types = [];
-  let Args = [ArgFltSemantics, ArgUint32];
-}
-
 def CastFP : Opcode {
   let Types = [];
   let Args = [ArgFltSemantics, ArgRoundingMode];