truffle: src/share/vm/opto/library

comparison src/share/vm/opto/library_call.cpp @ 681:fbde8ec322d0

6761600: Use sse 4.2 in intrinsics Summary: Use SSE 4.2 in intrinsics for String.{compareTo/equals/indexOf} and Arrays.equals. Reviewed-by: kvn, never, jrose

author	cfang
date	Tue, 31 Mar 2009 14:07:08 -0700
parents	c771b7f43bbf
children	9c6be3edf0dc

comparison

equal deleted inserted replaced

-:d3676b4cb78c
+:fbde8ec322d0
 }
 bool inline_string_compareTo();
 bool inline_string_indexOf();
 Node* string_indexOf(Node* string_object, ciTypeArray* target_array, jint offset, jint cache_i, jint md2_i);
+bool inline_string_equals();
 Node* pop_math_arg();
 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_trans(vmIntrinsics::ID id);
 // -XX:-InlineNatives disables nearly all intrinsics:
 if (!InlineNatives) {
 switch (id) {
 case vmIntrinsics::_indexOf:
 case vmIntrinsics::_compareTo:
+case vmIntrinsics::_equals:
 case vmIntrinsics::_equalsC:
 break;  // InlineNatives does not control String.compareTo
 default:
 return NULL;
 }
 case vmIntrinsics::_compareTo:
 if (!SpecialStringCompareTo)  return NULL;
 break;
 case vmIntrinsics::_indexOf:
 if (!SpecialStringIndexOf)  return NULL;
+break;
+case vmIntrinsics::_equals:
+if (!SpecialStringEquals)  return NULL;
 break;
 case vmIntrinsics::_equalsC:
 if (!SpecialArraysEquals)  return NULL;
 break;
 case vmIntrinsics::_arraycopy:
 case vmIntrinsics::_compareTo:
 return inline_string_compareTo();
 case vmIntrinsics::_indexOf:
 return inline_string_indexOf();
+case vmIntrinsics::_equals:
+return inline_string_equals();
 case vmIntrinsics::_getObject:
 return inline_unsafe_access(!is_native_ptr, !is_store, T_OBJECT, false);
 case vmIntrinsics::_getBoolean:
 return inline_unsafe_access(!is_native_ptr, !is_store, T_BOOLEAN, false);
 //------------------------------inline_string_compareTo------------------------
 bool LibraryCallKit::inline_string_compareTo() {
+if (!Matcher::has_match_rule(Op_StrComp)) return false;
 const int value_offset = java_lang_String::value_offset_in_bytes();
 const int count_offset = java_lang_String::count_offset_in_bytes();
 const int offset_offset = java_lang_String::offset_offset_in_bytes();
 _sp += 2;
 memory(string_type->add_offset(count_offset)),
 memory(string_type->add_offset(offset_offset)),
 receiver,
 argument));
 push(compare);
+return true;
+}
+//------------------------------inline_string_equals------------------------
+bool LibraryCallKit::inline_string_equals() {
+if (!Matcher::has_match_rule(Op_StrEquals)) return false;
+const int value_offset = java_lang_String::value_offset_in_bytes();
+const int count_offset = java_lang_String::count_offset_in_bytes();
+const int offset_offset = java_lang_String::offset_offset_in_bytes();
+_sp += 2;
+Node* argument = pop();  // pop non-receiver first:  it was pushed second
+Node* receiver = pop();
+// Null check on self without removing any arguments.  The argument
+// null check technically happens in the wrong place, which can lead to
+// invalid stack traces when string compare is inlined into a method
+// which handles NullPointerExceptions.
+_sp += 2;
+receiver = do_null_check(receiver, T_OBJECT);
+//should not do null check for argument for String.equals(), because spec
+//allows to specify NULL as argument.
+_sp -= 2;
+if (stopped()) {
+return true;
+}
+// get String klass for instanceOf
+ciInstanceKlass* klass = env()->String_klass();
+// two paths (plus control) merge
+RegionNode* region = new (C, 3) RegionNode(3);
+Node* phi = new (C, 3) PhiNode(region, TypeInt::BOOL);
+Node* inst = gen_instanceof(argument, makecon(TypeKlassPtr::make(klass)));
+Node* cmp  = _gvn.transform(new (C, 3) CmpINode(inst, intcon(1)));
+Node* bol  = _gvn.transform(new (C, 2) BoolNode(cmp, BoolTest::eq));
+IfNode* iff = create_and_map_if(control(), bol, PROB_MAX, COUNT_UNKNOWN);
+Node* if_true  = _gvn.transform(new (C, 1) IfTrueNode(iff));
+set_control(if_true);
+const TypeInstPtr* string_type =
+TypeInstPtr::make(TypePtr::BotPTR, klass, false, NULL, 0);
+// instanceOf == true
+Node* equals =
+_gvn.transform(new (C, 7) StrEqualsNode(
+control(),
+memory(TypeAryPtr::CHARS),
+memory(string_type->add_offset(value_offset)),
+memory(string_type->add_offset(count_offset)),
+memory(string_type->add_offset(offset_offset)),
+receiver,
+argument));
+phi->init_req(1, _gvn.transform(equals));
+region->init_req(1, if_true);
+//instanceOf == false, fallthrough
+Node* if_false = _gvn.transform(new (C, 1) IfFalseNode(iff));
+set_control(if_false);
+phi->init_req(2, _gvn.transform(intcon(0)));
+region->init_req(2, if_false);
+// post merge
+set_control(_gvn.transform(region));
+record_for_igvn(region);
+push(_gvn.transform(phi));
 return true;
 }
 //------------------------------inline_array_equals----------------------------
 bool LibraryCallKit::inline_array_equals() {
 #undef __
 C->set_has_loops(true);
 return result;
 }
 //------------------------------inline_string_indexOf------------------------
 bool LibraryCallKit::inline_string_indexOf() {
+const int value_offset  = java_lang_String::value_offset_in_bytes();
+const int count_offset  = java_lang_String::count_offset_in_bytes();
+const int offset_offset = java_lang_String::offset_offset_in_bytes();
 _sp += 2;
 Node *argument = pop();  // pop non-receiver first:  it was pushed second
 Node *receiver = pop();
-// don't intrinsify if argument isn't a constant string.
+Node* result;
-if (!argument->is_Con()) {
+if (Matcher::has_match_rule(Op_StrIndexOf) &&
-return false;
+UseSSE42Intrinsics) {
-}
+// Generate SSE4.2 version of indexOf
-const TypeOopPtr* str_type = _gvn.type(argument)->isa_oopptr();
+// We currently only have match rules that use SSE4.2
-if (str_type == NULL) {
-return false;
+// Null check on self without removing any arguments.  The argument
-}
+// null check technically happens in the wrong place, which can lead to
-ciInstanceKlass* klass = env()->String_klass();
+// invalid stack traces when string compare is inlined into a method
-ciObject* str_const = str_type->const_oop();
+// which handles NullPointerExceptions.
-if (str_const == NULL || str_const->klass() != klass) {
+_sp += 2;
-return false;
+receiver = do_null_check(receiver, T_OBJECT);
-}
+argument = do_null_check(argument, T_OBJECT);
-ciInstance* str = str_const->as_instance();
+_sp -= 2;
-assert(str != NULL, "must be instance");
+if (stopped()) {
-const int value_offset  = java_lang_String::value_offset_in_bytes();
+return true;
-const int count_offset  = java_lang_String::count_offset_in_bytes();
+}
-const int offset_offset = java_lang_String::offset_offset_in_bytes();
+ciInstanceKlass* klass = env()->String_klass();
-ciObject* v = str->field_value_by_offset(value_offset).as_object();
+const TypeInstPtr* string_type =
-int       o = str->field_value_by_offset(offset_offset).as_int();
+TypeInstPtr::make(TypePtr::BotPTR, klass, false, NULL, 0);
-int       c = str->field_value_by_offset(count_offset).as_int();
-ciTypeArray* pat = v->as_type_array(); // pattern (argument) character array
+result =
+_gvn.transform(new (C, 7)
-// constant strings have no offset and count == length which
+StrIndexOfNode(control(),
-// simplifies the resulting code somewhat so lets optimize for that.
+memory(TypeAryPtr::CHARS),
-if (o != 0 || c != pat->length()) {
+memory(string_type->add_offset(value_offset)),
-return false;
+memory(string_type->add_offset(count_offset)),
-}
+memory(string_type->add_offset(offset_offset)),
+receiver,
-// Null check on self without removing any arguments.  The argument
+argument));
-// null check technically happens in the wrong place, which can lead to
+} else { //Use LibraryCallKit::string_indexOf
-// invalid stack traces when string compare is inlined into a method
+// don't intrinsify is argument isn't a constant string.
-// which handles NullPointerExceptions.
+if (!argument->is_Con()) {
-_sp += 2;
+return false;
-receiver = do_null_check(receiver, T_OBJECT);
+}
-// No null check on the argument is needed since it's a constant String oop.
+const TypeOopPtr* str_type = _gvn.type(argument)->isa_oopptr();
-_sp -= 2;
+if (str_type == NULL) {
-if (stopped()) {
+return false;
-return true;
+}
-}
+ciInstanceKlass* klass = env()->String_klass();
+ciObject* str_const = str_type->const_oop();
-// The null string as a pattern always returns 0 (match at beginning of string)
+if (str_const == NULL || str_const->klass() != klass) {
-if (c == 0) {
+return false;
-push(intcon(0));
+}
-return true;
+ciInstance* str = str_const->as_instance();
-}
+assert(str != NULL, "must be instance");
-jchar lastChar = pat->char_at(o + (c - 1));
+ciObject* v = str->field_value_by_offset(value_offset).as_object();
-int cache = 0;
+int       o = str->field_value_by_offset(offset_offset).as_int();
-int i;
+int       c = str->field_value_by_offset(count_offset).as_int();
-for (i = 0; i < c - 1; i++) {
+ciTypeArray* pat = v->as_type_array(); // pattern (argument) character array
-assert(i < pat->length(), "out of range");
-cache |= (1 << (pat->char_at(o + i) & (sizeof(cache) * BitsPerByte - 1)));
+// constant strings have no offset and count == length which
-}
+// simplifies the resulting code somewhat so lets optimize for that.
+if (o != 0 || c != pat->length()) {
-int md2 = c;
+return false;
-for (i = 0; i < c - 1; i++) {
+}
-assert(i < pat->length(), "out of range");
-if (pat->char_at(o + i) == lastChar) {
+// Null check on self without removing any arguments.  The argument
-md2 = (c - 1) - i;
+// null check technically happens in the wrong place, which can lead to
-}
+// invalid stack traces when string compare is inlined into a method
-}
+// which handles NullPointerExceptions.
+_sp += 2;
-Node* result = string_indexOf(receiver, pat, o, cache, md2);
+receiver = do_null_check(receiver, T_OBJECT);
+// No null check on the argument is needed since it's a constant String oop.
+_sp -= 2;
+if (stopped()) {
+return true;
+}
+// The null string as a pattern always returns 0 (match at beginning of string)
+if (c == 0) {
+push(intcon(0));
+return true;
+}
+// Generate default indexOf
+jchar lastChar = pat->char_at(o + (c - 1));
+int cache = 0;
+int i;
+for (i = 0; i < c - 1; i++) {
+assert(i < pat->length(), "out of range");
+cache |= (1 << (pat->char_at(o + i) & (sizeof(cache) * BitsPerByte - 1)));
+}
+int md2 = c;
+for (i = 0; i < c - 1; i++) {
+assert(i < pat->length(), "out of range");
+if (pat->char_at(o + i) == lastChar) {
+md2 = (c - 1) - i;
+}
+}
+result = string_indexOf(receiver, pat, o, cache, md2);
+}
 push(result);
 return true;
 }
 //--------------------------pop_math_arg--------------------------------

Mercurial > hg > truffle

comparison src/share/vm/opto/library_call.cpp @ 681:fbde8ec322d0