compiler: open code string equality
Open code string equality with builtin memcmp. This allows
further optimizations in the backend.
Change-Id: I09618972d46fd09b0b4acee148e56a671f69d7d2
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/183538
Reviewed-by: Ian Lance Taylor <iant@golang.org>
diff --git a/go/expressions.cc b/go/expressions.cc
index 050da32..2f33dee 100644
--- a/go/expressions.cc
+++ b/go/expressions.cc
@@ -6226,10 +6226,27 @@
bool is_idiv_op = ((this->op_ == OPERATOR_DIV &&
left_type->integer_type() != NULL)
|| this->op_ == OPERATOR_MOD);
+ bool is_string_op = (left_type->is_string_type()
+ && this->right_->type()->is_string_type());
+
+ if (is_string_op)
+ {
+ // Mark string([]byte) operands to reuse the backing store.
+ // String comparison does not keep the reference, so it is safe.
+ Type_conversion_expression* lce =
+ this->left_->conversion_expression();
+ if (lce != NULL && lce->expr()->type()->is_slice_type())
+ lce->set_no_copy(true);
+ Type_conversion_expression* rce =
+ this->right_->conversion_expression();
+ if (rce != NULL && rce->expr()->type()->is_slice_type())
+ rce->set_no_copy(true);
+ }
if (is_shift_op
|| (is_idiv_op
- && (gogo->check_divide_by_zero() || gogo->check_divide_overflow())))
+ && (gogo->check_divide_by_zero() || gogo->check_divide_overflow()))
+ || is_string_op)
{
if (!this->left_->is_variable() && !this->left_->is_constant())
{
@@ -7217,19 +7234,42 @@
if (left_type->is_string_type() && right_type->is_string_type())
{
- // Mark string([]byte) operands to reuse the backing store.
- // String comparison does not keep the reference, so it is safe.
- Type_conversion_expression* lce = left->conversion_expression();
- if (lce != NULL && lce->expr()->type()->is_slice_type())
- lce->set_no_copy(true);
- Type_conversion_expression* rce = right->conversion_expression();
- if (rce != NULL && rce->expr()->type()->is_slice_type())
- rce->set_no_copy(true);
+ go_assert(left->is_variable() || left->is_constant());
+ go_assert(right->is_variable() || right->is_constant());
if (op == OPERATOR_EQEQ || op == OPERATOR_NOTEQ)
{
- left = Runtime::make_call(Runtime::EQSTRING, location, 2,
- left, right);
+ // (l.len == r.len
+ // ? (l.ptr == r.ptr ? true : memcmp(l.ptr, r.ptr, r.len) == 0)
+ // : false)
+ Expression* llen = Expression::make_string_info(left,
+ STRING_INFO_LENGTH,
+ location);
+ Expression* rlen = Expression::make_string_info(right,
+ STRING_INFO_LENGTH,
+ location);
+ Expression* leneq = Expression::make_binary(OPERATOR_EQEQ, llen, rlen,
+ location);
+ Expression* lptr = Expression::make_string_info(left->copy(),
+ STRING_INFO_DATA,
+ location);
+ Expression* rptr = Expression::make_string_info(right->copy(),
+ STRING_INFO_DATA,
+ location);
+ Expression* ptreq = Expression::make_binary(OPERATOR_EQEQ, lptr, rptr,
+ location);
+ Expression* btrue = Expression::make_boolean(true, location);
+ Expression* call = Runtime::make_call(Runtime::MEMCMP, location, 3,
+ lptr->copy(), rptr->copy(),
+ rlen->copy());
+ Type* int32_type = Type::lookup_integer_type("int32");
+ Expression* zero = Expression::make_integer_ul(0, int32_type, location);
+ Expression* cmp = Expression::make_binary(OPERATOR_EQEQ, call, zero,
+ location);
+ Expression* cond = Expression::make_conditional(ptreq, btrue, cmp,
+ location);
+ Expression* bfalse = Expression::make_boolean(false, location);
+ left = Expression::make_conditional(leneq, cond, bfalse, location);
right = Expression::make_boolean(true, location);
}
else
diff --git a/go/runtime.def b/go/runtime.def
index 7b66b16..ec7ec76 100644
--- a/go/runtime.def
+++ b/go/runtime.def
@@ -39,9 +39,6 @@
DEF_GO_RUNTIME(CONCATSTRINGS, "runtime.concatstrings",
P3(POINTER, POINTER, INT), R1(STRING))
-// Compare two strings for equality.
-DEF_GO_RUNTIME(EQSTRING, "runtime.eqstring", P2(STRING, STRING), R1(BOOL))
-
// Compare two strings.
DEF_GO_RUNTIME(CMPSTRING, "runtime.cmpstring", P2(STRING, STRING), R1(INT))
diff --git a/libgo/go/runtime/alg.go b/libgo/go/runtime/alg.go
index ec951e3..a2bb5bb 100644
--- a/libgo/go/runtime/alg.go
+++ b/libgo/go/runtime/alg.go
@@ -44,7 +44,6 @@
//go:linkname ifacevaleq runtime.ifacevaleq
//go:linkname ifaceefaceeq runtime.ifaceefaceeq
//go:linkname efacevaleq runtime.efacevaleq
-//go:linkname eqstring runtime.eqstring
//go:linkname cmpstring runtime.cmpstring
//
// Temporary to be called from C code.
diff --git a/libgo/go/runtime/stubs.go b/libgo/go/runtime/stubs.go
index 530997b..e00d759 100644
--- a/libgo/go/runtime/stubs.go
+++ b/libgo/go/runtime/stubs.go
@@ -273,18 +273,6 @@
return true
}
-func eqstring(x, y string) bool {
- a := stringStructOf(&x)
- b := stringStructOf(&y)
- if a.len != b.len {
- return false
- }
- if a.str == b.str {
- return true
- }
- return memequal(a.str, b.str, uintptr(a.len))
-}
-
// For gccgo this is in the C code.
func osyield()
