diff --git a/8144993.patch b/8144993.patch index f3f1600456ed92a7d92c87fc38964ce20a5f73ec..0254e94d68afe7d90e15e6a2dea4aea311b87c4f 100644 --- a/8144993.patch +++ b/8144993.patch @@ -82,8 +82,8 @@ diff --git a/hotspot/src/share/vm/opto/macro.cpp b/hotspot/src/share/vm/opto/mac index 3c13f973f..628ee6656 100644 --- a/hotspot/src/share/vm/opto/macro.cpp +++ b/hotspot/src/share/vm/opto/macro.cpp -@@ -1381,14 +1381,23 @@ void PhaseMacroExpand::expand_allocate_common( - +@@ -1402,11 +1402,20 @@ void PhaseMacroExpand::expand_allocate_common( + // If initialization is performed by an array copy, any required // MemBarStoreStore was already added. If the object does not - // escape no need for a MemBarStoreStore. Otherwise we need a @@ -102,14 +102,11 @@ index 3c13f973f..628ee6656 100644 + // implementation: CMS and G1 will not scan newly created object, + // so it's safe to skip storestore barrier when allocation does + // not escape. - #ifndef AARCH64 - if (init == NULL || (!init->is_complete_with_arraycopy() && !init->does_not_escape())) { - #else - if (!alloc->does_not_escape_thread() && -+ !alloc->is_allocation_MemBar_redundant() && - (init == NULL || !init->is_complete_with_arraycopy())) { - #endif - if (init == NULL || init->req() < InitializeNode::RawStores) { + if ( AARCH64_ONLY ( !alloc->does_not_escape_thread() && ++ !alloc->is_allocation_MemBar_redundant() && + (init == NULL || + !init->is_complete_with_arraycopy()) ) + NOT_AARCH64 ( init == NULL || diff --git a/hotspot/src/share/vm/opto/parse1.cpp b/hotspot/src/share/vm/opto/parse1.cpp index 2d6daa159..da0c6dd68 100644 --- a/hotspot/src/share/vm/opto/parse1.cpp diff --git a/8160369.patch b/8160369.patch new file mode 100644 index 0000000000000000000000000000000000000000..dd304263c83aa672657c6173347db28ca4dbbd63 --- /dev/null +++ b/8160369.patch @@ -0,0 +1,444 @@ +From be5a699028cd0b8fd49eb2df0c4b3d1653eca4f3 Mon Sep 17 00:00:00 2001 +Date: Mon, 25 Jan 2021 17:22:52 +0800 +Subject: Backport of JDK-8160369 + +Summary::[Backport of JDK-8160369 and it's subtasks] Memory fences needed around setting and reading object lengths +LLT: +bug url: https://bugs.openjdk.java.net/browse/JDK-8160369 +--- + .../g1/g1BlockOffsetTable.cpp | 2 +- + .../g1/g1BlockOffsetTable.inline.hpp | 4 +- + .../vm/gc_implementation/g1/g1RemSet.cpp | 101 +++++++++---- + .../vm/gc_implementation/g1/heapRegion.cpp | 140 ++++++++++-------- + .../vm/gc_implementation/g1/heapRegion.hpp | 2 + + .../gc_implementation/g1/heapRegionType.hpp | 3 + + .../parNew/parNewGeneration.cpp | 21 ++- + 7 files changed, 173 insertions(+), 100 deletions(-) + +diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1BlockOffsetTable.cpp b/hotspot/src/share/vm/gc_implementation/g1/g1BlockOffsetTable.cpp +index ead98e24a..1977fc83d 100644 +--- a/hotspot/src/share/vm/gc_implementation/g1/g1BlockOffsetTable.cpp ++++ b/hotspot/src/share/vm/gc_implementation/g1/g1BlockOffsetTable.cpp +@@ -264,7 +264,7 @@ G1BlockOffsetArray::forward_to_block_containing_addr_slow(HeapWord* q, + while (n <= next_boundary) { + q = n; + oop obj = oop(q); +- if (obj->klass_or_null() == NULL) return q; ++ if (obj->klass_or_null_acquire() == NULL) return q; + n += block_size(q); + } + assert(q <= next_boundary && n > next_boundary, "Consequence of loop"); +diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1BlockOffsetTable.inline.hpp b/hotspot/src/share/vm/gc_implementation/g1/g1BlockOffsetTable.inline.hpp +index bcfd52a4a..ffc56a0ba 100644 +--- a/hotspot/src/share/vm/gc_implementation/g1/g1BlockOffsetTable.inline.hpp ++++ b/hotspot/src/share/vm/gc_implementation/g1/g1BlockOffsetTable.inline.hpp +@@ -166,7 +166,7 @@ forward_to_block_containing_addr_const(HeapWord* q, HeapWord* n, + while (n <= addr) { + q = n; + oop obj = oop(q); +- if (obj->klass_or_null() == NULL) return q; ++ if (obj->klass_or_null_acquire() == NULL) return q; + n += block_size(q); + } + assert(q <= n, "wrong order for q and addr"); +@@ -177,7 +177,7 @@ forward_to_block_containing_addr_const(HeapWord* q, HeapWord* n, + inline HeapWord* + G1BlockOffsetArray::forward_to_block_containing_addr(HeapWord* q, + const void* addr) { +- if (oop(q)->klass_or_null() == NULL) return q; ++ if (oop(q)->klass_or_null_acquire() == NULL) return q; + HeapWord* n = q + block_size(q); + // In the normal case, where the query "addr" is a card boundary, and the + // offset table chunks are the same size as cards, the block starting at +diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.cpp b/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.cpp +index 4cad9234c..b062947c8 100644 +--- a/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.cpp ++++ b/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.cpp +@@ -460,18 +460,26 @@ bool G1RemSet::refine_card(jbyte* card_ptr, uint worker_i, + // And find the region containing it. + HeapRegion* r = _g1->heap_region_containing(start); + +- // Why do we have to check here whether a card is on a young region, +- // given that we dirty young regions and, as a result, the +- // post-barrier is supposed to filter them out and never to enqueue +- // them? When we allocate a new region as the "allocation region" we +- // actually dirty its cards after we release the lock, since card +- // dirtying while holding the lock was a performance bottleneck. So, +- // as a result, it is possible for other threads to actually +- // allocate objects in the region (after the acquire the lock) +- // before all the cards on the region are dirtied. This is unlikely, +- // and it doesn't happen often, but it can happen. So, the extra +- // check below filters out those cards. +- if (r->is_young()) { ++ // This check is needed for some uncommon cases where we should ++ // ignore the card. ++ // ++ // The region could be young. Cards for young regions are ++ // distinctly marked (set to g1_young_gen), so the post-barrier will ++ // filter them out. However, that marking is performed ++ // concurrently. A write to a young object could occur before the ++ // card has been marked young, slipping past the filter. ++ // ++ // The card could be stale, because the region has been freed since ++ // the card was recorded. In this case the region type could be ++ // anything. If (still) free or (reallocated) young, just ignore ++ // it. If (reallocated) old or humongous, the later card trimming ++ // and additional checks in iteration may detect staleness. At ++ // worst, we end up processing a stale card unnecessarily. ++ // ++ // In the normal (non-stale) case, the synchronization between the ++ // enqueueing of the card and processing it here will have ensured ++ // we see the up-to-date region type here. ++ if (!r->is_old_or_humongous()) { + return false; + } + +@@ -503,26 +511,69 @@ bool G1RemSet::refine_card(jbyte* card_ptr, uint worker_i, + assert(!check_for_refs_into_cset, "sanity"); + assert(!SafepointSynchronize::is_at_safepoint(), "sanity"); + ++ const jbyte* orig_card_ptr = card_ptr; + card_ptr = hot_card_cache->insert(card_ptr); + if (card_ptr == NULL) { + // There was no eviction. Nothing to do. + return false; +- } +- +- start = _ct_bs->addr_for(card_ptr); +- r = _g1->heap_region_containing(start); ++ } else if (card_ptr != orig_card_ptr) { ++ // Original card was inserted and an old card was evicted. ++ start = _ct_bs->addr_for(card_ptr); ++ r = _g1->heap_region_containing(start); ++ ++ // Check whether the region formerly in the cache should be ++ // ignored, as discussed earlier for the original card. The ++ // region could have been freed while in the cache. The cset is ++ // not relevant here, since we're in concurrent phase. ++ if (!r->is_old_or_humongous()) { ++ return false; ++ } ++ } // Else we still have the original card. ++ } + +- // Checking whether the region we got back from the cache +- // is young here is inappropriate. The region could have been +- // freed, reallocated and tagged as young while in the cache. +- // Hence we could see its young type change at any time. ++ // Trim the region designated by the card to what's been allocated ++ // in the region. The card could be stale, or the card could cover ++ // (part of) an object at the end of the allocated space and extend ++ // beyond the end of allocation. ++ HeapWord* scan_limit; ++ if (_g1->is_gc_active()) { ++ // If we're in a STW GC, then a card might be in a GC alloc region ++ // and extend onto a GC LAB, which may not be parsable. Stop such ++ // at the "scan_top" of the region. ++ scan_limit = r->scan_top(); ++ } else { ++ // Non-humongous objects are only allocated in the old-gen during ++ // GC, so if region is old then top is stable. Humongous object ++ // allocation sets top last; if top has not yet been set, this is ++ // a stale card and we'll end up with an empty intersection. If ++ // this is not a stale card, the synchronization between the ++ // enqueuing of the card and processing it here will have ensured ++ // we see the up-to-date top here. ++ scan_limit = r->top(); ++ } ++ if (scan_limit <= start) { ++ // If the trimmed region is empty, the card must be stale. ++ return false; + } + ++ // Okay to clean and process the card now. There are still some ++ // stale card cases that may be detected by iteration and dealt with ++ // as iteration failure. ++ *const_cast(card_ptr) = CardTableModRefBS::clean_card_val(); ++ ++ // This fence serves two purposes. First, the card must be cleaned ++ // before processing the contents. Second, we can't proceed with ++ // processing until after the read of top, for synchronization with ++ // possibly concurrent humongous object allocation. It's okay that ++ // reading top and reading type were racy wrto each other. We need ++ // both set, in any order, to proceed. ++ OrderAccess::fence(); ++ + // Don't use addr_for(card_ptr + 1) which can ask for +- // a card beyond the heap. This is not safe without a perm +- // gen at the upper end of the heap. +- HeapWord* end = start + CardTableModRefBS::card_size_in_words; +- MemRegion dirtyRegion(start, end); ++ // a card beyond the heap. ++ HeapWord* end = start + CardTableModRefBS::card_size_in_words; ++ MemRegion dirty_region(start, MIN2(scan_limit, end)); ++ assert(!dirty_region.is_empty(), "sanity"); + + #if CARD_REPEAT_HISTO + init_ct_freq_table(_g1->max_capacity()); +@@ -570,7 +621,7 @@ bool G1RemSet::refine_card(jbyte* card_ptr, uint worker_i, + // allocation in this region and making it safe to check the young type. + + bool card_processed = +- r->oops_on_card_seq_iterate_careful(dirtyRegion, ++ r->oops_on_card_seq_iterate_careful(dirty_region, + &filter_then_update_rs_oop_cl, + card_ptr); + +diff --git a/hotspot/src/share/vm/gc_implementation/g1/heapRegion.cpp b/hotspot/src/share/vm/gc_implementation/g1/heapRegion.cpp +index 794911ef6..7c48501f3 100644 +--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegion.cpp ++++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegion.cpp +@@ -375,6 +375,50 @@ void HeapRegion::note_self_forwarding_removal_end(bool during_initial_mark, + _prev_marked_bytes = marked_bytes; + } + ++// Humongous objects are allocated directly in the old-gen. Need ++// special handling for concurrent processing encountering an ++// in-progress allocation. ++static bool do_oops_on_card_in_humongous(MemRegion mr, ++ FilterOutOfRegionClosure* cl, ++ HeapRegion* hr, ++ G1CollectedHeap* g1h) { ++ assert(hr->isHumongous(), "precondition"); ++ HeapRegion* sr = hr->humongous_start_region(); ++ oop obj = oop(sr->bottom()); ++ ++ // If concurrent and klass_or_null is NULL, then space has been ++ // allocated but the object has not yet been published by setting ++ // the klass. That can only happen if the card is stale. However, ++ // we've already set the card clean, so we must return failure, ++ // since the allocating thread could have performed a write to the ++ // card that might be missed otherwise. ++ if (!g1h->is_gc_active() && (obj->klass_or_null_acquire() == NULL)) { ++ return false; ++ } ++ ++ // We have a well-formed humongous object at the start of sr. ++ // Only filler objects follow a humongous object in the containing ++ // regions, and we can ignore those. So only process the one ++ // humongous object. ++ if (!g1h->is_obj_dead(obj, sr)) { ++ if (obj->is_objArray() || (sr->bottom() < mr.start())) { ++ // objArrays are always marked precisely, so limit processing ++ // with mr. Non-objArrays might be precisely marked, and since ++ // it's humongous it's worthwhile avoiding full processing. ++ // However, the card could be stale and only cover filler ++ // objects. That should be rare, so not worth checking for; ++ // instead let it fall out from the bounded iteration. ++ obj->oop_iterate(cl, mr); ++ } else { ++ // If obj is not an objArray and mr contains the start of the ++ // obj, then this could be an imprecise mark, and we need to ++ // process the entire object. ++ obj->oop_iterate(cl); ++ } ++ } ++ return true; ++} ++ + HeapWord* + HeapRegion::object_iterate_mem_careful(MemRegion mr, + ObjectClosure* cl) { +@@ -399,9 +443,6 @@ HeapRegion::object_iterate_mem_careful(MemRegion mr, + } else if (!g1h->is_obj_dead(obj)) { + cl->do_object(obj); + } +- if (cl->abort()) return cur; +- // The check above must occur before the operation below, since an +- // abort might invalidate the "size" operation. + cur += block_size(cur); + } + return NULL; +@@ -411,30 +452,14 @@ bool HeapRegion::oops_on_card_seq_iterate_careful(MemRegion mr, + FilterOutOfRegionClosure* cl, + jbyte* card_ptr) { + assert(card_ptr != NULL, "pre-condition"); ++ assert(MemRegion(bottom(), end()).contains(mr), "Card region not in heap region"); + G1CollectedHeap* g1h = G1CollectedHeap::heap(); + +- // If we're within a stop-world GC, then we might look at a card in a +- // GC alloc region that extends onto a GC LAB, which may not be +- // parseable. Stop such at the "scan_top" of the region. +- if (g1h->is_gc_active()) { +- mr = mr.intersection(MemRegion(bottom(), scan_top())); +- } else { +- mr = mr.intersection(used_region()); +- } +- if (mr.is_empty()) { +- return true; +- } +- // Otherwise, find the obj that extends onto mr.start(). +- +- // The intersection of the incoming mr (for the card) and the +- // allocated part of the region is non-empty. This implies that +- // we have actually allocated into this region. The code in +- // G1CollectedHeap.cpp that allocates a new region sets the +- // is_young tag on the region before allocating. Thus we +- // safely know if this region is young. +- if (is_young()) { +- return true; ++ // Special handling for humongous regions. ++ if (isHumongous()) { ++ return do_oops_on_card_in_humongous(mr, cl, this, g1h); + } ++ assert(is_old(), "precondition"); + + // We can only clean the card here, after we make the decision that + // the card is not young. +@@ -446,50 +471,37 @@ bool HeapRegion::oops_on_card_seq_iterate_careful(MemRegion mr, + HeapWord* const start = mr.start(); + HeapWord* const end = mr.end(); + +- // Update BOT as needed while finding start of (potential) object. ++ // Find the obj that extends onto mr.start(). ++ // Update BOT as needed while finding start of (possibly dead) ++ // object containing the start of the region. + HeapWord* cur = block_start(start); +- assert(cur <= start, "Postcondition"); +- +- oop obj; +- +- HeapWord* next = cur; +- do { +- cur = next; +- obj = oop(cur); +- if (obj->klass_or_null() == NULL) { +- // Ran into an unparseable point. +- assert(!g1h->is_gc_active(), +- err_msg("Unparsable heap during GC at " PTR_FORMAT, p2i(cur))); +- return false; +- } +- // Otherwise... +- next = cur + block_size(cur); +- } while (next <= start); +- +- // If we finish the above loop...We have a parseable object that +- // begins on or before the start of the memory region, and ends +- // inside or spans the entire region. +- assert(cur <= start, "Loop postcondition"); +- assert(obj->klass_or_null() != NULL, "Loop postcondition"); ++#ifdef ASSERT ++ { ++ assert(cur <= start, ++ err_msg("cur: " PTR_FORMAT ", start: " PTR_FORMAT, p2i(cur), p2i(start))); ++ HeapWord* next = cur + block_size(cur); ++ assert(start < next, ++ err_msg("start: " PTR_FORMAT ", next: " PTR_FORMAT, p2i(start), p2i(next))); ++ } ++#endif + + do { +- obj = oop(cur); +- assert((cur + block_size(cur)) > (HeapWord*)obj, "Loop invariant"); +- if (obj->klass_or_null() == NULL) { +- // Ran into an unparseable point. +- assert(!g1h->is_gc_active(), +- err_msg("Unparsable heap during GC at " PTR_FORMAT, p2i(cur))); +- return false; +- } +- +- // Advance the current pointer. "obj" still points to the object to iterate. +- cur = cur + block_size(cur); ++ oop obj = oop(cur); ++ assert(obj->is_oop(true), err_msg("Not an oop at " PTR_FORMAT, p2i(obj))); ++ assert(obj->klass_or_null() != NULL, ++ err_msg("Unparsable heap at " PTR_FORMAT, p2i(obj))); ++ ++ if (g1h->is_obj_dead(obj, this)) { ++ // Carefully step over dead object. ++ cur += block_size(cur); ++ } else { ++ // Step over live object, and process its references. ++ cur += obj->size(); ++ // Non-objArrays are usually marked imprecise at the object ++ // start, in which case we need to iterate over them in full. ++ // objArrays are precisely marked, but can still be iterated ++ // over in full if completely covered. + +- if (!g1h->is_obj_dead(obj)) { +- // Non-objArrays are sometimes marked imprecise at the object start. We +- // always need to iterate over them in full. +- // We only iterate over object arrays in full if they are completely contained +- // in the memory region. + if (!obj->is_objArray() || (((HeapWord*)obj) >= start && cur <= end)) { + obj->oop_iterate(cl); + } else { +diff --git a/hotspot/src/share/vm/gc_implementation/g1/heapRegion.hpp b/hotspot/src/share/vm/gc_implementation/g1/heapRegion.hpp +index 52ef1d0d2..8a45b3915 100644 +--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegion.hpp ++++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegion.hpp +@@ -422,6 +422,8 @@ class HeapRegion: public G1OffsetTableContigSpace { + + bool is_old() const { return _type.is_old(); } + ++ bool is_old_or_humongous() const { return _type.is_old_or_humongous(); } ++ + // For a humongous region, region in which it starts. + HeapRegion* humongous_start_region() const { + return _humongous_start_region; +diff --git a/hotspot/src/share/vm/gc_implementation/g1/heapRegionType.hpp b/hotspot/src/share/vm/gc_implementation/g1/heapRegionType.hpp +index a9a4fbc25..007dabf19 100644 +--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegionType.hpp ++++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegionType.hpp +@@ -111,6 +111,9 @@ public: + + bool is_old() const { return get() == OldTag; } + ++ bool is_old_or_humongous() const { return (get() & (OldTag | HumMask)) != 0; } ++ ++ + // Setters + + void set_free() { set(FreeTag); } +diff --git a/hotspot/src/share/vm/gc_implementation/parNew/parNewGeneration.cpp b/hotspot/src/share/vm/gc_implementation/parNew/parNewGeneration.cpp +index f05b4f177..9481dba10 100644 +--- a/hotspot/src/share/vm/gc_implementation/parNew/parNewGeneration.cpp ++++ b/hotspot/src/share/vm/gc_implementation/parNew/parNewGeneration.cpp +@@ -1551,22 +1551,25 @@ bool ParNewGeneration::take_from_overflow_list_work(ParScanThreadState* par_scan + return false; + } + assert(prefix != NULL && prefix != BUSY, "Error"); +- size_t i = 1; + oop cur = prefix; +- while (i < objsFromOverflow && cur->klass_or_null() != NULL) { +- i++; cur = cur->list_ptr_from_klass(); ++ for (size_t i = 1; i < objsFromOverflow; ++i) { ++ oop next = cur->list_ptr_from_klass(); ++ if (next == NULL) break; ++ cur = next; + } ++ assert(cur != NULL, "Loop postcondition"); + + // Reattach remaining (suffix) to overflow list +- if (cur->klass_or_null() == NULL) { ++ oop suffix = cur->list_ptr_from_klass(); ++ if (suffix == NULL) { + // Write back the NULL in lieu of the BUSY we wrote + // above and it is still the same value. + if (_overflow_list == BUSY) { + (void) Atomic::cmpxchg_ptr(NULL, &_overflow_list, BUSY); + } + } else { +- assert(cur->klass_or_null() != (Klass*)(address)BUSY, "Error"); +- oop suffix = cur->list_ptr_from_klass(); // suffix will be put back on global list ++ assert(suffix != BUSY, "Error"); ++ // suffix will be put back on global list + cur->set_klass_to_list_ptr(NULL); // break off suffix + // It's possible that the list is still in the empty(busy) state + // we left it in a short while ago; in that case we may be +@@ -1586,8 +1589,10 @@ bool ParNewGeneration::take_from_overflow_list_work(ParScanThreadState* par_scan + // Too bad, someone else got in in between; we'll need to do a splice. + // Find the last item of suffix list + oop last = suffix; +- while (last->klass_or_null() != NULL) { +- last = last->list_ptr_from_klass(); ++ while (true) { ++ oop next = last->list_ptr_from_klass(); ++ if (next == NULL) break; ++ last = next; + } + // Atomically prepend suffix to current overflow list + observed_overflow_list = _overflow_list; +-- +2.19.0 + diff --git a/8204947.patch b/8204947.patch index 26ffa6219f6977b7d3e9babfb9d7b7c91b3b00ca..f444efce8d8e959410a90e530a2fb277ec44da22 100644 --- a/8204947.patch +++ b/8204947.patch @@ -774,14 +774,46 @@ diff --git a/hotspot/src/share/vm/utilities/taskqueue.hpp b/hotspot/src/share/vm index c8223b2eb..0f1376b49 100644 --- a/hotspot/src/share/vm/utilities/taskqueue.hpp +++ b/hotspot/src/share/vm/utilities/taskqueue.hpp -@@ -620,8 +632,8 @@ public: +@@ -503,6 +503,8 @@ protected: + public: + // Returns "true" if some TaskQueue in the set contains a task. + virtual bool peek() = 0; ++ // Tasks in queue ++ virtual uint tasks() const = 0; + virtual size_t tasks() = 0; + }; + +@@ -540,6 +542,7 @@ public: + bool steal(uint queue_num, int* seed, E& t); + + bool peek(); ++ uint tasks() const; + size_t tasks(); + + uint size() const { return _n; } +@@ -609,6 +612,15 @@ size_t GenericTaskQueueSet::tasks() { + return n; + } + ++template ++uint GenericTaskQueueSet::tasks() const { ++ uint n = 0; ++ for (uint j = 0; j < _n; j++) { ++ n += _queues[j]->size(); ++ } ++ return n; ++} ++ + // When to terminate from the termination protocol. + class TerminatorTerminator: public CHeapObj { + public: +@@ -620,7 +632,7 @@ public: #undef TRACESPINNING -class ParallelTaskTerminator: public StackObj { --private: +class ParallelTaskTerminator: public CHeapObj { -+protected: + protected: int _n_threads; TaskQueueSetSuper* _queue_set; @@ -656,7 +668,7 @@ public: diff --git a/8205921.patch b/8205921.patch index 6c4d7a599ba5169f9700234b3a8b8c75c17a1fa5..747077e785000e47d8dc55417cc371ec5229df53 100644 --- a/8205921.patch +++ b/8205921.patch @@ -20,6 +20,7 @@ Bug url: https://bugs.openjdk.java.net/browse/JDK-8205921 .../parallelScavenge/psCompactionManager.hpp | 12 +- .../parallelScavenge/psPromotionManager.hpp | 4 +- .../parallelScavenge/psTasks.cpp | 3 +- + .../shenandoah/shenandoahConcurrentMark.cpp | 3 +- hotspot/src/share/vm/utilities/taskqueue.cpp | 18 --- hotspot/src/share/vm/utilities/taskqueue.hpp | 105 ++++++++++++++---- 16 files changed, 113 insertions(+), 92 deletions(-) @@ -388,6 +389,27 @@ index f829e9344..4fe869fd6 100644 TASKQUEUE_STATS_ONLY(pm->record_steal(p)); pm->process_popped_location_depth(p); pm->drain_stacks_depth(true); +diff --git a/hotspot/src/share/vm/gc_implementation/shenandoah/shenandoahConcurrentMark.cpp b/hotspot/src/share/vm/gc_implementation/shenandoah/shenandoahConcurrentMark.cpp +index 85bbea6cd..afcb0dd4a 100644 +--- a/hotspot/src/share/vm/gc_implementation/shenandoah/shenandoahConcurrentMark.cpp ++++ b/hotspot/src/share/vm/gc_implementation/shenandoah/shenandoahConcurrentMark.cpp +@@ -939,7 +939,6 @@ void ShenandoahConcurrentMark::mark_loop_prework(uint w, ShenandoahTaskTerminato + + template + void ShenandoahConcurrentMark::mark_loop_work(T* cl, ShenandoahLiveData* live_data, uint worker_id, ShenandoahTaskTerminator *terminator) { +- int seed = 17; + uintx stride = ShenandoahMarkLoopStride; + + ShenandoahHeap* heap = ShenandoahHeap::heap(); +@@ -999,7 +998,7 @@ void ShenandoahConcurrentMark::mark_loop_work(T* cl, ShenandoahLiveData* live_da + uint work = 0; + for (uint i = 0; i < stride; i++) { + if (q->pop(t) || +- queues->steal(worker_id, &seed, t)) { ++ queues->steal(worker_id, t)) { + do_task(q, cl, live_data, &t); + work++; + } else { diff --git a/hotspot/src/share/vm/utilities/taskqueue.cpp b/hotspot/src/share/vm/utilities/taskqueue.cpp index 0f4dcc90b..37f4066ab 100644 --- a/hotspot/src/share/vm/utilities/taskqueue.cpp @@ -493,10 +515,10 @@ index 0f1376b49..77556a7d4 100644 public: // Returns "true" if some TaskQueue in the set contains a task. virtual bool peek() = 0; -@@ -517,27 +557,23 @@ private: +@@ -520,27 +560,23 @@ private: public: typedef typename T::element_type E; - + - GenericTaskQueueSet(int n) : _n(n) { + GenericTaskQueueSet(uint n) : _n(n) { typedef T* GenericTaskQueuePtr; @@ -506,14 +528,14 @@ index 0f1376b49..77556a7d4 100644 _queues[i] = NULL; } } - + - bool steal_best_of_2(uint queue_num, int* seed, E& t); + bool steal_best_of_2(uint queue_num, E& t); - + void register_queue(uint i, T* q); - + T* queue(uint n); - + - // The thread with queue number "queue_num" (and whose random number seed is - // at "seed") is trying to steal a task from some other queue. (It may try - // several queues, according to some configuration parameter.) If some steal @@ -525,8 +547,8 @@ index 0f1376b49..77556a7d4 100644 + // Returns if stealing succeeds, and sets "t" to the stolen task. + bool steal(uint queue_num, E& t); bool peek(); - }; - + uint tasks() const; + size_t tasks(); @@ -560,9 +596,9 @@ GenericTaskQueueSet::queue(uint i) { } diff --git a/Ddot-intrinsic-implement.patch b/Ddot-intrinsic-implement.patch index 81034ca45fb60058b8390258e52c5fe7d26406d4..2b091a517c5c4b04ee7549857a4bad3d4a7415d4 100644 --- a/Ddot-intrinsic-implement.patch +++ b/Ddot-intrinsic-implement.patch @@ -3,9 +3,9 @@ index 1e9b1cb91..c0fd37d05 100644 --- a/hotspot/src/cpu/aarch64/vm/assembler_aarch64.hpp +++ b/hotspot/src/cpu/aarch64/vm/assembler_aarch64.hpp @@ -2061,6 +2061,14 @@ public: - ld_st(Vt, T, a, op1, op2); \ + ld_st(Vt, T, a, op1, op2); \ } - + + void ld1_d(FloatRegister Vt, int index, const Address &a) { + starti; + assert(index == 0 || index == 1, "Index must be 0 or 1 for Vx.2D"); @@ -164,16 +164,16 @@ diff --git a/hotspot/src/cpu/aarch64/vm/macroAssembler_aarch64.hpp b/hotspot/src index 388177589..1abc7e3b0 100644 --- a/hotspot/src/cpu/aarch64/vm/macroAssembler_aarch64.hpp +++ b/hotspot/src/cpu/aarch64/vm/macroAssembler_aarch64.hpp -@@ -1173,6 +1181,9 @@ public: +@@ -1180,6 +1180,9 @@ public: Register table0, Register table1, Register table2, Register table3, bool upper = false); - + + void f2j_ddot(Register n, Register dx, Register incx, + Register dy, Register incy, Register temp_reg); + void string_compare(Register str1, Register str2, - Register cnt1, Register cnt2, Register result, - Register tmp1); + Register cnt1, Register cnt2, Register result, + Register tmp1); @@ -1236,6 +1239,11 @@ private: // Uses rscratch2 if the address is not directly reachable Address spill_address(int size, int offset, Register tmp=rscratch2); @@ -190,6 +190,14 @@ diff --git a/hotspot/src/cpu/aarch64/vm/stubGenerator_aarch64.cpp b/hotspot/src/ index 0d73c0c0c..337d5c1dd 100644 --- a/hotspot/src/cpu/aarch64/vm/stubGenerator_aarch64.cpp +++ b/hotspot/src/cpu/aarch64/vm/stubGenerator_aarch64.cpp +@@ -45,6 +45,7 @@ + + #include "stubRoutines_aarch64.hpp" + ++ + #ifdef COMPILER2 + #include "opto/runtime.hpp" + #endif @@ -3220,6 +3221,39 @@ class StubGenerator: public StubCodeGenerator { return start; } diff --git a/G1-memory-uncommit.patch b/G1-memory-uncommit.patch index fefcf1bb333af990b1ba0010a55eb1c6626f3ca0..fd8ccff06f682e70dcf0bc52ecbed67d1d6ce194 100644 --- a/G1-memory-uncommit.patch +++ b/G1-memory-uncommit.patch @@ -3,13 +3,13 @@ index 84f0a4ac..b38ee52e 100644 --- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/gc_interface/GCCause.java +++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/gc_interface/GCCause.java @@ -54,6 +54,7 @@ public enum GCCause { - + _g1_inc_collection_pause ("G1 Evacuation Pause"), _g1_humongous_allocation ("G1 Humongous Allocation"), + _g1_periodic_gc ("G1 Periodic GC"), - - _last_ditch_collection ("Last ditch collection"), - _last_gc_cause ("ILLEGAL VALUE - last gc cause - ILLEGAL VALUE"); + + _shenandoah_allocation_failure_evac ("Allocation Failure During Evacuation"), + _shenandoah_stop_vm ("Stopping VM"), diff --git a/hotspot/make/bsd/makefiles/mapfile-vers-debug b/hotspot/make/bsd/makefiles/mapfile-vers-debug index 49a70edc..00651d42 100644 --- a/hotspot/make/bsd/makefiles/mapfile-vers-debug @@ -1669,25 +1669,38 @@ index bdac7cb0..283df9bf 100644 @@ -100,6 +100,9 @@ const char* GCCause::to_string(GCCause::Cause cause) { case _g1_humongous_allocation: return "G1 Humongous Allocation"; - + + case _g1_periodic_collection: + return "G1 Periodic Collection"; + - case _last_ditch_collection: - return "Last ditch collection"; - + case _shenandoah_allocation_failure_evac: + return "Allocation Failure During Evacuation"; + diff --git a/hotspot/src/share/vm/gc_interface/gcCause.hpp b/hotspot/src/share/vm/gc_interface/gcCause.hpp index 29408d77..5be14548 100644 --- a/hotspot/src/share/vm/gc_interface/gcCause.hpp +++ b/hotspot/src/share/vm/gc_interface/gcCause.hpp @@ -72,6 +72,7 @@ class GCCause : public AllStatic { - + _g1_inc_collection_pause, _g1_humongous_allocation, + _g1_periodic_collection, - - _last_ditch_collection, - _last_gc_cause + + _shenandoah_stop_vm, + _shenandoah_metadata_gc_clear_softrefs, +diff --git a/hotspot/src/share/vm/memory/threadLocalAllocBuffer.hpp b/hotspot/src/share/vm/memory/threadLocalAllocBuffer.hpp +index 0f8727fe..8bbcbda4 100644 +--- a/hotspot/src/share/vm/memory/threadLocalAllocBuffer.hpp ++++ b/hotspot/src/share/vm/memory/threadLocalAllocBuffer.hpp +@@ -98,7 +98,7 @@ private: + static GlobalTLABStats* global_stats() { return _global_stats; } + + public: +- ThreadLocalAllocBuffer() : _allocation_fraction(TLABAllocationWeight), _allocated_before_last_gc(0), _initialized(false) { ++ ThreadLocalAllocBuffer() : _allocation_fraction(TLABAllocationWeight), _allocated_before_last_gc(0), _initialized(false), _gclab(false) { + // do nothing. tlabs must be inited by initialize() calls + } + diff --git a/hotspot/src/share/vm/prims/jvm.cpp b/hotspot/src/share/vm/prims/jvm.cpp index de01fefd..e149ca64 100644 --- a/hotspot/src/share/vm/prims/jvm.cpp @@ -1759,16 +1772,16 @@ diff --git a/hotspot/src/share/vm/runtime/thread.cpp b/hotspot/src/share/vm/runt index 3db27350..7374eee5 100644 --- a/hotspot/src/share/vm/runtime/thread.cpp +++ b/hotspot/src/share/vm/runtime/thread.cpp -@@ -98,6 +98,7 @@ - #if INCLUDE_ALL_GCS +@@ -99,6 +99,7 @@ + #include "gc_implementation/shenandoah/shenandoahControlThread.hpp" #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepThread.hpp" #include "gc_implementation/g1/concurrentMarkThread.inline.hpp" +#include "gc_implementation/g1/g1CollectedHeap.hpp" #include "gc_implementation/parallelScavenge/pcTasks.hpp" #endif // INCLUDE_ALL_GCS #ifdef COMPILER1 -@@ -3605,6 +3619,7 @@ jint Threads::create_vm(JavaVMInitArgs* args, bool* canTryAgain) { - ConcurrentMarkSweepThread::makeSurrogateLockerThread(THREAD); +@@ -3677,6 +3678,7 @@ jint Threads::create_vm(JavaVMInitArgs* args, bool* canTryAgain) { + ShenandoahControlThread::makeSurrogateLockerThread(THREAD); } else { ConcurrentMarkThread::makeSurrogateLockerThread(THREAD); + G1CollectedHeap::heap()->init_periodic_gc_thread(); diff --git a/Remove-unused-GenericTaskQueueSet-T-F-tasks.patch b/Remove-unused-GenericTaskQueueSet-T-F-tasks.patch new file mode 100644 index 0000000000000000000000000000000000000000..1eff0c0b064bb03e757878cc821fb2cf8c26dfda --- /dev/null +++ b/Remove-unused-GenericTaskQueueSet-T-F-tasks.patch @@ -0,0 +1,51 @@ +From 79a2de08f6a6aa5113e730bd9bc58229f7a2da14 Mon Sep 17 00:00:00 2001 +Date: Fri, 22 Jan 2021 16:21:34 +0800 +Subject: Remove unused GenericTaskQueueSet::tasks() + +Summary: : remove unused GenericTaskQueueSet::tasks() +LLT: NA +Bug url: NA +--- + hotspot/src/share/vm/utilities/taskqueue.hpp | 12 ------------ + 1 file changed, 12 deletions(-) + +diff --git a/hotspot/src/share/vm/utilities/taskqueue.hpp b/hotspot/src/share/vm/utilities/taskqueue.hpp +index 77556a7d4..3df7744dc 100644 +--- a/hotspot/src/share/vm/utilities/taskqueue.hpp ++++ b/hotspot/src/share/vm/utilities/taskqueue.hpp +@@ -543,8 +543,6 @@ class TaskQueueSetSuper { + public: + // Returns "true" if some TaskQueue in the set contains a task. + virtual bool peek() = 0; +- // Tasks in queue +- virtual uint tasks() const = 0; + virtual size_t tasks() = 0; + }; + +@@ -578,7 +576,6 @@ public: + // Returns if stealing succeeds, and sets "t" to the stolen task. + bool steal(uint queue_num, E& t); + bool peek(); +- uint tasks() const; + size_t tasks(); + + uint size() const { return _n; } +@@ -677,15 +674,6 @@ size_t GenericTaskQueueSet::tasks() { + return n; + } + +-template +-uint GenericTaskQueueSet::tasks() const { +- uint n = 0; +- for (uint j = 0; j < _n; j++) { +- n += _queues[j]->size(); +- } +- return n; +-} +- + // When to terminate from the termination protocol. + class TerminatorTerminator: public CHeapObj { + public: +-- +2.19.0 + diff --git a/jdk8u-jdk8u-jdk8u292-b01.tar.xz b/aarch64-port-jdk8u-shenandoah-aarch64-shenandoah-jdk8u282-b08.tar.xz old mode 100755 new mode 100644 similarity index 81% rename from jdk8u-jdk8u-jdk8u292-b01.tar.xz rename to aarch64-port-jdk8u-shenandoah-aarch64-shenandoah-jdk8u282-b08.tar.xz index ba5f3e9c34d5e338d14c3777c331d729955085ba..67ab6294aa04457535e006dbd2dd61c40cfb3fa6 Binary files a/jdk8u-jdk8u-jdk8u292-b01.tar.xz and b/aarch64-port-jdk8u-shenandoah-aarch64-shenandoah-jdk8u282-b08.tar.xz differ diff --git a/delete-untrustworthy-cacert-files.patch b/delete-untrustworthy-cacert-files.patch new file mode 100644 index 0000000000000000000000000000000000000000..5c96039f5832cd63e535fc0ee5e97b6f718bc5e3 --- /dev/null +++ b/delete-untrustworthy-cacert-files.patch @@ -0,0 +1,261 @@ +From 00a5f242451e72d32e29156bb132ceb4b78cf719 Mon Sep 17 00:00:00 2001 +Date: Tue, 26 Jan 2021 16:46:28 +0800 +Subject: delete untrustworthy cacert files + +Summary: : delete untrustworthy cacert files +LLT: jtreg -nr -va jdk/test/sun/security/lib/cacerts/VerifyCACerts.java +Bug url: NA + +--- + jdk/make/data/cacerts/addtrustexternalca | 32 ------------------ + jdk/make/data/cacerts/addtrustqualifiedca | 32 ------------------ + jdk/make/data/cacerts/thawtepremiumserverca | 27 --------------- + jdk/make/data/cacerts/utnuserfirstobjectca | 33 ------------------- + jdk/make/data/cacerts/verisigntsaca | 24 -------------- + .../security/lib/cacerts/VerifyCACerts.java | 25 +++----------- + 6 files changed, 5 insertions(+), 168 deletions(-) + delete mode 100644 jdk/make/data/cacerts/addtrustexternalca + delete mode 100644 jdk/make/data/cacerts/addtrustqualifiedca + delete mode 100644 jdk/make/data/cacerts/thawtepremiumserverca + delete mode 100644 jdk/make/data/cacerts/utnuserfirstobjectca + delete mode 100644 jdk/make/data/cacerts/verisigntsaca + +diff --git a/jdk/make/data/cacerts/addtrustexternalca b/jdk/make/data/cacerts/addtrustexternalca +deleted file mode 100644 +index ad84cad96..000000000 +--- a/jdk/make/data/cacerts/addtrustexternalca ++++ /dev/null +@@ -1,32 +0,0 @@ +-Owner: CN=AddTrust External CA Root, OU=AddTrust External TTP Network, O=AddTrust AB, C=SE +-Issuer: CN=AddTrust External CA Root, OU=AddTrust External TTP Network, O=AddTrust AB, C=SE +-Serial number: 1 +-Valid from: Tue May 30 10:48:38 GMT 2000 until: Sat May 30 10:48:38 GMT 2020 +-Signature algorithm name: SHA1withRSA +-Subject Public Key Algorithm: 2048-bit RSA key +-Version: 3 +------BEGIN CERTIFICATE----- +-MIIENjCCAx6gAwIBAgIBATANBgkqhkiG9w0BAQUFADBvMQswCQYDVQQGEwJTRTEU +-MBIGA1UEChMLQWRkVHJ1c3QgQUIxJjAkBgNVBAsTHUFkZFRydXN0IEV4dGVybmFs +-IFRUUCBOZXR3b3JrMSIwIAYDVQQDExlBZGRUcnVzdCBFeHRlcm5hbCBDQSBSb290 +-MB4XDTAwMDUzMDEwNDgzOFoXDTIwMDUzMDEwNDgzOFowbzELMAkGA1UEBhMCU0Ux +-FDASBgNVBAoTC0FkZFRydXN0IEFCMSYwJAYDVQQLEx1BZGRUcnVzdCBFeHRlcm5h +-bCBUVFAgTmV0d29yazEiMCAGA1UEAxMZQWRkVHJ1c3QgRXh0ZXJuYWwgQ0EgUm9v +-dDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALf3GjPm8gAELTngTlvt +-H7xsD821+iO2zt6bETOXpClMfZOfvUq8k+0DGuOPz+VtUFrWlymUWoCwSXrbLpX9 +-uMq/NzgtHj6RQa1wVsfwTz/oMp50ysiQVOnGXw94nZpAPA6sYapeFI+eh6FqUNzX +-mk6vBbOmcZSccbNQYArHE504B4YCqOmoaSYYkKtMsE8jqzpPhNjfzp/haW+710LX +-a0Tkx63ubUFfclpxCDezeWWkWaCUN/cALw3CknLa0Dhy2xSoRcRdKn23tNbE7qzN +-E0S3ySvdQwAl+mG5aWpYIxG3pzOPVnVZ9c0p10a3CitlttNCbxWyuHv77+ldU9U0 +-WicCAwEAAaOB3DCB2TAdBgNVHQ4EFgQUrb2YejS0Jvf6xCZU7wO94CTLVBowCwYD +-VR0PBAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wgZkGA1UdIwSBkTCBjoAUrb2YejS0 +-Jvf6xCZU7wO94CTLVBqhc6RxMG8xCzAJBgNVBAYTAlNFMRQwEgYDVQQKEwtBZGRU +-cnVzdCBBQjEmMCQGA1UECxMdQWRkVHJ1c3QgRXh0ZXJuYWwgVFRQIE5ldHdvcmsx +-IjAgBgNVBAMTGUFkZFRydXN0IEV4dGVybmFsIENBIFJvb3SCAQEwDQYJKoZIhvcN +-AQEFBQADggEBALCb4IUlwtYj4g+WBpKdQZic2YR5gdkeWxQHIzZlj7DYd7usQWxH +-YINRsPkyPef89iYTx4AWpb9a/IfPeHmJIZriTAcKhjW88t5RxNKWt9x+Tu5w/Rw5 +-6wwCURQtjr0W4MHfRnXnJK3s9EK0hZNwEGe6nQY1ShjTK3rMUUKhemPR5ruhxSvC +-Nr4TDea9Y355e6cJDUCrat2PisP29owaQgVR1EX1n6diIWgVIEM8med8vSTYqZEX +-c4g/VhsxOBi0cQ+azcgOno4uG+GMmIPLHzHxREzGBHNJdmAPx/i9F4BrLunMTA5a +-mnkPIAou1Z5jJh5VkpTYghdae9C8x49OhgQ= +------END CERTIFICATE----- +diff --git a/jdk/make/data/cacerts/addtrustqualifiedca b/jdk/make/data/cacerts/addtrustqualifiedca +deleted file mode 100644 +index 0c62d44c7..000000000 +--- a/jdk/make/data/cacerts/addtrustqualifiedca ++++ /dev/null +@@ -1,32 +0,0 @@ +-Owner: CN=AddTrust Qualified CA Root, OU=AddTrust TTP Network, O=AddTrust AB, C=SE +-Issuer: CN=AddTrust Qualified CA Root, OU=AddTrust TTP Network, O=AddTrust AB, C=SE +-Serial number: 1 +-Valid from: Tue May 30 10:44:50 GMT 2000 until: Sat May 30 10:44:50 GMT 2020 +-Signature algorithm name: SHA1withRSA +-Subject Public Key Algorithm: 2048-bit RSA key +-Version: 3 +------BEGIN CERTIFICATE----- +-MIIEHjCCAwagAwIBAgIBATANBgkqhkiG9w0BAQUFADBnMQswCQYDVQQGEwJTRTEU +-MBIGA1UEChMLQWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFkZFRydXN0IFRUUCBOZXR3 +-b3JrMSMwIQYDVQQDExpBZGRUcnVzdCBRdWFsaWZpZWQgQ0EgUm9vdDAeFw0wMDA1 +-MzAxMDQ0NTBaFw0yMDA1MzAxMDQ0NTBaMGcxCzAJBgNVBAYTAlNFMRQwEgYDVQQK +-EwtBZGRUcnVzdCBBQjEdMBsGA1UECxMUQWRkVHJ1c3QgVFRQIE5ldHdvcmsxIzAh +-BgNVBAMTGkFkZFRydXN0IFF1YWxpZmllZCBDQSBSb290MIIBIjANBgkqhkiG9w0B +-AQEFAAOCAQ8AMIIBCgKCAQEA5B6a/twJWoekn0e+EV+vhDTbYjx5eLfpMLXsDBwq +-xBb/4Oxx64r1EW7tTw2R0hIYLUkVAcKkIhPHEWT/IhKauY5cLwjPcWqzZwFZ8V1G +-87B4pfYOQnrjfxvM0PC3KP0q6p6zsLkEqv32x7SxuCqg+1jxGaBvcCV+PmlKfw8i +-2O+tCBGaKZnhqkRFmhJePp1tUvznoD1oL/BLcHwTOK28FSXx1s6rosAx1i+f4P8U +-WfyEk9mHfExUE+uf0S0R+Bg6Ot4l2ffTQO2kBhLEO+GRwVY18BTcZTYJbqukB8c1 +-0cIDMzZbdSZtQvESa0NvS3GU+jQd7RNuyoB/mC9suWXY6QIDAQABo4HUMIHRMB0G +-A1UdDgQWBBQ5lYtii1zJ1IC6WA+XPxUIQ8yYpzALBgNVHQ8EBAMCAQYwDwYDVR0T +-AQH/BAUwAwEB/zCBkQYDVR0jBIGJMIGGgBQ5lYtii1zJ1IC6WA+XPxUIQ8yYp6Fr +-pGkwZzELMAkGA1UEBhMCU0UxFDASBgNVBAoTC0FkZFRydXN0IEFCMR0wGwYDVQQL +-ExRBZGRUcnVzdCBUVFAgTmV0d29yazEjMCEGA1UEAxMaQWRkVHJ1c3QgUXVhbGlm +-aWVkIENBIFJvb3SCAQEwDQYJKoZIhvcNAQEFBQADggEBABmrder4i2VhlRO6aQTv +-hsoToMeqT2QbPxj2qC0sVY8FtzDqQmodwCVRLae/DLPt7wh/bDxGGuoYQ992zPlm +-hpwsaPXpF/gxsxjE1kh9I0xowX67ARRvxdlu3rsEQmr49lx95dr6h+sNNVJn0J6X +-dgWTP5XHAeZpVTh/EGGZyeNfpso+gmNIquIISD6q8rKFYqa0p9m9N5xotS1WfbC3 +-P6CxB9bpT9zeRXEwMn8bLgn5v1Kh7sKAPgZcLlVAwRv1cEWw3F369nJad9Jjzc9Y +-iQBCYz95OdBEsIJuQRno3eDBiFrRHnGTHyQwdOUeqN48Jzd/g66ed8/wMLH/S5no +-xqE= +------END CERTIFICATE----- +diff --git a/jdk/make/data/cacerts/thawtepremiumserverca b/jdk/make/data/cacerts/thawtepremiumserverca +deleted file mode 100644 +index 2df456ab0..000000000 +--- a/jdk/make/data/cacerts/thawtepremiumserverca ++++ /dev/null +@@ -1,27 +0,0 @@ +-Owner: EMAILADDRESS=premium-server@thawte.com, CN=Thawte Premium Server CA, OU=Certification Services Division, O=Thawte Consulting cc, L=Cape Town, ST=Western Cape, C=ZA +-Issuer: EMAILADDRESS=premium-server@thawte.com, CN=Thawte Premium Server CA, OU=Certification Services Division, O=Thawte Consulting cc, L=Cape Town, ST=Western Cape, C=ZA +-Serial number: 36122296c5e338a520a1d25f4cd70954 +-Valid from: Thu Aug 01 00:00:00 GMT 1996 until: Fri Jan 01 23:59:59 GMT 2021 +-Signature algorithm name: SHA1withRSA +-Subject Public Key Algorithm: 1024-bit RSA key +-Version: 3 +------BEGIN CERTIFICATE----- +-MIIDNjCCAp+gAwIBAgIQNhIilsXjOKUgodJfTNcJVDANBgkqhkiG9w0BAQUFADCB +-zjELMAkGA1UEBhMCWkExFTATBgNVBAgTDFdlc3Rlcm4gQ2FwZTESMBAGA1UEBxMJ +-Q2FwZSBUb3duMR0wGwYDVQQKExRUaGF3dGUgQ29uc3VsdGluZyBjYzEoMCYGA1UE +-CxMfQ2VydGlmaWNhdGlvbiBTZXJ2aWNlcyBEaXZpc2lvbjEhMB8GA1UEAxMYVGhh +-d3RlIFByZW1pdW0gU2VydmVyIENBMSgwJgYJKoZIhvcNAQkBFhlwcmVtaXVtLXNl +-cnZlckB0aGF3dGUuY29tMB4XDTk2MDgwMTAwMDAwMFoXDTIxMDEwMTIzNTk1OVow +-gc4xCzAJBgNVBAYTAlpBMRUwEwYDVQQIEwxXZXN0ZXJuIENhcGUxEjAQBgNVBAcT +-CUNhcGUgVG93bjEdMBsGA1UEChMUVGhhd3RlIENvbnN1bHRpbmcgY2MxKDAmBgNV +-BAsTH0NlcnRpZmljYXRpb24gU2VydmljZXMgRGl2aXNpb24xITAfBgNVBAMTGFRo +-YXd0ZSBQcmVtaXVtIFNlcnZlciBDQTEoMCYGCSqGSIb3DQEJARYZcHJlbWl1bS1z +-ZXJ2ZXJAdGhhd3RlLmNvbTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA0jY2 +-aovXwlue2oFBYo847kkEVdbQ7xwblRZH7xhINTpS9CtqBo87L+pW46+GjZ4X9560 +-ZXUCTe/LCaIhUdib0GfQug2SBhRz1JPLlyoAnFxODLz6FVL88kRu2hFKbgifLy3j +-+ao6hnO2RlNYyIkFvYMRuHM/qgeN9EJN50CdHDcCAwEAAaMTMBEwDwYDVR0TAQH/ +-BAUwAwEB/zANBgkqhkiG9w0BAQUFAAOBgQBlkKyID1bZ5jA01CbH0FDxkt5r1DmI +-CSLGpmODA/eZd9iy5Ri4XWPz1HP7bJyZePFLeH0ZJMMrAoT4vCLZiiLXoPxx7JGH +-IPG47LHlVYCsPVLIOQ7C8MAFT9aCdYy9X9LcdpoFEsmvcsPcJX6kTY4XpeCHf+Ga +-WuFg3GQjPEIuTQ== +------END CERTIFICATE----- +diff --git a/jdk/make/data/cacerts/utnuserfirstobjectca b/jdk/make/data/cacerts/utnuserfirstobjectca +deleted file mode 100644 +index 80a0b5c23..000000000 +--- a/jdk/make/data/cacerts/utnuserfirstobjectca ++++ /dev/null +@@ -1,33 +0,0 @@ +-Owner: CN=UTN-USERFirst-Object, OU=http://www.usertrust.com, O=The USERTRUST Network, L=Salt Lake City, ST=UT, C=US +-Issuer: CN=UTN-USERFirst-Object, OU=http://www.usertrust.com, O=The USERTRUST Network, L=Salt Lake City, ST=UT, C=US +-Serial number: 44be0c8b500024b411d3362de0b35f1b +-Valid from: Fri Jul 09 18:31:20 GMT 1999 until: Tue Jul 09 18:40:36 GMT 2019 +-Signature algorithm name: SHA1withRSA +-Subject Public Key Algorithm: 2048-bit RSA key +-Version: 3 +------BEGIN CERTIFICATE----- +-MIIEZjCCA06gAwIBAgIQRL4Mi1AAJLQR0zYt4LNfGzANBgkqhkiG9w0BAQUFADCB +-lTELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAlVUMRcwFQYDVQQHEw5TYWx0IExha2Ug +-Q2l0eTEeMBwGA1UEChMVVGhlIFVTRVJUUlVTVCBOZXR3b3JrMSEwHwYDVQQLExho +-dHRwOi8vd3d3LnVzZXJ0cnVzdC5jb20xHTAbBgNVBAMTFFVUTi1VU0VSRmlyc3Qt +-T2JqZWN0MB4XDTk5MDcwOTE4MzEyMFoXDTE5MDcwOTE4NDAzNlowgZUxCzAJBgNV +-BAYTAlVTMQswCQYDVQQIEwJVVDEXMBUGA1UEBxMOU2FsdCBMYWtlIENpdHkxHjAc +-BgNVBAoTFVRoZSBVU0VSVFJVU1QgTmV0d29yazEhMB8GA1UECxMYaHR0cDovL3d3 +-dy51c2VydHJ1c3QuY29tMR0wGwYDVQQDExRVVE4tVVNFUkZpcnN0LU9iamVjdDCC +-ASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAM6qgT+jo2F4qjEAVZURnicP +-HxzfOpuCaDDASmEd8S8O+r5596Uj71VRloTN2+O5bj4x2AogZ8f02b+U60cEPgLO +-KqJdhwQJ9jCdGIqXsqoc/EHSoTbL+z2RuufZcDX65OeQw5ujm9M89RKZd7G3CeBo +-5hy485RjiGpq/gt2yb70IuRnuasaXnfBhQfdDWy/7gbHd2pBnqcP1/vulBe3/IW+ +-pKvEHDHd17bR5PDv3xaPslKT16HUiaEHLr/hARJCHhrh2JU022R5KP+6LhHC5ehb +-kkj7RwvCbNqtMoNB86XlQXD9ZZBt+vpRxPm9lisZBCzTbafc8H9vg2XiaquHhnUC +-AwEAAaOBrzCBrDALBgNVHQ8EBAMCAcYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4E +-FgQU2u1kdBScFDyr3ZmpvVsoTYs8ydgwQgYDVR0fBDswOTA3oDWgM4YxaHR0cDov +-L2NybC51c2VydHJ1c3QuY29tL1VUTi1VU0VSRmlyc3QtT2JqZWN0LmNybDApBgNV +-HSUEIjAgBggrBgEFBQcDAwYIKwYBBQUHAwgGCisGAQQBgjcKAwQwDQYJKoZIhvcN +-AQEFBQADggEBAAgfUrE3RHjb/c652pWWmKpVZIC1WkDdIaXFwfNfLEzIR1pp6ujw +-NTX00CXzyKakh0q9G7FzCL3Uw8q2NbtZhncxzaeAFK4T7/yxSPlrJSUtUbYsbUXB +-mMiKVl0+7kNOPmsnjtA6S4ULX9Ptaqd1y9Fahy85dRNacrACgZ++8A+EVCBibGnU +-4U3GDZlDAQ0Slox4nb9QorFEqmrPF3rPbw/U+CRVX/A0FklmPlBGyWNxODFiuGK5 +-81OtbLUrohKqGU8J2l7nk8aOFAj+8DCAGKCGhU3IfdeLA/5u1fedFqySLKAj5ZyR +-Uh+U3xeUc8OzwcFxBSAAeL0TUh2oPs0AH8g= +------END CERTIFICATE----- +diff --git a/jdk/make/data/cacerts/verisigntsaca b/jdk/make/data/cacerts/verisigntsaca +deleted file mode 100644 +index 9813ddaea..000000000 +--- a/jdk/make/data/cacerts/verisigntsaca ++++ /dev/null +@@ -1,24 +0,0 @@ +-Owner: CN=Thawte Timestamping CA, OU=Thawte Certification, O=Thawte, L=Durbanville, ST=Western Cape, C=ZA +-Issuer: CN=Thawte Timestamping CA, OU=Thawte Certification, O=Thawte, L=Durbanville, ST=Western Cape, C=ZA +-Serial number: 67c8e1e8e3be1cbdfc913b8ea6238749 +-Valid from: Wed Jan 01 00:00:00 GMT 1997 until: Fri Jan 01 23:59:59 GMT 2021 +-Signature algorithm name: SHA1withRSA +-Subject Public Key Algorithm: 1024-bit RSA key +-Version: 3 +------BEGIN CERTIFICATE----- +-MIICsDCCAhmgAwIBAgIQZ8jh6OO+HL38kTuOpiOHSTANBgkqhkiG9w0BAQUFADCB +-izELMAkGA1UEBhMCWkExFTATBgNVBAgTDFdlc3Rlcm4gQ2FwZTEUMBIGA1UEBxML +-RHVyYmFudmlsbGUxDzANBgNVBAoTBlRoYXd0ZTEdMBsGA1UECxMUVGhhd3RlIENl +-cnRpZmljYXRpb24xHzAdBgNVBAMTFlRoYXd0ZSBUaW1lc3RhbXBpbmcgQ0EwHhcN +-OTcwMTAxMDAwMDAwWhcNMjEwMTAxMjM1OTU5WjCBizELMAkGA1UEBhMCWkExFTAT +-BgNVBAgTDFdlc3Rlcm4gQ2FwZTEUMBIGA1UEBxMLRHVyYmFudmlsbGUxDzANBgNV +-BAoTBlRoYXd0ZTEdMBsGA1UECxMUVGhhd3RlIENlcnRpZmljYXRpb24xHzAdBgNV +-BAMTFlRoYXd0ZSBUaW1lc3RhbXBpbmcgQ0EwgZ8wDQYJKoZIhvcNAQEBBQADgY0A +-MIGJAoGBANYrWHhhRYZT6jR7UZztsOYuGA7+4F+oJ9O0yeB8WU4WDnNUYMF/9p8u +-6TqFJBU820cEY8OexJQaWt9MevPZQx08EHp5JduQ/vBR5zDWQQD9nyjfeb6Uu522 +-FOMjhdepQeBMpHmwKxqL8vg7ij5FrHGSALSQQZj7X+36ty6K+Ig3AgMBAAGjEzAR +-MA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEFBQADgYEAS+mqF4EF+3kKMZ/F +-QfRWVKvpwuWXjhj+kckMPiZkyaFMJ2SnvQGTVXFuF0853BvcSTUQOSP/ypvIz2Y/ +-3Ewa1IEGQlIf4SaxFhe65nByMUToTo1b5NP50OOPJWQx5yr4GIg2GlLFDUE1G2m3 +-JvUXzMEZXkt8XOKDgJH6L/uatxY= +------END CERTIFICATE----- +diff --git a/jdk/test/sun/security/lib/cacerts/VerifyCACerts.java b/jdk/test/sun/security/lib/cacerts/VerifyCACerts.java +index 1f443381c..29d4f0f97 100644 +--- a/jdk/test/sun/security/lib/cacerts/VerifyCACerts.java ++++ b/jdk/test/sun/security/lib/cacerts/VerifyCACerts.java +@@ -27,7 +27,6 @@ + * @bug 8189131 8198240 8191844 8189949 8191031 8196141 8204923 8195774 8199779 + * 8209452 8209506 8210432 8195793 8216577 8222089 8222133 8222137 8222136 + * 8223499 8225392 8232019 8234245 8233223 8225068 8225069 8243321 8243320 +- * 8225072 8258630 + * @summary Check root CA entries in cacerts file + */ + import java.io.ByteArrayInputStream; +@@ -58,7 +57,7 @@ public class VerifyCACerts { + // SHA-256 of cacerts, can be generated with + // shasum -a 256 cacerts | sed -e 's/../&:/g' | tr '[:lower:]' '[:upper:]' | cut -c1-95 + private static final String CHECKSUM +- = "84:BB:36:9E:B0:07:A7:C5:7F:38:EC:36:82:5C:0F:46:C0:35:3B:B1:1F:06:C2:D0:47:B9:39:FA:87:64:E5:9D"; ++ = "8E:A5:85:3C:66:C0:7C:B1:2A:B6:67:31:B3:4A:8E:78:1B:8D:DC:49:F1:42:65:DB:CE:7C:69:41:F3:94:3A:F7"; + + // map of cert alias to SHA-256 fingerprint + @SuppressWarnings("serial") +@@ -93,12 +92,6 @@ public class VerifyCACerts { + "E7:93:C9:B0:2F:D8:AA:13:E2:1C:31:22:8A:CC:B0:81:19:64:3B:74:9C:89:89:64:B1:74:6D:46:C3:D4:CB:D2"); + put("usertrusteccca [jdk]", + "4F:F4:60:D5:4B:9C:86:DA:BF:BC:FC:57:12:E0:40:0D:2B:ED:3F:BC:4D:4F:BD:AA:86:E0:6A:DC:D2:A9:AD:7A"); +- put("utnuserfirstobjectca [jdk]", +- "6F:FF:78:E4:00:A7:0C:11:01:1C:D8:59:77:C4:59:FB:5A:F9:6A:3D:F0:54:08:20:D0:F4:B8:60:78:75:E5:8F"); +- put("addtrustexternalca [jdk]", +- "68:7F:A4:51:38:22:78:FF:F0:C8:B1:1F:8D:43:D5:76:67:1C:6E:B2:BC:EA:B4:13:FB:83:D9:65:D0:6D:2F:F2"); +- put("addtrustqualifiedca [jdk]", +- "80:95:21:08:05:DB:4B:BC:35:5E:44:28:D8:FD:6E:C2:CD:E3:AB:5F:B9:7A:99:42:98:8E:B8:F4:DC:D0:60:16"); + put("baltimorecybertrustca [jdk]", + "16:AF:57:A9:F6:76:B0:AB:12:60:95:AA:5E:BA:DE:F2:2A:B3:11:19:D6:44:AC:95:CD:4B:93:DB:F3:F2:6A:EB"); + put("digicertglobalrootca [jdk]", +@@ -253,19 +246,11 @@ public class VerifyCACerts { + @SuppressWarnings("serial") + private static final HashSet EXPIRY_EXC_ENTRIES = new HashSet() { + { +- // Valid until: Tue Jul 09 14:40:36 EDT 2019 +- add("utnuserfirstobjectca [jdk]"); +- // Valid until: Sat May 30 10:38:31 GMT 2020 +- add("addtrustexternalca [jdk]"); +- // Valid until: Sat May 30 10:44:50 GMT 2020 +- add("addtrustqualifiedca [jdk]"); +- // Valid until: Fri Jan 01 15:59:59 PST 2021 +- add("verisigntsaca [jdk]"); +- // Valid until: Fri Jan 01 15:59:59 PST 2021 +- add("thawtepremiumserverca [jdk]"); +- // Valid until: Wed Mar 17 02:51:37 PDT 2021 ++ // Valid until: Wed Mar 17 17:51:37 HKT 2021 + add("luxtrustglobalrootca [jdk]"); +- // Valid until: Wed Mar 17 11:33:33 PDT 2021 ++ // Valid until: Tue Apr 06 15:29:40 HKT 2021 ++ add("soneraclass2ca [jdk]"); ++ // Valid until: Thu Mar 18 02:33:33 HKT 2021 + add("quovadisrootca [jdk]"); + } + }; +-- +2.19.0 + diff --git a/generate_source_tarball.sh b/generate_source_tarball.sh index 4f9fd92567ef8239fa6fb1c443e2a3db86f56b7b..a4f8c2c904279cdc2fa2aac8f7101011218fc7cc 100755 --- a/generate_source_tarball.sh +++ b/generate_source_tarball.sh @@ -19,6 +19,12 @@ # level folder, name is created, based on parameter # +if [ ! "x$PR3756" = "x" ] ; then + if [ ! -f "$PR3756" ] ; then + echo "You have specified PR3756 as $PR3756 but it does not exists. exiting" + exit 1 + fi +fi set -e OPENJDK_URL_DEFAULT=http://hg.openjdk.java.net @@ -105,6 +111,32 @@ do hg clone ${REPO_ROOT}/${subrepo} -r ${VERSION} done +#if [ -d jdk ]; then +#echo "Removing EC source code we don't build" +#rm -vf jdk/src/share/native/sun/security/ec/impl/ec2.h +#rm -vf jdk/src/share/native/sun/security/ec/impl/ec2_163.c +#rm -vf jdk/src/share/native/sun/security/ec/impl/ec2_193.c +#rm -vf jdk/src/share/native/sun/security/ec/impl/ec2_233.c +#rm -vf jdk/src/share/native/sun/security/ec/impl/ec2_aff.c +#rm -vf jdk/src/share/native/sun/security/ec/impl/ec2_mont.c +#rm -vf jdk/src/share/native/sun/security/ec/impl/ecp_192.c +#rm -vf jdk/src/share/native/sun/security/ec/impl/ecp_224.c +# +#echo "Syncing EC list with NSS" +# +#if [ "x$PR3756" = "x" ] ; then +## get pr3756.patch (from http://icedtea.classpath.org/hg/icedtea8) from most correct tag +## Do not push it or publish it (see http://icedtea.classpath.org/bugzilla/show_bug.cgi?id=3756) +# wget http://icedtea.classpath.org/hg/icedtea8/raw-file/tip/patches/pr3756.patch +# patch -Np1 < pr3756.patch +# rm pr3756.patch +#else +# echo "Applying ${PR3756}" +# patch -Np1 < $PR3756 +#fi; +#fi +#find . -name '*.orig' -exec rm -vf '{}' ';' + popd echo "Compressing remaining forest" if [ "X$COMPRESSION" = "Xxz" ] ; then diff --git a/java-1.8.0-openjdk.spec b/java-1.8.0-openjdk.spec index b64b7bc9872ec0cfa7309bc470b3fc0397957557..bf1c06eb6751c08a934ab2a665a9bba7f040b11b 100644 --- a/java-1.8.0-openjdk.spec +++ b/java-1.8.0-openjdk.spec @@ -146,9 +146,10 @@ %global origin_nice OpenJDK %global top_level_dir_name %{origin} # Define old aarch64/jdk8u tree variables for compatibility -%global project jdk8u -%global repo jdk8u -%global revision jdk8u292-b01 +%global project aarch64-port +%global repo jdk8u-shenandoah +%global revision aarch64-shenandoah-jdk8u282-b08 +%global full_revision %{project}-%{repo}-%{revision} # Define IcedTea version used for SystemTap tapsets and desktop files %global icedteaver 3.15.0 @@ -914,7 +915,7 @@ Provides: java-%{javaver}-%{origin}-accessibility%{?1} = %{epoch}:%{version}-%{r Name: java-%{javaver}-%{origin} Version: %{javaver}.%{updatever}.%{buildver} -Release: 0 +Release: 5 # java-1.5.0-ibm from jpackage.org set Epoch to 1 for unknown reasons # and this change was brought into RHEL-4. java-1.5.0-ibm packages # also included the epoch in their virtual provides. This created a @@ -942,7 +943,7 @@ Group: Development/Languages License: ASL 1.1 and ASL 2.0 and BSD and BSD with advertising and GPL+ and GPLv2 and GPLv2 with exceptions and IJG and LGPLv2+ and MIT and MPLv2.0 and Public Domain and W3C and zlib URL: http://openjdk.java.net/ -Source0: %{project}-%{repo}-%{revision}.tar.xz +Source0: %{full_revision}.tar.xz # Custom README for -src subpackage Source2: README.md @@ -1010,6 +1011,7 @@ Patch75: Add-ability-to-configure-third-port-for-remote-JMX.patch Patch76: 8203196.patch Patch77: 8190332.patch Patch78: 8171410.patch +Patch83: 8204947.patch Patch85: 8139041.patch # 8u252 @@ -1042,6 +1044,7 @@ Patch114: 8181503.patch Patch115: 8243670.patch Patch116: fix-crash-in-JVMTI-debug.patch Patch118: Fix-LineBuffer-vappend-when-buffer-too-small.patch +Patch121: Remove-unused-GenericTaskQueueSet-T-F-tasks.patch Patch122: optimize-jmap-F-dump-xxx.patch Patch123: recreate-.java_pid-file-when-deleted-for-attach-mechanism.patch Patch124: Support-Git-commit-ID-in-the-SOURCE-field-of-the-release.patch @@ -1051,17 +1054,20 @@ Patch127: add-DumpSharedSpace-guarantee-when-create-anonymous-classes.patch # 8u272 Patch129: 8248336.patch +Patch133: 8160369.patch Patch134: PS-GC-adding-acquire_size-method-for-PSParallelCompa.patch Patch138: add-appcds-file-lock.patch Patch139: G1-memory-uncommit.patch Patch140: 8015927.patch Patch141: 8040327.patch Patch142: 8207160.patch +Patch143: delete-untrustworthy-cacert-files.patch Patch144: add-appcds-test-case.patch # 8u282 Patch145: 8080911.patch Patch146: 8168926.patch +Patch147: 8215047.patch Patch148: 8237894.patch Patch149: Remove-the-parentheses-around-company-name.patch Patch150: 8240353.patch @@ -1439,6 +1445,7 @@ pushd %{top_level_dir_name} %patch76 -p1 %patch77 -p1 %patch78 -p1 +%patch83 -p1 %patch85 -p1 %patch86 -p1 %patch87 -p1 @@ -1465,6 +1472,7 @@ pushd %{top_level_dir_name} %patch115 -p1 %patch116 -p1 %patch118 -p1 +%patch121 -p1 %patch122 -p1 %patch123 -p1 %patch124 -p1 @@ -1472,15 +1480,18 @@ pushd %{top_level_dir_name} %patch126 -p1 %patch127 -p1 %patch129 -p1 +%patch133 -p1 %patch134 -p1 %patch138 -p1 %patch139 -p1 %patch140 -p1 %patch141 -p1 %patch142 -p1 +%patch143 -p1 %patch144 -p1 %patch145 -p1 %patch146 -p1 +%patch147 -p1 %patch148 -p1 %patch149 -p1 %patch150 -p1 @@ -2100,14 +2111,6 @@ require "copy_jdk_configs.lua" %endif %changelog -* Tue Feb 9 2021 jdkboy - 1:1.8.0.292-b01.0 -- updated to jdk8u292-b01 (from jdk8u/jdk8u) -- delete 8204947.patch temperarily -- delete Remove-unused-GenericTaskQueueSet-T-F-tasks.patch -- delete 8160369.patch -- delete 8215047.patch temperarily -- delte delete-untrustworthy-cacert-files.patch - * Fri Feb 5 2021 noah - 1:1.8.0.282-b08.5 - delete some file header diff --git a/patch_list b/patch_list index ddb5e0c79039994977cc2936079238f20437f0da..56ce2a58c6a88b2e74cc1d2f9195870c7cf4e062 100644 --- a/patch_list +++ b/patch_list @@ -38,12 +38,13 @@ Add-ability-to-configure-third-port-for-remote-JMX.patch 8203196.patch 8190332.patch 8171410.patch +8204947.patch 8139041.patch 6858051-Create-GC-worker-threads-dynamically.patch 6858051-Add-a-switch-for-the-dynamic-thread-related-log.patch dismiss-warnings-in-GCC-8.X.patch -8144993.patch -8223504.patch +8144993-Elide-redundant-memory-barrier-after-AllocationNode.patch +8223504-improve-performance-of-forall-loops-by-better.patch add-vm-option-BoxTypeCachedMax-for-Integer-and-Long-cache.patch 8080289-8040213-8189067-move-the-store-out-of-the-loop.patch 8182397.patch @@ -64,6 +65,7 @@ Test8167409.sh-fails-to-run-with-32bit-jdk-on-64bit-.patch 8243670.patch fix-crash-in-JVMTI-debug.patch Fix-LineBuffer-vappend-when-buffer-too-small.patch +Remove-unused-GenericTaskQueueSet-T-F-tasks.patch optimize-jmap-F-dump-xxx.patch recreate-.java_pid-file-when-deleted-for-attach-mechanism.patch Support-Git-commit-ID-in-the-SOURCE-field-of-the-release.patch @@ -71,15 +73,17 @@ Extend-CDS-to-support-app-class-metadata-sharing.patch zlib-optimization.patch add-DumpSharedSpace-guarantee-when-create-anonymous-classes.patch 8248336.patch +8160369.patch PS-GC-adding-acquire_size-method-for-PSParallelCompa.patch add-appcds-file-lock.patch G1-memory-uncommit.patch 8015927.patch 8040327.patch 8207160.patch +delete-untrustworthy-cacert-files.patch add-appcds-test-case.patch 8080911.patch 8168926.patch +8215047.patch 8237894.patch Remove-the-parentheses-around-company-name.patch -8240353.patch diff --git a/sources b/sources index 04b7be0e8ddb1948f1e18e4f1201a83f69c88fdf..552f136aa8ca6a9159b9e4cb0cbe97a1880c23d8 100644 --- a/sources +++ b/sources @@ -1,2 +1,2 @@ SHA512 (tapsets-icedtea-3.15.0.tar.xz) = 36eed87c370306c715d7a9d0906a7d719d6d956d38d03fb8f2d528d22e0067cabb3a7df10e8a7c5b65b70f2c12b9a8e7078a78a3cac478b6031d42f36415b05f -SHA512 (jdk8u-jdk8u-jdk8u292-b01.tar.xz) = 629e4443e84f003c5736261f55ca9c7cab3e24487e54a8136a4b7d627da68b46 +SHA512 (aarch64-port-jdk8u-shenandoah-aarch64-shenandoah-jdk8u282-b08.tar.xz) = c0a525bc2c8e5b81af7903952eac1e3d9e6b7793399b38ef4c1abbb14370798dcc0478bc6bbf9ef63ba4461c98e16fa99d13d642413b045ef39d4305d6312b5f diff --git a/tapsets-icedtea-3.15.0.tar.xz b/tapsets-icedtea-3.15.0.tar.xz old mode 100755 new mode 100644 diff --git a/update_main_sources.sh b/update_main_sources.sh index af19cea809ce4957cc4eb8ac18ce3d982656f6ad..557d5778ee26bd98f2de4c423d466805b50653cf 100755 --- a/update_main_sources.sh +++ b/update_main_sources.sh @@ -15,16 +15,23 @@ # # the used values are then substituted to spec and sources +if [ ! "x$PR2126" = "x" ] ; then + if [ ! -f "$PR2126" ] ; then + echo "You have specified PR2126 as $PR2126 but it does not exists. exiting" + exit 1 + fi +fi + set -e if [ "x$PROJECT_NAME" = "x" ] ; then - PROJECT_NAME="jdk8u" + PROJECT_NAME="aarch64-port" fi if [ "x$REPO_NAME" = "x" ] ; then - REPO_NAME="jdk8u" + REPO_NAME="jdk8u-shenandoah" fi if [ "x$VERSION" = "x" ] ; then - VERSION="jdk8u292-b01" + VERSION="aarch64-shenandoah-jdk8u282-b08" fi if [ "x$COMPRESSION" = "x" ] ; then @@ -47,12 +54,13 @@ fi FILENAME=${FILE_NAME_ROOT}.tar.${COMPRESSION} if [ ! -f ${FILENAME} ] ; then - echo "Generating ${FILENAME}" - . ./generate_source_tarball.sh +echo "Generating ${FILENAME}" +. ./generate_source_tarball.sh else - echo "${FILENAME} already exists, using" +echo "${FILENAME} already exists, using" fi + echo "Touching spec: $SPEC" echo sed -i "s/^%global\s\+project.*/%global project ${PROJECT_NAME}/" $SPEC echo sed -i "s/^%global\s\+repo.*/%global repo ${REPO_NAME}/" $SPEC