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

References

gen/tools/clang/include/clang/Basic/arm_mve_builtin_cg.inc
  178   Value *Val11 = Builder.CreateAnd(Val7, Val10);
  228   Value *Val15 = Builder.CreateAnd(Val11, Val14);
  246   Value *Val12 = Builder.CreateAnd(Val8, Val11);
  261   Value *Val8 = Builder.CreateAnd(Val4, Val7);
include/llvm/IR/IRBuilder.h
 1294     return CreateAnd(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
 1298     return CreateAnd(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
 1305       Accum = CreateAnd(Accum, Ops[i]);
 2621     Value *MaskedPtr = CreateAnd(PtrIntValue, Mask, "maskedptr");
lib/Analysis/LoopAccessAnalysis.cpp
 2250     Value *IsConflict = ChkBuilder.CreateAnd(Cmp0, Cmp1, "found.conflict");
lib/Analysis/ScalarEvolutionExpander.cpp
 2325     BackedgeCheck = Builder.CreateAnd(
lib/CodeGen/AtomicExpandPass.cpp
  536     return Builder.CreateAnd(Loaded, Inc, "new");
  538     return Builder.CreateNot(Builder.CreateAnd(Loaded, Inc), "new");
  696     Value *Loaded_MaskOut = Builder.CreateAnd(Loaded, PMV.Inv_Mask);
  709     Value *NewVal_Masked = Builder.CreateAnd(NewVal, PMV.Mask);
  710     Value *Loaded_MaskOut = Builder.CreateAnd(Loaded, PMV.Inv_Mask);
  726     Value *Loaded_MaskOut = Builder.CreateAnd(Loaded, PMV.Inv_Mask);
  880   Value *InitLoaded_MaskOut = Builder.CreateAnd(InitLoaded, PMV.Inv_Mask);
  915   Value *OldVal_MaskOut = Builder.CreateAnd(OldVal, PMV.Inv_Mask);
  995       CmpVal_Shifted, Builder.CreateAnd(OldVal, PMV.Mask), "Success");
lib/CodeGen/CodeGenPrepare.cpp
 5801       Builder.CreateAnd(Load, ConstantInt::get(Ctx, DemandBits)));
lib/CodeGen/IntrinsicLowering.cpp
   88     Tmp3 = Builder.CreateAnd(Tmp3,
   91     Tmp2 = Builder.CreateAnd(Tmp2,
  119     Tmp7 = Builder.CreateAnd(Tmp7,
  123     Tmp6 = Builder.CreateAnd(Tmp6,
  127     Tmp5 = Builder.CreateAnd(Tmp5,
  131     Tmp4 = Builder.CreateAnd(Tmp4,
  135     Tmp3 = Builder.CreateAnd(Tmp3,
  139     Tmp2 = Builder.CreateAnd(Tmp2,
  177       Value *LHS = Builder.CreateAnd(PartValue, MaskCst, "cppop.and1");
  181       Value *RHS = Builder.CreateAnd(VShift, MaskCst, "cppop.and2");
  304     Src = LowerCTPOP(Context, Builder.CreateAnd(NotSrc, SrcM1), CI);
lib/CodeGen/SafeStack.cpp
  544         IRB.CreateAnd(IRB.CreatePtrToInt(BasePointer, IntPtrTy),
  666         IRB.CreateAnd(SP, ConstantInt::get(IntPtrTy, ~uint64_t(Align - 1))),
lib/CodeGen/ScalarizeMaskedMemIntrin.cpp
  195       Predicate = Builder.CreateICmpNE(Builder.CreateAnd(SclrMask, Mask),
  326       Predicate = Builder.CreateICmpNE(Builder.CreateAnd(SclrMask, Mask),
  445       Predicate = Builder.CreateICmpNE(Builder.CreateAnd(SclrMask, Mask),
  566       Predicate = Builder.CreateICmpNE(Builder.CreateAnd(SclrMask, Mask),
  656       Predicate = Builder.CreateICmpNE(Builder.CreateAnd(SclrMask, Mask),
  762       Predicate = Builder.CreateICmpNE(Builder.CreateAnd(SclrMask, Mask),
lib/IR/AutoUpgrade.cpp
 1296     LHS = Builder.CreateAnd(LHS, Mask);
 1297     RHS = Builder.CreateAnd(RHS, Mask);
 1315       Vec = Builder.CreateAnd(Vec, getX86MaskVec(Builder, Mask, NumElts));
 1753       Value *Mask = Builder.CreateAnd(CI->getArgOperand(2), Builder.getInt8(1));
 1828       Rep = Builder.CreateAnd(Op0, Op1);
 1863       Rep = Builder.CreateAnd(LHS, RHS);
 1869       Rep = Builder.CreateAnd(LHS, RHS);
 2206       Value *Sel0 = Builder.CreateAnd(CI->getArgOperand(0), Sel);
 2207       Value *Sel1 = Builder.CreateAnd(CI->getArgOperand(1), NotSel);
 2684       Rep = Builder.CreateAnd(Builder.CreateBitCast(CI->getArgOperand(0), ITy),
 2694       Rep = Builder.CreateAnd(Rep,
lib/IR/Core.cpp
 3376   return wrap(unwrap(B)->CreateAnd(unwrap(LHS), unwrap(RHS), Name));
lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp
  733     Res = Builder.CreateAnd(Res, TruncMask);
  845   Value *Tmp1 = Builder.CreateAnd(Remainder_GE_Den, Remainder_GE_Zero);
lib/Target/AMDGPU/AMDGPULibCalls.cpp
 1142     sign = B.CreateAnd(B.CreateBitCast(opr0, nTy), sign, "__pow_sign");
lib/Target/ARM/ARMCodeGenPrepare.cpp
  725     Value *Masked = Builder.CreateAnd(Trunc->getOperand(0), Mask);
lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp
 1038     Value *And = IRBuilder<>(In).CreateAnd(T->getOperand(0), Mask);
 1538     P = B.CreateAnd(P, BMI);
 1552       P = B.CreateAnd(P, BMI);
 1622       return B.CreateAnd(B.CreateXor(And0->getOperand(0), And1->getOperand(0)),
 1757       return B.CreateAnd(B.CreateXor(And0->getOperand(0), And1), C0);
 2216       Value *CmpBoth = Builder.CreateAnd(Cond, CmpB);
lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp
  557   Value *Cmp1 = IRB.CreateAnd(ThrewCmp, ThrewValueCmp, "cmp1");
lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp
  245   Value *And = Builder.CreateAnd(MOps.Root, Mask);
lib/Transforms/IPO/LowerTypeTests.cpp
  583       B.CreateAnd(BitOffset, ConstantInt::get(BitsType, BitWidth - 1));
  585   Value *MaskedBits = B.CreateAnd(Bits, BitMask);
  682         B.CreateAnd(Byte, ConstantExpr::getPtrToInt(TIL.BitMask, Int8Ty));
lib/Transforms/IPO/WholeProgramDevirt.cpp
 1376       Value *BitsAndBit = B.CreateAnd(Bits, Bit);
lib/Transforms/InstCombine/InstCombineAddSub.cpp
 1873       return BinaryOperator::CreateNeg(Builder.CreateAnd(A, B));
lib/Transforms/InstCombine/InstCombineAndOrXor.cpp
  150             Value *NewAnd = Builder.CreateAnd(X, AndRHS);
  513     Value *NewAnd = Builder.CreateAnd(A, NewMask);
  652     Value *NewAnd = Builder.CreateAnd(A, NewOr);
  663     Value *NewAnd = Builder.CreateAnd(A, NewOr);
  669     Value *NewAnd1 = Builder.CreateAnd(B, D);
  670     Value *NewAnd2 = Builder.CreateAnd(A, NewAnd1);
  741     Value *NewAnd = Builder.CreateAnd(A, NewOr1);
  889       Value *Masked = Builder.CreateAnd(A, Mask);
 1717   return new ZExtInst(Builder.CreateAnd(NewBO, X), Ty);
 1766       Value *And = Builder.CreateAnd(X, Op1);
 1780       Value *And = Builder.CreateAnd(X, ConstantInt::get(I.getType(),
 1795         Value *NewRHS = Builder.CreateAnd(Y, Op1, Y->getName() + ".masked");
 1801         Value *NewLHS = Builder.CreateAnd(X, Op1, X->getName() + ".masked");
 1839             auto *And = Builder.CreateAnd(BinOp, TruncC2);
 1927           return replaceInstUsesWith(I, Builder.CreateAnd(Res, Y));
 1930           return replaceInstUsesWith(I, Builder.CreateAnd(Res, X));
 1935           return replaceInstUsesWith(I, Builder.CreateAnd(Res, Y));
 1938           return replaceInstUsesWith(I, Builder.CreateAnd(Res, X));
 2248           Value *NewAnd = Builder.CreateAnd(LAddOpnd, MaskC);
 2540           return BinaryOperator::CreateOr(Builder.CreateAnd(X, C1), B);
 2543           return BinaryOperator::CreateOr(Builder.CreateAnd(X, C2), A);
 2547           return BinaryOperator::CreateXor(Builder.CreateAnd(X, C1), B);
 2550           return BinaryOperator::CreateXor(Builder.CreateAnd(X, C2), A);
 2590     return BinaryOperator::CreateOr(Op1, Builder.CreateAnd(A, C));
 2885         return Builder.CreateAnd(LHS, RHS);
 2921     Value *NewA = Builder.CreateAnd(D, NotM);
 2928     Value *LHS = Builder.CreateAnd(X, C);
 2930     Value *RHS = Builder.CreateAnd(B, NotC);
 3080       Value *And = Builder.CreateAnd(X, ConstantExpr::getNot(C2));
 3184           Builder.CreateAnd(Builder.CreateNot(A), C), B);
 3190           Builder.CreateAnd(Builder.CreateNot(B), C), A);
 3205     return BinaryOperator::CreateNot(Builder.CreateAnd(A, B));
lib/Transforms/InstCombine/InstCombineCalls.cpp
 4058       II->setArgOperand(0, Builder.CreateAnd(CurrCond, NextCond));
lib/Transforms/InstCombine/InstCombineCasts.cpp
  731       Value *And = Builder.CreateAnd(Src, ConstantInt::get(SrcTy, 1));
  742       Value *And = Builder.CreateAnd(X, ConstantInt::get(SrcTy, MaskC));
  749       Value *And = Builder.CreateAnd(X, ConstantInt::get(SrcTy, MaskC));
  945             Result = Builder.CreateAnd(Result,
 1157       Value *And = Builder.CreateAnd(A, AndConst, CSrc->getName() + ".mask");
 1217     return BinaryOperator::CreateXor(Builder.CreateAnd(X, ZC), ZC);
lib/Transforms/InstCombine/InstCombineCompares.cpp
  407       V = Builder.CreateAnd(ConstantInt::get(Ty, 1), V);
 1355   Value *Masked = Builder.CreateAnd(X, Mask);
 1707     Value *NewAnd = Builder.CreateAnd(Shift->getOperand(0), NewShift);
 1775       Value *NewAnd = Builder.CreateAnd(W, ZextC2, And->getName());
 1814         Value *NewAnd = Builder.CreateAnd(A, NewOr, And->getName());
 2104     Value *And = Builder.CreateAnd(X, Mask, Shl->getName() + ".mask");
 2116     Value *And = Builder.CreateAnd(X, Mask, Shl->getName() + ".mask");
 2249     Value *And = Builder.CreateAnd(X, Mask, Shr->getName() + ".mask");
 2280   Value *And = Builder.CreateAnd(SRem->getOperand(0), MaskC);
 2984       Value *And = Builder.CreateAnd(BOp0, NotBOC);
 3591   Value *T1 = Builder.CreateAnd(T0, Y);
 3969           Value *And1 = Builder.CreateAnd(BO0->getOperand(0), Mask);
 3970           Value *And2 = Builder.CreateAnd(BO1->getOperand(0), Mask);
 4187       Op1 = Builder.CreateAnd(Op1, Z);
 4232       Value *And = Builder.CreateAnd(Xor, Builder.getInt(AndVal),
 4257       Value *Mask = Builder.CreateAnd(A, Builder.getInt(MaskV));
 5523       return new ICmpInst(I.getInversePredicate(), Builder.CreateAnd(A, B),
lib/Transforms/InstCombine/InstCombineSelect.cpp
  177       V = Builder.CreateAnd(V, ConstantInt::get(SelType, AndMask));
  209     V = Builder.CreateAnd(V, ConstantInt::get(V->getType(), AndMask));
  529   Value *MaskedX = Builder.CreateAnd(X, FullMask);
  659     V = Builder.CreateAnd(V, ConstantInt::get(V->getType(), C1));
 2544         Value *And = Builder.CreateAnd(CondVal, TrueSI->getCondition());
lib/Transforms/InstCombine/InstCombineShifts.cpp
  332     Value *Rem = Builder.CreateAnd(A, ConstantInt::get(I.getType(), *B - 1),
  510     Value *And = Builder.CreateAnd(InnerShift->getOperand(0),
  669       Value *And = Builder.CreateAnd(NSh,
  717           Value *XM = Builder.CreateAnd(V1, ConstantExpr::getShl(CC, Op1),
  751           Value *XM = Builder.CreateAnd(V1, ConstantExpr::getShl(CC, Op1),
lib/Transforms/Instrumentation/AddressSanitizer.cpp
 1644       IRB.CreateAnd(AddrLong, ConstantInt::get(IntptrTy, Granularity - 1));
 3281   Value *PartialSize = IRB.CreateAnd(OldSize, AllocaRzMask);
lib/Transforms/Instrumentation/ControlHeightReduction.cpp
 1957     MergedCondition = IRB.CreateAnd(MergedCondition, Cond);
 1965         MergedCondition = IRB.CreateAnd(MergedCondition, Cond);
 1971       MergedCondition = IRB.CreateAnd(MergedCondition, Negate);
lib/Transforms/Instrumentation/DataFlowSanitizer.cpp
 1076           IRB.CreateAnd(IRB.CreatePtrToInt(Addr, IntptrTy),
lib/Transforms/Instrumentation/HWAddressSanitizer.cpp
  641     TagMismatch = IRB.CreateAnd(TagMismatch, TagNotIgnored);
  879     TaggedPtrLong = IRB.CreateAnd(PtrLong, ShiftedTag);
  897     UntaggedPtrLong = IRB.CreateAnd(PtrLong,
 1004     Value *ThreadLongNew = IRB.CreateAnd(
lib/Transforms/Instrumentation/InstrOrderFile.cpp
  149     Value *WrappedIdx = updateB.CreateAnd(
lib/Transforms/Instrumentation/MemorySanitizer.cpp
 1392           IRB.CreateAnd(OffsetLong, ConstantInt::get(MS.IntptrTy, ~AndMask));
 1430             IRB.CreateAnd(OriginLong, ConstantInt::get(MS.IntptrTy, ~Mask));
 1954     Value *S1S2 = IRB.CreateAnd(S1, S2);
 1955     Value *V1S2 = IRB.CreateAnd(V1, S2);
 1956     Value *S1V2 = IRB.CreateAnd(S1, V2);
 1976     Value *S1S2 = IRB.CreateAnd(S1, S2);
 1977     Value *V1S2 = IRB.CreateAnd(V1, S2);
 1978     Value *S1V2 = IRB.CreateAnd(S1, V2);
 2236       IRB.CreateAnd(IRB.CreateICmpNE(Sc, Zero),
 2238                       IRB.CreateAnd(IRB.CreateXor(Sc, MinusOne), C), Zero));
 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);
 2962         Value *MaskedPassThruShadow = IRB.CreateAnd(
lib/Transforms/Scalar/LoopPredication.cpp
  597   return Builder.CreateAnd(FirstIterationCheck, LimitCheck);
  645   return Builder.CreateAnd(FirstIterationCheck, LimitCheck);
lib/Transforms/Scalar/LowerAtomic.cpp
   62     Res = Builder.CreateAnd(Orig, Val);
   65     Res = Builder.CreateNot(Builder.CreateAnd(Orig, Val));
lib/Transforms/Scalar/MakeGuardsExplicit.cpp
   73       B.CreateAnd(ExplicitGuard->getCondition(), WidenableCondition);
lib/Transforms/Utils/FlattenCFG.cpp
  302       NC = Builder.CreateAnd(PC, CC);
lib/Transforms/Utils/IntegerDivision.cpp
  316   Value *Carry = Builder.CreateAnd(Tmp10, One);
  317   Value *Tmp11 = Builder.CreateAnd(Tmp10, Divisor);
lib/Transforms/Utils/SimplifyLibCalls.cpp
  959     C = B.CreateAnd(C, B.getIntN(Width, 0xFF));
  967     Value *Bits = B.CreateIsNotNull(B.CreateAnd(Shl, BitfieldC), "memchr.bits");
  971     return B.CreateIntToPtr(B.CreateAnd(Bounds, Bits, "memchr"), CI->getType());
 2252   return B.CreateAnd(CI->getArgOperand(0),
tools/clang/lib/CodeGen/CGBuiltin.cpp
  767       CGF.Builder.CreateAnd(CGF.Builder.CreateTrunc(BitPos, CGF.Int8Ty),
  803       NewByte = CGF.Builder.CreateAnd(OldByte, CGF.Builder.CreateNot(Mask));
  816   return CGF.Builder.CreateAnd(
 1370     llvm::Value *Underflow = CGF.Builder.CreateAnd(
 1981     Value *Result = Builder.CreateAnd(Tmp, llvm::ConstantInt::get(ArgType, 1));
 2281     V = Builder.CreateAnd(Eq, IsLessThanInf, "and");
 2282     V = Builder.CreateAnd(V, IsNormal, "and");
 5721     Ops[0] = Builder.CreateAnd(Ops[0], Ops[1]);
 6976     Value *EltsFromInput = Builder.CreateAnd(CmpRes, Ops[0]);
 6977     Value *EltsFromTbl = Builder.CreateAnd(Builder.CreateNot(CmpRes), TblRes);
 6995     Value *EltsFromInput = Builder.CreateAnd(CmpRes, Ops[0]);
 6996     Value *EltsFromTbl = Builder.CreateAnd(Builder.CreateNot(CmpRes), TblRes);
 7877     Ops[0] = Builder.CreateAnd(Ops[0], Ops[1]);
 8343     Ops[1] = Builder.CreateAnd(Ops[0], Ops[1], "vbsl");
 8344     Ops[2] = Builder.CreateAnd(Builder.CreateNot(Ops[0]), Ops[2], "vbsl");
 9688       Cmp = CGF.Builder.CreateAnd(Cmp, getMaskVecValue(CGF, MaskIn, NumElts));
 9948     LHS = CGF.Builder.CreateAnd(LHS, Mask);
 9949     RHS = CGF.Builder.CreateAnd(RHS, Mask);
10122     Value *Bitset = Builder.CreateAnd(Features, Mask);
10124     Result = Builder.CreateAnd(Result, Cmp);
10137     Value *Bitset = Builder.CreateAnd(Features, Mask);
10139     Result = Builder.CreateAnd(Result, Cmp);
12224     Value *Amt = Builder.CreateAnd(Builder.CreateZExt(Ops[2], Int128Ty),
tools/clang/lib/CodeGen/CGCall.cpp
 3010         Builder.CreateAnd(CanNullCheck, RetValNullabilityPrecondition);
tools/clang/lib/CodeGen/CGDecl.cpp
 2514           Builder.CreateAnd(RetValNullabilityPrecondition,
tools/clang/lib/CodeGen/CGExpr.cpp
  751       llvm::Value *Align = Builder.CreateAnd(
  824       llvm::Value *Slot = Builder.CreateAnd(Hash,
 1623     Check = Builder.CreateAnd(Upper, Lower);
 3027     Cond = Cond ? Builder.CreateAnd(Cond, Check) : Check;
 3037     JointCond = Builder.CreateAnd(FatalCond, RecoverableCond);
tools/clang/lib/CodeGen/CGExprAgg.cpp
 1016     return Builder.CreateAnd(Cmp, CmpImag, "and.eq");
tools/clang/lib/CodeGen/CGExprScalar.cpp
  755     return Builder.CreateAnd(Ops.LHS, Ops.RHS, "and");
  930   Check = Builder.CreateAnd(GE, LE);
 1607     Mask = Builder.CreateAnd(Mask, MaskBits, "mask");
 3605         Builder.CreateAnd(RHS, GetWidthMinusOneValue(Ops.LHS, RHS), "shl.mask");
 3668         Builder.CreateAnd(RHS, GetWidthMinusOneValue(Ops.LHS, RHS), "shr.mask");
 3891       Result = Builder.CreateAnd(ResultR, ResultI, "and.ri");
 3977     Value *And = Builder.CreateAnd(LHS, RHS);
 4221     llvm::Value *tmp3 = Builder.CreateAnd(RHSTmp, tmp2);
 4222     llvm::Value *tmp4 = Builder.CreateAnd(LHSTmp, tmp);
 4718             : Builder.CreateAnd(BaseIsNotNullptr, ResultIsNotNullptr);
 4754     ValidGEP = Builder.CreateAnd(ValidGEP, NoOffsetOverflow);
tools/clang/lib/CodeGen/CGOpenMPRuntime.cpp
 8962     llvm::Value *Member = MapperCGF.Builder.CreateAnd(
 8994     llvm::Value *LeftToFrom = MapperCGF.Builder.CreateAnd(
 9009     llvm::Value *AllocMapType = MapperCGF.Builder.CreateAnd(
 9021     llvm::Value *ToMapType = MapperCGF.Builder.CreateAnd(
 9032     llvm::Value *FromMapType = MapperCGF.Builder.CreateAnd(
 9103   llvm::Value *DeleteBit = MapperCGF.Builder.CreateAnd(
 9123   llvm::Value *MapTypeArg = MapperCGF.Builder.CreateAnd(
tools/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp
  649   return Bld.CreateAnd(getNVPTXThreadID(CGF), Bld.getInt32(LaneIDMask),
  689   return Bld.CreateAnd(Bld.CreateNUWSub(NumThreads, Bld.getInt32(1)),
 3558   llvm::Value *CondAlgo1 = Bld.CreateAnd(
 3562   llvm::Value *CondAlgo2 = Bld.CreateAnd(
 3563       Algo2, Bld.CreateIsNull(Bld.CreateAnd(LaneIDArgVal, Bld.getInt16(1))));
 3564   CondAlgo2 = Bld.CreateAnd(
 3593   llvm::Value *CondCopy = Bld.CreateAnd(
tools/clang/lib/CodeGen/CodeGenFunction.cpp
 2259         Condition ? Builder.CreateAnd(Condition, FeatureCond) : FeatureCond;
tools/clang/lib/CodeGen/ItaniumCXXABI.cpp
  618     IsVirtual = Builder.CreateAnd(RawAdj, ptrdiff_1);
  620     IsVirtual = Builder.CreateAnd(FnAsInt, ptrdiff_1);
 1100     llvm::Value *OrAdjAnd1 = Builder.CreateAnd(OrAdj, One);
 1138     llvm::Value *VirtualBit = Builder.CreateAnd(Adj, One, "memptr.virtualbit");
 2308           ? Builder.CreateAnd(LI, llvm::ConstantInt::get(CGM.Int8Ty, 1))
tools/clang/lib/CodeGen/MicrosoftCXXABI.cpp
 2412     Builder.CreateStore(Builder.CreateAnd(LI, Mask), Guard);
 2527         Builder.CreateICmpEQ(Builder.CreateAnd(LI, Bit), Zero);
tools/clang/lib/CodeGen/TargetInfo.cpp
  265   PtrAsInt = CGF.Builder.CreateAnd(PtrAsInt,
 3766     InRegs = InRegs ? CGF.Builder.CreateAnd(InRegs, FitsInFP) : FitsInFP;
 4232     NumRegs = Builder.CreateAnd(NumRegs, Builder.getInt8((uint8_t) ~1U));
 5382     reg_offs = CGF.Builder.CreateAnd(
 5496     OnStackPtr = CGF.Builder.CreateAnd(
tools/polly/lib/CodeGen/IslExprBuilder.cpp
  578     Res = Builder.CreateAnd(LHS, RHS);
tools/polly/lib/CodeGen/IslNodeBuilder.cpp
 1269   Cond = Builder.CreateAnd(Cond, OverflowHappened, "polly.preload.cond.result");
 1610   RTC = Builder.CreateAnd(RTC, OverflowHappened, "polly.rtc.result");
unittests/IR/PatternMatch.cpp
  557     EXPECT_TRUE(match(IRB.CreateAnd(X, X), m_And(m_Value(tX), m_Deferred(tX))));
  563         match(IRB.CreateAnd(X, Y), m_c_And(m_Value(tX), m_Deferred(tX))));
  574   checkMatch(IRB.CreateAnd(X, IRB.CreateAnd(X, Y)));
  574   checkMatch(IRB.CreateAnd(X, IRB.CreateAnd(X, Y)));
  575   checkMatch(IRB.CreateAnd(X, IRB.CreateAnd(Y, X)));
  575   checkMatch(IRB.CreateAnd(X, IRB.CreateAnd(Y, X)));
  576   checkMatch(IRB.CreateAnd(IRB.CreateAnd(X, Y), X));
  576   checkMatch(IRB.CreateAnd(IRB.CreateAnd(X, Y), X));
  577   checkMatch(IRB.CreateAnd(IRB.CreateAnd(Y, X), X));
  577   checkMatch(IRB.CreateAnd(IRB.CreateAnd(Y, X), X));