[Fixed Point Arithmetic] Fixed Point Constant

[leonardchan]

Summary

This patch proposes an abstract type that represents fixed point numbers, similar to APInt or APSInt that was discussed in https://reviews.llvm.org/D48456#inline-425585. This type holds a value, scale, and saturation and is meant to perform intermediate calculations on constant fixed point values.

Currently this class is used as a way for handling the conversions between fixed point numbers with different sizes and radixes. For example, if I'm casting from a signed _Accum to a saturated unsigned short _Accum, I will need to check the value of the signed _Accum to see if it fits into the short _Accum which involves getting and comparing against the max/min values of the short _Accum. The FixedPointNumber class currently handles the radix shifting and extension when converting to a signed _Accum.

[rjmccall]

include/clang/Basic/FixedPoint.h

11 ↗

(On Diff #153119)

Referencing the standard here would be good, and maybe even excerpting the key parts.

23 ↗

(On Diff #153119)

The established naming convention here — as seen in APInt, APFloat, APValue, etc. — would call this APFixedPoint. Maybe that's not a great convention, but we should at least discuss deviating from it.

You might also want a type which encapsulates the details of a fixed-point type, i.e. the semantic width, scale, and saturating-ness. (Like the "float semantics" of APFloat.)

I think a key question here is whether you want a FixedPointNumber to exactly represent the bit-pattern or just the semantic value. I think it would eliminate a non-trivial source of bugs in this type if it just represents the semantic value, i.e. if a 16-bit unsigned fract value on a target where that uses a padded representation did not explicitly represent the padding bit, and then just added it back in in some accessor that asks for the bit-pattern. Regardless, that should be clearly documented.

26 ↗

(On Diff #153119)

This probably shouldn't be optional, since it's a really important semantic aspect of the type whether it's saturating or not.

83 ↗

(On Diff #153119)

LLVM convention does not include the trailing underscore; they're just capitalized. No, I don't like it, either.

include/clang/Basic/TargetInfo.h

318 ↗

(On Diff #153119)

You can cut "false otherwise".

319 ↗

(On Diff #153119)

The convention is that predicates like this start with a verb, so this should be something like doUnsignedFixedPointTypesHavePadding.

lib/AST/ASTContext.cpp

10379 ↗

(On Diff #153119)

Please put at least the member functions on FixedPointNumber in their own .cpp file.

[ebevhan]

include/clang/Basic/FixedPoint.h

23 ↗

(On Diff #153119)

a 16-bit unsigned fract value on a target where that uses a padded representation did not explicitly represent the padding bit

So does that mean that the underlying APInt in this type would be 15 bits instead of 16, to avoid representing the padding? It feels a bit scary to throw around values with different internal representation than what other parts of the code (say, the target specification) have specified them to be.

45 ↗

(On Diff #153119)

I'm not so sure that extension and truncation on their own are particularly meaningful operations on fixed-point values. I think you need to provide both a width and a scale for these kinds of operations so you can both resize and rescale the value simultaneously. Perhaps you can even provide a 'saturation width' that the value should be saturating on when converting.

You have the convert method, but it only takes a QualType, so if you need to convert to something that doesn't exist as a type, it's not enough. Maybe I'm overdesigning.

57 ↗

(On Diff #153119)

As with the integer conversion in the earlier patch, this does not round toward zero. This might lead to surprising results.

lib/AST/ASTContext.cpp

10303 ↗

(On Diff #153119)

It is possible to perform saturation without extending and comparing, by looking at the bits above the 'imagined' sign bit in the resulting type. If they are all the same, then the value is in range, otherwise you must saturate.

Explicit comparison probably gets the point across better.

10320 ↗

(On Diff #153119)

If you do rescaling before and after resizing, you can use extOrTrunc instead.

10342 ↗

(On Diff #153119)

This width and scale commoning looks odd. If you have two types for which the width is the same but the scale is different, you will discard bits from the value with lower scale and the comparison might be wrong.

You need to find a width and scale that can fit all of the values of both.

[rjmccall]

include/clang/Basic/FixedPoint.h

23 ↗

(On Diff #153119)

Well, you can encapsulate it so that the 15-bit APInt is never exposed to users of the type. That's a relatively small number (probably just 1) of places to check for correctness, vs. having to have logic to handle the padding bit in basically every operation on the type in addition to all the other configuration-explosions that are actually mandatory.

[leonardchan]

• Renamed to APFixedPoint
• Added FixedPointSemantics to represent saturation and whether or not padding is involved. Similar to APFloatSemantics, this indicated how the underlying APSInt passed to this will be used (ie. is the MSB padding or not).

[leonardchan]

include/clang/Basic/FixedPoint.h

23 ↗

(On Diff #153119)

I definitely think the class needs to know at least of either the number of integral bits, or if this padding exists since the initial task I wanted it to do was handle conversion between unsigned and signed types while taking care of this padding.

I think a good solution would be to pass an additional semantics type such that we can still pass a literal APSInt to represent the underlying integer and know stuff like saturation and padding. I don't think it should represent the scale or width though since those are configured by the target and can have different values.

This semantic type I think would also help discern how to treat the underlying APSInt.

45 ↗

(On Diff #153119)

This makes sense. I had the extend and trunc methods so I could match the width of another fixed type when comparing, but if that's the only use for it, it makes sense to have a function that just accepts the width and scale.

lib/AST/ASTContext.cpp

10320 ↗

(On Diff #153119)

I think having this line just be Val_ = Val_.extOrTrunc(DstWidth); would allow for truncation to occur first before potentially right shifting.

[rjmccall]

include/clang/Basic/FixedPoint.h

31 ↗

(On Diff #153426)

I figured you'd want this to be a struct which include the scale, width, signed-ness, and saturating-ness; and then APFixedPoint can just store one of these next to a bare APInt.

41 ↗

(On Diff #153426)

Why the elaborated-type-specifier?

[ebevhan]

I also think it would be good with some unit tests for this class once the functionality and interface is nailed down.

include/clang/Basic/FixedPoint.h

31 ↗

(On Diff #153426)

That's what I was expecting too, similar to the APFloat version.

What width would it contain? The width with or without padding? Probably the one with padding as the APInt itself has the width without padding.

53 ↗

(On Diff #153426)

occurred

lib/AST/ASTContext.cpp

10320 ↗

(On Diff #153119)

True, but I meant something more along the lines of

if(DstScale < Scale)
  Val = Val >> (Scale - DstScale);
Val = Val.extOrTrunc(DstWidth);
if(DstScale > Scale)
  Val = Val << (DstScale - Scale);

But I think you've changed it a bit so I need to have a look at the revised version.

lib/Basic/FixedPoint.cpp

20 ↗

(On Diff #153426)

I'm unsure if this operation is useful for anything but converting fixed-point to integer. Make this a member of APFixedPoint, drop the arguments and give it a name that makes it clearer that it is a round-to-zero integer conversion? toIntegerRoundToZero?

53 ↗

(On Diff #153426)

I think saturation can be modeled a bit better. It should be possible to do the overflow check/saturation once instead of twice, and also have it fit in better with the other conversions.

Saturation on a value is essentially checking whether all bits above and including a certain bit are all the same, and 'clamping' to either the minimum (the mask) or maximum (inverse of the mask) if not.

// Saturate Value to SatWidth. This will clamp Value at the signed min/max of a value that is SatWidth long.
Saturate(SatWidth):
  Mask = highBits(Width, SatWidth + 1)
  Masked = Value & Mask
  Result = Value
  if (Masked == Mask || Masked == 0) {
    if (Masked.isNegative())
      Result = Mask
    else
      Result = ~Mask
  }

This cannot be done on the value in the source scale, since upscaling after clamping would produce an incorrect value - we would shift in 0's from the right even though we should have saturated all bits completely. Also, we cannot upscale without first extending or we might shift out bits on the left that could affect saturation.

One thing to note is that (I'm *pretty sure* this is the case) fractional bits cannot affect saturation. This means that we can find a common scale, then perform the saturation operation, and then resize, and the value should just fall into place. Basically:

1. Upscale if necessary, but extend first to ensure that we don't drop any bits on the left. Do this by resizing to SrcWidth - SrcScale + std::max(SrcScale, DstScale) and then upscaling normally by DstScale - SrcScale.
2. Downscale if necessary by SrcScale - DstScale. (I think; in our downstream, we saturate first and then downscale, but we also assume that saturation can only occur on _Fract, and doing saturation first makes the saturation width calculation a bit messier because it will be a max expression. I'm unsure if the order can be changed.)
3. At this point, the scale of the value should be DstScale. Saturate with Saturate(DstWidth).
4. Now the value should be in range for the new width, and will be at the right scale as well. Resize with extOrTrunc(DstWidth).
5. (Also; if the result was negative and the dest type is unsigned, just make the result zero here instead.)

Note that the order of operations is different than what I've mentioned before with non-saturated conversion (downscale if needed, resize, upscale if needed), but it works because we only do the upscale as a resize+upscale. Somewhere in here you also need to change the signedness of the value, but I'm not entirely certain where. Likely after 4.

Everything I've mentioned here is semi-conjectural, since our implementation has different type widths than the defaults in this one, we can only saturate on _Fract, and our unsigned types have padding. It's possible that there are some assumptions that cause this method to fail for unsigned without padding, or perhaps for some other type conversion, but I haven't come up with a counterexample yet.

61 ↗

(On Diff #153426)

This is a bit tricky. The spec does indeed say that conversion to integer must round toward zero, but does not say that conversion between fixed-point types must. If we have these routines perform conversion like this, we would likely have to emit extra code (either an addition or the two negations) during fixed-to-fixed conversion to match the consteval behavior.

I think fixed-to-fixed conversion should keep using a normal shift, and reserve the round-to-zero shift for conversion to integer.

89 ↗

(On Diff #153426)

You can use getMax and getMin here to simplify the logic, I think?

As I mention in my other comment I think that the saturation logic can be more strongly integrated into the conversion.

114 ↗

(On Diff #153426)

if (Scale != OtherScale)
  CommonWidth += std::abs(OtherScale - Scale)

They need to be int, of course.

122 ↗

(On Diff #153426)

Are the if's needed? If CommonScale == Scale or OtherScale, shl will do nothing.

[ebevhan]

lib/Basic/FixedPoint.cpp

53 ↗

(On Diff #153426)

Now that I think about it a bit more, it's clear that the Saturate routine does not work for unsigned fixed-point without padding. That would need to be taken into consideration, but the rest should work.

[leonardchan]

• Added tests
• Moved all conversion logic into convert
• Saturation is checked by checking the bits above the sign bit in the destination type

[leonardchan]

include/clang/Basic/FixedPoint.h

31 ↗

(On Diff #153426)

Woops my bad, I thought you were referring to the APFloatSemantics. I actually didn't know about fltSemantics until now.

lib/Basic/FixedPoint.cpp

20 ↗

(On Diff #153426)

You're right. Removed it altogether.

53 ↗

(On Diff #153426)

Thanks for the deeper explanation. The implementation is essentially the same and catching the unsigned fixed point without padding is just checking if the value is negative and we are casting to an unsigned.

53 ↗

(On Diff #153426)

Also I wasn't sure if this was a typo, but I have

if (!(Masked == Mask || Masked == 0)) {

instead of

if (Masked == Mask || Masked == 0) {

because I think the mask comparison checks if the bits above the sign changed which indicates saturation.

61 ↗

(On Diff #153426)

You're right. The spec also says that shifting falls under the typical rounding behavior which is implementation-defined.

89 ↗

(On Diff #153426)

Removed saturatedRescaleAndResize and rescaleAndResize altogether since the logic in both can be performed in convert.

[ebevhan]

include/clang/Basic/FixedPoint.h

67 ↗

(On Diff #153821)

If this class is supposed to be used like APInt and APSInt, perhaps this function should return a copy instead of modifying in place.

The reason that the APFloat convert function modifies in place is because it needs to return a status code, but I don't think that is necessary for this.

lib/Basic/FixedPoint.cpp

25 ↗

(On Diff #153821)

Why the early exit? What does the logic below not handle?

If this value has padding but the other doesn't (or vice versa), the scales will be different and the code below should work just fine.

40 ↗

(On Diff #153821)

It should be possible to replace this with extOrTrunc and move it below the saturation.

44 ↗

(On Diff #153821)

Combine the above block with the below one.

49 ↗

(On Diff #153821)

Val is an APSInt so it should be possible to just do >> and get the right behavior, provided that the signedness is correct.

58 ↗

(On Diff #153821)

If the value is unsigned and negative, we always zero it?

Also, this code always saturates the value regardless of whether the destination semantics call for it, no?

73 ↗

(On Diff #153821)

When we say 'width' do we mean the width - padding or the width including padding? What information does the semantics structure enshrine?

93 ↗

(On Diff #153821)

Use extOrTrunc and you won't need the ifs.

All of those accessors are a bit misnamed, it should be called extOrTruncOrSelf...

53 ↗

(On Diff #153426)

Yes, that was a typo! Sorry! Good thing you realized it.

[leonardchan]

lib/Basic/FixedPoint.cpp

40 ↗

(On Diff #153821)

I don't think we can move the extension below saturation since saturation requires checking the bits above the dst width which may require extending and shifting beforehand.

Still leaving it above saturation may require checking for the width over using extOrTrunc to prevent truncating early before right shifting.

58 ↗

(On Diff #153821)

You're right. I did not test for this since I thought this would fall under undefined behavior converting a signed negative number to an unsigned number. I'll add a check for saturation since I imagine most people would expect modular wrap around, but do you think I should add a test case for this?

73 ↗

(On Diff #153821)

This width includes the padding. This is commented on over struct fixedPointSema where this width represents that of the underlying APInt, so if the sema is unsigned and hasUnsignedPadding is true, then in a provided APInt with this width, the width-1 bit is padding.

[rjmccall]

include/clang/Basic/FixedPoint.h

31 ↗

(On Diff #153426)

Thanks, this looks a lot better to me. Please do capitalize FixedPointSemantics, though; fltSemantics is a bizarre deviation from LLVM's style guidelines that should be fixed, not something to emulate.

41 ↗

(On Diff #153426)

Similarly, this should be renamed to getIntegralBits to follow the normal LLVM method-naming guidelines.

Also, please go ahead and hide all the members here behind getters and setters. It's better to reserve flexibility in advance than to have to rewrite a bunch of code later.

[leonardchan]

• Renamed fixedPointSemantics to FixedPointSemantics and hid the members behind getters

[rjmccall]

Thanks, much appreciated. A couple more style changes that I noticed and this will be LGTM, although you should also make sure you have Bevin Hansson's approval.

include/clang/AST/ASTContext.h

33 ↗

(On Diff #154020)

Please forward-declare FixedPointSemantics and APFixedPoint instead of including them here. This file is #included into almost the entire project, but relatively few files will actually need to use any of the functionality of APFixedPoint. Among other things, it will make your life much happier bringing up this feature if every tiny change to the APFixedPoint interface doesn't force a full recompile.

1953 ↗

(On Diff #154020)

Please spell out "semantics" here.

include/clang/Basic/FixedPoint.h

41 ↗

(On Diff #153426)

All of these inlines are unnecessary.

[ebevhan]

lib/Basic/FixedPoint.cpp

40 ↗

(On Diff #153821)

I think the cases where saturation takes effect are limited to simply truncation, since when we upscale we automatically extend first to avoid shifting out bits. This means that the only situation where we need to check for saturation is right before we truncate, and we don't have to worry about anything happening when we upscale.

Do you have an example of when the extension is needed? (In case it wasn't clear, I mean the NewVal = NewVal.extend(DstWidth); extension, not the extension that is part of the upscale)

58 ↗

(On Diff #153821)

Yes, even though it's undefined behavior to wrap, I think it's a good idea to do as little work as possible for each operation and keep every operation as simple as possible. This is to make it easier to codegen later, since it will mean fewer operations, it will be simpler to understand the connection between the semantics of the operations and the code emission and there will be better 'alignment' between generated code and constant evaluation results.

Obviously, if you invoke undefined behavior in runtime anything can happen, but I think that the operations should behave "sensibly" in isolation.

50 ↗

(On Diff #154020)

If you move the !DstSema.isSigned() && NewVal.isNegative() block after the mask check, you can avoid doing = 0 twice.

58 ↗

(On Diff #154020)

The signedness of NewVal is not being set here.

unittests/Basic/FixedPointTest.cpp

380 ↗

(On Diff #154020)

Technically, neither CheckSaturatedConversion function checks whether or not the result was correct, only that it saturated.

506 ↗

(On Diff #154020)

Acc?

[leonardchan]

lib/Basic/FixedPoint.cpp

40 ↗

(On Diff #153821)

Ooooooh I see. Sorry this confused me for a bit. Thanks.

unittests/Basic/FixedPointTest.cpp

380 ↗

(On Diff #154020)

Could you elaborate on this? It should be correct that the value saturates to the respective min/max for the destination type right?

506 ↗

(On Diff #154020)

Short for Accum. Changed to Accum since it wasn't clear at first.

[leonardchan]

@ebevhan Any followup on the patch/my previous comments?

[rjmccall]

include/clang/AST/ASTContext.h

1953 ↗

(On Diff #154020)

You missed this request.

include/clang/Basic/FixedPoint.h

64 ↗

(On Diff #154465)

This should get a documentation comment describing the class. You should mention that, like APSInt, it carries all of the semantic information about the value's type (width, signed-ness, saturating-ness, etc.), but by design it does not carry the original C type — among other reasons, so that it can more easily be moved to LLVM should fixed-point types gain native IR support.

[rjmccall]

include/clang/Basic/FixedPoint.h

64 ↗

(On Diff #154465)

Documentation comments start with ///.

Otherwise, these changes look good; LGTM, but of course you should settle Bevin's review comments before committing.

[ebevhan]

Sorry for the late response, I've been away.

LGTM, although my browser doesn't want to let me set Accepted on this.

unittests/Basic/FixedPointTest.cpp

380 ↗

(On Diff #154020)

It should... I'm not sure what I was thinking of when I wrote this comment, and I can't think of a counterexample so it's fine as it is.

506 ↗

(On Diff #154020)

Seems like you got a couple Accumum from that.

[leonardchan]

• Fixed Accumum names

[bricci]

Just a nit but could you please add new-lines to your commit messages.
Also the 3 bools in FixedPointSemantics are a little bit wasteful.
I don't know here if it matter but I have been spending the last weeks
cleaning up this kind of thing and this already cut the time of an fsyntax-only
by ~3.5%.

[bricci]

And using the name Sema is a bad idea IMHO since this has a totally different meaning in clang.

[leonardchan]

In D48661#1189537, @bricci wrote:

Just a nit but could you please add new-lines to your commit messages.

My bad, will remember this for future commits.

Also the 3 bools in FixedPointSemantics are a little bit wasteful.
I don't know here if it matter but I have been spending the last weeks
cleaning up this kind of thing and this already cut the time of an fsyntax-only
by ~3.5%.

Would you recommend something along the lines of having a bitmask instead of 3 bools? What should I keep in mind to avoid making fsyntax-only longer?

And using the name Sema is a bad idea IMHO since this has a totally different meaning in clang.

I'll make another small patch where I rename this.

[bricci]

Added some comments inline.
However I have not looked at the logic too closely and
have not looked at the tests at all.

cfe/trunk/include/clang/AST/ASTContext.h

1966

could you add some comments for these functions ?
What are they doing ?

cfe/trunk/include/clang/Basic/FixedPoint.h

24

This should be removed if unused. It is very strange to have
something basic like a fixed point type depending on ASTContext...

31

s/treaded/treated

54

Do you really need the branch here?
Why not just return
Width - Scale - (IsSigned || (!IsSigned && HasUnsignedPadding))

Also doc

62

My point is that you have two unsigned and then 3 bools.
This means that your class has now sizeof == 3*sizeof(unsigned)
This is annoying on 64 bits archs since pretty much everything
in clang is aligned to 8 bytes (because of pointer alignment requirements)
Just stuff your bits into Width or Scale. Moreover I think that
you could just use a single unsigned to store all of this.

For example you could here use a bit-field like so:
unsigned Width : 15; (or any other appropriate split with Scale)
unsigned Scale : 14; (or any other appropriate split with Width)
unsigned IsSigned : 1;
unsigned IsSaturated : 1;
unsigned HasUnsignedPadding : 1;

Now I do not now if this matters or not in this case but it seems
to me that this is easy to do.

85

same comment about "sema"

99

Maybe a bit more documentation here...

Also use /// for comments explaining something to an user:
eg:

/// Create a new Frob blablabla
Frob makeFrobinator()

so that doxygen picks up these comments.

Use // for comments which are internal only
eg:

...
// TODO this is broken because blablabla
...

110

doc

120

does this fit into 80 cols ?

130

doc

cfe/trunk/lib/AST/ASTContext.cpp

10439

assert( ... && "Ty is not a fixed point type!")

10448

same

10453

same

cfe/trunk/lib/Basic/FixedPoint.cpp

15

Basic depends on ASTContext ? huh

98

Would this work: do a test for equality and return 0 if true,
then it seems to me that you can drop every else if.
Also maybe use the above trick to remove some branches.

[bricci]

Just to provide a bit of additional context:

My comment about fsyntax-only is not specific to fsyntax-only.
This is just an handy way to benchmark the frontend without noise
from LLVM. It is important to keep all frequently used structures small
(within reason) even if this result in a little bit of additional work to pack/unpack
(again, within reason) since the front-end is not doing a lot of computations
but is doing a lot of memory accesses.

On my machine when I do an fsyntax-only on all of Boost
~25% of the cycles are spent with execution stalled because of
a cache miss.

Now this basic fixed point type will potentially ends up in
the Type/Stmt/Decl hierarchy -> it *must* be small.

For another example of what not to do see APSInt which
stores a single bool, thus wasting 8 bytes on 64 bits archs
just for this single bit. I actually have a patch stuffing it into APInt
but have not bothered to upstream it since in this case it do not
really matter for clang.

cfe/trunk/include/clang/AST/ASTContext.h

 namespace llvm {
 
 struct fltSemantics;
 
 } // namespace llvm
 
 namespace clang {
 
+class APFixedPoint;
 class APValue;
 class ASTMutationListener;
 class ASTRecordLayout;
 class AtomicExpr;
 class BlockExpr;
 class BuiltinTemplateDecl;
 class CharUnits;
 class CXXABI;
 class CXXConstructorDecl;
 class CXXMethodDecl;
 class CXXRecordDecl;
 class DiagnosticsEngine;
 class Expr;
+class FixedPointSemantics;
 class MangleContext;
 class MangleNumberingContext;
 class MaterializeTemporaryExpr;
 class MemberSpecializationInfo;
 class Module;
 class ObjCCategoryDecl;
 class ObjCCategoryImplDecl;
 class ObjCContainerDecl;
if (!type.getTypePtr()->isObjCObjectPointerType() ||
       return type;
     Qualifiers Qs = type.getQualifiers();
     Qs.removeObjCLifetime();
     return getQualifiedType(type.getUnqualifiedType(), Qs);
   }
 
   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;
 
   TemplateName getOverloadedTemplateName(UnresolvedSetIterator Begin,
                                          UnresolvedSetIterator End) const;
 
   TemplateName getQualifiedTemplateName(NestedNameSpecifier *NNS,

cfe/trunk/include/clang/Basic/FixedPoint.h

+//===- 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

cfe/trunk/include/clang/Basic/TargetInfo.h

case SignedLong:
       return UnsignedLong;
     case SignedLongLong:
       return UnsignedLongLong;
     default:
       llvm_unreachable("Unexpected signed integer type");
     }
   }
 
+  /// 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().
   unsigned getTypeWidth(IntType T) const;
 
   /// Return integer type with specified width.
   virtual IntType getIntTypeByWidth(unsigned BitWidth, bool IsSigned) const;
 

cfe/trunk/lib/AST/ASTContext.cpp

 #include "clang/AST/Type.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/AST/UnresolvedSet.h"
 #include "clang/AST/VTableBuilder.h"
 #include "clang/Basic/AddressSpaces.h"
 #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"
 #include "clang/Basic/Linkage.h"
 #include "clang/Basic/ObjCRuntime.h"
 #include "clang/Basic/SanitizerBlacklist.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
switch (BT->getKind()) {
     case BuiltinType::SatUShortFract:
     case BuiltinType::UFract:
     case BuiltinType::SatUFract:
     case BuiltinType::ULongFract:
     case BuiltinType::SatULongFract:
       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));
+}

cfe/trunk/lib/Basic/CMakeLists.txt

add_clang_library(clangBasic
   Builtins.cpp
   CharInfo.cpp
   Cuda.cpp
   Diagnostic.cpp
   DiagnosticIDs.cpp
   DiagnosticOptions.cpp
   FileManager.cpp
   FileSystemStatCache.cpp
+  FixedPoint.cpp
   IdentifierTable.cpp
   LangOptions.cpp
   MemoryBufferCache.cpp
   Module.cpp
   ObjCRuntime.cpp
   OpenMPKinds.cpp
   OperatorPrecedence.cpp
   SanitizerBlacklist.cpp

cfe/trunk/lib/Basic/FixedPoint.cpp

+//===- 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

cfe/trunk/lib/Sema/SemaExpr.cpp

 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/EvaluatedExprVisitor.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
 #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"
 #include "clang/Lex/LiteralSupport.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Sema/AnalysisBasedWarnings.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/DelayedDiagnostic.h"
if (Literal.isAccum) {
         Ty = Context.FractTy;
       }
     }
 
     if (Literal.isUnsigned) Ty = Context.getCorrespondingUnsignedType(Ty);
 
     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
       // the maximal value for the type.
       --Val;
     else if (Val.ugt(MaxVal) || Overflowed)
       Diag(Tok.getLocation(), diag::err_too_large_for_fixed_point);
 

cfe/trunk/test/Frontend/fixed_point_declarations.c

 // 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
 signed _Accum         s_accum;        // CHECK-DAG: @s_accum        = {{.*}}global i32 0, align 4
 signed long _Accum    s_long_accum;   // CHECK-DAG: @s_long_accum   = {{.*}}global i64 0, align 8
 unsigned short _Accum u_short_accum;  // CHECK-DAG: @u_short_accum  = {{.*}}global i16 0, align 2
 unsigned _Accum       u_accum;        // CHECK-DAG: @u_accum        = {{.*}}global i32 0, align 4
 unsigned long _Accum  u_long_accum;   // CHECK-DAG: @u_long_accum   = {{.*}}global i64 0, align 8

 unsigned long _Accum  u_long_accum_eps  = 0x1p-32ulk;       // CHECK-DAG: @u_long_accum_eps  = {{.*}}global i64 1, align 8
 
 short _Fract          short_fract_eps   = 0x1p-7hr;         // CHECK-DAG: @short_fract_eps   = {{.*}}global i8  1, align 1
 _Fract                fract_eps         = 0x1p-15r;         // CHECK-DAG: @fract_eps         = {{.*}}global i16 1, align 2
 long _Fract           long_fract_eps    = 0x1p-31lr;        // CHECK-DAG: @long_fract_eps    = {{.*}}global i32 1, align 4
 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

cfe/trunk/unittests/Basic/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Support
   )
 
 add_clang_unittest(BasicTests
   CharInfoTest.cpp
   DiagnosticTest.cpp
   FileManagerTest.cpp
+  FixedPointTest.cpp
   MemoryBufferCacheTest.cpp
   SourceManagerTest.cpp
   VirtualFileSystemTest.cpp
   )
 
 target_link_libraries(BasicTests
   PRIVATE
+  clangAST
   clangBasic
   clangLex
   )

cfe/trunk/unittests/Basic/FixedPointTest.cpp

+//===- 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 _Accum sema converted to other sema for different values.
+void CheckSignedAccumConversionsAgainstOthers(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 _Accum sema converted to other sema for different
+// values.
+void CheckUnsignedAccumConversionsAgainstOthers(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, AccumConversions) {
+  // Normal conversions
+  CheckSignedAccumConversionsAgainstOthers(getSAccumSema(), 128);
+  CheckUnsignedAccumConversionsAgainstOthers(getUSAccumSema(), 256);
+  CheckSignedAccumConversionsAgainstOthers(getAccumSema(), 32768);
+  CheckUnsignedAccumConversionsAgainstOthers(getUAccumSema(), 65536);
+  CheckSignedAccumConversionsAgainstOthers(getLAccumSema(), 2147483648);
+  CheckUnsignedAccumConversionsAgainstOthers(getULAccumSema(), 4294967296);
+
+  CheckUnsignedAccumConversionsAgainstOthers(getPadUSAccumSema(), 128);
+  CheckUnsignedAccumConversionsAgainstOthers(getPadUAccumSema(), 32768);
+  CheckUnsignedAccumConversionsAgainstOthers(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