[BOLT] Process fragment siblings in lite mode, keep lite mode on

[Amir]

Summary

In lite mode, include split function fragments to the list of functions to
process even if a fragment has no samples. This is required to properly
detect and update split jump tables (jump tables that contain pointers to code
in the main and cold fragments).

[Amir]

Rebase

[maksfb]

If the function is local, it will have a /<N> suffix inserted after the main fragment name and after .cold. Will this change cover such case? Please add a test for it.

bolt/lib/Rewrite/RewriteInstance.cpp

1525–1526

[Amir]

Refactoring, bugfixes, added tests

[maksfb]

What do you think about preliminary matching fragments while reading the symbol table for non-stripped binaries? It's almost exactly what you are doing in this diff, right?

bolt/test/X86/fragment-lite-reverse.s

48

How is foo different from main for the purpose of this test?

From what I've seen, cold fragments typically have local visibility (but we shouldn't rely on it), while main fragments could be of any type.

[Amir]

Update testcase

[Amir]

In D140457#4038384, @maksfb wrote:

What do you think about preliminary matching fragments while reading the symbol table for non-stripped binaries? It's almost exactly what you are doing in this diff, right?

Let me look into that. I thought that selectFunctionsToProcess is the appropriate place since at that point we know which functions we want to skip and it's the earliest place to override that.

bolt/test/X86/fragment-lite-reverse.s

48

Fixed.

[maksfb]

In D140457#4038808, @Amir wrote:

In D140457#4038384, @maksfb wrote:

What do you think about preliminary matching fragments while reading the symbol table for non-stripped binaries? It's almost exactly what you are doing in this diff, right?

Let me look into that. I thought that selectFunctionsToProcess is the appropriate place since at that point we know which functions we want to skip and it's the earliest place to override that.

Sorry, I wasn't clear. I mean to match fragments early and then use the fragment dependency info in selectFunctionsToProcess(). It's still the right place to set functions as ignored.

[maksfb]

We need another set of tests where the main fragment has local visibility.

[Amir]

Add RI::registerFragments, update tests

[Amir]

Allow multiple parents per fragment (the case of ICF-folded cold fragments)

[Amir]

clang-format

[maksfb]

Thanks for refactoring the code.

What happens to stripped binaries? Should we disable lite mode for them?

bolt/lib/Core/BinaryContext.cpp

504

Do we have to check isFragment() before checking isParentFragment()? BTW, what do you think about renaming the latter to isChildOf()?

bolt/lib/Rewrite/RewriteInstance.cpp

737

Add the call to the end of discoverFileObjects(). That's where we register functions, data objects, etc.

1347

1351

What if you have global foo+foo.cold.1 and local foo/1+foo.cold.1/1? What will foo.cold.1/1 match to?

[Amir]

In D140457#4064034, @maksfb wrote:

Thanks for refactoring the code.

What happens to stripped binaries? Should we disable lite mode for them?

Actually, I don't know what happens to stripped binaries. For them, the more functions we process, the higher the risk that we miss a fragment or incorrectly update the jump table. Disabling lite mode doesn't fix processing stripped binaries with split functions. BTW, lite mode wasn't even disabled for such binaries since the determination is based on symbol names.

[Amir]

bolt/lib/Core/BinaryContext.cpp

504

D142667

[Amir]

Updated fragment-lite test with local and global baz+fragment

[Amir]

In D140457#4064034, @maksfb wrote:

Thanks for refactoring the code.

What happens to stripped binaries? Should we disable lite mode for them?

What happens to stripped binaries: D142686

[maksfb]

bolt/test/X86/fragment-lite.s

29

IIRC, FileCheck will pass this check even for Parent : baz/1.

[Amir]

Added an open-source binary test: https://github.com/rafaelauler/bolt-tests/pull/21

[Amir]

Update test

[maksfb]

LGTM

bolt/include/bolt/Core/BinaryContext.h

public:
   std::unique_ptr<MCAsmBackend> MAB;
 
   /// Indicates if relocations are available for usage.
   bool HasRelocations{false};
 
   /// Indicates if the binary is stripped
   bool IsStripped{false};
 
+  /// Indicates if the binary contains split functions.
+  bool HasSplitFunctions{false};
+
   /// Is the binary always loaded at a fixed address. Shared objects and
   /// position-independent executables (PIEs) are examples of binaries that
   /// will have HasFixedLoadAddress set to false.
   bool HasFixedLoadAddress{true};
 
   /// True if the binary has no dynamic dependencies, i.e., if it was statically
   /// linked.
   bool IsStaticExecutable{false};

bolt/include/bolt/Rewrite/RewriteInstance.h

 
 private:
   using ELF64LEPhdrTy = object::ELF64LEFile::Elf_Phdr;
 
   /// Populate array of binary functions and other objects of interest
   /// from meta data in the file.
   void discoverFileObjects();
 
+  /// Process fragments, locate parent functions.
+  void registerFragments();
+
   /// Read info from special sections. E.g. eh_frame and .gcc_except_table
   /// for exception and stack unwinding information.
   Error readSpecialSections();
 
   /// Adjust supplied command-line options based on input data.
   void adjustCommandLineOptions();
 
   /// Process runtime relocations.

bolt/lib/Core/BinaryContext.cpp

if (analyzeJumpTable(Address, JumpTable::JTT_PIC, BF))
     return MemoryContentsType::POSSIBLE_PIC_JUMP_TABLE;
 
   if (analyzeJumpTable(Address, JumpTable::JTT_NORMAL, BF))
     return MemoryContentsType::POSSIBLE_JUMP_TABLE;
 
   return MemoryContentsType::UNKNOWN;
 }
 
-/// Check if <fragment restored name> == <parent restored name>.cold(.\d+)?
-bool isPotentialFragmentByName(BinaryFunction &Fragment,
-                               BinaryFunction &Parent) {
-  for (StringRef Name : Parent.getNames()) {
-    std::string NamePrefix = Regex::escape(NameResolver::restore(Name));
-    std::string NameRegex = Twine(NamePrefix, "\\.cold(\\.[0-9]+)?").str();
-    if (Fragment.hasRestoredNameRegex(NameRegex))
-      return true;
-  }
-  return false;
-}
-
 bool BinaryContext::analyzeJumpTable(
     const uint64_t Address, const JumpTable::JumpTableType Type,
     BinaryFunction &BF, const uint64_t NextJTAddress,
     JumpTable::AddressesType *EntriesAsAddress) {
   // Is one of the targets __builtin_unreachable?
   bool HasUnreachable = false;
 
   // Number of targets other than __builtin_unreachable.
   uint64_t NumRealEntries = 0;
 
   auto addEntryAddress = [&](uint64_t EntryAddress) {
     if (EntriesAsAddress)
       EntriesAsAddress->emplace_back(EntryAddress);
   };
 
   auto doesBelongToFunction = [&](const uint64_t Addr,
                                   BinaryFunction *TargetBF) -> bool {
     if (BF.containsAddress(Addr))
       return true;
     // Nothing to do if we failed to identify the containing function.
     if (!TargetBF)
       return false;
-    // Case 1: check if BF is a fragment and TargetBF is its parent.
-    if (BF.isFragment()) {
-      // Parent function may or may not be already registered.
-      // Set parent link based on function name matching heuristic.
-      return registerFragment(BF, *TargetBF);
-    }
-    // Case 2: check if TargetBF is a fragment and BF is its parent.
-    return TargetBF->isFragment() && registerFragment(*TargetBF, BF);
+    // Check if BF is a fragment of TargetBF or vice versa.
+    return (BF.isFragment() && BF.isParentFragment(TargetBF)) ||
+           (TargetBF->isFragment() && TargetBF->isParentFragment(&BF));
   };
 
   ErrorOr<BinarySection &> Section = getSectionForAddress(Address);
   if (!Section)
     return false;
 
   // The upper bound is defined by containing object, section limits, and
   // the next jump table in memory.
if (NumCollisions) {
     if (!opts::Verbosity)
       errs() << ". Use -v=1 to see the list.";
     errs() << '\n';
   }
 }
 
 bool BinaryContext::registerFragment(BinaryFunction &TargetFunction,
                                      BinaryFunction &Function) const {
-  if (!isPotentialFragmentByName(TargetFunction, Function))
-    return false;
   assert(TargetFunction.isFragment() && "TargetFunction must be a fragment");
   if (TargetFunction.isParentFragment(&Function))
     return true;
   TargetFunction.addParentFragment(Function);
   Function.addFragment(TargetFunction);
   if (!HasRelocations) {
     TargetFunction.setSimple(false);
     Function.setSimple(false);
for (const std::pair<BinaryFunction *, uint64_t> &It :
 
     BinaryFunction *TargetFunction =
         getBinaryFunctionContainingAddress(Address);
     if (&Function == TargetFunction)
       continue;
 
     if (TargetFunction) {
       if (TargetFunction->isFragment() &&
-          !registerFragment(*TargetFunction, Function)) {
+          !TargetFunction->isParentFragment(&Function)) {
         errs() << "BOLT-WARNING: interprocedural reference between unrelated "
                   "fragments: "
                << Function.getPrintName() << " and "
                << TargetFunction->getPrintName() << '\n';
       }
       if (uint64_t Offset = Address - TargetFunction->getAddress())
         TargetFunction->addEntryPointAtOffset(Offset);
 

bolt/lib/Rewrite/RewriteInstance.cpp

 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/DataExtractor.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/ManagedStatic.h"
+#include "llvm/Support/Regex.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <fstream>
 #include <memory>
 #include <optional>
 #include <system_error>
Error RewriteInstance::run() {
 
   if (Error E = discoverStorage())
     return E;
   if (Error E = readSpecialSections())
     return E;
   adjustCommandLineOptions();
   discoverFileObjects();
 
   preprocessProfileData();
 
   // Skip disassembling if we have a translation table and we are running an
   // aggregation job.
   if (opts::AggregateOnly && BAT->enabledFor(InputFile)) {
     processProfileData();
     return Error::success();
   }
 
LastSymbol = std::stable_partition(
         [this](const SymbolRef &Symbol) { return !BC->isMarker(Symbol); });
     if (!SortedFileSymbols.empty())
       --LastSymbol;
   }
 
   BinaryFunction *PreviousFunction = nullptr;
   unsigned AnonymousId = 0;
 
+  // Regex object for matching cold fragments.
+  Regex ColdFragment(".*\\.cold(\\.[0-9]+)?");
+
   const auto SortedSymbolsEnd = LastSymbol == SortedFileSymbols.end()
                                     ? LastSymbol
                                     : std::next(LastSymbol);
   for (auto ISym = SortedFileSymbols.begin(); ISym != SortedSymbolsEnd;
        ++ISym) {
     const SymbolRef &Symbol = *ISym;
     // Keep undefined symbols for pretty printing?
     if (cantFail(Symbol.getFlags()) & SymbolRef::SF_Undefined)
if (BFI != BC->getBinaryFunctions().end()) {
       // Skip symbols from zero-sized sections.
       if (!Section->getSize())
         continue;
 
       BF = BC->createBinaryFunction(UniqueName, *Section, Address, SymbolSize);
       if (!IsSimple)
         BF->setSimple(false);
     }
+
+    // Check if it's a cold function fragment.
+    if (ColdFragment.match(SymName)) {
+      static bool PrintedWarning = false;
+      if (!PrintedWarning) {
+        PrintedWarning = true;
+        errs() << "BOLT-WARNING: split function detected on input : "
+               << SymName;
+        if (BC->HasRelocations)
+          errs() << ". The support is limited in relocation mode\n";
+      }
+      BC->HasSplitFunctions = true;
+      BF->IsFragment = true;
+    }
+
     if (!AlternativeName.empty())
       BF->addAlternativeName(AlternativeName);
 
     registerName(SymbolSize);
     PreviousFunction = BF;
   }
 
   // Read dynamic relocation first as their presence affects the way we process
void RewriteInstance::discoverFileObjects() {
 
   if (opts::LinuxKernelMode) {
     // Read all special linux kernel sections and their relocations
     processLKSections();
   } else {
     // Read all relocations now that we have binary functions mapped.
     processRelocations();
   }
+  registerFragments();
+}
+
+void RewriteInstance::registerFragments() {
+  if (!BC->HasSplitFunctions)
+    return;
+
+  for (auto &BFI : BC->getBinaryFunctions()) {
+    BinaryFunction &Function = BFI.second;
+    if (!Function.isFragment())
+      continue;
+    unsigned ParentsFound = 0;
+    for (StringRef Name : Function.getNames()) {
+      StringRef BaseName, Suffix;
+      std::tie(BaseName, Suffix) = Name.split('/');
+      const size_t ColdSuffixPos = BaseName.find(".cold");
+      if (ColdSuffixPos == StringRef::npos)
+        continue;
+      // For cold function with local (foo.cold/1) symbol, prefer a parent with
+      // local symbol as well (foo/1) over global symbol (foo).
+      std::string ParentName = BaseName.substr(0, ColdSuffixPos).str();
+      const BinaryData *BD = BC->getBinaryDataByName(ParentName);
+      if (Suffix != "") {
+        ParentName.append(Twine("/", Suffix).str());
+        const BinaryData *BDLocal = BC->getBinaryDataByName(ParentName);
+        if (BDLocal || !BD)
+          BD = BDLocal;
+      }
+      if (!BD) {
+        if (opts::Verbosity >= 1)
+          outs() << "BOLT-INFO: parent function not found for " << Name << "\n";
+        continue;
+      }
+      const uint64_t Address = BD->getAddress();
+      BinaryFunction *BF = BC->getBinaryFunctionAtAddress(Address);
+      if (!BF) {
+        if (opts::Verbosity >= 1)
+          outs() << formatv("BOLT-INFO: parent function not found at {0:x}\n",
+                            Address);
+        continue;
+      }
+      BC->registerFragment(Function, *BF);
+      ++ParentsFound;
+    }
+    if (!ParentsFound) {
+      errs() << "BOLT-ERROR: parent function not found for " << Function
+             << '\n';
+      exit(1);
+    }
+  }
 }
 
 void RewriteInstance::createPLTBinaryFunction(uint64_t TargetAddress,
                                               uint64_t EntryAddress,
                                               uint64_t EntrySize) {
   if (!TargetAddress)
     return;
 
   auto setPLTSymbol = [&](BinaryFunction *BF, StringRef Name) {
     const unsigned PtrSize = BC->AsmInfo->getCodePointerSize();
     MCSymbol *TargetSymbol = BC->registerNameAtAddress(
         Name.str() + "@GOT", TargetAddress, PtrSize, PtrSize);
     BF->setPLTSymbol(TargetSymbol);
   };
 
   BinaryFunction *BF = BC->getBinaryFunctionAtAddress(EntryAddress);
   if (BF && BC->isAArch64()) {
     // Handle IFUNC trampoline
     setPLTSymbol(BF, BF->getOneName());
     return;
   }
 
   const Relocation *Rel = BC->getDynamicRelocationAt(TargetAddress);
   if (!Rel || !Rel->Symbol)
     return;
void RewriteInstance::adjustFunctionBoundaries() {
   for (auto BFI = BC->getBinaryFunctions().begin(),
             BFE = BC->getBinaryFunctions().end();
        BFI != BFE; ++BFI) {
     BinaryFunction &Function = BFI->second;
     const BinaryFunction *NextFunction = nullptr;
     if (std::next(BFI) != BFE)
       NextFunction = &std::next(BFI)->second;
 
-    // Check if it's a fragment of a function.
-    std::optional<StringRef> FragName =
-        Function.hasRestoredNameRegex(".*\\.cold(\\.[0-9]+)?");
-    if (FragName) {
-      static bool PrintedWarning = false;
-      if (!PrintedWarning) {
-        PrintedWarning = true;
-        errs() << "BOLT-WARNING: split function detected on input : "
-               << *FragName;
-        if (BC->HasRelocations)
-          errs() << ". The support is limited in relocation mode";
-        if (opts::Lite) {
-          opts::Lite = false;
-          errs() << "\nBOLT-WARNING: disabling lite mode (-lite) when split "
-                 << "functions are present\n";
-        }
-      }
-      Function.IsFragment = true;
-    }
-
     // Check if there's a symbol or a function with a larger address in the
     // same section. If there is - it determines the maximum size for the
     // current function. Otherwise, it is the size of a containing section
     // the defines it.
     //
     // NOTE: ignore some symbols that could be tolerated inside the body
     //       of a function.
     auto NextSymRefI = FileSymRefs.upper_bound(Function.getAddress());
     while (NextSymRefI != FileSymRefs.end()) {
       SymbolRef &Symbol = NextSymRefI->second;
void RewriteInstance::selectFunctionsToProcess() {
   StringSet<> ReorderFunctionsUserSet;
   if (opts::ReorderFunctions == ReorderFunctions::RT_USER) {
     for (const std::string &Function :
          ReorderFunctions::readFunctionOrderFile())
       ReorderFunctionsUserSet.insert(Function);
   }
 
   uint64_t NumFunctionsToProcess = 0;
-  auto shouldProcess = [&](const BinaryFunction &Function) {
+  auto mustSkip = [&](const BinaryFunction &Function) {
     if (opts::MaxFunctions && NumFunctionsToProcess > opts::MaxFunctions)
+      return true;
+    for (std::string &Name : opts::SkipFunctionNames)
+      if (Function.hasNameRegex(Name))
+        return true;
+
+    return false;
+  };
+
+  auto shouldProcess = [&](const BinaryFunction &Function) {
+    if (mustSkip(Function))
       return false;
 
     // If the list is not empty, only process functions from the list.
     if (!opts::ForceFunctionNames.empty() || !ForceFunctionsNR.empty()) {
       // Regex check (-funcs and -funcs-file options).
       for (std::string &Name : opts::ForceFunctionNames)
         if (Function.hasNameRegex(Name))
           return true;
 
       // Non-regex check (-funcs-no-regex and -funcs-file-no-regex).
       std::optional<StringRef> Match =
           Function.forEachName([&ForceFunctionsNR](StringRef Name) {
             return ForceFunctionsNR.count(Name.str());
           });
       return Match.has_value();
     }
 
-    for (std::string &Name : opts::SkipFunctionNames)
-      if (Function.hasNameRegex(Name))
-        return false;
-
     if (opts::Lite) {
       // Forcibly include functions specified in the -function-order file.
       if (opts::ReorderFunctions == ReorderFunctions::RT_USER) {
         std::optional<StringRef> Match =
             Function.forEachName([&](StringRef Name) {
               return ReorderFunctionsUserSet.contains(Name);
             });
         if (Match.has_value())
for (auto &BFI : BC->getBinaryFunctions()) {
 
     // Pseudo functions are explicitly marked by us not to be processed.
     if (Function.isPseudo()) {
       Function.IsIgnored = true;
       Function.HasExternalRefRelocations = true;
       continue;
     }
 
+    // Decide what to do with fragments after parent functions are processed.
+    if (Function.isFragment())
+      continue;
+
     if (!shouldProcess(Function)) {
-      LLVM_DEBUG(dbgs() << "BOLT-INFO: skipping processing of function "
-                        << Function << " per user request\n");
+      if (opts::Verbosity >= 1) {
+        outs() << "BOLT-INFO: skipping processing " << Function
+               << " per user request\n";
+      }
       Function.setIgnored();
     } else {
       ++NumFunctionsToProcess;
       if (opts::MaxFunctions && NumFunctionsToProcess == opts::MaxFunctions)
         outs() << "BOLT-INFO: processing ending on " << Function << '\n';
     }
   }
+
+  if (!BC->HasSplitFunctions)
+    return;
+
+  // Fragment overrides:
+  // - If the fragment must be skipped, then the parent must be skipped as well.
+  // Otherwise, fragment should follow the parent function:
+  // - if the parent is skipped, skip fragment,
+  // - if the parent is processed, process the fragment(s) as well.
+  for (auto &BFI : BC->getBinaryFunctions()) {
+    BinaryFunction &Function = BFI.second;
+    if (!Function.isFragment())
+      continue;
+    if (mustSkip(Function)) {
+      for (BinaryFunction *Parent : Function.ParentFragments) {
+        if (opts::Verbosity >= 1) {
+          outs() << "BOLT-INFO: skipping processing " << *Parent
+                 << " together with fragment function\n";
+        }
+        Parent->setIgnored();
+        --NumFunctionsToProcess;
+      }
+      Function.setIgnored();
+      continue;
+    }
+
+    bool IgnoredParent =
+        llvm::any_of(Function.ParentFragments, [&](BinaryFunction *Parent) {
+          return Parent->isIgnored();
+        });
+    if (IgnoredParent) {
+      if (opts::Verbosity >= 1) {
+        outs() << "BOLT-INFO: skipping processing " << Function
+               << " together with parent function\n";
+      }
+      Function.setIgnored();
+    } else {
+      ++NumFunctionsToProcess;
+      if (opts::Verbosity >= 1) {
+        outs() << "BOLT-INFO: processing " << Function
+               << " as a sibling of non-ignored function\n";
+      }
+      if (opts::MaxFunctions && NumFunctionsToProcess == opts::MaxFunctions)
+        outs() << "BOLT-INFO: processing ending on " << Function << '\n';
+    }
+  }
 }
 
 void RewriteInstance::readDebugInfo() {
   NamedRegionTimer T("readDebugInfo", "read debug info", TimerGroupName,
                      TimerGroupDesc, opts::TimeRewrite);
   if (!opts::UpdateDebugSections)
     return;
 

bolt/test/CMakeLists.txt

list(APPEND BOLT_TEST_DEPS
   llvm-objdump
   llvm-readelf
   llvm-readobj
   llvm-strip
   llvm-objcopy
   merge-fdata
   not
   perf2bolt
+  split-file
   yaml2obj
   )
 
 add_custom_target(bolt-test-depends DEPENDS ${BOLT_TEST_DEPS})
 set_target_properties(bolt-test-depends PROPERTIES FOLDER "BOLT")
 
 add_lit_testsuite(check-bolt "Running the BOLT regression tests"
   ${CMAKE_CURRENT_BINARY_DIR}

bolt/test/X86/fragment-lite-reverse.s

+# Check that BOLT in lite mode processes fragments as expected.
+
+# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o
+# RUN: link_fdata %s %t.o %t.fdata
+# RUN: %clang %cflags %t.o -o %t.exe -Wl,-q
+# RUN: llvm-bolt %t.exe -o %t.out --lite=1 --data %t.fdata -v=1 2>&1 \
+# RUN:   | FileCheck %s
+
+# CHECK: BOLT-INFO: skipping processing main.cold.1 together with parent function
+# CHECK: BOLT-INFO: skipping processing foo.cold.1/1 together with parent function
+# CHECK: BOLT-INFO: skipping processing bar.cold.1/1 together with parent function
+
+  .globl main
+  .type main, %function
+main:
+  .cfi_startproc
+  cmpl  $0x0, %eax
+  je  main.cold.1
+  retq
+  .cfi_endproc
+.size main, .-main
+
+  .globl foo
+  .type foo, %function
+foo:
+  .cfi_startproc
+  cmpl  $0x0, %eax
+  je  foo.cold.1
+  retq
+  .cfi_endproc
+.size foo, .-foo
+
+  .local bar
+  .type bar, %function
+bar:
+  .cfi_startproc
+  cmpl  $0x0, %eax
+  je  bar.cold.1
+  retq
+  .cfi_endproc
+.size bar, .-bar
+
+  .section .text.cold
+  .globl main.cold.1
+  .type main.cold.1, %function
+main.cold.1:
+# FDATA: 0 [unknown] 0 1 main.cold.1 0 1 0
+  .cfi_startproc
+  pushq %rbp
+  movq  %rsp, %rbp
+  movl  $0x0, %eax
+  popq  %rbp
+  retq
+  .cfi_endproc
+.size main.cold.1, .-main.cold.1
+
+  .local foo.cold.1
+  .type foo.cold.1, %function
+foo.cold.1:
+# FDATA: 0 [unknown] 0 1 foo.cold.1/1 0 1 0
+  .cfi_startproc
+  pushq %rbp
+  movq  %rsp, %rbp
+  movl  $0x0, %eax
+  popq  %rbp
+  retq
+  .cfi_endproc
+.size foo.cold.1, .-foo.cold.1
+
+  .local bar.cold.1
+  .type bar.cold.1, %function
+bar.cold.1:
+# FDATA: 0 [unknown] 0 1 bar.cold.1/1 0 1 0
+  .cfi_startproc
+  pushq %rbp
+  movq  %rsp, %rbp
+  movl  $0x0, %eax
+  popq  %rbp
+  retq
+  .cfi_endproc
+.size bar.cold.1, .-bar.cold.1

bolt/test/X86/fragment-lite.s

+# Check that BOLT in lite mode processes fragments as expected.
+
+# RUN: split-file %s %t
+# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %t/main.s -o %t.o
+# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %t/baz.s -o %t.baz.o
+# RUN: link_fdata %s %t.o %t.main.fdata
+# RUN: link_fdata %s %t.baz.o %t.baz.fdata
+# RUN: merge-fdata %t.main.fdata %t.baz.fdata > %t.fdata
+# RUN: %clang %cflags %t.o %t.baz.o -o %t.exe -Wl,-q
+# RUN: llvm-bolt %t.exe -o %t.out --lite=1 --data %t.fdata -v=1 -print-cfg \
+# RUN:   2>&1 | FileCheck %s
+
+# CHECK: BOLT-INFO: processing main.cold.1 as a sibling of non-ignored function
+# CHECK: BOLT-INFO: processing foo.cold.1/1 as a sibling of non-ignored function
+# CHECK: BOLT-INFO: processing bar.cold.1/1 as a sibling of non-ignored function
+# CHECK: BOLT-INFO: processing baz.cold.1 as a sibling of non-ignored function
+# CHECK: BOLT-INFO: processing baz.cold.1/1 as a sibling of non-ignored function
+
+# CHECK: Binary Function "main.cold.1" after building cfg
+# CHECK: Parent : main
+
+# CHECK: Binary Function "foo.cold.1/1" after building cfg
+# CHECK: Parent : foo
+
+# CHECK: Binary Function "bar.cold.1/1" after building cfg
+# CHECK: Parent : bar/1
+
+# CHECK: Binary Function "baz.cold.1" after building cfg
+# CHECK: Parent : baz
+
+# CHECK: Binary Function "baz.cold.1/1" after building cfg
+# CHECK: Parent : baz/1
+
+#--- main.s
+  .globl main
+  .type main, %function
+main:
+  .cfi_startproc
+# FDATA: 0 [unknown] 0 1 main 0 1 0
+  cmpl  $0x0, %eax
+  je  main.cold.1
+  retq
+  .cfi_endproc
+.size main, .-main
+
+  .globl foo
+  .type foo, %function
+foo:
+  .cfi_startproc
+# FDATA: 0 [unknown] 0 1 foo 0 1 0
+  cmpl  $0x0, %eax
+  je  foo.cold.1
+  retq
+  .cfi_endproc
+.size foo, .-foo
+
+  .local bar
+  .type bar, %function
+bar:
+  .cfi_startproc
+# FDATA: 0 [unknown] 0 1 bar/1 0 1 0
+  cmpl  $0x0, %eax
+  je  bar.cold.1
+  retq
+  .cfi_endproc
+.size bar, .-bar
+
+  .globl baz
+  .type baz, %function
+baz:
+  .cfi_startproc
+# FDATA: 0 [unknown] 0 1 baz 0 1 0
+  cmpl  $0x0, %eax
+  je  baz.cold.1
+  retq
+  .cfi_endproc
+.size baz, .-baz
+
+  .section .text.cold
+  .globl main.cold.1
+  .type main.cold.1, %function
+main.cold.1:
+  .cfi_startproc
+  pushq %rbp
+  movq  %rsp, %rbp
+  movl  $0x0, %eax
+  popq  %rbp
+  retq
+  .cfi_endproc
+.size main.cold.1, .-main.cold.1
+
+  .local foo.cold.1
+  .type foo.cold.1, %function
+foo.cold.1:
+  .cfi_startproc
+  pushq %rbp
+  movq  %rsp, %rbp
+  movl  $0x0, %eax
+  popq  %rbp
+  retq
+  .cfi_endproc
+.size foo.cold.1, .-foo.cold.1
+
+  .local bar.cold.1
+  .type bar.cold.1, %function
+bar.cold.1:
+  .cfi_startproc
+  pushq %rbp
+  movq  %rsp, %rbp
+  movl  $0x0, %eax
+  popq  %rbp
+  retq
+  .cfi_endproc
+.size bar.cold.1, .-bar.cold.1
+
+  .globl baz.cold.1
+  .type baz.cold.1, %function
+baz.cold.1:
+  .cfi_startproc
+  pushq %rbp
+  movq  %rsp, %rbp
+  movl  $0x0, %eax
+  popq  %rbp
+  retq
+  .cfi_endproc
+.size baz.cold.1, .-baz.cold.1
+
+#--- baz.s
+  .local baz
+  .type baz, %function
+baz:
+  .cfi_startproc
+# FDATA: 0 [unknown] 0 1 baz/1 0 1 0
+  cmpl  $0x0, %eax
+  je  baz.cold.1
+  retq
+  .cfi_endproc
+.size baz, .-baz
+
+  .section .text.cold
+  .local baz.cold.1
+  .type baz.cold.1, %function
+baz.cold.1:
+  .cfi_startproc
+  pushq %rbp
+  movq  %rsp, %rbp
+  movl  $0x0, %eax
+  popq  %rbp
+  retq
+  .cfi_endproc
+.size baz.cold.1, .-baz.cold.1

bolt/test/X86/split-func-icf.s

 # This reproduces an issue where two cold fragments are folded into one, so the
 # fragment has two parents.
 # The fragment is only reachable through a jump table, so all functions must be
 # ignored.
 
 # REQUIRES: system-linux
 
 # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o
 # RUN: llvm-strip --strip-unneeded %t.o
 # RUN: %clang %cflags %t.o -o %t.exe -Wl,-q
 # RUN: llvm-bolt %t.exe -o %t.out -v=1 --print-only=main2.cold.1 --print-disasm 2>&1 | FileCheck %s
 
 # CHECK-NOT: unclaimed PC-relative relocations left in data
-# CHECK-DAG: BOLT-INFO: marking main2.cold.1(*2) as a fragment of main
 # CHECK-DAG: BOLT-INFO: marking main2.cold.1(*2) as a fragment of main2
+# CHECK-DAG: BOLT-INFO: marking main2.cold.1(*2) as a fragment of main
 # CHECK: Binary Function "main2.cold.1(*2)" after disassembly
 # CHECK: End of Function "main2.cold.1(*2)"
 # CHECK-DAG: BOLT-WARNING: Ignoring main2
 # CHECK-DAG: BOLT-WARNING: Ignoring main
 # CHECK-DAG: BOLT-WARNING: Ignoring main2.cold.1(*2)
 # CHECK: BOLT-WARNING: skipped 3 functions due to cold fragments
   .text
   .globl main

bolt/test/lit.cfg.py

tools = [
     ToolSubst('llvm-objdump', unresolved='fatal'),
     ToolSubst('llvm-objcopy', unresolved='fatal'),
     ToolSubst('llvm-strip', unresolved='fatal'),
     ToolSubst('llvm-readelf', unresolved='fatal'),
     ToolSubst('link_fdata', command=sys.executable, unresolved='fatal', extra_args=[link_fdata_cmd]),
     ToolSubst('merge-fdata', unresolved='fatal'),
     ToolSubst('llvm-readobj', unresolved='fatal'),
     ToolSubst('llvm-dwp', unresolved='fatal'),
+    ToolSubst('split-file', unresolved='fatal'),
 ]
 llvm_config.add_tool_substitutions(tools, tool_dirs)
 
 def calculate_arch_features(arch_string):
     features = []
     for arch in arch_string.split():
         features.append(arch.lower() + '-registered-target')
     return features