maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[InstCombine] fix formatting in vector evaluators; NFC 

We need to alter the functionality as shown in D52548.

llvm-svn: 343379
This commit is contained in:
Sanjay Patel 2018-09-29 15:05:24 +00:00
parent 20c64510cb
commit 54d31ef87e
2 changed files with 13 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
llvm/lib/Transforms/InstCombine/InstCombineInternal.h
View File

@ -551,7 +551,6 @@ private:
Value *EmitGEPOffset(User *GEP); Value *EmitGEPOffset(User *GEP);
Instruction *scalarizePHI(ExtractElementInst &EI, PHINode *PN); Instruction *scalarizePHI(ExtractElementInst &EI, PHINode *PN);
Value *EvaluateInDifferentElementOrder(Value *V, ArrayRef<int> Mask);
Instruction *foldCastedBitwiseLogic(BinaryOperator &I); Instruction *foldCastedBitwiseLogic(BinaryOperator &I);
Instruction *narrowBinOp(TruncInst &Trunc); Instruction *narrowBinOp(TruncInst &Trunc);
Instruction *narrowMaskedBinOp(BinaryOperator &And); Instruction *narrowMaskedBinOp(BinaryOperator &And);

26
llvm/lib/Transforms/InstCombine/InstCombineVectorOps.cpp
View File

@ -871,7 +871,7 @@ Instruction *InstCombiner::visitInsertElementInst(InsertElementInst &IE) {
/// Return true if we can evaluate the specified expression tree if the vector /// Return true if we can evaluate the specified expression tree if the vector
/// elements were shuffled in a different order. /// elements were shuffled in a different order.
static bool CanEvaluateShuffled(Value *V, ArrayRef<int> Mask, static bool canEvaluateShuffled(Value *V, ArrayRef<int> Mask,
unsigned Depth = 5) { unsigned Depth = 5) {
// We can always reorder the elements of a constant. // We can always reorder the elements of a constant.
if (isa<Constant>(V)) if (isa<Constant>(V))
@ -919,7 +919,7 @@ static bool CanEvaluateShuffled(Value *V, ArrayRef<int> Mask,
case Instruction::FPExt: case Instruction::FPExt:
case Instruction::GetElementPtr: { case Instruction::GetElementPtr: {
for (Value *Operand : I->operands()) { for (Value *Operand : I->operands()) {
if (!CanEvaluateShuffled(Operand, Mask, Depth-1)) if (!canEvaluateShuffled(Operand, Mask, Depth - 1))
return false; return false;
} }
return true; return true;
@ -939,7 +939,7 @@ static bool CanEvaluateShuffled(Value *V, ArrayRef<int> Mask,
SeenOnce = true; SeenOnce = true;
} }
} }
return CanEvaluateShuffled(I->getOperand(0), Mask, Depth-1); return canEvaluateShuffled(I->getOperand(0), Mask, Depth - 1);
} }
} }
return false; return false;
@ -1023,12 +1023,12 @@ static Value *buildNew(Instruction *I, ArrayRef<Value*> NewOps) {
llvm_unreachable("failed to rebuild vector instructions"); llvm_unreachable("failed to rebuild vector instructions");
} }
Value * static Value *evaluateInDifferentElementOrder(Value *V, ArrayRef<int> Mask) {
InstCombiner::EvaluateInDifferentElementOrder(Value *V, ArrayRef<int> Mask) {
// Mask.size() does not need to be equal to the number of vector elements. // Mask.size() does not need to be equal to the number of vector elements.
assert(V->getType()->isVectorTy() && "can't reorder non-vector elements"); assert(V->getType()->isVectorTy() && "can't reorder non-vector elements");
Type *EltTy = V->getType()->getScalarType(); Type *EltTy = V->getType()->getScalarType();
Type *I32Ty = IntegerType::getInt32Ty(V->getContext());
if (isa<UndefValue>(V)) if (isa<UndefValue>(V))
return UndefValue::get(VectorType::get(EltTy, Mask.size())); return UndefValue::get(VectorType::get(EltTy, Mask.size()));
@ -1039,9 +1039,9 @@ InstCombiner::EvaluateInDifferentElementOrder(Value *V, ArrayRef<int> Mask) {
SmallVector<Constant *, 16> MaskValues; SmallVector<Constant *, 16> MaskValues;
for (int i = 0, e = Mask.size(); i != e; ++i) { for (int i = 0, e = Mask.size(); i != e; ++i) {
if (Mask[i] == -1) if (Mask[i] == -1)
MaskValues.push_back(UndefValue::get(Builder.getInt32Ty())); MaskValues.push_back(UndefValue::get(I32Ty));
else else
MaskValues.push_back(Builder.getInt32(Mask[i])); MaskValues.push_back(ConstantInt::get(I32Ty, Mask[i]));
} }
return ConstantExpr::getShuffleVector(C, UndefValue::get(C->getType()), return ConstantExpr::getShuffleVector(C, UndefValue::get(C->getType()),
ConstantVector::get(MaskValues)); ConstantVector::get(MaskValues));
@ -1083,7 +1083,7 @@ InstCombiner::EvaluateInDifferentElementOrder(Value *V, ArrayRef<int> Mask) {
SmallVector<Value*, 8> NewOps; SmallVector<Value*, 8> NewOps;
bool NeedsRebuild = (Mask.size() != I->getType()->getVectorNumElements()); bool NeedsRebuild = (Mask.size() != I->getType()->getVectorNumElements());
for (int i = 0, e = I->getNumOperands(); i != e; ++i) { for (int i = 0, e = I->getNumOperands(); i != e; ++i) {
Value *V = EvaluateInDifferentElementOrder(I->getOperand(i), Mask); Value *V = evaluateInDifferentElementOrder(I->getOperand(i), Mask);
NewOps.push_back(V); NewOps.push_back(V);
NeedsRebuild |= (V != I->getOperand(i)); NeedsRebuild |= (V != I->getOperand(i));
} }
@ -1110,11 +1110,11 @@ InstCombiner::EvaluateInDifferentElementOrder(Value *V, ArrayRef<int> Mask) {
// If element is not in Mask, no need to handle the operand 1 (element to // If element is not in Mask, no need to handle the operand 1 (element to
// be inserted). Just evaluate values in operand 0 according to Mask. // be inserted). Just evaluate values in operand 0 according to Mask.
if (!Found) if (!Found)
return EvaluateInDifferentElementOrder(I->getOperand(0), Mask); return evaluateInDifferentElementOrder(I->getOperand(0), Mask);
Value *V = EvaluateInDifferentElementOrder(I->getOperand(0), Mask); Value *V = evaluateInDifferentElementOrder(I->getOperand(0), Mask);
return InsertElementInst::Create(V, I->getOperand(1), return InsertElementInst::Create(V, I->getOperand(1),
Builder.getInt32(Index), "", I); ConstantInt::get(I32Ty, Index), "", I);
} }
} }
llvm_unreachable("failed to reorder elements of vector instruction!"); llvm_unreachable("failed to reorder elements of vector instruction!");
@ -1465,8 +1465,8 @@ Instruction *InstCombiner::visitShuffleVectorInst(ShuffleVectorInst &SVI) {
} }
if (isa<UndefValue>(RHS) && !SVI.increasesLength() && if (isa<UndefValue>(RHS) && !SVI.increasesLength() &&
CanEvaluateShuffled(LHS, Mask)) { canEvaluateShuffled(LHS, Mask)) {
Value *V = EvaluateInDifferentElementOrder(LHS, Mask); Value *V = evaluateInDifferentElementOrder(LHS, Mask);
return replaceInstUsesWith(SVI, V); return replaceInstUsesWith(SVI, V);
} }