Skip to content

Commit

Permalink
[ValueTracking] clang-format a section I'm about to touch; NFC
Browse files Browse the repository at this point in the history 
(Whitespace only change)

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@295690 91177308-0d34-0410-b5e6-96231b3b80d8
  • Loading branch information
@sanjoy
sanjoy committed Feb 21, 2017
1 parent 1cd3a6f commit 475a9ff
Showing 1 changed file with 64 additions and 64 deletions.
128 changes: 64 additions & 64 deletions lib/Analysis/ValueTracking.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -3810,79 +3810,79 @@ bool llvm::isGuaranteedToExecuteForEveryIteration(const Instruction *I,

bool llvm::propagatesFullPoison(const Instruction *I) {
switch (I->getOpcode()) {
case Instruction::Add:
case Instruction::Sub:
case Instruction::Xor:
case Instruction::Trunc:
case Instruction::BitCast:
case Instruction::AddrSpaceCast:
// These operations all propagate poison unconditionally. Note that poison
// is not any particular value, so xor or subtraction of poison with
// itself still yields poison, not zero.
return true;
case Instruction::Add:
case Instruction::Sub:
case Instruction::Xor:
case Instruction::Trunc:
case Instruction::BitCast:
case Instruction::AddrSpaceCast:
// These operations all propagate poison unconditionally. Note that poison
// is not any particular value, so xor or subtraction of poison with
// itself still yields poison, not zero.
return true;

case Instruction::AShr:
case Instruction::SExt:
// For these operations, one bit of the input is replicated across
// multiple output bits. A replicated poison bit is still poison.
return true;
case Instruction::AShr:
case Instruction::SExt:
// For these operations, one bit of the input is replicated across
// multiple output bits. A replicated poison bit is still poison.
return true;

case Instruction::Shl: {
// Left shift *by* a poison value is poison. The number of
// positions to shift is unsigned, so no negative values are
// possible there. Left shift by zero places preserves poison. So
// it only remains to consider left shift of poison by a positive
// number of places.
//
// A left shift by a positive number of places leaves the lowest order bit
// non-poisoned. However, if such a shift has a no-wrap flag, then we can
// make the poison operand violate that flag, yielding a fresh full-poison
// value.
auto *OBO = cast<OverflowingBinaryOperator>(I);
return OBO->hasNoUnsignedWrap() || OBO->hasNoSignedWrap();
}
case Instruction::Shl: {
// Left shift *by* a poison value is poison. The number of
// positions to shift is unsigned, so no negative values are
// possible there. Left shift by zero places preserves poison. So
// it only remains to consider left shift of poison by a positive
// number of places.
//
// A left shift by a positive number of places leaves the lowest order bit
// non-poisoned. However, if such a shift has a no-wrap flag, then we can
// make the poison operand violate that flag, yielding a fresh full-poison
// value.
auto *OBO = cast<OverflowingBinaryOperator>(I);
return OBO->hasNoUnsignedWrap() || OBO->hasNoSignedWrap();
}

case Instruction::Mul: {
// A multiplication by zero yields a non-poison zero result, so we need to
// rule out zero as an operand. Conservatively, multiplication by a
// non-zero constant is not multiplication by zero.
//
// Multiplication by a non-zero constant can leave some bits
// non-poisoned. For example, a multiplication by 2 leaves the lowest
// order bit unpoisoned. So we need to consider that.
//
// Multiplication by 1 preserves poison. If the multiplication has a
// no-wrap flag, then we can make the poison operand violate that flag
// when multiplied by any integer other than 0 and 1.
auto *OBO = cast<OverflowingBinaryOperator>(I);
if (OBO->hasNoUnsignedWrap() || OBO->hasNoSignedWrap()) {
for (Value *V : OBO->operands()) {
if (auto *CI = dyn_cast<ConstantInt>(V)) {
// A ConstantInt cannot yield poison, so we can assume that it is
// the other operand that is poison.
return !CI->isZero();
}
case Instruction::Mul: {
// A multiplication by zero yields a non-poison zero result, so we need to
// rule out zero as an operand. Conservatively, multiplication by a
// non-zero constant is not multiplication by zero.
//
// Multiplication by a non-zero constant can leave some bits
// non-poisoned. For example, a multiplication by 2 leaves the lowest
// order bit unpoisoned. So we need to consider that.
//
// Multiplication by 1 preserves poison. If the multiplication has a
// no-wrap flag, then we can make the poison operand violate that flag
// when multiplied by any integer other than 0 and 1.
auto *OBO = cast<OverflowingBinaryOperator>(I);
if (OBO->hasNoUnsignedWrap() || OBO->hasNoSignedWrap()) {
for (Value *V : OBO->operands()) {
if (auto *CI = dyn_cast<ConstantInt>(V)) {
// A ConstantInt cannot yield poison, so we can assume that it is
// the other operand that is poison.
return !CI->isZero();
}
}
return false;
}
return false;
}

case Instruction::ICmp:
// Comparing poison with any value yields poison. This is why, for
// instance, x s< (x +nsw 1) can be folded to true.
return true;
case Instruction::ICmp:
// Comparing poison with any value yields poison. This is why, for
// instance, x s< (x +nsw 1) can be folded to true.
return true;

case Instruction::GetElementPtr:
// A GEP implicitly represents a sequence of additions, subtractions,
// truncations, sign extensions and multiplications. The multiplications
// are by the non-zero sizes of some set of types, so we do not have to be
// concerned with multiplication by zero. If the GEP is in-bounds, then
// these operations are implicitly no-signed-wrap so poison is propagated
// by the arguments above for Add, Sub, Trunc, SExt and Mul.
return cast<GEPOperator>(I)->isInBounds();
case Instruction::GetElementPtr:
// A GEP implicitly represents a sequence of additions, subtractions,
// truncations, sign extensions and multiplications. The multiplications
// are by the non-zero sizes of some set of types, so we do not have to be
// concerned with multiplication by zero. If the GEP is in-bounds, then
// these operations are implicitly no-signed-wrap so poison is propagated
// by the arguments above for Add, Sub, Trunc, SExt and Mul.
return cast<GEPOperator>(I)->isInBounds();

default:
return false;
default:
return false;
}
}

Expand Down

0 comments on commit 475a9ff

Please sign in to comment.