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

This change adds '--write-if-changed' flag to llvm-elfabi tool. When
enabled, llvm-elfabi will not overwrite the existing file if the
content of the file will not be changed, which preserves the
timestamp.

Differential Revision: https://reviews.llvm.org/D92902

include/llvm/InterfaceStub/ELFObjHandler.h

@@ -16,6 +16,7 @@
 #include "llvm/InterfaceStub/ELFStub.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/ELFTypes.h"
+#include "llvm/Support/FileSystem.h"
 
 namespace llvm {
 
@@ -35,8 +36,10 @@ 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);
+                      ELFTarget OutputFormat, bool WriteIfChanged = false);
 
 } // end namespace elfabi
 } // end namespace llvm

lib/InterfaceStub/ELFObjHandler.cpp

@@ -17,6 +17,7 @@
 #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;
@@ -663,8 +664,25 @@ 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) {
+static Error writeELFBinaryToFile(StringRef FilePath, const ELFStub &Stub,
+                                  bool WriteIfChanged) {
   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)
@@ -674,13 +692,10 @@ static Error writeELFBinaryToFile(StringRef FilePath, const ELFStub &Stub) {
                                  "` for writing");
 
   // Write binary to file.
-  std::unique_ptr<FileOutputBuffer> Buf = std::move(*BufOrError);
+  std::unique_ptr<FileOutputBuffer> FileBuf = std::move(*BufOrError);
-  Builder.write(Buf->getBufferStart());
+  memcpy(FileBuf->getBufferStart(), Buf.data(), Buf.size());
 
-  if (Error E = Buf->commit())
+  return FileBuf->commit();
-    return E;
-
-  return Error::success();
 }
 
 Expected<std::unique_ptr<ELFStub>> readELFFile(MemoryBufferRef Buf) {
@@ -705,15 +720,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) {
+                      ELFTarget OutputFormat, bool WriteIfChanged) {
   if (OutputFormat == ELFTarget::ELF32LE)
-    return writeELFBinaryToFile<ELF32LE>(FilePath, Stub);
+    return writeELFBinaryToFile<ELF32LE>(FilePath, Stub, WriteIfChanged);
   if (OutputFormat == ELFTarget::ELF32BE)
-    return writeELFBinaryToFile<ELF32BE>(FilePath, Stub);
+    return writeELFBinaryToFile<ELF32BE>(FilePath, Stub, WriteIfChanged);
   if (OutputFormat == ELFTarget::ELF64LE)
-    return writeELFBinaryToFile<ELF64LE>(FilePath, Stub);
+    return writeELFBinaryToFile<ELF64LE>(FilePath, Stub, WriteIfChanged);
   if (OutputFormat == ELFTarget::ELF64BE)
-    return writeELFBinaryToFile<ELF64BE>(FilePath, Stub);
+    return writeELFBinaryToFile<ELF64BE>(FilePath, Stub, WriteIfChanged);
   llvm_unreachable("invalid binary output target");
 }
 

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

@@ -0,0 +1,19 @@
+## Test writing unchanged content to ELF Stub file with --write-if-changed flag.
+
+# RUN: llvm-elfabi %s --output-target=elf64-little %t
+# RUN: touch -m -d "1970-01-01 00:00:00" %t
+# RUN: llvm-elfabi %s --output-target=elf64-little %t --write-if-changed
+# RUN: ls -l %t | FileCheck %s
+
+--- !tapi-tbe
+TbeVersion: 1.0
+Arch: x86_64
+NeededLibs:
+  - libc.so.6
+Symbols:
+  bar: { Type: Object, Size: 42 }
+  baz: { Type: TLS, Size: 3 }
+  plus: { Type: Func }
+...
+
+# CHECK: {{[[:space:]]1970}}

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

@@ -0,0 +1,8 @@
+## Test writing unchanged content to TBE file with --write-if-changed flag.
+
+# RUN: llvm-elfabi --elf %p/Inputs/gnu_hash.so --emit-tbe=%t
+# RUN: touch -m -d "1970-01-01 00:00:00" %t
+# RUN: llvm-elfabi --elf %p/Inputs/gnu_hash.so --emit-tbe=%t --write-if-changed
+# RUN: ls -l %t | FileCheck %s
+
+# CHECK: {{[[:space:]]1970}}

tools/llvm-elfabi/llvm-elfabi.cpp

@@ -57,22 +57,37 @@ 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) {
-  std::error_code SysErr;
+  // Write TBE to memory first.
+  std::string TBEStr;
+  raw_string_ostream OutStr(TBEStr);
+  Error YAMLErr = writeTBEToOutputStream(OutStr, Stub);
+  if (YAMLErr)
+    return YAMLErr;
+  OutStr.flush();
 
-  // Open file for writing.
+  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;
   raw_fd_ostream Out(FilePath, SysErr);
   if (SysErr)
     return createStringError(SysErr, "Couldn't open `%s` for writing",
                              FilePath.data());
-  // Write file.
+  Out << TBEStr;
-  Error YAMLErr = writeTBEToOutputStream(Out, Stub);
-  if (YAMLErr)
-    return YAMLErr;
-
   return Error::success();
 }
 
@@ -153,8 +168,8 @@ int main(int argc, char *argv[]) {
     if (BinaryOutputTarget.getNumOccurrences() == 0)
       fatalError(createStringError(errc::not_supported,
                                    "no binary output target specified."));
-    Error BinaryWriteError =
+    Error BinaryWriteError = writeBinaryStub(
-        writeBinaryStub(BinaryOutputFilePath, *TargetStub, BinaryOutputTarget);
+        BinaryOutputFilePath, *TargetStub, BinaryOutputTarget, WriteIfChanged);
     if (BinaryWriteError)
       fatalError(std::move(BinaryWriteError));
   }