6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-10-02 02:55:35 +00:00
Code Issues Projects Releases Wiki Activity

Change name of copyFlags() to copyIRFlags(). Add convenience method for logical 'and' of all flags. NFC.

Browse Source 
Adding 'IR' to the names in an attempt to be less ambiguous about the flags we're dealing with here.

The 'and' method is needed by the SLPVectorizer (PR20802) and possibly other passes.



git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@217004 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Sanjay Patel 2014-09-03 01:06:50 +00:00
parent fbe935edc1
commit ae77bf49f4
3 changed files with 24 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
include/llvm/IR/InstrTypes.h
View File

@ -360,7 +360,11 @@ public:
/// Convenience method to copy supported wrapping, exact, and fast-math flags
/// from V to this instruction.
void copyFlags(const Value *V);
void copyIRFlags(const Value *V);
/// Logical 'and' of any supported wrapping, exact, and fast-math flags of
/// V and this instruction.
void andIRFlags(const Value *V);
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const Instruction *I) {

19
lib/IR/Instructions.cpp
View File

@ -2030,7 +2030,7 @@ bool BinaryOperator::isExact() const {
return cast<PossiblyExactOperator>(this)->isExact();
}
void BinaryOperator::copyFlags(const Value *V) {
void BinaryOperator::copyIRFlags(const Value *V) {
// Copy the wrapping flags.
if (auto *OB = dyn_cast<OverflowingBinaryOperator>(V)) {
setHasNoSignedWrap(OB->hasNoSignedWrap());
@ -2046,6 +2046,23 @@ void BinaryOperator::copyFlags(const Value *V) {
copyFastMathFlags(FP->getFastMathFlags());
}
void BinaryOperator::andIRFlags(const Value *V) {
if (auto *OB = dyn_cast<OverflowingBinaryOperator>(V)) {
setHasNoSignedWrap(hasNoSignedWrap() & OB->hasNoSignedWrap());
setHasNoUnsignedWrap(hasNoUnsignedWrap() & OB->hasNoUnsignedWrap());
}
if (auto *PE = dyn_cast<PossiblyExactOperator>(V))
setIsExact(isExact() & PE->isExact());
if (auto *FP = dyn_cast<FPMathOperator>(V)) {
FastMathFlags FM = getFastMathFlags();
FM &= FP->getFastMathFlags();
copyFastMathFlags(FM);
}
}
//===----------------------------------------------------------------------===//
// FPMathOperator Class
//===----------------------------------------------------------------------===//

2
lib/Transforms/Vectorize/LoopVectorize.cpp
View File

@ -3249,7 +3249,7 @@ void InnerLoopVectorizer::vectorizeBlockInLoop(BasicBlock *BB, PhiVector *PV) {
Value *V = Builder.CreateBinOp(BinOp->getOpcode(), A[Part], B[Part]);
if (BinaryOperator *VecOp = dyn_cast<BinaryOperator>(V))
VecOp->copyFlags(BinOp);
VecOp->copyIRFlags(BinOp);
Entry[Part] = V;
}