openjdk-8: fix infrastructure for version host gcc != cross gcc (again)

Building OpenJDK-8 (target) with an older host compiler (gcc < 6) does
not work as the build errors with error messages regarding unrecognized
gcc command line options.

As part of the (cross) build particularly, OpenJDK-8 builds a host tool
(adlc) using the host gcc. We have a patch, openjdk8-fix-adlc-flags.patch,
that tries to make the adlc build use the correct / intended compiler
flags.

This doesn't work right now, as that build still sees compiler flags
intended for / understood by the gcc version used for the actual cross
compile only.

The reason is that while we have infrastructure in place to add compiler
flags based on the compiler version, we add all of them unconditionally to
CFLAGS / CXXFLAGS directly but above patch uses TARGET_CFLAGS /
TARGET_CXXFLAGS to  filter out unwanted BUILD_CFLAGS / BUILD_CXXFLAGS from
CFLAGS / CXXFLAGS, In other words above patch cannot do what it intends to
do and all compiler version specific flags (-fno-lifetime-dse &
-fno-delete-null-pointer-checks) end up in CFLAGS / CXXFLAGS.

So far, this was only affecting people using host gcc < 6, but upcoming
patches adding support for gcc >= 8 will add even more compiler flags that
even gcc < 7 don't support - it's time to finally address this.

We fix the issue by adding the compiler version specific flags to
BUILD_CFLAGS / BUILD_CXXFLAGS and TARGET_CFLAGS / TARGET_CXXFLAGS as
necessary, so that above patch can work as intended.

We now support all necessary combinations:
* -native builds
* -target builds
* host tools built using the native compiler during the -target build

A similar but different patch existed here before as
commit 6801f6d4e19c ("openjdk-8-common: Fix the issue of building
failed adlc on host with gcc < 6") but was reverted subsequently
due to reportedly still(?) having (new?) issues with older compilers.
This patch here is different from the older patch in that it
*doesn't* set the cflags during a python_anonymous() function, and
thus it guarantees deterministic execution order.

This change here was tested to work using host gcc versions 4.8.4 and
6.3.0 and 7.3.0

Signed-off-by: André Draszik <andre.draszik@jci.com>
Signed-off-by: Richard Leitner <richard.leitner@skidata.com>

2 files changed, 33 insertions, 25 deletions

diff --git a/recipes-core/openjdk/openjdk-8-common.inc b/recipes-core/openjdk/openjdk-8-common.inc
index ad39dee..744c062 100644
--- a/recipes-core/openjdk/openjdk-8-common.inc
+++ b/recipes-core/openjdk/openjdk-8-common.inc
@@ -224,32 +224,39 @@ FLAGS_GCC7 = "-fno-lifetime-dse -fno-delete-null-pointer-checks"
 # version is and only add the flags that are appropriate for that GCC
 # version.
 
-def version_specific_cflags(d):
-    import re
-
-    extraflags = None
-    version = None
+def get_cflags_by_cc_version(d, version):
+    if version.isdigit():
+        return d.getVar('FLAGS_GCC%d' % int(version)) or ''
+    return ''
 
-    if bb.data.inherits_class('native', d):
+def get_build_cflags(d):
+    def get_build_cc_version(build_cc):
         from subprocess import Popen, PIPE
-
-        cmd = d.expand('${CC} -dumpversion').split()
+        cmd = d.expand('%s -dumpversion' % build_cc).split()
         cc = Popen(cmd, stdout=PIPE, stderr=PIPE)
-        version = cc.communicate()[0].decode('utf-8')[0]
-    else:
-        # in the cross case, trust that GCCVERSION is correct. This won't
-        # work if the native toolchain is Clang, but as of this writing that
-        # doesn't work anyway.
-        version = d.getVar('GCCVERSION', expand=True)[0]
-        # skip non digit characters at the beginning, e.g. from "linaro-6.2%"
-        match = re.search("\d", version)
-        if match:
-            version = version[match.start():]
+        return cc.communicate()[0].decode('utf-8')[0]
 
-    if version.isdigit():
-        extraflags = d.getVar('FLAGS_GCC%d' % int(version), True) or ''
-        return extraflags
-    return ''
+    build_cc = d.getVar('BUILD_CC')
+    version = get_build_cc_version(build_cc)
+    return get_cflags_by_cc_version(d, version)
+
+def get_target_cflags(d):
+    import re
 
-CFLAGS_append = " ${@version_specific_cflags(d)}"
-CXXFLAGS_append = " ${@version_specific_cflags(d)}"
+    # in the cross case, trust that GCCVERSION is correct. This won't
+    # work if the native toolchain is Clang, but as of this writing that
+    # doesn't work anyway.
+    version = d.getVar('GCCVERSION')[0]
+    # skip non digit characters at the beginning, e.g. from "linaro-6.2%"
+    match = re.search("\d", version)
+    if match:
+        version = version[match.start():]
+    return get_cflags_by_cc_version(d, version)
+
+
+# flags for -native, and for bits that need a host-tool during -cross
+BUILD_CFLAGS_append = " ${@get_build_cflags(d)}"
+BUILD_CXXFLAGS_append = " ${@get_build_cflags(d)}"
+# flags for -cross
+TARGET_CFLAGS_append = " ${@get_target_cflags(d)}"
+TARGET_CXXFLAGS_append = " ${@get_target_cflags(d)}"
diff --git a/recipes-core/openjdk/openjdk-8-release-16xbyy.inc b/recipes-core/openjdk/openjdk-8-release-16xbyy.inc
index fd95e95..36ce073 100644
--- a/recipes-core/openjdk/openjdk-8-release-16xbyy.inc
+++ b/recipes-core/openjdk/openjdk-8-release-16xbyy.inc
@@ -54,7 +54,8 @@ ARM_INSTRUCTION_SET_armv4t = "ARM"
 
 # readdir_r was deprecated in glibc-2.24. Ignore the error for now
 # NOTE: When updating the recipe, please check if this is still needed
-CFLAGS_append = " -Wno-error=deprecated-declarations"
+BUILD_CFLAGS_append = " -Wno-error=deprecated-declarations"
+TARGET_CFLAGS_append = " -Wno-error=deprecated-declarations"
 
 # Enable zero mode for arm based builds, as normal hotspot fails to build
 PACKAGECONFIG_append_arm = " zero"