Merge branch 'master' into dev.regabi

Change-Id: I098acdbc5e2676aeb8700d935e796a9c29d04b88

diff --cc src/cmd/compile/internal/gc/builtin.go
index 07e864dd2e466801a6a34158334e58c4f07a9c5f,e04f23e2294ed6bfbd06681db61169e09f9e069e..d3e3f9ade6731472ded9795ae5a883dd1169063c
--- 1/src/cmd/compile/internal/gc/builtin.go
--- 2/src/cmd/compile/internal/gc/builtin.go
+++ b/src/cmd/compile/internal/gc/builtin.go
@@@ -205,137 -203,138 +206,138 @@@ var runtimeDecls = [...]struct 
  }
  
  func runtimeTypes() []*types.Type {
-       var typs [131]*types.Type
+       var typs [132]*types.Type
 -      typs[0] = types.Bytetype
 +      typs[0] = types.ByteType
        typs[1] = types.NewPtr(typs[0])
 -      typs[2] = types.Types[TANY]
 +      typs[2] = types.Types[types.TANY]
        typs[3] = types.NewPtr(typs[2])
 -      typs[4] = functype(nil, []*Node{anonfield(typs[1])}, []*Node{anonfield(typs[3])})
 -      typs[5] = types.Types[TUINTPTR]
 -      typs[6] = types.Types[TBOOL]
 -      typs[7] = types.Types[TUNSAFEPTR]
 -      typs[8] = functype(nil, []*Node{anonfield(typs[5]), anonfield(typs[1]), anonfield(typs[6])}, []*Node{anonfield(typs[7])})
 +      typs[4] = functype(nil, []*ir.Field{anonfield(typs[1])}, []*ir.Field{anonfield(typs[3])})
 +      typs[5] = types.Types[types.TUINTPTR]
 +      typs[6] = types.Types[types.TBOOL]
 +      typs[7] = types.Types[types.TUNSAFEPTR]
 +      typs[8] = functype(nil, []*ir.Field{anonfield(typs[5]), anonfield(typs[1]), anonfield(typs[6])}, []*ir.Field{anonfield(typs[7])})
        typs[9] = functype(nil, nil, nil)
 -      typs[10] = types.Types[TINTER]
 -      typs[11] = functype(nil, []*Node{anonfield(typs[10])}, nil)
 -      typs[12] = types.Types[TINT32]
 +      typs[10] = types.Types[types.TINTER]
 +      typs[11] = functype(nil, []*ir.Field{anonfield(typs[10])}, nil)
 +      typs[12] = types.Types[types.TINT32]
        typs[13] = types.NewPtr(typs[12])
 -      typs[14] = functype(nil, []*Node{anonfield(typs[13])}, []*Node{anonfield(typs[10])})
 -      typs[15] = types.Types[TINT]
 -      typs[16] = functype(nil, []*Node{anonfield(typs[15]), anonfield(typs[15])}, nil)
 -      typs[17] = types.Types[TUINT]
 -      typs[18] = functype(nil, []*Node{anonfield(typs[17]), anonfield(typs[15])}, nil)
 -      typs[19] = functype(nil, []*Node{anonfield(typs[6])}, nil)
 -      typs[20] = types.Types[TFLOAT64]
 -      typs[21] = functype(nil, []*Node{anonfield(typs[20])}, nil)
 -      typs[22] = types.Types[TINT64]
 -      typs[23] = functype(nil, []*Node{anonfield(typs[22])}, nil)
 -      typs[24] = types.Types[TUINT64]
 -      typs[25] = functype(nil, []*Node{anonfield(typs[24])}, nil)
 -      typs[26] = types.Types[TCOMPLEX128]
 -      typs[27] = functype(nil, []*Node{anonfield(typs[26])}, nil)
 -      typs[28] = types.Types[TSTRING]
 -      typs[29] = functype(nil, []*Node{anonfield(typs[28])}, nil)
 -      typs[30] = functype(nil, []*Node{anonfield(typs[2])}, nil)
 -      typs[31] = functype(nil, []*Node{anonfield(typs[5])}, nil)
 +      typs[14] = functype(nil, []*ir.Field{anonfield(typs[13])}, []*ir.Field{anonfield(typs[10])})
 +      typs[15] = types.Types[types.TINT]
 +      typs[16] = functype(nil, []*ir.Field{anonfield(typs[15]), anonfield(typs[15])}, nil)
 +      typs[17] = types.Types[types.TUINT]
 +      typs[18] = functype(nil, []*ir.Field{anonfield(typs[17]), anonfield(typs[15])}, nil)
 +      typs[19] = functype(nil, []*ir.Field{anonfield(typs[6])}, nil)
 +      typs[20] = types.Types[types.TFLOAT64]
 +      typs[21] = functype(nil, []*ir.Field{anonfield(typs[20])}, nil)
 +      typs[22] = types.Types[types.TINT64]
 +      typs[23] = functype(nil, []*ir.Field{anonfield(typs[22])}, nil)
 +      typs[24] = types.Types[types.TUINT64]
 +      typs[25] = functype(nil, []*ir.Field{anonfield(typs[24])}, nil)
 +      typs[26] = types.Types[types.TCOMPLEX128]
 +      typs[27] = functype(nil, []*ir.Field{anonfield(typs[26])}, nil)
 +      typs[28] = types.Types[types.TSTRING]
 +      typs[29] = functype(nil, []*ir.Field{anonfield(typs[28])}, nil)
 +      typs[30] = functype(nil, []*ir.Field{anonfield(typs[2])}, nil)
 +      typs[31] = functype(nil, []*ir.Field{anonfield(typs[5])}, nil)
        typs[32] = types.NewArray(typs[0], 32)
        typs[33] = types.NewPtr(typs[32])
 -      typs[34] = functype(nil, []*Node{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28])}, []*Node{anonfield(typs[28])})
 -      typs[35] = functype(nil, []*Node{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28])}, []*Node{anonfield(typs[28])})
 -      typs[36] = functype(nil, []*Node{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28])}, []*Node{anonfield(typs[28])})
 -      typs[37] = functype(nil, []*Node{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28])}, []*Node{anonfield(typs[28])})
 +      typs[34] = functype(nil, []*ir.Field{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28])}, []*ir.Field{anonfield(typs[28])})
 +      typs[35] = functype(nil, []*ir.Field{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28])}, []*ir.Field{anonfield(typs[28])})
 +      typs[36] = functype(nil, []*ir.Field{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28])}, []*ir.Field{anonfield(typs[28])})
 +      typs[37] = functype(nil, []*ir.Field{anonfield(typs[33]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28]), anonfield(typs[28])}, []*ir.Field{anonfield(typs[28])})
        typs[38] = types.NewSlice(typs[28])
 -      typs[39] = functype(nil, []*Node{anonfield(typs[33]), anonfield(typs[38])}, []*Node{anonfield(typs[28])})
 -      typs[40] = functype(nil, []*Node{anonfield(typs[28]), anonfield(typs[28])}, []*Node{anonfield(typs[15])})
 +      typs[39] = functype(nil, []*ir.Field{anonfield(typs[33]), anonfield(typs[38])}, []*ir.Field{anonfield(typs[28])})
 +      typs[40] = functype(nil, []*ir.Field{anonfield(typs[28]), anonfield(typs[28])}, []*ir.Field{anonfield(typs[15])})
        typs[41] = types.NewArray(typs[0], 4)
        typs[42] = types.NewPtr(typs[41])
 -      typs[43] = functype(nil, []*Node{anonfield(typs[42]), anonfield(typs[22])}, []*Node{anonfield(typs[28])})
 -      typs[44] = functype(nil, []*Node{anonfield(typs[33]), anonfield(typs[1]), anonfield(typs[15])}, []*Node{anonfield(typs[28])})
 -      typs[45] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[15])}, []*Node{anonfield(typs[28])})
 -      typs[46] = types.Runetype
 +      typs[43] = functype(nil, []*ir.Field{anonfield(typs[42]), anonfield(typs[22])}, []*ir.Field{anonfield(typs[28])})
 +      typs[44] = functype(nil, []*ir.Field{anonfield(typs[33]), anonfield(typs[1]), anonfield(typs[15])}, []*ir.Field{anonfield(typs[28])})
 +      typs[45] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[15])}, []*ir.Field{anonfield(typs[28])})
 +      typs[46] = types.RuneType
        typs[47] = types.NewSlice(typs[46])
 -      typs[48] = functype(nil, []*Node{anonfield(typs[33]), anonfield(typs[47])}, []*Node{anonfield(typs[28])})
 +      typs[48] = functype(nil, []*ir.Field{anonfield(typs[33]), anonfield(typs[47])}, []*ir.Field{anonfield(typs[28])})
        typs[49] = types.NewSlice(typs[0])
 -      typs[50] = functype(nil, []*Node{anonfield(typs[33]), anonfield(typs[28])}, []*Node{anonfield(typs[49])})
 +      typs[50] = functype(nil, []*ir.Field{anonfield(typs[33]), anonfield(typs[28])}, []*ir.Field{anonfield(typs[49])})
        typs[51] = types.NewArray(typs[46], 32)
        typs[52] = types.NewPtr(typs[51])
 -      typs[53] = functype(nil, []*Node{anonfield(typs[52]), anonfield(typs[28])}, []*Node{anonfield(typs[47])})
 -      typs[54] = functype(nil, []*Node{anonfield(typs[3]), anonfield(typs[15]), anonfield(typs[3]), anonfield(typs[15]), anonfield(typs[5])}, []*Node{anonfield(typs[15])})
 -      typs[55] = functype(nil, []*Node{anonfield(typs[28]), anonfield(typs[15])}, []*Node{anonfield(typs[46]), anonfield(typs[15])})
 -      typs[56] = functype(nil, []*Node{anonfield(typs[28])}, []*Node{anonfield(typs[15])})
 -      typs[57] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[2])}, []*Node{anonfield(typs[2])})
 -      typs[58] = functype(nil, []*Node{anonfield(typs[2])}, []*Node{anonfield(typs[7])})
 -      typs[59] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[3])}, []*Node{anonfield(typs[2])})
 -      typs[60] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[2])}, []*Node{anonfield(typs[2]), anonfield(typs[6])})
 -      typs[61] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[1]), anonfield(typs[1])}, nil)
 -      typs[62] = functype(nil, []*Node{anonfield(typs[1])}, nil)
 +      typs[53] = functype(nil, []*ir.Field{anonfield(typs[52]), anonfield(typs[28])}, []*ir.Field{anonfield(typs[47])})
 +      typs[54] = functype(nil, []*ir.Field{anonfield(typs[3]), anonfield(typs[15]), anonfield(typs[3]), anonfield(typs[15]), anonfield(typs[5])}, []*ir.Field{anonfield(typs[15])})
 +      typs[55] = functype(nil, []*ir.Field{anonfield(typs[28]), anonfield(typs[15])}, []*ir.Field{anonfield(typs[46]), anonfield(typs[15])})
 +      typs[56] = functype(nil, []*ir.Field{anonfield(typs[28])}, []*ir.Field{anonfield(typs[15])})
 +      typs[57] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[2])}, []*ir.Field{anonfield(typs[2])})
 +      typs[58] = functype(nil, []*ir.Field{anonfield(typs[2])}, []*ir.Field{anonfield(typs[7])})
 +      typs[59] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[3])}, []*ir.Field{anonfield(typs[2])})
 +      typs[60] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[2])}, []*ir.Field{anonfield(typs[2]), anonfield(typs[6])})
 +      typs[61] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[1]), anonfield(typs[1])}, nil)
 +      typs[62] = functype(nil, []*ir.Field{anonfield(typs[1])}, nil)
        typs[63] = types.NewPtr(typs[5])
 -      typs[64] = functype(nil, []*Node{anonfield(typs[63]), anonfield(typs[7]), anonfield(typs[7])}, []*Node{anonfield(typs[6])})
 -      typs[65] = types.Types[TUINT32]
 -      typs[66] = functype(nil, nil, []*Node{anonfield(typs[65])})
 +      typs[64] = functype(nil, []*ir.Field{anonfield(typs[63]), anonfield(typs[7]), anonfield(typs[7])}, []*ir.Field{anonfield(typs[6])})
 +      typs[65] = types.Types[types.TUINT32]
 +      typs[66] = functype(nil, nil, []*ir.Field{anonfield(typs[65])})
        typs[67] = types.NewMap(typs[2], typs[2])
 -      typs[68] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[22]), anonfield(typs[3])}, []*Node{anonfield(typs[67])})
 -      typs[69] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[15]), anonfield(typs[3])}, []*Node{anonfield(typs[67])})
 -      typs[70] = functype(nil, nil, []*Node{anonfield(typs[67])})
 -      typs[71] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3])}, []*Node{anonfield(typs[3])})
 -      typs[72] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[2])}, []*Node{anonfield(typs[3])})
 -      typs[73] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3]), anonfield(typs[1])}, []*Node{anonfield(typs[3])})
 -      typs[74] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3])}, []*Node{anonfield(typs[3]), anonfield(typs[6])})
 -      typs[75] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[2])}, []*Node{anonfield(typs[3]), anonfield(typs[6])})
 -      typs[76] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3]), anonfield(typs[1])}, []*Node{anonfield(typs[3]), anonfield(typs[6])})
 -      typs[77] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3])}, nil)
 -      typs[78] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[2])}, nil)
 -      typs[79] = functype(nil, []*Node{anonfield(typs[3])}, nil)
 -      typs[80] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[67])}, nil)
 +      typs[68] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[22]), anonfield(typs[3])}, []*ir.Field{anonfield(typs[67])})
 +      typs[69] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[15]), anonfield(typs[3])}, []*ir.Field{anonfield(typs[67])})
 +      typs[70] = functype(nil, nil, []*ir.Field{anonfield(typs[67])})
 +      typs[71] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3])}, []*ir.Field{anonfield(typs[3])})
 +      typs[72] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[2])}, []*ir.Field{anonfield(typs[3])})
 +      typs[73] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3]), anonfield(typs[1])}, []*ir.Field{anonfield(typs[3])})
 +      typs[74] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3])}, []*ir.Field{anonfield(typs[3]), anonfield(typs[6])})
 +      typs[75] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[2])}, []*ir.Field{anonfield(typs[3]), anonfield(typs[6])})
 +      typs[76] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3]), anonfield(typs[1])}, []*ir.Field{anonfield(typs[3]), anonfield(typs[6])})
 +      typs[77] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[3])}, nil)
 +      typs[78] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[67]), anonfield(typs[2])}, nil)
 +      typs[79] = functype(nil, []*ir.Field{anonfield(typs[3])}, nil)
 +      typs[80] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[67])}, nil)
        typs[81] = types.NewChan(typs[2], types.Cboth)
 -      typs[82] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[22])}, []*Node{anonfield(typs[81])})
 -      typs[83] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[15])}, []*Node{anonfield(typs[81])})
 +      typs[82] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[22])}, []*ir.Field{anonfield(typs[81])})
 +      typs[83] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[15])}, []*ir.Field{anonfield(typs[81])})
        typs[84] = types.NewChan(typs[2], types.Crecv)
 -      typs[85] = functype(nil, []*Node{anonfield(typs[84]), anonfield(typs[3])}, nil)
 -      typs[86] = functype(nil, []*Node{anonfield(typs[84]), anonfield(typs[3])}, []*Node{anonfield(typs[6])})
 +      typs[85] = functype(nil, []*ir.Field{anonfield(typs[84]), anonfield(typs[3])}, nil)
 +      typs[86] = functype(nil, []*ir.Field{anonfield(typs[84]), anonfield(typs[3])}, []*ir.Field{anonfield(typs[6])})
        typs[87] = types.NewChan(typs[2], types.Csend)
 -      typs[88] = functype(nil, []*Node{anonfield(typs[87]), anonfield(typs[3])}, nil)
 +      typs[88] = functype(nil, []*ir.Field{anonfield(typs[87]), anonfield(typs[3])}, nil)
        typs[89] = types.NewArray(typs[0], 3)
 -      typs[90] = tostruct([]*Node{namedfield("enabled", typs[6]), namedfield("pad", typs[89]), namedfield("needed", typs[6]), namedfield("cgo", typs[6]), namedfield("alignme", typs[24])})
 -      typs[91] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[3]), anonfield(typs[3])}, nil)
 -      typs[92] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[3])}, nil)
 -      typs[93] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[3]), anonfield(typs[15]), anonfield(typs[3]), anonfield(typs[15])}, []*Node{anonfield(typs[15])})
 -      typs[94] = functype(nil, []*Node{anonfield(typs[87]), anonfield(typs[3])}, []*Node{anonfield(typs[6])})
 -      typs[95] = functype(nil, []*Node{anonfield(typs[3]), anonfield(typs[84])}, []*Node{anonfield(typs[6])})
 +      typs[90] = tostruct([]*ir.Field{namedfield("enabled", typs[6]), namedfield("pad", typs[89]), namedfield("needed", typs[6]), namedfield("cgo", typs[6]), namedfield("alignme", typs[24])})
 +      typs[91] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[3]), anonfield(typs[3])}, nil)
 +      typs[92] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[3])}, nil)
 +      typs[93] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[3]), anonfield(typs[15]), anonfield(typs[3]), anonfield(typs[15])}, []*ir.Field{anonfield(typs[15])})
 +      typs[94] = functype(nil, []*ir.Field{anonfield(typs[87]), anonfield(typs[3])}, []*ir.Field{anonfield(typs[6])})
 +      typs[95] = functype(nil, []*ir.Field{anonfield(typs[3]), anonfield(typs[84])}, []*ir.Field{anonfield(typs[6])})
        typs[96] = types.NewPtr(typs[6])
 -      typs[97] = functype(nil, []*Node{anonfield(typs[3]), anonfield(typs[96]), anonfield(typs[84])}, []*Node{anonfield(typs[6])})
 -      typs[98] = functype(nil, []*Node{anonfield(typs[63])}, nil)
 -      typs[99] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[1]), anonfield(typs[63]), anonfield(typs[15]), anonfield(typs[15]), anonfield(typs[6])}, []*Node{anonfield(typs[15]), anonfield(typs[6])})
 -      typs[100] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[15]), anonfield(typs[15])}, []*Node{anonfield(typs[7])})
 -      typs[101] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[22]), anonfield(typs[22])}, []*Node{anonfield(typs[7])})
 -      typs[102] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[15]), anonfield(typs[15]), anonfield(typs[7])}, []*Node{anonfield(typs[7])})
 +      typs[97] = functype(nil, []*ir.Field{anonfield(typs[3]), anonfield(typs[96]), anonfield(typs[84])}, []*ir.Field{anonfield(typs[6])})
 +      typs[98] = functype(nil, []*ir.Field{anonfield(typs[63])}, nil)
 +      typs[99] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[1]), anonfield(typs[63]), anonfield(typs[15]), anonfield(typs[15]), anonfield(typs[6])}, []*ir.Field{anonfield(typs[15]), anonfield(typs[6])})
 +      typs[100] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[15]), anonfield(typs[15])}, []*ir.Field{anonfield(typs[7])})
 +      typs[101] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[22]), anonfield(typs[22])}, []*ir.Field{anonfield(typs[7])})
 +      typs[102] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[15]), anonfield(typs[15]), anonfield(typs[7])}, []*ir.Field{anonfield(typs[7])})
        typs[103] = types.NewSlice(typs[2])
 -      typs[104] = functype(nil, []*Node{anonfield(typs[1]), anonfield(typs[103]), anonfield(typs[15])}, []*Node{anonfield(typs[103])})
 -      typs[105] = functype(nil, []*Node{anonfield(typs[3]), anonfield(typs[3]), anonfield(typs[5])}, nil)
 -      typs[106] = functype(nil, []*Node{anonfield(typs[7]), anonfield(typs[5])}, nil)
 -      typs[107] = functype(nil, []*Node{anonfield(typs[3]), anonfield(typs[3]), anonfield(typs[5])}, []*Node{anonfield(typs[6])})
 -      typs[108] = functype(nil, []*Node{anonfield(typs[3]), anonfield(typs[3])}, []*Node{anonfield(typs[6])})
 -      typs[109] = functype(nil, []*Node{anonfield(typs[7]), anonfield(typs[7])}, []*Node{anonfield(typs[6])})
 -      typs[110] = functype(nil, []*Node{anonfield(typs[7]), anonfield(typs[5]), anonfield(typs[5])}, []*Node{anonfield(typs[5])})
 -      typs[111] = functype(nil, []*Node{anonfield(typs[7]), anonfield(typs[5])}, []*Node{anonfield(typs[5])})
 -      typs[112] = functype(nil, []*Node{anonfield(typs[22]), anonfield(typs[22])}, []*Node{anonfield(typs[22])})
 -      typs[113] = functype(nil, []*Node{anonfield(typs[24]), anonfield(typs[24])}, []*Node{anonfield(typs[24])})
 -      typs[114] = functype(nil, []*Node{anonfield(typs[20])}, []*Node{anonfield(typs[22])})
 -      typs[115] = functype(nil, []*Node{anonfield(typs[20])}, []*Node{anonfield(typs[24])})
 -      typs[116] = functype(nil, []*Node{anonfield(typs[20])}, []*Node{anonfield(typs[65])})
 -      typs[117] = functype(nil, []*Node{anonfield(typs[22])}, []*Node{anonfield(typs[20])})
 -      typs[118] = functype(nil, []*Node{anonfield(typs[24])}, []*Node{anonfield(typs[20])})
 -      typs[119] = functype(nil, []*Node{anonfield(typs[65])}, []*Node{anonfield(typs[20])})
 -      typs[120] = functype(nil, []*Node{anonfield(typs[26]), anonfield(typs[26])}, []*Node{anonfield(typs[26])})
 -      typs[121] = functype(nil, []*Node{anonfield(typs[5]), anonfield(typs[5])}, nil)
 -      typs[122] = functype(nil, []*Node{anonfield(typs[5]), anonfield(typs[5]), anonfield(typs[5])}, nil)
 -      typs[123] = functype(nil, []*Node{anonfield(typs[7]), anonfield(typs[1]), anonfield(typs[5])}, nil)
 +      typs[104] = functype(nil, []*ir.Field{anonfield(typs[1]), anonfield(typs[103]), anonfield(typs[15])}, []*ir.Field{anonfield(typs[103])})
 +      typs[105] = functype(nil, []*ir.Field{anonfield(typs[3]), anonfield(typs[3]), anonfield(typs[5])}, nil)
 +      typs[106] = functype(nil, []*ir.Field{anonfield(typs[7]), anonfield(typs[5])}, nil)
 +      typs[107] = functype(nil, []*ir.Field{anonfield(typs[3]), anonfield(typs[3]), anonfield(typs[5])}, []*ir.Field{anonfield(typs[6])})
 +      typs[108] = functype(nil, []*ir.Field{anonfield(typs[3]), anonfield(typs[3])}, []*ir.Field{anonfield(typs[6])})
 +      typs[109] = functype(nil, []*ir.Field{anonfield(typs[7]), anonfield(typs[7])}, []*ir.Field{anonfield(typs[6])})
 +      typs[110] = functype(nil, []*ir.Field{anonfield(typs[7]), anonfield(typs[5]), anonfield(typs[5])}, []*ir.Field{anonfield(typs[5])})
 +      typs[111] = functype(nil, []*ir.Field{anonfield(typs[7]), anonfield(typs[5])}, []*ir.Field{anonfield(typs[5])})
 +      typs[112] = functype(nil, []*ir.Field{anonfield(typs[22]), anonfield(typs[22])}, []*ir.Field{anonfield(typs[22])})
 +      typs[113] = functype(nil, []*ir.Field{anonfield(typs[24]), anonfield(typs[24])}, []*ir.Field{anonfield(typs[24])})
 +      typs[114] = functype(nil, []*ir.Field{anonfield(typs[20])}, []*ir.Field{anonfield(typs[22])})
 +      typs[115] = functype(nil, []*ir.Field{anonfield(typs[20])}, []*ir.Field{anonfield(typs[24])})
 +      typs[116] = functype(nil, []*ir.Field{anonfield(typs[20])}, []*ir.Field{anonfield(typs[65])})
 +      typs[117] = functype(nil, []*ir.Field{anonfield(typs[22])}, []*ir.Field{anonfield(typs[20])})
 +      typs[118] = functype(nil, []*ir.Field{anonfield(typs[24])}, []*ir.Field{anonfield(typs[20])})
 +      typs[119] = functype(nil, []*ir.Field{anonfield(typs[65])}, []*ir.Field{anonfield(typs[20])})
 +      typs[120] = functype(nil, []*ir.Field{anonfield(typs[26]), anonfield(typs[26])}, []*ir.Field{anonfield(typs[26])})
 +      typs[121] = functype(nil, []*ir.Field{anonfield(typs[5]), anonfield(typs[5])}, nil)
-       typs[122] = functype(nil, []*ir.Field{anonfield(typs[7]), anonfield(typs[1]), anonfield(typs[5])}, nil)
-       typs[123] = types.NewSlice(typs[7])
-       typs[124] = functype(nil, []*ir.Field{anonfield(typs[7]), anonfield(typs[123])}, nil)
-       typs[125] = types.Types[types.TUINT8]
-       typs[126] = functype(nil, []*ir.Field{anonfield(typs[125]), anonfield(typs[125])}, nil)
-       typs[127] = types.Types[types.TUINT16]
-       typs[128] = functype(nil, []*ir.Field{anonfield(typs[127]), anonfield(typs[127])}, nil)
-       typs[129] = functype(nil, []*ir.Field{anonfield(typs[65]), anonfield(typs[65])}, nil)
-       typs[130] = functype(nil, []*ir.Field{anonfield(typs[24]), anonfield(typs[24])}, nil)
++      typs[122] = functype(nil, []*ir.Field{anonfield(typs[5]), anonfield(typs[5]), anonfield(typs[5])}, nil)
++      typs[123] = functype(nil, []*ir.Field{anonfield(typs[7]), anonfield(typs[1]), anonfield(typs[5])}, nil)
+       typs[124] = types.NewSlice(typs[7])
 -      typs[125] = functype(nil, []*Node{anonfield(typs[7]), anonfield(typs[124])}, nil)
 -      typs[126] = types.Types[TUINT8]
 -      typs[127] = functype(nil, []*Node{anonfield(typs[126]), anonfield(typs[126])}, nil)
 -      typs[128] = types.Types[TUINT16]
 -      typs[129] = functype(nil, []*Node{anonfield(typs[128]), anonfield(typs[128])}, nil)
 -      typs[130] = functype(nil, []*Node{anonfield(typs[65]), anonfield(typs[65])}, nil)
 -      typs[131] = functype(nil, []*Node{anonfield(typs[24]), anonfield(typs[24])}, nil)
++      typs[125] = functype(nil, []*ir.Field{anonfield(typs[7]), anonfield(typs[124])}, nil)
++      typs[126] = types.Types[types.TUINT8]
++      typs[127] = functype(nil, []*ir.Field{anonfield(typs[126]), anonfield(typs[126])}, nil)
++      typs[128] = types.Types[types.TUINT16]
++      typs[129] = functype(nil, []*ir.Field{anonfield(typs[128]), anonfield(typs[128])}, nil)
++      typs[130] = functype(nil, []*ir.Field{anonfield(typs[65]), anonfield(typs[65])}, nil)
++      typs[131] = functype(nil, []*ir.Field{anonfield(typs[24]), anonfield(typs[24])}, nil)
        return typs[:]
  }

diff --cc src/cmd/compile/internal/gc/go.go
Simple merge

diff --cc src/cmd/compile/internal/gc/ssa.go
index 9539e9cc8a4c2e871da1467245431ed2c1d08310,65b9291b764d0237bc1f33fe6cd4ac76dd1c8406..f13c45c2a618b8a492c8d40dcc784dfea34af1d2
--- 1/src/cmd/compile/internal/gc/ssa.go
--- 2/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@@ -965,8 -967,46 +966,46 @@@ func (s *state) newValueOrSfCall2(op ss
        return s.newValue2(op, t, arg0, arg1)
  }
  
- func (s *state) instrument(t *types.Type, addr *ssa.Value, wr bool) {
-       if !s.curfn.InstrumentBody() {
+ type instrumentKind uint8
+ 
+ const (
+       instrumentRead = iota
+       instrumentWrite
+       instrumentMove
+ )
+ 
+ func (s *state) instrument(t *types.Type, addr *ssa.Value, kind instrumentKind) {
+       s.instrument2(t, addr, nil, kind)
+ }
+ 
+ // instrumentFields instruments a read/write operation on addr.
+ // If it is instrumenting for MSAN and t is a struct type, it instruments
+ // operation for each field, instead of for the whole struct.
+ func (s *state) instrumentFields(t *types.Type, addr *ssa.Value, kind instrumentKind) {
 -      if !flag_msan || !t.IsStruct() {
++      if !base.Flag.MSan || !t.IsStruct() {
+               s.instrument(t, addr, kind)
+               return
+       }
+       for _, f := range t.Fields().Slice() {
+               if f.Sym.IsBlank() {
+                       continue
+               }
+               offptr := s.newValue1I(ssa.OpOffPtr, types.NewPtr(f.Type), f.Offset, addr)
+               s.instrumentFields(f.Type, offptr, kind)
+       }
+ }
+ 
+ func (s *state) instrumentMove(t *types.Type, dst, src *ssa.Value) {
 -      if flag_msan {
++      if base.Flag.MSan {
+               s.instrument2(t, dst, src, instrumentMove)
+       } else {
+               s.instrument(t, src, instrumentRead)
+               s.instrument(t, dst, instrumentWrite)
+       }
+ }
+ 
+ func (s *state) instrument2(t *types.Type, addr, addr2 *ssa.Value, kind instrumentKind) {
 -      if !s.curfn.Func.InstrumentBody() {
++      if !s.curfn.Func().InstrumentBody() {
                return
        }
  
@@@ -982,35 -1022,56 +1021,56 @@@
        var fn *obj.LSym
        needWidth := false
  
 -      if flag_msan {
+       if addr2 != nil && kind != instrumentMove {
+               panic("instrument2: non-nil addr2 for non-move instrumentation")
+       }
+ 
-               fn = msanread
-               if wr {
 +      if base.Flag.MSan {
+               switch kind {
+               case instrumentRead:
+                       fn = msanread
+               case instrumentWrite:
                        fn = msanwrite
+               case instrumentMove:
+                       fn = msanmove
+               default:
+                       panic("unreachable")
                }
                needWidth = true
 -      } else if flag_race && t.NumComponents(types.CountBlankFields) > 1 {
 +      } else if base.Flag.Race && t.NumComponents(types.CountBlankFields) > 1 {
                // for composite objects we have to write every address
                // because a write might happen to any subobject.
                // composites with only one element don't have subobjects, though.
-               fn = racereadrange
-               if wr {
+               switch kind {
+               case instrumentRead:
+                       fn = racereadrange
+               case instrumentWrite:
                        fn = racewriterange
+               default:
+                       panic("unreachable")
                }
                needWidth = true
 -      } else if flag_race {
 +      } else if base.Flag.Race {
                // for non-composite objects we can write just the start
                // address, as any write must write the first byte.
-               fn = raceread
-               if wr {
+               switch kind {
+               case instrumentRead:
+                       fn = raceread
+               case instrumentWrite:
                        fn = racewrite
+               default:
+                       panic("unreachable")
                }
        } else {
                panic("unreachable")
        }
  
        args := []*ssa.Value{addr}
+       if addr2 != nil {
+               args = append(args, addr2)
+       }
        if needWidth {
 -              args = append(args, s.constInt(types.Types[TUINTPTR], w))
 +              args = append(args, s.constInt(types.Types[types.TUINTPTR], w))
        }
        s.rtcall(fn, true, nil, args...)
  }
@@@ -1029,18 -1090,17 +1089,17 @@@ func (s *state) store(t *types.Type, ds
  }
  
  func (s *state) zero(t *types.Type, dst *ssa.Value) {
-       s.instrument(t, dst, true)
+       s.instrument(t, dst, instrumentWrite)
        store := s.newValue2I(ssa.OpZero, types.TypeMem, t.Size(), dst, s.mem())
        store.Aux = t
 -      s.vars[&memVar] = store
 +      s.vars[memVar] = store
  }
  
  func (s *state) move(t *types.Type, dst, src *ssa.Value) {
-       s.instrument(t, src, false)
-       s.instrument(t, dst, true)
+       s.instrumentMove(t, dst, src)
        store := s.newValue3I(ssa.OpMove, types.TypeMem, t.Size(), dst, src, s.mem())
        store.Aux = t
 -      s.vars[&memVar] = store
 +      s.vars[memVar] = store
  }
  
  // stmtList converts the statement list n to SSA and adds it to s.

diff --cc src/cmd/compile/internal/logopt/logopt_test.go
Simple merge

diff --cc src/cmd/compile/internal/wasm/ssa.go
Simple merge

diff --cc src/go/types/stdlib_test.go
Simple merge