Use llvm::all_of (NFC)

[Miss_Grape]

Summary

address the comment

[kazu]

llvm/include/llvm/Demangle/ItaniumDemangle.h

1266–1272 ↗

(On Diff #452646)

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 ↗

(On Diff #452646)

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/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/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++)