Refactor: Simplify boolean conditional return statements in lib/Transforms/Vectorize

[LegalizeAdulthood]

Summary

Use clang-tidy to simplify boolean conditional return statements

[mzolotukhin]

Hi Richard,

Thanks for cleaning this up. In the first spot I prefer the original version, but the rest look fine (and if you feel strong about the first place too, I don't mind committing the change there as well).

Please mention that it's NFC in the commit message.

Thanks,
Michael

lib/Transforms/Vectorize/BBVectorize.cpp

937–938 ↗

(On Diff #26468)

Here I prefer the original version, for me it seems more natural to express the logic.

lib/Transforms/Vectorize/LoopVectorize.cpp

5218–5220

LGTM.

lib/Transforms/Vectorize/SLPVectorizer.cpp

171–173

LGTM.

1703

LGTM.

[LegalizeAdulthood]

Updated to latest.

[LegalizeAdulthood]

In D10003#178196, @mzolotukhin wrote:

Hi Richard,

Thanks for cleaning this up. In the first spot I prefer the original version, but the rest look fine (and if you feel strong about the first place too, I don't mind committing the change there as well).

Please mention that it's NFC in the commit message.

I don't have commit access. Subsequent improvements to clang-tidy based on feedback from these reviews resulted in the one exception you noted no longer being generated as a simplification per LLVM/Clang coding preferences.

[mzolotukhin]

Thanks! I committed it for you in r251206.

Michael

lib/Transforms/Vectorize/LoopVectorize.cpp

if (APStepVal.getBitWidth() > 64)
     return true;
 
   int64_t StepVal = APStepVal.getSExtValue();
 
   return StepVal > MaxMergeDistance;
 }
 
 static bool isStrideMul(Instruction *I, LoopVectorizationLegality *Legal) {
-  if (Legal->hasStride(I->getOperand(0)) || Legal->hasStride(I->getOperand(1)))
-    return true;
-  return false;
+  return Legal->hasStride(I->getOperand(0)) ||
+         Legal->hasStride(I->getOperand(1));
 }
 
 unsigned
 LoopVectorizationCostModel::getInstructionCost(Instruction *I, unsigned VF) {
   // If we know that this instruction will remain uniform, check the cost of
   // the scalar version.
   if (Legal->isUniformAfterVectorization(I))
     VF = 1;
 

lib/Transforms/Vectorize/SLPVectorizer.cpp

default:
     return 0;
   }
 }
 
 ///\returns bool representing if Opcode \p Op can be part
 /// of an alternate sequence which can later be merged as
 /// a ShuffleVector instruction.
 static bool canCombineAsAltInst(unsigned Op) {
-  if (Op == Instruction::FAdd || Op == Instruction::FSub ||
-      Op == Instruction::Sub || Op == Instruction::Add)
-    return true;
-  return false;
+  return Op == Instruction::FAdd || Op == Instruction::FSub ||
+         Op == Instruction::Sub || Op == Instruction::Add;
 }
 
 /// \returns ShuffleVector instruction if instructions in \p VL have
 ///  alternate fadd,fsub / fsub,fadd/add,sub/sub,add sequence.
 /// (i.e. e.g. opcodes of fadd,fsub,fadd,fsub...)
 static unsigned isAltInst(ArrayRef<Value *> VL) {
   Instruction *I0 = dyn_cast<Instruction>(VL[0]);
   unsigned Opcode = I0->getOpcode();
   unsigned AltOpcode = getAltOpcode(Opcode);
if (!VectorizableTree[0].NeedToGather &&
       (allConstant(VectorizableTree[1].Scalars) ||
        isSplat(VectorizableTree[1].Scalars)))
     return true;
 
   // Gathering cost would be too much for tiny trees.
   if (VectorizableTree[0].NeedToGather || VectorizableTree[1].NeedToGather)
     return false;
 
   return true;
 }
 
 int BoUpSLP::getSpillCost() {
   // Walk from the bottom of the tree to the top, tracking which values are
   // live. When we see a call instruction that is not part of our tree,
   // query TTI to see if there is a cost to keeping values live over it
   // (for example, if spills and fills are required).
   unsigned BundleWidth = VectorizableTree.front().Scalars.size();
if (ILeft && IRight) {
     } else if (ILeft->getOpcode() == IRight->getOpcode() &&
                Left[i - 1] == IRight) {
       // Try preserve broadcasts.
       return true;
     }
     return false;
   }
   // One opcode, put the instruction on the right.
-  if (ILeft) {
-    return true;
-  }
-  return false;
+  return ILeft != nullptr;
 }
 
 void BoUpSLP::reorderInputsAccordingToOpcode(ArrayRef<Value *> VL,
                                              SmallVectorImpl<Value *> &Left,
                                              SmallVectorImpl<Value *> &Right) {
 
   SmallVector<Value *, 16> OrigLeft, OrigRight;