Script 'mail_helper' called by obssrc
Hello community,

here is the log from the commit of package java-1_8_0-openjdk for 
openSUSE:Factory checked in at 2026-11-18 18:32:09
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/java-1_8_0-openjdk (Old)
 and      /work/SRC/openSUSE:Factory/.java-1_8_0-openjdk.new.1251 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Package is "java-1_8_0-openjdk"

Wed Nov 18 18:32:09 2026 rev:120 rq:1398394 version:1.8.0.514

Changes:
--------
--- /work/SRC/openSUSE:Factory/java-1_8_0-openjdk/java-1_8_0-openjdk.changes    
2026-11-10 16:30:05.913985214 +0100
+++ 
/work/SRC/openSUSE:Factory/.java-1_8_0-openjdk.new.1251/java-1_8_0-openjdk.changes
  2026-11-18 18:33:59.327054148 +0100
@@ -1,0 +2,29 @@
+Wed Nov 18 07:59:57 UTC 2026 - Fridrich Strba <[email protected]>
+
+- Upgrade to upstream tag jdk8u514-b01 (November 2026 CSPU)
+  * Fixes
+    + JDK-8394492: Update FreeType to 2.15.0
+    + JDK-8384495: Update Libpng to 1.6.58 8393195: Update Libpng
+      to 1.6.59
+    + JDK-8393456, CVE-2026-114940, bsc#1290782: Improve TLS client
+      connections
+    + JDK-8391595, CVE-2026-114944, bsc#1290786: [REDO] Enhance JMX
+      Connections
+    + JDK-8389830, CVE-2026-114943, bsc#1290784: Enhance JFR Events
+    + JDK-8389989, CVE-2026-114946, bsc#1290788: Enhance loop
+      handling
+    + JDK-8387162, CVE-2026-114939, bsc#1290781: Enhance Kerberos
+      tickets
+    + JDK-8316771: Krb5.java has not defined messages for all error
+      codes
+    + JDK-8274205: Handle KDC_ERR_SVC_UNAVAILABLE error code from
+      KDC
+    + JDK-8396902: Bump update version for OpenJDK: 8u514
+- Added patches:
+  * s390-size_t.patch
+    + Fix log2_intptr(size_t) overload ambiguity on 31-bit s390
+  * s390-min-max.patch
+    + Fix MAX/MIN template usage on 31-bit s390 where
+      size_t != uintx
+
+-------------------------------------------------------------------

Old:
----
  jdk8u512-b09.tar.gz

New:
----
  jdk8u514-b01.tar.gz
  s390-min-max.patch
  s390-size_t.patch

----------(New B)----------
  New:    + Fix log2_intptr(size_t) overload ambiguity on 31-bit s390
  * s390-min-max.patch
    + Fix MAX/MIN template usage on 31-bit s390 where
  New:- Added patches:
  * s390-size_t.patch
    + Fix log2_intptr(size_t) overload ambiguity on 31-bit s390
----------(New E)----------

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Other differences:
------------------
++++++ java-1_8_0-openjdk.spec ++++++
--- /var/tmp/diff_new_pack.6GeAm9/_old  2026-11-18 18:34:04.818286779 +0100
+++ /var/tmp/diff_new_pack.6GeAm9/_new  2026-11-18 18:34:04.826287118 +0100
@@ -45,8 +45,8 @@
 %global priority        1805
 %global featurever      8
 %global javaver         1.%{featurever}.0
-%global updatever       512
-%global buildver        09
+%global updatever       514
+%global buildver        01
 # Standard JPackage directories and symbolic links.
 %global sdklnk          java-%{javaver}-openjdk
 %global archname        %{sdklnk}
@@ -235,6 +235,8 @@
 Patch2002:      JDK_1_8_0-8208602.patch
 Patch3000:      tls13extensions.patch
 Patch4000:      riscv64-zero.patch
+Patch4001:      s390-size_t.patch
+Patch4002:      s390-min-max.patch
 Patch5001:      fips.patch
 BuildRequires:  alsa-lib-devel
 BuildRequires:  autoconf
@@ -484,6 +486,8 @@
 %ifarch riscv64
 %patch -P 4000 -p1
 %endif
+%patch -P 4001 -p1
+%patch -P 4002 -p1
 %patch -P 5001 -p1
 
 (cd common/autoconf && bash ./autogen.sh)

++++++ jdk8u512-b09.tar.gz -> jdk8u514-b01.tar.gz ++++++
/work/SRC/openSUSE:Factory/java-1_8_0-openjdk/jdk8u512-b09.tar.gz 
/work/SRC/openSUSE:Factory/.java-1_8_0-openjdk.new.1251/jdk8u514-b01.tar.gz 
differ: char 13, line 1

++++++ s390-min-max.patch ++++++
diff --git 
a/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.cpp
 
b/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.cpp
index 3903da074f..e10ed32766 100644
--- 
a/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.cpp
+++ 
b/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.cpp
@@ -2676,7 +2676,7 @@ void CFLS_LAB::get_from_global_pool(size_t word_sz, 
AdaptiveFreeList<FreeChunk>*
   if (ResizeOldPLAB && CMSOldPLABResizeQuicker) {
     size_t multiple = 
_num_blocks[word_sz]/(CMSOldPLABToleranceFactor*CMSOldPLABNumRefills*n_blks);
     n_blks +=  CMSOldPLABReactivityFactor*multiple*n_blks;
-    n_blks = MIN2(n_blks, CMSOldPLABMax);
+    n_blks = MIN2(n_blks, (size_t) CMSOldPLABMax);
   }
   assert(n_blks > 0, "Error");
   _cfls->par_get_chunk_of_blocks(word_sz, n_blks, fl);
diff --git 
a/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp
 
b/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp
index d48e208c59..c3e90eac34 100644
--- 
a/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp
+++ 
b/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp
@@ -961,7 +961,7 @@ void 
ConcurrentMarkSweepGeneration::compute_new_size_free_list() {
   if (free_percentage < desired_free_percentage) {
     size_t desired_capacity = (size_t)(used() / ((double) 1 - 
desired_free_percentage));
     assert(desired_capacity >= capacity(), "invalid expansion size");
-    size_t expand_bytes = MAX2(desired_capacity - capacity(), 
MinHeapDeltaBytes);
+    size_t expand_bytes = MAX2(desired_capacity - capacity(), (size_t) 
MinHeapDeltaBytes);
     if (PrintGCDetails && Verbose) {
       size_t desired_capacity = (size_t)(used() / ((double) 1 - 
desired_free_percentage));
       gclog_or_tty->print_cr("\nFrom compute_new_size: ");
@@ -6591,7 +6591,7 @@ void CMSCollector::reset(bool asynch) {
     HeapWord* curAddr = _markBitMap.startWord();
     while (curAddr < _markBitMap.endWord()) {
       size_t remaining  = pointer_delta(_markBitMap.endWord(), curAddr);
-      MemRegion chunk(curAddr, MIN2(CMSBitMapYieldQuantum, remaining));
+      MemRegion chunk(curAddr, MIN2((size_t) CMSBitMapYieldQuantum, 
remaining));
       _markBitMap.clear_large_range(chunk);
       if (ConcurrentMarkSweepThread::should_yield() &&
           !foregroundGCIsActive() &&
@@ -6889,7 +6889,7 @@ void CMSMarkStack::expand() {
     return;
   }
   // Double capacity if possible
-  size_t new_capacity = MIN2(_capacity*2, MarkStackSizeMax);
+  size_t new_capacity = MIN2(_capacity*2, (size_t) MarkStackSizeMax);
   // Do not give up existing stack until we have managed to
   // get the double capacity that we desired.
   ReservedSpace rs(ReservedSpace::allocation_align_size_up(
diff --git a/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp 
b/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp
index 14b5749f9a..ed3420f719 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp
@@ -3916,7 +3916,7 @@ void CMTask::drain_local_queue(bool partially) {
   // of things to do) or totally (at the very end).
   size_t target_size;
   if (partially) {
-    target_size = MIN2((size_t)_task_queue->max_elems()/3, 
GCDrainStackTargetSize);
+    target_size = MIN2((size_t)_task_queue->max_elems()/3, (size_t) 
GCDrainStackTargetSize);
   } else {
     target_size = 0;
   }
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp 
b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp
index 1da72eac07..f3a84fa65e 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp
@@ -1725,7 +1725,7 @@ HeapWord* G1CollectedHeap::expand_and_allocate(size_t 
word_size, AllocationConte
 
   verify_region_sets_optional();
 
-  size_t expand_bytes = MAX2(word_size * HeapWordSize, MinHeapDeltaBytes);
+  size_t expand_bytes = MAX2(word_size * HeapWordSize, (size_t) 
MinHeapDeltaBytes);
   ergo_verbose1(ErgoHeapSizing,
                 "attempt heap expansion",
                 ergo_format_reason("allocation request failed")
diff --git 
a/hotspot/src/share/vm/gc_implementation/g1/g1ConcurrentMarkObjArrayProcessor.cpp
 
b/hotspot/src/share/vm/gc_implementation/g1/g1ConcurrentMarkObjArrayProcessor.cpp
index d91b632f31..91d9be2fe9 100644
--- 
a/hotspot/src/share/vm/gc_implementation/g1/g1ConcurrentMarkObjArrayProcessor.cpp
+++ 
b/hotspot/src/share/vm/gc_implementation/g1/g1ConcurrentMarkObjArrayProcessor.cpp
@@ -41,7 +41,7 @@ void G1CMObjArrayProcessor::push_array_slice(HeapWord* what) {
 }
 
 size_t G1CMObjArrayProcessor::process_array_slice(objArrayOop obj, HeapWord* 
start_from, size_t remaining) {
-  size_t words_to_scan = MIN2(remaining, ObjArrayMarkingStride);
+  size_t words_to_scan = MIN2(remaining, (size_t) ObjArrayMarkingStride);
 
   if (remaining > ObjArrayMarkingStride) {
     push_array_slice(start_from + ObjArrayMarkingStride);
diff --git 
a/hotspot/src/share/vm/gc_implementation/g1/g1PageBasedVirtualSpace.hpp 
b/hotspot/src/share/vm/gc_implementation/g1/g1PageBasedVirtualSpace.hpp
index 4d0b7b21b1..e2e446c4d9 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/g1PageBasedVirtualSpace.hpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1PageBasedVirtualSpace.hpp
@@ -89,7 +89,7 @@ class G1PageBasedVirtualSpace VALUE_OBJ_CLASS_SPEC {
   void pretouch_internal(size_t start_page, size_t end_page);
 
   // Returns the index of the page which contains the given address.
-  uintptr_t  addr_to_page_index(char* addr) const;
+  size_t  addr_to_page_index(char* addr) const;
   // Returns the address of the given page index.
   char*  page_start(size_t index) const;
 
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1StringDedupQueue.cpp 
b/hotspot/src/share/vm/gc_implementation/g1/g1StringDedupQueue.cpp
index 747f61ba06..b83984295c 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/g1StringDedupQueue.cpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1StringDedupQueue.cpp
@@ -38,7 +38,7 @@ G1StringDedupQueue::G1StringDedupQueue() :
   _cancel(false),
   _empty(true),
   _dropped(0) {
-  _nqueues = MAX2(ParallelGCThreads, (size_t)1);
+  _nqueues = MAX2((size_t) ParallelGCThreads, (size_t)1);
   _queues = NEW_C_HEAP_ARRAY(G1StringDedupWorkerQueue, _nqueues, mtGC);
   for (size_t i = 0; i < _nqueues; i++) {
     new (_queues + i) 
G1StringDedupWorkerQueue(G1StringDedupWorkerQueue::default_segment_size(), 
_max_cache_size, _max_size);
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1StringDedupTable.cpp 
b/hotspot/src/share/vm/gc_implementation/g1/g1StringDedupTable.cpp
index 94d355624c..3d99dbaab9 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/g1StringDedupTable.cpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1StringDedupTable.cpp
@@ -120,7 +120,7 @@ public:
 };
 
 G1StringDedupEntryCache::G1StringDedupEntryCache(size_t max_size) :
-  _nlists(MAX2(ParallelGCThreads, (size_t)1)),
+  _nlists(MAX2((size_t) ParallelGCThreads, (size_t)1)),
   _max_list_length(0),
   _cached(PaddedArray<G1StringDedupEntryList, 
mtGC>::create_unfreeable((uint)_nlists)),
   _overflowed(PaddedArray<G1StringDedupEntryList, 
mtGC>::create_unfreeable((uint)_nlists)) {
diff --git a/hotspot/src/share/vm/gc_implementation/g1/heapRegion.cpp 
b/hotspot/src/share/vm/gc_implementation/g1/heapRegion.cpp
index b9078d5004..3ac9565dd1 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegion.cpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegion.cpp
@@ -109,7 +109,7 @@ void HeapRegion::setup_heap_region_size(size_t 
initial_heap_size, size_t max_hea
   uintx region_size = G1HeapRegionSize;
   if (FLAG_IS_DEFAULT(G1HeapRegionSize)) {
     size_t average_heap_size = (initial_heap_size + max_heap_size) / 2;
-    region_size = MAX2(average_heap_size / HeapRegionBounds::target_number(),
+    region_size = MAX2((uintx) (average_heap_size / 
HeapRegionBounds::target_number()),
                        (uintx) HeapRegionBounds::min_size());
   }
 
diff --git a/hotspot/src/share/vm/gc_implementation/parNew/parNewGeneration.cpp 
b/hotspot/src/share/vm/gc_implementation/parNew/parNewGeneration.cpp
index afca7c5b07..cd54733655 100644
--- a/hotspot/src/share/vm/gc_implementation/parNew/parNewGeneration.cpp
+++ b/hotspot/src/share/vm/gc_implementation/parNew/parNewGeneration.cpp
@@ -194,7 +194,7 @@ bool ParScanThreadState::take_from_overflow_stack() {
   const size_t num_overflow_elems = of_stack->size();
   const size_t space_available = queue->max_elems() - queue->size();
   const size_t num_take_elems = MIN3(space_available / 4,
-                                     ParGCDesiredObjsFromOverflowList,
+                                     (size_t) ParGCDesiredObjsFromOverflowList,
                                      num_overflow_elems);
   // Transfer the most recent num_take_elems from the overflow
   // stack to our work queue.
diff --git 
a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp 
b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp
index 0fa980ef83..998d381576 100644
--- 
a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp
+++ 
b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp
@@ -913,8 +913,8 @@ void PSParallelCompact::initialize_space_info()
 void PSParallelCompact::initialize_dead_wood_limiter()
 {
   const size_t max = 100;
-  _dwl_mean = double(MIN2(ParallelOldDeadWoodLimiterMean, max)) / 100.0;
-  _dwl_std_dev = double(MIN2(ParallelOldDeadWoodLimiterStdDev, max)) / 100.0;
+  _dwl_mean = double(MIN2((size_t) ParallelOldDeadWoodLimiterMean, max)) / 
100.0;
+  _dwl_std_dev = double(MIN2((size_t) ParallelOldDeadWoodLimiterStdDev, max)) 
/ 100.0;
   _dwl_first_term = 1.0 / (sqrt(2.0 * M_PI) * _dwl_std_dev);
   DEBUG_ONLY(_dwl_initialized = true;)
   _dwl_adjustment = normal_distribution(1.0);
diff --git a/hotspot/src/share/vm/memory/collectorPolicy.cpp 
b/hotspot/src/share/vm/memory/collectorPolicy.cpp
index 727408d528..ed41cbbf60 100644
--- a/hotspot/src/share/vm/memory/collectorPolicy.cpp
+++ b/hotspot/src/share/vm/memory/collectorPolicy.cpp
@@ -385,7 +385,7 @@ void TwoGenerationCollectorPolicy::initialize_flags() {
       uintx calculated_size = NewSize + OldSize;
       double shrink_factor = (double) MaxHeapSize / calculated_size;
       uintx smaller_new_size = align_size_down((uintx)(NewSize * 
shrink_factor), _gen_alignment);
-      FLAG_SET_ERGO(uintx, NewSize, MAX2(young_gen_size_lower_bound(), 
smaller_new_size));
+      FLAG_SET_ERGO(uintx, NewSize, MAX2((uintx) young_gen_size_lower_bound(), 
smaller_new_size));
       _initial_gen0_size = NewSize;
 
       // OldSize is already aligned because above we aligned MaxHeapSize to
@@ -423,7 +423,7 @@ void GenCollectorPolicy::initialize_size_info() {
 
   // Determine maximum size of gen0
 
-  size_t max_new_size = 0;
+  uintx max_new_size = 0;
   if (!FLAG_IS_DEFAULT(MaxNewSize)) {
     max_new_size = MaxNewSize;
   } else {
@@ -448,7 +448,7 @@ void GenCollectorPolicy::initialize_size_info() {
     _initial_gen0_size = max_new_size;
     _max_gen0_size = max_new_size;
   } else {
-    size_t desired_new_size = 0;
+    uintx desired_new_size = 0;
     if (FLAG_IS_CMDLINE(NewSize)) {
       // If NewSize is set on the command line, we must use it as
       // the initial size and it also makes sense to use it as the
@@ -461,7 +461,7 @@ void GenCollectorPolicy::initialize_size_info() {
       // limit, but use NewRatio to calculate the initial size.
       _min_gen0_size = NewSize;
       desired_new_size =
-        MAX2(scale_by_NewRatio_aligned(_initial_heap_byte_size), NewSize);
+        MAX2((uintx) (scale_by_NewRatio_aligned(_initial_heap_byte_size)), 
NewSize);
       max_new_size = MAX2(max_new_size, NewSize);
     } else {
       // For the case where NewSize is the default, use NewRatio
@@ -469,9 +469,9 @@ void GenCollectorPolicy::initialize_size_info() {
       // Use the default NewSize as the floor for these values.  If
       // NewRatio is overly large, the resulting sizes can be too
       // small.
-      _min_gen0_size = MAX2(scale_by_NewRatio_aligned(_min_heap_byte_size), 
NewSize);
+      _min_gen0_size = MAX2((uintx) 
(scale_by_NewRatio_aligned(_min_heap_byte_size)), NewSize);
       desired_new_size =
-        MAX2(scale_by_NewRatio_aligned(_initial_heap_byte_size), NewSize);
+        MAX2((uintx) (scale_by_NewRatio_aligned(_initial_heap_byte_size)), 
NewSize);
     }
 
     assert(_min_gen0_size > 0, "Sanity check");
@@ -573,7 +573,7 @@ void TwoGenerationCollectorPolicy::initialize_size_info() {
   } else {
     // It's been explicitly set on the command line.  Use the
     // OldSize and then determine the consequences.
-    _min_gen1_size = MIN2(OldSize, _min_heap_byte_size - _min_gen0_size);
+    _min_gen1_size = MIN2(OldSize, (uintx) (_min_heap_byte_size - 
_min_gen0_size));
     _initial_gen1_size = OldSize;
 
     // If the user has explicitly set an OldSize that is inconsistent
diff --git a/hotspot/src/share/vm/memory/metaspace.cpp 
b/hotspot/src/share/vm/memory/metaspace.cpp
index fb0564ac27..9258fbd187 100644
--- a/hotspot/src/share/vm/memory/metaspace.cpp
+++ b/hotspot/src/share/vm/memory/metaspace.cpp
@@ -1482,7 +1482,7 @@ void MetaspaceGC::initialize() {
 
 void MetaspaceGC::post_initialize() {
   // Reset the high-water mark once the VM initialization is done.
-  _capacity_until_GC = MAX2(MetaspaceAux::committed_bytes(), MetaspaceSize);
+  _capacity_until_GC = MAX2(MetaspaceAux::committed_bytes(), (size_t) 
MetaspaceSize);
 }
 
 bool MetaspaceGC::can_expand(size_t word_size, bool is_class) {
@@ -1542,7 +1542,7 @@ void MetaspaceGC::compute_new_size() {
     (size_t)MIN2(min_tmp, double(MaxMetaspaceSize));
   // Don't shrink less than the initial generation size
   minimum_desired_capacity = MAX2(minimum_desired_capacity,
-                                  MetaspaceSize);
+                                  (size_t) MetaspaceSize);
 
   if (PrintGCDetails && Verbose) {
     gclog_or_tty->print_cr("\nMetaspaceGC::compute_new_size: ");
@@ -1600,7 +1600,7 @@ void MetaspaceGC::compute_new_size() {
     const double max_tmp = used_after_gc / minimum_used_percentage;
     size_t maximum_desired_capacity = (size_t)MIN2(max_tmp, 
double(MaxMetaspaceSize));
     maximum_desired_capacity = MAX2(maximum_desired_capacity,
-                                    MetaspaceSize);
+                                    (size_t) MetaspaceSize);
     if (PrintGCDetails && Verbose) {
       gclog_or_tty->print_cr("  "
                              "  maximum_free_percentage: %6.2f"
@@ -3361,7 +3361,7 @@ void Metaspace::global_initialize() {
     // on the medium chunk list.   The next chunk will be small and progress
     // from there.  This size calculated by -version.
     _first_class_chunk_word_size = MIN2((size_t)MediumChunk*6,
-                                       
(CompressedClassSpaceSize/BytesPerWord)*2);
+                                       (size_t) 
((CompressedClassSpaceSize/BytesPerWord)*2));
     _first_class_chunk_word_size = 
align_word_size_up(_first_class_chunk_word_size);
     // Arbitrarily set the initial virtual space to a multiple
     // of the boot class loader size.
diff --git a/hotspot/src/share/vm/oops/objArrayKlass.inline.hpp 
b/hotspot/src/share/vm/oops/objArrayKlass.inline.hpp
index e082df55ab..500127af73 100644
--- a/hotspot/src/share/vm/oops/objArrayKlass.inline.hpp
+++ b/hotspot/src/share/vm/oops/objArrayKlass.inline.hpp
@@ -48,7 +48,7 @@ void ObjArrayKlass::objarray_follow_contents(oop obj, int 
index) {
   const size_t beg_index = size_t(index);
   assert(beg_index < len || len == 0, "index too large");
 
-  const size_t stride = MIN2(len - beg_index, ObjArrayMarkingStride);
+  const size_t stride = MIN2(len - beg_index, (size_t) ObjArrayMarkingStride);
   const size_t end_index = beg_index + stride;
   T* const base = (T*)a->base();
   T* const beg = base + beg_index;
@@ -82,7 +82,7 @@ void 
ObjArrayKlass::objarray_follow_contents(ParCompactionManager* cm, oop obj,
   const size_t beg_index = size_t(index);
   assert(beg_index < len || len == 0, "index too large");
 
-  const size_t stride = MIN2(len - beg_index, ObjArrayMarkingStride);
+  const size_t stride = MIN2(len - beg_index, (size_t) ObjArrayMarkingStride);
   const size_t end_index = beg_index + stride;
   T* const base = (T*)a->base();
   T* const beg = base + beg_index;
diff --git a/hotspot/src/share/vm/runtime/arguments.cpp 
b/hotspot/src/share/vm/runtime/arguments.cpp
index 478ddf21be..47f8cc464b 100644
--- a/hotspot/src/share/vm/runtime/arguments.cpp
+++ b/hotspot/src/share/vm/runtime/arguments.cpp
@@ -1292,7 +1292,7 @@ void Arguments::set_cms_and_parnew_gc_flags() {
     (ParallelGCThreads == 0 ? 1 : ParallelGCThreads);
   const size_t preferred_max_new_size_unaligned =
     MIN2(max_heap/(NewRatio+1), ScaleForWordSize(young_gen_per_worker * 
parallel_gc_threads));
-  size_t preferred_max_new_size =
+  uintx preferred_max_new_size = (uintx)
     align_size_up(preferred_max_new_size_unaligned, os::vm_page_size());
 
   // Unless explicitly requested otherwise, size young gen
@@ -1323,7 +1323,7 @@ void Arguments::set_cms_and_parnew_gc_flags() {
            " max_heap: " SIZE_FORMAT,
            min_heap_size(), InitialHeapSize, max_heap);
     }
-    size_t min_new = preferred_max_new_size;
+    uintx min_new = preferred_max_new_size;
     if (FLAG_IS_CMDLINE(NewSize)) {
       min_new = NewSize;
     }
@@ -1342,7 +1342,7 @@ void Arguments::set_cms_and_parnew_gc_flags() {
       // so it's NewRatio x of NewSize.
       if (FLAG_IS_DEFAULT(OldSize)) {
         if (max_heap > NewSize) {
-          FLAG_SET_ERGO(uintx, OldSize, MIN2(NewRatio*NewSize, max_heap - 
NewSize));
+          FLAG_SET_ERGO(uintx, OldSize, MIN2(NewRatio*NewSize, (uintx) 
(max_heap - NewSize)));
           if (PrintGCDetails && Verbose) {
             // Too early to use gclog_or_tty
             tty->print_cr("CMS ergo set OldSize: " SIZE_FORMAT, OldSize);

++++++ s390-size_t.patch ++++++
diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1BiasedArray.hpp 
b/hotspot/src/share/vm/gc_implementation/g1/g1BiasedArray.hpp
index 88a6735740..a3d1055317 100644
--- a/hotspot/src/share/vm/gc_implementation/g1/g1BiasedArray.hpp
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1BiasedArray.hpp
@@ -78,7 +78,8 @@ protected:
     size_t num_target_elems = pointer_delta(end, bottom, 
mapping_granularity_in_bytes);
     idx_t bias = (uintptr_t)bottom / mapping_granularity_in_bytes;
     address base = create_new_base_array(num_target_elems, 
target_elem_size_in_bytes);
-    initialize_base(base, num_target_elems, bias, target_elem_size_in_bytes, 
log2_intptr(mapping_granularity_in_bytes));
+    initialize_base(base, num_target_elems, bias, target_elem_size_in_bytes,
+                    log2_intptr((uintptr_t) mapping_granularity_in_bytes));
   }
 
   size_t bias() const { return _bias; }
diff --git a/hotspot/src/share/vm/runtime/os.cpp 
b/hotspot/src/share/vm/runtime/os.cpp
index 9a1f38414b..de04108352 100644
--- a/hotspot/src/share/vm/runtime/os.cpp
+++ b/hotspot/src/share/vm/runtime/os.cpp
@@ -1305,7 +1305,7 @@ char** os::split_path(const char* path, int* n) {
 }
 
 void os::set_memory_serialize_page(address page) {
-  int count = log2_intptr(sizeof(class JavaThread)) - log2_int(64);
+  int count = log2_intptr((uintptr_t) sizeof(class JavaThread)) - log2_int(64);
   _mem_serialize_page = (volatile int32_t *)page;
   // We initialize the serialization page shift count here
   // We assume a cache line size of 64 bytes

Reply via email to