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

References

include/llvm/CodeGen/BasicTTIImpl.h

 1292       return ConcreteTTI->getArithmeticReductionCost(Instruction::Mul, Tys[0],
 1371       Cost += ConcreteTTI->getArithmeticInstrCost(Instruction::Mul, ExtTy);
 1435       Cost += ConcreteTTI->getArithmeticInstrCost(Instruction::Mul, ExtTy);

include/llvm/IR/IRBuilder.h

 1172     return CreateInsertNUWNSWBinOp(Instruction::Mul, LHS, RHS, Name,

include/llvm/IR/InstrTypes.h

  364   DEFINE_HELPERS(Mul, NSW) // CreateNSWMul
  365   DEFINE_HELPERS(Mul, NUW) // CreateNUWMul

include/llvm/IR/Instruction.h

  488            Opcode == Add || Opcode == Mul;
  502     case Mul: case FMul:

include/llvm/IR/Operator.h

  102            I->getOpcode() == Instruction::Mul ||
  108            CE->getOpcode() == Instruction::Mul ||
  428   : public ConcreteOperator<OverflowingBinaryOperator, Instruction::Mul> {

include/llvm/IR/PatternMatch.h

  826 inline BinaryOp_match<LHS, RHS, Instruction::Mul> m_Mul(const LHS &L,
  828   return BinaryOp_match<LHS, RHS, Instruction::Mul>(L, R);
  951 inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Mul,
  954   return OverflowingBinaryOp_match<LHS, RHS, Instruction::Mul,
  984 inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Mul,
  987   return OverflowingBinaryOp_match<LHS, RHS, Instruction::Mul,
 1821 inline BinaryOp_match<LHS, RHS, Instruction::Mul, true> m_c_Mul(const LHS &L,
 1823   return BinaryOp_match<LHS, RHS, Instruction::Mul, true>(L, R);

lib/Analysis/BasicAliasAnalysis.cpp

  335       case Instruction::Mul:

lib/Analysis/CFLGraph.h

  565       case Instruction::Mul:

lib/Analysis/DemandedBits.cpp

  176   case Instruction::Mul:

lib/Analysis/IVDescriptors.cpp

  571   case Instruction::Mul:
  756     return Instruction::Mul;

lib/Analysis/InstructionSimplify.cpp

  833   if (Constant *C = foldOrCommuteConstant(Instruction::Mul, Op0, Op1, Q))
  859   if (Value *V = SimplifyAssociativeBinOp(Instruction::Mul, Op0, Op1, Q,
  864   if (Value *V = ExpandBinOp(Instruction::Mul, Op0, Op1, Instruction::Add,
  871     if (Value *V = ThreadBinOpOverSelect(Instruction::Mul, Op0, Op1, Q,
  878     if (Value *V = ThreadBinOpOverPHI(Instruction::Mul, Op0, Op1, Q,
 4776   case Instruction::Mul:
 5274   case Instruction::Mul:

lib/Analysis/ObjCARCInstKind.cpp

  256     case Instruction::Mul:

lib/Analysis/ScalarEvolution.cpp

 2373         return Instruction::Mul;
 4510   case Instruction::Mul:
 4557     if (BinOp == Instruction::Mul || !isOverflowIntrinsicNoWrap(WO, DT))
 6208     case Instruction::Mul: {
 6227         if (!NewBO || NewBO->Opcode != Instruction::Mul) {

lib/Analysis/ScalarEvolutionExpander.cpp

  804       P = InsertBinop(Instruction::Mul, P, P, SCEV::FlagAnyWrap,
  807         Result = Result ? InsertBinop(Instruction::Mul, Result, P,
  846         Prod = InsertBinop(Instruction::Mul, Prod, W, S->getNoWrapFlags(),

lib/Analysis/TargetTransformInfo.cpp

 1158   case Instruction::Mul:

lib/Analysis/ValueTracking.cpp

 1035   case Instruction::Mul: {
 1367             Opcode == Instruction::Mul) {
 1416             else if (Opcode == Instruction::Mul && Known2.isNonNegative() &&
 2563     case Instruction::Mul: {
 2713   case Instruction::Mul: {
 3822            Operator::getOpcode(U->getOperand(1)) != Instruction::Mul &&
 4329   case Instruction::Mul:

lib/AsmParser/LLLexer.cpp

  843   INSTKEYWORD(mul,   Mul);  INSTKEYWORD(fmul,   FMul);

lib/AsmParser/LLParser.cpp

 3462         Opc == Instruction::Mul || Opc == Instruction::Shl) {
 3487     case Instruction::Mul:

lib/Bitcode/Reader/BitcodeReader.cpp

 1085     return IsFP ? Instruction::FMul : Instruction::Mul;
 2544               Opc == Instruction::Mul ||
 3902             Opc == Instruction::Mul ||

lib/Bitcode/Writer/BitcodeWriter.cpp

  534   case Instruction::Mul:

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

 2292   case Instruction::Mul:
 2305     case Instruction::Mul: return MCBinaryExpr::createMul(LHS, RHS, Ctx);

lib/CodeGen/CodeGenPrepare.cpp

 3553   case Instruction::Mul:
 4113   case Instruction::Mul:

lib/CodeGen/ExpandReductions.cpp

   39     return Instruction::Mul;

lib/CodeGen/SelectionDAG/FastISel.cpp

 1806   case Instruction::Mul:

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

 2986   case Instruction::Mul:

lib/CodeGen/TargetLoweringBase.cpp

 1596   case Mul:            return ISD::MUL;

lib/ExecutionEngine/ExecutionEngine.cpp

  782     case Instruction::Mul:
  801           case Instruction::Mul: GV.IntVal = LHS.IntVal * RHS.IntVal; break;

lib/ExecutionEngine/Interpreter/Execution.cpp

  788     case Instruction::Mul:   INTEGER_VECTOR_OPERATION(*) break;
  825     case Instruction::Mul:   R.IntVal = Src1.IntVal * Src2.IntVal; break;
 2075   case Instruction::Mul:  Dest.IntVal = Op0.IntVal * Op1.IntVal; break;

lib/FuzzMutate/Operations.cpp

   21   Ops.push_back(binOpDescriptor(1, Instruction::Mul));
   99   case Instruction::Mul:

lib/IR/ConstantFold.cpp

 1009     case Instruction::Mul: {
 1108     case Instruction::Mul:
 1230       case Instruction::Mul:
 1351     case Instruction::Mul:

lib/IR/ConstantRange.cpp

  266   case Instruction::Mul:
  785   case Instruction::Mul:

lib/IR/Constants.cpp

 1880   case Instruction::Mul:
 2276   return get(Instruction::Mul, C1, C2, Flags);
 2349       case Instruction::Mul: // X * 1 = X
 2394   case Instruction::Mul:

lib/IR/Instruction.cpp

  124   case Instruction::Mul:
  316   case Mul: return "mul";

lib/IR/Instructions.cpp

 2278   case Mul:

lib/IR/IntrinsicInst.cpp

  240       return Instruction::Mul;

lib/IR/Verifier.cpp

 3167   case Instruction::Mul:

lib/Target/AArch64/AArch64FastISel.cpp

  786   case Instruction::Mul: {
 5156   case Instruction::Mul:

lib/Target/AArch64/AArch64TargetTransformInfo.cpp

  107   case Instruction::Mul:
  530         int MulCost = getArithmeticInstrCost(Instruction::Mul, Ty, Opd1Info,
  905   case Instruction::Mul:

lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp

  252   case Instruction::Mul:
  264   case Instruction::Mul:
  461   if (I.getOpcode() != Instruction::Mul)

lib/Target/ARM/ARMISelLowering.cpp

14777     case Instruction::Mul:

lib/Target/ARM/ARMParallelDSP.cpp

  104             if (I->getOpcode() == Instruction::Mul)
  107           if (I->getOpcode() == Instruction::Mul)
  471   case Instruction::Mul: {

lib/Target/ARM/ARMTargetTransformInfo.cpp

 1088   case Instruction::Mul:

lib/Target/PowerPC/PPCTargetTransformInfo.cpp

  154   case Instruction::Mul:

lib/Target/RISCV/RISCVTargetTransformInfo.cpp

   56   case Instruction::Mul:

lib/Target/SystemZ/SystemZTargetTransformInfo.cpp

  119   case Instruction::Mul:
  949   case Instruction::Mul: // SE: 16->32, 32->64, z14:16->64

lib/Target/X86/X86TargetTransformInfo.cpp

  270         Cost += getArithmeticInstrCost(Instruction::Mul, Ty, Op1Info, Op2Info);
  577       return getArithmeticInstrCost(Instruction::Mul, Ty, Op1Info, Op2Info,
 3020   case Instruction::Mul:

lib/Target/XCore/XCoreLowerThreadLocal.cpp

   90     case Instruction::Mul:

lib/Transforms/AggressiveInstCombine/TruncInstCombine.cpp

   52   case Instruction::Mul:
  114     case Instruction::Mul:
  345     case Instruction::Mul:

lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

 1821       case Instruction::Mul:

lib/Transforms/InstCombine/InstCombineCasts.cpp

   55       if (I->getOpcode() == Instruction::Mul) {
  178   case Instruction::Mul:
  353   case Instruction::Mul:
  597   case Instruction::Mul: {
 1002   case Instruction::Mul:
 1331   case Instruction::Mul:

lib/Transforms/InstCombine/InstCombineCompares.cpp

 2838     case Instruction::Mul:
 2999   case Instruction::Mul:
 3956     case Instruction::Mul: {
 4441     case Instruction::Mul:
 4462     case Instruction::Mul:
 4539   assert(MulInstr->getOpcode() == Instruction::Mul);

lib/Transforms/InstCombine/InstCombineInternal.h

  591     case Instruction::Mul: return willNotOverflowMul(LHS, RHS, CxtI, IsSigned);

lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

  724         auto *Mul = BinaryOperator::Create(Instruction::Mul, X,
  750         auto *Mul = BinaryOperator::Create(Instruction::Mul, X,

lib/Transforms/InstCombine/InstCombineSelect.cpp

  246   case Instruction::Mul:
  276   case Instruction::Mul:

lib/Transforms/InstCombine/InstCombineVectorOps.cpp

 1157     case Instruction::Mul:
 1221     case Instruction::Mul:
 1319     case Instruction::Mul:
 1452         return { Instruction::Mul, BO0, ShlOne };

lib/Transforms/InstCombine/InstructionCombining.cpp

  486   if (LOp == Instruction::Mul)
  532       return Instruction::Mul;
  618             InnerOpcode == Instruction::Mul) {
 1225       if (BO->getOpcode() == Instruction::Mul) {

lib/Transforms/Instrumentation/PoisonChecking.cpp

  141   case Instruction::Mul: {

lib/Transforms/Scalar/CorrelatedValuePropagation.cpp

  458   case Instruction::Mul:
  878       case Instruction::Mul:

lib/Transforms/Scalar/Float2Int.cpp

  115   case Instruction::FMul: return Instruction::Mul;

lib/Transforms/Scalar/GVN.cpp

  501     case Instruction::Mul:

lib/Transforms/Scalar/GVNSink.cpp

  449     case Instruction::Mul:

lib/Transforms/Scalar/IndVarSimplify.cpp

 1094   case Instruction::Mul:
 1189     case Instruction::Mul:
 1243   if (OpCode == Instruction::Mul)
 1259       OpCode != Instruction::Mul)
 1423       OpCode != Instruction::Mul)

lib/Transforms/Scalar/LoopRerollPass.cpp

  748     case Instruction::Mul:

lib/Transforms/Scalar/LoopStrengthReduce.cpp

  946           if (UI && UI->getOpcode() == Instruction::Mul &&

lib/Transforms/Scalar/NaryReassociate.cpp

  220   case Instruction::Mul:
  288   case Instruction::Mul:
  486   case Instruction::Mul:
  501   case Instruction::Mul:
  515   case Instruction::Mul:

lib/Transforms/Scalar/NewGVN.cpp

 2004     case Instruction::Mul:

lib/Transforms/Scalar/Reassociate.cpp

  340   assert((Opcode == Instruction::Mul || Opcode == Instruction::FMul) &&
  582         if ((Opcode == Instruction::Mul && match(Tmp, m_Neg(m_Value()))) ||
 1042   BinaryOperator *BO = isReassociableOp(V, Instruction::Mul, Instruction::FMul);
 1117   BinaryOperator *BO = isReassociableOp(V, Instruction::Mul, Instruction::FMul);
 1533         isReassociableOp(Ops[i].Op, Instruction::Mul, Instruction::FMul);
 1605           isReassociableOp(Ops[i].Op, Instruction::Mul, Instruction::FMul);
 1880   case Instruction::Mul:
 2079     if (isReassociableOp(I->getOperand(0), Instruction::Mul) ||
 2081          (isReassociableOp(I->user_back(), Instruction::Mul) ||
 2123       if (isReassociableOp(I->getOperand(1), Instruction::Mul) &&
 2125            !isReassociableOp(I->user_back(), Instruction::Mul))) {
 2242     if (I->getOpcode() == Instruction::Mul &&

lib/Transforms/Scalar/SCCP.cpp

 1031   if (I.getOpcode() == Instruction::And || I.getOpcode() == Instruction::Mul ||
 1044           I.getOpcode() == Instruction::Mul) {
 1544       case Instruction::Mul:

lib/Transforms/Scalar/SpeculativeExecution.cpp

  216     case Instruction::Mul:

lib/Transforms/Scalar/StraightLineStrengthReduce.cpp

  377   case Instruction::Mul:

lib/Transforms/Utils/BypassSlowDivision.cpp

  198   case Instruction::Mul: {

lib/Transforms/Utils/Local.cpp

 1697     case Instruction::Mul:

lib/Transforms/Utils/LoopUtils.cpp

  876   case Instruction::Mul:
  957     return createSimpleTargetReduction(B, TTI, Instruction::Mul, Src, Flags);

lib/Transforms/Utils/SimplifyIndVar.cpp

  418   case Instruction::Mul:
  737       BO->getOpcode() != Instruction::Mul)

lib/Transforms/Vectorize/LoopVectorize.cpp

 1700     MulOp = Instruction::Mul;
 1964     MulOp = Instruction::Mul;
 4145   case Instruction::Mul:
 6190   case Instruction::Mul:
 6201     if (I->getOpcode() == Instruction::Mul && isStrideMul(I, Legal))
 6315     return VF * TTI.getArithmeticInstrCost(Instruction::Mul, VectorTy) +
 6865     case Instruction::Mul:

lib/Transforms/Vectorize/SLPVectorizer.cpp

 2571     case Instruction::Mul:
 3085     case Instruction::Mul:
 3969     case Instruction::Mul:
 5015   case Instruction::Mul:
 5778                 Opcode == Instruction::Mul || Opcode == Instruction::FMul ||

tools/lldb/source/Expression/IRInterpreter.cpp

  580       case Instruction::Mul:
  699     case Instruction::Mul:
  750       case Instruction::Mul:

tools/llvm-stress/llvm-stress.cpp

  397     case 2:{Op = (isFloat?Instruction::FMul : Instruction::Mul); break; }

tools/polly/lib/Analysis/ScopBuilder.cpp

 2672   case Instruction::Mul:
 3114       (BinOp->getOpcode() == Instruction::Mul ||

tools/polly/lib/CodeGen/IslExprBuilder.cpp

  108     case Instruction::Mul:
  126   case Instruction::Mul:
  161   return createBinOp(Instruction::Mul, LHS, RHS, Name);

unittests/IR/ConstantRangeTest.cpp

 1663       Instruction::Mul, OverflowingBinaryOperator::NoUnsignedWrap,
 1670       Instruction::Mul, OverflowingBinaryOperator::NoSignedWrap,

unittests/Transforms/Utils/CloningTest.cpp

   72   BinaryOperator *Mul = BinaryOperator::Create(Instruction::Mul, V, V);

unittests/Transforms/Vectorize/VPlanSlpTest.cpp

  324   EXPECT_EQ(CombinedMulAB->getOpcode(), Instruction::Mul);
  342   EXPECT_EQ(CombinedMulCD->getOpcode(), Instruction::Mul);