Let writeWindowsResourceCOFF() take a TimeStamp parameter

[thakis]

Summary

For lld, pass in Config->Timestamp (which is set based on lld's
/timestamp: and /Brepro flags). Since the writeWindowsResourceCOFF()
data is only used in-memory by LLD and the obj's timestamp isn't used
for anything in the output, this doesn't change behavior.

For llvm-cvtres, add an optional /timestamp: parameter, and use the
current behavior of calling time() if the parameter is not passed in.

This doesn't really change observable behavior (unless someone passes
/timestamp: to llvm-cvtres, which wasn't possible before), but it
removes the last unqualified call to time() from llvm/lib, which seems
like a good thing.

[hans]

lgtm

[ruiu]

LGTM

llvm/trunk/tools/llvm-cvtres/llvm-cvtres.cpp

94

Can this happen? Is this for the year 2038 problem?

[thakis]

llvm/trunk/tools/llvm-cvtres/llvm-cvtres.cpp

94

I just moved this function around so I'm not sure, but that was my guess as well.

lld/trunk/COFF/DriverUtils.cpp

for (MemoryBufferRef MB : MBs) {
     for (const auto &DupeDiag : Duplicates)
       if (Config->ForceMultipleRes)
         warn(DupeDiag);
       else
         error(DupeDiag);
   }
 
   Expected<std::unique_ptr<MemoryBuffer>> E =
-      llvm::object::writeWindowsResourceCOFF(Config->Machine, Parser);
+      llvm::object::writeWindowsResourceCOFF(Config->Machine, Parser,
+                                             Config->Timestamp);
   if (!E)
     fatal("failed to write .res to COFF: " + toString(E.takeError()));
 
   MemoryBufferRef MBRef = **E;
   make<std::unique_ptr<MemoryBuffer>>(std::move(*E)); // take ownership
   return MBRef;
 }
 

llvm/trunk/include/llvm/Object/WindowsResource.h

private:
   std::vector<std::vector<uint8_t>> Data;
   std::vector<std::vector<UTF16>> StringTable;
 
   std::vector<std::string> InputFilenames;
 };
 
 Expected<std::unique_ptr<MemoryBuffer>>
 writeWindowsResourceCOFF(llvm::COFF::MachineTypes MachineType,
-                         const WindowsResourceParser &Parser);
+                         const WindowsResourceParser &Parser,
+                         uint32_t TimeDateStamp);
 
 void printResourceTypeName(uint16_t TypeID, raw_ostream &OS);
 } // namespace object
 } // namespace llvm
 
 #endif

llvm/trunk/lib/Object/WindowsResource.cpp

uint32_t WindowsResourceParser::TreeNode::getTreeSize() const {
   }
   return Size;
 }
 
 class WindowsResourceCOFFWriter {
 public:
   WindowsResourceCOFFWriter(COFF::MachineTypes MachineType,
                             const WindowsResourceParser &Parser, Error &E);
-  std::unique_ptr<MemoryBuffer> write();
+  std::unique_ptr<MemoryBuffer> write(uint32_t TimeDateStamp);
 
 private:
   void performFileLayout();
   void performSectionOneLayout();
   void performSectionTwoLayout();
-  void writeCOFFHeader();
+  void writeCOFFHeader(uint32_t TimeDateStamp);
   void writeFirstSectionHeader();
   void writeSecondSectionHeader();
   void writeFirstSection();
   void writeSecondSection();
   void writeSymbolTable();
   void writeStringTable();
   void writeDirectoryTree();
   void writeDirectoryStringTable();
void WindowsResourceCOFFWriter::performSectionTwoLayout() {
   for (auto const &Entry : Data) {
     DataOffsets.push_back(SectionTwoSize);
     SectionTwoSize += alignTo(Entry.size(), sizeof(uint64_t));
   }
   FileSize += SectionTwoSize;
   FileSize = alignTo(FileSize, SECTION_ALIGNMENT);
 }
 
-static std::time_t getTime() {
-  std::time_t Now = time(nullptr);
-  if (Now < 0 || !isUInt<32>(Now))
-    return UINT32_MAX;
-  return Now;
-}
-
-std::unique_ptr<MemoryBuffer> WindowsResourceCOFFWriter::write() {
+std::unique_ptr<MemoryBuffer>
+WindowsResourceCOFFWriter::write(uint32_t TimeDateStamp) {
   BufferStart = OutputBuffer->getBufferStart();
 
-  writeCOFFHeader();
+  writeCOFFHeader(TimeDateStamp);
   writeFirstSectionHeader();
   writeSecondSectionHeader();
   writeFirstSection();
   writeSecondSection();
   writeSymbolTable();
   writeStringTable();
 
   return std::move(OutputBuffer);
 }
 
-void WindowsResourceCOFFWriter::writeCOFFHeader() {
+void WindowsResourceCOFFWriter::writeCOFFHeader(uint32_t TimeDateStamp) {
   // Write the COFF header.
   auto *Header = reinterpret_cast<coff_file_header *>(BufferStart);
   Header->Machine = MachineType;
   Header->NumberOfSections = 2;
-  Header->TimeDateStamp = getTime();
+  Header->TimeDateStamp = TimeDateStamp;
   Header->PointerToSymbolTable = SymbolTableOffset;
   // One symbol for every resource plus 2 for each section and @feat.00
   Header->NumberOfSymbols = Data.size() + 5;
   Header->SizeOfOptionalHeader = 0;
+  // cvtres.exe sets 32BIT_MACHINE even for 64-bit machine types. Match it.
   Header->Characteristics = COFF::IMAGE_FILE_32BIT_MACHINE;
 }
 
 void WindowsResourceCOFFWriter::writeFirstSectionHeader() {
   // Write the first section header.
   CurrentOffset += sizeof(coff_file_header);
   auto *SectionOneHeader =
       reinterpret_cast<coff_section *>(BufferStart + CurrentOffset);
default:
       llvm_unreachable("unknown machine type");
     }
     CurrentOffset += sizeof(coff_relocation);
   }
 }
 
 Expected<std::unique_ptr<MemoryBuffer>>
 writeWindowsResourceCOFF(COFF::MachineTypes MachineType,
-                         const WindowsResourceParser &Parser) {
+                         const WindowsResourceParser &Parser,
+                         uint32_t TimeDateStamp) {
   Error E = Error::success();
   WindowsResourceCOFFWriter Writer(MachineType, Parser, E);
   if (E)
     return std::move(E);
-  return Writer.write();
+  return Writer.write(TimeDateStamp);
 }
 
 } // namespace object
 } // namespace llvm

llvm/trunk/test/tools/llvm-cvtres/help.test

 ; RUN: llvm-cvtres /h > %t
 ; RUN: FileCheck -input-file=%t %s -check-prefix=HELP_TEST
 
 ; HELP_TEST:    OVERVIEW: Resource Converter
 ; HELP_TEST-DAG:  USAGE: llvm-cvtres [options] file...
 ; HELP_TEST-DAG:  OPTIONS:
 ; HELP_TEST-NEXT:   /DEFINE:symbol 
 ; HELP_TEST-NEXT:   /FOLDDUPS:     
 ; HELP_TEST-NEXT:   /MACHINE:{ARM|ARM64|EBC|IA64|X64|X86}
 ; HELP_TEST-DAG:    /NOLOGO        
 ; HELP_TEST-NEXT:   /OUT:filename  
 ; HELP_TEST-NEXT:   /READONLY      
+; HELP_TEST-NEXT:   /TIMESTAMP:<value> Timestamp for coff header, defaults to current time
 ; HELP_TEST-NEXT:   /VERBOSE

llvm/trunk/test/tools/llvm-cvtres/timestamp.test

+RUN: llvm-cvtres /timestamp:0x12345678 /out:%t %p/Inputs/test_resource.res
+RUN: llvm-readobj -h %t | FileCheck %s --check-prefix=1TO8
+
+1TO8: TimeDateStamp: 1979-09-05 22:51:36 (0x12345678)
+
+
+RUN: not llvm-cvtres /timestamp:0x123456789 /out:%t \
+RUN:     %p/Inputs/test_resource.res 2>&1 | FileCheck %s --check-prefix=ERR
+
+ERR: invalid timestamp: 0x123456789.  Expected 32-bit integer

llvm/trunk/tools/llvm-cvtres/Opts.td

 include "llvm/Option/OptParser.td"
 
 // All the switches can be preceded by either '/' or '-'.
 
 def DEFINE : Joined<["/", "-"], "DEFINE:">, HelpText<"">, MetaVarName<"symbol">;
 def FOLDDUPS : Flag<["/", "-"], "FOLDDUPS:">, HelpText<"">;
 def MACHINE : Joined<["/", "-"], "MACHINE:">, HelpText<"">, MetaVarName<"{ARM|ARM64|EBC|IA64|X64|X86}">;
 def NOLOGO : Flag<["/", "-"], "NOLOGO">, HelpText<"">;
 def OUT : Joined<["/", "-"], "OUT:">, HelpText<"">, MetaVarName<"filename">;
 def READONLY : Flag<["/", "-"], "READONLY">, HelpText<"">;
 def VERBOSE : Flag<["/", "-"], "VERBOSE">, HelpText<"">;
 def HELP : Flag<["/", "-"], "HELP">;
 def H : Flag<["/", "-"], "H">, Alias<HELP>;
 def HELP_Q : Flag<["/?", "-?"], "">, Alias<HELP>;
+
+// Extensions.
+
+def TIMESTAMP : Joined<["/", "-"], "TIMESTAMP:">,
+    HelpText<"Timestamp for coff header, defaults to current time">;

llvm/trunk/tools/llvm-cvtres/llvm-cvtres.cpp

 
 void error(Error EC) {
   if (!EC)
     return;
   handleAllErrors(std::move(EC),
                   [&](const ErrorInfoBase &EI) { reportError(EI.message()); });
 }
 
+static uint32_t getTime() {
+  std::time_t Now = time(nullptr);
+  if (Now < 0 || !isUInt<32>(Now))
+    return UINT32_MAX;
+  return static_cast<uint32_t>(Now);
+}
+
 template <typename T> T error(Expected<T> EC) {
   if (!EC)
     error(EC.takeError());
   return std::move(EC.get());
 }
 
 int main(int Argc, const char **Argv) {
   InitLLVM X(Argc, Argv);
int main(int Argc, const char **Argv) {
 
   if (InputArgs.hasArg(OPT_OUT)) {
     OutputFile = InputArgs.getLastArgValue(OPT_OUT);
   } else {
     OutputFile = sys::path::filename(StringRef(InputFiles[0]));
     sys::path::replace_extension(OutputFile, ".obj");
   }
 
+  uint32_t DateTimeStamp;
+  if (llvm::opt::Arg *Arg = InputArgs.getLastArg(OPT_TIMESTAMP)) {
+    StringRef Value(Arg->getValue());
+    if (Value.getAsInteger(0, DateTimeStamp))
+      reportError(Twine("invalid timestamp: ") + Value +
+            ".  Expected 32-bit integer\n");
+  } else {
+    DateTimeStamp = getTime();
+  }
+
   if (Verbose) {
     outs() << "Machine: ";
     switch (MachineType) {
     case COFF::IMAGE_FILE_MACHINE_ARM64:
       outs() << "ARM64\n";
       break;
     case COFF::IMAGE_FILE_MACHINE_ARMNT:
       outs() << "ARM\n";
for (const auto& DupeDiag : Duplicates)
       reportError(DupeDiag);
   }
 
   if (Verbose) {
     Parser.printTree(outs());
   }
 
   std::unique_ptr<MemoryBuffer> OutputBuffer =
-      error(llvm::object::writeWindowsResourceCOFF(MachineType, Parser));
+      error(llvm::object::writeWindowsResourceCOFF(MachineType, Parser,
+                                                   DateTimeStamp));
   auto FileOrErr =
       FileOutputBuffer::create(OutputFile, OutputBuffer->getBufferSize());
   if (!FileOrErr)
     reportError(OutputFile, errorToErrorCode(FileOrErr.takeError()));
   std::unique_ptr<FileOutputBuffer> FileBuffer = std::move(*FileOrErr);
   std::copy(OutputBuffer->getBufferStart(), OutputBuffer->getBufferEnd(),
             FileBuffer->getBufferStart());
   error(FileBuffer->commit());