mirror of
https://github.com/golang/go.git
synced 2025-12-08 06:10:04 +00:00
2805d20689
This makes the overall naming and use of the functions to create a Type more consistent. Passes toolstash -cmp. Change-Id: Ie0d40b42cc32b5ecf5f20502675a225038ea40e4 Reviewed-on: https://go-review.googlesource.com/38354 Reviewed-by: Matthew Dempsky <mdempsky@google.com> Run-TryBot: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org>
361 lines
9.4 KiB
Go
361 lines
9.4 KiB
Go
// Copyright 2009 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package gc
|
|
|
|
// select
|
|
func typecheckselect(sel *Node) {
|
|
var ncase *Node
|
|
var n *Node
|
|
|
|
var def *Node
|
|
lno := setlineno(sel)
|
|
count := 0
|
|
typecheckslice(sel.Ninit.Slice(), Etop)
|
|
for _, n1 := range sel.List.Slice() {
|
|
count++
|
|
ncase = n1
|
|
setlineno(ncase)
|
|
if ncase.Op != OXCASE {
|
|
Fatalf("typecheckselect %v", ncase.Op)
|
|
}
|
|
|
|
if ncase.List.Len() == 0 {
|
|
// default
|
|
if def != nil {
|
|
yyerror("multiple defaults in select (first at %v)", def.Line())
|
|
} else {
|
|
def = ncase
|
|
}
|
|
} else if ncase.List.Len() > 1 {
|
|
yyerror("select cases cannot be lists")
|
|
} else {
|
|
ncase.List.SetFirst(typecheck(ncase.List.First(), Etop))
|
|
n = ncase.List.First()
|
|
ncase.Left = n
|
|
ncase.List.Set(nil)
|
|
setlineno(n)
|
|
switch n.Op {
|
|
default:
|
|
yyerror("select case must be receive, send or assign recv")
|
|
|
|
// convert x = <-c into OSELRECV(x, <-c).
|
|
// remove implicit conversions; the eventual assignment
|
|
// will reintroduce them.
|
|
case OAS:
|
|
if (n.Right.Op == OCONVNOP || n.Right.Op == OCONVIFACE) && n.Right.Implicit() {
|
|
n.Right = n.Right.Left
|
|
}
|
|
|
|
if n.Right.Op != ORECV {
|
|
yyerror("select assignment must have receive on right hand side")
|
|
break
|
|
}
|
|
|
|
n.Op = OSELRECV
|
|
|
|
// convert x, ok = <-c into OSELRECV2(x, <-c) with ntest=ok
|
|
case OAS2RECV:
|
|
if n.Rlist.First().Op != ORECV {
|
|
yyerror("select assignment must have receive on right hand side")
|
|
break
|
|
}
|
|
|
|
n.Op = OSELRECV2
|
|
n.Left = n.List.First()
|
|
n.List.Set1(n.List.Second())
|
|
n.Right = n.Rlist.First()
|
|
n.Rlist.Set(nil)
|
|
|
|
// convert <-c into OSELRECV(N, <-c)
|
|
case ORECV:
|
|
n = nod(OSELRECV, nil, n)
|
|
|
|
n.Typecheck = 1
|
|
ncase.Left = n
|
|
|
|
case OSEND:
|
|
break
|
|
}
|
|
}
|
|
|
|
typecheckslice(ncase.Nbody.Slice(), Etop)
|
|
}
|
|
|
|
sel.Xoffset = int64(count)
|
|
lineno = lno
|
|
}
|
|
|
|
func walkselect(sel *Node) {
|
|
if sel.List.Len() == 0 && sel.Xoffset != 0 {
|
|
Fatalf("double walkselect") // already rewrote
|
|
}
|
|
|
|
lno := setlineno(sel)
|
|
i := sel.List.Len()
|
|
|
|
// optimization: zero-case select
|
|
var init []*Node
|
|
var r *Node
|
|
var n *Node
|
|
var var_ *Node
|
|
var selv *Node
|
|
var chosen *Node
|
|
if i == 0 {
|
|
sel.Nbody.Set1(mkcall("block", nil, nil))
|
|
goto out
|
|
}
|
|
|
|
// optimization: one-case select: single op.
|
|
// TODO(rsc): Reenable optimization once order.go can handle it.
|
|
// golang.org/issue/7672.
|
|
if i == 1 {
|
|
cas := sel.List.First()
|
|
setlineno(cas)
|
|
l := cas.Ninit.Slice()
|
|
if cas.Left != nil { // not default:
|
|
n := cas.Left
|
|
l = append(l, n.Ninit.Slice()...)
|
|
n.Ninit.Set(nil)
|
|
var ch *Node
|
|
switch n.Op {
|
|
default:
|
|
Fatalf("select %v", n.Op)
|
|
|
|
// ok already
|
|
case OSEND:
|
|
ch = n.Left
|
|
|
|
case OSELRECV, OSELRECV2:
|
|
ch = n.Right.Left
|
|
if n.Op == OSELRECV || n.List.Len() == 0 {
|
|
if n.Left == nil {
|
|
n = n.Right
|
|
} else {
|
|
n.Op = OAS
|
|
}
|
|
break
|
|
}
|
|
|
|
if n.Left == nil {
|
|
nblank = typecheck(nblank, Erv|Easgn)
|
|
n.Left = nblank
|
|
}
|
|
|
|
n.Op = OAS2
|
|
n.List.Prepend(n.Left)
|
|
n.Rlist.Set1(n.Right)
|
|
n.Right = nil
|
|
n.Left = nil
|
|
n.Typecheck = 0
|
|
n = typecheck(n, Etop)
|
|
}
|
|
|
|
// if ch == nil { block() }; n;
|
|
a := nod(OIF, nil, nil)
|
|
|
|
a.Left = nod(OEQ, ch, nodnil())
|
|
var ln Nodes
|
|
ln.Set(l)
|
|
a.Nbody.Set1(mkcall("block", nil, &ln))
|
|
l = ln.Slice()
|
|
a = typecheck(a, Etop)
|
|
l = append(l, a)
|
|
l = append(l, n)
|
|
}
|
|
|
|
l = append(l, cas.Nbody.Slice()...)
|
|
l = append(l, nod(OBREAK, nil, nil))
|
|
sel.Nbody.Set(l)
|
|
goto out
|
|
}
|
|
|
|
// convert case value arguments to addresses.
|
|
// this rewrite is used by both the general code and the next optimization.
|
|
for _, cas := range sel.List.Slice() {
|
|
setlineno(cas)
|
|
n = cas.Left
|
|
if n == nil {
|
|
continue
|
|
}
|
|
switch n.Op {
|
|
case OSEND:
|
|
n.Right = nod(OADDR, n.Right, nil)
|
|
n.Right = typecheck(n.Right, Erv)
|
|
|
|
case OSELRECV, OSELRECV2:
|
|
if n.Op == OSELRECV2 && n.List.Len() == 0 {
|
|
n.Op = OSELRECV
|
|
}
|
|
if n.Op == OSELRECV2 {
|
|
n.List.SetFirst(nod(OADDR, n.List.First(), nil))
|
|
n.List.SetFirst(typecheck(n.List.First(), Erv))
|
|
}
|
|
|
|
if n.Left == nil {
|
|
n.Left = nodnil()
|
|
} else {
|
|
n.Left = nod(OADDR, n.Left, nil)
|
|
n.Left = typecheck(n.Left, Erv)
|
|
}
|
|
}
|
|
}
|
|
|
|
// optimization: two-case select but one is default: single non-blocking op.
|
|
if i == 2 && (sel.List.First().Left == nil || sel.List.Second().Left == nil) {
|
|
var cas *Node
|
|
var dflt *Node
|
|
if sel.List.First().Left == nil {
|
|
cas = sel.List.Second()
|
|
dflt = sel.List.First()
|
|
} else {
|
|
dflt = sel.List.Second()
|
|
cas = sel.List.First()
|
|
}
|
|
|
|
n := cas.Left
|
|
setlineno(n)
|
|
r := nod(OIF, nil, nil)
|
|
r.Ninit.Set(cas.Ninit.Slice())
|
|
switch n.Op {
|
|
default:
|
|
Fatalf("select %v", n.Op)
|
|
|
|
case OSEND:
|
|
// if selectnbsend(c, v) { body } else { default body }
|
|
ch := n.Left
|
|
r.Left = mkcall1(chanfn("selectnbsend", 2, ch.Type), Types[TBOOL], &r.Ninit, typename(ch.Type), ch, n.Right)
|
|
|
|
case OSELRECV:
|
|
// if c != nil && selectnbrecv(&v, c) { body } else { default body }
|
|
r = nod(OIF, nil, nil)
|
|
r.Ninit.Set(cas.Ninit.Slice())
|
|
ch := n.Right.Left
|
|
r.Left = mkcall1(chanfn("selectnbrecv", 2, ch.Type), Types[TBOOL], &r.Ninit, typename(ch.Type), n.Left, ch)
|
|
|
|
case OSELRECV2:
|
|
// if c != nil && selectnbrecv2(&v, c) { body } else { default body }
|
|
r = nod(OIF, nil, nil)
|
|
r.Ninit.Set(cas.Ninit.Slice())
|
|
ch := n.Right.Left
|
|
r.Left = mkcall1(chanfn("selectnbrecv2", 2, ch.Type), Types[TBOOL], &r.Ninit, typename(ch.Type), n.Left, n.List.First(), ch)
|
|
}
|
|
|
|
r.Left = typecheck(r.Left, Erv)
|
|
r.Nbody.Set(cas.Nbody.Slice())
|
|
r.Rlist.Set(append(dflt.Ninit.Slice(), dflt.Nbody.Slice()...))
|
|
sel.Nbody.Set2(r, nod(OBREAK, nil, nil))
|
|
goto out
|
|
}
|
|
|
|
init = sel.Ninit.Slice()
|
|
sel.Ninit.Set(nil)
|
|
|
|
// generate sel-struct
|
|
setlineno(sel)
|
|
selv = temp(selecttype(int32(sel.Xoffset)))
|
|
r = nod(OAS, selv, nil)
|
|
r = typecheck(r, Etop)
|
|
init = append(init, r)
|
|
var_ = conv(conv(nod(OADDR, selv, nil), Types[TUNSAFEPTR]), typPtr(Types[TUINT8]))
|
|
r = mkcall("newselect", nil, nil, var_, nodintconst(selv.Type.Width), nodintconst(sel.Xoffset))
|
|
r = typecheck(r, Etop)
|
|
init = append(init, r)
|
|
|
|
// register cases
|
|
for _, cas := range sel.List.Slice() {
|
|
setlineno(cas)
|
|
|
|
init = append(init, cas.Ninit.Slice()...)
|
|
cas.Ninit.Set(nil)
|
|
|
|
var x *Node
|
|
if n := cas.Left; n != nil {
|
|
init = append(init, n.Ninit.Slice()...)
|
|
|
|
switch n.Op {
|
|
default:
|
|
Fatalf("select %v", n.Op)
|
|
case OSEND:
|
|
// selectsend(sel *byte, hchan *chan any, elem *any)
|
|
x = mkcall1(chanfn("selectsend", 2, n.Left.Type), nil, nil, var_, n.Left, n.Right)
|
|
case OSELRECV:
|
|
// selectrecv(sel *byte, hchan *chan any, elem *any, received *bool)
|
|
x = mkcall1(chanfn("selectrecv", 2, n.Right.Left.Type), nil, nil, var_, n.Right.Left, n.Left, nodnil())
|
|
case OSELRECV2:
|
|
// selectrecv(sel *byte, hchan *chan any, elem *any, received *bool)
|
|
x = mkcall1(chanfn("selectrecv", 2, n.Right.Left.Type), nil, nil, var_, n.Right.Left, n.Left, n.List.First())
|
|
}
|
|
} else {
|
|
// selectdefault(sel *byte)
|
|
x = mkcall("selectdefault", nil, nil, var_)
|
|
}
|
|
|
|
init = append(init, x)
|
|
}
|
|
|
|
// run the select
|
|
setlineno(sel)
|
|
chosen = temp(Types[TINT])
|
|
r = nod(OAS, chosen, mkcall("selectgo", Types[TINT], nil, var_))
|
|
r = typecheck(r, Etop)
|
|
init = append(init, r)
|
|
|
|
// selv is no longer alive after selectgo.
|
|
init = append(init, nod(OVARKILL, selv, nil))
|
|
|
|
// dispatch cases
|
|
for i, cas := range sel.List.Slice() {
|
|
setlineno(cas)
|
|
|
|
cond := nod(OEQ, chosen, nodintconst(int64(i)))
|
|
cond = typecheck(cond, Erv)
|
|
|
|
r = nod(OIF, cond, nil)
|
|
r.Nbody.AppendNodes(&cas.Nbody)
|
|
r.Nbody.Append(nod(OBREAK, nil, nil))
|
|
init = append(init, r)
|
|
}
|
|
|
|
sel.Nbody.Set(init)
|
|
|
|
out:
|
|
sel.List.Set(nil)
|
|
walkstmtlist(sel.Nbody.Slice())
|
|
lineno = lno
|
|
}
|
|
|
|
// Keep in sync with src/runtime/select.go.
|
|
func selecttype(size int32) *Type {
|
|
// 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(typPtr(Types[TUINT8]))))
|
|
scase.List.Append(nod(ODCLFIELD, newname(lookup("chan")), typenod(typPtr(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("receivedp")), typenod(typPtr(Types[TUINT8]))))
|
|
scase.List.Append(nod(ODCLFIELD, newname(lookup("releasetime")), typenod(Types[TUINT64])))
|
|
scase = typecheck(scase, Etype)
|
|
scase.Type.SetNoalg(true)
|
|
scase.Type.SetLocal(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(typPtr(Types[TUINT8]))))
|
|
sel.List.Append(nod(ODCLFIELD, newname(lookup("lockorder")), typenod(typPtr(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.SetNoalg(true)
|
|
sel.Type.SetLocal(true)
|
|
|
|
return sel.Type
|
|
}
|