Skip to content

G
go
Commit 34699bc7 authored by Josh Bleecher Snyder's avatar Josh Bleecher Snyder
Browse files
Options

cmd/compile: reduce use of **Node parameters 

Escape analysis has a hard time with tree-like
structures (see #13493 and #14858).
This is unlikely to change.
As a result, when invoking a function that accepts
a **Node parameter, we usually allocate a *Node
on the heap. This happens a whole lot.

This CL changes functions from taking a **Node
to acting more like append: It both modifies
the input and returns a replacement for it.

Because of the cascading nature of escape analysis,
in order to get the benefits, I had to modify
almost all such functions. The remaining functions
are in racewalk and the backend. I would be happy
to update them as well in a separate CL.

This CL was created by manually updating the
function signatures and the directly impacted
bits of code. The callsites were then automatically
updated using a bespoke script:
https://gist.github.com/josharian/046b1be7aceae244de39

For ease of reviewing and future understanding,
this CL is also broken down into four CLs,
mailed separately, which show the manual
and the automated changes separately.
They are CLs 20990, 20991, 20992, and 20993.

Passes toolstash -cmp.

name       old time/op     new time/op     delta
Template       335ms ± 5%      324ms ± 5%   -3.35%        (p=0.000 n=23+24)
Unicode        176ms ± 9%      165ms ± 6%   -6.12%        (p=0.000 n=23+24)
GoTypes        1.10s ± 4%      1.07s ± 2%   -2.77%        (p=0.000 n=24+24)
Compiler       5.31s ± 3%      5.15s ± 3%   -2.95%        (p=0.000 n=24+24)
MakeBash       41.6s ± 1%      41.7s ± 2%     ~           (p=0.586 n=23+23)

name       old alloc/op    new alloc/op    delta
Template      63.3MB ± 0%     62.4MB ± 0%   -1.36%        (p=0.000 n=25+23)
Unicode       42.4MB ± 0%     41.6MB ± 0%   -1.99%        (p=0.000 n=24+25)
GoTypes        220MB ± 0%      217MB ± 0%   -1.11%        (p=0.000 n=25+25)
Compiler       994MB ± 0%      973MB ± 0%   -2.08%        (p=0.000 n=24+25)

name       old allocs/op   new allocs/op   delta
Template        681k ± 0%       574k ± 0%  -15.71%        (p=0.000 n=24+25)
Unicode         518k ± 0%       413k ± 0%  -20.34%        (p=0.000 n=25+24)
GoTypes        2.08M ± 0%      1.78M ± 0%  -14.62%        (p=0.000 n=25+25)
Compiler       9.26M ± 0%      7.64M ± 0%  -17.48%        (p=0.000 n=25+25)

name       old text-bytes  new text-bytes  delta
HelloSize       578k ± 0%       578k ± 0%     ~     (all samples are equal)
CmdGoSize      6.46M ± 0%      6.46M ± 0%     ~     (all samples are equal)

name       old data-bytes  new data-bytes  delta
HelloSize       128k ± 0%       128k ± 0%     ~     (all samples are equal)
CmdGoSize       281k ± 0%       281k ± 0%     ~     (all samples are equal)

name       old exe-bytes   new exe-bytes   delta
HelloSize       921k ± 0%       921k ± 0%     ~     (all samples are equal)
CmdGoSize      9.86M ± 0%      9.86M ± 0%     ~     (all samples are equal)

Change-Id: I277d95bd56d51c166ef7f560647aeaa092f3f475
Reviewed-on: https://go-review.googlesource.com/20959Reviewed-by: default avatarDave Cheney <dave@cheney.net>
Reviewed-by: default avatarIan Lance Taylor <iant@golang.org>
parent d1b8871f
Hide whitespace changes
Inline Side-by-side
Showing with 971 additions and 942 deletions
src/cmd/compile/internal/gc/alg.go
View file @ 34699bc7
......@@ -186,7 +186,7 @@ func genhash(sym *Sym, t *Type) {
tfn.Rlist.Append(n)
funchdr(fn)
typecheck(&fn.Func.Nname.Name.Param.Ntype, Etype)
fn.Func.Nname.Name.Param.Ntype = typecheck(fn.Func.Nname.Name.Param.Ntype, Etype)
// genhash is only called for types that have equality but
// cannot be handled by the standard algorithms,
......@@ -281,7 +281,7 @@ func genhash(sym *Sym, t *Type) {
funcbody(fn)
Curfn = fn
fn.Func.Dupok = true
typecheck(&fn, Etop)
fn = typecheck(fn, Etop)
typecheckslice(fn.Nbody.Slice(), Etop)
Curfn = nil
popdcl()
......@@ -331,7 +331,7 @@ func hashfor(t *Type) *Node {
tfn.List.Append(Nod(ODCLFIELD, nil, typenod(Ptrto(t))))
tfn.List.Append(Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
tfn.Rlist.Append(Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
typecheck(&tfn, Etype)
tfn = typecheck(tfn, Etype)
n.Type = tfn.Type
return n
}
......@@ -365,7 +365,7 @@ func geneq(sym *Sym, t *Type) {
tfn.Rlist.Append(n)
funchdr(fn)
typecheck(&fn.Func.Nname.Name.Param.Ntype, Etype)
fn.Func.Nname.Name.Param.Ntype = typecheck(fn.Func.Nname.Name.Param.Ntype, Etype)
// geneq is only called for types that have equality but
// cannot be handled by the standard algorithms,
......@@ -474,7 +474,7 @@ func geneq(sym *Sym, t *Type) {
funcbody(fn)
Curfn = fn
fn.Func.Dupok = true
typecheck(&fn, Etop)
fn = typecheck(fn, Etop)
typecheckslice(fn.Nbody.Slice(), Etop)
Curfn = nil
popdcl()
......@@ -516,8 +516,8 @@ func eqmem(p *Node, q *Node, field *Sym, size int64) *Node {
nx.Etype = 1 // does not escape
ny := Nod(OADDR, NodSym(OXDOT, q, field), nil)
ny.Etype = 1 // does not escape
typecheck(&nx, Erv)
typecheck(&ny, Erv)
nx = typecheck(nx, Erv)
ny = typecheck(ny, Erv)
fn, needsize := eqmemfunc(size, nx.Type.Type)
call := Nod(OCALL, fn, nil)
......@@ -540,7 +540,7 @@ func eqmemfunc(size int64, t *Type) (fn *Node, needsize bool) {
fn = syslook(buf)
}
substArgTypes(&fn, t, t)
fn = substArgTypes(fn, t, t)
return fn, needsize
}
......
src/cmd/compile/internal/gc/bexport.go
View file @ 34699bc7
......@@ -193,7 +193,7 @@ func Export(out *obj.Biobuf, trace bool) int {
switch n := sym.Def; n.Op {
case OLITERAL:
// constant
typecheck(&n, Erv)
n = typecheck(n, Erv)
if n == nil || n.Op != OLITERAL {
Fatalf("exporter: dumpexportconst: oconst nil: %v", sym)
}
......@@ -201,7 +201,7 @@ func Export(out *obj.Biobuf, trace bool) int {
case ONAME:
// variable or function
typecheck(&n, Erv|Ecall)
n = typecheck(n, Erv|Ecall)
if n == nil || n.Type == nil {
Fatalf("exporter: variable/function exported but not defined: %v", sym)
}
......
src/cmd/compile/internal/gc/cgen.go
View file @ 34699bc7
......@@ -391,7 +391,7 @@ func cgen_wb(n, res *Node, wb bool) {
case OMINUS:
if Isfloat[nl.Type.Etype] {
nr = Nodintconst(-1)
convlit(&nr, n.Type)
nr = convlit(nr, n.Type)
a = Thearch.Optoas(OMUL, nl.Type)
goto sbop
}
......@@ -803,7 +803,7 @@ func cgen_wbptr(n, res *Node) {
wbVar := syslook("writeBarrier")
wbEnabled := NodSym(ODOT, wbVar, wbVar.Type.Field(0).Sym)
wbEnabled = typecheck(&wbEnabled, Erv)
wbEnabled = typecheck(wbEnabled, Erv)
pbr := Thearch.Ginscmp(ONE, Types[TUINT8], wbEnabled, Nodintconst(0), -1)
Thearch.Gins(Thearch.Optoas(OAS, Types[Tptr]), &src, &dst)
pjmp := Gbranch(obj.AJMP, nil, 0)
......@@ -1784,7 +1784,7 @@ func bgenx(n, res *Node, wantTrue bool, likely int, to *obj.Prog) {
Genlist(n.Ninit)
if n.Type == nil {
convlit(&n, Types[TBOOL])
n = convlit(n, Types[TBOOL])
if n.Type == nil {
return
}
......@@ -2866,7 +2866,7 @@ func cgen_append(n, res *Node) {
Regfree(&rlen)
fn := syslook("growslice")
substArgTypes(&fn, res.Type.Type, res.Type.Type)
fn = substArgTypes(fn, res.Type.Type, res.Type.Type)
Ginscall(fn, 0)
if Widthptr == 4 && Widthreg == 8 {
......
src/cmd/compile/internal/gc/closure.go
View file @ 34699bc7
......@@ -97,7 +97,7 @@ func typecheckclosure(func_ *Node, top int) {
}
oldfn := Curfn
typecheck(&func_.Func.Ntype, Etype)
func_.Func.Ntype = typecheck(func_.Func.Ntype, Etype)
func_.Type = func_.Func.Ntype.Type
func_.Func.Top = top
......@@ -197,7 +197,7 @@ func makeclosure(func_ *Node) *Node {
if len(xfunc.Nbody.Slice()) == 0 {
Fatalf("empty body - won't generate any code")
}
typecheck(&xfunc, Etop)
xfunc = typecheck(xfunc, Etop)
xfunc.Func.Closure = func_
func_.Func.Closure = xfunc
......@@ -262,7 +262,7 @@ func capturevars(xfunc *Node) {
Warnl(v.Lineno, "%v capturing by %s: %v (addr=%v assign=%v width=%d)", name, how, v.Sym, v.Name.Param.Closure.Addrtaken, v.Name.Param.Closure.Assigned, int32(v.Type.Width))
}
typecheck(&outer, Erv)
outer = typecheck(outer, Erv)
func_.Func.Enter.Append(outer)
}
......@@ -442,7 +442,7 @@ func walkclosure(func_ *Node, init *Nodes) *Node {
clos.Type = func_.Type
typecheck(&clos, Erv)
clos = typecheck(clos, Erv)
// typecheck will insert a PTRLIT node under CONVNOP,
// tag it with escape analysis result.
......@@ -457,7 +457,7 @@ func walkclosure(func_ *Node, init *Nodes) *Node {
delete(prealloc, func_)
}
walkexpr(&clos, init)
clos = walkexpr(clos, init)
return clos
}
......@@ -608,7 +608,7 @@ func makepartialcall(fn *Node, t0 *Type, meth *Sym) *Node {
xfunc.Nbody.Set(body)
typecheck(&xfunc, Etop)
xfunc = typecheck(xfunc, Etop)
sym.Def = xfunc
xtop = append(xtop, xfunc)
Curfn = savecurfn
......@@ -647,7 +647,7 @@ func walkpartialcall(n *Node, init *Nodes) *Node {
clos.Type = n.Type
typecheck(&clos, Erv)
clos = typecheck(clos, Erv)
// typecheck will insert a PTRLIT node under CONVNOP,
// tag it with escape analysis result.
......@@ -662,7 +662,7 @@ func walkpartialcall(n *Node, init *Nodes) *Node {
delete(prealloc, n)
}
walkexpr(&clos, init)
clos = walkexpr(clos, init)
return clos
}
src/cmd/compile/internal/gc/const.go
View file @ 34699bc7
......@@ -91,33 +91,35 @@ func truncfltlit(oldv *Mpflt, t *Type) *Mpflt {
// NegOne returns a Node of type t with value -1.
func NegOne(t *Type) *Node {
n := Nodintconst(-1)
convlit(&n, t)
n = convlit(n, t)
return n
}
// convert n, if literal, to type t.
// implicit conversion.
func convlit(np **Node, t *Type) {
convlit1(np, t, false)
// The result of convlit MUST be assigned back to n, e.g.
// n.Left = convlit(n.Left, t)
func convlit(n *Node, t *Type) *Node {
return convlit1(n, t, false)
}
// convert n, if literal, to type t.
// return a new node if necessary
//(if n is a named constant, can't edit n->type directly).
func convlit1(np **Node, t *Type, explicit bool) {
n := *np
// (if n is a named constant, can't edit n->type directly).
// The result of convlit1 MUST be assigned back to n, e.g.
// n.Left = convlit1(n.Left, t, explicit)
func convlit1(n *Node, t *Type, explicit bool) *Node {
if n == nil || t == nil || n.Type == nil || isideal(t) || n.Type == t {
return
return n
}
if !explicit && !isideal(n.Type) {
return
return n
}
if n.Op == OLITERAL {
nn := Nod(OXXX, nil, nil)
*nn = *n
n = nn
*np = n
}
switch n.Op {
......@@ -131,23 +133,22 @@ func convlit1(np **Node, t *Type, explicit bool) {
}
if n.Type.Etype == TIDEAL {
convlit(&n.Left, t)
convlit(&n.Right, t)
n.Left = convlit(n.Left, t)
n.Right = convlit(n.Right, t)
n.Type = t
}
return
return n
// target is invalid type for a constant? leave alone.
case OLITERAL:
if !okforconst[t.Etype] && n.Type.Etype != TNIL {
defaultlit(&n, nil)
*np = n
return
n = defaultlit(n, nil)
return n
}
case OLSH, ORSH:
convlit1(&n.Left, t, explicit && isideal(n.Left.Type))
n.Left = convlit1(n.Left, t, explicit && isideal(n.Left.Type))
t = n.Left.Type
if t != nil && t.Etype == TIDEAL && n.Val().Ctype() != CTINT {
n.SetVal(toint(n.Val()))
......@@ -158,7 +159,7 @@ func convlit1(np **Node, t *Type, explicit bool) {
}
n.Type = t
return
return n
case OCOMPLEX:
if n.Type.Etype == TIDEAL {
......@@ -173,22 +174,22 @@ func convlit1(np **Node, t *Type, explicit bool) {
case TCOMPLEX128:
n.Type = t
convlit(&n.Left, Types[TFLOAT64])
convlit(&n.Right, Types[TFLOAT64])
n.Left = convlit(n.Left, Types[TFLOAT64])
n.Right = convlit(n.Right, Types[TFLOAT64])
case TCOMPLEX64:
n.Type = t
convlit(&n.Left, Types[TFLOAT32])
convlit(&n.Right, Types[TFLOAT32])
n.Left = convlit(n.Left, Types[TFLOAT32])
n.Right = convlit(n.Right, Types[TFLOAT32])
}
}
return
return n
}
// avoided repeated calculations, errors
if Eqtype(n.Type, t) {
return
return n
}
ct := consttype(n)
......@@ -201,11 +202,11 @@ func convlit1(np **Node, t *Type, explicit bool) {
if et == TINTER {
if ct == CTNIL && n.Type == Types[TNIL] {
n.Type = t
return
return n
}
defaultlit(np, nil)
return
n = defaultlit(n, nil)
return n
}
switch ct {
......@@ -220,7 +221,7 @@ func convlit1(np **Node, t *Type, explicit bool) {
// let normal conversion code handle it
case TSTRING:
return
return n
case TARRAY:
if !Isslice(t) {
......@@ -301,7 +302,7 @@ func convlit1(np **Node, t *Type, explicit bool) {
}
n.Type = t
return
return n
bad:
if n.Diag == 0 {
......@@ -312,9 +313,9 @@ bad:
}
if isideal(n.Type) {
defaultlit(&n, nil)
*np = n
n = defaultlit(n, nil)
}
return n
}
func copyval(v Val) Val {
......@@ -667,7 +668,7 @@ func evconst(n *Node) {
OCONV_ | CTFLT_,
OCONV_ | CTSTR_,
OCONV_ | CTBOOL_:
convlit1(&nl, n.Type, true)
nl = convlit1(nl, n.Type, true)
v = nl.Val()
......@@ -748,12 +749,12 @@ func evconst(n *Node) {
// ideal const mixes with anything but otherwise must match.
default:
if nl.Type.Etype != TIDEAL {
defaultlit(&nr, nl.Type)
nr = defaultlit(nr, nl.Type)
n.Right = nr
}
if nr.Type.Etype != TIDEAL {
defaultlit(&nl, nr.Type)
nl = defaultlit(nl, nr.Type)
n.Left = nl
}
......@@ -764,7 +765,7 @@ func evconst(n *Node) {
// right must be unsigned.
// left can be ideal.
case OLSH, ORSH:
defaultlit(&nr, Types[TUINT])
nr = defaultlit(nr, Types[TUINT])
n.Right = nr
if nr.Type != nil && (Issigned[nr.Type.Etype] || !Isint[nr.Type.Etype]) {
......@@ -1244,17 +1245,17 @@ func idealkind(n *Node) Ctype {
}
}
func defaultlit(np **Node, t *Type) {
n := *np
// The result of defaultlit MUST be assigned back to n, e.g.
// n.Left = defaultlit(n.Left, t)
func defaultlit(n *Node, t *Type) *Node {
if n == nil || !isideal(n.Type) {
return
return n
}
if n.Op == OLITERAL {
nn := Nod(OXXX, nil, nil)
*nn = *n
n = nn
*np = n
}
lno := setlineno(n)
......@@ -1263,8 +1264,8 @@ func defaultlit(np **Node, t *Type) {
switch ctype {
default:
if t != nil {
convlit(np, t)
return
n = convlit(n, t)
return n
}
if n.Val().Ctype() == CTNIL {
......@@ -1280,7 +1281,7 @@ func defaultlit(np **Node, t *Type) {
if n.Val().Ctype() == CTSTR {
t1 := Types[TSTRING]
convlit(np, t1)
n = convlit(n, t1)
break
}
......@@ -1294,7 +1295,7 @@ func defaultlit(np **Node, t *Type) {
if t != nil && t.Etype == TBOOL {
t1 = t
}
convlit(np, t1)
n = convlit(n, t1)
case CTINT:
t1 = Types[TINT]
......@@ -1314,7 +1315,7 @@ func defaultlit(np **Node, t *Type) {
}
lineno = lno
return
return n
num:
// Note: n.Val().Ctype() can be CTxxx (not a constant) here
......@@ -1339,62 +1340,64 @@ num:
if n.Val().Ctype() != CTxxx {
overflow(n.Val(), t1)
}
convlit(np, t1)
n = convlit(n, t1)
lineno = lno
return
return n
}
// defaultlit on both nodes simultaneously;
// if they're both ideal going in they better
// get the same type going out.
// force means must assign concrete (non-ideal) type.
func defaultlit2(lp **Node, rp **Node, force bool) {
l := *lp
r := *rp
// The results of defaultlit2 MUST be assigned back to l and r, e.g.
// n.Left, n.Right = defaultlit2(n.Left, n.Right, force)
func defaultlit2(l *Node, r *Node, force bool) (*Node, *Node) {
if l.Type == nil || r.Type == nil {
return
return l, r
}
if !isideal(l.Type) {
convlit(rp, l.Type)
return
r = convlit(r, l.Type)
return l, r
}
if !isideal(r.Type) {
convlit(lp, r.Type)
return
l = convlit(l, r.Type)
return l, r
}
if !force {
return
return l, r
}
if l.Type.Etype == TBOOL {
convlit(lp, Types[TBOOL])
convlit(rp, Types[TBOOL])
l = convlit(l, Types[TBOOL])
r = convlit(r, Types[TBOOL])
}
lkind := idealkind(l)
rkind := idealkind(r)
if lkind == CTCPLX || rkind == CTCPLX {
convlit(lp, Types[TCOMPLEX128])
convlit(rp, Types[TCOMPLEX128])
return
l = convlit(l, Types[TCOMPLEX128])
r = convlit(r, Types[TCOMPLEX128])
return l, r
}
if lkind == CTFLT || rkind == CTFLT {
convlit(lp, Types[TFLOAT64])
convlit(rp, Types[TFLOAT64])
return
l = convlit(l, Types[TFLOAT64])
r = convlit(r, Types[TFLOAT64])
return l, r
}
if lkind == CTRUNE || rkind == CTRUNE {
convlit(lp, runetype)
convlit(rp, runetype)
return
l = convlit(l, runetype)
r = convlit(r, runetype)
return l, r
}
convlit(lp, Types[TINT])
convlit(rp, Types[TINT])
l = convlit(l, Types[TINT])
r = convlit(r, Types[TINT])
return l, r
}
// strlit returns the value of a literal string Node as a string.
......
src/cmd/compile/internal/gc/dcl.go
View file @ 34699bc7
......@@ -750,7 +750,7 @@ func structfield(n *Node) *Field {
f.Isddd = n.Isddd
if n.Right != nil {
typecheck(&n.Right, Etype)
n.Right = typecheck(n.Right, Etype)
n.Type = n.Right.Type
if n.Left != nil {
n.Left.Type = n.Type
......@@ -904,7 +904,7 @@ func interfacefield(n *Node) *Field {
f.Sym = f.Nname.Sym
}
} else {
typecheck(&n.Right, Etype)
n.Right = typecheck(n.Right, Etype)
n.Type = n.Right.Type
if n.Embedded != 0 {
......
src/cmd/compile/internal/gc/esc.go
View file @ 34699bc7
......@@ -912,7 +912,7 @@ func esc(e *EscState, n *Node, up *Node) {
a = Nod(OADDR, a, nil)
a.Lineno = v.Lineno
e.nodeEscState(a).Escloopdepth = e.loopdepth
typecheck(&a, Erv)
a = typecheck(a, Erv)
}
escassignNilWhy(e, n, a, "captured by a closure")
......
src/cmd/compile/internal/gc/export.go
View file @ 34699bc7
......@@ -226,7 +226,7 @@ func reexportdep(n *Node) {
func dumpexportconst(s *Sym) {
n := s.Def
typecheck(&n, Erv)
n = typecheck(n, Erv)
if n == nil || n.Op != OLITERAL {
Fatalf("dumpexportconst: oconst nil: %v", s)
}
......@@ -243,7 +243,7 @@ func dumpexportconst(s *Sym) {
func dumpexportvar(s *Sym) {
n := s.Def
typecheck(&n, Erv|Ecall)
n = typecheck(n, Erv|Ecall)
if n == nil || n.Type == nil {
Yyerror("variable exported but not defined: %v", s)
return
......@@ -511,7 +511,7 @@ func importimport(s *Sym, path string) {
func importconst(s *Sym, t *Type, n *Node) {
importsym(s, OLITERAL)
convlit(&n, t)
n = convlit(n, t)
if s.Def != nil { // TODO: check if already the same.
return
......
src/cmd/compile/internal/gc/init.go
View file @ 34699bc7
......@@ -177,7 +177,7 @@ func fninit(n []*Node) {
funcbody(fn)
Curfn = fn
typecheck(&fn, Etop)
fn = typecheck(fn, Etop)
typecheckslice(r, Etop)
Curfn = nil
funccompile(fn)
......
src/cmd/compile/internal/gc/inl.go
View file @ 34699bc7
......@@ -269,7 +269,7 @@ func inlcopy(n *Node) *Node {
func inlcalls(fn *Node) {
savefn := Curfn
Curfn = fn
inlnode(&fn)
fn = inlnode(fn)
if fn != Curfn {
Fatalf("inlnode replaced curfn")
}
......@@ -288,11 +288,12 @@ func inlconv2stmt(n *Node) {
}
// Turn an OINLCALL into a single valued expression.
func inlconv2expr(np **Node) {
n := *np
// The result of inlconv2expr MUST be assigned back to n, e.g.
// n.Left = inlconv2expr(n.Left)
func inlconv2expr(n *Node) *Node {
r := n.Rlist.First()
addinit(&r, append(n.Ninit.Slice(), n.Nbody.Slice()...))
*np = r
r = addinit(r, append(n.Ninit.Slice(), n.Nbody.Slice()...))
return r
}
// Turn the rlist (with the return values) of the OINLCALL in
......@@ -306,14 +307,14 @@ func inlconv2list(n *Node) []*Node {
}
s := n.Rlist.Slice()
addinit(&s[0], append(n.Ninit.Slice(), n.Nbody.Slice()...))
s[0] = addinit(s[0], append(n.Ninit.Slice(), n.Nbody.Slice()...))
return s
}
func inlnodelist(l Nodes) {
s := l.Slice()
for i := range s {
inlnode(&s[i])
s[i] = inlnode(s[i])
}
}
......@@ -328,13 +329,13 @@ func inlnodelist(l Nodes) {
// have to edit /this/ n, so you'd have to push that one down as well,
// but then you may as well do it here. so this is cleaner and
// shorter and less complicated.
func inlnode(np **Node) {
if *np == nil {
return
// The result of inlnode MUST be assigned back to n, e.g.
// n.Left = inlnode(n.Left)
func inlnode(n *Node) *Node {
if n == nil {
return n
}
n := *np
switch n.Op {
// inhibit inlining of their argument
case ODEFER, OPROC:
......@@ -348,7 +349,7 @@ func inlnode(np **Node) {
// TODO do them here (or earlier),
// so escape analysis can avoid more heapmoves.
case OCLOSURE:
return
return n
}
lno := setlineno(n)
......@@ -360,17 +361,17 @@ func inlnode(np **Node) {
}
}
inlnode(&n.Left)
n.Left = inlnode(n.Left)
if n.Left != nil && n.Left.Op == OINLCALL {
inlconv2expr(&n.Left)
n.Left = inlconv2expr(n.Left)
}
inlnode(&n.Right)
n.Right = inlnode(n.Right)
if n.Right != nil && n.Right.Op == OINLCALL {
if n.Op == OFOR {
inlconv2stmt(n.Right)
} else {
inlconv2expr(&n.Right)
n.Right = inlconv2expr(n.Right)
}
}
......@@ -401,7 +402,7 @@ func inlnode(np **Node) {
s := n.List.Slice()
for i1, n1 := range s {
if n1.Op == OINLCALL {
inlconv2expr(&s[i1])
s[i1] = inlconv2expr(s[i1])
}
}
}
......@@ -413,7 +414,7 @@ func inlnode(np **Node) {
n.Rlist.Set(inlconv2list(n.Rlist.First()))
n.Op = OAS2
n.Typecheck = 0
typecheck(np, Etop)
n = typecheck(n, Etop)
break
}
fallthrough
......@@ -425,7 +426,7 @@ func inlnode(np **Node) {
if n.Op == OIF {
inlconv2stmt(n1)
} else {
inlconv2expr(&s[i1])
s[i1] = inlconv2expr(s[i1])
}
}
}
......@@ -445,7 +446,7 @@ func inlnode(np **Node) {
case OCALLFUNC, OCALLMETH:
// TODO(marvin): Fix Node.EType type union.
if n.Etype == EType(OPROC) || n.Etype == EType(ODEFER) {
return
return n
}
}
......@@ -455,10 +456,10 @@ func inlnode(np **Node) {
fmt.Printf("%v:call to func %v\n", n.Line(), Nconv(n.Left, FmtSign))
}
if n.Left.Func != nil && len(n.Left.Func.Inl.Slice()) != 0 { // normal case
mkinlcall(np, n.Left, n.Isddd)
n = mkinlcall(n, n.Left, n.Isddd)
} else if n.Left.Op == ONAME && n.Left.Left != nil && n.Left.Left.Op == OTYPE && n.Left.Right != nil && n.Left.Right.Op == ONAME { // methods called as functions
if n.Left.Sym.Def != nil {
mkinlcall(np, n.Left.Sym.Def, n.Isddd)
n = mkinlcall(n, n.Left.Sym.Def, n.Isddd)
}
}
......@@ -476,13 +477,16 @@ func inlnode(np **Node) {
Fatalf("no function definition for [%p] %v\n", n.Left.Type, Tconv(n.Left.Type, FmtSign))
}
mkinlcall(np, n.Left.Type.Nname, n.Isddd)
n = mkinlcall(n, n.Left.Type.Nname, n.Isddd)
}
lineno = lno
return n
}
func mkinlcall(np **Node, fn *Node, isddd bool) {
// The result of mkinlcall MUST be assigned back to n, e.g.
// n.Left = mkinlcall(n.Left, fn, isddd)
func mkinlcall(n *Node, fn *Node, isddd bool) *Node {
save_safemode := safemode
// imported functions may refer to unsafe as long as the
......@@ -492,8 +496,9 @@ func mkinlcall(np **Node, fn *Node, isddd bool) {
if pkg != localpkg && pkg != nil {
safemode = 0
}
mkinlcall1(np, fn, isddd)
n = mkinlcall1(n, fn, isddd)
safemode = save_safemode
return n
}
func tinlvar(t *Field) *Node {
......@@ -504,7 +509,7 @@ func tinlvar(t *Field) *Node {
return t.Nname.Name.Inlvar
}
typecheck(&nblank, Erv|Easgn)
nblank = typecheck(nblank, Erv|Easgn)
return nblank
}
......@@ -514,22 +519,22 @@ var inlgen int
// On return ninit has the parameter assignments, the nbody is the
// inlined function body and list, rlist contain the input, output
// parameters.
func mkinlcall1(np **Node, fn *Node, isddd bool) {
// The result of mkinlcall1 MUST be assigned back to n, e.g.
// n.Left = mkinlcall1(n.Left, fn, isddd)
func mkinlcall1(n *Node, fn *Node, isddd bool) *Node {
// For variadic fn.
if len(fn.Func.Inl.Slice()) == 0 {
return
return n
}
if fn == Curfn || fn.Name.Defn == Curfn {
return
return n
}
if Debug['l'] < 2 {
typecheckinl(fn)
}
n := *np
// Bingo, we have a function node, and it has an inlineable body
if Debug['m'] > 1 {
fmt.Printf("%v: inlining call to %v %v { %v }\n", n.Line(), fn.Sym, Tconv(fn.Type, FmtSharp), Hconv(fn.Func.Inl, FmtSharp))
......@@ -566,7 +571,7 @@ func mkinlcall1(np **Node, fn *Node, isddd bool) {
ln.Name.Inlvar = inlvar(ln)
// Typecheck because inlvar is not necessarily a function parameter.
typecheck(&ln.Name.Inlvar, Erv)
ln.Name.Inlvar = typecheck(ln.Name.Inlvar, Erv)
if ln.Class&^PHEAP != PAUTO {
ninit.Append(Nod(ODCL, ln.Name.Inlvar, nil)) // otherwise gen won't emit the allocations for heapallocs
......@@ -579,7 +584,7 @@ func mkinlcall1(np **Node, fn *Node, isddd bool) {
for _, t := range fn.Type.Results().Fields().Slice() {
if t != nil && t.Nname != nil && !isblank(t.Nname) {
m = inlvar(t.Nname)
typecheck(&m, Erv)
m = typecheck(m, Erv)
t.Nname.Name.Inlvar = m
} else {
// anonymous return values, synthesize names for use in assignment that replaces return
......@@ -607,7 +612,7 @@ func mkinlcall1(np **Node, fn *Node, isddd bool) {
}
as := Nod(OAS, tinlvar(t), n.Left.Left)
if as != nil {
typecheck(&as, Etop)
as = typecheck(as, Etop)
ninit.Append(as)
}
}
......@@ -734,7 +739,7 @@ func mkinlcall1(np **Node, fn *Node, isddd bool) {
}
if as.Rlist.Len() != 0 {
typecheck(&as, Etop)
as = typecheck(as, Etop)
ninit.Append(as)
}
......@@ -754,14 +759,14 @@ func mkinlcall1(np **Node, fn *Node, isddd bool) {
as.Right = Nod(OSLICE, as.Right, Nod(OKEY, nil, nil))
}
typecheck(&as, Etop)
as = typecheck(as, Etop)
ninit.Append(as)
}
// zero the outparams
for _, n := range retvars {
as = Nod(OAS, n, nil)
typecheck(&as, Etop)
as = typecheck(as, Etop)
ninit.Append(as)
}
......@@ -801,7 +806,7 @@ func mkinlcall1(np **Node, fn *Node, isddd bool) {
//dumplist("call body", body);
*np = call
n = call
// transitive inlining
// might be nice to do this before exporting the body,
......@@ -820,8 +825,10 @@ func mkinlcall1(np **Node, fn *Node, isddd bool) {
fn.Func.Inl.Set(body)
if Debug['m'] > 2 {
fmt.Printf("%v: After inlining %v\n\n", n.Line(), Nconv(*np, FmtSign))
fmt.Printf("%v: After inlining %v\n\n", n.Line(), Nconv(n, FmtSign))
}
return n
}
// Every time we expand a function we generate a new set of tmpnames,
......@@ -945,12 +952,12 @@ func (subst *inlsubst) node(n *Node) *Node {
as.List.Append(n)
}
as.Rlist.Set(subst.list(n.List))
typecheck(&as, Etop)
as = typecheck(as, Etop)
m.Ninit.Append(as)
}
typecheckslice(m.Ninit.Slice(), Etop)
typecheck(&m, Etop)
m = typecheck(m, Etop)
// dump("Return after substitution", m);
return m
......
src/cmd/compile/internal/gc/main.go
View file @ 34699bc7
......@@ -371,7 +371,7 @@ func Main() {
// Don't use range--typecheck can add closures to xtop.
for i := 0; i < len(xtop); i++ {
if xtop[i].Op != ODCL && xtop[i].Op != OAS && xtop[i].Op != OAS2 {
typecheck(&xtop[i], Etop)
xtop[i] = typecheck(xtop[i], Etop)
}
}
......@@ -381,7 +381,7 @@ func Main() {
// Don't use range--typecheck can add closures to xtop.
for i := 0; i < len(xtop); i++ {
if xtop[i].Op == ODCL || xtop[i].Op == OAS || xtop[i].Op == OAS2 {
typecheck(&xtop[i], Etop)
xtop[i] = typecheck(xtop[i], Etop)
}
}
resumecheckwidth()
......@@ -488,7 +488,7 @@ func Main() {
// Phase 9: Check external declarations.
for i, n := range externdcl {
if n.Op == ONAME {
typecheck(&externdcl[i], Erv)
externdcl[i] = typecheck(externdcl[i], Erv)
}
}
......
src/cmd/compile/internal/gc/order.go
View file @ 34699bc7
......@@ -63,7 +63,7 @@ func ordertemp(t *Type, order *Order, clear bool) *Node {
var_ := temp(t)
if clear {
a := Nod(OAS, var_, nil)
typecheck(&a, Etop)
a = typecheck(a, Etop)
order.out = append(order.out, a)
}
......@@ -86,7 +86,7 @@ func ordertemp(t *Type, order *Order, clear bool) *Node {
func ordercopyexpr(n *Node, t *Type, order *Order, clear int) *Node {
var_ := ordertemp(t, order, clear != 0)
a := Nod(OAS, var_, n)
typecheck(&a, Etop)
a = typecheck(a, Etop)
order.out = append(order.out, a)
return var_
}
......@@ -111,7 +111,7 @@ func ordercheapexpr(n *Node, order *Order) *Node {
*a = *n
a.Orig = a
a.Left = l
typecheck(&a, Erv)
a = typecheck(a, Erv)
return a
}
......@@ -139,7 +139,7 @@ func ordersafeexpr(n *Node, order *Order) *Node {
*a = *n
a.Orig = a
a.Left = l
typecheck(&a, Erv)
a = typecheck(a, Erv)
return a
case ODOTPTR, OIND:
......@@ -151,7 +151,7 @@ func ordersafeexpr(n *Node, order *Order) *Node {
*a = *n
a.Orig = a
a.Left = l
typecheck(&a, Erv)
a = typecheck(a, Erv)
return a
case OINDEX, OINDEXMAP:
......@@ -170,7 +170,7 @@ func ordersafeexpr(n *Node, order *Order) *Node {
a.Orig = a
a.Left = l
a.Right = r
typecheck(&a, Erv)
a = typecheck(a, Erv)
return a
}
......@@ -199,12 +199,11 @@ func isaddrokay(n *Node) bool {
// Orderaddrtemp ensures that *np is okay to pass by address to runtime routines.
// If the original argument *np is not okay, orderaddrtemp creates a tmp, emits
// tmp = *np, and then sets *np to the tmp variable.
func orderaddrtemp(np **Node, order *Order) {
n := *np
func orderaddrtemp(n *Node, order *Order) *Node {
if isaddrokay(n) {
return
return n
}
*np = ordercopyexpr(n, n.Type, order, 0)
return ordercopyexpr(n, n.Type, order, 0)
}
type ordermarker int
......@@ -232,11 +231,11 @@ func cleantempnopop(mark ordermarker, order *Order, out *[]*Node) {
n.Name.Keepalive = false
n.Addrtaken = true // ensure SSA keeps the n variable
kill = Nod(OVARLIVE, n, nil)
typecheck(&kill, Etop)
kill = typecheck(kill, Etop)
*out = append(*out, kill)
}
kill = Nod(OVARKILL, n, nil)
typecheck(&kill, Etop)
kill = typecheck(kill, Etop)
*out = append(*out, kill)
}
}
......@@ -277,28 +276,29 @@ func orderblockNodes(n *Nodes) {
// Orderexprinplace orders the side effects in *np and
// leaves them as the init list of the final *np.
func orderexprinplace(np **Node, outer *Order) {
n := *np
// The result of orderexprinplace MUST be assigned back to n, e.g.
// n.Left = orderexprinplace(n.Left, outer)
func orderexprinplace(n *Node, outer *Order) *Node {
var order Order
orderexpr(&n, &order, nil)
addinit(&n, order.out)
n = orderexpr(n, &order, nil)
n = addinit(n, order.out)
// insert new temporaries from order
// at head of outer list.
outer.temp = append(outer.temp, order.temp...)
*np = n
return n
}
// Orderstmtinplace orders the side effects of the single statement *np
// and replaces it with the resulting statement list.
func orderstmtinplace(np **Node) {
n := *np
// The result of orderstmtinplace MUST be assigned back to n, e.g.
// n.Left = orderstmtinplace(n.Left)
func orderstmtinplace(n *Node) *Node {
var order Order
mark := marktemp(&order)
orderstmt(n, &order)
cleantemp(mark, &order)
*np = liststmt(order.out)
return liststmt(order.out)
}
// Orderinit moves n's init list to order->out.
......@@ -347,7 +347,7 @@ func copyret(n *Node, order *Order) []*Node {
as := Nod(OAS2, nil, nil)
as.List.Set(l1)
as.Rlist.Set1(n)
typecheck(&as, Etop)
as = typecheck(as, Etop)
orderstmt(as, order)
return l2
......@@ -366,8 +366,8 @@ func ordercallargs(l *Nodes, order *Order) {
// Ordercall orders the call expression n.
// n->op is OCALLMETH/OCALLFUNC/OCALLINTER or a builtin like OCOPY.
func ordercall(n *Node, order *Order) {
orderexpr(&n.Left, order, nil)
orderexpr(&n.Right, order, nil) // ODDDARG temp
n.Left = orderexpr(n.Left, order, nil)
n.Right = orderexpr(n.Right, order, nil) // ODDDARG temp
ordercallargs(&n.List, order)
if n.Op == OCALLFUNC {
......@@ -434,7 +434,7 @@ func ordermapassign(n *Node, order *Order) {
m := n.Left
n.Left = ordertemp(m.Type, order, false)
a := Nod(OAS, m, n.Left)
typecheck(&a, Etop)
a = typecheck(a, Etop)
order.out = append(order.out, a)
}
......@@ -453,14 +453,14 @@ func ordermapassign(n *Node, order *Order) {
}
n.List.SetIndex(i1, ordertemp(m.Type, order, false))
a = Nod(OAS, m, n.List.Index(i1))
typecheck(&a, Etop)
a = typecheck(a, Etop)
post = append(post, a)
} else if instrumenting && n.Op == OAS2FUNC && !isblank(n.List.Index(i1)) {
m = n.List.Index(i1)
t := ordertemp(m.Type, order, false)
n.List.SetIndex(i1, t)
a = Nod(OAS, m, t)
typecheck(&a, Etop)
a = typecheck(a, Etop)
post = append(post, a)
}
}
......@@ -491,8 +491,8 @@ func orderstmt(n *Node, order *Order) {
case OAS:
t := marktemp(order)
orderexpr(&n.Left, order, nil)
orderexpr(&n.Right, order, n.Left)
n.Left = orderexpr(n.Left, order, nil)
n.Right = orderexpr(n.Right, order, n.Left)
ordermapassign(n, order)
cleantemp(t, order)
......@@ -504,8 +504,8 @@ func orderstmt(n *Node, order *Order) {
ORECOVER,
ORECV:
t := marktemp(order)
orderexpr(&n.Left, order, nil)
orderexpr(&n.Right, order, nil)
n.Left = orderexpr(n.Left, order, nil)
n.Right = orderexpr(n.Right, order, nil)
orderexprlist(n.List, order)
orderexprlist(n.Rlist, order)
switch n.Op {
......@@ -524,7 +524,7 @@ func orderstmt(n *Node, order *Order) {
// a map index expression.
t := marktemp(order)
orderexpr(&n.Left, order, nil)
n.Left = orderexpr(n.Left, order, nil)
n.Left = ordersafeexpr(n.Left, order)
tmp1 := treecopy(n.Left, 0)
if tmp1.Op == OINDEXMAP {
......@@ -533,8 +533,8 @@ func orderstmt(n *Node, order *Order) {
tmp1 = ordercopyexpr(tmp1, n.Left.Type, order, 0)
// TODO(marvin): Fix Node.EType type union.
n.Right = Nod(Op(n.Etype), tmp1, n.Right)
typecheck(&n.Right, Erv)
orderexpr(&n.Right, order, nil)
n.Right = typecheck(n.Right, Erv)
n.Right = orderexpr(n.Right, order, nil)
n.Etype = 0
n.Op = OAS
ordermapassign(n, order)
......@@ -547,14 +547,14 @@ func orderstmt(n *Node, order *Order) {
orderexprlist(n.List, order)
r := n.Rlist.First()
orderexpr(&r.Left, order, nil)
orderexpr(&r.Right, order, nil)
r.Left = orderexpr(r.Left, order, nil)
r.Right = orderexpr(r.Right, order, nil)
// See case OINDEXMAP below.
if r.Right.Op == OARRAYBYTESTR {
r.Right.Op = OARRAYBYTESTRTMP
}
orderaddrtemp(&r.Right, order)
r.Right = orderaddrtemp(r.Right, order)
ordermapassign(n, order)
cleantemp(t, order)
......@@ -574,7 +574,7 @@ func orderstmt(n *Node, order *Order) {
t := marktemp(order)
orderexprlist(n.List, order)
orderexpr(&n.Rlist.First().Left, order, nil) // i in i.(T)
n.Rlist.First().Left = orderexpr(n.Rlist.First().Left, order, nil) // i in i.(T)
if isblank(n.List.First()) {
order.out = append(order.out, n)
} else {
......@@ -582,7 +582,7 @@ func orderstmt(n *Node, order *Order) {
tmp1 := ordertemp(typ, order, haspointers(typ))
order.out = append(order.out, n)
r := Nod(OAS, n.List.First(), tmp1)
typecheck(&r, Etop)
r = typecheck(r, Etop)
ordermapassign(r, order)
n.List.Set([]*Node{tmp1, n.List.Second()})
}
......@@ -595,7 +595,7 @@ func orderstmt(n *Node, order *Order) {
t := marktemp(order)
orderexprlist(n.List, order)
orderexpr(&n.Rlist.First().Left, order, nil) // arg to recv
n.Rlist.First().Left = orderexpr(n.Rlist.First().Left, order, nil) // arg to recv
ch := n.Rlist.First().Left.Type
tmp1 := ordertemp(ch.Type, order, haspointers(ch.Type))
var tmp2 *Node
......@@ -606,10 +606,10 @@ func orderstmt(n *Node, order *Order) {
}
order.out = append(order.out, n)
r := Nod(OAS, n.List.First(), tmp1)
typecheck(&r, Etop)
r = typecheck(r, Etop)
ordermapassign(r, order)
r = Nod(OAS, n.List.Second(), tmp2)
typecheck(&r, Etop)
r = typecheck(r, Etop)
ordermapassign(r, order)
n.List.Set([]*Node{tmp1, tmp2})
cleantemp(t, order)
......@@ -664,9 +664,9 @@ func orderstmt(n *Node, order *Order) {
case ODELETE:
t := marktemp(order)
orderexpr(n.List.Addr(0), order, nil)
orderexpr(n.List.Addr(1), order, nil)
orderaddrtemp(n.List.Addr(1), order) // map key
n.List.SetIndex(0, orderexpr(n.List.Index(0), order, nil))
n.List.SetIndex(1, orderexpr(n.List.Index(1), order, nil))
n.List.SetIndex(1, orderaddrtemp(n.List.Index(1), order)) // map key
order.out = append(order.out, n)
cleantemp(t, order)
......@@ -675,12 +675,12 @@ func orderstmt(n *Node, order *Order) {
case OFOR:
t := marktemp(order)
orderexprinplace(&n.Left, order)
n.Left = orderexprinplace(n.Left, order)
var l []*Node
cleantempnopop(t, order, &l)
n.Nbody.Set(append(l, n.Nbody.Slice()...))
orderblockNodes(&n.Nbody)
orderstmtinplace(&n.Right)
n.Right = orderstmtinplace(n.Right)
order.out = append(order.out, n)
cleantemp(t, order)
......@@ -689,7 +689,7 @@ func orderstmt(n *Node, order *Order) {
case OIF:
t := marktemp(order)
orderexprinplace(&n.Left, order)
n.Left = orderexprinplace(n.Left, order)
var l []*Node
cleantempnopop(t, order, &l)
n.Nbody.Set(append(l, n.Nbody.Slice()...))
......@@ -706,9 +706,9 @@ func orderstmt(n *Node, order *Order) {
case OPANIC:
t := marktemp(order)
orderexpr(&n.Left, order, nil)
n.Left = orderexpr(n.Left, order, nil)
if !Isinter(n.Left.Type) {
orderaddrtemp(&n.Left, order)
n.Left = orderaddrtemp(n.Left, order)
}
order.out = append(order.out, n)
cleantemp(t, order)
......@@ -724,7 +724,7 @@ func orderstmt(n *Node, order *Order) {
case ORANGE:
t := marktemp(order)
orderexpr(&n.Right, order, nil)
n.Right = orderexpr(n.Right, order, nil)
switch n.Type.Etype {
default:
Fatalf("orderstmt range %v", n.Type)
......@@ -751,7 +751,7 @@ func orderstmt(n *Node, order *Order) {
if r.Type.Etype == TSTRING && r.Type != Types[TSTRING] {
r = Nod(OCONV, r, nil)
r.Type = Types[TSTRING]
typecheck(&r, Erv)
r = typecheck(r, Erv)
}
n.Right = ordercopyexpr(r, r.Type, order, 0)
......@@ -768,7 +768,7 @@ func orderstmt(n *Node, order *Order) {
prealloc[n] = ordertemp(Types[TUINT8], order, true)
}
for i := range n.List.Slice() {
orderexprinplace(n.List.Addr(i), order)
n.List.SetIndex(i, orderexprinplace(n.List.Index(i), order))
}
orderblockNodes(&n.Nbody)
order.out = append(order.out, n)
......@@ -839,7 +839,7 @@ func orderstmt(n *Node, order *Order) {
// r->left is x, r->ntest is ok, r->right is ORECV, r->right->left is c.
// r->left == N means 'case <-c'.
// c is always evaluated; x and ok are only evaluated when assigned.
orderexpr(&r.Right.Left, order, nil)
r.Right.Left = orderexpr(r.Right.Left, order, nil)
if r.Right.Left.Op != ONAME {
r.Right.Left = ordercopyexpr(r.Right.Left, r.Right.Left.Type, order, 0)
......@@ -862,13 +862,13 @@ func orderstmt(n *Node, order *Order) {
if r.Colas {
tmp2 = Nod(ODCL, tmp1, nil)
typecheck(&tmp2, Etop)
tmp2 = typecheck(tmp2, Etop)
n2.Ninit.Append(tmp2)
}
r.Left = ordertemp(r.Right.Left.Type.Type, order, haspointers(r.Right.Left.Type.Type))
tmp2 = Nod(OAS, tmp1, r.Left)
typecheck(&tmp2, Etop)
tmp2 = typecheck(tmp2, Etop)
n2.Ninit.Append(tmp2)
}
......@@ -879,13 +879,13 @@ func orderstmt(n *Node, order *Order) {
tmp1 = r.List.First()
if r.Colas {
tmp2 = Nod(ODCL, tmp1, nil)
typecheck(&tmp2, Etop)
tmp2 = typecheck(tmp2, Etop)
n2.Ninit.Append(tmp2)
}
r.List.Set1(ordertemp(tmp1.Type, order, false))
tmp2 = Nod(OAS, tmp1, r.List.First())
typecheck(&tmp2, Etop)
tmp2 = typecheck(tmp2, Etop)
n2.Ninit.Append(tmp2)
}
n2.Ninit.Set(orderblock(n2.Ninit))
......@@ -898,12 +898,12 @@ func orderstmt(n *Node, order *Order) {
// case c <- x
// r->left is c, r->right is x, both are always evaluated.
orderexpr(&r.Left, order, nil)
r.Left = orderexpr(r.Left, order, nil)
if !istemp(r.Left) {
r.Left = ordercopyexpr(r.Left, r.Left.Type, order, 0)
}
orderexpr(&r.Right, order, nil)
r.Right = orderexpr(r.Right, order, nil)
if !istemp(r.Right) {
r.Right = ordercopyexpr(r.Right, r.Right.Type, order, 0)
}
......@@ -929,9 +929,9 @@ func orderstmt(n *Node, order *Order) {
case OSEND:
t := marktemp(order)
orderexpr(&n.Left, order, nil)
orderexpr(&n.Right, order, nil)
orderaddrtemp(&n.Right, order)
n.Left = orderexpr(n.Left, order, nil)
n.Right = orderexpr(n.Right, order, nil)
n.Right = orderaddrtemp(n.Right, order)
order.out = append(order.out, n)
cleantemp(t, order)
......@@ -945,7 +945,7 @@ func orderstmt(n *Node, order *Order) {
case OSWITCH:
t := marktemp(order)
orderexpr(&n.Left, order, nil)
n.Left = orderexpr(n.Left, order, nil)
for _, n4 := range n.List.Slice() {
if n4.Op != OXCASE {
Fatalf("order switch case %v", Oconv(n4.Op, 0))
......@@ -965,7 +965,7 @@ func orderstmt(n *Node, order *Order) {
func orderexprlist(l Nodes, order *Order) {
s := l.Slice()
for i := range s {
orderexpr(&s[i], order, nil)
s[i] = orderexpr(s[i], order, nil)
}
}
......@@ -974,7 +974,7 @@ func orderexprlist(l Nodes, order *Order) {
func orderexprlistinplace(l Nodes, order *Order) {
s := l.Slice()
for i := range s {
orderexprinplace(&s[i], order)
s[i] = orderexprinplace(s[i], order)
}
}
......@@ -986,10 +986,11 @@ var prealloc = map[*Node]*Node{}
// If this is part of an assignment lhs = *np, lhs is given.
// Otherwise lhs == nil. (When lhs != nil it may be possible
// to avoid copying the result of the expression to a temporary.)
func orderexpr(np **Node, order *Order, lhs *Node) {
n := *np
// The result of orderexpr MUST be assigned back to n, e.g.
// n.Left = orderexpr(n.Left, order, lhs)
func orderexpr(n *Node, order *Order, lhs *Node) *Node {
if n == nil {
return
return n
}
lno := setlineno(n)
......@@ -997,8 +998,8 @@ func orderexpr(np **Node, order *Order, lhs *Node) {
switch n.Op {
default:
orderexpr(&n.Left, order, nil)
orderexpr(&n.Right, order, nil)
n.Left = orderexpr(n.Left, order, nil)
n.Right = orderexpr(n.Right, order, nil)
orderexprlist(n.List, order)
orderexprlist(n.Rlist, order)
......@@ -1039,8 +1040,8 @@ func orderexpr(np **Node, order *Order, lhs *Node) {
}
case OCMPSTR:
orderexpr(&n.Left, order, nil)
orderexpr(&n.Right, order, nil)
n.Left = orderexpr(n.Left, order, nil)
n.Right = orderexpr(n.Right, order, nil)
// Mark string(byteSlice) arguments to reuse byteSlice backing
// buffer during conversion. String comparison does not
......@@ -1054,9 +1055,9 @@ func orderexpr(np **Node, order *Order, lhs *Node) {
// key must be addressable
case OINDEXMAP:
orderexpr(&n.Left, order, nil)
n.Left = orderexpr(n.Left, order, nil)
orderexpr(&n.Right, order, nil)
n.Right = orderexpr(n.Right, order, nil)
// For x = m[string(k)] where k is []byte, the allocation of
// backing bytes for the string can be avoided by reusing
......@@ -1072,7 +1073,7 @@ func orderexpr(np **Node, order *Order, lhs *Node) {
n.Right.Op = OARRAYBYTESTRTMP
}
orderaddrtemp(&n.Right, order)
n.Right = orderaddrtemp(n.Right, order)
if n.Etype == 0 {
// use of value (not being assigned);
// make copy in temporary.
......@@ -1082,15 +1083,15 @@ func orderexpr(np **Node, order *Order, lhs *Node) {
// concrete type (not interface) argument must be addressable
// temporary to pass to runtime.
case OCONVIFACE:
orderexpr(&n.Left, order, nil)
n.Left = orderexpr(n.Left, order, nil)
if !Isinter(n.Left.Type) {
orderaddrtemp(&n.Left, order)
n.Left = orderaddrtemp(n.Left, order)
}
case OANDAND, OOROR:
mark := marktemp(order)
orderexpr(&n.Left, order, nil)
n.Left = orderexpr(n.Left, order, nil)
// Clean temporaries from first branch at beginning of second.
// Leave them on the stack so that they can be killed in the outer
......@@ -1099,7 +1100,7 @@ func orderexpr(np **Node, order *Order, lhs *Node) {
cleantempnopop(mark, order, &s)
n.Right.Ninit.Set(append(s, n.Right.Ninit.Slice()...))
orderexprinplace(&n.Right, order)
n.Right = orderexprinplace(n.Right, order)
case OCALLFUNC,
OCALLINTER,
......@@ -1130,22 +1131,22 @@ func orderexpr(np **Node, order *Order, lhs *Node) {
}
case OSLICE, OSLICEARR, OSLICESTR:
orderexpr(&n.Left, order, nil)
orderexpr(&n.Right.Left, order, nil)
n.Left = orderexpr(n.Left, order, nil)
n.Right.Left = orderexpr(n.Right.Left, order, nil)
n.Right.Left = ordercheapexpr(n.Right.Left, order)
orderexpr(&n.Right.Right, order, nil)
n.Right.Right = orderexpr(n.Right.Right, order, nil)
n.Right.Right = ordercheapexpr(n.Right.Right, order)
if lhs == nil || lhs.Op != ONAME && !samesafeexpr(lhs, n.Left) {
n = ordercopyexpr(n, n.Type, order, 0)
}
case OSLICE3, OSLICE3ARR:
orderexpr(&n.Left, order, nil)
orderexpr(&n.Right.Left, order, nil)
n.Left = orderexpr(n.Left, order, nil)
n.Right.Left = orderexpr(n.Right.Left, order, nil)
n.Right.Left = ordercheapexpr(n.Right.Left, order)
orderexpr(&n.Right.Right.Left, order, nil)
n.Right.Right.Left = orderexpr(n.Right.Right.Left, order, nil)
n.Right.Right.Left = ordercheapexpr(n.Right.Right.Left, order)
orderexpr(&n.Right.Right.Right, order, nil)
n.Right.Right.Right = orderexpr(n.Right.Right.Right, order, nil)
n.Right.Right.Right = ordercheapexpr(n.Right.Right.Right, order)
if lhs == nil || lhs.Op != ONAME && !samesafeexpr(lhs, n.Left) {
n = ordercopyexpr(n, n.Type, order, 0)
......@@ -1157,8 +1158,8 @@ func orderexpr(np **Node, order *Order, lhs *Node) {
}
case OARRAYLIT, OCALLPART:
orderexpr(&n.Left, order, nil)
orderexpr(&n.Right, order, nil)
n.Left = orderexpr(n.Left, order, nil)
n.Right = orderexpr(n.Right, order, nil)
orderexprlist(n.List, order)
orderexprlist(n.Rlist, order)
if n.Noescape {
......@@ -1175,7 +1176,7 @@ func orderexpr(np **Node, order *Order, lhs *Node) {
}
case ODOTTYPE, ODOTTYPE2:
orderexpr(&n.Left, order, nil)
n.Left = orderexpr(n.Left, order, nil)
// TODO(rsc): The Isfat is for consistency with componentgen and walkexpr.
// It needs to be removed in all three places.
// That would allow inlining x.(struct{*int}) the same as x.(*int).
......@@ -1184,22 +1185,21 @@ func orderexpr(np **Node, order *Order, lhs *Node) {
}
case ORECV:
orderexpr(&n.Left, order, nil)
n.Left = orderexpr(n.Left, order, nil)
n = ordercopyexpr(n, n.Type, order, 1)
case OEQ, ONE:
orderexpr(&n.Left, order, nil)
orderexpr(&n.Right, order, nil)
n.Left = orderexpr(n.Left, order, nil)
n.Right = orderexpr(n.Right, order, nil)
t := n.Left.Type
if t.Etype == TSTRUCT || Isfixedarray(t) {
// for complex comparisons, we need both args to be
// addressable so we can pass them to the runtime.
orderaddrtemp(&n.Left, order)
orderaddrtemp(&n.Right, order)
n.Left = orderaddrtemp(n.Left, order)
n.Right = orderaddrtemp(n.Right, order)
}
}
lineno = lno
*np = n
return n
}
src/cmd/compile/internal/gc/pgen.go
View file @ 34699bc7
......@@ -380,7 +380,7 @@ func compile(fn *Node) {
for _, t := range Curfn.Type.Results().Fields().Slice() {
if t.Nname != nil {
n := Nod(OAS, t.Nname, nil)
typecheck(&n, Etop)
n = typecheck(n, Etop)
Curfn.Nbody.Set(append([]*Node{n}, Curfn.Nbody.Slice()...))
}
}
......
src/cmd/compile/internal/gc/racewalk.go
View file @ 34699bc7
......@@ -228,7 +228,7 @@ func instrumentnode(np **Node, init *Nodes, wr int, skip int) {
n1 := Nod(OCONVNOP, n.Left, nil)
n1.Type = Ptrto(Types[TUINT8])
n1 = Nod(OIND, n1, nil)
typecheck(&n1, Erv)
n1 = typecheck(n1, Erv)
callinstr(&n1, init, 0, skip)
}
......@@ -581,12 +581,12 @@ func detachexpr(n *Node, init *Nodes) *Node {
addr := Nod(OADDR, n, nil)
l := temp(Ptrto(n.Type))
as := Nod(OAS, l, addr)
typecheck(&as, Etop)
walkexpr(&as, init)
as = typecheck(as, Etop)
as = walkexpr(as, init)
init.Append(as)
ind := Nod(OIND, l, nil)
typecheck(&ind, Erv)
walkexpr(&ind, init)
ind = typecheck(ind, Erv)
ind = walkexpr(ind, init)
return ind
}
......
src/cmd/compile/internal/gc/range.go
View file @ 34699bc7
......@@ -24,7 +24,7 @@ func typecheckrange(n *Node) {
// 3. typecheck body.
// 4. decldepth--.
typecheck(&n.Right, Erv)
n.Right = typecheck(n.Right, Erv)
t := n.Right.Type
if t == nil {
......@@ -34,7 +34,7 @@ func typecheckrange(n *Node) {
ls = n.List.Slice()
for i1, n1 := range ls {
if n1.Name == nil || n1.Name.Defn != n {
typecheck(&ls[i1], Erv|Easgn)
ls[i1] = typecheck(ls[i1], Erv|Easgn)
}
}
......@@ -122,7 +122,7 @@ out:
ls = n.List.Slice()
for i1, n1 := range ls {
if n1.Typecheck == 0 {
typecheck(&ls[i1], Erv|Easgn)
ls[i1] = typecheck(ls[i1], Erv|Easgn)
}
}
......@@ -213,7 +213,7 @@ func walkrange(n *Node) {
tmp.Right.Type = Types[Tptr]
tmp.Right.Typecheck = 1
a = Nod(OAS, hp, tmp)
typecheck(&a, Etop)
a = typecheck(a, Etop)
n.Right.Ninit.Set1(a)
}
......@@ -231,12 +231,12 @@ func walkrange(n *Node) {
fn := syslook("mapiterinit")
substArgTypes(&fn, t.Key(), t.Type, th)
fn = substArgTypes(fn, t.Key(), t.Type, th)
init = append(init, mkcall1(fn, nil, nil, typename(t), ha, Nod(OADDR, hit, nil)))
n.Left = Nod(ONE, NodSym(ODOT, hit, keysym), nodnil())
fn = syslook("mapiternext")
substArgTypes(&fn, th)
fn = substArgTypes(fn, th)
n.Right = mkcall1(fn, nil, nil, Nod(OADDR, hit, nil))
key := NodSym(ODOT, hit, keysym)
......@@ -316,11 +316,11 @@ func walkrange(n *Node) {
typecheckslice(init, Etop)
n.Ninit.Append(init...)
typecheckslice(n.Left.Ninit.Slice(), Etop)
typecheck(&n.Left, Erv)
typecheck(&n.Right, Etop)
n.Left = typecheck(n.Left, Erv)
n.Right = typecheck(n.Right, Etop)
typecheckslice(body, Etop)
n.Nbody.Set(append(body, n.Nbody.Slice()...))
walkstmt(&n)
n = walkstmt(n)
lineno = lno
}
......@@ -398,8 +398,8 @@ func memclrrange(n, v1, v2, a *Node) bool {
n.Nbody.Append(v1)
typecheck(&n.Left, Erv)
n.Left = typecheck(n.Left, Erv)
typecheckslice(n.Nbody.Slice(), Etop)
walkstmt(&n)
n = walkstmt(n)
return true
}
src/cmd/compile/internal/gc/select.go
View file @ 34699bc7
......@@ -31,7 +31,8 @@ func typecheckselect(sel *Node) {
} else if ncase.List.Len() > 1 {
Yyerror("select cases cannot be lists")
} else {
n = typecheck(ncase.List.Addr(0), Etop)
ncase.List.SetIndex(0, typecheck(ncase.List.Index(0), Etop))
n = ncase.List.Index(0)
ncase.Left = n
ncase.List.Set(nil)
setlineno(n)
......@@ -137,7 +138,7 @@ func walkselect(sel *Node) {
}
if n.Left == nil {
typecheck(&nblank, Erv|Easgn)
nblank = typecheck(nblank, Erv|Easgn)
n.Left = nblank
}
......@@ -147,7 +148,7 @@ func walkselect(sel *Node) {
n.Right = nil
n.Left = nil
n.Typecheck = 0
typecheck(&n, Etop)
n = typecheck(n, Etop)
}
// if ch == nil { block() }; n;
......@@ -158,7 +159,7 @@ func walkselect(sel *Node) {
ln.Set(l)
a.Nbody.Set1(mkcall("block", nil, &ln))
l = ln.Slice()
typecheck(&a, Etop)
a = typecheck(a, Etop)
l = append(l, a)
l = append(l, n)
}
......@@ -179,7 +180,7 @@ func walkselect(sel *Node) {
switch n.Op {
case OSEND:
n.Right = Nod(OADDR, n.Right, nil)
typecheck(&n.Right, Erv)
n.Right = typecheck(n.Right, Erv)
case OSELRECV, OSELRECV2:
if n.Op == OSELRECV2 && n.List.Len() == 0 {
......@@ -187,14 +188,14 @@ func walkselect(sel *Node) {
}
if n.Op == OSELRECV2 {
n.List.SetIndex(0, Nod(OADDR, n.List.First(), nil))
typecheck(n.List.Addr(0), Erv)
n.List.SetIndex(0, typecheck(n.List.Index(0), Erv))
}
if n.Left == nil {
n.Left = nodnil()
} else {
n.Left = Nod(OADDR, n.Left, nil)
typecheck(&n.Left, Erv)
n.Left = typecheck(n.Left, Erv)
}
}
}
......@@ -242,7 +243,7 @@ func walkselect(sel *Node) {
r.Left = mkcall1(chanfn("selectnbrecv2", 2, ch.Type), Types[TBOOL], &r.Ninit, typename(ch.Type), n.Left, n.List.First(), ch)
}
typecheck(&r.Left, Erv)
r.Left = typecheck(r.Left, Erv)
r.Nbody.Set(cas.Nbody.Slice())
r.Rlist.Set(append(dflt.Ninit.Slice(), dflt.Nbody.Slice()...))
sel.Nbody.Set1(r)
......@@ -257,11 +258,11 @@ func walkselect(sel *Node) {
selv = temp(selecttype(int32(sel.Xoffset)))
r = Nod(OAS, selv, nil)
typecheck(&r, Etop)
r = typecheck(r, Etop)
init = append(init, r)
var_ = conv(conv(Nod(OADDR, selv, nil), Types[TUNSAFEPTR]), Ptrto(Types[TUINT8]))
r = mkcall("newselect", nil, nil, var_, Nodintconst(selv.Type.Width), Nodintconst(sel.Xoffset))
typecheck(&r, Etop)
r = typecheck(r, Etop)
init = append(init, r)
// register cases
for _, cas := range sel.List.Slice() {
......@@ -330,7 +331,7 @@ func selecttype(size int32) *Type {
scase.List.Append(Nod(ODCLFIELD, newname(Lookup("so")), typenod(Types[TUINT16])))
scase.List.Append(Nod(ODCLFIELD, newname(Lookup("receivedp")), typenod(Ptrto(Types[TUINT8]))))
scase.List.Append(Nod(ODCLFIELD, newname(Lookup("releasetime")), typenod(Types[TUINT64])))
typecheck(&scase, Etype)
scase = typecheck(scase, Etype)
scase.Type.Noalg = true
scase.Type.Local = true
......@@ -345,7 +346,7 @@ func selecttype(size int32) *Type {
sel.List.Append(Nod(ODCLFIELD, newname(Lookup("lockorderarr")), arr))
arr = Nod(OTARRAY, Nodintconst(int64(size)), typenod(Types[TUINT16]))
sel.List.Append(Nod(ODCLFIELD, newname(Lookup("pollorderarr")), arr))
typecheck(&sel, Etype)
sel = typecheck(sel, Etype)
sel.Type.Noalg = true
sel.Type.Local = true
......
src/cmd/compile/internal/gc/sinit.go
View file @ 34699bc7
......@@ -520,8 +520,8 @@ func (n *Node) isSimpleName() bool {
func litas(l *Node, r *Node, init *Nodes) {
a := Nod(OAS, l, r)
typecheck(&a, Etop)
walkexpr(&a, init)
a = typecheck(a, Etop)
a = walkexpr(a, init)
init.Append(a)
}
......@@ -608,16 +608,16 @@ func structlit(ctxt int, pass int, n *Node, var_ *Node, init *Nodes) {
a = NodSym(ODOT, var_, index.Sym)
a = Nod(OAS, a, value)
typecheck(&a, Etop)
a = typecheck(a, Etop)
if pass == 1 {
walkexpr(&a, init) // add any assignments in r to top
a = walkexpr(a, init) // add any assignments in r to top
if a.Op != OAS {
Fatalf("structlit: not as")
}
a.Dodata = 2
} else {
orderstmtinplace(&a)
walkstmt(&a)
a = orderstmtinplace(a)
a = walkstmt(a)
}
init.Append(a)
......@@ -672,16 +672,16 @@ func arraylit(ctxt int, pass int, n *Node, var_ *Node, init *Nodes) {
a = Nod(OINDEX, var_, index)
a = Nod(OAS, a, value)
typecheck(&a, Etop)
a = typecheck(a, Etop)
if pass == 1 {
walkexpr(&a, init)
a = walkexpr(a, init)
if a.Op != OAS {
Fatalf("arraylit: not as")
}
a.Dodata = 2
} else {
orderstmtinplace(&a)
walkstmt(&a)
a = orderstmtinplace(a)
a = walkstmt(a)
}
init.Append(a)
......@@ -708,7 +708,7 @@ func slicelit(ctxt int, n *Node, var_ *Node, init *Nodes) {
a := Nod(OSLICE, vstat, Nod(OKEY, nil, nil))
a = Nod(OAS, var_, a)
typecheck(&a, Etop)
a = typecheck(a, Etop)
a.Dodata = 2
init.Append(a)
return
......@@ -754,7 +754,7 @@ func slicelit(ctxt int, n *Node, var_ *Node, init *Nodes) {
if vstat == nil {
a = Nod(OAS, x, nil)
typecheck(&a, Etop)
a = typecheck(a, Etop)
init.Append(a) // zero new temp
}
......@@ -763,7 +763,7 @@ func slicelit(ctxt int, n *Node, var_ *Node, init *Nodes) {
a = temp(t)
if vstat == nil {
a = Nod(OAS, temp(t), nil)
typecheck(&a, Etop)
a = typecheck(a, Etop)
init.Append(a) // zero new temp
a = a.Left
}
......@@ -775,8 +775,8 @@ func slicelit(ctxt int, n *Node, var_ *Node, init *Nodes) {
}
a = Nod(OAS, vauto, a)
typecheck(&a, Etop)
walkexpr(&a, init)
a = typecheck(a, Etop)
a = walkexpr(a, init)
init.Append(a)
if vstat != nil {
......@@ -784,17 +784,17 @@ func slicelit(ctxt int, n *Node, var_ *Node, init *Nodes) {
a = Nod(OIND, vauto, nil)
a = Nod(OAS, a, vstat)
typecheck(&a, Etop)
walkexpr(&a, init)
a = typecheck(a, Etop)
a = walkexpr(a, init)
init.Append(a)
}
// make slice out of heap (5)
a = Nod(OAS, var_, Nod(OSLICE, vauto, Nod(OKEY, nil, nil)))
typecheck(&a, Etop)
orderstmtinplace(&a)
walkstmt(&a)
a = typecheck(a, Etop)
a = orderstmtinplace(a)
a = walkstmt(a)
init.Append(a)
// put dynamics into slice (6)
for _, r := range n.List.Slice() {
......@@ -829,9 +829,9 @@ func slicelit(ctxt int, n *Node, var_ *Node, init *Nodes) {
setlineno(value)
a = Nod(OAS, a, value)
typecheck(&a, Etop)
orderstmtinplace(&a)
walkstmt(&a)
a = typecheck(a, Etop)
a = orderstmtinplace(a)
a = walkstmt(a)
init.Append(a)
}
}
......@@ -906,8 +906,8 @@ func maplit(ctxt int, n *Node, var_ *Node, init *Nodes) {
a = Nod(OINDEX, vstat, a)
a = NodSym(ODOT, a, syma)
a = Nod(OAS, a, index)
typecheck(&a, Etop)
walkexpr(&a, init)
a = typecheck(a, Etop)
a = walkexpr(a, init)
a.Dodata = 2
init.Append(a)
......@@ -918,8 +918,8 @@ func maplit(ctxt int, n *Node, var_ *Node, init *Nodes) {
a = Nod(OINDEX, vstat, a)
a = NodSym(ODOT, a, symb)
a = Nod(OAS, a, value)
typecheck(&a, Etop)
walkexpr(&a, init)
a = typecheck(a, Etop)
a = walkexpr(a, init)
a.Dodata = 2
init.Append(a)
......@@ -951,8 +951,8 @@ func maplit(ctxt int, n *Node, var_ *Node, init *Nodes) {
a.Left = Nod(OLT, index, Nodintconst(tarr.Bound))
a.Right = Nod(OAS, index, Nod(OADD, index, Nodintconst(1)))
typecheck(&a, Etop)
walkstmt(&a)
a = typecheck(a, Etop)
a = walkstmt(a)
init.Append(a)
}
......@@ -978,19 +978,19 @@ func maplit(ctxt int, n *Node, var_ *Node, init *Nodes) {
setlineno(r.Left)
a = Nod(OAS, key, r.Left)
typecheck(&a, Etop)
walkstmt(&a)
a = typecheck(a, Etop)
a = walkstmt(a)
init.Append(a)
setlineno(r.Right)
a = Nod(OAS, val, r.Right)
typecheck(&a, Etop)
walkstmt(&a)
a = typecheck(a, Etop)
a = walkstmt(a)
init.Append(a)
setlineno(val)
a = Nod(OAS, Nod(OINDEX, var_, key), val)
typecheck(&a, Etop)
walkstmt(&a)
a = typecheck(a, Etop)
a = walkstmt(a)
init.Append(a)
if nerr != nerrors {
......@@ -1000,10 +1000,10 @@ func maplit(ctxt int, n *Node, var_ *Node, init *Nodes) {
if key != nil {
a = Nod(OVARKILL, key, nil)
typecheck(&a, Etop)
a = typecheck(a, Etop)
init.Append(a)
a = Nod(OVARKILL, val, nil)
typecheck(&a, Etop)
a = typecheck(a, Etop)
init.Append(a)
}
}
......@@ -1022,7 +1022,7 @@ func anylit(ctxt int, n *Node, var_ *Node, init *Nodes) {
var r *Node
if n.Right != nil {
r = Nod(OADDR, n.Right, nil)
typecheck(&r, Erv)
r = typecheck(r, Erv)
} else {
r = Nod(ONEW, nil, nil)
r.Typecheck = 1
......@@ -1030,14 +1030,14 @@ func anylit(ctxt int, n *Node, var_ *Node, init *Nodes) {
r.Esc = n.Esc
}
walkexpr(&r, init)
r = walkexpr(r, init)
a := Nod(OAS, var_, r)
typecheck(&a, Etop)
a = typecheck(a, Etop)
init.Append(a)
var_ = Nod(OIND, var_, nil)
typecheck(&var_, Erv|Easgn)
var_ = typecheck(var_, Erv|Easgn)
anylit(ctxt, n.Left, var_, init)
case OSTRUCTLIT:
......@@ -1055,8 +1055,8 @@ func anylit(ctxt int, n *Node, var_ *Node, init *Nodes) {
// copy static to var
a := Nod(OAS, var_, vstat)
typecheck(&a, Etop)
walkexpr(&a, init)
a = typecheck(a, Etop)
a = walkexpr(a, init)
init.Append(a)
// add expressions to automatic
......@@ -1073,8 +1073,8 @@ func anylit(ctxt int, n *Node, var_ *Node, init *Nodes) {
// initialize of not completely specified
if var_.isSimpleName() || n.List.Len() < t.NumFields() {
a := Nod(OAS, var_, nil)
typecheck(&a, Etop)
walkexpr(&a, init)
a = typecheck(a, Etop)
a = walkexpr(a, init)
init.Append(a)
}
......@@ -1099,8 +1099,8 @@ func anylit(ctxt int, n *Node, var_ *Node, init *Nodes) {
// copy static to automatic
a := Nod(OAS, var_, vstat)
typecheck(&a, Etop)
walkexpr(&a, init)
a = typecheck(a, Etop)
a = walkexpr(a, init)
init.Append(a)
// add expressions to automatic
......@@ -1117,8 +1117,8 @@ func anylit(ctxt int, n *Node, var_ *Node, init *Nodes) {
// initialize of not completely specified
if var_.isSimpleName() || int64(n.List.Len()) < t.Bound {
a := Nod(OAS, var_, nil)
typecheck(&a, Etop)
walkexpr(&a, init)
a = typecheck(a, Etop)
a = walkexpr(a, init)
init.Append(a)
}
......
src/cmd/compile/internal/gc/subr.go
View file @ 34699bc7
......@@ -484,7 +484,7 @@ func Nodbool(b bool) *Node {
func aindex(b *Node, t *Type) *Type {
bound := int64(-1) // open bound
typecheck(&b, Erv)
b = typecheck(b, Erv)
if b != nil {
switch consttype(b) {
default:
......@@ -1042,7 +1042,7 @@ func assignconvfn(n *Node, t *Type, context func() string) *Node {
old := n
old.Diag++ // silence errors about n; we'll issue one below
defaultlit(&n, t)
n = defaultlit(n, t)
old.Diag--
if t.Etype == TBLANK {
return n
......@@ -1082,10 +1082,11 @@ func assignconvfn(n *Node, t *Type, context func() string) *Node {
// substArgTypes substitutes the given list of types for
// successive occurrences of the "any" placeholder in the
// type syntax expression n.Type.
func substArgTypes(np **Node, types ...*Type) {
n := Nod(0, nil, nil)
*n = **np
*np = n
// The result of substArgTypes MUST be assigned back to old, e.g.
// n.Left = substArgTypes(n.Left, t1, t2)
func substArgTypes(old *Node, types ...*Type) *Node {
n := Nod(OXXX, nil, nil)
*n = *old // make shallow copy
for _, t := range types {
dowidth(t)
......@@ -1094,6 +1095,7 @@ func substArgTypes(np **Node, types ...*Type) {
if len(types) > 0 {
Fatalf("substArgTypes: too many argument types")
}
return n
}
// substAny walks t, replacing instances of "any" with successive
......@@ -1478,8 +1480,8 @@ func safeexpr(n *Node, init *Nodes) *Node {
r := Nod(OXXX, nil, nil)
*r = *n
r.Left = l
typecheck(&r, Erv)
walkexpr(&r, init)
r = typecheck(r, Erv)
r = walkexpr(r, init)
return r
case ODOTPTR, OIND:
......@@ -1490,7 +1492,7 @@ func safeexpr(n *Node, init *Nodes) *Node {
a := Nod(OXXX, nil, nil)
*a = *n
a.Left = l
walkexpr(&a, init)
a = walkexpr(a, init)
return a
case OINDEX, OINDEXMAP:
......@@ -1503,7 +1505,7 @@ func safeexpr(n *Node, init *Nodes) *Node {
*a = *n
a.Left = l
a.Right = r
walkexpr(&a, init)
a = walkexpr(a, init)
return a
}
......@@ -1517,8 +1519,8 @@ func safeexpr(n *Node, init *Nodes) *Node {
func copyexpr(n *Node, t *Type, init *Nodes) *Node {
l := temp(t)
a := Nod(OAS, l, n)
typecheck(&a, Etop)
walkexpr(&a, init)
a = typecheck(a, Etop)
a = walkexpr(a, init)
init.Append(a)
return l
}
......@@ -1684,7 +1686,7 @@ func dotpath(s *Sym, t *Type, save **Field, ignorecase bool) (path []Dlist, ambi
// will give shortest unique addressing.
// modify the tree with missing type names.
func adddot(n *Node) *Node {
typecheck(&n.Left, Etype|Erv)
n.Left = typecheck(n.Left, Etype|Erv)
n.Diag |= n.Left.Diag
t := n.Left.Type
if t == nil {
......@@ -2018,7 +2020,7 @@ func genwrapper(rcvr *Type, method *Field, newnam *Sym, iface int) {
if rcvr.Etype == TSTRUCT || rcvr.Etype == TINTER || Isptr[rcvr.Etype] && rcvr.Type.Etype == TSTRUCT {
fn.Func.Dupok = true
}
typecheck(&fn, Etop)
fn = typecheck(fn, Etop)
typecheckslice(fn.Nbody.Slice(), Etop)
inlcalls(fn)
......@@ -2038,7 +2040,7 @@ func hashmem(t *Type) *Node {
tfn.List.Append(Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
tfn.List.Append(Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
tfn.Rlist.Append(Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
typecheck(&tfn, Etype)
tfn = typecheck(tfn, Etype)
n.Type = tfn.Type
return n
}
......@@ -2305,25 +2307,25 @@ func mkpkg(path string) *Pkg {
return p
}
func addinit(np **Node, init []*Node) {
// The result of addinit MUST be assigned back to n, e.g.
// n.Left = addinit(n.Left, init)
func addinit(n *Node, init []*Node) *Node {
if len(init) == 0 {
return
return n
}
n := *np
switch n.Op {
// There may be multiple refs to this node;
// introduce OCONVNOP to hold init list.
case ONAME, OLITERAL:
n = Nod(OCONVNOP, n, nil)
n.Type = n.Left.Type
n.Typecheck = 1
*np = n
}
n.Ninit.Set(append(init, n.Ninit.Slice()...))
n.Ullman = UINF
return n
}
var reservedimports = []string{
......@@ -2377,7 +2379,7 @@ func isbadimport(path string) bool {
func checknil(x *Node, init *Nodes) {
if Isinter(x.Type) {
x = Nod(OITAB, x, nil)
typecheck(&x, Erv)
x = typecheck(x, Erv)
}
n := Nod(OCHECKNIL, x, nil)
......
src/cmd/compile/internal/gc/swt.go
View file @ 34699bc7
......@@ -67,7 +67,7 @@ func typecheckswitch(n *Node) {
if n.Left != nil && n.Left.Op == OTYPESW {
// type switch
top = Etype
typecheck(&n.Left.Right, Erv)
n.Left.Right = typecheck(n.Left.Right, Erv)
t = n.Left.Right.Type
if t != nil && t.Etype != TINTER {
Yyerror("cannot type switch on non-interface value %v", Nconv(n.Left.Right, FmtLong))
......@@ -76,8 +76,8 @@ func typecheckswitch(n *Node) {
// expression switch
top = Erv
if n.Left != nil {
typecheck(&n.Left, Erv)
defaultlit(&n.Left, nil)
n.Left = typecheck(n.Left, Erv)
n.Left = defaultlit(n.Left, nil)
t = n.Left.Type
} else {
t = Types[TBOOL]
......@@ -117,7 +117,7 @@ func typecheckswitch(n *Node) {
ls := ncase.List.Slice()
for i1, n1 := range ls {
setlineno(n1)
typecheck(&ls[i1], Erv|Etype)
ls[i1] = typecheck(ls[i1], Erv|Etype)
n1 = ls[i1]
if n1.Type == nil || t == nil {
continue
......@@ -126,7 +126,7 @@ func typecheckswitch(n *Node) {
switch top {
// expression switch
case Erv:
defaultlit(&ls[i1], t)
ls[i1] = defaultlit(ls[i1], t)
n1 = ls[i1]
switch {
case n1.Op == OTYPE:
......@@ -177,7 +177,7 @@ func typecheckswitch(n *Node) {
nvar.Name.Param.Ntype = typenod(n.Type)
}
typecheck(&nvar, Erv|Easgn)
nvar = typecheck(nvar, Erv|Easgn)
ncase.Rlist.SetIndex(0, nvar)
}
}
......@@ -193,7 +193,7 @@ func walkswitch(sw *Node) {
// convert switch {...} to switch true {...}
if sw.Left == nil {
sw.Left = Nodbool(true)
typecheck(&sw.Left, Erv)
sw.Left = typecheck(sw.Left, Erv)
}
if sw.Left.Op == OTYPESW {
......@@ -224,7 +224,7 @@ func (s *exprSwitch) walk(sw *Node) {
}
}
walkexpr(&cond, &sw.Ninit)
cond = walkexpr(cond, &sw.Ninit)
t := sw.Type
if t == nil {
return
......@@ -296,13 +296,13 @@ func (s *exprSwitch) walkCases(cc []*caseClause) *Node {
a := Nod(OIF, nil, nil)
if (s.kind != switchKindTrue && s.kind != switchKindFalse) || assignop(n.Left.Type, s.exprname.Type, nil) == OCONVIFACE || assignop(s.exprname.Type, n.Left.Type, nil) == OCONVIFACE {
a.Left = Nod(OEQ, s.exprname, n.Left) // if name == val
typecheck(&a.Left, Erv)
a.Left = typecheck(a.Left, Erv)
} else if s.kind == switchKindTrue {
a.Left = n.Left // if val
} else {
// s.kind == switchKindFalse
a.Left = Nod(ONOT, n.Left, nil) // if !val
typecheck(&a.Left, Erv)
a.Left = typecheck(a.Left, Erv)
}
a.Nbody.Set1(n.Right) // goto l
......@@ -325,7 +325,7 @@ func (s *exprSwitch) walkCases(cc []*caseClause) *Node {
} else {
a.Left = le
}
typecheck(&a.Left, Erv)
a.Left = typecheck(a.Left, Erv)
a.Nbody.Set1(s.walkCases(cc[:half]))
a.Rlist.Set1(s.walkCases(cc[half:]))
return a
......@@ -526,7 +526,7 @@ func (s *typeSwitch) walk(sw *Node) {
return
}
walkexpr(&cond.Right, &sw.Ninit)
cond.Right = walkexpr(cond.Right, &sw.Ninit)
if !Istype(cond.Right.Type, TINTER) {
Yyerror("type switch must be on an interface")
return
......@@ -538,14 +538,14 @@ func (s *typeSwitch) walk(sw *Node) {
s.facename = temp(cond.Right.Type)
a := Nod(OAS, s.facename, cond.Right)
typecheck(&a, Etop)
a = typecheck(a, Etop)
cas = append(cas, a)
s.okname = temp(Types[TBOOL])
typecheck(&s.okname, Erv)
s.okname = typecheck(s.okname, Erv)
s.hashname = temp(Types[TUINT32])
typecheck(&s.hashname, Erv)
s.hashname = typecheck(s.hashname, Erv)
// set up labels and jumps
casebody(sw, s.facename)
......@@ -590,7 +590,7 @@ func (s *typeSwitch) walk(sw *Node) {
blk.List.Set([]*Node{Nod(OLABEL, lbl, nil), def})
def = blk
}
typecheck(&i.Left, Erv)
i.Left = typecheck(i.Left, Erv)
cas = append(cas, i)
if !isnilinter(cond.Right.Type) {
......@@ -608,7 +608,7 @@ func (s *typeSwitch) walk(sw *Node) {
h.Xoffset = int64(2 * Widthptr) // offset of hash in runtime._type
h.Bounded = true // guaranteed not to fault
a = Nod(OAS, s.hashname, h)
typecheck(&a, Etop)
a = typecheck(a, Etop)
cas = append(cas, a)
// insert type equality check into each case block
......@@ -680,12 +680,12 @@ func (s *typeSwitch) typeone(t *Node) *Node {
var init []*Node
if t.Rlist.Len() == 0 {
name = nblank
typecheck(&nblank, Erv|Easgn)
nblank = typecheck(nblank, Erv|Easgn)
} else {
name = t.Rlist.First()
init = []*Node{Nod(ODCL, name, nil)}
a := Nod(OAS, name, nil)
typecheck(&a, Etop)
a = typecheck(a, Etop)
init = append(init, a)
}
......@@ -694,7 +694,7 @@ func (s *typeSwitch) typeone(t *Node) *Node {
b := Nod(ODOTTYPE, s.facename, nil)
b.Type = t.Left.Type // interface.(type)
a.Rlist.Set1(b)
typecheck(&a, Etop)
a = typecheck(a, Etop)
init = append(init, a)
c := Nod(OIF, nil, nil)
......@@ -715,7 +715,7 @@ func (s *typeSwitch) walkCases(cc []*caseClause) *Node {
}
a := Nod(OIF, nil, nil)
a.Left = Nod(OEQ, s.hashname, Nodintconst(int64(c.hash)))
typecheck(&a.Left, Erv)
a.Left = typecheck(a.Left, Erv)
a.Nbody.Set1(n.Right)
cas = append(cas, a)
}
......@@ -726,7 +726,7 @@ func (s *typeSwitch) walkCases(cc []*caseClause) *Node {
half := len(cc) / 2
a := Nod(OIF, nil, nil)
a.Left = Nod(OLE, s.hashname, Nodintconst(int64(cc[half-1].hash)))
typecheck(&a.Left, Erv)
a.Left = typecheck(a.Left, Erv)
a.Nbody.Set1(s.walkCases(cc[:half]))
a.Rlist.Set1(s.walkCases(cc[half:]))
return a
......
src/cmd/compile/internal/gc/typecheck.go
View file @ 34699bc7
......@@ -36,7 +36,7 @@ func resolve(n *Node) *Node {
func typecheckslice(l []*Node, top int) {
for i := range l {
typecheck(&l[i], top)
l[i] = typecheck(l[i], top)
}
}
......@@ -102,16 +102,15 @@ func sprint_depchain(fmt_ *string, stack []*Node, cur *Node, first *Node) {
var typecheck_tcstack []*Node
// typecheck type checks node *np.
// It replaces *np with a new pointer in some cases.
// It returns the final value of *np as a convenience.
func typecheck(np **Node, top int) *Node {
// typecheck type checks node n.
// The result of typecheck MUST be assigned back to n, e.g.
// n.Left = typecheck(n.Left, top)
func typecheck(n *Node, top int) *Node {
// cannot type check until all the source has been parsed
if !typecheckok {
Fatalf("early typecheck")
}
n := *np
if n == nil {
return nil
}
......@@ -126,8 +125,6 @@ func typecheck(np **Node, top int) *Node {
// Resolve definition of name and value of iota lazily.
n = resolve(n)
*np = n
// Skip typecheck if already done.
// But re-typecheck ONAME/OTYPE/OLITERAL/OPACK node in case context has changed.
if n.Typecheck == 1 {
......@@ -177,8 +174,7 @@ func typecheck(np **Node, top int) *Node {
n.Typecheck = 2
typecheck_tcstack = append(typecheck_tcstack, n)
typecheck1(&n, top)
*np = n
n = typecheck1(n, top)
n.Typecheck = 1
......@@ -227,25 +223,24 @@ func callrecvlist(l Nodes) bool {
// array/slice indexes. It is equivalent to defaultlit
// except for constants of numerical kind, which are acceptable
// whenever they can be represented by a value of type int.
func indexlit(np **Node) {
n := *np
// The result of indexlit MUST be assigned back to n, e.g.
// n.Left = indexlit(n.Left)
func indexlit(n *Node) *Node {
if n == nil || !isideal(n.Type) {
return
return n
}
switch consttype(n) {
case CTINT, CTRUNE, CTFLT, CTCPLX:
defaultlit(np, Types[TINT])
n = defaultlit(n, Types[TINT])
}
defaultlit(np, nil)
n = defaultlit(n, nil)
return n
}
func typecheck1(np **Node, top int) {
n := *np
defer func() {
*np = n
}()
// The result of typecheck1 MUST be assigned back to n, e.g.
// n.Left = typecheck1(n.Left, top)
func typecheck1(n *Node, top int) *Node {
switch n.Op {
case OXDOT, ODOT, ODOTPTR, ODOTMETH, ODOTINTER:
// n.Sym is a field/method name, not a variable.
......@@ -254,13 +249,13 @@ func typecheck1(np **Node, top int) {
if n.Op == ONAME && n.Etype != 0 && top&Ecall == 0 {
Yyerror("use of builtin %v not in function call", n.Sym)
n.Type = nil
return
return n
}
typecheckdef(n)
if n.Op == ONONAME {
n.Type = nil
return
return n
}
}
}
......@@ -301,7 +296,7 @@ OpSwitch:
if isblank(n) {
Yyerror("cannot use _ as value")
n.Type = nil
return
return n
}
n.Used = true
......@@ -310,7 +305,7 @@ OpSwitch:
if top&Ecall == 0 && isunsafebuiltin(n) {
Yyerror("%v is not an expression, must be called", n)
n.Type = nil
return
return n
}
ok |= Erv
......@@ -319,7 +314,7 @@ OpSwitch:
case OPACK:
Yyerror("use of package %v without selector", n.Sym)
n.Type = nil
return
return n
case ODDD:
break
......@@ -330,7 +325,7 @@ OpSwitch:
if n.Type == nil {
n.Type = nil
return
return n
}
case OTARRAY:
......@@ -348,7 +343,8 @@ OpSwitch:
Yyerror("use of [...] array outside of array literal")
}
} else {
l := typecheck(&n.Left, Erv)
n.Left = typecheck(n.Left, Erv)
l := n.Left
var v Val
switch consttype(l) {
case CTINT, CTRUNE:
......@@ -364,25 +360,25 @@ OpSwitch:
Yyerror("invalid array bound %v", l)
}
n.Type = nil
return
return n
}
t.Bound = v.U.(*Mpint).Int64()
if doesoverflow(v, Types[TINT]) {
Yyerror("array bound is too large")
n.Type = nil
return
return n
} else if t.Bound < 0 {
Yyerror("array bound must be non-negative")
n.Type = nil
return
return n
}
}
typecheck(&r, Etype)
r = typecheck(r, Etype)
if r.Type == nil {
n.Type = nil
return
return n
}
t.Type = r.Type
n.Op = OTYPE
......@@ -395,11 +391,13 @@ OpSwitch:
case OTMAP:
ok |= Etype
l := typecheck(&n.Left, Etype)
r := typecheck(&n.Right, Etype)
n.Left = typecheck(n.Left, Etype)
n.Right = typecheck(n.Right, Etype)
l := n.Left
r := n.Right
if l.Type == nil || r.Type == nil {
n.Type = nil
return
return n
}
n.Op = OTYPE
n.Type = maptype(l.Type, r.Type)
......@@ -408,10 +406,11 @@ OpSwitch:
case OTCHAN:
ok |= Etype
l := typecheck(&n.Left, Etype)
n.Left = typecheck(n.Left, Etype)
l := n.Left
if l.Type == nil {
n.Type = nil
return
return n
}
t := typ(TCHAN)
t.Type = l.Type
......@@ -428,7 +427,7 @@ OpSwitch:
n.Type = tostruct(n.List.Slice())
if n.Type == nil || n.Type.Broke {
n.Type = nil
return
return n
}
n.List.Set(nil)
......@@ -438,7 +437,7 @@ OpSwitch:
n.Type = tointerface(n.List.Slice())
if n.Type == nil {
n.Type = nil
return
return n
}
case OTFUNC:
......@@ -447,7 +446,7 @@ OpSwitch:
n.Type = functype(n.Left, n.List.Slice(), n.Rlist.Slice())
if n.Type == nil {
n.Type = nil
return
return n
}
// type or expr
......@@ -458,11 +457,12 @@ OpSwitch:
ntop |= Eindir
}
ntop |= top & Ecomplit
l := typecheck(&n.Left, ntop)
n.Left = typecheck(n.Left, ntop)
l := n.Left
t := l.Type
if t == nil {
n.Type = nil
return
return n
}
if l.Op == OTYPE {
ok |= Etype
......@@ -476,7 +476,7 @@ OpSwitch:
if top&(Erv|Etop) != 0 {
Yyerror("invalid indirect of %v", Nconv(n.Left, FmtLong))
n.Type = nil
return
return n
}
break OpSwitch
......@@ -513,45 +513,49 @@ OpSwitch:
var r *Node
if n.Op == OASOP {
ok |= Etop
l = typecheck(&n.Left, Erv)
r = typecheck(&n.Right, Erv)
n.Left = typecheck(n.Left, Erv)
n.Right = typecheck(n.Right, Erv)
l = n.Left
r = n.Right
checkassign(n, n.Left)
if l.Type == nil || r.Type == nil {
n.Type = nil
return
return n
}
if n.Implicit && !okforarith[l.Type.Etype] {
Yyerror("invalid operation: %v (non-numeric type %v)", n, l.Type)
n.Type = nil
return
return n
}
// TODO(marvin): Fix Node.EType type union.
op = Op(n.Etype)
} else {
ok |= Erv
l = typecheck(&n.Left, Erv|top&Eiota)
r = typecheck(&n.Right, Erv|top&Eiota)
n.Left = typecheck(n.Left, Erv|top&Eiota)
n.Right = typecheck(n.Right, Erv|top&Eiota)
l = n.Left
r = n.Right
if l.Type == nil || r.Type == nil {
n.Type = nil
return
return n
}
op = n.Op
}
if op == OLSH || op == ORSH {
defaultlit(&r, Types[TUINT])
r = defaultlit(r, Types[TUINT])
n.Right = r
t := r.Type
if !Isint[t.Etype] || Issigned[t.Etype] {
Yyerror("invalid operation: %v (shift count type %v, must be unsigned integer)", n, r.Type)
n.Type = nil
return
return n
}
t = l.Type
if t != nil && t.Etype != TIDEAL && !Isint[t.Etype] {
Yyerror("invalid operation: %v (shift of type %v)", n, t)
n.Type = nil
return
return n
}
// no defaultlit for left
......@@ -562,13 +566,13 @@ OpSwitch:
}
// ideal mixed with non-ideal
defaultlit2(&l, &r, false)
l, r = defaultlit2(l, r, false)
n.Left = l
n.Right = r
if l.Type == nil || r.Type == nil {
n.Type = nil
return
return n
}
t := l.Type
if t.Etype == TIDEAL {
......@@ -593,7 +597,7 @@ OpSwitch:
if Isinter(r.Type) && !Isinter(l.Type) && algtype1(l.Type, nil) == ANOEQ {
Yyerror("invalid operation: %v (operator %v not defined on %s)", n, Oconv(op, 0), typekind(l.Type))
n.Type = nil
return
return n
}
dowidth(l.Type)
......@@ -615,7 +619,7 @@ OpSwitch:
if Isinter(l.Type) && !Isinter(r.Type) && algtype1(r.Type, nil) == ANOEQ {
Yyerror("invalid operation: %v (operator %v not defined on %s)", n, Oconv(op, 0), typekind(r.Type))
n.Type = nil
return
return n
}
dowidth(r.Type)
......@@ -635,18 +639,18 @@ OpSwitch:
}
if t.Etype != TIDEAL && !Eqtype(l.Type, r.Type) {
defaultlit2(&l, &r, true)
l, r = defaultlit2(l, r, true)
if Isinter(r.Type) == Isinter(l.Type) || aop == 0 {
Yyerror("invalid operation: %v (mismatched types %v and %v)", n, l.Type, r.Type)
n.Type = nil
return
return n
}
}
if !okfor[op][et] {
Yyerror("invalid operation: %v (operator %v not defined on %s)", n, Oconv(op, 0), typekind(t))
n.Type = nil
return
return n
}
// okfor allows any array == array, map == map, func == func.
......@@ -654,32 +658,32 @@ OpSwitch:
if Isfixedarray(l.Type) && algtype1(l.Type, nil) == ANOEQ {
Yyerror("invalid operation: %v (%v cannot be compared)", n, l.Type)
n.Type = nil
return
return n
}
if Isslice(l.Type) && !isnil(l) && !isnil(r) {
Yyerror("invalid operation: %v (slice can only be compared to nil)", n)
n.Type = nil
return
return n
}
if l.Type.Etype == TMAP && !isnil(l) && !isnil(r) {
Yyerror("invalid operation: %v (map can only be compared to nil)", n)
n.Type = nil
return
return n
}
if l.Type.Etype == TFUNC && !isnil(l) && !isnil(r) {
Yyerror("invalid operation: %v (func can only be compared to nil)", n)
n.Type = nil
return
return n
}
var badtype *Type
if l.Type.Etype == TSTRUCT && algtype1(l.Type, &badtype) == ANOEQ {
Yyerror("invalid operation: %v (struct containing %v cannot be compared)", n, badtype)
n.Type = nil
return
return n
}
t = l.Type
......@@ -687,7 +691,7 @@ OpSwitch:
evconst(n)
t = idealbool
if n.Op != OLITERAL {
defaultlit2(&l, &r, true)
l, r = defaultlit2(l, r, true)
n.Left = l
n.Right = r
}
......@@ -736,7 +740,7 @@ OpSwitch:
if r.Val().U.(*Mpint).CmpInt64(0) == 0 {
Yyerror("division by zero")
n.Type = nil
return
return n
}
}
......@@ -745,16 +749,17 @@ OpSwitch:
case OCOM, OMINUS, ONOT, OPLUS:
ok |= Erv
l := typecheck(&n.Left, Erv|top&Eiota)
n.Left = typecheck(n.Left, Erv|top&Eiota)
l := n.Left
t := l.Type
if t == nil {
n.Type = nil
return
return n
}
if !okfor[n.Op][t.Etype] {
Yyerror("invalid operation: %v %v", Oconv(n.Op, 0), t)
n.Type = nil
return
return n
}
n.Type = t
......@@ -764,10 +769,10 @@ OpSwitch:
case OADDR:
ok |= Erv
typecheck(&n.Left, Erv|Eaddr)
n.Left = typecheck(n.Left, Erv|Eaddr)
if n.Left.Type == nil {
n.Type = nil
return
return n
}
checklvalue(n.Left, "take the address of")
r := outervalue(n.Left)
......@@ -786,22 +791,22 @@ OpSwitch:
if l.Name != nil && l.Name.Param != nil && l.Name.Param.Closure != nil {
l.Name.Param.Closure.Addrtaken = true
}
defaultlit(&n.Left, nil)
n.Left = defaultlit(n.Left, nil)
l = n.Left
t := l.Type
if t == nil {
n.Type = nil
return
return n
}
n.Type = Ptrto(t)
break OpSwitch
case OCOMPLIT:
ok |= Erv
typecheckcomplit(&n)
n = typecheckcomplit(n)
if n.Type == nil {
n.Type = nil
return
return n
}
break OpSwitch
......@@ -811,19 +816,19 @@ OpSwitch:
n.Op = ODOT
if n.Left == nil {
n.Type = nil
return
return n
}
}
typecheck(&n.Left, Erv|Etype)
n.Left = typecheck(n.Left, Erv|Etype)
defaultlit(&n.Left, nil)
n.Left = defaultlit(n.Left, nil)
t := n.Left.Type
if t == nil {
adderrorname(n)
n.Type = nil
return
return n
}
s := n.Sym
......@@ -836,14 +841,14 @@ OpSwitch:
Yyerror("%v undefined (type %v has no method %v)", n, t, n.Sym)
}
n.Type = nil
return
return n
}
if n.Type.Etype != TFUNC || n.Type.Recv() == nil {
Yyerror("type %v has no method %v", n.Left.Type, Sconv(n.Right.Sym, FmtShort))
n.Type = nil
n.Type = nil
return
return n
}
n.Op = ONAME
......@@ -862,7 +867,7 @@ OpSwitch:
t = t.Type
if t == nil {
n.Type = nil
return
return n
}
n.Op = ODOTPTR
checkwidth(t)
......@@ -871,7 +876,7 @@ OpSwitch:
if isblanksym(n.Sym) {
Yyerror("cannot refer to blank field or method")
n.Type = nil
return
return n
}
if lookdot(n, t, 0) == nil {
......@@ -896,7 +901,7 @@ OpSwitch:
}
}
n.Type = nil
return
return n
}
switch n.Op {
......@@ -916,26 +921,26 @@ OpSwitch:
case ODOTTYPE:
ok |= Erv
typecheck(&n.Left, Erv)
defaultlit(&n.Left, nil)
n.Left = typecheck(n.Left, Erv)
n.Left = defaultlit(n.Left, nil)
l := n.Left
t := l.Type
if t == nil {
n.Type = nil
return
return n
}
if !Isinter(t) {
Yyerror("invalid type assertion: %v (non-interface type %v on left)", n, t)
n.Type = nil
return
return n
}
if n.Right != nil {
typecheck(&n.Right, Etype)
n.Right = typecheck(n.Right, Etype)
n.Type = n.Right.Type
n.Right = nil
if n.Type == nil {
return
return n
}
}
......@@ -953,7 +958,7 @@ OpSwitch:
Yyerror("impossible type assertion:\n\t%v does not implement %v (missing %v method)", n.Type, t, missing.Sym)
}
n.Type = nil
return
return n
}
}
......@@ -961,25 +966,25 @@ OpSwitch:
case OINDEX:
ok |= Erv
typecheck(&n.Left, Erv)
defaultlit(&n.Left, nil)
implicitstar(&n.Left)
n.Left = typecheck(n.Left, Erv)
n.Left = defaultlit(n.Left, nil)
n.Left = implicitstar(n.Left)
l := n.Left
typecheck(&n.Right, Erv)
n.Right = typecheck(n.Right, Erv)
r := n.Right
t := l.Type
if t == nil || r.Type == nil {
n.Type = nil
return
return n
}
switch t.Etype {
default:
Yyerror("invalid operation: %v (type %v does not support indexing)", n, t)
n.Type = nil
return
return n
case TSTRING, TARRAY:
indexlit(&n.Right)
n.Right = indexlit(n.Right)
if t.Etype == TSTRING {
n.Type = bytetype
} else {
......@@ -1014,7 +1019,7 @@ OpSwitch:
case TMAP:
n.Etype = 0
defaultlit(&n.Right, t.Key())
n.Right = defaultlit(n.Right, t.Key())
if n.Right.Type != nil {
n.Right = assignconv(n.Right, t.Key(), "map index")
}
......@@ -1026,24 +1031,24 @@ OpSwitch:
case ORECV:
ok |= Etop | Erv
typecheck(&n.Left, Erv)
defaultlit(&n.Left, nil)
n.Left = typecheck(n.Left, Erv)
n.Left = defaultlit(n.Left, nil)
l := n.Left
t := l.Type
if t == nil {
n.Type = nil
return
return n
}
if t.Etype != TCHAN {
Yyerror("invalid operation: %v (receive from non-chan type %v)", n, t)
n.Type = nil
return
return n
}
if t.Chan&Crecv == 0 {
Yyerror("invalid operation: %v (receive from send-only type %v)", n, t)
n.Type = nil
return
return n
}
n.Type = t.Type
......@@ -1051,32 +1056,33 @@ OpSwitch:
case OSEND:
ok |= Etop
l := typecheck(&n.Left, Erv)
typecheck(&n.Right, Erv)
defaultlit(&n.Left, nil)
n.Left = typecheck(n.Left, Erv)
l := n.Left
n.Right = typecheck(n.Right, Erv)
n.Left = defaultlit(n.Left, nil)
l = n.Left
t := l.Type
if t == nil {
n.Type = nil
return
return n
}
if t.Etype != TCHAN {
Yyerror("invalid operation: %v (send to non-chan type %v)", n, t)
n.Type = nil
return
return n
}
if t.Chan&Csend == 0 {
Yyerror("invalid operation: %v (send to receive-only type %v)", n, t)
n.Type = nil
return
return n
}
defaultlit(&n.Right, t.Type)
n.Right = defaultlit(n.Right, t.Type)
r := n.Right
if r.Type == nil {
n.Type = nil
return
return n
}
n.Right = assignconv(r, l.Type.Type, "send")
......@@ -1088,30 +1094,30 @@ OpSwitch:
case OSLICE:
ok |= Erv
typecheck(&n.Left, top)
typecheck(&n.Right.Left, Erv)
typecheck(&n.Right.Right, Erv)
defaultlit(&n.Left, nil)
indexlit(&n.Right.Left)
indexlit(&n.Right.Right)
n.Left = typecheck(n.Left, top)
n.Right.Left = typecheck(n.Right.Left, Erv)
n.Right.Right = typecheck(n.Right.Right, Erv)
n.Left = defaultlit(n.Left, nil)
n.Right.Left = indexlit(n.Right.Left)
n.Right.Right = indexlit(n.Right.Right)
l := n.Left
if Isfixedarray(l.Type) {
if !islvalue(n.Left) {
Yyerror("invalid operation %v (slice of unaddressable value)", n)
n.Type = nil
return
return n
}
n.Left = Nod(OADDR, n.Left, nil)
n.Left.Implicit = true
typecheck(&n.Left, Erv)
n.Left = typecheck(n.Left, Erv)
l = n.Left
}
t := l.Type
if t == nil {
n.Type = nil
return
return n
}
var tp *Type
if Istype(t, TSTRING) {
......@@ -1129,58 +1135,58 @@ OpSwitch:
} else {
Yyerror("cannot slice %v (type %v)", l, t)
n.Type = nil
return
return n
}
lo := n.Right.Left
if lo != nil && !checksliceindex(l, lo, tp) {
n.Type = nil
return
return n
}
hi := n.Right.Right
if hi != nil && !checksliceindex(l, hi, tp) {
n.Type = nil
return
return n
}
if !checksliceconst(lo, hi) {
n.Type = nil
return
return n
}
break OpSwitch
case OSLICE3:
ok |= Erv
typecheck(&n.Left, top)
typecheck(&n.Right.Left, Erv)
typecheck(&n.Right.Right.Left, Erv)
typecheck(&n.Right.Right.Right, Erv)
defaultlit(&n.Left, nil)
indexlit(&n.Right.Left)
indexlit(&n.Right.Right.Left)
indexlit(&n.Right.Right.Right)
n.Left = typecheck(n.Left, top)
n.Right.Left = typecheck(n.Right.Left, Erv)
n.Right.Right.Left = typecheck(n.Right.Right.Left, Erv)
n.Right.Right.Right = typecheck(n.Right.Right.Right, Erv)
n.Left = defaultlit(n.Left, nil)
n.Right.Left = indexlit(n.Right.Left)
n.Right.Right.Left = indexlit(n.Right.Right.Left)
n.Right.Right.Right = indexlit(n.Right.Right.Right)
l := n.Left
if Isfixedarray(l.Type) {
if !islvalue(n.Left) {
Yyerror("invalid operation %v (slice of unaddressable value)", n)
n.Type = nil
return
return n
}
n.Left = Nod(OADDR, n.Left, nil)
n.Left.Implicit = true
typecheck(&n.Left, Erv)
n.Left = typecheck(n.Left, Erv)
l = n.Left
}
t := l.Type
if t == nil {
n.Type = nil
return
return n
}
if Istype(t, TSTRING) {
Yyerror("invalid operation %v (3-index slice of string)", n)
n.Type = nil
return
return n
}
var tp *Type
......@@ -1196,27 +1202,27 @@ OpSwitch:
} else {
Yyerror("cannot slice %v (type %v)", l, t)
n.Type = nil
return
return n
}
lo := n.Right.Left
if lo != nil && !checksliceindex(l, lo, tp) {
n.Type = nil
return
return n
}
mid := n.Right.Right.Left
if mid != nil && !checksliceindex(l, mid, tp) {
n.Type = nil
return
return n
}
hi := n.Right.Right.Right
if hi != nil && !checksliceindex(l, hi, tp) {
n.Type = nil
return
return n
}
if !checksliceconst(lo, hi) || !checksliceconst(lo, mid) || !checksliceconst(mid, hi) {
n.Type = nil
return
return n
}
break OpSwitch
......@@ -1231,12 +1237,12 @@ OpSwitch:
Yyerror("invalid use of ... with builtin %v", l)
}
n = r
typecheck1(&n, top)
return
n = typecheck1(n, top)
return n
}
}
typecheck(&n.Left, Erv|Etype|Ecall|top&Eproc)
n.Left = typecheck(n.Left, Erv|Etype|Ecall|top&Eproc)
n.Diag |= n.Left.Diag
l = n.Left
if l.Op == ONAME && l.Etype != 0 {
......@@ -1251,11 +1257,11 @@ OpSwitch:
n.Left = n.Right
n.Right = nil
typecheck1(&n, top)
return
n = typecheck1(n, top)
return n
}
defaultlit(&n.Left, nil)
n.Left = defaultlit(n.Left, nil)
l = n.Left
if l.Op == OTYPE {
if n.Isddd || l.Type.Bound == -100 {
......@@ -1275,21 +1281,21 @@ OpSwitch:
n.Type = l.Type
if !onearg(n, "conversion to %v", l.Type) {
n.Type = nil
return
return n
}
typecheck1(&n, top)
return
n = typecheck1(n, top)
return n
}
if n.List.Len() == 1 && !n.Isddd {
typecheck(n.List.Addr(0), Erv|Efnstruct)
n.List.SetIndex(0, typecheck(n.List.Index(0), Erv|Efnstruct))
} else {
typecheckslice(n.List.Slice(), Erv)
}
t := l.Type
if t == nil {
n.Type = nil
return
return n
}
checkwidth(t)
......@@ -1315,7 +1321,7 @@ OpSwitch:
if t.Etype != TFUNC {
Yyerror("cannot call non-function %v (type %v)", l, t)
n.Type = nil
return
return n
}
}
......@@ -1355,16 +1361,16 @@ OpSwitch:
ok |= Erv
if !onearg(n, "%v", Oconv(n.Op, 0)) {
n.Type = nil
return
return n
}
typecheck(&n.Left, Erv)
defaultlit(&n.Left, nil)
implicitstar(&n.Left)
n.Left = typecheck(n.Left, Erv)
n.Left = defaultlit(n.Left, nil)
n.Left = implicitstar(n.Left)
l := n.Left
t := l.Type
if t == nil {
n.Type = nil
return
return n
}
switch n.Op {
case OCAP:
......@@ -1424,7 +1430,7 @@ OpSwitch:
badcall1:
Yyerror("invalid argument %v for %v", Nconv(n.Left, FmtLong), Oconv(n.Op, 0))
n.Type = nil
return
return n
case OCOMPLEX:
ok |= Erv
......@@ -1435,14 +1441,14 @@ OpSwitch:
if n.List.First().Op != OCALLFUNC && n.List.First().Op != OCALLMETH {
Yyerror("invalid operation: complex expects two arguments")
n.Type = nil
return
return n
}
t := n.List.First().Left.Type
if t.Results().NumFields() != 2 {
Yyerror("invalid operation: complex expects two arguments, %v returns %d results", n.List.First(), t.Results().NumFields())
n.Type = nil
return
return n
}
t = n.List.First().Type
......@@ -1451,18 +1457,20 @@ OpSwitch:
} else {
if !twoarg(n) {
n.Type = nil
return
return n
}
l = typecheck(&n.Left, Erv|top&Eiota)
r = typecheck(&n.Right, Erv|top&Eiota)
n.Left = typecheck(n.Left, Erv|top&Eiota)
n.Right = typecheck(n.Right, Erv|top&Eiota)
l = n.Left
r = n.Right
if l.Type == nil || r.Type == nil {
n.Type = nil
return
return n
}
defaultlit2(&l, &r, false)
l, r = defaultlit2(l, r, false)
if l.Type == nil || r.Type == nil {
n.Type = nil
return
return n
}
n.Left = l
n.Right = r
......@@ -1471,7 +1479,7 @@ OpSwitch:
if !Eqtype(l.Type, r.Type) {
Yyerror("invalid operation: %v (mismatched types %v and %v)", n, l.Type, r.Type)
n.Type = nil
return
return n
}
var t *Type
......@@ -1479,7 +1487,7 @@ OpSwitch:
default:
Yyerror("invalid operation: %v (arguments have type %v, expected floating-point)", n, l.Type)
n.Type = nil
return
return n
case TIDEAL:
t = Types[TIDEAL]
......@@ -1505,26 +1513,26 @@ OpSwitch:
case OCLOSE:
if !onearg(n, "%v", Oconv(n.Op, 0)) {
n.Type = nil
return
return n
}
typecheck(&n.Left, Erv)
defaultlit(&n.Left, nil)
n.Left = typecheck(n.Left, Erv)
n.Left = defaultlit(n.Left, nil)
l := n.Left
t := l.Type
if t == nil {
n.Type = nil
return
return n
}
if t.Etype != TCHAN {
Yyerror("invalid operation: %v (non-chan type %v)", n, t)
n.Type = nil
return
return n
}
if t.Chan&Csend == 0 {
Yyerror("invalid operation: %v (cannot close receive-only channel)", n)
n.Type = nil
return
return n
}
ok |= Etop
......@@ -1535,19 +1543,19 @@ OpSwitch:
if args.Len() == 0 {
Yyerror("missing arguments to delete")
n.Type = nil
return
return n
}
if args.Len() == 1 {
Yyerror("missing second (key) argument to delete")
n.Type = nil
return
return n
}
if args.Len() != 2 {
Yyerror("too many arguments to delete")
n.Type = nil
return
return n
}
ok |= Etop
......@@ -1557,7 +1565,7 @@ OpSwitch:
if l.Type != nil && l.Type.Etype != TMAP {
Yyerror("first argument to delete must be map; have %v", Tconv(l.Type, FmtLong))
n.Type = nil
return
return n
}
args.SetIndex(1, assignconv(r, l.Type.Key(), "delete"))
......@@ -1569,11 +1577,11 @@ OpSwitch:
if args.Len() == 0 {
Yyerror("missing arguments to append")
n.Type = nil
return
return n
}
if args.Len() == 1 && !n.Isddd {
typecheck(args.Addr(0), Erv|Efnstruct)
args.SetIndex(0, typecheck(args.Index(0), Erv|Efnstruct))
} else {
typecheckslice(args.Slice(), Erv)
}
......@@ -1581,7 +1589,7 @@ OpSwitch:
t := args.First().Type
if t == nil {
n.Type = nil
return
return n
}
// Unpack multiple-return result before type-checking.
......@@ -1596,29 +1604,29 @@ OpSwitch:
if Isconst(args.First(), CTNIL) {
Yyerror("first argument to append must be typed slice; have untyped nil")
n.Type = nil
return
return n
}
Yyerror("first argument to append must be slice; have %v", Tconv(t, FmtLong))
n.Type = nil
return
return n
}
if n.Isddd {
if args.Len() == 1 {
Yyerror("cannot use ... on first argument to append")
n.Type = nil
return
return n
}
if args.Len() != 2 {
Yyerror("too many arguments to append")
n.Type = nil
return
return n
}
if Istype(t.Type, TUINT8) && Istype(args.Second().Type, TSTRING) {
defaultlit(args.Addr(1), Types[TSTRING])
args.SetIndex(1, defaultlit(args.Index(1), Types[TSTRING]))
break OpSwitch
}
......@@ -1651,30 +1659,30 @@ OpSwitch:
if args.Len() < 2 {
Yyerror("missing arguments to copy")
n.Type = nil
return
return n
}
if args.Len() > 2 {
Yyerror("too many arguments to copy")
n.Type = nil
return
return n
}
n.Left = args.First()
n.Right = args.Second()
n.List.Set(nil)
n.Type = Types[TINT]
typecheck(&n.Left, Erv)
typecheck(&n.Right, Erv)
n.Left = typecheck(n.Left, Erv)
n.Right = typecheck(n.Right, Erv)
if n.Left.Type == nil || n.Right.Type == nil {
n.Type = nil
return
return n
}
defaultlit(&n.Left, nil)
defaultlit(&n.Right, nil)
n.Left = defaultlit(n.Left, nil)
n.Right = defaultlit(n.Right, nil)
if n.Left.Type == nil || n.Right.Type == nil {
n.Type = nil
return
return n
}
// copy([]byte, string)
......@@ -1684,7 +1692,7 @@ OpSwitch:
}
Yyerror("arguments to copy have different element types: %v and string", Tconv(n.Left.Type, FmtLong))
n.Type = nil
return
return n
}
if !Isslice(n.Left.Type) || !Isslice(n.Right.Type) {
......@@ -1696,13 +1704,13 @@ OpSwitch:
Yyerror("second argument to copy should be slice or string; have %v", Tconv(n.Right.Type, FmtLong))
}
n.Type = nil
return
return n
}
if !Eqtype(n.Left.Type.Type, n.Right.Type.Type) {
Yyerror("arguments to copy have different element types: %v and %v", Tconv(n.Left.Type, FmtLong), Tconv(n.Right.Type, FmtLong))
n.Type = nil
return
return n
}
break OpSwitch
......@@ -1710,12 +1718,12 @@ OpSwitch:
case OCONV:
ok |= Erv
saveorignode(n)
typecheck(&n.Left, Erv|top&(Eindir|Eiota))
convlit1(&n.Left, n.Type, true)
n.Left = typecheck(n.Left, Erv|top&(Eindir|Eiota))
n.Left = convlit1(n.Left, n.Type, true)
t := n.Left.Type
if t == nil || n.Type == nil {
n.Type = nil
return
return n
}
var why string
n.Op = convertop(t, n.Type, &why)
......@@ -1746,7 +1754,7 @@ OpSwitch:
case OSTRARRAYRUNE:
if n.Left.Op == OLITERAL {
stringtoarraylit(&n)
n = stringtoarraylit(n)
}
}
......@@ -1758,16 +1766,16 @@ OpSwitch:
if len(args) == 0 {
Yyerror("missing argument to make")
n.Type = nil
return
return n
}
n.List.Set(nil)
l := args[0]
typecheck(&l, Etype)
l = typecheck(l, Etype)
t := l.Type
if t == nil {
n.Type = nil
return
return n
}
i := 1
......@@ -1775,43 +1783,43 @@ OpSwitch:
default:
Yyerror("cannot make type %v", t)
n.Type = nil
return
return n
case TARRAY:
if !Isslice(t) {
Yyerror("cannot make type %v", t)
n.Type = nil
return
return n
}
if i >= len(args) {
Yyerror("missing len argument to make(%v)", t)
n.Type = nil
return
return n
}
l = args[i]
i++
typecheck(&l, Erv)
l = typecheck(l, Erv)
var r *Node
if i < len(args) {
r = args[i]
i++
typecheck(&r, Erv)
r = typecheck(r, Erv)
}
if l.Type == nil || (r != nil && r.Type == nil) {
n.Type = nil
return
return n
}
if !checkmake(t, "len", l) || r != nil && !checkmake(t, "cap", r) {
n.Type = nil
return
return n
}
if Isconst(l, CTINT) && r != nil && Isconst(r, CTINT) && l.Val().U.(*Mpint).Cmp(r.Val().U.(*Mpint)) > 0 {
Yyerror("len larger than cap in make(%v)", t)
n.Type = nil
return
return n
}
n.Left = l
......@@ -1822,15 +1830,15 @@ OpSwitch:
if i < len(args) {
l = args[i]
i++
typecheck(&l, Erv)
defaultlit(&l, Types[TINT])
l = typecheck(l, Erv)
l = defaultlit(l, Types[TINT])
if l.Type == nil {
n.Type = nil
return
return n
}
if !checkmake(t, "size", l) {
n.Type = nil
return
return n
}
n.Left = l
} else {
......@@ -1843,15 +1851,15 @@ OpSwitch:
if i < len(args) {
l = args[i]
i++
typecheck(&l, Erv)
defaultlit(&l, Types[TINT])
l = typecheck(l, Erv)
l = defaultlit(l, Types[TINT])
if l.Type == nil {
n.Type = nil
return
return n
}
if !checkmake(t, "buffer", l) {
n.Type = nil
return
return n
}
n.Left = l
} else {
......@@ -1864,7 +1872,7 @@ OpSwitch:
Yyerror("too many arguments to make(%v)", t)
n.Op = OMAKE
n.Type = nil
return
return n
}
n.Type = t
......@@ -1876,20 +1884,20 @@ OpSwitch:
if args.Len() == 0 {
Yyerror("missing argument to new")
n.Type = nil
return
return n
}
l := args.First()
typecheck(&l, Etype)
l = typecheck(l, Etype)
t := l.Type
if t == nil {
n.Type = nil
return
return n
}
if args.Len() > 1 {
Yyerror("too many arguments to new(%v)", t)
n.Type = nil
return
return n
}
n.Left = l
......@@ -1903,9 +1911,9 @@ OpSwitch:
for i1, n1 := range ls {
// Special case for print: int constant is int64, not int.
if Isconst(n1, CTINT) {
defaultlit(&ls[i1], Types[TINT64])
ls[i1] = defaultlit(ls[i1], Types[TINT64])
} else {
defaultlit(&ls[i1], nil)
ls[i1] = defaultlit(ls[i1], nil)
}
}
......@@ -1915,13 +1923,13 @@ OpSwitch:
ok |= Etop
if !onearg(n, "panic") {
n.Type = nil
return
return n
}
typecheck(&n.Left, Erv)
defaultlit(&n.Left, Types[TINTER])
n.Left = typecheck(n.Left, Erv)
n.Left = defaultlit(n.Left, Types[TINTER])
if n.Left.Type == nil {
n.Type = nil
return
return n
}
break OpSwitch
......@@ -1930,7 +1938,7 @@ OpSwitch:
if n.List.Len() != 0 {
Yyerror("too many arguments to recover")
n.Type = nil
return
return n
}
n.Type = Types[TINTER]
......@@ -1941,17 +1949,17 @@ OpSwitch:
typecheckclosure(n, top)
if n.Type == nil {
n.Type = nil
return
return n
}
break OpSwitch
case OITAB:
ok |= Erv
typecheck(&n.Left, Erv)
n.Left = typecheck(n.Left, Erv)
t := n.Left.Type
if t == nil {
n.Type = nil
return
return n
}
if t.Etype != TINTER {
Fatalf("OITAB of %v", t)
......@@ -1961,11 +1969,11 @@ OpSwitch:
case OSPTR:
ok |= Erv
typecheck(&n.Left, Erv)
n.Left = typecheck(n.Left, Erv)
t := n.Left.Type
if t == nil {
n.Type = nil
return
return n
}
if !Isslice(t) && t.Etype != TSTRING {
Fatalf("OSPTR of %v", t)
......@@ -1983,13 +1991,13 @@ OpSwitch:
case OCFUNC:
ok |= Erv
typecheck(&n.Left, Erv)
n.Left = typecheck(n.Left, Erv)
n.Type = Types[TUINTPTR]
break OpSwitch
case OCONVNOP:
ok |= Erv
typecheck(&n.Left, Erv)
n.Left = typecheck(n.Left, Erv)
break OpSwitch
// statements
......@@ -2027,7 +2035,7 @@ OpSwitch:
case ODEFER:
ok |= Etop
typecheck(&n.Left, Etop|Erv)
n.Left = typecheck(n.Left, Etop|Erv)
if n.Left.Diag == 0 {
checkdefergo(n)
}
......@@ -2035,7 +2043,7 @@ OpSwitch:
case OPROC:
ok |= Etop
typecheck(&n.Left, Etop|Eproc|Erv)
n.Left = typecheck(n.Left, Etop|Eproc|Erv)
checkdefergo(n)
break OpSwitch
......@@ -2043,14 +2051,14 @@ OpSwitch:
ok |= Etop
typecheckslice(n.Ninit.Slice(), Etop)
decldepth++
typecheck(&n.Left, Erv)
n.Left = typecheck(n.Left, Erv)
if n.Left != nil {
t := n.Left.Type
if t != nil && t.Etype != TBOOL {
Yyerror("non-bool %v used as for condition", Nconv(n.Left, FmtLong))
}
}
typecheck(&n.Right, Etop)
n.Right = typecheck(n.Right, Etop)
typecheckslice(n.Nbody.Slice(), Etop)
decldepth--
break OpSwitch
......@@ -2058,7 +2066,7 @@ OpSwitch:
case OIF:
ok |= Etop
typecheckslice(n.Ninit.Slice(), Etop)
typecheck(&n.Left, Erv)
n.Left = typecheck(n.Left, Erv)
if n.Left != nil {
t := n.Left.Type
if t != nil && t.Etype != TBOOL {
......@@ -2079,7 +2087,7 @@ OpSwitch:
if Curfn == nil {
Yyerror("return outside function")
n.Type = nil
return
return n
}
if Curfn.Type.Outnamed && n.List.Len() == 0 {
......@@ -2110,7 +2118,7 @@ OpSwitch:
case OTYPESW:
Yyerror("use of .(type) outside type switch")
n.Type = nil
return
return n
case OXCASE:
ok |= Etop
......@@ -2125,12 +2133,12 @@ OpSwitch:
case ODCLCONST:
ok |= Etop
typecheck(&n.Left, Erv)
n.Left = typecheck(n.Left, Erv)
break OpSwitch
case ODCLTYPE:
ok |= Etop
typecheck(&n.Left, Etype)
n.Left = typecheck(n.Left, Etype)
if incannedimport == 0 {
checkwidth(n.Left.Type)
}
......@@ -2161,20 +2169,20 @@ OpSwitch:
if n.Op == OTYPE && top&Etype == 0 {
Yyerror("type %v is not an expression", n.Type)
n.Type = nil
return
return n
}
if top&(Erv|Etype) == Etype && n.Op != OTYPE {
Yyerror("%v is not a type", n)
n.Type = nil
return
return n
}
// TODO(rsc): simplify
if (top&(Ecall|Erv|Etype) != 0) && top&Etop == 0 && ok&(Erv|Etype|Ecall) == 0 {
Yyerror("%v used as value", n)
n.Type = nil
return
return n
}
if (top&Etop != 0) && top&(Ecall|Erv|Etype) == 0 && ok&Etop == 0 {
......@@ -2184,13 +2192,14 @@ OpSwitch:
}
n.Type = nil
return
return n
}
/* TODO
if(n->type == T)
fatal("typecheck nil type");
*/
return n
}
func checksliceindex(l *Node, r *Node, tp *Type) bool {
......@@ -2285,25 +2294,25 @@ func checkdefergo(n *Node) {
}
}
func implicitstar(nn **Node) {
// The result of implicitstar MUST be assigned back to n, e.g.
// n.Left = implicitstar(n.Left)
func implicitstar(n *Node) *Node {
// insert implicit * if needed for fixed array
n := *nn
t := n.Type
if t == nil || !Isptr[t.Etype] {
return
return n
}
t = t.Type
if t == nil {
return
return n
}
if !Isfixedarray(t) {
return
return n
}
n = Nod(OIND, n, nil)
n.Implicit = true
typecheck(&n, Erv)
*nn = n
n = typecheck(n, Erv)
return n
}
func onearg(n *Node, f string, args ...interface{}) bool {
......@@ -2482,7 +2491,7 @@ func lookdot(n *Node, t *Type, dostrcmp int) *Field {
if Isptr[n.Left.Type.Etype] {
n.Left = Nod(OIND, n.Left, nil) // implicitstar
n.Left.Implicit = true
typecheck(&n.Left, Erv)
n.Left = typecheck(n.Left, Erv)
}
n.Op = ODOTINTER
......@@ -2504,11 +2513,11 @@ func lookdot(n *Node, t *Type, dostrcmp int) *Field {
checklvalue(n.Left, "call pointer method on")
n.Left = Nod(OADDR, n.Left, nil)
n.Left.Implicit = true
typecheck(&n.Left, Etype|Erv)
n.Left = typecheck(n.Left, Etype|Erv)
} else if tt.Etype == Tptr && rcvr.Etype != Tptr && Eqtype(tt.Type, rcvr) {
n.Left = Nod(OIND, n.Left, nil)
n.Left.Implicit = true
typecheck(&n.Left, Etype|Erv)
n.Left = typecheck(n.Left, Etype|Erv)
} else if tt.Etype == Tptr && tt.Type.Etype == Tptr && Eqtype(derefall(tt), derefall(rcvr)) {
Yyerror("calling method %v with receiver %v requires explicit dereference", n.Sym, Nconv(n.Left, FmtLong))
for tt.Etype == Tptr {
......@@ -2518,7 +2527,7 @@ func lookdot(n *Node, t *Type, dostrcmp int) *Field {
}
n.Left = Nod(OIND, n.Left, nil)
n.Left.Implicit = true
typecheck(&n.Left, Etype|Erv)
n.Left = typecheck(n.Left, Etype|Erv)
tt = tt.Type
}
} else {
......@@ -2867,7 +2876,7 @@ func pushtype(n *Node, t *Type) {
n.Implicit = true // don't print
n.Right.Implicit = true // * is okay
} else if Debug['s'] != 0 {
typecheck(&n.Right, Etype)
n.Right = typecheck(n.Right, Etype)
if n.Right.Type != nil && Eqtype(n.Right.Type, t) {
fmt.Printf("%v: redundant type: %v\n", n.Line(), t)
}
......@@ -2879,12 +2888,12 @@ func pushtype(n *Node, t *Type) {
// TODO(mdempsky): Find a nicer solution.
var structkey = typ(Txxx)
func typecheckcomplit(np **Node) {
n := *np
// The result of typecheckcomplit MUST be assigned back to n, e.g.
// n.Left = typecheckcomplit(n.Left)
func typecheckcomplit(n *Node) *Node {
lno := lineno
defer func() {
lineno = lno
*np = n
}()
if n.Right == nil {
......@@ -2893,7 +2902,7 @@ func typecheckcomplit(np **Node) {
}
Yyerror("missing type in composite literal")
n.Type = nil
return
return n
}
// Save original node (including n->right)
......@@ -2902,11 +2911,12 @@ func typecheckcomplit(np **Node) {
*norig = *n
setlineno(n.Right)
l := typecheck(&n.Right, Etype|Ecomplit) // sic
n.Right = typecheck(n.Right, Etype|Ecomplit)
l := n.Right // sic
t := l.Type
if t == nil {
n.Type = nil
return
return n
}
nerr := nerrors
n.Type = t
......@@ -2917,14 +2927,14 @@ func typecheckcomplit(np **Node) {
if !n.Right.Implicit {
Yyerror("invalid pointer type %v for composite literal (use &%v instead)", t, t.Type)
n.Type = nil
return
return n
}
// Also, the underlying type must be a struct, map, slice, or array.
if !iscomptype(t) {
Yyerror("invalid pointer type %v for composite literal", t)
n.Type = nil
return
return n
}
t = t.Type
......@@ -2957,7 +2967,7 @@ func typecheckcomplit(np **Node) {
n.List.SetIndex(i2, l)
}
typecheck(&l.Left, Erv)
l.Left = typecheck(l.Left, Erv)
evconst(l.Left)
i = nonnegconst(l.Left)
if i < 0 && l.Left.Diag == 0 {
......@@ -2981,8 +2991,8 @@ func typecheckcomplit(np **Node) {
r = l.Right
pushtype(r, t.Type)
typecheck(&r, Erv)
defaultlit(&r, t.Type)
r = typecheck(r, Erv)
r = defaultlit(r, t.Type)
l.Right = assignconv(r, t.Type, "array or slice literal")
}
......@@ -3001,15 +3011,15 @@ func typecheckcomplit(np **Node) {
l = n3
setlineno(l)
if l.Op != OKEY {
typecheck(n.List.Addr(i3), Erv)
n.List.SetIndex(i3, typecheck(n.List.Index(i3), Erv))
Yyerror("missing key in map literal")
continue
}
r = l.Left
pushtype(r, t.Key())
typecheck(&r, Erv)
defaultlit(&r, t.Key())
r = typecheck(r, Erv)
r = defaultlit(r, t.Key())
l.Left = assignconv(r, t.Key(), "map key")
if l.Left.Op != OCONV {
keydup(l.Left, hash)
......@@ -3017,8 +3027,8 @@ func typecheckcomplit(np **Node) {
r = l.Right
pushtype(r, t.Type)
typecheck(&r, Erv)
defaultlit(&r, t.Type)
r = typecheck(r, Erv)
r = defaultlit(r, t.Type)
l.Right = assignconv(r, t.Type, "map value")
}
......@@ -3037,7 +3047,7 @@ func typecheckcomplit(np **Node) {
ls := n.List.Slice()
for i1, n1 := range ls {
setlineno(n1)
typecheck(&ls[i1], Erv)
ls[i1] = typecheck(ls[i1], Erv)
n1 = ls[i1]
if f == nil {
if bad == 0 {
......@@ -3076,14 +3086,14 @@ func typecheckcomplit(np **Node) {
Yyerror("mixture of field:value and value initializers")
}
bad++
typecheck(&ls[i], Erv)
ls[i] = typecheck(ls[i], Erv)
continue
}
s := l.Left.Sym
if s == nil {
Yyerror("invalid field name %v in struct initializer", l.Left)
typecheck(&l.Right, Erv)
l.Right = typecheck(l.Right, Erv)
continue
}
......@@ -3112,7 +3122,7 @@ func typecheckcomplit(np **Node) {
r = l.Right
// No pushtype allowed here. Tried and rejected.
typecheck(&r, Erv)
r = typecheck(r, Erv)
l.Right = assignconv(r, f.Type, "field value")
}
......@@ -3123,7 +3133,7 @@ func typecheckcomplit(np **Node) {
if nerr != nerrors {
n.Type = nil
return
return n
}
n.Orig = norig
......@@ -3136,7 +3146,7 @@ func typecheckcomplit(np **Node) {
}
n.Orig = norig
return
return n
}
// lvalue etc
......@@ -3252,10 +3262,10 @@ func typecheckas(n *Node) {
n.Left = resolve(n.Left)
if n.Left.Name == nil || n.Left.Name.Defn != n || n.Left.Name.Param.Ntype != nil {
typecheck(&n.Left, Erv|Easgn)
n.Left = typecheck(n.Left, Erv|Easgn)
}
typecheck(&n.Right, Erv)
n.Right = typecheck(n.Right, Erv)
checkassign(n, n.Left)
if n.Right != nil && n.Right.Type != nil {
if n.Left.Type != nil {
......@@ -3264,7 +3274,7 @@ func typecheckas(n *Node) {
}
if n.Left.Name != nil && n.Left.Name.Defn == n && n.Left.Name.Param.Ntype == nil {
defaultlit(&n.Right, nil)
n.Right = defaultlit(n.Right, nil)
n.Left.Type = n.Right.Type
}
......@@ -3274,7 +3284,7 @@ func typecheckas(n *Node) {
n.Typecheck = 1
if n.Left.Typecheck == 0 {
typecheck(&n.Left, Erv|Easgn)
n.Left = typecheck(n.Left, Erv|Easgn)
}
}
......@@ -3295,14 +3305,14 @@ func typecheckas2(n *Node) {
ls[i1] = n1
if n1.Name == nil || n1.Name.Defn != n || n1.Name.Param.Ntype != nil {
typecheck(&ls[i1], Erv|Easgn)
ls[i1] = typecheck(ls[i1], Erv|Easgn)
}
}
cl := n.List.Len()
cr := n.Rlist.Len()
if cl > 1 && cr == 1 {
typecheck(n.Rlist.Addr(0), Erv|Efnstruct)
n.Rlist.SetIndex(0, typecheck(n.Rlist.Index(0), Erv|Efnstruct))
} else {
typecheckslice(n.Rlist.Slice(), Erv)
}
......@@ -3320,7 +3330,7 @@ func typecheckas2(n *Node) {
rs[il] = assignconv(nr, nl.Type, "assignment")
}
if nl.Name != nil && nl.Name.Defn == n && nl.Name.Param.Ntype == nil {
defaultlit(&rs[il], nil)
rs[il] = defaultlit(rs[il], nil)
nl.Type = rs[il].Type
}
}
......@@ -3406,14 +3416,14 @@ out:
ls = n.List.Slice()
for i1, n1 := range ls {
if n1.Typecheck == 0 {
typecheck(&ls[i1], Erv|Easgn)
ls[i1] = typecheck(ls[i1], Erv|Easgn)
}
}
}
// type check function definition
func typecheckfunc(n *Node) {
typecheck(&n.Func.Nname, Erv|Easgn)
n.Func.Nname = typecheck(n.Func.Nname, Erv|Easgn)
t := n.Func.Nname.Type
if t == nil {
return
......@@ -3432,8 +3442,9 @@ func typecheckfunc(n *Node) {
}
}
func stringtoarraylit(np **Node) {
n := *np
// The result of stringtoarraylit MUST be assigned back to n, e.g.
// n.Left = stringtoarraylit(n.Left)
func stringtoarraylit(n *Node) *Node {
if n.Left.Op != OLITERAL || n.Left.Val().Ctype() != CTSTR {
Fatalf("stringtoarraylit %v", n)
}
......@@ -3456,8 +3467,8 @@ func stringtoarraylit(np **Node) {
nn := Nod(OCOMPLIT, nil, typenod(n.Type))
nn.List.Set(l)
typecheck(&nn, Erv)
*np = nn
nn = typecheck(nn, Erv)
return nn
}
var ntypecheckdeftype int
......@@ -3466,7 +3477,7 @@ var methodqueue []*Node
func domethod(n *Node) {
nt := n.Type.Nname
typecheck(&nt, Etype)
nt = typecheck(nt, Etype)
if nt.Type == nil {
// type check failed; leave empty func
// TODO(mdempsky): Fix Type rekinding.
......@@ -3555,7 +3566,7 @@ func typecheckdeftype(n *Node) {
setlineno(n)
n.Type.Sym = n.Sym
n.Typecheck = 1
typecheck(&n.Name.Param.Ntype, Etype)
n.Name.Param.Ntype = typecheck(n.Name.Param.Ntype, Etype)
t := n.Name.Param.Ntype.Type
if t == nil {
n.Diag = 1
......@@ -3663,7 +3674,7 @@ func typecheckdef(n *Node) *Node {
case OLITERAL:
if n.Name.Param.Ntype != nil {
typecheck(&n.Name.Param.Ntype, Etype)
n.Name.Param.Ntype = typecheck(n.Name.Param.Ntype, Etype)
n.Type = n.Name.Param.Ntype.Type
n.Name.Param.Ntype = nil
if n.Type == nil {
......@@ -3680,7 +3691,7 @@ func typecheckdef(n *Node) *Node {
Yyerror("xxx")
}
typecheck(&e, Erv|Eiota)
e = typecheck(e, Erv|Eiota)
if Isconst(e, CTNIL) {
Yyerror("const initializer cannot be nil")
goto ret
......@@ -3707,7 +3718,7 @@ func typecheckdef(n *Node) *Node {
goto ret
}
convlit(&e, t)
e = convlit(e, t)
}
n.SetVal(e.Val())
......@@ -3715,7 +3726,7 @@ func typecheckdef(n *Node) *Node {
case ONAME:
if n.Name.Param.Ntype != nil {
typecheck(&n.Name.Param.Ntype, Etype)
n.Name.Param.Ntype = typecheck(n.Name.Param.Ntype, Etype)
n.Type = n.Name.Param.Ntype.Type
if n.Type == nil {
n.Diag = 1
......@@ -3742,12 +3753,12 @@ func typecheckdef(n *Node) *Node {
}
if n.Name.Defn.Op == ONAME {
typecheck(&n.Name.Defn, Erv)
n.Name.Defn = typecheck(n.Name.Defn, Erv)
n.Type = n.Name.Defn.Type
break
}
typecheck(&n.Name.Defn, Etop) // fills in n->type
n.Name.Defn = typecheck(n.Name.Defn, Etop) // fills in n->type
case OTYPE:
if Curfn != nil {
......@@ -3806,7 +3817,7 @@ func checkmake(t *Type, arg string, n *Node) bool {
// Delay defaultlit until after we've checked range, to avoid
// a redundant "constant NNN overflows int" error.
defaultlit(&n, Types[TINT])
n = defaultlit(n, Types[TINT])
return true
......@@ -3821,7 +3832,7 @@ func checkmake(t *Type, arg string, n *Node) bool {
}
// Defaultlit still necessary for non-constant: n might be 1<<k.
defaultlit(&n, Types[TINT])
n = defaultlit(n, Types[TINT])
return true
}
......
src/cmd/compile/internal/gc/unsafe.go
View file @ 34699bc7
......@@ -30,8 +30,8 @@ func unsafenmagic(nn *Node) *Node {
var v int64
switch s.Name {
case "Alignof", "Sizeof":
typecheck(&r, Erv)
defaultlit(&r, nil)
r = typecheck(r, Erv)
r = defaultlit(r, nil)
tr := r.Type
if tr == nil {
goto bad
......@@ -52,10 +52,10 @@ func unsafenmagic(nn *Node) *Node {
// Remember base of selector to find it back after dot insertion.
// Since r->left may be mutated by typechecking, check it explicitly
// first to track it correctly.
typecheck(&r.Left, Erv)
r.Left = typecheck(r.Left, Erv)
base := r.Left
typecheck(&r, Erv)
r = typecheck(r, Erv)
switch r.Op {
case ODOT, ODOTPTR:
break
......
src/cmd/compile/internal/gc/walk.go
View file @ 34699bc7
......@@ -29,7 +29,7 @@ func walk(fn *Node) {
// It's hard to be on the heap when not-used, but best to be consistent about &~PHEAP here and below.
for i, ln := range fn.Func.Dcl {
if ln.Op == ONAME && ln.Class&^PHEAP == PAUTO {
typecheck(&ln, Erv|Easgn)
ln = typecheck(ln, Erv|Easgn)
fn.Func.Dcl[i] = ln
}
}
......@@ -77,7 +77,7 @@ func walk(fn *Node) {
func walkstmtlist(s []*Node) {
for i := range s {
walkstmt(&s[i])
s[i] = walkstmt(s[i])
}
}
......@@ -139,13 +139,14 @@ func adjustargs(n *Node, adjust int) {
}
}
func walkstmt(np **Node) {
n := *np
// The result of walkstmt MUST be assigned back to n, e.g.
// n.Left = walkstmt(n.Left)
func walkstmt(n *Node) *Node {
if n == nil {
return
return n
}
if n.Dodata == 2 { // don't walk, generated by anylit.
return
return n
}
setlineno(n)
......@@ -185,11 +186,12 @@ func walkstmt(np **Node) {
if n.Typecheck == 0 {
Fatalf("missing typecheck: %v", Nconv(n, FmtSign))
}
wascopy := n.Op == OCOPY
init := n.Ninit
n.Ninit.Set(nil)
walkexpr(&n, &init)
addinit(&n, init.Slice())
if (*np).Op == OCOPY && n.Op == OCONVNOP {
n = walkexpr(n, &init)
n = addinit(n, init.Slice())
if wascopy && n.Op == OCONVNOP {
n.Op = OEMPTY // don't leave plain values as statements.
}
......@@ -202,11 +204,11 @@ func walkstmt(np **Node) {
init := n.Ninit
n.Ninit.Set(nil)
walkexpr(&n.Left, &init)
n.Left = walkexpr(n.Left, &init)
n = mkcall1(chanfn("chanrecv1", 2, n.Left.Type), nil, &init, typename(n.Left.Type), n.Left, nodnil())
walkexpr(&n, &init)
n = walkexpr(n, &init)
addinit(&n, init.Slice())
n = addinit(n, init.Slice())
case OBREAK,
ODCL,
......@@ -230,19 +232,19 @@ func walkstmt(np **Node) {
fallthrough
case OCASE:
walkstmt(&n.Right)
n.Right = walkstmt(n.Right)
case ODEFER:
hasdefer = true
switch n.Left.Op {
case OPRINT, OPRINTN:
walkprintfunc(&n.Left, &n.Ninit)
n.Left = walkprintfunc(n.Left, &n.Ninit)
case OCOPY:
n.Left = copyany(n.Left, &n.Ninit, true)
default:
walkexpr(&n.Left, &n.Ninit)
n.Left = walkexpr(n.Left, &n.Ninit)
}
// make room for size & fn arguments.
......@@ -253,28 +255,28 @@ func walkstmt(np **Node) {
walkstmtlist(n.Left.Ninit.Slice())
init := n.Left.Ninit
n.Left.Ninit.Set(nil)
walkexpr(&n.Left, &init)
addinit(&n.Left, init.Slice())
n.Left = walkexpr(n.Left, &init)
n.Left = addinit(n.Left, init.Slice())
}
walkstmt(&n.Right)
n.Right = walkstmt(n.Right)
walkstmtlist(n.Nbody.Slice())
case OIF:
walkexpr(&n.Left, &n.Ninit)
n.Left = walkexpr(n.Left, &n.Ninit)
walkstmtlist(n.Nbody.Slice())
walkstmtlist(n.Rlist.Slice())
case OPROC:
switch n.Left.Op {
case OPRINT, OPRINTN:
walkprintfunc(&n.Left, &n.Ninit)
n.Left = walkprintfunc(n.Left, &n.Ninit)
case OCOPY:
n.Left = copyany(n.Left, &n.Ninit, true)
default:
walkexpr(&n.Left, &n.Ninit)
n.Left = walkexpr(n.Left, &n.Ninit)
}
// make room for size & fn arguments.
......@@ -349,8 +351,7 @@ func walkstmt(np **Node) {
if n.Op == ONAME {
Fatalf("walkstmt ended up with name: %v", Nconv(n, FmtSign))
}
*np = n
return n
}
func isSmallMakeSlice(n *Node) bool {
......@@ -374,21 +375,21 @@ func isSmallMakeSlice(n *Node) bool {
// complex side effects like statements are appended to init
func walkexprlist(s []*Node, init *Nodes) {
for i := range s {
walkexpr(&s[i], init)
s[i] = walkexpr(s[i], init)
}
}
func walkexprlistsafe(s []*Node, init *Nodes) {
for i, n := range s {
s[i] = safeexpr(n, init)
walkexpr(&s[i], init)
s[i] = walkexpr(s[i], init)
}
}
func walkexprlistcheap(s []*Node, init *Nodes) {
for i, n := range s {
s[i] = cheapexpr(n, init)
walkexpr(&s[i], init)
s[i] = walkexpr(s[i], init)
}
}
......@@ -449,11 +450,11 @@ func assertFuncName(from, to *Type, with2suffix bool) string {
panic("unreachable")
}
func walkexpr(np **Node, init *Nodes) {
n := *np
// The result of walkexpr MUST be assigned back to n, e.g.
// n.Left = walkexpr(n.Left, init)
func walkexpr(n *Node, init *Nodes) *Node {
if n == nil {
return
return n
}
if init == &n.Ninit {
......@@ -470,9 +471,9 @@ func walkexpr(np **Node, init *Nodes) {
// annoying case - not typechecked
if n.Op == OKEY {
walkexpr(&n.Left, init)
walkexpr(&n.Right, init)
return
n.Left = walkexpr(n.Left, init)
n.Right = walkexpr(n.Right, init)
return n
}
lno := setlineno(n)
......@@ -506,14 +507,14 @@ opswitch:
OIMAG,
ODOTMETH,
ODOTINTER:
walkexpr(&n.Left, init)
n.Left = walkexpr(n.Left, init)
case OIND:
walkexpr(&n.Left, init)
n.Left = walkexpr(n.Left, init)
case ODOT:
usefield(n)
walkexpr(&n.Left, init)
n.Left = walkexpr(n.Left, init)
case ODOTPTR:
usefield(n)
......@@ -524,17 +525,17 @@ opswitch:
checknil(n.Left, init)
}
walkexpr(&n.Left, init)
n.Left = walkexpr(n.Left, init)
case OEFACE:
walkexpr(&n.Left, init)
walkexpr(&n.Right, init)
n.Left = walkexpr(n.Left, init)
n.Right = walkexpr(n.Right, init)
case OSPTR, OITAB:
walkexpr(&n.Left, init)
n.Left = walkexpr(n.Left, init)
case OLEN, OCAP:
walkexpr(&n.Left, init)
n.Left = walkexpr(n.Left, init)
// replace len(*[10]int) with 10.
// delayed until now to preserve side effects.
......@@ -550,8 +551,8 @@ opswitch:
}
case OLSH, ORSH:
walkexpr(&n.Left, init)
walkexpr(&n.Right, init)
n.Left = walkexpr(n.Left, init)
n.Right = walkexpr(n.Right, init)
t := n.Left.Type
n.Bounded = bounded(n.Right, 8*t.Width)
if Debug['m'] != 0 && n.Etype != 0 && !Isconst(n.Right, CTINT) {
......@@ -574,17 +575,17 @@ opswitch:
n.Right = n.List.Second()
}
walkexpr(&n.Left, init)
walkexpr(&n.Right, init)
n.Left = walkexpr(n.Left, init)
n.Right = walkexpr(n.Right, init)
case OOR, OXOR:
walkexpr(&n.Left, init)
walkexpr(&n.Right, init)
walkrotate(&n)
n.Left = walkexpr(n.Left, init)
n.Right = walkexpr(n.Right, init)
n = walkrotate(n)
case OEQ, ONE:
walkexpr(&n.Left, init)
walkexpr(&n.Right, init)
n.Left = walkexpr(n.Left, init)
n.Right = walkexpr(n.Right, init)
// Disable safemode while compiling this code: the code we
// generate internally can refer to unsafe.Pointer.
......@@ -594,19 +595,19 @@ opswitch:
old_safemode := safemode
safemode = 0
walkcompare(&n, init)
n = walkcompare(n, init)
safemode = old_safemode
case OANDAND, OOROR:
walkexpr(&n.Left, init)
n.Left = walkexpr(n.Left, init)
// cannot put side effects from n.Right on init,
// because they cannot run before n.Left is checked.
// save elsewhere and store on the eventual n.Right.
var ll Nodes
walkexpr(&n.Right, &ll)
addinit(&n.Right, ll.Slice())
n.Right = walkexpr(n.Right, &ll)
n.Right = addinit(n.Right, ll.Slice())
case OPRINT, OPRINTN:
walkexprlist(n.List.Slice(), init)
......@@ -635,7 +636,7 @@ opswitch:
if n.List.Len() != 0 && n.List.First().Op == OAS {
break
}
walkexpr(&n.Left, init)
n.Left = walkexpr(n.Left, init)
walkexprlist(n.List.Slice(), init)
ll := ascompatte(n.Op, n, n.Isddd, t.Params(), n.List.Slice(), 0, init)
n.List.Set(reorder1(ll))
......@@ -667,7 +668,7 @@ opswitch:
break
}
walkexpr(&n.Left, init)
n.Left = walkexpr(n.Left, init)
walkexprlist(n.List.Slice(), init)
if n.Left.Op == ONAME && n.Left.Sym.Name == "Sqrt" && n.Left.Sym.Pkg.Path == "math" {
......@@ -688,7 +689,7 @@ opswitch:
if n.List.Len() != 0 && n.List.First().Op == OAS {
break
}
walkexpr(&n.Left, init)
n.Left = walkexpr(n.Left, init)
walkexprlist(n.List.Slice(), init)
ll := ascompatte(n.Op, n, false, t.Recvs(), []*Node{n.Left.Left}, 0, init)
lr := ascompatte(n.Op, n, n.Isddd, t.Params(), n.List.Slice(), 0, init)
......@@ -700,7 +701,7 @@ opswitch:
case OAS:
init.AppendNodes(&n.Ninit)
walkexpr(&n.Left, init)
n.Left = walkexpr(n.Left, init)
n.Left = safeexpr(n.Left, init)
if oaslit(n, init) {
......@@ -713,7 +714,7 @@ opswitch:
switch n.Right.Op {
default:
walkexpr(&n.Right, init)
n.Right = walkexpr(n.Right, init)
case ODOTTYPE:
// TODO(rsc): The Isfat is for consistency with componentgen and orderexpr.
......@@ -721,13 +722,13 @@ opswitch:
// That would allow inlining x.(struct{*int}) the same as x.(*int).
if isdirectiface(n.Right.Type) && !Isfat(n.Right.Type) && !instrumenting {
// handled directly during cgen
walkexpr(&n.Right, init)
n.Right = walkexpr(n.Right, init)
break
}
// x = i.(T); n.Left is x, n.Right.Left is i.
// orderstmt made sure x is addressable.
walkexpr(&n.Right.Left, init)
n.Right.Left = walkexpr(n.Right.Left, init)
n1 := Nod(OADDR, n.Left, nil)
r := n.Right // i.(T)
......@@ -737,21 +738,21 @@ opswitch:
}
fn := syslook(assertFuncName(r.Left.Type, r.Type, false))
substArgTypes(&fn, r.Left.Type, r.Type)
fn = substArgTypes(fn, r.Left.Type, r.Type)
n = mkcall1(fn, nil, init, typename(r.Type), r.Left, n1)
walkexpr(&n, init)
n = walkexpr(n, init)
break opswitch
case ORECV:
// x = <-c; n.Left is x, n.Right.Left is c.
// orderstmt made sure x is addressable.
walkexpr(&n.Right.Left, init)
n.Right.Left = walkexpr(n.Right.Left, init)
n1 := Nod(OADDR, n.Left, nil)
r := n.Right.Left // the channel
n = mkcall1(chanfn("chanrecv1", 2, r.Type), nil, init, typename(r.Type), r, n1)
walkexpr(&n, init)
n = walkexpr(n, init)
break opswitch
case OAPPEND:
......@@ -796,7 +797,7 @@ opswitch:
r := n.Rlist.First()
walkexprlistsafe(n.List.Slice(), init)
walkexpr(&r, init)
r = walkexpr(r, init)
ll := ascompatet(n.Op, n.List, r.Type, 0, init)
for i, n := range ll {
......@@ -811,7 +812,7 @@ opswitch:
r := n.Rlist.First()
walkexprlistsafe(n.List.Slice(), init)
walkexpr(&r.Left, init)
r.Left = walkexpr(r.Left, init)
var n1 *Node
if isblank(n.List.First()) {
n1 = nodnil()
......@@ -822,7 +823,7 @@ opswitch:
fn := chanfn("chanrecv2", 2, r.Left.Type)
r = mkcall1(fn, n.List.Second().Type, init, typename(r.Left.Type), r.Left, n1)
n = Nod(OAS, n.List.Second(), r)
typecheck(&n, Etop)
n = typecheck(n, Etop)
// a,b = m[i];
case OAS2MAPR:
......@@ -830,8 +831,8 @@ opswitch:
r := n.Rlist.First()
walkexprlistsafe(n.List.Slice(), init)
walkexpr(&r.Left, init)
walkexpr(&r.Right, init)
r.Left = walkexpr(r.Left, init)
r.Right = walkexpr(r.Right, init)
t := r.Left.Type
p := ""
if t.Type.Width <= 128 { // Check ../../runtime/hashmap.go:maxValueSize before changing.
......@@ -881,13 +882,13 @@ opswitch:
var_ := temp(Ptrto(t.Type))
var_.Typecheck = 1
n.List.SetIndex(0, var_)
walkexpr(&n, init)
n = walkexpr(n, init)
init.Append(n)
n = Nod(OAS, a, Nod(OIND, var_, nil))
}
typecheck(&n, Etop)
walkexpr(&n, init)
n = typecheck(n, Etop)
n = walkexpr(n, init)
// TODO: ptr is always non-nil, so disable nil check for this OIND op.
......@@ -895,8 +896,8 @@ opswitch:
init.AppendNodes(&n.Ninit)
map_ := n.List.First()
key := n.List.Second()
walkexpr(&map_, init)
walkexpr(&key, init)
map_ = walkexpr(map_, init)
key = walkexpr(key, init)
// orderstmt made sure key is addressable.
key = Nod(OADDR, key, nil)
......@@ -912,7 +913,7 @@ opswitch:
if isdirectiface(e.Type) && !Isfat(e.Type) && !instrumenting {
// handled directly during gen.
walkexprlistsafe(n.List.Slice(), init)
walkexpr(&e.Left, init)
e.Left = walkexpr(e.Left, init)
break
}
......@@ -921,7 +922,7 @@ opswitch:
init.AppendNodes(&n.Ninit)
walkexprlistsafe(n.List.Slice(), init)
walkexpr(&e.Left, init)
e.Left = walkexpr(e.Left, init)
t := e.Type // T
from := e.Left // i
......@@ -955,7 +956,7 @@ opswitch:
Warn("type assertion (ok only) inlined")
}
n = Nod(OAS, ok, fast)
typecheck(&n, Etop)
n = typecheck(n, Etop)
break
}
}
......@@ -972,19 +973,19 @@ opswitch:
Warn("type assertion not inlined")
}
fn := syslook(assertFuncName(from.Type, t, true))
substArgTypes(&fn, from.Type, t)
fn = substArgTypes(fn, from.Type, t)
call := mkcall1(fn, oktype, init, typename(t), from, resptr)
n = Nod(OAS, ok, call)
typecheck(&n, Etop)
n = typecheck(n, Etop)
case ODOTTYPE, ODOTTYPE2:
if !isdirectiface(n.Type) || Isfat(n.Type) {
Fatalf("walkexpr ODOTTYPE") // should see inside OAS only
}
walkexpr(&n.Left, init)
n.Left = walkexpr(n.Left, init)
case OCONVIFACE:
walkexpr(&n.Left, init)
n.Left = walkexpr(n.Left, init)
// Optimize convT2E as a two-word copy when T is pointer-shaped.
if isnilinter(n.Type) && isdirectiface(n.Left.Type) {
......@@ -1032,20 +1033,20 @@ opswitch:
l := temp(Ptrto(Types[TUINT8]))
n1 := Nod(OAS, l, sym.Def)
typecheck(&n1, Etop)
n1 = typecheck(n1, Etop)
init.Append(n1)
fn := syslook("typ2Itab")
n1 = Nod(OCALL, fn, nil)
n1.List.Set(ll)
typecheck(&n1, Erv)
walkexpr(&n1, init)
n1 = typecheck(n1, Erv)
n1 = walkexpr(n1, init)
n2 := Nod(OIF, nil, nil)
n2.Left = Nod(OEQ, l, nodnil())
n2.Nbody.Set1(Nod(OAS, l, n1))
n2.Likely = -1
typecheck(&n2, Etop)
n2 = typecheck(n2, Etop)
init.Append(n2)
l = Nod(OEFACE, l, n.Left)
......@@ -1076,25 +1077,25 @@ opswitch:
// Allocate stack buffer for value stored in interface.
r = temp(n.Left.Type)
r = Nod(OAS, r, nil) // zero temp
typecheck(&r, Etop)
r = typecheck(r, Etop)
init.Append(r)
r = Nod(OADDR, r.Left, nil)
typecheck(&r, Erv)
r = typecheck(r, Erv)
}
ll = append(ll, r)
}
fn := syslook(convFuncName(n.Left.Type, n.Type))
if !Isinter(n.Left.Type) {
substArgTypes(&fn, n.Left.Type, n.Left.Type, n.Type)
fn = substArgTypes(fn, n.Left.Type, n.Left.Type, n.Type)
} else {
substArgTypes(&fn, n.Left.Type, n.Type)
fn = substArgTypes(fn, n.Left.Type, n.Type)
}
dowidth(fn.Type)
n = Nod(OCALL, fn, nil)
n.List.Set(ll)
typecheck(&n, Erv)
walkexpr(&n, init)
n = typecheck(n, Erv)
n = walkexpr(n, init)
case OCONV, OCONVNOP:
if Thearch.Thechar == '5' {
......@@ -1123,23 +1124,23 @@ opswitch:
}
}
walkexpr(&n.Left, init)
n.Left = walkexpr(n.Left, init)
case OANDNOT:
walkexpr(&n.Left, init)
n.Left = walkexpr(n.Left, init)
n.Op = OAND
n.Right = Nod(OCOM, n.Right, nil)
typecheck(&n.Right, Erv)
walkexpr(&n.Right, init)
n.Right = typecheck(n.Right, Erv)
n.Right = walkexpr(n.Right, init)
case OMUL:
walkexpr(&n.Left, init)
walkexpr(&n.Right, init)
walkmul(&n, init)
n.Left = walkexpr(n.Left, init)
n.Right = walkexpr(n.Right, init)
n = walkmul(n, init)
case ODIV, OMOD:
walkexpr(&n.Left, init)
walkexpr(&n.Right, init)
n.Left = walkexpr(n.Left, init)
n.Right = walkexpr(n.Right, init)
// rewrite complex div into function call.
et := n.Left.Type.Etype
......@@ -1157,7 +1158,7 @@ opswitch:
}
// Try rewriting as shifts or magic multiplies.
walkdiv(&n, init)
n = walkdiv(n, init)
// rewrite 64-bit div and mod into function calls
// on 32-bit architectures.
......@@ -1181,13 +1182,13 @@ opswitch:
}
case OINDEX:
walkexpr(&n.Left, init)
n.Left = walkexpr(n.Left, init)
// save the original node for bounds checking elision.
// If it was a ODIV/OMOD walk might rewrite it.
r := n.Right
walkexpr(&n.Right, init)
n.Right = walkexpr(n.Right, init)
// if range of type cannot exceed static array bound,
// disable bounds check.
......@@ -1236,8 +1237,8 @@ opswitch:
if n.Etype == 1 {
break
}
walkexpr(&n.Left, init)
walkexpr(&n.Right, init)
n.Left = walkexpr(n.Left, init)
n.Right = walkexpr(n.Right, init)
t := n.Left.Type
p := ""
......@@ -1273,24 +1274,24 @@ opswitch:
Fatalf("walkexpr ORECV") // should see inside OAS only
case OSLICE, OSLICEARR, OSLICESTR:
walkexpr(&n.Left, init)
walkexpr(&n.Right.Left, init)
n.Left = walkexpr(n.Left, init)
n.Right.Left = walkexpr(n.Right.Left, init)
if n.Right.Left != nil && iszero(n.Right.Left) {
// Reduce x[0:j] to x[:j].
n.Right.Left = nil
}
walkexpr(&n.Right.Right, init)
n.Right.Right = walkexpr(n.Right.Right, init)
n = reduceSlice(n)
case OSLICE3, OSLICE3ARR:
walkexpr(&n.Left, init)
walkexpr(&n.Right.Left, init)
n.Left = walkexpr(n.Left, init)
n.Right.Left = walkexpr(n.Right.Left, init)
if n.Right.Left != nil && iszero(n.Right.Left) {
// Reduce x[0:j:k] to x[:j:k].
n.Right.Left = nil
}
walkexpr(&n.Right.Right.Left, init)
walkexpr(&n.Right.Right.Right, init)
n.Right.Right.Left = walkexpr(n.Right.Right.Left, init)
n.Right.Right.Right = walkexpr(n.Right.Right.Right, init)
r := n.Right.Right.Right
if r != nil && r.Op == OCAP && samesafeexpr(n.Left, r.Left) {
......@@ -1305,7 +1306,7 @@ opswitch:
}
case OADDR:
walkexpr(&n.Left, init)
n.Left = walkexpr(n.Left, init)
case ONEW:
if n.Esc == EscNone {
......@@ -1314,10 +1315,10 @@ opswitch:
}
r := temp(n.Type.Type)
r = Nod(OAS, r, nil) // zero temp
typecheck(&r, Etop)
r = typecheck(r, Etop)
init.Append(r)
r = Nod(OADDR, r.Left, nil)
typecheck(&r, Erv)
r = typecheck(r, Erv)
n = r
} else {
n = callnew(n.Type.Type)
......@@ -1330,8 +1331,8 @@ opswitch:
if (Isconst(n.Left, CTSTR) && len(n.Left.Val().U.(string)) == 0) || (Isconst(n.Right, CTSTR) && len(n.Right.Val().U.(string)) == 0) {
// TODO(marvin): Fix Node.EType type union.
r := Nod(Op(n.Etype), Nod(OLEN, n.Left, nil), Nod(OLEN, n.Right, nil))
typecheck(&r, Erv)
walkexpr(&r, init)
r = typecheck(r, Erv)
r = walkexpr(r, init)
r.Type = n.Type
n = r
break
......@@ -1341,8 +1342,8 @@ opswitch:
if (Op(n.Etype) == OEQ || Op(n.Etype) == ONE) && Isconst(n.Right, CTSTR) && n.Left.Op == OADDSTR && n.Left.List.Len() == 2 && Isconst(n.Left.List.Second(), CTSTR) && strlit(n.Right) == strlit(n.Left.List.Second()) {
// TODO(marvin): Fix Node.EType type union.
r := Nod(Op(n.Etype), Nod(OLEN, n.Left.List.First(), nil), Nodintconst(0))
typecheck(&r, Erv)
walkexpr(&r, init)
r = typecheck(r, Erv)
r = walkexpr(r, init)
r.Type = n.Type
n = r
break
......@@ -1371,8 +1372,8 @@ opswitch:
r = Nod(OOROR, Nod(ONE, Nod(OLEN, n.Left, nil), Nod(OLEN, n.Right, nil)), r)
}
typecheck(&r, Erv)
walkexpr(&r, nil)
r = typecheck(r, Erv)
r = walkexpr(r, nil)
} else {
// sys_cmpstring(s1, s2) :: 0
r = mkcall("cmpstring", Types[TINT], init, conv(n.Left, Types[TSTRING]), conv(n.Right, Types[TSTRING]))
......@@ -1381,7 +1382,7 @@ opswitch:
r = Nod(Op(n.Etype), r, Nodintconst(0))
}
typecheck(&r, Erv)
r = typecheck(r, Erv)
if n.Type.Etype != TBOOL {
Fatalf("cmp %v", n.Type)
}
......@@ -1402,7 +1403,7 @@ opswitch:
case OCLOSE:
fn := syslook("closechan")
substArgTypes(&fn, n.Left.Type)
fn = substArgTypes(fn, n.Left.Type)
n = mkcall1(fn, nil, init, n.Left)
case OMAKECHAN:
......@@ -1418,7 +1419,7 @@ opswitch:
var_ := temp(hmap(t))
a = Nod(OAS, var_, nil) // zero temp
typecheck(&a, Etop)
a = typecheck(a, Etop)
init.Append(a)
a = Nod(OADDR, var_, nil)
......@@ -1428,13 +1429,13 @@ opswitch:
var_ = temp(mapbucket(t))
r = Nod(OAS, var_, nil) // zero temp
typecheck(&r, Etop)
r = typecheck(r, Etop)
init.Append(r)
r = Nod(OADDR, var_, nil)
}
fn := syslook("makemap")
substArgTypes(&fn, hmap(t), mapbucket(t), t.Key(), t.Type)
fn = substArgTypes(fn, hmap(t), mapbucket(t), t.Key(), t.Type)
n = mkcall1(fn, n.Type, init, typename(n.Type), conv(n.Left, Types[TINT64]), a, r)
case OMAKESLICE:
......@@ -1454,18 +1455,18 @@ opswitch:
t = aindex(r, t.Type) // [r]T
var_ := temp(t)
a := Nod(OAS, var_, nil) // zero temp
typecheck(&a, Etop)
a = typecheck(a, Etop)
init.Append(a)
r := Nod(OSLICE, var_, Nod(OKEY, nil, l)) // arr[:l]
r = conv(r, n.Type) // in case n.Type is named.
typecheck(&r, Erv)
walkexpr(&r, init)
r = typecheck(r, Erv)
r = walkexpr(r, init)
n = r
} else {
// makeslice(t *Type, nel int64, max int64) (ary []any)
fn := syslook("makeslice")
substArgTypes(&fn, t.Type) // any-1
fn = substArgTypes(fn, t.Type) // any-1
n = mkcall1(fn, n.Type, init, typename(n.Type), conv(l, Types[TINT64]), conv(r, Types[TINT64]))
}
......@@ -1553,7 +1554,7 @@ opswitch:
n.Right = cheapexpr(n.Right, init)
n.Left = cheapexpr(n.Left, init)
substArgTypes(&fn, n.Right.Type, n.Left.Type)
fn = substArgTypes(fn, n.Right.Type, n.Left.Type)
r := mkcall1(fn, n.Type, init, n.Left, n.Right)
// TODO(marvin): Fix Node.EType type union.
if Op(n.Etype) == ONE {
......@@ -1567,8 +1568,8 @@ opswitch:
} else {
r = Nod(OOROR, Nod(ONE, Nod(OITAB, n.Left, nil), Nod(OITAB, n.Right, nil)), r)
}
typecheck(&r, Erv)
walkexpr(&r, init)
r = typecheck(r, Erv)
r = walkexpr(r, init)
r.Type = n.Type
n = r
......@@ -1580,7 +1581,7 @@ opswitch:
case OSEND:
n1 := n.Right
n1 = assignconv(n1, n.Left.Type.Type, "chan send")
walkexpr(&n1, init)
n1 = walkexpr(n1, init)
n1 = Nod(OADDR, n1, nil)
n = mkcall1(chanfn("chansend1", 2, n.Left.Type), nil, init, typename(n.Left.Type), n.Left, n1)
......@@ -1601,7 +1602,7 @@ opswitch:
evconst(n)
n.Type = t
if n.Op == OLITERAL {
typecheck(&n, Erv)
n = typecheck(n, Erv)
}
ullmancalc(n)
......@@ -1611,7 +1612,7 @@ opswitch:
}
lineno = lno
*np = n
return n
}
func reduceSlice(n *Node) *Node {
......@@ -1720,7 +1721,7 @@ func ascompatet(op Op, nl Nodes, nr *Type, fp int, init *Nodes) []*Node {
// have been pulled from the output arguments
if fncall(l, r.Type) {
tmp := temp(r.Type)
typecheck(&tmp, Erv)
tmp = typecheck(tmp, Erv)
a := Nod(OAS, l, tmp)
a = convas(a, init)
mm = append(mm, a)
......@@ -1771,11 +1772,11 @@ func mkdotargslice(lr0, nn []*Node, l *Field, fp int, init *Nodes, ddd *Node) []
}
n.List.Set(lr0)
n.Esc = esc
typecheck(&n, Erv)
n = typecheck(n, Erv)
if n.Type == nil {
Fatalf("mkdotargslice: typecheck failed")
}
walkexpr(&n, init)
n = walkexpr(n, init)
}
a := Nod(OAS, nodarg(l, fp), n)
......@@ -1848,8 +1849,8 @@ func ascompatte(op Op, call *Node, isddd bool, nl *Type, lr []*Node, fp int, ini
a := Nod(OAS2, nil, nil)
a.List.Set(alist)
a.Rlist.Set(lr)
typecheck(&a, Etop)
walkstmt(&a)
a = typecheck(a, Etop)
a = walkstmt(a)
init.Append(a)
lr = alist
r = lr[0]
......@@ -1945,20 +1946,20 @@ func walkprint(nn *Node, init *Nodes) *Node {
if n.Op == OLITERAL {
switch n.Val().Ctype() {
case CTRUNE:
defaultlit(&n, runetype)
n = defaultlit(n, runetype)
case CTINT:
defaultlit(&n, Types[TINT64])
n = defaultlit(n, Types[TINT64])
case CTFLT:
defaultlit(&n, Types[TFLOAT64])
n = defaultlit(n, Types[TFLOAT64])
}
}
if n.Op != OLITERAL && n.Type != nil && n.Type.Etype == TIDEAL {
defaultlit(&n, Types[TINT64])
n = defaultlit(n, Types[TINT64])
}
defaultlit(&n, nil)
n = defaultlit(n, nil)
all.SetIndex(i1, n)
if n.Type == nil || n.Type.Etype == TFORW {
continue
......@@ -1972,13 +1973,13 @@ func walkprint(nn *Node, init *Nodes) *Node {
} else {
on = syslook("printiface")
}
substArgTypes(&on, n.Type) // any-1
on = substArgTypes(on, n.Type) // any-1
} else if Isptr[et] || et == TCHAN || et == TMAP || et == TFUNC || et == TUNSAFEPTR {
on = syslook("printpointer")
substArgTypes(&on, n.Type) // any-1
on = substArgTypes(on, n.Type) // any-1
} else if Isslice(n.Type) {
on = syslook("printslice")
substArgTypes(&on, n.Type) // any-1
on = substArgTypes(on, n.Type) // any-1
} else if Isint[et] {
if et == TUINT64 {
if (t.Sym.Pkg == Runtimepkg || compiling_runtime != 0) && t.Sym.Name == "hex" {
......@@ -2024,8 +2025,8 @@ func walkprint(nn *Node, init *Nodes) *Node {
walkexprlist(calls, init)
r = Nod(OEMPTY, nil, nil)
typecheck(&r, Etop)
walkexpr(&r, init)
r = typecheck(r, Etop)
r = walkexpr(r, init)
r.Ninit.Set(calls)
return r
}
......@@ -2033,7 +2034,7 @@ func walkprint(nn *Node, init *Nodes) *Node {
func callnew(t *Type) *Node {
dowidth(t)
fn := syslook("newobject")
substArgTypes(&fn, t)
fn = substArgTypes(fn, t)
return mkcall1(fn, Ptrto(t), nil, typename(t))
}
......@@ -2181,7 +2182,7 @@ func convas(n *Node, init *Nodes) *Node {
}
if isblank(n.Left) {
defaultlit(&n.Right, nil)
n.Right = defaultlit(n.Right, nil)
goto out
}
......@@ -2189,9 +2190,9 @@ func convas(n *Node, init *Nodes) *Node {
map_ := n.Left.Left
key := n.Left.Right
val := n.Right
walkexpr(&map_, init)
walkexpr(&key, init)
walkexpr(&val, init)
map_ = walkexpr(map_, init)
key = walkexpr(key, init)
val = walkexpr(val, init)
// orderexpr made sure key and val are addressable.
key = Nod(OADDR, key, nil)
......@@ -2203,7 +2204,7 @@ func convas(n *Node, init *Nodes) *Node {
if !Eqtype(lt, rt) {
n.Right = assignconv(n.Right, lt, "assignment")
walkexpr(&n.Right, init)
n.Right = walkexpr(n.Right, init)
}
out:
......@@ -2296,7 +2297,7 @@ func reorder3(all []*Node) []*Node {
}
if l.Op == OINDEX && Isfixedarray(l.Left.Type) {
reorder3save(&l.Right, all, i, &early)
l.Right = reorder3save(l.Right, all, i, &early)
l = l.Left
continue
}
......@@ -2312,18 +2313,18 @@ func reorder3(all []*Node) []*Node {
break
case OINDEX, OINDEXMAP:
reorder3save(&l.Left, all, i, &early)
reorder3save(&l.Right, all, i, &early)
l.Left = reorder3save(l.Left, all, i, &early)
l.Right = reorder3save(l.Right, all, i, &early)
if l.Op == OINDEXMAP {
all[i] = convas(all[i], &mapinit)
}
case OIND, ODOTPTR:
reorder3save(&l.Left, all, i, &early)
l.Left = reorder3save(l.Left, all, i, &early)
}
// Save expression on right side.
reorder3save(&all[i].Right, all, i, &early)
all[i].Right = reorder3save(all[i].Right, all, i, &early)
}
early = append(mapinit.Slice(), early...)
......@@ -2334,17 +2335,18 @@ func reorder3(all []*Node) []*Node {
// assignments in all up to but not including the ith assignment,
// copy into a temporary during *early and
// replace *np with that temp.
func reorder3save(np **Node, all []*Node, i int, early *[]*Node) {
n := *np
// The result of reorder3save MUST be assigned back to n, e.g.
// n.Left = reorder3save(n.Left, all, i, early)
func reorder3save(n *Node, all []*Node, i int, early *[]*Node) *Node {
if !aliased(n, all, i) {
return
return n
}
q := temp(n.Type)
q = Nod(OAS, q, n)
typecheck(&q, Etop)
q = typecheck(q, Etop)
*early = append(*early, q)
*np = q.Left
return q.Left
}
// what's the outer value that a write to n affects?
......@@ -2590,7 +2592,7 @@ func paramstoheap(params *Type, out bool) []*Node {
if v.Class&^PHEAP != PPARAMOUT {
as := Nod(OAS, v, v.Name.Param.Stackparam)
v.Name.Param.Stackparam.Typecheck = 1
typecheck(&as, Etop)
as = typecheck(as, Etop)
as = applywritebarrier(as)
nn = append(nn, as)
}
......@@ -2639,11 +2641,11 @@ func vmkcall(fn *Node, t *Type, init *Nodes, va []*Node) *Node {
r := Nod(OCALL, fn, nil)
r.List.Set(va[:n])
if fn.Type.Results().NumFields() > 0 {
typecheck(&r, Erv|Efnstruct)
r = typecheck(r, Erv|Efnstruct)
} else {
typecheck(&r, Etop)
r = typecheck(r, Etop)
}
walkexpr(&r, init)
r = walkexpr(r, init)
r.Type = t
return r
}
......@@ -2662,7 +2664,7 @@ func conv(n *Node, t *Type) *Node {
}
n = Nod(OCONV, n, nil)
n.Type = t
typecheck(&n, Erv)
n = typecheck(n, Erv)
return n
}
......@@ -2675,9 +2677,9 @@ func chanfn(name string, n int, t *Type) *Node {
default:
Fatalf("chanfn %d", n)
case 1:
substArgTypes(&fn, t.Type)
fn = substArgTypes(fn, t.Type)
case 2:
substArgTypes(&fn, t.Type, t.Type)
fn = substArgTypes(fn, t.Type, t.Type)
}
return fn
}
......@@ -2687,7 +2689,7 @@ func mapfn(name string, t *Type) *Node {
Fatalf("mapfn %v", t)
}
fn := syslook(name)
substArgTypes(&fn, t.Key(), t.Type, t.Key(), t.Type)
fn = substArgTypes(fn, t.Key(), t.Type, t.Key(), t.Type)
return fn
}
......@@ -2696,13 +2698,13 @@ func mapfndel(name string, t *Type) *Node {
Fatalf("mapfn %v", t)
}
fn := syslook(name)
substArgTypes(&fn, t.Key(), t.Type, t.Key())
fn = substArgTypes(fn, t.Key(), t.Type, t.Key())
return fn
}
func writebarrierfn(name string, l *Type, r *Type) *Node {
fn := syslook(name)
substArgTypes(&fn, l, r)
fn = substArgTypes(fn, l, r)
return fn
}
......@@ -2763,8 +2765,8 @@ func addstr(n *Node, init *Nodes) *Node {
cat := syslook(fn)
r := Nod(OCALL, cat, nil)
r.List.Set(args)
typecheck(&r, Erv)
walkexpr(&r, init)
r = typecheck(r, Erv)
r = walkexpr(r, init)
r.Type = n.Type
return r
......@@ -2816,7 +2818,7 @@ func appendslice(n *Node, init *Nodes) *Node {
// instantiate growslice(Type*, []any, int) []any
fn := syslook("growslice")
substArgTypes(&fn, s.Type.Type, s.Type.Type)
fn = substArgTypes(fn, s.Type.Type, s.Type.Type)
// s = growslice(T, s, n)
nif.Nbody.Set1(Nod(OAS, s, mkcall1(fn, s.Type, &nif.Ninit, typename(s.Type), s, nn)))
......@@ -2834,7 +2836,7 @@ func appendslice(n *Node, init *Nodes) *Node {
nptr1.Etype = 1
nptr2 := l2
fn := syslook("typedslicecopy")
substArgTypes(&fn, l1.Type, l2.Type)
fn = substArgTypes(fn, l1.Type, l2.Type)
var ln Nodes
ln.Set(l)
nt := mkcall1(fn, Types[TINT], &ln, typename(l1.Type.Type), nptr1, nptr2)
......@@ -2852,7 +2854,7 @@ func appendslice(n *Node, init *Nodes) *Node {
} else {
fn = syslook("slicecopy")
}
substArgTypes(&fn, l1.Type, l2.Type)
fn = substArgTypes(fn, l1.Type, l2.Type)
var ln Nodes
ln.Set(l)
nt := mkcall1(fn, Types[TINT], &ln, nptr1, nptr2, Nodintconst(s.Type.Type.Width))
......@@ -2867,7 +2869,7 @@ func appendslice(n *Node, init *Nodes) *Node {
nptr2 := Nod(OSPTR, l2, nil)
fn := syslook("memmove")
substArgTypes(&fn, s.Type.Type, s.Type.Type)
fn = substArgTypes(fn, s.Type.Type, s.Type.Type)
var ln Nodes
ln.Set(l)
......@@ -2908,7 +2910,7 @@ func appendslice(n *Node, init *Nodes) *Node {
func walkappend(n *Node, init *Nodes, dst *Node) *Node {
if !samesafeexpr(dst, n.List.First()) {
n.List.SetIndex(0, safeexpr(n.List.Index(0), init))
walkexpr(n.List.Addr(0), init)
n.List.SetIndex(0, walkexpr(n.List.Index(0), init))
}
walkexprlistsafe(n.List.Slice()[1:], init)
......@@ -2950,7 +2952,7 @@ func walkappend(n *Node, init *Nodes, dst *Node) *Node {
nx.Left = Nod(OLT, Nod(OSUB, Nod(OCAP, ns, nil), Nod(OLEN, ns, nil)), na)
fn := syslook("growslice") // growslice(<type>, old []T, mincap int) (ret []T)
substArgTypes(&fn, ns.Type.Type, ns.Type.Type)
fn = substArgTypes(fn, ns.Type.Type, ns.Type.Type)
nx.Nbody.Set1(Nod(OAS, ns,
mkcall1(fn, ns.Type, &nx.Ninit, typename(ns.Type), ns,
......@@ -3005,12 +3007,12 @@ func copyany(n *Node, init *Nodes, runtimecall bool) *Node {
} else {
fn = syslook("slicecopy")
}
substArgTypes(&fn, n.Left.Type, n.Right.Type)
fn = substArgTypes(fn, n.Left.Type, n.Right.Type)
return mkcall1(fn, n.Type, init, n.Left, n.Right, Nodintconst(n.Left.Type.Type.Width))
}
walkexpr(&n.Left, init)
walkexpr(&n.Right, init)
n.Left = walkexpr(n.Left, init)
n.Right = walkexpr(n.Right, init)
nl := temp(n.Left.Type)
nr := temp(n.Right.Type)
var l []*Node
......@@ -3035,7 +3037,7 @@ func copyany(n *Node, init *Nodes, runtimecall bool) *Node {
// Call memmove.
fn := syslook("memmove")
substArgTypes(&fn, nl.Type.Type, nl.Type.Type)
fn = substArgTypes(fn, nl.Type.Type, nl.Type.Type)
nwid := temp(Types[TUINTPTR])
l = append(l, Nod(OAS, nwid, conv(nlen, Types[TUINTPTR])))
nwid = Nod(OMUL, nwid, Nodintconst(nl.Type.Type.Width))
......@@ -3060,7 +3062,7 @@ func eqfor(t *Type, needsize *int) *Node {
if a == AMEM {
n := syslook("memequal")
substArgTypes(&n, t, t)
n = substArgTypes(n, t, t)
*needsize = 1
return n
}
......@@ -3072,15 +3074,15 @@ func eqfor(t *Type, needsize *int) *Node {
ntype.List.Append(Nod(ODCLFIELD, nil, typenod(Ptrto(t))))
ntype.List.Append(Nod(ODCLFIELD, nil, typenod(Ptrto(t))))
ntype.Rlist.Append(Nod(ODCLFIELD, nil, typenod(Types[TBOOL])))
typecheck(&ntype, Etype)
ntype = typecheck(ntype, Etype)
n.Type = ntype.Type
*needsize = 0
return n
}
func walkcompare(np **Node, init *Nodes) {
n := *np
// The result of walkcompare MUST be assigned back to n, e.g.
// n.Left = walkcompare(n.Left, init)
func walkcompare(n *Node, init *Nodes) *Node {
// Given interface value l and concrete value r, rewrite
// l == r
// to
......@@ -3103,7 +3105,7 @@ func walkcompare(np **Node, init *Nodes) {
x := temp(r.Type)
if haspointers(r.Type) {
a := Nod(OAS, x, nil)
typecheck(&a, Etop)
a = typecheck(a, Etop)
init.Append(a)
}
ok := temp(Types[TBOOL])
......@@ -3119,8 +3121,8 @@ func walkcompare(np **Node, init *Nodes) {
expr.List.Append(x)
expr.List.Append(ok)
expr.Rlist.Append(a)
typecheck(&expr, Etop)
walkexpr(&expr, init)
expr = typecheck(expr, Etop)
expr = walkexpr(expr, init)
if n.Op == OEQ {
r = Nod(OANDAND, ok, Nod(OEQ, x, r))
......@@ -3128,8 +3130,8 @@ func walkcompare(np **Node, init *Nodes) {
r = Nod(OOROR, Nod(ONOT, ok, nil), Nod(ONE, x, r))
}
init.Append(expr)
finishcompare(np, n, r, init)
return
n = finishcompare(n, n, r, init)
return n
}
// Must be comparison of array or struct.
......@@ -3138,11 +3140,11 @@ func walkcompare(np **Node, init *Nodes) {
switch t.Etype {
default:
return
return n
case TARRAY:
if Isslice(t) {
return
return n
}
case TSTRUCT:
......@@ -3165,13 +3167,13 @@ func walkcompare(np **Node, init *Nodes) {
l = temp(Ptrto(t))
a := Nod(OAS, l, Nod(OADDR, cmpl, nil))
a.Right.Etype = 1 // addr does not escape
typecheck(&a, Etop)
a = typecheck(a, Etop)
init.Append(a)
r = temp(Ptrto(t))
a = Nod(OAS, r, Nod(OADDR, cmpr, nil))
a.Right.Etype = 1 // addr does not escape
typecheck(&a, Etop)
a = typecheck(a, Etop)
init.Append(a)
var andor Op = OANDAND
......@@ -3199,22 +3201,22 @@ func walkcompare(np **Node, init *Nodes) {
if expr == nil {
expr = Nodbool(n.Op == OEQ)
}
finishcompare(np, n, expr, init)
return
n = finishcompare(n, n, expr, init)
return n
}
if t.Etype == TARRAY {
// Zero- or single-element array, of any type.
switch t.Bound {
case 0:
finishcompare(np, n, Nodbool(n.Op == OEQ), init)
return
n = finishcompare(n, n, Nodbool(n.Op == OEQ), init)
return n
case 1:
l0 := Nod(OINDEX, l, Nodintconst(0))
r0 := Nod(OINDEX, r, Nodintconst(0))
a := Nod(n.Op, l0, r0)
finishcompare(np, n, a, init)
return
n = finishcompare(n, n, a, init)
return n
}
}
......@@ -3240,8 +3242,8 @@ func walkcompare(np **Node, init *Nodes) {
if expr == nil {
expr = Nodbool(n.Op == OEQ)
}
finishcompare(np, n, expr, init)
return
n = finishcompare(n, n, expr, init)
return n
}
// Chose not to inline. Call equality function directly.
......@@ -3258,22 +3260,25 @@ func walkcompare(np **Node, init *Nodes) {
r = Nod(ONOT, r, nil)
}
finishcompare(np, n, r, init)
return
n = finishcompare(n, n, r, init)
return n
}
func finishcompare(np **Node, n, r *Node, init *Nodes) {
// Using np here to avoid passing &r to typecheck.
*np = r
typecheck(np, Erv)
walkexpr(np, init)
r = *np
// The result of finishcompare MUST be assigned back to nn, e.g.
// n.Left = finishcompare(n.Left, x, r, init)
func finishcompare(nn *Node, n, r *Node, init *Nodes) *Node {
// Use nn here to avoid passing r to typecheck.
nn = r
nn = typecheck(nn, Erv)
nn = walkexpr(nn, init)
r = nn
if r.Type != n.Type {
r = Nod(OCONVNOP, r, nil)
r.Type = n.Type
r.Typecheck = 1
*np = r
nn = r
}
return nn
}
func samecheap(a *Node, b *Node) bool {
......@@ -3307,24 +3312,24 @@ func samecheap(a *Node, b *Node) bool {
return false
}
func walkrotate(np **Node) {
// The result of walkrotate MUST be assigned back to n, e.g.
// n.Left = walkrotate(n.Left)
func walkrotate(n *Node) *Node {
if Thearch.Thechar == '0' || Thearch.Thechar == '7' || Thearch.Thechar == '9' {
return
return n
}
n := *np
// Want << | >> or >> | << or << ^ >> or >> ^ << on unsigned value.
l := n.Left
r := n.Right
if (n.Op != OOR && n.Op != OXOR) || (l.Op != OLSH && l.Op != ORSH) || (r.Op != OLSH && r.Op != ORSH) || n.Type == nil || Issigned[n.Type.Etype] || l.Op == r.Op {
return
return n
}
// Want same, side effect-free expression on lhs of both shifts.
if !samecheap(l.Left, r.Left) {
return
return n
}
// Constants adding to width?
......@@ -3349,23 +3354,22 @@ func walkrotate(np **Node) {
if s == 0 || s == w {
n = n.Left
}
*np = n
return
return n
}
}
return
return n
}
// TODO: Could allow s and 32-s if s is bounded (maybe s&31 and 32-s&31).
return
return n
}
// walkmul rewrites integer multiplication by powers of two as shifts.
func walkmul(np **Node, init *Nodes) {
n := *np
// The result of walkmul MUST be assigned back to n, e.g.
// n.Left = walkmul(n.Left, init)
func walkmul(n *Node, init *Nodes) *Node {
if !Isint[n.Type.Etype] {
return
return n
}
var nr *Node
......@@ -3377,7 +3381,7 @@ func walkmul(np **Node, init *Nodes) {
nl = n.Right
nr = n.Left
} else {
return
return n
}
neg := 0
......@@ -3395,7 +3399,7 @@ func walkmul(np **Node, init *Nodes) {
pow = powtwo(nr)
if pow < 0 {
return
return n
}
if pow >= 1000 {
// negative power of 2, like -16
......@@ -3406,7 +3410,7 @@ func walkmul(np **Node, init *Nodes) {
w = int(nl.Type.Width * 8)
if pow+1 >= w { // too big, shouldn't happen
return
return n
}
nl = cheapexpr(nl, init)
......@@ -3425,24 +3429,25 @@ ret:
n = Nod(OMINUS, n, nil)
}
typecheck(&n, Erv)
walkexpr(&n, init)
*np = n
n = typecheck(n, Erv)
n = walkexpr(n, init)
return n
}
// walkdiv rewrites division by a constant as less expensive
// operations.
func walkdiv(np **Node, init *Nodes) {
// The result of walkdiv MUST be assigned back to n, e.g.
// n.Left = walkdiv(n.Left, init)
func walkdiv(n *Node, init *Nodes) *Node {
// if >= 0, nr is 1<<pow // 1 if nr is negative.
// TODO(minux)
if Thearch.Thechar == '0' || Thearch.Thechar == '7' || Thearch.Thechar == '9' {
return
return n
}
n := *np
if n.Right.Op != OLITERAL {
return
return n
}
// nr is a constant.
......@@ -3465,7 +3470,7 @@ func walkdiv(np **Node, init *Nodes) {
if pow+1 >= w {
// divisor too large.
return
return n
}
if pow < 0 {
......@@ -3484,7 +3489,7 @@ func walkdiv(np **Node, init *Nodes) {
}
if m.Bad != 0 {
return
return n
}
// We have a quick division method so use it
......@@ -3500,7 +3505,7 @@ func walkdiv(np **Node, init *Nodes) {
switch Simtype[nl.Type.Etype] {
default:
return
return n
// n1 = nl * magic >> w (HMUL)
case TUINT8, TUINT16, TUINT32:
......@@ -3508,13 +3513,13 @@ func walkdiv(np **Node, init *Nodes) {
Nodconst(nc, nl.Type, int64(m.Um))
n1 := Nod(OHMUL, nl, nc)
typecheck(&n1, Erv)
n1 = typecheck(n1, Erv)
if m.Ua != 0 {
// Select a Go type with (at least) twice the width.
var twide *Type
switch Simtype[nl.Type.Etype] {
default:
return
return n
case TUINT8, TUINT16:
twide = Types[TUINT32]
......@@ -3552,7 +3557,7 @@ func walkdiv(np **Node, init *Nodes) {
Nodconst(nc, nl.Type, m.Sm)
n1 := Nod(OHMUL, nl, nc)
typecheck(&n1, Erv)
n1 = typecheck(n1, Erv)
if m.Sm < 0 {
// add the numerator.
n1 = Nod(OADD, n1, nl)
......@@ -3606,7 +3611,7 @@ func walkdiv(np **Node, init *Nodes) {
Nodconst(nc, Types[Simtype[TUINT]], int64(w)-1)
n1 := Nod(ORSH, nl, nc) // n1 = -1 iff nl < 0.
if pow == 1 {
typecheck(&n1, Erv)
n1 = typecheck(n1, Erv)
n1 = cheapexpr(n1, init)
// n = (nl+ε)&1 -ε where ε=1 iff nl<0.
......@@ -3622,7 +3627,7 @@ func walkdiv(np **Node, init *Nodes) {
Nodconst(nc, nl.Type, (1<<uint(pow))-1)
n2 := Nod(OAND, n1, nc) // n2 = 2^pow-1 iff nl<0.
typecheck(&n2, Erv)
n2 = typecheck(n2, Erv)
n2 = cheapexpr(n2, init)
n3 := Nod(OADD, nl, n2)
......@@ -3686,9 +3691,9 @@ func walkdiv(np **Node, init *Nodes) {
goto ret
ret:
typecheck(&n, Erv)
walkexpr(&n, init)
*np = n
n = typecheck(n, Erv)
n = walkexpr(n, init)
return n
}
// return 1 if integer n must be in range [0, max), 0 otherwise
......@@ -3954,9 +3959,9 @@ func candiscard(n *Node) bool {
var walkprintfunc_prgen int
func walkprintfunc(np **Node, init *Nodes) {
n := *np
// The result of walkprintfunc MUST be assigned back to n, e.g.
// n.Left = walkprintfunc(n.Left, init)
func walkprintfunc(n *Node, init *Nodes) *Node {
if n.Ninit.Len() != 0 {
walkstmtlist(n.Ninit.Slice())
init.AppendNodes(&n.Ninit)
......@@ -3989,14 +3994,14 @@ func walkprintfunc(np **Node, init *Nodes) {
a = Nod(n.Op, nil, nil)
a.List.Set(printargs)
typecheck(&a, Etop)
walkstmt(&a)
a = typecheck(a, Etop)
a = walkstmt(a)
fn.Nbody.Set1(a)
funcbody(fn)
typecheck(&fn, Etop)
fn = typecheck(fn, Etop)
typecheckslice(fn.Nbody.Slice(), Etop)
xtop = append(xtop, fn)
Curfn = oldfn
......@@ -4004,7 +4009,7 @@ func walkprintfunc(np **Node, init *Nodes) {
a = Nod(OCALL, nil, nil)
a.Left = fn.Func.Nname
a.List.Set(n.List.Slice())
typecheck(&a, Etop)
walkexpr(&a, init)
*np = a
a = typecheck(a, Etop)
a = walkexpr(a, init)
return a
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7