Merge
This commit is contained in:
Lev Serebryakov
commit
77e87e05ad
.hgtags.hgtags-top-repo
corba
hotspot
.hgtags
agent/src/share/classes/sun/jvm/hotspot
src/share/vm
classfile
gc_implementation
concurrentMarkSweep
compactibleFreeListSpace.cppconcurrentMarkSweepGeneration.cppfreeBlockDictionary.hppfreeChunk.cppfreeChunk.hppvmStructs_cms.hpp
includeDB_gc_concurrentMarkSweepshared
oops
opto
runtime
jaxp
jaxws
jdk
.hgtags
make
src
share/classes
java/awt
javax/management/modelmbean
sun/security/provider/certpath
solaris/native/java/net
windows/native/sun/windows
test
javax/management/Introspector
sun/security
langtools
.hgtags
src/share/classes
com/sun/tools/javac
code
comp
util
zip
sun/tools/javap
test/tools/javac
make
1
.hgtags
1
.hgtags
@ -2,3 +2,4 @@
|
||||
bf2517e15f0c0f950e5b3143c4ca11e2df73dcc1 jdk7-b25
|
||||
5ae7db536e3fcf6be78e45b240a9058095e0ed38 jdk7-b26
|
||||
67052ac87fc927d048e62ec54ff42adb230d3f7c jdk7-b27
|
||||
18dc4ba4739a537fd146f77da51db16efce28da2 jdk7-b28
|
||||
|
||||
@ -2,3 +2,4 @@ cfeea66a3fa8ca3686a7cfa2d0ce8ab0169f168d jdk7-b24
|
||||
cbc8ad9dd0e085a607427ea35411990982f19a36 jdk7-b25
|
||||
9410f77cc30c604d1caf7c9fe3a57fa19e1acbe8 jdk7-b26
|
||||
11b4dc9f2be3523ef989a0db8459eb56b3045c3a jdk7-b27
|
||||
56652b46f328937f6b9b5130f1e4cd80f48868ef jdk7-b28
|
||||
|
||||
@ -2,3 +2,4 @@
|
||||
5e61d5df62586474414d1058e9186441aa908f51 jdk7-b25
|
||||
0043eb3d4e628f049ff80a8c223b5657136085e7 jdk7-b26
|
||||
e84e9018bebbf3e5bafc5706e7882a15cb1c7d99 jdk7-b27
|
||||
27509b7d21ed783b3f6eb7b7612781c675a30c2f jdk7-b28
|
||||
|
||||
@ -31,6 +31,9 @@ COMPILER_NAME=Sun Studio
|
||||
|
||||
# Sun Studio Compiler settings specific to Solaris
|
||||
ifeq ($(PLATFORM), solaris)
|
||||
# FIXUP: Change to SS12 when validated
|
||||
#COMPILER_VERSION=SS12
|
||||
#REQUIRED_CC_VER=5.9
|
||||
COMPILER_VERSION=SS11
|
||||
REQUIRED_CC_VER=5.8
|
||||
CC = $(COMPILER_PATH)cc
|
||||
@ -51,8 +54,8 @@ endif
|
||||
# Sun Studio Compiler settings specific to Linux
|
||||
ifeq ($(PLATFORM), linux)
|
||||
# This has not been tested
|
||||
COMPILER_VERSION=SS11
|
||||
REQUIRED_CC_VER=5.8
|
||||
COMPILER_VERSION=SS12
|
||||
REQUIRED_CC_VER=5.9
|
||||
CC = $(COMPILER_PATH)cc
|
||||
CPP = $(COMPILER_PATH)cc -E
|
||||
CXX = $(COMPILER_PATH)CC
|
||||
|
||||
@ -123,9 +123,15 @@ if [ "${osname}" = SunOS ] ; then
|
||||
solaris_arch=i386
|
||||
fi
|
||||
|
||||
# Get the SS11 compilers into path (make sure it matches ALT setting)
|
||||
compiler_path=${jdk_devtools}/${solaris_arch}/SUNWspro/SS11/bin
|
||||
compiler_name=SS11
|
||||
# Get the compilers into path (make sure it matches ALT setting)
|
||||
if [ "${JPRT_SOLARIS_COMPILER_NAME}" != "" ] ; then
|
||||
compiler_name=${JPRT_SOLARIS_COMPILER_NAME}
|
||||
else
|
||||
# FIXUP: Change to SS12 when validated
|
||||
#compiler_name=SS12
|
||||
compiler_name=SS11
|
||||
fi
|
||||
compiler_path=${jdk_devtools}/${solaris_arch}/SUNWspro/${compiler_name}/bin
|
||||
ALT_COMPILER_PATH="${compiler_path}"
|
||||
export ALT_COMPILER_PATH
|
||||
dirMustExist "${compiler_path}" ALT_COMPILER_PATH
|
||||
|
||||
@ -2,3 +2,4 @@ a61af66fc99eb5ec9d50c05b0c599757b1289ceb jdk7-b24
|
||||
7836be3e92d0a4f9ee7566f602c91f5609534e66 jdk7-b25
|
||||
ad0b851458ff9d1d490ed2d79bb84f75a9fdb753 jdk7-b26
|
||||
e3d2692f8442e2d951166dc9bd9a330684754438 jdk7-b27
|
||||
c14dab40ed9bf45ad21150bd70c9c80cdf655415 jdk7-b28
|
||||
|
||||
@ -189,7 +189,7 @@ public class CompactibleFreeListSpace extends CompactibleSpace {
|
||||
cur = cur.addOffsetTo(adjustObjectSizeInBytes(size));
|
||||
}
|
||||
|
||||
if (FreeChunk.secondWordIndicatesFreeChunk(dbg.getAddressValue(klassOop))) {
|
||||
if (FreeChunk.indicatesFreeChunk(cur)) {
|
||||
if (! cur.equals(regionStart)) {
|
||||
res.add(new MemRegion(regionStart, cur));
|
||||
}
|
||||
|
||||
@ -28,6 +28,7 @@ import java.util.*;
|
||||
import sun.jvm.hotspot.debugger.*;
|
||||
import sun.jvm.hotspot.types.*;
|
||||
import sun.jvm.hotspot.runtime.*;
|
||||
import sun.jvm.hotspot.oops.*;
|
||||
|
||||
public class FreeChunk extends VMObject {
|
||||
static {
|
||||
@ -42,13 +43,13 @@ public class FreeChunk extends VMObject {
|
||||
Type type = db.lookupType("FreeChunk");
|
||||
nextField = type.getAddressField("_next");
|
||||
prevField = type.getAddressField("_prev");
|
||||
sizeField = type.getCIntegerField("_size");
|
||||
sizeField = type.getAddressField("_size");
|
||||
}
|
||||
|
||||
// Fields
|
||||
private static AddressField nextField;
|
||||
private static AddressField prevField;
|
||||
private static CIntegerField sizeField;
|
||||
private static AddressField sizeField;
|
||||
|
||||
// Accessors
|
||||
public FreeChunk next() {
|
||||
@ -61,20 +62,34 @@ public class FreeChunk extends VMObject {
|
||||
}
|
||||
|
||||
public long size() {
|
||||
return sizeField.getValue(addr);
|
||||
if (VM.getVM().isCompressedOopsEnabled()) {
|
||||
Mark mark = new Mark(sizeField.getValue(addr));
|
||||
return mark.getSize();
|
||||
} else {
|
||||
Address size = sizeField.getValue(addr);
|
||||
Debugger dbg = VM.getVM().getDebugger();
|
||||
return dbg.getAddressValue(size);
|
||||
}
|
||||
}
|
||||
|
||||
public FreeChunk(Address addr) {
|
||||
super(addr);
|
||||
}
|
||||
|
||||
public static boolean secondWordIndicatesFreeChunk(long word) {
|
||||
return (word & 0x1L) == 0x1L;
|
||||
public static boolean indicatesFreeChunk(Address cur) {
|
||||
FreeChunk f = new FreeChunk(cur);
|
||||
return f.isFree();
|
||||
}
|
||||
|
||||
public boolean isFree() {
|
||||
Debugger dbg = VM.getVM().getDebugger();
|
||||
Address prev = prevField.getValue(addr);
|
||||
return secondWordIndicatesFreeChunk(dbg.getAddressValue(prev));
|
||||
if (VM.getVM().isCompressedOopsEnabled()) {
|
||||
Mark mark = new Mark(sizeField.getValue(addr));
|
||||
return mark.isCmsFreeChunk();
|
||||
} else {
|
||||
Address prev = prevField.getValue(addr);
|
||||
Debugger dbg = VM.getVM().getDebugger();
|
||||
long word = dbg.getAddressValue(prev);
|
||||
return (word & 0x1L) == 0x1L;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -79,6 +79,11 @@ public class Mark extends VMObject {
|
||||
noHashInPlace = db.lookupLongConstant("markOopDesc::no_hash_in_place").longValue();
|
||||
noLockInPlace = db.lookupLongConstant("markOopDesc::no_lock_in_place").longValue();
|
||||
maxAge = db.lookupLongConstant("markOopDesc::max_age").longValue();
|
||||
|
||||
/* Constants in markOop used by CMS. */
|
||||
cmsShift = db.lookupLongConstant("markOopDesc::cms_shift").longValue();
|
||||
cmsMask = db.lookupLongConstant("markOopDesc::cms_mask").longValue();
|
||||
sizeShift = db.lookupLongConstant("markOopDesc::size_shift").longValue();
|
||||
}
|
||||
|
||||
// Field accessors
|
||||
@ -120,6 +125,11 @@ public class Mark extends VMObject {
|
||||
|
||||
private static long maxAge;
|
||||
|
||||
/* Constants in markOop used by CMS. */
|
||||
private static long cmsShift;
|
||||
private static long cmsMask;
|
||||
private static long sizeShift;
|
||||
|
||||
public Mark(Address addr) {
|
||||
super(addr);
|
||||
}
|
||||
@ -290,4 +300,11 @@ public class Mark extends VMObject {
|
||||
//
|
||||
// // Recover address of oop from encoded form used in mark
|
||||
// inline void* decode_pointer() { return clear_lock_bits(); }
|
||||
|
||||
// Copy markOop methods for CMS here.
|
||||
public boolean isCmsFreeChunk() {
|
||||
return isUnlocked() &&
|
||||
(Bits.maskBitsLong(value() >> cmsShift, cmsMask) & 0x1L) == 0x1L;
|
||||
}
|
||||
public long getSize() { return (long)(value() >> sizeShift); }
|
||||
}
|
||||
|
||||
@ -283,6 +283,7 @@
|
||||
template(cache_field_name, "cache") \
|
||||
template(value_name, "value") \
|
||||
template(frontCacheEnabled_name, "frontCacheEnabled") \
|
||||
template(stringCacheEnabled_name, "stringCacheEnabled") \
|
||||
\
|
||||
/* non-intrinsic name/signature pairs: */ \
|
||||
template(register_method_name, "register") \
|
||||
|
||||
@ -805,28 +805,30 @@ size_t CompactibleFreeListSpace::block_size(const HeapWord* p) const {
|
||||
// This must be volatile, or else there is a danger that the compiler
|
||||
// will compile the code below into a sometimes-infinite loop, by keeping
|
||||
// the value read the first time in a register.
|
||||
oop o = (oop)p;
|
||||
volatile oop* second_word_addr = o->klass_addr();
|
||||
while (true) {
|
||||
klassOop k = (klassOop)(*second_word_addr);
|
||||
// We must do this until we get a consistent view of the object.
|
||||
if (FreeChunk::secondWordIndicatesFreeChunk((intptr_t)k)) {
|
||||
FreeChunk* fc = (FreeChunk*)p;
|
||||
volatile size_t* sz_addr = (volatile size_t*)(fc->size_addr());
|
||||
size_t res = (*sz_addr);
|
||||
klassOop k2 = (klassOop)(*second_word_addr); // Read to confirm.
|
||||
if (k == k2) {
|
||||
if (FreeChunk::indicatesFreeChunk(p)) {
|
||||
volatile FreeChunk* fc = (volatile FreeChunk*)p;
|
||||
size_t res = fc->size();
|
||||
// If the object is still a free chunk, return the size, else it
|
||||
// has been allocated so try again.
|
||||
if (FreeChunk::indicatesFreeChunk(p)) {
|
||||
assert(res != 0, "Block size should not be 0");
|
||||
return res;
|
||||
}
|
||||
} else {
|
||||
// must read from what 'p' points to in each loop.
|
||||
klassOop k = ((volatile oopDesc*)p)->klass_or_null();
|
||||
if (k != NULL) {
|
||||
assert(k->is_oop(true /* ignore mark word */), "Should really be klass oop.");
|
||||
oop o = (oop)p;
|
||||
assert(o->is_parsable(), "Should be parsable");
|
||||
assert(o->is_oop(true /* ignore mark word */), "Should be an oop.");
|
||||
size_t res = o->size_given_klass(k->klass_part());
|
||||
res = adjustObjectSize(res);
|
||||
assert(res != 0, "Block size should not be 0");
|
||||
return res;
|
||||
}
|
||||
} else if (k != NULL) {
|
||||
assert(k->is_oop(true /* ignore mark word */), "Should really be klass oop.");
|
||||
assert(o->is_parsable(), "Should be parsable");
|
||||
assert(o->is_oop(true /* ignore mark word */), "Should be an oop.");
|
||||
size_t res = o->size_given_klass(k->klass_part());
|
||||
res = adjustObjectSize(res);
|
||||
assert(res != 0, "Block size should not be 0");
|
||||
return res;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -845,31 +847,31 @@ const {
|
||||
// This must be volatile, or else there is a danger that the compiler
|
||||
// will compile the code below into a sometimes-infinite loop, by keeping
|
||||
// the value read the first time in a register.
|
||||
oop o = (oop)p;
|
||||
volatile oop* second_word_addr = o->klass_addr();
|
||||
DEBUG_ONLY(uint loops = 0;)
|
||||
while (true) {
|
||||
klassOop k = (klassOop)(*second_word_addr);
|
||||
// We must do this until we get a consistent view of the object.
|
||||
if (FreeChunk::secondWordIndicatesFreeChunk((intptr_t)k)) {
|
||||
FreeChunk* fc = (FreeChunk*)p;
|
||||
volatile size_t* sz_addr = (volatile size_t*)(fc->size_addr());
|
||||
size_t res = (*sz_addr);
|
||||
klassOop k2 = (klassOop)(*second_word_addr); // Read to confirm.
|
||||
if (k == k2) {
|
||||
if (FreeChunk::indicatesFreeChunk(p)) {
|
||||
volatile FreeChunk* fc = (volatile FreeChunk*)p;
|
||||
size_t res = fc->size();
|
||||
if (FreeChunk::indicatesFreeChunk(p)) {
|
||||
assert(res != 0, "Block size should not be 0");
|
||||
assert(loops == 0, "Should be 0");
|
||||
return res;
|
||||
}
|
||||
} else if (k != NULL && o->is_parsable()) {
|
||||
assert(k->is_oop(), "Should really be klass oop.");
|
||||
assert(o->is_oop(), "Should be an oop");
|
||||
size_t res = o->size_given_klass(k->klass_part());
|
||||
res = adjustObjectSize(res);
|
||||
assert(res != 0, "Block size should not be 0");
|
||||
return res;
|
||||
} else {
|
||||
return c->block_size_if_printezis_bits(p);
|
||||
// must read from what 'p' points to in each loop.
|
||||
klassOop k = ((volatile oopDesc*)p)->klass_or_null();
|
||||
if (k != NULL && ((oopDesc*)p)->is_parsable()) {
|
||||
assert(k->is_oop(), "Should really be klass oop.");
|
||||
oop o = (oop)p;
|
||||
assert(o->is_oop(), "Should be an oop");
|
||||
size_t res = o->size_given_klass(k->klass_part());
|
||||
res = adjustObjectSize(res);
|
||||
assert(res != 0, "Block size should not be 0");
|
||||
return res;
|
||||
} else {
|
||||
return c->block_size_if_printezis_bits(p);
|
||||
}
|
||||
}
|
||||
assert(loops == 0, "Can loop at most once");
|
||||
DEBUG_ONLY(loops++;)
|
||||
@ -907,9 +909,8 @@ bool CompactibleFreeListSpace::block_is_obj(const HeapWord* p) const {
|
||||
// and those objects (if garbage) may have been modified to hold
|
||||
// live range information.
|
||||
// assert(ParallelGCThreads > 0 || _bt.block_start(p) == p, "Should be a block boundary");
|
||||
klassOop k = oop(p)->klass();
|
||||
intptr_t ki = (intptr_t)k;
|
||||
if (FreeChunk::secondWordIndicatesFreeChunk(ki)) return false;
|
||||
if (FreeChunk::indicatesFreeChunk(p)) return false;
|
||||
klassOop k = oop(p)->klass_or_null();
|
||||
if (k != NULL) {
|
||||
// Ignore mark word because it may have been used to
|
||||
// chain together promoted objects (the last one
|
||||
@ -1027,7 +1028,7 @@ HeapWord* CompactibleFreeListSpace::allocate(size_t size) {
|
||||
FreeChunk* fc = (FreeChunk*)res;
|
||||
fc->markNotFree();
|
||||
assert(!fc->isFree(), "shouldn't be marked free");
|
||||
assert(oop(fc)->klass() == NULL, "should look uninitialized");
|
||||
assert(oop(fc)->klass_or_null() == NULL, "should look uninitialized");
|
||||
// Verify that the block offset table shows this to
|
||||
// be a single block, but not one which is unallocated.
|
||||
_bt.verify_single_block(res, size);
|
||||
@ -2593,7 +2594,7 @@ HeapWord* CFLS_LAB::alloc(size_t word_sz) {
|
||||
}
|
||||
res->markNotFree();
|
||||
assert(!res->isFree(), "shouldn't be marked free");
|
||||
assert(oop(res)->klass() == NULL, "should look uninitialized");
|
||||
assert(oop(res)->klass_or_null() == NULL, "should look uninitialized");
|
||||
// mangle a just allocated object with a distinct pattern.
|
||||
debug_only(res->mangleAllocated(word_sz));
|
||||
return (HeapWord*)res;
|
||||
|
||||
@ -190,7 +190,8 @@ ConcurrentMarkSweepGeneration::ConcurrentMarkSweepGeneration(
|
||||
// depends on this property.
|
||||
debug_only(
|
||||
FreeChunk* junk = NULL;
|
||||
assert(junk->prev_addr() == (void*)(oop(junk)->klass_addr()),
|
||||
assert(UseCompressedOops ||
|
||||
junk->prev_addr() == (void*)(oop(junk)->klass_addr()),
|
||||
"Offset of FreeChunk::_prev within FreeChunk must match"
|
||||
" that of OopDesc::_klass within OopDesc");
|
||||
)
|
||||
@ -1039,7 +1040,7 @@ void CMSCollector::direct_allocated(HeapWord* start, size_t size) {
|
||||
// mark end of object
|
||||
}
|
||||
// check that oop looks uninitialized
|
||||
assert(oop(start)->klass() == NULL, "_klass should be NULL");
|
||||
assert(oop(start)->klass_or_null() == NULL, "_klass should be NULL");
|
||||
}
|
||||
|
||||
void CMSCollector::promoted(bool par, HeapWord* start,
|
||||
@ -1309,17 +1310,25 @@ ConcurrentMarkSweepGeneration::par_promote(int thread_num,
|
||||
}
|
||||
}
|
||||
oop obj = oop(obj_ptr);
|
||||
assert(obj->klass() == NULL, "Object should be uninitialized here.");
|
||||
assert(obj->klass_or_null() == NULL, "Object should be uninitialized here.");
|
||||
// Otherwise, copy the object. Here we must be careful to insert the
|
||||
// klass pointer last, since this marks the block as an allocated object.
|
||||
// Except with compressed oops it's the mark word.
|
||||
HeapWord* old_ptr = (HeapWord*)old;
|
||||
if (word_sz > (size_t)oopDesc::header_size()) {
|
||||
Copy::aligned_disjoint_words(old_ptr + oopDesc::header_size(),
|
||||
obj_ptr + oopDesc::header_size(),
|
||||
word_sz - oopDesc::header_size());
|
||||
}
|
||||
|
||||
if (UseCompressedOops) {
|
||||
// Copy gap missed by (aligned) header size calculation above
|
||||
obj->set_klass_gap(old->klass_gap());
|
||||
}
|
||||
|
||||
// Restore the mark word copied above.
|
||||
obj->set_mark(m);
|
||||
|
||||
// Now we can track the promoted object, if necessary. We take care
|
||||
// To delay the transition from uninitialized to full object
|
||||
// (i.e., insertion of klass pointer) until after, so that it
|
||||
@ -1327,7 +1336,8 @@ ConcurrentMarkSweepGeneration::par_promote(int thread_num,
|
||||
if (promoInfo->tracking()) {
|
||||
promoInfo->track((PromotedObject*)obj, old->klass());
|
||||
}
|
||||
// Finally, install the klass pointer.
|
||||
|
||||
// Finally, install the klass pointer (this should be volatile).
|
||||
obj->set_klass(old->klass());
|
||||
|
||||
assert(old->is_oop(), "Will dereference klass ptr below");
|
||||
@ -6165,7 +6175,7 @@ size_t CMSCollector::block_size_if_printezis_bits(HeapWord* addr) const {
|
||||
HeapWord* CMSCollector::next_card_start_after_block(HeapWord* addr) const {
|
||||
size_t sz = 0;
|
||||
oop p = (oop)addr;
|
||||
if (p->klass() != NULL && p->is_parsable()) {
|
||||
if (p->klass_or_null() != NULL && p->is_parsable()) {
|
||||
sz = CompactibleFreeListSpace::adjustObjectSize(p->size());
|
||||
} else {
|
||||
sz = block_size_using_printezis_bits(addr);
|
||||
@ -6602,7 +6612,7 @@ size_t ScanMarkedObjectsAgainCarefullyClosure::do_object_careful_m(
|
||||
}
|
||||
if (_bitMap->isMarked(addr)) {
|
||||
// it's marked; is it potentially uninitialized?
|
||||
if (p->klass() != NULL) {
|
||||
if (p->klass_or_null() != NULL) {
|
||||
if (CMSPermGenPrecleaningEnabled && !p->is_parsable()) {
|
||||
// Signal precleaning to redirty the card since
|
||||
// the klass pointer is already installed.
|
||||
@ -6615,11 +6625,8 @@ size_t ScanMarkedObjectsAgainCarefullyClosure::do_object_careful_m(
|
||||
if (p->is_objArray()) {
|
||||
// objArrays are precisely marked; restrict scanning
|
||||
// to dirty cards only.
|
||||
size = p->oop_iterate(_scanningClosure, mr);
|
||||
assert(size == CompactibleFreeListSpace::adjustObjectSize(size),
|
||||
"adjustObjectSize should be the identity for array sizes, "
|
||||
"which are necessarily larger than minimum object size of "
|
||||
"two heap words");
|
||||
size = CompactibleFreeListSpace::adjustObjectSize(
|
||||
p->oop_iterate(_scanningClosure, mr));
|
||||
} else {
|
||||
// A non-array may have been imprecisely marked; we need
|
||||
// to scan object in its entirety.
|
||||
@ -6653,7 +6660,7 @@ size_t ScanMarkedObjectsAgainCarefullyClosure::do_object_careful_m(
|
||||
}
|
||||
} else {
|
||||
// Either a not yet marked object or an uninitialized object
|
||||
if (p->klass() == NULL || !p->is_parsable()) {
|
||||
if (p->klass_or_null() == NULL || !p->is_parsable()) {
|
||||
// An uninitialized object, skip to the next card, since
|
||||
// we may not be able to read its P-bits yet.
|
||||
assert(size == 0, "Initial value");
|
||||
@ -6710,7 +6717,7 @@ size_t SurvivorSpacePrecleanClosure::do_object_careful(oop p) {
|
||||
HeapWord* addr = (HeapWord*)p;
|
||||
DEBUG_ONLY(_collector->verify_work_stacks_empty();)
|
||||
assert(!_span.contains(addr), "we are scanning the survivor spaces");
|
||||
assert(p->klass() != NULL, "object should be initializd");
|
||||
assert(p->klass_or_null() != NULL, "object should be initializd");
|
||||
assert(p->is_parsable(), "must be parsable.");
|
||||
// an initialized object; ignore mark word in verification below
|
||||
// since we are running concurrent with mutators
|
||||
@ -6868,7 +6875,7 @@ void MarkFromRootsClosure::do_bit(size_t offset) {
|
||||
assert(_skipBits == 0, "tautology");
|
||||
_skipBits = 2; // skip next two marked bits ("Printezis-marks")
|
||||
oop p = oop(addr);
|
||||
if (p->klass() == NULL || !p->is_parsable()) {
|
||||
if (p->klass_or_null() == NULL || !p->is_parsable()) {
|
||||
DEBUG_ONLY(if (!_verifying) {)
|
||||
// We re-dirty the cards on which this object lies and increase
|
||||
// the _threshold so that we'll come back to scan this object
|
||||
@ -6890,7 +6897,7 @@ void MarkFromRootsClosure::do_bit(size_t offset) {
|
||||
if (_threshold < end_card_addr) {
|
||||
_threshold = end_card_addr;
|
||||
}
|
||||
if (p->klass() != NULL) {
|
||||
if (p->klass_or_null() != NULL) {
|
||||
// Redirty the range of cards...
|
||||
_mut->mark_range(redirty_range);
|
||||
} // ...else the setting of klass will dirty the card anyway.
|
||||
@ -7048,7 +7055,7 @@ void Par_MarkFromRootsClosure::do_bit(size_t offset) {
|
||||
assert(_skip_bits == 0, "tautology");
|
||||
_skip_bits = 2; // skip next two marked bits ("Printezis-marks")
|
||||
oop p = oop(addr);
|
||||
if (p->klass() == NULL || !p->is_parsable()) {
|
||||
if (p->klass_or_null() == NULL || !p->is_parsable()) {
|
||||
// in the case of Clean-on-Enter optimization, redirty card
|
||||
// and avoid clearing card by increasing the threshold.
|
||||
return;
|
||||
@ -8023,7 +8030,7 @@ size_t SweepClosure::doLiveChunk(FreeChunk* fc) {
|
||||
"alignment problem");
|
||||
|
||||
#ifdef DEBUG
|
||||
if (oop(addr)->klass() != NULL &&
|
||||
if (oop(addr)->klass_or_null() != NULL &&
|
||||
( !_collector->should_unload_classes()
|
||||
|| oop(addr)->is_parsable())) {
|
||||
// Ignore mark word because we are running concurrent with mutators
|
||||
@ -8036,7 +8043,7 @@ size_t SweepClosure::doLiveChunk(FreeChunk* fc) {
|
||||
|
||||
} else {
|
||||
// This should be an initialized object that's alive.
|
||||
assert(oop(addr)->klass() != NULL &&
|
||||
assert(oop(addr)->klass_or_null() != NULL &&
|
||||
(!_collector->should_unload_classes()
|
||||
|| oop(addr)->is_parsable()),
|
||||
"Should be an initialized object");
|
||||
|
||||
@ -22,88 +22,6 @@
|
||||
*
|
||||
*/
|
||||
|
||||
//
|
||||
// Free block maintenance for Concurrent Mark Sweep Generation
|
||||
//
|
||||
// The main data structure for free blocks are
|
||||
// . an indexed array of small free blocks, and
|
||||
// . a dictionary of large free blocks
|
||||
//
|
||||
|
||||
// No virtuals in FreeChunk (don't want any vtables).
|
||||
|
||||
// A FreeChunk is merely a chunk that can be in a doubly linked list
|
||||
// and has a size field. NOTE: FreeChunks are distinguished from allocated
|
||||
// objects in two ways (by the sweeper). The second word (prev) has the
|
||||
// LSB set to indicate a free chunk; allocated objects' klass() pointers
|
||||
// don't have their LSB set. The corresponding bit in the CMSBitMap is
|
||||
// set when the chunk is allocated. There are also blocks that "look free"
|
||||
// but are not part of the free list and should not be coalesced into larger
|
||||
// free blocks. These free blocks have their two LSB's set.
|
||||
|
||||
class FreeChunk VALUE_OBJ_CLASS_SPEC {
|
||||
friend class VMStructs;
|
||||
FreeChunk* _next;
|
||||
FreeChunk* _prev;
|
||||
size_t _size;
|
||||
|
||||
public:
|
||||
NOT_PRODUCT(static const size_t header_size();)
|
||||
// Returns "true" if the "wrd", which is required to be the second word
|
||||
// of a block, indicates that the block represents a free chunk.
|
||||
static bool secondWordIndicatesFreeChunk(intptr_t wrd) {
|
||||
return (wrd & 0x1) == 0x1;
|
||||
}
|
||||
bool isFree() const {
|
||||
return secondWordIndicatesFreeChunk((intptr_t)_prev);
|
||||
}
|
||||
bool cantCoalesce() const { return (((intptr_t)_prev) & 0x3) == 0x3; }
|
||||
FreeChunk* next() const { return _next; }
|
||||
FreeChunk* prev() const { return (FreeChunk*)(((intptr_t)_prev) & ~(0x3)); }
|
||||
debug_only(void* prev_addr() const { return (void*)&_prev; })
|
||||
|
||||
void linkAfter(FreeChunk* ptr) {
|
||||
linkNext(ptr);
|
||||
if (ptr != NULL) ptr->linkPrev(this);
|
||||
}
|
||||
void linkAfterNonNull(FreeChunk* ptr) {
|
||||
assert(ptr != NULL, "precondition violation");
|
||||
linkNext(ptr);
|
||||
ptr->linkPrev(this);
|
||||
}
|
||||
void linkNext(FreeChunk* ptr) { _next = ptr; }
|
||||
void linkPrev(FreeChunk* ptr) { _prev = (FreeChunk*)((intptr_t)ptr | 0x1); }
|
||||
void clearPrev() { _prev = NULL; }
|
||||
void clearNext() { _next = NULL; }
|
||||
void dontCoalesce() {
|
||||
// the block should be free
|
||||
assert(isFree(), "Should look like a free block");
|
||||
_prev = (FreeChunk*)(((intptr_t)_prev) | 0x2);
|
||||
}
|
||||
void markFree() { _prev = (FreeChunk*)((intptr_t)_prev | 0x1); }
|
||||
void markNotFree() { _prev = NULL; }
|
||||
|
||||
size_t size() const { return _size; }
|
||||
void setSize(size_t size) { _size = size; }
|
||||
|
||||
// For volatile reads:
|
||||
size_t* size_addr() { return &_size; }
|
||||
|
||||
// Return the address past the end of this chunk
|
||||
HeapWord* end() const { return ((HeapWord*) this) + _size; }
|
||||
|
||||
// debugging
|
||||
void verify() const PRODUCT_RETURN;
|
||||
void verifyList() const PRODUCT_RETURN;
|
||||
void mangleAllocated(size_t size) PRODUCT_RETURN;
|
||||
void mangleFreed(size_t size) PRODUCT_RETURN;
|
||||
};
|
||||
|
||||
// Alignment helpers etc.
|
||||
#define numQuanta(x,y) ((x+y-1)/y)
|
||||
enum AlignmentConstants {
|
||||
MinChunkSize = numQuanta(sizeof(FreeChunk), MinObjAlignmentInBytes) * MinObjAlignment
|
||||
};
|
||||
|
||||
// A FreeBlockDictionary is an abstract superclass that will allow
|
||||
// a number of alternative implementations in the future.
|
||||
|
||||
@ -47,15 +47,15 @@ void FreeChunk::mangleAllocated(size_t size) {
|
||||
Copy::fill_to_words(addr + hdr, size - hdr, baadbabeHeapWord);
|
||||
}
|
||||
|
||||
void FreeChunk::mangleFreed(size_t size) {
|
||||
void FreeChunk::mangleFreed(size_t sz) {
|
||||
assert(baadbabeHeapWord != deadbeefHeapWord, "Need distinct patterns");
|
||||
// mangle all but the header of a just-freed block of storage
|
||||
// just prior to passing it to the storage dictionary
|
||||
assert(size >= MinChunkSize, "smallest size of object");
|
||||
assert(size == _size, "just checking");
|
||||
assert(sz >= MinChunkSize, "smallest size of object");
|
||||
assert(sz == size(), "just checking");
|
||||
HeapWord* addr = (HeapWord*)this;
|
||||
size_t hdr = header_size();
|
||||
Copy::fill_to_words(addr + hdr, size - hdr, deadbeefHeapWord);
|
||||
Copy::fill_to_words(addr + hdr, sz - hdr, deadbeefHeapWord);
|
||||
}
|
||||
|
||||
void FreeChunk::verifyList() const {
|
||||
|
||||
@ -0,0 +1,137 @@
|
||||
/*
|
||||
* Copyright 2001-2005 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
||||
* CA 95054 USA or visit www.sun.com if you need additional information or
|
||||
* have any questions.
|
||||
*
|
||||
*/
|
||||
|
||||
//
|
||||
// Free block maintenance for Concurrent Mark Sweep Generation
|
||||
//
|
||||
// The main data structure for free blocks are
|
||||
// . an indexed array of small free blocks, and
|
||||
// . a dictionary of large free blocks
|
||||
//
|
||||
|
||||
// No virtuals in FreeChunk (don't want any vtables).
|
||||
|
||||
// A FreeChunk is merely a chunk that can be in a doubly linked list
|
||||
// and has a size field. NOTE: FreeChunks are distinguished from allocated
|
||||
// objects in two ways (by the sweeper), depending on whether the VM is 32 or
|
||||
// 64 bits.
|
||||
// In 32 bits or 64 bits without CompressedOops, the second word (prev) has the
|
||||
// LSB set to indicate a free chunk; allocated objects' klass() pointers
|
||||
// don't have their LSB set. The corresponding bit in the CMSBitMap is
|
||||
// set when the chunk is allocated. There are also blocks that "look free"
|
||||
// but are not part of the free list and should not be coalesced into larger
|
||||
// free blocks. These free blocks have their two LSB's set.
|
||||
|
||||
class FreeChunk VALUE_OBJ_CLASS_SPEC {
|
||||
friend class VMStructs;
|
||||
// For 64 bit compressed oops, the markOop encodes both the size and the
|
||||
// indication that this is a FreeChunk and not an object.
|
||||
volatile size_t _size;
|
||||
FreeChunk* _prev;
|
||||
FreeChunk* _next;
|
||||
|
||||
markOop mark() const volatile { return (markOop)_size; }
|
||||
void set_mark(markOop m) { _size = (size_t)m; }
|
||||
|
||||
public:
|
||||
NOT_PRODUCT(static const size_t header_size();)
|
||||
|
||||
// Returns "true" if the address indicates that the block represents
|
||||
// a free chunk.
|
||||
static bool indicatesFreeChunk(const HeapWord* addr) {
|
||||
// Force volatile read from addr because value might change between
|
||||
// calls. We really want the read of _mark and _prev from this pointer
|
||||
// to be volatile but making the fields volatile causes all sorts of
|
||||
// compilation errors.
|
||||
return ((volatile FreeChunk*)addr)->isFree();
|
||||
}
|
||||
|
||||
bool isFree() const volatile {
|
||||
LP64_ONLY(if (UseCompressedOops) return mark()->is_cms_free_chunk(); else)
|
||||
return (((intptr_t)_prev) & 0x1) == 0x1;
|
||||
}
|
||||
bool cantCoalesce() const {
|
||||
assert(isFree(), "can't get coalesce bit on not free");
|
||||
return (((intptr_t)_prev) & 0x2) == 0x2;
|
||||
}
|
||||
void dontCoalesce() {
|
||||
// the block should be free
|
||||
assert(isFree(), "Should look like a free block");
|
||||
_prev = (FreeChunk*)(((intptr_t)_prev) | 0x2);
|
||||
}
|
||||
FreeChunk* prev() const {
|
||||
return (FreeChunk*)(((intptr_t)_prev) & ~(0x3));
|
||||
}
|
||||
|
||||
debug_only(void* prev_addr() const { return (void*)&_prev; })
|
||||
|
||||
size_t size() const volatile {
|
||||
LP64_ONLY(if (UseCompressedOops) return mark()->get_size(); else )
|
||||
return _size;
|
||||
}
|
||||
void setSize(size_t sz) {
|
||||
LP64_ONLY(if (UseCompressedOops) set_mark(markOopDesc::set_size_and_free(sz)); else )
|
||||
_size = sz;
|
||||
}
|
||||
|
||||
FreeChunk* next() const { return _next; }
|
||||
|
||||
void linkAfter(FreeChunk* ptr) {
|
||||
linkNext(ptr);
|
||||
if (ptr != NULL) ptr->linkPrev(this);
|
||||
}
|
||||
void linkAfterNonNull(FreeChunk* ptr) {
|
||||
assert(ptr != NULL, "precondition violation");
|
||||
linkNext(ptr);
|
||||
ptr->linkPrev(this);
|
||||
}
|
||||
void linkNext(FreeChunk* ptr) { _next = ptr; }
|
||||
void linkPrev(FreeChunk* ptr) {
|
||||
LP64_ONLY(if (UseCompressedOops) _prev = ptr; else)
|
||||
_prev = (FreeChunk*)((intptr_t)ptr | 0x1);
|
||||
}
|
||||
void clearPrev() { _prev = NULL; }
|
||||
void clearNext() { _next = NULL; }
|
||||
void markNotFree() {
|
||||
LP64_ONLY(if (UseCompressedOops) set_mark(markOopDesc::prototype());)
|
||||
// Also set _prev to null
|
||||
_prev = NULL;
|
||||
}
|
||||
|
||||
// Return the address past the end of this chunk
|
||||
HeapWord* end() const { return ((HeapWord*) this) + size(); }
|
||||
|
||||
// debugging
|
||||
void verify() const PRODUCT_RETURN;
|
||||
void verifyList() const PRODUCT_RETURN;
|
||||
void mangleAllocated(size_t size) PRODUCT_RETURN;
|
||||
void mangleFreed(size_t size) PRODUCT_RETURN;
|
||||
};
|
||||
|
||||
// Alignment helpers etc.
|
||||
#define numQuanta(x,y) ((x+y-1)/y)
|
||||
enum AlignmentConstants {
|
||||
MinChunkSize = numQuanta(sizeof(FreeChunk), MinObjAlignmentInBytes) * MinObjAlignment
|
||||
};
|
||||
|
||||
@ -23,6 +23,7 @@
|
||||
*/
|
||||
|
||||
#define VM_STRUCTS_CMS(nonstatic_field, \
|
||||
volatile_nonstatic_field, \
|
||||
static_field) \
|
||||
nonstatic_field(CompactibleFreeListSpace, _collector, CMSCollector*) \
|
||||
nonstatic_field(CompactibleFreeListSpace, _bt, BlockOffsetArrayNonContigSpace) \
|
||||
@ -36,9 +37,9 @@
|
||||
nonstatic_field(CMSCollector, _markBitMap, CMSBitMap) \
|
||||
nonstatic_field(ConcurrentMarkSweepGeneration, _cmsSpace, CompactibleFreeListSpace*) \
|
||||
static_field(ConcurrentMarkSweepThread, _collector, CMSCollector*) \
|
||||
volatile_nonstatic_field(FreeChunk, _size, size_t) \
|
||||
nonstatic_field(FreeChunk, _next, FreeChunk*) \
|
||||
nonstatic_field(FreeChunk, _prev, FreeChunk*) \
|
||||
nonstatic_field(FreeChunk, _size, size_t) \
|
||||
nonstatic_field(LinearAllocBlock, _word_size, size_t) \
|
||||
nonstatic_field(FreeList, _size, size_t) \
|
||||
nonstatic_field(FreeList, _count, ssize_t) \
|
||||
|
||||
@ -206,6 +206,7 @@ freeBlockDictionary.cpp thread_<os_family>.inline.hpp
|
||||
|
||||
freeBlockDictionary.hpp allocation.hpp
|
||||
freeBlockDictionary.hpp debug.hpp
|
||||
freeBlockDictionary.hpp freeChunk.hpp
|
||||
freeBlockDictionary.hpp globalDefinitions.hpp
|
||||
freeBlockDictionary.hpp memRegion.hpp
|
||||
freeBlockDictionary.hpp mutex.hpp
|
||||
@ -214,6 +215,14 @@ freeBlockDictionary.hpp ostream.hpp
|
||||
freeChunk.cpp copy.hpp
|
||||
freeChunk.cpp freeBlockDictionary.hpp
|
||||
|
||||
freeChunk.hpp allocation.hpp
|
||||
freeChunk.hpp debug.hpp
|
||||
freeChunk.hpp globalDefinitions.hpp
|
||||
freeChunk.hpp markOop.hpp
|
||||
freeChunk.hpp memRegion.hpp
|
||||
freeChunk.hpp mutex.hpp
|
||||
freeChunk.hpp ostream.hpp
|
||||
|
||||
freeList.cpp freeBlockDictionary.hpp
|
||||
freeList.cpp freeList.hpp
|
||||
freeList.cpp globals.hpp
|
||||
|
||||
@ -66,7 +66,7 @@ void ImmutableSpace::print() const {
|
||||
|
||||
#endif
|
||||
|
||||
void ImmutableSpace::verify(bool allow_dirty) const {
|
||||
void ImmutableSpace::verify(bool allow_dirty) {
|
||||
HeapWord* p = bottom();
|
||||
HeapWord* t = end();
|
||||
HeapWord* prev_p = NULL;
|
||||
|
||||
@ -59,5 +59,5 @@ class ImmutableSpace: public CHeapObj {
|
||||
// Debugging
|
||||
virtual void print() const PRODUCT_RETURN;
|
||||
virtual void print_short() const PRODUCT_RETURN;
|
||||
virtual void verify(bool allow_dirty) const;
|
||||
virtual void verify(bool allow_dirty);
|
||||
};
|
||||
|
||||
@ -599,12 +599,28 @@ void MutableNUMASpace::initialize(MemRegion mr, bool clear_space) {
|
||||
// Mark the the holes in chunks below the top() as invalid.
|
||||
void MutableNUMASpace::set_top(HeapWord* value) {
|
||||
bool found_top = false;
|
||||
for (int i = 0; i < lgrp_spaces()->length(); i++) {
|
||||
for (int i = 0; i < lgrp_spaces()->length();) {
|
||||
LGRPSpace *ls = lgrp_spaces()->at(i);
|
||||
MutableSpace *s = ls->space();
|
||||
HeapWord *top = MAX2((HeapWord*)round_down((intptr_t)s->top(), page_size()), s->bottom());
|
||||
|
||||
if (s->contains(value)) {
|
||||
// Check if setting the chunk's top to a given value would create a hole less than
|
||||
// a minimal object; assuming that's not the last chunk in which case we don't care.
|
||||
if (i < lgrp_spaces()->length() - 1) {
|
||||
size_t remainder = pointer_delta(s->end(), value);
|
||||
const size_t minimal_object_size = oopDesc::header_size();
|
||||
if (remainder < minimal_object_size && remainder > 0) {
|
||||
// Add a filler object of a minimal size, it will cross the chunk boundary.
|
||||
SharedHeap::fill_region_with_object(MemRegion(value, minimal_object_size));
|
||||
value += minimal_object_size;
|
||||
assert(!s->contains(value), "Should be in the next chunk");
|
||||
// Restart the loop from the same chunk, since the value has moved
|
||||
// to the next one.
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
if (!os::numa_has_static_binding() && top < value && top < s->end()) {
|
||||
ls->add_invalid_region(MemRegion(top, value));
|
||||
}
|
||||
@ -620,6 +636,7 @@ void MutableNUMASpace::set_top(HeapWord* value) {
|
||||
s->set_top(s->end());
|
||||
}
|
||||
}
|
||||
i++;
|
||||
}
|
||||
MutableSpace::set_top(value);
|
||||
}
|
||||
@ -700,12 +717,14 @@ HeapWord* MutableNUMASpace::cas_allocate(size_t size) {
|
||||
MutableSpace *s = lgrp_spaces()->at(i)->space();
|
||||
HeapWord *p = s->cas_allocate(size);
|
||||
if (p != NULL) {
|
||||
size_t remainder = pointer_delta(s->end(), p);
|
||||
size_t remainder = pointer_delta(s->end(), p + size);
|
||||
if (remainder < (size_t)oopDesc::header_size() && remainder > 0) {
|
||||
if (s->cas_deallocate(p, size)) {
|
||||
// We were the last to allocate and created a fragment less than
|
||||
// a minimal object.
|
||||
p = NULL;
|
||||
} else {
|
||||
guarantee(false, "Deallocation should always succeed");
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -761,10 +780,12 @@ void MutableNUMASpace::print_on(outputStream* st) const {
|
||||
}
|
||||
}
|
||||
|
||||
void MutableNUMASpace::verify(bool allow_dirty) const {
|
||||
for (int i = 0; i < lgrp_spaces()->length(); i++) {
|
||||
lgrp_spaces()->at(i)->space()->verify(allow_dirty);
|
||||
}
|
||||
void MutableNUMASpace::verify(bool allow_dirty) {
|
||||
// This can be called after setting an arbitary value to the space's top,
|
||||
// so an object can cross the chunk boundary. We ensure the parsablity
|
||||
// of the space and just walk the objects in linear fashion.
|
||||
ensure_parsability();
|
||||
MutableSpace::verify(allow_dirty);
|
||||
}
|
||||
|
||||
// Scan pages and gather stats about page placement and size.
|
||||
|
||||
@ -192,7 +192,7 @@ class MutableNUMASpace : public MutableSpace {
|
||||
// Debugging
|
||||
virtual void print_on(outputStream* st) const;
|
||||
virtual void print_short_on(outputStream* st) const;
|
||||
virtual void verify(bool allow_dirty) const;
|
||||
virtual void verify(bool allow_dirty);
|
||||
|
||||
virtual void set_top(HeapWord* value);
|
||||
};
|
||||
|
||||
@ -118,7 +118,7 @@ void MutableSpace::print_on(outputStream* st) const {
|
||||
bottom(), top(), end());
|
||||
}
|
||||
|
||||
void MutableSpace::verify(bool allow_dirty) const {
|
||||
void MutableSpace::verify(bool allow_dirty) {
|
||||
HeapWord* p = bottom();
|
||||
HeapWord* t = top();
|
||||
HeapWord* prev_p = NULL;
|
||||
|
||||
@ -98,5 +98,5 @@ class MutableSpace: public ImmutableSpace {
|
||||
virtual void print_on(outputStream* st) const;
|
||||
virtual void print_short() const;
|
||||
virtual void print_short_on(outputStream* st) const;
|
||||
virtual void verify(bool allow_dirty) const;
|
||||
virtual void verify(bool allow_dirty);
|
||||
};
|
||||
|
||||
@ -29,8 +29,10 @@
|
||||
//
|
||||
// Bit-format of an object header (most significant first):
|
||||
//
|
||||
//
|
||||
// unused:0/25 hash:25/31 age:4 biased_lock:1 lock:2 = 32/64 bits
|
||||
// 32 bits: unused:0 hash:25 age:4 biased_lock:1 lock:2
|
||||
// 64 bits: unused:24 hash:31 cms:2 age:4 biased_lock:1 lock:2
|
||||
// unused:20 size:35 cms:2 age:4 biased_lock:1 lock:2 (if cms
|
||||
// free chunk)
|
||||
//
|
||||
// - hash contains the identity hash value: largest value is
|
||||
// 31 bits, see os::random(). Also, 64-bit vm's require
|
||||
@ -91,6 +93,7 @@ class markOopDesc: public oopDesc {
|
||||
biased_lock_bits = 1,
|
||||
max_hash_bits = BitsPerWord - age_bits - lock_bits - biased_lock_bits,
|
||||
hash_bits = max_hash_bits > 31 ? 31 : max_hash_bits,
|
||||
cms_bits = LP64_ONLY(1) NOT_LP64(0),
|
||||
epoch_bits = 2
|
||||
};
|
||||
|
||||
@ -106,7 +109,8 @@ class markOopDesc: public oopDesc {
|
||||
enum { lock_shift = 0,
|
||||
biased_lock_shift = lock_bits,
|
||||
age_shift = lock_bits + biased_lock_bits,
|
||||
hash_shift = lock_bits + biased_lock_bits + age_bits,
|
||||
cms_shift = age_shift + age_bits,
|
||||
hash_shift = cms_shift + cms_bits,
|
||||
epoch_shift = hash_shift
|
||||
};
|
||||
|
||||
@ -118,7 +122,9 @@ class markOopDesc: public oopDesc {
|
||||
age_mask = right_n_bits(age_bits),
|
||||
age_mask_in_place = age_mask << age_shift,
|
||||
epoch_mask = right_n_bits(epoch_bits),
|
||||
epoch_mask_in_place = epoch_mask << epoch_shift
|
||||
epoch_mask_in_place = epoch_mask << epoch_shift,
|
||||
cms_mask = right_n_bits(cms_bits),
|
||||
cms_mask_in_place = cms_mask << cms_shift
|
||||
#ifndef _WIN64
|
||||
,hash_mask = right_n_bits(hash_bits),
|
||||
hash_mask_in_place = (address_word)hash_mask << hash_shift
|
||||
@ -360,4 +366,40 @@ class markOopDesc: public oopDesc {
|
||||
|
||||
// see the definition in markOop.cpp for the gory details
|
||||
bool should_not_be_cached() const;
|
||||
|
||||
// These markOops indicate cms free chunk blocks and not objects.
|
||||
// In 64 bit, the markOop is set to distinguish them from oops.
|
||||
// These are defined in 32 bit mode for vmStructs.
|
||||
const static uintptr_t cms_free_chunk_pattern = 0x1;
|
||||
|
||||
// Constants for the size field.
|
||||
enum { size_shift = cms_shift + cms_bits,
|
||||
size_bits = 35 // need for compressed oops 32G
|
||||
};
|
||||
// These values are too big for Win64
|
||||
const static uintptr_t size_mask = LP64_ONLY(right_n_bits(size_bits))
|
||||
NOT_LP64(0);
|
||||
const static uintptr_t size_mask_in_place =
|
||||
(address_word)size_mask << size_shift;
|
||||
|
||||
#ifdef _LP64
|
||||
static markOop cms_free_prototype() {
|
||||
return markOop(((intptr_t)prototype() & ~cms_mask_in_place) |
|
||||
((cms_free_chunk_pattern & cms_mask) << cms_shift));
|
||||
}
|
||||
uintptr_t cms_encoding() const {
|
||||
return mask_bits(value() >> cms_shift, cms_mask);
|
||||
}
|
||||
bool is_cms_free_chunk() const {
|
||||
return is_neutral() &&
|
||||
(cms_encoding() & cms_free_chunk_pattern) == cms_free_chunk_pattern;
|
||||
}
|
||||
|
||||
size_t get_size() const { return (size_t)(value() >> size_shift); }
|
||||
static markOop set_size_and_free(size_t size) {
|
||||
assert((size & ~size_mask) == 0, "shouldn't overflow size field");
|
||||
return markOop(((intptr_t)cms_free_prototype() & ~size_mask_in_place) |
|
||||
(((intptr_t)size & size_mask) << size_shift));
|
||||
}
|
||||
#endif // _LP64
|
||||
};
|
||||
|
||||
@ -158,7 +158,6 @@ public:
|
||||
assert(ProfileTraps, "used only under +ProfileTraps");
|
||||
uint old_flags = (_header._struct._flags & flag_mask);
|
||||
_header._struct._flags = (new_state << trap_shift) | old_flags;
|
||||
assert(trap_state() == new_state, "sanity");
|
||||
}
|
||||
|
||||
u1 flags() {
|
||||
|
||||
@ -253,11 +253,17 @@ bool MemNode::all_controls_dominate(Node* dom, Node* sub) {
|
||||
if (dom == NULL || dom->is_top() || sub == NULL || sub->is_top())
|
||||
return false; // Conservative answer for dead code
|
||||
|
||||
// Check 'dom'.
|
||||
// Check 'dom'. Skip Proj and CatchProj nodes.
|
||||
dom = dom->find_exact_control(dom);
|
||||
if (dom == NULL || dom->is_top())
|
||||
return false; // Conservative answer for dead code
|
||||
|
||||
if (dom == sub) {
|
||||
// For the case when, for example, 'sub' is Initialize and the original
|
||||
// 'dom' is Proj node of the 'sub'.
|
||||
return false;
|
||||
}
|
||||
|
||||
if (dom->is_Con() || dom->is_Start() || dom->is_Root() || dom == sub)
|
||||
return true;
|
||||
|
||||
@ -271,6 +277,7 @@ bool MemNode::all_controls_dominate(Node* dom, Node* sub) {
|
||||
sub->is_Region(), "expecting only these nodes");
|
||||
|
||||
// Get control edge of 'sub'.
|
||||
Node* orig_sub = sub;
|
||||
sub = sub->find_exact_control(sub->in(0));
|
||||
if (sub == NULL || sub->is_top())
|
||||
return false; // Conservative answer for dead code
|
||||
@ -296,14 +303,16 @@ bool MemNode::all_controls_dominate(Node* dom, Node* sub) {
|
||||
|
||||
for (uint next = 0; next < dom_list.size(); next++) {
|
||||
Node* n = dom_list.at(next);
|
||||
if (n == orig_sub)
|
||||
return false; // One of dom's inputs dominated by sub.
|
||||
if (!n->is_CFG() && n->pinned()) {
|
||||
// Check only own control edge for pinned non-control nodes.
|
||||
n = n->find_exact_control(n->in(0));
|
||||
if (n == NULL || n->is_top())
|
||||
return false; // Conservative answer for dead code
|
||||
assert(n->is_CFG(), "expecting control");
|
||||
}
|
||||
if (n->is_Con() || n->is_Start() || n->is_Root()) {
|
||||
dom_list.push(n);
|
||||
} else if (n->is_Con() || n->is_Start() || n->is_Root()) {
|
||||
only_dominating_controls = true;
|
||||
} else if (n->is_CFG()) {
|
||||
if (n->dominates(sub, nlist))
|
||||
|
||||
@ -1039,6 +1039,9 @@ Node* Node::find_exact_control(Node* ctrl) {
|
||||
//--------------------------dominates------------------------------------------
|
||||
// Helper function for MemNode::all_controls_dominate().
|
||||
// Check if 'this' control node dominates or equal to 'sub' control node.
|
||||
// We already know that if any path back to Root or Start reaches 'this',
|
||||
// then all paths so, so this is a simple search for one example,
|
||||
// not an exhaustive search for a counterexample.
|
||||
bool Node::dominates(Node* sub, Node_List &nlist) {
|
||||
assert(this->is_CFG(), "expecting control");
|
||||
assert(sub != NULL && sub->is_CFG(), "expecting control");
|
||||
@ -1047,110 +1050,115 @@ bool Node::dominates(Node* sub, Node_List &nlist) {
|
||||
int iterations_without_region_limit = DominatorSearchLimit;
|
||||
|
||||
Node* orig_sub = sub;
|
||||
Node* dom = this;
|
||||
bool met_dom = false;
|
||||
nlist.clear();
|
||||
bool this_dominates = false;
|
||||
bool result = false; // Conservative answer
|
||||
|
||||
while (sub != NULL) { // walk 'sub' up the chain to 'this'
|
||||
if (sub == this) {
|
||||
// Walk 'sub' backward up the chain to 'dom', watching for regions.
|
||||
// After seeing 'dom', continue up to Root or Start.
|
||||
// If we hit a region (backward split point), it may be a loop head.
|
||||
// Keep going through one of the region's inputs. If we reach the
|
||||
// same region again, go through a different input. Eventually we
|
||||
// will either exit through the loop head, or give up.
|
||||
// (If we get confused, break out and return a conservative 'false'.)
|
||||
while (sub != NULL) {
|
||||
if (sub->is_top()) break; // Conservative answer for dead code.
|
||||
if (sub == dom) {
|
||||
if (nlist.size() == 0) {
|
||||
// No Region nodes except loops were visited before and the EntryControl
|
||||
// path was taken for loops: it did not walk in a cycle.
|
||||
result = true;
|
||||
break;
|
||||
} else if (this_dominates) {
|
||||
result = false; // already met before: walk in a cycle
|
||||
break;
|
||||
return true;
|
||||
} else if (met_dom) {
|
||||
break; // already met before: walk in a cycle
|
||||
} else {
|
||||
// Region nodes were visited. Continue walk up to Start or Root
|
||||
// to make sure that it did not walk in a cycle.
|
||||
this_dominates = true; // first time meet
|
||||
met_dom = true; // first time meet
|
||||
iterations_without_region_limit = DominatorSearchLimit; // Reset
|
||||
}
|
||||
}
|
||||
if (sub->is_Start() || sub->is_Root()) {
|
||||
result = this_dominates;
|
||||
break;
|
||||
// Success if we met 'dom' along a path to Start or Root.
|
||||
// We assume there are no alternative paths that avoid 'dom'.
|
||||
// (This assumption is up to the caller to ensure!)
|
||||
return met_dom;
|
||||
}
|
||||
Node* up = sub->find_exact_control(sub->in(0));
|
||||
if (up == NULL || up->is_top()) {
|
||||
result = false; // Conservative answer for dead code
|
||||
break;
|
||||
}
|
||||
if (sub == up && (sub->is_Loop() || sub->is_Region() && sub->req() != 3)) {
|
||||
// Take first valid path on the way up to 'this'.
|
||||
Node* up = sub->in(0);
|
||||
// Normalize simple pass-through regions and projections:
|
||||
up = sub->find_exact_control(up);
|
||||
// If sub == up, we found a self-loop. Try to push past it.
|
||||
if (sub == up && sub->is_Loop()) {
|
||||
// Take loop entry path on the way up to 'dom'.
|
||||
up = sub->in(1); // in(LoopNode::EntryControl);
|
||||
} else if (sub == up && sub->is_Region() && sub->req() != 3) {
|
||||
// Always take in(1) path on the way up to 'dom' for clone regions
|
||||
// (with only one input) or regions which merge > 2 paths
|
||||
// (usually used to merge fast/slow paths).
|
||||
up = sub->in(1);
|
||||
} else if (sub == up && sub->is_Region()) {
|
||||
assert(sub->req() == 3, "sanity");
|
||||
// Try both paths for Regions with 2 input paths (it may be a loop head).
|
||||
// It could give conservative 'false' answer without information
|
||||
// which region's input is the entry path.
|
||||
iterations_without_region_limit = DominatorSearchLimit; // Reset
|
||||
|
||||
// Try both paths for such Regions.
|
||||
// It is not accurate without regions dominating information.
|
||||
// With such information the other path should be checked for
|
||||
// the most dominating Region which was visited before.
|
||||
bool region_was_visited_before = false;
|
||||
uint i = 1;
|
||||
uint size = nlist.size();
|
||||
if (size == 0) {
|
||||
// No such Region nodes were visited before.
|
||||
// Take first valid path on the way up to 'this'.
|
||||
} else {
|
||||
// Was this Region node visited before?
|
||||
intptr_t ni;
|
||||
int j = size - 1;
|
||||
for (; j >= 0; j--) {
|
||||
ni = (intptr_t)nlist.at(j);
|
||||
if ((Node*)(ni & ~1) == sub) {
|
||||
if ((ni & 1) != 0) {
|
||||
break; // Visited 2 paths. Give up.
|
||||
} else {
|
||||
// The Region node was visited before only once.
|
||||
nlist.remove(j);
|
||||
region_was_visited_before = true;
|
||||
for (; i < sub->req(); i++) {
|
||||
Node* in = sub->in(i);
|
||||
if (in != NULL && !in->is_top() && in != sub) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
i++; // Take other path.
|
||||
break;
|
||||
}
|
||||
// Was this Region node visited before?
|
||||
// If so, we have reached it because we accidentally took a
|
||||
// loop-back edge from 'sub' back into the body of the loop,
|
||||
// and worked our way up again to the loop header 'sub'.
|
||||
// So, take the first unexplored path on the way up to 'dom'.
|
||||
for (int j = nlist.size() - 1; j >= 0; j--) {
|
||||
intptr_t ni = (intptr_t)nlist.at(j);
|
||||
Node* visited = (Node*)(ni & ~1);
|
||||
bool visited_twice_already = ((ni & 1) != 0);
|
||||
if (visited == sub) {
|
||||
if (visited_twice_already) {
|
||||
// Visited 2 paths, but still stuck in loop body. Give up.
|
||||
return false;
|
||||
}
|
||||
}
|
||||
if (j >= 0 && (ni & 1) != 0) {
|
||||
result = false; // Visited 2 paths. Give up.
|
||||
// The Region node was visited before only once.
|
||||
// (We will repush with the low bit set, below.)
|
||||
nlist.remove(j);
|
||||
// We will find a new edge and re-insert.
|
||||
region_was_visited_before = true;
|
||||
break;
|
||||
}
|
||||
// The Region node was not visited before.
|
||||
}
|
||||
for (; i < sub->req(); i++) {
|
||||
|
||||
// Find an incoming edge which has not been seen yet; walk through it.
|
||||
assert(up == sub, "");
|
||||
uint skip = region_was_visited_before ? 1 : 0;
|
||||
for (uint i = 1; i < sub->req(); i++) {
|
||||
Node* in = sub->in(i);
|
||||
if (in != NULL && !in->is_top() && in != sub) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (i < sub->req()) {
|
||||
up = sub->in(i);
|
||||
if (region_was_visited_before && sub != up) {
|
||||
// Set 0 bit to indicate that both paths were taken.
|
||||
nlist.push((Node*)((intptr_t)sub + 1));
|
||||
} else {
|
||||
nlist.push(sub);
|
||||
if (skip == 0) {
|
||||
up = in;
|
||||
break;
|
||||
}
|
||||
--skip; // skip this nontrivial input
|
||||
}
|
||||
}
|
||||
|
||||
// Set 0 bit to indicate that both paths were taken.
|
||||
nlist.push((Node*)((intptr_t)sub + (region_was_visited_before ? 1 : 0)));
|
||||
}
|
||||
if (sub == up) {
|
||||
result = false; // some kind of tight cycle
|
||||
break;
|
||||
|
||||
if (up == sub) {
|
||||
break; // some kind of tight cycle
|
||||
}
|
||||
if (up == orig_sub && met_dom) {
|
||||
// returned back after visiting 'dom'
|
||||
break; // some kind of cycle
|
||||
}
|
||||
if (--iterations_without_region_limit < 0) {
|
||||
result = false; // dead cycle
|
||||
break;
|
||||
break; // dead cycle
|
||||
}
|
||||
sub = up;
|
||||
}
|
||||
return result;
|
||||
|
||||
// Did not meet Root or Start node in pred. chain.
|
||||
// Conservative answer for dead code.
|
||||
return false;
|
||||
}
|
||||
|
||||
//------------------------------remove_dead_region-----------------------------
|
||||
|
||||
@ -1174,7 +1174,7 @@ void Arguments::set_ergonomics_flags() {
|
||||
// field offset to determine free list chunk markers.
|
||||
// Check that UseCompressedOops can be set with the max heap size allocated
|
||||
// by ergonomics.
|
||||
if (!UseConcMarkSweepGC && MaxHeapSize <= max_heap_for_compressed_oops()) {
|
||||
if (MaxHeapSize <= max_heap_for_compressed_oops()) {
|
||||
if (FLAG_IS_DEFAULT(UseCompressedOops)) {
|
||||
// Leave compressed oops off by default. Uncomment
|
||||
// the following line to return it to default status.
|
||||
|
||||
@ -2246,6 +2246,9 @@ class CommandLineFlags {
|
||||
product(bool, AggressiveOpts, false, \
|
||||
"Enable aggressive optimizations - see arguments.cpp") \
|
||||
\
|
||||
product(bool, UseStringCache, false, \
|
||||
"Enable String cache capabilities on String.java") \
|
||||
\
|
||||
/* statistics */ \
|
||||
develop(bool, UseVTune, false, \
|
||||
"enable support for Intel's VTune profiler") \
|
||||
|
||||
@ -2926,21 +2926,42 @@ jint Threads::create_vm(JavaVMInitArgs* args, bool* canTryAgain) {
|
||||
}
|
||||
|
||||
if (AggressiveOpts) {
|
||||
// Forcibly initialize java/util/HashMap and mutate the private
|
||||
// static final "frontCacheEnabled" field before we start creating instances
|
||||
{
|
||||
// Forcibly initialize java/util/HashMap and mutate the private
|
||||
// static final "frontCacheEnabled" field before we start creating instances
|
||||
#ifdef ASSERT
|
||||
klassOop tmp_k = SystemDictionary::find(vmSymbolHandles::java_util_HashMap(), Handle(), Handle(), CHECK_0);
|
||||
assert(tmp_k == NULL, "java/util/HashMap should not be loaded yet");
|
||||
klassOop tmp_k = SystemDictionary::find(vmSymbolHandles::java_util_HashMap(), Handle(), Handle(), CHECK_0);
|
||||
assert(tmp_k == NULL, "java/util/HashMap should not be loaded yet");
|
||||
#endif
|
||||
klassOop k_o = SystemDictionary::resolve_or_null(vmSymbolHandles::java_util_HashMap(), Handle(), Handle(), CHECK_0);
|
||||
KlassHandle k = KlassHandle(THREAD, k_o);
|
||||
guarantee(k.not_null(), "Must find java/util/HashMap");
|
||||
instanceKlassHandle ik = instanceKlassHandle(THREAD, k());
|
||||
ik->initialize(CHECK_0);
|
||||
fieldDescriptor fd;
|
||||
// Possible we might not find this field; if so, don't break
|
||||
if (ik->find_local_field(vmSymbols::frontCacheEnabled_name(), vmSymbols::bool_signature(), &fd)) {
|
||||
k()->bool_field_put(fd.offset(), true);
|
||||
klassOop k_o = SystemDictionary::resolve_or_null(vmSymbolHandles::java_util_HashMap(), Handle(), Handle(), CHECK_0);
|
||||
KlassHandle k = KlassHandle(THREAD, k_o);
|
||||
guarantee(k.not_null(), "Must find java/util/HashMap");
|
||||
instanceKlassHandle ik = instanceKlassHandle(THREAD, k());
|
||||
ik->initialize(CHECK_0);
|
||||
fieldDescriptor fd;
|
||||
// Possible we might not find this field; if so, don't break
|
||||
if (ik->find_local_field(vmSymbols::frontCacheEnabled_name(), vmSymbols::bool_signature(), &fd)) {
|
||||
k()->bool_field_put(fd.offset(), true);
|
||||
}
|
||||
}
|
||||
|
||||
if (UseStringCache) {
|
||||
// Forcibly initialize java/lang/String and mutate the private
|
||||
// static final "stringCacheEnabled" field before we start creating instances
|
||||
#ifdef ASSERT
|
||||
klassOop tmp_k = SystemDictionary::find(vmSymbolHandles::java_lang_String(), Handle(), Handle(), CHECK_0);
|
||||
assert(tmp_k == NULL, "java/lang/String should not be loaded yet");
|
||||
#endif
|
||||
klassOop k_o = SystemDictionary::resolve_or_null(vmSymbolHandles::java_lang_String(), Handle(), Handle(), CHECK_0);
|
||||
KlassHandle k = KlassHandle(THREAD, k_o);
|
||||
guarantee(k.not_null(), "Must find java/lang/String");
|
||||
instanceKlassHandle ik = instanceKlassHandle(THREAD, k());
|
||||
ik->initialize(CHECK_0);
|
||||
fieldDescriptor fd;
|
||||
// Possible we might not find this field; if so, don't break
|
||||
if (ik->find_local_field(vmSymbols::stringCacheEnabled_name(), vmSymbols::bool_signature(), &fd)) {
|
||||
k()->bool_field_put(fd.offset(), true);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -1695,7 +1695,12 @@ static inline uint64_t cast_uint64_t(size_t x)
|
||||
declare_constant(markOopDesc::no_hash) \
|
||||
declare_constant(markOopDesc::no_hash_in_place) \
|
||||
declare_constant(markOopDesc::no_lock_in_place) \
|
||||
declare_constant(markOopDesc::max_age)
|
||||
declare_constant(markOopDesc::max_age) \
|
||||
\
|
||||
/* Constants in markOop used by CMS. */ \
|
||||
declare_constant(markOopDesc::cms_shift) \
|
||||
declare_constant(markOopDesc::cms_mask) \
|
||||
declare_constant(markOopDesc::size_shift) \
|
||||
|
||||
/* NOTE that we do not use the last_entry() macro here; it is used */
|
||||
/* in vmStructs_<os>_<cpu>.hpp's VM_LONG_CONSTANTS_OS_CPU macro (and */
|
||||
@ -1959,6 +1964,7 @@ VMStructEntry VMStructs::localHotSpotVMStructs[] = {
|
||||
GENERATE_STATIC_VM_STRUCT_ENTRY)
|
||||
|
||||
VM_STRUCTS_CMS(GENERATE_NONSTATIC_VM_STRUCT_ENTRY, \
|
||||
GENERATE_NONSTATIC_VM_STRUCT_ENTRY, \
|
||||
GENERATE_STATIC_VM_STRUCT_ENTRY)
|
||||
#endif // SERIALGC
|
||||
|
||||
@ -2100,6 +2106,7 @@ VMStructs::init() {
|
||||
CHECK_STATIC_VM_STRUCT_ENTRY);
|
||||
|
||||
VM_STRUCTS_CMS(CHECK_NONSTATIC_VM_STRUCT_ENTRY,
|
||||
CHECK_VOLATILE_NONSTATIC_VM_STRUCT_ENTRY,
|
||||
CHECK_STATIC_VM_STRUCT_ENTRY);
|
||||
#endif // SERIALGC
|
||||
|
||||
@ -2204,6 +2211,7 @@ VMStructs::init() {
|
||||
debug_only(VM_STRUCTS_PARALLELGC(ENSURE_FIELD_TYPE_PRESENT, \
|
||||
ENSURE_FIELD_TYPE_PRESENT));
|
||||
debug_only(VM_STRUCTS_CMS(ENSURE_FIELD_TYPE_PRESENT, \
|
||||
ENSURE_FIELD_TYPE_PRESENT, \
|
||||
ENSURE_FIELD_TYPE_PRESENT));
|
||||
#endif // SERIALGC
|
||||
debug_only(VM_STRUCTS_CPU(ENSURE_FIELD_TYPE_PRESENT, \
|
||||
|
||||
@ -2,3 +2,4 @@
|
||||
a3b3ba7d6034dc754b51ddc3d281399ac1cae5f1 jdk7-b25
|
||||
da43cb85fac1646d6f97e4a35e510bbfdff97bdb jdk7-b26
|
||||
bafed478d67c3acf7744aaad88b9404261ea6739 jdk7-b27
|
||||
b996318955c0ad8e9fa0ffb56c74f626786e863f jdk7-b28
|
||||
|
||||
@ -2,3 +2,4 @@
|
||||
59fd8224ba2da5c2d8d4c68e33cf33ab41ce8de0 jdk7-b25
|
||||
debd37e1a422e580edb086c95d6e89199133a39c jdk7-b26
|
||||
27d8f42862c11b4ddc4af2dd2d2a3cd86cda04c2 jdk7-b27
|
||||
eefcd5204500a11d6aa802dca9f961cf10ab64c2 jdk7-b28
|
||||
|
||||
@ -2,3 +2,4 @@
|
||||
75fca0b0ab83ab1392e615910cea020f66535390 jdk7-b25
|
||||
fb57027902e04ecafceae31a605e69b436c23d57 jdk7-b26
|
||||
3e599d98875ddf919c8ea11cff9b3a99ba631a9b jdk7-b27
|
||||
02e4c5348592a8d7fc2cba28bc5f8e35c0e17277 jdk7-b28
|
||||
|
||||
@ -197,7 +197,6 @@ endif
|
||||
|
||||
# Lint Flags:
|
||||
# -Xa ANSI C plus K&R, favor ANSI rules
|
||||
# -Xarch=XXX Same as 'cc -xarch=XXX'
|
||||
# -fd report on old style func defs
|
||||
# -errchk=structarg report on 64bit struct args by value
|
||||
# -errchk=longptr64 report on 64bit to 32bit issues (ignores casts)
|
||||
@ -206,6 +205,7 @@ endif
|
||||
# -x suppress unused externs
|
||||
# -u suppress extern func/vars used/defined
|
||||
# -errfmt=simple use one line errors with position info
|
||||
# $(LINT_XARCH_OPTION) See Compiler-sun.gwk
|
||||
|
||||
LINTFLAGS_COMMON = -Xa
|
||||
LINTFLAGS_COMMON += -fd
|
||||
@ -224,42 +224,12 @@ LINTFLAGS_DBG =
|
||||
# Tell the compilers to never generate globalized names, all the time.
|
||||
CFLAGS_COMMON += -W0,-noglobal
|
||||
|
||||
# Arch specific settings (determines type of .o files and instruction set)
|
||||
ifeq ($(ARCH_FAMILY), sparc)
|
||||
ifdef VIS_NEEDED
|
||||
XARCH_VALUE/32=v8plusa
|
||||
XARCH_VALUE/64=v9a
|
||||
else
|
||||
# Someday this should change to improve optimization on UltraSPARC
|
||||
# and abandon the old v8-only machines like the SPARCstation 10.
|
||||
# Indications with Mustang is that alacrity runs do not show a
|
||||
# big improvement using v8plus over v8, but other benchmarks might.
|
||||
XARCH_VALUE/32=v8
|
||||
XARCH_VALUE/64=v9
|
||||
endif
|
||||
endif
|
||||
ifeq ($(ARCH_FAMILY), i586)
|
||||
XARCH_VALUE/64=amd64
|
||||
XARCH_VALUE/32=
|
||||
endif
|
||||
|
||||
# Arch value based on current data model being built
|
||||
XARCH_VALUE=$(XARCH_VALUE/$(ARCH_DATA_MODEL))
|
||||
ifneq ($(XARCH_VALUE), )
|
||||
# The actual compiler -xarch options to use
|
||||
XARCH_OPTION/32 = -xarch=$(XARCH_VALUE/32)
|
||||
XARCH_OPTION/64 = -xarch=$(XARCH_VALUE/64)
|
||||
XARCH_OPTION = $(XARCH_OPTION/$(ARCH_DATA_MODEL))
|
||||
endif
|
||||
|
||||
# If we have a specific -xarch value to use, add it
|
||||
ifdef XARCH_OPTION
|
||||
CFLAGS_COMMON += $(XARCH_OPTION)
|
||||
CXXFLAGS_COMMON += $(XARCH_OPTION)
|
||||
ASFLAGS_COMMON += $(XARCH_OPTION)
|
||||
EXTRA_LIBS += $(XARCH_OPTION)
|
||||
LINTFLAGS_COMMON += -Xarch=$(XARCH_VALUE)
|
||||
endif
|
||||
# If we have a specific arch value to use, add it
|
||||
CFLAGS_COMMON += $(XARCH_OPTION)
|
||||
CXXFLAGS_COMMON += $(XARCH_OPTION)
|
||||
ASFLAGS_COMMON += $(AS_XARCH_OPTION)
|
||||
EXTRA_LIBS += $(XARCH_OPTION)
|
||||
LINTFLAGS_COMMON += $(LINT_XARCH_OPTION)
|
||||
|
||||
#
|
||||
# uncomment the following to build with PERTURBALOT set
|
||||
|
||||
@ -1236,7 +1236,6 @@ ifeq ($(PLATFORM), windows)
|
||||
$(RM) $(TEMPDIR)/rebase.input
|
||||
endif
|
||||
$(RM) -r $(JDK_IMAGE_DIR)
|
||||
$(RM) -r $(JDK_DEBUG_IMAGE_DIR)
|
||||
$(RM) -r $(JRE_IMAGE_DIR)
|
||||
|
||||
images images-clobber::
|
||||
|
||||
@ -31,6 +31,9 @@ COMPILER_NAME=Sun Studio
|
||||
|
||||
# Sun Studio Compiler settings specific to Solaris
|
||||
ifeq ($(PLATFORM), solaris)
|
||||
# FIXUP: Change to SS12 when validated
|
||||
#COMPILER_VERSION=SS12
|
||||
#REQUIRED_CC_VER=5.9
|
||||
COMPILER_VERSION=SS11
|
||||
REQUIRED_CC_VER=5.8
|
||||
CC = $(COMPILER_PATH)cc
|
||||
@ -51,8 +54,8 @@ endif
|
||||
# Sun Studio Compiler settings specific to Linux
|
||||
ifeq ($(PLATFORM), linux)
|
||||
# This has not been tested
|
||||
COMPILER_VERSION=SS11
|
||||
REQUIRED_CC_VER=5.8
|
||||
COMPILER_VERSION=SS12
|
||||
REQUIRED_CC_VER=5.9
|
||||
CC = $(COMPILER_PATH)cc
|
||||
CPP = $(COMPILER_PATH)cc -E
|
||||
CXX = $(COMPILER_PATH)CC
|
||||
@ -74,3 +77,58 @@ endif
|
||||
_CC_VER :=$(shell $(CC) -V 2>&1 | $(HEAD) -n 1)
|
||||
CC_VER :=$(call GetVersion,"$(_CC_VER)")
|
||||
|
||||
# Arch specific settings (determines type of .o files and instruction set)
|
||||
# Starting in SS12 (5.9), the arch options changed.
|
||||
# The assembler /usr/ccs/bin/as wants older SS11 (5.8) style options.
|
||||
# Note: We need to have both 32 and 64 values at all times for awt Makefiles.
|
||||
#
|
||||
XARCH_OPTION_OLD/32 =
|
||||
XARCH_OPTION_OLD/64 =
|
||||
XARCH_OPTION_NEW/32 = -m32
|
||||
XARCH_OPTION_NEW/64 = -m64
|
||||
# Lint options are slightly different
|
||||
LINT_XARCH_OPTION_OLD/32 =
|
||||
LINT_XARCH_OPTION_OLD/64 =
|
||||
LINT_XARCH_OPTION_NEW/32 = -m32
|
||||
LINT_XARCH_OPTION_NEW/64 = -m64
|
||||
ifeq ($(ARCH_FAMILY), sparc)
|
||||
ifdef VIS_NEEDED
|
||||
XARCH_OPTION_OLD/32 += -xarch=v8plusa
|
||||
XARCH_OPTION_OLD/64 += -xarch=v9a
|
||||
XARCH_OPTION_NEW/32 += -xarch=sparcvis
|
||||
XARCH_OPTION_NEW/64 += -xarch=sparcvis
|
||||
else
|
||||
# Someday this should change to improve optimization on UltraSPARC
|
||||
# and abandon v8, even change to sparcvis or sparcvis2, this
|
||||
# abandons machines like the SPARCstation 10.
|
||||
# Indications with jdk6 is that alacrity runs do not show a
|
||||
# big improvement using v8plus over v8, but other benchmarks might.
|
||||
XARCH_OPTION_OLD/32 += -xarch=v8
|
||||
XARCH_OPTION_OLD/64 += -xarch=v9
|
||||
# Note that this new option (SS12+) effectively means v8plus
|
||||
XARCH_OPTION_NEW/32 += -xarch=sparc
|
||||
XARCH_OPTION_NEW/64 += -xarch=sparc
|
||||
endif
|
||||
LINT_XARCH_OPTION_OLD/64 += -Xarch=v9
|
||||
endif
|
||||
ifeq ($(ARCH_FAMILY), i586)
|
||||
XARCH_OPTION_OLD/64 += -xarch=amd64
|
||||
LINT_XARCH_OPTION_OLD/64 += -Xarch=amd64
|
||||
endif
|
||||
# Pick the options we want based on the compiler being used.
|
||||
ifeq ($(shell expr $(CC_VER) \>= 5.9), 1)
|
||||
XARCH_OPTION/32 = $(XARCH_OPTION_NEW/32)
|
||||
XARCH_OPTION/64 = $(XARCH_OPTION_NEW/64)
|
||||
LINT_XARCH_OPTION/32 = $(LINT_XARCH_OPTION_NEW/32)
|
||||
LINT_XARCH_OPTION/64 = $(LINT_XARCH_OPTION_NEW/64)
|
||||
else
|
||||
XARCH_OPTION/32 = $(XARCH_OPTION_OLD/32)
|
||||
XARCH_OPTION/64 = $(XARCH_OPTION_OLD/64)
|
||||
LINT_XARCH_OPTION/32 = $(LINT_XARCH_OPTION_OLD/32)
|
||||
LINT_XARCH_OPTION/64 = $(LINT_XARCH_OPTION_OLD/64)
|
||||
endif
|
||||
XARCH_OPTION = $(XARCH_OPTION/$(ARCH_DATA_MODEL))
|
||||
LINT_XARCH_OPTION = $(LINT_XARCH_OPTION/$(ARCH_DATA_MODEL))
|
||||
# The /usr/ccs/bin/as assembler always wants the older SS11 (5.8) options.
|
||||
AS_XARCH_OPTION = $(XARCH_OPTION_OLD/$(ARCH_DATA_MODEL))
|
||||
|
||||
|
||||
@ -119,7 +119,7 @@ if [ "${osname}" = SunOS ] ; then
|
||||
# System place where JDK installed images are stored?
|
||||
jdk_instances=/usr/jdk/instances
|
||||
|
||||
# Get the SS11 compilers (and latest patches for them too)
|
||||
# Get the Sun Studio compilers (and latest patches for them too)
|
||||
if [ "${ALT_COMPILER_PATH}" = "" ] ; then
|
||||
ALT_COMPILER_PATH=/opt/SUNWspro/bin
|
||||
export ALT_COMPILER_PATH
|
||||
|
||||
@ -133,9 +133,15 @@ if [ "${osname}" = SunOS ] ; then
|
||||
solaris_arch=i386
|
||||
fi
|
||||
|
||||
# Get the SS11 compilers into path (make sure it matches ALT setting)
|
||||
compiler_path=${jdk_devtools}/${solaris_arch}/SUNWspro/SS11/bin
|
||||
compiler_name=SS11
|
||||
# Get the compilers into path (make sure it matches ALT setting)
|
||||
if [ "${JPRT_SOLARIS_COMPILER_NAME}" != "" ] ; then
|
||||
compiler_name=${JPRT_SOLARIS_COMPILER_NAME}
|
||||
else
|
||||
# FIXUP: Change to SS12 when validated
|
||||
#compiler_name=SS12
|
||||
compiler_name=SS11
|
||||
fi
|
||||
compiler_path=${jdk_devtools}/${solaris_arch}/SUNWspro/${compiler_name}/bin
|
||||
ALT_COMPILER_PATH="${compiler_path}"
|
||||
export ALT_COMPILER_PATH
|
||||
dirMustExist "${compiler_path}" ALT_COMPILER_PATH
|
||||
|
||||
@ -93,7 +93,6 @@ else # PLATFORM
|
||||
# Other extra flags needed for compiling.
|
||||
#
|
||||
CPPFLAGS += -I$(OPENWIN_HOME)/include \
|
||||
-I$(MOTIF_DIR)/include \
|
||||
-I$(SHARE_SRC)/native/$(PKGDIR)/debug \
|
||||
-I$(SHARE_SRC)/native/$(PKGDIR)/image \
|
||||
-I$(SHARE_SRC)/native/$(PKGDIR)/image/cvutils \
|
||||
|
||||
@ -3057,10 +3057,24 @@ public abstract class Component implements ImageObserver, MenuContainer,
|
||||
// services. Additionally, the request is restricted to
|
||||
// the bounds of the component.
|
||||
if (parent != null) {
|
||||
int px = this.x + ((x < 0) ? 0 : x);
|
||||
int py = this.y + ((y < 0) ? 0 : y);
|
||||
if (x < 0) {
|
||||
width += x;
|
||||
x = 0;
|
||||
}
|
||||
if (y < 0) {
|
||||
height += y;
|
||||
y = 0;
|
||||
}
|
||||
|
||||
int pwidth = (width > this.width) ? this.width : width;
|
||||
int pheight = (height > this.height) ? this.height : height;
|
||||
|
||||
if (pwidth <= 0 || pheight <= 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
int px = this.x + x;
|
||||
int py = this.y + y;
|
||||
parent.repaint(tm, px, py, pwidth, pheight);
|
||||
}
|
||||
} else {
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 1997-2007 Sun Microsystems, Inc. All Rights Reserved.
|
||||
* Copyright 1997-2008 Sun Microsystems, Inc. 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
|
||||
@ -485,7 +485,6 @@ public class DragSourceContext
|
||||
|
||||
Cursor c = null;
|
||||
|
||||
targetAct = DnDConstants.ACTION_NONE;
|
||||
switch (status) {
|
||||
case ENTER:
|
||||
case OVER:
|
||||
@ -507,6 +506,10 @@ public class DragSourceContext
|
||||
else
|
||||
c = DragSource.DefaultCopyDrop;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
targetAct = DnDConstants.ACTION_NONE;
|
||||
|
||||
}
|
||||
|
||||
setCursorImpl(c);
|
||||
|
||||
@ -1696,8 +1696,8 @@ public class RequiredModelMBean
|
||||
} catch (Exception e) {
|
||||
// eat exceptions because interface doesn't have an
|
||||
// exception on it
|
||||
if (MODELMBEAN_LOGGER.isLoggable(Level.WARNING)) {
|
||||
MODELMBEAN_LOGGER.logp(Level.WARNING,
|
||||
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
|
||||
MODELMBEAN_LOGGER.logp(Level.FINER,
|
||||
RequiredModelMBean.class.getName(),
|
||||
"getAttributes(String[])",
|
||||
"Failed to get \"" + attrNames[i] + "\": ", e);
|
||||
@ -1857,8 +1857,8 @@ public class RequiredModelMBean
|
||||
attrValue.getClass().getName() +
|
||||
" received.");
|
||||
} catch (ClassNotFoundException x) {
|
||||
if (MODELMBEAN_LOGGER.isLoggable(Level.WARNING)) {
|
||||
MODELMBEAN_LOGGER.logp(Level.WARNING,
|
||||
if (MODELMBEAN_LOGGER.isLoggable(Level.FINER)) {
|
||||
MODELMBEAN_LOGGER.logp(Level.FINER,
|
||||
RequiredModelMBean.class.getName(),
|
||||
"setAttribute(Attribute)","Class " +
|
||||
attrType + " for attribute "
|
||||
@ -2224,8 +2224,8 @@ public class RequiredModelMBean
|
||||
ntfyObj.getMessage() + " Severity = " +
|
||||
(String)ntfyDesc.getFieldValue("severity"));
|
||||
} catch (Exception e) {
|
||||
if (MODELMBEAN_LOGGER.isLoggable(Level.WARNING)) {
|
||||
MODELMBEAN_LOGGER.logp(Level.WARNING,
|
||||
if (MODELMBEAN_LOGGER.isLoggable(Level.FINE)) {
|
||||
MODELMBEAN_LOGGER.logp(Level.FINE,
|
||||
RequiredModelMBean.class.getName(),
|
||||
"sendNotification(Notification)",
|
||||
"Failed to log " +
|
||||
@ -2618,8 +2618,8 @@ public class RequiredModelMBean
|
||||
" Old value = " + oldv +
|
||||
" New value = " + newv);
|
||||
} catch (Exception e) {
|
||||
if (MODELMBEAN_LOGGER.isLoggable(Level.WARNING)) {
|
||||
MODELMBEAN_LOGGER.logp(Level.WARNING,
|
||||
if (MODELMBEAN_LOGGER.isLoggable(Level.FINE)) {
|
||||
MODELMBEAN_LOGGER.logp(Level.FINE,
|
||||
RequiredModelMBean.class.getName(),mth,
|
||||
"Failed to log " + ntfyObj.getType() +
|
||||
" notification: ", e);
|
||||
@ -2644,8 +2644,8 @@ public class RequiredModelMBean
|
||||
" Old value = " + oldv +
|
||||
" New value = " + newv);
|
||||
} catch (Exception e) {
|
||||
if (MODELMBEAN_LOGGER.isLoggable(Level.WARNING)) {
|
||||
MODELMBEAN_LOGGER.logp(Level.WARNING,
|
||||
if (MODELMBEAN_LOGGER.isLoggable(Level.FINE)) {
|
||||
MODELMBEAN_LOGGER.logp(Level.FINE,
|
||||
RequiredModelMBean.class.getName(),mth,
|
||||
"Failed to log " + ntfyObj.getType() +
|
||||
" notification: ", e);
|
||||
|
||||
@ -102,7 +102,7 @@ class OCSPChecker extends PKIXCertPathChecker {
|
||||
*/
|
||||
public void init(boolean forward) throws CertPathValidatorException {
|
||||
if (!forward) {
|
||||
remainingCerts = certs.length;
|
||||
remainingCerts = certs.length + 1;
|
||||
} else {
|
||||
throw new CertPathValidatorException(
|
||||
"Forward checking not supported");
|
||||
@ -131,14 +131,22 @@ class OCSPChecker extends PKIXCertPathChecker {
|
||||
|
||||
InputStream in = null;
|
||||
OutputStream out = null;
|
||||
|
||||
// Decrement the certificate counter
|
||||
remainingCerts--;
|
||||
|
||||
try {
|
||||
// Examine OCSP properties
|
||||
X509Certificate responderCert = null;
|
||||
boolean seekResponderCert = false;
|
||||
X500Principal responderSubjectName = null;
|
||||
X500Principal responderIssuerName = null;
|
||||
BigInteger responderSerialNumber = null;
|
||||
|
||||
boolean seekIssuerCert = true;
|
||||
X509CertImpl issuerCertImpl = null;
|
||||
X509CertImpl currCertImpl =
|
||||
X509CertImpl.toImpl((X509Certificate)cert);
|
||||
|
||||
/*
|
||||
* OCSP security property values, in the following order:
|
||||
* 1. ocsp.responderURL
|
||||
@ -148,6 +156,9 @@ class OCSPChecker extends PKIXCertPathChecker {
|
||||
*/
|
||||
String[] properties = getOCSPProperties();
|
||||
|
||||
// Check whether OCSP is feasible before seeking cert information
|
||||
URL url = getOCSPServerURL(currCertImpl, properties);
|
||||
|
||||
// When responder's subject name is set then the issuer/serial
|
||||
// properties are ignored
|
||||
if (properties[1] != null) {
|
||||
@ -172,14 +183,9 @@ class OCSPChecker extends PKIXCertPathChecker {
|
||||
seekResponderCert = true;
|
||||
}
|
||||
|
||||
boolean seekIssuerCert = true;
|
||||
X509CertImpl issuerCertImpl = null;
|
||||
X509CertImpl currCertImpl =
|
||||
X509CertImpl.toImpl((X509Certificate)cert);
|
||||
remainingCerts--;
|
||||
|
||||
// Set the issuer certificate
|
||||
if (remainingCerts != 0) {
|
||||
// Set the issuer certificate to the next cert in the chain
|
||||
// (unless we're processing the final cert).
|
||||
if (remainingCerts < certs.length) {
|
||||
issuerCertImpl = X509CertImpl.toImpl(certs[remainingCerts]);
|
||||
seekIssuerCert = false; // done
|
||||
|
||||
@ -312,7 +318,8 @@ class OCSPChecker extends PKIXCertPathChecker {
|
||||
// Construct an OCSP Request
|
||||
OCSPRequest ocspRequest =
|
||||
new OCSPRequest(currCertImpl, issuerCertImpl);
|
||||
URL url = getOCSPServerURL(currCertImpl, properties);
|
||||
|
||||
// Use the URL to the OCSP service that was created earlier
|
||||
HttpURLConnection con = (HttpURLConnection)url.openConnection();
|
||||
if (DEBUG != null) {
|
||||
DEBUG.println("connecting to OCSP service at: " + url);
|
||||
|
||||
@ -358,15 +358,28 @@ Java_java_net_PlainSocketImpl_socketConnect(JNIEnv *env, jobject this,
|
||||
* See 6343810.
|
||||
*/
|
||||
while (1) {
|
||||
fd_set wr, ex;
|
||||
#ifndef USE_SELECT
|
||||
{
|
||||
fprintf(stdout,"\nNATIVE: fd = %d] ", fd);
|
||||
struct pollfd pfd;
|
||||
pfd.fd = fd;
|
||||
pfd.events = POLLOUT;
|
||||
|
||||
FD_ZERO(&wr);
|
||||
FD_SET(fd, &wr);
|
||||
FD_ZERO(&ex);
|
||||
FD_SET(fd, &ex);
|
||||
connect_rv = NET_Poll(&pfd, 1, -1);
|
||||
}
|
||||
#else
|
||||
{
|
||||
fd_set wr, ex;
|
||||
|
||||
FD_ZERO(&wr);
|
||||
FD_SET(fd, &wr);
|
||||
FD_ZERO(&ex);
|
||||
FD_SET(fd, &ex);
|
||||
|
||||
connect_rv = NET_Select(fd+1, 0, &wr, &ex, 0);
|
||||
}
|
||||
#endif
|
||||
|
||||
errno = 0;
|
||||
connect_rv = NET_Select(fd+1, 0, &wr, &ex, 0);
|
||||
if (connect_rv == JVM_IO_ERR) {
|
||||
if (errno == EINTR) {
|
||||
continue;
|
||||
|
||||
@ -3464,6 +3464,21 @@ UINT AwtComponent::WindowsKeyToJavaKey(UINT windowsKey, UINT modifiers)
|
||||
return java_awt_event_KeyEvent_VK_UNDEFINED;
|
||||
}
|
||||
|
||||
BOOL AwtComponent::IsNavigationKey(UINT wkey) {
|
||||
switch (wkey) {
|
||||
case VK_END:
|
||||
case VK_PRIOR: // PageUp
|
||||
case VK_NEXT: // PageDown
|
||||
case VK_HOME:
|
||||
case VK_LEFT:
|
||||
case VK_UP:
|
||||
case VK_RIGHT:
|
||||
case VK_DOWN:
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
// determine if a key is a numpad key (distinguishes the numpad
|
||||
// arrow keys from the non-numpad arrow keys, for example).
|
||||
BOOL AwtComponent::IsNumPadKey(UINT vkey, BOOL extended)
|
||||
@ -3563,7 +3578,10 @@ UINT AwtComponent::WindowsKeyToJavaChar(UINT wkey, UINT modifiers, TransOps ops)
|
||||
// fix for 4623376,4737679,4501485,4740906,4708221 (4173679/4122715)
|
||||
// Here we try to resolve a conflict with ::ToAsciiEx's translating
|
||||
// ALT+number key combinations. kdm@sarc.spb.su
|
||||
keyboardState[VK_MENU] &= ~KEY_STATE_DOWN;
|
||||
// yan: Do it for navigation keys only, otherwise some AltGr deadkeys fail.
|
||||
if( IsNavigationKey(wkey) ) {
|
||||
keyboardState[VK_MENU] &= ~KEY_STATE_DOWN;
|
||||
}
|
||||
|
||||
if (ctrlIsDown)
|
||||
{
|
||||
|
||||
@ -823,6 +823,7 @@ public:
|
||||
private:
|
||||
AwtComponent* SearchChild(UINT id);
|
||||
void RemoveChild(UINT id) ;
|
||||
static BOOL IsNavigationKey(UINT wkey);
|
||||
|
||||
ChildListItem* m_childList;
|
||||
|
||||
|
||||
@ -1,75 +0,0 @@
|
||||
/*
|
||||
* Copyright 2005 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
||||
* CA 95054 USA or visit www.sun.com if you need additional information or
|
||||
* have any questions.
|
||||
*/
|
||||
|
||||
/*
|
||||
* @test
|
||||
* @bug 6316460
|
||||
* @summary Test that the legacy com.sun.management.jmx.Introspector
|
||||
* methods work.
|
||||
* @author Eamonn McManus
|
||||
* @run clean LegacyIntrospectorTest
|
||||
* @run build LegacyIntrospectorTest
|
||||
* @run main LegacyIntrospectorTest
|
||||
*/
|
||||
|
||||
import javax.management.*;
|
||||
import com.sun.management.jmx.*;
|
||||
|
||||
public class LegacyIntrospectorTest {
|
||||
public static interface TestMBean {
|
||||
public int getWhatever();
|
||||
}
|
||||
public static class Test implements TestMBean {
|
||||
public int getWhatever() {return 0;}
|
||||
}
|
||||
|
||||
@SuppressWarnings("deprecation")
|
||||
public static void main(String[] args) throws Exception {
|
||||
MBeanInfo mbi = Introspector.testCompliance(Test.class);
|
||||
MBeanAttributeInfo mbai = mbi.getAttributes()[0];
|
||||
if (!mbai.getName().equals("Whatever"))
|
||||
throw new Exception("Wrong attribute name: " + mbai.getName());
|
||||
Class c = Introspector.getMBeanInterface(Test.class);
|
||||
if (c != TestMBean.class)
|
||||
throw new Exception("Wrong interface: " + c);
|
||||
|
||||
MBeanServer mbs1 = new MBeanServerImpl();
|
||||
if (!mbs1.getDefaultDomain().equals("DefaultDomain"))
|
||||
throw new Exception("Wrong default domain: " + mbs1.getDefaultDomain());
|
||||
|
||||
MBeanServer mbs2 = new MBeanServerImpl("Foo");
|
||||
if (!mbs2.getDefaultDomain().equals("Foo"))
|
||||
throw new Exception("Wrong default domain: " + mbs2.getDefaultDomain());
|
||||
|
||||
ObjectName delegateName =
|
||||
new ObjectName("JMImplementation:type=MBeanServerDelegate");
|
||||
MBeanInfo delegateInfo = mbs2.getMBeanInfo(delegateName);
|
||||
MBeanInfo refDelegateInfo =
|
||||
MBeanServerFactory.newMBeanServer().getMBeanInfo(delegateName);
|
||||
if (!delegateInfo.equals(refDelegateInfo))
|
||||
throw new Exception("Wrong delegate info from MBeanServerImpl: " +
|
||||
delegateInfo);
|
||||
|
||||
System.out.println("TEST PASSED");
|
||||
}
|
||||
}
|
||||
@ -2,32 +2,22 @@
|
||||
* Copyright 2008 Sun Microsystems, Inc. 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 modi
|
||||
fy it
|
||||
* under the terms of the GNU General Public License version 2 onl
|
||||
y, as
|
||||
* 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, bu
|
||||
t WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABIL
|
||||
ITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public L
|
||||
icense
|
||||
* version 2 for more details (a copy is included in the LICENSE f
|
||||
ile that
|
||||
* 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 Licen
|
||||
se version
|
||||
* 2 along with this work; if not, write to the Free Software Foun
|
||||
dation,
|
||||
* 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 Sun Microsystems, Inc., 4150 Network Circle, San
|
||||
ta Clara,
|
||||
* CA 95054 USA or visit www.sun.com if you need additional inform
|
||||
ation or
|
||||
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
||||
* CA 95054 USA or visit www.sun.com if you need additional information or
|
||||
* have any questions.
|
||||
*/
|
||||
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
#
|
||||
# Copyright 2006 Sun Microsystems, Inc. All Rights Reserved.
|
||||
# Copyright 2006-2008 Sun Microsystems, Inc. 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
|
||||
@ -90,7 +90,8 @@ chmod u+w cert8.db
|
||||
|
||||
echo | ${TESTJAVA}${FS}bin${FS}java -Dfile -Dnss \
|
||||
-Dnss.lib=${NSS}${FS}lib${FS}${PF}${FS}${LIBNAME} \
|
||||
KeyToolTest || exit 12
|
||||
KeyToolTest
|
||||
status=$?
|
||||
|
||||
rm -f p11-nss.txt
|
||||
rm -f cert8.db
|
||||
@ -101,4 +102,5 @@ rm HumanInputStream*.class
|
||||
rm KeyToolTest.class
|
||||
rm TestException.class
|
||||
|
||||
exit $?
|
||||
exit $status
|
||||
|
||||
|
||||
@ -2,3 +2,4 @@
|
||||
58039502942e52f4144a33f36290a2bd2f3581e6 jdk7-b25
|
||||
c46d25a2350ac147d0121d9c9725af6fcb1b4dbe jdk7-b26
|
||||
a17265993253d61becd04fe7d96d1fe8b4bd6dff jdk7-b27
|
||||
4ef4bd31856949554967fbf22783babb21a62a0e jdk7-b28
|
||||
|
||||
@ -301,7 +301,11 @@ public class Types {
|
||||
: isSubtypeUnchecked(elemtype(t), elemtype(s), warn);
|
||||
} else if (isSubtype(t, s)) {
|
||||
return true;
|
||||
} else if (!s.isRaw()) {
|
||||
}
|
||||
else if (t.tag == TYPEVAR) {
|
||||
return isSubtypeUnchecked(t.getUpperBound(), s, warn);
|
||||
}
|
||||
else if (!s.isRaw()) {
|
||||
Type t2 = asSuper(t, s.tsym);
|
||||
if (t2 != null && t2.isRaw()) {
|
||||
if (isReifiable(s))
|
||||
|
||||
@ -454,6 +454,8 @@ public class Attr extends JCTree.Visitor {
|
||||
void attribTypeVariables(List<JCTypeParameter> typarams, Env<AttrContext> env) {
|
||||
for (JCTypeParameter tvar : typarams) {
|
||||
TypeVar a = (TypeVar)tvar.type;
|
||||
a.tsym.flags_field |= UNATTRIBUTED;
|
||||
a.bound = Type.noType;
|
||||
if (!tvar.bounds.isEmpty()) {
|
||||
List<Type> bounds = List.of(attribType(tvar.bounds.head, env));
|
||||
for (JCExpression bound : tvar.bounds.tail)
|
||||
@ -464,13 +466,14 @@ public class Attr extends JCTree.Visitor {
|
||||
// java.lang.Object.
|
||||
types.setBounds(a, List.of(syms.objectType));
|
||||
}
|
||||
a.tsym.flags_field &= ~UNATTRIBUTED;
|
||||
}
|
||||
}
|
||||
|
||||
void attribBounds(List<JCTypeParameter> typarams, Env<AttrContext> env) {
|
||||
for (JCTypeParameter tvar : typarams)
|
||||
chk.checkNonCyclic(tvar.pos(), (TypeVar)tvar.type);
|
||||
attribStats(typarams, env);
|
||||
}
|
||||
|
||||
void attribBounds(List<JCTypeParameter> typarams) {
|
||||
for (JCTypeParameter typaram : typarams) {
|
||||
Type bound = typaram.type.getUpperBound();
|
||||
if (bound != null && bound.tsym instanceof ClassSymbol) {
|
||||
@ -581,7 +584,7 @@ public class Attr extends JCTree.Visitor {
|
||||
try {
|
||||
chk.checkDeprecatedAnnotation(tree.pos(), m);
|
||||
|
||||
attribBounds(tree.typarams, env);
|
||||
attribBounds(tree.typarams);
|
||||
|
||||
// If we override any other methods, check that we do so properly.
|
||||
// JLS ???
|
||||
@ -2689,7 +2692,7 @@ public class Attr extends JCTree.Visitor {
|
||||
chk.validateAnnotations(tree.mods.annotations, c);
|
||||
|
||||
// Validate type parameters, supertype and interfaces.
|
||||
attribBounds(tree.typarams, env);
|
||||
attribBounds(tree.typarams);
|
||||
chk.validateTypeParams(tree.typarams);
|
||||
chk.validate(tree.extending);
|
||||
chk.validate(tree.implementing);
|
||||
|
||||
@ -1486,6 +1486,8 @@ public class Check {
|
||||
|
||||
private void checkNonCyclic1(DiagnosticPosition pos, Type t, Set<TypeVar> seen) {
|
||||
final TypeVar tv;
|
||||
if (t.tag == TYPEVAR && (t.tsym.flags() & UNATTRIBUTED) != 0)
|
||||
return;
|
||||
if (seen.contains(t)) {
|
||||
tv = (TypeVar)t;
|
||||
tv.bound = new ErrorType();
|
||||
|
||||
@ -228,7 +228,7 @@ public class Resolve {
|
||||
// another symbol which is a member of `site'
|
||||
// (because, if it is overridden, `sym' is not strictly
|
||||
// speaking a member of `site'.)
|
||||
(sym.kind != MTH || sym.isConstructor() ||
|
||||
(sym.kind != MTH || sym.isConstructor() || sym.isStatic() ||
|
||||
((MethodSymbol)sym).implementation(site.tsym, types, true) == sym);
|
||||
default: // this case includes erroneous combinations as well
|
||||
return isAccessible(env, site);
|
||||
|
||||
@ -1606,7 +1606,7 @@ public class JavacFileManager implements StandardJavaFileManager {
|
||||
/** @deprecated see bug 6410637 */
|
||||
@Deprecated
|
||||
public String getPath() {
|
||||
return entry.getName() + "(" + entry + ")";
|
||||
return zipName + "(" + entry.getName() + ")";
|
||||
}
|
||||
|
||||
public long getLastModified() {
|
||||
|
||||
@ -1,3 +1,28 @@
|
||||
/*
|
||||
* Copyright 2007-2008 Sun Microsystems, Inc. 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. Sun designates this
|
||||
* particular file as subject to the "Classpath" exception as provided
|
||||
* by Sun in the LICENSE file that accompanied this code.
|
||||
*
|
||||
* 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
||||
* CA 95054 USA or visit www.sun.com if you need additional information or
|
||||
* have any questions.
|
||||
*/
|
||||
|
||||
package com.sun.tools.javac.zip;
|
||||
|
||||
import java.io.*;
|
||||
|
||||
@ -1,3 +1,28 @@
|
||||
/*
|
||||
* Copyright 2007-2008 Sun Microsystems, Inc. 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. Sun designates this
|
||||
* particular file as subject to the "Classpath" exception as provided
|
||||
* by Sun in the LICENSE file that accompanied this code.
|
||||
*
|
||||
* 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
||||
* CA 95054 USA or visit www.sun.com if you need additional information or
|
||||
* have any questions.
|
||||
*/
|
||||
|
||||
package com.sun.tools.javac.zip;
|
||||
|
||||
import java.io.File;
|
||||
|
||||
@ -58,7 +58,7 @@ public class ClassData implements RuntimeConstants {
|
||||
private String superclassname;
|
||||
private int source_cpx=0;
|
||||
private byte tags[];
|
||||
private Hashtable indexHashAscii = new Hashtable();
|
||||
private Hashtable<Object,Integer> indexHashAscii = new Hashtable<Object,Integer>();
|
||||
private String pkgPrefix="";
|
||||
private int pkgPrefixLen=0;
|
||||
|
||||
@ -167,19 +167,19 @@ public class ClassData implements RuntimeConstants {
|
||||
switch(tags[i] = tag) {
|
||||
case CONSTANT_UTF8:
|
||||
String str=in.readUTF();
|
||||
indexHashAscii.put(cpool[i] = str, new Integer(i));
|
||||
indexHashAscii.put(cpool[i] = str, i);
|
||||
break;
|
||||
case CONSTANT_INTEGER:
|
||||
cpool[i] = new Integer(in.readInt());
|
||||
cpool[i] = Integer.valueOf(in.readInt());
|
||||
break;
|
||||
case CONSTANT_FLOAT:
|
||||
cpool[i] = new Float(in.readFloat());
|
||||
cpool[i] = Float.valueOf(in.readFloat());
|
||||
break;
|
||||
case CONSTANT_LONG:
|
||||
cpool[i++] = new Long(in.readLong());
|
||||
cpool[i++] = Long.valueOf(in.readLong());
|
||||
break;
|
||||
case CONSTANT_DOUBLE:
|
||||
cpool[i++] = new Double(in.readDouble());
|
||||
cpool[i++] = Double.valueOf(in.readDouble());
|
||||
break;
|
||||
case CONSTANT_CLASS:
|
||||
case CONSTANT_STRING:
|
||||
@ -365,7 +365,7 @@ public class ClassData implements RuntimeConstants {
|
||||
* Returns the access of this class or interface.
|
||||
*/
|
||||
public String[] getAccess(){
|
||||
Vector v = new Vector();
|
||||
Vector<String> v = new Vector<String>();
|
||||
if ((access & ACC_PUBLIC) !=0) v.addElement("public");
|
||||
if ((access & ACC_FINAL) !=0) v.addElement("final");
|
||||
if ((access & ACC_ABSTRACT) !=0) v.addElement("abstract");
|
||||
|
||||
@ -45,7 +45,7 @@ public class FieldData implements RuntimeConstants {
|
||||
int value_cpx=0;
|
||||
boolean isSynthetic=false;
|
||||
boolean isDeprecated=false;
|
||||
Vector attrs;
|
||||
Vector<AttrData> attrs;
|
||||
|
||||
public FieldData(ClassData cls){
|
||||
this.cls=cls;
|
||||
@ -60,7 +60,7 @@ public class FieldData implements RuntimeConstants {
|
||||
descriptor_index = in.readUnsignedShort();
|
||||
// Read the attributes
|
||||
int attributes_count = in.readUnsignedShort();
|
||||
attrs=new Vector(attributes_count);
|
||||
attrs=new Vector<AttrData>(attributes_count);
|
||||
for (int i = 0; i < attributes_count; i++) {
|
||||
int attr_name_index=in.readUnsignedShort();
|
||||
if (cls.getTag(attr_name_index)!=CONSTANT_UTF8) continue;
|
||||
@ -99,7 +99,7 @@ public class FieldData implements RuntimeConstants {
|
||||
* Returns access of a field.
|
||||
*/
|
||||
public String[] getAccess(){
|
||||
Vector v = new Vector();
|
||||
Vector<String> v = new Vector<String>();
|
||||
if ((access & ACC_PUBLIC) !=0) v.addElement("public");
|
||||
if ((access & ACC_PRIVATE) !=0) v.addElement("private");
|
||||
if ((access & ACC_PROTECTED) !=0) v.addElement("protected");
|
||||
|
||||
@ -63,7 +63,7 @@ class InnerClassData implements RuntimeConstants {
|
||||
* Returns the access of this class or interface.
|
||||
*/
|
||||
public String[] getAccess(){
|
||||
Vector v = new Vector();
|
||||
Vector<String> v = new Vector<String>();
|
||||
if ((access & ACC_PUBLIC) !=0) v.addElement("public");
|
||||
if ((access & ACC_FINAL) !=0) v.addElement("final");
|
||||
if ((access & ACC_ABSTRACT) !=0) v.addElement("abstract");
|
||||
|
||||
@ -653,7 +653,7 @@ public class JavapPrinter {
|
||||
case CONSTANT_METHOD:
|
||||
case CONSTANT_INTERFACEMETHOD:
|
||||
case CONSTANT_FIELD: {
|
||||
CPX2 x = (CPX2)(cls.getCpoolEntry(cpx));
|
||||
CPX2 x = cls.getCpoolEntry(cpx);
|
||||
if (x.cpx1 == cls.getthis_cpx()) {
|
||||
// don't print class part for local references
|
||||
cpx=x.cpx2;
|
||||
@ -851,7 +851,7 @@ public class JavapPrinter {
|
||||
case CONSTANT_INTERFACEMETHOD:
|
||||
case CONSTANT_FIELD: {
|
||||
// CPX2 x=(CPX2)(cpool[cpx]);
|
||||
CPX2 x = (CPX2)(cls.getCpoolEntry(cpx));
|
||||
CPX2 x = cls.getCpoolEntry(cpx);
|
||||
if (x.cpx1 == cls.getthis_cpx()) {
|
||||
// don't print class part for local references
|
||||
cpx=x.cpx2;
|
||||
|
||||
@ -35,9 +35,9 @@ import java.io.*;
|
||||
*
|
||||
* @author Sucheta Dambalkar (Adopted code from old javap)
|
||||
*/
|
||||
public class Main{
|
||||
public class Main {
|
||||
|
||||
private Vector classList = new Vector();
|
||||
private Vector<String> classList = new Vector<String>();
|
||||
private PrintWriter out;
|
||||
JavapEnvironment env = new JavapEnvironment();
|
||||
private static boolean errorOccurred = false;
|
||||
@ -201,7 +201,7 @@ public class Main{
|
||||
*/
|
||||
private void displayResults() {
|
||||
for (int i = 0; i < classList.size() ; i++ ) {
|
||||
String Name = (String)classList.elementAt(i);
|
||||
String Name = classList.elementAt(i);
|
||||
InputStream classin = env.getFileInputStream(Name);
|
||||
|
||||
try {
|
||||
|
||||
@ -43,14 +43,14 @@ public class MethodData {
|
||||
int descriptor_index;
|
||||
int attributes_count;
|
||||
byte[] code;
|
||||
Vector exception_table = new Vector(0);
|
||||
Vector lin_num_tb = new Vector(0);
|
||||
Vector loc_var_tb = new Vector(0);
|
||||
Vector<TrapData> exception_table = new Vector<TrapData>(0);
|
||||
Vector<LineNumData> lin_num_tb = new Vector<LineNumData>(0);
|
||||
Vector<LocVarData> loc_var_tb = new Vector<LocVarData>(0);
|
||||
StackMapTableData[] stackMapTable;
|
||||
StackMapData[] stackMap;
|
||||
int[] exc_index_table=null;
|
||||
Vector attrs=new Vector(0);
|
||||
Vector code_attrs=new Vector(0);
|
||||
Vector<AttrData> attrs=new Vector<AttrData>(0);
|
||||
Vector<AttrData> code_attrs=new Vector<AttrData>(0);
|
||||
int max_stack, max_locals;
|
||||
boolean isSynthetic=false;
|
||||
boolean isDeprecated=false;
|
||||
@ -165,7 +165,7 @@ public class MethodData {
|
||||
*/
|
||||
void readExceptionTable (DataInputStream in) throws IOException {
|
||||
int exception_table_len=in.readUnsignedShort();
|
||||
exception_table=new Vector(exception_table_len);
|
||||
exception_table=new Vector<TrapData>(exception_table_len);
|
||||
for (int l = 0; l < exception_table_len; l++) {
|
||||
exception_table.addElement(new TrapData(in, l));
|
||||
}
|
||||
@ -177,7 +177,7 @@ public class MethodData {
|
||||
void readLineNumTable (DataInputStream in) throws IOException {
|
||||
int attr_len = in.readInt(); // attr_length
|
||||
int lin_num_tb_len = in.readUnsignedShort();
|
||||
lin_num_tb=new Vector(lin_num_tb_len);
|
||||
lin_num_tb=new Vector<LineNumData>(lin_num_tb_len);
|
||||
for (int l = 0; l < lin_num_tb_len; l++) {
|
||||
lin_num_tb.addElement(new LineNumData(in));
|
||||
}
|
||||
@ -189,7 +189,7 @@ public class MethodData {
|
||||
void readLocVarTable (DataInputStream in) throws IOException {
|
||||
int attr_len=in.readInt(); // attr_length
|
||||
int loc_var_tb_len = in.readUnsignedShort();
|
||||
loc_var_tb = new Vector(loc_var_tb_len);
|
||||
loc_var_tb = new Vector<LocVarData>(loc_var_tb_len);
|
||||
for (int l = 0; l < loc_var_tb_len; l++) {
|
||||
loc_var_tb.addElement(new LocVarData(in));
|
||||
}
|
||||
@ -237,7 +237,7 @@ public class MethodData {
|
||||
*/
|
||||
public String[] getAccess(){
|
||||
|
||||
Vector v = new Vector();
|
||||
Vector<String> v = new Vector<String>();
|
||||
if ((access & ACC_PUBLIC) !=0) v.addElement("public");
|
||||
if ((access & ACC_PRIVATE) !=0) v.addElement("private");
|
||||
if ((access & ACC_PROTECTED) !=0) v.addElement("protected");
|
||||
|
||||
@ -26,8 +26,6 @@
|
||||
|
||||
package sun.tools.javap;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.util.Hashtable;
|
||||
import java.util.Vector;
|
||||
|
||||
@ -36,14 +34,14 @@ public class Tables implements Constants {
|
||||
/**
|
||||
* Define mnemocodes table.
|
||||
*/
|
||||
static Hashtable mnemocodes = new Hashtable(301, 0.5f);
|
||||
static Hashtable<String,Integer> mnemocodes = new Hashtable<String,Integer>(301, 0.5f);
|
||||
static String opcExtNamesTab[]=new String[128];
|
||||
static String opcPrivExtNamesTab[]=new String[128];
|
||||
static void defineNonPriv(int opc, String mnem) {
|
||||
mnemocodes.put(opcExtNamesTab[opc]=mnem, new Integer(opc_nonpriv*256+opc));
|
||||
mnemocodes.put(opcExtNamesTab[opc]=mnem, opc_nonpriv*256+opc);
|
||||
}
|
||||
static void definePriv(int opc, String mnem) {
|
||||
mnemocodes.put(opcPrivExtNamesTab[opc]="priv_"+mnem, new Integer(opc_priv*256+opc));
|
||||
mnemocodes.put(opcPrivExtNamesTab[opc]="priv_"+mnem, opc_priv*256+opc);
|
||||
}
|
||||
static void defineExt(int opc, String mnem) {
|
||||
defineNonPriv(opc, mnem);
|
||||
@ -51,28 +49,28 @@ public class Tables implements Constants {
|
||||
}
|
||||
static { int k;
|
||||
for (k=0; k<opc_wide; k++) {
|
||||
mnemocodes.put(opcNamesTab[k], new Integer(k));
|
||||
mnemocodes.put(opcNamesTab[k], k);
|
||||
}
|
||||
for (k=opc_wide+1; k<opcNamesTab.length; k++) {
|
||||
mnemocodes.put(opcNamesTab[k], new Integer(k));
|
||||
mnemocodes.put(opcNamesTab[k], k);
|
||||
}
|
||||
mnemocodes.put("invokenonvirtual", new Integer(opc_invokespecial));
|
||||
mnemocodes.put("invokenonvirtual", opc_invokespecial);
|
||||
|
||||
mnemocodes.put("iload_w", new Integer(opc_iload_w));
|
||||
mnemocodes.put("lload_w", new Integer(opc_lload_w));
|
||||
mnemocodes.put("fload_w", new Integer(opc_fload_w));
|
||||
mnemocodes.put("dload_w", new Integer(opc_dload_w));
|
||||
mnemocodes.put("aload_w", new Integer(opc_aload_w));
|
||||
mnemocodes.put("istore_w", new Integer(opc_istore_w));
|
||||
mnemocodes.put("lstore_w", new Integer(opc_lstore_w));
|
||||
mnemocodes.put("fstore_w", new Integer(opc_fstore_w));
|
||||
mnemocodes.put("dstore_w", new Integer(opc_dstore_w));
|
||||
mnemocodes.put("astore_w", new Integer(opc_astore_w));
|
||||
mnemocodes.put("ret_w", new Integer(opc_ret_w));
|
||||
mnemocodes.put("iinc_w", new Integer(opc_iinc_w));
|
||||
mnemocodes.put("iload_w", opc_iload_w);
|
||||
mnemocodes.put("lload_w", opc_lload_w);
|
||||
mnemocodes.put("fload_w", opc_fload_w);
|
||||
mnemocodes.put("dload_w", opc_dload_w);
|
||||
mnemocodes.put("aload_w", opc_aload_w);
|
||||
mnemocodes.put("istore_w", opc_istore_w);
|
||||
mnemocodes.put("lstore_w", opc_lstore_w);
|
||||
mnemocodes.put("fstore_w", opc_fstore_w);
|
||||
mnemocodes.put("dstore_w", opc_dstore_w);
|
||||
mnemocodes.put("astore_w", opc_astore_w);
|
||||
mnemocodes.put("ret_w", opc_ret_w);
|
||||
mnemocodes.put("iinc_w", opc_iinc_w);
|
||||
|
||||
mnemocodes.put("nonpriv", new Integer(opc_nonpriv));
|
||||
mnemocodes.put("priv", new Integer(opc_priv));
|
||||
mnemocodes.put("nonpriv", opc_nonpriv);
|
||||
mnemocodes.put("priv", opc_priv);
|
||||
|
||||
defineExt(0, "load_ubyte");
|
||||
defineExt(1, "load_byte");
|
||||
@ -183,7 +181,7 @@ public class Tables implements Constants {
|
||||
}
|
||||
|
||||
public static int opcode(String mnem) {
|
||||
Integer Val=(Integer)(mnemocodes.get(mnem));
|
||||
Integer Val=mnemocodes.get(mnem);
|
||||
if (Val == null) return -1;
|
||||
return Val.intValue();
|
||||
}
|
||||
@ -191,7 +189,7 @@ public class Tables implements Constants {
|
||||
/**
|
||||
* Initialized keyword and token Hashtables
|
||||
*/
|
||||
static Vector keywordNames = new Vector(40);
|
||||
static Vector<String> keywordNames = new Vector<String>(40);
|
||||
private static void defineKeywordName(String id, int token) {
|
||||
|
||||
if (token>=keywordNames.size()) {
|
||||
@ -202,7 +200,7 @@ public class Tables implements Constants {
|
||||
public static String keywordName(int token) {
|
||||
if (token==-1) return "EOF";
|
||||
if (token>=keywordNames.size()) return null;
|
||||
return (String)keywordNames.elementAt(token);
|
||||
return keywordNames.elementAt(token);
|
||||
}
|
||||
static {
|
||||
defineKeywordName("ident", IDENT);
|
||||
@ -217,15 +215,15 @@ public class Tables implements Constants {
|
||||
defineKeywordName("RBRACE", RBRACE);
|
||||
}
|
||||
|
||||
static Hashtable keywords = new Hashtable(40);
|
||||
static Hashtable<String,Integer> keywords = new Hashtable<String,Integer>(40);
|
||||
public static int keyword(String idValue) {
|
||||
Integer Val=(Integer)(keywords.get(idValue));
|
||||
if (Val == null) return IDENT;
|
||||
return Val.intValue();
|
||||
Integer val=keywords.get(idValue);
|
||||
if (val == null) return IDENT;
|
||||
return val.intValue();
|
||||
}
|
||||
|
||||
private static void defineKeyword(String id, int token) {
|
||||
keywords.put(id, new Integer(token));
|
||||
keywords.put(id, token);
|
||||
defineKeywordName(id, token);
|
||||
}
|
||||
static {
|
||||
@ -275,8 +273,8 @@ public class Tables implements Constants {
|
||||
/**
|
||||
* Define tag table.
|
||||
*/
|
||||
private static Vector tagNames = new Vector(10);
|
||||
private static Hashtable Tags = new Hashtable(10);
|
||||
private static Vector<String> tagNames = new Vector<String>(10);
|
||||
private static Hashtable<String,Integer> Tags = new Hashtable<String,Integer>(10);
|
||||
static {
|
||||
defineTag("Asciz",CONSTANT_UTF8);
|
||||
defineTag("int",CONSTANT_INTEGER);
|
||||
@ -291,7 +289,7 @@ public class Tables implements Constants {
|
||||
defineTag("NameAndType",CONSTANT_NAMEANDTYPE);
|
||||
}
|
||||
private static void defineTag(String id, int val) {
|
||||
Tags.put(id, new Integer(val));
|
||||
Tags.put(id, val);
|
||||
if (val>=tagNames.size()) {
|
||||
tagNames.setSize(val+1);
|
||||
}
|
||||
@ -299,10 +297,10 @@ public class Tables implements Constants {
|
||||
}
|
||||
public static String tagName(int tag) {
|
||||
if (tag>=tagNames.size()) return null;
|
||||
return (String)tagNames.elementAt(tag);
|
||||
return tagNames.elementAt(tag);
|
||||
}
|
||||
public static int tagValue(String idValue) {
|
||||
Integer Val=(Integer)(Tags.get(idValue));
|
||||
Integer Val=Tags.get(idValue);
|
||||
if (Val == null) return 0;
|
||||
return Val.intValue();
|
||||
}
|
||||
@ -310,8 +308,8 @@ public class Tables implements Constants {
|
||||
/**
|
||||
* Define type table. These types used in "newarray" instruction only.
|
||||
*/
|
||||
private static Vector typeNames = new Vector(10);
|
||||
private static Hashtable Types = new Hashtable(10);
|
||||
private static Vector<String> typeNames = new Vector<String>(10);
|
||||
private static Hashtable<String,Integer> Types = new Hashtable<String,Integer>(10);
|
||||
static {
|
||||
defineType("int",T_INT);
|
||||
defineType("long",T_LONG);
|
||||
@ -324,28 +322,28 @@ public class Tables implements Constants {
|
||||
defineType("short",T_SHORT);
|
||||
}
|
||||
private static void defineType(String id, int val) {
|
||||
Types.put(id, new Integer(val));
|
||||
Types.put(id, val);
|
||||
if (val>=typeNames.size()) {
|
||||
typeNames.setSize(val+1);
|
||||
}
|
||||
typeNames.setElementAt(id, val);
|
||||
}
|
||||
public static int typeValue(String idValue) {
|
||||
Integer Val=(Integer)(Types.get(idValue));
|
||||
Integer Val=Types.get(idValue);
|
||||
if (Val == null) return -1;
|
||||
return Val.intValue();
|
||||
}
|
||||
public static String typeName(int type) {
|
||||
if (type>=typeNames.size()) return null;
|
||||
return (String)typeNames.elementAt(type);
|
||||
return typeNames.elementAt(type);
|
||||
}
|
||||
|
||||
/**
|
||||
* Define MapTypes table.
|
||||
* These constants used in stackmap tables only.
|
||||
*/
|
||||
private static Vector mapTypeNames = new Vector(10);
|
||||
private static Hashtable MapTypes = new Hashtable(10);
|
||||
private static Vector<String> mapTypeNames = new Vector<String>(10);
|
||||
private static Hashtable<String,Integer> MapTypes = new Hashtable<String,Integer>(10);
|
||||
static {
|
||||
defineMapType("bogus", ITEM_Bogus);
|
||||
defineMapType("int", ITEM_Integer);
|
||||
@ -358,20 +356,20 @@ public class Tables implements Constants {
|
||||
defineMapType("uninitialized", ITEM_NewObject);
|
||||
}
|
||||
private static void defineMapType(String id, int val) {
|
||||
MapTypes.put(id, new Integer(val));
|
||||
MapTypes.put(id, val);
|
||||
if (val>=mapTypeNames.size()) {
|
||||
mapTypeNames.setSize(val+1);
|
||||
}
|
||||
mapTypeNames.setElementAt(id, val);
|
||||
}
|
||||
public static int mapTypeValue(String idValue) {
|
||||
Integer Val=(Integer)(MapTypes.get(idValue));
|
||||
Integer Val=MapTypes.get(idValue);
|
||||
if (Val == null) return -1;
|
||||
return Val.intValue();
|
||||
}
|
||||
public static String mapTypeName(int type) {
|
||||
if (type>=mapTypeNames.size()) return null;
|
||||
return (String)mapTypeNames.elementAt(type);
|
||||
return mapTypeNames.elementAt(type);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -79,7 +79,7 @@ public class TypeSignature {
|
||||
* Returns java type signature of a parameter.
|
||||
*/
|
||||
public String getParametersHelper(String parameterdes){
|
||||
Vector parameters = new Vector();
|
||||
Vector<String> parameters = new Vector<String>();
|
||||
int startindex = -1;
|
||||
int endindex = -1;
|
||||
String param = "";
|
||||
@ -187,7 +187,7 @@ public class TypeSignature {
|
||||
int i;
|
||||
|
||||
for(i = 0; i < parameters.size(); i++){
|
||||
parametersignature += (String)parameters.elementAt(i);
|
||||
parametersignature += parameters.elementAt(i);
|
||||
if(i != parameters.size()-1){
|
||||
parametersignature += ", ";
|
||||
}
|
||||
|
||||
@ -24,7 +24,7 @@ public class T6589361 {
|
||||
Iterable<JavaFileObject> files = fm.list(StandardLocation.PLATFORM_CLASS_PATH, "java.lang", set, false);
|
||||
for (JavaFileObject file : files) {
|
||||
|
||||
if (file.toString().startsWith("java" + File.separator + "lang" + File.separator + "Object.class")) {
|
||||
if (file.toString().contains("java" + File.separator + "lang" + File.separator + "Object.class")) {
|
||||
String str = fm.inferBinaryName(StandardLocation.CLASS_PATH, file);
|
||||
if (!str.equals("java.lang.Object")) {
|
||||
throw new AssertionError("Error in JavacFileManager.inferBinaryName method!");
|
||||
|
||||
65
langtools/test/tools/javac/T6705935.java
Normal file
65
langtools/test/tools/javac/T6705935.java
Normal file
@ -0,0 +1,65 @@
|
||||
/*
|
||||
* Copyright 2008 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
||||
* CA 95054 USA or visit www.sun.com if you need additional information or
|
||||
* have any questions.
|
||||
*/
|
||||
|
||||
/*
|
||||
* @test
|
||||
* @bug 6705935
|
||||
* @summary javac reports path name of entry in ZipFileIndex incorectly
|
||||
*/
|
||||
|
||||
import java.io.*;
|
||||
import java.util.*;
|
||||
import javax.tools.*;
|
||||
import com.sun.tools.javac.util.*;
|
||||
|
||||
public class T6705935 {
|
||||
public static void main(String... args) throws Exception {
|
||||
new T6705935().run();
|
||||
}
|
||||
|
||||
public void run() throws Exception {
|
||||
File java_home = new File(System.getProperty("java.home"));
|
||||
if (java_home.getName().equals("jre"))
|
||||
java_home = java_home.getParentFile();
|
||||
|
||||
JavaCompiler c = ToolProvider.getSystemJavaCompiler();
|
||||
JavaFileManager fm = c.getStandardFileManager(null, null, null);
|
||||
for (JavaFileObject fo: fm.list(StandardLocation.PLATFORM_CLASS_PATH,
|
||||
"java.lang",
|
||||
Collections.singleton(JavaFileObject.Kind.CLASS),
|
||||
false)) {
|
||||
String p = ((BaseFileObject)fo).getPath();
|
||||
int bra = p.indexOf("(");
|
||||
int ket = p.indexOf(")");
|
||||
//System.err.println(bra + "," + ket + "," + p.length());
|
||||
if (bra == -1 || ket != p.length() -1)
|
||||
throw new Exception("unexpected path: " + p + "[" + bra + "," + ket + "," + p.length());
|
||||
String part1 = p.substring(0, bra);
|
||||
String part2 = p.substring(bra + 1, ket);
|
||||
//System.err.println("[" + part1 + "|" + part2 + "]" + " " + java_home);
|
||||
if (part1.equals(part2) || !part1.startsWith(java_home.getPath()))
|
||||
throw new Exception("bad path: " + p);
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
35
langtools/test/tools/javac/generics/6677785/T6677785.java
Normal file
35
langtools/test/tools/javac/generics/6677785/T6677785.java
Normal file
@ -0,0 +1,35 @@
|
||||
/*
|
||||
* Copyright 2008 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
||||
* CA 95054 USA or visit www.sun.com if you need additional information or
|
||||
* have any questions.
|
||||
*/
|
||||
|
||||
/*
|
||||
* @test
|
||||
* @bug 6677785
|
||||
* @summary REGRESSION: StackOverFlowError with Cyclic Class level Type Parameters when used in constructors
|
||||
* @author Maurizio Cimadamore
|
||||
* @compile/fail/ref=T6677785.out -XDstdout -XDrawDiagnostics T6677785.java
|
||||
*/
|
||||
public class T6677785<E extends T, T extends E> {
|
||||
T6677785() {}
|
||||
T6677785(E e) {}
|
||||
T6677785(E e, T t) {}
|
||||
}
|
||||
2
langtools/test/tools/javac/generics/6677785/T6677785.out
Normal file
2
langtools/test/tools/javac/generics/6677785/T6677785.out
Normal file
@ -0,0 +1,2 @@
|
||||
T6677785.java:31:23: compiler.err.cyclic.inheritance: E
|
||||
1 error
|
||||
37
langtools/test/tools/javac/generics/T6507024.java
Normal file
37
langtools/test/tools/javac/generics/T6507024.java
Normal file
@ -0,0 +1,37 @@
|
||||
/*
|
||||
* Copyright 2008 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
||||
* CA 95054 USA or visit www.sun.com if you need additional information or
|
||||
* have any questions.
|
||||
*/
|
||||
|
||||
/*
|
||||
* @test
|
||||
* @bug 6507024
|
||||
* @summary unchecked conversion between arrays fails after capture conversion
|
||||
* @author Maurizio Cimadamore
|
||||
*
|
||||
* @compile T6507024.java
|
||||
*/
|
||||
|
||||
public class T6507024<T> {
|
||||
<Z> void m(T6507024<Z>[] results) {
|
||||
T6507024<Z>[] r = results.getClass().cast(null);
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,31 @@
|
||||
/*
|
||||
* Copyright 2008 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
||||
* CA 95054 USA or visit www.sun.com if you need additional information or
|
||||
* have any questions.
|
||||
*/
|
||||
|
||||
/*
|
||||
* @test
|
||||
* @bug 6665223
|
||||
* @summary Static import of inherited protected method causes compiler exception
|
||||
* @author Maurizio Cimadamore
|
||||
*
|
||||
* @compile pkg/A.java
|
||||
*/
|
||||
31
langtools/test/tools/javac/staticImport/6665223/pkg/A.java
Normal file
31
langtools/test/tools/javac/staticImport/6665223/pkg/A.java
Normal file
@ -0,0 +1,31 @@
|
||||
/*
|
||||
* Copyright 2008 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
||||
* CA 95054 USA or visit www.sun.com if you need additional information or
|
||||
* have any questions.
|
||||
*/
|
||||
package pkg;
|
||||
|
||||
import static pkg.B.b;
|
||||
|
||||
class A {
|
||||
public static void main(String[] args) {
|
||||
b();
|
||||
}
|
||||
}
|
||||
29
langtools/test/tools/javac/staticImport/6665223/pkg/B.java
Normal file
29
langtools/test/tools/javac/staticImport/6665223/pkg/B.java
Normal file
@ -0,0 +1,29 @@
|
||||
/*
|
||||
* Copyright 2008 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
||||
* CA 95054 USA or visit www.sun.com if you need additional information or
|
||||
* have any questions.
|
||||
*/
|
||||
package pkg;
|
||||
|
||||
class B extends B2 {}
|
||||
|
||||
abstract class B2 {
|
||||
protected static void b() {}
|
||||
}
|
||||
@ -225,7 +225,10 @@ COMMON_BUILD_ARGUMENTS = \
|
||||
JDK_MKTG_VERSION=$(JDK_MKTG_VERSION) \
|
||||
JDK_MAJOR_VERSION=$(JDK_MAJOR_VERSION) \
|
||||
JDK_MINOR_VERSION=$(JDK_MINOR_VERSION) \
|
||||
JDK_MICRO_VERSION=$(JDK_MICRO_VERSION)
|
||||
JDK_MICRO_VERSION=$(JDK_MICRO_VERSION) \
|
||||
PREVIOUS_MAJOR_VERSION=$(PREVIOUS_MAJOR_VERSION) \
|
||||
PREVIOUS_MINOR_VERSION=$(PREVIOUS_MINOR_VERSION) \
|
||||
PREVIOUS_MICRO_VERSION=$(PREVIOUS_MICRO_VERSION)
|
||||
|
||||
ifdef ARCH_DATA_MODEL
|
||||
COMMON_BUILD_ARGUMENTS += ARCH_DATA_MODEL=$(ARCH_DATA_MODEL)
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user