[clang] Implement constexpr bit_cast for vectors

[DaPorkchop_]

Summary

This makes __builtin_bit_cast support converting to and from vector types in a constexpr context.

Without this patch, attempting to use std::bit_cast with a vector type will fail to compile with a message such as:
constexpr bit_cast involving type '__attribute__((__vector_size__(4 * sizeof(int)))) int const' (vector of 4 'int' values) is not yet supported

clang/lib/AST/ExprConstant.cpp

bool visit(const APValue &Val, QualType Ty, CharUnits Offset) {
     case APValue::Int:
       return visitInt(Val.getInt(), Ty, Offset);
     case APValue::Float:
       return visitFloat(Val.getFloat(), Ty, Offset);
     case APValue::Array:
       return visitArray(Val, Ty, Offset);
     case APValue::Struct:
       return visitRecord(Val, Ty, Offset);
+    case APValue::Vector:
+      return visitVector(Val, Ty, Offset);
 
     case APValue::ComplexInt:
     case APValue::ComplexFloat:
-    case APValue::Vector:
     case APValue::FixedPoint:
       // FIXME: We should support these.
 
     case APValue::Union:
     case APValue::MemberPointer:
     case APValue::AddrLabelDiff: {
       Info.FFDiag(BCE->getBeginLoc(),
                   diag::note_constexpr_bit_cast_unsupported_type)
if (Val.hasArrayFiller()) {
         if (!visit(Filler, CAT->getElementType(), Offset + I * ElemWidth))
           return false;
       }
     }
 
     return true;
   }
 
+  bool visitVector(const APValue &Val, QualType Ty, CharUnits Offset) {
+    const auto *VT = Ty->castAs<VectorType>();
+
+    CharUnits ElemWidth = Info.Ctx.getTypeSizeInChars(VT->getElementType());
+    unsigned VectorLength = Val.getVectorLength();
+    // Visit each of the vector elements
+    for (unsigned I = 0; I != VectorLength; ++I) {
+      const APValue &SubObj = Val.getVectorElt(I);
+      if (!visit(SubObj, VT->getElementType(), Offset + I * ElemWidth))
+        return false;
+    }
+
+    return true;
+  }
+
   bool visitInt(const APSInt &Val, QualType Ty, CharUnits Offset) {
     APSInt AdjustedVal = Val;
     unsigned Width = AdjustedVal.getBitWidth();
     if (Ty->isBooleanType()) {
       Width = Info.Ctx.getTypeSize(Ty);
       AdjustedVal = AdjustedVal.extend(Width);
     }
 
for (size_t I = 0; I != Size; ++I) {
       if (!ElementValue)
         return std::nullopt;
       ArrayValue.getArrayInitializedElt(I) = std::move(*ElementValue);
     }
 
     return ArrayValue;
   }
 
+  std::optional<APValue> visit(const VectorType *Ty, CharUnits Offset) {
+    size_t NumElements = Ty->getNumElements();
+    CharUnits ElementWidth = Info.Ctx.getTypeSizeInChars(Ty->getElementType());
+
+    SmallVector<APValue, 4> Elts;
+    for (size_t I = 0; I != NumElements; ++I) {
+      std::optional<APValue> ElementValue =
+          visitType(Ty->getElementType(), Offset + I * ElementWidth);
+      if (!ElementValue)
+        return std::nullopt;
+      Elts.push_back(std::move(*ElementValue));
+    }
+
+    return APValue(Elts.data(), Elts.size());
+  }
+
   std::optional<APValue> visit(const Type *Ty, CharUnits Offset) {
     return unsupportedType(QualType(Ty, 0));
   }
 
   std::optional<APValue> visitType(QualType Ty, CharUnits Offset) {
     QualType Can = Ty.getCanonicalType();
 
     switch (Can->getTypeClass()) {

clang/test/SemaCXX/constexpr-builtin-bit-cast.cpp

 constexpr long double fivehundredandthirtynine = 539.0;
 
 static_assert(bit_cast<long double>(ld539) == fivehundredandthirtynine, "");
 
 #else
 static_assert(round_trip<__int128_t>(34.0L));
 #endif
 }
+
+namespace test_vector {
+
+typedef unsigned uint2 __attribute__((vector_size(2 * sizeof(unsigned))));
+typedef char byte8 __attribute__((vector_size(sizeof(unsigned long long))));
+
+constexpr uint2 test_vector = { 0x0C05FEFE, 0xCAFEBABE };
+
+static_assert(bit_cast<unsigned long long>(test_vector) == (LITTLE_END
+                                                                ? 0xCAFEBABE0C05FEFE
+                                                                : 0x0C05FEFECAFEBABE), "");
+
+static_assert(round_trip<uint2>(0xCAFEBABE0C05FEFEULL), "");
+static_assert(round_trip<byte8>(0xCAFEBABE0C05FEFEULL), "");
+
+}