Date: Sun, 25 Sep 2022 23:07:23 GMT From: Greg Lewis <glewis@FreeBSD.org> To: ports-committers@FreeBSD.org, dev-commits-ports-all@FreeBSD.org, dev-commits-ports-main@FreeBSD.org Subject: git: 749c57a8a8b8 - main - java/openjdk11: Update to 11.0.16.1 Message-ID: <202209252307.28PN7NAx016588@gitrepo.freebsd.org>
next in thread | raw e-mail | index | archive | help
The branch main has been updated by glewis: URL: https://cgit.FreeBSD.org/ports/commit/?id=749c57a8a8b8f36b8b6abeb48c64697f6dfc8f0a commit 749c57a8a8b8f36b8b6abeb48c64697f6dfc8f0a Author: Greg Lewis <glewis@FreeBSD.org> AuthorDate: 2022-09-25 23:06:16 +0000 Commit: Greg Lewis <glewis@FreeBSD.org> CommitDate: 2022-09-25 23:06:16 +0000 java/openjdk11: Update to 11.0.16.1 --- java/openjdk11/Makefile | 2 +- java/openjdk11/files/patch-16-1 | 543 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 544 insertions(+), 1 deletion(-) diff --git a/java/openjdk11/Makefile b/java/openjdk11/Makefile index f8baec3ea93c..60ef9756b3a5 100644 --- a/java/openjdk11/Makefile +++ b/java/openjdk11/Makefile @@ -1,7 +1,7 @@ PORTNAME= openjdk DISTVERSIONPREFIX= jdk- DISTVERSION= ${JDK_MAJOR_VERSION}.${JDK_MINOR_VERSION}.${JDK_PATCH_VERSION}+${JDK_BUILD_NUMBER}-${BSD_JDK_VERSION} -PORTREVISION= 1 +PORTREVISION= 2 CATEGORIES= java devel PKGNAMESUFFIX?= ${JDK_MAJOR_VERSION} diff --git a/java/openjdk11/files/patch-16-1 b/java/openjdk11/files/patch-16-1 new file mode 100644 index 000000000000..57aa64ecbb75 --- /dev/null +++ b/java/openjdk11/files/patch-16-1 @@ -0,0 +1,543 @@ +--- .jcheck/conf ++++ .jcheck/conf +@@ -1,7 +1,7 @@ + [general] + project=jdk-updates + jbs=JDK +-version=11.0.16 ++version=11.0.16.1 + + [checks] + error=author,committer,reviewers,merge,issues,executable,symlink,message,hg-tag,whitespace +--- make/autoconf/version-numbers ++++ make/autoconf/version-numbers +@@ -29,11 +29,11 @@ + DEFAULT_VERSION_FEATURE=11 + DEFAULT_VERSION_INTERIM=0 + DEFAULT_VERSION_UPDATE=16 +-DEFAULT_VERSION_PATCH=0 ++DEFAULT_VERSION_PATCH=1 + DEFAULT_VERSION_EXTRA1=0 + DEFAULT_VERSION_EXTRA2=0 + DEFAULT_VERSION_EXTRA3=0 +-DEFAULT_VERSION_DATE=2022-07-19 ++DEFAULT_VERSION_DATE=2022-08-12 + DEFAULT_VERSION_CLASSFILE_MAJOR=55 # "`$EXPR $DEFAULT_VERSION_FEATURE + 44`" + DEFAULT_VERSION_CLASSFILE_MINOR=0 + DEFAULT_ACCEPTABLE_BOOT_VERSIONS="10 11" +--- src/hotspot/share/opto/callnode.cpp ++++ src/hotspot/share/opto/callnode.cpp +@@ -1378,7 +1378,6 @@ AllocateNode::AllocateNode(Compile* C, const TypeFunc *atype, + init_req( KlassNode , klass_node); + init_req( InitialTest , initial_test); + init_req( ALength , topnode); +- init_req( ValidLengthTest , topnode); + C->add_macro_node(this); + } + +@@ -1399,6 +1398,54 @@ void AllocateNode::compute_MemBar_redundancy(ciMethod* initializer) + } + } + ++//============================================================================= ++Node* AllocateArrayNode::Ideal(PhaseGVN *phase, bool can_reshape) { ++ if (remove_dead_region(phase, can_reshape)) return this; ++ // Don't bother trying to transform a dead node ++ if (in(0) && in(0)->is_top()) return NULL; ++ ++ const Type* type = phase->type(Ideal_length()); ++ if (type->isa_int() && type->is_int()->_hi < 0) { ++ if (can_reshape) { ++ PhaseIterGVN *igvn = phase->is_IterGVN(); ++ // Unreachable fall through path (negative array length), ++ // the allocation can only throw so disconnect it. ++ Node* proj = proj_out_or_null(TypeFunc::Control); ++ Node* catchproj = NULL; ++ if (proj != NULL) { ++ for (DUIterator_Fast imax, i = proj->fast_outs(imax); i < imax; i++) { ++ Node *cn = proj->fast_out(i); ++ if (cn->is_Catch()) { ++ catchproj = cn->as_Multi()->proj_out_or_null(CatchProjNode::fall_through_index); ++ break; ++ } ++ } ++ } ++ if (catchproj != NULL && catchproj->outcnt() > 0 && ++ (catchproj->outcnt() > 1 || ++ catchproj->unique_out()->Opcode() != Op_Halt)) { ++ assert(catchproj->is_CatchProj(), "must be a CatchProjNode"); ++ Node* nproj = catchproj->clone(); ++ igvn->register_new_node_with_optimizer(nproj); ++ ++ Node *frame = new ParmNode( phase->C->start(), TypeFunc::FramePtr ); ++ frame = phase->transform(frame); ++ // Halt & Catch Fire ++ Node* halt = new HaltNode(nproj, frame, "unexpected negative array length"); ++ phase->C->root()->add_req(halt); ++ phase->transform(halt); ++ ++ igvn->replace_node(catchproj, phase->C->top()); ++ return this; ++ } ++ } else { ++ // Can't correct it during regular GVN so register for IGVN ++ phase->C->record_for_igvn(this); ++ } ++ } ++ return NULL; ++} ++ + // Retrieve the length from the AllocateArrayNode. Narrow the type with a + // CastII, if appropriate. If we are not allowed to create new nodes, and + // a CastII is appropriate, return NULL. +--- src/hotspot/share/opto/callnode.hpp ++++ src/hotspot/share/opto/callnode.hpp +@@ -839,7 +839,6 @@ public: + KlassNode, // type (maybe dynamic) of the obj. + InitialTest, // slow-path test (may be constant) + ALength, // array length (or TOP if none) +- ValidLengthTest, + ParmLimit + }; + +@@ -849,7 +848,6 @@ public: + fields[KlassNode] = TypeInstPtr::NOTNULL; + fields[InitialTest] = TypeInt::BOOL; + fields[ALength] = t; // length (can be a bad length) +- fields[ValidLengthTest] = TypeInt::BOOL; + + const TypeTuple *domain = TypeTuple::make(ParmLimit, fields); + +@@ -947,16 +945,18 @@ public: + // + class AllocateArrayNode : public AllocateNode { + public: +- AllocateArrayNode(Compile* C, const TypeFunc* atype, Node* ctrl, Node* mem, Node* abio, Node* size, Node* klass_node, +- Node* initial_test, Node* count_val, Node* valid_length_test) ++ AllocateArrayNode(Compile* C, const TypeFunc *atype, Node *ctrl, Node *mem, Node *abio, ++ Node* size, Node* klass_node, Node* initial_test, ++ Node* count_val ++ ) + : AllocateNode(C, atype, ctrl, mem, abio, size, klass_node, + initial_test) + { + init_class_id(Class_AllocateArray); + set_req(AllocateNode::ALength, count_val); +- set_req(AllocateNode::ValidLengthTest, valid_length_test); + } + virtual int Opcode() const; ++ virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); + + // Dig the length operand out of a array allocation site. + Node* Ideal_length() { +--- src/hotspot/share/opto/cfgnode.cpp ++++ src/hotspot/share/opto/cfgnode.cpp +@@ -2352,17 +2352,6 @@ const Type* CatchNode::Value(PhaseGVN* phase) const { + // Rethrows always throw exceptions, never return + if (call->entry_point() == OptoRuntime::rethrow_stub()) { + f[CatchProjNode::fall_through_index] = Type::TOP; +- } else if (call->is_AllocateArray()) { +- Node* klass_node = call->in(AllocateNode::KlassNode); +- Node* length = call->in(AllocateNode::ALength); +- const Type* length_type = phase->type(length); +- const Type* klass_type = phase->type(klass_node); +- Node* valid_length_test = call->in(AllocateNode::ValidLengthTest); +- const Type* valid_length_test_t = phase->type(valid_length_test); +- if (length_type == Type::TOP || klass_type == Type::TOP || valid_length_test_t == Type::TOP || +- valid_length_test_t->is_int()->is_con(0)) { +- f[CatchProjNode::fall_through_index] = Type::TOP; +- } + } else if( call->req() > TypeFunc::Parms ) { + const Type *arg0 = phase->type( call->in(TypeFunc::Parms) ); + // Check for null receiver to virtual or interface calls +--- src/hotspot/share/opto/compile.cpp ++++ src/hotspot/share/opto/compile.cpp +@@ -3706,7 +3706,7 @@ bool Compile::final_graph_reshaping() { + // 'fall-thru' path, so expected kids is 1 less. + if (n->is_PCTable() && n->in(0) && n->in(0)->in(0)) { + if (n->in(0)->in(0)->is_Call()) { +- CallNode* call = n->in(0)->in(0)->as_Call(); ++ CallNode *call = n->in(0)->in(0)->as_Call(); + if (call->entry_point() == OptoRuntime::rethrow_stub()) { + required_outcnt--; // Rethrow always has 1 less kid + } else if (call->req() > TypeFunc::Parms && +@@ -3715,25 +3715,22 @@ bool Compile::final_graph_reshaping() { + // detected that the virtual call will always result in a null + // pointer exception. The fall-through projection of this CatchNode + // will not be populated. +- Node* arg0 = call->in(TypeFunc::Parms); ++ Node *arg0 = call->in(TypeFunc::Parms); + if (arg0->is_Type() && + arg0->as_Type()->type()->higher_equal(TypePtr::NULL_PTR)) { + required_outcnt--; + } +- } else if (call->entry_point() == OptoRuntime::new_array_Java() || +- call->entry_point() == OptoRuntime::new_array_nozero_Java()) { +- // Check for illegal array length. In such case, the optimizer has ++ } else if (call->entry_point() == OptoRuntime::new_array_Java() && ++ call->req() > TypeFunc::Parms+1 && ++ call->is_CallStaticJava()) { ++ // Check for negative array length. In such case, the optimizer has + // detected that the allocation attempt will always result in an + // exception. There is no fall-through projection of this CatchNode . +- assert(call->is_CallStaticJava(), "static call expected"); +- assert(call->req() == call->jvms()->endoff() + 1, "missing extra input"); +- Node* valid_length_test = call->in(call->req()-1); +- call->del_req(call->req()-1); +- if (valid_length_test->find_int_con(1) == 0) { ++ Node *arg1 = call->in(TypeFunc::Parms+1); ++ if (arg1->is_Type() && ++ arg1->as_Type()->type()->join(TypeInt::POS)->empty()) { + required_outcnt--; + } +- assert(n->outcnt() == required_outcnt, "malformed control flow"); +- continue; + } + } + } +@@ -3742,14 +3739,6 @@ bool Compile::final_graph_reshaping() { + record_method_not_compilable("malformed control flow"); + return true; // Not all targets reachable! + } +- } else if (n->is_PCTable() && n->in(0) && n->in(0)->in(0) && n->in(0)->in(0)->is_Call()) { +- CallNode* call = n->in(0)->in(0)->as_Call(); +- if (call->entry_point() == OptoRuntime::new_array_Java() || +- call->entry_point() == OptoRuntime::new_array_nozero_Java()) { +- assert(call->is_CallStaticJava(), "static call expected"); +- assert(call->req() == call->jvms()->endoff() + 1, "missing extra input"); +- call->del_req(call->req()-1); // valid length test useless now +- } + } + // Check that I actually visited all kids. Unreached kids + // must be infinite loops. +--- src/hotspot/share/opto/graphKit.cpp ++++ src/hotspot/share/opto/graphKit.cpp +@@ -2593,9 +2593,7 @@ void GraphKit::make_slow_call_ex(Node* call, ciInstanceKlass* ex_klass, bool sep + // Make a catch node with just two handlers: fall-through and catch-all + Node* i_o = _gvn.transform( new ProjNode(call, TypeFunc::I_O, separate_io_proj) ); + Node* catc = _gvn.transform( new CatchNode(control(), i_o, 2) ); +- Node* norm = new CatchProjNode(catc, CatchProjNode::fall_through_index, CatchProjNode::no_handler_bci); +- _gvn.set_type_bottom(norm); +- C->record_for_igvn(norm); ++ Node* norm = _gvn.transform( new CatchProjNode(catc, CatchProjNode::fall_through_index, CatchProjNode::no_handler_bci) ); + Node* excp = _gvn.transform( new CatchProjNode(catc, CatchProjNode::catch_all_index, CatchProjNode::no_handler_bci) ); + + { PreserveJVMState pjvms(this); +@@ -3731,28 +3729,20 @@ Node* GraphKit::new_array(Node* klass_node, // array klass (maybe variable) + initial_slow_test = initial_slow_test->as_Bool()->as_int_value(&_gvn); + } + +- const TypeOopPtr* ary_type = _gvn.type(klass_node)->is_klassptr()->as_instance_type(); +- Node* valid_length_test = _gvn.intcon(1); +- if (ary_type->klass()->is_array_klass()) { +- BasicType bt = ary_type->klass()->as_array_klass()->element_type()->basic_type(); +- jint max = TypeAryPtr::max_array_length(bt); +- Node* valid_length_cmp = _gvn.transform(new CmpUNode(length, intcon(max))); +- valid_length_test = _gvn.transform(new BoolNode(valid_length_cmp, BoolTest::le)); +- } +- + // Create the AllocateArrayNode and its result projections + AllocateArrayNode* alloc + = new AllocateArrayNode(C, AllocateArrayNode::alloc_type(TypeInt::INT), + control(), mem, i_o(), + size, klass_node, + initial_slow_test, +- length, valid_length_test); ++ length); + + // Cast to correct type. Note that the klass_node may be constant or not, + // and in the latter case the actual array type will be inexact also. + // (This happens via a non-constant argument to inline_native_newArray.) + // In any case, the value of klass_node provides the desired array type. + const TypeInt* length_type = _gvn.find_int_type(length); ++ const TypeOopPtr* ary_type = _gvn.type(klass_node)->is_klassptr()->as_instance_type(); + if (ary_type->isa_aryptr() && length_type != NULL) { + // Try to get a better type than POS for the size + ary_type = ary_type->is_aryptr()->cast_to_size(length_type); +--- src/hotspot/share/opto/macro.cpp ++++ src/hotspot/share/opto/macro.cpp +@@ -1288,8 +1288,7 @@ void PhaseMacroExpand::expand_allocate_common( + AllocateNode* alloc, // allocation node to be expanded + Node* length, // array length for an array allocation + const TypeFunc* slow_call_type, // Type of slow call +- address slow_call_address, // Address of slow call +- Node* valid_length_test // whether length is valid or not ++ address slow_call_address // Address of slow call + ) + { + +@@ -1629,12 +1628,6 @@ void PhaseMacroExpand::expand_allocate_common( + // Copy debug information and adjust JVMState information, then replace + // allocate node with the call + copy_call_debug_info((CallNode *) alloc, call); +- // For array allocations, copy the valid length check to the call node so Compile::final_graph_reshaping() can verify +- // that the call has the expected number of CatchProj nodes (in case the allocation always fails and the fallthrough +- // path dies). +- if (valid_length_test != NULL) { +- call->add_req(valid_length_test); +- } + if (!always_slow) { + call->set_cnt(PROB_UNLIKELY_MAG(4)); // Same effect as RC_UNCOMMON. + } else { +@@ -1989,12 +1982,11 @@ Node* PhaseMacroExpand::prefetch_allocation(Node* i_o, Node*& needgc_false, + void PhaseMacroExpand::expand_allocate(AllocateNode *alloc) { + expand_allocate_common(alloc, NULL, + OptoRuntime::new_instance_Type(), +- OptoRuntime::new_instance_Java(), NULL); ++ OptoRuntime::new_instance_Java()); + } + + void PhaseMacroExpand::expand_allocate_array(AllocateArrayNode *alloc) { + Node* length = alloc->in(AllocateNode::ALength); +- Node* valid_length_test = alloc->in(AllocateNode::ValidLengthTest); + InitializeNode* init = alloc->initialization(); + Node* klass_node = alloc->in(AllocateNode::KlassNode); + ciKlass* k = _igvn.type(klass_node)->is_klassptr()->klass(); +@@ -2009,7 +2001,7 @@ void PhaseMacroExpand::expand_allocate_array(AllocateArrayNode *alloc) { + } + expand_allocate_common(alloc, length, + OptoRuntime::new_array_Type(), +- slow_call_address, valid_length_test); ++ slow_call_address); + } + + //-------------------mark_eliminated_box---------------------------------- +--- src/hotspot/share/opto/macro.hpp ++++ src/hotspot/share/opto/macro.hpp +@@ -98,8 +98,7 @@ private: + void expand_allocate_common(AllocateNode* alloc, + Node* length, + const TypeFunc* slow_call_type, +- address slow_call_address, +- Node* valid_length_test); ++ address slow_call_address); + Node *value_from_mem(Node *mem, Node *ctl, BasicType ft, const Type *ftype, const TypeOopPtr *adr_t, AllocateNode *alloc); + Node *value_from_mem_phi(Node *mem, BasicType ft, const Type *ftype, const TypeOopPtr *adr_t, AllocateNode *alloc, Node_Stack *value_phis, int level); + +--- src/hotspot/share/opto/split_if.cpp ++++ src/hotspot/share/opto/split_if.cpp +@@ -128,8 +128,8 @@ bool PhaseIdealLoop::split_up( Node *n, Node *blk1, Node *blk2 ) { + } + } else { + // We might see an Opaque1 from a loop limit check here +- assert(use->is_If() || use->is_CMove() || use->Opcode() == Op_Opaque1 || use->is_AllocateArray(), "unexpected node type"); +- Node *use_c = (use->is_If() || use->is_AllocateArray()) ? use->in(0) : get_ctrl(use); ++ assert(use->is_If() || use->is_CMove() || use->Opcode() == Op_Opaque1, "unexpected node type"); ++ Node *use_c = use->is_If() ? use->in(0) : get_ctrl(use); + if (use_c == blk1 || use_c == blk2) { + assert(use->is_CMove(), "unexpected node type"); + continue; +@@ -166,15 +166,14 @@ bool PhaseIdealLoop::split_up( Node *n, Node *blk1, Node *blk2 ) { + --j; + } else { + // We might see an Opaque1 from a loop limit check here +- assert(u->is_If() || u->is_CMove() || u->Opcode() == Op_Opaque1 || u->is_AllocateArray(), "unexpected node type"); +- assert(u->is_AllocateArray() || u->in(1) == bol, ""); +- assert(!u->is_AllocateArray() || u->in(AllocateNode::ValidLengthTest) == bol, "wrong input to AllocateArray"); ++ assert(u->is_If() || u->is_CMove() || u->Opcode() == Op_Opaque1, "unexpected node type"); ++ assert(u->in(1) == bol, ""); + // Get control block of either the CMove or the If input +- Node *u_ctrl = (u->is_If() || u->is_AllocateArray()) ? u->in(0) : get_ctrl(u); ++ Node *u_ctrl = u->is_If() ? u->in(0) : get_ctrl(u); + assert((u_ctrl != blk1 && u_ctrl != blk2) || u->is_CMove(), "won't converge"); + Node *x = bol->clone(); + register_new_node(x, u_ctrl); +- _igvn.replace_input_of(u, u->is_AllocateArray() ? AllocateNode::ValidLengthTest : 1, x); ++ _igvn.replace_input_of(u, 1, x); + --j; + } + } +--- test/hotspot/jtreg/compiler/allocation/TestAllocArrayAfterAllocNoUse.java ++++ /dev/null +@@ -1,52 +0,0 @@ +-/* +- * Copyright (c) 2022, Red Hat, Inc. All rights reserved. +- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +- * +- * This code is free software; you can redistribute it and/or modify it +- * under the terms of the GNU General Public License version 2 only, as +- * published by the Free Software Foundation. +- * +- * This code is distributed in the hope that it will be useful, but WITHOUT +- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +- * version 2 for more details (a copy is included in the LICENSE file that +- * accompanied this code). +- * +- * You should have received a copy of the GNU General Public License version +- * 2 along with this work; if not, write to the Free Software Foundation, +- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +- * +- * Please contact 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 8279125 +- * @summary fatal error: no reachable node should have no use +- * @requires vm.flavor == "server" +- * +- * @run main/othervm -XX:-BackgroundCompilation -XX:-DoEscapeAnalysis TestAllocArrayAfterAllocNoUse +- * +- */ +- +-public class TestAllocArrayAfterAllocNoUse { +- private static Object field; +- +- public static void main(String[] args) { +- for (int i = 0; i < 20_000; i++) { +- test(); +- } +- } +- +- private static void test() { +- try { +- final TestAllocArrayAfterAllocNoUse o = new TestAllocArrayAfterAllocNoUse(); +- } catch (Exception e) { +- final int[] array = new int[100]; +- field = array; +- } +- +- } +-} +--- test/hotspot/jtreg/compiler/allocation/TestCCPAllocateArray.java ++++ /dev/null +@@ -1,53 +0,0 @@ +-/* +- * Copyright (c) 2022, Red Hat, Inc. All rights reserved. +- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +- * +- * This code is free software; you can redistribute it and/or modify it +- * under the terms of the GNU General Public License version 2 only, as +- * published by the Free Software Foundation. +- * +- * This code is distributed in the hope that it will be useful, but WITHOUT +- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +- * version 2 for more details (a copy is included in the LICENSE file that +- * accompanied this code). +- * +- * You should have received a copy of the GNU General Public License version +- * 2 along with this work; if not, write to the Free Software Foundation, +- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +- * +- * Please contact 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 8279062 +- * @summary C2: assert(t->meet(t0) == t) failed: Not monotonic after JDK-8278413 +- * +- * @run main/othervm -XX:-BackgroundCompilation TestCCPAllocateArray +- * +- */ +- +-public class TestCCPAllocateArray { +- public static void main(String[] args) { +- for (int i = 0; i < 20_000; i++) { +- try { +- test(); +- } catch (OutOfMemoryError e) { +- } +- length(42); +- } +- } +- +- private static int[] test() { +- int i = 2; +- for (; i < 4; i *= 2); +- return new int[length(i)]; +- } +- +- private static int length(int i) { +- return i == 4 ? Integer.MAX_VALUE : 0; +- } +-} +--- test/hotspot/jtreg/compiler/allocation/TestFailedAllocationBadGraph.java ++++ /dev/null +@@ -1,80 +0,0 @@ +-/* +- * Copyright (c) 2022, Red Hat, Inc. All rights reserved. +- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +- * +- * This code is free software; you can redistribute it and/or modify it +- * under the terms of the GNU General Public License version 2 only, as +- * published by the Free Software Foundation. +- * +- * This code is distributed in the hope that it will be useful, but WITHOUT +- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +- * version 2 for more details (a copy is included in the LICENSE file that +- * accompanied this code). +- * +- * You should have received a copy of the GNU General Public License version +- * 2 along with this work; if not, write to the Free Software Foundation, +- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +- * +- * Please contact 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 8279219 +- * @summary C2 crash when allocating array of size too large +- * @requires vm.compiler2.enabled +- * @library /test/lib / +- * @build sun.hotspot.WhiteBox +- * @run driver ClassFileInstaller sun.hotspot.WhiteBox +- * @run main/othervm -ea -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -XX:-BackgroundCompilation TestFailedAllocationBadGraph +- */ +- +-import sun.hotspot.WhiteBox; +-import java.lang.reflect.Method; +-import compiler.whitebox.CompilerWhiteBoxTest; +- +-public class TestFailedAllocationBadGraph { +- private static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox(); +- +- private static long[] array; +- private static int field; +- private static volatile int barrier; +- +- public static void main(String[] args) throws Exception { +- run("test1"); +- run("test2"); +- } +- +- private static void run(String method) throws Exception { +- Method m = TestFailedAllocationBadGraph.class.getDeclaredMethod(method); +- WHITE_BOX.enqueueMethodForCompilation(m, CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION); +- if (!WHITE_BOX.isMethodCompiled(m) || WHITE_BOX.getMethodCompilationLevel(m) != CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION) { +- throw new RuntimeException("should still be compiled"); +- } +- } +- +- private static int test1() { +- int length = Integer.MAX_VALUE; +- try { +- array = new long[length]; +- } catch (OutOfMemoryError outOfMemoryError) { +- barrier = 0x42; +- length = field; +- } +- return length; +- } +- +- private static int test2() { +- int length = -1; +- try { +- array = new long[length]; +- } catch (OutOfMemoryError outOfMemoryError) { +- barrier = 0x42; +- length = field; +- } +- return length; +- } +-}
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?202209252307.28PN7NAx016588>