mirror
/
go
mirror of https://github.com/golang/go.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

cmd/compile/internal/ssa: add Op{SP,SB} type checks to check.go 

gc/ssa.go initilizes SP and SB values with TUINTPTR type.
Assign same type in SSA tests and modify check.go to catch
mismatching types for those ops.

This makes SSA tests more consistent.

Change-Id: I798440d57d00fb949d1a0cd796759c9b82a934bd
Reviewed-on: https://go-review.googlesource.com/106658
Run-TryBot: Iskander Sharipov <iskander.sharipov@intel.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
This commit is contained in:
isharipo 2018-04-12 20:54:36 +03:00 committed by Ilya Tocar
parent d18f186b9b
commit cb44c8debb
10 changed files with 44 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/cmd/compile/internal/ssa/branchelim_test.go
View File

@ -37,7 +37,7 @@ func TestBranchElimIf(t *testing.T) {
fun := c.Fun("entry",
Bloc("entry",
Valu("start", OpInitMem, types.TypeMem, 0, nil),
Valu("sb", OpSB, types.TypeInvalid, 0, nil),
Valu("sb", OpSB, c.config.Types.Uintptr, 0, nil),
Valu("const1", OpConst32, intType, 1, nil),
Valu("const2", OpConst32, intType, 2, nil),
Valu("addr", OpAddr, boolType.PtrTo(), 0, nil, "sb"),
@ -89,7 +89,7 @@ func TestBranchElimIfElse(t *testing.T) {
fun := c.Fun("entry",
Bloc("entry",
Valu("start", OpInitMem, types.TypeMem, 0, nil),
Valu("sb", OpSB, types.TypeInvalid, 0, nil),
Valu("sb", OpSB, c.config.Types.Uintptr, 0, nil),
Valu("const1", OpConst32, intType, 1, nil),
Valu("const2", OpConst32, intType, 2, nil),
Valu("addr", OpAddr, boolType.PtrTo(), 0, nil, "sb"),
@ -141,7 +141,7 @@ func TestNoBranchElimLoop(t *testing.T) {
fun := c.Fun("entry",
Bloc("entry",
Valu("start", OpInitMem, types.TypeMem, 0, nil),
Valu("sb", OpSB, types.TypeInvalid, 0, nil),
Valu("sb", OpSB, c.config.Types.Uintptr, 0, nil),
Valu("const2", OpConst32, intType, 2, nil),
Valu("const3", OpConst32, intType, 3, nil),
Goto("b5")),

11
src/cmd/compile/internal/ssa/check.go
View File

@ -212,8 +212,17 @@ func checkFunc(f *Func) {
f.Fatalf("unexpected floating-point type %v", v.LongString())
}
// Check types.
// TODO: more type checks?
switch c := f.Config; v.Op {
case OpSP, OpSB:
if v.Type != c.Types.Uintptr {
f.Fatalf("bad %s type: want uintptr, have %s",
v.Op, v.Type.String())
}
}
// TODO: check for cycles in values
// TODO: check type
}
}

8
src/cmd/compile/internal/ssa/cse_test.go
View File

@ -25,7 +25,7 @@ func TestCSEAuxPartitionBug(t *testing.T) {
fun := c.Fun("entry",
Bloc("entry",
Valu("start", OpInitMem, types.TypeMem, 0, nil),
Valu("sp", OpSP, c.config.Types.BytePtr, 0, nil),
Valu("sp", OpSP, c.config.Types.Uintptr, 0, nil),
Valu("r7", OpAdd64, c.config.Types.Int64, 0, nil, "arg3", "arg1"),
Valu("r1", OpAdd64, c.config.Types.Int64, 0, nil, "arg1", "arg2"),
Valu("arg1", OpArg, c.config.Types.Int64, 0, arg1Aux),
@ -93,9 +93,9 @@ func TestZCSE(t *testing.T) {
fun := c.Fun("entry",
Bloc("entry",
Valu("start", OpInitMem, types.TypeMem, 0, nil),
Valu("sp", OpSP, c.config.Types.BytePtr, 0, nil),
Valu("sb1", OpSB, c.config.Types.BytePtr, 0, nil),
Valu("sb2", OpSB, c.config.Types.BytePtr, 0, nil),
Valu("sp", OpSP, c.config.Types.Uintptr, 0, nil),
Valu("sb1", OpSB, c.config.Types.Uintptr, 0, nil),
Valu("sb2", OpSB, c.config.Types.Uintptr, 0, nil),
Valu("addr1", OpAddr, c.config.Types.Int64.PtrTo(), 0, nil, "sb1"),
Valu("addr2", OpAddr, c.config.Types.Int64.PtrTo(), 0, nil, "sb2"),
Valu("a1ld", OpLoad, c.config.Types.Int64, 0, nil, "addr1", "start"),

8
src/cmd/compile/internal/ssa/deadstore_test.go
View File

@ -16,7 +16,7 @@ func TestDeadStore(t *testing.T) {
fun := c.Fun("entry",
Bloc("entry",
Valu("start", OpInitMem, types.TypeMem, 0, nil),
Valu("sb", OpSB, types.TypeInvalid, 0, nil),
Valu("sb", OpSB, c.config.Types.Uintptr, 0, nil),
Valu("v", OpConstBool, c.config.Types.Bool, 1, nil),
Valu("addr1", OpAddr, ptrType, 0, nil, "sb"),
Valu("addr2", OpAddr, ptrType, 0, nil, "sb"),
@ -51,7 +51,7 @@ func TestDeadStorePhi(t *testing.T) {
fun := c.Fun("entry",
Bloc("entry",
Valu("start", OpInitMem, types.TypeMem, 0, nil),
Valu("sb", OpSB, types.TypeInvalid, 0, nil),
Valu("sb", OpSB, c.config.Types.Uintptr, 0, nil),
Valu("v", OpConstBool, c.config.Types.Bool, 1, nil),
Valu("addr", OpAddr, ptrType, 0, nil, "sb"),
Goto("loop")),
@ -78,7 +78,7 @@ func TestDeadStoreTypes(t *testing.T) {
fun := c.Fun("entry",
Bloc("entry",
Valu("start", OpInitMem, types.TypeMem, 0, nil),
Valu("sb", OpSB, types.TypeInvalid, 0, nil),
Valu("sb", OpSB, c.config.Types.Uintptr, 0, nil),
Valu("v", OpConstBool, c.config.Types.Bool, 1, nil),
Valu("addr1", OpAddr, t1, 0, nil, "sb"),
Valu("addr2", OpAddr, t2, 0, nil, "sb"),
@ -108,7 +108,7 @@ func TestDeadStoreUnsafe(t *testing.T) {
fun := c.Fun("entry",
Bloc("entry",
Valu("start", OpInitMem, types.TypeMem, 0, nil),
Valu("sb", OpSB, types.TypeInvalid, 0, nil),
Valu("sb", OpSB, c.config.Types.Uintptr, 0, nil),
Valu("v", OpConstBool, c.config.Types.Bool, 1, nil),
Valu("addr1", OpAddr, ptrType, 0, nil, "sb"),
Valu("store1", OpStore, types.TypeMem, 0, c.config.Types.Int64, "addr1", "v", "start"), // store 8 bytes

8
src/cmd/compile/internal/ssa/fuse_test.go
View File

@ -13,7 +13,7 @@ func TestFuseEliminatesOneBranch(t *testing.T) {
fun := c.Fun("entry",
Bloc("entry",
Valu("mem", OpInitMem, types.TypeMem, 0, nil),
Valu("sb", OpSB, types.TypeInvalid, 0, nil),
Valu("sb", OpSB, c.config.Types.Uintptr, 0, nil),
Goto("checkPtr")),
Bloc("checkPtr",
Valu("ptr1", OpLoad, ptrType, 0, nil, "sb", "mem"),
@ -41,7 +41,7 @@ func TestFuseEliminatesBothBranches(t *testing.T) {
fun := c.Fun("entry",
Bloc("entry",
Valu("mem", OpInitMem, types.TypeMem, 0, nil),
Valu("sb", OpSB, types.TypeInvalid, 0, nil),
Valu("sb", OpSB, c.config.Types.Uintptr, 0, nil),
Goto("checkPtr")),
Bloc("checkPtr",
Valu("ptr1", OpLoad, ptrType, 0, nil, "sb", "mem"),
@ -74,7 +74,7 @@ func TestFuseHandlesPhis(t *testing.T) {
fun := c.Fun("entry",
Bloc("entry",
Valu("mem", OpInitMem, types.TypeMem, 0, nil),
Valu("sb", OpSB, types.TypeInvalid, 0, nil),
Valu("sb", OpSB, c.config.Types.Uintptr, 0, nil),
Goto("checkPtr")),
Bloc("checkPtr",
Valu("ptr1", OpLoad, ptrType, 0, nil, "sb", "mem"),
@ -107,7 +107,7 @@ func TestFuseEliminatesEmptyBlocks(t *testing.T) {
fun := c.Fun("entry",
Bloc("entry",
Valu("mem", OpInitMem, types.TypeMem, 0, nil),
Valu("sb", OpSB, types.TypeInvalid, 0, nil),
Valu("sb", OpSB, c.config.Types.Uintptr, 0, nil),
Goto("z0")),
Bloc("z1",
Goto("z2")),

2
src/cmd/compile/internal/ssa/loop_test.go
View File

@ -49,7 +49,7 @@ func TestLoopConditionS390X(t *testing.T) {
fun := c.Fun("entry",
Bloc("entry",
Valu("mem", OpInitMem, types.TypeMem, 0, nil),
Valu("SP", OpSP, c.config.Types.UInt64, 0, nil),
Valu("SP", OpSP, c.config.Types.Uintptr, 0, nil),
Valu("ret", OpAddr, c.config.Types.Int64.PtrTo(), 0, nil, "SP"),
Valu("N", OpArg, c.config.Types.Int64, 0, c.Frontend().Auto(src.NoXPos, c.config.Types.Int64)),
Valu("starti", OpConst64, c.config.Types.Int64, 0, nil),

22
src/cmd/compile/internal/ssa/nilcheck_test.go
View File

@ -24,7 +24,7 @@ func benchmarkNilCheckDeep(b *testing.B, depth int) {
blocs = append(blocs,
Bloc("entry",
Valu("mem", OpInitMem, types.TypeMem, 0, nil),
Valu("sb", OpSB, types.TypeInvalid, 0, nil),
Valu("sb", OpSB, c.config.Types.Uintptr, 0, nil),
Goto(blockn(0)),
),
)
@ -69,7 +69,7 @@ func TestNilcheckSimple(t *testing.T) {
fun := c.Fun("entry",
Bloc("entry",
Valu("mem", OpInitMem, types.TypeMem, 0, nil),
Valu("sb", OpSB, types.TypeInvalid, 0, nil),
Valu("sb", OpSB, c.config.Types.Uintptr, 0, nil),
Goto("checkPtr")),
Bloc("checkPtr",
Valu("ptr1", OpLoad, ptrType, 0, nil, "sb", "mem"),
@ -106,7 +106,7 @@ func TestNilcheckDomOrder(t *testing.T) {
fun := c.Fun("entry",
Bloc("entry",
Valu("mem", OpInitMem, types.TypeMem, 0, nil),
Valu("sb", OpSB, types.TypeInvalid, 0, nil),
Valu("sb", OpSB, c.config.Types.Uintptr, 0, nil),
Goto("checkPtr")),
Bloc("checkPtr",
Valu("ptr1", OpLoad, ptrType, 0, nil, "sb", "mem"),
@ -142,7 +142,7 @@ func TestNilcheckAddr(t *testing.T) {
fun := c.Fun("entry",
Bloc("entry",
Valu("mem", OpInitMem, types.TypeMem, 0, nil),
Valu("sb", OpSB, types.TypeInvalid, 0, nil),
Valu("sb", OpSB, c.config.Types.Uintptr, 0, nil),
Goto("checkPtr")),
Bloc("checkPtr",
Valu("ptr1", OpAddr, ptrType, 0, nil, "sb"),
@ -175,7 +175,7 @@ func TestNilcheckAddPtr(t *testing.T) {
fun := c.Fun("entry",
Bloc("entry",
Valu("mem", OpInitMem, types.TypeMem, 0, nil),
Valu("sb", OpSB, types.TypeInvalid, 0, nil),
Valu("sb", OpSB, c.config.Types.Uintptr, 0, nil),
Goto("checkPtr")),
Bloc("checkPtr",
Valu("off", OpConst64, c.config.Types.Int64, 20, nil),
@ -210,8 +210,8 @@ func TestNilcheckPhi(t *testing.T) {
fun := c.Fun("entry",
Bloc("entry",
Valu("mem", OpInitMem, types.TypeMem, 0, nil),
Valu("sb", OpSB, types.TypeInvalid, 0, nil),
Valu("sp", OpSP, types.TypeInvalid, 0, nil),
Valu("sb", OpSB, c.config.Types.Uintptr, 0, nil),
Valu("sp", OpSP, c.config.Types.Uintptr, 0, nil),
Valu("baddr", OpAddr, c.config.Types.Bool, 0, "b", "sp"),
Valu("bool1", OpLoad, c.config.Types.Bool, 0, nil, "baddr", "mem"),
If("bool1", "b1", "b2")),
@ -254,7 +254,7 @@ func TestNilcheckKeepRemove(t *testing.T) {
fun := c.Fun("entry",
Bloc("entry",
Valu("mem", OpInitMem, types.TypeMem, 0, nil),
Valu("sb", OpSB, types.TypeInvalid, 0, nil),
Valu("sb", OpSB, c.config.Types.Uintptr, 0, nil),
Goto("checkPtr")),
Bloc("checkPtr",
Valu("ptr1", OpLoad, ptrType, 0, nil, "sb", "mem"),
@ -302,7 +302,7 @@ func TestNilcheckInFalseBranch(t *testing.T) {
fun := c.Fun("entry",
Bloc("entry",
Valu("mem", OpInitMem, types.TypeMem, 0, nil),
Valu("sb", OpSB, types.TypeInvalid, 0, nil),
Valu("sb", OpSB, c.config.Types.Uintptr, 0, nil),
Goto("checkPtr")),
Bloc("checkPtr",
Valu("ptr1", OpLoad, ptrType, 0, nil, "sb", "mem"),
@ -353,7 +353,7 @@ func TestNilcheckUser(t *testing.T) {
fun := c.Fun("entry",
Bloc("entry",
Valu("mem", OpInitMem, types.TypeMem, 0, nil),
Valu("sb", OpSB, types.TypeInvalid, 0, nil),
Valu("sb", OpSB, c.config.Types.Uintptr, 0, nil),
Goto("checkPtr")),
Bloc("checkPtr",
Valu("ptr1", OpLoad, ptrType, 0, nil, "sb", "mem"),
@ -392,7 +392,7 @@ func TestNilcheckBug(t *testing.T) {
fun := c.Fun("entry",
Bloc("entry",
Valu("mem", OpInitMem, types.TypeMem, 0, nil),
Valu("sb", OpSB, types.TypeInvalid, 0, nil),
Valu("sb", OpSB, c.config.Types.Uintptr, 0, nil),
Goto("checkPtr")),
Bloc("checkPtr",
Valu("ptr1", OpLoad, ptrType, 0, nil, "sb", "mem"),

2
src/cmd/compile/internal/ssa/passbm_test.go
View File

@ -68,7 +68,7 @@ func genFunction(size int) []bloc {
blocs = append(blocs,
Bloc("entry",
Valu(valn("store", 0, 4), OpInitMem, types.TypeMem, 0, nil),
Valu("sb", OpSB, types.TypeInvalid, 0, nil),
Valu("sb", OpSB, types.Types[types.TUINTPTR], 0, nil),
Goto(blockn(1)),
),
)

4
src/cmd/compile/internal/ssa/shift_test.go
View File

@ -35,7 +35,7 @@ func makeConstShiftFunc(c *Conf, amount int64, op Op, typ *types.Type) fun {
fun := c.Fun("entry",
Bloc("entry",
Valu("mem", OpInitMem, types.TypeMem, 0, nil),
Valu("SP", OpSP, c.config.Types.UInt64, 0, nil),
Valu("SP", OpSP, c.config.Types.Uintptr, 0, nil),
Valu("argptr", OpOffPtr, ptyp, 8, nil, "SP"),
Valu("resptr", OpOffPtr, ptyp, 16, nil, "SP"),
Valu("load", OpLoad, typ, 0, nil, "argptr", "mem"),
@ -93,7 +93,7 @@ func makeShiftExtensionFunc(c *Conf, amount int64, lshift, rshift Op, typ *types
fun := c.Fun("entry",
Bloc("entry",
Valu("mem", OpInitMem, types.TypeMem, 0, nil),
Valu("SP", OpSP, c.config.Types.UInt64, 0, nil),
Valu("SP", OpSP, c.config.Types.Uintptr, 0, nil),
Valu("argptr", OpOffPtr, ptyp, 8, nil, "SP"),
Valu("resptr", OpOffPtr, ptyp, 16, nil, "SP"),
Valu("load", OpLoad, typ, 0, nil, "argptr", "mem"),

8
src/cmd/compile/internal/ssa/writebarrier_test.go
View File

@ -16,8 +16,8 @@ func TestWriteBarrierStoreOrder(t *testing.T) {
fun := c.Fun("entry",
Bloc("entry",
Valu("start", OpInitMem, types.TypeMem, 0, nil),
Valu("sb", OpSB, types.TypeInvalid, 0, nil),
Valu("sp", OpSP, types.TypeInvalid, 0, nil),
Valu("sb", OpSB, c.config.Types.Uintptr, 0, nil),
Valu("sp", OpSP, c.config.Types.Uintptr, 0, nil),
Valu("v", OpConstNil, ptrType, 0, nil),
Valu("addr1", OpAddr, ptrType, 0, nil, "sb"),
Valu("wb2", OpStore, types.TypeMem, 0, ptrType, "addr1", "v", "wb1"),
@ -40,8 +40,8 @@ func TestWriteBarrierPhi(t *testing.T) {
fun := c.Fun("entry",
Bloc("entry",
Valu("start", OpInitMem, types.TypeMem, 0, nil),
Valu("sb", OpSB, types.TypeInvalid, 0, nil),
Valu("sp", OpSP, types.TypeInvalid, 0, nil),
Valu("sb", OpSB, c.config.Types.Uintptr, 0, nil),
Valu("sp", OpSP, c.config.Types.Uintptr, 0, nil),
Goto("loop")),
Bloc("loop",
Valu("phi", OpPhi, types.TypeMem, 0, nil, "start", "wb"),