infernap12/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2026-08-03 06:35:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove the parameter again

Browse Source
This commit is contained in:
Marc Chevalier 2026-07-16 13:30:17 +02:00
parent a1f22fd38c
commit fe5bcdcbad
3 changed files with 11 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/hotspot/share/opto/graphKit.cpp
View File

@ -4021,7 +4021,9 @@ Node* GraphKit::atomic_layout_array_test_and_get_layout_kind(Node* array, Region
}
// Deoptimize if 'ary' is a null-free inline type array and 'val' is null
Node* GraphKit::inline_array_null_guard(Node* ary, Node* val, int nargs, bool safe_for_replace) {
// Return `ary` as nullable if `val` is statically known to be null. Beware
// it will also replace_in_map `ary` with the casted version.
Node* GraphKit::inline_array_null_guard(Node* ary, Node* val, int nargs) {
RegionNode* region = new RegionNode(3);
Node* null_ctl = top();
null_check_oop(val, &null_ctl);
@ -4045,9 +4047,7 @@ Node* GraphKit::inline_array_null_guard(Node* ary, Node* val, int nargs, bool sa
const TypeAryPtr* ary_t = _gvn.type(ary)->is_aryptr();
ary_t = ary_t->cast_to_not_null_free();
Node* cast = _gvn.transform(new CheckCastPPNode(control(), ary, ary_t));
if (safe_for_replace) {
replace_in_map(ary, cast);
}
replace_in_map(ary, cast);
ary = cast;
}
return ary;

2
src/hotspot/share/opto/graphKit.hpp
View File

@ -842,7 +842,7 @@ class GraphKit : public Phase {
Node* null_free_array_test(Node* array, bool null_free = true);
Node* null_free_atomic_array_test(Node* array, ciInlineKlass* vk);
Node* atomic_layout_array_test_and_get_layout_kind(Node* array, RegionNode* atomic_region);
Node* inline_array_null_guard(Node* ary, Node* val, int nargs, bool safe_for_replace);
Node* inline_array_null_guard(Node* ary, Node* val, int nargs);
Node* gen_subtype_check(Node* obj, Node* superklass);

29
src/hotspot/share/opto/parse2.cpp
View File

@ -253,41 +253,24 @@ void Parse::array_store(BasicType bt) {
// Array might be a flat array, emit runtime checks (for null, a simple inline_array_null_guard is sufficient).
assert(UseArrayFlattening && !not_flat && elemtype->is_oopptr()->can_be_inline_type() &&
(!array_type->klass_is_exact() || array_type->is_flat()), "array can't be a flat array");
// If the array cannot be flat and null-free, we don't need to do inline_array_null_guard
// in the flat branch under. In this case, the flat branch is thus a bit faster, but the
// non-flat branch always need to be protected. If the array can be both flat and null-free,
// we just do the inline_array_null_guard guard the flat/non-flat branching so we don't
// duplicate it.
bool can_be_flat_and_null_free =
!elemtype->is_inlinetypeptr() // Can't tell statically whether it's possible, so we must soundly assume so
|| elemtype->inline_klass()->has_null_free_atomic_layout()
|| elemtype->inline_klass()->has_null_free_non_atomic_layout();
if (can_be_flat_and_null_free) {
array = inline_array_null_guard(array, stored_value_casted, 3, true);
array_type = _gvn.type(array)->is_aryptr();
}
// TODO 8350865 Depending on the available layouts, we can avoid this check in below flat/not-flat branches. Also the safe_for_replace arg is now always true.
array = inline_array_null_guard(array, stored_value_casted, 3);
// Reload array type which could have been updated by inline_array_null_guard().
array_type = _gvn.type(array)->is_aryptr();
IdealKit ideal(this);
ideal.if_then(flat_array_test(array, /* flat = */ false)); {
// Non-flat array
if (!array_type->is_flat()) {
sync_kit(ideal);
Node* array_ = array;
const TypeAryPtr* array_type_ = array_type;
if (!can_be_flat_and_null_free) {
array_ = inline_array_null_guard(array_, stored_value_casted, 3, false);
array_type_ = _gvn.type(array_)->is_aryptr();
}
assert(array_type_->is_not_flat() || ideal.ctrl()->in(0)->as_If()->is_flat_array_check(&_gvn), "Should be found");
assert(array_type->is_not_flat() || ideal.ctrl()->in(0)->as_If()->is_flat_array_check(&_gvn), "Should be found");
inc_sp(3);
access_store_at(array_, adr, adr_type, stored_value_casted, elemtype, bt, MO_UNORDERED | IN_HEAP | IS_ARRAY, false);
access_store_at(array, adr, adr_type, stored_value_casted, elemtype, bt, MO_UNORDERED | IN_HEAP | IS_ARRAY, false);
dec_sp(3);
ideal.sync_kit(this);
}
} ideal.else_(); {
// Flat array
sync_kit(ideal);
// Either array can be null-free and flat, and inline_array_null_guard is done above, or it cannot, and we don't need to perform this check.
if (!array_type->is_not_flat()) {
// Try to determine the inline klass type of the stored value
ciInlineKlass* vk = nullptr;
@ -325,7 +308,7 @@ void Parse::array_store(BasicType bt) {
} else if (!array_type->is_not_null_free()) {
// Array is not flat but may be null free
assert(elemtype->is_oopptr()->can_be_inline_type(), "array can't be null-free");
array = inline_array_null_guard(array, stored_value_casted, 3, true);
array = inline_array_null_guard(array, stored_value_casted, 3);
}
}
inc_sp(3);