[IR] Add a ConstantInt::getAllOnes wrapper around ConstantInt::get/getSigned.

[craig.topper]

Summary

Creating an all ones value for a type larger than i64 requires
using using ConstantInt::getSigned with -1, passing true to the
IsSigned operand of ConstantInt::get with -1, or using
Constant::getAllOnesValue.

Many places in tree used the ConstantInt::get -1 without IsSigned.
This likely works fine for the types they see in practice, but
it seemed better to have a more explicit way to do this.

This patch adds ConstantInt::getAllOnes and replaces other calls
to use it.

[nikic]

This patch adds ConstantInt::getAllOnes and replaces other calls to use it.

Does it? I don't see any change to the Constant hierarchy.

In any case, I don't get why we need getAllOnes() when we already have getAllOnesValue().

[craig.topper]

Add the rest of the commit that I meant to push

[craig.topper]

In D147558#4244139, @nikic wrote:

This patch adds ConstantInt::getAllOnes and replaces other calls to use it.

Does it? I don't see any change to the Constant hierarchy.

In any case, I don't get why we need getAllOnes() when we already have getAllOnesValue().

getAllOnesValue has to reinspect the type to determine int vs FP. We also can't override on IntegerType* to return a ConstantInt*. Not sure if any of the callers of ConstantInt::get/getSigned was using that feature.

[nikic]

In D147558#4244195, @craig.topper wrote:

getAllOnesValue has to reinspect the type to determine int vs FP.

Is there reason to believe that this has any non-negligible cost?

We also can't override on IntegerType* to return a ConstantInt*. Not sure if any of the callers of ConstantInt::get/getSigned was using that feature.

We pretty much always handle int or vector of int, so specializing on ConstantInt return doesn't seem like something that would commonly be needed.

llvm/include/llvm/IR/Constants.h

 //===-- llvm/Constants.h - Constant class subclass definitions --*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
public:
   /// Get a ConstantInt for a specific signed value.
   static ConstantInt *getSigned(IntegerType *Ty, int64_t V) {
     return get(Ty, V, true);
   }
   static Constant *getSigned(Type *Ty, int64_t V) {
     return get(Ty, V, true);
   }
 
+  /// Return a ConstantInt containing all ones for the specified type.
+  static ConstantInt *getAllOnes(IntegerType *Ty) {
+    return get(Ty, -1, true);
+  }
+  static Constant *getAllOnes(Type *Ty) {
+    return get(Ty, -1, true);
+  }
+
   /// Return a ConstantInt with the specified value and an implied Type. The
   /// type is the integer type that corresponds to the bit width of the value.
   static ConstantInt *get(LLVMContext &Context, const APInt &V);
 
   /// Return a ConstantInt constructed from the string strStart with the given
   /// radix.
   static ConstantInt *get(IntegerType *Ty, StringRef Str, uint8_t Radix);
 

llvm/include/llvm/IR/IRBuilder.h

 //===- llvm/IRBuilder.h - Builder for LLVM Instructions ---------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
public:
   Value *CreateLogicalAnd(Value *Cond1, Value *Cond2, const Twine &Name = "") {
     assert(Cond2->getType()->isIntOrIntVectorTy(1));
     return CreateSelect(Cond1, Cond2,
                         ConstantInt::getNullValue(Cond2->getType()), Name);
   }
 
   Value *CreateLogicalOr(Value *Cond1, Value *Cond2, const Twine &Name = "") {
     assert(Cond2->getType()->isIntOrIntVectorTy(1));
-    return CreateSelect(Cond1, ConstantInt::getAllOnesValue(Cond2->getType()),
+    return CreateSelect(Cond1, ConstantInt::getAllOnes(Cond2->getType()),
                         Cond2, Name);
   }
 
   Value *CreateLogicalOp(Instruction::BinaryOps Opc, Value *Cond1, Value *Cond2,
                          const Twine &Name = "") {
     switch (Opc) {
     case Instruction::And:
       return CreateLogicalAnd(Cond1, Cond2, Name);
public:
    FastMathFlags FMF = FMFSource->getFastMathFlags();
     if (Value *Res = Folder.FoldUnOpFMF(Instruction::FNeg, V, FMF))
       return Res;
    return Insert(setFPAttrs(UnaryOperator::CreateFNeg(V), nullptr, FMF),
                  Name);
   }
 
   Value *CreateNot(Value *V, const Twine &Name = "") {
-    return CreateXor(V, Constant::getAllOnesValue(V->getType()), Name);
+    return CreateXor(V, ConstantInt::getAllOnes(V->getType()), Name);
   }
 
   Value *CreateUnOp(Instruction::UnaryOps Opc,
                     Value *V, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
     if (Value *Res = Folder.FoldUnOpFMF(Opc, V, FMF))
       return Res;
     Instruction *UnOp = UnaryOperator::Create(Opc, V);
public:
 
   /// Return a boolean value testing if \p Arg < 0.
   Value *CreateIsNeg(Value *Arg, const Twine &Name = "") {
     return CreateICmpSLT(Arg, ConstantInt::getNullValue(Arg->getType()), Name);
   }
 
   /// Return a boolean value testing if \p Arg > -1.
   Value *CreateIsNotNeg(Value *Arg, const Twine &Name = "") {
-    return CreateICmpSGT(Arg, ConstantInt::getAllOnesValue(Arg->getType()),
+    return CreateICmpSGT(Arg, ConstantInt::getAllOnes(Arg->getType()),
                          Name);
   }
 
   /// Return the i64 difference between two pointer values, dividing out
   /// the size of the pointed-to objects.
   ///
   /// This is intended to implement C-style pointer subtraction. As such, the
   /// pointers must be appropriately aligned for their element types and

llvm/lib/Analysis/IVDescriptors.cpp

 //===- llvm/Analysis/IVDescriptors.cpp - IndVar Descriptors -----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
Value *RecurrenceDescriptor::getRecurrenceIdentity(RecurKind K, Type *Tp,
   case RecurKind::Or:
     // Adding, Xoring, Oring zero to a number does not change it.
     return ConstantInt::get(Tp, 0);
   case RecurKind::Mul:
     // Multiplying a number by 1 does not change it.
     return ConstantInt::get(Tp, 1);
   case RecurKind::And:
     // AND-ing a number with an all-1 value does not change it.
-    return ConstantInt::get(Tp, -1, true);
+    return ConstantInt::getAllOnes(Tp);
   case RecurKind::FMul:
     // Multiplying a number by 1 does not change it.
     return ConstantFP::get(Tp, 1.0L);
   case RecurKind::FMulAdd:
   case RecurKind::FAdd:
     // Adding zero to a number does not change it.
     // FIXME: Ideally we should not need to check FMF for FAdd and should always
     // use -0.0. However, this will currently result in mixed vectors of 0.0/-0.0.
     // Instead, we should ensure that 1) the FMF from FAdd are propagated to the PHI
     // nodes where possible, and 2) PHIs with the nsz flag + -0.0 use 0.0. This would
     // mean we can then remove the check for noSignedZeros() below (see D98963).
     if (FMF.noSignedZeros())
       return ConstantFP::get(Tp, 0.0L);
     return ConstantFP::get(Tp, -0.0L);
   case RecurKind::UMin:
-    return ConstantInt::get(Tp, -1, true);
+    return ConstantInt::getAllOnes(Tp);
   case RecurKind::UMax:
     return ConstantInt::get(Tp, 0);
   case RecurKind::SMin:
     return ConstantInt::get(Tp,
                             APInt::getSignedMaxValue(Tp->getIntegerBitWidth()));
   case RecurKind::SMax:
     return ConstantInt::get(Tp,
                             APInt::getSignedMinValue(Tp->getIntegerBitWidth()));

llvm/lib/Analysis/InstructionSimplify.cpp

 //===- InstructionSimplify.cpp - Fold instruction operands ----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
if ((match(Op0, m_Add(m_Value(X), m_Constant(C1))) &&
       (match(Op1, m_Add(m_Value(X), m_Constant(C1))) &&
        match(Op0, m_Sub(m_Constant(C2), m_Specific(X))))) {
     if (ConstantExpr::getNot(C1) == C2) {
       // (X + C) & (~C - X) --> (X + C) & ~(X + C) --> 0
       // (X + C) | (~C - X) --> (X + C) | ~(X + C) --> -1
       // (X + C) ^ (~C - X) --> (X + C) ^ ~(X + C) --> -1
       Type *Ty = Op0->getType();
       return Opcode == Instruction::And ? ConstantInt::getNullValue(Ty)
-                                        : ConstantInt::getAllOnesValue(Ty);
+                                        : ConstantInt::getAllOnes(Ty);
     }
   }
   return nullptr;
 }
 
 /// Given operands for an And, see if we can fold the result.
 /// If not, this returns null.
 static Value *simplifyAndInst(Value *Op0, Value *Op1, const SimplifyQuery &Q,

 
 // TODO: Many of these folds could use LogicalAnd/LogicalOr.
 static Value *simplifyOrLogic(Value *X, Value *Y) {
   assert(X->getType() == Y->getType() && "Expected same type for 'or' ops");
   Type *Ty = X->getType();
 
   // X | ~X --> -1
   if (match(Y, m_Not(m_Specific(X))))
-    return ConstantInt::getAllOnesValue(Ty);
+    return ConstantInt::getAllOnes(Ty);
 
   // X | ~(X & ?) = -1
   if (match(Y, m_Not(m_c_And(m_Specific(X), m_Value()))))
-    return ConstantInt::getAllOnesValue(Ty);
+    return ConstantInt::getAllOnes(Ty);
 
   // X | (X & ?) --> X
   if (match(Y, m_c_And(m_Specific(X), m_Value())))
     return X;
 
   Value *A, *B;
 
   // (A ^ B) | (A | B) --> A | B
   // (A ^ B) | (B | A) --> B | A
   if (match(X, m_Xor(m_Value(A), m_Value(B))) &&
       match(Y, m_c_Or(m_Specific(A), m_Specific(B))))
     return Y;
 
   // ~(A ^ B) | (A | B) --> -1
   // ~(A ^ B) | (B | A) --> -1
   if (match(X, m_Not(m_Xor(m_Value(A), m_Value(B)))) &&
       match(Y, m_c_Or(m_Specific(A), m_Specific(B))))
-    return ConstantInt::getAllOnesValue(Ty);
+    return ConstantInt::getAllOnes(Ty);
 
   // (A & ~B) | (A ^ B) --> A ^ B
   // (~B & A) | (A ^ B) --> A ^ B
   // (A & ~B) | (B ^ A) --> B ^ A
   // (~B & A) | (B ^ A) --> B ^ A
   if (match(X, m_c_And(m_Value(A), m_Not(m_Value(B)))) &&
       match(Y, m_c_Xor(m_Specific(A), m_Specific(B))))
     return Y;
 
   // (~A ^ B) | (A & B) --> ~A ^ B
   // (B ^ ~A) | (A & B) --> B ^ ~A
   // (~A ^ B) | (B & A) --> ~A ^ B
   // (B ^ ~A) | (B & A) --> B ^ ~A
   if (match(X, m_c_Xor(m_NotForbidUndef(m_Value(A)), m_Value(B))) &&
       match(Y, m_c_And(m_Specific(A), m_Specific(B))))
     return X;
 
   // (~A | B) | (A ^ B) --> -1
   // (~A | B) | (B ^ A) --> -1
   // (B | ~A) | (A ^ B) --> -1
   // (B | ~A) | (B ^ A) --> -1
   if (match(X, m_c_Or(m_Not(m_Value(A)), m_Value(B))) &&
       match(Y, m_c_Xor(m_Specific(A), m_Specific(B))))
-    return ConstantInt::getAllOnesValue(Ty);
+    return ConstantInt::getAllOnes(Ty);
 
   // (~A & B) | ~(A | B) --> ~A
   // (~A & B) | ~(B | A) --> ~A
   // (B & ~A) | ~(A | B) --> ~A
   // (B & ~A) | ~(B | A) --> ~A
   Value *NotA;
   if (match(X,
             m_c_And(m_CombineAnd(m_Value(NotA), m_NotForbidUndef(m_Value(A))),
static Value *simplifyOrInst(Value *Op0, Value *Op1, const SimplifyQuery &Q,
   // X | poison -> poison
   if (isa<PoisonValue>(Op1))
     return Op1;
 
   // X | undef -> -1
   // X | -1 = -1
   // Do not return Op1 because it may contain undef elements if it's a vector.
   if (Q.isUndefValue(Op1) || match(Op1, m_AllOnes()))
-    return Constant::getAllOnesValue(Op0->getType());
+    return ConstantInt::getAllOnes(Op0->getType());
 
   // X | X = X
   // X | 0 = X
   if (Op0 == Op1 || match(Op1, m_Zero()))
     return Op0;
 
   if (Value *R = simplifyOrLogic(Op0, Op1))
     return R;
static Value *simplifyOrInst(Value *Op0, Value *Op1, const SimplifyQuery &Q,
   if ((match(Op0, m_Shl(m_AllOnes(), m_Value(X))) &&
        match(Op1, m_LShr(m_AllOnes(), m_Value(Y)))) ||
       (match(Op1, m_Shl(m_AllOnes(), m_Value(X))) &&
        match(Op0, m_LShr(m_AllOnes(), m_Value(Y))))) {
     const APInt *C;
     if ((match(X, m_Sub(m_APInt(C), m_Specific(Y))) ||
          match(Y, m_Sub(m_APInt(C), m_Specific(X)))) &&
         C->ule(X->getType()->getScalarSizeInBits())) {
-      return ConstantInt::getAllOnesValue(X->getType());
+      return ConstantInt::getAllOnes(X->getType());
     }
   }
 
   // A funnel shift (rotate) can be decomposed into simpler shifts. See if we
   // are mixing in another shift that is redundant with the funnel shift.
 
   // (fshl X, ?, Y) | (shl X, Y) --> fshl X, ?, Y
   // (shl X, Y) | (fshl X, ?, Y) --> fshl X, ?, Y
if (match(Op1, m_Zero()))
     return Op0;
 
   // A ^ A = 0
   if (Op0 == Op1)
     return Constant::getNullValue(Op0->getType());
 
   // A ^ ~A  =  ~A ^ A  =  -1
   if (match(Op0, m_Not(m_Specific(Op1))) || match(Op1, m_Not(m_Specific(Op0))))
-    return Constant::getAllOnesValue(Op0->getType());
+    return ConstantInt::getAllOnes(Op0->getType());
 
   auto foldAndOrNot = [](Value *X, Value *Y) -> Value * {
     Value *A, *B;
     // (~A & B) ^ (A | B) --> A -- There are 8 commuted variants.
     if (match(X, m_c_And(m_Not(m_Value(A)), m_Value(B))) &&
         match(Y, m_c_Or(m_Specific(A), m_Specific(B))))
       return A;
 
case Intrinsic::fshr: {
     }
 
     // Rotating zero by anything is zero.
     if (match(Op0, m_Zero()) && match(Op1, m_Zero()))
       return ConstantInt::getNullValue(F->getReturnType());
 
     // Rotating -1 by anything is -1.
     if (match(Op0, m_AllOnes()) && match(Op1, m_AllOnes()))
-      return ConstantInt::getAllOnesValue(F->getReturnType());
+      return ConstantInt::getAllOnes(F->getReturnType());
 
     return nullptr;
   }
   case Intrinsic::experimental_constrained_fma: {
     auto *FPI = cast<ConstrainedFPIntrinsic>(Call);
     if (Value *V = simplifyFPOp(Args, {}, Q, *FPI->getExceptionBehavior(),
                                 *FPI->getRoundingMode()))
       return V;

llvm/lib/Analysis/MemoryBuiltins.cpp

 //===- MemoryBuiltins.cpp - Identify calls to memory builtins -------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
if (SizeOffsetPair != ObjectSizeOffsetEvaluator::unknown()) {
       ResultSize = Builder.CreateZExtOrTrunc(ResultSize, ResultType);
       Value *Ret = Builder.CreateSelect(
           UseZero, ConstantInt::get(ResultType, 0), ResultSize);
 
       // The non-constant size expression cannot evaluate to -1.
       if (!isa<Constant>(SizeOffsetPair.first) ||
           !isa<Constant>(SizeOffsetPair.second))
         Builder.CreateAssumption(
-            Builder.CreateICmpNE(Ret, ConstantInt::get(ResultType, -1)));
+            Builder.CreateICmpNE(Ret, ConstantInt::getAllOnes(ResultType)));
 
       return Ret;
     }
   }
 
   if (!MustSucceed)
     return nullptr;
 

llvm/lib/Analysis/ScalarEvolution.cpp

 //===- ScalarEvolution.cpp - Scalar Evolution Analysis --------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
case Instruction::AShr: {
     // bitwidth(K) iterations.
     Value *FirstValue = PN->getIncomingValueForBlock(Predecessor);
     KnownBits Known = computeKnownBits(FirstValue, DL, 0, &AC,
                                        Predecessor->getTerminator(), &DT);
     auto *Ty = cast<IntegerType>(RHS->getType());
     if (Known.isNonNegative())
       StableValue = ConstantInt::get(Ty, 0);
     else if (Known.isNegative())
-      StableValue = ConstantInt::get(Ty, -1, true);
+      StableValue = ConstantInt::getAllOnes(Ty);
     else
       return getCouldNotCompute();
 
     break;
   }
   case Instruction::LShr:
   case Instruction::Shl:
     // Both {K,lshr,<positive-constant>} and {K,shl,<positive-constant>}

llvm/lib/CodeGen/CodeGenPrepare.cpp

 //===- CodeGenPrepare.cpp - Prepare a function for code generation --------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
static bool matchUAddWithOverflowConstantEdgeCases(CmpInst *Cmp,
   // We are not expecting non-canonical/degenerate code. Just bail out.
   if (isa<Constant>(A))
     return false;
 
   ICmpInst::Predicate Pred = Cmp->getPredicate();
   if (Pred == ICmpInst::ICMP_EQ && match(B, m_AllOnes()))
     B = ConstantInt::get(B->getType(), 1);
   else if (Pred == ICmpInst::ICMP_NE && match(B, m_ZeroInt()))
-    B = ConstantInt::get(B->getType(), -1);
+    B = ConstantInt::getAllOnes(B->getType());
   else
     return false;
 
   // Check the users of the variable operand of the compare looking for an add
   // with the adjusted constant.
   for (User *U : A->users()) {
     if (match(U, m_Add(m_Specific(A), m_Specific(B)))) {
       Add = cast<BinaryOperator>(U);

llvm/lib/CodeGen/ExpandLargeFpConvert.cpp

 //===--- ExpandLargeFpConvert.cpp - Expand large fp convert----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
static void expandFPToI(Instruction *FPToI) {
   FPMantissaWidth = FPMantissaWidth == 63 ? 112 : FPMantissaWidth;
   unsigned FloatWidth = PowerOf2Ceil(FPMantissaWidth);
   unsigned ExponentWidth = FloatWidth - FPMantissaWidth - 1;
   unsigned ExponentBias = (1 << (ExponentWidth - 1)) - 1;
   Value *ImplicitBit = Builder.CreateShl(
       Builder.getIntN(BitWidth, 1), Builder.getIntN(BitWidth, FPMantissaWidth));
   Value *SignificandMask =
       Builder.CreateSub(ImplicitBit, Builder.getIntN(BitWidth, 1));
-  Value *NegOne = Builder.CreateSExt(
-      ConstantInt::getSigned(Builder.getInt32Ty(), -1), IntTy);
+  Value *NegOne =
+      Builder.CreateSExt(ConstantInt::getAllOnes(Builder.getInt32Ty()), IntTy);
   Value *NegInf =
       Builder.CreateShl(ConstantInt::getSigned(IntTy, 1),
                         ConstantInt::getSigned(IntTy, BitWidth - 1));
 
   BasicBlock *Entry = Builder.GetInsertBlock();
   Function *F = Entry->getParent();
   Entry->setName(Twine(Entry->getName(), "fp-to-i-entry"));
   BasicBlock *End =
static void expandFPToI(Instruction *FPToI) {
   // conversion.
   if (FloatVal->getType()->isX86_FP80Ty())
     FloatVal0 =
         Builder.CreateFPExt(FloatVal, Type::getFP128Ty(Builder.getContext()));
   Value *ARep0 =
       Builder.CreateBitCast(FloatVal0, Builder.getIntNTy(FloatWidth));
   Value *ARep = Builder.CreateZExt(ARep0, FPToI->getType());
   Value *PosOrNeg = Builder.CreateICmpSGT(
-      ARep0, ConstantInt::getSigned(Builder.getIntNTy(FloatWidth), -1));
+      ARep0, ConstantInt::getAllOnes(Builder.getIntNTy(FloatWidth)));
   Value *Sign = Builder.CreateSelect(PosOrNeg, ConstantInt::getSigned(IntTy, 1),
-                                     ConstantInt::getSigned(IntTy, -1));
+                                     ConstantInt::getAllOnes(IntTy));
   Value *And =
       Builder.CreateLShr(ARep, Builder.getIntN(BitWidth, FPMantissaWidth));
   Value *And2 = Builder.CreateAnd(
       And, Builder.getIntN(BitWidth, (1 << ExponentWidth) - 1));
   Value *Abs = Builder.CreateAnd(ARep, SignificandMask);
   Value *Or = Builder.CreateOr(Abs, ImplicitBit);
   Value *Cmp =
       Builder.CreateICmpULT(And2, Builder.getIntN(BitWidth, ExponentBias));
Value *Sub5 = Builder.CreateSub(
       FloatWidth == 128 ? Call : Cast);
   Value *ShProm = Builder.CreateZExt(Sub5, IntTy);
   Value *Shr6 = Builder.CreateLShr(IsSigned ? Sub : IntVal,
                                    FloatWidth == 128 ? Sub5 : ShProm);
   Value *Sub8 =
       Builder.CreateAdd(FloatWidth == 128 ? Call : Cast,
                         Builder.getIntN(BitWidthNew, FPMantissaWidth + 3));
   Value *ShProm9 = Builder.CreateZExt(Sub8, IntTy);
-  Value *Shr9 = Builder.CreateLShr(ConstantInt::getSigned(IntTy, -1),
+  Value *Shr9 = Builder.CreateLShr(ConstantInt::getAllOnes(IntTy),
                                    FloatWidth == 128 ? Sub8 : ShProm9);
   Value *And = Builder.CreateAnd(Shr9, IsSigned ? Sub : IntVal);
   Value *Cmp10 = Builder.CreateICmpNE(And, Builder.getIntN(BitWidth, 0));
   Value *Conv11 = Builder.CreateZExt(Cmp10, IntTy);
   Value *Or = Builder.CreateOr(Shr6, Conv11);
   Builder.CreateBr(SwEpilog);
 
   // sw.epilog:

llvm/lib/CodeGen/ExpandReductions.cpp

 //===--- ExpandReductions.cpp - Expand experimental reduction intrinsics --===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
case Intrinsic::vector_reduce_or: {
       unsigned NumElts = FTy->getNumElements();
       if (!isPowerOf2_32(NumElts))
         continue;
 
       if (FTy->getElementType() == Builder.getInt1Ty()) {
         Rdx = Builder.CreateBitCast(Vec, Builder.getIntNTy(NumElts));
         if (ID == Intrinsic::vector_reduce_and) {
           Rdx = Builder.CreateICmpEQ(
-              Rdx, ConstantInt::getAllOnesValue(Rdx->getType()));
+              Rdx, ConstantInt::getAllOnes(Rdx->getType()));
         } else {
           assert(ID == Intrinsic::vector_reduce_or && "Expected or reduction.");
           Rdx = Builder.CreateIsNotNull(Rdx);
         }
         break;
       }
 
       Rdx = getShuffleReduction(Builder, Vec, getOpcode(ID), RK);

llvm/lib/CodeGen/ExpandVectorPredication.cpp

 //===----- CodeGen/ExpandVectorPredication.cpp - Expand VP intrinsics -----===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
static Value *getNeutralReductionElement(const VPReductionIntrinsic &VPI,
   case Intrinsic::vp_reduce_or:
   case Intrinsic::vp_reduce_xor:
   case Intrinsic::vp_reduce_umax:
     return Constant::getNullValue(EltTy);
   case Intrinsic::vp_reduce_mul:
     return ConstantInt::get(EltTy, 1, /*IsSigned*/ false);
   case Intrinsic::vp_reduce_and:
   case Intrinsic::vp_reduce_umin:
-    return ConstantInt::getAllOnesValue(EltTy);
+    return ConstantInt::getAllOnes(EltTy);
   case Intrinsic::vp_reduce_smin:
     return ConstantInt::get(EltTy->getContext(),
                             APInt::getSignedMaxValue(EltBits));
   case Intrinsic::vp_reduce_smax:
     return ConstantInt::get(EltTy->getContext(),
                             APInt::getSignedMinValue(EltBits));
   case Intrinsic::vp_reduce_fmax:
     Negative = true;

llvm/lib/IR/AutoUpgrade.cpp

 //===-- AutoUpgrade.cpp - Implement auto-upgrade helper functions ---------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
if (!NewFn) {
     } else if (IsX86 &&
                (Name == "avx512.kortestz.w" || Name == "avx512.kortestc.w")) {
       Value *LHS = getX86MaskVec(Builder, CI->getArgOperand(0), 16);
       Value *RHS = getX86MaskVec(Builder, CI->getArgOperand(1), 16);
       Rep = Builder.CreateOr(LHS, RHS);
       Rep = Builder.CreateBitCast(Rep, Builder.getInt16Ty());
       Value *C;
       if (Name[14] == 'c')
-        C = ConstantInt::getAllOnesValue(Builder.getInt16Ty());
+        C = ConstantInt::getAllOnes(Builder.getInt16Ty());
       else
         C = ConstantInt::getNullValue(Builder.getInt16Ty());
       Rep = Builder.CreateICmpEQ(Rep, C);
       Rep = Builder.CreateZExt(Rep, Builder.getInt32Ty());
     } else if (IsX86 && (Name == "sse.add.ss" || Name == "sse2.add.sd" ||
                          Name == "sse.sub.ss" || Name == "sse2.sub.sd" ||
                          Name == "sse.mul.ss" || Name == "sse2.mul.sd" ||
                          Name == "sse.div.ss" || Name == "sse2.div.sd")) {

llvm/lib/IR/VectorBuilder.cpp

 //===- VectorBuilder.cpp - Builder for VP Intrinsics ----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //

 
 Module &VectorBuilder::getModule() const {
   return *Builder.GetInsertBlock()->getModule();
 }
 
 Value *VectorBuilder::getAllTrueMask() {
   auto *BoolTy = Builder.getInt1Ty();
   auto *MaskTy = VectorType::get(BoolTy, StaticVectorLength);
-  return ConstantInt::getAllOnesValue(MaskTy);
+  return ConstantInt::getAllOnes(MaskTy);
 }
 
 Value &VectorBuilder::requestMask() {
   if (Mask)
     return *Mask;
 
   return *getAllTrueMask();
 }

llvm/lib/Target/Hexagon/HexagonVectorCombine.cpp

 //===-- HexagonVectorCombine.cpp ------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // HexagonVectorCombine is a utility class implementing a variety of functions
auto HexagonVectorCombine::getNullValue(Type *Ty) const -> Constant * {
   auto Zero = ConstantInt::get(Ty->getScalarType(), 0);
   if (auto *VecTy = dyn_cast<VectorType>(Ty))
     return ConstantVector::getSplat(VecTy->getElementCount(), Zero);
   return Zero;
 }
 
 auto HexagonVectorCombine::getFullValue(Type *Ty) const -> Constant * {
   assert(Ty->isIntOrIntVectorTy());
-  auto Minus1 = ConstantInt::get(Ty->getScalarType(), -1);
+  auto Minus1 = ConstantInt::getAllOnes(Ty->getScalarType());
   if (auto *VecTy = dyn_cast<VectorType>(Ty))
     return ConstantVector::getSplat(VecTy->getElementCount(), Minus1);
   return Minus1;
 }
 
 auto HexagonVectorCombine::getConstSplat(Type *Ty, int Val) const
     -> Constant * {
   assert(Ty->isVectorTy());

llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp

 //===- InstCombineAddSub.cpp ------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
if (match(&I, m_c_BinOp(m_Value(A), m_OneUse(m_c_Or(m_Neg(m_Deferred(A)),
     return BinaryOperator::CreateAnd(Add, A);
   }
 
   // Canonicalize ((A & -A) - 1) --> ((A - 1) & ~A)
   // Forms all commutable operations, and simplifies ctpop -> cttz folds.
   if (match(&I,
             m_Add(m_OneUse(m_c_And(m_Value(A), m_OneUse(m_Neg(m_Deferred(A))))),
                   m_AllOnes()))) {
-    Constant *AllOnes = ConstantInt::getAllOnesValue(RHS->getType());
+    Constant *AllOnes = ConstantInt::getAllOnes(RHS->getType());
     Value *Dec = Builder.CreateAdd(A, AllOnes);
     Value *Not = Builder.CreateXor(A, AllOnes);
     return BinaryOperator::CreateAnd(Dec, Not);
   }
 
   // Disguised reassociation/factorization:
   // ~(A * C1) + A
   // ((A * -C1) - 1) + A
   // ((A * -C1) + A) - 1
   // (A * (1 - C1)) - 1
   if (match(&I,
             m_c_Add(m_OneUse(m_Not(m_OneUse(m_Mul(m_Value(A), m_APInt(C1))))),
                     m_Deferred(A)))) {
     Type *Ty = I.getType();
     Constant *NewMulC = ConstantInt::get(Ty, 1 - *C1);
     Value *NewMul = Builder.CreateMul(A, NewMulC);
-    return BinaryOperator::CreateAdd(NewMul, ConstantInt::getAllOnesValue(Ty));
+    return BinaryOperator::CreateAdd(NewMul, ConstantInt::getAllOnes(Ty));
   }
 
   // (A * -2**C) + B --> B - (A << C)
   const APInt *NegPow2C;
   if (match(&I, m_c_Add(m_OneUse(m_Mul(m_Value(A), m_NegatedPower2(NegPow2C))),
                         m_Value(B)))) {
     Constant *ShiftAmtC = ConstantInt::get(Ty, NegPow2C->countr_zero());
     Value *Shl = Builder.CreateShl(A, ShiftAmtC);

llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

 //===- InstCombineAndOrXor.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
Instruction *InstCombinerImpl::visitOr(BinaryOperator &I) {
 
   // or(sext(A), B) / or(B, sext(A)) --> A ? -1 : B, where A is i1 or <N x i1>.
   // TODO: Move this into foldBinopOfSextBoolToSelect as a more generalized fold
   //       with binop identity constant. But creating a select with non-constant
   //       arm may not be reversible due to poison semantics. Is that a good
   //       canonicalization?
   if (match(Op0, m_OneUse(m_SExt(m_Value(A)))) &&
       A->getType()->isIntOrIntVectorTy(1))
-    return SelectInst::Create(A, ConstantInt::getAllOnesValue(Ty), Op1);
+    return SelectInst::Create(A, ConstantInt::getAllOnes(Ty), Op1);
   if (match(Op1, m_OneUse(m_SExt(m_Value(A)))) &&
       A->getType()->isIntOrIntVectorTy(1))
-    return SelectInst::Create(A, ConstantInt::getAllOnesValue(Ty), Op0);
+    return SelectInst::Create(A, ConstantInt::getAllOnes(Ty), Op0);
 
   // Note: If we've gotten to the point of visiting the outer OR, then the
   // inner one couldn't be simplified.  If it was a constant, then it won't
   // be simplified by a later pass either, so we try swapping the inner/outer
   // ORs in the hopes that we'll be able to simplify it this way.
   // (X|C) | V --> (X|V) | C
   ConstantInt *CI;
   if (Op0->hasOneUse() && !match(Op1, m_ConstantInt()) &&
Instruction *InstCombinerImpl::visitOr(BinaryOperator &I) {
   // or(ashr(subNSW(Y, X), ScalarSizeInBits(Y) - 1), X)  --> X s> Y ? -1 : X.
   {
     Value *X, *Y;
     if (match(&I, m_c_Or(m_OneUse(m_AShr(
                              m_NSWSub(m_Value(Y), m_Value(X)),
                              m_SpecificInt(Ty->getScalarSizeInBits() - 1))),
                          m_Deferred(X)))) {
       Value *NewICmpInst = Builder.CreateICmpSGT(X, Y);
-      Value *AllOnes = ConstantInt::getAllOnesValue(Ty);
+      Value *AllOnes = ConstantInt::getAllOnes(Ty);
       return SelectInst::Create(NewICmpInst, AllOnes, X);
     }
   }
 
   if (Instruction *V =
           canonicalizeCondSignextOfHighBitExtractToSignextHighBitExtract(I))
     return V;
 
if (match(M, m_Not(m_Value(NotM)))) {
     Value *NewA = Builder.CreateAnd(D, NotM);
     return BinaryOperator::CreateXor(NewA, X);
   }
 
   Constant *C;
   if (D->hasOneUse() && match(M, m_Constant(C))) {
     // Propagating undef is unsafe. Clamp undef elements to -1.
     Type *EltTy = C->getType()->getScalarType();
-    C = Constant::replaceUndefsWith(C, ConstantInt::getAllOnesValue(EltTy));
+    C = Constant::replaceUndefsWith(C, ConstantInt::getAllOnes(EltTy));
     // Unfold.
     Value *LHS = Builder.CreateAnd(X, C);
     Value *NotC = Builder.CreateNot(C);
     Value *RHS = Builder.CreateAnd(B, NotC);
     return BinaryOperator::CreateOr(LHS, RHS);
   }
 
   return nullptr;
Instruction *InstCombinerImpl::foldNot(BinaryOperator &I) {
   }
 
   // Is this a 'not' (~) fed by a binary operator?
   BinaryOperator *NotVal;
   if (match(NotOp, m_BinOp(NotVal))) {
     // ~((-X) | Y) --> (X - 1) & (~Y)
     if (match(NotVal,
               m_OneUse(m_c_Or(m_OneUse(m_Neg(m_Value(X))), m_Value(Y))))) {
-      Value *DecX = Builder.CreateAdd(X, ConstantInt::getAllOnesValue(Ty));
+      Value *DecX = Builder.CreateAdd(X, ConstantInt::getAllOnes(Ty));
       Value *NotY = Builder.CreateNot(Y);
       return BinaryOperator::CreateAnd(DecX, NotY);
     }
 
     // ~(~X >>s Y) --> (X >>s Y)
     if (match(NotVal, m_AShr(m_Not(m_Value(X)), m_Value(Y))))
       return BinaryOperator::CreateAShr(X, Y);
 
if (match(NotOp, m_BinOp(NotVal))) {
 
     // ~(C >>s Y) --> ~C >>u Y (when inverting the replicated sign bits)
     Constant *C;
     if (match(NotVal, m_AShr(m_Constant(C), m_Value(Y))) &&
         match(C, m_Negative())) {
       // We matched a negative constant, so propagating undef is unsafe.
       // Clamp undef elements to -1.
       Type *EltTy = Ty->getScalarType();
-      C = Constant::replaceUndefsWith(C, ConstantInt::getAllOnesValue(EltTy));
+      C = Constant::replaceUndefsWith(C, ConstantInt::getAllOnes(EltTy));
       return BinaryOperator::CreateLShr(ConstantExpr::getNot(C), Y);
     }
 
     // ~(C >>u Y) --> ~C >>s Y (when inverting the replicated sign bits)
     if (match(NotVal, m_LShr(m_Constant(C), m_Value(Y))) &&
         match(C, m_NonNegative())) {
       // We matched a non-negative constant, so propagating undef is unsafe.
       // Clamp undef elements to 0.

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

 //===- InstCombineCalls.cpp -----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
case Intrinsic::vector_reduce_and: {
     Value *Vect;
     if (match(Arg, m_ZExtOrSExtOrSelf(m_Value(Vect)))) {
       if (auto *FTy = dyn_cast<FixedVectorType>(Vect->getType()))
         if (FTy->getElementType() == Builder.getInt1Ty()) {
           Value *Res = Builder.CreateBitCast(
               Vect, Builder.getIntNTy(FTy->getNumElements()));
           if (IID == Intrinsic::vector_reduce_and) {
             Res = Builder.CreateICmpEQ(
-                Res, ConstantInt::getAllOnesValue(Res->getType()));
+                Res, ConstantInt::getAllOnes(Res->getType()));
           } else {
             assert(IID == Intrinsic::vector_reduce_or &&
                    "Expected or reduction.");
             Res = Builder.CreateIsNotNull(Res);
           }
           if (Arg != Vect)
             Res = Builder.CreateCast(cast<CastInst>(Arg)->getOpcode(), Res,
                                      II->getType());

llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp

 //===- InstCombineCasts.cpp -----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
if (Cmp->hasOneUse() &&
 
       APInt KnownZeroMask(~Known.Zero);
       if (KnownZeroMask.isPowerOf2()) {
         Value *In = Cmp->getOperand(0);
 
         // If the icmp tests for a known zero bit we can constant fold it.
         if (!Op1C->isZero() && Op1C->getValue() != KnownZeroMask) {
           Value *V = Pred == ICmpInst::ICMP_NE ?
-                       ConstantInt::getAllOnesValue(Sext.getType()) :
+                       ConstantInt::getAllOnes(Sext.getType()) :
                        ConstantInt::getNullValue(Sext.getType());
           return replaceInstUsesWith(Sext, V);
         }
 
         if (!Op1C->isZero() == (Pred == ICmpInst::ICMP_NE)) {
           // sext ((x & 2^n) == 0)   -> (x >> n) - 1
           // sext ((x & 2^n) != 2^n) -> (x >> n) - 1
           unsigned ShiftAmt = KnownZeroMask.countr_zero();
           // Perform a right shift to place the desired bit in the LSB.
           if (ShiftAmt)
             In = Builder.CreateLShr(In,
                                     ConstantInt::get(In->getType(), ShiftAmt));
 
           // At this point "In" is either 1 or 0. Subtract 1 to turn
           // {1, 0} -> {0, -1}.
           In = Builder.CreateAdd(In,
-                                 ConstantInt::getAllOnesValue(In->getType()),
+                                 ConstantInt::getAllOnes(In->getType()),
                                  "sext");
         } else {
           // sext ((x & 2^n) != 0)   -> (x << bitwidth-n) a>> bitwidth-1
           // sext ((x & 2^n) == 2^n) -> (x << bitwidth-n) a>> bitwidth-1
           unsigned ShiftAmt = KnownZeroMask.countl_zero();
           // Perform a left shift to place the desired bit in the MSB.
           if (ShiftAmt)
             In = Builder.CreateShl(In,

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

 //===- InstCombineCompares.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
Instruction *InstCombinerImpl::foldCmpLoadFromIndexedGlobal(
   // 0x00..00, 0x80..00.
   // Emitting 'icmp eq Idx, 0' isn't correct in this case because the
   // comparison is false if Idx was 0x80..00.
   // We need to erase the highest countTrailingZeros(ElementSize) bits of Idx.
   unsigned ElementSize =
       DL.getTypeAllocSize(Init->getType()->getArrayElementType());
   auto MaskIdx = [&](Value *Idx) {
     if (!GEP->isInBounds() && llvm::countr_zero(ElementSize) != 0) {
-      Value *Mask = ConstantInt::get(Idx->getType(), -1);
+      Value *Mask = ConstantInt::getAllOnes(Idx->getType());
       Mask = Builder.CreateLShr(Mask, llvm::countr_zero(ElementSize));
       Idx = Builder.CreateAnd(Idx, Mask);
     }
     return Idx;
   };
 
   // If the comparison is only true for one or two elements, emit direct
   // comparisons.
Instruction *InstCombinerImpl::foldICmpTruncConstant(ICmpInst &Cmp,
   const APInt *ShAmtC;
   bool TrueIfSigned;
   if (isSignBitCheck(Pred, C, TrueIfSigned) &&
       match(X, m_Shr(m_Value(ShOp), m_APInt(ShAmtC))) &&
       DstBits == SrcBits - ShAmtC->getZExtValue()) {
     return TrueIfSigned ? new ICmpInst(ICmpInst::ICMP_SLT, ShOp,
                                        ConstantInt::getNullValue(SrcTy))
                         : new ICmpInst(ICmpInst::ICMP_SGT, ShOp,
-                                       ConstantInt::getAllOnesValue(SrcTy));
+                                       ConstantInt::getAllOnes(SrcTy));
   }
 
   return nullptr;
 }
 
 /// Fold icmp (xor X, Y), C.
 Instruction *InstCombinerImpl::foldICmpXorConstant(ICmpInst &Cmp,
                                                    BinaryOperator *Xor,
if (isSignBitCheck(Cmp.getPredicate(), C, TrueIfSigned)) {
     // If the sign bit of the XorCst is not set, there is no change to
     // the operation, just stop using the Xor.
     if (!XorC->isNegative())
       return replaceOperand(Cmp, 0, X);
 
     // Emit the opposite comparison.
     if (TrueIfSigned)
       return new ICmpInst(ICmpInst::ICMP_SGT, X,
-                          ConstantInt::getAllOnesValue(X->getType()));
+                          ConstantInt::getAllOnes(X->getType()));
     else
       return new ICmpInst(ICmpInst::ICMP_SLT, X,
                           ConstantInt::getNullValue(X->getType()));
   }
 
   if (Xor->hasOneUse()) {
     // (icmp u/s (xor X SignMask), C) -> (icmp s/u X, (xor C SignMask))
     if (!Cmp.isEquality() && XorC->isSignMask()) {
if (IsAShr) {
     // (ashr X, ShiftC) u< C --> X s> -1
     if (C.getBitWidth() > 2 && C.getNumSignBits() <= ShAmtVal) {
       if (Pred == CmpInst::ICMP_UGT) {
         return new ICmpInst(CmpInst::ICMP_SLT, X,
                             ConstantInt::getNullValue(ShrTy));
       }
       if (Pred == CmpInst::ICMP_ULT) {
         return new ICmpInst(CmpInst::ICMP_SGT, X,
-                            ConstantInt::getAllOnesValue(ShrTy));
+                            ConstantInt::getAllOnes(ShrTy));
       }
     }
   } else {
     if (Pred == CmpInst::ICMP_ULT || (Pred == CmpInst::ICMP_UGT && IsExact)) {
       // icmp ult (lshr X, ShAmtC), C --> icmp ult X, (C << ShAmtC)
       // icmp ugt (lshr exact X, ShAmtC), C --> icmp ugt X, (C << ShAmtC)
       APInt ShiftedC = C.shl(ShAmtVal);
       if (ShiftedC.lshr(ShAmtVal) == C)
if (match(BCSrcOp, m_SIToFP(m_Value(X)))) {
 
       // icmp slt (bitcast (sitofp X)), 1 --> icmp slt X, 1
       if (Pred == ICmpInst::ICMP_SLT && match(Op1, m_One()))
         return new ICmpInst(Pred, X, ConstantInt::get(X->getType(), 1));
 
       // icmp sgt (bitcast (sitofp X)), -1 --> icmp sgt X, -1
       if (Pred == ICmpInst::ICMP_SGT && match(Op1, m_AllOnes()))
         return new ICmpInst(Pred, X,
-                            ConstantInt::getAllOnesValue(X->getType()));
+                            ConstantInt::getAllOnes(X->getType()));
     }
 
     // Zero-equality checks are preserved through unsigned floating-point casts:
     // icmp eq (bitcast (uitofp X)), 0 --> icmp eq X, 0
     // icmp ne (bitcast (uitofp X)), 0 --> icmp ne X, 0
     if (match(BCSrcOp, m_UIToFP(m_Value(X))))
       if (Cmp.isEquality() && match(Op1, m_Zero()))
         return new ICmpInst(Pred, X, ConstantInt::getNullValue(X->getType()));
if (match(Op1, m_APInt(C)) && Bitcast->hasOneUse() &&
           if (auto *XVTy = dyn_cast<VectorType>(XType))
             NewType = VectorType::get(NewType, XVTy->getElementCount());
           Value *NewBitcast = Builder.CreateBitCast(X, NewType);
           if (TrueIfSigned)
             return new ICmpInst(ICmpInst::ICMP_SLT, NewBitcast,
                                 ConstantInt::getNullValue(NewType));
           else
             return new ICmpInst(ICmpInst::ICMP_SGT, NewBitcast,
-                                ConstantInt::getAllOnesValue(NewType));
+                                ConstantInt::getAllOnes(NewType));
         }
       }
     }
   }
 
   // Test to see if the operands of the icmp are casted versions of other
   // values. If the ptr->ptr cast can be stripped off both arguments, do so.
   if (DstType->isPointerTy() && (isa<Constant>(Op1) || isa<BitCastInst>(Op1))) {
Instruction *InstCombinerImpl::foldICmpIntrinsicWithConstant(ICmpInst &Cmp,
   unsigned BitWidth = C.getBitWidth();
   ICmpInst::Predicate Pred = Cmp.getPredicate();
   switch (II->getIntrinsicID()) {
   case Intrinsic::ctpop: {
     // (ctpop X > BitWidth - 1) --> X == -1
     Value *X = II->getArgOperand(0);
     if (C == BitWidth - 1 && Pred == ICmpInst::ICMP_UGT)
       return CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_EQ, X,
-                             ConstantInt::getAllOnesValue(Ty));
+                             ConstantInt::getAllOnes(Ty));
     // (ctpop X < BitWidth) --> X != -1
     if (C == BitWidth && Pred == ICmpInst::ICMP_ULT)
       return CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_NE, X,
-                             ConstantInt::getAllOnesValue(Ty));
+                             ConstantInt::getAllOnes(Ty));
     break;
   }
   case Intrinsic::ctlz: {
     // ctlz(0bXXXXXXXX) > 3 -> 0bXXXXXXXX < 0b00010000
     if (Pred == ICmpInst::ICMP_UGT && C.ult(BitWidth)) {
       unsigned Num = C.getLimitedValue();
       APInt Limit = APInt::getOneBitSet(BitWidth, BitWidth - Num - 1);
       return CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_ULT,

llvm/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

 //===- InstCombineMulDivRem.cpp -------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
Instruction *InstCombinerImpl::visitUDiv(BinaryOperator &I) {
   // TODO: Could use isKnownNegative() to handle non-constant values.
   Type *Ty = I.getType();
   if (match(Op1, m_Negative())) {
     Value *Cmp = Builder.CreateICmpUGE(Op0, Op1);
     return CastInst::CreateZExtOrBitCast(Cmp, Ty);
   }
   // Op0 / (sext i1 X) --> zext (Op0 == -1) (if X is 0, the div is undefined)
   if (match(Op1, m_SExt(m_Value(X))) && X->getType()->isIntOrIntVectorTy(1)) {
-    Value *Cmp = Builder.CreateICmpEQ(Op0, ConstantInt::getAllOnesValue(Ty));
+    Value *Cmp = Builder.CreateICmpEQ(Op0, ConstantInt::getAllOnes(Ty));
     return CastInst::CreateZExtOrBitCast(Cmp, Ty);
   }
 
   if (Instruction *NarrowDiv = narrowUDivURem(I, Builder))
     return NarrowDiv;
 
   // If the udiv operands are non-overflowing multiplies with a common operand,
   // then eliminate the common factor:
Instruction *InstCombinerImpl::visitSDiv(BinaryOperator &I) {
 
   // abs(X) / X --> X > -1 ? 1 : -1
   // X / abs(X) --> X > -1 ? 1 : -1
   if (match(&I, m_c_BinOp(
                     m_OneUse(m_Intrinsic<Intrinsic::abs>(m_Value(X), m_One())),
                     m_Deferred(X)))) {
     Value *Cond = Builder.CreateIsNotNeg(X);
     return SelectInst::Create(Cond, ConstantInt::get(Ty, 1),
-                              ConstantInt::getAllOnesValue(Ty));
+                              ConstantInt::getAllOnes(Ty));
   }
 
   KnownBits KnownDividend = computeKnownBits(Op0, 0, &I);
   if (!I.isExact() &&
       (match(Op1, m_Power2(Op1C)) || match(Op1, m_NegatedPower2(Op1C))) &&
       KnownDividend.countMinTrailingZeros() >= Op1C->countr_zero()) {
     I.setIsExact();
     return &I;
Instruction *InstCombinerImpl::visitURem(BinaryOperator &I) {
   }
 
   // If the divisor is a sext of a boolean, then the divisor must be max
   // unsigned value (-1). Therefore, the remainder is Op0 unless Op0 is also
   // max unsigned value. In that case, the remainder is 0:
   // urem Op0, (sext i1 X) --> (Op0 == -1) ? 0 : Op0
   Value *X;
   if (match(Op1, m_SExt(m_Value(X))) && X->getType()->isIntOrIntVectorTy(1)) {
-    Value *Cmp = Builder.CreateICmpEQ(Op0, ConstantInt::getAllOnesValue(Ty));
+    Value *Cmp = Builder.CreateICmpEQ(Op0, ConstantInt::getAllOnes(Ty));
     return SelectInst::Create(Cmp, ConstantInt::getNullValue(Ty), Op0);
   }
 
   // For "(X + 1) % Op1" and if (X u< Op1) => (X + 1) == Op1 ? 0 : X + 1 .
   if (match(Op0, m_Add(m_Value(X), m_One()))) {
     Value *Val =
         simplifyICmpInst(ICmpInst::ICMP_ULT, X, Op1, SQ.getWithInstruction(&I));
     if (Val && match(Val, m_One())) {

llvm/lib/Transforms/InstCombine/InstCombineShifts.cpp

 //===- InstCombineShifts.cpp ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
if (!I.hasNoSignedWrap() && ComputeNumSignBits(Op0, 0, &I) > ShAmtC) {
       return &I;
     }
   }
 
   // Transform  (x >> y) << y  to  x & (-1 << y)
   // Valid for any type of right-shift.
   Value *X;
   if (match(Op0, m_OneUse(m_Shr(m_Value(X), m_Specific(Op1))))) {
-    Constant *AllOnes = ConstantInt::getAllOnesValue(Ty);
+    Constant *AllOnes = ConstantInt::getAllOnes(Ty);
     Value *Mask = Builder.CreateShl(AllOnes, Op1);
     return BinaryOperator::CreateAnd(Mask, X);
   }
 
   Constant *C1;
   if (match(Op1, m_Constant(C1))) {
     Constant *C2;
     Value *X;
if (!I.isExact() &&
         MaskedValueIsZero(Op0, APInt::getLowBitsSet(BitWidth, ShAmtC), 0, &I)) {
       I.setIsExact();
       return &I;
     }
   }
 
   // Transform  (x << y) >> y  to  x & (-1 >> y)
   if (match(Op0, m_OneUse(m_Shl(m_Value(X), m_Specific(Op1))))) {
-    Constant *AllOnes = ConstantInt::getAllOnesValue(Ty);
+    Constant *AllOnes = ConstantInt::getAllOnes(Ty);
     Value *Mask = Builder.CreateLShr(AllOnes, Op1);
     return BinaryOperator::CreateAnd(Mask, X);
   }
 
   if (Instruction *Overflow = foldLShrOverflowBit(I))
     return Overflow;
 
   return nullptr;

llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp

 //===- InstCombineSimplifyDemanded.cpp ------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
case Instruction::Xor: {
 
     // If the RHS is a constant, see if we can change it. Don't alter a -1
     // constant because that's a canonical 'not' op, and that is better for
     // combining, SCEV, and codegen.
     const APInt *C;
     if (match(I->getOperand(1), m_APInt(C)) && !C->isAllOnes()) {
       if ((*C | ~DemandedMask).isAllOnes()) {
         // Force bits to 1 to create a 'not' op.
-        I->setOperand(1, ConstantInt::getAllOnesValue(VTy));
+        I->setOperand(1, ConstantInt::getAllOnes(VTy));
         return I;
       }
       // If we can't turn this into a 'not', try to shrink the constant.
       if (ShrinkDemandedConstant(I, 1, DemandedMask))
         return I;
     }
 
     // If our LHS is an 'and' and if it has one use, and if any of the bits we

llvm/lib/Transforms/InstCombine/InstCombineVectorOps.cpp

 //===- InstCombineVectorOps.cpp -------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
case Instruction::Or: {
     const APInt *C;
     if (match(BO1, m_APInt(C)) && MaskedValueIsZero(BO0, *C, DL))
       return {Instruction::Add, BO0, BO1};
     break;
   }
   case Instruction::Sub:
     // sub 0, X --> mul X, -1
     if (match(BO0, m_ZeroInt()))
-      return {Instruction::Mul, BO1, ConstantInt::getAllOnesValue(Ty)};
+      return {Instruction::Mul, BO1, ConstantInt::getAllOnes(Ty)};
     break;
   default:
     break;
   }
   return {};
 }
 
 /// A select shuffle of a select shuffle with a shared operand can be reduced

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

 //===- InstructionCombining.cpp - Combine multiple instructions -----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
Instruction *InstCombinerImpl::foldBinopOfSextBoolToSelect(BinaryOperator &BO) {
   Value *BO1 = BO.getOperand(1);
   Value *X;
   Constant *C;
   if (!match(BO0, m_SExt(m_Value(X))) || !match(BO1, m_ImmConstant(C)) ||
       !X->getType()->isIntOrIntVectorTy(1))
     return nullptr;
 
   // bo (sext i1 X), C --> select X, (bo -1, C), (bo 0, C)
-  Constant *Ones = ConstantInt::getAllOnesValue(BO.getType());
+  Constant *Ones = ConstantInt::getAllOnes(BO.getType());
   Constant *Zero = ConstantInt::getNullValue(BO.getType());
   Value *TVal = Builder.CreateBinOp(BO.getOpcode(), Ones, C);
   Value *FVal = Builder.CreateBinOp(BO.getOpcode(), Zero, C);
   return SelectInst::Create(X, TVal, FVal);
 }
 
 static Constant *constantFoldOperationIntoSelectOperand(
     Instruction &I, SelectInst *SI, Value *SO) {
Instruction *InstCombinerImpl::visitFreeze(FreezeInst &I) {
   // TODO: This could use getBinopAbsorber() / getBinopIdentity() to avoid
   //       duplicating logic for binops at least.
   auto getUndefReplacement = [&I](Type *Ty) {
     Constant *BestValue = nullptr;
     Constant *NullValue = Constant::getNullValue(Ty);
     for (const auto *U : I.users()) {
       Constant *C = NullValue;
       if (match(U, m_Or(m_Value(), m_Value())))
-        C = ConstantInt::getAllOnesValue(Ty);
+        C = ConstantInt::getAllOnes(Ty);
       else if (match(U, m_Select(m_Specific(&I), m_Constant(), m_Value())))
         C = ConstantInt::getTrue(Ty);
 
       if (!BestValue)
         BestValue = C;
       else if (BestValue != C)
         BestValue = NullValue;
     }

llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp

 //===- AddressSanitizer.cpp - memory error detector -----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
if (CanUsePrivateAliases && UsePrivateAlias) {
       // Create local alias for NewGlobal to avoid crash on ODR between
       // instrumented and non-instrumented libraries.
       InstrumentedGlobal =
           GlobalAlias::create(GlobalValue::PrivateLinkage, "", NewGlobal);
     }
 
     // ODR should not happen for local linkage.
     if (NewGlobal->hasLocalLinkage()) {
-      ODRIndicator = ConstantExpr::getIntToPtr(ConstantInt::get(IntptrTy, -1),
-                                               IRB.getInt8PtrTy());
+      ODRIndicator = ConstantExpr::getIntToPtr(
+          ConstantInt::getAllOnes(IntptrTy), IRB.getInt8PtrTy());
     } else if (UseOdrIndicator) {
       // With local aliases, we need to provide another externally visible
       // symbol __odr_asan_XXX to detect ODR violation.
       auto *ODRIndicatorSym =
           new GlobalVariable(M, IRB.getInt8Ty(), false, Linkage,
                              Constant::getNullValue(IRB.getInt8Ty()),
                              kODRGenPrefix + NameForGlobal, nullptr,
                              NewGlobal->getThreadLocalMode());

llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

 //===- HWAddressSanitizer.cpp - detector of uninitialized reads -------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
case instr: {
       // buffer in pages, it must be a power of two, and the start of the buffer
       // must be aligned by twice that much. Therefore wrap around of the ring
       // buffer is simply Addr &= ~((ThreadLong >> 56) << 12).
       // The use of AShr instead of LShr is due to
       //   https://bugs.llvm.org/show_bug.cgi?id=39030
       // Runtime library makes sure not to use the highest bit.
       Value *WrapMask = IRB.CreateXor(
           IRB.CreateShl(IRB.CreateAShr(ThreadLong, 56), 12, "", true, true),
-          ConstantInt::get(IntptrTy, (uint64_t)-1));
+          ConstantInt::getAllOnes(IntptrTy));
       Value *ThreadLongNew = IRB.CreateAnd(
           IRB.CreateAdd(ThreadLong, ConstantInt::get(IntptrTy, 8)), WrapMask);
       IRB.CreateStore(ThreadLongNew, SlotPtr);
       break;
     }
     case none: {
       llvm_unreachable(
           "A stack history recording mode should've been selected.");

llvm/lib/Transforms/Instrumentation/SanitizerCoverage.cpp

 //===-- SanitizerCoverage.cpp - coverage instrumentation for sanitizers ---===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
for (auto &BB : F) {
 
     CFs.push_back((Constant *)Constant::getNullValue(IntptrPtrTy));
 
     for (auto &Inst : BB) {
       if (CallBase *CB = dyn_cast<CallBase>(&Inst)) {
         if (CB->isIndirectCall()) {
           // TODO(navidem): handle indirect calls, for now mark its existence.
           CFs.push_back((Constant *)IRB.CreateIntToPtr(
-              ConstantInt::get(IntptrTy, -1), IntptrPtrTy));
+              ConstantInt::getAllOnes(IntptrTy), IntptrPtrTy));
         } else {
           auto CalledF = CB->getCalledFunction();
           if (CalledF && !CalledF->isIntrinsic())
             CFs.push_back(
                 (Constant *)IRB.CreatePointerCast(CalledF, IntptrPtrTy));
         }
       }
     }

llvm/lib/Transforms/Scalar/ConstraintElimination.cpp

 //===-- ConstraintElimination.cpp - Eliminate conds using constraints. ----===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
if (doesHold(CmpInst::ICMP_SGE, B, ConstantInt::get(B->getType(), 0))) {
       addFact(CmpInst::ICMP_SLT, A, B, NumIn, NumOut, DFSInStack);
     }
     break;
   case CmpInst::ICMP_SLT:
     if (doesHold(CmpInst::ICMP_SGE, A, ConstantInt::get(B->getType(), 0)))
       addFact(CmpInst::ICMP_ULT, A, B, NumIn, NumOut, DFSInStack);
     break;
   case CmpInst::ICMP_SGT:
-    if (doesHold(CmpInst::ICMP_SGE, B, ConstantInt::get(B->getType(), -1)))
+    if (doesHold(CmpInst::ICMP_SGE, B, ConstantInt::getAllOnes(B->getType())))
       addFact(CmpInst::ICMP_UGE, A, ConstantInt::get(B->getType(), 0), NumIn,
               NumOut, DFSInStack);
     break;
   case CmpInst::ICMP_SGE:
     if (doesHold(CmpInst::ICMP_SGE, B, ConstantInt::get(B->getType(), 0))) {
       addFact(CmpInst::ICMP_UGE, A, B, NumIn, NumOut, DFSInStack);
     }
     break;

llvm/lib/Transforms/Scalar/LoopStrengthReduce.cpp

 //===- LoopStrengthReduce.cpp - Strength Reduce IVs in Loops --------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
static void DoInitialMatch(const SCEV *S, Loop *L,
   if (const SCEVMulExpr *Mul = dyn_cast<SCEVMulExpr>(S))
     if (Mul->getOperand(0)->isAllOnesValue()) {
       SmallVector<const SCEV *, 4> Ops(drop_begin(Mul->operands()));
       const SCEV *NewMul = SE.getMulExpr(Ops);
 
       SmallVector<const SCEV *, 4> MyGood;
       SmallVector<const SCEV *, 4> MyBad;
       DoInitialMatch(NewMul, L, MyGood, MyBad, SE);
-      const SCEV *NegOne = SE.getSCEV(ConstantInt::getAllOnesValue(
+      const SCEV *NegOne = SE.getSCEV(ConstantInt::getAllOnes(
         SE.getEffectiveSCEVType(NewMul->getType())));
       for (const SCEV *S : MyGood)
         Good.push_back(SE.getMulExpr(NegOne, S));
       for (const SCEV *S : MyBad)
         Bad.push_back(SE.getMulExpr(NegOne, S));
       return;
     }
 

llvm/lib/Transforms/Scalar/Reassociate.cpp

 //===- Reassociate.cpp - Reassociate binary expressions -------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //

 
 /// Replace 0-X with X*-1.
 static BinaryOperator *LowerNegateToMultiply(Instruction *Neg) {
   assert((isa<UnaryOperator>(Neg) || isa<BinaryOperator>(Neg)) &&
          "Expected a Negate!");
   // FIXME: It's not safe to lower a unary FNeg into a FMul by -1.0.
   unsigned OpNo = isa<BinaryOperator>(Neg) ? 1 : 0;
   Type *Ty = Neg->getType();
-  Constant *NegOne = Ty->isIntOrIntVectorTy() ?
-    ConstantInt::getAllOnesValue(Ty) : ConstantFP::get(Ty, -1.0);
+  Constant *NegOne = Ty->isIntOrIntVectorTy() ? ConstantInt::getAllOnes(Ty)
+                                              : ConstantFP::get(Ty, -1.0);
 
   BinaryOperator *Res = CreateMul(Neg->getOperand(OpNo), NegOne, "", Neg, Neg);
   Neg->setOperand(OpNo, Constant::getNullValue(Ty)); // Drop use of op.
   Res->takeName(Neg);
   Neg->replaceAllUsesWith(Res);
   Res->setDebugLoc(Neg->getDebugLoc());
   return Res;
 }

llvm/lib/Transforms/Utils/CodeExtractor.cpp

 //===- CodeExtractor.cpp - Pull code region into a new function -----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //

 }
 
 /// Insert lifetime start/end markers surrounding the call to the new function
 /// for objects defined in the caller.
 static void insertLifetimeMarkersSurroundingCall(
     Module *M, ArrayRef<Value *> LifetimesStart, ArrayRef<Value *> LifetimesEnd,
     CallInst *TheCall) {
   LLVMContext &Ctx = M->getContext();
-  auto NegativeOne = ConstantInt::getSigned(Type::getInt64Ty(Ctx), -1);
+  auto NegativeOne = ConstantInt::getAllOnes(Type::getInt64Ty(Ctx));
   Instruction *Term = TheCall->getParent()->getTerminator();
 
   // Emit lifetime markers for the pointers given in \p Objects. Insert the
   // markers before the call if \p InsertBefore, and after the call otherwise.
   auto insertMarkers = [&](Intrinsic::ID MarkerFunc, ArrayRef<Value *> Objects,
                            bool InsertBefore) {
     for (Value *Mem : Objects) {
       assert((!isa<Instruction>(Mem) || cast<Instruction>(Mem)->getFunction() ==

llvm/lib/Transforms/Utils/IntegerDivision.cpp

 //===-- IntegerDivision.cpp - Expand integer division ---------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
static Value *generateUnsignedDivisionCode(Value *Dividend, Value *Divisor,
   // that's been hand-tuned to lessen the amount of control flow involved.
 
   // Some helper values
   IntegerType *DivTy = cast<IntegerType>(Dividend->getType());
   unsigned BitWidth = DivTy->getBitWidth();
 
   ConstantInt *Zero = ConstantInt::get(DivTy, 0);
   ConstantInt *One = ConstantInt::get(DivTy, 1);
-  ConstantInt *NegOne = ConstantInt::getSigned(DivTy, -1);
+  ConstantInt *NegOne = ConstantInt::getAllOnes(DivTy);
   ConstantInt *MSB = ConstantInt::get(DivTy, BitWidth - 1);
 
   ConstantInt *True = Builder.getTrue();
 
   BasicBlock *IBB = Builder.GetInsertBlock();
   Function *F = IBB->getParent();
   Function *CTLZ = Intrinsic::getDeclaration(F->getParent(), Intrinsic::ctlz,
                                              DivTy);

llvm/lib/Transforms/Utils/LoopUnrollRuntime.cpp

 //===-- UnrollLoopRuntime.cpp - Runtime Loop unrolling utilities ----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
bool llvm::UnrollRuntimeLoopRemainder(
   // In this case, freeze the TripCount and base BECount on the frozen
   // TripCount. We will introduce two branches using these values, and it's
   // important that they see a consistent value (which would not be guaranteed
   // if were frozen independently.)
   if ((!OtherExits.empty() || !SE->loopHasNoAbnormalExits(L)) &&
       !isGuaranteedNotToBeUndefOrPoison(TripCount, AC, PreHeaderBR, DT)) {
     TripCount = B.CreateFreeze(TripCount);
     BECount =
-        B.CreateAdd(TripCount, ConstantInt::get(TripCount->getType(), -1));
+        B.CreateAdd(TripCount, ConstantInt::getAllOnes(TripCount->getType()));
   } else {
     // If we don't need to freeze, use SCEVExpander for BECount as well, to
     // allow slightly better value reuse.
     BECount =
         Expander.expandCodeFor(BECountSC, BECountSC->getType(), PreHeaderBR);
   }
 
   Value * const ModVal = CreateTripRemainder(B, BECount, TripCount, Count);

llvm/tools/llvm-stress/llvm-stress.cpp

 //===- llvm-stress.cpp - Generate random LL files to stress-test LLVM -----===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
protected:
   Value *getRandomVal() {
     assert(PT->size());
     return PT->at(getRandom() % PT->size());
   }
 
   Constant *getRandomConstant(Type *Tp) {
     if (Tp->isIntegerTy()) {
       if (getRandom() & 1)
-        return ConstantInt::getAllOnesValue(Tp);
+        return ConstantInt::getAllOnes(Tp);
       return ConstantInt::getNullValue(Tp);
     } else if (Tp->isFloatingPointTy()) {
       if (getRandom() & 1)
         return ConstantFP::getAllOnesValue(Tp);
       return ConstantFP::getZero(Tp);
     }
     return UndefValue::get(Tp);
   }
 
   /// Return a random value with a known type.
   Value *getRandomValue(Type *Tp) {
     unsigned index = getRandom();
     for (unsigned i=0; i<PT->size(); ++i) {
       Value *V = PT->at((index + i) % PT->size());
       if (V->getType() == Tp)
         return V;
     }
 
     // If the requested type was not found, generate a constant value.
     if (Tp->isIntegerTy()) {
       if (getRandom() & 1)
-        return ConstantInt::getAllOnesValue(Tp);
+        return ConstantInt::getAllOnes(Tp);
       return ConstantInt::getNullValue(Tp);
     } else if (Tp->isFloatingPointTy()) {
       if (getRandom() & 1)
         return ConstantFP::getAllOnesValue(Tp);
       return ConstantFP::getZero(Tp);
     } else if (auto *VTp = dyn_cast<FixedVectorType>(Tp)) {
       std::vector<Constant*> TempValues;
       TempValues.reserve(VTp->getNumElements());

llvm/unittests/Analysis/ScalarEvolutionTest.cpp

 //===- ScalarEvolutionsTest.cpp - ScalarEvolution unit tests --------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
auto *Cmp = CmpInst::Create(Instruction::ICmp, CmpInst::ICMP_SGT, PN,
                                 ConstantInt::get(Context, APInt(64, 90)), "cmp",
                                 CondBB);
     BasicBlock *NextBB;
     if (i != Iters - 1)
       NextBB = BasicBlock::Create(Context, "for.cond", F, EndBB);
     else
       NextBB = EndBB;
     BranchInst::Create(IncBB, NextBB, Cmp, CondBB);
-    auto *Dec = BinaryOperator::CreateNSWAdd(
-        PN, ConstantInt::get(Context, APInt(64, -1)), "dec", IncBB);
+    auto *Dec = BinaryOperator::CreateNSWAdd(PN, ConstantInt::getAllOnes(I64Ty),
+                                             "dec", IncBB);
     PN->addIncoming(Dec, IncBB);
     BranchInst::Create(CondBB, IncBB);
 
     Accum = GetElementPtrInst::Create(I8Ty, Accum, PN, "gep", EndBB);
 
     PrevBB = CondBB;
     CondBB = NextBB;
   }

llvm/unittests/IR/PatternMatch.cpp

 //===---- llvm/unittest/IR/PatternMatch.cpp - PatternMatch unit tests ----===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 

 }
 
 TEST_F(PatternMatchTest, SpecificIntEQ) {
   Type *IntTy = IRB.getInt32Ty();
   unsigned BitWidth = IntTy->getScalarSizeInBits();
 
   Value *Zero = ConstantInt::get(IntTy, 0);
   Value *One = ConstantInt::get(IntTy, 1);
-  Value *NegOne = ConstantInt::get(IntTy, -1);
+  Value *NegOne = ConstantInt::getAllOnes(IntTy);
 
   EXPECT_TRUE(
       m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ, APInt(BitWidth, 0))
           .match(Zero));
   EXPECT_FALSE(
       m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_EQ, APInt(BitWidth, 0))
           .match(One));
   EXPECT_FALSE(

 }
 
 TEST_F(PatternMatchTest, SpecificIntNE) {
   Type *IntTy = IRB.getInt32Ty();
   unsigned BitWidth = IntTy->getScalarSizeInBits();
 
   Value *Zero = ConstantInt::get(IntTy, 0);
   Value *One = ConstantInt::get(IntTy, 1);
-  Value *NegOne = ConstantInt::get(IntTy, -1);
+  Value *NegOne = ConstantInt::getAllOnes(IntTy);
 
   EXPECT_FALSE(
       m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE, APInt(BitWidth, 0))
           .match(Zero));
   EXPECT_TRUE(
       m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_NE, APInt(BitWidth, 0))
           .match(One));
   EXPECT_TRUE(

 }
 
 TEST_F(PatternMatchTest, SpecificIntUGT) {
   Type *IntTy = IRB.getInt32Ty();
   unsigned BitWidth = IntTy->getScalarSizeInBits();
 
   Value *Zero = ConstantInt::get(IntTy, 0);
   Value *One = ConstantInt::get(IntTy, 1);
-  Value *NegOne = ConstantInt::get(IntTy, -1);
+  Value *NegOne = ConstantInt::getAllOnes(IntTy);
 
   EXPECT_FALSE(
       m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT, APInt(BitWidth, 0))
           .match(Zero));
   EXPECT_TRUE(
       m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGT, APInt(BitWidth, 0))
           .match(One));
   EXPECT_TRUE(
EXPECT_FALSE(
           .match(NegOne));
 }
 
 TEST_F(PatternMatchTest, SignbitZeroChecks) {
   Type *IntTy = IRB.getInt32Ty();
 
   Value *Zero = ConstantInt::get(IntTy, 0);
   Value *One = ConstantInt::get(IntTy, 1);
-  Value *NegOne = ConstantInt::get(IntTy, -1);
+  Value *NegOne = ConstantInt::getAllOnes(IntTy);
 
   EXPECT_TRUE(m_Negative().match(NegOne));
   EXPECT_FALSE(m_NonNegative().match(NegOne));
   EXPECT_FALSE(m_StrictlyPositive().match(NegOne));
   EXPECT_TRUE(m_NonPositive().match(NegOne));
 
   EXPECT_FALSE(m_Negative().match(Zero));
   EXPECT_TRUE(m_NonNegative().match(Zero));
   EXPECT_FALSE(m_StrictlyPositive().match(Zero));
   EXPECT_TRUE(m_NonPositive().match(Zero));
 
   EXPECT_FALSE(m_Negative().match(One));
   EXPECT_TRUE(m_NonNegative().match(One));
   EXPECT_TRUE(m_StrictlyPositive().match(One));
   EXPECT_FALSE(m_NonPositive().match(One));
 }
 
 TEST_F(PatternMatchTest, SpecificIntUGE) {
   Type *IntTy = IRB.getInt32Ty();
   unsigned BitWidth = IntTy->getScalarSizeInBits();
 
   Value *Zero = ConstantInt::get(IntTy, 0);
   Value *One = ConstantInt::get(IntTy, 1);
-  Value *NegOne = ConstantInt::get(IntTy, -1);
+  Value *NegOne = ConstantInt::getAllOnes(IntTy);
 
   EXPECT_TRUE(
       m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE, APInt(BitWidth, 0))
           .match(Zero));
   EXPECT_TRUE(
       m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_UGE, APInt(BitWidth, 0))
           .match(One));
   EXPECT_TRUE(

 }
 
 TEST_F(PatternMatchTest, SpecificIntULT) {
   Type *IntTy = IRB.getInt32Ty();
   unsigned BitWidth = IntTy->getScalarSizeInBits();
 
   Value *Zero = ConstantInt::get(IntTy, 0);
   Value *One = ConstantInt::get(IntTy, 1);
-  Value *NegOne = ConstantInt::get(IntTy, -1);
+  Value *NegOne = ConstantInt::getAllOnes(IntTy);
 
   EXPECT_FALSE(
       m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, APInt(BitWidth, 0))
           .match(Zero));
   EXPECT_FALSE(
       m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULT, APInt(BitWidth, 0))
           .match(One));
   EXPECT_FALSE(

 }
 
 TEST_F(PatternMatchTest, SpecificIntULE) {
   Type *IntTy = IRB.getInt32Ty();
   unsigned BitWidth = IntTy->getScalarSizeInBits();
 
   Value *Zero = ConstantInt::get(IntTy, 0);
   Value *One = ConstantInt::get(IntTy, 1);
-  Value *NegOne = ConstantInt::get(IntTy, -1);
+  Value *NegOne = ConstantInt::getAllOnes(IntTy);
 
   EXPECT_TRUE(
       m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE, APInt(BitWidth, 0))
           .match(Zero));
   EXPECT_FALSE(
       m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_ULE, APInt(BitWidth, 0))
           .match(One));
   EXPECT_FALSE(

 }
 
 TEST_F(PatternMatchTest, SpecificIntSGT) {
   Type *IntTy = IRB.getInt32Ty();
   unsigned BitWidth = IntTy->getScalarSizeInBits();
 
   Value *Zero = ConstantInt::get(IntTy, 0);
   Value *One = ConstantInt::get(IntTy, 1);
-  Value *NegOne = ConstantInt::get(IntTy, -1);
+  Value *NegOne = ConstantInt::getAllOnes(IntTy);
 
   EXPECT_FALSE(
       m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT, APInt(BitWidth, 0))
           .match(Zero));
   EXPECT_TRUE(
       m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGT, APInt(BitWidth, 0))
           .match(One));
   EXPECT_FALSE(

 }
 
 TEST_F(PatternMatchTest, SpecificIntSGE) {
   Type *IntTy = IRB.getInt32Ty();
   unsigned BitWidth = IntTy->getScalarSizeInBits();
 
   Value *Zero = ConstantInt::get(IntTy, 0);
   Value *One = ConstantInt::get(IntTy, 1);
-  Value *NegOne = ConstantInt::get(IntTy, -1);
+  Value *NegOne = ConstantInt::getAllOnes(IntTy);
 
   EXPECT_TRUE(
       m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE, APInt(BitWidth, 0))
           .match(Zero));
   EXPECT_TRUE(
       m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SGE, APInt(BitWidth, 0))
           .match(One));
   EXPECT_FALSE(

 }
 
 TEST_F(PatternMatchTest, SpecificIntSLT) {
   Type *IntTy = IRB.getInt32Ty();
   unsigned BitWidth = IntTy->getScalarSizeInBits();
 
   Value *Zero = ConstantInt::get(IntTy, 0);
   Value *One = ConstantInt::get(IntTy, 1);
-  Value *NegOne = ConstantInt::get(IntTy, -1);
+  Value *NegOne = ConstantInt::getAllOnes(IntTy);
 
   EXPECT_FALSE(
       m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT, APInt(BitWidth, 0))
           .match(Zero));
   EXPECT_FALSE(
       m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLT, APInt(BitWidth, 0))
           .match(One));
   EXPECT_TRUE(

 }
 
 TEST_F(PatternMatchTest, SpecificIntSLE) {
   Type *IntTy = IRB.getInt32Ty();
   unsigned BitWidth = IntTy->getScalarSizeInBits();
 
   Value *Zero = ConstantInt::get(IntTy, 0);
   Value *One = ConstantInt::get(IntTy, 1);
-  Value *NegOne = ConstantInt::get(IntTy, -1);
+  Value *NegOne = ConstantInt::getAllOnes(IntTy);
 
   EXPECT_TRUE(
       m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE, APInt(BitWidth, 0))
           .match(Zero));
   EXPECT_FALSE(
       m_SpecificInt_ICMP(ICmpInst::Predicate::ICMP_SLE, APInt(BitWidth, 0))
           .match(One));
   EXPECT_TRUE(