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
1106–1107

Why not accept an FastMathFlags instead?

lib/Analysis/ValueTracking.cpp
3371–3372

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

3375

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
1106

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.

1243

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

lib/Analysis/InstructionSimplify.cpp
3783 ↗(On Diff #41912)

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

lib/Analysis/ValueTracking.cpp
3400

You already tested for KeepExceptions at this scope.

lib/IR/ConstantFold.cpp
1182

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
1804

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
1106

Should be done, at least for this patch.

1243

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
3400

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

lib/IR/ConstantFold.cpp
1182

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
1197

sweet!

lib/Transforms/InstCombine/InstructionCombining.cpp
212

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 232 files. Files without inline comments have been collapsed. Expand All Files

Revision Contents

PathSize
include/
llvm/
Analysis/
9 lines
IR/
30 lines
80 lines
60 lines
lib/
Analysis/
67 lines
IR/
3 lines
43 lines
45 lines
Transforms/
InstCombine/
11 lines
13 lines
Scalar/
5 lines
test/
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
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 42225

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
▲ Show 20 Lines • Show All 190 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 877 Lines • ▼ Show 20 Linespublic:
/// ///
static Constant *getOffsetOf(Type *Ty, Constant *FieldNo); static Constant *getOffsetOf(Type *Ty, Constant *FieldNo);
static Constant *getNeg(Constant *C, bool HasNUW = false, bool HasNSW =false); static Constant *getNeg(Constant *C, bool HasNUW = false, bool HasNSW =false);
static Constant *getFNeg(Constant *C); static Constant *getFNeg(Constant *C);
static Constant *getNot(Constant *C); static Constant *getNot(Constant *C);
static Constant *getAdd(Constant *C1, Constant *C2, static Constant *getAdd(Constant *C1, Constant *C2,
bool HasNUW = false, bool HasNSW = false); bool HasNUW = false, bool HasNSW = false);
static Constant *getFAdd(Constant *C1, Constant *C2); static Constant *getFAdd(Constant *C1, Constant *C2,
FastMathFlags FMF = FastMathFlags());
static Constant *getSub(Constant *C1, Constant *C2, static Constant *getSub(Constant *C1, Constant *C2,
bool HasNUW = false, bool HasNSW = false); bool HasNUW = false, bool HasNSW = false);
static Constant *getFSub(Constant *C1, Constant *C2); static Constant *getFSub(Constant *C1, Constant *C2,
FastMathFlags FMF = FastMathFlags());
static Constant *getMul(Constant *C1, Constant *C2, static Constant *getMul(Constant *C1, Constant *C2,
bool HasNUW = false, bool HasNSW = false); bool HasNUW = false, bool HasNSW = false);
static Constant *getFMul(Constant *C1, Constant *C2); static Constant *getFMul(Constant *C1, Constant *C2,
FastMathFlags FMF = FastMathFlags());
static Constant *getUDiv(Constant *C1, Constant *C2, bool isExact = false); static Constant *getUDiv(Constant *C1, Constant *C2, bool isExact = false);
static Constant *getSDiv(Constant *C1, Constant *C2, bool isExact = false); static Constant *getSDiv(Constant *C1, Constant *C2, bool isExact = false);
static Constant *getFDiv(Constant *C1, Constant *C2); static Constant *getFDiv(Constant *C1, Constant *C2,
FastMathFlags FMF = FastMathFlags());
static Constant *getURem(Constant *C1, Constant *C2); static Constant *getURem(Constant *C1, Constant *C2);
static Constant *getSRem(Constant *C1, Constant *C2); static Constant *getSRem(Constant *C1, Constant *C2);
static Constant *getFRem(Constant *C1, Constant *C2); static Constant *getFRem(Constant *C1, Constant *C2,
FastMathFlags FMF = FastMathFlags());
static Constant *getAnd(Constant *C1, Constant *C2); static Constant *getAnd(Constant *C1, Constant *C2);
static Constant *getOr(Constant *C1, Constant *C2); static Constant *getOr(Constant *C1, Constant *C2);
static Constant *getXor(Constant *C1, Constant *C2); static Constant *getXor(Constant *C1, Constant *C2);
static Constant *getShl(Constant *C1, Constant *C2, static Constant *getShl(Constant *C1, Constant *C2,
bool HasNUW = false, bool HasNSW = false); bool HasNUW = false, bool HasNSW = false);
static Constant *getLShr(Constant *C1, Constant *C2, bool isExact = false); static Constant *getLShr(Constant *C1, Constant *C2, bool isExact = false);
static Constant *getAShr(Constant *C1, Constant *C2, bool isExact = false); static Constant *getAShr(Constant *C1, Constant *C2, bool isExact = false);
static Constant *getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced = false); static Constant *getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced = false);
▲ Show 20 Lines • Show All 144 Lines • ▼ Show 20 Linespublic:
/// ///
/// \param OnlyIfReducedTy see \a getWithOperands() docs. /// \param OnlyIfReducedTy see \a getWithOperands() docs.
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 Flags operator-specific set of flags (e.g. SDivOperator::IsExact).
/// \param OnlyIfReducedTy see \a getWithOperands() docs. /// \param OnlyIfReducedTy see \a getWithOperands() docs.
/// \param FMF common fast-math flags that can affect folding.
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?
/// Return a binary or shift operator constant expression, folding if
/// possible.
///
/// Convenience overload for passing fast-math flags.
///
/// \param FMF common fast-math flags that can affect folding.
static Constant *get(unsigned Opcode, Constant *C1, Constant *C2,
FastMathFlags FMF);
/// \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
▲ Show 20 Lines • Show All 111 Lines • ▼ Show 20 Linespublic:
static inline bool classof(const Value *V) { static inline bool classof(const Value *V) {
return V->getValueID() == ConstantExprVal; return V->getValueID() == ConstantExprVal;
} }
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);
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.
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/ValueTracking.cpp

Show First 20 Lines • Show All 3,311 Lines • ▼ Show 20 Lines
bool llvm::isDereferenceablePointer(const Value *V, const DataLayout &DL, bool llvm::isDereferenceablePointer(const Value *V, const DataLayout &DL,
const Instruction *CtxI, const Instruction *CtxI,
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);
} }
/// Evaluates floating point operation to examine how it could affect
/// floating-environment at run-time if it's not folded. Returns false for
/// unsupported operation (not on constant operands), otherwise true is returned
/// and S is assigned status of the operation.
static bool getFPOpExceptions(const Operator *O, APFloat::opStatus &S) {
switch (O->getOpcode()) {
default:
assert(false && "Expected floating-point instruction!");
return false;
case Instruction::FMul:
case Instruction::FAdd:
case Instruction::FSub:
case Instruction::FDiv:
case Instruction::FRem:
break;
}
ConstantFP *LHSC = dyn_cast<ConstantFP>(O->getOperand(0));
ConstantFP *RHSC = dyn_cast<ConstantFP>(O->getOperand(1));
if (!LHSC || !RHSC)
return false;
APFloat LHS = LHSC->getValueAPF();
APFloat RHS = RHSC->getValueAPF();
switch (O->getOpcode()) {
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;
}
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) {
const Operator *Inst = dyn_cast<Operator>(V); const Operator *Inst = dyn_cast<Operator>(V);
if (!Inst) if (!Inst)
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?
return false; return false;
for (unsigned i = 0, e = Inst->getNumOperands(); i != e; ++i) for (unsigned i = 0, e = Inst->getNumOperands(); i != e; ++i)
majnemerUnsubmitted
Not Done
ReplyInline Actions

const auto *

majnemer: `const auto *`
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;
bool KeepExceptions = false;
if (const auto *MathOp = dyn_cast<FPMathOperator>(Inst)) {
// Rounding-mode changes the observable exceptions by moving the
// overflow/underflow boundaries.
KeepExceptions = !MathOp->hasNoExceptions() || !MathOp->hasNoRounding();
}
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 (!getFPOpExceptions(Inst, S))
return false;
if (S != APFloat::opOK || (S & APFloat::opInexact))
return false;
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 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, 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
Optional<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);
return ConstantFP::get(C1->getContext(), C3V); break;
case Instruction::FSub: case Instruction::FSub:
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…
sdmitroukAuthorUnsubmitted
Not Done
ReplyInline Actions

Changed it using Optional.

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

sweet!

mehdi_amini: sweet!
} }
} else if (VectorType *VTy = dyn_cast<VectorType>(C1->getType())) { } else if (VectorType *VTy = dyn_cast<VectorType>(C1->getType())) {
// Perform elementwise folding. // Perform elementwise folding.
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, 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, 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, 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,432 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
switch (Opcode) { switch (Opcode) {
default:
assert(!FMF.any() &&
"Fast-math flags must be used only with floating-point opcodes!");
break;
case Instruction::FAdd:
case Instruction::FSub:
case Instruction::FMul:
case Instruction::FDiv:
case Instruction::FRem:
break;
}
switch (Opcode) {
case Instruction::Add: case Instruction::Add:
case Instruction::Sub: case Instruction::Sub:
case Instruction::Mul: case Instruction::Mul:
assert(C1->getType() == C2->getType() && "Op types should be identical!"); assert(C1->getType() == C2->getType() && "Op types should be identical!");
assert(C1->getType()->isIntOrIntVectorTy() && assert(C1->getType()->isIntOrIntVectorTy() &&
"Tried to create an integer operation on a non-integer type!"); "Tried to create an integer operation on a non-integer type!");
break; break;
case Instruction::FAdd: case Instruction::FAdd:
Show All 40 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);
LLVMContextImpl *pImpl = C1->getContext().pImpl; LLVMContextImpl *pImpl = C1->getContext().pImpl;
return pImpl->ExprConstants.getOrCreate(C1->getType(), Key); return pImpl->ExprConstants.getOrCreate(C1->getType(), Key);
} }
Constant *ConstantExpr::get(unsigned Opcode, Constant *C1, Constant *C2,
FastMathFlags FMF) {
return get(Opcode, C1, C2, 0, nullptr, FMF);
}
Constant *ConstantExpr::getSizeOf(Type* Ty) { Constant *ConstantExpr::getSizeOf(Type* Ty) {
// sizeof is implemented as: (i64) gep (Ty*)null, 1 // sizeof is implemented as: (i64) gep (Ty*)null, 1
// Note that a non-inbounds gep is used, as null isn't within any object. // Note that a non-inbounds gep is used, as null isn't within any object.
Constant *GEPIdx = ConstantInt::get(Type::getInt32Ty(Ty->getContext()), 1); Constant *GEPIdx = ConstantInt::get(Type::getInt32Ty(Ty->getContext()), 1);
Constant *GEP = getGetElementPtr( Constant *GEP = getGetElementPtr(
Ty, Constant::getNullValue(PointerType::getUnqual(Ty)), GEPIdx); Ty, Constant::getNullValue(PointerType::getUnqual(Ty)), GEPIdx);
return getPtrToInt(GEP, return getPtrToInt(GEP,
Type::getInt64Ty(Ty->getContext())); Type::getInt64Ty(Ty->getContext()));
▲ Show 20 Lines • Show All 301 Lines • ▼ Show 20 Lines
Constant *ConstantExpr::getAdd(Constant *C1, Constant *C2, Constant *ConstantExpr::getAdd(Constant *C1, Constant *C2,
bool HasNUW, bool HasNSW) { bool HasNUW, bool HasNSW) {
unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) | unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
(HasNSW ? OverflowingBinaryOperator::NoSignedWrap : 0); (HasNSW ? OverflowingBinaryOperator::NoSignedWrap : 0);
return get(Instruction::Add, C1, C2, Flags); return get(Instruction::Add, C1, C2, Flags);
} }
Constant *ConstantExpr::getFAdd(Constant *C1, Constant *C2) { Constant *ConstantExpr::getFAdd(Constant *C1, Constant *C2, FastMathFlags FMF) {
return get(Instruction::FAdd, C1, C2); return get(Instruction::FAdd, C1, C2, 0, nullptr, FMF);
} }
Constant *ConstantExpr::getSub(Constant *C1, Constant *C2, Constant *ConstantExpr::getSub(Constant *C1, Constant *C2,
bool HasNUW, bool HasNSW) { bool HasNUW, bool HasNSW) {
unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) | unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
(HasNSW ? OverflowingBinaryOperator::NoSignedWrap : 0); (HasNSW ? OverflowingBinaryOperator::NoSignedWrap : 0);
return get(Instruction::Sub, C1, C2, Flags); return get(Instruction::Sub, C1, C2, Flags);
} }
Constant *ConstantExpr::getFSub(Constant *C1, Constant *C2) { Constant *ConstantExpr::getFSub(Constant *C1, Constant *C2, FastMathFlags FMF) {
return get(Instruction::FSub, C1, C2); return get(Instruction::FSub, C1, C2, 0, nullptr, FMF);
} }
Constant *ConstantExpr::getMul(Constant *C1, Constant *C2, Constant *ConstantExpr::getMul(Constant *C1, Constant *C2,
bool HasNUW, bool HasNSW) { bool HasNUW, bool HasNSW) {
unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) | unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
(HasNSW ? OverflowingBinaryOperator::NoSignedWrap : 0); (HasNSW ? OverflowingBinaryOperator::NoSignedWrap : 0);
return get(Instruction::Mul, C1, C2, Flags); return get(Instruction::Mul, C1, C2, Flags, nullptr);
} }
Constant *ConstantExpr::getFMul(Constant *C1, Constant *C2) { Constant *ConstantExpr::getFMul(Constant *C1, Constant *C2, FastMathFlags FMF) {
return get(Instruction::FMul, C1, C2); return get(Instruction::FMul, C1, C2, 0, nullptr, FMF);
} }
Constant *ConstantExpr::getUDiv(Constant *C1, Constant *C2, bool isExact) { Constant *ConstantExpr::getUDiv(Constant *C1, Constant *C2, bool isExact) {
return get(Instruction::UDiv, C1, C2, return get(Instruction::UDiv, C1, C2,
isExact ? PossiblyExactOperator::IsExact : 0); isExact ? PossiblyExactOperator::IsExact : 0);
} }
Constant *ConstantExpr::getSDiv(Constant *C1, Constant *C2, bool isExact) { Constant *ConstantExpr::getSDiv(Constant *C1, Constant *C2, bool isExact) {
return get(Instruction::SDiv, C1, C2, return get(Instruction::SDiv, C1, C2,
isExact ? PossiblyExactOperator::IsExact : 0); isExact ? PossiblyExactOperator::IsExact : 0);
} }
Constant *ConstantExpr::getFDiv(Constant *C1, Constant *C2) { Constant *ConstantExpr::getFDiv(Constant *C1, Constant *C2, FastMathFlags FMF) {
return get(Instruction::FDiv, C1, C2); return get(Instruction::FDiv, C1, C2, 0, nullptr, FMF);
} }
Constant *ConstantExpr::getURem(Constant *C1, Constant *C2) { Constant *ConstantExpr::getURem(Constant *C1, Constant *C2) {
return get(Instruction::URem, C1, C2); return get(Instruction::URem, C1, C2);
} }
Constant *ConstantExpr::getSRem(Constant *C1, Constant *C2) { Constant *ConstantExpr::getSRem(Constant *C1, Constant *C2) {
return get(Instruction::SRem, C1, C2); return get(Instruction::SRem, C1, C2);
} }
Constant *ConstantExpr::getFRem(Constant *C1, Constant *C2) { Constant *ConstantExpr::getFRem(Constant *C1, Constant *C2, FastMathFlags FMF) {
return get(Instruction::FRem, C1, C2); return get(Instruction::FRem, C1, C2, 0, nullptr, FMF);
} }
Constant *ConstantExpr::getAnd(Constant *C1, Constant *C2) { Constant *ConstantExpr::getAnd(Constant *C1, Constant *C2) {
return get(Instruction::And, C1, C2); return get(Instruction::And, C1, C2);
} }
Constant *ConstantExpr::getOr(Constant *C1, Constant *C2) { Constant *ConstantExpr::getOr(Constant *C1, Constant *C2) {
return get(Instruction::Or, C1, C2); return get(Instruction::Or, C1, C2);
▲ Show 20 Lines • Show All 773 Lines • Show Last 20 Lines

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) {
Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
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.
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);
if (isa<Constant>(Op0)) if (isa<Constant>(Op0))
if (SelectInst *SI = dyn_cast<SelectInst>(Op1)) if (SelectInst *SI = dyn_cast<SelectInst>(Op1))
if (Instruction *R = FoldOpIntoSelect(I, SI)) if (Instruction *R = FoldOpIntoSelect(I, SI))
return R; return R;
bool AllowReassociate = I.hasUnsafeAlgebra(); bool AllowReassociate = I.hasUnsafeAlgebra();
bool AllowReciprocal = I.hasAllowReciprocal(); bool AllowReciprocal = I.hasAllowReciprocal();
FastMathFlags FMF = I.getFastMathFlags();
if (Constant *Op1C = dyn_cast<Constant>(Op1)) { if (Constant *Op1C = dyn_cast<Constant>(Op1)) {
if (SelectInst *SI = dyn_cast<SelectInst>(Op0)) if (SelectInst *SI = dyn_cast<SelectInst>(Op0))
if (Instruction *R = FoldOpIntoSelect(I, SI)) if (Instruction *R = FoldOpIntoSelect(I, SI))
return R; return R;
if (AllowReassociate) { 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;
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.
if (isa<FPMathOperator>(I))
Flags = I.getFastMathFlags();
if (Value *V = SimplifyFPBinOp(Opcode, B, C, Flags, DL)) {
mehdi_aminiUnsubmitted
Not Done
ReplyInline Actions

No braces

mehdi_amini: No braces
// 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, 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/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/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