markdcl()
// func sym(p *T, h uintptr) uintptr
- fn := Nod(ODCLFUNC, nil, nil)
+ fn := nod(ODCLFUNC, nil, nil)
fn.Func.Nname = newname(sym)
fn.Func.Nname.Class = PFUNC
- tfn := Nod(OTFUNC, nil, nil)
+ tfn := nod(OTFUNC, nil, nil)
fn.Func.Nname.Name.Param.Ntype = tfn
- n := Nod(ODCLFIELD, newname(lookup("p")), typenod(ptrto(t)))
+ n := nod(ODCLFIELD, newname(lookup("p")), typenod(ptrto(t)))
tfn.List.Append(n)
np := n.Left
- n = Nod(ODCLFIELD, newname(lookup("h")), typenod(Types[TUINTPTR]))
+ n = nod(ODCLFIELD, newname(lookup("h")), typenod(Types[TUINTPTR]))
tfn.List.Append(n)
nh := n.Left
- n = Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])) // return value
+ n = nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])) // return value
tfn.Rlist.Append(n)
funchdr(fn)
// pure memory.
hashel := hashfor(t.Elem())
- n := Nod(ORANGE, nil, Nod(OIND, np, nil))
+ n := nod(ORANGE, nil, nod(OIND, np, nil))
ni := newname(lookup("i"))
ni.Type = Types[TINT]
n.List.Set1(ni)
ni = n.List.First()
// h = hashel(&p[i], h)
- call := Nod(OCALL, hashel, nil)
+ call := nod(OCALL, hashel, nil)
- nx := Nod(OINDEX, np, ni)
+ nx := nod(OINDEX, np, ni)
nx.Bounded = true
- na := Nod(OADDR, nx, nil)
+ na := nod(OADDR, nx, nil)
na.Etype = 1 // no escape to heap
call.List.Append(na)
call.List.Append(nh)
- n.Nbody.Append(Nod(OAS, nh, call))
+ n.Nbody.Append(nod(OAS, nh, call))
fn.Nbody.Append(n)
// Hash non-memory fields with appropriate hash function.
if !f.Type.IsRegularMemory() {
hashel := hashfor(f.Type)
- call := Nod(OCALL, hashel, nil)
+ call := nod(OCALL, hashel, nil)
nx := nodSym(OXDOT, np, f.Sym) // TODO: fields from other packages?
- na := Nod(OADDR, nx, nil)
+ na := nod(OADDR, nx, nil)
na.Etype = 1 // no escape to heap
call.List.Append(na)
call.List.Append(nh)
- fn.Nbody.Append(Nod(OAS, nh, call))
+ fn.Nbody.Append(nod(OAS, nh, call))
i++
continue
}
// h = hashel(&p.first, size, h)
hashel := hashmem(f.Type)
- call := Nod(OCALL, hashel, nil)
+ call := nod(OCALL, hashel, nil)
nx := nodSym(OXDOT, np, f.Sym) // TODO: fields from other packages?
- na := Nod(OADDR, nx, nil)
+ na := nod(OADDR, nx, nil)
na.Etype = 1 // no escape to heap
call.List.Append(na)
call.List.Append(nh)
call.List.Append(nodintconst(size))
- fn.Nbody.Append(Nod(OAS, nh, call))
+ fn.Nbody.Append(nod(OAS, nh, call))
i = next
}
}
- r := Nod(ORETURN, nil, nil)
+ r := nod(ORETURN, nil, nil)
r.List.Append(nh)
fn.Nbody.Append(r)
n := newname(sym)
n.Class = PFUNC
- tfn := Nod(OTFUNC, nil, nil)
- tfn.List.Append(Nod(ODCLFIELD, nil, typenod(ptrto(t))))
- tfn.List.Append(Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
- tfn.Rlist.Append(Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
+ tfn := nod(OTFUNC, nil, nil)
+ tfn.List.Append(nod(ODCLFIELD, nil, typenod(ptrto(t))))
+ tfn.List.Append(nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
+ tfn.Rlist.Append(nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
tfn = typecheck(tfn, Etype)
n.Type = tfn.Type
return n
markdcl()
// func sym(p, q *T) bool
- fn := Nod(ODCLFUNC, nil, nil)
+ fn := nod(ODCLFUNC, nil, nil)
fn.Func.Nname = newname(sym)
fn.Func.Nname.Class = PFUNC
- tfn := Nod(OTFUNC, nil, nil)
+ tfn := nod(OTFUNC, nil, nil)
fn.Func.Nname.Name.Param.Ntype = tfn
- n := Nod(ODCLFIELD, newname(lookup("p")), typenod(ptrto(t)))
+ n := nod(ODCLFIELD, newname(lookup("p")), typenod(ptrto(t)))
tfn.List.Append(n)
np := n.Left
- n = Nod(ODCLFIELD, newname(lookup("q")), typenod(ptrto(t)))
+ n = nod(ODCLFIELD, newname(lookup("q")), typenod(ptrto(t)))
tfn.List.Append(n)
nq := n.Left
- n = Nod(ODCLFIELD, nil, typenod(Types[TBOOL]))
+ n = nod(ODCLFIELD, nil, typenod(Types[TBOOL]))
tfn.Rlist.Append(n)
funchdr(fn)
// pure memory. Even if we unrolled the range loop,
// each iteration would be a function call, so don't bother
// unrolling.
- nrange := Nod(ORANGE, nil, Nod(OIND, np, nil))
+ nrange := nod(ORANGE, nil, nod(OIND, np, nil))
ni := newname(lookup("i"))
ni.Type = Types[TINT]
ni = nrange.List.First()
// if p[i] != q[i] { return false }
- nx := Nod(OINDEX, np, ni)
+ nx := nod(OINDEX, np, ni)
nx.Bounded = true
- ny := Nod(OINDEX, nq, ni)
+ ny := nod(OINDEX, nq, ni)
ny.Bounded = true
- nif := Nod(OIF, nil, nil)
- nif.Left = Nod(ONE, nx, ny)
- r := Nod(ORETURN, nil, nil)
+ nif := nod(OIF, nil, nil)
+ nif.Left = nod(ONE, nx, ny)
+ r := nod(ORETURN, nil, nil)
r.List.Append(nodbool(false))
nif.Nbody.Append(r)
nrange.Nbody.Append(nif)
fn.Nbody.Append(nrange)
// return true
- ret := Nod(ORETURN, nil, nil)
+ ret := nod(ORETURN, nil, nil)
ret.List.Append(nodbool(true))
fn.Nbody.Append(ret)
cond = n
return
}
- cond = Nod(OANDAND, cond, n)
+ cond = nod(OANDAND, cond, n)
}
// Walk the struct using memequal for runs of AMEM
cond = nodbool(true)
}
- ret := Nod(ORETURN, nil, nil)
+ ret := nod(ORETURN, nil, nil)
ret.List.Append(cond)
fn.Nbody.Append(ret)
}
func eqfield(p *Node, q *Node, field *Sym) *Node {
nx := nodSym(OXDOT, p, field)
ny := nodSym(OXDOT, q, field)
- ne := Nod(OEQ, nx, ny)
+ ne := nod(OEQ, nx, ny)
return ne
}
// eqmem returns the node
// memequal(&p.field, &q.field [, size])
func eqmem(p *Node, q *Node, field *Sym, size int64) *Node {
- nx := Nod(OADDR, nodSym(OXDOT, p, field), nil)
+ nx := nod(OADDR, nodSym(OXDOT, p, field), nil)
nx.Etype = 1 // does not escape
- ny := Nod(OADDR, nodSym(OXDOT, q, field), nil)
+ ny := nod(OADDR, nodSym(OXDOT, q, field), nil)
ny.Etype = 1 // does not escape
nx = typecheck(nx, Erv)
ny = typecheck(ny, Erv)
fn, needsize := eqmemfunc(size, nx.Type.Elem())
- call := Nod(OCALL, fn, nil)
+ call := nod(OCALL, fn, nil)
call.List.Append(nx)
call.List.Append(ny)
if needsize {
// (not doing so can cause significant performance
// degradation due to unnecessary calls to empty
// functions).
- body = []*Node{Nod(OEMPTY, nil, nil)}
+ body = []*Node{nod(OEMPTY, nil, nil)}
}
f.Func.Inl.Set(body)
funcbody(f)
// importtype declares that pt, an imported named type, has underlying type t.
func (p *importer) importtype(pt, t *Type) {
if pt.Etype == TFORW {
- n := pt.Nod
- copytype(pt.Nod, t)
- pt.Nod = n // unzero nod
+ n := pt.nod
+ copytype(pt.nod, t)
+ pt.nod = n // unzero nod
pt.Sym.Importdef = importpkg
pt.Sym.Lastlineno = lineno
declare(n, PEXTERN)
var n *Node
if sym.Name != "" {
- n = Nod(ODCLFIELD, newname(sym), typenod(typ))
+ n = nod(ODCLFIELD, newname(sym), typenod(typ))
} else {
// anonymous field - typ must be T or *T and T must be a type name
s := typ.Sym
sym := p.fieldName()
params := p.paramList()
result := p.paramList()
- return Nod(ODCLFIELD, newname(sym), typenod(functype(fakethis(), params, result)))
+ return nod(ODCLFIELD, newname(sym), typenod(functype(fakethis(), params, result)))
}
// parser.go:sym,hidden_importsym
isddd = true
}
- n := Nod(ODCLFIELD, nil, typenod(typ))
+ n := nod(ODCLFIELD, nil, typenod(typ))
n.Isddd = isddd
if named {
c := p.int()
list := make([]*Node, c)
for i := range list {
- list[i] = Nod(OKEY, mkname(p.fieldSym()), p.expr())
+ list[i] = nod(OKEY, mkname(p.fieldSym()), p.expr())
}
return list
}
// again. Re-introduce explicit uintptr(c) conversion.
// (issue 16317).
if typ.IsUnsafePtr() {
- conv := Nod(OCALL, typenod(Types[TUINTPTR]), nil)
+ conv := nod(OCALL, typenod(Types[TUINTPTR]), nil)
conv.List.Set1(n)
n = conv
}
- conv := Nod(OCALL, typenod(typ), nil)
+ conv := nod(OCALL, typenod(typ), nil)
conv.List.Set1(n)
n = conv
}
if !p.bool() /* !implicit, i.e. '&' operator */ {
if n.Op == OCOMPLIT {
// Special case for &T{...}: turn into (*T){...}.
- n.Right = Nod(OIND, n.Right, nil)
+ n.Right = nod(OIND, n.Right, nil)
n.Right.Implicit = true
} else {
- n = Nod(OADDR, n, nil)
+ n = nod(OADDR, n, nil)
}
}
return n
case OSTRUCTLIT:
- n := Nod(OCOMPLIT, nil, typenod(p.typ()))
+ n := nod(OCOMPLIT, nil, typenod(p.typ()))
n.List.Set(p.elemList()) // special handling of field names
return n
// unreachable - mapped to case OCOMPLIT below by exporter
case OCOMPLIT:
- n := Nod(OCOMPLIT, nil, typenod(p.typ()))
+ n := nod(OCOMPLIT, nil, typenod(p.typ()))
n.List.Set(p.exprList())
return n
case OKEY:
left, right := p.exprsOrNil()
- return Nod(OKEY, left, right)
+ return nod(OKEY, left, right)
// case OCALLPART:
// unimplemented
// unreachable - mapped to case ODOTTYPE below by exporter
case ODOTTYPE:
- n := Nod(ODOTTYPE, p.expr(), nil)
+ n := nod(ODOTTYPE, p.expr(), nil)
if p.bool() {
n.Right = p.expr()
} else {
// unreachable - mapped to cases below by exporter
case OINDEX:
- return Nod(op, p.expr(), p.expr())
+ return nod(op, p.expr(), p.expr())
case OSLICE, OSLICE3:
- n := Nod(op, p.expr(), nil)
+ n := nod(op, p.expr(), nil)
low, high := p.exprsOrNil()
var max *Node
if n.Op.IsSlice3() {
// unreachable - mapped to OCONV case below by exporter
case OCONV:
- n := Nod(OCALL, typenod(p.typ()), nil)
+ n := nod(OCALL, typenod(p.typ()), nil)
n.List.Set(p.exprList())
return n
// unreachable - mapped to OCALL case below by exporter
case OCALL:
- n := Nod(OCALL, p.expr(), nil)
+ n := nod(OCALL, p.expr(), nil)
n.List.Set(p.exprList())
n.Isddd = p.bool()
return n
// unary expressions
case OPLUS, OMINUS, OADDR, OCOM, OIND, ONOT, ORECV:
- return Nod(op, p.expr(), nil)
+ return nod(op, p.expr(), nil)
// binary expressions
case OADD, OAND, OANDAND, OANDNOT, ODIV, OEQ, OGE, OGT, OLE, OLT,
OLSH, OMOD, OMUL, ONE, OOR, OOROR, ORSH, OSEND, OSUB, OXOR:
- return Nod(op, p.expr(), p.expr())
+ return nod(op, p.expr(), p.expr())
case OADDSTR:
list := p.exprList()
x := list[0]
for _, y := range list[1:] {
- x = Nod(OADD, x, y)
+ x = nod(OADD, x, y)
}
return x
case ODCLCONST:
// TODO(gri) these should not be exported in the first place
- return Nod(OEMPTY, nil, nil)
+ return nod(OEMPTY, nil, nil)
// --------------------------------------------------------------------
// statements
// unreachable - mapped to OAS case below by exporter
case OAS:
- return Nod(OAS, p.expr(), p.expr())
+ return nod(OAS, p.expr(), p.expr())
case OASOP:
- n := Nod(OASOP, nil, nil)
+ n := nod(OASOP, nil, nil)
n.Etype = EType(p.int())
n.Left = p.expr()
if !p.bool() {
// unreachable - mapped to OAS2 case below by exporter
case OAS2:
- n := Nod(OAS2, nil, nil)
+ n := nod(OAS2, nil, nil)
n.List.Set(p.exprList())
n.Rlist.Set(p.exprList())
return n
case ORETURN:
- n := Nod(ORETURN, nil, nil)
+ n := nod(ORETURN, nil, nil)
n.List.Set(p.exprList())
return n
// unreachable - generated by compiler for trampolin routines (not exported)
case OPROC, ODEFER:
- return Nod(op, p.expr(), nil)
+ return nod(op, p.expr(), nil)
case OIF:
markdcl()
- n := Nod(OIF, nil, nil)
+ n := nod(OIF, nil, nil)
n.Ninit.Set(p.stmtList())
n.Left = p.expr()
n.Nbody.Set(p.stmtList())
case OFOR:
markdcl()
- n := Nod(OFOR, nil, nil)
+ n := nod(OFOR, nil, nil)
n.Ninit.Set(p.stmtList())
n.Left, n.Right = p.exprsOrNil()
n.Nbody.Set(p.stmtList())
case ORANGE:
markdcl()
- n := Nod(ORANGE, nil, nil)
+ n := nod(ORANGE, nil, nil)
n.List.Set(p.stmtList())
n.Right = p.expr()
n.Nbody.Set(p.stmtList())
case OSELECT, OSWITCH:
markdcl()
- n := Nod(op, nil, nil)
+ n := nod(op, nil, nil)
n.Ninit.Set(p.stmtList())
n.Left, _ = p.exprsOrNil()
n.List.Set(p.stmtList())
case OXCASE:
markdcl()
- n := Nod(OXCASE, nil, nil)
+ n := nod(OXCASE, nil, nil)
n.Xoffset = int64(block)
n.List.Set(p.exprList())
// TODO(gri) eventually we must declare variables for type switch
// unreachable - mapped to OXFALL case below by exporter
case OXFALL:
- n := Nod(OXFALL, nil, nil)
+ n := nod(OXFALL, nil, nil)
n.Xoffset = int64(block)
return n
if left != nil {
left = newname(left.Sym)
}
- return Nod(op, left, nil)
+ return nod(op, left, nil)
// case OEMPTY:
// unreachable - not emitted by exporter
case OGOTO, OLABEL:
- n := Nod(op, newname(p.expr().Sym), nil)
+ n := nod(op, newname(p.expr().Sym), nil)
n.Sym = dclstack // context, for goto restrictions
return n
}
func builtinCall(op Op) *Node {
- return Nod(OCALL, mkname(builtinpkg.Lookup(goopnames[op])), nil)
+ return nod(OCALL, mkname(builtinpkg.Lookup(goopnames[op])), nil)
}
func (p *importer) exprsOrNil() (a, b *Node) {
// function literals aka closures
func closurehdr(ntype *Node) {
- n := Nod(OCLOSURE, nil, nil)
+ n := nod(OCLOSURE, nil, nil)
n.Func.Ntype = ntype
n.Func.Depth = funcdepth
n.Func.Outerfunc = Curfn
if name != nil {
name = newname(name.Sym)
}
- a := Nod(ODCLFIELD, name, n1.Right)
+ a := nod(ODCLFIELD, name, n1.Right)
a.Isddd = n1.Isddd
if name != nil {
name.Isddd = a.Isddd
if name != nil {
name = newname(name.Sym)
}
- ntype.Rlist.Append(Nod(ODCLFIELD, name, n2.Right))
+ ntype.Rlist.Append(nod(ODCLFIELD, name, n2.Right))
}
}
func closurebody(body []*Node) *Node {
if len(body) == 0 {
- body = []*Node{Nod(OEMPTY, nil, nil)}
+ body = []*Node{nod(OEMPTY, nil, nil)}
}
func_ := Curfn
func makeclosure(func_ *Node) *Node {
// wrap body in external function
// that begins by reading closure parameters.
- xtype := Nod(OTFUNC, nil, nil)
+ xtype := nod(OTFUNC, nil, nil)
xtype.List.Set(func_.List.Slice())
xtype.Rlist.Set(func_.Rlist.Slice())
// create the function
- xfunc := Nod(ODCLFUNC, nil, nil)
+ xfunc := nod(ODCLFUNC, nil, nil)
xfunc.Func.Nname = newfuncname(closurename(func_))
xfunc.Func.Nname.Sym.Flags |= SymExported // disable export
v.Name.Byval = true
} else {
outermost.Addrtaken = true
- outer = Nod(OADDR, outer, nil)
+ outer = nod(OADDR, outer, nil)
}
if Debug['m'] > 1 {
}
// cv refers to the field inside of closure OSTRUCTLIT.
- cv := Nod(OCLOSUREVAR, nil, nil)
+ cv := nod(OCLOSUREVAR, nil, nil)
cv.Type = v.Type
if !v.Name.Byval {
v.Class = PAUTO
v.Ullman = 1
xfunc.Func.Dcl = append(xfunc.Func.Dcl, v)
- body = append(body, Nod(OAS, v, cv))
+ body = append(body, nod(OAS, v, cv))
} else {
// Declare variable holding addresses taken from closure
// and initialize in entry prologue.
addr := newname(lookupf("&%s", v.Sym.Name))
- addr.Name.Param.Ntype = Nod(OIND, typenod(v.Type), nil)
+ addr.Name.Param.Ntype = nod(OIND, typenod(v.Type), nil)
addr.Class = PAUTO
addr.Used = true
addr.Name.Curfn = xfunc
xfunc.Func.Dcl = append(xfunc.Func.Dcl, addr)
v.Name.Heapaddr = addr
if v.Name.Byval {
- cv = Nod(OADDR, cv, nil)
+ cv = nod(OADDR, cv, nil)
}
- body = append(body, Nod(OAS, addr, cv))
+ body = append(body, nod(OAS, addr, cv))
}
}
// the struct is unnamed so that closures in multiple packages with the
// same struct type can share the descriptor.
- typ := Nod(OTSTRUCT, nil, nil)
+ typ := nod(OTSTRUCT, nil, nil)
- typ.List.Set1(Nod(ODCLFIELD, newname(lookup(".F")), typenod(Types[TUINTPTR])))
+ typ.List.Set1(nod(ODCLFIELD, newname(lookup(".F")), typenod(Types[TUINTPTR])))
for _, v := range func_.Func.Cvars.Slice() {
if v.Op == OXXX {
continue
}
typ1 := typenod(v.Type)
if !v.Name.Byval {
- typ1 = Nod(OIND, typ1, nil)
+ typ1 = nod(OIND, typ1, nil)
}
- typ.List.Append(Nod(ODCLFIELD, newname(v.Sym), typ1))
+ typ.List.Append(nod(ODCLFIELD, newname(v.Sym), typ1))
}
- clos := Nod(OCOMPLIT, nil, Nod(OIND, typ, nil))
+ clos := nod(OCOMPLIT, nil, nod(OIND, typ, nil))
clos.Esc = func_.Esc
clos.Right.Implicit = true
- clos.List.Set(append([]*Node{Nod(OCFUNC, func_.Func.Closure.Func.Nname, nil)}, func_.Func.Enter.Slice()...))
+ clos.List.Set(append([]*Node{nod(OCFUNC, func_.Func.Closure.Func.Nname, nil)}, func_.Func.Enter.Slice()...))
// Force type conversion from *struct to the func type.
- clos = Nod(OCONVNOP, clos, nil)
+ clos = nod(OCONVNOP, clos, nil)
clos.Type = func_.Type
savecurfn := Curfn
Curfn = nil
- xtype := Nod(OTFUNC, nil, nil)
+ xtype := nod(OTFUNC, nil, nil)
var l []*Node
var callargs []*Node
ddd := false
- xfunc := Nod(ODCLFUNC, nil, nil)
+ xfunc := nod(ODCLFUNC, nil, nil)
Curfn = xfunc
for i, t := range t0.Params().Fields().Slice() {
n := newname(lookupN("a", i))
n.Class = PPARAM
xfunc.Func.Dcl = append(xfunc.Func.Dcl, n)
callargs = append(callargs, n)
- fld := Nod(ODCLFIELD, n, typenod(t.Type))
+ fld := nod(ODCLFIELD, n, typenod(t.Type))
if t.Isddd {
fld.Isddd = true
ddd = true
n.Class = PPARAMOUT
xfunc.Func.Dcl = append(xfunc.Func.Dcl, n)
retargs = append(retargs, n)
- l = append(l, Nod(ODCLFIELD, n, typenod(t.Type)))
+ l = append(l, nod(ODCLFIELD, n, typenod(t.Type)))
}
xtype.Rlist.Set(l)
// Declare and initialize variable holding receiver.
xfunc.Func.Needctxt = true
- cv := Nod(OCLOSUREVAR, nil, nil)
+ cv := nod(OCLOSUREVAR, nil, nil)
cv.Xoffset = int64(Widthptr)
cv.Type = rcvrtype
if int(cv.Type.Align) > Widthptr {
cv.Xoffset = int64(cv.Type.Align)
}
- ptr := Nod(ONAME, nil, nil)
+ ptr := nod(ONAME, nil, nil)
ptr.Sym = lookup("rcvr")
ptr.Class = PAUTO
ptr.Addable = true
var body []*Node
if rcvrtype.IsPtr() || rcvrtype.IsInterface() {
ptr.Name.Param.Ntype = typenod(rcvrtype)
- body = append(body, Nod(OAS, ptr, cv))
+ body = append(body, nod(OAS, ptr, cv))
} else {
ptr.Name.Param.Ntype = typenod(ptrto(rcvrtype))
- body = append(body, Nod(OAS, ptr, Nod(OADDR, cv, nil)))
+ body = append(body, nod(OAS, ptr, nod(OADDR, cv, nil)))
}
- call := Nod(OCALL, nodSym(OXDOT, ptr, meth), nil)
+ call := nod(OCALL, nodSym(OXDOT, ptr, meth), nil)
call.List.Set(callargs)
call.Isddd = ddd
if t0.Results().NumFields() == 0 {
body = append(body, call)
} else {
- n := Nod(OAS2, nil, nil)
+ n := nod(OAS2, nil, nil)
n.List.Set(retargs)
n.Rlist.Set1(call)
body = append(body, n)
- n = Nod(ORETURN, nil, nil)
+ n = nod(ORETURN, nil, nil)
body = append(body, n)
}
checknil(n.Left, init)
}
- typ := Nod(OTSTRUCT, nil, nil)
- typ.List.Set1(Nod(ODCLFIELD, newname(lookup("F")), typenod(Types[TUINTPTR])))
- typ.List.Append(Nod(ODCLFIELD, newname(lookup("R")), typenod(n.Left.Type)))
+ typ := nod(OTSTRUCT, nil, nil)
+ typ.List.Set1(nod(ODCLFIELD, newname(lookup("F")), typenod(Types[TUINTPTR])))
+ typ.List.Append(nod(ODCLFIELD, newname(lookup("R")), typenod(n.Left.Type)))
- clos := Nod(OCOMPLIT, nil, Nod(OIND, typ, nil))
+ clos := nod(OCOMPLIT, nil, nod(OIND, typ, nil))
clos.Esc = n.Esc
clos.Right.Implicit = true
- clos.List.Set1(Nod(OCFUNC, n.Func.Nname, nil))
+ clos.List.Set1(nod(OCFUNC, n.Func.Nname, nil))
clos.List.Append(n.Left)
// Force type conversion from *struct to the func type.
- clos = Nod(OCONVNOP, clos, nil)
+ clos = nod(OCONVNOP, clos, nil)
clos.Type = n.Type
func saveorig(n *Node) *Node {
if n == n.Orig {
// duplicate node for n->orig.
- n1 := Nod(OLITERAL, nil, nil)
+ n1 := nod(OLITERAL, nil, nil)
n.Orig = n1
*n1 = *n
}
func nodlit(v Val) *Node {
- n := Nod(OLITERAL, nil, nil)
+ n := nod(OLITERAL, nil, nil)
n.SetVal(v)
switch v.Ctype() {
default:
i = toflt(i)
c := new(Mpcplx)
- n := Nod(OLITERAL, nil, nil)
+ n := nod(OLITERAL, nil, nil)
n.Type = Types[TIDEAL]
n.SetVal(Val{c})
if len(el) == 1 && len(vl) > 1 {
e := el[0]
- as2 := Nod(OAS2, nil, nil)
+ as2 := nod(OAS2, nil, nil)
as2.List.Set(vl)
as2.Rlist.Set1(e)
for _, v := range vl {
v.Name.Param.Ntype = t
v.Name.Defn = as2
if funcdepth > 0 {
- init = append(init, Nod(ODCL, v, nil))
+ init = append(init, nod(ODCL, v, nil))
}
}
if e != nil || funcdepth > 0 || isblank(v) {
if funcdepth > 0 {
- init = append(init, Nod(ODCL, v, nil))
+ init = append(init, nod(ODCL, v, nil))
}
- e = Nod(OAS, v, e)
+ e = nod(OAS, v, e)
init = append(init, e)
if e.Right != nil {
v.Name.Defn = e
v.Name.Param.Ntype = t
v.Name.Defn = c
- vv = append(vv, Nod(ODCLCONST, v, nil))
+ vv = append(vv, nod(ODCLCONST, v, nil))
}
if len(clcopy) != 0 {
Fatalf("newname nil")
}
- n := Nod(ONAME, nil, nil)
+ n := nod(ONAME, nil, nil)
n.Sym = s
n.Type = nil
n.Addable = true
// if we copied another type with *t = *u
// then t->nod might be out of date, so
// check t->nod->type too
- if t.Nod == nil || t.Nod.Type != t {
- t.Nod = Nod(OTYPE, nil, nil)
- t.Nod.Type = t
- t.Nod.Sym = t.Sym
+ if t.nod == nil || t.nod.Type != t {
+ t.nod = nod(OTYPE, nil, nil)
+ t.nod.Type = t
+ t.nod.Sym = t.Sym
}
- return t.Nod
+ return t.nod
}
// oldname returns the Node that declares symbol s in the current scope.
c := n.Name.Param.Innermost
if c == nil || c.Name.Funcdepth != funcdepth {
// Do not have a closure var for the active closure yet; make one.
- c = Nod(ONAME, nil, nil)
+ c = nod(ONAME, nil, nil)
c.Sym = s
c.Class = PAUTOHEAP
c.setIsClosureVar(true)
n = newname(n.Sym)
declare(n, dclcontext)
n.Name.Defn = defn
- defn.Ninit.Append(Nod(ODCL, n, nil))
+ defn.Ninit.Append(nod(ODCL, n, nil))
left[i] = n
}
}
func colas(left, right []*Node, lno int32) *Node {
- n := Nod(OAS, nil, nil) // assume common case
+ n := nod(OAS, nil, nil) // assume common case
n.Colas = true
n.Lineno = lno // set before calling colasdefn for correct error line
colasdefn(left, n) // modifies left, call before using left[0] in common case
func typedcl1(n *Node, t *Node, local bool) *Node {
n.Name.Param.Ntype = t
n.Local = local
- return Nod(ODCLTYPE, n, nil)
+ return nod(ODCLTYPE, n, nil)
}
// structs, functions, and methods.
} else {
n = newname(Pkglookup(name, s.Pkg))
}
- n = Nod(ODCLFIELD, n, oldname(s))
+ n = nod(ODCLFIELD, n, oldname(s))
n.Embedded = 1
return n
}
func fakethis() *Node {
- n := Nod(ODCLFIELD, nil, typenod(ptrto(typ(TSTRUCT))))
+ n := nod(ODCLFIELD, nil, typenod(ptrto(typ(TSTRUCT))))
return n
}
}
}
- n := Nod(ODCLFIELD, newname(msym), nil)
+ n := nod(ODCLFIELD, newname(msym), nil)
n.Type = t
for _, f := range mt.Methods().Slice() {
}
a := v.Name.Defn
if !v.Name.Byval {
- a = Nod(OADDR, a, nil)
+ a = nod(OADDR, a, nil)
a.Lineno = v.Lineno
e.nodeEscState(a).Escloopdepth = e.loopdepth
a = typecheck(a, Erv)
case OCLOSURE:
// OCLOSURE is lowered to OPTRLIT,
// insert OADDR to account for the additional indirection.
- a := Nod(OADDR, src, nil)
+ a := nod(OADDR, src, nil)
a.Lineno = src.Lineno
e.nodeEscState(a).Escloopdepth = e.nodeEscState(src).Escloopdepth
a.Type = ptrto(src.Type)
// Because this is for purposes of escape accounting, not execution,
// some semantically dubious node combinations are (currently) possible.
func (e *EscState) addDereference(n *Node) *Node {
- ind := Nod(OIND, n, nil)
+ ind := nod(OIND, n, nil)
e.nodeEscState(ind).Escloopdepth = e.nodeEscState(n).Escloopdepth
ind.Lineno = n.Lineno
t := n.Type
nE := e.nodeEscState(n)
nE.Escretval.Set(nil) // Suspect this is not nil for indirect calls.
for _, t := range fntype.Results().Fields().Slice() {
- src := Nod(ONAME, nil, nil)
+ src := nod(ONAME, nil, nil)
buf := fmt.Sprintf(".out%d", i)
i++
src.Sym = lookup(buf)
src = lls[0]
if n2.Isddd && !n.Isddd {
// Introduce ODDDARG node to represent ... allocation.
- src = Nod(ODDDARG, nil, nil)
+ src = nod(ODDDARG, nil, nil)
arr := typArray(n2.Type.Elem(), int64(len(lls)))
src.Type = ptrto(arr) // make pointer so it will be tracked
src.Lineno = n.Lineno
note = t.Note
if t.Isddd && !n.Isddd {
// Introduce ODDDARG node to represent ... allocation.
- src = Nod(ODDDARG, nil, nil)
+ src = nod(ODDDARG, nil, nil)
src.Lineno = n.Lineno
arr := typArray(t.Type.Elem(), int64(len(lls)-i))
src.Type = ptrto(arr) // make pointer so it will be tracked
// Preserve a copy so we can still write code referring to the original,
// and substitute that copy into the function declaration list
// so that analyses of the local (on-stack) variables use it.
- stackcopy := Nod(ONAME, nil, nil)
+ stackcopy := nod(ONAME, nil, nil)
stackcopy.Sym = n.Sym
stackcopy.Type = n.Type
stackcopy.Xoffset = n.Xoffset
// a chance to registerizer them
s := lookupN("autotmp_", statuniqgen)
statuniqgen++
- n := Nod(ONAME, nil, nil)
+ n := nod(ONAME, nil, nil)
n.Sym = s
s.Def = n
n.Type = t
funarg = t.StructType().Funarg
// Build fake variable name for whole arg struct.
- n = Nod(ONAME, nil, nil)
+ n = nod(ONAME, nil, nil)
n.Sym = lookup(".args")
n.Type = t
first := t.Field(0)
// Build fake name for individual variable.
// This is safe because if there was a real declared name
// we'd have used it above.
- n = Nod(ONAME, nil, nil)
+ n = nod(ONAME, nil, nil)
n.Type = t.Type
n.Sym = t.Sym
if t.Offset == BADWIDTH {
// (2)
Maxarg = 0
- fn := Nod(ODCLFUNC, nil, nil)
+ fn := nod(ODCLFUNC, nil, nil)
initsym := lookup("init")
fn.Func.Nname = newname(initsym)
fn.Func.Nname.Name.Defn = fn
- fn.Func.Nname.Name.Param.Ntype = Nod(OTFUNC, nil, nil)
+ fn.Func.Nname.Name.Param.Ntype = nod(OTFUNC, nil, nil)
declare(fn.Func.Nname, PFUNC)
funchdr(fn)
// (3)
- a := Nod(OIF, nil, nil)
- a.Left = Nod(OGT, gatevar, nodintconst(1))
+ a := nod(OIF, nil, nil)
+ a.Left = nod(OGT, gatevar, nodintconst(1))
a.Likely = 1
r = append(r, a)
// (3a)
- a.Nbody.Set1(Nod(ORETURN, nil, nil))
+ a.Nbody.Set1(nod(ORETURN, nil, nil))
// (4)
- b := Nod(OIF, nil, nil)
- b.Left = Nod(OEQ, gatevar, nodintconst(1))
+ b := nod(OIF, nil, nil)
+ b.Left = nod(OEQ, gatevar, nodintconst(1))
// this actually isn't likely, but code layout is better
// like this: no JMP needed after the call.
b.Likely = 1
r = append(r, b)
// (4a)
- b.Nbody.Set1(Nod(OCALL, syslook("throwinit"), nil))
+ b.Nbody.Set1(nod(OCALL, syslook("throwinit"), nil))
// (5)
- a = Nod(OAS, gatevar, nodintconst(1))
+ a = nod(OAS, gatevar, nodintconst(1))
r = append(r, a)
for _, s := range initSyms {
if s.Def != nil && s != initsym {
// could check that it is fn of no args/returns
- a = Nod(OCALL, s.Def, nil)
+ a = nod(OCALL, s.Def, nil)
r = append(r, a)
}
}
if s.Def == nil {
break
}
- a = Nod(OCALL, s.Def, nil)
+ a = nod(OCALL, s.Def, nil)
r = append(r, a)
}
// (9)
- a = Nod(OAS, gatevar, nodintconst(2))
+ a = nod(OAS, gatevar, nodintconst(2))
r = append(r, a)
// (10)
- a = Nod(ORETURN, nil, nil)
+ a = nod(ORETURN, nil, nil)
r = append(r, a)
exportsym(fn.Func.Nname)
if ln.Op == ONAME {
ln.Name.Inlvar = typecheck(inlvar(ln), Erv)
if ln.Class == PPARAM || ln.Name.Param.Stackcopy != nil && ln.Name.Param.Stackcopy.Class == PPARAM {
- ninit.Append(Nod(ODCL, ln.Name.Inlvar, nil))
+ ninit.Append(nod(ODCL, ln.Name.Inlvar, nil))
}
}
}
i++
}
- ninit.Append(Nod(ODCL, m, nil))
+ ninit.Append(nod(ODCL, m, nil))
retvars = append(retvars, m)
}
if t == nil {
Fatalf("method call unknown receiver type: %+v", n)
}
- as := Nod(OAS, tinlvar(t), n.Left.Left)
+ as := nod(OAS, tinlvar(t), n.Left.Left)
if as != nil {
as = typecheck(as, Etop)
ninit.Append(as)
}
// assign arguments to the parameters' temp names
- as := Nod(OAS2, nil, nil)
+ as := nod(OAS2, nil, nil)
as.Rlist.Set(n.List.Slice())
li := 0
// turn the variadic args into a slice.
if variadic {
- as = Nod(OAS, vararg, nil)
+ as = nod(OAS, vararg, nil)
if varargcount == 0 {
as.Right = nodnil()
as.Right.Type = varargtype
} else {
vararrtype := typArray(varargtype.Elem(), int64(varargcount))
- as.Right = Nod(OCOMPLIT, nil, typenod(vararrtype))
+ as.Right = nod(OCOMPLIT, nil, typenod(vararrtype))
as.Right.List.Set(varargs)
- as.Right = Nod(OSLICE, as.Right, nil)
+ as.Right = nod(OSLICE, as.Right, nil)
}
as = typecheck(as, Etop)
// zero the outparams
for _, n := range retvars {
- as = Nod(OAS, n, nil)
+ as = nod(OAS, n, nil)
as = typecheck(as, Etop)
ninit.Append(as)
}
body := subst.list(fn.Func.Inl)
- lab := Nod(OLABEL, retlabel, nil)
+ lab := nod(OLABEL, retlabel, nil)
lab.Used = true // avoid 'not used' when function doesn't have return
body = append(body, lab)
//dumplist("ninit post", ninit);
- call := Nod(OINLCALL, nil, nil)
+ call := nod(OINLCALL, nil, nil)
call.Ninit.Set(ninit.Slice())
call.Nbody.Set(body)
// dump("Return before substitution", n);
case ORETURN:
- m := Nod(OGOTO, subst.retlabel, nil)
+ m := nod(OGOTO, subst.retlabel, nil)
m.Ninit.Set(subst.list(n.Ninit))
if len(subst.retvars) != 0 && n.List.Len() != 0 {
- as := Nod(OAS2, nil, nil)
+ as := nod(OAS2, nil, nil)
// Make a shallow copy of retvars.
// Otherwise OINLCALL.Rlist will be the same list,
return m
case OGOTO, OLABEL:
- m := Nod(OXXX, nil, nil)
+ m := nod(OXXX, nil, nil)
*m = *n
m.Ninit.Set(nil)
p := fmt.Sprintf("%s·%d", n.Left.Sym.Name, inlgen)
return m
default:
- m := Nod(OXXX, nil, nil)
+ m := nod(OXXX, nil, nil)
*m = *n
m.Ninit.Set(nil)
// Special case for &T{...}: turn into (*T){...}.
// TODO(mdempsky): Switch back to p.nod after we
// get rid of gcCompat.
- x.Right = Nod(OIND, x.Right, nil)
+ x.Right = nod(OIND, x.Right, nil)
x.Right.Implicit = true
return x
}
l := p.bodyList(body)
if len(l) == 0 {
// TODO(mdempsky): Line number?
- return Nod(OEMPTY, nil, nil)
+ return nod(OEMPTY, nil, nil)
}
return liststmt(l)
}
}
func (p *noder) nod(orig syntax.Node, op Op, left, right *Node) *Node {
- return p.setlineno(orig, Nod(op, left, right))
+ return p.setlineno(orig, nod(op, left, right))
}
func (p *noder) setlineno(src syntax.Node, dst *Node) *Node {
func ordertemp(t *Type, order *Order, clear bool) *Node {
var_ := temp(t)
if clear {
- a := Nod(OAS, var_, nil)
+ a := nod(OAS, var_, nil)
a = typecheck(a, Etop)
order.out = append(order.out, a)
}
// to be filled in.)
func ordercopyexpr(n *Node, t *Type, order *Order, clear int) *Node {
var_ := ordertemp(t, order, clear != 0)
- a := Nod(OAS, var_, n)
+ a := nod(OAS, var_, n)
a = typecheck(a, Etop)
order.out = append(order.out, a)
return var_
if n.Name.Keepalive {
n.Name.Keepalive = false
n.Addrtaken = true // ensure SSA keeps the n variable
- kill = Nod(OVARLIVE, n, nil)
+ kill = nod(OVARLIVE, n, nil)
kill = typecheck(kill, Etop)
*out = append(*out, kill)
}
- kill = Nod(OVARKILL, n, nil)
+ kill = nod(OVARKILL, n, nil)
kill = typecheck(kill, Etop)
*out = append(*out, kill)
}
l2 = append(l2, tmp)
}
- as := Nod(OAS2, nil, nil)
+ as := nod(OAS2, nil, nil)
as.List.Set(l1)
as.Rlist.Set1(n)
as = typecheck(as, Etop)
if (n.Left.Op == OINDEXMAP || (needwritebarrier(n.Left, n.Right) && n.Left.Type.Width > int64(4*Widthptr))) && !isaddrokay(n.Right) {
m := n.Left
n.Left = ordertemp(m.Type, order, false)
- a := Nod(OAS, m, n.Left)
+ a := nod(OAS, m, n.Left)
a = typecheck(a, Etop)
order.out = append(order.out, a)
}
m.Right = ordercopyexpr(m.Right, m.Right.Type, order, 0)
}
n.List.SetIndex(i1, ordertemp(m.Type, order, false))
- a = Nod(OAS, m, n.List.Index(i1))
+ a = nod(OAS, m, n.List.Index(i1))
a = typecheck(a, Etop)
post = append(post, a)
} else if instrumenting && n.Op == OAS2FUNC && !isblank(n.List.Index(i1)) {
m = n.List.Index(i1)
t := ordertemp(m.Type, order, false)
n.List.SetIndex(i1, t)
- a = Nod(OAS, m, t)
+ a = nod(OAS, m, t)
a = typecheck(a, Etop)
post = append(post, a)
}
}
tmp1 = ordercopyexpr(tmp1, n.Left.Type, order, 0)
// TODO(marvin): Fix Node.EType type union.
- n.Right = Nod(Op(n.Etype), tmp1, n.Right)
+ n.Right = nod(Op(n.Etype), tmp1, n.Right)
n.Right = typecheck(n.Right, Erv)
n.Right = orderexpr(n.Right, order, nil)
n.Etype = 0
order.out = append(order.out, n)
if tmp1 != nil {
- r := Nod(OAS, n.List.First(), tmp1)
+ r := nod(OAS, n.List.First(), tmp1)
r = typecheck(r, Etop)
ordermapassign(r, order)
n.List.SetIndex(0, tmp1)
tmp1 := ordertemp(ch.Elem(), order, haspointers(ch.Elem()))
tmp2 := ordertemp(Types[TBOOL], order, false)
order.out = append(order.out, n)
- r := Nod(OAS, n.List.First(), tmp1)
+ r := nod(OAS, n.List.First(), tmp1)
r = typecheck(r, Etop)
ordermapassign(r, order)
r = okas(n.List.Second(), tmp2)
r := n.Right
if r.Type.IsString() && r.Type != Types[TSTRING] {
- r = Nod(OCONV, r, nil)
+ r = nod(OCONV, r, nil)
r.Type = Types[TSTRING]
r = typecheck(r, Erv)
}
tmp1 = r.Left
if r.Colas {
- tmp2 = Nod(ODCL, tmp1, nil)
+ tmp2 = nod(ODCL, tmp1, nil)
tmp2 = typecheck(tmp2, Etop)
n2.Ninit.Append(tmp2)
}
r.Left = ordertemp(r.Right.Left.Type.Elem(), order, haspointers(r.Right.Left.Type.Elem()))
- tmp2 = Nod(OAS, tmp1, r.Left)
+ tmp2 = nod(OAS, tmp1, r.Left)
tmp2 = typecheck(tmp2, Etop)
n2.Ninit.Append(tmp2)
}
if r.List.Len() != 0 {
tmp1 = r.List.First()
if r.Colas {
- tmp2 = Nod(ODCL, tmp1, nil)
+ tmp2 = nod(ODCL, tmp1, nil)
tmp2 = typecheck(tmp2, Etop)
n2.Ninit.Append(tmp2)
}
if !isblank(ok) {
val = conv(val, ok.Type)
}
- return Nod(OAS, ok, val)
+ return nod(OAS, ok, val)
}
my = lookup(ipkg.Name)
}
- pack := Nod(OPACK, nil, nil)
+ pack := nod(OPACK, nil, nil)
pack.Sym = my
pack.Name.Pkg = ipkg
pack.Lineno = line
if rangeOk && p.got(LRANGE) {
// LRANGE expr
- r := Nod(ORANGE, nil, p.expr())
+ r := nod(ORANGE, nil, p.expr())
r.Etype = 0 // := flag
return r
}
p.next()
rhs := p.expr()
- stmt := Nod(OASOP, lhs, rhs)
+ stmt := nod(OASOP, lhs, rhs)
stmt.Etype = EType(op) // rathole to pass opcode
return stmt
// expr LINCOP
p.next()
- stmt := Nod(OASOP, lhs, nodintconst(1))
+ stmt := nod(OASOP, lhs, nodintconst(1))
stmt.Implicit = true
stmt.Etype = EType(p.op)
return stmt
p.syntax_error("expecting semicolon or newline or }")
// we already progressed, no need to advance
}
- lhs := Nod(OLABEL, lhs, nil)
+ lhs := nod(OLABEL, lhs, nil)
lhs.Sym = dclstack // context, for goto restrictions
p.next() // consume ':' after making label node for correct lineno
return p.labeled_stmt(lhs)
p.next()
if rangeOk && p.got(LRANGE) {
// expr_list '=' LRANGE expr
- r := Nod(ORANGE, nil, p.expr())
+ r := nod(ORANGE, nil, p.expr())
r.List.Set(lhs)
r.Etype = 0 // := flag
return r
if len(lhs) == 1 && len(rhs) == 1 {
// simple
- return Nod(OAS, lhs[0], rhs[0])
+ return nod(OAS, lhs[0], rhs[0])
}
// multiple
- stmt := Nod(OAS2, nil, nil)
+ stmt := nod(OAS2, nil, nil)
stmt.List.Set(lhs)
stmt.Rlist.Set(rhs)
return stmt
if rangeOk && p.got(LRANGE) {
// expr_list LCOLAS LRANGE expr
- r := Nod(ORANGE, nil, p.expr())
+ r := nod(ORANGE, nil, p.expr())
r.List.Set(lhs)
r.Colas = true
colasdefn(lhs, r)
rhs := p.expr_list()
if rhs[0].Op == OTYPESW {
- ts := Nod(OTYPESW, nil, rhs[0].Right)
+ ts := nod(OTYPESW, nil, rhs[0].Right)
if len(rhs) > 1 {
yyerror("expr.(type) must be alone in list")
}
// right will point to next case
// done in casebody()
markdcl() // matching popdcl in caseblock
- stmt := Nod(OXCASE, nil, nil)
+ stmt := nod(OXCASE, nil, nil)
stmt.List.Set(cases)
if tswitch != nil {
if n := tswitch.Left; n != nil {
// right will point to next case
// done in casebody()
markdcl() // matching popdcl in caseblock
- stmt := Nod(OXCASE, nil, nil)
+ stmt := nod(OXCASE, nil, nil)
var n *Node
if len(cases) == 1 {
- n = Nod(OAS, cases[0], rhs)
+ n = nod(OAS, cases[0], rhs)
} else {
- n = Nod(OAS2, nil, nil)
+ n = nod(OAS2, nil, nil)
n.List.Set(cases)
n.Rlist.Set1(rhs)
}
// right will point to next case
// done in casebody()
markdcl() // matching popdcl in caseblock
- stmt := Nod(OXCASE, nil, nil)
+ stmt := nod(OXCASE, nil, nil)
stmt.List.Set1(colas(cases, []*Node{rhs}, lno))
p.want(':') // consume ':' after declaring select cases for correct lineno
default:
markdcl() // for matching popdcl in caseblock
- stmt := Nod(OXCASE, nil, nil) // don't return nil
+ stmt := nod(OXCASE, nil, nil) // don't return nil
p.syntax_error("expecting := or = or : or comma")
p.advance(LCASE, LDEFAULT, '}')
return stmt
p.next()
markdcl() // matching popdcl in caseblock
- stmt := Nod(OXCASE, nil, nil)
+ stmt := nod(OXCASE, nil, nil)
if tswitch != nil {
if n := tswitch.Left; n != nil {
// type switch - declare variable
default:
markdcl() // matching popdcl in caseblock
- stmt := Nod(OXCASE, nil, nil) // don't return nil
+ stmt := nod(OXCASE, nil, nil) // don't return nil
p.syntax_error("expecting case or default or }")
p.advance(LCASE, LDEFAULT, '}')
return stmt
popdcl()
if len(l) == 0 {
- return Nod(OEMPTY, nil, nil)
+ return nod(OEMPTY, nil, nil)
}
return liststmt(l)
}
if post != nil && post.Colas {
yyerror("cannot declare in the for-increment")
}
- h := Nod(OFOR, nil, nil)
+ h := nod(OFOR, nil, nil)
if init != nil {
h.Ninit.Set1(init)
}
}
// normal test
- h := Nod(OFOR, nil, nil)
+ h := nod(OFOR, nil, nil)
h.Left = cond
return h
}
}
init, cond, _ := p.header(false)
- h := Nod(OIF, nil, nil)
+ h := nod(OIF, nil, nil)
if init != nil {
h.Ninit.Set1(init)
}
}
p.want(LSELECT)
- hdr := Nod(OSELECT, nil, nil)
+ hdr := nod(OSELECT, nil, nil)
hdr.List.Set(p.caseblock_list(nil))
return hdr
}
for p.prec > prec {
op, prec1 := p.op, p.prec
p.next()
- x = Nod(op, x, p.bexpr(prec1))
+ x = nod(op, x, p.bexpr(prec1))
}
return x
}
x := unparen(p.uexpr())
if x.Op == OCOMPLIT {
// Special case for &T{...}: turn into (*T){...}.
- x.Right = Nod(OIND, x.Right, nil)
+ x.Right = nod(OIND, x.Right, nil)
x.Right.Implicit = true
} else {
- x = Nod(OADDR, x, nil)
+ x = nod(OADDR, x, nil)
}
return x
}
// x is not a channel type => we have a receive op
- return Nod(ORECV, x, nil)
+ return nod(ORECV, x, nil)
default:
return p.pexpr(false)
// simple uexpr
p.next()
- return Nod(op, p.uexpr(), nil)
+ return nod(op, p.uexpr(), nil)
}
// pseudocall parses call-like statements that can be preceded by 'defer' and 'go'.
// in a go/defer statement. In that case, operand is called
// with keep_parens set.
if keep_parens {
- x = Nod(OPAREN, x, nil)
+ x = nod(OPAREN, x, nil)
}
return x
// pexpr '.' '(' expr_or_type ')'
t := p.expr() // expr_or_type
p.want(')')
- x = Nod(ODOTTYPE, x, t)
+ x = nod(ODOTTYPE, x, t)
case LTYPE:
// pexpr '.' '(' LTYPE ')'
p.next()
p.want(')')
- x = Nod(OTYPESW, nil, x)
+ x = nod(OTYPESW, nil, x)
}
default:
if i == nil {
yyerror("missing index in index expression")
}
- x = Nod(OINDEX, x, i)
+ x = nod(OINDEX, x, i)
case 1:
- x = Nod(OSLICE, x, nil)
+ x = nod(OSLICE, x, nil)
x.SetSliceBounds(index[0], index[1], nil)
case 2:
if index[1] == nil {
if index[2] == nil {
yyerror("final index required in 3-index slice")
}
- x = Nod(OSLICE3, x, nil)
+ x = nod(OSLICE3, x, nil)
x.SetSliceBounds(index[0], index[1], index[2])
default:
args, ddd := p.arg_list()
// call or conversion
- x = Nod(OCALL, x, nil)
+ x = nod(OCALL, x, nil)
x.List.Set(args)
x.Isddd = ddd
if p.got(':') {
// key ':' value
- return Nod(OKEY, x, wrapname(p.bare_complitexpr()))
+ return nod(OKEY, x, wrapname(p.bare_complitexpr()))
}
// value
// Introduce a wrapper node to give the correct line.
switch x.Op {
case ONAME, ONONAME, OTYPE, OPACK, OLITERAL:
- x = Nod(OPAREN, x, nil)
+ x = nod(OPAREN, x, nil)
x.Implicit = true
}
return x
}
// make node early so we get the right line number
- n := Nod(OCOMPLIT, nil, nil)
+ n := nod(OCOMPLIT, nil, nil)
p.want('{')
p.xnest++
p.want(LDDD)
if typ := p.try_ntype(); typ != nil {
- return Nod(ODDD, typ, nil)
+ return nod(ODDD, typ, nil)
}
yyerror("final argument in variadic function missing type")
- return Nod(ODDD, typenod(typ(TINTER)), nil)
+ return nod(ODDD, typenod(typ(TINTER)), nil)
}
func (p *parser) ntype() *Node {
if p.tok == '(' {
result = p.param_list(false)
} else if t := p.try_ntype(); t != nil {
- result = []*Node{Nod(ODCLFIELD, nil, t)}
+ result = []*Node{nod(ODCLFIELD, nil, t)}
}
- typ := Nod(OTFUNC, recv, nil)
+ typ := nod(OTFUNC, recv, nil)
typ.List.Set(params)
typ.Rlist.Set(result)
// recvchantype
p.next()
p.want(LCHAN)
- t := Nod(OTCHAN, p.chan_elem(), nil)
+ t := nod(OTCHAN, p.chan_elem(), nil)
t.Etype = EType(Crecv)
return t
var len *Node
if p.tok != ']' {
if p.got(LDDD) {
- len = Nod(ODDD, nil, nil)
+ len = nod(ODDD, nil, nil)
} else {
len = p.expr()
}
}
p.xnest--
p.want(']')
- return Nod(OTARRAY, len, p.ntype())
+ return nod(OTARRAY, len, p.ntype())
case LCHAN:
// LCHAN non_recvchantype
if p.got(LCOMM) {
dir = EType(Csend)
}
- t := Nod(OTCHAN, p.chan_elem(), nil)
+ t := nod(OTCHAN, p.chan_elem(), nil)
t.Etype = dir
return t
key := p.ntype()
p.want(']')
val := p.ntype()
- return Nod(OTMAP, key, val)
+ return nod(OTMAP, key, val)
case LSTRUCT:
return p.structtype()
case '*':
// ptrtype
p.next()
- return Nod(OIND, p.ntype(), nil)
+ return nod(OIND, p.ntype(), nil)
case LNAME:
return p.dotname()
}
p.want('}')
- t := Nod(OTSTRUCT, nil, nil)
+ t := nod(OTSTRUCT, nil, nil)
t.List.Set(l)
return t
}
}
p.want('}')
- t := Nod(OTINTER, nil, nil)
+ t := nod(OTINTER, nil, nil)
t.List.Set(l)
return t
}
}
}
- f := Nod(ODCLFUNC, nil, nil)
+ f := nod(ODCLFUNC, nil, nil)
f.Func.Nname = newfuncname(name)
f.Func.Nname.Name.Defn = f
f.Func.Nname.Name.Param.Ntype = t // TODO: check if nname already has an ntype
return nil
}
- f := Nod(ODCLFUNC, nil, nil)
+ f := nod(ODCLFUNC, nil, nil)
f.Func.Shortname = newfuncname(name)
f.Func.Nname = methodname(f.Func.Shortname, recv.Right)
f.Func.Nname.Name.Defn = f
p.fnest--
p.want('}')
if body == nil {
- body = []*Node{Nod(OEMPTY, nil, nil)}
+ body = []*Node{nod(OEMPTY, nil, nil)}
}
return body
}
}
for i, n := range fields {
- fields[i] = Nod(ODCLFIELD, n, typ)
+ fields[i] = nod(ODCLFIELD, n, typ)
fields[i].SetVal(tag)
}
return fields
p.want(')')
tag := p.oliteral()
- field.Right = Nod(OIND, field.Right, nil)
+ field.Right = nod(OIND, field.Right, nil)
field.SetVal(tag)
yyerror("cannot parenthesize embedded type")
return []*Node{field}
p.want(')')
tag := p.oliteral()
- field.Right = Nod(OIND, field.Right, nil)
+ field.Right = nod(OIND, field.Right, nil)
field.SetVal(tag)
yyerror("cannot parenthesize embedded type")
return []*Node{field}
field := p.embed(nil)
tag := p.oliteral()
- field.Right = Nod(OIND, field.Right, nil)
+ field.Right = nod(OIND, field.Right, nil)
field.SetVal(tag)
return []*Node{field}
}
if p.tok != '(' {
// packname
pname := p.packname(sym)
- return Nod(ODCLFIELD, nil, oldname(pname))
+ return nod(ODCLFIELD, nil, oldname(pname))
}
// MethodName Signature
mname := newname(sym)
sig := p.signature(fakethis())
- meth := Nod(ODCLFIELD, mname, sig)
+ meth := nod(ODCLFIELD, mname, sig)
ifacedcl(meth)
return meth
p.next()
pname := p.packname(nil)
p.want(')')
- n := Nod(ODCLFIELD, nil, oldname(pname))
+ n := nod(ODCLFIELD, nil, oldname(pname))
yyerror("cannot parenthesize embedded type")
return n
// p.name must be a type name (or nil in case of syntax error)
typ = mkname(p.name)
}
- n := Nod(ODCLFIELD, name, typ)
+ n := nod(ODCLFIELD, name, typ)
// rewrite ...T parameter
if typ != nil && typ.Op == ODDD {
return list
}
-var missing_stmt = Nod(OXXX, nil, nil)
+var missing_stmt = nod(OXXX, nil, nil)
// Statement =
// Declaration | LabeledStmt | SimpleStmt |
case LFALL:
p.next()
// will be converted to OFALL
- stmt := Nod(OXFALL, nil, nil)
+ stmt := nod(OXFALL, nil, nil)
stmt.Xoffset = int64(block)
return stmt
case LBREAK:
p.next()
- return Nod(OBREAK, p.onew_name(), nil)
+ return nod(OBREAK, p.onew_name(), nil)
case LCONTINUE:
p.next()
- return Nod(OCONTINUE, p.onew_name(), nil)
+ return nod(OCONTINUE, p.onew_name(), nil)
case LGO:
p.next()
- return Nod(OPROC, p.pseudocall(), nil)
+ return nod(OPROC, p.pseudocall(), nil)
case LDEFER:
p.next()
- return Nod(ODEFER, p.pseudocall(), nil)
+ return nod(ODEFER, p.pseudocall(), nil)
case LGOTO:
p.next()
- stmt := Nod(OGOTO, p.new_name(p.sym()), nil)
+ stmt := nod(OGOTO, p.new_name(p.sym()), nil)
stmt.Sym = dclstack // context, for goto restrictions
return stmt
results = p.expr_list()
}
- stmt := Nod(ORETURN, nil, nil)
+ stmt := nod(ORETURN, nil, nil)
stmt.List.Set(results)
if stmt.List.Len() == 0 && Curfn != nil {
for _, ln := range Curfn.Func.Dcl {
// add clearing of the output parameters
for _, t := range Curfn.Type.Results().Fields().Slice() {
if t.Nname != nil {
- n := Nod(OAS, t.Nname, nil)
+ n := nod(OAS, t.Nname, nil)
n = typecheck(n, Etop)
Curfn.Nbody.Prepend(n)
}
case OSPTR, OLEN, OCAP:
instrumentnode(&n.Left, init, 0, 0)
if n.Left.Type.IsMap() {
- n1 := Nod(OCONVNOP, n.Left, nil)
+ n1 := nod(OCONVNOP, n.Left, nil)
n1.Type = ptrto(Types[TUINT8])
- n1 = Nod(OIND, n1, nil)
+ n1 = nod(OIND, n1, nil)
n1 = typecheck(n1, Erv)
callinstr(&n1, init, 0, skip)
}
}
func uintptraddr(n *Node) *Node {
- r := Nod(OADDR, n, nil)
+ r := nod(OADDR, n, nil)
r.Bounded = true
r = conv(r, Types[TUNSAFEPTR])
r = conv(r, Types[TUINTPTR])
}
func detachexpr(n *Node, init *Nodes) *Node {
- addr := Nod(OADDR, n, nil)
+ addr := nod(OADDR, n, nil)
l := temp(ptrto(n.Type))
- as := Nod(OAS, l, addr)
+ as := nod(OAS, l, addr)
as = typecheck(as, Etop)
as = walkexpr(as, init)
init.Append(as)
- ind := Nod(OIND, l, nil)
+ ind := nod(OIND, l, nil)
ind = typecheck(ind, Erv)
ind = walkexpr(ind, init)
return ind
// There may be multiple refs to this node;
// introduce OCONVNOP to hold init list.
case ONAME, OLITERAL:
- n = Nod(OCONVNOP, n, nil)
+ n = nod(OCONVNOP, n, nil)
n.Type = n.Left.Type
n.Typecheck = 1
hn := temp(Types[TINT])
var hp *Node
- init = append(init, Nod(OAS, hv1, nil))
- init = append(init, Nod(OAS, hn, Nod(OLEN, ha, nil)))
+ init = append(init, nod(OAS, hv1, nil))
+ init = append(init, nod(OAS, hn, nod(OLEN, ha, nil)))
if v2 != nil {
hp = temp(ptrto(n.Type.Elem()))
- tmp := Nod(OINDEX, ha, nodintconst(0))
+ tmp := nod(OINDEX, ha, nodintconst(0))
tmp.Bounded = true
- init = append(init, Nod(OAS, hp, Nod(OADDR, tmp, nil)))
+ init = append(init, nod(OAS, hp, nod(OADDR, tmp, nil)))
}
- n.Left = Nod(OLT, hv1, hn)
- n.Right = Nod(OAS, hv1, Nod(OADD, hv1, nodintconst(1)))
+ n.Left = nod(OLT, hv1, hn)
+ n.Right = nod(OAS, hv1, nod(OADD, hv1, nodintconst(1)))
if v1 == nil {
body = nil
} else if v2 == nil {
- body = []*Node{Nod(OAS, v1, hv1)}
+ body = []*Node{nod(OAS, v1, hv1)}
} else {
- a := Nod(OAS2, nil, nil)
+ a := nod(OAS2, nil, nil)
a.List.Set([]*Node{v1, v2})
- a.Rlist.Set([]*Node{hv1, Nod(OIND, hp, nil)})
+ a.Rlist.Set([]*Node{hv1, nod(OIND, hp, nil)})
body = []*Node{a}
// Advance pointer as part of increment.
// Advancing during the increment ensures that the pointer p only points
// pass the end of the array during the final "p++; i++; if(i >= len(x)) break;",
// after which p is dead, so it cannot confuse the collector.
- tmp := Nod(OADD, hp, nodintconst(t.Elem().Width))
+ tmp := nod(OADD, hp, nodintconst(t.Elem().Width))
tmp.Type = hp.Type
tmp.Typecheck = 1
tmp.Right.Type = Types[Tptr]
tmp.Right.Typecheck = 1
- a = Nod(OAS, hp, tmp)
+ a = nod(OAS, hp, tmp)
a = typecheck(a, Etop)
n.Right.Ninit.Set1(a)
}
fn := syslook("mapiterinit")
fn = substArgTypes(fn, t.Key(), t.Val(), th)
- init = append(init, mkcall1(fn, nil, nil, typename(t), ha, Nod(OADDR, hit, nil)))
- n.Left = Nod(ONE, nodSym(ODOT, hit, keysym), nodnil())
+ init = append(init, mkcall1(fn, nil, nil, typename(t), ha, nod(OADDR, hit, nil)))
+ n.Left = nod(ONE, nodSym(ODOT, hit, keysym), nodnil())
fn = syslook("mapiternext")
fn = substArgTypes(fn, th)
- n.Right = mkcall1(fn, nil, nil, Nod(OADDR, hit, nil))
+ n.Right = mkcall1(fn, nil, nil, nod(OADDR, hit, nil))
key := nodSym(ODOT, hit, keysym)
- key = Nod(OIND, key, nil)
+ key = nod(OIND, key, nil)
if v1 == nil {
body = nil
} else if v2 == nil {
- body = []*Node{Nod(OAS, v1, key)}
+ body = []*Node{nod(OAS, v1, key)}
} else {
val := nodSym(ODOT, hit, valsym)
- val = Nod(OIND, val, nil)
- a := Nod(OAS2, nil, nil)
+ val = nod(OIND, val, nil)
+ a := nod(OAS2, nil, nil)
a.List.Set([]*Node{v1, v2})
a.Rlist.Set([]*Node{key, val})
body = []*Node{a}
hv1 := temp(t.Elem())
hv1.Typecheck = 1
if haspointers(t.Elem()) {
- init = append(init, Nod(OAS, hv1, nil))
+ init = append(init, nod(OAS, hv1, nil))
}
hb := temp(Types[TBOOL])
- n.Left = Nod(ONE, hb, nodbool(false))
- a := Nod(OAS2RECV, nil, nil)
+ n.Left = nod(ONE, hb, nodbool(false))
+ a := nod(OAS2RECV, nil, nil)
a.Typecheck = 1
a.List.Set([]*Node{hv1, hb})
- a.Rlist.Set1(Nod(ORECV, ha, nil))
+ a.Rlist.Set1(nod(ORECV, ha, nil))
n.Left.Ninit.Set1(a)
if v1 == nil {
body = nil
} else {
- body = []*Node{Nod(OAS, v1, hv1)}
+ body = []*Node{nod(OAS, 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, Nod(OAS, hv1, nil))
+ body = append(body, nod(OAS, hv1, nil))
case TSTRING:
// Transform string range statements like "for v1, v2 = range a" into
hv2 := temp(runetype)
// hv1 := 0
- init = append(init, Nod(OAS, hv1, nil))
+ init = append(init, nod(OAS, hv1, nil))
// hv1 < len(ha)
- n.Left = Nod(OLT, hv1, Nod(OLEN, ha, nil))
+ n.Left = nod(OLT, hv1, nod(OLEN, ha, nil))
if v1 != nil {
// v1 = hv1
- body = append(body, Nod(OAS, v1, hv1))
+ body = append(body, nod(OAS, v1, hv1))
}
// hv2 := ha[hv1]
- nind := Nod(OINDEX, ha, hv1)
+ nind := nod(OINDEX, ha, hv1)
nind.Bounded = true
- body = append(body, Nod(OAS, hv2, conv(nind, runetype)))
+ body = append(body, nod(OAS, hv2, conv(nind, runetype)))
// if hv2 < utf8.RuneSelf
- nif := Nod(OIF, nil, nil)
- nif.Left = Nod(OLT, nind, nodintconst(utf8.RuneSelf))
+ nif := nod(OIF, nil, nil)
+ nif.Left = nod(OLT, nind, nodintconst(utf8.RuneSelf))
// hv1++
- nif.Nbody.Set1(Nod(OAS, hv1, Nod(OADD, hv1, nodintconst(1))))
+ nif.Nbody.Set1(nod(OAS, hv1, nod(OADD, hv1, nodintconst(1))))
// } else {
- eif := Nod(OAS2, nil, nil)
+ eif := nod(OAS2, nil, nil)
nif.Rlist.Set1(eif)
// hv2, hv1 = charntorune(ha, hv1)
if v2 != nil {
// v2 = hv2
- body = append(body, Nod(OAS, v2, hv2))
+ body = append(body, nod(OAS, v2, hv2))
}
}
n.Op = OIF
n.Nbody.Set(nil)
- n.Left = Nod(ONE, Nod(OLEN, a, nil), nodintconst(0))
+ n.Left = nod(ONE, nod(OLEN, a, nil), nodintconst(0))
// hp = &a[0]
hp := temp(ptrto(Types[TUINT8]))
- tmp := Nod(OINDEX, a, nodintconst(0))
+ tmp := nod(OINDEX, a, nodintconst(0))
tmp.Bounded = true
- tmp = Nod(OADDR, tmp, nil)
- tmp = Nod(OCONVNOP, tmp, nil)
+ tmp = nod(OADDR, tmp, nil)
+ tmp = nod(OCONVNOP, tmp, nil)
tmp.Type = ptrto(Types[TUINT8])
- n.Nbody.Append(Nod(OAS, hp, tmp))
+ n.Nbody.Append(nod(OAS, hp, tmp))
// hn = len(a) * sizeof(elem(a))
hn := temp(Types[TUINTPTR])
- tmp = Nod(OLEN, a, nil)
- tmp = Nod(OMUL, tmp, nodintconst(elemsize))
+ tmp = nod(OLEN, a, nil)
+ tmp = nod(OMUL, tmp, nodintconst(elemsize))
tmp = conv(tmp, Types[TUINTPTR])
- n.Nbody.Append(Nod(OAS, hn, tmp))
+ n.Nbody.Append(nod(OAS, hn, tmp))
// memclr(hp, hn)
fn := mkcall("memclr", nil, nil, hp, hn)
n.Nbody.Append(fn)
// i = len(a) - 1
- v1 = Nod(OAS, v1, Nod(OSUB, Nod(OLEN, a, nil), nodintconst(1)))
+ v1 = nod(OAS, v1, nod(OSUB, nod(OLEN, a, nil), nodintconst(1)))
n.Nbody.Append(v1)
func methodfunc(f *Type, receiver *Type) *Type {
var in []*Node
if receiver != nil {
- d := Nod(ODCLFIELD, nil, nil)
+ d := nod(ODCLFIELD, nil, nil)
d.Type = receiver
in = append(in, d)
}
var d *Node
for _, t := range f.Params().Fields().Slice() {
- d = Nod(ODCLFIELD, nil, nil)
+ d = nod(ODCLFIELD, nil, nil)
d.Type = t.Type
d.Isddd = t.Isddd
in = append(in, d)
var out []*Node
for _, t := range f.Results().Fields().Slice() {
- d = Nod(ODCLFIELD, nil, nil)
+ d = nod(ODCLFIELD, nil, nil)
d.Type = t.Type
out = append(out, d)
}
func typename(t *Type) *Node {
s := typenamesym(t)
- n := Nod(OADDR, s.Def, nil)
+ n := nod(OADDR, s.Def, nil)
n.Type = ptrto(s.Def.Type)
n.Addable = true
n.Ullman = 2
itabs = append(itabs, itabEntry{t: t, itype: itype, sym: s})
}
- n := Nod(OADDR, s.Def, nil)
+ n := nod(OADDR, s.Def, nil)
n.Type = ptrto(s.Def.Type)
n.Addable = true
n.Ullman = 2
// The latter is the type of an auto-generated wrapper.
dtypesym(ptrto(errortype))
- dtypesym(functype(nil, []*Node{Nod(ODCLFIELD, nil, typenod(errortype))}, []*Node{Nod(ODCLFIELD, nil, typenod(Types[TSTRING]))}))
+ dtypesym(functype(nil, []*Node{nod(ODCLFIELD, nil, typenod(errortype))}, []*Node{nod(ODCLFIELD, nil, typenod(Types[TSTRING]))}))
// add paths for runtime and main, which 6l imports implicitly.
dimportpath(Runtimepkg)
x.Typecheck = 1
s.Def = x
}
- z := Nod(OADDR, s.Def, nil)
+ z := nod(OADDR, s.Def, nil)
z.Type = ptrto(Types[TUINT8])
z.Addable = true
z.Typecheck = 1
// convert <-c into OSELRECV(N, <-c)
case ORECV:
- n = Nod(OSELRECV, nil, n)
+ n = nod(OSELRECV, nil, n)
n.Typecheck = 1
ncase.Left = n
}
// if ch == nil { block() }; n;
- a := Nod(OIF, nil, nil)
+ a := nod(OIF, nil, nil)
- a.Left = Nod(OEQ, ch, nodnil())
+ a.Left = nod(OEQ, ch, nodnil())
var ln Nodes
ln.Set(l)
a.Nbody.Set1(mkcall("block", nil, &ln))
}
switch n.Op {
case OSEND:
- n.Right = Nod(OADDR, n.Right, nil)
+ n.Right = nod(OADDR, n.Right, nil)
n.Right = typecheck(n.Right, Erv)
case OSELRECV, OSELRECV2:
n.Op = OSELRECV
}
if n.Op == OSELRECV2 {
- n.List.SetIndex(0, Nod(OADDR, n.List.First(), nil))
+ n.List.SetIndex(0, nod(OADDR, n.List.First(), nil))
n.List.SetIndex(0, typecheck(n.List.Index(0), Erv))
}
if n.Left == nil {
n.Left = nodnil()
} else {
- n.Left = Nod(OADDR, n.Left, nil)
+ n.Left = nod(OADDR, n.Left, nil)
n.Left = typecheck(n.Left, Erv)
}
}
n := cas.Left
setlineno(n)
- r := Nod(OIF, nil, nil)
+ r := nod(OIF, nil, nil)
r.Ninit.Set(cas.Ninit.Slice())
switch n.Op {
default:
// if c != nil && selectnbrecv(&v, c) { body } else { default body }
case OSELRECV:
- r = Nod(OIF, nil, nil)
+ r = nod(OIF, nil, nil)
r.Ninit.Set(cas.Ninit.Slice())
ch := n.Right.Left
// if c != nil && selectnbrecv2(&v, c) { body } else { default body }
case OSELRECV2:
- r = Nod(OIF, nil, nil)
+ r = nod(OIF, nil, nil)
r.Ninit.Set(cas.Ninit.Slice())
ch := n.Right.Left
setlineno(sel)
selv = temp(selecttype(int32(sel.Xoffset)))
- r = Nod(OAS, selv, nil)
+ r = nod(OAS, selv, nil)
r = typecheck(r, Etop)
init = append(init, r)
- var_ = conv(conv(Nod(OADDR, selv, nil), Types[TUNSAFEPTR]), ptrto(Types[TUINT8]))
+ var_ = conv(conv(nod(OADDR, selv, nil), Types[TUNSAFEPTR]), ptrto(Types[TUINT8]))
r = mkcall("newselect", nil, nil, var_, nodintconst(selv.Type.Width), nodintconst(sel.Xoffset))
r = typecheck(r, Etop)
init = append(init, r)
for _, cas := range sel.List.Slice() {
setlineno(cas)
n = cas.Left
- r = Nod(OIF, nil, nil)
+ r = nod(OIF, nil, nil)
r.Ninit.Set(cas.Ninit.Slice())
cas.Ninit.Set(nil)
if n != nil {
}
// selv is no longer alive after use.
- r.Nbody.Append(Nod(OVARKILL, selv, nil))
+ r.Nbody.Append(nod(OVARKILL, selv, nil))
r.Nbody.AppendNodes(&cas.Nbody)
- r.Nbody.Append(Nod(OBREAK, nil, nil))
+ r.Nbody.Append(nod(OBREAK, nil, nil))
init = append(init, r)
}
// TODO(dvyukov): it's possible to generate Scase only once
// and then cache; and also cache Select per size.
- scase := Nod(OTSTRUCT, nil, nil)
- scase.List.Append(Nod(ODCLFIELD, newname(lookup("elem")), typenod(ptrto(Types[TUINT8]))))
- scase.List.Append(Nod(ODCLFIELD, newname(lookup("chan")), typenod(ptrto(Types[TUINT8]))))
- scase.List.Append(Nod(ODCLFIELD, newname(lookup("pc")), typenod(Types[TUINTPTR])))
- scase.List.Append(Nod(ODCLFIELD, newname(lookup("kind")), typenod(Types[TUINT16])))
- scase.List.Append(Nod(ODCLFIELD, newname(lookup("so")), typenod(Types[TUINT16])))
- scase.List.Append(Nod(ODCLFIELD, newname(lookup("receivedp")), typenod(ptrto(Types[TUINT8]))))
- scase.List.Append(Nod(ODCLFIELD, newname(lookup("releasetime")), typenod(Types[TUINT64])))
+ scase := nod(OTSTRUCT, nil, nil)
+ scase.List.Append(nod(ODCLFIELD, newname(lookup("elem")), typenod(ptrto(Types[TUINT8]))))
+ scase.List.Append(nod(ODCLFIELD, newname(lookup("chan")), typenod(ptrto(Types[TUINT8]))))
+ scase.List.Append(nod(ODCLFIELD, newname(lookup("pc")), typenod(Types[TUINTPTR])))
+ scase.List.Append(nod(ODCLFIELD, newname(lookup("kind")), typenod(Types[TUINT16])))
+ scase.List.Append(nod(ODCLFIELD, newname(lookup("so")), typenod(Types[TUINT16])))
+ scase.List.Append(nod(ODCLFIELD, newname(lookup("receivedp")), typenod(ptrto(Types[TUINT8]))))
+ scase.List.Append(nod(ODCLFIELD, newname(lookup("releasetime")), typenod(Types[TUINT64])))
scase = typecheck(scase, Etype)
scase.Type.Noalg = true
scase.Type.Local = true
- sel := Nod(OTSTRUCT, nil, nil)
- sel.List.Append(Nod(ODCLFIELD, newname(lookup("tcase")), typenod(Types[TUINT16])))
- sel.List.Append(Nod(ODCLFIELD, newname(lookup("ncase")), typenod(Types[TUINT16])))
- sel.List.Append(Nod(ODCLFIELD, newname(lookup("pollorder")), typenod(ptrto(Types[TUINT8]))))
- sel.List.Append(Nod(ODCLFIELD, newname(lookup("lockorder")), typenod(ptrto(Types[TUINT8]))))
- arr := Nod(OTARRAY, nodintconst(int64(size)), scase)
- sel.List.Append(Nod(ODCLFIELD, newname(lookup("scase")), arr))
- arr = Nod(OTARRAY, nodintconst(int64(size)), typenod(Types[TUINT16]))
- sel.List.Append(Nod(ODCLFIELD, newname(lookup("lockorderarr")), arr))
- arr = Nod(OTARRAY, nodintconst(int64(size)), typenod(Types[TUINT16]))
- sel.List.Append(Nod(ODCLFIELD, newname(lookup("pollorderarr")), arr))
+ sel := nod(OTSTRUCT, nil, nil)
+ sel.List.Append(nod(ODCLFIELD, newname(lookup("tcase")), typenod(Types[TUINT16])))
+ sel.List.Append(nod(ODCLFIELD, newname(lookup("ncase")), typenod(Types[TUINT16])))
+ sel.List.Append(nod(ODCLFIELD, newname(lookup("pollorder")), typenod(ptrto(Types[TUINT8]))))
+ sel.List.Append(nod(ODCLFIELD, newname(lookup("lockorder")), typenod(ptrto(Types[TUINT8]))))
+ arr := nod(OTARRAY, nodintconst(int64(size)), scase)
+ sel.List.Append(nod(ODCLFIELD, newname(lookup("scase")), arr))
+ arr = nod(OTARRAY, nodintconst(int64(size)), typenod(Types[TUINT16]))
+ sel.List.Append(nod(ODCLFIELD, newname(lookup("lockorderarr")), arr))
+ arr = nod(OTARRAY, nodintconst(int64(size)), typenod(Types[TUINT16]))
+ sel.List.Append(nod(ODCLFIELD, newname(lookup("pollorderarr")), arr))
sel = typecheck(sel, Etype)
sel.Type.Noalg = true
sel.Type.Local = true
if staticcopy(l, r, out) {
return true
}
- *out = append(*out, Nod(OAS, l, r))
+ *out = append(*out, nod(OAS, l, r))
return true
case OLITERAL:
switch r.Left.Op {
case OARRAYLIT, OSLICELIT, OSTRUCTLIT, OMAPLIT:
// copy pointer
- gdata(l, Nod(OADDR, inittemps[r], nil), int(l.Type.Width))
+ gdata(l, nod(OADDR, inittemps[r], nil), int(l.Type.Width))
return true
}
n := *l
n.Xoffset = l.Xoffset + int64(array_array)
- gdata(&n, Nod(OADDR, a, nil), Widthptr)
+ gdata(&n, nod(OADDR, a, nil), Widthptr)
n.Xoffset = l.Xoffset + int64(array_nel)
gdata(&n, r.Right, Widthint)
n.Xoffset = l.Xoffset + int64(array_cap)
if e.Expr.Op == OLITERAL {
gdata(&n, e.Expr, int(n.Type.Width))
} else {
- ll := Nod(OXXX, nil, nil)
+ ll := nod(OXXX, nil, nil)
*ll = n
ll.Orig = ll // completely separate copy
if !staticassign(ll, e.Expr, out) {
// Requires computation, but we're
// copying someone else's computation.
- rr := Nod(OXXX, nil, nil)
+ rr := nod(OXXX, nil, nil)
*rr = *orig
rr.Orig = rr // completely separate copy
rr.Type = ll.Type
rr.Xoffset += e.Xoffset
setlineno(rr)
- *out = append(*out, Nod(OAS, ll, rr))
+ *out = append(*out, nod(OAS, ll, rr))
}
}
}
a := staticname(r.Left.Type)
inittemps[r] = a
- gdata(l, Nod(OADDR, a, nil), int(l.Type.Width))
+ gdata(l, nod(OADDR, a, nil), int(l.Type.Width))
// Init underlying literal.
if !staticassign(a, r.Left, out) {
- *out = append(*out, Nod(OAS, a, r.Left))
+ *out = append(*out, nod(OAS, a, r.Left))
}
return true
}
inittemps[r] = a
n := *l
n.Xoffset = l.Xoffset + int64(array_array)
- gdata(&n, Nod(OADDR, a, nil), Widthptr)
+ gdata(&n, nod(OADDR, a, nil), Widthptr)
n.Xoffset = l.Xoffset + int64(array_nel)
gdata(&n, r.Right, Widthint)
n.Xoffset = l.Xoffset + int64(array_cap)
gdata(&n, e.Expr, int(n.Type.Width))
} else {
setlineno(e.Expr)
- a := Nod(OXXX, nil, nil)
+ a := nod(OXXX, nil, nil)
*a = n
a.Orig = a // completely separate copy
if !staticassign(a, e.Expr, out) {
- *out = append(*out, Nod(OAS, a, e.Expr))
+ *out = append(*out, nod(OAS, a, e.Expr))
}
}
}
// Copy val directly into n.
n.Type = val.Type
setlineno(val)
- a := Nod(OXXX, nil, nil)
+ a := nod(OXXX, nil, nil)
*a = n
a.Orig = a
if !staticassign(a, val, out) {
- *out = append(*out, Nod(OAS, a, val))
+ *out = append(*out, nod(OAS, a, val))
}
} else {
// Construct temp to hold val, write pointer to temp into n.
a := staticname(val.Type)
inittemps[val] = a
if !staticassign(a, val, out) {
- *out = append(*out, Nod(OAS, a, val))
+ *out = append(*out, nod(OAS, a, val))
}
- ptr := Nod(OADDR, a, nil)
+ ptr := nod(OADDR, a, nil)
n.Type = ptrto(val.Type)
gdata(&n, ptr, Widthptr)
}
}
func litas(l *Node, r *Node, init *Nodes) {
- a := Nod(OAS, l, r)
+ a := nod(OAS, l, r)
a = typecheck(a, Etop)
a = walkexpr(a, init)
init.Append(a)
var indexnode func(*Node) *Node
switch n.Op {
case OARRAYLIT, OSLICELIT:
- indexnode = func(index *Node) *Node { return Nod(OINDEX, var_, index) }
+ indexnode = func(index *Node) *Node { return nod(OINDEX, var_, index) }
case OSTRUCTLIT:
indexnode = func(index *Node) *Node { return nodSym(ODOT, var_, index.Sym) }
default:
// build list of assignments: var[index] = expr
setlineno(value)
- a := Nod(OAS, indexnode(index), value)
+ a := nod(OAS, indexnode(index), value)
a = typecheck(a, Etop)
switch kind {
case initKindStatic:
fixedlit(ctxt, initKindDynamic, n, vstat, init)
// copy static to slice
- a := Nod(OSLICE, vstat, nil)
+ a := nod(OSLICE, vstat, nil)
- a = Nod(OAS, var_, a)
+ a = nod(OAS, var_, a)
a = typecheck(a, Etop)
a.IsStatic = true
init.Append(a)
x.Type = t
if vstat == nil {
- a = Nod(OAS, x, nil)
+ a = nod(OAS, x, nil)
a = typecheck(a, Etop)
init.Append(a) // zero new temp
}
- a = Nod(OADDR, x, nil)
+ a = nod(OADDR, x, nil)
} else if n.Esc == EscNone {
a = temp(t)
if vstat == nil {
- a = Nod(OAS, temp(t), nil)
+ a = nod(OAS, temp(t), nil)
a = typecheck(a, Etop)
init.Append(a) // zero new temp
a = a.Left
}
- a = Nod(OADDR, a, nil)
+ a = nod(OADDR, a, nil)
} else {
- a = Nod(ONEW, nil, nil)
+ a = nod(ONEW, nil, nil)
a.List.Set1(typenod(t))
}
- a = Nod(OAS, vauto, a)
+ a = nod(OAS, vauto, a)
a = typecheck(a, Etop)
a = walkexpr(a, init)
init.Append(a)
if vstat != nil {
// copy static to heap (4)
- a = Nod(OIND, vauto, nil)
+ a = nod(OIND, vauto, nil)
- a = Nod(OAS, a, vstat)
+ a = nod(OAS, a, vstat)
a = typecheck(a, Etop)
a = walkexpr(a, init)
init.Append(a)
}
index := r.Left
value := r.Right
- a := Nod(OINDEX, vauto, index)
+ a := nod(OINDEX, vauto, index)
a.Bounded = true
// TODO need to check bounds?
// build list of vauto[c] = expr
setlineno(value)
- a = Nod(OAS, a, value)
+ a = nod(OAS, a, value)
a = typecheck(a, Etop)
a = orderstmtinplace(a)
}
// make slice out of heap (6)
- a = Nod(OAS, var_, Nod(OSLICE, vauto, nil))
+ a = nod(OAS, var_, nod(OSLICE, vauto, nil))
a = typecheck(a, Etop)
a = orderstmtinplace(a)
// make the map var
nerr := nerrors
- a := Nod(OMAKE, nil, nil)
+ a := nod(OMAKE, nil, nil)
a.List.Set2(typenod(n.Type), nodintconst(int64(len(n.List.Slice()))))
litas(m, a, init)
if isliteral(index) && isliteral(value) {
// build vstatk[b] = index
setlineno(index)
- lhs := Nod(OINDEX, vstatk, nodintconst(b))
- as := Nod(OAS, lhs, index)
+ lhs := nod(OINDEX, vstatk, nodintconst(b))
+ as := nod(OAS, lhs, index)
as = typecheck(as, Etop)
as = walkexpr(as, init)
as.IsStatic = true
// build vstatv[b] = value
setlineno(value)
- lhs = Nod(OINDEX, vstatv, nodintconst(b))
- as = Nod(OAS, lhs, value)
+ lhs = nod(OINDEX, vstatv, nodintconst(b))
+ as = nod(OAS, lhs, value)
as = typecheck(as, Etop)
as = walkexpr(as, init)
as.IsStatic = true
// map[vstatk[i]] = vstatv[i]
// }
i := temp(Types[TINT])
- rhs := Nod(OINDEX, vstatv, i)
+ rhs := nod(OINDEX, vstatv, i)
rhs.Bounded = true
- kidx := Nod(OINDEX, vstatk, i)
+ kidx := nod(OINDEX, vstatk, i)
kidx.Bounded = true
- lhs := Nod(OINDEX, m, kidx)
+ lhs := nod(OINDEX, m, kidx)
- zero := Nod(OAS, i, nodintconst(0))
- cond := Nod(OLT, i, nodintconst(tk.NumElem()))
- incr := Nod(OAS, i, Nod(OADD, i, nodintconst(1)))
- body := Nod(OAS, lhs, rhs)
+ zero := nod(OAS, i, nodintconst(0))
+ cond := nod(OLT, i, nodintconst(tk.NumElem()))
+ incr := nod(OAS, i, nod(OADD, i, nodintconst(1)))
+ body := nod(OAS, lhs, rhs)
- loop := Nod(OFOR, cond, incr)
+ loop := nod(OFOR, cond, incr)
loop.Nbody.Set1(body)
loop.Ninit.Set1(zero)
}
setlineno(index)
- a = Nod(OAS, key, index)
+ a = nod(OAS, key, index)
a = typecheck(a, Etop)
a = walkstmt(a)
init.Append(a)
setlineno(value)
- a = Nod(OAS, val, value)
+ a = nod(OAS, val, value)
a = typecheck(a, Etop)
a = walkstmt(a)
init.Append(a)
setlineno(val)
- a = Nod(OAS, Nod(OINDEX, m, key), val)
+ a = nod(OAS, nod(OINDEX, m, key), val)
a = typecheck(a, Etop)
a = walkstmt(a)
init.Append(a)
}
if key != nil {
- a = Nod(OVARKILL, key, nil)
+ a = nod(OVARKILL, key, nil)
a = typecheck(a, Etop)
init.Append(a)
- a = Nod(OVARKILL, val, nil)
+ a = nod(OVARKILL, val, nil)
a = typecheck(a, Etop)
init.Append(a)
}
var r *Node
if n.Right != nil {
- r = Nod(OADDR, n.Right, nil)
+ r = nod(OADDR, n.Right, nil)
r = typecheck(r, Erv)
} else {
- r = Nod(ONEW, nil, nil)
+ r = nod(ONEW, nil, nil)
r.Typecheck = 1
r.Type = t
r.Esc = n.Esc
}
r = walkexpr(r, init)
- a := Nod(OAS, var_, r)
+ a := nod(OAS, var_, r)
a = typecheck(a, Etop)
init.Append(a)
- var_ = Nod(OIND, var_, nil)
+ var_ = nod(OIND, var_, nil)
var_ = typecheck(var_, Erv|Easgn)
anylit(n.Left, var_, init)
fixedlit(ctxt, initKindStatic, n, vstat, init)
// copy static to var
- a := Nod(OAS, var_, vstat)
+ a := nod(OAS, var_, vstat)
a = typecheck(a, Etop)
a = walkexpr(a, init)
}
// initialization of an array or struct with unspecified components (missing fields or arrays)
if var_.isSimpleName() || int64(n.List.Len()) < components {
- a := Nod(OAS, var_, nil)
+ a := nod(OAS, var_, nil)
a = typecheck(a, Etop)
a = walkexpr(a, init)
init.Append(a)
func (e *ssaExport) namedAuto(name string, typ ssa.Type) ssa.GCNode {
t := typ.(*Type)
s := &Sym{Name: name, Pkg: localpkg}
- n := Nod(ONAME, nil, nil)
+ n := nod(ONAME, nil, nil)
s.Def = n
s.Def.Used = true
n.Sym = s
}
}
-func Nod(op Op, nleft *Node, nright *Node) *Node {
+func nod(op Op, nleft *Node, nright *Node) *Node {
n := new(Node)
n.Op = op
n.Left = nleft
// 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 Op, left *Node, sym *Sym) *Node {
- n := Nod(op, left, nil)
+ n := nod(op, left, nil)
n.Sym = sym
return n
}
if n.Orig != nil {
return
}
- norig := Nod(n.Op, nil, nil)
+ norig := nod(n.Op, nil, nil)
*norig = *n
n.Orig = norig
}
}
func nodintconst(v int64) *Node {
- c := Nod(OLITERAL, nil, nil)
+ c := nod(OLITERAL, nil, nil)
c.Addable = true
c.SetVal(Val{new(Mpint)})
c.Val().U.(*Mpint).SetInt64(v)
}
func nodfltconst(v *Mpflt) *Node {
- c := Nod(OLITERAL, nil, nil)
+ c := nod(OLITERAL, nil, nil)
c.Addable = true
c.SetVal(Val{newMpflt()})
c.Val().U.(*Mpflt).Set(v)
// if the next step is non-bool (like interface{}).
if n.Type == idealbool && !t.IsBoolean() {
if n.Op == ONAME || n.Op == OLITERAL {
- r := Nod(OCONVNOP, n, nil)
+ r := nod(OCONVNOP, n, nil)
r.Type = Types[TBOOL]
r.Typecheck = 1
r.Implicit = true
op = OCONV
}
- r := Nod(op, n, nil)
+ r := nod(op, n, nil)
r.Type = t
r.Typecheck = 1
r.Implicit = true
Fatalf("SetSliceBounds %v given three bounds", n.Op)
}
if n.Right == nil {
- n.Right = Nod(OKEY, low, high)
+ n.Right = nod(OKEY, low, high)
return
}
n.Right.Left = low
return
case OSLICE3, OSLICE3ARR:
if n.Right == nil {
- n.Right = Nod(OKEY, low, Nod(OKEY, high, max))
+ n.Right = nod(OKEY, low, nod(OKEY, high, max))
}
n.Right.Left = low
n.Right.Right.Left = high
if l == n.Left {
return n
}
- r := Nod(OXXX, nil, nil)
+ r := nod(OXXX, nil, nil)
*r = *n
r.Left = l
r = typecheck(r, Erv)
if l == n.Left {
return n
}
- a := Nod(OXXX, nil, nil)
+ a := nod(OXXX, nil, nil)
*a = *n
a.Left = l
a = walkexpr(a, init)
if l == n.Left && r == n.Right {
return n
}
- a := Nod(OXXX, nil, nil)
+ a := nod(OXXX, nil, nil)
*a = *n
a.Left = l
a.Right = r
func copyexpr(n *Node, t *Type, init *Nodes) *Node {
l := temp(t)
- a := Nod(OAS, l, n)
+ a := nod(OAS, l, n)
a = typecheck(a, Etop)
a = walkexpr(a, init)
init.Append(a)
} else if t.Sym != nil {
n = newname(t.Sym)
}
- a := Nod(ODCLFIELD, n, typenod(t.Type))
+ a := nod(ODCLFIELD, n, typenod(t.Type))
a.Isddd = t.Isddd
if n != nil {
n.Isddd = t.Isddd
dclcontext = PEXTERN
markdcl()
- this := Nod(ODCLFIELD, newname(lookup(".this")), typenod(rcvr))
+ this := nod(ODCLFIELD, newname(lookup(".this")), typenod(rcvr))
this.Left.Name.Param.Ntype = this.Right
in := structargs(method.Type.Params(), true)
out := structargs(method.Type.Results(), false)
- t := Nod(OTFUNC, nil, nil)
+ t := nod(OTFUNC, nil, nil)
l := []*Node{this}
if iface != 0 && rcvr.Width < Types[Tptr].Width {
// Building method for interface table and receiver
// Add a dummy padding argument after the
// receiver to make up the difference.
tpad := typArray(Types[TUINT8], Types[Tptr].Width-rcvr.Width)
- pad := Nod(ODCLFIELD, newname(lookup(".pad")), typenod(tpad))
+ pad := nod(ODCLFIELD, newname(lookup(".pad")), typenod(tpad))
l = append(l, pad)
}
t.List.Set(append(l, in...))
t.Rlist.Set(out)
- fn := Nod(ODCLFUNC, nil, nil)
+ fn := nod(ODCLFUNC, nil, nil)
fn.Func.Nname = newname(newnam)
fn.Func.Nname.Name.Defn = fn
fn.Func.Nname.Name.Param.Ntype = t
// generate nil pointer check for better error
if rcvr.IsPtr() && rcvr.Elem() == methodrcvr {
// generating wrapper from *T to T.
- n := Nod(OIF, nil, nil)
+ n := nod(OIF, nil, nil)
- n.Left = Nod(OEQ, this.Left, nodnil())
+ n.Left = nod(OEQ, this.Left, nodnil())
// these strings are already in the reflect tables,
// so no space cost to use them here.
l = append(l, nodlit(v))
v.U = method.Sym.Name
l = append(l, nodlit(v)) // method name
- call := Nod(OCALL, syslook("panicwrap"), nil)
+ call := nod(OCALL, syslook("panicwrap"), nil)
call.List.Set(l)
n.Nbody.Set1(call)
fn.Nbody.Append(n)
dot = dot.Left // skip final .M
// TODO(mdempsky): Remove dependency on dotlist.
if !dotlist[0].field.Type.IsPtr() {
- dot = Nod(OADDR, dot, nil)
+ dot = nod(OADDR, dot, nil)
}
- as := Nod(OAS, this.Left, Nod(OCONVNOP, dot, nil))
+ as := nod(OAS, this.Left, nod(OCONVNOP, dot, nil))
as.Right.Type = rcvr
fn.Nbody.Append(as)
- n := Nod(ORETJMP, nil, nil)
+ n := nod(ORETJMP, nil, nil)
n.Left = newname(methodsym(method.Sym, methodrcvr, 0))
fn.Nbody.Append(n)
} else {
fn.Func.Wrapper = true // ignore frame for panic+recover matching
- call := Nod(OCALL, dot, nil)
+ call := nod(OCALL, dot, nil)
call.List.Set(args)
call.Isddd = isddd
if method.Type.Results().NumFields() > 0 {
- n := Nod(ORETURN, nil, nil)
+ n := nod(ORETURN, nil, nil)
n.List.Set1(call)
call = n
}
n := newname(sym)
n.Class = PFUNC
- tfn := Nod(OTFUNC, nil, nil)
- tfn.List.Append(Nod(ODCLFIELD, nil, typenod(ptrto(t))))
- tfn.List.Append(Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
- tfn.List.Append(Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
- tfn.Rlist.Append(Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
+ tfn := nod(OTFUNC, nil, nil)
+ tfn.List.Append(nod(ODCLFIELD, nil, typenod(ptrto(t))))
+ tfn.List.Append(nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
+ tfn.List.Append(nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
+ tfn.Rlist.Append(nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
tfn = typecheck(tfn, Etype)
n.Type = tfn.Type
return n
}
func liststmt(l []*Node) *Node {
- n := Nod(OBLOCK, nil, nil)
+ n := nod(OBLOCK, nil, nil)
n.List.Set(l)
if len(l) != 0 {
n.Lineno = l[0].Lineno
// There may be multiple refs to this node;
// introduce OCONVNOP to hold init list.
case ONAME, OLITERAL:
- n = Nod(OCONVNOP, n, nil)
+ n = nod(OCONVNOP, n, nil)
n.Type = n.Left.Type
n.Typecheck = 1
}
func checknil(x *Node, init *Nodes) {
x = walkexpr(x, nil) // caller has not done this yet
if x.Type.IsInterface() {
- x = Nod(OITAB, x, nil)
+ x = nod(OITAB, x, nil)
x = typecheck(x, Erv)
}
- n := Nod(OCHECKNIL, x, nil)
+ n := nod(OCHECKNIL, x, nil)
n.Typecheck = 1
init.Append(n)
}
ptr.Type = ptrto(t)
ptr.Bounded = true
ptr.Typecheck = 1
- ind := Nod(OIND, ptr, nil)
+ ind := nod(OIND, ptr, nil)
ind.Type = t
ind.Typecheck = 1
return ind
s.exprname = cond
} else {
s.exprname = temp(cond.Type)
- cas = []*Node{Nod(OAS, s.exprname, cond)}
+ cas = []*Node{nod(OAS, s.exprname, cond)}
typecheckslice(cas, Etop)
}
n := c.node
lno := setlineno(n)
- a := Nod(OIF, nil, nil)
+ a := nod(OIF, nil, nil)
if rng := n.List.Slice(); rng != nil {
// Integer range.
// exprname is a temp or a constant,
// so it is safe to evaluate twice.
// In most cases, this conjunction will be
// rewritten by walkinrange into a single comparison.
- low := Nod(OGE, s.exprname, rng[0])
- high := Nod(OLE, s.exprname, rng[1])
- a.Left = Nod(OANDAND, low, high)
+ low := nod(OGE, s.exprname, rng[0])
+ high := nod(OLE, s.exprname, rng[1])
+ a.Left = nod(OANDAND, low, high)
a.Left = typecheck(a.Left, Erv)
a.Left = walkexpr(a.Left, nil) // give walk the opportunity to optimize the range check
} else if (s.kind != switchKindTrue && s.kind != switchKindFalse) || assignop(n.Left.Type, s.exprname.Type, nil) == OCONVIFACE || assignop(s.exprname.Type, n.Left.Type, nil) == OCONVIFACE {
- a.Left = Nod(OEQ, s.exprname, n.Left) // if name == val
+ a.Left = nod(OEQ, s.exprname, n.Left) // if name == val
a.Left = typecheck(a.Left, Erv)
} else if s.kind == switchKindTrue {
a.Left = n.Left // if val
} else {
// s.kind == switchKindFalse
- a.Left = Nod(ONOT, n.Left, nil) // if !val
+ a.Left = nod(ONOT, n.Left, nil) // if !val
a.Left = typecheck(a.Left, Erv)
}
a.Nbody.Set1(n.Right) // goto l
// find the middle and recur
half := len(cc) / 2
- a := Nod(OIF, nil, nil)
+ a := nod(OIF, nil, nil)
n := cc[half-1].node
var mid *Node
if rng := n.List.Slice(); rng != nil {
} else {
mid = n.Left
}
- le := Nod(OLE, s.exprname, mid)
+ le := nod(OLE, s.exprname, mid)
if Isconst(mid, CTSTR) {
// Search by length and then by value; see caseClauseByConstVal.
- lenlt := Nod(OLT, Nod(OLEN, s.exprname, nil), Nod(OLEN, mid, nil))
- leneq := Nod(OEQ, Nod(OLEN, s.exprname, nil), Nod(OLEN, mid, nil))
- a.Left = Nod(OOROR, lenlt, Nod(OANDAND, leneq, le))
+ lenlt := nod(OLT, nod(OLEN, s.exprname, nil), nod(OLEN, mid, nil))
+ leneq := nod(OEQ, nod(OLEN, s.exprname, nil), nod(OLEN, mid, nil))
+ a.Left = nod(OOROR, lenlt, nod(OANDAND, leneq, le))
} else {
a.Left = le
}
var cas []*Node // cases
var stat []*Node // statements
var def *Node // defaults
- br := Nod(OBREAK, nil, nil)
+ br := nod(OBREAK, nil, nil)
for i, n := range sw.List.Slice() {
setlineno(n)
n.Op = OCASE
needvar := n.List.Len() != 1 || n.List.First().Op == OLITERAL
- jmp := Nod(OGOTO, autolabel(".s"), nil)
+ jmp := nod(OGOTO, autolabel(".s"), nil)
switch n.List.Len() {
case 0:
// default
if typeswvar != nil || sw.Left.Type.IsInterface() || !n.List.First().Type.IsInteger() || n.List.Len() < integerRangeMin {
// Can't use integer ranges. Expand each case into a separate node.
for _, n1 := range n.List.Slice() {
- cas = append(cas, Nod(OCASE, n1, jmp))
+ cas = append(cas, nod(OCASE, n1, jmp))
}
break
}
}
if end-beg >= integerRangeMin {
// Record range in List.
- c := Nod(OCASE, nil, jmp)
+ c := nod(OCASE, nil, jmp)
c.List.Set2(search[beg], search[end-1])
cas = append(cas, c)
} else {
// Not large enough for range; record separately.
for _, n := range search[beg:end] {
- cas = append(cas, Nod(OCASE, n, jmp))
+ cas = append(cas, nod(OCASE, n, jmp))
}
}
beg = end
// Advance to next constant, adding individual non-constant
// or as-yet-unhandled constant cases as we go.
for ; j < len(s) && (j < run || !Isconst(s[j], CTINT)); j++ {
- cas = append(cas, Nod(OCASE, s[j], jmp))
+ cas = append(cas, nod(OCASE, s[j], jmp))
}
}
}
- stat = append(stat, Nod(OLABEL, jmp.Left, nil))
+ stat = append(stat, nod(OLABEL, jmp.Left, nil))
if typeswvar != nil && needvar && n.Rlist.Len() != 0 {
l := []*Node{
- Nod(ODCL, n.Rlist.First(), nil),
- Nod(OAS, n.Rlist.First(), typeswvar),
+ nod(ODCL, n.Rlist.First(), nil),
+ nod(OAS, n.Rlist.First(), typeswvar),
}
typecheckslice(l, Etop)
stat = append(stat, l...)
}
if cc.defjmp == nil {
- cc.defjmp = Nod(OBREAK, nil, nil)
+ cc.defjmp = nod(OBREAK, nil, nil)
}
// diagnose duplicate cases
}
if cc.defjmp == nil {
- cc.defjmp = Nod(OBREAK, nil, nil)
+ cc.defjmp = nod(OBREAK, nil, nil)
}
// diagnose duplicate cases
// predeclare temporary variables and the boolean var
s.facename = temp(cond.Right.Type)
- a := Nod(OAS, s.facename, cond.Right)
+ a := nod(OAS, s.facename, cond.Right)
a = typecheck(a, Etop)
cas = append(cas, a)
// Use a similar strategy for non-empty interfaces.
// Get interface descriptor word.
- typ := Nod(OITAB, s.facename, nil)
+ typ := nod(OITAB, s.facename, nil)
// Check for nil first.
- i := Nod(OIF, nil, nil)
- i.Left = Nod(OEQ, typ, nodnil())
+ i := nod(OIF, nil, nil)
+ i.Left = nod(OEQ, typ, nodnil())
if clauses.niljmp != nil {
// Do explicit nil case right here.
i.Nbody.Set1(clauses.niljmp)
} else {
// Jump to default case.
lbl := autolabel(".s")
- i.Nbody.Set1(Nod(OGOTO, lbl, nil))
+ i.Nbody.Set1(nod(OGOTO, lbl, nil))
// Wrap default case with label.
- blk := Nod(OBLOCK, nil, nil)
- blk.List.Set([]*Node{Nod(OLABEL, lbl, nil), def})
+ blk := nod(OBLOCK, nil, nil)
+ blk.List.Set([]*Node{nod(OLABEL, lbl, nil), def})
def = blk
}
i.Left = typecheck(i.Left, Erv)
h.Typecheck = 1
h.Xoffset = int64(2 * Widthptr) // offset of hash in runtime._type
h.Bounded = true // guaranteed not to fault
- a = Nod(OAS, s.hashname, h)
+ a = nod(OAS, s.hashname, h)
a = typecheck(a, Etop)
cas = append(cas, a)
nblank = typecheck(nblank, Erv|Easgn)
} else {
name = t.Rlist.First()
- init = []*Node{Nod(ODCL, name, nil)}
- a := Nod(OAS, name, nil)
+ init = []*Node{nod(ODCL, name, nil)}
+ a := nod(OAS, name, nil)
a = typecheck(a, Etop)
init = append(init, a)
}
- a := Nod(OAS2, nil, nil)
+ a := nod(OAS2, nil, nil)
a.List.Set([]*Node{name, s.okname}) // name, ok =
- b := Nod(ODOTTYPE, s.facename, nil)
+ b := nod(ODOTTYPE, s.facename, nil)
b.Type = t.Left.Type // interface.(type)
a.Rlist.Set1(b)
a = typecheck(a, Etop)
init = append(init, a)
- c := Nod(OIF, nil, nil)
+ c := nod(OIF, nil, nil)
c.Left = s.okname
c.Nbody.Set1(t.Right) // if ok { goto l }
if !c.isconst {
Fatalf("typeSwitch walkCases")
}
- a := Nod(OIF, nil, nil)
- a.Left = Nod(OEQ, s.hashname, nodintconst(int64(c.hash)))
+ a := nod(OIF, nil, nil)
+ a.Left = nod(OEQ, s.hashname, nodintconst(int64(c.hash)))
a.Left = typecheck(a.Left, Erv)
a.Nbody.Set1(n.Right)
cas = append(cas, a)
// find the middle and recur
half := len(cc) / 2
- a := Nod(OIF, nil, nil)
- a.Left = Nod(OLE, s.hashname, nodintconst(int64(cc[half-1].hash)))
+ a := nod(OIF, nil, nil)
+ a.Left = nod(OLE, s.hashname, nodintconst(int64(cc[half-1].hash)))
a.Left = typecheck(a.Left, Erv)
a.Nbody.Set1(s.walkCases(cc[:half]))
a.Rlist.Set1(s.walkCases(cc[half:]))
{nodlit(Val{"abc"}), nodlit(Val{"xyz"})},
}
for i, test := range tests {
- a := caseClause{node: Nod(OXXX, test.a, nil)}
- b := caseClause{node: Nod(OXXX, test.b, nil)}
+ a := caseClause{node: nod(OXXX, test.a, nil)}
+ b := caseClause{node: nod(OXXX, test.b, nil)}
s := caseClauseByConstVal{a, b}
if less := s.Less(0, 1); !less {
t.Errorf("%d: caseClauseByConstVal(%v, %v) = false", i, test.a, test.b)
methods Fields
allMethods Fields
- Nod *Node // canonical OTYPE node
+ nod *Node // canonical OTYPE node
Orig *Type // original type (type literal or predefined type)
Sym *Sym // symbol containing name, for named types
dowidth(l.Type)
if r.Type.IsInterface() == l.Type.IsInterface() || l.Type.Width >= 1<<16 {
- l = Nod(aop, l, nil)
+ l = nod(aop, l, nil)
l.Type = r.Type
l.Typecheck = 1
n.Left = l
dowidth(r.Type)
if r.Type.IsInterface() == l.Type.IsInterface() || r.Type.Width >= 1<<16 {
- r = Nod(aop, r, nil)
+ r = nod(aop, r, nil)
r.Type = l.Type
r.Typecheck = 1
n.Right = r
return n
}
- n.Left = Nod(OADDR, n.Left, nil)
+ n.Left = nod(OADDR, n.Left, nil)
n.Left.Implicit = true
n.Left = typecheck(n.Left, Erv)
l = n.Left
switch n.Op {
case OCONVNOP:
if n.Left.Op == OLITERAL {
- r := Nod(OXXX, nil, nil)
+ r := nod(OXXX, nil, nil)
n.Op = OCONV
n.Orig = r
*r = *n
if !t.IsArray() {
return n
}
- n = Nod(OIND, n, nil)
+ n = nod(OIND, n, nil)
n.Implicit = true
n = typecheck(n, Erv)
return n
}
if t.IsInterface() {
if n.Left.Type.IsPtr() {
- n.Left = Nod(OIND, n.Left, nil) // implicitstar
+ n.Left = nod(OIND, n.Left, nil) // implicitstar
n.Left.Implicit = true
n.Left = typecheck(n.Left, Erv)
}
if !eqtype(rcvr, tt) {
if rcvr.Etype == Tptr && eqtype(rcvr.Elem(), tt) {
checklvalue(n.Left, "call pointer method on")
- n.Left = Nod(OADDR, n.Left, nil)
+ n.Left = nod(OADDR, n.Left, nil)
n.Left.Implicit = true
n.Left = typecheck(n.Left, Etype|Erv)
} else if tt.Etype == Tptr && rcvr.Etype != Tptr && eqtype(tt.Elem(), rcvr) {
- n.Left = Nod(OIND, n.Left, nil)
+ n.Left = nod(OIND, n.Left, nil)
n.Left.Implicit = true
n.Left = typecheck(n.Left, Etype|Erv)
} else if tt.Etype == Tptr && tt.Elem().Etype == Tptr && eqtype(derefall(tt), derefall(rcvr)) {
if rcvr.Etype == Tptr && tt.Elem().Etype != Tptr {
break
}
- n.Left = Nod(OIND, n.Left, nil)
+ n.Left = nod(OIND, n.Left, nil)
n.Left.Implicit = true
n.Left = typecheck(n.Left, Etype|Erv)
tt = tt.Elem()
}
// Save original node (including n->right)
- norig := Nod(n.Op, nil, nil)
+ norig := nod(n.Op, nil, nil)
*norig = *n
l := n2
setlineno(l)
if l.Op != OKEY {
- l = Nod(OKEY, nodintconst(int64(i)), l)
+ l = nod(OKEY, nodintconst(int64(i)), l)
l.Left.Type = Types[TINT]
l.Left.Typecheck = 1
n.List.SetIndex(i2, l)
}
// No pushtype allowed here. Must name fields for that.
n1 = assignconv(n1, f.Type, "field value")
- n1 = Nod(OKEY, newname(f.Sym), n1)
+ n1 = nod(OKEY, newname(f.Sym), n1)
n1.Left.Type = structkey
n1.Left.Xoffset = f.Offset
n1.Left.Typecheck = 1
n.Orig = norig
if n.Type.IsPtr() {
- n = Nod(OPTRLIT, n, nil)
+ n = nod(OPTRLIT, n, nil)
n.Typecheck = 1
n.Type = n.Left.Type
n.Left.Type = t
if n.Type.Elem().Etype == TUINT8 {
// []byte
for i := 0; i < len(s); i++ {
- l = append(l, Nod(OKEY, nodintconst(int64(i)), nodintconst(int64(s[0]))))
+ l = append(l, nod(OKEY, nodintconst(int64(i)), nodintconst(int64(s[0]))))
}
} else {
// []rune
i := 0
for _, r := range s {
- l = append(l, Nod(OKEY, nodintconst(int64(i)), nodintconst(int64(r))))
+ l = append(l, nod(OKEY, nodintconst(int64(i)), nodintconst(int64(r))))
i++
}
}
- nn := Nod(OCOMPLIT, nil, typenod(n.Type))
+ nn := nod(OCOMPLIT, nil, typenod(n.Type))
nn.List.Set(l)
nn = typecheck(nn, Erv)
return nn
// type check failed; leave empty func
// TODO(mdempsky): Fix Type rekinding.
n.Type.Etype = TFUNC
- n.Type.Nod = nil
+ n.Type.nod = nil
return
}
// TODO(mdempsky): Fix Type rekinding.
*n.Type = *nt.Type
- n.Type.Nod = nil
+ n.Type.nod = nil
checkwidth(n.Type)
}
}
t.methods = Fields{}
t.allMethods = Fields{}
- t.Nod = nil
+ t.nod = nil
t.Deferwidth = false
// Update nodes waiting on this type.
for _, s := range builtinFuncs {
// TODO(marvin): Fix Node.EType type union.
s2 := Pkglookup(s.name, builtinpkg)
- s2.Def = Nod(ONAME, nil, nil)
+ s2.Def = nod(ONAME, nil, nil)
s2.Def.Sym = s2
s2.Def.Etype = EType(s.op)
}
s = lookup("_")
s.Block = -100
- s.Def = Nod(ONAME, nil, nil)
+ s.Def = nod(ONAME, nil, nil)
s.Def.Sym = s
Types[TBLANK] = typ(TBLANK)
s.Def.Type = Types[TBLANK]
s = Pkglookup("_", builtinpkg)
s.Block = -100
- s.Def = Nod(ONAME, nil, nil)
+ s.Def = nod(ONAME, nil, nil)
s.Def.Sym = s
Types[TBLANK] = typ(TBLANK)
s.Def.Type = Types[TBLANK]
s.Def.Name = new(Name)
s = Pkglookup("iota", builtinpkg)
- s.Def = Nod(OIOTA, nil, nil)
+ s.Def = nod(OIOTA, nil, nil)
s.Def.Sym = s
s.Def.Name = new(Name)
}
s1.Block = s.Block
}
- nodfp = Nod(ONAME, nil, nil)
+ nodfp = nod(ONAME, nil, nil)
nodfp.Type = Types[TINT32]
nodfp.Xoffset = 0
nodfp.Class = PPARAM
var val Val
val.U = new(Mpint)
val.U.(*Mpint).SetInt64(v)
- n := Nod(OLITERAL, nil, nil)
+ n := nod(OLITERAL, nil, nil)
n.Orig = nn
n.SetVal(val)
n.Type = Types[TUINTPTR]
if prealloc[v] == nil {
prealloc[v] = callnew(v.Type)
}
- nn := Nod(OAS, v.Name.Heapaddr, prealloc[v])
+ nn := nod(OAS, v.Name.Heapaddr, prealloc[v])
nn.Colas = true
nn = typecheck(nn, Etop)
return walkstmt(nn)
}
if cl == PPARAMOUT {
if ln.isParamStackCopy() {
- ln = walkexpr(typecheck(Nod(OIND, ln.Name.Heapaddr, nil), Erv), nil)
+ ln = walkexpr(typecheck(nod(OIND, ln.Name.Heapaddr, nil), Erv), nil)
}
rl = append(rl, ln)
}
}
if n.Op == ONAME && n.Class == PAUTOHEAP {
- nn := Nod(OIND, n.Name.Heapaddr, nil)
+ nn := nod(OIND, n.Name.Heapaddr, nil)
nn = typecheck(nn, Erv)
nn = walkexpr(nn, init)
nn.Left.NonNil = true
n = mkcall("gopanic", nil, init, n.Left)
case ORECOVER:
- n = mkcall("gorecover", n.Type, init, Nod(OADDR, nodfp, nil))
+ n = mkcall("gorecover", n.Type, init, nod(OADDR, nodfp, nil))
case OLITERAL:
n.Addable = true
// orderstmt made sure x is addressable.
n.Right.Left = walkexpr(n.Right.Left, init)
- n1 := Nod(OADDR, n.Left, nil)
+ n1 := nod(OADDR, n.Left, nil)
r := n.Right // i.(T)
if Debug_typeassert > 0 {
// orderstmt made sure x is addressable.
n.Right.Left = walkexpr(n.Right.Left, init)
- n1 := Nod(OADDR, n.Left, nil)
+ n1 := nod(OADDR, n.Left, nil)
r := n.Right.Left // the channel
n = mkcall1(chanfn("chanrecv1", 2, r.Type), nil, init, typename(r.Type), r, n1)
n = walkexpr(n, init)
if isblank(n.List.First()) {
n1 = nodnil()
} else {
- n1 = Nod(OADDR, n.List.First(), nil)
+ n1 = nod(OADDR, n.List.First(), nil)
}
n1.Etype = 1 // addr does not escape
fn := chanfn("chanrecv2", 2, r.Left.Type)
ok := n.List.Second()
call := mkcall1(fn, ok.Type, init, typename(r.Left.Type), r.Left, n1)
- n = Nod(OAS, ok, call)
+ n = nod(OAS, ok, call)
n = typecheck(n, Etop)
// a,b = m[i];
} else {
// standard version takes key by reference
// orderexpr made sure key is addressable.
- key = Nod(OADDR, r.Right, nil)
+ key = nod(OADDR, r.Right, nil)
p = "mapaccess2"
}
n.List.SetIndex(0, var_)
n = walkexpr(n, init)
init.Append(n)
- n = Nod(OAS, a, Nod(OIND, var_, nil))
+ n = nod(OAS, a, nod(OIND, var_, nil))
}
n = typecheck(n, Etop)
key = walkexpr(key, init)
// orderstmt made sure key is addressable.
- key = Nod(OADDR, key, nil)
+ key = nod(OADDR, key, nil)
t := map_.Type
n = mkcall1(mapfndel("mapdelete", t), nil, init, typename(t), map_, key)
var fast *Node
switch toKind {
case 'T':
- tab := Nod(OITAB, from, nil)
+ tab := nod(OITAB, from, nil)
if fromKind == 'E' {
- typ := Nod(OCONVNOP, typename(t), nil)
+ typ := nod(OCONVNOP, typename(t), nil)
typ.Type = ptrto(Types[TUINTPTR])
- fast = Nod(OEQ, tab, typ)
+ fast = nod(OEQ, tab, typ)
break
}
- fast = Nod(OANDAND,
- Nod(ONE, nodnil(), tab),
- Nod(OEQ, itabType(tab), typename(t)),
+ fast = nod(OANDAND,
+ nod(ONE, nodnil(), tab),
+ nod(OEQ, itabType(tab), typename(t)),
)
case 'E':
- tab := Nod(OITAB, from, nil)
- fast = Nod(ONE, nodnil(), tab)
+ tab := nod(OITAB, from, nil)
+ fast = nod(ONE, nodnil(), tab)
}
if fast != nil {
if isblank(res) {
if Debug_typeassert > 0 {
Warn("type assertion (ok only) inlined")
}
- n = Nod(OAS, ok, fast)
+ n = nod(OAS, ok, fast)
n = typecheck(n, Etop)
} else {
if Debug_typeassert > 0 {
Warn("type assertion (scalar result) inlined")
}
- n = Nod(OIF, ok, nil)
+ n = nod(OIF, ok, nil)
n.Likely = 1
if isblank(ok) {
n.Left = fast
} else {
- n.Ninit.Set1(Nod(OAS, ok, fast))
+ n.Ninit.Set1(nod(OAS, ok, fast))
}
- n.Nbody.Set1(Nod(OAS, res, ifaceData(from, res.Type)))
- n.Rlist.Set1(Nod(OAS, res, nil))
+ n.Nbody.Set1(nod(OAS, res, ifaceData(from, res.Type)))
+ n.Rlist.Set1(nod(OAS, res, nil))
n = typecheck(n, Etop)
}
break
if isblank(res) {
resptr = nodnil()
} else {
- resptr = Nod(OADDR, res, nil)
+ resptr = nod(OADDR, res, nil)
}
resptr.Etype = 1 // addr does not escape
fn := syslook(assertFuncName(from.Type, t, true))
fn = substArgTypes(fn, from.Type, t)
call := mkcall1(fn, oktype, init, typename(t), from, resptr)
- n = Nod(OAS, ok, call)
+ n = nod(OAS, ok, call)
n = typecheck(n, Etop)
case ODOTTYPE, ODOTTYPE2:
} else {
t = itabname(n.Left.Type, n.Type)
}
- l := Nod(OEFACE, t, n.Left)
+ l := nod(OEFACE, t, n.Left)
l.Type = n.Type
l.Typecheck = n.Typecheck
n = l
// with non-interface cases, is not visible to orderstmt, so we
// have to fall back on allocating a temp here.
if islvalue(n.Left) {
- ll = append(ll, Nod(OADDR, n.Left, nil))
+ ll = append(ll, nod(OADDR, n.Left, nil))
} else {
- ll = append(ll, Nod(OADDR, copyexpr(n.Left, n.Left.Type, init), nil))
+ ll = append(ll, nod(OADDR, copyexpr(n.Left, n.Left.Type, init), nil))
}
dowidth(n.Left.Type)
r := nodnil()
if n.Esc == EscNone && n.Left.Type.Width <= 1024 {
// Allocate stack buffer for value stored in interface.
r = temp(n.Left.Type)
- r = Nod(OAS, r, nil) // zero temp
+ r = nod(OAS, r, nil) // zero temp
r = typecheck(r, Etop)
init.Append(r)
- r = Nod(OADDR, r.Left, nil)
+ r = nod(OADDR, r.Left, nil)
r = typecheck(r, Erv)
}
ll = append(ll, r)
fn = substArgTypes(fn, n.Left.Type, n.Type)
}
dowidth(fn.Type)
- n = Nod(OCALL, fn, nil)
+ n = nod(OCALL, fn, nil)
n.List.Set(ll)
n = typecheck(n, Erv)
n = walkexpr(n, init)
case OANDNOT:
n.Left = walkexpr(n.Left, init)
n.Op = OAND
- n.Right = Nod(OCOM, n.Right, nil)
+ n.Right = nod(OCOM, n.Right, nil)
n.Right = typecheck(n.Right, Erv)
n.Right = walkexpr(n.Right, init)
} else {
// standard version takes key by reference.
// orderexpr made sure key is addressable.
- key = Nod(OADDR, n.Right, nil)
+ key = nod(OADDR, n.Right, nil)
p = "mapaccess1"
}
n = mkcall1(mapfn(p, t), ptrto(t.Val()), init, typename(t), n.Left, key, z)
}
n.NonNil = true // mapaccess always returns a non-nil pointer
- n = Nod(OIND, n, nil)
+ n = nod(OIND, n, nil)
n.Type = t.Val()
n.Typecheck = 1
Fatalf("large ONEW with EscNone: %v", n)
}
r := temp(n.Type.Elem())
- r = Nod(OAS, r, nil) // zero temp
+ r = nod(OAS, r, nil) // zero temp
r = typecheck(r, Etop)
init.Append(r)
- r = Nod(OADDR, r.Left, nil)
+ r = nod(OADDR, r.Left, nil)
r = typecheck(r, Erv)
n = r
} else {
// s + "badgerbadgerbadger" == "badgerbadgerbadger"
if (Op(n.Etype) == OEQ || Op(n.Etype) == ONE) && Isconst(n.Right, CTSTR) && n.Left.Op == OADDSTR && n.Left.List.Len() == 2 && Isconst(n.Left.List.Second(), CTSTR) && strlit(n.Right) == strlit(n.Left.List.Second()) {
// TODO(marvin): Fix Node.EType type union.
- r := Nod(Op(n.Etype), Nod(OLEN, n.Left.List.First(), nil), nodintconst(0))
+ r := nod(Op(n.Etype), nod(OLEN, n.Left.List.First(), nil), nodintconst(0))
r = typecheck(r, Erv)
r = walkexpr(r, init)
r.Type = n.Type
ncs = safeexpr(ncs, init)
}
// TODO(marvin): Fix Node.EType type union.
- r := Nod(cmp, Nod(OLEN, ncs, nil), nodintconst(int64(len(s))))
+ r := nod(cmp, nod(OLEN, ncs, nil), nodintconst(int64(len(s))))
for i := 0; i < len(s); i++ {
cb := nodintconst(int64(s[i]))
- ncb := Nod(OINDEX, ncs, nodintconst(int64(i)))
- r = Nod(and, r, Nod(cmp, ncb, cb))
+ ncb := nod(OINDEX, ncs, nodintconst(int64(i)))
+ r = nod(and, r, nod(cmp, ncb, cb))
}
r = typecheck(r, Erv)
r = walkexpr(r, init)
// TODO(marvin): Fix Node.EType type union.
if Op(n.Etype) == OEQ {
// len(left) == len(right) && eqstring(left, right)
- r = Nod(OANDAND, Nod(OEQ, Nod(OLEN, n.Left, nil), Nod(OLEN, n.Right, nil)), r)
+ r = nod(OANDAND, nod(OEQ, nod(OLEN, n.Left, nil), nod(OLEN, n.Right, nil)), r)
} else {
// len(left) != len(right) || !eqstring(left, right)
- r = Nod(ONOT, r, nil)
- r = Nod(OOROR, Nod(ONE, Nod(OLEN, n.Left, nil), Nod(OLEN, n.Right, nil)), r)
+ r = nod(ONOT, r, nil)
+ r = nod(OOROR, nod(ONE, nod(OLEN, n.Left, nil), nod(OLEN, n.Right, nil)), r)
}
r = typecheck(r, Erv)
// sys_cmpstring(s1, s2) :: 0
r = mkcall("cmpstring", Types[TINT], init, conv(n.Left, Types[TSTRING]), conv(n.Right, Types[TSTRING]))
// TODO(marvin): Fix Node.EType type union.
- r = Nod(Op(n.Etype), r, nodintconst(0))
+ r = nod(Op(n.Etype), r, nodintconst(0))
}
r = typecheck(r, Erv)
// Allocate hmap buffer on stack.
var_ := temp(hmap(t))
- a = Nod(OAS, var_, nil) // zero temp
+ a = nod(OAS, var_, nil) // zero temp
a = typecheck(a, Etop)
init.Append(a)
- a = Nod(OADDR, var_, nil)
+ a = nod(OADDR, var_, nil)
// Allocate one bucket on stack.
// Maximum key/value size is 128 bytes, larger objects
// are stored with an indirection. So max bucket size is 2048+eps.
var_ = temp(mapbucket(t))
- r = Nod(OAS, var_, nil) // zero temp
+ r = nod(OAS, var_, nil) // zero temp
r = typecheck(r, Etop)
init.Append(r)
- r = Nod(OADDR, var_, nil)
+ r = nod(OADDR, var_, nil)
}
fn := syslook("makemap")
// n = arr[:l]
t = aindex(r, t.Elem()) // [r]T
var_ := temp(t)
- a := Nod(OAS, var_, nil) // zero temp
+ a := nod(OAS, var_, nil) // zero temp
a = typecheck(a, Etop)
init.Append(a)
- r := Nod(OSLICE, var_, nil) // arr[:l]
+ r := nod(OSLICE, var_, nil) // arr[:l]
r.SetSliceBounds(nil, l, nil)
r = conv(r, n.Type) // in case n.Type is named.
r = typecheck(r, Erv)
if n.Esc == EscNone {
t := aindex(nodintconst(4), Types[TUINT8])
var_ := temp(t)
- a = Nod(OADDR, var_, nil)
+ a = nod(OADDR, var_, nil)
}
// intstring(*[4]byte, rune)
// Create temporary buffer for string on stack.
t := aindex(nodintconst(tmpstringbufsize), Types[TUINT8])
- a = Nod(OADDR, temp(t), nil)
+ a = nod(OADDR, temp(t), nil)
}
// slicebytetostring(*[32]byte, []byte) string;
// Create temporary buffer for string on stack.
t := aindex(nodintconst(tmpstringbufsize), Types[TUINT8])
- a = Nod(OADDR, temp(t), nil)
+ a = nod(OADDR, temp(t), nil)
}
n = mkcall("slicerunetostring", n.Type, init, a, n.Left)
// Create temporary buffer for slice on stack.
t := aindex(nodintconst(tmpstringbufsize), Types[TUINT8])
- a = Nod(OADDR, temp(t), nil)
+ a = nod(OADDR, temp(t), nil)
}
n = mkcall("stringtoslicebyte", n.Type, init, a, conv(n.Left, Types[TSTRING]))
// Create temporary buffer for slice on stack.
t := aindex(nodintconst(tmpstringbufsize), Types[TINT32])
- a = Nod(OADDR, temp(t), nil)
+ a = nod(OADDR, temp(t), nil)
}
n = mkcall("stringtoslicerune", n.Type, init, a, n.Left)
r := mkcall1(fn, n.Type, init, n.Left, n.Right)
// TODO(marvin): Fix Node.EType type union.
if Op(n.Etype) == ONE {
- r = Nod(ONOT, r, nil)
+ r = nod(ONOT, r, nil)
}
// check itable/type before full compare.
// TODO(marvin): Fix Node.EType type union.
if Op(n.Etype) == OEQ {
- r = Nod(OANDAND, Nod(OEQ, Nod(OITAB, n.Left, nil), Nod(OITAB, n.Right, nil)), r)
+ r = nod(OANDAND, nod(OEQ, nod(OITAB, n.Left, nil), nod(OITAB, n.Right, nil)), r)
} else {
- r = Nod(OOROR, Nod(ONE, Nod(OITAB, n.Left, nil), Nod(OITAB, n.Right, nil)), r)
+ r = nod(OOROR, nod(ONE, nod(OITAB, n.Left, nil), nod(OITAB, n.Right, nil)), r)
}
r = typecheck(r, Erv)
r = walkexpr(r, init)
n1 := n.Right
n1 = assignconv(n1, n.Left.Type.Elem(), "chan send")
n1 = walkexpr(n1, init)
- n1 = Nod(OADDR, n1, nil)
+ n1 = nod(OADDR, n1, nil)
n = mkcall1(chanfn("chansend1", 2, n.Left.Type), nil, init, typename(n.Left.Type), n.Left, n1)
case OCLOSURE:
func ascompatee1(op Op, l *Node, r *Node, init *Nodes) *Node {
// convas will turn map assigns into function calls,
// making it impossible for reorder3 to work.
- n := Nod(OAS, l, r)
+ n := nod(OAS, l, r)
if l.Op == OINDEXMAP {
return n
if fncall(l, r.Type) {
tmp := temp(r.Type)
tmp = typecheck(tmp, Erv)
- a := Nod(OAS, l, tmp)
+ a := nod(OAS, l, tmp)
a = convas(a, init)
mm = append(mm, a)
l = tmp
}
- a := Nod(OAS, l, nodarg(r, fp))
+ a := nod(OAS, l, nodarg(r, fp))
a = convas(a, init)
ullmancalc(a)
if a.Ullman >= UINF {
n = nodnil()
n.Type = tslice
} else {
- n = Nod(OCOMPLIT, nil, typenod(tslice))
+ n = nod(OCOMPLIT, nil, typenod(tslice))
if ddd != nil && prealloc[ddd] != nil {
prealloc[n] = prealloc[ddd] // temporary to use
}
n = walkexpr(n, init)
}
- a := Nod(OAS, nodarg(l, fp), n)
+ a := nod(OAS, nodarg(l, fp), n)
nn = append(nn, convas(a, init))
return nn
}
// optimization - can do block copy
if eqtypenoname(r.Type, nl) {
arg := nodarg(nl, fp)
- r = Nod(OCONVNOP, r, nil)
+ r = nod(OCONVNOP, r, nil)
r.Type = arg.Type
- nn = []*Node{convas(Nod(OAS, arg, r), init)}
+ nn = []*Node{convas(nod(OAS, arg, r), init)}
goto ret
}
alist = append(alist, tmp)
}
- a := Nod(OAS2, nil, nil)
+ a := nod(OAS2, nil, nil)
a.List.Set(alist)
a.Rlist.Set(lr)
a = typecheck(a, Etop)
// argument to a ddd parameter then it is
// passed through unencapsulated
if r != nil && len(lr) <= 1 && isddd && eqtype(l.Type, r.Type) {
- a := Nod(OAS, nodarg(l, fp), r)
+ a := nod(OAS, nodarg(l, fp), r)
a = convas(a, init)
nn = append(nn, a)
break
break
}
- a := Nod(OAS, nodarg(l, fp), r)
+ a := nod(OAS, nodarg(l, fp), r)
a = convas(a, init)
nn = append(nn, a)
t = on.Type.Params().Field(0).Type
if !eqtype(t, n.Type) {
- n = Nod(OCONV, n, nil)
+ n = nod(OCONV, n, nil)
n.Type = t
}
- r = Nod(OCALL, on, nil)
+ r = nod(OCALL, on, nil)
r.List.Append(n)
calls = append(calls, r)
}
typecheckslice(calls, Etop)
walkexprlist(calls, init)
- r = Nod(OEMPTY, nil, nil)
+ r = nod(OEMPTY, nil, nil)
r = typecheck(r, Etop)
r = walkexpr(r, init)
r.Ninit.Set(calls)
val = walkexpr(val, init)
// orderexpr made sure key and val are addressable.
- key = Nod(OADDR, key, nil)
+ key = nod(OADDR, key, nil)
- val = Nod(OADDR, val, nil)
+ val = nod(OADDR, val, nil)
n = mkcall1(mapfn("mapassign1", map_.Type), nil, init, typename(map_.Type), map_, key, val)
goto out
}
// make assignment of fncall to tempname
a = temp(n.Right.Type)
- a = Nod(OAS, a, n.Right)
+ a = nod(OAS, a, n.Right)
g = append(g, a)
// put normal arg assignment on list
}
q := temp(n.Type)
- q = Nod(OAS, q, n)
+ q = nod(OAS, q, n)
q = typecheck(q, Etop)
*early = append(*early, q)
return q.Left
// Defer might stop a panic and show the
// return values as they exist at the time of panic.
// Make sure to zero them on entry to the function.
- nn = append(nn, Nod(OAS, nodarg(t, 1), nil))
+ nn = append(nn, nod(OAS, nodarg(t, 1), nil))
}
v := t.Nname
}
if stackcopy := v.Name.Param.Stackcopy; stackcopy != nil {
- nn = append(nn, walkstmt(Nod(ODCL, v, nil)))
+ nn = append(nn, walkstmt(nod(ODCL, v, nil)))
if stackcopy.Class == PPARAM {
- nn = append(nn, walkstmt(typecheck(Nod(OAS, v, stackcopy), Etop)))
+ nn = append(nn, walkstmt(typecheck(nod(OAS, v, stackcopy), Etop)))
}
}
}
continue
}
if stackcopy := v.Name.Param.Stackcopy; stackcopy != nil && stackcopy.Class == PPARAMOUT {
- nn = append(nn, walkstmt(typecheck(Nod(OAS, stackcopy, v), Etop)))
+ nn = append(nn, walkstmt(typecheck(nod(OAS, stackcopy, v), Etop)))
}
}
n := fn.Type.Params().NumFields()
- r := Nod(OCALL, fn, nil)
+ r := nod(OCALL, fn, nil)
r.List.Set(va[:n])
if fn.Type.Results().NumFields() > 0 {
r = typecheck(r, Erv|Efnstruct)
if eqtype(n.Type, t) {
return n
}
- n = Nod(OCONV, n, nil)
+ n = nod(OCONV, n, nil)
n.Type = t
n = typecheck(n, Erv)
return n
// Create temporary buffer for result string on stack.
t := aindex(nodintconst(tmpstringbufsize), Types[TUINT8])
- buf = Nod(OADDR, temp(t), nil)
+ buf = nod(OADDR, temp(t), nil)
}
}
fn = "concatstrings"
t := typSlice(Types[TSTRING])
- slice := Nod(OCOMPLIT, nil, typenod(t))
+ slice := nod(OCOMPLIT, nil, typenod(t))
if prealloc[n] != nil {
prealloc[slice] = prealloc[n]
}
}
cat := syslook(fn)
- r := Nod(OCALL, cat, nil)
+ r := nod(OCALL, cat, nil)
r.List.Set(args)
r = typecheck(r, Erv)
r = walkexpr(r, init)
// var s []T
s := temp(l1.Type)
- l = append(l, Nod(OAS, s, l1)) // s = l1
+ l = append(l, nod(OAS, s, l1)) // s = l1
// n := len(s) + len(l2)
nn := temp(Types[TINT])
- l = append(l, Nod(OAS, nn, Nod(OADD, Nod(OLEN, s, nil), Nod(OLEN, l2, nil))))
+ l = append(l, nod(OAS, nn, nod(OADD, nod(OLEN, s, nil), nod(OLEN, l2, nil))))
// if uint(n) > uint(cap(s))
- nif := Nod(OIF, nil, nil)
- nif.Left = Nod(OGT, Nod(OCONV, nn, nil), Nod(OCONV, Nod(OCAP, s, nil), nil))
+ nif := nod(OIF, nil, nil)
+ nif.Left = nod(OGT, nod(OCONV, nn, nil), nod(OCONV, nod(OCAP, s, nil), nil))
nif.Left.Left.Type = Types[TUINT]
nif.Left.Right.Type = Types[TUINT]
fn = substArgTypes(fn, s.Type.Elem(), s.Type.Elem())
// s = growslice(T, s, n)
- nif.Nbody.Set1(Nod(OAS, s, mkcall1(fn, s.Type, &nif.Ninit, typename(s.Type.Elem()), s, nn)))
+ nif.Nbody.Set1(nod(OAS, s, mkcall1(fn, s.Type, &nif.Ninit, typename(s.Type.Elem()), s, nn)))
l = append(l, nif)
// s = s[:n]
- nt := Nod(OSLICE, s, nil)
+ nt := nod(OSLICE, s, nil)
nt.SetSliceBounds(nil, nn, nil)
nt.Etype = 1
- l = append(l, Nod(OAS, s, nt))
+ l = append(l, nod(OAS, s, nt))
if haspointers(l1.Type.Elem()) {
// copy(s[len(l1):], l2)
- nptr1 := Nod(OSLICE, s, nil)
- nptr1.SetSliceBounds(Nod(OLEN, l1, nil), nil, nil)
+ nptr1 := nod(OSLICE, s, nil)
+ nptr1.SetSliceBounds(nod(OLEN, l1, nil), nil, nil)
nptr1.Etype = 1
nptr2 := l2
fn := syslook("typedslicecopy")
} else if instrumenting {
// rely on runtime to instrument copy.
// copy(s[len(l1):], l2)
- nptr1 := Nod(OSLICE, s, nil)
- nptr1.SetSliceBounds(Nod(OLEN, l1, nil), nil, nil)
+ nptr1 := nod(OSLICE, s, nil)
+ nptr1.SetSliceBounds(nod(OLEN, l1, nil), nil, nil)
nptr1.Etype = 1
nptr2 := l2
var fn *Node
l = append(ln.Slice(), nt)
} else {
// memmove(&s[len(l1)], &l2[0], len(l2)*sizeof(T))
- nptr1 := Nod(OINDEX, s, Nod(OLEN, l1, nil))
+ nptr1 := nod(OINDEX, s, nod(OLEN, l1, nil))
nptr1.Bounded = true
- nptr1 = Nod(OADDR, nptr1, nil)
+ nptr1 = nod(OADDR, nptr1, nil)
- nptr2 := Nod(OSPTR, l2, nil)
+ nptr2 := nod(OSPTR, l2, nil)
fn := syslook("memmove")
fn = substArgTypes(fn, s.Type.Elem(), s.Type.Elem())
var ln Nodes
ln.Set(l)
- nwid := cheapexpr(conv(Nod(OLEN, l2, nil), Types[TUINTPTR]), &ln)
+ nwid := cheapexpr(conv(nod(OLEN, l2, nil), Types[TUINTPTR]), &ln)
- nwid = Nod(OMUL, nwid, nodintconst(s.Type.Elem().Width))
+ nwid = nod(OMUL, nwid, nodintconst(s.Type.Elem().Width))
nt := mkcall1(fn, nil, &ln, nptr1, nptr2, nwid)
l = append(ln.Slice(), nt)
}
var l []*Node
ns := temp(nsrc.Type)
- l = append(l, Nod(OAS, ns, nsrc)) // s = src
+ l = append(l, nod(OAS, ns, nsrc)) // s = src
na := nodintconst(int64(argc)) // const argc
- nx := Nod(OIF, nil, nil) // if cap(s) - len(s) < argc
- nx.Left = Nod(OLT, Nod(OSUB, Nod(OCAP, ns, nil), Nod(OLEN, ns, nil)), na)
+ nx := nod(OIF, nil, nil) // if cap(s) - len(s) < argc
+ nx.Left = nod(OLT, nod(OSUB, nod(OCAP, ns, nil), nod(OLEN, ns, nil)), na)
fn := syslook("growslice") // growslice(<type>, old []T, mincap int) (ret []T)
fn = substArgTypes(fn, ns.Type.Elem(), ns.Type.Elem())
- nx.Nbody.Set1(Nod(OAS, ns,
+ nx.Nbody.Set1(nod(OAS, ns,
mkcall1(fn, ns.Type, &nx.Ninit, typename(ns.Type.Elem()), ns,
- Nod(OADD, Nod(OLEN, ns, nil), na))))
+ nod(OADD, nod(OLEN, ns, nil), na))))
l = append(l, nx)
nn := temp(Types[TINT])
- l = append(l, Nod(OAS, nn, Nod(OLEN, ns, nil))) // n = len(s)
+ l = append(l, nod(OAS, nn, nod(OLEN, ns, nil))) // n = len(s)
- nx = Nod(OSLICE, ns, nil) // ...s[:n+argc]
- nx.SetSliceBounds(nil, Nod(OADD, nn, na), nil)
+ nx = nod(OSLICE, ns, nil) // ...s[:n+argc]
+ nx.SetSliceBounds(nil, nod(OADD, nn, na), nil)
nx.Etype = 1
- l = append(l, Nod(OAS, ns, nx)) // s = s[:n+argc]
+ l = append(l, nod(OAS, ns, nx)) // s = s[:n+argc]
ls = n.List.Slice()[1:]
for i, n := range ls {
- nx = Nod(OINDEX, ns, nn) // s[n] ...
+ nx = nod(OINDEX, ns, nn) // s[n] ...
nx.Bounded = true
- l = append(l, Nod(OAS, nx, n)) // s[n] = arg
+ l = append(l, nod(OAS, nx, n)) // s[n] = arg
if i+1 < len(ls) {
- l = append(l, Nod(OAS, nn, Nod(OADD, nn, nodintconst(1)))) // n = n + 1
+ l = append(l, nod(OAS, nn, nod(OADD, nn, nodintconst(1)))) // n = n + 1
}
}
nl := temp(n.Left.Type)
nr := temp(n.Right.Type)
var l []*Node
- l = append(l, Nod(OAS, nl, n.Left))
- l = append(l, Nod(OAS, nr, n.Right))
+ l = append(l, nod(OAS, nl, n.Left))
+ l = append(l, nod(OAS, nr, n.Right))
- nfrm := Nod(OSPTR, nr, nil)
- nto := Nod(OSPTR, nl, nil)
+ nfrm := nod(OSPTR, nr, nil)
+ nto := nod(OSPTR, nl, nil)
nlen := temp(Types[TINT])
// n = len(to)
- l = append(l, Nod(OAS, nlen, Nod(OLEN, nl, nil)))
+ l = append(l, nod(OAS, nlen, nod(OLEN, nl, nil)))
// if n > len(frm) { n = len(frm) }
- nif := Nod(OIF, nil, nil)
+ nif := nod(OIF, nil, nil)
- nif.Left = Nod(OGT, nlen, Nod(OLEN, nr, nil))
- nif.Nbody.Append(Nod(OAS, nlen, Nod(OLEN, nr, nil)))
+ nif.Left = nod(OGT, nlen, nod(OLEN, nr, nil))
+ nif.Nbody.Append(nod(OAS, nlen, nod(OLEN, nr, nil)))
l = append(l, nif)
// Call memmove.
fn = substArgTypes(fn, nl.Type.Elem(), nl.Type.Elem())
nwid := temp(Types[TUINTPTR])
- l = append(l, Nod(OAS, nwid, conv(nlen, Types[TUINTPTR])))
- nwid = Nod(OMUL, nwid, nodintconst(nl.Type.Elem().Width))
+ l = append(l, nod(OAS, nwid, conv(nlen, Types[TUINTPTR])))
+ nwid = nod(OMUL, nwid, nodintconst(nl.Type.Elem().Width))
l = append(l, mkcall1(fn, nil, init, nto, nfrm, nwid))
typecheckslice(l, Etop)
sym := typesymprefix(".eq", t)
n := newname(sym)
n.Class = PFUNC
- ntype := Nod(OTFUNC, nil, nil)
- ntype.List.Append(Nod(ODCLFIELD, nil, typenod(ptrto(t))))
- ntype.List.Append(Nod(ODCLFIELD, nil, typenod(ptrto(t))))
- ntype.Rlist.Append(Nod(ODCLFIELD, nil, typenod(Types[TBOOL])))
+ ntype := nod(OTFUNC, nil, nil)
+ ntype.List.Append(nod(ODCLFIELD, nil, typenod(ptrto(t))))
+ ntype.List.Append(nod(ODCLFIELD, nil, typenod(ptrto(t))))
+ ntype.Rlist.Append(nod(ODCLFIELD, nil, typenod(Types[TBOOL])))
ntype = typecheck(ntype, Etype)
n.Type = ntype.Type
*needsize = 0
// For non-empty interface, this is:
// l.tab != nil && l.tab._type == type(r)
var eqtype *Node
- tab := Nod(OITAB, l, nil)
+ tab := nod(OITAB, l, nil)
rtyp := typename(r.Type)
if l.Type.IsEmptyInterface() {
tab.Type = ptrto(Types[TUINT8])
tab.Typecheck = 1
- eqtype = Nod(eq, tab, rtyp)
+ eqtype = nod(eq, tab, rtyp)
} else {
- nonnil := Nod(brcom(eq), nodnil(), tab)
- match := Nod(eq, itabType(tab), rtyp)
- eqtype = Nod(andor, nonnil, match)
+ nonnil := nod(brcom(eq), nodnil(), tab)
+ match := nod(eq, itabType(tab), rtyp)
+ eqtype = nod(andor, nonnil, match)
}
// Check for data equal.
- eqdata := Nod(eq, ifaceData(l, r.Type), r)
+ eqdata := nod(eq, ifaceData(l, r.Type), r)
// Put it all together.
- expr := Nod(andor, eqtype, eqdata)
+ expr := nod(andor, eqtype, eqdata)
n = finishcompare(n, expr, init)
return n
}
if !inline {
// eq algs take pointers
pl := temp(ptrto(t))
- al := Nod(OAS, pl, Nod(OADDR, cmpl, nil))
+ al := nod(OAS, pl, nod(OADDR, cmpl, nil))
al.Right.Etype = 1 // addr does not escape
al = typecheck(al, Etop)
init.Append(al)
pr := temp(ptrto(t))
- ar := Nod(OAS, pr, Nod(OADDR, cmpr, nil))
+ ar := nod(OAS, pr, nod(OADDR, cmpr, nil))
ar.Right.Etype = 1 // addr does not escape
ar = typecheck(ar, Etop)
init.Append(ar)
var needsize int
- call := Nod(OCALL, eqfor(t, &needsize), nil)
+ call := nod(OCALL, eqfor(t, &needsize), nil)
call.List.Append(pl)
call.List.Append(pr)
if needsize != 0 {
}
res := call
if n.Op != OEQ {
- res = Nod(ONOT, res, nil)
+ res = nod(ONOT, res, nil)
}
n = finishcompare(n, res, init)
return n
}
var expr *Node
compare := func(el, er *Node) {
- a := Nod(n.Op, el, er)
+ a := nod(n.Op, el, er)
if expr == nil {
expr = a
} else {
- expr = Nod(andor, expr, a)
+ expr = nod(andor, expr, a)
}
}
cmpl = safeexpr(cmpl, init)
} else {
for i := 0; int64(i) < t.NumElem(); i++ {
compare(
- Nod(OINDEX, cmpl, nodintconst(int64(i))),
- Nod(OINDEX, cmpr, nodintconst(int64(i))),
+ nod(OINDEX, cmpl, nodintconst(int64(i))),
+ nod(OINDEX, cmpr, nodintconst(int64(i))),
)
}
}
nn = walkexpr(nn, init)
r = nn
if r.Type != n.Type {
- r = Nod(OCONVNOP, r, nil)
+ r = nod(OCONVNOP, r, nil)
r.Type = n.Type
r.Typecheck = 1
nn = r
// which is equivalent to 0 ≤ (b-a) && (b-a) < (c-a),
// which is equivalent to uint(b-a) < uint(c-a).
ut := b.Type.toUnsigned()
- lhs := conv(Nod(OSUB, b, a), ut)
+ lhs := conv(nod(OSUB, b, a), ut)
rhs := nodintconst(bound)
if negateResult {
// Negate top level.
opr = brcom(opr)
}
- cmp := Nod(opr, lhs, rhs)
+ cmp := nod(opr, lhs, rhs)
cmp.Lineno = n.Lineno
cmp = addinit(cmp, l.Ninit.Slice())
cmp = addinit(cmp, r.Ninit.Slice())
goto ret
}
- n = Nod(OLSH, nl, nodintconst(int64(pow)))
+ n = nod(OLSH, nl, nodintconst(int64(pow)))
ret:
if neg != 0 {
- n = Nod(OMINUS, n, nil)
+ n = nod(OMINUS, n, nil)
}
n = typecheck(n, Erv)
// for modulo too.
if n.Op == OMOD {
// rewrite as A%B = A - (A/B*B).
- n1 := Nod(ODIV, nl, nr)
+ n1 := nod(ODIV, nl, nr)
- n2 := Nod(OMUL, n1, nr)
- n = Nod(OSUB, nl, n2)
+ n2 := nod(OMUL, n1, nr)
+ n = nod(OSUB, nl, n2)
goto ret
}
var nc Node
Nodconst(&nc, nl.Type, int64(m.Um))
- n1 := Nod(OHMUL, nl, &nc)
+ n1 := nod(OHMUL, nl, &nc)
n1 = typecheck(n1, Erv)
if m.Ua != 0 {
// Select a Go type with (at least) twice the width.
// add numerator (might overflow).
// n2 = (n1 + nl)
- n2 := Nod(OADD, conv(n1, twide), conv(nl, twide))
+ n2 := nod(OADD, conv(n1, twide), conv(nl, twide))
// shift by m.s
var nc Node
Nodconst(&nc, Types[TUINT], int64(m.S))
- n = conv(Nod(ORSH, n2, &nc), nl.Type)
+ n = conv(nod(ORSH, n2, &nc), nl.Type)
} else {
// n = n1 >> m.s
var nc Node
Nodconst(&nc, Types[TUINT], int64(m.S))
- n = Nod(ORSH, n1, &nc)
+ n = nod(ORSH, n1, &nc)
}
// n1 = nl * magic >> w
var nc Node
Nodconst(&nc, nl.Type, m.Sm)
- n1 := Nod(OHMUL, nl, &nc)
+ n1 := nod(OHMUL, nl, &nc)
n1 = typecheck(n1, Erv)
if m.Sm < 0 {
// add the numerator.
- n1 = Nod(OADD, n1, nl)
+ n1 = nod(OADD, n1, nl)
}
// shift by m.s
var ns Node
Nodconst(&ns, Types[TUINT], int64(m.S))
- n2 := conv(Nod(ORSH, n1, &ns), nl.Type)
+ n2 := conv(nod(ORSH, n1, &ns), nl.Type)
// add 1 iff n1 is negative.
var nneg Node
Nodconst(&nneg, Types[TUINT], int64(w)-1)
- n3 := Nod(ORSH, nl, &nneg) // n4 = -1 iff n1 is negative.
- n = Nod(OSUB, n2, n3)
+ n3 := nod(ORSH, nl, &nneg) // n4 = -1 iff n1 is negative.
+ n = nod(OSUB, n2, n3)
// apply sign.
if m.Sd < 0 {
- n = Nod(OMINUS, n, nil)
+ n = nod(OMINUS, n, nil)
}
}
var nc Node
Nodconst(&nc, Types[simtype[TUINT]], int64(w)-1)
- n1 := Nod(ORSH, nl, &nc) // n1 = -1 iff nl < 0.
+ n1 := nod(ORSH, nl, &nc) // n1 = -1 iff nl < 0.
if pow == 1 {
n1 = typecheck(n1, Erv)
n1 = cheapexpr(n1, init)
// n = (nl+ε)&1 -ε where ε=1 iff nl<0.
- n2 := Nod(OSUB, nl, n1)
+ n2 := nod(OSUB, nl, n1)
var nc Node
Nodconst(&nc, nl.Type, 1)
- n3 := Nod(OAND, n2, &nc)
- n = Nod(OADD, n3, n1)
+ n3 := nod(OAND, n2, &nc)
+ n = nod(OADD, n3, n1)
} else {
// n = (nl+ε)&(nr-1) - ε where ε=2^pow-1 iff nl<0.
var nc Node
Nodconst(&nc, nl.Type, (1<<uint(pow))-1)
- n2 := Nod(OAND, n1, &nc) // n2 = 2^pow-1 iff nl<0.
+ n2 := nod(OAND, n1, &nc) // n2 = 2^pow-1 iff nl<0.
n2 = typecheck(n2, Erv)
n2 = cheapexpr(n2, init)
- n3 := Nod(OADD, nl, n2)
- n4 := Nod(OAND, n3, &nc)
- n = Nod(OSUB, n4, n2)
+ n3 := nod(OADD, nl, n2)
+ n4 := nod(OAND, n3, &nc)
+ n = nod(OSUB, n4, n2)
}
break
var nc Node
Nodconst(&nc, Types[simtype[TUINT]], int64(w)-1)
- n1 := Nod(ORSH, nl, &nc) // n1 = -1 iff nl < 0.
+ n1 := nod(ORSH, nl, &nc) // n1 = -1 iff nl < 0.
if pow == 1 {
// nl+1 is nl-(-1)
- n.Left = Nod(OSUB, nl, n1)
+ n.Left = nod(OSUB, nl, n1)
} else {
// Do a logical right right on -1 to keep pow bits.
var nc Node
Nodconst(&nc, Types[simtype[TUINT]], int64(w)-int64(pow))
- n2 := Nod(ORSH, conv(n1, nl.Type.toUnsigned()), &nc)
- n.Left = Nod(OADD, nl, conv(n2, nl.Type))
+ n2 := nod(ORSH, conv(n1, nl.Type.toUnsigned()), &nc)
+ n.Left = nod(OADD, nl, conv(n2, nl.Type))
}
// n = (nl + 2^pow-1) >> pow
}
if s != 0 {
- n = Nod(OMINUS, n, nil)
+ n = nod(OMINUS, n, nil)
}
break
}
init.AppendNodes(&n.Ninit)
}
- t := Nod(OTFUNC, nil, nil)
+ t := nod(OTFUNC, nil, nil)
num := 0
var printargs []*Node
var a *Node
for _, n1 := range n.List.Slice() {
buf = fmt.Sprintf("a%d", num)
num++
- a = Nod(ODCLFIELD, newname(lookup(buf)), typenod(n1.Type))
+ a = nod(ODCLFIELD, newname(lookup(buf)), typenod(n1.Type))
t.List.Append(a)
printargs = append(printargs, a.Left)
}
- fn := Nod(ODCLFUNC, nil, nil)
+ fn := nod(ODCLFUNC, nil, nil)
walkprintfunc_prgen++
buf = fmt.Sprintf("print·%d", walkprintfunc_prgen)
fn.Func.Nname = newname(lookup(buf))
Curfn = nil
funchdr(fn)
- a = Nod(n.Op, nil, nil)
+ a = nod(n.Op, nil, nil)
a.List.Set(printargs)
a = typecheck(a, Etop)
a = walkstmt(a)
xtop = append(xtop, fn)
Curfn = oldfn
- a = Nod(OCALL, nil, nil)
+ a = nod(OCALL, nil, nil)
a.Left = fn.Func.Nname
a.List.Set(n.List.Slice())
a = typecheck(a, Etop)
}
// TODO(gri) find a better solution
-var missing_stmt Stmt = new(EmptyStmt) // = Nod(OXXX, nil, nil)
+var missing_stmt Stmt = new(EmptyStmt) // = nod(OXXX, nil, nil)
// Statement =
// Declaration | LabeledStmt | SimpleStmt |
s.Tok = _Fallthrough
return s
// // will be converted to OFALL
- // stmt := Nod(OXFALL, nil, nil)
+ // stmt := nod(OXFALL, nil, nil)
// stmt.Xoffset = int64(block)
// return stmt
s.Tok = _Goto
s.Label = p.name()
return s
- // stmt := Nod(OGOTO, p.new_name(p.name()), nil)
+ // stmt := nod(OGOTO, p.new_name(p.name()), nil)
// stmt.Sym = dclstack // context, for goto restrictions
// return stmt