Refactor: Simplify boolean conditional return statements in lib/Target/NVPTX

[LegalizeAdulthood]

Summary

Use clang-tidy to simplify boolean conditional return statements

[craig.topper]

lib/Target/NVPTX/NVPTXAsmPrinter.cpp

638

Use !=

1919–1920

Fix indentation to line up with previous line.

lib/Target/NVPTX/NVPTXISelLowering.cpp

3740

Push negate through

4105–4106

Drop the else and the curly braces

lib/Target/NVPTX/NVPTXUtilities.cpp

338–339

Indent to line up with previous line. Same below

[LegalizeAdulthood]

lib/Target/NVPTX/NVPTXAsmPrinter.cpp

638

Fixed.

1919–1920

Fixed.

lib/Target/NVPTX/NVPTXISelLowering.cpp

3740

Fixed.

4105–4106

While I know this is an LLVM/clang style rule, it's beyond the scope of this change. There is a check for this in clang-tidy to detect it.

lib/Target/NVPTX/NVPTXUtilities.cpp

338–339

Fixed.

[LegalizeAdulthood]

Update from comments, clang-format

[jingyue]

other than that LGTM. Pretty useful tool! Thanks.

lib/Target/NVPTX/NVPTXUtilities.cpp

348

return (id == Intrinsics::xxx) ||
       (id == Intrinsics::yyy) ||

makes the code more aligned.

[jholewinski]

LGTM

lib/Target/NVPTX/NVPTXAsmPrinter.cpp

void NVPTXAsmPrinter::emitDeclaration(const Function *F, raw_ostream &O) {
   O << ";\n";
 }
 
 static bool usedInGlobalVarDef(const Constant *C) {
   if (!C)
     return false;
 
   if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(C)) {
-    if (GV->getName() == "llvm.used")
-      return false;
-    return true;
+    return GV->getName() != "llvm.used";
   }
 
   for (const User *U : C->users())
     if (const Constant *C = dyn_cast<Constant>(U))
       if (usedInGlobalVarDef(C))
         return true;
 
   return false;

 }
 
 // buildTypeNameMap - Run through symbol table looking for type names.
 //
 
 bool NVPTXAsmPrinter::isImageType(const Type *Ty) {
 
   std::map<const Type *, std::string>::iterator PI = TypeNameMap.find(Ty);
 
-  if (PI != TypeNameMap.end() && (!PI->second.compare("struct._image1d_t") ||
+  return PI != TypeNameMap.end() && (!PI->second.compare("struct._image1d_t") ||
                                      !PI->second.compare("struct._image2d_t") ||
-                                  !PI->second.compare("struct._image3d_t")))
-    return true;
-
-  return false;
+                                     !PI->second.compare("struct._image3d_t"));
 }
 
 
 bool NVPTXAsmPrinter::ignoreLoc(const MachineInstr &MI) {
   switch (MI.getOpcode()) {
   default:
     return false;
   case NVPTX::CallArgBeginInst:

lib/Target/NVPTX/NVPTXISelLowering.cpp

bool NVPTXTargetLowering::isLegalAddressingMode(const AddrMode &AM,
   //
   // The legal address modes are
   // - [avar]
   // - [areg]
   // - [areg+immoff]
   // - [immAddr]
 
   if (AM.BaseGV) {
-    if (AM.BaseOffs || AM.HasBaseReg || AM.Scale)
-      return false;
-    return true;
+    return !AM.BaseOffs && !AM.HasBaseReg && !AM.Scale;
   }
 
   switch (AM.Scale) {
   case 0: // "r", "r+i" or "i" is allowed
     break;
   case 1:
     if (AM.HasBaseReg) // "r+r+i" or "r+r" is not allowed.
       return false;
if (LHSSign == Unknown)
     return false;
 
   IsSigned = (LHSSign == Signed);
 
   // The RHS can be a demotable op or a constant
   if (ConstantSDNode *CI = dyn_cast<ConstantSDNode>(RHS)) {
     APInt Val = CI->getAPIntValue();
     if (LHSSign == Unsigned) {
-      if (Val.isIntN(OptSize)) {
-        return true;
-      }
-      return false;
+      return Val.isIntN(OptSize);
     } else {
-      if (Val.isSignedIntN(OptSize)) {
-        return true;
-      }
-      return false;
+      return Val.isSignedIntN(OptSize);
     }
   } else {
     OperandSignedness RHSSign;
     if (!IsMulWideOperandDemotable(RHS, OptSize, RHSSign))
       return false;
 
-    if (LHSSign != RHSSign)
-      return false;
-
-    return true;
+    return LHSSign == RHSSign;
   }
 }
 
 /// TryMULWIDECombine - Attempt to replace a multiply of M bits with a multiply
 /// of M/2 bits that produces an M-bit result (i.e. mul.wide). This transform
 /// works on both multiply DAG nodes and SHL DAG nodes with a constant shift
 /// amount.
 static SDValue TryMULWIDECombine(SDNode *N,

lib/Target/NVPTX/NVPTXUtilities.cpp

for (int i = 0, n = alignNode->getNumOperands(); i < n; i++) {
           return false;
         }
       }
     }
   }
   return false;
 }
 
 bool llvm::isBarrierIntrinsic(Intrinsic::ID id) {
-  if ((id == Intrinsic::nvvm_barrier0) ||
+  return (id == Intrinsic::nvvm_barrier0) ||
          (id == Intrinsic::nvvm_barrier0_popc) ||
          (id == Intrinsic::nvvm_barrier0_and) ||
          (id == Intrinsic::nvvm_barrier0_or) ||
-      (id == Intrinsic::cuda_syncthreads))
-    return true;
-  return false;
+         (id == Intrinsic::cuda_syncthreads);
 }
 
 // Interface for checking all memory space transfer related intrinsics
 bool llvm::isMemorySpaceTransferIntrinsic(Intrinsic::ID id) {
-  if (id == Intrinsic::nvvm_ptr_local_to_gen ||
+  return id == Intrinsic::nvvm_ptr_local_to_gen ||
       id == Intrinsic::nvvm_ptr_shared_to_gen ||
       id == Intrinsic::nvvm_ptr_global_to_gen ||
       id == Intrinsic::nvvm_ptr_constant_to_gen ||
       id == Intrinsic::nvvm_ptr_gen_to_global ||
       id == Intrinsic::nvvm_ptr_gen_to_shared ||
       id == Intrinsic::nvvm_ptr_gen_to_local ||
       id == Intrinsic::nvvm_ptr_gen_to_constant ||
-      id == Intrinsic::nvvm_ptr_gen_to_param) {
-    return true;
-  }
-
-  return false;
+      id == Intrinsic::nvvm_ptr_gen_to_param;
 }
 
 // consider several special intrinsics in striping pointer casts, and
 // provide an option to ignore GEP indicies for find out the base address only
 // which could be used in simple alias disambigurate.
 const Value *
 llvm::skipPointerTransfer(const Value *V, bool ignore_GEP_indices) {
   V = V->stripPointerCasts();