Remove __VERSION__

[sylvestre.ledru]

Summary

It has been introduced in 2011 for gcc compat:
https://github.com/llvm-mirror/clang/commit/ad1a4c6e89594e704775ddb6b036ac982fd68cad
it is probably time to remove it

[sylvestre.ledru]

Actually, I don't think removing -dumpversion is a great idea. it will remove the capability of clang to be a dropped in replacement.

I see a lot of occurrences:
https://github.com/search?q=%22-dumpversion%22&type=Code
https://codesearch.debian.net/search?q=%22-dumpversion%22

(just in the source of Firefox, I see 6 different usage)

[rnk]

But, based on the github search, I don't think we could reasonably change dumpversion to print 8.0.0, so I'm not sure it really matters. Firefox builds with clang these days, so I'm not sure what they could possibly be using -dumpversion for that would matter.

[sylvestre.ledru]

This isn't firefox per say but thirdparty apps.
If you feel confident, sure, we can land that and see what happens :)

[sylvestre.ledru]

@rnk is it good for you ?

[rnk]

In D64062#1567175, @sylvestre.ledru wrote:

This isn't firefox per say but thirdparty apps.
If you feel confident, sure, we can land that and see what happens :)

One concern that I have is that we don't have a replacement for -dumpversion. I thought I saw someone propose adding such a flag, but I can't find it. Basically, we should do something to handle this user's use case:
http://clang-developers.42468.n3.nabble.com/How-to-dump-clang-version-td4025542.html

docs/ReleaseNotes.rst

83

Maybe "It had been introduced..." or "It was introduced..." instead.

Actually, I think it's worth taking the time to elaborate a bit. Users *will* trip over this, and it's likely that the release notes will become the canonical documentation for it.

Try this text:

- The ``-dumpversion`` flag and the ``__VERSION__`` macro have been removed.
  Previously they both produced information designed for compatibility with GCC
  4.2.1, but that should no longer be necessary. To get clang's version, use the
  `clang namespaced version macros`_ and ``--version``.

_ https://clang.llvm.org/docs/LanguageExtensions.html#builtin-macros

[sylvestre.ledru]

Update of the release note.
thanks to @rnk for the suggestion

[sylvestre.ledru]

@rnk Works for you?
I would like to land that before the 9 branch. Thanks

[rnk]

I still have this open concern:

In D64062#1574868, @rnk wrote:

One concern that I have is that we don't have a replacement for -dumpversion. I thought I saw someone propose adding such a flag, but I can't find it. Basically, we should do something to handle this user's use case:
http://clang-developers.42468.n3.nabble.com/How-to-dump-clang-version-td4025542.html

Perhaps we should just remove __VERSION__ and keep -dumpversion.

[sylvestre.ledru]

In D64062#1581290, @rnk wrote:

Perhaps we should just remove __VERSION__ and keep -dumpversion.

As you wish. clang --version seems an alternative and dumpversion never worked for clang. so, I don't expect software to use it for clang.

[rnk]

In D64062#1581662, @sylvestre.ledru wrote:

In D64062#1581290, @rnk wrote:

Perhaps we should just remove __VERSION__ and keep -dumpversion.

As you wish. clang --version seems an alternative and dumpversion never worked for clang. so, I don't expect software to use it for clang.

That's true, but users seem to want some programmatic way to extract the compiler version number without having to resort to sed & co, and we don't provide that right now. -dumpversion can easily be the name for that feature.

[sylvestre.ledru]

Keep -dumpversion

[sylvestre.ledru]

Actually remove it

[sylvestre.ledru]

@rnk Should be good this time :)

[rnk]

lgtm, minor changes

docs/ReleaseNotes.rst

91

I guess move the bullet to the generic "list of changes", since this isn't a flag or option.

94

typo "The"

95–96

"Previously this macro was set to a string aiming to achieve compatibility with GCC 4.2.1, but that should no longer be necessary. To get Clang's version..."

[sylvestre.ledru]

Thanks @rnk :)

[saugustine]

This revision breaks python 2.7.16 builds, which are still supported by upstream python for a few more months. I'm preparing a revert.

The file is getcompiler.c:

/* Return the compiler identification, if possible. */

#include "Python.h"

#ifndef COMPILER

#ifdef GNUC
#define COMPILER "\n[GCC " VERSION "]"
#endif

#endif /* !COMPILER */

#ifndef COMPILER

#ifdef __cplusplus
#define COMPILER "[C++]"
#else
#define COMPILER "[C]"
#endif

#endif /* !COMPILER */

const char *
Py_GetCompiler(void)
{

return COMPILER;

}

[saugustine]

The revert is at https://reviews.llvm.org/D64687, which I will commit shortly if there are no objections.

[sylvestre.ledru]

@rnk looks like it is too risky to remove it.
What about changing it from

#define __VERSION__ "4.2.1 Compatible Clang 7.0.1 (tags/RELEASE_701/final)"

to

#define __VERSION__ "Clang 7.0.1 (tags/RELEASE_701/final)"

Hopefully, it won't break much stuff

[saugustine]

From the failure mode I was seeing, any value at all for VERSION will be fine, as long as it is a valid preprocessor string.

It would also solve this particular problem to not define GNUC, but I as that would create other, more severe, problems, as long as clang identifies itself as GNUC, we should maintain compatibility with it.

[rnk]

In D64062#1584219, @saugustine wrote:

This revision breaks python 2.7.16 builds, which are still supported by upstream python for a few more months. I'm preparing a revert.

The file is getcompiler.c:

I just want to point out that this code was already doing the wrong thing. It will report that the compiler is some incorrect version of GCC. After we add VERSION back it will keep doing the wrong thing, which was sort of the point of removing it in the first place: to find such broken code and fix it. In any case, it sounds like it's not worth the effort, so let's just change the value of VERSION instead of removing it.

docs/ClangCommandLineReference.rst

 Filename to write DOT-formatted header dependencies to
 
 .. option:: -dependency-file <arg>
 
 Filename (or -) to write dependency output to
 
 .. option:: -dumpmachine
 
-.. option:: -dumpversion
-
 .. option:: --dyld-prefix=<arg>, --dyld-prefix <arg>
 
 .. option:: -dylib\_file <arg>
 
 .. option:: -dylinker
 
 .. program:: clang1
 .. option:: -dylinker\_install\_name<arg>

docs/LanguageExtensions.rst

 option for a warning and returns true if that is a valid warning option.
 
 .. code-block:: c++
 
   #if __has_warning("-Wformat")
   ...
   #endif
 
+.. _languageextensions-builtin-macros:
+
 Builtin Macros
 ==============
 
 ``__BASE_FILE__``
   Defined to a string that contains the name of the main input file passed to
   Clang.
 
 ``__FILE_NAME__``

docs/ReleaseNotes.rst

 The following options are deprecated and ignored. They will be removed in
 future versions of Clang.
 
 - ...
 
 Modified Compiler Flags
 -----------------------
 
-- ``clang -dumpversion`` now returns the version of Clang itself.
+- ...
+
+Removed Compiler Options
+------------------------
+
+- The ``-dumpversion`` flag and the ``__VERSION__`` macro have been removed.
+  Previously they both produced information designed for compatibility with GCC
+  4.2.1, but that should no longer be necessary. To get clang's version, use the
+  :ref:`clang namespaced version macros <languageextensions-builtin-macros>`,
+  and ``--version``.
 
 - ...
 
 New Pragmas in Clang
 --------------------
 
 - ...
 
 Attribute Changes in Clang
 --------------------------
 
 - ...
 
 Windows Support
 ---------------
 
 - clang-cl now treats non-existent files as possible typos for flags,

include/clang/Driver/Options.td

 def dependency_file : Separate<["-"], "dependency-file">, Flags<[CC1Option]>,
   HelpText<"Filename (or -) to write dependency output to">;
 def dependency_dot : Separate<["-"], "dependency-dot">, Flags<[CC1Option]>,
   HelpText<"Filename to write DOT-formatted header dependencies to">;
 def module_dependency_dir : Separate<["-"], "module-dependency-dir">,
   Flags<[CC1Option]>, HelpText<"Directory to dump module dependencies to">;
 def dumpmachine : Flag<["-"], "dumpmachine">;
 def dumpspecs : Flag<["-"], "dumpspecs">, Flags<[Unsupported]>;
-def dumpversion : Flag<["-"], "dumpversion">;
 def dylib__file : Separate<["-"], "dylib_file">;
 def dylinker__install__name : JoinedOrSeparate<["-"], "dylinker_install_name">;
 def dylinker : Flag<["-"], "dylinker">;
 def dynamiclib : Flag<["-"], "dynamiclib">;
 def dynamic : Flag<["-"], "dynamic">, Flags<[NoArgumentUnused]>;
 def d_Flag : Flag<["-"], "d">, Group<d_Group>;
 def d_Joined : Joined<["-"], "d">, Group<d_Group>;
 def emit_ast : Flag<["-"], "emit-ast">,

lib/Basic/Version.cpp

 #ifdef CLANG_VENDOR
   OS << " (based on " << BACKEND_PACKAGE_STRING << ")";
 #endif
 
   return OS.str();
 }
 
 std::string getClangFullCPPVersion() {
-  // The version string we report in __VERSION__ is just a compacted version of
-  // the one we report on the command line.
   std::string buf;
   llvm::raw_string_ostream OS(buf);
 #ifdef CLANG_VENDOR
   OS << CLANG_VENDOR;
 #endif
   OS << "Clang " CLANG_VERSION_STRING " " << getClangFullRepositoryVersion();
   return OS.str();
 }
 
 } // end namespace clang

lib/Driver/Driver.cpp

bool Driver::HandleImmediateArgs(const Compilation &C) {
   // The order these options are handled in gcc is all over the place, but we
   // don't expect inconsistencies w.r.t. that to matter in practice.
 
   if (C.getArgs().hasArg(options::OPT_dumpmachine)) {
     llvm::outs() << C.getDefaultToolChain().getTripleString() << '\n';
     return false;
   }
 
-  if (C.getArgs().hasArg(options::OPT_dumpversion)) {
-    // Since -dumpversion is only implemented for pedantic GCC compatibility, we
-    // return an answer which matches our definition of __VERSION__.
-    llvm::outs() << CLANG_VERSION_STRING << "\n";
-    return false;
-  }
-
   if (C.getArgs().hasArg(options::OPT__print_diagnostic_categories)) {
     PrintDiagnosticCategories(llvm::outs());
     return false;
   }
 
   if (C.getArgs().hasArg(options::OPT_help) ||
       C.getArgs().hasArg(options::OPT__help_hidden)) {
     PrintHelp(C.getArgs().hasArg(options::OPT__help_hidden));

lib/Frontend/InitPreprocessor.cpp

#undef TOSTR2
   Builder.defineMacro("__OPENCL_MEMORY_SCOPE_WORK_GROUP", "1");
   Builder.defineMacro("__OPENCL_MEMORY_SCOPE_DEVICE", "2");
   Builder.defineMacro("__OPENCL_MEMORY_SCOPE_ALL_SVM_DEVICES", "3");
   Builder.defineMacro("__OPENCL_MEMORY_SCOPE_SUB_GROUP", "4");
 
   // Support for #pragma redefine_extname (Sun compatibility)
   Builder.defineMacro("__PRAGMA_REDEFINE_EXTNAME", "1");
 
-  // As sad as it is, enough software depends on the __VERSION__ for version
-  // checks that it is necessary to report 4.2.1 (the base GCC version we claim
-  // compatibility with) first.
-  Builder.defineMacro("__VERSION__", "\"4.2.1 Compatible " +
-                      Twine(getClangFullCPPVersion()) + "\"");
-
   // Initialize language-specific preprocessor defines.
 
   // Standard conforming mode?
   if (!LangOpts.GNUMode && !LangOpts.MSVCCompat)
     Builder.defineMacro("__STRICT_ANSI__");
 
   if (!LangOpts.MSVCCompat && LangOpts.CPlusPlus11)
     Builder.defineMacro("__GXX_EXPERIMENTAL_CXX0X__");

test/Driver/immediate-options.c

 // RUN: %clang --help | FileCheck %s -check-prefix=HELP
 // HELP: isystem
 // HELP-NOT: ast-dump
 // HELP-NOT: driver-mode
 
 // RUN: %clang --help-hidden | FileCheck %s -check-prefix=HELP-HIDDEN
 // HELP-HIDDEN: driver-mode
 
-// RUN: %clang -dumpversion | FileCheck %s -check-prefix=DUMPVERSION
-// DUMPVERSION: {{[0-9]+\.[0-9.]+}}
-
 // RUN: %clang -print-search-dirs | FileCheck %s -check-prefix=PRINT-SEARCH-DIRS
 // PRINT-SEARCH-DIRS: programs: ={{.*}}
 // PRINT-SEARCH-DIRS: libraries: ={{.*}}
 
 // Test if the -print-resource-dir option is accepted without error.
 // Allow unspecified output because the value of CLANG_RESOURCE_DIR is unknown.
 // RUN: %clang -print-resource-dir | FileCheck %s -check-prefix=PRINT-RESOURCE-DIR
 // PRINT-RESOURCE-DIR: {{.+}}

test/Index/complete-exprs.c

 typedef int type;
 void f5(float f) {
   (type)f;
 }
 
 // RUN: c-index-test -code-completion-at=%s:7:10 -Xclang -code-completion-patterns %s | FileCheck -check-prefix=CHECK-CC1 %s
 // RUN: env CINDEXTEST_EDITING=1 CINDEXTEST_COMPLETION_CACHING=1 c-index-test -code-completion-at=%s:7:10 -Xclang -code-completion-patterns %s | FileCheck -check-prefix=CHECK-CC1 %s
 // CHECK-CC1: NotImplemented:{TypedText __PRETTY_FUNCTION__} (65)
-// CHECK-CC1: macro definition:{TypedText __VERSION__} (70)
 // CHECK-CC1: FunctionDecl:{ResultType int}{TypedText f}{LeftParen (}{Placeholder int}{RightParen )} (12) (unavailable)
 // CHECK-CC1-NOT: NotImplemented:{TypedText float} (65)
 // CHECK-CC1: ParmDecl:{ResultType int}{TypedText j} (8)
 // CHECK-CC1: NotImplemented:{ResultType size_t}{TypedText sizeof}{LeftParen (}{Placeholder expression-or-type}{RightParen )} (40)
 // RUN: env CINDEXTEST_EDITING=1 CINDEXTEST_COMPLETION_CACHING=1 c-index-test -code-completion-at=%s:7:10 -Xclang -code-completion-patterns %s | FileCheck -check-prefix=CHECK-CC1 %s
 // RUN: c-index-test -code-completion-at=%s:7:14 -Xclang -code-completion-patterns %s | FileCheck -check-prefix=CHECK-CC1 %s
 // RUN: env CINDEXTEST_EDITING=1 CINDEXTEST_COMPLETION_CACHING=1 c-index-test -code-completion-at=%s:7:14 -Xclang -code-completion-patterns %s | FileCheck -check-prefix=CHECK-CC1 %s
 
 // RUN: c-index-test -code-completion-at=%s:7:18 -Xclang -code-completion-patterns %s | FileCheck -check-prefix=CHECK-CC1 %s
 // RUN: c-index-test -code-completion-at=%s:7:22 -Xclang -code-completion-patterns %s | FileCheck -check-prefix=CHECK-CC1 %s
 // RUN: c-index-test -code-completion-at=%s:7:2 -Xclang -code-completion-patterns %s | FileCheck -check-prefix=CHECK-CC2 %s
-// CHECK-CC2: macro definition:{TypedText __VERSION__} (70)
 // CHECK-CC2: FunctionDecl:{ResultType int}{TypedText f}{LeftParen (}{Placeholder int}{RightParen )} (50)
 // CHECK-CC2: NotImplemented:{TypedText float} (50)
 // CHECK-CC2: ParmDecl:{ResultType int}{TypedText j} (34)
 // CHECK-CC2: NotImplemented:{ResultType size_t}{TypedText sizeof}{LeftParen (}{Placeholder expression-or-type}{RightParen )} (40)
 // RUN: c-index-test -code-completion-at=%s:11:16 -Xclang -code-completion-patterns %s | FileCheck -check-prefix=CHECK-CC4 %s
 // CHECK-CC4: FunctionDecl:{ResultType int}{TypedText f}{LeftParen (}{Placeholder int}{RightParen )} (50)
 // CHECK-CC4: VarDecl:{ResultType struct X}{TypedText f1} (50) (deprecated)
 

test/Preprocessor/init.c

 // COMMON:#define __GNUC_STDC_INLINE__ 1
 // COMMON:#define __GNUC__ {{.*}}
 // COMMON:#define __GXX_ABI_VERSION {{.*}}
 // COMMON:#define __ORDER_BIG_ENDIAN__ 4321
 // COMMON:#define __ORDER_LITTLE_ENDIAN__ 1234
 // COMMON:#define __ORDER_PDP_ENDIAN__ 3412
 // COMMON:#define __STDC_HOSTED__ 1
 // COMMON:#define __STDC__ 1
-// COMMON:#define __VERSION__ {{.*}}
 // COMMON:#define __clang__ 1
 // COMMON:#define __clang_major__ {{[0-9]+}}
 // COMMON:#define __clang_minor__ {{[0-9]+}}
 // COMMON:#define __clang_patchlevel__ {{[0-9]+}}
 // COMMON:#define __clang_version__ {{.*}}
 // COMMON:#define __llvm__ 1
 //
 // RUN: %clang_cc1 -E -dM -triple=x86_64-pc-win32 < /dev/null | FileCheck -match-full-lines -check-prefix C-DEFAULT %s

 // SPARC:#define __UINT_LEAST16_TYPE__ unsigned short
 // SPARC:#define __UINT_LEAST32_MAX__ 4294967295U
 // SPARC:#define __UINT_LEAST32_TYPE__ unsigned int
 // SPARC:#define __UINT_LEAST64_MAX__ 18446744073709551615ULL
 // SPARC:#define __UINT_LEAST64_TYPE__ long long unsigned int
 // SPARC:#define __UINT_LEAST8_MAX__ 255
 // SPARC:#define __UINT_LEAST8_TYPE__ unsigned char
 // SPARC:#define __USER_LABEL_PREFIX__
-// SPARC:#define __VERSION__ "4.2.1 Compatible{{.*}}
 // SPARC:#define __WCHAR_MAX__ 2147483647
 // SPARC:#define __WCHAR_TYPE__ int
 // SPARC:#define __WCHAR_WIDTH__ 32
 // SPARC:#define __WINT_TYPE__ int
 // SPARC:#define __WINT_WIDTH__ 32
 // SPARC:#define __sparc 1
 // SPARC:#define __sparc__ 1
 // SPARC:#define __sparcv8 1

 // X86_64-CLOUDABI:#define __UINT_LEAST64_TYPE__ long unsigned int
 // X86_64-CLOUDABI:#define __UINT_LEAST8_FMTX__ "hhX"
 // X86_64-CLOUDABI:#define __UINT_LEAST8_FMTo__ "hho"
 // X86_64-CLOUDABI:#define __UINT_LEAST8_FMTu__ "hhu"
 // X86_64-CLOUDABI:#define __UINT_LEAST8_FMTx__ "hhx"
 // X86_64-CLOUDABI:#define __UINT_LEAST8_MAX__ 255
 // X86_64-CLOUDABI:#define __UINT_LEAST8_TYPE__ unsigned char
 // X86_64-CLOUDABI:#define __USER_LABEL_PREFIX__
-// X86_64-CLOUDABI:#define __VERSION__ "4.2.1 Compatible{{.*}}
 // X86_64-CLOUDABI:#define __WCHAR_MAX__ 2147483647
 // X86_64-CLOUDABI:#define __WCHAR_TYPE__ int
 // X86_64-CLOUDABI:#define __WCHAR_WIDTH__ 32
 // X86_64-CLOUDABI:#define __WINT_MAX__ 2147483647
 // X86_64-CLOUDABI:#define __WINT_TYPE__ int
 // X86_64-CLOUDABI:#define __WINT_WIDTH__ 32
 // X86_64-CLOUDABI:#define __amd64 1
 // X86_64-CLOUDABI:#define __amd64__ 1

 // WEBASSEMBLY-NEXT:#define __UINT_LEAST64_TYPE__ long long unsigned int
 // WEBASSEMBLY-NEXT:#define __UINT_LEAST8_FMTX__ "hhX"
 // WEBASSEMBLY-NEXT:#define __UINT_LEAST8_FMTo__ "hho"
 // WEBASSEMBLY-NEXT:#define __UINT_LEAST8_FMTu__ "hhu"
 // WEBASSEMBLY-NEXT:#define __UINT_LEAST8_FMTx__ "hhx"
 // WEBASSEMBLY-NEXT:#define __UINT_LEAST8_MAX__ 255
 // WEBASSEMBLY-NEXT:#define __UINT_LEAST8_TYPE__ unsigned char
 // WEBASSEMBLY-NEXT:#define __USER_LABEL_PREFIX__
-// WEBASSEMBLY-NEXT:#define __VERSION__ "{{.*}}"
 // WEBASSEMBLY-NEXT:#define __WCHAR_MAX__ 2147483647
 // WEBASSEMBLY-NEXT:#define __WCHAR_TYPE__ int
 // WEBASSEMBLY-NOT:#define __WCHAR_UNSIGNED__
 // WEBASSEMBLY-NEXT:#define __WCHAR_WIDTH__ 32
 // WEBASSEMBLY-NEXT:#define __WINT_MAX__ 2147483647
 // WEBASSEMBLY-NEXT:#define __WINT_TYPE__ int
 // WEBASSEMBLY-NOT:#define __WINT_UNSIGNED__
 // WEBASSEMBLY-NEXT:#define __WINT_WIDTH__ 32

utils/builtin-defines.c

 /* Undefine things we don't expect to match. */
 #undef __DEC_EVAL_METHOD__
 #undef __INT16_TYPE__
 #undef __INT32_TYPE__
 #undef __INT64_TYPE__
 #undef __INT8_TYPE__
 #undef __SSP__
 #undef __APPLE_CC__
-#undef __VERSION__
 #undef __clang__
 #undef __llvm__
 #undef __nocona
 #undef __nocona__
 #undef __k8
 #undef __k8__
 #undef __tune_nocona__
 #undef __tune_core2__