Skip to content

Commit 45e4e00

Browse files
TobiHartmannTobiHartmann
committed
8300079: SIGSEGV in LibraryCallKit::inline_string_copy due to constant NULL src argument
Reviewed-by: roland, chagedorn, kvn
1 parent 030b071 commit 45e4e00

File tree

2 files changed

+154
-124
lines changed

2 files changed

+154
-124
lines changed

‎src/hotspot/share/opto/library_call.cpp

+96-124
Original file line numberDiff line numberDiff line change
@@ -1365,10 +1365,13 @@ bool LibraryCallKit::inline_string_copy(bool compress) {
13651365
AllocateArrayNode* alloc = tightly_coupled_allocation(dst);
13661366

13671367
// Figure out the size and type of the elements we will be copying.
1368-
const Type* src_type = src->Value(&_gvn);
1369-
const Type* dst_type = dst->Value(&_gvn);
1370-
BasicType src_elem = src_type->isa_aryptr()->elem()->array_element_basic_type();
1371-
BasicType dst_elem = dst_type->isa_aryptr()->elem()->array_element_basic_type();
1368+
const TypeAryPtr* src_type = src->Value(&_gvn)->isa_aryptr();
1369+
const TypeAryPtr* dst_type = dst->Value(&_gvn)->isa_aryptr();
1370+
if (src_type == nullptr || dst_type == nullptr) {
1371+
return false;
1372+
}
1373+
BasicType src_elem = src_type->elem()->array_element_basic_type();
1374+
BasicType dst_elem = dst_type->elem()->array_element_basic_type();
13721375
assert((compress && dst_elem == T_BYTE && (src_elem == T_BYTE || src_elem == T_CHAR)) ||
13731376
(!compress && src_elem == T_BYTE && (dst_elem == T_BYTE || dst_elem == T_CHAR)),
13741377
"Unsupported array types for inline_string_copy");
@@ -5386,19 +5389,17 @@ bool LibraryCallKit::inline_encodeISOArray(bool ascii) {
53865389
src = must_be_not_null(src, true);
53875390
dst = must_be_not_null(dst, true);
53885391

5389-
const Type* src_type = src->Value(&_gvn);
5390-
const Type* dst_type = dst->Value(&_gvn);
5391-
const TypeAryPtr* top_src = src_type->isa_aryptr();
5392-
const TypeAryPtr* top_dest = dst_type->isa_aryptr();
5393-
if (top_src == NULL || top_src->elem() == Type::BOTTOM ||
5394-
top_dest == NULL || top_dest->elem() == Type::BOTTOM) {
5392+
const TypeAryPtr* src_type = src->Value(&_gvn)->isa_aryptr();
5393+
const TypeAryPtr* dst_type = dst->Value(&_gvn)->isa_aryptr();
5394+
if (src_type == nullptr || src_type->elem() == Type::BOTTOM ||
5395+
dst_type == nullptr || dst_type->elem() == Type::BOTTOM) {
53955396
// failed array check
53965397
return false;
53975398
}
53985399

53995400
// Figure out the size and type of the elements we will be copying.
5400-
BasicType src_elem = src_type->isa_aryptr()->elem()->array_element_basic_type();
5401-
BasicType dst_elem = dst_type->isa_aryptr()->elem()->array_element_basic_type();
5401+
BasicType src_elem = src_type->elem()->array_element_basic_type();
5402+
BasicType dst_elem = dst_type->elem()->array_element_basic_type();
54025403
if (!((src_elem == T_CHAR) || (src_elem== T_BYTE)) || dst_elem != T_BYTE) {
54035404
return false;
54045405
}
@@ -5441,18 +5442,16 @@ bool LibraryCallKit::inline_multiplyToLen() {
54415442
x = must_be_not_null(x, true);
54425443
y = must_be_not_null(y, true);
54435444

5444-
const Type* x_type = x->Value(&_gvn);
5445-
const Type* y_type = y->Value(&_gvn);
5446-
const TypeAryPtr* top_x = x_type->isa_aryptr();
5447-
const TypeAryPtr* top_y = y_type->isa_aryptr();
5448-
if (top_x == NULL || top_x->elem() == Type::BOTTOM ||
5449-
top_y == NULL || top_y->elem() == Type::BOTTOM) {
5445+
const TypeAryPtr* x_type = x->Value(&_gvn)->isa_aryptr();
5446+
const TypeAryPtr* y_type = y->Value(&_gvn)->isa_aryptr();
5447+
if (x_type == nullptr || x_type->elem() == Type::BOTTOM ||
5448+
y_type == nullptr || y_type->elem() == Type::BOTTOM) {
54505449
// failed array check
54515450
return false;
54525451
}
54535452

5454-
BasicType x_elem = x_type->isa_aryptr()->elem()->array_element_basic_type();
5455-
BasicType y_elem = y_type->isa_aryptr()->elem()->array_element_basic_type();
5453+
BasicType x_elem = x_type->elem()->array_element_basic_type();
5454+
BasicType y_elem = y_type->elem()->array_element_basic_type();
54565455
if (x_elem != T_INT || y_elem != T_INT) {
54575456
return false;
54585457
}
@@ -5549,18 +5548,16 @@ bool LibraryCallKit::inline_squareToLen() {
55495548
x = must_be_not_null(x, true);
55505549
z = must_be_not_null(z, true);
55515550

5552-
const Type* x_type = x->Value(&_gvn);
5553-
const Type* z_type = z->Value(&_gvn);
5554-
const TypeAryPtr* top_x = x_type->isa_aryptr();
5555-
const TypeAryPtr* top_z = z_type->isa_aryptr();
5556-
if (top_x == NULL || top_x->elem() == Type::BOTTOM ||
5557-
top_z == NULL || top_z->elem() == Type::BOTTOM) {
5551+
const TypeAryPtr* x_type = x->Value(&_gvn)->isa_aryptr();
5552+
const TypeAryPtr* z_type = z->Value(&_gvn)->isa_aryptr();
5553+
if (x_type == nullptr || x_type->elem() == Type::BOTTOM ||
5554+
z_type == nullptr || z_type->elem() == Type::BOTTOM) {
55585555
// failed array check
55595556
return false;
55605557
}
55615558

5562-
BasicType x_elem = x_type->isa_aryptr()->elem()->array_element_basic_type();
5563-
BasicType z_elem = z_type->isa_aryptr()->elem()->array_element_basic_type();
5559+
BasicType x_elem = x_type->elem()->array_element_basic_type();
5560+
BasicType z_elem = z_type->elem()->array_element_basic_type();
55645561
if (x_elem != T_INT || z_elem != T_INT) {
55655562
return false;
55665563
}
@@ -5596,20 +5593,19 @@ bool LibraryCallKit::inline_mulAdd() {
55965593
Node* len = argument(3);
55975594
Node* k = argument(4);
55985595

5596+
in = must_be_not_null(in, true);
55995597
out = must_be_not_null(out, true);
56005598

5601-
const Type* out_type = out->Value(&_gvn);
5602-
const Type* in_type = in->Value(&_gvn);
5603-
const TypeAryPtr* top_out = out_type->isa_aryptr();
5604-
const TypeAryPtr* top_in = in_type->isa_aryptr();
5605-
if (top_out == NULL || top_out->elem() == Type::BOTTOM ||
5606-
top_in == NULL || top_in->elem() == Type::BOTTOM) {
5599+
const TypeAryPtr* out_type = out->Value(&_gvn)->isa_aryptr();
5600+
const TypeAryPtr* in_type = in->Value(&_gvn)->isa_aryptr();
5601+
if (out_type == nullptr || out_type->elem() == Type::BOTTOM ||
5602+
in_type == nullptr || in_type->elem() == Type::BOTTOM) {
56075603
// failed array check
56085604
return false;
56095605
}
56105606

5611-
BasicType out_elem = out_type->isa_aryptr()->elem()->array_element_basic_type();
5612-
BasicType in_elem = in_type->isa_aryptr()->elem()->array_element_basic_type();
5607+
BasicType out_elem = out_type->elem()->array_element_basic_type();
5608+
BasicType in_elem = in_type->elem()->array_element_basic_type();
56135609
if (out_elem != T_INT || in_elem != T_INT) {
56145610
return false;
56155611
}
@@ -5647,26 +5643,22 @@ bool LibraryCallKit::inline_montgomeryMultiply() {
56475643
Node* inv = argument(4);
56485644
Node* m = argument(6);
56495645

5650-
const Type* a_type = a->Value(&_gvn);
5651-
const TypeAryPtr* top_a = a_type->isa_aryptr();
5652-
const Type* b_type = b->Value(&_gvn);
5653-
const TypeAryPtr* top_b = b_type->isa_aryptr();
5654-
const Type* n_type = a->Value(&_gvn);
5655-
const TypeAryPtr* top_n = n_type->isa_aryptr();
5656-
const Type* m_type = a->Value(&_gvn);
5657-
const TypeAryPtr* top_m = m_type->isa_aryptr();
5658-
if (top_a == NULL || top_a->elem() == Type::BOTTOM ||
5659-
top_b == NULL || top_b->elem() == Type::BOTTOM ||
5660-
top_n == NULL || top_n->elem() == Type::BOTTOM ||
5661-
top_m == NULL || top_m->elem() == Type::BOTTOM) {
5646+
const TypeAryPtr* a_type = a->Value(&_gvn)->isa_aryptr();
5647+
const TypeAryPtr* b_type = b->Value(&_gvn)->isa_aryptr();
5648+
const TypeAryPtr* n_type = n->Value(&_gvn)->isa_aryptr();
5649+
const TypeAryPtr* m_type = m->Value(&_gvn)->isa_aryptr();
5650+
if (a_type == nullptr || a_type->elem() == Type::BOTTOM ||
5651+
b_type == nullptr || b_type->elem() == Type::BOTTOM ||
5652+
n_type == nullptr || n_type->elem() == Type::BOTTOM ||
5653+
m_type == nullptr || m_type->elem() == Type::BOTTOM) {
56625654
// failed array check
56635655
return false;
56645656
}
56655657

5666-
BasicType a_elem = a_type->isa_aryptr()->elem()->array_element_basic_type();
5667-
BasicType b_elem = b_type->isa_aryptr()->elem()->array_element_basic_type();
5668-
BasicType n_elem = n_type->isa_aryptr()->elem()->array_element_basic_type();
5669-
BasicType m_elem = m_type->isa_aryptr()->elem()->array_element_basic_type();
5658+
BasicType a_elem = a_type->elem()->array_element_basic_type();
5659+
BasicType b_elem = b_type->elem()->array_element_basic_type();
5660+
BasicType n_elem = n_type->elem()->array_element_basic_type();
5661+
BasicType m_elem = m_type->elem()->array_element_basic_type();
56705662
if (a_elem != T_INT || b_elem != T_INT || n_elem != T_INT || m_elem != T_INT) {
56715663
return false;
56725664
}
@@ -5706,22 +5698,19 @@ bool LibraryCallKit::inline_montgomerySquare() {
57065698
Node* inv = argument(3);
57075699
Node* m = argument(5);
57085700

5709-
const Type* a_type = a->Value(&_gvn);
5710-
const TypeAryPtr* top_a = a_type->isa_aryptr();
5711-
const Type* n_type = a->Value(&_gvn);
5712-
const TypeAryPtr* top_n = n_type->isa_aryptr();
5713-
const Type* m_type = a->Value(&_gvn);
5714-
const TypeAryPtr* top_m = m_type->isa_aryptr();
5715-
if (top_a == NULL || top_a->elem() == Type::BOTTOM ||
5716-
top_n == NULL || top_n->elem() == Type::BOTTOM ||
5717-
top_m == NULL || top_m->elem() == Type::BOTTOM) {
5701+
const TypeAryPtr* a_type = a->Value(&_gvn)->isa_aryptr();
5702+
const TypeAryPtr* n_type = n->Value(&_gvn)->isa_aryptr();
5703+
const TypeAryPtr* m_type = m->Value(&_gvn)->isa_aryptr();
5704+
if (a_type == nullptr || a_type->elem() == Type::BOTTOM ||
5705+
n_type == nullptr || n_type->elem() == Type::BOTTOM ||
5706+
m_type == nullptr || m_type->elem() == Type::BOTTOM) {
57185707
// failed array check
57195708
return false;
57205709
}
57215710

5722-
BasicType a_elem = a_type->isa_aryptr()->elem()->array_element_basic_type();
5723-
BasicType n_elem = n_type->isa_aryptr()->elem()->array_element_basic_type();
5724-
BasicType m_elem = m_type->isa_aryptr()->elem()->array_element_basic_type();
5711+
BasicType a_elem = a_type->elem()->array_element_basic_type();
5712+
BasicType n_elem = n_type->elem()->array_element_basic_type();
5713+
BasicType m_elem = m_type->elem()->array_element_basic_type();
57255714
if (a_elem != T_INT || n_elem != T_INT || m_elem != T_INT) {
57265715
return false;
57275716
}
@@ -5762,17 +5751,15 @@ bool LibraryCallKit::inline_bigIntegerShift(bool isRightShift) {
57625751
Node* shiftCount = argument(3);
57635752
Node* numIter = argument(4);
57645753

5765-
const Type* newArr_type = newArr->Value(&_gvn);
5766-
const TypeAryPtr* top_newArr = newArr_type->isa_aryptr();
5767-
const Type* oldArr_type = oldArr->Value(&_gvn);
5768-
const TypeAryPtr* top_oldArr = oldArr_type->isa_aryptr();
5769-
if (top_newArr == NULL || top_newArr->elem() == Type::BOTTOM || top_oldArr == NULL
5770-
|| top_oldArr->elem() == Type::BOTTOM) {
5754+
const TypeAryPtr* newArr_type = newArr->Value(&_gvn)->isa_aryptr();
5755+
const TypeAryPtr* oldArr_type = oldArr->Value(&_gvn)->isa_aryptr();
5756+
if (newArr_type == nullptr || newArr_type->elem() == Type::BOTTOM ||
5757+
oldArr_type == nullptr || oldArr_type->elem() == Type::BOTTOM) {
57715758
return false;
57725759
}
57735760

5774-
BasicType newArr_elem = newArr_type->isa_aryptr()->elem()->array_element_basic_type();
5775-
BasicType oldArr_elem = oldArr_type->isa_aryptr()->elem()->array_element_basic_type();
5761+
BasicType newArr_elem = newArr_type->elem()->array_element_basic_type();
5762+
BasicType oldArr_elem = oldArr_type->elem()->array_element_basic_type();
57765763
if (newArr_elem != T_INT || oldArr_elem != T_INT) {
57775764
return false;
57785765
}
@@ -6009,15 +5996,14 @@ bool LibraryCallKit::inline_updateBytesCRC32() {
60095996
Node* offset = argument(2); // type: int
60105997
Node* length = argument(3); // type: int
60115998

6012-
const Type* src_type = src->Value(&_gvn);
6013-
const TypeAryPtr* top_src = src_type->isa_aryptr();
6014-
if (top_src == NULL || top_src->elem() == Type::BOTTOM) {
5999+
const TypeAryPtr* src_type = src->Value(&_gvn)->isa_aryptr();
6000+
if (src_type == nullptr || src_type->elem() == Type::BOTTOM) {
60156001
// failed array check
60166002
return false;
60176003
}
60186004

60196005
// Figure out the size and type of the elements we will be copying.
6020-
BasicType src_elem = src_type->isa_aryptr()->elem()->array_element_basic_type();
6006+
BasicType src_elem = src_type->elem()->array_element_basic_type();
60216007
if (src_elem != T_BYTE) {
60226008
return false;
60236009
}
@@ -6098,15 +6084,14 @@ bool LibraryCallKit::inline_updateBytesCRC32C() {
60986084

60996085
Node* length = _gvn.transform(new SubINode(end, offset));
61006086

6101-
const Type* src_type = src->Value(&_gvn);
6102-
const TypeAryPtr* top_src = src_type->isa_aryptr();
6103-
if (top_src == NULL || top_src->elem() == Type::BOTTOM) {
6087+
const TypeAryPtr* src_type = src->Value(&_gvn)->isa_aryptr();
6088+
if (src_type == nullptr || src_type->elem() == Type::BOTTOM) {
61046089
// failed array check
61056090
return false;
61066091
}
61076092

61086093
// Figure out the size and type of the elements we will be copying.
6109-
BasicType src_elem = src_type->isa_aryptr()->elem()->array_element_basic_type();
6094+
BasicType src_elem = src_type->elem()->array_element_basic_type();
61106095
if (src_elem != T_BYTE) {
61116096
return false;
61126097
}
@@ -6191,15 +6176,14 @@ bool LibraryCallKit::inline_updateBytesAdler32() {
61916176
Node* offset = argument(2); // type: int
61926177
Node* length = argument(3); // type: int
61936178

6194-
const Type* src_type = src->Value(&_gvn);
6195-
const TypeAryPtr* top_src = src_type->isa_aryptr();
6196-
if (top_src == NULL || top_src->elem() == Type::BOTTOM) {
6179+
const TypeAryPtr* src_type = src->Value(&_gvn)->isa_aryptr();
6180+
if (src_type == nullptr || src_type->elem() == Type::BOTTOM) {
61976181
// failed array check
61986182
return false;
61996183
}
62006184

62016185
// Figure out the size and type of the elements we will be copying.
6202-
BasicType src_elem = src_type->isa_aryptr()->elem()->array_element_basic_type();
6186+
BasicType src_elem = src_type->elem()->array_element_basic_type();
62036187
if (src_elem != T_BYTE) {
62046188
return false;
62056189
}
@@ -6433,11 +6417,10 @@ bool LibraryCallKit::inline_aescrypt_Block(vmIntrinsics::ID id) {
64336417
dest = must_be_not_null(dest, true);
64346418

64356419
// (1) src and dest are arrays.
6436-
const Type* src_type = src->Value(&_gvn);
6437-
const Type* dest_type = dest->Value(&_gvn);
6438-
const TypeAryPtr* top_src = src_type->isa_aryptr();
6439-
const TypeAryPtr* top_dest = dest_type->isa_aryptr();
6440-
assert (top_src != NULL && top_src->elem() != Type::BOTTOM && top_dest != NULL && top_dest->elem() != Type::BOTTOM, "args are strange");
6420+
const TypeAryPtr* src_type = src->Value(&_gvn)->isa_aryptr();
6421+
const TypeAryPtr* dest_type = dest->Value(&_gvn)->isa_aryptr();
6422+
assert( src_type != nullptr && src_type->elem() != Type::BOTTOM &&
6423+
dest_type != nullptr && dest_type->elem() != Type::BOTTOM, "args are strange");
64416424

64426425
// for the quick and dirty code we will skip all the checks.
64436426
// we are just trying to get the call to be generated.
@@ -6494,12 +6477,10 @@ bool LibraryCallKit::inline_cipherBlockChaining_AESCrypt(vmIntrinsics::ID id) {
64946477
dest = must_be_not_null(dest, false);
64956478

64966479
// (1) src and dest are arrays.
6497-
const Type* src_type = src->Value(&_gvn);
6498-
const Type* dest_type = dest->Value(&_gvn);
6499-
const TypeAryPtr* top_src = src_type->isa_aryptr();
6500-
const TypeAryPtr* top_dest = dest_type->isa_aryptr();
6501-
assert (top_src != NULL && top_src->elem() != Type::BOTTOM
6502-
&& top_dest != NULL && top_dest->elem() != Type::BOTTOM, "args are strange");
6480+
const TypeAryPtr* src_type = src->Value(&_gvn)->isa_aryptr();
6481+
const TypeAryPtr* dest_type = dest->Value(&_gvn)->isa_aryptr();
6482+
assert( src_type != nullptr && src_type->elem() != Type::BOTTOM &&
6483+
dest_type != nullptr && dest_type->elem() != Type::BOTTOM, "args are strange");
65036484

65046485
// checks are the responsibility of the caller
65056486
Node* src_start = src;
@@ -6582,12 +6563,10 @@ bool LibraryCallKit::inline_electronicCodeBook_AESCrypt(vmIntrinsics::ID id) {
65826563
Node* dest_offset = argument(5);
65836564

65846565
// (1) src and dest are arrays.
6585-
const Type* src_type = src->Value(&_gvn);
6586-
const Type* dest_type = dest->Value(&_gvn);
6587-
const TypeAryPtr* top_src = src_type->isa_aryptr();
6588-
const TypeAryPtr* top_dest = dest_type->isa_aryptr();
6589-
assert(top_src != NULL && top_src->elem() != Type::BOTTOM
6590-
&& top_dest != NULL && top_dest->elem() != Type::BOTTOM, "args are strange");
6566+
const TypeAryPtr* src_type = src->Value(&_gvn)->isa_aryptr();
6567+
const TypeAryPtr* dest_type = dest->Value(&_gvn)->isa_aryptr();
6568+
assert( src_type != nullptr && src_type->elem() != Type::BOTTOM &&
6569+
dest_type != nullptr && dest_type->elem() != Type::BOTTOM, "args are strange");
65916570

65926571
// checks are the responsibility of the caller
65936572
Node* src_start = src;
@@ -6656,12 +6635,10 @@ bool LibraryCallKit::inline_counterMode_AESCrypt(vmIntrinsics::ID id) {
66566635
Node* dest_offset = argument(5);
66576636

66586637
// (1) src and dest are arrays.
6659-
const Type* src_type = src->Value(&_gvn);
6660-
const Type* dest_type = dest->Value(&_gvn);
6661-
const TypeAryPtr* top_src = src_type->isa_aryptr();
6662-
const TypeAryPtr* top_dest = dest_type->isa_aryptr();
6663-
assert(top_src != NULL && top_src->elem() != Type::BOTTOM &&
6664-
top_dest != NULL && top_dest->elem() != Type::BOTTOM, "args are strange");
6638+
const TypeAryPtr* src_type = src->Value(&_gvn)->isa_aryptr();
6639+
const TypeAryPtr* dest_type = dest->Value(&_gvn)->isa_aryptr();
6640+
assert( src_type != nullptr && src_type->elem() != Type::BOTTOM &&
6641+
dest_type != nullptr && dest_type->elem() != Type::BOTTOM, "args are strange");
66656642

66666643
// checks are the responsibility of the caller
66676644
Node* src_start = src;
@@ -7095,14 +7072,13 @@ bool LibraryCallKit::inline_digestBase_implCompress(vmIntrinsics::ID id) {
70957072
Node* src = argument(1); // type oop
70967073
Node* ofs = argument(2); // type int
70977074

7098-
const Type* src_type = src->Value(&_gvn);
7099-
const TypeAryPtr* top_src = src_type->isa_aryptr();
7100-
if (top_src == NULL || top_src->elem() == Type::BOTTOM) {
7075+
const TypeAryPtr* src_type = src->Value(&_gvn)->isa_aryptr();
7076+
if (src_type == nullptr || src_type->elem() == Type::BOTTOM) {
71017077
// failed array check
71027078
return false;
71037079
}
71047080
// Figure out the size and type of the elements we will be copying.
7105-
BasicType src_elem = src_type->isa_aryptr()->elem()->array_element_basic_type();
7081+
BasicType src_elem = src_type->elem()->array_element_basic_type();
71067082
if (src_elem != T_BYTE) {
71077083
return false;
71087084
}
@@ -7187,14 +7163,13 @@ bool LibraryCallKit::inline_digestBase_implCompressMB(int predicate) {
71877163
Node* ofs = argument(2); // type int
71887164
Node* limit = argument(3); // type int
71897165

7190-
const Type* src_type = src->Value(&_gvn);
7191-
const TypeAryPtr* top_src = src_type->isa_aryptr();
7192-
if (top_src == NULL || top_src->elem() == Type::BOTTOM) {
7166+
const TypeAryPtr* src_type = src->Value(&_gvn)->isa_aryptr();
7167+
if (src_type == nullptr || src_type->elem() == Type::BOTTOM) {
71937168
// failed array check
71947169
return false;
71957170
}
71967171
// Figure out the size and type of the elements we will be copying.
7197-
BasicType src_elem = src_type->isa_aryptr()->elem()->array_element_basic_type();
7172+
BasicType src_elem = src_type->elem()->array_element_basic_type();
71987173
if (src_elem != T_BYTE) {
71997174
return false;
72007175
}
@@ -7325,15 +7300,12 @@ bool LibraryCallKit::inline_galoisCounterMode_AESCrypt() {
73257300
Node* ghash_object = argument(8);
73267301

73277302
// (1) in, ct and out are arrays.
7328-
const Type* in_type = in->Value(&_gvn);
7329-
const Type* ct_type = ct->Value(&_gvn);
7330-
const Type* out_type = out->Value(&_gvn);
7331-
const TypeAryPtr* top_in = in_type->isa_aryptr();
7332-
const TypeAryPtr* top_ct = ct_type->isa_aryptr();
7333-
const TypeAryPtr* top_out = out_type->isa_aryptr();
7334-
assert(top_in != NULL && top_in->elem() != Type::BOTTOM &&
7335-
top_ct != NULL && top_ct->elem() != Type::BOTTOM &&
7336-
top_out != NULL && top_out->elem() != Type::BOTTOM, "args are strange");
7303+
const TypeAryPtr* in_type = in->Value(&_gvn)->isa_aryptr();
7304+
const TypeAryPtr* ct_type = ct->Value(&_gvn)->isa_aryptr();
7305+
const TypeAryPtr* out_type = out->Value(&_gvn)->isa_aryptr();
7306+
assert( in_type != nullptr && in_type->elem() != Type::BOTTOM &&
7307+
ct_type != nullptr && ct_type->elem() != Type::BOTTOM &&
7308+
out_type != nullptr && out_type->elem() != Type::BOTTOM, "args are strange");
73377309

73387310
// checks are the responsibility of the caller
73397311
Node* in_start = in;

0 commit comments

Comments
 (0)