[BOLT] Add blocks order kind to YAML profile header

[Amir]

Summary

Specify blocks order used in YAML profile. Needed to ensure profile backwards
compatibility with pre-D155514 DFS order by default.

[maksfb]

bolt/include/bolt/Profile/ProfileYAMLMapping.h

27

Since we only use DFS and non-DFS values internally, perhaps we can have the same boolean value in YAML?

[Amir]

Use IsDFSOrder bool value

[maksfb]

Will the test work on non-linux systems? If the asm is not necessary, maybe use C?

[Amir]

Switch test to C

[Amir]

In D156176#4530453, @maksfb wrote:

Will the test work on non-linux systems? If the asm is not necessary, maybe use C?

Assembly should work on any system, but switch to C to ensure portability.

[Amir]

clang-format

bolt/include/bolt/Profile/ProfileYAMLMapping.h

 #include <vector>
 
 using llvm::bolt::BinaryFunction;
 
 namespace llvm {
 namespace yaml {
 
 namespace bolt {
 struct CallSiteInfo {
   llvm::yaml::Hex32 Offset{0};
   uint32_t DestId{0};
   uint32_t EntryDiscriminator{0}; /// multiple entry discriminator
   uint64_t Count{0};
   uint64_t Mispreds{0};
 
   bool operator==(const CallSiteInfo &Other) const {
     return Offset == Other.Offset && DestId == Other.DestId &&

 struct BinaryProfileHeader {
   uint32_t Version{1};
   std::string FileName; // Name of the profiled binary.
   std::string Id;       // BuildID.
   PROFILE_PF Flags{BinaryFunction::PF_NONE};
   // Type of the profile.
   std::string Origin;     // How the profile was obtained.
   std::string EventNames; // Events used for sample profile.
+  bool IsDFSOrder{true};  // Whether using DFS block order in function profile
 };
 } // end namespace bolt
 
 template <> struct MappingTraits<bolt::BinaryProfileHeader> {
   static void mapping(IO &YamlIO, bolt::BinaryProfileHeader &Header) {
     YamlIO.mapRequired("profile-version", Header.Version);
     YamlIO.mapRequired("binary-name", Header.FileName);
     YamlIO.mapOptional("binary-build-id", Header.Id);
     YamlIO.mapRequired("profile-flags", Header.Flags);
     YamlIO.mapOptional("profile-origin", Header.Origin);
     YamlIO.mapOptional("profile-events", Header.EventNames);
+    YamlIO.mapOptional("dfs-order", Header.IsDFSOrder);
   }
 };
 
 } // end namespace yaml
 } // end namespace llvm
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::yaml::bolt::BinaryFunctionProfile)
 

bolt/lib/Profile/YAMLProfileReader.cpp

bool YAMLProfileReader::hasLocalsWithFileName() const {
   }
   return false;
 }
 
 bool YAMLProfileReader::parseFunctionProfile(
     BinaryFunction &BF, const yaml::bolt::BinaryFunctionProfile &YamlBF) {
   BinaryContext &BC = BF.getBinaryContext();
 
+  const bool IsDFSOrder = YamlBP.Header.IsDFSOrder;
   bool ProfileMatched = true;
   uint64_t MismatchedBlocks = 0;
   uint64_t MismatchedCalls = 0;
   uint64_t MismatchedEdges = 0;
 
   uint64_t FunctionExecutionCount = 0;
 
   BF.setExecutionCount(YamlBF.ExecCount);
 
   uint64_t FuncRawBranchCount = 0;
   for (const yaml::bolt::BinaryBasicBlockProfile &YamlBB : YamlBF.Blocks)
     for (const yaml::bolt::SuccessorInfo &YamlSI : YamlBB.Successors)
       FuncRawBranchCount += YamlSI.Count;
   BF.setRawBranchCount(FuncRawBranchCount);
 
-  if (!opts::IgnoreHash && YamlBF.Hash != BF.computeHash(opts::ProfileUseDFS)) {
+  if (!opts::IgnoreHash && YamlBF.Hash != BF.computeHash(IsDFSOrder)) {
     if (opts::Verbosity >= 1)
       errs() << "BOLT-WARNING: function hash mismatch\n";
     ProfileMatched = false;
   }
 
   if (YamlBF.NumBasicBlocks != BF.size()) {
     if (opts::Verbosity >= 1)
       errs() << "BOLT-WARNING: number of basic blocks mismatch\n";
     ProfileMatched = false;
   }
 
   BinaryFunction::BasicBlockOrderType Order;
-  if (opts::ProfileUseDFS)
+  if (IsDFSOrder)
     llvm::copy(BF.dfs(), std::back_inserter(Order));
   else
     llvm::copy(BF.getLayout().blocks(), std::back_inserter(Order));
 
   for (const yaml::bolt::BinaryBasicBlockProfile &YamlBB : YamlBF.Blocks) {
     if (YamlBB.Index >= Order.size()) {
       if (opts::Verbosity >= 2)
         errs() << "BOLT-WARNING: index " << YamlBB.Index
for (auto &BFI : BC.getBinaryFunctions()) {
     BinaryFunction &Function = BFI.second;
 
     // Clear function call count that may have been set while pre-processing
     // the profile.
     Function.setExecutionCount(BinaryFunction::COUNT_NO_PROFILE);
 
     // Recompute hash once per function.
     if (!opts::IgnoreHash)
-      Function.computeHash(opts::ProfileUseDFS);
+      Function.computeHash(YamlBP.Header.IsDFSOrder);
 
     for (StringRef FunctionName : Function.getNames()) {
       auto PI = ProfileNameToProfile.find(FunctionName);
       if (PI == ProfileNameToProfile.end())
         continue;
 
       yaml::bolt::BinaryFunctionProfile &YamlBF = *PI->getValue();
       if (profileMatches(YamlBF, Function))

bolt/lib/Profile/YAMLProfileWriter.cpp

std::error_code YAMLProfileWriter::writeProfile(const RewriteInstance &RI) {
   yaml::bolt::BinaryProfile BP;
 
   // Fill out the header info.
   BP.Header.Version = 1;
   BP.Header.FileName = std::string(BC.getFilename());
   std::optional<StringRef> BuildID = BC.getFileBuildID();
   BP.Header.Id = BuildID ? std::string(*BuildID) : "<unknown>";
   BP.Header.Origin = std::string(RI.getProfileReader()->getReaderName());
+  BP.Header.IsDFSOrder = opts::ProfileUseDFS;
 
   StringSet<> EventNames = RI.getProfileReader()->getEventNames();
   if (!EventNames.empty()) {
     std::string Sep;
     for (const StringMapEntry<std::nullopt_t> &EventEntry : EventNames) {
       BP.Header.EventNames += Sep + EventEntry.first().str();
       Sep = ",";
     }

bolt/test/yaml-profile-kind.c

+/* This test checks the handling of YAML profile with different block orders.
+# RUN: %clang %cflags %s -o %t.exe
+# RUN: link_fdata %s %t.exe %t.fdata
+# RUN: llvm-bolt %t.exe -o /dev/null -data %t.fdata -w %t.yaml
+# RUN: FileCheck %s --input-file %t.yaml --check-prefix=CHECK-BINARY
+# CHECK-BINARY: dfs-order: false
+# RUN: llvm-bolt %t.exe -o /dev/null -data %t.fdata -w %t.yaml --profile-use-dfs
+# RUN: FileCheck %s --input-file %t.yaml --check-prefix=CHECK-DFS
+# CHECK-DFS: dfs-order: true
+
+# FDATA: 0 [unknown] 0 1 main 0 0 0
+*/
+int main() { return 0; }