[dev.ssa] cmd/compile/internal/ssa: add == and != for complex

Change-Id: Iefabce4eb0dbc313dd1863513b45307cc76c545a
Reviewed-on: https://go-review.googlesource.com/14468
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>

diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 5132c53000a3cbc3e6073632953a055ee30c9ae9..b69631338e50c6df2776a91bccfca68aa6ed9510 100644 (file)
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -1476,6 +1476,22 @@ func (s *state) expr(n *Node) *ssa.Value {
        case OLT, OEQ, ONE, OLE, OGE, OGT:
                a := s.expr(n.Left)
                b := s.expr(n.Right)
+               if n.Left.Type.IsComplex() {
+                       pt := floatForComplex(n.Type)
+                       op := s.ssaOp(OEQ, pt)
+                       r := s.newValue2(op, Types[TBOOL], s.newValue1(ssa.OpComplexReal, pt, a), s.newValue1(ssa.OpComplexReal, pt, b))
+                       i := s.newValue2(op, Types[TBOOL], s.newValue1(ssa.OpComplexImag, pt, a), s.newValue1(ssa.OpComplexImag, pt, b))
+                       c := s.newValue2(ssa.OpAnd8, Types[TBOOL], r, i)
+                       switch n.Op {
+                       case OEQ:
+                               return c
+                       case ONE:
+                               return s.newValue1(ssa.OpNot, Types[TBOOL], c)
+                       default:
+                               s.Fatalf("ordered complex compare %s", opnames[n.Op])
+                       }
+
+               }
                return s.newValue2(s.ssaOp(n.Op, n.Left.Type), Types[TBOOL], a, b)
        case OMUL:
                a := s.expr(n.Left)

diff --git a/src/cmd/compile/internal/gc/testdata/fp_ssa.go b/src/cmd/compile/internal/gc/testdata/fp_ssa.go
index 6985cd0641d9553cab64bad6c3b67683ceb26005..e7480a113857d6758184d9f38a64edb7b705fa8c 100644 (file)
--- a/src/cmd/compile/internal/gc/testdata/fp_ssa.go
+++ b/src/cmd/compile/internal/gc/testdata/fp_ssa.go
@@ -1557,6 +1557,45 @@ func cx64imag_ssa(a complex64) float32 {
        return imag(a)
 }
 
+func cx128eq_ssa(a, b complex128) bool {
+       switch { // prevent inlining
+       }
+       return a == b
+}
+
+func cx128ne_ssa(a, b complex128) bool {
+       switch { // prevent inlining
+       }
+       return a != b
+}
+
+func cx64eq_ssa(a, b complex64) bool {
+       switch { // prevent inlining
+       }
+       return a == b
+}
+
+func cx64ne_ssa(a, b complex64) bool {
+       switch { // prevent inlining
+       }
+       return a != b
+}
+
+func expectTrue(s string, b bool) int {
+       if !b {
+               println("expected true for", s, ", got false")
+               return 1
+       }
+       return 0
+}
+func expectFalse(s string, b bool) int {
+       if b {
+               println("expected false for", s, ", got true")
+               return 1
+       }
+       return 0
+}
+
 func complexTest128() int {
        fails := 0
        var a complex128 = 1 + 2i
@@ -1569,6 +1608,10 @@ func complexTest128() int {
        r := cx128real_ssa(a)
        i := cx128imag_ssa(a)
        cnst := cx128cnst_ssa(a)
+       c1 := cx128eq_ssa(a, a)
+       c2 := cx128eq_ssa(a, b)
+       c3 := cx128ne_ssa(a, a)
+       c4 := cx128ne_ssa(a, b)
 
        fails += expectCx128("sum", sum, 4+8i)
        fails += expectCx128("diff", diff, 2+4i)
@@ -1578,6 +1621,10 @@ func complexTest128() int {
        fails += expect64("real", r, 1)
        fails += expect64("imag", i, 2)
        fails += expectCx128("cnst", cnst, -4+7i)
+       fails += expectTrue(fmt.Sprintf("%v==%v", a, a), c1)
+       fails += expectFalse(fmt.Sprintf("%v==%v", a, b), c2)
+       fails += expectFalse(fmt.Sprintf("%v!=%v", a, a), c3)
+       fails += expectTrue(fmt.Sprintf("%v!=%v", a, b), c4)
 
        return fails
 }
@@ -1593,6 +1640,10 @@ func complexTest64() int {
        neg := cx64neg_ssa(a)
        r := cx64real_ssa(a)
        i := cx64imag_ssa(a)
+       c1 := cx64eq_ssa(a, a)
+       c2 := cx64eq_ssa(a, b)
+       c3 := cx64ne_ssa(a, a)
+       c4 := cx64ne_ssa(a, b)
 
        fails += expectCx64("sum", sum, 4+8i)
        fails += expectCx64("diff", diff, 2+4i)
@@ -1601,6 +1652,10 @@ func complexTest64() int {
        fails += expectCx64("neg", neg, -1-2i)
        fails += expect32("real", r, 1)
        fails += expect32("imag", i, 2)
+       fails += expectTrue(fmt.Sprintf("%v==%v", a, a), c1)
+       fails += expectFalse(fmt.Sprintf("%v==%v", a, b), c2)
+       fails += expectFalse(fmt.Sprintf("%v!=%v", a, a), c3)
+       fails += expectTrue(fmt.Sprintf("%v!=%v", a, b), c4)
 
        return fails
 }