1 //===- FixedPoint.cpp - Fixed point constant handling -----------*- C++ -*-===//
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
10 /// Defines the implementation for the fixed point number interface.
12 //===----------------------------------------------------------------------===//
14 #include "clang/Basic/FixedPoint.h"
18 APFixedPoint APFixedPoint::convert(const FixedPointSemantics &DstSema,
19 bool *Overflow) const {
20 llvm::APSInt NewVal = Val;
21 unsigned DstWidth = DstSema.getWidth();
22 unsigned DstScale = DstSema.getScale();
23 bool Upscaling = DstScale > getScale();
28 NewVal = NewVal.extend(NewVal.getBitWidth() + DstScale - getScale());
29 NewVal <<= (DstScale - getScale());
31 NewVal >>= (getScale() - DstScale);
34 auto Mask = llvm::APInt::getBitsSetFrom(
36 std::min(DstScale + DstSema.getIntegralBits(), NewVal.getBitWidth()));
37 llvm::APInt Masked(NewVal & Mask);
39 // Change in the bits above the sign
40 if (!(Masked == Mask || Masked == 0)) {
41 // Found overflow in the bits above the sign
42 if (DstSema.isSaturated())
43 NewVal = NewVal.isNegative() ? Mask : ~Mask;
48 // If the dst semantics are unsigned, but our value is signed and negative, we
50 if (!DstSema.isSigned() && NewVal.isSigned() && NewVal.isNegative()) {
51 // Found negative overflow for unsigned result
52 if (DstSema.isSaturated())
58 NewVal = NewVal.extOrTrunc(DstWidth);
59 NewVal.setIsSigned(DstSema.isSigned());
60 return APFixedPoint(NewVal, DstSema);
63 int APFixedPoint::compare(const APFixedPoint &Other) const {
64 llvm::APSInt ThisVal = getValue();
65 llvm::APSInt OtherVal = Other.getValue();
66 bool ThisSigned = Val.isSigned();
67 bool OtherSigned = OtherVal.isSigned();
68 unsigned OtherScale = Other.getScale();
69 unsigned OtherWidth = OtherVal.getBitWidth();
71 unsigned CommonWidth = std::max(Val.getBitWidth(), OtherWidth);
73 // Prevent overflow in the event the widths are the same but the scales differ
74 CommonWidth += getScale() >= OtherScale ? getScale() - OtherScale
75 : OtherScale - getScale();
77 ThisVal = ThisVal.extOrTrunc(CommonWidth);
78 OtherVal = OtherVal.extOrTrunc(CommonWidth);
80 unsigned CommonScale = std::max(getScale(), OtherScale);
81 ThisVal = ThisVal.shl(CommonScale - getScale());
82 OtherVal = OtherVal.shl(CommonScale - OtherScale);
84 if (ThisSigned && OtherSigned) {
85 if (ThisVal.sgt(OtherVal))
87 else if (ThisVal.slt(OtherVal))
89 } else if (!ThisSigned && !OtherSigned) {
90 if (ThisVal.ugt(OtherVal))
92 else if (ThisVal.ult(OtherVal))
94 } else if (ThisSigned && !OtherSigned) {
95 if (ThisVal.isSignBitSet())
97 else if (ThisVal.ugt(OtherVal))
99 else if (ThisVal.ult(OtherVal))
102 // !ThisSigned && OtherSigned
103 if (OtherVal.isSignBitSet())
105 else if (ThisVal.ugt(OtherVal))
107 else if (ThisVal.ult(OtherVal))
114 APFixedPoint APFixedPoint::getMax(const FixedPointSemantics &Sema) {
115 bool IsUnsigned = !Sema.isSigned();
116 auto Val = llvm::APSInt::getMaxValue(Sema.getWidth(), IsUnsigned);
117 if (IsUnsigned && Sema.hasUnsignedPadding())
119 return APFixedPoint(Val, Sema);
122 APFixedPoint APFixedPoint::getMin(const FixedPointSemantics &Sema) {
123 auto Val = llvm::APSInt::getMinValue(Sema.getWidth(), !Sema.isSigned());
124 return APFixedPoint(Val, Sema);
127 FixedPointSemantics FixedPointSemantics::getCommonSemantics(
128 const FixedPointSemantics &Other) const {
129 unsigned CommonScale = std::max(getScale(), Other.getScale());
130 unsigned CommonWidth =
131 std::max(getIntegralBits(), Other.getIntegralBits()) + CommonScale;
133 bool ResultIsSigned = isSigned() || Other.isSigned();
134 bool ResultIsSaturated = isSaturated() || Other.isSaturated();
135 bool ResultHasUnsignedPadding = false;
136 if (!ResultIsSigned) {
137 // Both are unsigned.
138 ResultHasUnsignedPadding = hasUnsignedPadding() &&
139 Other.hasUnsignedPadding() && !ResultIsSaturated;
142 // If the result is signed, add an extra bit for the sign. Otherwise, if it is
143 // unsigned and has unsigned padding, we only need to add the extra padding
144 // bit back if we are not saturating.
145 if (ResultIsSigned || ResultHasUnsignedPadding)
148 return FixedPointSemantics(CommonWidth, CommonScale, ResultIsSigned,
149 ResultIsSaturated, ResultHasUnsignedPadding);
152 APFixedPoint APFixedPoint::add(const APFixedPoint &Other,
153 bool *Overflow) const {
154 auto CommonFXSema = Sema.getCommonSemantics(Other.getSemantics());
155 APFixedPoint ConvertedThis = convert(CommonFXSema);
156 APFixedPoint ConvertedOther = Other.convert(CommonFXSema);
157 llvm::APSInt ThisVal = ConvertedThis.getValue();
158 llvm::APSInt OtherVal = ConvertedOther.getValue();
159 bool Overflowed = false;
162 if (CommonFXSema.isSaturated()) {
163 Result = CommonFXSema.isSigned() ? ThisVal.sadd_sat(OtherVal)
164 : ThisVal.uadd_sat(OtherVal);
166 Result = ThisVal.isSigned() ? ThisVal.sadd_ov(OtherVal, Overflowed)
167 : ThisVal.uadd_ov(OtherVal, Overflowed);
171 *Overflow = Overflowed;
173 return APFixedPoint(Result, CommonFXSema);
176 void APFixedPoint::toString(llvm::SmallVectorImpl<char> &Str) const {
177 llvm::APSInt Val = getValue();
178 unsigned Scale = getScale();
180 if (Val.isSigned() && Val.isNegative() && Val != -Val) {
185 llvm::APSInt IntPart = Val >> Scale;
187 // Add 4 digits to hold the value after multiplying 10 (the radix)
188 unsigned Width = Val.getBitWidth() + 4;
189 llvm::APInt FractPart = Val.zextOrTrunc(Scale).zext(Width);
190 llvm::APInt FractPartMask = llvm::APInt::getAllOnesValue(Scale).zext(Width);
191 llvm::APInt RadixInt = llvm::APInt(Width, 10);
193 IntPart.toString(Str, /*Radix=*/10);
196 (FractPart * RadixInt)
198 .toString(Str, /*Radix=*/10, Val.isSigned());
199 FractPart = (FractPart * RadixInt) & FractPartMask;
200 } while (FractPart != 0);
203 APFixedPoint APFixedPoint::negate(bool *Overflow) const {
204 if (!isSaturated()) {
207 (!isSigned() && Val != 0) || (isSigned() && Val.isMinSignedValue());
208 return APFixedPoint(-Val, Sema);
211 // We never overflow for saturation
216 return Val.isMinSignedValue() ? getMax(Sema) : APFixedPoint(-Val, Sema);
218 return APFixedPoint(Sema);
221 llvm::APSInt APFixedPoint::convertToInt(unsigned DstWidth, bool DstSign,
222 bool *Overflow) const {
223 llvm::APSInt Result = getIntPart();
224 unsigned SrcWidth = getWidth();
226 llvm::APSInt DstMin = llvm::APSInt::getMinValue(DstWidth, !DstSign);
227 llvm::APSInt DstMax = llvm::APSInt::getMaxValue(DstWidth, !DstSign);
229 if (SrcWidth < DstWidth) {
230 Result = Result.extend(DstWidth);
231 } else if (SrcWidth > DstWidth) {
232 DstMin = DstMin.extend(SrcWidth);
233 DstMax = DstMax.extend(SrcWidth);
237 if (Result.isSigned() && !DstSign) {
238 *Overflow = Result.isNegative() || Result.ugt(DstMax);
239 } else if (Result.isUnsigned() && DstSign) {
240 *Overflow = Result.ugt(DstMax);
242 *Overflow = Result < DstMin || Result > DstMax;
246 Result.setIsSigned(DstSign);
247 return Result.extOrTrunc(DstWidth);
250 APFixedPoint APFixedPoint::getFromIntValue(const llvm::APSInt &Value,
251 const FixedPointSemantics &DstFXSema,
253 FixedPointSemantics IntFXSema = FixedPointSemantics::GetIntegerSemantics(
254 Value.getBitWidth(), Value.isSigned());
255 return APFixedPoint(Value, IntFXSema).convert(DstFXSema, Overflow);