jdk-sandbox: comparison src/hotspot/share/opto/library

equal deleted inserted replaced

-:2368e8e9cec6
+:8123901bc3d1
 Node* arg2 = argument(1);
 arg1 = must_be_not_null(arg1, true);
 arg2 = must_be_not_null(arg2, true);
+arg1 = access_resolve(arg1, ACCESS_READ);
+arg2 = access_resolve(arg2, ACCESS_READ);
 // Get start addr and length of first argument
 Node* arg1_start  = array_element_address(arg1, intcon(0), T_BYTE);
 Node* arg1_cnt    = load_array_length(arg1);
 // Get start addr and length of second argument
 if (!stopped()) {
 arg1 = must_be_not_null(arg1, true);
 arg2 = must_be_not_null(arg2, true);
+arg1 = access_resolve(arg1, ACCESS_READ);
+arg2 = access_resolve(arg2, ACCESS_READ);
 // Get start addr and length of first argument
 Node* arg1_start  = array_element_address(arg1, intcon(0), T_BYTE);
 Node* arg1_cnt    = load_array_length(arg1);
 bool LibraryCallKit::inline_array_equals(StrIntrinsicNode::ArgEnc ae) {
 assert(ae == StrIntrinsicNode::UU || ae == StrIntrinsicNode::LL, "unsupported array types");
 Node* arg1 = argument(0);
 Node* arg2 = argument(1);
+arg1 = access_resolve(arg1, ACCESS_READ);
+arg2 = access_resolve(arg2, ACCESS_READ);
 const TypeAryPtr* mtype = (ae == StrIntrinsicNode::UU) ? TypeAryPtr::CHARS : TypeAryPtr::BYTES;
 set_result(_gvn.transform(new AryEqNode(control(), memory(mtype), arg1, arg2, ae)));
 clear_upper_avx();
 return true;
 // Range checks
 generate_string_range_check(ba, offset, len, false);
 if (stopped()) {
 return true;
 }
+ba = access_resolve(ba, ACCESS_READ);
 Node* ba_start = array_element_address(ba, offset, T_BYTE);
 Node* result = new HasNegativesNode(control(), memory(TypeAryPtr::BYTES), ba_start, len);
 set_result(_gvn.transform(result));
 return true;
 }
 Node*       result_phi = new PhiNode(result_rgn, TypeInt::INT);
 src = must_be_not_null(src, true);
 tgt = must_be_not_null(tgt, true);
+src = access_resolve(src, ACCESS_READ);
+tgt = access_resolve(tgt, ACCESS_READ);
 // Get start addr and length of source string
 Node* src_start = array_element_address(src, intcon(0), T_BYTE);
 Node* src_count = load_array_length(src);
 // Get start addr and length of substring
 Node* tgt_count   = argument(3); // char count
 Node* from_index  = argument(4); // char index
 src = must_be_not_null(src, true);
 tgt = must_be_not_null(tgt, true);
+src = access_resolve(src, ACCESS_READ);
+tgt = access_resolve(tgt, ACCESS_READ);
 // Multiply byte array index by 2 if String is UTF16 encoded
 Node* src_offset = (ae == StrIntrinsicNode::LL) ? from_index : _gvn.transform(new LShiftINode(from_index, intcon(1)));
 src_count = _gvn.transform(new SubINode(src_count, from_index));
 Node* src_start = array_element_address(src, src_offset, T_BYTE);
 Node* tgt         = argument(1); // tgt is int ch
 Node* from_index  = argument(2);
 Node* max         = argument(3);
 src = must_be_not_null(src, true);
+src = access_resolve(src, ACCESS_READ);
 Node* src_offset = _gvn.transform(new LShiftINode(from_index, intcon(1)));
 Node* src_start = array_element_address(src, src_offset, T_BYTE);
 Node* src_count = _gvn.transform(new SubINode(max, from_index));
 generate_string_range_check(dst, dst_offset, length, convert_dst);
 if (stopped()) {
 return true;
 }
+src = access_resolve(src, ACCESS_READ);
+dst = access_resolve(dst, ACCESS_WRITE);
 Node* src_start = array_element_address(src, src_offset, src_elem);
 Node* dst_start = array_element_address(dst, dst_offset, dst_elem);
 // 'src_start' points to src array + scaled offset
 // 'dst_start' points to dst array + scaled offset
 Node* count = NULL;
 Node* klass_node = makecon(TypeKlassPtr::make(ciTypeArrayKlass::make(T_BYTE)));
 newcopy = new_array(klass_node, size, 0);  // no arguments to push
 AllocateArrayNode* alloc = tightly_coupled_allocation(newcopy, NULL);
 // Calculate starting addresses.
+value = access_resolve(value, ACCESS_READ);
 Node* src_start = array_element_address(value, offset, T_CHAR);
 Node* dst_start = basic_plus_adr(newcopy, arrayOopDesc::base_offset_in_bytes(T_BYTE));
 // Check if src array address is aligned to HeapWordSize (dst is always aligned)
 const TypeInt* toffset = gvn().type(offset)->is_int();
 if (stopped()) {
 return true;
 }
 if (!stopped()) {
+src = access_resolve(src, ACCESS_READ);
+dst = access_resolve(dst, ACCESS_READ);
 // Calculate starting addresses.
 Node* src_start = array_element_address(src, src_begin, T_BYTE);
 Node* dst_start = array_element_address(dst, dst_begin, T_CHAR);
 // Check if array addresses are aligned to HeapWordSize
 if (!is_store && value->is_Con() && index->is_Con()) {
 return false;
 }
 value = must_be_not_null(value, true);
+value = access_resolve(value, is_store ? ACCESS_WRITE : ACCESS_READ);
 Node* adr = array_element_address(value, index, T_CHAR);
 if (adr->is_top()) {
 return false;
 }
 // How many elements will we copy from the original?
 // The answer is MinI(orig_length - start, length).
 Node* orig_tail = _gvn.transform(new SubINode(orig_length, start));
 Node* moved = generate_min_max(vmIntrinsics::_min, orig_tail, length);
+original = access_resolve(original, ACCESS_READ);
 // Generate a direct call to the right arraycopy function(s).
 // We know the copy is disjoint but we might not know if the
 // oop stores need checking.
 // Extreme case:  Arrays.copyOf((Integer[])x, 10, String[].class).
 // This will fail a store-check if x contains any non-nulls.
 // because gc barriers are required when accessing the array.
 Node* is_obja = generate_objArray_guard(obj_klass, (RegionNode*)NULL);
 if (is_obja != NULL) {
 PreserveJVMState pjvms2(this);
 set_control(is_obja);
+obj = access_resolve(obj, ACCESS_READ);
 // Generate a direct call to the right arraycopy function(s).
 Node* alloc = tightly_coupled_allocation(alloc_obj, NULL);
 ArrayCopyNode* ac = ArrayCopyNode::make(this, true, obj, intcon(0), alloc_obj, intcon(0), obj_length, alloc != NULL, false);
 ac->set_cloneoop();
 Node* n = _gvn.transform(ac);
 if (stopped()) {
 return true;
 }
-ArrayCopyNode* ac = ArrayCopyNode::make(this, true, src, src_offset, dest, dest_offset, length, alloc != NULL, negative_length_guard_generated,
+Node* new_src = access_resolve(src, ACCESS_READ);
+Node* new_dest = access_resolve(dest, ACCESS_WRITE);
+ArrayCopyNode* ac = ArrayCopyNode::make(this, true, new_src, src_offset, new_dest, dest_offset, length, alloc != NULL, negative_length_guard_generated,
 // Create LoadRange and LoadKlass nodes for use during macro expansion here
 // so the compiler has a chance to eliminate them: during macro expansion,
 // we have to set their control (CastPP nodes are eliminated).
 load_object_klass(src), load_object_klass(dest),
 load_array_length(src), load_array_length(dest));
 Node *length      = argument(4);
 src = must_be_not_null(src, true);
 dst = must_be_not_null(dst, true);
+src = access_resolve(src, ACCESS_READ);
+dst = access_resolve(dst, ACCESS_WRITE);
 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->klass()  == NULL ||
 Node* ylen = argument(3);
 Node* z    = argument(4);
 x = must_be_not_null(x, true);
 y = must_be_not_null(y, true);
+x = access_resolve(x, ACCESS_READ);
+y = access_resolve(y, ACCESS_READ);
+z = access_resolve(z, ACCESS_WRITE);
 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();
 Node* zlen = argument(3);
 x = must_be_not_null(x, true);
 z = must_be_not_null(z, true);
+x = access_resolve(x, ACCESS_READ);
+z = access_resolve(z, ACCESS_WRITE);
 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->klass()  == NULL ||
 Node* len      = argument(3);
 Node* k        = argument(4);
 out = must_be_not_null(out, true);
+in = access_resolve(in, ACCESS_READ);
+out = access_resolve(out, ACCESS_WRITE);
 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->klass()  == NULL ||
 Node* b    = argument(1);
 Node* n    = argument(2);
 Node* len  = argument(3);
 Node* inv  = argument(4);
 Node* m    = argument(6);
+a = access_resolve(a, ACCESS_READ);
+b = access_resolve(b, ACCESS_READ);
+n = access_resolve(n, ACCESS_READ);
+m = access_resolve(m, ACCESS_WRITE);
 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();
 Node* n    = argument(1);
 Node* len  = argument(2);
 Node* inv  = argument(3);
 Node* m    = argument(5);
+a = access_resolve(a, ACCESS_READ);
+n = access_resolve(n, ACCESS_READ);
+m = access_resolve(m, ACCESS_WRITE);
 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);
 return false;
 }
 // 'src_start' points to src array + scaled offset
 src = must_be_not_null(src, true);
+src = access_resolve(src, ACCESS_READ);
 Node* src_start = array_element_address(src, offset, src_elem);
 // We assume that range check is done by caller.
 // TODO: generate range check (offset+length < src.length) in debug VM.
 return false;
 }
 // 'src_start' points to src array + scaled offset
 src = must_be_not_null(src, true);
+src = access_resolve(src, ACCESS_READ);
 Node* src_start = array_element_address(src, offset, src_elem);
 // static final int[] byteTable in class CRC32C
 Node* table = get_table_from_crc32c_class(callee()->holder());
 table = must_be_not_null(table, true);
+table = access_resolve(table, ACCESS_READ);
 Node* table_start = array_element_address(table, intcon(0), T_INT);
 // We assume that range check is done by caller.
 // TODO: generate range check (offset+length < src.length) in debug VM.
 Node* src_start = basic_plus_adr(top(), base, offset);
 // static final int[] byteTable in class CRC32C
 Node* table = get_table_from_crc32c_class(callee()->holder());
 table = must_be_not_null(table, true);
+table = access_resolve(table, ACCESS_READ);
 Node* table_start = array_element_address(table, intcon(0), T_INT);
 // Call the stub.
 address stubAddr = StubRoutines::updateBytesCRC32C();
 const char *stubName = "updateBytesCRC32C";
 if (src_elem != T_BYTE) {
 return false;
 }
 // 'src_start' points to src array + scaled offset
+src = access_resolve(src, ACCESS_READ);
 Node* src_start = array_element_address(src, offset, src_elem);
 // We assume that range check is done by caller.
 // TODO: generate range check (offset+length < src.length) in debug VM.
 Node* dest_offset     = argument(4);
 src = must_be_not_null(src, true);
 dest = must_be_not_null(dest, true);
+src = access_resolve(src, ACCESS_READ);
+dest = access_resolve(dest, ACCESS_WRITE);
 // (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();
 Node* dest_offset                = argument(5);
 src = must_be_not_null(src, false);
 dest = must_be_not_null(dest, false);
+src = access_resolve(src, ACCESS_READ);
+dest = access_resolve(dest, ACCESS_WRITE);
 // (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();
 if (k_start == NULL) return false;
 // similarly, get the start address of the r vector
 Node* objRvec = load_field_from_object(cipherBlockChaining_object, "r", "[B", /*is_exact*/ false);
 if (objRvec == NULL) return false;
+objRvec = access_resolve(objRvec, ACCESS_WRITE);
 Node* r_start = array_element_address(objRvec, intcon(0), T_BYTE);
 Node* cbcCrypt;
 if (Matcher::pass_original_key_for_aes()) {
 // on SPARC we need to pass the original key since key expansion needs to happen in intrinsics due to
 Node* src = argument(1);
 Node* src_offset = argument(2);
 Node* len = argument(3);
 Node* dest = argument(4);
 Node* dest_offset = argument(5);
+src = access_resolve(src, ACCESS_READ);
+dest = access_resolve(dest, ACCESS_WRITE);
+counterMode_object = access_resolve(counterMode_object, ACCESS_WRITE);
 // (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();
 Node* k_start = get_key_start_from_aescrypt_object(aescrypt_object);
 if (k_start == NULL) return false;
 // similarly, get the start address of the r vector
 Node* obj_counter = load_field_from_object(counterMode_object, "counter", "[B", /*is_exact*/ false);
 if (obj_counter == NULL) return false;
+obj_counter = access_resolve(obj_counter, ACCESS_WRITE);
 Node* cnt_start = array_element_address(obj_counter, intcon(0), T_BYTE);
 Node* saved_encCounter = load_field_from_object(counterMode_object, "encryptedCounter", "[B", /*is_exact*/ false);
 if (saved_encCounter == NULL) return false;
+saved_encCounter = access_resolve(saved_encCounter, ACCESS_WRITE);
 Node* saved_encCounter_start = array_element_address(saved_encCounter, intcon(0), T_BYTE);
 Node* used = field_address_from_object(counterMode_object, "used", "I", /*is_exact*/ false);
 Node* ctrCrypt;
 if (Matcher::pass_original_key_for_aes()) {
 #endif // PPC64
 assert (objAESCryptKey != NULL, "wrong version of com.sun.crypto.provider.AESCrypt");
 if (objAESCryptKey == NULL) return (Node *) NULL;
 // now have the array, need to get the start address of the K array
+objAESCryptKey = access_resolve(objAESCryptKey, ACCESS_READ);
 Node* k_start = array_element_address(objAESCryptKey, intcon(0), T_INT);
 return k_start;
 }
 //------------------------------get_original_key_start_from_aescrypt_object-----------------------
 Node* objAESCryptKey = load_field_from_object(aescrypt_object, "lastKey", "[B", /*is_exact*/ false);
 assert (objAESCryptKey != NULL, "wrong version of com.sun.crypto.provider.AESCrypt");
 if (objAESCryptKey == NULL) return (Node *) NULL;
 // now have the array, need to get the start address of the lastKey array
+objAESCryptKey = access_resolve(objAESCryptKey, ACCESS_READ);
 Node* original_k_start = array_element_address(objAESCryptKey, intcon(0), T_BYTE);
 return original_k_start;
 }
 //----------------------------inline_cipherBlockChaining_AESCrypt_predicate----------------------------
 Node* subkeyH        = argument(4);
 state = must_be_not_null(state, true);
 subkeyH = must_be_not_null(subkeyH, true);
 data = must_be_not_null(data, true);
+state = access_resolve(state, ACCESS_WRITE);
+subkeyH = access_resolve(subkeyH, ACCESS_READ);
+data = access_resolve(data, ACCESS_READ);
 Node* state_start  = array_element_address(state, intcon(0), T_LONG);
 assert(state_start, "state is NULL");
 Node* subkeyH_start  = array_element_address(subkeyH, intcon(0), T_LONG);
 assert(subkeyH_start, "subkeyH is NULL");
 if (src_elem != T_BYTE) {
 return false;
 }
 // 'src_start' points to src array + offset
 src = must_be_not_null(src, true);
+src = access_resolve(src, ACCESS_READ);
 Node* src_start = array_element_address(src, ofs, src_elem);
 Node* state = NULL;
 address stubAddr;
 const char *stubName;
 if (src_elem != T_BYTE) {
 return false;
 }
 // 'src_start' points to src array + offset
 src = must_be_not_null(src, false);
+src = access_resolve(src, ACCESS_READ);
 Node* src_start = array_element_address(src, ofs, src_elem);
 const char* klass_SHA_name = NULL;
 const char* stub_name = NULL;
 address     stub_addr = NULL;
 Node* sha_state = load_field_from_object(sha_object, "state", "[I", /*is_exact*/ false);
 assert (sha_state != NULL, "wrong version of sun.security.provider.SHA/SHA2");
 if (sha_state == NULL) return (Node *) NULL;
 // now have the array, need to get the start address of the state array
+sha_state = access_resolve(sha_state, ACCESS_WRITE);
 Node* state = array_element_address(sha_state, intcon(0), T_INT);
 return state;
 }
 //------------------------------get_state_from_sha5_object-----------------------
 Node* sha_state = load_field_from_object(sha_object, "state", "[J", /*is_exact*/ false);
 assert (sha_state != NULL, "wrong version of sun.security.provider.SHA5");
 if (sha_state == NULL) return (Node *) NULL;
 // now have the array, need to get the start address of the state array
+sha_state = access_resolve(sha_state, ACCESS_WRITE);
 Node* state = array_element_address(sha_state, intcon(0), T_LONG);
 return state;
 }
 //----------------------------inline_digestBase_implCompressMB_predicate----------------------------

changeset 51705	8123901bc3d1
parent 51643	8267d480566f
child 51850	9b8f2ef4663a