Revert "[llvm-elfabi] Add flag to preserve timestamp when output is the same"

This reverts commit fddb417. which
causes test failures on Mac builders.

Author: zeroomega

llvm/include/llvm/InterfaceStub/ELFObjHandler.h

@@ -16,7 +16,6 @@
 #include "llvm/InterfaceStub/ELFStub.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/ELFTypes.h"
-#include "llvm/Support/FileSystem.h"
 
 namespace llvm {
 
@@ -36,10 +35,8 @@ Expected<std::unique_ptr<ELFStub>> readELFFile(MemoryBufferRef Buf);
 /// @param FilePath File path for writing the ELF binary.
 /// @param Stub Source ELFStub to generate a binary ELF stub from.
 /// @param OutputFormat Target ELFType to write binary as.
-/// @param WriteIfChanged Whether or not to preserve timestamp if
-///        the output stays the same.
 Error writeBinaryStub(StringRef FilePath, const ELFStub &Stub,
-                      ELFTarget OutputFormat, bool WriteIfChanged = false);
+                      ELFTarget OutputFormat);
 
 } // end namespace elfabi
 } // end namespace llvm

llvm/lib/InterfaceStub/ELFObjHandler.cpp

@@ -17,7 +17,6 @@
 #include "llvm/Support/FileOutputBuffer.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/MemoryBuffer.h"
-#include "llvm/Support/Process.h"
 
 using llvm::MemoryBufferRef;
 using llvm::object::ELFObjectFile;
@@ -664,25 +663,8 @@ buildStub(const ELFObjectFile<ELFT> &ElfObj) {
 /// @param FilePath File path for writing the ELF binary.
 /// @param Stub Source ELFStub to generate a binary ELF stub from.
 template <class ELFT>
-static Error writeELFBinaryToFile(StringRef FilePath, const ELFStub &Stub,
-                                  bool WriteIfChanged) {
+static Error writeELFBinaryToFile(StringRef FilePath, const ELFStub &Stub) {
   ELFStubBuilder<ELFT> Builder{Stub};
-  // Write Stub to memory first.
-  std::vector<uint8_t> Buf(Builder.getSize());
-  Builder.write(Buf.data());
-
-  if (WriteIfChanged) {
-    if (ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrError =
-            MemoryBuffer::getFile(FilePath)) {
-      // Compare Stub output with existing Stub file.
-      // If Stub file unchanged, abort updating.
-      if ((*BufOrError)->getBufferSize() == Builder.getSize() &&
-          !memcmp((*BufOrError)->getBufferStart(), Buf.data(),
-                  Builder.getSize()))
-        return Error::success();
-    }
-  }
-
   Expected<std::unique_ptr<FileOutputBuffer>> BufOrError =
       FileOutputBuffer::create(FilePath, Builder.getSize());
   if (!BufOrError)
@@ -692,10 +674,13 @@ static Error writeELFBinaryToFile(StringRef FilePath, const ELFStub &Stub,
                                  "` for writing");
 
   // Write binary to file.
-  std::unique_ptr<FileOutputBuffer> FileBuf = std::move(*BufOrError);
-  memcpy(FileBuf->getBufferStart(), Buf.data(), Buf.size());
+  std::unique_ptr<FileOutputBuffer> Buf = std::move(*BufOrError);
+  Builder.write(Buf->getBufferStart());
 
-  return FileBuf->commit();
+  if (Error E = Buf->commit())
+    return E;
+
+  return Error::success();
 }
 
 Expected<std::unique_ptr<ELFStub>> readELFFile(MemoryBufferRef Buf) {
@@ -720,15 +705,15 @@ Expected<std::unique_ptr<ELFStub>> readELFFile(MemoryBufferRef Buf) {
 // This function wraps the ELFT writeELFBinaryToFile() so writeBinaryStub()
 // can be called without having to use ELFType templates directly.
 Error writeBinaryStub(StringRef FilePath, const ELFStub &Stub,
-                      ELFTarget OutputFormat, bool WriteIfChanged) {
+                      ELFTarget OutputFormat) {
   if (OutputFormat == ELFTarget::ELF32LE)
-    return writeELFBinaryToFile<ELF32LE>(FilePath, Stub, WriteIfChanged);
+    return writeELFBinaryToFile<ELF32LE>(FilePath, Stub);
   if (OutputFormat == ELFTarget::ELF32BE)
-    return writeELFBinaryToFile<ELF32BE>(FilePath, Stub, WriteIfChanged);
+    return writeELFBinaryToFile<ELF32BE>(FilePath, Stub);
   if (OutputFormat == ELFTarget::ELF64LE)
-    return writeELFBinaryToFile<ELF64LE>(FilePath, Stub, WriteIfChanged);
+    return writeELFBinaryToFile<ELF64LE>(FilePath, Stub);
   if (OutputFormat == ELFTarget::ELF64BE)
-    return writeELFBinaryToFile<ELF64BE>(FilePath, Stub, WriteIfChanged);
+    return writeELFBinaryToFile<ELF64BE>(FilePath, Stub);
   llvm_unreachable("invalid binary output target");
 }
 

llvm/test/tools/llvm-elfabi/preserve-dates-stub.test

@@ -57,37 +57,22 @@ cl::opt<ELFTarget> BinaryOutputTarget(
                clEnumValN(ELFTarget::ELF64BE, "elf64-big",
                           "64-bit big-endian ELF stub")));
 cl::opt<std::string> BinaryOutputFilePath(cl::Positional, cl::desc("output"));
-cl::opt<bool> WriteIfChanged(
-    "write-if-changed",
-    cl::desc("Write the output file only if it is new or has changed."));
 
 /// writeTBE() writes a Text-Based ELF stub to a file using the latest version
 /// of the YAML parser.
 static Error writeTBE(StringRef FilePath, ELFStub &Stub) {
-  // Write TBE to memory first.
-  std::string TBEStr;
-  raw_string_ostream OutStr(TBEStr);
-  Error YAMLErr = writeTBEToOutputStream(OutStr, Stub);
-  if (YAMLErr)
-    return YAMLErr;
-  OutStr.flush();
-
-  if (WriteIfChanged) {
-    if (ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrError =
-            MemoryBuffer::getFile(FilePath)) {
-      // Compare TBE output with existing TBE file.
-      // If TBE file unchanged, abort updating.
-      if ((*BufOrError)->getBuffer() == TBEStr)
-        return Error::success();
-    }
-  }
-  // Open TBE file for writing.
   std::error_code SysErr;
+
+  // Open file for writing.
   raw_fd_ostream Out(FilePath, SysErr);
   if (SysErr)
     return createStringError(SysErr, "Couldn't open `%s` for writing",
                              FilePath.data());
-  Out << TBEStr;
+  // Write file.
+  Error YAMLErr = writeTBEToOutputStream(Out, Stub);
+  if (YAMLErr)
+    return YAMLErr;
+
   return Error::success();
 }
 
@@ -168,8 +153,8 @@ int main(int argc, char *argv[]) {
     if (BinaryOutputTarget.getNumOccurrences() == 0)
       fatalError(createStringError(errc::not_supported,
                                    "no binary output target specified."));
-    Error BinaryWriteError = writeBinaryStub(
-        BinaryOutputFilePath, *TargetStub, BinaryOutputTarget, WriteIfChanged);
+    Error BinaryWriteError =
+        writeBinaryStub(BinaryOutputFilePath, *TargetStub, BinaryOutputTarget);
     if (BinaryWriteError)
       fatalError(std::move(BinaryWriteError));
   }