[Fixed Point Arithmetic] Add APFixedPoint to APValue

[leonardchan]

Summary

This adds APFixedPoint to the union of values that can be represented with an APValue.

[leonardchan]

Regarding tests, I couldn't actually find any under clang/unittests that test APValue specifically. Is it worth it to add some still?

[rjmccall]

One nit-pick, then this is good to go.

clang/include/clang/AST/APValue.h

183 ↗

(On Diff #181893)

I know this is the established pattern, but could you just make MakeFixedPoint take a APFixedPoint && and move it into place instead of default-constructing one and then assigning over it?

[rjmccall]

Thanks, LGTM.

include/clang/AST/APValue.h

 //===--- APValue.h - Union class for APFloat/APSInt/Complex -----*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines the APValue class.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_AST_APVALUE_H
 #define LLVM_CLANG_AST_APVALUE_H
 
+#include "clang/Basic/FixedPoint.h"
 #include "clang/Basic/LLVM.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/PointerUnion.h"
 
 namespace clang {
   class AddrLabelExpr;

 class APValue {
   typedef llvm::APSInt APSInt;
   typedef llvm::APFloat APFloat;
 public:
   enum ValueKind {
     Uninitialized,
     Int,
     Float,
+    FixedPoint,
     ComplexInt,
     ComplexFloat,
     LValue,
     Vector,
     Array,
     Struct,
     Union,
     MemberPointer,

 public:
   APValue() : Kind(Uninitialized) {}
   explicit APValue(APSInt I) : Kind(Uninitialized) {
     MakeInt(); setInt(std::move(I));
   }
   explicit APValue(APFloat F) : Kind(Uninitialized) {
     MakeFloat(); setFloat(std::move(F));
   }
+  explicit APValue(APFixedPoint FX) : Kind(Uninitialized) {
+    MakeFixedPoint(std::move(FX));
+  }
   explicit APValue(const APValue *E, unsigned N) : Kind(Uninitialized) {
     MakeVector(); setVector(E, N);
   }
   APValue(APSInt R, APSInt I) : Kind(Uninitialized) {
     MakeComplexInt(); setComplexInt(std::move(R), std::move(I));
   }
   APValue(APFloat R, APFloat I) : Kind(Uninitialized) {
     MakeComplexFloat(); setComplexFloat(std::move(R), std::move(I));
public:
 
   /// Swaps the contents of this and the given APValue.
   void swap(APValue &RHS);
 
   ValueKind getKind() const { return Kind; }
   bool isUninit() const { return Kind == Uninitialized; }
   bool isInt() const { return Kind == Int; }
   bool isFloat() const { return Kind == Float; }
+  bool isFixedPoint() const { return Kind == FixedPoint; }
   bool isComplexInt() const { return Kind == ComplexInt; }
   bool isComplexFloat() const { return Kind == ComplexFloat; }
   bool isLValue() const { return Kind == LValue; }
   bool isVector() const { return Kind == Vector; }
   bool isArray() const { return Kind == Array; }
   bool isStruct() const { return Kind == Struct; }
   bool isUnion() const { return Kind == Union; }
   bool isMemberPointer() const { return Kind == MemberPointer; }
public:
   APFloat &getFloat() {
     assert(isFloat() && "Invalid accessor");
     return *(APFloat*)(char*)Data.buffer;
   }
   const APFloat &getFloat() const {
     return const_cast<APValue*>(this)->getFloat();
   }
 
+  APFixedPoint &getFixedPoint() {
+    assert(isFixedPoint() && "Invalid accessor");
+    return *(APFixedPoint *)(char *)Data.buffer;
+  }
+  const APFixedPoint &getFixedPoint() const {
+    return const_cast<APValue *>(this)->getFixedPoint();
+  }
+
   APSInt &getComplexIntReal() {
     assert(isComplexInt() && "Invalid accessor");
     return ((ComplexAPSInt*)(char*)Data.buffer)->Real;
   }
   const APSInt &getComplexIntReal() const {
     return const_cast<APValue*>(this)->getComplexIntReal();
   }
 
public:
   void setInt(APSInt I) {
     assert(isInt() && "Invalid accessor");
     *(APSInt *)(char *)Data.buffer = std::move(I);
   }
   void setFloat(APFloat F) {
     assert(isFloat() && "Invalid accessor");
     *(APFloat *)(char *)Data.buffer = std::move(F);
   }
+  void setFixedPoint(APFixedPoint FX) {
+    assert(isFixedPoint() && "Invalid accessor");
+    *(APFixedPoint *)(char *)Data.buffer = std::move(FX);
+  }
   void setVector(const APValue *E, unsigned N) {
     assert(isVector() && "Invalid accessor");
     ((Vec*)(char*)Data.buffer)->Elts = new APValue[N];
     ((Vec*)(char*)Data.buffer)->NumElts = N;
     for (unsigned i = 0; i != N; ++i)
       ((Vec*)(char*)Data.buffer)->Elts[i] = E[i];
   }
   void setComplexInt(APSInt R, APSInt I) {
void MakeInt() {
     new ((void*)Data.buffer) APSInt(1);
     Kind = Int;
   }
   void MakeFloat() {
     assert(isUninit() && "Bad state change");
     new ((void*)(char*)Data.buffer) APFloat(0.0);
     Kind = Float;
   }
+  void MakeFixedPoint(APFixedPoint &&FX) {
+    assert(isUninit() && "Bad state change");
+    new ((void *)(char *)Data.buffer) APFixedPoint(std::move(FX));
+    Kind = FixedPoint;
+  }
   void MakeVector() {
     assert(isUninit() && "Bad state change");
     new ((void*)(char*)Data.buffer) Vec();
     Kind = Vector;
   }
   void MakeComplexInt() {
     assert(isUninit() && "Bad state change");
     new ((void*)(char*)Data.buffer) ComplexAPSInt();

include/clang/AST/Type.h

 QualType DecayedType::getPointeeType() const {
   QualType Decayed = getDecayedType();
   (void)AttributedType::stripOuterNullability(Decayed);
   return cast<PointerType>(Decayed)->getPointeeType();
 }
 
 // Get the decimal string representation of a fixed point type, represented
 // as a scaled integer.
+// TODO: At some point, we should change the arguments to instead just accept an
+// APFixedPoint instead of APSInt and scale.
 void FixedPointValueToString(SmallVectorImpl<char> &Str, llvm::APSInt Val,
                              unsigned Scale);
 
 } // namespace clang
 
 #endif // LLVM_CLANG_AST_TYPE_H

include/clang/Basic/FixedPoint.h

 /// types described in ISO/IEC JTC1 SC22 WG14 N1169 starting at clause 4.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_BASIC_FIXEDPOINT_H
 #define LLVM_CLANG_BASIC_FIXEDPOINT_H
 
 #include "llvm/ADT/APSInt.h"
+#include "llvm/ADT/SmallString.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace clang {
 
 class ASTContext;
 class QualType;
 
 /// The fixed point semantics work similarly to llvm::fltSemantics. The width
APFixedPoint(const llvm::APInt &Val, const FixedPointSemantics &Sema)
      assert(Val.getBitWidth() == Sema.getWidth() &&
             "The value should have a bit width that matches the Sema width");
    }
 
    APFixedPoint(uint64_t Val, const FixedPointSemantics &Sema)
        : APFixedPoint(llvm::APInt(Sema.getWidth(), Val, Sema.isSigned()),
                       Sema) {}
 
+   // Zero initialization.
+   APFixedPoint(const FixedPointSemantics &Sema) : APFixedPoint(0, Sema) {}
+
    llvm::APSInt getValue() const { return llvm::APSInt(Val, !Sema.isSigned()); }
    inline unsigned getWidth() const { return Sema.getWidth(); }
    inline unsigned getScale() const { return Sema.getScale(); }
    inline bool isSaturated() const { return Sema.isSaturated(); }
    inline bool isSigned() const { return Sema.isSigned(); }
    inline bool hasPadding() const { return Sema.hasUnsignedPadding(); }
+   FixedPointSemantics getSemantics() const { return Sema; }
+
+   bool getBoolValue() const { return Val.getBoolValue(); }
 
    // Convert this number to match the semantics provided.
    APFixedPoint convert(const FixedPointSemantics &DstSema) const;
 
    APFixedPoint shr(unsigned Amt) const {
      return APFixedPoint(Val >> Amt, Sema);
    }
 
   APFixedPoint shl(unsigned Amt) const {
     return APFixedPoint(Val << Amt, Sema);
   }
 
   llvm::APSInt getIntPart() const {
     if (Val < 0 && Val != -Val) // Cover the case when we have the min val
       return -(-Val >> getScale());
     else
       return Val >> getScale();
   }
 
+  void toString(llvm::SmallVectorImpl<char> &Str) const;
+  std::string toString() const {
+    llvm::SmallString<40> S;
+    toString(S);
+    return S.str();
+  }
+
   // If LHS > RHS, return 1. If LHS == RHS, return 0. If LHS < RHS, return -1.
   int compare(const APFixedPoint &Other) const;
   bool operator==(const APFixedPoint &Other) const {
     return compare(Other) == 0;
   }
   bool operator!=(const APFixedPoint &Other) const {
     return compare(Other) != 0;
   }
public:
   static APFixedPoint getMax(const FixedPointSemantics &Sema);
   static APFixedPoint getMin(const FixedPointSemantics &Sema);
 
 private:
   llvm::APSInt Val;
   FixedPointSemantics Sema;
 };
 
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+                                     const APFixedPoint &FX) {
+  OS << FX.toString();
+  return OS;
+}
+
 }  // namespace clang
 
 #endif

lib/AST/APValue.cpp

APValue::APValue(const APValue &RHS) : Kind(Uninitialized) {
   case Int:
     MakeInt();
     setInt(RHS.getInt());
     break;
   case Float:
     MakeFloat();
     setFloat(RHS.getFloat());
     break;
+  case FixedPoint: {
+    APFixedPoint FXCopy = RHS.getFixedPoint();
+    MakeFixedPoint(std::move(FXCopy));
+    break;
+  }
   case Vector:
     MakeVector();
     setVector(((const Vec *)(const char *)RHS.Data.buffer)->Elts,
               RHS.getVectorLength());
     break;
   case ComplexInt:
     MakeComplexInt();
     setComplexInt(RHS.getComplexIntReal(), RHS.getComplexIntImag());
APValue::APValue(const APValue &RHS) : Kind(Uninitialized) {
   }
 }
 
 void APValue::DestroyDataAndMakeUninit() {
   if (Kind == Int)
     ((APSInt*)(char*)Data.buffer)->~APSInt();
   else if (Kind == Float)
     ((APFloat*)(char*)Data.buffer)->~APFloat();
+  else if (Kind == FixedPoint)
+    ((APFixedPoint *)(char *)Data.buffer)->~APFixedPoint();
   else if (Kind == Vector)
     ((Vec*)(char*)Data.buffer)->~Vec();
   else if (Kind == ComplexInt)
     ((ComplexAPSInt*)(char*)Data.buffer)->~ComplexAPSInt();
   else if (Kind == ComplexFloat)
     ((ComplexAPFloat*)(char*)Data.buffer)->~ComplexAPFloat();
   else if (Kind == LValue)
     ((LV*)(char*)Data.buffer)->~LV();
bool APValue::needsCleanup() const {
   case Union:
   case Array:
   case Vector:
     return true;
   case Int:
     return getInt().needsCleanup();
   case Float:
     return getFloat().needsCleanup();
+  case FixedPoint:
+    return getFixedPoint().getValue().needsCleanup();
   case ComplexFloat:
     assert(getComplexFloatImag().needsCleanup() ==
                getComplexFloatReal().needsCleanup() &&
            "In _Complex float types, real and imaginary values always have the "
            "same size.");
     return getComplexFloatReal().needsCleanup();
   case ComplexInt:
     assert(getComplexIntImag().needsCleanup() ==
case Uninitialized:
     OS << "Uninitialized";
     return;
   case Int:
     OS << "Int: " << getInt();
     return;
   case Float:
     OS << "Float: " << GetApproxValue(getFloat());
     return;
+  case FixedPoint:
+    OS << "FixedPoint : " << getFixedPoint();
+    return;
   case Vector:
     OS << "Vector: ";
     getVectorElt(0).dump(OS);
     for (unsigned i = 1; i != getVectorLength(); ++i) {
       OS << ", ";
       getVectorElt(i).dump(OS);
     }
     return;
case APValue::Int:
     if (Ty->isBooleanType())
       Out << (getInt().getBoolValue() ? "true" : "false");
     else
       Out << getInt();
     return;
   case APValue::Float:
     Out << GetApproxValue(getFloat());
     return;
+  case APValue::FixedPoint:
+    Out << getFixedPoint();
+    return;
   case APValue::Vector: {
     Out << '{';
     QualType ElemTy = Ty->getAs<VectorType>()->getElementType();
     getVectorElt(0).printPretty(Out, Ctx, ElemTy);
     for (unsigned i = 1; i != getVectorLength(); ++i) {
       Out << ", ";
       getVectorElt(i).printPretty(Out, Ctx, ElemTy);
     }

lib/AST/ExprConstant.cpp

 
 static bool HandleConversionToBool(const APValue &Val, bool &Result) {
   switch (Val.getKind()) {
   case APValue::Uninitialized:
     return false;
   case APValue::Int:
     Result = Val.getInt().getBoolValue();
     return true;
+  case APValue::FixedPoint:
+    Result = Val.getFixedPoint().getBoolValue();
+    return true;
   case APValue::Float:
     Result = !Val.getFloat().isZero();
     return true;
   case APValue::ComplexInt:
     Result = Val.getComplexIntReal().getBoolValue() ||
              Val.getComplexIntImag().getBoolValue();
     return true;
   case APValue::ComplexFloat:

lib/AST/Type.cpp

 }
 
 CXXRecordDecl *MemberPointerType::getMostRecentCXXRecordDecl() const {
   return getClass()->getAsCXXRecordDecl()->getMostRecentNonInjectedDecl();
 }
 
 void clang::FixedPointValueToString(SmallVectorImpl<char> &Str,
                                     llvm::APSInt Val, unsigned Scale) {
-  if (Val.isSigned() && Val.isNegative() && Val != -Val) {
-    Val = -Val;
-    Str.push_back('-');
-  }
-
-  llvm::APSInt IntPart = Val >> Scale;
-
-  // Add 4 digits to hold the value after multiplying 10 (the radix)
-  unsigned Width = Val.getBitWidth() + 4;
-  llvm::APInt FractPart = Val.zextOrTrunc(Scale).zext(Width);
-  llvm::APInt FractPartMask = llvm::APInt::getAllOnesValue(Scale).zext(Width);
-  llvm::APInt RadixInt = llvm::APInt(Width, 10);
-
-  IntPart.toString(Str, /*radix=*/10);
-  Str.push_back('.');
-  do {
-    (FractPart * RadixInt)
-        .lshr(Scale)
-        .toString(Str, /*radix=*/10, Val.isSigned());
-    FractPart = (FractPart * RadixInt) & FractPartMask;
-  } while (FractPart != 0);
+  FixedPointSemantics FXSema(Val.getBitWidth(), Scale, Val.isSigned(),
+                             /*isSaturated=*/false,
+                             /*hasUnsignedPadding=*/false);
+  APFixedPoint(Val, FXSema).toString(Str);
 }

lib/Basic/FixedPoint.cpp

FixedPointSemantics FixedPointSemantics::getCommonSemantics(
   // bit back if we are not saturating.
   if (ResultIsSigned || ResultHasUnsignedPadding)
     CommonWidth++;
 
   return FixedPointSemantics(CommonWidth, CommonScale, ResultIsSigned,
                              ResultIsSaturated, ResultHasUnsignedPadding);
 }
 
+void APFixedPoint::toString(llvm::SmallVectorImpl<char> &Str) const {
+  llvm::APSInt Val = getValue();
+  unsigned Scale = getScale();
+
+  if (Val.isSigned() && Val.isNegative() && Val != -Val) {
+    Val = -Val;
+    Str.push_back('-');
+  }
+
+  llvm::APSInt IntPart = Val >> Scale;
+
+  // Add 4 digits to hold the value after multiplying 10 (the radix)
+  unsigned Width = Val.getBitWidth() + 4;
+  llvm::APInt FractPart = Val.zextOrTrunc(Scale).zext(Width);
+  llvm::APInt FractPartMask = llvm::APInt::getAllOnesValue(Scale).zext(Width);
+  llvm::APInt RadixInt = llvm::APInt(Width, 10);
+
+  IntPart.toString(Str, /*radix=*/10);
+  Str.push_back('.');
+  do {
+    (FractPart * RadixInt)
+        .lshr(Scale)
+        .toString(Str, /*radix=*/10, Val.isSigned());
+    FractPart = (FractPart * RadixInt) & FractPartMask;
+  } while (FractPart != 0);
+}
+
 }  // namespace clang

lib/CodeGen/CGExprConstant.cpp

llvm::Constant *ConstantEmitter::tryEmitPrivate(const APValue &Value,
                                                 QualType DestType) {
   switch (Value.getKind()) {
   case APValue::Uninitialized:
     llvm_unreachable("Constant expressions should be initialized.");
   case APValue::LValue:
     return ConstantLValueEmitter(*this, Value, DestType).tryEmit();
   case APValue::Int:
     return llvm::ConstantInt::get(CGM.getLLVMContext(), Value.getInt());
+  case APValue::FixedPoint:
+    return llvm::ConstantInt::get(CGM.getLLVMContext(),
+                                  Value.getFixedPoint().getValue());
   case APValue::ComplexInt: {
     llvm::Constant *Complex[2];
 
     Complex[0] = llvm::ConstantInt::get(CGM.getLLVMContext(),
                                         Value.getComplexIntReal());
     Complex[1] = llvm::ConstantInt::get(CGM.getLLVMContext(),
                                         Value.getComplexIntImag());
 

lib/Sema/SemaTemplate.cpp

case APValue::LValue: {
       assert((!VD || !ParamType->isNullPtrType()) &&
              "non-null value of type nullptr_t?");
       Converted = VD ? TemplateArgument(VD, CanonParamType)
                      : TemplateArgument(CanonParamType, /*isNullPtr*/true);
       break;
     }
     case APValue::AddrLabelDiff:
       return Diag(StartLoc, diag::err_non_type_template_arg_addr_label_diff);
+    case APValue::FixedPoint:
     case APValue::Float:
     case APValue::ComplexInt:
     case APValue::ComplexFloat:
     case APValue::Vector:
     case APValue::Array:
     case APValue::Struct:
     case APValue::Union:
       llvm_unreachable("invalid kind for template argument");