Use llvm::all_of (NFC)

[Miss_Grape]

Summary

address the comment

[kazu]

llvm/include/llvm/Demangle/ItaniumDemangle.h

1266–1272

I am not sure if it's a good idea to modify this file without making corresponding changes to libcxxabi/src/demangle/ItaniumDemangle.h. Note that the comment at the beginning of the file says:

// Generic itanium demangler library.
// There are two copies of this file in the source tree.  The one under
// libcxxabi is the original and the one under llvm is the copy.  Use
// cp-to-llvm.sh to update the copy.  See README.txt for more details.

Also, we probably don't want to introduce dependence on llvm headers in libcxxabi/src/demangle/ItaniumDemangle.h. In turn, we probably shouldn't include llvm headers in llvm/include/llvm/Demangle/ItaniumDemangle.h either.

llvm/lib/ProfileData/InstrProfReader.cpp

165

I am not sure if this change improves readability. drop_end(buffer, buffer.size() - count) makes it harder to see the original intention that we iterate on the first count elements. That is, we would be asking readers to compute buffer.size() - (buffer.size() - count), which evaluates to count.

I would be inclined to wait for std::ranges::views::take in C++20. If you really wanted to, you could implement an equivalent of std::ranges::take_view or something in llvm/include/llvm/ADT/STLExtras.h.

[kazu]

LGTM. Thank you for updating the patch!

llvm/include/llvm/Demangle/ItaniumDemangle.h

 // libcxxabi is the original and the one under llvm is the copy.  Use
 // cp-to-llvm.sh to update the copy.  See README.txt for more details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEMANGLE_ITANIUMDEMANGLE_H
 #define LLVM_DEMANGLE_ITANIUMDEMANGLE_H
 
+#include "../ADT/STLExtras.h"
 #include "DemangleConfig.h"
 #include "StringView.h"
 #include "Utility.h"
 #include <algorithm>
 #include <cassert>
 #include <cctype>
 #include <cstdio>
 #include <cstdlib>
if (OB.CurrentPackMax == std::numeric_limits<unsigned>::max()) {
       OB.CurrentPackMax = static_cast<unsigned>(Data.size());
       OB.CurrentPackIndex = 0;
     }
   }
 
 public:
   ParameterPack(NodeArray Data_) : Node(KParameterPack), Data(Data_) {
     ArrayCache = FunctionCache = RHSComponentCache = Cache::Unknown;
-    if (std::all_of(Data.begin(), Data.end(), [](Node* P) {
-          return P->ArrayCache == Cache::No;
-        }))
+    if (llvm::all_of(Data, [](Node *P) { return P->ArrayCache == Cache::No; }))
       ArrayCache = Cache::No;
-    if (std::all_of(Data.begin(), Data.end(), [](Node* P) {
-          return P->FunctionCache == Cache::No;
-        }))
+    if (llvm::all_of(Data,
+                     [](Node *P) { return P->FunctionCache == Cache::No; }))
       FunctionCache = Cache::No;
-    if (std::all_of(Data.begin(), Data.end(), [](Node* P) {
-          return P->RHSComponentCache == Cache::No;
-        }))
+    if (llvm::all_of(Data,
+                     [](Node *P) { return P->RHSComponentCache == Cache::No; }))
       RHSComponentCache = Cache::No;
   }
 
   template<typename Fn> void match(Fn F) const { F(Data); }
 
   bool hasRHSComponentSlow(OutputBuffer &OB) const override {
     initializePackExpansion(OB);
     size_t Idx = OB.CurrentPackIndex;

llvm/lib/Analysis/TypeMetadataUtils.cpp

for (const Use &U : VPtr->uses()) {
     Value *User = U.getUser();
     if (isa<BitCastInst>(User)) {
       findLoadCallsAtConstantOffset(M, DevirtCalls, User, Offset, CI, DT);
     } else if (isa<LoadInst>(User)) {
       findCallsAtConstantOffset(DevirtCalls, nullptr, User, Offset, CI, DT);
     } else if (auto GEP = dyn_cast<GetElementPtrInst>(User)) {
       // Take into account the GEP offset.
       if (VPtr == GEP->getPointerOperand() && GEP->hasAllConstantIndices()) {
-        SmallVector<Value *, 8> Indices(GEP->op_begin() + 1, GEP->op_end());
+        SmallVector<Value *, 8> Indices(drop_begin(GEP->operands()));
         int64_t GEPOffset = M->getDataLayout().getIndexedOffsetInType(
             GEP->getSourceElementType(), Indices);
         findLoadCallsAtConstantOffset(M, DevirtCalls, User, Offset + GEPOffset,
                                       CI, DT);
       }
     }
   }
 }

llvm/lib/IR/Verifier.cpp

for (auto &MIBOp : MD->operands()) {
     Check(MIB->getOperand(0) != nullptr,
           "!memprof MemInfoBlock first operand should not be null", MIB);
     Check(isa<MDNode>(MIB->getOperand(0)),
           "!memprof MemInfoBlock first operand should be an MDNode", MIB);
     MDNode *StackMD = dyn_cast<MDNode>(MIB->getOperand(0));
     visitCallStackMetadata(StackMD);
 
     // Check that remaining operands are MDString.
-    Check(std::all_of(MIB->op_begin() + 1, MIB->op_end(),
+    Check(llvm::all_of(llvm::drop_begin(MIB->operands()),
                        [](const MDOperand &Op) { return isa<MDString>(Op); }),
           "Not all !memprof MemInfoBlock operands 1 to N are MDString", MIB);
   }
 }
 
 void Verifier::visitCallsiteMetadata(Instruction &I, MDNode *MD) {
   Check(isa<CallBase>(I), "!callsite metadata should only exist on calls", &I);
   // Verify the partial callstack annotated from memprof profiles. This callsite
   // is a part of a profiled allocation callstack.

llvm/lib/ProfileData/InstrProfReader.cpp

 //===- InstrProfReader.cpp - Instrumented profiling reader ----------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains support for reading profiling data for clang's
 // instrumentation based PGO and coverage.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ProfileData/InstrProfReader.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/IR/ProfileSummary.h"
 #include "llvm/ProfileData/InstrProf.h"
 #include "llvm/ProfileData/MemProf.h"
 #include "llvm/ProfileData/ProfileCommon.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"

 }
 
 bool TextInstrProfReader::hasFormat(const MemoryBuffer &Buffer) {
   // Verify that this really looks like plain ASCII text by checking a
   // 'reasonable' number of characters (up to profile magic size).
   size_t count = std::min(Buffer.getBufferSize(), sizeof(uint64_t));
   StringRef buffer = Buffer.getBufferStart();
   return count == 0 ||
-         std::all_of(buffer.begin(), buffer.begin() + count,
+         llvm::all_of(drop_end(buffer, buffer.size() - count),
                       [](char c) { return isPrint(c) || isSpace(c); });
 }
 
 // Read the profile variant flag from the header: ":FE" means this is a FE
 // generated profile. ":IR" means this is an IR level profile. Other strings
 // with a leading ':' will be reported an error format.
 Error TextInstrProfReader::readHeader() {
   Symtab.reset(new InstrProfSymtab());
 

llvm/lib/Target/SPIRV/SPIRVModuleAnalysis.cpp

 //===----------------------------------------------------------------------===//
 
 #include "SPIRVModuleAnalysis.h"
 #include "SPIRV.h"
 #include "SPIRVSubtarget.h"
 #include "SPIRVTargetMachine.h"
 #include "SPIRVUtils.h"
 #include "TargetInfo/SPIRVTargetInfo.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/TargetPassConfig.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "spirv-module-analysis"
 
 static cl::opt<bool>
if (ReqCaps.empty()) {
     for (auto Cap : ReqCaps) { // Only need 1 of the capabilities to work.
       if (Reqs.isCapabilityAvailable(Cap))
         return {true, {Cap}, {}, ReqMinVer, ReqMaxVer};
     }
   }
   // If there are no capabilities, or we can't satisfy the version or
   // capability requirements, use the list of extensions (if the subtarget
   // can handle them all).
-  if (std::all_of(ReqExts.begin(), ReqExts.end(),
-                  [&ST](const SPIRV::Extension::Extension &Ext) {
-                    return ST.canUseExtension(Ext);
-                  })) {
+  if (llvm::all_of(ReqExts, [&ST](const SPIRV::Extension::Extension &Ext) {
     return {true, {}, ReqExts, 0, 0}; // TODO: add versions to extensions.
   }
   return {false, {}, {}, 0, 0};
 }
 
 void SPIRVModuleAnalysis::setBaseInfo(const Module &M) {
   MAI.MaxID = 0;
   for (int i = 0; i < SPIRV::NUM_MODULE_SECTIONS; i++)