graal-compiler: src/share/vm/opto/library

comparison src/share/vm/opto/library_call.cpp @ 17810:62c54fcc0a35

Merge

author	kvn
date	Tue, 25 Mar 2014 17:07:36 -0700
parents	7c462558a08a 9ab9f254cfe2
children	400709e275c1

comparison

equal deleted inserted replaced

-:a433eb716ce1
+:62c54fcc0a35
 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();
 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?");
 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:
 }
 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;
 }
 //------------------------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,
 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));

Mercurial > hg > graal-compiler

comparison src/share/vm/opto/library_call.cpp @ 17810:62c54fcc0a35