[IR] Modernize and Cleanup LLVM/IR folder

[gAlfonso-bit]

Summary

No functional changes were made. Instead, warnings were fixed, and optimizations were made

[gAlfonso-bit]

Fixed clang-tidy

[ldionne]

No functional changes were made.

That doesn't sound correct. You made some constructors explicit, at the very least. Also I'm seeing some function moving from member functions to static functions, and so on.

Regardless, I don't touch this part of the codebase so I'm not sure why I'm marked as a reviewer here.

[gAlfonso-bit]

Will split this into many patches

[dexonsmith]

Just a couple of comments inline to keep in mind if/when you start splitting pieces of this out.

llvm/lib/IR/Function.cpp

692–695

Is this an improvement? With this change (and the one to LLVMContext::setGC()), there's potentially allocation traffic with this usage pattern:

std::string GC = /* ... */;
F.setGC(std::move(GC));

where previously there was none.

Another option might be to make this (and the called API) a StringRef, and audit callers to delay any std::string allocation until LLVMContext::setGC().

llvm/lib/IR/IRPrintingPasses.cpp

55–56

When you split this out, I'd suggest using StringRef as the parameter and then Banner(Banner.str()).

llvm/include/llvm-c/Core.h

  */
 void LLVMSetOperand(LLVMValueRef User, unsigned Index, LLVMValueRef Val);
 
 /**
  * Obtain the number of operands in a llvm::User value.
  *
  * @see llvm::User::getNumOperands()
  */
-int LLVMGetNumOperands(LLVMValueRef Val);
+unsigned LLVMGetNumOperands(LLVMValueRef Val);
 
 /**
  * @}
  */
 
 /**
  * @defgroup LLVMCCoreValueConstant Constants
  *

llvm/include/llvm/IR/DIBuilder.h

public:
     /// using the \p Parent relationship.
     /// \param Parent     Macro file parent (could be nullptr).
     /// \param Line       Source line number where the macro file is included.
     /// \param File       File descriptor containing the name of the macro file.
     DIMacroFile *createTempMacroFile(DIMacroFile *Parent, unsigned Line,
                                      DIFile *File);
 
     /// Create a single enumerator value.
-    DIEnumerator *createEnumerator(StringRef Name, APSInt Value);
+    DIEnumerator *createEnumerator(StringRef Name, const APSInt &Value);
     DIEnumerator *createEnumerator(StringRef Name, uint64_t Val,
                                    bool IsUnsigned = false);
 
     /// Create a DWARF unspecified type.
     DIBasicType *createUnspecifiedType(StringRef Name);
 
     /// Create C++11 nullptr type.
     DIBasicType *createNullPtrType();

llvm/include/llvm/IR/DiagnosticInfo.h

struct Argument {
     Argument(StringRef Key, float N);
     Argument(StringRef Key, long N);
     Argument(StringRef Key, long long N);
     Argument(StringRef Key, unsigned N);
     Argument(StringRef Key, unsigned long N);
     Argument(StringRef Key, unsigned long long N);
     Argument(StringRef Key, ElementCount EC);
     Argument(StringRef Key, bool B) : Key(Key), Val(B ? "true" : "false") {}
-    Argument(StringRef Key, DebugLoc dl);
+    Argument(StringRef Key, const DebugLoc &dl);
     Argument(StringRef Key, InstructionCost C);
   };
 
   /// \p PassName is the name of the pass emitting this diagnostic. \p
   /// RemarkName is a textual identifier for the remark (single-word,
   /// camel-case). \p Fn is the function where the diagnostic is being emitted.
   /// \p Loc is the location information to use in the diagnostic. If line table
   /// information is available, the diagnostic will include the source code
   /// location.
   DiagnosticInfoOptimizationBase(enum DiagnosticKind Kind,
                                  enum DiagnosticSeverity Severity,
                                  const char *PassName, StringRef RemarkName,
                                  const Function &Fn,
                                  const DiagnosticLocation &Loc)
       : DiagnosticInfoWithLocationBase(Kind, Severity, Fn, Loc),
         PassName(PassName), RemarkName(RemarkName) {}
 
   void insert(StringRef S);
-  void insert(Argument A);
+  void insert(const Argument &A);
   void insert(setIsVerbose V);
   void insert(setExtraArgs EA);
 
   /// \see DiagnosticInfo::print.
   void print(DiagnosticPrinter &DP) const override;
 
   /// Return true if this optimization remark is enabled by one of
   /// of the LLVM command line flags (-pass-remarks, -pass-remarks-missed,

llvm/include/llvm/IR/Function.h

public:
   Optional<StringRef> getSectionPrefix() const;
 
   /// hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm
   ///                             to use during code generation.
   bool hasGC() const {
     return getSubclassDataFromValue() & (1<<14);
   }
   const std::string &getGC() const;
-  void setGC(std::string Str);
+  void setGC(const std::string &Str);
   void clearGC();
 
   /// Return the attribute list for this Function.
   AttributeList getAttributes() const { return AttributeSets; }
 
   /// Set the attribute list for this Function.
   void setAttributes(AttributeList Attrs) { AttributeSets = Attrs; }
 

llvm/include/llvm/IR/IRPrintingPasses.h

 /// functions above to create passes for use with the legacy pass manager.
 class PrintModulePass : public PassInfoMixin<PrintModulePass> {
   raw_ostream &OS;
   std::string Banner;
   bool ShouldPreserveUseListOrder;
 
 public:
   PrintModulePass();
-  PrintModulePass(raw_ostream &OS, const std::string &Banner = "",
+  PrintModulePass(raw_ostream &OS, std::string Banner = "",
                   bool ShouldPreserveUseListOrder = false);
 
   PreservedAnalyses run(Module &M, AnalysisManager<Module> &);
   static bool isRequired() { return true; }
 };
 
 /// Pass for printing a Function as LLVM's text IR assembly.
 ///
 /// Note: This pass is for use with the new pass manager. Use the create...Pass
 /// functions above to create passes for use with the legacy pass manager.
 class PrintFunctionPass : public PassInfoMixin<PrintFunctionPass> {
   raw_ostream &OS;
   std::string Banner;
 
 public:
   PrintFunctionPass();
-  PrintFunctionPass(raw_ostream &OS, const std::string &Banner = "");
+  PrintFunctionPass(raw_ostream &OS, std::string Banner = "");
 
   PreservedAnalyses run(Function &F, AnalysisManager<Function> &);
   static bool isRequired() { return true; }
 };
 
 } // namespace llvm
 
 #endif

llvm/include/llvm/IR/InlineAsm.h

private:
 
   std::string AsmString, Constraints;
   FunctionType *FTy;
   bool HasSideEffects;
   bool IsAlignStack;
   AsmDialect Dialect;
   bool CanThrow;
 
-  InlineAsm(FunctionType *Ty, const std::string &AsmString,
+  InlineAsm(FunctionType *Ty, std::string AsmString,
             const std::string &Constraints, bool hasSideEffects,
             bool isAlignStack, AsmDialect asmDialect, bool canThrow);
 
   /// When the ConstantUniqueMap merges two types and makes two InlineAsms
   /// identical, it destroys one of them with this method.
   void destroyConstant();
 
 public:

llvm/include/llvm/IR/LLVMContext.h

#undef LLVM_FIXED_MD_KIND
   SyncScope::ID getOrInsertSyncScopeID(StringRef SSN);
 
   /// getSyncScopeNames - Populates client supplied SmallVector with
   /// synchronization scope names registered with LLVMContext.  Synchronization
   /// scope names are ordered by increasing synchronization scope IDs.
   void getSyncScopeNames(SmallVectorImpl<StringRef> &SSNs) const;
 
   /// Define the GC for a function
-  void setGC(const Function &Fn, std::string GCName);
+  void setGC(const Function &Fn, const std::string &GCName);
 
   /// Return the GC for a function
   const std::string &getGC(const Function &Fn);
 
   /// Remove the GC for a function
   void deleteGC(const Function &Fn);
 
   /// Return true if the Context runtime configuration is set to discard all

llvm/include/llvm/IR/LegacyPassManagers.h

protected:
 
   // Collection of Analysis provided by Parent pass manager and
   // used by current pass manager. At at time there can not be more
   // then PMT_Last active pass mangers.
   DenseMap<AnalysisID, Pass *> *InheritedAnalysis[PMT_Last];
 
   /// isPassDebuggingExecutionsOrMore - Return true if -debug-pass=Executions
   /// or higher is specified.
-  bool isPassDebuggingExecutionsOrMore() const;
+  static bool isPassDebuggingExecutionsOrMore();
 
 private:
   void dumpAnalysisUsage(StringRef Msg, const Pass *P,
                          const AnalysisUsage::VectorType &Set) const;
 
   // Set of available Analysis. This information is used while scheduling
   // pass. If a pass requires an analysis which is not available then
   // the required analysis pass is scheduled to run before the pass itself is

llvm/lib/IR/AsmWriter.cpp

 };
 
 void llvm::printLLVMNameWithoutPrefix(raw_ostream &OS, StringRef Name) {
   assert(!Name.empty() && "Cannot get empty name!");
 
   // Scan the name to see if it needs quotes first.
   bool NeedsQuotes = isdigit(static_cast<unsigned char>(Name[0]));
   if (!NeedsQuotes) {
-    for (unsigned i = 0, e = Name.size(); i != e; ++i) {
+    for (unsigned char C : Name) {
       // By making this unsigned, the value passed in to isalnum will always be
       // in the range 0-255.  This is important when building with MSVC because
       // its implementation will assert.  This situation can arise when dealing
       // with UTF-8 multibyte characters.
-      unsigned char C = Name[i];
       if (!isalnum(static_cast<unsigned char>(C)) && C != '-' && C != '.' &&
           C != '_') {
         NeedsQuotes = true;
         break;
       }
     }
   }
 
if (all_of(Mask, [](int Elt) { return Elt == 0; })) {
     Out << ">";
   }
 }
 
 namespace {
 
 class TypePrinting {
 public:
-  TypePrinting(const Module *M = nullptr) : DeferredM(M) {}
+  explicit TypePrinting(const Module *M = nullptr) : DeferredM(M) {}
 
   TypePrinting(const TypePrinting &) = delete;
   TypePrinting &operator=(const TypePrinting &) = delete;
 
   /// The named types that are used by the current module.
   TypeFinder &getNamedTypes();
 
   /// The numbered types, number to type mapping.
if (STy->getNumElements() == 0) {
     }
 
     OS << " }";
   }
   if (STy->isPacked())
     OS << '>';
 }
 
-AbstractSlotTrackerStorage::~AbstractSlotTrackerStorage() {}
+AbstractSlotTrackerStorage::~AbstractSlotTrackerStorage() = default;
 
 namespace llvm {
 
 //===----------------------------------------------------------------------===//
 // SlotTracker Class: Enumerate slot numbers for unnamed values
 //===----------------------------------------------------------------------===//
 /// This class provides computation of slot numbers for LLVM Assembly writing.
 ///
explicit SlotTracker(const Function *F,
                        bool ShouldInitializeAllMetadata = false);
 
   /// Construct from a module summary index.
   explicit SlotTracker(const ModuleSummaryIndex *Index);
 
   SlotTracker(const SlotTracker &) = delete;
   SlotTracker &operator=(const SlotTracker &) = delete;
 
-  ~SlotTracker() = default;
+  ~SlotTracker() override = default;
 
   void setProcessHook(
       std::function<void(AbstractSlotTrackerStorage *, const Module *, bool)>);
   void setProcessHook(std::function<void(AbstractSlotTrackerStorage *,
                                          const Function *, bool)>);
 
   unsigned getNextMetadataSlot() override { return mdnNext; }
 

 }
 
 namespace {
 
 struct FieldSeparator {
   bool Skip = true;
   const char *Sep;
 
-  FieldSeparator(const char *Sep = ", ") : Sep(Sep) {}
+  explicit FieldSeparator(const char *Sep = ", ") : Sep(Sep) {}
 };
 
 raw_ostream &operator<<(raw_ostream &OS, FieldSeparator &FS) {
   if (FS.Skip) {
     FS.Skip = false;
     return OS;
   }
   return OS << FS.Sep;

llvm/lib/IR/AttributeImpl.h

 protected:
   enum AttrEntryKind {
     EnumAttrEntry,
     IntAttrEntry,
     StringAttrEntry,
     TypeAttrEntry,
   };
 
-  AttributeImpl(AttrEntryKind KindID) : KindID(KindID) {}
+  explicit AttributeImpl(AttrEntryKind KindID) : KindID(KindID) {}
 
 public:
   // AttributesImpl is uniqued, these should not be available.
   AttributeImpl(const AttributeImpl &) = delete;
   AttributeImpl &operator=(const AttributeImpl &) = delete;
 
   bool isEnumAttribute() const { return KindID == EnumAttrEntry; }
   bool isIntAttribute() const { return KindID == IntAttrEntry; }

 class EnumAttributeImpl : public AttributeImpl {
   Attribute::AttrKind Kind;
 
 protected:
   EnumAttributeImpl(AttrEntryKind ID, Attribute::AttrKind Kind)
       : AttributeImpl(ID), Kind(Kind) {}
 
 public:
-  EnumAttributeImpl(Attribute::AttrKind Kind)
+  explicit EnumAttributeImpl(Attribute::AttrKind Kind)
       : AttributeImpl(EnumAttrEntry), Kind(Kind) {
     assert(Kind != Attribute::AttrKind::None &&
            "Can't create a None attribute!");
   }
 
   Attribute::AttrKind getEnumKind() const { return Kind; }
 };
 
class StringAttributeImpl final
 
   unsigned KindSize;
   unsigned ValSize;
   size_t numTrailingObjects(OverloadToken<char>) const {
     return KindSize + 1 + ValSize + 1;
   }
 
 public:
-  StringAttributeImpl(StringRef Kind, StringRef Val = StringRef())
+  explicit StringAttributeImpl(StringRef Kind, StringRef Val = StringRef())
       : AttributeImpl(StringAttrEntry), KindSize(Kind.size()),
         ValSize(Val.size()) {
     char *TrailingString = getTrailingObjects<char>();
     // Some users rely on zero-termination.
     llvm::copy(Kind, TrailingString);
     TrailingString[KindSize] = '\0';
     llvm::copy(Val, &TrailingString[KindSize + 1]);
     TrailingString[KindSize + 1 + ValSize] = '\0';
: public FoldingSetNode,
       private TrailingObjects<AttributeSetNode, Attribute> {
   friend TrailingObjects;
 
   unsigned NumAttrs; ///< Number of attributes in this node.
   AttributeBitSet AvailableAttrs; ///< Available enum attributes.
 
   DenseMap<StringRef, Attribute> StringAttrs;
 
-  AttributeSetNode(ArrayRef<Attribute> Attrs);
+  explicit AttributeSetNode(ArrayRef<Attribute> Attrs);
 
   static AttributeSetNode *getSorted(LLVMContext &C,
                                      ArrayRef<Attribute> SortedAttrs);
   Optional<Attribute> findEnumAttribute(Attribute::AttrKind Kind) const;
 
 public:
   // AttributesSetNode is uniqued, these should not be available.
   AttributeSetNode(const AttributeSetNode &) = delete;
private:
   AttributeBitSet AvailableFunctionAttrs;
   /// Union of enum attributes available at any index.
   AttributeBitSet AvailableSomewhereAttrs;
 
   // Helper fn for TrailingObjects class.
   size_t numTrailingObjects(OverloadToken<AttributeSet>) { return NumAttrSets; }
 
 public:
-  AttributeListImpl(ArrayRef<AttributeSet> Sets);
+  explicit AttributeListImpl(ArrayRef<AttributeSet> Sets);
 
   // AttributesSetImpt is uniqued, these should not be available.
   AttributeListImpl(const AttributeListImpl &) = delete;
   AttributeListImpl &operator=(const AttributeListImpl &) = delete;
 
   /// Return true if the AttributeSet or the FunctionIndex has an
   /// enum attribute of the given kind.
   bool hasFnAttribute(Attribute::AttrKind Kind) const {

llvm/lib/IR/Attributes.cpp

AttributeSet AttributeSet::removeAttributes(LLVMContext &C,
   return get(C, B);
 }
 
 unsigned AttributeSet::getNumAttributes() const {
   return SetNode ? SetNode->getNumAttributes() : 0;
 }
 
 bool AttributeSet::hasAttribute(Attribute::AttrKind Kind) const {
-  return SetNode ? SetNode->hasAttribute(Kind) : false;
+  return SetNode != nullptr && SetNode->hasAttribute(Kind);
 }
 
 bool AttributeSet::hasAttribute(StringRef Kind) const {
-  return SetNode ? SetNode->hasAttribute(Kind) : false;
+  return SetNode != nullptr && SetNode->hasAttribute(Kind);
 }
 
 Attribute AttributeSet::getAttribute(Attribute::AttrKind Kind) const {
   return SetNode ? SetNode->getAttribute(Kind) : Attribute();
 }
 
 Attribute AttributeSet::getAttribute(StringRef Kind) const {
   return SetNode ? SetNode->getAttribute(Kind) : Attribute();

llvm/lib/IR/AutoUpgrade.cpp

if (Name.startswith("arm.neon.vclz")) {
                                "llvm.ctlz." + Name.substr(14), F->getParent());
       return true;
     }
     if (Name.startswith("arm.neon.vcnt")) {
       NewFn = Intrinsic::getDeclaration(F->getParent(), Intrinsic::ctpop,
                                         F->arg_begin()->getType());
       return true;
     }
-    static const Regex vldRegex("^arm\\.neon\\.vld([1234]|[234]lane)\\.v[a-z0-9]*$");
+    static const Regex vldRegex(
+        R"(^arm\.neon\.vld([1234]|[234]lane)\.v[a-z0-9]*$)");
     if (vldRegex.match(Name)) {
       auto fArgs = F->getFunctionType()->params();
       SmallVector<Type *, 4> Tys(fArgs.begin(), fArgs.end());
       // Can't use Intrinsic::getDeclaration here as the return types might
       // then only be structurally equal.
       FunctionType* fType = FunctionType::get(F->getReturnType(), Tys, false);
       StringRef Suffix =
           F->getContext().supportsTypedPointers() ? "p0i8" : "p0";
       NewFn = Function::Create(fType, F->getLinkage(), F->getAddressSpace(),
                                "llvm." + Name + "." + Suffix, F->getParent());
       return true;
     }
-    static const Regex vstRegex("^arm\\.neon\\.vst([1234]|[234]lane)\\.v[a-z0-9]*$");
+    static const Regex vstRegex(
+        R"(^arm\.neon\.vst([1234]|[234]lane)\.v[a-z0-9]*$)");
     if (vstRegex.match(Name)) {
       static const Intrinsic::ID StoreInts[] = {Intrinsic::arm_neon_vst1,
                                                 Intrinsic::arm_neon_vst2,
                                                 Intrinsic::arm_neon_vst3,
                                                 Intrinsic::arm_neon_vst4};
 
       static const Intrinsic::ID StoreLaneInts[] = {
         Intrinsic::arm_neon_vst2lane, Intrinsic::arm_neon_vst3lane,

 // must also have the strictfp attribute. This latter restriction is
 // necessary to prevent unwanted libcall simplification when a function is
 // being cloned (such as for inlining).
 //
 // The "dangling" strictfp attribute usage was only used to prevent constant
 // folding and other libcall simplification. The nobuiltin attribute on the
 // callsite has the same effect.
 struct StrictFPUpgradeVisitor : public InstVisitor<StrictFPUpgradeVisitor> {
-  StrictFPUpgradeVisitor() {}
+  StrictFPUpgradeVisitor() = default;
 
   void visitCallBase(CallBase &Call) {
     if (!Call.isStrictFP())
       return;
     if (isa<ConstrainedFPIntrinsic>(&Call))
       return;
     // If we get here, the caller doesn't have the strictfp attribute
     // but this callsite does. Replace the strictfp attribute with nobuiltin.

llvm/lib/IR/BuiltinGCs.cpp

 /// includes the C backend). Note that the code generated is not quite as
 /// efficient as algorithms which generate stack maps to identify roots.
 ///
 /// In order to support this particular transformation, all stack roots are
 /// coallocated in the stack. This allows a fully target-independent stack map
 /// while introducing only minor runtime overhead.
 class ShadowStackGC : public GCStrategy {
 public:
-  ShadowStackGC() {}
+  ShadowStackGC() = default;
 };
 
 /// A GCStrategy which serves as an example for the usage of a statepoint based
 /// lowering strategy.  This GCStrategy is intended to suitable as a default
 /// implementation usable with any collector which can consume the standard
 /// stackmap format generated by statepoints, uses the default addrespace to
 /// distinguish between gc managed and non-gc managed pointers, and has
 /// reasonable relocation semantics.

llvm/lib/IR/Constants.cpp

Constant *ConstantArray::get(ArrayType *Ty, ArrayRef<Constant*> V) {
   return Ty->getContext().pImpl->ArrayConstants.getOrCreate(Ty, V);
 }
 
 Constant *ConstantArray::getImpl(ArrayType *Ty, ArrayRef<Constant*> V) {
   // Empty arrays are canonicalized to ConstantAggregateZero.
   if (V.empty())
     return ConstantAggregateZero::get(Ty);
 
-  for (unsigned i = 0, e = V.size(); i != e; ++i) {
-    assert(V[i]->getType() == Ty->getElementType() &&
+  for (auto *I : V) {
+    assert(I->getType() == Ty->getElementType() &&
            "Wrong type in array element initializer");
   }
 
   // If this is an all-zero array, return a ConstantAggregateZero object.  If
   // all undef, return an UndefValue, if "all simple", then return a
   // ConstantDataArray.
   Constant *C = V[0];
   if (isa<PoisonValue>(C) && rangeOnlyContains(V.begin(), V.end(), C))
Constant *ConstantStruct::get(StructType *ST, ArrayRef<Constant*> V) {
   bool isPoison = false;
 
   if (!V.empty()) {
     isUndef = isa<UndefValue>(V[0]);
     isPoison = isa<PoisonValue>(V[0]);
     isZero = V[0]->isNullValue();
     // PoisonValue inherits UndefValue, so its check is not necessary.
     if (isUndef || isZero) {
-      for (unsigned i = 0, e = V.size(); i != e; ++i) {
-        if (!V[i]->isNullValue())
+      for (auto *I : V) {
+        if (!I->isNullValue())
           isZero = false;
-        if (!isa<PoisonValue>(V[i]))
+        if (!isa<PoisonValue>(I))
           isPoison = false;
-        if (isa<PoisonValue>(V[i]) || !isa<UndefValue>(V[i]))
+        if (isa<PoisonValue>(I) || !isa<UndefValue>(I))
           isUndef = false;
       }
     }
   }
   if (isZero)
     return ConstantAggregateZero::get(ST);
   if (isPoison)
     return PoisonValue::get(ST);

llvm/lib/IR/Core.cpp

 LLVMAttributeRef LLVMCreateEnumAttribute(LLVMContextRef C, unsigned KindID,
                                          uint64_t Val) {
   auto &Ctx = *unwrap(C);
   auto AttrKind = (Attribute::AttrKind)KindID;
 
   if (AttrKind == Attribute::AttrKind::ByVal) {
     // After r362128, byval attributes need to have a type attribute. Provide a
     // NULL one until a proper API is added for this.
-    return wrap(Attribute::getWithByValType(Ctx, NULL));
+    return wrap(Attribute::getWithByValType(Ctx, nullptr));
   }
 
   if (AttrKind == Attribute::AttrKind::StructRet) {
     // Same as byval.
-    return wrap(Attribute::getWithStructRetType(Ctx, NULL));
+    return wrap(Attribute::getWithStructRetType(Ctx, nullptr));
   }
 
   return wrap(Attribute::get(Ctx, AttrKind, Val));
 }
 
 unsigned LLVMGetEnumAttributeKind(LLVMAttributeRef A) {
   return unwrap(A).getKindAsEnum();
 }
LLVMUseRef LLVMGetOperandUse(LLVMValueRef Val, unsigned Index) {
   Value *V = unwrap(Val);
   return wrap(&cast<User>(V)->getOperandUse(Index));
 }
 
 void LLVMSetOperand(LLVMValueRef Val, unsigned Index, LLVMValueRef Op) {
   unwrap<User>(Val)->setOperand(Index, unwrap(Op));
 }
 
-int LLVMGetNumOperands(LLVMValueRef Val) {
+unsigned LLVMGetNumOperands(LLVMValueRef Val) {
   Value *V = unwrap(Val);
   if (isa<MetadataAsValue>(V))
     return LLVMGetMDNodeNumOperands(Val);
 
   return cast<User>(V)->getNumOperands();
 }
 
 /*--.. Operations on constants of any type .................................--*/

llvm/lib/IR/DIBuilder.cpp

 
 DIEnumerator *DIBuilder::createEnumerator(StringRef Name, uint64_t Val,
                                           bool IsUnsigned) {
   assert(!Name.empty() && "Unable to create enumerator without name");
   return DIEnumerator::get(VMContext, APInt(64, Val, !IsUnsigned), IsUnsigned,
                            Name);
 }
 
-DIEnumerator *DIBuilder::createEnumerator(StringRef Name, APSInt Value) {
+DIEnumerator *DIBuilder::createEnumerator(StringRef Name, const APSInt &Value) {
   assert(!Name.empty() && "Unable to create enumerator without name");
   return DIEnumerator::get(VMContext, APInt(Value), Value.isUnsigned(), Name);
 }
 
 DIBasicType *DIBuilder::createUnspecifiedType(StringRef Name) {
   assert(!Name.empty() && "Unable to create type without name");
   return DIBasicType::get(VMContext, dwarf::DW_TAG_unspecified_type, Name);
 }

 
 DIMacroNodeArray
 DIBuilder::getOrCreateMacroArray(ArrayRef<Metadata *> Elements) {
   return MDTuple::get(VMContext, Elements);
 }
 
 DITypeRefArray DIBuilder::getOrCreateTypeArray(ArrayRef<Metadata *> Elements) {
   SmallVector<llvm::Metadata *, 16> Elts;
-  for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
-    if (Elements[i] && isa<MDNode>(Elements[i]))
-      Elts.push_back(cast<DIType>(Elements[i]));
+  for (auto *Element : Elements) {
+    if (isa_and_nonnull<MDNode>(Element))
+      Elts.push_back(cast<DIType>(Element));
     else
-      Elts.push_back(Elements[i]);
+      Elts.push_back(Element);
   }
   return DITypeRefArray(MDNode::get(VMContext, Elts));
 }
 
 DISubrange *DIBuilder::getOrCreateSubrange(int64_t Lo, int64_t Count) {
   auto *LB = ConstantAsMetadata::get(
       ConstantInt::getSigned(Type::getInt64Ty(VMContext), Lo));
   auto *CountNode = ConstantAsMetadata::get(

llvm/lib/IR/DebugInfo.cpp

void DebugInfoFinder::processCompileUnit(DICompileUnit *CU) {
   }
 }
 
 void DebugInfoFinder::processInstruction(const Module &M,
                                          const Instruction &I) {
   if (auto *DVI = dyn_cast<DbgVariableIntrinsic>(&I))
     processVariable(M, *DVI);
 
-  if (auto DbgLoc = I.getDebugLoc())
+  if (const auto &DbgLoc = I.getDebugLoc())
     processLocation(M, DbgLoc.get());
 }
 
 void DebugInfoFinder::processLocation(const Module &M, const DILocation *Loc) {
   if (!Loc)
     return;
   processScope(Loc->getScope());
   processLocation(M, Loc->getInlinedAt());
private:
   // TODO: Remember the distinct subprogram we created for a given linkage name,
   // so that we can continue to unique whenever possible. Map <newly created
   // node, old linkage name> to the first (possibly distinct) mdsubprogram
   // created for that combination. This is not strictly needed for correctness,
   // but can cut down on the number of MDNodes and let us diff cleanly with the
   // output of -gline-tables-only.
 
 public:
-  DebugTypeInfoRemoval(LLVMContext &C)
+  explicit DebugTypeInfoRemoval(LLVMContext &C)
       : EmptySubroutineType(DISubroutineType::get(C, DINode::FlagZero, 0,
                                                   MDNode::get(C, {}))) {}
 
   Metadata *map(Metadata *M) {
     if (!M)
       return nullptr;
     auto Replacement = Replacements.find(M);
     if (Replacement != Replacements.end())

llvm/lib/IR/DiagnosticHandler.cpp

if (!Val.empty()) {
       if (!Pattern->isValid(RegexError))
         report_fatal_error("Invalid regular expression '" + Val +
                                "' in -pass-remarks: " + RegexError,
                            false);
     }
   }
 };
 
-static PassRemarksOpt PassRemarksPassedOptLoc;
-static PassRemarksOpt PassRemarksMissedOptLoc;
-static PassRemarksOpt PassRemarksAnalysisOptLoc;
+PassRemarksOpt PassRemarksPassedOptLoc;
+PassRemarksOpt PassRemarksMissedOptLoc;
+PassRemarksOpt PassRemarksAnalysisOptLoc;
 
 // -pass-remarks
 //    Command line flag to enable emitOptimizationRemark()
-static cl::opt<PassRemarksOpt, true, cl::parser<std::string>> PassRemarks(
+cl::opt<PassRemarksOpt, true, cl::parser<std::string>> PassRemarks(
     "pass-remarks", cl::value_desc("pattern"),
     cl::desc("Enable optimization remarks from passes whose name match "
              "the given regular expression"),
     cl::Hidden, cl::location(PassRemarksPassedOptLoc), cl::ValueRequired,
     cl::ZeroOrMore);
 
 // -pass-remarks-missed
 //    Command line flag to enable emitOptimizationRemarkMissed()
-static cl::opt<PassRemarksOpt, true, cl::parser<std::string>> PassRemarksMissed(
+cl::opt<PassRemarksOpt, true, cl::parser<std::string>> PassRemarksMissed(
     "pass-remarks-missed", cl::value_desc("pattern"),
     cl::desc("Enable missed optimization remarks from passes whose name match "
              "the given regular expression"),
     cl::Hidden, cl::location(PassRemarksMissedOptLoc), cl::ValueRequired,
     cl::ZeroOrMore);
 
 // -pass-remarks-analysis
 //    Command line flag to enable emitOptimizationRemarkAnalysis()
-static cl::opt<PassRemarksOpt, true, cl::parser<std::string>>
-    PassRemarksAnalysis(
-        "pass-remarks-analysis", cl::value_desc("pattern"),
-        cl::desc(
-            "Enable optimization analysis remarks from passes whose name match "
-            "the given regular expression"),
-        cl::Hidden, cl::location(PassRemarksAnalysisOptLoc), cl::ValueRequired,
-        cl::ZeroOrMore);
-}
+cl::opt<PassRemarksOpt, true, cl::parser<std::string>> PassRemarksAnalysis(
+} // namespace
 
 bool DiagnosticHandler::isAnalysisRemarkEnabled(StringRef PassName) const {
   return (PassRemarksAnalysisOptLoc.Pattern &&
           PassRemarksAnalysisOptLoc.Pattern->match(PassName));
 }
 bool DiagnosticHandler::isMissedOptRemarkEnabled(StringRef PassName) const {
   return (PassRemarksMissedOptLoc.Pattern &&
           PassRemarksMissedOptLoc.Pattern->match(PassName));

llvm/lib/IR/DiagnosticInfo.cpp

 
 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key,
                                                    InstructionCost C)
     : Key(std::string(Key)) {
   raw_string_ostream OS(Val);
   C.print(OS);
 }
 
-DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, DebugLoc Loc)
+DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key,
+                                                   const DebugLoc &Loc)
     : Key(std::string(Key)), Loc(Loc) {
   if (Loc) {
     Val = (Loc->getFilename() + ":" + Twine(Loc.getLine()) + ":" +
-           Twine(Loc.getCol())).str();
+           Twine(Loc.getCol()))
+              .str();
   } else {
     Val = "<UNKNOWN LOCATION>";
   }
 }
 
 void DiagnosticInfoOptimizationBase::print(DiagnosticPrinter &DP) const {
   DP << getLocationStr() << ": " << getMsg();
   if (Hotness)

 void DiagnosticInfoISelFallback::print(DiagnosticPrinter &DP) const {
   DP << "Instruction selection used fallback path for " << getFunction();
 }
 
 void DiagnosticInfoOptimizationBase::insert(StringRef S) {
   Args.emplace_back(S);
 }
 
-void DiagnosticInfoOptimizationBase::insert(Argument A) {
+void DiagnosticInfoOptimizationBase::insert(const Argument &A) {
   Args.push_back(std::move(A));
 }
 
 void DiagnosticInfoOptimizationBase::insert(setIsVerbose V) {
   IsVerbose = true;
 }
 
 void DiagnosticInfoOptimizationBase::insert(setExtraArgs EA) {

llvm/lib/IR/Function.cpp

DenormalMode Function::getDenormalMode(const fltSemantics &FPType) const {
   return parseDenormalFPAttribute(Attr.getValueAsString());
 }
 
 const std::string &Function::getGC() const {
   assert(hasGC() && "Function has no collector");
   return getContext().getGC(*this);
 }
 
-void Function::setGC(std::string Str) {
+void Function::setGC(const std::string &Str) {
   setValueSubclassDataBit(14, !Str.empty());
   getContext().setGC(*this, std::move(Str));
 }
 
 void Function::clearGC() {
   if (!hasGC())
     return;
   getContext().deleteGC(*this);
   setValueSubclassDataBit(14, false);
 }
 
case IITDescriptor::VecOfAnyPtrsToElt: {
           dyn_cast<PointerType>(ThisArgVecTy->getElementType());
       if (!ThisArgEltTy)
         return true;
       return !ThisArgEltTy->isOpaqueOrPointeeTypeMatches(
           ReferenceType->getElementType());
     }
     case IITDescriptor::VecElementArgument: {
       if (D.getArgumentNumber() >= ArgTys.size())
-        return IsDeferredCheck ? true : DeferCheck(Ty);
+        return IsDeferredCheck || DeferCheck(Ty);
       auto *ReferenceType = dyn_cast<VectorType>(ArgTys[D.getArgumentNumber()]);
       return !ReferenceType || Ty != ReferenceType->getElementType();
     }
     case IITDescriptor::Subdivide2Argument:
     case IITDescriptor::Subdivide4Argument: {
       // If this is a forward reference, defer the check for later.
       if (D.getArgumentNumber() >= ArgTys.size())
         return IsDeferredCheck || DeferCheck(Ty);

llvm/lib/IR/GVMaterializer.cpp

 //===-- GVMaterializer.cpp - Base implementation for GV materializers -----===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Minimal implementation of the abstract interface for materializing
 // GlobalValues.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/GVMaterializer.h"
 using namespace llvm;
 
-GVMaterializer::~GVMaterializer() {}
+GVMaterializer::~GVMaterializer() = default;

llvm/lib/IR/IRBuilder.cpp

CallInst *IRBuilderBase::CreateAlignmentAssumption(const DataLayout &DL,
                                                    Value *PtrValue,
                                                    Value *Alignment,
                                                    Value *OffsetValue) {
   assert(isa<PointerType>(PtrValue->getType()) &&
          "trying to create an alignment assumption on a non-pointer?");
   return CreateAlignmentAssumptionHelper(DL, PtrValue, Alignment, OffsetValue);
 }
 
-IRBuilderDefaultInserter::~IRBuilderDefaultInserter() {}
-IRBuilderCallbackInserter::~IRBuilderCallbackInserter() {}
-IRBuilderFolder::~IRBuilderFolder() {}
+IRBuilderDefaultInserter::~IRBuilderDefaultInserter() = default;
+IRBuilderCallbackInserter::~IRBuilderCallbackInserter() = default;
+IRBuilderFolder::~IRBuilderFolder() = default;
 void ConstantFolder::anchor() {}
 void NoFolder::anchor() {}

llvm/lib/IR/IRPrintingPasses.cpp

 //===--- IRPrintingPasses.cpp - Module and Function printing passes -------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // PrintModulePass and PrintFunctionPass implementations.
 //
 //===----------------------------------------------------------------------===//
 
+#include <utility>
+
 #include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PrintPasses.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
 PrintModulePass::PrintModulePass() : OS(dbgs()) {}
-PrintModulePass::PrintModulePass(raw_ostream &OS, const std::string &Banner,
+PrintModulePass::PrintModulePass(raw_ostream &OS, std::string Banner,
                                  bool ShouldPreserveUseListOrder)
-    : OS(OS), Banner(Banner),
+    : OS(OS), Banner(std::move(Banner)),
       ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) {}
 
 PreservedAnalyses PrintModulePass::run(Module &M, ModuleAnalysisManager &) {
   if (llvm::isFunctionInPrintList("*")) {
     if (!Banner.empty())
       OS << Banner << "\n";
     M.print(OS, nullptr, ShouldPreserveUseListOrder);
   }
   else {
     bool BannerPrinted = false;
     for(const auto &F : M.functions()) {
       if (llvm::isFunctionInPrintList(F.getName())) {
         if (!BannerPrinted && !Banner.empty()) {
           OS << Banner << "\n";
           BannerPrinted = true;
         }
         F.print(OS);
       }
     }
   }
   return PreservedAnalyses::all();
 }
 
 PrintFunctionPass::PrintFunctionPass() : OS(dbgs()) {}
-PrintFunctionPass::PrintFunctionPass(raw_ostream &OS, const std::string &Banner)
-    : OS(OS), Banner(Banner) {}
+PrintFunctionPass::PrintFunctionPass(raw_ostream &OS, std::string Banner)
+    : OS(OS), Banner(std::move(Banner)) {}
 
 PreservedAnalyses PrintFunctionPass::run(Function &F,
                                          FunctionAnalysisManager &) {
   if (isFunctionInPrintList(F.getName())) {
     if (forcePrintModuleIR())
       OS << Banner << " (function: " << F.getName() << ")\n" << *F.getParent();
     else
       OS << Banner << '\n' << static_cast<Value &>(F);

llvm/lib/IR/InlineAsm.cpp

 #include "llvm/IR/Value.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
 #include <algorithm>
 #include <cassert>
 #include <cctype>
 #include <cstddef>
 #include <cstdlib>
+#include <utility>
 
 using namespace llvm;
 
-InlineAsm::InlineAsm(FunctionType *FTy, const std::string &asmString,
+InlineAsm::InlineAsm(FunctionType *FTy, std::string asmString,
                      const std::string &constraints, bool hasSideEffects,
                      bool isAlignStack, AsmDialect asmDialect, bool canThrow)
     : Value(PointerType::getUnqual(FTy), Value::InlineAsmVal),
-      AsmString(asmString), Constraints(constraints), FTy(FTy),
+      AsmString(std::move(asmString)), Constraints(constraints), FTy(FTy),
       HasSideEffects(hasSideEffects), IsAlignStack(isAlignStack),
       Dialect(asmDialect), CanThrow(canThrow) {
   // Do various checks on the constraint string and type.
   assert(Verify(getFunctionType(), constraints) &&
          "Function type not legal for constraints!");
 }
 
 InlineAsm *InlineAsm::get(FunctionType *FTy, StringRef AsmString,
if (*I == '{') {   // Physical register reference.
           ConstraintsSoFar[N].multipleAlternatives[multipleAlternativeIndex];
         if (scInfo.MatchingInput != -1)
           return true;
         // Note that operand #n has a matching input.
         scInfo.MatchingInput = ConstraintsSoFar.size();
         assert(scInfo.MatchingInput >= 0);
       } else {
         if (ConstraintsSoFar[N].hasMatchingInput() &&
-            (size_t)ConstraintsSoFar[N].MatchingInput !=
+            static_cast<size_t>(ConstraintsSoFar[N].MatchingInput) !=
                 ConstraintsSoFar.size())
           return true;
         // Note that operand #n has a matching input.
         ConstraintsSoFar[N].MatchingInput = ConstraintsSoFar.size();
         assert(ConstraintsSoFar[N].MatchingInput >= 0);
         }
     } else if (*I == '|') {
       multipleAlternativeIndex++;
bool InlineAsm::Verify(FunctionType *Ty, StringRef ConstStr) {
   ConstraintInfoVector Constraints = ParseConstraints(ConstStr);
 
   // Error parsing constraints.
   if (Constraints.empty() && !ConstStr.empty()) return false;
 
   unsigned NumOutputs = 0, NumInputs = 0, NumClobbers = 0;
   unsigned NumIndirect = 0;
 
-  for (unsigned i = 0, e = Constraints.size(); i != e; ++i) {
-    switch (Constraints[i].Type) {
+  for (auto &Constraint : Constraints) {
+    switch (Constraint.Type) {
     case InlineAsm::isOutput:
-      if ((NumInputs-NumIndirect) != 0 || NumClobbers != 0)
-        return false;  // outputs before inputs and clobbers.
-      if (!Constraints[i].isIndirect) {
+      if (NumInputs != NumIndirect || NumClobbers != 0)
+        return false; // outputs before inputs and clobbers.
+      if (!Constraint.isIndirect) {
         ++NumOutputs;
         break;
       }
       ++NumIndirect;
       LLVM_FALLTHROUGH; // We fall through for Indirect Outputs.
     case InlineAsm::isInput:
-      if (NumClobbers) return false;               // inputs before clobbers.
+      if (NumClobbers)
+        return false; // inputs before clobbers.
       ++NumInputs;
       break;
     case InlineAsm::isClobber:
       ++NumClobbers;
       break;
     }
   }
 

llvm/lib/IR/Instructions.cpp

for (int i = 0; i != NumMaskElts; ++i) {
     }
     if (M < NumSrcElts) {
       Src0Elts.setBit(i);
       Src0Identity &= (M == i);
       continue;
     }
     Src1Elts.setBit(i);
     Src1Identity &= (M == (i + NumSrcElts));
-    continue;
   }
   assert((Src0Elts | Src1Elts | UndefElts).isAllOnesValue() &&
          "unknown shuffle elements");
   assert(!Src0Elts.isNullValue() && !Src1Elts.isNullValue() &&
          "2-source shuffle not found");
 
   // Determine lo/hi span ranges.
   // TODO: How should we handle undefs at the start of subvector insertions?

llvm/lib/IR/LLVMContext.cpp

 SyncScope::ID LLVMContext::getOrInsertSyncScopeID(StringRef SSN) {
   return pImpl->getOrInsertSyncScopeID(SSN);
 }
 
 void LLVMContext::getSyncScopeNames(SmallVectorImpl<StringRef> &SSNs) const {
   pImpl->getSyncScopeNames(SSNs);
 }
 
-void LLVMContext::setGC(const Function &Fn, std::string GCName) {
+void LLVMContext::setGC(const Function &Fn, const std::string &GCName) {
   auto It = pImpl->GCNames.find(&Fn);
 
   if (It == pImpl->GCNames.end()) {
     pImpl->GCNames.insert(std::make_pair(&Fn, std::move(GCName)));
     return;
   }
   It->second = std::move(GCName);
 }

llvm/lib/IR/LLVMContextImpl.h

 struct AnonStructTypeKeyInfo {
   struct KeyTy {
     ArrayRef<Type*> ETypes;
     bool isPacked;
 
     KeyTy(const ArrayRef<Type*>& E, bool P) :
       ETypes(E), isPacked(P) {}
 
-    KeyTy(const StructType *ST)
+    explicit KeyTy(const StructType *ST)
         : ETypes(ST->elements()), isPacked(ST->isPacked()) {}
 
     bool operator==(const KeyTy& that) const {
       if (isPacked != that.isPacked)
         return false;
       if (ETypes != that.ETypes)
         return false;
       return true;

 struct FunctionTypeKeyInfo {
   struct KeyTy {
     const Type *ReturnType;
     ArrayRef<Type*> Params;
     bool isVarArg;
 
     KeyTy(const Type* R, const ArrayRef<Type*>& P, bool V) :
       ReturnType(R), Params(P), isVarArg(V) {}
-    KeyTy(const FunctionType *FT)
+    explicit KeyTy(const FunctionType *FT)
         : ReturnType(FT->getReturnType()), Params(FT->params()),
           isVarArg(FT->isVarArg()) {}
 
     bool operator==(const KeyTy& that) const {
       if (ReturnType != that.ReturnType)
         return false;
       if (isVarArg != that.isVarArg)
         return false;

 
 /// Structure for hashing arbitrary MDNode operands.
 class MDNodeOpsKey {
   ArrayRef<Metadata *> RawOps;
   ArrayRef<MDOperand> Ops;
   unsigned Hash;
 
 protected:
-  MDNodeOpsKey(ArrayRef<Metadata *> Ops)
+  explicit MDNodeOpsKey(ArrayRef<Metadata *> Ops)
       : RawOps(Ops), Hash(calculateHash(Ops)) {}
 
   template <class NodeTy>
-  MDNodeOpsKey(const NodeTy *N, unsigned Offset = 0)
+  explicit MDNodeOpsKey(const NodeTy *N, unsigned Offset = 0)
       : Ops(N->op_begin() + Offset, N->op_end()), Hash(N->getHash()) {}
 
   template <class NodeTy>
   bool compareOps(const NodeTy *RHS, unsigned Offset = 0) const {
     if (getHash() != RHS->getHash())
       return false;
 
     assert((RawOps.empty() || Ops.empty()) && "Two sets of operands?");
template <class NodeTy> struct MDNodeSubsetEqualImpl {
   }
 };
 
 /// DenseMapInfo for MDTuple.
 ///
 /// Note that we don't need the is-function-local bit, since that's implicit in
 /// the operands.
 template <> struct MDNodeKeyImpl<MDTuple> : MDNodeOpsKey {
-  MDNodeKeyImpl(ArrayRef<Metadata *> Ops) : MDNodeOpsKey(Ops) {}
-  MDNodeKeyImpl(const MDTuple *N) : MDNodeOpsKey(N) {}
+  explicit MDNodeKeyImpl(ArrayRef<Metadata *> Ops) : MDNodeOpsKey(Ops) {}
+  explicit MDNodeKeyImpl(const MDTuple *N) : MDNodeOpsKey(N) {}
 
   bool isKeyOf(const MDTuple *RHS) const { return compareOps(RHS); }
 
   unsigned getHashValue() const { return getHash(); }
 
   static unsigned calculateHash(MDTuple *N) {
     return MDNodeOpsKey::calculateHash(N);
   }
 };
 
 /// DenseMapInfo for DILocation.
 template <> struct MDNodeKeyImpl<DILocation> {
   unsigned Line;
   unsigned Column;
   Metadata *Scope;
   Metadata *InlinedAt;
   bool ImplicitCode;
 
   MDNodeKeyImpl(unsigned Line, unsigned Column, Metadata *Scope,
                 Metadata *InlinedAt, bool ImplicitCode)
       : Line(Line), Column(Column), Scope(Scope), InlinedAt(InlinedAt),
         ImplicitCode(ImplicitCode) {}
-  MDNodeKeyImpl(const DILocation *L)
+  explicit MDNodeKeyImpl(const DILocation *L)
       : Line(L->getLine()), Column(L->getColumn()), Scope(L->getRawScope()),
         InlinedAt(L->getRawInlinedAt()), ImplicitCode(L->isImplicitCode()) {}
 
   bool isKeyOf(const DILocation *RHS) const {
     return Line == RHS->getLine() && Column == RHS->getColumn() &&
            Scope == RHS->getRawScope() && InlinedAt == RHS->getRawInlinedAt() &&
            ImplicitCode == RHS->isImplicitCode();
   }
 
   unsigned getHashValue() const {
     return hash_combine(Line, Column, Scope, InlinedAt, ImplicitCode);
   }
 };
 
 /// DenseMapInfo for GenericDINode.
 template <> struct MDNodeKeyImpl<GenericDINode> : MDNodeOpsKey {
   unsigned Tag;
   MDString *Header;
 
   MDNodeKeyImpl(unsigned Tag, MDString *Header, ArrayRef<Metadata *> DwarfOps)
       : MDNodeOpsKey(DwarfOps), Tag(Tag), Header(Header) {}
-  MDNodeKeyImpl(const GenericDINode *N)
+  explicit MDNodeKeyImpl(const GenericDINode *N)
       : MDNodeOpsKey(N, 1), Tag(N->getTag()), Header(N->getRawHeader()) {}
 
   bool isKeyOf(const GenericDINode *RHS) const {
     return Tag == RHS->getTag() && Header == RHS->getRawHeader() &&
            compareOps(RHS, 1);
   }
 
   unsigned getHashValue() const { return hash_combine(getHash(), Tag, Header); }
 
   static unsigned calculateHash(GenericDINode *N) {
     return MDNodeOpsKey::calculateHash(N, 1);
   }
 };
 
 template <> struct MDNodeKeyImpl<DISubrange> {
   Metadata *CountNode;
   Metadata *LowerBound;
   Metadata *UpperBound;
   Metadata *Stride;
 
   MDNodeKeyImpl(Metadata *CountNode, Metadata *LowerBound, Metadata *UpperBound,
                 Metadata *Stride)
       : CountNode(CountNode), LowerBound(LowerBound), UpperBound(UpperBound),
         Stride(Stride) {}
-  MDNodeKeyImpl(const DISubrange *N)
+  explicit MDNodeKeyImpl(const DISubrange *N)
       : CountNode(N->getRawCountNode()), LowerBound(N->getRawLowerBound()),
         UpperBound(N->getRawUpperBound()), Stride(N->getRawStride()) {}
 
   bool isKeyOf(const DISubrange *RHS) const {
     auto BoundsEqual = [=](Metadata *Node1, Metadata *Node2) -> bool {
       if (Node1 == Node2)
         return true;
 
template <> struct MDNodeKeyImpl<DIGenericSubrange> {
   Metadata *LowerBound;
   Metadata *UpperBound;
   Metadata *Stride;
 
   MDNodeKeyImpl(Metadata *CountNode, Metadata *LowerBound, Metadata *UpperBound,
                 Metadata *Stride)
       : CountNode(CountNode), LowerBound(LowerBound), UpperBound(UpperBound),
         Stride(Stride) {}
-  MDNodeKeyImpl(const DIGenericSubrange *N)
+  explicit MDNodeKeyImpl(const DIGenericSubrange *N)
       : CountNode(N->getRawCountNode()), LowerBound(N->getRawLowerBound()),
         UpperBound(N->getRawUpperBound()), Stride(N->getRawStride()) {}
 
   bool isKeyOf(const DIGenericSubrange *RHS) const {
     return (CountNode == RHS->getRawCountNode()) &&
            (LowerBound == RHS->getRawLowerBound()) &&
            (UpperBound == RHS->getRawUpperBound()) &&
            (Stride == RHS->getRawStride());

 };
 
 template <> struct MDNodeKeyImpl<DIEnumerator> {
   APInt Value;
   MDString *Name;
   bool IsUnsigned;
 
   MDNodeKeyImpl(APInt Value, bool IsUnsigned, MDString *Name)
-      : Value(Value), Name(Name), IsUnsigned(IsUnsigned) {}
+      : Value(std::move(Value)), Name(Name), IsUnsigned(IsUnsigned) {}
   MDNodeKeyImpl(int64_t Value, bool IsUnsigned, MDString *Name)
       : Value(APInt(64, Value, !IsUnsigned)), Name(Name),
         IsUnsigned(IsUnsigned) {}
-  MDNodeKeyImpl(const DIEnumerator *N)
+  explicit MDNodeKeyImpl(const DIEnumerator *N)
       : Value(N->getValue()), Name(N->getRawName()),
         IsUnsigned(N->isUnsigned()) {}
 
   bool isKeyOf(const DIEnumerator *RHS) const {
     return APInt::isSameValue(Value, RHS->getValue()) &&
            IsUnsigned == RHS->isUnsigned() && Name == RHS->getRawName();
   }
 
   unsigned getHashValue() const { return hash_combine(Value, Name); }
 };
 
 template <> struct MDNodeKeyImpl<DIBasicType> {
   unsigned Tag;
   MDString *Name;
   uint64_t SizeInBits;
   uint32_t AlignInBits;
   unsigned Encoding;
   unsigned Flags;
 
   MDNodeKeyImpl(unsigned Tag, MDString *Name, uint64_t SizeInBits,
                 uint32_t AlignInBits, unsigned Encoding, unsigned Flags)
       : Tag(Tag), Name(Name), SizeInBits(SizeInBits), AlignInBits(AlignInBits),
         Encoding(Encoding), Flags(Flags) {}
-  MDNodeKeyImpl(const DIBasicType *N)
+  explicit MDNodeKeyImpl(const DIBasicType *N)
       : Tag(N->getTag()), Name(N->getRawName()), SizeInBits(N->getSizeInBits()),
-        AlignInBits(N->getAlignInBits()), Encoding(N->getEncoding()), Flags(N->getFlags()) {}
+        AlignInBits(N->getAlignInBits()), Encoding(N->getEncoding()),
+        Flags(N->getFlags()) {}
 
   bool isKeyOf(const DIBasicType *RHS) const {
     return Tag == RHS->getTag() && Name == RHS->getRawName() &&
            SizeInBits == RHS->getSizeInBits() &&
            AlignInBits == RHS->getAlignInBits() &&
-           Encoding == RHS->getEncoding() &&
-           Flags == RHS->getFlags();
+           Encoding == RHS->getEncoding() && Flags == RHS->getFlags();
   }
 
   unsigned getHashValue() const {
     return hash_combine(Tag, Name, SizeInBits, AlignInBits, Encoding);
   }
 };
 
 template <> struct MDNodeKeyImpl<DIStringType> {
   unsigned Tag;
   MDString *Name;
   Metadata *StringLength;
   Metadata *StringLengthExp;
   uint64_t SizeInBits;
   uint32_t AlignInBits;
   unsigned Encoding;
 
   MDNodeKeyImpl(unsigned Tag, MDString *Name, Metadata *StringLength,
                 Metadata *StringLengthExp, uint64_t SizeInBits,
                 uint32_t AlignInBits, unsigned Encoding)
       : Tag(Tag), Name(Name), StringLength(StringLength),
         StringLengthExp(StringLengthExp), SizeInBits(SizeInBits),
         AlignInBits(AlignInBits), Encoding(Encoding) {}
-  MDNodeKeyImpl(const DIStringType *N)
+  explicit MDNodeKeyImpl(const DIStringType *N)
       : Tag(N->getTag()), Name(N->getRawName()),
         StringLength(N->getRawStringLength()),
         StringLengthExp(N->getRawStringLengthExp()),
         SizeInBits(N->getSizeInBits()), AlignInBits(N->getAlignInBits()),
         Encoding(N->getEncoding()) {}
 
   bool isKeyOf(const DIStringType *RHS) const {
     return Tag == RHS->getTag() && Name == RHS->getRawName() &&
MDNodeKeyImpl(unsigned Tag, MDString *Name, Metadata *File, unsigned Line,
                 Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits,
                 uint32_t AlignInBits, uint64_t OffsetInBits,
                 Optional<unsigned> DWARFAddressSpace, unsigned Flags,
                 Metadata *ExtraData, Metadata *Annotations)
       : Tag(Tag), Name(Name), File(File), Line(Line), Scope(Scope),
         BaseType(BaseType), SizeInBits(SizeInBits), OffsetInBits(OffsetInBits),
         AlignInBits(AlignInBits), DWARFAddressSpace(DWARFAddressSpace),
         Flags(Flags), ExtraData(ExtraData), Annotations(Annotations) {}
-  MDNodeKeyImpl(const DIDerivedType *N)
+  explicit MDNodeKeyImpl(const DIDerivedType *N)
       : Tag(N->getTag()), Name(N->getRawName()), File(N->getRawFile()),
         Line(N->getLine()), Scope(N->getRawScope()),
         BaseType(N->getRawBaseType()), SizeInBits(N->getSizeInBits()),
         OffsetInBits(N->getOffsetInBits()), AlignInBits(N->getAlignInBits()),
         DWARFAddressSpace(N->getDWARFAddressSpace()), Flags(N->getFlags()),
         ExtraData(N->getRawExtraData()), Annotations(N->getRawAnnotations()) {}
 
   bool isKeyOf(const DIDerivedType *RHS) const {
MDNodeKeyImpl(unsigned Tag, MDString *Name, Metadata *File, unsigned Line,
       : Tag(Tag), Name(Name), File(File), Line(Line), Scope(Scope),
         BaseType(BaseType), SizeInBits(SizeInBits), OffsetInBits(OffsetInBits),
         AlignInBits(AlignInBits), Flags(Flags), Elements(Elements),
         RuntimeLang(RuntimeLang), VTableHolder(VTableHolder),
         TemplateParams(TemplateParams), Identifier(Identifier),
         Discriminator(Discriminator), DataLocation(DataLocation),
         Associated(Associated), Allocated(Allocated), Rank(Rank),
         Annotations(Annotations) {}
-  MDNodeKeyImpl(const DICompositeType *N)
+  explicit MDNodeKeyImpl(const DICompositeType *N)
       : Tag(N->getTag()), Name(N->getRawName()), File(N->getRawFile()),
         Line(N->getLine()), Scope(N->getRawScope()),
         BaseType(N->getRawBaseType()), SizeInBits(N->getSizeInBits()),
         OffsetInBits(N->getOffsetInBits()), AlignInBits(N->getAlignInBits()),
         Flags(N->getFlags()), Elements(N->getRawElements()),
         RuntimeLang(N->getRuntimeLang()), VTableHolder(N->getRawVTableHolder()),
         TemplateParams(N->getRawTemplateParams()),
         Identifier(N->getRawIdentifier()),

 
 template <> struct MDNodeKeyImpl<DISubroutineType> {
   unsigned Flags;
   uint8_t CC;
   Metadata *TypeArray;
 
   MDNodeKeyImpl(unsigned Flags, uint8_t CC, Metadata *TypeArray)
       : Flags(Flags), CC(CC), TypeArray(TypeArray) {}
-  MDNodeKeyImpl(const DISubroutineType *N)
+  explicit MDNodeKeyImpl(const DISubroutineType *N)
       : Flags(N->getFlags()), CC(N->getCC()), TypeArray(N->getRawTypeArray()) {}
 
   bool isKeyOf(const DISubroutineType *RHS) const {
     return Flags == RHS->getFlags() && CC == RHS->getCC() &&
            TypeArray == RHS->getRawTypeArray();
   }
 
   unsigned getHashValue() const { return hash_combine(Flags, CC, TypeArray); }
 };
 
 template <> struct MDNodeKeyImpl<DIFile> {
   MDString *Filename;
   MDString *Directory;
   Optional<DIFile::ChecksumInfo<MDString *>> Checksum;
   Optional<MDString *> Source;
 
   MDNodeKeyImpl(MDString *Filename, MDString *Directory,
                 Optional<DIFile::ChecksumInfo<MDString *>> Checksum,
                 Optional<MDString *> Source)
       : Filename(Filename), Directory(Directory), Checksum(Checksum),
         Source(Source) {}
-  MDNodeKeyImpl(const DIFile *N)
+  explicit MDNodeKeyImpl(const DIFile *N)
       : Filename(N->getRawFilename()), Directory(N->getRawDirectory()),
         Checksum(N->getRawChecksum()), Source(N->getRawSource()) {}
 
   bool isKeyOf(const DIFile *RHS) const {
     return Filename == RHS->getRawFilename() &&
            Directory == RHS->getRawDirectory() &&
            Checksum == RHS->getRawChecksum() &&
            Source == RHS->getRawSource();
MDNodeKeyImpl(Metadata *Scope, MDString *Name, MDString *LinkageName,
                 Metadata *ThrownTypes, Metadata *Annotations)
       : Scope(Scope), Name(Name), LinkageName(LinkageName), File(File),
         Line(Line), Type(Type), ScopeLine(ScopeLine),
         ContainingType(ContainingType), VirtualIndex(VirtualIndex),
         ThisAdjustment(ThisAdjustment), Flags(Flags), SPFlags(SPFlags),
         Unit(Unit), TemplateParams(TemplateParams), Declaration(Declaration),
         RetainedNodes(RetainedNodes), ThrownTypes(ThrownTypes),
         Annotations(Annotations) {}
-  MDNodeKeyImpl(const DISubprogram *N)
+  explicit MDNodeKeyImpl(const DISubprogram *N)
       : Scope(N->getRawScope()), Name(N->getRawName()),
         LinkageName(N->getRawLinkageName()), File(N->getRawFile()),
         Line(N->getLine()), Type(N->getRawType()), ScopeLine(N->getScopeLine()),
         ContainingType(N->getRawContainingType()),
         VirtualIndex(N->getVirtualIndex()),
         ThisAdjustment(N->getThisAdjustment()), Flags(N->getFlags()),
         SPFlags(N->getSPFlags()), Unit(N->getRawUnit()),
         TemplateParams(N->getRawTemplateParams()),
         Declaration(N->getRawDeclaration()),
         RetainedNodes(N->getRawRetainedNodes()),
-        ThrownTypes(N->getRawThrownTypes()), Annotations(N->getRawAnnotations())
-        {}
+        ThrownTypes(N->getRawThrownTypes()),
+        Annotations(N->getRawAnnotations()) {}
 
   bool isKeyOf(const DISubprogram *RHS) const {
     return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
            LinkageName == RHS->getRawLinkageName() &&
            File == RHS->getRawFile() && Line == RHS->getLine() &&
            Type == RHS->getRawType() && ScopeLine == RHS->getScopeLine() &&
            ContainingType == RHS->getRawContainingType() &&
            VirtualIndex == RHS->getVirtualIndex() &&

 template <> struct MDNodeKeyImpl<DILexicalBlock> {
   Metadata *Scope;
   Metadata *File;
   unsigned Line;
   unsigned Column;
 
   MDNodeKeyImpl(Metadata *Scope, Metadata *File, unsigned Line, unsigned Column)
       : Scope(Scope), File(File), Line(Line), Column(Column) {}
-  MDNodeKeyImpl(const DILexicalBlock *N)
+  explicit MDNodeKeyImpl(const DILexicalBlock *N)
       : Scope(N->getRawScope()), File(N->getRawFile()), Line(N->getLine()),
         Column(N->getColumn()) {}
 
   bool isKeyOf(const DILexicalBlock *RHS) const {
     return Scope == RHS->getRawScope() && File == RHS->getRawFile() &&
            Line == RHS->getLine() && Column == RHS->getColumn();
   }
 
   unsigned getHashValue() const {
     return hash_combine(Scope, File, Line, Column);
   }
 };
 
 template <> struct MDNodeKeyImpl<DILexicalBlockFile> {
   Metadata *Scope;
   Metadata *File;
   unsigned Discriminator;
 
   MDNodeKeyImpl(Metadata *Scope, Metadata *File, unsigned Discriminator)
       : Scope(Scope), File(File), Discriminator(Discriminator) {}
-  MDNodeKeyImpl(const DILexicalBlockFile *N)
+  explicit MDNodeKeyImpl(const DILexicalBlockFile *N)
       : Scope(N->getRawScope()), File(N->getRawFile()),
         Discriminator(N->getDiscriminator()) {}
 
   bool isKeyOf(const DILexicalBlockFile *RHS) const {
     return Scope == RHS->getRawScope() && File == RHS->getRawFile() &&
            Discriminator == RHS->getDiscriminator();
   }
 
   unsigned getHashValue() const {
     return hash_combine(Scope, File, Discriminator);
   }
 };
 
 template <> struct MDNodeKeyImpl<DINamespace> {
   Metadata *Scope;
   MDString *Name;
   bool ExportSymbols;
 
   MDNodeKeyImpl(Metadata *Scope, MDString *Name, bool ExportSymbols)
       : Scope(Scope), Name(Name), ExportSymbols(ExportSymbols) {}
-  MDNodeKeyImpl(const DINamespace *N)
+  explicit MDNodeKeyImpl(const DINamespace *N)
       : Scope(N->getRawScope()), Name(N->getRawName()),
         ExportSymbols(N->getExportSymbols()) {}
 
   bool isKeyOf(const DINamespace *RHS) const {
     return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
            ExportSymbols == RHS->getExportSymbols();
   }
 
   unsigned getHashValue() const {
     return hash_combine(Scope, Name);
   }
 };
 
 template <> struct MDNodeKeyImpl<DICommonBlock> {
   Metadata *Scope;
   Metadata *Decl;
   MDString *Name;
   Metadata *File;
   unsigned LineNo;
 
   MDNodeKeyImpl(Metadata *Scope, Metadata *Decl, MDString *Name,
                 Metadata *File, unsigned LineNo)
       : Scope(Scope), Decl(Decl), Name(Name), File(File), LineNo(LineNo) {}
-  MDNodeKeyImpl(const DICommonBlock *N)
+  explicit MDNodeKeyImpl(const DICommonBlock *N)
       : Scope(N->getRawScope()), Decl(N->getRawDecl()), Name(N->getRawName()),
         File(N->getRawFile()), LineNo(N->getLineNo()) {}
 
   bool isKeyOf(const DICommonBlock *RHS) const {
     return Scope == RHS->getRawScope() && Decl == RHS->getRawDecl() &&
       Name == RHS->getRawName() && File == RHS->getRawFile() &&
       LineNo == RHS->getLineNo();
   }
template <> struct MDNodeKeyImpl<DIModule> {
   bool IsDecl;
 
   MDNodeKeyImpl(Metadata *File, Metadata *Scope, MDString *Name,
                 MDString *ConfigurationMacros, MDString *IncludePath,
                 MDString *APINotesFile, unsigned LineNo, bool IsDecl)
       : File(File), Scope(Scope), Name(Name),
         ConfigurationMacros(ConfigurationMacros), IncludePath(IncludePath),
         APINotesFile(APINotesFile), LineNo(LineNo), IsDecl(IsDecl) {}
-  MDNodeKeyImpl(const DIModule *N)
+  explicit MDNodeKeyImpl(const DIModule *N)
       : File(N->getRawFile()), Scope(N->getRawScope()), Name(N->getRawName()),
         ConfigurationMacros(N->getRawConfigurationMacros()),
         IncludePath(N->getRawIncludePath()),
         APINotesFile(N->getRawAPINotesFile()), LineNo(N->getLineNo()),
         IsDecl(N->getIsDecl()) {}
 
   bool isKeyOf(const DIModule *RHS) const {
     return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&

 
 template <> struct MDNodeKeyImpl<DITemplateTypeParameter> {
   MDString *Name;
   Metadata *Type;
   bool IsDefault;
 
   MDNodeKeyImpl(MDString *Name, Metadata *Type, bool IsDefault)
       : Name(Name), Type(Type), IsDefault(IsDefault) {}
-  MDNodeKeyImpl(const DITemplateTypeParameter *N)
+  explicit MDNodeKeyImpl(const DITemplateTypeParameter *N)
       : Name(N->getRawName()), Type(N->getRawType()),
         IsDefault(N->isDefault()) {}
 
   bool isKeyOf(const DITemplateTypeParameter *RHS) const {
     return Name == RHS->getRawName() && Type == RHS->getRawType() &&
            IsDefault == RHS->isDefault();
   }
 
   unsigned getHashValue() const { return hash_combine(Name, Type, IsDefault); }
 };
 
 template <> struct MDNodeKeyImpl<DITemplateValueParameter> {
   unsigned Tag;
   MDString *Name;
   Metadata *Type;
   bool IsDefault;
   Metadata *Value;
 
   MDNodeKeyImpl(unsigned Tag, MDString *Name, Metadata *Type, bool IsDefault,
                 Metadata *Value)
       : Tag(Tag), Name(Name), Type(Type), IsDefault(IsDefault), Value(Value) {}
-  MDNodeKeyImpl(const DITemplateValueParameter *N)
+  explicit MDNodeKeyImpl(const DITemplateValueParameter *N)
       : Tag(N->getTag()), Name(N->getRawName()), Type(N->getRawType()),
         IsDefault(N->isDefault()), Value(N->getValue()) {}
 
   bool isKeyOf(const DITemplateValueParameter *RHS) const {
     return Tag == RHS->getTag() && Name == RHS->getRawName() &&
            Type == RHS->getRawType() && IsDefault == RHS->isDefault() &&
            Value == RHS->getValue();
   }
MDNodeKeyImpl(Metadata *Scope, MDString *Name, MDString *LinkageName,
                 Metadata *StaticDataMemberDeclaration, Metadata *TemplateParams,
                 uint32_t AlignInBits, Metadata *Annotations)
       : Scope(Scope), Name(Name), LinkageName(LinkageName), File(File),
         Line(Line), Type(Type), IsLocalToUnit(IsLocalToUnit),
         IsDefinition(IsDefinition),
         StaticDataMemberDeclaration(StaticDataMemberDeclaration),
         TemplateParams(TemplateParams), AlignInBits(AlignInBits),
         Annotations(Annotations) {}
-  MDNodeKeyImpl(const DIGlobalVariable *N)
+  explicit MDNodeKeyImpl(const DIGlobalVariable *N)
       : Scope(N->getRawScope()), Name(N->getRawName()),
         LinkageName(N->getRawLinkageName()), File(N->getRawFile()),
         Line(N->getLine()), Type(N->getRawType()),
         IsLocalToUnit(N->isLocalToUnit()), IsDefinition(N->isDefinition()),
         StaticDataMemberDeclaration(N->getRawStaticDataMemberDeclaration()),
         TemplateParams(N->getRawTemplateParams()),
         AlignInBits(N->getAlignInBits()), Annotations(N->getRawAnnotations()) {}
 
template <> struct MDNodeKeyImpl<DILocalVariable> {
   uint32_t AlignInBits;
   Metadata *Annotations;
 
   MDNodeKeyImpl(Metadata *Scope, MDString *Name, Metadata *File, unsigned Line,
                 Metadata *Type, unsigned Arg, unsigned Flags,
                 uint32_t AlignInBits, Metadata *Annotations)
       : Scope(Scope), Name(Name), File(File), Line(Line), Type(Type), Arg(Arg),
         Flags(Flags), AlignInBits(AlignInBits), Annotations(Annotations) {}
-  MDNodeKeyImpl(const DILocalVariable *N)
+  explicit MDNodeKeyImpl(const DILocalVariable *N)
       : Scope(N->getRawScope()), Name(N->getRawName()), File(N->getRawFile()),
         Line(N->getLine()), Type(N->getRawType()), Arg(N->getArg()),
         Flags(N->getFlags()), AlignInBits(N->getAlignInBits()),
         Annotations(N->getRawAnnotations()) {}
 
   bool isKeyOf(const DILocalVariable *RHS) const {
     return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
            File == RHS->getRawFile() && Line == RHS->getLine() &&

 template <> struct MDNodeKeyImpl<DILabel> {
   Metadata *Scope;
   MDString *Name;
   Metadata *File;
   unsigned Line;
 
   MDNodeKeyImpl(Metadata *Scope, MDString *Name, Metadata *File, unsigned Line)
       : Scope(Scope), Name(Name), File(File), Line(Line) {}
-  MDNodeKeyImpl(const DILabel *N)
+  explicit MDNodeKeyImpl(const DILabel *N)
       : Scope(N->getRawScope()), Name(N->getRawName()), File(N->getRawFile()),
         Line(N->getLine()) {}
 
   bool isKeyOf(const DILabel *RHS) const {
     return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
            File == RHS->getRawFile() && Line == RHS->getLine();
   }
 
   /// Using name and line to get hash value. It should already be mostly unique.
   unsigned getHashValue() const {
     return hash_combine(Scope, Name, Line);
   }
 };
 
 template <> struct MDNodeKeyImpl<DIExpression> {
   ArrayRef<uint64_t> Elements;
 
-  MDNodeKeyImpl(ArrayRef<uint64_t> Elements) : Elements(Elements) {}
-  MDNodeKeyImpl(const DIExpression *N) : Elements(N->getElements()) {}
+  explicit MDNodeKeyImpl(ArrayRef<uint64_t> Elements) : Elements(Elements) {}
+  explicit MDNodeKeyImpl(const DIExpression *N) : Elements(N->getElements()) {}
 
   bool isKeyOf(const DIExpression *RHS) const {
     return Elements == RHS->getElements();
   }
 
   unsigned getHashValue() const {
     return hash_combine_range(Elements.begin(), Elements.end());
   }
 };
 
 template <> struct MDNodeKeyImpl<DIGlobalVariableExpression> {
   Metadata *Variable;
   Metadata *Expression;
 
   MDNodeKeyImpl(Metadata *Variable, Metadata *Expression)
       : Variable(Variable), Expression(Expression) {}
-  MDNodeKeyImpl(const DIGlobalVariableExpression *N)
+  explicit MDNodeKeyImpl(const DIGlobalVariableExpression *N)
       : Variable(N->getRawVariable()), Expression(N->getRawExpression()) {}
 
   bool isKeyOf(const DIGlobalVariableExpression *RHS) const {
     return Variable == RHS->getRawVariable() &&
            Expression == RHS->getRawExpression();
   }
 
   unsigned getHashValue() const { return hash_combine(Variable, Expression); }
 };
 
 template <> struct MDNodeKeyImpl<DIObjCProperty> {
   MDString *Name;
   Metadata *File;
   unsigned Line;
   MDString *GetterName;
   MDString *SetterName;
   unsigned Attributes;
   Metadata *Type;
 
   MDNodeKeyImpl(MDString *Name, Metadata *File, unsigned Line,
                 MDString *GetterName, MDString *SetterName, unsigned Attributes,
                 Metadata *Type)
       : Name(Name), File(File), Line(Line), GetterName(GetterName),
         SetterName(SetterName), Attributes(Attributes), Type(Type) {}
-  MDNodeKeyImpl(const DIObjCProperty *N)
+  explicit MDNodeKeyImpl(const DIObjCProperty *N)
       : Name(N->getRawName()), File(N->getRawFile()), Line(N->getLine()),
         GetterName(N->getRawGetterName()), SetterName(N->getRawSetterName()),
         Attributes(N->getAttributes()), Type(N->getRawType()) {}
 
   bool isKeyOf(const DIObjCProperty *RHS) const {
     return Name == RHS->getRawName() && File == RHS->getRawFile() &&
            Line == RHS->getLine() && GetterName == RHS->getRawGetterName() &&
            SetterName == RHS->getRawSetterName() &&
template <> struct MDNodeKeyImpl<DIImportedEntity> {
   unsigned Line;
   MDString *Name;
   Metadata *Elements;
 
   MDNodeKeyImpl(unsigned Tag, Metadata *Scope, Metadata *Entity, Metadata *File,
                 unsigned Line, MDString *Name, Metadata *Elements)
       : Tag(Tag), Scope(Scope), Entity(Entity), File(File), Line(Line),
         Name(Name), Elements(Elements) {}
-  MDNodeKeyImpl(const DIImportedEntity *N)
+  explicit MDNodeKeyImpl(const DIImportedEntity *N)
       : Tag(N->getTag()), Scope(N->getRawScope()), Entity(N->getRawEntity()),
         File(N->getRawFile()), Line(N->getLine()), Name(N->getRawName()),
         Elements(N->getRawElements()) {}
 
   bool isKeyOf(const DIImportedEntity *RHS) const {
     return Tag == RHS->getTag() && Scope == RHS->getRawScope() &&
            Entity == RHS->getRawEntity() && File == RHS->getFile() &&
            Line == RHS->getLine() && Name == RHS->getRawName() &&
            Elements == RHS->getRawElements();
   }
 
   unsigned getHashValue() const {
     return hash_combine(Tag, Scope, Entity, File, Line, Name, Elements);
   }
 };
 
 template <> struct MDNodeKeyImpl<DIMacro> {
   unsigned MIType;
   unsigned Line;
   MDString *Name;
   MDString *Value;
 
   MDNodeKeyImpl(unsigned MIType, unsigned Line, MDString *Name, MDString *Value)
       : MIType(MIType), Line(Line), Name(Name), Value(Value) {}
-  MDNodeKeyImpl(const DIMacro *N)
+  explicit MDNodeKeyImpl(const DIMacro *N)
       : MIType(N->getMacinfoType()), Line(N->getLine()), Name(N->getRawName()),
         Value(N->getRawValue()) {}
 
   bool isKeyOf(const DIMacro *RHS) const {
     return MIType == RHS->getMacinfoType() && Line == RHS->getLine() &&
            Name == RHS->getRawName() && Value == RHS->getRawValue();
   }
 
   unsigned getHashValue() const {
     return hash_combine(MIType, Line, Name, Value);
   }
 };
 
 template <> struct MDNodeKeyImpl<DIMacroFile> {
   unsigned MIType;
   unsigned Line;
   Metadata *File;
   Metadata *Elements;
 
   MDNodeKeyImpl(unsigned MIType, unsigned Line, Metadata *File,
                 Metadata *Elements)
       : MIType(MIType), Line(Line), File(File), Elements(Elements) {}
-  MDNodeKeyImpl(const DIMacroFile *N)
+  explicit MDNodeKeyImpl(const DIMacroFile *N)
       : MIType(N->getMacinfoType()), Line(N->getLine()), File(N->getRawFile()),
         Elements(N->getRawElements()) {}
 
   bool isKeyOf(const DIMacroFile *RHS) const {
     return MIType == RHS->getMacinfoType() && Line == RHS->getLine() &&
            File == RHS->getRawFile() && Elements == RHS->getRawElements();
   }
 
   unsigned getHashValue() const {
     return hash_combine(MIType, Line, File, Elements);
   }
 };
 
 template <> struct MDNodeKeyImpl<DIArgList> {
   ArrayRef<ValueAsMetadata *> Args;
 
-  MDNodeKeyImpl(ArrayRef<ValueAsMetadata *> Args) : Args(Args) {}
-  MDNodeKeyImpl(const DIArgList *N) : Args(N->getArgs()) {}
+  explicit MDNodeKeyImpl(ArrayRef<ValueAsMetadata *> Args) : Args(Args) {}
+  explicit MDNodeKeyImpl(const DIArgList *N) : Args(N->getArgs()) {}
 
   bool isKeyOf(const DIArgList *RHS) const { return Args == RHS->getArgs(); }
 
   unsigned getHashValue() const {
     return hash_combine_range(Args.begin(), Args.end());
   }
 };
 
#include "llvm/IR/Metadata.def"
   /// do not use GC (i.e., most programs) at the cost of increased overhead for
   /// clients which do use GC.
   DenseMap<const Function*, std::string> GCNames;
 
   /// Flag to indicate if Value (other than GlobalValue) retains their name or
   /// not.
   bool DiscardValueNames = false;
 
-  LLVMContextImpl(LLVMContext &C);
+  explicit LLVMContextImpl(LLVMContext &C);
   ~LLVMContextImpl();
 
   /// Destroy the ConstantArrays if they are not used.
   void dropTriviallyDeadConstantArrays();
 
   mutable OptPassGate *OPG = nullptr;
 
   /// Access the object which can disable optional passes and individual

llvm/lib/IR/LegacyPassManager.cpp

static cl::opt<enum PassDebugLevel> PassDebugging(
     cl::values(clEnumVal(Disabled, "disable debug output"),
                clEnumVal(Arguments, "print pass arguments to pass to 'opt'"),
                clEnumVal(Structure, "print pass structure before run()"),
                clEnumVal(Executions, "print pass name before it is executed"),
                clEnumVal(Details, "print pass details when it is executed")));
 
 /// isPassDebuggingExecutionsOrMore - Return true if -debug-pass=Executions
 /// or higher is specified.
-bool PMDataManager::isPassDebuggingExecutionsOrMore() const {
+bool PMDataManager::isPassDebuggingExecutionsOrMore() {
   return PassDebugging >= Executions;
 }
 
 unsigned PMDataManager::initSizeRemarkInfo(
     Module &M, StringMap<std::pair<unsigned, unsigned>> &FunctionToInstrCount) {
   // Only calculate getInstructionCount if the size-info remark is requested.
   unsigned InstrCount = 0;
 
for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index)
     Changed |= getContainedManager(Index)->doInitialization(M);
 
   return Changed;
 }
 
 bool FunctionPassManagerImpl::doFinalization(Module &M) {
   bool Changed = false;
 
-  for (int Index = getNumContainedManagers() - 1; Index >= 0; --Index)
-    Changed |= getContainedManager(Index)->doFinalization(M);
+  for (unsigned Index = getNumContainedManagers(); Index > 0; --Index)
+    Changed |= getContainedManager(Index - 1)->doFinalization(M);
 
   for (ImmutablePass *ImPass : getImmutablePasses())
     Changed |= ImPass->doFinalization(M);
 
   return Changed;
 }
 
 void FunctionPassManagerImpl::releaseMemoryOnTheFly() {
void PMDataManager::freePass(Pass *P, StringRef Msg,
 
   AnalysisID PI = P->getPassID();
   if (const PassInfo *PInf = TPM->findAnalysisPassInfo(PI)) {
     // Remove the pass itself (if it is not already removed).
     AvailableAnalysis.erase(PI);
 
     // Remove all interfaces this pass implements, for which it is also
     // listed as the available implementation.
-    const std::vector<const PassInfo*> &II = PInf->getInterfacesImplemented();
-    for (unsigned i = 0, e = II.size(); i != e; ++i) {
-      DenseMap<AnalysisID, Pass*>::iterator Pos =
-        AvailableAnalysis.find(II[i]->getTypeInfo());
+    const std::vector<const PassInfo *> &II = PInf->getInterfacesImplemented();
+    for (auto *I : II) {
+      DenseMap<AnalysisID, Pass *>::iterator Pos =
+          AvailableAnalysis.find(I->getTypeInfo());
       if (Pos != AvailableAnalysis.end() && Pos->second == P)
         AvailableAnalysis.erase(Pos);
     }
   }
 }
 
 /// Add pass P into the PassVector. Update
 /// AvailableAnalysis appropriately if ProcessAnalysis is true.
for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index)
     Changed |= getContainedPass(Index)->doInitialization(M);
 
   return Changed;
 }
 
 bool FPPassManager::doFinalization(Module &M) {
   bool Changed = false;
 
-  for (int Index = getNumContainedPasses() - 1; Index >= 0; --Index)
-    Changed |= getContainedPass(Index)->doFinalization(M);
+  for (unsigned Index = getNumContainedPasses(); Index > 0; --Index)
+    Changed |= getContainedPass(Index - 1)->doFinalization(M);
 
   return Changed;
 }
 
 //===----------------------------------------------------------------------===//
 // MPPassManager implementation
 
 /// Execute all of the passes scheduled for execution by invoking
#endif
     verifyPreservedAnalysis(MP);
     if (LocalChanged)
       removeNotPreservedAnalysis(MP);
     recordAvailableAnalysis(MP);
     removeDeadPasses(MP, M.getModuleIdentifier(), ON_MODULE_MSG);
   }
 
   // Finalize module passes
-  for (int Index = getNumContainedPasses() - 1; Index >= 0; --Index)
-    Changed |= getContainedPass(Index)->doFinalization(M);
+  for (unsigned Index = getNumContainedPasses(); Index > 0; --Index)
+    Changed |= getContainedPass(Index - 1)->doFinalization(M);
 
   // Finalize on-the-fly passes
   for (auto &OnTheFlyManager : OnTheFlyManagers) {
     legacy::FunctionPassManagerImpl *FPP = OnTheFlyManager.second;
     // We don't know when is the last time an on-the-fly pass is run,
     // so we need to releaseMemory / finalize here
     FPP->releaseMemoryOnTheFly();
     Changed |= FPP->doFinalization(M);
if (PM->getPassManagerType() != PMT_FunctionPassManager) {
     PMS.push(FPP);
     PM = FPP;
   }
 
   // Assign FPP as the manager of this pass.
   PM->add(this);
 }
 
-legacy::PassManagerBase::~PassManagerBase() {}
+legacy::PassManagerBase::~PassManagerBase() = default;

llvm/lib/IR/Metadata.cpp

case CLASS##Kind:                                                            \
     delete cast<CLASS>(this);                                                  \
     break;
 #include "llvm/IR/Metadata.def"
   }
 }
 
 template <class T, class InfoT>
 static T *uniquifyImpl(T *N, DenseSet<T *, InfoT> &Store) {
   if (T *U = getUniqued(Store, N))
     return U;
 
   Store.insert(N);
   return N;
 }
 
 template <class NodeTy> struct MDNode::HasCachedHash {
   using Yes = char[1];
if (!A || !B)
     return nullptr;
 
   if (A == B)
     return A;
 
   // First, walk both lists in order of the lower boundary of each interval.
   // At each step, try to merge the new interval to the last one we adedd.
   SmallVector<ConstantInt *, 4> EndPoints;
-  int AI = 0;
-  int BI = 0;
-  int AN = A->getNumOperands() / 2;
-  int BN = B->getNumOperands() / 2;
+  unsigned AI = 0;
+  unsigned BI = 0;
+  unsigned AN = A->getNumOperands() / 2;
+  unsigned BN = B->getNumOperands() / 2;
   while (AI < AN && BI < BN) {
     ConstantInt *ALow = mdconst::extract<ConstantInt>(A->getOperand(2 * AI));
     ConstantInt *BLow = mdconst::extract<ConstantInt>(B->getOperand(2 * BI));
 
     if (ALow->getValue().slt(BLow->getValue())) {
       addRange(EndPoints, ALow,
                mdconst::extract<ConstantInt>(A->getOperand(2 * AI + 1)));
       ++AI;
MDNode *MDNode::getMostGenericRange(MDNode *A, MDNode *B) {
   while (BI < BN) {
     addRange(EndPoints, mdconst::extract<ConstantInt>(B->getOperand(2 * BI)),
              mdconst::extract<ConstantInt>(B->getOperand(2 * BI + 1)));
     ++BI;
   }
 
   // If we have more than 2 ranges (4 endpoints) we have to try to merge
   // the last and first ones.
-  unsigned Size = EndPoints.size();
+  size_t Size = EndPoints.size();
   if (Size > 4) {
     ConstantInt *FB = EndPoints[0];
     ConstantInt *FE = EndPoints[1];
     if (tryMergeRange(EndPoints, FB, FE)) {
-      for (unsigned i = 0; i < Size - 2; ++i) {
+      for (size_t i = 0; i < Size - 2; ++i) {
         EndPoints[i] = EndPoints[i + 2];
       }
       EndPoints.resize(Size - 2);
     }
   }
 
   // If in the end we have a single range, it is possible that it is now the
   // full range. Just drop the metadata in that case.

llvm/lib/IR/ModuleSummaryIndex.cpp

GlobalValue::VisibilityTypes ValueInfo::getELFVisibility() const {
   return HasProtected ? GlobalValue::ProtectedVisibility
                       : GlobalValue::DefaultVisibility;
 }
 
 bool ValueInfo::isDSOLocal(bool WithDSOLocalPropagation) const {
   // With DSOLocal propagation done, the flag in evey summary is the same.
   // Check the first one is enough.
   return WithDSOLocalPropagation
-             ? getSummaryList().size() && getSummaryList()[0]->isDSOLocal()
-             : getSummaryList().size() &&
+             ? !getSummaryList().empty() && getSummaryList()[0]->isDSOLocal()
+             : !getSummaryList().empty() &&
                    llvm::all_of(
                        getSummaryList(),
                        [](const std::unique_ptr<GlobalValueSummary> &Summary) {
                          return Summary->isDSOLocal();
                        });
 }
 
 bool ValueInfo::canAutoHide() const {
   // Can only auto hide if all copies are eligible to auto hide.
-  return getSummaryList().size() &&
+  return !getSummaryList().empty() &&
          llvm::all_of(getSummaryList(),
                       [](const std::unique_ptr<GlobalValueSummary> &Summary) {
                         return Summary->canAutoHide();
                       });
 }
 
 // Gets the number of readonly and writeonly refs in RefEdgeList
 std::pair<unsigned, unsigned> FunctionSummary::specialRefCounts() const {
   // Here we take advantage of having all readonly and writeonly references
   // located in the end of the RefEdgeList.
   auto Refs = refs();
   unsigned RORefCnt = 0, WORefCnt = 0;
-  int I;
-  for (I = Refs.size() - 1; I >= 0 && Refs[I].isWriteOnly(); --I)
+  unsigned I;
+  for (I = Refs.size(); I > 0 && Refs[I - 1].isWriteOnly(); --I)
     WORefCnt++;
-  for (; I >= 0 && Refs[I].isReadOnly(); --I)
+  for (; I > 0 && Refs[I - 1].isReadOnly(); --I)
     RORefCnt++;
   return {RORefCnt, WORefCnt};
 }
 
 constexpr uint64_t ModuleSummaryIndex::BitcodeSummaryVersion;
 
 uint64_t ModuleSummaryIndex::getFlags() const {
   uint64_t Flags = 0;
if (!IsDSOLocal)
       for (const std::unique_ptr<GlobalValueSummary> &Summary :
            P.second.SummaryList)
         Summary->setDSOLocal(false);
   }
   setWithAttributePropagation();
   setWithDSOLocalPropagation();
   if (llvm::AreStatisticsEnabled())
     for (auto &P : *this)
-      if (P.second.SummaryList.size())
+      if (!P.second.SummaryList.empty())
         if (auto *GVS = dyn_cast<GlobalVarSummary>(
                 P.second.SummaryList[0]->getBaseObject()))
           if (isGlobalValueLive(GVS)) {
             if (GVS->maybeReadOnly())
               ReadOnlyLiveGVars++;
             if (GVS->maybeWriteOnly())
               WriteOnlyLiveGVars++;
           }
auto HasRefsPreventingImport = [this](const GlobalVarSummary *GVS) {
     // be imported. Not doing so will result in:
     // a) GV internalization in source module (because it's writeonly)
     // b) Importing of GV declaration to destination module as a result
     //    of promotion.
     // c) Link error (external declaration with internal definition).
     // However we do not promote objects referenced by writeonly GV
     // initializer by means of converting it to 'zeroinitializer'
     return !(ImportConstantsWithRefs && GVS->isConstant()) &&
-           !isReadOnly(GVS) && !isWriteOnly(GVS) && GVS->refs().size();
+           !isReadOnly(GVS) && !isWriteOnly(GVS) && !GVS->refs().empty();
   };
   auto *GVS = cast<GlobalVarSummary>(S->getBaseObject());
 
   // Global variable with non-trivial initializer can be imported
   // if it's readonly. This gives us extra opportunities for constant
   // folding and converting indirect calls to direct calls. We don't
   // analyze GV references during attribute propagation, because we
   // don't know yet if it is readonly or not.

llvm/lib/IR/Operator.cpp

 
 Align GEPOperator::getMaxPreservedAlignment(const DataLayout &DL) const {
   /// compute the worse possible offset for every level of the GEP et accumulate
   /// the minimum alignment into Result.
 
   Align Result = Align(llvm::Value::MaximumAlignment);
   for (gep_type_iterator GTI = gep_type_begin(this), GTE = gep_type_end(this);
        GTI != GTE; ++GTI) {
-    int64_t Offset = 1;
+    uint64_t Offset;
     ConstantInt *OpC = dyn_cast<ConstantInt>(GTI.getOperand());
 
     if (StructType *STy = GTI.getStructTypeOrNull()) {
       const StructLayout *SL = DL.getStructLayout(STy);
       Offset = SL->getElementOffset(OpC->getZExtValue());
     } else {
       assert(GTI.isSequential() && "should be sequencial");
       /// If the index isn't know we take 1 because it is the index that will
       /// give the worse alignment of the offset.
-      int64_t ElemCount = 1;
-      if (OpC)
-        ElemCount = OpC->getZExtValue();
+      const uint64_t ElemCount = OpC ? OpC->getZExtValue() : 1;
       Offset = DL.getTypeAllocSize(GTI.getIndexedType()) * ElemCount;
     }
     Result = Align(MinAlign(Offset, Result.value()));
   }
   return Result;
 }
 
 bool GEPOperator::accumulateConstantOffset(

llvm/lib/IR/OptBisect.cpp

 #include "llvm/Pass.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <limits>
 
 using namespace llvm;
 
-static cl::opt<int> OptBisectLimit("opt-bisect-limit", cl::Hidden,
-                                   cl::init(OptBisect::Disabled), cl::Optional,
-                                   cl::cb<void, int>([](int Limit) {
-                                     llvm::OptBisector->setLimit(Limit);
-                                   }),
-                                   cl::desc("Maximum optimization to perform"));
-
 static void printPassMessage(const StringRef &Name, int PassNum,
                              StringRef TargetDesc, bool Running) {
   StringRef Status = Running ? "" : "NOT ";
   errs() << "BISECT: " << Status << "running pass "
          << "(" << PassNum << ") " << Name << " on " << TargetDesc << "\n";
 }
 
 bool OptBisect::shouldRunPass(const Pass *P, StringRef IRDescription) {
   assert(isEnabled());
 
   return checkPass(P->getPassName(), IRDescription);
 }
 
 bool OptBisect::checkPass(const StringRef PassName,
                           const StringRef TargetDesc) {
   assert(isEnabled());
 
-  int CurBisectNum = ++LastBisectNum;
-  bool ShouldRun = (BisectLimit == -1 || CurBisectNum <= BisectLimit);
-  printPassMessage(PassName, CurBisectNum, TargetDesc, ShouldRun);
+  LastBisectNum++;
+  bool ShouldRun = (BisectLimit == -1 || LastBisectNum <= BisectLimit);
+  printPassMessage(PassName, LastBisectNum, TargetDesc, ShouldRun);
   return ShouldRun;
 }
 
 const int OptBisect::Disabled;
 
 ManagedStatic<OptBisect> llvm::OptBisector;

llvm/lib/IR/Pass.cpp

 
 namespace {
 
 struct GetCFGOnlyPasses : public PassRegistrationListener {
   using VectorType = AnalysisUsage::VectorType;
 
   VectorType &CFGOnlyList;
 
-  GetCFGOnlyPasses(VectorType &L) : CFGOnlyList(L) {}
+  explicit GetCFGOnlyPasses(VectorType &L) : CFGOnlyList(L) {}
 
   void passEnumerate(const PassInfo *P) override {
     if (P->isCFGOnlyPass())
       CFGOnlyList.push_back(P->getTypeInfo());
   }
 };
 
 } // end anonymous namespace

llvm/lib/IR/PassTimingInfo.cpp

 /// It was intended to be generic but now we decided to split
 /// interfaces completely. This is now exclusively for legacy-pass-manager use.
 class PassTimingInfo {
 public:
   using PassInstanceID = void *;
 
 private:
   StringMap<unsigned> PassIDCountMap; ///< Map that counts instances of passes
-  DenseMap<PassInstanceID, std::unique_ptr<Timer>> TimingData; ///< timers for pass instances
+  DenseMap<PassInstanceID, std::unique_ptr<Timer>>
+      TimingData; ///< timers for pass instances
   TimerGroup TG;
 
 public:
   /// Default constructor for yet-inactive timeinfo.
   /// Use \p init() to activate it.
   PassTimingInfo();
 
   /// Print out timing information and release timers.
Timer *PassTimingInfo::getPassTimer(Pass *P, PassInstanceID Pass) {
   sys::SmartScopedLock<true> Lock(*TimingInfoMutex);
   std::unique_ptr<Timer> &T = TimingData[Pass];
 
   if (!T) {
     StringRef PassName = P->getPassName();
     StringRef PassArgument;
     if (const PassInfo *PI = Pass::lookupPassInfo(P->getPassID()))
       PassArgument = PI->getPassArgument();
-    T.reset(newPassTimer(PassArgument.empty() ? PassName : PassArgument, PassName));
+    T.reset(
+        newPassTimer(PassArgument.empty() ? PassName : PassArgument, PassName));
   }
   return T.get();
 }
 
 PassTimingInfo *PassTimingInfo::TheTimeInfo;
 } // namespace legacy
 } // namespace
 

 // Pass timing handling for the New Pass Manager
 //===----------------------------------------------------------------------===//
 
 /// Returns the timer for the specified pass invocation of \p PassID.
 /// Each time it creates a new timer.
 Timer &TimePassesHandler::getPassTimer(StringRef PassID) {
   if (!PerRun) {
     TimerVector &Timers = TimingData[PassID];
-    if (Timers.size() == 0)
+    if (Timers.empty())
       Timers.emplace_back(new Timer(PassID, PassID, TG));
     return *Timers.front();
   }
 
   // Take a vector of Timers created for this \p PassID and append
   // one more timer to it.
   TimerVector &Timers = TimingData[PassID];
   unsigned Count = Timers.size() + 1;

 
 TimePassesHandler::TimePassesHandler(bool Enabled, bool PerRun)
     : TG("pass", "... Pass execution timing report ..."), Enabled(Enabled),
       PerRun(PerRun) {}
 
 TimePassesHandler::TimePassesHandler()
     : TimePassesHandler(TimePassesIsEnabled, TimePassesPerRun) {}
 
-void TimePassesHandler::setOutStream(raw_ostream &Out) {
-  OutStream = &Out;
-}
+void TimePassesHandler::setOutStream(raw_ostream &Out) { OutStream = &Out; }
 
 void TimePassesHandler::print() {
   if (!Enabled)
     return;
   TG.print(OutStream ? *OutStream : *CreateInfoOutputFile(), true);
 }
 
 LLVM_DUMP_METHOD void TimePassesHandler::dump() const {
   dbgs() << "Dumping timers for " << getTypeName<TimePassesHandler>()
          << ":\n\tRunning:\n";
   for (auto &I : TimingData) {
     StringRef PassID = I.getKey();
-    const TimerVector& MyTimers = I.getValue();
+    const TimerVector &MyTimers = I.getValue();
     for (unsigned idx = 0; idx < MyTimers.size(); idx++) {
-      const Timer* MyTimer = MyTimers[idx].get();
+      const Timer *MyTimer = MyTimers[idx].get();
       if (MyTimer && MyTimer->isRunning())
-        dbgs() << "\tTimer " << MyTimer << " for pass " << PassID << "(" << idx << ")\n";
+        dbgs() << "\tTimer " << MyTimer << " for pass " << PassID << "(" << idx
+               << ")\n";
     }
   }
   dbgs() << "\tTriggered:\n";
   for (auto &I : TimingData) {
     StringRef PassID = I.getKey();
-    const TimerVector& MyTimers = I.getValue();
+    const TimerVector &MyTimers = I.getValue();
     for (unsigned idx = 0; idx < MyTimers.size(); idx++) {
-      const Timer* MyTimer = MyTimers[idx].get();
+      const Timer *MyTimer = MyTimers[idx].get();
       if (MyTimer && MyTimer->hasTriggered() && !MyTimer->isRunning())
-        dbgs() << "\tTimer " << MyTimer << " for pass " << PassID << "(" << idx << ")\n";
+        dbgs() << "\tTimer " << MyTimer << " for pass " << PassID << "(" << idx
+               << ")\n";
     }
   }
 }
 
 void TimePassesHandler::startTimer(StringRef PassID) {
   Timer &MyTimer = getPassTimer(PassID);
   TimerStack.push_back(&MyTimer);
   if (!MyTimer.isRunning())
     MyTimer.startTimer();
 }
 
 void TimePassesHandler::stopTimer(StringRef PassID) {
-  assert(TimerStack.size() > 0 && "empty stack in popTimer");
+  assert(!TimerStack.empty() && "empty stack in popTimer");
   Timer *MyTimer = TimerStack.pop_back_val();
   assert(MyTimer && "timer should be present");
   if (MyTimer->isRunning())
     MyTimer->stopTimer();
 }
 
 void TimePassesHandler::runBeforePass(StringRef PassID) {
   if (isSpecialPass(PassID,
void TimePassesHandler::runAfterPass(StringRef PassID) {
   LLVM_DEBUG(dump());
 }
 
 void TimePassesHandler::registerCallbacks(PassInstrumentationCallbacks &PIC) {
   if (!Enabled)
     return;
 
   PIC.registerBeforeNonSkippedPassCallback(
-      [this](StringRef P, Any) { this->runBeforePass(P); });
+      [this](StringRef P, const Any &) { this->runBeforePass(P); });
   PIC.registerAfterPassCallback(
-      [this](StringRef P, Any, const PreservedAnalyses &) {
+      [this](StringRef P, const Any &, const PreservedAnalyses &) {
         this->runAfterPass(P);
       });
   PIC.registerAfterPassInvalidatedCallback(
       [this](StringRef P, const PreservedAnalyses &) {
         this->runAfterPass(P);
       });
   PIC.registerBeforeAnalysisCallback(
-      [this](StringRef P, Any) { this->runBeforePass(P); });
+      [this](StringRef P, const Any &) { this->runBeforePass(P); });
   PIC.registerAfterAnalysisCallback(
-      [this](StringRef P, Any) { this->runAfterPass(P); });
+      [this](StringRef P, const Any &) { this->runAfterPass(P); });
 }
 
 } // namespace llvm

llvm/lib/IR/PseudoProbe.cpp

 Optional<PseudoProbe> extractProbeFromDiscriminator(const Instruction &Inst) {
   assert(isa<CallBase>(&Inst) && !isa<IntrinsicInst>(&Inst) &&
          "Only call instructions should have pseudo probe encodes as their "
          "Dwarf discriminators");
   if (const DebugLoc &DLoc = Inst.getDebugLoc()) {
     const DILocation *DIL = DLoc;
     auto Discriminator = DIL->getDiscriminator();
     if (DILocation::isPseudoProbeDiscriminator(Discriminator)) {
-      PseudoProbe Probe;
+      PseudoProbe Probe{};
       Probe.Id =
           PseudoProbeDwarfDiscriminator::extractProbeIndex(Discriminator);
       Probe.Type =
           PseudoProbeDwarfDiscriminator::extractProbeType(Discriminator);
       Probe.Attr =
           PseudoProbeDwarfDiscriminator::extractProbeAttributes(Discriminator);
       Probe.Factor =
           PseudoProbeDwarfDiscriminator::extractProbeFactor(Discriminator) /
           (float)PseudoProbeDwarfDiscriminator::FullDistributionFactor;
       return Probe;
     }
   }
   return None;
 }
 
 Optional<PseudoProbe> extractProbe(const Instruction &Inst) {
   if (const auto *II = dyn_cast<PseudoProbeInst>(&Inst)) {
-    PseudoProbe Probe;
+    PseudoProbe Probe{};
     Probe.Id = II->getIndex()->getZExtValue();
     Probe.Type = (uint32_t)PseudoProbeType::Block;
     Probe.Attr = II->getAttributes()->getZExtValue();
     Probe.Factor = II->getFactor()->getZExtValue() /
                    (float)PseudoProbeFullDistributionFactor;
     return Probe;
   }
 

llvm/lib/IR/Verifier.cpp

if (L == R)
     return true;
   PointerType *PL = dyn_cast<PointerType>(L);
   PointerType *PR = dyn_cast<PointerType>(R);
   if (!PL || !PR)
     return false;
   return PL->getAddressSpace() == PR->getAddressSpace();
 }
 
-static AttrBuilder getParameterABIAttributes(int I, AttributeList Attrs) {
+static AttrBuilder getParameterABIAttributes(unsigned I, AttributeList Attrs) {
   static const Attribute::AttrKind ABIAttrs[] = {
       Attribute::StructRet,  Attribute::ByVal,          Attribute::InAlloca,
       Attribute::InReg,      Attribute::StackAlignment, Attribute::SwiftSelf,
       Attribute::SwiftAsync, Attribute::SwiftError,     Attribute::Preallocated,
       Attribute::ByRef};
   AttrBuilder Copy;
   for (auto AK : ABIAttrs) {
     Attribute Attr = Attrs.getParamAttrs(I).getAttribute(AK);
void Verifier::verifyMustTailCall(CallInst &CI) {
   AttributeList CalleeAttrs = CI.getAttributes();
   if (CI.getCallingConv() == CallingConv::SwiftTail ||
       CI.getCallingConv() == CallingConv::Tail) {
     StringRef CCName =
         CI.getCallingConv() == CallingConv::Tail ? "tailcc" : "swifttailcc";
 
     // - Only sret, byval, swiftself, and swiftasync ABI-impacting attributes
     //   are allowed in swifttailcc call
-    for (int I = 0, E = CallerTy->getNumParams(); I != E; ++I) {
+    for (unsigned I = 0, E = CallerTy->getNumParams(); I != E; ++I) {
       AttrBuilder ABIAttrs = getParameterABIAttributes(I, CallerAttrs);
       SmallString<32> Context{CCName, StringRef(" musttail caller")};
       verifyTailCCMustTailAttrs(ABIAttrs, Context);
     }
-    for (int I = 0, E = CalleeTy->getNumParams(); I != E; ++I) {
+    for (unsigned I = 0, E = CalleeTy->getNumParams(); I != E; ++I) {
       AttrBuilder ABIAttrs = getParameterABIAttributes(I, CalleeAttrs);
       SmallString<32> Context{CCName, StringRef(" musttail callee")};
       verifyTailCCMustTailAttrs(ABIAttrs, Context);
     }
     // - Varargs functions are not allowed
     Assert(!CallerTy->isVarArg(), Twine("cannot guarantee ") + CCName +
                                       " tail call for varargs function");
     return;
   }
 
   // - The caller and callee prototypes must match.  Pointer types of
   //   parameters or return types may differ in pointee type, but not
   //   address space.
   if (!CI.getCalledFunction() || !CI.getCalledFunction()->isIntrinsic()) {
     Assert(CallerTy->getNumParams() == CalleeTy->getNumParams(),
            "cannot guarantee tail call due to mismatched parameter counts",
            &CI);
-    for (int I = 0, E = CallerTy->getNumParams(); I != E; ++I) {
+    for (unsigned I = 0, E = CallerTy->getNumParams(); I != E; ++I) {
       Assert(
           isTypeCongruent(CallerTy->getParamType(I), CalleeTy->getParamType(I)),
           "cannot guarantee tail call due to mismatched parameter types", &CI);
     }
   }
 
   // - All ABI-impacting function attributes, such as sret, byval, inreg,
   //   returned, preallocated, and inalloca, must match.
-  for (int I = 0, E = CallerTy->getNumParams(); I != E; ++I) {
+  for (unsigned I = 0, E = CallerTy->getNumParams(); I != E; ++I) {
     AttrBuilder CallerABIAttrs = getParameterABIAttributes(I, CallerAttrs);
     AttrBuilder CalleeABIAttrs = getParameterABIAttributes(I, CalleeAttrs);
     Assert(CallerABIAttrs == CalleeABIAttrs,
            "cannot guarantee tail call due to mismatched ABI impacting "
            "function attributes",
            &CI, CI.getOperand(I));
   }
 }
void Verifier::verifyFragmentExpression(const DbgVariableIntrinsic &I) {
   if (!V || !E || !E->isValid())
     return;
 
   // Nothing to do if this isn't a DW_OP_LLVM_fragment expression.
   auto Fragment = E->getFragmentInfo();
   if (!Fragment)
     return;
 
-  // The frontend helps out GDB by emitting the members of local anonymous
-  // unions as artificial local variables with shared storage. When SROA splits
-  // the storage for artificial local variables that are smaller than the entire
-  // union, the overhang piece will be outside of the allotted space for the
-  // variable and this check fails.
-  // FIXME: Remove this check as soon as clang stops doing this; it hides bugs.
-  if (V->isArtificial())
-    return;
-
   verifyFragmentExpression(*V, *Fragment, &I);
 }
 
 template <typename ValueOrMetadata>
 void Verifier::verifyFragmentExpression(const DIVariable &V,
                                         DIExpression::FragmentInfo Fragment,
                                         ValueOrMetadata *Desc) {
   // If there's no size, the type is broken, but that should be checked

 
 FunctionPass *llvm::createVerifierPass(bool FatalErrors) {
   return new VerifierLegacyPass(FatalErrors);
 }
 
 AnalysisKey VerifierAnalysis::Key;
 VerifierAnalysis::Result VerifierAnalysis::run(Module &M,
                                                ModuleAnalysisManager &) {
-  Result Res;
+  Result Res{};
   Res.IRBroken = llvm::verifyModule(M, &dbgs(), &Res.DebugInfoBroken);
   return Res;
 }
 
 VerifierAnalysis::Result VerifierAnalysis::run(Function &F,
                                                FunctionAnalysisManager &) {
   return { llvm::verifyFunction(F, &dbgs()), false };
 }

llvm/lib/Support/APInt.cpp

if (isSingleWord() || getActiveBits() <= APINT_BITS_PER_WORD) {
     if (isSigned) {
       int64_t sext = SignExtend64(getWord(0), BitWidth);
       return double(sext);
     } else
       return double(getWord(0));
   }
 
   // Determine if the value is negative.
-  bool isNeg = isSigned ? (*this)[BitWidth-1] : false;
+  bool isNeg = isSigned && (*this)[BitWidth - 1];
 
   // Construct the absolute value if we're negative.
   APInt Tmp(isNeg ? -(*this) : (*this));
 
   // Figure out how many bits we're using.
   unsigned n = Tmp.getActiveBits();
 
   // The exponent (without bias normalization) is just the number of bits

llvm/tools/llvm-c-test/echo.cpp

LLVMValueRef CloneInstruction(LLVMValueRef Src, LLVMBuilderRef Builder) {
 
     // We tried everything, it must be an instruction
     // that hasn't been generated already.
     LLVMValueRef Dst = nullptr;
 
     LLVMOpcode Op = LLVMGetInstructionOpcode(Src);
     switch(Op) {
       case LLVMRet: {
-        int OpCount = LLVMGetNumOperands(Src);
-        if (OpCount == 0)
+        if (LLVMGetNumOperands(Src) == 0)
           Dst = LLVMBuildRetVoid(Builder);
         else
           Dst = LLVMBuildRet(Builder, CloneValue(LLVMGetOperand(Src, 0)));
         break;
       }
       case LLVMBr: {
         if (!LLVMIsConditional(Src)) {
           LLVMValueRef SrcOp = LLVMGetOperand(Src, 0);