Move emscripten version macros to emscripten/version.h (#16147)

This helper make emcc more like vanilla clang.  See: #15703

Author: sbc100

ChangeLog.md

@@ -20,6 +20,12 @@ See docs/process.md for more on how version tagging works.
 
 3.1.4
 -----
+- The `__EMSCRIPTEN_major__`, `__EMSCRIPTEN_minor__` and `__EMSCRIPTEN_tiny__`
+  macros are now available via the `emscripten/version.h` header file.  For the
+  time being, unless you enable `-sSTRICT`, these are still also defined
+  directly on the command line.  If you use these macros please make sure you
+  include `emscripten/version.h` (or `emscripten.h` which indirectly includes
+  it). (#16147)
 
 3.1.3 - 31/01/2022
 ------------------

emcc.py

@@ -836,6 +836,12 @@ def get_cflags(user_args):
     # The preprocessor define EMSCRIPTEN is deprecated. Don't pass it to code
     # in strict mode. Code should use the define __EMSCRIPTEN__ instead.
     cflags.append('-DEMSCRIPTEN')
+    # The __EMSCRIPTEN_major__/__EMSCRIPTEN_minor__/__EMSCRIPTEN_tiny__ macros
+    # are now defined in emscripten/version.h but in non-strict mode, we continue
+    # to define them here (for now) for backwards compatibility.
+    cflags += ['-D__EMSCRIPTEN_major__=' + str(shared.EMSCRIPTEN_VERSION_MAJOR),
+               '-D__EMSCRIPTEN_minor__=' + str(shared.EMSCRIPTEN_VERSION_MINOR),
+               '-D__EMSCRIPTEN_tiny__=' + str(shared.EMSCRIPTEN_VERSION_TINY)]
 
   # if exception catching is disabled, we can prevent that code from being
   # generated in the frontend
@@ -873,10 +879,7 @@ def get_cflags(user_args):
 
   # Set the LIBCPP ABI version to at least 2 so that we get nicely aligned string
   # data and other nice fixes.
-  cflags += ['-D__EMSCRIPTEN_major__=' + str(shared.EMSCRIPTEN_VERSION_MAJOR),
-             '-D__EMSCRIPTEN_minor__=' + str(shared.EMSCRIPTEN_VERSION_MINOR),
-             '-D__EMSCRIPTEN_tiny__=' + str(shared.EMSCRIPTEN_VERSION_TINY),
-             '-D_LIBCPP_ABI_VERSION=2']
+  cflags += ['-D_LIBCPP_ABI_VERSION=2']
 
   if not settings.USE_PTHREADS:
     # There is no point in using thread safe static inits in code that cannot

site/source/docs/compiling/Building-Projects.rst

@@ -339,7 +339,9 @@ Detecting Emscripten in Preprocessor
 Emscripten provides the following preprocessor macros that can be used to identify the compiler version and platform:
 
  * The preprocessor define ``__EMSCRIPTEN__`` is always defined when compiling programs with Emscripten.
- * The preprocessor variables ``__EMSCRIPTEN_major__``, ``__EMSCRIPTEN_minor__`` and ``__EMSCRIPTEN_tiny__`` specify, as integers, the currently used Emscripten compiler version.
+ * The preprocessor variables ``__EMSCRIPTEN_major__``, ``__EMSCRIPTEN_minor__``
+   and ``__EMSCRIPTEN_tiny__`` are defined in ``emscripten/version.h`` and
+   specify, as integers, the currently used Emscripten compiler version.
  * Emscripten behaves like a variant of Unix, so the preprocessor defines ``unix``, ``__unix`` and ``__unix__`` are always present when compiling code with Emscripten.
  * Emscripten uses Clang/LLVM as its underlying codegen compiler, so the preprocessor defines ``__llvm__`` and ``__clang__`` are defined, and the preprocessor defines ``__clang_major__``, ``__clang_minor__`` and ``__clang_patchlevel__`` indicate the version of Clang that is used.
  * Clang/LLVM is GCC-compatible, so the preprocessor defines ``__GNUC__``, ``__GNUC_MINOR__`` and ``__GNUC_PATCHLEVEL__`` are also defined to represent the level of GCC compatibility that Clang/LLVM provides.

system/include/compat/arm_neon.h

@@ -285,6 +285,7 @@
 #  undef HEDLEY_EMSCRIPTEN_VERSION
 #endif
 #if defined(__EMSCRIPTEN__)
+#include <emscripten/version.h>
 #  define HEDLEY_EMSCRIPTEN_VERSION HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)
 #endif
 

system/include/emscripten/emscripten.h

@@ -25,6 +25,7 @@
 #include "em_types.h"
 #include "em_js.h"
 #include "wget.h"
+#include "version.h"
 
 #ifdef __cplusplus
 extern "C" {

tests/test_other.py

@@ -4407,19 +4407,20 @@ def test_readdir_r_silly(self):
   def test_emversion(self):
     create_file('src.cpp', r'''
       #include <stdio.h>
+      #include <emscripten/version.h>
       int main() {
         printf("major: %d\n", __EMSCRIPTEN_major__);
         printf("minor: %d\n", __EMSCRIPTEN_minor__);
         printf("tiny: %d\n", __EMSCRIPTEN_tiny__);
       }
     ''')
-    self.run_process([EMXX, 'src.cpp'])
     expected = '''\
 major: %d
 minor: %d
 tiny: %d
 ''' % (shared.EMSCRIPTEN_VERSION_MAJOR, shared.EMSCRIPTEN_VERSION_MINOR, shared.EMSCRIPTEN_VERSION_TINY)
-    self.assertContained(expected, self.run_js('a.out.js'))
+    self.do_runf('src.cpp', expected)
+    self.do_runf('src.cpp', expected, emcc_args=['-sSTRICT'])
 
   def test_libc_files_without_syscalls(self):
     # a program which includes FS due to libc js library support, but has no syscalls,

tools/system_libs.py

@@ -9,6 +9,7 @@
 import logging
 import os
 import shutil
+import textwrap
 from enum import IntEnum, auto
 from glob import iglob
 
@@ -1873,6 +1874,15 @@ def install_system_headers(stamp):
   cmake_dest = shared.Cache.get_sysroot_dir('lib', 'cmake')
   copytree_exist_ok(cmake_src, cmake_dest)
 
+  # Create a version header based on the emscripten-version.txt
+  version_file = os.path.join(shared.Cache.get_include_dir(), 'emscripten/version.h')
+  utils.write_file(version_file, textwrap.dedent(f'''\
+  /* Automatically generated by tools/system_libs.py */
+  #define __EMSCRIPTEN_major__ {shared.EMSCRIPTEN_VERSION_MAJOR}
+  #define __EMSCRIPTEN_minor__ {shared.EMSCRIPTEN_VERSION_MINOR}
+  #define __EMSCRIPTEN_tiny__ {shared.EMSCRIPTEN_VERSION_TINY}
+  '''))
+
   # Create a stamp file that signal the the header have been installed
   # Removing this file, or running `emcc --clear-cache` or running
   # `./embuilder build sysroot --force` will cause the re-installation of