src/share/vm/opto/library_call.cpp
Index
Unified diffs
Context diffs
Sdiffs
Patch
New
Old
Previous File
Next File
*** old/src/share/vm/opto/library_call.cpp Wed Oct 23 08:41:18 2013
--- new/src/share/vm/opto/library_call.cpp Wed Oct 23 08:41:18 2013
*** 201,212 ****
--- 201,219 ----
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);
! bool inline_math_mathExact(Node* math);
! bool inline_math_addExact();
! void inline_math_mathExact(Node* math);
! 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);
bool inline_min_max(vmIntrinsics::ID id);
Node* generate_min_max(vmIntrinsics::ID id, Node* x, Node* y);
*** 505,521 ****
--- 512,548 ----
case vmIntrinsics::_updateBytesCRC32:
case vmIntrinsics::_updateByteBufferCRC32:
if (!UseCRC32Intrinsics) return NULL;
break;
! case vmIntrinsics::_addExact:
if (!Matcher::match_rule_supported(Op_AddExactI)) {
! return NULL;
}
if (!UseMathExactIntrinsics) {
return NULL;
}
! case vmIntrinsics::_incrementExactI:
+ case vmIntrinsics::_addExactI:
! if (!Matcher::match_rule_supported(Op_AddExactI) || !UseMathExactIntrinsics) return NULL;
+ break;
+ case vmIntrinsics::_incrementExactL:
+ case vmIntrinsics::_addExactL:
+ if (!Matcher::match_rule_supported(Op_AddExactL) || !UseMathExactIntrinsics) return NULL;
+ break;
+ case vmIntrinsics::_decrementExactI:
+ case vmIntrinsics::_subtractExactI:
+ if (!Matcher::match_rule_supported(Op_SubExactI) || !UseMathExactIntrinsics) return NULL;
+ break;
+ case vmIntrinsics::_decrementExactL:
+ case vmIntrinsics::_subtractExactL:
+ if (!Matcher::match_rule_supported(Op_SubExactL) || !UseMathExactIntrinsics) return NULL;
+ break;
+ case vmIntrinsics::_negateExactI:
+ if (!Matcher::match_rule_supported(Op_NegExactI) || !UseMathExactIntrinsics) return NULL;
+ break;
+ case vmIntrinsics::_negateExactL:
+ if (!Matcher::match_rule_supported(Op_NegExactL) || !UseMathExactIntrinsics) return NULL;
+ break;
+ case vmIntrinsics::_multiplyExactI:
+ if (!Matcher::match_rule_supported(Op_MulExactI) || !UseMathExactIntrinsics) return NULL;
+ break;
+ case vmIntrinsics::_multiplyExactL:
+ if (!Matcher::match_rule_supported(Op_MulExactL) || !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?");
*** 684,694 ****
--- 711,732 ----
case vmIntrinsics::_dpow: return inline_math_native(intrinsic_id());
case vmIntrinsics::_min:
case vmIntrinsics::_max: return inline_min_max(intrinsic_id());
! case vmIntrinsics::_addExact: return inline_math_addExact();
! case vmIntrinsics::_addExactI: return inline_math_addExactI(false /* add */);
+ case vmIntrinsics::_addExactL: return inline_math_addExactL(false /* add */);
+ case vmIntrinsics::_decrementExactI: return inline_math_subtractExactI(true /* decrement */);
+ case vmIntrinsics::_decrementExactL: return inline_math_subtractExactL(true /* decrement */);
+ case vmIntrinsics::_incrementExactI: return inline_math_addExactI(true /* increment */);
+ case vmIntrinsics::_incrementExactL: return inline_math_addExactL(true /* increment */);
+ case vmIntrinsics::_multiplyExactI: return inline_math_multiplyExactI();
+ case vmIntrinsics::_multiplyExactL: return inline_math_multiplyExactL();
+ case vmIntrinsics::_negateExactI: return inline_math_negateExactI();
+ case vmIntrinsics::_negateExactL: return inline_math_negateExactL();
+ case vmIntrinsics::_subtractExactI: return inline_math_subtractExactI(false /* subtract */);
+ case vmIntrinsics::_subtractExactL: return inline_math_subtractExactL(false /* subtract */);
case vmIntrinsics::_arraycopy: return inline_arraycopy();
case vmIntrinsics::_compareTo: return inline_string_compareTo();
case vmIntrinsics::_indexOf: return inline_string_indexOf();
*** 1929,1939 ****
--- 1967,1984 ----
bool LibraryCallKit::inline_min_max(vmIntrinsics::ID id) {
set_result(generate_min_max(id, argument(0), argument(1)));
return true;
}
! bool LibraryCallKit::inline_math_mathExact(Node* math) {
! void LibraryCallKit::inline_math_mathExact(Node* math) {
+ // If we didn't get the expected opcode it means we have optimized
+ // 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);
*** 1952,1974 ****
--- 1997,2106 ----
Deoptimization::Action_none);
}
set_control(fast_path);
set_result(result);
return true;
}
! bool LibraryCallKit::inline_math_addExactI(bool is_increment) {
Node* arg1 = argument(0);
! Node* arg2 = 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) );
! if (add->Opcode() == Op_AddExactI) {
! return inline_math_mathExact(add);
! inline_math_mathExact(add);
! return true;
+ }
+
+ bool LibraryCallKit::inline_math_addExactL(bool is_increment) {
+ Node* arg1 = argument(0); // type long
+ // 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);
+ Node* arg2 = NULL;
+
+ if (is_decrement) {
+ arg2 = intcon(1);
} else {
! set_result(add);
! 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
+ // argument(1) == TOP
+ Node* arg2 = NULL;
+
+ if (is_decrement) {
+ arg2 = longcon(1);
+ } else {
+ Node* 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);
+
+ Node* neg = _gvn.transform(new(C) NegExactINode(NULL, arg1));
+ inline_math_mathExact(neg);
+ return true;
+ }
+
+ bool LibraryCallKit::inline_math_negateExactL() {
+ Node* arg1 = 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);
+ 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);
+ // 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) {
src/share/vm/opto/library_call.cpp
Index
Unified diffs
Context diffs
Sdiffs
Patch
New
Old
Previous File
Next File