Add a -ffixed-date-time= flag that sets the initial value of __DATE__, __TIME__, __TIMESTAMP__

[thakis]

Summary

This is useful for creating reproducible builds. Defining these via -D triggers warnings, and can cause bugs (presently, e.g. PR29119). It makes it also impossible to override DATE and TIME and forget TIMESTAMP.

TIMESTAMP has slightly different semantics in that it's the timestamp of the current TU, not the time of compilation, but either meaning is bad for reproducible builds.

[ed]

I'd be interested in seeing a feature like this appearing. Any chance this feature may be part of Clang 4.0?

[hfinkel]

In D23934#631656, @ed wrote:

I'd be interested in seeing a feature like this appearing.

I agree.

lib/Driver/Tools.cpp

4687

This seems like a fairly random place for this code. It is far removed from any other handling of preprocessor-related options.

5996

Somewhere around here would make more sense.

[emaste]

Please also accept SOURCE_DATE_EPOCH set in the environment -- see https://reproducible-builds.org/specs/source-date-epoch/

Also although I'm generally leery of options auto-detecting the argument format, I think we should be able to pass an epoch timestamp to -ffixed-date-time.

[hfinkel]

In D23934#632216, @emaste wrote:

Please also accept SOURCE_DATE_EPOCH set in the environment -- see https://reproducible-builds.org/specs/source-date-epoch/

It looks like there's reasonable adoption of this: https://wiki.debian.org/ReproducibleBuilds/TimestampsProposal#Reading_the_variable and gcc >= 7 will support it.

Also although I'm generally leery of options auto-detecting the argument format, I think we should be able to pass an epoch timestamp to -ffixed-date-time.

I'd also find this convenient. The auto-detection should be unambiguous (if it is an integer, then it is an epoch).

[emaste]

Ping?

[vsapsai]

Cannot tell for sure from code but looks like we are still emitting -Wdate-time "expansion of date or time macro is not reproducible" with this flag. At least it's not covered by tests. And another similar warning is -Wpch-date-time.

[efriedma]

lib/Frontend/CompilerInvocation.cpp

2252

Does using mktime like this depend on the local timezone?

[Alexander]

What is the status of this issue?

[Alexander]

lib/Frontend/CompilerInvocation.cpp

2252

Since the return value of mktime() is ignored here, its dependence on the local timezone should not matter. The main effect of this call is to fill in tm_isdst flag with the best guess. This may result in unexpected results if fixed-date-time is set inside the "spring forward" hour for the local timezone, but this issue is inherent in the ISO 8601 format.

[emaste]

Ping.

[appcs]

Hello, Will this feature be committed? Thanks!

[emaste]

The original author appears to have given up on it. Someone will need to rebase and work on pushing it forward

[appcs]

In D23934#3355355, @emaste wrote:

The original author appears to have given up on it. Someone will need to rebase and work on pushing it forward

Please see: https://reviews.llvm.org/D121040

[appcs]

In D23934#3314277, @appcs wrote:

Hello, Will this feature be committed? Thanks!

In D23934#3355355, @emaste wrote:

The original author appears to have given up on it. Someone will need to rebase and work on pushing it forward

Rebased. Please see: D122517

include/clang/Driver/Options.td

def finline_functions : Flag<["-"], "finline-functions">, Group<f_clang_Group>, Flags<[CC1Option]>,
   HelpText<"Inline suitable functions">;
 def finline_hint_functions: Flag<["-"], "finline-hint-functions">, Group<f_clang_Group>, Flags<[CC1Option]>,
   HelpText<"Inline functions wich are (explicitly or implicitly) marked inline">;
 def finline : Flag<["-"], "finline">, Group<clang_ignored_f_Group>;
 def finput_charset_EQ : Joined<["-"], "finput-charset=">, Group<f_Group>;
 def fexec_charset_EQ : Joined<["-"], "fexec-charset=">, Group<f_Group>;
 def finstrument_functions : Flag<["-"], "finstrument-functions">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Generate calls to instrument function entry and exit">;
+def ffixed_date_time_EQ : Joined<["-"], "ffixed-date-time=">, Group<f_Group>,
+  Flags<[CC1Option, CoreOption]>,
+  HelpText<"Set a fixed value for __DATE__, __TIME__, __TIMESTAMP__, formatted as 1969-12-31T23:59:59 (RFC3339 without fractional seconds and timezone)">;
 
 def fxray_instrument : Flag<["-"], "fxray-instrument">, Group<f_Group>,
   Flags<[CC1Option]>,
   HelpText<"Generate XRay instrumentation sleds on function entry and exit">;
 def fnoxray_instrument : Flag<["-"], "fno-xray-instrument">, Group<f_Group>,
   Flags<[CC1Option]>;
 
 def fxray_instruction_threshold_EQ :

include/clang/Lex/PreprocessorOptions.h

 //===--- PreprocessorOptions.h ----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_LEX_PREPROCESSOROPTIONS_H_
 #define LLVM_CLANG_LEX_PREPROCESSOROPTIONS_H_
 
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include <cassert>
 #include <set>
 #include <string>
+#include <ctime>
 #include <utility>
 #include <vector>
 
 namespace llvm {
   class MemoryBuffer;
 }
 
 namespace clang {
public:
   /// \brief The set of modules that failed to build.
   ///
   /// This pointer will be shared among all of the compiler instances created
   /// to (re)build modules, so that once a module fails to build anywhere,
   /// other instances will see that the module has failed and won't try to
   /// build it again.
   IntrusiveRefCntPtr<FailedModulesSet> FailedModules;
 
+  /// If set, a fixed time that __DATE__, __TIME__, __TIMESTAMP__ expand to.
+  llvm::Optional<tm> FixedDateTime;
+
 public:
   PreprocessorOptions() : UsePredefines(true), DetailedRecord(false),
                           DisablePCHValidation(false),
                           AllowPCHWithCompilerErrors(false),
                           DumpDeserializedPCHDecls(false),
                           PrecompiledPreambleBytes(0, true),
                           RemappedFilesKeepOriginalName(true),
                           RetainRemappedFileBuffers(false),

lib/Driver/Tools.cpp

#endif
   }
 
   if (Args.hasFlag(options::OPT_fdebug_types_section,
                    options::OPT_fno_debug_types_section, false)) {
     CmdArgs.push_back("-backend-option");
     CmdArgs.push_back("-generate-type-units");
   }
 
+  if (Arg *A = Args.getLastArg(options::OPT_ffixed_date_time_EQ)) {
+    StringRef DateTime = A->getValue();
+    CmdArgs.push_back(Args.MakeArgString("-ffixed-date-time=" + DateTime));
+  }
+
   // CloudABI and WebAssembly use -ffunction-sections and -fdata-sections by
   // default.
   bool UseSeparateSections = Triple.getOS() == llvm::Triple::CloudABI ||
                              Triple.getArch() == llvm::Triple::wasm32 ||
                              Triple.getArch() == llvm::Triple::wasm64;
 
   if (Args.hasFlag(options::OPT_ffunction_sections,
                    options::OPT_fno_function_sections, UseSeparateSections)) {
#endif
   // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
   if (Arg *A = Args.getLastArg(options::OPT_traditional,
                                options::OPT_traditional_cpp)) {
     if (isa<PreprocessJobAction>(JA))
       CmdArgs.push_back("-traditional-cpp");
     else
       D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
   }
 
   Args.AddLastArg(CmdArgs, options::OPT_dM);
   Args.AddLastArg(CmdArgs, options::OPT_dD);
 
   // Handle serialized diagnostics.
   if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
     CmdArgs.push_back("-serialize-diagnostic-file");
     CmdArgs.push_back(Args.MakeArgString(A->getValue()));
   }

lib/Frontend/CompilerInvocation.cpp

 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Target/TargetOptions.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include <atomic>
+#include <ctime>
 #include <memory>
 #include <sys/stat.h>
 #include <system_error>
 using namespace clang;
 
 //===----------------------------------------------------------------------===//
 // Initialization.
 //===----------------------------------------------------------------------===//
unsigned Library = llvm::StringSwitch<unsigned>(Name)
       .Case("libstdc++", ARCXX_libstdcxx)
       .Case("none", ARCXX_nolib)
       .Default(~0U);
     if (Library == ~0U)
       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
     else
       Opts.ObjCXXARCStandardLibrary = (ObjCXXARCStandardLibraryKind)Library;
   }
+
+  if (Arg *A = Args.getLastArg(OPT_ffixed_date_time_EQ)) {
+    StringRef DateTime = A->getValue();
+    tm TM = {};
+    char *Rest = strptime(DateTime.str().c_str(), "%Y-%m-%dT%T", &TM);
+    if (!Rest || *Rest)
+      Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)
+                                                << DateTime;
+    else {
+      // Fill in tm_wday.
+      TM.tm_isdst = -1;
+      mktime(&TM);
+      Opts.FixedDateTime = TM;
+    }
+  }
 }
 
 static void ParsePreprocessorOutputArgs(PreprocessorOutputOptions &Opts,
                                         ArgList &Args,
                                         frontend::ActionKind Action) {
   using namespace options;
 
   switch (Action) {

lib/Lex/PPMacroExpansion.cpp

 #include "clang/Basic/TargetInfo.h"
 #include "clang/Lex/CodeCompletionHandler.h"
 #include "clang/Lex/DirectoryLookup.h"
 #include "clang/Lex/ExternalPreprocessorSource.h"
 #include "clang/Lex/LexDiagnostic.h"
 #include "clang/Lex/MacroArgs.h"
 #include "clang/Lex/MacroInfo.h"
 #include "clang/Lex/Preprocessor.h"
+#include "clang/Lex/PreprocessorOptions.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdio>
void Preprocessor::removeCachedMacroExpandedTokensOfLastLexer() {
   MacroExpandingLexersStack.pop_back();
 }
 
 /// ComputeDATE_TIME - Compute the current time, enter it into the specified
 /// scratch buffer, then return DATELoc/TIMELoc locations with the position of
 /// the identifier tokens inserted.
 static void ComputeDATE_TIME(SourceLocation &DATELoc, SourceLocation &TIMELoc,
                              Preprocessor &PP) {
+  struct tm *TM;
+  PreprocessorOptions &PO = PP.getPreprocessorOpts();
+  if (PO.FixedDateTime.hasValue())
+    TM = PO.FixedDateTime.getPointer();
+  else {
     time_t TT = time(nullptr);
-  struct tm *TM = localtime(&TT);
+    TM = localtime(&TT);
+  }
 
   static const char * const Months[] = {
     "Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"
   };
 
   {
     SmallString<32> TmpBuffer;
     llvm::raw_svector_ostream TmpStream(TmpBuffer);
if (II == Ident__LINE__) {
     // __INCLUDE_LEVEL__ expands to a simple numeric value.
     OS << Depth;
     Tok.setKind(tok::numeric_constant);
   } else if (II == Ident__TIMESTAMP__) {
     Diag(Tok.getLocation(), diag::warn_pp_date_time);
     // MSVC, ICC, GCC, VisualAge C++ extension.  The generated string should be
     // of the form "Ddd Mmm dd hh::mm::ss yyyy", which is returned by asctime.
 
+    const char *Result;
+    PreprocessorOptions &PO = getPreprocessorOpts();
+    if (PO.FixedDateTime.hasValue()) {
+      Result = asctime(PO.FixedDateTime.getPointer());
+    } else {
       // Get the file that we are lexing out of.  If we're currently lexing from
       // a macro, dig into the include stack.
       const FileEntry *CurFile = nullptr;
       PreprocessorLexer *TheLexer = getCurrentFileLexer();
 
       if (TheLexer)
         CurFile = SourceMgr.getFileEntryForID(TheLexer->getFileID());
 
-    const char *Result;
       if (CurFile) {
         time_t TT = CurFile->getModificationTime();
         struct tm *TM = localtime(&TT);
         Result = asctime(TM);
       } else {
         Result = "??? ??? ?? ??:??:?? ????\n";
       }
+    }
     // Surround the string with " and strip the trailing newline.
     OS << '"' << StringRef(Result).drop_back() << '"';
     Tok.setKind(tok::string_literal);
   } else if (II == Ident__COUNTER__) {
     // __COUNTER__ expands to a simple numeric value.
     OS << CounterValue++;
     Tok.setKind(tok::numeric_constant);
   } else if (II == Ident__has_feature) {

test/Preprocessor/fixed-date-time.cc

+// RUN: %clang_cc1 -ffixed-date-time=2008-09-02T14:30:27 -std=c++11 %s -verify
+// RUN: not %clang_cc1 -ffixed-date-time=2008-09-02T14:30:27asdf -std=c++11 %s 2>&1 | FileCheck %s
+// expected-no-diagnostics
+
+// CHECK: error: invalid value '2008-09-02T14:30:27asdf' in '-ffixed-date-time=2008-09-02T14:30:27asdf'
+
+constexpr int constexpr_strcmp(const char *p, const char *q) {
+  return *p != *q ? *p - *q : !*p ? 0 : constexpr_strcmp(p + 1, q + 1);
+}
+
+static_assert(!constexpr_strcmp(__DATE__, "Sep  2 2008"), "");
+static_assert(!constexpr_strcmp(__TIME__, "14:30:27"), "");
+static_assert(!constexpr_strcmp(__TIMESTAMP__, "Tue Sep  2 14:30:27 2008"), "");