Rewrite all uses of ir.Nod and friends to call the IR constructors directly.
This gives the results a more specific type and will play nicely with
introduction of more specific types throughout the code in a followup CL.
Passes buildall w/ toolstash -cmp.
[git-generate]
cd src/cmd/compile/internal/gc
rf '
ex . ../ir {
import "cmd/compile/internal/ir"
import "cmd/compile/internal/types"
import "cmd/compile/internal/syntax"
import "cmd/internal/src"
var p *noder
var orig syntax.Node
var op ir.Op
var l, r ir.Node
var sym *types.Sym
p.nod(orig, op, l, r) -> ir.NodAt(p.pos(orig), op, l, r)
p.nodSym(orig, op, l, sym) -> nodlSym(p.pos(orig), op, l, sym)
var xpos src.XPos
var ns ir.Nodes
npos(xpos, nodSym(op, l, sym)) -> nodlSym(xpos, op, l, sym)
npos(xpos, liststmt(ns)) -> ir.NewBlockStmt(xpos, ns)
}
ex . ../ir {
import "cmd/compile/internal/base"
import "cmd/compile/internal/ir"
import "cmd/compile/internal/types"
var op ir.Op
var l, r ir.Node
ir.Nod(op, l, r) -> ir.NodAt(base.Pos, op, l, r)
var sym *types.Sym
nodSym(op, l, sym) -> nodlSym(base.Pos, op, l, sym)
}
ex . ../ir {
import "cmd/compile/internal/ir"
import "cmd/internal/src"
# rf overlapping match handling is not quite good enough
# for certain nested rewrites, so handle these two - which often contain other ir.NodAt calls - early.
var l, r ir.Node
var xpos src.XPos
ir.NodAt(xpos, ir.OAS, l, r) -> ir.NewAssignStmt(xpos, l, r)
ir.NodAt(xpos, ir.OIF, l, nil) -> ir.NewIfStmt(xpos, l, nil, nil)
}
ex . ../ir {
import "cmd/compile/internal/ir"
import "cmd/compile/internal/types"
import "cmd/internal/src"
var l, r ir.Node
var sym *types.Sym
var xpos src.XPos
nodlSym(xpos, ir.ODOT, l, sym) -> ir.NewSelectorExpr(xpos, ir.ODOT, l, sym)
nodlSym(xpos, ir.OXDOT, l, sym) -> ir.NewSelectorExpr(xpos, ir.OXDOT, l, sym)
nodlSym(xpos, ir.ODOTPTR, l, sym) -> ir.NewSelectorExpr(xpos, ir.ODOTPTR, l, sym)
nodlSym(xpos, ir.OGOTO, nil, sym) -> ir.NewBranchStmt(xpos, ir.OGOTO, sym)
nodlSym(xpos, ir.ORETJMP, nil, sym) -> ir.NewBranchStmt(xpos, ir.ORETJMP, sym)
nodlSym(xpos, ir.OLABEL, nil, sym) -> ir.NewLabelStmt(xpos, sym)
nodlSym(xpos, ir.OSTRUCTKEY, l, sym) -> ir.NewStructKeyExpr(xpos, sym, l)
ir.NodAt(xpos, ir.OADD, l, r) -> ir.NewBinaryExpr(xpos, ir.OADD, l, r)
ir.NodAt(xpos, ir.OAND, l, r) -> ir.NewBinaryExpr(xpos, ir.OAND, l, r)
ir.NodAt(xpos, ir.OANDNOT, l, r) -> ir.NewBinaryExpr(xpos, ir.OANDNOT, l, r)
ir.NodAt(xpos, ir.ODIV, l, r) -> ir.NewBinaryExpr(xpos, ir.ODIV, l, r)
ir.NodAt(xpos, ir.OEQ, l, r) -> ir.NewBinaryExpr(xpos, ir.OEQ, l, r)
ir.NodAt(xpos, ir.OGE, l, r) -> ir.NewBinaryExpr(xpos, ir.OGE, l, r)
ir.NodAt(xpos, ir.OGT, l, r) -> ir.NewBinaryExpr(xpos, ir.OGT, l, r)
ir.NodAt(xpos, ir.OLE, l, r) -> ir.NewBinaryExpr(xpos, ir.OLE, l, r)
ir.NodAt(xpos, ir.OLSH, l, r) -> ir.NewBinaryExpr(xpos, ir.OLSH, l, r)
ir.NodAt(xpos, ir.OLT, l, r) -> ir.NewBinaryExpr(xpos, ir.OLT, l, r)
ir.NodAt(xpos, ir.OMOD, l, r) -> ir.NewBinaryExpr(xpos, ir.OMOD, l, r)
ir.NodAt(xpos, ir.OMUL, l, r) -> ir.NewBinaryExpr(xpos, ir.OMUL, l, r)
ir.NodAt(xpos, ir.ONE, l, r) -> ir.NewBinaryExpr(xpos, ir.ONE, l, r)
ir.NodAt(xpos, ir.OOR, l, r) -> ir.NewBinaryExpr(xpos, ir.OOR, l, r)
ir.NodAt(xpos, ir.ORSH, l, r) -> ir.NewBinaryExpr(xpos, ir.ORSH, l, r)
ir.NodAt(xpos, ir.OSUB, l, r) -> ir.NewBinaryExpr(xpos, ir.OSUB, l, r)
ir.NodAt(xpos, ir.OXOR, l, r) -> ir.NewBinaryExpr(xpos, ir.OXOR, l, r)
ir.NodAt(xpos, ir.OCOPY, l, r) -> ir.NewBinaryExpr(xpos, ir.OCOPY, l, r)
ir.NodAt(xpos, ir.OCOMPLEX, l, r) -> ir.NewBinaryExpr(xpos, ir.OCOMPLEX, l, r)
ir.NodAt(xpos, ir.OEFACE, l, r) -> ir.NewBinaryExpr(xpos, ir.OEFACE, l, r)
ir.NodAt(xpos, ir.OADDR, l, nil) -> ir.NewAddrExpr(xpos, l)
ir.NodAt(xpos, ir.OADDSTR, nil, nil) -> ir.NewAddStringExpr(xpos, nil)
ir.NodAt(xpos, ir.OANDAND, l, r) -> ir.NewLogicalExpr(xpos, ir.OANDAND, l, r)
ir.NodAt(xpos, ir.OOROR, l, r) -> ir.NewLogicalExpr(xpos, ir.OOROR, l, r)
ir.NodAt(xpos, ir.OARRAYLIT, nil, nil) -> ir.NewCompLitExpr(xpos, ir.OARRAYLIT, nil, nil)
ir.NodAt(xpos, ir.OCOMPLIT, nil, nil) -> ir.NewCompLitExpr(xpos, ir.OCOMPLIT, nil, nil)
ir.NodAt(xpos, ir.OMAPLIT, nil, nil) -> ir.NewCompLitExpr(xpos, ir.OMAPLIT, nil, nil)
ir.NodAt(xpos, ir.OSTRUCTLIT, nil, nil) -> ir.NewCompLitExpr(xpos, ir.OSTRUCTLIT, nil, nil)
ir.NodAt(xpos, ir.OSLICELIT, nil, nil) -> ir.NewCompLitExpr(xpos, ir.OSLICELIT, nil, nil)
ir.NodAt(xpos, ir.OARRAYLIT, nil, r) -> ir.NewCompLitExpr(xpos, ir.OARRAYLIT, r.(ir.Ntype), nil)
ir.NodAt(xpos, ir.OCOMPLIT, nil, r) -> ir.NewCompLitExpr(xpos, ir.OCOMPLIT, r.(ir.Ntype), nil)
ir.NodAt(xpos, ir.OMAPLIT, nil, r) -> ir.NewCompLitExpr(xpos, ir.OMAPLIT, r.(ir.Ntype), nil)
ir.NodAt(xpos, ir.OSTRUCTLIT, nil, r) -> ir.NewCompLitExpr(xpos, ir.OSTRUCTLIT, r.(ir.Ntype), nil)
ir.NodAt(xpos, ir.OSLICELIT, nil, r) -> ir.NewCompLitExpr(xpos, ir.OSLICELIT, r.(ir.Ntype), nil)
ir.NodAt(xpos, ir.OAS2, nil, nil) -> ir.NewAssignListStmt(xpos, ir.OAS2, nil, nil)
ir.NodAt(xpos, ir.OAS2DOTTYPE, nil, nil) -> ir.NewAssignListStmt(xpos, ir.OAS2DOTTYPE, nil, nil)
ir.NodAt(xpos, ir.OAS2FUNC, nil, nil) -> ir.NewAssignListStmt(xpos, ir.OAS2FUNC, nil, nil)
ir.NodAt(xpos, ir.OAS2MAPR, nil, nil) -> ir.NewAssignListStmt(xpos, ir.OAS2MAPR, nil, nil)
ir.NodAt(xpos, ir.OAS2RECV, nil, nil) -> ir.NewAssignListStmt(xpos, ir.OAS2RECV, nil, nil)
ir.NodAt(xpos, ir.OSELRECV2, nil, nil) -> ir.NewAssignListStmt(xpos, ir.OSELRECV2, nil, nil)
ir.NodAt(xpos, ir.OASOP, l, r) -> ir.NewAssignOpStmt(xpos, ir.OXXX, l, r)
ir.NodAt(xpos, ir.OBITNOT, l, nil) -> ir.NewUnaryExpr(xpos, ir.OBITNOT, l)
ir.NodAt(xpos, ir.ONEG, l, nil) -> ir.NewUnaryExpr(xpos, ir.ONEG, l)
ir.NodAt(xpos, ir.ONOT, l, nil) -> ir.NewUnaryExpr(xpos, ir.ONOT, l)
ir.NodAt(xpos, ir.OPLUS, l, nil) -> ir.NewUnaryExpr(xpos, ir.OPLUS, l)
ir.NodAt(xpos, ir.ORECV, l, nil) -> ir.NewUnaryExpr(xpos, ir.ORECV, l)
ir.NodAt(xpos, ir.OALIGNOF, l, nil) -> ir.NewUnaryExpr(xpos, ir.OALIGNOF, l)
ir.NodAt(xpos, ir.OCAP, l, nil) -> ir.NewUnaryExpr(xpos, ir.OCAP, l)
ir.NodAt(xpos, ir.OCLOSE, l, nil) -> ir.NewUnaryExpr(xpos, ir.OCLOSE, l)
ir.NodAt(xpos, ir.OIMAG, l, nil) -> ir.NewUnaryExpr(xpos, ir.OIMAG, l)
ir.NodAt(xpos, ir.OLEN, l, nil) -> ir.NewUnaryExpr(xpos, ir.OLEN, l)
ir.NodAt(xpos, ir.ONEW, l, nil) -> ir.NewUnaryExpr(xpos, ir.ONEW, l)
ir.NodAt(xpos, ir.ONEWOBJ, l, nil) -> ir.NewUnaryExpr(xpos, ir.ONEWOBJ, l)
ir.NodAt(xpos, ir.OOFFSETOF, l, nil) -> ir.NewUnaryExpr(xpos, ir.OOFFSETOF, l)
ir.NodAt(xpos, ir.OPANIC, l, nil) -> ir.NewUnaryExpr(xpos, ir.OPANIC, l)
ir.NodAt(xpos, ir.OREAL, l, nil) -> ir.NewUnaryExpr(xpos, ir.OREAL, l)
ir.NodAt(xpos, ir.OSIZEOF, l, nil) -> ir.NewUnaryExpr(xpos, ir.OSIZEOF, l)
ir.NodAt(xpos, ir.OCHECKNIL, l, nil) -> ir.NewUnaryExpr(xpos, ir.OCHECKNIL, l)
ir.NodAt(xpos, ir.OCFUNC, l, nil) -> ir.NewUnaryExpr(xpos, ir.OCFUNC, l)
ir.NodAt(xpos, ir.OIDATA, l, nil) -> ir.NewUnaryExpr(xpos, ir.OIDATA, l)
ir.NodAt(xpos, ir.OITAB, l, nil) -> ir.NewUnaryExpr(xpos, ir.OITAB, l)
ir.NodAt(xpos, ir.OSPTR, l, nil) -> ir.NewUnaryExpr(xpos, ir.OSPTR, l)
ir.NodAt(xpos, ir.OVARDEF, l, nil) -> ir.NewUnaryExpr(xpos, ir.OVARDEF, l)
ir.NodAt(xpos, ir.OVARKILL, l, nil) -> ir.NewUnaryExpr(xpos, ir.OVARKILL, l)
ir.NodAt(xpos, ir.OVARLIVE, l, nil) -> ir.NewUnaryExpr(xpos, ir.OVARLIVE, l)
ir.NodAt(xpos, ir.OBLOCK, nil, nil) -> ir.NewBlockStmt(xpos, nil)
ir.NodAt(xpos, ir.OBREAK, nil, nil) -> ir.NewBranchStmt(xpos, ir.OBREAK, nil)
ir.NodAt(xpos, ir.OCONTINUE, nil, nil) -> ir.NewBranchStmt(xpos, ir.OCONTINUE, nil)
ir.NodAt(xpos, ir.OFALL, nil, nil) -> ir.NewBranchStmt(xpos, ir.OFALL, nil)
ir.NodAt(xpos, ir.OGOTO, nil, nil) -> ir.NewBranchStmt(xpos, ir.OGOTO, nil)
ir.NodAt(xpos, ir.ORETJMP, nil, nil) -> ir.NewBranchStmt(xpos, ir.ORETJMP, nil)
ir.NodAt(xpos, ir.OCALL, l, nil) -> ir.NewCallExpr(xpos, ir.OCALL, l, nil)
ir.NodAt(xpos, ir.OCALLFUNC, l, nil) -> ir.NewCallExpr(xpos, ir.OCALLFUNC, l, nil)
ir.NodAt(xpos, ir.OCALLINTER, l, nil) -> ir.NewCallExpr(xpos, ir.OCALLINTER, l, nil)
ir.NodAt(xpos, ir.OCALLMETH, l, nil) -> ir.NewCallExpr(xpos, ir.OCALLMETH, l, nil)
ir.NodAt(xpos, ir.OAPPEND, l, nil) -> ir.NewCallExpr(xpos, ir.OAPPEND, l, nil)
ir.NodAt(xpos, ir.ODELETE, l, nil) -> ir.NewCallExpr(xpos, ir.ODELETE, l, nil)
ir.NodAt(xpos, ir.OGETG, l, nil) -> ir.NewCallExpr(xpos, ir.OGETG, l, nil)
ir.NodAt(xpos, ir.OMAKE, l, nil) -> ir.NewCallExpr(xpos, ir.OMAKE, l, nil)
ir.NodAt(xpos, ir.OPRINT, l, nil) -> ir.NewCallExpr(xpos, ir.OPRINT, l, nil)
ir.NodAt(xpos, ir.OPRINTN, l, nil) -> ir.NewCallExpr(xpos, ir.OPRINTN, l, nil)
ir.NodAt(xpos, ir.ORECOVER, l, nil) -> ir.NewCallExpr(xpos, ir.ORECOVER, l, nil)
ir.NodAt(xpos, ir.OCASE, nil, nil) -> ir.NewCaseStmt(xpos, nil, nil)
ir.NodAt(xpos, ir.OCONV, l, nil) -> ir.NewConvExpr(xpos, ir.OCONV, nil, l)
ir.NodAt(xpos, ir.OCONVIFACE, l, nil) -> ir.NewConvExpr(xpos, ir.OCONVIFACE, nil, l)
ir.NodAt(xpos, ir.OCONVNOP, l, nil) -> ir.NewConvExpr(xpos, ir.OCONVNOP, nil, l)
ir.NodAt(xpos, ir.ORUNESTR, l, nil) -> ir.NewConvExpr(xpos, ir.ORUNESTR, nil, l)
ir.NodAt(xpos, ir.ODCL, l, nil) -> ir.NewDecl(xpos, ir.ODCL, l)
ir.NodAt(xpos, ir.ODCLCONST, l, nil) -> ir.NewDecl(xpos, ir.ODCLCONST, l)
ir.NodAt(xpos, ir.ODCLTYPE, l, nil) -> ir.NewDecl(xpos, ir.ODCLTYPE, l)
ir.NodAt(xpos, ir.ODCLFUNC, nil, nil) -> ir.NewFunc(xpos)
ir.NodAt(xpos, ir.ODEFER, l, nil) -> ir.NewGoDeferStmt(xpos, ir.ODEFER, l)
ir.NodAt(xpos, ir.OGO, l, nil) -> ir.NewGoDeferStmt(xpos, ir.OGO, l)
ir.NodAt(xpos, ir.ODEREF, l, nil) -> ir.NewStarExpr(xpos, l)
ir.NodAt(xpos, ir.ODOT, l, nil) -> ir.NewSelectorExpr(xpos, ir.ODOT, l, nil)
ir.NodAt(xpos, ir.ODOTPTR, l, nil) -> ir.NewSelectorExpr(xpos, ir.ODOTPTR, l, nil)
ir.NodAt(xpos, ir.ODOTMETH, l, nil) -> ir.NewSelectorExpr(xpos, ir.ODOTMETH, l, nil)
ir.NodAt(xpos, ir.ODOTINTER, l, nil) -> ir.NewSelectorExpr(xpos, ir.ODOTINTER, l, nil)
ir.NodAt(xpos, ir.OXDOT, l, nil) -> ir.NewSelectorExpr(xpos, ir.OXDOT, l, nil)
ir.NodAt(xpos, ir.ODOTTYPE, l, nil) -> ir.NewTypeAssertExpr(xpos, l, nil)
ir.NodAt(xpos, ir.ODOTTYPE, l, r) -> ir.NewTypeAssertExpr(xpos, l, r.(ir.Ntype))
ir.NodAt(xpos, ir.OFOR, l, r) -> ir.NewForStmt(xpos, nil, l, r, nil)
ir.NodAt(xpos, ir.OINDEX, l, r) -> ir.NewIndexExpr(xpos, l, r)
ir.NodAt(xpos, ir.OINLMARK, nil, nil) -> ir.NewInlineMarkStmt(xpos, types.BADWIDTH)
ir.NodAt(xpos, ir.OKEY, l, r) -> ir.NewKeyExpr(xpos, l, r)
ir.NodAt(xpos, ir.OLABEL, nil, nil) -> ir.NewLabelStmt(xpos, nil)
ir.NodAt(xpos, ir.OMAKECHAN, l, r) -> ir.NewMakeExpr(xpos, ir.OMAKECHAN, l, r)
ir.NodAt(xpos, ir.OMAKEMAP, l, r) -> ir.NewMakeExpr(xpos, ir.OMAKEMAP, l, r)
ir.NodAt(xpos, ir.OMAKESLICE, l, r) -> ir.NewMakeExpr(xpos, ir.OMAKESLICE, l, r)
ir.NodAt(xpos, ir.OMAKESLICECOPY, l, r) -> ir.NewMakeExpr(xpos, ir.OMAKESLICECOPY, l, r)
ir.NodAt(xpos, ir.ONIL, nil, nil) -> ir.NewNilExpr(xpos)
ir.NodAt(xpos, ir.OPACK, nil, nil) -> ir.NewPkgName(xpos, nil, nil)
ir.NodAt(xpos, ir.OPAREN, l, nil) -> ir.NewParenExpr(xpos, l)
ir.NodAt(xpos, ir.ORANGE, nil, r) -> ir.NewRangeStmt(xpos, nil, r, nil)
ir.NodAt(xpos, ir.ORESULT, nil, nil) -> ir.NewResultExpr(xpos, nil, types.BADWIDTH)
ir.NodAt(xpos, ir.ORETURN, nil, nil) -> ir.NewReturnStmt(xpos, nil)
ir.NodAt(xpos, ir.OSELECT, nil, nil) -> ir.NewSelectStmt(xpos, nil)
ir.NodAt(xpos, ir.OSEND, l, r) -> ir.NewSendStmt(xpos, l, r)
ir.NodAt(xpos, ir.OSLICE, l, nil) -> ir.NewSliceExpr(xpos, ir.OSLICE, l)
ir.NodAt(xpos, ir.OSLICEARR, l, nil) -> ir.NewSliceExpr(xpos, ir.OSLICEARR, l)
ir.NodAt(xpos, ir.OSLICESTR, l, nil) -> ir.NewSliceExpr(xpos, ir.OSLICESTR, l)
ir.NodAt(xpos, ir.OSLICE3, l, nil) -> ir.NewSliceExpr(xpos, ir.OSLICE3, l)
ir.NodAt(xpos, ir.OSLICE3ARR, l, nil) -> ir.NewSliceExpr(xpos, ir.OSLICE3ARR, l)
ir.NodAt(xpos, ir.OSLICEHEADER, l, nil) -> ir.NewSliceHeaderExpr(xpos, nil, l, nil, nil)
ir.NodAt(xpos, ir.OSWITCH, l, nil) -> ir.NewSwitchStmt(xpos, l, nil)
ir.NodAt(xpos, ir.OINLCALL, nil, nil) -> ir.NewInlinedCallExpr(xpos, nil, nil)
}
rm noder.nod noder.nodSym nodSym nodlSym ir.NodAt ir.Nod
'
Change-Id: Ibf1eb708de8463ae74ccc47d7966cc263a18295e
Reviewed-on: https://go-review.googlesource.com/c/go/+/277933
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
// for i := 0; i < nelem; i++
ni := temp(types.Types[types.TINT])
- init := ir.Nod(ir.OAS, ni, nodintconst(0))
- cond := ir.Nod(ir.OLT, ni, nodintconst(t.NumElem()))
- post := ir.Nod(ir.OAS, ni, ir.Nod(ir.OADD, ni, nodintconst(1)))
- loop := ir.Nod(ir.OFOR, cond, post)
+ init := ir.NewAssignStmt(base.Pos, ni, nodintconst(0))
+ cond := ir.NewBinaryExpr(base.Pos, ir.OLT, ni, nodintconst(t.NumElem()))
+ post := ir.NewAssignStmt(base.Pos, ni, ir.NewBinaryExpr(base.Pos, ir.OADD, ni, nodintconst(1)))
+ loop := ir.NewForStmt(base.Pos, nil, cond, post, nil)
loop.PtrInit().Append(init)
// h = hashel(&p[i], h)
- call := ir.Nod(ir.OCALL, hashel, nil)
+ call := ir.NewCallExpr(base.Pos, ir.OCALL, hashel, nil)
- nx := ir.Nod(ir.OINDEX, np, ni)
+ nx := ir.NewIndexExpr(base.Pos, np, ni)
nx.SetBounded(true)
na := nodAddr(nx)
call.PtrList().Append(na)
call.PtrList().Append(nh)
- loop.PtrBody().Append(ir.Nod(ir.OAS, nh, call))
+ loop.PtrBody().Append(ir.NewAssignStmt(base.Pos, nh, call))
fn.PtrBody().Append(loop)
// Hash non-memory fields with appropriate hash function.
if !IsRegularMemory(f.Type) {
hashel := hashfor(f.Type)
- call := ir.Nod(ir.OCALL, hashel, nil)
- nx := nodSym(ir.OXDOT, np, f.Sym) // TODO: fields from other packages?
+ call := ir.NewCallExpr(base.Pos, ir.OCALL, hashel, nil)
+ nx := ir.NewSelectorExpr(base.Pos, ir.OXDOT, np, f.Sym) // TODO: fields from other packages?
na := nodAddr(nx)
call.PtrList().Append(na)
call.PtrList().Append(nh)
- fn.PtrBody().Append(ir.Nod(ir.OAS, nh, call))
+ fn.PtrBody().Append(ir.NewAssignStmt(base.Pos, nh, call))
i++
continue
}
// h = hashel(&p.first, size, h)
hashel := hashmem(f.Type)
- call := ir.Nod(ir.OCALL, hashel, nil)
- nx := nodSym(ir.OXDOT, np, f.Sym) // TODO: fields from other packages?
+ call := ir.NewCallExpr(base.Pos, ir.OCALL, hashel, nil)
+ nx := ir.NewSelectorExpr(base.Pos, ir.OXDOT, np, f.Sym) // TODO: fields from other packages?
na := nodAddr(nx)
call.PtrList().Append(na)
call.PtrList().Append(nh)
call.PtrList().Append(nodintconst(size))
- fn.PtrBody().Append(ir.Nod(ir.OAS, nh, call))
+ fn.PtrBody().Append(ir.NewAssignStmt(base.Pos, nh, call))
i = next
}
}
- r := ir.Nod(ir.ORETURN, nil, nil)
+ r := ir.NewReturnStmt(base.Pos, nil)
r.PtrList().Append(nh)
fn.PtrBody().Append(r)
// checkIdx generates a node to check for equality at index i.
checkIdx := func(i ir.Node) ir.Node {
// pi := p[i]
- pi := ir.Nod(ir.OINDEX, np, i)
+ pi := ir.NewIndexExpr(base.Pos, np, i)
pi.SetBounded(true)
pi.SetType(t.Elem())
// qi := q[i]
- qi := ir.Nod(ir.OINDEX, nq, i)
+ qi := ir.NewIndexExpr(base.Pos, nq, i)
qi.SetBounded(true)
qi.SetType(t.Elem())
return eq(pi, qi)
// Generate a series of checks.
for i := int64(0); i < nelem; i++ {
// if check {} else { goto neq }
- nif := ir.Nod(ir.OIF, checkIdx(nodintconst(i)), nil)
- nif.PtrRlist().Append(nodSym(ir.OGOTO, nil, neq))
+ nif := ir.NewIfStmt(base.Pos, checkIdx(nodintconst(i)), nil, nil)
+ nif.PtrRlist().Append(ir.NewBranchStmt(base.Pos, ir.OGOTO, neq))
fn.PtrBody().Append(nif)
}
if last {
- fn.PtrBody().Append(ir.Nod(ir.OAS, nr, checkIdx(nodintconst(nelem))))
+ fn.PtrBody().Append(ir.NewAssignStmt(base.Pos, nr, checkIdx(nodintconst(nelem))))
}
} else {
// Generate a for loop.
// for i := 0; i < nelem; i++
i := temp(types.Types[types.TINT])
- init := ir.Nod(ir.OAS, i, nodintconst(0))
- cond := ir.Nod(ir.OLT, i, nodintconst(nelem))
- post := ir.Nod(ir.OAS, i, ir.Nod(ir.OADD, i, nodintconst(1)))
- loop := ir.Nod(ir.OFOR, cond, post)
+ init := ir.NewAssignStmt(base.Pos, i, nodintconst(0))
+ cond := ir.NewBinaryExpr(base.Pos, ir.OLT, i, nodintconst(nelem))
+ post := ir.NewAssignStmt(base.Pos, i, ir.NewBinaryExpr(base.Pos, ir.OADD, i, nodintconst(1)))
+ loop := ir.NewForStmt(base.Pos, nil, cond, post, nil)
loop.PtrInit().Append(init)
// if eq(pi, qi) {} else { goto neq }
- nif := ir.Nod(ir.OIF, checkIdx(i), nil)
- nif.PtrRlist().Append(nodSym(ir.OGOTO, nil, neq))
+ nif := ir.NewIfStmt(base.Pos, checkIdx(i), nil, nil)
+ nif.PtrRlist().Append(ir.NewBranchStmt(base.Pos, ir.OGOTO, neq))
loop.PtrBody().Append(nif)
fn.PtrBody().Append(loop)
if last {
- fn.PtrBody().Append(ir.Nod(ir.OAS, nr, nodbool(true)))
+ fn.PtrBody().Append(ir.NewAssignStmt(base.Pos, nr, nodbool(true)))
}
}
}
case types.TFLOAT32, types.TFLOAT64:
checkAll(2, true, func(pi, qi ir.Node) ir.Node {
// p[i] == q[i]
- return ir.Nod(ir.OEQ, pi, qi)
+ return ir.NewBinaryExpr(base.Pos, ir.OEQ, pi, qi)
})
// TODO: pick apart structs, do them piecemeal too
default:
checkAll(1, true, func(pi, qi ir.Node) ir.Node {
// p[i] == q[i]
- return ir.Nod(ir.OEQ, pi, qi)
+ return ir.NewBinaryExpr(base.Pos, ir.OEQ, pi, qi)
})
}
// Enforce ordering by starting a new set of reorderable conditions.
conds = append(conds, []ir.Node{})
}
- p := nodSym(ir.OXDOT, np, f.Sym)
- q := nodSym(ir.OXDOT, nq, f.Sym)
+ p := ir.NewSelectorExpr(base.Pos, ir.OXDOT, np, f.Sym)
+ q := ir.NewSelectorExpr(base.Pos, ir.OXDOT, nq, f.Sym)
switch {
case f.Type.IsString():
eqlen, eqmem := eqstring(p, q)
and(eqlen)
and(eqmem)
default:
- and(ir.Nod(ir.OEQ, p, q))
+ and(ir.NewBinaryExpr(base.Pos, ir.OEQ, p, q))
}
if EqCanPanic(f.Type) {
// Also enforce ordering after something that can panic.
}
if len(flatConds) == 0 {
- fn.PtrBody().Append(ir.Nod(ir.OAS, nr, nodbool(true)))
+ fn.PtrBody().Append(ir.NewAssignStmt(base.Pos, nr, nodbool(true)))
} else {
for _, c := range flatConds[:len(flatConds)-1] {
// if cond {} else { goto neq }
- n := ir.Nod(ir.OIF, c, nil)
- n.PtrRlist().Append(nodSym(ir.OGOTO, nil, neq))
+ n := ir.NewIfStmt(base.Pos, c, nil, nil)
+ n.PtrRlist().Append(ir.NewBranchStmt(base.Pos, ir.OGOTO, neq))
fn.PtrBody().Append(n)
}
- fn.PtrBody().Append(ir.Nod(ir.OAS, nr, flatConds[len(flatConds)-1]))
+ fn.PtrBody().Append(ir.NewAssignStmt(base.Pos, nr, flatConds[len(flatConds)-1]))
}
}
// ret:
// return
ret := autolabel(".ret")
- fn.PtrBody().Append(nodSym(ir.OLABEL, nil, ret))
- fn.PtrBody().Append(ir.Nod(ir.ORETURN, nil, nil))
+ fn.PtrBody().Append(ir.NewLabelStmt(base.Pos, ret))
+ fn.PtrBody().Append(ir.NewReturnStmt(base.Pos, nil))
// neq:
// r = false
// return (or goto ret)
- fn.PtrBody().Append(nodSym(ir.OLABEL, nil, neq))
- fn.PtrBody().Append(ir.Nod(ir.OAS, nr, nodbool(false)))
+ fn.PtrBody().Append(ir.NewLabelStmt(base.Pos, neq))
+ fn.PtrBody().Append(ir.NewAssignStmt(base.Pos, nr, nodbool(false)))
if EqCanPanic(t) || anyCall(fn) {
// Epilogue is large, so share it with the equal case.
- fn.PtrBody().Append(nodSym(ir.OGOTO, nil, ret))
+ fn.PtrBody().Append(ir.NewBranchStmt(base.Pos, ir.OGOTO, ret))
} else {
// Epilogue is small, so don't bother sharing.
- fn.PtrBody().Append(ir.Nod(ir.ORETURN, nil, nil))
+ fn.PtrBody().Append(ir.NewReturnStmt(base.Pos, nil))
}
// TODO(khr): the epilogue size detection condition above isn't perfect.
// We should really do a generic CL that shares epilogues across
// eqfield returns the node
// p.field == q.field
func eqfield(p ir.Node, q ir.Node, field *types.Sym) ir.Node {
- nx := nodSym(ir.OXDOT, p, field)
- ny := nodSym(ir.OXDOT, q, field)
- ne := ir.Nod(ir.OEQ, nx, ny)
+ nx := ir.NewSelectorExpr(base.Pos, ir.OXDOT, p, field)
+ ny := ir.NewSelectorExpr(base.Pos, ir.OXDOT, q, field)
+ ne := ir.NewBinaryExpr(base.Pos, ir.OEQ, nx, ny)
return ne
}
func eqstring(s, t ir.Node) (eqlen *ir.BinaryExpr, eqmem *ir.CallExpr) {
s = conv(s, types.Types[types.TSTRING])
t = conv(t, types.Types[types.TSTRING])
- sptr := ir.Nod(ir.OSPTR, s, nil)
- tptr := ir.Nod(ir.OSPTR, t, nil)
- slen := conv(ir.Nod(ir.OLEN, s, nil), types.Types[types.TUINTPTR])
- tlen := conv(ir.Nod(ir.OLEN, t, nil), types.Types[types.TUINTPTR])
+ sptr := ir.NewUnaryExpr(base.Pos, ir.OSPTR, s)
+ tptr := ir.NewUnaryExpr(base.Pos, ir.OSPTR, t)
+ slen := conv(ir.NewUnaryExpr(base.Pos, ir.OLEN, s), types.Types[types.TUINTPTR])
+ tlen := conv(ir.NewUnaryExpr(base.Pos, ir.OLEN, t), types.Types[types.TUINTPTR])
fn := syslook("memequal")
fn = substArgTypes(fn, types.Types[types.TUINT8], types.Types[types.TUINT8])
fn = syslook("ifaceeq")
}
- stab := ir.Nod(ir.OITAB, s, nil)
- ttab := ir.Nod(ir.OITAB, t, nil)
- sdata := ir.Nod(ir.OIDATA, s, nil)
- tdata := ir.Nod(ir.OIDATA, t, nil)
+ stab := ir.NewUnaryExpr(base.Pos, ir.OITAB, s)
+ ttab := ir.NewUnaryExpr(base.Pos, ir.OITAB, t)
+ sdata := ir.NewUnaryExpr(base.Pos, ir.OIDATA, s)
+ tdata := ir.NewUnaryExpr(base.Pos, ir.OIDATA, t)
sdata.SetType(types.Types[types.TUNSAFEPTR])
tdata.SetType(types.Types[types.TUNSAFEPTR])
sdata.SetTypecheck(1)
// eqmem returns the node
// memequal(&p.field, &q.field [, size])
func eqmem(p ir.Node, q ir.Node, field *types.Sym, size int64) ir.Node {
- nx := typecheck(nodAddr(nodSym(ir.OXDOT, p, field)), ctxExpr)
- ny := typecheck(nodAddr(nodSym(ir.OXDOT, q, field)), ctxExpr)
+ nx := typecheck(nodAddr(ir.NewSelectorExpr(base.Pos, ir.OXDOT, p, field)), ctxExpr)
+ ny := typecheck(nodAddr(ir.NewSelectorExpr(base.Pos, ir.OXDOT, q, field)), ctxExpr)
fn, needsize := eqmemfunc(size, nx.Type().Elem())
- call := ir.Nod(ir.OCALL, fn, nil)
+ call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
call.PtrList().Append(nx)
call.PtrList().Append(ny)
if needsize {
// If it is a small variable captured by value, downgrade it to PAUTO.
v.SetClass(ir.PAUTO)
fn.Dcl = append(fn.Dcl, v)
- body = append(body, ir.Nod(ir.OAS, v, cr))
+ body = append(body, ir.NewAssignStmt(base.Pos, v, cr))
} else {
// Declare variable holding addresses taken from closure
// and initialize in entry prologue.
if v.Byval() {
src = nodAddr(cr)
}
- body = append(body, ir.Nod(ir.OAS, addr, src))
+ body = append(body, ir.NewAssignStmt(base.Pos, addr, src))
}
}
typ := closureType(clo)
- clos := ir.Nod(ir.OCOMPLIT, nil, ir.TypeNode(typ))
+ clos := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(typ).(ir.Ntype), nil)
clos.SetEsc(clo.Esc())
- clos.PtrList().Set(append([]ir.Node{ir.Nod(ir.OCFUNC, fn.Nname, nil)}, fn.ClosureEnter.Slice()...))
+ clos.PtrList().Set(append([]ir.Node{ir.NewUnaryExpr(base.Pos, ir.OCFUNC, fn.Nname)}, fn.ClosureEnter.Slice()...))
addr := nodAddr(clos)
addr.SetEsc(clo.Esc())
var body []ir.Node
if rcvrtype.IsPtr() || rcvrtype.IsInterface() {
ptr.SetType(rcvrtype)
- body = append(body, ir.Nod(ir.OAS, ptr, cr))
+ body = append(body, ir.NewAssignStmt(base.Pos, ptr, cr))
} else {
ptr.SetType(types.NewPtr(rcvrtype))
- body = append(body, ir.Nod(ir.OAS, ptr, nodAddr(cr)))
+ body = append(body, ir.NewAssignStmt(base.Pos, ptr, nodAddr(cr)))
}
- call := ir.Nod(ir.OCALL, nodSym(ir.OXDOT, ptr, meth), nil)
+ call := ir.NewCallExpr(base.Pos, ir.OCALL, ir.NewSelectorExpr(base.Pos, ir.OXDOT, ptr, meth), nil)
call.PtrList().Set(paramNnames(tfn.Type()))
call.SetIsDDD(tfn.Type().IsVariadic())
if t0.NumResults() != 0 {
- ret := ir.Nod(ir.ORETURN, nil, nil)
+ ret := ir.NewReturnStmt(base.Pos, nil)
ret.PtrList().Set1(call)
body = append(body, ret)
} else {
n.SetLeft(cheapexpr(n.Left(), init))
n.SetLeft(walkexpr(n.Left(), nil))
- tab := typecheck(ir.Nod(ir.OITAB, n.Left(), nil), ctxExpr)
+ tab := typecheck(ir.NewUnaryExpr(base.Pos, ir.OITAB, n.Left()), ctxExpr)
- c := ir.Nod(ir.OCHECKNIL, tab, nil)
+ c := ir.NewUnaryExpr(base.Pos, ir.OCHECKNIL, tab)
c.SetTypecheck(1)
init.Append(c)
}
typ := partialCallType(n)
- clos := ir.Nod(ir.OCOMPLIT, nil, ir.TypeNode(typ))
+ clos := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(typ).(ir.Ntype), nil)
clos.SetEsc(n.Esc())
- clos.PtrList().Set2(ir.Nod(ir.OCFUNC, n.Func().Nname, nil), n.Left())
+ clos.PtrList().Set2(ir.NewUnaryExpr(base.Pos, ir.OCFUNC, n.Func().Nname), n.Left())
addr := nodAddr(clos)
addr.SetEsc(n.Esc())
if len(el) == 1 && len(vl) > 1 {
e := el[0]
- as2 := ir.Nod(ir.OAS2, nil, nil)
+ as2 := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
as2.PtrRlist().Set1(e)
for _, v := range vl {
as2.PtrList().Append(v)
v.Ntype = t
v.Defn = as2
if Curfn != nil {
- init = append(init, ir.Nod(ir.ODCL, v, nil))
+ init = append(init, ir.NewDecl(base.Pos, ir.ODCL, v))
}
}
if e != nil || Curfn != nil || ir.IsBlank(v) {
if Curfn != nil {
- init = append(init, ir.Nod(ir.ODCL, v, nil))
+ init = append(init, ir.NewDecl(base.Pos, ir.ODCL, v))
}
- as := ir.Nod(ir.OAS, v, e)
+ as := ir.NewAssignStmt(base.Pos, v, e)
init = append(init, as)
if e != nil {
v.Defn = as
n := NewName(n.Sym())
declare(n, dclcontext)
n.Defn = defn
- defn.PtrInit().Append(ir.Nod(ir.ODCL, n, nil))
+ defn.PtrInit().Append(ir.NewDecl(base.Pos, ir.ODCL, n))
left[i] = n
}
// OTAILCALL or something to this effect.
var tail ir.Node
if tfn.Type().NumResults() == 0 && tfn.Type().NumParams() == 0 && tfn.Type().NumRecvs() == 0 {
- tail = nodSym(ir.ORETJMP, nil, f.Nname.Sym())
+ tail = ir.NewBranchStmt(base.Pos, ir.ORETJMP, f.Nname.Sym())
} else {
- call := ir.Nod(ir.OCALL, f.Nname, nil)
+ call := ir.NewCallExpr(base.Pos, ir.OCALL, f.Nname, nil)
call.PtrList().Set(paramNnames(tfn.Type()))
call.SetIsDDD(tfn.Type().IsVariadic())
tail = call
if tfn.Type().NumResults() > 0 {
- n := ir.Nod(ir.ORETURN, nil, nil)
+ n := ir.NewReturnStmt(base.Pos, nil)
n.PtrList().Set1(call)
tail = n
}
cases := make([]ir.Node, r.uint64())
for i := range cases {
- cas := ir.NodAt(r.pos(), ir.OCASE, nil, nil)
+ cas := ir.NewCaseStmt(r.pos(), nil, nil)
cas.PtrList().Set(r.stmtList())
if namedTypeSwitch {
// Note: per-case variables will have distinct, dotted
// TODO(mdempsky): Export position information for OSTRUCTKEY nodes.
savedlineno := base.Pos
base.Pos = r.pos()
- n := ir.NodAt(base.Pos, ir.OCOMPLIT, nil, ir.TypeNode(r.typ()))
+ n := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(r.typ()).(ir.Ntype), nil)
n.PtrList().Set(r.elemList()) // special handling of field names
base.Pos = savedlineno
return n
// unreachable - mapped to case OCOMPLIT below by exporter
case ir.OCOMPLIT:
- n := ir.NodAt(r.pos(), ir.OCOMPLIT, nil, ir.TypeNode(r.typ()))
+ n := ir.NewCompLitExpr(r.pos(), ir.OCOMPLIT, ir.TypeNode(r.typ()).(ir.Ntype), nil)
n.PtrList().Set(r.exprList())
return n
case ir.OKEY:
pos := r.pos()
left, right := r.exprsOrNil()
- return ir.NodAt(pos, ir.OKEY, left, right)
+ return ir.NewKeyExpr(pos, left, right)
// case OSTRUCTKEY:
// unreachable - handled in case OSTRUCTLIT by elemList
case ir.OXDOT:
// see parser.new_dotname
- return npos(r.pos(), nodSym(ir.OXDOT, r.expr(), r.ident()))
+ return ir.NewSelectorExpr(r.pos(), ir.OXDOT, r.expr(), r.ident())
// case ODOTTYPE, ODOTTYPE2:
// unreachable - mapped to case ODOTTYPE below by exporter
case ir.ODOTTYPE:
- n := ir.NodAt(r.pos(), ir.ODOTTYPE, r.expr(), nil)
+ n := ir.NewTypeAssertExpr(r.pos(), r.expr(), nil)
n.SetType(r.typ())
return n
// unreachable - mapped to cases below by exporter
case ir.OINDEX:
- return ir.NodAt(r.pos(), ir.OINDEX, r.expr(), r.expr())
+ return ir.NewIndexExpr(r.pos(), r.expr(), r.expr())
case ir.OSLICE, ir.OSLICE3:
n := ir.NewSliceExpr(r.pos(), op, r.expr())
// unreachable - mapped to OCONV case below by exporter
case ir.OCONV:
- n := ir.NodAt(r.pos(), ir.OCONV, r.expr(), nil)
+ n := ir.NewConvExpr(r.pos(), ir.OCONV, nil, r.expr())
n.SetType(r.typ())
return n
// unreachable - mapped to OCALL case below by exporter
case ir.OCALL:
- n := ir.NodAt(r.pos(), ir.OCALL, nil, nil)
+ n := ir.NewCallExpr(r.pos(), ir.OCALL, nil, nil)
n.PtrInit().Set(r.stmtList())
n.SetLeft(r.expr())
n.PtrList().Set(r.exprList())
list := r.exprList()
x := npos(pos, list[0])
for _, y := range list[1:] {
- x = ir.NodAt(pos, ir.OADD, x, y)
+ x = ir.NewBinaryExpr(pos, ir.OADD, x, y)
}
return x
declare(lhs, ir.PAUTO)
var stmts ir.Nodes
- stmts.Append(ir.Nod(ir.ODCL, lhs, nil))
- stmts.Append(ir.Nod(ir.OAS, lhs, nil))
- return npos(pos, liststmt(stmts.Slice()))
+ stmts.Append(ir.NewDecl(base.Pos, ir.ODCL, lhs))
+ stmts.Append(ir.NewAssignStmt(base.Pos, lhs, nil))
+ return ir.NewBlockStmt(pos, stmts.Slice())
// case OAS, OASWB:
// unreachable - mapped to OAS case below by exporter
case ir.OAS:
- return ir.NodAt(r.pos(), ir.OAS, r.expr(), r.expr())
+ return ir.NewAssignStmt(r.pos(), r.expr(), r.expr())
case ir.OASOP:
- n := ir.NodAt(r.pos(), ir.OASOP, nil, nil)
+ n := ir.NewAssignOpStmt(r.pos(), ir.OXXX, nil, nil)
n.SetSubOp(r.op())
n.SetLeft(r.expr())
if !r.bool() {
// unreachable - mapped to OAS2 case below by exporter
case ir.OAS2:
- n := ir.NodAt(r.pos(), ir.OAS2, nil, nil)
+ n := ir.NewAssignListStmt(r.pos(), ir.OAS2, nil, nil)
n.PtrList().Set(r.exprList())
n.PtrRlist().Set(r.exprList())
return n
case ir.ORETURN:
- n := ir.NodAt(r.pos(), ir.ORETURN, nil, nil)
+ n := ir.NewReturnStmt(r.pos(), nil)
n.PtrList().Set(r.exprList())
return n
return ir.NewGoDeferStmt(r.pos(), op, r.expr())
case ir.OIF:
- n := ir.NodAt(r.pos(), ir.OIF, nil, nil)
+ n := ir.NewIfStmt(r.pos(), nil, nil, nil)
n.PtrInit().Set(r.stmtList())
n.SetLeft(r.expr())
n.PtrBody().Set(r.stmtList())
return n
case ir.OFOR:
- n := ir.NodAt(r.pos(), ir.OFOR, nil, nil)
+ n := ir.NewForStmt(r.pos(), nil, nil, nil, nil)
n.PtrInit().Set(r.stmtList())
left, right := r.exprsOrNil()
n.SetLeft(left)
return n
case ir.ORANGE:
- n := ir.NodAt(r.pos(), ir.ORANGE, nil, nil)
+ n := ir.NewRangeStmt(r.pos(), nil, nil, nil)
n.PtrList().Set(r.stmtList())
n.SetRight(r.expr())
n.PtrBody().Set(r.stmtList())
return n
case ir.OSELECT:
- n := ir.NodAt(r.pos(), ir.OSELECT, nil, nil)
+ n := ir.NewSelectStmt(r.pos(), nil)
n.PtrInit().Set(r.stmtList())
r.exprsOrNil() // TODO(rsc): Delete (and fix exporter). These are always nil.
n.PtrList().Set(r.caseList(n))
return n
case ir.OSWITCH:
- n := ir.NodAt(r.pos(), ir.OSWITCH, nil, nil)
+ n := ir.NewSwitchStmt(r.pos(), nil, nil)
n.PtrInit().Set(r.stmtList())
left, _ := r.exprsOrNil()
n.SetLeft(left)
// handled by caseList
case ir.OFALL:
- n := ir.NodAt(r.pos(), ir.OFALL, nil, nil)
+ n := ir.NewBranchStmt(r.pos(), ir.OFALL, nil)
return n
// case OEMPTY:
list := make([]ir.Node, c)
for i := range list {
s := r.ident()
- list[i] = nodSym(ir.OSTRUCTKEY, r.expr(), s)
+ list[i] = ir.NewStructKeyExpr(base.Pos, s, r.expr())
}
return list
}
// Turn an OINLCALL into a statement.
func inlconv2stmt(inlcall *ir.InlinedCallExpr) ir.Node {
- n := ir.NodAt(inlcall.Pos(), ir.OBLOCK, nil, nil)
+ n := ir.NewBlockStmt(inlcall.Pos(), nil)
n.SetList(inlcall.Init())
n.PtrList().AppendNodes(inlcall.PtrBody())
return n
if inlvar == nil {
base.Fatalf("missing inlvar for %v", n)
}
- as.PtrInit().Append(ir.Nod(ir.ODCL, inlvar, nil))
+ as.PtrInit().Append(ir.NewDecl(base.Pos, ir.ODCL, inlvar))
inlvar.Name().Defn = as
return inlvar
}
if v.Byval() {
iv := typecheck(inlvar(v), ctxExpr)
- ninit.Append(ir.Nod(ir.ODCL, iv, nil))
- ninit.Append(typecheck(ir.Nod(ir.OAS, iv, o), ctxStmt))
+ ninit.Append(ir.NewDecl(base.Pos, ir.ODCL, iv))
+ ninit.Append(typecheck(ir.NewAssignStmt(base.Pos, iv, o), ctxStmt))
inlvars[v] = iv
} else {
addr := NewName(lookup("&" + v.Sym().Name))
addr.SetType(types.NewPtr(v.Type()))
ia := typecheck(inlvar(addr), ctxExpr)
- ninit.Append(ir.Nod(ir.ODCL, ia, nil))
- ninit.Append(typecheck(ir.Nod(ir.OAS, ia, nodAddr(o)), ctxStmt))
+ ninit.Append(ir.NewDecl(base.Pos, ir.ODCL, ia))
+ ninit.Append(typecheck(ir.NewAssignStmt(base.Pos, ia, nodAddr(o)), ctxStmt))
inlvars[addr] = ia
// When capturing by reference, all occurrence of the captured var
// must be substituted with dereference of the temporary address
- inlvars[v] = typecheck(ir.Nod(ir.ODEREF, ia, nil), ctxExpr)
+ inlvars[v] = typecheck(ir.NewStarExpr(base.Pos, ia), ctxExpr)
}
}
}
}
// Assign arguments to the parameters' temp names.
- as := ir.Nod(ir.OAS2, nil, nil)
+ as := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
as.SetColas(true)
if n.Op() == ir.OCALLMETH {
sel := n.Left().(*ir.SelectorExpr)
vas.SetRight(nodnil())
vas.Right().SetType(param.Type)
} else {
- lit := ir.Nod(ir.OCOMPLIT, nil, ir.TypeNode(param.Type))
+ lit := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(param.Type).(ir.Ntype), nil)
lit.PtrList().Set(varargs)
vas.SetRight(lit)
}
if !delayretvars {
// Zero the return parameters.
for _, n := range retvars {
- ninit.Append(ir.Nod(ir.ODCL, n, nil))
- ras := ir.Nod(ir.OAS, n, nil)
+ ninit.Append(ir.NewDecl(base.Pos, ir.ODCL, n))
+ ras := ir.NewAssignStmt(base.Pos, n, nil)
ninit.Append(typecheck(ras, ctxStmt))
}
}
// to put a breakpoint. Not sure if that's really necessary or not
// (in which case it could go at the end of the function instead).
// Note issue 28603.
- inlMark := ir.Nod(ir.OINLMARK, nil, nil)
+ inlMark := ir.NewInlineMarkStmt(base.Pos, types.BADWIDTH)
inlMark.SetPos(n.Pos().WithIsStmt())
inlMark.SetOffset(int64(newIndex))
ninit.Append(inlMark)
body := subst.list(ir.AsNodes(fn.Inl.Body))
- lab := nodSym(ir.OLABEL, nil, retlabel)
+ lab := ir.NewLabelStmt(base.Pos, retlabel)
body = append(body, lab)
typecheckslice(body, ctxStmt)
//dumplist("ninit post", ninit);
- call := ir.Nod(ir.OINLCALL, nil, nil)
+ call := ir.NewInlinedCallExpr(base.Pos, nil, nil)
call.PtrInit().Set(ninit.Slice())
call.PtrBody().Set(body)
call.PtrRlist().Set(retvars)
// this return is guaranteed to belong to the current inlined function.
init := subst.list(n.Init())
if len(subst.retvars) != 0 && n.List().Len() != 0 {
- as := ir.Nod(ir.OAS2, nil, nil)
+ as := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
// Make a shallow copy of retvars.
// Otherwise OINLCALL.Rlist will be the same list,
if subst.delayretvars {
for _, n := range as.List().Slice() {
- as.PtrInit().Append(ir.Nod(ir.ODCL, n, nil))
+ as.PtrInit().Append(ir.NewDecl(base.Pos, ir.ODCL, n))
n.Name().Defn = as
}
}
init = append(init, typecheck(as, ctxStmt))
}
- init = append(init, nodSym(ir.OGOTO, nil, subst.retlabel))
+ init = append(init, ir.NewBranchStmt(base.Pos, ir.OGOTO, subst.retlabel))
typecheckslice(init, ctxStmt)
return ir.NewBlockStmt(base.Pos, init)
return
}
- dt := ir.NodAt(sel.Pos(), ir.ODOTTYPE, sel.Left(), nil)
+ dt := ir.NewTypeAssertExpr(sel.Pos(), sel.Left(), nil)
dt.SetType(typ)
- x := typecheck(nodlSym(sel.Pos(), ir.OXDOT, dt, sel.Sym()), ctxExpr|ctxCallee)
+ x := typecheck(ir.NewSelectorExpr(sel.Pos(), ir.OXDOT, dt, sel.Sym()), ctxExpr|ctxCallee)
switch x.Op() {
case ir.ODOTMETH:
if base.Flag.LowerM != 0 {
if block != nil {
body := p.stmts(block.List)
if body == nil {
- body = []ir.Node{ir.Nod(ir.OBLOCK, nil, nil)}
+ body = []ir.Node{ir.NewBlockStmt(base.Pos, nil)}
}
fn.PtrBody().Set(body)
n.Defn = v
n.SetIota(cs.iota)
- nn = append(nn, p.nod(decl, ir.ODCLCONST, n, nil))
+ nn = append(nn, ir.NewDecl(p.pos(decl), ir.ODCLCONST, n))
}
if len(values) > len(names) {
p.checkUnused(pragma)
}
- nod := p.nod(decl, ir.ODCLTYPE, n, nil)
+ nod := ir.NewDecl(p.pos(decl), ir.ODCLTYPE, n)
if n.Alias() && !langSupported(1, 9, types.LocalPkg) {
base.ErrorfAt(nod.Pos(), "type aliases only supported as of -lang=go1.9")
}
n.SetDiag(expr.Bad) // avoid follow-on errors if there was a syntax error
return n
case *syntax.CompositeLit:
- n := p.nod(expr, ir.OCOMPLIT, nil, nil)
+ n := ir.NewCompLitExpr(p.pos(expr), ir.OCOMPLIT, nil, nil)
if expr.Type != nil {
n.SetRight(p.expr(expr.Type))
}
return n
case *syntax.KeyValueExpr:
// use position of expr.Key rather than of expr (which has position of ':')
- return p.nod(expr.Key, ir.OKEY, p.expr(expr.Key), p.wrapname(expr.Value, p.expr(expr.Value)))
+ return ir.NewKeyExpr(p.pos(expr.Key), p.expr(expr.Key), p.wrapname(expr.Value, p.expr(expr.Value)))
case *syntax.FuncLit:
return p.funcLit(expr)
case *syntax.ParenExpr:
- return p.nod(expr, ir.OPAREN, p.expr(expr.X), nil)
+ return ir.NewParenExpr(p.pos(expr), p.expr(expr.X))
case *syntax.SelectorExpr:
// parser.new_dotname
obj := p.expr(expr.X)
pack.Used = true
return importName(pack.Pkg.Lookup(expr.Sel.Value))
}
- n := nodSym(ir.OXDOT, obj, p.name(expr.Sel))
+ n := ir.NewSelectorExpr(base.Pos, ir.OXDOT, obj, p.name(expr.Sel))
n.SetPos(p.pos(expr)) // lineno may have been changed by p.expr(expr.X)
return n
case *syntax.IndexExpr:
- return p.nod(expr, ir.OINDEX, p.expr(expr.X), p.expr(expr.Index))
+ return ir.NewIndexExpr(p.pos(expr), p.expr(expr.X), p.expr(expr.Index))
case *syntax.SliceExpr:
op := ir.OSLICE
if expr.Full {
n.SetSliceBounds(index[0], index[1], index[2])
return n
case *syntax.AssertExpr:
- return p.nod(expr, ir.ODOTTYPE, p.expr(expr.X), p.typeExpr(expr.Type))
+ return ir.NewTypeAssertExpr(p.pos(expr), p.expr(expr.X), p.typeExpr(expr.Type).(ir.Ntype))
case *syntax.Operation:
if expr.Op == syntax.Add && expr.Y != nil {
return p.sum(expr)
}
return ir.NewBinaryExpr(pos, op, x, y)
case *syntax.CallExpr:
- n := p.nod(expr, ir.OCALL, p.expr(expr.Fun), nil)
+ n := ir.NewCallExpr(p.pos(expr), ir.OCALL, p.expr(expr.Fun), nil)
n.PtrList().Set(p.exprs(expr.ArgList))
n.SetIsDDD(expr.HasDots)
return n
nstr = nil
chunks = chunks[:0]
}
- n = p.nod(add, ir.OADD, n, r)
+ n = ir.NewBinaryExpr(p.pos(add), ir.OADD, n, r)
}
if len(chunks) > 1 {
nstr.SetVal(constant.MakeString(strings.Join(chunks, "")))
l := p.blockStmt(stmt)
if len(l) == 0 {
// TODO(mdempsky): Line number?
- return ir.Nod(ir.OBLOCK, nil, nil)
+ return ir.NewBlockStmt(base.Pos, nil)
}
return liststmt(l)
case *syntax.ExprStmt:
return p.wrapname(stmt, p.expr(stmt.X))
case *syntax.SendStmt:
- return p.nod(stmt, ir.OSEND, p.expr(stmt.Chan), p.expr(stmt.Value))
+ return ir.NewSendStmt(p.pos(stmt), p.expr(stmt.Chan), p.expr(stmt.Value))
case *syntax.DeclStmt:
return liststmt(p.decls(stmt.DeclList))
case *syntax.AssignStmt:
rhs := p.exprList(stmt.Rhs)
if list, ok := stmt.Lhs.(*syntax.ListExpr); ok && len(list.ElemList) != 1 || len(rhs) != 1 {
- n := p.nod(stmt, ir.OAS2, nil, nil)
+ n := ir.NewAssignListStmt(p.pos(stmt), ir.OAS2, nil, nil)
n.SetColas(stmt.Op == syntax.Def)
n.PtrList().Set(p.assignList(stmt.Lhs, n, n.Colas()))
n.PtrRlist().Set(rhs)
return n
}
- n := p.nod(stmt, ir.OAS, nil, nil)
+ n := ir.NewAssignStmt(p.pos(stmt), nil, nil)
n.SetColas(stmt.Op == syntax.Def)
n.SetLeft(p.assignList(stmt.Lhs, n, n.Colas())[0])
n.SetRight(rhs[0])
if stmt.Results != nil {
results = p.exprList(stmt.Results)
}
- n := p.nod(stmt, ir.ORETURN, nil, nil)
+ n := ir.NewReturnStmt(p.pos(stmt), nil)
n.PtrList().Set(results)
if n.List().Len() == 0 && Curfn != nil {
for _, ln := range Curfn.Dcl {
n := NewName(sym)
declare(n, dclcontext)
n.Defn = defn
- defn.PtrInit().Append(ir.Nod(ir.ODCL, n, nil))
+ defn.PtrInit().Append(ir.NewDecl(base.Pos, ir.ODCL, n))
res[i] = n
}
func (p *noder) ifStmt(stmt *syntax.IfStmt) ir.Node {
p.openScope(stmt.Pos())
- n := p.nod(stmt, ir.OIF, nil, nil)
+ n := ir.NewIfStmt(p.pos(stmt), nil, nil, nil)
if stmt.Init != nil {
n.PtrInit().Set1(p.stmt(stmt.Init))
}
panic("unexpected RangeClause")
}
- n := p.nod(r, ir.ORANGE, nil, p.expr(r.X))
+ n := ir.NewRangeStmt(p.pos(r), nil, p.expr(r.X), nil)
if r.Lhs != nil {
n.SetColas(r.Def)
n.PtrList().Set(p.assignList(r.Lhs, n, n.Colas()))
return n
}
- n := p.nod(stmt, ir.OFOR, nil, nil)
+ n := ir.NewForStmt(p.pos(stmt), nil, nil, nil, nil)
if stmt.Init != nil {
n.PtrInit().Set1(p.stmt(stmt.Init))
}
func (p *noder) switchStmt(stmt *syntax.SwitchStmt) ir.Node {
p.openScope(stmt.Pos())
- n := p.nod(stmt, ir.OSWITCH, nil, nil)
+ n := ir.NewSwitchStmt(p.pos(stmt), nil, nil)
if stmt.Init != nil {
n.PtrInit().Set1(p.stmt(stmt.Init))
}
}
p.openScope(clause.Pos())
- n := p.nod(clause, ir.OCASE, nil, nil)
+ n := ir.NewCaseStmt(p.pos(clause), nil, nil)
if clause.Cases != nil {
n.PtrList().Set(p.exprList(clause.Cases))
}
}
func (p *noder) selectStmt(stmt *syntax.SelectStmt) ir.Node {
- n := p.nod(stmt, ir.OSELECT, nil, nil)
+ n := ir.NewSelectStmt(p.pos(stmt), nil)
n.PtrList().Set(p.commClauses(stmt.Body, stmt.Rbrace))
return n
}
}
p.openScope(clause.Pos())
- n := p.nod(clause, ir.OCASE, nil, nil)
+ n := ir.NewCaseStmt(p.pos(clause), nil, nil)
if clause.Comm != nil {
n.PtrList().Set1(p.stmt(clause.Comm))
}
func (p *noder) labeledStmt(label *syntax.LabeledStmt, fallOK bool) ir.Node {
sym := p.name(label.Label)
- lhs := p.nodSym(label, ir.OLABEL, nil, sym)
+ lhs := ir.NewLabelStmt(p.pos(label), sym)
var ls ir.Node
if label.Stmt != nil { // TODO(mdempsky): Should always be present.
}
fallthrough
case ir.ONAME, ir.ONONAME, ir.OPACK:
- p := p.nod(n, ir.OPAREN, x, nil)
+ p := ir.NewParenExpr(p.pos(n), x)
p.SetImplicit(true)
return p
}
return x
}
-func (p *noder) nod(orig syntax.Node, op ir.Op, left, right ir.Node) ir.Node {
- return ir.NodAt(p.pos(orig), op, left, right)
-}
-
-func (p *noder) nodSym(orig syntax.Node, op ir.Op, left ir.Node, sym *types.Sym) ir.Node {
- n := nodSym(op, left, sym)
- n.SetPos(p.pos(orig))
- return n
-}
-
func (p *noder) pos(n syntax.Node) src.XPos {
// TODO(gri): orig.Pos() should always be known - fix package syntax
xpos := base.Pos
v = temp(t)
}
if clear {
- o.append(ir.Nod(ir.OAS, v, nil))
+ o.append(ir.NewAssignStmt(base.Pos, v, nil))
}
o.temp = append(o.temp, v)
func (o *Order) copyExpr1(n ir.Node, clear bool) *ir.Name {
t := n.Type()
v := o.newTemp(t, clear)
- o.append(ir.Nod(ir.OAS, v, n))
+ o.append(ir.NewAssignStmt(base.Pos, v, n))
return v
}
var out []ir.Node
for i := len(o.temp) - 1; i >= int(mark); i-- {
n := o.temp[i]
- out = append(out, typecheck(ir.Nod(ir.OVARKILL, n, nil), ctxStmt))
+ out = append(out, typecheck(ir.NewUnaryExpr(base.Pos, ir.OVARKILL, n), ctxStmt))
}
return out
}
x := o.copyExpr(arg.Left())
arg.SetLeft(x)
x.Name().SetAddrtaken(true) // ensure SSA keeps the x variable
- n.PtrBody().Append(typecheck(ir.Nod(ir.OVARLIVE, x, nil), ctxStmt))
+ n.PtrBody().Append(typecheck(ir.NewUnaryExpr(base.Pos, ir.OVARLIVE, x), ctxStmt))
}
}
}
case instrumenting && n.Op() == ir.OAS2FUNC && !ir.IsBlank(m):
t := o.newTemp(m.Type(), false)
n.List().SetIndex(i, t)
- a := ir.Nod(ir.OAS, m, t)
+ a := ir.NewAssignStmt(base.Pos, m, t)
post = append(post, typecheck(a, ctxStmt))
}
}
}
l2 = o.copyExpr(l2)
r := o.expr(typecheck(ir.NewBinaryExpr(n.Pos(), n.SubOp(), l2, n.Right()), ctxExpr), nil)
- as := typecheck(ir.NodAt(n.Pos(), ir.OAS, l1, r), ctxStmt)
+ as := typecheck(ir.NewAssignStmt(n.Pos(), l1, r), ctxStmt)
o.mapAssign(as)
o.cleanTemp(t)
return
r := n.Right()
if r.Type().IsString() && r.Type() != types.Types[types.TSTRING] {
- r = ir.Nod(ir.OCONV, r, nil)
+ r = ir.NewConvExpr(base.Pos, ir.OCONV, nil, r)
r.SetType(types.Types[types.TSTRING])
r = typecheck(r, ctxExpr)
}
if len(init) > 0 && init[0].Op() == ir.ODCL && init[0].(*ir.Decl).Left() == n {
init = init[1:]
}
- dcl := typecheck(ir.Nod(ir.ODCL, n, nil), ctxStmt)
+ dcl := typecheck(ir.NewDecl(base.Pos, ir.ODCL, n), ctxStmt)
ncas.PtrInit().Append(dcl)
}
tmp := o.newTemp(t, t.HasPointers())
- as := typecheck(ir.Nod(ir.OAS, n, conv(tmp, n.Type())), ctxStmt)
+ as := typecheck(ir.NewAssignStmt(base.Pos, n, conv(tmp, n.Type())), ctxStmt)
ncas.PtrInit().Append(as)
r.PtrList().SetIndex(i, tmp)
}
n := n.(*ir.SwitchStmt)
if base.Debug.Libfuzzer != 0 && !hasDefaultCase(n) {
// Add empty "default:" case for instrumentation.
- n.PtrList().Append(ir.Nod(ir.OCASE, nil, nil))
+ n.PtrList().Append(ir.NewCaseStmt(base.Pos, nil, nil))
}
t := o.markTemp()
// Evaluate left-hand side.
lhs := o.expr(n.Left(), nil)
- o.out = append(o.out, typecheck(ir.Nod(ir.OAS, r, lhs), ctxStmt))
+ o.out = append(o.out, typecheck(ir.NewAssignStmt(base.Pos, r, lhs), ctxStmt))
// Evaluate right-hand side, save generated code.
saveout := o.out
t := o.markTemp()
o.edge()
rhs := o.expr(n.Right(), nil)
- o.out = append(o.out, typecheck(ir.Nod(ir.OAS, r, rhs), ctxStmt))
+ o.out = append(o.out, typecheck(ir.NewAssignStmt(base.Pos, r, rhs), ctxStmt))
o.cleanTemp(t)
gen := o.out
o.out = saveout
// If left-hand side doesn't cause a short-circuit, issue right-hand side.
- nif := ir.Nod(ir.OIF, r, nil)
+ nif := ir.NewIfStmt(base.Pos, r, nil, nil)
if n.Op() == ir.OANDAND {
nif.PtrBody().Set(gen)
} else {
// Emit the creation of the map (with all its static entries).
m := o.newTemp(n.Type(), false)
- as := ir.Nod(ir.OAS, m, n)
+ as := ir.NewAssignStmt(base.Pos, m, n)
typecheck(as, ctxStmt)
o.stmt(as)
// Emit eval+insert of dynamic entries, one at a time.
for _, r := range dynamics {
- as := ir.Nod(ir.OAS, ir.Nod(ir.OINDEX, m, r.Left()), r.Right())
+ as := ir.NewAssignStmt(base.Pos, ir.NewIndexExpr(base.Pos, m, r.Left()), r.Right())
typecheck(as, ctxStmt) // Note: this converts the OINDEX to an OINDEXMAP
o.stmt(as)
}
o.out = append(o.out, n)
- as := ir.Nod(ir.OAS2, nil, nil)
+ as := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
as.PtrList().Set(left)
as.PtrRlist().Set(tmplist)
o.stmt(typecheck(as, ctxStmt))
o.out = append(o.out, n)
if tmp1 != nil {
- r := ir.Nod(ir.OAS, n.List().First(), tmp1)
+ r := ir.NewAssignStmt(base.Pos, n.List().First(), tmp1)
o.mapAssign(typecheck(r, ctxStmt))
n.List().SetFirst(tmp1)
}
if tmp2 != nil {
- r := ir.Nod(ir.OAS, n.List().Second(), conv(tmp2, n.List().Second().Type()))
+ r := ir.NewAssignStmt(base.Pos, n.List().Second(), conv(tmp2, n.List().Second().Type()))
o.mapAssign(typecheck(r, ctxStmt))
n.List().SetSecond(tmp2)
}
return n
}
- nfor := ir.NodAt(nrange.Pos(), ir.OFOR, nil, nil)
+ nfor := ir.NewForStmt(nrange.Pos(), nil, nil, nil, nil)
nfor.SetInit(nrange.Init())
nfor.SetSym(nrange.Sym())
hv1 := temp(types.Types[types.TINT])
hn := temp(types.Types[types.TINT])
- init = append(init, ir.Nod(ir.OAS, hv1, nil))
- init = append(init, ir.Nod(ir.OAS, hn, ir.Nod(ir.OLEN, ha, nil)))
+ init = append(init, ir.NewAssignStmt(base.Pos, hv1, nil))
+ init = append(init, ir.NewAssignStmt(base.Pos, hn, ir.NewUnaryExpr(base.Pos, ir.OLEN, ha)))
- nfor.SetLeft(ir.Nod(ir.OLT, hv1, hn))
- nfor.SetRight(ir.Nod(ir.OAS, hv1, ir.Nod(ir.OADD, hv1, nodintconst(1))))
+ nfor.SetLeft(ir.NewBinaryExpr(base.Pos, ir.OLT, hv1, hn))
+ nfor.SetRight(ir.NewAssignStmt(base.Pos, hv1, ir.NewBinaryExpr(base.Pos, ir.OADD, hv1, nodintconst(1))))
// for range ha { body }
if v1 == nil {
// for v1 := range ha { body }
if v2 == nil {
- body = []ir.Node{ir.Nod(ir.OAS, v1, hv1)}
+ body = []ir.Node{ir.NewAssignStmt(base.Pos, v1, hv1)}
break
}
// for v1, v2 := range ha { body }
if cheapComputableIndex(nrange.Type().Elem().Width) {
// v1, v2 = hv1, ha[hv1]
- tmp := ir.Nod(ir.OINDEX, ha, hv1)
+ tmp := ir.NewIndexExpr(base.Pos, ha, hv1)
tmp.SetBounded(true)
// Use OAS2 to correctly handle assignments
// of the form "v1, a[v1] := range".
- a := ir.Nod(ir.OAS2, nil, nil)
+ a := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
a.PtrList().Set2(v1, v2)
a.PtrRlist().Set2(hv1, tmp)
body = []ir.Node{a}
// elimination on the index variable (see #20711).
// Enhance the prove pass to understand this.
ifGuard = ir.NewIfStmt(base.Pos, nil, nil, nil)
- ifGuard.SetLeft(ir.Nod(ir.OLT, hv1, hn))
+ ifGuard.SetLeft(ir.NewBinaryExpr(base.Pos, ir.OLT, hv1, hn))
nfor.SetOp(ir.OFORUNTIL)
hp := temp(types.NewPtr(nrange.Type().Elem()))
- tmp := ir.Nod(ir.OINDEX, ha, nodintconst(0))
+ tmp := ir.NewIndexExpr(base.Pos, ha, nodintconst(0))
tmp.SetBounded(true)
- init = append(init, ir.Nod(ir.OAS, hp, nodAddr(tmp)))
+ init = append(init, ir.NewAssignStmt(base.Pos, hp, nodAddr(tmp)))
// Use OAS2 to correctly handle assignments
// of the form "v1, a[v1] := range".
- a := ir.Nod(ir.OAS2, nil, nil)
+ a := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
a.PtrList().Set2(v1, v2)
- a.PtrRlist().Set2(hv1, ir.Nod(ir.ODEREF, hp, nil))
+ a.PtrRlist().Set2(hv1, ir.NewStarExpr(base.Pos, hp))
body = append(body, a)
// Advance pointer as part of the late increment.
// This runs *after* the condition check, so we know
// advancing the pointer is safe and won't go past the
// end of the allocation.
- as := ir.Nod(ir.OAS, hp, addptr(hp, t.Elem().Width))
+ as := ir.NewAssignStmt(base.Pos, hp, addptr(hp, t.Elem().Width))
nfor.PtrList().Set1(typecheck(as, ctxStmt))
case types.TMAP:
fn = substArgTypes(fn, t.Key(), t.Elem(), th)
init = append(init, mkcall1(fn, nil, nil, typename(t), ha, nodAddr(hit)))
- nfor.SetLeft(ir.Nod(ir.ONE, nodSym(ir.ODOT, hit, keysym), nodnil()))
+ nfor.SetLeft(ir.NewBinaryExpr(base.Pos, ir.ONE, ir.NewSelectorExpr(base.Pos, ir.ODOT, hit, keysym), nodnil()))
fn = syslook("mapiternext")
fn = substArgTypes(fn, th)
nfor.SetRight(mkcall1(fn, nil, nil, nodAddr(hit)))
- key := ir.Nod(ir.ODEREF, nodSym(ir.ODOT, hit, keysym), nil)
+ key := ir.NewStarExpr(base.Pos, ir.NewSelectorExpr(base.Pos, ir.ODOT, hit, keysym))
if v1 == nil {
body = nil
} else if v2 == nil {
- body = []ir.Node{ir.Nod(ir.OAS, v1, key)}
+ body = []ir.Node{ir.NewAssignStmt(base.Pos, v1, key)}
} else {
- elem := ir.Nod(ir.ODEREF, nodSym(ir.ODOT, hit, elemsym), nil)
- a := ir.Nod(ir.OAS2, nil, nil)
+ elem := ir.NewStarExpr(base.Pos, ir.NewSelectorExpr(base.Pos, ir.ODOT, hit, elemsym))
+ a := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
a.PtrList().Set2(v1, v2)
a.PtrRlist().Set2(key, elem)
body = []ir.Node{a}
hv1 := temp(t.Elem())
hv1.SetTypecheck(1)
if t.Elem().HasPointers() {
- init = append(init, ir.Nod(ir.OAS, hv1, nil))
+ init = append(init, ir.NewAssignStmt(base.Pos, hv1, nil))
}
hb := temp(types.Types[types.TBOOL])
- nfor.SetLeft(ir.Nod(ir.ONE, hb, nodbool(false)))
- a := ir.Nod(ir.OAS2RECV, nil, nil)
+ nfor.SetLeft(ir.NewBinaryExpr(base.Pos, ir.ONE, hb, nodbool(false)))
+ a := ir.NewAssignListStmt(base.Pos, ir.OAS2RECV, nil, nil)
a.SetTypecheck(1)
a.PtrList().Set2(hv1, hb)
- a.PtrRlist().Set1(ir.Nod(ir.ORECV, ha, nil))
+ a.PtrRlist().Set1(ir.NewUnaryExpr(base.Pos, ir.ORECV, ha))
nfor.Left().PtrInit().Set1(a)
if v1 == nil {
body = nil
} else {
- body = []ir.Node{ir.Nod(ir.OAS, v1, hv1)}
+ body = []ir.Node{ir.NewAssignStmt(base.Pos, v1, hv1)}
}
// Zero hv1. This prevents hv1 from being the sole, inaccessible
// reference to an otherwise GC-able value during the next channel receive.
// See issue 15281.
- body = append(body, ir.Nod(ir.OAS, hv1, nil))
+ body = append(body, ir.NewAssignStmt(base.Pos, hv1, nil))
case types.TSTRING:
// Transform string range statements like "for v1, v2 = range a" into
hv2 := temp(types.RuneType)
// hv1 := 0
- init = append(init, ir.Nod(ir.OAS, hv1, nil))
+ init = append(init, ir.NewAssignStmt(base.Pos, hv1, nil))
// hv1 < len(ha)
- nfor.SetLeft(ir.Nod(ir.OLT, hv1, ir.Nod(ir.OLEN, ha, nil)))
+ nfor.SetLeft(ir.NewBinaryExpr(base.Pos, ir.OLT, hv1, ir.NewUnaryExpr(base.Pos, ir.OLEN, ha)))
if v1 != nil {
// hv1t = hv1
- body = append(body, ir.Nod(ir.OAS, hv1t, hv1))
+ body = append(body, ir.NewAssignStmt(base.Pos, hv1t, hv1))
}
// hv2 := rune(ha[hv1])
- nind := ir.Nod(ir.OINDEX, ha, hv1)
+ nind := ir.NewIndexExpr(base.Pos, ha, hv1)
nind.SetBounded(true)
- body = append(body, ir.Nod(ir.OAS, hv2, conv(nind, types.RuneType)))
+ body = append(body, ir.NewAssignStmt(base.Pos, hv2, conv(nind, types.RuneType)))
// if hv2 < utf8.RuneSelf
- nif := ir.Nod(ir.OIF, nil, nil)
- nif.SetLeft(ir.Nod(ir.OLT, hv2, nodintconst(utf8.RuneSelf)))
+ nif := ir.NewIfStmt(base.Pos, nil, nil, nil)
+ nif.SetLeft(ir.NewBinaryExpr(base.Pos, ir.OLT, hv2, nodintconst(utf8.RuneSelf)))
// hv1++
- nif.PtrBody().Set1(ir.Nod(ir.OAS, hv1, ir.Nod(ir.OADD, hv1, nodintconst(1))))
+ nif.PtrBody().Set1(ir.NewAssignStmt(base.Pos, hv1, ir.NewBinaryExpr(base.Pos, ir.OADD, hv1, nodintconst(1))))
// } else {
- eif := ir.Nod(ir.OAS2, nil, nil)
+ eif := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
nif.PtrRlist().Set1(eif)
// hv2, hv1 = decoderune(ha, hv1)
if v1 != nil {
if v2 != nil {
// v1, v2 = hv1t, hv2
- a := ir.Nod(ir.OAS2, nil, nil)
+ a := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
a.PtrList().Set2(v1, v2)
a.PtrRlist().Set2(hv1t, hv2)
body = append(body, a)
} else {
// v1 = hv1t
- body = append(body, ir.Nod(ir.OAS, v1, hv1t))
+ body = append(body, ir.NewAssignStmt(base.Pos, v1, hv1t))
}
}
}
// memclr{NoHeap,Has}Pointers(hp, hn)
// i = len(a) - 1
// }
- n := ir.Nod(ir.OIF, nil, nil)
+ n := ir.NewIfStmt(base.Pos, nil, nil, nil)
n.PtrBody().Set(nil)
- n.SetLeft(ir.Nod(ir.ONE, ir.Nod(ir.OLEN, a, nil), nodintconst(0)))
+ n.SetLeft(ir.NewBinaryExpr(base.Pos, ir.ONE, ir.NewUnaryExpr(base.Pos, ir.OLEN, a), nodintconst(0)))
// hp = &a[0]
hp := temp(types.Types[types.TUNSAFEPTR])
- ix := ir.Nod(ir.OINDEX, a, nodintconst(0))
+ ix := ir.NewIndexExpr(base.Pos, a, nodintconst(0))
ix.SetBounded(true)
addr := convnop(nodAddr(ix), types.Types[types.TUNSAFEPTR])
- n.PtrBody().Append(ir.Nod(ir.OAS, hp, addr))
+ n.PtrBody().Append(ir.NewAssignStmt(base.Pos, hp, addr))
// hn = len(a) * sizeof(elem(a))
hn := temp(types.Types[types.TUINTPTR])
- mul := conv(ir.Nod(ir.OMUL, ir.Nod(ir.OLEN, a, nil), nodintconst(elemsize)), types.Types[types.TUINTPTR])
- n.PtrBody().Append(ir.Nod(ir.OAS, hn, mul))
+ mul := conv(ir.NewBinaryExpr(base.Pos, ir.OMUL, ir.NewUnaryExpr(base.Pos, ir.OLEN, a), nodintconst(elemsize)), types.Types[types.TUINTPTR])
+ n.PtrBody().Append(ir.NewAssignStmt(base.Pos, hn, mul))
var fn ir.Node
if a.Type().Elem().HasPointers() {
n.PtrBody().Append(fn)
// i = len(a) - 1
- v1 = ir.Nod(ir.OAS, v1, ir.Nod(ir.OSUB, ir.Nod(ir.OLEN, a, nil), nodintconst(1)))
+ v1 = ir.NewAssignStmt(base.Pos, v1, ir.NewBinaryExpr(base.Pos, ir.OSUB, ir.NewUnaryExpr(base.Pos, ir.OLEN, a), nodintconst(1)))
n.PtrBody().Append(v1)
func addptr(p ir.Node, n int64) ir.Node {
t := p.Type()
- p = ir.Nod(ir.OCONVNOP, p, nil)
+ p = ir.NewConvExpr(base.Pos, ir.OCONVNOP, nil, p)
p.SetType(types.Types[types.TUINTPTR])
- p = ir.Nod(ir.OADD, p, nodintconst(n))
+ p = ir.NewBinaryExpr(base.Pos, ir.OADD, p, nodintconst(n))
- p = ir.Nod(ir.OCONVNOP, p, nil)
+ p = ir.NewConvExpr(base.Pos, ir.OCONVNOP, nil, p)
p.SetType(t)
return p
ncase.SetLeft(n)
ncase.PtrList().Set(nil)
oselrecv2 := func(dst, recv ir.Node, colas bool) {
- n := ir.NodAt(n.Pos(), ir.OSELRECV2, nil, nil)
+ n := ir.NewAssignListStmt(n.Pos(), ir.OSELRECV2, nil, nil)
n.PtrList().Set2(dst, ir.BlankNode)
n.PtrRlist().Set1(recv)
n.SetColas(colas)
}
l = append(l, cas.Body().Slice()...)
- l = append(l, ir.Nod(ir.OBREAK, nil, nil))
+ l = append(l, ir.NewBranchStmt(base.Pos, ir.OBREAK, nil))
return l
}
n := cas.Left()
setlineno(n)
- r := ir.Nod(ir.OIF, nil, nil)
+ r := ir.NewIfStmt(base.Pos, nil, nil, nil)
r.PtrInit().Set(cas.Init().Slice())
var call ir.Node
switch n.Op() {
r.SetLeft(typecheck(call, ctxExpr))
r.PtrBody().Set(cas.Body().Slice())
r.PtrRlist().Set(append(dflt.Init().Slice(), dflt.Body().Slice()...))
- return []ir.Node{r, ir.Nod(ir.OBREAK, nil, nil)}
+ return []ir.Node{r, ir.NewBranchStmt(base.Pos, ir.OBREAK, nil)}
}
if dflt != nil {
// generate sel-struct
base.Pos = sellineno
selv := temp(types.NewArray(scasetype(), int64(ncas)))
- init = append(init, typecheck(ir.Nod(ir.OAS, selv, nil), ctxStmt))
+ init = append(init, typecheck(ir.NewAssignStmt(base.Pos, selv, nil), ctxStmt))
// No initialization for order; runtime.selectgo is responsible for that.
order := temp(types.NewArray(types.Types[types.TUINT16], 2*int64(ncas)))
var pc0, pcs ir.Node
if base.Flag.Race {
pcs = temp(types.NewArray(types.Types[types.TUINTPTR], int64(ncas)))
- pc0 = typecheck(nodAddr(ir.Nod(ir.OINDEX, pcs, nodintconst(0))), ctxExpr)
+ pc0 = typecheck(nodAddr(ir.NewIndexExpr(base.Pos, pcs, nodintconst(0))), ctxExpr)
} else {
pc0 = nodnil()
}
casorder[i] = cas
setField := func(f string, val ir.Node) {
- r := ir.Nod(ir.OAS, nodSym(ir.ODOT, ir.Nod(ir.OINDEX, selv, nodintconst(int64(i))), lookup(f)), val)
+ r := ir.NewAssignStmt(base.Pos, ir.NewSelectorExpr(base.Pos, ir.ODOT, ir.NewIndexExpr(base.Pos, selv, nodintconst(int64(i))), lookup(f)), val)
init = append(init, typecheck(r, ctxStmt))
}
// TODO(mdempsky): There should be a cleaner way to
// handle this.
if base.Flag.Race {
- r := mkcall("selectsetpc", nil, nil, nodAddr(ir.Nod(ir.OINDEX, pcs, nodintconst(int64(i)))))
+ r := mkcall("selectsetpc", nil, nil, nodAddr(ir.NewIndexExpr(base.Pos, pcs, nodintconst(int64(i)))))
init = append(init, r)
}
}
base.Pos = sellineno
chosen := temp(types.Types[types.TINT])
recvOK := temp(types.Types[types.TBOOL])
- r := ir.Nod(ir.OAS2, nil, nil)
+ r := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
r.PtrList().Set2(chosen, recvOK)
fn := syslook("selectgo")
r.PtrRlist().Set1(mkcall1(fn, fn.Type().Results(), nil, bytePtrToIndex(selv, 0), bytePtrToIndex(order, 0), pc0, nodintconst(int64(nsends)), nodintconst(int64(nrecvs)), nodbool(dflt == nil)))
init = append(init, typecheck(r, ctxStmt))
// selv and order are no longer alive after selectgo.
- init = append(init, ir.Nod(ir.OVARKILL, selv, nil))
- init = append(init, ir.Nod(ir.OVARKILL, order, nil))
+ init = append(init, ir.NewUnaryExpr(base.Pos, ir.OVARKILL, selv))
+ init = append(init, ir.NewUnaryExpr(base.Pos, ir.OVARKILL, order))
if base.Flag.Race {
- init = append(init, ir.Nod(ir.OVARKILL, pcs, nil))
+ init = append(init, ir.NewUnaryExpr(base.Pos, ir.OVARKILL, pcs))
}
// dispatch cases
cond = typecheck(cond, ctxExpr)
cond = defaultlit(cond, nil)
- r := ir.Nod(ir.OIF, cond, nil)
+ r := ir.NewIfStmt(base.Pos, cond, nil, nil)
if n := cas.Left(); n != nil && n.Op() == ir.OSELRECV2 {
if !ir.IsBlank(n.List().Second()) {
- x := ir.Nod(ir.OAS, n.List().Second(), recvOK)
+ x := ir.NewAssignStmt(base.Pos, n.List().Second(), recvOK)
r.PtrBody().Append(typecheck(x, ctxStmt))
}
}
r.PtrBody().AppendNodes(cas.PtrBody())
- r.PtrBody().Append(ir.Nod(ir.OBREAK, nil, nil))
+ r.PtrBody().Append(ir.NewBranchStmt(base.Pos, ir.OBREAK, nil))
init = append(init, r)
}
if dflt != nil {
setlineno(dflt)
- dispatch(ir.Nod(ir.OLT, chosen, nodintconst(0)), dflt)
+ dispatch(ir.NewBinaryExpr(base.Pos, ir.OLT, chosen, nodintconst(0)), dflt)
}
for i, cas := range casorder {
setlineno(cas)
- dispatch(ir.Nod(ir.OEQ, chosen, nodintconst(int64(i))), cas)
+ dispatch(ir.NewBinaryExpr(base.Pos, ir.OEQ, chosen, nodintconst(int64(i))), cas)
}
return init
// bytePtrToIndex returns a Node representing "(*byte)(&n[i])".
func bytePtrToIndex(n ir.Node, i int64) ir.Node {
- s := nodAddr(ir.Nod(ir.OINDEX, n, nodintconst(i)))
+ s := nodAddr(ir.NewIndexExpr(base.Pos, n, nodintconst(i)))
t := types.NewPtr(types.Types[types.TUINT8])
return convnop(s, t)
}
if loff != 0 || !types.Identical(typ, l.Type()) {
dst = ir.NewNameOffsetExpr(base.Pos, l, loff, typ)
}
- s.append(ir.Nod(ir.OAS, dst, conv(r, typ)))
+ s.append(ir.NewAssignStmt(base.Pos, dst, conv(r, typ)))
return true
case ir.ONIL:
ll := ir.NewNameOffsetExpr(base.Pos, l, loff+e.Xoffset, typ)
rr := ir.NewNameOffsetExpr(base.Pos, orig, e.Xoffset, typ)
setlineno(rr)
- s.append(ir.Nod(ir.OAS, ll, rr))
+ s.append(ir.NewAssignStmt(base.Pos, ll, rr))
}
return true
// Init underlying literal.
if !s.staticassign(a, 0, r.Left(), a.Type()) {
- s.append(ir.Nod(ir.OAS, a, r.Left()))
+ s.append(ir.NewAssignStmt(base.Pos, a, r.Left()))
}
return true
}
setlineno(e.Expr)
if !s.staticassign(l, loff+e.Xoffset, e.Expr, e.Expr.Type()) {
a := ir.NewNameOffsetExpr(base.Pos, l, loff+e.Xoffset, e.Expr.Type())
- s.append(ir.Nod(ir.OAS, a, e.Expr))
+ s.append(ir.NewAssignStmt(base.Pos, a, e.Expr))
}
}
setlineno(val)
if !s.staticassign(l, loff+int64(Widthptr), val, val.Type()) {
a := ir.NewNameOffsetExpr(base.Pos, l, loff+int64(Widthptr), val.Type())
- s.append(ir.Nod(ir.OAS, a, val))
+ s.append(ir.NewAssignStmt(base.Pos, a, val))
}
} else {
// Construct temp to hold val, write pointer to temp into n.
a := staticname(val.Type())
s.inittemps[val] = a
if !s.staticassign(a, 0, val, val.Type()) {
- s.append(ir.Nod(ir.OAS, a, val))
+ s.append(ir.NewAssignStmt(base.Pos, a, val))
}
addrsym(l, loff+int64(Widthptr), a, 0)
}
}
func litas(l ir.Node, r ir.Node, init *ir.Nodes) {
- appendWalkStmt(init, ir.Nod(ir.OAS, l, r))
+ appendWalkStmt(init, ir.NewAssignStmt(base.Pos, l, r))
}
// initGenType is a bitmap indicating the types of generation that will occur for a static value.
}
r = kv.Right()
}
- a := ir.Nod(ir.OINDEX, var_, nodintconst(k))
+ a := ir.NewIndexExpr(base.Pos, var_, nodintconst(k))
k++
if isBlank {
return ir.BlankNode, r
return ir.BlankNode, r.Left()
}
setlineno(r)
- return nodSym(ir.ODOT, var_, r.Sym()), r.Left()
+ return ir.NewSelectorExpr(base.Pos, ir.ODOT, var_, r.Sym()), r.Left()
}
default:
base.Fatalf("fixedlit bad op: %v", n.Op())
}
if vstat == nil {
- a = ir.Nod(ir.OAS, x, nil)
+ a = ir.NewAssignStmt(base.Pos, x, nil)
a = typecheck(a, ctxStmt)
init.Append(a) // zero new temp
} else {
// Declare that we're about to initialize all of x.
// (Which happens at the *vauto = vstat below.)
- init.Append(ir.Nod(ir.OVARDEF, x, nil))
+ init.Append(ir.NewUnaryExpr(base.Pos, ir.OVARDEF, x))
}
a = nodAddr(x)
} else if n.Esc() == EscNone {
a = temp(t)
if vstat == nil {
- a = ir.Nod(ir.OAS, temp(t), nil)
+ a = ir.NewAssignStmt(base.Pos, temp(t), nil)
a = typecheck(a, ctxStmt)
init.Append(a) // zero new temp
a = a.(*ir.AssignStmt).Left()
} else {
- init.Append(ir.Nod(ir.OVARDEF, a, nil))
+ init.Append(ir.NewUnaryExpr(base.Pos, ir.OVARDEF, a))
}
a = nodAddr(a)
} else {
- a = ir.Nod(ir.ONEW, ir.TypeNode(t), nil)
+ a = ir.NewUnaryExpr(base.Pos, ir.ONEW, ir.TypeNode(t))
}
- appendWalkStmt(init, ir.Nod(ir.OAS, vauto, a))
+ appendWalkStmt(init, ir.NewAssignStmt(base.Pos, vauto, a))
if vstat != nil {
// copy static to heap (4)
- a = ir.Nod(ir.ODEREF, vauto, nil)
- appendWalkStmt(init, ir.Nod(ir.OAS, a, vstat))
+ a = ir.NewStarExpr(base.Pos, vauto)
+ appendWalkStmt(init, ir.NewAssignStmt(base.Pos, a, vstat))
}
// put dynamics into array (5)
}
value = kv.Right()
}
- a := ir.Nod(ir.OINDEX, vauto, nodintconst(index))
+ a := ir.NewIndexExpr(base.Pos, vauto, nodintconst(index))
a.SetBounded(true)
index++
// build list of vauto[c] = expr
setlineno(value)
- as := typecheck(ir.Nod(ir.OAS, a, value), ctxStmt)
+ as := typecheck(ir.NewAssignStmt(base.Pos, a, value), ctxStmt)
as = orderStmtInPlace(as, map[string][]*ir.Name{})
as = walkstmt(as)
init.Append(as)
}
// make slice out of heap (6)
- a = ir.Nod(ir.OAS, var_, ir.Nod(ir.OSLICE, vauto, nil))
+ a = ir.NewAssignStmt(base.Pos, var_, ir.NewSliceExpr(base.Pos, ir.OSLICE, vauto))
a = typecheck(a, ctxStmt)
a = orderStmtInPlace(a, map[string][]*ir.Name{})
func maplit(n *ir.CompLitExpr, m ir.Node, init *ir.Nodes) {
// make the map var
- a := ir.Nod(ir.OMAKE, nil, nil)
+ a := ir.NewCallExpr(base.Pos, ir.OMAKE, nil, nil)
a.SetEsc(n.Esc())
a.PtrList().Set2(ir.TypeNode(n.Type()), nodintconst(int64(n.List().Len())))
litas(m, a, init)
// map[vstatk[i]] = vstate[i]
// }
i := temp(types.Types[types.TINT])
- rhs := ir.Nod(ir.OINDEX, vstate, i)
+ rhs := ir.NewIndexExpr(base.Pos, vstate, i)
rhs.SetBounded(true)
- kidx := ir.Nod(ir.OINDEX, vstatk, i)
+ kidx := ir.NewIndexExpr(base.Pos, vstatk, i)
kidx.SetBounded(true)
- lhs := ir.Nod(ir.OINDEX, m, kidx)
+ lhs := ir.NewIndexExpr(base.Pos, m, kidx)
- zero := ir.Nod(ir.OAS, i, nodintconst(0))
- cond := ir.Nod(ir.OLT, i, nodintconst(tk.NumElem()))
- incr := ir.Nod(ir.OAS, i, ir.Nod(ir.OADD, i, nodintconst(1)))
- body := ir.Nod(ir.OAS, lhs, rhs)
+ zero := ir.NewAssignStmt(base.Pos, i, nodintconst(0))
+ cond := ir.NewBinaryExpr(base.Pos, ir.OLT, i, nodintconst(tk.NumElem()))
+ incr := ir.NewAssignStmt(base.Pos, i, ir.NewBinaryExpr(base.Pos, ir.OADD, i, nodintconst(1)))
+ body := ir.NewAssignStmt(base.Pos, lhs, rhs)
- loop := ir.Nod(ir.OFOR, cond, incr)
+ loop := ir.NewForStmt(base.Pos, nil, cond, incr, nil)
loop.PtrBody().Set1(body)
loop.PtrInit().Set1(zero)
index, elem := r.Left(), r.Right()
setlineno(index)
- appendWalkStmt(init, ir.Nod(ir.OAS, tmpkey, index))
+ appendWalkStmt(init, ir.NewAssignStmt(base.Pos, tmpkey, index))
setlineno(elem)
- appendWalkStmt(init, ir.Nod(ir.OAS, tmpelem, elem))
+ appendWalkStmt(init, ir.NewAssignStmt(base.Pos, tmpelem, elem))
setlineno(tmpelem)
- appendWalkStmt(init, ir.Nod(ir.OAS, ir.Nod(ir.OINDEX, m, tmpkey), tmpelem))
+ appendWalkStmt(init, ir.NewAssignStmt(base.Pos, ir.NewIndexExpr(base.Pos, m, tmpkey), tmpelem))
}
- appendWalkStmt(init, ir.Nod(ir.OVARKILL, tmpkey, nil))
- appendWalkStmt(init, ir.Nod(ir.OVARKILL, tmpelem, nil))
+ appendWalkStmt(init, ir.NewUnaryExpr(base.Pos, ir.OVARKILL, tmpkey))
+ appendWalkStmt(init, ir.NewUnaryExpr(base.Pos, ir.OVARKILL, tmpelem))
}
func anylit(n ir.Node, var_ ir.Node, init *ir.Nodes) {
var r ir.Node
if n.Right() != nil {
// n.Right is stack temporary used as backing store.
- appendWalkStmt(init, ir.Nod(ir.OAS, n.Right(), nil)) // zero backing store, just in case (#18410)
+ appendWalkStmt(init, ir.NewAssignStmt(base.Pos, n.Right(), nil)) // zero backing store, just in case (#18410)
r = nodAddr(n.Right())
} else {
- r = ir.Nod(ir.ONEW, ir.TypeNode(n.Left().Type()), nil)
+ r = ir.NewUnaryExpr(base.Pos, ir.ONEW, ir.TypeNode(n.Left().Type()))
r.SetEsc(n.Esc())
}
- appendWalkStmt(init, ir.Nod(ir.OAS, var_, r))
+ appendWalkStmt(init, ir.NewAssignStmt(base.Pos, var_, r))
- var_ = ir.Nod(ir.ODEREF, var_, nil)
+ var_ = ir.NewStarExpr(base.Pos, var_)
var_ = typecheck(var_, ctxExpr|ctxAssign)
anylit(n.Left(), var_, init)
fixedlit(ctxt, initKindStatic, n, vstat, init)
// copy static to var
- appendWalkStmt(init, ir.Nod(ir.OAS, var_, vstat))
+ appendWalkStmt(init, ir.NewAssignStmt(base.Pos, var_, vstat))
// add expressions to automatic
fixedlit(inInitFunction, initKindDynamic, n, var_, init)
}
// initialization of an array or struct with unspecified components (missing fields or arrays)
if isSimpleName(var_) || int64(n.List().Len()) < components {
- appendWalkStmt(init, ir.Nod(ir.OAS, var_, nil))
+ appendWalkStmt(init, ir.NewAssignStmt(base.Pos, var_, nil))
}
fixedlit(inInitFunction, initKindLocalCode, n, var_, init)
return n
}
-// nodSym makes a Node with Op op and with the Left field set to left
-// and the Sym field set to sym. This is for ODOT and friends.
-func nodSym(op ir.Op, left ir.Node, sym *types.Sym) ir.Node {
- return nodlSym(base.Pos, op, left, sym)
-}
-
-// nodlSym makes a Node with position Pos, with Op op, and with the Left field set to left
-// and the Sym field set to sym. This is for ODOT and friends.
-func nodlSym(pos src.XPos, op ir.Op, left ir.Node, sym *types.Sym) ir.Node {
- n := ir.NodAt(pos, op, left, nil)
- n.SetSym(sym)
- return n
-}
-
// methcmp sorts methods by symbol.
type methcmp []*types.Field
}
func nodnil() ir.Node {
- n := ir.Nod(ir.ONIL, nil, nil)
+ n := ir.NewNilExpr(base.Pos)
n.SetType(types.Types[types.TNIL])
return n
}
// if the next step is non-bool (like interface{}).
if n.Type() == types.UntypedBool && !t.IsBoolean() {
if n.Op() == ir.ONAME || n.Op() == ir.OLITERAL {
- r := ir.Nod(ir.OCONVNOP, n, nil)
+ r := ir.NewConvExpr(base.Pos, ir.OCONVNOP, nil, n)
r.SetType(types.Types[types.TBOOL])
r.SetTypecheck(1)
r.SetImplicit(true)
if c != n || init.Len() != 0 {
base.Fatalf("backingArrayPtrLen not cheap: %v", n)
}
- ptr = ir.Nod(ir.OSPTR, n, nil)
+ ptr = ir.NewUnaryExpr(base.Pos, ir.OSPTR, n)
if n.Type().IsString() {
ptr.SetType(types.Types[types.TUINT8].PtrTo())
} else {
ptr.SetType(n.Type().Elem().PtrTo())
}
- length = ir.Nod(ir.OLEN, n, nil)
+ length = ir.NewUnaryExpr(base.Pos, ir.OLEN, n)
length.SetType(types.Types[types.TINT])
return ptr, length
}
func copyexpr(n ir.Node, t *types.Type, init *ir.Nodes) ir.Node {
l := temp(t)
- appendWalkStmt(init, ir.Nod(ir.OAS, l, n))
+ appendWalkStmt(init, ir.NewAssignStmt(base.Pos, l, n))
return l
}
case path != nil:
// rebuild elided dots
for c := len(path) - 1; c >= 0; c-- {
- dot := nodSym(ir.ODOT, n.Left(), path[c].field.Sym)
+ dot := ir.NewSelectorExpr(base.Pos, ir.ODOT, n.Left(), path[c].field.Sym)
dot.SetImplicit(true)
dot.SetType(path[c].field.Type)
n.SetLeft(dot)
// generate nil pointer check for better error
if rcvr.IsPtr() && rcvr.Elem() == methodrcvr {
// generating wrapper from *T to T.
- n := ir.Nod(ir.OIF, nil, nil)
- n.SetLeft(ir.Nod(ir.OEQ, nthis, nodnil()))
- call := ir.Nod(ir.OCALL, syslook("panicwrap"), nil)
+ n := ir.NewIfStmt(base.Pos, nil, nil, nil)
+ n.SetLeft(ir.NewBinaryExpr(base.Pos, ir.OEQ, nthis, nodnil()))
+ call := ir.NewCallExpr(base.Pos, ir.OCALL, syslook("panicwrap"), nil)
n.PtrBody().Set1(call)
fn.PtrBody().Append(n)
}
if !left.Type().IsPtr() {
left = nodAddr(left)
}
- as := ir.Nod(ir.OAS, nthis, convnop(left, rcvr))
+ as := ir.NewAssignStmt(base.Pos, nthis, convnop(left, rcvr))
fn.PtrBody().Append(as)
- fn.PtrBody().Append(nodSym(ir.ORETJMP, nil, methodSym(methodrcvr, method.Sym)))
+ fn.PtrBody().Append(ir.NewBranchStmt(base.Pos, ir.ORETJMP, methodSym(methodrcvr, method.Sym)))
} else {
fn.SetWrapper(true) // ignore frame for panic+recover matching
- call := ir.Nod(ir.OCALL, dot, nil)
+ call := ir.NewCallExpr(base.Pos, ir.OCALL, dot, nil)
call.PtrList().Set(paramNnames(tfn.Type()))
call.SetIsDDD(tfn.Type().IsVariadic())
if method.Type.NumResults() > 0 {
- ret := ir.Nod(ir.ORETURN, nil, nil)
+ ret := ir.NewReturnStmt(base.Pos, nil)
ret.PtrList().Set1(call)
fn.PtrBody().Append(ret)
} else {
}
func liststmt(l []ir.Node) ir.Node {
- n := ir.Nod(ir.OBLOCK, nil, nil)
+ n := ir.NewBlockStmt(base.Pos, nil)
n.PtrList().Set(l)
if len(l) != 0 {
n.SetPos(l[0].Pos())
if ir.MayBeShared(n) {
// Introduce OCONVNOP to hold init list.
old := n
- n = ir.Nod(ir.OCONVNOP, old, nil)
+ n = ir.NewConvExpr(base.Pos, ir.OCONVNOP, nil, old)
n.SetType(old.Type())
n.SetTypecheck(1)
}
// itabType loads the _type field from a runtime.itab struct.
func itabType(itab ir.Node) ir.Node {
- typ := nodSym(ir.ODOTPTR, itab, nil)
+ typ := ir.NewSelectorExpr(base.Pos, ir.ODOTPTR, itab, nil)
typ.SetType(types.NewPtr(types.Types[types.TUINT8]))
typ.SetTypecheck(1)
typ.SetOffset(int64(Widthptr)) // offset of _type in runtime.itab
if t.IsInterface() {
base.Fatalf("ifaceData interface: %v", t)
}
- ptr := ir.NodAt(pos, ir.OIDATA, n, nil)
+ ptr := ir.NewUnaryExpr(pos, ir.OIDATA, n)
if isdirectiface(t) {
ptr.SetType(t)
ptr.SetTypecheck(1)
}
ptr.SetType(types.NewPtr(t))
ptr.SetTypecheck(1)
- ind := ir.NodAt(pos, ir.ODEREF, ptr, nil)
+ ind := ir.NewStarExpr(pos, ptr)
ind.SetType(t)
ind.SetTypecheck(1)
ind.SetBounded(true)
for _, ncase := range sw.List().Slice() {
ncase := ncase.(*ir.CaseStmt)
label := autolabel(".s")
- jmp := npos(ncase.Pos(), nodSym(ir.OGOTO, nil, label))
+ jmp := ir.NewBranchStmt(ncase.Pos(), ir.OGOTO, label)
// Process case dispatch.
if ncase.List().Len() == 0 {
}
// Process body.
- body.Append(npos(ncase.Pos(), nodSym(ir.OLABEL, nil, label)))
+ body.Append(ir.NewLabelStmt(ncase.Pos(), label))
body.Append(ncase.Body().Slice()...)
if fall, pos := endsInFallthrough(ncase.Body().Slice()); !fall {
- br := ir.Nod(ir.OBREAK, nil, nil)
+ br := ir.NewBranchStmt(base.Pos, ir.OBREAK, nil)
br.SetPos(pos)
body.Append(br)
}
sw.PtrList().Set(nil)
if defaultGoto == nil {
- br := ir.Nod(ir.OBREAK, nil, nil)
+ br := ir.NewBranchStmt(base.Pos, ir.OBREAK, nil)
br.SetPos(br.Pos().WithNotStmt())
defaultGoto = br
}
// Perform two-level binary search.
binarySearch(len(runs), &s.done,
func(i int) ir.Node {
- return ir.Nod(ir.OLE, ir.Nod(ir.OLEN, s.exprname, nil), nodintconst(runLen(runs[i-1])))
+ return ir.NewBinaryExpr(base.Pos, ir.OLE, ir.NewUnaryExpr(base.Pos, ir.OLEN, s.exprname), nodintconst(runLen(runs[i-1])))
},
func(i int, nif *ir.IfStmt) {
run := runs[i]
- nif.SetLeft(ir.Nod(ir.OEQ, ir.Nod(ir.OLEN, s.exprname, nil), nodintconst(runLen(run))))
+ nif.SetLeft(ir.NewBinaryExpr(base.Pos, ir.OEQ, ir.NewUnaryExpr(base.Pos, ir.OLEN, s.exprname), nodintconst(runLen(run))))
s.search(run, nif.PtrBody())
},
)
func (s *exprSwitch) search(cc []exprClause, out *ir.Nodes) {
binarySearch(len(cc), out,
func(i int) ir.Node {
- return ir.Nod(ir.OLE, s.exprname, cc[i-1].hi)
+ return ir.NewBinaryExpr(base.Pos, ir.OLE, s.exprname, cc[i-1].hi)
},
func(i int, nif *ir.IfStmt) {
c := &cc[i]
func (c *exprClause) test(exprname ir.Node) ir.Node {
// Integer range.
if c.hi != c.lo {
- low := ir.NodAt(c.pos, ir.OGE, exprname, c.lo)
- high := ir.NodAt(c.pos, ir.OLE, exprname, c.hi)
- return ir.NodAt(c.pos, ir.OANDAND, low, high)
+ low := ir.NewBinaryExpr(c.pos, ir.OGE, exprname, c.lo)
+ high := ir.NewBinaryExpr(c.pos, ir.OLE, exprname, c.hi)
+ return ir.NewLogicalExpr(c.pos, ir.OANDAND, low, high)
}
// Optimize "switch true { ...}" and "switch false { ... }".
if ir.BoolVal(exprname) {
return c.lo
} else {
- return ir.NodAt(c.pos, ir.ONOT, c.lo, nil)
+ return ir.NewUnaryExpr(c.pos, ir.ONOT, c.lo)
}
}
- return ir.NodAt(c.pos, ir.OEQ, exprname, c.lo)
+ return ir.NewBinaryExpr(c.pos, ir.OEQ, exprname, c.lo)
}
func allCaseExprsAreSideEffectFree(sw *ir.SwitchStmt) bool {
// Get interface descriptor word.
// For empty interfaces this will be the type.
// For non-empty interfaces this will be the itab.
- itab := ir.Nod(ir.OITAB, s.facename, nil)
+ itab := ir.NewUnaryExpr(base.Pos, ir.OITAB, s.facename)
// For empty interfaces, do:
// if e._type == nil {
// }
// h := e._type.hash
// Use a similar strategy for non-empty interfaces.
- ifNil := ir.Nod(ir.OIF, nil, nil)
- ifNil.SetLeft(ir.Nod(ir.OEQ, itab, nodnil()))
+ ifNil := ir.NewIfStmt(base.Pos, nil, nil, nil)
+ ifNil.SetLeft(ir.NewBinaryExpr(base.Pos, ir.OEQ, itab, nodnil()))
base.Pos = base.Pos.WithNotStmt() // disable statement marks after the first check.
ifNil.SetLeft(typecheck(ifNil.Left(), ctxExpr))
ifNil.SetLeft(defaultlit(ifNil.Left(), nil))
sw.PtrBody().Append(ifNil)
// Load hash from type or itab.
- dotHash := nodSym(ir.ODOTPTR, itab, nil)
+ dotHash := ir.NewSelectorExpr(base.Pos, ir.ODOTPTR, itab, nil)
dotHash.SetType(types.Types[types.TUINT32])
dotHash.SetTypecheck(1)
if s.facename.Type().IsEmptyInterface() {
dotHash.SetBounded(true) // guaranteed not to fault
s.hashname = copyexpr(dotHash, dotHash.Type(), sw.PtrBody())
- br := ir.Nod(ir.OBREAK, nil, nil)
+ br := ir.NewBranchStmt(base.Pos, ir.OBREAK, nil)
var defaultGoto, nilGoto ir.Node
var body ir.Nodes
for _, ncase := range sw.List().Slice() {
caseVarInitialized := false
label := autolabel(".s")
- jmp := npos(ncase.Pos(), nodSym(ir.OGOTO, nil, label))
+ jmp := ir.NewBranchStmt(ncase.Pos(), ir.OGOTO, label)
if ncase.List().Len() == 0 { // default:
if defaultGoto != nil {
}
}
- body.Append(npos(ncase.Pos(), nodSym(ir.OLABEL, nil, label)))
+ body.Append(ir.NewLabelStmt(ncase.Pos(), label))
if caseVar != nil && !caseVarInitialized {
val := s.facename
if singleType != nil {
val = ifaceData(ncase.Pos(), s.facename, singleType)
}
l := []ir.Node{
- ir.NodAt(ncase.Pos(), ir.ODCL, caseVar, nil),
- ir.NodAt(ncase.Pos(), ir.OAS, caseVar, val),
+ ir.NewDecl(ncase.Pos(), ir.ODCL, caseVar),
+ ir.NewAssignStmt(ncase.Pos(), caseVar, val),
}
typecheckslice(l, ctxStmt)
body.Append(l...)
var body ir.Nodes
if caseVar != nil {
l := []ir.Node{
- ir.NodAt(pos, ir.ODCL, caseVar, nil),
- ir.NodAt(pos, ir.OAS, caseVar, nil),
+ ir.NewDecl(pos, ir.ODCL, caseVar),
+ ir.NewAssignStmt(pos, caseVar, nil),
}
typecheckslice(l, ctxStmt)
body.Append(l...)
}
// cv, ok = iface.(type)
- as := ir.NodAt(pos, ir.OAS2, nil, nil)
+ as := ir.NewAssignListStmt(pos, ir.OAS2, nil, nil)
as.PtrList().Set2(caseVar, s.okname) // cv, ok =
- dot := ir.NodAt(pos, ir.ODOTTYPE, s.facename, nil)
+ dot := ir.NewTypeAssertExpr(pos, s.facename, nil)
dot.SetType(typ) // iface.(type)
as.PtrRlist().Set1(dot)
appendWalkStmt(&body, as)
// if ok { goto label }
- nif := ir.NodAt(pos, ir.OIF, nil, nil)
+ nif := ir.NewIfStmt(pos, nil, nil, nil)
nif.SetLeft(s.okname)
nif.PtrBody().Set1(jmp)
body.Append(nif)
binarySearch(len(cc), &s.done,
func(i int) ir.Node {
- return ir.Nod(ir.OLE, s.hashname, nodintconst(int64(cc[i-1].hash)))
+ return ir.NewBinaryExpr(base.Pos, ir.OLE, s.hashname, nodintconst(int64(cc[i-1].hash)))
},
func(i int, nif *ir.IfStmt) {
// TODO(mdempsky): Omit hash equality check if
// there's only one type.
c := cc[i]
- nif.SetLeft(ir.Nod(ir.OEQ, s.hashname, nodintconst(int64(c.hash))))
+ nif.SetLeft(ir.NewBinaryExpr(base.Pos, ir.OEQ, s.hashname, nodintconst(int64(c.hash))))
nif.PtrBody().AppendNodes(&c.body)
},
)
}
half := lo + n/2
- nif := ir.Nod(ir.OIF, nil, nil)
+ nif := ir.NewIfStmt(base.Pos, nil, nil, nil)
nif.SetLeft(less(half))
base.Pos = base.Pos.WithNotStmt()
nif.SetLeft(typecheck(nif.Left(), ctxExpr))
return n
}
- n := ir.NodAt(n.Pos(), ir.OCONV, arg, nil)
+ n := ir.NewConvExpr(n.Pos(), ir.OCONV, nil, arg)
n.SetType(l.Type())
return typecheck1(n, top)
}
n.SetType(nil)
return n
}
- nn = ir.NodAt(n.Pos(), ir.OMAKESLICE, l, r)
+ nn = ir.NewMakeExpr(n.Pos(), ir.OMAKESLICE, l, r)
case types.TMAP:
if i < len(args) {
} else {
l = nodintconst(0)
}
- nn = ir.NodAt(n.Pos(), ir.OMAKEMAP, l, nil)
+ nn = ir.NewMakeExpr(n.Pos(), ir.OMAKEMAP, l, nil)
nn.SetEsc(n.Esc())
case types.TCHAN:
} else {
l = nodintconst(0)
}
- nn = ir.NodAt(n.Pos(), ir.OMAKECHAN, l, nil)
+ nn = ir.NewMakeExpr(n.Pos(), ir.OMAKECHAN, l, nil)
}
if i < len(args) {
// Empty identifier is valid but useless.
// Eliminate now to simplify life later.
// See issues 7538, 11589, 11593.
- n = ir.NodAt(n.Pos(), ir.OBLOCK, nil, nil)
+ n = ir.NewBlockStmt(n.Pos(), nil)
}
return n
n.(ir.OrigNode).SetOrig(ir.SepCopy(n))
}
- as := ir.Nod(ir.OAS2, nil, nil)
+ as := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
as.PtrRlist().Append(list...)
// If we're outside of function context, then this call will
list = nil
for _, f := range t.FieldSlice() {
t := temp(f.Type)
- as.PtrInit().Append(ir.Nod(ir.ODCL, t, nil))
+ as.PtrInit().Append(ir.NewDecl(base.Pos, ir.ODCL, t))
as.PtrList().Append(t)
list = append(list, t)
}
if !t.IsArray() {
return n
}
- star := ir.Nod(ir.ODEREF, n, nil)
+ star := ir.NewStarExpr(base.Pos, n)
star.SetImplicit(true)
return typecheck(star, ctxExpr)
}
n.SetType(f1.Type)
if t.IsInterface() {
if n.Left().Type().IsPtr() {
- star := ir.Nod(ir.ODEREF, n.Left(), nil)
+ star := ir.NewStarExpr(base.Pos, n.Left())
star.SetImplicit(true)
n.SetLeft(typecheck(star, ctxExpr))
}
addr.SetImplicit(true)
n.SetLeft(typecheck(addr, ctxType|ctxExpr))
} else if tt.IsPtr() && (!rcvr.IsPtr() || rcvr.IsPtr() && rcvr.Elem().NotInHeap()) && types.Identical(tt.Elem(), rcvr) {
- star := ir.Nod(ir.ODEREF, n.Left(), nil)
+ star := ir.NewStarExpr(base.Pos, n.Left())
star.SetImplicit(true)
n.SetLeft(typecheck(star, ctxType|ctxExpr))
} else if tt.IsPtr() && tt.Elem().IsPtr() && types.Identical(derefall(tt), derefall(rcvr)) {
if rcvr.IsPtr() && !tt.Elem().IsPtr() {
break
}
- star := ir.Nod(ir.ODEREF, n.Left(), nil)
+ star := ir.NewStarExpr(base.Pos, n.Left())
star.SetImplicit(true)
n.SetLeft(typecheck(star, ctxType|ctxExpr))
tt = tt.Elem()
}
// No pushtype allowed here. Must name fields for that.
n1 = assignconv(n1, f.Type, "field value")
- sk := nodSym(ir.OSTRUCTKEY, n1, f.Sym)
+ sk := ir.NewStructKeyExpr(base.Pos, f.Sym, n1)
sk.SetOffset(f.Offset)
ls[i] = sk
}
var l []ir.Node
i := 0
for _, r := range ir.StringVal(n.Left()) {
- l = append(l, ir.Nod(ir.OKEY, nodintconst(int64(i)), nodintconst(int64(r))))
+ l = append(l, ir.NewKeyExpr(base.Pos, nodintconst(int64(i)), nodintconst(int64(r))))
i++
}
- nn := ir.Nod(ir.OCOMPLIT, nil, ir.TypeNode(n.Type()))
+ nn := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(n.Type()).(ir.Ntype), nil)
nn.PtrList().Set(l)
return typecheck(nn, ctxExpr)
}
}
}
- fn.PtrBody().Set([]ir.Node{ir.Nod(ir.OBLOCK, nil, nil)})
+ fn.PtrBody().Set([]ir.Node{ir.NewBlockStmt(base.Pos, nil)})
}
func deadcodeslice(nn *ir.Nodes) {
if base.Flag.CompilingRuntime {
base.Errorf("%v escapes to heap, not allowed in runtime", v)
}
- nn := ir.Nod(ir.OAS, v.Name().Heapaddr, callnew(v.Type()))
+ nn := ir.NewAssignStmt(base.Pos, v.Name().Heapaddr, callnew(v.Type()))
nn.SetColas(true)
return walkstmt(typecheck(nn, ctxStmt))
}
if cl == ir.PPARAMOUT {
var ln ir.Node = ln
if isParamStackCopy(ln) {
- ln = walkexpr(typecheck(ir.Nod(ir.ODEREF, ln.Name().Heapaddr, nil), ctxExpr), nil)
+ ln = walkexpr(typecheck(ir.NewStarExpr(base.Pos, ln.Name().Heapaddr), ctxExpr), nil)
}
rl = append(rl, ln)
}
}
if n.Op() == ir.ONAME && n.(*ir.Name).Class() == ir.PAUTOHEAP {
- nn := ir.Nod(ir.ODEREF, n.Name().Heapaddr, nil)
+ nn := ir.NewStarExpr(base.Pos, n.Name().Heapaddr)
nn.Left().MarkNonNil()
return walkexpr(typecheck(nn, ctxExpr), init)
}
if n.Op() == ir.OASOP {
// Rewrite x op= y into x = x op y.
- n = ir.Nod(ir.OAS, left,
- typecheck(ir.NewBinaryExpr(base.Pos, n.(*ir.AssignOpStmt).SubOp(), left, right), ctxExpr))
+ n = ir.NewAssignStmt(base.Pos, left, typecheck(ir.NewBinaryExpr(base.Pos, n.(*ir.AssignOpStmt).SubOp(), left, right), ctxExpr))
} else {
n.(*ir.AssignStmt).SetLeft(left)
}
as := n.(*ir.AssignStmt)
if oaslit(as, init) {
- return ir.NodAt(as.Pos(), ir.OBLOCK, nil, nil)
+ return ir.NewBlockStmt(as.Pos(), nil)
}
if as.Right() == nil {
fn := chanfn("chanrecv2", 2, r.Left().Type())
ok := n.List().Second()
call := mkcall1(fn, types.Types[types.TBOOL], init, r.Left(), n1)
- return typecheck(ir.Nod(ir.OAS, ok, call), ctxStmt)
+ return typecheck(ir.NewAssignStmt(base.Pos, ok, call), ctxStmt)
// a,b = m[i]
case ir.OAS2MAPR:
n.List().SetFirst(var_)
init.Append(walkexpr(n, init))
- as := ir.Nod(ir.OAS, a, ir.Nod(ir.ODEREF, var_, nil))
+ as := ir.NewAssignStmt(base.Pos, a, ir.NewStarExpr(base.Pos, var_))
return walkexpr(typecheck(as, ctxStmt), init)
case ir.ODELETE:
// Optimize convT2E or convT2I as a two-word copy when T is pointer-shaped.
if isdirectiface(fromType) {
- l := ir.Nod(ir.OEFACE, typeword(), n.Left())
+ l := ir.NewBinaryExpr(base.Pos, ir.OEFACE, typeword(), n.Left())
l.SetType(toType)
l.SetTypecheck(n.Typecheck())
return l
// and staticuint64s[n.Left * 8 + 7] on big-endian.
n.SetLeft(cheapexpr(n.Left(), init))
// byteindex widens n.Left so that the multiplication doesn't overflow.
- index := ir.Nod(ir.OLSH, byteindex(n.Left()), nodintconst(3))
+ index := ir.NewBinaryExpr(base.Pos, ir.OLSH, byteindex(n.Left()), nodintconst(3))
if thearch.LinkArch.ByteOrder == binary.BigEndian {
- index = ir.Nod(ir.OADD, index, nodintconst(7))
+ index = ir.NewBinaryExpr(base.Pos, ir.OADD, index, nodintconst(7))
}
- xe := ir.Nod(ir.OINDEX, staticuint64s, index)
+ xe := ir.NewIndexExpr(base.Pos, staticuint64s, index)
xe.SetBounded(true)
value = xe
case n.Left().Op() == ir.ONAME && n.Left().(*ir.Name).Class() == ir.PEXTERN && n.Left().(*ir.Name).Readonly():
case !fromType.IsInterface() && n.Esc() == EscNone && fromType.Width <= 1024:
// n.Left does not escape. Use a stack temporary initialized to n.Left.
value = temp(fromType)
- init.Append(typecheck(ir.Nod(ir.OAS, value, n.Left()), ctxStmt))
+ init.Append(typecheck(ir.NewAssignStmt(base.Pos, value, n.Left()), ctxStmt))
}
if value != nil {
// Value is identical to n.Left.
// Construct the interface directly: {type/itab, &value}.
- l := ir.Nod(ir.OEFACE, typeword(), typecheck(nodAddr(value), ctxExpr))
+ l := ir.NewBinaryExpr(base.Pos, ir.OEFACE, typeword(), typecheck(nodAddr(value), ctxExpr))
l.SetType(toType)
l.SetTypecheck(n.Typecheck())
return l
if toType.IsEmptyInterface() && fromType.IsInterface() && !fromType.IsEmptyInterface() {
// Evaluate the input interface.
c := temp(fromType)
- init.Append(ir.Nod(ir.OAS, c, n.Left()))
+ init.Append(ir.NewAssignStmt(base.Pos, c, n.Left()))
// Get the itab out of the interface.
tmp := temp(types.NewPtr(types.Types[types.TUINT8]))
- init.Append(ir.Nod(ir.OAS, tmp, typecheck(ir.Nod(ir.OITAB, c, nil), ctxExpr)))
+ init.Append(ir.NewAssignStmt(base.Pos, tmp, typecheck(ir.NewUnaryExpr(base.Pos, ir.OITAB, c), ctxExpr)))
// Get the type out of the itab.
- nif := ir.Nod(ir.OIF, typecheck(ir.Nod(ir.ONE, tmp, nodnil()), ctxExpr), nil)
- nif.PtrBody().Set1(ir.Nod(ir.OAS, tmp, itabType(tmp)))
+ nif := ir.NewIfStmt(base.Pos, typecheck(ir.NewBinaryExpr(base.Pos, ir.ONE, tmp, nodnil()), ctxExpr), nil, nil)
+ nif.PtrBody().Set1(ir.NewAssignStmt(base.Pos, tmp, itabType(tmp)))
init.Append(nif)
// Build the result.
- e := ir.Nod(ir.OEFACE, tmp, ifaceData(n.Pos(), c, types.NewPtr(types.Types[types.TUINT8])))
+ e := ir.NewBinaryExpr(base.Pos, ir.OEFACE, tmp, ifaceData(n.Pos(), c, types.NewPtr(types.Types[types.TUINT8])))
e.SetType(toType) // assign type manually, typecheck doesn't understand OEFACE.
e.SetTypecheck(1)
return e
dowidth(fromType)
fn = substArgTypes(fn, fromType)
dowidth(fn.Type())
- call := ir.Nod(ir.OCALL, fn, nil)
+ call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
call.PtrList().Set1(n.Left())
- e := ir.Nod(ir.OEFACE, typeword(), safeexpr(walkexpr(typecheck(call, ctxExpr), init), init))
+ e := ir.NewBinaryExpr(base.Pos, ir.OEFACE, typeword(), safeexpr(walkexpr(typecheck(call, ctxExpr), init), init))
e.SetType(toType)
e.SetTypecheck(1)
return e
fn := syslook(fnname)
fn = substArgTypes(fn, fromType, toType)
dowidth(fn.Type())
- call := ir.Nod(ir.OCALL, fn, nil)
+ call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
call.PtrList().Set2(tab, v)
return walkexpr(typecheck(call, ctxExpr), init)
}
call.SetType(types.NewPtr(t.Elem()))
call.MarkNonNil() // mapaccess1* and mapassign always return non-nil pointers.
- star := ir.Nod(ir.ODEREF, call, nil)
+ star := ir.NewStarExpr(base.Pos, call)
star.SetType(t.Elem())
star.SetTypecheck(1)
return star
base.Fatalf("large ONEW with EscNone: %v", n)
}
r := temp(n.Type().Elem())
- init.Append(typecheck(ir.Nod(ir.OAS, r, nil), ctxStmt)) // zero temp
+ init.Append(typecheck(ir.NewAssignStmt(base.Pos, r, nil), ctxStmt)) // zero temp
return typecheck(nodAddr(r), ctxExpr)
}
return callnew(n.Type().Elem())
// var hv hmap
hv := temp(hmapType)
- init.Append(typecheck(ir.Nod(ir.OAS, hv, nil), ctxStmt))
+ init.Append(typecheck(ir.NewAssignStmt(base.Pos, hv, nil), ctxStmt))
// h = &hv
h = nodAddr(hv)
// h.buckets = b
// }
- nif := ir.Nod(ir.OIF, ir.Nod(ir.OLE, hint, nodintconst(BUCKETSIZE)), nil)
+ nif := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OLE, hint, nodintconst(BUCKETSIZE)), nil, nil)
nif.SetLikely(true)
// var bv bmap
bv := temp(bmap(t))
- nif.PtrBody().Append(ir.Nod(ir.OAS, bv, nil))
+ nif.PtrBody().Append(ir.NewAssignStmt(base.Pos, bv, nil))
// b = &bv
b := nodAddr(bv)
// h.buckets = b
bsym := hmapType.Field(5).Sym // hmap.buckets see reflect.go:hmap
- na := ir.Nod(ir.OAS, nodSym(ir.ODOT, h, bsym), b)
+ na := ir.NewAssignStmt(base.Pos, ir.NewSelectorExpr(base.Pos, ir.ODOT, h, bsym), b)
nif.PtrBody().Append(na)
appendWalkStmt(init, nif)
}
// h.hash0 = fastrand()
rand := mkcall("fastrand", types.Types[types.TUINT32], init)
hashsym := hmapType.Field(4).Sym // hmap.hash0 see reflect.go:hmap
- appendWalkStmt(init, ir.Nod(ir.OAS, nodSym(ir.ODOT, h, hashsym), rand))
+ appendWalkStmt(init, ir.NewAssignStmt(base.Pos, ir.NewSelectorExpr(base.Pos, ir.ODOT, h, hashsym), rand))
return convnop(h, t)
}
// Call runtime.makehmap to allocate an
// if len < 0 { panicmakeslicelen() }
// panicmakeslicecap()
// }
- nif := ir.Nod(ir.OIF, ir.Nod(ir.OGT, conv(l, types.Types[types.TUINT64]), nodintconst(i)), nil)
- niflen := ir.Nod(ir.OIF, ir.Nod(ir.OLT, l, nodintconst(0)), nil)
+ nif := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OGT, conv(l, types.Types[types.TUINT64]), nodintconst(i)), nil, nil)
+ niflen := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OLT, l, nodintconst(0)), nil, nil)
niflen.PtrBody().Set1(mkcall("panicmakeslicelen", nil, init))
nif.PtrBody().Append(niflen, mkcall("panicmakeslicecap", nil, init))
init.Append(typecheck(nif, ctxStmt))
t = types.NewArray(t.Elem(), i) // [r]T
var_ := temp(t)
- appendWalkStmt(init, ir.Nod(ir.OAS, var_, nil)) // zero temp
- r := ir.Nod(ir.OSLICE, var_, nil) // arr[:l]
+ appendWalkStmt(init, ir.NewAssignStmt(base.Pos, var_, nil)) // zero temp
+ r := ir.NewSliceExpr(base.Pos, ir.OSLICE, var_) // arr[:l]
r.SetSliceBounds(nil, l, nil)
// The conv is necessary in case n.Type is named.
return walkexpr(typecheck(conv(r, n.Type()), ctxExpr), init)
argtype = types.Types[types.TINT]
}
- m := ir.Nod(ir.OSLICEHEADER, nil, nil)
+ m := ir.NewSliceHeaderExpr(base.Pos, nil, nil, nil, nil)
m.SetType(t)
fn := syslook(fnname)
}
length := conv(n.Left(), types.Types[types.TINT])
- copylen := ir.Nod(ir.OLEN, n.Right(), nil)
- copyptr := ir.Nod(ir.OSPTR, n.Right(), nil)
+ copylen := ir.NewUnaryExpr(base.Pos, ir.OLEN, n.Right())
+ copyptr := ir.NewUnaryExpr(base.Pos, ir.OSPTR, n.Right())
if !t.Elem().HasPointers() && n.Bounded() {
// When len(to)==len(from) and elements have no pointers:
// We do not check for overflow of len(to)*elem.Width here
// since len(from) is an existing checked slice capacity
// with same elem.Width for the from slice.
- size := ir.Nod(ir.OMUL, conv(length, types.Types[types.TUINTPTR]), conv(nodintconst(t.Elem().Width), types.Types[types.TUINTPTR]))
+ size := ir.NewBinaryExpr(base.Pos, ir.OMUL, conv(length, types.Types[types.TUINTPTR]), conv(nodintconst(t.Elem().Width), types.Types[types.TUINTPTR]))
// instantiate mallocgc(size uintptr, typ *byte, needszero bool) unsafe.Pointer
fn := syslook("mallocgc")
- sh := ir.Nod(ir.OSLICEHEADER, nil, nil)
+ sh := ir.NewSliceHeaderExpr(base.Pos, nil, nil, nil, nil)
sh.SetLeft(mkcall1(fn, types.Types[types.TUNSAFEPTR], init, size, nodnil(), nodbool(false)))
sh.Left().MarkNonNil()
sh.PtrList().Set2(length, length)
sh.SetType(t)
s := temp(t)
- r := typecheck(ir.Nod(ir.OAS, s, sh), ctxStmt)
+ r := typecheck(ir.NewAssignStmt(base.Pos, s, sh), ctxStmt)
r = walkexpr(r, init)
init.Append(r)
// instantiate memmove(to *any, frm *any, size uintptr)
fn = syslook("memmove")
fn = substArgTypes(fn, t.Elem(), t.Elem())
- ncopy := mkcall1(fn, nil, init, ir.Nod(ir.OSPTR, s, nil), copyptr, size)
+ ncopy := mkcall1(fn, nil, init, ir.NewUnaryExpr(base.Pos, ir.OSPTR, s), copyptr, size)
init.Append(walkexpr(typecheck(ncopy, ctxStmt), init))
return s
// Replace make+copy with runtime.makeslicecopy.
// instantiate makeslicecopy(typ *byte, tolen int, fromlen int, from unsafe.Pointer) unsafe.Pointer
fn := syslook("makeslicecopy")
- s := ir.Nod(ir.OSLICEHEADER, nil, nil)
+ s := ir.NewSliceHeaderExpr(base.Pos, nil, nil, nil, nil)
s.SetLeft(mkcall1(fn, types.Types[types.TUNSAFEPTR], init, typename(t.Elem()), length, copylen, conv(copyptr, types.Types[types.TUNSAFEPTR])))
s.Left().MarkNonNil()
s.PtrList().Set2(length, length)
a = callnew(t)
}
p := temp(t.PtrTo()) // *[n]byte
- init.Append(typecheck(ir.Nod(ir.OAS, p, a), ctxStmt))
+ init.Append(typecheck(ir.NewAssignStmt(base.Pos, p, a), ctxStmt))
// Copy from the static string data to the [n]byte.
if len(sc) > 0 {
- as := ir.Nod(ir.OAS,
- ir.Nod(ir.ODEREF, p, nil),
- ir.Nod(ir.ODEREF, convnop(ir.Nod(ir.OSPTR, s, nil), t.PtrTo()), nil))
+ as := ir.NewAssignStmt(base.Pos, ir.NewStarExpr(base.Pos, p), ir.NewStarExpr(base.Pos, convnop(ir.NewUnaryExpr(base.Pos, ir.OSPTR, s), t.PtrTo())))
appendWalkStmt(init, as)
}
// Slice the [n]byte to a []byte.
- slice := ir.NodAt(n.Pos(), ir.OSLICEARR, p, nil)
+ slice := ir.NewSliceExpr(n.Pos(), ir.OSLICEARR, p)
slice.SetType(n.Type())
slice.SetTypecheck(1)
return walkexpr(slice, init)
l = tmp
}
- res := ir.Nod(ir.ORESULT, nil, nil)
+ res := ir.NewResultExpr(base.Pos, nil, types.BADWIDTH)
res.SetOffset(base.Ctxt.FixedFrameSize() + r.Offset)
res.SetType(r.Type)
res.SetTypecheck(1)
n = nodnil()
n.SetType(typ)
} else {
- lit := ir.Nod(ir.OCOMPLIT, nil, ir.TypeNode(typ))
+ lit := ir.NewCompLitExpr(base.Pos, ir.OCOMPLIT, ir.TypeNode(typ).(ir.Ntype), nil)
lit.PtrList().Append(args...)
lit.SetImplicit(true)
n = lit
case types.TPTR:
if n.Type().Elem().NotInHeap() {
on = syslook("printuintptr")
- n = ir.Nod(ir.OCONV, n, nil)
+ n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
n.SetType(types.Types[types.TUNSAFEPTR])
- n = ir.Nod(ir.OCONV, n, nil)
+ n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
n.SetType(types.Types[types.TUINTPTR])
break
}
continue
}
- r := ir.Nod(ir.OCALL, on, nil)
+ r := ir.NewCallExpr(base.Pos, ir.OCALL, on, nil)
if params := on.Type().Params().FieldSlice(); len(params) > 0 {
t := params[0].Type
if !types.Identical(t, n.Type()) {
- n = ir.Nod(ir.OCONV, n, nil)
+ n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
n.SetType(t)
}
r.PtrList().Append(n)
typecheckslice(calls, ctxStmt)
walkexprlist(calls, init)
- r := ir.Nod(ir.OBLOCK, nil, nil)
+ r := ir.NewBlockStmt(base.Pos, nil)
r.PtrList().Set(calls)
return walkstmt(typecheck(r, ctxStmt))
}
func callnew(t *types.Type) ir.Node {
dowidth(t)
- n := ir.Nod(ir.ONEWOBJ, typename(t), nil)
+ n := ir.NewUnaryExpr(base.Pos, ir.ONEWOBJ, typename(t))
n.SetType(types.NewPtr(t))
n.SetTypecheck(1)
n.MarkNonNil()
}
q := ir.Node(temp(n.Type()))
- as := typecheck(ir.Nod(ir.OAS, q, n), ctxStmt)
+ as := typecheck(ir.NewAssignStmt(base.Pos, q, n), ctxStmt)
*early = append(*early, as)
return q
}
}
if stackcopy := v.Name().Stackcopy; stackcopy != nil {
- nn = append(nn, walkstmt(ir.Nod(ir.ODCL, v, nil)))
+ nn = append(nn, walkstmt(ir.NewDecl(base.Pos, ir.ODCL, v)))
if stackcopy.Class() == ir.PPARAM {
- nn = append(nn, walkstmt(typecheck(ir.Nod(ir.OAS, v, stackcopy), ctxStmt)))
+ nn = append(nn, walkstmt(typecheck(ir.NewAssignStmt(base.Pos, v, stackcopy), ctxStmt)))
}
}
}
v = v.Name().Stackcopy
}
// Zero the stack location containing f.
- Curfn.Enter.Append(ir.NodAt(Curfn.Pos(), ir.OAS, v, nil))
+ Curfn.Enter.Append(ir.NewAssignStmt(Curfn.Pos(), v, nil))
}
}
continue
}
if stackcopy := v.Name().Stackcopy; stackcopy != nil && stackcopy.Class() == ir.PPARAMOUT {
- nn = append(nn, walkstmt(typecheck(ir.Nod(ir.OAS, stackcopy, v), ctxStmt)))
+ nn = append(nn, walkstmt(typecheck(ir.NewAssignStmt(base.Pos, stackcopy, v), ctxStmt)))
}
}
if types.Identical(n.Type(), t) {
return n
}
- n = ir.Nod(ir.OCONV, n, nil)
+ n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
n.SetType(t)
n = typecheck(n, ctxExpr)
return n
if types.Identical(n.Type(), t) {
return n
}
- n = ir.Nod(ir.OCONVNOP, n, nil)
+ n = ir.NewConvExpr(base.Pos, ir.OCONVNOP, nil, n)
n.SetType(t)
n = typecheck(n, ctxExpr)
return n
// the wrong result for negative values.
// Reinterpreting the value as an unsigned byte solves both cases.
if !types.Identical(n.Type(), types.Types[types.TUINT8]) {
- n = ir.Nod(ir.OCONV, n, nil)
+ n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
n.SetType(types.Types[types.TUINT8])
n.SetTypecheck(1)
}
- n = ir.Nod(ir.OCONV, n, nil)
+ n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
n.SetType(types.Types[types.TINT])
n.SetTypecheck(1)
return n
}
cat := syslook(fn)
- r := ir.Nod(ir.OCALL, cat, nil)
+ r := ir.NewCallExpr(base.Pos, ir.OCALL, cat, nil)
r.PtrList().Set(args)
r1 := typecheck(r, ctxExpr)
r1 = walkexpr(r1, init)
// var s []T
s := temp(l1.Type())
- nodes.Append(ir.Nod(ir.OAS, s, l1)) // s = l1
+ nodes.Append(ir.NewAssignStmt(base.Pos, s, l1)) // s = l1
elemtype := s.Type().Elem()
// n := len(s) + len(l2)
nn := temp(types.Types[types.TINT])
- nodes.Append(ir.Nod(ir.OAS, nn, ir.Nod(ir.OADD, ir.Nod(ir.OLEN, s, nil), ir.Nod(ir.OLEN, l2, nil))))
+ nodes.Append(ir.NewAssignStmt(base.Pos, nn, ir.NewBinaryExpr(base.Pos, ir.OADD, ir.NewUnaryExpr(base.Pos, ir.OLEN, s), ir.NewUnaryExpr(base.Pos, ir.OLEN, l2))))
// if uint(n) > uint(cap(s))
- nif := ir.Nod(ir.OIF, nil, nil)
+ nif := ir.NewIfStmt(base.Pos, nil, nil, nil)
nuint := conv(nn, types.Types[types.TUINT])
- scapuint := conv(ir.Nod(ir.OCAP, s, nil), types.Types[types.TUINT])
- nif.SetLeft(ir.Nod(ir.OGT, nuint, scapuint))
+ scapuint := conv(ir.NewUnaryExpr(base.Pos, ir.OCAP, s), types.Types[types.TUINT])
+ nif.SetLeft(ir.NewBinaryExpr(base.Pos, ir.OGT, nuint, scapuint))
// instantiate growslice(typ *type, []any, int) []any
fn := syslook("growslice")
fn = substArgTypes(fn, elemtype, elemtype)
// s = growslice(T, s, n)
- nif.PtrBody().Set1(ir.Nod(ir.OAS, s, mkcall1(fn, s.Type(), nif.PtrInit(), typename(elemtype), s, nn)))
+ nif.PtrBody().Set1(ir.NewAssignStmt(base.Pos, s, mkcall1(fn, s.Type(), nif.PtrInit(), typename(elemtype), s, nn)))
nodes.Append(nif)
// s = s[:n]
- nt := ir.Nod(ir.OSLICE, s, nil)
+ nt := ir.NewSliceExpr(base.Pos, ir.OSLICE, s)
nt.SetSliceBounds(nil, nn, nil)
nt.SetBounded(true)
- nodes.Append(ir.Nod(ir.OAS, s, nt))
+ nodes.Append(ir.NewAssignStmt(base.Pos, s, nt))
var ncopy ir.Node
if elemtype.HasPointers() {
// copy(s[len(l1):], l2)
- slice := ir.Nod(ir.OSLICE, s, nil)
+ slice := ir.NewSliceExpr(base.Pos, ir.OSLICE, s)
slice.SetType(s.Type())
- slice.SetSliceBounds(ir.Nod(ir.OLEN, l1, nil), nil, nil)
+ slice.SetSliceBounds(ir.NewUnaryExpr(base.Pos, ir.OLEN, l1), nil, nil)
Curfn.SetWBPos(n.Pos())
// rely on runtime to instrument:
// copy(s[len(l1):], l2)
// l2 can be a slice or string.
- slice := ir.Nod(ir.OSLICE, s, nil)
+ slice := ir.NewSliceExpr(base.Pos, ir.OSLICE, s)
slice.SetType(s.Type())
- slice.SetSliceBounds(ir.Nod(ir.OLEN, l1, nil), nil, nil)
+ slice.SetSliceBounds(ir.NewUnaryExpr(base.Pos, ir.OLEN, l1), nil, nil)
ptr1, len1 := backingArrayPtrLen(cheapexpr(slice, &nodes))
ptr2, len2 := backingArrayPtrLen(l2)
ncopy = mkcall1(fn, types.Types[types.TINT], &nodes, ptr1, len1, ptr2, len2, nodintconst(elemtype.Width))
} else {
// memmove(&s[len(l1)], &l2[0], len(l2)*sizeof(T))
- ix := ir.Nod(ir.OINDEX, s, ir.Nod(ir.OLEN, l1, nil))
+ ix := ir.NewIndexExpr(base.Pos, s, ir.NewUnaryExpr(base.Pos, ir.OLEN, l1))
ix.SetBounded(true)
addr := nodAddr(ix)
- sptr := ir.Nod(ir.OSPTR, l2, nil)
+ sptr := ir.NewUnaryExpr(base.Pos, ir.OSPTR, l2)
- nwid := cheapexpr(conv(ir.Nod(ir.OLEN, l2, nil), types.Types[types.TUINTPTR]), &nodes)
- nwid = ir.Nod(ir.OMUL, nwid, nodintconst(elemtype.Width))
+ nwid := cheapexpr(conv(ir.NewUnaryExpr(base.Pos, ir.OLEN, l2), types.Types[types.TUINTPTR]), &nodes)
+ nwid = ir.NewBinaryExpr(base.Pos, ir.OMUL, nwid, nodintconst(elemtype.Width))
// instantiate func memmove(to *any, frm *any, length uintptr)
fn := syslook("memmove")
var nodes []ir.Node
// if l2 >= 0 (likely happens), do nothing
- nifneg := ir.Nod(ir.OIF, ir.Nod(ir.OGE, l2, nodintconst(0)), nil)
+ nifneg := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OGE, l2, nodintconst(0)), nil, nil)
nifneg.SetLikely(true)
// else panicmakeslicelen()
// s := l1
s := temp(l1.Type())
- nodes = append(nodes, ir.Nod(ir.OAS, s, l1))
+ nodes = append(nodes, ir.NewAssignStmt(base.Pos, s, l1))
elemtype := s.Type().Elem()
// n := len(s) + l2
nn := temp(types.Types[types.TINT])
- nodes = append(nodes, ir.Nod(ir.OAS, nn, ir.Nod(ir.OADD, ir.Nod(ir.OLEN, s, nil), l2)))
+ nodes = append(nodes, ir.NewAssignStmt(base.Pos, nn, ir.NewBinaryExpr(base.Pos, ir.OADD, ir.NewUnaryExpr(base.Pos, ir.OLEN, s), l2)))
// if uint(n) > uint(cap(s))
nuint := conv(nn, types.Types[types.TUINT])
- capuint := conv(ir.Nod(ir.OCAP, s, nil), types.Types[types.TUINT])
- nif := ir.Nod(ir.OIF, ir.Nod(ir.OGT, nuint, capuint), nil)
+ capuint := conv(ir.NewUnaryExpr(base.Pos, ir.OCAP, s), types.Types[types.TUINT])
+ nif := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OGT, nuint, capuint), nil, nil)
// instantiate growslice(typ *type, old []any, newcap int) []any
fn := syslook("growslice")
fn = substArgTypes(fn, elemtype, elemtype)
// s = growslice(T, s, n)
- nif.PtrBody().Set1(ir.Nod(ir.OAS, s, mkcall1(fn, s.Type(), nif.PtrInit(), typename(elemtype), s, nn)))
+ nif.PtrBody().Set1(ir.NewAssignStmt(base.Pos, s, mkcall1(fn, s.Type(), nif.PtrInit(), typename(elemtype), s, nn)))
nodes = append(nodes, nif)
// s = s[:n]
- nt := ir.Nod(ir.OSLICE, s, nil)
+ nt := ir.NewSliceExpr(base.Pos, ir.OSLICE, s)
nt.SetSliceBounds(nil, nn, nil)
nt.SetBounded(true)
- nodes = append(nodes, ir.Nod(ir.OAS, s, nt))
+ nodes = append(nodes, ir.NewAssignStmt(base.Pos, s, nt))
// lptr := &l1[0]
l1ptr := temp(l1.Type().Elem().PtrTo())
- tmp := ir.Nod(ir.OSPTR, l1, nil)
- nodes = append(nodes, ir.Nod(ir.OAS, l1ptr, tmp))
+ tmp := ir.NewUnaryExpr(base.Pos, ir.OSPTR, l1)
+ nodes = append(nodes, ir.NewAssignStmt(base.Pos, l1ptr, tmp))
// sptr := &s[0]
sptr := temp(elemtype.PtrTo())
- tmp = ir.Nod(ir.OSPTR, s, nil)
- nodes = append(nodes, ir.Nod(ir.OAS, sptr, tmp))
+ tmp = ir.NewUnaryExpr(base.Pos, ir.OSPTR, s)
+ nodes = append(nodes, ir.NewAssignStmt(base.Pos, sptr, tmp))
// hp := &s[len(l1)]
- ix := ir.Nod(ir.OINDEX, s, ir.Nod(ir.OLEN, l1, nil))
+ ix := ir.NewIndexExpr(base.Pos, s, ir.NewUnaryExpr(base.Pos, ir.OLEN, l1))
ix.SetBounded(true)
hp := convnop(nodAddr(ix), types.Types[types.TUNSAFEPTR])
// hn := l2 * sizeof(elem(s))
- hn := conv(ir.Nod(ir.OMUL, l2, nodintconst(elemtype.Width)), types.Types[types.TUINTPTR])
+ hn := conv(ir.NewBinaryExpr(base.Pos, ir.OMUL, l2, nodintconst(elemtype.Width)), types.Types[types.TUINTPTR])
clrname := "memclrNoHeapPointers"
hasPointers := elemtype.HasPointers()
if hasPointers {
// if l1ptr == sptr
- nifclr := ir.Nod(ir.OIF, ir.Nod(ir.OEQ, l1ptr, sptr), nil)
+ nifclr := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OEQ, l1ptr, sptr), nil, nil)
nifclr.SetBody(clr)
nodes = append(nodes, nifclr)
} else {
var l []ir.Node
ns := temp(nsrc.Type())
- l = append(l, ir.Nod(ir.OAS, ns, nsrc)) // s = src
+ l = append(l, ir.NewAssignStmt(base.Pos, ns, nsrc)) // s = src
- na := nodintconst(int64(argc)) // const argc
- nif := ir.Nod(ir.OIF, nil, nil) // if cap(s) - len(s) < argc
- nif.SetLeft(ir.Nod(ir.OLT, ir.Nod(ir.OSUB, ir.Nod(ir.OCAP, ns, nil), ir.Nod(ir.OLEN, ns, nil)), na))
+ na := nodintconst(int64(argc)) // const argc
+ nif := ir.NewIfStmt(base.Pos, nil, nil, nil) // if cap(s) - len(s) < argc
+ nif.SetLeft(ir.NewBinaryExpr(base.Pos, ir.OLT, ir.NewBinaryExpr(base.Pos, ir.OSUB, ir.NewUnaryExpr(base.Pos, ir.OCAP, ns), ir.NewUnaryExpr(base.Pos, ir.OLEN, ns)), na))
fn := syslook("growslice") // growslice(<type>, old []T, mincap int) (ret []T)
fn = substArgTypes(fn, ns.Type().Elem(), ns.Type().Elem())
- nif.PtrBody().Set1(ir.Nod(ir.OAS, ns,
- mkcall1(fn, ns.Type(), nif.PtrInit(), typename(ns.Type().Elem()), ns,
- ir.Nod(ir.OADD, ir.Nod(ir.OLEN, ns, nil), na))))
+ nif.PtrBody().Set1(ir.NewAssignStmt(base.Pos, ns, mkcall1(fn, ns.Type(), nif.PtrInit(), typename(ns.Type().Elem()), ns,
+ ir.NewBinaryExpr(base.Pos, ir.OADD, ir.NewUnaryExpr(base.Pos, ir.OLEN, ns), na))))
l = append(l, nif)
nn := temp(types.Types[types.TINT])
- l = append(l, ir.Nod(ir.OAS, nn, ir.Nod(ir.OLEN, ns, nil))) // n = len(s)
+ l = append(l, ir.NewAssignStmt(base.Pos, nn, ir.NewUnaryExpr(base.Pos, ir.OLEN, ns))) // n = len(s)
- slice := ir.Nod(ir.OSLICE, ns, nil) // ...s[:n+argc]
- slice.SetSliceBounds(nil, ir.Nod(ir.OADD, nn, na), nil)
+ slice := ir.NewSliceExpr(base.Pos, ir.OSLICE, ns) // ...s[:n+argc]
+ slice.SetSliceBounds(nil, ir.NewBinaryExpr(base.Pos, ir.OADD, nn, na), nil)
slice.SetBounded(true)
- l = append(l, ir.Nod(ir.OAS, ns, slice)) // s = s[:n+argc]
+ l = append(l, ir.NewAssignStmt(base.Pos, ns, slice)) // s = s[:n+argc]
ls = n.List().Slice()[1:]
for i, n := range ls {
- ix := ir.Nod(ir.OINDEX, ns, nn) // s[n] ...
+ ix := ir.NewIndexExpr(base.Pos, ns, nn) // s[n] ...
ix.SetBounded(true)
- l = append(l, ir.Nod(ir.OAS, ix, n)) // s[n] = arg
+ l = append(l, ir.NewAssignStmt(base.Pos, ix, n)) // s[n] = arg
if i+1 < len(ls) {
- l = append(l, ir.Nod(ir.OAS, nn, ir.Nod(ir.OADD, nn, nodintconst(1)))) // n = n + 1
+ l = append(l, ir.NewAssignStmt(base.Pos, nn, ir.NewBinaryExpr(base.Pos, ir.OADD, nn, nodintconst(1)))) // n = n + 1
}
}
nl := temp(n.Left().Type())
nr := temp(n.Right().Type())
var l []ir.Node
- l = append(l, ir.Nod(ir.OAS, nl, n.Left()))
- l = append(l, ir.Nod(ir.OAS, nr, n.Right()))
+ l = append(l, ir.NewAssignStmt(base.Pos, nl, n.Left()))
+ l = append(l, ir.NewAssignStmt(base.Pos, nr, n.Right()))
- nfrm := ir.Nod(ir.OSPTR, nr, nil)
- nto := ir.Nod(ir.OSPTR, nl, nil)
+ nfrm := ir.NewUnaryExpr(base.Pos, ir.OSPTR, nr)
+ nto := ir.NewUnaryExpr(base.Pos, ir.OSPTR, nl)
nlen := temp(types.Types[types.TINT])
// n = len(to)
- l = append(l, ir.Nod(ir.OAS, nlen, ir.Nod(ir.OLEN, nl, nil)))
+ l = append(l, ir.NewAssignStmt(base.Pos, nlen, ir.NewUnaryExpr(base.Pos, ir.OLEN, nl)))
// if n > len(frm) { n = len(frm) }
- nif := ir.Nod(ir.OIF, nil, nil)
+ nif := ir.NewIfStmt(base.Pos, nil, nil, nil)
- nif.SetLeft(ir.Nod(ir.OGT, nlen, ir.Nod(ir.OLEN, nr, nil)))
- nif.PtrBody().Append(ir.Nod(ir.OAS, nlen, ir.Nod(ir.OLEN, nr, nil)))
+ nif.SetLeft(ir.NewBinaryExpr(base.Pos, ir.OGT, nlen, ir.NewUnaryExpr(base.Pos, ir.OLEN, nr)))
+ nif.PtrBody().Append(ir.NewAssignStmt(base.Pos, nlen, ir.NewUnaryExpr(base.Pos, ir.OLEN, nr)))
l = append(l, nif)
// if to.ptr != frm.ptr { memmove( ... ) }
- ne := ir.Nod(ir.OIF, ir.Nod(ir.ONE, nto, nfrm), nil)
+ ne := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.ONE, nto, nfrm), nil, nil)
ne.SetLikely(true)
l = append(l, ne)
fn := syslook("memmove")
fn = substArgTypes(fn, nl.Type().Elem(), nl.Type().Elem())
nwid := ir.Node(temp(types.Types[types.TUINTPTR]))
- setwid := ir.Nod(ir.OAS, nwid, conv(nlen, types.Types[types.TUINTPTR]))
+ setwid := ir.NewAssignStmt(base.Pos, nwid, conv(nlen, types.Types[types.TUINTPTR]))
ne.PtrBody().Append(setwid)
- nwid = ir.Nod(ir.OMUL, nwid, nodintconst(nl.Type().Elem().Width))
+ nwid = ir.NewBinaryExpr(base.Pos, ir.OMUL, nwid, nodintconst(nl.Type().Elem().Width))
call := mkcall1(fn, nil, init, nto, nfrm, nwid)
ne.PtrBody().Append(call)
// For non-empty interface, this is:
// l.tab != nil && l.tab._type == type(r)
var eqtype ir.Node
- tab := ir.Nod(ir.OITAB, l, nil)
+ tab := ir.NewUnaryExpr(base.Pos, ir.OITAB, l)
rtyp := typename(r.Type())
if l.Type().IsEmptyInterface() {
tab.SetType(types.NewPtr(types.Types[types.TUINT8]))
}
fn, needsize := eqfor(t)
- call := ir.Nod(ir.OCALL, fn, nil)
+ call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
call.PtrList().Append(nodAddr(cmpl))
call.PtrList().Append(nodAddr(cmpr))
if needsize {
}
res := ir.Node(call)
if n.Op() != ir.OEQ {
- res = ir.Nod(ir.ONOT, res, nil)
+ res = ir.NewUnaryExpr(base.Pos, ir.ONOT, res)
}
return finishcompare(n, res, init)
}
continue
}
compare(
- nodSym(ir.OXDOT, cmpl, sym),
- nodSym(ir.OXDOT, cmpr, sym),
+ ir.NewSelectorExpr(base.Pos, ir.OXDOT, cmpl, sym),
+ ir.NewSelectorExpr(base.Pos, ir.OXDOT, cmpr, sym),
)
}
} else {
}
if step == 1 {
compare(
- ir.Nod(ir.OINDEX, cmpl, nodintconst(i)),
- ir.Nod(ir.OINDEX, cmpr, nodintconst(i)),
+ ir.NewIndexExpr(base.Pos, cmpl, nodintconst(i)),
+ ir.NewIndexExpr(base.Pos, cmpr, nodintconst(i)),
)
i++
remains -= t.Elem().Width
} else {
elemType := t.Elem().ToUnsigned()
- cmplw := ir.Node(ir.Nod(ir.OINDEX, cmpl, nodintconst(i)))
+ cmplw := ir.Node(ir.NewIndexExpr(base.Pos, cmpl, nodintconst(i)))
cmplw = conv(cmplw, elemType) // convert to unsigned
cmplw = conv(cmplw, convType) // widen
- cmprw := ir.Node(ir.Nod(ir.OINDEX, cmpr, nodintconst(i)))
+ cmprw := ir.Node(ir.NewIndexExpr(base.Pos, cmpr, nodintconst(i)))
cmprw = conv(cmprw, elemType)
cmprw = conv(cmprw, convType)
// For code like this: uint32(s[0]) | uint32(s[1])<<8 | uint32(s[2])<<16 ...
// ssa will generate a single large load.
for offset := int64(1); offset < step; offset++ {
- lb := ir.Node(ir.Nod(ir.OINDEX, cmpl, nodintconst(i+offset)))
+ lb := ir.Node(ir.NewIndexExpr(base.Pos, cmpl, nodintconst(i+offset)))
lb = conv(lb, elemType)
lb = conv(lb, convType)
- lb = ir.Nod(ir.OLSH, lb, nodintconst(8*t.Elem().Width*offset))
- cmplw = ir.Nod(ir.OOR, cmplw, lb)
- rb := ir.Node(ir.Nod(ir.OINDEX, cmpr, nodintconst(i+offset)))
+ lb = ir.NewBinaryExpr(base.Pos, ir.OLSH, lb, nodintconst(8*t.Elem().Width*offset))
+ cmplw = ir.NewBinaryExpr(base.Pos, ir.OOR, cmplw, lb)
+ rb := ir.Node(ir.NewIndexExpr(base.Pos, cmpr, nodintconst(i+offset)))
rb = conv(rb, elemType)
rb = conv(rb, convType)
- rb = ir.Nod(ir.OLSH, rb, nodintconst(8*t.Elem().Width*offset))
- cmprw = ir.Nod(ir.OOR, cmprw, rb)
+ rb = ir.NewBinaryExpr(base.Pos, ir.OLSH, rb, nodintconst(8*t.Elem().Width*offset))
+ cmprw = ir.NewBinaryExpr(base.Pos, ir.OOR, cmprw, rb)
}
compare(cmplw, cmprw)
i += step
// We still need to use cmpl and cmpr, in case they contain
// an expression which might panic. See issue 23837.
t := temp(cmpl.Type())
- a1 := typecheck(ir.Nod(ir.OAS, t, cmpl), ctxStmt)
- a2 := typecheck(ir.Nod(ir.OAS, t, cmpr), ctxStmt)
+ a1 := typecheck(ir.NewAssignStmt(base.Pos, t, cmpl), ctxStmt)
+ a2 := typecheck(ir.NewAssignStmt(base.Pos, t, cmpr), ctxStmt)
init.Append(a1, a2)
}
return finishcompare(n, expr, init)
eqtab, eqdata := eqinterface(n.Left(), n.Right())
var cmp ir.Node
if n.Op() == ir.OEQ {
- cmp = ir.Nod(ir.OANDAND, eqtab, eqdata)
+ cmp = ir.NewLogicalExpr(base.Pos, ir.OANDAND, eqtab, eqdata)
} else {
eqtab.SetOp(ir.ONE)
- cmp = ir.Nod(ir.OOROR, eqtab, ir.Nod(ir.ONOT, eqdata, nil))
+ cmp = ir.NewLogicalExpr(base.Pos, ir.OOROR, eqtab, ir.NewUnaryExpr(base.Pos, ir.ONOT, eqdata))
}
return finishcompare(n, cmp, init)
}
if len(s) > 0 {
ncs = safeexpr(ncs, init)
}
- r := ir.Node(ir.NewBinaryExpr(base.Pos, cmp, ir.Nod(ir.OLEN, ncs, nil), nodintconst(int64(len(s)))))
+ r := ir.Node(ir.NewBinaryExpr(base.Pos, cmp, ir.NewUnaryExpr(base.Pos, ir.OLEN, ncs), nodintconst(int64(len(s)))))
remains := len(s)
for i := 0; remains > 0; {
if remains == 1 || !canCombineLoads {
cb := nodintconst(int64(s[i]))
- ncb := ir.Nod(ir.OINDEX, ncs, nodintconst(int64(i)))
+ ncb := ir.NewIndexExpr(base.Pos, ncs, nodintconst(int64(i)))
r = ir.NewLogicalExpr(base.Pos, and, r, ir.NewBinaryExpr(base.Pos, cmp, ncb, cb))
remains--
i++
convType = types.Types[types.TUINT16]
step = 2
}
- ncsubstr := conv(ir.Nod(ir.OINDEX, ncs, nodintconst(int64(i))), convType)
+ ncsubstr := conv(ir.NewIndexExpr(base.Pos, ncs, nodintconst(int64(i))), convType)
csubstr := int64(s[i])
// Calculate large constant from bytes as sequence of shifts and ors.
// Like this: uint32(s[0]) | uint32(s[1])<<8 | uint32(s[2])<<16 ...
// ssa will combine this into a single large load.
for offset := 1; offset < step; offset++ {
- b := conv(ir.Nod(ir.OINDEX, ncs, nodintconst(int64(i+offset))), convType)
- b = ir.Nod(ir.OLSH, b, nodintconst(int64(8*offset)))
- ncsubstr = ir.Nod(ir.OOR, ncsubstr, b)
+ b := conv(ir.NewIndexExpr(base.Pos, ncs, nodintconst(int64(i+offset))), convType)
+ b = ir.NewBinaryExpr(base.Pos, ir.OLSH, b, nodintconst(int64(8*offset)))
+ ncsubstr = ir.NewBinaryExpr(base.Pos, ir.OOR, ncsubstr, b)
csubstr |= int64(s[i+offset]) << uint8(8*offset)
}
csubstrPart := nodintconst(csubstr)
// memequal then tests equality up to length len.
if n.Op() == ir.OEQ {
// len(left) == len(right) && memequal(left, right, len)
- r = ir.Nod(ir.OANDAND, eqlen, eqmem)
+ r = ir.NewLogicalExpr(base.Pos, ir.OANDAND, eqlen, eqmem)
} else {
// len(left) != len(right) || !memequal(left, right, len)
eqlen.SetOp(ir.ONE)
- r = ir.Nod(ir.OOROR, eqlen, ir.Nod(ir.ONOT, eqmem, nil))
+ r = ir.NewLogicalExpr(base.Pos, ir.OOROR, eqlen, ir.NewUnaryExpr(base.Pos, ir.ONOT, eqmem))
}
} else {
// sys_cmpstring(s1, s2) :: 0
func IsMethod(n Node) bool {
return n.Type().Recv() != nil
}
-
-func Nod(op Op, nleft, nright Node) Node {
- return NodAt(base.Pos, op, nleft, nright)
-}
-
-func NodAt(pos src.XPos, op Op, nleft, nright Node) Node {
- switch op {
- default:
- panic("NodAt " + op.String())
- case OADD, OAND, OANDNOT, ODIV, OEQ, OGE, OGT, OLE,
- OLSH, OLT, OMOD, OMUL, ONE, OOR, ORSH, OSUB, OXOR,
- OCOPY, OCOMPLEX,
- OEFACE:
- return NewBinaryExpr(pos, op, nleft, nright)
- case OADDR:
- return NewAddrExpr(pos, nleft)
- case OADDSTR:
- return NewAddStringExpr(pos, nil)
- case OANDAND, OOROR:
- return NewLogicalExpr(pos, op, nleft, nright)
- case OARRAYLIT, OCOMPLIT, OMAPLIT, OSTRUCTLIT, OSLICELIT:
- var typ Ntype
- if nright != nil {
- typ = nright.(Ntype)
- }
- return NewCompLitExpr(pos, op, typ, nil)
- case OAS:
- return NewAssignStmt(pos, nleft, nright)
- case OAS2, OAS2DOTTYPE, OAS2FUNC, OAS2MAPR, OAS2RECV, OSELRECV2:
- n := NewAssignListStmt(pos, op, nil, nil)
- return n
- case OASOP:
- return NewAssignOpStmt(pos, OXXX, nleft, nright)
- case OBITNOT, ONEG, ONOT, OPLUS, ORECV,
- OALIGNOF, OCAP, OCLOSE, OIMAG, OLEN, ONEW, ONEWOBJ,
- OOFFSETOF, OPANIC, OREAL, OSIZEOF,
- OCHECKNIL, OCFUNC, OIDATA, OITAB, OSPTR, OVARDEF, OVARKILL, OVARLIVE:
- if nright != nil {
- panic("unary nright")
- }
- return NewUnaryExpr(pos, op, nleft)
- case OBLOCK:
- return NewBlockStmt(pos, nil)
- case OBREAK, OCONTINUE, OFALL, OGOTO, ORETJMP:
- return NewBranchStmt(pos, op, nil)
- case OCALL, OCALLFUNC, OCALLINTER, OCALLMETH,
- OAPPEND, ODELETE, OGETG, OMAKE, OPRINT, OPRINTN, ORECOVER:
- return NewCallExpr(pos, op, nleft, nil)
- case OCASE:
- return NewCaseStmt(pos, nil, nil)
- case OCONV, OCONVIFACE, OCONVNOP, ORUNESTR:
- return NewConvExpr(pos, op, nil, nleft)
- case ODCL, ODCLCONST, ODCLTYPE:
- return NewDecl(pos, op, nleft)
- case ODCLFUNC:
- return NewFunc(pos)
- case ODEFER, OGO:
- return NewGoDeferStmt(pos, op, nleft)
- case ODEREF:
- return NewStarExpr(pos, nleft)
- case ODOT, ODOTPTR, ODOTMETH, ODOTINTER, OXDOT:
- return NewSelectorExpr(pos, op, nleft, nil)
- case ODOTTYPE, ODOTTYPE2:
- var typ Ntype
- if nright != nil {
- typ = nright.(Ntype)
- }
- n := NewTypeAssertExpr(pos, nleft, typ)
- if op != ODOTTYPE {
- n.SetOp(op)
- }
- return n
- case OFOR:
- return NewForStmt(pos, nil, nleft, nright, nil)
- case OIF:
- return NewIfStmt(pos, nleft, nil, nil)
- case OINDEX, OINDEXMAP:
- n := NewIndexExpr(pos, nleft, nright)
- if op != OINDEX {
- n.SetOp(op)
- }
- return n
- case OINLMARK:
- return NewInlineMarkStmt(pos, types.BADWIDTH)
- case OKEY:
- return NewKeyExpr(pos, nleft, nright)
- case OSTRUCTKEY:
- return NewStructKeyExpr(pos, nil, nleft)
- case OLABEL:
- return NewLabelStmt(pos, nil)
- case OLITERAL, OTYPE, OIOTA:
- return newNameAt(pos, op, nil)
- case OMAKECHAN, OMAKEMAP, OMAKESLICE, OMAKESLICECOPY:
- return NewMakeExpr(pos, op, nleft, nright)
- case ONIL:
- return NewNilExpr(pos)
- case OPACK:
- return NewPkgName(pos, nil, nil)
- case OPAREN:
- return NewParenExpr(pos, nleft)
- case ORANGE:
- return NewRangeStmt(pos, nil, nright, nil)
- case ORESULT:
- return NewResultExpr(pos, nil, types.BADWIDTH)
- case ORETURN:
- return NewReturnStmt(pos, nil)
- case OSELECT:
- return NewSelectStmt(pos, nil)
- case OSEND:
- return NewSendStmt(pos, nleft, nright)
- case OSLICE, OSLICEARR, OSLICESTR, OSLICE3, OSLICE3ARR:
- return NewSliceExpr(pos, op, nleft)
- case OSLICEHEADER:
- return NewSliceHeaderExpr(pos, nil, nleft, nil, nil)
- case OSWITCH:
- return NewSwitchStmt(pos, nleft, nil)
- case OINLCALL:
- return NewInlinedCallExpr(pos, nil, nil)
- }
-}