stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8076055: cms: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files

Browse Source 
Reviewed-by: brutisso, tschatzl
This commit is contained in:
David Lindholm 2015-03-27 15:10:11 +01:00
parent dcd40878af
commit 04fdb5ca76
4 changed files with 43 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

82
hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp
View File

@ -65,8 +65,6 @@
#include "services/memoryService.hpp"
#include "services/runtimeService.hpp"
PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
// statics
CMSCollector* ConcurrentMarkSweepGeneration::_collector = NULL;
bool CMSCollector::_full_gc_requested = false;
@ -1593,7 +1591,7 @@ void CMSCollector::acquire_control_and_collect(bool full,
bitMapLock()->lock_without_safepoint_check();
if (TraceCMSState) {
gclog_or_tty->print_cr("CMS foreground collector has asked for control "
INTPTR_FORMAT " with first state %d", Thread::current(), first_state);
INTPTR_FORMAT " with first state %d", p2i(Thread::current()), first_state);
gclog_or_tty->print_cr(" gets control with state %d", _collectorState);
}
@ -1763,27 +1761,27 @@ void CMSCollector::print_eden_and_survivor_chunk_arrays() {
// Eden
if (_eden_chunk_array != NULL) {
gclog_or_tty->print_cr("eden " PTR_FORMAT "-" PTR_FORMAT "-" PTR_FORMAT "(" SIZE_FORMAT ")",
eden_space->bottom(), eden_space->top(),
eden_space->end(), eden_space->capacity());
p2i(eden_space->bottom()), p2i(eden_space->top()),
p2i(eden_space->end()), eden_space->capacity());
gclog_or_tty->print_cr("_eden_chunk_index=" SIZE_FORMAT ", "
"_eden_chunk_capacity=" SIZE_FORMAT,
_eden_chunk_index, _eden_chunk_capacity);
for (size_t i = 0; i < _eden_chunk_index; i++) {
gclog_or_tty->print_cr("_eden_chunk_array[" SIZE_FORMAT "]=" PTR_FORMAT,
i, _eden_chunk_array[i]);
i, p2i(_eden_chunk_array[i]));
}
}
// Survivor
if (_survivor_chunk_array != NULL) {
gclog_or_tty->print_cr("survivor " PTR_FORMAT "-" PTR_FORMAT "-" PTR_FORMAT "(" SIZE_FORMAT ")",
from_space->bottom(), from_space->top(),
from_space->end(), from_space->capacity());
p2i(from_space->bottom()), p2i(from_space->top()),
p2i(from_space->end()), from_space->capacity());
gclog_or_tty->print_cr("_survivor_chunk_index=" SIZE_FORMAT ", "
"_survivor_chunk_capacity=" SIZE_FORMAT,
_survivor_chunk_index, _survivor_chunk_capacity);
for (size_t i = 0; i < _survivor_chunk_index; i++) {
gclog_or_tty->print_cr("_survivor_chunk_array[" SIZE_FORMAT "]=" PTR_FORMAT,
i, _survivor_chunk_array[i]);
i, p2i(_survivor_chunk_array[i]));
}
}
}
@ -1890,7 +1888,7 @@ void CMSCollector::collect_in_background(GCCause::Cause cause) {
while (_collectorState != Idling) {
if (TraceCMSState) {
gclog_or_tty->print_cr("Thread " INTPTR_FORMAT " in CMS state %d",
Thread::current(), _collectorState);
p2i(Thread::current()), _collectorState);
}
// The foreground collector
// holds the Heap_lock throughout its collection.
@ -1924,7 +1922,7 @@ void CMSCollector::collect_in_background(GCCause::Cause cause) {
if (TraceCMSState) {
gclog_or_tty->print_cr("CMS Thread " INTPTR_FORMAT
" exiting collection CMS state %d",
Thread::current(), _collectorState);
p2i(Thread::current()), _collectorState);
}
return;
} else {
@ -2031,7 +2029,7 @@ void CMSCollector::collect_in_background(GCCause::Cause cause) {
}
if (TraceCMSState) {
gclog_or_tty->print_cr(" Thread " INTPTR_FORMAT " done - next CMS state %d",
Thread::current(), _collectorState);
p2i(Thread::current()), _collectorState);
}
assert(_foregroundGCShouldWait, "block post-condition");
}
@ -2054,7 +2052,7 @@ void CMSCollector::collect_in_background(GCCause::Cause cause) {
if (TraceCMSState) {
gclog_or_tty->print_cr("CMS Thread " INTPTR_FORMAT
" exiting collection CMS state %d",
Thread::current(), _collectorState);
p2i(Thread::current()), _collectorState);
}
if (PrintGC && Verbose) {
_cmsGen->print_heap_change(prev_used);
@ -2112,7 +2110,7 @@ bool CMSCollector::waitForForegroundGC() {
CGC_lock->notify();
if (TraceCMSState) {
gclog_or_tty->print_cr("CMS Thread " INTPTR_FORMAT " waiting at CMS state %d",
Thread::current(), _collectorState);
p2i(Thread::current()), _collectorState);
}
while (_foregroundGCIsActive) {
CGC_lock->wait(Mutex::_no_safepoint_check_flag);
@ -2124,7 +2122,7 @@ bool CMSCollector::waitForForegroundGC() {
}
if (TraceCMSState) {
gclog_or_tty->print_cr("CMS Thread " INTPTR_FORMAT " continuing at CMS state %d",
Thread::current(), _collectorState);
p2i(Thread::current()), _collectorState);
}
return res;
}
@ -2356,13 +2354,13 @@ bool CMSCollector::is_cms_reachable(HeapWord* addr) {
// Clear the marking bit map array before starting, but, just
// for kicks, first report if the given address is already marked
gclog_or_tty->print_cr("Start: Address " PTR_FORMAT " is%s marked", addr,
gclog_or_tty->print_cr("Start: Address " PTR_FORMAT " is%s marked", p2i(addr),
_markBitMap.isMarked(addr) ? "" : " not");
if (verify_after_remark()) {
MutexLockerEx x(verification_mark_bm()->lock(), Mutex::_no_safepoint_check_flag);
bool result = verification_mark_bm()->isMarked(addr);
gclog_or_tty->print_cr("TransitiveMark: Address " PTR_FORMAT " %s marked", addr,
gclog_or_tty->print_cr("TransitiveMark: Address " PTR_FORMAT " %s marked", p2i(addr),
result ? "IS" : "is NOT");
return result;
} else {
@ -2377,13 +2375,13 @@ CMSCollector::print_on_error(outputStream* st) {
CMSCollector* collector = ConcurrentMarkSweepGeneration::_collector;
if (collector != NULL) {
CMSBitMap* bitmap = &collector->_markBitMap;
st->print_cr("Marking Bits: (CMSBitMap*) " PTR_FORMAT, bitmap);
st->print_cr("Marking Bits: (CMSBitMap*) " PTR_FORMAT, p2i(bitmap));
bitmap->print_on_error(st, " Bits: ");
st->cr();
CMSBitMap* mut_bitmap = &collector->_modUnionTable;
st->print_cr("Mod Union Table: (CMSBitMap*) " PTR_FORMAT, mut_bitmap);
st->print_cr("Mod Union Table: (CMSBitMap*) " PTR_FORMAT, p2i(mut_bitmap));
mut_bitmap->print_on_error(st, " Bits: ");
}
}
@ -2406,7 +2404,7 @@ class VerifyMarkedClosure: public BitMapClosure {
HeapWord* addr = _marks->offsetToHeapWord(offset);
if (!_marks->isMarked(addr)) {
oop(addr)->print_on(gclog_or_tty);
gclog_or_tty->print_cr(" ("INTPTR_FORMAT" should have been marked)", addr);
gclog_or_tty->print_cr(" ("INTPTR_FORMAT" should have been marked)", p2i(addr));
_failed = true;
}
return true;
@ -2474,7 +2472,7 @@ bool CMSCollector::verify_after_remark(bool silent) {
// presumably, a mutation to A failed to be picked up by preclean/remark?
verify_after_remark_work_2();
} else {
warning("Unrecognized value %d for CMSRemarkVerifyVariant",
warning("Unrecognized value " UINTX_FORMAT " for CMSRemarkVerifyVariant",
CMSRemarkVerifyVariant);
}
if (!silent) gclog_or_tty->print(" done] ");
@ -5056,7 +5054,7 @@ void CMSCollector::merge_survivor_plab_arrays(ContiguousSpace* surv,
for (size_t i = 0; i < total - 1; i++) {
if (PrintCMSStatistics > 0) {
gclog_or_tty->print(" (chunk" SIZE_FORMAT ":" INTPTR_FORMAT ") ",
i, _survivor_chunk_array[i]);
i, p2i(_survivor_chunk_array[i]));
}
assert(_survivor_chunk_array[i] < _survivor_chunk_array[i+1],
"Not sorted");
@ -5700,8 +5698,8 @@ void ConcurrentMarkSweepGeneration::setNearLargestChunk() {
gclog_or_tty->print_cr(
"CMS: Large Block: " PTR_FORMAT ";"
" Proximity: " PTR_FORMAT " -> " PTR_FORMAT,
largestAddr,
_cmsSpace->nearLargestChunk(), minAddr + nearLargestOffset);
p2i(largestAddr),
p2i(_cmsSpace->nearLargestChunk()), p2i(minAddr + nearLargestOffset));
}
_cmsSpace->set_nearLargestChunk(minAddr + nearLargestOffset);
}
@ -6184,7 +6182,7 @@ void MarkRefsIntoVerifyClosure::do_oop(oop obj) {
_verification_bm->mark(addr);
if (!_cms_bm->isMarked(addr)) {
oop(addr)->print();
gclog_or_tty->print_cr(" (" INTPTR_FORMAT " should have been marked)", addr);
gclog_or_tty->print_cr(" (" INTPTR_FORMAT " should have been marked)", p2i(addr));
fatal("... aborting");
}
}
@ -6979,7 +6977,7 @@ void PushAndMarkVerifyClosure::do_oop(oop obj) {
if (!_cms_bm->isMarked(addr)) {
oop(addr)->print();
gclog_or_tty->print_cr(" (" INTPTR_FORMAT " should have been marked)",
addr);
p2i(addr));
fatal("... aborting");
}
@ -7375,16 +7373,16 @@ SweepClosure::SweepClosure(CMSCollector* collector,
"sweep _limit out of bounds");
if (CMSTraceSweeper) {
gclog_or_tty->print_cr("\n====================\nStarting new sweep with limit " PTR_FORMAT,
_limit);
p2i(_limit));
}
}
void SweepClosure::print_on(outputStream* st) const {
tty->print_cr("_sp = [" PTR_FORMAT "," PTR_FORMAT ")",
_sp->bottom(), _sp->end());
tty->print_cr("_limit = " PTR_FORMAT, _limit);
tty->print_cr("_freeFinger = " PTR_FORMAT, _freeFinger);
NOT_PRODUCT(tty->print_cr("_last_fc = " PTR_FORMAT, _last_fc);)
p2i(_sp->bottom()), p2i(_sp->end()));
tty->print_cr("_limit = " PTR_FORMAT, p2i(_limit));
tty->print_cr("_freeFinger = " PTR_FORMAT, p2i(_freeFinger));
NOT_PRODUCT(tty->print_cr("_last_fc = " PTR_FORMAT, p2i(_last_fc));)
tty->print_cr("_inFreeRange = %d, _freeRangeInFreeLists = %d, _lastFreeRangeCoalesced = %d",
_inFreeRange, _freeRangeInFreeLists, _lastFreeRangeCoalesced);
}
@ -7428,7 +7426,7 @@ SweepClosure::~SweepClosure() {
}
if (CMSTraceSweeper) {
gclog_or_tty->print_cr("end of sweep with _limit = " PTR_FORMAT "\n================",
_limit);
p2i(_limit));
}
}
#endif // PRODUCT
@ -7437,7 +7435,7 @@ void SweepClosure::initialize_free_range(HeapWord* freeFinger,
bool freeRangeInFreeLists) {
if (CMSTraceSweeper) {
gclog_or_tty->print("---- Start free range at " PTR_FORMAT " with free block (%d)\n",
freeFinger, freeRangeInFreeLists);
p2i(freeFinger), freeRangeInFreeLists);
}
assert(!inFreeRange(), "Trampling existing free range");
set_inFreeRange(true);
@ -7501,14 +7499,14 @@ size_t SweepClosure::do_blk_careful(HeapWord* addr) {
// coalesced chunk to the appropriate free list.
if (inFreeRange()) {
assert(freeFinger() >= _sp->bottom() && freeFinger() < _limit,
err_msg("freeFinger() " PTR_FORMAT" is out-of-bounds", freeFinger()));
err_msg("freeFinger() " PTR_FORMAT" is out-of-bounds", p2i(freeFinger())));
flush_cur_free_chunk(freeFinger(),
pointer_delta(addr, freeFinger()));
if (CMSTraceSweeper) {
gclog_or_tty->print("Sweep: last chunk: ");
gclog_or_tty->print("put_free_blk " PTR_FORMAT " ("SIZE_FORMAT") "
"[coalesced:%d]\n",
freeFinger(), pointer_delta(addr, freeFinger()),
p2i(freeFinger()), pointer_delta(addr, freeFinger()),
lastFreeRangeCoalesced() ? 1 : 0);
}
}
@ -7652,7 +7650,7 @@ void SweepClosure::do_already_free_chunk(FreeChunk* fc) {
// the midst of a free range, we are coalescing
print_free_block_coalesced(fc);
if (CMSTraceSweeper) {
gclog_or_tty->print(" -- pick up free block " PTR_FORMAT " (" SIZE_FORMAT ")\n", fc, size);
gclog_or_tty->print(" -- pick up free block " PTR_FORMAT " (" SIZE_FORMAT ")\n", p2i(fc), size);
}
// remove it from the free lists
_sp->removeFreeChunkFromFreeLists(fc);
@ -7714,7 +7712,7 @@ size_t SweepClosure::do_garbage_chunk(FreeChunk* fc) {
// this will be swept up when we hit the end of the
// free range
if (CMSTraceSweeper) {
gclog_or_tty->print(" -- pick up garbage " PTR_FORMAT " (" SIZE_FORMAT ")\n", fc, size);
gclog_or_tty->print(" -- pick up garbage " PTR_FORMAT " (" SIZE_FORMAT ")\n", p2i(fc), size);
}
// If the chunk is being coalesced and the current free range is
// in the free lists, remove the current free range so that it
@ -7807,7 +7805,7 @@ void SweepClosure::do_post_free_or_garbage_chunk(FreeChunk* fc,
}
if (CMSTraceSweeper) {
gclog_or_tty->print_cr(" -- pick up another chunk at " PTR_FORMAT " (" SIZE_FORMAT ")", fc, chunkSize);
gclog_or_tty->print_cr(" -- pick up another chunk at " PTR_FORMAT " (" SIZE_FORMAT ")", p2i(fc), chunkSize);
}
HeapWord* const fc_addr = (HeapWord*) fc;
@ -7906,14 +7904,14 @@ void SweepClosure::lookahead_and_flush(FreeChunk* fc, size_t chunk_size) {
err_msg("eob = " PTR_FORMAT " eob-1 = " PTR_FORMAT " _limit = " PTR_FORMAT
" out of bounds wrt _sp = [" PTR_FORMAT "," PTR_FORMAT ")"
" when examining fc = " PTR_FORMAT "(" SIZE_FORMAT ")",
eob, eob-1, _limit, _sp->bottom(), _sp->end(), fc, chunk_size));
p2i(eob), p2i(eob-1), p2i(_limit), p2i(_sp->bottom()), p2i(_sp->end()), p2i(fc), chunk_size));
if (eob >= _limit) {
assert(eob == _limit || fc->is_free(), "Only a free chunk should allow us to cross over the limit");
if (CMSTraceSweeper) {
gclog_or_tty->print_cr("_limit " PTR_FORMAT " reached or crossed by block "
"[" PTR_FORMAT "," PTR_FORMAT ") in space "
"[" PTR_FORMAT "," PTR_FORMAT ")",
_limit, fc, eob, _sp->bottom(), _sp->end());
p2i(_limit), p2i(fc), p2i(eob), p2i(_sp->bottom()), p2i(_sp->end()));
}
// Return the storage we are tracking back into the free lists.
if (CMSTraceSweeper) {
@ -7937,7 +7935,7 @@ void SweepClosure::flush_cur_free_chunk(HeapWord* chunk, size_t size) {
}
if (CMSTraceSweeper) {
gclog_or_tty->print_cr(" -- add free block " PTR_FORMAT " (" SIZE_FORMAT ") to free lists",
chunk, size);
p2i(chunk), size);
}
// A new free range is going to be starting. The current
// free range has not been added to the free lists yet or
@ -8010,7 +8008,7 @@ bool debug_verify_chunk_in_free_list(FreeChunk* fc) {
void SweepClosure::print_free_block_coalesced(FreeChunk* fc) const {
if (CMSTraceSweeper) {
gclog_or_tty->print_cr("Sweep:coal_free_blk " PTR_FORMAT " (" SIZE_FORMAT ")",
fc, fc->size());
p2i(fc), fc->size());
}
}

4
hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/freeChunk.cpp
View File

@ -27,8 +27,6 @@
#include "memory/freeBlockDictionary.hpp"
#include "utilities/copy.hpp"
PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
#ifndef PRODUCT
#define baadbabeHeapWord badHeapWordVal
@ -74,5 +72,5 @@ void FreeChunk::verifyList() const {
void FreeChunk::print_on(outputStream* st) {
st->print_cr("Next: " PTR_FORMAT " Prev: " PTR_FORMAT " %s",
next(), prev(), cantCoalesce() ? "[can't coalesce]" : "");
p2i(next()), p2i(prev()), cantCoalesce() ? "[can't coalesce]" : "");
}

6
hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/promotionInfo.cpp
View File

@ -28,8 +28,6 @@
#include "oops/markOop.inline.hpp"
#include "oops/oop.inline.hpp"
PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
/////////////////////////////////////////////////////////////////////////
//// PromotionInfo
/////////////////////////////////////////////////////////////////////////
@ -360,6 +358,6 @@ void PromotionInfo::print_on(outputStream* st) const {
void SpoolBlock::print_on(outputStream* st) const {
st->print("[" PTR_FORMAT "," PTR_FORMAT "), " SIZE_FORMAT " HeapWords -> " PTR_FORMAT,
this, (HeapWord*)displacedHdr + bufferSize,
bufferSize, nextSpoolBlock);
p2i(this), p2i((HeapWord*)displacedHdr + bufferSize),
bufferSize, p2i(nextSpoolBlock));
}

2
hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/vmCMSOperations.cpp
View File

@ -34,8 +34,6 @@
#include "runtime/os.hpp"
#include "utilities/dtrace.hpp"
PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
//////////////////////////////////////////////////////////
// Methods in abstract class VM_CMS_Operation
//////////////////////////////////////////////////////////