Skip to content
This repository was archived by the owner on Sep 19, 2023. It is now read-only.
/ jdk20u Public archive

Commit aae19b3

Browse files
TobiHartmannTobiHartmann
committed
8300079: SIGSEGV in LibraryCallKit::inline_string_copy due to constant NULL src argument
Backport-of: 45e4e00981ef8b4bf143afce0889698319273c1d
1 parent ac96054 commit aae19b3

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
@@ -1361,10 +1361,13 @@ bool LibraryCallKit::inline_string_copy(bool compress) {
13611361
AllocateArrayNode* alloc = tightly_coupled_allocation(dst);
13621362

13631363
// Figure out the size and type of the elements we will be copying.
1364-
const Type* src_type = src->Value(&_gvn);
1365-
const Type* dst_type = dst->Value(&_gvn);
1366-
BasicType src_elem = src_type->isa_aryptr()->elem()->array_element_basic_type();
1367-
BasicType dst_elem = dst_type->isa_aryptr()->elem()->array_element_basic_type();
1364+
const TypeAryPtr* src_type = src->Value(&_gvn)->isa_aryptr();
1365+
const TypeAryPtr* dst_type = dst->Value(&_gvn)->isa_aryptr();
1366+
if (src_type == nullptr || dst_type == nullptr) {
1367+
return false;
1368+
}
1369+
BasicType src_elem = src_type->elem()->array_element_basic_type();
1370+
BasicType dst_elem = dst_type->elem()->array_element_basic_type();
13681371
assert((compress && dst_elem == T_BYTE && (src_elem == T_BYTE || src_elem == T_CHAR)) ||
13691372
(!compress && src_elem == T_BYTE && (dst_elem == T_BYTE || dst_elem == T_CHAR)),
13701373
"Unsupported array types for inline_string_copy");
@@ -5444,19 +5447,17 @@ bool LibraryCallKit::inline_encodeISOArray(bool ascii) {
54445447
src = must_be_not_null(src, true);
54455448
dst = must_be_not_null(dst, true);
54465449

5447-
const Type* src_type = src->Value(&_gvn);
5448-
const Type* dst_type = dst->Value(&_gvn);
5449-
const TypeAryPtr* top_src = src_type->isa_aryptr();
5450-
const TypeAryPtr* top_dest = dst_type->isa_aryptr();
5451-
if (top_src == NULL || top_src->elem() == Type::BOTTOM ||
5452-
top_dest == NULL || top_dest->elem() == Type::BOTTOM) {
5450+
const TypeAryPtr* src_type = src->Value(&_gvn)->isa_aryptr();
5451+
const TypeAryPtr* dst_type = dst->Value(&_gvn)->isa_aryptr();
5452+
if (src_type == nullptr || src_type->elem() == Type::BOTTOM ||
5453+
dst_type == nullptr || dst_type->elem() == Type::BOTTOM) {
54535454
// failed array check
54545455
return false;
54555456
}
54565457

54575458
// Figure out the size and type of the elements we will be copying.
5458-
BasicType src_elem = src_type->isa_aryptr()->elem()->array_element_basic_type();
5459-
BasicType dst_elem = dst_type->isa_aryptr()->elem()->array_element_basic_type();
5459+
BasicType src_elem = src_type->elem()->array_element_basic_type();
5460+
BasicType dst_elem = dst_type->elem()->array_element_basic_type();
54605461
if (!((src_elem == T_CHAR) || (src_elem== T_BYTE)) || dst_elem != T_BYTE) {
54615462
return false;
54625463
}
@@ -5499,18 +5500,16 @@ bool LibraryCallKit::inline_multiplyToLen() {
54995500
x = must_be_not_null(x, true);
55005501
y = must_be_not_null(y, true);
55015502

5502-
const Type* x_type = x->Value(&_gvn);
5503-
const Type* y_type = y->Value(&_gvn);
5504-
const TypeAryPtr* top_x = x_type->isa_aryptr();
5505-
const TypeAryPtr* top_y = y_type->isa_aryptr();
5506-
if (top_x == NULL || top_x->elem() == Type::BOTTOM ||
5507-
top_y == NULL || top_y->elem() == Type::BOTTOM) {
5503+
const TypeAryPtr* x_type = x->Value(&_gvn)->isa_aryptr();
5504+
const TypeAryPtr* y_type = y->Value(&_gvn)->isa_aryptr();
5505+
if (x_type == nullptr || x_type->elem() == Type::BOTTOM ||
5506+
y_type == nullptr || y_type->elem() == Type::BOTTOM) {
55085507
// failed array check
55095508
return false;
55105509
}
55115510

5512-
BasicType x_elem = x_type->isa_aryptr()->elem()->array_element_basic_type();
5513-
BasicType y_elem = y_type->isa_aryptr()->elem()->array_element_basic_type();
5511+
BasicType x_elem = x_type->elem()->array_element_basic_type();
5512+
BasicType y_elem = y_type->elem()->array_element_basic_type();
55145513
if (x_elem != T_INT || y_elem != T_INT) {
55155514
return false;
55165515
}
@@ -5607,18 +5606,16 @@ bool LibraryCallKit::inline_squareToLen() {
56075606
x = must_be_not_null(x, true);
56085607
z = must_be_not_null(z, true);
56095608

5610-
const Type* x_type = x->Value(&_gvn);
5611-
const Type* z_type = z->Value(&_gvn);
5612-
const TypeAryPtr* top_x = x_type->isa_aryptr();
5613-
const TypeAryPtr* top_z = z_type->isa_aryptr();
5614-
if (top_x == NULL || top_x->elem() == Type::BOTTOM ||
5615-
top_z == NULL || top_z->elem() == Type::BOTTOM) {
5609+
const TypeAryPtr* x_type = x->Value(&_gvn)->isa_aryptr();
5610+
const TypeAryPtr* z_type = z->Value(&_gvn)->isa_aryptr();
5611+
if (x_type == nullptr || x_type->elem() == Type::BOTTOM ||
5612+
z_type == nullptr || z_type->elem() == Type::BOTTOM) {
56165613
// failed array check
56175614
return false;
56185615
}
56195616

5620-
BasicType x_elem = x_type->isa_aryptr()->elem()->array_element_basic_type();
5621-
BasicType z_elem = z_type->isa_aryptr()->elem()->array_element_basic_type();
5617+
BasicType x_elem = x_type->elem()->array_element_basic_type();
5618+
BasicType z_elem = z_type->elem()->array_element_basic_type();
56225619
if (x_elem != T_INT || z_elem != T_INT) {
56235620
return false;
56245621
}
@@ -5654,20 +5651,19 @@ bool LibraryCallKit::inline_mulAdd() {
56545651
Node* len = argument(3);
56555652
Node* k = argument(4);
56565653

5654+
in = must_be_not_null(in, true);
56575655
out = must_be_not_null(out, true);
56585656

5659-
const Type* out_type = out->Value(&_gvn);
5660-
const Type* in_type = in->Value(&_gvn);
5661-
const TypeAryPtr* top_out = out_type->isa_aryptr();
5662-
const TypeAryPtr* top_in = in_type->isa_aryptr();
5663-
if (top_out == NULL || top_out->elem() == Type::BOTTOM ||
5664-
top_in == NULL || top_in->elem() == Type::BOTTOM) {
5657+
const TypeAryPtr* out_type = out->Value(&_gvn)->isa_aryptr();
5658+
const TypeAryPtr* in_type = in->Value(&_gvn)->isa_aryptr();
5659+
if (out_type == nullptr || out_type->elem() == Type::BOTTOM ||
5660+
in_type == nullptr || in_type->elem() == Type::BOTTOM) {
56655661
// failed array check
56665662
return false;
56675663
}
56685664

5669-
BasicType out_elem = out_type->isa_aryptr()->elem()->array_element_basic_type();
5670-
BasicType in_elem = in_type->isa_aryptr()->elem()->array_element_basic_type();
5665+
BasicType out_elem = out_type->elem()->array_element_basic_type();
5666+
BasicType in_elem = in_type->elem()->array_element_basic_type();
56715667
if (out_elem != T_INT || in_elem != T_INT) {
56725668
return false;
56735669
}
@@ -5705,26 +5701,22 @@ bool LibraryCallKit::inline_montgomeryMultiply() {
57055701
Node* inv = argument(4);
57065702
Node* m = argument(6);
57075703

5708-
const Type* a_type = a->Value(&_gvn);
5709-
const TypeAryPtr* top_a = a_type->isa_aryptr();
5710-
const Type* b_type = b->Value(&_gvn);
5711-
const TypeAryPtr* top_b = b_type->isa_aryptr();
5712-
const Type* n_type = a->Value(&_gvn);
5713-
const TypeAryPtr* top_n = n_type->isa_aryptr();
5714-
const Type* m_type = a->Value(&_gvn);
5715-
const TypeAryPtr* top_m = m_type->isa_aryptr();
5716-
if (top_a == NULL || top_a->elem() == Type::BOTTOM ||
5717-
top_b == NULL || top_b->elem() == Type::BOTTOM ||
5718-
top_n == NULL || top_n->elem() == Type::BOTTOM ||
5719-
top_m == NULL || top_m->elem() == Type::BOTTOM) {
5704+
const TypeAryPtr* a_type = a->Value(&_gvn)->isa_aryptr();
5705+
const TypeAryPtr* b_type = b->Value(&_gvn)->isa_aryptr();
5706+
const TypeAryPtr* n_type = n->Value(&_gvn)->isa_aryptr();
5707+
const TypeAryPtr* m_type = m->Value(&_gvn)->isa_aryptr();
5708+
if (a_type == nullptr || a_type->elem() == Type::BOTTOM ||
5709+
b_type == nullptr || b_type->elem() == Type::BOTTOM ||
5710+
n_type == nullptr || n_type->elem() == Type::BOTTOM ||
5711+
m_type == nullptr || m_type->elem() == Type::BOTTOM) {
57205712
// failed array check
57215713
return false;
57225714
}
57235715

5724-
BasicType a_elem = a_type->isa_aryptr()->elem()->array_element_basic_type();
5725-
BasicType b_elem = b_type->isa_aryptr()->elem()->array_element_basic_type();
5726-
BasicType n_elem = n_type->isa_aryptr()->elem()->array_element_basic_type();
5727-
BasicType m_elem = m_type->isa_aryptr()->elem()->array_element_basic_type();
5716+
BasicType a_elem = a_type->elem()->array_element_basic_type();
5717+
BasicType b_elem = b_type->elem()->array_element_basic_type();
5718+
BasicType n_elem = n_type->elem()->array_element_basic_type();
5719+
BasicType m_elem = m_type->elem()->array_element_basic_type();
57285720
if (a_elem != T_INT || b_elem != T_INT || n_elem != T_INT || m_elem != T_INT) {
57295721
return false;
57305722
}
@@ -5764,22 +5756,19 @@ bool LibraryCallKit::inline_montgomerySquare() {
57645756
Node* inv = argument(3);
57655757
Node* m = argument(5);
57665758

5767-
const Type* a_type = a->Value(&_gvn);
5768-
const TypeAryPtr* top_a = a_type->isa_aryptr();
5769-
const Type* n_type = a->Value(&_gvn);
5770-
const TypeAryPtr* top_n = n_type->isa_aryptr();
5771-
const Type* m_type = a->Value(&_gvn);
5772-
const TypeAryPtr* top_m = m_type->isa_aryptr();
5773-
if (top_a == NULL || top_a->elem() == Type::BOTTOM ||
5774-
top_n == NULL || top_n->elem() == Type::BOTTOM ||
5775-
top_m == NULL || top_m->elem() == Type::BOTTOM) {
5759+
const TypeAryPtr* a_type = a->Value(&_gvn)->isa_aryptr();
5760+
const TypeAryPtr* n_type = n->Value(&_gvn)->isa_aryptr();
5761+
const TypeAryPtr* m_type = m->Value(&_gvn)->isa_aryptr();
5762+
if (a_type == nullptr || a_type->elem() == Type::BOTTOM ||
5763+
n_type == nullptr || n_type->elem() == Type::BOTTOM ||
5764+
m_type == nullptr || m_type->elem() == Type::BOTTOM) {
57765765
// failed array check
57775766
return false;
57785767
}
57795768

5780-
BasicType a_elem = a_type->isa_aryptr()->elem()->array_element_basic_type();
5781-
BasicType n_elem = n_type->isa_aryptr()->elem()->array_element_basic_type();
5782-
BasicType m_elem = m_type->isa_aryptr()->elem()->array_element_basic_type();
5769+
BasicType a_elem = a_type->elem()->array_element_basic_type();
5770+
BasicType n_elem = n_type->elem()->array_element_basic_type();
5771+
BasicType m_elem = m_type->elem()->array_element_basic_type();
57835772
if (a_elem != T_INT || n_elem != T_INT || m_elem != T_INT) {
57845773
return false;
57855774
}
@@ -5820,17 +5809,15 @@ bool LibraryCallKit::inline_bigIntegerShift(bool isRightShift) {
58205809
Node* shiftCount = argument(3);
58215810
Node* numIter = argument(4);
58225811

5823-
const Type* newArr_type = newArr->Value(&_gvn);
5824-
const TypeAryPtr* top_newArr = newArr_type->isa_aryptr();
5825-
const Type* oldArr_type = oldArr->Value(&_gvn);
5826-
const TypeAryPtr* top_oldArr = oldArr_type->isa_aryptr();
5827-
if (top_newArr == NULL || top_newArr->elem() == Type::BOTTOM || top_oldArr == NULL
5828-
|| top_oldArr->elem() == Type::BOTTOM) {
5812+
const TypeAryPtr* newArr_type = newArr->Value(&_gvn)->isa_aryptr();
5813+
const TypeAryPtr* oldArr_type = oldArr->Value(&_gvn)->isa_aryptr();
5814+
if (newArr_type == nullptr || newArr_type->elem() == Type::BOTTOM ||
5815+
oldArr_type == nullptr || oldArr_type->elem() == Type::BOTTOM) {
58295816
return false;
58305817
}
58315818

5832-
BasicType newArr_elem = newArr_type->isa_aryptr()->elem()->array_element_basic_type();
5833-
BasicType oldArr_elem = oldArr_type->isa_aryptr()->elem()->array_element_basic_type();
5819+
BasicType newArr_elem = newArr_type->elem()->array_element_basic_type();
5820+
BasicType oldArr_elem = oldArr_type->elem()->array_element_basic_type();
58345821
if (newArr_elem != T_INT || oldArr_elem != T_INT) {
58355822
return false;
58365823
}
@@ -6035,15 +6022,14 @@ bool LibraryCallKit::inline_updateBytesCRC32() {
60356022
Node* offset = argument(2); // type: int
60366023
Node* length = argument(3); // type: int
60376024

6038-
const Type* src_type = src->Value(&_gvn);
6039-
const TypeAryPtr* top_src = src_type->isa_aryptr();
6040-
if (top_src == NULL || top_src->elem() == Type::BOTTOM) {
6025+
const TypeAryPtr* src_type = src->Value(&_gvn)->isa_aryptr();
6026+
if (src_type == nullptr || src_type->elem() == Type::BOTTOM) {
60416027
// failed array check
60426028
return false;
60436029
}
60446030

60456031
// Figure out the size and type of the elements we will be copying.
6046-
BasicType src_elem = src_type->isa_aryptr()->elem()->array_element_basic_type();
6032+
BasicType src_elem = src_type->elem()->array_element_basic_type();
60476033
if (src_elem != T_BYTE) {
60486034
return false;
60496035
}
@@ -6124,15 +6110,14 @@ bool LibraryCallKit::inline_updateBytesCRC32C() {
61246110

61256111
Node* length = _gvn.transform(new SubINode(end, offset));
61266112

6127-
const Type* src_type = src->Value(&_gvn);
6128-
const TypeAryPtr* top_src = src_type->isa_aryptr();
6129-
if (top_src == NULL || top_src->elem() == Type::BOTTOM) {
6113+
const TypeAryPtr* src_type = src->Value(&_gvn)->isa_aryptr();
6114+
if (src_type == nullptr || src_type->elem() == Type::BOTTOM) {
61306115
// failed array check
61316116
return false;
61326117
}
61336118

61346119
// Figure out the size and type of the elements we will be copying.
6135-
BasicType src_elem = src_type->isa_aryptr()->elem()->array_element_basic_type();
6120+
BasicType src_elem = src_type->elem()->array_element_basic_type();
61366121
if (src_elem != T_BYTE) {
61376122
return false;
61386123
}
@@ -6217,15 +6202,14 @@ bool LibraryCallKit::inline_updateBytesAdler32() {
62176202
Node* offset = argument(2); // type: int
62186203
Node* length = argument(3); // type: int
62196204

6220-
const Type* src_type = src->Value(&_gvn);
6221-
const TypeAryPtr* top_src = src_type->isa_aryptr();
6222-
if (top_src == NULL || top_src->elem() == Type::BOTTOM) {
6205+
const TypeAryPtr* src_type = src->Value(&_gvn)->isa_aryptr();
6206+
if (src_type == nullptr || src_type->elem() == Type::BOTTOM) {
62236207
// failed array check
62246208
return false;
62256209
}
62266210

62276211
// Figure out the size and type of the elements we will be copying.
6228-
BasicType src_elem = src_type->isa_aryptr()->elem()->array_element_basic_type();
6212+
BasicType src_elem = src_type->elem()->array_element_basic_type();
62296213
if (src_elem != T_BYTE) {
62306214
return false;
62316215
}
@@ -6459,11 +6443,10 @@ bool LibraryCallKit::inline_aescrypt_Block(vmIntrinsics::ID id) {
64596443
dest = must_be_not_null(dest, true);
64606444

64616445
// (1) src and dest are arrays.
6462-
const Type* src_type = src->Value(&_gvn);
6463-
const Type* dest_type = dest->Value(&_gvn);
6464-
const TypeAryPtr* top_src = src_type->isa_aryptr();
6465-
const TypeAryPtr* top_dest = dest_type->isa_aryptr();
6466-
assert (top_src != NULL && top_src->elem() != Type::BOTTOM && top_dest != NULL && top_dest->elem() != Type::BOTTOM, "args are strange");
6446+
const TypeAryPtr* src_type = src->Value(&_gvn)->isa_aryptr();
6447+
const TypeAryPtr* dest_type = dest->Value(&_gvn)->isa_aryptr();
6448+
assert( src_type != nullptr && src_type->elem() != Type::BOTTOM &&
6449+
dest_type != nullptr && dest_type->elem() != Type::BOTTOM, "args are strange");
64676450

64686451
// for the quick and dirty code we will skip all the checks.
64696452
// we are just trying to get the call to be generated.
@@ -6520,12 +6503,10 @@ bool LibraryCallKit::inline_cipherBlockChaining_AESCrypt(vmIntrinsics::ID id) {
65206503
dest = must_be_not_null(dest, false);
65216504

65226505
// (1) src and dest are arrays.
6523-
const Type* src_type = src->Value(&_gvn);
6524-
const Type* dest_type = dest->Value(&_gvn);
6525-
const TypeAryPtr* top_src = src_type->isa_aryptr();
6526-
const TypeAryPtr* top_dest = dest_type->isa_aryptr();
6527-
assert (top_src != NULL && top_src->elem() != Type::BOTTOM
6528-
&& top_dest != NULL && top_dest->elem() != Type::BOTTOM, "args are strange");
6506+
const TypeAryPtr* src_type = src->Value(&_gvn)->isa_aryptr();
6507+
const TypeAryPtr* dest_type = dest->Value(&_gvn)->isa_aryptr();
6508+
assert( src_type != nullptr && src_type->elem() != Type::BOTTOM &&
6509+
dest_type != nullptr && dest_type->elem() != Type::BOTTOM, "args are strange");
65296510

65306511
// checks are the responsibility of the caller
65316512
Node* src_start = src;
@@ -6608,12 +6589,10 @@ bool LibraryCallKit::inline_electronicCodeBook_AESCrypt(vmIntrinsics::ID id) {
66086589
Node* dest_offset = argument(5);
66096590

66106591
// (1) src and dest are arrays.
6611-
const Type* src_type = src->Value(&_gvn);
6612-
const Type* dest_type = dest->Value(&_gvn);
6613-
const TypeAryPtr* top_src = src_type->isa_aryptr();
6614-
const TypeAryPtr* top_dest = dest_type->isa_aryptr();
6615-
assert(top_src != NULL && top_src->elem() != Type::BOTTOM
6616-
&& top_dest != NULL && top_dest->elem() != Type::BOTTOM, "args are strange");
6592+
const TypeAryPtr* src_type = src->Value(&_gvn)->isa_aryptr();
6593+
const TypeAryPtr* dest_type = dest->Value(&_gvn)->isa_aryptr();
6594+
assert( src_type != nullptr && src_type->elem() != Type::BOTTOM &&
6595+
dest_type != nullptr && dest_type->elem() != Type::BOTTOM, "args are strange");
66176596

66186597
// checks are the responsibility of the caller
66196598
Node* src_start = src;
@@ -6682,12 +6661,10 @@ bool LibraryCallKit::inline_counterMode_AESCrypt(vmIntrinsics::ID id) {
66826661
Node* dest_offset = argument(5);
66836662

66846663
// (1) src and dest are arrays.
6685-
const Type* src_type = src->Value(&_gvn);
6686-
const Type* dest_type = dest->Value(&_gvn);
6687-
const TypeAryPtr* top_src = src_type->isa_aryptr();
6688-
const TypeAryPtr* top_dest = dest_type->isa_aryptr();
6689-
assert(top_src != NULL && top_src->elem() != Type::BOTTOM &&
6690-
top_dest != NULL && top_dest->elem() != Type::BOTTOM, "args are strange");
6664+
const TypeAryPtr* src_type = src->Value(&_gvn)->isa_aryptr();
6665+
const TypeAryPtr* dest_type = dest->Value(&_gvn)->isa_aryptr();
6666+
assert( src_type != nullptr && src_type->elem() != Type::BOTTOM &&
6667+
dest_type != nullptr && dest_type->elem() != Type::BOTTOM, "args are strange");
66916668

66926669
// checks are the responsibility of the caller
66936670
Node* src_start = src;
@@ -7121,14 +7098,13 @@ bool LibraryCallKit::inline_digestBase_implCompress(vmIntrinsics::ID id) {
71217098
Node* src = argument(1); // type oop
71227099
Node* ofs = argument(2); // type int
71237100

7124-
const Type* src_type = src->Value(&_gvn);
7125-
const TypeAryPtr* top_src = src_type->isa_aryptr();
7126-
if (top_src == NULL || top_src->elem() == Type::BOTTOM) {
7101+
const TypeAryPtr* src_type = src->Value(&_gvn)->isa_aryptr();
7102+
if (src_type == nullptr || src_type->elem() == Type::BOTTOM) {
71277103
// failed array check
71287104
return false;
71297105
}
71307106
// Figure out the size and type of the elements we will be copying.
7131-
BasicType src_elem = src_type->isa_aryptr()->elem()->array_element_basic_type();
7107+
BasicType src_elem = src_type->elem()->array_element_basic_type();
71327108
if (src_elem != T_BYTE) {
71337109
return false;
71347110
}
@@ -7213,14 +7189,13 @@ bool LibraryCallKit::inline_digestBase_implCompressMB(int predicate) {
72137189
Node* ofs = argument(2); // type int
72147190
Node* limit = argument(3); // type int
72157191

7216-
const Type* src_type = src->Value(&_gvn);
7217-
const TypeAryPtr* top_src = src_type->isa_aryptr();
7218-
if (top_src == NULL || top_src->elem() == Type::BOTTOM) {
7192+
const TypeAryPtr* src_type = src->Value(&_gvn)->isa_aryptr();
7193+
if (src_type == nullptr || src_type->elem() == Type::BOTTOM) {
72197194
// failed array check
72207195
return false;
72217196
}
72227197
// Figure out the size and type of the elements we will be copying.
7223-
BasicType src_elem = src_type->isa_aryptr()->elem()->array_element_basic_type();
7198+
BasicType src_elem = src_type->elem()->array_element_basic_type();
72247199
if (src_elem != T_BYTE) {
72257200
return false;
72267201
}
@@ -7351,15 +7326,12 @@ bool LibraryCallKit::inline_galoisCounterMode_AESCrypt() {
73517326
Node* ghash_object = argument(8);
73527327

73537328
// (1) in, ct and out are arrays.
7354-
const Type* in_type = in->Value(&_gvn);
7355-
const Type* ct_type = ct->Value(&_gvn);
7356-
const Type* out_type = out->Value(&_gvn);
7357-
const TypeAryPtr* top_in = in_type->isa_aryptr();
7358-
const TypeAryPtr* top_ct = ct_type->isa_aryptr();
7359-
const TypeAryPtr* top_out = out_type->isa_aryptr();
7360-
assert(top_in != NULL && top_in->elem() != Type::BOTTOM &&
7361-
top_ct != NULL && top_ct->elem() != Type::BOTTOM &&
7362-
top_out != NULL && top_out->elem() != Type::BOTTOM, "args are strange");
7329+
const TypeAryPtr* in_type = in->Value(&_gvn)->isa_aryptr();
7330+
const TypeAryPtr* ct_type = ct->Value(&_gvn)->isa_aryptr();
7331+
const TypeAryPtr* out_type = out->Value(&_gvn)->isa_aryptr();
7332+
assert( in_type != nullptr && in_type->elem() != Type::BOTTOM &&
7333+
ct_type != nullptr && ct_type->elem() != Type::BOTTOM &&
7334+
out_type != nullptr && out_type->elem() != Type::BOTTOM, "args are strange");
73637335

73647336
// checks are the responsibility of the caller
73657337
Node* in_start = in;

0 commit comments

Comments
 (0)