reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

lib/CodeGen/AtomicExpandPass.cpp
  538     return Builder.CreateNot(Builder.CreateAnd(Loaded, Inc), "new");
  679   Ret.Inv_Mask = Builder.CreateNot(Ret.Mask, "Inv_Mask");
lib/CodeGen/IntrinsicLowering.cpp
  207   V = Builder.CreateNot(V);
  300     Value *NotSrc = Builder.CreateNot(Src);
lib/IR/AutoUpgrade.cpp
 1868       LHS = Builder.CreateNot(LHS);
 1884       LHS = Builder.CreateNot(LHS);
 1889       Rep = Builder.CreateNot(Rep);
 2205       Value *NotSel = Builder.CreateNot(Sel);
 2693       Rep = Builder.CreateNot(Builder.CreateBitCast(CI->getArgOperand(0), ITy));
lib/IR/Core.cpp
 3415   return wrap(unwrap(B)->CreateNot(unwrap(V), Name));
lib/Target/AMDGPU/AMDGPUPrintfRuntimeBinding.cpp
  365             Builder.CreateSExt(Builder.CreateNot(cmp), I32Ty, "printf_res");
lib/Transforms/InstCombine/InstCombineAddSub.cpp
  887     return BinaryOperator::CreateAdd(Builder.CreateNot(Y), X);
  933       return new ZExtInst(Builder.CreateNot(X), Ty);
  940       Value *NotX = Builder.CreateNot(X);
 1717     return BinaryOperator::CreateAdd(Builder.CreateNot(Op1), X);
 1721     return BinaryOperator::CreateAdd(Builder.CreateNot(X), Op0);
 1881           Y, Builder.CreateNot(Op1, Op1->getName() + ".not"));
 1896                                   Builder.CreateNot(Y, Y->getName() + ".not"));
 1964         Value *Not = Builder.CreateNot(MinMax);
lib/Transforms/InstCombine/InstCombineAndOrXor.cpp
 1880       return BinaryOperator::CreateAnd(Op0, Builder.CreateNot(B));
 1883       return BinaryOperator::CreateAnd(Op1, Builder.CreateNot(B));
 1889           return BinaryOperator::CreateAnd(Op0, Builder.CreateNot(C));
 1895           return BinaryOperator::CreateAnd(Op1, Builder.CreateNot(C));
 2614       Value *Not = Builder.CreateNot(B, B->getName() + ".not");
 2618       Value *Not = Builder.CreateNot(A, A->getName() + ".not");
 2632         Value *Not = Builder.CreateNot(NotOp, NotOp->getName() + ".not");
 2879           Value *NotY = Builder.CreateNot(Y, Y->getName() + ".not");
 2929     Value *NotC = Builder.CreateNot(C);
 2959   Value *NotX = Builder.CreateNot(X, X->getName() + ".not");
 3011     Value *NotY = Builder.CreateNot(Y, Y->getName() + ".not");
 3017     Value *NotY = Builder.CreateNot(Y, Y->getName() + ".not");
 3036         Value *NotX = Builder.CreateNot(NotVal->getOperand(0), "notlhs");
 3037         Value *NotY = Builder.CreateNot(NotVal->getOperand(1), "notrhs");
 3047         return BinaryOperator::CreateAdd(Builder.CreateNot(X), Y);
 3160     return BinaryOperator::CreateAnd(X, Builder.CreateNot(Op0));
 3164     return BinaryOperator::CreateAnd(X, Builder.CreateNot(Op1));
 3169     return BinaryOperator::CreateAnd(Op0, Builder.CreateNot(X));
 3177     return BinaryOperator::CreateAnd(Op1, Builder.CreateNot(X));
 3184           Builder.CreateAnd(Builder.CreateNot(A), C), B);
 3190           Builder.CreateAnd(Builder.CreateNot(B), C), A);
 3258         Value *NotY = Builder.CreateNot(RHS);
 3266         Value *NotX = Builder.CreateNot(LHS);
 3275         Value *NotLHS = Builder.CreateNot(LHS);
 3276         Value *NotRHS = Builder.CreateNot(RHS);
lib/Transforms/InstCombine/InstCombineCalls.cpp
 3944                          Builder.CreateNot(A), II->getName());
 3946                          Builder.CreateNot(B), II->getName());
lib/Transforms/InstCombine/InstCombineCasts.cpp
 1243       In = Builder.CreateNot(In, In->getName() + ".not");
lib/Transforms/InstCombine/InstCombineCompares.cpp
 3658     Res = Builder.CreateNot(Res, "umul.not.ov");
 3684     return new ICmpInst(Pred, Builder.CreateNot(Op1), X);
 3688     return new ICmpInst(Pred, X, Builder.CreateNot(Op0));
 5272     return BinaryOperator::CreateAnd(Builder.CreateNot(A), B);
 5280     return BinaryOperator::CreateAnd(Builder.CreateNot(B), A);
 5288     return BinaryOperator::CreateOr(Builder.CreateNot(A), B);
 5296     return BinaryOperator::CreateOr(Builder.CreateNot(B), A);
lib/Transforms/InstCombine/InstCombineSelect.cpp
 1647       NotA = Builder.CreateNot(A);
 1649       NotB = Builder.CreateNot(B);
 1651       NotC = Builder.CreateNot(C);
 1655     Value *NewOuter = Builder.CreateNot(
 2247       Value *NotCond = Builder.CreateNot(CondVal, "not." + CondVal->getName());
 2256       Value *NotCond = Builder.CreateNot(CondVal, "not." + CondVal->getName());
 2293       Value *NotCond = Builder.CreateNot(CondVal, "not." + CondVal->getName());
 2299       Value *NotCond = Builder.CreateNot(CondVal, "not." + CondVal->getName());
 2478           Value *B = Builder.CreateNot(Y);
lib/Transforms/Instrumentation/MemorySanitizer.cpp
 1970     Value *V1 = IRB.CreateNot(I.getOperand(0));
 1971     Value *V2 = IRB.CreateNot(I.getOperand(1));
 2254         IRB.CreateOr(IRB.CreateAnd(A, IRB.CreateNot(SaOtherBits)), SaSignBit);
 2257       return IRB.CreateAnd(A, IRB.CreateNot(Sa));
 2271         IRB.CreateOr(IRB.CreateAnd(A, IRB.CreateNot(SaSignBit)), SaOtherBits);
lib/Transforms/Instrumentation/PoisonChecking.cpp
  253   CreateAssert(B, B.CreateNot(Cond));
lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp
 1292                              : B.CreateNot(TakeBackedgeLoopCond);
lib/Transforms/Scalar/LowerAtomic.cpp
   65     Res = Builder.CreateNot(Builder.CreateAnd(Orig, Val));
lib/Transforms/Utils/SimplifyCFG.cpp
 2717             Builder.CreateNot(NewCond, PBI->getCondition()->getName() + ".not");
 2824               Builder.CreateNot(PBI->getCondition(), "not.cond"));
 2839                 Builder.CreateNot(PBI->getCondition(), "not.cond"));
 3060   Value *PPred = PStore->getParent() == PTB ? PCond : QB.CreateNot(PCond);
 3061   Value *QPred = QStore->getParent() == QTB ? QCond : QB.CreateNot(QCond);
 3064     PPred = QB.CreateNot(PPred);
 3066     QPred = QB.CreateNot(QPred);
 3370     PBICond = Builder.CreateNot(PBICond, PBICond->getName() + ".not");
 3374     BICond = Builder.CreateNot(BICond, BICond->getName() + ".not");
 4234           Builder.CreateAssumption(Builder.CreateNot(Cond));
lib/Transforms/Vectorize/VPlan.cpp
  307     Value *V = Builder.CreateNot(A);
tools/clang/lib/CodeGen/CGAtomic.cpp
  649     Result = CGF.Builder.CreateNot(Result);
 1190         ResVal = Builder.CreateNot(ResVal);
tools/clang/lib/CodeGen/CGBuiltin.cpp
  786       Mask = CGF.Builder.CreateNot(Mask);
  803       NewByte = CGF.Builder.CreateAnd(OldByte, CGF.Builder.CreateNot(Mask));
 1907     Value *Inverse = Builder.CreateNot(ArgValue, "not");
 6977     Value *EltsFromTbl = Builder.CreateAnd(Builder.CreateNot(CmpRes), TblRes);
 6996     Value *EltsFromTbl = Builder.CreateAnd(Builder.CreateNot(CmpRes), TblRes);
 8344     Ops[2] = Builder.CreateAnd(Builder.CreateNot(Ops[0]), Ops[2], "vbsl");
 9591     LHS = CGF.Builder.CreateNot(LHS);
11583     return Builder.CreateBitCast(Builder.CreateNot(Res),
tools/clang/lib/CodeGen/CGExprScalar.cpp
 2607   return Builder.CreateNot(Op, "neg");
 2629   BoolVal = Builder.CreateNot(BoolVal, "lnot");
 3099       llvm::Value *NotOverflow = Builder.CreateNot(overflow);
 3104       CGF.EmitTrapCheck(Builder.CreateNot(overflow));
 4208     llvm::Value *tmp2 = Builder.CreateNot(tmp);
 4728     auto *NoOffsetOverflow = Builder.CreateNot(EvaluatedGEP.OffsetOverflows);
tools/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp
  690                        Bld.CreateNot(Mask), "master_tid");
tools/polly/lib/CodeGen/IslNodeBuilder.cpp
 1267   Value *OverflowHappened = Builder.CreateNot(ExprBuilder.getOverflowState(),
 1595       Builder.CreateNot(ExprBuilder.getOverflowState(), "polly.rtc.overflown");