[llvm] Use x.empty() instead of llvm::empty(x) (NFC)

[kazu]

Summary

I'm planning to deprecate and eventually remove llvm::empty.

I thought about replacing llvm::empty(x) with std::empty(x), but it
turns out that all uses can be converted to x.empty(). That is, no
use requires the ability of std::empty to accept C arrays and
std::initializer_list.

[foad]

AMDGPU part LGTM, thanks!

[dblaikie]

hmm, I think I remember llvm::empty was added, maybe before llvm::iterator_range got an empty operation of its own? And in theory range-based-for loops only require begin/end, so it's sort of nice that empty could be used with that same requirement, but if, practically speaking, all our ranges have empty on them - yeah, guess this is an OK way forward.

[kazu]

In D133677#3784137, @dblaikie wrote:

hmm, I think I remember llvm::empty was added, maybe before llvm::iterator_range got an empty operation of its own? And in theory range-based-for loops only require begin/end, so it's sort of nice that empty could be used with that same requirement, but if, practically speaking, all our ranges have empty on them - yeah, guess this is an OK way forward.

Thank you for the review, David!

Yes, llvm::empty indeed predates llvm::iterator_range::empty by about a year.

9fd397b423ba442808957e65e3ad25a07cd203e4 added llvm::empty on October 31, 2018.

fdaa74217420729140f1786ea037ac445a724c8e added llvm::iterator_range::empty on October 7, 2019.

FWIW, the only instance of llvm::empty(x) in our repository that couldn't be converted to x.empty() was involving std::initializer_list, but I've already converted that to x.size() in a fairly natural way in af91e2b9dba6a754e62862e14629af0d240d82bc.

llvm/include/llvm/ExecutionEngine/JITLink/JITLink.h

 };
 
 /// Represents a section address range via a pair of Block pointers
 /// to the first and last Blocks in the section.
 class SectionRange {
 public:
   SectionRange() = default;
   SectionRange(const Section &Sec) {
-    if (llvm::empty(Sec.blocks()))
+    if (Sec.blocks().empty())
       return;
     First = Last = *Sec.blocks().begin();
     for (auto *B : Sec.blocks()) {
       if (B->getAddress() < First->getAddress())
         First = B;
       if (B->getAddress() > Last->getAddress())
         Last = B;
     }

llvm/lib/CodeGen/AsmPrinter/DwarfFile.cpp

void DwarfFile::emitUnit(DwarfUnit *TheU, bool UseOffsets) {
 
   MCSection *S = TheU->getSection();
 
   if (!S)
     return;
 
   // Skip CUs that ended up not being needed (split CUs that were abandoned
   // because they added no information beyond the non-split CU)
-  if (llvm::empty(TheU->getUnitDie().values()))
+  if (TheU->getUnitDie().values().empty())
     return;
 
   Asm->OutStreamer->switchSection(S);
   TheU->emitHeader(UseOffsets);
   Asm->emitDwarfDIE(TheU->getUnitDie());
 
   if (MCSymbol *EndLabel = TheU->getEndLabel())
     Asm->OutStreamer->emitLabel(EndLabel);
 }
 
 // Compute the size and offset for each DIE.
 void DwarfFile::computeSizeAndOffsets() {
   // Offset from the first CU in the debug info section is 0 initially.
   uint64_t SecOffset = 0;
 
   // Iterate over each compile unit and set the size and offsets for each
   // DIE within each compile unit. All offsets are CU relative.
   for (const auto &TheU : CUs) {
     if (TheU->getCUNode()->isDebugDirectivesOnly())
       continue;
 
     // Skip CUs that ended up not being needed (split CUs that were abandoned
     // because they added no information beyond the non-split CU)
-    if (llvm::empty(TheU->getUnitDie().values()))
+    if (TheU->getUnitDie().values().empty())
       return;
 
     TheU->setDebugSectionOffset(SecOffset);
     SecOffset += computeSizeAndOffsetsForUnit(TheU.get());
   }
   if (SecOffset > UINT32_MAX && !Asm->isDwarf64())
     report_fatal_error("The generated debug information is too large "
                        "for the 32-bit DWARF format.");

llvm/lib/ExecutionEngine/JITLink/JITLink.cpp

for (auto *B : SortedBlocks) {
         }
       } else
         OS << "    no edges\n";
       OS << "\n";
     }
   }
 
   OS << "Absolute symbols:\n";
-  if (!llvm::empty(absolute_symbols())) {
+  if (!absolute_symbols().empty()) {
     for (auto *Sym : absolute_symbols())
       OS << "  " << Sym->getAddress() << ": " << *Sym << "\n";
   } else
     OS << "  none\n";
 
   OS << "\nExternal symbols:\n";
-  if (!llvm::empty(external_symbols())) {
+  if (!external_symbols().empty()) {
     for (auto *Sym : external_symbols())
       OS << "  " << Sym->getAddress() << ": " << *Sym << "\n";
   } else
     OS << "  none\n";
 }
 
 raw_ostream &operator<<(raw_ostream &OS, const SymbolLookupFlags &LF) {
   switch (LF) {

llvm/lib/ExecutionEngine/JITLink/JITLinkMemoryManager.cpp

 
 JITLinkMemoryManager::~JITLinkMemoryManager() = default;
 JITLinkMemoryManager::InFlightAlloc::~InFlightAlloc() = default;
 
 BasicLayout::BasicLayout(LinkGraph &G) : G(G) {
 
   for (auto &Sec : G.sections()) {
     // Skip empty sections.
-    if (empty(Sec.blocks()))
+    if (Sec.blocks().empty())
       continue;
 
     auto &Seg = Segments[{Sec.getMemProt(), Sec.getMemDeallocPolicy()}];
     for (auto *B : Sec.blocks())
       if (LLVM_LIKELY(!B->isZeroFill()))
         Seg.ContentBlocks.push_back(B);
       else
         Seg.ZeroFillBlocks.push_back(B);

llvm/lib/ExecutionEngine/Orc/DebuggerSupportPlugin.cpp

struct DebugSectionInfo {
       uint64_t Alignment = 0;
       orc::ExecutorAddr StartAddr;
       uint64_t Size = 0;
     };
 
     SmallVector<DebugSectionInfo, 12> DebugSecInfos;
     size_t NumSections = 0;
     for (auto &Sec : G.sections()) {
-      if (llvm::empty(Sec.blocks()))
+      if (Sec.blocks().empty())
         continue;
 
       ++NumSections;
       if (isDebugSection(Sec)) {
         size_t SepPos = Sec.getName().find(',');
         if (SepPos > 16 || (Sec.getName().size() - (SepPos + 1) > 16)) {
           LLVM_DEBUG({
             dbgs() << "Skipping debug object synthesis for graph "
size_t ContainerBlockSize =
         sizeof(typename MachOTraits::Header) + SegmentLCSize;
     auto ContainerBlockContent = G.allocateBuffer(ContainerBlockSize);
     MachOContainerBlock = &G.createMutableContentBlock(
         SDOSec, ContainerBlockContent, orc::ExecutorAddr(), 8, 0);
 
     // Copy debug section blocks and symbols.
     orc::ExecutorAddr NextBlockAddr(MachOContainerBlock->getSize());
     for (auto &SI : DebugSecInfos) {
-      assert(!llvm::empty(SI.Sec->blocks()) && "Empty debug info section?");
+      assert(!SI.Sec->blocks().empty() && "Empty debug info section?");
 
       // Update addresses in debug section.
       LLVM_DEBUG({
         dbgs() << "  Appending " << SI.Sec->getName() << " ("
                << SI.Sec->blocks_size() << " block(s)) at "
                << formatv("{0:x8}", NextBlockAddr) << "\n";
       });
       for (auto *B : SI.Sec->blocks()) {

llvm/lib/ExecutionEngine/Orc/Layer.cpp

for (auto &G : M.global_values()) {
 
       // Otherwise we just need a normal linker mangling.
       auto MangledName = Mangle(G.getName());
       SymbolFlags[MangledName] = JITSymbolFlags::fromGlobalValue(G);
       SymbolToDefinition[MangledName] = &G;
     }
 
     // If we need an init symbol for this module then create one.
-    if (!llvm::empty(getStaticInitGVs(M))) {
+    if (!getStaticInitGVs(M).empty()) {
       size_t Counter = 0;
 
       do {
         std::string InitSymbolName;
         raw_string_ostream(InitSymbolName)
             << "$." << M.getModuleIdentifier() << ".__inits." << Counter++;
         InitSymbol = ES.intern(InitSymbolName);
       } while (SymbolFlags.count(InitSymbol));

llvm/lib/ExecutionEngine/Orc/MachOPlatform.cpp

Error MachOPlatform::MachOPlatformPlugin::processObjCImageInfo(
   //       in which case we just verify it.
   auto *ObjCImageInfo = G.findSectionByName(ObjCImageInfoSectionName);
   if (!ObjCImageInfo)
     return Error::success();
 
   auto ObjCImageInfoBlocks = ObjCImageInfo->blocks();
 
   // Check that the section is not empty if present.
-  if (llvm::empty(ObjCImageInfoBlocks))
+  if (ObjCImageInfoBlocks.empty())
     return make_error<StringError>("Empty " + ObjCImageInfoSectionName +
                                        " section in " + G.getName(),
                                    inconvertibleErrorCode());
 
   // Check that there's only one block in the section.
   if (std::next(ObjCImageInfoBlocks.begin()) != ObjCImageInfoBlocks.end())
     return make_error<StringError>("Multiple blocks in " +
                                        ObjCImageInfoSectionName +

llvm/lib/Target/AMDGPU/AMDGPURegisterBankInfo.cpp

void AMDGPURegisterBankInfo::applyMappingImpl(
   }
   case AMDGPU::G_SEXT:
   case AMDGPU::G_ZEXT:
   case AMDGPU::G_ANYEXT: {
     Register SrcReg = MI.getOperand(1).getReg();
     LLT SrcTy = MRI.getType(SrcReg);
     const bool Signed = Opc == AMDGPU::G_SEXT;
 
-    assert(empty(OpdMapper.getVRegs(1)));
+    assert(OpdMapper.getVRegs(1).empty());
 
     MachineIRBuilder B(MI);
     const RegisterBank *SrcBank =
       OpdMapper.getInstrMapping().getOperandMapping(1).BreakDown[0].RegBank;
 
     Register DstReg = MI.getOperand(0).getReg();
     LLT DstTy = MRI.getType(DstReg);
     if (DstTy.isScalar() &&

llvm/lib/Target/X86/X86FastISel.cpp

for (auto Itr = std::prev(Start); Itr != End; --Itr) {
     // Check that the extractvalue operand comes from the intrinsic.
     const auto *EVI = cast<ExtractValueInst>(Itr);
     if (EVI->getAggregateOperand() != II)
       return false;
   }
 
   // Make sure no potentially eflags clobbering phi moves can be inserted in
   // between.
-  auto HasPhis = [](const BasicBlock *Succ) {
-    return !llvm::empty(Succ->phis());
-  };
+  auto HasPhis = [](const BasicBlock *Succ) { return !Succ->phis().empty(); };
   if (I->isTerminator() && llvm::any_of(successors(I), HasPhis))
     return false;
 
   // Make sure there are no potentially eflags clobbering constant
   // materializations in between.
   if (llvm::any_of(I->operands(), [](Value *V) { return isa<Constant>(V); }))
     return false;
 

llvm/lib/Transforms/Utils/LoopUtils.cpp

auto HasNoClobbersOnPath =
     if (Info.PathIsNoop) {
       for (auto *Exiting : ExitingBlocks) {
         if (!Seen.contains(Exiting))
           continue;
         for (auto *Succ : successors(Exiting)) {
           if (L.contains(Succ))
             continue;
 
-          Info.PathIsNoop &= llvm::empty(Succ->phis()) &&
+          Info.PathIsNoop &= Succ->phis().empty() &&
                              (!Info.ExitForPath || Info.ExitForPath == Succ);
           if (!Info.PathIsNoop)
             break;
           assert((!Info.ExitForPath || Info.ExitForPath == Succ) &&
                  "cannot have multiple exit blocks");
           Info.ExitForPath = Succ;
         }
       }

llvm/tools/llvm-jitlink/llvm-jitlink-coff.cpp

Error registerCOFFGraphInfo(Session &S, LinkGraph &G) {
   }
 
   auto &FileInfo = S.FileInfos[FileName];
   LLVM_DEBUG(
       { dbgs() << "Registering COFF file info for \"" << FileName << "\"\n"; });
   for (auto &Sec : G.sections()) {
     LLVM_DEBUG({
       dbgs() << "  Section \"" << Sec.getName() << "\": "
-             << (llvm::empty(Sec.symbols()) ? "empty. skipping."
-                                            : "processing...")
+             << (Sec.symbols().empty() ? "empty. skipping." : "processing...")
              << "\n";
     });
 
     // Skip empty sections.
-    if (llvm::empty(Sec.symbols()))
+    if (Sec.symbols().empty())
       continue;
 
     if (FileInfo.SectionInfos.count(Sec.getName()))
       return make_error<StringError>("Encountered duplicate section name \"" +
                                          Sec.getName() + "\" in \"" + FileName +
                                          "\"",
                                      inconvertibleErrorCode());
 

llvm/tools/llvm-jitlink/llvm-jitlink-elf.cpp

Error registerELFGraphInfo(Session &S, LinkGraph &G) {
 
   auto &FileInfo = S.FileInfos[FileName];
   LLVM_DEBUG({
     dbgs() << "Registering ELF file info for \"" << FileName << "\"\n";
   });
   for (auto &Sec : G.sections()) {
     LLVM_DEBUG({
       dbgs() << "  Section \"" << Sec.getName() << "\": "
-             << (llvm::empty(Sec.symbols()) ? "empty. skipping."
-                                            : "processing...")
+             << (Sec.symbols().empty() ? "empty. skipping." : "processing...")
              << "\n";
     });
 
     // Skip empty sections.
-    if (llvm::empty(Sec.symbols()))
+    if (Sec.symbols().empty())
       continue;
 
     if (FileInfo.SectionInfos.count(Sec.getName()))
       return make_error<StringError>("Encountered duplicate section name \"" +
                                          Sec.getName() + "\" in \"" + FileName +
                                          "\"",
                                      inconvertibleErrorCode());
 

llvm/tools/llvm-jitlink/llvm-jitlink-macho.cpp

Error registerMachOGraphInfo(Session &S, LinkGraph &G) {
 
   auto &FileInfo = S.FileInfos[FileName];
   LLVM_DEBUG({
     dbgs() << "Registering MachO file info for \"" << FileName << "\"\n";
   });
   for (auto &Sec : G.sections()) {
     LLVM_DEBUG({
       dbgs() << "  Section \"" << Sec.getName() << "\": "
-             << (llvm::empty(Sec.symbols()) ? "empty. skipping."
-                                            : "processing...")
+             << (Sec.symbols().empty() ? "empty. skipping." : "processing...")
              << "\n";
     });
 
     // Skip empty sections.
-    if (llvm::empty(Sec.symbols()))
+    if (Sec.symbols().empty())
       continue;
 
     if (FileInfo.SectionInfos.count(Sec.getName()))
       return make_error<StringError>("Encountered duplicate section name \"" +
                                          Sec.getName() + "\" in \"" + FileName +
                                          "\"",
                                      inconvertibleErrorCode());
 

llvm/tools/llvm-jitlink/llvm-jitlink.cpp

static void dumpSectionContents(raw_ostream &OS, LinkGraph &G) {
   static_assert(isPowerOf2_64(DumpWidth), "DumpWidth must be a power of two");
 
   // Put sections in address order.
   std::vector<Section *> Sections;
   for (auto &S : G.sections())
     Sections.push_back(&S);
 
   llvm::sort(Sections, [](const Section *LHS, const Section *RHS) {
-    if (llvm::empty(LHS->symbols()) && llvm::empty(RHS->symbols()))
+    if (LHS->symbols().empty() && RHS->symbols().empty())
       return false;
-    if (llvm::empty(LHS->symbols()))
+    if (LHS->symbols().empty())
       return false;
-    if (llvm::empty(RHS->symbols()))
+    if (RHS->symbols().empty())
       return true;
     SectionRange LHSRange(*LHS);
     SectionRange RHSRange(*RHS);
     return LHSRange.getStart() < RHSRange.getStart();
   });
 
   for (auto *S : Sections) {
     OS << S->getName() << " content:";
-    if (llvm::empty(S->symbols())) {
+    if (S->symbols().empty()) {
       OS << "\n  section empty\n";
       continue;
     }
 
     // Sort symbols into order, then render.
     std::vector<Symbol *> Syms(S->symbols().begin(), S->symbols().end());
     llvm::sort(Syms, [](const Symbol *LHS, const Symbol *RHS) {
       return LHS->getAddress() < RHS->getAddress();