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

Commit

Permalink
8300079: SIGSEGV in LibraryCallKit::inline_string_copy due to constan…
Browse files Browse the repository at this point in the history
…t NULL src argument

Backport-of: 45e4e00981ef8b4bf143afce0889698319273c1d
  • Loading branch information
TobiHartmann committed Apr 4, 2023
1 parent ac96054 commit aae19b3
Show file tree
Hide file tree
Showing 2 changed files with 154 additions and 124 deletions.
220 changes: 96 additions & 124 deletions src/hotspot/share/opto/library_call.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -1361,10 +1361,13 @@ bool LibraryCallKit::inline_string_copy(bool compress) {
AllocateArrayNode* alloc = tightly_coupled_allocation(dst);

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

const Type* src_type = src->Value(&_gvn);
const Type* dst_type = dst->Value(&_gvn);
const TypeAryPtr* top_src = src_type->isa_aryptr();
const TypeAryPtr* top_dest = dst_type->isa_aryptr();
if (top_src == NULL || top_src->elem() == Type::BOTTOM ||
top_dest == NULL || top_dest->elem() == Type::BOTTOM) {
const TypeAryPtr* src_type = src->Value(&_gvn)->isa_aryptr();
const TypeAryPtr* dst_type = dst->Value(&_gvn)->isa_aryptr();
if (src_type == nullptr || src_type->elem() == Type::BOTTOM ||
dst_type == nullptr || dst_type->elem() == Type::BOTTOM) {
// failed array check
return false;
}

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

const Type* x_type = x->Value(&_gvn);
const Type* y_type = y->Value(&_gvn);
const TypeAryPtr* top_x = x_type->isa_aryptr();
const TypeAryPtr* top_y = y_type->isa_aryptr();
if (top_x == NULL || top_x->elem() == Type::BOTTOM ||
top_y == NULL || top_y->elem() == Type::BOTTOM) {
const TypeAryPtr* x_type = x->Value(&_gvn)->isa_aryptr();
const TypeAryPtr* y_type = y->Value(&_gvn)->isa_aryptr();
if (x_type == nullptr || x_type->elem() == Type::BOTTOM ||
y_type == nullptr || y_type->elem() == Type::BOTTOM) {
// failed array check
return false;
}

BasicType x_elem = x_type->isa_aryptr()->elem()->array_element_basic_type();
BasicType y_elem = y_type->isa_aryptr()->elem()->array_element_basic_type();
BasicType x_elem = x_type->elem()->array_element_basic_type();
BasicType y_elem = y_type->elem()->array_element_basic_type();
if (x_elem != T_INT || y_elem != T_INT) {
return false;
}
Expand Down Expand Up @@ -5607,18 +5606,16 @@ bool LibraryCallKit::inline_squareToLen() {
x = must_be_not_null(x, true);
z = must_be_not_null(z, true);

const Type* x_type = x->Value(&_gvn);
const Type* z_type = z->Value(&_gvn);
const TypeAryPtr* top_x = x_type->isa_aryptr();
const TypeAryPtr* top_z = z_type->isa_aryptr();
if (top_x == NULL || top_x->elem() == Type::BOTTOM ||
top_z == NULL || top_z->elem() == Type::BOTTOM) {
const TypeAryPtr* x_type = x->Value(&_gvn)->isa_aryptr();
const TypeAryPtr* z_type = z->Value(&_gvn)->isa_aryptr();
if (x_type == nullptr || x_type->elem() == Type::BOTTOM ||
z_type == nullptr || z_type->elem() == Type::BOTTOM) {
// failed array check
return false;
}

BasicType x_elem = x_type->isa_aryptr()->elem()->array_element_basic_type();
BasicType z_elem = z_type->isa_aryptr()->elem()->array_element_basic_type();
BasicType x_elem = x_type->elem()->array_element_basic_type();
BasicType z_elem = z_type->elem()->array_element_basic_type();
if (x_elem != T_INT || z_elem != T_INT) {
return false;
}
Expand Down Expand Up @@ -5654,20 +5651,19 @@ bool LibraryCallKit::inline_mulAdd() {
Node* len = argument(3);
Node* k = argument(4);

in = must_be_not_null(in, true);
out = must_be_not_null(out, true);

const Type* out_type = out->Value(&_gvn);
const Type* in_type = in->Value(&_gvn);
const TypeAryPtr* top_out = out_type->isa_aryptr();
const TypeAryPtr* top_in = in_type->isa_aryptr();
if (top_out == NULL || top_out->elem() == Type::BOTTOM ||
top_in == NULL || top_in->elem() == Type::BOTTOM) {
const TypeAryPtr* out_type = out->Value(&_gvn)->isa_aryptr();
const TypeAryPtr* in_type = in->Value(&_gvn)->isa_aryptr();
if (out_type == nullptr || out_type->elem() == Type::BOTTOM ||
in_type == nullptr || in_type->elem() == Type::BOTTOM) {
// failed array check
return false;
}

BasicType out_elem = out_type->isa_aryptr()->elem()->array_element_basic_type();
BasicType in_elem = in_type->isa_aryptr()->elem()->array_element_basic_type();
BasicType out_elem = out_type->elem()->array_element_basic_type();
BasicType in_elem = in_type->elem()->array_element_basic_type();
if (out_elem != T_INT || in_elem != T_INT) {
return false;
}
Expand Down Expand Up @@ -5705,26 +5701,22 @@ bool LibraryCallKit::inline_montgomeryMultiply() {
Node* inv = argument(4);
Node* m = argument(6);

const Type* a_type = a->Value(&_gvn);
const TypeAryPtr* top_a = a_type->isa_aryptr();
const Type* b_type = b->Value(&_gvn);
const TypeAryPtr* top_b = b_type->isa_aryptr();
const Type* n_type = a->Value(&_gvn);
const TypeAryPtr* top_n = n_type->isa_aryptr();
const Type* m_type = a->Value(&_gvn);
const TypeAryPtr* top_m = m_type->isa_aryptr();
if (top_a == NULL || top_a->elem() == Type::BOTTOM ||
top_b == NULL || top_b->elem() == Type::BOTTOM ||
top_n == NULL || top_n->elem() == Type::BOTTOM ||
top_m == NULL || top_m->elem() == Type::BOTTOM) {
const TypeAryPtr* a_type = a->Value(&_gvn)->isa_aryptr();
const TypeAryPtr* b_type = b->Value(&_gvn)->isa_aryptr();
const TypeAryPtr* n_type = n->Value(&_gvn)->isa_aryptr();
const TypeAryPtr* m_type = m->Value(&_gvn)->isa_aryptr();
if (a_type == nullptr || a_type->elem() == Type::BOTTOM ||
b_type == nullptr || b_type->elem() == Type::BOTTOM ||
n_type == nullptr || n_type->elem() == Type::BOTTOM ||
m_type == nullptr || m_type->elem() == Type::BOTTOM) {
// failed array check
return false;
}

BasicType a_elem = a_type->isa_aryptr()->elem()->array_element_basic_type();
BasicType b_elem = b_type->isa_aryptr()->elem()->array_element_basic_type();
BasicType n_elem = n_type->isa_aryptr()->elem()->array_element_basic_type();
BasicType m_elem = m_type->isa_aryptr()->elem()->array_element_basic_type();
BasicType a_elem = a_type->elem()->array_element_basic_type();
BasicType b_elem = b_type->elem()->array_element_basic_type();
BasicType n_elem = n_type->elem()->array_element_basic_type();
BasicType m_elem = m_type->elem()->array_element_basic_type();
if (a_elem != T_INT || b_elem != T_INT || n_elem != T_INT || m_elem != T_INT) {
return false;
}
Expand Down Expand Up @@ -5764,22 +5756,19 @@ bool LibraryCallKit::inline_montgomerySquare() {
Node* inv = argument(3);
Node* m = argument(5);

const Type* a_type = a->Value(&_gvn);
const TypeAryPtr* top_a = a_type->isa_aryptr();
const Type* n_type = a->Value(&_gvn);
const TypeAryPtr* top_n = n_type->isa_aryptr();
const Type* m_type = a->Value(&_gvn);
const TypeAryPtr* top_m = m_type->isa_aryptr();
if (top_a == NULL || top_a->elem() == Type::BOTTOM ||
top_n == NULL || top_n->elem() == Type::BOTTOM ||
top_m == NULL || top_m->elem() == Type::BOTTOM) {
const TypeAryPtr* a_type = a->Value(&_gvn)->isa_aryptr();
const TypeAryPtr* n_type = n->Value(&_gvn)->isa_aryptr();
const TypeAryPtr* m_type = m->Value(&_gvn)->isa_aryptr();
if (a_type == nullptr || a_type->elem() == Type::BOTTOM ||
n_type == nullptr || n_type->elem() == Type::BOTTOM ||
m_type == nullptr || m_type->elem() == Type::BOTTOM) {
// failed array check
return false;
}

BasicType a_elem = a_type->isa_aryptr()->elem()->array_element_basic_type();
BasicType n_elem = n_type->isa_aryptr()->elem()->array_element_basic_type();
BasicType m_elem = m_type->isa_aryptr()->elem()->array_element_basic_type();
BasicType a_elem = a_type->elem()->array_element_basic_type();
BasicType n_elem = n_type->elem()->array_element_basic_type();
BasicType m_elem = m_type->elem()->array_element_basic_type();
if (a_elem != T_INT || n_elem != T_INT || m_elem != T_INT) {
return false;
}
Expand Down Expand Up @@ -5820,17 +5809,15 @@ bool LibraryCallKit::inline_bigIntegerShift(bool isRightShift) {
Node* shiftCount = argument(3);
Node* numIter = argument(4);

const Type* newArr_type = newArr->Value(&_gvn);
const TypeAryPtr* top_newArr = newArr_type->isa_aryptr();
const Type* oldArr_type = oldArr->Value(&_gvn);
const TypeAryPtr* top_oldArr = oldArr_type->isa_aryptr();
if (top_newArr == NULL || top_newArr->elem() == Type::BOTTOM || top_oldArr == NULL
|| top_oldArr->elem() == Type::BOTTOM) {
const TypeAryPtr* newArr_type = newArr->Value(&_gvn)->isa_aryptr();
const TypeAryPtr* oldArr_type = oldArr->Value(&_gvn)->isa_aryptr();
if (newArr_type == nullptr || newArr_type->elem() == Type::BOTTOM ||
oldArr_type == nullptr || oldArr_type->elem() == Type::BOTTOM) {
return false;
}

BasicType newArr_elem = newArr_type->isa_aryptr()->elem()->array_element_basic_type();
BasicType oldArr_elem = oldArr_type->isa_aryptr()->elem()->array_element_basic_type();
BasicType newArr_elem = newArr_type->elem()->array_element_basic_type();
BasicType oldArr_elem = oldArr_type->elem()->array_element_basic_type();
if (newArr_elem != T_INT || oldArr_elem != T_INT) {
return false;
}
Expand Down Expand Up @@ -6035,15 +6022,14 @@ bool LibraryCallKit::inline_updateBytesCRC32() {
Node* offset = argument(2); // type: int
Node* length = argument(3); // type: int

const Type* src_type = src->Value(&_gvn);
const TypeAryPtr* top_src = src_type->isa_aryptr();
if (top_src == NULL || top_src->elem() == Type::BOTTOM) {
const TypeAryPtr* src_type = src->Value(&_gvn)->isa_aryptr();
if (src_type == nullptr || src_type->elem() == Type::BOTTOM) {
// failed array check
return false;
}

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

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

const Type* src_type = src->Value(&_gvn);
const TypeAryPtr* top_src = src_type->isa_aryptr();
if (top_src == NULL || top_src->elem() == Type::BOTTOM) {
const TypeAryPtr* src_type = src->Value(&_gvn)->isa_aryptr();
if (src_type == nullptr || src_type->elem() == Type::BOTTOM) {
// failed array check
return false;
}

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

const Type* src_type = src->Value(&_gvn);
const TypeAryPtr* top_src = src_type->isa_aryptr();
if (top_src == NULL || top_src->elem() == Type::BOTTOM) {
const TypeAryPtr* src_type = src->Value(&_gvn)->isa_aryptr();
if (src_type == nullptr || src_type->elem() == Type::BOTTOM) {
// failed array check
return false;
}

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

// (1) src and dest are arrays.
const Type* src_type = src->Value(&_gvn);
const Type* dest_type = dest->Value(&_gvn);
const TypeAryPtr* top_src = src_type->isa_aryptr();
const TypeAryPtr* top_dest = dest_type->isa_aryptr();
assert (top_src != NULL && top_src->elem() != Type::BOTTOM && top_dest != NULL && top_dest->elem() != Type::BOTTOM, "args are strange");
const TypeAryPtr* src_type = src->Value(&_gvn)->isa_aryptr();
const TypeAryPtr* dest_type = dest->Value(&_gvn)->isa_aryptr();
assert( src_type != nullptr && src_type->elem() != Type::BOTTOM &&
dest_type != nullptr && dest_type->elem() != Type::BOTTOM, "args are strange");

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

// (1) src and dest are arrays.
const Type* src_type = src->Value(&_gvn);
const Type* dest_type = dest->Value(&_gvn);
const TypeAryPtr* top_src = src_type->isa_aryptr();
const TypeAryPtr* top_dest = dest_type->isa_aryptr();
assert (top_src != NULL && top_src->elem() != Type::BOTTOM
&& top_dest != NULL && top_dest->elem() != Type::BOTTOM, "args are strange");
const TypeAryPtr* src_type = src->Value(&_gvn)->isa_aryptr();
const TypeAryPtr* dest_type = dest->Value(&_gvn)->isa_aryptr();
assert( src_type != nullptr && src_type->elem() != Type::BOTTOM &&
dest_type != nullptr && dest_type->elem() != Type::BOTTOM, "args are strange");

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

// (1) src and dest are arrays.
const Type* src_type = src->Value(&_gvn);
const Type* dest_type = dest->Value(&_gvn);
const TypeAryPtr* top_src = src_type->isa_aryptr();
const TypeAryPtr* top_dest = dest_type->isa_aryptr();
assert(top_src != NULL && top_src->elem() != Type::BOTTOM
&& top_dest != NULL && top_dest->elem() != Type::BOTTOM, "args are strange");
const TypeAryPtr* src_type = src->Value(&_gvn)->isa_aryptr();
const TypeAryPtr* dest_type = dest->Value(&_gvn)->isa_aryptr();
assert( src_type != nullptr && src_type->elem() != Type::BOTTOM &&
dest_type != nullptr && dest_type->elem() != Type::BOTTOM, "args are strange");

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

// (1) src and dest are arrays.
const Type* src_type = src->Value(&_gvn);
const Type* dest_type = dest->Value(&_gvn);
const TypeAryPtr* top_src = src_type->isa_aryptr();
const TypeAryPtr* top_dest = dest_type->isa_aryptr();
assert(top_src != NULL && top_src->elem() != Type::BOTTOM &&
top_dest != NULL && top_dest->elem() != Type::BOTTOM, "args are strange");
const TypeAryPtr* src_type = src->Value(&_gvn)->isa_aryptr();
const TypeAryPtr* dest_type = dest->Value(&_gvn)->isa_aryptr();
assert( src_type != nullptr && src_type->elem() != Type::BOTTOM &&
dest_type != nullptr && dest_type->elem() != Type::BOTTOM, "args are strange");

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

const Type* src_type = src->Value(&_gvn);
const TypeAryPtr* top_src = src_type->isa_aryptr();
if (top_src == NULL || top_src->elem() == Type::BOTTOM) {
const TypeAryPtr* src_type = src->Value(&_gvn)->isa_aryptr();
if (src_type == nullptr || src_type->elem() == Type::BOTTOM) {
// failed array check
return false;
}
// Figure out the size and type of the elements we will be copying.
BasicType src_elem = src_type->isa_aryptr()->elem()->array_element_basic_type();
BasicType src_elem = src_type->elem()->array_element_basic_type();
if (src_elem != T_BYTE) {
return false;
}
Expand Down Expand Up @@ -7213,14 +7189,13 @@ bool LibraryCallKit::inline_digestBase_implCompressMB(int predicate) {
Node* ofs = argument(2); // type int
Node* limit = argument(3); // type int

const Type* src_type = src->Value(&_gvn);
const TypeAryPtr* top_src = src_type->isa_aryptr();
if (top_src == NULL || top_src->elem() == Type::BOTTOM) {
const TypeAryPtr* src_type = src->Value(&_gvn)->isa_aryptr();
if (src_type == nullptr || src_type->elem() == Type::BOTTOM) {
// failed array check
return false;
}
// Figure out the size and type of the elements we will be copying.
BasicType src_elem = src_type->isa_aryptr()->elem()->array_element_basic_type();
BasicType src_elem = src_type->elem()->array_element_basic_type();
if (src_elem != T_BYTE) {
return false;
}
Expand Down Expand Up @@ -7351,15 +7326,12 @@ bool LibraryCallKit::inline_galoisCounterMode_AESCrypt() {
Node* ghash_object = argument(8);

// (1) in, ct and out are arrays.
const Type* in_type = in->Value(&_gvn);
const Type* ct_type = ct->Value(&_gvn);
const Type* out_type = out->Value(&_gvn);
const TypeAryPtr* top_in = in_type->isa_aryptr();
const TypeAryPtr* top_ct = ct_type->isa_aryptr();
const TypeAryPtr* top_out = out_type->isa_aryptr();
assert(top_in != NULL && top_in->elem() != Type::BOTTOM &&
top_ct != NULL && top_ct->elem() != Type::BOTTOM &&
top_out != NULL && top_out->elem() != Type::BOTTOM, "args are strange");
const TypeAryPtr* in_type = in->Value(&_gvn)->isa_aryptr();
const TypeAryPtr* ct_type = ct->Value(&_gvn)->isa_aryptr();
const TypeAryPtr* out_type = out->Value(&_gvn)->isa_aryptr();
assert( in_type != nullptr && in_type->elem() != Type::BOTTOM &&
ct_type != nullptr && ct_type->elem() != Type::BOTTOM &&
out_type != nullptr && out_type->elem() != Type::BOTTOM, "args are strange");

// checks are the responsibility of the caller
Node* in_start = in;
Expand Down

1 comment on commit aae19b3

@openjdk-notifier
Copy link

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Please sign in to comment.