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

Declarations

include/llvm/ADT/APInt.h

  931   APInt operator*(const APInt &RHS) const;

References

include/llvm/ADT/APSInt.h

  271     return APSInt(static_cast<const APInt&>(*this) * RHS, IsUnsigned);

lib/Analysis/BasicAliasAnalysis.cpp

  593       APInt WideScaledOffset = IndexOffset.sextOrTrunc(MaxPointerSize*2) *
  604         Decomposed.OtherOffset += IndexOffset.sextOrTrunc(MaxPointerSize) * Scale;
 2025     MinDiff.zextOrTrunc(Var0.Scale.getBitWidth()) * Var0.Scale.abs();

lib/Analysis/ConstantFolding.cpp

  954         Offset -= NewIdx * ElemSize;
 2320           APInt Product = (Lhs.sextOrSelf(ExtendedWidth) *

lib/Analysis/DependenceAnalysis.cpp

 1419     APInt A2 = A0 - Q*A1; A0 = A1; A1 = A2;
 1420     APInt B2 = B0 - Q*B1; B0 = B1; B1 = B2;

lib/Analysis/InlineCost.cpp

  412     Offset += OpC->getValue().sextOrTrunc(IntPtrWidth) * TypeSize;

lib/Analysis/ScalarEvolution.cpp

 2283     AccumulatedConstant += Scale * C->getAPInt();
 2292           Scale * cast<SCEVConstant>(Mul->getOperand(0))->getAPInt();
 2954           ConstantInt::get(getContext(), LHSC->getAPInt() * RHSC->getAPInt());
 5791   APInt Offset = Step * MaxBECount;

lib/Analysis/ValueTracking.cpp

  419   APInt BottomKnown = Bottom0.getLoBits(TrailBitsKnown0) *

lib/CodeGen/GlobalISel/Utils.cpp

  359       return C1 * C2;

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

 4699   case ISD::MUL:  return std::make_pair(C1 * C2, true);

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

 3888         APInt Offs = ElementSize * CI->getValue().sextOrTrunc(IdxSize);

lib/CodeGen/SelectionDAG/TargetLowering.cpp

 4587     while ((t = Divisor * Factor) != 1)
 4985     assert((D0 * P).isOneValue() && "Multiplicative inverse sanity check.");
 5172     assert((D0 * P).isOneValue() && "Multiplicative inverse sanity check.");

lib/ExecutionEngine/ExecutionEngine.cpp

  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/IR/ConstantFold.cpp

 1231         return ConstantInt::get(CI1->getContext(), C1V * C2V);

lib/IR/ConstantRange.cpp

  947   ConstantRange Result_zext = ConstantRange(this_min * Other_min,
  948                                             this_max * Other_max + 1);
  970   auto L = {this_min * Other_min, this_min * Other_max,
  970   auto L = {this_min * Other_min, this_min * Other_max,
  971             this_max * Other_min, this_max * Other_max};
  971             this_max * Other_min, this_max * Other_max};

lib/IR/Operator.cpp

   58     Offset += Index * APInt(Offset.getBitWidth(),

lib/Support/APInt.cpp

  257   *this = *this * RHS;
 1136   APInt square(x_old * x_old);
 1137   APInt nextSquare((x_old + 1) * (x_old +1));
 1177     t[i] -= t[i^1] * q;
 1213   r1 = signedMin - q1*anc;    // initialize r1 = rem(2p,abs(nc))
 1215   r2 = signedMin - q2*ad;     // initialize r2 = rem(2p,abs(d))
 1258   r1 = signedMin - q1*nc;   // initialize r1 = rem(2p,nc)
 1260   r2 = signedMax - q2*d;    // initialize r2 = rem((2p-1),d)
 1964   APInt Res = *this * RHS;
 1976     return *this * RHS;
 1979   APInt Res = lshr(1) * RHS;
 2909   APInt SqrB = B * B;
 2969   APInt D = SqrB - 4*A*C;
 2973   APInt Q = SQ * SQ;
 3004   assert((SQ*SQ).sle(D) && "SQ = |_sqrt(D)_|, so SQ*SQ <= D");
 3013   APInt VX = (A*X + B)*X + C;
 3013   APInt VX = (A*X + B)*X + C;
 3014   APInt VY = VX + TwoA*X + A + B;

lib/Transforms/IPO/Attributor.cpp

 3576         APInt TotalSize = SizeT->getValue() * Num->getValue();

lib/Transforms/InstCombine/InstCombineAddSub.cpp

 1044             ConstantInt::get(X->getType()->getContext(), C0 * C1);

lib/Transforms/InstCombine/InstCombineCompares.cpp

 2361   APInt Prod = C * *C2;

lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp

  801       if ((CS->getValue().zextOrSelf(128)*APInt(128, TypeSize)).ugt(MaxSize))

lib/Transforms/Scalar/LoopStrengthReduce.cpp

 4221               (C->getAPInt().abs() * APInt(BitWidth, F.Scale))

lib/Transforms/Scalar/SROA.cpp

  754           GEPOffset += Index * APInt(Offset.getBitWidth(),
 1490     Offset -= NumSkippedElements * ElementSize;
 1503     Offset -= NumSkippedElements * ElementSize;
 1557   Offset -= NumSkippedElements * ElementSize;

tools/clang/lib/Basic/FixedPoint.cpp

  196     (FractPart * RadixInt)
  199     FractPart = (FractPart * RadixInt) & FractPartMask;

tools/clang/lib/CodeGen/CGExprCXX.cpp

  761                                          adjustedCount * arraySizeMultiplier);

tools/lldb/source/Utility/Scalar.cpp

 2238       result.m_integer = a->m_integer * b->m_integer;

unittests/ADT/APIntTest.cpp

  300   EXPECT_EQ(neg_one, neg_one * one);
  301   EXPECT_EQ(neg_one, one * neg_one);
  302   EXPECT_EQ(one, neg_one * neg_one);
  303   EXPECT_EQ(one, one * one);
  914   auto p = a * b + c;
 1445   ValC = ValA * ValB;
 2342   APInt A = HugePrime * APInt(BitWidth, 9931);
 2343   APInt B = HugePrime * APInt(BitWidth, 123456);
 2530         auto Prod = Quo.zext(16) * B.zext(16);
 2533           EXPECT_TRUE(((Quo - 1).zext(16) * B.zext(16)).ult(Ai));
 2563         auto Prod = Quo.sext(16) * B.sext(16);
 2566           EXPECT_TRUE(((Quo - 1).sext(16) * B.sext(16)).ult(A));
 2571         auto Prod = Quo.sext(16) * B.sext(16);
 2574           EXPECT_TRUE(((Quo + 1).sext(16) * B.sext(16)).ugt(A));
 2616         APInt D = APInt(2 * Bits, A) * APInt(2 * Bits, B);
 2714       APInt One = V * MulInv;