Fix C4800

```
warning C4800: 'uint32_t' : forcing value to bool 'true' or 'false' (performance warning)
```

compiler/compile/OMRCompilation.cpp

@@ -776,7 +776,7 @@ OMR::Compilation::getOSRTransitionTarget()
 bool
 OMR::Compilation::isOSRTransitionTarget(TR::OSRTransitionTarget target)
    {
-   return target & self()->getOSRTransitionTarget();
+   return (target & self()->getOSRTransitionTarget()) != 0;
    }
 
 /*

compiler/control/OMROptions.cpp

@@ -4522,7 +4522,7 @@ OMR::Options::checkDisableFlagForAllMethods(OMR::Optimizations o, bool b)
 char *
 OMR::Options::setStaticBool(char *option, void *base, TR::OptionTable *entry)
    {
-   *((bool*)entry->parm1) = (bool)entry->parm2;
+   *((bool*)entry->parm1) = (entry->parm2 != 0);
    return option;
    }
 

compiler/cs2/bitvectr.h

@@ -398,7 +398,7 @@ class ABitVector : private Allocator {
       wordIndex = fIndex / kBitWordSize;
       bitIndex = fIndex % kBitWordSize;
 
-      bitValue = (fVector.WordAt(wordIndex) << bitIndex) >> (kBitWordSize - 1);
+      bitValue = ((fVector.WordAt(wordIndex) << bitIndex) >> (kBitWordSize - 1)) != 0;
       return bitValue;
     }
 
@@ -476,7 +476,7 @@ inline bool ABitVector<Allocator>::ValueAt (BitIndex bitIndex) const {
   wordIndex = bitIndex / kBitWordSize;
   bitIndex = bitIndex % kBitWordSize;
 
-  return (WordAt(wordIndex) << bitIndex) >> (kBitWordSize - 1);
+  return ((WordAt(wordIndex) << bitIndex) >> (kBitWordSize - 1)) != 0;
 }
 
 template <class Allocator>

compiler/il/OMRResolvedMethodSymbol.cpp

@@ -2398,7 +2398,7 @@ OMR::ResolvedMethodSymbol::isParmVariant(TR::ParameterSymbol * parmSymbol)
                   "Parm %d (%p) cannot be owned by current method that only has %d parms", parmSymbol->getOrdinal(), parmSymbol, numberOfParameters);
    TR_ASSERT_FATAL(self()->getParmSymRef(parmSymbol->getSlot())->getSymbol()->getParmSymbol() == parmSymbol,
                   "Parm %p is not owned by current method %s", parmSymbol, self()->signature(self()->comp()->trMemory()));
-   return _variantParms->get(parmSymbol->getOrdinal());
+   return _variantParms->get(parmSymbol->getOrdinal()) != 0;
    }
 
 void

compiler/infra/Assert.cpp

@@ -199,7 +199,7 @@ namespace TR
       {
       if (!_node) return;
 
-      static bool printFullContext = feGetEnv("TR_AssertFullContext");
+      static bool printFullContext = feGetEnv("TR_AssertFullContext") != NULL;
       TR::Compilation *comp = TR::comp();
       TR_Debug *debug = comp->findOrCreateDebug();
 
@@ -250,7 +250,7 @@ namespace TR
       {
       if (!_instruction) return;
 
-      static bool printFullContext = feGetEnv("TR_AssertFullContext");
+      static bool printFullContext = feGetEnv("TR_AssertFullContext") != NULL;
       static int numInstructionsInContext = feGetEnv("TR_AssertNumInstructionsInContext") ?
          atoi(feGetEnv("TR_AssertNumInstructionsInContext")) : 11;
       TR_Debug *debug = TR::comp()->findOrCreateDebug();

compiler/infra/BitVector.cpp

@@ -241,7 +241,7 @@ bool TR_BitContainer::intersects(TR_BitVector& v2)
    else if (_type == bitvector)
       return false;
    else
-      return v2.get(_singleBit);
+      return v2.get(_singleBit) != 0;
    }
 
 bool TR_BitContainer::intersects(TR_BitContainer& v2)
@@ -254,7 +254,7 @@ bool TR_BitContainer::intersects(TR_BitContainer& v2)
       {
       // v2 is singleton
       if (_type == bitvector && _bitVector)
-         return get(v2._singleBit);
+         return get(v2._singleBit) != 0;
       else if (_type == bitvector)
          return false;
       else

compiler/infra/BitVector.hpp

@@ -429,7 +429,7 @@ class TR_BitVector
    // value had been set
    bool clear(int64_t n)
       {
-      bool rc = get(n);
+      bool rc = get(n) != 0;
       if (rc)
          reset(n);
 #if BV_SANITY_CHECK

compiler/infra/OMRCfg.cpp

@@ -667,22 +667,22 @@ TR::CFGEdge * TR::CFGNode::getExceptionPredecessorEdge(TR::CFGNode * n)
 
 bool TR::CFGNode::hasSuccessor(TR::CFGNode * n)
    {
-   return (bool)getSuccessorEdge(n);
+   return getSuccessorEdge(n) != NULL;
    }
 
 bool TR::CFGNode::hasExceptionSuccessor(TR::CFGNode * n)
    {
-   return (bool)getExceptionSuccessorEdge(n);
+   return getExceptionSuccessorEdge(n) != NULL;
    }
 
 bool TR::CFGNode::hasPredecessor(TR::CFGNode * n)
    {
-   return (bool)getPredecessorEdge(n);
+   return getPredecessorEdge(n) != NULL;
    }
 
 bool TR::CFGNode::hasExceptionPredecessor(TR::CFGNode * n)
    {
-   return (bool)getExceptionPredecessorEdge(n);
+   return getExceptionPredecessorEdge(n) != NULL;
    }
 
 

compiler/infra/SimpleRegex.cpp

@@ -373,7 +373,7 @@ bool SimpleRegex::Simple::match(const char *s, bool isCaseSensitive, bool useLoc
 
 bool SimpleRegex::Regex::match(const char *s, bool isCaseSensitive, bool useLocale)
    {
-   int32_t rc = false;
+   bool rc = false;
    for (Regex *p = this; p && !rc; p = p->remainder)
       {
       rc = p->simple->match(s, isCaseSensitive, useLocale);

compiler/optimizer/DeadTreesElimination.cpp

@@ -629,7 +629,7 @@ void TR::DeadTreesElimination::prePerformOnBlocks()
           && tt->getPrevTreeTop()->getNode()->getOpCodeValue() == TR::BBStart
           && !tt->getPrevTreeTop()->getNode()->getBlock()->isExtensionOfPreviousBlock())
          {
-         requestOpt(OMR::redundantGotoElimination, tt->getEnclosingBlock());
+         requestOpt(OMR::redundantGotoElimination, true, tt->getEnclosingBlock());
          }
 
       if (node->getVisitCount() >= visitCount)
@@ -1003,6 +1003,7 @@ int32_t TR::DeadTreesElimination::process(TR::TreeTop *startTree, TR::TreeTop *e
                   {
                   requestOpt(
                      OMR::redundantGotoElimination,
+                     true,
                      prevTree->getNode()->getBlock());
                   }
                }

compiler/optimizer/InductionVariable.cpp

@@ -6473,7 +6473,7 @@ TR_InductionVariableAnalysis::analyzeExitEdges(TR_RegionStructure *loop,
                }
             }
          else
-            osrInduceExitEdge = _isOSRInduceBlock.get(toNum);
+            osrInduceExitEdge = (_isOSRInduceBlock.get(toNum) != 0);
 
          if (osrInduceExitEdge)
             {

compiler/optimizer/Inliner.cpp

@@ -1032,7 +1032,7 @@ TR_CallStack::initializeControlFlowInfo(TR::ResolvedMethodSymbol * callerSymbol)
 
    for (int32_t i = 0; i < numberOfBlocks; ++i)
       {
-      blockInfo(i)._inALoop = loopingBlocks.get(i);
+      blockInfo(i)._inALoop = (loopingBlocks.get(i) != 0);
       }
    // Walk forward following successor edges to mark blocks that are always reached
    //

compiler/optimizer/LocalAnticipatability.cpp

@@ -55,7 +55,7 @@ TR_LocalAnticipatability::TR_LocalAnticipatability(TR_LocalAnalysisInfo &info, T
       traceMsg(comp(), "Starting LocalAnticipatability\n");
 
    static const char *e = feGetEnv("TR_loadaddrAsLoad");
-   _loadaddrAsLoad = e ? atoi(e) : true;
+   _loadaddrAsLoad = e ? (atoi(e) != 0) : true;
 
    initializeLocalAnalysis(true);
    TR::SymbolReferenceTable *symRefTab = comp()->getSymRefTab();

compiler/optimizer/LoopVersioner.cpp

@@ -5912,7 +5912,7 @@ void TR_LoopVersioner::buildConditionalTree(
                TR::Node *storeNode = _storeTrees[indexNode->getSymbolReference()->getReferenceNumber()]->getNode();
                //int32_t exitValue = exitValue = storeNode->getFirstChild()->getSecondChild()->getInt();
 
-               loopLimit = _loopTestTree->getNode()->getSecondChild()->duplicateTree(comp());
+               loopLimit = _loopTestTree->getNode()->getSecondChild()->duplicateTree();
                if(isAddition)
                   {
                   range = TR::Node::create(TR::isub, 2, loopLimit,entryNode);
@@ -5996,7 +5996,7 @@ void TR_LoopVersioner::buildConditionalTree(
                TR_ASSERT(parent, "Parent shouldn't be null\n");
 
                TR_ASSERT(indexChildIndex>=0, "Index child index should be valid at this point\n");
-               duplicateIndexNode = conditionalNode->getChild(indexChildIndex)->duplicateTree(comp());
+               duplicateIndexNode = conditionalNode->getChild(indexChildIndex)->duplicateTree();
 
                int visitCount = comp()->incVisitCount();
                int32_t indexSymRefNum = loopDrivingSymRef->getReferenceNumber();
@@ -6019,24 +6019,24 @@ void TR_LoopVersioner::buildConditionalTree(
             if(indexNodeOccursAsSecondChild)
                {
                if (!reverseBranch)
-                  duplicateComparisonNode = TR::Node::createif(conditionalNode->getOpCodeValue(), conditionalNode->getFirstChild()->duplicateTree(comp()),duplicateIndexNode, _exitGotoTarget);
+                  duplicateComparisonNode = TR::Node::createif(conditionalNode->getOpCodeValue(), conditionalNode->getFirstChild()->duplicateTree(),duplicateIndexNode, _exitGotoTarget);
                else
-                  duplicateComparisonNode = TR::Node::createif(conditionalNode->getOpCode().getOpCodeForReverseBranch(), conditionalNode->getFirstChild()->duplicateTree(comp()), duplicateIndexNode, _exitGotoTarget);
+                  duplicateComparisonNode = TR::Node::createif(conditionalNode->getOpCode().getOpCodeForReverseBranch(), conditionalNode->getFirstChild()->duplicateTree(), duplicateIndexNode, _exitGotoTarget);
                }
             else
                {
                if (!reverseBranch)
-                  duplicateComparisonNode = TR::Node::createif(conditionalNode->getOpCodeValue(),duplicateIndexNode, conditionalNode->getSecondChild()->duplicateTree(comp()), _exitGotoTarget);
+                  duplicateComparisonNode = TR::Node::createif(conditionalNode->getOpCodeValue(),duplicateIndexNode, conditionalNode->getSecondChild()->duplicateTree(), _exitGotoTarget);
                else
-                  duplicateComparisonNode = TR::Node::createif(conditionalNode->getOpCode().getOpCodeForReverseBranch(), duplicateIndexNode, conditionalNode->getSecondChild()->duplicateTree(comp()), _exitGotoTarget);
+                  duplicateComparisonNode = TR::Node::createif(conditionalNode->getOpCode().getOpCodeForReverseBranch(), duplicateIndexNode, conditionalNode->getSecondChild()->duplicateTree(), _exitGotoTarget);
                }
             }
          else
             {
             if (!reverseBranch)
-               duplicateComparisonNode = TR::Node::createif(conditionalNode->getOpCodeValue(), conditionalNode->getFirstChild()->duplicateTree(comp()), conditionalNode->getSecondChild()->duplicateTree(comp()), _exitGotoTarget);
+               duplicateComparisonNode = TR::Node::createif(conditionalNode->getOpCodeValue(), conditionalNode->getFirstChild()->duplicateTree(), conditionalNode->getSecondChild()->duplicateTree(), _exitGotoTarget);
             else
-               duplicateComparisonNode = TR::Node::createif(conditionalNode->getOpCode().getOpCodeForReverseBranch(), conditionalNode->getFirstChild()->duplicateTree(comp()), conditionalNode->getSecondChild()->duplicateTree(comp()), _exitGotoTarget);
+               duplicateComparisonNode = TR::Node::createif(conditionalNode->getOpCode().getOpCodeForReverseBranch(), conditionalNode->getFirstChild()->duplicateTree(), conditionalNode->getSecondChild()->duplicateTree(), _exitGotoTarget);
             }
 
          if (duplicateComparisonNode->getFirstChild()->getOpCodeValue() == TR::instanceof)

compiler/optimizer/RegisterCandidate.hpp

@@ -134,7 +134,7 @@ class TR_RegisterCandidate : public TR_Link<TR_RegisterCandidate>
      }
 
      bool find(uint32_t block) {
-       return _candidateBlocks.get(block);
+       return _candidateBlocks.get(block) != 0;
      }
      uint32_t getNumberOfLoadsAndStores(uint32_t block) {
        if (_candidateBlocks.get(block))

compiler/optimizer/Structure.cpp

@@ -3374,7 +3374,7 @@ void TR_RegionStructure::resetInvariance()
 bool TR_RegionStructure::isExprInvariant(TR::Node *expr, bool usePrecomputed)
    {
    if (_invariantExpressions && usePrecomputed)
-      return _invariantExpressions->get(expr->getGlobalIndex());
+      return _invariantExpressions->get(expr->getGlobalIndex()) != 0;
 
    return isExprTreeInvariant(expr);
    }
@@ -3393,7 +3393,7 @@ bool TR_RegionStructure::isExprTreeInvariant(TR::Node *expr)
    {
    if(!_invariantSymbols)
       computeInvariantSymbols();
-   return _invariantSymbols->get(symRef->getReferenceNumber());
+   return _invariantSymbols->get(symRef->getReferenceNumber()) != 0;
    }
 
 bool TR_RegionStructure::isSubtreeInvariant(TR::Node *node, vcount_t visitCount)

compiler/optimizer/UseDefInfo.cpp

@@ -413,7 +413,7 @@ bool TR_UseDefInfo::_runReachingDefinitions(TR_ReachingDefinitions& reachingDefi
 
    reachingDefinitions.perform();
 
-   bool succeeded = reachingDefinitions._blockAnalysisInfo;
+   bool succeeded = reachingDefinitions._blockAnalysisInfo != NULL;
    if (!succeeded)
       {
       invalidateUseDefInfo();
@@ -639,7 +639,7 @@ void TR_UseDefInfo::findTrivialSymbolsToExclude(TR::Node *node, TR::TreeTop *tre
 bool TR_UseDefInfo::isTrivialUseDefNode(TR::Node *node, AuxiliaryData &aux)
    {
    if (aux._doneTrivialNode.get(node->getGlobalIndex()))
-      return aux._isTrivialNode.get(node->getGlobalIndex());
+      return aux._isTrivialNode.get(node->getGlobalIndex()) != 0;
 
    bool result = isTrivialUseDefNodeImpl(node, aux);
    aux._doneTrivialNode.set(node->getGlobalIndex());

compiler/optimizer/VPHandlers.cpp

@@ -7560,7 +7560,7 @@ TR::Node *constrainIand(OMR::ValuePropagation *vp, TR::Node *node)
    if (rhs && rhs->asIntConst())
       {
       int32_t mask = rhs->asIntConst()->getInt();
-      signBitsMaskedOff = leadingZeroes(mask);
+      signBitsMaskedOff = leadingZeroes(mask) != 0;
 
       // take opportunity to remove if unneeded
       if(255 == mask && lhs) // loading from byte
@@ -8964,7 +8964,7 @@ static TR::Node *constrainIfcmpeqne(OMR::ValuePropagation *vp, TR::Node *node, b
             {
             TR::ILOpCode lhsCmp = lhsChild->getOpCode();
             TR::ILOpCode newIfOp = lhsCmp.convertCmpToIfCmp();
-            if (branchOnEqual != bool(rhsConst))
+            if (branchOnEqual != (rhsConst != 0))
                newIfOp = newIfOp.getOpCodeForReverseBranch();
 
             if (performTransformation(vp->comp(),

compiler/ras/DebugCounter.cpp

@@ -301,7 +301,7 @@ TR::DebugCounterBase::initializeReloData(TR::Compilation *comp, int32_t delta, i
       {
       _reloData = new (comp->trPersistentMemory()) TR::DebugCounterReloData(delta, fidelity, staticDelta);
       }
-   return _reloData;
+   return _reloData != NULL;
    }
 
 void

compiler/ras/LimitFile.cpp

@@ -1166,7 +1166,7 @@ TR_Debug::methodSigCanBeFound(const char *methodSig, TR::CompilationFilters * fi
          filter = filter->findRegex(methodSig);
       }
 
-   bool excluded = filters->defaultExclude();
+   bool excluded = filters->defaultExclude() != 0;
    if (filter)
       {
       switch (filter->getFilterType())

compiler/x/codegen/BinaryCommutativeAnalyser.cpp

@@ -887,7 +887,7 @@ TR::Register *TR_X86BinaryCommutativeAnalyser::integerAddAnalyserImpl(TR::Node
          }
 
       targetRegister = tempReg;
-      bool is64Bit = TR::InstOpCode(regRegOpCode).hasLongSource();
+      bool is64Bit = TR::InstOpCode(regRegOpCode).hasLongSource() != 0;
 
       // if eflags are required then we cannot use LEA as it doesn't set or use them
       if (needsEflags || (carry != 0))

compiler/x/codegen/HelperCallSnippet.cpp

@@ -355,7 +355,7 @@ TR_Debug::printBody(TR::FILE *pOutFile, TR::X86HelperCallSnippet  * snippet, uin
          {
          uint32_t pushLength;
 
-         bool useDedicatedFrameReg = _comp->cg()->getLinkage()->getProperties().getAlwaysDedicateFramePointerRegister();
+         bool useDedicatedFrameReg = _comp->cg()->getLinkage()->getProperties().getAlwaysDedicateFramePointerRegister() != 0;
          if (snippet->getOffset() >= -128 && snippet->getOffset() <= 127)
             pushLength = (useDedicatedFrameReg ? 3 : 4);
          else
@@ -436,7 +436,7 @@ uint32_t TR::X86HelperCallSnippet::getLength(int32_t estimatedSnippetStart)
 
       if (_offset != -1)
          {
-         bool useDedicatedFrameReg = cg()->getLinkage()->getProperties().getAlwaysDedicateFramePointerRegister();
+         bool useDedicatedFrameReg = cg()->getLinkage()->getProperties().getAlwaysDedicateFramePointerRegister() != 0;
          if (_offset >= -128 && _offset <= 127)
             length += (useDedicatedFrameReg ? 3 : 4);
          else

compiler/x/codegen/OMRCodeGenerator.cpp

@@ -375,7 +375,7 @@ OMR::X86::CodeGenerator::initializeX86(TR::Compilation *comp)
          {
          self()->setSupportsArraySet();
          }
-      static bool disableX86TRTO = (bool)feGetEnv("TR_disableX86TRTO");
+      static bool disableX86TRTO = feGetEnv("TR_disableX86TRTO") != NULL;
       if (!disableX86TRTO)
          {
          TR_ASSERT_FATAL(comp->compileRelocatableCode() || comp->isOutOfProcessCompilation() || comp->target().cpu.supportsFeature(OMR_FEATURE_X86_SSE4_1) == self()->getX86ProcessorInfo().supportsSSE4_1(), "supportsSSE4_1() failed\n");
@@ -384,7 +384,7 @@ OMR::X86::CodeGenerator::initializeX86(TR::Compilation *comp)
             self()->setSupportsArrayTranslateTRTO();
             }
          }
-      static bool disableX86TROT = (bool)feGetEnv("TR_disableX86TROT");
+      static bool disableX86TROT = feGetEnv("TR_disableX86TROT") != NULL;
       if (!disableX86TROT)
          {
          TR_ASSERT_FATAL(comp->compileRelocatableCode() || comp->isOutOfProcessCompilation() || comp->target().cpu.supportsFeature(OMR_FEATURE_X86_SSE4_1) == self()->getX86ProcessorInfo().supportsSSE4_1(), "supportsSSE4_1() failed\n");

compiler/x/codegen/OMRInstruction.hpp

@@ -97,7 +97,7 @@ class OMR_EXTENSIBLE Instruction : public OMR::Instruction
    TR::InstOpCode::Mnemonic getOpCodeValue() { return _opcode.getOpCodeValue(); }
    TR::InstOpCode::Mnemonic setOpCodeValue(TR::InstOpCode::Mnemonic op) { return _opcode.setOpCodeValue(op); }
 
-   virtual bool isBranchOp() {return _opcode.isBranchOp();}
+   virtual bool isBranchOp() {return _opcode.isBranchOp() != 0;}
    virtual bool isLabel();
    virtual bool isRegRegMove();
    virtual bool isPatchBarrier();

compiler/x/codegen/OMRTreeEvaluator.cpp

@@ -2193,8 +2193,8 @@ TR::Register *OMR::X86::TreeEvaluator::arraycopyEvaluator(TR::Node *node, TR::Co
 
    TR::DataType dt = node->getArrayCopyElementType();
    uint32_t elementSize = 1;
-   static bool useREPMOVSW = feGetEnv("TR_UseREPMOVSWForArrayCopy");
-   static bool forceByteArrayElementCopy = feGetEnv("TR_ForceByteArrayElementCopy");
+   static bool useREPMOVSW = feGetEnv("TR_UseREPMOVSWForArrayCopy") != NULL;
+   static bool forceByteArrayElementCopy = feGetEnv("TR_ForceByteArrayElementCopy") != NULL;
    if (!forceByteArrayElementCopy)
       {
       if (node->isReferenceArrayCopy() || dt == TR::Address)
@@ -2203,8 +2203,8 @@ TR::Register *OMR::X86::TreeEvaluator::arraycopyEvaluator(TR::Node *node, TR::Co
          elementSize = TR::Symbol::convertTypeToSize(dt);
       }
 
-   static bool optimizeForConstantLengthArrayCopy = feGetEnv("TR_OptimizeForConstantLengthArrayCopy");
-   static bool ignoreDirectionForConstantLengthArrayCopy = feGetEnv("TR_IgnoreDirectionForConstantLengthArrayCopy");
+   static bool optimizeForConstantLengthArrayCopy = feGetEnv("TR_OptimizeForConstantLengthArrayCopy") != NULL;
+   static bool ignoreDirectionForConstantLengthArrayCopy = feGetEnv("TR_IgnoreDirectionForConstantLengthArrayCopy") != NULL;
 #define shortConstArrayWithDirThreshold 256
 #define shortConstArrayWithoutDirThreshold  16*4
    bool isShortConstArrayWithDirection = false;

compiler/x/codegen/SIMDTreeEvaluator.cpp

@@ -42,7 +42,7 @@ static TR::MemoryReference* ConvertToPatchableMemoryReference(TR::MemoryReferenc
       // Hence, the unresolved memory reference must be evaluated into a register first.
       //
       TR::Register* tempReg = cg->allocateRegister();
-      generateRegMemInstruction(LEARegMem(cg), node, tempReg, mr, cg);
+      generateRegMemInstruction(LEARegMem(), node, tempReg, mr, cg);
       mr = generateX86MemoryReference(tempReg, 0, cg);
       cg->stopUsingRegister(tempReg);
       }

compiler/x/codegen/SubtractAnalyser.cpp

@@ -175,7 +175,7 @@ TR::Register* TR_X86SubtractAnalyser::integerSubtractAnalyserImpl(TR::Node     *
                // Don't do this though if condition codes are needed.  The sequence
                // depends on the carry flag being valid as if a sub was done.
                //
-               bool nodeIs64Bit = TR::InstOpCode(regRegOpCode).hasLongSource();
+               bool nodeIs64Bit = TR::InstOpCode(regRegOpCode).hasLongSource() != 0;
                generateRegInstruction(NEGReg(nodeIs64Bit), secondChild, secondRegister, _cg);
                thirdReg       = secondRegister;
                secondRegister = firstRegister;