From aac13806ea477817f1e602ec9b952a72e6f33cc8 Mon Sep 17 00:00:00 2001 From: John Cuthbertson Date: Mon, 1 Oct 2012 09:28:13 -0700 Subject: [PATCH 001/102] 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack Set the value of MarkStackSize to a value based on the number of parallel marking threads with a reasonable minimum. Expand the marking stack if we have to restart marking due to an overflow up to a reasonable maximum. Allocate the underlying space for the marking stack from virtual memory. Reviewed-by: jmasa, brutisso --- .../gc_implementation/g1/concurrentMark.cpp | 300 +++++++++++++----- .../gc_implementation/g1/concurrentMark.hpp | 51 ++- .../gc_implementation/g1/g1CollectedHeap.cpp | 8 +- hotspot/src/share/vm/runtime/arguments.cpp | 22 +- 4 files changed, 271 insertions(+), 110 deletions(-) diff --git a/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp b/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp index d3dc1eb7bb7..e03b2f41cfc 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp +++ b/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp @@ -46,27 +46,11 @@ // Concurrent marking bit map wrapper -CMBitMapRO::CMBitMapRO(ReservedSpace rs, int shifter) : - _bm((uintptr_t*)NULL,0), +CMBitMapRO::CMBitMapRO(int shifter) : + _bm(), _shifter(shifter) { - _bmStartWord = (HeapWord*)(rs.base()); - _bmWordSize = rs.size()/HeapWordSize; // rs.size() is in bytes - ReservedSpace brs(ReservedSpace::allocation_align_size_up( - (_bmWordSize >> (_shifter + LogBitsPerByte)) + 1)); - - MemTracker::record_virtual_memory_type((address)brs.base(), mtGC); - - guarantee(brs.is_reserved(), "couldn't allocate concurrent marking bit map"); - // For now we'll just commit all of the bit map up fromt. - // Later on we'll try to be more parsimonious with swap. - guarantee(_virtual_space.initialize(brs, brs.size()), - "couldn't reseve backing store for concurrent marking bit map"); - assert(_virtual_space.committed_size() == brs.size(), - "didn't reserve backing store for all of concurrent marking bit map?"); - _bm.set_map((uintptr_t*)_virtual_space.low()); - assert(_virtual_space.committed_size() << (_shifter + LogBitsPerByte) >= - _bmWordSize, "inconsistency in bit map sizing"); - _bm.set_size(_bmWordSize >> _shifter); + _bmStartWord = 0; + _bmWordSize = 0; } HeapWord* CMBitMapRO::getNextMarkedWordAddress(HeapWord* addr, @@ -108,15 +92,40 @@ int CMBitMapRO::heapWordDiffToOffsetDiff(size_t diff) const { } #ifndef PRODUCT -bool CMBitMapRO::covers(ReservedSpace rs) const { +bool CMBitMapRO::covers(ReservedSpace heap_rs) const { // assert(_bm.map() == _virtual_space.low(), "map inconsistency"); assert(((size_t)_bm.size() * ((size_t)1 << _shifter)) == _bmWordSize, "size inconsistency"); - return _bmStartWord == (HeapWord*)(rs.base()) && - _bmWordSize == rs.size()>>LogHeapWordSize; + return _bmStartWord == (HeapWord*)(heap_rs.base()) && + _bmWordSize == heap_rs.size()>>LogHeapWordSize; } #endif +bool CMBitMap::allocate(ReservedSpace heap_rs) { + _bmStartWord = (HeapWord*)(heap_rs.base()); + _bmWordSize = heap_rs.size()/HeapWordSize; // heap_rs.size() is in bytes + ReservedSpace brs(ReservedSpace::allocation_align_size_up( + (_bmWordSize >> (_shifter + LogBitsPerByte)) + 1)); + if (!brs.is_reserved()) { + warning("ConcurrentMark marking bit map allocation failure"); + return false; + } + MemTracker::record_virtual_memory_type((address)brs.base(), mtGC); + // For now we'll just commit all of the bit map up front. + // Later on we'll try to be more parsimonious with swap. + if (!_virtual_space.initialize(brs, brs.size())) { + warning("ConcurrentMark marking bit map backing store failure"); + return false; + } + assert(_virtual_space.committed_size() == brs.size(), + "didn't reserve backing store for all of concurrent marking bit map?"); + _bm.set_map((uintptr_t*)_virtual_space.low()); + assert(_virtual_space.committed_size() << (_shifter + LogBitsPerByte) >= + _bmWordSize, "inconsistency in bit map sizing"); + _bm.set_size(_bmWordSize >> _shifter); + return true; +} + void CMBitMap::clearAll() { _bm.clear(); return; @@ -163,20 +172,79 @@ CMMarkStack::CMMarkStack(ConcurrentMark* cm) : #endif {} -void CMMarkStack::allocate(size_t size) { - _base = NEW_C_HEAP_ARRAY(oop, size, mtGC); - if (_base == NULL) { - vm_exit_during_initialization("Failed to allocate CM region mark stack"); +bool CMMarkStack::allocate(size_t capacity) { + // allocate a stack of the requisite depth + ReservedSpace rs(ReservedSpace::allocation_align_size_up(capacity * sizeof(oop))); + if (!rs.is_reserved()) { + warning("ConcurrentMark MarkStack allocation failure"); + return false; } - _index = 0; - _capacity = (jint) size; + MemTracker::record_virtual_memory_type((address)rs.base(), mtGC); + if (!_virtual_space.initialize(rs, rs.size())) { + warning("ConcurrentMark MarkStack backing store failure"); + // Release the virtual memory reserved for the marking stack + rs.release(); + return false; + } + assert(_virtual_space.committed_size() == rs.size(), + "Didn't reserve backing store for all of ConcurrentMark stack?"); + _base = (oop*) _virtual_space.low(); + setEmpty(); + _capacity = (jint) capacity; _saved_index = -1; NOT_PRODUCT(_max_depth = 0); + return true; +} + +void CMMarkStack::expand() { + // Called, during remark, if we've overflown the marking stack during marking. + assert(isEmpty(), "stack should been emptied while handling overflow"); + assert(_capacity <= (jint) MarkStackSizeMax, "stack bigger than permitted"); + // Clear expansion flag + _should_expand = false; + if (_capacity == (jint) MarkStackSizeMax) { + if (PrintGCDetails && Verbose) { + gclog_or_tty->print_cr(" (benign) Can't expand marking stack capacity, at max size limit"); + } + return; + } + // Double capacity if possible + jint new_capacity = MIN2(_capacity*2, (jint) 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(new_capacity * + sizeof(oop))); + if (rs.is_reserved()) { + // Release the backing store associated with old stack + _virtual_space.release(); + // Reinitialize virtual space for new stack + if (!_virtual_space.initialize(rs, rs.size())) { + fatal("Not enough swap for expanded marking stack capacity"); + } + _base = (oop*)(_virtual_space.low()); + _index = 0; + _capacity = new_capacity; + } else { + if (PrintGCDetails && Verbose) { + // Failed to double capacity, continue; + gclog_or_tty->print(" (benign) Failed to expand marking stack capacity from " + SIZE_FORMAT"K to " SIZE_FORMAT"K", + _capacity / K, new_capacity / K); + } + } +} + +void CMMarkStack::set_should_expand() { + // If we're resetting the marking state because of an + // marking stack overflow, record that we should, if + // possible, expand the stack. + _should_expand = _cm->has_overflown(); } CMMarkStack::~CMMarkStack() { if (_base != NULL) { - FREE_C_HEAP_ARRAY(oop, _base, mtGC); + _base = NULL; + _virtual_space.release(); } } @@ -217,7 +285,7 @@ void CMMarkStack::par_adjoin_arr(oop* ptr_arr, int n) { jint res = Atomic::cmpxchg(next_index, &_index, index); if (res == index) { for (int i = 0; i < n; i++) { - int ind = index + i; + int ind = index + i; assert(ind < _capacity, "By overflow test above."); _base[ind] = ptr_arr[i]; } @@ -228,7 +296,6 @@ void CMMarkStack::par_adjoin_arr(oop* ptr_arr, int n) { } } - void CMMarkStack::par_push_arr(oop* ptr_arr, int n) { MutexLockerEx x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag); jint start = _index; @@ -244,9 +311,9 @@ void CMMarkStack::par_push_arr(oop* ptr_arr, int n) { assert(ind < _capacity, "By overflow test above."); _base[ind] = ptr_arr[i]; } + NOT_PRODUCT(_max_depth = MAX2(_max_depth, next_index)); } - bool CMMarkStack::par_pop_arr(oop* ptr_arr, int max, int* n) { MutexLockerEx x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag); jint index = _index; @@ -255,7 +322,7 @@ bool CMMarkStack::par_pop_arr(oop* ptr_arr, int max, int* n) { return false; } else { int k = MIN2(max, index); - jint new_ind = index - k; + jint new_ind = index - k; for (int j = 0; j < k; j++) { ptr_arr[j] = _base[new_ind + j]; } @@ -404,9 +471,10 @@ uint ConcurrentMark::scale_parallel_threads(uint n_par_threads) { return MAX2((n_par_threads + 2) / 4, 1U); } -ConcurrentMark::ConcurrentMark(ReservedSpace rs, uint max_regions) : - _markBitMap1(rs, MinObjAlignment - 1), - _markBitMap2(rs, MinObjAlignment - 1), +ConcurrentMark::ConcurrentMark(G1CollectedHeap* g1h, ReservedSpace heap_rs) : + _g1h(g1h), + _markBitMap1(MinObjAlignment - 1), + _markBitMap2(MinObjAlignment - 1), _parallel_marking_threads(0), _max_parallel_marking_threads(0), @@ -415,10 +483,10 @@ ConcurrentMark::ConcurrentMark(ReservedSpace rs, uint max_regions) : _cleanup_sleep_factor(0.0), _cleanup_task_overhead(1.0), _cleanup_list("Cleanup List"), - _region_bm((BitMap::idx_t) max_regions, false /* in_resource_area*/), - _card_bm((rs.size() + CardTableModRefBS::card_size - 1) >> - CardTableModRefBS::card_shift, - false /* in_resource_area*/), + _region_bm((BitMap::idx_t)(g1h->max_regions()), false /* in_resource_area*/), + _card_bm((heap_rs.size() + CardTableModRefBS::card_size - 1) >> + CardTableModRefBS::card_shift, + false /* in_resource_area*/), _prevMarkBitMap(&_markBitMap1), _nextMarkBitMap(&_markBitMap2), @@ -449,7 +517,8 @@ ConcurrentMark::ConcurrentMark(ReservedSpace rs, uint max_regions) : _parallel_workers(NULL), _count_card_bitmaps(NULL), - _count_marked_bytes(NULL) { + _count_marked_bytes(NULL), + _completed_initialization(false) { CMVerboseLevel verbose_level = (CMVerboseLevel) G1MarkingVerboseLevel; if (verbose_level < no_verbose) { verbose_level = no_verbose; @@ -464,61 +533,34 @@ ConcurrentMark::ConcurrentMark(ReservedSpace rs, uint max_regions) : "heap end = "PTR_FORMAT, _heap_start, _heap_end); } - _markStack.allocate(MarkStackSize); + if (!_markBitMap1.allocate(heap_rs)) { + warning("Failed to allocate first CM bit map"); + return; + } + if (!_markBitMap2.allocate(heap_rs)) { + warning("Failed to allocate second CM bit map"); + return; + } // Create & start a ConcurrentMark thread. _cmThread = new ConcurrentMarkThread(this); assert(cmThread() != NULL, "CM Thread should have been created"); assert(cmThread()->cm() != NULL, "CM Thread should refer to this cm"); - _g1h = G1CollectedHeap::heap(); assert(CGC_lock != NULL, "Where's the CGC_lock?"); - assert(_markBitMap1.covers(rs), "_markBitMap1 inconsistency"); - assert(_markBitMap2.covers(rs), "_markBitMap2 inconsistency"); + assert(_markBitMap1.covers(heap_rs), "_markBitMap1 inconsistency"); + assert(_markBitMap2.covers(heap_rs), "_markBitMap2 inconsistency"); SATBMarkQueueSet& satb_qs = JavaThread::satb_mark_queue_set(); satb_qs.set_buffer_size(G1SATBBufferSize); _root_regions.init(_g1h, this); - _tasks = NEW_C_HEAP_ARRAY(CMTask*, _max_worker_id, mtGC); - _accum_task_vtime = NEW_C_HEAP_ARRAY(double, _max_worker_id, mtGC); - - _count_card_bitmaps = NEW_C_HEAP_ARRAY(BitMap, _max_worker_id, mtGC); - _count_marked_bytes = NEW_C_HEAP_ARRAY(size_t*, _max_worker_id, mtGC); - - BitMap::idx_t card_bm_size = _card_bm.size(); - - // so that the assertion in MarkingTaskQueue::task_queue doesn't fail - _active_tasks = _max_worker_id; - for (uint i = 0; i < _max_worker_id; ++i) { - CMTaskQueue* task_queue = new CMTaskQueue(); - task_queue->initialize(); - _task_queues->register_queue(i, task_queue); - - _count_card_bitmaps[i] = BitMap(card_bm_size, false); - _count_marked_bytes[i] = NEW_C_HEAP_ARRAY(size_t, (size_t) max_regions, mtGC); - - _tasks[i] = new CMTask(i, this, - _count_marked_bytes[i], - &_count_card_bitmaps[i], - task_queue, _task_queues); - - _accum_task_vtime[i] = 0.0; - } - - // Calculate the card number for the bottom of the heap. Used - // in biasing indexes into the accounting card bitmaps. - _heap_bottom_card_num = - intptr_t(uintptr_t(_g1h->reserved_region().start()) >> - CardTableModRefBS::card_shift); - - // Clear all the liveness counting data - clear_all_count_data(); - if (ConcGCThreads > ParallelGCThreads) { - vm_exit_during_initialization("Can't have more ConcGCThreads " - "than ParallelGCThreads."); + warning("Can't have more ConcGCThreads (" UINT32_FORMAT ") " + "than ParallelGCThreads (" UINT32_FORMAT ").", + ConcGCThreads, ParallelGCThreads); + return; } if (ParallelGCThreads == 0) { // if we are not running with any parallel GC threads we will not @@ -590,9 +632,86 @@ ConcurrentMark::ConcurrentMark(ReservedSpace rs, uint max_regions) : } } + if (FLAG_IS_DEFAULT(MarkStackSize)) { + uintx mark_stack_size = + MIN2(MarkStackSizeMax, + MAX2(MarkStackSize, (uintx) (parallel_marking_threads() * TASKQUEUE_SIZE))); + // Verify that the calculated value for MarkStackSize is in range. + // It would be nice to use the private utility routine from Arguments. + if (!(mark_stack_size >= 1 && mark_stack_size <= MarkStackSizeMax)) { + warning("Invalid value calculated for MarkStackSize (" UINTX_FORMAT "): " + "must be between " UINTX_FORMAT " and " UINTX_FORMAT, + mark_stack_size, 1, MarkStackSizeMax); + return; + } + FLAG_SET_ERGO(uintx, MarkStackSize, mark_stack_size); + } else { + // Verify MarkStackSize is in range. + if (FLAG_IS_CMDLINE(MarkStackSize)) { + if (FLAG_IS_DEFAULT(MarkStackSizeMax)) { + if (!(MarkStackSize >= 1 && MarkStackSize <= MarkStackSizeMax)) { + warning("Invalid value specified for MarkStackSize (" UINTX_FORMAT "): " + "must be between " UINTX_FORMAT " and " UINTX_FORMAT, + MarkStackSize, 1, MarkStackSizeMax); + return; + } + } else if (FLAG_IS_CMDLINE(MarkStackSizeMax)) { + if (!(MarkStackSize >= 1 && MarkStackSize <= MarkStackSizeMax)) { + warning("Invalid value specified for MarkStackSize (" UINTX_FORMAT ")" + " or for MarkStackSizeMax (" UINTX_FORMAT ")", + MarkStackSize, MarkStackSizeMax); + return; + } + } + } + } + + if (!_markStack.allocate(MarkStackSize)) { + warning("Failed to allocate CM marking stack"); + return; + } + + _tasks = NEW_C_HEAP_ARRAY(CMTask*, _max_worker_id, mtGC); + _accum_task_vtime = NEW_C_HEAP_ARRAY(double, _max_worker_id, mtGC); + + _count_card_bitmaps = NEW_C_HEAP_ARRAY(BitMap, _max_worker_id, mtGC); + _count_marked_bytes = NEW_C_HEAP_ARRAY(size_t*, _max_worker_id, mtGC); + + BitMap::idx_t card_bm_size = _card_bm.size(); + + // so that the assertion in MarkingTaskQueue::task_queue doesn't fail + _active_tasks = _max_worker_id; + + size_t max_regions = (size_t) _g1h->max_regions(); + for (uint i = 0; i < _max_worker_id; ++i) { + CMTaskQueue* task_queue = new CMTaskQueue(); + task_queue->initialize(); + _task_queues->register_queue(i, task_queue); + + _count_card_bitmaps[i] = BitMap(card_bm_size, false); + _count_marked_bytes[i] = NEW_C_HEAP_ARRAY(size_t, max_regions, mtGC); + + _tasks[i] = new CMTask(i, this, + _count_marked_bytes[i], + &_count_card_bitmaps[i], + task_queue, _task_queues); + + _accum_task_vtime[i] = 0.0; + } + + // Calculate the card number for the bottom of the heap. Used + // in biasing indexes into the accounting card bitmaps. + _heap_bottom_card_num = + intptr_t(uintptr_t(_g1h->reserved_region().start()) >> + CardTableModRefBS::card_shift); + + // Clear all the liveness counting data + clear_all_count_data(); + // so that the call below can read a sensible value - _heap_start = (HeapWord*) rs.base(); + _heap_start = (HeapWord*) heap_rs.base(); set_non_marking_state(); + _completed_initialization = true; } void ConcurrentMark::update_g1_committed(bool force) { @@ -1165,6 +1284,11 @@ void ConcurrentMark::checkpointRootsFinal(bool clear_all_soft_refs) { assert(!restart_for_overflow(), "sanity"); } + // Expand the marking stack, if we have to and if we can. + if (_markStack.should_expand()) { + _markStack.expand(); + } + // Reset the marking state if marking completed if (!restart_for_overflow()) { set_non_marking_state(); @@ -2785,7 +2909,7 @@ void ConcurrentMark::verify_no_cset_oops(bool verify_stacks, // Verify entries on the task queues for (uint i = 0; i < _max_worker_id; i += 1) { cl.set_phase(VerifyNoCSetOopsQueues, i); - OopTaskQueue* queue = _task_queues->queue(i); + CMTaskQueue* queue = _task_queues->queue(i); queue->oops_do(&cl); } } @@ -2840,8 +2964,8 @@ void ConcurrentMark::verify_no_cset_oops(bool verify_stacks, #endif // PRODUCT void ConcurrentMark::clear_marking_state(bool clear_overflow) { - _markStack.setEmpty(); - _markStack.clear_overflow(); + _markStack.set_should_expand(); + _markStack.setEmpty(); // Also clears the _markStack overflow flag if (clear_overflow) { clear_has_overflown(); } else { @@ -2850,7 +2974,7 @@ void ConcurrentMark::clear_marking_state(bool clear_overflow) { _finger = _heap_start; for (uint i = 0; i < _max_worker_id; ++i) { - OopTaskQueue* queue = _task_queues->queue(i); + CMTaskQueue* queue = _task_queues->queue(i); queue->set_empty(); } } diff --git a/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.hpp b/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.hpp index 5bac7a6b34d..8089c98294a 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.hpp +++ b/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.hpp @@ -63,7 +63,7 @@ class CMBitMapRO VALUE_OBJ_CLASS_SPEC { public: // constructor - CMBitMapRO(ReservedSpace rs, int shifter); + CMBitMapRO(int shifter); enum { do_yield = true }; @@ -117,8 +117,11 @@ class CMBitMap : public CMBitMapRO { public: // constructor - CMBitMap(ReservedSpace rs, int shifter) : - CMBitMapRO(rs, shifter) {} + CMBitMap(int shifter) : + CMBitMapRO(shifter) {} + + // Allocates the back store for the marking bitmap + bool allocate(ReservedSpace heap_rs); // write marks void mark(HeapWord* addr) { @@ -155,17 +158,18 @@ class CMBitMap : public CMBitMapRO { MemRegion getAndClearMarkedRegion(HeapWord* addr, HeapWord* end_addr); }; -// Represents a marking stack used by the CM collector. -// Ideally this should be GrowableArray<> just like MSC's marking stack(s). +// Represents a marking stack used by ConcurrentMarking in the G1 collector. class CMMarkStack VALUE_OBJ_CLASS_SPEC { + VirtualSpace _virtual_space; // Underlying backing store for actual stack ConcurrentMark* _cm; oop* _base; // bottom of stack - jint _index; // one more than last occupied index - jint _capacity; // max #elements - jint _saved_index; // value of _index saved at start of GC - NOT_PRODUCT(jint _max_depth;) // max depth plumbed during run + jint _index; // one more than last occupied index + jint _capacity; // max #elements + jint _saved_index; // value of _index saved at start of GC + NOT_PRODUCT(jint _max_depth;) // max depth plumbed during run - bool _overflow; + bool _overflow; + bool _should_expand; DEBUG_ONLY(bool _drain_in_progress;) DEBUG_ONLY(bool _drain_in_progress_yields;) @@ -173,7 +177,13 @@ class CMMarkStack VALUE_OBJ_CLASS_SPEC { CMMarkStack(ConcurrentMark* cm); ~CMMarkStack(); - void allocate(size_t size); +#ifndef PRODUCT + jint max_depth() const { + return _max_depth; + } +#endif + + bool allocate(size_t capacity); oop pop() { if (!isEmpty()) { @@ -231,11 +241,17 @@ class CMMarkStack VALUE_OBJ_CLASS_SPEC { bool isEmpty() { return _index == 0; } bool isFull() { return _index == _capacity; } - int maxElems() { return _capacity; } + int maxElems() { return _capacity; } bool overflow() { return _overflow; } void clear_overflow() { _overflow = false; } + bool should_expand() const { return _should_expand; } + void set_should_expand(); + + // Expand the stack, typically in response to an overflow condition + void expand(); + int size() { return _index; } void setEmpty() { _index = 0; clear_overflow(); } @@ -344,6 +360,7 @@ public: class ConcurrentMarkThread; class ConcurrentMark: public CHeapObj { + friend class CMMarkStack; friend class ConcurrentMarkThread; friend class CMTask; friend class CMBitMapClosure; @@ -577,6 +594,9 @@ protected: // the card bitmaps. intptr_t _heap_bottom_card_num; + // Set to true when initialization is complete + bool _completed_initialization; + public: // Manipulation of the global mark stack. // Notice that the first mark_stack_push is CAS-based, whereas the @@ -636,7 +656,7 @@ public: return _task_queues->steal(worker_id, hash_seed, obj); } - ConcurrentMark(ReservedSpace rs, uint max_regions); + ConcurrentMark(G1CollectedHeap* g1h, ReservedSpace heap_rs); ~ConcurrentMark(); ConcurrentMarkThread* cmThread() { return _cmThread; } @@ -907,6 +927,11 @@ public: // Should *not* be called from parallel code. inline bool mark_and_count(oop obj); + // Returns true if initialization was successfully completed. + bool completed_initialization() const { + return _completed_initialization; + } + protected: // Clear all the per-task bitmaps and arrays used to store the // counting data. diff --git a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp index 70b45fea4f0..448c5707787 100644 --- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp +++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @@ -2079,7 +2079,11 @@ jint G1CollectedHeap::initialize() { // Create the ConcurrentMark data structure and thread. // (Must do this late, so that "max_regions" is defined.) - _cm = new ConcurrentMark(heap_rs, max_regions()); + _cm = new ConcurrentMark(this, heap_rs); + if (_cm == NULL || !_cm->completed_initialization()) { + vm_shutdown_during_initialization("Could not create/initialize ConcurrentMark"); + return JNI_ENOMEM; + } _cmThread = _cm->cmThread(); // Initialize the from_card cache structure of HeapRegionRemSet. @@ -2087,7 +2091,7 @@ jint G1CollectedHeap::initialize() { // Now expand into the initial heap size. if (!expand(init_byte_size)) { - vm_exit_during_initialization("Failed to allocate initial heap."); + vm_shutdown_during_initialization("Failed to allocate initial heap."); return JNI_ENOMEM; } diff --git a/hotspot/src/share/vm/runtime/arguments.cpp b/hotspot/src/share/vm/runtime/arguments.cpp index f850e05cbab..21e5cce7b18 100644 --- a/hotspot/src/share/vm/runtime/arguments.cpp +++ b/hotspot/src/share/vm/runtime/arguments.cpp @@ -1499,13 +1499,12 @@ void Arguments::set_g1_gc_flags() { Abstract_VM_Version::parallel_worker_threads()); } - if (FLAG_IS_DEFAULT(MarkStackSize)) { - FLAG_SET_DEFAULT(MarkStackSize, 128 * TASKQUEUE_SIZE); - } - if (PrintGCDetails && Verbose) { - tty->print_cr("MarkStackSize: %uk MarkStackSizeMax: %uk", - MarkStackSize / K, MarkStackSizeMax / K); - tty->print_cr("ConcGCThreads: %u", ConcGCThreads); + // MarkStackSize will be set (if it hasn't been set by the user) + // when concurrent marking is initialized. + // Its value will be based upon the number of parallel marking threads. + // But we do set the maximum mark stack size here. + if (FLAG_IS_DEFAULT(MarkStackSizeMax)) { + FLAG_SET_DEFAULT(MarkStackSizeMax, 128 * TASKQUEUE_SIZE); } if (FLAG_IS_DEFAULT(GCTimeRatio) || GCTimeRatio == 0) { @@ -1517,6 +1516,12 @@ void Arguments::set_g1_gc_flags() { // is allocation). We might consider increase it further. FLAG_SET_DEFAULT(GCTimeRatio, 9); } + + if (PrintGCDetails && Verbose) { + tty->print_cr("MarkStackSize: %uk MarkStackSizeMax: %uk", + MarkStackSize / K, MarkStackSizeMax / K); + tty->print_cr("ConcGCThreads: %u", ConcGCThreads); + } } void Arguments::set_heap_size() { @@ -1980,6 +1985,9 @@ bool Arguments::check_vm_args_consistency() { status = status && verify_min_value(ClassMetaspaceSize, 1*M, "ClassMetaspaceSize"); + status = status && verify_interval(MarkStackSizeMax, + 1, (max_jint - 1), "MarkStackSizeMax"); + #ifdef SPARC if (UseConcMarkSweepGC || UseG1GC) { // Issue a stern warning if the user has explicitly set From 5c0bff8f21b15aa6841596305dedf2f3a9302a9b Mon Sep 17 00:00:00 2001 From: Maurizio Cimadamore Date: Mon, 10 Dec 2012 12:10:50 +0000 Subject: [PATCH 002/102] 8004094: Javac compiler error - synthetic method accessor generated with duplicate name Method clash check logic should skip methods marked with ACC_SYNTHETIC Reviewed-by: jjg --- .../com/sun/tools/javac/comp/Check.java | 6 ++- .../test/tools/javac/generics/8004094/B.java | 47 +++++++++++++++++++ .../javac/generics/8004094/T8004094.java | 32 +++++++++++++ 3 files changed, 83 insertions(+), 2 deletions(-) create mode 100644 langtools/test/tools/javac/generics/8004094/B.java create mode 100644 langtools/test/tools/javac/generics/8004094/T8004094.java diff --git a/langtools/src/share/classes/com/sun/tools/javac/comp/Check.java b/langtools/src/share/classes/com/sun/tools/javac/comp/Check.java index 78ba105984f..c796d3ff10d 100644 --- a/langtools/src/share/classes/com/sun/tools/javac/comp/Check.java +++ b/langtools/src/share/classes/com/sun/tools/javac/comp/Check.java @@ -1833,13 +1833,15 @@ public class Check { for (Scope.Entry e1 = t1.tsym.members().elems; e1 != null; e1 = e1.sibling) { Symbol s1 = e1.sym; Type st1 = null; - if (s1.kind != MTH || !s1.isInheritedIn(site.tsym, types)) continue; + if (s1.kind != MTH || !s1.isInheritedIn(site.tsym, types) || + (s1.flags() & SYNTHETIC) != 0) continue; Symbol impl = ((MethodSymbol)s1).implementation(site.tsym, types, false); if (impl != null && (impl.flags() & ABSTRACT) == 0) continue; for (Scope.Entry e2 = t2.tsym.members().lookup(s1.name); e2.scope != null; e2 = e2.next()) { Symbol s2 = e2.sym; if (s1 == s2) continue; - if (s2.kind != MTH || !s2.isInheritedIn(site.tsym, types)) continue; + if (s2.kind != MTH || !s2.isInheritedIn(site.tsym, types) || + (s2.flags() & SYNTHETIC) != 0) continue; if (st1 == null) st1 = types.memberType(t1, s1); Type st2 = types.memberType(t2, s2); if (types.overrideEquivalent(st1, st2)) { diff --git a/langtools/test/tools/javac/generics/8004094/B.java b/langtools/test/tools/javac/generics/8004094/B.java new file mode 100644 index 00000000000..735a7fdfa85 --- /dev/null +++ b/langtools/test/tools/javac/generics/8004094/B.java @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +abstract class A { + + private static String s = null; + + static void test() { + new Object() { + void m() { + Object o = s; + } + }; + } +} + +public abstract class B extends A { + + private static Integer i = null; + + static void test() { + new Object() { + void m() { + Object o = i; + } + }; + } +} diff --git a/langtools/test/tools/javac/generics/8004094/T8004094.java b/langtools/test/tools/javac/generics/8004094/T8004094.java new file mode 100644 index 00000000000..76c54d2c9e5 --- /dev/null +++ b/langtools/test/tools/javac/generics/8004094/T8004094.java @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test + * @bug 8004094 + * @summary Javac compiler error - synthetic method accessor generated with duplicate name + * + * @compile B.java T8004094.java + */ + +public class T8004094 extends B { } From 8fc2d739bd9a1e790e60775bd3e3f9179df5196e Mon Sep 17 00:00:00 2001 From: Vicente Romero Date: Mon, 10 Dec 2012 16:21:26 +0000 Subject: [PATCH 003/102] 8003967: detect and remove all mutable implicit static enum fields in langtools Reviewed-by: jjg --- .../com/sun/tools/classfile/Opcode.java | 8 +- .../internal/toolkit/util/DocFileFactory.java | 2 +- .../classes/com/sun/tools/javac/Server.java | 6 +- .../com/sun/tools/javac/code/Flags.java | 4 +- .../com/sun/tools/javac/code/Kinds.java | 2 +- .../com/sun/tools/javac/code/Lint.java | 6 +- .../com/sun/tools/javac/code/Source.java | 2 +- .../com/sun/tools/javac/code/TargetType.java | 15 +- .../com/sun/tools/javac/code/TypeTag.java | 6 +- .../com/sun/tools/javac/code/Types.java | 2 +- .../com/sun/tools/javac/comp/ConstFold.java | 6 +- .../com/sun/tools/javac/comp/Flow.java | 6 +- .../com/sun/tools/javac/comp/Resolve.java | 6 +- .../sun/tools/javac/file/ZipFileIndex.java | 2 +- .../classes/com/sun/tools/javac/jvm/Code.java | 2 +- .../com/sun/tools/javac/jvm/Target.java | 8 +- .../sun/tools/javac/main/JavaCompiler.java | 4 +- .../com/sun/tools/javac/main/Option.java | 76 ++---- .../sun/tools/javac/parser/JavaTokenizer.java | 2 +- .../JavacProcessingEnvironment.java | 2 +- .../com/sun/tools/javac/tree/JCTree.java | 12 +- .../sun/tools/javac/util/BaseFileManager.java | 4 +- .../com/sun/tools/javac/util/List.java | 4 +- .../javac/util/MandatoryWarningHandler.java | 4 +- .../javac/util/RichDiagnosticFormatter.java | 2 +- .../com/sun/tools/javah/JavahTask.java | 2 +- .../com/sun/tools/javap/JavapTask.java | 2 +- .../javax/lang/model/element/Modifier.java | 10 +- .../javax/lang/model/util/ElementFilter.java | 10 +- .../classes/javax/tools/StandardLocation.java | 2 +- .../T8003967/DetectMutableStaticFields.java | 242 ++++++++++++++++++ 31 files changed, 333 insertions(+), 128 deletions(-) create mode 100644 langtools/test/tools/javac/T8003967/DetectMutableStaticFields.java diff --git a/langtools/src/share/classes/com/sun/tools/classfile/Opcode.java b/langtools/src/share/classes/com/sun/tools/classfile/Opcode.java index 7ecf4979228..f22bec8f003 100644 --- a/langtools/src/share/classes/com/sun/tools/classfile/Opcode.java +++ b/langtools/src/share/classes/com/sun/tools/classfile/Opcode.java @@ -448,10 +448,10 @@ public enum Opcode { } - private static Opcode[] stdOpcodes = new Opcode[256]; - private static Opcode[] wideOpcodes = new Opcode[256]; - private static Opcode[] nonPrivOpcodes = new Opcode[256]; - private static Opcode[] privOpcodes = new Opcode[256]; + private static final Opcode[] stdOpcodes = new Opcode[256]; + private static final Opcode[] wideOpcodes = new Opcode[256]; + private static final Opcode[] nonPrivOpcodes = new Opcode[256]; + private static final Opcode[] privOpcodes = new Opcode[256]; static { for (Opcode o: values()) getOpcodeBlock(o.opcode >> 8)[o.opcode & 0xff] = o; diff --git a/langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/util/DocFileFactory.java b/langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/util/DocFileFactory.java index dc5349c87bc..57db795ae16 100644 --- a/langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/util/DocFileFactory.java +++ b/langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/util/DocFileFactory.java @@ -46,7 +46,7 @@ import com.sun.tools.doclets.internal.toolkit.Configuration; * @since 1.8 */ abstract class DocFileFactory { - private static Map factories = + private static final Map factories = new WeakHashMap(); /** diff --git a/langtools/src/share/classes/com/sun/tools/javac/Server.java b/langtools/src/share/classes/com/sun/tools/javac/Server.java index fcb2127138c..6fb48a9cf8e 100644 --- a/langtools/src/share/classes/com/sun/tools/javac/Server.java +++ b/langtools/src/share/classes/com/sun/tools/javac/Server.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2005, 2008, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2005, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -49,7 +49,7 @@ class Server implements Runnable { private final OutputStream out; private final boolean isSocket; private static final JavaCompiler tool = ToolProvider.getSystemJavaCompiler(); - private static Logger logger = Logger.getLogger("com.sun.tools.javac"); + private static final Logger logger = Logger.getLogger("com.sun.tools.javac"); static class CwdFileManager extends ForwardingJavaFileManager { String cwd; CwdFileManager(JavaFileManager fileManager) { @@ -69,7 +69,7 @@ class Server implements Runnable { // } } // static CwdFileManager fm = new CwdFileManager(tool.getStandardFileManager()); - static StandardJavaFileManager fm = tool.getStandardFileManager(null, null, null); + static final StandardJavaFileManager fm = tool.getStandardFileManager(null, null, null); static { // Use the same file manager for all compilations. This will // cache jar files in the standard file manager. Use diff --git a/langtools/src/share/classes/com/sun/tools/javac/code/Flags.java b/langtools/src/share/classes/com/sun/tools/javac/code/Flags.java index 36b669b6337..bbaba526807 100644 --- a/langtools/src/share/classes/com/sun/tools/javac/code/Flags.java +++ b/langtools/src/share/classes/com/sun/tools/javac/code/Flags.java @@ -307,7 +307,7 @@ public class Flags { } // Cache of modifier sets. - private static Map> modifierSets = + private static final Map> modifierSets = new java.util.concurrent.ConcurrentHashMap>(64); public static boolean isStatic(Symbol symbol) { @@ -356,7 +356,7 @@ public class Flags { VARARGS("varargs"), PACKAGE("package"); - String name; + private final String name; Flag(String name) { this.name = name; diff --git a/langtools/src/share/classes/com/sun/tools/javac/code/Kinds.java b/langtools/src/share/classes/com/sun/tools/javac/code/Kinds.java index 12d3703d1fd..08fbd1a57e4 100644 --- a/langtools/src/share/classes/com/sun/tools/javac/code/Kinds.java +++ b/langtools/src/share/classes/com/sun/tools/javac/code/Kinds.java @@ -110,7 +110,7 @@ public class Kinds { INSTANCE_INIT("kindname.instance.init"), PACKAGE("kindname.package"); - private String name; + private final String name; KindName(String name) { this.name = name; diff --git a/langtools/src/share/classes/com/sun/tools/javac/code/Lint.java b/langtools/src/share/classes/com/sun/tools/javac/code/Lint.java index 88573c593ca..552b4eeb1d4 100644 --- a/langtools/src/share/classes/com/sun/tools/javac/code/Lint.java +++ b/langtools/src/share/classes/com/sun/tools/javac/code/Lint.java @@ -28,11 +28,14 @@ package com.sun.tools.javac.code; import java.util.EnumSet; import java.util.HashMap; import java.util.Map; +import java.util.Set; +import javax.lang.model.element.Modifier; import com.sun.tools.javac.code.Symbol.*; import com.sun.tools.javac.util.Context; import com.sun.tools.javac.util.List; import com.sun.tools.javac.util.Options; import com.sun.tools.javac.util.Pair; + import static com.sun.tools.javac.code.Flags.*; @@ -95,7 +98,8 @@ public class Lint private final EnumSet values; private final EnumSet suppressedValues; - private static Map map = new HashMap(); + private static final Map map = + new java.util.concurrent.ConcurrentHashMap(20); protected Lint(Context context) { diff --git a/langtools/src/share/classes/com/sun/tools/javac/code/Source.java b/langtools/src/share/classes/com/sun/tools/javac/code/Source.java index 8066ea1be2c..18ebdfe1124 100644 --- a/langtools/src/share/classes/com/sun/tools/javac/code/Source.java +++ b/langtools/src/share/classes/com/sun/tools/javac/code/Source.java @@ -87,7 +87,7 @@ public enum Source { public final String name; - private static Map tab = new HashMap(); + private static final Map tab = new HashMap(); static { for (Source s : values()) { tab.put(s.name, s); diff --git a/langtools/src/share/classes/com/sun/tools/javac/code/TargetType.java b/langtools/src/share/classes/com/sun/tools/javac/code/TargetType.java index 573f6275ddd..45a90307f6e 100644 --- a/langtools/src/share/classes/com/sun/tools/javac/code/TargetType.java +++ b/langtools/src/share/classes/com/sun/tools/javac/code/TargetType.java @@ -166,7 +166,7 @@ public enum TargetType { static final int MAXIMUM_TARGET_TYPE_VALUE = 0x22; private final int targetTypeValue; - private Set flags; + private final Set flags; TargetType(int targetTypeValue, TargetAttribute... attributes) { if (targetTypeValue < Byte.MIN_VALUE @@ -233,10 +233,10 @@ public enum TargetType { return this.targetTypeValue; } - private static TargetType[] targets = null; + private static final TargetType[] targets; - private static TargetType[] buildTargets() { - TargetType[] targets = new TargetType[MAXIMUM_TARGET_TYPE_VALUE + 1]; + static { + targets = new TargetType[MAXIMUM_TARGET_TYPE_VALUE + 1]; TargetType[] alltargets = values(); for (TargetType target : alltargets) { if (target.targetTypeValue >= 0) @@ -246,13 +246,9 @@ public enum TargetType { if (targets[i] == null) targets[i] = UNKNOWN; } - return targets; } public static boolean isValidTargetTypeValue(int tag) { - if (targets == null) - targets = buildTargets(); - if (((byte)tag) == ((byte)UNKNOWN.targetTypeValue)) return true; @@ -260,9 +256,6 @@ public enum TargetType { } public static TargetType fromTargetTypeValue(int tag) { - if (targets == null) - targets = buildTargets(); - if (((byte)tag) == ((byte)UNKNOWN.targetTypeValue)) return UNKNOWN; diff --git a/langtools/src/share/classes/com/sun/tools/javac/code/TypeTag.java b/langtools/src/share/classes/com/sun/tools/javac/code/TypeTag.java index da6affeec42..d786621e918 100644 --- a/langtools/src/share/classes/com/sun/tools/javac/code/TypeTag.java +++ b/langtools/src/share/classes/com/sun/tools/javac/code/TypeTag.java @@ -135,9 +135,11 @@ public enum TypeTag { /** This field will only be used for tags related with numeric types for * optimization reasons. */ - private int order = 0; + private final int order; - private TypeTag() {} + private TypeTag() { + this(0); + } private TypeTag(int order) { this.order = order; diff --git a/langtools/src/share/classes/com/sun/tools/javac/code/Types.java b/langtools/src/share/classes/com/sun/tools/javac/code/Types.java index 342aeb986b3..88882955b4f 100644 --- a/langtools/src/share/classes/com/sun/tools/javac/code/Types.java +++ b/langtools/src/share/classes/com/sun/tools/javac/code/Types.java @@ -2849,7 +2849,7 @@ public class Types { } return tvars1; } - static private Mapping newInstanceFun = new Mapping("newInstanceFun") { + private static final Mapping newInstanceFun = new Mapping("newInstanceFun") { public Type apply(Type t) { return new TypeVar(t.tsym, t.getUpperBound(), t.getLowerBound()); } }; // diff --git a/langtools/src/share/classes/com/sun/tools/javac/comp/ConstFold.java b/langtools/src/share/classes/com/sun/tools/javac/comp/ConstFold.java index a0f9ec1b04b..2b6003ff0c4 100644 --- a/langtools/src/share/classes/com/sun/tools/javac/comp/ConstFold.java +++ b/langtools/src/share/classes/com/sun/tools/javac/comp/ConstFold.java @@ -62,9 +62,9 @@ strictfp class ConstFold { syms = Symtab.instance(context); } - static Integer minusOne = -1; - static Integer zero = 0; - static Integer one = 1; + static final Integer minusOne = -1; + static final Integer zero = 0; + static final Integer one = 1; /** Convert boolean to integer (true = 1, false = 0). */ diff --git a/langtools/src/share/classes/com/sun/tools/javac/comp/Flow.java b/langtools/src/share/classes/com/sun/tools/javac/comp/Flow.java index d0afb484158..21863e7f075 100644 --- a/langtools/src/share/classes/com/sun/tools/javac/comp/Flow.java +++ b/langtools/src/share/classes/com/sun/tools/javac/comp/Flow.java @@ -246,8 +246,8 @@ public class Flow { */ SPECULATIVE_LOOP("var.might.be.assigned.in.loop", true); - String errKey; - boolean isFinal; + final String errKey; + final boolean isFinal; FlowKind(String errKey, boolean isFinal) { this.errKey = errKey; @@ -295,7 +295,7 @@ public class Flow { } }; - JCTree.Tag treeTag; + final JCTree.Tag treeTag; private JumpKind(Tag treeTag) { this.treeTag = treeTag; diff --git a/langtools/src/share/classes/com/sun/tools/javac/comp/Resolve.java b/langtools/src/share/classes/com/sun/tools/javac/comp/Resolve.java index df783a26a69..5617d6ea351 100644 --- a/langtools/src/share/classes/com/sun/tools/javac/comp/Resolve.java +++ b/langtools/src/share/classes/com/sun/tools/javac/comp/Resolve.java @@ -156,7 +156,7 @@ public class Resolve { OBJECT_INIT("object-init"), INTERNAL("internal"); - String opt; + final String opt; private VerboseResolutionMode(String opt) { this.opt = opt; @@ -3381,8 +3381,8 @@ public class Resolve { } }; - boolean isBoxingRequired; - boolean isVarargsRequired; + final boolean isBoxingRequired; + final boolean isVarargsRequired; MethodResolutionPhase(boolean isBoxingRequired, boolean isVarargsRequired) { this.isBoxingRequired = isBoxingRequired; diff --git a/langtools/src/share/classes/com/sun/tools/javac/file/ZipFileIndex.java b/langtools/src/share/classes/com/sun/tools/javac/file/ZipFileIndex.java index dbb9f68a91f..e5c66ae8c20 100644 --- a/langtools/src/share/classes/com/sun/tools/javac/file/ZipFileIndex.java +++ b/langtools/src/share/classes/com/sun/tools/javac/file/ZipFileIndex.java @@ -83,7 +83,7 @@ public class ZipFileIndex { public final static long NOT_MODIFIED = Long.MIN_VALUE; - private static boolean NON_BATCH_MODE = System.getProperty("nonBatchMode") != null;// TODO: Use -XD compiler switch for this. + private static final boolean NON_BATCH_MODE = System.getProperty("nonBatchMode") != null;// TODO: Use -XD compiler switch for this. private Map directories = Collections.emptyMap(); diff --git a/langtools/src/share/classes/com/sun/tools/javac/jvm/Code.java b/langtools/src/share/classes/com/sun/tools/javac/jvm/Code.java index 59788f2a1d5..548d82d6281 100644 --- a/langtools/src/share/classes/com/sun/tools/javac/jvm/Code.java +++ b/langtools/src/share/classes/com/sun/tools/javac/jvm/Code.java @@ -1825,7 +1825,7 @@ public class Code { } } - static Type jsrReturnValue = new Type(INT, null); + static final Type jsrReturnValue = new Type(INT, null); /* ************************************************************************** diff --git a/langtools/src/share/classes/com/sun/tools/javac/jvm/Target.java b/langtools/src/share/classes/com/sun/tools/javac/jvm/Target.java index f6432b864a0..8323a05deed 100644 --- a/langtools/src/share/classes/com/sun/tools/javac/jvm/Target.java +++ b/langtools/src/share/classes/com/sun/tools/javac/jvm/Target.java @@ -86,17 +86,15 @@ public enum Target { return instance; } - private static Target MIN; + private static final Target MIN = values()[0]; public static Target MIN() { return MIN; } - private static Target MAX; + private static final Target MAX = values()[values().length - 1]; public static Target MAX() { return MAX; } - private static Map tab = new HashMap(); + private static final Map tab = new HashMap(); static { for (Target t : values()) { - if (MIN == null) MIN = t; - MAX = t; tab.put(t.name, t); } tab.put("5", JDK1_5); diff --git a/langtools/src/share/classes/com/sun/tools/javac/main/JavaCompiler.java b/langtools/src/share/classes/com/sun/tools/javac/main/JavaCompiler.java index 3181727e45a..c2fb0dfb780 100644 --- a/langtools/src/share/classes/com/sun/tools/javac/main/JavaCompiler.java +++ b/langtools/src/share/classes/com/sun/tools/javac/main/JavaCompiler.java @@ -189,7 +189,7 @@ public class JavaCompiler implements ClassReader.SourceCompleter { } } - private static CompilePolicy DEFAULT_COMPILE_POLICY = CompilePolicy.BY_TODO; + private static final CompilePolicy DEFAULT_COMPILE_POLICY = CompilePolicy.BY_TODO; protected static enum ImplicitSourcePolicy { /** Don't generate or process implicitly read source files. */ @@ -543,7 +543,7 @@ public class JavaCompiler implements ClassReader.SourceCompleter { public static CompileState max(CompileState a, CompileState b) { return a.value > b.value ? a : b; } - private int value; + private final int value; }; /** Partial map to record which compiler phases have been executed * for each compilation unit. Used for ATTR and FLOW phases. diff --git a/langtools/src/share/classes/com/sun/tools/javac/main/Option.java b/langtools/src/share/classes/com/sun/tools/javac/main/Option.java index 8a44ac4345c..70e5901848a 100644 --- a/langtools/src/share/classes/com/sun/tools/javac/main/Option.java +++ b/langtools/src/share/classes/com/sun/tools/javac/main/Option.java @@ -167,7 +167,6 @@ public enum Option { ENCODING("-encoding", "opt.arg.encoding", "opt.encoding", STANDARD, FILEMANAGER) { @Override public boolean process(OptionHelper helper, String option, String operand) { -// System.err.println("process encoding " + operand); return super.process(helper, option, operand); } @@ -246,9 +245,7 @@ public enum Option { } }, - A("-A", "opt.arg.key.equals.value", "opt.A", STANDARD, BASIC) { - { hasSuffix = true; } - + A("-A", "opt.arg.key.equals.value", "opt.A", STANDARD, BASIC, true) { @Override public boolean matches(String arg) { return arg.startsWith("-A"); @@ -293,8 +290,6 @@ public enum Option { // This option exists only for the purpose of documenting itself. // It's actually implemented by the launcher. J("-J", "opt.arg.flag", "opt.J", STANDARD, INFO) { - { hasSuffix = true; } - @Override public boolean process(OptionHelper helper, String option) { throw new AssertionError @@ -302,10 +297,6 @@ public enum Option { } }, - // stop after parsing and attributing. - // new HiddenOption("-attrparseonly"), - - // new Option("-moreinfo", "opt.moreinfo") { MOREINFO("-moreinfo", null, HIDDEN, BASIC) { @Override public boolean process(OptionHelper helper, String option) { @@ -317,23 +308,6 @@ public enum Option { // treat warnings as errors WERROR("-Werror", "opt.Werror", STANDARD, BASIC), -// // use complex inference from context in the position of a method call argument -// COMPLEXINFERENCE("-complexinference", null, HIDDEN, BASIC), - - // generare source stubs - // new HiddenOption("-stubs"), - - // relax some constraints to allow compiling from stubs - // new HiddenOption("-relax"), - - // output source after translating away inner classes - // new Option("-printflat", "opt.printflat"), - // new HiddenOption("-printflat"), - - // display scope search details - // new Option("-printsearch", "opt.printsearch"), - // new HiddenOption("-printsearch"), - // prompt after each error // new Option("-prompt", "opt.prompt"), PROMPT("-prompt", null, HIDDEN, BASIC), @@ -342,13 +316,8 @@ public enum Option { DOE("-doe", null, HIDDEN, BASIC), // output source after type erasure - // new Option("-s", "opt.s"), PRINTSOURCE("-printsource", null, HIDDEN, BASIC), - // output shrouded class files - // new Option("-scramble", "opt.scramble"), - // new Option("-scrambleall", "opt.scrambleall"), - // display warnings for generic unchecked operations WARNUNCHECKED("-warnunchecked", null, HIDDEN, BASIC) { @Override @@ -408,18 +377,16 @@ public enum Option { * -XDx sets the option x to the value x. */ XD("-XD", null, HIDDEN, BASIC) { - String s; @Override public boolean matches(String s) { - this.s = s; return s.startsWith(text); } @Override public boolean process(OptionHelper helper, String option) { - s = s.substring(text.length()); - int eq = s.indexOf('='); - String key = (eq < 0) ? s : s.substring(0, eq); - String value = (eq < 0) ? s : s.substring(eq+1); + option = option.substring(text.length()); + int eq = option.indexOf('='); + String key = (eq < 0) ? option : option.substring(0, eq); + String value = (eq < 0) ? option : option.substring(eq+1); helper.put(key, value); return false; } @@ -428,8 +395,6 @@ public enum Option { // This option exists only for the purpose of documenting itself. // It's actually implemented by the CommandLine class. AT("@", "opt.arg.file", "opt.AT", STANDARD, INFO) { - { hasSuffix = true; } - @Override public boolean process(OptionHelper helper, String option) { throw new AssertionError("the @ flag should be caught by CommandLine."); @@ -445,17 +410,15 @@ public enum Option { * name to a separate list. */ SOURCEFILE("sourcefile", null, HIDDEN, INFO) { - String s; @Override public boolean matches(String s) { - this.s = s; return s.endsWith(".java") // Java source file || SourceVersion.isName(s); // Legal type name } @Override public boolean process(OptionHelper helper, String option) { - if (s.endsWith(".java") ) { - File f = new File(s); + if (option.endsWith(".java") ) { + File f = new File(option); if (!f.exists()) { helper.error("err.file.not.found", f); return true; @@ -465,9 +428,9 @@ public enum Option { return true; } helper.addFile(f); + } else { + helper.addClassName(option); } - else - helper.addClassName(s); return false; } }; @@ -521,7 +484,7 @@ public enum Option { /** Suffix option (-foo=bar or -foo:bar) */ - boolean hasSuffix; + final boolean hasSuffix; /** The kind of choices for this option, if any. */ @@ -535,24 +498,30 @@ public enum Option { Option(String text, String descrKey, OptionKind kind, OptionGroup group) { - this(text, null, descrKey, kind, group, null, null); + this(text, null, descrKey, kind, group, null, null, false); } Option(String text, String argsNameKey, String descrKey, OptionKind kind, OptionGroup group) { - this(text, argsNameKey, descrKey, kind, group, null, null); + this(text, argsNameKey, descrKey, kind, group, null, null, false); + } + + Option(String text, String argsNameKey, String descrKey, + OptionKind kind, OptionGroup group, boolean doHasSuffix) { + this(text, argsNameKey, descrKey, kind, group, null, null, doHasSuffix); } Option(String text, String descrKey, OptionKind kind, OptionGroup group, ChoiceKind choiceKind, Map choices) { - this(text, null, descrKey, kind, group, choiceKind, choices); + this(text, null, descrKey, kind, group, choiceKind, choices, false); } Option(String text, String descrKey, OptionKind kind, OptionGroup group, ChoiceKind choiceKind, String... choices) { - this(text, null, descrKey, kind, group, choiceKind, createChoices(choices)); + this(text, null, descrKey, kind, group, choiceKind, + createChoices(choices), false); } // where private static Map createChoices(String... choices) { @@ -564,7 +533,8 @@ public enum Option { private Option(String text, String argsNameKey, String descrKey, OptionKind kind, OptionGroup group, - ChoiceKind choiceKind, Map choices) { + ChoiceKind choiceKind, Map choices, + boolean doHasSuffix) { this.text = text; this.argsNameKey = argsNameKey; this.descrKey = descrKey; @@ -573,7 +543,7 @@ public enum Option { this.choiceKind = choiceKind; this.choices = choices; char lastChar = text.charAt(text.length()-1); - hasSuffix = lastChar == ':' || lastChar == '='; + this.hasSuffix = doHasSuffix || lastChar == ':' || lastChar == '='; } public String getText() { diff --git a/langtools/src/share/classes/com/sun/tools/javac/parser/JavaTokenizer.java b/langtools/src/share/classes/com/sun/tools/javac/parser/JavaTokenizer.java index 20d3f4b93cd..2c77a712901 100644 --- a/langtools/src/share/classes/com/sun/tools/javac/parser/JavaTokenizer.java +++ b/langtools/src/share/classes/com/sun/tools/javac/parser/JavaTokenizer.java @@ -44,7 +44,7 @@ import static com.sun.tools.javac.util.LayoutCharacters.*; */ public class JavaTokenizer { - private static boolean scannerDebug = false; + private static final boolean scannerDebug = false; /** Allow hex floating-point literals. */ diff --git a/langtools/src/share/classes/com/sun/tools/javac/processing/JavacProcessingEnvironment.java b/langtools/src/share/classes/com/sun/tools/javac/processing/JavacProcessingEnvironment.java index 061d571478c..498ca34b415 100644 --- a/langtools/src/share/classes/com/sun/tools/javac/processing/JavacProcessingEnvironment.java +++ b/langtools/src/share/classes/com/sun/tools/javac/processing/JavacProcessingEnvironment.java @@ -1336,7 +1336,7 @@ public class JavacProcessingEnvironment implements ProcessingEnvironment, Closea return nodes; } - private static TreeScanner treeCleaner = new TreeScanner() { + private static final TreeScanner treeCleaner = new TreeScanner() { public void scan(JCTree node) { super.scan(node); if (node != null) diff --git a/langtools/src/share/classes/com/sun/tools/javac/tree/JCTree.java b/langtools/src/share/classes/com/sun/tools/javac/tree/JCTree.java index 2e65c5dfa46..269890eeb2b 100644 --- a/langtools/src/share/classes/com/sun/tools/javac/tree/JCTree.java +++ b/langtools/src/share/classes/com/sun/tools/javac/tree/JCTree.java @@ -340,15 +340,17 @@ public abstract class JCTree implements Tree, Cloneable, DiagnosticPosition { */ LETEXPR; // ala scheme - private Tag noAssignTag; + private final Tag noAssignTag; - private static int numberOfOperators = MOD.ordinal() - POS.ordinal() + 1; + private static final int numberOfOperators = MOD.ordinal() - POS.ordinal() + 1; private Tag(Tag noAssignTag) { this.noAssignTag = noAssignTag; } - private Tag() { } + private Tag() { + this(null); + } public static int getNumberOfOperators() { return numberOfOperators; @@ -1838,8 +1840,8 @@ public abstract class JCTree implements Tree, Cloneable, DiagnosticPosition { /** Toplevel # new */ TOPLEVEL(ReferenceMode.NEW, false); - ReferenceMode mode; - boolean unbound; + final ReferenceMode mode; + final boolean unbound; private ReferenceKind(ReferenceMode mode, boolean unbound) { this.mode = mode; diff --git a/langtools/src/share/classes/com/sun/tools/javac/util/BaseFileManager.java b/langtools/src/share/classes/com/sun/tools/javac/util/BaseFileManager.java index db3d662ba0e..cd27b07d4a7 100644 --- a/langtools/src/share/classes/com/sun/tools/javac/util/BaseFileManager.java +++ b/langtools/src/share/classes/com/sun/tools/javac/util/BaseFileManager.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2009, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -181,7 +181,7 @@ public abstract class BaseFileManager { return false; } // where - private static Set