--- a/.hgtags-top-repo Sun Jun 28 16:38:22 2015 -0700
+++ b/.hgtags-top-repo Wed Jul 05 20:39:17 2017 +0200
@@ -312,3 +312,4 @@
f546760134eb861fcfecd4ce611b0040b0d25a6a jdk9-b67
70e4272790b6199e9ca89df2758ff9cb58ec4125 jdk9-b68
1bcfd6b8726582cff5a42dbfc75903e36f9dd4fe jdk9-b69
+eed77fcd77711fcdba05f18fc22f37d86efb243c jdk9-b70
--- a/hotspot/.hgtags Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/.hgtags Wed Jul 05 20:39:17 2017 +0200
@@ -472,3 +472,4 @@
d47dfabd16d48eb96a451edd1b61194a39ee0eb5 jdk9-b67
11af3990d56c97b40318bc1f20608e86f051a3f7 jdk9-b68
ff0929a59ced0e144201aa05819ae2e47d6f2c61 jdk9-b69
+8672e9264db30c21504063932dbc374eabc287a1 jdk9-b70
--- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/runtime/VM.java Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/runtime/VM.java Wed Jul 05 20:39:17 2017 +0200
@@ -121,6 +121,8 @@
private Flag[] commandLineFlags;
private Map flagsMap;
+ private static Type intType;
+ private static Type uintType;
private static Type intxType;
private static Type uintxType;
private static Type sizetType;
@@ -170,6 +172,28 @@
return addr.getCIntegerAt(0, boolType.getSize(), boolType.isUnsigned()) != 0;
}
+ public boolean isInt() {
+ return type.equals("int");
+ }
+
+ public long getInt() {
+ if (Assert.ASSERTS_ENABLED) {
+ Assert.that(isInt(), "not an int flag!");
+ }
+ return addr.getCIntegerAt(0, intType.getSize(), false);
+ }
+
+ public boolean isUInt() {
+ return type.equals("uint");
+ }
+
+ public long getUInt() {
+ if (Assert.ASSERTS_ENABLED) {
+ Assert.that(isUInt(), "not a uint flag!");
+ }
+ return addr.getCIntegerAt(0, uintType.getSize(), false);
+ }
+
public boolean isIntx() {
return type.equals("intx");
}
@@ -206,6 +230,10 @@
public String getValue() {
if (isBool()) {
return new Boolean(getBool()).toString();
+ } else if (isInt()) {
+ return new Long(getInt()).toString();
+ } else if (isUInt()) {
+ return new Long(getUInt()).toString();
} else if (isIntx()) {
return new Long(getIntx()).toString();
} else if (isUIntx()) {
@@ -334,6 +362,8 @@
heapWordSize = db.lookupIntConstant("HeapWordSize").intValue();
oopSize = db.lookupIntConstant("oopSize").intValue();
+ intType = db.lookupType("int");
+ uintType = db.lookupType("uint");
intxType = db.lookupType("intx");
uintxType = db.lookupType("uintx");
sizetType = db.lookupType("size_t");
--- a/hotspot/src/cpu/aarch64/vm/aarch64.ad Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/cpu/aarch64/vm/aarch64.ad Wed Jul 05 20:39:17 2017 +0200
@@ -13276,7 +13276,7 @@
ins_cost(INSN_COST);
format %{ "movi $dst, $con\t# vector(16B)" %}
ins_encode %{
- __ mov(as_FloatRegister($dst$$reg), __ T16B, $con$$constant);
+ __ mov(as_FloatRegister($dst$$reg), __ T16B, $con$$constant & 0xff);
%}
ins_pipe(pipe_class_default);
%}
@@ -13298,7 +13298,7 @@
ins_cost(INSN_COST);
format %{ "movi $dst, $con\t# vector(8H)" %}
ins_encode %{
- __ mov(as_FloatRegister($dst$$reg), __ T8H, $con$$constant);
+ __ mov(as_FloatRegister($dst$$reg), __ T8H, $con$$constant & 0xffff);
%}
ins_pipe(pipe_class_default);
%}
--- a/hotspot/src/cpu/aarch64/vm/assembler_aarch64.hpp Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/cpu/aarch64/vm/assembler_aarch64.hpp Wed Jul 05 20:39:17 2017 +0200
@@ -491,6 +491,11 @@
i->rf(_index, 16);
i->f(_ext.option(), 15, 13);
unsigned size = i->get(31, 30);
+ if (i->get(26, 26) && i->get(23, 23)) {
+ // SIMD Q Type - Size = 128 bits
+ assert(size == 0, "bad size");
+ size = 0b100;
+ }
if (size == 0) // It's a byte
i->f(_ext.shift() >= 0, 12);
else {
--- a/hotspot/src/cpu/aarch64/vm/macroAssembler_aarch64.cpp Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/cpu/aarch64/vm/macroAssembler_aarch64.cpp Wed Jul 05 20:39:17 2017 +0200
@@ -1408,6 +1408,52 @@
movk(r, imm64 & 0xffff, 32);
}
+// Macro to mov replicated immediate to vector register.
+// Vd will get the following values for different arrangements in T
+// imm32 == hex 000000gh T8B: Vd = ghghghghghghghgh
+// imm32 == hex 000000gh T16B: Vd = ghghghghghghghghghghghghghghghgh
+// imm32 == hex 0000efgh T4H: Vd = efghefghefghefgh
+// imm32 == hex 0000efgh T8H: Vd = efghefghefghefghefghefghefghefgh
+// imm32 == hex abcdefgh T2S: Vd = abcdefghabcdefgh
+// imm32 == hex abcdefgh T4S: Vd = abcdefghabcdefghabcdefghabcdefgh
+// T1D/T2D: invalid
+void MacroAssembler::mov(FloatRegister Vd, SIMD_Arrangement T, u_int32_t imm32) {
+ assert(T != T1D && T != T2D, "invalid arrangement");
+ if (T == T8B || T == T16B) {
+ assert((imm32 & ~0xff) == 0, "extraneous bits in unsigned imm32 (T8B/T16B)");
+ movi(Vd, T, imm32 & 0xff, 0);
+ return;
+ }
+ u_int32_t nimm32 = ~imm32;
+ if (T == T4H || T == T8H) {
+ assert((imm32 & ~0xffff) == 0, "extraneous bits in unsigned imm32 (T4H/T8H)");
+ imm32 &= 0xffff;
+ nimm32 &= 0xffff;
+ }
+ u_int32_t x = imm32;
+ int movi_cnt = 0;
+ int movn_cnt = 0;
+ while (x) { if (x & 0xff) movi_cnt++; x >>= 8; }
+ x = nimm32;
+ while (x) { if (x & 0xff) movn_cnt++; x >>= 8; }
+ if (movn_cnt < movi_cnt) imm32 = nimm32;
+ unsigned lsl = 0;
+ while (imm32 && (imm32 & 0xff) == 0) { lsl += 8; imm32 >>= 8; }
+ if (movn_cnt < movi_cnt)
+ mvni(Vd, T, imm32 & 0xff, lsl);
+ else
+ movi(Vd, T, imm32 & 0xff, lsl);
+ imm32 >>= 8; lsl += 8;
+ while (imm32) {
+ while ((imm32 & 0xff) == 0) { lsl += 8; imm32 >>= 8; }
+ if (movn_cnt < movi_cnt)
+ bici(Vd, T, imm32 & 0xff, lsl);
+ else
+ orri(Vd, T, imm32 & 0xff, lsl);
+ lsl += 8; imm32 >>= 8;
+ }
+}
+
void MacroAssembler::mov_immediate64(Register dst, u_int64_t imm64)
{
#ifndef PRODUCT
--- a/hotspot/src/cpu/aarch64/vm/macroAssembler_aarch64.hpp Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/cpu/aarch64/vm/macroAssembler_aarch64.hpp Wed Jul 05 20:39:17 2017 +0200
@@ -465,44 +465,7 @@
void movptr(Register r, uintptr_t imm64);
- // Macro to mov replicated immediate to vector register.
- // Where imm32 == hex abcdefgh, Vd will get the following values
- // for different arrangements in T
- // T8B: Vd = ghghghghghghghgh
- // T16B: Vd = ghghghghghghghghghghghghghghghgh
- // T4H: Vd = efghefghefghefgh
- // T8H: Vd = efghefghefghefghefghefghefghefgh
- // T2S: Vd = abcdefghabcdefgh
- // T4S: Vd = abcdefghabcdefghabcdefghabcdefgh
- // T1D/T2D: invalid
- void mov(FloatRegister Vd, SIMD_Arrangement T, u_int32_t imm32) {
- assert(T != T1D && T != T2D, "invalid arrangement");
- u_int32_t nimm32 = ~imm32;
- if (T == T8B || T == T16B) { imm32 &= 0xff; nimm32 &= 0xff; }
- if (T == T4H || T == T8H) { imm32 &= 0xffff; nimm32 &= 0xffff; }
- u_int32_t x = imm32;
- int movi_cnt = 0;
- int movn_cnt = 0;
- while (x) { if (x & 0xff) movi_cnt++; x >>= 8; }
- x = nimm32;
- while (x) { if (x & 0xff) movn_cnt++; x >>= 8; }
- if (movn_cnt < movi_cnt) imm32 = nimm32;
- unsigned lsl = 0;
- while (imm32 && (imm32 & 0xff) == 0) { lsl += 8; imm32 >>= 8; }
- if (movn_cnt < movi_cnt)
- mvni(Vd, T, imm32 & 0xff, lsl);
- else
- movi(Vd, T, imm32 & 0xff, lsl);
- imm32 >>= 8; lsl += 8;
- while (imm32) {
- while ((imm32 & 0xff) == 0) { lsl += 8; imm32 >>= 8; }
- if (movn_cnt < movi_cnt)
- bici(Vd, T, imm32 & 0xff, lsl);
- else
- orri(Vd, T, imm32 & 0xff, lsl);
- lsl += 8; imm32 >>= 8;
- }
- }
+ void mov(FloatRegister Vd, SIMD_Arrangement T, u_int32_t imm32);
// macro instructions for accessing and updating floating point
// status register
--- a/hotspot/src/cpu/aarch64/vm/vm_version_aarch64.cpp Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/cpu/aarch64/vm/vm_version_aarch64.cpp Wed Jul 05 20:39:17 2017 +0200
@@ -228,6 +228,9 @@
warning("SHA512 instruction (for SHA-384 and SHA-512) is not available on this CPU.");
FLAG_SET_DEFAULT(UseSHA512Intrinsics, false);
}
+ if (!(UseSHA1Intrinsics || UseSHA256Intrinsics || UseSHA512Intrinsics)) {
+ FLAG_SET_DEFAULT(UseSHA, false);
+ }
}
// This machine allows unaligned memory accesses
--- a/hotspot/src/share/vm/ci/ciMethod.cpp Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/share/vm/ci/ciMethod.cpp Wed Jul 05 20:39:17 2017 +0200
@@ -71,8 +71,7 @@
// Loaded method.
ciMethod::ciMethod(methodHandle h_m, ciInstanceKlass* holder) :
ciMetadata(h_m()),
- _holder(holder),
- _has_injected_profile(false)
+ _holder(holder)
{
assert(h_m() != NULL, "no null method");
@@ -170,8 +169,7 @@
_liveness( NULL),
_can_be_statically_bound(false),
_method_blocks( NULL),
- _method_data( NULL),
- _has_injected_profile( false)
+ _method_data( NULL)
#if defined(COMPILER2) || defined(SHARK)
,
_flow( NULL),
--- a/hotspot/src/share/vm/ci/ciMethod.hpp Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/share/vm/ci/ciMethod.hpp Wed Jul 05 20:39:17 2017 +0200
@@ -81,7 +81,6 @@
bool _is_c1_compilable;
bool _is_c2_compilable;
bool _can_be_statically_bound;
- bool _has_injected_profile;
// Lazy fields, filled in on demand
address _code;
@@ -179,9 +178,9 @@
// Code size for inlining decisions.
int code_size_for_inlining();
- bool caller_sensitive() { return get_Method()->caller_sensitive(); }
- bool force_inline() { return get_Method()->force_inline(); }
- bool dont_inline() { return get_Method()->dont_inline(); }
+ bool caller_sensitive() const { return get_Method()->caller_sensitive(); }
+ bool force_inline() const { return get_Method()->force_inline(); }
+ bool dont_inline() const { return get_Method()->dont_inline(); }
int comp_level();
int highest_osr_comp_level();
@@ -289,9 +288,6 @@
int instructions_size();
int scale_count(int count, float prof_factor = 1.); // make MDO count commensurate with IIC
- bool has_injected_profile() const { return _has_injected_profile; }
- void set_injected_profile(bool x) { _has_injected_profile = x; }
-
// Stack walking support
bool is_ignored_by_security_stack_walk() const;
--- a/hotspot/src/share/vm/classfile/classFileParser.cpp Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/share/vm/classfile/classFileParser.cpp Wed Jul 05 20:39:17 2017 +0200
@@ -1742,6 +1742,10 @@
if (_location != _in_method) break; // only allow for methods
if (!privileged) break; // only allow in privileged code
return _method_DontInline;
+ case vmSymbols::VM_SYMBOL_ENUM_NAME(java_lang_invoke_InjectedProfile_signature):
+ if (_location != _in_method) break; // only allow for methods
+ if (!privileged) break; // only allow in privileged code
+ return _method_InjectedProfile;
case vmSymbols::VM_SYMBOL_ENUM_NAME(java_lang_invoke_LambdaForm_Compiled_signature):
if (_location != _in_method) break; // only allow for methods
if (!privileged) break; // only allow in privileged code
@@ -1783,6 +1787,8 @@
m->set_force_inline(true);
if (has_annotation(_method_DontInline))
m->set_dont_inline(true);
+ if (has_annotation(_method_InjectedProfile))
+ m->set_has_injected_profile(true);
if (has_annotation(_method_LambdaForm_Compiled) && m->intrinsic_id() == vmIntrinsics::_none)
m->set_intrinsic_id(vmIntrinsics::_compiledLambdaForm);
if (has_annotation(_method_LambdaForm_Hidden))
--- a/hotspot/src/share/vm/classfile/classFileParser.hpp Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/share/vm/classfile/classFileParser.hpp Wed Jul 05 20:39:17 2017 +0200
@@ -127,6 +127,7 @@
_method_CallerSensitive,
_method_ForceInline,
_method_DontInline,
+ _method_InjectedProfile,
_method_LambdaForm_Compiled,
_method_LambdaForm_Hidden,
_sun_misc_Contended,
--- a/hotspot/src/share/vm/classfile/vmSymbols.hpp Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/share/vm/classfile/vmSymbols.hpp Wed Jul 05 20:39:17 2017 +0200
@@ -278,6 +278,7 @@
template(java_lang_invoke_LambdaForm, "java/lang/invoke/LambdaForm") \
template(java_lang_invoke_ForceInline_signature, "Ljava/lang/invoke/ForceInline;") \
template(java_lang_invoke_DontInline_signature, "Ljava/lang/invoke/DontInline;") \
+ template(java_lang_invoke_InjectedProfile_signature, "Ljava/lang/invoke/InjectedProfile;") \
template(java_lang_invoke_Stable_signature, "Ljava/lang/invoke/Stable;") \
template(java_lang_invoke_LambdaForm_Compiled_signature, "Ljava/lang/invoke/LambdaForm$Compiled;") \
template(java_lang_invoke_LambdaForm_Hidden_signature, "Ljava/lang/invoke/LambdaForm$Hidden;") \
--- a/hotspot/src/share/vm/gc/parallel/psMarkSweep.cpp Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/share/vm/gc/parallel/psMarkSweep.cpp Wed Jul 05 20:39:17 2017 +0200
@@ -96,7 +96,7 @@
heap->collector_policy()->should_clear_all_soft_refs();
uint count = maximum_heap_compaction ? 1 : MarkSweepAlwaysCompactCount;
- UIntFlagSetting flag_setting(MarkSweepAlwaysCompactCount, count);
+ UIntXFlagSetting flag_setting(MarkSweepAlwaysCompactCount, count);
PSMarkSweep::invoke_no_policy(clear_all_soft_refs || maximum_heap_compaction);
}
--- a/hotspot/src/share/vm/gc/shared/collectorPolicy.cpp Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/share/vm/gc/shared/collectorPolicy.cpp Wed Jul 05 20:39:17 2017 +0200
@@ -785,7 +785,7 @@
// free memory should be here, especially if they are expensive. If this
// attempt fails, an OOM exception will be thrown.
{
- UIntFlagSetting flag_change(MarkSweepAlwaysCompactCount, 1); // Make sure the heap is fully compacted
+ UIntXFlagSetting flag_change(MarkSweepAlwaysCompactCount, 1); // Make sure the heap is fully compacted
gch->do_collection(true /* full */,
true /* clear_all_soft_refs */,
--- a/hotspot/src/share/vm/oops/method.cpp Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/share/vm/oops/method.cpp Wed Jul 05 20:39:17 2017 +0200
@@ -93,6 +93,7 @@
set_force_inline(false);
set_hidden(false);
set_dont_inline(false);
+ set_has_injected_profile(false);
set_method_data(NULL);
clear_method_counters();
set_vtable_index(Method::garbage_vtable_index);
--- a/hotspot/src/share/vm/oops/method.hpp Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/share/vm/oops/method.hpp Wed Jul 05 20:39:17 2017 +0200
@@ -76,12 +76,13 @@
// Flags
enum Flags {
- _jfr_towrite = 1 << 0,
- _caller_sensitive = 1 << 1,
- _force_inline = 1 << 2,
- _dont_inline = 1 << 3,
- _hidden = 1 << 4,
- _running_emcp = 1 << 5
+ _jfr_towrite = 1 << 0,
+ _caller_sensitive = 1 << 1,
+ _force_inline = 1 << 2,
+ _dont_inline = 1 << 3,
+ _hidden = 1 << 4,
+ _has_injected_profile = 1 << 5,
+ _running_emcp = 1 << 6
};
u1 _flags;
@@ -814,6 +815,13 @@
_flags = x ? (_flags | _hidden) : (_flags & ~_hidden);
}
+ bool has_injected_profile() {
+ return (_flags & _has_injected_profile) != 0;
+ }
+ void set_has_injected_profile(bool x) {
+ _flags = x ? (_flags | _has_injected_profile) : (_flags & ~_has_injected_profile);
+ }
+
ConstMethod::MethodType method_type() const {
return _constMethod->method_type();
}
--- a/hotspot/src/share/vm/opto/arraycopynode.cpp Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/share/vm/opto/arraycopynode.cpp Wed Jul 05 20:39:17 2017 +0200
@@ -438,11 +438,17 @@
// replace fallthrough projections of the ArrayCopyNode by the
// new memory, control and the input IO.
CallProjections callprojs;
- extract_projections(&callprojs, true);
+ extract_projections(&callprojs, true, false);
- igvn->replace_node(callprojs.fallthrough_ioproj, in(TypeFunc::I_O));
- igvn->replace_node(callprojs.fallthrough_memproj, mem);
- igvn->replace_node(callprojs.fallthrough_catchproj, ctl);
+ if (callprojs.fallthrough_ioproj != NULL) {
+ igvn->replace_node(callprojs.fallthrough_ioproj, in(TypeFunc::I_O));
+ }
+ if (callprojs.fallthrough_memproj != NULL) {
+ igvn->replace_node(callprojs.fallthrough_memproj, mem);
+ }
+ if (callprojs.fallthrough_catchproj != NULL) {
+ igvn->replace_node(callprojs.fallthrough_catchproj, ctl);
+ }
// The ArrayCopyNode is not disconnected. It still has the
// projections for the exception case. Replace current
--- a/hotspot/src/share/vm/opto/callnode.cpp Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/share/vm/opto/callnode.cpp Wed Jul 05 20:39:17 2017 +0200
@@ -724,6 +724,26 @@
//
bool CallNode::may_modify(const TypeOopPtr *t_oop, PhaseTransform *phase) {
assert((t_oop != NULL), "sanity");
+ if (is_call_to_arraycopystub()) {
+ const TypeTuple* args = _tf->domain();
+ Node* dest = NULL;
+ // Stubs that can be called once an ArrayCopyNode is expanded have
+ // different signatures. Look for the second pointer argument,
+ // that is the destination of the copy.
+ for (uint i = TypeFunc::Parms, j = 0; i < args->cnt(); i++) {
+ if (args->field_at(i)->isa_ptr()) {
+ j++;
+ if (j == 2) {
+ dest = in(i);
+ break;
+ }
+ }
+ }
+ if (!dest->is_top() && may_modify_arraycopy_helper(phase->type(dest)->is_oopptr(), t_oop, phase)) {
+ return true;
+ }
+ return false;
+ }
if (t_oop->is_known_instance()) {
// The instance_id is set only for scalar-replaceable allocations which
// are not passed as arguments according to Escape Analysis.
@@ -810,7 +830,7 @@
}
-void CallNode::extract_projections(CallProjections* projs, bool separate_io_proj) {
+void CallNode::extract_projections(CallProjections* projs, bool separate_io_proj, bool do_asserts) {
projs->fallthrough_proj = NULL;
projs->fallthrough_catchproj = NULL;
projs->fallthrough_ioproj = NULL;
@@ -873,17 +893,18 @@
}
}
- // The resproj may not exist because the result couuld be ignored
+ // The resproj may not exist because the result could be ignored
// and the exception object may not exist if an exception handler
// swallows the exception but all the other must exist and be found.
assert(projs->fallthrough_proj != NULL, "must be found");
- assert(Compile::current()->inlining_incrementally() || projs->fallthrough_catchproj != NULL, "must be found");
- assert(Compile::current()->inlining_incrementally() || projs->fallthrough_memproj != NULL, "must be found");
- assert(Compile::current()->inlining_incrementally() || projs->fallthrough_ioproj != NULL, "must be found");
- assert(Compile::current()->inlining_incrementally() || projs->catchall_catchproj != NULL, "must be found");
+ do_asserts = do_asserts && !Compile::current()->inlining_incrementally();
+ assert(!do_asserts || projs->fallthrough_catchproj != NULL, "must be found");
+ assert(!do_asserts || projs->fallthrough_memproj != NULL, "must be found");
+ assert(!do_asserts || projs->fallthrough_ioproj != NULL, "must be found");
+ assert(!do_asserts || projs->catchall_catchproj != NULL, "must be found");
if (separate_io_proj) {
- assert(Compile::current()->inlining_incrementally() || projs->catchall_memproj != NULL, "must be found");
- assert(Compile::current()->inlining_incrementally() || projs->catchall_ioproj != NULL, "must be found");
+ assert(!do_asserts || projs->catchall_memproj != NULL, "must be found");
+ assert(!do_asserts || projs->catchall_ioproj != NULL, "must be found");
}
}
@@ -909,6 +930,12 @@
return SafePointNode::Ideal(phase, can_reshape);
}
+bool CallNode::is_call_to_arraycopystub() const {
+ if (_name != NULL && strstr(_name, "arraycopy") != 0) {
+ return true;
+ }
+ return false;
+}
//=============================================================================
uint CallJavaNode::size_of() const { return sizeof(*this); }
@@ -1007,14 +1034,6 @@
//=============================================================================
-bool CallLeafNode::is_call_to_arraycopystub() const {
- if (_name != NULL && strstr(_name, "arraycopy") != 0) {
- return true;
- }
- return false;
-}
-
-
#ifndef PRODUCT
void CallLeafNode::dump_spec(outputStream *st) const {
st->print("# ");
@@ -1930,26 +1949,3 @@
return true;
}
-bool CallLeafNode::may_modify(const TypeOopPtr *t_oop, PhaseTransform *phase) {
- if (is_call_to_arraycopystub()) {
- const TypeTuple* args = _tf->domain();
- Node* dest = NULL;
- // Stubs that can be called once an ArrayCopyNode is expanded have
- // different signatures. Look for the second pointer argument,
- // that is the destination of the copy.
- for (uint i = TypeFunc::Parms, j = 0; i < args->cnt(); i++) {
- if (args->field_at(i)->isa_ptr()) {
- j++;
- if (j == 2) {
- dest = in(i);
- break;
- }
- }
- }
- if (!dest->is_top() && may_modify_arraycopy_helper(phase->type(dest)->is_oopptr(), t_oop, phase)) {
- return true;
- }
- return false;
- }
- return CallNode::may_modify(t_oop, phase);
-}
--- a/hotspot/src/share/vm/opto/callnode.hpp Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/share/vm/opto/callnode.hpp Wed Jul 05 20:39:17 2017 +0200
@@ -565,13 +565,15 @@
address _entry_point; // Address of method being called
float _cnt; // Estimate of number of times called
CallGenerator* _generator; // corresponding CallGenerator for some late inline calls
+ const char *_name; // Printable name, if _method is NULL
CallNode(const TypeFunc* tf, address addr, const TypePtr* adr_type)
: SafePointNode(tf->domain()->cnt(), NULL, adr_type),
_tf(tf),
_entry_point(addr),
_cnt(COUNT_UNKNOWN),
- _generator(NULL)
+ _generator(NULL),
+ _name(NULL)
{
init_class_id(Class_Call);
}
@@ -626,10 +628,12 @@
// Collect all the interesting edges from a call for use in
// replacing the call by something else. Used by macro expansion
// and the late inlining support.
- void extract_projections(CallProjections* projs, bool separate_io_proj);
+ void extract_projections(CallProjections* projs, bool separate_io_proj, bool do_asserts = true);
virtual uint match_edge(uint idx) const;
+ bool is_call_to_arraycopystub() const;
+
#ifndef PRODUCT
virtual void dump_req(outputStream *st = tty) const;
virtual void dump_spec(outputStream *st) const;
@@ -683,7 +687,7 @@
virtual uint size_of() const; // Size is bigger
public:
CallStaticJavaNode(Compile* C, const TypeFunc* tf, address addr, ciMethod* method, int bci)
- : CallJavaNode(tf, addr, method, bci), _name(NULL) {
+ : CallJavaNode(tf, addr, method, bci) {
init_class_id(Class_CallStaticJava);
if (C->eliminate_boxing() && (method != NULL) && method->is_boxing_method()) {
init_flags(Flag_is_macro);
@@ -694,14 +698,14 @@
}
CallStaticJavaNode(const TypeFunc* tf, address addr, const char* name, int bci,
const TypePtr* adr_type)
- : CallJavaNode(tf, addr, NULL, bci), _name(name) {
+ : CallJavaNode(tf, addr, NULL, bci) {
init_class_id(Class_CallStaticJava);
// This node calls a runtime stub, which often has narrow memory effects.
_adr_type = adr_type;
_is_scalar_replaceable = false;
_is_non_escaping = false;
+ _name = name;
}
- const char *_name; // Runtime wrapper name
// Result of Escape Analysis
bool _is_scalar_replaceable;
@@ -754,13 +758,12 @@
public:
CallRuntimeNode(const TypeFunc* tf, address addr, const char* name,
const TypePtr* adr_type)
- : CallNode(tf, addr, adr_type),
- _name(name)
+ : CallNode(tf, addr, adr_type)
{
init_class_id(Class_CallRuntime);
+ _name = name;
}
- const char *_name; // Printable name, if _method is NULL
virtual int Opcode() const;
virtual void calling_convention( BasicType* sig_bt, VMRegPair *parm_regs, uint argcnt ) const;
@@ -785,8 +788,6 @@
#ifndef PRODUCT
virtual void dump_spec(outputStream *st) const;
#endif
- bool is_call_to_arraycopystub() const;
- virtual bool may_modify(const TypeOopPtr *t_oop, PhaseTransform *phase);
};
//------------------------------CallLeafNoFPNode-------------------------------
--- a/hotspot/src/share/vm/opto/compile.cpp Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/share/vm/opto/compile.cpp Wed Jul 05 20:39:17 2017 +0200
@@ -3390,9 +3390,6 @@
bool Compile::too_many_traps(ciMethod* method,
int bci,
Deoptimization::DeoptReason reason) {
- if (method->has_injected_profile()) {
- return false;
- }
ciMethodData* md = method->method_data();
if (md->is_empty()) {
// Assume the trap has not occurred, or that it occurred only
@@ -3442,9 +3439,6 @@
bool Compile::too_many_recompiles(ciMethod* method,
int bci,
Deoptimization::DeoptReason reason) {
- if (method->has_injected_profile()) {
- return false;
- }
ciMethodData* md = method->method_data();
if (md->is_empty()) {
// Assume the trap has not occurred, or that it occurred only
--- a/hotspot/src/share/vm/opto/library_call.cpp Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/share/vm/opto/library_call.cpp Wed Jul 05 20:39:17 2017 +0200
@@ -6125,8 +6125,6 @@
jint false_cnt = aobj->element_value(0).as_int();
jint true_cnt = aobj->element_value(1).as_int();
- method()->set_injected_profile(true);
-
if (C->log() != NULL) {
C->log()->elem("observe source='profileBoolean' false='%d' true='%d'",
false_cnt, true_cnt);
--- a/hotspot/src/share/vm/opto/memnode.cpp Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/share/vm/opto/memnode.cpp Wed Jul 05 20:39:17 2017 +0200
@@ -108,11 +108,10 @@
#endif
-static bool membar_for_arraycopy_helper(const TypeOopPtr *t_oop, MergeMemNode* mm, PhaseTransform *phase) {
- if (mm->memory_at(Compile::AliasIdxRaw)->is_Proj()) {
- Node* n = mm->memory_at(Compile::AliasIdxRaw)->in(0);
- if ((n->is_ArrayCopy() && n->as_ArrayCopy()->may_modify(t_oop, phase)) ||
- (n->is_CallLeaf() && n->as_CallLeaf()->may_modify(t_oop, phase))) {
+static bool membar_for_arraycopy_helper(const TypeOopPtr *t_oop, Node* n, PhaseTransform *phase) {
+ if (n->is_Proj()) {
+ n = n->in(0);
+ if (n->is_Call() && n->as_Call()->may_modify(t_oop, phase)) {
return true;
}
}
@@ -121,16 +120,22 @@
static bool membar_for_arraycopy(const TypeOopPtr *t_oop, MemBarNode* mb, PhaseTransform *phase) {
Node* mem = mb->in(TypeFunc::Memory);
+
if (mem->is_MergeMem()) {
- return membar_for_arraycopy_helper(t_oop, mem->as_MergeMem(), phase);
- } else if (mem->is_Phi()) {
- // after macro expansion of an ArrayCopyNode we may have a Phi
- for (uint i = 1; i < mem->req(); i++) {
- if (mem->in(i) != NULL && mem->in(i)->is_MergeMem() && membar_for_arraycopy_helper(t_oop, mem->in(i)->as_MergeMem(), phase)) {
- return true;
+ Node* n = mem->as_MergeMem()->memory_at(Compile::AliasIdxRaw);
+ if (membar_for_arraycopy_helper(t_oop, n, phase)) {
+ return true;
+ } else if (n->is_Phi()) {
+ for (uint i = 1; i < n->req(); i++) {
+ if (n->in(i) != NULL) {
+ if (membar_for_arraycopy_helper(t_oop, n->in(i), phase)) {
+ return true;
+ }
+ }
}
}
}
+
return false;
}
--- a/hotspot/src/share/vm/prims/jvmtiRedefineClasses.cpp Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/share/vm/prims/jvmtiRedefineClasses.cpp Wed Jul 05 20:39:17 2017 +0200
@@ -43,6 +43,7 @@
#include "runtime/deoptimization.hpp"
#include "runtime/relocator.hpp"
#include "utilities/bitMap.inline.hpp"
+#include "utilities/events.hpp"
PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
@@ -174,6 +175,9 @@
// Free os::malloc allocated memory.
os::free(_scratch_classes);
+ // Reset the_class_oop to null for error printing.
+ _the_class_oop = NULL;
+
if (RC_TRACE_ENABLED(0x00000004)) {
// Used to have separate timers for "doit" and "all", but the timer
// overhead skewed the measurements.
@@ -4105,6 +4109,13 @@
java_lang_Class::classRedefinedCount(the_class_mirror),
os::available_memory() >> 10));
+ {
+ ResourceMark rm(THREAD);
+ Events::log_redefinition(THREAD, "redefined class name=%s, count=%d",
+ the_class->external_name(),
+ java_lang_Class::classRedefinedCount(the_class_mirror));
+
+ }
RC_TIMER_STOP(_timer_rsc_phase2);
} // end redefine_single_class()
@@ -4249,3 +4260,11 @@
tty->cr();
}
}
+
+void VM_RedefineClasses::print_on_error(outputStream* st) const {
+ VM_Operation::print_on_error(st);
+ if (_the_class_oop != NULL) {
+ ResourceMark rm;
+ st->print_cr(", redefining class %s", _the_class_oop->external_name());
+ }
+}
--- a/hotspot/src/share/vm/prims/jvmtiRedefineClasses.hpp Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/share/vm/prims/jvmtiRedefineClasses.hpp Wed Jul 05 20:39:17 2017 +0200
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2003, 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -539,5 +539,8 @@
static unsigned char * get_cached_class_file_bytes(JvmtiCachedClassFileData *cache) {
return cache == NULL ? NULL : cache->data;
}
+
+ // Error printing
+ void print_on_error(outputStream* st) const;
};
#endif // SHARE_VM_PRIMS_JVMTIREDEFINECLASSES_HPP
--- a/hotspot/src/share/vm/prims/whitebox.cpp Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/share/vm/prims/whitebox.cpp Wed Jul 05 20:39:17 2017 +0200
@@ -710,6 +710,24 @@
return NULL;
WB_END
+WB_ENTRY(jobject, WB_GetIntVMFlag(JNIEnv* env, jobject o, jstring name))
+ int result;
+ if (GetVMFlag <int> (thread, env, name, &result, &CommandLineFlags::intAt)) {
+ ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
+ return longBox(thread, env, result);
+ }
+ return NULL;
+WB_END
+
+WB_ENTRY(jobject, WB_GetUintVMFlag(JNIEnv* env, jobject o, jstring name))
+ uint result;
+ if (GetVMFlag <uint> (thread, env, name, &result, &CommandLineFlags::uintAt)) {
+ ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
+ return longBox(thread, env, result);
+ }
+ return NULL;
+WB_END
+
WB_ENTRY(jobject, WB_GetIntxVMFlag(JNIEnv* env, jobject o, jstring name))
intx result;
if (GetVMFlag <intx> (thread, env, name, &result, &CommandLineFlags::intxAt)) {
@@ -771,6 +789,16 @@
SetVMFlag <bool> (thread, env, name, &result, &CommandLineFlags::boolAtPut);
WB_END
+WB_ENTRY(void, WB_SetIntVMFlag(JNIEnv* env, jobject o, jstring name, jlong value))
+ int result = value;
+ SetVMFlag <int> (thread, env, name, &result, &CommandLineFlags::intAtPut);
+WB_END
+
+WB_ENTRY(void, WB_SetUintVMFlag(JNIEnv* env, jobject o, jstring name, jlong value))
+ uint result = value;
+ SetVMFlag <uint> (thread, env, name, &result, &CommandLineFlags::uintAtPut);
+WB_END
+
WB_ENTRY(void, WB_SetIntxVMFlag(JNIEnv* env, jobject o, jstring name, jlong value))
intx result = value;
SetVMFlag <intx> (thread, env, name, &result, &CommandLineFlags::intxAtPut);
@@ -1336,6 +1364,8 @@
{CC"isConstantVMFlag", CC"(Ljava/lang/String;)Z", (void*)&WB_IsConstantVMFlag},
{CC"isLockedVMFlag", CC"(Ljava/lang/String;)Z", (void*)&WB_IsLockedVMFlag},
{CC"setBooleanVMFlag", CC"(Ljava/lang/String;Z)V",(void*)&WB_SetBooleanVMFlag},
+ {CC"setIntVMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetIntVMFlag},
+ {CC"setUintVMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetUintVMFlag},
{CC"setIntxVMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetIntxVMFlag},
{CC"setUintxVMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetUintxVMFlag},
{CC"setUint64VMFlag", CC"(Ljava/lang/String;J)V",(void*)&WB_SetUint64VMFlag},
@@ -1345,6 +1375,10 @@
(void*)&WB_SetStringVMFlag},
{CC"getBooleanVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Boolean;",
(void*)&WB_GetBooleanVMFlag},
+ {CC"getIntVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
+ (void*)&WB_GetIntVMFlag},
+ {CC"getUintVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
+ (void*)&WB_GetUintVMFlag},
{CC"getIntxVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
(void*)&WB_GetIntxVMFlag},
{CC"getUintxVMFlag", CC"(Ljava/lang/String;)Ljava/lang/Long;",
--- a/hotspot/src/share/vm/runtime/arguments.cpp Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/share/vm/runtime/arguments.cpp Wed Jul 05 20:39:17 2017 +0200
@@ -586,11 +586,12 @@
static bool set_numeric_flag(char* name, char* value, Flag::Flags origin) {
julong v;
+ int int_v;
intx intx_v;
bool is_neg = false;
// Check the sign first since atomull() parses only unsigned values.
if (*value == '-') {
- if (!CommandLineFlags::intxAt(name, &intx_v)) {
+ if (!CommandLineFlags::intxAt(name, &intx_v) && !CommandLineFlags::intAt(name, &int_v)) {
return false;
}
value++;
@@ -599,6 +600,17 @@
if (!atomull(value, &v)) {
return false;
}
+ int_v = (int) v;
+ if (is_neg) {
+ int_v = -int_v;
+ }
+ if (CommandLineFlags::intAtPut(name, &int_v, origin)) {
+ return true;
+ }
+ uint uint_v = (uint) v;
+ if (!is_neg && CommandLineFlags::uintAtPut(name, &uint_v, origin)) {
+ return true;
+ }
intx_v = (intx) v;
if (is_neg) {
intx_v = -intx_v;
--- a/hotspot/src/share/vm/runtime/deoptimization.cpp Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/share/vm/runtime/deoptimization.cpp Wed Jul 05 20:39:17 2017 +0200
@@ -1460,7 +1460,11 @@
//
// The other actions cause immediate removal of the present code.
- bool update_trap_state = (reason != Reason_tenured);
+ // Traps caused by injected profile shouldn't pollute trap counts.
+ bool injected_profile_trap = trap_method->has_injected_profile() &&
+ (reason == Reason_intrinsic || reason == Reason_unreached);
+
+ bool update_trap_state = (reason != Reason_tenured) && !injected_profile_trap;
bool make_not_entrant = false;
bool make_not_compilable = false;
bool reprofile = false;
--- a/hotspot/src/share/vm/runtime/globals.cpp Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/share/vm/runtime/globals.cpp Wed Jul 05 20:39:17 2017 +0200
@@ -93,6 +93,32 @@
*((bool*) _addr) = value;
}
+bool Flag::is_int() const {
+ return strcmp(_type, "int") == 0;
+}
+
+int Flag::get_int() const {
+ return *((int*) _addr);
+}
+
+void Flag::set_int(int value) {
+ check_writable();
+ *((int*) _addr) = value;
+}
+
+bool Flag::is_uint() const {
+ return strcmp(_type, "uint") == 0;
+}
+
+uint Flag::get_uint() const {
+ return *((uint*) _addr);
+}
+
+void Flag::set_uint(uint value) {
+ check_writable();
+ *((uint*) _addr) = value;
+}
+
bool Flag::is_intx() const {
return strcmp(_type, "intx") == 0;
}
@@ -316,6 +342,12 @@
if (is_bool()) {
st->print("%-16s", get_bool() ? "true" : "false");
}
+ if (is_int()) {
+ st->print("%-16d", get_int());
+ }
+ if (is_uint()) {
+ st->print("%-16u", get_uint());
+ }
if (is_intx()) {
st->print("%-16ld", get_intx());
}
@@ -411,6 +443,10 @@
void Flag::print_as_flag(outputStream* st) {
if (is_bool()) {
st->print("-XX:%s%s", get_bool() ? "+" : "-", _name);
+ } else if (is_int()) {
+ st->print("-XX:%s=%d", _name, get_int());
+ } else if (is_uint()) {
+ st->print("-XX:%s=%u", _name, get_uint());
} else if (is_intx()) {
st->print("-XX:%s=" INTX_FORMAT, _name, get_intx());
} else if (is_uintx()) {
@@ -663,6 +699,62 @@
faddr->set_origin(origin);
}
+bool CommandLineFlags::intAt(const char* name, size_t len, int* value, bool allow_locked, bool return_flag) {
+ Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
+ if (result == NULL) return false;
+ if (!result->is_int()) return false;
+ *value = result->get_int();
+ return true;
+}
+
+bool CommandLineFlags::intAtPut(const char* name, size_t len, int* value, Flag::Flags origin) {
+ Flag* result = Flag::find_flag(name, len);
+ if (result == NULL) return false;
+ if (!result->is_int()) return false;
+ int old_value = result->get_int();
+ trace_flag_changed<EventIntFlagChanged, s4>(name, old_value, *value, origin);
+ result->set_int(*value);
+ *value = old_value;
+ result->set_origin(origin);
+ return true;
+}
+
+void CommandLineFlagsEx::intAtPut(CommandLineFlagWithType flag, int value, Flag::Flags origin) {
+ Flag* faddr = address_of_flag(flag);
+ guarantee(faddr != NULL && faddr->is_int(), "wrong flag type");
+ trace_flag_changed<EventIntFlagChanged, s4>(faddr->_name, faddr->get_int(), value, origin);
+ faddr->set_int(value);
+ faddr->set_origin(origin);
+}
+
+bool CommandLineFlags::uintAt(const char* name, size_t len, uint* value, bool allow_locked, bool return_flag) {
+ Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
+ if (result == NULL) return false;
+ if (!result->is_uint()) return false;
+ *value = result->get_uint();
+ return true;
+}
+
+bool CommandLineFlags::uintAtPut(const char* name, size_t len, uint* value, Flag::Flags origin) {
+ Flag* result = Flag::find_flag(name, len);
+ if (result == NULL) return false;
+ if (!result->is_uint()) return false;
+ uint old_value = result->get_uint();
+ trace_flag_changed<EventUnsignedIntFlagChanged, u4>(name, old_value, *value, origin);
+ result->set_uint(*value);
+ *value = old_value;
+ result->set_origin(origin);
+ return true;
+}
+
+void CommandLineFlagsEx::uintAtPut(CommandLineFlagWithType flag, uint value, Flag::Flags origin) {
+ Flag* faddr = address_of_flag(flag);
+ guarantee(faddr != NULL && faddr->is_uint(), "wrong flag type");
+ trace_flag_changed<EventUnsignedIntFlagChanged, u4>(faddr->_name, faddr->get_uint(), value, origin);
+ faddr->set_uint(value);
+ faddr->set_origin(origin);
+}
+
bool CommandLineFlags::intxAt(const char* name, size_t len, intx* value, bool allow_locked, bool return_flag) {
Flag* result = Flag::find_flag(name, len, allow_locked, return_flag);
if (result == NULL) return false;
--- a/hotspot/src/share/vm/runtime/globals.hpp Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/share/vm/runtime/globals.hpp Wed Jul 05 20:39:17 2017 +0200
@@ -279,6 +279,14 @@
bool get_bool() const;
void set_bool(bool value);
+ bool is_int() const;
+ int get_int() const;
+ void set_int(int value);
+
+ bool is_uint() const;
+ uint get_uint() const;
+ void set_uint(uint value);
+
bool is_intx() const;
intx get_intx() const;
void set_intx(intx value);
@@ -363,13 +371,28 @@
~CounterSetting() { (*counter)--; }
};
+class IntFlagSetting {
+ int val;
+ int* flag;
+ public:
+ IntFlagSetting(int& fl, int newValue) { flag = &fl; val = fl; fl = newValue; }
+ ~IntFlagSetting() { *flag = val; }
+};
class UIntFlagSetting {
+ uint val;
+ uint* flag;
+ public:
+ UIntFlagSetting(uint& fl, uint newValue) { flag = &fl; val = fl; fl = newValue; }
+ ~UIntFlagSetting() { *flag = val; }
+};
+
+class UIntXFlagSetting {
uintx val;
uintx* flag;
public:
- UIntFlagSetting(uintx& fl, uintx newValue) { flag = &fl; val = fl; fl = newValue; }
- ~UIntFlagSetting() { *flag = val; }
+ UIntXFlagSetting(uintx& fl, uintx newValue) { flag = &fl; val = fl; fl = newValue; }
+ ~UIntXFlagSetting() { *flag = val; }
};
class DoubleFlagSetting {
@@ -396,6 +419,16 @@
static bool boolAtPut(const char* name, size_t len, bool* value, Flag::Flags origin);
static bool boolAtPut(const char* name, bool* value, Flag::Flags origin) { return boolAtPut(name, strlen(name), value, origin); }
+ static bool intAt(const char* name, size_t len, int* value, bool allow_locked = false, bool return_flag = false);
+ static bool intAt(const char* name, int* value, bool allow_locked = false, bool return_flag = false) { return intAt(name, strlen(name), value, allow_locked, return_flag); }
+ static bool intAtPut(const char* name, size_t len, int* value, Flag::Flags origin);
+ static bool intAtPut(const char* name, int* value, Flag::Flags origin) { return intAtPut(name, strlen(name), value, origin); }
+
+ static bool uintAt(const char* name, size_t len, uint* value, bool allow_locked = false, bool return_flag = false);
+ static bool uintAt(const char* name, uint* value, bool allow_locked = false, bool return_flag = false) { return uintAt(name, strlen(name), value, allow_locked, return_flag); }
+ static bool uintAtPut(const char* name, size_t len, uint* value, Flag::Flags origin);
+ static bool uintAtPut(const char* name, uint* value, Flag::Flags origin) { return uintAtPut(name, strlen(name), value, origin); }
+
static bool intxAt(const char* name, size_t len, intx* value, bool allow_locked = false, bool return_flag = false);
static bool intxAt(const char* name, intx* value, bool allow_locked = false, bool return_flag = false) { return intxAt(name, strlen(name), value, allow_locked, return_flag); }
static bool intxAtPut(const char* name, size_t len, intx* value, Flag::Flags origin);
--- a/hotspot/src/share/vm/runtime/globals_extension.hpp Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/share/vm/runtime/globals_extension.hpp Wed Jul 05 20:39:17 2017 +0200
@@ -197,6 +197,8 @@
class CommandLineFlagsEx : CommandLineFlags {
public:
static void boolAtPut(CommandLineFlagWithType flag, bool value, Flag::Flags origin);
+ static void intAtPut(CommandLineFlagWithType flag, int value, Flag::Flags origin);
+ static void uintAtPut(CommandLineFlagWithType flag, uint value, Flag::Flags origin);
static void intxAtPut(CommandLineFlagWithType flag, intx value, Flag::Flags origin);
static void uintxAtPut(CommandLineFlagWithType flag, uintx value, Flag::Flags origin);
static void uint64_tAtPut(CommandLineFlagWithType flag, uint64_t value, Flag::Flags origin);
--- a/hotspot/src/share/vm/runtime/vm_operations.hpp Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/share/vm/runtime/vm_operations.hpp Wed Jul 05 20:39:17 2017 +0200
@@ -192,7 +192,7 @@
static const char* mode_to_string(Mode mode);
// Debugging
- void print_on_error(outputStream* st) const;
+ virtual void print_on_error(outputStream* st) const;
const char* name() const { return _names[type()]; }
static const char* name(int type) {
assert(type >= 0 && type < VMOp_Terminating, "invalid VM operation type");
--- a/hotspot/src/share/vm/services/management.cpp Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/share/vm/services/management.cpp Wed Jul 05 20:39:17 2017 +0200
@@ -1558,6 +1558,12 @@
if (flag->is_bool()) {
global->value.z = flag->get_bool() ? JNI_TRUE : JNI_FALSE;
global->type = JMM_VMGLOBAL_TYPE_JBOOLEAN;
+ } else if (flag->is_int()) {
+ global->value.j = (jlong)flag->get_int();
+ global->type = JMM_VMGLOBAL_TYPE_JLONG;
+ } else if (flag->is_uint()) {
+ global->value.j = (jlong)flag->get_uint();
+ global->type = JMM_VMGLOBAL_TYPE_JLONG;
} else if (flag->is_intx()) {
global->value.j = (jlong)flag->get_intx();
global->type = JMM_VMGLOBAL_TYPE_JLONG;
--- a/hotspot/src/share/vm/services/writeableFlags.cpp Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/share/vm/services/writeableFlags.cpp Wed Jul 05 20:39:17 2017 +0200
@@ -44,6 +44,36 @@
return CommandLineFlags::boolAtPut((char*)name, &value, origin) ? SUCCESS : ERR_OTHER;
}
+// set a int global flag
+int WriteableFlags::set_int_flag(const char* name, const char* arg, Flag::Flags origin, FormatBuffer<80>& err_msg) {
+ int value;
+
+ if (sscanf(arg, "%d", &value)) {
+ return set_int_flag(name, value, origin, err_msg);
+ }
+ err_msg.print("flag value must be an integer");
+ return WRONG_FORMAT;
+}
+
+int WriteableFlags::set_int_flag(const char* name, int value, Flag::Flags origin, FormatBuffer<80>& err_msg) {
+ return CommandLineFlags::intAtPut((char*)name, &value, origin) ? SUCCESS : ERR_OTHER;
+}
+
+// set a uint global flag
+int WriteableFlags::set_uint_flag(const char* name, const char* arg, Flag::Flags origin, FormatBuffer<80>& err_msg) {
+ uint value;
+
+ if (sscanf(arg, "%u", &value)) {
+ return set_uint_flag(name, value, origin, err_msg);
+ }
+ err_msg.print("flag value must be an unsigned integer");
+ return WRONG_FORMAT;
+}
+
+int WriteableFlags::set_uint_flag(const char* name, uint value, Flag::Flags origin, FormatBuffer<80>& err_msg) {
+ return CommandLineFlags::uintAtPut((char*)name, &value, origin) ? SUCCESS : ERR_OTHER;
+}
+
// set a intx global flag
int WriteableFlags::set_intx_flag(const char* name, const char* arg, Flag::Flags origin, FormatBuffer<80>& err_msg) {
intx value;
@@ -173,6 +203,10 @@
}
if (f->is_bool()) {
return set_bool_flag(f->_name, flag_value, origin, err_msg);
+ } else if (f->is_int()) {
+ return set_int_flag(f->_name, flag_value, origin, err_msg);
+ } else if (f->is_uint()) {
+ return set_uint_flag(f->_name, flag_value, origin, err_msg);
} else if (f->is_intx()) {
return set_intx_flag(f->_name, flag_value, origin, err_msg);
} else if (f->is_uintx()) {
@@ -195,6 +229,12 @@
if (f->is_bool()) {
bool bvalue = (new_value.z == JNI_TRUE ? true : false);
return set_bool_flag(f->_name, bvalue, origin, err_msg);
+ } else if (f->is_int()) {
+ int ivalue = (int)new_value.j;
+ return set_int_flag(f->_name, ivalue, origin, err_msg);
+ } else if (f->is_uint()) {
+ uint uvalue = (uint)new_value.j;
+ return set_uint_flag(f->_name, uvalue, origin, err_msg);
} else if (f->is_intx()) {
intx ivalue = (intx)new_value.j;
return set_intx_flag(f->_name, ivalue, origin, err_msg);
--- a/hotspot/src/share/vm/services/writeableFlags.hpp Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/share/vm/services/writeableFlags.hpp Wed Jul 05 20:39:17 2017 +0200
@@ -56,6 +56,10 @@
// set a boolean global flag
static int set_bool_flag(const char* name, const char* value, Flag::Flags origin, FormatBuffer<80>& err_msg);
+ // set a int global flag
+ static int set_int_flag(const char* name, const char* value, Flag::Flags origin, FormatBuffer<80>& err_msg);
+ // set a uint global flag
+ static int set_uint_flag(const char* name, const char* value, Flag::Flags origin, FormatBuffer<80>& err_msg);
// set a intx global flag
static int set_intx_flag(const char* name, const char* value, Flag::Flags origin, FormatBuffer<80>& err_msg);
// set a uintx global flag
@@ -66,6 +70,10 @@
static int set_size_t_flag(const char* name, const char* value, Flag::Flags origin, FormatBuffer<80>& err_msg);
// set a boolean global flag
static int set_bool_flag(const char* name, bool value, Flag::Flags origin, FormatBuffer<80>& err_msg);
+ // set a int global flag
+ static int set_int_flag(const char* name, int value, Flag::Flags origin, FormatBuffer<80>& err_msg);
+ // set a uint global flag
+ static int set_uint_flag(const char* name, uint value, Flag::Flags origin, FormatBuffer<80>& err_msg);
// set a intx global flag
static int set_intx_flag(const char* name, intx value, Flag::Flags origin, FormatBuffer<80>& err_msg);
// set a uintx global flag
--- a/hotspot/src/share/vm/trace/trace.xml Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/share/vm/trace/trace.xml Wed Jul 05 20:39:17 2017 +0200
@@ -122,6 +122,22 @@
<value type="CLASS" field="definingClassLoader" label="Defining Class Loader"/>
</event>
+ <event id="IntFlagChanged" path="vm/flag/int_changed" label="Int Flag Changed"
+ is_instant="true">
+ <value type="UTF8" field="name" label="Name" />
+ <value type="INTEGER" field="old_value" label="Old Value" />
+ <value type="INTEGER" field="new_value" label="New Value" />
+ <value type="FLAGVALUEORIGIN" field="origin" label="Origin" />
+ </event>
+
+ <event id="UnsignedIntFlagChanged" path="vm/flag/uint_changed" label="Unsigned Int Flag Changed"
+ is_instant="true">
+ <value type="UTF8" field="name" label="Name" />
+ <value type="UINT" field="old_value" label="Old Value" />
+ <value type="UINT" field="new_value" label="New Value" />
+ <value type="FLAGVALUEORIGIN" field="origin" label="Origin" />
+ </event>
+
<event id="LongFlagChanged" path="vm/flag/long_changed" label="Long Flag Changed"
is_instant="true">
<value type="UTF8" field="name" label="Name" />
--- a/hotspot/src/share/vm/utilities/events.cpp Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/share/vm/utilities/events.cpp Wed Jul 05 20:39:17 2017 +0200
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -37,6 +37,7 @@
EventLog* Events::_logs = NULL;
StringEventLog* Events::_messages = NULL;
StringEventLog* Events::_exceptions = NULL;
+StringEventLog* Events::_redefinitions = NULL;
StringEventLog* Events::_deopt_messages = NULL;
EventLog::EventLog() {
@@ -66,6 +67,7 @@
if (LogEvents) {
_messages = new StringEventLog("Events");
_exceptions = new StringEventLog("Internal exceptions");
+ _redefinitions = new StringEventLog("Classes redefined");
_deopt_messages = new StringEventLog("Deoptimization events");
}
}
--- a/hotspot/src/share/vm/utilities/events.hpp Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/src/share/vm/utilities/events.hpp Wed Jul 05 20:39:17 2017 +0200
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -186,6 +186,9 @@
// Deoptization related messages
static StringEventLog* _deopt_messages;
+ // Redefinition related messages
+ static StringEventLog* _redefinitions;
+
public:
static void print_all(outputStream* out);
@@ -198,6 +201,8 @@
// Log exception related message
static void log_exception(Thread* thread, const char* format, ...) ATTRIBUTE_PRINTF(2, 3);
+ static void log_redefinition(Thread* thread, const char* format, ...) ATTRIBUTE_PRINTF(2, 3);
+
static void log_deopt_message(Thread* thread, const char* format, ...) ATTRIBUTE_PRINTF(2, 3);
// Register default loggers
@@ -222,6 +227,15 @@
}
}
+inline void Events::log_redefinition(Thread* thread, const char* format, ...) {
+ if (LogEvents) {
+ va_list ap;
+ va_start(ap, format);
+ _redefinitions->logv(thread, format, ap);
+ va_end(ap);
+ }
+}
+
inline void Events::log_deopt_message(Thread* thread, const char* format, ...) {
if (LogEvents) {
va_list ap;
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/arraycopy/TestLoadBypassArrayCopy.java Wed Jul 05 20:39:17 2017 +0200
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 8086046
+ * @summary load bypasses arraycopy that sets the value after the ArrayCopyNode is expanded
+ * @run main/othervm -XX:-BackgroundCompilation -XX:-UseOnStackReplacement -XX:CompileCommand=dontinline,TestLoadBypassArrayCopy::test_helper -XX:-TieredCompilation TestLoadBypassArrayCopy
+ *
+ */
+
+public class TestLoadBypassArrayCopy {
+
+ static long i;
+ static boolean test_helper() {
+ i++;
+ if ((i%10) == 0) {
+ return false;
+ }
+ return true;
+ }
+
+ static int test(int[] src, int len, boolean flag) {
+ int[] dest = new int[10];
+ int res = 0;
+ while (test_helper()) {
+ System.arraycopy(src, 0, dest, 0, len);
+ // predicate moved out of loop so control of following
+ // load is not the ArrayCopyNode. Otherwise, if the memory
+ // of the load is changed and the control is set to the
+ // ArrayCopyNode the graph is unschedulable and the test
+ // doesn't fail.
+ if (flag) {
+ }
+ // The memory of this load shouldn't bypass the arraycopy
+ res = dest[0];
+ }
+ return res;
+ }
+
+ static public void main(String[] args) {
+ int[] src = new int[10];
+ src[0] = 0x42;
+ for (int i = 0; i < 20000; i++) {
+ int res = test(src, 10, false);
+ if (res != src[0]) {
+ throw new RuntimeException("test failed");
+ }
+ }
+ }
+}
--- a/hotspot/test/compiler/intrinsics/sha/cli/SHAOptionsBase.java Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/test/compiler/intrinsics/sha/cli/SHAOptionsBase.java Wed Jul 05 20:39:17 2017 +0200
@@ -71,7 +71,7 @@
* instructions required by the option are not supported.
*/
protected static String getWarningForUnsupportedCPU(String optionName) {
- if (Platform.isSparc()) {
+ if (Platform.isSparc() || Platform.isAArch64()) {
switch (optionName) {
case SHAOptionsBase.USE_SHA_OPTION:
return SHAOptionsBase.SHA_INSTRUCTIONS_ARE_NOT_AVAILABLE;
--- a/hotspot/test/compiler/intrinsics/sha/cli/TestUseSHA1IntrinsicsOptionOnSupportedCPU.java Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/test/compiler/intrinsics/sha/cli/TestUseSHA1IntrinsicsOptionOnSupportedCPU.java Wed Jul 05 20:39:17 2017 +0200
@@ -36,7 +36,7 @@
*/
public class TestUseSHA1IntrinsicsOptionOnSupportedCPU {
public static void main(String args[]) throws Throwable {
- new SHAOptionsBase(new GenericTestCaseForSupportedSparcCPU(
+ new SHAOptionsBase(new GenericTestCaseForSupportedCPU(
SHAOptionsBase.USE_SHA1_INTRINSICS_OPTION)).test();
}
}
--- a/hotspot/test/compiler/intrinsics/sha/cli/TestUseSHA1IntrinsicsOptionOnUnsupportedCPU.java Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/test/compiler/intrinsics/sha/cli/TestUseSHA1IntrinsicsOptionOnUnsupportedCPU.java Wed Jul 05 20:39:17 2017 +0200
@@ -40,9 +40,11 @@
new SHAOptionsBase(
new GenericTestCaseForUnsupportedSparcCPU(
SHAOptionsBase.USE_SHA1_INTRINSICS_OPTION),
- new UseSHAIntrinsicsSpecificTestCaseForUnsupportedSparcCPU(
+ new GenericTestCaseForUnsupportedX86CPU(
SHAOptionsBase.USE_SHA1_INTRINSICS_OPTION),
- new GenericTestCaseForUnsupportedX86CPU(
+ new GenericTestCaseForUnsupportedAArch64CPU(
+ SHAOptionsBase.USE_SHA1_INTRINSICS_OPTION),
+ new UseSHAIntrinsicsSpecificTestCaseForUnsupportedCPU(
SHAOptionsBase.USE_SHA1_INTRINSICS_OPTION),
new GenericTestCaseForOtherCPU(
SHAOptionsBase.USE_SHA1_INTRINSICS_OPTION)).test();
--- a/hotspot/test/compiler/intrinsics/sha/cli/TestUseSHA256IntrinsicsOptionOnSupportedCPU.java Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/test/compiler/intrinsics/sha/cli/TestUseSHA256IntrinsicsOptionOnSupportedCPU.java Wed Jul 05 20:39:17 2017 +0200
@@ -37,7 +37,7 @@
*/
public class TestUseSHA256IntrinsicsOptionOnSupportedCPU {
public static void main(String args[]) throws Throwable {
- new SHAOptionsBase(new GenericTestCaseForSupportedSparcCPU(
+ new SHAOptionsBase(new GenericTestCaseForSupportedCPU(
SHAOptionsBase.USE_SHA256_INTRINSICS_OPTION)).test();
}
}
--- a/hotspot/test/compiler/intrinsics/sha/cli/TestUseSHA256IntrinsicsOptionOnUnsupportedCPU.java Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/test/compiler/intrinsics/sha/cli/TestUseSHA256IntrinsicsOptionOnUnsupportedCPU.java Wed Jul 05 20:39:17 2017 +0200
@@ -40,9 +40,11 @@
new SHAOptionsBase(
new GenericTestCaseForUnsupportedSparcCPU(
SHAOptionsBase.USE_SHA256_INTRINSICS_OPTION),
- new UseSHAIntrinsicsSpecificTestCaseForUnsupportedSparcCPU(
+ new GenericTestCaseForUnsupportedX86CPU(
SHAOptionsBase.USE_SHA256_INTRINSICS_OPTION),
- new GenericTestCaseForUnsupportedX86CPU(
+ new GenericTestCaseForUnsupportedAArch64CPU(
+ SHAOptionsBase.USE_SHA256_INTRINSICS_OPTION),
+ new UseSHAIntrinsicsSpecificTestCaseForUnsupportedCPU(
SHAOptionsBase.USE_SHA256_INTRINSICS_OPTION),
new GenericTestCaseForOtherCPU(
SHAOptionsBase.USE_SHA256_INTRINSICS_OPTION)).test();
--- a/hotspot/test/compiler/intrinsics/sha/cli/TestUseSHA512IntrinsicsOptionOnSupportedCPU.java Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/test/compiler/intrinsics/sha/cli/TestUseSHA512IntrinsicsOptionOnSupportedCPU.java Wed Jul 05 20:39:17 2017 +0200
@@ -37,7 +37,7 @@
*/
public class TestUseSHA512IntrinsicsOptionOnSupportedCPU {
public static void main(String args[]) throws Throwable {
- new SHAOptionsBase(new GenericTestCaseForSupportedSparcCPU(
+ new SHAOptionsBase(new GenericTestCaseForSupportedCPU(
SHAOptionsBase.USE_SHA512_INTRINSICS_OPTION)).test();
}
}
--- a/hotspot/test/compiler/intrinsics/sha/cli/TestUseSHA512IntrinsicsOptionOnUnsupportedCPU.java Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/test/compiler/intrinsics/sha/cli/TestUseSHA512IntrinsicsOptionOnUnsupportedCPU.java Wed Jul 05 20:39:17 2017 +0200
@@ -40,9 +40,11 @@
new SHAOptionsBase(
new GenericTestCaseForUnsupportedSparcCPU(
SHAOptionsBase.USE_SHA512_INTRINSICS_OPTION),
- new UseSHAIntrinsicsSpecificTestCaseForUnsupportedSparcCPU(
+ new GenericTestCaseForUnsupportedX86CPU(
SHAOptionsBase.USE_SHA512_INTRINSICS_OPTION),
- new GenericTestCaseForUnsupportedX86CPU(
+ new GenericTestCaseForUnsupportedAArch64CPU(
+ SHAOptionsBase.USE_SHA512_INTRINSICS_OPTION),
+ new UseSHAIntrinsicsSpecificTestCaseForUnsupportedCPU(
SHAOptionsBase.USE_SHA512_INTRINSICS_OPTION),
new GenericTestCaseForOtherCPU(
SHAOptionsBase.USE_SHA512_INTRINSICS_OPTION)).test();
--- a/hotspot/test/compiler/intrinsics/sha/cli/TestUseSHAOptionOnSupportedCPU.java Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/test/compiler/intrinsics/sha/cli/TestUseSHAOptionOnSupportedCPU.java Wed Jul 05 20:39:17 2017 +0200
@@ -37,9 +37,9 @@
public class TestUseSHAOptionOnSupportedCPU {
public static void main(String args[]) throws Throwable {
new SHAOptionsBase(
- new GenericTestCaseForSupportedSparcCPU(
+ new GenericTestCaseForSupportedCPU(
SHAOptionsBase.USE_SHA_OPTION),
- new UseSHASpecificTestCaseForSupportedSparcCPU(
+ new UseSHASpecificTestCaseForSupportedCPU(
SHAOptionsBase.USE_SHA_OPTION)).test();
}
}
--- a/hotspot/test/compiler/intrinsics/sha/cli/TestUseSHAOptionOnUnsupportedCPU.java Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/test/compiler/intrinsics/sha/cli/TestUseSHAOptionOnUnsupportedCPU.java Wed Jul 05 20:39:17 2017 +0200
@@ -39,9 +39,11 @@
new SHAOptionsBase(
new GenericTestCaseForUnsupportedSparcCPU(
SHAOptionsBase.USE_SHA_OPTION),
- new UseSHASpecificTestCaseForUnsupportedSparcCPU(
+ new GenericTestCaseForUnsupportedX86CPU(
SHAOptionsBase.USE_SHA_OPTION),
- new GenericTestCaseForUnsupportedX86CPU(
+ new GenericTestCaseForUnsupportedAArch64CPU(
+ SHAOptionsBase.USE_SHA_OPTION),
+ new UseSHASpecificTestCaseForUnsupportedCPU(
SHAOptionsBase.USE_SHA_OPTION),
new GenericTestCaseForOtherCPU(
SHAOptionsBase.USE_SHA_OPTION)).test();
--- a/hotspot/test/compiler/intrinsics/sha/cli/testcases/GenericTestCaseForOtherCPU.java Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/test/compiler/intrinsics/sha/cli/testcases/GenericTestCaseForOtherCPU.java Wed Jul 05 20:39:17 2017 +0200
@@ -35,16 +35,18 @@
SHAOptionsBase.TestCase {
public GenericTestCaseForOtherCPU(String optionName) {
// Execute the test case on any CPU except SPARC and X86
- super(optionName, new NotPredicate(new OrPredicate(Platform::isSparc,
- new OrPredicate(Platform::isX64, Platform::isX86))));
+ super(optionName, new NotPredicate(
+ new OrPredicate(
+ new OrPredicate(Platform::isSparc, Platform::isAArch64),
+ new OrPredicate(Platform::isX64, Platform::isX86))));
}
@Override
protected void verifyWarnings() throws Throwable {
String shouldPassMessage = String.format("JVM should start with "
+ "option '%s' without any warnings", optionName);
- // Verify that on non-x86 and non-SPARC CPU usage of SHA-related
- // options will not cause any warnings.
+ // Verify that on non-x86, non-SPARC and non-AArch64 CPU usage of
+ // SHA-related options will not cause any warnings.
CommandLineOptionTest.verifySameJVMStartup(null,
new String[] { ".*" + optionName + ".*" }, shouldPassMessage,
shouldPassMessage, ExitCode.OK,
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/intrinsics/sha/cli/testcases/GenericTestCaseForSupportedCPU.java Wed Jul 05 20:39:17 2017 +0200
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) 2014, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+import jdk.test.lib.ExitCode;
+import jdk.test.lib.Platform;
+import jdk.test.lib.cli.CommandLineOptionTest;
+import jdk.test.lib.cli.predicate.AndPredicate;
+import jdk.test.lib.cli.predicate.OrPredicate;
+
+/**
+ * Generic test case for SHA-related options targeted to CPUs which
+ * support instructions required by the tested option.
+ */
+public class GenericTestCaseForSupportedCPU extends
+ SHAOptionsBase.TestCase {
+ public GenericTestCaseForSupportedCPU(String optionName) {
+ super(optionName,
+ new AndPredicate(
+ new OrPredicate(Platform::isSparc, Platform::isAArch64),
+ SHAOptionsBase.getPredicateForOption(optionName)));
+ }
+
+ @Override
+ protected void verifyWarnings() throws Throwable {
+
+ String shouldPassMessage = String.format("JVM should start with option"
+ + " '%s' without any warnings", optionName);
+ // Verify that there are no warning when option is explicitly enabled.
+ CommandLineOptionTest.verifySameJVMStartup(null, new String[] {
+ SHAOptionsBase.getWarningForUnsupportedCPU(optionName)
+ }, shouldPassMessage, shouldPassMessage, ExitCode.OK,
+ CommandLineOptionTest.prepareBooleanFlag(optionName, true));
+
+ // Verify that option could be disabled even if +UseSHA was passed to
+ // JVM.
+ CommandLineOptionTest.verifySameJVMStartup(null, new String[] {
+ SHAOptionsBase.getWarningForUnsupportedCPU(optionName)
+ }, shouldPassMessage, String.format("It should be able to "
+ + "disable option '%s' even if %s was passed to JVM",
+ optionName, CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA_OPTION, true)),
+ ExitCode.OK,
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA_OPTION, true),
+ CommandLineOptionTest.prepareBooleanFlag(optionName, false));
+
+ // Verify that it is possible to enable the tested option and disable
+ // all SHA intrinsics via -UseSHA without any warnings.
+ CommandLineOptionTest.verifySameJVMStartup(null, new String[] {
+ SHAOptionsBase.getWarningForUnsupportedCPU(optionName)
+ }, shouldPassMessage, String.format("It should be able to "
+ + "enable option '%s' even if %s was passed to JVM",
+ optionName, CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA_OPTION, false)),
+ ExitCode.OK,
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA_OPTION, false),
+ CommandLineOptionTest.prepareBooleanFlag(optionName, true));
+ }
+
+ @Override
+ protected void verifyOptionValues() throws Throwable {
+ // Verify that "It should be able to disable option "
+
+ CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "true",
+ String.format("Option '%s' should be enabled by default",
+ optionName));
+
+ // Verify that it is possible to explicitly enable the option.
+ CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "true",
+ String.format("Option '%s' was set to have value 'true'",
+ optionName),
+ CommandLineOptionTest.prepareBooleanFlag(optionName, true));
+
+ // Verify that it is possible to explicitly disable the option.
+ CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false",
+ String.format("Option '%s' was set to have value 'false'",
+ optionName),
+ CommandLineOptionTest.prepareBooleanFlag(optionName, false));
+
+ // verify that option is disabled when -UseSHA was passed to JVM.
+ CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false",
+ String.format("Option '%s' should have value 'false' when %s"
+ + " flag set to JVM", optionName,
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA_OPTION, false)),
+ CommandLineOptionTest.prepareBooleanFlag(optionName, true),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA_OPTION, false));
+
+ // Verify that it is possible to explicitly disable the tested option
+ // even if +UseSHA was passed to JVM.
+ CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false",
+ String.format("Option '%s' should have value 'false' if set so"
+ + " even if %s flag set to JVM", optionName,
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA_OPTION, true)),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA_OPTION, true),
+ CommandLineOptionTest.prepareBooleanFlag(optionName, false));
+ }
+}
--- a/hotspot/test/compiler/intrinsics/sha/cli/testcases/GenericTestCaseForSupportedSparcCPU.java Sun Jun 28 16:38:22 2015 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,119 +0,0 @@
-/*
- * Copyright (c) 2014, 2015, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-import jdk.test.lib.ExitCode;
-import jdk.test.lib.Platform;
-import jdk.test.lib.cli.CommandLineOptionTest;
-import jdk.test.lib.cli.predicate.AndPredicate;
-
-/**
- * Generic test case for SHA-related options targeted to SPARC CPUs which
- * support instructions required by the tested option.
- */
-public class GenericTestCaseForSupportedSparcCPU extends
- SHAOptionsBase.TestCase {
- public GenericTestCaseForSupportedSparcCPU(String optionName) {
- super(optionName, new AndPredicate(Platform::isSparc,
- SHAOptionsBase.getPredicateForOption(optionName)));
- }
-
- @Override
- protected void verifyWarnings() throws Throwable {
-
- String shouldPassMessage = String.format("JVM should start with option"
- + " '%s' without any warnings", optionName);
- // Verify that there are no warning when option is explicitly enabled.
- CommandLineOptionTest.verifySameJVMStartup(null, new String[] {
- SHAOptionsBase.getWarningForUnsupportedCPU(optionName)
- }, shouldPassMessage, shouldPassMessage, ExitCode.OK,
- CommandLineOptionTest.prepareBooleanFlag(optionName, true));
-
- // Verify that option could be disabled even if +UseSHA was passed to
- // JVM.
- CommandLineOptionTest.verifySameJVMStartup(null, new String[] {
- SHAOptionsBase.getWarningForUnsupportedCPU(optionName)
- }, shouldPassMessage, String.format("It should be able to "
- + "disable option '%s' even if %s was passed to JVM",
- optionName, CommandLineOptionTest.prepareBooleanFlag(
- SHAOptionsBase.USE_SHA_OPTION, true)),
- ExitCode.OK,
- CommandLineOptionTest.prepareBooleanFlag(
- SHAOptionsBase.USE_SHA_OPTION, true),
- CommandLineOptionTest.prepareBooleanFlag(optionName, false));
-
- // Verify that it is possible to enable the tested option and disable
- // all SHA intrinsics via -UseSHA without any warnings.
- CommandLineOptionTest.verifySameJVMStartup(null, new String[] {
- SHAOptionsBase.getWarningForUnsupportedCPU(optionName)
- }, shouldPassMessage, String.format("It should be able to "
- + "enable option '%s' even if %s was passed to JVM",
- optionName, CommandLineOptionTest.prepareBooleanFlag(
- SHAOptionsBase.USE_SHA_OPTION, false)),
- ExitCode.OK,
- CommandLineOptionTest.prepareBooleanFlag(
- SHAOptionsBase.USE_SHA_OPTION, false),
- CommandLineOptionTest.prepareBooleanFlag(optionName, true));
- }
-
- @Override
- protected void verifyOptionValues() throws Throwable {
- // Verify that "It should be able to disable option "
-
- CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "true",
- String.format("Option '%s' should be enabled by default",
- optionName));
-
- // Verify that it is possible to explicitly enable the option.
- CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "true",
- String.format("Option '%s' was set to have value 'true'",
- optionName),
- CommandLineOptionTest.prepareBooleanFlag(optionName, true));
-
- // Verify that it is possible to explicitly disable the option.
- CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false",
- String.format("Option '%s' was set to have value 'false'",
- optionName),
- CommandLineOptionTest.prepareBooleanFlag(optionName, false));
-
- // verify that option is disabled when -UseSHA was passed to JVM.
- CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false",
- String.format("Option '%s' should have value 'false' when %s"
- + " flag set to JVM", optionName,
- CommandLineOptionTest.prepareBooleanFlag(
- SHAOptionsBase.USE_SHA_OPTION, false)),
- CommandLineOptionTest.prepareBooleanFlag(optionName, true),
- CommandLineOptionTest.prepareBooleanFlag(
- SHAOptionsBase.USE_SHA_OPTION, false));
-
- // Verify that it is possible to explicitly disable the tested option
- // even if +UseSHA was passed to JVM.
- CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false",
- String.format("Option '%s' should have value 'false' if set so"
- + " even if %s flag set to JVM", optionName,
- CommandLineOptionTest.prepareBooleanFlag(
- SHAOptionsBase.USE_SHA_OPTION, true)),
- CommandLineOptionTest.prepareBooleanFlag(
- SHAOptionsBase.USE_SHA_OPTION, true),
- CommandLineOptionTest.prepareBooleanFlag(optionName, false));
- }
-}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/intrinsics/sha/cli/testcases/GenericTestCaseForUnsupportedAArch64CPU.java Wed Jul 05 20:39:17 2017 +0200
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2014, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+import jdk.test.lib.ExitCode;
+import jdk.test.lib.Platform;
+import jdk.test.lib.cli.CommandLineOptionTest;
+import jdk.test.lib.cli.predicate.AndPredicate;
+import jdk.test.lib.cli.predicate.NotPredicate;
+
+/**
+ * Generic test case for SHA-related options targeted to AArch64 CPUs
+ * which don't support instruction required by the tested option.
+ */
+public class GenericTestCaseForUnsupportedAArch64CPU extends
+ SHAOptionsBase.TestCase {
+ public GenericTestCaseForUnsupportedAArch64CPU(String optionName) {
+ super(optionName, new AndPredicate(Platform::isAArch64,
+ new NotPredicate(SHAOptionsBase.getPredicateForOption(
+ optionName))));
+ }
+
+ @Override
+ protected void verifyWarnings() throws Throwable {
+ String shouldPassMessage = String.format("JVM startup should pass with"
+ + "option '-XX:-%s' without any warnings", optionName);
+ //Verify that option could be disabled without any warnings.
+ CommandLineOptionTest.verifySameJVMStartup(null, new String[] {
+ SHAOptionsBase.getWarningForUnsupportedCPU(optionName)
+ }, shouldPassMessage, shouldPassMessage, ExitCode.OK,
+ CommandLineOptionTest.prepareBooleanFlag(optionName, false));
+
+ shouldPassMessage = String.format("JVM should start with '-XX:+"
+ + "%s' flag, but output should contain warning.", optionName);
+ // Verify that when the tested option is explicitly enabled, then
+ // a warning will occur in VM output.
+ CommandLineOptionTest.verifySameJVMStartup(new String[] {
+ SHAOptionsBase.getWarningForUnsupportedCPU(optionName)
+ }, null, shouldPassMessage, shouldPassMessage, ExitCode.OK,
+ CommandLineOptionTest.prepareBooleanFlag(optionName, true));
+ }
+
+ @Override
+ protected void verifyOptionValues() throws Throwable {
+ // Verify that option is disabled by default.
+ CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false",
+ String.format("Option '%s' should be disabled by default",
+ optionName));
+
+ // Verify that option is disabled even if it was explicitly enabled
+ // using CLI options.
+ CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false",
+ String.format("Option '%s' should be off on unsupported "
+ + "AArch64CPU even if set to true directly", optionName),
+ CommandLineOptionTest.prepareBooleanFlag(optionName, true));
+
+ // Verify that option is disabled when +UseSHA was passed to JVM.
+ CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false",
+ String.format("Option '%s' should be off on unsupported "
+ + "AArch64CPU even if %s flag set to JVM",
+ optionName, CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA_OPTION, true)),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA_OPTION, true));
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/intrinsics/sha/cli/testcases/UseSHAIntrinsicsSpecificTestCaseForUnsupportedCPU.java Wed Jul 05 20:39:17 2017 +0200
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2014, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+import jdk.test.lib.ExitCode;
+import jdk.test.lib.Platform;
+import jdk.test.lib.cli.CommandLineOptionTest;
+import jdk.test.lib.cli.predicate.AndPredicate;
+import jdk.test.lib.cli.predicate.OrPredicate;
+import jdk.test.lib.cli.predicate.NotPredicate;
+import sha.predicate.IntrinsicPredicates;
+
+/**
+ * Test case specific to UseSHA*Intrinsics options targeted to SPARC and AArch64
+ * CPUs which don't support required instruction, but support other SHA-related
+ * instructions.
+ *
+ * For example, CPU support sha1 instruction, but don't support sha256 or
+ * sha512.
+ */
+public class UseSHAIntrinsicsSpecificTestCaseForUnsupportedCPU
+ extends SHAOptionsBase.TestCase {
+ public UseSHAIntrinsicsSpecificTestCaseForUnsupportedCPU(
+ String optionName) {
+ // execute test case on SPARC CPU that support any sha* instructions,
+ // but does not support sha* instruction required by the tested option.
+ super(optionName, new AndPredicate(
+ new OrPredicate(Platform::isSparc, Platform::isAArch64),
+ new AndPredicate(
+ IntrinsicPredicates.ANY_SHA_INSTRUCTION_AVAILABLE,
+ new NotPredicate(SHAOptionsBase.getPredicateForOption(
+ optionName)))));
+ }
+ @Override
+ protected void verifyWarnings() throws Throwable {
+ String shouldPassMessage = String.format("JVM should start with "
+ + "'-XX:+%s' flag, but output should contain warning.",
+ optionName);
+ // Verify that attempt to enable the tested option will cause a warning
+ CommandLineOptionTest.verifySameJVMStartup(new String[] {
+ SHAOptionsBase.getWarningForUnsupportedCPU(optionName)
+ }, null, shouldPassMessage, shouldPassMessage, ExitCode.OK,
+ CommandLineOptionTest.prepareBooleanFlag(optionName, true));
+ }
+}
--- a/hotspot/test/compiler/intrinsics/sha/cli/testcases/UseSHAIntrinsicsSpecificTestCaseForUnsupportedSparcCPU.java Sun Jun 28 16:38:22 2015 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,62 +0,0 @@
-/*
- * Copyright (c) 2014, 2015, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-import jdk.test.lib.ExitCode;
-import jdk.test.lib.Platform;
-import jdk.test.lib.cli.CommandLineOptionTest;
-import jdk.test.lib.cli.predicate.AndPredicate;
-import jdk.test.lib.cli.predicate.NotPredicate;
-import sha.predicate.IntrinsicPredicates;
-
-/**
- * Test case specific to UseSHA*Intrinsics options targeted to SPARC CPUs which
- * don't support required instruction, but support other SHA-related
- * instructions.
- *
- * For example, CPU support sha1 instruction, but don't support sha256 or
- * sha512.
- */
-public class UseSHAIntrinsicsSpecificTestCaseForUnsupportedSparcCPU
- extends SHAOptionsBase.TestCase {
- public UseSHAIntrinsicsSpecificTestCaseForUnsupportedSparcCPU(
- String optionName) {
- // execute test case on SPARC CPU that support any sha* instructions,
- // but does not support sha* instruction required by the tested option.
- super(optionName, new AndPredicate(Platform::isSparc,
- new AndPredicate(
- IntrinsicPredicates.ANY_SHA_INSTRUCTION_AVAILABLE,
- new NotPredicate(SHAOptionsBase.getPredicateForOption(
- optionName)))));
- }
- @Override
- protected void verifyWarnings() throws Throwable {
- String shouldPassMessage = String.format("JVM should start with "
- + "'-XX:+%s' flag, but output should contain warning.",
- optionName);
- // Verify that attempt to enable the tested option will cause a warning
- CommandLineOptionTest.verifySameJVMStartup(new String[] {
- SHAOptionsBase.getWarningForUnsupportedCPU(optionName)
- }, null, shouldPassMessage, shouldPassMessage, ExitCode.OK,
- CommandLineOptionTest.prepareBooleanFlag(optionName, true));
- }
-}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/intrinsics/sha/cli/testcases/UseSHASpecificTestCaseForSupportedCPU.java Wed Jul 05 20:39:17 2017 +0200
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) 2014, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+import jdk.test.lib.Asserts;
+import jdk.test.lib.ExitCode;
+import jdk.test.lib.Platform;
+import jdk.test.lib.cli.CommandLineOptionTest;
+import jdk.test.lib.cli.predicate.AndPredicate;
+import jdk.test.lib.cli.predicate.OrPredicate;
+import sha.predicate.IntrinsicPredicates;
+
+/**
+ * UseSHA specific test case targeted to SPARC and AArch64 CPUs which
+ * support any sha* instruction.
+ */
+public class UseSHASpecificTestCaseForSupportedCPU
+ extends SHAOptionsBase.TestCase {
+ public UseSHASpecificTestCaseForSupportedCPU(String optionName) {
+ super(SHAOptionsBase.USE_SHA_OPTION, new AndPredicate(
+ new OrPredicate(Platform::isSparc, Platform::isAArch64),
+ IntrinsicPredicates.ANY_SHA_INSTRUCTION_AVAILABLE));
+
+ Asserts.assertEQ(optionName, SHAOptionsBase.USE_SHA_OPTION,
+ String.format("Test case should be used for '%s' option only.",
+ SHAOptionsBase.USE_SHA_OPTION));
+ }
+
+ @Override
+ protected void verifyWarnings() throws Throwable {
+ String shouldPassMessage = String.format("JVM startup should pass when"
+ + " %s was passed and all UseSHA*Intrinsics options "
+ + "were disabled",
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA_OPTION, true));
+ // Verify that there will be no warnings when +UseSHA was passed and
+ // all UseSHA*Intrinsics options were disabled.
+ CommandLineOptionTest.verifySameJVMStartup(
+ null, new String[] { ".*UseSHA.*" }, shouldPassMessage,
+ shouldPassMessage, ExitCode.OK,
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA_OPTION, true),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA1_INTRINSICS_OPTION, false),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA256_INTRINSICS_OPTION, false),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA512_INTRINSICS_OPTION, false));
+ }
+
+ @Override
+ protected void verifyOptionValues() throws Throwable {
+ // Verify that UseSHA is disabled when all UseSHA*Intrinsics are
+ // disabled.
+ CommandLineOptionTest.verifyOptionValueForSameVM(
+ SHAOptionsBase.USE_SHA_OPTION, "false", String.format(
+ "'%s' option should be disabled when all UseSHA*Intrinsics are"
+ + " disabled", SHAOptionsBase.USE_SHA_OPTION),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA1_INTRINSICS_OPTION, false),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA256_INTRINSICS_OPTION, false),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA512_INTRINSICS_OPTION, false));
+
+ CommandLineOptionTest.verifyOptionValueForSameVM(
+ // Verify that UseSHA is disabled when all UseSHA*Intrinsics are
+ // disabled even if it was explicitly enabled.
+ SHAOptionsBase.USE_SHA_OPTION, "false",
+ String.format("'%s' option should be disabled when all "
+ + "UseSHA*Intrinsics are disabled even if %s flag set "
+ + "to JVM", SHAOptionsBase.USE_SHA_OPTION,
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA_OPTION, true)),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA_OPTION, true),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA1_INTRINSICS_OPTION, false),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA256_INTRINSICS_OPTION, false),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA512_INTRINSICS_OPTION, false));
+
+ // Verify that explicitly disabled UseSHA option remains disabled even
+ // if all UseSHA*Intrinsics options were enabled.
+ CommandLineOptionTest.verifyOptionValueForSameVM(
+ SHAOptionsBase.USE_SHA_OPTION, "false",
+ String.format("'%s' option should be disabled if %s flag "
+ + "set even if all UseSHA*Intrinsics were enabled",
+ SHAOptionsBase.USE_SHA_OPTION,
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA_OPTION, false)),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA_OPTION, false),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA1_INTRINSICS_OPTION, true),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA256_INTRINSICS_OPTION, true),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA512_INTRINSICS_OPTION, true));
+ }
+}
--- a/hotspot/test/compiler/intrinsics/sha/cli/testcases/UseSHASpecificTestCaseForSupportedSparcCPU.java Sun Jun 28 16:38:22 2015 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,119 +0,0 @@
-/*
- * Copyright (c) 2014, 2015, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-import jdk.test.lib.Asserts;
-import jdk.test.lib.ExitCode;
-import jdk.test.lib.Platform;
-import jdk.test.lib.cli.CommandLineOptionTest;
-import jdk.test.lib.cli.predicate.AndPredicate;
-import sha.predicate.IntrinsicPredicates;
-
-/**
- * UseSHA specific test case targeted to SPARC CPUs which support any sha*
- * instruction.
- */
-public class UseSHASpecificTestCaseForSupportedSparcCPU
- extends SHAOptionsBase.TestCase {
- public UseSHASpecificTestCaseForSupportedSparcCPU(String optionName) {
- super(SHAOptionsBase.USE_SHA_OPTION, new AndPredicate(Platform::isSparc,
- IntrinsicPredicates.ANY_SHA_INSTRUCTION_AVAILABLE));
-
- Asserts.assertEQ(optionName, SHAOptionsBase.USE_SHA_OPTION,
- String.format("Test case should be used for '%s' option only.",
- SHAOptionsBase.USE_SHA_OPTION));
- }
-
- @Override
- protected void verifyWarnings() throws Throwable {
- String shouldPassMessage = String.format("JVM startup should pass when"
- + " %s was passed and all UseSHA*Intrinsics options "
- + "were disabled",
- CommandLineOptionTest.prepareBooleanFlag(
- SHAOptionsBase.USE_SHA_OPTION, true));
- // Verify that there will be no warnings when +UseSHA was passed and
- // all UseSHA*Intrinsics options were disabled.
- CommandLineOptionTest.verifySameJVMStartup(
- null, new String[] { ".*UseSHA.*" }, shouldPassMessage,
- shouldPassMessage, ExitCode.OK,
- CommandLineOptionTest.prepareBooleanFlag(
- SHAOptionsBase.USE_SHA_OPTION, true),
- CommandLineOptionTest.prepareBooleanFlag(
- SHAOptionsBase.USE_SHA1_INTRINSICS_OPTION, false),
- CommandLineOptionTest.prepareBooleanFlag(
- SHAOptionsBase.USE_SHA256_INTRINSICS_OPTION, false),
- CommandLineOptionTest.prepareBooleanFlag(
- SHAOptionsBase.USE_SHA512_INTRINSICS_OPTION, false));
- }
-
- @Override
- protected void verifyOptionValues() throws Throwable {
- // Verify that UseSHA is disabled when all UseSHA*Intrinsics are
- // disabled.
- CommandLineOptionTest.verifyOptionValueForSameVM(
- SHAOptionsBase.USE_SHA_OPTION, "false", String.format(
- "'%s' option should be disabled when all UseSHA*Intrinsics are"
- + " disabled", SHAOptionsBase.USE_SHA_OPTION),
- CommandLineOptionTest.prepareBooleanFlag(
- SHAOptionsBase.USE_SHA1_INTRINSICS_OPTION, false),
- CommandLineOptionTest.prepareBooleanFlag(
- SHAOptionsBase.USE_SHA256_INTRINSICS_OPTION, false),
- CommandLineOptionTest.prepareBooleanFlag(
- SHAOptionsBase.USE_SHA512_INTRINSICS_OPTION, false));
-
- CommandLineOptionTest.verifyOptionValueForSameVM(
- // Verify that UseSHA is disabled when all UseSHA*Intrinsics are
- // disabled even if it was explicitly enabled.
- SHAOptionsBase.USE_SHA_OPTION, "false",
- String.format("'%s' option should be disabled when all "
- + "UseSHA*Intrinsics are disabled even if %s flag set "
- + "to JVM", SHAOptionsBase.USE_SHA_OPTION,
- CommandLineOptionTest.prepareBooleanFlag(
- SHAOptionsBase.USE_SHA_OPTION, true)),
- CommandLineOptionTest.prepareBooleanFlag(
- SHAOptionsBase.USE_SHA_OPTION, true),
- CommandLineOptionTest.prepareBooleanFlag(
- SHAOptionsBase.USE_SHA1_INTRINSICS_OPTION, false),
- CommandLineOptionTest.prepareBooleanFlag(
- SHAOptionsBase.USE_SHA256_INTRINSICS_OPTION, false),
- CommandLineOptionTest.prepareBooleanFlag(
- SHAOptionsBase.USE_SHA512_INTRINSICS_OPTION, false));
-
- // Verify that explicitly disabled UseSHA option remains disabled even
- // if all UseSHA*Intrinsics options were enabled.
- CommandLineOptionTest.verifyOptionValueForSameVM(
- SHAOptionsBase.USE_SHA_OPTION, "false",
- String.format("'%s' option should be disabled if %s flag "
- + "set even if all UseSHA*Intrinsics were enabled",
- SHAOptionsBase.USE_SHA_OPTION,
- CommandLineOptionTest.prepareBooleanFlag(
- SHAOptionsBase.USE_SHA_OPTION, false)),
- CommandLineOptionTest.prepareBooleanFlag(
- SHAOptionsBase.USE_SHA_OPTION, false),
- CommandLineOptionTest.prepareBooleanFlag(
- SHAOptionsBase.USE_SHA1_INTRINSICS_OPTION, true),
- CommandLineOptionTest.prepareBooleanFlag(
- SHAOptionsBase.USE_SHA256_INTRINSICS_OPTION, true),
- CommandLineOptionTest.prepareBooleanFlag(
- SHAOptionsBase.USE_SHA512_INTRINSICS_OPTION, true));
- }
-}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/intrinsics/sha/cli/testcases/UseSHASpecificTestCaseForUnsupportedCPU.java Wed Jul 05 20:39:17 2017 +0200
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2014, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+import jdk.test.lib.Asserts;
+import jdk.test.lib.ExitCode;
+import jdk.test.lib.Platform;
+import jdk.test.lib.cli.CommandLineOptionTest;
+import jdk.test.lib.cli.predicate.AndPredicate;
+import jdk.test.lib.cli.predicate.OrPredicate;
+import jdk.test.lib.cli.predicate.NotPredicate;
+import sha.predicate.IntrinsicPredicates;
+
+/**
+ * UseSHA specific test case targeted to SPARC and AArch64 CPUs which don't
+ * support all sha* instructions./
+ */
+public class UseSHASpecificTestCaseForUnsupportedCPU
+ extends SHAOptionsBase.TestCase {
+ public UseSHASpecificTestCaseForUnsupportedCPU(String optionName) {
+ super(SHAOptionsBase.USE_SHA_OPTION, new AndPredicate(
+ new OrPredicate(Platform::isSparc, Platform::isAArch64),
+ new NotPredicate(
+ IntrinsicPredicates.ANY_SHA_INSTRUCTION_AVAILABLE)));
+
+ Asserts.assertEQ(optionName, SHAOptionsBase.USE_SHA_OPTION,
+ "Test case should be used for " + SHAOptionsBase.USE_SHA_OPTION
+ + " option only.");
+ }
+
+ @Override
+ protected void verifyWarnings() throws Throwable {
+ // Verify that attempt to use UseSHA option will cause a warning.
+ String shouldPassMessage = String.format("JVM startup should pass with"
+ + " '%s' option on unsupported CPU, but there should be"
+ + "the message shown.", optionName);
+ CommandLineOptionTest.verifySameJVMStartup(new String[] {
+ SHAOptionsBase.getWarningForUnsupportedCPU(optionName)
+ }, null, shouldPassMessage, shouldPassMessage, ExitCode.OK,
+ CommandLineOptionTest.prepareBooleanFlag(optionName, true));
+ }
+
+ @Override
+ protected void verifyOptionValues() throws Throwable {
+ // Verify that UseSHA option remains disabled even if all
+ // UseSHA*Intrinsics were enabled.
+ CommandLineOptionTest.verifyOptionValueForSameVM(
+ SHAOptionsBase.USE_SHA_OPTION, "false", String.format(
+ "%s option should be disabled on unsupported CPU"
+ + " even if all UseSHA*Intrinsics options were enabled.",
+ SHAOptionsBase.USE_SHA_OPTION),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA1_INTRINSICS_OPTION, true),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA256_INTRINSICS_OPTION, true),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA512_INTRINSICS_OPTION, true));
+
+ // Verify that UseSHA option remains disabled even if all
+ // UseSHA*Intrinsics options were enabled and UseSHA was enabled as well.
+ CommandLineOptionTest.verifyOptionValueForSameVM(
+ SHAOptionsBase.USE_SHA_OPTION, "false", String.format(
+ "%s option should be disabled on unsupported CPU"
+ + " even if all UseSHA*Intrinsics options were enabled"
+ + " and %s was enabled as well",
+ SHAOptionsBase.USE_SHA_OPTION,
+ SHAOptionsBase.USE_SHA_OPTION),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA_OPTION, true),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA1_INTRINSICS_OPTION, true),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA256_INTRINSICS_OPTION, true),
+ CommandLineOptionTest.prepareBooleanFlag(
+ SHAOptionsBase.USE_SHA512_INTRINSICS_OPTION, true));
+ }
+}
--- a/hotspot/test/compiler/intrinsics/sha/cli/testcases/UseSHASpecificTestCaseForUnsupportedSparcCPU.java Sun Jun 28 16:38:22 2015 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,94 +0,0 @@
-/*
- * Copyright (c) 2014, 2015, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-import jdk.test.lib.Asserts;
-import jdk.test.lib.ExitCode;
-import jdk.test.lib.Platform;
-import jdk.test.lib.cli.CommandLineOptionTest;
-import jdk.test.lib.cli.predicate.AndPredicate;
-import jdk.test.lib.cli.predicate.NotPredicate;
-import sha.predicate.IntrinsicPredicates;
-
-/**
- * UseSHA specific test case targeted to SPARC CPUs which don't support all sha*
- * instructions.
- */
-public class UseSHASpecificTestCaseForUnsupportedSparcCPU
- extends SHAOptionsBase.TestCase {
- public UseSHASpecificTestCaseForUnsupportedSparcCPU(String optionName) {
- super(SHAOptionsBase.USE_SHA_OPTION, new AndPredicate(Platform::isSparc,
- new NotPredicate(
- IntrinsicPredicates.ANY_SHA_INSTRUCTION_AVAILABLE)));
-
- Asserts.assertEQ(optionName, SHAOptionsBase.USE_SHA_OPTION,
- "Test case should be used for " + SHAOptionsBase.USE_SHA_OPTION
- + " option only.");
- }
-
- @Override
- protected void verifyWarnings() throws Throwable {
- // Verify that attempt to use UseSHA option will cause a warning.
- String shouldPassMessage = String.format("JVM startup should pass with"
- + " '%s' option on unsupported SparcCPU, but there should be"
- + "the message shown.", optionName);
- CommandLineOptionTest.verifySameJVMStartup(new String[] {
- SHAOptionsBase.getWarningForUnsupportedCPU(optionName)
- }, null, shouldPassMessage, shouldPassMessage, ExitCode.OK,
- CommandLineOptionTest.prepareBooleanFlag(optionName, true));
- }
-
- @Override
- protected void verifyOptionValues() throws Throwable {
- // Verify that UseSHA option remains disabled even if all
- // UseSHA*Intrinsics were enabled.
- CommandLineOptionTest.verifyOptionValueForSameVM(
- SHAOptionsBase.USE_SHA_OPTION, "false", String.format(
- "%s option should be disabled on unsupported SparcCPU"
- + " even if all UseSHA*Intrinsics options were enabled.",
- SHAOptionsBase.USE_SHA_OPTION),
- CommandLineOptionTest.prepareBooleanFlag(
- SHAOptionsBase.USE_SHA1_INTRINSICS_OPTION, true),
- CommandLineOptionTest.prepareBooleanFlag(
- SHAOptionsBase.USE_SHA256_INTRINSICS_OPTION, true),
- CommandLineOptionTest.prepareBooleanFlag(
- SHAOptionsBase.USE_SHA512_INTRINSICS_OPTION, true));
-
- // Verify that UseSHA option remains disabled even if all
- // UseSHA*Intrinsics options were enabled and UseSHA was enabled as well.
- CommandLineOptionTest.verifyOptionValueForSameVM(
- SHAOptionsBase.USE_SHA_OPTION, "false", String.format(
- "%s option should be disabled on unsupported SparcCPU"
- + " even if all UseSHA*Intrinsics options were enabled"
- + " and %s was enabled as well",
- SHAOptionsBase.USE_SHA_OPTION,
- SHAOptionsBase.USE_SHA_OPTION),
- CommandLineOptionTest.prepareBooleanFlag(
- SHAOptionsBase.USE_SHA_OPTION, true),
- CommandLineOptionTest.prepareBooleanFlag(
- SHAOptionsBase.USE_SHA1_INTRINSICS_OPTION, true),
- CommandLineOptionTest.prepareBooleanFlag(
- SHAOptionsBase.USE_SHA256_INTRINSICS_OPTION, true),
- CommandLineOptionTest.prepareBooleanFlag(
- SHAOptionsBase.USE_SHA512_INTRINSICS_OPTION, true));
- }
-}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/jsr292/PollutedTrapCounts.java Wed Jul 05 20:39:17 2017 +0200
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/**
+ * @test
+ * @bug 8074551
+ * @library /testlibrary
+ * @run main PollutedTrapCounts
+ */
+import java.lang.invoke.*;
+import jdk.test.lib.*;
+
+public class PollutedTrapCounts {
+ public static void main(String[] args) throws Exception {
+ ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
+ "-XX:+IgnoreUnrecognizedVMOptions",
+ "-XX:-TieredCompilation", "-Xbatch",
+ "-XX:PerBytecodeRecompilationCutoff=10", "-XX:PerMethodRecompilationCutoff=10",
+ "-XX:+PrintCompilation", "-XX:+UnlockDiagnosticVMOptions", "-XX:+PrintInlining",
+ "PollutedTrapCounts$Test");
+
+ OutputAnalyzer analyzer = new OutputAnalyzer(pb.start());
+
+ analyzer.shouldHaveExitValue(0);
+
+ analyzer.shouldNotContain("not compilable (disabled)");
+ }
+
+ static class Test {
+ public static final MethodHandle test1;
+ public static final MethodHandle test2;
+ public static final MethodHandle empty;
+
+ static {
+ try {
+ Class<?> THIS_CLASS = Test.class;
+ MethodHandles.Lookup LOOKUP = MethodHandles.lookup();
+ test1 = LOOKUP.findStatic(THIS_CLASS, "test1", MethodType.methodType(boolean.class, boolean.class));
+ test2 = LOOKUP.findStatic(THIS_CLASS, "test2", MethodType.methodType(boolean.class, boolean.class));
+ empty = LOOKUP.findStatic(THIS_CLASS, "empty", MethodType.methodType(void.class, boolean.class));
+ } catch(Throwable e) {
+ throw new Error(e);
+ }
+ }
+
+ static boolean test1(boolean b) {
+ return b;
+ }
+ static boolean test2(boolean b) {
+ return true;
+ }
+ static void empty(boolean b) {}
+
+ static void test(boolean freqValue, boolean removeInlineBlocker) throws Throwable {
+ MethodHandle innerGWT = MethodHandles.guardWithTest(test1, empty, empty);
+ MethodHandle outerGWT = MethodHandles.guardWithTest(test2, innerGWT, innerGWT);
+
+ // Trigger compilation
+ for (int i = 0; i < 20_000; i++) {
+ outerGWT.invokeExact(freqValue);
+ }
+
+ // Trigger deopt & nmethod invalidation
+ outerGWT.invokeExact(!freqValue);
+
+ // Force inline blocker removal on rare-taken path
+ if (removeInlineBlocker) {
+ for (int i = 0; i < 100; i++) {
+ outerGWT.invokeExact(!freqValue);
+ }
+ }
+
+ // Trigger recompilation
+ for (int i = 0; i < 20_000; i++) {
+ outerGWT.invokeExact(freqValue);
+ }
+ }
+
+ public static void main(String[] args) throws Throwable {
+ boolean freqValue = true;
+ boolean removeInlineBlocker = false;
+ for (int i = 0; i < 20; i++) {
+ test(freqValue, removeInlineBlocker);
+ freqValue = !freqValue;
+ removeInlineBlocker = !removeInlineBlocker;
+ }
+ }
+ }
+}
--- a/hotspot/test/compiler/testlibrary/sha/predicate/IntrinsicPredicates.java Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/test/compiler/testlibrary/sha/predicate/IntrinsicPredicates.java Wed Jul 05 20:39:17 2017 +0200
@@ -59,16 +59,19 @@
};
public static final BooleanSupplier SHA1_INSTRUCTION_AVAILABLE
- = new CPUSpecificPredicate("sparc.*", new String[] { "sha1" },
- null);
+ = new OrPredicate(
+ new CPUSpecificPredicate("sparc.*", new String[] { "sha1" },null),
+ new CPUSpecificPredicate("aarch64.*", new String[] { "sha1" },null));
public static final BooleanSupplier SHA256_INSTRUCTION_AVAILABLE
- = new CPUSpecificPredicate("sparc.*", new String[] { "sha256" },
- null);
+ = new OrPredicate(
+ new CPUSpecificPredicate("sparc.*", new String[] { "sha256" },null),
+ new CPUSpecificPredicate("aarch64.*", new String[] { "sha256" },null));
public static final BooleanSupplier SHA512_INSTRUCTION_AVAILABLE
- = new CPUSpecificPredicate("sparc.*", new String[] { "sha512" },
- null);
+ = new OrPredicate(
+ new CPUSpecificPredicate("sparc.*", new String[] { "sha512" },null),
+ new CPUSpecificPredicate("aarch64.*", new String[] { "sha512" },null));
public static final BooleanSupplier ANY_SHA_INSTRUCTION_AVAILABLE
= new OrPredicate(IntrinsicPredicates.SHA1_INSTRUCTION_AVAILABLE,
--- a/hotspot/test/testlibrary_tests/RandomGeneratorTest.java Sun Jun 28 16:38:22 2015 -0700
+++ b/hotspot/test/testlibrary_tests/RandomGeneratorTest.java Wed Jul 05 20:39:17 2017 +0200
@@ -32,11 +32,15 @@
* @run driver RandomGeneratorTest DIFFERENT_SEED
*/
-import jdk.test.lib.ProcessTools;
-import jdk.test.lib.Utils;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
+import jdk.test.lib.OutputAnalyzer;
+import jdk.test.lib.ProcessTools;
+import jdk.test.lib.Utils;
/**
* The test verifies correctness of work {@link jdk.test.lib.Utils#getRandomInstance()}.
@@ -59,8 +63,13 @@
jvmArgs.add(optStr);
}
jvmArgs.add(RandomRunner.class.getName());
+ String origFileName = seedOpt.name() + "_orig";
+ jvmArgs.add(origFileName);
+ int fileNameIndex = jvmArgs.size() - 1;
String[] cmdLineArgs = jvmArgs.toArray(new String[jvmArgs.size()]);
- String etalon = ProcessTools.executeTestJvm(cmdLineArgs).getStdout().trim();
+ ProcessTools.executeTestJvm(cmdLineArgs).shouldHaveExitValue(0);
+ String etalon = Utils.fileAsString(origFileName).trim();
+ cmdLineArgs[fileNameIndex] = seedOpt.name();
seedOpt.verify(etalon, cmdLineArgs);
}
@@ -121,26 +130,31 @@
* @throws Throwable - Throws an exception in case test failure.
*/
public void verify(String orig, String[] cmdLine) {
- String lastLineOrig = getLastLine(orig);
- String lastLine;
+ String output;
+ OutputAnalyzer oa;
try {
- lastLine = getLastLine(ProcessTools.executeTestJvm(cmdLine).getStdout().trim());
+ oa = ProcessTools.executeTestJvm(cmdLine);
} catch (Throwable t) {
throw new Error("TESTBUG: Unexpedted exception during jvm execution.", t);
}
- if (!isOutputExpected(lastLineOrig, lastLine)) {
- throw new AssertionError("Unexpected random number sequence for mode: " + this.name());
+ oa.shouldHaveExitValue(0);
+ try {
+ output = Utils.fileAsString(name()).trim();
+ } catch (IOException ioe) {
+ throw new Error("TESTBUG: Problem during IO operation with file: " + name(), ioe);
}
- }
-
- private static String getLastLine(String output) {
- return output.substring(output.lastIndexOf(Utils.NEW_LINE)).trim();
+ if (!isOutputExpected(orig, output)) {
+ System.err.println("Initial output: " + orig);
+ System.err.println("Second run output: " + output);
+ throw new AssertionError("Unexpected random number sequence for mode: " + this.name());
+ }
}
}
/**
* The helper class generates several random numbers
- * and prints them out.
+ * and put results to a file. The file name came as first
+ * command line argument.
*/
public static class RandomRunner {
private static final int COUNT = 10;
@@ -150,7 +164,11 @@
for (int i = 0; i < COUNT; i++) {
sb.append(rng.nextLong()).append(' ');
}
- System.out.println(sb.toString());
+ try (PrintWriter pw = new PrintWriter(new FileWriter(args[0]))) {
+ pw.write(sb.toString());
+ } catch (IOException ioe) {
+ throw new Error("TESTBUG: Problem during IO operation with file: " + args[0], ioe);
+ }
}
}
}
--- a/make/common/MakeBase.gmk Sun Jun 28 16:38:22 2015 -0700
+++ b/make/common/MakeBase.gmk Wed Jul 05 20:39:17 2017 +0200
@@ -369,8 +369,9 @@
HGTIP_FILENAME=.hgtip
HG_SEARCH = ./REPO ./*/REPO ./*/*/REPO ./*/*/*/REPO
REPO_LIST = $(patsubst ./%,%,$(patsubst %/,%,$(sort $(dir \
- $(shell $(CD) $(SRC_ROOT) ; ( $(LS) -d $(HG_SEARCH:%/REPO=%/$(HG_DIRECTORY)) ; \
- $(LS) $(HG_SEARCH:%/REPO=%/$(HGTIP_FILENAME)) ) \
+ $(shell $(CD) $(SRC_ROOT) ; \
+ $(LS) -d $(HG_SEARCH:%/REPO=%/$(HG_DIRECTORY)) \
+ $(HG_SEARCH:%/REPO=%/$(HGTIP_FILENAME)) \
2> /dev/null)))))
# Emit the repo:tip pairs to $@
--- a/make/common/TestFilesCompilation.gmk Sun Jun 28 16:38:22 2015 -0700
+++ b/make/common/TestFilesCompilation.gmk Wed Jul 05 20:39:17 2017 +0200
@@ -86,8 +86,8 @@
OBJECT_DIR := $$($1_OUTPUT_DIR)/support/$$($1_PREFIX)$$(name), \
OUTPUT_DIR := $$($1_OUTPUT_DIR)/$$($1_OUTPUT_SUBDIR), \
LANG := C, \
- CFLAGS := $$($1_CFLAGS), \
- LDFLAGS := $$($1_LDFLAGS), \
+ CFLAGS := $$($1_CFLAGS) $$($1_CFLAGS_$$($1_PREFIX)$$(name)), \
+ LDFLAGS := $$($1_LDFLAGS) $$($1_LDFLAGS_$$($1_PREFIX)$$(name)), \
OPTIMIZATION := LOW, \
DEBUG_SYMBOLS := true)) \
$$(eval $1 += $$(BUILD_TEST_$$(name)) ) \
--- a/test/lib/sun/hotspot/WhiteBox.java Sun Jun 28 16:38:22 2015 -0700
+++ b/test/lib/sun/hotspot/WhiteBox.java Wed Jul 05 20:39:17 2017 +0200
@@ -306,6 +306,8 @@
public native boolean isConstantVMFlag(String name);
public native boolean isLockedVMFlag(String name);
public native void setBooleanVMFlag(String name, boolean value);
+ public native void setIntVMFlag(String name, long value);
+ public native void setUintVMFlag(String name, long value);
public native void setIntxVMFlag(String name, long value);
public native void setUintxVMFlag(String name, long value);
public native void setUint64VMFlag(String name, long value);
@@ -313,6 +315,8 @@
public native void setStringVMFlag(String name, String value);
public native void setDoubleVMFlag(String name, double value);
public native Boolean getBooleanVMFlag(String name);
+ public native Long getIntVMFlag(String name);
+ public native Long getUintVMFlag(String name);
public native Long getIntxVMFlag(String name);
public native Long getUintxVMFlag(String name);
public native Long getUint64VMFlag(String name);
@@ -320,9 +324,9 @@
public native String getStringVMFlag(String name);
public native Double getDoubleVMFlag(String name);
private final List<Function<String,Object>> flagsGetters = Arrays.asList(
- this::getBooleanVMFlag, this::getIntxVMFlag, this::getUintxVMFlag,
- this::getUint64VMFlag, this::getSizeTVMFlag, this::getStringVMFlag,
- this::getDoubleVMFlag);
+ this::getBooleanVMFlag, this::getIntVMFlag, this::getUintVMFlag,
+ this::getIntxVMFlag, this::getUintxVMFlag, this::getUint64VMFlag,
+ this::getSizeTVMFlag, this::getStringVMFlag, this::getDoubleVMFlag);
public Object getVMFlag(String name) {
return flagsGetters.stream()