Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package java-1_8_0-openj9 for openSUSE:Factory checked in at 2026-08-09 21:34:19 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/java-1_8_0-openj9 (Old) and /work/SRC/openSUSE:Factory/.java-1_8_0-openj9.new.16738 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "java-1_8_0-openj9" Sun Aug 9 21:34:19 2026 rev:41 rq:1370100 version:1.8.0.502 Changes: -------- --- /work/SRC/openSUSE:Factory/java-1_8_0-openj9/java-1_8_0-openj9.changes 2026-06-05 14:59:09.917490343 +0200 +++ /work/SRC/openSUSE:Factory/.java-1_8_0-openj9.new.16738/java-1_8_0-openj9.changes 2026-08-09 21:36:32.252689999 +0200 @@ -1,0 +2,43 @@ +Thu Aug 6 15:55:16 UTC 2026 - Bernhard Wiedemann <[email protected]> + +- Add patches for reproducible builds: + * java-40y.patch + * reproducible-nls.patch + * reproducible-tracemerge-order.patch + * reproducible-generatecharacter.patch + * reproducible-generated-timestamps.patch + * reproducible-tzdb-order.patch + * javadoc-linkoffline-order.patch + * reproducible-generated-source-dates.patch + * javadoc-classuse-order.patch +- Use strip-nondeterminism to normalize jar mtimes + +------------------------------------------------------------------- +Thu Aug 6 05:54:36 UTC 2026 - Fridrich Strba <[email protected]> + +- Update to OpenJDK 8u502 build 07 with OpenJ9 0.60.0 virtual + machine +- Including Oracle July 2026 CPU changes + * CVE-2026-46968 (bsc#1272224), CVE-2026-47010 (bsc#1272225), + CVE-2026-47021 (bsc#1272227), CVE-2026-47027 (bsc#1272228), + CVE-2026-60147 (bsc#1272237), CVE-2026-47059 (bsc#1272235), + CVE-2026-47063 (bsc#1272236), CVE-2026-47057 (bsc#1272233), + CVE-2026-47058 (bsc#1272234), CVE-2026-41254 (bsc#1272459) +- OpenJ9 specific security fixes + * CVE-2026-16439 (bsc#1272250) + * CVE-2026-16441 (bsc#1272248) + * OpenJ9 changes, see + https://www.eclipse.org/openj9/docs/version0.60/ +- Modified patch: + * openj9-openssl.patch + + rebase +- Added patches: + * omr-gcc16.patch + + remove inlining annotation that compiler cannot honour + and that is fatal with gcc16 + * openj9-gcc16.patch + + add memory barrier between zeroing a memory by memset and + constructing an object into it, since gcc16 was optimizing + out the zeroing and OpenJ9 VM heavily relies on it + +------------------------------------------------------------------- Old: ---- 0a800bff022b59d6f7e9da4afe99d212f0654c6c.zip 6426f03fa087b257a7e58f363ef61526c896fea3.zip c53b6b93f422b77b3395a3464d5578b706e9a618.zip New: ---- 2e3166f7afc61f577ccaa63b85444b63b82491f7.zip 396c827fb365c53b26586f55ec09d4727b37d9be.zip f2b70d560f68e4c66e046b713fd78c58bbecc402.zip java-40y.patch javadoc-classuse-order.patch javadoc-linkoffline-order.patch omr-gcc16.patch openj9-gcc16.patch reproducible-generatecharacter.patch reproducible-generated-source-dates.patch reproducible-generated-timestamps.patch reproducible-nls.patch reproducible-tracemerge-order.patch reproducible-tzdb-order.patch ----------(New B)---------- New:- Add patches for reproducible builds: * java-40y.patch * reproducible-nls.patch New: * reproducible-generated-source-dates.patch * javadoc-classuse-order.patch - Use strip-nondeterminism to normalize jar mtimes New: * reproducible-tzdb-order.patch * javadoc-linkoffline-order.patch * reproducible-generated-source-dates.patch New:- Added patches: * omr-gcc16.patch + remove inlining annotation that compiler cannot honour New: and that is fatal with gcc16 * openj9-gcc16.patch + add memory barrier between zeroing a memory by memset and New: * reproducible-tracemerge-order.patch * reproducible-generatecharacter.patch * reproducible-generated-timestamps.patch New: * javadoc-linkoffline-order.patch * reproducible-generated-source-dates.patch * javadoc-classuse-order.patch New: * reproducible-generatecharacter.patch * reproducible-generated-timestamps.patch * reproducible-tzdb-order.patch New: * java-40y.patch * reproducible-nls.patch * reproducible-tracemerge-order.patch New: * reproducible-nls.patch * reproducible-tracemerge-order.patch * reproducible-generatecharacter.patch New: * reproducible-generated-timestamps.patch * reproducible-tzdb-order.patch * javadoc-linkoffline-order.patch ----------(New E)---------- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ java-1_8_0-openj9.spec ++++++ --- /var/tmp/diff_new_pack.GD3IW5/_old 2026-08-09 21:36:34.152754696 +0200 +++ /var/tmp/diff_new_pack.GD3IW5/_new 2026-08-09 21:36:34.152754696 +0200 @@ -32,22 +32,22 @@ %global abs2rel perl -e %{script} %global syslibdir %{_libdir} # Standard JPackage naming and versioning defines. -%global updatever 492 -%global buildver b09 +%global updatever 502 +%global buildver b07 %global root_repository https://github.com/ibmruntimes/openj9-openjdk-jdk8/archive -%global root_revision 0a800bff022b59d6f7e9da4afe99d212f0654c6c -%global root_branch v0.59.0-release -%global omr_repository https://github.com/eclipse/openj9-omr/archive -%global omr_revision 6426f03fa087b257a7e58f363ef61526c896fea3 -%global omr_branch v0.59.0-release -%global openj9_repository https://github.com/eclipse/openj9/archive -%global openj9_revision c53b6b93f422b77b3395a3464d5578b706e9a618 -%global openj9_branch v0.59.0-release -%global openj9_tag openj9-0.59.0 +%global root_revision f2b70d560f68e4c66e046b713fd78c58bbecc402 +%global root_branch v0.60.0-release +%global omr_repository https://github.com/eclipse-openj9/openj9-omr/archive +%global omr_revision 2e3166f7afc61f577ccaa63b85444b63b82491f7 +%global omr_branch v0.60.0-release +%global openj9_repository https://github.com/eclipse-openj9/openj9/archive +%global openj9_revision 396c827fb365c53b26586f55ec09d4727b37d9be +%global openj9_branch v0.60.0-release +%global openj9_tag openj9-0.60.0 # priority must be 6 digits in total %global priority 1801 %global featurever 8 -%global javaver 1.8.0 +%global javaver 1.%{featurever}.0 %if 0%{?suse_version} > 1500 %bcond_without libalternatives %else @@ -123,6 +123,22 @@ # Disable doclint for compatibility Patch3: disable-doclint-by-default.patch Patch4: reproducible-version.patch +# Fixes for build with gcc 16 +Patch6: omr-gcc16.patch +Patch7: openj9-gcc16.patch +# Fixes for reproducible builds +Patch8: java-40y.patch +Patch9: reproducible-generatecharacter.patch +Patch10: reproducible-tzdb-order.patch +Patch11: javadoc-linkoffline-order.patch +# Use SOURCE_DATE_EPOCH for the dates the CLDR converter and +# EquivMapsGenerator write into the sources they generate +Patch12: reproducible-generated-source-dates.patch +# Drop build timestamps from generated javadoc and CORBA sources +Patch13: reproducible-generated-timestamps.patch +Patch14: javadoc-classuse-order.patch +Patch15: reproducible-nls.patch +Patch16: reproducible-tracemerge-order.patch # Patches for system libraries Patch201: system-libjpeg.patch Patch202: system-libpng.patch @@ -160,6 +176,9 @@ BuildRequires: nasm >= 2.11 BuildRequires: openssl-devel BuildRequires: pkgconfig +%if 0%{?suse_version} >= 1500 +BuildRequires: strip-nondeterminism +%endif BuildRequires: unzip BuildRequires: xorg-x11-proto-devel BuildRequires: zip @@ -365,6 +384,17 @@ %patch -P 2 -p1 %patch -P 3 -p1 %patch -P 4 -p1 +%patch -P 6 -p1 +%patch -P 7 -p1 +%patch -P 8 -p1 +%patch -P 9 -p1 +%patch -P 10 -p1 +%patch -P 11 -p1 +%patch -P 12 -p1 +%patch -P 13 -p1 +%patch -P 14 -p1 +%patch -P 15 -p1 +%patch -P 16 -p1 cat %{SOURCE100} \ | sed "s/@OPENJ9_SHA@/`expr substr '%{openj9_revision}' 1 7`/g" \ @@ -435,7 +465,8 @@ --with-lcms=system \ --with-openssl=system \ --with-stdc++lib=dynamic \ - --with-native-debug-symbols=internal + --with-native-debug-symbols=internal \ + --with-copyright-year="$(date -u -d "@${SOURCE_DATE_EPOCH:-$(date +%%s)}" +%%Y)" %{make} \ JAVAC_FLAGS=-g \ @@ -649,6 +680,13 @@ echo "" >> accessibility.properties popd +%if 0%?have_strip_nondeterminism > 0 +strip-all-nondeterminism %{buildroot}/%{_jvmdir} +# ct.sym is a jar, but strip-all-nondeterminism only looks at *.jar, *.zip and +# a few other suffixes, so it has to be normalised by name. +strip-nondeterminism --type zip --timestamp=${SOURCE_DATE_EPOCH:-1494270000} \ + --clamp-timestamp %{buildroot}%{_jvmdir}/%{sdkdir}/lib/ct.sym +%endif # fdupes links the files from JDK to JRE, so it breaks a JRE # use it carefully :)) %fdupes -s %{buildroot}/%{_jvmdir}/%{jredir}/ ++++++ 0a800bff022b59d6f7e9da4afe99d212f0654c6c.zip -> 2e3166f7afc61f577ccaa63b85444b63b82491f7.zip ++++++ /work/SRC/openSUSE:Factory/java-1_8_0-openj9/0a800bff022b59d6f7e9da4afe99d212f0654c6c.zip /work/SRC/openSUSE:Factory/.java-1_8_0-openj9.new.16738/2e3166f7afc61f577ccaa63b85444b63b82491f7.zip differ: char 11, line 2 ++++++ 0a800bff022b59d6f7e9da4afe99d212f0654c6c.zip -> 396c827fb365c53b26586f55ec09d4727b37d9be.zip ++++++ /work/SRC/openSUSE:Factory/java-1_8_0-openj9/0a800bff022b59d6f7e9da4afe99d212f0654c6c.zip /work/SRC/openSUSE:Factory/.java-1_8_0-openj9.new.16738/396c827fb365c53b26586f55ec09d4727b37d9be.zip differ: char 11, line 2 ++++++ 0a800bff022b59d6f7e9da4afe99d212f0654c6c.zip -> f2b70d560f68e4c66e046b713fd78c58bbecc402.zip ++++++ /work/SRC/openSUSE:Factory/java-1_8_0-openj9/0a800bff022b59d6f7e9da4afe99d212f0654c6c.zip /work/SRC/openSUSE:Factory/.java-1_8_0-openj9.new.16738/f2b70d560f68e4c66e046b713fd78c58bbecc402.zip differ: char 11, line 2 ++++++ java-40y.patch ++++++ diff --git a/jdk/make/src/classes/build/tools/generatecurrencydata/GenerateCurrencyData.java b/jdk/make/src/classes/build/tools/generatecurrencydata/GenerateCurrencyData.java index d599d974..b544701f 100644 --- a/jdk/make/src/classes/build/tools/generatecurrencydata/GenerateCurrencyData.java +++ b/jdk/make/src/classes/build/tools/generatecurrencydata/GenerateCurrencyData.java @@ -283,8 +283,8 @@ public class GenerateCurrencyData { checkCurrencyCode(newCurrency); String timeString = currencyInfo.substring(4, length - 4); long time = format.parse(timeString).getTime(); - if (Math.abs(time - System.currentTimeMillis()) > ((long) 10) * 365 * 24 * 60 * 60 * 1000) { - throw new RuntimeException("time is more than 10 years from present: " + time); + if (Math.abs(time - System.currentTimeMillis()) > ((long) 40) * 365 * 24 * 60 * 60 * 1000) { + throw new RuntimeException("time is more than 40 years from present: " + time); } specialCaseCutOverTimes[specialCaseCount] = time; specialCaseOldCurrencies[specialCaseCount] = oldCurrency; ++++++ javadoc-classuse-order.patch ++++++ From: Bernhard M. Wiedemann <[email protected]> Subject: Sort class-use table entries deterministically The lists behind the "Methods in ... that return/with parameters of type ..." tables on class-use pages are collected in the order javadoc processed the classes and then sorted via Doc.compareTo, which only collates the member name plus, for executable members, the signature. Identically named members of different classes - e.g. get_val() of the seven org.omg.DynamicAny._Dyn*Stub classes generated by idlj - compare equal, so the stable sort keeps them in class processing order and the generated HTML varies between builds. Break ties on the fully qualified member name. Current javadoc versions already do this: their class-use comparator falls back to comparing the fully qualified names. Signed-off-by: Bernhard M. Wiedemann <[email protected]> --- a/langtools/src/share/classes/com/sun/tools/doclets/formats/html/ClassUseWriter.java +++ b/langtools/src/share/classes/com/sun/tools/doclets/formats/html/ClassUseWriter.java @@ -28,6 +28,7 @@ import java.io.IOException; import java.util.ArrayList; import java.util.Collections; +import java.util.Comparator; import java.util.HashMap; import java.util.Iterator; import java.util.List; @@ -182,7 +183,18 @@ Map<String,List<ProgramElementDoc>> map = new HashMap<String,List<ProgramElementDoc>>(); List<? extends ProgramElementDoc> list= classMap.get(classdoc.qualifiedName()); if (list != null) { - Collections.sort(list); + // Doc.compareTo only collates the name (plus the signature for + // executable members), so identically named members of different + // classes would stay in the order their classes were processed. + Collections.sort(list, new Comparator<ProgramElementDoc>() { + public int compare(ProgramElementDoc d1, ProgramElementDoc d2) { + int result = d1.compareTo(d2); + if (result != 0) { + return result; + } + return d1.qualifiedName().compareTo(d2.qualifiedName()); + } + }); Iterator<? extends ProgramElementDoc> it = list.iterator(); while (it.hasNext()) { ProgramElementDoc doc = it.next(); ++++++ javadoc-linkoffline-order.patch ++++++ From: Bernhard M. Wiedemann <[email protected]> Subject: Order OpenJ9 javadoc after the core API javadoc The openj9-only-* javadoc targets depend on OPENJ9_JAVADOC_MARKER, whose stated purpose is to make sure the core API javadoc - and with it the package-list file consumed by their -linkoffline options - is generated first. The corresponding non-"only" targets pass the same -linkoffline $(COREAPI_DOCSDIR)/ but carry no such dependency, so under parallel make they can run before package-list exists. javadoc then silently drops the external references, and whether e.g. java.lang.String renders as a link or as plain text in the platform docs depends on build scheduling. Add the core API index file as a prerequisite of those eight targets. The MGMT target gets the index file rather than the marker because the marker itself depends on OPENJ9_MGMT_INDEXALL_FILE, which would form a dependency cycle. Signed-off-by: Bernhard M. Wiedemann <[email protected]> diff --git a/closed/make/Javadoc.gmk b/closed/make/Javadoc.gmk index f26b1893..3ae3d4d5 100644 --- a/closed/make/Javadoc.gmk +++ b/closed/make/Javadoc.gmk @@ -88,7 +88,7 @@ openj9-sharedclassesdocs : $(OPENJ9_SHAREDCLASSES_INDEX_FILE) $(OPENJ9_SHAREDCLASSES_INDEX_FILE): GET2DOCSDIR := $(PLATFORM_DOCSDIR)/.. # Run javadoc if the index file is out of date or missing -$(OPENJ9_SHAREDCLASSES_INDEX_FILE) : $(OPENJ9_SHAREDCLASSES_OPTIONS_FILE) $(OPENJ9_SHAREDCLASSES_PACKAGES_FILE) +$(OPENJ9_SHAREDCLASSES_INDEX_FILE) : $(COREAPI_DOCSDIR)/index.html $(OPENJ9_SHAREDCLASSES_OPTIONS_FILE) $(OPENJ9_SHAREDCLASSES_PACKAGES_FILE) $(prep-javadoc) $(call JavadocSummary,$(OPENJ9_SHAREDCLASSES_OPTIONS_FILE),$(OPENJ9_SHAREDCLASSES_PACKAGES_FILE)) $(JAVADOC_CMD) -d $(@D) \ @@ -138,7 +138,7 @@ openj9-gpudocs: $(OPENJ9_GPU_INDEX_FILE) $(OPENJ9_GPU_INDEX_FILE) : GET2DOCSDIR := $(PLATFORM_DOCSDIR)/.. # Run javadoc if the index file is out of date or missing -$(OPENJ9_GPU_INDEX_FILE) : $(OPENJ9_GPU_OPTIONS_FILE) $(OPENJ9_GPU_PACKAGES_FILE) +$(OPENJ9_GPU_INDEX_FILE) : $(COREAPI_DOCSDIR)/index.html $(OPENJ9_GPU_OPTIONS_FILE) $(OPENJ9_GPU_PACKAGES_FILE) $(prep-javadoc) $(call JavadocSummary,$(OPENJ9_GPU_OPTIONS_FILE),$(OPENJ9_GPU_PACKAGES_FILE)) $(JAVADOC_CMD) -d $(@D) \ @@ -188,7 +188,7 @@ openj9-cudadocs : $(OPENJ9_CUDA_INDEX_FILE) $(OPENJ9_CUDA_INDEX_FILE) : GET2DOCSDIR := $(PLATFORM_DOCSDIR)/.. # Run javadoc if the index file is out of date or missing -$(OPENJ9_CUDA_INDEX_FILE) : $(OPENJ9_CUDA_OPTIONS_FILE) $(OPENJ9_CUDA_PACKAGES_FILE) +$(OPENJ9_CUDA_INDEX_FILE) : $(COREAPI_DOCSDIR)/index.html $(OPENJ9_CUDA_OPTIONS_FILE) $(OPENJ9_CUDA_PACKAGES_FILE) $(prep-javadoc) $(call JavadocSummary,$(OPENJ9_CUDA_OPTIONS_FILE),$(OPENJ9_CUDA_PACKAGES_FILE)) $(JAVADOC_CMD) -d $(@D) \ @@ -238,7 +238,7 @@ openj9-dataaccessdocs : $(OPENJ9_DATAACCESS_INDEX_FILE) $(OPENJ9_DATAACCESS_INDEX_FILE) : GET2DOCSDIR := $(PLATFORM_DOCSDIR)/.. # Run javadoc if the index file is out of date or missing -$(OPENJ9_DATAACCESS_INDEX_FILE) : $(OPENJ9_DATAACCESS_OPTIONS_FILE) $(OPENJ9_DATAACCESS_PACKAGES_FILE) +$(OPENJ9_DATAACCESS_INDEX_FILE) : $(COREAPI_DOCSDIR)/index.html $(OPENJ9_DATAACCESS_OPTIONS_FILE) $(OPENJ9_DATAACCESS_PACKAGES_FILE) $(prep-javadoc) $(call JavadocSummary,$(OPENJ9_DATAACCESS_OPTIONS_FILE),$(OPENJ9_DATAACCESS_PACKAGES_FILE)) $(JAVADOC_CMD) -d $(@D) \ @@ -288,7 +288,7 @@ openj9-jvmdocs : $(OPENJ9_JVM_INDEX_FILE) $(OPENJ9_JVM_INDEX_FILE) : GET2DOCSDIR := $(PLATFORM_DOCSDIR)/.. # Run javadoc if the index file is out of date or missing -$(OPENJ9_JVM_INDEX_FILE) : $(OPENJ9_JVM_OPTIONS_FILE) $(OPENJ9_JVM_PACKAGES_FILE) +$(OPENJ9_JVM_INDEX_FILE) : $(COREAPI_DOCSDIR)/index.html $(OPENJ9_JVM_OPTIONS_FILE) $(OPENJ9_JVM_PACKAGES_FILE) $(prep-javadoc) $(call JavadocSummary,$(OPENJ9_JVM_OPTIONS_FILE),$(OPENJ9_JVM_PACKAGES_FILE)) $(JAVADOC_CMD) -d $(@D) \ @@ -339,7 +339,7 @@ openj9-dtfjdocs : $(OPENJ9_DTFJ_INDEX_FILE) $(OPENJ9_DTFJ_INDEX_FILE) : GET2DOCSDIR := $(PLATFORM_DOCSDIR)/.. # Run javadoc if the index file is out of date or missing -$(OPENJ9_DTFJ_INDEX_FILE) : $(OPENJ9_DTFJ_OPTIONS_FILE) $(OPENJ9_DTFJ_PACKAGES_FILE) +$(OPENJ9_DTFJ_INDEX_FILE) : $(COREAPI_DOCSDIR)/index.html $(OPENJ9_DTFJ_OPTIONS_FILE) $(OPENJ9_DTFJ_PACKAGES_FILE) $(prep-javadoc) $(call JavadocSummary,$(OPENJ9_DTFJ_OPTIONS_FILE),$(OPENJ9_DTFJ_PACKAGES_FILE)) $(JAVADOC_CMD) -d $(@D) \ @@ -390,7 +390,7 @@ openj9-zosconditionhandlingdocs : $(OPENJ9_ZOSCONDITIONHANDLING_INDEX_FILE) $(OPENJ9_ZOSCONDITIONHANDLING_INDEX_FILE) : GET2DOCSDIR := $(PLATFORM_DOCSDIR)/.. # Run javadoc if the index file is out of date or missing -$(OPENJ9_ZOSCONDITIONHANDLING_INDEX_FILE) : $(OPENJ9_ZOSCONDITIONHANDLING_OPTIONS_FILE) $(OPENJ9_ZOSCONDITIONHANDLING_PACKAGES_FILE) +$(OPENJ9_ZOSCONDITIONHANDLING_INDEX_FILE) : $(COREAPI_DOCSDIR)/index.html $(OPENJ9_ZOSCONDITIONHANDLING_OPTIONS_FILE) $(OPENJ9_ZOSCONDITIONHANDLING_PACKAGES_FILE) $(prep-javadoc) $(call JavadocSummary,$(OPENJ9_ZOSCONDITIONHANDLING_OPTIONS_FILE),$(OPENJ9_ZOSCONDITIONHANDLING_PACKAGES_FILE)) $(JAVADOC_CMD) -d $(@D) \ @@ -470,7 +470,7 @@ OPENJ9_MGMT_SRCPATH := $(OPENJ9_DOCS_SRCDIR)$(PATH_SEP)$(TEMP_SUN_MGMT_PKGDIR) # The dependency on the index.html file ensures this javadoc # generation will replace the openjdk javadoc generation. $(OPENJ9_MGMT_INDEXALL_FILE) : FIRST_COPYRIGHT_YEAR := $(OPENJ9_MGMT_FIRST_COPYRIGHT_YEAR) -$(OPENJ9_MGMT_INDEXALL_FILE) : $(OPENJ9_MGMT_INDEX_FILE) $(OPENJ9_MGMT_OPTIONS_FILE) $(OPENJ9_MGMT_PACKAGES_FILE) +$(OPENJ9_MGMT_INDEXALL_FILE) : $(COREAPI_DOCSDIR)/index.html $(OPENJ9_MGMT_INDEX_FILE) $(OPENJ9_MGMT_OPTIONS_FILE) $(OPENJ9_MGMT_PACKAGES_FILE) $(MKDIR) -p $(TEMP_SUN_MGMT_SRCDIR) $(CP) $(SUN_MGMT_SRCDIR)/GarbageCollectorMXBean.java $(TEMP_SUN_MGMT_SRCDIR) $(CP) $(SUN_MGMT_SRCDIR)/OperatingSystemMXBean.java $(TEMP_SUN_MGMT_SRCDIR) ++++++ omr-gcc16.patch ++++++ --- a/omr/gc/base/MemorySubSpaceGenerational.hpp +++ b/omr/gc/base/MemorySubSpaceGenerational.hpp @@ -107,7 +107,7 @@ class MM_MemorySubSpaceGenerational : public MM_MemorySubSpace virtual uintptr_t releaseFreeMemoryPages(MM_EnvironmentBase* env, uintptr_t memoryType); - virtual MMINLINE uintptr_t getContractionSize() const { return _memorySubSpaceOld->getContractionSize(); } + virtual uintptr_t getContractionSize() const { return _memorySubSpaceOld->getContractionSize(); } /** * Create a MemorySubSpaceGenerational object. ++++++ openj9-gcc16.patch ++++++ --- a/openj9/runtime/compiler/control/CompilationThread.cpp +++ b/openj9/runtime/compiler/control/CompilationThread.cpp @@ -778,6 +778,7 @@ bool TR::CompilationInfo::createCompilationInfo(J9JITConfig *jitConfig) /* Note: there are embedded objects in TR::CompilationInfo that rely on the fact that we do memset this object to 0 */ memset(alloc, 0, sizeof(TR::CompilationInfo)); + __asm__("" : : : "memory"); _compilationRuntime = new (alloc) TR::CompilationInfo(jitConfig); jitConfig->compilationRuntime = (void *)_compilationRuntime; #ifdef DEBUG ++++++ openj9-openssl.patch ++++++ --- /var/tmp/diff_new_pack.GD3IW5/_old 2026-08-09 21:36:34.408763413 +0200 +++ /var/tmp/diff_new_pack.GD3IW5/_new 2026-08-09 21:36:34.412763550 +0200 @@ -8,7 +8,7 @@ +#define SSL_R_UNEXPECTED_EOF_WHILE_READING 294 +#endif + - static bool - handleOpenSSLConnectionError(int connfd, SSL *&ssl, BIO *&bio, const char *errMsg, int ret, TR::CompilationInfo *compInfo) - { + static bool handleOpenSSLConnectionError(int connfd, SSL *&ssl, BIO *&bio, const char *errMsg, int ret, + TR::CompilationInfo *compInfo) + { ++++++ reproducible-generatecharacter.patch ++++++ From: Magnus Ihse Bursie <[email protected]> Subject: 8243985: Make source generation by generatecharacter reproducible Backported from upstream OpenJDK commit 09e8b7ca4d614ed05a22e0544b17c68b5c7b00db, which postdates this jdk8 branch point. GenerateCharacter embedded the current wall-clock time in every generated source file's header comment, so the CharacterData*.java shipped in src.zip differed between otherwise identical builds. --- a/jdk/make/src/classes/build/tools/generatecharacter/GenerateCharacter.java +++ b/jdk/make/src/classes/build/tools/generatecharacter/GenerateCharacter.java @@ -692,7 +692,7 @@ PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(theOutputFileName))); out.println(commentStart + " This file was generated AUTOMATICALLY from a template file " + - new java.util.Date() + commentEnd); + commentEnd); int marklen = commandMarker.length(); LOOP: while(true) { try { ++++++ reproducible-generated-source-dates.patch ++++++ From: Bernhard M. Wiedemann <[email protected]> Subject: Use SOURCE_DATE_EPOCH for dates written into generated sources Two build tools stamp the current year into the copyright header of the sources they generate, all of which end up in the shipped src.zip: CopyrightHeaders in the CLDR converter (sun/util/resources/cldr/**) and EquivMapsGenerator (sun/util/locale/LocaleEquivalentMaps.java). Take the date from SOURCE_DATE_EPOCH when it is set and keep the current time otherwise. The year is still computed in America/Los_Angeles, as before, so only the instant changes. Same fix as in the java-1_8_0-openjdk package. The matching GenerateCharacter fix is the separate backport of JDK-8243985. Signed-off-by: Bernhard M. Wiedemann <[email protected]> diff --git a/jdk/make/src/classes/build/tools/cldrconverter/CopyrightHeaders.java b/jdk/make/src/classes/build/tools/cldrconverter/CopyrightHeaders.java index 1ea0186b..7c349ec0 100644 --- a/jdk/make/src/classes/build/tools/cldrconverter/CopyrightHeaders.java +++ b/jdk/make/src/classes/build/tools/cldrconverter/CopyrightHeaders.java @@ -145,8 +145,17 @@ class CopyrightHeaders { } private static int getYear() { - return new GregorianCalendar(TimeZone.getTimeZone("America/Los_Angeles"), - Locale.US).get(Calendar.YEAR); + GregorianCalendar cal = + new GregorianCalendar(TimeZone.getTimeZone("America/Los_Angeles"), + Locale.US); + String sourceDateEpoch = System.getenv("SOURCE_DATE_EPOCH"); + if (sourceDateEpoch != null && !sourceDateEpoch.isEmpty()) { + try { + cal.setTimeInMillis(Long.parseLong(sourceDateEpoch.trim()) * 1000L); + } catch (NumberFormatException e) { + } + } + return cal.get(Calendar.YEAR); } // no instantiation diff --git a/jdk/make/src/classes/build/tools/generatelsrequivmaps/EquivMapsGenerator.java b/jdk/make/src/classes/build/tools/generatelsrequivmaps/EquivMapsGenerator.java index ba83f92a..7e732752 100644 --- a/jdk/make/src/classes/build/tools/generatelsrequivmaps/EquivMapsGenerator.java +++ b/jdk/make/src/classes/build/tools/generatelsrequivmaps/EquivMapsGenerator.java @@ -226,9 +226,16 @@ public class EquivMapsGenerator { + "}"; private static String getOpenJDKCopyright() { - int year = Calendar.getInstance(TimeZone - .getTimeZone("America/Los_Angeles")).get(Calendar.YEAR); - return String.format(Locale.US, COPYRIGHT, year); + Calendar cal = Calendar.getInstance(TimeZone + .getTimeZone("America/Los_Angeles")); + String sourceDateEpoch = System.getenv("SOURCE_DATE_EPOCH"); + if (sourceDateEpoch != null && !sourceDateEpoch.isEmpty()) { + try { + cal.setTimeInMillis(Long.parseLong(sourceDateEpoch.trim()) * 1000L); + } catch (NumberFormatException e) { + } + } + return String.format(Locale.US, COPYRIGHT, cal.get(Calendar.YEAR)); } /** ++++++ reproducible-generated-timestamps.patch ++++++ From: Bernhard M. Wiedemann <[email protected]> Subject: Drop build timestamps from generated javadoc and CORBA output Ported from the java-1_8_0-openjdk package: - HtmlDocWriter appends the wall-clock time to the "Generated by javadoc" comment and HtmlDocletWriter emits it again as <meta name="date"> - together making every generated HTML page differ between builds. Suppress both when SOURCE_DATE_EPOCH is set. - The IDL compiler writes the generation time into the prolog of every file it generates, and MC.java into the CORBA log wrapper sources; the timestamps also reach the org.omg javadoc through the class comments. Drop the date; it carries no information the build does not already have. Signed-off-by: Bernhard M. Wiedemann <[email protected]> diff --git a/corba/src/share/classes/com/sun/tools/corba/se/idl/toJavaPortable/Util.java b/corba/src/share/classes/com/sun/tools/corba/se/idl/toJavaPortable/Util.java index 7e0d8373..e271bf78 100644 --- a/corba/src/share/classes/com/sun/tools/corba/se/idl/toJavaPortable/Util.java +++ b/corba/src/share/classes/com/sun/tools/corba/se/idl/toJavaPortable/Util.java @@ -68,11 +68,8 @@ package com.sun.tools.corba.se.idl.toJavaPortable; import java.io.File; import java.io.PrintWriter; import java.math.BigInteger; -import java.text.DateFormat; -import java.util.Date; import java.util.Enumeration; import java.util.Hashtable; -import java.util.Locale; import java.util.Vector; import com.sun.tools.corba.se.idl.ConstEntry; @@ -1131,26 +1128,6 @@ public class Util extends com.sun.tools.corba.se.idl.Util //stream.println ("* " + Util.getMessage ("toJavaProlog2", Compile.compiler.arguments.file)); stream.println ("* " + Util.getMessage ("toJavaProlog2", Compile.compiler.arguments.file.replace (File.separatorChar, '/'))); - /////////////// - // This SHOULD work, but there's a bug in the JDK. - // stream.println ("* " + DateFormat.getDateTimeInstance (DateFormat.FULL, DateFormat.FULL, Locale.getDefault ()).format (new Date ())); - // This gets around the bug: - - DateFormat formatter = DateFormat.getDateTimeInstance (DateFormat.FULL, DateFormat.FULL, Locale.getDefault ()); - - // Japanese-specific workaround. JDK bug 4069784 being repaired by JavaSoft. - // Keep this transient solution until bug fix is reported.cd . - - if (Locale.getDefault () == Locale.JAPAN) - formatter.setTimeZone (java.util.TimeZone.getTimeZone ("JST")); - else - formatter.setTimeZone (java.util.TimeZone.getDefault ()); - - stream.println ("* " + formatter.format (new Date ())); - - // <daz> - /////////////// - stream.println ("*/"); stream.println (); } // writeProlog diff --git a/corba/src/share/classes/com/sun/tools/corba/se/logutil/MC.java b/corba/src/share/classes/com/sun/tools/corba/se/logutil/MC.java index b2fd98a5..007827f5 100644 --- a/corba/src/share/classes/com/sun/tools/corba/se/logutil/MC.java +++ b/corba/src/share/classes/com/sun/tools/corba/se/logutil/MC.java @@ -30,7 +30,6 @@ import java.io.FileOutputStream; import java.io.IOException; import java.util.Arrays; -import java.util.Date; import java.util.Formatter; import java.util.List; import java.util.Queue; @@ -154,7 +153,7 @@ public class MC { groupName); pw.println("//"); pw.printMsg("// Generated by MC.java version @, DO NOT EDIT BY HAND!", VERSION); - pw.printMsg("// Generated from input file @ on @", inFile, new Date()); + pw.printMsg("// Generated from input file @", inFile); pw.println(); } diff --git a/langtools/src/share/classes/com/sun/tools/doclets/formats/html/HtmlDocletWriter.java b/langtools/src/share/classes/com/sun/tools/doclets/formats/html/HtmlDocletWriter.java index 76229a1f..baa1cd37 100644 --- a/langtools/src/share/classes/com/sun/tools/doclets/formats/html/HtmlDocletWriter.java +++ b/langtools/src/share/classes/com/sun/tools/doclets/formats/html/HtmlDocletWriter.java @@ -400,7 +400,7 @@ public class HtmlDocletWriter extends HtmlDocWriter { head.addContent(meta); } head.addContent(getTitle()); - if (!configuration.notimestamp) { + if (!configuration.notimestamp && System.getenv("SOURCE_DATE_EPOCH") == null) { SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd"); Content meta = HtmlTree.META("date", dateFormat.format(new Date())); head.addContent(meta); diff --git a/langtools/src/share/classes/com/sun/tools/doclets/formats/html/markup/HtmlDocWriter.java b/langtools/src/share/classes/com/sun/tools/doclets/formats/html/markup/HtmlDocWriter.java index 1ddf6e67..e3fbb792 100644 --- a/langtools/src/share/classes/com/sun/tools/doclets/formats/html/markup/HtmlDocWriter.java +++ b/langtools/src/share/classes/com/sun/tools/doclets/formats/html/markup/HtmlDocWriter.java @@ -328,7 +328,7 @@ public abstract class HtmlDocWriter extends HtmlWriter { protected Comment getGeneratedBy(boolean timestamp) { String text = "Generated by javadoc"; // marker string, deliberately not localized - if (timestamp) { + if (timestamp && System.getenv("SOURCE_DATE_EPOCH") == null) { Calendar calendar = new GregorianCalendar(TimeZone.getDefault()); Date today = calendar.getTime(); text += " ("+ configuration.getDocletSpecificBuildDate() + ") on " + today; ++++++ reproducible-nls.patch ++++++ diff --git a/openj9/sourcetools/j9nls/com/ibm/oti/NLSTool/J9NLS.java b/openj9/sourcetools/j9nls/com/ibm/oti/NLSTool/J9NLS.java index 25aa5c221..2fea566e0 100644 --- a/openj9/sourcetools/j9nls/com/ibm/oti/NLSTool/J9NLS.java +++ b/openj9/sourcetools/j9nls/com/ibm/oti/NLSTool/J9NLS.java @@ -22,6 +22,7 @@ package com.ibm.oti.NLSTool; import java.io.BufferedReader; +import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; @@ -291,8 +292,8 @@ public class J9NLS implements NLSConstants { } else { String fileName = getNameWithLocale(outFileName, locale); if (propertiesDifferentFromCopyOnDisk(fileName)) { - out = new FileOutputStream(fileName); - outputProperties.store(out, null); + out = new FileOutputStream(fileName); + storeOutputProperties(out); out.flush(); dp("** Generated " + fileName + "\n"); totalPropertiesFilesCreated++; @@ -308,6 +309,22 @@ public class J9NLS implements NLSConstants { } } + /** + * Writes the generated properties, dropping the leading comment line in + * which Properties.store() records the current time: it would make the + * generated files differ between otherwise identical builds. + * + * @param out + * @throws IOException + */ + private void storeOutputProperties(OutputStream out) throws IOException { + ByteArrayOutputStream buffer = new ByteArrayOutputStream(); + outputProperties.store(buffer, null); + /* Properties.store(OutputStream, String) writes ISO 8859-1. */ + String stored = buffer.toString("ISO-8859-1"); + out.write(stored.substring(stored.indexOf('\n') + 1).getBytes("ISO-8859-1")); + } + private MsgInfo createMsgInfo(String macro, String key, String msg, Properties nlsProperties) { MsgInfo msgInfo = new MsgInfo(); msgInfo.setMacro(macro); ++++++ reproducible-tracemerge-order.patch ++++++ diff --git a/omr/tools/tracegen/FileUtils.cpp b/omr/tools/tracegen/FileUtils.cpp index 7db9723f8..b015970fb 100644 --- a/omr/tools/tracegen/FileUtils.cpp +++ b/omr/tools/tracegen/FileUtils.cpp @@ -120,44 +120,106 @@ FileUtils::getMtime(const char *filePath) return statbuf.st_mtime; } +/* + * Compare two directory entry names. strcmp() is used rather than strcoll() + * so that the ordering is a plain byte comparison, and hence does not depend + * on the locale the build happens to run in. + */ +static int +compareEntryNames(const void *left, const void *right) +{ + return strcmp(*(const char *const *)left, *(const char *const *)right); +} + +static void +freeEntryNames(char ***entries, size_t entryCount) +{ + if (NULL != *entries) { + size_t index = 0; + for (index = 0; index < entryCount; index += 1) { + Port::omrmem_free((void **)&(*entries)[index]); + } + Port::omrmem_free((void **)entries); + } +} + RCType FileUtils::visitDirectory(J9TDFOptions *options, const char *dirName, const char *fileExtFilter, void *targetObject, VisitFileCallBack callback) { char *resultBuffer = NULL; RCType rc = RC_OK; intptr_t handle = PORT_INVALID_FIND_FILE_HANDLE; + char **entries = NULL; + size_t entryCount = 0; + size_t entryCapacity = 0; + size_t index = 0; rc = Port::omrfile_findfirst(dirName, &resultBuffer, &handle); if (RC_OK != rc) { printError("Failed to open directory %s\n", dirName); - goto failed; + /* findfirst leaves no handle open when it fails, so there is nothing to close. */ + return RC_FAILED; } + /* + * Collect the entries before visiting any of them. The order in which the + * filesystem reports directory entries is not stable, and that order used + * to reach the merged trace data, so otherwise identical builds produced + * different output. + */ while (RC_FAILED != rc) { - char *nextEntry = NULL; - size_t nextEntrySize = 0; /* skip current and parent dir */ if ((0 == strcmp(resultBuffer, ".")) || (0 == strcmp(resultBuffer, ".."))) { - goto next; + Port::omrmem_free((void **)&resultBuffer); + } else { + if (entryCount == entryCapacity) { + size_t newCapacity = (0 == entryCapacity) ? 16 : (entryCapacity * 2); + char **newEntries = (char **)Port::omrmem_calloc(newCapacity, sizeof(char *)); + if (NULL == newEntries) { + goto failed; + } + if (NULL != entries) { + memcpy(newEntries, entries, entryCount * sizeof(char *)); + Port::omrmem_free((void **)&entries); + } + entries = newEntries; + entryCapacity = newCapacity; + } + /* the array takes ownership of the name allocated by findfirst/findnext */ + entries[entryCount] = resultBuffer; + entryCount += 1; + resultBuffer = NULL; } + rc = Port::omrfile_findnext(handle, &resultBuffer); + } + Port::omrfile_findclose(handle); + handle = PORT_INVALID_FIND_FILE_HANDLE; + + if (0 != entryCount) { + qsort(entries, entryCount, sizeof(char *), compareEntryNames); + } + + for (index = 0; index < entryCount; index += 1) { + const char *entryName = entries[index]; + size_t nextEntrySize = strlen(dirName) + strlen(PATH_SEP) + strlen(entryName) + 1; + char *nextEntry = (char *)Port::omrmem_calloc(1, nextEntrySize); + struct J9FileStat buf; - nextEntrySize = strlen(dirName) + 1 /* PATH_SEP */ + strlen(resultBuffer) + 1; - nextEntry = (char *)Port::omrmem_calloc(1, nextEntrySize); if (NULL == nextEntry) { goto failed; } - snprintf(nextEntry, nextEntrySize, "%s" PATH_SEP "%s", dirName, resultBuffer); + snprintf(nextEntry, nextEntrySize, "%s" PATH_SEP "%s", dirName, entryName); - struct J9FileStat buf; if (RC_OK != Port::omrfile_stat(nextEntry, 0, &buf)) { if (options->statErrorsAreFatal) { printError("stat failed %s\n", nextEntry); + Port::omrmem_free((void **)&nextEntry); goto failed; } } else if (buf.isDir) { visitDirectory(options, nextEntry, fileExtFilter, targetObject, callback); } else { - const char *ext = FileUtils::getFileExt(resultBuffer); + const char *ext = FileUtils::getFileExt(entryName); if (NULL != ext) { if (0 == strcmp(ext, fileExtFilter)) { callback(targetObject, options, nextEntry); @@ -165,17 +227,17 @@ FileUtils::visitDirectory(J9TDFOptions *options, const char *dirName, const char } } Port::omrmem_free((void **)&nextEntry); -next: - Port::omrmem_free((void **)&resultBuffer); - rc = Port::omrfile_findnext(handle, &resultBuffer); } - Port::omrfile_findclose(handle); + freeEntryNames(&entries, entryCount); return RC_OK; failed: - Port::omrfile_findclose(handle); + if (PORT_INVALID_FIND_FILE_HANDLE != handle) { + Port::omrfile_findclose(handle); + } Port::omrmem_free((void **)&resultBuffer); + freeEntryNames(&entries, entryCount); return RC_FAILED; } ++++++ reproducible-tzdb-order.patch ++++++ From: Bernhard M. Wiedemann <[email protected]> Subject: 8209880: tzdb.dat is not reproducibly built Backport of OpenJDK commit e71557a2d9e3a3d84fb2d4cea02c4364258f0249 (JDK 12, by Naoto Sato), which postdates this jdk8 branch. The list of deduplicated ZoneRules was built by round-tripping the sorted zone map through a HashSet, so its order depended on HashSet iteration order. That order is not part of any contract and in fact changed between JDK releases, so tzdb.dat differed depending on which JVM ran the compiler: with this tree's tzdata2026a, the original code produces different files under JDK 17 and JDK 26, while the fixed version is byte-identical across both. Deduplicate with an explicit loop that keeps the sorted encounter order instead. The upstream fix uses stream().distinct(), which is equivalent, but the javac 8 used as boot compiler here rejects its type inference, so spell it out. Signed-off-by: Bernhard M. Wiedemann <[email protected]> diff --git a/jdk/make/src/classes/build/tools/tzdb/TzdbZoneRulesCompiler.java b/jdk/make/src/classes/build/tools/tzdb/TzdbZoneRulesCompiler.java index a4747c3d..26d9b908 100644 --- a/jdk/make/src/classes/build/tools/tzdb/TzdbZoneRulesCompiler.java +++ b/jdk/make/src/classes/build/tools/tzdb/TzdbZoneRulesCompiler.java @@ -68,7 +68,6 @@ import java.text.ParsePosition; import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; -import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.NoSuchElementException; @@ -232,8 +231,13 @@ public final class TzdbZoneRulesCompiler { for (String regionId : regionArray) { out.writeUTF(regionId); } - // rules -- hashset -> remove the dup - List<ZoneRules> rulesList = new ArrayList<>(new HashSet<>(builtZones.values())); + // rules -- remove the dup, keeping the sorted encounter order + List<ZoneRules> rulesList = new ArrayList<>(); + for (ZoneRules rules : builtZones.values()) { + if (!rulesList.contains(rules)) { + rulesList.add(rules); + } + } out.writeShort(rulesList.size()); ByteArrayOutputStream baos = new ByteArrayOutputStream(1024); for (ZoneRules rules : rulesList) {
