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

References

include/llvm/IR/IRBuilder.h
 1563       return CreateBinOp(static_cast<Instruction::BinaryOps>(Opc),
lib/Analysis/ScalarEvolutionExpander.cpp
  228   Instruction *BO = cast<Instruction>(Builder.CreateBinOp(Opcode, LHS, RHS));
lib/CodeGen/CodeGenPrepare.cpp
 5923   Value *NewTVal = Builder.CreateBinOp(Opcode, Shift->getOperand(0), TVal);
 5924   Value *NewFVal = Builder.CreateBinOp(Opcode, Shift->getOperand(0), FVal);
lib/CodeGen/ExpandReductions.cpp
  109         Rdx = Builder.CreateBinOp((Instruction::BinaryOps)getOpcode(ID),
lib/IR/Core.cpp
 3392   return wrap(unwrap(B)->CreateBinOp(Instruction::BinaryOps(map_from_llvmopcode(Op)), unwrap(LHS),
lib/Target/AMDGPU/AMDGPUAtomicOptimizer.cpp
  253     return B.CreateBinOp(Instruction::Add, LHS, RHS);
  255     return B.CreateBinOp(Instruction::Sub, LHS, RHS);
  257     return B.CreateBinOp(Instruction::And, LHS, RHS);
  259     return B.CreateBinOp(Instruction::Or, LHS, RHS);
  261     return B.CreateBinOp(Instruction::Xor, LHS, RHS);
lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp
  310   ExtRes = Builder.CreateBinOp(I.getOpcode(), ExtOp0, ExtOp1);
  913           NewElt = Builder.CreateBinOp(Opc, NumEltN, DenEltN);
lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp
 1603       return B.CreateBinOp(cast<BinaryOperator>(T)->getOpcode(),
 1638                               B.CreateBinOp(Op, X, Z),
 1639                               B.CreateBinOp(Op, Y, Z));
 1646                               B.CreateBinOp(Op, X, Y),
 1647                               B.CreateBinOp(Op, X, Z));
 1700       return B.CreateBinOp(BitOp->getOpcode(),
 1728       return B.CreateBinOp(BitOp2->getOpcode(), X,
 1729                 B.CreateBinOp(BitOp1->getOpcode(), CA, CB));
lib/Target/NVPTX/NVPTXGenericToNVVM.cpp
  301       return Builder.CreateBinOp(Instruction::BinaryOps(C->getOpcode()),
lib/Target/XCore/XCoreLowerThreadLocal.cpp
  104                   Builder.CreateBinOp((Instruction::BinaryOps)OpCode,
lib/Transforms/AggressiveInstCombine/TruncInstCombine.cpp
  351       Res = Builder.CreateBinOp((Instruction::BinaryOps)Opc, LHS, RHS);
lib/Transforms/InstCombine/InstCombineAndOrXor.cpp
  109   Value *BinOp = Builder.CreateBinOp(I.getOpcode(), NewLHS, NewRHS);
 1472     Value *AndOr = Builder.CreateBinOp(Opcode, A, B, I.getName() + ".demorgan");
 1516       Value *NewOp = Builder.CreateBinOp(LogicOpc, X, TruncC);
 1526       Value *NewOp = Builder.CreateBinOp(LogicOpc, X, TruncC);
 1569     Value *NewOp = Builder.CreateBinOp(LogicOpc, Cast0Src, Cast1Src,
 1715   Value *NewBO = Opc == Instruction::Sub ? Builder.CreateBinOp(Opc, NewC, X)
 1716                                          : Builder.CreateBinOp(Opc, X, NewC);
 1835               BinOp = Builder.CreateBinOp(Op0I->getOpcode(), X, TruncC1);
 1837               BinOp = Builder.CreateBinOp(Op0I->getOpcode(), TruncC1, X);
lib/Transforms/InstCombine/InstCombineCompares.cpp
 4493       Result = Builder.CreateBinOp(BinaryOp, LHS, RHS);
 4498       Result = Builder.CreateBinOp(BinaryOp, LHS, RHS);
lib/Transforms/InstCombine/InstCombineMulDivRem.cpp
  324       Value *Rem = Builder.CreateBinOp(RemOpc, X, DivOp1);
  930     Value *NarrowOp = Builder.CreateBinOp(Opcode, X, Y);
  946     Value *NarrowOp = isa<Constant>(D) ? Builder.CreateBinOp(Opcode, X, TruncC)
  947                                        : Builder.CreateBinOp(Opcode, TruncC, X);
lib/Transforms/InstCombine/InstCombineShifts.cpp
  323           I.getOpcode(), Builder.CreateBinOp(I.getOpcode(), Op0, C), A);
  647       Value *NSh = Builder.CreateBinOp(I.getOpcode(), TrOp, ShAmt, I.getName());
  697           Value *X = Builder.CreateBinOp(Op0BO->getOpcode(), YS, V1,
  732           Value *X = Builder.CreateBinOp(Op0BO->getOpcode(), V1, YS,
  771             Builder.CreateBinOp(I.getOpcode(), Op0BO->getOperand(0), Op1);
  815           Builder.CreateBinOp(I.getOpcode(), FalseVal, Op1);
  816         Value *NewOp = Builder.CreateBinOp(TBO->getOpcode(), NewShift,
  834           Builder.CreateBinOp(I.getOpcode(), TrueVal, Op1);
  835         Value *NewOp = Builder.CreateBinOp(FBO->getOpcode(), NewShift,
lib/Transforms/InstCombine/InstructionCombining.cpp
  567         V = Builder.CreateBinOp(TopLevelOpcode, B, D, RHS->getName());
  569         SimplifiedInst = Builder.CreateBinOp(InnerOpcode, A, V);
  587         V = Builder.CreateBinOp(TopLevelOpcode, A, C, LHS->getName());
  589         SimplifiedInst = Builder.CreateBinOp(InnerOpcode, V, B);
  696       C = Builder.CreateBinOp(InnerOpcode, L, R);
  705       C = Builder.CreateBinOp(TopLevelOpcode, B, C);
  714       C = Builder.CreateBinOp(TopLevelOpcode, A, C);
  733       A = Builder.CreateBinOp(InnerOpcode, L, R);
  742       A = Builder.CreateBinOp(TopLevelOpcode, A, C);
  751       A = Builder.CreateBinOp(TopLevelOpcode, A, B);
  783       SI = Builder.CreateSelect(A, V2, Builder.CreateBinOp(Opcode, C, E));
  785       SI = Builder.CreateSelect(A, Builder.CreateBinOp(Opcode, B, D), V1);
  849   Value *RI = Builder.CreateBinOp(BO->getOpcode(), Op0, Op1,
  922   Value *RI = Builder.CreateBinOp(I->getOpcode(), Op0, Op1, "phitmp");
 1426     Value *NewBO0 = Builder.CreateBinOp(Opcode, L0, R0);
 1429     Value *NewBO1 = Builder.CreateBinOp(Opcode, L1, R1);
 1442     Value *XY = Builder.CreateBinOp(Opcode, X, Y);
 1608   Value *NarrowBO = Builder.CreateBinOp(BO.getOpcode(), X, Y, "narrow");
lib/Transforms/Instrumentation/MemorySanitizer.cpp
 2386     Value *Shift = IRB.CreateBinOp(I.getOpcode(), S1, V2);
lib/Transforms/Scalar/CorrelatedValuePropagation.cpp
  501       B.CreateBinOp(Opcode, WO->getLHS(), WO->getRHS(), WO->getName());
  648   auto *BO = B.CreateBinOp(Instr->getOpcode(), LHS, RHS, Instr->getName());
lib/Transforms/Scalar/Float2Int.cpp
  496     NewV = IRB.CreateBinOp(mapBinOpcode(I->getOpcode()),
lib/Transforms/Scalar/Scalarizer.cpp
  146     return Builder.CreateBinOp(BO.getOpcode(), Op0, Op1, Name);
lib/Transforms/Utils/LoopUtils.cpp
  803       Result = Builder.CreateBinOp((Instruction::BinaryOps)Op, Result, Ext,
  846       TmpVec = Builder.CreateBinOp((Instruction::BinaryOps)Op, TmpVec, Shuf,
lib/Transforms/Utils/SimplifyCFG.cpp
 2762           Builder.CreateBinOp(Opc, PBI->getCondition(), CondInPred, "or.cond"));
 2826                Builder.CreateBinOp(Instruction::And, NotCond, CondInPred,
 2829             MergedCond = cast<Instruction>(Builder.CreateBinOp(
 2835           MergedCond = cast<Instruction>(Builder.CreateBinOp(
 2840             MergedCond = cast<Instruction>(Builder.CreateBinOp(
lib/Transforms/Vectorize/LoopVectorize.cpp
 1709   Value *Mul = addFastMathFlag(Builder.CreateBinOp(MulOp, Step, ConstVF));
 1735         Builder.CreateBinOp(AddOp, LastInduction, SplatVF, "step.add")));
 1941   Value *BOp = Builder.CreateBinOp(BinOp, Val, MulOp, "induction");
 1980       auto *Mul = addFastMathFlag(Builder.CreateBinOp(MulOp, StartIdx, Step));
 1981       auto *Add = addFastMathFlag(Builder.CreateBinOp(AddOp, ScalarIV, Mul));
 2251                           ? Builder.CreateBinOp(Instruction::And, ShuffledMask,
 2870     Value *BOp = B.CreateBinOp(InductionBinOp->getOpcode(), StartValue, MulExp,
 3324         NewI = B.CreateBinOp(BO->getOpcode(), ShrinkOperand(BO->getOperand(0)),
 3788           Builder.CreateBinOp((Instruction::BinaryOps)Op, RdxPart,
 6574     return addFastMathFlag(Builder.CreateBinOp(BinOp, Val, MulOp));
lib/Transforms/Vectorize/SLPVectorizer.cpp
 3993       Value *V = Builder.CreateBinOp(
 4183         V0 = Builder.CreateBinOp(
 4185         V1 = Builder.CreateBinOp(
 5794         return Builder.CreateBinOp((Instruction::BinaryOps)Opcode, LHS, RHS,
lib/Transforms/Vectorize/VPlan.cpp
  299     Value *V = Builder.CreateBinOp((Instruction::BinaryOps)getOpcode(), A, B);
tools/clang/lib/CodeGen/CGAtomic.cpp
  647     Result = CGF.Builder.CreateBinOp(PostOp, RMWI, LoadVal1);
 1187         ResVal = Builder.CreateBinOp(PostOp, ResVal, LoadVal1);
tools/clang/lib/CodeGen/CGBuiltin.cpp
  203   Result = CGF.Builder.CreateBinOp(Op, Result, Args[1]);
  205     Result = CGF.Builder.CreateBinOp(llvm::Instruction::Xor, Result,
 9593   return CGF.Builder.CreateBitCast(CGF.Builder.CreateBinOp(Opc, LHS, RHS),
tools/clang/lib/CodeGen/CGExprScalar.cpp
 2392       return isPre ? Builder.CreateBinOp(op, old, amt) : old;
tools/clang/lib/CodeGen/ItaniumCXXABI.cpp
 1103     EqZero = Builder.CreateBinOp(And, EqZero, OrAdjAnd1EqZero);
 1107   llvm::Value *Result = Builder.CreateBinOp(Or, EqZero, AdjEq);
 1108   Result = Builder.CreateBinOp(And, PtrEq, Result,
tools/clang/lib/CodeGen/MicrosoftCXXABI.cpp
 2858       Res = Builder.CreateBinOp(And, Res, Cmp);
 2868     Res = Builder.CreateBinOp(Or, Res, IsZero);
 2873   return Builder.CreateBinOp(And, Res, Cmp0, "memptr.cmp");
tools/polly/lib/CodeGen/BlockGenerators.cpp
 1184   Value *NewInst = Builder.CreateBinOp(Inst->getOpcode(), NewOpZero, NewOpOne,
unittests/IR/IRBuilderTest.cpp
  450   F = Builder.CreateBinOp(Instruction::FAdd, F, F);