Rename NonNegInstruction -> PossiblyNonNegInst

Author: nikic

llvm/include/llvm/Bitcode/LLVMBitCodes.h

@@ -505,8 +505,8 @@ enum FastMathMap {
   AllowReassoc    = (1 << 7)
 };
 
-/// Flags for serializing NonNegInstruction's SubclassOptionalData contents.
-enum NonNegInstructionOptionalFlags { NNI_NON_NEG = 0 };
+/// Flags for serializing PossiblyNonNegInst's SubclassOptionalData contents.
+enum PossiblyNonNegInstOptionalFlags { PNNI_NON_NEG = 0 };
 
 /// PossiblyExactOperatorOptionalFlags - Flags for serializing
 /// PossiblyExactOperator's SubclassOptionalData contents.

llvm/include/llvm/IR/InstrTypes.h

@@ -693,7 +693,7 @@ class CastInst : public UnaryInstruction {
 };
 
 /// Instruction that can have a nneg flag (only zext).
-class NonNegInstruction : public CastInst {
+class PossiblyNonNegInst : public CastInst {
 public:
   enum { NonNeg = (1 << 0) };
 

llvm/lib/AsmParser/LLParser.cpp

@@ -6386,11 +6386,10 @@ int LLParser::parseInstruction(Instruction *&Inst, BasicBlock *BB,
   case lltok::kw_zext: {
     bool NonNeg = EatIfPresent(lltok::kw_nneg);
     bool Res = parseCast(Inst, PFS, KeywordVal);
+    if (Res != 0)
+      return Res;
     if (NonNeg)
       Inst->setNonNeg();
-    if (Res != 0) {
-      return Res;
-    }
     return 0;
   }
   case lltok::kw_trunc:

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

@@ -4893,13 +4893,12 @@ Error BitcodeReader::parseFunctionBody(Function *F) {
         }
       } else {
         auto CastOp = (Instruction::CastOps)Opc;
-
         if (!CastInst::castIsValid(CastOp, Op, ResTy))
           return error("Invalid cast");
         I = CastInst::Create(CastOp, Op, ResTy);
       }
-      if (OpNum < Record.size() && isa<NonNegInstruction>(I) &&
-          (Record[OpNum] & (1 << bitc::NNI_NON_NEG)))
+      if (OpNum < Record.size() && isa<PossiblyNonNegInst>(I) &&
+          (Record[OpNum] & (1 << bitc::PNNI_NON_NEG)))
         I->setNonNeg(true);
       InstructionList.push_back(I);
       break;

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

@@ -1550,9 +1550,9 @@ static uint64_t getOptimizationFlags(const Value *V) {
       Flags |= bitc::AllowContract;
     if (FPMO->hasApproxFunc())
       Flags |= bitc::ApproxFunc;
-  } else if (const auto *NNI = dyn_cast<NonNegInstruction>(V)) {
+  } else if (const auto *NNI = dyn_cast<PossiblyNonNegInst>(V)) {
     if (NNI->hasNonNeg())
-      Flags |= 1 << bitc::NNI_NON_NEG;
+      Flags |= 1 << bitc::PNNI_NON_NEG;
   }
 
   return Flags;

llvm/lib/IR/AsmWriter.cpp

@@ -1348,7 +1348,7 @@ static void WriteOptimizationInfo(raw_ostream &Out, const User *U) {
   } else if (const GEPOperator *GEP = dyn_cast<GEPOperator>(U)) {
     if (GEP->isInBounds())
       Out << " inbounds";
-  } else if (const auto *NNI = dyn_cast<NonNegInstruction>(U)) {
+  } else if (const auto *NNI = dyn_cast<PossiblyNonNegInst>(U)) {
     if (NNI->hasNonNeg())
       Out << " nneg";
   }

llvm/lib/IR/Instruction.cpp

@@ -172,9 +172,9 @@ void Instruction::setIsExact(bool b) {
 }
 
 void Instruction::setNonNeg(bool b) {
-  assert(isa<NonNegInstruction>(this) && "Must be zext");
-  SubclassOptionalData = (SubclassOptionalData & ~NonNegInstruction::NonNeg) |
-                         (b * NonNegInstruction::NonNeg);
+  assert(isa<PossiblyNonNegInst>(this) && "Must be zext");
+  SubclassOptionalData = (SubclassOptionalData & ~PossiblyNonNegInst::NonNeg) |
+                         (b * PossiblyNonNegInst::NonNeg);
 }
 
 bool Instruction::hasNoUnsignedWrap() const {
@@ -186,8 +186,8 @@ bool Instruction::hasNoSignedWrap() const {
 }
 
 bool Instruction::hasNonNeg() const {
-  assert(isa<NonNegInstruction>(this) && "Must be zext");
-  return (SubclassOptionalData & NonNegInstruction::NonNeg) != 0;
+  assert(isa<PossiblyNonNegInst>(this) && "Must be zext");
+  return (SubclassOptionalData & PossiblyNonNegInst::NonNeg) != 0;
 }
 
 bool Instruction::hasPoisonGeneratingFlags() const {
@@ -395,8 +395,8 @@ void Instruction::copyIRFlags(const Value *V, bool IncludeWrapFlags) {
     if (auto *DestGEP = dyn_cast<GetElementPtrInst>(this))
       DestGEP->setIsInBounds(SrcGEP->isInBounds() || DestGEP->isInBounds());
 
-  if (auto *NNI = dyn_cast<NonNegInstruction>(V))
-    if (isa<NonNegInstruction>(this))
+  if (auto *NNI = dyn_cast<PossiblyNonNegInst>(V))
+    if (isa<PossiblyNonNegInst>(this))
       setNonNeg(NNI->hasNonNeg());
 }
 
@@ -424,8 +424,8 @@ void Instruction::andIRFlags(const Value *V) {
     if (auto *DestGEP = dyn_cast<GetElementPtrInst>(this))
       DestGEP->setIsInBounds(SrcGEP->isInBounds() && DestGEP->isInBounds());
 
-  if (auto *NNI = dyn_cast<NonNegInstruction>(V))
-    if (isa<NonNegInstruction>(this))
+  if (auto *NNI = dyn_cast<PossiblyNonNegInst>(V))
+    if (isa<PossiblyNonNegInst>(this))
       setNonNeg(hasNonNeg() && NNI->hasNonNeg());
 }
 

llvm/lib/IR/Operator.cpp

@@ -38,7 +38,7 @@ bool Operator::hasPoisonGeneratingFlags() const {
     return GEP->isInBounds() || GEP->getInRangeIndex() != std::nullopt;
   }
   case Instruction::ZExt:
-    if (auto *NNI = dyn_cast<NonNegInstruction>(this))
+    if (auto *NNI = dyn_cast<PossiblyNonNegInst>(this))
       return NNI->hasNonNeg();
     return false;
   default: