This is an archive of the discontinued LLVM Phabricator instance.

Differential D14069

[FPEnv Core 04/14] Skip constant folding to preserve FPEnv
AcceptedPublic

Authored by sdmitrouk on Oct 26 2015, 6:55 AM.

Details

Reviewers
• tstellarAMD
mehdi_amini
hfinkel
Summary

Consider floating point environment flags when constant folding
expressions.

Diff Detail

Repository
rL LLVM

Event Timeline

sdmitrouk updated this revision to Diff 38402.Oct 26 2015, 6:55 AM
sdmitrouk retitled this revision from to [FPEnv Core 04/14] Skip constant folding to preserve FPEnv.
sdmitrouk updated this object.
sdmitrouk added reviewers: hfinkel, mehdi_amini.
sdmitrouk set the repository for this revision to rL LLVM.
sdmitrouk added subscribers: llvm-commits, resistor, scanon.
scanon added inline comments.Oct 26 2015, 8:29 AM
include/llvm/Analysis/ValueTracking.h
261

I think we should leave the one-sentence intro as-is to maximize readability; it's still correct with the new settings, AFAICT. Then let's add a paragraph to explain the floating-point-specific details:

"If KeepExceptions is true, then speculative execution of most floating-point operations will result in observably different floating-point exceptions being raised."

Worth noting: it's not obvious that KeepRounding fits the bill for isSafeToSpeculativelyExecute, but rounding-mode does change the observable exceptions by moving the overflow/underflow boundaries. However, that's just one small part of what you're trying to get at here with rounding, the larger part of which seems conceptually to be closer to "memory dependent" (except that the "memory" is floating-point control).

majnemer added a subscriber: majnemer.Oct 26 2015, 8:55 AM
majnemer added inline comments.
include/llvm/IR/Constants.h
1099–1100

Why not accept an FastMathFlags instead?

lib/Analysis/ValueTracking.cpp
3324–3325

Unless I am mistaken, could you figure out these flags from V itself?

3329

const auto *

lib/IR/Constants.cpp
347–354

Why was this changed?

sdmitrouk updated this revision to Diff 41912.Dec 4 2015, 12:02 PM

Updated text of comments, updated code to pass fast-math flags in several places, adjusted code according to review comments, updated tests which are affected by inversion of meaning of flags.

Herald added a reviewer: • tstellarAMD. · View Herald TranscriptDec 4 2015, 12:02 PM
Herald added subscribers: dsanders, qcolombet, jholewinski. · View Herald Transcript
sdmitrouk updated this revision to Diff 42097.Dec 7 2015, 1:07 PM
sdmitrouk edited edge metadata.

Revert questionable change in undef-label.ll (it shouldn't be here anyway), this also removes four tests that are now in D14067.

mehdi_amini added inline comments.Dec 7 2015, 2:28 PM
include/llvm/Analysis/ValueTracking.h
265

The KeepExceptions parameter is not clear to me, what would it be used for? (there is no use in this patch)

include/llvm/IR/Constants.h
1099

Document the new FMF parameter, especially how it differs from Flags, it is confusing right now.

Also, seeing multiple places where you need to explicitly add 0, nullptr, to be able to pass a FMF, it can be worthwhile to add an override that does not take Flags and OnlyIfReducedTy and forward to this one.

1227

Should it be allowed on non-FP operations? I could see it assert instead.

lib/Analysis/InstructionSimplify.cpp
3783

It this related to this patch or could this be committed separately?

lib/Analysis/ValueTracking.cpp
3353

You already tested for KeepExceptions at this scope.

lib/IR/ConstantFold.cpp
1183

I'd refactor the test with a named lambda defined before the switch.
That said the full switch could be refactored better already.

lib/IR/Constants.cpp
1883

You may want to assert that if FMF is supplied we have a Floating point Opcode?

lib/Transforms/InstCombine/InstCombineMulDivRem.cpp
1214

Initialize closer to its use, there are multiple path that early return and don't need this.

lib/Transforms/InstCombine/InstructionCombining.cpp
215

No braces

sdmitrouk updated this revision to Diff 42225.Dec 8 2015, 2:12 PM

Addressing review comments.

sdmitrouk marked 5 inline comments as done.Dec 8 2015, 2:23 PM

@joker.eph, thanks. Changed according to your comments, but tests on this revision don't pass... Can't reorder commits nicely due to changes of flags (now that default value FastMathFlags() is "bad" for incremental changes). Instead I'm leaving patches separated for review, but when committing will squash them to make tests pass on each revision.

include/llvm/Analysis/ValueTracking.h
265

It's left from one of previous versions, the one with function attributes. Removed.

include/llvm/IR/Constants.h
1099

Should be done, at least for this patch.

1233

Moved it to place where it's used (used to be two such places), changed type of argument and added an assert.

lib/Analysis/ValueTracking.cpp
3353

Accidentally applied stash to the next patch instead of this one.

lib/IR/ConstantFold.cpp
1185–1189

Changed it using Optional.

sdmitrouk mentioned this in D14070: [FPEnv Core 05/14] Teach IR builder and folders about new flags.Dec 8 2015, 2:26 PM
mehdi_amini accepted this revision.Dec 8 2015, 2:59 PM
mehdi_amini edited edge metadata.

LGTM with the few nitpicks below.

include/llvm/Analysis/ValueTracking.h
265

It seems you left the doxygen change in?

lib/IR/ConstantFold.cpp
1212

sweet!

lib/Transforms/InstCombine/InstructionCombining.cpp
212–216

Keep the name FMF for consistency with everywhere else.

This revision is now accepted and ready to land.Dec 8 2015, 2:59 PM
sdmitrouk updated this revision to Diff 42270.Dec 9 2015, 1:47 AM
sdmitrouk edited edge metadata.
sdmitrouk marked 5 inline comments as done.

Address the nitpicks, thanks for noticing them.

mehdi_amini added inline comments.Dec 11 2015, 3:28 PM
include/llvm/IR/FastMathFlags.h
39

Shouldn't the default be NoExceptions | NoRounding ?

mehdi_amini requested changes to this revision.Dec 11 2015, 3:36 PM
mehdi_amini edited edge metadata.
This revision now requires changes to proceed.Dec 11 2015, 3:36 PM
mehdi_amini accepted this revision.Dec 11 2015, 3:56 PM
mehdi_amini edited edge metadata.

Thinking about it more we will never reach correctness without having the safe option by default.

This revision is now accepted and ready to land.Dec 11 2015, 3:56 PM
sdmitrouk added inline comments.Dec 11 2015, 4:53 PM
include/llvm/IR/FastMathFlags.h
39

Well, it was initially, and it was easier then, but meaning of flags was changed after comments in D14067 partly to make default value all zeroes.

Large Diff

This large diff affects 238 files. Files without inline comments have been collapsed. Expand All Files

Revision Contents

PathSize
include/
llvm/
Analysis/
12 lines
IR/
10 lines
80 lines
60 lines
lib/
Analysis/
4 lines
23 lines
IR/
3 lines
47 lines
59 lines
Transforms/
InstCombine/
11 lines
15 lines
Scalar/
5 lines
test/
Bitcode/
100 lines
8 lines
8 lines
4 lines
CodeGen/
AArch64/
2 lines
4 lines
16 lines
76 lines
10 lines
66 lines
14 lines
54 lines
64 lines
28 lines
32 lines
20 lines
24 lines
48 lines
4 lines
42 lines
2 lines
AMDGPU/
580 lines
2 lines
28 lines
6 lines
16 lines
10 lines
64 lines
12 lines
10 lines
26 lines
4 lines
4 lines
8 lines
8 lines
2 lines
16 lines
8 lines
16 lines
32 lines
4 lines
128 lines
4 lines
22 lines
6 lines
14 lines
22 lines
20 lines
12 lines
12 lines
14 lines
10 lines
20 lines
10 lines
72 lines
4 lines
2 lines
16 lines
4 lines
4 lines
2 lines
2 lines
64 lines
64 lines
6 lines
56 lines
72 lines
40 lines
40 lines
48 lines
16 lines
4 lines
2 lines
16 lines
122 lines
2 lines
56 lines
10 lines
2 lines
10 lines
18 lines
36 lines
16 lines
4 lines
72 lines
94 lines
12 lines
2 lines
1188 lines
274 lines
6 lines
36 lines
2 lines
12 lines
2 lines
42 lines
2 lines
ARM/
82 lines
12 lines
52 lines
4 lines
4 lines
2 lines
2 lines
28 lines
8 lines
6 lines
8 lines
24 lines
4 lines
8 lines
6 lines
72 lines
12 lines
2 lines
18 lines
60 lines
4 lines
8 lines
12 lines
24 lines
8 lines
8 lines
8 lines
10 lines
Hexagon/
6 lines
Mips/
48 lines
msa/
16 lines
28 lines
14 lines
NVPTX/
2 lines
8 lines
22 lines
8 lines
20 lines
6 lines
2 lines
2 lines
PowerPC/
16 lines
10 lines
96 lines
28 lines
90 lines
8 lines
2 lines
86 lines
2 lines
16 lines
2 lines
4 lines
6 lines
60 lines
10 lines
4 lines
SystemZ/
34 lines
34 lines
2 lines
34 lines
34 lines
34 lines
2 lines
34 lines
74 lines
34 lines
74 lines
2 lines
6 lines
34 lines
34 lines
2 lines
Thumb2/
4 lines
8 lines
20 lines
4 lines
X86/
6 lines
14 lines
16 lines
58 lines
68 lines
4 lines
4 lines
76 lines
34 lines
16 lines
4 lines
252 lines
148 lines
64 lines
2 lines
16 lines
4 lines
56 lines
12 lines
124 lines
58 lines
50 lines
4 lines
2 lines
146 lines
12 lines
10 lines
224 lines
4 lines
2 lines
124 lines
6 lines
6 lines
14 lines
6 lines
4 lines
88 lines
48 lines
12 lines
96 lines
56 lines
3 lines
4 lines
4 lines
Transforms/
CodeGenPrepare/
X86/
24 lines
InstCombine/
32 lines
26 lines
LoopReroll/
48 lines
20 lines
Reassociate/
6 lines
SCCP/
2 lines
SLPVectorizer/
X86/
50 lines

Diff 41912

include/llvm/Analysis/ValueTracking.h

Show First 20 Lines • Show All 250 Lines • ▼ Show 20 Linesnamespace llvm {
/// dereferenceable at the specified instruction. /// dereferenceable at the specified instruction.
bool isDereferenceableAndAlignedPointer(const Value *V, unsigned Align, bool isDereferenceableAndAlignedPointer(const Value *V, unsigned Align,
const DataLayout &DL, const DataLayout &DL,
const Instruction *CtxI = nullptr, const Instruction *CtxI = nullptr,
const DominatorTree *DT = nullptr, const DominatorTree *DT = nullptr,
const TargetLibraryInfo *TLI = nullptr); const TargetLibraryInfo *TLI = nullptr);
/// isSafeToSpeculativelyExecute - Return true if the instruction does not /// isSafeToSpeculativelyExecute - Return true if the instruction does not
/// have any effects besides calculating the result and does not have /// have any effects besides calculating the result (in a way that doesn't
/// undefined behavior. /// lose floating-point exceptions or precision when requested via
/// corresponding flags) and does not have undefined behavior.
scanonUnsubmitted
Not Done
ReplyInline Actions

I think we should leave the one-sentence intro as-is to maximize readability; it's still correct with the new settings, AFAICT. Then let's add a paragraph to explain the floating-point-specific details:

"If KeepExceptions is true, then speculative execution of most floating-point operations will result in observably different floating-point exceptions being raised."

Worth noting: it's not obvious that KeepRounding fits the bill for isSafeToSpeculativelyExecute, but rounding-mode does change the observable exceptions by moving the overflow/underflow boundaries. However, that's just one small part of what you're trying to get at here with rounding, the larger part of which seems conceptually to be closer to "memory dependent" (except that the "memory" is floating-point control).

scanon: I think we should leave the one-sentence intro as-is to maximize readability; it's still…
///
/// If KeepExceptions is true, then speculative execution of most
/// floating-point operations will result in observably different
/// floating-point exceptions being raised.
mehdi_aminiUnsubmitted
Done
ReplyInline Actions

The KeepExceptions parameter is not clear to me, what would it be used for? (there is no use in this patch)

mehdi_amini: The `KeepExceptions` parameter is not clear to me, what would it be used for? (there is no use…
sdmitroukAuthorUnsubmitted
Not Done
ReplyInline Actions

It's left from one of previous versions, the one with function attributes. Removed.

sdmitrouk: It's left from one of previous versions, the one with function attributes. Removed.
mehdi_aminiUnsubmitted
Not Done
ReplyInline Actions

It seems you left the doxygen change in?

mehdi_amini: It seems you left the doxygen change in?
/// ///
/// This method never returns true for an instruction that returns true for /// This method never returns true for an instruction that returns true for
/// mayHaveSideEffects; however, this method also does some other checks in /// mayHaveSideEffects; however, this method also does some other checks in
/// addition. It checks for undefined behavior, like dividing by zero or /// addition. It checks for undefined behavior, like dividing by zero or
/// loading from an invalid pointer (but not for undefined results, like a /// loading from an invalid pointer (but not for undefined results, like a
/// shift with a shift amount larger than the width of the result). It checks /// shift with a shift amount larger than the width of the result). It checks
/// for malloc and alloca because speculatively executing them might cause a /// for malloc and alloca because speculatively executing them might cause a
/// memory leak. It also returns false for instructions related to control /// memory leak. It also returns false for instructions related to control
/// flow, specifically terminators and PHI nodes. /// flow, specifically terminators and PHI nodes.
/// ///
/// If the CtxI is specified this method performs context-sensitive analysis /// If the CtxI is specified this method performs context-sensitive analysis
/// and returns true if it is safe to execute the instruction immediately /// and returns true if it is safe to execute the instruction immediately
/// before the CtxI. /// before the CtxI.
/// ///
/// If the CtxI is NOT specified this method only looks at the instruction /// If the CtxI is NOT specified this method only looks at the instruction
/// itself and its operands, so if this method returns true, it is safe to /// itself and its operands, so if this method returns true, it is safe to
/// move the instruction as long as the correct dominance relationships for /// move the instruction as long as the correct dominance relationships for
/// the operands and users hold. /// the operands and users hold.
/// ///
/// This method can return true for instructions that read memory; /// This method can return true for instructions that read memory;
/// for such instructions, moving them may change the resulting value. /// for such instructions, moving them may change the resulting value.
bool isSafeToSpeculativelyExecute(const Value *V, bool isSafeToSpeculativelyExecute(const Value *V,
const Instruction *CtxI = nullptr, const Instruction *CtxI = nullptr,
const DominatorTree *DT = nullptr, const DominatorTree *DT = nullptr,
const TargetLibraryInfo *TLI = nullptr); const TargetLibraryInfo *TLI = nullptr,
bool KeepExceptions = false);
/// Returns true if the result or effects of the given instructions \p I /// Returns true if the result or effects of the given instructions \p I
/// depend on or influence global memory. /// depend on or influence global memory.
/// Memory dependence arises for example if the the instruction reads from /// Memory dependence arises for example if the the instruction reads from
/// memory or may produce effects or undefined behaviour. Memory dependent /// memory or may produce effects or undefined behaviour. Memory dependent
/// instructions generally cannot be reorderd with respect to other memory /// instructions generally cannot be reorderd with respect to other memory
/// dependent instructions or moved into non-dominated basic blocks. /// dependent instructions or moved into non-dominated basic blocks.
/// Instructions which just compute a value based on the values of their /// Instructions which just compute a value based on the values of their
▲ Show 20 Lines • Show All 160 Lines • Show Last 20 Lines

include/llvm/IR/Constants.h

Show All 20 Lines
#ifndef LLVM_IR_CONSTANTS_H #ifndef LLVM_IR_CONSTANTS_H
#define LLVM_IR_CONSTANTS_H #define LLVM_IR_CONSTANTS_H
#include "llvm/ADT/APFloat.h" #include "llvm/ADT/APFloat.h"
#include "llvm/ADT/APInt.h" #include "llvm/ADT/APInt.h"
#include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/ArrayRef.h"
#include "llvm/IR/Constant.h" #include "llvm/IR/Constant.h"
#include "llvm/IR/DerivedTypes.h" #include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/FastMathFlags.h"
#include "llvm/IR/OperandTraits.h" #include "llvm/IR/OperandTraits.h"
namespace llvm { namespace llvm {
class ArrayType; class ArrayType;
class IntegerType; class IntegerType;
class StructType; class StructType;
class PointerType; class PointerType;
▲ Show 20 Lines • Show All 1,052 Lines • ▼ Show 20 Linespublic:
static Constant *getSelect(Constant *C, Constant *V1, Constant *V2, static Constant *getSelect(Constant *C, Constant *V1, Constant *V2,
Type *OnlyIfReducedTy = nullptr); Type *OnlyIfReducedTy = nullptr);
/// get - Return a binary or shift operator constant expression, /// get - Return a binary or shift operator constant expression,
/// folding if possible. /// folding if possible.
/// ///
/// \param OnlyIfReducedTy see \a getWithOperands() docs. /// \param OnlyIfReducedTy see \a getWithOperands() docs.
static Constant *get(unsigned Opcode, Constant *C1, Constant *C2, static Constant *get(unsigned Opcode, Constant *C1, Constant *C2,
unsigned Flags = 0, Type *OnlyIfReducedTy = nullptr); unsigned Flags = 0, Type *OnlyIfReducedTy = nullptr,
FastMathFlags FMF = FastMathFlags());
mehdi_aminiUnsubmitted
Done
ReplyInline Actions

Document the new FMF parameter, especially how it differs from Flags, it is confusing right now.

Also, seeing multiple places where you need to explicitly add 0, nullptr, to be able to pass a FMF, it can be worthwhile to add an override that does not take Flags and OnlyIfReducedTy and forward to this one.

mehdi_amini: Document the new `FMF` parameter, especially how it differs from Flags, it is confusing right…
sdmitroukAuthorUnsubmitted
Not Done
ReplyInline Actions

Should be done, at least for this patch.

sdmitrouk: Should be done, at least for this patch.
majnemerUnsubmitted
Not Done
ReplyInline Actions

Why not accept an FastMathFlags instead?

majnemer: Why not accept an `FastMathFlags` instead?
/// \brief Return an ICmp or FCmp comparison operator constant expression. /// \brief Return an ICmp or FCmp comparison operator constant expression.
/// ///
/// \param OnlyIfReduced see \a getWithOperands() docs. /// \param OnlyIfReduced see \a getWithOperands() docs.
static Constant *getCompare(unsigned short pred, Constant *C1, Constant *C2, static Constant *getCompare(unsigned short pred, Constant *C1, Constant *C2,
bool OnlyIfReduced = false); bool OnlyIfReduced = false);
/// get* - Return some common constants without having to /// get* - Return some common constants without having to
/// specify the full Instruction::OPCODE identifier. /// specify the full Instruction::OPCODE identifier.
▲ Show 20 Lines • Show All 106 Lines • ▼ Show 20 Linespublic:
/// would make it harder to remove ConstantExprs altogether. /// would make it harder to remove ConstantExprs altogether.
Instruction *getAsInstruction(); Instruction *getAsInstruction();
/// Methods for support type inquiry through isa, cast, and dyn_cast: /// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const Value *V) { static inline bool classof(const Value *V) {
return V->getValueID() == ConstantExprVal; return V->getValueID() == ConstantExprVal;
} }
/// Evaluates floating point operation to examine how it could affect
/// floating-environment at run-time if it's not folded, does nothing for
/// non-FP operations. Returns false for unsupported values, otherwise true
/// is returned and S is assigned status of the operation.
static bool getFPOpExceptions(const Value *V, APFloat::opStatus &S);
mehdi_aminiUnsubmitted
Done
ReplyInline Actions

Should it be allowed on non-FP operations? I could see it assert instead.

mehdi_amini: Should it be allowed on non-FP operations? I could see it assert instead.
private: private:
// Shadow Value::setValueSubclassData with a private forwarding method so that // Shadow Value::setValueSubclassData with a private forwarding method so that
// subclasses cannot accidentally use it. // subclasses cannot accidentally use it.
void setValueSubclassData(unsigned short D) { void setValueSubclassData(unsigned short D) {
Value::setValueSubclassData(D); Value::setValueSubclassData(D);
sdmitroukAuthorUnsubmitted
Not Done
ReplyInline Actions

Moved it to place where it's used (used to be two such places), changed type of argument and added an assert.

sdmitrouk: Moved it to place where it's used (used to be two such places), changed type of argument and…
} }
}; };
template <> template <>
struct OperandTraits<ConstantExpr> : struct OperandTraits<ConstantExpr> :
public VariadicOperandTraits<ConstantExpr, 1> { public VariadicOperandTraits<ConstantExpr, 1> {
}; };
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

include/llvm/IR/FastMathFlags.h

  • This file was added.
//===- FastMathFlags.h - Fast math flags structure definition ---*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file provides convenience struct for specifying and reasoning about
// fast-math flags.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_IR_FASTMATHFLAGS_H
#define LLVM_IR_FASTMATHFLAGS_H
namespace llvm {
/// Convenience struct for specifying and reasoning about fast-math flags.
class FastMathFlags {
private:
friend class FPMathOperator;
unsigned Flags;
FastMathFlags(unsigned F) : Flags(F) { }
public:
enum {
UnsafeAlgebra = (1 << 0),
NoNaNs = (1 << 1),
NoInfs = (1 << 2),
NoSignedZeros = (1 << 3),
AllowReciprocal = (1 << 4),
NoExceptions = (1 << 5),
NoRounding = (1 << 6)
};
FastMathFlags() : Flags(0)
{ }
mehdi_aminiUnsubmitted
Not Done
ReplyInline Actions

Shouldn't the default be NoExceptions | NoRounding ?

mehdi_amini: Shouldn't the default be `NoExceptions | NoRounding` ?
sdmitroukAuthorUnsubmitted
Not Done
ReplyInline Actions

Well, it was initially, and it was easier then, but meaning of flags was changed after comments in D14067 partly to make default value all zeroes.

sdmitrouk: Well, it was initially, and it was easier then, but meaning of flags was changed after comments…
/// Whether any flag is set
bool any() const { return Flags != 0; }
/// Set all the flags to false
void clear() { Flags = 0; }
/// Flag queries
bool noNaNs() const { return 0 != (Flags & NoNaNs); }
bool noInfs() const { return 0 != (Flags & NoInfs); }
bool noSignedZeros() const { return 0 != (Flags & NoSignedZeros); }
bool allowReciprocal() const { return 0 != (Flags & AllowReciprocal); }
bool unsafeAlgebra() const { return 0 != (Flags & UnsafeAlgebra); }
bool noExceptions() const { return 0 != (Flags & NoExceptions); }
bool noRounding() const { return 0 != (Flags & NoRounding); }
/// Flag setters
void setNoNaNs() { Flags |= NoNaNs; }
void setNoInfs() { Flags |= NoInfs; }
void setNoSignedZeros() { Flags |= NoSignedZeros; }
void setAllowReciprocal() { Flags |= AllowReciprocal; }
void setNoExceptions() { Flags |= NoExceptions; }
void setNoRounding() { Flags |= NoRounding; }
void setUnsafeAlgebra() {
Flags |= UnsafeAlgebra;
setNoNaNs();
setNoInfs();
setNoSignedZeros();
setAllowReciprocal();
setNoExceptions();
setNoRounding();
}
void operator&=(const FastMathFlags &OtherFlags) {
Flags &= OtherFlags.Flags;
}
};
} // End llvm namespace
#endif

include/llvm/IR/Operator.h

lib/Analysis/InstructionSimplify.cpp

Show First 20 Lines • Show All 3,769 Lines • ▼ Show 20 Lines
static Value *SimplifyFPBinOp(unsigned Opcode, Value *LHS, Value *RHS, static Value *SimplifyFPBinOp(unsigned Opcode, Value *LHS, Value *RHS,
const FastMathFlags &FMF, const Query &Q, const FastMathFlags &FMF, const Query &Q,
unsigned MaxRecurse) { unsigned MaxRecurse) {
switch (Opcode) { switch (Opcode) {
case Instruction::FAdd: case Instruction::FAdd:
return SimplifyFAddInst(LHS, RHS, FMF, Q, MaxRecurse); return SimplifyFAddInst(LHS, RHS, FMF, Q, MaxRecurse);
case Instruction::FSub: case Instruction::FSub:
return SimplifyFSubInst(LHS, RHS, FMF, Q, MaxRecurse); return SimplifyFSubInst(LHS, RHS, FMF, Q, MaxRecurse);
case Instruction::FRem:
return SimplifyFRemInst(LHS, RHS, FMF, Q, MaxRecurse);
case Instruction::FMul: case Instruction::FMul:
return SimplifyFMulInst(LHS, RHS, FMF, Q, MaxRecurse); return SimplifyFMulInst(LHS, RHS, FMF, Q, MaxRecurse);
case Instruction::FDiv:
return SimplifyFDivInst(LHS, RHS, FMF, Q, MaxRecurse);
mehdi_aminiUnsubmitted
Not Done
ReplyInline Actions

It this related to this patch or could this be committed separately?

mehdi_amini: It this related to this patch or could this be committed separately?
default: default:
return SimplifyBinOp(Opcode, LHS, RHS, Q, MaxRecurse); return SimplifyBinOp(Opcode, LHS, RHS, Q, MaxRecurse);
} }
} }
Value *llvm::SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS, Value *llvm::SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS,
const DataLayout &DL, const TargetLibraryInfo *TLI, const DataLayout &DL, const TargetLibraryInfo *TLI,
const DominatorTree *DT, AssumptionCache *AC, const DominatorTree *DT, AssumptionCache *AC,
▲ Show 20 Lines • Show All 394 Lines • Show Last 20 Lines

lib/Analysis/ValueTracking.cpp

Show First 20 Lines • Show All 3,314 Lines • ▼ Show 20 Linesbool llvm::isDereferenceablePointer(const Value *V, const DataLayout &DL,
const DominatorTree *DT, const DominatorTree *DT,
const TargetLibraryInfo *TLI) { const TargetLibraryInfo *TLI) {
return isDereferenceableAndAlignedPointer(V, 1, DL, CtxI, DT, TLI); return isDereferenceableAndAlignedPointer(V, 1, DL, CtxI, DT, TLI);
} }
bool llvm::isSafeToSpeculativelyExecute(const Value *V, bool llvm::isSafeToSpeculativelyExecute(const Value *V,
const Instruction *CtxI, const Instruction *CtxI,
const DominatorTree *DT, const DominatorTree *DT,
const TargetLibraryInfo *TLI) { const TargetLibraryInfo *TLI,
bool KeepExceptions) {
const Operator *Inst = dyn_cast<Operator>(V); const Operator *Inst = dyn_cast<Operator>(V);
majnemerUnsubmitted
Not Done
ReplyInline Actions

Unless I am mistaken, could you figure out these flags from V itself?

majnemer: Unless I am mistaken, could you figure out these flags from `V` itself?
if (!Inst) if (!Inst)
return false; return false;
if (const auto *MathOp = dyn_cast<FPMathOperator>(Inst)) {
majnemerUnsubmitted
Not Done
ReplyInline Actions

const auto *

majnemer: `const auto *`
// Rounding-mode changes the observable exceptions by moving the
// overflow/underflow boundaries.
KeepExceptions |= !MathOp->hasNoExceptions() || !MathOp->hasNoRounding();
}
for (unsigned i = 0, e = Inst->getNumOperands(); i != e; ++i) for (unsigned i = 0, e = Inst->getNumOperands(); i != e; ++i)
if (Constant *C = dyn_cast<Constant>(Inst->getOperand(i))) if (Constant *C = dyn_cast<Constant>(Inst->getOperand(i)))
if (C->canTrap()) if (C->canTrap())
return false; return false;
switch (Inst->getOpcode()) { switch (Inst->getOpcode()) {
default: default:
return true; return true;
case Instruction::FMul:
case Instruction::FAdd:
case Instruction::FSub:
case Instruction::FDiv:
case Instruction::FRem:
if (KeepExceptions) {
APFloat::opStatus S;
if (!ConstantExpr::getFPOpExceptions(Inst, S))
return false;
if (KeepExceptions && (S != APFloat::opOK || (S & APFloat::opInexact)))
mehdi_aminiUnsubmitted
Done
ReplyInline Actions

You already tested for KeepExceptions at this scope.

mehdi_amini: You already tested for `KeepExceptions` at this scope.
sdmitroukAuthorUnsubmitted
Not Done
ReplyInline Actions

Accidentally applied stash to the next patch instead of this one.

sdmitrouk: Accidentally applied stash to the next patch instead of this one.
return false;
}
return true;
case Instruction::UDiv: case Instruction::UDiv:
case Instruction::URem: { case Instruction::URem: {
// x / y is undefined if y == 0. // x / y is undefined if y == 0.
const APInt *V; const APInt *V;
if (match(Inst->getOperand(1), m_APInt(V))) if (match(Inst->getOperand(1), m_APInt(V)))
return *V != 0; return *V != 0;
return false; return false;
} }
▲ Show 20 Lines • Show All 874 Lines • Show Last 20 Lines

lib/IR/ConstantFold.h

lib/IR/ConstantFold.cpp

Show First 20 Lines • Show All 909 Lines • ▼ Show 20 Lines if (StructType *ST = dyn_cast<StructType>(Agg->getType()))
return ConstantStruct::get(ST, Result); return ConstantStruct::get(ST, Result);
if (ArrayType *AT = dyn_cast<ArrayType>(Agg->getType())) if (ArrayType *AT = dyn_cast<ArrayType>(Agg->getType()))
return ConstantArray::get(AT, Result); return ConstantArray::get(AT, Result);
return ConstantVector::get(Result); return ConstantVector::get(Result);
} }
Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode,
Constant *C1, Constant *C2) { Constant *C1, Constant *C2,
FastMathFlags FMF) {
// Handle UndefValue up front. // Handle UndefValue up front.
if (isa<UndefValue>(C1) || isa<UndefValue>(C2)) { if (isa<UndefValue>(C1) || isa<UndefValue>(C2)) {
switch (Opcode) { switch (Opcode) {
case Instruction::Xor: case Instruction::Xor:
if (isa<UndefValue>(C1) && isa<UndefValue>(C2)) if (isa<UndefValue>(C1) && isa<UndefValue>(C2))
// Handle undef ^ undef -> 0 special case. This is a common // Handle undef ^ undef -> 0 special case. This is a common
// idiom (misuse). // idiom (misuse).
return Constant::getNullValue(C1->getType()); return Constant::getNullValue(C1->getType());
▲ Show 20 Lines • Show All 167 Lines • ▼ Show 20 Lines case Instruction::AShr:
if (ConstantExpr *CE1 = dyn_cast<ConstantExpr>(C1)) if (ConstantExpr *CE1 = dyn_cast<ConstantExpr>(C1))
if (CE1->getOpcode() == Instruction::ZExt) // Top bits known zero. if (CE1->getOpcode() == Instruction::ZExt) // Top bits known zero.
return ConstantExpr::getLShr(C1, C2); return ConstantExpr::getLShr(C1, C2);
break; break;
} }
} else if (isa<ConstantInt>(C1)) { } else if (isa<ConstantInt>(C1)) {
// If C1 is a ConstantInt and C2 is not, swap the operands. // If C1 is a ConstantInt and C2 is not, swap the operands.
if (Instruction::isCommutative(Opcode)) if (Instruction::isCommutative(Opcode))
return ConstantExpr::get(Opcode, C2, C1); return ConstantExpr::get(Opcode, C2, C1, 0, nullptr, FMF);
} }
// At this point we know neither constant is an UndefValue. // At this point we know neither constant is an UndefValue.
if (ConstantInt *CI1 = dyn_cast<ConstantInt>(C1)) { if (ConstantInt *CI1 = dyn_cast<ConstantInt>(C1)) {
if (ConstantInt *CI2 = dyn_cast<ConstantInt>(C2)) { if (ConstantInt *CI2 = dyn_cast<ConstantInt>(C2)) {
const APInt &C1V = CI1->getValue(); const APInt &C1V = CI1->getValue();
const APInt &C2V = CI2->getValue(); const APInt &C2V = CI2->getValue();
switch (Opcode) { switch (Opcode) {
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines if (ConstantInt *CI1 = dyn_cast<ConstantInt>(C1)) {
default: default:
break; break;
} }
} else if (ConstantFP *CFP1 = dyn_cast<ConstantFP>(C1)) { } else if (ConstantFP *CFP1 = dyn_cast<ConstantFP>(C1)) {
if (ConstantFP *CFP2 = dyn_cast<ConstantFP>(C2)) { if (ConstantFP *CFP2 = dyn_cast<ConstantFP>(C2)) {
APFloat C1V = CFP1->getValueAPF(); APFloat C1V = CFP1->getValueAPF();
APFloat C2V = CFP2->getValueAPF(); APFloat C2V = CFP2->getValueAPF();
APFloat C3V = C1V; // copy for modification APFloat C3V = C1V; // copy for modification
APFloat::opStatus S;
switch (Opcode) { switch (Opcode) {
default: default:
break; break;
case Instruction::FAdd: case Instruction::FAdd:
(void)C3V.add(C2V, APFloat::rmNearestTiesToEven); S = C3V.add(C2V, APFloat::rmNearestTiesToEven);
if ((!FMF.noExceptions() && S != APFloat::opOK) ||
(!FMF.noRounding() && (S & APFloat::opInexact)))
break;
mehdi_aminiUnsubmitted
Done
ReplyInline Actions

I'd refactor the test with a named lambda defined before the switch.
That said the full switch could be refactored better already.

mehdi_amini: I'd refactor the test with a named lambda defined before the switch. That said the full switch…
return ConstantFP::get(C1->getContext(), C3V); return ConstantFP::get(C1->getContext(), C3V);
case Instruction::FSub: case Instruction::FSub:
(void)C3V.subtract(C2V, APFloat::rmNearestTiesToEven); S = C3V.subtract(C2V, APFloat::rmNearestTiesToEven);
if ((!FMF.noExceptions() && S != APFloat::opOK) ||
(!FMF.noRounding() && (S & APFloat::opInexact)))
break;
sdmitroukAuthorUnsubmitted
Not Done
ReplyInline Actions

Changed it using Optional.

sdmitrouk: Changed it using `Optional`.
return ConstantFP::get(C1->getContext(), C3V); return ConstantFP::get(C1->getContext(), C3V);
case Instruction::FMul: case Instruction::FMul:
(void)C3V.multiply(C2V, APFloat::rmNearestTiesToEven); S = C3V.multiply(C2V, APFloat::rmNearestTiesToEven);
if ((!FMF.noExceptions() && S != APFloat::opOK) ||
(!FMF.noRounding() && (S & APFloat::opInexact)))
break;
return ConstantFP::get(C1->getContext(), C3V); return ConstantFP::get(C1->getContext(), C3V);
case Instruction::FDiv: case Instruction::FDiv:
(void)C3V.divide(C2V, APFloat::rmNearestTiesToEven); S = C3V.divide(C2V, APFloat::rmNearestTiesToEven);
if ((!FMF.noExceptions() && S != APFloat::opOK) ||
(!FMF.noRounding() && (S & APFloat::opInexact)))
break;
return ConstantFP::get(C1->getContext(), C3V); return ConstantFP::get(C1->getContext(), C3V);
case Instruction::FRem: case Instruction::FRem:
(void)C3V.mod(C2V); S = C3V.mod(C2V);
if ((!FMF.noExceptions() && S != APFloat::opOK) ||
(!FMF.noRounding() && (S & APFloat::opInexact)))
break;
return ConstantFP::get(C1->getContext(), C3V); return ConstantFP::get(C1->getContext(), C3V);
} }
} }
} else if (VectorType *VTy = dyn_cast<VectorType>(C1->getType())) { } else if (VectorType *VTy = dyn_cast<VectorType>(C1->getType())) {
// Perform elementwise folding. // Perform elementwise folding.
mehdi_aminiUnsubmitted
Not Done
ReplyInline Actions

sweet!

mehdi_amini: sweet!
SmallVector<Constant*, 16> Result; SmallVector<Constant*, 16> Result;
Type *Ty = IntegerType::get(VTy->getContext(), 32); Type *Ty = IntegerType::get(VTy->getContext(), 32);
for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) { for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
Constant *LHS = Constant *LHS =
ConstantExpr::getExtractElement(C1, ConstantInt::get(Ty, i)); ConstantExpr::getExtractElement(C1, ConstantInt::get(Ty, i));
Constant *RHS = Constant *RHS =
ConstantExpr::getExtractElement(C2, ConstantInt::get(Ty, i)); ConstantExpr::getExtractElement(C2, ConstantInt::get(Ty, i));
Result.push_back(ConstantExpr::get(Opcode, LHS, RHS)); Result.push_back(ConstantExpr::get(Opcode, LHS, RHS, 0, nullptr, FMF));
} }
return ConstantVector::get(Result); return ConstantVector::get(Result);
} }
if (ConstantExpr *CE1 = dyn_cast<ConstantExpr>(C1)) { if (ConstantExpr *CE1 = dyn_cast<ConstantExpr>(C1)) {
// There are many possible foldings we could do here. We should probably // There are many possible foldings we could do here. We should probably
// at least fold add of a pointer with an integer into the appropriate // at least fold add of a pointer with an integer into the appropriate
// getelementptr. This will improve alias analysis a bit. // getelementptr. This will improve alias analysis a bit.
// Given ((a + b) + c), if (b + c) folds to something interesting, return // Given ((a + b) + c), if (b + c) folds to something interesting, return
// (a + (b + c)). // (a + (b + c)).
if (Instruction::isAssociative(Opcode) && CE1->getOpcode() == Opcode) { if (Instruction::isAssociative(Opcode) && CE1->getOpcode() == Opcode) {
Constant *T = ConstantExpr::get(Opcode, CE1->getOperand(1), C2); Constant *T = ConstantExpr::get(Opcode, CE1->getOperand(1), C2, 0,
nullptr, FMF);
if (!isa<ConstantExpr>(T) || cast<ConstantExpr>(T)->getOpcode() != Opcode) if (!isa<ConstantExpr>(T) || cast<ConstantExpr>(T)->getOpcode() != Opcode)
return ConstantExpr::get(Opcode, CE1->getOperand(0), T); return ConstantExpr::get(Opcode, CE1->getOperand(0), T, 0, nullptr,
FMF);
} }
} else if (isa<ConstantExpr>(C2)) { } else if (isa<ConstantExpr>(C2)) {
// If C2 is a constant expr and C1 isn't, flop them around and fold the // If C2 is a constant expr and C1 isn't, flop them around and fold the
// other way if possible. // other way if possible.
if (Instruction::isCommutative(Opcode)) if (Instruction::isCommutative(Opcode))
return ConstantFoldBinaryInstruction(Opcode, C2, C1); return ConstantFoldBinaryInstruction(Opcode, C2, C1, FMF);
} }
// i1 can be simplified in many cases. // i1 can be simplified in many cases.
if (C1->getType()->isIntegerTy(1)) { if (C1->getType()->isIntegerTy(1)) {
switch (Opcode) { switch (Opcode) {
case Instruction::Add: case Instruction::Add:
case Instruction::Sub: case Instruction::Sub:
return ConstantExpr::getXor(C1, C2); return ConstantExpr::getXor(C1, C2);
▲ Show 20 Lines • Show All 1,029 Lines • Show Last 20 Lines

lib/IR/Constants.cpp

Show First 20 Lines • Show All 338 Lines • ▼ Show 20 Lines
static bool canTrapImpl(const Constant *C, static bool canTrapImpl(const Constant *C,
SmallPtrSetImpl<const ConstantExpr *> &NonTrappingOps) { SmallPtrSetImpl<const ConstantExpr *> &NonTrappingOps) {
assert(C->getType()->isFirstClassType() && "Cannot evaluate aggregate vals!"); assert(C->getType()->isFirstClassType() && "Cannot evaluate aggregate vals!");
// The only thing that could possibly trap are constant exprs. // The only thing that could possibly trap are constant exprs.
const ConstantExpr *CE = dyn_cast<ConstantExpr>(C); const ConstantExpr *CE = dyn_cast<ConstantExpr>(C);
if (!CE) if (!CE)
return false; return false;
// ConstantExpr traps if any operands can trap. // ConstantExpr traps if any operands can trap.
for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i) { for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i) {
if (ConstantExpr *Op = dyn_cast<ConstantExpr>(CE->getOperand(i))) { if (ConstantExpr *Op = dyn_cast<ConstantExpr>(CE->getOperand(i))) {
if (NonTrappingOps.insert(Op).second && canTrapImpl(Op, NonTrappingOps)) if (NonTrappingOps.insert(Op).second && canTrapImpl(Op, NonTrappingOps))
return true; return true;
} }
} }
majnemerUnsubmitted
Not Done
ReplyInline Actions

Why was this changed?

majnemer: Why was this changed?
// Otherwise, only specific operations can trap. // Otherwise, only specific operations can trap.
switch (CE->getOpcode()) { switch (CE->getOpcode()) {
default: default:
return false; return false;
case Instruction::UDiv: case Instruction::UDiv:
case Instruction::SDiv: case Instruction::SDiv:
case Instruction::FDiv: case Instruction::FDiv:
case Instruction::URem: case Instruction::URem:
▲ Show 20 Lines • Show All 1,511 Lines • ▼ Show 20 Lines if (VectorType *VT = dyn_cast<VectorType>(DstTy)) {
MidTy = VectorType::get(MidTy, VT->getNumElements()); MidTy = VectorType::get(MidTy, VT->getNumElements());
} }
C = getBitCast(C, MidTy); C = getBitCast(C, MidTy);
} }
return getFoldedCast(Instruction::AddrSpaceCast, C, DstTy, OnlyIfReduced); return getFoldedCast(Instruction::AddrSpaceCast, C, DstTy, OnlyIfReduced);
} }
Constant *ConstantExpr::get(unsigned Opcode, Constant *C1, Constant *C2, Constant *ConstantExpr::get(unsigned Opcode, Constant *C1, Constant *C2,
unsigned Flags, Type *OnlyIfReducedTy) { unsigned Flags, Type *OnlyIfReducedTy,
FastMathFlags FMF) {
mehdi_aminiUnsubmitted
Not Done
ReplyInline Actions

You may want to assert that if FMF is supplied we have a Floating point Opcode?

mehdi_amini: You may want to assert that if FMF is supplied we have a Floating point Opcode?
// Check the operands for consistency first. // Check the operands for consistency first.
assert(Opcode >= Instruction::BinaryOpsBegin && assert(Opcode >= Instruction::BinaryOpsBegin &&
Opcode < Instruction::BinaryOpsEnd && Opcode < Instruction::BinaryOpsEnd &&
"Invalid opcode in binary constant expression"); "Invalid opcode in binary constant expression");
assert(C1->getType() == C2->getType() && assert(C1->getType() == C2->getType() &&
"Operand types in binary constant expression should match"); "Operand types in binary constant expression should match");
#ifndef NDEBUG #ifndef NDEBUG
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines case Instruction::AShr:
assert(C1->getType()->isIntOrIntVectorTy() && assert(C1->getType()->isIntOrIntVectorTy() &&
"Tried to create a shift operation on a non-integer type!"); "Tried to create a shift operation on a non-integer type!");
break; break;
default: default:
break; break;
} }
#endif #endif
if (Constant *FC = ConstantFoldBinaryInstruction(Opcode, C1, C2)) if (Constant *FC = ConstantFoldBinaryInstruction(Opcode, C1, C2, FMF))
return FC; // Fold a few common cases. return FC; // Fold a few common cases.
if (OnlyIfReducedTy == C1->getType()) if (OnlyIfReducedTy == C1->getType())
return nullptr; return nullptr;
Constant *ArgVec[] = { C1, C2 }; Constant *ArgVec[] = { C1, C2 };
ConstantExprKeyType Key(Opcode, ArgVec, 0, Flags); ConstantExprKeyType Key(Opcode, ArgVec, 0, Flags);
▲ Show 20 Lines • Show All 1,144 Lines • ▼ Show 20 Lines if (isa<OverflowingBinaryOperator>(BO)) {
BO->setHasNoSignedWrap(SubclassOptionalData & BO->setHasNoSignedWrap(SubclassOptionalData &
OverflowingBinaryOperator::NoSignedWrap); OverflowingBinaryOperator::NoSignedWrap);
} }
if (isa<PossiblyExactOperator>(BO)) if (isa<PossiblyExactOperator>(BO))
BO->setIsExact(SubclassOptionalData & PossiblyExactOperator::IsExact); BO->setIsExact(SubclassOptionalData & PossiblyExactOperator::IsExact);
return BO; return BO;
} }
} }
bool ConstantExpr::getFPOpExceptions(const Value *V, APFloat::opStatus &S) {
unsigned Opcode;
const User *U;
if (const Operator *Op = dyn_cast<Operator>(V)) {
U = Op;
Opcode = Op->getOpcode();
} if (const ConstantExpr *C = dyn_cast<ConstantExpr>(V)) {
U = C;
Opcode = C->getOpcode();
} else {
return false;
}
switch (Opcode) {
default:
return true;
case Instruction::FMul:
case Instruction::FAdd:
case Instruction::FSub:
case Instruction::FDiv:
case Instruction::FRem: {
ConstantFP *LHSC = dyn_cast<ConstantFP>(U->getOperand(0));
ConstantFP *RHSC = dyn_cast<ConstantFP>(U->getOperand(1));
if (!LHSC || !RHSC) {
return false;
}
APFloat LHS = LHSC->getValueAPF();
APFloat RHS = LHSC->getValueAPF();
switch (Opcode) {
case Instruction::FMul:
S = LHS.multiply(RHS, APFloat::rmNearestTiesToEven);
break;
case Instruction::FAdd:
S = LHS.add(RHS, APFloat::rmNearestTiesToEven);
break;
case Instruction::FSub:
S = LHS.subtract(RHS, APFloat::rmNearestTiesToEven);
break;
case Instruction::FDiv:
S = LHS.divide(RHS, APFloat::rmNearestTiesToEven);
break;
case Instruction::FRem:
S = LHS.mod(RHS);
break;
}
return true;
}
}
}

lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

Show First 20 Lines • Show All 1,205 Lines • ▼ Show 20 Lines if (!Cvt)
return nullptr; return nullptr;
ConstantFP *R; ConstantFP *R;
R = ConstantFP::get(Dividend->getType()->getContext(), Reciprocal); R = ConstantFP::get(Dividend->getType()->getContext(), Reciprocal);
return BinaryOperator::CreateFMul(Dividend, R); return BinaryOperator::CreateFMul(Dividend, R);
} }
Instruction *InstCombiner::visitFDiv(BinaryOperator &I) { Instruction *InstCombiner::visitFDiv(BinaryOperator &I) {
FastMathFlags FMF = I.getFastMathFlags();
mehdi_aminiUnsubmitted
Not Done
ReplyInline Actions

Initialize closer to its use, there are multiple path that early return and don't need this.

mehdi_amini: Initialize closer to its use, there are multiple path that early return and don't need this.
Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
if (Value *V = SimplifyVectorOp(I)) if (Value *V = SimplifyVectorOp(I))
return ReplaceInstUsesWith(I, V); return ReplaceInstUsesWith(I, V);
if (Value *V = SimplifyFDivInst(Op0, Op1, I.getFastMathFlags(), if (Value *V = SimplifyFDivInst(Op0, Op1, I.getFastMathFlags(),
DL, TLI, DT, AC)) DL, TLI, DT, AC))
return ReplaceInstUsesWith(I, V); return ReplaceInstUsesWith(I, V);
Show All 15 Lines if (AllowReassociate) {
Constant *C1 = nullptr; Constant *C1 = nullptr;
Constant *C2 = Op1C; Constant *C2 = Op1C;
Value *X; Value *X;
Instruction *Res = nullptr; Instruction *Res = nullptr;
if (match(Op0, m_FMul(m_Value(X), m_Constant(C1)))) { if (match(Op0, m_FMul(m_Value(X), m_Constant(C1)))) {
// (X*C1)/C2 => X * (C1/C2) // (X*C1)/C2 => X * (C1/C2)
// //
Constant *C = ConstantExpr::getFDiv(C1, C2); Constant *C = ConstantExpr::getFDiv(C1, C2, FMF);
if (isNormalFp(C)) if (isNormalFp(C))
Res = BinaryOperator::CreateFMul(X, C); Res = BinaryOperator::CreateFMul(X, C);
} else if (match(Op0, m_FDiv(m_Value(X), m_Constant(C1)))) { } else if (match(Op0, m_FDiv(m_Value(X), m_Constant(C1)))) {
// (X/C1)/C2 => X /(C2*C1) [=> X * 1/(C2*C1) if reciprocal is allowed] // (X/C1)/C2 => X /(C2*C1) [=> X * 1/(C2*C1) if reciprocal is allowed]
// //
Constant *C = ConstantExpr::getFMul(C1, C2); Constant *C = ConstantExpr::getFMul(C1, C2, FMF);
if (isNormalFp(C)) { if (isNormalFp(C)) {
Res = CvtFDivConstToReciprocal(X, C, AllowReciprocal); Res = CvtFDivConstToReciprocal(X, C, AllowReciprocal);
if (!Res) if (!Res)
Res = BinaryOperator::CreateFDiv(X, C); Res = BinaryOperator::CreateFDiv(X, C);
} }
} }
if (Res) { if (Res) {
Show All 14 LinesInstruction *InstCombiner::visitFDiv(BinaryOperator &I) {
if (AllowReassociate && isa<Constant>(Op0)) { if (AllowReassociate && isa<Constant>(Op0)) {
Constant *C1 = cast<Constant>(Op0), *C2; Constant *C1 = cast<Constant>(Op0), *C2;
Constant *Fold = nullptr; Constant *Fold = nullptr;
Value *X; Value *X;
bool CreateDiv = true; bool CreateDiv = true;
// C1 / (X*C2) => (C1/C2) / X // C1 / (X*C2) => (C1/C2) / X
if (match(Op1, m_FMul(m_Value(X), m_Constant(C2)))) if (match(Op1, m_FMul(m_Value(X), m_Constant(C2))))
Fold = ConstantExpr::getFDiv(C1, C2); Fold = ConstantExpr::getFDiv(C1, C2, FMF);
else if (match(Op1, m_FDiv(m_Value(X), m_Constant(C2)))) { else if (match(Op1, m_FDiv(m_Value(X), m_Constant(C2)))) {
// C1 / (X/C2) => (C1*C2) / X // C1 / (X/C2) => (C1*C2) / X
Fold = ConstantExpr::getFMul(C1, C2); Fold = ConstantExpr::getFMul(C1, C2, FMF);
} else if (match(Op1, m_FDiv(m_Constant(C2), m_Value(X)))) { } else if (match(Op1, m_FDiv(m_Constant(C2), m_Value(X)))) {
// C1 / (C2/X) => (C1/C2) * X // C1 / (C2/X) => (C1/C2) * X
Fold = ConstantExpr::getFDiv(C1, C2); Fold = ConstantExpr::getFDiv(C1, C2, FMF);
CreateDiv = false; CreateDiv = false;
} }
if (Fold && isNormalFp(Fold)) { if (Fold && isNormalFp(Fold)) {
Instruction *R = CreateDiv ? BinaryOperator::CreateFDiv(Fold, X) Instruction *R = CreateDiv ? BinaryOperator::CreateFDiv(Fold, X)
: BinaryOperator::CreateFMul(X, Fold); : BinaryOperator::CreateFMul(X, Fold);
R->setFastMathFlags(I.getFastMathFlags()); R->setFastMathFlags(I.getFastMathFlags());
return R; return R;
▲ Show 20 Lines • Show All 208 Lines • Show Last 20 Lines

lib/Transforms/InstCombine/InstructionCombining.cpp

Show First 20 Lines • Show All 203 Lines • ▼ Show 20 Lines do {
if (I.isAssociative()) { if (I.isAssociative()) {
// Transform: "(A op B) op C" ==> "A op (B op C)" if "B op C" simplifies. // Transform: "(A op B) op C" ==> "A op (B op C)" if "B op C" simplifies.
if (Op0 && Op0->getOpcode() == Opcode) { if (Op0 && Op0->getOpcode() == Opcode) {
Value *A = Op0->getOperand(0); Value *A = Op0->getOperand(0);
Value *B = Op0->getOperand(1); Value *B = Op0->getOperand(1);
Value *C = I.getOperand(1); Value *C = I.getOperand(1);
// Does "B op C" simplify? // Does "B op C" simplify?
if (Value *V = SimplifyBinOp(Opcode, B, C, DL)) { FastMathFlags Flags;
if (isa<FPMathOperator>(I)) {
Flags = I.getFastMathFlags();
}
mehdi_aminiUnsubmitted
Not Done
ReplyInline Actions

No braces

mehdi_amini: No braces
if (Value *V = SimplifyFPBinOp(Opcode, B, C, Flags, DL)) {
mehdi_aminiUnsubmitted
Not Done
ReplyInline Actions

Keep the name FMF for consistency with everywhere else.

mehdi_amini: Keep the name FMF for consistency with everywhere else.
// It simplifies to V. Form "A op V". // It simplifies to V. Form "A op V".
I.setOperand(0, A); I.setOperand(0, A);
I.setOperand(1, V); I.setOperand(1, V);
// Conservatively clear the optional flags, since they may not be // Conservatively clear the optional flags, since they may not be
// preserved by the reassociation. // preserved by the reassociation.
if (MaintainNoSignedWrap(I, B, C) && if (MaintainNoSignedWrap(I, B, C) &&
(!Op0 || (isa<BinaryOperator>(Op0) && Op0->hasNoSignedWrap()))) { (!Op0 || (isa<BinaryOperator>(Op0) && Op0->hasNoSignedWrap()))) {
// Note: this is only valid because SimplifyBinOp doesn't look at // Note: this is only valid because SimplifyBinOp doesn't look at
▲ Show 20 Lines • Show All 481 Lines • ▼ Show 20 Lines if (CastInst *CI = dyn_cast<CastInst>(&I)) {
return IC->Builder->CreateCast(CI->getOpcode(), SO, I.getType()); return IC->Builder->CreateCast(CI->getOpcode(), SO, I.getType());
} }
// Figure out if the constant is the left or the right argument. // Figure out if the constant is the left or the right argument.
bool ConstIsRHS = isa<Constant>(I.getOperand(1)); bool ConstIsRHS = isa<Constant>(I.getOperand(1));
Constant *ConstOperand = cast<Constant>(I.getOperand(ConstIsRHS)); Constant *ConstOperand = cast<Constant>(I.getOperand(ConstIsRHS));
if (Constant *SOC = dyn_cast<Constant>(SO)) { if (Constant *SOC = dyn_cast<Constant>(SO)) {
if (ConstIsRHS) if (ConstIsRHS) {
return ConstantExpr::get(I.getOpcode(), SOC, ConstOperand); FastMathFlags FMF;
if (isa<FPMathOperator>(I))
FMF = I.getFastMathFlags();
return ConstantExpr::get(I.getOpcode(), SOC, ConstOperand, 0, nullptr,
FMF);
}
return ConstantExpr::get(I.getOpcode(), ConstOperand, SOC); return ConstantExpr::get(I.getOpcode(), ConstOperand, SOC);
} }
Value *Op0 = SO, *Op1 = ConstOperand; Value *Op0 = SO, *Op1 = ConstOperand;
if (!ConstIsRHS) if (!ConstIsRHS)
std::swap(Op0, Op1); std::swap(Op0, Op1);
if (BinaryOperator *BO = dyn_cast<BinaryOperator>(&I)) { if (BinaryOperator *BO = dyn_cast<BinaryOperator>(&I)) {
▲ Show 20 Lines • Show All 2,448 Lines • Show Last 20 Lines

lib/Transforms/Scalar/Scalarizer.cpp

test/Bitcode/binaryFloatInstructions.3.2.ll

test/Bitcode/compatibility-3.6.ll

test/Bitcode/compatibility-3.7.ll

test/Bitcode/constantsTest.3.2.ll

test/CodeGen/AArch64/arm64-ccmp.ll

test/CodeGen/AArch64/arm64-dagcombiner-load-slicing.ll

test/CodeGen/AArch64/arm64-fmadd.ll

test/CodeGen/AArch64/arm64-misched-basic-A53.ll

test/CodeGen/AArch64/arm64-neon-2velem-high.ll

test/CodeGen/AArch64/arm64-neon-2velem.ll

test/CodeGen/AArch64/arm64-neon-scalar-by-elem-mul.ll

test/CodeGen/AArch64/arm64-vmul.ll

test/CodeGen/AArch64/fcvt-fixed.ll

test/CodeGen/AArch64/fcvt_combine.ll

test/CodeGen/AArch64/fdiv-combine.ll

test/CodeGen/AArch64/fdiv_combine.ll

test/CodeGen/AArch64/floatdp_2source.ll

test/CodeGen/AArch64/fp-dp3.ll

test/CodeGen/AArch64/neon-diagnostics.ll

test/CodeGen/AArch64/neon-fma.ll

test/CodeGen/AArch64/vcvt-oversize.ll

test/CodeGen/AMDGPU/big_alu.ll

test/CodeGen/AMDGPU/bitcast.ll

test/CodeGen/AMDGPU/commute_modifiers.ll

test/CodeGen/AMDGPU/cvt_flr_i32_f32.ll

test/CodeGen/AMDGPU/cvt_rpi_i32_f32.ll

test/CodeGen/AMDGPU/ds-negative-offset-addressing-mode-loop.ll

test/CodeGen/AMDGPU/ds_read2.ll

test/CodeGen/AMDGPU/ds_read2_offset_order.ll

test/CodeGen/AMDGPU/ds_read2_superreg.ll

test/CodeGen/AMDGPU/ds_read2st64.ll

test/CodeGen/AMDGPU/fabs.f64.ll

test/CodeGen/AMDGPU/fabs.ll

test/CodeGen/AMDGPU/fadd.ll

test/CodeGen/AMDGPU/fadd64.ll

test/CodeGen/AMDGPU/fconst64.ll

test/CodeGen/AMDGPU/fdiv.f64.ll

test/CodeGen/AMDGPU/fdiv.ll

test/CodeGen/AMDGPU/fetch-limits.r600.ll

test/CodeGen/AMDGPU/fetch-limits.r700+.ll

test/CodeGen/AMDGPU/ffloor.f64.ll

test/CodeGen/AMDGPU/fma-combine.ll

test/CodeGen/AMDGPU/fmad.ll

test/CodeGen/AMDGPU/fmul.ll

test/CodeGen/AMDGPU/fmul64.ll

test/CodeGen/AMDGPU/fmuladd.ll

test/CodeGen/AMDGPU/fneg-fabs.f64.ll

test/CodeGen/AMDGPU/fneg-fabs.ll

test/CodeGen/AMDGPU/fneg.f64.ll

test/CodeGen/AMDGPU/fneg.ll

test/CodeGen/AMDGPU/frem.ll

test/CodeGen/AMDGPU/fsub.ll

test/CodeGen/AMDGPU/fsub64.ll

test/CodeGen/AMDGPU/half.ll

test/CodeGen/AMDGPU/imm.ll

test/CodeGen/AMDGPU/jump-address.ll

test/CodeGen/AMDGPU/literals.ll

test/CodeGen/AMDGPU/llvm.AMDGPU.cube.ll

test/CodeGen/AMDGPU/llvm.AMDGPU.fract.f64.ll

test/CodeGen/AMDGPU/llvm.AMDGPU.fract.ll

test/CodeGen/AMDGPU/llvm.AMDGPU.rcp.f64.ll

test/CodeGen/AMDGPU/llvm.AMDGPU.rcp.ll

test/CodeGen/AMDGPU/llvm.SI.sample.ll

test/CodeGen/AMDGPU/llvm.SI.sampled.ll

test/CodeGen/AMDGPU/llvm.sin.ll

test/CodeGen/AMDGPU/load-input-fold.ll

test/CodeGen/AMDGPU/mad-combine.ll

test/CodeGen/AMDGPU/mad-sub.ll

test/CodeGen/AMDGPU/madak.ll

test/CodeGen/AMDGPU/madmk.ll

test/CodeGen/AMDGPU/max-literals.ll

test/CodeGen/AMDGPU/merge-stores.ll

test/CodeGen/AMDGPU/operand-spacing.ll

test/CodeGen/AMDGPU/pv-packing.ll

test/CodeGen/AMDGPU/pv.ll

test/CodeGen/AMDGPU/r600-encoding.ll

test/CodeGen/AMDGPU/r600-export-fix.ll

test/CodeGen/AMDGPU/r600-infinite-loop-bug-while-reorganizing-vector.ll

test/CodeGen/AMDGPU/reciprocal.ll

test/CodeGen/AMDGPU/rsq.ll

test/CodeGen/AMDGPU/rv7x0_count3.ll

test/CodeGen/AMDGPU/schedule-fs-loop-nested-if.ll

test/CodeGen/AMDGPU/schedule-if-2.ll

test/CodeGen/AMDGPU/schedule-if.ll

test/CodeGen/AMDGPU/schedule-vs-if-nested-loop.ll

test/CodeGen/AMDGPU/sgpr-copy.ll

test/CodeGen/AMDGPU/shared-op-cycle.ll

test/CodeGen/AMDGPU/shl_add_ptr.ll

test/CodeGen/AMDGPU/si-sgpr-spill.ll

test/CodeGen/AMDGPU/si-spill-cf.ll

test/CodeGen/AMDGPU/subreg-coalescer-crash.ll

test/CodeGen/AMDGPU/swizzle-export.ll

test/CodeGen/AMDGPU/tex-clause-antidep.ll

test/CodeGen/AMDGPU/texture-input-merge.ll

test/CodeGen/AMDGPU/use-sgpr-multiple-times.ll

test/CodeGen/AMDGPU/v_mac.ll

test/CodeGen/AMDGPU/vop-shrink.ll

test/CodeGen/ARM/2009-11-07-SubRegAsmPrinting.ll

test/CodeGen/ARM/a15-mla.ll

test/CodeGen/ARM/crash-greedy.ll

test/CodeGen/ARM/darwin-eabi.ll

test/CodeGen/ARM/debug-info-branch-folding.ll

test/CodeGen/ARM/debug-info-d16-reg.ll

test/CodeGen/ARM/debug-info-qreg.ll

test/CodeGen/ARM/fmacs.ll

test/CodeGen/ARM/fmscs.ll

test/CodeGen/ARM/fnegs.ll

test/CodeGen/ARM/fnmacs.ll

test/CodeGen/ARM/fnmscs.ll

test/CodeGen/ARM/fnmul.ll

test/CodeGen/ARM/fnmuls.ll

test/CodeGen/ARM/fp-fast.ll

test/CodeGen/ARM/fusedMAC.ll

test/CodeGen/ARM/ifcvt10.ll

test/CodeGen/ARM/isel-v8i32-crash.ll

test/CodeGen/ARM/reg_sequence.ll

test/CodeGen/ARM/saxpy10-a9.ll

test/CodeGen/ARM/unsafe-fsub.ll

test/CodeGen/ARM/vcvt.ll

test/CodeGen/ARM/vcvt_combine.ll

test/CodeGen/ARM/vdiv_combine.ll

test/CodeGen/ARM/vfp.ll

test/CodeGen/ARM/vmla.ll

test/CodeGen/ARM/vmls.ll

test/CodeGen/ARM/vmul.ll

test/CodeGen/Hexagon/opt-fneg.ll

test/CodeGen/Mips/fmadd1.ll

test/CodeGen/Mips/msa/3rf.ll

test/CodeGen/Mips/msa/arithmetic_float.ll

test/CodeGen/Mips/msa/basic_operations_float.ll

test/CodeGen/NVPTX/div-ri.ll

test/CodeGen/NVPTX/fast-math.ll

test/CodeGen/NVPTX/fma-assoc.ll

test/CodeGen/NVPTX/fma-disable.ll

test/CodeGen/NVPTX/fma.ll

test/CodeGen/NVPTX/fp-contract.ll

test/CodeGen/NVPTX/implicit-def.ll

test/CodeGen/NVPTX/rsqrt.ll

test/CodeGen/PowerPC/a2-fp-basic.ll

test/CodeGen/PowerPC/fdiv-combine.ll

test/CodeGen/PowerPC/fma-assoc.ll

test/CodeGen/PowerPC/fma-ext.ll

test/CodeGen/PowerPC/fma.ll

test/CodeGen/PowerPC/fneg.ll

test/CodeGen/PowerPC/loop-prep-all.ll

test/CodeGen/PowerPC/machine-combiner.ll

test/CodeGen/PowerPC/pip-inner.ll

test/CodeGen/PowerPC/ppc440-fp-basic.ll

test/CodeGen/PowerPC/pr15632.ll

test/CodeGen/PowerPC/qpx-bv-sint.ll

test/CodeGen/PowerPC/qpx-split-vsetcc.ll

test/CodeGen/PowerPC/recipest.ll

test/CodeGen/PowerPC/s000-alias-misched.ll

test/CodeGen/PowerPC/unsafe-math.ll

test/CodeGen/SystemZ/fp-add-01.ll

test/CodeGen/SystemZ/fp-add-02.ll

test/CodeGen/SystemZ/fp-add-03.ll

test/CodeGen/SystemZ/fp-cmp-04.ll

test/CodeGen/SystemZ/fp-div-01.ll

test/CodeGen/SystemZ/fp-div-02.ll

test/CodeGen/SystemZ/fp-div-03.ll

test/CodeGen/SystemZ/fp-mul-01.ll

test/CodeGen/SystemZ/fp-mul-02.ll

test/CodeGen/SystemZ/fp-mul-03.ll

test/CodeGen/SystemZ/fp-mul-04.ll

test/CodeGen/SystemZ/fp-mul-05.ll

test/CodeGen/SystemZ/fp-sincos-01.ll

test/CodeGen/SystemZ/fp-sub-01.ll

test/CodeGen/SystemZ/fp-sub-02.ll

test/CodeGen/SystemZ/fp-sub-03.ll

test/CodeGen/Thumb2/2010-06-14-NEONCoalescer.ll

test/CodeGen/Thumb2/buildvector-crash.ll

test/CodeGen/Thumb2/float-ops.ll

test/CodeGen/Thumb2/ifcvt-neon.ll

test/CodeGen/X86/2008-10-27-CoalescerBug.ll

test/CodeGen/X86/2012-04-26-sdglue.ll

test/CodeGen/X86/atomic_mi.ll

test/CodeGen/X86/avx512-fma.ll

test/CodeGen/X86/avx512vl-arith.ll

test/CodeGen/X86/chain_order.ll

test/CodeGen/X86/constant-pool-remat-0.ll

test/CodeGen/X86/fadd-combines.ll

test/CodeGen/X86/fdiv-combine.ll

test/CodeGen/X86/fdiv.ll

test/CodeGen/X86/fma-do-not-commute.ll

test/CodeGen/X86/fma_patterns.ll

test/CodeGen/X86/fma_patterns_wide.ll

test/CodeGen/X86/fmul-combines.ll

test/CodeGen/X86/fmul-zero.ll

test/CodeGen/X86/fold-load-binops.ll

test/CodeGen/X86/fold-xmm-zero.ll

test/CodeGen/X86/fp-fast.ll

test/CodeGen/X86/fp_constant_op.ll

test/CodeGen/X86/haddsub-2.ll

test/CodeGen/X86/haddsub-undef.ll

test/CodeGen/X86/haddsub.ll

test/CodeGen/X86/load-slice.ll

test/CodeGen/X86/lsr-static-addr.ll

test/CodeGen/X86/machine-combiner.ll

test/CodeGen/X86/misched-copy.ll

test/CodeGen/X86/misched-ilp.ll

test/CodeGen/X86/misched-matmul.ll

test/CodeGen/X86/negative-sin.ll

test/CodeGen/X86/pr23103.ll

test/CodeGen/X86/pr24139.ll

test/CodeGen/X86/select.ll

test/CodeGen/X86/sincos-opt.ll

test/CodeGen/X86/sink-hoist.ll

test/CodeGen/X86/sse-fcopysign.ll

test/CodeGen/X86/sse1.ll

test/CodeGen/X86/sse3-avx-addsub-2.ll

test/CodeGen/X86/sse3-avx-addsub.ll

test/CodeGen/X86/sse41.ll

test/CodeGen/X86/stack-folding-fp-avx1.ll

test/CodeGen/X86/stack-folding-fp-sse42.ll

test/CodeGen/X86/undef-label.ll

test/CodeGen/X86/vec_ss_load_fold.ll

test/CodeGen/X86/vec_unsafe-fp-math.ll

test/Transforms/CodeGenPrepare/X86/select.ll

test/Transforms/InstCombine/2009-01-19-fmod-constant-float-specials.ll

test/Transforms/InstCombine/fold-fops-into-selects.ll

test/Transforms/LoopReroll/basic.ll

test/Transforms/LoopReroll/nonconst_lb.ll

test/Transforms/Reassociate/mixed-fast-nonfast-fp.ll

test/Transforms/SCCP/apint-load.ll

test/Transforms/SLPVectorizer/X86/insert-element-build-vector.ll