Index: include/clang/AST/ASTContext.h =================================================================== --- include/clang/AST/ASTContext.h +++ include/clang/AST/ASTContext.h @@ -30,6 +30,7 @@ #include "clang/AST/TemplateName.h" #include "clang/AST/Type.h" #include "clang/Basic/AddressSpaces.h" +#include "clang/Basic/FixedPoint.h" #include "clang/Basic/IdentifierTable.h" #include "clang/Basic/LLVM.h" #include "clang/Basic/LangOptions.h" @@ -1949,6 +1950,8 @@ unsigned char getFixedPointScale(QualType Ty) const; unsigned char getFixedPointIBits(QualType Ty) const; + FixedPointNumber getFixedPointMax(QualType Ty) const; + FixedPointNumber getFixedPointMin(QualType Ty) const; DeclarationNameInfo getNameForTemplate(TemplateName Name, SourceLocation NameLoc) const; Index: include/clang/Basic/FixedPoint.h =================================================================== --- /dev/null +++ include/clang/Basic/FixedPoint.h @@ -0,0 +1,88 @@ +//===- 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. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_BASIC_FIXEDPOINT_H +#define LLVM_CLANG_BASIC_FIXEDPOINT_H + +#include "clang/AST/ASTContext.h" +#include "llvm/ADT/APSInt.h" + +namespace clang { + +class FixedPointNumber { + public: + FixedPointNumber(const llvm::APSInt &Val, unsigned Scale, + bool Saturated = false) + : Val_(Val), Scale_(Scale), Saturated_(Saturated) {} + + llvm::APSInt getValue() const { return Val_; } + unsigned getScale() const { return Scale_; } + bool isSaturated() const { return Saturated_; } + + // Convert this number to match the scale, width, and saturation of the + // provided fixed point type. + void convert(const ASTContext &Context, const QualType &Ty); + + FixedPointNumber shr(unsigned Amt) const { + return FixedPointNumber(Val_ >> Amt, Scale_, Saturated_); + } + + FixedPointNumber shl(unsigned Amt) const { + return FixedPointNumber(Val_ << Amt, Scale_, Saturated_); + } + + FixedPointNumber extend(unsigned Width) const { + llvm::APSInt ValCpy = Val_; + if (ValCpy.getBitWidth() < Width) ValCpy = ValCpy.extend(Width); + return FixedPointNumber(ValCpy, Scale_, Saturated_); + } + + FixedPointNumber trunc(unsigned Width) const { + llvm::APSInt ValCpy = Val_; + if (ValCpy.getBitWidth() > Width) ValCpy = ValCpy.trunc(Width); + return FixedPointNumber(ValCpy, Scale_, Saturated_); + } + + llvm::APSInt getIntPart() const { return Val_ >> Scale_; } + + // If LHS > RHS, return 1. If LHS == RHS, return 0. If LHS < RHS, return -1. + int compare(const FixedPointNumber &Other) const; + bool operator==(const FixedPointNumber &Other) const { + return compare(Other) == 0; + } + bool operator!=(const FixedPointNumber &Other) const { + return compare(Other) != 0; + } + bool operator>(const FixedPointNumber &Other) const { + return compare(Other) > 0; + } + bool operator<(const FixedPointNumber &Other) const { + return compare(Other) < 0; + } + bool operator>=(const FixedPointNumber &Other) const { + return compare(Other) >= 0; + } + bool operator<=(const FixedPointNumber &Other) const { + return compare(Other) <= 0; + } + + private: + llvm::APSInt Val_; + unsigned Scale_; + bool Saturated_; +}; + +} // namespace clang + +#endif Index: include/clang/Basic/TargetInfo.h =================================================================== --- include/clang/Basic/TargetInfo.h +++ include/clang/Basic/TargetInfo.h @@ -311,6 +311,13 @@ } } + /// 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. + /// False otherwise. + bool unsignedFixedPointTypesHavePadding() const { return SameFBits; } + /// Return the width (in bits) of the specified integer type enum. /// /// For example, SignedInt -> getIntWidth(). Index: lib/AST/ASTContext.cpp =================================================================== --- lib/AST/ASTContext.cpp +++ lib/AST/ASTContext.cpp @@ -10274,3 +10274,106 @@ return 0; } } + +FixedPointNumber ASTContext::getFixedPointMax(QualType Ty) const { + assert(Ty->isFixedPointType()); + unsigned NumBits = getTypeSize(Ty); + bool IsUnsigned = Ty->isUnsignedFixedPointType(); + auto Val = llvm::APSInt::getMaxValue(NumBits, IsUnsigned); + FixedPointNumber Fixed(Val, getFixedPointScale(Ty), + Ty->isSaturatedFixedPointType()); + if (IsUnsigned && getTargetInfo().unsignedFixedPointTypesHavePadding()) + Fixed = Fixed.shr(1); + return Fixed; +} + +FixedPointNumber ASTContext::getFixedPointMin(QualType Ty) const { + assert(Ty->isFixedPointType()); + unsigned NumBits = getTypeSize(Ty); + bool IsUnsigned = Ty->isUnsignedFixedPointType(); + auto Val = llvm::APSInt::getMinValue(NumBits, IsUnsigned); + return FixedPointNumber(Val, getFixedPointScale(Ty), + Ty->isSaturatedFixedPointType()); +} + +void FixedPointNumber::convert(const ASTContext &Context, const QualType &Ty) { + assert(Ty->isFixedPointType()); + + if (Ty->isSaturatedFixedPointType()) { + FixedPointNumber MaxVal = Context.getFixedPointMax(Ty); + FixedPointNumber MinVal = Context.getFixedPointMin(Ty); + if (*this > MaxVal) { + *this = MaxVal; + return; + } + if (*this < MinVal) { + *this = MinVal; + return; + } + } + + unsigned DstWidth = Context.getTypeSize(Ty); + unsigned DstScale = Context.getFixedPointScale(Ty); + unsigned SrcWidth = Val_.getBitWidth(); + bool SrcIsSigned = Val_.isSigned(); + + if (DstWidth > SrcWidth) Val_ = Val_.extend(DstWidth); + + if (DstScale > Scale_) { + Val_ = Val_.shl(DstScale - Scale_); + } else if (DstScale < Scale_) { + Val_ = SrcIsSigned ? Val_.ashr(Scale_ - DstScale) + : Val_.lshr(Scale_ - DstScale); + } + + if (DstWidth < SrcWidth) Val_ = Val_.trunc(DstWidth); + + Saturated_ = Ty->isSaturatedFixedPointType(); +} + +int FixedPointNumber::compare(const FixedPointNumber &Other) const { + llvm::APSInt ThisVal = Val_; + 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); + ThisVal = ThisVal.extend(CommonWidth); + OtherVal = OtherVal.extend(CommonWidth); + + unsigned CommonScale = std::max(Scale_, OtherScale); + if (Scale_ < CommonScale) ThisVal = ThisVal.shl(CommonScale - Scale_); + if (OtherScale < CommonScale) + 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; +} Index: lib/Sema/SemaExpr.cpp =================================================================== --- lib/Sema/SemaExpr.cpp +++ lib/Sema/SemaExpr.cpp @@ -3351,16 +3351,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 SameFBits 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: 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