qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-09-28 20:24:29 -06:00
Code Releases Activity

[release-branch.go1.9] cmd/compile: fix sign-extension merging rules

Browse Source 
If we have

  y = <int16> (MOVBQSX x)
  z = <int32> (MOVWQSX y)

We used to use this rewrite rule:

(MOVWQSX x:(MOVBQSX _)) -> x

But that resulted in replacing z with a value whose type
is only int16.  Then if z is spilled and restored, it gets
zero extended instead of sign extended.

Instead use the rule

(MOVWQSX (MOVBQSX x)) -> (MOVBQSX x)

The result is has the correct type, so it can be spilled
and restored correctly.  It might mean that a few more extension
ops might not be eliminated, but that's the price for correctness.

Fixes #21963

Change-Id: I6ec82c3d2dbe43cc1fee6fb2bd6b3a72fca3af00
Reviewed-on: https://go-review.googlesource.com/65290
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-on: https://go-review.googlesource.com/70986
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
This commit is contained in:
Keith Randall 2017-09-21 12:52:38 -07:00 committed by Russ Cox
parent 79996e4a1d
commit 78952c06c5
3 changed files with 113 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
src/cmd/compile/internal/ssa/gen/AMD64.rules
View File

@ -2405,15 +2405,17 @@
(BSFQ (ORQconst <t> [1<<16] (MOVWQZX x))) -> (BSFQ (ORQconst <t> [1<<16] x)) (BSFQ (ORQconst <t> [1<<16] (MOVWQZX x))) -> (BSFQ (ORQconst <t> [1<<16] x))
// Redundant sign/zero extensions // Redundant sign/zero extensions
(MOVLQSX x:(MOVLQSX _)) -> x // Note: see issue 21963. We have to make sure we use the right type on
(MOVLQSX x:(MOVWQSX _)) -> x // the resulting extension (the outer type, not the inner type).
(MOVLQSX x:(MOVBQSX _)) -> x (MOVLQSX (MOVLQSX x)) -> (MOVLQSX x)
(MOVWQSX x:(MOVWQSX _)) -> x (MOVLQSX (MOVWQSX x)) -> (MOVWQSX x)
(MOVWQSX x:(MOVBQSX _)) -> x (MOVLQSX (MOVBQSX x)) -> (MOVBQSX x)
(MOVBQSX x:(MOVBQSX _)) -> x (MOVWQSX (MOVWQSX x)) -> (MOVWQSX x)
(MOVLQZX x:(MOVLQZX _)) -> x (MOVWQSX (MOVBQSX x)) -> (MOVBQSX x)
(MOVLQZX x:(MOVWQZX _)) -> x (MOVBQSX (MOVBQSX x)) -> (MOVBQSX x)
(MOVLQZX x:(MOVBQZX _)) -> x (MOVLQZX (MOVLQZX x)) -> (MOVLQZX x)
(MOVWQZX x:(MOVWQZX _)) -> x (MOVLQZX (MOVWQZX x)) -> (MOVWQZX x)
(MOVWQZX x:(MOVBQZX _)) -> x (MOVLQZX (MOVBQZX x)) -> (MOVBQZX x)
(MOVBQZX x:(MOVBQZX _)) -> x (MOVWQZX (MOVWQZX x)) -> (MOVWQZX x)
(MOVWQZX (MOVBQZX x)) -> (MOVBQZX x)
(MOVBQZX (MOVBQZX x)) -> (MOVBQZX x)

144
src/cmd/compile/internal/ssa/rewriteAMD64.go
View File

@ -4319,16 +4319,16 @@ func rewriteValueAMD64_OpAMD64MOVBQSX_0(v *Value) bool {
v.AddArg(x) v.AddArg(x)
return true return true
} }
// match: (MOVBQSX x:(MOVBQSX _)) // match: (MOVBQSX (MOVBQSX x))
// cond: // cond:
// result: x // result: (MOVBQSX x)
for { for {
x := v.Args[0] v_0 := v.Args[0]
if x.Op != OpAMD64MOVBQSX { if v_0.Op != OpAMD64MOVBQSX {
break break
} }
v.reset(OpCopy) x := v_0.Args[0]
v.Type = x.Type v.reset(OpAMD64MOVBQSX)
v.AddArg(x) v.AddArg(x)
return true return true
} }
@ -4536,16 +4536,16 @@ func rewriteValueAMD64_OpAMD64MOVBQZX_0(v *Value) bool {
v.AddArg(x) v.AddArg(x)
return true return true
} }
// match: (MOVBQZX x:(MOVBQZX _)) // match: (MOVBQZX (MOVBQZX x))
// cond: // cond:
// result: x // result: (MOVBQZX x)
for { for {
x := v.Args[0] v_0 := v.Args[0]
if x.Op != OpAMD64MOVBQZX { if v_0.Op != OpAMD64MOVBQZX {
break break
} }
v.reset(OpCopy) x := v_0.Args[0]
v.Type = x.Type v.reset(OpAMD64MOVBQZX)
v.AddArg(x) v.AddArg(x)
return true return true
} }
@ -6392,42 +6392,42 @@ func rewriteValueAMD64_OpAMD64MOVLQSX_0(v *Value) bool {
v.AddArg(x) v.AddArg(x)
return true return true
} }
// match: (MOVLQSX x:(MOVLQSX _)) // match: (MOVLQSX (MOVLQSX x))
// cond: // cond:
// result: x // result: (MOVLQSX x)
for { for {
x := v.Args[0] v_0 := v.Args[0]
if x.Op != OpAMD64MOVLQSX { if v_0.Op != OpAMD64MOVLQSX {
break break
} }
v.reset(OpCopy) x := v_0.Args[0]
v.Type = x.Type v.reset(OpAMD64MOVLQSX)
v.AddArg(x) v.AddArg(x)
return true return true
} }
// match: (MOVLQSX x:(MOVWQSX _)) // match: (MOVLQSX (MOVWQSX x))
// cond: // cond:
// result: x // result: (MOVWQSX x)
for { for {
x := v.Args[0] v_0 := v.Args[0]
if x.Op != OpAMD64MOVWQSX { if v_0.Op != OpAMD64MOVWQSX {
break break
} }
v.reset(OpCopy) x := v_0.Args[0]
v.Type = x.Type v.reset(OpAMD64MOVWQSX)
v.AddArg(x) v.AddArg(x)
return true return true
} }
// match: (MOVLQSX x:(MOVBQSX _)) // match: (MOVLQSX (MOVBQSX x))
// cond: // cond:
// result: x // result: (MOVBQSX x)
for { for {
x := v.Args[0] v_0 := v.Args[0]
if x.Op != OpAMD64MOVBQSX { if v_0.Op != OpAMD64MOVBQSX {
break break
} }
v.reset(OpCopy) x := v_0.Args[0]
v.Type = x.Type v.reset(OpAMD64MOVBQSX)
v.AddArg(x) v.AddArg(x)
return true return true
} }
@ -6611,42 +6611,42 @@ func rewriteValueAMD64_OpAMD64MOVLQZX_0(v *Value) bool {
v.AddArg(x) v.AddArg(x)
return true return true
} }
// match: (MOVLQZX x:(MOVLQZX _)) // match: (MOVLQZX (MOVLQZX x))
// cond: // cond:
// result: x // result: (MOVLQZX x)
for { for {
x := v.Args[0] v_0 := v.Args[0]
if x.Op != OpAMD64MOVLQZX { if v_0.Op != OpAMD64MOVLQZX {
break break
} }
v.reset(OpCopy) x := v_0.Args[0]
v.Type = x.Type v.reset(OpAMD64MOVLQZX)
v.AddArg(x) v.AddArg(x)
return true return true
} }
// match: (MOVLQZX x:(MOVWQZX _)) // match: (MOVLQZX (MOVWQZX x))
// cond: // cond:
// result: x // result: (MOVWQZX x)
for { for {
x := v.Args[0] v_0 := v.Args[0]
if x.Op != OpAMD64MOVWQZX { if v_0.Op != OpAMD64MOVWQZX {
break break
} }
v.reset(OpCopy) x := v_0.Args[0]
v.Type = x.Type v.reset(OpAMD64MOVWQZX)
v.AddArg(x) v.AddArg(x)
return true return true
} }
// match: (MOVLQZX x:(MOVBQZX _)) // match: (MOVLQZX (MOVBQZX x))
// cond: // cond:
// result: x // result: (MOVBQZX x)
for { for {
x := v.Args[0] v_0 := v.Args[0]
if x.Op != OpAMD64MOVBQZX { if v_0.Op != OpAMD64MOVBQZX {
break break
} }
v.reset(OpCopy) x := v_0.Args[0]
v.Type = x.Type v.reset(OpAMD64MOVBQZX)
v.AddArg(x) v.AddArg(x)
return true return true
} }
@ -10767,29 +10767,29 @@ func rewriteValueAMD64_OpAMD64MOVWQSX_0(v *Value) bool {
v.AddArg(x) v.AddArg(x)
return true return true
} }
// match: (MOVWQSX x:(MOVWQSX _)) // match: (MOVWQSX (MOVWQSX x))
// cond: // cond:
// result: x // result: (MOVWQSX x)
for { for {
x := v.Args[0] v_0 := v.Args[0]
if x.Op != OpAMD64MOVWQSX { if v_0.Op != OpAMD64MOVWQSX {
break break
} }
v.reset(OpCopy) x := v_0.Args[0]
v.Type = x.Type v.reset(OpAMD64MOVWQSX)
v.AddArg(x) v.AddArg(x)
return true return true
} }
// match: (MOVWQSX x:(MOVBQSX _)) // match: (MOVWQSX (MOVBQSX x))
// cond: // cond:
// result: x // result: (MOVBQSX x)
for { for {
x := v.Args[0] v_0 := v.Args[0]
if x.Op != OpAMD64MOVBQSX { if v_0.Op != OpAMD64MOVBQSX {
break break
} }
v.reset(OpCopy) x := v_0.Args[0]
v.Type = x.Type v.reset(OpAMD64MOVBQSX)
v.AddArg(x) v.AddArg(x)
return true return true
} }
@ -10999,29 +10999,29 @@ func rewriteValueAMD64_OpAMD64MOVWQZX_0(v *Value) bool {
v.AddArg(x) v.AddArg(x)
return true return true
} }
// match: (MOVWQZX x:(MOVWQZX _)) // match: (MOVWQZX (MOVWQZX x))
// cond: // cond:
// result: x // result: (MOVWQZX x)
for { for {
x := v.Args[0] v_0 := v.Args[0]
if x.Op != OpAMD64MOVWQZX { if v_0.Op != OpAMD64MOVWQZX {
break break
} }
v.reset(OpCopy) x := v_0.Args[0]
v.Type = x.Type v.reset(OpAMD64MOVWQZX)
v.AddArg(x) v.AddArg(x)
return true return true
} }
// match: (MOVWQZX x:(MOVBQZX _)) // match: (MOVWQZX (MOVBQZX x))
// cond: // cond:
// result: x // result: (MOVBQZX x)
for { for {
x := v.Args[0] v_0 := v.Args[0]
if x.Op != OpAMD64MOVBQZX { if v_0.Op != OpAMD64MOVBQZX {
break break
} }
v.reset(OpCopy) x := v_0.Args[0]
v.Type = x.Type v.reset(OpAMD64MOVBQZX)
v.AddArg(x) v.AddArg(x)
return true return true
} }

27
test/fixedbugs/issue21963.go Normal file
View File

@ -0,0 +1,27 @@
// run
// Copyright 2017 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package main
import (
"fmt"
"runtime"
)
//go:noinline
func f(x []int32, y *int8) int32 {
c := int32(int16(*y))
runtime.GC()
return x[0] * c
}
func main() {
var x = [1]int32{5}
var y int8 = -1
if got, want := f(x[:], &y), int32(-5); got != want {
panic(fmt.Sprintf("wanted %d, got %d", want, got))
}
}