[clang][Interp] Implement basic support for floating point values

[tbaeder]

Summary

This only handles floats for now, so 32 bit floating point values.

There are a few things I'm uncertain about, like how to implement Floating<>::truncate() or whether or not Float32 should be part of AluTypeClass.

[tbaeder]

clang/lib/AST/Interp/Context.cpp

117

clang/lib/AST/Interp/Floating.h

107

The operations here don't do overflow or UB handling.

[shafik]

clang/lib/AST/Interp/Floating.h

81

bool isNaN() const { return V != V; }

[aaron.ballman]

I've not given this a full review yet, but I do have some comments on a partial review. Mostly, I'm concerned we're going to have different semantics when evaluating than we'd get if the evaluation happened at runtime because we're using the host floating-point environment and not the target. I'm also a bit concerned the design won't extend very easily to long double support. We don't have to solve all of this with the initial offering, but I think we want to be sure we're building the float support on a stable base.

Adding @jcranmer-intel for another set of eyes on this code from someone who knows many of the most terrifying parts of floating-point support.

clang/lib/AST/Interp/ByteCodeExprGen.cpp

180

Is there a reason you want to convert to the host float format here instead of passing along the APFloat object so semantics follow the target?

clang/lib/AST/Interp/Floating.h

28–30

Er, how will this extend to long double where the number of bits is rather more difficult?

75–80

Hmm, this is making my spidey senses tingle. For example, negative zero should be negative, but < won't help you with that: https://godbolt.org/z/xonxqPv5r (and it definitely won't help for negative inf or a signed NaN).

[jcranmer-intel]

Some extra constexpr tests that may be interesting:

• Constant expressions that produce floating point exceptions other than FE_INEXACT.
• Subnormal values as operands, as well as operations with normal operands that produce denormal values (i.e., check for DAZ/FTZ, respectively.)
• qNaN arithmetic
• sNaN arithmetic
• different NaN payloads (this can also catch out differences caused by host hardware: there's disagreement as to which NaN payload is used in an fadd, some processors prefer the first one, others prefer the second one).
• converting infinity, NaN, numbers outside INT_MAX range to integers
• converting integers to floating-point outside the latter's range--that's only possible with unsigned __int128 and float or uint32_t and half though

Some of these tests relate to things that you haven't implemented yet--and that's fine--but it's worth keeping in mind for future patches.

clang/lib/AST/Interp/Floating.h

28–30

Or half and bfloat, which are both 16-bit floating-point types?

32–34

My gut reaction is that, for floating-point types, you're probably better off using APFloat directly rather than trying to use the float/double platform types directly. Directly using platform types for computation means you potentially have changes based on the how clang itself was compiled--especially if someone decides to compile clang with -ffast-math and now all your constexpr stuff is executing in FTZ/DAZ mode. APFloat may be slower, but it also provides more protection from floating-point chicanery.

83

This is supposed to be capable of returning unordered if *this or RHS is a NaN, right?

107

They also don't support rounding mode. (constexpr evaluation arguably should at least support FENV_ROUND)

[tbaeder]

clang/lib/AST/Interp/Floating.h

28–30

I have spent some time with this today and tried to simply always use APFloat instead of a primitive type. Unfortunately that doesn't work because what we put on the stack is not the Floating (or Integral), but the underlying primitive type. So even if we do the final math (in ::add, etc) via APFloat, we need something we can serialize to char[] so we can put it on the stack. Do you think that would work?

[jcranmer-intel]

clang/lib/AST/Interp/Floating.h

28–30

I don't know enough about the structure of the bytecode interpreter here to say for sure, but this smells to me like you're baking in an assumption that every primitive target type has a corresponding primitive type on the host. This assumption just doesn't hold when it comes to floating point (only two of the seven types, float and double, are generally portable, and even then, there be dragons in some corner cases).

If you do need to continue down this route, there are two requirements that should be upheld:

• The representation shouldn't assume that the underlying primitive type exists on host (bfloat16 and float128 are better test cases here).
• Conversion to/from host primitive types shouldn't be easy to accidentally do.

(Worth repeating again that bit size is insufficient to distinguish floating point types: bfloat and half are both 16-bit, PPC long double and IEEE 754 quad precision are both 128-bit, and x86 long double is 80 bits stored as 96 bits on 32-bit and 128 bits on 64-bit.)

[tbaeder]

clang/lib/AST/Interp/Floating.h

28–30

Well, is there a way to convert an APFloat to a char[] that would work instead of going to float/double and storing that? The only thing I see in the docs is convertToHexString() (and the docs don't mention whether the conversion is lossy). If not, do you think adding such a conversion to APFloat and its various implementations is the better way forward?

[aaron.ballman]

clang/lib/AST/Interp/Floating.h

28–30

Let's avoid serializing the floats to strings so that we can parse the string to turn it back into a float later; that's going to have poor performance even if we do get all the corner cases correct regarding things like rounding, etc.

APFloat does not have any sort of serialization functionality beyond through strings representing the value. I think you'd have to invent such an interface.

[tbaeder]

clang/lib/AST/Interp/Floating.h

28–30

Do you know who I might talk to regrading such an interface, both the implementation as well as general feasibility?

[aaron.ballman]

clang/lib/AST/Interp/Floating.h

28–30

I think there may be at least two ways to do this: use an APFloat and put the serialization interfaces there, or use an APValue and put the serialization interfaces there.

Because APFloat is an ADT in LLVM, I think it should probably go up on Discourse for broader discussion. @chandlerc is still listed as the code owner for ADTs but he's not been active in quite some time. Instead, I would recommend talking to @dblaikie (he's got a good eye for ADT work in general) and @foad, @RKSimon, and @sepavloff as folks who have recently been touching APFloat.

APValue is a Clang-specific class, and it already has some amount of serialization support, it seems (https://github.com/llvm/llvm-project/blob/main/clang/include/clang/AST/APValue.h#L54). From a quick look, it seems we're already using APValue in a reasonable number of places in the interpreter, so it might make sense to use this object consistently to represent all values in the new interpreter?

[jcranmer-intel]

clang/lib/AST/Interp/Floating.h

28–30

Going through APInt is already possible in APFloat, and that might have some methods to go to char arrays.

[dblaikie]

clang/lib/AST/Interp/Floating.h

28–30

Yeah - IR gets serialized APFloats somehow (maybe through some layers of indirection) so I'd suggest looking at how, say, a global float named constant gets lowered to bitcode to see how that APFloat is serialized.

If that's not enough of a pointer for you/others to find something helpful, I can look further to see what I can find (I got some of the way - a small example with just extern const float v; const float v = 3.14; and breaking on APFloat's ctor immediately finds the APFLoat being constructed from that literal - then I looked at llvm::GlobalVariable's ctor, which does break on the creation of v, but didn't continue further to figure out how the parsed value gets into the IR constant)

[tbaeder]

clang/lib/AST/Interp/Floating.h

28–30

So, I think this is implemented in emitGlobalConstantFP(): https://github.com/llvm/llvm-project/blob/main/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp#L3206. I now wonder how to implement this, since the number of chunks isn't fixed. And all this seems rather costly given that we'd have to do this every time we access a floating point value on the stack.

[dblaikie]

clang/lib/AST/Interp/Floating.h

28–30

That looks like the lowering to assembly - I meant the lowering to LLVM IR bitcode, though perhaps it's similarly complicated.

As for variable length - I expect the strings encoding had variable length too, but either relied on null termination or a length prefix. The APFloat serialization could use a length prefix encoding to specify how many bytes to read/decode (I guess LLVM IR bitcode does something like that - though I think the bitcode records always encode their length, so it might be implicit).

[tbaeder]

Another try, this time without any underlying host type.

There are a few things I'm uncertain about. The tests are obviously not enough, especially now that I had to add another CastFP opcode to cast floats between different semantics.

The general approach seems much saner than before, but I'm sure you'll find enough problem with this one as well :)

BTW, I feel like there are a lot of comments on this review now, so if you'd like me to split the new version of the patch out into another ticket, I can do that of course.

[tbaeder]

clang/lib/AST/Interp/Floating.h

34–35

This is currently commented out, but I think I can get the semantics of the APFloat and ask its semantics for min/max values.

[jcranmer-intel]

clang/lib/AST/Interp/Floating.h

34–35

APFloat::get{Largest,Smallest} will do the trick.

90

FYI, operator== on APFloat requires the two types to have the same semantics. Probably the fastest way to check if it's -1 is either ilogb(F) == 0 && F.isNegative() or F.isExactlyValue(-1.0).

clang/lib/AST/Interp/Interp.cpp

404

FWIW, const llvm::fltSemantics & is the usual way it's used.

[tbaeder]

clang/lib/AST/Interp/Interp.cpp

404

I saw, but this is going through a char[] stack a gain and I don't think using a reference works there.

[tbaeder]

clang/lib/AST/Interp/Floating.h

34–35

I only need them for isMin(), so isSmallest() even works, thanks!

[tbaeder]

Any other opinions on the new approach?

[sepavloff]

clang/lib/AST/Interp/Boolean.h

56

Is there any reason why operator double exists, but operator float does not?

clang/lib/AST/Interp/ByteCodeExprGen.cpp

118

Does this two-stage conversion make sense? In contrast to things like PT_Sint8 PT_Float is not a real type, it designates a set (potentially open) of all floating-point types. What is the meaning of this conversion? Why emitCastFP is not enough?

BTW which classes implement emitCast and emitCastFP? Usually such casts depend on rounding mode, how these methods get it?

695

Should this method get floating-point semantic as a parameter?

clang/lib/AST/Interp/Floating.h

38

This constructor creates a value of particular floating-point type, which generally is not compatible with floating-point values of other types. Does it need a semantic argument?

45

This method requires semantic just as getInf.

55–63

Conversions to integers are bitcasts+truncation but the conversion to bool is different. What semantics have these operations?

[tbaeder]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

118

I think we could do this in CastFP, yes. But what happens right now is that we use Floating::from() with, e.g. a int32_t, which just does APFloat(int32_t), which I think results in float semantics. So if we're instead casting from int to double, the CastFP is needed.

CastFP is implemented below in this diff and uses Floating::toSemantics(). Cast is using ToT::from(FromT), so uses Floating::from() to do the cast.

695

Yes I think that would be alright, we could just get the right semantics in this function.

clang/lib/AST/Interp/Floating.h

38

That's a good question. I think generally you're right but I don't know where this constructor is used at all right now. Might just be dead code.

55–63

They are basically used for casting. I didn't mean to make the bool implementation different, just seemed to make sense to me to do it this way.

[sepavloff]

clang/lib/AST/Interp/Floating.h

55–63

If they are used for casting, they need to preserve value, that is conversion float->int32 should transform 1.0->0x00000001. The method toAPSInt uses bitcast, so it converts 1.0->0x3f800000. APFloat::convertToInteger should be used to make value-preverving conversion but it requires knowledge of rounding mode.

[tbaeder]

clang/lib/AST/Interp/Floating.h

55–63

That's good to know, thanks. I've already used TowardZero in Floating::toSemantics(), but that was more a guess.

Is the rounding mode I'm supposed to use simply LangOptions::getDefaultRoundingMode()?

[sepavloff]

clang/lib/AST/Interp/Floating.h

55–63

Rounding mode is stored in AST node, a call to Expr::getFPFeaturesInEffect may be used to extract various FP features in the form of FPOptions. LangOptions::getDefaultRoundingMode() returns the default rounding mode, which may be changed using #pragma STDC FENV_ROUND.

[tbaeder]

Another (and even longer) version.

Introduce special opcodes for floating point operations and pass the rounding mode to them. Also create special int->float and float->int casts so we can handle that properly.

This makes clang/tests/SemaCXX/rouding-math.cpp work. I've only enabled one of the two RUN lines though. The other one fails because we don't handle CXXNewExprs yet.

[tbaeder]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

695

I left the implementation of this out since visitZeroInitializer() is dead code right now anyway and the patch is already large enough.

[tbaeder]

Ping

[sepavloff]

clang/lib/AST/Interp/PrimType.h

39

In contrast to other members of this enumeration, PT_Float does not designate a concrete type, and it must creates problems. For example, how function primSize(PrimType Type) can be implemented?

[tbaeder]

clang/lib/AST/Interp/PrimType.h

39

Yes, floats are a bit special, see also the special case in getCtorPrim() in Descriptor.cpp. But I don't think it's a problem for primSize() since that only uses sizeof().

[sepavloff]

clang/lib/AST/Interp/PrimType.h

39

sizeof in primSize() would return sizeof(clang::interp::Floating), which is sizeof(APFloat). This value is not the same as sizeof(float) or sizeof(double).

[tbaeder]

clang/lib/AST/Interp/PrimType.h

39

I am aware, but primSize() is not used to implement sizeof() or anything like that, it's used on the host side to do memory allocation, e.g. Descriptor uses it to allocate NumElems * primSize(T) bytes for primitive arrays.

[tbaeder]

Moved the tests to their own file and moved the isConstantContext() changes to InterpState to their own NFC commit.

[tbaeder]

Ping

[jcranmer-intel]

clang/lib/AST/Interp/Interp.cpp

481

Not sure I understand the conditions that cause S.inConstantContext() to be true, which gives me some cause for concern. Additionally, there's no tests covering the checks in the function.

clang/lib/AST/Interp/Opcodes.td

515

Integer-to-floating point conversion is dependent on rounding mode--consider (float)UINT_MAX.

[tbaeder]

clang/lib/AST/Interp/Interp.cpp

481

This function is almost copy/paste from checkFloatingPointResult in ExprConstant.cpp: https://github.com/llvm/llvm-project/blob/main/clang/lib/AST/ExprConstant.cpp#L2581

clang/lib/AST/Interp/Opcodes.td

515

This test succeeds here, whether I use -frounding-math or not:

constexpr float f = (float)4294967295;
static_assert(f == (float)4.2949673E+9);

How can I test this behavior?

[sepavloff]

clang/lib/AST/Interp/Opcodes.td

515

You can use #pragma STDC FENV_ROUND. See clang/test/AST/const-fpfeatures.c as an example.

[tbaeder]

Added a const-fpfeatures.cpp test and added semantics converstion to ::add as an example.

[tbaeder]

clang/lib/AST/Interp/Opcodes.td

515

Why does it work here to compare both f and f2 to the same value? https://godbolt.org/z/zdsf1sK7r

[tbaeder]

Return opStatus from convertToInteger as well, and add a test case to floats.cpp that tests float-to-integer conversion.

[tbaeder]

Report overflows when converting floats to integers.

[jcranmer-intel]

clang/lib/AST/Interp/Opcodes.td

515

FENV_ROUND is a new feature of C2x, so it doesn't look like it's properly handled in gcc or clang yet. (It's for sure not handled in clang--the code to convert a floating-point literal into an APFloat hardcodes default rounding mode in its call.)

Dynamic rounding mode shows you the difference: https://godbolt.org/z/856xM8KTh

[tbaeder]

clang/lib/AST/Interp/Opcodes.td

515

So I can't test this at all because it first needs work in clang to do the float->APFloat conversion correctly?

[sepavloff]

Patch https://reviews.llvm.org/D137719 fixed int->float conversion.

[tbaeder]

Added the int-to-float conversion tests from https://reviews.llvm.org/D137719

[tbaeder]

Ping

[tbaeder]

FYI, I noticed the way the floating values are serialized doesn't work if the APFloat heap-allocated anything; those values aren't preserved through (de)serialization of course.

Reproducer:

constexpr double foo() {
  return __LDBL_MIN__;
}

[sepavloff]

In D134859#3943926, @tbaeder wrote:

FYI, I noticed the way the floating values are serialized doesn't work if the APFloat heap-allocated anything; those values aren't preserved through (de)serialization of course.

Reproducer:

constexpr double foo() {
  return __LDBL_MIN__;
}

The return statement returns a value of type long double while the function returns double. If long double is wider than double, truncation occurs, may be this is the reason?

[tbaeder]

In D134859#3945709, @sepavloff wrote:

In D134859#3943926, @tbaeder wrote:

FYI, I noticed the way the floating values are serialized doesn't work if the APFloat heap-allocated anything; those values aren't preserved through (de)serialization of course.

Reproducer:

constexpr double foo() {
  return __LDBL_MIN__;
}

The return statement returns a value of type long double while the function returns double. If long double is wider than double, truncation occurs, may be this is the reason?

It also happens when the function returns a long double.

I tracked the problem down to the way we emit byte code into a std::vector. It's simply reintepret_cast'ed to const char *, so that won't work for APFloat.

This change seems to fix the problem:

diff --git a/clang/lib/AST/Interp/ByteCodeEmitter.cpp b/clang/lib/AST/Interp/ByteCodeEmitter.cpp
index ff2136d34872..61e9662013c3 100644
--- a/clang/lib/AST/Interp/ByteCodeEmitter.cpp
+++ b/clang/lib/AST/Interp/ByteCodeEmitter.cpp
@@ -163,8 +163,15 @@ static void emit(Program &P, std::vector<char> &Code, const T &Val,
   }

   if constexpr (!std::is_pointer_v<T>) {
-    const char *Data = reinterpret_cast<const char *>(&Val);
-    Code.insert(Code.end(), Data, Data + Size);
+     if constexpr (std::is_trivially_copyable_v<T>) {
+      const char *Data = reinterpret_cast<const char *>(&Val);
+      Code.insert(Code.end(), Data, Data + Size);
+     } else {
+       // Construct the value directly into our storage vector.
+       size_t ValPos = Code.size();
+       Code.resize(Code.size() + Size);
+       new (Code.data() + ValPos) T(Val);
+     }
   } else {
     uint32_t ID = P.getOrCreateNativePointer(Val);
     const char *Data = reinterpret_cast<const char *>(&ID);

[tbaeder]

Remove some questionable (but unused) Floating API that didn't take floating-point semantics into account.

[sepavloff]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

123

According to C standard (6.3.1.4p1):

When a finite value of real floating type is converted to an integer type other than _Bool, the fractional part is discarded (i.e., the value is truncated toward zero).

So the conversion should not depend on rounding mode. The same applies to the conversion to boolean (6.3.1.2p1):

When any scalar value is converted to _Bool, the result is 0 if the value compares equal to 0; otherwise, the result is 1.

594

This and some subsequent operations also should depend on rounding mode?

clang/lib/AST/Interp/Floating.h

110

Do we really need this check? In AST operands of addition always have the same type.

clang/lib/AST/Interp/Interp.cpp

477–478

This comment is not exact. In a context context rounding mode may be affected by #pragma STDC FENV_ROUND.

clang/lib/AST/Interp/Interp.h

1263

Integral::canRepresent is suitable only for integral-to-intergal conversions. With loss of precision the floating-point numbers can represent wider range of integers.

[tbaeder]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

123

So this is a difference between C and C++?

594

Yes, I did add as an example, the others will have to follow.

clang/lib/AST/Interp/Floating.h

110

In https://godbolt.org/z/s4n75jc4h, the LHS of the CompoundAssignOperator is float while the RHS is double

[sepavloff]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

123

No, C++ behaves similarly ([conv.fpint]):

A prvalue of a floating-point type can be converted to a prvalue of an integer type. The conversion truncates;
that is, the fractional part is discarded.

and [conv.bool]:

A prvalue of arithmetic, unscoped enumeration, pointer, or pointer-to-member type can be converted to a
prvalue of type bool. A zero value, null pointer value, or null member pointer value is converted to false;
any other value is converted to true.

Theses conversions do not depend on rounding mode.

[tbaeder]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

123

Ah ok, thanks for the explanation. That explains why the current interpeter hardcodes rmTowardZero there. The rounding mode in Floating::convertToInteger was unused for that reason.

[tbaeder]

Ping

[sepavloff]

clang/lib/AST/Interp/Floating.h

110

The case of CompoundAssignOperator cannot be implemented using the same function as for BinaryOperator. The operation float += double implies three operations:

1. float value is converted to double,
2. addition of double values is made,
3. double result is converted to float.

The conversions 1 and 3 are not represented by ImplicitCasts, as demonstrated by your code snippet.

[tbaeder]

Remove conversion in Floating::add() and tests that relied on it. Compound assignment operators can be properly implemented later.

[sepavloff]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

592

As discussed previously, compound assign operator cannot be implemented with the same function as corresponding binary operator in general case.

clang/lib/AST/Interp/Interp.h

1258

Conversion to boolean can be made with APFloat::isNonZero. It would correctly handle all values including NaNs/Infs. convertToInteger may leave Result unchanged if Status is invalid.

1263

I was wrong, this is float-to-integer conversion. Would it be easier to detect overflow (as well as other cases, like NaN) by checking that Status==opInvalidOp && F.isFinite()?

[tbaeder]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

592

I left this in so at least one of the test cases in const-fpfeatures.cpp would work. But it seems like using res = res + y instead works as well and breaks if the #pragma before is commented-out, so I can use that instead.

clang/lib/AST/Interp/Interp.h

1263

That seems to work, yes. I switched to that and added an overflow test case to`floats.cpp`.

[sepavloff]

LGTM.

clang/lib/AST/CMakeLists.txt

add_clang_library(clangAST
   Interp/ByteCodeStmtGen.cpp
   Interp/Context.cpp
   Interp/Descriptor.cpp
   Interp/Disasm.cpp
   Interp/EvalEmitter.cpp
   Interp/Frame.cpp
   Interp/Function.cpp
   Interp/InterpBuiltin.cpp
+  Interp/Floating.cpp
   Interp/Interp.cpp
   Interp/InterpBlock.cpp
   Interp/InterpFrame.cpp
   Interp/InterpStack.cpp
   Interp/InterpState.cpp
   Interp/Pointer.cpp
   Interp/PrimType.cpp
   Interp/Program.cpp

clang/lib/AST/Interp/Boolean.h

 namespace interp {
 
 /// Wrapper around boolean types.
 class Boolean final {
  private:
   /// Underlying boolean.
   bool V;
 
-  /// Construct a wrapper from a boolean.
-  explicit Boolean(bool V) : V(V) {}
-
  public:
   /// Zero-initializes a boolean.
   Boolean() : V(false) {}
+  explicit Boolean(bool V) : V(V) {}
 
   bool operator<(Boolean RHS) const { return V < RHS.V; }
   bool operator>(Boolean RHS) const { return V > RHS.V; }
   bool operator<=(Boolean RHS) const { return V <= RHS.V; }
   bool operator>=(Boolean RHS) const { return V >= RHS.V; }
   bool operator==(Boolean RHS) const { return V == RHS.V; }
   bool operator!=(Boolean RHS) const { return V != RHS.V; }
 
   bool operator>(unsigned RHS) const { return static_cast<unsigned>(V) > RHS; }
 
   Boolean operator-() const { return Boolean(V); }
   Boolean operator~() const { return Boolean(true); }
 
   explicit operator int8_t() const { return V; }
   explicit operator uint8_t() const { return V; }
   explicit operator int16_t() const { return V; }
   explicit operator uint16_t() const { return V; }
   explicit operator int32_t() const { return V; }
   explicit operator uint32_t() const { return V; }
   explicit operator int64_t() const { return V; }
   explicit operator uint64_t() const { return V; }
   explicit operator bool() const { return V; }
 
   APSInt toAPSInt() const {
     return APSInt(APInt(1, static_cast<uint64_t>(V), false), true);
   }
   APSInt toAPSInt(unsigned NumBits) const {
     return APSInt(toAPSInt().zextOrTrunc(NumBits), true);
   }
   APValue toAPValue() const { return APValue(toAPSInt()); }
 

clang/lib/AST/Interp/ByteCodeEmitter.cpp

 //===--- ByteCodeEmitter.cpp - Instruction emitter for the VM ---*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "ByteCodeEmitter.h"
 #include "Context.h"
+#include "Floating.h"
 #include "Opcode.h"
 #include "Program.h"
 #include "clang/AST/DeclCXX.h"
 #include <type_traits>
 
 using namespace clang;
 using namespace clang::interp;
 

clang/lib/AST/Interp/ByteCodeExprGen.h

public:
   /// Initializes the compiler and the backend emitter.
   template <typename... Tys>
   ByteCodeExprGen(Context &Ctx, Program &P, Tys &&... Args)
       : Emitter(Ctx, P, Args...), Ctx(Ctx), P(P) {}
 
   // Expression visitors - result returned on interp stack.
   bool VisitCastExpr(const CastExpr *E);
   bool VisitIntegerLiteral(const IntegerLiteral *E);
+  bool VisitFloatingLiteral(const FloatingLiteral *E);
   bool VisitParenExpr(const ParenExpr *E);
   bool VisitBinaryOperator(const BinaryOperator *E);
   bool VisitPointerArithBinOp(const BinaryOperator *E);
   bool VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *E);
   bool VisitCallExpr(const CallExpr *E);
   bool VisitBuiltinCallExpr(const CallExpr *E);
   bool VisitCXXMemberCallExpr(const CXXMemberCallExpr *E);
   bool VisitCXXDefaultInitExpr(const CXXDefaultInitExpr *E);
private:
   }
 
   /// Returns whether we should create a global variable for the
   /// given VarDecl.
   bool shouldBeGloballyIndexed(const VarDecl *VD) const {
     return VD->hasGlobalStorage() || VD->isConstexpr();
   }
 
+  llvm::RoundingMode getRoundingMode(const Expr *E) const {
+    FPOptions FPO = E->getFPFeaturesInEffect(Ctx.getLangOpts());
+
+    if (FPO.getRoundingMode() == llvm::RoundingMode::Dynamic)
+      return llvm::RoundingMode::NearestTiesToEven;
+
+    return FPO.getRoundingMode();
+  }
+
 protected:
   /// Variable to storage mapping.
   llvm::DenseMap<const ValueDecl *, Scope::Local> Locals;
 
   /// OpaqueValueExpr to location mapping.
   llvm::DenseMap<const OpaqueValueExpr *, unsigned> OpaqueExprs;
 
   /// Current scope.

clang/lib/AST/Interp/ByteCodeExprGen.cpp

 //===--- ByteCodeExprGen.cpp - Code generator for expressions ---*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "ByteCodeExprGen.h"
 #include "ByteCodeEmitter.h"
 #include "ByteCodeGenError.h"
 #include "ByteCodeStmtGen.h"
 #include "Context.h"
+#include "Floating.h"
 #include "Function.h"
 #include "PrimType.h"
 #include "Program.h"
 #include "State.h"
 
 using namespace clang;
 using namespace clang::interp;
 
case CK_DerivedToBase: {
     assert(ToDecl);
     const Record *R = getRecord(FromDecl);
     const Record::Base *ToBase = R->getBase(ToDecl);
     assert(ToBase);
 
     return this->emitGetPtrBase(ToBase->Offset, CE);
   }
 
+  case CK_FloatingCast: {
+    if (!this->visit(SubExpr))
+      return false;
+    const auto *TargetSemantics =
+        &Ctx.getASTContext().getFloatTypeSemantics(CE->getType());
+    return this->emitCastFP(TargetSemantics, getRoundingMode(CE), CE);
+  }
+
+  case CK_IntegralToFloating: {
+    std::optional<PrimType> FromT = classify(SubExpr->getType());
+    if (!FromT)
+      return false;
+
+    if (!this->visit(SubExpr))
+      return false;
+
+    const auto *TargetSemantics =
+        &Ctx.getASTContext().getFloatTypeSemantics(CE->getType());
+    llvm::RoundingMode RM = getRoundingMode(CE);
+    return this->emitCastIntegralFloating(*FromT, TargetSemantics, RM, CE);
+  }
+
+  case CK_FloatingToBoolean:
+  case CK_FloatingToIntegral: {
+    std::optional<PrimType> ToT = classify(CE->getType());
+
+    if (!ToT)
+      return false;
+
+    if (!this->visit(SubExpr))
+      return false;
+
+    return this->emitCastFloatingIntegral(*ToT, CE);
+  }
+
   case CK_ArrayToPointerDecay:
   case CK_AtomicToNonAtomic:
   case CK_ConstructorConversion:
   case CK_FunctionToPointerDecay:
   case CK_NonAtomicToAtomic:
   case CK_NoOp:
   case CK_UserDefinedConversion:
   case CK_NullToPointer:

 bool ByteCodeExprGen<Emitter>::VisitIntegerLiteral(const IntegerLiteral *LE) {
   if (DiscardResult)
     return true;
 
   return this->emitConst(LE->getValue(), LE);
 }
 
 template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitFloatingLiteral(const FloatingLiteral *E) {
+  if (DiscardResult)
+    return true;
+
+  return this->emitConstFloat(E->getValue(), E);
+}
+
+template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitParenExpr(const ParenExpr *PE) {
   return this->visit(PE->getSubExpr());
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitBinaryOperator(const BinaryOperator *BO) {
   const Expr *LHS = BO->getLHS();
   const Expr *RHS = BO->getRHS();
case BO_LT:
     return Discard(this->emitLT(*LT, BO));
   case BO_LE:
     return Discard(this->emitLE(*LT, BO));
   case BO_GT:
     return Discard(this->emitGT(*LT, BO));
   case BO_GE:
     return Discard(this->emitGE(*LT, BO));
   case BO_Sub:
+    if (BO->getType()->isFloatingType())
+      return Discard(this->emitSubf(getRoundingMode(BO), BO));
     return Discard(this->emitSub(*T, BO));
   case BO_Add:
+    if (BO->getType()->isFloatingType())
+      return Discard(this->emitAddf(getRoundingMode(BO), BO));
     return Discard(this->emitAdd(*T, BO));
   case BO_Mul:
+    if (BO->getType()->isFloatingType())
+      return Discard(this->emitMulf(getRoundingMode(BO), BO));
     return Discard(this->emitMul(*T, BO));
   case BO_Rem:
     return Discard(this->emitRem(*T, BO));
   case BO_Div:
+    if (BO->getType()->isFloatingType())
+      return Discard(this->emitDivf(getRoundingMode(BO), BO));
     return Discard(this->emitDiv(*T, BO));
   case BO_Assign:
     if (DiscardResult)
       return this->emitStorePop(*T, BO);
     return this->emitStore(*T, BO);
   case BO_And:
     return Discard(this->emitBitAnd(*T, BO));
   case BO_Or:
bool ByteCodeExprGen<Emitter>::VisitCompoundAssignOperator(
   std::optional<PrimType> ResultT = classify(E->getType());
 
   if (!LT || !RT || !ResultT || !LHSComputationT)
     return false;
 
   assert(!E->getType()->isPointerType() &&
          "Support pointer arithmethic in compound assignment operators");
 
+  assert(!E->getType()->isFloatingType() &&
+         "Support floating types in compound assignment operators");
+
   // Get LHS pointer, load its value and get RHS value.
   if (!visit(LHS))
     return false;
   if (!this->emitLoad(*LT, E))
     return false;
   // If necessary, cast LHS to its computation type.
   if (*LT != *LHSComputationT) {
     if (!this->emitCast(*LT, *LHSComputationT, E))
       return false;
   }
 
   if (!visit(RHS))
     return false;
 
   // Perform operation.
   switch (E->getOpcode()) {
   case BO_AddAssign:
     if (!this->emitAdd(*LHSComputationT, E))
       return false;
     break;
   case BO_SubAssign:
     if (!this->emitSub(*LHSComputationT, E))
       return false;
     break;
   case BO_MulAssign:
     if (!this->emitMul(*LHSComputationT, E))
       return false;
     break;
   case BO_DivAssign:
     if (!this->emitDiv(*LHSComputationT, E))
bool ByteCodeExprGen<Emitter>::visitZeroInitializer(PrimType T, const Expr *E) {
   case PT_Uint32:
     return this->emitZeroUint32(E);
   case PT_Sint64:
     return this->emitZeroSint64(E);
   case PT_Uint64:
     return this->emitZeroUint64(E);
   case PT_Ptr:
     return this->emitNullPtr(E);
+  case PT_Float:
+    assert(false);
   }
   llvm_unreachable("unknown primitive type");
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::dereference(
     const Expr *LV, DerefKind AK, llvm::function_ref<bool(PrimType)> Direct,
     llvm::function_ref<bool(PrimType)> Indirect) {
case PT_Uint32:
     return this->emitConstUint32(Value, E);
   case PT_Sint64:
     return this->emitConstSint64(Value, E);
   case PT_Uint64:
     return this->emitConstUint64(Value, E);
   case PT_Bool:
     return this->emitConstBool(Value, E);
   case PT_Ptr:
+  case PT_Float:
     llvm_unreachable("Invalid integral type");
     break;
   }
   llvm_unreachable("unknown primitive type");
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::emitConst(const APSInt &Value, const Expr *E) {

clang/lib/AST/Interp/Context.cpp

if (T->isUnsignedIntegerOrEnumerationType()) {
     default:
       return {};
     }
   }
 
   if (T->isNullPtrType())
     return PT_Ptr;
 
+  if (T->isFloatingType())
+    return PT_Float;
+
   if (auto *AT = dyn_cast<AtomicType>(T))
     return classify(AT->getValueType());
 
   return {};
 }
 
 unsigned Context::getCharBit() const {
   return Ctx.getTargetInfo().getCharWidth();

clang/lib/AST/Interp/Descriptor.cpp

 //===--- Descriptor.cpp - Types for the constexpr VM ------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Descriptor.h"
 #include "Boolean.h"
+#include "Floating.h"
 #include "Pointer.h"
 #include "PrimType.h"
 #include "Record.h"
 
 using namespace clang;
 using namespace clang::interp;
 
 template <typename T>
for (const auto &F : D->ElemRecord->fields()) {
 
     *(reinterpret_cast<Descriptor **>(Dst + FieldOff) - 1) = FieldDesc;
     if (auto Fn = FieldDesc->MoveFn)
       Fn(B, Src + FieldOff, Dst + FieldOff, FieldDesc);
   }
 }
 
 static BlockCtorFn getCtorPrim(PrimType Type) {
+  // Floating types are special. They are primitives, but need their
+  // constructor called.
+  if (Type == PT_Float)
+    return ctorTy<PrimConv<PT_Float>::T>;
+
   COMPOSITE_TYPE_SWITCH(Type, return ctorTy<T>, return nullptr);
 }
 
 static BlockDtorFn getDtorPrim(PrimType Type) {
   COMPOSITE_TYPE_SWITCH(Type, return dtorTy<T>, return nullptr);
 }
 
 static BlockMoveFn getMovePrim(PrimType Type) {

clang/lib/AST/Interp/Disasm.cpp

 //===--- Disasm.cpp - Disassembler for bytecode functions -------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Dump method for Function which disassembles the bytecode.
 //
 //===----------------------------------------------------------------------===//
 
+#include "Floating.h"
 #include "Function.h"
 #include "Opcode.h"
 #include "PrimType.h"
 #include "Program.h"
 #include "clang/AST/DeclCXX.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Format.h"
 

clang/lib/AST/Interp/Floating.h

+//===--- Floating.h - Types for the constexpr VM ----------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Defines the VM types and helpers operating on types.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_INTERP_FLOATING_H
+#define LLVM_CLANG_AST_INTERP_FLOATING_H
+
+#include "Primitives.h"
+#include "clang/AST/APValue.h"
+#include "llvm/ADT/APFloat.h"
+
+namespace clang {
+namespace interp {
+
+using APFloat = llvm::APFloat;
+using APSInt = llvm::APSInt;
+
+class Floating final {
+private:
+  // The underlying value storage.
+  APFloat F;
+
+public:
+  /// Zero-initializes a Floating.
+  Floating() : F(0.0f) {}
+  Floating(const APFloat &F) : F(F) {}
+
+  // Static constructors for special floating point values.
+  static Floating getInf(const llvm::fltSemantics &Sem) {
+    return Floating(APFloat::getInf(Sem));
+  }
+  const APFloat &getAPFloat() const { return F; }
+
+  bool operator<(Floating RHS) const { return F < RHS.F; }
+  bool operator>(Floating RHS) const { return F > RHS.F; }
+  bool operator<=(Floating RHS) const { return F <= RHS.F; }
+  bool operator>=(Floating RHS) const { return F >= RHS.F; }
+  bool operator==(Floating RHS) const { return F == RHS.F; }
+  bool operator!=(Floating RHS) const { return F != RHS.F; }
+  Floating operator-() const { return Floating(-F); }
+
+  APFloat::opStatus convertToInteger(APSInt &Result) const {
+    bool IsExact;
+    return F.convertToInteger(Result, llvm::APFloat::rmTowardZero, &IsExact);
+  }
+
+  Floating toSemantics(const llvm::fltSemantics *Sem,
+                       llvm::RoundingMode RM) const {
+    APFloat Copy = F;
+    bool LosesInfo;
+    Copy.convert(*Sem, RM, &LosesInfo);
+    (void)LosesInfo;
+    return Floating(Copy);
+  }
+
+  /// Convert this Floating to one with the same semantics as \Other.
+  Floating toSemantics(const Floating &Other, llvm::RoundingMode RM) const {
+    return toSemantics(&Other.F.getSemantics(), RM);
+  }
+
+  APSInt toAPSInt(unsigned NumBits = 0) const {
+    return APSInt(F.bitcastToAPInt());
+  }
+  APValue toAPValue() const { return APValue(F); }
+  void print(llvm::raw_ostream &OS) const {
+    // Can't use APFloat::print() since it appends a newline.
+    SmallVector<char, 16> Buffer;
+    F.toString(Buffer);
+    OS << Buffer;
+  }
+
+  unsigned bitWidth() const { return F.semanticsSizeInBits(F.getSemantics()); }
+
+  bool isSigned() const { return true; }
+  bool isNegative() const { return F.isNegative(); }
+  bool isPositive() const { return !F.isNegative(); }
+  bool isZero() const { return F.isZero(); }
+  bool isNonZero() const { return F.isNonZero(); }
+  bool isMin() const { return F.isSmallest(); }
+  bool isMinusOne() const { return F.isExactlyValue(-1.0); }
+  bool isNan() const { return F.isNaN(); }
+  bool isFinite() const { return F.isFinite(); }
+
+  ComparisonCategoryResult compare(const Floating &RHS) const {
+    return Compare(F, RHS.F);
+  }
+
+  static APFloat::opStatus fromIntegral(APSInt Val,
+                                        const llvm::fltSemantics &Sem,
+                                        llvm::RoundingMode RM,
+                                        Floating &Result) {
+    APFloat F = APFloat(Sem);
+    APFloat::opStatus Status = F.convertFromAPInt(Val, Val.isSigned(), RM);
+    Result = Floating(F);
+    return Status;
+  }
+
+  // -------
+
+  static APFloat::opStatus add(Floating A, Floating B, llvm::RoundingMode RM,
+                               Floating *R) {
+    *R = Floating(A.F);
+    return R->F.add(B.F, RM);
+  }
+
+  static APFloat::opStatus sub(Floating A, Floating B, llvm::RoundingMode RM,
+                               Floating *R) {
+    *R = Floating(A.F);
+    return R->F.subtract(B.F, RM);
+  }
+
+  static APFloat::opStatus mul(Floating A, Floating B, llvm::RoundingMode RM,
+                               Floating *R) {
+    *R = Floating(A.F);
+    return R->F.multiply(B.F, RM);
+  }
+
+  static APFloat::opStatus div(Floating A, Floating B, llvm::RoundingMode RM,
+                               Floating *R) {
+    *R = Floating(A.F);
+    return R->F.divide(B.F, RM);
+  }
+
+  static bool neg(Floating A, Floating *R) {
+    *R = -A;
+    return false;
+  }
+};
+
+llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, Floating F);
+Floating getSwappedBytes(Floating F);
+
+} // namespace interp
+} // namespace clang
+
+#endif

clang/lib/AST/Interp/Floating.cpp

-//===--- PrimType.cpp - Types for the constexpr VM --------------*- C++ -*-===//
+//===---- Floating.cpp - Support for floating point values ------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "PrimType.h"
-#include "Boolean.h"
-#include "Pointer.h"
-
-using namespace clang;
-using namespace clang::interp;
+#include "Floating.h"
 
 namespace clang {
 namespace interp {
 
-size_t primSize(PrimType Type) {
-  TYPE_SWITCH(Type, return sizeof(T));
-  llvm_unreachable("not a primitive type");
+llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, Floating F) {
+  F.print(OS);
+  return OS;
 }
 
+Floating getSwappedBytes(Floating F) { return F; }
+
 } // namespace interp
 } // namespace clang

clang/lib/AST/Interp/Integral.h

 #include "clang/AST/ComparisonCategories.h"
 #include "clang/AST/APValue.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstddef>
 #include <cstdint>
 
+#include "Primitives.h"
+
 namespace clang {
 namespace interp {
 
 using APInt = llvm::APInt;
 using APSInt = llvm::APSInt;
 
-/// Helper to compare two comparable types.
-template <typename T>
-ComparisonCategoryResult Compare(const T &X, const T &Y) {
-  if (X < Y)
-    return ComparisonCategoryResult::Less;
-  if (X > Y)
-    return ComparisonCategoryResult::Greater;
-  return ComparisonCategoryResult::Equal;
-}
-
+/// Wrapper around numeric types.
+///
+/// These wrappers are required to shared an interface between APSint and
+/// builtin primitive numeral types, while optimising for storage and
+/// allowing methods operating on primitive type to compile to fast code.
+template <unsigned Bits, bool Signed> class Integral final {
+private:
+  template <unsigned OtherBits, bool OtherSigned> friend class Integral;
   // Helper structure to select the representation.
-template <unsigned Bits, bool Signed> struct Repr;
+  template <unsigned ReprBits, bool ReprSigned> struct Repr;
   template <> struct Repr<8, false> { using Type = uint8_t; };
   template <> struct Repr<16, false> { using Type = uint16_t; };
   template <> struct Repr<32, false> { using Type = uint32_t; };
   template <> struct Repr<64, false> { using Type = uint64_t; };
   template <> struct Repr<8, true> { using Type = int8_t; };
   template <> struct Repr<16, true> { using Type = int16_t; };
   template <> struct Repr<32, true> { using Type = int32_t; };
   template <> struct Repr<64, true> { using Type = int64_t; };
 
-/// Wrapper around numeric types.
-///
-/// These wrappers are required to shared an interface between APSint and
-/// builtin primitive numeral types, while optimising for storage and
-/// allowing methods operating on primitive type to compile to fast code.
-template <unsigned Bits, bool Signed> class Integral final {
-private:
-  template <unsigned OtherBits, bool OtherSigned> friend class Integral;
-
   // The primitive representing the integral.
   using ReprT = typename Repr<Bits, Signed>::Type;
   ReprT V;
 
   /// Primitive representing limits.
   static const auto Min = std::numeric_limits<ReprT>::min();
   static const auto Max = std::numeric_limits<ReprT>::max();
 

clang/lib/AST/Interp/Interp.h

 //===--- Interp.h - Interpreter for the constexpr VM ------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Definition of the interpreter state and entry point.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_AST_INTERP_INTERP_H
 #define LLVM_CLANG_AST_INTERP_INTERP_H
 
 #include "Boolean.h"
+#include "Floating.h"
 #include "Function.h"
 #include "InterpFrame.h"
 #include "InterpStack.h"
 #include "InterpState.h"
 #include "Opcode.h"
 #include "PrimType.h"
 #include "Program.h"
 #include "State.h"
if (LHS.isSigned() && LHS.isMin() && RHS.isNegative() && RHS.isMinusOne()) {
     const SourceInfo &Loc = S.Current->getSource(OpPC);
     const Expr *E = S.Current->getExpr(OpPC);
     S.CCEDiag(Loc, diag::note_constexpr_overflow) << Trunc << E->getType();
     return false;
   }
   return true;
 }
 
+/// Checks if the result is a floating-point operation is valid
+/// in the current context.
+bool CheckFloatResult(InterpState &S, CodePtr OpPC, APFloat::opStatus Status);
+
 /// Interpreter entry point.
 bool Interpret(InterpState &S, APValue &Result);
 
 bool InterpretBuiltin(InterpState &S, CodePtr PC, unsigned BuiltinID);
 
 enum class ArithOp { Add, Sub };
 
 //===----------------------------------------------------------------------===//

 template <PrimType Name, class T = typename PrimConv<Name>::T>
 bool Add(InterpState &S, CodePtr OpPC) {
   const T &RHS = S.Stk.pop<T>();
   const T &LHS = S.Stk.pop<T>();
   const unsigned Bits = RHS.bitWidth() + 1;
   return AddSubMulHelper<T, T::add, std::plus>(S, OpPC, Bits, LHS, RHS);
 }
 
+inline bool Addf(InterpState &S, CodePtr OpPC, llvm::RoundingMode RM) {
+  const Floating &RHS = S.Stk.pop<Floating>();
+  const Floating &LHS = S.Stk.pop<Floating>();
+
+  Floating Result;
+  auto Status = Floating::add(LHS, RHS, RM, &Result);
+  S.Stk.push<Floating>(Result);
+  return CheckFloatResult(S, OpPC, Status);
+}
+
 template <PrimType Name, class T = typename PrimConv<Name>::T>
 bool Sub(InterpState &S, CodePtr OpPC) {
   const T &RHS = S.Stk.pop<T>();
   const T &LHS = S.Stk.pop<T>();
   const unsigned Bits = RHS.bitWidth() + 1;
   return AddSubMulHelper<T, T::sub, std::minus>(S, OpPC, Bits, LHS, RHS);
 }
 
+inline bool Subf(InterpState &S, CodePtr OpPC, llvm::RoundingMode RM) {
+  const Floating &RHS = S.Stk.pop<Floating>();
+  const Floating &LHS = S.Stk.pop<Floating>();
+
+  Floating Result;
+  auto Status = Floating::sub(LHS, RHS, RM, &Result);
+  S.Stk.push<Floating>(Result);
+  return CheckFloatResult(S, OpPC, Status);
+}
+
 template <PrimType Name, class T = typename PrimConv<Name>::T>
 bool Mul(InterpState &S, CodePtr OpPC) {
   const T &RHS = S.Stk.pop<T>();
   const T &LHS = S.Stk.pop<T>();
   const unsigned Bits = RHS.bitWidth() * 2;
   return AddSubMulHelper<T, T::mul, std::multiplies>(S, OpPC, Bits, LHS, RHS);
 }
 
+inline bool Mulf(InterpState &S, CodePtr OpPC, llvm::RoundingMode RM) {
+  const Floating &RHS = S.Stk.pop<Floating>();
+  const Floating &LHS = S.Stk.pop<Floating>();
+
+  Floating Result;
+  auto Status = Floating::mul(LHS, RHS, RM, &Result);
+  S.Stk.push<Floating>(Result);
+  return CheckFloatResult(S, OpPC, Status);
+}
 /// 1) Pops the RHS from the stack.
 /// 2) Pops the LHS from the stack.
 /// 3) Pushes 'LHS & RHS' on the stack
 template <PrimType Name, class T = typename PrimConv<Name>::T>
 bool BitAnd(InterpState &S, CodePtr OpPC) {
   const T &RHS = S.Stk.pop<T>();
   const T &LHS = S.Stk.pop<T>();
 
bool Div(InterpState &S, CodePtr OpPC) {
   T Result;
   if (!T::div(LHS, RHS, Bits, &Result)) {
     S.Stk.push<T>(Result);
     return true;
   }
   return false;
 }
 
+inline bool Divf(InterpState &S, CodePtr OpPC, llvm::RoundingMode RM) {
+  const Floating &RHS = S.Stk.pop<Floating>();
+  const Floating &LHS = S.Stk.pop<Floating>();
+
+  if (!CheckDivRem(S, OpPC, LHS, RHS))
+    return false;
+
+  Floating Result;
+  auto Status = Floating::div(LHS, RHS, RM, &Result);
+  S.Stk.push<Floating>(Result);
+  return CheckFloatResult(S, OpPC, Status);
+}
+
 //===----------------------------------------------------------------------===//
 // Inv
 //===----------------------------------------------------------------------===//
 
 template <PrimType Name, class T = typename PrimConv<Name>::T>
 bool Inv(InterpState &S, CodePtr OpPC) {
   using BoolT = PrimConv<PT_Bool>::T;
   const T &Val = S.Stk.pop<T>();

 
 template <PrimType TIn, PrimType TOut> bool Cast(InterpState &S, CodePtr OpPC) {
   using T = typename PrimConv<TIn>::T;
   using U = typename PrimConv<TOut>::T;
   S.Stk.push<U>(U::from(S.Stk.pop<T>()));
   return true;
 }
 
+/// 1) Pops a Floating from the stack.
+/// 2) Pushes a new floating on the stack that uses the given semantics.
+/// Not templated, so implemented in Interp.cpp.
+bool CastFP(InterpState &S, CodePtr OpPC, const llvm::fltSemantics *Sem,
+            llvm::RoundingMode RM);
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool CastIntegralFloating(InterpState &S, CodePtr OpPC,
+                          const llvm::fltSemantics *Sem,
+                          llvm::RoundingMode RM) {
+  const T &From = S.Stk.pop<T>();
+  APSInt FromAP = From.toAPSInt();
+  Floating Result;
+
+  auto Status = Floating::fromIntegral(FromAP, *Sem, RM, Result);
+  S.Stk.push<Floating>(Result);
+
+  return CheckFloatResult(S, OpPC, Status);
+}
+
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool CastFloatingIntegral(InterpState &S, CodePtr OpPC) {
+  const Floating &F = S.Stk.pop<Floating>();
+
+  if constexpr (std::is_same_v<T, Boolean>) {
+    S.Stk.push<T>(T(F.isNonZero()));
+    return true;
+  } else {
+    APSInt Result(std::max(8u, T::bitWidth() + 1),
+                  /*IsUnsigned=*/!T::isSigned());
+    auto Status = F.convertToInteger(Result);
+
+    // Float-to-Integral overflow check.
+    if ((Status & APFloat::opStatus::opInvalidOp) && F.isFinite()) {
+      const Expr *E = S.Current->getExpr(OpPC);
+      QualType Type = E->getType();
+
+      S.CCEDiag(E, diag::note_constexpr_overflow) << F.getAPFloat() << Type;
+      return S.noteUndefinedBehavior();
+    }
+
+    S.Stk.push<T>(T(Result));
+    return CheckFloatResult(S, OpPC, Status);
+  }
+}
+
 //===----------------------------------------------------------------------===//
 // Zero, Nullptr
 //===----------------------------------------------------------------------===//
 
 template <PrimType Name, class T = typename PrimConv<Name>::T>
 bool Zero(InterpState &S, CodePtr OpPC) {
   S.Stk.push<T>(T::zero());
   return true;

clang/lib/AST/Interp/Interp.cpp

bool CheckPure(InterpState &S, CodePtr OpPC, const CXXMethodDecl *MD) {
   if (!MD->isPure())
     return true;
   const SourceInfo &E = S.Current->getSource(OpPC);
   S.FFDiag(E, diag::note_constexpr_pure_virtual_call, 1) << MD;
   S.Note(MD->getLocation(), diag::note_declared_at);
   return false;
 }
 
 static void DiagnoseUninitializedSubobject(InterpState &S, const SourceInfo &SI,
                                            QualType SubObjType,
                                            SourceLocation SubObjLoc) {
   S.FFDiag(SI, diag::note_constexpr_uninitialized) << true << SubObjType;
   if (SubObjLoc.isValid())
     S.Note(SubObjLoc, diag::note_constexpr_subobject_declared_here);
 }
 
 static bool CheckFieldsInitialized(InterpState &S, CodePtr OpPC,

 }
 
 bool CheckCtorCall(InterpState &S, CodePtr OpPC, const Pointer &This) {
   assert(!This.isZero());
   const Record *R = This.getRecord();
   return CheckFieldsInitialized(S, OpPC, This, R);
 }
 
+bool CheckFloatResult(InterpState &S, CodePtr OpPC, APFloat::opStatus Status) {
+  // In a constant context, assume that any dynamic rounding mode or FP
+  // exception state matches the default floating-point environment.
+  if (S.inConstantContext())
+    return true;
+
+  const SourceInfo &E = S.Current->getSource(OpPC);
+  FPOptions FPO = E.asExpr()->getFPFeaturesInEffect(S.Ctx.getLangOpts());
+
+  if ((Status & APFloat::opInexact) &&
+      FPO.getRoundingMode() == llvm::RoundingMode::Dynamic) {
+    // Inexact result means that it depends on rounding mode. If the requested
+    // mode is dynamic, the evaluation cannot be made in compile time.
+    S.FFDiag(E, diag::note_constexpr_dynamic_rounding);
+    return false;
+  }
+
+  if ((Status != APFloat::opOK) &&
+      (FPO.getRoundingMode() == llvm::RoundingMode::Dynamic ||
+       FPO.getExceptionMode() != LangOptions::FPE_Ignore ||
+       FPO.getAllowFEnvAccess())) {
+    S.FFDiag(E, diag::note_constexpr_float_arithmetic_strict);
+    return false;
+  }
+
+  if ((Status & APFloat::opStatus::opInvalidOp) &&
+      FPO.getExceptionMode() != LangOptions::FPE_Ignore) {
+    // There is no usefully definable result.
+    S.FFDiag(E);
+    return false;
+  }
+
+  return true;
+}
+
+bool CastFP(InterpState &S, CodePtr OpPC, const llvm::fltSemantics *Sem,
+            llvm::RoundingMode RM) {
+  Floating F = S.Stk.pop<Floating>();
+  Floating Result = F.toSemantics(Sem, RM);
+  S.Stk.push<Floating>(Result);
+  return true;
+}
+
 bool Interpret(InterpState &S, APValue &Result) {
   // The current stack frame when we started Interpret().
   // This is being used by the ops to determine wheter
   // to return from this function and thus terminate
   // interpretation.
   const InterpFrame *StartFrame = S.Current;
   assert(!S.Current->isRoot());
   CodePtr PC = S.Current->getPC();

clang/lib/AST/Interp/InterpFrame.cpp

 //===--- InterpFrame.cpp - Call Frame implementation for the VM -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "InterpFrame.h"
 #include "Boolean.h"
+#include "Floating.h"
 #include "Function.h"
 #include "InterpStack.h"
 #include "InterpState.h"
 #include "Pointer.h"
 #include "PrimType.h"
 #include "Program.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclCXX.h"

clang/lib/AST/Interp/InterpStack.h

else if constexpr (std::is_same_v<T, uint32_t> ||
                        std::is_same_v<T, Integral<32, false>>)
       return PT_Uint32;
     else if constexpr (std::is_same_v<T, int64_t> ||
                        std::is_same_v<T, Integral<64, true>>)
       return PT_Sint64;
     else if constexpr (std::is_same_v<T, uint64_t> ||
                        std::is_same_v<T, Integral<64, false>>)
       return PT_Uint64;
+    else if constexpr (std::is_same_v<T, Floating>)
+      return PT_Float;
 
     llvm_unreachable("unknown type push()'ed into InterpStack");
   }
 #endif
 };
 
 } // namespace interp
 } // namespace clang
 
 #endif

clang/lib/AST/Interp/Opcodes.td

 def Sint8 : Type;
 def Uint8 : Type;
 def Sint16 : Type;
 def Uint16 : Type;
 def Sint32 : Type;
 def Uint32 : Type;
 def Sint64 : Type;
 def Uint64 : Type;
+def Float : Type;
 def Ptr : Type;
 
 //===----------------------------------------------------------------------===//
 // Types transferred to the interpreter.
 //===----------------------------------------------------------------------===//
 
 class ArgType { string Name = ?; }
 def ArgSint8 : ArgType { let Name = "int8_t"; }
 def ArgUint8 : ArgType { let Name = "uint8_t"; }
 def ArgSint16 : ArgType { let Name = "int16_t"; }
 def ArgUint16 : ArgType { let Name = "uint16_t"; }
 def ArgSint32 : ArgType { let Name = "int32_t"; }
 def ArgUint32 : ArgType { let Name = "uint32_t"; }
 def ArgSint64 : ArgType { let Name = "int64_t"; }
 def ArgUint64 : ArgType { let Name = "uint64_t"; }
+def ArgFloat : ArgType { let Name = "Floating"; }
 def ArgBool : ArgType { let Name = "bool"; }
 
 def ArgFunction : ArgType { let Name = "const Function *"; }
 def ArgRecordDecl : ArgType { let Name = "const RecordDecl *"; }
 def ArgRecordField : ArgType { let Name = "const Record::Field *"; }
+def ArgFltSemantics : ArgType { let Name = "const llvm::fltSemantics *"; }
+def ArgRoundingMode : ArgType { let Name = "llvm::RoundingMode"; }
 
 //===----------------------------------------------------------------------===//
 // Classes of types instructions operate on.
 //===----------------------------------------------------------------------===//
 
 class TypeClass {
   list<Type> Types;
 }
 
-def NumberTypeClass : TypeClass {
+def IntegerTypeClass : TypeClass {
   let Types = [Sint8, Uint8, Sint16, Uint16, Sint32,
                Uint32, Sint64, Uint64];
 }
 
-def IntegerTypeClass : TypeClass {
-  let Types = [Sint8, Uint8, Sint16, Uint16, Sint32,
-               Uint32, Sint64, Uint64];
+def NumberTypeClass : TypeClass {
+  let Types = !listconcat(IntegerTypeClass.Types, [Float]);
+}
+
+def FloatTypeClass : TypeClass {
+  let Types = [Float];
 }
 
 def AluTypeClass : TypeClass {
-  let Types = !listconcat(NumberTypeClass.Types, [Bool]);
+  let Types = !listconcat(IntegerTypeClass.Types, [Bool]);
 }
 
 def PtrTypeClass : TypeClass {
   let Types = [Ptr];
 }
 
 def BoolTypeClass : TypeClass {
   let Types = [Bool];
 }
 
+def NonPtrTypeClass : TypeClass {
+  let Types = !listconcat(IntegerTypeClass.Types, [Bool], [Float]);
+}
+
 def AllTypeClass : TypeClass {
-  let Types = !listconcat(AluTypeClass.Types, PtrTypeClass.Types);
+  let Types = !listconcat(AluTypeClass.Types, PtrTypeClass.Types, FloatTypeClass.Types);
 }
 
 def ComparableTypeClass : TypeClass {
-  let Types = !listconcat(AluTypeClass.Types, [Ptr]);
+  let Types = !listconcat(AluTypeClass.Types, [Ptr], [Float]);
 }
 
 class SingletonTypeClass<Type Ty> : TypeClass {
   let Types = [Ty];
 }
 
 //===----------------------------------------------------------------------===//
 // Record describing all opcodes.
class Opcode {
   bit HasGroup = 0;
 }
 
 class AluOpcode : Opcode {
   let Types = [AluTypeClass];
   let HasGroup = 1;
 }
 
+class FloatOpcode : Opcode {
+  let Types = [];
+  let Args = [ArgRoundingMode];
+}
+
 class IntegerOpcode : Opcode {
   let Types = [IntegerTypeClass];
   let HasGroup = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // Jump opcodes
 //===----------------------------------------------------------------------===//

 def ConstSint8 : ConstOpcode<Sint8, ArgSint8>;
 def ConstUint8 : ConstOpcode<Uint8, ArgUint8>;
 def ConstSint16 : ConstOpcode<Sint16, ArgSint16>;
 def ConstUint16 : ConstOpcode<Uint16, ArgUint16>;
 def ConstSint32 : ConstOpcode<Sint32, ArgSint32>;
 def ConstUint32 : ConstOpcode<Uint32, ArgUint32>;
 def ConstSint64 : ConstOpcode<Sint64, ArgSint64>;
 def ConstUint64 : ConstOpcode<Uint64, ArgUint64>;
+def ConstFloat : ConstOpcode<Float, ArgFloat>;
 def ConstBool : ConstOpcode<Bool, ArgBool>;
 
 // [] -> [Integer]
 def Zero : Opcode {
   let Types = [AluTypeClass];
   let HasGroup = 1;
 }
 
def DecPtr : Opcode {
   let HasGroup = 0;
 }
 
 //===----------------------------------------------------------------------===//
 // Binary operators.
 //===----------------------------------------------------------------------===//
 
 // [Real, Real] -> [Real]
-def Sub : AluOpcode;
-def Add : AluOpcode;
-def Mul : AluOpcode;
-def Rem : Opcode {
-  let Types = [NumberTypeClass];
-  let HasGroup = 1;
-}
+def Add  : AluOpcode;
+def Addf : FloatOpcode;
+def Sub  : AluOpcode;
+def Subf : FloatOpcode;
+def Mul  : AluOpcode;
+def Mulf : FloatOpcode;
+def Rem  : IntegerOpcode;
+def Div  : IntegerOpcode;
+def Divf : FloatOpcode;
+
+def BitAnd : IntegerOpcode;
+def BitOr : IntegerOpcode;
+def BitXor : IntegerOpcode;
 
 def Shl : Opcode {
   let Types = [IntegerTypeClass, IntegerTypeClass];
   let HasGroup = 1;
 }
 
 def Shr : Opcode {
   let Types = [IntegerTypeClass, IntegerTypeClass];
   let HasGroup = 1;
 }
 
-def BitAnd : IntegerOpcode;
-def BitOr : IntegerOpcode;
-def Div : Opcode {
-  let Types = [NumberTypeClass];
-  let HasGroup = 1;
-}
-def BitXor : IntegerOpcode;
-
 //===----------------------------------------------------------------------===//
 // Unary operators.
 //===----------------------------------------------------------------------===//
 
 // [Real] -> [Real]
 def Inv: Opcode {
   let Types = [BoolTypeClass];
   let HasGroup = 1;
 }
 
 def Inc: IntegerOpcode;
 def IncPop : IntegerOpcode;
 def Dec: IntegerOpcode;
 def DecPop: IntegerOpcode;
 
 // [Real] -> [Real]
 def Neg: Opcode {
-  let Types = [AluTypeClass];
+  let Types = [NonPtrTypeClass];
   let HasGroup = 1;
 }
 
 // [Real] -> [Real]
 def Comp: Opcode {
-  let Types = [NumberTypeClass];
+  let Types = [IntegerTypeClass];
   let HasGroup = 1;
 }
 
 //===----------------------------------------------------------------------===//
-// Cast.
+// Cast, CastFP.
 //===----------------------------------------------------------------------===//
-// TODO: Expand this to handle casts between more types.
 
 def FromCastTypeClass : TypeClass {
   let Types = [Uint8, Sint8, Uint16, Sint16, Uint32, Sint32, Uint64, Sint64, Bool];
 }
 
 def ToCastTypeClass : TypeClass {
   let Types = [Uint8, Sint8, Uint16, Sint16, Uint32, Sint32, Uint64, Sint64, Bool];
 }
 
 def Cast: Opcode {
   let Types = [FromCastTypeClass, ToCastTypeClass];
   let HasGroup = 1;
 }
 
+def CastFP : Opcode {
+  let Types = [];
+  let Args = [ArgFltSemantics, ArgRoundingMode];
+}
+
+// Cast an integer to a floating type
+def CastIntegralFloating : Opcode {
+  let Types = [AluTypeClass];
+  let Args = [ArgFltSemantics, ArgRoundingMode];
+  let HasGroup = 1;
+}
+
+// Cast a floating to an integer type
+def CastFloatingIntegral : Opcode {
+  let Types = [AluTypeClass];
+  let Args = [];
+  let HasGroup = 1;
+}
+
 //===----------------------------------------------------------------------===//
 // Comparison opcodes.
 //===----------------------------------------------------------------------===//
 
 class EqualityOpcode : Opcode {
   let Types = [AllTypeClass];
   let HasGroup = 1;
 }

clang/lib/AST/Interp/PrimType.h

 #include <cstddef>
 #include <cstdint>
 
 namespace clang {
 namespace interp {
 
 class Pointer;
 class Boolean;
+class Floating;
 
 /// Enumeration of the primitive types of the VM.
 enum PrimType : unsigned {
   PT_Sint8,
   PT_Uint8,
   PT_Sint16,
   PT_Uint16,
   PT_Sint32,
   PT_Uint32,
   PT_Sint64,
   PT_Uint64,
   PT_Bool,
+  PT_Float,
   PT_Ptr,
 };
 
 /// Mapping from primitive types to their representation.
 template <PrimType T> struct PrimConv;
 template <> struct PrimConv<PT_Sint8> { using T = Integral<8, true>; };
 template <> struct PrimConv<PT_Uint8> { using T = Integral<8, false>; };
 template <> struct PrimConv<PT_Sint16> { using T = Integral<16, true>; };
 template <> struct PrimConv<PT_Uint16> { using T = Integral<16, false>; };
 template <> struct PrimConv<PT_Sint32> { using T = Integral<32, true>; };
 template <> struct PrimConv<PT_Uint32> { using T = Integral<32, false>; };
 template <> struct PrimConv<PT_Sint64> { using T = Integral<64, true>; };
 template <> struct PrimConv<PT_Uint64> { using T = Integral<64, false>; };
+template <> struct PrimConv<PT_Float> { using T = Floating; };
 template <> struct PrimConv<PT_Bool> { using T = Boolean; };
 template <> struct PrimConv<PT_Ptr> { using T = Pointer; };
 
 /// Returns the size of a primitive type in bytes.
 size_t primSize(PrimType Type);
 
 /// Aligns a size to the pointer alignment.
 constexpr size_t align(size_t Size) {
inline bool isPrimitiveIntegral(PrimType Type) {
   case PT_Sint8:
   case PT_Uint8:
   case PT_Sint16:
   case PT_Uint16:
   case PT_Sint32:
   case PT_Uint32:
   case PT_Sint64:
   case PT_Uint64:
+  case PT_Float:
     return true;
   default:
     return false;
   }
 }
 
 } // namespace interp
 } // namespace clang
 
 /// Helper macro to simplify type switches.
 /// The macro implicitly exposes a type T in the scope of the inner block.
 #define TYPE_SWITCH_CASE(Name, B) \
   case Name: { using T = PrimConv<Name>::T; B; break; }
 #define TYPE_SWITCH(Expr, B)                                                   \
   do {                                                                         \
     switch (Expr) {                                                            \
       TYPE_SWITCH_CASE(PT_Sint8, B)                                            \
       TYPE_SWITCH_CASE(PT_Uint8, B)                                            \
       TYPE_SWITCH_CASE(PT_Sint16, B)                                           \
       TYPE_SWITCH_CASE(PT_Uint16, B)                                           \
       TYPE_SWITCH_CASE(PT_Sint32, B)                                           \
       TYPE_SWITCH_CASE(PT_Uint32, B)                                           \
       TYPE_SWITCH_CASE(PT_Sint64, B)                                           \
       TYPE_SWITCH_CASE(PT_Uint64, B)                                           \
+      TYPE_SWITCH_CASE(PT_Float, B)                                            \
       TYPE_SWITCH_CASE(PT_Bool, B)                                             \
       TYPE_SWITCH_CASE(PT_Ptr, B)                                              \
     }                                                                          \
   } while (0)
 #define COMPOSITE_TYPE_SWITCH(Expr, B, D)                                      \
   do {                                                                         \
     switch (Expr) {                                                            \
       TYPE_SWITCH_CASE(PT_Ptr, B)                                              \
       default: { D; break; }                                                   \
     }                                                                          \
   } while (0)
 #endif

clang/lib/AST/Interp/PrimType.cpp

 //===--- PrimType.cpp - Types for the constexpr VM --------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "PrimType.h"
 #include "Boolean.h"
+#include "Floating.h"
 #include "Pointer.h"
 
 using namespace clang;
 using namespace clang::interp;
 
 namespace clang {
 namespace interp {
 
 size_t primSize(PrimType Type) {
   TYPE_SWITCH(Type, return sizeof(T));
   llvm_unreachable("not a primitive type");
 }
 
 } // namespace interp
 } // namespace clang

clang/lib/AST/Interp/Primitives.h

+//===------ Primitives.h - Types for the constexpr VM -----------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Utilities and helper functions for all primitive types:
+//  - Integral
+//  - Floating
+//  - Boolean
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_INTERP_PRIMITIVES_H
+#define LLVM_CLANG_AST_INTERP_PRIMITIVES_H
+
+#include "clang/AST/ComparisonCategories.h"
+
+namespace clang {
+namespace interp {
+
+/// Helper to compare two comparable types.
+template <typename T> ComparisonCategoryResult Compare(const T &X, const T &Y) {
+  if (X < Y)
+    return ComparisonCategoryResult::Less;
+  if (X > Y)
+    return ComparisonCategoryResult::Greater;
+  return ComparisonCategoryResult::Equal;
+}
+
+} // namespace interp
+} // namespace clang
+
+#endif

clang/test/AST/Interp/const-fpfeatures.cpp

+// RUN: %clang_cc1 -S -emit-llvm -triple i386-linux -std=c++2a -Wno-unknown-pragmas %s -o - | FileCheck %s
+// RUN: %clang_cc1 -S -emit-llvm -triple i386-linux -fexperimental-new-constant-interpreter -std=c++2a -Wno-unknown-pragmas %s -o - | FileCheck %s
+
+
+#pragma STDC FENV_ROUND FE_UPWARD
+
+float F1u = 1.0F + 0x0.000002p0F;
+float F2u = 1.0F + 0x0.000001p0F;
+float F3u = 0x1.000001p0;
+// CHECK: @F1u = {{.*}} float 0x3FF0000020000000
+// CHECK: @F2u = {{.*}} float 0x3FF0000020000000
+// CHECK: @F3u = {{.*}} float 0x3FF0000020000000
+
+float FI1u = 0xFFFFFFFFU;
+// CHECK: @FI1u = {{.*}} float 0x41F0000000000000
+
+#pragma STDC FENV_ROUND FE_DOWNWARD
+
+float F1d = 1.0F + 0x0.000002p0F;
+float F2d = 1.0F + 0x0.000001p0F;
+float F3d = 0x1.000001p0;
+
+// CHECK: @F1d = {{.*}} float 0x3FF0000020000000
+// CHECK: @F2d = {{.*}} float 1.000000e+00
+// CHECK: @F3d = {{.*}} float 1.000000e+00
+
+
+float FI1d = 0xFFFFFFFFU;
+// CHECK: @FI1d = {{.*}} float 0x41EFFFFFE0000000
+
+// nextUp(1.F) == 0x1.000002p0F
+
+constexpr float add_round_down(float x, float y) {
+  #pragma STDC FENV_ROUND FE_DOWNWARD
+  float res = x;
+  res = res + y;
+  return res;
+}
+
+constexpr float add_round_up(float x, float y) {
+  #pragma STDC FENV_ROUND FE_UPWARD
+  float res = x;
+  res = res + y;
+  return res;
+}
+
+float V1 = add_round_down(1.0F, 0x0.000001p0F);
+float V2 = add_round_up(1.0F, 0x0.000001p0F);
+// CHECK: @V1 = {{.*}} float 1.000000e+00
+// CHECK: @V2 = {{.*}} float 0x3FF0000020000000
+
+
+/// FIXME: The following tests need support for compound assign operators
+///   with LHS and RHS of different semantics.
+#if 0
+constexpr float add_cast_round_down(float x, double y) {
+  #pragma STDC FENV_ROUND FE_DOWNWARD
+  float res = x;
+  res += y;
+  return res;
+}
+
+constexpr float add_cast_round_up(float x, double y) {
+  #pragma STDC FENV_ROUND FE_UPWARD
+  float res = x;
+  res += y;
+  return res;
+}
+
+float V3 = add_cast_round_down(1.0F, 0x0.000001p0F);
+float V4 = add_cast_round_up(1.0F, 0x0.000001p0F);
+
+
+#endif

clang/test/AST/Interp/floats.cpp

+// RUN: %clang_cc1 -fexperimental-new-constant-interpreter -verify %s
+// RUN: %clang_cc1 -verify=ref %s
+
+constexpr int i = 2;
+constexpr float f = 1.0f;
+static_assert(f == 1.0f, "");
+
+constexpr float f2 = 1u * f;
+static_assert(f2 == 1.0f, "");
+
+constexpr float f3 = 1.5;
+constexpr int i3 = f3;
+static_assert(i3 == 1);
+
+constexpr bool b3 = f3;
+static_assert(b3);
+
+
+static_assert(1.0f + 3u == 4, "");
+static_assert(4.0f / 1.0f == 4, "");
+static_assert(10.0f * false == 0, "");
+
+constexpr float floats[] = {1.0f, 2.0f, 3.0f, 4.0f};
+
+constexpr float m = 5.0f / 0.0f; // ref-error {{must be initialized by a constant expression}} \
+                                 // ref-note {{division by zero}} \
+                                 // expected-error {{must be initialized by a constant expression}} \
+                                 // expected-note {{division by zero}}
+
+static_assert(~2.0f == 3, ""); // ref-error {{invalid argument type 'float' to unary expression}} \
+                               // expected-error {{invalid argument type 'float' to unary expression}}
+
+/// Initialized by a double.
+constexpr float df = 0.0;
+/// The other way around.
+constexpr double fd = 0.0f;
+
+static_assert(0.0f == -0.0f, "");
+
+const int k = 3 * (1.0f / 3.0f);
+static_assert(k == 1, "");
+
+constexpr bool b = 1.0;
+static_assert(b, "");
+
+constexpr double db = true;
+static_assert(db == 1.0, "");
+
+constexpr float fa[] = {1.0f, 2.0, 1, false};
+constexpr double da[] = {1.0f, 2.0, 1, false};
+
+constexpr float fm = __FLT_MAX__;
+constexpr int someInt = fm; // ref-error {{must be initialized by a constant expression}} \
+                            // ref-note {{is outside the range of representable values}} \
+                            // expected-error {{must be initialized by a constant expression}} \
+                            // expected-note {{is outside the range of representable values}}

clang/test/SemaCXX/rounding-math.cpp

 // RUN: %clang_cc1 -triple x86_64-linux -verify=norounding -Wno-unknown-pragmas %s
 // RUN: %clang_cc1 -triple x86_64-linux -verify=rounding %s -frounding-math -Wno-unknown-pragmas
+// RUN: %clang_cc1 -triple x86_64-linux -verify=rounding %s -frounding-math -fexperimental-new-constant-interpreter -Wno-unknown-pragmas
 // rounding-no-diagnostics
 
 #define fold(x) (__builtin_constant_p(x) ? (x) : (x))
 
 constexpr double a = 1.0 / 3.0;
 
 constexpr int f(int n) { return int(n * (1.0 / 3.0)); }