Move FPFeatures from BinaryOperator bitfields to Trailing storage

[mibintc]

Summary

This patch moves the FPFeatures field from BinaryOperator bitfields to Trailing storage, since there is a current desire to widen the FPOptions type. It's a preliminary patch, looking for feedback from @rjmccall and others. On the dev email list, there was an alternate proposal to maintain this information in state. I had already partly implemented this change so I just continued along this way.

There's still a problem in the patch, there's a bug in the AST statement visitor, something wrong with the template metaprogramming? i still haven't found that problem, but i wanted to put this up for any feedback before i find and fix that problem, If you see what i did wrong please let me know. The problem has to do with combining the CompoundAssignmentOperator and BinaryOperator. I needed to do that because BinaryOperator needs to be finalized before Trailing storage can be used.

FPFeatures are also needed on CXXOperatorCall. I put that field into CallExpr. Do you want that to go into Trailing storage as well? I didn't do that. It would also require CallExpr and CXXOperatorCall to be collapsed together.

[mibintc]

There's a bug in this patch that i haven't solved yet. I think it's just 1 bug. The bug is that the AST statement visitor is going to the "fallback" instead of the right destination when walking CompoundAssignmentOperator. This patch collapses CompoundAssignmentOperator class into BinaryOperator class. In a spot check, i think all the failing tests are because the Visitor walk isn't working correctly for CompoundAssign (for example += ). These are the test fails reported by check-clang in my sandbox,
Failing Tests (15):

Clang :: Analysis/loopexit-cfg-output.cpp
Clang :: CXX/drs/dr2xx.cpp
Clang :: CXX/expr/expr.const/p2-0x.cpp
Clang :: CXX/expr/expr.prim/expr.prim.lambda/expr.prim.lambda.capture/p17.cpp
Clang :: CodeGen/ffp-contract-fast-option.cpp
Clang :: CodeGenCXX/const-init-cxx1y.cpp
Clang :: CodeGenCXX/const-init-cxx2a.cpp
Clang :: CodeGenCXX/non-const-init-cxx2a.cpp
Clang :: Sema/warn-unreachable.c
Clang :: Sema/warn-unsequenced.c
Clang :: SemaCXX/constant-expression-cxx1y.cpp
Clang :: SemaCXX/constant-expression-cxx2a.cpp
Clang :: SemaCXX/decomposed-condition.cpp
Clang :: SemaCXX/integer-overflow.cpp
Clang :: SemaCXX/warn-unsequenced.cpp

[mibintc]

This revision has been rebased, the LIT test failures seen in the previous revision have been corrected: check-all passes. Still owe you some polishing. I'm going to add a couple inline comments.

[mibintc]

In D76384#1929774, @mibintc wrote:

There's a bug in this patch that i haven't solved yet. I think it's just 1 bug. The bug is that the AST statement visitor is going to the "fallback" instead of the right destination when walking CompoundAssignmentOperator. This patch collapses CompoundAssignmentOperator class into BinaryOperator class. In a spot check, i think all the failing tests are because the Visitor walk isn't working correctly for CompoundAssign (for example += ). These are the test fails reported by check-clang in my sandbox,
Failing Tests (15):

Clang :: Analysis/loopexit-cfg-output.cpp
Clang :: CXX/drs/dr2xx.cpp
Clang :: CXX/expr/expr.const/p2-0x.cpp
Clang :: CXX/expr/expr.prim/expr.prim.lambda/expr.prim.lambda.capture/p17.cpp
Clang :: CodeGen/ffp-contract-fast-option.cpp
Clang :: CodeGenCXX/const-init-cxx1y.cpp
Clang :: CodeGenCXX/const-init-cxx2a.cpp
Clang :: CodeGenCXX/non-const-init-cxx2a.cpp
Clang :: Sema/warn-unreachable.c
Clang :: Sema/warn-unsequenced.c
Clang :: SemaCXX/constant-expression-cxx1y.cpp
Clang :: SemaCXX/constant-expression-cxx2a.cpp
Clang :: SemaCXX/decomposed-condition.cpp
Clang :: SemaCXX/integer-overflow.cpp
Clang :: SemaCXX/warn-unsequenced.cpp

The new revision corrects all these fails. i have a couple questions about test cases, i've inline those in the test case modification. Also need to do clang-format and also some changes to CXXCallOperator to remove redundant accessor

clang/include/clang/AST/ExprCXX.h

164–165

i can get rid of these 2 accessor functions, we get them from CallExpr

clang/test/Analysis/loopexit-cfg-output.cpp

211 ↗

(On Diff #251699)

With these changes, the blocks print out in a different order but the semantic meaning appears to be the same. Is this difference acceptable?

clang/test/Sema/warn-unreachable.c

86 ↗

(On Diff #251699)

The srcpos for compound assignment is now the same as srcpos for ordinary binary operator, so i changed the test case to move the diagnostic, ok?

[mibintc]

This revision fixes the clang-tidy,clang-format and removes the redundant accessors. Ready for your review.

[rjmccall]

Let's make this patch be purely a representation change. I wouldn't expect *any* test changes from that; if there are, we should understand why. You can then add the stuff about tracking whether there's a pragma in a separate patch.

clang/include/clang/AST/StmtVisitor.h

92

Let's stick with the existing formatting for consistency. It's just vertically aligning the DISPATCH and class-name tokens to emphasize the common pattern.

clang/include/clang/Serialization/ASTBitCodes.h

1563

I think the intent is that we don't change constant values in this file. You can leave this in place with a comment saying it's defunct, though.

[mibintc]

In D76384#1934785, @rjmccall wrote:

Let's make this patch be purely a representation change. I wouldn't expect *any* test changes from that; if there are, we should understand why. You can then add the stuff about tracking whether there's a pragma in a separate patch.

OK, some of the tests show ConditionalOperator in the IR matching. Since that operator is necessarily getting merged into BinaryOperator those tests will have to change. I'll see about changing the srcpos for the conditional assignment operator so i can undo the srcpos changes in those tests.

[rjmccall]

In D76384#1936769, @mibintc wrote:

In D76384#1934785, @rjmccall wrote:

Let's make this patch be purely a representation change. I wouldn't expect *any* test changes from that; if there are, we should understand why. You can then add the stuff about tracking whether there's a pragma in a separate patch.

OK, some of the tests show ConditionalOperator in the IR matching. Since that operator is necessarily getting merged into BinaryOperator those tests will have to change. I'll see about changing the srcpos for the conditional assignment operator so i can undo the srcpos changes in those tests.

I assume you mean CompoundAssignOperator. Sure, if there's some sort of debug output / AST dump in a test that includes expression node names, obviously that's okay to change; and it's possible that the new behavior with CompoundAssignOperator not split out is better in some way. We should just make sure we understand any changes we see.

[mibintc]

I think this addresses all the feedback from @rjmccall

[mibintc]

This comment was removed by mibintc.

[mibintc]

I don't see those Harbormaster fails, using trunk and RHEL8 on architecture x86_64, Debug build of clang;clang-tools-extra and check-all. I ran all the failed lit tests separately and each passed

[rjmccall]

clang/include/clang/AST/Expr.h

2573

Let's split the CallExpr changes out into a separate patch, so that we have one patch that's *purely* about unifying BinaryOperator and CompoundAssignOperator and putting FPOptions in trailing storage, and then another that's about adding FPOptions to CallExpr.

For that latter patch, CallExpr already has its own, hand-rolled concept of trailing storage which you should be able to emulate instead of unifying the hierarchy.

3417

Why does this use unsigned for the trailing storage of the FPOptions?

3421

Can these bits go in the bitfields?

3465

Okay, so this is *always* adding trailing storage. Is there a common value for FPOptions — something that corresponds to default settings, for example — that we could use to avoid needing storage in the common case?

Also, it would be useful to extract a function somewhere that you can use in all of these places for consistency, maybe something like this on FPOptions:

/// Does this FPOptions require trailing storage when stored in various AST nodes,
/// or can it be recreated using `defaultWithoutTrailingStorage`?
bool requiresTrailingStorage() const { return *this == defaultWithoutTrailingStorage(); }

/// Return the default value of FPOptions that's used when trailing storage isn't required.
static FPOptions defaultWithoutTrailingStorage() { ... }

3471

Please change the text in this assertion and the one in the constructor above. The requirement is now that you use the appropriate constructor for the case. Or maybe we should just have one constructor that takes optional CompLHS/CompResult types and then assert that they're given if we're building a compound assignment? If you do the same for Create, the whole thing might end up being much more convenient for callers, too.

3643

Are these necessary?

3676

These should all assert that they're being used on a compound-assignment operator.

Please preserve the comments from CompoundAssignOperator on these.

6029

Why is this in this patch?

clang/lib/AST/Expr.cpp

4285

These places should use that same unified predicate.

[mibintc]

clang/include/clang/AST/Expr.h

3465

The reason I set hasFPFeatures to True in this revision is because in the previous review you asked me to make it purely a representational change and "add stuff about whether there is a pragma in a separate patch". The stuff I had in the previous version was smarter about creating trailing storage, it only created trailing storage when the pragma was in effect. I envirsioned that the evolution would accept something that always created the FPOptions in trailing storage, and in the 2nd generation would adopt the more thrifty way of creating trailing storage.

[rjmccall]

clang/include/clang/AST/Expr.h

3465

Well, let's at least set up the infrastructure and APIs correctly, even if we always allocate trailing storage.

For example, should getFPOptions take an ASTContext & so that it can always return the right options instead of making clients do hasFPOptions() ? getFPOptions() : ctx.getFPOptions()?

[mibintc]

@rjmccall Many thanks for your code review. Please take a look at this when you get a chance.

[mibintc]

I added some inline replies to John. I'm not certain I have everything yet exactly the way he wants it.

clang/include/clang/AST/Expr.h

2573

I've split off the CallExpr changes to a future patch - will you give me a hint about CallExpr's own hand-rolled concept of trailing storage? e.g. a line number or identifier name that i can hunt for and track down.

3417

I will change it to FPOptions

3420

I think I need hasFPFeatures in the node itself because that's how i know whether there's trailingstorage e.g. in the AST reader-writer. hasFPFeatures is always true at the moment but that will be improved in the next generation.

3421

i eliminated isCompoundAssign because, i can just check the opcode, i think there's always a opcode or a dummy opcode. But I need hasFPFeatures

3465

To explain further, in the pragma patch, which is fully formed but split off for a future commit, the Sema structure holds the current value of the floating point settings (in FPOptions FPFeatures). It is initialized from the command line, and as compound statements/blocks which contain pragma's are entered and exited, the value of Sema.FPFeatures is updated. I will add a bit "has_pragma_features" to FPOptions. When that bit is true, I know that the initial value of FPOptions (which is derived from command line) is different than the current settings. In this circumstance only it is necessary to hold FPFeatures in the Expr nodes (in Trailing storage). In all other cases, FPOptions can be derived from LangOpts and LangOpts is available in each clang pass. There are a bunch of occurrences where FPOptions() has been added as an nth parameter to various function calls, i believe though I'm not certain that in those cases the value of FPOptions is "don't care". (those occurrences were pre-existing in the source code). I hope this makes sense.

3471

I combined the dual Constructor's and Create's into singles with default parameters. I had to do some juggling at some of the call sites to make the new interface work. Do you prefer this way?

6029

I'm not sure what this is referring to?

clang/include/clang/AST/StmtVisitor.h

92

You had mentioned in your previous review about having things lined up properly here, and I don't disagree--this comment is just to let you know that I had applied the clang-format patch that was supplied by the BuildBots in the pre-commit checks. The buildbot pre-commit check wants them on different lines. I've switched the formatting to what you request.

clang/include/clang/Basic/LangOptions.h

379

I added these at your suggestion but not presently making use of them

clang/lib/AST/Expr.cpp

4285

I'm not sure if I captured what you want here.

[mibintc]

On my RHEL8 system building Debug clang;clang-tools-extra, check-all is passing.

[rjmccall]

clang/include/clang/AST/Expr.h

2573

Sure, check out CallExpr's sizeOfTrailingObjects and offsetToTrailingObjects.

3420

It's pretty common to make ASTStmtReader and ASTStmtWriter friends of the bitfields struct.

3421

If IsCompoundAssign is important enough to be worth optimizing, it's not a problem per se to keep it separate. Up to you. But it can definitely go in the bitfields if you need it.

3465

That does make sense, thank you. I wonder if it would be sensible for Sema to maintain not just the current state + whether there are any pragma overrides but also an idea of what specifically has been overridden. That would make the AST basically agnostic to the default settings; you'd always be able to just apply the overrides to the defaults. At that point, we'd be able to re-use serialized modules in builds with different fast-math settings, which would be really nice.

On the other hand, since the default settings are sometimes exposed as #defines (e.g. FAST_MATH) and therefore can influence the AST in other ways, maybe we wouldn't be able to re-use serialized modules that way.

Regardless, the right API would be to pass in the ASTContext so that this accessor can simply return the correct settings instead of making the caller merge information.

[rjmccall]

clang/include/clang/AST/Expr.h

3471

QualType has an empty state, so I would just declare the parameters like QualType CompLHSType = QualType(). That'll make the call sites much simpler, because you can structure the code like:

QualType CompLHSType, CompResultType;
if (E->isCompoundAssign()) {
  CompLHSType = ...;
  CompResultType = ...;
}
return BinaryOperator::Create(...);

3633

We generally lower-case method names, so these would be isCompoundAssign() and hasFPFeatures() (maybe hasFPFeatureOverrides()?).

6029

I was probably looking at the wrong diff, sorry. The "new changes only" display can get confused when patches are rebased.

clang/include/clang/Basic/LangOptions.h

379

Please do. You don't have to do it how I suggested — if you want to make requiresTrailingStorage just return true, that's fine — but please use this to centralize all the decisions about whether or not trailing storage is required.

[mibintc]

Here's another revision, I believe this handles all of @rjmccall 's requests. Thank you, John, for your review!

[rjmccall]

clang/include/clang/AST/Expr.h

3439

Sorry, I wasn't trying to say you need this here! Since you can use TrailingObjects for BinaryOperator, you absolutely should take advantage of what it does. I was just pointing you at the CallExpr stuff so that you can see the places you'll need to update when you add this storage to CallExpr.

3653

I'm not sure it's a good idea to have this accessor, at least not with such a tempting name. Maybe getStoredFPFeatures() and hasStoredFPFeatures()?

3663

These two accessors will need to take ASTContexts eventually. Are you planning to do that in a follow-up patch?

clang/include/clang/AST/JSONNodeDumper.h

265

What actually calls this? StmtVisitor as written doesn't fall back on a VisitCompoundAssignOperator. You could *make* it fall back on one, of course.

clang/include/clang/AST/RecursiveASTVisitor.h

427

Comment needs updating.

clang/include/clang/AST/StmtVisitor.h

146

Comment needs updating, but more importantly, you're making all of these fall back on VisitBinAssign, which is definitely not correct.

clang/include/clang/Basic/LangOptions.h

392

The problem with having both functions that take ASTContexts and functions that don't is that it's easy to mix them, so they either need to have the same behavior (in which case it's pointless to have an overload that takes the ASTContext) or you're making something really error-prone.

I would feel a lot more confident that you were designing and using these APIs correctly if you actually took advantage of the ability to not store trailing FPOptions in some case, like when they match the global settings in the ASTContext. That way you'll actually be verifying that everything behaves correctly if nodes don't store FPOptions. If you do that, I think you'll see my point about not having all these easily-confusable functions that do or do not take ASTContexts..

[erichkeane]

Trying to help Melanie respond to the comments, so I ran through the patch and came up with the following comments/responses. Sorry for the 'surprise hit' :)

clang/include/clang/AST/Expr.h

3439

Yep, this shouldn't be necessary. Uses of this should be able to use totalSizeToAlloc and additionalSizeToAlloc.

3638

Since changing this value can result in a change of allocation size, I don't think this should be settable after creation.

3654

Whats the purpose of having both of these? It seems that you can either: 1- Have only the first and require consumers to check if they aren't sure, or 2- Only do the second, and those who have checked just get the default anyway.

3690–3693

Nit, I'd prefer this be named 'isCompoundAssignment'. Also, the patch seems a little inconsistent with FPFeatures vs FPOptions.

clang/include/clang/AST/StmtVisitor.h

146

@rjmccall : What would you think fits better? If we don't have something like this, VisitBinaryOperator is going to have to redirect to VisitBinAssign anyway. We could presumably keep VisitCompoundAssignOperator, but that seems like a naming difference.

clang/include/clang/Basic/LangOptions.h

383

Nit: return {}; ?

Also, why are there two versions of this? It seems that the ASTContext one should be the only required one.

392

I think I disagree with @rjmccall that these requiresTrailingStorage should be here at all. I think we should store in the AST ANY programmer opinion, even if they match the global setting. It seems to me that this would be more tolerant of any global-setting rewrites that modules/et-al introduce, as well as make the AST Print consistent. Always storing FPOptions when the user has explicitly overriding it also better captures the programmer's intent.

clang/lib/AST/Expr.cpp

4274

Again, should just use the TrailingObjects::totalSizeToAlloc I think. Alternatively, implement a new 'totalSizeToAlloc' based on the hasFPFeatures and isCompound).

clang/lib/AST/ExprConstant.cpp

7788

Perhaps not changing this name is a good idea, and just leaving this as VisitCompoundOperator, then having the 'default' behavior to be to just call VisitBinaryOperator.

[rjmccall]

clang/include/clang/AST/StmtVisitor.h

146

VisitBinAssign is an existing method that is used specifically for the simple assignment operator. The old delegation was that VisitBinMulAssign delegated to VisitCompoundAssignOperator, which delegated to VisitBinaryOperator (because CAO was a subclass of that), which delegated to VisitExpr. The natural new delegation here would be for VisitBinMulAssign to just delegate directly to VisitBinaryOperator. If it's still useful to have an intermediate visitor method in the delegation chain for all the compound assignment operators, that's fine, but it shouldn't be VisitBinAssign.

clang/include/clang/Basic/LangOptions.h

392

I covered this elsewhere in the review. If you want to have that tolerance — and I think you should — then expressions should store (and Sema should track) the active pragma state, which can be most easily expressed as a pair of an FPOptions and a mask to apply to the global FPOptions. When you enter a pragma, you clear the relevant bits from the global FPOptions mask.

But the whole point of putting this stuff in trailing storage is so that you can make FPOptions as big as you need without actually inflating the AST size for a million nodes that don't care in the slightest about FPOptions.

[rjmccall]

clang/include/clang/Basic/LangOptions.h

392

But the whole point of putting this stuff in trailing storage is so that you can make FPOptions as big as you need without actually inflating the AST size for a million nodes that don't care in the slightest about FPOptions.

I meant to say: for a million nodes that don't care in the slightest about FPOptions, as well as for a million more nodes that aren't using pragma overrides.

[erichkeane]

clang/include/clang/Basic/LangOptions.h

392

Right, I get the intent, and I completely agree with that. My point was EVERY Expr that is affected by a #pragma should store it. Though, after looking at your Macro concern above, I'm less compelled.

I guess was suggesting that the logic for "requiresTrailingStorage" should just be "modified by a pragma" instead of "FPOptions != The global setting".

[rjmccall]

clang/include/clang/Basic/LangOptions.h

392

Well, "modified by a pragma" still wouldn't make the AST agnostic to global settings, since the pragmas don't override everything in FPOptions at once. But I agree that would achieve the most important goal, which is to stop inflating the AST when pragmas *aren't* in effect, which is approximately 100% of the time. In order to do that, though, we'll need to start tracking pragmas, which we should do but which can wait for a follow-up patch. In the meantime, I don't think you're ever going to get the interfaces right for queries like BinaryOperator::getFPOptions unless you actually stop relying on the fact that you're unconditionally storing FPOptions. You need to passing around ASTContexts for that. That's why I'm suggesting using an exact match with the global settings as a simple thing you can easily check without modifying what data you collect in FPOptions.

[erichkeane]

clang/include/clang/Basic/LangOptions.h

392

That sounds like a good plan to me. Thanks for entertaining my conversation/questions.

[sepavloff]

clang/include/clang/Basic/LangOptions.h

392

we'll need to start tracking pragmas

This is made in D76599 by representing floating point pragmas with a special statement node. These nodes allow an AST consumer like CodeGen or constant evaluator to maintain current set of floating options when it traverses AST. This approach looks simpler and more consistent as global state is represented as a variable in AST consumer and is not replicated to every relevant node. It makes easier to implement codegen for things like rounding mode, when change of the FP state requires specific instructions. A pragma statement can be used to generate required code. But if the state is spread by several nodes, it is more difficult for codegen to create necessary prolog/epilog code. Now compiler does not have support of properties that need synchronization with hardware, so these problems are not topical yet, but they eventually will arise.

[rjmccall]

clang/include/clang/Basic/LangOptions.h

392

Constant evaluation does not normally traverse the AST in the way you mean. It does this when evaluating a constexpr function, but that's not the dominant case of constant evaluation.

At the LLVM level, I think inlining, reordering, and ABI requirements on calls argue against a simple implementation model based on setting hardware flags when a pragma is entered and resetting them on exit.

[sepavloff]

clang/include/clang/Basic/LangOptions.h

392

Constant evaluation does not normally traverse the AST in the way you mean. It does this when evaluating a constexpr function, but that's not the dominant case of constant evaluation.

Evaluate* functions accept EvalInfo as argument, it can be extended to contain the current FPOptions, taken from Sema.

At the LLVM level, I think inlining, reordering, and ABI requirements on calls argue against a simple implementation model based on setting hardware flags when a pragma is entered and resetting them on exit.

For targets that encode FP environment in instructions this is true. But most targets encode FP environment in hardware registers, and a model, in which required FP environment is set at entry to some region and reset on exit from it, is very attractive. Actually constrained intrinsics is a way to prevent from reordering and similar optimizations that break this simple model. As C language provide setting FP environment only at block (or global) level it would be natural if AST would have similar property.

[rjmccall]

clang/include/clang/Basic/LangOptions.h

392

Many clients of the constant evaluator are not tied to Sema or are analyzing code that wasn't necessarily written in the current context. What you're discussing is *extremely* error-prone.

For targets that encode FP environment in instructions this is true. But most targets encode FP environment in hardware registers, and a model, in which required FP environment is set at entry to some region and reset on exit from it, is very attractive.

The constrained-intrinsics representation records options on each intrinsic, so no, it wouldn't naturally support a setup where the frontend emits intrinsics that change hardware flags on entry/exit to a region. That nicely matches a model where options are set on each expression. It also, fortunately, naturally supports optimizations like inlining as long as we turn non-intrinsic operations into intrinsics where necessary.

[mibintc]

I beleive this patch responds to all @rjmccall 's review comments, except I don't know how to program a solution to his StmtVisitor remark. I'll add more info about that. This patch optionally allocates the trailing storage in BinaryOperator. I verified that it was optionally allocated by adding an assert when trailing storage was allocated; the only lit tests that failed were the floating point pragma tests.

[mibintc]

If I change StmtVisitor to send compound assignment opcodes to BinaryOperator, then 12 clang LIT tests fail, all related to compound assignment mishandling, i.e. this patch

• a/clang/include/clang/AST/StmtVisitor.h

+++ b/clang/include/clang/AST/StmtVisitor.h
@@ -143,7 +143,7 @@ public:

// methods, fall back on VisitCompoundAssignOperator.

#define CAO_FALLBACK(NAME) \

RetTy VisitBin##NAME(PTR(BinaryOperator) S, ParamTys... P) {                 \

• DISPATCH(BinAssign, BinaryOperator); \

+ DISPATCH(BinaryOperator, BinaryOperator); \

}
CAO_FALLBACK(MulAssign) CAO_FALLBACK(DivAssign) CAO_FALLBACK(RemAssign)
CAO_FALLBACK(AddAssign) CAO_FALLBACK(SubAssign) CAO_FALLBACK(ShlAssign)

These clang lit tests fail,
Failing Tests (12):

Clang :: CXX/drs/dr2xx.cpp
Clang :: CXX/expr/expr.const/p2-0x.cpp
Clang :: CXX/expr/expr.prim/expr.prim.lambda/expr.prim.lambda.capture/p17.cpp
Clang :: CodeGenCXX/const-init-cxx1y.cpp
Clang :: CodeGenCXX/const-init-cxx2a.cpp
Clang :: CodeGenCXX/non-const-init-cxx2a.cpp
Clang :: Sema/warn-unsequenced.c
Clang :: SemaCXX/constant-expression-cxx1y.cpp
Clang :: SemaCXX/constant-expression-cxx2a.cpp
Clang :: SemaCXX/decomposed-condition.cpp
Clang :: SemaCXX/integer-overflow.cpp
Clang :: SemaCXX/warn-unsequenced.cpp

[sepavloff]

clang/include/clang/Basic/LangOptions.h

392

Many clients of the constant evaluator are not tied to Sema or are analyzing code that wasn't necessarily written in the current context. What you're discussing is *extremely* error-prone.

There is another implementation of representing FP environment in AST: D77545. Although it is made for limited number of cases, it could be extended.

[mibintc]

It seems like the macro's in StmtVisitor.h only work if CAO and BinaryOperator are separate classes.

[rjmccall]

I would guess that some visitor still has a VisitCompoundAssignOperator implementation, and that the behavior of VisitBinAssign happens to do what's needed for it.

You basically have two options:

• Keep a VisitCompoundAssignOperator around in StmtVisitor for all the compound-assignment operators to delegate to. You'll have to implement its delegation to VisitBinaryOperator manually.
• Search the source base for any remaining implementations of VisitCompoundAssignOperator and fold them into VisitBinaryOperator.

[mibintc]

I finally decided that combining BinaryOperator and CompoundAssignOperator was too difficult, this patch uses the trailing object approach similar to that used in CallExpr. @rjmccall thank you once again for all your reviews in developing this patch. I hope that this version is acceptable or within a hair's breadth of acceptable. As an experiment to confirm to myself that the trailing storage was only active in the pragma case, i added a "assert(0)" to getStoredFPFeatures. In that case check-clang showed 5 expected fails for the pragma tests cases. ( Clang :: CodeGen/constrained-math-builtins.c Clang :: CodeGen/fp-contract-fast-pragma.cpp Clang :: CodeGen/fp-contract-on-asm.c Clang :: CodeGen/fp-contract-on-pragma.cpp Clang :: CodeGen/fp-contract-pragma.cpp)

Then i removed that assert before submitting this to review.

[rjmccall]

Okay, that's fine, it's definitely a simpler change to not mess with the basic node hierarchy. The one problem I see is that you've (accidentally?) set up the FPOptions methods so that you can't call them on a BinaryOperator that's actually a CompoundAssignOperator — they'll end up accessing the wrong memory. Fortunately, that's pretty easy to fix, and fixing it should let you drop all the duplicate methods you've currently got on CompoundAssignOperator.

clang/include/clang/AST/Expr.h

3447

You should add an offsetOfTrailingStorage() method that returns isa<CompoundAssignOperator>(this) ? sizeof(CompoundAssignOperator) : sizeof(BinaryOperator), and then you can add that here instead of hard-coding sizeof(BinaryOperator).

[mibintc]

I made the changes requested by @rjmccall ; I also used clang-format on the tip. check-clang is passing. Look OK?

[rjmccall]

Thanks. Just a bunch of fairly minor requests now.

clang/include/clang/AST/Expr.h

3443

You don't need the non-const overload.

3693

Should HasFPFeatures be a bool everywhere you're passing it around?

clang/lib/AST/Expr.cpp

4322

Please define this in the header. You can just do:

inline size_t BinaryOperator::offsetOfTrailingStorage() const { ... }

after both of the classes are fully defined.

clang/lib/Analysis/BodyFarm.cpp

120

These construction sites don't seem like appropriate uses of defaultWithoutTrailingStorage, which is an implementation detail of the AST nodes. The right behavior here is for all of these places to use the default FPOptions from the language options, then let the AST figure out the right way to store that. That happens to have the same effect currently as defaultWithoutTrailingStorage, but the latter should be able to change, while the right behavior for these places will remain the same.

[mibintc]

Responded to @rjmccall 's review

[mibintc]

Adding an inline reply for John. rebased the patch, also re-applied clang-format. What do you think?

clang/lib/Analysis/BodyFarm.cpp

120

OK i changed these in BodyFarm to use the default constructor. In Sema I changed them from defaultWithoutTrailingStorage to use Sema.FPFeatures which is the current setting combining pragma values + command line options.

[rjmccall]

clang/lib/Analysis/BodyFarm.cpp

120

That's right for Sema. For all the other generated uses, I think you should use FPOptions(C.getLangOpts()) instead of the default constructor. Most of these don't really care about FPOptions — they're just creating an assignment or some other operation which is not FP-sensitive — but for the ones that do, we should follow the default behavior in the language options.

[mibintc]

Lost power in Monday's storm, back online today. I made the changes requested by @rjmccall. Look OK?

[rjmccall]

Minor fixes, then LGTM.

clang/lib/AST/ASTImporter.cpp

6805

Oh, these two calls need to use E->getFPFeatures(Importer.getFromContext()), since that's the context that the node was built in.

clang/lib/CodeGen/CGObjC.cpp

1497 ↗

(On Diff #257704)

Missed this one.

clang/lib/CodeGen/CGStmtOpenMP.cpp

2935 ↗

(On Diff #257704)

Missed this one.

clang/lib/Sema/SemaOverload.cpp

13786

This should use FPFeatures, I think.

[mibintc]

Responding to @rjmccall 's review. John, after this is approved I want to proceed with pragma float_control as proposed in D72841. Can you recommend an approach, do you think I will need to do it incrementally?

[rjmccall]

In D76384#1984498, @mibintc wrote:

Responding to @rjmccall 's review. John, after this is approved I want to proceed with pragma float_control as proposed in D72841. Can you recommend an approach, do you think I will need to do it incrementally?

I think the basic technical approach from that patch seems reasonable. It's not my goal to hold up your work to pursue other technical goals; we took this detour just to minimize the memory impact of your work.

I *would* like an NFC patch first that renames FPFeatures to something like CurFPFeatures in order to more clearly distinguish it from FPOptions in Sema code, though. That should be very quick.

[rjmccall]

Oh, and this patch LGTM, thank you.

[mibintc]

In D76384#1984584, @rjmccall wrote:

In D76384#1984498, @mibintc wrote:

Responding to @rjmccall 's review. John, after this is approved I want to proceed with pragma float_control as proposed in D72841. Can you recommend an approach, do you think I will need to do it incrementally?

I think the basic technical approach from that patch seems reasonable. It's not my goal to hold up your work to pursue other technical goals; we took this detour just to minimize the memory impact of your work.

Thanks for all. I'm sure my work will be easier in the long run to have this well scrutinized. And I learned a lot. And I endorse not being wasteful of memory.

I *would* like an NFC patch first that renames FPFeatures to something like CurFPFeatures in order to more clearly distinguish it from FPOptions in Sema code, though. That should be very quick.

OK. I think this means I can commit now and change the identifier spelling in a future standalone patch.

[mibintc]

In D76384#1984584, @rjmccall wrote:

I *would* like an NFC patch first that renames FPFeatures to something like CurFPFeatures in order to more clearly distinguish it from FPOptions in Sema code, though. That should be very quick.

You mean, Sema.FPFeatures -> Sema.CurFPFeatures, confirm?

[rjmccall]

In D76384#1984683, @mibintc wrote:

In D76384#1984584, @rjmccall wrote:

I *would* like an NFC patch first that renames FPFeatures to something like CurFPFeatures in order to more clearly distinguish it from FPOptions in Sema code, though. That should be very quick.

You mean, Sema.FPFeatures -> Sema.CurFPFeatures, confirm?

Right.

[mibintc]

@rjmccall Can you check the patch added last night here, commit 3ee1ec0b9dd6ee2350f39ae8a418bf3ce28d06cf
Author: Benjamin Kramer <[e-mail]>
Date: Thu Apr 16 11:45:02 2020 +0200

LangOptions cannot depend on ASTContext, make it not use ASTContext directly

Fixes a layering violation introduced in 2ba4e3a4598b165245c581c506a813cd4a7dce33.

[martong]

clang/lib/AST/ASTImporter.cpp

6804

This introduced an assertion failure during CTU analysis. The reason is that the LHSType and the ResultType have been imported twice.

The fix is in e033ec291a1b72f307ab14569ca99822c127610b

Details:

   clang: ../../git/llvm-project/clang/lib/Basic/SourceManager.cpp:918: clang::FileID clang::SourceManager::getFileIDLoaded(unsigned int) const: Assertion `0 && "Invalid SLocOffset or bad function choice"' failed.
   clang::SourceManager::getDecomposedExpansionLoc(clang::SourceLocation) const
   clang::SourceManager::getPresumedLoc(clang::SourceLocation, bool) const
   clang::ASTImporter::Import(clang::SourceLocation)
   llvm::Error clang::ASTImporter::importInto<clang::SourceLocation>(clang::SourceLocation&, clang::SourceLocation const&)
   clang::ASTNodeImporter::ImportDeclParts(clang::NamedDecl*, clang::DeclContext*&, clang::DeclContext*&, clang::DeclarationName&, clang::NamedDecl*&, clang::SourceLocation&)
   clang::ASTNodeImporter::VisitRecordDecl(clang::RecordDecl*)
   clang::declvisitor::Base<std::add_pointer, clang::ASTNodeImporter, llvm::Expected<clang::Decl*> >::Visit(clang::Decl*)
   clang::ASTImporter::Import(clang::Decl*)
   clang::ASTNodeImporter::VisitRecordType(clang::RecordType const*)
   clang::TypeVisitor<clang::ASTNodeImporter, llvm::Expected<clang::QualType> >::Visit(clang::Type const*)
   clang::ASTImporter::Import(clang::QualType)
   clang::ASTNodeImporter::VisitElaboratedType(clang::ElaboratedType const*)
   clang::TypeVisitor<clang::ASTNodeImporter, llvm::Expected<clang::QualType> >::Visit(clang::Type const*)
   clang::ASTImporter::Import(clang::QualType)
   clang::ASTNodeImporter::VisitPointerType(clang::PointerType const*)
   clang::TypeVisitor<clang::ASTNodeImporter, llvm::Expected<clang::QualType> >::Visit(clang::Type const*)
   clang::ASTImporter::Import(clang::QualType)
   clang::QualType clang::ASTNodeImporter::importChecked<clang::QualType>(llvm::Error&, clang::QualType const&)
 
clang::ASTNodeImporter::VisitCompoundAssignOperator(clang::CompoundAssignOperator*)

[mibintc]

clang/lib/AST/ASTImporter.cpp

6804

@martong Thank you.

[mibintc]

In D76384#1986525, @mibintc wrote:

@rjmccall Can you check the patch added last night here, commit 3ee1ec0b9dd6ee2350f39ae8a418bf3ce28d06cf
Author: Benjamin Kramer <[e-mail]>
Date: Thu Apr 16 11:45:02 2020 +0200

LangOptions cannot depend on ASTContext, make it not use ASTContext directly

Fixes a layering violation introduced in 2ba4e3a4598b165245c581c506a813cd4a7dce33.

I checked Benny's patch and it seems to have all the right semantics. The lit tests pass and the trailing storage is only created in the pragma case.

[mibintc]

I also added this patch which is a companion to this.
commit 8812b0cc5cc09f350d8e89bff99f185c5e1a5d4d
Author: Melanie Blower <[e-mail]>
Date: Thu Apr 16 08:45:26 2020 -0700

[NFC] Rename Sema.FPFeatures to CurFPFeatures and accessor to getCurFPFeatures

[rjmccall]

In D76384#1986761, @mibintc wrote:

In D76384#1986525, @mibintc wrote:

@rjmccall Can you check the patch added last night here, commit 3ee1ec0b9dd6ee2350f39ae8a418bf3ce28d06cf
Author: Benjamin Kramer <[e-mail]>
Date: Thu Apr 16 11:45:02 2020 +0200

LangOptions cannot depend on ASTContext, make it not use ASTContext directly

Fixes a layering violation introduced in 2ba4e3a4598b165245c581c506a813cd4a7dce33.

I checked Benny's patch and it seems to have all the right semantics. The lit tests pass and the trailing storage is only created in the pragma case.

Looks good to me, too.

clang/include/clang/AST/Expr.h

class CallExpr : public Expr {
   /// this pointer to the trailing objects.
   static unsigned offsetToTrailingObjects(StmtClass SC);
 
 public:
   enum class ADLCallKind : bool { NotADL, UsesADL };
   static constexpr ADLCallKind NotADL = ADLCallKind::NotADL;
   static constexpr ADLCallKind UsesADL = ADLCallKind::UsesADL;
 
+  FPOptions FPFeatures;
+
 protected:
   /// Build a call expression, assuming that appropriate storage has been
   /// allocated for the trailing objects.
   CallExpr(StmtClass SC, Expr *Fn, ArrayRef<Expr *> PreArgs,
            ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK,
-           SourceLocation RParenLoc, unsigned MinNumArgs, ADLCallKind UsesADL);
+           SourceLocation RParenLoc, FPOptions FP_Features, unsigned MinNumArgs,
+           ADLCallKind UsesADL);
 
   /// Build an empty call expression, for deserialization.
   CallExpr(StmtClass SC, unsigned NumPreArgs, unsigned NumArgs,
            EmptyShell Empty);
 
   /// Return the size in bytes needed for the trailing objects.
   /// Used by the derived classes to allocate the right amount of storage.
   static unsigned sizeOfTrailingObjects(unsigned NumPreArgs, unsigned NumArgs) {
public:
   /// of Args.size() and MinNumArgs. This is used in a few places to allocate
   /// enough storage for the default arguments. UsesADL specifies whether the
   /// callee was found through argument-dependent lookup.
   ///
   /// Note that you can use CreateTemporary if you need a temporary call
   /// expression on the stack.
   static CallExpr *Create(const ASTContext &Ctx, Expr *Fn,
                           ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK,
-                          SourceLocation RParenLoc, unsigned MinNumArgs = 0,
+                          SourceLocation RParenLoc, FPOptions FP_Features,
+                          unsigned MinNumArgs = 0,
                           ADLCallKind UsesADL = NotADL);
 
   /// Create a temporary call expression with no arguments in the memory
   /// pointed to by Mem. Mem must points to at least sizeof(CallExpr)
   /// + sizeof(Stmt *) bytes of storage, aligned to alignof(CallExpr):
   ///
   /// \code{.cpp}
   ///   alignas(CallExpr) char Buffer[sizeof(CallExpr) + sizeof(Stmt *)];
public:
   /// If the callee is a FunctionDecl, return it. Otherwise return null.
   FunctionDecl *getDirectCallee() {
     return dyn_cast_or_null<FunctionDecl>(getCalleeDecl());
   }
   const FunctionDecl *getDirectCallee() const {
     return dyn_cast_or_null<FunctionDecl>(getCalleeDecl());
   }
 
+  // Set the FPFeatures status of this CallExpr. Only meaningful for
+  // operations on floating point types. e.g. intrinsics
+  void setFPFeatures(FPOptions F) { FPFeatures = F; }
+  FPOptions getFPFeatures() const { return FPFeatures; }
+
+  // Get the FP contractability status of this CallExpr. Only meaningful for
+  // operations on floating point types. e.g. intrinsics
+  bool isFPContractableWithinStatement() const {
+    return FPFeatures.allowFPContractWithinStatement();
+  }
+
   /// getNumArgs - Return the number of actual arguments to this call.
   unsigned getNumArgs() const { return NumArgs; }
 
   /// Retrieve the call arguments.
   Expr **getArgs() {
     return reinterpret_cast<Expr **>(getTrailingStmts() + PREARGS_START +
                                      getNumPreArgs());
   }

 /// a C++ template, whether BinaryOperator or CXXOperatorCallExpr is
 /// used to store an expression "x + y" depends on the subexpressions
 /// for x and y. If neither x or y is type-dependent, and the "+"
 /// operator resolves to a built-in operation, BinaryOperator will be
 /// used to express the computation (x and y may still be
 /// value-dependent). If either x or y is type-dependent, or if the
 /// "+" resolves to an overloaded operator, CXXOperatorCallExpr will
 /// be used to express the computation.
-class BinaryOperator : public Expr {
+class BinaryOperator final
+    : public Expr,
+      private llvm::TrailingObjects<BinaryOperator, unsigned, QualType> {
   enum { LHS, RHS, END_EXPR };
   Stmt *SubExprs[END_EXPR];
+  bool hasFPFeatures;
+  bool isCompoundAssign;
+
+  /// Return the size in bytes needed for the trailing objects.
+  /// Used by the derived classes to allocate the right amount of storage.
+  static unsigned sizeOfTrailingObjects(bool hasFP, bool isCompound) {
+    return (hasFP ? 1 : 0) * sizeof(unsigned) +
+           (isCompound ? 2 : 0) * sizeof(QualType);
+  }
+  unsigned numTrailingObjects(OverloadToken<unsigned>) const {
+    return hasFPFeatures ? 1 : 0;
+  }
+  unsigned numTrailingObjects(OverloadToken<QualType>) const {
+    return isCompoundAssign ? 2 : 0;
+  }
 
 public:
   typedef BinaryOperatorKind Opcode;
 
   BinaryOperator(Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy,
                  ExprValueKind VK, ExprObjectKind OK, SourceLocation opLoc,
                  FPOptions FPFeatures)
       : Expr(BinaryOperatorClass, ResTy, VK, OK) {
     BinaryOperatorBits.Opc = opc;
-    BinaryOperatorBits.FPFeatures = FPFeatures.getInt();
     BinaryOperatorBits.OpLoc = opLoc;
+    hasFPFeatures = true;
+    isCompoundAssign = 0;
+    if (hasFPFeatures) {
+      *getTrailingObjects<unsigned>() = FPFeatures.getInt();
+    }
     SubExprs[LHS] = lhs;
     SubExprs[RHS] = rhs;
     assert(!isCompoundAssignmentOp() &&
-           "Use CompoundAssignOperator for compound assignments");
+           "Use BinaryOperator for compound assignments");
     setDependence(computeDependence(this));
   }
-
-  /// Construct an empty binary operator.
-  explicit BinaryOperator(EmptyShell Empty) : Expr(BinaryOperatorClass, Empty) {
-    BinaryOperatorBits.Opc = BO_Comma;
+  BinaryOperator(Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy,
+                 ExprValueKind VK, ExprObjectKind OK, QualType CompLHSType,
+                 QualType CompResultType, SourceLocation opLoc,
+                 FPOptions FPFeatures)
+      : Expr(BinaryOperatorClass, ResTy, VK, OK) {
+    BinaryOperatorBits.Opc = opc;
+    BinaryOperatorBits.OpLoc = opLoc;
+    SubExprs[LHS] = lhs;
+    SubExprs[RHS] = rhs;
+    hasFPFeatures = true;
+    isCompoundAssign = 1;
+    if (hasFPFeatures) {
+      *getTrailingObjects<unsigned>() = FPFeatures.getInt();
+    }
+    assert(isCompoundAssignmentOp() &&
+           "Expected CompoundAssignOperator for compound assignments");
+    setComputationLHSType(CompLHSType);
+    setComputationResultType(CompResultType);
+    setDependence(computeDependence(this));
   }
 
   SourceLocation getExprLoc() const { return getOperatorLoc(); }
   SourceLocation getOperatorLoc() const { return BinaryOperatorBits.OpLoc; }
   void setOperatorLoc(SourceLocation L) { BinaryOperatorBits.OpLoc = L; }
 
   Opcode getOpcode() const {
     return static_cast<Opcode>(BinaryOperatorBits.Opc);
public:
 
   // Return true if a binary operator using the specified opcode and operands
   // would match the 'p = (i8*)nullptr + n' idiom for casting a pointer-sized
   // integer to a pointer.
   static bool isNullPointerArithmeticExtension(ASTContext &Ctx, Opcode Opc,
                                                Expr *LHS, Expr *RHS);
 
   static bool classof(const Stmt *S) {
-    return S->getStmtClass() >= firstBinaryOperatorConstant &&
-           S->getStmtClass() <= lastBinaryOperatorConstant;
+    return S->getStmtClass() == BinaryOperatorClass;
   }
 
   // Iterators
   child_range children() {
     return child_range(&SubExprs[0], &SubExprs[0]+END_EXPR);
   }
   const_child_range children() const {
     return const_child_range(&SubExprs[0], &SubExprs[0] + END_EXPR);
   }
 
   // Set the FP contractability status of this operator. Only meaningful for
   // operations on floating point types.
   void setFPFeatures(FPOptions F) {
-    BinaryOperatorBits.FPFeatures = F.getInt();
+    assert(HasFPFeatures());
+    *getTrailingObjects<unsigned>() = F.getInt();
   }
 
+  static BinaryOperator *
+  CreateEmpty(const ASTContext &C, unsigned hasFPFeatures, unsigned isCompound);
+
+  static BinaryOperator *Create(const ASTContext &C, Expr *lhs, Expr *rhs,
+                                Opcode opc, QualType ResTy, ExprValueKind VK,
+                                ExprObjectKind OK, SourceLocation opLoc,
+                                FPOptions FPFeatures);
+  static BinaryOperator *Create(const ASTContext &C, Expr *lhs, Expr *rhs,
+                                Opcode opc, QualType ResTy, ExprValueKind VK,
+                                ExprObjectKind OK, QualType CompLHSType,
+                                QualType CompResultType, SourceLocation opLoc,
+                                FPOptions FPFeatures);
+
+  unsigned getFPFeat() const {
+    assert(HasFPFeatures());
+    return *getTrailingObjects<unsigned>();
+  }
+  unsigned getFPFeat() {
+    assert(HasFPFeatures());
+    return *getTrailingObjects<unsigned>();
+  }
+
+  void setIsCompoundAssign(bool B) { isCompoundAssign = B; }
+  bool IsCompoundAssign() const { return isCompoundAssign; }
+
+  void setHasFPFeatures(bool B) { hasFPFeatures = B; }
+  bool HasFPFeatures() const { return hasFPFeatures; }
   FPOptions getFPFeatures() const {
-    return FPOptions(BinaryOperatorBits.FPFeatures);
+    assert(HasFPFeatures());
+    return FPOptions(*getTrailingObjects<unsigned>());
   }
 
   // Get the FP contractability status of this operator. Only meaningful for
   // operations on floating point types.
   bool isFPContractableWithinStatement() const {
     return getFPFeatures().allowFPContractWithinStatement();
   }
 
   // Get the FENV_ACCESS status of this operator. Only meaningful for
   // operations on floating point types.
   bool isFEnvAccessOn() const { return getFPFeatures().allowFEnvAccess(); }
 
+  QualType getComputationLHSType() const {
+    return getTrailingObjects<QualType>()[0];
+  }
+  void setComputationLHSType(QualType T) {
+    getTrailingObjects<QualType>()[0] = T;
+  }
+  QualType getComputationResultType() const {
+    return getTrailingObjects<QualType>()[1];
+  }
+  void setComputationResultType(QualType T) {
+    getTrailingObjects<QualType>()[1] = T;
+  }
+
 protected:
   BinaryOperator(Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy,
                  ExprValueKind VK, ExprObjectKind OK, SourceLocation opLoc,
                  FPOptions FPFeatures, bool dead2)
-      : Expr(CompoundAssignOperatorClass, ResTy, VK, OK) {
+      : Expr(BinaryOperatorClass, ResTy, VK, OK) {
     BinaryOperatorBits.Opc = opc;
-    BinaryOperatorBits.FPFeatures = FPFeatures.getInt();
     BinaryOperatorBits.OpLoc = opLoc;
     SubExprs[LHS] = lhs;
     SubExprs[RHS] = rhs;
     setDependence(computeDependence(this));
   }
 
-  BinaryOperator(StmtClass SC, EmptyShell Empty) : Expr(SC, Empty) {
+  BinaryOperator(EmptyShell Empty, unsigned hasFPFeatures, unsigned isCompound)
+      : Expr(BinaryOperatorClass, Empty) {
+    if (isCompound)
       BinaryOperatorBits.Opc = BO_MulAssign;
   }
-};
-
-/// CompoundAssignOperator - For compound assignments (e.g. +=), we keep
-/// track of the type the operation is performed in.  Due to the semantics of
-/// these operators, the operands are promoted, the arithmetic performed, an
-/// implicit conversion back to the result type done, then the assignment takes
-/// place.  This captures the intermediate type which the computation is done
-/// in.
-class CompoundAssignOperator : public BinaryOperator {
-  QualType ComputationLHSType;
-  QualType ComputationResultType;
-public:
-  CompoundAssignOperator(Expr *lhs, Expr *rhs, Opcode opc, QualType ResType,
-                         ExprValueKind VK, ExprObjectKind OK,
-                         QualType CompLHSType, QualType CompResultType,
-                         SourceLocation OpLoc, FPOptions FPFeatures)
-    : BinaryOperator(lhs, rhs, opc, ResType, VK, OK, OpLoc, FPFeatures,
-                     true),
-      ComputationLHSType(CompLHSType),
-      ComputationResultType(CompResultType) {
-    assert(isCompoundAssignmentOp() &&
-           "Only should be used for compound assignments");
-  }
-
-  /// Build an empty compound assignment operator expression.
-  explicit CompoundAssignOperator(EmptyShell Empty)
-    : BinaryOperator(CompoundAssignOperatorClass, Empty) { }
-
-  // The two computation types are the type the LHS is converted
-  // to for the computation and the type of the result; the two are
-  // distinct in a few cases (specifically, int+=ptr and ptr-=ptr).
-  QualType getComputationLHSType() const { return ComputationLHSType; }
-  void setComputationLHSType(QualType T) { ComputationLHSType = T; }
-
-  QualType getComputationResultType() const { return ComputationResultType; }
-  void setComputationResultType(QualType T) { ComputationResultType = T; }
-
-  static bool classof(const Stmt *S) {
-    return S->getStmtClass() == CompoundAssignOperatorClass;
-  }
+  friend TrailingObjects;
 };
 
 /// AbstractConditionalOperator - An abstract base class for
 /// ConditionalOperator and BinaryConditionalOperator.
 class AbstractConditionalOperator : public Expr {
   SourceLocation QuestionLoc, ColonLoc;
   friend class ASTStmtReader;
 
private:
 
   size_t numTrailingObjects(OverloadToken<Stmt *>) const { return NumExprs; }
 
   SourceLocation BeginLoc, EndLoc;
   unsigned NumExprs;
   friend TrailingObjects;
   friend class ASTStmtReader;
   friend class ASTStmtWriter;
 };
 
 } // end namespace clang
 
 #endif // LLVM_CLANG_AST_EXPR_H

clang/include/clang/AST/ExprCXX.h

public:
   }
 
   SourceLocation getBeginLoc() const { return Range.getBegin(); }
   SourceLocation getEndLoc() const { return Range.getEnd(); }
   SourceRange getSourceRange() const { return Range; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == CXXOperatorCallExprClass;
   }
-
-  // Set the FP contractability status of this operator. Only meaningful for
-  // operations on floating point types.
-  void setFPFeatures(FPOptions F) {
-    CXXOperatorCallExprBits.FPFeatures = F.getInt();
-  }
-  FPOptions getFPFeatures() const {
-    return FPOptions(CXXOperatorCallExprBits.FPFeatures);
-  }
-
-  // Get the FP contractability status of this operator. Only meaningful for
-  // operations on floating point types.
-  bool isFPContractableWithinStatement() const {
-    return getFPFeatures().allowFPContractWithinStatement();
-  }
 };
 
 /// Represents a call to a member function that
 /// may be written either with member call syntax (e.g., "obj.func()"
 /// or "objptr->func()") or with normal function-call syntax
 /// ("func()") within a member function that ends up calling a member
 /// function. The callee in either case is a MemberExpr that contains
 /// both the object argument and the member function, while the
 /// arguments are the arguments within the parentheses (not including

clang/include/clang/AST/JSONNodeDumper.h

public:
   void VisitObjCPropertyDecl(const ObjCPropertyDecl *D);
   void VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D);
   void VisitBlockDecl(const BlockDecl *D);
 
   void VisitDeclRefExpr(const DeclRefExpr *DRE);
   void VisitPredefinedExpr(const PredefinedExpr *PE);
   void VisitUnaryOperator(const UnaryOperator *UO);
   void VisitBinaryOperator(const BinaryOperator *BO);
-  void VisitCompoundAssignOperator(const CompoundAssignOperator *CAO);
+  void VisitCompoundAssignOperator(const BinaryOperator *CAO);
   void VisitMemberExpr(const MemberExpr *ME);
   void VisitCXXNewExpr(const CXXNewExpr *NE);
   void VisitCXXDeleteExpr(const CXXDeleteExpr *DE);
   void VisitCXXThisExpr(const CXXThisExpr *TE);
   void VisitCastExpr(const CastExpr *CE);
   void VisitImplicitCastExpr(const ImplicitCastExpr *ICE);
   void VisitCallExpr(const CallExpr *CE);
   void VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *TTE);

clang/include/clang/AST/RecursiveASTVisitor.h

 #define OPERATOR(NAME) GENERAL_BINOP_FALLBACK(NAME, BinaryOperator)
   BINOP_LIST()
 #undef OPERATOR
 
 // Define Traverse*(), WalkUpFrom*(), and Visit*() for compound
 // assignment methods.  Compound assignment operators are not
 // classes in themselves (they're all opcodes in
 // CompoundAssignOperator) but do have visitors.
-#define OPERATOR(NAME)                                                         \
-  GENERAL_BINOP_FALLBACK(NAME##Assign, CompoundAssignOperator)
+#define OPERATOR(NAME) GENERAL_BINOP_FALLBACK(NAME##Assign, BinaryOperator)
 
   CAO_LIST()
+
 #undef OPERATOR
 #undef GENERAL_BINOP_FALLBACK
 
 // ---- Methods on Types ----
 // FIXME: revamp to take TypeLoc's rather than Types.
 
 // Declare Traverse*() for all concrete Type classes.
 #define ABSTRACT_TYPE(CLASS, BASE)
case BO_##NAME:                                                              \
     DISPATCH_STMT(Bin##NAME, BinaryOperator, S);
 
       BINOP_LIST()
 #undef OPERATOR
 #undef BINOP_LIST
 
 #define OPERATOR(NAME)                                                         \
   case BO_##NAME##Assign:                                                      \
-    DISPATCH_STMT(Bin##NAME##Assign, CompoundAssignOperator, S);
+    DISPATCH_STMT(Bin##NAME##Assign, BinaryOperator, S);
 
       CAO_LIST()
 #undef OPERATOR
 #undef CAO_LIST
     }
   } else if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(S)) {
     switch (UnOp->getOpcode()) {
 #define OPERATOR(NAME)                                                         \

 DEF_TRAVERSE_STMT(CUDAKernelCallExpr, {})
 
 // These operators (all of them) do not need any action except
 // iterating over the children.
 DEF_TRAVERSE_STMT(BinaryConditionalOperator, {})
 DEF_TRAVERSE_STMT(ConditionalOperator, {})
 DEF_TRAVERSE_STMT(UnaryOperator, {})
 DEF_TRAVERSE_STMT(BinaryOperator, {})
-DEF_TRAVERSE_STMT(CompoundAssignOperator, {})
 DEF_TRAVERSE_STMT(CXXNoexceptExpr, {})
 DEF_TRAVERSE_STMT(PackExpansionExpr, {})
 DEF_TRAVERSE_STMT(SizeOfPackExpr, {})
 DEF_TRAVERSE_STMT(SubstNonTypeTemplateParmPackExpr, {})
 DEF_TRAVERSE_STMT(SubstNonTypeTemplateParmExpr, {})
 DEF_TRAVERSE_STMT(FunctionParmPackExpr, {})
 DEF_TRAVERSE_STMT(CXXFoldExpr, {})
 DEF_TRAVERSE_STMT(AtomicExpr, {})

clang/include/clang/AST/Stmt.h

protected:
 
   class BinaryOperatorBitfields {
     friend class BinaryOperator;
 
     unsigned : NumExprBits;
 
     unsigned Opc : 6;
 
-    /// This is only meaningful for operations on floating point
-    /// types and 0 otherwise.
-    unsigned FPFeatures : 8;
-
     SourceLocation OpLoc;
   };
 
   class InitListExprBitfields {
     friend class InitListExpr;
 
     unsigned : NumExprBits;
 
class CXXOperatorCallExprBitfields {
     friend class ASTStmtReader;
     friend class CXXOperatorCallExpr;
 
     unsigned : NumCallExprBits;
 
     /// The kind of this overloaded operator. One of the enumerator
     /// value of OverloadedOperatorKind.
     unsigned OperatorKind : 6;
-
-    // Only meaningful for floating point types.
-    unsigned FPFeatures : 8;
   };
 
   class CXXRewrittenBinaryOperatorBitfields {
     friend class ASTStmtReader;
     friend class CXXRewrittenBinaryOperator;
 
     unsigned : NumCallExprBits;
 

clang/include/clang/AST/StmtVisitor.h

if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
       case BO_Cmp:       DISPATCH(BinCmp,       BinaryOperator);
 
       case BO_And:       DISPATCH(BinAnd,       BinaryOperator);
       case BO_Xor:       DISPATCH(BinXor,       BinaryOperator);
       case BO_Or :       DISPATCH(BinOr,        BinaryOperator);
       case BO_LAnd:      DISPATCH(BinLAnd,      BinaryOperator);
       case BO_LOr :      DISPATCH(BinLOr,       BinaryOperator);
       case BO_Assign:    DISPATCH(BinAssign,    BinaryOperator);
-      case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator);
-      case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator);
-      case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator);
-      case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator);
-      case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator);
-      case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator);
-      case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator);
-      case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator);
-      case BO_OrAssign:  DISPATCH(BinOrAssign,  CompoundAssignOperator);
-      case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator);
+      case BO_MulAssign: DISPATCH(BinMulAssign, BinaryOperator);
+      case BO_DivAssign: DISPATCH(BinDivAssign, BinaryOperator);
+      case BO_RemAssign: DISPATCH(BinRemAssign, BinaryOperator);
+      case BO_AddAssign: DISPATCH(BinAddAssign, BinaryOperator);
+      case BO_SubAssign: DISPATCH(BinSubAssign, BinaryOperator);
+      case BO_ShlAssign: DISPATCH(BinShlAssign, BinaryOperator);
+      case BO_ShrAssign: DISPATCH(BinShrAssign, BinaryOperator);
+      case BO_AndAssign: DISPATCH(BinAndAssign, BinaryOperator);
+      case BO_OrAssign:  DISPATCH(BinOrAssign,  BinaryOperator);
+      case BO_XorAssign: DISPATCH(BinXorAssign, BinaryOperator);
       case BO_Comma:     DISPATCH(BinComma,     BinaryOperator);
       }
     } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) {
       switch (UnOp->getOpcode()) {
       case UO_PostInc:   DISPATCH(UnaryPostInc,   UnaryOperator);
       case UO_PostDec:   DISPATCH(UnaryPostDec,   UnaryOperator);
       case UO_PreInc:    DISPATCH(UnaryPreInc,    UnaryOperator);
       case UO_PreDec:    DISPATCH(UnaryPreDec,    UnaryOperator);
       case UO_AddrOf:    DISPATCH(UnaryAddrOf,    UnaryOperator);
       case UO_Deref:     DISPATCH(UnaryDeref,     UnaryOperator);
       case UO_Plus:      DISPATCH(UnaryPlus,      UnaryOperator);
       case UO_Minus:     DISPATCH(UnaryMinus,     UnaryOperator);
       case UO_Not:       DISPATCH(UnaryNot,       UnaryOperator);
       case UO_LNot:      DISPATCH(UnaryLNot,      UnaryOperator);
       case UO_Real:      DISPATCH(UnaryReal,      UnaryOperator);
       case UO_Imag:      DISPATCH(UnaryImag,      UnaryOperator);
       case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator);
       case UO_Coawait:   DISPATCH(UnaryCoawait,   UnaryOperator);
#define BINOP_FALLBACK(NAME) \
   BINOP_FALLBACK(LAnd)  BINOP_FALLBACK(LOr)
 
   BINOP_FALLBACK(Assign)
   BINOP_FALLBACK(Comma)
 #undef BINOP_FALLBACK
 
   // If the implementation doesn't implement compound assignment operator
   // methods, fall back on VisitCompoundAssignOperator.
-#define CAO_FALLBACK(NAME) \
-  RetTy VisitBin ## NAME(PTR(CompoundAssignOperator) S, ParamTys... P) { \
-    DISPATCH(CompoundAssignOperator, CompoundAssignOperator); \
+#define CAO_FALLBACK(NAME)                                                     \
+  RetTy VisitBin##NAME(PTR(BinaryOperator) S, ParamTys... P) {                 \
+    DISPATCH(BinAssign, BinaryOperator);                                       \
   }
   CAO_FALLBACK(MulAssign) CAO_FALLBACK(DivAssign) CAO_FALLBACK(RemAssign)
   CAO_FALLBACK(AddAssign) CAO_FALLBACK(SubAssign) CAO_FALLBACK(ShlAssign)
   CAO_FALLBACK(ShrAssign) CAO_FALLBACK(AndAssign) CAO_FALLBACK(OrAssign)
   CAO_FALLBACK(XorAssign)
 #undef CAO_FALLBACK
 
   // If the implementation doesn't implement unary operator methods, fall back

clang/include/clang/AST/TextNodeDumper.h

#include "clang/AST/AttrTextNodeDump.inc"
   void VisitStringLiteral(const StringLiteral *Str);
   void VisitInitListExpr(const InitListExpr *ILE);
   void VisitGenericSelectionExpr(const GenericSelectionExpr *E);
   void VisitUnaryOperator(const UnaryOperator *Node);
   void VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *Node);
   void VisitMemberExpr(const MemberExpr *Node);
   void VisitExtVectorElementExpr(const ExtVectorElementExpr *Node);
   void VisitBinaryOperator(const BinaryOperator *Node);
-  void VisitCompoundAssignOperator(const CompoundAssignOperator *Node);
   void VisitAddrLabelExpr(const AddrLabelExpr *Node);
   void VisitCXXNamedCastExpr(const CXXNamedCastExpr *Node);
   void VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *Node);
   void VisitCXXThisExpr(const CXXThisExpr *Node);
   void VisitCXXFunctionalCastExpr(const CXXFunctionalCastExpr *Node);
   void VisitCXXUnresolvedConstructExpr(const CXXUnresolvedConstructExpr *Node);
   void VisitCXXConstructExpr(const CXXConstructExpr *Node);
   void VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *Node);

clang/include/clang/Basic/LangOptions.h

#include "clang/Basic/LangOptions.def"
 
   /// Return the OpenCL C or C++ version as a VersionTuple.
   VersionTuple getOpenCLVersionTuple() const;
 };
 
 /// Floating point control options
 class FPOptions {
 public:
-  FPOptions() : fp_contract(LangOptions::FPC_Off),
-                fenv_access(LangOptions::FEA_Off),
-                rounding(LangOptions::FPR_ToNearest),
-                exceptions(LangOptions::FPE_Ignore)
-        {}
+  FPOptions()
+      : fp_contract(LangOptions::FPC_Off), fenv_access(LangOptions::FEA_Off),
+        exceptions(LangOptions::FPE_Ignore) {}
 
   // Used for serializing.
   explicit FPOptions(unsigned I)
       : fp_contract(static_cast<LangOptions::FPContractModeKind>(I & 3)),
         fenv_access(static_cast<LangOptions::FEnvAccessModeKind>((I >> 2) & 1)),
         rounding(static_cast<LangOptions::FPRoundingModeKind>((I >> 3) & 7)),
         exceptions(static_cast<LangOptions::FPExceptionModeKind>((I >> 6) & 3))
         {}
 
   explicit FPOptions(const LangOptions &LangOpts)
       : fp_contract(LangOpts.getDefaultFPContractMode()),
-        fenv_access(LangOptions::FEA_Off),
-        rounding(LangOptions::FPR_ToNearest),
-        exceptions(LangOptions::FPE_Ignore)
-        {}
+        fenv_access(LangOptions::FEA_Off), rounding(LangOptions::FPR_ToNearest),
+        exceptions(LangOptions::FPE_Ignore) {}
   // FIXME: Use getDefaultFEnvAccessMode() when available.
 
   bool allowFPContractWithinStatement() const {
     return fp_contract == LangOptions::FPC_On;
   }
 
   bool allowFPContractAcrossStatement() const {
     return fp_contract == LangOptions::FPC_Fast;
   }
 
   void setAllowFPContractWithinStatement() {
     fp_contract = LangOptions::FPC_On;
   }
 
   void setAllowFPContractAcrossStatement() {
     fp_contract = LangOptions::FPC_Fast;
   }
 
   void setDisallowFPContract() { fp_contract = LangOptions::FPC_Off; }
 
   bool allowFEnvAccess() const {
     return fenv_access == LangOptions::FEA_On;
   }
 
   void setAllowFEnvAccess() {
public:
   bool isFPConstrained() const {
     return getRoundingMode() != LangOptions::FPR_ToNearest ||
            getExceptionMode() != LangOptions::FPE_Ignore ||
            allowFEnvAccess();
   }
 
   /// Used to serialize this.
   unsigned getInt() const {
-    return fp_contract | (fenv_access << 2) | (rounding << 3)
-        | (exceptions << 6);
+    return fp_contract | (fenv_access << 2) | (rounding << 3) |
+           (exceptions << 6);
   }
 
 private:
   /// Adjust BinaryOperatorBitfields::FPFeatures and
   /// CXXOperatorCallExprBitfields::FPFeatures to match the total bit-field size
   /// of these fields.
   unsigned fp_contract : 2;
   unsigned fenv_access : 1;

clang/include/clang/Basic/StmtNodes.td

 def OffsetOfExpr : StmtNode<Expr>;
 def UnaryExprOrTypeTraitExpr : StmtNode<Expr>;
 def ArraySubscriptExpr : StmtNode<Expr>;
 def OMPArraySectionExpr : StmtNode<Expr>;
 def CallExpr : StmtNode<Expr>;
 def MemberExpr : StmtNode<Expr>;
 def CastExpr : StmtNode<Expr, 1>;
 def BinaryOperator : StmtNode<Expr>;
-def CompoundAssignOperator : StmtNode<BinaryOperator>;
 def AbstractConditionalOperator : StmtNode<Expr, 1>;
 def ConditionalOperator : StmtNode<AbstractConditionalOperator>;
 def BinaryConditionalOperator : StmtNode<AbstractConditionalOperator>;
 def ImplicitCastExpr : StmtNode<CastExpr>;
 def ExplicitCastExpr : StmtNode<CastExpr, 1>;
 def CStyleCastExpr : StmtNode<ExplicitCastExpr>;
 def CompoundLiteralExpr : StmtNode<Expr>;
 def ExtVectorElementExpr : StmtNode<Expr>;

clang/include/clang/Serialization/ASTBitCodes.h

enum StmtCode {
       EXPR_CALL,
 
       /// A MemberExpr record.
       EXPR_MEMBER,
 
       /// A BinaryOperator record.
       EXPR_BINARY_OPERATOR,
 
-      /// A CompoundAssignOperator record.
+      /// Defunct: CompoundAssignOperator is part of BinaryOperator
       EXPR_COMPOUND_ASSIGN_OPERATOR,
 
       /// A ConditionOperator record.
       EXPR_CONDITIONAL_OPERATOR,
 
       /// An ImplicitCastExpr record.
       EXPR_IMPLICIT_CAST,
 
       /// A CStyleCastExpr record.
enum StmtCode {
       EXPR_USER_DEFINED_LITERAL,
 
       /// A CXXStdInitializerListExpr record.
       EXPR_CXX_STD_INITIALIZER_LIST,
 
       /// A CXXBoolLiteralExpr record.
       EXPR_CXX_BOOL_LITERAL,
 
       EXPR_CXX_NULL_PTR_LITERAL,  // CXXNullPtrLiteralExpr
       EXPR_CXX_TYPEID_EXPR,       // CXXTypeidExpr (of expr).
       EXPR_CXX_TYPEID_TYPE,       // CXXTypeidExpr (of type).
       EXPR_CXX_THIS,              // CXXThisExpr
       EXPR_CXX_THROW,             // CXXThrowExpr
       EXPR_CXX_DEFAULT_ARG,       // CXXDefaultArgExpr
       EXPR_CXX_DEFAULT_INIT,      // CXXDefaultInitExpr
       EXPR_CXX_BIND_TEMPORARY,    // CXXBindTemporaryExpr
 
       EXPR_CXX_SCALAR_VALUE_INIT, // CXXScalarValueInitExpr
       EXPR_CXX_NEW,               // CXXNewExpr
       EXPR_CXX_DELETE,            // CXXDeleteExpr
       EXPR_CXX_PSEUDO_DESTRUCTOR, // CXXPseudoDestructorExpr
 
       EXPR_EXPR_WITH_CLEANUPS,    // ExprWithCleanups
 
       EXPR_CXX_DEPENDENT_SCOPE_MEMBER,   // CXXDependentScopeMemberExpr
       EXPR_CXX_DEPENDENT_SCOPE_DECL_REF, // DependentScopeDeclRefExpr
       EXPR_CXX_UNRESOLVED_CONSTRUCT,     // CXXUnresolvedConstructExpr
       EXPR_CXX_UNRESOLVED_MEMBER,        // UnresolvedMemberExpr
       EXPR_CXX_UNRESOLVED_LOOKUP,        // UnresolvedLookupExpr
 
       EXPR_CXX_EXPRESSION_TRAIT,  // ExpressionTraitExpr
       EXPR_CXX_NOEXCEPT,          // CXXNoexceptExpr
 
       EXPR_OPAQUE_VALUE,          // OpaqueValueExpr
       EXPR_BINARY_CONDITIONAL_OPERATOR,  // BinaryConditionalOperator
       EXPR_TYPE_TRAIT,            // TypeTraitExpr
       EXPR_ARRAY_TYPE_TRAIT,      // ArrayTypeTraitIntExpr
 
       EXPR_PACK_EXPANSION,        // PackExpansionExpr
       EXPR_SIZEOF_PACK,           // SizeOfPackExpr
       EXPR_SUBST_NON_TYPE_TEMPLATE_PARM, // SubstNonTypeTemplateParmExpr
       EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK,// SubstNonTypeTemplateParmPackExpr
       EXPR_FUNCTION_PARM_PACK,    // FunctionParmPackExpr
       EXPR_MATERIALIZE_TEMPORARY, // MaterializeTemporaryExpr
       EXPR_CXX_FOLD,              // CXXFoldExpr
       EXPR_CONCEPT_SPECIALIZATION,// ConceptSpecializationExpr
       EXPR_REQUIRES,              // RequiresExpr
 
       // CUDA
       EXPR_CUDA_KERNEL_CALL,       // CUDAKernelCallExpr
 
       // OpenCL
       EXPR_ASTYPE,                 // AsTypeExpr
 
       // Microsoft
       EXPR_CXX_PROPERTY_REF_EXPR, // MSPropertyRefExpr
       EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR, // MSPropertySubscriptExpr
       EXPR_CXX_UUIDOF_EXPR,       // CXXUuidofExpr (of expr).
       EXPR_CXX_UUIDOF_TYPE,       // CXXUuidofExpr (of type).
       STMT_SEH_LEAVE,             // SEHLeaveStmt
       STMT_SEH_EXCEPT,            // SEHExceptStmt
       STMT_SEH_FINALLY,           // SEHFinallyStmt
       STMT_SEH_TRY,               // SEHTryStmt
 
       // OpenMP directives
       STMT_OMP_PARALLEL_DIRECTIVE,
enum StmtCode {
       STMT_OMP_TARGET_TEAMS_DIRECTIVE,
       STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE,
       STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE,
       STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE,
       STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE,
       EXPR_OMP_ARRAY_SECTION,
 
       // ARC
       EXPR_OBJC_BRIDGED_CAST,     // ObjCBridgedCastExpr
 
       STMT_MS_DEPENDENT_EXISTS,   // MSDependentExistsStmt
       EXPR_LAMBDA,                // LambdaExpr
       STMT_COROUTINE_BODY,
       STMT_CORETURN,
       EXPR_COAWAIT,
       EXPR_COYIELD,
       EXPR_DEPENDENT_COAWAIT,
     };
 

clang/lib/AST/ASTImporter.cpp

public:
     ExpectedStmt VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E);
     ExpectedStmt VisitBinaryOperator(BinaryOperator *E);
     ExpectedStmt VisitConditionalOperator(ConditionalOperator *E);
     ExpectedStmt VisitBinaryConditionalOperator(BinaryConditionalOperator *E);
     ExpectedStmt VisitOpaqueValueExpr(OpaqueValueExpr *E);
     ExpectedStmt VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E);
     ExpectedStmt VisitExpressionTraitExpr(ExpressionTraitExpr *E);
     ExpectedStmt VisitArraySubscriptExpr(ArraySubscriptExpr *E);
-    ExpectedStmt VisitCompoundAssignOperator(CompoundAssignOperator *E);
     ExpectedStmt VisitImplicitCastExpr(ImplicitCastExpr *E);
     ExpectedStmt VisitExplicitCastExpr(ExplicitCastExpr *E);
     ExpectedStmt VisitOffsetOfExpr(OffsetOfExpr *OE);
     ExpectedStmt VisitCXXThrowExpr(CXXThrowExpr *E);
     ExpectedStmt VisitCXXNoexceptExpr(CXXNoexceptExpr *E);
     ExpectedStmt VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E);
     ExpectedStmt VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
     ExpectedStmt VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);

 }
 
 ExpectedStmt ASTNodeImporter::VisitBinaryOperator(BinaryOperator *E) {
   Error Err = Error::success();
   auto ToLHS = importChecked(Err, E->getLHS());
   auto ToRHS = importChecked(Err, E->getRHS());
   auto ToType = importChecked(Err, E->getType());
   auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
+  auto HasFPFeatures = E->HasFPFeatures();
   if (Err)
     return std::move(Err);
 
-  return new (Importer.getToContext()) BinaryOperator(
-      ToLHS, ToRHS, E->getOpcode(), ToType, E->getValueKind(),
-      E->getObjectKind(), ToOperatorLoc, E->getFPFeatures());
+  if (E->IsCompoundAssign()) {
+    auto ToComputationLHSType = importChecked(Err, E->getComputationLHSType());
+    auto ToComputationResultType =
+        importChecked(Err, E->getComputationResultType());
+    if (Err)
+      return std::move(Err);
+    return BinaryOperator::Create(
+        Importer.getToContext(), ToLHS, ToRHS, E->getOpcode(), ToType,
+        E->getValueKind(), E->getObjectKind(), ToComputationLHSType,
+        ToComputationResultType, ToOperatorLoc,
+        HasFPFeatures ? E->getFPFeatures() : FPOptions());
+  }
+  return BinaryOperator::Create(
+      Importer.getToContext(), ToLHS, ToRHS, E->getOpcode(), ToType,
+      E->getValueKind(), E->getObjectKind(), ToOperatorLoc,
+      HasFPFeatures ? E->getFPFeatures() : FPOptions());
 }
 
 ExpectedStmt ASTNodeImporter::VisitConditionalOperator(ConditionalOperator *E) {
   Error Err = Error::success();
   auto ToCond = importChecked(Err, E->getCond());
   auto ToQuestionLoc = importChecked(Err, E->getQuestionLoc());
   auto ToLHS = importChecked(Err, E->getLHS());
   auto ToColonLoc = importChecked(Err, E->getColonLoc());
ExpectedStmt ASTNodeImporter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
   if (Err)
     return std::move(Err);
 
   return new (Importer.getToContext()) ArraySubscriptExpr(
       ToLHS, ToRHS, ToType, E->getValueKind(), E->getObjectKind(),
       ToRBracketLoc);
 }
 
-ExpectedStmt
-ASTNodeImporter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
-  Error Err = Error::success();
-  auto ToLHS = importChecked(Err, E->getLHS());
-  auto ToRHS = importChecked(Err, E->getRHS());
-  auto ToType = importChecked(Err, E->getType());
-  auto ToComputationLHSType = importChecked(Err, E->getComputationLHSType());
-  auto ToComputationResultType =
-      importChecked(Err, E->getComputationResultType());
-  auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
-  if (Err)
-    return std::move(Err);
-
-  return new (Importer.getToContext()) CompoundAssignOperator(
-      ToLHS, ToRHS, E->getOpcode(), ToType, E->getValueKind(),
-      E->getObjectKind(), ToComputationLHSType, ToComputationResultType,
-      ToOperatorLoc, E->getFPFeatures());
-}
-
 Expected<CXXCastPath>
 ASTNodeImporter::ImportCastPath(CastExpr *CE) {
   CXXCastPath Path;
   for (auto I = CE->path_begin(), E = CE->path_end(); I != E; ++I) {
     if (auto SpecOrErr = import(*I))
       Path.push_back(*SpecOrErr);
     else
       return SpecOrErr.takeError();
   }
   return Path;
 }
 
 ExpectedStmt ASTNodeImporter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
ExpectedStmt ASTNodeImporter::VisitCallExpr(CallExpr *E) {
   if (const auto *OCE = dyn_cast<CXXOperatorCallExpr>(E)) {
     return CXXOperatorCallExpr::Create(
         Importer.getToContext(), OCE->getOperator(), ToCallee, ToArgs, ToType,
         OCE->getValueKind(), ToRParenLoc, OCE->getFPFeatures(),
         OCE->getADLCallKind());
   }
 
   return CallExpr::Create(Importer.getToContext(), ToCallee, ToArgs, ToType,
-                          E->getValueKind(), ToRParenLoc, /*MinNumArgs=*/0,
-                          E->getADLCallKind());
+                          E->getValueKind(), ToRParenLoc, FPOptions(),
+                          /*MinNumArgs=*/0, E->getADLCallKind());
 }
 
 ExpectedStmt ASTNodeImporter::VisitLambdaExpr(LambdaExpr *E) {
   CXXRecordDecl *FromClass = E->getLambdaClass();
   auto ToClassOrErr = import(FromClass);
   if (!ToClassOrErr)
     return ToClassOrErr.takeError();
   CXXRecordDecl *ToClass = *ToClassOrErr;

clang/lib/AST/Expr.cpp

 
 
 //===----------------------------------------------------------------------===//
 // Postfix Operators.
 //===----------------------------------------------------------------------===//
 
 CallExpr::CallExpr(StmtClass SC, Expr *Fn, ArrayRef<Expr *> PreArgs,
                    ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK,
-                   SourceLocation RParenLoc, unsigned MinNumArgs,
-                   ADLCallKind UsesADL)
+                   SourceLocation RParenLoc, FPOptions FP_Features,
+                   unsigned MinNumArgs, ADLCallKind UsesADL)
     : Expr(SC, Ty, VK, OK_Ordinary), RParenLoc(RParenLoc) {
   NumArgs = std::max<unsigned>(Args.size(), MinNumArgs);
   unsigned NumPreArgs = PreArgs.size();
+  FPFeatures = FP_Features;
   CallExprBits.NumPreArgs = NumPreArgs;
   assert((NumPreArgs == getNumPreArgs()) && "NumPreArgs overflow!");
 
   unsigned OffsetToTrailingObjects = offsetToTrailingObjects(SC);
   CallExprBits.OffsetToTrailingObjects = OffsetToTrailingObjects;
   assert((CallExprBits.OffsetToTrailingObjects == OffsetToTrailingObjects) &&
          "OffsetToTrailingObjects overflow!");
 
CallExpr::CallExpr(StmtClass SC, unsigned NumPreArgs, unsigned NumArgs,
   unsigned OffsetToTrailingObjects = offsetToTrailingObjects(SC);
   CallExprBits.OffsetToTrailingObjects = OffsetToTrailingObjects;
   assert((CallExprBits.OffsetToTrailingObjects == OffsetToTrailingObjects) &&
          "OffsetToTrailingObjects overflow!");
 }
 
 CallExpr *CallExpr::Create(const ASTContext &Ctx, Expr *Fn,
                            ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK,
-                           SourceLocation RParenLoc, unsigned MinNumArgs,
-                           ADLCallKind UsesADL) {
+                           SourceLocation RParenLoc, FPOptions FP_Features,
+                           unsigned MinNumArgs, ADLCallKind UsesADL) {
   unsigned NumArgs = std::max<unsigned>(Args.size(), MinNumArgs);
   unsigned SizeOfTrailingObjects =
       CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/0, NumArgs);
   void *Mem =
       Ctx.Allocate(sizeof(CallExpr) + SizeOfTrailingObjects, alignof(CallExpr));
   return new (Mem) CallExpr(CallExprClass, Fn, /*PreArgs=*/{}, Args, Ty, VK,
-                            RParenLoc, MinNumArgs, UsesADL);
+                            RParenLoc, FP_Features, MinNumArgs, UsesADL);
 }
 
 CallExpr *CallExpr::CreateTemporary(void *Mem, Expr *Fn, QualType Ty,
                                     ExprValueKind VK, SourceLocation RParenLoc,
                                     ADLCallKind UsesADL) {
   assert(!(reinterpret_cast<uintptr_t>(Mem) % alignof(CallExpr)) &&
          "Misaligned memory in CallExpr::CreateTemporary!");
-  return new (Mem) CallExpr(CallExprClass, Fn, /*PreArgs=*/{}, /*Args=*/{}, Ty,
-                            VK, RParenLoc, /*MinNumArgs=*/0, UsesADL);
+  return new (Mem)
+      CallExpr(CallExprClass, Fn, /*PreArgs=*/{}, /*Args=*/{}, Ty, VK,
+               RParenLoc, FPOptions(), /*MinNumArgs=*/0, UsesADL);
 }
 
 CallExpr *CallExpr::CreateEmpty(const ASTContext &Ctx, unsigned NumArgs,
                                 EmptyShell Empty) {
   unsigned SizeOfTrailingObjects =
       CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/0, NumArgs);
   void *Mem =
       Ctx.Allocate(sizeof(CallExpr) + SizeOfTrailingObjects, alignof(CallExpr));
case BinaryOperatorClass: {
     if (BO->isAssignmentOp())
       return false;
     WarnE = this;
     Loc = BO->getOperatorLoc();
     R1 = BO->getLHS()->getSourceRange();
     R2 = BO->getRHS()->getSourceRange();
     return true;
   }
-  case CompoundAssignOperatorClass:
   case VAArgExprClass:
   case AtomicExprClass:
     return false;
 
   case ConditionalOperatorClass: {
     // If only one of the LHS or RHS is a warning, the operator might
     // be being used for control flow. Only warn if both the LHS and
     // RHS are warnings.
bool Expr::HasSideEffects(const ASTContext &Ctx,
   case BlockExprClass:
   case CXXBindTemporaryExprClass:
     if (!IncludePossibleEffects)
       break;
     return true;
 
   case MSPropertyRefExprClass:
   case MSPropertySubscriptExprClass:
-  case CompoundAssignOperatorClass:
   case VAArgExprClass:
   case AtomicExprClass:
   case CXXThrowExprClass:
   case CXXNewExprClass:
   case CXXDeleteExprClass:
   case CoawaitExprClass:
   case DependentCoawaitExprClass:
   case CoyieldExprClass:

 
 ParenListExpr *ParenListExpr::CreateEmpty(const ASTContext &Ctx,
                                           unsigned NumExprs) {
   void *Mem =
       Ctx.Allocate(totalSizeToAlloc<Stmt *>(NumExprs), alignof(ParenListExpr));
   return new (Mem) ParenListExpr(EmptyShell(), NumExprs);
 }
 
+BinaryOperator *BinaryOperator::CreateEmpty(const ASTContext &C,
+                                            unsigned hasFPFeatures,
+                                            unsigned isCompound) {
+  unsigned SizeOfTrailingObjects =
+      BinaryOperator::sizeOfTrailingObjects(hasFPFeatures, isCompound);
+  void *Mem = C.Allocate(sizeof(BinaryOperator) + SizeOfTrailingObjects,
+                         alignof(BinaryOperator));
+  return new (Mem) BinaryOperator(EmptyShell(), hasFPFeatures, isCompound);
+}
+
+BinaryOperator *BinaryOperator::Create(const ASTContext &C, Expr *lhs,
+                                       Expr *rhs, Opcode opc, QualType ResTy,
+                                       ExprValueKind VK, ExprObjectKind OK,
+                                       SourceLocation opLoc,
+                                       FPOptions FPFeatures) {
+  bool hasFPFeatures = true;
+  unsigned SizeOfTrailingObjects =
+      BinaryOperator::sizeOfTrailingObjects(hasFPFeatures, 0);
+  void *Mem = C.Allocate(sizeof(BinaryOperator) + SizeOfTrailingObjects,
+                         alignof(BinaryOperator));
+  return new (Mem)
+      BinaryOperator(lhs, rhs, opc, ResTy, VK, OK, opLoc, FPFeatures);
+}
+
+BinaryOperator *
+BinaryOperator::Create(const ASTContext &C, Expr *lhs, Expr *rhs, Opcode opc,
+                       QualType ResTy, ExprValueKind VK, ExprObjectKind OK,
+                       QualType CompLHSType, QualType CompResultType,
+                       SourceLocation opLoc, FPOptions FPFeatures) {
+  bool hasFPFeatures = true;
+  unsigned SizeOfTrailingObjects =
+      BinaryOperator::sizeOfTrailingObjects(hasFPFeatures, 1);
+  void *Mem = C.Allocate(sizeof(BinaryOperator) + SizeOfTrailingObjects,
+                         alignof(BinaryOperator));
+  return new (Mem) BinaryOperator(lhs, rhs, opc, ResTy, VK, OK, CompLHSType,
+                                  CompResultType, opLoc, FPFeatures);
+}
+
 const OpaqueValueExpr *OpaqueValueExpr::findInCopyConstruct(const Expr *e) {
   if (const ExprWithCleanups *ewc = dyn_cast<ExprWithCleanups>(e))
     e = ewc->getSubExpr();
   if (const MaterializeTemporaryExpr *m = dyn_cast<MaterializeTemporaryExpr>(e))
     e = m->getSubExpr();
   e = cast<CXXConstructExpr>(e)->getArg(0);
   while (const ImplicitCastExpr *ice = dyn_cast<ImplicitCastExpr>(e))
     e = ice->getSubExpr();
   return cast<OpaqueValueExpr>(e);
 }
 
 PseudoObjectExpr *PseudoObjectExpr::Create(const ASTContext &Context,
                                            EmptyShell sh,
                                            unsigned numSemanticExprs) {
   void *buffer =
       Context.Allocate(totalSizeToAlloc<Expr *>(1 + numSemanticExprs),
                        alignof(PseudoObjectExpr));
   return new(buffer) PseudoObjectExpr(sh, numSemanticExprs);
 }
 
 PseudoObjectExpr::PseudoObjectExpr(EmptyShell shell, unsigned numSemanticExprs)
   : Expr(PseudoObjectExprClass, shell) {
   PseudoObjectExprBits.NumSubExprs = numSemanticExprs + 1;

clang/lib/AST/ExprCXX.cpp

 
 CXXOperatorCallExpr::CXXOperatorCallExpr(OverloadedOperatorKind OpKind,
                                          Expr *Fn, ArrayRef<Expr *> Args,
                                          QualType Ty, ExprValueKind VK,
                                          SourceLocation OperatorLoc,
                                          FPOptions FPFeatures,
                                          ADLCallKind UsesADL)
     : CallExpr(CXXOperatorCallExprClass, Fn, /*PreArgs=*/{}, Args, Ty, VK,
-               OperatorLoc, /*MinNumArgs=*/0, UsesADL) {
+               OperatorLoc, FPFeatures, /*MinNumArgs=*/0, UsesADL) {
   CXXOperatorCallExprBits.OperatorKind = OpKind;
-  CXXOperatorCallExprBits.FPFeatures = FPFeatures.getInt();
   assert(
       (CXXOperatorCallExprBits.OperatorKind == static_cast<unsigned>(OpKind)) &&
       "OperatorKind overflow!");
-  assert((CXXOperatorCallExprBits.FPFeatures == FPFeatures.getInt()) &&
-         "FPFeatures overflow!");
   Range = getSourceRangeImpl();
 }
 
 CXXOperatorCallExpr::CXXOperatorCallExpr(unsigned NumArgs, EmptyShell Empty)
     : CallExpr(CXXOperatorCallExprClass, /*NumPreArgs=*/0, NumArgs, Empty) {}
 
 CXXOperatorCallExpr *CXXOperatorCallExpr::Create(
     const ASTContext &Ctx, OverloadedOperatorKind OpKind, Expr *Fn,
if (Kind == OO_PlusPlus || Kind == OO_MinusMinus) {
     return getOperatorLoc();
   }
 }
 
 CXXMemberCallExpr::CXXMemberCallExpr(Expr *Fn, ArrayRef<Expr *> Args,
                                      QualType Ty, ExprValueKind VK,
                                      SourceLocation RP, unsigned MinNumArgs)
     : CallExpr(CXXMemberCallExprClass, Fn, /*PreArgs=*/{}, Args, Ty, VK, RP,
-               MinNumArgs, NotADL) {}
+               FPOptions(), MinNumArgs, NotADL) {}
 
 CXXMemberCallExpr::CXXMemberCallExpr(unsigned NumArgs, EmptyShell Empty)
     : CallExpr(CXXMemberCallExprClass, /*NumPreArgs=*/0, NumArgs, Empty) {}
 
 CXXMemberCallExpr *CXXMemberCallExpr::Create(const ASTContext &Ctx, Expr *Fn,
                                              ArrayRef<Expr *> Args, QualType Ty,
                                              ExprValueKind VK,
                                              SourceLocation RP,
SourceLocation CXXFunctionalCastExpr::getEndLoc() const {
   return RParenLoc.isValid() ? RParenLoc : getSubExpr()->getEndLoc();
 }
 
 UserDefinedLiteral::UserDefinedLiteral(Expr *Fn, ArrayRef<Expr *> Args,
                                        QualType Ty, ExprValueKind VK,
                                        SourceLocation LitEndLoc,
                                        SourceLocation SuffixLoc)
     : CallExpr(UserDefinedLiteralClass, Fn, /*PreArgs=*/{}, Args, Ty, VK,
-               LitEndLoc, /*MinNumArgs=*/0, NotADL),
+               LitEndLoc, FPOptions(), /*MinNumArgs=*/0, NotADL),
       UDSuffixLoc(SuffixLoc) {}
 
 UserDefinedLiteral::UserDefinedLiteral(unsigned NumArgs, EmptyShell Empty)
     : CallExpr(UserDefinedLiteralClass, /*NumPreArgs=*/0, NumArgs, Empty) {}
 
 UserDefinedLiteral *UserDefinedLiteral::Create(const ASTContext &Ctx, Expr *Fn,
                                                ArrayRef<Expr *> Args,
                                                QualType Ty, ExprValueKind VK,
TypeTraitExpr *TypeTraitExpr::CreateDeserialized(const ASTContext &C,
   return new (Mem) TypeTraitExpr(EmptyShell());
 }
 
 CUDAKernelCallExpr::CUDAKernelCallExpr(Expr *Fn, CallExpr *Config,
                                        ArrayRef<Expr *> Args, QualType Ty,
                                        ExprValueKind VK, SourceLocation RP,
                                        unsigned MinNumArgs)
     : CallExpr(CUDAKernelCallExprClass, Fn, /*PreArgs=*/Config, Args, Ty, VK,
-               RP, MinNumArgs, NotADL) {}
+               RP, FPOptions(), MinNumArgs, NotADL) {}
 
 CUDAKernelCallExpr::CUDAKernelCallExpr(unsigned NumArgs, EmptyShell Empty)
     : CallExpr(CUDAKernelCallExprClass, /*NumPreArgs=*/END_PREARG, NumArgs,
                Empty) {}
 
 CUDAKernelCallExpr *
 CUDAKernelCallExpr::Create(const ASTContext &Ctx, Expr *Fn, CallExpr *Config,
                            ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK,
CUDAKernelCallExpr *CUDAKernelCallExpr::CreateEmpty(const ASTContext &Ctx,
                                                     EmptyShell Empty) {
   // Allocate storage for the trailing objects of CallExpr.
   unsigned SizeOfTrailingObjects =
       CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/END_PREARG, NumArgs);
   void *Mem = Ctx.Allocate(sizeof(CUDAKernelCallExpr) + SizeOfTrailingObjects,
                            alignof(CUDAKernelCallExpr));
   return new (Mem) CUDAKernelCallExpr(NumArgs, Empty);
 }
 No newline at end of file

clang/lib/AST/ExprClassification.cpp

case Expr::ParenExprClass:
     // or a void expression if its result expression is, respectively, an
     // lvalue, a function designator, or a void expression.
   case Expr::GenericSelectionExprClass:
     if (cast<GenericSelectionExpr>(E)->isResultDependent())
       return Cl::CL_PRValue;
     return ClassifyInternal(Ctx,cast<GenericSelectionExpr>(E)->getResultExpr());
 
   case Expr::BinaryOperatorClass:
-  case Expr::CompoundAssignOperatorClass:
     // C doesn't have any binary expressions that are lvalues.
     if (Lang.CPlusPlus)
       return ClassifyBinaryOp(Ctx, cast<BinaryOperator>(E));
     return Cl::CL_PRValue;
 
   case Expr::CallExprClass:
   case Expr::CXXOperatorCallExprClass:
   case Expr::CXXMemberCallExprClass:

clang/lib/AST/ExprConstant.cpp

public:
   bool VisitUnaryImag(const UnaryOperator *E);
   bool VisitUnaryPreInc(const UnaryOperator *UO) {
     return VisitUnaryPreIncDec(UO);
   }
   bool VisitUnaryPreDec(const UnaryOperator *UO) {
     return VisitUnaryPreIncDec(UO);
   }
   bool VisitBinAssign(const BinaryOperator *BO);
-  bool VisitCompoundAssignOperator(const CompoundAssignOperator *CAO);
 
   bool VisitCastExpr(const CastExpr *E) {
     switch (E->getCastKind()) {
     default:
       return LValueExprEvaluatorBaseTy::VisitCastExpr(E);
 
     case CK_LValueBitCast:
       this->CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
bool LValueExprEvaluator::VisitUnaryPreIncDec(const UnaryOperator *UO) {
   if (!this->Visit(UO->getSubExpr()))
     return false;
 
   return handleIncDec(
       this->Info, UO, Result, UO->getSubExpr()->getType(),
       UO->isIncrementOp(), nullptr);
 }
 
-bool LValueExprEvaluator::VisitCompoundAssignOperator(
-    const CompoundAssignOperator *CAO) {
+bool LValueExprEvaluator::VisitBinAssign(const BinaryOperator *E) {
   if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
-    return Error(CAO);
+    return Error(E);
 
+  if (E->isCompoundAssignmentOp()) {
     APValue RHS;
 
     // The overall lvalue result is the result of evaluating the LHS.
-  if (!this->Visit(CAO->getLHS())) {
+    if (!this->Visit(E->getLHS())) {
       if (Info.noteFailure())
-      Evaluate(RHS, this->Info, CAO->getRHS());
+        Evaluate(RHS, this->Info, E->getRHS());
       return false;
     }
 
-  if (!Evaluate(RHS, this->Info, CAO->getRHS()))
+    if (!Evaluate(RHS, this->Info, E->getRHS()))
       return false;
 
     return handleCompoundAssignment(
-      this->Info, CAO,
-      Result, CAO->getLHS()->getType(), CAO->getComputationLHSType(),
-      CAO->getOpForCompoundAssignment(CAO->getOpcode()), RHS);
+        this->Info, E, Result, E->getLHS()->getType(),
+        E->getComputationLHSType(),
+        E->getOpForCompoundAssignment(E->getOpcode()), RHS);
   }
 
-bool LValueExprEvaluator::VisitBinAssign(const BinaryOperator *E) {
-  if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
-    return Error(E);
-
   APValue NewVal;
 
   if (!this->Visit(E->getLHS())) {
     if (Info.noteFailure())
       Evaluate(NewVal, this->Info, E->getRHS());
     return false;
   }
 

 #include "clang/AST/StmtNodes.inc"
   case Expr::PredefinedExprClass:
   case Expr::FloatingLiteralClass:
   case Expr::ImaginaryLiteralClass:
   case Expr::StringLiteralClass:
   case Expr::ArraySubscriptExprClass:
   case Expr::OMPArraySectionExprClass:
   case Expr::MemberExprClass:
-  case Expr::CompoundAssignOperatorClass:
   case Expr::CompoundLiteralExprClass:
   case Expr::ExtVectorElementExprClass:
   case Expr::DesignatedInitExprClass:
   case Expr::ArrayInitLoopExprClass:
   case Expr::ArrayInitIndexExprClass:
   case Expr::NoInitExprClass:
   case Expr::DesignatedInitUpdateExprClass:
   case Expr::ImplicitValueInitExprClass:

clang/lib/AST/ItaniumMangle.cpp

case Expr::ArraySubscriptExprClass: {
     // Array subscript is treated as a syntactically weird form of
     // binary operator.
     Out << "ix";
     mangleExpression(AE->getLHS());
     mangleExpression(AE->getRHS());
     break;
   }
 
-  case Expr::CompoundAssignOperatorClass: // fallthrough
   case Expr::BinaryOperatorClass: {
     const BinaryOperator *BO = cast<BinaryOperator>(E);
     if (BO->getOpcode() == BO_PtrMemD)
       Out << "ds";
     else
       mangleOperatorName(BinaryOperator::getOverloadedOperator(BO->getOpcode()),
                          /*Arity=*/2);
     mangleExpression(BO->getLHS());

clang/lib/AST/JSONNodeDumper.cpp

void JSONNodeDumper::VisitUnaryOperator(const UnaryOperator *UO) {
   JOS.attribute("isPostfix", UO->isPostfix());
   JOS.attribute("opcode", UnaryOperator::getOpcodeStr(UO->getOpcode()));
   if (!UO->canOverflow())
     JOS.attribute("canOverflow", false);
 }
 
 void JSONNodeDumper::VisitBinaryOperator(const BinaryOperator *BO) {
   JOS.attribute("opcode", BinaryOperator::getOpcodeStr(BO->getOpcode()));
-}
-
-void JSONNodeDumper::VisitCompoundAssignOperator(
-    const CompoundAssignOperator *CAO) {
-  VisitBinaryOperator(CAO);
-  JOS.attribute("computeLHSType", createQualType(CAO->getComputationLHSType()));
+  if (BO->isCompoundAssignmentOp()) {
+    JOS.attribute("computeLHSType",
+                  createQualType(BO->getComputationLHSType()));
     JOS.attribute("computeResultType",
-                createQualType(CAO->getComputationResultType()));
+                  createQualType(BO->getComputationResultType()));
+  }
 }
 
 void JSONNodeDumper::VisitMemberExpr(const MemberExpr *ME) {
   // Note, we always write this Boolean field because the information it conveys
   // is critical to understanding the AST node.
   ValueDecl *VD = ME->getMemberDecl();
   JOS.attribute("name", VD && VD->getDeclName() ? VD->getNameAsString() : "");
   JOS.attribute("isArrow", ME->isArrow());

clang/lib/AST/StmtPrinter.cpp

 }
 
 void StmtPrinter::VisitBinaryOperator(BinaryOperator *Node) {
   PrintExpr(Node->getLHS());
   OS << " " << BinaryOperator::getOpcodeStr(Node->getOpcode()) << " ";
   PrintExpr(Node->getRHS());
 }
 
-void StmtPrinter::VisitCompoundAssignOperator(CompoundAssignOperator *Node) {
-  PrintExpr(Node->getLHS());
-  OS << " " << BinaryOperator::getOpcodeStr(Node->getOpcode()) << " ";
-  PrintExpr(Node->getRHS());
-}
-
 void StmtPrinter::VisitConditionalOperator(ConditionalOperator *Node) {
   PrintExpr(Node->getCond());
   OS << " ? ";
   PrintExpr(Node->getLHS());
   OS << " : ";
   PrintExpr(Node->getRHS());
 }
 

clang/lib/AST/StmtProfile.cpp

void StmtProfiler::VisitCStyleCastExpr(const CStyleCastExpr *S) {
   VisitExplicitCastExpr(S);
 }
 
 void StmtProfiler::VisitBinaryOperator(const BinaryOperator *S) {
   VisitExpr(S);
   ID.AddInteger(S->getOpcode());
 }
 
-void
-StmtProfiler::VisitCompoundAssignOperator(const CompoundAssignOperator *S) {
-  VisitBinaryOperator(S);
-}
-
 void StmtProfiler::VisitConditionalOperator(const ConditionalOperator *S) {
   VisitExpr(S);
 }
 
 void StmtProfiler::VisitBinaryConditionalOperator(
     const BinaryConditionalOperator *S) {
   VisitExpr(S);
 }
case OO_Less:
     return Stmt::BinaryOperatorClass;
 
   case OO_Greater:
     BinaryOp = BO_GT;
     return Stmt::BinaryOperatorClass;
 
   case OO_PlusEqual:
     BinaryOp = BO_AddAssign;
-    return Stmt::CompoundAssignOperatorClass;
+    return Stmt::BinaryOperatorClass;
 
   case OO_MinusEqual:
     BinaryOp = BO_SubAssign;
-    return Stmt::CompoundAssignOperatorClass;
+    return Stmt::BinaryOperatorClass;
 
   case OO_StarEqual:
     BinaryOp = BO_MulAssign;
-    return Stmt::CompoundAssignOperatorClass;
+    return Stmt::BinaryOperatorClass;
 
   case OO_SlashEqual:
     BinaryOp = BO_DivAssign;
-    return Stmt::CompoundAssignOperatorClass;
+    return Stmt::BinaryOperatorClass;
 
   case OO_PercentEqual:
     BinaryOp = BO_RemAssign;
-    return Stmt::CompoundAssignOperatorClass;
+    return Stmt::BinaryOperatorClass;
 
   case OO_CaretEqual:
     BinaryOp = BO_XorAssign;
-    return Stmt::CompoundAssignOperatorClass;
+    return Stmt::BinaryOperatorClass;
 
   case OO_AmpEqual:
     BinaryOp = BO_AndAssign;
-    return Stmt::CompoundAssignOperatorClass;
+    return Stmt::BinaryOperatorClass;
 
   case OO_PipeEqual:
     BinaryOp = BO_OrAssign;
-    return Stmt::CompoundAssignOperatorClass;
+    return Stmt::BinaryOperatorClass;
 
   case OO_LessLess:
     BinaryOp = BO_Shl;
     return Stmt::BinaryOperatorClass;
 
   case OO_GreaterGreater:
     BinaryOp = BO_Shr;
     return Stmt::BinaryOperatorClass;
 
   case OO_LessLessEqual:
     BinaryOp = BO_ShlAssign;
-    return Stmt::CompoundAssignOperatorClass;
+    return Stmt::BinaryOperatorClass;
 
   case OO_GreaterGreaterEqual:
     BinaryOp = BO_ShrAssign;
-    return Stmt::CompoundAssignOperatorClass;
+    return Stmt::BinaryOperatorClass;
 
   case OO_EqualEqual:
     BinaryOp = BO_EQ;
     return Stmt::BinaryOperatorClass;
 
   case OO_ExclaimEqual:
     BinaryOp = BO_NE;
     return Stmt::BinaryOperatorClass;
if (S->isTypeDependent()) {
     BinaryOperatorKind BinaryOp = BO_Comma;
     Stmt::StmtClass SC = DecodeOperatorCall(S, UnaryOp, BinaryOp);
 
     ID.AddInteger(SC);
     for (unsigned I = 0, N = S->getNumArgs(); I != N; ++I)
       Visit(S->getArg(I));
     if (SC == Stmt::UnaryOperatorClass)
       ID.AddInteger(UnaryOp);
-    else if (SC == Stmt::BinaryOperatorClass ||
-             SC == Stmt::CompoundAssignOperatorClass)
+    else if (SC == Stmt::BinaryOperatorClass)
       ID.AddInteger(BinaryOp);
     else
       assert(SC == Stmt::ArraySubscriptExprClass);
 
     return;
   }
 
   VisitCallExpr(S);

clang/lib/AST/TextNodeDumper.cpp

 
 void TextNodeDumper::VisitExtVectorElementExpr(
     const ExtVectorElementExpr *Node) {
   OS << " " << Node->getAccessor().getNameStart();
 }
 
 void TextNodeDumper::VisitBinaryOperator(const BinaryOperator *Node) {
   OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode()) << "'";
-}
-
-void TextNodeDumper::VisitCompoundAssignOperator(
-    const CompoundAssignOperator *Node) {
-  OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode())
-     << "' ComputeLHSTy=";
+  if (Node->isCompoundAssignmentOp()) {
+    OS << " ComputeLHSTy=";
     dumpBareType(Node->getComputationLHSType());
     OS << " ComputeResultTy=";
     dumpBareType(Node->getComputationResultType());
   }
+}
 
 void TextNodeDumper::VisitAddrLabelExpr(const AddrLabelExpr *Node) {
   OS << " " << Node->getLabel()->getName();
   dumpPointer(Node->getLabel());
 }
 
 void TextNodeDumper::VisitCXXNamedCastExpr(const CXXNamedCastExpr *Node) {
   OS << " " << Node->getCastName() << "<"

clang/lib/Analysis/BodyFarm.cpp

 
 private:
   ASTContext &C;
 };
 }
 
 BinaryOperator *ASTMaker::makeAssignment(const Expr *LHS, const Expr *RHS,
                                          QualType Ty) {
- return new (C) BinaryOperator(const_cast<Expr*>(LHS), const_cast<Expr*>(RHS),
-                               BO_Assign, Ty, VK_RValue,
-                               OK_Ordinary, SourceLocation(), FPOptions());
+  return BinaryOperator::Create(
+      C, const_cast<Expr *>(LHS), const_cast<Expr *>(RHS), BO_Assign, Ty,
+      VK_RValue, OK_Ordinary, SourceLocation(), FPOptions());
 }
 
 BinaryOperator *ASTMaker::makeComparison(const Expr *LHS, const Expr *RHS,
                                          BinaryOperator::Opcode Op) {
   assert(BinaryOperator::isLogicalOp(Op) ||
          BinaryOperator::isComparisonOp(Op));
-  return new (C) BinaryOperator(const_cast<Expr*>(LHS),
-                                const_cast<Expr*>(RHS),
-                                Op,
-                                C.getLogicalOperationType(),
-                                VK_RValue,
+  return BinaryOperator::Create(C, const_cast<Expr *>(LHS),
+                                const_cast<Expr *>(RHS), Op,
+                                C.getLogicalOperationType(), VK_RValue,
                                 OK_Ordinary, SourceLocation(), FPOptions());
 }
 
 CompoundStmt *ASTMaker::makeCompound(ArrayRef<Stmt *> Stmts) {
   return CompoundStmt::Create(C, Stmts, SourceLocation(), SourceLocation());
 }
 
 DeclRefExpr *ASTMaker::makeDeclRefExpr(
SubExpr = M.makeImplicitCast(Call, Ty, CK_FunctionToPointerDecay);
              && Call->getType()->isPointerType()
              && Call->getType()->getPointeeType()->isFunctionType()){
     SubExpr = Call;
   } else {
     llvm_unreachable("Unexpected state");
   }
 
   return CallExpr::Create(C, SubExpr, CallArgs, C.VoidTy, VK_RValue,
-                          SourceLocation());
+                          SourceLocation(), FPOptions());
 }
 
 static CallExpr *create_call_once_lambda_call(ASTContext &C, ASTMaker M,
                                               const ParmVarDecl *Callback,
                                               CXXRecordDecl *CallbackDecl,
                                               ArrayRef<Expr *> CallArgs) {
   assert(CallbackDecl != nullptr);
   assert(CallbackDecl->isLambda());
static Stmt *create_dispatch_once(ASTContext &C, const FunctionDecl *D) {
 
   // (1) Create the call.
   CallExpr *CE = CallExpr::Create(
       /*ASTContext=*/C,
       /*StmtClass=*/M.makeLvalueToRvalue(/*Expr=*/Block),
       /*Args=*/None,
       /*QualType=*/C.VoidTy,
       /*ExprValueType=*/VK_RValue,
-      /*SourceLocation=*/SourceLocation());
+      /*SourceLocation=*/SourceLocation(), FPOptions());
 
   // (2) Create the assignment to the predicate.
   Expr *DoneValue =
       new (C) UnaryOperator(M.makeIntegerLiteral(0, C.LongTy), UO_Not, C.LongTy,
                             VK_RValue, OK_Ordinary, SourceLocation(),
                             /*CanOverflow*/false);
 
   BinaryOperator *B =
static Stmt *create_dispatch_sync(ASTContext &C, const FunctionDecl *D) {
   //
   // void dispatch_sync(dispatch_queue_t queue, void (^block)(void)) {
   //   block();
   // }
   //
   ASTMaker M(C);
   DeclRefExpr *DR = M.makeDeclRefExpr(PV);
   ImplicitCastExpr *ICE = M.makeLvalueToRvalue(DR, Ty);
-  CallExpr *CE =
-      CallExpr::Create(C, ICE, None, C.VoidTy, VK_RValue, SourceLocation());
+  CallExpr *CE = CallExpr::Create(C, ICE, None, C.VoidTy, VK_RValue,
+                                  SourceLocation(), FPOptions());
   return CE;
 }
 
 static Stmt *create_OSAtomicCompareAndSwap(ASTContext &C, const FunctionDecl *D)
 {
   // There are exactly 3 arguments.
   if (D->param_size() != 3)
     return nullptr;

clang/lib/Analysis/CFG.cpp

case Stmt::InitListExprClass:
       return VisitInitListExpr(cast<InitListExpr>(S), asc);
 
     case Stmt::AddrLabelExprClass:
       return VisitAddrLabelExpr(cast<AddrLabelExpr>(S), asc);
 
     case Stmt::BinaryConditionalOperatorClass:
       return VisitConditionalOperator(cast<BinaryConditionalOperator>(S), asc);
 
-    case Stmt::BinaryOperatorClass:
+    case Stmt::BinaryOperatorClass: {
+      auto  BO = dyn_cast<BinaryOperator>(S);
+      if (BO->isCompoundAssignmentOp())
+        return VisitStmt(S, asc);
       return VisitBinaryOperator(cast<BinaryOperator>(S), asc);
+    }
 
     case Stmt::BlockExprClass:
       return VisitBlockExpr(cast<BlockExpr>(S), asc);
 
     case Stmt::BreakStmtClass:
       return VisitBreakStmt(cast<BreakStmt>(S));
 
     case Stmt::CallExprClass:

clang/lib/Analysis/ReachableCode.cpp

case Expr::BinaryOperatorClass: {
       const BinaryOperator *BO = cast<BinaryOperator>(S);
       return BO->getOperatorLoc();
     }
     case Expr::UnaryOperatorClass: {
       const UnaryOperator *UO = cast<UnaryOperator>(S);
       R1 = UO->getSubExpr()->getSourceRange();
       return UO->getOperatorLoc();
     }
-    case Expr::CompoundAssignOperatorClass: {
-      const CompoundAssignOperator *CAO = cast<CompoundAssignOperator>(S);
-      R1 = CAO->getLHS()->getSourceRange();
-      R2 = CAO->getRHS()->getSourceRange();
-      return CAO->getOperatorLoc();
-    }
     case Expr::BinaryConditionalOperatorClass:
     case Expr::ConditionalOperatorClass: {
       const AbstractConditionalOperator *CO =
       cast<AbstractConditionalOperator>(S);
       return CO->getQuestionLoc();
     }
     case Expr::MemberExprClass: {
       const MemberExpr *ME = cast<MemberExpr>(S);

clang/lib/Analysis/ThreadSafetyCommon.cpp

case Stmt::CallExprClass:
     return translateCallExpr(cast<CallExpr>(S), Ctx);
   case Stmt::CXXMemberCallExprClass:
     return translateCXXMemberCallExpr(cast<CXXMemberCallExpr>(S), Ctx);
   case Stmt::CXXOperatorCallExprClass:
     return translateCXXOperatorCallExpr(cast<CXXOperatorCallExpr>(S), Ctx);
   case Stmt::UnaryOperatorClass:
     return translateUnaryOperator(cast<UnaryOperator>(S), Ctx);
   case Stmt::BinaryOperatorClass:
-  case Stmt::CompoundAssignOperatorClass:
     return translateBinaryOperator(cast<BinaryOperator>(S), Ctx);
 
   case Stmt::ArraySubscriptExprClass:
     return translateArraySubscriptExpr(cast<ArraySubscriptExpr>(S), Ctx);
   case Stmt::ConditionalOperatorClass:
     return translateAbstractConditionalOperator(
              cast<ConditionalOperator>(S), Ctx);
   case Stmt::BinaryConditionalOperatorClass:

clang/lib/CodeGen/CGExpr.cpp

LValue CodeGenFunction::EmitLValue(const Expr *E) {
 
   case Expr::ObjCPropertyRefExprClass:
     llvm_unreachable("cannot emit a property reference directly");
 
   case Expr::ObjCSelectorExprClass:
     return EmitObjCSelectorLValue(cast<ObjCSelectorExpr>(E));
   case Expr::ObjCIsaExprClass:
     return EmitObjCIsaExpr(cast<ObjCIsaExpr>(E));
-  case Expr::BinaryOperatorClass:
-    return EmitBinaryOperatorLValue(cast<BinaryOperator>(E));
-  case Expr::CompoundAssignOperatorClass: {
-    QualType Ty = E->getType();
+  case Expr::BinaryOperatorClass: {
+    const auto *const BO = cast<BinaryOperator>(E);
+    if (BO->isCompoundAssignmentOp()) {
+      QualType Ty = BO->getType();
       if (const AtomicType *AT = Ty->getAs<AtomicType>())
         Ty = AT->getValueType();
       if (!Ty->isAnyComplexType())
-      return EmitCompoundAssignmentLValue(cast<CompoundAssignOperator>(E));
-    return EmitComplexCompoundAssignmentLValue(cast<CompoundAssignOperator>(E));
+        return EmitCompoundAssignmentLValue(BO);
+      return EmitComplexCompoundAssignmentLValue(BO);
+    }
+    return EmitBinaryOperatorLValue(BO);
   }
   case Expr::CallExprClass:
   case Expr::CXXMemberCallExprClass:
   case Expr::CXXOperatorCallExprClass:
   case Expr::UserDefinedLiteralClass:
     return EmitCallExprLValue(cast<CallExpr>(E));
   case Expr::CXXRewrittenBinaryOperatorClass:
     return EmitLValue(cast<CXXRewrittenBinaryOperator>(E)->getSemanticForm());

clang/lib/CodeGen/CGExprComplex.cpp

public:
 
   struct BinOpInfo {
     ComplexPairTy LHS;
     ComplexPairTy RHS;
     QualType Ty;  // Computation Type.
   };
 
   BinOpInfo EmitBinOps(const BinaryOperator *E);
-  LValue EmitCompoundAssignLValue(const CompoundAssignOperator *E,
-                                  ComplexPairTy (ComplexExprEmitter::*Func)
-                                  (const BinOpInfo &),
-                                  RValue &Val);
-  ComplexPairTy EmitCompoundAssign(const CompoundAssignOperator *E,
-                                   ComplexPairTy (ComplexExprEmitter::*Func)
-                                   (const BinOpInfo &));
+  LValue EmitCompoundAssignLValue(
+      const BinaryOperator *E,
+      ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo &),
+  ComplexPairTy EmitCompoundAssign(
+      const BinaryOperator *E,
+      ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo &));
 
   ComplexPairTy EmitBinAdd(const BinOpInfo &Op);
   ComplexPairTy EmitBinSub(const BinOpInfo &Op);
   ComplexPairTy EmitBinMul(const BinOpInfo &Op);
   ComplexPairTy EmitBinDiv(const BinOpInfo &Op);
 
   ComplexPairTy EmitComplexBinOpLibCall(StringRef LibCallName,
                                         const BinOpInfo &Op);
ComplexPairTy VisitBinDiv(const BinaryOperator *E) {
     return EmitBinDiv(EmitBinOps(E));
   }
 
   ComplexPairTy VisitCXXRewrittenBinaryOperator(CXXRewrittenBinaryOperator *E) {
     return Visit(E->getSemanticForm());
   }
 
   // Compound assignments.
-  ComplexPairTy VisitBinAddAssign(const CompoundAssignOperator *E) {
+  ComplexPairTy VisitBinAddAssign(const BinaryOperator *E) {
     return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinAdd);
   }
-  ComplexPairTy VisitBinSubAssign(const CompoundAssignOperator *E) {
+  ComplexPairTy VisitBinSubAssign(const BinaryOperator *E) {
     return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinSub);
   }
-  ComplexPairTy VisitBinMulAssign(const CompoundAssignOperator *E) {
+  ComplexPairTy VisitBinMulAssign(const BinaryOperator *E) {
     return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinMul);
   }
-  ComplexPairTy VisitBinDivAssign(const CompoundAssignOperator *E) {
+  ComplexPairTy VisitBinDivAssign(const BinaryOperator *E) {
     return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinDiv);
   }
 
   // GCC rejects rem/and/or/xor for integer complex.
   // Logical and/or always return int, never complex.
 
   // No comparisons produce a complex result.
 
if (E->getRHS()->getType()->isRealFloatingType())
     Ops.RHS = ComplexPairTy(CGF.EmitScalarExpr(E->getRHS()), nullptr);
   else
     Ops.RHS = Visit(E->getRHS());
 
   Ops.Ty = E->getType();
   return Ops;
 }
 
-
-LValue ComplexExprEmitter::
-EmitCompoundAssignLValue(const CompoundAssignOperator *E,
-          ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&),
-                         RValue &Val) {
+LValue ComplexExprEmitter::EmitCompoundAssignLValue(
+    const BinaryOperator *E,
+    ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo &), RValue &Val) {
   TestAndClearIgnoreReal();
   TestAndClearIgnoreImag();
   QualType LHSTy = E->getLHS()->getType();
   if (const AtomicType *AT = LHSTy->getAs<AtomicType>())
     LHSTy = AT->getValueType();
 
   BinOpInfo OpInfo;
 
if (LHSTy->isAnyComplexType()) {
     CGF.EmitStoreOfScalar(ResVal, LHS, /*isInit*/ false);
     Val = RValue::get(ResVal);
   }
 
   return LHS;
 }
 
 // Compound assignments.
-ComplexPairTy ComplexExprEmitter::
-EmitCompoundAssign(const CompoundAssignOperator *E,
-                   ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&)){
+ComplexPairTy ComplexExprEmitter::EmitCompoundAssign(
+    const BinaryOperator *E,
+    ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo &)) {
   RValue Val;
   LValue LV = EmitCompoundAssignLValue(E, Func, Val);
 
   // The result of an assignment in C is the assigned r-value.
   if (!CGF.getLangOpts().CPlusPlus)
     return Val.getComplexVal();
 
   // If the lvalue is non-volatile, return the computed value of the assignment.
static CompoundFunc getComplexOp(BinaryOperatorKind Op) {
   case BO_DivAssign: return &ComplexExprEmitter::EmitBinDiv;
   case BO_SubAssign: return &ComplexExprEmitter::EmitBinSub;
   case BO_AddAssign: return &ComplexExprEmitter::EmitBinAdd;
   default:
     llvm_unreachable("unexpected complex compound assignment");
   }
 }
 
-LValue CodeGenFunction::
-EmitComplexCompoundAssignmentLValue(const CompoundAssignOperator *E) {
+LValue
+CodeGenFunction::EmitComplexCompoundAssignmentLValue(const BinaryOperator *E) {
   CompoundFunc Op = getComplexOp(E->getOpcode());
   RValue Val;
   return ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Op, Val);
 }
 
-LValue CodeGenFunction::
-EmitScalarCompoundAssignWithComplex(const CompoundAssignOperator *E,
+LValue
+CodeGenFunction::EmitScalarCompoundAssignWithComplex(const BinaryOperator *E,
                                                      llvm::Value *&Result) {
   CompoundFunc Op = getComplexOp(E->getOpcode());
   RValue Val;
   LValue Ret = ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Op, Val);
   Result = Val.getScalarVal();
   return Ret;
 }

clang/lib/CodeGen/CGExprScalar.cpp

bool mayHaveIntegerOverflow(llvm::ConstantInt *LHS, llvm::ConstantInt *RHS,
   return Overflow;
 }
 
 struct BinOpInfo {
   Value *LHS;
   Value *RHS;
   QualType Ty;  // Computation Type.
   BinaryOperator::Opcode Opcode; // Opcode of BinOp to perform
+  bool HasFPFeatures;
   FPOptions FPFeatures;
   const Expr *E;      // Entire expr, for error unsupported.  May not be binop.
 
   /// Check if the binop can result in integer overflow.
   bool mayHaveIntegerOverflow() const {
     // Without constant input, we can't rule out overflow.
     auto *LHSCI = dyn_cast<llvm::ConstantInt>(LHS);
     auto *RHSCI = dyn_cast<llvm::ConstantInt>(RHS);
public:
   Value *EmitOr (const BinOpInfo &Ops) {
     return Builder.CreateOr(Ops.LHS, Ops.RHS, "or");
   }
 
   // Helper functions for fixed point binary operations.
   Value *EmitFixedPointBinOp(const BinOpInfo &Ops);
 
   BinOpInfo EmitBinOps(const BinaryOperator *E);
-  LValue EmitCompoundAssignLValue(const CompoundAssignOperator *E,
-                            Value *(ScalarExprEmitter::*F)(const BinOpInfo &),
-                                  Value *&Result);
+  LValue
+  EmitCompoundAssignLValue(const BinaryOperator *E,
 
-  Value *EmitCompoundAssign(const CompoundAssignOperator *E,
+  Value *EmitCompoundAssign(const BinaryOperator *E,
                             Value *(ScalarExprEmitter::*F)(const BinOpInfo &));
 
   // Binary operators and binary compound assignment operators.
-#define HANDLEBINOP(OP) \
-  Value *VisitBin ## OP(const BinaryOperator *E) {                         \
-    return Emit ## OP(EmitBinOps(E));                                      \
-  }                                                                        \
-  Value *VisitBin ## OP ## Assign(const CompoundAssignOperator *E) {       \
-    return EmitCompoundAssign(E, &ScalarExprEmitter::Emit ## OP);          \
+#define HANDLEBINOP(OP)                                                        \
+  Value *VisitBin##OP(const BinaryOperator *E) {                               \
+    return Emit##OP(EmitBinOps(E));                                            \
+  }                                                                            \
+  Value *VisitBin##OP##Assign(const BinaryOperator *E) {                       \
+    return EmitCompoundAssign(E, &ScalarExprEmitter::Emit##OP);                \
   }
   HANDLEBINOP(Mul)
   HANDLEBINOP(Div)
   HANDLEBINOP(Rem)
   HANDLEBINOP(Add)
   HANDLEBINOP(Sub)
   HANDLEBINOP(Shl)
   HANDLEBINOP(Shr)

 
 BinOpInfo ScalarExprEmitter::EmitBinOps(const BinaryOperator *E) {
   TestAndClearIgnoreResultAssign();
   BinOpInfo Result;
   Result.LHS = Visit(E->getLHS());
   Result.RHS = Visit(E->getRHS());
   Result.Ty  = E->getType();
   Result.Opcode = E->getOpcode();
+  Result.HasFPFeatures = E->HasFPFeatures();
+  if (Result.HasFPFeatures)
     Result.FPFeatures = E->getFPFeatures();
+  else
+    Result.FPFeatures = FPOptions(CGF.getLangOpts());
   Result.E = E;
   return Result;
 }
 
 LValue ScalarExprEmitter::EmitCompoundAssignLValue(
-                                              const CompoundAssignOperator *E,
-                        Value *(ScalarExprEmitter::*Func)(const BinOpInfo &),
-                                                   Value *&Result) {
+    const BinaryOperator *E,
+    Value *(ScalarExprEmitter::*Func)(const BinOpInfo &), Value *&Result) {
   QualType LHSTy = E->getLHS()->getType();
   BinOpInfo OpInfo;
 
   if (E->getComputationResultType()->isAnyComplexType())
     return CGF.EmitScalarCompoundAssignWithComplex(E, Result);
 
   // Emit the RHS first.  __block variables need to have the rhs evaluated
   // first, plus this should improve codegen a little.
   OpInfo.RHS = Visit(E->getRHS());
   OpInfo.Ty = E->getComputationResultType();
   OpInfo.Opcode = E->getOpcode();
+  OpInfo.HasFPFeatures = E->HasFPFeatures();
+  if (OpInfo.HasFPFeatures)
     OpInfo.FPFeatures = E->getFPFeatures();
+  else
+    OpInfo.FPFeatures = FPOptions(CGF.getLangOpts());
   OpInfo.E = E;
   // Load/convert the LHS.
   LValue LHSLV = EmitCheckedLValue(E->getLHS(), CodeGenFunction::TCK_Store);
 
   llvm::PHINode *atomicPHI = nullptr;
   if (const AtomicType *atomicTy = LHSTy->getAs<AtomicType>()) {
     QualType type = atomicTy->getValueType();
     if (!type->isBooleanType() && type->isIntegerType() &&
else
     CGF.EmitStoreThroughLValue(RValue::get(Result), LHSLV);
 
   if (CGF.getLangOpts().OpenMP)
     CGF.CGM.getOpenMPRuntime().checkAndEmitLastprivateConditional(CGF,
                                                                   E->getLHS());
   return LHSLV;
 }
 
-Value *ScalarExprEmitter::EmitCompoundAssign(const CompoundAssignOperator *E,
-                      Value *(ScalarExprEmitter::*Func)(const BinOpInfo &)) {
+Value *ScalarExprEmitter::EmitCompoundAssign(
+    const BinaryOperator *E,
   bool Ignore = TestAndClearIgnoreResultAssign();
   Value *RHS = nullptr;
   LValue LHS = EmitCompoundAssignLValue(E, Func, RHS);
 
   // If the result is clearly ignored, return now.
   if (Ignore)
     return nullptr;
 
if (BaseExpr->isRValue()) {
     Addr = EmitLValue(BaseExpr).getAddress(*this);
   }
 
   // Cast the address to Class*.
   Addr = Builder.CreateElementBitCast(Addr, ConvertType(E->getType()));
   return MakeAddrLValue(Addr, E->getType());
 }
 
-
-LValue CodeGenFunction::EmitCompoundAssignmentLValue(
-                                            const CompoundAssignOperator *E) {
+LValue CodeGenFunction::EmitCompoundAssignmentLValue(const BinaryOperator *E) {
   ScalarExprEmitter Scalar(*this);
   Value *Result = nullptr;
   switch (E->getOpcode()) {
 #define COMPOUND_OP(Op)                                                       \
     case BO_##Op##Assign:                                                     \
       return Scalar.EmitCompoundAssignLValue(E, &ScalarExprEmitter::Emit##Op, \
                                              Result)
   COMPOUND_OP(Mul);

clang/lib/CodeGen/CodeGenFunction.h

public:
   /// \param Result [out] - If non-null, this will be set to a Value* for the
   /// bit-field contents after the store, appropriate for use as the result of
   /// an assignment to the bit-field.
   void EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst,
                                       llvm::Value **Result=nullptr);
 
   /// Emit an l-value for an assignment (simple or compound) of complex type.
   LValue EmitComplexAssignmentLValue(const BinaryOperator *E);
-  LValue EmitComplexCompoundAssignmentLValue(const CompoundAssignOperator *E);
-  LValue EmitScalarCompoundAssignWithComplex(const CompoundAssignOperator *E,
+  LValue EmitComplexCompoundAssignmentLValue(const BinaryOperator *E);
+  LValue EmitScalarCompoundAssignWithComplex(const BinaryOperator *E,
                                              llvm::Value *&Result);
 
   // Note: only available for agg return types
   LValue EmitBinaryOperatorLValue(const BinaryOperator *E);
-  LValue EmitCompoundAssignmentLValue(const CompoundAssignOperator *E);
+  LValue EmitCompoundAssignmentLValue(const BinaryOperator *E);
   // Note: only available for agg return types
   LValue EmitCallExprLValue(const CallExpr *E);
   // Note: only available for agg return types
   LValue EmitVAArgExprLValue(const VAArgExpr *E);
   LValue EmitDeclRefLValue(const DeclRefExpr *E);
   LValue EmitStringLiteralLValue(const StringLiteral *E);
   LValue EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E);
   LValue EmitPredefinedLValue(const PredefinedExpr *E);

clang/lib/Frontend/Rewrite/RewriteModernObjC.cpp

RewriteModernObjC::SynthesizeCallToFunctionDecl(FunctionDecl *FD,
 
   // Now, we cast the reference to a pointer to the objc_msgSend type.
   QualType pToFunc = Context->getPointerType(msgSendType);
   ImplicitCastExpr *ICE =
     ImplicitCastExpr::Create(*Context, pToFunc, CK_FunctionToPointerDecay,
                              DRE, nullptr, VK_RValue);
 
   const auto *FT = msgSendType->castAs<FunctionType>();
-  CallExpr *Exp = CallExpr::Create(
-      *Context, ICE, Args, FT->getCallResultType(*Context), VK_RValue, EndLoc);
+  CallExpr *Exp =
+      CallExpr::Create(*Context, ICE, Args, FT->getCallResultType(*Context),
+                       VK_RValue, EndLoc, FPOptions());
   return Exp;
 }
 
 static bool scanForProtocolRefs(const char *startBuf, const char *endBuf,
                                 const char *&startRef, const char *&endRef) {
   while (startBuf < endBuf) {
     if (*startBuf == '<')
       startRef = startBuf; // mark the start.
Stmt *RewriteModernObjC::RewriteObjCBoxedExpr(ObjCBoxedExpr *Exp) {
   cast = NoTypeInfoCStyleCastExpr(Context, castType, CK_BitCast,
                                   cast);
 
   // Don't forget the parens to enforce the proper binding.
   ParenExpr *PE = new (Context) ParenExpr(StartLoc, EndLoc, cast);
 
   auto *FT = msgSendType->castAs<FunctionType>();
   CallExpr *CE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(),
-                                  VK_RValue, EndLoc);
+                                  VK_RValue, EndLoc, FPOptions());
   ReplaceStmt(Exp, CE);
   return CE;
 }
 
 Stmt *RewriteModernObjC::RewriteObjCArrayLiteralExpr(ObjCArrayLiteral *Exp) {
   // synthesize declaration of helper functions needed in this routine.
   if (!SelGetUidFunctionDecl)
     SynthSelGetUidFunctionDecl();
Stmt *RewriteModernObjC::RewriteObjCArrayLiteralExpr(ObjCArrayLiteral *Exp) {
   Expr *count = IntegerLiteral::Create(*Context,
                                        llvm::APInt(UnsignedIntSize, NumElements),
                                        Context->UnsignedIntTy, SourceLocation());
   InitExprs.push_back(count);
   for (unsigned i = 0; i < NumElements; i++)
     InitExprs.push_back(Exp->getElement(i));
   Expr *NSArrayCallExpr =
       CallExpr::Create(*Context, NSArrayDRE, InitExprs, NSArrayFType, VK_LValue,
-                       SourceLocation());
+                       SourceLocation(), FPOptions());
 
   FieldDecl *ARRFD = FieldDecl::Create(*Context, nullptr, SourceLocation(),
                                     SourceLocation(),
                                     &Context->Idents.get("arr"),
                                     Context->getPointerType(Context->VoidPtrTy),
                                     nullptr, /*BitWidth=*/nullptr,
                                     /*Mutable=*/true, ICIS_NoInit);
   MemberExpr *ArrayLiteralME =
Stmt *RewriteModernObjC::RewriteObjCArrayLiteralExpr(ObjCArrayLiteral *Exp) {
   cast = NoTypeInfoCStyleCastExpr(Context, castType, CK_BitCast,
                                   cast);
 
   // Don't forget the parens to enforce the proper binding.
   ParenExpr *PE = new (Context) ParenExpr(StartLoc, EndLoc, cast);
 
   const FunctionType *FT = msgSendType->castAs<FunctionType>();
   CallExpr *CE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(),
-                                  VK_RValue, EndLoc);
+                                  VK_RValue, EndLoc, FPOptions());
   ReplaceStmt(Exp, CE);
   return CE;
 }
 
 Stmt *RewriteModernObjC::RewriteObjCDictionaryLiteralExpr(ObjCDictionaryLiteral *Exp) {
   // synthesize declaration of helper functions needed in this routine.
   if (!SelGetUidFunctionDecl)
     SynthSelGetUidFunctionDecl();
for (unsigned i = 0; i < NumElements; i++) {
     ObjCDictionaryElement Element = Exp->getKeyValueElement(i);
     KeyExprs.push_back(Element.Key);
     ValueExprs.push_back(Element.Value);
   }
 
   // (const id [])objects
   Expr *NSValueCallExpr =
       CallExpr::Create(*Context, NSDictDRE, ValueExprs, NSDictFType, VK_LValue,
-                       SourceLocation());
+                       SourceLocation(), FPOptions());
 
   FieldDecl *ARRFD = FieldDecl::Create(*Context, nullptr, SourceLocation(),
                                        SourceLocation(),
                                        &Context->Idents.get("arr"),
                                        Context->getPointerType(Context->VoidPtrTy),
                                        nullptr, /*BitWidth=*/nullptr,
                                        /*Mutable=*/true, ICIS_NoInit);
   MemberExpr *DictLiteralValueME =
       MemberExpr::CreateImplicit(*Context, NSValueCallExpr, false, ARRFD,
                                  ARRFD->getType(), VK_LValue, OK_Ordinary);
   QualType ConstIdT = Context->getObjCIdType().withConst();
   CStyleCastExpr * DictValueObjects =
     NoTypeInfoCStyleCastExpr(Context,
                              Context->getPointerType(ConstIdT),
                              CK_BitCast,
                              DictLiteralValueME);
   // (const id <NSCopying> [])keys
-  Expr *NSKeyCallExpr = CallExpr::Create(
-      *Context, NSDictDRE, KeyExprs, NSDictFType, VK_LValue, SourceLocation());
+  Expr *NSKeyCallExpr =
+      CallExpr::Create(*Context, NSDictDRE, KeyExprs, NSDictFType, VK_LValue,
+                       SourceLocation(), FPOptions());
 
   MemberExpr *DictLiteralKeyME =
       MemberExpr::CreateImplicit(*Context, NSKeyCallExpr, false, ARRFD,
                                  ARRFD->getType(), VK_LValue, OK_Ordinary);
 
   CStyleCastExpr * DictKeyObjects =
     NoTypeInfoCStyleCastExpr(Context,
                              Context->getPointerType(ConstIdT),
Stmt *RewriteModernObjC::RewriteObjCDictionaryLiteralExpr(ObjCDictionaryLiteral *Exp) {
   cast = NoTypeInfoCStyleCastExpr(Context, castType, CK_BitCast,
                                   cast);
 
   // Don't forget the parens to enforce the proper binding.
   ParenExpr *PE = new (Context) ParenExpr(StartLoc, EndLoc, cast);
 
   const FunctionType *FT = msgSendType->castAs<FunctionType>();
   CallExpr *CE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(),
-                                  VK_RValue, EndLoc);
+                                  VK_RValue, EndLoc, FPOptions());
   ReplaceStmt(Exp, CE);
   return CE;
 }
 
 // struct __rw_objc_super {
 //   struct objc_object *object; struct objc_object *superClass;
 // };
 QualType RewriteModernObjC::getSuperStructType() {
Expr *RewriteModernObjC::SynthMsgSendStretCallExpr(FunctionDecl *MsgSendStretFlavor,
   // AST for __Stretn(receiver, args).s;
   IdentifierInfo *ID = &Context->Idents.get(name);
   FunctionDecl *FD =
       FunctionDecl::Create(*Context, TUDecl, SourceLocation(), SourceLocation(),
                            ID, FuncType, nullptr, SC_Extern, false, false);
   DeclRefExpr *DRE = new (Context)
       DeclRefExpr(*Context, FD, false, castType, VK_RValue, SourceLocation());
   CallExpr *STCE = CallExpr::Create(*Context, DRE, MsgExprs, castType,
-                                    VK_LValue, SourceLocation());
+                                    VK_LValue, SourceLocation(), FPOptions());
 
   FieldDecl *FieldD = FieldDecl::Create(*Context, nullptr, SourceLocation(),
                                     SourceLocation(),
                                     &Context->Idents.get("s"),
                                     returnType, nullptr,
                                     /*BitWidth=*/nullptr,
                                     /*Mutable=*/true, ICIS_NoInit);
   MemberExpr *ME = MemberExpr::CreateImplicit(
case ObjCMessageExpr::SuperClass: {
 
     if (LangOpts.MicrosoftExt) {
       SynthSuperConstructorFunctionDecl();
       // Simulate a constructor call...
       DeclRefExpr *DRE = new (Context)
           DeclRefExpr(*Context, SuperConstructorFunctionDecl, false, superType,
                       VK_LValue, SourceLocation());
       SuperRep = CallExpr::Create(*Context, DRE, InitExprs, superType,
-                                  VK_LValue, SourceLocation());
+                                  VK_LValue, SourceLocation(), FPOptions());
       // The code for super is a little tricky to prevent collision with
       // the structure definition in the header. The rewriter has it's own
       // internal definition (__rw_objc_super) that is uses. This is why
       // we need the cast below. For example:
       // (struct __rw_objc_super *)&__rw_objc_super((id)self, (id)objc_getClass("SUPER"))
       //
       SuperRep = new (Context) UnaryOperator(SuperRep, UO_AddrOf,
                                Context->getPointerType(SuperRep->getType()),
case ObjCMessageExpr::SuperInstance:{
 
     if (LangOpts.MicrosoftExt) {
       SynthSuperConstructorFunctionDecl();
       // Simulate a constructor call...
       DeclRefExpr *DRE = new (Context)
           DeclRefExpr(*Context, SuperConstructorFunctionDecl, false, superType,
                       VK_LValue, SourceLocation());
       SuperRep = CallExpr::Create(*Context, DRE, InitExprs, superType,
-                                  VK_LValue, SourceLocation());
+                                  VK_LValue, SourceLocation(), FPOptions());
       // The code for super is a little tricky to prevent collision with
       // the structure definition in the header. The rewriter has it's own
       // internal definition (__rw_objc_super) that is uses. This is why
       // we need the cast below. For example:
       // (struct __rw_objc_super *)&__rw_objc_super((id)self, (id)objc_getClass("SUPER"))
       //
       SuperRep = new (Context) UnaryOperator(SuperRep, UO_AddrOf,
                                Context->getPointerType(SuperRep->getType()),
Stmt *RewriteModernObjC::SynthMessageExpr(ObjCMessageExpr *Exp,
   cast = NoTypeInfoCStyleCastExpr(Context, castType, CK_BitCast,
                                   cast);
 
   // Don't forget the parens to enforce the proper binding.
   ParenExpr *PE = new (Context) ParenExpr(StartLoc, EndLoc, cast);
 
   const FunctionType *FT = msgSendType->castAs<FunctionType>();
   CallExpr *CE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(),
-                                  VK_RValue, EndLoc);
+                                  VK_RValue, EndLoc, FPOptions());
   Stmt *ReplacingStmt = CE;
   if (MsgSendStretFlavor) {
     // We have the method which returns a struct/union. Must also generate
     // call to objc_msgSend_stret and hang both varieties on a conditional
     // expression which dictate which one to envoke depending on size of
     // method's return type.
 
     Expr *STCE = SynthMsgSendStretCallExpr(MsgSendStretFlavor,
Stmt *RewriteModernObjC::SynthesizeBlockCall(CallExpr *Exp, const Expr *BlockExp) {
   // Add the implicit argument.
   BlkExprs.push_back(BlkCast);
   // Add the user arguments.
   for (CallExpr::arg_iterator I = Exp->arg_begin(),
        E = Exp->arg_end(); I != E; ++I) {
     BlkExprs.push_back(*I);
   }
   CallExpr *CE = CallExpr::Create(*Context, PE, BlkExprs, Exp->getType(),
-                                  VK_RValue, SourceLocation());
+                                  VK_RValue, SourceLocation(), FPOptions());
   return CE;
 }
 
 // We need to return the rewritten expression to handle cases where the
 // DeclRefExpr is embedded in another expression being rewritten.
 // For example:
 //
 // int main() {
if (ImportedBlockDecls.size()) {
     int flag = (BLOCK_HAS_COPY_DISPOSE | BLOCK_HAS_DESCRIPTOR);
     unsigned IntSize =
       static_cast<unsigned>(Context->getTypeSize(Context->IntTy));
     Expr *FlagExp = IntegerLiteral::Create(*Context, llvm::APInt(IntSize, flag),
                                            Context->IntTy, SourceLocation());
     InitExprs.push_back(FlagExp);
   }
   NewRep = CallExpr::Create(*Context, DRE, InitExprs, FType, VK_LValue,
-                            SourceLocation());
+                            SourceLocation(), FPOptions());
 
   if (GlobalBlockExpr) {
     assert (!GlobalConstructionExp &&
             "SynthBlockInitExpr - GlobalConstructionExp must be null");
     GlobalConstructionExp = NewRep;
     NewRep = DRE;
   }
 

clang/lib/Frontend/Rewrite/RewriteObjC.cpp

RewriteObjC::SynthesizeCallToFunctionDecl(FunctionDecl *FD,
   // Now, we cast the reference to a pointer to the objc_msgSend type.
   QualType pToFunc = Context->getPointerType(msgSendType);
   ImplicitCastExpr *ICE =
     ImplicitCastExpr::Create(*Context, pToFunc, CK_FunctionToPointerDecay,
                              DRE, nullptr, VK_RValue);
 
   const auto *FT = msgSendType->castAs<FunctionType>();
 
-  CallExpr *Exp = CallExpr::Create(
-      *Context, ICE, Args, FT->getCallResultType(*Context), VK_RValue, EndLoc);
+  CallExpr *Exp =
+      CallExpr::Create(*Context, ICE, Args, FT->getCallResultType(*Context),
+                       VK_RValue, EndLoc, FPOptions());
   return Exp;
 }
 
 static bool scanForProtocolRefs(const char *startBuf, const char *endBuf,
                                 const char *&startRef, const char *&endRef) {
   while (startBuf < endBuf) {
     if (*startBuf == '<')
       startRef = startBuf; // mark the start.
CallExpr *RewriteObjC::SynthMsgSendStretCallExpr(FunctionDecl *MsgSendStretFlavor,
   cast = NoTypeInfoCStyleCastExpr(Context, castType, CK_BitCast,
                                             cast);
 
   // Don't forget the parens to enforce the proper binding.
   ParenExpr *PE = new (Context) ParenExpr(SourceLocation(), SourceLocation(), cast);
 
   const auto *FT = msgSendType->castAs<FunctionType>();
   CallExpr *STCE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(),
-                                    VK_RValue, SourceLocation());
+                                    VK_RValue, SourceLocation(), FPOptions());
   return STCE;
 }
 
 Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp,
                                     SourceLocation StartLoc,
                                     SourceLocation EndLoc) {
   if (!SelGetUidFunctionDecl)
     SynthSelGetUidFunctionDecl();
case ObjCMessageExpr::SuperClass: {
 
     if (LangOpts.MicrosoftExt) {
       SynthSuperConstructorFunctionDecl();
       // Simulate a constructor call...
       DeclRefExpr *DRE = new (Context)
           DeclRefExpr(*Context, SuperConstructorFunctionDecl, false, superType,
                       VK_LValue, SourceLocation());
       SuperRep = CallExpr::Create(*Context, DRE, InitExprs, superType,
-                                  VK_LValue, SourceLocation());
+                                  VK_LValue, SourceLocation(), FPOptions());
       // The code for super is a little tricky to prevent collision with
       // the structure definition in the header. The rewriter has it's own
       // internal definition (__rw_objc_super) that is uses. This is why
       // we need the cast below. For example:
       // (struct objc_super *)&__rw_objc_super((id)self, (id)objc_getClass("SUPER"))
       //
       SuperRep = new (Context) UnaryOperator(SuperRep, UO_AddrOf,
                                Context->getPointerType(SuperRep->getType()),
case ObjCMessageExpr::SuperInstance:{
 
     if (LangOpts.MicrosoftExt) {
       SynthSuperConstructorFunctionDecl();
       // Simulate a constructor call...
       DeclRefExpr *DRE = new (Context)
           DeclRefExpr(*Context, SuperConstructorFunctionDecl, false, superType,
                       VK_LValue, SourceLocation());
       SuperRep = CallExpr::Create(*Context, DRE, InitExprs, superType,
-                                  VK_LValue, SourceLocation());
+                                  VK_LValue, SourceLocation(), FPOptions());
       // The code for super is a little tricky to prevent collision with
       // the structure definition in the header. The rewriter has it's own
       // internal definition (__rw_objc_super) that is uses. This is why
       // we need the cast below. For example:
       // (struct objc_super *)&__rw_objc_super((id)self, (id)objc_getClass("SUPER"))
       //
       SuperRep = new (Context) UnaryOperator(SuperRep, UO_AddrOf,
                                Context->getPointerType(SuperRep->getType()),
Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp,
   cast = NoTypeInfoCStyleCastExpr(Context, castType, CK_BitCast,
                                   cast);
 
   // Don't forget the parens to enforce the proper binding.
   ParenExpr *PE = new (Context) ParenExpr(StartLoc, EndLoc, cast);
 
   const auto *FT = msgSendType->castAs<FunctionType>();
   CallExpr *CE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(),
-                                  VK_RValue, EndLoc);
+                                  VK_RValue, EndLoc, FPOptions());
   Stmt *ReplacingStmt = CE;
   if (MsgSendStretFlavor) {
     // We have the method which returns a struct/union. Must also generate
     // call to objc_msgSend_stret and hang both varieties on a conditional
     // expression which dictate which one to envoke depending on size of
     // method's return type.
 
     CallExpr *STCE = SynthMsgSendStretCallExpr(MsgSendStretFlavor,
Stmt *RewriteObjC::SynthesizeBlockCall(CallExpr *Exp, const Expr *BlockExp) {
   // Add the implicit argument.
   BlkExprs.push_back(BlkCast);
   // Add the user arguments.
   for (CallExpr::arg_iterator I = Exp->arg_begin(),
        E = Exp->arg_end(); I != E; ++I) {
     BlkExprs.push_back(*I);
   }
   CallExpr *CE = CallExpr::Create(*Context, PE, BlkExprs, Exp->getType(),
-                                  VK_RValue, SourceLocation());
+                                  VK_RValue, SourceLocation(), FPOptions());
   return CE;
 }
 
 // We need to return the rewritten expression to handle cases where the
 // BlockDeclRefExpr is embedded in another expression being rewritten.
 // For example:
 //
 // int main() {
if (ImportedBlockDecls.size()) {
     int flag = (BLOCK_HAS_COPY_DISPOSE | BLOCK_HAS_DESCRIPTOR);
     unsigned IntSize =
       static_cast<unsigned>(Context->getTypeSize(Context->IntTy));
     Expr *FlagExp = IntegerLiteral::Create(*Context, llvm::APInt(IntSize, flag),
                                            Context->IntTy, SourceLocation());
     InitExprs.push_back(FlagExp);
   }
   NewRep = CallExpr::Create(*Context, DRE, InitExprs, FType, VK_LValue,
-                            SourceLocation());
+                            SourceLocation(), FPOptions());
   NewRep = new (Context) UnaryOperator(
       NewRep, UO_AddrOf, Context->getPointerType(NewRep->getType()), VK_RValue,
       OK_Ordinary, SourceLocation(), false);
   NewRep = NoTypeInfoCStyleCastExpr(Context, FType, CK_BitCast,
                                     NewRep);
   BlockDeclRefs.clear();
   BlockByRefDecls.clear();
   BlockByRefDeclsPtrSet.clear();

clang/lib/Index/IndexBody.cpp

while (isa<CastExpr>(*It) || isa<ParenExpr>(*It)) {
         break;
       --It;
     }
     const Stmt *Parent = *It;
 
     if (auto BO = dyn_cast<BinaryOperator>(Parent)) {
       if (BO->getOpcode() == BO_Assign && BO->getLHS()->IgnoreParenCasts() == E)
         Roles |= (unsigned)SymbolRole::Write;
+      if (BO->isCompoundAssignmentOp() &&
+          BO->getLHS()->IgnoreParenCasts() == E) {
+        Roles |= (unsigned)SymbolRole::Read;
+        Roles |= (unsigned)SymbolRole::Write;
+      }
 
     } else if (auto UO = dyn_cast<UnaryOperator>(Parent)) {
       if (UO->isIncrementDecrementOp()) {
         Roles |= (unsigned)SymbolRole::Read;
         Roles |= (unsigned)SymbolRole::Write;
       } else if (UO->getOpcode() == UO_AddrOf) {
         Roles |= (unsigned)SymbolRole::AddressOf;
       }
 
-    } else if (auto CA = dyn_cast<CompoundAssignOperator>(Parent)) {
-      if (CA->getLHS()->IgnoreParenCasts() == E) {
-        Roles |= (unsigned)SymbolRole::Read;
-        Roles |= (unsigned)SymbolRole::Write;
-      }
-
     } else if (auto CE = dyn_cast<CallExpr>(Parent)) {
       if (CE->getCallee()->IgnoreParenCasts() == E) {
         addCallRole(Roles, Relations);
         if (auto *ME = dyn_cast<MemberExpr>(E)) {
           if (auto *CXXMD = dyn_cast_or_null<CXXMethodDecl>(ME->getMemberDecl()))
             if (CXXMD->isVirtual() && !ME->hasQualifier()) {
               Roles |= (unsigned)SymbolRole::Dynamic;
               auto BaseTy = ME->getBase()->IgnoreImpCasts()->getType();

clang/lib/Sema/AnalysisBasedWarnings.cpp

AnalysisBasedWarnings::IssueWarnings(sema::AnalysisBasedWarnings::Policy P,
   if (P.enableCheckUnreachable || P.enableThreadSafetyAnalysis ||
       P.enableConsumedAnalysis) {
     // Unreachable code analysis and thread safety require a linearized CFG.
     AC.getCFGBuildOptions().setAllAlwaysAdd();
   }
   else {
     AC.getCFGBuildOptions()
       .setAlwaysAdd(Stmt::BinaryOperatorClass)
-      .setAlwaysAdd(Stmt::CompoundAssignOperatorClass)
       .setAlwaysAdd(Stmt::BlockExprClass)
       .setAlwaysAdd(Stmt::CStyleCastExprClass)
       .setAlwaysAdd(Stmt::DeclRefExprClass)
       .setAlwaysAdd(Stmt::ImplicitCastExprClass)
       .setAlwaysAdd(Stmt::UnaryOperatorClass)
       .setAlwaysAdd(Stmt::AttributedStmtClass);
   }
 

clang/lib/Sema/SemaChecking.cpp

S.Diag(E->getExprLoc(), DiagID)
         << E->getType() << T.getUnqualifiedType() << PrettySourceValue
         << PrettyTargetValue << E->getSourceRange() << SourceRange(CContext);
   }
 }
 
 /// Analyze the given compound assignment for the possible losing of
 /// floating-point precision.
 static void AnalyzeCompoundAssignment(Sema &S, BinaryOperator *E) {
-  assert(isa<CompoundAssignOperator>(E) &&
+
+  assert(E->isCompoundAssignmentOp() &&
          "Must be compound assignment operation");
   // Recurse on the LHS and RHS in here
   AnalyzeImplicitConversions(S, E->getLHS(), E->getOperatorLoc());
   AnalyzeImplicitConversions(S, E->getRHS(), E->getOperatorLoc());
 
   if (E->getLHS()->getType()->isAtomicType())
     S.Diag(E->getOperatorLoc(), diag::warn_atomic_implicit_seq_cst);
 
   // Now check the outermost expression
   const auto *ResultBT = E->getLHS()->getType()->getAs<BuiltinType>();
-  const auto *RBT = cast<CompoundAssignOperator>(E)
-                        ->getComputationResultType()
-                        ->getAs<BuiltinType>();
+  const auto *RBT = E->getComputationResultType()->getAs<BuiltinType>();
 
   // The below checks assume source is floating point.
   if (!ResultBT || !RBT || !RBT->isFloatingPoint()) return;
 
   // If source is floating point but target is an integer.
   if (ResultBT->isInteger())
     return DiagnoseImpCast(S, E, E->getRHS()->getType(), E->getLHS()->getType(),
                            E->getExprLoc(), diag::warn_impcast_float_integer);
if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
     // Do a somewhat different check with comparison operators.
     if (BO->isComparisonOp())
       return AnalyzeComparison(S, BO);
 
     // And with simple assignments.
     if (BO->getOpcode() == BO_Assign)
       return AnalyzeAssignment(S, BO);
     // And with compound assignments.
-    if (BO->isAssignmentOp())
+    if (BO->isAssignmentOp() || BO->isCompoundAssignmentOp())
       return AnalyzeCompoundAssignment(S, BO);
   }
 
   // These break the otherwise-useful invariant below.  Fortunately,
   // we don't really need to recurse into them, because any internal
   // expressions should have been analyzed already when they were
   // built into statements.
   if (isa<StmtExpr>(E)) return;
if (SemaRef.getLangOpts().CPlusPlus17) {
         SequencedSubexpression SeqBefore(*this);
         Region = RHSRegion;
         Visit(BO->getRHS());
       }
 
       Region = LHSRegion;
       Visit(BO->getLHS());
 
-      if (O && isa<CompoundAssignOperator>(BO))
+      if (O && BO->isCompoundAssignmentOp())
         notePostUse(O, BO);
 
     } else {
       // C++11 does not specify any sequencing between the LHS and RHS.
       Region = LHSRegion;
       Visit(BO->getLHS());
 
-      if (O && isa<CompoundAssignOperator>(BO))
+      if (O && BO->isCompoundAssignmentOp())
         notePostUse(O, BO);
 
       Region = RHSRegion;
       Visit(BO->getRHS());
     }
 
     // C++11 [expr.ass]p1:
     //  the assignment is sequenced [...] before the value computation of the
     //  assignment expression.
     // C11 6.5.16/3 has no such rule.
     Region = OldRegion;
     if (O)
       notePostMod(O, BO,
                   SemaRef.getLangOpts().CPlusPlus ? UK_ModAsValue
                                                   : UK_ModAsSideEffect);
     if (SemaRef.getLangOpts().CPlusPlus17) {
       Tree.merge(RHSRegion);
       Tree.merge(LHSRegion);
     }
   }
 
-  void VisitCompoundAssignOperator(const CompoundAssignOperator *CAO) {
-    VisitBinAssign(CAO);
-  }
-
   void VisitUnaryPreInc(const UnaryOperator *UO) { VisitUnaryPreIncDec(UO); }
   void VisitUnaryPreDec(const UnaryOperator *UO) { VisitUnaryPreIncDec(UO); }
   void VisitUnaryPreIncDec(const UnaryOperator *UO) {
     Object O = getObject(UO->getSubExpr(), true);
     if (!O)
       return VisitExpr(UO);
 
     notePreMod(O, UO);

clang/lib/Sema/SemaExceptionSpec.cpp

if (cast<Expr>(S)->getType()->isVariablyModifiedType())
       return CT_Can;
     return canSubStmtsThrow(*this, S);
 
     // Some might be dependent for other reasons.
   case Expr::ArraySubscriptExprClass:
   case Expr::OMPArraySectionExprClass:
   case Expr::BinaryOperatorClass:
   case Expr::DependentCoawaitExprClass:
-  case Expr::CompoundAssignOperatorClass:
   case Expr::CStyleCastExprClass:
   case Expr::CXXStaticCastExprClass:
   case Expr::CXXFunctionalCastExprClass:
   case Expr::ImplicitCastExprClass:
   case Expr::MaterializeTemporaryExprClass:
   case Expr::UnaryOperatorClass: {
     // FIXME: Properly determine whether a variably-modified type can throw.
     if (auto *CE = dyn_cast<CastExpr>(S))

clang/lib/Sema/SemaExpr.cpp

if (isa<CXXPseudoDestructorExpr>(Fn)) {
         // Pseudo-destructor calls should not have any arguments.
         Diag(Fn->getBeginLoc(), diag::err_pseudo_dtor_call_with_args)
             << FixItHint::CreateRemoval(
                    SourceRange(ArgExprs.front()->getBeginLoc(),
                                ArgExprs.back()->getEndLoc()));
       }
 
       return CallExpr::Create(Context, Fn, /*Args=*/{}, Context.VoidTy,
-                              VK_RValue, RParenLoc);
+                              VK_RValue, RParenLoc, FPFeatures);
     }
     if (Fn->getType() == Context.PseudoObjectTy) {
       ExprResult result = CheckPlaceholderExpr(Fn);
       if (result.isInvalid()) return ExprError();
       Fn = result.get();
     }
 
     // Determine whether this is a dependent call inside a C++ template,
     // in which case we won't do any semantic analysis now.
     if (Fn->isTypeDependent() || Expr::hasAnyTypeDependentArguments(ArgExprs)) {
       if (ExecConfig) {
         return CUDAKernelCallExpr::Create(
             Context, Fn, cast<CallExpr>(ExecConfig), ArgExprs,
             Context.DependentTy, VK_RValue, RParenLoc);
       } else {
 
         tryImplicitlyCaptureThisIfImplicitMemberFunctionAccessWithDependentArgs(
             *this, dyn_cast<UnresolvedMemberExpr>(Fn->IgnoreParens()),
             Fn->getBeginLoc());
 
         return CallExpr::Create(Context, Fn, ArgExprs, Context.DependentTy,
-                                VK_RValue, RParenLoc);
+                                VK_RValue, RParenLoc, FPFeatures);
       }
     }
 
     // Determine whether this is a call to an object (C++ [over.call.object]).
     if (Fn->getType()->isRecordType())
       return BuildCallToObjectOfClassType(Scope, Fn, LParenLoc, ArgExprs,
                                           RParenLoc);
 
ExprResult Sema::BuildCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
   // Check for overloaded calls.  This can happen even in C due to extensions.
   if (Fn->getType() == Context.OverloadTy) {
     OverloadExpr::FindResult find = OverloadExpr::find(Fn);
 
     // We aren't supposed to apply this logic if there's an '&' involved.
     if (!find.HasFormOfMemberPointer) {
       if (Expr::hasAnyTypeDependentArguments(ArgExprs))
         return CallExpr::Create(Context, Fn, ArgExprs, Context.DependentTy,
-                                VK_RValue, RParenLoc);
+                                VK_RValue, RParenLoc, FPFeatures);
       OverloadExpr *ovl = find.Expression;
       if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(ovl))
         return BuildOverloadedCallExpr(
             Scope, Fn, ULE, LParenLoc, ArgExprs, RParenLoc, ExecConfig,
             /*AllowTypoCorrection=*/true, find.IsAddressOfOperand);
       return BuildCallToMemberFunction(Scope, Fn, LParenLoc, ArgExprs,
                                        RParenLoc);
     }
ExprResult Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl,
   if (Config) {
     assert(UsesADL == ADLCallKind::NotADL &&
            "CUDAKernelCallExpr should not use ADL");
     TheCall =
         CUDAKernelCallExpr::Create(Context, Fn, cast<CallExpr>(Config), Args,
                                    ResultTy, VK_RValue, RParenLoc, NumParams);
   } else {
     TheCall = CallExpr::Create(Context, Fn, Args, ResultTy, VK_RValue,
-                               RParenLoc, NumParams, UsesADL);
+                               RParenLoc, FPFeatures, NumParams, UsesADL);
   }
 
   if (!getLangOpts().CPlusPlus) {
     // Forget about the nulled arguments since typo correction
     // do not handle them well.
     TheCall->shrinkNumArgs(Args.size());
     // C cannot always handle TypoExpr nodes in builtin calls and direct
     // function calls as their argument checking don't necessarily handle
if (!getLangOpts().CPlusPlus) {
     // immaterial since this only happens when some typos were corrected.
     if (CorrectedTypos && Args.size() < NumParams) {
       if (Config)
         TheCall = CUDAKernelCallExpr::Create(
             Context, Fn, cast<CallExpr>(Config), Args, ResultTy, VK_RValue,
             RParenLoc, NumParams);
       else
         TheCall = CallExpr::Create(Context, Fn, Args, ResultTy, VK_RValue,
-                                   RParenLoc, NumParams, UsesADL);
+                                   RParenLoc, FPFeatures, NumParams, UsesADL);
     }
     // We can now handle the nulled arguments for the default arguments.
     TheCall->setNumArgsUnsafe(std::max<unsigned>(Args.size(), NumParams));
   }
 
   // Bail out early if calling a builtin with custom type checking.
   if (BuiltinID && Context.BuiltinInfo.hasCustomTypechecking(BuiltinID))
     return CheckBuiltinFunctionCall(FDecl, BuiltinID, TheCall);
static ExprResult convertHalfVecBinOp(Sema &S, ExprResult LHS, ExprResult RHS,
   QualType BinOpResTy = RHS.get()->getType();
 
   // If Opc is a comparison, ResultType is a vector of shorts. In that case,
   // change BinOpResTy to a vector of ints.
   if (isVector(ResultTy, Context.ShortTy))
     BinOpResTy = S.GetSignedVectorType(BinOpResTy);
 
   if (IsCompAssign)
-    return new (Context) CompoundAssignOperator(
-        LHS.get(), RHS.get(), Opc, ResultTy, VK, OK, BinOpResTy, BinOpResTy,
-        OpLoc, FPFeatures);
+    return BinaryOperator::Create(Context, LHS.get(), RHS.get(), Opc, ResultTy,
+                                  VK, OK, BinOpResTy, BinOpResTy, OpLoc,
+                                  FPFeatures);
 
   LHS = convertVector(LHS.get(), Context.FloatTy, S);
-  auto *BO = new (Context) BinaryOperator(LHS.get(), RHS.get(), Opc, BinOpResTy,
-                                          VK, OK, OpLoc, FPFeatures);
+  auto *BO = BinaryOperator::Create(Context, LHS.get(), RHS.get(), Opc,
+                                    BinOpResTy, VK, OK, OpLoc, FPFeatures);
   return convertVector(BO, ResultTy->castAs<VectorType>()->getElementType(), S);
 }
 
 static std::pair<ExprResult, ExprResult>
 CorrectDelayedTyposInBinOp(Sema &S, BinaryOperatorKind Opc, Expr *LHSExpr,
                            Expr *RHSExpr) {
   ExprResult LHS = LHSExpr, RHS = RHSExpr;
   if (!S.getLangOpts().CPlusPlus) {
else if (const ObjCIvarRefExpr *OIRE =
            dyn_cast<ObjCIvarRefExpr>(LHS.get()->IgnoreParenCasts()))
     DiagnoseDirectIsaAccess(*this, OIRE, OpLoc, RHS.get());
 
   // Opc is not a compound assignment if CompResultTy is null.
   if (CompResultTy.isNull()) {
     if (ConvertHalfVec)
       return convertHalfVecBinOp(*this, LHS, RHS, Opc, ResultTy, VK, OK, false,
                                  OpLoc, FPFeatures);
-    return new (Context) BinaryOperator(LHS.get(), RHS.get(), Opc, ResultTy, VK,
-                                        OK, OpLoc, FPFeatures);
+    return BinaryOperator::Create(Context, LHS.get(), RHS.get(), Opc, ResultTy,
+                                  VK, OK, OpLoc, FPFeatures);
   }
 
   // Handle compound assignments.
   if (getLangOpts().CPlusPlus && LHS.get()->getObjectKind() !=
       OK_ObjCProperty) {
     VK = VK_LValue;
     OK = LHS.get()->getObjectKind();
   }
 
   if (ConvertHalfVec)
     return convertHalfVecBinOp(*this, LHS, RHS, Opc, ResultTy, VK, OK, true,
                                OpLoc, FPFeatures);
 
-  return new (Context) CompoundAssignOperator(
-      LHS.get(), RHS.get(), Opc, ResultTy, VK, OK, CompLHSTy, CompResultTy,
-      OpLoc, FPFeatures);
+  if (!BinaryOperator::isCompoundAssignmentOp(Opc))
+    return BinaryOperator::Create(Context, LHS.get(), RHS.get(), Opc, ResultTy,
+                                  VK, OK, OpLoc, FPFeatures);
+  return BinaryOperator::Create(Context, LHS.get(), RHS.get(), Opc, ResultTy,
+                                VK, OK, CompLHSTy, CompResultTy, OpLoc,
+                                FPFeatures);
 }
 
 /// DiagnoseBitwisePrecedence - Emit a warning when bitwise and comparison
 /// operators are mixed in a way that suggests that the programmer forgot that
 /// comparison operators have higher precedence. The most typical example of
 /// such code is "flags & 0x0020 != 0", which is equivalent to "flags & 1".
 static void DiagnoseBitwisePrecedence(Sema &Self, BinaryOperatorKind Opc,
                                       SourceLocation OpLoc, Expr *LHSExpr,
case BuiltinType::BuiltinFn: {
     auto *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts());
     if (DRE) {
       auto *FD = cast<FunctionDecl>(DRE->getDecl());
       if (FD->getBuiltinID() == Builtin::BI__noop) {
         E = ImpCastExprToType(E, Context.getPointerType(FD->getType()),
                               CK_BuiltinFnToFnPtr)
                 .get();
         return CallExpr::Create(Context, E, /*Args=*/{}, Context.IntTy,
-                                VK_RValue, SourceLocation());
+                                VK_RValue, SourceLocation(), FPFeatures);
       }
     }
 
     Diag(E->getBeginLoc(), diag::err_builtin_fn_use);
     return ExprError();
   }
 
   // Expressions of unknown type.

clang/lib/Sema/SemaExprCXX.cpp

ExprResult Sema::ActOnDecltypeExpression(Expr *E) {
   }
   if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
     if (BO->getOpcode() == BO_Comma) {
       ExprResult RHS = ActOnDecltypeExpression(BO->getRHS());
       if (RHS.isInvalid())
         return ExprError();
       if (RHS.get() == BO->getRHS())
         return E;
-      return new (Context) BinaryOperator(
-          BO->getLHS(), RHS.get(), BO_Comma, BO->getType(), BO->getValueKind(),
-          BO->getObjectKind(), BO->getOperatorLoc(), BO->getFPFeatures());
+      return BinaryOperator::Create(
+          Context, BO->getLHS(), RHS.get(), BO_Comma, BO->getType(),
+          BO->getValueKind(), BO->getObjectKind(), BO->getOperatorLoc(),
+          BO->HasFPFeatures() ? BO->getFPFeatures() : FPOptions());
     }
   }
 
   CXXBindTemporaryExpr *TopBind = dyn_cast<CXXBindTemporaryExpr>(E);
   CallExpr *TopCall = TopBind ? dyn_cast<CallExpr>(TopBind->getSubExpr())
                               : nullptr;
   if (TopCall)
     E = TopCall;

clang/lib/Sema/SemaOpenMP.cpp

bool OpenMPAtomicUpdateChecker::checkStatement(Stmt *S, unsigned DiagId,
   //  --x;
   //  x binop= expr;
   //  x = x binop expr;
   //  x = expr binop x;
   if (auto *AtomicBody = dyn_cast<Expr>(S)) {
     AtomicBody = AtomicBody->IgnoreParenImpCasts();
     if (AtomicBody->getType()->isScalarType() ||
         AtomicBody->isInstantiationDependent()) {
-      if (const auto *AtomicCompAssignOp = dyn_cast<CompoundAssignOperator>(
-              AtomicBody->IgnoreParenImpCasts())) {
-        // Check for Compound Assignment Operation
+      if (auto *AtomicBinOp =
+              dyn_cast<BinaryOperator>(AtomicBody->IgnoreParenImpCasts())) {
+        if (AtomicBinOp->isCompoundAssignmentOp()) {
           Op = BinaryOperator::getOpForCompoundAssignment(
-            AtomicCompAssignOp->getOpcode());
-        OpLoc = AtomicCompAssignOp->getOperatorLoc();
-        E = AtomicCompAssignOp->getRHS();
-        X = AtomicCompAssignOp->getLHS()->IgnoreParens();
+              AtomicBinOp->getOpcode());
+          OpLoc = AtomicBinOp->getOperatorLoc();
+          E = AtomicBinOp->getRHS();
+          X = AtomicBinOp->getLHS()->IgnoreParens();
           IsXLHSInRHSPart = true;
-      } else if (auto *AtomicBinOp = dyn_cast<BinaryOperator>(
-                     AtomicBody->IgnoreParenImpCasts())) {
-        // Check for Binary Operation
-        if (checkBinaryOperation(AtomicBinOp, DiagId, NoteId))
+        } else if (checkBinaryOperation(AtomicBinOp, DiagId, NoteId))
           return true;
+        // Check for Binary Operation
       } else if (const auto *AtomicUnaryOp = dyn_cast<UnaryOperator>(
                      AtomicBody->IgnoreParenImpCasts())) {
         // Check for Unary Operation
         if (AtomicUnaryOp->isIncrementDecrementOp()) {
           IsPostfixUpdate = AtomicUnaryOp->isPostfix();
           Op = AtomicUnaryOp->isIncrementOp() ? BO_Add : BO_Sub;
           OpLoc = AtomicUnaryOp->getOperatorLoc();
           X = AtomicUnaryOp->getSubExpr()->IgnoreParens();
if (DeclareReductionRef.isUsable()) {
       }
       FunctionProtoType::ExtProtoInfo EPI;
       QualType Params[] = {PtrRedTy, PtrRedTy};
       QualType FnTy = Context.getFunctionType(Context.VoidTy, Params, EPI);
       auto *OVE = new (Context) OpaqueValueExpr(
           ELoc, Context.getPointerType(FnTy), VK_RValue, OK_Ordinary,
           S.DefaultLvalueConversion(DeclareReductionRef.get()).get());
       Expr *Args[] = {LHS.get(), RHS.get()};
-      ReductionOp =
-          CallExpr::Create(Context, OVE, Args, Context.VoidTy, VK_RValue, ELoc);
+      ReductionOp = CallExpr::Create(Context, OVE, Args, Context.VoidTy,
+                                     VK_RValue, ELoc, S.FPFeatures);
     } else {
       ReductionOp = S.BuildBinOp(
           Stack->getCurScope(), ReductionId.getBeginLoc(), BOK, LHSDRE, RHSDRE);
       if (ReductionOp.isUsable()) {
         if (BOK != BO_LT && BOK != BO_GT) {
           ReductionOp =
               S.BuildBinOp(Stack->getCurScope(), ReductionId.getBeginLoc(),
                            BO_Assign, LHSDRE, ReductionOp.get());

clang/lib/Sema/SemaOverload.cpp

if (getLangOpts().MSVCCompat &&
     if (CandidateSet->empty() ||
         CandidateSet->BestViableFunction(*this, Fn->getBeginLoc(), Best) ==
             OR_No_Viable_Function) {
       // In Microsoft mode, if we are inside a template class member function
       // then create a type dependent CallExpr. The goal is to postpone name
       // lookup to instantiation time to be able to search into type dependent
       // base classes.
       CallExpr *CE = CallExpr::Create(Context, Fn, Args, Context.DependentTy,
-                                      VK_RValue, RParenLoc);
+                                      VK_RValue, RParenLoc, FPFeatures);
       CE->markDependentForPostponedNameLookup();
       *Result = CE;
       return true;
     }
   }
 
   if (CandidateSet->empty())
     return false;
if (FnDecl) {
 
       // Determine the result type.
       QualType ResultTy = FnDecl->getReturnType();
       ExprValueKind VK = Expr::getValueKindForType(ResultTy);
       ResultTy = ResultTy.getNonLValueExprType(Context);
 
       Args[0] = Input;
       CallExpr *TheCall = CXXOperatorCallExpr::Create(
-          Context, Op, FnExpr.get(), ArgsArray, ResultTy, VK, OpLoc,
-          FPOptions(), Best->IsADLCandidate);
+          Context, Op, FnExpr.get(), ArgsArray, ResultTy, VK, OpLoc, FPFeatures,
+          Best->IsADLCandidate);
 
       if (CheckCallReturnType(FnDecl->getReturnType(), OpLoc, TheCall, FnDecl))
         return ExprError();
 
       if (CheckFunctionCall(FnDecl, TheCall,
                             FnDecl->getType()->castAs<FunctionProtoType>()))
         return ExprError();
       return CheckForImmediateInvocation(MaybeBindToTemporary(TheCall), FnDecl);
ExprResult Sema::CreateOverloadedBinOp(SourceLocation OpLoc,
 
   // If either side is type-dependent, create an appropriate dependent
   // expression.
   if (Args[0]->isTypeDependent() || Args[1]->isTypeDependent()) {
     if (Fns.empty()) {
       // If there are no functions to store, just build a dependent
       // BinaryOperator or CompoundAssignment.
       if (Opc <= BO_Assign || Opc > BO_OrAssign)
-        return new (Context) BinaryOperator(
-            Args[0], Args[1], Opc, Context.DependentTy, VK_RValue, OK_Ordinary,
+        return BinaryOperator::Create(Context, Args[0], Args[1], Opc,
+                                      Context.DependentTy, VK_RValue,
+                                      OK_Ordinary, OpLoc, FPFeatures);
+
+      return BinaryOperator::Create(Context, Args[0], Args[1], Opc,
+                                    Context.DependentTy, VK_LValue, OK_Ordinary,
+                                    Context.DependentTy, Context.DependentTy,
                                     OpLoc, FPFeatures);
-
-      return new (Context) CompoundAssignOperator(
-          Args[0], Args[1], Opc, Context.DependentTy, VK_LValue, OK_Ordinary,
-          Context.DependentTy, Context.DependentTy, OpLoc,
-          FPFeatures);
     }
 
     // FIXME: save results of ADL from here?
     CXXRecordDecl *NamingClass = nullptr; // lookup ignores member operators
     // TODO: provide better source location info in DNLoc component.
     DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(Op);
     DeclarationNameInfo OpNameInfo(OpName, OpLoc);
     UnresolvedLookupExpr *Fn = UnresolvedLookupExpr::Create(
case OR_Success: {
         QualType ResultTy = FnDecl->getReturnType();
         ExprValueKind VK = Expr::getValueKindForType(ResultTy);
         ResultTy = ResultTy.getNonLValueExprType(Context);
 
         CXXOperatorCallExpr *TheCall =
             CXXOperatorCallExpr::Create(Context, OO_Subscript, FnExpr.get(),
                                         Args, ResultTy, VK, RLoc, FPOptions());
 
         if (CheckCallReturnType(FnDecl->getReturnType(), LLoc, TheCall, FnDecl))
           return ExprError();
 
         if (CheckFunctionCall(Method, TheCall,
                               Method->getType()->castAs<FunctionProtoType>()))
           return ExprError();
 
         return MaybeBindToTemporary(TheCall);
       } else {
if (BinaryOperator *op = dyn_cast<BinaryOperator>(NakedMemExpr)) {
     if (CheckOtherCall(call, proto))
       return ExprError();
 
     return MaybeBindToTemporary(call);
   }
 
   if (isa<CXXPseudoDestructorExpr>(NakedMemExpr))
     return CallExpr::Create(Context, MemExprE, Args, Context.VoidTy, VK_RValue,
-                            RParenLoc);
+                            RParenLoc, FPFeatures);
 
   UnbridgedCastsSet UnbridgedCasts;
   if (checkArgPlaceholdersForOverload(*this, Args, UnbridgedCasts))
     return ExprError();
 
   MemberExpr *MemExpr;
   CXXMethodDecl *Method = nullptr;
   DeclAccessPair FoundDecl = DeclAccessPair::make(nullptr, AS_public);
ExprResult FnExpr = CreateFunctionRefExpr(*this, Method, Best->FoundDecl,
                                             Base, HadMultipleCandidates, OpLoc);
   if (FnExpr.isInvalid())
     return ExprError();
 
   QualType ResultTy = Method->getReturnType();
   ExprValueKind VK = Expr::getValueKindForType(ResultTy);
   ResultTy = ResultTy.getNonLValueExprType(Context);
   CXXOperatorCallExpr *TheCall = CXXOperatorCallExpr::Create(
-      Context, OO_Arrow, FnExpr.get(), Base, ResultTy, VK, OpLoc, FPOptions());
+      Context, OO_Arrow, FnExpr.get(), Base, ResultTy, VK, OpLoc, FPFeatures);
 
   if (CheckCallReturnType(Method->getReturnType(), OpLoc, TheCall, Method))
     return ExprError();
 
   if (CheckFunctionCall(Method, TheCall,
                         Method->getType()->castAs<FunctionProtoType>()))
     return ExprError();
 

clang/lib/Sema/SemaPseudoObject.cpp

if (RHS->hasPlaceholderType() || isa<InitListExpr>(RHS)) {
     Semantics.pop_back();
   }
 
   Expr *syntactic;
 
   ExprResult result;
   if (opcode == BO_Assign) {
     result = semanticRHS;
-    syntactic = new (S.Context) BinaryOperator(syntacticLHS, capturedRHS,
-                                               opcode, capturedRHS->getType(),
-                                               capturedRHS->getValueKind(),
-                                               OK_Ordinary, opcLoc,
-                                               FPOptions());
+    syntactic = BinaryOperator::Create(
+        S.Context, syntacticLHS, capturedRHS, opcode, capturedRHS->getType(),
+        capturedRHS->getValueKind(), OK_Ordinary, opcLoc, FPOptions());
   } else {
     ExprResult opLHS = buildGet();
     if (opLHS.isInvalid()) return ExprError();
 
     // Build an ordinary, non-compound operation.
     BinaryOperatorKind nonCompound =
       BinaryOperator::getOpForCompoundAssignment(opcode);
     result = S.BuildBinOp(Sc, opcLoc, nonCompound, opLHS.get(), semanticRHS);
     if (result.isInvalid()) return ExprError();
 
-    syntactic =
-      new (S.Context) CompoundAssignOperator(syntacticLHS, capturedRHS, opcode,
-                                             result.get()->getType(),
-                                             result.get()->getValueKind(),
-                                             OK_Ordinary,
-                                             opLHS.get()->getType(),
-                                             result.get()->getType(),
-                                             opcLoc, FPOptions());
+    syntactic = BinaryOperator::Create(
+        S.Context, syntacticLHS, capturedRHS, opcode, result.get()->getType(),
+        result.get()->getValueKind(), OK_Ordinary, opLHS.get()->getType(),
+        result.get()->getType(), opcLoc, FPOptions());
   }
 
   // The result of the assignment, if not void, is the value set into
   // the l-value.
   result = buildSet(result.get(), opcLoc, captureSetValueAsResult());
   if (result.isInvalid()) return ExprError();
   addSemanticExpr(result.get());
   if (!captureSetValueAsResult() && !result.get()->getType()->isVoidType() &&
ExprResult Sema::checkPseudoObjectIncDec(Scope *Sc, SourceLocation opcLoc,
   }
 }
 
 ExprResult Sema::checkPseudoObjectAssignment(Scope *S, SourceLocation opcLoc,
                                              BinaryOperatorKind opcode,
                                              Expr *LHS, Expr *RHS) {
   // Do nothing if either argument is dependent.
   if (LHS->isTypeDependent() || RHS->isTypeDependent())
-    return new (Context) BinaryOperator(LHS, RHS, opcode, Context.DependentTy,
-                                        VK_RValue, OK_Ordinary, opcLoc,
-                                        FPOptions());
+    return BinaryOperator::Create(Context, LHS, RHS, opcode,
+                                  Context.DependentTy, VK_RValue, OK_Ordinary,
+                                  opcLoc, FPOptions());
 
   // Filter out non-overload placeholder types in the RHS.
   if (RHS->getType()->isNonOverloadPlaceholderType()) {
     ExprResult result = CheckPlaceholderExpr(RHS);
     if (result.isInvalid()) return ExprError();
     RHS = result.get();
   }
 

 /// Given a pseudo-object expression, recreate what it looks like
 /// syntactically without the attendant OpaqueValueExprs.
 ///
 /// This is a hack which should be removed when TreeTransform is
 /// capable of rebuilding a tree without stripping implicit
 /// operations.
 Expr *Sema::recreateSyntacticForm(PseudoObjectExpr *E) {
   Expr *syntax = E->getSyntacticForm();
+  BinaryOperator *bop = dyn_cast<BinaryOperator>(syntax);
   if (UnaryOperator *uop = dyn_cast<UnaryOperator>(syntax)) {
     Expr *op = stripOpaqueValuesFromPseudoObjectRef(*this, uop->getSubExpr());
     return new (Context) UnaryOperator(
         op, uop->getOpcode(), uop->getType(), uop->getValueKind(),
         uop->getObjectKind(), uop->getOperatorLoc(), uop->canOverflow());
-  } else if (CompoundAssignOperator *cop
-               = dyn_cast<CompoundAssignOperator>(syntax)) {
-    Expr *lhs = stripOpaqueValuesFromPseudoObjectRef(*this, cop->getLHS());
-    Expr *rhs = cast<OpaqueValueExpr>(cop->getRHS())->getSourceExpr();
-    return new (Context) CompoundAssignOperator(lhs, rhs, cop->getOpcode(),
-                                                cop->getType(),
-                                                cop->getValueKind(),
-                                                cop->getObjectKind(),
-                                                cop->getComputationLHSType(),
-                                                cop->getComputationResultType(),
-                                                cop->getOperatorLoc(),
-                                                FPOptions());
-  } else if (BinaryOperator *bop = dyn_cast<BinaryOperator>(syntax)) {
+  } else if (bop && bop->isCompoundAssignmentOp()) {
+    Expr *lhs = stripOpaqueValuesFromPseudoObjectRef(*this, bop->getLHS());
+    Expr *rhs = cast<OpaqueValueExpr>(bop->getRHS())->getSourceExpr();
+    return BinaryOperator::Create(
+        Context, lhs, rhs, bop->getOpcode(), bop->getType(),
+        bop->getValueKind(), bop->getObjectKind(), bop->getComputationLHSType(),
+        bop->getComputationResultType(), bop->getOperatorLoc(), FPOptions());
+  } else if (bop) {
     Expr *lhs = stripOpaqueValuesFromPseudoObjectRef(*this, bop->getLHS());
     Expr *rhs = cast<OpaqueValueExpr>(bop->getRHS())->getSourceExpr();
-    return new (Context) BinaryOperator(lhs, rhs, bop->getOpcode(),
-                                        bop->getType(), bop->getValueKind(),
-                                        bop->getObjectKind(),
-                                        bop->getOperatorLoc(), FPOptions());
+    return BinaryOperator::Create(Context, lhs, rhs, bop->getOpcode(),
+                                  bop->getObjectKind(), bop->getOperatorLoc(),
+                                  FPOptions());
   } else {
     assert(syntax->hasPlaceholderType(BuiltinType::PseudoObject));
     return stripOpaqueValuesFromPseudoObjectRef(*this, syntax);
   }
 }

clang/lib/Sema/TreeTransform.h

Expr *Callee = new (SemaRef.Context)
                     SemaRef.Context.BuiltinFnTy, VK_RValue, BuiltinLoc);
     QualType CalleePtrTy = SemaRef.Context.getPointerType(Builtin->getType());
     Callee = SemaRef.ImpCastExprToType(Callee, CalleePtrTy,
                                        CK_BuiltinFnToFnPtr).get();
 
     // Build the CallExpr
     ExprResult TheCall = CallExpr::Create(
         SemaRef.Context, Callee, SubExprs, Builtin->getCallResultType(),
-        Expr::getValueKindForType(Builtin->getReturnType()), RParenLoc);
+        Expr::getValueKindForType(Builtin->getReturnType()), RParenLoc,
+        FPOptions());
 
     // Type-check the __builtin_shufflevector expression.
     return SemaRef.SemaBuiltinShuffleVector(cast<CallExpr>(TheCall.get()));
   }
 
   /// Build a new convert vector expression.
   ExprResult RebuildConvertVectorExpr(SourceLocation BuiltinLoc,
                                       Expr *SrcExpr, TypeSourceInfo *DstTInfo,
if (RHS.isInvalid())
     return ExprError();
 
   if (!getDerived().AlwaysRebuild() &&
       LHS.get() == E->getLHS() &&
       RHS.get() == E->getRHS())
     return E;
 
   Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
+  if (E->HasFPFeatures())
     getSema().FPFeatures = E->getFPFeatures();
+  else
+    getSema().FPFeatures = FPOptions();
 
   return getDerived().RebuildBinaryOperator(E->getOperatorLoc(), E->getOpcode(),
                                             LHS.get(), RHS.get());
 }
 
 template <typename Derived>
 ExprResult TreeTransform<Derived>::TransformCXXRewrittenBinaryOperator(
     CXXRewrittenBinaryOperator *E) {
for (Expr *PossibleBinOp : PossibleBinOps) {
     UnqualLookups.addDecl(Found);
   }
 
   return getDerived().RebuildCXXRewrittenBinaryOperator(
       E->getOperatorLoc(), Decomp.Opcode, UnqualLookups, LHS.get(), RHS.get());
 }
 
 template<typename Derived>
-ExprResult
-TreeTransform<Derived>::TransformCompoundAssignOperator(
-                                                      CompoundAssignOperator *E) {
-  return getDerived().TransformBinaryOperator(E);
-}
-
-template<typename Derived>
 ExprResult TreeTransform<Derived>::
 TransformBinaryConditionalOperator(BinaryConditionalOperator *e) {
   // Just rebuild the common and RHS expressions and see whether we
   // get any changes.
 
   ExprResult commonExpr = getDerived().TransformExpr(e->getCommon());
   if (commonExpr.isInvalid())
     return ExprError();

clang/lib/Serialization/ASTReaderStmt.cpp

void ASTStmtReader::VisitOMPArraySectionExpr(OMPArraySectionExpr *E) {
   E->setRBracketLoc(readSourceLocation());
 }
 
 void ASTStmtReader::VisitCallExpr(CallExpr *E) {
   VisitExpr(E);
   unsigned NumArgs = Record.readInt();
   assert((NumArgs == E->getNumArgs()) && "Wrong NumArgs!");
   E->setRParenLoc(readSourceLocation());
+  E->setFPFeatures(FPOptions(Record.readInt()));
   E->setCallee(Record.readSubExpr());
   for (unsigned I = 0; I != NumArgs; ++I)
     E->setArg(I, Record.readSubExpr());
   E->setADLCallKind(static_cast<CallExpr::ADLCallKind>(Record.readInt()));
 }
 
 void ASTStmtReader::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
   VisitCallExpr(E);
void ASTStmtReader::VisitCastExpr(CastExpr *E) {
   while (NumBaseSpecs--) {
     auto *BaseSpec = new (Record.getContext()) CXXBaseSpecifier;
     *BaseSpec = Record.readCXXBaseSpecifier();
     *BaseI++ = BaseSpec;
   }
 }
 
 void ASTStmtReader::VisitBinaryOperator(BinaryOperator *E) {
+  bool hasFP_Features;
+  bool isCompoundAssign;
   VisitExpr(E);
+  E->setHasFPFeatures(hasFP_Features = Record.readInt());
+  E->setIsCompoundAssign(isCompoundAssign = Record.readInt());
   E->setLHS(Record.readSubExpr());
   E->setRHS(Record.readSubExpr());
   E->setOpcode((BinaryOperator::Opcode)Record.readInt());
   E->setOperatorLoc(readSourceLocation());
-  E->setFPFeatures(FPOptions(Record.readInt()));
+  if (hasFP_Features) {
+    int x = Record.readInt();
+    E->setFPFeatures(FPOptions(x));
   }
-
-void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
-  VisitBinaryOperator(E);
+  if (isCompoundAssign) {
     E->setComputationLHSType(Record.readType());
     E->setComputationResultType(Record.readType());
   }
+}
 
 void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) {
   VisitExpr(E);
   E->SubExprs[ConditionalOperator::COND] = Record.readSubExpr();
   E->SubExprs[ConditionalOperator::LHS] = Record.readSubExpr();
   E->SubExprs[ConditionalOperator::RHS] = Record.readSubExpr();
   E->QuestionLoc = readSourceLocation();
   E->ColonLoc = readSourceLocation();
void ASTStmtReader::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) {
   S->QualifierLoc = Record.readNestedNameSpecifierLoc();
   S->NameInfo = Record.readDeclarationNameInfo();
   S->SubStmt = Record.readSubStmt();
 }
 
 void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
   VisitCallExpr(E);
   E->CXXOperatorCallExprBits.OperatorKind = Record.readInt();
-  E->CXXOperatorCallExprBits.FPFeatures = Record.readInt();
   E->Range = Record.readSourceRange();
 }
 
 void ASTStmtReader::VisitCXXRewrittenBinaryOperator(
     CXXRewrittenBinaryOperator *E) {
   VisitExpr(E);
   E->CXXRewrittenBinaryOperatorBits.IsReversed = Record.readInt();
   E->SemanticForm = Record.readSubExpr();
while (true) {
     bool Finished = false;
     bool IsStmtReference = false;
     Expected<unsigned> MaybeStmtCode = Record.readRecord(Cursor, Entry.ID);
     if (!MaybeStmtCode) {
       Error(toString(MaybeStmtCode.takeError()));
       return nullptr;
     }
     switch ((StmtCode)MaybeStmtCode.get()) {
+    default:
+      llvm_unreachable("Unexpected StmtCode");
     case STMT_STOP:
       Finished = true;
       break;
 
     case STMT_REF_PTR:
       IsStmtReference = true;
       assert(StmtEntries.find(Record[0]) != StmtEntries.end() &&
              "No stmt was recorded for this offset reference!");
while (true) {
     case EXPR_MEMBER:
       S = MemberExpr::CreateEmpty(Context, Record[ASTStmtReader::NumExprFields],
                                   Record[ASTStmtReader::NumExprFields + 1],
                                   Record[ASTStmtReader::NumExprFields + 2],
                                   Record[ASTStmtReader::NumExprFields + 3]);
       break;
 
     case EXPR_BINARY_OPERATOR:
-      S = new (Context) BinaryOperator(Empty);
-      break;
-
-    case EXPR_COMPOUND_ASSIGN_OPERATOR:
-      S = new (Context) CompoundAssignOperator(Empty);
+      S = BinaryOperator::CreateEmpty(Context,
+                                      Record[ASTStmtReader::NumExprFields],
+                                      Record[ASTStmtReader::NumExprFields + 1]);
       break;
 
     case EXPR_CONDITIONAL_OPERATOR:
       S = new (Context) ConditionalOperator(Empty);
       break;
 
     case EXPR_BINARY_CONDITIONAL_OPERATOR:
       S = new (Context) BinaryConditionalOperator(Empty);

clang/lib/Serialization/ASTWriter.cpp

#define RECORD(X) EmitRecordID(X, #X, Stream, Record)
   RECORD(EXPR_PAREN);
   RECORD(EXPR_PAREN_LIST);
   RECORD(EXPR_UNARY_OPERATOR);
   RECORD(EXPR_SIZEOF_ALIGN_OF);
   RECORD(EXPR_ARRAY_SUBSCRIPT);
   RECORD(EXPR_CALL);
   RECORD(EXPR_MEMBER);
   RECORD(EXPR_BINARY_OPERATOR);
-  RECORD(EXPR_COMPOUND_ASSIGN_OPERATOR);
   RECORD(EXPR_CONDITIONAL_OPERATOR);
   RECORD(EXPR_IMPLICIT_CAST);
   RECORD(EXPR_CSTYLE_CAST);
   RECORD(EXPR_COMPOUND_LITERAL);
   RECORD(EXPR_EXT_VECTOR_ELEMENT);
   RECORD(EXPR_INIT_LIST);
   RECORD(EXPR_DESIGNATED_INIT);
   RECORD(EXPR_DESIGNATED_INIT_UPDATE);

clang/lib/Serialization/ASTWriterStmt.cpp

void ASTStmtWriter::VisitOMPArraySectionExpr(OMPArraySectionExpr *E) {
   Record.AddSourceLocation(E->getRBracketLoc());
   Code = serialization::EXPR_OMP_ARRAY_SECTION;
 }
 
 void ASTStmtWriter::VisitCallExpr(CallExpr *E) {
   VisitExpr(E);
   Record.push_back(E->getNumArgs());
   Record.AddSourceLocation(E->getRParenLoc());
+  Record.push_back(E->getFPFeatures().getInt());
   Record.AddStmt(E->getCallee());
   for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
        Arg != ArgEnd; ++Arg)
     Record.AddStmt(*Arg);
   Record.push_back(static_cast<unsigned>(E->getADLCallKind()));
   Code = serialization::EXPR_CALL;
 }
 
void ASTStmtWriter::VisitCastExpr(CastExpr *E) {
 
   for (CastExpr::path_iterator
          PI = E->path_begin(), PE = E->path_end(); PI != PE; ++PI)
     Record.AddCXXBaseSpecifier(**PI);
 }
 
 void ASTStmtWriter::VisitBinaryOperator(BinaryOperator *E) {
   VisitExpr(E);
+  bool HasFPFeatures = E->HasFPFeatures();
+  // Write this first for easy access when deserializing, as they affect the
+  // size of the UnaryOperator.
+  Record.push_back(HasFPFeatures);
+  Record.push_back(E->isCompoundAssignmentOp());
   Record.AddStmt(E->getLHS());
   Record.AddStmt(E->getRHS());
   Record.push_back(E->getOpcode()); // FIXME: stable encoding
   Record.AddSourceLocation(E->getOperatorLoc());
+  if (HasFPFeatures)
     Record.push_back(E->getFPFeatures().getInt());
-  Code = serialization::EXPR_BINARY_OPERATOR;
-}
-
-void ASTStmtWriter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
-  VisitBinaryOperator(E);
+  if (E->isCompoundAssignmentOp()) {
     Record.AddTypeRef(E->getComputationLHSType());
     Record.AddTypeRef(E->getComputationResultType());
-  Code = serialization::EXPR_COMPOUND_ASSIGN_OPERATOR;
+  }
+  Code = serialization::EXPR_BINARY_OPERATOR;
 }
 
 void ASTStmtWriter::VisitConditionalOperator(ConditionalOperator *E) {
   VisitExpr(E);
   Record.AddStmt(E->getCond());
   Record.AddStmt(E->getLHS());
   Record.AddStmt(E->getRHS());
   Record.AddSourceLocation(E->getQuestionLoc());
void ASTStmtWriter::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) {
   Record.AddDeclarationNameInfo(S->getNameInfo());
   Record.AddStmt(S->getSubStmt());
   Code = serialization::STMT_MS_DEPENDENT_EXISTS;
 }
 
 void ASTStmtWriter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
   VisitCallExpr(E);
   Record.push_back(E->getOperator());
-  Record.push_back(E->getFPFeatures().getInt());
   Record.AddSourceRange(E->Range);
   Code = serialization::EXPR_CXX_OPERATOR_CALL;
 }
 
 void ASTStmtWriter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
   VisitCallExpr(E);
   Code = serialization::EXPR_CXX_MEMBER_CALL;
 }

clang/lib/StaticAnalyzer/Checkers/IdenticalExprChecker.cpp

while (I1 != CompStmt1->body_end() && I2 != CompStmt2->body_end()) {
       if (!isIdenticalStmt(Ctx, *I1, *I2, IgnoreSideEffects))
         return false;
       ++I1;
       ++I2;
     }
 
     return true;
   }
-  case Stmt::CompoundAssignOperatorClass:
   case Stmt::BinaryOperatorClass: {
     const BinaryOperator *BinOp1 = cast<BinaryOperator>(Stmt1);
     const BinaryOperator *BinOp2 = cast<BinaryOperator>(Stmt2);
     return BinOp1->getOpcode() == BinOp2->getOpcode();
   }
   case Stmt::CharacterLiteralClass: {
     const CharacterLiteral *CharLit1 = cast<CharacterLiteral>(Stmt1);
     const CharacterLiteral *CharLit2 = cast<CharacterLiteral>(Stmt2);

clang/lib/StaticAnalyzer/Core/ExprEngine.cpp

switch (S->getStmtClass()) {
     case Stmt::ChooseExprClass: { // __builtin_choose_expr
       Bldr.takeNodes(Pred);
       const auto *C = cast<ChooseExpr>(S);
       VisitGuardedExpr(C, C->getLHS(), C->getRHS(), Pred, Dst);
       Bldr.addNodes(Dst);
       break;
     }
 
-    case Stmt::CompoundAssignOperatorClass:
-      Bldr.takeNodes(Pred);
-      VisitBinaryOperator(cast<BinaryOperator>(S), Pred, Dst);
-      Bldr.addNodes(Dst);
-      break;
-
     case Stmt::CompoundLiteralExprClass:
       Bldr.takeNodes(Pred);
       VisitCompoundLiteralExpr(cast<CompoundLiteralExpr>(S), Pred, Dst);
       Bldr.addNodes(Dst);
       break;
 
     case Stmt::BinaryConditionalOperatorClass:
     case Stmt::ConditionalOperatorClass: { // '?' operator

clang/lib/StaticAnalyzer/Core/ExprEngineC.cpp

for (ExplodedNodeSet::iterator it=CheckedSet.begin(), ei=CheckedSet.end();
     for (ExplodedNodeSet::iterator I = Tmp.begin(), E = Tmp.end(); I != E;
          ++I) {
 
       state = (*I)->getState();
       const LocationContext *LCtx = (*I)->getLocationContext();
       SVal V = state->getSVal(LHS, LCtx);
 
       // Get the computation type.
-      QualType CTy =
-        cast<CompoundAssignOperator>(B)->getComputationResultType();
+      QualType CTy = B->getComputationResultType();
       CTy = getContext().getCanonicalType(CTy);
 
-      QualType CLHSTy =
-        cast<CompoundAssignOperator>(B)->getComputationLHSType();
+      QualType CLHSTy = B->getComputationLHSType();
       CLHSTy = getContext().getCanonicalType(CLHSTy);
 
       QualType LTy = getContext().getCanonicalType(LHS->getType());
 
       // Promote LHS.
       V = svalBuilder.evalCast(V, CLHSTy, LTy);
 
       // Compute the result of the operation.

clang/test/AST/ast-dump-expr-json.c

 // CHECK-NEXT:       }
 // CHECK-NEXT:      ]
 // CHECK-NEXT:     }
 // CHECK-NEXT:    ]
 // CHECK-NEXT:   }
 // CHECK-NEXT:  ]
 // CHECK-NEXT: }
 
-
 // CHECK:  "kind": "FunctionDecl",
 // CHECK-NEXT:  "loc": {
 // CHECK-NEXT:   "offset": 157,
 // CHECK-NEXT:   "line": 7,
 // CHECK-NEXT:   "col": 6,
 // CHECK-NEXT:   "tokLen": 10
 // CHECK-NEXT:  },
 // CHECK-NEXT:  "range": {

 // CHECK-NEXT:        },
 // CHECK-NEXT:        "valueCategory": "rvalue",
 // CHECK-NEXT:        "value": "12"
 // CHECK-NEXT:       }
 // CHECK-NEXT:      ]
 // CHECK-NEXT:     },
 // CHECK-NEXT:     {
 // CHECK-NEXT:      "id": "0x{{.*}}",
-// CHECK-NEXT:      "kind": "CompoundAssignOperator",
+// CHECK-NEXT:      "kind": "BinaryOperator",
 // CHECK-NEXT:      "range": {
 // CHECK-NEXT:       "begin": {
 // CHECK-NEXT:        "offset": 191,
 // CHECK-NEXT:        "line": 9,
 // CHECK-NEXT:        "col": 3,
 // CHECK-NEXT:        "tokLen": 1
 // CHECK-NEXT:       },
 // CHECK-NEXT:       "end": {

 // CHECK-NEXT:       }
 // CHECK-NEXT:      ]
 // CHECK-NEXT:     }
 // CHECK-NEXT:    ]
 // CHECK-NEXT:   }
 // CHECK-NEXT:  ]
 // CHECK-NEXT: }
 
-
 // CHECK:  "kind": "FunctionDecl",
 // CHECK-NEXT:  "loc": {
 // CHECK-NEXT:   "offset": 210,
 // CHECK-NEXT:   "line": 12,
 // CHECK-NEXT:   "col": 6,
 // CHECK-NEXT:   "tokLen": 12
 // CHECK-NEXT:  },
 // CHECK-NEXT:  "range": {

clang/test/AST/ast-dump-expr.c

 
 void Assignment(int a) {
   a = 12;
   // CHECK: BinaryOperator 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:7> 'int' '='
   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:3> 'int' lvalue ParmVar 0x{{[^ ]*}} 'a' 'int'
   // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:7> 'int' 12
 
   a += a;
-  // CHECK: CompoundAssignOperator 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:8> 'int' '+=' ComputeLHSTy='int' ComputeResultTy='int'
+  // CHECK: BinaryOperator 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:8> 'int' '+=' ComputeLHSTy='int' ComputeResultTy='int'
   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:3> 'int' lvalue ParmVar 0x{{[^ ]*}} 'a' 'int'
   // CHECK-NEXT: ImplicitCastExpr
   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:8> 'int' lvalue ParmVar 0x{{[^ ]*}} 'a' 'int'
 }
 
 void Conditionals(int a) {
   a ? 0 : 1;
   // CHECK: ConditionalOperator 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:11> 'int'

clang/test/AST/dump.cpp

 // RUN: %clang_cc1 -verify -fopenmp -ast-dump %s | FileCheck %s -implicit-check-not=openmp_structured_block
 // RUN: %clang_cc1 -verify -fopenmp-simd -ast-dump %s | FileCheck %s -implicit-check-not=openmp_structured_block
 // expected-no-diagnostics
 
 int ga, gb;
 #pragma omp threadprivate(ga, gb)
 
 // CHECK:      |-OMPThreadPrivateDecl {{.+}} <col:1> col:1
 // CHECK-NEXT: | |-DeclRefExpr {{.+}} <col:27> 'int' lvalue Var {{.+}} 'ga' 'int'
 // CHECK-NEXT: | `-DeclRefExpr {{.+}} <col:31> 'int' lvalue Var {{.+}} 'gb' 'int'
 
 #pragma omp declare reduction(+ : int, char : omp_out *= omp_in)
 
 #pragma omp declare reduction(fun : float : omp_out += omp_in) initializer(omp_priv = omp_orig + 15)
 
 // CHECK:      |-OMPDeclareReductionDecl {{.+}} <line:[[@LINE-4]]:35> col:35 operator+ 'int' combiner 0x{{.+}}
-// CHECK-NEXT: | |-CompoundAssignOperator {{.+}} <col:47, col:58> 'int' lvalue '*=' ComputeLHSTy='int' ComputeResultTy='int'
+// CHECK-NEXT: | |-BinaryOperator {{.+}} <col:47, col:58> 'int' lvalue '*=' ComputeLHSTy='int' ComputeResultTy='int'
 // CHECK-NEXT: | | |-DeclRefExpr {{.+}} <col:47> 'int' lvalue Var {{.+}} 'omp_out' 'int'
 // CHECK-NEXT: | | `-ImplicitCastExpr {{.+}} <col:58> 'int' <LValueToRValue>
 // CHECK-NEXT: | |   `-DeclRefExpr {{.+}} <col:58> 'int' lvalue Var {{.+}} 'omp_in' 'int'
 // CHECK-NEXT: | |-VarDecl {{.+}} <col:35> col:35 implicit used omp_in 'int'
 // CHECK-NEXT: | `-VarDecl {{.+}} <col:35> col:35 implicit used omp_out 'int'
 // CHECK-NEXT: |-OMPDeclareReductionDecl {{.+}} <col:40> col:40 operator+ 'char' combiner 0x{{.+}}
-// CHECK-NEXT: | |-CompoundAssignOperator {{.+}} <col:47, col:58> 'char' lvalue '*=' ComputeLHSTy='int' ComputeResultTy='int'
+// CHECK-NEXT: | |-BinaryOperator {{.+}} <col:47, col:58> 'char' lvalue '*=' ComputeLHSTy='int' ComputeResultTy='int'
 // CHECK-NEXT: | | |-DeclRefExpr {{.+}} <col:47> 'char' lvalue Var {{.+}} 'omp_out' 'char'
 // CHECK-NEXT: | | `-ImplicitCastExpr {{.+}} <col:58> 'int' <IntegralCast>
 // CHECK-NEXT: | |   `-ImplicitCastExpr {{.+}} <col:58> 'char' <LValueToRValue>
 // CHECK-NEXT: | |     `-DeclRefExpr {{.+}} <col:58> 'char' lvalue Var {{.+}} 'omp_in' 'char'
 // CHECK-NEXT: | |-VarDecl {{.+}} <col:40> col:40 implicit used omp_in 'char'
 // CHECK-NEXT: | `-VarDecl {{.+}} <col:40> col:40 implicit used omp_out 'char'
 // CHECK-NEXT: |-OMPDeclareReductionDecl {{.+}} <line:[[@LINE-17]]:37> col:37 fun 'float' combiner 0x{{.+}} initializer 0x{{.+}}
-// CHECK-NEXT: | |-CompoundAssignOperator {{.+}} <col:45, col:56> 'float' lvalue '+=' ComputeLHSTy='float' ComputeResultTy='float'
+// CHECK-NEXT: | |-BinaryOperator {{.+}} <col:45, col:56> 'float' lvalue '+=' ComputeLHSTy='float' ComputeResultTy='float'
 // CHECK-NEXT: | | |-DeclRefExpr {{.+}} <col:45> 'float' lvalue Var {{.+}} 'omp_out' 'float'
 // CHECK-NEXT: | | `-ImplicitCastExpr {{.+}} <col:56> 'float' <LValueToRValue>
 // CHECK-NEXT: | |   `-DeclRefExpr {{.+}} <col:56> 'float' lvalue Var {{.+}} 'omp_in' 'float'
 // CHECK-NEXT: | |-BinaryOperator {{.+}} <col:87, col:98> 'float' '+'
 // CHECK-NEXT: | | |-ImplicitCastExpr {{.+}} <col:87> 'float' <LValueToRValue>
 // CHECK-NEXT: | | | `-DeclRefExpr {{.+}} <col:87> 'float' lvalue Var {{.+}} 'omp_orig' 'float'
 // CHECK-NEXT: | | `-ImplicitCastExpr {{.+}} <col:98> 'float' <IntegralToFloating>
 // CHECK-NEXT: | |   `-IntegerLiteral {{.+}} <col:98> 'int' 15

clang/test/Import/compound-assign-op/test.cpp

 // RUN: clang-import-test -dump-ast -import %S/Inputs/F.cpp -expression %s | FileCheck %s
 
 // CHECK: VarDecl
 // CHECK-NEXT: Integer
-// CHECK-NEXT: CompoundAssignOperator
+// CHECK-NEXT: BinaryOperator
 // CHECK-SAME: '+='
 
 // CHECK: VarDecl
 // CHECK-NEXT: Integer
-// CHECK-NEXT: CompoundAssignOperator
+// CHECK-NEXT: BinaryOperator
 // CHECK-SAME: '-='
 
 // CHECK: VarDecl
 // CHECK-NEXT: Integer
-// CHECK-NEXT: CompoundAssignOperator
+// CHECK-NEXT: BinaryOperator
 // CHECK-SAME: '*='
 
 // CHECK: VarDecl
 // CHECK-NEXT: Integer
-// CHECK-NEXT: CompoundAssignOperator
+// CHECK-NEXT: BinaryOperator
 // CHECK-SAME: '/='
 
 // CHECK: VarDecl
 // CHECK-NEXT: Integer
-// CHECK-NEXT: CompoundAssignOperator
+// CHECK-NEXT: BinaryOperator
 // CHECK-SAME: '&='
 
 // CHECK: VarDecl
 // CHECK-NEXT: Integer
-// CHECK-NEXT: CompoundAssignOperator
+// CHECK-NEXT: BinaryOperator
 // CHECK-SAME: '^='
 
 // CHECK: VarDecl
 // CHECK-NEXT: Integer
-// CHECK-NEXT: CompoundAssignOperator
+// CHECK-NEXT: BinaryOperator
 // CHECK-SAME: '<<='
 
 // CHECK: VarDecl
 // CHECK-NEXT: Integer
-// CHECK-NEXT: CompoundAssignOperator
+// CHECK-NEXT: BinaryOperator
 // CHECK-SAME: '>>='
 
 void expr() {
   f();
 }

clang/tools/libclang/CXCursor.cpp

CXCursor cxcursor::MakeCXCursor(const Stmt *S, const Decl *Parent,
   case Stmt::OMPArraySectionExprClass:
     K = CXCursor_OMPArraySectionExpr;
     break;
 
   case Stmt::BinaryOperatorClass:
     K = CXCursor_BinaryOperator;
     break;
 
-  case Stmt::CompoundAssignOperatorClass:
-    K = CXCursor_CompoundAssignOperator;
-    break;
-
   case Stmt::ConditionalOperatorClass:
     K = CXCursor_ConditionalOperator;
     break;
 
   case Stmt::CStyleCastExprClass:
     K = CXCursor_CStyleCastExpr;
     break;