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

References

include/llvm/CodeGen/BasicTTIImpl.h

 1054           BinaryOperator::And, MaskVT);
 1295       return ConcreteTTI->getArithmeticReductionCost(Instruction::And, Tys[0],
 1406           ConcreteTTI->getArithmeticInstrCost(BinaryOperator::And, OverflowTy);

include/llvm/IR/Instruction.h

  176     return Opcode == And || Opcode == Or || Opcode == Xor;
  487     return Opcode == And || Opcode == Or || Opcode == Xor ||
  503     case And: case Or: case Xor:
  518     return Opcode == And || Opcode == Or;

include/llvm/IR/PatternMatch.h

  874 inline BinaryOp_match<LHS, RHS, Instruction::And> m_And(const LHS &L,
  876   return BinaryOp_match<LHS, RHS, Instruction::And>(L, R);
 1828 inline BinaryOp_match<LHS, RHS, Instruction::And, true> m_c_And(const LHS &L,
 1830   return BinaryOp_match<LHS, RHS, Instruction::And, true>(L, R);

lib/Analysis/BranchProbabilityInfo.cpp

  684     if (LHS->getOpcode() == Instruction::And)

lib/Analysis/CFLGraph.h

  573       case Instruction::And:

lib/Analysis/ConstantFolding.cpp

  723   if (Opc == Instruction::And) {
 1276         Predicate == ICmpInst::ICMP_EQ ? Instruction::And : Instruction::Or;

lib/Analysis/DemandedBits.cpp

  233   case Instruction::And:

lib/Analysis/IVDescriptors.cpp

  573   case Instruction::And:
  760     return Instruction::And;

lib/Analysis/InstructionSimplify.cpp

   83   } else if (BinOpCode == BinaryOperator::And) {
 1905   if (Constant *C = foldOrCommuteConstant(Instruction::And, Op0, Op1, Q))
 1988   if (Value *V = SimplifyAssociativeBinOp(Instruction::And, Op0, Op1, Q,
 1993   if (Value *V = ExpandBinOp(Instruction::And, Op0, Op1, Instruction::Or,
 1998   if (Value *V = ExpandBinOp(Instruction::And, Op0, Op1, Instruction::Xor,
 2005     if (Value *V = ThreadBinOpOverSelect(Instruction::And, Op0, Op1, Q,
 2012     if (Value *V = ThreadBinOpOverPHI(Instruction::And, Op0, Op1, Q,
 2151   if (Value *V = ExpandBinOp(Instruction::Or, Op0, Op1, Instruction::And, Q,
 4792   case Instruction::And:
 5311   case Instruction::And:

lib/Analysis/LazyValueInfo.cpp

 1295   if (!BO || (isTrueDest && BO->getOpcode() != BinaryOperator::And) ||

lib/Analysis/ObjCARCInstKind.cpp

  267     case Instruction::And:

lib/Analysis/ScalarEvolution.cpp

 4513   case Instruction::And:
 6246     case Instruction::And:
 6336             if (LBO->getOpcode() == Instruction::And &&
 7228     if (BO->getOpcode() == Instruction::And) {
 9684     if (BO->getOpcode() == Instruction::And) {

lib/Analysis/TargetTransformInfo.cpp

 1169   case Instruction::And:

lib/Analysis/ValueTracking.cpp

  990   case Instruction::And: {
 1365             Opcode == Instruction::And ||
 1950             if (BO->getOpcode() == Instruction::And) {
 2479     case Instruction::And:
 5320   assert((LHS->getOpcode() == Instruction::And ||
 5379     if ((LHSBO->getOpcode() == Instruction::And ||
 5443   case Instruction::And:

lib/AsmParser/LLLexer.cpp

  847   INSTKEYWORD(and,   And);  INSTKEYWORD(or,    Or);   INSTKEYWORD(xor,   Xor);

lib/Bitcode/Reader/BitcodeReader.cpp

 1101     return IsFP ? -1 : Instruction::And;

lib/Bitcode/Writer/BitcodeWriter.cpp

  545   case Instruction::And:  return bitc::BINOP_AND;

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

 2296   case Instruction::And:
 2309     case Instruction::And: return MCBinaryExpr::createAnd(LHS, RHS, Ctx);

lib/CodeGen/CodeGenPrepare.cpp

 1485         BinaryOperator::Create(Instruction::And, AndI->getOperand(0),
 1508     if (User->getOpcode() != Instruction::And ||
 3745   if ((Inst->getOpcode() == Instruction::And ||
 3774       if (AndInst && AndInst->getOpcode() == Instruction::And) {
 5739     case Instruction::And: {
 7012   if (BinOp && (BinOp->getOpcode() == Instruction::And) &&
 7208       Opc = Instruction::And;
 7233     if (Opc == Instruction::And)

lib/CodeGen/ExpandReductions.cpp

   41     return Instruction::And;

lib/CodeGen/SelectionDAG/FastISel.cpp

 1828   case Instruction::And:

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

 2098       if (BOpc == Instruction::And)
 2101         BOpc = Instruction::And;
 2156     assert(Opc == Instruction::And && "Unknown merge op!");
 2266         (Opcode == Instruction::And || Opcode == Instruction::Or)) {
 2987   case Instruction::And:

lib/CodeGen/TargetLoweringBase.cpp

 1607   case And:            return ISD::AND;

lib/ExecutionEngine/ExecutionEngine.cpp

  788     case Instruction::And:
  806           case Instruction::And: GV.IntVal = LHS.IntVal & RHS.IntVal; break;

lib/ExecutionEngine/Interpreter/Execution.cpp

  793     case Instruction::And:   INTEGER_VECTOR_OPERATION(&) break;
  835     case Instruction::And:   R.IntVal = Src1.IntVal & Src2.IntVal; break;
 2085   case Instruction::And:  Dest.IntVal = Op0.IntVal & Op1.IntVal; break;

lib/FuzzMutate/Operations.cpp

   29   Ops.push_back(binOpDescriptor(1, Instruction::And));
  107   case Instruction::And:

lib/IR/ConstantFold.cpp

  253   case Instruction::And: {
 1005     case Instruction::And:
 1127     case Instruction::And:
 1248       case Instruction::And:

lib/IR/ConstantRange.cpp

  801   case Instruction::And:

lib/IR/Constants.cpp

 1897   case Instruction::And:
 2310   return get(Instruction::And, C1, C2);
 2351       case Instruction::And: // X & -1 = X
 2393   case Instruction::And:

lib/IR/Instruction.cpp

  326   case And: return "and";

lib/IR/Instructions.cpp

 2326   case And: case Or:

lib/IR/Verifier.cpp

 3196   case Instruction::And:

lib/Target/AArch64/AArch64FastISel.cpp

  758       if (AI->getOpcode() == Instruction::And) {
  847   case Instruction::And: {
 1960   case Instruction::And:
 2339       if (AI->getOpcode() == Instruction::And && isValueAvailable(AI)) {
 5172   case Instruction::And:

lib/Target/AArch64/AArch64TargetTransformInfo.cpp

  112   case Instruction::And:
  902   case Instruction::And:

lib/Target/AMDGPU/AMDGPUAtomicOptimizer.cpp

  257     return B.CreateBinOp(Instruction::And, LHS, RHS);

lib/Target/ARM/ARMTargetTransformInfo.cpp

  118   if (Opcode == Instruction::And) {
 1085   case Instruction::And:

lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp

  983     case Instruction::And:
 1235     case Instruction::And:
 1270       case Instruction::And:
 1578     case Instruction::And:
 1595         case Instruction::And:
 1616       if (And0->getOpcode() != Instruction::And ||
 1617           And1->getOpcode() != Instruction::And)
 1691         case Instruction::And:
 1709           case Instruction::And:
 1736       if (I->getOpcode() != Instruction::And)
 1747       if (!And0 || And0->getOpcode() != Instruction::And)

lib/Target/Mips/MipsFastISel.cpp

  874   case Instruction::And:
 2065   case Instruction::And:

lib/Target/PowerPC/PPCTargetTransformInfo.cpp

  145   case Instruction::And:

lib/Target/RISCV/RISCVTargetTransformInfo.cpp

   53   case Instruction::And:

lib/Target/SystemZ/SystemZTDC.cpp

  102           (LI->getOpcode() == Instruction::And ||
  296     case Instruction::And:

lib/Target/SystemZ/SystemZTargetTransformInfo.cpp

  137   case Instruction::And:
  476                 (I->getOpcode() == Instruction::And ||
  482       else if (Opcode == Instruction::Or || Opcode == Instruction::And) {
  964   case Instruction::And:

lib/Target/X86/X86TargetTransformInfo.cpp

  284       return getArithmeticInstrCost(Instruction::And, Ty, Op1Info, Op2Info,
 2997   case Instruction::And:

lib/Target/XCore/XCoreLowerThreadLocal.cpp

  100     case Instruction::And:

lib/Transforms/AggressiveInstCombine/TruncInstCombine.cpp

   53   case Instruction::And:
  115     case Instruction::And:
  346     case Instruction::And:

lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

  931   assert(CxtI.getOpcode() == Instruction::And);
 1416   assert((Opcode == Instruction::And || Opcode == Instruction::Or) &&
 1428   FCmpInst::Predicate NanPred = Opcode == Instruction::And ? FCmpInst::FCMP_ORD
 1461   assert((Opcode == Instruction::And || Opcode == Instruction::Or) &&
 1465   Opcode = (Opcode == Instruction::And) ? Instruction::Or : Instruction::And;
 1465   Opcode = (Opcode == Instruction::And) ? Instruction::Or : Instruction::And;
 1583     Value *Res = LogicOpc == Instruction::And ? foldAndOfICmps(ICmp0, ICmp1, I)
 1595     if (Value *R = foldLogicOfFCmps(FCmp0, FCmp1, LogicOpc == Instruction::And))
 1603   assert(I.getOpcode() == Instruction::And);
 2854     if (Value *AndICmp = SimplifyBinOp(Instruction::And, LHS, RHS, SQ)) {
 3027     if (NotVal->getOpcode() == Instruction::And ||
 3038         if (NotVal->getOpcode() == Instruction::And)

lib/Transforms/InstCombine/InstCombineCasts.cpp

  179   case Instruction::And:
  354   case Instruction::And:
  592   case Instruction::And:
  997   case Instruction::And:
 1021         if (I->getOpcode() == Instruction::And)
 1326   case Instruction::And:

lib/Transforms/InstCombine/InstCombineCompares.cpp

 1919     auto BOpc = Pred == CmpInst::ICMP_EQ ? Instruction::And : Instruction::Or;
 1932     auto BOpc = Pred == CmpInst::ICMP_EQ ? Instruction::And : Instruction::Or;
 2830     case Instruction::And:
 2989   case Instruction::And: {
 4575         if (BO->getOpcode() != Instruction::And)
 4704         assert(BO->getOpcode() == Instruction::And);

lib/Transforms/InstCombine/InstCombineSelect.cpp

  247   case Instruction::And:
  274   case Instruction::And:

lib/Transforms/InstCombine/InstCombineShifts.cpp

  283   return BinaryOperator::Create(Instruction::And, NewShift, NewMask);
  435   case Instruction::And:
  552   case Instruction::And:
  597   case Instruction::And:
  686       case Instruction::And:

lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp

  165   case Instruction::And: {
  291       if (LHSInst->getOpcode() == Instruction::And && LHSInst->hasOneUse() &&
  778   case Instruction::And: {

lib/Transforms/InstCombine/InstCombineVectorOps.cpp

 1164     case Instruction::And:
 1232     case Instruction::And:
 1330     case Instruction::And:

lib/Transforms/InstCombine/InstructionCombining.cpp

  477   if (LOp == Instruction::And)
  482     return ROp == Instruction::And;

lib/Transforms/Scalar/AlignmentFromAssumptions.cpp

  222   if (!CmpBO || CmpBO->getOpcode() != Instruction::And)

lib/Transforms/Scalar/CorrelatedValuePropagation.cpp

  882       case Instruction::And:

lib/Transforms/Scalar/EarlyCSE.cpp

  829       (BI->getSuccessor(0) == BB) ? Instruction::And : Instruction::Or;

lib/Transforms/Scalar/GVN.cpp

  512     case Instruction::And:

lib/Transforms/Scalar/GVNSink.cpp

  460     case Instruction::And:

lib/Transforms/Scalar/IndVarSimplify.cpp

 1099   case Instruction::And:

lib/Transforms/Scalar/JumpThreading.cpp

  692         I->getOpcode() == Instruction::And) {

lib/Transforms/Scalar/LoopIdiomRecognize.cpp

 1310     if (!DefX2 || DefX2->getOpcode() != Instruction::And)

lib/Transforms/Scalar/LoopUnswitch.cpp

  449     if (BO->getOpcode() == Instruction::And ||
  455         NewChain = BO->getOpcode() == Instruction::And ? OC_OpChainAnd :
  463         NewChain = BO->getOpcode() == Instruction::And ? OC_OpChainAnd :

lib/Transforms/Scalar/NewGVN.cpp

 2015     case Instruction::And:

lib/Transforms/Scalar/Reassociate.cpp

  124             I->getOpcode() == Instruction::And)) {
 1142         if (Opcode == Instruction::And)   // ...&X&~X = 0
 1154       if (Opcode == Instruction::And || Opcode == Instruction::Or) {
 1863   case Instruction::And:

lib/Transforms/Scalar/SCCP.cpp

 1031   if (I.getOpcode() == Instruction::And || I.getOpcode() == Instruction::Mul ||
 1043       if (I.getOpcode() == Instruction::And ||
 1545       case Instruction::And:

lib/Transforms/Scalar/SimpleLoopUnswitch.cpp

  399       if (cast<Instruction>(BI.getCondition())->getOpcode() != Instruction::And)
  481                  Instruction::And &&
 1936                  Instruction::And &&
 2575     if (CondI.getOpcode() != Instruction::And &&
 2689             Instruction::And) {

lib/Transforms/Scalar/SpeculativeExecution.cpp

  217     case Instruction::And:

lib/Transforms/Utils/Local.cpp

 1705     case Instruction::And:
 2751     if (I->getOpcode() == Instruction::And &&

lib/Transforms/Utils/LoopRotationUtils.cpp

  549     case Instruction::And:

lib/Transforms/Utils/LoopUtils.cpp

  879   case Instruction::And:
  959     return createSimpleTargetReduction(B, TTI, Instruction::And, Src, Flags);

lib/Transforms/Utils/PredicateInfo.cpp

  379       assert(BinOp->getOpcode() == Instruction::And &&
  429     if (BinOp->getOpcode() == Instruction::And)
  447       assert((BinOp->getOpcode() == Instruction::And ||

lib/Transforms/Utils/SimplifyCFG.cpp

  650         if (I->getOpcode() == (isEQ ? Instruction::Or : Instruction::And)) {
 2690         Opc = Instruction::And;
 2692         Opc = Instruction::And;
 2826                Builder.CreateBinOp(Instruction::And, NotCond, CondInPred,
 2836               Instruction::And, PBI->getCondition(), CondInPred, "and.cond"));

lib/Transforms/Vectorize/LoopVectorizationPlanner.h

  134     return createInstruction(Instruction::BinaryOps::And, {LHS, RHS});

lib/Transforms/Vectorize/LoopVectorize.cpp

 2251                           ? Builder.CreateBinOp(Instruction::And, ShuffledMask,
 4152   case Instruction::And:
 6197   case Instruction::And:
 6844     case Instruction::And:

lib/Transforms/Vectorize/SLPVectorizer.cpp

 2582     case Instruction::And:
 3096     case Instruction::And:
 3980     case Instruction::And:
 5016   case Instruction::And:
 5779                 Opcode == Instruction::And || Opcode == Instruction::Or ||

tools/clang/lib/CodeGen/CGAtomic.cpp

  604     PostOp = llvm::Instruction::And;
  631     PostOp = llvm::Instruction::And; // the NOT is special cased below
 1070       PostOp = llvm::Instruction::And;
 1134       PostOp = llvm::Instruction::And; // the NOT is special cased below

tools/clang/lib/CodeGen/CGBuiltin.cpp

 2784                                 llvm::Instruction::And);
 2805                                 llvm::Instruction::And, true);
11556     return EmitX86MaskLogic(*this, Instruction::And, Ops);
11561     return EmitX86MaskLogic(*this, Instruction::And, Ops, true);

tools/clang/lib/CodeGen/ItaniumCXXABI.cpp

 1052     Or = llvm::Instruction::And;
 1055     And = llvm::Instruction::And;

tools/clang/lib/CodeGen/MicrosoftCXXABI.cpp

 2830     Or = llvm::Instruction::And;
 2833     And = llvm::Instruction::And;

tools/lldb/source/Expression/IRInterpreter.cpp

  574       case Instruction::And:
  707     case Instruction::And:
  786       case Instruction::And:

tools/llvm-stress/llvm-stress.cpp

  405     case 10:{Op = Instruction::And;  break; }

tools/polly/lib/Analysis/ScopBuilder.cpp

  458     assert(Opcode == Instruction::And || Opcode == Instruction::Or);
  475     if (Opcode == Instruction::And)
 2666   case Instruction::And:

tools/polly/lib/Analysis/ScopDetection.cpp

  565     if (Opcode == Instruction::And || Opcode == Instruction::Or) {

tools/polly/lib/Support/SCEVValidator.cpp

  685     if (Opcode == Instruction::And || Opcode == Instruction::Or)

unittests/IR/ConstantsTest.cpp

  496   bool result = ConstantExpr::get(Instruction::And, TheConstantExpr,
  585       Instruction::And, TheConstantExpr, TheConstant)->isNullValue());

unittests/Transforms/Vectorize/VPlanPredicatorTest.cpp

   96   EXPECT_EQ(InnerAnd->getOpcode(), Instruction::And);
  196   EXPECT_EQ(And->getOpcode(), Instruction::And);
  197   EXPECT_EQ(NotAnd->getOpcode(), Instruction::And);