leonardchan updated this revision to Diff 156280.
leonardchan marked an inline comment as done.

Repository:
  rC Clang

https://reviews.llvm.org/D48661

Files:
  include/clang/AST/ASTContext.h
  include/clang/Basic/FixedPoint.h
  include/clang/Basic/TargetInfo.h
  lib/AST/ASTContext.cpp
  lib/Basic/CMakeLists.txt
  lib/Basic/FixedPoint.cpp
  lib/Sema/SemaExpr.cpp
  test/Frontend/fixed_point_declarations.c
  unittests/Basic/CMakeLists.txt
  unittests/Basic/FixedPointTest.cpp

Index: unittests/Basic/FixedPointTest.cpp
===================================================================
--- /dev/null
+++ unittests/Basic/FixedPointTest.cpp
@@ -0,0 +1,683 @@
+//===- unittests/Basic/FixedPointTest.cpp -- fixed point number tests -----===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Basic/FixedPoint.h"
+#include "llvm/ADT/APSInt.h"
+#include "gtest/gtest.h"
+
+using clang::APFixedPoint;
+using clang::FixedPointSemantics;
+using llvm::APInt;
+using llvm::APSInt;
+
+namespace {
+
+FixedPointSemantics Saturated(FixedPointSemantics Sema) {
+  Sema.setSaturated(true);
+  return Sema;
+}
+
+FixedPointSemantics getSAccumSema() {
+  return FixedPointSemantics(/*width=*/16, /*scale=*/7, /*isSigned=*/true,
+                             /*isSaturated=*/false,
+                             /*hasUnsignedPadding=*/false);
+}
+
+FixedPointSemantics getAccumSema() {
+  return FixedPointSemantics(/*width=*/32, /*scale=*/15, /*isSigned=*/true,
+                             /*isSaturated=*/false,
+                             /*hasUnsignedPadding=*/false);
+}
+
+FixedPointSemantics getLAccumSema() {
+  return FixedPointSemantics(/*width=*/64, /*scale=*/31, /*isSigned=*/true,
+                             /*isSaturated=*/false,
+                             /*hasUnsignedPadding=*/false);
+}
+
+FixedPointSemantics getSFractSema() {
+  return FixedPointSemantics(/*width=*/8, /*scale=*/7, /*isSigned=*/true,
+                             /*isSaturated=*/false,
+                             /*hasUnsignedPadding=*/false);
+}
+
+FixedPointSemantics getFractSema() {
+  return FixedPointSemantics(/*width=*/16, /*scale=*/15, /*isSigned=*/true,
+                             /*isSaturated=*/false,
+                             /*hasUnsignedPadding=*/false);
+}
+
+FixedPointSemantics getLFractSema() {
+  return FixedPointSemantics(/*width=*/32, /*scale=*/31, /*isSigned=*/true,
+                             /*isSaturated=*/false,
+                             /*hasUnsignedPadding=*/false);
+}
+
+FixedPointSemantics getUSAccumSema() {
+  return FixedPointSemantics(/*width=*/16, /*scale=*/8, /*isSigned=*/false,
+                             /*isSaturated=*/false,
+                             /*hasUnsignedPadding=*/false);
+}
+
+FixedPointSemantics getUAccumSema() {
+  return FixedPointSemantics(/*width=*/32, /*scale=*/16, /*isSigned=*/false,
+                             /*isSaturated=*/false,
+                             /*hasUnsignedPadding=*/false);
+}
+
+FixedPointSemantics getULAccumSema() {
+  return FixedPointSemantics(/*width=*/64, /*scale=*/32, /*isSigned=*/false,
+                             /*isSaturated=*/false,
+                             /*hasUnsignedPadding=*/false);
+}
+
+FixedPointSemantics getUSFractSema() {
+  return FixedPointSemantics(/*width=*/8, /*scale=*/8, /*isSigned=*/false,
+                             /*isSaturated=*/false,
+                             /*hasUnsignedPadding=*/false);
+}
+
+FixedPointSemantics getUFractSema() {
+  return FixedPointSemantics(/*width=*/16, /*scale=*/16, /*isSigned=*/false,
+                             /*isSaturated=*/false,
+                             /*hasUnsignedPadding=*/false);
+}
+
+FixedPointSemantics getULFractSema() {
+  return FixedPointSemantics(/*width=*/32, /*scale=*/32, /*isSigned=*/false,
+                             /*isSaturated=*/false,
+                             /*hasUnsignedPadding=*/false);
+}
+
+FixedPointSemantics getPadUSAccumSema() {
+  return FixedPointSemantics(/*width=*/16, /*scale=*/7, /*isSigned=*/false,
+                             /*isSaturated=*/false,
+                             /*hasUnsignedPadding=*/true);
+}
+
+FixedPointSemantics getPadUAccumSema() {
+  return FixedPointSemantics(/*width=*/32, /*scale=*/15, /*isSigned=*/false,
+                             /*isSaturated=*/false,
+                             /*hasUnsignedPadding=*/true);
+}
+
+FixedPointSemantics getPadULAccumSema() {
+  return FixedPointSemantics(/*width=*/64, /*scale=*/31, /*isSigned=*/false,
+                             /*isSaturated=*/false,
+                             /*hasUnsignedPadding=*/true);
+}
+
+FixedPointSemantics getPadUSFractSema() {
+  return FixedPointSemantics(/*width=*/8, /*scale=*/7, /*isSigned=*/false,
+                             /*isSaturated=*/false,
+                             /*hasUnsignedPadding=*/true);
+}
+
+FixedPointSemantics getPadUFractSema() {
+  return FixedPointSemantics(/*width=*/16, /*scale=*/15, /*isSigned=*/false,
+                             /*isSaturated=*/false,
+                             /*hasUnsignedPadding=*/true);
+}
+
+FixedPointSemantics getPadULFractSema() {
+  return FixedPointSemantics(/*width=*/32, /*scale=*/31, /*isSigned=*/false,
+                             /*isSaturated=*/false,
+                             /*hasUnsignedPadding=*/true);
+}
+
+void CheckUnpaddedMax(const FixedPointSemantics &Sema) {
+  ASSERT_EQ(APFixedPoint::getMax(Sema).getValue(),
+            APSInt::getMaxValue(Sema.getWidth(), !Sema.isSigned()));
+}
+
+void CheckPaddedMax(const FixedPointSemantics &Sema) {
+  ASSERT_EQ(APFixedPoint::getMax(Sema).getValue(),
+            APSInt::getMaxValue(Sema.getWidth(), !Sema.isSigned()) >> 1);
+}
+
+void CheckMin(const FixedPointSemantics &Sema) {
+  ASSERT_EQ(APFixedPoint::getMin(Sema).getValue(),
+            APSInt::getMinValue(Sema.getWidth(), !Sema.isSigned()));
+}
+
+TEST(FixedPointTest, getMax) {
+  CheckUnpaddedMax(getSAccumSema());
+  CheckUnpaddedMax(getAccumSema());
+  CheckUnpaddedMax(getLAccumSema());
+  CheckUnpaddedMax(getUSAccumSema());
+  CheckUnpaddedMax(getUAccumSema());
+  CheckUnpaddedMax(getULAccumSema());
+  CheckUnpaddedMax(getSFractSema());
+  CheckUnpaddedMax(getFractSema());
+  CheckUnpaddedMax(getLFractSema());
+  CheckUnpaddedMax(getUSFractSema());
+  CheckUnpaddedMax(getUFractSema());
+  CheckUnpaddedMax(getULFractSema());
+
+  CheckPaddedMax(getPadUSAccumSema());
+  CheckPaddedMax(getPadUAccumSema());
+  CheckPaddedMax(getPadULAccumSema());
+  CheckPaddedMax(getPadUSFractSema());
+  CheckPaddedMax(getPadUFractSema());
+  CheckPaddedMax(getPadULFractSema());
+}
+
+TEST(FixedPointTest, getMin) {
+  CheckMin(getSAccumSema());
+  CheckMin(getAccumSema());
+  CheckMin(getLAccumSema());
+  CheckMin(getUSAccumSema());
+  CheckMin(getUAccumSema());
+  CheckMin(getULAccumSema());
+  CheckMin(getSFractSema());
+  CheckMin(getFractSema());
+  CheckMin(getLFractSema());
+  CheckMin(getUSFractSema());
+  CheckMin(getUFractSema());
+  CheckMin(getULFractSema());
+
+  CheckMin(getPadUSAccumSema());
+  CheckMin(getPadUAccumSema());
+  CheckMin(getPadULAccumSema());
+  CheckMin(getPadUSFractSema());
+  CheckMin(getPadUFractSema());
+  CheckMin(getPadULFractSema());
+}
+
+void CheckIntPart(const FixedPointSemantics &Sema, int64_t IntPart) {
+  unsigned Scale = Sema.getScale();
+
+  // Value with a fraction
+  APFixedPoint ValWithFract(APInt(Sema.getWidth(),
+                                  (IntPart << Scale) + (1ULL << (Scale - 1)),
+                                  Sema.isSigned()),
+                            Sema);
+  ASSERT_EQ(ValWithFract.getIntPart(), IntPart);
+
+  // Just fraction
+  APFixedPoint JustFract(
+      APInt(Sema.getWidth(), (1ULL << (Scale - 1)), Sema.isSigned()), Sema);
+  ASSERT_EQ(JustFract.getIntPart(), 0);
+
+  // Whole number
+  APFixedPoint WholeNum(
+      APInt(Sema.getWidth(), (IntPart << Scale), Sema.isSigned()), Sema);
+  ASSERT_EQ(WholeNum.getIntPart(), IntPart);
+
+  // Negative
+  if (Sema.isSigned()) {
+    APFixedPoint Negative(
+        APInt(Sema.getWidth(), (IntPart << Scale), Sema.isSigned()), Sema);
+    ASSERT_EQ(Negative.getIntPart(), IntPart);
+  }
+}
+
+void CheckIntPartMin(const FixedPointSemantics &Sema, int64_t Expected) {
+  ASSERT_EQ(APFixedPoint::getMin(Sema).getIntPart(), Expected);
+}
+
+void CheckIntPartMax(const FixedPointSemantics &Sema, uint64_t Expected) {
+  ASSERT_EQ(APFixedPoint::getMax(Sema).getIntPart(), Expected);
+}
+
+TEST(FixedPoint, getIntPart) {
+  // Normal values
+  CheckIntPart(getSAccumSema(), 2);
+  CheckIntPart(getAccumSema(), 2);
+  CheckIntPart(getLAccumSema(), 2);
+  CheckIntPart(getUSAccumSema(), 2);
+  CheckIntPart(getUAccumSema(), 2);
+  CheckIntPart(getULAccumSema(), 2);
+
+  // Zero
+  CheckIntPart(getSAccumSema(), 0);
+  CheckIntPart(getAccumSema(), 0);
+  CheckIntPart(getLAccumSema(), 0);
+  CheckIntPart(getUSAccumSema(), 0);
+  CheckIntPart(getUAccumSema(), 0);
+  CheckIntPart(getULAccumSema(), 0);
+
+  CheckIntPart(getSFractSema(), 0);
+  CheckIntPart(getFractSema(), 0);
+  CheckIntPart(getLFractSema(), 0);
+  CheckIntPart(getUSFractSema(), 0);
+  CheckIntPart(getUFractSema(), 0);
+  CheckIntPart(getULFractSema(), 0);
+
+  // Min
+  CheckIntPartMin(getSAccumSema(), -256);
+  CheckIntPartMin(getAccumSema(), -65536);
+  CheckIntPartMin(getLAccumSema(), -4294967296);
+
+  CheckIntPartMin(getSFractSema(), -1);
+  CheckIntPartMin(getFractSema(), -1);
+  CheckIntPartMin(getLFractSema(), -1);
+
+  // Max
+  CheckIntPartMax(getSAccumSema(), 255);
+  CheckIntPartMax(getAccumSema(), 65535);
+  CheckIntPartMax(getLAccumSema(), 4294967295);
+  CheckIntPartMax(getUSAccumSema(), 255);
+  CheckIntPartMax(getUAccumSema(), 65535);
+  CheckIntPartMax(getULAccumSema(), 4294967295);
+
+  CheckIntPartMax(getSFractSema(), 0);
+  CheckIntPartMax(getFractSema(), 0);
+  CheckIntPartMax(getLFractSema(), 0);
+  CheckIntPartMax(getUSFractSema(), 0);
+  CheckIntPartMax(getUFractSema(), 0);
+  CheckIntPartMax(getULFractSema(), 0);
+
+  // Padded
+  // Normal Values
+  CheckIntPart(getPadUSAccumSema(), 2);
+  CheckIntPart(getPadUAccumSema(), 2);
+  CheckIntPart(getPadULAccumSema(), 2);
+
+  // Zero
+  CheckIntPart(getPadUSAccumSema(), 0);
+  CheckIntPart(getPadUAccumSema(), 0);
+  CheckIntPart(getPadULAccumSema(), 0);
+
+  CheckIntPart(getPadUSFractSema(), 0);
+  CheckIntPart(getPadUFractSema(), 0);
+  CheckIntPart(getPadULFractSema(), 0);
+
+  // Max
+  CheckIntPartMax(getPadUSAccumSema(), 255);
+  CheckIntPartMax(getPadUAccumSema(), 65535);
+  CheckIntPartMax(getPadULAccumSema(), 4294967295);
+
+  CheckIntPartMax(getPadUSFractSema(), 0);
+  CheckIntPartMax(getPadUFractSema(), 0);
+  CheckIntPartMax(getPadULFractSema(), 0);
+}
+
+TEST(FixedPoint, compare) {
+  // Equality
+  // With fractional part (2.5)
+  // Across sizes
+  ASSERT_EQ(APFixedPoint(320, getSAccumSema()),
+            APFixedPoint(81920, getAccumSema()));
+  ASSERT_EQ(APFixedPoint(320, getSAccumSema()),
+            APFixedPoint(5368709120, getLAccumSema()));
+  ASSERT_EQ(APFixedPoint(0, getSAccumSema()), APFixedPoint(0, getLAccumSema()));
+
+  // Across types (0.5)
+  ASSERT_EQ(APFixedPoint(64, getSAccumSema()),
+            APFixedPoint(64, getSFractSema()));
+  ASSERT_EQ(APFixedPoint(16384, getAccumSema()),
+            APFixedPoint(16384, getFractSema()));
+  ASSERT_EQ(APFixedPoint(1073741824, getLAccumSema()),
+            APFixedPoint(1073741824, getLFractSema()));
+
+  // Across widths and types (0.5)
+  ASSERT_EQ(APFixedPoint(64, getSAccumSema()),
+            APFixedPoint(16384, getFractSema()));
+  ASSERT_EQ(APFixedPoint(64, getSAccumSema()),
+            APFixedPoint(1073741824, getLFractSema()));
+
+  // Across saturation
+  ASSERT_EQ(APFixedPoint(320, getSAccumSema()),
+            APFixedPoint(81920, Saturated(getAccumSema())));
+
+  // Across signs
+  ASSERT_EQ(APFixedPoint(320, getSAccumSema()),
+            APFixedPoint(640, getUSAccumSema()));
+  ASSERT_EQ(APFixedPoint(-320, getSAccumSema()),
+            APFixedPoint(-81920, getAccumSema()));
+
+  // Across padding
+  ASSERT_EQ(APFixedPoint(320, getSAccumSema()),
+            APFixedPoint(320, getPadUSAccumSema()));
+  ASSERT_EQ(APFixedPoint(640, getUSAccumSema()),
+            APFixedPoint(320, getPadUSAccumSema()));
+
+  // Less than
+  ASSERT_LT(APFixedPoint(-1, getSAccumSema()), APFixedPoint(0, getAccumSema()));
+  ASSERT_LT(APFixedPoint(-1, getSAccumSema()),
+            APFixedPoint(0, getUAccumSema()));
+  ASSERT_LT(APFixedPoint(0, getSAccumSema()), APFixedPoint(1, getAccumSema()));
+  ASSERT_LT(APFixedPoint(0, getSAccumSema()), APFixedPoint(1, getUAccumSema()));
+  ASSERT_LT(APFixedPoint(0, getUSAccumSema()), APFixedPoint(1, getAccumSema()));
+  ASSERT_LT(APFixedPoint(0, getUSAccumSema()),
+            APFixedPoint(1, getUAccumSema()));
+
+  // Greater than
+  ASSERT_GT(APFixedPoint(0, getAccumSema()), APFixedPoint(-1, getSAccumSema()));
+  ASSERT_GT(APFixedPoint(0, getUAccumSema()),
+            APFixedPoint(-1, getSAccumSema()));
+  ASSERT_GT(APFixedPoint(1, getAccumSema()), APFixedPoint(0, getSAccumSema()));
+  ASSERT_GT(APFixedPoint(1, getUAccumSema()), APFixedPoint(0, getSAccumSema()));
+  ASSERT_GT(APFixedPoint(1, getAccumSema()), APFixedPoint(0, getUSAccumSema()));
+  ASSERT_GT(APFixedPoint(1, getUAccumSema()),
+            APFixedPoint(0, getUSAccumSema()));
+}
+
+// Check that a fixed point value in one sema is the same in another sema
+void CheckUnsaturatedConversion(FixedPointSemantics Src,
+                                FixedPointSemantics Dst, int64_t TestVal) {
+  int64_t ScaledVal = TestVal;
+  if (Dst.getScale() > Src.getScale()) {
+    ScaledVal <<= (Dst.getScale() - Src.getScale());
+  } else {
+    ScaledVal >>= (Src.getScale() - Dst.getScale());
+  }
+
+  APFixedPoint Fixed(TestVal, Src);
+  APFixedPoint Expected(ScaledVal, Dst);
+  ASSERT_EQ(Fixed.convert(Dst), Expected);
+}
+
+// Check the value in a given fixed point sema overflows to the saturated min
+// for another sema
+void CheckSaturatedConversionMin(FixedPointSemantics Src,
+                                 FixedPointSemantics Dst, int64_t TestVal) {
+  APFixedPoint Fixed(TestVal, Src);
+  ASSERT_EQ(Fixed.convert(Dst), APFixedPoint::getMin(Dst));
+}
+
+// Check the value in a given fixed point sema overflows to the saturated max
+// for another sema
+void CheckSaturatedConversionMax(FixedPointSemantics Src,
+                                 FixedPointSemantics Dst, int64_t TestVal) {
+  APFixedPoint Fixed(TestVal, Src);
+  ASSERT_EQ(Fixed.convert(Dst), APFixedPoint::getMax(Dst));
+}
+
+// Check one signed _Accumum sema converted to other sema for different values.
+void CheckSignedAccumumConversionsAgainstOthers(FixedPointSemantics Src,
+                                                int64_t OneVal) {
+  int64_t NormalVal = (OneVal * 2) + (OneVal / 2); // 2.5
+  int64_t HalfVal = (OneVal / 2);                  // 0.5
+
+  // +Accums to Accums
+  CheckUnsaturatedConversion(Src, getSAccumSema(), NormalVal);
+  CheckUnsaturatedConversion(Src, getAccumSema(), NormalVal);
+  CheckUnsaturatedConversion(Src, getLAccumSema(), NormalVal);
+  CheckUnsaturatedConversion(Src, getUSAccumSema(), NormalVal);
+  CheckUnsaturatedConversion(Src, getUAccumSema(), NormalVal);
+  CheckUnsaturatedConversion(Src, getULAccumSema(), NormalVal);
+  CheckUnsaturatedConversion(Src, getPadUSAccumSema(), NormalVal);
+  CheckUnsaturatedConversion(Src, getPadUAccumSema(), NormalVal);
+  CheckUnsaturatedConversion(Src, getPadULAccumSema(), NormalVal);
+
+  // -Accums to Accums
+  CheckUnsaturatedConversion(Src, getSAccumSema(), -NormalVal);
+  CheckUnsaturatedConversion(Src, getAccumSema(), -NormalVal);
+  CheckUnsaturatedConversion(Src, getLAccumSema(), -NormalVal);
+  CheckSaturatedConversionMin(Src, Saturated(getUSAccumSema()), -NormalVal);
+  CheckSaturatedConversionMin(Src, Saturated(getUAccumSema()), -NormalVal);
+  CheckSaturatedConversionMin(Src, Saturated(getULAccumSema()), -NormalVal);
+  CheckSaturatedConversionMin(Src, Saturated(getPadUSAccumSema()), -NormalVal);
+  CheckSaturatedConversionMin(Src, Saturated(getPadUAccumSema()), -NormalVal);
+  CheckSaturatedConversionMin(Src, Saturated(getPadULAccumSema()), -NormalVal);
+
+  // +Accums to Fracts
+  CheckUnsaturatedConversion(Src, getSFractSema(), HalfVal);
+  CheckUnsaturatedConversion(Src, getFractSema(), HalfVal);
+  CheckUnsaturatedConversion(Src, getLFractSema(), HalfVal);
+  CheckUnsaturatedConversion(Src, getUSFractSema(), HalfVal);
+  CheckUnsaturatedConversion(Src, getUFractSema(), HalfVal);
+  CheckUnsaturatedConversion(Src, getULFractSema(), HalfVal);
+  CheckUnsaturatedConversion(Src, getPadUSFractSema(), HalfVal);
+  CheckUnsaturatedConversion(Src, getPadUFractSema(), HalfVal);
+  CheckUnsaturatedConversion(Src, getPadULFractSema(), HalfVal);
+
+  // -Accums to Fracts
+  CheckUnsaturatedConversion(Src, getSFractSema(), -HalfVal);
+  CheckUnsaturatedConversion(Src, getFractSema(), -HalfVal);
+  CheckUnsaturatedConversion(Src, getLFractSema(), -HalfVal);
+  CheckSaturatedConversionMin(Src, Saturated(getUSFractSema()), -HalfVal);
+  CheckSaturatedConversionMin(Src, Saturated(getUFractSema()), -HalfVal);
+  CheckSaturatedConversionMin(Src, Saturated(getULFractSema()), -HalfVal);
+  CheckSaturatedConversionMin(Src, Saturated(getPadUSFractSema()), -HalfVal);
+  CheckSaturatedConversionMin(Src, Saturated(getPadUFractSema()), -HalfVal);
+  CheckSaturatedConversionMin(Src, Saturated(getPadULFractSema()), -HalfVal);
+
+  // 0 to Accums
+  CheckUnsaturatedConversion(Src, getSAccumSema(), 0);
+  CheckUnsaturatedConversion(Src, getAccumSema(), 0);
+  CheckUnsaturatedConversion(Src, getLAccumSema(), 0);
+  CheckUnsaturatedConversion(Src, getUSAccumSema(), 0);
+  CheckUnsaturatedConversion(Src, getUAccumSema(), 0);
+  CheckUnsaturatedConversion(Src, getULAccumSema(), 0);
+  CheckUnsaturatedConversion(Src, getPadUSAccumSema(), 0);
+  CheckUnsaturatedConversion(Src, getPadUAccumSema(), 0);
+  CheckUnsaturatedConversion(Src, getPadULAccumSema(), 0);
+
+  // 0 to Fracts
+  CheckUnsaturatedConversion(Src, getSFractSema(), 0);
+  CheckUnsaturatedConversion(Src, getFractSema(), 0);
+  CheckUnsaturatedConversion(Src, getLFractSema(), 0);
+  CheckUnsaturatedConversion(Src, getUSFractSema(), 0);
+  CheckUnsaturatedConversion(Src, getUFractSema(), 0);
+  CheckUnsaturatedConversion(Src, getULFractSema(), 0);
+  CheckUnsaturatedConversion(Src, getPadUSFractSema(), 0);
+  CheckUnsaturatedConversion(Src, getPadUFractSema(), 0);
+  CheckUnsaturatedConversion(Src, getPadULFractSema(), 0);
+}
+
+// Check one unsigned _Accumum sema converted to other sema for different
+// values.
+void CheckUnsignedAccumumConversionsAgainstOthers(FixedPointSemantics Src,
+                                                  int64_t OneVal) {
+  int64_t NormalVal = (OneVal * 2) + (OneVal / 2); // 2.5
+  int64_t HalfVal = (OneVal / 2);                  // 0.5
+
+  // +UAccums to Accums
+  CheckUnsaturatedConversion(Src, getSAccumSema(), NormalVal);
+  CheckUnsaturatedConversion(Src, getAccumSema(), NormalVal);
+  CheckUnsaturatedConversion(Src, getLAccumSema(), NormalVal);
+  CheckUnsaturatedConversion(Src, getUSAccumSema(), NormalVal);
+  CheckUnsaturatedConversion(Src, getUAccumSema(), NormalVal);
+  CheckUnsaturatedConversion(Src, getULAccumSema(), NormalVal);
+  CheckUnsaturatedConversion(Src, getPadUSAccumSema(), NormalVal);
+  CheckUnsaturatedConversion(Src, getPadUAccumSema(), NormalVal);
+  CheckUnsaturatedConversion(Src, getPadULAccumSema(), NormalVal);
+
+  // +UAccums to Fracts
+  CheckUnsaturatedConversion(Src, getSFractSema(), HalfVal);
+  CheckUnsaturatedConversion(Src, getFractSema(), HalfVal);
+  CheckUnsaturatedConversion(Src, getLFractSema(), HalfVal);
+  CheckUnsaturatedConversion(Src, getUSFractSema(), HalfVal);
+  CheckUnsaturatedConversion(Src, getUFractSema(), HalfVal);
+  CheckUnsaturatedConversion(Src, getULFractSema(), HalfVal);
+  CheckUnsaturatedConversion(Src, getPadUSFractSema(), HalfVal);
+  CheckUnsaturatedConversion(Src, getPadUFractSema(), HalfVal);
+  CheckUnsaturatedConversion(Src, getPadULFractSema(), HalfVal);
+}
+
+TEST(FixedPoint, AccumumConversions) {
+  // Normal conversions
+  CheckSignedAccumumConversionsAgainstOthers(getSAccumSema(), 128);
+  CheckUnsignedAccumumConversionsAgainstOthers(getUSAccumSema(), 256);
+  CheckSignedAccumumConversionsAgainstOthers(getAccumSema(), 32768);
+  CheckUnsignedAccumumConversionsAgainstOthers(getUAccumSema(), 65536);
+  CheckSignedAccumumConversionsAgainstOthers(getLAccumSema(), 2147483648);
+  CheckUnsignedAccumumConversionsAgainstOthers(getULAccumSema(), 4294967296);
+
+  CheckUnsignedAccumumConversionsAgainstOthers(getPadUSAccumSema(), 128);
+  CheckUnsignedAccumumConversionsAgainstOthers(getPadUAccumSema(), 32768);
+  CheckUnsignedAccumumConversionsAgainstOthers(getPadULAccumSema(), 2147483648);
+}
+
+TEST(FixedPoint, AccumConversionOverflow) {
+  // To SAccum max limit (65536)
+  CheckSaturatedConversionMax(getLAccumSema(), Saturated(getAccumSema()),
+                              140737488355328);
+  CheckSaturatedConversionMax(getLAccumSema(), Saturated(getUAccumSema()),
+                              140737488355328);
+  CheckSaturatedConversionMax(getLAccumSema(), Saturated(getPadUAccumSema()),
+                              140737488355328);
+  CheckSaturatedConversionMax(getULAccumSema(), Saturated(getAccumSema()),
+                              281474976710656);
+  CheckSaturatedConversionMax(getULAccumSema(), Saturated(getUAccumSema()),
+                              281474976710656);
+  CheckSaturatedConversionMax(getULAccumSema(), Saturated(getPadUAccumSema()),
+                              281474976710656);
+
+  CheckSaturatedConversionMax(getPadULAccumSema(), Saturated(getAccumSema()),
+                              140737488355328);
+  CheckSaturatedConversionMax(getPadULAccumSema(), Saturated(getUAccumSema()),
+                              140737488355328);
+  CheckSaturatedConversionMax(getPadULAccumSema(),
+                              Saturated(getPadUAccumSema()), 140737488355328);
+
+  // To SAccum min limit (-65536)
+  CheckSaturatedConversionMin(getLAccumSema(), Saturated(getAccumSema()),
+                              -140737488355328);
+  CheckSaturatedConversionMin(getLAccumSema(), Saturated(getUAccumSema()),
+                              -140737488355328);
+  CheckSaturatedConversionMin(getLAccumSema(), Saturated(getPadUAccumSema()),
+                              -140737488355328);
+}
+
+TEST(FixedPoint, SAccumConversionOverflow) {
+  // To SAccum max limit (256)
+  CheckSaturatedConversionMax(getAccumSema(), Saturated(getSAccumSema()),
+                              8388608);
+  CheckSaturatedConversionMax(getAccumSema(), Saturated(getUSAccumSema()),
+                              8388608);
+  CheckSaturatedConversionMax(getAccumSema(), Saturated(getPadUSAccumSema()),
+                              8388608);
+  CheckSaturatedConversionMax(getUAccumSema(), Saturated(getSAccumSema()),
+                              16777216);
+  CheckSaturatedConversionMax(getUAccumSema(), Saturated(getUSAccumSema()),
+                              16777216);
+  CheckSaturatedConversionMax(getUAccumSema(), Saturated(getPadUSAccumSema()),
+                              16777216);
+  CheckSaturatedConversionMax(getLAccumSema(), Saturated(getSAccumSema()),
+                              549755813888);
+  CheckSaturatedConversionMax(getLAccumSema(), Saturated(getUSAccumSema()),
+                              549755813888);
+  CheckSaturatedConversionMax(getLAccumSema(), Saturated(getPadUSAccumSema()),
+                              549755813888);
+  CheckSaturatedConversionMax(getULAccumSema(), Saturated(getSAccumSema()),
+                              1099511627776);
+  CheckSaturatedConversionMax(getULAccumSema(), Saturated(getUSAccumSema()),
+                              1099511627776);
+  CheckSaturatedConversionMax(getULAccumSema(), Saturated(getPadUSAccumSema()),
+                              1099511627776);
+
+  CheckSaturatedConversionMax(getPadUAccumSema(), Saturated(getSAccumSema()),
+                              8388608);
+  CheckSaturatedConversionMax(getPadUAccumSema(), Saturated(getUSAccumSema()),
+                              8388608);
+  CheckSaturatedConversionMax(getPadUAccumSema(),
+                              Saturated(getPadUSAccumSema()), 8388608);
+  CheckSaturatedConversionMax(getPadULAccumSema(), Saturated(getSAccumSema()),
+                              549755813888);
+  CheckSaturatedConversionMax(getPadULAccumSema(), Saturated(getUSAccumSema()),
+                              549755813888);
+  CheckSaturatedConversionMax(getPadULAccumSema(),
+                              Saturated(getPadUSAccumSema()), 549755813888);
+
+  // To SAccum min limit (-256)
+  CheckSaturatedConversionMin(getAccumSema(), Saturated(getSAccumSema()),
+                              -8388608);
+  CheckSaturatedConversionMin(getAccumSema(), Saturated(getUSAccumSema()),
+                              -8388608);
+  CheckSaturatedConversionMin(getAccumSema(), Saturated(getPadUSAccumSema()),
+                              -8388608);
+  CheckSaturatedConversionMin(getLAccumSema(), Saturated(getSAccumSema()),
+                              -549755813888);
+  CheckSaturatedConversionMin(getLAccumSema(), Saturated(getUSAccumSema()),
+                              -549755813888);
+  CheckSaturatedConversionMin(getLAccumSema(), Saturated(getPadUSAccumSema()),
+                              -549755813888);
+}
+
+void CheckSaturatedConversionToFractMax(FixedPointSemantics Src,
+                                        int64_t OneVal) {
+  CheckSaturatedConversionMax(Src, Saturated(getSFractSema()), OneVal);
+  CheckSaturatedConversionMax(Src, Saturated(getFractSema()), OneVal);
+  CheckSaturatedConversionMax(Src, Saturated(getLFractSema()), OneVal);
+  CheckSaturatedConversionMax(Src, Saturated(getUSFractSema()), OneVal);
+  CheckSaturatedConversionMax(Src, Saturated(getUFractSema()), OneVal);
+  CheckSaturatedConversionMax(Src, Saturated(getPadULFractSema()), OneVal);
+  CheckSaturatedConversionMax(Src, Saturated(getPadUSFractSema()), OneVal);
+  CheckSaturatedConversionMax(Src, Saturated(getPadUFractSema()), OneVal);
+  CheckSaturatedConversionMax(Src, Saturated(getPadULFractSema()), OneVal);
+}
+
+void CheckSaturatedConversionToFractMin(FixedPointSemantics Src,
+                                        int64_t MinusOneVal) {
+  CheckSaturatedConversionMin(Src, Saturated(getSFractSema()), MinusOneVal);
+  CheckSaturatedConversionMin(Src, Saturated(getFractSema()), MinusOneVal);
+  CheckSaturatedConversionMin(Src, Saturated(getLFractSema()), MinusOneVal);
+  CheckSaturatedConversionMin(Src, Saturated(getUSFractSema()), MinusOneVal);
+  CheckSaturatedConversionMin(Src, Saturated(getUFractSema()), MinusOneVal);
+  CheckSaturatedConversionMin(Src, Saturated(getPadULFractSema()), MinusOneVal);
+  CheckSaturatedConversionMin(Src, Saturated(getPadUSFractSema()), MinusOneVal);
+  CheckSaturatedConversionMin(Src, Saturated(getPadUFractSema()), MinusOneVal);
+  CheckSaturatedConversionMin(Src, Saturated(getPadULFractSema()), MinusOneVal);
+}
+
+TEST(FixedPoint, OverflowConversionsToFract) {
+  CheckSaturatedConversionToFractMax(getSAccumSema(), 128);
+  CheckSaturatedConversionToFractMin(getSAccumSema(), -128);
+  CheckSaturatedConversionToFractMax(getAccumSema(), 32768);
+  CheckSaturatedConversionToFractMin(getAccumSema(), -32768);
+  CheckSaturatedConversionToFractMax(getLAccumSema(), 2147483648);
+  CheckSaturatedConversionToFractMin(getLAccumSema(), -2147483648);
+
+  // Unsigned
+  CheckSaturatedConversionToFractMax(getUSAccumSema(), 256);
+  CheckSaturatedConversionToFractMax(getUAccumSema(), 65536);
+  CheckSaturatedConversionToFractMax(getULAccumSema(), 4294967296);
+
+  // Padded unsigned
+  CheckSaturatedConversionToFractMax(getPadUSAccumSema(), 128);
+  CheckSaturatedConversionToFractMax(getPadUAccumSema(), 32768);
+  CheckSaturatedConversionToFractMax(getPadULAccumSema(), 2147483648);
+}
+
+TEST(FixedPoint, GetValueSignAfterConversion) {
+  APFixedPoint Fixed(255 << 7, getSAccumSema());
+  ASSERT_TRUE(Fixed.getValue().isSigned());
+  APFixedPoint UFixed = Fixed.convert(getUSAccumSema());
+  ASSERT_TRUE(UFixed.getValue().isUnsigned());
+  ASSERT_EQ(UFixed.getValue(), APSInt::getUnsigned(255 << 8).extOrTrunc(16));
+}
+
+TEST(FixedPoint, ModularWrapAround) {
+  // Positive to negative
+  APFixedPoint Val = APFixedPoint(1ULL << 7, getSAccumSema());
+  ASSERT_EQ(Val.convert(getLFractSema()).getValue(), -(1ULL << 31));
+
+  Val = APFixedPoint(1ULL << 23, getAccumSema());
+  ASSERT_EQ(Val.convert(getSAccumSema()).getValue(), -(1ULL << 15));
+
+  Val = APFixedPoint(1ULL << 47, getLAccumSema());
+  ASSERT_EQ(Val.convert(getAccumSema()).getValue(), -(1ULL << 31));
+
+  // Negative to positive
+  Val = APFixedPoint(/*-1.5*/ -192, getSAccumSema());
+  ASSERT_EQ(Val.convert(getLFractSema()).getValue(), 1ULL << 30);
+
+  Val = APFixedPoint(-(257 << 15), getAccumSema());
+  ASSERT_EQ(Val.convert(getSAccumSema()).getValue(), 255 << 7);
+
+  Val = APFixedPoint(-(65537ULL << 31), getLAccumSema());
+  ASSERT_EQ(Val.convert(getAccumSema()).getValue(), 65535 << 15);
+
+  // Signed to unsigned
+  Val = APFixedPoint(-(1 << 7), getSAccumSema());
+  ASSERT_EQ(Val.convert(getUSAccumSema()).getValue(), 255 << 8);
+
+  Val = APFixedPoint(-(1 << 15), getAccumSema());
+  ASSERT_EQ(Val.convert(getUAccumSema()).getValue(), 65535ULL << 16);
+
+  Val = APFixedPoint(-(1ULL << 31), getLAccumSema());
+  ASSERT_EQ(Val.convert(getULAccumSema()).getValue().getZExtValue(),
+            4294967295ULL << 32);
+}
+
+} // namespace
Index: unittests/Basic/CMakeLists.txt
===================================================================
--- unittests/Basic/CMakeLists.txt
+++ unittests/Basic/CMakeLists.txt
@@ -6,13 +6,15 @@
   CharInfoTest.cpp
   DiagnosticTest.cpp
   FileManagerTest.cpp
+  FixedPointTest.cpp
   MemoryBufferCacheTest.cpp
   SourceManagerTest.cpp
   VirtualFileSystemTest.cpp
   )
 
 target_link_libraries(BasicTests
   PRIVATE
+  clangAST
   clangBasic
   clangLex
   )
Index: test/Frontend/fixed_point_declarations.c
===================================================================
--- test/Frontend/fixed_point_declarations.c
+++ test/Frontend/fixed_point_declarations.c
@@ -1,5 +1,4 @@
 // RUN: %clang -ffixed-point -S -emit-llvm %s -o - --target=x86_64-linux | FileCheck %s
-// RUN: %clang -ffixed-point -S -emit-llvm %s -o - --target=x86_64-scei-ps4-ubuntu-fast | FileCheck %s
 
 // Primary fixed point types
 signed short _Accum   s_short_accum;  // CHECK-DAG: @s_short_accum  = {{.*}}global i16 0, align 2
@@ -111,3 +110,18 @@
 unsigned short _Fract u_short_fract_eps = 0x1p-8uhr;        // CHECK-DAG: @u_short_fract_eps = {{.*}}global i8  1, align 1
 unsigned _Fract       u_fract_eps       = 0x1p-16ur;        // CHECK-DAG: @u_fract_eps       = {{.*}}global i16 1, align 2
 unsigned long _Fract  u_long_fract_eps  = 0x1p-32ulr;       // CHECK-DAG: @u_long_fract_eps  = {{.*}}global i32 1, align 4
+
+// Zero
+short _Accum          short_accum_zero    = 0.0hk;    // CHECK-DAG: @short_accum_zero     = {{.*}}global i16 0, align 2
+ _Accum               accum_zero          = 0.0k;     // CHECK-DAG: @accum_zero           = {{.*}}global i32 0, align 4
+long _Accum           long_accum_zero     = 0.0lk;    // CHECK-DAG: @long_accum_zero      = {{.*}}global i64 0, align 8
+unsigned short _Accum u_short_accum_zero  = 0.0uhk;   // CHECK-DAG: @u_short_accum_zero   = {{.*}}global i16 0, align 2
+unsigned  _Accum      u_accum_zero        = 0.0uk;    // CHECK-DAG: @u_accum_zero         = {{.*}}global i32 0, align 4
+unsigned long _Accum  u_long_accum_zero   = 0.0ulk;   // CHECK-DAG: @u_long_accum_zero    = {{.*}}global i64 0, align 8
+
+short _Fract          short_fract_zero    = 0.0hr;    // CHECK-DAG: @short_fract_zero     = {{.*}}global i8  0, align 1
+ _Fract               fract_zero          = 0.0r;     // CHECK-DAG: @fract_zero           = {{.*}}global i16 0, align 2
+long _Fract           long_fract_zero     = 0.0lr;    // CHECK-DAG: @long_fract_zero      = {{.*}}global i32 0, align 4
+unsigned short _Fract u_short_fract_zero  = 0.0uhr;   // CHECK-DAG: @u_short_fract_zero   = {{.*}}global i8  0, align 1
+unsigned  _Fract      u_fract_zero        = 0.0ur;    // CHECK-DAG: @u_fract_zero         = {{.*}}global i16 0, align 2
+unsigned long _Fract  u_long_fract_zero   = 0.0ulr;   // CHECK-DAG: @u_long_fract_zero    = {{.*}}global i32 0, align 4
Index: lib/Sema/SemaExpr.cpp
===================================================================
--- lib/Sema/SemaExpr.cpp
+++ lib/Sema/SemaExpr.cpp
@@ -26,6 +26,7 @@
 #include "clang/AST/ExprOpenMP.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/AST/TypeLoc.h"
+#include "clang/Basic/FixedPoint.h"
 #include "clang/Basic/PartialDiagnostic.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
@@ -3351,16 +3352,14 @@
 
     bool isSigned = !Literal.isUnsigned;
     unsigned scale = Context.getFixedPointScale(Ty);
-    unsigned ibits = Context.getFixedPointIBits(Ty);
     unsigned bit_width = Context.getTypeInfo(Ty).Width;
 
     llvm::APInt Val(bit_width, 0, isSigned);
     bool Overflowed = Literal.GetFixedPointValue(Val, scale);
+    bool ValIsZero = Val.isNullValue() && !Overflowed;
 
-    // Do not use bit_width since some types may have padding like _Fract or
-    // unsigned _Accums if PaddingOnUnsignedFixedPoint is set.
-    auto MaxVal = llvm::APInt::getMaxValue(ibits + scale).zextOrSelf(bit_width);
-    if (Literal.isFract && Val == MaxVal + 1)
+    auto MaxVal = Context.getFixedPointMax(Ty).getValue();
+    if (Literal.isFract && Val == MaxVal + 1 && !ValIsZero)
       // Clause 6.4.4 - The value of a constant shall be in the range of
       // representable values for its type, with exception for constants of a
       // fract type with a value of exactly 1; such a constant shall denote
Index: lib/Basic/FixedPoint.cpp
===================================================================
--- /dev/null
+++ lib/Basic/FixedPoint.cpp
@@ -0,0 +1,115 @@
+//===- FixedPoint.cpp - Fixed point constant handling -----------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+/// \file
+/// Defines the implementation for the fixed point number interface.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/AST/ASTContext.h"
+#include "clang/Basic/FixedPoint.h"
+
+namespace clang {
+
+APFixedPoint APFixedPoint::convert(const FixedPointSemantics &DstSema) const {
+  llvm::APSInt NewVal = Val;
+  unsigned DstWidth = DstSema.getWidth();
+  unsigned DstScale = DstSema.getScale();
+  bool Upscaling = DstScale > getScale();
+
+  if (Upscaling) {
+    NewVal = NewVal.extend(NewVal.getBitWidth() + DstScale - getScale());
+    NewVal <<= (DstScale - getScale());
+  } else {
+    NewVal >>= (getScale() - DstScale);
+  }
+
+  if (DstSema.isSaturated()) {
+    auto Mask = llvm::APInt::getBitsSetFrom(
+        NewVal.getBitWidth(),
+        std::min(DstScale + DstSema.getIntegralBits(), NewVal.getBitWidth()));
+    llvm::APInt Masked(NewVal & Mask);
+
+    // Change in the bits above the sign
+    if (!(Masked == Mask || Masked == 0))
+      NewVal = NewVal.isNegative() ? Mask : ~Mask;
+
+    if (!DstSema.isSigned() && NewVal.isNegative())
+      NewVal = 0;
+  }
+
+  NewVal = NewVal.extOrTrunc(DstWidth);
+  NewVal.setIsSigned(DstSema.isSigned());
+  return APFixedPoint(NewVal, DstSema);
+}
+
+int APFixedPoint::compare(const APFixedPoint &Other) const {
+  llvm::APSInt ThisVal = getValue();
+  llvm::APSInt OtherVal = Other.getValue();
+  bool ThisSigned = Val.isSigned();
+  bool OtherSigned = OtherVal.isSigned();
+  unsigned OtherScale = Other.getScale();
+  unsigned OtherWidth = OtherVal.getBitWidth();
+
+  unsigned CommonWidth = std::max(Val.getBitWidth(), OtherWidth);
+
+  // Prevent overflow in the event the widths are the same but the scales differ
+  CommonWidth += std::abs(static_cast<int>(getScale() - OtherScale));
+
+  ThisVal = ThisVal.extOrTrunc(CommonWidth);
+  OtherVal = OtherVal.extOrTrunc(CommonWidth);
+
+  unsigned CommonScale = std::max(getScale(), OtherScale);
+  ThisVal = ThisVal.shl(CommonScale - getScale());
+  OtherVal = OtherVal.shl(CommonScale - OtherScale);
+
+  if (ThisSigned && OtherSigned) {
+    if (ThisVal.sgt(OtherVal))
+      return 1;
+    else if (ThisVal.slt(OtherVal))
+      return -1;
+  } else if (!ThisSigned && !OtherSigned) {
+    if (ThisVal.ugt(OtherVal))
+      return 1;
+    else if (ThisVal.ult(OtherVal))
+      return -1;
+  } else if (ThisSigned && !OtherSigned) {
+    if (ThisVal.isSignBitSet())
+      return -1;
+    else if (ThisVal.ugt(OtherVal))
+      return 1;
+    else if (ThisVal.ult(OtherVal))
+      return -1;
+  } else {
+    // !ThisSigned && OtherSigned
+    if (OtherVal.isSignBitSet())
+      return 1;
+    else if (ThisVal.ugt(OtherVal))
+      return 1;
+    else if (ThisVal.ult(OtherVal))
+      return -1;
+  }
+
+  return 0;
+}
+
+APFixedPoint APFixedPoint::getMax(const FixedPointSemantics &Sema) {
+  bool IsUnsigned = !Sema.isSigned();
+  auto Val = llvm::APSInt::getMaxValue(Sema.getWidth(), IsUnsigned);
+  if (IsUnsigned && Sema.hasUnsignedPadding())
+    Val = Val.lshr(1);
+  return APFixedPoint(Val, Sema);
+}
+
+APFixedPoint APFixedPoint::getMin(const FixedPointSemantics &Sema) {
+  auto Val = llvm::APSInt::getMinValue(Sema.getWidth(), !Sema.isSigned());
+  return APFixedPoint(Val, Sema);
+}
+
+}  // namespace clang
Index: lib/Basic/CMakeLists.txt
===================================================================
--- lib/Basic/CMakeLists.txt
+++ lib/Basic/CMakeLists.txt
@@ -54,6 +54,7 @@
   DiagnosticOptions.cpp
   FileManager.cpp
   FileSystemStatCache.cpp
+  FixedPoint.cpp
   IdentifierTable.cpp
   LangOptions.cpp
   MemoryBufferCache.cpp
Index: lib/AST/ASTContext.cpp
===================================================================
--- lib/AST/ASTContext.cpp
+++ lib/AST/ASTContext.cpp
@@ -48,6 +48,7 @@
 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/CommentOptions.h"
 #include "clang/Basic/ExceptionSpecificationType.h"
+#include "clang/Basic/FixedPoint.h"
 #include "clang/Basic/IdentifierTable.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/LangOptions.h"
@@ -10388,3 +10389,22 @@
       return 0;
   }
 }
+
+FixedPointSemantics ASTContext::getFixedPointSemantics(QualType Ty) const {
+  assert(Ty->isFixedPointType());
+  bool isSigned = Ty->isSignedFixedPointType();
+  return FixedPointSemantics(
+      static_cast<unsigned>(getTypeSize(Ty)), getFixedPointScale(Ty), isSigned,
+      Ty->isSaturatedFixedPointType(),
+      !isSigned && getTargetInfo().doUnsignedFixedPointTypesHavePadding());
+}
+
+APFixedPoint ASTContext::getFixedPointMax(QualType Ty) const {
+  assert(Ty->isFixedPointType());
+  return APFixedPoint::getMax(getFixedPointSemantics(Ty));
+}
+
+APFixedPoint ASTContext::getFixedPointMin(QualType Ty) const {
+  assert(Ty->isFixedPointType());
+  return APFixedPoint::getMin(getFixedPointSemantics(Ty));
+}
Index: include/clang/Basic/TargetInfo.h
===================================================================
--- include/clang/Basic/TargetInfo.h
+++ include/clang/Basic/TargetInfo.h
@@ -312,6 +312,14 @@
     }
   }
 
+  /// In the event this target uses the same number of fractional bits for its
+  /// unsigned types as it does with its signed counterparts, there will be
+  /// exactly one bit of padding.
+  /// Return true if unsigned fixed point types have padding for this target.
+  bool doUnsignedFixedPointTypesHavePadding() const {
+    return PaddingOnUnsignedFixedPoint;
+  }
+
   /// Return the width (in bits) of the specified integer type enum.
   ///
   /// For example, SignedInt -> getIntWidth().
Index: include/clang/Basic/FixedPoint.h
===================================================================
--- /dev/null
+++ include/clang/Basic/FixedPoint.h
@@ -0,0 +1,138 @@
+//===- FixedPoint.h - Fixed point constant handling -------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+/// \file
+/// Defines the fixed point number interface.
+/// This is a class for abstracting various operations performed on fixed point
+/// 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"
+
+namespace clang {
+
+class ASTContext;
+class QualType;
+
+/// The fixed point semantics work similarly to llvm::fltSemantics. The width
+/// specifies the whole bit width of the underlying scaled integer (with padding
+/// if any). The scale represents the number of fractional bits in this type.
+/// When HasUnsignedPadding is true and this type is signed, the first bit
+/// in the value this represents is treaded as padding.
+class FixedPointSemantics {
+public:
+  FixedPointSemantics(unsigned Width, unsigned Scale, bool IsSigned,
+                      bool IsSaturated, bool HasUnsignedPadding)
+      : Width(Width), Scale(Scale), IsSigned(IsSigned),
+        IsSaturated(IsSaturated), HasUnsignedPadding(HasUnsignedPadding) {
+    assert(Width >= Scale && "Not enough room for the scale");
+  }
+
+  unsigned getWidth() const { return Width; }
+  unsigned getScale() const { return Scale; }
+  bool isSigned() const { return IsSigned; }
+  bool isSaturated() const { return IsSaturated; }
+  bool hasUnsignedPadding() const { return HasUnsignedPadding; }
+
+  void setSaturated(bool Saturated) { IsSaturated = Saturated; }
+
+  unsigned getIntegralBits() const {
+    if (IsSigned || (!IsSigned && HasUnsignedPadding))
+      return Width - Scale - 1;
+    else
+      return Width - Scale;
+  }
+
+private:
+  unsigned Width;
+  unsigned Scale;
+  bool IsSigned;
+  bool IsSaturated;
+  bool HasUnsignedPadding;
+};
+
+/// The APFixedPoint class works similarly to APInt/APSInt in that it is a
+/// functional replacement for a scaled integer. It is meant to replicate the
+/// fixed point types proposed in ISO/IEC JTC1 SC22 WG14 N1169. The class carries
+/// info about the fixed point type's width, sign, scale, and saturation, and
+/// provides different operations that would normally be performed on fixed point
+/// types.
+///
+/// Semantically this does not represent any existing C type other than fixed
+/// point types and should eventually be moved to LLVM if fixed point types gain
+/// native IR support.
+class APFixedPoint {
+ public:
+   APFixedPoint(const llvm::APInt &Val, const FixedPointSemantics &Sema)
+       : Val(Val, !Sema.isSigned()), Sema(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) {}
+
+   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(); }
+
+   // 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();
+  }
+
+  // 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;
+  }
+  bool operator>(const APFixedPoint &Other) const { return compare(Other) > 0; }
+  bool operator<(const APFixedPoint &Other) const { return compare(Other) < 0; }
+  bool operator>=(const APFixedPoint &Other) const {
+    return compare(Other) >= 0;
+  }
+  bool operator<=(const APFixedPoint &Other) const {
+    return compare(Other) <= 0;
+  }
+
+  static APFixedPoint getMax(const FixedPointSemantics &Sema);
+  static APFixedPoint getMin(const FixedPointSemantics &Sema);
+
+private:
+  llvm::APSInt Val;
+  FixedPointSemantics Sema;
+};
+
+}  // namespace clang
+
+#endif
Index: include/clang/AST/ASTContext.h
===================================================================
--- include/clang/AST/ASTContext.h
+++ include/clang/AST/ASTContext.h
@@ -79,6 +79,7 @@
 
 namespace clang {
 
+class APFixedPoint;
 class APValue;
 class ASTMutationListener;
 class ASTRecordLayout;
@@ -92,6 +93,7 @@
 class CXXRecordDecl;
 class DiagnosticsEngine;
 class Expr;
+class FixedPointSemantics;
 class MangleContext;
 class MangleNumberingContext;
 class MaterializeTemporaryExpr;
@@ -1955,6 +1957,9 @@
 
   unsigned char getFixedPointScale(QualType Ty) const;
   unsigned char getFixedPointIBits(QualType Ty) const;
+  FixedPointSemantics getFixedPointSemantics(QualType Ty) const;
+  APFixedPoint getFixedPointMax(QualType Ty) const;
+  APFixedPoint getFixedPointMin(QualType Ty) const;
 
   DeclarationNameInfo getNameForTemplate(TemplateName Name,
                                          SourceLocation NameLoc) const;
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

Reply via email to