truffle: src/share/vm/opto/library

comparison src/share/vm/opto/library_call.cpp @ 18041:52b4284cb496

Merge with jdk8u20-b26

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Wed, 15 Oct 2014 16:02:50 +0200
parents	4ca6dc0799b6 00c8a1255912
children	7848fc12602b

comparison

equal deleted inserted replaced

-:45d7b2c7029d
+:52b4284cb496
 Node* round_double_node(Node* n);
 bool runtime_math(const TypeFunc* call_type, address funcAddr, const char* funcName);
 bool inline_math_native(vmIntrinsics::ID id);
 bool inline_trig(vmIntrinsics::ID id);
 bool inline_math(vmIntrinsics::ID id);
-void inline_math_mathExact(Node* math);
+template <typename OverflowOp>
+bool inline_math_overflow(Node* arg1, Node* arg2);
+void inline_math_mathExact(Node* math, Node* test);
 bool inline_math_addExactI(bool is_increment);
 bool inline_math_addExactL(bool is_increment);
 bool inline_math_multiplyExactI();
 bool inline_math_multiplyExactL();
 bool inline_math_negateExactI();
 bool inline_math_negateExactL();
 bool inline_math_subtractExactI(bool is_decrement);
 bool inline_math_subtractExactL(bool is_decrement);
 bool inline_exp();
 bool inline_pow();
-void finish_pow_exp(Node* result, Node* x, Node* y, const TypeFunc* call_type, address funcAddr, const char* funcName);
+Node* finish_pow_exp(Node* result, Node* x, Node* y, const TypeFunc* call_type, address funcAddr, const char* funcName);
 bool inline_min_max(vmIntrinsics::ID id);
 Node* generate_min_max(vmIntrinsics::ID id, Node* x, Node* y);
 // This returns Type::AnyPtr, RawPtr, or OopPtr.
 int classify_unsafe_addr(Node* &base, Node* &offset);
 Node* make_unsafe_address(Node* base, Node* offset);
 bool inline_reference_get();
 bool inline_aescrypt_Block(vmIntrinsics::ID id);
 bool inline_cipherBlockChaining_AESCrypt(vmIntrinsics::ID id);
 Node* inline_cipherBlockChaining_AESCrypt_predicate(bool decrypting);
 Node* get_key_start_from_aescrypt_object(Node* aescrypt_object);
+Node* get_original_key_start_from_aescrypt_object(Node* aescrypt_object);
 bool inline_encodeISOArray();
 bool inline_updateCRC32();
 bool inline_updateBytesCRC32();
 bool inline_updateByteBufferCRC32();
 };
 if (!UseCRC32Intrinsics) return NULL;
 break;
 case vmIntrinsics::_incrementExactI:
 case vmIntrinsics::_addExactI:
-if (!Matcher::match_rule_supported(Op_AddExactI) || !UseMathExactIntrinsics) return NULL;
+if (!Matcher::match_rule_supported(Op_OverflowAddI) || !UseMathExactIntrinsics) return NULL;
 break;
 case vmIntrinsics::_incrementExactL:
 case vmIntrinsics::_addExactL:
-if (!Matcher::match_rule_supported(Op_AddExactL) || !UseMathExactIntrinsics) return NULL;
+if (!Matcher::match_rule_supported(Op_OverflowAddL) || !UseMathExactIntrinsics) return NULL;
 break;
 case vmIntrinsics::_decrementExactI:
 case vmIntrinsics::_subtractExactI:
-if (!Matcher::match_rule_supported(Op_SubExactI) || !UseMathExactIntrinsics) return NULL;
+if (!Matcher::match_rule_supported(Op_OverflowSubI) || !UseMathExactIntrinsics) return NULL;
 break;
 case vmIntrinsics::_decrementExactL:
 case vmIntrinsics::_subtractExactL:
-if (!Matcher::match_rule_supported(Op_SubExactL) || !UseMathExactIntrinsics) return NULL;
+if (!Matcher::match_rule_supported(Op_OverflowSubL) || !UseMathExactIntrinsics) return NULL;
 break;
 case vmIntrinsics::_negateExactI:
-if (!Matcher::match_rule_supported(Op_NegExactI) || !UseMathExactIntrinsics) return NULL;
+if (!Matcher::match_rule_supported(Op_OverflowSubI) || !UseMathExactIntrinsics) return NULL;
 break;
 case vmIntrinsics::_negateExactL:
-if (!Matcher::match_rule_supported(Op_NegExactL) || !UseMathExactIntrinsics) return NULL;
+if (!Matcher::match_rule_supported(Op_OverflowSubL) || !UseMathExactIntrinsics) return NULL;
 break;
 case vmIntrinsics::_multiplyExactI:
-if (!Matcher::match_rule_supported(Op_MulExactI) || !UseMathExactIntrinsics) return NULL;
+if (!Matcher::match_rule_supported(Op_OverflowMulI) || !UseMathExactIntrinsics) return NULL;
 break;
 case vmIntrinsics::_multiplyExactL:
-if (!Matcher::match_rule_supported(Op_MulExactL) || !UseMathExactIntrinsics) return NULL;
+if (!Matcher::match_rule_supported(Op_OverflowMulL) || !UseMathExactIntrinsics) return NULL;
 break;
 default:
 assert(id <= vmIntrinsics::LAST_COMPILER_INLINE, "caller responsibility");
 assert(id != vmIntrinsics::_Object_init && id != vmIntrinsics::_invoke, "enum out of order?");
 Node* LibraryCallKit::generate_current_thread(Node* &tls_output) {
 ciKlass*    thread_klass = env()->Thread_klass();
 const Type* thread_type  = TypeOopPtr::make_from_klass(thread_klass)->cast_to_ptr_type(TypePtr::NotNull);
 Node* thread = _gvn.transform(new (C) ThreadLocalNode());
 Node* p = basic_plus_adr(top()/*!oop*/, thread, in_bytes(JavaThread::threadObj_offset()));
-Node* threadObj = make_load(NULL, p, thread_type, T_OBJECT);
+Node* threadObj = make_load(NULL, p, thread_type, T_OBJECT, MemNode::unordered);
 tls_output = thread;
 return threadObj;
 }
 }
 set_result(n);
 return true;
 }
-void LibraryCallKit::finish_pow_exp(Node* result, Node* x, Node* y, const TypeFunc* call_type, address funcAddr, const char* funcName) {
+Node* LibraryCallKit::finish_pow_exp(Node* result, Node* x, Node* y, const TypeFunc* call_type, address funcAddr, const char* funcName) {
 //-------------------
 //result=(result.isNaN())? funcAddr():result;
 // Check: If isNaN() by checking result!=result? then either trap
 // or go to runtime
 Node* cmpisnan = _gvn.transform(new (C) CmpDNode(result, result));
 // The pow or exp intrinsic returned a NaN, which requires a call
 // to the runtime.  Recompile with the runtime call.
 uncommon_trap(Deoptimization::Reason_intrinsic,
 Deoptimization::Action_make_not_entrant);
 }
-set_result(result);
+return result;
 } else {
 // If this inlining ever returned NaN in the past, we compile a call
 // to the runtime to properly handle corner cases
 IfNode* iff = create_and_xform_if(control(), bolisnum, PROB_STATIC_FREQUENT, COUNT_UNKNOWN);
 assert(value_top == top(), "second value must be top");
 #endif
 result_region->init_req(2, control());
 result_val->init_req(2, value);
-set_result(result_region, result_val);
+set_control(_gvn.transform(result_region));
+return _gvn.transform(result_val);
 } else {
-set_result(result);
+return result;
 }
 }
 }
 //------------------------------inline_exp-------------------------------------
 // really odd corner cases (+/- Infinity).  Just uncommon-trap them.
 bool LibraryCallKit::inline_exp() {
 Node* arg = round_double_node(argument(0));
 Node* n   = _gvn.transform(new (C) ExpDNode(C, control(), arg));
-finish_pow_exp(n, arg, NULL, OptoRuntime::Math_D_D_Type(), CAST_FROM_FN_PTR(address, SharedRuntime::dexp), "EXP");
+n = finish_pow_exp(n, arg, NULL, OptoRuntime::Math_D_D_Type(), CAST_FROM_FN_PTR(address, SharedRuntime::dexp), "EXP");
+set_result(n);
 C->set_has_split_ifs(true); // Has chance for split-if optimization
 return true;
 }
 //------------------------------inline_pow-------------------------------------
 // Inline power instructions, if possible.
 bool LibraryCallKit::inline_pow() {
 // Pseudocode for pow
-// if (x <= 0.0) {
+// if (y == 2) {
-//   long longy = (long)y;
+//   return x * x;
-//   if ((double)longy == y) { // if y is long
+// } else {
-//     if (y + 1 == y) longy = 0; // huge number: even
+//   if (x <= 0.0) {
-//     result = ((1&longy) == 0)?-DPow(abs(x), y):DPow(abs(x), y);
+//     long longy = (long)y;
+//     if ((double)longy == y) { // if y is long
+//       if (y + 1 == y) longy = 0; // huge number: even
+//       result = ((1&longy) == 0)?-DPow(abs(x), y):DPow(abs(x), y);
+//     } else {
+//       result = NaN;
+//     }
 //   } else {
-//     result = NaN;
+//     result = DPow(x,y);
 //   }
-// } else {
+//   if (result != result)?  {
-//   result = DPow(x,y);
+//     result = uncommon_trap() or runtime_call();
+//   }
+//   return result;
 // }
-// if (result != result)?  {
-//   result = uncommon_trap() or runtime_call();
-// }
-// return result;
 Node* x = round_double_node(argument(0));
 Node* y = round_double_node(argument(2));
 Node* result = NULL;
+Node*   const_two_node = makecon(TypeD::make(2.0));
+Node*   cmp_node       = _gvn.transform(new (C) CmpDNode(y, const_two_node));
+Node*   bool_node      = _gvn.transform(new (C) BoolNode(cmp_node, BoolTest::eq));
+IfNode* if_node        = create_and_xform_if(control(), bool_node, PROB_STATIC_INFREQUENT, COUNT_UNKNOWN);
+Node*   if_true        = _gvn.transform(new (C) IfTrueNode(if_node));
+Node*   if_false       = _gvn.transform(new (C) IfFalseNode(if_node));
+RegionNode* region_node = new (C) RegionNode(3);
+region_node->init_req(1, if_true);
+Node* phi_node = new (C) PhiNode(region_node, Type::DOUBLE);
+// special case for x^y where y == 2, we can convert it to x * x
+phi_node->init_req(1, _gvn.transform(new (C) MulDNode(x, x)));
+// set control to if_false since we will now process the false branch
+set_control(if_false);
 if (!too_many_traps(Deoptimization::Reason_intrinsic)) {
 // Short form: skip the fancy tests and just check for NaN result.
 result = _gvn.transform(new (C) PowDNode(C, control(), x, y));
 } else {
 set_control(_gvn.transform(r));
 record_for_igvn(r);
 result = _gvn.transform(phi);
 }
-finish_pow_exp(result, x, y, OptoRuntime::Math_DD_D_Type(), CAST_FROM_FN_PTR(address, SharedRuntime::dpow), "POW");
+result = finish_pow_exp(result, x, y, OptoRuntime::Math_DD_D_Type(), CAST_FROM_FN_PTR(address, SharedRuntime::dpow), "POW");
+// control from finish_pow_exp is now input to the region node
+region_node->set_req(2, control());
+// the result from finish_pow_exp is now input to the phi node
+phi_node->init_req(2, result);
+set_control(_gvn.transform(region_node));
+record_for_igvn(region_node);
+set_result(_gvn.transform(phi_node));
 C->set_has_split_ifs(true); // Has chance for split-if optimization
 return true;
 }
 runtime_math(OptoRuntime::Math_D_D_Type(), FN_PTR(SharedRuntime::dlog),   "LOG");
 case vmIntrinsics::_dlog10: return Matcher::has_match_rule(Op_Log10D) ? inline_math(id) :
 runtime_math(OptoRuntime::Math_D_D_Type(), FN_PTR(SharedRuntime::dlog10), "LOG10");
 // These intrinsics are supported on all hardware
-case vmIntrinsics::_dsqrt:  return Matcher::has_match_rule(Op_SqrtD)  ? inline_math(id) : false;
+case vmIntrinsics::_dsqrt:  return Matcher::match_rule_supported(Op_SqrtD) ? inline_math(id) : false;
 case vmIntrinsics::_dabs:   return Matcher::has_match_rule(Op_AbsD)   ? inline_math(id) : false;
 case vmIntrinsics::_dexp:   return Matcher::has_match_rule(Op_ExpD)   ? inline_exp()    :
 runtime_math(OptoRuntime::Math_D_D_Type(),  FN_PTR(SharedRuntime::dexp),  "EXP");
 case vmIntrinsics::_dpow:   return Matcher::has_match_rule(Op_PowD)   ? inline_pow()    :
 bool LibraryCallKit::inline_min_max(vmIntrinsics::ID id) {
 set_result(generate_min_max(id, argument(0), argument(1)));
 return true;
 }
-void LibraryCallKit::inline_math_mathExact(Node* math) {
+void LibraryCallKit::inline_math_mathExact(Node* math, Node *test) {
-// If we didn't get the expected opcode it means we have optimized
+Node* bol = _gvn.transform( new (C) BoolNode(test, BoolTest::overflow) );
-// the node to something else and don't need the exception edge.
-if (!math->is_MathExact()) {
-set_result(math);
-return;
-}
-Node* result = _gvn.transform( new(C) ProjNode(math, MathExactNode::result_proj_node));
-Node* flags = _gvn.transform( new(C) FlagsProjNode(math, MathExactNode::flags_proj_node));
-Node* bol = _gvn.transform( new (C) BoolNode(flags, BoolTest::overflow) );
 IfNode* check = create_and_map_if(control(), bol, PROB_UNLIKELY_MAG(3), COUNT_UNKNOWN);
 Node* fast_path = _gvn.transform( new (C) IfFalseNode(check));
 Node* slow_path = _gvn.transform( new (C) IfTrueNode(check) );
 {
 uncommon_trap(Deoptimization::Reason_intrinsic,
 Deoptimization::Action_none);
 }
 set_control(fast_path);
-set_result(result);
+set_result(math);
+}
+template <typename OverflowOp>
+bool LibraryCallKit::inline_math_overflow(Node* arg1, Node* arg2) {
+typedef typename OverflowOp::MathOp MathOp;
+MathOp* mathOp = new(C) MathOp(arg1, arg2);
+Node* operation = _gvn.transform( mathOp );
+Node* ofcheck = _gvn.transform( new(C) OverflowOp(arg1, arg2) );
+inline_math_mathExact(operation, ofcheck);
+return true;
 }
 bool LibraryCallKit::inline_math_addExactI(bool is_increment) {
-Node* arg1 = argument(0);
+return inline_math_overflow<OverflowAddINode>(argument(0), is_increment ? intcon(1) : argument(1));
-Node* arg2 = NULL;
-if (is_increment) {
-arg2 = intcon(1);
-} else {
-arg2 = argument(1);
-}
-Node* add = _gvn.transform( new(C) AddExactINode(NULL, arg1, arg2) );
-inline_math_mathExact(add);
-return true;
 }
 bool LibraryCallKit::inline_math_addExactL(bool is_increment) {
-Node* arg1 = argument(0); // type long
+return inline_math_overflow<OverflowAddLNode>(argument(0), is_increment ? longcon(1) : argument(2));
-// argument(1) == TOP
-Node* arg2 = NULL;
-if (is_increment) {
-arg2 = longcon(1);
-} else {
-arg2 = argument(2); // type long
-// argument(3) == TOP
-}
-Node* add = _gvn.transform(new(C) AddExactLNode(NULL, arg1, arg2));
-inline_math_mathExact(add);
-return true;
 }
 bool LibraryCallKit::inline_math_subtractExactI(bool is_decrement) {
-Node* arg1 = argument(0);
+return inline_math_overflow<OverflowSubINode>(argument(0), is_decrement ? intcon(1) : argument(1));
-Node* arg2 = NULL;
-if (is_decrement) {
-arg2 = intcon(1);
-} else {
-arg2 = argument(1);
-}
-Node* sub = _gvn.transform(new(C) SubExactINode(NULL, arg1, arg2));
-inline_math_mathExact(sub);
-return true;
 }
 bool LibraryCallKit::inline_math_subtractExactL(bool is_decrement) {
-Node* arg1 = argument(0); // type long
+return inline_math_overflow<OverflowSubLNode>(argument(0), is_decrement ? longcon(1) : argument(2));
-// argument(1) == TOP
-Node* arg2 = NULL;
-if (is_decrement) {
-arg2 = longcon(1);
-} else {
-arg2 = argument(2); // type long
-// argument(3) == TOP
-}
-Node* sub = _gvn.transform(new(C) SubExactLNode(NULL, arg1, arg2));
-inline_math_mathExact(sub);
-return true;
 }
 bool LibraryCallKit::inline_math_negateExactI() {
-Node* arg1 = argument(0);
+return inline_math_overflow<OverflowSubINode>(intcon(0), argument(0));
-Node* neg = _gvn.transform(new(C) NegExactINode(NULL, arg1));
-inline_math_mathExact(neg);
-return true;
 }
 bool LibraryCallKit::inline_math_negateExactL() {
-Node* arg1 = argument(0);
+return inline_math_overflow<OverflowSubLNode>(longcon(0), argument(0));
-// argument(1) == TOP
-Node* neg = _gvn.transform(new(C) NegExactLNode(NULL, arg1));
-inline_math_mathExact(neg);
-return true;
 }
 bool LibraryCallKit::inline_math_multiplyExactI() {
-Node* arg1 = argument(0);
+return inline_math_overflow<OverflowMulINode>(argument(0), argument(1));
-Node* arg2 = argument(1);
-Node* mul = _gvn.transform(new(C) MulExactINode(NULL, arg1, arg2));
-inline_math_mathExact(mul);
-return true;
 }
 bool LibraryCallKit::inline_math_multiplyExactL() {
-Node* arg1 = argument(0);
+return inline_math_overflow<OverflowMulLNode>(argument(0), argument(2));
-// argument(1) == TOP
-Node* arg2 = argument(2);
-// argument(3) == TOP
-Node* mul = _gvn.transform(new(C) MulExactLNode(NULL, arg1, arg2));
-inline_math_mathExact(mul);
-return true;
 }
 Node*
 LibraryCallKit::generate_min_max(vmIntrinsics::ID id, Node* x0, Node* y0) {
 // These are the candidate return value:
 // volatile membars (for stores; compare Parse::do_put_xxx), which
 // we cannot do effectively here because we probably only have a
 // rough approximation of type.
 need_mem_bar = true;
 // For Stores, place a memory ordering barrier now.
-if (is_store)
+if (is_store) {
 insert_mem_bar(Op_MemBarRelease);
+} else {
+if (support_IRIW_for_not_multiple_copy_atomic_cpu) {
+insert_mem_bar(Op_MemBarVolatile);
+}
+}
 }
 // Memory barrier to prevent normal and 'unsafe' accesses from
 // bypassing each other.  Happens after null checks, so the
 // exception paths do not take memory state from the memory barrier,
 // of safe & unsafe memory.  Otherwise fails in a CTW of rt.jar
 // around 5701, class sun/reflect/UnsafeBooleanFieldAccessorImpl.
 if (need_mem_bar) insert_mem_bar(Op_MemBarCPUOrder);
 if (!is_store) {
-Node* p = make_load(control(), adr, value_type, type, adr_type, is_volatile);
+Node* p = make_load(control(), adr, value_type, type, adr_type, MemNode::unordered, is_volatile);
 // load value
 switch (type) {
 case T_BOOLEAN:
 case T_CHAR:
 case T_BYTE:
 }
 break;
 case T_ADDRESS:
 // Cast to an int type.
 p = _gvn.transform(new (C) CastP2XNode(NULL, p));
-p = ConvX2L(p);
+p = ConvX2UL(p);
 break;
 default:
 fatal(err_msg_res("unexpected type %d: %s", type, type2name(type)));
 break;
 }
 val = ConvL2X(val);
 val = _gvn.transform(new (C) CastX2PNode(val));
 break;
 }
+MemNode::MemOrd mo = is_volatile ? MemNode::release : MemNode::unordered;
 if (type != T_OBJECT ) {
-(void) store_to_memory(control(), adr, val, type, adr_type, is_volatile);
+(void) store_to_memory(control(), adr, val, type, adr_type, mo, is_volatile);
 } else {
 // Possibly an oop being stored to Java heap or native memory
 if (!TypePtr::NULL_PTR->higher_equal(_gvn.type(heap_base_oop))) {
 // oop to Java heap.
-(void) store_oop_to_unknown(control(), heap_base_oop, adr, adr_type, val, type);
+(void) store_oop_to_unknown(control(), heap_base_oop, adr, adr_type, val, type, mo);
 } else {
 // We can't tell at compile time if we are storing in the Java heap or outside
 // of it. So we need to emit code to conditionally do the proper type of
 // store.
 #define __ ideal.
 // QQQ who knows what probability is here??
 __ if_then(heap_base_oop, BoolTest::ne, null(), PROB_UNLIKELY(0.999)); {
 // Sync IdealKit and graphKit.
 sync_kit(ideal);
-Node* st = store_oop_to_unknown(control(), heap_base_oop, adr, adr_type, val, type);
+Node* st = store_oop_to_unknown(control(), heap_base_oop, adr, adr_type, val, type, mo);
 // Update IdealKit memory.
 __ sync_kit(this);
 } __ else_(); {
-__ store(__ ctrl(), adr, val, type, alias_type->index(), is_volatile);
+__ store(__ ctrl(), adr, val, type, alias_type->index(), mo, is_volatile);
 } __ end_if();
 // Final sync IdealKit and GraphKit.
 final_sync(ideal);
 #undef __
 }
 }
 }
 if (is_volatile) {
-if (!is_store)
+if (!is_store) {
 insert_mem_bar(Op_MemBarAcquire);
-else
+} else {
-insert_mem_bar(Op_MemBarVolatile);
+if (!support_IRIW_for_not_multiple_copy_atomic_cpu) {
+insert_mem_bar(Op_MemBarVolatile);
+}
+}
 }
 if (need_mem_bar) insert_mem_bar(Op_MemBarCPUOrder);
 return true;
 #ifdef _LP64
 if (adr->bottom_type()->is_ptr_to_narrowoop()) {
 Node *newval_enc = _gvn.transform(new (C) EncodePNode(newval, newval->bottom_type()->make_narrowoop()));
 if (kind == LS_xchg) {
 load_store = _gvn.transform(new (C) GetAndSetNNode(control(), mem, adr,
 newval_enc, adr_type, value_type->make_narrowoop()));
 } else {
 assert(kind == LS_cmpxchg, "wrong LoadStore operation");
 Node *oldval_enc = _gvn.transform(new (C) EncodePNode(oldval, oldval->bottom_type()->make_narrowoop()));
 load_store = _gvn.transform(new (C) CompareAndSwapNNode(control(), mem, adr,
 newval_enc, oldval_enc));
 }
 } else
 #endif
 {
 if (kind == LS_xchg) {
 insert_mem_bar(Op_MemBarCPUOrder);
 // Ensure that the store is atomic for longs:
 const bool require_atomic_access = true;
 Node* store;
 if (type == T_OBJECT) // reference stores need a store barrier.
-store = store_oop_to_unknown(control(), base, adr, adr_type, val, type);
+store = store_oop_to_unknown(control(), base, adr, adr_type, val, type, MemNode::release);
 else {
-store = store_to_memory(control(), adr, val, type, adr_type, require_atomic_access);
+store = store_to_memory(control(), adr, val, type, adr_type, MemNode::release, require_atomic_access);
 }
 insert_mem_bar(Op_MemBarCPUOrder);
 return true;
 }
 // Regardless of form, don't allow previous ld/st to move down,
 // then issue acquire, release, or volatile mem_bar.
 insert_mem_bar(Op_MemBarCPUOrder);
 switch(id) {
 case vmIntrinsics::_loadFence:
-insert_mem_bar(Op_MemBarAcquire);
+insert_mem_bar(Op_LoadFence);
 return true;
 case vmIntrinsics::_storeFence:
-insert_mem_bar(Op_MemBarRelease);
+insert_mem_bar(Op_StoreFence);
 return true;
 case vmIntrinsics::_fullFence:
 insert_mem_bar(Op_MemBarVolatile);
 return true;
 default:
 // Serializable.class or Object[].class.   The runtime will handle it.
 // But we must make an explicit check for initialization.
 Node* insp = basic_plus_adr(kls, in_bytes(InstanceKlass::init_state_offset()));
 // Use T_BOOLEAN for InstanceKlass::_init_state so the compiler
 // can generate code to load it as unsigned byte.
-Node* inst = make_load(NULL, insp, TypeInt::UBYTE, T_BOOLEAN);
+Node* inst = make_load(NULL, insp, TypeInt::UBYTE, T_BOOLEAN, MemNode::unordered);
 Node* bits = intcon(InstanceKlass::fully_initialized);
 test = _gvn.transform(new (C) SubINode(inst, bits));
 // The 'test' is non-zero if we need to take a slow path.
 }
 Node* cls = null_check(argument(1), T_OBJECT);
 Node* kls = load_klass_from_mirror(cls, false, NULL, 0);
 kls = null_check(kls, T_OBJECT);
 ByteSize offset = TRACE_ID_OFFSET;
 Node* insp = basic_plus_adr(kls, in_bytes(offset));
-Node* tvalue = make_load(NULL, insp, TypeLong::LONG, T_LONG);
+Node* tvalue = make_load(NULL, insp, TypeLong::LONG, T_LONG, MemNode::unordered);
 Node* bits = longcon(~0x03l); // ignore bit 0 & 1
 Node* andl = _gvn.transform(new (C) AndLNode(tvalue, bits));
 Node* clsused = longcon(0x01l); // set the class bit
 Node* orl = _gvn.transform(new (C) OrLNode(tvalue, clsused));
 const TypePtr *adr_type = _gvn.type(insp)->isa_ptr();
-store_to_memory(control(), insp, orl, T_LONG, adr_type);
+store_to_memory(control(), insp, orl, T_LONG, adr_type, MemNode::unordered);
 set_result(andl);
 return true;
 }
 bool LibraryCallKit::inline_native_threadID() {
 Node* tls_ptr = NULL;
 Node* cur_thr = generate_current_thread(tls_ptr);
 Node* p = basic_plus_adr(top()/*!oop*/, tls_ptr, in_bytes(JavaThread::osthread_offset()));
-Node* osthread = make_load(NULL, p, TypeRawPtr::NOTNULL, T_ADDRESS);
+Node* osthread = make_load(NULL, p, TypeRawPtr::NOTNULL, T_ADDRESS, MemNode::unordered);
 p = basic_plus_adr(top()/*!oop*/, osthread, in_bytes(OSThread::thread_id_offset()));
 Node* threadid = NULL;
 size_t thread_id_size = OSThread::thread_id_size();
 if (thread_id_size == (size_t) BytesPerLong) {
-threadid = ConvL2I(make_load(control(), p, TypeLong::LONG, T_LONG));
+threadid = ConvL2I(make_load(control(), p, TypeLong::LONG, T_LONG, MemNode::unordered));
 } else if (thread_id_size == (size_t) BytesPerInt) {
-threadid = make_load(control(), p, TypeInt::INT, T_INT);
+threadid = make_load(control(), p, TypeInt::INT, T_INT, MemNode::unordered);
 } else {
 ShouldNotReachHere();
 }
 set_result(threadid);
 return true;
 //------------------------inline_native_isInterrupted------------------
 // private native boolean java.lang.Thread.isInterrupted(boolean ClearInterrupted);
 bool LibraryCallKit::inline_native_isInterrupted() {
 // Add a fast path to t.isInterrupted(clear_int):
-//   (t == Thread.current() && (!TLS._osthread._interrupted || !clear_int))
+//   (t == Thread.current() &&
+//    (!TLS._osthread._interrupted || WINDOWS_ONLY(false) NOT_WINDOWS(!clear_int)))
 //   ? TLS._osthread._interrupted : /*slow path:*/ t.isInterrupted(clear_int)
 // So, in the common case that the interrupt bit is false,
 // we avoid making a call into the VM.  Even if the interrupt bit
 // is true, if the clear_int argument is false, we avoid the VM call.
 // However, if the receiver is not currentThread, we must call the VM,
 generate_slow_guard(bol_thr, slow_region);
 // (b) Interrupt bit on TLS must be false.
 Node* p = basic_plus_adr(top()/*!oop*/, tls_ptr, in_bytes(JavaThread::osthread_offset()));
-Node* osthread = make_load(NULL, p, TypeRawPtr::NOTNULL, T_ADDRESS);
+Node* osthread = make_load(NULL, p, TypeRawPtr::NOTNULL, T_ADDRESS, MemNode::unordered);
 p = basic_plus_adr(top()/*!oop*/, osthread, in_bytes(OSThread::interrupted_offset()));
 // Set the control input on the field _interrupted read to prevent it floating up.
-Node* int_bit = make_load(control(), p, TypeInt::BOOL, T_INT);
+Node* int_bit = make_load(control(), p, TypeInt::BOOL, T_INT, MemNode::unordered);
 Node* cmp_bit = _gvn.transform(new (C) CmpINode(int_bit, intcon(0)));
 Node* bol_bit = _gvn.transform(new (C) BoolNode(cmp_bit, BoolTest::ne));
 IfNode* iff_bit = create_and_map_if(control(), bol_bit, PROB_UNLIKELY_MAG(3), COUNT_UNKNOWN);
 result_val->init_req(no_int_result_path, intcon(0));
 // drop through to next case
 set_control( _gvn.transform(new (C) IfTrueNode(iff_bit)));
+#ifndef TARGET_OS_FAMILY_windows
 // (c) Or, if interrupt bit is set and clear_int is false, use 2nd fast path.
 Node* clr_arg = argument(1);
 Node* cmp_arg = _gvn.transform(new (C) CmpINode(clr_arg, intcon(0)));
 Node* bol_arg = _gvn.transform(new (C) BoolNode(cmp_arg, BoolTest::ne));
 IfNode* iff_arg = create_and_map_if(control(), bol_arg, PROB_FAIR, COUNT_UNKNOWN);
 result_rgn->init_req(no_clear_result_path, false_arg);
 result_val->init_req(no_clear_result_path, intcon(1));
 // drop through to next case
 set_control( _gvn.transform(new (C) IfTrueNode(iff_arg)));
+#else
+// To return true on Windows you must read the _interrupted field
+// and check the the event state i.e. take the slow path.
+#endif // TARGET_OS_FAMILY_windows
 // (d) Otherwise, go to the slow path.
 slow_region->add_req(control());
 set_control( _gvn.transform(slow_region));
 //---------------------------load_mirror_from_klass----------------------------
 // Given a klass oop, load its java mirror (a java.lang.Class oop).
 Node* LibraryCallKit::load_mirror_from_klass(Node* klass) {
 Node* p = basic_plus_adr(klass, in_bytes(Klass::java_mirror_offset()));
-return make_load(NULL, p, TypeInstPtr::MIRROR, T_OBJECT);
+return make_load(NULL, p, TypeInstPtr::MIRROR, T_OBJECT, MemNode::unordered);
 }
 //-----------------------load_klass_from_mirror_common-------------------------
 // Given a java mirror (a java.lang.Class oop), load its corresponding klass oop.
 // Test the klass oop for null (signifying a primitive Class like Integer.TYPE),
 // Fall through if (mods & mask) == bits, take the guard otherwise.
 Node* LibraryCallKit::generate_access_flags_guard(Node* kls, int modifier_mask, int modifier_bits, RegionNode* region) {
 // Branch around if the given klass has the given modifier bit set.
 // Like generate_guard, adds a new path onto the region.
 Node* modp = basic_plus_adr(kls, in_bytes(Klass::access_flags_offset()));
-Node* mods = make_load(NULL, modp, TypeInt::INT, T_INT);
+Node* mods = make_load(NULL, modp, TypeInt::INT, T_INT, MemNode::unordered);
 Node* mask = intcon(modifier_mask);
 Node* bits = intcon(modifier_bits);
 Node* mbit = _gvn.transform(new (C) AndINode(mods, mask));
 Node* cmp  = _gvn.transform(new (C) CmpINode(mbit, bits));
 Node* bol  = _gvn.transform(new (C) BoolNode(cmp, BoolTest::ne));
 query_value = gen_instanceof(obj, kls, safe_for_replace);
 break;
 case vmIntrinsics::_getModifiers:
 p = basic_plus_adr(kls, in_bytes(Klass::modifier_flags_offset()));
-query_value = make_load(NULL, p, TypeInt::INT, T_INT);
+query_value = make_load(NULL, p, TypeInt::INT, T_INT, MemNode::unordered);
 break;
 case vmIntrinsics::_isInterface:
 // (To verify this code sequence, check the asserts in JVM_IsInterface.)
 if (generate_interface_guard(kls, region) != NULL)
 case vmIntrinsics::_getComponentType:
 if (generate_array_guard(kls, region) != NULL) {
 // Be sure to pin the oop load to the guard edge just created:
 Node* is_array_ctrl = region->in(region->req()-1);
 Node* cma = basic_plus_adr(kls, in_bytes(ArrayKlass::component_mirror_offset()));
-Node* cmo = make_load(is_array_ctrl, cma, TypeInstPtr::MIRROR, T_OBJECT);
+Node* cmo = make_load(is_array_ctrl, cma, TypeInstPtr::MIRROR, T_OBJECT, MemNode::unordered);
 phi->add_req(cmo);
 }
 query_value = null();  // non-array case is null
 break;
 case vmIntrinsics::_getClassAccessFlags:
 p = basic_plus_adr(kls, in_bytes(Klass::access_flags_offset()));
-query_value = make_load(NULL, p, TypeInt::INT, T_INT);
+query_value = make_load(NULL, p, TypeInt::INT, T_INT, MemNode::unordered);
 break;
 default:
 fatal_unexpected_iid(id);
 break;
 // Get the Method* out of the appropriate vtable entry.
 int entry_offset  = (InstanceKlass::vtable_start_offset() +
 vtable_index*vtableEntry::size()) * wordSize +
 vtableEntry::method_offset_in_bytes();
 Node* entry_addr  = basic_plus_adr(obj_klass, entry_offset);
-Node* target_call = make_load(NULL, entry_addr, TypePtr::NOTNULL, T_ADDRESS);
+Node* target_call = make_load(NULL, entry_addr, TypePtr::NOTNULL, T_ADDRESS, MemNode::unordered);
 // Compare the target method with the expected method (e.g., Object.hashCode).
 const TypePtr* native_call_addr = TypeMetadataPtr::make(method);
 Node* native_call = makecon(native_call_addr);
 set_edges_for_java_call(slow_call);
 return slow_call;
 }
-//------------------------------inline_native_hashcode--------------------
+/**
-// Build special case code for calls to hashCode on an object.
+* Build special case code for calls to hashCode on an object. This call may
+* be virtual (invokevirtual) or bound (invokespecial). For each case we generate
+* slightly different code.
+*/
 bool LibraryCallKit::inline_native_hashcode(bool is_virtual, bool is_static) {
 assert(is_static == callee()->is_static(), "correct intrinsic selection");
 assert(!(is_virtual && is_static), "either virtual, special, or static");
 enum { _slow_path = 1, _fast_path, _null_path, PATH_LIMIT };
 RegionNode* result_reg = new(C) RegionNode(PATH_LIMIT);
-PhiNode*    result_val = new(C) PhiNode(result_reg,
+PhiNode*    result_val = new(C) PhiNode(result_reg, TypeInt::INT);
-TypeInt::INT);
 PhiNode*    result_io  = new(C) PhiNode(result_reg, Type::ABIO);
-PhiNode*    result_mem = new(C) PhiNode(result_reg, Type::MEMORY,
+PhiNode*    result_mem = new(C) PhiNode(result_reg, Type::MEMORY, TypePtr::BOTTOM);
-TypePtr::BOTTOM);
 Node* obj = NULL;
 if (!is_static) {
 // Check for hashing null object
 obj = null_check_receiver();
 if (stopped())  return true;        // unconditionally null
 if (!stopped())
 set_result(result_val->in(_null_path));
 return true;
 }
-// After null check, get the object's klass.
-Node* obj_klass = load_object_klass(obj);
-// This call may be virtual (invokevirtual) or bound (invokespecial).
-// For each case we generate slightly different code.
 // We only go to the fast case code if we pass a number of guards.  The
 // paths which do not pass are accumulated in the slow_region.
 RegionNode* slow_region = new (C) RegionNode(1);
 record_for_igvn(slow_region);
 // If the target method which we are calling happens to be the native
 // Object hashCode() method, we pass the guard.  We do not need this
 // guard for non-virtual calls -- the caller is known to be the native
 // Object hashCode().
 if (is_virtual) {
+// After null check, get the object's klass.
+Node* obj_klass = load_object_klass(obj);
 generate_virtual_guard(obj_klass, slow_region);
 }
 // Get the header out of the object, use LoadMarkNode when available
 Node* header_addr = basic_plus_adr(obj, oopDesc::mark_offset_in_bytes());
-Node* header = make_load(control(), header_addr, TypeX_X, TypeX_X->basic_type());
+// The control of the load must be NULL. Otherwise, the load can move before
+// the null check after castPP removal.
+Node* no_ctrl = NULL;
+Node* header = make_load(no_ctrl, header_addr, TypeX_X, TypeX_X->basic_type(), MemNode::unordered);
 // Test the header to see if it is unlocked.
-Node *lock_mask      = _gvn.MakeConX(markOopDesc::biased_lock_mask_in_place);
+Node* lock_mask      = _gvn.MakeConX(markOopDesc::biased_lock_mask_in_place);
-Node *lmasked_header = _gvn.transform(new (C) AndXNode(header, lock_mask));
+Node* lmasked_header = _gvn.transform(new (C) AndXNode(header, lock_mask));
-Node *unlocked_val   = _gvn.MakeConX(markOopDesc::unlocked_value);
+Node* unlocked_val   = _gvn.MakeConX(markOopDesc::unlocked_value);
-Node *chk_unlocked   = _gvn.transform(new (C) CmpXNode( lmasked_header, unlocked_val));
+Node* chk_unlocked   = _gvn.transform(new (C) CmpXNode( lmasked_header, unlocked_val));
-Node *test_unlocked  = _gvn.transform(new (C) BoolNode( chk_unlocked, BoolTest::ne));
+Node* test_unlocked  = _gvn.transform(new (C) BoolNode( chk_unlocked, BoolTest::ne));
 generate_slow_guard(test_unlocked, slow_region);
 // Get the hash value and check to see that it has been properly assigned.
 // We depend on hash_mask being at most 32 bits and avoid the use of
 // hash_mask_in_place because it could be larger than 32 bits in a 64-bit
 // vm: see markOop.hpp.
-Node *hash_mask      = _gvn.intcon(markOopDesc::hash_mask);
+Node* hash_mask      = _gvn.intcon(markOopDesc::hash_mask);
-Node *hash_shift     = _gvn.intcon(markOopDesc::hash_shift);
+Node* hash_shift     = _gvn.intcon(markOopDesc::hash_shift);
-Node *hshifted_header= _gvn.transform(new (C) URShiftXNode(header, hash_shift));
+Node* hshifted_header= _gvn.transform(new (C) URShiftXNode(header, hash_shift));
 // This hack lets the hash bits live anywhere in the mark object now, as long
 // as the shift drops the relevant bits into the low 32 bits.  Note that
 // Java spec says that HashCode is an int so there's no point in capturing
 // an 'X'-sized hashcode (32 in 32-bit build or 64 in 64-bit build).
 hshifted_header      = ConvX2I(hshifted_header);
-Node *hash_val       = _gvn.transform(new (C) AndINode(hshifted_header, hash_mask));
+Node* hash_val       = _gvn.transform(new (C) AndINode(hshifted_header, hash_mask));
-Node *no_hash_val    = _gvn.intcon(markOopDesc::no_hash);
+Node* no_hash_val    = _gvn.intcon(markOopDesc::no_hash);
-Node *chk_assigned   = _gvn.transform(new (C) CmpINode( hash_val, no_hash_val));
+Node* chk_assigned   = _gvn.transform(new (C) CmpINode( hash_val, no_hash_val));
-Node *test_assigned  = _gvn.transform(new (C) BoolNode( chk_assigned, BoolTest::eq));
+Node* test_assigned  = _gvn.transform(new (C) BoolNode( chk_assigned, BoolTest::eq));
 generate_slow_guard(test_assigned, slow_region);
 Node* init_mem = reset_memory();
 // fill in the rest of the null path:
 if (!stopped()) {
 // It's an instance, and it passed the slow-path tests.
 PreserveJVMState pjvms(this);
 Node* obj_size  = NULL;
-Node* alloc_obj = new_instance(obj_klass, NULL, &obj_size);
+// Need to deoptimize on exception from allocation since Object.clone intrinsic
+// is reexecuted if deoptimization occurs and there could be problems when merging
+// exception state between multiple Object.clone versions (reexecute=true vs reexecute=false).
+Node* alloc_obj = new_instance(obj_klass, NULL, &obj_size, /*deoptimize_on_exception=*/true);
 copy_to_clone(obj, alloc_obj, obj_size, false, !use_ReduceInitialCardMarks());
 // Present the results of the slow call.
 result_reg->init_req(_instance_path, control());
 start = _gvn.transform(new(C) AndXNode(start, MakeConX(~to_clear)));
 if (bump_bit != 0) {
 // Store a zero to the immediately preceding jint:
 Node* x1 = _gvn.transform(new(C) AddXNode(start, MakeConX(-bump_bit)));
 Node* p1 = basic_plus_adr(dest, x1);
-mem = StoreNode::make(_gvn, control(), mem, p1, adr_type, intcon(0), T_INT);
+mem = StoreNode::make(_gvn, control(), mem, p1, adr_type, intcon(0), T_INT, MemNode::unordered);
 mem = _gvn.transform(mem);
 }
 }
 Node* end = dest_size; // pre-rounded
 mem = ClearArrayNode::clear_memory(control(), mem, dest,
 // This is a common case, since abase can be odd mod 8.
 if (((src_off | dest_off) & (BytesPerLong-1)) == BytesPerInt &&
 ((src_off ^ dest_off) & (BytesPerLong-1)) == 0) {
 Node* sptr = basic_plus_adr(src,  src_off);
 Node* dptr = basic_plus_adr(dest, dest_off);
-Node* sval = make_load(control(), sptr, TypeInt::INT, T_INT, adr_type);
+Node* sval = make_load(control(), sptr, TypeInt::INT, T_INT, adr_type, MemNode::unordered);
-store_to_memory(control(), dptr, sval, T_INT, adr_type);
+store_to_memory(control(), dptr, sval, T_INT, adr_type, MemNode::unordered);
 src_off += BytesPerInt;
 dest_off += BytesPerInt;
 } else {
 return false;
 }
 // for the target array.  This is an optimistic check.  It will
 // look in each non-null element's class, at the desired klass's
 // super_check_offset, for the desired klass.
 int sco_offset = in_bytes(Klass::super_check_offset_offset());
 Node* p3 = basic_plus_adr(dest_elem_klass, sco_offset);
-Node* n3 = new(C) LoadINode(NULL, memory(p3), p3, _gvn.type(p3)->is_ptr());
+Node* n3 = new(C) LoadINode(NULL, memory(p3), p3, _gvn.type(p3)->is_ptr(), TypeInt::INT, MemNode::unordered);
 Node* check_offset = ConvI2X(_gvn.transform(n3));
 Node* check_value  = dest_elem_klass;
 Node* src_start  = array_element_address(src,  src_offset,  T_OBJECT);
 Node* dest_start = array_element_address(dest, dest_offset, T_OBJECT);
 result = _gvn.transform(new (C) AndINode(result, intcon(0xFF)));
 Node* base = makecon(TypeRawPtr::make(StubRoutines::crc_table_addr()));
 Node* offset = _gvn.transform(new (C) LShiftINode(result, intcon(0x2)));
 Node* adr = basic_plus_adr(top(), base, ConvI2X(offset));
-result = make_load(control(), adr, TypeInt::INT, T_INT);
+result = make_load(control(), adr, TypeInt::INT, T_INT, MemNode::unordered);
 crc = _gvn.transform(new (C) URShiftINode(crc, intcon(8)));
 result = _gvn.transform(new (C) XorINode(crc, result));
 result = _gvn.transform(new (C) XorINode(result, M1));
 set_result(result);
 ciInstanceKlass* klass = env()->Object_klass();
 const TypeOopPtr* object_type = TypeOopPtr::make_from_klass(klass);
 Node* no_ctrl = NULL;
-Node* result = make_load(no_ctrl, adr, object_type, T_OBJECT);
+Node* result = make_load(no_ctrl, adr, object_type, T_OBJECT, MemNode::unordered);
 // Use the pre-barrier to record the value in the referent field
 pre_barrier(false /* do_load */,
 control(),
 NULL /* obj */, NULL /* adr */, max_juint /* alias_idx */, NULL /* val */, NULL /* val_type */,
 // Build the resultant type of the load
 const Type *type = TypeOopPtr::make_from_klass(field_klass->as_klass());
 // Build the load.
-Node* loadedField = make_load(NULL, adr, type, bt, adr_type, is_vol);
+Node* loadedField = make_load(NULL, adr, type, bt, adr_type, MemNode::unordered, is_vol);
 return loadedField;
 }
 //------------------------------inline_aescrypt_Block-----------------------
 // now need to get the start of its expanded key array
 // this requires a newer class file that has this array as littleEndian ints, otherwise we revert to java
 Node* k_start = get_key_start_from_aescrypt_object(aescrypt_object);
 if (k_start == NULL) return false;
-// Call the stub.
+if (Matcher::pass_original_key_for_aes()) {
-make_runtime_call(RC_LEAF|RC_NO_FP, OptoRuntime::aescrypt_block_Type(),
+// on SPARC we need to pass the original key since key expansion needs to happen in intrinsics due to
-stubAddr, stubName, TypePtr::BOTTOM,
+// compatibility issues between Java key expansion and SPARC crypto instructions
-src_start, dest_start, k_start);
+Node* original_k_start = get_original_key_start_from_aescrypt_object(aescrypt_object);
+if (original_k_start == NULL) return false;
+// Call the stub.
+make_runtime_call(RC_LEAF|RC_NO_FP, OptoRuntime::aescrypt_block_Type(),
+stubAddr, stubName, TypePtr::BOTTOM,
+src_start, dest_start, k_start, original_k_start);
+} else {
+// Call the stub.
+make_runtime_call(RC_LEAF|RC_NO_FP, OptoRuntime::aescrypt_block_Type(),
+stubAddr, stubName, TypePtr::BOTTOM,
+src_start, dest_start, k_start);
+}
 return true;
 }
 //------------------------------inline_cipherBlockChaining_AESCrypt-----------------------
 // 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;
 Node* r_start = array_element_address(objRvec, intcon(0), T_BYTE);
-// Call the stub, passing src_start, dest_start, k_start, r_start and src_len
+Node* cbcCrypt;
-make_runtime_call(RC_LEAF|RC_NO_FP,
+if (Matcher::pass_original_key_for_aes()) {
-OptoRuntime::cipherBlockChaining_aescrypt_Type(),
+// on SPARC we need to pass the original key since key expansion needs to happen in intrinsics due to
-stubAddr, stubName, TypePtr::BOTTOM,
+// compatibility issues between Java key expansion and SPARC crypto instructions
-src_start, dest_start, k_start, r_start, len);
+Node* original_k_start = get_original_key_start_from_aescrypt_object(aescrypt_object);
+if (original_k_start == NULL) return false;
-// return is void so no result needs to be pushed
+// Call the stub, passing src_start, dest_start, k_start, r_start, src_len and original_k_start
+cbcCrypt = make_runtime_call(RC_LEAF|RC_NO_FP,
+OptoRuntime::cipherBlockChaining_aescrypt_Type(),
+stubAddr, stubName, TypePtr::BOTTOM,
+src_start, dest_start, k_start, r_start, len, original_k_start);
+} else {
+// Call the stub, passing src_start, dest_start, k_start, r_start and src_len
+cbcCrypt = make_runtime_call(RC_LEAF|RC_NO_FP,
+OptoRuntime::cipherBlockChaining_aescrypt_Type(),
+stubAddr, stubName, TypePtr::BOTTOM,
+src_start, dest_start, k_start, r_start, len);
+}
+// return cipher length (int)
+Node* retvalue = _gvn.transform(new (C) ProjNode(cbcCrypt, TypeFunc::Parms));
+set_result(retvalue);
 return true;
 }
 //------------------------------get_key_start_from_aescrypt_object-----------------------
 Node * LibraryCallKit::get_key_start_from_aescrypt_object(Node *aescrypt_object) {
 if (objAESCryptKey == NULL) return (Node *) NULL;
 // now have the array, need to get the start address of the K array
 Node* k_start = array_element_address(objAESCryptKey, intcon(0), T_INT);
 return k_start;
+}
+//------------------------------get_original_key_start_from_aescrypt_object-----------------------
+Node * LibraryCallKit::get_original_key_start_from_aescrypt_object(Node *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
+Node* original_k_start = array_element_address(objAESCryptKey, intcon(0), T_BYTE);
+return original_k_start;
 }
 //----------------------------inline_cipherBlockChaining_AESCrypt_predicate----------------------------
 // Return node representing slow path of predicate check.
 // the pseudo code we want to emulate with this predicate is:

Mercurial > hg > truffle

comparison src/share/vm/opto/library_call.cpp @ 18041:52b4284cb496