[BOLT][NFC] Rename {MachO,}RewriteInstance::create methods

[Amir]

Summary

Follow the code style of fallible constructors in [LLVM Programmer's Manual]
(https://llvm.org/docs/ProgrammersManual.html#fallible-constructors)
and rename RewriteInstance::createRewriteInstance to RewriteInstance::create

[rafauler]

LGTM

[Amir]

Update fuzzer and heatmap

bolt/include/bolt/Rewrite/MachORewriteInstance.h

class MachORewriteInstance {
 
   void writeInstrumentationSection(StringRef SectionName,
                                    raw_pwrite_stream &OS);
   void rewriteFile();
 
 public:
   // This constructor has complex initialization that can fail during
   // construction. Constructors can’t return errors, so clients must test \p Err
-  // after the object is constructed. Use createMachORewriteInstance instead.
+  // after the object is constructed. Use `create` method instead.
   MachORewriteInstance(object::MachOObjectFile *InputFile, StringRef ToolPath,
                        Error &Err);
 
   static Expected<std::unique_ptr<MachORewriteInstance>>
-  createMachORewriteInstance(object::MachOObjectFile *InputFile,
-                             StringRef ToolPath);
+  create(object::MachOObjectFile *InputFile, StringRef ToolPath);
   ~MachORewriteInstance();
 
   Error setProfile(StringRef FileName);
 
   /// Run all the necessary steps to read, optimize and rewrite the binary.
   void run();
 };
 
 } // namespace bolt
 } // namespace llvm
 
 #endif

bolt/include/bolt/Rewrite/RewriteInstance.h

 /// This class encapsulates all data necessary to carry on binary reading,
 /// disassembly, CFG building, BB reordering (among other binary-level
 /// optimizations) and rewriting. It also has the logic to coordinate such
 /// events.
 class RewriteInstance {
 public:
   // This constructor has complex initialization that can fail during
   // construction. Constructors can’t return errors, so clients must test \p Err
-  // after the object is constructed. Use createRewriteInstance instead.
+  // after the object is constructed. Use `create` method instead.
   RewriteInstance(llvm::object::ELFObjectFileBase *File, const int Argc,
                   const char *const *Argv, StringRef ToolPath, Error &Err);
 
   static Expected<std::unique_ptr<RewriteInstance>>
-  createRewriteInstance(llvm::object::ELFObjectFileBase *File, const int Argc,
-                        const char *const *Argv, StringRef ToolPath);
+  create(llvm::object::ELFObjectFileBase *File, const int Argc,
   ~RewriteInstance();
 
   /// Assign profile from \p Filename to this instance.
   Error setProfile(StringRef Filename);
 
   /// Run all the necessary steps to read, optimize and rewrite the binary.
   Error run();
 

bolt/lib/Rewrite/MachORewriteInstance.cpp

#endif
   llvm_unreachable("architecture unsupported by MCPlusBuilder");
 }
 
 } // anonymous namespace
 
 #define DEBUG_TYPE "bolt"
 
 Expected<std::unique_ptr<MachORewriteInstance>>
-MachORewriteInstance::createMachORewriteInstance(
-    object::MachOObjectFile *InputFile, StringRef ToolPath) {
+MachORewriteInstance::create(object::MachOObjectFile *InputFile,
+                             StringRef ToolPath) {
   Error Err = Error::success();
   auto MachORI =
       std::make_unique<MachORewriteInstance>(InputFile, ToolPath, Err);
   if (Err)
     return std::move(Err);
   return std::move(MachORI);
 }
 

bolt/lib/Rewrite/RewriteInstance.cpp

bool refersToReorderedSection(ErrorOr<BinarySection &> Section) {
   return llvm::any_of(opts::ReorderData, [&](const std::string &SectionName) {
     return Section && Section->getName() == SectionName;
   });
 }
 
 } // anonymous namespace
 
 Expected<std::unique_ptr<RewriteInstance>>
-RewriteInstance::createRewriteInstance(ELFObjectFileBase *File, const int Argc,
-                                       const char *const *Argv,
-                                       StringRef ToolPath) {
+RewriteInstance::create(ELFObjectFileBase *File, const int Argc,
+                        const char *const *Argv, StringRef ToolPath) {
   Error Err = Error::success();
   auto RI = std::make_unique<RewriteInstance>(File, Argc, Argv, ToolPath, Err);
   if (Err)
     return std::move(Err);
   return std::move(RI);
 }
 
 RewriteInstance::RewriteInstance(ELFObjectFileBase *File, const int Argc,

bolt/tools/driver/llvm-bolt.cpp

int main(int argc, char **argv) {
   if (!opts::DiffOnly) {
     Expected<OwningBinary<Binary>> BinaryOrErr =
         createBinary(opts::InputFilename);
     if (Error E = BinaryOrErr.takeError())
       report_error(opts::InputFilename, std::move(E));
     Binary &Binary = *BinaryOrErr.get().getBinary();
 
     if (auto *e = dyn_cast<ELFObjectFileBase>(&Binary)) {
-      auto RIOrErr =
-          RewriteInstance::createRewriteInstance(e, argc, argv, ToolPath);
+      auto RIOrErr = RewriteInstance::create(e, argc, argv, ToolPath);
       if (Error E = RIOrErr.takeError())
         report_error(opts::InputFilename, std::move(E));
       RewriteInstance &RI = *RIOrErr.get();
       if (!opts::PerfData.empty()) {
         if (!opts::AggregateOnly) {
           errs() << ToolName
                  << ": WARNING: reading perf data directly is unsupported, "
                     "please use "
if (auto *e = dyn_cast<ELFObjectFileBase>(&Binary)) {
       if (opts::AggregateOnly && opts::PerfData.empty()) {
         errs() << ToolName << ": missing required -perfdata option.\n";
         exit(1);
       }
 
       if (Error E = RI.run())
         report_error(opts::InputFilename, std::move(E));
     } else if (auto *O = dyn_cast<MachOObjectFile>(&Binary)) {
-      auto MachORIOrErr =
-          MachORewriteInstance::createMachORewriteInstance(O, ToolPath);
+      auto MachORIOrErr = MachORewriteInstance::create(O, ToolPath);
       if (Error E = MachORIOrErr.takeError())
         report_error(opts::InputFilename, std::move(E));
       MachORewriteInstance &MachORI = *MachORIOrErr.get();
 
       if (!opts::InputDataFilename.empty())
         if (Error E = MachORI.setProfile(opts::InputDataFilename))
           report_error(opts::InputDataFilename, std::move(E));
 
int main(int argc, char **argv) {
   if (Error E = BinaryOrErr1.takeError())
     report_error(opts::InputFilename, std::move(E));
   if (Error E = BinaryOrErr2.takeError())
     report_error(opts::InputFilename2, std::move(E));
   Binary &Binary1 = *BinaryOrErr1.get().getBinary();
   Binary &Binary2 = *BinaryOrErr2.get().getBinary();
   if (auto *ELFObj1 = dyn_cast<ELFObjectFileBase>(&Binary1)) {
     if (auto *ELFObj2 = dyn_cast<ELFObjectFileBase>(&Binary2)) {
-      auto RI1OrErr =
-          RewriteInstance::createRewriteInstance(ELFObj1, argc, argv, ToolPath);
+      auto RI1OrErr = RewriteInstance::create(ELFObj1, argc, argv, ToolPath);
       if (Error E = RI1OrErr.takeError())
         report_error(opts::InputFilename, std::move(E));
       RewriteInstance &RI1 = *RI1OrErr.get();
       if (Error E = RI1.setProfile(opts::InputDataFilename))
         report_error(opts::InputDataFilename, std::move(E));
-      auto RI2OrErr =
-          RewriteInstance::createRewriteInstance(ELFObj2, argc, argv, ToolPath);
+      auto RI2OrErr = RewriteInstance::create(ELFObj2, argc, argv, ToolPath);
       if (Error E = RI2OrErr.takeError())
         report_error(opts::InputFilename2, std::move(E));
       RewriteInstance &RI2 = *RI2OrErr.get();
       if (Error E = RI2.setProfile(opts::InputDataFilename2))
         report_error(opts::InputDataFilename2, std::move(E));
       outs() << "BOLT-DIFF: *** Analyzing binary 1: " << opts::InputFilename
              << "\n";
       outs() << "BOLT-DIFF: *** Binary 1 fdata:     " << opts::InputDataFilename

bolt/tools/heatmap/heatmap.cpp

int main(int argc, char **argv) {
   std::string ToolPath = GetExecutablePath(argv[0]);
   Expected<OwningBinary<Binary>> BinaryOrErr =
       createBinary(opts::InputFilename);
   if (Error E = BinaryOrErr.takeError())
     report_error(opts::InputFilename, std::move(E));
   Binary &Binary = *BinaryOrErr.get().getBinary();
 
   if (auto *e = dyn_cast<ELFObjectFileBase>(&Binary)) {
-    auto RIOrErr =
-        RewriteInstance::createRewriteInstance(e, argc, argv, ToolPath);
+    auto RIOrErr = RewriteInstance::create(e, argc, argv, ToolPath);
     if (Error E = RIOrErr.takeError())
       report_error("RewriteInstance", std::move(E));
 
     RewriteInstance &RI = *RIOrErr.get();
     if (Error E = RI.setProfile(opts::PerfData))
       report_error(opts::PerfData, std::move(E));
 
     if (Error E = RI.run())
       report_error(opts::InputFilename, std::move(E));
   } else {
     report_error(opts::InputFilename, object_error::invalid_file_type);
   }
 
   return EXIT_SUCCESS;
 }

bolt/tools/llvm-bolt-fuzzer/llvm-bolt-fuzzer.cpp

extern "C" int LLVMFuzzerTestOneInput(const char *Data, size_t Size) {
   }
   Binary &Binary = *BinaryOrErr.get();
   // Check that the binary is an ELF64LE object file.
   auto *E = dyn_cast<ELF64LEObjectFile>(&Binary);
   if (!E)
     return 0;
 
   // Fuzz RewriteInstance.
-  auto RIOrErr =
-      RewriteInstance::createRewriteInstance(E, argc, argv, "llvm-bolt");
+  auto RIOrErr = RewriteInstance::create(E, argc, argv, "llvm-bolt");
   if (Error E = RIOrErr.takeError()) {
     consumeError(std::move(E));
     return 0;
   }
   RewriteInstance &RI = *RIOrErr.get();
   if (Error E = RI.run())
     consumeError(std::move(E));
   return 0;