[dev.cc] cmd/internal/gc, cmd/new6g etc: convert from cmd/gc, cmd/6g etc
First draft of converted Go compiler, using rsc.io/c2go rev 83d795a.
Change-Id: I29f4c7010de07d2ff1947bbca9865879d83c32c3
Reviewed-on: https://go-review.googlesource.com/4851
Reviewed-by: Rob Pike <r@golang.org>
diff --git a/src/cmd/internal/gc/align.go b/src/cmd/internal/gc/align.go
new file mode 100644
index 0000000..062d35a
--- /dev/null
+++ b/src/cmd/internal/gc/align.go
@@ -0,0 +1,735 @@
+// 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
+
+import "cmd/internal/obj"
+
+/*
+ * machine size and rounding
+ * alignment is dictated around
+ * the size of a pointer, set in betypeinit
+ * (see ../6g/galign.c).
+ */
+var defercalc int
+
+func Rnd(o int64, r int64) int64 {
+ if r < 1 || r > 8 || r&(r-1) != 0 {
+ Fatal("rnd %d", r)
+ }
+ return (o + r - 1) &^ (r - 1)
+}
+
+func offmod(t *Type) {
+ var f *Type
+ var o int32
+
+ o = 0
+ for f = t.Type; f != nil; f = f.Down {
+ if f.Etype != TFIELD {
+ Fatal("offmod: not TFIELD: %v", Tconv(f, obj.FmtLong))
+ }
+ f.Width = int64(o)
+ o += int32(Widthptr)
+ if int64(o) >= Thearch.MAXWIDTH {
+ Yyerror("interface too large")
+ o = int32(Widthptr)
+ }
+ }
+}
+
+func widstruct(errtype *Type, t *Type, o int64, flag int) int64 {
+ var f *Type
+ var w int64
+ var maxalign int32
+ var starto int64
+ var lastzero int64
+
+ starto = o
+ maxalign = int32(flag)
+ if maxalign < 1 {
+ maxalign = 1
+ }
+ lastzero = 0
+ for f = t.Type; f != nil; f = f.Down {
+ if f.Etype != TFIELD {
+ Fatal("widstruct: not TFIELD: %v", Tconv(f, obj.FmtLong))
+ }
+ if f.Type == nil {
+ // broken field, just skip it so that other valid fields
+ // get a width.
+ continue
+ }
+
+ dowidth(f.Type)
+ if int32(f.Type.Align) > maxalign {
+ maxalign = int32(f.Type.Align)
+ }
+ if f.Type.Width < 0 {
+ Fatal("invalid width %d", f.Type.Width)
+ }
+ w = f.Type.Width
+ if f.Type.Align > 0 {
+ o = Rnd(o, int64(f.Type.Align))
+ }
+ f.Width = o // really offset for TFIELD
+ if f.Nname != nil {
+ // this same stackparam logic is in addrescapes
+ // in typecheck.c. usually addrescapes runs after
+ // widstruct, in which case we could drop this,
+ // but function closure functions are the exception.
+ if f.Nname.Stackparam != nil {
+ f.Nname.Stackparam.Xoffset = o
+ f.Nname.Xoffset = 0
+ } else {
+ f.Nname.Xoffset = o
+ }
+ }
+
+ if w == 0 {
+ lastzero = o
+ }
+ o += w
+ if o >= Thearch.MAXWIDTH {
+ Yyerror("type %v too large", Tconv(errtype, obj.FmtLong))
+ o = 8 // small but nonzero
+ }
+ }
+
+ // For nonzero-sized structs which end in a zero-sized thing, we add
+ // an extra byte of padding to the type. This padding ensures that
+ // taking the address of the zero-sized thing can't manufacture a
+ // pointer to the next object in the heap. See issue 9401.
+ if flag == 1 && o > starto && o == lastzero {
+ o++
+ }
+
+ // final width is rounded
+ if flag != 0 {
+ o = Rnd(o, int64(maxalign))
+ }
+ t.Align = uint8(maxalign)
+
+ // type width only includes back to first field's offset
+ t.Width = o - starto
+
+ return o
+}
+
+func dowidth(t *Type) {
+ var et int32
+ var w int64
+ var lno int
+ var t1 *Type
+
+ if Widthptr == 0 {
+ Fatal("dowidth without betypeinit")
+ }
+
+ if t == nil {
+ return
+ }
+
+ if t.Width > 0 {
+ return
+ }
+
+ if t.Width == -2 {
+ lno = int(lineno)
+ lineno = int32(t.Lineno)
+ if !(t.Broke != 0) {
+ t.Broke = 1
+ Yyerror("invalid recursive type %v", Tconv(t, 0))
+ }
+
+ t.Width = 0
+ lineno = int32(lno)
+ return
+ }
+
+ // break infinite recursion if the broken recursive type
+ // is referenced again
+ if t.Broke != 0 && t.Width == 0 {
+ return
+ }
+
+ // defer checkwidth calls until after we're done
+ defercalc++
+
+ lno = int(lineno)
+ lineno = int32(t.Lineno)
+ t.Width = -2
+ t.Align = 0
+
+ et = int32(t.Etype)
+ switch et {
+ case TFUNC,
+ TCHAN,
+ TMAP,
+ TSTRING:
+ break
+
+ /* simtype == 0 during bootstrap */
+ default:
+ if Simtype[t.Etype] != 0 {
+ et = int32(Simtype[t.Etype])
+ }
+ }
+
+ w = 0
+ switch et {
+ default:
+ Fatal("dowidth: unknown type: %v", Tconv(t, 0))
+
+ /* compiler-specific stuff */
+ case TINT8,
+ TUINT8,
+ TBOOL:
+ // bool is int8
+ w = 1
+
+ case TINT16,
+ TUINT16:
+ w = 2
+
+ case TINT32,
+ TUINT32,
+ TFLOAT32:
+ w = 4
+
+ case TINT64,
+ TUINT64,
+ TFLOAT64,
+ TCOMPLEX64:
+ w = 8
+ t.Align = uint8(Widthreg)
+
+ case TCOMPLEX128:
+ w = 16
+ t.Align = uint8(Widthreg)
+
+ case TPTR32:
+ w = 4
+ checkwidth(t.Type)
+
+ case TPTR64:
+ w = 8
+ checkwidth(t.Type)
+
+ case TUNSAFEPTR:
+ w = int64(Widthptr)
+
+ case TINTER: // implemented as 2 pointers
+ w = 2 * int64(Widthptr)
+
+ t.Align = uint8(Widthptr)
+ offmod(t)
+
+ case TCHAN: // implemented as pointer
+ w = int64(Widthptr)
+
+ checkwidth(t.Type)
+
+ // make fake type to check later to
+ // trigger channel argument check.
+ t1 = typ(TCHANARGS)
+
+ t1.Type = t
+ checkwidth(t1)
+
+ case TCHANARGS:
+ t1 = t.Type
+ dowidth(t.Type) // just in case
+ if t1.Type.Width >= 1<<16 {
+ Yyerror("channel element type too large (>64kB)")
+ }
+ t.Width = 1
+
+ case TMAP: // implemented as pointer
+ w = int64(Widthptr)
+
+ checkwidth(t.Type)
+ checkwidth(t.Down)
+
+ case TFORW: // should have been filled in
+ if !(t.Broke != 0) {
+ Yyerror("invalid recursive type %v", Tconv(t, 0))
+ }
+ w = 1 // anything will do
+
+ // dummy type; should be replaced before use.
+ case TANY:
+ if !(Debug['A'] != 0) {
+ Fatal("dowidth any")
+ }
+ w = 1 // anything will do
+
+ case TSTRING:
+ if sizeof_String == 0 {
+ Fatal("early dowidth string")
+ }
+ w = int64(sizeof_String)
+ t.Align = uint8(Widthptr)
+
+ case TARRAY:
+ if t.Type == nil {
+ break
+ }
+ if t.Bound >= 0 {
+ var cap uint64
+
+ dowidth(t.Type)
+ if t.Type.Width != 0 {
+ cap = (uint64(Thearch.MAXWIDTH) - 1) / uint64(t.Type.Width)
+ if uint64(t.Bound) > cap {
+ Yyerror("type %v larger than address space", Tconv(t, obj.FmtLong))
+ }
+ }
+
+ w = t.Bound * t.Type.Width
+ t.Align = t.Type.Align
+ } else if t.Bound == -1 {
+ w = int64(sizeof_Array)
+ checkwidth(t.Type)
+ t.Align = uint8(Widthptr)
+ } else if t.Bound == -100 {
+ if !(t.Broke != 0) {
+ Yyerror("use of [...] array outside of array literal")
+ t.Broke = 1
+ }
+ } else {
+ Fatal("dowidth %v", Tconv(t, 0)) // probably [...]T
+ }
+
+ case TSTRUCT:
+ if t.Funarg != 0 {
+ Fatal("dowidth fn struct %v", Tconv(t, 0))
+ }
+ w = widstruct(t, t, 0, 1)
+
+ // make fake type to check later to
+ // trigger function argument computation.
+ case TFUNC:
+ t1 = typ(TFUNCARGS)
+
+ t1.Type = t
+ checkwidth(t1)
+
+ // width of func type is pointer
+ w = int64(Widthptr)
+
+ // function is 3 cated structures;
+ // compute their widths as side-effect.
+ case TFUNCARGS:
+ t1 = t.Type
+
+ w = widstruct(t.Type, *getthis(t1), 0, 0)
+ w = widstruct(t.Type, *getinarg(t1), w, Widthreg)
+ w = widstruct(t.Type, *Getoutarg(t1), w, Widthreg)
+ t1.Argwid = w
+ if w%int64(Widthreg) != 0 {
+ Warn("bad type %v %d\n", Tconv(t1, 0), w)
+ }
+ t.Align = 1
+ }
+
+ if Widthptr == 4 && w != int64(int32(w)) {
+ Yyerror("type %v too large", Tconv(t, 0))
+ }
+
+ t.Width = w
+ if t.Align == 0 {
+ if w > 8 || w&(w-1) != 0 {
+ Fatal("invalid alignment for %v", Tconv(t, 0))
+ }
+ t.Align = uint8(w)
+ }
+
+ lineno = int32(lno)
+
+ if defercalc == 1 {
+ resumecheckwidth()
+ } else {
+ defercalc--
+ }
+}
+
+/*
+ * when a type's width should be known, we call checkwidth
+ * to compute it. during a declaration like
+ *
+ * type T *struct { next T }
+ *
+ * it is necessary to defer the calculation of the struct width
+ * until after T has been initialized to be a pointer to that struct.
+ * similarly, during import processing structs may be used
+ * before their definition. in those situations, calling
+ * defercheckwidth() stops width calculations until
+ * resumecheckwidth() is called, at which point all the
+ * checkwidths that were deferred are executed.
+ * dowidth should only be called when the type's size
+ * is needed immediately. checkwidth makes sure the
+ * size is evaluated eventually.
+ */
+type TypeList struct {
+ t *Type
+ next *TypeList
+}
+
+var tlfree *TypeList
+
+var tlq *TypeList
+
+func checkwidth(t *Type) {
+ var l *TypeList
+
+ if t == nil {
+ return
+ }
+
+ // function arg structs should not be checked
+ // outside of the enclosing function.
+ if t.Funarg != 0 {
+ Fatal("checkwidth %v", Tconv(t, 0))
+ }
+
+ if !(defercalc != 0) {
+ dowidth(t)
+ return
+ }
+
+ if t.Deferwidth != 0 {
+ return
+ }
+ t.Deferwidth = 1
+
+ l = tlfree
+ if l != nil {
+ tlfree = l.next
+ } else {
+ l = new(TypeList)
+ }
+
+ l.t = t
+ l.next = tlq
+ tlq = l
+}
+
+func defercheckwidth() {
+ // we get out of sync on syntax errors, so don't be pedantic.
+ if defercalc != 0 && nerrors == 0 {
+ Fatal("defercheckwidth")
+ }
+ defercalc = 1
+}
+
+func resumecheckwidth() {
+ var l *TypeList
+
+ if !(defercalc != 0) {
+ Fatal("resumecheckwidth")
+ }
+ for l = tlq; l != nil; l = tlq {
+ l.t.Deferwidth = 0
+ tlq = l.next
+ dowidth(l.t)
+ l.next = tlfree
+ tlfree = l
+ }
+
+ defercalc = 0
+}
+
+func typeinit() {
+ var i int
+ var etype int
+ var sameas int
+ var t *Type
+ var s *Sym
+ var s1 *Sym
+
+ if Widthptr == 0 {
+ Fatal("typeinit before betypeinit")
+ }
+
+ for i = 0; i < NTYPE; i++ {
+ Simtype[i] = uint8(i)
+ }
+
+ Types[TPTR32] = typ(TPTR32)
+ dowidth(Types[TPTR32])
+
+ Types[TPTR64] = typ(TPTR64)
+ dowidth(Types[TPTR64])
+
+ t = typ(TUNSAFEPTR)
+ Types[TUNSAFEPTR] = t
+ t.Sym = Pkglookup("Pointer", unsafepkg)
+ t.Sym.Def = typenod(t)
+
+ dowidth(Types[TUNSAFEPTR])
+
+ Tptr = TPTR32
+ if Widthptr == 8 {
+ Tptr = TPTR64
+ }
+
+ for i = TINT8; i <= TUINT64; i++ {
+ Isint[i] = 1
+ }
+ Isint[TINT] = 1
+ Isint[TUINT] = 1
+ Isint[TUINTPTR] = 1
+
+ Isfloat[TFLOAT32] = 1
+ Isfloat[TFLOAT64] = 1
+
+ Iscomplex[TCOMPLEX64] = 1
+ Iscomplex[TCOMPLEX128] = 1
+
+ Isptr[TPTR32] = 1
+ Isptr[TPTR64] = 1
+
+ isforw[TFORW] = 1
+
+ Issigned[TINT] = 1
+ Issigned[TINT8] = 1
+ Issigned[TINT16] = 1
+ Issigned[TINT32] = 1
+ Issigned[TINT64] = 1
+
+ /*
+ * initialize okfor
+ */
+ for i = 0; i < NTYPE; i++ {
+ if Isint[i] != 0 || i == TIDEAL {
+ okforeq[i] = 1
+ okforcmp[i] = 1
+ okforarith[i] = 1
+ okforadd[i] = 1
+ okforand[i] = 1
+ okforconst[i] = 1
+ issimple[i] = 1
+ Minintval[i] = new(Mpint)
+ Maxintval[i] = new(Mpint)
+ }
+
+ if Isfloat[i] != 0 {
+ okforeq[i] = 1
+ okforcmp[i] = 1
+ okforadd[i] = 1
+ okforarith[i] = 1
+ okforconst[i] = 1
+ issimple[i] = 1
+ minfltval[i] = new(Mpflt)
+ maxfltval[i] = new(Mpflt)
+ }
+
+ if Iscomplex[i] != 0 {
+ okforeq[i] = 1
+ okforadd[i] = 1
+ okforarith[i] = 1
+ okforconst[i] = 1
+ issimple[i] = 1
+ }
+ }
+
+ issimple[TBOOL] = 1
+
+ okforadd[TSTRING] = 1
+
+ okforbool[TBOOL] = 1
+
+ okforcap[TARRAY] = 1
+ okforcap[TCHAN] = 1
+
+ okforconst[TBOOL] = 1
+ okforconst[TSTRING] = 1
+
+ okforlen[TARRAY] = 1
+ okforlen[TCHAN] = 1
+ okforlen[TMAP] = 1
+ okforlen[TSTRING] = 1
+
+ okforeq[TPTR32] = 1
+ okforeq[TPTR64] = 1
+ okforeq[TUNSAFEPTR] = 1
+ okforeq[TINTER] = 1
+ okforeq[TCHAN] = 1
+ okforeq[TSTRING] = 1
+ okforeq[TBOOL] = 1
+ okforeq[TMAP] = 1 // nil only; refined in typecheck
+ okforeq[TFUNC] = 1 // nil only; refined in typecheck
+ okforeq[TARRAY] = 1 // nil slice only; refined in typecheck
+ okforeq[TSTRUCT] = 1 // it's complicated; refined in typecheck
+
+ okforcmp[TSTRING] = 1
+
+ for i = 0; i < len(okfor); i++ {
+ okfor[i] = okfornone[:]
+ }
+
+ // binary
+ okfor[OADD] = okforadd[:]
+
+ okfor[OAND] = okforand[:]
+ okfor[OANDAND] = okforbool[:]
+ okfor[OANDNOT] = okforand[:]
+ okfor[ODIV] = okforarith[:]
+ okfor[OEQ] = okforeq[:]
+ okfor[OGE] = okforcmp[:]
+ okfor[OGT] = okforcmp[:]
+ okfor[OLE] = okforcmp[:]
+ okfor[OLT] = okforcmp[:]
+ okfor[OMOD] = okforand[:]
+ okfor[OMUL] = okforarith[:]
+ okfor[ONE] = okforeq[:]
+ okfor[OOR] = okforand[:]
+ okfor[OOROR] = okforbool[:]
+ okfor[OSUB] = okforarith[:]
+ okfor[OXOR] = okforand[:]
+ okfor[OLSH] = okforand[:]
+ okfor[ORSH] = okforand[:]
+
+ // unary
+ okfor[OCOM] = okforand[:]
+
+ okfor[OMINUS] = okforarith[:]
+ okfor[ONOT] = okforbool[:]
+ okfor[OPLUS] = okforarith[:]
+
+ // special
+ okfor[OCAP] = okforcap[:]
+
+ okfor[OLEN] = okforlen[:]
+
+ // comparison
+ iscmp[OLT] = 1
+
+ iscmp[OGT] = 1
+ iscmp[OGE] = 1
+ iscmp[OLE] = 1
+ iscmp[OEQ] = 1
+ iscmp[ONE] = 1
+
+ mpatofix(Maxintval[TINT8], "0x7f")
+ mpatofix(Minintval[TINT8], "-0x80")
+ mpatofix(Maxintval[TINT16], "0x7fff")
+ mpatofix(Minintval[TINT16], "-0x8000")
+ mpatofix(Maxintval[TINT32], "0x7fffffff")
+ mpatofix(Minintval[TINT32], "-0x80000000")
+ mpatofix(Maxintval[TINT64], "0x7fffffffffffffff")
+ mpatofix(Minintval[TINT64], "-0x8000000000000000")
+
+ mpatofix(Maxintval[TUINT8], "0xff")
+ mpatofix(Maxintval[TUINT16], "0xffff")
+ mpatofix(Maxintval[TUINT32], "0xffffffff")
+ mpatofix(Maxintval[TUINT64], "0xffffffffffffffff")
+
+ /* f is valid float if min < f < max. (min and max are not themselves valid.) */
+ mpatoflt(maxfltval[TFLOAT32], "33554431p103") /* 2^24-1 p (127-23) + 1/2 ulp*/
+ mpatoflt(minfltval[TFLOAT32], "-33554431p103")
+ mpatoflt(maxfltval[TFLOAT64], "18014398509481983p970") /* 2^53-1 p (1023-52) + 1/2 ulp */
+ mpatoflt(minfltval[TFLOAT64], "-18014398509481983p970")
+
+ maxfltval[TCOMPLEX64] = maxfltval[TFLOAT32]
+ minfltval[TCOMPLEX64] = minfltval[TFLOAT32]
+ maxfltval[TCOMPLEX128] = maxfltval[TFLOAT64]
+ minfltval[TCOMPLEX128] = minfltval[TFLOAT64]
+
+ /* for walk to use in error messages */
+ Types[TFUNC] = functype(nil, nil, nil)
+
+ /* types used in front end */
+ // types[TNIL] got set early in lexinit
+ Types[TIDEAL] = typ(TIDEAL)
+
+ Types[TINTER] = typ(TINTER)
+
+ /* simple aliases */
+ Simtype[TMAP] = uint8(Tptr)
+
+ Simtype[TCHAN] = uint8(Tptr)
+ Simtype[TFUNC] = uint8(Tptr)
+ Simtype[TUNSAFEPTR] = uint8(Tptr)
+
+ /* pick up the backend thearch.typedefs */
+ for i = range Thearch.Typedefs {
+ s = Lookup(Thearch.Typedefs[i].Name)
+ s1 = Pkglookup(Thearch.Typedefs[i].Name, builtinpkg)
+
+ etype = Thearch.Typedefs[i].Etype
+ if etype < 0 || etype >= len(Types) {
+ Fatal("typeinit: %s bad etype", s.Name)
+ }
+ sameas = Thearch.Typedefs[i].Sameas
+ if sameas < 0 || sameas >= len(Types) {
+ Fatal("typeinit: %s bad sameas", s.Name)
+ }
+ Simtype[etype] = uint8(sameas)
+ minfltval[etype] = minfltval[sameas]
+ maxfltval[etype] = maxfltval[sameas]
+ Minintval[etype] = Minintval[sameas]
+ Maxintval[etype] = Maxintval[sameas]
+
+ t = Types[etype]
+ if t != nil {
+ Fatal("typeinit: %s already defined", s.Name)
+ }
+
+ t = typ(etype)
+ t.Sym = s1
+
+ dowidth(t)
+ Types[etype] = t
+ s1.Def = typenod(t)
+ }
+
+ Array_array = int(Rnd(0, int64(Widthptr)))
+ Array_nel = int(Rnd(int64(Array_array)+int64(Widthptr), int64(Widthint)))
+ Array_cap = int(Rnd(int64(Array_nel)+int64(Widthint), int64(Widthint)))
+ sizeof_Array = int(Rnd(int64(Array_cap)+int64(Widthint), int64(Widthptr)))
+
+ // string is same as slice wo the cap
+ sizeof_String = int(Rnd(int64(Array_nel)+int64(Widthint), int64(Widthptr)))
+
+ dowidth(Types[TSTRING])
+ dowidth(idealstring)
+}
+
+/*
+ * compute total size of f's in/out arguments.
+ */
+func Argsize(t *Type) int {
+ var save Iter
+ var fp *Type
+ var w int64
+ var x int64
+
+ w = 0
+
+ fp = Structfirst(&save, Getoutarg(t))
+ for fp != nil {
+ x = fp.Width + fp.Type.Width
+ if x > w {
+ w = x
+ }
+ fp = structnext(&save)
+ }
+
+ fp = funcfirst(&save, t)
+ for fp != nil {
+ x = fp.Width + fp.Type.Width
+ if x > w {
+ w = x
+ }
+ fp = funcnext(&save)
+ }
+
+ w = (w + int64(Widthptr) - 1) &^ (int64(Widthptr) - 1)
+ if int64(int(w)) != w {
+ Fatal("argsize too big")
+ }
+ return int(w)
+}
diff --git a/src/cmd/internal/gc/array.go b/src/cmd/internal/gc/array.go
new file mode 100644
index 0000000..0408613
--- /dev/null
+++ b/src/cmd/internal/gc/array.go
@@ -0,0 +1,9 @@
+// Copyright 2013 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
+
+const (
+ DEFAULTCAPACITY = 16
+)
diff --git a/src/cmd/internal/gc/bits.go b/src/cmd/internal/gc/bits.go
new file mode 100644
index 0000000..613e15d
--- /dev/null
+++ b/src/cmd/internal/gc/bits.go
@@ -0,0 +1,167 @@
+// Inferno utils/cc/bits.c
+// http://code.google.com/p/inferno-os/source/browse/utils/cc/bits.c
+//
+// Copyright © 1994-1999 Lucent Technologies Inc. All rights reserved.
+// Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+// Portions Copyright © 1997-1999 Vita Nuova Limited
+// Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
+// Portions Copyright © 2004,2006 Bruce Ellis
+// Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+// Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
+// Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package gc
+
+import "fmt"
+
+/*
+Bits
+bor(Bits a, Bits b)
+{
+ Bits c;
+ int i;
+
+ for(i=0; i<BITS; i++)
+ c.b[i] = a.b[i] | b.b[i];
+ return c;
+}
+
+Bits
+band(Bits a, Bits b)
+{
+ Bits c;
+ int i;
+
+ for(i=0; i<BITS; i++)
+ c.b[i] = a.b[i] & b.b[i];
+ return c;
+}
+
+Bits
+bnot(Bits a)
+{
+ Bits c;
+ int i;
+
+ for(i=0; i<BITS; i++)
+ c.b[i] = ~a.b[i];
+ return c;
+}
+*/
+func bany(a *Bits) int {
+ var i int
+
+ for i = 0; i < BITS; i++ {
+ if a.b[i] != 0 {
+ return 1
+ }
+ }
+ return 0
+}
+
+/*
+int
+beq(Bits a, Bits b)
+{
+ int i;
+
+ for(i=0; i<BITS; i++)
+ if(a.b[i] != b.b[i])
+ return 0;
+ return 1;
+}
+*/
+func bnum(a Bits) int {
+ var i int
+ var b uint64
+
+ for i = 0; i < BITS; i++ {
+ b = a.b[i]
+ if b != 0 {
+ return 64*i + Bitno(b)
+ }
+ }
+
+ Fatal("bad in bnum")
+ return 0
+}
+
+func blsh(n uint) Bits {
+ var c Bits
+
+ c = zbits
+ c.b[n/64] = 1 << (n % 64)
+ return c
+}
+
+func btest(a *Bits, n uint) int {
+ return bool2int(a.b[n/64]&(1<<(n%64)) != 0)
+}
+
+func biset(a *Bits, n uint) {
+ a.b[n/64] |= 1 << (n % 64)
+}
+
+func biclr(a *Bits, n uint) {
+ a.b[n/64] &^= (1 << (n % 64))
+}
+
+func Bitno(b uint64) int {
+ var i int
+
+ for i = 0; i < 64; i++ {
+ if b&(1<<uint(i)) != 0 {
+ return i
+ }
+ }
+ Fatal("bad in bitno")
+ return 0
+}
+
+func Qconv(bits Bits, flag int) string {
+ var fp string
+
+ var i int
+ var first int
+
+ first = 1
+
+ for bany(&bits) != 0 {
+ i = bnum(bits)
+ if first != 0 {
+ first = 0
+ } else {
+ fp += fmt.Sprintf(" ")
+ }
+ if var_[i].node == nil || var_[i].node.Sym == nil {
+ fp += fmt.Sprintf("$%d", i)
+ } else {
+ fp += fmt.Sprintf("%s(%d)", var_[i].node.Sym.Name, i)
+ if var_[i].offset != 0 {
+ fp += fmt.Sprintf("%+d", int64(var_[i].offset))
+ }
+ }
+
+ biclr(&bits, uint(i))
+ }
+
+ return fp
+}
diff --git a/src/cmd/internal/gc/builtin.go b/src/cmd/internal/gc/builtin.go
new file mode 100644
index 0000000..8742d4b
--- /dev/null
+++ b/src/cmd/internal/gc/builtin.go
@@ -0,0 +1,6 @@
+package gc
+
+// AUTO-GENERATED by mkbuiltin; DO NOT EDIT
+var runtimeimport string = "package runtime\n" + "import runtime \"runtime\"\n" + "func @\"\".newobject (@\"\".typ·2 *byte) (? *any)\n" + "func @\"\".panicindex ()\n" + "func @\"\".panicslice ()\n" + "func @\"\".panicdivide ()\n" + "func @\"\".throwreturn ()\n" + "func @\"\".throwinit ()\n" + "func @\"\".panicwrap (? string, ? string, ? string)\n" + "func @\"\".gopanic (? interface {})\n" + "func @\"\".gorecover (? *int32) (? interface {})\n" + "func @\"\".printbool (? bool)\n" + "func @\"\".printfloat (? float64)\n" + "func @\"\".printint (? int64)\n" + "func @\"\".printhex (? uint64)\n" + "func @\"\".printuint (? uint64)\n" + "func @\"\".printcomplex (? complex128)\n" + "func @\"\".printstring (? string)\n" + "func @\"\".printpointer (? any)\n" + "func @\"\".printiface (? any)\n" + "func @\"\".printeface (? any)\n" + "func @\"\".printslice (? any)\n" + "func @\"\".printnl ()\n" + "func @\"\".printsp ()\n" + "func @\"\".printlock ()\n" + "func @\"\".printunlock ()\n" + "func @\"\".concatstring2 (? *[32]byte, ? string, ? string) (? string)\n" + "func @\"\".concatstring3 (? *[32]byte, ? string, ? string, ? string) (? string)\n" + "func @\"\".concatstring4 (? *[32]byte, ? string, ? string, ? string, ? string) (? string)\n" + "func @\"\".concatstring5 (? *[32]byte, ? string, ? string, ? string, ? string, ? string) (? string)\n" + "func @\"\".concatstrings (? *[32]byte, ? []string) (? string)\n" + "func @\"\".cmpstring (? string, ? string) (? int)\n" + "func @\"\".eqstring (? string, ? string) (? bool)\n" + "func @\"\".intstring (? *[4]byte, ? int64) (? string)\n" + "func @\"\".slicebytetostring (? *[32]byte, ? []byte) (? string)\n" + "func @\"\".slicebytetostringtmp (? []byte) (? string)\n" + "func @\"\".slicerunetostring (? *[32]byte, ? []rune) (? string)\n" + "func @\"\".stringtoslicebyte (? *[32]byte, ? string) (? []byte)\n" + "func @\"\".stringtoslicebytetmp (? string) (? []byte)\n" + "func @\"\".stringtoslicerune (? *[32]rune, ? string) (? []rune)\n" + "func @\"\".stringiter (? string, ? int) (? int)\n" + "func @\"\".stringiter2 (? string, ? int) (@\"\".retk·1 int, @\"\".retv·2 rune)\n" + "func @\"\".slicecopy (@\"\".to·2 any, @\"\".fr·3 any, @\"\".wid·4 uintptr) (? int)\n" + "func @\"\".slicestringcopy (@\"\".to·2 any, @\"\".fr·3 any) (? int)\n" + "func @\"\".typ2Itab (@\"\".typ·2 *byte, @\"\".typ2·3 *byte, @\"\".cache·4 **byte) (@\"\".ret·1 *byte)\n" + "func @\"\".convI2E (@\"\".elem·2 any) (@\"\".ret·1 any)\n" + "func @\"\".convI2I (@\"\".typ·2 *byte, @\"\".elem·3 any) (@\"\".ret·1 any)\n" + "func @\"\".convT2E (@\"\".typ·2 *byte, @\"\".elem·3 *any) (@\"\".ret·1 any)\n" + "func @\"\".convT2I (@\"\".typ·2 *byte, @\"\".typ2·3 *byte, @\"\".cache·4 **byte, @\"\".elem·5 *any) (@\"\".ret·1 any)\n" + "func @\"\".assertE2E (@\"\".typ·1 *byte, @\"\".iface·2 any, @\"\".ret·3 *any)\n" + "func @\"\".assertE2E2 (@\"\".typ·2 *byte, @\"\".iface·3 any, @\"\".ret·4 *any) (? bool)\n" + "func @\"\".assertE2I (@\"\".typ·1 *byte, @\"\".iface·2 any, @\"\".ret·3 *any)\n" + "func @\"\".assertE2I2 (@\"\".typ·2 *byte, @\"\".iface·3 any, @\"\".ret·4 *any) (? bool)\n" + "func @\"\".assertE2T (@\"\".typ·1 *byte, @\"\".iface·2 any, @\"\".ret·3 *any)\n" + "func @\"\".assertE2T2 (@\"\".typ·2 *byte, @\"\".iface·3 any, @\"\".ret·4 *any) (? bool)\n" + "func @\"\".assertI2E (@\"\".typ·1 *byte, @\"\".iface·2 any, @\"\".ret·3 *any)\n" + "func @\"\".assertI2E2 (@\"\".typ·2 *byte, @\"\".iface·3 any, @\"\".ret·4 *any) (? bool)\n" + "func @\"\".assertI2I (@\"\".typ·1 *byte, @\"\".iface·2 any, @\"\".ret·3 *any)\n" + "func @\"\".assertI2I2 (@\"\".typ·2 *byte, @\"\".iface·3 any, @\"\".ret·4 *any) (? bool)\n" + "func @\"\".assertI2T (@\"\".typ·1 *byte, @\"\".iface·2 any, @\"\".ret·3 *any)\n" + "func @\"\".assertI2T2 (@\"\".typ·2 *byte, @\"\".iface·3 any, @\"\".ret·4 *any) (? bool)\n" + "func @\"\".ifaceeq (@\"\".i1·2 any, @\"\".i2·3 any) (@\"\".ret·1 bool)\n" + "func @\"\".efaceeq (@\"\".i1·2 any, @\"\".i2·3 any) (@\"\".ret·1 bool)\n" + "func @\"\".ifacethash (@\"\".i1·2 any) (@\"\".ret·1 uint32)\n" + "func @\"\".efacethash (@\"\".i1·2 any) (@\"\".ret·1 uint32)\n" + "func @\"\".makemap (@\"\".mapType·2 *byte, @\"\".hint·3 int64, @\"\".mapbuf·4 *any, @\"\".bucketbuf·5 *any) (@\"\".hmap·1 map[any]any)\n" + "func @\"\".mapaccess1 (@\"\".mapType·2 *byte, @\"\".hmap·3 map[any]any, @\"\".key·4 *any) (@\"\".val·1 *any)\n" + "func @\"\".mapaccess1_fast32 (@\"\".mapType·2 *byte, @\"\".hmap·3 map[any]any, @\"\".key·4 any) (@\"\".val·1 *any)\n" + "func @\"\".mapaccess1_fast64 (@\"\".mapType·2 *byte, @\"\".hmap·3 map[any]any, @\"\".key·4 any) (@\"\".val·1 *any)\n" + "func @\"\".mapaccess1_faststr (@\"\".mapType·2 *byte, @\"\".hmap·3 map[any]any, @\"\".key·4 any) (@\"\".val·1 *any)\n" + "func @\"\".mapaccess2 (@\"\".mapType·3 *byte, @\"\".hmap·4 map[any]any, @\"\".key·5 *any) (@\"\".val·1 *any, @\"\".pres·2 bool)\n" + "func @\"\".mapaccess2_fast32 (@\"\".mapType·3 *byte, @\"\".hmap·4 map[any]any, @\"\".key·5 any) (@\"\".val·1 *any, @\"\".pres·2 bool)\n" + "func @\"\".mapaccess2_fast64 (@\"\".mapType·3 *byte, @\"\".hmap·4 map[any]any, @\"\".key·5 any) (@\"\".val·1 *any, @\"\".pres·2 bool)\n" + "func @\"\".mapaccess2_faststr (@\"\".mapType·3 *byte, @\"\".hmap·4 map[any]any, @\"\".key·5 any) (@\"\".val·1 *any, @\"\".pres·2 bool)\n" + "func @\"\".mapassign1 (@\"\".mapType·1 *byte, @\"\".hmap·2 map[any]any, @\"\".key·3 *any, @\"\".val·4 *any)\n" + "func @\"\".mapiterinit (@\"\".mapType·1 *byte, @\"\".hmap·2 map[any]any, @\"\".hiter·3 *any)\n" + "func @\"\".mapdelete (@\"\".mapType·1 *byte, @\"\".hmap·2 map[any]any, @\"\".key·3 *any)\n" + "func @\"\".mapiternext (@\"\".hiter·1 *any)\n" + "func @\"\".makechan (@\"\".chanType·2 *byte, @\"\".hint·3 int64) (@\"\".hchan·1 chan any)\n" + "func @\"\".chanrecv1 (@\"\".chanType·1 *byte, @\"\".hchan·2 <-chan any, @\"\".elem·3 *any)\n" + "func @\"\".chanrecv2 (@\"\".chanType·2 *byte, @\"\".hchan·3 <-chan any, @\"\".elem·4 *any) (? bool)\n" + "func @\"\".chansend1 (@\"\".chanType·1 *byte, @\"\".hchan·2 chan<- any, @\"\".elem·3 *any)\n" + "func @\"\".closechan (@\"\".hchan·1 any)\n" + "func @\"\".writebarrierptr (@\"\".dst·1 *any, @\"\".src·2 any)\n" + "func @\"\".writebarrierstring (@\"\".dst·1 *any, @\"\".src·2 any)\n" + "func @\"\".writebarrierslice (@\"\".dst·1 *any, @\"\".src·2 any)\n" + "func @\"\".writebarrieriface (@\"\".dst·1 *any, @\"\".src·2 any)\n" + "func @\"\".writebarrierfat01 (@\"\".dst·1 *any, _ *byte, @\"\".src·3 any)\n" + "func @\"\".writebarrierfat10 (@\"\".dst·1 *any, _ *byte, @\"\".src·3 any)\n" + "func @\"\".writebarrierfat11 (@\"\".dst·1 *any, _ *byte, @\"\".src·3 any)\n" + "func @\"\".writebarrierfat001 (@\"\".dst·1 *any, _ *byte, @\"\".src·3 any)\n" + "func @\"\".writebarrierfat010 (@\"\".dst·1 *any, _ *byte, @\"\".src·3 any)\n" + "func @\"\".writebarrierfat011 (@\"\".dst·1 *any, _ *byte, @\"\".src·3 any)\n" + "func @\"\".writebarrierfat100 (@\"\".dst·1 *any, _ *byte, @\"\".src·3 any)\n" + "func @\"\".writebarrierfat101 (@\"\".dst·1 *any, _ *byte, @\"\".src·3 any)\n" + "func @\"\".writebarrierfat110 (@\"\".dst·1 *any, _ *byte, @\"\".src·3 any)\n" + "func @\"\".writebarrierfat111 (@\"\".dst·1 *any, _ *byte, @\"\".src·3 any)\n" + "func @\"\".writebarrierfat0001 (@\"\".dst·1 *any, _ *byte, @\"\".src·3 any)\n" + "func @\"\".writebarrierfat0010 (@\"\".dst·1 *any, _ *byte, @\"\".src·3 any)\n" + "func @\"\".writebarrierfat0011 (@\"\".dst·1 *any, _ *byte, @\"\".src·3 any)\n" + "func @\"\".writebarrierfat0100 (@\"\".dst·1 *any, _ *byte, @\"\".src·3 any)\n" + "func @\"\".writebarrierfat0101 (@\"\".dst·1 *any, _ *byte, @\"\".src·3 any)\n" + "func @\"\".writebarrierfat0110 (@\"\".dst·1 *any, _ *byte, @\"\".src·3 any)\n" + "func @\"\".writebarrierfat0111 (@\"\".dst·1 *any, _ *byte, @\"\".src·3 any)\n" + "func @\"\".writebarrierfat1000 (@\"\".dst·1 *any, _ *byte, @\"\".src·3 any)\n" + "func @\"\".writebarrierfat1001 (@\"\".dst·1 *any, _ *byte, @\"\".src·3 any)\n" + "func @\"\".writebarrierfat1010 (@\"\".dst·1 *any, _ *byte, @\"\".src·3 any)\n" + "func @\"\".writebarrierfat1011 (@\"\".dst·1 *any, _ *byte, @\"\".src·3 any)\n" + "func @\"\".writebarrierfat1100 (@\"\".dst·1 *any, _ *byte, @\"\".src·3 any)\n" + "func @\"\".writebarrierfat1101 (@\"\".dst·1 *any, _ *byte, @\"\".src·3 any)\n" + "func @\"\".writebarrierfat1110 (@\"\".dst·1 *any, _ *byte, @\"\".src·3 any)\n" + "func @\"\".writebarrierfat1111 (@\"\".dst·1 *any, _ *byte, @\"\".src·3 any)\n" + "func @\"\".typedmemmove (@\"\".typ·1 *byte, @\"\".dst·2 *any, @\"\".src·3 *any)\n" + "func @\"\".typedslicecopy (@\"\".typ·2 *byte, @\"\".dst·3 any, @\"\".src·4 any) (? int)\n" + "func @\"\".selectnbsend (@\"\".chanType·2 *byte, @\"\".hchan·3 chan<- any, @\"\".elem·4 *any) (? bool)\n" + "func @\"\".selectnbrecv (@\"\".chanType·2 *byte, @\"\".elem·3 *any, @\"\".hchan·4 <-chan any) (? bool)\n" + "func @\"\".selectnbrecv2 (@\"\".chanType·2 *byte, @\"\".elem·3 *any, @\"\".received·4 *bool, @\"\".hchan·5 <-chan any) (? bool)\n" + "func @\"\".newselect (@\"\".sel·1 *byte, @\"\".selsize·2 int64, @\"\".size·3 int32)\n" + "func @\"\".selectsend (@\"\".sel·2 *byte, @\"\".hchan·3 chan<- any, @\"\".elem·4 *any) (@\"\".selected·1 bool)\n" + "func @\"\".selectrecv (@\"\".sel·2 *byte, @\"\".hchan·3 <-chan any, @\"\".elem·4 *any) (@\"\".selected·1 bool)\n" + "func @\"\".selectrecv2 (@\"\".sel·2 *byte, @\"\".hchan·3 <-chan any, @\"\".elem·4 *any, @\"\".received·5 *bool) (@\"\".selected·1 bool)\n" + "func @\"\".selectdefault (@\"\".sel·2 *byte) (@\"\".selected·1 bool)\n" + "func @\"\".selectgo (@\"\".sel·1 *byte)\n" + "func @\"\".block ()\n" + "func @\"\".makeslice (@\"\".typ·2 *byte, @\"\".nel·3 int64, @\"\".cap·4 int64) (@\"\".ary·1 []any)\n" + "func @\"\".growslice (@\"\".typ·2 *byte, @\"\".old·3 []any, @\"\".n·4 int64) (@\"\".ary·1 []any)\n" + "func @\"\".memmove (@\"\".to·1 *any, @\"\".frm·2 *any, @\"\".length·3 uintptr)\n" + "func @\"\".memclr (@\"\".ptr·1 *byte, @\"\".length·2 uintptr)\n" + "func @\"\".memequal (@\"\".x·2 *any, @\"\".y·3 *any, @\"\".size·4 uintptr) (? bool)\n" + "func @\"\".memequal8 (@\"\".x·2 *any, @\"\".y·3 *any) (? bool)\n" + "func @\"\".memequal16 (@\"\".x·2 *any, @\"\".y·3 *any) (? bool)\n" + "func @\"\".memequal32 (@\"\".x·2 *any, @\"\".y·3 *any) (? bool)\n" + "func @\"\".memequal64 (@\"\".x·2 *any, @\"\".y·3 *any) (? bool)\n" + "func @\"\".memequal128 (@\"\".x·2 *any, @\"\".y·3 *any) (? bool)\n" + "func @\"\".int64div (? int64, ? int64) (? int64)\n" + "func @\"\".uint64div (? uint64, ? uint64) (? uint64)\n" + "func @\"\".int64mod (? int64, ? int64) (? int64)\n" + "func @\"\".uint64mod (? uint64, ? uint64) (? uint64)\n" + "func @\"\".float64toint64 (? float64) (? int64)\n" + "func @\"\".float64touint64 (? float64) (? uint64)\n" + "func @\"\".int64tofloat64 (? int64) (? float64)\n" + "func @\"\".uint64tofloat64 (? uint64) (? float64)\n" + "func @\"\".complex128div (@\"\".num·2 complex128, @\"\".den·3 complex128) (@\"\".quo·1 complex128)\n" + "func @\"\".racefuncenter (? uintptr)\n" + "func @\"\".racefuncexit ()\n" + "func @\"\".raceread (? uintptr)\n" + "func @\"\".racewrite (? uintptr)\n" + "func @\"\".racereadrange (@\"\".addr·1 uintptr, @\"\".size·2 uintptr)\n" + "func @\"\".racewriterange (@\"\".addr·1 uintptr, @\"\".size·2 uintptr)\n" + "\n" + "$$\n"
+
+var unsafeimport string = "package unsafe\n" + "import runtime \"runtime\"\n" + "type @\"\".Pointer uintptr\n" + "func @\"\".Offsetof (? any) (? uintptr)\n" + "func @\"\".Sizeof (? any) (? uintptr)\n" + "func @\"\".Alignof (? any) (? uintptr)\n" + "\n" + "$$\n"
diff --git a/src/cmd/internal/gc/bv.go b/src/cmd/internal/gc/bv.go
new file mode 100644
index 0000000..998a1f5
--- /dev/null
+++ b/src/cmd/internal/gc/bv.go
@@ -0,0 +1,208 @@
+// Copyright 2013 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
+
+import "fmt"
+
+const (
+ WORDSIZE = 4
+ WORDBITS = 32
+ WORDMASK = WORDBITS - 1
+ WORDSHIFT = 5
+)
+
+func bvsize(n uint32) uint32 {
+ return ((n + WORDBITS - 1) / WORDBITS) * WORDSIZE
+}
+
+func bvbits(bv *Bvec) int32 {
+ return bv.n
+}
+
+func bvwords(bv *Bvec) int32 {
+ return (bv.n + WORDBITS - 1) / WORDBITS
+}
+
+func bvalloc(n int32) *Bvec {
+ return &Bvec{n, make([]uint32, bvsize(uint32(n))/4)}
+}
+
+/* difference */
+func bvandnot(dst *Bvec, src1 *Bvec, src2 *Bvec) {
+ var i int32
+ var w int32
+
+ if dst.n != src1.n || dst.n != src2.n {
+ Fatal("bvand: lengths %d, %d, and %d are not equal", dst.n, src1.n, src2.n)
+ }
+ i = 0
+ w = 0
+ for ; i < dst.n; (func() { i += WORDBITS; w++ })() {
+ dst.b[w] = src1.b[w] &^ src2.b[w]
+ }
+}
+
+func bvcmp(bv1 *Bvec, bv2 *Bvec) int {
+ if bv1.n != bv2.n {
+ Fatal("bvequal: lengths %d and %d are not equal", bv1.n, bv2.n)
+ }
+ for i, x := range bv1.b {
+ if x != bv2.b[i] {
+ return 1
+ }
+ }
+ return 0
+}
+
+func bvcopy(dst *Bvec, src *Bvec) {
+ for i, x := range src.b {
+ dst.b[i] = x
+ }
+}
+
+func bvconcat(src1 *Bvec, src2 *Bvec) *Bvec {
+ var dst *Bvec
+ var i int32
+
+ dst = bvalloc(src1.n + src2.n)
+ for i = 0; i < src1.n; i++ {
+ if bvget(src1, i) != 0 {
+ bvset(dst, i)
+ }
+ }
+ for i = 0; i < src2.n; i++ {
+ if bvget(src2, i) != 0 {
+ bvset(dst, i+src1.n)
+ }
+ }
+ return dst
+}
+
+func bvget(bv *Bvec, i int32) int {
+ if i < 0 || i >= bv.n {
+ Fatal("bvget: index %d is out of bounds with length %d\n", i, bv.n)
+ }
+ return int((bv.b[i>>WORDSHIFT] >> uint(i&WORDMASK)) & 1)
+}
+
+// bvnext returns the smallest index >= i for which bvget(bv, i) == 1.
+// If there is no such index, bvnext returns -1.
+func bvnext(bv *Bvec, i int32) int {
+ var w uint32
+
+ if i >= bv.n {
+ return -1
+ }
+
+ // Jump i ahead to next word with bits.
+ if bv.b[i>>WORDSHIFT]>>uint(i&WORDMASK) == 0 {
+ i &^= WORDMASK
+ i += WORDBITS
+ for i < bv.n && bv.b[i>>WORDSHIFT] == 0 {
+ i += WORDBITS
+ }
+ }
+
+ if i >= bv.n {
+ return -1
+ }
+
+ // Find 1 bit.
+ w = bv.b[i>>WORDSHIFT] >> uint(i&WORDMASK)
+
+ for w&1 == 0 {
+ w >>= 1
+ i++
+ }
+
+ return int(i)
+}
+
+func bvisempty(bv *Bvec) int {
+ var i int32
+
+ for i = 0; i < bv.n; i += WORDBITS {
+ if bv.b[i>>WORDSHIFT] != 0 {
+ return 0
+ }
+ }
+ return 1
+}
+
+func bvnot(bv *Bvec) {
+ var i int32
+ var w int32
+
+ i = 0
+ w = 0
+ for ; i < bv.n; (func() { i += WORDBITS; w++ })() {
+ bv.b[w] = ^bv.b[w]
+ }
+}
+
+/* union */
+func bvor(dst *Bvec, src1 *Bvec, src2 *Bvec) {
+ var i int32
+ var w int32
+
+ if dst.n != src1.n || dst.n != src2.n {
+ Fatal("bvor: lengths %d, %d, and %d are not equal", dst.n, src1.n, src2.n)
+ }
+ i = 0
+ w = 0
+ for ; i < dst.n; (func() { i += WORDBITS; w++ })() {
+ dst.b[w] = src1.b[w] | src2.b[w]
+ }
+}
+
+/* intersection */
+func bvand(dst *Bvec, src1 *Bvec, src2 *Bvec) {
+ var i int32
+ var w int32
+
+ if dst.n != src1.n || dst.n != src2.n {
+ Fatal("bvor: lengths %d, %d, and %d are not equal", dst.n, src1.n, src2.n)
+ }
+ i = 0
+ w = 0
+ for ; i < dst.n; (func() { i += WORDBITS; w++ })() {
+ dst.b[w] = src1.b[w] & src2.b[w]
+ }
+}
+
+func bvprint(bv *Bvec) {
+ var i int32
+
+ fmt.Printf("#*")
+ for i = 0; i < bv.n; i++ {
+ fmt.Printf("%d", bvget(bv, i))
+ }
+}
+
+func bvreset(bv *Bvec, i int32) {
+ var mask uint32
+
+ if i < 0 || i >= bv.n {
+ Fatal("bvreset: index %d is out of bounds with length %d\n", i, bv.n)
+ }
+ mask = ^(1 << uint(i%WORDBITS))
+ bv.b[i/WORDBITS] &= mask
+}
+
+func bvresetall(bv *Bvec) {
+ for i := range bv.b {
+ bv.b[i] = 0
+ }
+}
+
+func bvset(bv *Bvec, i int32) {
+ var mask uint32
+
+ if i < 0 || i >= bv.n {
+ Fatal("bvset: index %d is out of bounds with length %d\n", i, bv.n)
+ }
+ mask = 1 << uint(i%WORDBITS)
+ bv.b[i/WORDBITS] |= mask
+}
diff --git a/src/cmd/internal/gc/closure.go b/src/cmd/internal/gc/closure.go
new file mode 100644
index 0000000..5a1ae65
--- /dev/null
+++ b/src/cmd/internal/gc/closure.go
@@ -0,0 +1,696 @@
+// 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
+
+import (
+ "cmd/internal/obj"
+ "fmt"
+)
+
+/*
+ * function literals aka closures
+ */
+func closurehdr(ntype *Node) {
+ var n *Node
+ var name *Node
+ var a *Node
+ var l *NodeList
+
+ n = Nod(OCLOSURE, nil, nil)
+ n.Ntype = ntype
+ n.Funcdepth = Funcdepth
+
+ funchdr(n)
+
+ // steal ntype's argument names and
+ // leave a fresh copy in their place.
+ // references to these variables need to
+ // refer to the variables in the external
+ // function declared below; see walkclosure.
+ n.List = ntype.List
+
+ n.Rlist = ntype.Rlist
+ ntype.List = nil
+ ntype.Rlist = nil
+ for l = n.List; l != nil; l = l.Next {
+ name = l.N.Left
+ if name != nil {
+ name = newname(name.Sym)
+ }
+ a = Nod(ODCLFIELD, name, l.N.Right)
+ a.Isddd = l.N.Isddd
+ if name != nil {
+ name.Isddd = a.Isddd
+ }
+ ntype.List = list(ntype.List, a)
+ }
+
+ for l = n.Rlist; l != nil; l = l.Next {
+ name = l.N.Left
+ if name != nil {
+ name = newname(name.Sym)
+ }
+ ntype.Rlist = list(ntype.Rlist, Nod(ODCLFIELD, name, l.N.Right))
+ }
+}
+
+func closurebody(body *NodeList) *Node {
+ var func_ *Node
+ var v *Node
+ var l *NodeList
+
+ if body == nil {
+ body = list1(Nod(OEMPTY, nil, nil))
+ }
+
+ func_ = Curfn
+ func_.Nbody = body
+ func_.Endlineno = lineno
+ funcbody(func_)
+
+ // closure-specific variables are hanging off the
+ // ordinary ones in the symbol table; see oldname.
+ // unhook them.
+ // make the list of pointers for the closure call.
+ for l = func_.Cvars; l != nil; l = l.Next {
+ v = l.N
+ v.Closure.Closure = v.Outer
+ v.Outerexpr = oldname(v.Sym)
+ }
+
+ return func_
+}
+
+func typecheckclosure(func_ *Node, top int) {
+ var oldfn *Node
+ var n *Node
+ var l *NodeList
+ var olddd int
+
+ for l = func_.Cvars; l != nil; l = l.Next {
+ n = l.N.Closure
+ if !(n.Captured != 0) {
+ n.Captured = 1
+ if n.Decldepth == 0 {
+ Fatal("typecheckclosure: var %v does not have decldepth assigned", Nconv(n, obj.FmtShort))
+ }
+
+ // Ignore assignments to the variable in straightline code
+ // preceding the first capturing by a closure.
+ if n.Decldepth == decldepth {
+ n.Assigned = 0
+ }
+ }
+ }
+
+ for l = func_.Dcl; l != nil; l = l.Next {
+ if l.N.Op == ONAME && (l.N.Class == PPARAM || l.N.Class == PPARAMOUT) {
+ l.N.Decldepth = 1
+ }
+ }
+
+ oldfn = Curfn
+ typecheck(&func_.Ntype, Etype)
+ func_.Type = func_.Ntype.Type
+ func_.Top = top
+
+ // Type check the body now, but only if we're inside a function.
+ // At top level (in a variable initialization: curfn==nil) we're not
+ // ready to type check code yet; we'll check it later, because the
+ // underlying closure function we create is added to xtop.
+ if Curfn != nil && func_.Type != nil {
+ Curfn = func_
+ olddd = decldepth
+ decldepth = 1
+ typechecklist(func_.Nbody, Etop)
+ decldepth = olddd
+ Curfn = oldfn
+ }
+
+ // Create top-level function
+ xtop = list(xtop, makeclosure(func_))
+}
+
+var makeclosure_closgen int
+
+func makeclosure(func_ *Node) *Node {
+ var xtype *Node
+ var xfunc *Node
+
+ /*
+ * wrap body in external function
+ * that begins by reading closure parameters.
+ */
+ xtype = Nod(OTFUNC, nil, nil)
+
+ xtype.List = func_.List
+ xtype.Rlist = func_.Rlist
+
+ // create the function
+ xfunc = Nod(ODCLFUNC, nil, nil)
+
+ makeclosure_closgen++
+ namebuf = fmt.Sprintf("func·%.3d", makeclosure_closgen)
+ xfunc.Nname = newname(Lookup(namebuf))
+ xfunc.Nname.Sym.Flags |= SymExported // disable export
+ xfunc.Nname.Ntype = xtype
+ xfunc.Nname.Defn = xfunc
+ declare(xfunc.Nname, PFUNC)
+ xfunc.Nname.Funcdepth = func_.Funcdepth
+ xfunc.Funcdepth = func_.Funcdepth
+ xfunc.Endlineno = func_.Endlineno
+
+ xfunc.Nbody = func_.Nbody
+ xfunc.Dcl = concat(func_.Dcl, xfunc.Dcl)
+ if xfunc.Nbody == nil {
+ Fatal("empty body - won't generate any code")
+ }
+ typecheck(&xfunc, Etop)
+
+ xfunc.Closure = func_
+ func_.Closure = xfunc
+
+ func_.Nbody = nil
+ func_.List = nil
+ func_.Rlist = nil
+
+ return xfunc
+}
+
+// capturevars is called in a separate phase after all typechecking is done.
+// It decides whether each variable captured by a closure should be captured
+// by value or by reference.
+// We use value capturing for values <= 128 bytes that are never reassigned
+// after capturing (effectively constant).
+func capturevars(xfunc *Node) {
+ var func_ *Node
+ var v *Node
+ var outer *Node
+ var l *NodeList
+ var lno int
+
+ lno = int(lineno)
+ lineno = xfunc.Lineno
+
+ func_ = xfunc.Closure
+ func_.Enter = nil
+ for l = func_.Cvars; l != nil; l = l.Next {
+ v = l.N
+ if v.Type == nil {
+ // if v->type is nil, it means v looked like it was
+ // going to be used in the closure but wasn't.
+ // this happens because when parsing a, b, c := f()
+ // the a, b, c gets parsed as references to older
+ // a, b, c before the parser figures out this is a
+ // declaration.
+ v.Op = OXXX
+
+ continue
+ }
+
+ // type check the & of closed variables outside the closure,
+ // so that the outer frame also grabs them and knows they escape.
+ dowidth(v.Type)
+
+ outer = v.Outerexpr
+ v.Outerexpr = nil
+
+ // out parameters will be assigned to implicitly upon return.
+ if outer.Class != PPARAMOUT && !(v.Closure.Addrtaken != 0) && !(v.Closure.Assigned != 0) && v.Type.Width <= 128 {
+ v.Byval = 1
+ } else {
+ v.Closure.Addrtaken = 1
+ outer = Nod(OADDR, outer, nil)
+ }
+
+ if Debug['m'] > 1 {
+ var name *Sym
+ var how string
+ name = nil
+ if v.Curfn != nil && v.Curfn.Nname != nil {
+ name = v.Curfn.Nname.Sym
+ }
+ how = "ref"
+ if v.Byval != 0 {
+ how = "value"
+ }
+ Warnl(int(v.Lineno), "%v capturing by %s: %v (addr=%d assign=%d width=%d)", Sconv(name, 0), how, Sconv(v.Sym, 0), v.Closure.Addrtaken, v.Closure.Assigned, int32(v.Type.Width))
+ }
+
+ typecheck(&outer, Erv)
+ func_.Enter = list(func_.Enter, outer)
+ }
+
+ lineno = int32(lno)
+}
+
+// transformclosure is called in a separate phase after escape analysis.
+// It transform closure bodies to properly reference captured variables.
+func transformclosure(xfunc *Node) {
+ var func_ *Node
+ var cv *Node
+ var addr *Node
+ var v *Node
+ var f *Node
+ var l *NodeList
+ var body *NodeList
+ var param **Type
+ var fld *Type
+ var offset int64
+ var lno int
+ var nvar int
+
+ lno = int(lineno)
+ lineno = xfunc.Lineno
+ func_ = xfunc.Closure
+
+ if func_.Top&Ecall != 0 {
+ // If the closure is directly called, we transform it to a plain function call
+ // with variables passed as args. This avoids allocation of a closure object.
+ // Here we do only a part of the transformation. Walk of OCALLFUNC(OCLOSURE)
+ // will complete the transformation later.
+ // For illustration, the following closure:
+ // func(a int) {
+ // println(byval)
+ // byref++
+ // }(42)
+ // becomes:
+ // func(a int, byval int, &byref *int) {
+ // println(byval)
+ // (*&byref)++
+ // }(42, byval, &byref)
+
+ // f is ONAME of the actual function.
+ f = xfunc.Nname
+
+ // Get pointer to input arguments and rewind to the end.
+ // We are going to append captured variables to input args.
+ param = &getinargx(f.Type).Type
+
+ for ; *param != nil; param = &(*param).Down {
+ }
+ for l = func_.Cvars; l != nil; l = l.Next {
+ v = l.N
+ if v.Op == OXXX {
+ continue
+ }
+ fld = typ(TFIELD)
+ fld.Funarg = 1
+ if v.Byval != 0 {
+ // If v is captured by value, we merely downgrade it to PPARAM.
+ v.Class = PPARAM
+
+ v.Ullman = 1
+ fld.Nname = v
+ } else {
+ // If v of type T is captured by reference,
+ // we introduce function param &v *T
+ // and v remains PPARAMREF with &v heapaddr
+ // (accesses will implicitly deref &v).
+ namebuf = fmt.Sprintf("&%s", v.Sym.Name)
+
+ addr = newname(Lookup(namebuf))
+ addr.Type = Ptrto(v.Type)
+ addr.Class = PPARAM
+ v.Heapaddr = addr
+ fld.Nname = addr
+ }
+
+ fld.Type = fld.Nname.Type
+ fld.Sym = fld.Nname.Sym
+
+ // Declare the new param and append it to input arguments.
+ xfunc.Dcl = list(xfunc.Dcl, fld.Nname)
+
+ *param = fld
+ param = &fld.Down
+ }
+
+ // Recalculate param offsets.
+ if f.Type.Width > 0 {
+ Fatal("transformclosure: width is already calculated")
+ }
+ dowidth(f.Type)
+ xfunc.Type = f.Type // update type of ODCLFUNC
+ } else {
+ // The closure is not called, so it is going to stay as closure.
+ nvar = 0
+
+ body = nil
+ offset = int64(Widthptr)
+ for l = func_.Cvars; l != nil; l = l.Next {
+ v = l.N
+ if v.Op == OXXX {
+ continue
+ }
+ nvar++
+
+ // cv refers to the field inside of closure OSTRUCTLIT.
+ cv = Nod(OCLOSUREVAR, nil, nil)
+
+ cv.Type = v.Type
+ if !(v.Byval != 0) {
+ cv.Type = Ptrto(v.Type)
+ }
+ offset = Rnd(offset, int64(cv.Type.Align))
+ cv.Xoffset = offset
+ offset += cv.Type.Width
+
+ if v.Byval != 0 && v.Type.Width <= int64(2*Widthptr) && Thearch.Thechar == '6' {
+ // If it is a small variable captured by value, downgrade it to PAUTO.
+ // This optimization is currently enabled only for amd64, see:
+ // https://github.com/golang/go/issues/9865
+ v.Class = PAUTO
+
+ v.Ullman = 1
+ xfunc.Dcl = list(xfunc.Dcl, v)
+ body = list(body, Nod(OAS, v, cv))
+ } else {
+ // Declare variable holding addresses taken from closure
+ // and initialize in entry prologue.
+ namebuf = fmt.Sprintf("&%s", v.Sym.Name)
+
+ addr = newname(Lookup(namebuf))
+ addr.Ntype = Nod(OIND, typenod(v.Type), nil)
+ addr.Class = PAUTO
+ addr.Used = 1
+ addr.Curfn = xfunc
+ xfunc.Dcl = list(xfunc.Dcl, addr)
+ v.Heapaddr = addr
+ if v.Byval != 0 {
+ cv = Nod(OADDR, cv, nil)
+ }
+ body = list(body, Nod(OAS, addr, cv))
+ }
+ }
+
+ typechecklist(body, Etop)
+ walkstmtlist(body)
+ xfunc.Enter = body
+ xfunc.Needctxt = uint8(bool2int(nvar > 0))
+ }
+
+ lineno = int32(lno)
+}
+
+func walkclosure(func_ *Node, init **NodeList) *Node {
+ var clos *Node
+ var typ *Node
+ var typ1 *Node
+ var v *Node
+ var l *NodeList
+
+ // If no closure vars, don't bother wrapping.
+ if func_.Cvars == nil {
+ return func_.Closure.Nname
+ }
+
+ // Create closure in the form of a composite literal.
+ // supposing the closure captures an int i and a string s
+ // and has one float64 argument and no results,
+ // the generated code looks like:
+ //
+ // clos = &struct{F uintptr; A0 *int; A1 *string}{func·001, &i, &s}
+ //
+ // The use of the struct provides type information to the garbage
+ // collector so that it can walk the closure. We could use (in this case)
+ // [3]unsafe.Pointer instead, but that would leave the gc in the dark.
+ // The information appears in the binary in the form of type descriptors;
+ // 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.List = list1(Nod(ODCLFIELD, newname(Lookup("F")), typenod(Types[TUINTPTR])))
+ for l = func_.Cvars; l != nil; l = l.Next {
+ v = l.N
+ if v.Op == OXXX {
+ continue
+ }
+ typ1 = typenod(v.Type)
+ if !(v.Byval != 0) {
+ typ1 = Nod(OIND, typ1, nil)
+ }
+ typ.List = list(typ.List, Nod(ODCLFIELD, newname(v.Sym), typ1))
+ }
+
+ clos = Nod(OCOMPLIT, nil, Nod(OIND, typ, nil))
+ clos.Esc = func_.Esc
+ clos.Right.Implicit = 1
+ clos.List = concat(list1(Nod(OCFUNC, func_.Closure.Nname, nil)), func_.Enter)
+
+ // Force type conversion from *struct to the func type.
+ clos = Nod(OCONVNOP, clos, nil)
+
+ clos.Type = func_.Type
+
+ typecheck(&clos, Erv)
+
+ // typecheck will insert a PTRLIT node under CONVNOP,
+ // tag it with escape analysis result.
+ clos.Left.Esc = func_.Esc
+
+ // non-escaping temp to use, if any.
+ // orderexpr did not compute the type; fill it in now.
+ if func_.Alloc != nil {
+ func_.Alloc.Type = clos.Left.Left.Type
+ func_.Alloc.Orig.Type = func_.Alloc.Type
+ clos.Left.Right = func_.Alloc
+ func_.Alloc = nil
+ }
+
+ walkexpr(&clos, init)
+
+ return clos
+}
+
+func typecheckpartialcall(fn *Node, sym *Node) {
+ switch fn.Op {
+ case ODOTINTER,
+ ODOTMETH:
+ break
+
+ default:
+ Fatal("invalid typecheckpartialcall")
+ }
+
+ // Create top-level function.
+ fn.Nname = makepartialcall(fn, fn.Type, sym)
+
+ fn.Right = sym
+ fn.Op = OCALLPART
+ fn.Type = fn.Nname.Type
+}
+
+var makepartialcall_gopkg *Pkg
+
+func makepartialcall(fn *Node, t0 *Type, meth *Node) *Node {
+ var ptr *Node
+ var n *Node
+ var fld *Node
+ var call *Node
+ var xtype *Node
+ var xfunc *Node
+ var cv *Node
+ var savecurfn *Node
+ var rcvrtype *Type
+ var basetype *Type
+ var t *Type
+ var body *NodeList
+ var l *NodeList
+ var callargs *NodeList
+ var retargs *NodeList
+ var p string
+ var sym *Sym
+ var spkg *Pkg
+ var i int
+ var ddd int
+
+ // TODO: names are not right
+ rcvrtype = fn.Left.Type
+
+ if exportname(meth.Sym.Name) {
+ p = fmt.Sprintf("%v.%s·fm", Tconv(rcvrtype, obj.FmtLeft|obj.FmtShort), meth.Sym.Name)
+ } else {
+ p = fmt.Sprintf("%v.(%v)·fm", Tconv(rcvrtype, obj.FmtLeft|obj.FmtShort), Sconv(meth.Sym, obj.FmtLeft))
+ }
+ basetype = rcvrtype
+ if Isptr[rcvrtype.Etype] != 0 {
+ basetype = basetype.Type
+ }
+ if basetype.Etype != TINTER && basetype.Sym == nil {
+ Fatal("missing base type for %v", Tconv(rcvrtype, 0))
+ }
+
+ spkg = nil
+ if basetype.Sym != nil {
+ spkg = basetype.Sym.Pkg
+ }
+ if spkg == nil {
+ if makepartialcall_gopkg == nil {
+ makepartialcall_gopkg = mkpkg(newstrlit("go"))
+ }
+ spkg = makepartialcall_gopkg
+ }
+
+ sym = Pkglookup(p, spkg)
+
+ if sym.Flags&SymUniq != 0 {
+ return sym.Def
+ }
+ sym.Flags |= SymUniq
+
+ savecurfn = Curfn
+ Curfn = nil
+
+ xtype = Nod(OTFUNC, nil, nil)
+ i = 0
+ l = nil
+ callargs = nil
+ ddd = 0
+ xfunc = Nod(ODCLFUNC, nil, nil)
+ Curfn = xfunc
+ for t = getinargx(t0).Type; t != nil; t = t.Down {
+ namebuf = fmt.Sprintf("a%d", i)
+ i++
+ n = newname(Lookup(namebuf))
+ n.Class = PPARAM
+ xfunc.Dcl = list(xfunc.Dcl, n)
+ callargs = list(callargs, n)
+ fld = Nod(ODCLFIELD, n, typenod(t.Type))
+ if t.Isddd != 0 {
+ fld.Isddd = 1
+ ddd = 1
+ }
+
+ l = list(l, fld)
+ }
+
+ xtype.List = l
+ i = 0
+ l = nil
+ retargs = nil
+ for t = getoutargx(t0).Type; t != nil; t = t.Down {
+ namebuf = fmt.Sprintf("r%d", i)
+ i++
+ n = newname(Lookup(namebuf))
+ n.Class = PPARAMOUT
+ xfunc.Dcl = list(xfunc.Dcl, n)
+ retargs = list(retargs, n)
+ l = list(l, Nod(ODCLFIELD, n, typenod(t.Type)))
+ }
+
+ xtype.Rlist = l
+
+ xfunc.Dupok = 1
+ xfunc.Nname = newname(sym)
+ xfunc.Nname.Sym.Flags |= SymExported // disable export
+ xfunc.Nname.Ntype = xtype
+ xfunc.Nname.Defn = xfunc
+ declare(xfunc.Nname, PFUNC)
+
+ // Declare and initialize variable holding receiver.
+ body = nil
+
+ xfunc.Needctxt = 1
+ 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.Sym = Lookup("rcvr")
+ ptr.Class = PAUTO
+ ptr.Addable = 1
+ ptr.Ullman = 1
+ ptr.Used = 1
+ ptr.Curfn = xfunc
+ xfunc.Dcl = list(xfunc.Dcl, ptr)
+ if Isptr[rcvrtype.Etype] != 0 || Isinter(rcvrtype) != 0 {
+ ptr.Ntype = typenod(rcvrtype)
+ body = list(body, Nod(OAS, ptr, cv))
+ } else {
+ ptr.Ntype = typenod(Ptrto(rcvrtype))
+ body = list(body, Nod(OAS, ptr, Nod(OADDR, cv, nil)))
+ }
+
+ call = Nod(OCALL, Nod(OXDOT, ptr, meth), nil)
+ call.List = callargs
+ call.Isddd = uint8(ddd)
+ if t0.Outtuple == 0 {
+ body = list(body, call)
+ } else {
+ n = Nod(OAS2, nil, nil)
+ n.List = retargs
+ n.Rlist = list1(call)
+ body = list(body, n)
+ n = Nod(ORETURN, nil, nil)
+ body = list(body, n)
+ }
+
+ xfunc.Nbody = body
+
+ typecheck(&xfunc, Etop)
+ sym.Def = xfunc
+ xtop = list(xtop, xfunc)
+ Curfn = savecurfn
+
+ return xfunc
+}
+
+func walkpartialcall(n *Node, init **NodeList) *Node {
+ var clos *Node
+ var typ *Node
+
+ // Create closure in the form of a composite literal.
+ // For x.M with receiver (x) type T, the generated code looks like:
+ //
+ // clos = &struct{F uintptr; R T}{M.T·f, x}
+ //
+ // Like walkclosure above.
+
+ if Isinter(n.Left.Type) != 0 {
+ // Trigger panic for method on nil interface now.
+ // Otherwise it happens in the wrapper and is confusing.
+ n.Left = cheapexpr(n.Left, init)
+
+ checknil(n.Left, init)
+ }
+
+ typ = Nod(OTSTRUCT, nil, nil)
+ typ.List = list1(Nod(ODCLFIELD, newname(Lookup("F")), typenod(Types[TUINTPTR])))
+ typ.List = list(typ.List, Nod(ODCLFIELD, newname(Lookup("R")), typenod(n.Left.Type)))
+
+ clos = Nod(OCOMPLIT, nil, Nod(OIND, typ, nil))
+ clos.Esc = n.Esc
+ clos.Right.Implicit = 1
+ clos.List = list1(Nod(OCFUNC, n.Nname.Nname, nil))
+ clos.List = list(clos.List, n.Left)
+
+ // Force type conversion from *struct to the func type.
+ clos = Nod(OCONVNOP, clos, nil)
+
+ clos.Type = n.Type
+
+ typecheck(&clos, Erv)
+
+ // typecheck will insert a PTRLIT node under CONVNOP,
+ // tag it with escape analysis result.
+ clos.Left.Esc = n.Esc
+
+ // non-escaping temp to use, if any.
+ // orderexpr did not compute the type; fill it in now.
+ if n.Alloc != nil {
+ n.Alloc.Type = clos.Left.Left.Type
+ n.Alloc.Orig.Type = n.Alloc.Type
+ clos.Left.Right = n.Alloc
+ n.Alloc = nil
+ }
+
+ walkexpr(&clos, init)
+
+ return clos
+}
diff --git a/src/cmd/internal/gc/const.go b/src/cmd/internal/gc/const.go
new file mode 100644
index 0000000..c8c244b
--- /dev/null
+++ b/src/cmd/internal/gc/const.go
@@ -0,0 +1,1764 @@
+// 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
+
+import "cmd/internal/obj"
+
+/*
+ * truncate float literal fv to 32-bit or 64-bit precision
+ * according to type; return truncated value.
+ */
+func truncfltlit(oldv *Mpflt, t *Type) *Mpflt {
+ var d float64
+ var fv *Mpflt
+ var v Val
+
+ if t == nil {
+ return oldv
+ }
+
+ v = Val{}
+ v.Ctype = CTFLT
+ v.U.Fval = oldv
+ overflow(v, t)
+
+ fv = new(Mpflt)
+ *fv = *oldv
+
+ // convert large precision literal floating
+ // into limited precision (float64 or float32)
+ switch t.Etype {
+ case TFLOAT64:
+ d = mpgetflt(fv)
+ Mpmovecflt(fv, d)
+
+ case TFLOAT32:
+ d = mpgetflt32(fv)
+ Mpmovecflt(fv, d)
+ }
+
+ return fv
+}
+
+/*
+ * convert n, if literal, to type t.
+ * implicit conversion.
+ */
+func Convlit(np **Node, t *Type) {
+ convlit1(np, t, 0)
+}
+
+/*
+ * convert n, if literal, to type t.
+ * return a new node if necessary
+ * (if n is a named constant, can't edit n->type directly).
+ */
+func convlit1(np **Node, t *Type, explicit int) {
+ var ct int
+ var et int
+ var n *Node
+ var nn *Node
+
+ n = *np
+ if n == nil || t == nil || n.Type == nil || isideal(t) != 0 || n.Type == t {
+ return
+ }
+ if !(explicit != 0) && !(isideal(n.Type) != 0) {
+ return
+ }
+
+ if n.Op == OLITERAL {
+ nn = Nod(OXXX, nil, nil)
+ *nn = *n
+ n = nn
+ *np = n
+ }
+
+ switch n.Op {
+ default:
+ if n.Type == idealbool {
+ if t.Etype == TBOOL {
+ n.Type = t
+ } else {
+ n.Type = Types[TBOOL]
+ }
+ }
+
+ if n.Type.Etype == TIDEAL {
+ Convlit(&n.Left, t)
+ Convlit(&n.Right, t)
+ n.Type = t
+ }
+
+ return
+
+ // target is invalid type for a constant? leave alone.
+ case OLITERAL:
+ if !(okforconst[t.Etype] != 0) && n.Type.Etype != TNIL {
+ defaultlit(&n, nil)
+ *np = n
+ return
+ }
+
+ case OLSH,
+ ORSH:
+ convlit1(&n.Left, t, bool2int(explicit != 0 && isideal(n.Left.Type) != 0))
+ t = n.Left.Type
+ if t != nil && t.Etype == TIDEAL && n.Val.Ctype != CTINT {
+ n.Val = toint(n.Val)
+ }
+ if t != nil && !(Isint[t.Etype] != 0) {
+ Yyerror("invalid operation: %v (shift of type %v)", Nconv(n, 0), Tconv(t, 0))
+ t = nil
+ }
+
+ n.Type = t
+ return
+
+ case OCOMPLEX:
+ if n.Type.Etype == TIDEAL {
+ switch t.Etype {
+ // If trying to convert to non-complex type,
+ // leave as complex128 and let typechecker complain.
+ default:
+ t = Types[TCOMPLEX128]
+ fallthrough
+
+ //fallthrough
+ case TCOMPLEX128:
+ n.Type = t
+
+ Convlit(&n.Left, Types[TFLOAT64])
+ Convlit(&n.Right, Types[TFLOAT64])
+
+ case TCOMPLEX64:
+ n.Type = t
+ Convlit(&n.Left, Types[TFLOAT32])
+ Convlit(&n.Right, Types[TFLOAT32])
+ }
+ }
+
+ return
+ }
+
+ // avoided repeated calculations, errors
+ if Eqtype(n.Type, t) {
+ return
+ }
+
+ ct = consttype(n)
+ if ct < 0 {
+ goto bad
+ }
+
+ et = int(t.Etype)
+ if et == TINTER {
+ if ct == CTNIL && n.Type == Types[TNIL] {
+ n.Type = t
+ return
+ }
+
+ defaultlit(np, nil)
+ return
+ }
+
+ switch ct {
+ default:
+ goto bad
+
+ case CTNIL:
+ switch et {
+ default:
+ n.Type = nil
+ goto bad
+
+ // let normal conversion code handle it
+ case TSTRING:
+ return
+
+ case TARRAY:
+ if !(Isslice(t) != 0) {
+ goto bad
+ }
+
+ case TPTR32,
+ TPTR64,
+ TINTER,
+ TMAP,
+ TCHAN,
+ TFUNC,
+ TUNSAFEPTR:
+ break
+
+ // A nil literal may be converted to uintptr
+ // if it is an unsafe.Pointer
+ case TUINTPTR:
+ if n.Type.Etype == TUNSAFEPTR {
+ n.Val.U.Xval = new(Mpint)
+ Mpmovecfix(n.Val.U.Xval, 0)
+ n.Val.Ctype = CTINT
+ } else {
+ goto bad
+ }
+ }
+
+ case CTSTR,
+ CTBOOL:
+ if et != int(n.Type.Etype) {
+ goto bad
+ }
+
+ case CTINT,
+ CTRUNE,
+ CTFLT,
+ CTCPLX:
+ ct = int(n.Val.Ctype)
+ if Isint[et] != 0 {
+ switch ct {
+ default:
+ goto bad
+
+ case CTCPLX,
+ CTFLT,
+ CTRUNE:
+ n.Val = toint(n.Val)
+ fallthrough
+
+ // flowthrough
+ case CTINT:
+ overflow(n.Val, t)
+ }
+ } else if Isfloat[et] != 0 {
+ switch ct {
+ default:
+ goto bad
+
+ case CTCPLX,
+ CTINT,
+ CTRUNE:
+ n.Val = toflt(n.Val)
+ fallthrough
+
+ // flowthrough
+ case CTFLT:
+ n.Val.U.Fval = truncfltlit(n.Val.U.Fval, t)
+ }
+ } else if Iscomplex[et] != 0 {
+ switch ct {
+ default:
+ goto bad
+
+ case CTFLT,
+ CTINT,
+ CTRUNE:
+ n.Val = tocplx(n.Val)
+
+ case CTCPLX:
+ overflow(n.Val, t)
+ }
+ } else if et == TSTRING && (ct == CTINT || ct == CTRUNE) && explicit != 0 {
+ n.Val = tostr(n.Val)
+ } else {
+ goto bad
+ }
+ }
+
+ n.Type = t
+ return
+
+bad:
+ if !(n.Diag != 0) {
+ if !(t.Broke != 0) {
+ Yyerror("cannot convert %v to type %v", Nconv(n, 0), Tconv(t, 0))
+ }
+ n.Diag = 1
+ }
+
+ if isideal(n.Type) != 0 {
+ defaultlit(&n, nil)
+ *np = n
+ }
+
+ return
+}
+
+func copyval(v Val) Val {
+ var i *Mpint
+ var f *Mpflt
+ var c *Mpcplx
+
+ switch v.Ctype {
+ case CTINT,
+ CTRUNE:
+ i = new(Mpint)
+ mpmovefixfix(i, v.U.Xval)
+ v.U.Xval = i
+
+ case CTFLT:
+ f = new(Mpflt)
+ mpmovefltflt(f, v.U.Fval)
+ v.U.Fval = f
+
+ case CTCPLX:
+ c = new(Mpcplx)
+ mpmovefltflt(&c.Real, &v.U.Cval.Real)
+ mpmovefltflt(&c.Imag, &v.U.Cval.Imag)
+ v.U.Cval = c
+ }
+
+ return v
+}
+
+func tocplx(v Val) Val {
+ var c *Mpcplx
+
+ switch v.Ctype {
+ case CTINT,
+ CTRUNE:
+ c = new(Mpcplx)
+ Mpmovefixflt(&c.Real, v.U.Xval)
+ Mpmovecflt(&c.Imag, 0.0)
+ v.Ctype = CTCPLX
+ v.U.Cval = c
+
+ case CTFLT:
+ c = new(Mpcplx)
+ mpmovefltflt(&c.Real, v.U.Fval)
+ Mpmovecflt(&c.Imag, 0.0)
+ v.Ctype = CTCPLX
+ v.U.Cval = c
+ }
+
+ return v
+}
+
+func toflt(v Val) Val {
+ var f *Mpflt
+
+ switch v.Ctype {
+ case CTINT,
+ CTRUNE:
+ f = new(Mpflt)
+ Mpmovefixflt(f, v.U.Xval)
+ v.Ctype = CTFLT
+ v.U.Fval = f
+
+ case CTCPLX:
+ f = new(Mpflt)
+ mpmovefltflt(f, &v.U.Cval.Real)
+ if mpcmpfltc(&v.U.Cval.Imag, 0) != 0 {
+ Yyerror("constant %v%vi truncated to real", Fconv(&v.U.Cval.Real, obj.FmtSharp), Fconv(&v.U.Cval.Imag, obj.FmtSharp|obj.FmtSign))
+ }
+ v.Ctype = CTFLT
+ v.U.Fval = f
+ }
+
+ return v
+}
+
+func toint(v Val) Val {
+ var i *Mpint
+
+ switch v.Ctype {
+ case CTRUNE:
+ v.Ctype = CTINT
+
+ case CTFLT:
+ i = new(Mpint)
+ if mpmovefltfix(i, v.U.Fval) < 0 {
+ Yyerror("constant %v truncated to integer", Fconv(v.U.Fval, obj.FmtSharp))
+ }
+ v.Ctype = CTINT
+ v.U.Xval = i
+
+ case CTCPLX:
+ i = new(Mpint)
+ if mpmovefltfix(i, &v.U.Cval.Real) < 0 {
+ Yyerror("constant %v%vi truncated to integer", Fconv(&v.U.Cval.Real, obj.FmtSharp), Fconv(&v.U.Cval.Imag, obj.FmtSharp|obj.FmtSign))
+ }
+ if mpcmpfltc(&v.U.Cval.Imag, 0) != 0 {
+ Yyerror("constant %v%vi truncated to real", Fconv(&v.U.Cval.Real, obj.FmtSharp), Fconv(&v.U.Cval.Imag, obj.FmtSharp|obj.FmtSign))
+ }
+ v.Ctype = CTINT
+ v.U.Xval = i
+ }
+
+ return v
+}
+
+func doesoverflow(v Val, t *Type) int {
+ switch v.Ctype {
+ case CTINT,
+ CTRUNE:
+ if !(Isint[t.Etype] != 0) {
+ Fatal("overflow: %v integer constant", Tconv(t, 0))
+ }
+ if Mpcmpfixfix(v.U.Xval, Minintval[t.Etype]) < 0 || Mpcmpfixfix(v.U.Xval, Maxintval[t.Etype]) > 0 {
+ return 1
+ }
+
+ case CTFLT:
+ if !(Isfloat[t.Etype] != 0) {
+ Fatal("overflow: %v floating-point constant", Tconv(t, 0))
+ }
+ if mpcmpfltflt(v.U.Fval, minfltval[t.Etype]) <= 0 || mpcmpfltflt(v.U.Fval, maxfltval[t.Etype]) >= 0 {
+ return 1
+ }
+
+ case CTCPLX:
+ if !(Iscomplex[t.Etype] != 0) {
+ Fatal("overflow: %v complex constant", Tconv(t, 0))
+ }
+ if mpcmpfltflt(&v.U.Cval.Real, minfltval[t.Etype]) <= 0 || mpcmpfltflt(&v.U.Cval.Real, maxfltval[t.Etype]) >= 0 || mpcmpfltflt(&v.U.Cval.Imag, minfltval[t.Etype]) <= 0 || mpcmpfltflt(&v.U.Cval.Imag, maxfltval[t.Etype]) >= 0 {
+ return 1
+ }
+ }
+
+ return 0
+}
+
+func overflow(v Val, t *Type) {
+ // v has already been converted
+ // to appropriate form for t.
+ if t == nil || t.Etype == TIDEAL {
+ return
+ }
+
+ if !(doesoverflow(v, t) != 0) {
+ return
+ }
+
+ switch v.Ctype {
+ case CTINT,
+ CTRUNE:
+ Yyerror("constant %v overflows %v", Bconv(v.U.Xval, 0), Tconv(t, 0))
+
+ case CTFLT:
+ Yyerror("constant %v overflows %v", Fconv(v.U.Fval, obj.FmtSharp), Tconv(t, 0))
+
+ case CTCPLX:
+ Yyerror("constant %v overflows %v", Fconv(v.U.Fval, obj.FmtSharp), Tconv(t, 0))
+ }
+}
+
+func tostr(v Val) Val {
+ var rune_ uint
+ var s *Strlit
+
+ switch v.Ctype {
+ case CTINT,
+ CTRUNE:
+ if Mpcmpfixfix(v.U.Xval, Minintval[TINT]) < 0 || Mpcmpfixfix(v.U.Xval, Maxintval[TINT]) > 0 {
+ Yyerror("overflow in int -> string")
+ }
+ rune_ = uint(Mpgetfix(v.U.Xval))
+ s = &Strlit{S: string(rune_)}
+ v = Val{}
+ v.Ctype = CTSTR
+ v.U.Sval = s
+
+ case CTFLT:
+ Yyerror("no float -> string")
+ fallthrough
+
+ case CTNIL:
+ v = Val{}
+ v.Ctype = CTSTR
+ v.U.Sval = new(Strlit)
+ }
+
+ return v
+}
+
+func consttype(n *Node) int {
+ if n == nil || n.Op != OLITERAL {
+ return -1
+ }
+ return int(n.Val.Ctype)
+}
+
+func Isconst(n *Node, ct int) int {
+ var t int
+
+ t = consttype(n)
+
+ // If the caller is asking for CTINT, allow CTRUNE too.
+ // Makes life easier for back ends.
+ return bool2int(t == ct || (ct == CTINT && t == CTRUNE))
+}
+
+func saveorig(n *Node) *Node {
+ var n1 *Node
+
+ if n == n.Orig {
+ // duplicate node for n->orig.
+ n1 = Nod(OLITERAL, nil, nil)
+
+ n.Orig = n1
+ *n1 = *n
+ }
+
+ return n.Orig
+}
+
+/*
+ * if n is constant, rewrite as OLITERAL node.
+ */
+func evconst(n *Node) {
+ var nl *Node
+ var nr *Node
+ var norig *Node
+ var str *Strlit
+ var wl int
+ var wr int
+ var lno int
+ var et int
+ var v Val
+ var rv Val
+ var b Mpint
+ var l1 *NodeList
+ var l2 *NodeList
+
+ // pick off just the opcodes that can be
+ // constant evaluated.
+ switch n.Op {
+ default:
+ return
+
+ case OADD,
+ OAND,
+ OANDAND,
+ OANDNOT,
+ OARRAYBYTESTR,
+ OCOM,
+ ODIV,
+ OEQ,
+ OGE,
+ OGT,
+ OLE,
+ OLSH,
+ OLT,
+ OMINUS,
+ OMOD,
+ OMUL,
+ ONE,
+ ONOT,
+ OOR,
+ OOROR,
+ OPLUS,
+ ORSH,
+ OSUB,
+ OXOR:
+ break
+
+ case OCONV:
+ if n.Type == nil {
+ return
+ }
+ if !(okforconst[n.Type.Etype] != 0) && n.Type.Etype != TNIL {
+ return
+ }
+
+ // merge adjacent constants in the argument list.
+ case OADDSTR:
+ for l1 = n.List; l1 != nil; l1 = l1.Next {
+ if Isconst(l1.N, CTSTR) != 0 && l1.Next != nil && Isconst(l1.Next.N, CTSTR) != 0 {
+ // merge from l1 up to but not including l2
+ str = new(Strlit)
+ l2 = l1
+ for l2 != nil && Isconst(l2.N, CTSTR) != 0 {
+ nr = l2.N
+ str.S += nr.Val.U.Sval.S
+ l2 = l2.Next
+ }
+
+ nl = Nod(OXXX, nil, nil)
+ *nl = *l1.N
+ nl.Orig = nl
+ nl.Val.Ctype = CTSTR
+ nl.Val.U.Sval = str
+ l1.N = nl
+ l1.Next = l2
+ }
+ }
+
+ // fix list end pointer.
+ for l2 = n.List; l2 != nil; l2 = l2.Next {
+ n.List.End = l2
+ }
+
+ // collapse single-constant list to single constant.
+ if count(n.List) == 1 && Isconst(n.List.N, CTSTR) != 0 {
+ n.Op = OLITERAL
+ n.Val = n.List.N.Val
+ }
+
+ return
+ }
+
+ nl = n.Left
+ if nl == nil || nl.Type == nil {
+ return
+ }
+ if consttype(nl) < 0 {
+ return
+ }
+ wl = int(nl.Type.Etype)
+ if Isint[wl] != 0 || Isfloat[wl] != 0 || Iscomplex[wl] != 0 {
+ wl = TIDEAL
+ }
+
+ nr = n.Right
+ if nr == nil {
+ goto unary
+ }
+ if nr.Type == nil {
+ return
+ }
+ if consttype(nr) < 0 {
+ return
+ }
+ wr = int(nr.Type.Etype)
+ if Isint[wr] != 0 || Isfloat[wr] != 0 || Iscomplex[wr] != 0 {
+ wr = TIDEAL
+ }
+
+ // check for compatible general types (numeric, string, etc)
+ if wl != wr {
+ goto illegal
+ }
+
+ // check for compatible types.
+ switch n.Op {
+ // ideal const mixes with anything but otherwise must match.
+ default:
+ if nl.Type.Etype != TIDEAL {
+ defaultlit(&nr, nl.Type)
+ n.Right = nr
+ }
+
+ if nr.Type.Etype != TIDEAL {
+ defaultlit(&nl, nr.Type)
+ n.Left = nl
+ }
+
+ if nl.Type.Etype != nr.Type.Etype {
+ goto illegal
+ }
+
+ // right must be unsigned.
+ // left can be ideal.
+ case OLSH,
+ ORSH:
+ defaultlit(&nr, Types[TUINT])
+
+ n.Right = nr
+ if nr.Type != nil && (Issigned[nr.Type.Etype] != 0 || !(Isint[nr.Type.Etype] != 0)) {
+ goto illegal
+ }
+ if nl.Val.Ctype != CTRUNE {
+ nl.Val = toint(nl.Val)
+ }
+ nr.Val = toint(nr.Val)
+ }
+
+ // copy numeric value to avoid modifying
+ // n->left, in case someone still refers to it (e.g. iota).
+ v = nl.Val
+
+ if wl == TIDEAL {
+ v = copyval(v)
+ }
+
+ rv = nr.Val
+
+ // convert to common ideal
+ if v.Ctype == CTCPLX || rv.Ctype == CTCPLX {
+ v = tocplx(v)
+ rv = tocplx(rv)
+ }
+
+ if v.Ctype == CTFLT || rv.Ctype == CTFLT {
+ v = toflt(v)
+ rv = toflt(rv)
+ }
+
+ // Rune and int turns into rune.
+ if v.Ctype == CTRUNE && rv.Ctype == CTINT {
+ rv.Ctype = CTRUNE
+ }
+ if v.Ctype == CTINT && rv.Ctype == CTRUNE {
+ if n.Op == OLSH || n.Op == ORSH {
+ rv.Ctype = CTINT
+ } else {
+ v.Ctype = CTRUNE
+ }
+ }
+
+ if v.Ctype != rv.Ctype {
+ // Use of undefined name as constant?
+ if (v.Ctype == 0 || rv.Ctype == 0) && nerrors > 0 {
+ return
+ }
+ Fatal("constant type mismatch %v(%d) %v(%d)", Tconv(nl.Type, 0), v.Ctype, Tconv(nr.Type, 0), rv.Ctype)
+ }
+
+ // run op
+ switch uint32(n.Op)<<16 | uint32(v.Ctype) {
+ default:
+ goto illegal
+
+ case OADD<<16 | CTINT,
+ OADD<<16 | CTRUNE:
+ mpaddfixfix(v.U.Xval, rv.U.Xval, 0)
+
+ case OSUB<<16 | CTINT,
+ OSUB<<16 | CTRUNE:
+ mpsubfixfix(v.U.Xval, rv.U.Xval)
+
+ case OMUL<<16 | CTINT,
+ OMUL<<16 | CTRUNE:
+ mpmulfixfix(v.U.Xval, rv.U.Xval)
+
+ case ODIV<<16 | CTINT,
+ ODIV<<16 | CTRUNE:
+ if mpcmpfixc(rv.U.Xval, 0) == 0 {
+ Yyerror("division by zero")
+ Mpmovecfix(v.U.Xval, 1)
+ break
+ }
+
+ mpdivfixfix(v.U.Xval, rv.U.Xval)
+
+ case OMOD<<16 | CTINT,
+ OMOD<<16 | CTRUNE:
+ if mpcmpfixc(rv.U.Xval, 0) == 0 {
+ Yyerror("division by zero")
+ Mpmovecfix(v.U.Xval, 1)
+ break
+ }
+
+ mpmodfixfix(v.U.Xval, rv.U.Xval)
+
+ case OLSH<<16 | CTINT,
+ OLSH<<16 | CTRUNE:
+ mplshfixfix(v.U.Xval, rv.U.Xval)
+
+ case ORSH<<16 | CTINT,
+ ORSH<<16 | CTRUNE:
+ mprshfixfix(v.U.Xval, rv.U.Xval)
+
+ case OOR<<16 | CTINT,
+ OOR<<16 | CTRUNE:
+ mporfixfix(v.U.Xval, rv.U.Xval)
+
+ case OAND<<16 | CTINT,
+ OAND<<16 | CTRUNE:
+ mpandfixfix(v.U.Xval, rv.U.Xval)
+
+ case OANDNOT<<16 | CTINT,
+ OANDNOT<<16 | CTRUNE:
+ mpandnotfixfix(v.U.Xval, rv.U.Xval)
+
+ case OXOR<<16 | CTINT,
+ OXOR<<16 | CTRUNE:
+ mpxorfixfix(v.U.Xval, rv.U.Xval)
+
+ case OADD<<16 | CTFLT:
+ mpaddfltflt(v.U.Fval, rv.U.Fval)
+
+ case OSUB<<16 | CTFLT:
+ mpsubfltflt(v.U.Fval, rv.U.Fval)
+
+ case OMUL<<16 | CTFLT:
+ mpmulfltflt(v.U.Fval, rv.U.Fval)
+
+ case ODIV<<16 | CTFLT:
+ if mpcmpfltc(rv.U.Fval, 0) == 0 {
+ Yyerror("division by zero")
+ Mpmovecflt(v.U.Fval, 1.0)
+ break
+ }
+
+ mpdivfltflt(v.U.Fval, rv.U.Fval)
+
+ // The default case above would print 'ideal % ideal',
+ // which is not quite an ideal error.
+ case OMOD<<16 | CTFLT:
+ if !(n.Diag != 0) {
+ Yyerror("illegal constant expression: floating-point % operation")
+ n.Diag = 1
+ }
+
+ return
+
+ case OADD<<16 | CTCPLX:
+ mpaddfltflt(&v.U.Cval.Real, &rv.U.Cval.Real)
+ mpaddfltflt(&v.U.Cval.Imag, &rv.U.Cval.Imag)
+
+ case OSUB<<16 | CTCPLX:
+ mpsubfltflt(&v.U.Cval.Real, &rv.U.Cval.Real)
+ mpsubfltflt(&v.U.Cval.Imag, &rv.U.Cval.Imag)
+
+ case OMUL<<16 | CTCPLX:
+ cmplxmpy(v.U.Cval, rv.U.Cval)
+
+ case ODIV<<16 | CTCPLX:
+ if mpcmpfltc(&rv.U.Cval.Real, 0) == 0 && mpcmpfltc(&rv.U.Cval.Imag, 0) == 0 {
+ Yyerror("complex division by zero")
+ Mpmovecflt(&rv.U.Cval.Real, 1.0)
+ Mpmovecflt(&rv.U.Cval.Imag, 0.0)
+ break
+ }
+
+ cmplxdiv(v.U.Cval, rv.U.Cval)
+
+ case OEQ<<16 | CTNIL:
+ goto settrue
+
+ case ONE<<16 | CTNIL:
+ goto setfalse
+
+ case OEQ<<16 | CTINT,
+ OEQ<<16 | CTRUNE:
+ if Mpcmpfixfix(v.U.Xval, rv.U.Xval) == 0 {
+ goto settrue
+ }
+ goto setfalse
+
+ case ONE<<16 | CTINT,
+ ONE<<16 | CTRUNE:
+ if Mpcmpfixfix(v.U.Xval, rv.U.Xval) != 0 {
+ goto settrue
+ }
+ goto setfalse
+
+ case OLT<<16 | CTINT,
+ OLT<<16 | CTRUNE:
+ if Mpcmpfixfix(v.U.Xval, rv.U.Xval) < 0 {
+ goto settrue
+ }
+ goto setfalse
+
+ case OLE<<16 | CTINT,
+ OLE<<16 | CTRUNE:
+ if Mpcmpfixfix(v.U.Xval, rv.U.Xval) <= 0 {
+ goto settrue
+ }
+ goto setfalse
+
+ case OGE<<16 | CTINT,
+ OGE<<16 | CTRUNE:
+ if Mpcmpfixfix(v.U.Xval, rv.U.Xval) >= 0 {
+ goto settrue
+ }
+ goto setfalse
+
+ case OGT<<16 | CTINT,
+ OGT<<16 | CTRUNE:
+ if Mpcmpfixfix(v.U.Xval, rv.U.Xval) > 0 {
+ goto settrue
+ }
+ goto setfalse
+
+ case OEQ<<16 | CTFLT:
+ if mpcmpfltflt(v.U.Fval, rv.U.Fval) == 0 {
+ goto settrue
+ }
+ goto setfalse
+
+ case ONE<<16 | CTFLT:
+ if mpcmpfltflt(v.U.Fval, rv.U.Fval) != 0 {
+ goto settrue
+ }
+ goto setfalse
+
+ case OLT<<16 | CTFLT:
+ if mpcmpfltflt(v.U.Fval, rv.U.Fval) < 0 {
+ goto settrue
+ }
+ goto setfalse
+
+ case OLE<<16 | CTFLT:
+ if mpcmpfltflt(v.U.Fval, rv.U.Fval) <= 0 {
+ goto settrue
+ }
+ goto setfalse
+
+ case OGE<<16 | CTFLT:
+ if mpcmpfltflt(v.U.Fval, rv.U.Fval) >= 0 {
+ goto settrue
+ }
+ goto setfalse
+
+ case OGT<<16 | CTFLT:
+ if mpcmpfltflt(v.U.Fval, rv.U.Fval) > 0 {
+ goto settrue
+ }
+ goto setfalse
+
+ case OEQ<<16 | CTCPLX:
+ if mpcmpfltflt(&v.U.Cval.Real, &rv.U.Cval.Real) == 0 && mpcmpfltflt(&v.U.Cval.Imag, &rv.U.Cval.Imag) == 0 {
+ goto settrue
+ }
+ goto setfalse
+
+ case ONE<<16 | CTCPLX:
+ if mpcmpfltflt(&v.U.Cval.Real, &rv.U.Cval.Real) != 0 || mpcmpfltflt(&v.U.Cval.Imag, &rv.U.Cval.Imag) != 0 {
+ goto settrue
+ }
+ goto setfalse
+
+ case OEQ<<16 | CTSTR:
+ if cmpslit(nl, nr) == 0 {
+ goto settrue
+ }
+ goto setfalse
+
+ case ONE<<16 | CTSTR:
+ if cmpslit(nl, nr) != 0 {
+ goto settrue
+ }
+ goto setfalse
+
+ case OLT<<16 | CTSTR:
+ if cmpslit(nl, nr) < 0 {
+ goto settrue
+ }
+ goto setfalse
+
+ case OLE<<16 | CTSTR:
+ if cmpslit(nl, nr) <= 0 {
+ goto settrue
+ }
+ goto setfalse
+
+ case OGE<<16 | CTSTR:
+ if cmpslit(nl, nr) >= 0 {
+ goto settrue
+ }
+ goto setfalse
+
+ case OGT<<16 | CTSTR:
+ if cmpslit(nl, nr) > 0 {
+ goto settrue
+ }
+ goto setfalse
+
+ case OOROR<<16 | CTBOOL:
+ if v.U.Bval != 0 || rv.U.Bval != 0 {
+ goto settrue
+ }
+ goto setfalse
+
+ case OANDAND<<16 | CTBOOL:
+ if v.U.Bval != 0 && rv.U.Bval != 0 {
+ goto settrue
+ }
+ goto setfalse
+
+ case OEQ<<16 | CTBOOL:
+ if v.U.Bval == rv.U.Bval {
+ goto settrue
+ }
+ goto setfalse
+
+ case ONE<<16 | CTBOOL:
+ if v.U.Bval != rv.U.Bval {
+ goto settrue
+ }
+ goto setfalse
+ }
+
+ goto ret
+
+ // copy numeric value to avoid modifying
+ // nl, in case someone still refers to it (e.g. iota).
+unary:
+ v = nl.Val
+
+ if wl == TIDEAL {
+ v = copyval(v)
+ }
+
+ switch uint32(n.Op)<<16 | uint32(v.Ctype) {
+ default:
+ if !(n.Diag != 0) {
+ Yyerror("illegal constant expression %v %v", Oconv(int(n.Op), 0), Tconv(nl.Type, 0))
+ n.Diag = 1
+ }
+
+ return
+
+ case OCONV<<16 | CTNIL,
+ OARRAYBYTESTR<<16 | CTNIL:
+ if n.Type.Etype == TSTRING {
+ v = tostr(v)
+ nl.Type = n.Type
+ break
+ }
+ fallthrough
+
+ // fall through
+ case OCONV<<16 | CTINT,
+ OCONV<<16 | CTRUNE,
+ OCONV<<16 | CTFLT,
+ OCONV<<16 | CTSTR:
+ convlit1(&nl, n.Type, 1)
+
+ v = nl.Val
+
+ case OPLUS<<16 | CTINT,
+ OPLUS<<16 | CTRUNE:
+ break
+
+ case OMINUS<<16 | CTINT,
+ OMINUS<<16 | CTRUNE:
+ mpnegfix(v.U.Xval)
+
+ case OCOM<<16 | CTINT,
+ OCOM<<16 | CTRUNE:
+ et = Txxx
+ if nl.Type != nil {
+ et = int(nl.Type.Etype)
+ }
+
+ // calculate the mask in b
+ // result will be (a ^ mask)
+ switch et {
+ // signed guys change sign
+ default:
+ Mpmovecfix(&b, -1)
+
+ // unsigned guys invert their bits
+ case TUINT8,
+ TUINT16,
+ TUINT32,
+ TUINT64,
+ TUINT,
+ TUINTPTR:
+ mpmovefixfix(&b, Maxintval[et])
+ }
+
+ mpxorfixfix(v.U.Xval, &b)
+
+ case OPLUS<<16 | CTFLT:
+ break
+
+ case OMINUS<<16 | CTFLT:
+ mpnegflt(v.U.Fval)
+
+ case OPLUS<<16 | CTCPLX:
+ break
+
+ case OMINUS<<16 | CTCPLX:
+ mpnegflt(&v.U.Cval.Real)
+ mpnegflt(&v.U.Cval.Imag)
+
+ case ONOT<<16 | CTBOOL:
+ if !(v.U.Bval != 0) {
+ goto settrue
+ }
+ goto setfalse
+ }
+
+ret:
+ norig = saveorig(n)
+ *n = *nl
+
+ // restore value of n->orig.
+ n.Orig = norig
+
+ n.Val = v
+
+ // check range.
+ lno = int(setlineno(n))
+
+ overflow(v, n.Type)
+ lineno = int32(lno)
+
+ // truncate precision for non-ideal float.
+ if v.Ctype == CTFLT && n.Type.Etype != TIDEAL {
+ n.Val.U.Fval = truncfltlit(v.U.Fval, n.Type)
+ }
+ return
+
+settrue:
+ norig = saveorig(n)
+ *n = *Nodbool(1)
+ n.Orig = norig
+ return
+
+setfalse:
+ norig = saveorig(n)
+ *n = *Nodbool(0)
+ n.Orig = norig
+ return
+
+illegal:
+ if !(n.Diag != 0) {
+ Yyerror("illegal constant expression: %v %v %v", Tconv(nl.Type, 0), Oconv(int(n.Op), 0), Tconv(nr.Type, 0))
+ n.Diag = 1
+ }
+
+ return
+}
+
+func nodlit(v Val) *Node {
+ var n *Node
+
+ n = Nod(OLITERAL, nil, nil)
+ n.Val = v
+ switch v.Ctype {
+ default:
+ Fatal("nodlit ctype %d", v.Ctype)
+ fallthrough
+
+ case CTSTR:
+ n.Type = idealstring
+
+ case CTBOOL:
+ n.Type = idealbool
+
+ case CTINT,
+ CTRUNE,
+ CTFLT,
+ CTCPLX:
+ n.Type = Types[TIDEAL]
+
+ case CTNIL:
+ n.Type = Types[TNIL]
+ }
+
+ return n
+}
+
+func nodcplxlit(r Val, i Val) *Node {
+ var n *Node
+ var c *Mpcplx
+
+ r = toflt(r)
+ i = toflt(i)
+
+ c = new(Mpcplx)
+ n = Nod(OLITERAL, nil, nil)
+ n.Type = Types[TIDEAL]
+ n.Val.U.Cval = c
+ n.Val.Ctype = CTCPLX
+
+ if r.Ctype != CTFLT || i.Ctype != CTFLT {
+ Fatal("nodcplxlit ctype %d/%d", r.Ctype, i.Ctype)
+ }
+
+ mpmovefltflt(&c.Real, r.U.Fval)
+ mpmovefltflt(&c.Imag, i.U.Fval)
+ return n
+}
+
+// idealkind returns a constant kind like consttype
+// but for an arbitrary "ideal" (untyped constant) expression.
+func idealkind(n *Node) int {
+ var k1 int
+ var k2 int
+
+ if n == nil || !(isideal(n.Type) != 0) {
+ return CTxxx
+ }
+
+ switch n.Op {
+ default:
+ return CTxxx
+
+ case OLITERAL:
+ return int(n.Val.Ctype)
+
+ // numeric kinds.
+ case OADD,
+ OAND,
+ OANDNOT,
+ OCOM,
+ ODIV,
+ OMINUS,
+ OMOD,
+ OMUL,
+ OSUB,
+ OXOR,
+ OOR,
+ OPLUS:
+ k1 = idealkind(n.Left)
+
+ k2 = idealkind(n.Right)
+ if k1 > k2 {
+ return k1
+ } else {
+ return k2
+ }
+ fallthrough
+
+ case OREAL,
+ OIMAG:
+ return CTFLT
+
+ case OCOMPLEX:
+ return CTCPLX
+
+ case OADDSTR:
+ return CTSTR
+
+ case OANDAND,
+ OEQ,
+ OGE,
+ OGT,
+ OLE,
+ OLT,
+ ONE,
+ ONOT,
+ OOROR,
+ OCMPSTR,
+ OCMPIFACE:
+ return CTBOOL
+
+ // shifts (beware!).
+ case OLSH,
+ ORSH:
+ return idealkind(n.Left)
+ }
+}
+
+func defaultlit(np **Node, t *Type) {
+ var lno int
+ var ctype int
+ var n *Node
+ var nn *Node
+ var t1 *Type
+
+ n = *np
+ if n == nil || !(isideal(n.Type) != 0) {
+ return
+ }
+
+ if n.Op == OLITERAL {
+ nn = Nod(OXXX, nil, nil)
+ *nn = *n
+ n = nn
+ *np = n
+ }
+
+ lno = int(setlineno(n))
+ ctype = idealkind(n)
+ switch ctype {
+ default:
+ if t != nil {
+ Convlit(np, t)
+ return
+ }
+
+ if n.Val.Ctype == CTNIL {
+ lineno = int32(lno)
+ if !(n.Diag != 0) {
+ Yyerror("use of untyped nil")
+ n.Diag = 1
+ }
+
+ n.Type = nil
+ break
+ }
+
+ if n.Val.Ctype == CTSTR {
+ t1 = Types[TSTRING]
+ Convlit(np, t1)
+ break
+ }
+
+ Yyerror("defaultlit: unknown literal: %v", Nconv(n, 0))
+
+ case CTxxx:
+ Fatal("defaultlit: idealkind is CTxxx: %v", Nconv(n, obj.FmtSign))
+
+ case CTBOOL:
+ t1 = Types[TBOOL]
+ if t != nil && t.Etype == TBOOL {
+ t1 = t
+ }
+ Convlit(np, t1)
+
+ case CTINT:
+ t1 = Types[TINT]
+ goto num
+
+ case CTRUNE:
+ t1 = runetype
+ goto num
+
+ case CTFLT:
+ t1 = Types[TFLOAT64]
+ goto num
+
+ case CTCPLX:
+ t1 = Types[TCOMPLEX128]
+ goto num
+ }
+
+ lineno = int32(lno)
+ return
+
+num:
+ if t != nil {
+ if Isint[t.Etype] != 0 {
+ t1 = t
+ n.Val = toint(n.Val)
+ } else if Isfloat[t.Etype] != 0 {
+ t1 = t
+ n.Val = toflt(n.Val)
+ } else if Iscomplex[t.Etype] != 0 {
+ t1 = t
+ n.Val = tocplx(n.Val)
+ }
+ }
+
+ overflow(n.Val, t1)
+ Convlit(np, t1)
+ lineno = int32(lno)
+ return
+}
+
+/*
+ * defaultlit on both nodes simultaneously;
+ * if they're both ideal going in they better
+ * get the same type going out.
+ * force means must assign concrete (non-ideal) type.
+ */
+func defaultlit2(lp **Node, rp **Node, force int) {
+ var l *Node
+ var r *Node
+ var lkind int
+ var rkind int
+
+ l = *lp
+ r = *rp
+ if l.Type == nil || r.Type == nil {
+ return
+ }
+ if !(isideal(l.Type) != 0) {
+ Convlit(rp, l.Type)
+ return
+ }
+
+ if !(isideal(r.Type) != 0) {
+ Convlit(lp, r.Type)
+ return
+ }
+
+ if !(force != 0) {
+ return
+ }
+ if l.Type.Etype == TBOOL {
+ Convlit(lp, Types[TBOOL])
+ Convlit(rp, Types[TBOOL])
+ }
+
+ lkind = idealkind(l)
+ rkind = idealkind(r)
+ if lkind == CTCPLX || rkind == CTCPLX {
+ Convlit(lp, Types[TCOMPLEX128])
+ Convlit(rp, Types[TCOMPLEX128])
+ return
+ }
+
+ if lkind == CTFLT || rkind == CTFLT {
+ Convlit(lp, Types[TFLOAT64])
+ Convlit(rp, Types[TFLOAT64])
+ return
+ }
+
+ if lkind == CTRUNE || rkind == CTRUNE {
+ Convlit(lp, runetype)
+ Convlit(rp, runetype)
+ return
+ }
+
+ Convlit(lp, Types[TINT])
+ Convlit(rp, Types[TINT])
+}
+
+func cmpslit(l, r *Node) int {
+ return stringsCompare(l.Val.U.Sval.S, r.Val.U.Sval.S)
+}
+
+func Smallintconst(n *Node) int {
+ if n.Op == OLITERAL && Isconst(n, CTINT) != 0 && n.Type != nil {
+ switch Simtype[n.Type.Etype] {
+ case TINT8,
+ TUINT8,
+ TINT16,
+ TUINT16,
+ TINT32,
+ TUINT32,
+ TBOOL,
+ TPTR32:
+ return 1
+
+ case TIDEAL,
+ TINT64,
+ TUINT64,
+ TPTR64:
+ if Mpcmpfixfix(n.Val.U.Xval, Minintval[TINT32]) < 0 || Mpcmpfixfix(n.Val.U.Xval, Maxintval[TINT32]) > 0 {
+ break
+ }
+ return 1
+ }
+ }
+
+ return 0
+}
+
+func nonnegconst(n *Node) int {
+ if n.Op == OLITERAL && n.Type != nil {
+ switch Simtype[n.Type.Etype] {
+ // check negative and 2^31
+ case TINT8,
+ TUINT8,
+ TINT16,
+ TUINT16,
+ TINT32,
+ TUINT32,
+ TINT64,
+ TUINT64,
+ TIDEAL:
+ if Mpcmpfixfix(n.Val.U.Xval, Minintval[TUINT32]) < 0 || Mpcmpfixfix(n.Val.U.Xval, Maxintval[TINT32]) > 0 {
+ break
+ }
+ return int(Mpgetfix(n.Val.U.Xval))
+ }
+ }
+
+ return -1
+}
+
+/*
+ * convert x to type et and back to int64
+ * for sign extension and truncation.
+ */
+func iconv(x int64, et int) int64 {
+ switch et {
+ case TINT8:
+ x = int64(int8(x))
+
+ case TUINT8:
+ x = int64(uint8(x))
+
+ case TINT16:
+ x = int64(int16(x))
+
+ case TUINT16:
+ x = int64(uint64(x))
+
+ case TINT32:
+ x = int64(int32(x))
+
+ case TUINT32:
+ x = int64(uint32(x))
+
+ case TINT64,
+ TUINT64:
+ break
+ }
+
+ return x
+}
+
+/*
+ * convert constant val to type t; leave in con.
+ * for back end.
+ */
+func Convconst(con *Node, t *Type, val *Val) {
+ var i int64
+ var tt int
+
+ tt = Simsimtype(t)
+
+ // copy the constant for conversion
+ Nodconst(con, Types[TINT8], 0)
+
+ con.Type = t
+ con.Val = *val
+
+ if Isint[tt] != 0 {
+ con.Val.Ctype = CTINT
+ con.Val.U.Xval = new(Mpint)
+ switch val.Ctype {
+ default:
+ Fatal("convconst ctype=%d %v", val.Ctype, Tconv(t, obj.FmtLong))
+ fallthrough
+
+ case CTINT,
+ CTRUNE:
+ i = Mpgetfix(val.U.Xval)
+
+ case CTBOOL:
+ i = int64(val.U.Bval)
+
+ case CTNIL:
+ i = 0
+ }
+
+ i = iconv(i, tt)
+ Mpmovecfix(con.Val.U.Xval, i)
+ return
+ }
+
+ if Isfloat[tt] != 0 {
+ con.Val = toflt(con.Val)
+ if con.Val.Ctype != CTFLT {
+ Fatal("convconst ctype=%d %v", con.Val.Ctype, Tconv(t, 0))
+ }
+ if tt == TFLOAT32 {
+ con.Val.U.Fval = truncfltlit(con.Val.U.Fval, t)
+ }
+ return
+ }
+
+ if Iscomplex[tt] != 0 {
+ con.Val = tocplx(con.Val)
+ if tt == TCOMPLEX64 {
+ con.Val.U.Cval.Real = *truncfltlit(&con.Val.U.Cval.Real, Types[TFLOAT32])
+ con.Val.U.Cval.Imag = *truncfltlit(&con.Val.U.Cval.Imag, Types[TFLOAT32])
+ }
+
+ return
+ }
+
+ Fatal("convconst %v constant", Tconv(t, obj.FmtLong))
+}
+
+// complex multiply v *= rv
+// (a, b) * (c, d) = (a*c - b*d, b*c + a*d)
+func cmplxmpy(v *Mpcplx, rv *Mpcplx) {
+ var ac Mpflt
+ var bd Mpflt
+ var bc Mpflt
+ var ad Mpflt
+
+ mpmovefltflt(&ac, &v.Real)
+ mpmulfltflt(&ac, &rv.Real) // ac
+
+ mpmovefltflt(&bd, &v.Imag)
+
+ mpmulfltflt(&bd, &rv.Imag) // bd
+
+ mpmovefltflt(&bc, &v.Imag)
+
+ mpmulfltflt(&bc, &rv.Real) // bc
+
+ mpmovefltflt(&ad, &v.Real)
+
+ mpmulfltflt(&ad, &rv.Imag) // ad
+
+ mpmovefltflt(&v.Real, &ac)
+
+ mpsubfltflt(&v.Real, &bd) // ac-bd
+
+ mpmovefltflt(&v.Imag, &bc)
+
+ mpaddfltflt(&v.Imag, &ad) // bc+ad
+}
+
+// complex divide v /= rv
+// (a, b) / (c, d) = ((a*c + b*d), (b*c - a*d))/(c*c + d*d)
+func cmplxdiv(v *Mpcplx, rv *Mpcplx) {
+ var ac Mpflt
+ var bd Mpflt
+ var bc Mpflt
+ var ad Mpflt
+ var cc_plus_dd Mpflt
+
+ mpmovefltflt(&cc_plus_dd, &rv.Real)
+ mpmulfltflt(&cc_plus_dd, &rv.Real) // cc
+
+ mpmovefltflt(&ac, &rv.Imag)
+
+ mpmulfltflt(&ac, &rv.Imag) // dd
+
+ mpaddfltflt(&cc_plus_dd, &ac) // cc+dd
+
+ mpmovefltflt(&ac, &v.Real)
+
+ mpmulfltflt(&ac, &rv.Real) // ac
+
+ mpmovefltflt(&bd, &v.Imag)
+
+ mpmulfltflt(&bd, &rv.Imag) // bd
+
+ mpmovefltflt(&bc, &v.Imag)
+
+ mpmulfltflt(&bc, &rv.Real) // bc
+
+ mpmovefltflt(&ad, &v.Real)
+
+ mpmulfltflt(&ad, &rv.Imag) // ad
+
+ mpmovefltflt(&v.Real, &ac)
+
+ mpaddfltflt(&v.Real, &bd) // ac+bd
+ mpdivfltflt(&v.Real, &cc_plus_dd) // (ac+bd)/(cc+dd)
+
+ mpmovefltflt(&v.Imag, &bc)
+
+ mpsubfltflt(&v.Imag, &ad) // bc-ad
+ mpdivfltflt(&v.Imag, &cc_plus_dd) // (bc+ad)/(cc+dd)
+}
+
+// Is n a Go language constant (as opposed to a compile-time constant)?
+// Expressions derived from nil, like string([]byte(nil)), while they
+// may be known at compile time, are not Go language constants.
+// Only called for expressions known to evaluated to compile-time
+// constants.
+func isgoconst(n *Node) int {
+ var l *Node
+ var t *Type
+
+ if n.Orig != nil {
+ n = n.Orig
+ }
+
+ switch n.Op {
+ case OADD,
+ OADDSTR,
+ OAND,
+ OANDAND,
+ OANDNOT,
+ OCOM,
+ ODIV,
+ OEQ,
+ OGE,
+ OGT,
+ OLE,
+ OLSH,
+ OLT,
+ OMINUS,
+ OMOD,
+ OMUL,
+ ONE,
+ ONOT,
+ OOR,
+ OOROR,
+ OPLUS,
+ ORSH,
+ OSUB,
+ OXOR,
+ OIOTA,
+ OCOMPLEX,
+ OREAL,
+ OIMAG:
+ if isgoconst(n.Left) != 0 && (n.Right == nil || isgoconst(n.Right) != 0) {
+ return 1
+ }
+
+ case OCONV:
+ if okforconst[n.Type.Etype] != 0 && isgoconst(n.Left) != 0 {
+ return 1
+ }
+
+ case OLEN,
+ OCAP:
+ l = n.Left
+ if isgoconst(l) != 0 {
+ return 1
+ }
+
+ // Special case: len/cap is constant when applied to array or
+ // pointer to array when the expression does not contain
+ // function calls or channel receive operations.
+ t = l.Type
+
+ if t != nil && Isptr[t.Etype] != 0 {
+ t = t.Type
+ }
+ if Isfixedarray(t) != 0 && !(hascallchan(l) != 0) {
+ return 1
+ }
+
+ case OLITERAL:
+ if n.Val.Ctype != CTNIL {
+ return 1
+ }
+
+ case ONAME:
+ l = n.Sym.Def
+ if l != nil && l.Op == OLITERAL && n.Val.Ctype != CTNIL {
+ return 1
+ }
+
+ case ONONAME:
+ if n.Sym.Def != nil && n.Sym.Def.Op == OIOTA {
+ return 1
+ }
+
+ // Only constant calls are unsafe.Alignof, Offsetof, and Sizeof.
+ case OCALL:
+ l = n.Left
+
+ for l.Op == OPAREN {
+ l = l.Left
+ }
+ if l.Op != ONAME || l.Sym.Pkg != unsafepkg {
+ break
+ }
+ if l.Sym.Name == "Alignof" || l.Sym.Name == "Offsetof" || l.Sym.Name == "Sizeof" {
+ return 1
+ }
+ }
+
+ //dump("nonconst", n);
+ return 0
+}
+
+func hascallchan(n *Node) int {
+ var l *NodeList
+
+ if n == nil {
+ return 0
+ }
+ switch n.Op {
+ case OAPPEND,
+ OCALL,
+ OCALLFUNC,
+ OCALLINTER,
+ OCALLMETH,
+ OCAP,
+ OCLOSE,
+ OCOMPLEX,
+ OCOPY,
+ ODELETE,
+ OIMAG,
+ OLEN,
+ OMAKE,
+ ONEW,
+ OPANIC,
+ OPRINT,
+ OPRINTN,
+ OREAL,
+ ORECOVER,
+ ORECV:
+ return 1
+ }
+
+ if hascallchan(n.Left) != 0 || hascallchan(n.Right) != 0 {
+ return 1
+ }
+
+ for l = n.List; l != nil; l = l.Next {
+ if hascallchan(l.N) != 0 {
+ return 1
+ }
+ }
+ for l = n.Rlist; l != nil; l = l.Next {
+ if hascallchan(l.N) != 0 {
+ return 1
+ }
+ }
+
+ return 0
+}
diff --git a/src/cmd/internal/gc/cplx.go b/src/cmd/internal/gc/cplx.go
new file mode 100644
index 0000000..bc5b547
--- /dev/null
+++ b/src/cmd/internal/gc/cplx.go
@@ -0,0 +1,503 @@
+// 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
+
+import "cmd/internal/obj"
+
+func CASE(a int, b int) int {
+ return a<<16 | b
+}
+
+func overlap_cplx(f *Node, t *Node) int {
+ // check whether f and t could be overlapping stack references.
+ // not exact, because it's hard to check for the stack register
+ // in portable code. close enough: worst case we will allocate
+ // an extra temporary and the registerizer will clean it up.
+ return bool2int(f.Op == OINDREG && t.Op == OINDREG && f.Xoffset+f.Type.Width >= t.Xoffset && t.Xoffset+t.Type.Width >= f.Xoffset)
+}
+
+func Complexbool(op int, nl *Node, nr *Node, true_ bool, likely int, to *obj.Prog) {
+ var tnl Node
+ var tnr Node
+ var n1 Node
+ var n2 Node
+ var n3 Node
+ var n4 Node
+ var na Node
+ var nb Node
+ var nc Node
+
+ // make both sides addable in ullman order
+ if nr != nil {
+ if nl.Ullman > nr.Ullman && !(nl.Addable != 0) {
+ Tempname(&tnl, nl.Type)
+ Thearch.Cgen(nl, &tnl)
+ nl = &tnl
+ }
+
+ if !(nr.Addable != 0) {
+ Tempname(&tnr, nr.Type)
+ Thearch.Cgen(nr, &tnr)
+ nr = &tnr
+ }
+ }
+
+ if !(nl.Addable != 0) {
+ Tempname(&tnl, nl.Type)
+ Thearch.Cgen(nl, &tnl)
+ nl = &tnl
+ }
+
+ // build tree
+ // real(l) == real(r) && imag(l) == imag(r)
+
+ subnode(&n1, &n2, nl)
+
+ subnode(&n3, &n4, nr)
+
+ na = Node{}
+ na.Op = OANDAND
+ na.Left = &nb
+ na.Right = &nc
+ na.Type = Types[TBOOL]
+
+ nb = Node{}
+ nb.Op = OEQ
+ nb.Left = &n1
+ nb.Right = &n3
+ nb.Type = Types[TBOOL]
+
+ nc = Node{}
+ nc.Op = OEQ
+ nc.Left = &n2
+ nc.Right = &n4
+ nc.Type = Types[TBOOL]
+
+ if op == ONE {
+ true_ = !true_
+ }
+
+ Thearch.Bgen(&na, true_, likely, to)
+}
+
+// break addable nc-complex into nr-real and ni-imaginary
+func subnode(nr *Node, ni *Node, nc *Node) {
+ var tc int
+ var t *Type
+
+ if !(nc.Addable != 0) {
+ Fatal("subnode not addable")
+ }
+
+ tc = Simsimtype(nc.Type)
+ tc = cplxsubtype(tc)
+ t = Types[tc]
+
+ if nc.Op == OLITERAL {
+ nodfconst(nr, t, &nc.Val.U.Cval.Real)
+ nodfconst(ni, t, &nc.Val.U.Cval.Imag)
+ return
+ }
+
+ *nr = *nc
+ nr.Type = t
+
+ *ni = *nc
+ ni.Type = t
+ ni.Xoffset += t.Width
+}
+
+// generate code res = -nl
+func minus(nl *Node, res *Node) {
+ var ra Node
+
+ ra = Node{}
+ ra.Op = OMINUS
+ ra.Left = nl
+ ra.Type = nl.Type
+ Thearch.Cgen(&ra, res)
+}
+
+// build and execute tree
+// real(res) = -real(nl)
+// imag(res) = -imag(nl)
+func complexminus(nl *Node, res *Node) {
+ var n1 Node
+ var n2 Node
+ var n5 Node
+ var n6 Node
+
+ subnode(&n1, &n2, nl)
+ subnode(&n5, &n6, res)
+
+ minus(&n1, &n5)
+ minus(&n2, &n6)
+}
+
+// build and execute tree
+// real(res) = real(nl) op real(nr)
+// imag(res) = imag(nl) op imag(nr)
+func complexadd(op int, nl *Node, nr *Node, res *Node) {
+ var n1 Node
+ var n2 Node
+ var n3 Node
+ var n4 Node
+ var n5 Node
+ var n6 Node
+ var ra Node
+
+ subnode(&n1, &n2, nl)
+ subnode(&n3, &n4, nr)
+ subnode(&n5, &n6, res)
+
+ ra = Node{}
+ ra.Op = uint8(op)
+ ra.Left = &n1
+ ra.Right = &n3
+ ra.Type = n1.Type
+ Thearch.Cgen(&ra, &n5)
+
+ ra = Node{}
+ ra.Op = uint8(op)
+ ra.Left = &n2
+ ra.Right = &n4
+ ra.Type = n2.Type
+ Thearch.Cgen(&ra, &n6)
+}
+
+// build and execute tree
+// tmp = real(nl)*real(nr) - imag(nl)*imag(nr)
+// imag(res) = real(nl)*imag(nr) + imag(nl)*real(nr)
+// real(res) = tmp
+func complexmul(nl *Node, nr *Node, res *Node) {
+ var n1 Node
+ var n2 Node
+ var n3 Node
+ var n4 Node
+ var n5 Node
+ var n6 Node
+ var rm1 Node
+ var rm2 Node
+ var ra Node
+ var tmp Node
+
+ subnode(&n1, &n2, nl)
+ subnode(&n3, &n4, nr)
+ subnode(&n5, &n6, res)
+ Tempname(&tmp, n5.Type)
+
+ // real part -> tmp
+ rm1 = Node{}
+
+ rm1.Op = OMUL
+ rm1.Left = &n1
+ rm1.Right = &n3
+ rm1.Type = n1.Type
+
+ rm2 = Node{}
+ rm2.Op = OMUL
+ rm2.Left = &n2
+ rm2.Right = &n4
+ rm2.Type = n2.Type
+
+ ra = Node{}
+ ra.Op = OSUB
+ ra.Left = &rm1
+ ra.Right = &rm2
+ ra.Type = rm1.Type
+ Thearch.Cgen(&ra, &tmp)
+
+ // imag part
+ rm1 = Node{}
+
+ rm1.Op = OMUL
+ rm1.Left = &n1
+ rm1.Right = &n4
+ rm1.Type = n1.Type
+
+ rm2 = Node{}
+ rm2.Op = OMUL
+ rm2.Left = &n2
+ rm2.Right = &n3
+ rm2.Type = n2.Type
+
+ ra = Node{}
+ ra.Op = OADD
+ ra.Left = &rm1
+ ra.Right = &rm2
+ ra.Type = rm1.Type
+ Thearch.Cgen(&ra, &n6)
+
+ // tmp ->real part
+ Thearch.Cgen(&tmp, &n5)
+}
+
+func nodfconst(n *Node, t *Type, fval *Mpflt) {
+ *n = Node{}
+ n.Op = OLITERAL
+ n.Addable = 1
+ ullmancalc(n)
+ n.Val.U.Fval = fval
+ n.Val.Ctype = CTFLT
+ n.Type = t
+
+ if !(Isfloat[t.Etype] != 0) {
+ Fatal("nodfconst: bad type %v", Tconv(t, 0))
+ }
+}
+
+/*
+ * cplx.c
+ */
+func Complexop(n *Node, res *Node) int {
+ if n != nil && n.Type != nil {
+ if Iscomplex[n.Type.Etype] != 0 {
+ goto maybe
+ }
+ }
+
+ if res != nil && res.Type != nil {
+ if Iscomplex[res.Type.Etype] != 0 {
+ goto maybe
+ }
+ }
+
+ if n.Op == OREAL || n.Op == OIMAG {
+ goto yes
+ }
+
+ goto no
+
+maybe:
+ switch n.Op {
+ case OCONV, // implemented ops
+ OADD,
+ OSUB,
+ OMUL,
+ OMINUS,
+ OCOMPLEX,
+ OREAL,
+ OIMAG:
+ goto yes
+
+ case ODOT,
+ ODOTPTR,
+ OINDEX,
+ OIND,
+ ONAME:
+ goto yes
+ }
+
+ //dump("\ncomplex-no", n);
+no:
+ return 0
+
+ //dump("\ncomplex-yes", n);
+yes:
+ return 1
+}
+
+func Complexmove(f *Node, t *Node) {
+ var ft int
+ var tt int
+ var n1 Node
+ var n2 Node
+ var n3 Node
+ var n4 Node
+ var tmp Node
+
+ if Debug['g'] != 0 {
+ Dump("\ncomplexmove-f", f)
+ Dump("complexmove-t", t)
+ }
+
+ if !(t.Addable != 0) {
+ Fatal("complexmove: to not addable")
+ }
+
+ ft = Simsimtype(f.Type)
+ tt = Simsimtype(t.Type)
+ switch uint32(ft)<<16 | uint32(tt) {
+ default:
+ Fatal("complexmove: unknown conversion: %v -> %v\n", Tconv(f.Type, 0), Tconv(t.Type, 0))
+ fallthrough
+
+ // complex to complex move/convert.
+ // make f addable.
+ // also use temporary if possible stack overlap.
+ case TCOMPLEX64<<16 | TCOMPLEX64,
+ TCOMPLEX64<<16 | TCOMPLEX128,
+ TCOMPLEX128<<16 | TCOMPLEX64,
+ TCOMPLEX128<<16 | TCOMPLEX128:
+ if !(f.Addable != 0) || overlap_cplx(f, t) != 0 {
+ Tempname(&tmp, f.Type)
+ Complexmove(f, &tmp)
+ f = &tmp
+ }
+
+ subnode(&n1, &n2, f)
+ subnode(&n3, &n4, t)
+
+ Thearch.Cgen(&n1, &n3)
+ Thearch.Cgen(&n2, &n4)
+ }
+}
+
+func Complexgen(n *Node, res *Node) {
+ var nl *Node
+ var nr *Node
+ var tnl Node
+ var tnr Node
+ var n1 Node
+ var n2 Node
+ var tmp Node
+ var tl int
+ var tr int
+
+ if Debug['g'] != 0 {
+ Dump("\ncomplexgen-n", n)
+ Dump("complexgen-res", res)
+ }
+
+ for n.Op == OCONVNOP {
+ n = n.Left
+ }
+
+ // pick off float/complex opcodes
+ switch n.Op {
+ case OCOMPLEX:
+ if res.Addable != 0 {
+ subnode(&n1, &n2, res)
+ Tempname(&tmp, n1.Type)
+ Thearch.Cgen(n.Left, &tmp)
+ Thearch.Cgen(n.Right, &n2)
+ Thearch.Cgen(&tmp, &n1)
+ return
+ }
+
+ case OREAL,
+ OIMAG:
+ nl = n.Left
+ if !(nl.Addable != 0) {
+ Tempname(&tmp, nl.Type)
+ Complexgen(nl, &tmp)
+ nl = &tmp
+ }
+
+ subnode(&n1, &n2, nl)
+ if n.Op == OREAL {
+ Thearch.Cgen(&n1, res)
+ return
+ }
+
+ Thearch.Cgen(&n2, res)
+ return
+ }
+
+ // perform conversion from n to res
+ tl = Simsimtype(res.Type)
+
+ tl = cplxsubtype(tl)
+ tr = Simsimtype(n.Type)
+ tr = cplxsubtype(tr)
+ if tl != tr {
+ if !(n.Addable != 0) {
+ Tempname(&n1, n.Type)
+ Complexmove(n, &n1)
+ n = &n1
+ }
+
+ Complexmove(n, res)
+ return
+ }
+
+ if !(res.Addable != 0) {
+ Thearch.Igen(res, &n1, nil)
+ Thearch.Cgen(n, &n1)
+ Thearch.Regfree(&n1)
+ return
+ }
+
+ if n.Addable != 0 {
+ Complexmove(n, res)
+ return
+ }
+
+ switch n.Op {
+ default:
+ Dump("complexgen: unknown op", n)
+ Fatal("complexgen: unknown op %v", Oconv(int(n.Op), 0))
+ fallthrough
+
+ case ODOT,
+ ODOTPTR,
+ OINDEX,
+ OIND,
+ ONAME, // PHEAP or PPARAMREF var
+ OCALLFUNC,
+ OCALLMETH,
+ OCALLINTER:
+ Thearch.Igen(n, &n1, res)
+
+ Complexmove(&n1, res)
+ Thearch.Regfree(&n1)
+ return
+
+ case OCONV,
+ OADD,
+ OSUB,
+ OMUL,
+ OMINUS,
+ OCOMPLEX,
+ OREAL,
+ OIMAG:
+ break
+ }
+
+ nl = n.Left
+ if nl == nil {
+ return
+ }
+ nr = n.Right
+
+ // make both sides addable in ullman order
+ if nr != nil {
+ if nl.Ullman > nr.Ullman && !(nl.Addable != 0) {
+ Tempname(&tnl, nl.Type)
+ Thearch.Cgen(nl, &tnl)
+ nl = &tnl
+ }
+
+ if !(nr.Addable != 0) {
+ Tempname(&tnr, nr.Type)
+ Thearch.Cgen(nr, &tnr)
+ nr = &tnr
+ }
+ }
+
+ if !(nl.Addable != 0) {
+ Tempname(&tnl, nl.Type)
+ Thearch.Cgen(nl, &tnl)
+ nl = &tnl
+ }
+
+ switch n.Op {
+ default:
+ Fatal("complexgen: unknown op %v", Oconv(int(n.Op), 0))
+
+ case OCONV:
+ Complexmove(nl, res)
+
+ case OMINUS:
+ complexminus(nl, res)
+
+ case OADD,
+ OSUB:
+ complexadd(int(n.Op), nl, nr, res)
+
+ case OMUL:
+ complexmul(nl, nr, res)
+ }
+}
diff --git a/src/cmd/internal/gc/dcl.go b/src/cmd/internal/gc/dcl.go
new file mode 100644
index 0000000..0aeb587
--- /dev/null
+++ b/src/cmd/internal/gc/dcl.go
@@ -0,0 +1,1565 @@
+// 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
+
+import (
+ "cmd/internal/obj"
+ "fmt"
+ "strings"
+)
+
+func dflag() int {
+ if !(Debug['d'] != 0) {
+ return 0
+ }
+ if Debug['y'] != 0 {
+ return 1
+ }
+ if incannedimport != 0 {
+ return 0
+ }
+ return 1
+}
+
+/*
+ * declaration stack & operations
+ */
+func dcopy(a *Sym, b *Sym) {
+ a.Pkg = b.Pkg
+ a.Name = b.Name
+ a.Def = b.Def
+ a.Block = b.Block
+ a.Lastlineno = b.Lastlineno
+}
+
+func push() *Sym {
+ var d *Sym
+
+ d = new(Sym)
+ d.Lastlineno = lineno
+ d.Link = dclstack
+ dclstack = d
+ return d
+}
+
+func pushdcl(s *Sym) *Sym {
+ var d *Sym
+
+ d = push()
+ dcopy(d, s)
+ if dflag() != 0 {
+ fmt.Printf("\t%v push %v %p\n", Ctxt.Line(int(lineno)), Sconv(s, 0), s.Def)
+ }
+ return d
+}
+
+func popdcl() {
+ var d *Sym
+ var s *Sym
+ var lno int
+
+ // if(dflag())
+ // print("revert\n");
+
+ for d = dclstack; d != nil; d = d.Link {
+ if d.Name == "" {
+ break
+ }
+ s = Pkglookup(d.Name, d.Pkg)
+ lno = int(s.Lastlineno)
+ dcopy(s, d)
+ d.Lastlineno = int32(lno)
+ if dflag() != 0 {
+ fmt.Printf("\t%v pop %v %p\n", Ctxt.Line(int(lineno)), Sconv(s, 0), s.Def)
+ }
+ }
+
+ if d == nil {
+ Fatal("popdcl: no mark")
+ }
+ dclstack = d.Link
+ block = d.Block
+}
+
+func poptodcl() {
+ // pop the old marker and push a new one
+ // (cannot reuse the existing one)
+ // because we use the markers to identify blocks
+ // for the goto restriction checks.
+ popdcl()
+
+ markdcl()
+}
+
+func markdcl() {
+ var d *Sym
+
+ d = push()
+ d.Name = "" // used as a mark in fifo
+ d.Block = block
+
+ blockgen++
+ block = blockgen
+}
+
+// if(dflag())
+// print("markdcl\n");
+func dumpdcl(st string) {
+ var s *Sym
+ var d *Sym
+ var i int
+
+ i = 0
+ for d = dclstack; d != nil; d = d.Link {
+ i++
+ fmt.Printf(" %.2d %p", i, d)
+ if d.Name == "" {
+ fmt.Printf("\n")
+ continue
+ }
+
+ fmt.Printf(" '%s'", d.Name)
+ s = Pkglookup(d.Name, d.Pkg)
+ fmt.Printf(" %v\n", Sconv(s, 0))
+ }
+}
+
+func testdclstack() {
+ var d *Sym
+
+ for d = dclstack; d != nil; d = d.Link {
+ if d.Name == "" {
+ if nerrors != 0 {
+ errorexit()
+ }
+ Yyerror("mark left on the stack")
+ continue
+ }
+ }
+}
+
+func redeclare(s *Sym, where string) {
+ var pkgstr *Strlit
+ var line1 int
+ var line2 int
+
+ if s.Lastlineno == 0 {
+ var tmp *Strlit
+ if s.Origpkg != nil {
+ tmp = s.Origpkg.Path
+ } else {
+ tmp = s.Pkg.Path
+ }
+ pkgstr = tmp
+ Yyerror("%v redeclared %s\n"+"\tprevious declaration during import \"%v\"", Sconv(s, 0), where, Zconv(pkgstr, 0))
+ } else {
+ line1 = parserline()
+ line2 = int(s.Lastlineno)
+
+ // When an import and a declaration collide in separate files,
+ // present the import as the "redeclared", because the declaration
+ // is visible where the import is, but not vice versa.
+ // See issue 4510.
+ if s.Def == nil {
+ line2 = line1
+ line1 = int(s.Lastlineno)
+ }
+
+ yyerrorl(int(line1), "%v redeclared %s\n"+"\tprevious declaration at %v", Sconv(s, 0), where, Ctxt.Line(line2))
+ }
+}
+
+var vargen int
+
+/*
+ * declare individual names - var, typ, const
+ */
+
+var declare_typegen int
+
+func declare(n *Node, ctxt int) {
+ var s *Sym
+ var gen int
+
+ if ctxt == PDISCARD {
+ return
+ }
+
+ if isblank(n) {
+ return
+ }
+
+ n.Lineno = int32(parserline())
+ s = n.Sym
+
+ // kludgy: typecheckok means we're past parsing. Eg genwrapper may declare out of package names later.
+ if importpkg == nil && !(typecheckok != 0) && s.Pkg != localpkg {
+ Yyerror("cannot declare name %v", Sconv(s, 0))
+ }
+
+ if ctxt == PEXTERN && s.Name == "init" {
+ Yyerror("cannot declare init - must be func", s)
+ }
+
+ gen = 0
+ if ctxt == PEXTERN {
+ externdcl = list(externdcl, n)
+ if dflag() != 0 {
+ fmt.Printf("\t%v global decl %v %p\n", Ctxt.Line(int(lineno)), Sconv(s, 0), n)
+ }
+ } else {
+ if Curfn == nil && ctxt == PAUTO {
+ Fatal("automatic outside function")
+ }
+ if Curfn != nil {
+ Curfn.Dcl = list(Curfn.Dcl, n)
+ }
+ if n.Op == OTYPE {
+ declare_typegen++
+ gen = declare_typegen
+ } else if n.Op == ONAME && ctxt == PAUTO && !strings.Contains(s.Name, "·") {
+ vargen++
+ gen = vargen
+ }
+ pushdcl(s)
+ n.Curfn = Curfn
+ }
+
+ if ctxt == PAUTO {
+ n.Xoffset = 0
+ }
+
+ if s.Block == block {
+ // functype will print errors about duplicate function arguments.
+ // Don't repeat the error here.
+ if ctxt != PPARAM && ctxt != PPARAMOUT {
+ redeclare(s, "in this block")
+ }
+ }
+
+ s.Block = block
+ s.Lastlineno = int32(parserline())
+ s.Def = n
+ n.Vargen = int32(gen)
+ n.Funcdepth = Funcdepth
+ n.Class = uint8(ctxt)
+
+ autoexport(n, ctxt)
+}
+
+func addvar(n *Node, t *Type, ctxt int) {
+ if n == nil || n.Sym == nil || (n.Op != ONAME && n.Op != ONONAME) || t == nil {
+ Fatal("addvar: n=%v t=%v nil", Nconv(n, 0), Tconv(t, 0))
+ }
+
+ n.Op = ONAME
+ declare(n, ctxt)
+ n.Type = t
+}
+
+/*
+ * declare variables from grammar
+ * new_name_list (type | [type] = expr_list)
+ */
+func variter(vl *NodeList, t *Node, el *NodeList) *NodeList {
+ var doexpr int
+ var v *Node
+ var e *Node
+ var as2 *Node
+ var init *NodeList
+
+ init = nil
+ doexpr = bool2int(el != nil)
+
+ if count(el) == 1 && count(vl) > 1 {
+ e = el.N
+ as2 = Nod(OAS2, nil, nil)
+ as2.List = vl
+ as2.Rlist = list1(e)
+ for ; vl != nil; vl = vl.Next {
+ v = vl.N
+ v.Op = ONAME
+ declare(v, dclcontext)
+ v.Ntype = t
+ v.Defn = as2
+ if Funcdepth > 0 {
+ init = list(init, Nod(ODCL, v, nil))
+ }
+ }
+
+ return list(init, as2)
+ }
+
+ for ; vl != nil; vl = vl.Next {
+ if doexpr != 0 {
+ if el == nil {
+ Yyerror("missing expression in var declaration")
+ break
+ }
+
+ e = el.N
+ el = el.Next
+ } else {
+ e = nil
+ }
+
+ v = vl.N
+ v.Op = ONAME
+ declare(v, dclcontext)
+ v.Ntype = t
+
+ if e != nil || Funcdepth > 0 || isblank(v) {
+ if Funcdepth > 0 {
+ init = list(init, Nod(ODCL, v, nil))
+ }
+ e = Nod(OAS, v, e)
+ init = list(init, e)
+ if e.Right != nil {
+ v.Defn = e
+ }
+ }
+ }
+
+ if el != nil {
+ Yyerror("extra expression in var declaration")
+ }
+ return init
+}
+
+/*
+ * declare constants from grammar
+ * new_name_list [[type] = expr_list]
+ */
+func constiter(vl *NodeList, t *Node, cl *NodeList) *NodeList {
+ var v *Node
+ var c *Node
+ var vv *NodeList
+
+ vv = nil
+ if cl == nil {
+ if t != nil {
+ Yyerror("const declaration cannot have type without expression")
+ }
+ cl = lastconst
+ t = lasttype
+ } else {
+ lastconst = cl
+ lasttype = t
+ }
+
+ cl = listtreecopy(cl)
+
+ for ; vl != nil; vl = vl.Next {
+ if cl == nil {
+ Yyerror("missing value in const declaration")
+ break
+ }
+
+ c = cl.N
+ cl = cl.Next
+
+ v = vl.N
+ v.Op = OLITERAL
+ declare(v, dclcontext)
+
+ v.Ntype = t
+ v.Defn = c
+
+ vv = list(vv, Nod(ODCLCONST, v, nil))
+ }
+
+ if cl != nil {
+ Yyerror("extra expression in const declaration")
+ }
+ iota_ += 1
+ return vv
+}
+
+/*
+ * this generates a new name node,
+ * typically for labels or other one-off names.
+ */
+func newname(s *Sym) *Node {
+ var n *Node
+
+ if s == nil {
+ Fatal("newname nil")
+ }
+
+ n = Nod(ONAME, nil, nil)
+ n.Sym = s
+ n.Type = nil
+ n.Addable = 1
+ n.Ullman = 1
+ n.Xoffset = 0
+ return n
+}
+
+/*
+ * this generates a new name node for a name
+ * being declared.
+ */
+func dclname(s *Sym) *Node {
+ var n *Node
+
+ n = newname(s)
+ n.Op = ONONAME // caller will correct it
+ return n
+}
+
+func typenod(t *Type) *Node {
+ // 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
+ }
+
+ return t.Nod
+}
+
+/*
+ * this will return an old name
+ * that has already been pushed on the
+ * declaration list. a diagnostic is
+ * generated if no name has been defined.
+ */
+func oldname(s *Sym) *Node {
+ var n *Node
+ var c *Node
+
+ n = s.Def
+ if n == nil {
+ // maybe a top-level name will come along
+ // to give this a definition later.
+ // walkdef will check s->def again once
+ // all the input source has been processed.
+ n = newname(s)
+
+ n.Op = ONONAME
+ n.Iota = iota_ // save current iota value in const declarations
+ }
+
+ if Curfn != nil && n.Funcdepth > 0 && n.Funcdepth != Funcdepth && n.Op == ONAME {
+ // inner func is referring to var in outer func.
+ //
+ // TODO(rsc): If there is an outer variable x and we
+ // are parsing x := 5 inside the closure, until we get to
+ // the := it looks like a reference to the outer x so we'll
+ // make x a closure variable unnecessarily.
+ if n.Closure == nil || n.Closure.Funcdepth != Funcdepth {
+ // create new closure var.
+ c = Nod(ONAME, nil, nil)
+
+ c.Sym = s
+ c.Class = PPARAMREF
+ c.Isddd = n.Isddd
+ c.Defn = n
+ c.Addable = 0
+ c.Ullman = 2
+ c.Funcdepth = Funcdepth
+ c.Outer = n.Closure
+ n.Closure = c
+ c.Closure = n
+ c.Xoffset = 0
+ Curfn.Cvars = list(Curfn.Cvars, c)
+ }
+
+ // return ref to closure var, not original
+ return n.Closure
+ }
+
+ return n
+}
+
+/*
+ * := declarations
+ */
+func colasname(n *Node) int {
+ switch n.Op {
+ case ONAME,
+ ONONAME,
+ OPACK,
+ OTYPE,
+ OLITERAL:
+ return bool2int(n.Sym != nil)
+ }
+
+ return 0
+}
+
+func colasdefn(left *NodeList, defn *Node) {
+ var nnew int
+ var nerr int
+ var l *NodeList
+ var n *Node
+
+ for l = left; l != nil; l = l.Next {
+ if l.N.Sym != nil {
+ l.N.Sym.Flags |= SymUniq
+ }
+ }
+
+ nnew = 0
+ nerr = 0
+ for l = left; l != nil; l = l.Next {
+ n = l.N
+ if isblank(n) {
+ continue
+ }
+ if !(colasname(n) != 0) {
+ yyerrorl(int(defn.Lineno), "non-name %v on left side of :=", Nconv(n, 0))
+ nerr++
+ continue
+ }
+
+ if n.Sym.Flags&SymUniq == 0 {
+ yyerrorl(int(defn.Lineno), "%v repeated on left side of :=", Sconv(n.Sym, 0))
+ n.Diag++
+ nerr++
+ continue
+ }
+
+ n.Sym.Flags &^= SymUniq
+ if n.Sym.Block == block {
+ continue
+ }
+
+ nnew++
+ n = newname(n.Sym)
+ declare(n, dclcontext)
+ n.Defn = defn
+ defn.Ninit = list(defn.Ninit, Nod(ODCL, n, nil))
+ l.N = n
+ }
+
+ if nnew == 0 && nerr == 0 {
+ yyerrorl(int(defn.Lineno), "no new variables on left side of :=")
+ }
+}
+
+func colas(left *NodeList, right *NodeList, lno int32) *Node {
+ var as *Node
+
+ as = Nod(OAS2, nil, nil)
+ as.List = left
+ as.Rlist = right
+ as.Colas = 1
+ as.Lineno = lno
+ colasdefn(left, as)
+
+ // make the tree prettier; not necessary
+ if count(left) == 1 && count(right) == 1 {
+ as.Left = as.List.N
+ as.Right = as.Rlist.N
+ as.List = nil
+ as.Rlist = nil
+ as.Op = OAS
+ }
+
+ return as
+}
+
+/*
+ * declare the arguments in an
+ * interface field declaration.
+ */
+func ifacedcl(n *Node) {
+ if n.Op != ODCLFIELD || n.Right == nil {
+ Fatal("ifacedcl")
+ }
+
+ if isblank(n.Left) {
+ Yyerror("methods must have a unique non-blank name")
+ }
+
+ dclcontext = PPARAM
+ markdcl()
+ Funcdepth++
+ n.Outer = Curfn
+ Curfn = n
+ funcargs(n.Right)
+
+ // funcbody is normally called after the parser has
+ // seen the body of a function but since an interface
+ // field declaration does not have a body, we must
+ // call it now to pop the current declaration context.
+ dclcontext = PAUTO
+
+ funcbody(n)
+}
+
+/*
+ * declare the function proper
+ * and declare the arguments.
+ * called in extern-declaration context
+ * returns in auto-declaration context.
+ */
+func funchdr(n *Node) {
+ // change the declaration context from extern to auto
+ if Funcdepth == 0 && dclcontext != PEXTERN {
+ Fatal("funchdr: dclcontext")
+ }
+
+ dclcontext = PAUTO
+ markdcl()
+ Funcdepth++
+
+ n.Outer = Curfn
+ Curfn = n
+
+ if n.Nname != nil {
+ funcargs(n.Nname.Ntype)
+ } else if n.Ntype != nil {
+ funcargs(n.Ntype)
+ } else {
+ funcargs2(n.Type)
+ }
+}
+
+func funcargs(nt *Node) {
+ var n *Node
+ var nn *Node
+ var l *NodeList
+ var gen int
+
+ if nt.Op != OTFUNC {
+ Fatal("funcargs %v", Oconv(int(nt.Op), 0))
+ }
+
+ // re-start the variable generation number
+ // we want to use small numbers for the return variables,
+ // so let them have the chunk starting at 1.
+ vargen = count(nt.Rlist)
+
+ // declare the receiver and in arguments.
+ // no n->defn because type checking of func header
+ // will not fill in the types until later
+ if nt.Left != nil {
+ n = nt.Left
+ if n.Op != ODCLFIELD {
+ Fatal("funcargs receiver %v", Oconv(int(n.Op), 0))
+ }
+ if n.Left != nil {
+ n.Left.Op = ONAME
+ n.Left.Ntype = n.Right
+ declare(n.Left, PPARAM)
+ if dclcontext == PAUTO {
+ vargen++
+ n.Left.Vargen = int32(vargen)
+ }
+ }
+ }
+
+ for l = nt.List; l != nil; l = l.Next {
+ n = l.N
+ if n.Op != ODCLFIELD {
+ Fatal("funcargs in %v", Oconv(int(n.Op), 0))
+ }
+ if n.Left != nil {
+ n.Left.Op = ONAME
+ n.Left.Ntype = n.Right
+ declare(n.Left, PPARAM)
+ if dclcontext == PAUTO {
+ vargen++
+ n.Left.Vargen = int32(vargen)
+ }
+ }
+ }
+
+ // declare the out arguments.
+ gen = count(nt.List)
+ var i int = 0
+ for l = nt.Rlist; l != nil; l = l.Next {
+ n = l.N
+
+ if n.Op != ODCLFIELD {
+ Fatal("funcargs out %v", Oconv(int(n.Op), 0))
+ }
+
+ if n.Left == nil {
+ // Name so that escape analysis can track it. ~r stands for 'result'.
+ namebuf = fmt.Sprintf("~r%d", gen)
+ gen++
+
+ n.Left = newname(Lookup(namebuf))
+ }
+
+ // TODO: n->left->missing = 1;
+ n.Left.Op = ONAME
+
+ if isblank(n.Left) {
+ // Give it a name so we can assign to it during return. ~b stands for 'blank'.
+ // The name must be different from ~r above because if you have
+ // func f() (_ int)
+ // func g() int
+ // f is allowed to use a plain 'return' with no arguments, while g is not.
+ // So the two cases must be distinguished.
+ // We do not record a pointer to the original node (n->orig).
+ // Having multiple names causes too much confusion in later passes.
+ nn = Nod(OXXX, nil, nil)
+
+ *nn = *n.Left
+ nn.Orig = nn
+ namebuf = fmt.Sprintf("~b%d", gen)
+ gen++
+ nn.Sym = Lookup(namebuf)
+ n.Left = nn
+ }
+
+ n.Left.Ntype = n.Right
+ declare(n.Left, PPARAMOUT)
+ if dclcontext == PAUTO {
+ i++
+ n.Left.Vargen = int32(i)
+ }
+ }
+}
+
+/*
+ * Same as funcargs, except run over an already constructed TFUNC.
+ * This happens during import, where the hidden_fndcl rule has
+ * used functype directly to parse the function's type.
+ */
+func funcargs2(t *Type) {
+ var ft *Type
+ var n *Node
+
+ if t.Etype != TFUNC {
+ Fatal("funcargs2 %v", Tconv(t, 0))
+ }
+
+ if t.Thistuple != 0 {
+ for ft = getthisx(t).Type; ft != nil; ft = ft.Down {
+ if !(ft.Nname != nil) || !(ft.Nname.Sym != nil) {
+ continue
+ }
+ n = ft.Nname // no need for newname(ft->nname->sym)
+ n.Type = ft.Type
+ declare(n, PPARAM)
+ }
+ }
+
+ if t.Intuple != 0 {
+ for ft = getinargx(t).Type; ft != nil; ft = ft.Down {
+ if !(ft.Nname != nil) || !(ft.Nname.Sym != nil) {
+ continue
+ }
+ n = ft.Nname
+ n.Type = ft.Type
+ declare(n, PPARAM)
+ }
+ }
+
+ if t.Outtuple != 0 {
+ for ft = getoutargx(t).Type; ft != nil; ft = ft.Down {
+ if !(ft.Nname != nil) || !(ft.Nname.Sym != nil) {
+ continue
+ }
+ n = ft.Nname
+ n.Type = ft.Type
+ declare(n, PPARAMOUT)
+ }
+ }
+}
+
+/*
+ * finish the body.
+ * called in auto-declaration context.
+ * returns in extern-declaration context.
+ */
+func funcbody(n *Node) {
+ // change the declaration context from auto to extern
+ if dclcontext != PAUTO {
+ Fatal("funcbody: dclcontext")
+ }
+ popdcl()
+ Funcdepth--
+ Curfn = n.Outer
+ n.Outer = nil
+ if Funcdepth == 0 {
+ dclcontext = PEXTERN
+ }
+}
+
+/*
+ * new type being defined with name s.
+ */
+func typedcl0(s *Sym) *Node {
+ var n *Node
+
+ n = newname(s)
+ n.Op = OTYPE
+ declare(n, dclcontext)
+ return n
+}
+
+/*
+ * node n, which was returned by typedcl0
+ * is being declared to have uncompiled type t.
+ * return the ODCLTYPE node to use.
+ */
+func typedcl1(n *Node, t *Node, local int) *Node {
+ n.Ntype = t
+ n.Local = uint8(local)
+ return Nod(ODCLTYPE, n, nil)
+}
+
+/*
+ * structs, functions, and methods.
+ * they don't belong here, but where do they belong?
+ */
+func checkembeddedtype(t *Type) {
+ if t == nil {
+ return
+ }
+
+ if t.Sym == nil && Isptr[t.Etype] != 0 {
+ t = t.Type
+ if t.Etype == TINTER {
+ Yyerror("embedded type cannot be a pointer to interface")
+ }
+ }
+
+ if Isptr[t.Etype] != 0 {
+ Yyerror("embedded type cannot be a pointer")
+ } else if t.Etype == TFORW && t.Embedlineno == 0 {
+ t.Embedlineno = lineno
+ }
+}
+
+func structfield(n *Node) *Type {
+ var f *Type
+ var lno int
+
+ lno = int(lineno)
+ lineno = n.Lineno
+
+ if n.Op != ODCLFIELD {
+ Fatal("structfield: oops %v\n", Nconv(n, 0))
+ }
+
+ f = typ(TFIELD)
+ f.Isddd = n.Isddd
+
+ if n.Right != nil {
+ typecheck(&n.Right, Etype)
+ n.Type = n.Right.Type
+ if n.Left != nil {
+ n.Left.Type = n.Type
+ }
+ if n.Embedded != 0 {
+ checkembeddedtype(n.Type)
+ }
+ }
+
+ n.Right = nil
+
+ f.Type = n.Type
+ if f.Type == nil {
+ f.Broke = 1
+ }
+
+ switch n.Val.Ctype {
+ case CTSTR:
+ f.Note = n.Val.U.Sval
+
+ default:
+ Yyerror("field annotation must be string")
+ fallthrough
+
+ // fallthrough
+ case CTxxx:
+ f.Note = nil
+ }
+
+ if n.Left != nil && n.Left.Op == ONAME {
+ f.Nname = n.Left
+ f.Embedded = n.Embedded
+ f.Sym = f.Nname.Sym
+ }
+
+ lineno = int32(lno)
+ return f
+}
+
+var uniqgen uint32
+
+func checkdupfields(t *Type, what string) {
+ var lno int
+
+ lno = int(lineno)
+
+ for ; t != nil; t = t.Down {
+ if t.Sym != nil && t.Nname != nil && !isblank(t.Nname) {
+ if t.Sym.Uniqgen == uniqgen {
+ lineno = t.Nname.Lineno
+ Yyerror("duplicate %s %s", what, t.Sym.Name)
+ } else {
+ t.Sym.Uniqgen = uniqgen
+ }
+ }
+ }
+
+ lineno = int32(lno)
+}
+
+/*
+ * convert a parsed id/type list into
+ * a type for struct/interface/arglist
+ */
+func tostruct(l *NodeList) *Type {
+ var t *Type
+ var f *Type
+ var tp **Type
+ t = typ(TSTRUCT)
+
+ for tp = &t.Type; l != nil; l = l.Next {
+ f = structfield(l.N)
+
+ *tp = f
+ tp = &f.Down
+ }
+
+ for f = t.Type; f != nil && !(t.Broke != 0); f = f.Down {
+ if f.Broke != 0 {
+ t.Broke = 1
+ }
+ }
+
+ uniqgen++
+ checkdupfields(t.Type, "field")
+
+ if !(t.Broke != 0) {
+ checkwidth(t)
+ }
+
+ return t
+}
+
+func tofunargs(l *NodeList) *Type {
+ var t *Type
+ var f *Type
+ var tp **Type
+
+ t = typ(TSTRUCT)
+ t.Funarg = 1
+
+ for tp = &t.Type; l != nil; l = l.Next {
+ f = structfield(l.N)
+ f.Funarg = 1
+
+ // esc.c needs to find f given a PPARAM to add the tag.
+ if l.N.Left != nil && l.N.Left.Class == PPARAM {
+ l.N.Left.Paramfld = f
+ }
+
+ *tp = f
+ tp = &f.Down
+ }
+
+ for f = t.Type; f != nil && !(t.Broke != 0); f = f.Down {
+ if f.Broke != 0 {
+ t.Broke = 1
+ }
+ }
+
+ return t
+}
+
+func interfacefield(n *Node) *Type {
+ var f *Type
+ var lno int
+
+ lno = int(lineno)
+ lineno = n.Lineno
+
+ if n.Op != ODCLFIELD {
+ Fatal("interfacefield: oops %v\n", Nconv(n, 0))
+ }
+
+ if n.Val.Ctype != CTxxx {
+ Yyerror("interface method cannot have annotation")
+ }
+
+ f = typ(TFIELD)
+ f.Isddd = n.Isddd
+
+ if n.Right != nil {
+ if n.Left != nil {
+ // queue resolution of method type for later.
+ // right now all we need is the name list.
+ // avoids cycles for recursive interface types.
+ n.Type = typ(TINTERMETH)
+
+ n.Type.Nname = n.Right
+ n.Left.Type = n.Type
+ queuemethod(n)
+
+ if n.Left.Op == ONAME {
+ f.Nname = n.Left
+ f.Embedded = n.Embedded
+ f.Sym = f.Nname.Sym
+ }
+ } else {
+ typecheck(&n.Right, Etype)
+ n.Type = n.Right.Type
+
+ if n.Embedded != 0 {
+ checkembeddedtype(n.Type)
+ }
+
+ if n.Type != nil {
+ switch n.Type.Etype {
+ case TINTER:
+ break
+
+ case TFORW:
+ Yyerror("interface type loop involving %v", Tconv(n.Type, 0))
+ f.Broke = 1
+
+ default:
+ Yyerror("interface contains embedded non-interface %v", Tconv(n.Type, 0))
+ f.Broke = 1
+ }
+ }
+ }
+ }
+
+ n.Right = nil
+
+ f.Type = n.Type
+ if f.Type == nil {
+ f.Broke = 1
+ }
+
+ lineno = int32(lno)
+ return f
+}
+
+func tointerface(l *NodeList) *Type {
+ var t *Type
+ var f *Type
+ var tp **Type
+ var t1 *Type
+
+ t = typ(TINTER)
+
+ tp = &t.Type
+ for ; l != nil; l = l.Next {
+ f = interfacefield(l.N)
+
+ if l.N.Left == nil && f.Type.Etype == TINTER {
+ // embedded interface, inline methods
+ for t1 = f.Type.Type; t1 != nil; t1 = t1.Down {
+ f = typ(TFIELD)
+ f.Type = t1.Type
+ f.Broke = t1.Broke
+ f.Sym = t1.Sym
+ if f.Sym != nil {
+ f.Nname = newname(f.Sym)
+ }
+ *tp = f
+ tp = &f.Down
+ }
+ } else {
+ *tp = f
+ tp = &f.Down
+ }
+ }
+
+ for f = t.Type; f != nil && !(t.Broke != 0); f = f.Down {
+ if f.Broke != 0 {
+ t.Broke = 1
+ }
+ }
+
+ uniqgen++
+ checkdupfields(t.Type, "method")
+ t = sortinter(t)
+ checkwidth(t)
+
+ return t
+}
+
+func embedded(s *Sym, pkg *Pkg) *Node {
+ var n *Node
+ var name string
+ const (
+ CenterDot = 0xB7
+ )
+ // Names sometimes have disambiguation junk
+ // appended after a center dot. Discard it when
+ // making the name for the embedded struct field.
+ name = s.Name
+
+ if i := strings.Index(s.Name, string(CenterDot)); i >= 0 {
+ name = s.Name[:i]
+ }
+
+ if exportname(name) {
+ n = newname(Lookup(name))
+ } else if s.Pkg == builtinpkg {
+ // The name of embedded builtins belongs to pkg.
+ n = newname(Pkglookup(name, pkg))
+ } else {
+ n = newname(Pkglookup(name, s.Pkg))
+ }
+ n = Nod(ODCLFIELD, n, oldname(s))
+ n.Embedded = 1
+ return n
+}
+
+/*
+ * check that the list of declarations is either all anonymous or all named
+ */
+func findtype(l *NodeList) *Node {
+ for ; l != nil; l = l.Next {
+ if l.N.Op == OKEY {
+ return l.N.Right
+ }
+ }
+ return nil
+}
+
+func checkarglist(all *NodeList, input int) *NodeList {
+ var named int
+ var n *Node
+ var t *Node
+ var nextt *Node
+ var l *NodeList
+
+ named = 0
+ for l = all; l != nil; l = l.Next {
+ if l.N.Op == OKEY {
+ named = 1
+ break
+ }
+ }
+
+ if named != 0 {
+ n = nil
+ for l = all; l != nil; l = l.Next {
+ n = l.N
+ if n.Op != OKEY && n.Sym == nil {
+ Yyerror("mixed named and unnamed function parameters")
+ break
+ }
+ }
+
+ if l == nil && n != nil && n.Op != OKEY {
+ Yyerror("final function parameter must have type")
+ }
+ }
+
+ nextt = nil
+ for l = all; l != nil; l = l.Next {
+ // can cache result from findtype to avoid
+ // quadratic behavior here, but unlikely to matter.
+ n = l.N
+
+ if named != 0 {
+ if n.Op == OKEY {
+ t = n.Right
+ n = n.Left
+ nextt = nil
+ } else {
+ if nextt == nil {
+ nextt = findtype(l)
+ }
+ t = nextt
+ }
+ } else {
+ t = n
+ n = nil
+ }
+
+ // during import l->n->op is OKEY, but l->n->left->sym == S
+ // means it was a '?', not that it was
+ // a lone type This doesn't matter for the exported
+ // declarations, which are parsed by rules that don't
+ // use checkargs, but can happen for func literals in
+ // the inline bodies.
+ // TODO(rsc) this can go when typefmt case TFIELD in exportmode fmt.c prints _ instead of ?
+ if importpkg != nil && n.Sym == nil {
+ n = nil
+ }
+
+ if n != nil && n.Sym == nil {
+ t = n
+ n = nil
+ }
+
+ if n != nil {
+ n = newname(n.Sym)
+ }
+ n = Nod(ODCLFIELD, n, t)
+ if n.Right != nil && n.Right.Op == ODDD {
+ if !(input != 0) {
+ Yyerror("cannot use ... in output argument list")
+ } else if l.Next != nil {
+ Yyerror("can only use ... as final argument in list")
+ }
+ n.Right.Op = OTARRAY
+ n.Right.Right = n.Right.Left
+ n.Right.Left = nil
+ n.Isddd = 1
+ if n.Left != nil {
+ n.Left.Isddd = 1
+ }
+ }
+
+ l.N = n
+ }
+
+ return all
+}
+
+func fakethis() *Node {
+ var n *Node
+
+ n = Nod(ODCLFIELD, nil, typenod(Ptrto(typ(TSTRUCT))))
+ return n
+}
+
+/*
+ * Is this field a method on an interface?
+ * Those methods have an anonymous
+ * *struct{} as the receiver.
+ * (See fakethis above.)
+ */
+func isifacemethod(f *Type) int {
+ var rcvr *Type
+ var t *Type
+
+ rcvr = getthisx(f).Type
+ if rcvr.Sym != nil {
+ return 0
+ }
+ t = rcvr.Type
+ if !(Isptr[t.Etype] != 0) {
+ return 0
+ }
+ t = t.Type
+ if t.Sym != nil || t.Etype != TSTRUCT || t.Type != nil {
+ return 0
+ }
+ return 1
+}
+
+/*
+ * turn a parsed function declaration
+ * into a type
+ */
+func functype(this *Node, in *NodeList, out *NodeList) *Type {
+ var t *Type
+ var rcvr *NodeList
+ var s *Sym
+
+ t = typ(TFUNC)
+
+ rcvr = nil
+ if this != nil {
+ rcvr = list1(this)
+ }
+ t.Type = tofunargs(rcvr)
+ t.Type.Down = tofunargs(out)
+ t.Type.Down.Down = tofunargs(in)
+
+ uniqgen++
+ checkdupfields(t.Type.Type, "argument")
+ checkdupfields(t.Type.Down.Type, "argument")
+ checkdupfields(t.Type.Down.Down.Type, "argument")
+
+ if t.Type.Broke != 0 || t.Type.Down.Broke != 0 || t.Type.Down.Down.Broke != 0 {
+ t.Broke = 1
+ }
+
+ if this != nil {
+ t.Thistuple = 1
+ }
+ t.Outtuple = count(out)
+ t.Intuple = count(in)
+ t.Outnamed = 0
+ if t.Outtuple > 0 && out.N.Left != nil && out.N.Left.Orig != nil {
+ s = out.N.Left.Orig.Sym
+ if s != nil && (s.Name[0] != '~' || s.Name[1] != 'r') { // ~r%d is the name invented for an unnamed result
+ t.Outnamed = 1
+ }
+ }
+
+ return t
+}
+
+var methodsym_toppkg *Pkg
+
+func methodsym(nsym *Sym, t0 *Type, iface int) *Sym {
+ var s *Sym
+ var p string
+ var t *Type
+ var suffix string
+ var spkg *Pkg
+
+ t = t0
+ if t == nil {
+ goto bad
+ }
+ s = t.Sym
+ if s == nil && Isptr[t.Etype] != 0 {
+ t = t.Type
+ if t == nil {
+ goto bad
+ }
+ s = t.Sym
+ }
+
+ spkg = nil
+ if s != nil {
+ spkg = s.Pkg
+ }
+
+ // if t0 == *t and t0 has a sym,
+ // we want to see *t, not t0, in the method name.
+ if t != t0 && t0.Sym != nil {
+ t0 = Ptrto(t)
+ }
+
+ suffix = ""
+ if iface != 0 {
+ dowidth(t0)
+ if t0.Width < Types[Tptr].Width {
+ suffix = "·i"
+ }
+ }
+
+ if (spkg == nil || nsym.Pkg != spkg) && !exportname(nsym.Name) {
+ if t0.Sym == nil && Isptr[t0.Etype] != 0 {
+ p = fmt.Sprintf("(%v).%s.%s%s", Tconv(t0, obj.FmtLeft|obj.FmtShort), nsym.Pkg.Prefix, nsym.Name, suffix)
+ } else {
+ p = fmt.Sprintf("%v.%s.%s%s", Tconv(t0, obj.FmtLeft|obj.FmtShort), nsym.Pkg.Prefix, nsym.Name, suffix)
+ }
+ } else {
+ if t0.Sym == nil && Isptr[t0.Etype] != 0 {
+ p = fmt.Sprintf("(%v).%s%s", Tconv(t0, obj.FmtLeft|obj.FmtShort), nsym.Name, suffix)
+ } else {
+ p = fmt.Sprintf("%v.%s%s", Tconv(t0, obj.FmtLeft|obj.FmtShort), nsym.Name, suffix)
+ }
+ }
+
+ if spkg == nil {
+ if methodsym_toppkg == nil {
+ methodsym_toppkg = mkpkg(newstrlit("go"))
+ }
+ spkg = methodsym_toppkg
+ }
+
+ s = Pkglookup(p, spkg)
+
+ return s
+
+bad:
+ Yyerror("illegal receiver type: %v", Tconv(t0, 0))
+ return nil
+}
+
+func methodname(n *Node, t *Type) *Node {
+ var s *Sym
+
+ s = methodsym(n.Sym, t, 0)
+ if s == nil {
+ return n
+ }
+ return newname(s)
+}
+
+func methodname1(n *Node, t *Node) *Node {
+ var star string
+ var p string
+
+ star = ""
+ if t.Op == OIND {
+ star = "*"
+ t = t.Left
+ }
+
+ if t.Sym == nil || isblank(n) {
+ return newname(n.Sym)
+ }
+
+ if star != "" {
+ p = fmt.Sprintf("(%s%v).%v", star, Sconv(t.Sym, 0), Sconv(n.Sym, 0))
+ } else {
+ p = fmt.Sprintf("%v.%v", Sconv(t.Sym, 0), Sconv(n.Sym, 0))
+ }
+
+ if exportname(t.Sym.Name) {
+ n = newname(Lookup(p))
+ } else {
+ n = newname(Pkglookup(p, t.Sym.Pkg))
+ }
+
+ return n
+}
+
+/*
+ * add a method, declared as a function,
+ * n is fieldname, pa is base type, t is function type
+ */
+func addmethod(sf *Sym, t *Type, local bool, nointerface bool) {
+ var f *Type
+ var d *Type
+ var pa *Type
+ var n *Node
+
+ // get field sym
+ if sf == nil {
+ Fatal("no method symbol")
+ }
+
+ // get parent type sym
+ pa = getthisx(t).Type // ptr to this structure
+ if pa == nil {
+ Yyerror("missing receiver")
+ return
+ }
+
+ pa = pa.Type
+ f = methtype(pa, 1)
+ if f == nil {
+ t = pa
+ if t == nil { // rely on typecheck having complained before
+ return
+ }
+ if t != nil {
+ if Isptr[t.Etype] != 0 {
+ if t.Sym != nil {
+ Yyerror("invalid receiver type %v (%v is a pointer type)", Tconv(pa, 0), Tconv(t, 0))
+ return
+ }
+
+ t = t.Type
+ }
+
+ if t.Broke != 0 { // rely on typecheck having complained before
+ return
+ }
+ if t.Sym == nil {
+ Yyerror("invalid receiver type %v (%v is an unnamed type)", Tconv(pa, 0), Tconv(t, 0))
+ return
+ }
+
+ if Isptr[t.Etype] != 0 {
+ Yyerror("invalid receiver type %v (%v is a pointer type)", Tconv(pa, 0), Tconv(t, 0))
+ return
+ }
+
+ if t.Etype == TINTER {
+ Yyerror("invalid receiver type %v (%v is an interface type)", Tconv(pa, 0), Tconv(t, 0))
+ return
+ }
+ }
+
+ // Should have picked off all the reasons above,
+ // but just in case, fall back to generic error.
+ Yyerror("invalid receiver type %v (%v / %v)", Tconv(pa, 0), Tconv(pa, obj.FmtLong), Tconv(t, obj.FmtLong))
+
+ return
+ }
+
+ pa = f
+ if pa.Etype == TSTRUCT {
+ for f = pa.Type; f != nil; f = f.Down {
+ if f.Sym == sf {
+ Yyerror("type %v has both field and method named %v", Tconv(pa, 0), Sconv(sf, 0))
+ return
+ }
+ }
+ }
+
+ if local && !(pa.Local != 0) {
+ // defining method on non-local type.
+ Yyerror("cannot define new methods on non-local type %v", Tconv(pa, 0))
+
+ return
+ }
+
+ n = Nod(ODCLFIELD, newname(sf), nil)
+ n.Type = t
+
+ d = nil // last found
+ for f = pa.Method; f != nil; f = f.Down {
+ d = f
+ if f.Etype != TFIELD {
+ Fatal("addmethod: not TFIELD: %v", Tconv(f, obj.FmtLong))
+ }
+ if sf.Name != f.Sym.Name {
+ continue
+ }
+ if !Eqtype(t, f.Type) {
+ Yyerror("method redeclared: %v.%v\n\t%v\n\t%v", Tconv(pa, 0), Sconv(sf, 0), Tconv(f.Type, 0), Tconv(t, 0))
+ }
+ return
+ }
+
+ f = structfield(n)
+ f.Nointerface = uint8(bool2int(nointerface))
+
+ // during import unexported method names should be in the type's package
+ if importpkg != nil && f.Sym != nil && !exportname(f.Sym.Name) && f.Sym.Pkg != structpkg {
+ Fatal("imported method name %v in wrong package %s\n", Sconv(f.Sym, obj.FmtSign), structpkg.Name)
+ }
+
+ if d == nil {
+ pa.Method = f
+ } else {
+ d.Down = f
+ }
+ return
+}
+
+func funccompile(n *Node) {
+ Stksize = BADWIDTH
+ Maxarg = 0
+
+ if n.Type == nil {
+ if nerrors == 0 {
+ Fatal("funccompile missing type")
+ }
+ return
+ }
+
+ // assign parameter offsets
+ checkwidth(n.Type)
+
+ if Curfn != nil {
+ Fatal("funccompile %v inside %v", Sconv(n.Nname.Sym, 0), Sconv(Curfn.Nname.Sym, 0))
+ }
+
+ Stksize = 0
+ dclcontext = PAUTO
+ Funcdepth = n.Funcdepth + 1
+ compile(n)
+ Curfn = nil
+ Funcdepth = 0
+ dclcontext = PEXTERN
+}
+
+func funcsym(s *Sym) *Sym {
+ var p string
+ var s1 *Sym
+
+ p = fmt.Sprintf("%s·f", s.Name)
+ s1 = Pkglookup(p, s.Pkg)
+
+ if s1.Def == nil {
+ s1.Def = newname(s1)
+ s1.Def.Shortname = newname(s)
+ funcsyms = list(funcsyms, s1.Def)
+ }
+
+ return s1
+}
diff --git a/src/cmd/internal/gc/esc.go b/src/cmd/internal/gc/esc.go
new file mode 100644
index 0000000..35543e1
--- /dev/null
+++ b/src/cmd/internal/gc/esc.go
@@ -0,0 +1,1437 @@
+// Copyright 2011 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
+
+import (
+ "cmd/internal/obj"
+ "fmt"
+ "strings"
+)
+
+// Escape analysis.
+
+// Run analysis on minimal sets of mutually recursive functions
+// or single non-recursive functions, bottom up.
+//
+// Finding these sets is finding strongly connected components
+// in the static call graph. The algorithm for doing that is taken
+// from Sedgewick, Algorithms, Second Edition, p. 482, with two
+// adaptations.
+//
+// First, a hidden closure function (n->curfn != N) cannot be the
+// root of a connected component. Refusing to use it as a root
+// forces it into the component of the function in which it appears.
+// The analysis assumes that closures and the functions in which they
+// appear are analyzed together, so that the aliasing between their
+// variables can be modeled more precisely.
+//
+// Second, each function becomes two virtual nodes in the graph,
+// with numbers n and n+1. We record the function's node number as n
+// but search from node n+1. If the search tells us that the component
+// number (min) is n+1, we know that this is a trivial component: one function
+// plus its closures. If the search tells us that the component number is
+// n, then there was a path from node n+1 back to node n, meaning that
+// the function set is mutually recursive. The escape analysis can be
+// more precise when analyzing a single non-recursive function than
+// when analyzing a set of mutually recursive functions.
+
+var stack *NodeList
+
+var visitgen uint32
+
+const (
+ EscFuncUnknown = 0 + iota
+ EscFuncPlanned
+ EscFuncStarted
+ EscFuncTagged
+)
+
+func escapes(all *NodeList) {
+ var l *NodeList
+
+ for l = all; l != nil; l = l.Next {
+ l.N.Walkgen = 0
+ }
+
+ visitgen = 0
+ for l = all; l != nil; l = l.Next {
+ if l.N.Op == ODCLFUNC && l.N.Curfn == nil {
+ visit(l.N)
+ }
+ }
+
+ for l = all; l != nil; l = l.Next {
+ l.N.Walkgen = 0
+ }
+}
+
+func visit(n *Node) uint32 {
+ var min uint32
+ var recursive uint32
+ var l *NodeList
+ var block *NodeList
+
+ if n.Walkgen > 0 {
+ // already visited
+ return n.Walkgen
+ }
+
+ visitgen++
+ n.Walkgen = visitgen
+ visitgen++
+ min = visitgen
+
+ l = new(NodeList)
+ l.Next = stack
+ l.N = n
+ stack = l
+ min = visitcodelist(n.Nbody, min)
+ if (min == n.Walkgen || min == n.Walkgen+1) && n.Curfn == nil {
+ // This node is the root of a strongly connected component.
+
+ // The original min passed to visitcodelist was n->walkgen+1.
+ // If visitcodelist found its way back to n->walkgen, then this
+ // block is a set of mutually recursive functions.
+ // Otherwise it's just a lone function that does not recurse.
+ recursive = uint32(bool2int(min == n.Walkgen))
+
+ // Remove connected component from stack.
+ // Mark walkgen so that future visits return a large number
+ // so as not to affect the caller's min.
+ block = stack
+
+ for l = stack; l.N != n; l = l.Next {
+ l.N.Walkgen = ^uint32(0)
+ }
+ n.Walkgen = ^uint32(0)
+ stack = l.Next
+ l.Next = nil
+
+ // Run escape analysis on this set of functions.
+ analyze(block, int(recursive))
+ }
+
+ return min
+}
+
+func visitcodelist(l *NodeList, min uint32) uint32 {
+ for ; l != nil; l = l.Next {
+ min = visitcode(l.N, min)
+ }
+ return min
+}
+
+func visitcode(n *Node, min uint32) uint32 {
+ var fn *Node
+ var m uint32
+
+ if n == nil {
+ return min
+ }
+
+ min = visitcodelist(n.Ninit, min)
+ min = visitcode(n.Left, min)
+ min = visitcode(n.Right, min)
+ min = visitcodelist(n.List, min)
+ min = visitcode(n.Ntest, min)
+ min = visitcode(n.Nincr, min)
+ min = visitcodelist(n.Nbody, min)
+ min = visitcodelist(n.Nelse, min)
+ min = visitcodelist(n.Rlist, min)
+
+ if n.Op == OCALLFUNC || n.Op == OCALLMETH {
+ fn = n.Left
+ if n.Op == OCALLMETH {
+ fn = n.Left.Right.Sym.Def
+ }
+ if fn != nil && fn.Op == ONAME && fn.Class == PFUNC && fn.Defn != nil {
+ m = visit(fn.Defn)
+ if m < min {
+ min = m
+ }
+ }
+ }
+
+ if n.Op == OCLOSURE {
+ m = visit(n.Closure)
+ if m < min {
+ min = m
+ }
+ }
+
+ return min
+}
+
+// An escape analysis pass for a set of functions.
+//
+// First escfunc, esc and escassign recurse over the ast of each
+// function to dig out flow(dst,src) edges between any
+// pointer-containing nodes and store them in dst->escflowsrc. For
+// variables assigned to a variable in an outer scope or used as a
+// return value, they store a flow(theSink, src) edge to a fake node
+// 'the Sink'. For variables referenced in closures, an edge
+// flow(closure, &var) is recorded and the flow of a closure itself to
+// an outer scope is tracked the same way as other variables.
+//
+// Then escflood walks the graph starting at theSink and tags all
+// variables of it can reach an & node as escaping and all function
+// parameters it can reach as leaking.
+//
+// If a value's address is taken but the address does not escape,
+// then the value can stay on the stack. If the value new(T) does
+// not escape, then new(T) can be rewritten into a stack allocation.
+// The same is true of slice literals.
+//
+// If optimizations are disabled (-N), this code is not used.
+// Instead, the compiler assumes that any value whose address
+// is taken without being immediately dereferenced
+// needs to be moved to the heap, and new(T) and slice
+// literals are always real allocations.
+
+type EscState struct {
+ theSink Node
+ funcParam Node
+ dsts *NodeList
+ loopdepth int
+ pdepth int
+ dstcount int
+ edgecount int
+ noesc *NodeList
+ recursive int
+}
+
+var tags [16]*Strlit
+
+func mktag(mask int) *Strlit {
+ var s *Strlit
+ var buf string
+
+ switch mask & EscMask {
+ case EscNone,
+ EscReturn:
+ break
+
+ default:
+ Fatal("escape mktag")
+ }
+
+ mask >>= EscBits
+
+ if mask < len(tags) && tags[mask] != nil {
+ return tags[mask]
+ }
+
+ buf = fmt.Sprintf("esc:0x%x", mask)
+ s = newstrlit(buf)
+ if mask < len(tags) {
+ tags[mask] = s
+ }
+ return s
+}
+
+func parsetag(note *Strlit) int {
+ var em int
+
+ if note == nil {
+ return EscUnknown
+ }
+ if !strings.HasPrefix(note.S, "esc:") {
+ return EscUnknown
+ }
+ em = atoi(note.S[4:])
+ if em == 0 {
+ return EscNone
+ }
+ return EscReturn | em<<EscBits
+}
+
+func analyze(all *NodeList, recursive int) {
+ var l *NodeList
+ var es EscState
+ var e *EscState
+
+ es = EscState{}
+ e = &es
+ e.theSink.Op = ONAME
+ e.theSink.Orig = &e.theSink
+ e.theSink.Class = PEXTERN
+ e.theSink.Sym = Lookup(".sink")
+ e.theSink.Escloopdepth = -1
+ e.recursive = recursive
+
+ e.funcParam.Op = ONAME
+ e.funcParam.Orig = &e.funcParam
+ e.funcParam.Class = PAUTO
+ e.funcParam.Sym = Lookup(".param")
+ e.funcParam.Escloopdepth = 10000000
+
+ for l = all; l != nil; l = l.Next {
+ if l.N.Op == ODCLFUNC {
+ l.N.Esc = EscFuncPlanned
+ }
+ }
+
+ // flow-analyze functions
+ for l = all; l != nil; l = l.Next {
+ if l.N.Op == ODCLFUNC {
+ escfunc(e, l.N)
+ }
+ }
+
+ // print("escapes: %d e->dsts, %d edges\n", e->dstcount, e->edgecount);
+
+ // visit the upstream of each dst, mark address nodes with
+ // addrescapes, mark parameters unsafe
+ for l = e.dsts; l != nil; l = l.Next {
+ escflood(e, l.N)
+ }
+
+ // for all top level functions, tag the typenodes corresponding to the param nodes
+ for l = all; l != nil; l = l.Next {
+ if l.N.Op == ODCLFUNC {
+ esctag(e, l.N)
+ }
+ }
+
+ if Debug['m'] != 0 {
+ for l = e.noesc; l != nil; l = l.Next {
+ if l.N.Esc == EscNone {
+ var tmp *Sym
+ if l.N.Curfn != nil && l.N.Curfn.Nname != nil {
+ tmp = l.N.Curfn.Nname.Sym
+ } else {
+ tmp = nil
+ }
+ Warnl(int(l.N.Lineno), "%v %v does not escape", Sconv(tmp, 0), Nconv(l.N, obj.FmtShort))
+ }
+ }
+ }
+}
+
+func escfunc(e *EscState, func_ *Node) {
+ var savefn *Node
+ var ll *NodeList
+ var saveld int
+
+ // print("escfunc %N %s\n", func->nname, e->recursive?"(recursive)":"");
+
+ if func_.Esc != 1 {
+ Fatal("repeat escfunc %v", Nconv(func_.Nname, 0))
+ }
+ func_.Esc = EscFuncStarted
+
+ saveld = e.loopdepth
+ e.loopdepth = 1
+ savefn = Curfn
+ Curfn = func_
+
+ for ll = Curfn.Dcl; ll != nil; ll = ll.Next {
+ if ll.N.Op != ONAME {
+ continue
+ }
+ switch ll.N.Class {
+ // out params are in a loopdepth between the sink and all local variables
+ case PPARAMOUT:
+ ll.N.Escloopdepth = 0
+
+ case PPARAM:
+ ll.N.Escloopdepth = 1
+ if ll.N.Type != nil && !haspointers(ll.N.Type) {
+ break
+ }
+ if Curfn.Nbody == nil && !Curfn.Noescape {
+ ll.N.Esc = EscHeap
+ } else {
+ ll.N.Esc = EscNone // prime for escflood later
+ }
+ e.noesc = list(e.noesc, ll.N)
+ }
+ }
+
+ // in a mutually recursive group we lose track of the return values
+ if e.recursive != 0 {
+ for ll = Curfn.Dcl; ll != nil; ll = ll.Next {
+ if ll.N.Op == ONAME && ll.N.Class == PPARAMOUT {
+ escflows(e, &e.theSink, ll.N)
+ }
+ }
+ }
+
+ escloopdepthlist(e, Curfn.Nbody)
+ esclist(e, Curfn.Nbody, Curfn)
+ Curfn = savefn
+ e.loopdepth = saveld
+}
+
+// Mark labels that have no backjumps to them as not increasing e->loopdepth.
+// Walk hasn't generated (goto|label)->left->sym->label yet, so we'll cheat
+// and set it to one of the following two. Then in esc we'll clear it again.
+var looping Label
+
+var nonlooping Label
+
+func escloopdepthlist(e *EscState, l *NodeList) {
+ for ; l != nil; l = l.Next {
+ escloopdepth(e, l.N)
+ }
+}
+
+func escloopdepth(e *EscState, n *Node) {
+ if n == nil {
+ return
+ }
+
+ escloopdepthlist(e, n.Ninit)
+
+ switch n.Op {
+ case OLABEL:
+ if !(n.Left != nil) || !(n.Left.Sym != nil) {
+ Fatal("esc:label without label: %v", Nconv(n, obj.FmtSign))
+ }
+
+ // Walk will complain about this label being already defined, but that's not until
+ // after escape analysis. in the future, maybe pull label & goto analysis out of walk and put before esc
+ // if(n->left->sym->label != nil)
+ // fatal("escape analysis messed up analyzing label: %+N", n);
+ n.Left.Sym.Label = &nonlooping
+
+ case OGOTO:
+ if !(n.Left != nil) || !(n.Left.Sym != nil) {
+ Fatal("esc:goto without label: %v", Nconv(n, obj.FmtSign))
+ }
+
+ // If we come past one that's uninitialized, this must be a (harmless) forward jump
+ // but if it's set to nonlooping the label must have preceded this goto.
+ if n.Left.Sym.Label == &nonlooping {
+ n.Left.Sym.Label = &looping
+ }
+ }
+
+ escloopdepth(e, n.Left)
+ escloopdepth(e, n.Right)
+ escloopdepthlist(e, n.List)
+ escloopdepth(e, n.Ntest)
+ escloopdepth(e, n.Nincr)
+ escloopdepthlist(e, n.Nbody)
+ escloopdepthlist(e, n.Nelse)
+ escloopdepthlist(e, n.Rlist)
+}
+
+func esclist(e *EscState, l *NodeList, up *Node) {
+ for ; l != nil; l = l.Next {
+ esc(e, l.N, up)
+ }
+}
+
+func esc(e *EscState, n *Node, up *Node) {
+ var lno int
+ var ll *NodeList
+ var lr *NodeList
+ var a *Node
+ var v *Node
+
+ if n == nil {
+ return
+ }
+
+ lno = int(setlineno(n))
+
+ // ninit logically runs at a different loopdepth than the rest of the for loop.
+ esclist(e, n.Ninit, n)
+
+ if n.Op == OFOR || n.Op == ORANGE {
+ e.loopdepth++
+ }
+
+ // type switch variables have no ODCL.
+ // process type switch as declaration.
+ // must happen before processing of switch body,
+ // so before recursion.
+ if n.Op == OSWITCH && n.Ntest != nil && n.Ntest.Op == OTYPESW {
+ for ll = n.List; ll != nil; ll = ll.Next { // cases
+
+ // ll->n->nname is the variable per case
+ if ll.N.Nname != nil {
+ ll.N.Nname.Escloopdepth = e.loopdepth
+ }
+ }
+ }
+
+ esc(e, n.Left, n)
+ esc(e, n.Right, n)
+ esc(e, n.Ntest, n)
+ esc(e, n.Nincr, n)
+ esclist(e, n.Nbody, n)
+ esclist(e, n.Nelse, n)
+ esclist(e, n.List, n)
+ esclist(e, n.Rlist, n)
+
+ if n.Op == OFOR || n.Op == ORANGE {
+ e.loopdepth--
+ }
+
+ if Debug['m'] > 1 {
+ var tmp *Sym
+ if Curfn != nil && Curfn.Nname != nil {
+ tmp = Curfn.Nname.Sym
+ } else {
+ tmp = nil
+ }
+ fmt.Printf("%v:[%d] %v esc: %v\n", Ctxt.Line(int(lineno)), e.loopdepth, Sconv(tmp, 0), Nconv(n, 0))
+ }
+
+ switch n.Op {
+ // Record loop depth at declaration.
+ case ODCL:
+ if n.Left != nil {
+ n.Left.Escloopdepth = e.loopdepth
+ }
+
+ case OLABEL:
+ if n.Left.Sym.Label == &nonlooping {
+ if Debug['m'] > 1 {
+ fmt.Printf("%v:%v non-looping label\n", Ctxt.Line(int(lineno)), Nconv(n, 0))
+ }
+ } else if n.Left.Sym.Label == &looping {
+ if Debug['m'] > 1 {
+ fmt.Printf("%v: %v looping label\n", Ctxt.Line(int(lineno)), Nconv(n, 0))
+ }
+ e.loopdepth++
+ }
+
+ // See case OLABEL in escloopdepth above
+ // else if(n->left->sym->label == nil)
+ // fatal("escape analysis missed or messed up a label: %+N", n);
+
+ n.Left.Sym.Label = nil
+
+ // Everything but fixed array is a dereference.
+ case ORANGE:
+ if Isfixedarray(n.Type) != 0 && n.List != nil && n.List.Next != nil {
+ escassign(e, n.List.Next.N, n.Right)
+ }
+
+ case OSWITCH:
+ if n.Ntest != nil && n.Ntest.Op == OTYPESW {
+ for ll = n.List; ll != nil; ll = ll.Next { // cases
+
+ // ntest->right is the argument of the .(type),
+ // ll->n->nname is the variable per case
+ escassign(e, ll.N.Nname, n.Ntest.Right)
+ }
+ }
+
+ // Filter out the following special case.
+ //
+ // func (b *Buffer) Foo() {
+ // n, m := ...
+ // b.buf = b.buf[n:m]
+ // }
+ //
+ // This assignment is a no-op for escape analysis,
+ // it does not store any new pointers into b that were not already there.
+ // However, without this special case b will escape, because we assign to OIND/ODOTPTR.
+ case OAS,
+ OASOP:
+ if (n.Left.Op == OIND || n.Left.Op == ODOTPTR) && n.Left.Left.Op == ONAME && (n.Right.Op == OSLICE || n.Right.Op == OSLICE3 || n.Right.Op == OSLICESTR) && (n.Right.Left.Op == OIND || n.Right.Left.Op == ODOTPTR) && n.Right.Left.Left.Op == ONAME && n.Left.Left == n.Right.Left.Left { // dst is ONAME dereference // src is slice operation // slice is applied to ONAME dereference // dst and src reference the same base ONAME
+
+ // Here we also assume that the statement will not contain calls,
+ // that is, that order will move any calls to init.
+ // Otherwise base ONAME value could change between the moments
+ // when we evaluate it for dst and for src.
+ //
+ // Note, this optimization does not apply to OSLICEARR,
+ // because it does introduce a new pointer into b that was not already there
+ // (pointer to b itself). After such assignment, if b contents escape,
+ // b escapes as well. If we ignore such OSLICEARR, we will conclude
+ // that b does not escape when b contents do.
+ if Debug['m'] != 0 {
+ var tmp *Sym
+ if n.Curfn != nil && n.Curfn.Nname != nil {
+ tmp = n.Curfn.Nname.Sym
+ } else {
+ tmp = nil
+ }
+ Warnl(int(n.Lineno), "%v ignoring self-assignment to %v", Sconv(tmp, 0), Nconv(n.Left, obj.FmtShort))
+ }
+
+ break
+ }
+
+ escassign(e, n.Left, n.Right)
+
+ case OAS2: // x,y = a,b
+ if count(n.List) == count(n.Rlist) {
+ ll = n.List
+ lr = n.Rlist
+ for ; ll != nil; (func() { ll = ll.Next; lr = lr.Next })() {
+ escassign(e, ll.N, lr.N)
+ }
+ }
+
+ case OAS2RECV, // v, ok = <-ch
+ OAS2MAPR, // v, ok = m[k]
+ OAS2DOTTYPE: // v, ok = x.(type)
+ escassign(e, n.List.N, n.Rlist.N)
+
+ case OSEND: // ch <- x
+ escassign(e, &e.theSink, n.Right)
+
+ case ODEFER:
+ if e.loopdepth == 1 { // top level
+ break
+ }
+ fallthrough
+
+ // go f(x) - f and x escape
+ // arguments leak out of scope
+ // TODO: leak to a dummy node instead
+ // fallthrough
+ case OPROC:
+ escassign(e, &e.theSink, n.Left.Left)
+
+ escassign(e, &e.theSink, n.Left.Right) // ODDDARG for call
+ for ll = n.Left.List; ll != nil; ll = ll.Next {
+ escassign(e, &e.theSink, ll.N)
+ }
+
+ case OCALLMETH,
+ OCALLFUNC,
+ OCALLINTER:
+ esccall(e, n, up)
+
+ // esccall already done on n->rlist->n. tie it's escretval to n->list
+ case OAS2FUNC: // x,y = f()
+ lr = n.Rlist.N.Escretval
+
+ for ll = n.List; lr != nil && ll != nil; (func() { lr = lr.Next; ll = ll.Next })() {
+ escassign(e, ll.N, lr.N)
+ }
+ if lr != nil || ll != nil {
+ Fatal("esc oas2func")
+ }
+
+ case ORETURN:
+ ll = n.List
+ if count(n.List) == 1 && Curfn.Type.Outtuple > 1 {
+ // OAS2FUNC in disguise
+ // esccall already done on n->list->n
+ // tie n->list->n->escretval to curfn->dcl PPARAMOUT's
+ ll = n.List.N.Escretval
+ }
+
+ for lr = Curfn.Dcl; lr != nil && ll != nil; lr = lr.Next {
+ if lr.N.Op != ONAME || lr.N.Class != PPARAMOUT {
+ continue
+ }
+ escassign(e, lr.N, ll.N)
+ ll = ll.Next
+ }
+
+ if ll != nil {
+ Fatal("esc return list")
+ }
+
+ // Argument could leak through recover.
+ case OPANIC:
+ escassign(e, &e.theSink, n.Left)
+
+ case OAPPEND:
+ if !(n.Isddd != 0) {
+ for ll = n.List.Next; ll != nil; ll = ll.Next {
+ escassign(e, &e.theSink, ll.N) // lose track of assign to dereference
+ }
+ }
+
+ case OCONV,
+ OCONVNOP,
+ OCONVIFACE:
+ escassign(e, n, n.Left)
+
+ case OARRAYLIT:
+ if Isslice(n.Type) != 0 {
+ n.Esc = EscNone // until proven otherwise
+ e.noesc = list(e.noesc, n)
+ n.Escloopdepth = e.loopdepth
+
+ // Values make it to memory, lose track.
+ for ll = n.List; ll != nil; ll = ll.Next {
+ escassign(e, &e.theSink, ll.N.Right)
+ }
+ } else {
+ // Link values to array.
+ for ll = n.List; ll != nil; ll = ll.Next {
+ escassign(e, n, ll.N.Right)
+ }
+ }
+
+ // Link values to struct.
+ case OSTRUCTLIT:
+ for ll = n.List; ll != nil; ll = ll.Next {
+ escassign(e, n, ll.N.Right)
+ }
+
+ case OPTRLIT:
+ n.Esc = EscNone // until proven otherwise
+ e.noesc = list(e.noesc, n)
+ n.Escloopdepth = e.loopdepth
+
+ // Link OSTRUCTLIT to OPTRLIT; if OPTRLIT escapes, OSTRUCTLIT elements do too.
+ escassign(e, n, n.Left)
+
+ case OCALLPART:
+ n.Esc = EscNone // until proven otherwise
+ e.noesc = list(e.noesc, n)
+ n.Escloopdepth = e.loopdepth
+
+ // Contents make it to memory, lose track.
+ escassign(e, &e.theSink, n.Left)
+
+ case OMAPLIT:
+ n.Esc = EscNone // until proven otherwise
+ e.noesc = list(e.noesc, n)
+ n.Escloopdepth = e.loopdepth
+
+ // Keys and values make it to memory, lose track.
+ for ll = n.List; ll != nil; ll = ll.Next {
+ escassign(e, &e.theSink, ll.N.Left)
+ escassign(e, &e.theSink, ll.N.Right)
+ }
+
+ // Link addresses of captured variables to closure.
+ case OCLOSURE:
+ for ll = n.Cvars; ll != nil; ll = ll.Next {
+ v = ll.N
+ if v.Op == OXXX { // unnamed out argument; see dcl.c:/^funcargs
+ continue
+ }
+ a = v.Closure
+ if !(v.Byval != 0) {
+ a = Nod(OADDR, a, nil)
+ a.Lineno = v.Lineno
+ a.Escloopdepth = e.loopdepth
+ typecheck(&a, Erv)
+ }
+
+ escassign(e, n, a)
+ }
+ fallthrough
+
+ // fallthrough
+ case OMAKECHAN,
+ OMAKEMAP,
+ OMAKESLICE,
+ ONEW,
+ OARRAYRUNESTR,
+ OARRAYBYTESTR,
+ OSTRARRAYRUNE,
+ OSTRARRAYBYTE,
+ ORUNESTR:
+ n.Escloopdepth = e.loopdepth
+
+ n.Esc = EscNone // until proven otherwise
+ e.noesc = list(e.noesc, n)
+
+ case OADDSTR:
+ n.Escloopdepth = e.loopdepth
+ n.Esc = EscNone // until proven otherwise
+ e.noesc = list(e.noesc, n)
+
+ // Arguments of OADDSTR do not escape.
+
+ case OADDR:
+ n.Esc = EscNone // until proven otherwise
+ e.noesc = list(e.noesc, n)
+
+ // current loop depth is an upper bound on actual loop depth
+ // of addressed value.
+ n.Escloopdepth = e.loopdepth
+
+ // for &x, use loop depth of x if known.
+ // it should always be known, but if not, be conservative
+ // and keep the current loop depth.
+ if n.Left.Op == ONAME {
+ switch n.Left.Class {
+ case PAUTO:
+ if n.Left.Escloopdepth != 0 {
+ n.Escloopdepth = n.Left.Escloopdepth
+ }
+
+ // PPARAM is loop depth 1 always.
+ // PPARAMOUT is loop depth 0 for writes
+ // but considered loop depth 1 for address-of,
+ // so that writing the address of one result
+ // to another (or the same) result makes the
+ // first result move to the heap.
+ case PPARAM,
+ PPARAMOUT:
+ n.Escloopdepth = 1
+ }
+ }
+ }
+
+ lineno = int32(lno)
+}
+
+// Assert that expr somehow gets assigned to dst, if non nil. for
+// dst==nil, any name node expr still must be marked as being
+// evaluated in curfn. For expr==nil, dst must still be examined for
+// evaluations inside it (e.g *f(x) = y)
+func escassign(e *EscState, dst *Node, src *Node) {
+ var lno int
+ var ll *NodeList
+
+ if isblank(dst) || dst == nil || src == nil || src.Op == ONONAME || src.Op == OXXX {
+ return
+ }
+
+ if Debug['m'] > 1 {
+ var tmp *Sym
+ if Curfn != nil && Curfn.Nname != nil {
+ tmp = Curfn.Nname.Sym
+ } else {
+ tmp = nil
+ }
+ fmt.Printf("%v:[%d] %v escassign: %v(%v) = %v(%v)\n", Ctxt.Line(int(lineno)), e.loopdepth, Sconv(tmp, 0), Nconv(dst, obj.FmtShort), Jconv(dst, obj.FmtShort), Nconv(src, obj.FmtShort), Jconv(src, obj.FmtShort))
+ }
+
+ setlineno(dst)
+
+ // Analyze lhs of assignment.
+ // Replace dst with e->theSink if we can't track it.
+ switch dst.Op {
+ default:
+ Dump("dst", dst)
+ Fatal("escassign: unexpected dst")
+ fallthrough
+
+ case OARRAYLIT,
+ OCLOSURE,
+ OCONV,
+ OCONVIFACE,
+ OCONVNOP,
+ OMAPLIT,
+ OSTRUCTLIT,
+ OPTRLIT,
+ OCALLPART:
+ break
+
+ case ONAME:
+ if dst.Class == PEXTERN {
+ dst = &e.theSink
+ }
+
+ case ODOT: // treat "dst.x = src" as "dst = src"
+ escassign(e, dst.Left, src)
+
+ return
+
+ case OINDEX:
+ if Isfixedarray(dst.Left.Type) != 0 {
+ escassign(e, dst.Left, src)
+ return
+ }
+
+ dst = &e.theSink // lose track of dereference
+
+ case OIND,
+ ODOTPTR:
+ dst = &e.theSink // lose track of dereference
+
+ // lose track of key and value
+ case OINDEXMAP:
+ escassign(e, &e.theSink, dst.Right)
+
+ dst = &e.theSink
+ }
+
+ lno = int(setlineno(src))
+ e.pdepth++
+
+ switch src.Op {
+ case OADDR, // dst = &x
+ OIND, // dst = *x
+ ODOTPTR, // dst = (*x).f
+ ONAME,
+ OPARAM,
+ ODDDARG,
+ OPTRLIT,
+ OARRAYLIT,
+ OMAPLIT,
+ OSTRUCTLIT,
+ OMAKECHAN,
+ OMAKEMAP,
+ OMAKESLICE,
+ OARRAYRUNESTR,
+ OARRAYBYTESTR,
+ OSTRARRAYRUNE,
+ OSTRARRAYBYTE,
+ OADDSTR,
+ ONEW,
+ OCLOSURE,
+ OCALLPART,
+ ORUNESTR:
+ escflows(e, dst, src)
+
+ // Flowing multiple returns to a single dst happens when
+ // analyzing "go f(g())": here g() flows to sink (issue 4529).
+ case OCALLMETH,
+ OCALLFUNC,
+ OCALLINTER:
+ for ll = src.Escretval; ll != nil; ll = ll.Next {
+ escflows(e, dst, ll.N)
+ }
+
+ // A non-pointer escaping from a struct does not concern us.
+ case ODOT:
+ if src.Type != nil && !haspointers(src.Type) {
+ break
+ }
+ fallthrough
+
+ // Conversions, field access, slice all preserve the input value.
+ // fallthrough
+ case OCONV,
+ OCONVIFACE,
+ OCONVNOP,
+ ODOTMETH,
+ // treat recv.meth as a value with recv in it, only happens in ODEFER and OPROC
+ // iface.method already leaks iface in esccall, no need to put in extra ODOTINTER edge here
+ ODOTTYPE,
+ ODOTTYPE2,
+ OSLICE,
+ OSLICE3,
+ OSLICEARR,
+ OSLICE3ARR,
+ OSLICESTR:
+ escassign(e, dst, src.Left)
+
+ // Append returns first argument.
+ case OAPPEND:
+ escassign(e, dst, src.List.N)
+
+ // Index of array preserves input value.
+ case OINDEX:
+ if Isfixedarray(src.Left.Type) != 0 {
+ escassign(e, dst, src.Left)
+ }
+
+ // Might be pointer arithmetic, in which case
+ // the operands flow into the result.
+ // TODO(rsc): Decide what the story is here. This is unsettling.
+ case OADD,
+ OSUB,
+ OOR,
+ OXOR,
+ OMUL,
+ ODIV,
+ OMOD,
+ OLSH,
+ ORSH,
+ OAND,
+ OANDNOT,
+ OPLUS,
+ OMINUS,
+ OCOM:
+ escassign(e, dst, src.Left)
+
+ escassign(e, dst, src.Right)
+ }
+
+ e.pdepth--
+ lineno = int32(lno)
+}
+
+func escassignfromtag(e *EscState, note *Strlit, dsts *NodeList, src *Node) int {
+ var em int
+ var em0 int
+
+ em = parsetag(note)
+
+ if em == EscUnknown {
+ escassign(e, &e.theSink, src)
+ return em
+ }
+
+ if em == EscNone {
+ return em
+ }
+
+ // If content inside parameter (reached via indirection)
+ // escapes back to results, mark as such.
+ if em&EscContentEscapes != 0 {
+ escassign(e, &e.funcParam, src)
+ }
+
+ em0 = em
+ for em >>= EscReturnBits; em != 0 && dsts != nil; (func() { em >>= 1; dsts = dsts.Next })() {
+ if em&1 != 0 {
+ escassign(e, dsts.N, src)
+ }
+ }
+
+ if em != 0 && dsts == nil {
+ Fatal("corrupt esc tag %v or messed up escretval list\n", Zconv(note, 0))
+ }
+ return em0
+}
+
+// This is a bit messier than fortunate, pulled out of esc's big
+// switch for clarity. We either have the paramnodes, which may be
+// connected to other things through flows or we have the parameter type
+// nodes, which may be marked "noescape". Navigating the ast is slightly
+// different for methods vs plain functions and for imported vs
+// this-package
+func esccall(e *EscState, n *Node, up *Node) {
+ var ll *NodeList
+ var lr *NodeList
+ var a *Node
+ var fn *Node
+ var src *Node
+ var t *Type
+ var fntype *Type
+ var buf string
+ var i int
+
+ fn = nil
+ switch n.Op {
+ default:
+ Fatal("esccall")
+ fallthrough
+
+ case OCALLFUNC:
+ fn = n.Left
+ fntype = fn.Type
+
+ case OCALLMETH:
+ fn = n.Left.Right.Sym.Def
+ if fn != nil {
+ fntype = fn.Type
+ } else {
+ fntype = n.Left.Type
+ }
+
+ case OCALLINTER:
+ fntype = n.Left.Type
+ }
+
+ ll = n.List
+ if n.List != nil && n.List.Next == nil {
+ a = n.List.N
+ if a.Type.Etype == TSTRUCT && a.Type.Funarg != 0 { // f(g()).
+ ll = a.Escretval
+ }
+ }
+
+ if fn != nil && fn.Op == ONAME && fn.Class == PFUNC && fn.Defn != nil && fn.Defn.Nbody != nil && fn.Ntype != nil && fn.Defn.Esc < EscFuncTagged {
+ // function in same mutually recursive group. Incorporate into flow graph.
+ // print("esc local fn: %N\n", fn->ntype);
+ if fn.Defn.Esc == EscFuncUnknown || n.Escretval != nil {
+ Fatal("graph inconsistency")
+ }
+
+ // set up out list on this call node
+ for lr = fn.Ntype.Rlist; lr != nil; lr = lr.Next {
+ n.Escretval = list(n.Escretval, lr.N.Left) // type.rlist -> dclfield -> ONAME (PPARAMOUT)
+ }
+
+ // Receiver.
+ if n.Op != OCALLFUNC {
+ escassign(e, fn.Ntype.Left.Left, n.Left.Left)
+ }
+
+ for lr = fn.Ntype.List; ll != nil && lr != nil; (func() { ll = ll.Next; lr = lr.Next })() {
+ src = ll.N
+ if lr.N.Isddd != 0 && !(n.Isddd != 0) {
+ // Introduce ODDDARG node to represent ... allocation.
+ src = Nod(ODDDARG, nil, nil)
+
+ src.Type = typ(TARRAY)
+ src.Type.Type = lr.N.Type.Type
+ src.Type.Bound = int64(count(ll))
+ src.Type = Ptrto(src.Type) // make pointer so it will be tracked
+ src.Escloopdepth = e.loopdepth
+ src.Lineno = n.Lineno
+ src.Esc = EscNone // until we find otherwise
+ e.noesc = list(e.noesc, src)
+ n.Right = src
+ }
+
+ if lr.N.Left != nil {
+ escassign(e, lr.N.Left, src)
+ }
+ if src != ll.N {
+ break
+ }
+ }
+
+ // "..." arguments are untracked
+ for ; ll != nil; ll = ll.Next {
+ escassign(e, &e.theSink, ll.N)
+ }
+
+ return
+ }
+
+ // Imported or completely analyzed function. Use the escape tags.
+ if n.Escretval != nil {
+ Fatal("esc already decorated call %v\n", Nconv(n, obj.FmtSign))
+ }
+
+ // set up out list on this call node with dummy auto ONAMES in the current (calling) function.
+ i = 0
+
+ for t = getoutargx(fntype).Type; t != nil; t = t.Down {
+ src = Nod(ONAME, nil, nil)
+ buf = fmt.Sprintf(".dum%d", i)
+ i++
+ src.Sym = Lookup(buf)
+ src.Type = t.Type
+ src.Class = PAUTO
+ src.Curfn = Curfn
+ src.Escloopdepth = e.loopdepth
+ src.Used = 1
+ src.Lineno = n.Lineno
+ n.Escretval = list(n.Escretval, src)
+ }
+
+ // print("esc analyzed fn: %#N (%+T) returning (%+H)\n", fn, fntype, n->escretval);
+
+ // Receiver.
+ if n.Op != OCALLFUNC {
+ t = getthisx(fntype).Type
+ src = n.Left.Left
+ if haspointers(t.Type) {
+ escassignfromtag(e, t.Note, n.Escretval, src)
+ }
+ }
+
+ for t = getinargx(fntype).Type; ll != nil; ll = ll.Next {
+ src = ll.N
+ if t.Isddd != 0 && !(n.Isddd != 0) {
+ // Introduce ODDDARG node to represent ... allocation.
+ src = Nod(ODDDARG, nil, nil)
+
+ src.Escloopdepth = e.loopdepth
+ src.Lineno = n.Lineno
+ src.Type = typ(TARRAY)
+ src.Type.Type = t.Type.Type
+ src.Type.Bound = int64(count(ll))
+ src.Type = Ptrto(src.Type) // make pointer so it will be tracked
+ src.Esc = EscNone // until we find otherwise
+ e.noesc = list(e.noesc, src)
+ n.Right = src
+ }
+
+ if haspointers(t.Type) {
+ if escassignfromtag(e, t.Note, n.Escretval, src) == EscNone && up.Op != ODEFER && up.Op != OPROC {
+ a = src
+ for a.Op == OCONVNOP {
+ a = a.Left
+ }
+ switch a.Op {
+ // The callee has already been analyzed, so its arguments have esc tags.
+ // The argument is marked as not escaping at all.
+ // Record that fact so that any temporary used for
+ // synthesizing this expression can be reclaimed when
+ // the function returns.
+ // This 'noescape' is even stronger than the usual esc == EscNone.
+ // src->esc == EscNone means that src does not escape the current function.
+ // src->noescape = 1 here means that src does not escape this statement
+ // in the current function.
+ case OCALLPART,
+ OCLOSURE,
+ ODDDARG,
+ OARRAYLIT,
+ OPTRLIT,
+ OSTRUCTLIT:
+ a.Noescape = true
+ }
+ }
+ }
+
+ if src != ll.N {
+ break
+ }
+ t = t.Down
+ }
+
+ // "..." arguments are untracked
+ for ; ll != nil; ll = ll.Next {
+ escassign(e, &e.theSink, ll.N)
+ }
+}
+
+// Store the link src->dst in dst, throwing out some quick wins.
+func escflows(e *EscState, dst *Node, src *Node) {
+ if dst == nil || src == nil || dst == src {
+ return
+ }
+
+ // Don't bother building a graph for scalars.
+ if src.Type != nil && !haspointers(src.Type) {
+ return
+ }
+
+ if Debug['m'] > 2 {
+ fmt.Printf("%v::flows:: %v <- %v\n", Ctxt.Line(int(lineno)), Nconv(dst, obj.FmtShort), Nconv(src, obj.FmtShort))
+ }
+
+ if dst.Escflowsrc == nil {
+ e.dsts = list(e.dsts, dst)
+ e.dstcount++
+ }
+
+ e.edgecount++
+
+ dst.Escflowsrc = list(dst.Escflowsrc, src)
+}
+
+// Whenever we hit a reference node, the level goes up by one, and whenever
+// we hit an OADDR, the level goes down by one. as long as we're on a level > 0
+// finding an OADDR just means we're following the upstream of a dereference,
+// so this address doesn't leak (yet).
+// If level == 0, it means the /value/ of this node can reach the root of this flood.
+// so if this node is an OADDR, it's argument should be marked as escaping iff
+// it's currfn/e->loopdepth are different from the flood's root.
+// Once an object has been moved to the heap, all of it's upstream should be considered
+// escaping to the global scope.
+func escflood(e *EscState, dst *Node) {
+ var l *NodeList
+
+ switch dst.Op {
+ case ONAME,
+ OCLOSURE:
+ break
+
+ default:
+ return
+ }
+
+ if Debug['m'] > 1 {
+ var tmp *Sym
+ if dst.Curfn != nil && dst.Curfn.Nname != nil {
+ tmp = dst.Curfn.Nname.Sym
+ } else {
+ tmp = nil
+ }
+ fmt.Printf("\nescflood:%d: dst %v scope:%v[%d]\n", walkgen, Nconv(dst, obj.FmtShort), Sconv(tmp, 0), dst.Escloopdepth)
+ }
+
+ for l = dst.Escflowsrc; l != nil; l = l.Next {
+ walkgen++
+ escwalk(e, 0, dst, l.N)
+ }
+}
+
+// There appear to be some loops in the escape graph, causing
+// arbitrary recursion into deeper and deeper levels.
+// Cut this off safely by making minLevel sticky: once you
+// get that deep, you cannot go down any further but you also
+// cannot go up any further. This is a conservative fix.
+// Making minLevel smaller (more negative) would handle more
+// complex chains of indirections followed by address-of operations,
+// at the cost of repeating the traversal once for each additional
+// allowed level when a loop is encountered. Using -2 suffices to
+// pass all the tests we have written so far, which we assume matches
+// the level of complexity we want the escape analysis code to handle.
+const (
+ MinLevel = -2
+)
+
+func escwalk(e *EscState, level int, dst *Node, src *Node) {
+ var ll *NodeList
+ var leaks int
+ var newlevel int
+
+ if src.Walkgen == walkgen && src.Esclevel <= int32(level) {
+ return
+ }
+ src.Walkgen = walkgen
+ src.Esclevel = int32(level)
+
+ if Debug['m'] > 1 {
+ var tmp *Sym
+ if src.Curfn != nil && src.Curfn.Nname != nil {
+ tmp = src.Curfn.Nname.Sym
+ } else {
+ tmp = nil
+ }
+ fmt.Printf("escwalk: level:%d depth:%d %.*s %v(%v) scope:%v[%d]\n", level, e.pdepth, e.pdepth, "\t\t\t\t\t\t\t\t\t\t", Nconv(src, obj.FmtShort), Jconv(src, obj.FmtShort), Sconv(tmp, 0), src.Escloopdepth)
+ }
+
+ e.pdepth++
+
+ // Input parameter flowing to output parameter?
+ if dst.Op == ONAME && dst.Class == PPARAMOUT && dst.Vargen <= 20 {
+ if src.Op == ONAME && src.Class == PPARAM && src.Curfn == dst.Curfn && src.Esc != EscScope && src.Esc != EscHeap {
+ if level == 0 {
+ if Debug['m'] != 0 {
+ Warnl(int(src.Lineno), "leaking param: %v to result %v", Nconv(src, obj.FmtShort), Sconv(dst.Sym, 0))
+ }
+ if src.Esc&EscMask != EscReturn {
+ src.Esc = EscReturn
+ }
+ src.Esc |= 1 << uint((dst.Vargen-1)+EscReturnBits)
+ goto recurse
+ } else if level > 0 {
+ if Debug['m'] != 0 {
+ Warnl(int(src.Lineno), "%v leaking param %v content to result %v", Nconv(src.Curfn.Nname, 0), Nconv(src, obj.FmtShort), Sconv(dst.Sym, 0))
+ }
+ if src.Esc&EscMask != EscReturn {
+ src.Esc = EscReturn
+ }
+ src.Esc |= EscContentEscapes
+ goto recurse
+ }
+ }
+ }
+
+ // The second clause is for values pointed at by an object passed to a call
+ // that returns something reached via indirect from the object.
+ // We don't know which result it is or how many indirects, so we treat it as leaking.
+ leaks = bool2int(level <= 0 && dst.Escloopdepth < src.Escloopdepth || level < 0 && dst == &e.funcParam && haspointers(src.Type))
+
+ switch src.Op {
+ case ONAME:
+ if src.Class == PPARAM && (leaks != 0 || dst.Escloopdepth < 0) && src.Esc != EscHeap {
+ src.Esc = EscScope
+ if Debug['m'] != 0 {
+ Warnl(int(src.Lineno), "leaking param: %v", Nconv(src, obj.FmtShort))
+ }
+ }
+
+ // Treat a PPARAMREF closure variable as equivalent to the
+ // original variable.
+ if src.Class == PPARAMREF {
+ if leaks != 0 && Debug['m'] != 0 {
+ Warnl(int(src.Lineno), "leaking closure reference %v", Nconv(src, obj.FmtShort))
+ }
+ escwalk(e, level, dst, src.Closure)
+ }
+
+ case OPTRLIT,
+ OADDR:
+ if leaks != 0 {
+ src.Esc = EscHeap
+ addrescapes(src.Left)
+ if Debug['m'] != 0 {
+ Warnl(int(src.Lineno), "%v escapes to heap", Nconv(src, obj.FmtShort))
+ }
+ }
+
+ newlevel = level
+ if level > MinLevel {
+ newlevel--
+ }
+ escwalk(e, newlevel, dst, src.Left)
+
+ case OARRAYLIT:
+ if Isfixedarray(src.Type) != 0 {
+ break
+ }
+ fallthrough
+
+ // fall through
+ case ODDDARG,
+ OMAKECHAN,
+ OMAKEMAP,
+ OMAKESLICE,
+ OARRAYRUNESTR,
+ OARRAYBYTESTR,
+ OSTRARRAYRUNE,
+ OSTRARRAYBYTE,
+ OADDSTR,
+ OMAPLIT,
+ ONEW,
+ OCLOSURE,
+ OCALLPART,
+ ORUNESTR:
+ if leaks != 0 {
+ src.Esc = EscHeap
+ if Debug['m'] != 0 {
+ Warnl(int(src.Lineno), "%v escapes to heap", Nconv(src, obj.FmtShort))
+ }
+ }
+
+ case ODOT,
+ OSLICE,
+ OSLICEARR,
+ OSLICE3,
+ OSLICE3ARR,
+ OSLICESTR:
+ escwalk(e, level, dst, src.Left)
+
+ case OINDEX:
+ if Isfixedarray(src.Left.Type) != 0 {
+ escwalk(e, level, dst, src.Left)
+ break
+ }
+ fallthrough
+
+ // fall through
+ case ODOTPTR,
+ OINDEXMAP,
+ OIND:
+ newlevel = level
+
+ if level > MinLevel {
+ newlevel++
+ }
+ escwalk(e, newlevel, dst, src.Left)
+ }
+
+recurse:
+ for ll = src.Escflowsrc; ll != nil; ll = ll.Next {
+ escwalk(e, level, dst, ll.N)
+ }
+
+ e.pdepth--
+}
+
+func esctag(e *EscState, func_ *Node) {
+ var savefn *Node
+ var ll *NodeList
+ var t *Type
+
+ func_.Esc = EscFuncTagged
+
+ // External functions are assumed unsafe,
+ // unless //go:noescape is given before the declaration.
+ if func_.Nbody == nil {
+ if func_.Noescape {
+ for t = getinargx(func_.Type).Type; t != nil; t = t.Down {
+ if haspointers(t.Type) {
+ t.Note = mktag(EscNone)
+ }
+ }
+ }
+
+ return
+ }
+
+ savefn = Curfn
+ Curfn = func_
+
+ for ll = Curfn.Dcl; ll != nil; ll = ll.Next {
+ if ll.N.Op != ONAME || ll.N.Class != PPARAM {
+ continue
+ }
+
+ switch ll.N.Esc & EscMask {
+ case EscNone, // not touched by escflood
+ EscReturn:
+ if haspointers(ll.N.Type) { // don't bother tagging for scalars
+ ll.N.Paramfld.Note = mktag(int(ll.N.Esc))
+ }
+
+ case EscHeap, // touched by escflood, moved to heap
+ EscScope: // touched by escflood, value leaves scope
+ break
+ }
+ }
+
+ Curfn = savefn
+}
diff --git a/src/cmd/internal/gc/export.go b/src/cmd/internal/gc/export.go
new file mode 100644
index 0000000..5b34fe2
--- /dev/null
+++ b/src/cmd/internal/gc/export.go
@@ -0,0 +1,596 @@
+// 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
+
+import (
+ "cmd/internal/obj"
+ "fmt"
+ "sort"
+ "unicode"
+ "unicode/utf8"
+)
+
+var asmlist *NodeList
+
+// Mark n's symbol as exported
+func exportsym(n *Node) {
+ if n == nil || n.Sym == nil {
+ return
+ }
+ if n.Sym.Flags&(SymExport|SymPackage) != 0 {
+ if n.Sym.Flags&SymPackage != 0 {
+ Yyerror("export/package mismatch: %v", Sconv(n.Sym, 0))
+ }
+ return
+ }
+
+ n.Sym.Flags |= SymExport
+
+ if Debug['E'] != 0 {
+ fmt.Printf("export symbol %v\n", Sconv(n.Sym, 0))
+ }
+ exportlist = list(exportlist, n)
+}
+
+func exportname(s string) bool {
+ if s[0] < utf8.RuneSelf {
+ return 'A' <= s[0] && s[0] <= 'Z'
+ }
+ r, _ := utf8.DecodeRuneInString(s)
+ return unicode.IsUpper(r)
+}
+
+func initname(s string) int {
+ return bool2int(s == "init")
+}
+
+// exportedsym reports whether a symbol will be visible
+// to files that import our package.
+func exportedsym(sym *Sym) int {
+ // Builtins are visible everywhere.
+ if sym.Pkg == builtinpkg || sym.Origpkg == builtinpkg {
+ return 1
+ }
+
+ return bool2int(sym.Pkg == localpkg && exportname(sym.Name))
+}
+
+func autoexport(n *Node, ctxt int) {
+ if n == nil || n.Sym == nil {
+ return
+ }
+ if (ctxt != PEXTERN && ctxt != PFUNC) || dclcontext != PEXTERN {
+ return
+ }
+ if n.Ntype != nil && n.Ntype.Op == OTFUNC && n.Ntype.Left != nil { // method
+ return
+ }
+
+ // -A is for cmd/gc/mkbuiltin script, so export everything
+ if Debug['A'] != 0 || exportname(n.Sym.Name) || initname(n.Sym.Name) != 0 {
+ exportsym(n)
+ }
+ if asmhdr != "" && n.Sym.Pkg == localpkg && !(n.Sym.Flags&SymAsm != 0) {
+ n.Sym.Flags |= SymAsm
+ asmlist = list(asmlist, n)
+ }
+}
+
+func dumppkg(p *Pkg) {
+ var suffix string
+
+ if p == nil || p == localpkg || p.Exported != 0 || p == builtinpkg {
+ return
+ }
+ p.Exported = 1
+ suffix = ""
+ if !(p.Direct != 0) {
+ suffix = " // indirect"
+ }
+ fmt.Fprintf(bout, "\timport %s \"%v\"%s\n", p.Name, Zconv(p.Path, 0), suffix)
+}
+
+// Look for anything we need for the inline body
+func reexportdeplist(ll *NodeList) {
+ for ; ll != nil; ll = ll.Next {
+ reexportdep(ll.N)
+ }
+}
+
+func reexportdep(n *Node) {
+ var t *Type
+
+ if !(n != nil) {
+ return
+ }
+
+ //print("reexportdep %+hN\n", n);
+ switch n.Op {
+ case ONAME:
+ switch n.Class &^ PHEAP {
+ // methods will be printed along with their type
+ // nodes for T.Method expressions
+ case PFUNC:
+ if n.Left != nil && n.Left.Op == OTYPE {
+ break
+ }
+
+ // nodes for method calls.
+ if !(n.Type != nil) || n.Type.Thistuple > 0 {
+ break
+ }
+ fallthrough
+
+ // fallthrough
+ case PEXTERN:
+ if n.Sym != nil && !(exportedsym(n.Sym) != 0) {
+ if Debug['E'] != 0 {
+ fmt.Printf("reexport name %v\n", Sconv(n.Sym, 0))
+ }
+ exportlist = list(exportlist, n)
+ }
+ }
+
+ // Local variables in the bodies need their type.
+ case ODCL:
+ t = n.Left.Type
+
+ if t != Types[t.Etype] && t != idealbool && t != idealstring {
+ if Isptr[t.Etype] != 0 {
+ t = t.Type
+ }
+ if t != nil && t.Sym != nil && t.Sym.Def != nil && !(exportedsym(t.Sym) != 0) {
+ if Debug['E'] != 0 {
+ fmt.Printf("reexport type %v from declaration\n", Sconv(t.Sym, 0))
+ }
+ exportlist = list(exportlist, t.Sym.Def)
+ }
+ }
+
+ case OLITERAL:
+ t = n.Type
+ if t != Types[n.Type.Etype] && t != idealbool && t != idealstring {
+ if Isptr[t.Etype] != 0 {
+ t = t.Type
+ }
+ if t != nil && t.Sym != nil && t.Sym.Def != nil && !(exportedsym(t.Sym) != 0) {
+ if Debug['E'] != 0 {
+ fmt.Printf("reexport literal type %v\n", Sconv(t.Sym, 0))
+ }
+ exportlist = list(exportlist, t.Sym.Def)
+ }
+ }
+ fallthrough
+
+ // fallthrough
+ case OTYPE:
+ if n.Sym != nil && !(exportedsym(n.Sym) != 0) {
+ if Debug['E'] != 0 {
+ fmt.Printf("reexport literal/type %v\n", Sconv(n.Sym, 0))
+ }
+ exportlist = list(exportlist, n)
+ }
+
+ // for operations that need a type when rendered, put the type on the export list.
+ case OCONV,
+ OCONVIFACE,
+ OCONVNOP,
+ ORUNESTR,
+ OARRAYBYTESTR,
+ OARRAYRUNESTR,
+ OSTRARRAYBYTE,
+ OSTRARRAYRUNE,
+ ODOTTYPE,
+ ODOTTYPE2,
+ OSTRUCTLIT,
+ OARRAYLIT,
+ OPTRLIT,
+ OMAKEMAP,
+ OMAKESLICE,
+ OMAKECHAN:
+ t = n.Type
+
+ if !(t.Sym != nil) && t.Type != nil {
+ t = t.Type
+ }
+ if t != nil && t.Sym != nil && t.Sym.Def != nil && !(exportedsym(t.Sym) != 0) {
+ if Debug['E'] != 0 {
+ fmt.Printf("reexport type for expression %v\n", Sconv(t.Sym, 0))
+ }
+ exportlist = list(exportlist, t.Sym.Def)
+ }
+ }
+
+ reexportdep(n.Left)
+ reexportdep(n.Right)
+ reexportdeplist(n.List)
+ reexportdeplist(n.Rlist)
+ reexportdeplist(n.Ninit)
+ reexportdep(n.Ntest)
+ reexportdep(n.Nincr)
+ reexportdeplist(n.Nbody)
+ reexportdeplist(n.Nelse)
+}
+
+func dumpexportconst(s *Sym) {
+ var n *Node
+ var t *Type
+
+ n = s.Def
+ typecheck(&n, Erv)
+ if n == nil || n.Op != OLITERAL {
+ Fatal("dumpexportconst: oconst nil: %v", Sconv(s, 0))
+ }
+
+ t = n.Type // may or may not be specified
+ dumpexporttype(t)
+
+ if t != nil && !(isideal(t) != 0) {
+ fmt.Fprintf(bout, "\tconst %v %v = %v\n", Sconv(s, obj.FmtSharp), Tconv(t, obj.FmtSharp), Vconv(&n.Val, obj.FmtSharp))
+ } else {
+ fmt.Fprintf(bout, "\tconst %v = %v\n", Sconv(s, obj.FmtSharp), Vconv(&n.Val, obj.FmtSharp))
+ }
+}
+
+func dumpexportvar(s *Sym) {
+ var n *Node
+ var t *Type
+
+ n = s.Def
+ typecheck(&n, Erv|Ecall)
+ if n == nil || n.Type == nil {
+ Yyerror("variable exported but not defined: %v", Sconv(s, 0))
+ return
+ }
+
+ t = n.Type
+ dumpexporttype(t)
+
+ if t.Etype == TFUNC && n.Class == PFUNC {
+ if n.Inl != nil {
+ // when lazily typechecking inlined bodies, some re-exported ones may not have been typechecked yet.
+ // currently that can leave unresolved ONONAMEs in import-dot-ed packages in the wrong package
+ if Debug['l'] < 2 {
+ typecheckinl(n)
+ }
+
+ // NOTE: The space after %#S here is necessary for ld's export data parser.
+ fmt.Fprintf(bout, "\tfunc %v %v { %v }\n", Sconv(s, obj.FmtSharp), Tconv(t, obj.FmtShort|obj.FmtSharp), Hconv(n.Inl, obj.FmtSharp))
+
+ reexportdeplist(n.Inl)
+ } else {
+ fmt.Fprintf(bout, "\tfunc %v %v\n", Sconv(s, obj.FmtSharp), Tconv(t, obj.FmtShort|obj.FmtSharp))
+ }
+ } else {
+ fmt.Fprintf(bout, "\tvar %v %v\n", Sconv(s, obj.FmtSharp), Tconv(t, obj.FmtSharp))
+ }
+}
+
+type methodbyname []*Type
+
+func (x methodbyname) Len() int {
+ return len(x)
+}
+
+func (x methodbyname) Swap(i, j int) {
+ x[i], x[j] = x[j], x[i]
+}
+
+func (x methodbyname) Less(i, j int) bool {
+ var a *Type
+ var b *Type
+
+ a = x[i]
+ b = x[j]
+ return stringsCompare(a.Sym.Name, b.Sym.Name) < 0
+}
+
+func dumpexporttype(t *Type) {
+ var f *Type
+ var m []*Type
+ var i int
+ var n int
+
+ if t == nil {
+ return
+ }
+ if t.Printed != 0 || t == Types[t.Etype] || t == bytetype || t == runetype || t == errortype {
+ return
+ }
+ t.Printed = 1
+
+ if t.Sym != nil && t.Etype != TFIELD {
+ dumppkg(t.Sym.Pkg)
+ }
+
+ dumpexporttype(t.Type)
+ dumpexporttype(t.Down)
+
+ if t.Sym == nil || t.Etype == TFIELD {
+ return
+ }
+
+ n = 0
+ for f = t.Method; f != nil; f = f.Down {
+ dumpexporttype(f)
+ n++
+ }
+
+ m = make([]*Type, n)
+ i = 0
+ for f = t.Method; f != nil; f = f.Down {
+ m[i] = f
+ i++
+ }
+ sort.Sort(methodbyname(m[:n]))
+
+ fmt.Fprintf(bout, "\ttype %v %v\n", Sconv(t.Sym, obj.FmtSharp), Tconv(t, obj.FmtSharp|obj.FmtLong))
+ for i = 0; i < n; i++ {
+ f = m[i]
+ if f.Nointerface != 0 {
+ fmt.Fprintf(bout, "\t//go:nointerface\n")
+ }
+ if f.Type.Nname != nil && f.Type.Nname.Inl != nil { // nname was set by caninl
+
+ // when lazily typechecking inlined bodies, some re-exported ones may not have been typechecked yet.
+ // currently that can leave unresolved ONONAMEs in import-dot-ed packages in the wrong package
+ if Debug['l'] < 2 {
+ typecheckinl(f.Type.Nname)
+ }
+ fmt.Fprintf(bout, "\tfunc (%v) %v %v { %v }\n", Tconv(getthisx(f.Type).Type, obj.FmtSharp), Sconv(f.Sym, obj.FmtShort|obj.FmtByte|obj.FmtSharp), Tconv(f.Type, obj.FmtShort|obj.FmtSharp), Hconv(f.Type.Nname.Inl, obj.FmtSharp))
+ reexportdeplist(f.Type.Nname.Inl)
+ } else {
+ fmt.Fprintf(bout, "\tfunc (%v) %v %v\n", Tconv(getthisx(f.Type).Type, obj.FmtSharp), Sconv(f.Sym, obj.FmtShort|obj.FmtByte|obj.FmtSharp), Tconv(f.Type, obj.FmtShort|obj.FmtSharp))
+ }
+ }
+}
+
+func dumpsym(s *Sym) {
+ if s.Flags&SymExported != 0 {
+ return
+ }
+ s.Flags |= SymExported
+
+ if s.Def == nil {
+ Yyerror("unknown export symbol: %v", Sconv(s, 0))
+ return
+ }
+
+ // print("dumpsym %O %+S\n", s->def->op, s);
+ dumppkg(s.Pkg)
+
+ switch s.Def.Op {
+ default:
+ Yyerror("unexpected export symbol: %v %v", Oconv(int(s.Def.Op), 0), Sconv(s, 0))
+
+ case OLITERAL:
+ dumpexportconst(s)
+
+ case OTYPE:
+ if s.Def.Type.Etype == TFORW {
+ Yyerror("export of incomplete type %v", Sconv(s, 0))
+ } else {
+ dumpexporttype(s.Def.Type)
+ }
+
+ case ONAME:
+ dumpexportvar(s)
+ }
+}
+
+func dumpexport() {
+ var l *NodeList
+ var i int32
+ var lno int32
+ var p *Pkg
+
+ lno = lineno
+
+ fmt.Fprintf(bout, "\n$$\npackage %s", localpkg.Name)
+ if safemode != 0 {
+ fmt.Fprintf(bout, " safe")
+ }
+ fmt.Fprintf(bout, "\n")
+
+ for i = 0; i < int32(len(phash)); i++ {
+ for p = phash[i]; p != nil; p = p.Link {
+ if p.Direct != 0 {
+ dumppkg(p)
+ }
+ }
+ }
+
+ for l = exportlist; l != nil; l = l.Next {
+ lineno = l.N.Lineno
+ dumpsym(l.N.Sym)
+ }
+
+ fmt.Fprintf(bout, "\n$$\n")
+ lineno = lno
+}
+
+/*
+ * import
+ */
+
+/*
+ * return the sym for ss, which should match lexical
+ */
+func importsym(s *Sym, op int) *Sym {
+ var pkgstr string
+
+ if s.Def != nil && int(s.Def.Op) != op {
+ pkgstr = fmt.Sprintf("during import \"%v\"", Zconv(importpkg.Path, 0))
+ redeclare(s, pkgstr)
+ }
+
+ // mark the symbol so it is not reexported
+ if s.Def == nil {
+ if exportname(s.Name) || initname(s.Name) != 0 {
+ s.Flags |= SymExport
+ } else {
+ s.Flags |= SymPackage // package scope
+ }
+ }
+
+ return s
+}
+
+/*
+ * return the type pkg.name, forward declaring if needed
+ */
+func pkgtype(s *Sym) *Type {
+ var t *Type
+
+ importsym(s, OTYPE)
+ if s.Def == nil || s.Def.Op != OTYPE {
+ t = typ(TFORW)
+ t.Sym = s
+ s.Def = typenod(t)
+ }
+
+ if s.Def.Type == nil {
+ Yyerror("pkgtype %v", Sconv(s, 0))
+ }
+ return s.Def.Type
+}
+
+func importimport(s *Sym, z *Strlit) {
+ // Informational: record package name
+ // associated with import path, for use in
+ // human-readable messages.
+ var p *Pkg
+
+ if isbadimport(z) {
+ errorexit()
+ }
+ p = mkpkg(z)
+ if p.Name == "" {
+ p.Name = s.Name
+ Pkglookup(s.Name, nil).Npkg++
+ } else if p.Name != s.Name {
+ Yyerror("conflicting names %s and %s for package \"%v\"", p.Name, s.Name, Zconv(p.Path, 0))
+ }
+
+ if !(incannedimport != 0) && myimportpath != "" && z.S == myimportpath {
+ Yyerror("import \"%v\": package depends on \"%v\" (import cycle)", Zconv(importpkg.Path, 0), Zconv(z, 0))
+ errorexit()
+ }
+}
+
+func importconst(s *Sym, t *Type, n *Node) {
+ var n1 *Node
+
+ importsym(s, OLITERAL)
+ Convlit(&n, t)
+
+ if s.Def != nil { // TODO: check if already the same.
+ return
+ }
+
+ if n.Op != OLITERAL {
+ Yyerror("expression must be a constant")
+ return
+ }
+
+ if n.Sym != nil {
+ n1 = Nod(OXXX, nil, nil)
+ *n1 = *n
+ n = n1
+ }
+
+ n.Orig = newname(s)
+ n.Sym = s
+ declare(n, PEXTERN)
+
+ if Debug['E'] != 0 {
+ fmt.Printf("import const %v\n", Sconv(s, 0))
+ }
+}
+
+func importvar(s *Sym, t *Type) {
+ var n *Node
+
+ importsym(s, ONAME)
+ if s.Def != nil && s.Def.Op == ONAME {
+ if Eqtype(t, s.Def.Type) {
+ return
+ }
+ Yyerror("inconsistent definition for var %v during import\n\t%v (in \"%v\")\n\t%v (in \"%v\")", Sconv(s, 0), Tconv(s.Def.Type, 0), Zconv(s.Importdef.Path, 0), Tconv(t, 0), Zconv(importpkg.Path, 0))
+ }
+
+ n = newname(s)
+ s.Importdef = importpkg
+ n.Type = t
+ declare(n, PEXTERN)
+
+ if Debug['E'] != 0 {
+ fmt.Printf("import var %v %v\n", Sconv(s, 0), Tconv(t, obj.FmtLong))
+ }
+}
+
+func importtype(pt *Type, t *Type) {
+ var n *Node
+
+ // override declaration in unsafe.go for Pointer.
+ // there is no way in Go code to define unsafe.Pointer
+ // so we have to supply it.
+ if incannedimport != 0 && importpkg.Name == "unsafe" && pt.Nod.Sym.Name == "Pointer" {
+ t = Types[TUNSAFEPTR]
+ }
+
+ if pt.Etype == TFORW {
+ n = pt.Nod
+ copytype(pt.Nod, t)
+ pt.Nod = n // unzero nod
+ pt.Sym.Importdef = importpkg
+ pt.Sym.Lastlineno = int32(parserline())
+ declare(n, PEXTERN)
+ checkwidth(pt)
+ } else if !Eqtype(pt.Orig, t) {
+ Yyerror("inconsistent definition for type %v during import\n\t%v (in \"%v\")\n\t%v (in \"%v\")", Sconv(pt.Sym, 0), Tconv(pt, obj.FmtLong), Zconv(pt.Sym.Importdef.Path, 0), Tconv(t, obj.FmtLong), Zconv(importpkg.Path, 0))
+ }
+
+ if Debug['E'] != 0 {
+ fmt.Printf("import type %v %v\n", Tconv(pt, 0), Tconv(t, obj.FmtLong))
+ }
+}
+
+func dumpasmhdr() {
+ var b *obj.Biobuf
+ var l *NodeList
+ var n *Node
+ var t *Type
+
+ b, err := obj.Bopenw(asmhdr)
+ if err != nil {
+ Fatal("%v", err)
+ }
+ fmt.Fprintf(b, "// generated by %cg -asmhdr from package %s\n\n", Thearch.Thechar, localpkg.Name)
+ for l = asmlist; l != nil; l = l.Next {
+ n = l.N
+ if isblanksym(n.Sym) {
+ continue
+ }
+ switch n.Op {
+ case OLITERAL:
+ fmt.Fprintf(b, "#define const_%s %v\n", n.Sym.Name, Vconv(&n.Val, obj.FmtSharp))
+
+ case OTYPE:
+ t = n.Type
+ if t.Etype != TSTRUCT || t.Map != nil || t.Funarg != 0 {
+ break
+ }
+ fmt.Fprintf(b, "#define %s__size %d\n", t.Sym.Name, int(t.Width))
+ for t = t.Type; t != nil; t = t.Down {
+ if !isblanksym(t.Sym) {
+ fmt.Fprintf(b, "#define %s_%s %d\n", n.Sym.Name, t.Sym.Name, int(t.Width))
+ }
+ }
+ }
+ }
+
+ obj.Bterm(b)
+}
diff --git a/src/cmd/internal/gc/fmt.go b/src/cmd/internal/gc/fmt.go
new file mode 100644
index 0000000..08c08a4
--- /dev/null
+++ b/src/cmd/internal/gc/fmt.go
@@ -0,0 +1,1953 @@
+// Copyright 2011 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
+
+import (
+ "cmd/internal/obj"
+ "fmt"
+ "strings"
+ "unicode/utf8"
+)
+
+//
+// Format conversions
+// %L int Line numbers
+//
+// %E int etype values (aka 'Kind')
+//
+// %O int Node Opcodes
+// Flags: "%#O": print go syntax. (automatic unless fmtmode == FDbg)
+//
+// %J Node* Node details
+// Flags: "%hJ" suppresses things not relevant until walk.
+//
+// %V Val* Constant values
+//
+// %S Sym* Symbols
+// Flags: +,- #: mode (see below)
+// "%hS" unqualified identifier in any mode
+// "%hhS" in export mode: unqualified identifier if exported, qualified if not
+//
+// %T Type* Types
+// Flags: +,- #: mode (see below)
+// 'l' definition instead of name.
+// 'h' omit "func" and receiver in function types
+// 'u' (only in -/Sym mode) print type identifiers wit package name instead of prefix.
+//
+// %N Node* Nodes
+// Flags: +,- #: mode (see below)
+// 'h' (only in +/debug mode) suppress recursion
+// 'l' (only in Error mode) print "foo (type Bar)"
+//
+// %H NodeList* NodeLists
+// Flags: those of %N
+// ',' separate items with ',' instead of ';'
+//
+// %Z Strlit* String literals
+//
+// In mparith1.c:
+// %B Mpint* Big integers
+// %F Mpflt* Big floats
+//
+// %S, %T and %N obey use the following flags to set the format mode:
+const (
+ FErr = iota
+ FDbg
+ FExp
+ FTypeId
+)
+
+var fmtmode int = FErr
+
+var fmtpkgpfx int // %uT stickyness
+
+//
+// E.g. for %S: %+S %#S %-S print an identifier properly qualified for debug/export/internal mode.
+//
+// The mode flags +, - and # are sticky, meaning they persist through
+// recursions of %N, %T and %S, but not the h and l flags. The u flag is
+// sticky only on %T recursions and only used in %-/Sym mode.
+
+//
+// Useful format combinations:
+//
+// %+N %+H multiline recursive debug dump of node/nodelist
+// %+hN %+hH non recursive debug dump
+//
+// %#N %#T export format
+// %#lT type definition instead of name
+// %#hT omit"func" and receiver in function signature
+//
+// %lN "foo (type Bar)" for error messages
+//
+// %-T type identifiers
+// %-hT type identifiers without "func" and arg names in type signatures (methodsym)
+// %-uT type identifiers with package name instead of prefix (typesym, dcommontype, typehash)
+//
+
+func setfmode(flags *int) int {
+ var fm int
+
+ fm = fmtmode
+ if *flags&obj.FmtSign != 0 {
+ fmtmode = FDbg
+ } else if *flags&obj.FmtSharp != 0 {
+ fmtmode = FExp
+ } else if *flags&obj.FmtLeft != 0 {
+ fmtmode = FTypeId
+ }
+
+ *flags &^= (obj.FmtSharp | obj.FmtLeft | obj.FmtSign)
+ return fm
+}
+
+// Fmt "%L": Linenumbers
+
+var goopnames = []string{
+ OADDR: "&",
+ OADD: "+",
+ OADDSTR: "+",
+ OANDAND: "&&",
+ OANDNOT: "&^",
+ OAND: "&",
+ OAPPEND: "append",
+ OAS: "=",
+ OAS2: "=",
+ OBREAK: "break",
+ OCALL: "function call", // not actual syntax
+ OCAP: "cap",
+ OCASE: "case",
+ OCLOSE: "close",
+ OCOMPLEX: "complex",
+ OCOM: "^",
+ OCONTINUE: "continue",
+ OCOPY: "copy",
+ ODEC: "--",
+ ODELETE: "delete",
+ ODEFER: "defer",
+ ODIV: "/",
+ OEQ: "==",
+ OFALL: "fallthrough",
+ OFOR: "for",
+ OGE: ">=",
+ OGOTO: "goto",
+ OGT: ">",
+ OIF: "if",
+ OIMAG: "imag",
+ OINC: "++",
+ OIND: "*",
+ OLEN: "len",
+ OLE: "<=",
+ OLSH: "<<",
+ OLT: "<",
+ OMAKE: "make",
+ OMINUS: "-",
+ OMOD: "%",
+ OMUL: "*",
+ ONEW: "new",
+ ONE: "!=",
+ ONOT: "!",
+ OOROR: "||",
+ OOR: "|",
+ OPANIC: "panic",
+ OPLUS: "+",
+ OPRINTN: "println",
+ OPRINT: "print",
+ ORANGE: "range",
+ OREAL: "real",
+ ORECV: "<-",
+ ORECOVER: "recover",
+ ORETURN: "return",
+ ORSH: ">>",
+ OSELECT: "select",
+ OSEND: "<-",
+ OSUB: "-",
+ OSWITCH: "switch",
+ OXOR: "^",
+}
+
+// Fmt "%O": Node opcodes
+func Oconv(o int, flag int) string {
+ var fp string
+
+ if (flag&obj.FmtSharp != 0 /*untyped*/) || fmtmode != FDbg {
+ if o >= 0 && o < len(goopnames) && goopnames[o] != "" {
+ fp += goopnames[o]
+ return fp
+ }
+ }
+
+ if o >= 0 && o < len(opnames) && opnames[o] != "" {
+ fp += opnames[o]
+ return fp
+ }
+
+ fp += fmt.Sprintf("O-%d", o)
+ return fp
+}
+
+var classnames = []string{
+ "Pxxx",
+ "PEXTERN",
+ "PAUTO",
+ "PPARAM",
+ "PPARAMOUT",
+ "PPARAMREF",
+ "PFUNC",
+}
+
+// Fmt "%J": Node details.
+func Jconv(n *Node, flag int) string {
+ var fp string
+
+ var s string
+ var c int
+
+ c = flag & obj.FmtShort
+
+ if !(c != 0) && n.Ullman != 0 {
+ fp += fmt.Sprintf(" u(%d)", n.Ullman)
+ }
+
+ if !(c != 0) && n.Addable != 0 {
+ fp += fmt.Sprintf(" a(%d)", n.Addable)
+ }
+
+ if !(c != 0) && n.Vargen != 0 {
+ fp += fmt.Sprintf(" g(%d)", n.Vargen)
+ }
+
+ if n.Lineno != 0 {
+ fp += fmt.Sprintf(" l(%d)", n.Lineno)
+ }
+
+ if !(c != 0) && n.Xoffset != BADWIDTH {
+ fp += fmt.Sprintf(" x(%d%+d)", n.Xoffset, n.Stkdelta)
+ }
+
+ if n.Class != 0 {
+ s = ""
+ if n.Class&PHEAP != 0 {
+ s = ",heap"
+ }
+ if int(n.Class&^PHEAP) < len(classnames) {
+ fp += fmt.Sprintf(" class(%s%s)", classnames[n.Class&^PHEAP], s)
+ } else {
+ fp += fmt.Sprintf(" class(%d?%s)", n.Class&^PHEAP, s)
+ }
+ }
+
+ if n.Colas != 0 {
+ fp += fmt.Sprintf(" colas(%d)", n.Colas)
+ }
+
+ if n.Funcdepth != 0 {
+ fp += fmt.Sprintf(" f(%d)", n.Funcdepth)
+ }
+
+ switch n.Esc {
+ case EscUnknown:
+ break
+
+ case EscHeap:
+ fp += fmt.Sprintf(" esc(h)")
+
+ case EscScope:
+ fp += fmt.Sprintf(" esc(s)")
+
+ case EscNone:
+ fp += fmt.Sprintf(" esc(no)")
+
+ case EscNever:
+ if !(c != 0) {
+ fp += fmt.Sprintf(" esc(N)")
+ }
+
+ default:
+ fp += fmt.Sprintf(" esc(%d)", n.Esc)
+ }
+
+ if n.Escloopdepth != 0 {
+ fp += fmt.Sprintf(" ld(%d)", n.Escloopdepth)
+ }
+
+ if !(c != 0) && n.Typecheck != 0 {
+ fp += fmt.Sprintf(" tc(%d)", n.Typecheck)
+ }
+
+ if !(c != 0) && n.Dodata != 0 {
+ fp += fmt.Sprintf(" dd(%d)", n.Dodata)
+ }
+
+ if n.Isddd != 0 {
+ fp += fmt.Sprintf(" isddd(%d)", n.Isddd)
+ }
+
+ if n.Implicit != 0 {
+ fp += fmt.Sprintf(" implicit(%d)", n.Implicit)
+ }
+
+ if n.Embedded != 0 {
+ fp += fmt.Sprintf(" embedded(%d)", n.Embedded)
+ }
+
+ if n.Addrtaken != 0 {
+ fp += fmt.Sprintf(" addrtaken")
+ }
+
+ if n.Assigned != 0 {
+ fp += fmt.Sprintf(" assigned")
+ }
+
+ if !(c != 0) && n.Used != 0 {
+ fp += fmt.Sprintf(" used(%d)", n.Used)
+ }
+ return fp
+}
+
+// Fmt "%V": Values
+func Vconv(v *Val, flag int) string {
+ var fp string
+
+ var x int64
+
+ switch v.Ctype {
+ case CTINT:
+ if (flag&obj.FmtSharp != 0 /*untyped*/) || fmtmode == FExp {
+ fp += fmt.Sprintf("%v", Bconv(v.U.Xval, obj.FmtSharp))
+ return fp
+ }
+ fp += fmt.Sprintf("%v", Bconv(v.U.Xval, 0))
+ return fp
+
+ case CTRUNE:
+ x = Mpgetfix(v.U.Xval)
+ if ' ' <= x && x < 0x80 && x != '\\' && x != '\'' {
+ fp += fmt.Sprintf("'%c'", int(x))
+ return fp
+ }
+ if 0 <= x && x < 1<<16 {
+ fp += fmt.Sprintf("'\\u%04x'", uint(int(x)))
+ return fp
+ }
+ if 0 <= x && x <= utf8.MaxRune {
+ fp += fmt.Sprintf("'\\U%08x'", uint64(x))
+ return fp
+ }
+ fp += fmt.Sprintf("('\\x00' + %v)", Bconv(v.U.Xval, 0))
+ return fp
+
+ case CTFLT:
+ if (flag&obj.FmtSharp != 0 /*untyped*/) || fmtmode == FExp {
+ fp += fmt.Sprintf("%v", Fconv(v.U.Fval, 0))
+ return fp
+ }
+ fp += fmt.Sprintf("%v", Fconv(v.U.Fval, obj.FmtSharp))
+ return fp
+
+ case CTCPLX:
+ if (flag&obj.FmtSharp != 0 /*untyped*/) || fmtmode == FExp {
+ fp += fmt.Sprintf("(%v+%vi)", Fconv(&v.U.Cval.Real, 0), Fconv(&v.U.Cval.Imag, 0))
+ return fp
+ }
+ if mpcmpfltc(&v.U.Cval.Real, 0) == 0 {
+ fp += fmt.Sprintf("%vi", Fconv(&v.U.Cval.Imag, obj.FmtSharp))
+ return fp
+ }
+ if mpcmpfltc(&v.U.Cval.Imag, 0) == 0 {
+ fp += fmt.Sprintf("%v", Fconv(&v.U.Cval.Real, obj.FmtSharp))
+ return fp
+ }
+ if mpcmpfltc(&v.U.Cval.Imag, 0) < 0 {
+ fp += fmt.Sprintf("(%v%vi)", Fconv(&v.U.Cval.Real, obj.FmtSharp), Fconv(&v.U.Cval.Imag, obj.FmtSharp))
+ return fp
+ }
+ fp += fmt.Sprintf("(%v+%vi)", Fconv(&v.U.Cval.Real, obj.FmtSharp), Fconv(&v.U.Cval.Imag, obj.FmtSharp))
+ return fp
+
+ case CTSTR:
+ fp += fmt.Sprintf("\"%v\"", Zconv(v.U.Sval, 0))
+ return fp
+
+ case CTBOOL:
+ if v.U.Bval != 0 {
+ fp += "true"
+ return fp
+ }
+ fp += "false"
+ return fp
+
+ case CTNIL:
+ fp += "nil"
+ return fp
+ }
+
+ fp += fmt.Sprintf("<ctype=%d>", v.Ctype)
+ return fp
+}
+
+// Fmt "%Z": escaped string literals
+func Zconv(sp *Strlit, flag int) string {
+ var fp string
+ var s string
+ var n int
+
+ if sp == nil {
+ fp += "<nil>"
+ return fp
+ }
+
+ // NOTE: Keep in sync with ../ld/go.c:/^Zconv.
+ s = sp.S
+ for i := 0; i < len(s); i += n {
+ var r rune
+ r, n = utf8.DecodeRuneInString(s[i:])
+ switch r {
+ case utf8.RuneError:
+ if n == 1 {
+ fp += fmt.Sprintf("\\x%02x", s[i])
+ break
+ }
+ fallthrough
+
+ // fall through
+ default:
+ if r < ' ' {
+ fp += fmt.Sprintf("\\x%02x", r)
+ break
+ }
+
+ fp += string(r)
+
+ case '\t':
+ fp += "\\t"
+
+ case '\n':
+ fp += "\\n"
+
+ case '"',
+ '\\':
+ fp += `\` + string(r)
+
+ case 0xFEFF: // BOM, basically disallowed in source code
+ fp += "\\uFEFF"
+ }
+ }
+
+ return fp
+}
+
+/*
+s%,%,\n%g
+s%\n+%\n%g
+s%^[ ]*T%%g
+s%,.*%%g
+s%.+% [T&] = "&",%g
+s%^ ........*\]%&~%g
+s%~ %%g
+*/
+var etnames = []string{
+ TINT: "INT",
+ TUINT: "UINT",
+ TINT8: "INT8",
+ TUINT8: "UINT8",
+ TINT16: "INT16",
+ TUINT16: "UINT16",
+ TINT32: "INT32",
+ TUINT32: "UINT32",
+ TINT64: "INT64",
+ TUINT64: "UINT64",
+ TUINTPTR: "UINTPTR",
+ TFLOAT32: "FLOAT32",
+ TFLOAT64: "FLOAT64",
+ TCOMPLEX64: "COMPLEX64",
+ TCOMPLEX128: "COMPLEX128",
+ TBOOL: "BOOL",
+ TPTR32: "PTR32",
+ TPTR64: "PTR64",
+ TFUNC: "FUNC",
+ TARRAY: "ARRAY",
+ TSTRUCT: "STRUCT",
+ TCHAN: "CHAN",
+ TMAP: "MAP",
+ TINTER: "INTER",
+ TFORW: "FORW",
+ TFIELD: "FIELD",
+ TSTRING: "STRING",
+ TANY: "ANY",
+}
+
+// Fmt "%E": etype
+func Econv(et int, flag int) string {
+ var fp string
+
+ if et >= 0 && et < len(etnames) && etnames[et] != "" {
+ fp += etnames[et]
+ return fp
+ }
+ fp += fmt.Sprintf("E-%d", et)
+ return fp
+}
+
+// Fmt "%S": syms
+func symfmt(s *Sym, flag int) string {
+ var fp string
+
+ var p string
+
+ if s.Pkg != nil && !(flag&obj.FmtShort != 0 /*untyped*/) {
+ switch fmtmode {
+ case FErr: // This is for the user
+ if s.Pkg == localpkg {
+ fp += s.Name
+ return fp
+ }
+
+ // If the name was used by multiple packages, display the full path,
+ if s.Pkg.Name != "" && Pkglookup(s.Pkg.Name, nil).Npkg > 1 {
+ fp += fmt.Sprintf("\"%v\".%s", Zconv(s.Pkg.Path, 0), s.Name)
+ return fp
+ }
+ fp += fmt.Sprintf("%s.%s", s.Pkg.Name, s.Name)
+ return fp
+
+ case FDbg:
+ fp += fmt.Sprintf("%s.%s", s.Pkg.Name, s.Name)
+ return fp
+
+ case FTypeId:
+ if flag&obj.FmtUnsigned != 0 /*untyped*/ {
+ fp += fmt.Sprintf("%s.%s", s.Pkg.Name, s.Name)
+ return fp // dcommontype, typehash
+ }
+ fp += fmt.Sprintf("%s.%s", s.Pkg.Prefix, s.Name)
+ return fp // (methodsym), typesym, weaksym
+
+ case FExp:
+ if s.Name != "" && s.Name[0] == '.' {
+ Fatal("exporting synthetic symbol %s", s.Name)
+ }
+ if s.Pkg != builtinpkg {
+ fp += fmt.Sprintf("@\"%v\".%s", Zconv(s.Pkg.Path, 0), s.Name)
+ return fp
+ }
+ }
+ }
+
+ if flag&obj.FmtByte != 0 /*untyped*/ { // FmtByte (hh) implies FmtShort (h)
+
+ // skip leading "type." in method name
+ p = s.Name
+ if i := strings.LastIndex(s.Name, "."); i >= 0 {
+ p = s.Name[i+1:]
+ }
+
+ // exportname needs to see the name without the prefix too.
+ if (fmtmode == FExp && !exportname(p)) || fmtmode == FDbg {
+ fp += fmt.Sprintf("@\"%v\".%s", Zconv(s.Pkg.Path, 0), p)
+ return fp
+ }
+
+ fp += p
+ return fp
+ }
+
+ fp += s.Name
+ return fp
+}
+
+var basicnames = []string{
+ TINT: "int",
+ TUINT: "uint",
+ TINT8: "int8",
+ TUINT8: "uint8",
+ TINT16: "int16",
+ TUINT16: "uint16",
+ TINT32: "int32",
+ TUINT32: "uint32",
+ TINT64: "int64",
+ TUINT64: "uint64",
+ TUINTPTR: "uintptr",
+ TFLOAT32: "float32",
+ TFLOAT64: "float64",
+ TCOMPLEX64: "complex64",
+ TCOMPLEX128: "complex128",
+ TBOOL: "bool",
+ TANY: "any",
+ TSTRING: "string",
+ TNIL: "nil",
+ TIDEAL: "untyped number",
+ TBLANK: "blank",
+}
+
+func typefmt(t *Type, flag int) string {
+ var fp string
+
+ var t1 *Type
+ var s *Sym
+
+ if t == nil {
+ fp += "<T>"
+ return fp
+ }
+
+ if t == bytetype || t == runetype {
+ // in %-T mode collapse rune and byte with their originals.
+ if fmtmode != FTypeId {
+ fp += fmt.Sprintf("%v", Sconv(t.Sym, obj.FmtShort))
+ return fp
+ }
+ t = Types[t.Etype]
+ }
+
+ if t == errortype {
+ fp += "error"
+ return fp
+ }
+
+ // Unless the 'l' flag was specified, if the type has a name, just print that name.
+ if !(flag&obj.FmtLong != 0 /*untyped*/) && t.Sym != nil && t.Etype != TFIELD && t != Types[t.Etype] {
+ switch fmtmode {
+ case FTypeId:
+ if flag&obj.FmtShort != 0 /*untyped*/ {
+ if t.Vargen != 0 {
+ fp += fmt.Sprintf("%v·%d", Sconv(t.Sym, obj.FmtShort), t.Vargen)
+ return fp
+ }
+ fp += fmt.Sprintf("%v", Sconv(t.Sym, obj.FmtShort))
+ return fp
+ }
+
+ if flag&obj.FmtUnsigned != 0 /*untyped*/ {
+ fp += fmt.Sprintf("%v", Sconv(t.Sym, obj.FmtUnsigned))
+ return fp
+ }
+ fallthrough
+
+ // fallthrough
+ case FExp:
+ if t.Sym.Pkg == localpkg && t.Vargen != 0 {
+ fp += fmt.Sprintf("%v·%d", Sconv(t.Sym, 0), t.Vargen)
+ return fp
+ }
+ }
+
+ fp += fmt.Sprintf("%v", Sconv(t.Sym, 0))
+ return fp
+ }
+
+ if int(t.Etype) < len(basicnames) && basicnames[t.Etype] != "" {
+ if fmtmode == FErr && (t == idealbool || t == idealstring) {
+ fp += "untyped "
+ }
+ fp += basicnames[t.Etype]
+ return fp
+ }
+
+ if fmtmode == FDbg {
+ fp += fmt.Sprintf("%v-", Econv(int(t.Etype), 0))
+ }
+
+ switch t.Etype {
+ case TPTR32,
+ TPTR64:
+ if fmtmode == FTypeId && (flag&obj.FmtShort != 0 /*untyped*/) {
+ fp += fmt.Sprintf("*%v", Tconv(t.Type, obj.FmtShort))
+ return fp
+ }
+ fp += fmt.Sprintf("*%v", Tconv(t.Type, 0))
+ return fp
+
+ case TARRAY:
+ if t.Bound >= 0 {
+ fp += fmt.Sprintf("[%d]%v", t.Bound, Tconv(t.Type, 0))
+ return fp
+ }
+ if t.Bound == -100 {
+ fp += fmt.Sprintf("[...]%v", Tconv(t.Type, 0))
+ return fp
+ }
+ fp += fmt.Sprintf("[]%v", Tconv(t.Type, 0))
+ return fp
+
+ case TCHAN:
+ switch t.Chan {
+ case Crecv:
+ fp += fmt.Sprintf("<-chan %v", Tconv(t.Type, 0))
+ return fp
+
+ case Csend:
+ fp += fmt.Sprintf("chan<- %v", Tconv(t.Type, 0))
+ return fp
+ }
+
+ if t.Type != nil && t.Type.Etype == TCHAN && t.Type.Sym == nil && t.Type.Chan == Crecv {
+ fp += fmt.Sprintf("chan (%v)", Tconv(t.Type, 0))
+ return fp
+ }
+ fp += fmt.Sprintf("chan %v", Tconv(t.Type, 0))
+ return fp
+
+ case TMAP:
+ fp += fmt.Sprintf("map[%v]%v", Tconv(t.Down, 0), Tconv(t.Type, 0))
+ return fp
+
+ case TINTER:
+ fp += "interface {"
+ for t1 = t.Type; t1 != nil; t1 = t1.Down {
+ if exportname(t1.Sym.Name) {
+ if t1.Down != nil {
+ fp += fmt.Sprintf(" %v%v;", Sconv(t1.Sym, obj.FmtShort), Tconv(t1.Type, obj.FmtShort))
+ } else {
+ fp += fmt.Sprintf(" %v%v ", Sconv(t1.Sym, obj.FmtShort), Tconv(t1.Type, obj.FmtShort))
+ }
+ } else {
+ // non-exported method names must be qualified
+ if t1.Down != nil {
+ fp += fmt.Sprintf(" %v%v;", Sconv(t1.Sym, obj.FmtUnsigned), Tconv(t1.Type, obj.FmtShort))
+ } else {
+ fp += fmt.Sprintf(" %v%v ", Sconv(t1.Sym, obj.FmtUnsigned), Tconv(t1.Type, obj.FmtShort))
+ }
+ }
+ }
+
+ fp += "}"
+ return fp
+
+ case TFUNC:
+ if flag&obj.FmtShort != 0 /*untyped*/ {
+ fp += fmt.Sprintf("%v", Tconv(getinargx(t), 0))
+ } else {
+ if t.Thistuple != 0 {
+ fp += fmt.Sprintf("method%v func%v", Tconv(getthisx(t), 0), Tconv(getinargx(t), 0))
+ } else {
+ fp += fmt.Sprintf("func%v", Tconv(getinargx(t), 0))
+ }
+ }
+
+ switch t.Outtuple {
+ case 0:
+ break
+
+ case 1:
+ if fmtmode != FExp {
+ fp += fmt.Sprintf(" %v", Tconv(getoutargx(t).Type.Type, 0)) // struct->field->field's type
+ break
+ }
+ fallthrough
+
+ default:
+ fp += fmt.Sprintf(" %v", Tconv(getoutargx(t), 0))
+ }
+
+ return fp
+
+ // Format the bucket struct for map[x]y as map.bucket[x]y.
+ // This avoids a recursive print that generates very long names.
+ case TSTRUCT:
+ if t.Map != nil {
+ if t.Map.Bucket == t {
+ fp += fmt.Sprintf("map.bucket[%v]%v", Tconv(t.Map.Down, 0), Tconv(t.Map.Type, 0))
+ return fp
+ }
+
+ if t.Map.Hmap == t {
+ fp += fmt.Sprintf("map.hdr[%v]%v", Tconv(t.Map.Down, 0), Tconv(t.Map.Type, 0))
+ return fp
+ }
+
+ if t.Map.Hiter == t {
+ fp += fmt.Sprintf("map.iter[%v]%v", Tconv(t.Map.Down, 0), Tconv(t.Map.Type, 0))
+ return fp
+ }
+
+ Yyerror("unknown internal map type")
+ }
+
+ if t.Funarg != 0 {
+ fp += "("
+ if fmtmode == FTypeId || fmtmode == FErr { // no argument names on function signature, and no "noescape"/"nosplit" tags
+ for t1 = t.Type; t1 != nil; t1 = t1.Down {
+ if t1.Down != nil {
+ fp += fmt.Sprintf("%v, ", Tconv(t1, obj.FmtShort))
+ } else {
+ fp += fmt.Sprintf("%v", Tconv(t1, obj.FmtShort))
+ }
+ }
+ } else {
+ for t1 = t.Type; t1 != nil; t1 = t1.Down {
+ if t1.Down != nil {
+ fp += fmt.Sprintf("%v, ", Tconv(t1, 0))
+ } else {
+ fp += fmt.Sprintf("%v", Tconv(t1, 0))
+ }
+ }
+ }
+
+ fp += ")"
+ } else {
+ fp += "struct {"
+ for t1 = t.Type; t1 != nil; t1 = t1.Down {
+ if t1.Down != nil {
+ fp += fmt.Sprintf(" %v;", Tconv(t1, obj.FmtLong))
+ } else {
+ fp += fmt.Sprintf(" %v ", Tconv(t1, obj.FmtLong))
+ }
+ }
+ fp += "}"
+ }
+
+ return fp
+
+ case TFIELD:
+ if !(flag&obj.FmtShort != 0 /*untyped*/) {
+ s = t.Sym
+
+ // Take the name from the original, lest we substituted it with ~r%d or ~b%d.
+ // ~r%d is a (formerly) unnamed result.
+ if (fmtmode == FErr || fmtmode == FExp) && t.Nname != nil {
+ if t.Nname.Orig != nil {
+ s = t.Nname.Orig.Sym
+ if s != nil && s.Name[0] == '~' {
+ if s.Name[1] == 'r' { // originally an unnamed result
+ s = nil
+ } else if s.Name[1] == 'b' { // originally the blank identifier _
+ s = Lookup("_")
+ }
+ }
+ } else {
+ s = nil
+ }
+ }
+
+ if s != nil && !(t.Embedded != 0) {
+ if t.Funarg != 0 {
+ fp += fmt.Sprintf("%v ", Nconv(t.Nname, 0))
+ } else if flag&obj.FmtLong != 0 /*untyped*/ {
+ fp += fmt.Sprintf("%v ", Sconv(s, obj.FmtShort|obj.FmtByte)) // qualify non-exported names (used on structs, not on funarg)
+ } else {
+ fp += fmt.Sprintf("%v ", Sconv(s, 0))
+ }
+ } else if fmtmode == FExp {
+ // TODO(rsc) this breaks on the eliding of unused arguments in the backend
+ // when this is fixed, the special case in dcl.c checkarglist can go.
+ //if(t->funarg)
+ // fmtstrcpy(fp, "_ ");
+ //else
+ if t.Embedded != 0 && s.Pkg != nil && len(s.Pkg.Path.S) > 0 {
+ fp += fmt.Sprintf("@\"%v\".? ", Zconv(s.Pkg.Path, 0))
+ } else {
+ fp += "? "
+ }
+ }
+ }
+
+ if t.Isddd != 0 {
+ fp += fmt.Sprintf("...%v", Tconv(t.Type.Type, 0))
+ } else {
+ fp += fmt.Sprintf("%v", Tconv(t.Type, 0))
+ }
+
+ if !(flag&obj.FmtShort != 0 /*untyped*/) && t.Note != nil {
+ fp += fmt.Sprintf(" \"%v\"", Zconv(t.Note, 0))
+ }
+ return fp
+
+ case TFORW:
+ if t.Sym != nil {
+ fp += fmt.Sprintf("undefined %v", Sconv(t.Sym, 0))
+ return fp
+ }
+ fp += "undefined"
+ return fp
+
+ case TUNSAFEPTR:
+ if fmtmode == FExp {
+ fp += fmt.Sprintf("@\"unsafe\".Pointer")
+ return fp
+ }
+ fp += fmt.Sprintf("unsafe.Pointer")
+ return fp
+ }
+
+ if fmtmode == FExp {
+ Fatal("missing %v case during export", Econv(int(t.Etype), 0))
+ }
+
+ // Don't know how to handle - fall back to detailed prints.
+ fp += fmt.Sprintf("%v <%v> %v", Econv(int(t.Etype), 0), Sconv(t.Sym, 0), Tconv(t.Type, 0))
+ return fp
+}
+
+// Statements which may be rendered with a simplestmt as init.
+func stmtwithinit(op int) int {
+ switch op {
+ case OIF,
+ OFOR,
+ OSWITCH:
+ return 1
+ }
+
+ return 0
+}
+
+func stmtfmt(n *Node) string {
+ var f string
+
+ var complexinit int
+ var simpleinit int
+ var extrablock int
+
+ // some statements allow for an init, but at most one,
+ // but we may have an arbitrary number added, eg by typecheck
+ // and inlining. If it doesn't fit the syntax, emit an enclosing
+ // block starting with the init statements.
+
+ // if we can just say "for" n->ninit; ... then do so
+ simpleinit = bool2int(n.Ninit != nil && !(n.Ninit.Next != nil) && !(n.Ninit.N.Ninit != nil) && stmtwithinit(int(n.Op)) != 0)
+
+ // otherwise, print the inits as separate statements
+ complexinit = bool2int(n.Ninit != nil && !(simpleinit != 0) && (fmtmode != FErr))
+
+ // but if it was for if/for/switch, put in an extra surrounding block to limit the scope
+ extrablock = bool2int(complexinit != 0 && stmtwithinit(int(n.Op)) != 0)
+
+ if extrablock != 0 {
+ f += "{"
+ }
+
+ if complexinit != 0 {
+ f += fmt.Sprintf(" %v; ", Hconv(n.Ninit, 0))
+ }
+
+ switch n.Op {
+ case ODCL:
+ if fmtmode == FExp {
+ switch n.Left.Class &^ PHEAP {
+ case PPARAM,
+ PPARAMOUT,
+ PAUTO:
+ f += fmt.Sprintf("var %v %v", Nconv(n.Left, 0), Tconv(n.Left.Type, 0))
+ goto ret
+ }
+ }
+
+ f += fmt.Sprintf("var %v %v", Sconv(n.Left.Sym, 0), Tconv(n.Left.Type, 0))
+
+ case ODCLFIELD:
+ if n.Left != nil {
+ f += fmt.Sprintf("%v %v", Nconv(n.Left, 0), Nconv(n.Right, 0))
+ } else {
+ f += fmt.Sprintf("%v", Nconv(n.Right, 0))
+ }
+
+ // Don't export "v = <N>" initializing statements, hope they're always
+ // preceded by the DCL which will be re-parsed and typecheck to reproduce
+ // the "v = <N>" again.
+ case OAS:
+ if fmtmode == FExp && n.Right == nil {
+ break
+ }
+
+ if n.Colas != 0 && !(complexinit != 0) {
+ f += fmt.Sprintf("%v := %v", Nconv(n.Left, 0), Nconv(n.Right, 0))
+ } else {
+ f += fmt.Sprintf("%v = %v", Nconv(n.Left, 0), Nconv(n.Right, 0))
+ }
+
+ case OASOP:
+ if n.Implicit != 0 {
+ if n.Etype == OADD {
+ f += fmt.Sprintf("%v++", Nconv(n.Left, 0))
+ } else {
+ f += fmt.Sprintf("%v--", Nconv(n.Left, 0))
+ }
+ break
+ }
+
+ f += fmt.Sprintf("%v %v= %v", Nconv(n.Left, 0), Oconv(int(n.Etype), obj.FmtSharp), Nconv(n.Right, 0))
+
+ case OAS2:
+ if n.Colas != 0 && !(complexinit != 0) {
+ f += fmt.Sprintf("%v := %v", Hconv(n.List, obj.FmtComma), Hconv(n.Rlist, obj.FmtComma))
+ break
+ }
+ fallthrough
+
+ // fallthrough
+ case OAS2DOTTYPE,
+ OAS2FUNC,
+ OAS2MAPR,
+ OAS2RECV:
+ f += fmt.Sprintf("%v = %v", Hconv(n.List, obj.FmtComma), Hconv(n.Rlist, obj.FmtComma))
+
+ case ORETURN:
+ f += fmt.Sprintf("return %v", Hconv(n.List, obj.FmtComma))
+
+ case ORETJMP:
+ f += fmt.Sprintf("retjmp %v", Sconv(n.Sym, 0))
+
+ case OPROC:
+ f += fmt.Sprintf("go %v", Nconv(n.Left, 0))
+
+ case ODEFER:
+ f += fmt.Sprintf("defer %v", Nconv(n.Left, 0))
+
+ case OIF:
+ if simpleinit != 0 {
+ f += fmt.Sprintf("if %v; %v { %v }", Nconv(n.Ninit.N, 0), Nconv(n.Ntest, 0), Hconv(n.Nbody, 0))
+ } else {
+ f += fmt.Sprintf("if %v { %v }", Nconv(n.Ntest, 0), Hconv(n.Nbody, 0))
+ }
+ if n.Nelse != nil {
+ f += fmt.Sprintf(" else { %v }", Hconv(n.Nelse, 0))
+ }
+
+ case OFOR:
+ if fmtmode == FErr { // TODO maybe only if FmtShort, same below
+ f += "for loop"
+ break
+ }
+
+ f += "for"
+ if simpleinit != 0 {
+ f += fmt.Sprintf(" %v;", Nconv(n.Ninit.N, 0))
+ } else if n.Nincr != nil {
+ f += " ;"
+ }
+
+ if n.Ntest != nil {
+ f += fmt.Sprintf(" %v", Nconv(n.Ntest, 0))
+ }
+
+ if n.Nincr != nil {
+ f += fmt.Sprintf("; %v", Nconv(n.Nincr, 0))
+ } else if simpleinit != 0 {
+ f += ";"
+ }
+
+ f += fmt.Sprintf(" { %v }", Hconv(n.Nbody, 0))
+
+ case ORANGE:
+ if fmtmode == FErr {
+ f += "for loop"
+ break
+ }
+
+ if n.List == nil {
+ f += fmt.Sprintf("for range %v { %v }", Nconv(n.Right, 0), Hconv(n.Nbody, 0))
+ break
+ }
+
+ f += fmt.Sprintf("for %v = range %v { %v }", Hconv(n.List, obj.FmtComma), Nconv(n.Right, 0), Hconv(n.Nbody, 0))
+
+ case OSELECT,
+ OSWITCH:
+ if fmtmode == FErr {
+ f += fmt.Sprintf("%v statement", Oconv(int(n.Op), 0))
+ break
+ }
+
+ f += fmt.Sprintf("%v", Oconv(int(n.Op), obj.FmtSharp))
+ if simpleinit != 0 {
+ f += fmt.Sprintf(" %v;", Nconv(n.Ninit.N, 0))
+ }
+ if n.Ntest != nil {
+ f += fmt.Sprintf("%v", Nconv(n.Ntest, 0))
+ }
+
+ f += fmt.Sprintf(" { %v }", Hconv(n.List, 0))
+
+ case OCASE,
+ OXCASE:
+ if n.List != nil {
+ f += fmt.Sprintf("case %v: %v", Hconv(n.List, obj.FmtComma), Hconv(n.Nbody, 0))
+ } else {
+ f += fmt.Sprintf("default: %v", Hconv(n.Nbody, 0))
+ }
+
+ case OBREAK,
+ OCONTINUE,
+ OGOTO,
+ OFALL,
+ OXFALL:
+ if n.Left != nil {
+ f += fmt.Sprintf("%v %v", Oconv(int(n.Op), obj.FmtSharp), Nconv(n.Left, 0))
+ } else {
+ f += fmt.Sprintf("%v", Oconv(int(n.Op), obj.FmtSharp))
+ }
+
+ case OEMPTY:
+ break
+
+ case OLABEL:
+ f += fmt.Sprintf("%v: ", Nconv(n.Left, 0))
+ }
+
+ret:
+ if extrablock != 0 {
+ f += "}"
+ }
+
+ return f
+}
+
+var opprec = []int{
+ OAPPEND: 8,
+ OARRAYBYTESTR: 8,
+ OARRAYLIT: 8,
+ OARRAYRUNESTR: 8,
+ OCALLFUNC: 8,
+ OCALLINTER: 8,
+ OCALLMETH: 8,
+ OCALL: 8,
+ OCAP: 8,
+ OCLOSE: 8,
+ OCONVIFACE: 8,
+ OCONVNOP: 8,
+ OCONV: 8,
+ OCOPY: 8,
+ ODELETE: 8,
+ OLEN: 8,
+ OLITERAL: 8,
+ OMAKESLICE: 8,
+ OMAKE: 8,
+ OMAPLIT: 8,
+ ONAME: 8,
+ ONEW: 8,
+ ONONAME: 8,
+ OPACK: 8,
+ OPANIC: 8,
+ OPAREN: 8,
+ OPRINTN: 8,
+ OPRINT: 8,
+ ORUNESTR: 8,
+ OSTRARRAYBYTE: 8,
+ OSTRARRAYRUNE: 8,
+ OSTRUCTLIT: 8,
+ OTARRAY: 8,
+ OTCHAN: 8,
+ OTFUNC: 8,
+ OTINTER: 8,
+ OTMAP: 8,
+ OTSTRUCT: 8,
+ OINDEXMAP: 8,
+ OINDEX: 8,
+ OSLICE: 8,
+ OSLICESTR: 8,
+ OSLICEARR: 8,
+ OSLICE3: 8,
+ OSLICE3ARR: 8,
+ ODOTINTER: 8,
+ ODOTMETH: 8,
+ ODOTPTR: 8,
+ ODOTTYPE2: 8,
+ ODOTTYPE: 8,
+ ODOT: 8,
+ OXDOT: 8,
+ OCALLPART: 8,
+ OPLUS: 7,
+ ONOT: 7,
+ OCOM: 7,
+ OMINUS: 7,
+ OADDR: 7,
+ OIND: 7,
+ ORECV: 7,
+ OMUL: 6,
+ ODIV: 6,
+ OMOD: 6,
+ OLSH: 6,
+ ORSH: 6,
+ OAND: 6,
+ OANDNOT: 6,
+ OADD: 5,
+ OSUB: 5,
+ OOR: 5,
+ OXOR: 5,
+ OEQ: 4,
+ OLT: 4,
+ OLE: 4,
+ OGE: 4,
+ OGT: 4,
+ ONE: 4,
+ OCMPSTR: 4,
+ OCMPIFACE: 4,
+ OSEND: 3,
+ OANDAND: 2,
+ OOROR: 1,
+ OAS:// Statements handled by stmtfmt
+ -1,
+ OAS2: -1,
+ OAS2DOTTYPE: -1,
+ OAS2FUNC: -1,
+ OAS2MAPR: -1,
+ OAS2RECV: -1,
+ OASOP: -1,
+ OBREAK: -1,
+ OCASE: -1,
+ OCONTINUE: -1,
+ ODCL: -1,
+ ODCLFIELD: -1,
+ ODEFER: -1,
+ OEMPTY: -1,
+ OFALL: -1,
+ OFOR: -1,
+ OGOTO: -1,
+ OIF: -1,
+ OLABEL: -1,
+ OPROC: -1,
+ ORANGE: -1,
+ ORETURN: -1,
+ OSELECT: -1,
+ OSWITCH: -1,
+ OXCASE: -1,
+ OXFALL: -1,
+ OEND: 0,
+}
+
+func exprfmt(n *Node, prec int) string {
+ var f string
+
+ var nprec int
+ var ptrlit int
+ var l *NodeList
+
+ for n != nil && n.Implicit != 0 && (n.Op == OIND || n.Op == OADDR) {
+ n = n.Left
+ }
+
+ if n == nil {
+ f += "<N>"
+ return f
+ }
+
+ nprec = opprec[n.Op]
+ if n.Op == OTYPE && n.Sym != nil {
+ nprec = 8
+ }
+
+ if prec > nprec {
+ f += fmt.Sprintf("(%v)", Nconv(n, 0))
+ return f
+ }
+
+ switch n.Op {
+ case OPAREN:
+ f += fmt.Sprintf("(%v)", Nconv(n.Left, 0))
+ return f
+
+ case ODDDARG:
+ f += fmt.Sprintf("... argument")
+ return f
+
+ case OREGISTER:
+ f += fmt.Sprintf("%v", Ctxt.Rconv(int(n.Val.U.Reg)))
+ return f
+
+ case OLITERAL: // this is a bit of a mess
+ if fmtmode == FErr && n.Sym != nil {
+ f += fmt.Sprintf("%v", Sconv(n.Sym, 0))
+ return f
+ }
+ if n.Val.Ctype == CTNIL && n.Orig != nil && n.Orig != n {
+ f += exprfmt(n.Orig, prec)
+ return f
+ }
+ if n.Type != nil && n.Type != Types[n.Type.Etype] && n.Type != idealbool && n.Type != idealstring {
+ // Need parens when type begins with what might
+ // be misinterpreted as a unary operator: * or <-.
+ if Isptr[n.Type.Etype] != 0 || (n.Type.Etype == TCHAN && n.Type.Chan == Crecv) {
+ f += fmt.Sprintf("(%v)(%v)", Tconv(n.Type, 0), Vconv(&n.Val, 0))
+ return f
+ } else {
+ f += fmt.Sprintf("%v(%v)", Tconv(n.Type, 0), Vconv(&n.Val, 0))
+ return f
+ }
+ }
+
+ f += fmt.Sprintf("%v", Vconv(&n.Val, 0))
+ return f
+
+ // Special case: name used as local variable in export.
+ // _ becomes ~b%d internally; print as _ for export
+ case ONAME:
+ if fmtmode == FExp && n.Sym != nil && n.Sym.Name[0] == '~' && n.Sym.Name[1] == 'b' {
+ f += fmt.Sprintf("_")
+ return f
+ }
+ if fmtmode == FExp && n.Sym != nil && !isblank(n) && n.Vargen > 0 {
+ f += fmt.Sprintf("%v·%d", Sconv(n.Sym, 0), n.Vargen)
+ return f
+ }
+
+ // Special case: explicit name of func (*T) method(...) is turned into pkg.(*T).method,
+ // but for export, this should be rendered as (*pkg.T).meth.
+ // These nodes have the special property that they are names with a left OTYPE and a right ONAME.
+ if fmtmode == FExp && n.Left != nil && n.Left.Op == OTYPE && n.Right != nil && n.Right.Op == ONAME {
+ if Isptr[n.Left.Type.Etype] != 0 {
+ f += fmt.Sprintf("(%v).%v", Tconv(n.Left.Type, 0), Sconv(n.Right.Sym, obj.FmtShort|obj.FmtByte))
+ return f
+ } else {
+ f += fmt.Sprintf("%v.%v", Tconv(n.Left.Type, 0), Sconv(n.Right.Sym, obj.FmtShort|obj.FmtByte))
+ return f
+ }
+ }
+ fallthrough
+
+ //fallthrough
+ case OPACK,
+ ONONAME:
+ f += fmt.Sprintf("%v", Sconv(n.Sym, 0))
+ return f
+
+ case OTYPE:
+ if n.Type == nil && n.Sym != nil {
+ f += fmt.Sprintf("%v", Sconv(n.Sym, 0))
+ return f
+ }
+ f += fmt.Sprintf("%v", Tconv(n.Type, 0))
+ return f
+
+ case OTARRAY:
+ if n.Left != nil {
+ f += fmt.Sprintf("[]%v", Nconv(n.Left, 0))
+ return f
+ }
+ f += fmt.Sprintf("[]%v", Nconv(n.Right, 0))
+ return f // happens before typecheck
+
+ case OTMAP:
+ f += fmt.Sprintf("map[%v]%v", Nconv(n.Left, 0), Nconv(n.Right, 0))
+ return f
+
+ case OTCHAN:
+ switch n.Etype {
+ case Crecv:
+ f += fmt.Sprintf("<-chan %v", Nconv(n.Left, 0))
+ return f
+
+ case Csend:
+ f += fmt.Sprintf("chan<- %v", Nconv(n.Left, 0))
+ return f
+
+ default:
+ if n.Left != nil && n.Left.Op == OTCHAN && n.Left.Sym == nil && n.Left.Etype == Crecv {
+ f += fmt.Sprintf("chan (%v)", Nconv(n.Left, 0))
+ return f
+ } else {
+ f += fmt.Sprintf("chan %v", Nconv(n.Left, 0))
+ return f
+ }
+ }
+ fallthrough
+
+ case OTSTRUCT:
+ f += fmt.Sprintf("<struct>")
+ return f
+
+ case OTINTER:
+ f += fmt.Sprintf("<inter>")
+ return f
+
+ case OTFUNC:
+ f += fmt.Sprintf("<func>")
+ return f
+
+ case OCLOSURE:
+ if fmtmode == FErr {
+ f += "func literal"
+ return f
+ }
+ if n.Nbody != nil {
+ f += fmt.Sprintf("%v { %v }", Tconv(n.Type, 0), Hconv(n.Nbody, 0))
+ return f
+ }
+ f += fmt.Sprintf("%v { %v }", Tconv(n.Type, 0), Hconv(n.Closure.Nbody, 0))
+ return f
+
+ case OCOMPLIT:
+ ptrlit = bool2int(n.Right != nil && n.Right.Implicit != 0 && n.Right.Type != nil && Isptr[n.Right.Type.Etype] != 0)
+ if fmtmode == FErr {
+ if n.Right != nil && n.Right.Type != nil && !(n.Implicit != 0) {
+ if ptrlit != 0 {
+ f += fmt.Sprintf("&%v literal", Tconv(n.Right.Type.Type, 0))
+ return f
+ } else {
+ f += fmt.Sprintf("%v literal", Tconv(n.Right.Type, 0))
+ return f
+ }
+ }
+
+ f += "composite literal"
+ return f
+ }
+
+ if fmtmode == FExp && ptrlit != 0 {
+ // typecheck has overwritten OIND by OTYPE with pointer type.
+ f += fmt.Sprintf("(&%v{ %v })", Tconv(n.Right.Type.Type, 0), Hconv(n.List, obj.FmtComma))
+ return f
+ }
+
+ f += fmt.Sprintf("(%v{ %v })", Nconv(n.Right, 0), Hconv(n.List, obj.FmtComma))
+ return f
+
+ case OPTRLIT:
+ if fmtmode == FExp && n.Left.Implicit != 0 {
+ f += fmt.Sprintf("%v", Nconv(n.Left, 0))
+ return f
+ }
+ f += fmt.Sprintf("&%v", Nconv(n.Left, 0))
+ return f
+
+ case OSTRUCTLIT:
+ if fmtmode == FExp { // requires special handling of field names
+ if n.Implicit != 0 {
+ f += "{"
+ } else {
+ f += fmt.Sprintf("(%v{", Tconv(n.Type, 0))
+ }
+ for l = n.List; l != nil; l = l.Next {
+ f += fmt.Sprintf(" %v:%v", Sconv(l.N.Left.Sym, obj.FmtShort|obj.FmtByte), Nconv(l.N.Right, 0))
+
+ if l.Next != nil {
+ f += ","
+ } else {
+ f += " "
+ }
+ }
+
+ if !(n.Implicit != 0) {
+ f += "})"
+ return f
+ }
+ f += "}"
+ return f
+ }
+ fallthrough
+
+ // fallthrough
+
+ case OARRAYLIT,
+ OMAPLIT:
+ if fmtmode == FErr {
+ f += fmt.Sprintf("%v literal", Tconv(n.Type, 0))
+ return f
+ }
+ if fmtmode == FExp && n.Implicit != 0 {
+ f += fmt.Sprintf("{ %v }", Hconv(n.List, obj.FmtComma))
+ return f
+ }
+ f += fmt.Sprintf("(%v{ %v })", Tconv(n.Type, 0), Hconv(n.List, obj.FmtComma))
+ return f
+
+ case OKEY:
+ if n.Left != nil && n.Right != nil {
+ if fmtmode == FExp && n.Left.Type != nil && n.Left.Type.Etype == TFIELD {
+ // requires special handling of field names
+ f += fmt.Sprintf("%v:%v", Sconv(n.Left.Sym, obj.FmtShort|obj.FmtByte), Nconv(n.Right, 0))
+ return f
+ } else {
+ f += fmt.Sprintf("%v:%v", Nconv(n.Left, 0), Nconv(n.Right, 0))
+ return f
+ }
+ }
+
+ if !(n.Left != nil) && n.Right != nil {
+ f += fmt.Sprintf(":%v", Nconv(n.Right, 0))
+ return f
+ }
+ if n.Left != nil && !(n.Right != nil) {
+ f += fmt.Sprintf("%v:", Nconv(n.Left, 0))
+ return f
+ }
+ f += ":"
+ return f
+
+ case OXDOT,
+ ODOT,
+ ODOTPTR,
+ ODOTINTER,
+ ODOTMETH,
+ OCALLPART:
+ f += exprfmt(n.Left, nprec)
+ if n.Right == nil || n.Right.Sym == nil {
+ f += ".<nil>"
+ return f
+ }
+ f += fmt.Sprintf(".%v", Sconv(n.Right.Sym, obj.FmtShort|obj.FmtByte))
+ return f
+
+ case ODOTTYPE,
+ ODOTTYPE2:
+ f += exprfmt(n.Left, nprec)
+ if n.Right != nil {
+ f += fmt.Sprintf(".(%v)", Nconv(n.Right, 0))
+ return f
+ }
+ f += fmt.Sprintf(".(%v)", Tconv(n.Type, 0))
+ return f
+
+ case OINDEX,
+ OINDEXMAP,
+ OSLICE,
+ OSLICESTR,
+ OSLICEARR,
+ OSLICE3,
+ OSLICE3ARR:
+ f += exprfmt(n.Left, nprec)
+ f += fmt.Sprintf("[%v]", Nconv(n.Right, 0))
+ return f
+
+ case OCOPY,
+ OCOMPLEX:
+ f += fmt.Sprintf("%v(%v, %v)", Oconv(int(n.Op), obj.FmtSharp), Nconv(n.Left, 0), Nconv(n.Right, 0))
+ return f
+
+ case OCONV,
+ OCONVIFACE,
+ OCONVNOP,
+ OARRAYBYTESTR,
+ OARRAYRUNESTR,
+ OSTRARRAYBYTE,
+ OSTRARRAYRUNE,
+ ORUNESTR:
+ if n.Type == nil || n.Type.Sym == nil {
+ f += fmt.Sprintf("(%v)(%v)", Tconv(n.Type, 0), Nconv(n.Left, 0))
+ return f
+ }
+ if n.Left != nil {
+ f += fmt.Sprintf("%v(%v)", Tconv(n.Type, 0), Nconv(n.Left, 0))
+ return f
+ }
+ f += fmt.Sprintf("%v(%v)", Tconv(n.Type, 0), Hconv(n.List, obj.FmtComma))
+ return f
+
+ case OREAL,
+ OIMAG,
+ OAPPEND,
+ OCAP,
+ OCLOSE,
+ ODELETE,
+ OLEN,
+ OMAKE,
+ ONEW,
+ OPANIC,
+ ORECOVER,
+ OPRINT,
+ OPRINTN:
+ if n.Left != nil {
+ f += fmt.Sprintf("%v(%v)", Oconv(int(n.Op), obj.FmtSharp), Nconv(n.Left, 0))
+ return f
+ }
+ if n.Isddd != 0 {
+ f += fmt.Sprintf("%v(%v...)", Oconv(int(n.Op), obj.FmtSharp), Hconv(n.List, obj.FmtComma))
+ return f
+ }
+ f += fmt.Sprintf("%v(%v)", Oconv(int(n.Op), obj.FmtSharp), Hconv(n.List, obj.FmtComma))
+ return f
+
+ case OCALL,
+ OCALLFUNC,
+ OCALLINTER,
+ OCALLMETH:
+ f += exprfmt(n.Left, nprec)
+ if n.Isddd != 0 {
+ f += fmt.Sprintf("(%v...)", Hconv(n.List, obj.FmtComma))
+ return f
+ }
+ f += fmt.Sprintf("(%v)", Hconv(n.List, obj.FmtComma))
+ return f
+
+ case OMAKEMAP,
+ OMAKECHAN,
+ OMAKESLICE:
+ if n.List != nil { // pre-typecheck
+ f += fmt.Sprintf("make(%v, %v)", Tconv(n.Type, 0), Hconv(n.List, obj.FmtComma))
+ return f
+ }
+ if n.Right != nil {
+ f += fmt.Sprintf("make(%v, %v, %v)", Tconv(n.Type, 0), Nconv(n.Left, 0), Nconv(n.Right, 0))
+ return f
+ }
+ if n.Left != nil {
+ f += fmt.Sprintf("make(%v, %v)", Tconv(n.Type, 0), Nconv(n.Left, 0))
+ return f
+ }
+ f += fmt.Sprintf("make(%v)", Tconv(n.Type, 0))
+ return f
+
+ // Unary
+ case OPLUS,
+ OMINUS,
+ OADDR,
+ OCOM,
+ OIND,
+ ONOT,
+ ORECV:
+ if n.Left.Op == n.Op {
+ f += fmt.Sprintf("%v ", Oconv(int(n.Op), obj.FmtSharp))
+ } else {
+ f += fmt.Sprintf("%v", Oconv(int(n.Op), obj.FmtSharp))
+ }
+ f += exprfmt(n.Left, nprec+1)
+ return f
+
+ // Binary
+ case OADD,
+ OAND,
+ OANDAND,
+ OANDNOT,
+ ODIV,
+ OEQ,
+ OGE,
+ OGT,
+ OLE,
+ OLT,
+ OLSH,
+ OMOD,
+ OMUL,
+ ONE,
+ OOR,
+ OOROR,
+ ORSH,
+ OSEND,
+ OSUB,
+ OXOR:
+ f += exprfmt(n.Left, nprec)
+
+ f += fmt.Sprintf(" %v ", Oconv(int(n.Op), obj.FmtSharp))
+ f += exprfmt(n.Right, nprec+1)
+ return f
+
+ case OADDSTR:
+ for l = n.List; l != nil; l = l.Next {
+ if l != n.List {
+ f += fmt.Sprintf(" + ")
+ }
+ f += exprfmt(l.N, nprec)
+ }
+
+ return f
+
+ case OCMPSTR,
+ OCMPIFACE:
+ f += exprfmt(n.Left, nprec)
+ f += fmt.Sprintf(" %v ", Oconv(int(n.Etype), obj.FmtSharp))
+ f += exprfmt(n.Right, nprec+1)
+ return f
+ }
+
+ f += fmt.Sprintf("<node %v>", Oconv(int(n.Op), 0))
+ return f
+}
+
+func nodefmt(n *Node, flag int) string {
+ var f string
+
+ var t *Type
+
+ t = n.Type
+
+ // we almost always want the original, except in export mode for literals
+ // this saves the importer some work, and avoids us having to redo some
+ // special casing for package unsafe
+ if (fmtmode != FExp || n.Op != OLITERAL) && n.Orig != nil {
+ n = n.Orig
+ }
+
+ if flag&obj.FmtLong != 0 /*untyped*/ && t != nil {
+ if t.Etype == TNIL {
+ f += fmt.Sprintf("nil")
+ return f
+ } else {
+ f += fmt.Sprintf("%v (type %v)", Nconv(n, 0), Tconv(t, 0))
+ return f
+ }
+ }
+
+ // TODO inlining produces expressions with ninits. we can't print these yet.
+
+ if opprec[n.Op] < 0 {
+ return stmtfmt(n)
+ }
+
+ f += exprfmt(n, 0)
+ return f
+}
+
+var dumpdepth int
+
+func indent(s string) string {
+ return s + "\n" + strings.Repeat(". ", dumpdepth)
+}
+
+func nodedump(n *Node, flag int) string {
+ var fp string
+
+ var recur int
+
+ if n == nil {
+ return fp
+ }
+
+ recur = bool2int(!(flag&obj.FmtShort != 0 /*untyped*/))
+
+ if recur != 0 {
+ fp = indent(fp)
+ if dumpdepth > 10 {
+ fp += "..."
+ return fp
+ }
+
+ if n.Ninit != nil {
+ fp += fmt.Sprintf("%v-init%v", Oconv(int(n.Op), 0), Hconv(n.Ninit, 0))
+ fp = indent(fp)
+ }
+ }
+
+ // fmtprint(fp, "[%p]", n);
+
+ switch n.Op {
+ default:
+ fp += fmt.Sprintf("%v%v", Oconv(int(n.Op), 0), Jconv(n, 0))
+
+ case OREGISTER,
+ OINDREG:
+ fp += fmt.Sprintf("%v-%v%v", Oconv(int(n.Op), 0), Ctxt.Rconv(int(n.Val.U.Reg)), Jconv(n, 0))
+
+ case OLITERAL:
+ fp += fmt.Sprintf("%v-%v%v", Oconv(int(n.Op), 0), Vconv(&n.Val, 0), Jconv(n, 0))
+
+ case ONAME,
+ ONONAME:
+ if n.Sym != nil {
+ fp += fmt.Sprintf("%v-%v%v", Oconv(int(n.Op), 0), Sconv(n.Sym, 0), Jconv(n, 0))
+ } else {
+ fp += fmt.Sprintf("%v%v", Oconv(int(n.Op), 0), Jconv(n, 0))
+ }
+ if recur != 0 && n.Type == nil && n.Ntype != nil {
+ fp = indent(fp)
+ fp += fmt.Sprintf("%v-ntype%v", Oconv(int(n.Op), 0), Nconv(n.Ntype, 0))
+ }
+
+ case OASOP:
+ fp += fmt.Sprintf("%v-%v%v", Oconv(int(n.Op), 0), Oconv(int(n.Etype), 0), Jconv(n, 0))
+
+ case OTYPE:
+ fp += fmt.Sprintf("%v %v%v type=%v", Oconv(int(n.Op), 0), Sconv(n.Sym, 0), Jconv(n, 0), Tconv(n.Type, 0))
+ if recur != 0 && n.Type == nil && n.Ntype != nil {
+ fp = indent(fp)
+ fp += fmt.Sprintf("%v-ntype%v", Oconv(int(n.Op), 0), Nconv(n.Ntype, 0))
+ }
+ }
+
+ if n.Sym != nil && n.Op != ONAME {
+ fp += fmt.Sprintf(" %v G%d", Sconv(n.Sym, 0), n.Vargen)
+ }
+
+ if n.Type != nil {
+ fp += fmt.Sprintf(" %v", Tconv(n.Type, 0))
+ }
+
+ if recur != 0 {
+ if n.Left != nil {
+ fp += fmt.Sprintf("%v", Nconv(n.Left, 0))
+ }
+ if n.Right != nil {
+ fp += fmt.Sprintf("%v", Nconv(n.Right, 0))
+ }
+ if n.List != nil {
+ fp = indent(fp)
+ fp += fmt.Sprintf("%v-list%v", Oconv(int(n.Op), 0), Hconv(n.List, 0))
+ }
+
+ if n.Rlist != nil {
+ fp = indent(fp)
+ fp += fmt.Sprintf("%v-rlist%v", Oconv(int(n.Op), 0), Hconv(n.Rlist, 0))
+ }
+
+ if n.Ntest != nil {
+ fp = indent(fp)
+ fp += fmt.Sprintf("%v-test%v", Oconv(int(n.Op), 0), Nconv(n.Ntest, 0))
+ }
+
+ if n.Nbody != nil {
+ fp = indent(fp)
+ fp += fmt.Sprintf("%v-body%v", Oconv(int(n.Op), 0), Hconv(n.Nbody, 0))
+ }
+
+ if n.Nelse != nil {
+ fp = indent(fp)
+ fp += fmt.Sprintf("%v-else%v", Oconv(int(n.Op), 0), Hconv(n.Nelse, 0))
+ }
+
+ if n.Nincr != nil {
+ fp = indent(fp)
+ fp += fmt.Sprintf("%v-incr%v", Oconv(int(n.Op), 0), Nconv(n.Nincr, 0))
+ }
+ }
+
+ return fp
+}
+
+// Fmt "%S": syms
+// Flags: "%hS" suppresses qualifying with package
+func Sconv(s *Sym, flag int) string {
+ var fp string
+
+ var r int
+ var sm int
+ var sf int
+
+ if flag&obj.FmtLong != 0 /*untyped*/ {
+ panic("linksymfmt")
+ }
+
+ if s == nil {
+ fp += "<S>"
+ return fp
+ }
+
+ if s.Name == "_" {
+ fp += "_"
+ return fp
+ }
+
+ sf = flag
+ sm = setfmode(&flag)
+ _ = r
+ str := symfmt(s, flag)
+ flag = sf
+ fmtmode = sm
+ return str
+}
+
+// Fmt "%T": types.
+// Flags: 'l' print definition, not name
+// 'h' omit 'func' and receiver from function types, short type names
+// 'u' package name, not prefix (FTypeId mode, sticky)
+func Tconv(t *Type, flag int) string {
+ var fp string
+
+ var r int
+ var sm int
+ var sf int
+
+ if t == nil {
+ fp += "<T>"
+ return fp
+ }
+
+ if t.Trecur > 4 {
+ fp += "<...>"
+ return fp
+ }
+
+ t.Trecur++
+ sf = flag
+ sm = setfmode(&flag)
+
+ if fmtmode == FTypeId && (sf&obj.FmtUnsigned != 0) {
+ fmtpkgpfx++
+ }
+ if fmtpkgpfx != 0 {
+ flag |= obj.FmtUnsigned
+ }
+
+ _ = r
+ str := typefmt(t, flag)
+
+ if fmtmode == FTypeId && (sf&obj.FmtUnsigned != 0) {
+ fmtpkgpfx--
+ }
+
+ flag = sf
+ fmtmode = sm
+ t.Trecur--
+ return str
+}
+
+// Fmt '%N': Nodes.
+// Flags: 'l' suffix with "(type %T)" where possible
+// '+h' in debug mode, don't recurse, no multiline output
+func Nconv(n *Node, flag int) string {
+ var fp string
+
+ var r int
+ var sm int
+ var sf int
+
+ if n == nil {
+ fp += "<N>"
+ return fp
+ }
+ sf = flag
+ sm = setfmode(&flag)
+
+ _ = r
+ var str string
+ switch fmtmode {
+ case FErr,
+ FExp:
+ str = nodefmt(n, flag)
+
+ case FDbg:
+ dumpdepth++
+ str = nodedump(n, flag)
+ dumpdepth--
+
+ default:
+ Fatal("unhandled %N mode")
+ }
+
+ flag = sf
+ fmtmode = sm
+ return str
+}
+
+// Fmt '%H': NodeList.
+// Flags: all those of %N plus ',': separate with comma's instead of semicolons.
+func Hconv(l *NodeList, flag int) string {
+ var fp string
+
+ var r int
+ var sm int
+ var sf int
+ var sep string
+
+ if l == nil && fmtmode == FDbg {
+ fp += "<nil>"
+ return fp
+ }
+
+ sf = flag
+ sm = setfmode(&flag)
+ _ = r
+ sep = "; "
+ if fmtmode == FDbg {
+ sep = "\n"
+ } else if flag&obj.FmtComma != 0 /*untyped*/ {
+ sep = ", "
+ }
+
+ for ; l != nil; l = l.Next {
+ fp += fmt.Sprintf("%v", Nconv(l.N, 0))
+ if l.Next != nil {
+ fp += sep
+ }
+ }
+
+ flag = sf
+ fmtmode = sm
+ return fp
+}
+
+func dumplist(s string, l *NodeList) {
+ fmt.Printf("%s%v\n", s, Hconv(l, obj.FmtSign))
+}
+
+func Dump(s string, n *Node) {
+ fmt.Printf("%s [%p]%v\n", s, n, Nconv(n, obj.FmtSign))
+}
diff --git a/src/cmd/internal/gc/gen.go b/src/cmd/internal/gc/gen.go
new file mode 100644
index 0000000..a40a347
--- /dev/null
+++ b/src/cmd/internal/gc/gen.go
@@ -0,0 +1,1017 @@
+// 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
+
+import (
+ "cmd/internal/obj"
+ "fmt"
+)
+
+/*
+ * portable half of code generator.
+ * mainly statements and control flow.
+ */
+var labellist *Label
+
+var lastlabel *Label
+
+func Sysfunc(name string) *Node {
+ var n *Node
+
+ n = newname(Pkglookup(name, Runtimepkg))
+ n.Class = PFUNC
+ return n
+}
+
+/*
+ * the address of n has been taken and might be used after
+ * the current function returns. mark any local vars
+ * as needing to move to the heap.
+ */
+func addrescapes(n *Node) {
+ var buf string
+ var oldfn *Node
+
+ switch n.Op {
+ // probably a type error already.
+ // dump("addrescapes", n);
+ default:
+ break
+
+ case ONAME:
+ if n == nodfp {
+ break
+ }
+
+ // if this is a tmpname (PAUTO), it was tagged by tmpname as not escaping.
+ // on PPARAM it means something different.
+ if n.Class == PAUTO && n.Esc == EscNever {
+ break
+ }
+
+ switch n.Class {
+ case PPARAMREF:
+ addrescapes(n.Defn)
+
+ // if func param, need separate temporary
+ // to hold heap pointer.
+ // the function type has already been checked
+ // (we're in the function body)
+ // so the param already has a valid xoffset.
+
+ // expression to refer to stack copy
+ case PPARAM,
+ PPARAMOUT:
+ n.Stackparam = Nod(OPARAM, n, nil)
+
+ n.Stackparam.Type = n.Type
+ n.Stackparam.Addable = 1
+ if n.Xoffset == BADWIDTH {
+ Fatal("addrescapes before param assignment")
+ }
+ n.Stackparam.Xoffset = n.Xoffset
+ fallthrough
+
+ // fallthrough
+
+ case PAUTO:
+ n.Class |= PHEAP
+
+ n.Addable = 0
+ n.Ullman = 2
+ n.Xoffset = 0
+
+ // create stack variable to hold pointer to heap
+ oldfn = Curfn
+
+ Curfn = n.Curfn
+ n.Heapaddr = temp(Ptrto(n.Type))
+ buf = fmt.Sprintf("&%v", Sconv(n.Sym, 0))
+ n.Heapaddr.Sym = Lookup(buf)
+ n.Heapaddr.Orig.Sym = n.Heapaddr.Sym
+ n.Esc = EscHeap
+ if Debug['m'] != 0 {
+ fmt.Printf("%v: moved to heap: %v\n", n.Line(), Nconv(n, 0))
+ }
+ Curfn = oldfn
+ }
+
+ case OIND,
+ ODOTPTR:
+ break
+
+ // ODOTPTR has already been introduced,
+ // so these are the non-pointer ODOT and OINDEX.
+ // In &x[0], if x is a slice, then x does not
+ // escape--the pointer inside x does, but that
+ // is always a heap pointer anyway.
+ case ODOT,
+ OINDEX:
+ if !(Isslice(n.Left.Type) != 0) {
+ addrescapes(n.Left)
+ }
+ }
+}
+
+func clearlabels() {
+ var l *Label
+
+ for l = labellist; l != nil; l = l.Link {
+ l.Sym.Label = nil
+ }
+
+ labellist = nil
+ lastlabel = nil
+}
+
+func newlab(n *Node) *Label {
+ var s *Sym
+ var lab *Label
+
+ s = n.Left.Sym
+ lab = s.Label
+ if lab == nil {
+ lab = new(Label)
+ if lastlabel == nil {
+ labellist = lab
+ } else {
+ lastlabel.Link = lab
+ }
+ lastlabel = lab
+ lab.Sym = s
+ s.Label = lab
+ }
+
+ if n.Op == OLABEL {
+ if lab.Def != nil {
+ Yyerror("label %v already defined at %v", Sconv(s, 0), lab.Def.Line())
+ } else {
+ lab.Def = n
+ }
+ } else {
+ lab.Use = list(lab.Use, n)
+ }
+
+ return lab
+}
+
+func checkgoto(from *Node, to *Node) {
+ var nf int
+ var nt int
+ var block *Sym
+ var dcl *Sym
+ var fs *Sym
+ var ts *Sym
+ var lno int
+
+ if from.Sym == to.Sym {
+ return
+ }
+
+ nf = 0
+ for fs = from.Sym; fs != nil; fs = fs.Link {
+ nf++
+ }
+ nt = 0
+ for fs = to.Sym; fs != nil; fs = fs.Link {
+ nt++
+ }
+ fs = from.Sym
+ for ; nf > nt; nf-- {
+ fs = fs.Link
+ }
+ if fs != to.Sym {
+ lno = int(lineno)
+ setlineno(from)
+
+ // decide what to complain about.
+ // prefer to complain about 'into block' over declarations,
+ // so scan backward to find most recent block or else dcl.
+ block = nil
+
+ dcl = nil
+ ts = to.Sym
+ for ; nt > nf; nt-- {
+ if ts.Pkg == nil {
+ block = ts
+ } else {
+ dcl = ts
+ }
+ ts = ts.Link
+ }
+
+ for ts != fs {
+ if ts.Pkg == nil {
+ block = ts
+ } else {
+ dcl = ts
+ }
+ ts = ts.Link
+ fs = fs.Link
+ }
+
+ if block != nil {
+ Yyerror("goto %v jumps into block starting at %v", Sconv(from.Left.Sym, 0), Ctxt.Line(int(block.Lastlineno)))
+ } else {
+ Yyerror("goto %v jumps over declaration of %v at %v", Sconv(from.Left.Sym, 0), Sconv(dcl, 0), Ctxt.Line(int(dcl.Lastlineno)))
+ }
+ lineno = int32(lno)
+ }
+}
+
+func stmtlabel(n *Node) *Label {
+ var lab *Label
+
+ if n.Sym != nil {
+ lab = n.Sym.Label
+ if lab != nil {
+ if lab.Def != nil {
+ if lab.Def.Defn == n {
+ return lab
+ }
+ }
+ }
+ }
+ return nil
+}
+
+/*
+ * compile statements
+ */
+func Genlist(l *NodeList) {
+ for ; l != nil; l = l.Next {
+ gen(l.N)
+ }
+}
+
+/*
+ * generate code to start new proc running call n.
+ */
+func cgen_proc(n *Node, proc int) {
+ switch n.Left.Op {
+ default:
+ Fatal("cgen_proc: unknown call %v", Oconv(int(n.Left.Op), 0))
+ fallthrough
+
+ case OCALLMETH:
+ Cgen_callmeth(n.Left, proc)
+
+ case OCALLINTER:
+ Thearch.Cgen_callinter(n.Left, nil, proc)
+
+ case OCALLFUNC:
+ Thearch.Cgen_call(n.Left, proc)
+ }
+}
+
+/*
+ * generate declaration.
+ * have to allocate heap copy
+ * for escaped variables.
+ */
+func cgen_dcl(n *Node) {
+ if Debug['g'] != 0 {
+ Dump("\ncgen-dcl", n)
+ }
+ if n.Op != ONAME {
+ Dump("cgen_dcl", n)
+ Fatal("cgen_dcl")
+ }
+
+ if !(n.Class&PHEAP != 0) {
+ return
+ }
+ if compiling_runtime != 0 {
+ Yyerror("%v escapes to heap, not allowed in runtime.", Nconv(n, 0))
+ }
+ if n.Alloc == nil {
+ n.Alloc = callnew(n.Type)
+ }
+ Cgen_as(n.Heapaddr, n.Alloc)
+}
+
+/*
+ * generate discard of value
+ */
+func cgen_discard(nr *Node) {
+ var tmp Node
+
+ if nr == nil {
+ return
+ }
+
+ switch nr.Op {
+ case ONAME:
+ if !(nr.Class&PHEAP != 0) && nr.Class != PEXTERN && nr.Class != PFUNC && nr.Class != PPARAMREF {
+ gused(nr)
+ }
+
+ // unary
+ case OADD,
+ OAND,
+ ODIV,
+ OEQ,
+ OGE,
+ OGT,
+ OLE,
+ OLSH,
+ OLT,
+ OMOD,
+ OMUL,
+ ONE,
+ OOR,
+ ORSH,
+ OSUB,
+ OXOR:
+ cgen_discard(nr.Left)
+
+ cgen_discard(nr.Right)
+
+ // binary
+ case OCAP,
+ OCOM,
+ OLEN,
+ OMINUS,
+ ONOT,
+ OPLUS:
+ cgen_discard(nr.Left)
+
+ case OIND:
+ Cgen_checknil(nr.Left)
+
+ // special enough to just evaluate
+ default:
+ Tempname(&tmp, nr.Type)
+
+ Cgen_as(&tmp, nr)
+ gused(&tmp)
+ }
+}
+
+/*
+ * clearslim generates code to zero a slim node.
+ */
+func Clearslim(n *Node) {
+ var z Node
+ var zero Mpflt
+
+ z = Node{}
+ z.Op = OLITERAL
+ z.Type = n.Type
+ z.Addable = 1
+
+ switch Simtype[n.Type.Etype] {
+ case TCOMPLEX64,
+ TCOMPLEX128:
+ z.Val.U.Cval = new(Mpcplx)
+ Mpmovecflt(&z.Val.U.Cval.Real, 0.0)
+ Mpmovecflt(&z.Val.U.Cval.Imag, 0.0)
+
+ case TFLOAT32,
+ TFLOAT64:
+ Mpmovecflt(&zero, 0.0)
+ z.Val.Ctype = CTFLT
+ z.Val.U.Fval = &zero
+
+ case TPTR32,
+ TPTR64,
+ TCHAN,
+ TMAP:
+ z.Val.Ctype = CTNIL
+
+ case TBOOL:
+ z.Val.Ctype = CTBOOL
+
+ case TINT8,
+ TINT16,
+ TINT32,
+ TINT64,
+ TUINT8,
+ TUINT16,
+ TUINT32,
+ TUINT64:
+ z.Val.Ctype = CTINT
+ z.Val.U.Xval = new(Mpint)
+ Mpmovecfix(z.Val.U.Xval, 0)
+
+ default:
+ Fatal("clearslim called on type %v", Tconv(n.Type, 0))
+ }
+
+ ullmancalc(&z)
+ Thearch.Cgen(&z, n)
+}
+
+/*
+ * generate:
+ * res = iface{typ, data}
+ * n->left is typ
+ * n->right is data
+ */
+func Cgen_eface(n *Node, res *Node) {
+ var dst Node
+ /*
+ * the right node of an eface may contain function calls that uses res as an argument,
+ * so it's important that it is done first
+ */
+
+ var tmp *Node
+
+ tmp = temp(Types[Tptr])
+ Thearch.Cgen(n.Right, tmp)
+
+ Gvardef(res)
+
+ dst = *res
+ dst.Type = Types[Tptr]
+ dst.Xoffset += int64(Widthptr)
+ Thearch.Cgen(tmp, &dst)
+
+ dst.Xoffset -= int64(Widthptr)
+ Thearch.Cgen(n.Left, &dst)
+}
+
+/*
+ * generate:
+ * res = s[lo, hi];
+ * n->left is s
+ * n->list is (cap(s)-lo(TUINT), hi-lo(TUINT)[, lo*width(TUINTPTR)])
+ * caller (cgen) guarantees res is an addable ONAME.
+ *
+ * called for OSLICE, OSLICE3, OSLICEARR, OSLICE3ARR, OSLICESTR.
+ */
+func Cgen_slice(n *Node, res *Node) {
+ var src Node
+ var dst Node
+ var cap *Node
+ var len *Node
+ var offs *Node
+ var add *Node
+ var base *Node
+ var tmpcap *Node
+ var tmplen *Node
+ var cmp *Node
+ var con Node
+ var p1 *obj.Prog
+ var p2 *obj.Prog
+
+ cap = n.List.N
+ len = n.List.Next.N
+ offs = nil
+ if n.List.Next.Next != nil {
+ offs = n.List.Next.Next.N
+ }
+
+ // evaluate base pointer first, because it is the only
+ // possibly complex expression. once that is evaluated
+ // and stored, updating the len and cap can be done
+ // without making any calls, so without doing anything that
+ // might cause preemption or garbage collection.
+ // this makes the whole slice update atomic as far as the
+ // garbage collector can see.
+ base = temp(Types[TUINTPTR])
+
+ tmplen = temp(Types[TINT])
+ if n.Op != OSLICESTR {
+ tmpcap = temp(Types[TINT])
+ } else {
+ tmpcap = tmplen
+ }
+
+ if isnil(n.Left) != 0 {
+ Tempname(&src, n.Left.Type)
+ Thearch.Cgen(n.Left, &src)
+ } else {
+ src = *n.Left
+ }
+ if n.Op == OSLICE || n.Op == OSLICE3 || n.Op == OSLICESTR {
+ src.Xoffset += int64(Array_array)
+ }
+
+ if n.Op == OSLICEARR || n.Op == OSLICE3ARR {
+ if !(Isptr[n.Left.Type.Etype] != 0) {
+ Fatal("slicearr is supposed to work on pointer: %v\n", Nconv(n, obj.FmtSign))
+ }
+ Thearch.Cgen(&src, base)
+ Cgen_checknil(base)
+ } else {
+ src.Type = Types[Tptr]
+ Thearch.Cgen(&src, base)
+ }
+
+ // committed to the update
+ Gvardef(res)
+
+ // compute len and cap.
+ // len = n-i, cap = m-i, and offs = i*width.
+ // computing offs last lets the multiply overwrite i.
+ Thearch.Cgen((*Node)(len), tmplen)
+
+ if n.Op != OSLICESTR {
+ Thearch.Cgen(cap, tmpcap)
+ }
+
+ // if new cap != 0 { base += add }
+ // This avoids advancing base past the end of the underlying array/string,
+ // so that it cannot point at the next object in memory.
+ // If cap == 0, the base doesn't matter except insofar as it is 0 or non-zero.
+ // In essence we are replacing x[i:j:k] where i == j == k
+ // or x[i:j] where i == j == cap(x) with x[0:0:0].
+ if offs != nil {
+ p1 = gjmp(nil)
+ p2 = gjmp(nil)
+ Patch(p1, Pc)
+
+ Nodconst(&con, tmpcap.Type, 0)
+ cmp = Nod(OEQ, tmpcap, &con)
+ typecheck(&cmp, Erv)
+ Thearch.Bgen(cmp, true, -1, p2)
+
+ add = Nod(OADD, base, offs)
+ typecheck(&add, Erv)
+ Thearch.Cgen(add, base)
+
+ Patch(p2, Pc)
+ }
+
+ // dst.array = src.array [ + lo *width ]
+ dst = *res
+
+ dst.Xoffset += int64(Array_array)
+ dst.Type = Types[Tptr]
+ Thearch.Cgen(base, &dst)
+
+ // dst.len = hi [ - lo ]
+ dst = *res
+
+ dst.Xoffset += int64(Array_nel)
+ dst.Type = Types[Simtype[TUINT]]
+ Thearch.Cgen(tmplen, &dst)
+
+ if n.Op != OSLICESTR {
+ // dst.cap = cap [ - lo ]
+ dst = *res
+
+ dst.Xoffset += int64(Array_cap)
+ dst.Type = Types[Simtype[TUINT]]
+ Thearch.Cgen(tmpcap, &dst)
+ }
+}
+
+/*
+ * gather series of offsets
+ * >=0 is direct addressed field
+ * <0 is pointer to next field (+1)
+ */
+func Dotoffset(n *Node, oary []int64, nn **Node) int {
+ var i int
+
+ switch n.Op {
+ case ODOT:
+ if n.Xoffset == BADWIDTH {
+ Dump("bad width in dotoffset", n)
+ Fatal("bad width in dotoffset")
+ }
+
+ i = Dotoffset(n.Left, oary, nn)
+ if i > 0 {
+ if oary[i-1] >= 0 {
+ oary[i-1] += n.Xoffset
+ } else {
+ oary[i-1] -= n.Xoffset
+ }
+ break
+ }
+
+ if i < 10 {
+ oary[i] = n.Xoffset
+ i++
+ }
+
+ case ODOTPTR:
+ if n.Xoffset == BADWIDTH {
+ Dump("bad width in dotoffset", n)
+ Fatal("bad width in dotoffset")
+ }
+
+ i = Dotoffset(n.Left, oary, nn)
+ if i < 10 {
+ oary[i] = -(n.Xoffset + 1)
+ i++
+ }
+
+ default:
+ *nn = n
+ return 0
+ }
+
+ if i >= 10 {
+ *nn = nil
+ }
+ return i
+}
+
+/*
+ * make a new off the books
+ */
+func Tempname(nn *Node, t *Type) {
+ var n *Node
+ var s *Sym
+
+ if Curfn == nil {
+ Fatal("no curfn for tempname")
+ }
+
+ if t == nil {
+ Yyerror("tempname called with nil type")
+ t = Types[TINT32]
+ }
+
+ // give each tmp a different name so that there
+ // a chance to registerizer them
+ namebuf = fmt.Sprintf("autotmp_%.4d", statuniqgen)
+
+ statuniqgen++
+ s = Lookup(namebuf)
+ n = Nod(ONAME, nil, nil)
+ n.Sym = s
+ s.Def = n
+ n.Type = t
+ n.Class = PAUTO
+ n.Addable = 1
+ n.Ullman = 1
+ n.Esc = EscNever
+ n.Curfn = Curfn
+ Curfn.Dcl = list(Curfn.Dcl, n)
+
+ dowidth(t)
+ n.Xoffset = 0
+ *nn = *n
+}
+
+func temp(t *Type) *Node {
+ var n *Node
+
+ n = Nod(OXXX, nil, nil)
+ Tempname(n, t)
+ n.Sym.Def.Used = 1
+ return n.Orig
+}
+
+func gen(n *Node) {
+ var lno int32
+ var scontin *obj.Prog
+ var sbreak *obj.Prog
+ var p1 *obj.Prog
+ var p2 *obj.Prog
+ var p3 *obj.Prog
+ var lab *Label
+ var wasregalloc int32
+
+ //dump("gen", n);
+
+ lno = setlineno(n)
+
+ wasregalloc = int32(Thearch.Anyregalloc())
+
+ if n == nil {
+ goto ret
+ }
+
+ if n.Ninit != nil {
+ Genlist(n.Ninit)
+ }
+
+ setlineno(n)
+
+ switch n.Op {
+ default:
+ Fatal("gen: unknown op %v", Nconv(n, obj.FmtShort|obj.FmtSign))
+
+ case OCASE,
+ OFALL,
+ OXCASE,
+ OXFALL,
+ ODCLCONST,
+ ODCLFUNC,
+ ODCLTYPE:
+ break
+
+ case OEMPTY:
+ break
+
+ case OBLOCK:
+ Genlist(n.List)
+
+ case OLABEL:
+ if isblanksym(n.Left.Sym) {
+ break
+ }
+
+ lab = newlab(n)
+
+ // if there are pending gotos, resolve them all to the current pc.
+ for p1 = lab.Gotopc; p1 != nil; p1 = p2 {
+ p2 = unpatch(p1)
+ Patch(p1, Pc)
+ }
+
+ lab.Gotopc = nil
+ if lab.Labelpc == nil {
+ lab.Labelpc = Pc
+ }
+
+ if n.Defn != nil {
+ switch n.Defn.Op {
+ // so stmtlabel can find the label
+ case OFOR,
+ OSWITCH,
+ OSELECT:
+ n.Defn.Sym = lab.Sym
+ }
+ }
+
+ // if label is defined, emit jump to it.
+ // otherwise save list of pending gotos in lab->gotopc.
+ // the list is linked through the normal jump target field
+ // to avoid a second list. (the jumps are actually still
+ // valid code, since they're just going to another goto
+ // to the same label. we'll unwind it when we learn the pc
+ // of the label in the OLABEL case above.)
+ case OGOTO:
+ lab = newlab(n)
+
+ if lab.Labelpc != nil {
+ gjmp(lab.Labelpc)
+ } else {
+ lab.Gotopc = gjmp(lab.Gotopc)
+ }
+
+ case OBREAK:
+ if n.Left != nil {
+ lab = n.Left.Sym.Label
+ if lab == nil {
+ Yyerror("break label not defined: %v", Sconv(n.Left.Sym, 0))
+ break
+ }
+
+ lab.Used = 1
+ if lab.Breakpc == nil {
+ Yyerror("invalid break label %v", Sconv(n.Left.Sym, 0))
+ break
+ }
+
+ gjmp(lab.Breakpc)
+ break
+ }
+
+ if breakpc == nil {
+ Yyerror("break is not in a loop")
+ break
+ }
+
+ gjmp(breakpc)
+
+ case OCONTINUE:
+ if n.Left != nil {
+ lab = n.Left.Sym.Label
+ if lab == nil {
+ Yyerror("continue label not defined: %v", Sconv(n.Left.Sym, 0))
+ break
+ }
+
+ lab.Used = 1
+ if lab.Continpc == nil {
+ Yyerror("invalid continue label %v", Sconv(n.Left.Sym, 0))
+ break
+ }
+
+ gjmp(lab.Continpc)
+ break
+ }
+
+ if continpc == nil {
+ Yyerror("continue is not in a loop")
+ break
+ }
+
+ gjmp(continpc)
+
+ case OFOR:
+ sbreak = breakpc
+ p1 = gjmp(nil) // goto test
+ breakpc = gjmp(nil) // break: goto done
+ scontin = continpc
+ continpc = Pc
+
+ // define break and continue labels
+ lab = stmtlabel(n)
+ if lab != nil {
+ lab.Breakpc = breakpc
+ lab.Continpc = continpc
+ }
+
+ gen(n.Nincr) // contin: incr
+ Patch(p1, Pc) // test:
+ Thearch.Bgen(n.Ntest, false, -1, breakpc) // if(!test) goto break
+ Genlist(n.Nbody) // body
+ gjmp(continpc)
+ Patch(breakpc, Pc) // done:
+ continpc = scontin
+ breakpc = sbreak
+ if lab != nil {
+ lab.Breakpc = nil
+ lab.Continpc = nil
+ }
+
+ case OIF:
+ p1 = gjmp(nil) // goto test
+ p2 = gjmp(nil) // p2: goto else
+ Patch(p1, Pc) // test:
+ Thearch.Bgen(n.Ntest, false, int(-n.Likely), p2) // if(!test) goto p2
+ Genlist(n.Nbody) // then
+ p3 = gjmp(nil) // goto done
+ Patch(p2, Pc) // else:
+ Genlist(n.Nelse) // else
+ Patch(p3, Pc) // done:
+
+ case OSWITCH:
+ sbreak = breakpc
+ p1 = gjmp(nil) // goto test
+ breakpc = gjmp(nil) // break: goto done
+
+ // define break label
+ lab = stmtlabel(n)
+ if lab != nil {
+ lab.Breakpc = breakpc
+ }
+
+ Patch(p1, Pc) // test:
+ Genlist(n.Nbody) // switch(test) body
+ Patch(breakpc, Pc) // done:
+ breakpc = sbreak
+ if lab != nil {
+ lab.Breakpc = nil
+ }
+
+ case OSELECT:
+ sbreak = breakpc
+ p1 = gjmp(nil) // goto test
+ breakpc = gjmp(nil) // break: goto done
+
+ // define break label
+ lab = stmtlabel(n)
+ if lab != nil {
+ lab.Breakpc = breakpc
+ }
+
+ Patch(p1, Pc) // test:
+ Genlist(n.Nbody) // select() body
+ Patch(breakpc, Pc) // done:
+ breakpc = sbreak
+ if lab != nil {
+ lab.Breakpc = nil
+ }
+
+ case ODCL:
+ cgen_dcl(n.Left)
+
+ case OAS:
+ if gen_as_init(n) != 0 {
+ break
+ }
+ Cgen_as(n.Left, n.Right)
+
+ case OCALLMETH:
+ Cgen_callmeth(n, 0)
+
+ case OCALLINTER:
+ Thearch.Cgen_callinter(n, nil, 0)
+
+ case OCALLFUNC:
+ Thearch.Cgen_call(n, 0)
+
+ case OPROC:
+ cgen_proc(n, 1)
+
+ case ODEFER:
+ cgen_proc(n, 2)
+
+ case ORETURN,
+ ORETJMP:
+ Thearch.Cgen_ret(n)
+
+ case OCHECKNIL:
+ Cgen_checknil(n.Left)
+
+ case OVARKILL:
+ gvarkill(n.Left)
+ }
+
+ret:
+ if int32(Thearch.Anyregalloc()) != wasregalloc {
+ Dump("node", n)
+ Fatal("registers left allocated")
+ }
+
+ lineno = lno
+}
+
+func Cgen_as(nl *Node, nr *Node) {
+ var tl *Type
+
+ if Debug['g'] != 0 {
+ Dump("cgen_as", nl)
+ Dump("cgen_as = ", nr)
+ }
+
+ for nr != nil && nr.Op == OCONVNOP {
+ nr = nr.Left
+ }
+
+ if nl == nil || isblank(nl) {
+ cgen_discard(nr)
+ return
+ }
+
+ if nr == nil || iszero(nr) != 0 {
+ // heaps should already be clear
+ if nr == nil && (nl.Class&PHEAP != 0) {
+ return
+ }
+
+ tl = nl.Type
+ if tl == nil {
+ return
+ }
+ if Isfat(tl) != 0 {
+ if nl.Op == ONAME {
+ Gvardef(nl)
+ }
+ Thearch.Clearfat(nl)
+ return
+ }
+
+ Clearslim(nl)
+ return
+ }
+
+ tl = nl.Type
+ if tl == nil {
+ return
+ }
+
+ Thearch.Cgen(nr, nl)
+}
+
+func Cgen_callmeth(n *Node, proc int) {
+ var n2 Node
+ var l *Node
+
+ // generate a rewrite in n2 for the method call
+ // (p.f)(...) goes to (f)(p,...)
+
+ l = n.Left
+
+ if l.Op != ODOTMETH {
+ Fatal("cgen_callmeth: not dotmethod: %v")
+ }
+
+ n2 = *n
+ n2.Op = OCALLFUNC
+ n2.Left = l.Right
+ n2.Left.Type = l.Type
+
+ if n2.Left.Op == ONAME {
+ n2.Left.Class = PFUNC
+ }
+ Thearch.Cgen_call(&n2, proc)
+}
+
+func checklabels() {
+ var lab *Label
+ var l *NodeList
+
+ for lab = labellist; lab != nil; lab = lab.Link {
+ if lab.Def == nil {
+ for l = lab.Use; l != nil; l = l.Next {
+ yyerrorl(int(l.N.Lineno), "label %v not defined", Sconv(lab.Sym, 0))
+ }
+ continue
+ }
+
+ if lab.Use == nil && !(lab.Used != 0) {
+ yyerrorl(int(lab.Def.Lineno), "label %v defined and not used", Sconv(lab.Sym, 0))
+ continue
+ }
+
+ if lab.Gotopc != nil {
+ Fatal("label %v never resolved", Sconv(lab.Sym, 0))
+ }
+ for l = lab.Use; l != nil; l = l.Next {
+ checkgoto(l.N, lab.Def)
+ }
+ }
+}
diff --git a/src/cmd/internal/gc/go.go b/src/cmd/internal/gc/go.go
new file mode 100644
index 0000000..ff1a429
--- /dev/null
+++ b/src/cmd/internal/gc/go.go
@@ -0,0 +1,1179 @@
+// 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
+
+import (
+ "bytes"
+ "cmd/internal/obj"
+ "encoding/binary"
+)
+
+// 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.
+
+// avoid <ctype.h>
+
+// The parser's maximum stack size.
+// We have to use a #define macro here since yacc
+// or bison will check for its definition and use
+// a potentially smaller value if it is undefined.
+const (
+ NHUNK = 50000
+ BUFSIZ = 8192
+ NSYMB = 500
+ NHASH = 1024
+ STRINGSZ = 200
+ MAXALIGN = 7
+ UINF = 100
+ PRIME1 = 3
+ AUNK = 100
+ AMEM = 0 + iota - 9
+ AMEM0
+ AMEM8
+ AMEM16
+ AMEM32
+ AMEM64
+ AMEM128
+ ANOEQ
+ ANOEQ0
+ ANOEQ8
+ ANOEQ16
+ ANOEQ32
+ ANOEQ64
+ ANOEQ128
+ ASTRING
+ AINTER
+ ANILINTER
+ ASLICE
+ AFLOAT32
+ AFLOAT64
+ ACPLX64
+ ACPLX128
+ BADWIDTH = -1000000000
+ MaxStackVarSize = 10 * 1024 * 1024
+)
+
+/*
+ * note this is the representation
+ * of the compilers string literals,
+ * it is not the runtime representation
+ */
+type Strlit struct {
+ S string
+}
+
+const (
+ Mpscale = 29
+ Mpprec = 16
+ Mpnorm = Mpprec - 1
+ Mpbase = 1 << Mpscale
+ Mpsign = Mpbase >> 1
+ Mpmask = Mpbase - 1
+ Mpdebug = 0
+)
+
+type Mpint struct {
+ A [Mpprec]int
+ Neg uint8
+ Ovf uint8
+}
+
+type Mpflt struct {
+ Val Mpint
+ Exp int16
+}
+
+type Mpcplx struct {
+ Real Mpflt
+ Imag Mpflt
+}
+
+type Val struct {
+ Ctype int16
+ U struct {
+ Reg int16
+ Bval int16
+ Xval *Mpint
+ Fval *Mpflt
+ Cval *Mpcplx
+ Sval *Strlit
+ }
+}
+
+type Array struct {
+ length int32
+ size int32
+ capacity int32
+ data string
+}
+
+type Bvec struct {
+ n int32
+ b []uint32
+}
+
+type Pkg struct {
+ Name string
+ Path *Strlit
+ Pathsym *Sym
+ Prefix string
+ Link *Pkg
+ Imported uint8
+ Exported int8
+ Direct int8
+ Safe bool
+}
+
+type Sym struct {
+ Lexical uint16
+ Flags uint8
+ Sym uint8
+ Link *Sym
+ Npkg int32
+ Uniqgen uint32
+ Importdef *Pkg
+ Linkname string
+ Pkg *Pkg
+ Name string
+ Def *Node
+ Label *Label
+ Block int32
+ Lastlineno int32
+ Origpkg *Pkg
+ Lsym *obj.LSym
+}
+
+type Node struct {
+ Left *Node
+ Right *Node
+ Ntest *Node
+ Nincr *Node
+ Ninit *NodeList
+ Nbody *NodeList
+ Nelse *NodeList
+ List *NodeList
+ Rlist *NodeList
+ Op uint8
+ Nointerface bool
+ Ullman uint8
+ Addable uint8
+ Trecur uint8
+ Etype uint8
+ Bounded uint8
+ Class uint8
+ Method uint8
+ Embedded uint8
+ Colas uint8
+ Diag uint8
+ Noescape bool
+ Nosplit bool
+ Builtin uint8
+ Nowritebarrier bool
+ Walkdef uint8
+ Typecheck uint8
+ Local uint8
+ Dodata uint8
+ Initorder uint8
+ Used uint8
+ Isddd uint8
+ Readonly uint8
+ Implicit uint8
+ Addrtaken uint8
+ Assigned uint8
+ Captured uint8
+ Byval uint8
+ Dupok uint8
+ Wrapper uint8
+ Reslice uint8
+ Likely int8
+ Hasbreak uint8
+ Needzero uint8
+ Needctxt uint8
+ Esc uint
+ Funcdepth int
+ Type *Type
+ Orig *Node
+ Nname *Node
+ Shortname *Node
+ Enter *NodeList
+ Exit *NodeList
+ Cvars *NodeList
+ Dcl *NodeList
+ Inl *NodeList
+ Inldcl *NodeList
+ Val Val
+ Ntype *Node
+ Defn *Node
+ Pack *Node
+ Curfn *Node
+ Paramfld *Type
+ Decldepth int
+ Heapaddr *Node
+ Outerexpr *Node
+ Stackparam *Node
+ Alloc *Node
+ Outer *Node
+ Closure *Node
+ Top int
+ Inlvar *Node
+ Pkg *Pkg
+ Initplan *InitPlan
+ Escflowsrc *NodeList
+ Escretval *NodeList
+ Escloopdepth int
+ Sym *Sym
+ Vargen int32
+ Lineno int32
+ Endlineno int32
+ Xoffset int64
+ Stkdelta int64
+ Ostk int32
+ Iota int32
+ Walkgen uint32
+ Esclevel int32
+ Opt interface{}
+}
+
+type NodeList struct {
+ N *Node
+ Next *NodeList
+ End *NodeList
+}
+
+type Type struct {
+ Etype uint8
+ Nointerface uint8
+ Noalg uint8
+ Chan uint8
+ Trecur uint8
+ Printed uint8
+ Embedded uint8
+ Siggen uint8
+ Funarg uint8
+ Copyany uint8
+ Local uint8
+ Deferwidth uint8
+ Broke uint8
+ Isddd uint8
+ Align uint8
+ Haspointers uint8
+ Nod *Node
+ Orig *Type
+ Lineno int
+ Thistuple int
+ Outtuple int
+ Intuple int
+ Outnamed uint8
+ Method *Type
+ Xmethod *Type
+ Sym *Sym
+ Vargen int32
+ Nname *Node
+ Argwid int64
+ Type *Type
+ Width int64
+ Down *Type
+ Outer *Type
+ Note *Strlit
+ Bound int64
+ Bucket *Type
+ Hmap *Type
+ Hiter *Type
+ Map *Type
+ Maplineno int32
+ Embedlineno int32
+ Copyto *NodeList
+ Lastfn *Node
+}
+
+type Label struct {
+ Used uint8
+ Sym *Sym
+ Def *Node
+ Use *NodeList
+ Link *Label
+ Gotopc *obj.Prog
+ Labelpc *obj.Prog
+ Breakpc *obj.Prog
+ Continpc *obj.Prog
+}
+
+type InitEntry struct {
+ Xoffset int64
+ Key *Node
+ Expr *Node
+}
+
+type InitPlan struct {
+ Lit int64
+ Zero int64
+ Expr int64
+ E []InitEntry
+}
+
+const (
+ EscUnknown = iota
+ EscHeap
+ EscScope
+ EscNone
+ EscReturn
+ EscNever
+ EscBits = 3
+ EscMask = (1 << EscBits) - 1
+ EscContentEscapes = 1 << EscBits
+ EscReturnBits = EscBits + 1
+)
+
+/*
+ * Every node has a walkgen field.
+ * If you want to do a traversal of a node graph that
+ * might contain duplicates and want to avoid
+ * visiting the same nodes twice, increment walkgen
+ * before starting. Then before processing a node, do
+ *
+ * if(n->walkgen == walkgen)
+ * return;
+ * n->walkgen = walkgen;
+ *
+ * Such a walk cannot call another such walk recursively,
+ * because of the use of the global walkgen.
+ */
+var walkgen uint32
+
+const (
+ SymExport = 1 << 0
+ SymPackage = 1 << 1
+ SymExported = 1 << 2
+ SymUniq = 1 << 3
+ SymSiggen = 1 << 4
+ SymAsm = 1 << 5
+ SymAlgGen = 1 << 6
+)
+
+var dclstack *Sym
+
+type Iter struct {
+ Done int
+ Tfunc *Type
+ T *Type
+ An **Node
+ N *Node
+}
+
+// Node ops.
+const (
+ OXXX = iota
+ ONAME
+ ONONAME
+ OTYPE
+ OPACK
+ OLITERAL
+ OADD
+ OSUB
+ OOR
+ OXOR
+ OADDSTR
+ OADDR
+ OANDAND
+ OAPPEND
+ OARRAYBYTESTR
+ OARRAYBYTESTRTMP
+ OARRAYRUNESTR
+ OSTRARRAYBYTE
+ OSTRARRAYBYTETMP
+ OSTRARRAYRUNE
+ OAS
+ OAS2
+ OAS2FUNC
+ OAS2RECV
+ OAS2MAPR
+ OAS2DOTTYPE
+ OASOP
+ OCALL
+ OCALLFUNC
+ OCALLMETH
+ OCALLINTER
+ OCALLPART
+ OCAP
+ OCLOSE
+ OCLOSURE
+ OCMPIFACE
+ OCMPSTR
+ OCOMPLIT
+ OMAPLIT
+ OSTRUCTLIT
+ OARRAYLIT
+ OPTRLIT
+ OCONV
+ OCONVIFACE
+ OCONVNOP
+ OCOPY
+ ODCL
+ ODCLFUNC
+ ODCLFIELD
+ ODCLCONST
+ ODCLTYPE
+ ODELETE
+ ODOT
+ ODOTPTR
+ ODOTMETH
+ ODOTINTER
+ OXDOT
+ ODOTTYPE
+ ODOTTYPE2
+ OEQ
+ ONE
+ OLT
+ OLE
+ OGE
+ OGT
+ OIND
+ OINDEX
+ OINDEXMAP
+ OKEY
+ OPARAM
+ OLEN
+ OMAKE
+ OMAKECHAN
+ OMAKEMAP
+ OMAKESLICE
+ OMUL
+ ODIV
+ OMOD
+ OLSH
+ ORSH
+ OAND
+ OANDNOT
+ ONEW
+ ONOT
+ OCOM
+ OPLUS
+ OMINUS
+ OOROR
+ OPANIC
+ OPRINT
+ OPRINTN
+ OPAREN
+ OSEND
+ OSLICE
+ OSLICEARR
+ OSLICESTR
+ OSLICE3
+ OSLICE3ARR
+ ORECOVER
+ ORECV
+ ORUNESTR
+ OSELRECV
+ OSELRECV2
+ OIOTA
+ OREAL
+ OIMAG
+ OCOMPLEX
+ OBLOCK
+ OBREAK
+ OCASE
+ OXCASE
+ OCONTINUE
+ ODEFER
+ OEMPTY
+ OFALL
+ OXFALL
+ OFOR
+ OGOTO
+ OIF
+ OLABEL
+ OPROC
+ ORANGE
+ ORETURN
+ OSELECT
+ OSWITCH
+ OTYPESW
+ OTCHAN
+ OTMAP
+ OTSTRUCT
+ OTINTER
+ OTFUNC
+ OTARRAY
+ ODDD
+ ODDDARG
+ OINLCALL
+ OEFACE
+ OITAB
+ OSPTR
+ OCLOSUREVAR
+ OCFUNC
+ OCHECKNIL
+ OVARKILL
+ OREGISTER
+ OINDREG
+ OCMP
+ ODEC
+ OINC
+ OEXTEND
+ OHMUL
+ OLROT
+ ORROTC
+ ORETJMP
+ OEND
+)
+
+const (
+ Txxx = iota
+ TINT8
+ TUINT8
+ TINT16
+ TUINT16
+ TINT32
+ TUINT32
+ TINT64
+ TUINT64
+ TINT
+ TUINT
+ TUINTPTR
+ TCOMPLEX64
+ TCOMPLEX128
+ TFLOAT32
+ TFLOAT64
+ TBOOL
+ TPTR32
+ TPTR64
+ TFUNC
+ TARRAY
+ T_old_DARRAY
+ TSTRUCT
+ TCHAN
+ TMAP
+ TINTER
+ TFORW
+ TFIELD
+ TANY
+ TSTRING
+ TUNSAFEPTR
+ TIDEAL
+ TNIL
+ TBLANK
+ TFUNCARGS
+ TCHANARGS
+ TINTERMETH
+ NTYPE
+)
+
+const (
+ CTxxx = iota
+ CTINT
+ CTRUNE
+ CTFLT
+ CTCPLX
+ CTSTR
+ CTBOOL
+ CTNIL
+)
+
+const (
+ Cxxx = 0
+ Crecv = 1 << 0
+ Csend = 1 << 1
+ Cboth = Crecv | Csend
+)
+
+// declaration context
+const (
+ Pxxx = iota
+ PEXTERN
+ PAUTO
+ PPARAM
+ PPARAMOUT
+ PPARAMREF
+ PFUNC
+ PDISCARD
+ PHEAP = 1 << 7
+)
+
+const (
+ Etop = 1 << 1
+ Erv = 1 << 2
+ Etype = 1 << 3
+ Ecall = 1 << 4
+ Efnstruct = 1 << 5
+ Eiota = 1 << 6
+ Easgn = 1 << 7
+ Eindir = 1 << 8
+ Eaddr = 1 << 9
+ Eproc = 1 << 10
+ Ecomplit = 1 << 11
+)
+
+const (
+ BITS = 3
+ NVAR = BITS * 64
+)
+
+type Bits struct {
+ b [BITS]uint64
+}
+
+var zbits Bits
+
+type Var struct {
+ offset int64
+ node *Node
+ nextinnode *Var
+ width int
+ id int
+ name int8
+ etype int8
+ addr int8
+}
+
+var var_ [NVAR]Var
+
+type Typedef struct {
+ Name string
+ Etype int
+ Sameas int
+}
+
+type Sig struct {
+ name string
+ pkg *Pkg
+ isym *Sym
+ tsym *Sym
+ type_ *Type
+ mtype *Type
+ offset int32
+ link *Sig
+}
+
+type Io struct {
+ infile string
+ bin *obj.Biobuf
+ ilineno int32
+ nlsemi int
+ eofnl int
+ last int
+ peekc int
+ peekc1 int
+ cp string
+ importsafe bool
+}
+
+type Dlist struct {
+ field *Type
+}
+
+type Idir struct {
+ link *Idir
+ dir string
+}
+
+/*
+ * argument passing to/from
+ * smagic and umagic
+ */
+type Magic struct {
+ W int
+ S int
+ Bad int
+ Sd int64
+ Sm int64
+ Ud uint64
+ Um uint64
+ Ua int
+}
+
+/*
+ * note this is the runtime representation
+ * of the compilers arrays.
+ *
+ * typedef struct
+ * { // must not move anything
+ * uchar array[8]; // pointer to data
+ * uchar nel[4]; // number of elements
+ * uchar cap[4]; // allocated number of elements
+ * } Array;
+ */
+var Array_array int // runtime offsetof(Array,array) - same for String
+
+var Array_nel int // runtime offsetof(Array,nel) - same for String
+
+var Array_cap int // runtime offsetof(Array,cap)
+
+var sizeof_Array int // runtime sizeof(Array)
+
+/*
+ * note this is the runtime representation
+ * of the compilers strings.
+ *
+ * typedef struct
+ * { // must not move anything
+ * uchar array[8]; // pointer to data
+ * uchar nel[4]; // number of elements
+ * } String;
+ */
+var sizeof_String int // runtime sizeof(String)
+
+var dotlist [10]Dlist // size is max depth of embeddeds
+
+var curio Io
+
+var pushedio Io
+
+var lexlineno int32
+
+var lineno int32
+
+var prevlineno int32
+
+var pragcgobuf string
+
+var infile string
+
+var outfile string
+
+var bout *obj.Biobuf
+
+var nerrors int
+
+var nsavederrors int
+
+var nsyntaxerrors int
+
+var decldepth int
+
+var safemode int
+
+var nolocalimports int
+
+var namebuf string
+
+var lexbuf bytes.Buffer
+var strbuf bytes.Buffer
+
+func DBG(...interface{}) {}
+
+var litbuf string
+
+var Debug [256]int
+
+var debugstr string
+
+var Debug_checknil int
+
+var hash [NHASH]*Sym
+
+var importmyname *Sym // my name for package
+
+var localpkg *Pkg // package being compiled
+
+var importpkg *Pkg // package being imported
+
+var structpkg *Pkg // package that declared struct, during import
+
+var builtinpkg *Pkg // fake package for builtins
+
+var gostringpkg *Pkg // fake pkg for Go strings
+
+var itabpkg *Pkg // fake pkg for itab cache
+
+var Runtimepkg *Pkg // package runtime
+
+var racepkg *Pkg // package runtime/race
+
+var stringpkg *Pkg // fake package for C strings
+
+var typepkg *Pkg // fake package for runtime type info (headers)
+
+var typelinkpkg *Pkg // fake package for runtime type info (data)
+
+var weaktypepkg *Pkg // weak references to runtime type info
+
+var unsafepkg *Pkg // package unsafe
+
+var trackpkg *Pkg // fake package for field tracking
+
+var rawpkg *Pkg // fake package for raw symbol names
+
+var phash [128]*Pkg
+
+var Tptr int // either TPTR32 or TPTR64
+
+var myimportpath string
+
+var idirs *Idir
+
+var localimport string
+
+var asmhdr string
+
+var Types [NTYPE]*Type
+
+var idealstring *Type
+
+var idealbool *Type
+
+var bytetype *Type
+
+var runetype *Type
+
+var errortype *Type
+
+var Simtype [NTYPE]uint8
+
+var Isptr [NTYPE]uint8
+
+var isforw [NTYPE]uint8
+
+var Isint [NTYPE]uint8
+
+var Isfloat [NTYPE]uint8
+
+var Iscomplex [NTYPE]uint8
+
+var Issigned [NTYPE]uint8
+
+var issimple [NTYPE]uint8
+
+var okforeq [NTYPE]uint8
+
+var okforadd [NTYPE]uint8
+
+var okforand [NTYPE]uint8
+
+var okfornone [NTYPE]uint8
+
+var okforcmp [NTYPE]uint8
+
+var okforbool [NTYPE]uint8
+
+var okforcap [NTYPE]uint8
+
+var okforlen [NTYPE]uint8
+
+var okforarith [NTYPE]uint8
+
+var okforconst [NTYPE]uint8
+
+var okfor [OEND][]byte
+
+var iscmp [OEND]uint8
+
+var Minintval [NTYPE]*Mpint
+
+var Maxintval [NTYPE]*Mpint
+
+var minfltval [NTYPE]*Mpflt
+
+var maxfltval [NTYPE]*Mpflt
+
+var xtop *NodeList
+
+var externdcl *NodeList
+
+var exportlist *NodeList
+
+var importlist *NodeList // imported functions and methods with inlinable bodies
+
+var funcsyms *NodeList
+
+var dclcontext int // PEXTERN/PAUTO
+
+var incannedimport int
+
+var statuniqgen int // name generator for static temps
+
+var loophack int
+
+var iota_ int32
+
+var lastconst *NodeList
+
+var lasttype *Node
+
+var Maxarg int64
+
+var Stksize int64 // stack size for current frame
+
+var stkptrsize int64 // prefix of stack containing pointers
+
+var blockgen int32 // max block number
+
+var block int32 // current block number
+
+var Hasdefer int // flag that curfn has defer statetment
+
+var Curfn *Node
+
+var Widthptr int
+
+var Widthint int
+
+var Widthreg int
+
+var typesw *Node
+
+var nblank *Node
+
+var Use_sse int
+
+var thunk int32
+
+var Funcdepth int
+
+var typecheckok int
+
+var compiling_runtime int
+
+var compiling_wrappers int
+
+var inl_nonlocal int
+
+var use_writebarrier int
+
+var pure_go int
+
+var flag_installsuffix string
+
+var flag_race int
+
+var flag_largemodel int
+
+var noescape bool
+
+var nosplit bool
+
+var nowritebarrier bool
+
+var debuglive int
+
+var Ctxt *obj.Link
+
+var nointerface bool
+
+var writearchive int
+
+var bstdout obj.Biobuf
+
+var Nacl bool
+
+/*
+ * y.tab.c
+ */
+
+/*
+ * align.c
+ */
+
+/*
+ * array.c
+ */
+
+/*
+ * bits.c
+ */
+
+/*
+ * mparith1.c
+ */
+
+/*
+ * mparith2.c
+ */
+
+/*
+ * mparith3.c
+ */
+
+/*
+ * obj.c
+ */
+
+/*
+ * order.c
+ */
+
+/*
+ * range.c
+ */
+
+/*
+ * reflect.c
+ */
+
+/*
+ * select.c
+ */
+
+/*
+ * sinit.c
+ */
+
+/*
+ * subr.c
+ */
+
+/*
+ * swt.c
+ */
+
+/*
+ * typecheck.c
+ */
+
+/*
+ * unsafe.c
+ */
+
+/*
+ * walk.c
+ */
+
+/*
+ * thearch-specific ggen.c/gsubr.c/gobj.c/pgen.c/plive.c
+ */
+var continpc *obj.Prog
+
+var breakpc *obj.Prog
+
+var Pc *obj.Prog
+
+var firstpc *obj.Prog
+
+var nodfp *Node
+
+var Disable_checknil int
+
+var zerosize int64
+
+/*
+ * racewalk.c
+ */
+
+/*
+ * flow.c
+ */
+type Flow struct {
+ Prog *obj.Prog
+ P1 *Flow
+ P2 *Flow
+ P2link *Flow
+ S1 *Flow
+ S2 *Flow
+ Link *Flow
+ Active int32
+ Id int32
+ Rpo int32
+ Loop uint16
+ Refset uint8
+ Data interface{}
+}
+
+type Graph struct {
+ Start *Flow
+ Num int
+ Rpo []*Flow
+}
+
+/*
+ * interface to back end
+ */
+type ProgInfo struct {
+ Flags uint32
+ Reguse uint64
+ Regset uint64
+ Regindex uint64
+}
+
+const (
+ Pseudo = 1 << 1
+ OK = 1 << 2
+ SizeB = 1 << 3
+ SizeW = 1 << 4
+ SizeL = 1 << 5
+ SizeQ = 1 << 6
+ SizeF = 1 << 7
+ SizeD = 1 << 8
+ LeftAddr = 1 << 9
+ LeftRead = 1 << 10
+ LeftWrite = 1 << 11
+ RegRead = 1 << 12
+ CanRegRead = 1 << 13
+ RightAddr = 1 << 14
+ RightRead = 1 << 15
+ RightWrite = 1 << 16
+ Move = 1 << 17
+ Conv = 1 << 18
+ Cjmp = 1 << 19
+ Break = 1 << 20
+ Call = 1 << 21
+ Jump = 1 << 22
+ Skip = 1 << 23
+ SetCarry = 1 << 24
+ UseCarry = 1 << 25
+ KillCarry = 1 << 26
+ ShiftCX = 1 << 27
+ ImulAXDX = 1 << 28
+ PostInc = 1 << 29
+)
+
+type Arch struct {
+ ByteOrder binary.ByteOrder
+ Thechar int
+ Thestring string
+ Thelinkarch *obj.LinkArch
+ Typedefs []Typedef
+ REGSP int
+ REGCTXT int
+ MAXWIDTH int64
+ Anyregalloc func() int
+ Betypeinit func()
+ Bgen func(*Node, bool, int, *obj.Prog)
+ Cgen func(*Node, *Node)
+ Cgen_call func(*Node, int)
+ Cgen_callinter func(*Node, *Node, int)
+ Cgen_ret func(*Node)
+ Clearfat func(*Node)
+ Defframe func(*obj.Prog)
+ Excise func(*Flow)
+ Expandchecks func(*obj.Prog)
+ Gclean func()
+ Ginit func()
+ Gins func(int, *Node, *Node) *obj.Prog
+ Ginscall func(*Node, int)
+ Igen func(*Node, *Node, *Node)
+ Linkarchinit func()
+ Peep func(*obj.Prog)
+ Proginfo func(*ProgInfo, *obj.Prog)
+ Regalloc func(*Node, *Type, *Node)
+ Regfree func(*Node)
+ Regtyp func(*obj.Addr) int
+ Sameaddr func(*obj.Addr, *obj.Addr) int
+ Smallindir func(*obj.Addr, *obj.Addr) int
+ Stackaddr func(*obj.Addr) int
+ Excludedregs func() uint64
+ RtoB func(int) uint64
+ FtoB func(int) uint64
+ BtoR func(uint64) int
+ BtoF func(uint64) int
+ Optoas func(int, *Type) int
+ Doregbits func(int) uint64
+ Regnames func(*int) []string
+}
+
+var pcloc int32
+
+var Thearch Arch
+
+var Newproc *Node
+
+var Deferproc *Node
+
+var Deferreturn *Node
+
+var Panicindex *Node
+
+var panicslice *Node
+
+var throwreturn *Node
diff --git a/src/cmd/internal/gc/go.y b/src/cmd/internal/gc/go.y
new file mode 100644
index 0000000..9038449
--- /dev/null
+++ b/src/cmd/internal/gc/go.y
@@ -0,0 +1,2252 @@
+// 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.
+
+/*
+ * Go language grammar.
+ *
+ * The Go semicolon rules are:
+ *
+ * 1. all statements and declarations are terminated by semicolons.
+ * 2. semicolons can be omitted before a closing ) or }.
+ * 3. semicolons are inserted by the lexer before a newline
+ * following a specific list of tokens.
+ *
+ * Rules #1 and #2 are accomplished by writing the lists as
+ * semicolon-separated lists with an optional trailing semicolon.
+ * Rule #3 is implemented in yylex.
+ */
+
+%{
+package gc
+
+import (
+ "strings"
+)
+%}
+%union {
+ node *Node
+ list *NodeList
+ typ *Type
+ sym *Sym
+ val Val
+ i int
+}
+
+// |sed 's/.* //' |9 fmt -l1 |sort |9 fmt -l50 | sed 's/^/%xxx /'
+
+%token <val> LLITERAL
+%token <i> LASOP LCOLAS
+%token <sym> LBREAK LCASE LCHAN LCONST LCONTINUE LDDD
+%token <sym> LDEFAULT LDEFER LELSE LFALL LFOR LFUNC LGO LGOTO
+%token <sym> LIF LIMPORT LINTERFACE LMAP LNAME
+%token <sym> LPACKAGE LRANGE LRETURN LSELECT LSTRUCT LSWITCH
+%token <sym> LTYPE LVAR
+
+%token LANDAND LANDNOT LBODY LCOMM LDEC LEQ LGE LGT
+%token LIGNORE LINC LLE LLSH LLT LNE LOROR LRSH
+
+%type <i> lbrace import_here
+%type <sym> sym packname
+%type <val> oliteral
+
+%type <node> stmt ntype
+%type <node> arg_type
+%type <node> case caseblock
+%type <node> compound_stmt dotname embed expr complitexpr bare_complitexpr
+%type <node> expr_or_type
+%type <node> fndcl hidden_fndcl fnliteral
+%type <node> for_body for_header for_stmt if_header if_stmt non_dcl_stmt
+%type <node> interfacedcl keyval labelname name
+%type <node> name_or_type non_expr_type
+%type <node> new_name dcl_name oexpr typedclname
+%type <node> onew_name
+%type <node> osimple_stmt pexpr pexpr_no_paren
+%type <node> pseudocall range_stmt select_stmt
+%type <node> simple_stmt
+%type <node> switch_stmt uexpr
+%type <node> xfndcl typedcl start_complit
+
+%type <list> xdcl fnbody fnres loop_body dcl_name_list
+%type <list> new_name_list expr_list keyval_list braced_keyval_list expr_or_type_list xdcl_list
+%type <list> oexpr_list caseblock_list elseif elseif_list else stmt_list oarg_type_list_ocomma arg_type_list
+%type <list> interfacedcl_list vardcl vardcl_list structdcl structdcl_list
+%type <list> common_dcl constdcl constdcl1 constdcl_list typedcl_list
+
+%type <node> convtype comptype dotdotdot
+%type <node> indcl interfacetype structtype ptrtype
+%type <node> recvchantype non_recvchantype othertype fnret_type fntype
+
+%type <sym> hidden_importsym hidden_pkg_importsym
+
+%type <node> hidden_constant hidden_literal hidden_funarg
+%type <node> hidden_interfacedcl hidden_structdcl
+
+%type <list> hidden_funres
+%type <list> ohidden_funres
+%type <list> hidden_funarg_list ohidden_funarg_list
+%type <list> hidden_interfacedcl_list ohidden_interfacedcl_list
+%type <list> hidden_structdcl_list ohidden_structdcl_list
+
+%type <typ> hidden_type hidden_type_misc hidden_pkgtype
+%type <typ> hidden_type_func
+%type <typ> hidden_type_recv_chan hidden_type_non_recv_chan
+
+%left LCOMM /* outside the usual hierarchy; here for good error messages */
+
+%left LOROR
+%left LANDAND
+%left LEQ LNE LLE LGE LLT LGT
+%left '+' '-' '|' '^'
+%left '*' '/' '%' '&' LLSH LRSH LANDNOT
+
+/*
+ * manual override of shift/reduce conflicts.
+ * the general form is that we assign a precedence
+ * to the token being shifted and then introduce
+ * NotToken with lower precedence or PreferToToken with higher
+ * and annotate the reducing rule accordingly.
+ */
+%left NotPackage
+%left LPACKAGE
+
+%left NotParen
+%left '('
+
+%left ')'
+%left PreferToRightParen
+
+// TODO(rsc): Add %error-verbose
+
+%%
+file:
+ loadsys
+ package
+ imports
+ xdcl_list
+ {
+ xtop = concat(xtop, $4);
+ }
+
+package:
+ %prec NotPackage
+ {
+ prevlineno = lineno;
+ Yyerror("package statement must be first");
+ errorexit();
+ }
+| LPACKAGE sym ';'
+ {
+ mkpackage($2.Name);
+ }
+
+/*
+ * this loads the definitions for the low-level runtime functions,
+ * so that the compiler can generate calls to them,
+ * but does not make the name "runtime" visible as a package.
+ */
+loadsys:
+ {
+ importpkg = Runtimepkg;
+
+ if Debug['A'] != 0 {
+ cannedimports("runtime.Builtin", "package runtime\n\n$$\n\n");
+ } else {
+ cannedimports("runtime.Builtin", runtimeimport);
+ }
+ curio.importsafe = true
+ }
+ import_package
+ import_there
+ {
+ importpkg = nil;
+ }
+
+imports:
+| imports import ';'
+
+import:
+ LIMPORT import_stmt
+| LIMPORT '(' import_stmt_list osemi ')'
+| LIMPORT '(' ')'
+
+import_stmt:
+ import_here import_package import_there
+ {
+ ipkg := importpkg;
+ my := importmyname;
+ importpkg = nil;
+ importmyname = nil;
+
+ if my == nil {
+ my = Lookup(ipkg.Name);
+ }
+
+ pack := Nod(OPACK, nil, nil);
+ pack.Sym = my;
+ pack.Pkg = ipkg;
+ pack.Lineno = int32($1);
+
+ if strings.HasPrefix(my.Name, ".") {
+ importdot(ipkg, pack);
+ break;
+ }
+ if my.Name == "init" {
+ Yyerror("cannot import package as init - init must be a func");
+ break;
+ }
+ if my.Name == "_" {
+ break;
+ }
+ if my.Def != nil {
+ lineno = int32($1);
+ redeclare(my, "as imported package name");
+ }
+ my.Def = pack;
+ my.Lastlineno = int32($1);
+ my.Block = 1; // at top level
+ }
+| import_here import_there
+ {
+ // When an invalid import path is passed to importfile,
+ // it calls Yyerror and then sets up a fake import with
+ // no package statement. This allows us to test more
+ // than one invalid import statement in a single file.
+ if nerrors == 0 {
+ Fatal("phase error in import");
+ }
+ }
+
+import_stmt_list:
+ import_stmt
+| import_stmt_list ';' import_stmt
+
+import_here:
+ LLITERAL
+ {
+ // import with original name
+ $$ = parserline();
+ importmyname = nil;
+ importfile(&$1, $$);
+ }
+| sym LLITERAL
+ {
+ // import with given name
+ $$ = parserline();
+ importmyname = $1;
+ importfile(&$2, $$);
+ }
+| '.' LLITERAL
+ {
+ // import into my name space
+ $$ = parserline();
+ importmyname = Lookup(".");
+ importfile(&$2, $$);
+ }
+
+import_package:
+ LPACKAGE LNAME import_safety ';'
+ {
+ if importpkg.Name == "" {
+ importpkg.Name = $2.Name;
+ Pkglookup($2.Name, nil).Npkg++;
+ } else if importpkg.Name != $2.Name {
+ Yyerror("conflicting names %s and %s for package \"%v\"", importpkg.Name, $2.Name, Zconv(importpkg.Path, 0));
+ }
+ importpkg.Direct = 1;
+ importpkg.Safe = curio.importsafe
+
+ if safemode != 0 && !curio.importsafe {
+ Yyerror("cannot import unsafe package \"%v\"", Zconv(importpkg.Path, 0));
+ }
+ }
+
+import_safety:
+| LNAME
+ {
+ if $1.Name == "safe" {
+ curio.importsafe = true
+ }
+ }
+
+import_there:
+ {
+ defercheckwidth();
+ }
+ hidden_import_list '$' '$'
+ {
+ resumecheckwidth();
+ unimportfile();
+ }
+
+/*
+ * declarations
+ */
+xdcl:
+ {
+ Yyerror("empty top-level declaration");
+ $$ = nil;
+ }
+| common_dcl
+| xfndcl
+ {
+ $$ = list1($1);
+ }
+| non_dcl_stmt
+ {
+ Yyerror("non-declaration statement outside function body");
+ $$ = nil;
+ }
+| error
+ {
+ $$ = nil;
+ }
+
+common_dcl:
+ LVAR vardcl
+ {
+ $$ = $2;
+ }
+| LVAR '(' vardcl_list osemi ')'
+ {
+ $$ = $3;
+ }
+| LVAR '(' ')'
+ {
+ $$ = nil;
+ }
+| lconst constdcl
+ {
+ $$ = $2;
+ iota_ = -100000;
+ lastconst = nil;
+ }
+| lconst '(' constdcl osemi ')'
+ {
+ $$ = $3;
+ iota_ = -100000;
+ lastconst = nil;
+ }
+| lconst '(' constdcl ';' constdcl_list osemi ')'
+ {
+ $$ = concat($3, $5);
+ iota_ = -100000;
+ lastconst = nil;
+ }
+| lconst '(' ')'
+ {
+ $$ = nil;
+ iota_ = -100000;
+ }
+| LTYPE typedcl
+ {
+ $$ = list1($2);
+ }
+| LTYPE '(' typedcl_list osemi ')'
+ {
+ $$ = $3;
+ }
+| LTYPE '(' ')'
+ {
+ $$ = nil;
+ }
+
+lconst:
+ LCONST
+ {
+ iota_ = 0;
+ }
+
+vardcl:
+ dcl_name_list ntype
+ {
+ $$ = variter($1, $2, nil);
+ }
+| dcl_name_list ntype '=' expr_list
+ {
+ $$ = variter($1, $2, $4);
+ }
+| dcl_name_list '=' expr_list
+ {
+ $$ = variter($1, nil, $3);
+ }
+
+constdcl:
+ dcl_name_list ntype '=' expr_list
+ {
+ $$ = constiter($1, $2, $4);
+ }
+| dcl_name_list '=' expr_list
+ {
+ $$ = constiter($1, nil, $3);
+ }
+
+constdcl1:
+ constdcl
+| dcl_name_list ntype
+ {
+ $$ = constiter($1, $2, nil);
+ }
+| dcl_name_list
+ {
+ $$ = constiter($1, nil, nil);
+ }
+
+typedclname:
+ sym
+ {
+ // different from dclname because the name
+ // becomes visible right here, not at the end
+ // of the declaration.
+ $$ = typedcl0($1);
+ }
+
+typedcl:
+ typedclname ntype
+ {
+ $$ = typedcl1($1, $2, 1);
+ }
+
+simple_stmt:
+ expr
+ {
+ $$ = $1;
+
+ // These nodes do not carry line numbers.
+ // Since a bare name used as an expression is an error,
+ // introduce a wrapper node to give the correct line.
+ switch($$.Op) {
+ case ONAME, ONONAME, OTYPE, OPACK, OLITERAL:
+ $$ = Nod(OPAREN, $$, nil);
+ $$.Implicit = 1;
+ break;
+ }
+ }
+| expr LASOP expr
+ {
+ $$ = Nod(OASOP, $1, $3);
+ $$.Etype = uint8($2); // rathole to pass opcode
+ }
+| expr_list '=' expr_list
+ {
+ if $1.Next == nil && $3.Next == nil {
+ // simple
+ $$ = Nod(OAS, $1.N, $3.N);
+ break;
+ }
+ // multiple
+ $$ = Nod(OAS2, nil, nil);
+ $$.List = $1;
+ $$.Rlist = $3;
+ }
+| expr_list LCOLAS expr_list
+ {
+ if $3.N.Op == OTYPESW {
+ $$ = Nod(OTYPESW, nil, $3.N.Right);
+ if $3.Next != nil {
+ Yyerror("expr.(type) must be alone in list");
+ }
+ if $1.Next != nil {
+ Yyerror("argument count mismatch: %d = %d", count($1), 1);
+ } else if ($1.N.Op != ONAME && $1.N.Op != OTYPE && $1.N.Op != ONONAME) || isblank($1.N) {
+ Yyerror("invalid variable name %nil in type switch", $1.N);
+ } else {
+ $$.Left = dclname($1.N.Sym);
+ } // it's a colas, so must not re-use an oldname.
+ break;
+ }
+ $$ = colas($1, $3, int32($2));
+ }
+| expr LINC
+ {
+ $$ = Nod(OASOP, $1, Nodintconst(1));
+ $$.Implicit = 1;
+ $$.Etype = OADD;
+ }
+| expr LDEC
+ {
+ $$ = Nod(OASOP, $1, Nodintconst(1));
+ $$.Implicit = 1;
+ $$.Etype = OSUB;
+ }
+
+case:
+ LCASE expr_or_type_list ':'
+ {
+ var n, nn *Node
+
+ // will be converted to OCASE
+ // right will point to next case
+ // done in casebody()
+ markdcl();
+ $$ = Nod(OXCASE, nil, nil);
+ $$.List = $2;
+ if typesw != nil && typesw.Right != nil {
+ n = typesw.Right.Left
+ if n != nil {
+ // type switch - declare variable
+ nn = newname(n.Sym);
+ declare(nn, dclcontext);
+ $$.Nname = nn;
+
+ // keep track of the instances for reporting unused
+ nn.Defn = typesw.Right;
+ }
+ }
+ }
+| LCASE expr_or_type_list '=' expr ':'
+ {
+ var n *Node
+
+ // will be converted to OCASE
+ // right will point to next case
+ // done in casebody()
+ markdcl();
+ $$ = Nod(OXCASE, nil, nil);
+ if $2.Next == nil {
+ n = Nod(OAS, $2.N, $4);
+ } else {
+ n = Nod(OAS2, nil, nil);
+ n.List = $2;
+ n.Rlist = list1($4);
+ }
+ $$.List = list1(n);
+ }
+| LCASE expr_or_type_list LCOLAS expr ':'
+ {
+ // will be converted to OCASE
+ // right will point to next case
+ // done in casebody()
+ markdcl();
+ $$ = Nod(OXCASE, nil, nil);
+ $$.List = list1(colas($2, list1($4), int32($3)));
+ }
+| LDEFAULT ':'
+ {
+ var n, nn *Node
+
+ markdcl();
+ $$ = Nod(OXCASE, nil, nil);
+ if typesw != nil && typesw.Right != nil {
+ n = typesw.Right.Left
+ if n != nil {
+ // type switch - declare variable
+ nn = newname(n.Sym);
+ declare(nn, dclcontext);
+ $$.Nname = nn;
+
+ // keep track of the instances for reporting unused
+ nn.Defn = typesw.Right;
+ }
+ }
+ }
+
+compound_stmt:
+ '{'
+ {
+ markdcl();
+ }
+ stmt_list '}'
+ {
+ if $3 == nil {
+ $$ = Nod(OEMPTY, nil, nil);
+ } else {
+ $$ = liststmt($3);
+ }
+ popdcl();
+ }
+
+caseblock:
+ case
+ {
+ // If the last token read by the lexer was consumed
+ // as part of the case, clear it (parser has cleared yychar).
+ // If the last token read by the lexer was the lookahead
+ // leave it alone (parser has it cached in yychar).
+ // This is so that the stmt_list action doesn't look at
+ // the case tokens if the stmt_list is empty.
+ yylast = yychar;
+ $1.Xoffset = int64(block);
+ }
+ stmt_list
+ {
+ // This is the only place in the language where a statement
+ // list is not allowed to drop the final semicolon, because
+ // it's the only place where a statement list is not followed
+ // by a closing brace. Handle the error for pedantry.
+
+ // Find the final token of the statement list.
+ // yylast is lookahead; yyprev is last of stmt_list
+ last := yyprev;
+
+ if last > 0 && last != ';' && yychar != '}' {
+ Yyerror("missing statement after label");
+ }
+ $$ = $1;
+ $$.Nbody = $3;
+ popdcl();
+ }
+
+caseblock_list:
+ {
+ $$ = nil;
+ }
+| caseblock_list caseblock
+ {
+ $$ = list($1, $2);
+ }
+
+loop_body:
+ LBODY
+ {
+ markdcl();
+ }
+ stmt_list '}'
+ {
+ $$ = $3;
+ popdcl();
+ }
+
+range_stmt:
+ expr_list '=' LRANGE expr
+ {
+ $$ = Nod(ORANGE, nil, $4);
+ $$.List = $1;
+ $$.Etype = 0; // := flag
+ }
+| expr_list LCOLAS LRANGE expr
+ {
+ $$ = Nod(ORANGE, nil, $4);
+ $$.List = $1;
+ $$.Colas = 1;
+ colasdefn($1, $$);
+ }
+| LRANGE expr
+ {
+ $$ = Nod(ORANGE, nil, $2);
+ $$.Etype = 0; // := flag
+ }
+
+for_header:
+ osimple_stmt ';' osimple_stmt ';' osimple_stmt
+ {
+ // init ; test ; incr
+ if $5 != nil && $5.Colas != 0 {
+ Yyerror("cannot declare in the for-increment");
+ }
+ $$ = Nod(OFOR, nil, nil);
+ if $1 != nil {
+ $$.Ninit = list1($1);
+ }
+ $$.Ntest = $3;
+ $$.Nincr = $5;
+ }
+| osimple_stmt
+ {
+ // normal test
+ $$ = Nod(OFOR, nil, nil);
+ $$.Ntest = $1;
+ }
+| range_stmt
+
+for_body:
+ for_header loop_body
+ {
+ $$ = $1;
+ $$.Nbody = concat($$.Nbody, $2);
+ }
+
+for_stmt:
+ LFOR
+ {
+ markdcl();
+ }
+ for_body
+ {
+ $$ = $3;
+ popdcl();
+ }
+
+if_header:
+ osimple_stmt
+ {
+ // test
+ $$ = Nod(OIF, nil, nil);
+ $$.Ntest = $1;
+ }
+| osimple_stmt ';' osimple_stmt
+ {
+ // init ; test
+ $$ = Nod(OIF, nil, nil);
+ if $1 != nil {
+ $$.Ninit = list1($1);
+ }
+ $$.Ntest = $3;
+ }
+
+/* IF cond body (ELSE IF cond body)* (ELSE block)? */
+if_stmt:
+ LIF
+ {
+ markdcl();
+ }
+ if_header
+ {
+ if $3.Ntest == nil {
+ Yyerror("missing condition in if statement");
+ }
+ }
+ loop_body
+ {
+ $3.Nbody = $5;
+ }
+ elseif_list else
+ {
+ var n *Node
+ var nn *NodeList
+
+ $$ = $3;
+ n = $3;
+ popdcl();
+ for nn = concat($7, $8); nn != nil; nn = nn.Next {
+ if nn.N.Op == OIF {
+ popdcl();
+ }
+ n.Nelse = list1(nn.N);
+ n = nn.N;
+ }
+ }
+
+elseif:
+ LELSE LIF
+ {
+ markdcl();
+ }
+ if_header loop_body
+ {
+ if $4.Ntest == nil {
+ Yyerror("missing condition in if statement");
+ }
+ $4.Nbody = $5;
+ $$ = list1($4);
+ }
+
+elseif_list:
+ {
+ $$ = nil;
+ }
+| elseif_list elseif
+ {
+ $$ = concat($1, $2);
+ }
+
+else:
+ {
+ $$ = nil;
+ }
+| LELSE compound_stmt
+ {
+ l := &NodeList{N: $2}
+ l.End = l
+ $$ = l;
+ }
+
+switch_stmt:
+ LSWITCH
+ {
+ markdcl();
+ }
+ if_header
+ {
+ var n *Node
+ n = $3.Ntest;
+ if n != nil && n.Op != OTYPESW {
+ n = nil;
+ }
+ typesw = Nod(OXXX, typesw, n);
+ }
+ LBODY caseblock_list '}'
+ {
+ $$ = $3;
+ $$.Op = OSWITCH;
+ $$.List = $6;
+ typesw = typesw.Left;
+ popdcl();
+ }
+
+select_stmt:
+ LSELECT
+ {
+ typesw = Nod(OXXX, typesw, nil);
+ }
+ LBODY caseblock_list '}'
+ {
+ $$ = Nod(OSELECT, nil, nil);
+ $$.Lineno = typesw.Lineno;
+ $$.List = $4;
+ typesw = typesw.Left;
+ }
+
+/*
+ * expressions
+ */
+expr:
+ uexpr
+| expr LOROR expr
+ {
+ $$ = Nod(OOROR, $1, $3);
+ }
+| expr LANDAND expr
+ {
+ $$ = Nod(OANDAND, $1, $3);
+ }
+| expr LEQ expr
+ {
+ $$ = Nod(OEQ, $1, $3);
+ }
+| expr LNE expr
+ {
+ $$ = Nod(ONE, $1, $3);
+ }
+| expr LLT expr
+ {
+ $$ = Nod(OLT, $1, $3);
+ }
+| expr LLE expr
+ {
+ $$ = Nod(OLE, $1, $3);
+ }
+| expr LGE expr
+ {
+ $$ = Nod(OGE, $1, $3);
+ }
+| expr LGT expr
+ {
+ $$ = Nod(OGT, $1, $3);
+ }
+| expr '+' expr
+ {
+ $$ = Nod(OADD, $1, $3);
+ }
+| expr '-' expr
+ {
+ $$ = Nod(OSUB, $1, $3);
+ }
+| expr '|' expr
+ {
+ $$ = Nod(OOR, $1, $3);
+ }
+| expr '^' expr
+ {
+ $$ = Nod(OXOR, $1, $3);
+ }
+| expr '*' expr
+ {
+ $$ = Nod(OMUL, $1, $3);
+ }
+| expr '/' expr
+ {
+ $$ = Nod(ODIV, $1, $3);
+ }
+| expr '%' expr
+ {
+ $$ = Nod(OMOD, $1, $3);
+ }
+| expr '&' expr
+ {
+ $$ = Nod(OAND, $1, $3);
+ }
+| expr LANDNOT expr
+ {
+ $$ = Nod(OANDNOT, $1, $3);
+ }
+| expr LLSH expr
+ {
+ $$ = Nod(OLSH, $1, $3);
+ }
+| expr LRSH expr
+ {
+ $$ = Nod(ORSH, $1, $3);
+ }
+ /* not an expression anymore, but left in so we can give a good error */
+| expr LCOMM expr
+ {
+ $$ = Nod(OSEND, $1, $3);
+ }
+
+uexpr:
+ pexpr
+| '*' uexpr
+ {
+ $$ = Nod(OIND, $2, nil);
+ }
+| '&' uexpr
+ {
+ if $2.Op == OCOMPLIT {
+ // Special case for &T{...}: turn into (*T){...}.
+ $$ = $2;
+ $$.Right = Nod(OIND, $$.Right, nil);
+ $$.Right.Implicit = 1;
+ } else {
+ $$ = Nod(OADDR, $2, nil);
+ }
+ }
+| '+' uexpr
+ {
+ $$ = Nod(OPLUS, $2, nil);
+ }
+| '-' uexpr
+ {
+ $$ = Nod(OMINUS, $2, nil);
+ }
+| '!' uexpr
+ {
+ $$ = Nod(ONOT, $2, nil);
+ }
+| '~' uexpr
+ {
+ Yyerror("the bitwise complement operator is ^");
+ $$ = Nod(OCOM, $2, nil);
+ }
+| '^' uexpr
+ {
+ $$ = Nod(OCOM, $2, nil);
+ }
+| LCOMM uexpr
+ {
+ $$ = Nod(ORECV, $2, nil);
+ }
+
+/*
+ * call-like statements that
+ * can be preceded by 'defer' and 'go'
+ */
+pseudocall:
+ pexpr '(' ')'
+ {
+ $$ = Nod(OCALL, $1, nil);
+ }
+| pexpr '(' expr_or_type_list ocomma ')'
+ {
+ $$ = Nod(OCALL, $1, nil);
+ $$.List = $3;
+ }
+| pexpr '(' expr_or_type_list LDDD ocomma ')'
+ {
+ $$ = Nod(OCALL, $1, nil);
+ $$.List = $3;
+ $$.Isddd = 1;
+ }
+
+pexpr_no_paren:
+ LLITERAL
+ {
+ $$ = nodlit($1);
+ }
+| name
+| pexpr '.' sym
+ {
+ if $1.Op == OPACK {
+ var s *Sym
+ s = restrictlookup($3.Name, $1.Pkg);
+ $1.Used = 1;
+ $$ = oldname(s);
+ break;
+ }
+ $$ = Nod(OXDOT, $1, newname($3));
+ }
+| pexpr '.' '(' expr_or_type ')'
+ {
+ $$ = Nod(ODOTTYPE, $1, $4);
+ }
+| pexpr '.' '(' LTYPE ')'
+ {
+ $$ = Nod(OTYPESW, nil, $1);
+ }
+| pexpr '[' expr ']'
+ {
+ $$ = Nod(OINDEX, $1, $3);
+ }
+| pexpr '[' oexpr ':' oexpr ']'
+ {
+ $$ = Nod(OSLICE, $1, Nod(OKEY, $3, $5));
+ }
+| pexpr '[' oexpr ':' oexpr ':' oexpr ']'
+ {
+ if $5 == nil {
+ Yyerror("middle index required in 3-index slice");
+ }
+ if $7 == nil {
+ Yyerror("final index required in 3-index slice");
+ }
+ $$ = Nod(OSLICE3, $1, Nod(OKEY, $3, Nod(OKEY, $5, $7)));
+ }
+| pseudocall
+| convtype '(' expr ocomma ')'
+ {
+ // conversion
+ $$ = Nod(OCALL, $1, nil);
+ $$.List = list1($3);
+ }
+| comptype lbrace start_complit braced_keyval_list '}'
+ {
+ $$ = $3;
+ $$.Right = $1;
+ $$.List = $4;
+ fixlbrace($2);
+ }
+| pexpr_no_paren '{' start_complit braced_keyval_list '}'
+ {
+ $$ = $3;
+ $$.Right = $1;
+ $$.List = $4;
+ }
+| '(' expr_or_type ')' '{' start_complit braced_keyval_list '}'
+ {
+ Yyerror("cannot parenthesize type in composite literal");
+ $$ = $5;
+ $$.Right = $2;
+ $$.List = $6;
+ }
+| fnliteral
+
+start_complit:
+ {
+ // composite expression.
+ // make node early so we get the right line number.
+ $$ = Nod(OCOMPLIT, nil, nil);
+ }
+
+keyval:
+ expr ':' complitexpr
+ {
+ $$ = Nod(OKEY, $1, $3);
+ }
+
+bare_complitexpr:
+ expr
+ {
+ // These nodes do not carry line numbers.
+ // Since a composite literal commonly spans several lines,
+ // the line number on errors may be misleading.
+ // Introduce a wrapper node to give the correct line.
+ $$ = $1;
+ switch($$.Op) {
+ case ONAME, ONONAME, OTYPE, OPACK, OLITERAL:
+ $$ = Nod(OPAREN, $$, nil);
+ $$.Implicit = 1;
+ }
+ }
+| '{' start_complit braced_keyval_list '}'
+ {
+ $$ = $2;
+ $$.List = $3;
+ }
+
+complitexpr:
+ expr
+| '{' start_complit braced_keyval_list '}'
+ {
+ $$ = $2;
+ $$.List = $3;
+ }
+
+pexpr:
+ pexpr_no_paren
+| '(' expr_or_type ')'
+ {
+ $$ = $2;
+
+ // Need to know on lhs of := whether there are ( ).
+ // Don't bother with the OPAREN in other cases:
+ // it's just a waste of memory and time.
+ switch($$.Op) {
+ case ONAME, ONONAME, OPACK, OTYPE, OLITERAL, OTYPESW:
+ $$ = Nod(OPAREN, $$, nil);
+ }
+ }
+
+expr_or_type:
+ expr
+| non_expr_type %prec PreferToRightParen
+
+name_or_type:
+ ntype
+
+lbrace:
+ LBODY
+ {
+ $$ = LBODY;
+ }
+| '{'
+ {
+ $$ = '{';
+ }
+
+/*
+ * names and types
+ * newname is used before declared
+ * oldname is used after declared
+ */
+new_name:
+ sym
+ {
+ if $1 == nil {
+ $$ = nil;
+ } else {
+ $$ = newname($1);
+ }
+ }
+
+dcl_name:
+ sym
+ {
+ $$ = dclname($1);
+ }
+
+onew_name:
+ {
+ $$ = nil;
+ }
+| new_name
+
+sym:
+ LNAME
+ {
+ $$ = $1;
+ // during imports, unqualified non-exported identifiers are from builtinpkg
+ if importpkg != nil && !exportname($1.Name) {
+ $$ = Pkglookup($1.Name, builtinpkg);
+ }
+ }
+| hidden_importsym
+| '?'
+ {
+ $$ = nil;
+ }
+
+hidden_importsym:
+ '@' LLITERAL '.' LNAME
+ {
+ var p *Pkg
+
+ if $2.U.Sval.S == "" {
+ p = importpkg;
+ } else {
+ if isbadimport($2.U.Sval) {
+ errorexit();
+ }
+ p = mkpkg($2.U.Sval);
+ }
+ $$ = Pkglookup($4.Name, p);
+ }
+| '@' LLITERAL '.' '?'
+ {
+ var p *Pkg
+
+ if $2.U.Sval.S == "" {
+ p = importpkg;
+ } else {
+ if isbadimport($2.U.Sval) {
+ errorexit();
+ }
+ p = mkpkg($2.U.Sval);
+ }
+ $$ = Pkglookup("?", p);
+ }
+
+name:
+ sym %prec NotParen
+ {
+ $$ = oldname($1);
+ if $$.Pack != nil {
+ $$.Pack.Used = 1;
+ }
+ }
+
+labelname:
+ new_name
+
+/*
+ * to avoid parsing conflicts, type is split into
+ * channel types
+ * function types
+ * parenthesized types
+ * any other type
+ * the type system makes additional restrictions,
+ * but those are not implemented in the grammar.
+ */
+dotdotdot:
+ LDDD
+ {
+ Yyerror("final argument in variadic function missing type");
+ $$ = Nod(ODDD, typenod(typ(TINTER)), nil);
+ }
+| LDDD ntype
+ {
+ $$ = Nod(ODDD, $2, nil);
+ }
+
+ntype:
+ recvchantype
+| fntype
+| othertype
+| ptrtype
+| dotname
+| '(' ntype ')'
+ {
+ $$ = $2;
+ }
+
+non_expr_type:
+ recvchantype
+| fntype
+| othertype
+| '*' non_expr_type
+ {
+ $$ = Nod(OIND, $2, nil);
+ }
+
+non_recvchantype:
+ fntype
+| othertype
+| ptrtype
+| dotname
+| '(' ntype ')'
+ {
+ $$ = $2;
+ }
+
+convtype:
+ fntype
+| othertype
+
+comptype:
+ othertype
+
+fnret_type:
+ recvchantype
+| fntype
+| othertype
+| ptrtype
+| dotname
+
+dotname:
+ name
+| name '.' sym
+ {
+ if $1.Op == OPACK {
+ var s *Sym
+ s = restrictlookup($3.Name, $1.Pkg);
+ $1.Used = 1;
+ $$ = oldname(s);
+ break;
+ }
+ $$ = Nod(OXDOT, $1, newname($3));
+ }
+
+othertype:
+ '[' oexpr ']' ntype
+ {
+ $$ = Nod(OTARRAY, $2, $4);
+ }
+| '[' LDDD ']' ntype
+ {
+ // array literal of nelem
+ $$ = Nod(OTARRAY, Nod(ODDD, nil, nil), $4);
+ }
+| LCHAN non_recvchantype
+ {
+ $$ = Nod(OTCHAN, $2, nil);
+ $$.Etype = Cboth;
+ }
+| LCHAN LCOMM ntype
+ {
+ $$ = Nod(OTCHAN, $3, nil);
+ $$.Etype = Csend;
+ }
+| LMAP '[' ntype ']' ntype
+ {
+ $$ = Nod(OTMAP, $3, $5);
+ }
+| structtype
+| interfacetype
+
+ptrtype:
+ '*' ntype
+ {
+ $$ = Nod(OIND, $2, nil);
+ }
+
+recvchantype:
+ LCOMM LCHAN ntype
+ {
+ $$ = Nod(OTCHAN, $3, nil);
+ $$.Etype = Crecv;
+ }
+
+structtype:
+ LSTRUCT lbrace structdcl_list osemi '}'
+ {
+ $$ = Nod(OTSTRUCT, nil, nil);
+ $$.List = $3;
+ fixlbrace($2);
+ }
+| LSTRUCT lbrace '}'
+ {
+ $$ = Nod(OTSTRUCT, nil, nil);
+ fixlbrace($2);
+ }
+
+interfacetype:
+ LINTERFACE lbrace interfacedcl_list osemi '}'
+ {
+ $$ = Nod(OTINTER, nil, nil);
+ $$.List = $3;
+ fixlbrace($2);
+ }
+| LINTERFACE lbrace '}'
+ {
+ $$ = Nod(OTINTER, nil, nil);
+ fixlbrace($2);
+ }
+
+/*
+ * function stuff
+ * all in one place to show how crappy it all is
+ */
+xfndcl:
+ LFUNC fndcl fnbody
+ {
+ $$ = $2;
+ if $$ == nil {
+ break;
+ }
+ if noescape && $3 != nil {
+ Yyerror("can only use //go:noescape with external func implementations");
+ }
+ $$.Nbody = $3;
+ $$.Endlineno = lineno;
+ $$.Noescape = noescape;
+ $$.Nosplit = nosplit;
+ $$.Nowritebarrier = nowritebarrier;
+ funcbody($$);
+ }
+
+fndcl:
+ sym '(' oarg_type_list_ocomma ')' fnres
+ {
+ var t *Node
+
+ $$ = nil;
+ $3 = checkarglist($3, 1);
+
+ if $1.Name == "init" {
+ $1 = renameinit();
+ if $3 != nil || $5 != nil {
+ Yyerror("func init must have no arguments and no return values");
+ }
+ }
+ if localpkg.Name == "main" && $1.Name == "main" {
+ if $3 != nil || $5 != nil {
+ Yyerror("func main must have no arguments and no return values");
+ }
+ }
+
+ t = Nod(OTFUNC, nil, nil);
+ t.List = $3;
+ t.Rlist = $5;
+
+ $$ = Nod(ODCLFUNC, nil, nil);
+ $$.Nname = newname($1);
+ $$.Nname.Defn = $$;
+ $$.Nname.Ntype = t; // TODO: check if nname already has an ntype
+ declare($$.Nname, PFUNC);
+
+ funchdr($$);
+ }
+| '(' oarg_type_list_ocomma ')' sym '(' oarg_type_list_ocomma ')' fnres
+ {
+ var rcvr, t *Node
+
+ $$ = nil;
+ $2 = checkarglist($2, 0);
+ $6 = checkarglist($6, 1);
+
+ if $2 == nil {
+ Yyerror("method has no receiver");
+ break;
+ }
+ if $2.Next != nil {
+ Yyerror("method has multiple receivers");
+ break;
+ }
+ rcvr = $2.N;
+ if rcvr.Op != ODCLFIELD {
+ Yyerror("bad receiver in method");
+ break;
+ }
+
+ t = Nod(OTFUNC, rcvr, nil);
+ t.List = $6;
+ t.Rlist = $8;
+
+ $$ = Nod(ODCLFUNC, nil, nil);
+ $$.Shortname = newname($4);
+ $$.Nname = methodname1($$.Shortname, rcvr.Right);
+ $$.Nname.Defn = $$;
+ $$.Nname.Ntype = t;
+ $$.Nname.Nointerface = nointerface;
+ declare($$.Nname, PFUNC);
+
+ funchdr($$);
+ }
+
+hidden_fndcl:
+ hidden_pkg_importsym '(' ohidden_funarg_list ')' ohidden_funres
+ {
+ var s *Sym
+ var t *Type
+
+ $$ = nil;
+
+ s = $1;
+ t = functype(nil, $3, $5);
+
+ importsym(s, ONAME);
+ if s.Def != nil && s.Def.Op == ONAME {
+ if Eqtype(t, s.Def.Type) {
+ dclcontext = PDISCARD; // since we skip funchdr below
+ break;
+ }
+ Yyerror("inconsistent definition for func %v during import\n\t%v\n\t%v", Sconv(s, 0), Tconv(s.Def.Type, 0), Tconv(t, 0));
+ }
+
+ $$ = newname(s);
+ $$.Type = t;
+ declare($$, PFUNC);
+
+ funchdr($$);
+ }
+| '(' hidden_funarg_list ')' sym '(' ohidden_funarg_list ')' ohidden_funres
+ {
+ $$ = methodname1(newname($4), $2.N.Right);
+ $$.Type = functype($2.N, $6, $8);
+
+ checkwidth($$.Type);
+ addmethod($4, $$.Type, false, nointerface);
+ nointerface = false
+ funchdr($$);
+
+ // inl.C's inlnode in on a dotmeth node expects to find the inlineable body as
+ // (dotmeth's type).Nname.Inl, and dotmeth's type has been pulled
+ // out by typecheck's lookdot as this $$.ttype. So by providing
+ // this back link here we avoid special casing there.
+ $$.Type.Nname = $$;
+ }
+
+fntype:
+ LFUNC '(' oarg_type_list_ocomma ')' fnres
+ {
+ $3 = checkarglist($3, 1);
+ $$ = Nod(OTFUNC, nil, nil);
+ $$.List = $3;
+ $$.Rlist = $5;
+ }
+
+fnbody:
+ {
+ $$ = nil;
+ }
+| '{' stmt_list '}'
+ {
+ $$ = $2;
+ if $$ == nil {
+ $$ = list1(Nod(OEMPTY, nil, nil));
+ }
+ }
+
+fnres:
+ %prec NotParen
+ {
+ $$ = nil;
+ }
+| fnret_type
+ {
+ $$ = list1(Nod(ODCLFIELD, nil, $1));
+ }
+| '(' oarg_type_list_ocomma ')'
+ {
+ $2 = checkarglist($2, 0);
+ $$ = $2;
+ }
+
+fnlitdcl:
+ fntype
+ {
+ closurehdr($1);
+ }
+
+fnliteral:
+ fnlitdcl lbrace stmt_list '}'
+ {
+ $$ = closurebody($3);
+ fixlbrace($2);
+ }
+| fnlitdcl error
+ {
+ $$ = closurebody(nil);
+ }
+
+/*
+ * lists of things
+ * note that they are left recursive
+ * to conserve yacc stack. they need to
+ * be reversed to interpret correctly
+ */
+xdcl_list:
+ {
+ $$ = nil;
+ }
+| xdcl_list xdcl ';'
+ {
+ $$ = concat($1, $2);
+ if nsyntaxerrors == 0 {
+ testdclstack();
+ }
+ nointerface = false
+ noescape = false
+ nosplit = false
+ nowritebarrier = false
+ }
+
+vardcl_list:
+ vardcl
+| vardcl_list ';' vardcl
+ {
+ $$ = concat($1, $3);
+ }
+
+constdcl_list:
+ constdcl1
+| constdcl_list ';' constdcl1
+ {
+ $$ = concat($1, $3);
+ }
+
+typedcl_list:
+ typedcl
+ {
+ $$ = list1($1);
+ }
+| typedcl_list ';' typedcl
+ {
+ $$ = list($1, $3);
+ }
+
+structdcl_list:
+ structdcl
+| structdcl_list ';' structdcl
+ {
+ $$ = concat($1, $3);
+ }
+
+interfacedcl_list:
+ interfacedcl
+ {
+ $$ = list1($1);
+ }
+| interfacedcl_list ';' interfacedcl
+ {
+ $$ = list($1, $3);
+ }
+
+structdcl:
+ new_name_list ntype oliteral
+ {
+ var l *NodeList
+
+ var n *Node
+ l = $1;
+ if l == nil {
+ // ? symbol, during import (list1(nil) == nil)
+ n = $2;
+ if n.Op == OIND {
+ n = n.Left;
+ }
+ n = embedded(n.Sym, importpkg);
+ n.Right = $2;
+ n.Val = $3;
+ $$ = list1(n);
+ break;
+ }
+
+ for l=$1; l != nil; l=l.Next {
+ l.N = Nod(ODCLFIELD, l.N, $2);
+ l.N.Val = $3;
+ }
+ }
+| embed oliteral
+ {
+ $1.Val = $2;
+ $$ = list1($1);
+ }
+| '(' embed ')' oliteral
+ {
+ $2.Val = $4;
+ $$ = list1($2);
+ Yyerror("cannot parenthesize embedded type");
+ }
+| '*' embed oliteral
+ {
+ $2.Right = Nod(OIND, $2.Right, nil);
+ $2.Val = $3;
+ $$ = list1($2);
+ }
+| '(' '*' embed ')' oliteral
+ {
+ $3.Right = Nod(OIND, $3.Right, nil);
+ $3.Val = $5;
+ $$ = list1($3);
+ Yyerror("cannot parenthesize embedded type");
+ }
+| '*' '(' embed ')' oliteral
+ {
+ $3.Right = Nod(OIND, $3.Right, nil);
+ $3.Val = $5;
+ $$ = list1($3);
+ Yyerror("cannot parenthesize embedded type");
+ }
+
+packname:
+ LNAME
+ {
+ var n *Node
+
+ $$ = $1;
+ n = oldname($1);
+ if n.Pack != nil {
+ n.Pack.Used = 1;
+ }
+ }
+| LNAME '.' sym
+ {
+ var pkg *Pkg
+
+ if $1.Def == nil || $1.Def.Op != OPACK {
+ Yyerror("%v is not a package", Sconv($1, 0));
+ pkg = localpkg;
+ } else {
+ $1.Def.Used = 1;
+ pkg = $1.Def.Pkg;
+ }
+ $$ = restrictlookup($3.Name, pkg);
+ }
+
+embed:
+ packname
+ {
+ $$ = embedded($1, localpkg);
+ }
+
+interfacedcl:
+ new_name indcl
+ {
+ $$ = Nod(ODCLFIELD, $1, $2);
+ ifacedcl($$);
+ }
+| packname
+ {
+ $$ = Nod(ODCLFIELD, nil, oldname($1));
+ }
+| '(' packname ')'
+ {
+ $$ = Nod(ODCLFIELD, nil, oldname($2));
+ Yyerror("cannot parenthesize embedded type");
+ }
+
+indcl:
+ '(' oarg_type_list_ocomma ')' fnres
+ {
+ // without func keyword
+ $2 = checkarglist($2, 1);
+ $$ = Nod(OTFUNC, fakethis(), nil);
+ $$.List = $2;
+ $$.Rlist = $4;
+ }
+
+/*
+ * function arguments.
+ */
+arg_type:
+ name_or_type
+| sym name_or_type
+ {
+ $$ = Nod(ONONAME, nil, nil);
+ $$.Sym = $1;
+ $$ = Nod(OKEY, $$, $2);
+ }
+| sym dotdotdot
+ {
+ $$ = Nod(ONONAME, nil, nil);
+ $$.Sym = $1;
+ $$ = Nod(OKEY, $$, $2);
+ }
+| dotdotdot
+
+arg_type_list:
+ arg_type
+ {
+ $$ = list1($1);
+ }
+| arg_type_list ',' arg_type
+ {
+ $$ = list($1, $3);
+ }
+
+oarg_type_list_ocomma:
+ {
+ $$ = nil;
+ }
+| arg_type_list ocomma
+ {
+ $$ = $1;
+ }
+
+/*
+ * statement
+ */
+stmt:
+ {
+ $$ = nil;
+ }
+| compound_stmt
+| common_dcl
+ {
+ $$ = liststmt($1);
+ }
+| non_dcl_stmt
+| error
+ {
+ $$ = nil;
+ }
+
+non_dcl_stmt:
+ simple_stmt
+| for_stmt
+| switch_stmt
+| select_stmt
+| if_stmt
+| labelname ':'
+ {
+ $1 = Nod(OLABEL, $1, nil);
+ $1.Sym = dclstack; // context, for goto restrictions
+ }
+ stmt
+ {
+ var l *NodeList
+
+ $1.Defn = $4;
+ l = list1($1);
+ if $4 != nil {
+ l = list(l, $4);
+ }
+ $$ = liststmt(l);
+ }
+| LFALL
+ {
+ // will be converted to OFALL
+ $$ = Nod(OXFALL, nil, nil);
+ $$.Xoffset = int64(block);
+ }
+| LBREAK onew_name
+ {
+ $$ = Nod(OBREAK, $2, nil);
+ }
+| LCONTINUE onew_name
+ {
+ $$ = Nod(OCONTINUE, $2, nil);
+ }
+| LGO pseudocall
+ {
+ $$ = Nod(OPROC, $2, nil);
+ }
+| LDEFER pseudocall
+ {
+ $$ = Nod(ODEFER, $2, nil);
+ }
+| LGOTO new_name
+ {
+ $$ = Nod(OGOTO, $2, nil);
+ $$.Sym = dclstack; // context, for goto restrictions
+ }
+| LRETURN oexpr_list
+ {
+ $$ = Nod(ORETURN, nil, nil);
+ $$.List = $2;
+ if $$.List == nil && Curfn != nil {
+ var l *NodeList
+
+ for l=Curfn.Dcl; l != nil; l=l.Next {
+ if l.N.Class == PPARAM {
+ continue;
+ }
+ if l.N.Class != PPARAMOUT {
+ break;
+ }
+ if l.N.Sym.Def != l.N {
+ Yyerror("%s is shadowed during return", l.N.Sym.Name);
+ }
+ }
+ }
+ }
+
+stmt_list:
+ stmt
+ {
+ $$ = nil;
+ if $1 != nil {
+ $$ = list1($1);
+ }
+ }
+| stmt_list ';' stmt
+ {
+ $$ = $1;
+ if $3 != nil {
+ $$ = list($$, $3);
+ }
+ }
+
+new_name_list:
+ new_name
+ {
+ $$ = list1($1);
+ }
+| new_name_list ',' new_name
+ {
+ $$ = list($1, $3);
+ }
+
+dcl_name_list:
+ dcl_name
+ {
+ $$ = list1($1);
+ }
+| dcl_name_list ',' dcl_name
+ {
+ $$ = list($1, $3);
+ }
+
+expr_list:
+ expr
+ {
+ $$ = list1($1);
+ }
+| expr_list ',' expr
+ {
+ $$ = list($1, $3);
+ }
+
+expr_or_type_list:
+ expr_or_type
+ {
+ $$ = list1($1);
+ }
+| expr_or_type_list ',' expr_or_type
+ {
+ $$ = list($1, $3);
+ }
+
+/*
+ * list of combo of keyval and val
+ */
+keyval_list:
+ keyval
+ {
+ $$ = list1($1);
+ }
+| bare_complitexpr
+ {
+ $$ = list1($1);
+ }
+| keyval_list ',' keyval
+ {
+ $$ = list($1, $3);
+ }
+| keyval_list ',' bare_complitexpr
+ {
+ $$ = list($1, $3);
+ }
+
+braced_keyval_list:
+ {
+ $$ = nil;
+ }
+| keyval_list ocomma
+ {
+ $$ = $1;
+ }
+
+/*
+ * optional things
+ */
+osemi:
+| ';'
+
+ocomma:
+| ','
+
+oexpr:
+ {
+ $$ = nil;
+ }
+| expr
+
+oexpr_list:
+ {
+ $$ = nil;
+ }
+| expr_list
+
+osimple_stmt:
+ {
+ $$ = nil;
+ }
+| simple_stmt
+
+ohidden_funarg_list:
+ {
+ $$ = nil;
+ }
+| hidden_funarg_list
+
+ohidden_structdcl_list:
+ {
+ $$ = nil;
+ }
+| hidden_structdcl_list
+
+ohidden_interfacedcl_list:
+ {
+ $$ = nil;
+ }
+| hidden_interfacedcl_list
+
+oliteral:
+ {
+ $$.Ctype = CTxxx;
+ }
+| LLITERAL
+
+/*
+ * import syntax from package header
+ */
+hidden_import:
+ LIMPORT LNAME LLITERAL ';'
+ {
+ importimport($2, $3.U.Sval);
+ }
+| LVAR hidden_pkg_importsym hidden_type ';'
+ {
+ importvar($2, $3);
+ }
+| LCONST hidden_pkg_importsym '=' hidden_constant ';'
+ {
+ importconst($2, Types[TIDEAL], $4);
+ }
+| LCONST hidden_pkg_importsym hidden_type '=' hidden_constant ';'
+ {
+ importconst($2, $3, $5);
+ }
+| LTYPE hidden_pkgtype hidden_type ';'
+ {
+ importtype($2, $3);
+ }
+| LFUNC hidden_fndcl fnbody ';'
+ {
+ if $2 == nil {
+ dclcontext = PEXTERN; // since we skip the funcbody below
+ break;
+ }
+
+ $2.Inl = $3;
+
+ funcbody($2);
+ importlist = list(importlist, $2);
+
+ if Debug['E'] > 0 {
+ print("import [%v] func %lN \n", Zconv(importpkg.Path, 0), $2);
+ if Debug['m'] > 2 && $2.Inl != nil {
+ print("inl body:%+H\n", $2.Inl);
+ }
+ }
+ }
+
+hidden_pkg_importsym:
+ hidden_importsym
+ {
+ $$ = $1;
+ structpkg = $$.Pkg;
+ }
+
+hidden_pkgtype:
+ hidden_pkg_importsym
+ {
+ $$ = pkgtype($1);
+ importsym($1, OTYPE);
+ }
+
+/*
+ * importing types
+ */
+
+hidden_type:
+ hidden_type_misc
+| hidden_type_recv_chan
+| hidden_type_func
+
+hidden_type_non_recv_chan:
+ hidden_type_misc
+| hidden_type_func
+
+hidden_type_misc:
+ hidden_importsym
+ {
+ $$ = pkgtype($1);
+ }
+| LNAME
+ {
+ // predefined name like uint8
+ $1 = Pkglookup($1.Name, builtinpkg);
+ if $1.Def == nil || $1.Def.Op != OTYPE {
+ Yyerror("%s is not a type", $1.Name);
+ $$ = nil;
+ } else {
+ $$ = $1.Def.Type;
+ }
+ }
+| '[' ']' hidden_type
+ {
+ $$ = aindex(nil, $3);
+ }
+| '[' LLITERAL ']' hidden_type
+ {
+ $$ = aindex(nodlit($2), $4);
+ }
+| LMAP '[' hidden_type ']' hidden_type
+ {
+ $$ = maptype($3, $5);
+ }
+| LSTRUCT '{' ohidden_structdcl_list '}'
+ {
+ $$ = tostruct($3);
+ }
+| LINTERFACE '{' ohidden_interfacedcl_list '}'
+ {
+ $$ = tointerface($3);
+ }
+| '*' hidden_type
+ {
+ $$ = Ptrto($2);
+ }
+| LCHAN hidden_type_non_recv_chan
+ {
+ $$ = typ(TCHAN);
+ $$.Type = $2;
+ $$.Chan = Cboth;
+ }
+| LCHAN '(' hidden_type_recv_chan ')'
+ {
+ $$ = typ(TCHAN);
+ $$.Type = $3;
+ $$.Chan = Cboth;
+ }
+| LCHAN LCOMM hidden_type
+ {
+ $$ = typ(TCHAN);
+ $$.Type = $3;
+ $$.Chan = Csend;
+ }
+
+hidden_type_recv_chan:
+ LCOMM LCHAN hidden_type
+ {
+ $$ = typ(TCHAN);
+ $$.Type = $3;
+ $$.Chan = Crecv;
+ }
+
+hidden_type_func:
+ LFUNC '(' ohidden_funarg_list ')' ohidden_funres
+ {
+ $$ = functype(nil, $3, $5);
+ }
+
+hidden_funarg:
+ sym hidden_type oliteral
+ {
+ $$ = Nod(ODCLFIELD, nil, typenod($2));
+ if $1 != nil {
+ $$.Left = newname($1);
+ }
+ $$.Val = $3;
+ }
+| sym LDDD hidden_type oliteral
+ {
+ var t *Type
+
+ t = typ(TARRAY);
+ t.Bound = -1;
+ t.Type = $3;
+
+ $$ = Nod(ODCLFIELD, nil, typenod(t));
+ if $1 != nil {
+ $$.Left = newname($1);
+ }
+ $$.Isddd = 1;
+ $$.Val = $4;
+ }
+
+hidden_structdcl:
+ sym hidden_type oliteral
+ {
+ var s *Sym
+ var p *Pkg
+
+ if $1 != nil && $1.Name != "?" {
+ $$ = Nod(ODCLFIELD, newname($1), typenod($2));
+ $$.Val = $3;
+ } else {
+ s = $2.Sym;
+ if s == nil && Isptr[$2.Etype] != 0 {
+ s = $2.Type.Sym;
+ }
+ p = importpkg;
+ if $1 != nil {
+ p = $1.Pkg;
+ }
+ $$ = embedded(s, p);
+ $$.Right = typenod($2);
+ $$.Val = $3;
+ }
+ }
+
+hidden_interfacedcl:
+ sym '(' ohidden_funarg_list ')' ohidden_funres
+ {
+ $$ = Nod(ODCLFIELD, newname($1), typenod(functype(fakethis(), $3, $5)));
+ }
+| hidden_type
+ {
+ $$ = Nod(ODCLFIELD, nil, typenod($1));
+ }
+
+ohidden_funres:
+ {
+ $$ = nil;
+ }
+| hidden_funres
+
+hidden_funres:
+ '(' ohidden_funarg_list ')'
+ {
+ $$ = $2;
+ }
+| hidden_type
+ {
+ $$ = list1(Nod(ODCLFIELD, nil, typenod($1)));
+ }
+
+/*
+ * importing constants
+ */
+
+hidden_literal:
+ LLITERAL
+ {
+ $$ = nodlit($1);
+ }
+| '-' LLITERAL
+ {
+ $$ = nodlit($2);
+ switch($$.Val.Ctype){
+ case CTINT, CTRUNE:
+ mpnegfix($$.Val.U.Xval);
+ break;
+ case CTFLT:
+ mpnegflt($$.Val.U.Fval);
+ break;
+ case CTCPLX:
+ mpnegflt(&$$.Val.U.Cval.Real);
+ mpnegflt(&$$.Val.U.Cval.Imag);
+ break;
+ default:
+ Yyerror("bad negated constant");
+ }
+ }
+| sym
+ {
+ $$ = oldname(Pkglookup($1.Name, builtinpkg));
+ if $$.Op != OLITERAL {
+ Yyerror("bad constant %v", Sconv($$.Sym, 0));
+ }
+ }
+
+hidden_constant:
+ hidden_literal
+| '(' hidden_literal '+' hidden_literal ')'
+ {
+ if $2.Val.Ctype == CTRUNE && $4.Val.Ctype == CTINT {
+ $$ = $2;
+ mpaddfixfix($2.Val.U.Xval, $4.Val.U.Xval, 0);
+ break;
+ }
+ $4.Val.U.Cval.Real = $4.Val.U.Cval.Imag;
+ Mpmovecflt(&$4.Val.U.Cval.Imag, 0.0);
+ $$ = nodcplxlit($2.Val, $4.Val);
+ }
+
+hidden_import_list:
+| hidden_import_list hidden_import
+
+hidden_funarg_list:
+ hidden_funarg
+ {
+ $$ = list1($1);
+ }
+| hidden_funarg_list ',' hidden_funarg
+ {
+ $$ = list($1, $3);
+ }
+
+hidden_structdcl_list:
+ hidden_structdcl
+ {
+ $$ = list1($1);
+ }
+| hidden_structdcl_list ';' hidden_structdcl
+ {
+ $$ = list($1, $3);
+ }
+
+hidden_interfacedcl_list:
+ hidden_interfacedcl
+ {
+ $$ = list1($1);
+ }
+| hidden_interfacedcl_list ';' hidden_interfacedcl
+ {
+ $$ = list($1, $3);
+ }
+
+%%
+
+func fixlbrace(lbr int) {
+ // If the opening brace was an LBODY,
+ // set up for another one now that we're done.
+ // See comment in lex.C about loophack.
+ if lbr == LBODY {
+ loophack = 1
+ }
+}
+
diff --git a/src/cmd/internal/gc/gsubr.go b/src/cmd/internal/gc/gsubr.go
new file mode 100644
index 0000000..6762171
--- /dev/null
+++ b/src/cmd/internal/gc/gsubr.go
@@ -0,0 +1,617 @@
+// Derived from Inferno utils/6c/txt.c
+// http://code.google.com/p/inferno-os/source/browse/utils/6c/txt.c
+//
+// Copyright © 1994-1999 Lucent Technologies Inc. All rights reserved.
+// Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+// Portions Copyright © 1997-1999 Vita Nuova Limited
+// Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
+// Portions Copyright © 2004,2006 Bruce Ellis
+// Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+// Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
+// Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package gc
+
+import "cmd/internal/obj"
+
+var ddumped int
+
+var dfirst *obj.Prog
+
+var dpc *obj.Prog
+
+/*
+ * Is this node a memory operand?
+ */
+func Ismem(n *Node) int {
+ switch n.Op {
+ case OITAB,
+ OSPTR,
+ OLEN,
+ OCAP,
+ OINDREG,
+ ONAME,
+ OPARAM,
+ OCLOSUREVAR:
+ return 1
+
+ case OADDR:
+ return bool2int(Thearch.Thechar == '6' || Thearch.Thechar == '9') // because 6g uses PC-relative addressing; TODO(rsc): not sure why 9g too
+ }
+
+ return 0
+}
+
+func Samereg(a *Node, b *Node) int {
+ if a == nil || b == nil {
+ return 0
+ }
+ if a.Op != OREGISTER {
+ return 0
+ }
+ if b.Op != OREGISTER {
+ return 0
+ }
+ if a.Val.U.Reg != b.Val.U.Reg {
+ return 0
+ }
+ return 1
+}
+
+/*
+ * gsubr.c
+ */
+func Gbranch(as int, t *Type, likely int) *obj.Prog {
+ var p *obj.Prog
+
+ p = Prog(as)
+ p.To.Type = obj.TYPE_BRANCH
+ p.To.U.Branch = nil
+ if as != obj.AJMP && likely != 0 && Thearch.Thechar != '9' {
+ p.From.Type = obj.TYPE_CONST
+ p.From.Offset = int64(bool2int(likely > 0))
+ }
+
+ return p
+}
+
+func Prog(as int) *obj.Prog {
+ var p *obj.Prog
+
+ if as == obj.ADATA || as == obj.AGLOBL {
+ if ddumped != 0 {
+ Fatal("already dumped data")
+ }
+ if dpc == nil {
+ dpc = Ctxt.NewProg()
+ dfirst = dpc
+ }
+
+ p = dpc
+ dpc = Ctxt.NewProg()
+ p.Link = dpc
+ } else {
+ p = Pc
+ Pc = Ctxt.NewProg()
+ Clearp(Pc)
+ p.Link = Pc
+ }
+
+ if lineno == 0 {
+ if Debug['K'] != 0 {
+ Warn("prog: line 0")
+ }
+ }
+
+ p.As = int16(as)
+ p.Lineno = lineno
+ return p
+}
+
+func Nodreg(n *Node, t *Type, r int) {
+ if t == nil {
+ Fatal("nodreg: t nil")
+ }
+
+ *n = Node{}
+ n.Op = OREGISTER
+ n.Addable = 1
+ ullmancalc(n)
+ n.Val.U.Reg = int16(r)
+ n.Type = t
+}
+
+func Nodindreg(n *Node, t *Type, r int) {
+ Nodreg(n, t, r)
+ n.Op = OINDREG
+}
+
+func Afunclit(a *obj.Addr, n *Node) {
+ if a.Type == obj.TYPE_ADDR && a.Name == obj.NAME_EXTERN {
+ a.Type = obj.TYPE_MEM
+ a.Sym = Linksym(n.Sym)
+ }
+}
+
+func Clearp(p *obj.Prog) {
+ obj.Nopout(p)
+ p.As = obj.AEND
+ p.Pc = int64(pcloc)
+ pcloc++
+}
+
+func dumpdata() {
+ ddumped = 1
+ if dfirst == nil {
+ return
+ }
+ newplist()
+ *Pc = *dfirst
+ Pc = dpc
+ Clearp(Pc)
+}
+
+func fixautoused(p *obj.Prog) {
+ var lp **obj.Prog
+
+ for lp = &p; ; {
+ p = *lp
+ if !(p != nil) {
+ break
+ }
+ if p.As == obj.ATYPE && p.From.Node != nil && p.From.Name == obj.NAME_AUTO && !(((p.From.Node).(*Node)).Used != 0) {
+ *lp = p.Link
+ continue
+ }
+
+ if (p.As == obj.AVARDEF || p.As == obj.AVARKILL) && p.To.Node != nil && !(((p.To.Node).(*Node)).Used != 0) {
+ // Cannot remove VARDEF instruction, because - unlike TYPE handled above -
+ // VARDEFs are interspersed with other code, and a jump might be using the
+ // VARDEF as a target. Replace with a no-op instead. A later pass will remove
+ // the no-ops.
+ obj.Nopout(p)
+
+ continue
+ }
+
+ if p.From.Name == obj.NAME_AUTO && p.From.Node != nil {
+ p.From.Offset += ((p.From.Node).(*Node)).Stkdelta
+ }
+
+ if p.To.Name == obj.NAME_AUTO && p.To.Node != nil {
+ p.To.Offset += ((p.To.Node).(*Node)).Stkdelta
+ }
+
+ lp = &p.Link
+ }
+}
+
+func ggloblnod(nam *Node) {
+ var p *obj.Prog
+
+ p = Thearch.Gins(obj.AGLOBL, nam, nil)
+ p.Lineno = nam.Lineno
+ p.From.Sym.Gotype = Linksym(ngotype(nam))
+ p.To.Sym = nil
+ p.To.Type = obj.TYPE_CONST
+ p.To.Offset = nam.Type.Width
+ if nam.Readonly != 0 {
+ p.From3.Offset = obj.RODATA
+ }
+ if nam.Type != nil && !haspointers(nam.Type) {
+ p.From3.Offset |= obj.NOPTR
+ }
+}
+
+func ggloblsym(s *Sym, width int32, flags int8) {
+ var p *obj.Prog
+
+ p = Thearch.Gins(obj.AGLOBL, nil, nil)
+ p.From.Type = obj.TYPE_MEM
+ p.From.Name = obj.NAME_EXTERN
+ p.From.Sym = Linksym(s)
+ p.To.Type = obj.TYPE_CONST
+ p.To.Offset = int64(width)
+ p.From3.Offset = int64(flags)
+}
+
+func gjmp(to *obj.Prog) *obj.Prog {
+ var p *obj.Prog
+
+ p = Gbranch(obj.AJMP, nil, 0)
+ if to != nil {
+ Patch(p, to)
+ }
+ return p
+}
+
+func gtrack(s *Sym) {
+ var p *obj.Prog
+
+ p = Thearch.Gins(obj.AUSEFIELD, nil, nil)
+ p.From.Type = obj.TYPE_MEM
+ p.From.Name = obj.NAME_EXTERN
+ p.From.Sym = Linksym(s)
+}
+
+func gused(n *Node) {
+ Thearch.Gins(obj.ANOP, n, nil) // used
+}
+
+func Isfat(t *Type) int {
+ if t != nil {
+ switch t.Etype {
+ case TSTRUCT,
+ TARRAY,
+ TSTRING,
+ TINTER: // maybe remove later
+ return 1
+ }
+ }
+
+ return 0
+}
+
+func markautoused(p *obj.Prog) {
+ for ; p != nil; p = p.Link {
+ if p.As == obj.ATYPE || p.As == obj.AVARDEF || p.As == obj.AVARKILL {
+ continue
+ }
+
+ if p.From.Node != nil {
+ ((p.From.Node).(*Node)).Used = 1
+ }
+
+ if p.To.Node != nil {
+ ((p.To.Node).(*Node)).Used = 1
+ }
+ }
+}
+
+func Naddr(n *Node, a *obj.Addr, canemitcode int) {
+ var s *Sym
+
+ *a = obj.Zprog.From
+ if n == nil {
+ return
+ }
+
+ if n.Type != nil && n.Type.Etype != TIDEAL {
+ // TODO(rsc): This is undone by the selective clearing of width below,
+ // to match architectures that were not as aggressive in setting width
+ // during naddr. Those widths must be cleared to avoid triggering
+ // failures in gins when it detects real but heretofore latent (and one
+ // hopes innocuous) type mismatches.
+ // The type mismatches should be fixed and the clearing below removed.
+ dowidth(n.Type)
+
+ a.Width = n.Type.Width
+ }
+
+ switch n.Op {
+ default:
+ Fatal("naddr: bad %v %v", Oconv(int(n.Op), 0), Ctxt.Dconv(a))
+
+ case OREGISTER:
+ a.Type = obj.TYPE_REG
+ a.Reg = n.Val.U.Reg
+ a.Sym = nil
+ if Thearch.Thechar == '8' { // TODO(rsc): Never clear a->width.
+ a.Width = 0
+ }
+
+ case OINDREG:
+ a.Type = obj.TYPE_MEM
+ a.Reg = n.Val.U.Reg
+ a.Sym = Linksym(n.Sym)
+ a.Offset = n.Xoffset
+ if a.Offset != int64(int32(a.Offset)) {
+ Yyerror("offset %d too large for OINDREG", a.Offset)
+ }
+ if Thearch.Thechar == '8' { // TODO(rsc): Never clear a->width.
+ a.Width = 0
+ }
+
+ // n->left is PHEAP ONAME for stack parameter.
+ // compute address of actual parameter on stack.
+ case OPARAM:
+ a.Etype = Simtype[n.Left.Type.Etype]
+
+ a.Width = n.Left.Type.Width
+ a.Offset = n.Xoffset
+ a.Sym = Linksym(n.Left.Sym)
+ a.Type = obj.TYPE_MEM
+ a.Name = obj.NAME_PARAM
+ a.Node = n.Left.Orig
+
+ case OCLOSUREVAR:
+ if !(Curfn.Needctxt != 0) {
+ Fatal("closurevar without needctxt")
+ }
+ a.Type = obj.TYPE_MEM
+ a.Reg = int16(Thearch.REGCTXT)
+ a.Sym = nil
+ a.Offset = n.Xoffset
+
+ case OCFUNC:
+ Naddr(n.Left, a, canemitcode)
+ a.Sym = Linksym(n.Left.Sym)
+
+ case ONAME:
+ a.Etype = 0
+ if n.Type != nil {
+ a.Etype = Simtype[n.Type.Etype]
+ }
+ a.Offset = n.Xoffset
+ s = n.Sym
+ a.Node = n.Orig
+
+ //if(a->node >= (Node*)&n)
+ // fatal("stack node");
+ if s == nil {
+ s = Lookup(".noname")
+ }
+ if n.Method != 0 {
+ if n.Type != nil {
+ if n.Type.Sym != nil {
+ if n.Type.Sym.Pkg != nil {
+ s = Pkglookup(s.Name, n.Type.Sym.Pkg)
+ }
+ }
+ }
+ }
+
+ a.Type = obj.TYPE_MEM
+ switch n.Class {
+ default:
+ Fatal("naddr: ONAME class %v %d\n", Sconv(n.Sym, 0), n.Class)
+ fallthrough
+
+ case PEXTERN:
+ a.Name = obj.NAME_EXTERN
+
+ case PAUTO:
+ a.Name = obj.NAME_AUTO
+
+ case PPARAM,
+ PPARAMOUT:
+ a.Name = obj.NAME_PARAM
+
+ case PFUNC:
+ a.Name = obj.NAME_EXTERN
+ a.Type = obj.TYPE_ADDR
+ a.Width = int64(Widthptr)
+ s = funcsym(s)
+ }
+
+ a.Sym = Linksym(s)
+
+ case OLITERAL:
+ if Thearch.Thechar == '8' {
+ a.Width = 0
+ }
+ switch n.Val.Ctype {
+ default:
+ Fatal("naddr: const %v", Tconv(n.Type, obj.FmtLong))
+
+ case CTFLT:
+ a.Type = obj.TYPE_FCONST
+ a.U.Dval = mpgetflt(n.Val.U.Fval)
+
+ case CTINT,
+ CTRUNE:
+ a.Sym = nil
+ a.Type = obj.TYPE_CONST
+ a.Offset = Mpgetfix(n.Val.U.Xval)
+
+ case CTSTR:
+ datagostring(n.Val.U.Sval, a)
+
+ case CTBOOL:
+ a.Sym = nil
+ a.Type = obj.TYPE_CONST
+ a.Offset = int64(n.Val.U.Bval)
+
+ case CTNIL:
+ a.Sym = nil
+ a.Type = obj.TYPE_CONST
+ a.Offset = 0
+ }
+
+ case OADDR:
+ Naddr(n.Left, a, canemitcode)
+ a.Etype = uint8(Tptr)
+ if Thearch.Thechar != '5' && Thearch.Thechar != '9' { // TODO(rsc): Do this even for arm, ppc64.
+ a.Width = int64(Widthptr)
+ }
+ if a.Type != obj.TYPE_MEM {
+ Fatal("naddr: OADDR %v (from %v)", Ctxt.Dconv(a), Oconv(int(n.Left.Op), 0))
+ }
+ a.Type = obj.TYPE_ADDR
+
+ // itable of interface value
+ case OITAB:
+ Naddr(n.Left, a, canemitcode)
+
+ if a.Type == obj.TYPE_CONST && a.Offset == 0 {
+ break // itab(nil)
+ }
+ a.Etype = uint8(Tptr)
+ a.Width = int64(Widthptr)
+
+ // pointer in a string or slice
+ case OSPTR:
+ Naddr(n.Left, a, canemitcode)
+
+ if a.Type == obj.TYPE_CONST && a.Offset == 0 {
+ break // ptr(nil)
+ }
+ a.Etype = Simtype[Tptr]
+ a.Offset += int64(Array_array)
+ a.Width = int64(Widthptr)
+
+ // len of string or slice
+ case OLEN:
+ Naddr(n.Left, a, canemitcode)
+
+ if a.Type == obj.TYPE_CONST && a.Offset == 0 {
+ break // len(nil)
+ }
+ a.Etype = Simtype[TUINT]
+ if Thearch.Thechar == '9' {
+ a.Etype = Simtype[TINT]
+ }
+ a.Offset += int64(Array_nel)
+ if Thearch.Thechar != '5' { // TODO(rsc): Do this even on arm.
+ a.Width = int64(Widthint)
+ }
+
+ // cap of string or slice
+ case OCAP:
+ Naddr(n.Left, a, canemitcode)
+
+ if a.Type == obj.TYPE_CONST && a.Offset == 0 {
+ break // cap(nil)
+ }
+ a.Etype = Simtype[TUINT]
+ if Thearch.Thechar == '9' {
+ a.Etype = Simtype[TINT]
+ }
+ a.Offset += int64(Array_cap)
+ if Thearch.Thechar != '5' { // TODO(rsc): Do this even on arm.
+ a.Width = int64(Widthint)
+ }
+ }
+}
+
+func newplist() *obj.Plist {
+ var pl *obj.Plist
+
+ pl = obj.Linknewplist(Ctxt)
+
+ Pc = Ctxt.NewProg()
+ Clearp(Pc)
+ pl.Firstpc = Pc
+
+ return pl
+}
+
+func nodarg(t *Type, fp int) *Node {
+ var n *Node
+ var l *NodeList
+ var first *Type
+ var savet Iter
+
+ // entire argument struct, not just one arg
+ if t.Etype == TSTRUCT && t.Funarg != 0 {
+ n = Nod(ONAME, nil, nil)
+ n.Sym = Lookup(".args")
+ n.Type = t
+ first = Structfirst(&savet, &t)
+ if first == nil {
+ Fatal("nodarg: bad struct")
+ }
+ if first.Width == BADWIDTH {
+ Fatal("nodarg: offset not computed for %v", Tconv(t, 0))
+ }
+ n.Xoffset = first.Width
+ n.Addable = 1
+ goto fp
+ }
+
+ if t.Etype != TFIELD {
+ Fatal("nodarg: not field %v", Tconv(t, 0))
+ }
+
+ if fp == 1 {
+ for l = Curfn.Dcl; l != nil; l = l.Next {
+ n = l.N
+ if (n.Class == PPARAM || n.Class == PPARAMOUT) && !isblanksym(t.Sym) && n.Sym == t.Sym {
+ return n
+ }
+ }
+ }
+
+ n = Nod(ONAME, nil, nil)
+ n.Type = t.Type
+ n.Sym = t.Sym
+
+ if t.Width == BADWIDTH {
+ Fatal("nodarg: offset not computed for %v", Tconv(t, 0))
+ }
+ n.Xoffset = t.Width
+ n.Addable = 1
+ n.Orig = t.Nname
+
+ // Rewrite argument named _ to __,
+ // or else the assignment to _ will be
+ // discarded during code generation.
+fp:
+ if isblank(n) {
+ n.Sym = Lookup("__")
+ }
+
+ switch fp {
+ case 0: // output arg
+ n.Op = OINDREG
+
+ n.Val.U.Reg = int16(Thearch.REGSP)
+ if Thearch.Thechar == '5' {
+ n.Xoffset += 4
+ }
+ if Thearch.Thechar == '9' {
+ n.Xoffset += 8
+ }
+
+ case 1: // input arg
+ n.Class = PPARAM
+
+ case 2: // offset output arg
+ Fatal("shouldn't be used")
+
+ n.Op = OINDREG
+ n.Val.U.Reg = int16(Thearch.REGSP)
+ n.Xoffset += Types[Tptr].Width
+ }
+
+ n.Typecheck = 1
+ return n
+}
+
+func Patch(p *obj.Prog, to *obj.Prog) {
+ if p.To.Type != obj.TYPE_BRANCH {
+ Fatal("patch: not a branch")
+ }
+ p.To.U.Branch = to
+ p.To.Offset = to.Pc
+}
+
+func unpatch(p *obj.Prog) *obj.Prog {
+ var q *obj.Prog
+
+ if p.To.Type != obj.TYPE_BRANCH {
+ Fatal("unpatch: not a branch")
+ }
+ q = p.To.U.Branch
+ p.To.U.Branch = nil
+ p.To.Offset = 0
+ return q
+}
diff --git a/src/cmd/internal/gc/init.go b/src/cmd/internal/gc/init.go
new file mode 100644
index 0000000..e738dba
--- /dev/null
+++ b/src/cmd/internal/gc/init.go
@@ -0,0 +1,232 @@
+// 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
+
+import "fmt"
+
+// case OADD:
+// if(n->right->op == OLITERAL) {
+// v = n->right->vconst;
+// naddr(n->left, a, canemitcode);
+// } else
+// if(n->left->op == OLITERAL) {
+// v = n->left->vconst;
+// naddr(n->right, a, canemitcode);
+// } else
+// goto bad;
+// a->offset += v;
+// break;
+
+/*
+ * a function named init is a special case.
+ * it is called by the initialization before
+ * main is run. to make it unique within a
+ * package and also uncallable, the name,
+ * normally "pkg.init", is altered to "pkg.init·1".
+ */
+
+var renameinit_initgen int
+
+func renameinit() *Sym {
+ renameinit_initgen++
+ namebuf = fmt.Sprintf("init·%d", renameinit_initgen)
+ return Lookup(namebuf)
+}
+
+/*
+ * hand-craft the following initialization code
+ * var initdone· uint8 (1)
+ * func init() (2)
+ * if initdone· != 0 { (3)
+ * if initdone· == 2 (4)
+ * return
+ * throw(); (5)
+ * }
+ * initdone· = 1; (6)
+ * // over all matching imported symbols
+ * <pkg>.init() (7)
+ * { <init stmts> } (8)
+ * init·<n>() // if any (9)
+ * initdone· = 2; (10)
+ * return (11)
+ * }
+ */
+func anyinit(n *NodeList) int {
+ var h uint32
+ var s *Sym
+ var l *NodeList
+
+ // are there any interesting init statements
+ for l = n; l != nil; l = l.Next {
+ switch l.N.Op {
+ case ODCLFUNC,
+ ODCLCONST,
+ ODCLTYPE,
+ OEMPTY:
+ break
+
+ case OAS:
+ if isblank(l.N.Left) && candiscard(l.N.Right) != 0 {
+ break
+ }
+ fallthrough
+
+ // fall through
+ default:
+ return 1
+ }
+ }
+
+ // is this main
+ if localpkg.Name == "main" {
+ return 1
+ }
+
+ // is there an explicit init function
+ namebuf = fmt.Sprintf("init·1")
+
+ s = Lookup(namebuf)
+ if s.Def != nil {
+ return 1
+ }
+
+ // are there any imported init functions
+ for h = 0; h < NHASH; h++ {
+ for s = hash[h]; s != nil; s = s.Link {
+ if s.Name[0] != 'i' || s.Name != "init" {
+ continue
+ }
+ if s.Def == nil {
+ continue
+ }
+ return 1
+ }
+ }
+
+ // then none
+ return 0
+}
+
+func fninit(n *NodeList) {
+ var i int
+ var gatevar *Node
+ var a *Node
+ var b *Node
+ var fn *Node
+ var r *NodeList
+ var h uint32
+ var s *Sym
+ var initsym *Sym
+
+ if Debug['A'] != 0 {
+ // sys.go or unsafe.go during compiler build
+ return
+ }
+
+ n = initfix(n)
+ if !(anyinit(n) != 0) {
+ return
+ }
+
+ r = nil
+
+ // (1)
+ namebuf = fmt.Sprintf("initdone·")
+
+ gatevar = newname(Lookup(namebuf))
+ addvar(gatevar, Types[TUINT8], PEXTERN)
+
+ // (2)
+ Maxarg = 0
+
+ namebuf = fmt.Sprintf("init")
+
+ fn = Nod(ODCLFUNC, nil, nil)
+ initsym = Lookup(namebuf)
+ fn.Nname = newname(initsym)
+ fn.Nname.Defn = fn
+ fn.Nname.Ntype = Nod(OTFUNC, nil, nil)
+ declare(fn.Nname, PFUNC)
+ funchdr(fn)
+
+ // (3)
+ a = Nod(OIF, nil, nil)
+
+ a.Ntest = Nod(ONE, gatevar, Nodintconst(0))
+ r = list(r, a)
+
+ // (4)
+ b = Nod(OIF, nil, nil)
+
+ b.Ntest = Nod(OEQ, gatevar, Nodintconst(2))
+ b.Nbody = list1(Nod(ORETURN, nil, nil))
+ a.Nbody = list1(b)
+
+ // (5)
+ b = syslook("throwinit", 0)
+
+ b = Nod(OCALL, b, nil)
+ a.Nbody = list(a.Nbody, b)
+
+ // (6)
+ a = Nod(OAS, gatevar, Nodintconst(1))
+
+ r = list(r, a)
+
+ // (7)
+ for h = 0; h < NHASH; h++ {
+ for s = hash[h]; s != nil; s = s.Link {
+ if s.Name[0] != 'i' || s.Name != "init" {
+ continue
+ }
+ if s.Def == nil {
+ continue
+ }
+ if s == initsym {
+ continue
+ }
+
+ // could check that it is fn of no args/returns
+ a = Nod(OCALL, s.Def, nil)
+
+ r = list(r, a)
+ }
+ }
+
+ // (8)
+ r = concat(r, n)
+
+ // (9)
+ // could check that it is fn of no args/returns
+ for i = 1; ; i++ {
+ namebuf = fmt.Sprintf("init·%d", i)
+ s = Lookup(namebuf)
+ if s.Def == nil {
+ break
+ }
+ a = Nod(OCALL, s.Def, nil)
+ r = list(r, a)
+ }
+
+ // (10)
+ a = Nod(OAS, gatevar, Nodintconst(2))
+
+ r = list(r, a)
+
+ // (11)
+ a = Nod(ORETURN, nil, nil)
+
+ r = list(r, a)
+ exportsym(fn.Nname)
+
+ fn.Nbody = r
+ funcbody(fn)
+
+ Curfn = fn
+ typecheck(&fn, Etop)
+ typechecklist(r, Etop)
+ Curfn = nil
+ funccompile(fn)
+}
diff --git a/src/cmd/internal/gc/inl.go b/src/cmd/internal/gc/inl.go
new file mode 100644
index 0000000..1b4b40d
--- /dev/null
+++ b/src/cmd/internal/gc/inl.go
@@ -0,0 +1,1040 @@
+// Copyright 2011 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.
+//
+// The inlining facility makes 2 passes: first caninl determines which
+// functions are suitable for inlining, and for those that are it
+// saves a copy of the body. Then inlcalls walks each function body to
+// expand calls to inlinable functions.
+//
+// The debug['l'] flag controls the agressiveness. Note that main() swaps level 0 and 1,
+// making 1 the default and -l disable. -ll and more is useful to flush out bugs.
+// These additional levels (beyond -l) may be buggy and are not supported.
+// 0: disabled
+// 1: 40-nodes leaf functions, oneliners, lazy typechecking (default)
+// 2: early typechecking of all imported bodies
+// 3: allow variadic functions
+// 4: allow non-leaf functions , (breaks runtime.Caller)
+// 5: transitive inlining
+//
+// At some point this may get another default and become switch-offable with -N.
+//
+// The debug['m'] flag enables diagnostic output. a single -m is useful for verifying
+// which calls get inlined or not, more is for debugging, and may go away at any point.
+//
+// TODO:
+// - inline functions with ... args
+// - handle T.meth(f()) with func f() (t T, arg, arg, )
+
+package gc
+
+import (
+ "cmd/internal/obj"
+ "fmt"
+)
+
+// Used by caninl.
+
+// Used by inlcalls
+
+// Used during inlsubst[list]
+var inlfn *Node // function currently being inlined
+
+var inlretlabel *Node // target of the goto substituted in place of a return
+
+var inlretvars *NodeList // temp out variables
+
+// Get the function's package. For ordinary functions it's on the ->sym, but for imported methods
+// the ->sym can be re-used in the local package, so peel it off the receiver's type.
+func fnpkg(fn *Node) *Pkg {
+ var rcvr *Type
+
+ if fn.Type.Thistuple != 0 {
+ // method
+ rcvr = getthisx(fn.Type).Type.Type
+
+ if Isptr[rcvr.Etype] != 0 {
+ rcvr = rcvr.Type
+ }
+ if !(rcvr.Sym != nil) {
+ Fatal("receiver with no sym: [%v] %v (%v)", Sconv(fn.Sym, 0), Nconv(fn, obj.FmtLong), Tconv(rcvr, 0))
+ }
+ return rcvr.Sym.Pkg
+ }
+
+ // non-method
+ return fn.Sym.Pkg
+}
+
+// Lazy typechecking of imported bodies. For local functions, caninl will set ->typecheck
+// because they're a copy of an already checked body.
+func typecheckinl(fn *Node) {
+ var savefn *Node
+ var pkg *Pkg
+ var save_safemode int
+ var lno int
+
+ lno = int(setlineno(fn))
+
+ // typecheckinl is only for imported functions;
+ // their bodies may refer to unsafe as long as the package
+ // was marked safe during import (which was checked then).
+ // the ->inl of a local function has been typechecked before caninl copied it.
+ pkg = fnpkg(fn)
+
+ if pkg == localpkg || pkg == nil {
+ return // typecheckinl on local function
+ }
+
+ if Debug['m'] > 2 {
+ fmt.Printf("typecheck import [%v] %v { %v }\n", Sconv(fn.Sym, 0), Nconv(fn, obj.FmtLong), Hconv(fn.Inl, obj.FmtSharp))
+ }
+
+ save_safemode = safemode
+ safemode = 0
+
+ savefn = Curfn
+ Curfn = fn
+ typechecklist(fn.Inl, Etop)
+ Curfn = savefn
+
+ safemode = save_safemode
+
+ lineno = int32(lno)
+}
+
+// Caninl determines whether fn is inlineable.
+// If so, caninl saves fn->nbody in fn->inl and substitutes it with a copy.
+// fn and ->nbody will already have been typechecked.
+func caninl(fn *Node) {
+ var savefn *Node
+ var t *Type
+ var budget int
+
+ if fn.Op != ODCLFUNC {
+ Fatal("caninl %v", Nconv(fn, 0))
+ }
+ if !(fn.Nname != nil) {
+ Fatal("caninl no nname %v", Nconv(fn, obj.FmtSign))
+ }
+
+ // If fn has no body (is defined outside of Go), cannot inline it.
+ if fn.Nbody == nil {
+ return
+ }
+
+ if fn.Typecheck == 0 {
+ Fatal("caninl on non-typechecked function %v", Nconv(fn, 0))
+ }
+
+ // can't handle ... args yet
+ if Debug['l'] < 3 {
+ for t = fn.Type.Type.Down.Down.Type; t != nil; t = t.Down {
+ if t.Isddd != 0 {
+ return
+ }
+ }
+ }
+
+ budget = 40 // allowed hairyness
+ if ishairylist(fn.Nbody, &budget) != 0 {
+ return
+ }
+
+ savefn = Curfn
+ Curfn = fn
+
+ fn.Nname.Inl = fn.Nbody
+ fn.Nbody = inlcopylist(fn.Nname.Inl)
+ fn.Nname.Inldcl = inlcopylist(fn.Nname.Defn.Dcl)
+
+ // hack, TODO, check for better way to link method nodes back to the thing with the ->inl
+ // this is so export can find the body of a method
+ fn.Type.Nname = fn.Nname
+
+ if Debug['m'] > 1 {
+ fmt.Printf("%v: can inline %v as: %v { %v }\n", fn.Line(), Nconv(fn.Nname, obj.FmtSharp), Tconv(fn.Type, obj.FmtSharp), Hconv(fn.Nname.Inl, obj.FmtSharp))
+ } else if Debug['m'] != 0 {
+ fmt.Printf("%v: can inline %v\n", fn.Line(), Nconv(fn.Nname, 0))
+ }
+
+ Curfn = savefn
+}
+
+// Look for anything we want to punt on.
+func ishairylist(ll *NodeList, budget *int) int {
+ for ; ll != nil; ll = ll.Next {
+ if ishairy(ll.N, budget) != 0 {
+ return 1
+ }
+ }
+ return 0
+}
+
+func ishairy(n *Node, budget *int) int {
+ if !(n != nil) {
+ return 0
+ }
+
+ // Things that are too hairy, irrespective of the budget
+ switch n.Op {
+ case OCALL,
+ OCALLFUNC,
+ OCALLINTER,
+ OCALLMETH,
+ OPANIC,
+ ORECOVER:
+ if Debug['l'] < 4 {
+ return 1
+ }
+
+ case OCLOSURE,
+ OCALLPART,
+ ORANGE,
+ OFOR,
+ OSELECT,
+ OSWITCH,
+ OPROC,
+ ODEFER,
+ ODCLTYPE, // can't print yet
+ ODCLCONST, // can't print yet
+ ORETJMP:
+ return 1
+ }
+
+ (*budget)--
+
+ return bool2int(*budget < 0 || ishairy(n.Left, budget) != 0 || ishairy(n.Right, budget) != 0 || ishairylist(n.List, budget) != 0 || ishairylist(n.Rlist, budget) != 0 || ishairylist(n.Ninit, budget) != 0 || ishairy(n.Ntest, budget) != 0 || ishairy(n.Nincr, budget) != 0 || ishairylist(n.Nbody, budget) != 0 || ishairylist(n.Nelse, budget) != 0)
+}
+
+// Inlcopy and inlcopylist recursively copy the body of a function.
+// Any name-like node of non-local class is marked for re-export by adding it to
+// the exportlist.
+func inlcopylist(ll *NodeList) *NodeList {
+ var l *NodeList
+
+ l = nil
+ for ; ll != nil; ll = ll.Next {
+ l = list(l, inlcopy(ll.N))
+ }
+ return l
+}
+
+func inlcopy(n *Node) *Node {
+ var m *Node
+
+ if n == nil {
+ return nil
+ }
+
+ switch n.Op {
+ case ONAME,
+ OTYPE,
+ OLITERAL:
+ return n
+ }
+
+ m = Nod(OXXX, nil, nil)
+ *m = *n
+ m.Inl = nil
+ m.Left = inlcopy(n.Left)
+ m.Right = inlcopy(n.Right)
+ m.List = inlcopylist(n.List)
+ m.Rlist = inlcopylist(n.Rlist)
+ m.Ninit = inlcopylist(n.Ninit)
+ m.Ntest = inlcopy(n.Ntest)
+ m.Nincr = inlcopy(n.Nincr)
+ m.Nbody = inlcopylist(n.Nbody)
+ m.Nelse = inlcopylist(n.Nelse)
+
+ return m
+}
+
+// Inlcalls/nodelist/node walks fn's statements and expressions and substitutes any
+// calls made to inlineable functions. This is the external entry point.
+func inlcalls(fn *Node) {
+ var savefn *Node
+
+ savefn = Curfn
+ Curfn = fn
+ inlnode(&fn)
+ if fn != Curfn {
+ Fatal("inlnode replaced curfn")
+ }
+ Curfn = savefn
+}
+
+// Turn an OINLCALL into a statement.
+func inlconv2stmt(n *Node) {
+ n.Op = OBLOCK
+
+ // n->ninit stays
+ n.List = n.Nbody
+
+ n.Nbody = nil
+ n.Rlist = nil
+}
+
+// Turn an OINLCALL into a single valued expression.
+func inlconv2expr(np **Node) {
+ var n *Node
+ var r *Node
+ n = *np
+ r = n.Rlist.N
+ addinit(&r, concat(n.Ninit, n.Nbody))
+ *np = r
+}
+
+// Turn the rlist (with the return values) of the OINLCALL in
+// n into an expression list lumping the ninit and body
+// containing the inlined statements on the first list element so
+// order will be preserved Used in return, oas2func and call
+// statements.
+func inlconv2list(n *Node) *NodeList {
+ var l *NodeList
+
+ if n.Op != OINLCALL || n.Rlist == nil {
+ Fatal("inlconv2list %v\n", Nconv(n, obj.FmtSign))
+ }
+
+ l = n.Rlist
+ addinit(&l.N, concat(n.Ninit, n.Nbody))
+ return l
+}
+
+func inlnodelist(l *NodeList) {
+ for ; l != nil; l = l.Next {
+ inlnode(&l.N)
+ }
+}
+
+// inlnode recurses over the tree to find inlineable calls, which will
+// be turned into OINLCALLs by mkinlcall. When the recursion comes
+// back up will examine left, right, list, rlist, ninit, ntest, nincr,
+// nbody and nelse and use one of the 4 inlconv/glue functions above
+// to turn the OINLCALL into an expression, a statement, or patch it
+// in to this nodes list or rlist as appropriate.
+// NOTE it makes no sense to pass the glue functions down the
+// recursion to the level where the OINLCALL gets created because they
+// have to edit /this/ n, so you'd have to push that one down as well,
+// but then you may as well do it here. so this is cleaner and
+// shorter and less complicated.
+func inlnode(np **Node) {
+ var n *Node
+ var l *NodeList
+ var lno int
+
+ if *np == nil {
+ return
+ }
+
+ n = *np
+
+ switch n.Op {
+ // inhibit inlining of their argument
+ case ODEFER,
+ OPROC:
+ switch n.Left.Op {
+ case OCALLFUNC,
+ OCALLMETH:
+ n.Left.Etype = n.Op
+ }
+ fallthrough
+
+ // TODO do them here (or earlier),
+ // so escape analysis can avoid more heapmoves.
+ case OCLOSURE:
+ return
+ }
+
+ lno = int(setlineno(n))
+
+ inlnodelist(n.Ninit)
+ for l = n.Ninit; l != nil; l = l.Next {
+ if l.N.Op == OINLCALL {
+ inlconv2stmt(l.N)
+ }
+ }
+
+ inlnode(&n.Left)
+ if n.Left != nil && n.Left.Op == OINLCALL {
+ inlconv2expr(&n.Left)
+ }
+
+ inlnode(&n.Right)
+ if n.Right != nil && n.Right.Op == OINLCALL {
+ inlconv2expr(&n.Right)
+ }
+
+ inlnodelist(n.List)
+ switch n.Op {
+ case OBLOCK:
+ for l = n.List; l != nil; l = l.Next {
+ if l.N.Op == OINLCALL {
+ inlconv2stmt(l.N)
+ }
+ }
+
+ // if we just replaced arg in f(arg()) or return arg with an inlined call
+ // and arg returns multiple values, glue as list
+ case ORETURN,
+ OCALLFUNC,
+ OCALLMETH,
+ OCALLINTER,
+ OAPPEND,
+ OCOMPLEX:
+ if count(n.List) == 1 && n.List.N.Op == OINLCALL && count(n.List.N.Rlist) > 1 {
+ n.List = inlconv2list(n.List.N)
+ break
+ }
+ fallthrough
+
+ // fallthrough
+ default:
+ for l = n.List; l != nil; l = l.Next {
+ if l.N.Op == OINLCALL {
+ inlconv2expr(&l.N)
+ }
+ }
+ }
+
+ inlnodelist(n.Rlist)
+ switch n.Op {
+ case OAS2FUNC:
+ if n.Rlist.N.Op == OINLCALL {
+ n.Rlist = inlconv2list(n.Rlist.N)
+ n.Op = OAS2
+ n.Typecheck = 0
+ typecheck(np, Etop)
+ break
+ }
+ fallthrough
+
+ // fallthrough
+ default:
+ for l = n.Rlist; l != nil; l = l.Next {
+ if l.N.Op == OINLCALL {
+ inlconv2expr(&l.N)
+ }
+ }
+ }
+
+ inlnode(&n.Ntest)
+ if n.Ntest != nil && n.Ntest.Op == OINLCALL {
+ inlconv2expr(&n.Ntest)
+ }
+
+ inlnode(&n.Nincr)
+ if n.Nincr != nil && n.Nincr.Op == OINLCALL {
+ inlconv2stmt(n.Nincr)
+ }
+
+ inlnodelist(n.Nbody)
+ for l = n.Nbody; l != nil; l = l.Next {
+ if l.N.Op == OINLCALL {
+ inlconv2stmt(l.N)
+ }
+ }
+
+ inlnodelist(n.Nelse)
+ for l = n.Nelse; l != nil; l = l.Next {
+ if l.N.Op == OINLCALL {
+ inlconv2stmt(l.N)
+ }
+ }
+
+ // with all the branches out of the way, it is now time to
+ // transmogrify this node itself unless inhibited by the
+ // switch at the top of this function.
+ switch n.Op {
+ case OCALLFUNC,
+ OCALLMETH:
+ if n.Etype == OPROC || n.Etype == ODEFER {
+ return
+ }
+ }
+
+ switch n.Op {
+ case OCALLFUNC:
+ if Debug['m'] > 3 {
+ fmt.Printf("%v:call to func %v\n", n.Line(), Nconv(n.Left, obj.FmtSign))
+ }
+ if n.Left.Inl != nil { // normal case
+ mkinlcall(np, n.Left, int(n.Isddd))
+ } else if n.Left.Op == ONAME && n.Left.Left != nil && n.Left.Left.Op == OTYPE && n.Left.Right != nil && n.Left.Right.Op == ONAME { // methods called as functions
+ if n.Left.Sym.Def != nil {
+ mkinlcall(np, n.Left.Sym.Def, int(n.Isddd))
+ }
+ }
+
+ case OCALLMETH:
+ if Debug['m'] > 3 {
+ fmt.Printf("%v:call to meth %v\n", n.Line(), Nconv(n.Left.Right, obj.FmtLong))
+ }
+
+ // typecheck should have resolved ODOTMETH->type, whose nname points to the actual function.
+ if n.Left.Type == nil {
+ Fatal("no function type for [%p] %v\n", n.Left, Nconv(n.Left, obj.FmtSign))
+ }
+
+ if n.Left.Type.Nname == nil {
+ Fatal("no function definition for [%p] %v\n", n.Left.Type, Tconv(n.Left.Type, obj.FmtSign))
+ }
+
+ mkinlcall(np, n.Left.Type.Nname, int(n.Isddd))
+ }
+
+ lineno = int32(lno)
+}
+
+func mkinlcall(np **Node, fn *Node, isddd int) {
+ var save_safemode int
+ var pkg *Pkg
+
+ save_safemode = safemode
+
+ // imported functions may refer to unsafe as long as the
+ // package was marked safe during import (already checked).
+ pkg = fnpkg(fn)
+
+ if pkg != localpkg && pkg != nil {
+ safemode = 0
+ }
+ mkinlcall1(np, fn, isddd)
+ safemode = save_safemode
+}
+
+func tinlvar(t *Type) *Node {
+ if t.Nname != nil && !isblank(t.Nname) {
+ if !(t.Nname.Inlvar != nil) {
+ Fatal("missing inlvar for %v\n", Nconv(t.Nname, 0))
+ }
+ return t.Nname.Inlvar
+ }
+
+ typecheck(&nblank, Erv|Easgn)
+ return nblank
+}
+
+var inlgen int
+
+// if *np is a call, and fn is a function with an inlinable body, substitute *np with an OINLCALL.
+// On return ninit has the parameter assignments, the nbody is the
+// inlined function body and list, rlist contain the input, output
+// parameters.
+func mkinlcall1(np **Node, fn *Node, isddd int) {
+ var i int
+ var chkargcount int
+ var n *Node
+ var call *Node
+ var saveinlfn *Node
+ var as *Node
+ var m *Node
+ var dcl *NodeList
+ var ll *NodeList
+ var ninit *NodeList
+ var body *NodeList
+ var t *Type
+ var variadic int
+ var varargcount int
+ var multiret int
+ var vararg *Node
+ var varargs *NodeList
+ var varargtype *Type
+ var vararrtype *Type
+
+ // For variadic fn.
+ if fn.Inl == nil {
+ return
+ }
+
+ if fn == Curfn || fn.Defn == Curfn {
+ return
+ }
+
+ if Debug['l'] < 2 {
+ typecheckinl(fn)
+ }
+
+ n = *np
+
+ // Bingo, we have a function node, and it has an inlineable body
+ if Debug['m'] > 1 {
+ fmt.Printf("%v: inlining call to %v %v { %v }\n", n.Line(), Sconv(fn.Sym, 0), Tconv(fn.Type, obj.FmtSharp), Hconv(fn.Inl, obj.FmtSharp))
+ } else if Debug['m'] != 0 {
+ fmt.Printf("%v: inlining call to %v\n", n.Line(), Nconv(fn, 0))
+ }
+
+ if Debug['m'] > 2 {
+ fmt.Printf("%v: Before inlining: %v\n", n.Line(), Nconv(n, obj.FmtSign))
+ }
+
+ saveinlfn = inlfn
+ inlfn = fn
+
+ ninit = n.Ninit
+
+ //dumplist("ninit pre", ninit);
+
+ if fn.Defn != nil { // local function
+ dcl = fn.Inldcl // imported function
+ } else {
+ dcl = fn.Dcl
+ }
+
+ inlretvars = nil
+ i = 0
+
+ // Make temp names to use instead of the originals
+ for ll = dcl; ll != nil; ll = ll.Next {
+ if ll.N.Class == PPARAMOUT { // return values handled below.
+ continue
+ }
+ if ll.N.Op == ONAME {
+ ll.N.Inlvar = inlvar(ll.N)
+
+ // Typecheck because inlvar is not necessarily a function parameter.
+ typecheck(&ll.N.Inlvar, Erv)
+
+ if ll.N.Class&^PHEAP != PAUTO {
+ ninit = list(ninit, Nod(ODCL, ll.N.Inlvar, nil)) // otherwise gen won't emit the allocations for heapallocs
+ }
+ }
+ }
+
+ // temporaries for return values.
+ for t = getoutargx(fn.Type).Type; t != nil; t = t.Down {
+ if t != nil && t.Nname != nil && !isblank(t.Nname) {
+ m = inlvar(t.Nname)
+ typecheck(&m, Erv)
+ t.Nname.Inlvar = m
+ } else {
+ // anonymous return values, synthesize names for use in assignment that replaces return
+ m = retvar(t, i)
+ i++
+ }
+
+ ninit = list(ninit, Nod(ODCL, m, nil))
+ inlretvars = list(inlretvars, m)
+ }
+
+ // assign receiver.
+ if fn.Type.Thistuple != 0 && n.Left.Op == ODOTMETH {
+ // method call with a receiver.
+ t = getthisx(fn.Type).Type
+
+ if t != nil && t.Nname != nil && !isblank(t.Nname) && !(t.Nname.Inlvar != nil) {
+ Fatal("missing inlvar for %v\n", Nconv(t.Nname, 0))
+ }
+ if !(n.Left.Left != nil) {
+ Fatal("method call without receiver: %v", Nconv(n, obj.FmtSign))
+ }
+ if t == nil {
+ Fatal("method call unknown receiver type: %v", Nconv(n, obj.FmtSign))
+ }
+ as = Nod(OAS, tinlvar(t), n.Left.Left)
+ if as != nil {
+ typecheck(&as, Etop)
+ ninit = list(ninit, as)
+ }
+ }
+
+ // check if inlined function is variadic.
+ variadic = 0
+
+ varargtype = nil
+ varargcount = 0
+ for t = fn.Type.Type.Down.Down.Type; t != nil; t = t.Down {
+ if t.Isddd != 0 {
+ variadic = 1
+ varargtype = t.Type
+ }
+ }
+
+ // but if argument is dotted too forget about variadicity.
+ if variadic != 0 && isddd != 0 {
+ variadic = 0
+ }
+
+ // check if argument is actually a returned tuple from call.
+ multiret = 0
+
+ if n.List != nil && !(n.List.Next != nil) {
+ switch n.List.N.Op {
+ case OCALL,
+ OCALLFUNC,
+ OCALLINTER,
+ OCALLMETH:
+ if n.List.N.Left.Type.Outtuple > 1 {
+ multiret = n.List.N.Left.Type.Outtuple - 1
+ }
+ }
+ }
+
+ if variadic != 0 {
+ varargcount = count(n.List) + multiret
+ if n.Left.Op != ODOTMETH {
+ varargcount -= fn.Type.Thistuple
+ }
+ varargcount -= fn.Type.Intuple - 1
+ }
+
+ // assign arguments to the parameters' temp names
+ as = Nod(OAS2, nil, nil)
+
+ as.Rlist = n.List
+ ll = n.List
+
+ // TODO: if len(nlist) == 1 but multiple args, check that n->list->n is a call?
+ if fn.Type.Thistuple != 0 && n.Left.Op != ODOTMETH {
+ // non-method call to method
+ if !(n.List != nil) {
+ Fatal("non-method call to method without first arg: %v", Nconv(n, obj.FmtSign))
+ }
+
+ // append receiver inlvar to LHS.
+ t = getthisx(fn.Type).Type
+
+ if t != nil && t.Nname != nil && !isblank(t.Nname) && !(t.Nname.Inlvar != nil) {
+ Fatal("missing inlvar for %v\n", Nconv(t.Nname, 0))
+ }
+ if t == nil {
+ Fatal("method call unknown receiver type: %v", Nconv(n, obj.FmtSign))
+ }
+ as.List = list(as.List, tinlvar(t))
+ ll = ll.Next // track argument count.
+ }
+
+ // append ordinary arguments to LHS.
+ chkargcount = bool2int(n.List != nil && n.List.Next != nil)
+
+ vararg = nil // the slice argument to a variadic call
+ varargs = nil // the list of LHS names to put in vararg.
+ if !(chkargcount != 0) {
+ // 0 or 1 expression on RHS.
+ for t = getinargx(fn.Type).Type; t != nil; t = t.Down {
+ if variadic != 0 && t.Isddd != 0 {
+ vararg = tinlvar(t)
+ for i = 0; i < varargcount && ll != nil; i++ {
+ m = argvar(varargtype, i)
+ varargs = list(varargs, m)
+ as.List = list(as.List, m)
+ }
+
+ break
+ }
+
+ as.List = list(as.List, tinlvar(t))
+ }
+ } else {
+ // match arguments except final variadic (unless the call is dotted itself)
+ for t = getinargx(fn.Type).Type; t != nil; {
+ if !(ll != nil) {
+ break
+ }
+ if variadic != 0 && t.Isddd != 0 {
+ break
+ }
+ as.List = list(as.List, tinlvar(t))
+ t = t.Down
+ ll = ll.Next
+ }
+
+ // match varargcount arguments with variadic parameters.
+ if variadic != 0 && t != nil && t.Isddd != 0 {
+ vararg = tinlvar(t)
+ for i = 0; i < varargcount && ll != nil; i++ {
+ m = argvar(varargtype, i)
+ varargs = list(varargs, m)
+ as.List = list(as.List, m)
+ ll = ll.Next
+ }
+
+ if i == varargcount {
+ t = t.Down
+ }
+ }
+
+ if ll != nil || t != nil {
+ Fatal("arg count mismatch: %v vs %v\n", Tconv(getinargx(fn.Type), obj.FmtSharp), Hconv(n.List, obj.FmtComma))
+ }
+ }
+
+ if as.Rlist != nil {
+ typecheck(&as, Etop)
+ ninit = list(ninit, as)
+ }
+
+ // turn the variadic args into a slice.
+ if variadic != 0 {
+ as = Nod(OAS, vararg, nil)
+ if !(varargcount != 0) {
+ as.Right = nodnil()
+ as.Right.Type = varargtype
+ } else {
+ vararrtype = typ(TARRAY)
+ vararrtype.Type = varargtype.Type
+ vararrtype.Bound = int64(varargcount)
+
+ as.Right = Nod(OCOMPLIT, nil, typenod(varargtype))
+ as.Right.List = varargs
+ as.Right = Nod(OSLICE, as.Right, Nod(OKEY, nil, nil))
+ }
+
+ typecheck(&as, Etop)
+ ninit = list(ninit, as)
+ }
+
+ // zero the outparams
+ for ll = inlretvars; ll != nil; ll = ll.Next {
+ as = Nod(OAS, ll.N, nil)
+ typecheck(&as, Etop)
+ ninit = list(ninit, as)
+ }
+
+ inlretlabel = newlabel_inl()
+ inlgen++
+ body = inlsubstlist(fn.Inl)
+
+ body = list(body, Nod(OGOTO, inlretlabel, nil)) // avoid 'not used' when function doesnt have return
+ body = list(body, Nod(OLABEL, inlretlabel, nil))
+
+ typechecklist(body, Etop)
+
+ //dumplist("ninit post", ninit);
+
+ call = Nod(OINLCALL, nil, nil)
+
+ call.Ninit = ninit
+ call.Nbody = body
+ call.Rlist = inlretvars
+ call.Type = n.Type
+ call.Typecheck = 1
+
+ setlno(call, int(n.Lineno))
+
+ //dumplist("call body", body);
+
+ *np = call
+
+ inlfn = saveinlfn
+
+ // transitive inlining
+ // TODO do this pre-expansion on fn->inl directly. requires
+ // either supporting exporting statemetns with complex ninits
+ // or saving inl and making inlinl
+ if Debug['l'] >= 5 {
+ body = fn.Inl
+ fn.Inl = nil // prevent infinite recursion
+ inlnodelist(call.Nbody)
+ for ll = call.Nbody; ll != nil; ll = ll.Next {
+ if ll.N.Op == OINLCALL {
+ inlconv2stmt(ll.N)
+ }
+ }
+ fn.Inl = body
+ }
+
+ if Debug['m'] > 2 {
+ fmt.Printf("%v: After inlining %v\n\n", n.Line(), Nconv(*np, obj.FmtSign))
+ }
+}
+
+// Every time we expand a function we generate a new set of tmpnames,
+// PAUTO's in the calling functions, and link them off of the
+// PPARAM's, PAUTOS and PPARAMOUTs of the called function.
+func inlvar(var_ *Node) *Node {
+ var n *Node
+
+ if Debug['m'] > 3 {
+ fmt.Printf("inlvar %v\n", Nconv(var_, obj.FmtSign))
+ }
+
+ n = newname(var_.Sym)
+ n.Type = var_.Type
+ n.Class = PAUTO
+ n.Used = 1
+ n.Curfn = Curfn // the calling function, not the called one
+ n.Addrtaken = var_.Addrtaken
+
+ // Esc pass wont run if we're inlining into a iface wrapper.
+ // Luckily, we can steal the results from the target func.
+ // If inlining a function defined in another package after
+ // escape analysis is done, treat all local vars as escaping.
+ // See issue 9537.
+ if var_.Esc == EscHeap || (inl_nonlocal != 0 && var_.Op == ONAME) {
+ addrescapes(n)
+ }
+
+ Curfn.Dcl = list(Curfn.Dcl, n)
+ return n
+}
+
+// Synthesize a variable to store the inlined function's results in.
+func retvar(t *Type, i int) *Node {
+ var n *Node
+
+ namebuf = fmt.Sprintf("~r%d", i)
+ n = newname(Lookup(namebuf))
+ n.Type = t.Type
+ n.Class = PAUTO
+ n.Used = 1
+ n.Curfn = Curfn // the calling function, not the called one
+ Curfn.Dcl = list(Curfn.Dcl, n)
+ return n
+}
+
+// Synthesize a variable to store the inlined function's arguments
+// when they come from a multiple return call.
+func argvar(t *Type, i int) *Node {
+ var n *Node
+
+ namebuf = fmt.Sprintf("~arg%d", i)
+ n = newname(Lookup(namebuf))
+ n.Type = t.Type
+ n.Class = PAUTO
+ n.Used = 1
+ n.Curfn = Curfn // the calling function, not the called one
+ Curfn.Dcl = list(Curfn.Dcl, n)
+ return n
+}
+
+var newlabel_inl_label int
+
+func newlabel_inl() *Node {
+ var n *Node
+
+ newlabel_inl_label++
+ namebuf = fmt.Sprintf(".inlret%.6d", newlabel_inl_label)
+ n = newname(Lookup(namebuf))
+ n.Etype = 1 // flag 'safe' for escape analysis (no backjumps)
+ return n
+}
+
+// inlsubst and inlsubstlist recursively copy the body of the saved
+// pristine ->inl body of the function while substituting references
+// to input/output parameters with ones to the tmpnames, and
+// substituting returns with assignments to the output.
+func inlsubstlist(ll *NodeList) *NodeList {
+ var l *NodeList
+
+ l = nil
+ for ; ll != nil; ll = ll.Next {
+ l = list(l, inlsubst(ll.N))
+ }
+ return l
+}
+
+func inlsubst(n *Node) *Node {
+ var p string
+ var m *Node
+ var as *Node
+ var ll *NodeList
+
+ if n == nil {
+ return nil
+ }
+
+ switch n.Op {
+ case ONAME:
+ if n.Inlvar != nil { // These will be set during inlnode
+ if Debug['m'] > 2 {
+ fmt.Printf("substituting name %v -> %v\n", Nconv(n, obj.FmtSign), Nconv(n.Inlvar, obj.FmtSign))
+ }
+ return n.Inlvar
+ }
+
+ if Debug['m'] > 2 {
+ fmt.Printf("not substituting name %v\n", Nconv(n, obj.FmtSign))
+ }
+ return n
+
+ case OLITERAL,
+ OTYPE:
+ return n
+
+ // Since we don't handle bodies with closures, this return is guaranteed to belong to the current inlined function.
+
+ // dump("Return before substitution", n);
+ case ORETURN:
+ m = Nod(OGOTO, inlretlabel, nil)
+
+ m.Ninit = inlsubstlist(n.Ninit)
+
+ if inlretvars != nil && n.List != nil {
+ as = Nod(OAS2, nil, nil)
+
+ // shallow copy or OINLCALL->rlist will be the same list, and later walk and typecheck may clobber that.
+ for ll = inlretvars; ll != nil; ll = ll.Next {
+ as.List = list(as.List, ll.N)
+ }
+ as.Rlist = inlsubstlist(n.List)
+ typecheck(&as, Etop)
+ m.Ninit = list(m.Ninit, as)
+ }
+
+ typechecklist(m.Ninit, Etop)
+ typecheck(&m, Etop)
+
+ // dump("Return after substitution", m);
+ return m
+
+ case OGOTO,
+ OLABEL:
+ m = Nod(OXXX, nil, nil)
+ *m = *n
+ m.Ninit = nil
+ p = fmt.Sprintf("%s·%d", n.Left.Sym.Name, inlgen)
+ m.Left = newname(Lookup(p))
+
+ return m
+ }
+
+ m = Nod(OXXX, nil, nil)
+ *m = *n
+ m.Ninit = nil
+
+ if n.Op == OCLOSURE {
+ Fatal("cannot inline function containing closure: %v", Nconv(n, obj.FmtSign))
+ }
+
+ m.Left = inlsubst(n.Left)
+ m.Right = inlsubst(n.Right)
+ m.List = inlsubstlist(n.List)
+ m.Rlist = inlsubstlist(n.Rlist)
+ m.Ninit = concat(m.Ninit, inlsubstlist(n.Ninit))
+ m.Ntest = inlsubst(n.Ntest)
+ m.Nincr = inlsubst(n.Nincr)
+ m.Nbody = inlsubstlist(n.Nbody)
+ m.Nelse = inlsubstlist(n.Nelse)
+
+ return m
+}
+
+// Plaster over linenumbers
+func setlnolist(ll *NodeList, lno int) {
+ for ; ll != nil; ll = ll.Next {
+ setlno(ll.N, lno)
+ }
+}
+
+func setlno(n *Node, lno int) {
+ if !(n != nil) {
+ return
+ }
+
+ // don't clobber names, unless they're freshly synthesized
+ if n.Op != ONAME || n.Lineno == 0 {
+ n.Lineno = int32(lno)
+ }
+
+ setlno(n.Left, lno)
+ setlno(n.Right, lno)
+ setlnolist(n.List, lno)
+ setlnolist(n.Rlist, lno)
+ setlnolist(n.Ninit, lno)
+ setlno(n.Ntest, lno)
+ setlno(n.Nincr, lno)
+ setlnolist(n.Nbody, lno)
+ setlnolist(n.Nelse, lno)
+}
diff --git a/src/cmd/internal/gc/lex.go b/src/cmd/internal/gc/lex.go
new file mode 100644
index 0000000..98cebe8
--- /dev/null
+++ b/src/cmd/internal/gc/lex.go
@@ -0,0 +1,3204 @@
+// 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
+
+import (
+ "bytes"
+ "cmd/internal/obj"
+ "flag"
+ "fmt"
+ "io"
+ "log"
+ "os"
+ "path"
+ "strconv"
+ "strings"
+ "unicode"
+ "unicode/utf8"
+)
+
+var yychar_lex int
+
+var yyprev int
+
+var yylast int
+
+var imported_unsafe int
+
+var goos string
+
+var goarch string
+
+var goroot string
+
+// Debug arguments.
+// These can be specified with the -d flag, as in "-d nil"
+// to set the debug_checknil variable. In general the list passed
+// to -d can be comma-separated.
+var debugtab = []struct {
+ name string
+ val *int
+}{struct {
+ name string
+ val *int
+}{"nil", &Debug_checknil}}
+
+// Our own isdigit, isspace, isalpha, isalnum that take care
+// of EOF and other out of range arguments.
+func yy_isdigit(c int) bool {
+ return c >= 0 && c <= 0xFF && isdigit(c)
+}
+
+func yy_isspace(c int) bool {
+ return c == ' ' || c == '\t' || c == '\n' || c == '\r'
+}
+
+func yy_isalpha(c int) bool {
+ return 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z'
+}
+
+func yy_isalnum(c int) bool {
+ return c >= 0 && c <= 0xFF && isalnum(c)
+}
+
+// Disallow use of isdigit etc.
+
+const (
+ EOF = -1
+)
+
+func usage() {
+ fmt.Printf("usage: %cg [options] file.go...\n", Thearch.Thechar)
+ obj.Flagprint(1)
+ os.Exit(2)
+}
+
+func fault(s int) {
+ // If we've already complained about things
+ // in the program, don't bother complaining
+ // about the seg fault too; let the user clean up
+ // the code and try again.
+ if nsavederrors+nerrors > 0 {
+ errorexit()
+ }
+ Fatal("fault")
+}
+
+func doversion() {
+ var p string
+ var sep string
+
+ p = obj.Expstring()
+ if p == "X:none" {
+ p = ""
+ }
+ sep = ""
+ if p[0] != 0 {
+ sep = " "
+ }
+ fmt.Printf("%cg version %s%s%s\n", Thearch.Thechar, obj.Getgoversion(), sep, p)
+ os.Exit(0)
+}
+
+func Main() {
+ var l *NodeList
+ var p string
+
+ // Allow GOARCH=thearch.thestring or GOARCH=thearch.thestringsuffix,
+ // but not other values.
+ p = obj.Getgoarch()
+
+ if !strings.HasPrefix(p, Thearch.Thestring) {
+ log.Fatalf("cannot use %cg with GOARCH=%s", Thearch.Thechar, p)
+ }
+ goarch = p
+
+ Thearch.Linkarchinit()
+ Ctxt = obj.Linknew(Thearch.Thelinkarch)
+ Ctxt.Diag = Yyerror
+ Ctxt.Bso = &bstdout
+ bstdout = *obj.Binitw(os.Stdout)
+
+ localpkg = mkpkg(newstrlit(""))
+ localpkg.Prefix = "\"\""
+
+ // pseudo-package, for scoping
+ builtinpkg = mkpkg(newstrlit("go.builtin"))
+
+ builtinpkg.Prefix = "go.builtin" // not go%2ebuiltin
+
+ // pseudo-package, accessed by import "unsafe"
+ unsafepkg = mkpkg(newstrlit("unsafe"))
+
+ unsafepkg.Name = "unsafe"
+
+ // real package, referred to by generated runtime calls
+ Runtimepkg = mkpkg(newstrlit("runtime"))
+
+ Runtimepkg.Name = "runtime"
+
+ // pseudo-packages used in symbol tables
+ gostringpkg = mkpkg(newstrlit("go.string"))
+
+ gostringpkg.Name = "go.string"
+ gostringpkg.Prefix = "go.string" // not go%2estring
+
+ itabpkg = mkpkg(newstrlit("go.itab"))
+
+ itabpkg.Name = "go.itab"
+ itabpkg.Prefix = "go.itab" // not go%2eitab
+
+ weaktypepkg = mkpkg(newstrlit("go.weak.type"))
+
+ weaktypepkg.Name = "go.weak.type"
+ weaktypepkg.Prefix = "go.weak.type" // not go%2eweak%2etype
+
+ typelinkpkg = mkpkg(newstrlit("go.typelink"))
+ typelinkpkg.Name = "go.typelink"
+ typelinkpkg.Prefix = "go.typelink" // not go%2etypelink
+
+ trackpkg = mkpkg(newstrlit("go.track"))
+
+ trackpkg.Name = "go.track"
+ trackpkg.Prefix = "go.track" // not go%2etrack
+
+ typepkg = mkpkg(newstrlit("type"))
+
+ typepkg.Name = "type"
+
+ goroot = obj.Getgoroot()
+ goos = obj.Getgoos()
+
+ Nacl = goos == "nacl"
+ if Nacl {
+ flag_largemodel = 1
+ }
+
+ outfile = ""
+ obj.Flagcount("+", "compiling runtime", &compiling_runtime)
+ obj.Flagcount("%", "debug non-static initializers", &Debug['%'])
+ obj.Flagcount("A", "for bootstrapping, allow 'any' type", &Debug['A'])
+ obj.Flagcount("B", "disable bounds checking", &Debug['B'])
+ obj.Flagstr("D", "path: set relative path for local imports", &localimport)
+ obj.Flagcount("E", "debug symbol export", &Debug['E'])
+ obj.Flagfn1("I", "dir: add dir to import search path", addidir)
+ obj.Flagcount("K", "debug missing line numbers", &Debug['K'])
+ obj.Flagcount("L", "use full (long) path in error messages", &Debug['L'])
+ obj.Flagcount("M", "debug move generation", &Debug['M'])
+ obj.Flagcount("N", "disable optimizations", &Debug['N'])
+ obj.Flagcount("P", "debug peephole optimizer", &Debug['P'])
+ obj.Flagcount("R", "debug register optimizer", &Debug['R'])
+ obj.Flagcount("S", "print assembly listing", &Debug['S'])
+ obj.Flagfn0("V", "print compiler version", doversion)
+ obj.Flagcount("W", "debug parse tree after type checking", &Debug['W'])
+ obj.Flagstr("asmhdr", "file: write assembly header to named file", &asmhdr)
+ obj.Flagcount("complete", "compiling complete package (no C or assembly)", &pure_go)
+ obj.Flagstr("d", "list: print debug information about items in list", &debugstr)
+ obj.Flagcount("e", "no limit on number of errors reported", &Debug['e'])
+ obj.Flagcount("f", "debug stack frames", &Debug['f'])
+ obj.Flagcount("g", "debug code generation", &Debug['g'])
+ obj.Flagcount("h", "halt on error", &Debug['h'])
+ obj.Flagcount("i", "debug line number stack", &Debug['i'])
+ obj.Flagstr("installsuffix", "pkg directory suffix", &flag_installsuffix)
+ obj.Flagcount("j", "debug runtime-initialized variables", &Debug['j'])
+ obj.Flagcount("l", "disable inlining", &Debug['l'])
+ obj.Flagcount("live", "debug liveness analysis", &debuglive)
+ obj.Flagcount("m", "print optimization decisions", &Debug['m'])
+ obj.Flagcount("nolocalimports", "reject local (relative) imports", &nolocalimports)
+ obj.Flagstr("o", "obj: set output file", &outfile)
+ obj.Flagstr("p", "path: set expected package import path", &myimportpath)
+ obj.Flagcount("pack", "write package file instead of object file", &writearchive)
+ obj.Flagcount("r", "debug generated wrappers", &Debug['r'])
+ obj.Flagcount("race", "enable race detector", &flag_race)
+ obj.Flagcount("s", "warn about composite literals that can be simplified", &Debug['s'])
+ obj.Flagstr("trimpath", "prefix: remove prefix from recorded source file paths", &Ctxt.Trimpath)
+ obj.Flagcount("u", "reject unsafe code", &safemode)
+ obj.Flagcount("v", "increase debug verbosity", &Debug['v'])
+ obj.Flagcount("w", "debug type checking", &Debug['w'])
+ use_writebarrier = 1
+ obj.Flagcount("wb", "enable write barrier", &use_writebarrier)
+ obj.Flagcount("x", "debug lexer", &Debug['x'])
+ obj.Flagcount("y", "debug declarations in canned imports (with -d)", &Debug['y'])
+ if Thearch.Thechar == '6' {
+ obj.Flagcount("largemodel", "generate code that assumes a large memory model", &flag_largemodel)
+ }
+
+ obj.Flagparse(usage)
+ Ctxt.Debugasm = int32(Debug['S'])
+ Ctxt.Debugvlog = int32(Debug['v'])
+
+ if flag.NArg() < 1 {
+ usage()
+ }
+
+ if flag_race != 0 {
+ racepkg = mkpkg(newstrlit("runtime/race"))
+ racepkg.Name = "race"
+ }
+
+ // parse -d argument
+ if debugstr != "" {
+ var j int
+ f := strings.Split(debugstr, ",")
+ for i := range f {
+ if f[i] == "" {
+ continue
+ }
+ for j = 0; j < len(debugtab); j++ {
+ if debugtab[j].name == f[i] {
+ if debugtab[j].val != nil {
+ *debugtab[j].val = 1
+ }
+ break
+ }
+ }
+
+ if j >= len(debugtab) {
+ log.Fatalf("unknown debug information -d '%s'\n", f[i])
+ }
+ }
+ }
+
+ // enable inlining. for now:
+ // default: inlining on. (debug['l'] == 1)
+ // -l: inlining off (debug['l'] == 0)
+ // -ll, -lll: inlining on again, with extra debugging (debug['l'] > 1)
+ if Debug['l'] <= 1 {
+ Debug['l'] = 1 - Debug['l']
+ }
+
+ if Thearch.Thechar == '8' {
+ p = obj.Getgo386()
+ if p == "387" {
+ Use_sse = 0
+ } else if p == "sse2" {
+ Use_sse = 1
+ } else {
+ log.Fatalf("unsupported setting GO386=%s", p)
+ }
+ }
+
+ Thearch.Betypeinit()
+ if Widthptr == 0 {
+ Fatal("betypeinit failed")
+ }
+
+ lexinit()
+ typeinit()
+ lexinit1()
+ // TODO(rsc): Restore yytinit?
+
+ blockgen = 1
+ dclcontext = PEXTERN
+ nerrors = 0
+ lexlineno = 1
+
+ for _, infile = range flag.Args() {
+ linehist(infile, 0, 0)
+
+ curio.infile = infile
+ var err error
+ curio.bin, err = obj.Bopenr(infile)
+ if err != nil {
+ fmt.Printf("open %s: %v\n", infile, err)
+ errorexit()
+ }
+
+ curio.peekc = 0
+ curio.peekc1 = 0
+ curio.nlsemi = 0
+ curio.eofnl = 0
+ curio.last = 0
+
+ // Skip initial BOM if present.
+ if obj.Bgetrune(curio.bin) != obj.BOM {
+ obj.Bungetrune(curio.bin)
+ }
+
+ block = 1
+ iota_ = -1000000
+
+ imported_unsafe = 0
+
+ yyparse()
+ if nsyntaxerrors != 0 {
+ errorexit()
+ }
+
+ linehist("<pop>", 0, 0)
+ if curio.bin != nil {
+ obj.Bterm(curio.bin)
+ }
+ }
+
+ testdclstack()
+ mkpackage(localpkg.Name) // final import not used checks
+ lexfini()
+
+ typecheckok = 1
+ if Debug['f'] != 0 {
+ frame(1)
+ }
+
+ // Process top-level declarations in phases.
+
+ // Phase 1: const, type, and names and types of funcs.
+ // This will gather all the information about types
+ // and methods but doesn't depend on any of it.
+ defercheckwidth()
+
+ for l = xtop; l != nil; l = l.Next {
+ if l.N.Op != ODCL && l.N.Op != OAS {
+ typecheck(&l.N, Etop)
+ }
+ }
+
+ // Phase 2: Variable assignments.
+ // To check interface assignments, depends on phase 1.
+ for l = xtop; l != nil; l = l.Next {
+ if l.N.Op == ODCL || l.N.Op == OAS {
+ typecheck(&l.N, Etop)
+ }
+ }
+ resumecheckwidth()
+
+ // Phase 3: Type check function bodies.
+ for l = xtop; l != nil; l = l.Next {
+ if l.N.Op == ODCLFUNC || l.N.Op == OCLOSURE {
+ Curfn = l.N
+ decldepth = 1
+ saveerrors()
+ typechecklist(l.N.Nbody, Etop)
+ checkreturn(l.N)
+ if nerrors != 0 {
+ l.N.Nbody = nil // type errors; do not compile
+ }
+ }
+ }
+
+ // Phase 4: Decide how to capture closed variables.
+ // This needs to run before escape analysis,
+ // because variables captured by value do not escape.
+ for l = xtop; l != nil; l = l.Next {
+ if l.N.Op == ODCLFUNC && l.N.Closure != nil {
+ Curfn = l.N
+ capturevars(l.N)
+ }
+ }
+
+ Curfn = nil
+
+ if nsavederrors+nerrors != 0 {
+ errorexit()
+ }
+
+ // Phase 5: Inlining
+ if Debug['l'] > 1 {
+ // Typecheck imported function bodies if debug['l'] > 1,
+ // otherwise lazily when used or re-exported.
+ for l = importlist; l != nil; l = l.Next {
+ if l.N.Inl != nil {
+ saveerrors()
+ typecheckinl(l.N)
+ }
+ }
+
+ if nsavederrors+nerrors != 0 {
+ errorexit()
+ }
+ }
+
+ if Debug['l'] != 0 {
+ // Find functions that can be inlined and clone them before walk expands them.
+ for l = xtop; l != nil; l = l.Next {
+ if l.N.Op == ODCLFUNC {
+ caninl(l.N)
+ }
+ }
+
+ // Expand inlineable calls in all functions
+ for l = xtop; l != nil; l = l.Next {
+ if l.N.Op == ODCLFUNC {
+ inlcalls(l.N)
+ }
+ }
+ }
+
+ // Phase 6: Escape analysis.
+ // Required for moving heap allocations onto stack,
+ // which in turn is required by the closure implementation,
+ // which stores the addresses of stack variables into the closure.
+ // If the closure does not escape, it needs to be on the stack
+ // or else the stack copier will not update it.
+ escapes(xtop)
+
+ // Escape analysis moved escaped values off stack.
+ // Move large values off stack too.
+ movelarge(xtop)
+
+ // Phase 7: Transform closure bodies to properly reference captured variables.
+ // This needs to happen before walk, because closures must be transformed
+ // before walk reaches a call of a closure.
+ for l = xtop; l != nil; l = l.Next {
+ if l.N.Op == ODCLFUNC && l.N.Closure != nil {
+ Curfn = l.N
+ transformclosure(l.N)
+ }
+ }
+
+ Curfn = nil
+
+ // Phase 8: Compile top level functions.
+ for l = xtop; l != nil; l = l.Next {
+ if l.N.Op == ODCLFUNC {
+ funccompile(l.N)
+ }
+ }
+
+ if nsavederrors+nerrors == 0 {
+ fninit(xtop)
+ }
+
+ // Phase 9: Check external declarations.
+ for l = externdcl; l != nil; l = l.Next {
+ if l.N.Op == ONAME {
+ typecheck(&l.N, Erv)
+ }
+ }
+
+ if nerrors+nsavederrors != 0 {
+ errorexit()
+ }
+
+ dumpobj()
+
+ if asmhdr != "" {
+ dumpasmhdr()
+ }
+
+ if nerrors+nsavederrors != 0 {
+ errorexit()
+ }
+
+ Flusherrors()
+}
+
+func saveerrors() {
+ nsavederrors += nerrors
+ nerrors = 0
+}
+
+func arsize(b *obj.Biobuf, name string) int {
+ var buf [ArhdrSize]byte
+ if _, err := io.ReadFull(b, buf[:]); err != nil {
+ return -1
+ }
+ aname := strings.Trim(string(buf[0:16]), " ")
+ if !strings.HasPrefix(aname, name) {
+ return -1
+ }
+ asize := strings.Trim(string(buf[48:58]), " ")
+ i, _ := strconv.Atoi(asize)
+ return i
+}
+
+func skiptopkgdef(b *obj.Biobuf) int {
+ var p string
+ var sz int
+
+ /* archive header */
+ p = obj.Brdline(b, '\n')
+ if p == "" {
+ return 0
+ }
+ if obj.Blinelen(b) != 8 {
+ return 0
+ }
+ if p != "!<arch>\n" {
+ return 0
+ }
+
+ /* symbol table may be first; skip it */
+ sz = arsize(b, "__.GOSYMDEF")
+
+ if sz >= 0 {
+ obj.Bseek(b, int64(sz), 1)
+ } else {
+ obj.Bseek(b, 8, 0)
+ }
+
+ /* package export block is next */
+ sz = arsize(b, "__.PKGDEF")
+
+ if sz <= 0 {
+ return 0
+ }
+ return 1
+}
+
+func addidir(dir string) {
+ var pp **Idir
+
+ if dir == "" {
+ return
+ }
+
+ for pp = &idirs; *pp != nil; pp = &(*pp).link {
+ }
+ *pp = new(Idir)
+ (*pp).link = nil
+ (*pp).dir = dir
+}
+
+// is this path a local name? begins with ./ or ../ or /
+func islocalname(name *Strlit) bool {
+ return strings.HasPrefix(name.S, "/") ||
+ Ctxt.Windows != 0 && len(name.S) >= 3 && yy_isalpha(int(name.S[0])) && name.S[1] == ':' && name.S[2] == '/' ||
+ strings.HasPrefix(name.S, "./") || name.S == "." ||
+ strings.HasPrefix(name.S, "../") || name.S == ".."
+}
+
+func findpkg(name *Strlit) int {
+ var p *Idir
+ var q string
+ var suffix string
+ var suffixsep string
+
+ if islocalname(name) {
+ if safemode != 0 || nolocalimports != 0 {
+ return 0
+ }
+
+ // try .a before .6. important for building libraries:
+ // if there is an array.6 in the array.a library,
+ // want to find all of array.a, not just array.6.
+ namebuf = fmt.Sprintf("%v.a", Zconv(name, 0))
+
+ if obj.Access(namebuf, 0) >= 0 {
+ return 1
+ }
+ namebuf = fmt.Sprintf("%v.%c", Zconv(name, 0), Thearch.Thechar)
+ if obj.Access(namebuf, 0) >= 0 {
+ return 1
+ }
+ return 0
+ }
+
+ // local imports should be canonicalized already.
+ // don't want to see "encoding/../encoding/base64"
+ // as different from "encoding/base64".
+ _ = q
+ if path.Clean(name.S) != name.S {
+ Yyerror("non-canonical import path %v (should be %s)", Zconv(name, 0), q)
+ return 0
+ }
+
+ for p = idirs; p != nil; p = p.link {
+ namebuf = fmt.Sprintf("%s/%v.a", p.dir, Zconv(name, 0))
+ if obj.Access(namebuf, 0) >= 0 {
+ return 1
+ }
+ namebuf = fmt.Sprintf("%s/%v.%c", p.dir, Zconv(name, 0), Thearch.Thechar)
+ if obj.Access(namebuf, 0) >= 0 {
+ return 1
+ }
+ }
+
+ if goroot != "" {
+ suffix = ""
+ suffixsep = ""
+ if flag_installsuffix != "" {
+ suffixsep = "_"
+ suffix = flag_installsuffix
+ } else if flag_race != 0 {
+ suffixsep = "_"
+ suffix = "race"
+ }
+
+ namebuf = fmt.Sprintf("%s/pkg/%s_%s%s%s/%v.a", goroot, goos, goarch, suffixsep, suffix, Zconv(name, 0))
+ if obj.Access(namebuf, 0) >= 0 {
+ return 1
+ }
+ namebuf = fmt.Sprintf("%s/pkg/%s_%s%s%s/%v.%c", goroot, goos, goarch, suffixsep, suffix, Zconv(name, 0), Thearch.Thechar)
+ if obj.Access(namebuf, 0) >= 0 {
+ return 1
+ }
+ }
+
+ return 0
+}
+
+func fakeimport() {
+ importpkg = mkpkg(newstrlit("fake"))
+ cannedimports("fake.6", "$$\n")
+}
+
+func importfile(f *Val, line int) {
+ var imp *obj.Biobuf
+ var file string
+ var p string
+ var q string
+ var tag string
+ var c int32
+ var n int
+ var path_ *Strlit
+ var cleanbuf string
+ var prefix string
+
+ if f.Ctype != CTSTR {
+ Yyerror("import statement not a string")
+ fakeimport()
+ return
+ }
+
+ if len(f.U.Sval.S) == 0 {
+ Yyerror("import path is empty")
+ fakeimport()
+ return
+ }
+
+ if isbadimport(f.U.Sval) {
+ fakeimport()
+ return
+ }
+
+ // The package name main is no longer reserved,
+ // but we reserve the import path "main" to identify
+ // the main package, just as we reserve the import
+ // path "math" to identify the standard math package.
+ if f.U.Sval.S == "main" {
+ Yyerror("cannot import \"main\"")
+ errorexit()
+ }
+
+ if myimportpath != "" && f.U.Sval.S == myimportpath {
+ Yyerror("import \"%v\" while compiling that package (import cycle)", Zconv(f.U.Sval, 0))
+ errorexit()
+ }
+
+ if f.U.Sval.S == "unsafe" {
+ if safemode != 0 {
+ Yyerror("cannot import package unsafe")
+ errorexit()
+ }
+
+ importpkg = mkpkg(f.U.Sval)
+ cannedimports("unsafe.6", unsafeimport)
+ imported_unsafe = 1
+ return
+ }
+
+ path_ = f.U.Sval
+ if islocalname(path_) {
+ if path_.S[0] == '/' {
+ Yyerror("import path cannot be absolute path")
+ fakeimport()
+ return
+ }
+
+ prefix = Ctxt.Pathname
+ if localimport != "" {
+ prefix = localimport
+ }
+ cleanbuf = prefix
+ cleanbuf += "/"
+ cleanbuf += path_.S
+ cleanbuf = path.Clean(cleanbuf)
+ path_ = newstrlit(cleanbuf)
+
+ if isbadimport(path_) {
+ fakeimport()
+ return
+ }
+ }
+
+ if !(findpkg(path_) != 0) {
+ Yyerror("can't find import: \"%v\"", Zconv(f.U.Sval, 0))
+ errorexit()
+ }
+
+ importpkg = mkpkg(path_)
+
+ // If we already saw that package, feed a dummy statement
+ // to the lexer to avoid parsing export data twice.
+ if importpkg.Imported != 0 {
+ file = namebuf
+ tag = ""
+ if importpkg.Safe {
+ tag = "safe"
+ }
+
+ p = fmt.Sprintf("package %s %s\n$$\n", importpkg.Name, tag)
+ cannedimports(file, p)
+ return
+ }
+
+ importpkg.Imported = 1
+
+ var err error
+ imp, err = obj.Bopenr(namebuf)
+ if err != nil {
+ Yyerror("can't open import: \"%v\": %v", Zconv(f.U.Sval, 0), err)
+ errorexit()
+ }
+
+ file = namebuf
+
+ n = len(namebuf)
+ if n > 2 && namebuf[n-2] == '.' && namebuf[n-1] == 'a' {
+ if !(skiptopkgdef(imp) != 0) {
+ Yyerror("import %s: not a package file", file)
+ errorexit()
+ }
+ }
+
+ // check object header
+ p = obj.Brdstr(imp, '\n', 1)
+
+ if p != "empty archive" {
+ if !strings.HasPrefix(p, "go object ") {
+ Yyerror("import %s: not a go object file", file)
+ errorexit()
+ }
+
+ q = fmt.Sprintf("%s %s %s %s", obj.Getgoos(), obj.Getgoarch(), obj.Getgoversion(), obj.Expstring())
+ if p[10:] != q {
+ Yyerror("import %s: object is [%s] expected [%s]", file, p[10:], q)
+ errorexit()
+ }
+ }
+
+ // assume files move (get installed)
+ // so don't record the full path.
+ linehist(file[n-len(path_.S)-2:], -1, 1) // acts as #pragma lib
+
+ /*
+ * position the input right
+ * after $$ and return
+ */
+ pushedio = curio
+
+ curio.bin = imp
+ curio.peekc = 0
+ curio.peekc1 = 0
+ curio.infile = file
+ curio.nlsemi = 0
+ typecheckok = 1
+
+ for {
+ c = int32(getc())
+ if c == EOF {
+ break
+ }
+ if c != '$' {
+ continue
+ }
+ c = int32(getc())
+ if c == EOF {
+ break
+ }
+ if c != '$' {
+ continue
+ }
+ return
+ }
+
+ Yyerror("no import in \"%v\"", Zconv(f.U.Sval, 0))
+ unimportfile()
+}
+
+func unimportfile() {
+ if curio.bin != nil {
+ obj.Bterm(curio.bin)
+ curio.bin = nil
+ } else {
+ lexlineno-- // re correct sys.6 line number
+ }
+
+ curio = pushedio
+
+ pushedio.bin = nil
+ incannedimport = 0
+ typecheckok = 0
+}
+
+func cannedimports(file string, cp string) {
+ lexlineno++ // if sys.6 is included on line 1,
+
+ pushedio = curio
+
+ curio.bin = nil
+ curio.peekc = 0
+ curio.peekc1 = 0
+ curio.infile = file
+ curio.cp = cp
+ curio.nlsemi = 0
+ curio.importsafe = false
+
+ typecheckok = 1
+ incannedimport = 1
+}
+
+func isfrog(c int) bool {
+ // complain about possibly invisible control characters
+ if c < ' ' {
+ return !yy_isspace(c) // exclude good white space
+ }
+
+ if 0x7f <= c && c <= 0xa0 { // DEL, unicode block including unbreakable space.
+ return true
+ }
+ return false
+}
+
+type Loophack struct {
+ v int
+ next *Loophack
+}
+
+var _yylex_lstk *Loophack
+
+func _yylex(yylval *yySymType) int32 {
+ var c int
+ var c1 int
+ var escflag int
+ var v int64
+ var cp *bytes.Buffer
+ var rune_ uint
+ var s *Sym
+ var h *Loophack
+
+ prevlineno = lineno
+
+l0:
+ c = getc()
+ if yy_isspace(c) {
+ if c == '\n' && curio.nlsemi != 0 {
+ ungetc(c)
+ DBG("lex: implicit semi\n")
+ return ';'
+ }
+
+ goto l0
+ }
+
+ lineno = lexlineno /* start of token */
+
+ if c >= utf8.RuneSelf {
+ /* all multibyte runes are alpha */
+ cp = &lexbuf
+ cp.Reset()
+
+ goto talph
+ }
+
+ if yy_isalpha(c) {
+ cp = &lexbuf
+ cp.Reset()
+ goto talph
+ }
+
+ if yy_isdigit(c) {
+ goto tnum
+ }
+
+ switch c {
+ case EOF:
+ lineno = prevlineno
+ ungetc(EOF)
+ return -1
+
+ case '_':
+ cp = &lexbuf
+ cp.Reset()
+ goto talph
+
+ case '.':
+ c1 = getc()
+ if yy_isdigit(c1) {
+ cp = &lexbuf
+ cp.Reset()
+ cp.WriteByte(byte(c))
+ c = c1
+ goto casedot
+ }
+
+ if c1 == '.' {
+ c1 = getc()
+ if c1 == '.' {
+ c = LDDD
+ goto lx
+ }
+
+ ungetc(c1)
+ c1 = '.'
+ }
+
+ /* "..." */
+ case '"':
+ lexbuf.Reset()
+ lexbuf.WriteString(`"<string>"`)
+
+ cp = &strbuf
+ cp.Reset()
+
+ for {
+
+ if escchar('"', &escflag, &v) != 0 {
+ break
+ }
+ if v < utf8.RuneSelf || escflag != 0 {
+ cp.WriteByte(byte(v))
+ } else {
+ rune_ = uint(v)
+ cp.WriteRune(rune(rune_))
+ }
+ }
+
+ goto strlit
+
+ /* `...` */
+ case '`':
+ lexbuf.Reset()
+ lexbuf.WriteString("`<string>`")
+
+ cp = &strbuf
+ cp.Reset()
+
+ for {
+
+ c = int(getr())
+ if c == '\r' {
+ continue
+ }
+ if c == EOF {
+ Yyerror("eof in string")
+ break
+ }
+
+ if c == '`' {
+ break
+ }
+ cp.WriteRune(rune(c))
+ }
+
+ goto strlit
+
+ /* '.' */
+ case '\'':
+ if escchar('\'', &escflag, &v) != 0 {
+ Yyerror("empty character literal or unescaped ' in character literal")
+ v = '\''
+ }
+
+ if !(escchar('\'', &escflag, &v) != 0) {
+ Yyerror("missing '")
+ ungetc(int(v))
+ }
+
+ yylval.val.U.Xval = new(Mpint)
+ Mpmovecfix(yylval.val.U.Xval, v)
+ yylval.val.Ctype = CTRUNE
+ DBG("lex: codepoint literal\n")
+ litbuf = "string literal"
+ return LLITERAL
+
+ case '/':
+ c1 = getc()
+ if c1 == '*' {
+ var nl int
+
+ nl = 0
+ for {
+ c = int(getr())
+ if c == '\n' {
+ nl = 1
+ }
+ for c == '*' {
+ c = int(getr())
+ if c == '/' {
+ if nl != 0 {
+ ungetc('\n')
+ }
+ goto l0
+ }
+
+ if c == '\n' {
+ nl = 1
+ }
+ }
+
+ if c == EOF {
+ Yyerror("eof in comment")
+ errorexit()
+ }
+ }
+ }
+
+ if c1 == '/' {
+ c = getlinepragma()
+ for {
+ if c == '\n' || c == EOF {
+ ungetc(c)
+ goto l0
+ }
+
+ c = int(getr())
+ }
+ }
+
+ if c1 == '=' {
+ c = ODIV
+ goto asop
+ }
+
+ case ':':
+ c1 = getc()
+ if c1 == '=' {
+ c = LCOLAS
+ yylval.i = int(lexlineno)
+ goto lx
+ }
+
+ case '*':
+ c1 = getc()
+ if c1 == '=' {
+ c = OMUL
+ goto asop
+ }
+
+ case '%':
+ c1 = getc()
+ if c1 == '=' {
+ c = OMOD
+ goto asop
+ }
+
+ case '+':
+ c1 = getc()
+ if c1 == '+' {
+ c = LINC
+ goto lx
+ }
+
+ if c1 == '=' {
+ c = OADD
+ goto asop
+ }
+
+ case '-':
+ c1 = getc()
+ if c1 == '-' {
+ c = LDEC
+ goto lx
+ }
+
+ if c1 == '=' {
+ c = OSUB
+ goto asop
+ }
+
+ case '>':
+ c1 = getc()
+ if c1 == '>' {
+ c = LRSH
+ c1 = getc()
+ if c1 == '=' {
+ c = ORSH
+ goto asop
+ }
+
+ break
+ }
+
+ if c1 == '=' {
+ c = LGE
+ goto lx
+ }
+
+ c = LGT
+
+ case '<':
+ c1 = getc()
+ if c1 == '<' {
+ c = LLSH
+ c1 = getc()
+ if c1 == '=' {
+ c = OLSH
+ goto asop
+ }
+
+ break
+ }
+
+ if c1 == '=' {
+ c = LLE
+ goto lx
+ }
+
+ if c1 == '-' {
+ c = LCOMM
+ goto lx
+ }
+
+ c = LLT
+
+ case '=':
+ c1 = getc()
+ if c1 == '=' {
+ c = LEQ
+ goto lx
+ }
+
+ case '!':
+ c1 = getc()
+ if c1 == '=' {
+ c = LNE
+ goto lx
+ }
+
+ case '&':
+ c1 = getc()
+ if c1 == '&' {
+ c = LANDAND
+ goto lx
+ }
+
+ if c1 == '^' {
+ c = LANDNOT
+ c1 = getc()
+ if c1 == '=' {
+ c = OANDNOT
+ goto asop
+ }
+
+ break
+ }
+
+ if c1 == '=' {
+ c = OAND
+ goto asop
+ }
+
+ case '|':
+ c1 = getc()
+ if c1 == '|' {
+ c = LOROR
+ goto lx
+ }
+
+ if c1 == '=' {
+ c = OOR
+ goto asop
+ }
+
+ case '^':
+ c1 = getc()
+ if c1 == '=' {
+ c = OXOR
+ goto asop
+ }
+
+ /*
+ * clumsy dance:
+ * to implement rule that disallows
+ * if T{1}[0] { ... }
+ * but allows
+ * if (T{1}[0]) { ... }
+ * the block bodies for if/for/switch/select
+ * begin with an LBODY token, not '{'.
+ *
+ * when we see the keyword, the next
+ * non-parenthesized '{' becomes an LBODY.
+ * loophack is normally 0.
+ * a keyword makes it go up to 1.
+ * parens push loophack onto a stack and go back to 0.
+ * a '{' with loophack == 1 becomes LBODY and disables loophack.
+ *
+ * i said it was clumsy.
+ */
+ case '(',
+ '[':
+ if loophack != 0 || _yylex_lstk != nil {
+ h = new(Loophack)
+ if h == nil {
+ Flusherrors()
+ Yyerror("out of memory")
+ errorexit()
+ }
+
+ h.v = loophack
+ h.next = _yylex_lstk
+ _yylex_lstk = h
+ loophack = 0
+ }
+
+ goto lx
+
+ case ')',
+ ']':
+ if _yylex_lstk != nil {
+ h = _yylex_lstk
+ loophack = h.v
+ _yylex_lstk = h.next
+ }
+
+ goto lx
+
+ case '{':
+ if loophack == 1 {
+ DBG("%L lex: LBODY\n", lexlineno)
+ loophack = 0
+ return LBODY
+ }
+
+ goto lx
+
+ default:
+ goto lx
+ }
+
+ ungetc(c1)
+
+lx:
+ if c > 0xff {
+ DBG("%L lex: TOKEN %s\n", lexlineno, lexname(c))
+ } else {
+ DBG("%L lex: TOKEN '%c'\n", lexlineno, c)
+ }
+ if isfrog(c) {
+ Yyerror("illegal character 0x%x", uint(c))
+ goto l0
+ }
+
+ if importpkg == nil && (c == '#' || c == '$' || c == '?' || c == '@' || c == '\\') {
+ Yyerror("%s: unexpected %c", "syntax error", c)
+ goto l0
+ }
+
+ return int32(c)
+
+asop:
+ yylval.i = c // rathole to hold which asop
+ DBG("lex: TOKEN ASOP %c\n", c)
+ return LASOP
+
+ /*
+ * cp is set to lexbuf and some
+ * prefix has been stored
+ */
+talph:
+ for {
+
+ if c >= utf8.RuneSelf {
+ ungetc(c)
+ rune_ = uint(getr())
+
+ // 0xb7 · is used for internal names
+ if !unicode.IsLetter(rune(rune_)) && !unicode.IsDigit(rune(rune_)) && (importpkg == nil || rune_ != 0xb7) {
+ Yyerror("invalid identifier character U+%04x", rune_)
+ }
+ cp.WriteRune(rune(rune_))
+ } else if !yy_isalnum(c) && c != '_' {
+ break
+ } else {
+ cp.WriteByte(byte(c))
+ }
+ c = getc()
+ }
+
+ cp = nil
+ ungetc(c)
+
+ s = Lookup(lexbuf.String())
+ switch s.Lexical {
+ case LIGNORE:
+ goto l0
+
+ case LFOR,
+ LIF,
+ LSWITCH,
+ LSELECT:
+ loophack = 1 // see comment about loophack above
+ }
+
+ DBG("lex: %S %s\n", s, lexname(int(s.Lexical)))
+ yylval.sym = s
+ return int32(s.Lexical)
+
+tnum:
+ cp = &lexbuf
+ cp.Reset()
+ if c != '0' {
+ for {
+
+ cp.WriteByte(byte(c))
+ c = getc()
+ if yy_isdigit(c) {
+ continue
+ }
+ goto dc
+ }
+ }
+
+ cp.WriteByte(byte(c))
+ c = getc()
+ if c == 'x' || c == 'X' {
+ for {
+
+ cp.WriteByte(byte(c))
+ c = getc()
+ if yy_isdigit(c) {
+ continue
+ }
+ if c >= 'a' && c <= 'f' {
+ continue
+ }
+ if c >= 'A' && c <= 'F' {
+ continue
+ }
+ if lexbuf.Len() == 2 {
+ Yyerror("malformed hex constant")
+ }
+ if c == 'p' {
+ goto caseep
+ }
+ goto ncu
+ }
+ }
+
+ if c == 'p' { // 0p begins floating point zero
+ goto caseep
+ }
+
+ c1 = 0
+ for {
+
+ if !yy_isdigit(c) {
+ break
+ }
+ if c < '0' || c > '7' {
+ c1 = 1 // not octal
+ }
+ cp.WriteByte(byte(c))
+ c = getc()
+ }
+
+ if c == '.' {
+ goto casedot
+ }
+ if c == 'e' || c == 'E' {
+ goto caseep
+ }
+ if c == 'i' {
+ goto casei
+ }
+ if c1 != 0 {
+ Yyerror("malformed octal constant")
+ }
+ goto ncu
+
+dc:
+ if c == '.' {
+ goto casedot
+ }
+ if c == 'e' || c == 'E' || c == 'p' || c == 'P' {
+ goto caseep
+ }
+ if c == 'i' {
+ goto casei
+ }
+
+ncu:
+ cp = nil
+ ungetc(c)
+
+ yylval.val.U.Xval = new(Mpint)
+ mpatofix(yylval.val.U.Xval, lexbuf.String())
+ if yylval.val.U.Xval.Ovf != 0 {
+ Yyerror("overflow in constant")
+ Mpmovecfix(yylval.val.U.Xval, 0)
+ }
+
+ yylval.val.Ctype = CTINT
+ DBG("lex: integer literal\n")
+ litbuf = "literal "
+ litbuf += lexbuf.String()
+ return LLITERAL
+
+casedot:
+ for {
+
+ cp.WriteByte(byte(c))
+ c = getc()
+ if !yy_isdigit(c) {
+ break
+ }
+ }
+
+ if c == 'i' {
+ goto casei
+ }
+ if c != 'e' && c != 'E' {
+ goto caseout
+ }
+
+caseep:
+ cp.WriteByte(byte(c))
+ c = getc()
+ if c == '+' || c == '-' {
+ cp.WriteByte(byte(c))
+ c = getc()
+ }
+
+ if !yy_isdigit(c) {
+ Yyerror("malformed fp constant exponent")
+ }
+ for yy_isdigit(c) {
+
+ cp.WriteByte(byte(c))
+ c = getc()
+ }
+
+ if c == 'i' {
+ goto casei
+ }
+ goto caseout
+
+ // imaginary constant
+casei:
+ cp = nil
+
+ yylval.val.U.Cval = new(Mpcplx)
+ Mpmovecflt(&yylval.val.U.Cval.Real, 0.0)
+ mpatoflt(&yylval.val.U.Cval.Imag, lexbuf.String())
+ if yylval.val.U.Cval.Imag.Val.Ovf != 0 {
+ Yyerror("overflow in imaginary constant")
+ Mpmovecflt(&yylval.val.U.Cval.Real, 0.0)
+ }
+
+ yylval.val.Ctype = CTCPLX
+ DBG("lex: imaginary literal\n")
+ litbuf = "literal "
+ litbuf += lexbuf.String()
+ return LLITERAL
+
+caseout:
+ cp = nil
+ ungetc(c)
+
+ yylval.val.U.Fval = new(Mpflt)
+ mpatoflt(yylval.val.U.Fval, lexbuf.String())
+ if yylval.val.U.Fval.Val.Ovf != 0 {
+ Yyerror("overflow in float constant")
+ Mpmovecflt(yylval.val.U.Fval, 0.0)
+ }
+
+ yylval.val.Ctype = CTFLT
+ DBG("lex: floating literal\n")
+ litbuf = "literal "
+ litbuf += lexbuf.String()
+ return LLITERAL
+
+strlit:
+ yylval.val.U.Sval = &Strlit{S: cp.String()}
+ yylval.val.Ctype = CTSTR
+ DBG("lex: string literal\n")
+ litbuf = "string literal"
+ return LLITERAL
+}
+
+func more(pp *string) bool {
+ p := *pp
+ for p != "" && yy_isspace(int(p[0])) {
+ p = p[1:]
+ }
+ *pp = p
+ return p != ""
+}
+
+/*
+ * read and interpret syntax that looks like
+ * //line parse.y:15
+ * as a discontinuity in sequential line numbers.
+ * the next line of input comes from parse.y:15
+ */
+func getlinepragma() int {
+ var cmd, verb, name string
+ var i int
+ var c int
+ var n int
+ var cp *bytes.Buffer
+ var linep int
+ var h *obj.Hist
+
+ c = int(getr())
+ if c == 'g' {
+ goto go_
+ }
+ if c != 'l' {
+ goto out
+ }
+ for i = 1; i < 5; i++ {
+ c = int(getr())
+ if c != int("line "[i]) {
+ goto out
+ }
+ }
+
+ cp = &lexbuf
+ cp.Reset()
+ linep = 0
+ for {
+ c = int(getr())
+ if c == EOF {
+ goto out
+ }
+ if c == '\n' {
+ break
+ }
+ if c == ' ' {
+ continue
+ }
+ if c == ':' {
+ linep = cp.Len() + 1
+ }
+ cp.WriteByte(byte(c))
+ }
+
+ cp = nil
+
+ if linep == 0 {
+ goto out
+ }
+ n = 0
+ for _, c := range lexbuf.String()[linep:] {
+ if c < '0' || c > '9' {
+ goto out
+ }
+ n = n*10 + int(c) - '0'
+ if n > 1e8 {
+ Yyerror("line number out of range")
+ errorexit()
+ }
+ }
+
+ if n <= 0 {
+ goto out
+ }
+
+ // try to avoid allocating file name over and over
+ name = lexbuf.String()[:linep-1]
+ for h = Ctxt.Hist; h != nil; h = h.Link {
+ if h.Name != "" && h.Name == name {
+ linehist(h.Name, int32(n), 0)
+ goto out
+ }
+ }
+
+ linehist(name, int32(n), 0)
+ goto out
+
+go_:
+ cp = &lexbuf
+ cp.Reset()
+ cp.WriteByte('g') // already read
+ for {
+ c = int(getr())
+ if c == EOF || c >= utf8.RuneSelf {
+ goto out
+ }
+ if c == '\n' {
+ break
+ }
+ cp.WriteByte(byte(c))
+ }
+
+ cp = nil
+
+ if strings.HasPrefix(lexbuf.String(), "go:cgo_") {
+ pragcgo(lexbuf.String())
+ }
+
+ cmd = lexbuf.String()
+ verb = cmd
+ if i := strings.Index(verb, " "); i >= 0 {
+ verb = verb[:i]
+ }
+
+ if verb == "go:linkname" {
+ if !(imported_unsafe != 0) {
+ Yyerror("//go:linkname only allowed in Go files that import \"unsafe\"")
+ }
+ f := strings.Fields(cmd)
+ if len(f) != 3 {
+ Yyerror("usage: //go:linkname localname linkname")
+ goto out
+ }
+
+ Lookup(f[1]).Linkname = f[2]
+ goto out
+ }
+
+ if verb == "go:nointerface" && obj.Fieldtrack_enabled != 0 {
+ nointerface = true
+ goto out
+ }
+
+ if verb == "go:noescape" {
+ noescape = true
+ goto out
+ }
+
+ if verb == "go:nosplit" {
+ nosplit = true
+ goto out
+ }
+
+ if verb == "go:nowritebarrier" {
+ if !(compiling_runtime != 0) {
+ Yyerror("//go:nowritebarrier only allowed in runtime")
+ }
+ nowritebarrier = true
+ goto out
+ }
+
+out:
+ return c
+}
+
+func getimpsym(pp *string) string {
+ more(pp) // skip spaces
+ p := *pp
+ if p == "" || p[0] == '"' {
+ return ""
+ }
+ i := 0
+ for i < len(p) && !yy_isspace(int(p[i])) && p[i] != '"' {
+ i++
+ }
+ sym := p[:i]
+ *pp = p[i:]
+ return sym
+}
+
+func getquoted(pp *string) (string, bool) {
+ more(pp) // skip spaces
+ p := *pp
+ if p == "" || p[0] != '"' {
+ return "", false
+ }
+ p = p[1:]
+ i := strings.Index(p, `"`)
+ if i < 0 {
+ return "", false
+ }
+ *pp = p[i+1:]
+ return p[:i], true
+}
+
+// Copied nearly verbatim from the C compiler's #pragma parser.
+// TODO: Rewrite more cleanly once the compiler is written in Go.
+func pragcgo(text string) {
+ var local string
+ var remote string
+ var p string
+ var q string
+ var verb string
+
+ if i := strings.Index(text, " "); i >= 0 {
+ text, q = text[:i], text[i:]
+ }
+
+ verb = text[3:] // skip "go:"
+
+ if verb == "cgo_dynamic_linker" || verb == "dynlinker" {
+ var ok bool
+ p, ok = getquoted(&q)
+ if !ok {
+ goto err1
+ }
+ pragcgobuf += fmt.Sprintf("cgo_dynamic_linker %v\n", plan9quote(p))
+ goto out
+
+ err1:
+ Yyerror("usage: //go:cgo_dynamic_linker \"path\"")
+ goto out
+ }
+
+ if verb == "dynexport" {
+ verb = "cgo_export_dynamic"
+ }
+ if verb == "cgo_export_static" || verb == "cgo_export_dynamic" {
+ local = getimpsym(&q)
+ if local == "" {
+ goto err2
+ }
+ if !more(&q) {
+ pragcgobuf += fmt.Sprintf("%s %v\n", verb, plan9quote(local))
+ goto out
+ }
+
+ remote = getimpsym(&q)
+ if remote == "" {
+ goto err2
+ }
+ pragcgobuf += fmt.Sprintf("%s %v %v\n", verb, plan9quote(local), plan9quote(remote))
+ goto out
+
+ err2:
+ Yyerror("usage: //go:%s local [remote]", verb)
+ goto out
+ }
+
+ if verb == "cgo_import_dynamic" || verb == "dynimport" {
+ var ok bool
+ local = getimpsym(&q)
+ if local == "" {
+ goto err3
+ }
+ if !more(&q) {
+ pragcgobuf += fmt.Sprintf("cgo_import_dynamic %v\n", plan9quote(local))
+ goto out
+ }
+
+ remote = getimpsym(&q)
+ if remote == "" {
+ goto err3
+ }
+ if !more(&q) {
+ pragcgobuf += fmt.Sprintf("cgo_import_dynamic %v %v\n", plan9quote(local), plan9quote(remote))
+ goto out
+ }
+
+ p, ok = getquoted(&q)
+ if !ok {
+ goto err3
+ }
+ pragcgobuf += fmt.Sprintf("cgo_import_dynamic %v %v %v\n", plan9quote(local), plan9quote(remote), plan9quote(p))
+ goto out
+
+ err3:
+ Yyerror("usage: //go:cgo_import_dynamic local [remote [\"library\"]]")
+ goto out
+ }
+
+ if verb == "cgo_import_static" {
+ local = getimpsym(&q)
+ if local == "" || more(&q) {
+ goto err4
+ }
+ pragcgobuf += fmt.Sprintf("cgo_import_static %v\n", plan9quote(local))
+ goto out
+
+ err4:
+ Yyerror("usage: //go:cgo_import_static local")
+ goto out
+ }
+
+ if verb == "cgo_ldflag" {
+ var ok bool
+ p, ok = getquoted(&q)
+ if !ok {
+ goto err5
+ }
+ pragcgobuf += fmt.Sprintf("cgo_ldflag %v\n", plan9quote(p))
+ goto out
+
+ err5:
+ Yyerror("usage: //go:cgo_ldflag \"arg\"")
+ goto out
+ }
+
+out:
+}
+
+type yy struct{}
+
+var yymsg []struct {
+ yystate, yychar int
+ msg string
+}
+
+func (yy) Lex(v *yySymType) int {
+ return int(yylex(v))
+}
+
+func (yy) Error(msg string) {
+ Yyerror("%s", msg)
+}
+
+func yyparse() {
+ yyParse(yy{})
+}
+
+func yylex(yylval *yySymType) int32 {
+ var lx int
+
+ lx = int(_yylex(yylval))
+
+ if curio.nlsemi != 0 && lx == EOF {
+ // Treat EOF as "end of line" for the purposes
+ // of inserting a semicolon.
+ lx = ';'
+ }
+
+ switch lx {
+ case LNAME,
+ LLITERAL,
+ LBREAK,
+ LCONTINUE,
+ LFALL,
+ LRETURN,
+ LINC,
+ LDEC,
+ ')',
+ '}',
+ ']':
+ curio.nlsemi = 1
+
+ default:
+ curio.nlsemi = 0
+ }
+
+ // Track last two tokens returned by yylex.
+ yyprev = yylast
+
+ yylast = lx
+ return int32(lx)
+}
+
+func getc() int {
+ var c int
+ var c1 int
+ var c2 int
+
+ c = curio.peekc
+ if c != 0 {
+ curio.peekc = curio.peekc1
+ curio.peekc1 = 0
+ goto check
+ }
+
+ if curio.bin == nil {
+ if len(curio.cp) == 0 {
+ c = 0
+ } else {
+ c = int(curio.cp[0])
+ curio.cp = curio.cp[1:]
+ }
+ } else {
+ loop:
+ c = obj.Bgetc(curio.bin)
+ if c == 0xef {
+ c1 = obj.Bgetc(curio.bin)
+ c2 = obj.Bgetc(curio.bin)
+ if c1 == 0xbb && c2 == 0xbf {
+ yyerrorl(int(lexlineno), "Unicode (UTF-8) BOM in middle of file")
+ goto loop
+ }
+
+ obj.Bungetc(curio.bin)
+ obj.Bungetc(curio.bin)
+ }
+ }
+
+check:
+ switch c {
+ case 0:
+ if curio.bin != nil {
+ Yyerror("illegal NUL byte")
+ break
+ }
+ fallthrough
+
+ // insert \n at EOF
+ case EOF:
+ if curio.eofnl != 0 || curio.last == '\n' {
+ return EOF
+ }
+ curio.eofnl = 1
+ c = '\n'
+ fallthrough
+
+ case '\n':
+ if pushedio.bin == nil {
+ lexlineno++
+ }
+ }
+
+ curio.last = c
+ return c
+}
+
+func ungetc(c int) {
+ curio.peekc1 = curio.peekc
+ curio.peekc = c
+ if c == '\n' && pushedio.bin == nil {
+ lexlineno--
+ }
+}
+
+func getr() int32 {
+ var buf [utf8.UTFMax]byte
+
+ for i := 0; ; i++ {
+ c := getc()
+ if i == 0 && c < utf8.RuneSelf {
+ return int32(c)
+ }
+ buf[i] = byte(c)
+ if i+1 == len(buf) || utf8.FullRune(buf[:i+1]) {
+ r, w := utf8.DecodeRune(buf[:i+1])
+ if r == utf8.RuneError && w == 1 {
+ lineno = lexlineno
+ Yyerror("illegal UTF-8 sequence % x", buf[:i+1])
+ }
+ return int32(r)
+ }
+ }
+}
+
+func escchar(e int, escflg *int, val *int64) int {
+ var i int
+ var u int
+ var c int
+ var l int64
+
+ *escflg = 0
+
+ c = int(getr())
+ switch c {
+ case EOF:
+ Yyerror("eof in string")
+ return 1
+
+ case '\n':
+ Yyerror("newline in string")
+ return 1
+
+ case '\\':
+ break
+
+ default:
+ if c == e {
+ return 1
+ }
+ *val = int64(c)
+ return 0
+ }
+
+ u = 0
+ c = int(getr())
+ switch c {
+ case 'x':
+ *escflg = 1 // it's a byte
+ i = 2
+ goto hex
+
+ case 'u':
+ i = 4
+ u = 1
+ goto hex
+
+ case 'U':
+ i = 8
+ u = 1
+ goto hex
+
+ case '0',
+ '1',
+ '2',
+ '3',
+ '4',
+ '5',
+ '6',
+ '7':
+ *escflg = 1 // it's a byte
+ goto oct
+
+ case 'a':
+ c = '\a'
+ case 'b':
+ c = '\b'
+ case 'f':
+ c = '\f'
+ case 'n':
+ c = '\n'
+ case 'r':
+ c = '\r'
+ case 't':
+ c = '\t'
+ case 'v':
+ c = '\v'
+ case '\\':
+ c = '\\'
+
+ default:
+ if c != e {
+ Yyerror("unknown escape sequence: %c", c)
+ }
+ }
+
+ *val = int64(c)
+ return 0
+
+hex:
+ l = 0
+ for ; i > 0; i-- {
+ c = getc()
+ if c >= '0' && c <= '9' {
+ l = l*16 + int64(c) - '0'
+ continue
+ }
+
+ if c >= 'a' && c <= 'f' {
+ l = l*16 + int64(c) - 'a' + 10
+ continue
+ }
+
+ if c >= 'A' && c <= 'F' {
+ l = l*16 + int64(c) - 'A' + 10
+ continue
+ }
+
+ Yyerror("non-hex character in escape sequence: %c", c)
+ ungetc(c)
+ break
+ }
+
+ if u != 0 && (l > utf8.MaxRune || (0xd800 <= l && l < 0xe000)) {
+ Yyerror("invalid Unicode code point in escape sequence: %#x", l)
+ l = utf8.RuneError
+ }
+
+ *val = l
+ return 0
+
+oct:
+ l = int64(c) - '0'
+ for i = 2; i > 0; i-- {
+ c = getc()
+ if c >= '0' && c <= '7' {
+ l = l*8 + int64(c) - '0'
+ continue
+ }
+
+ Yyerror("non-octal character in escape sequence: %c", c)
+ ungetc(c)
+ }
+
+ if l > 255 {
+ Yyerror("octal escape value > 255: %d", l)
+ }
+
+ *val = l
+ return 0
+}
+
+var syms = []struct {
+ name string
+ lexical int
+ etype int
+ op int
+}{
+ /* name lexical etype op
+ */
+ /* basic types */
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"int8", LNAME, TINT8, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"int16", LNAME, TINT16, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"int32", LNAME, TINT32, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"int64", LNAME, TINT64, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"uint8", LNAME, TUINT8, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"uint16", LNAME, TUINT16, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"uint32", LNAME, TUINT32, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"uint64", LNAME, TUINT64, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"float32", LNAME, TFLOAT32, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"float64", LNAME, TFLOAT64, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"complex64", LNAME, TCOMPLEX64, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"complex128", LNAME, TCOMPLEX128, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"bool", LNAME, TBOOL, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"string", LNAME, TSTRING, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"any", LNAME, TANY, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"break", LBREAK, Txxx, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"case", LCASE, Txxx, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"chan", LCHAN, Txxx, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"const", LCONST, Txxx, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"continue", LCONTINUE, Txxx, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"default", LDEFAULT, Txxx, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"else", LELSE, Txxx, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"defer", LDEFER, Txxx, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"fallthrough", LFALL, Txxx, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"for", LFOR, Txxx, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"func", LFUNC, Txxx, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"go", LGO, Txxx, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"goto", LGOTO, Txxx, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"if", LIF, Txxx, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"import", LIMPORT, Txxx, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"interface", LINTERFACE, Txxx, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"map", LMAP, Txxx, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"package", LPACKAGE, Txxx, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"range", LRANGE, Txxx, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"return", LRETURN, Txxx, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"select", LSELECT, Txxx, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"struct", LSTRUCT, Txxx, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"switch", LSWITCH, Txxx, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"type", LTYPE, Txxx, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"var", LVAR, Txxx, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"append", LNAME, Txxx, OAPPEND},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"cap", LNAME, Txxx, OCAP},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"close", LNAME, Txxx, OCLOSE},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"complex", LNAME, Txxx, OCOMPLEX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"copy", LNAME, Txxx, OCOPY},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"delete", LNAME, Txxx, ODELETE},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"imag", LNAME, Txxx, OIMAG},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"len", LNAME, Txxx, OLEN},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"make", LNAME, Txxx, OMAKE},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"new", LNAME, Txxx, ONEW},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"panic", LNAME, Txxx, OPANIC},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"print", LNAME, Txxx, OPRINT},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"println", LNAME, Txxx, OPRINTN},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"real", LNAME, Txxx, OREAL},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"recover", LNAME, Txxx, ORECOVER},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"notwithstanding", LIGNORE, Txxx, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"thetruthofthematter", LIGNORE, Txxx, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"despiteallobjections", LIGNORE, Txxx, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"whereas", LIGNORE, Txxx, OXXX},
+ struct {
+ name string
+ lexical int
+ etype int
+ op int
+ }{"insofaras", LIGNORE, Txxx, OXXX},
+}
+
+func lexinit() {
+ var i int
+ var lex int
+ var s *Sym
+ var s1 *Sym
+ var t *Type
+ var etype int
+ var v Val
+
+ /*
+ * initialize basic types array
+ * initialize known symbols
+ */
+ for i = 0; i < len(syms); i++ {
+ lex = syms[i].lexical
+ s = Lookup(syms[i].name)
+ s.Lexical = uint16(lex)
+
+ etype = syms[i].etype
+ if etype != Txxx {
+ if etype < 0 || etype >= len(Types) {
+ Fatal("lexinit: %s bad etype", s.Name)
+ }
+ s1 = Pkglookup(syms[i].name, builtinpkg)
+ t = Types[etype]
+ if t == nil {
+ t = typ(etype)
+ t.Sym = s1
+
+ if etype != TANY && etype != TSTRING {
+ dowidth(t)
+ }
+ Types[etype] = t
+ }
+
+ s1.Lexical = LNAME
+ s1.Def = typenod(t)
+ continue
+ }
+
+ etype = syms[i].op
+ if etype != OXXX {
+ s1 = Pkglookup(syms[i].name, builtinpkg)
+ s1.Lexical = LNAME
+ s1.Def = Nod(ONAME, nil, nil)
+ s1.Def.Sym = s1
+ s1.Def.Etype = uint8(etype)
+ s1.Def.Builtin = 1
+ }
+ }
+
+ // logically, the type of a string literal.
+ // types[TSTRING] is the named type string
+ // (the type of x in var x string or var x = "hello").
+ // this is the ideal form
+ // (the type of x in const x = "hello").
+ idealstring = typ(TSTRING)
+
+ idealbool = typ(TBOOL)
+
+ s = Pkglookup("true", builtinpkg)
+ s.Def = Nodbool(1)
+ s.Def.Sym = Lookup("true")
+ s.Def.Type = idealbool
+
+ s = Pkglookup("false", builtinpkg)
+ s.Def = Nodbool(0)
+ s.Def.Sym = Lookup("false")
+ s.Def.Type = idealbool
+
+ s = Lookup("_")
+ s.Block = -100
+ s.Def = Nod(ONAME, nil, nil)
+ s.Def.Sym = s
+ Types[TBLANK] = typ(TBLANK)
+ s.Def.Type = Types[TBLANK]
+ nblank = s.Def
+
+ s = Pkglookup("_", builtinpkg)
+ s.Block = -100
+ s.Def = Nod(ONAME, nil, nil)
+ s.Def.Sym = s
+ Types[TBLANK] = typ(TBLANK)
+ s.Def.Type = Types[TBLANK]
+
+ Types[TNIL] = typ(TNIL)
+ s = Pkglookup("nil", builtinpkg)
+ v.Ctype = CTNIL
+ s.Def = nodlit(v)
+ s.Def.Sym = s
+}
+
+func lexinit1() {
+ var s *Sym
+ var s1 *Sym
+ var t *Type
+ var f *Type
+ var rcvr *Type
+ var in *Type
+ var out *Type
+
+ // t = interface { Error() string }
+ rcvr = typ(TSTRUCT)
+
+ rcvr.Type = typ(TFIELD)
+ rcvr.Type.Type = Ptrto(typ(TSTRUCT))
+ rcvr.Funarg = 1
+ in = typ(TSTRUCT)
+ in.Funarg = 1
+ out = typ(TSTRUCT)
+ out.Type = typ(TFIELD)
+ out.Type.Type = Types[TSTRING]
+ out.Funarg = 1
+ f = typ(TFUNC)
+ *getthis(f) = rcvr
+ *Getoutarg(f) = out
+ *getinarg(f) = in
+ f.Thistuple = 1
+ f.Intuple = 0
+ f.Outnamed = 0
+ f.Outtuple = 1
+ t = typ(TINTER)
+ t.Type = typ(TFIELD)
+ t.Type.Sym = Lookup("Error")
+ t.Type.Type = f
+
+ // error type
+ s = Lookup("error")
+
+ s.Lexical = LNAME
+ s1 = Pkglookup("error", builtinpkg)
+ errortype = t
+ errortype.Sym = s1
+ s1.Lexical = LNAME
+ s1.Def = typenod(errortype)
+
+ // byte alias
+ s = Lookup("byte")
+
+ s.Lexical = LNAME
+ s1 = Pkglookup("byte", builtinpkg)
+ bytetype = typ(TUINT8)
+ bytetype.Sym = s1
+ s1.Lexical = LNAME
+ s1.Def = typenod(bytetype)
+
+ // rune alias
+ s = Lookup("rune")
+
+ s.Lexical = LNAME
+ s1 = Pkglookup("rune", builtinpkg)
+ runetype = typ(TINT32)
+ runetype.Sym = s1
+ s1.Lexical = LNAME
+ s1.Def = typenod(runetype)
+}
+
+func lexfini() {
+ var s *Sym
+ var lex int
+ var etype int
+ var i int
+ var v Val
+
+ for i = 0; i < len(syms); i++ {
+ lex = syms[i].lexical
+ if lex != LNAME {
+ continue
+ }
+ s = Lookup(syms[i].name)
+ s.Lexical = uint16(lex)
+
+ etype = syms[i].etype
+ if etype != Txxx && (etype != TANY || Debug['A'] != 0) && s.Def == nil {
+ s.Def = typenod(Types[etype])
+ s.Origpkg = builtinpkg
+ }
+
+ etype = syms[i].op
+ if etype != OXXX && s.Def == nil {
+ s.Def = Nod(ONAME, nil, nil)
+ s.Def.Sym = s
+ s.Def.Etype = uint8(etype)
+ s.Def.Builtin = 1
+ s.Origpkg = builtinpkg
+ }
+ }
+
+ // backend-specific builtin types (e.g. int).
+ for i = range Thearch.Typedefs {
+ s = Lookup(Thearch.Typedefs[i].Name)
+ if s.Def == nil {
+ s.Def = typenod(Types[Thearch.Typedefs[i].Etype])
+ s.Origpkg = builtinpkg
+ }
+ }
+
+ // there's only so much table-driven we can handle.
+ // these are special cases.
+ s = Lookup("byte")
+
+ if s.Def == nil {
+ s.Def = typenod(bytetype)
+ s.Origpkg = builtinpkg
+ }
+
+ s = Lookup("error")
+ if s.Def == nil {
+ s.Def = typenod(errortype)
+ s.Origpkg = builtinpkg
+ }
+
+ s = Lookup("rune")
+ if s.Def == nil {
+ s.Def = typenod(runetype)
+ s.Origpkg = builtinpkg
+ }
+
+ s = Lookup("nil")
+ if s.Def == nil {
+ v.Ctype = CTNIL
+ s.Def = nodlit(v)
+ s.Def.Sym = s
+ s.Origpkg = builtinpkg
+ }
+
+ s = Lookup("iota")
+ if s.Def == nil {
+ s.Def = Nod(OIOTA, nil, nil)
+ s.Def.Sym = s
+ s.Origpkg = builtinpkg
+ }
+
+ s = Lookup("true")
+ if s.Def == nil {
+ s.Def = Nodbool(1)
+ s.Def.Sym = s
+ s.Origpkg = builtinpkg
+ }
+
+ s = Lookup("false")
+ if s.Def == nil {
+ s.Def = Nodbool(0)
+ s.Def.Sym = s
+ s.Origpkg = builtinpkg
+ }
+
+ nodfp = Nod(ONAME, nil, nil)
+ nodfp.Type = Types[TINT32]
+ nodfp.Xoffset = 0
+ nodfp.Class = PPARAM
+ nodfp.Sym = Lookup(".fp")
+}
+
+var lexn = []struct {
+ lex int
+ name string
+}{
+ struct {
+ lex int
+ name string
+ }{LANDAND, "ANDAND"},
+ struct {
+ lex int
+ name string
+ }{LANDNOT, "ANDNOT"},
+ struct {
+ lex int
+ name string
+ }{LASOP, "ASOP"},
+ struct {
+ lex int
+ name string
+ }{LBREAK, "BREAK"},
+ struct {
+ lex int
+ name string
+ }{LCASE, "CASE"},
+ struct {
+ lex int
+ name string
+ }{LCHAN, "CHAN"},
+ struct {
+ lex int
+ name string
+ }{LCOLAS, "COLAS"},
+ struct {
+ lex int
+ name string
+ }{LCOMM, "<-"},
+ struct {
+ lex int
+ name string
+ }{LCONST, "CONST"},
+ struct {
+ lex int
+ name string
+ }{LCONTINUE, "CONTINUE"},
+ struct {
+ lex int
+ name string
+ }{LDDD, "..."},
+ struct {
+ lex int
+ name string
+ }{LDEC, "DEC"},
+ struct {
+ lex int
+ name string
+ }{LDEFAULT, "DEFAULT"},
+ struct {
+ lex int
+ name string
+ }{LDEFER, "DEFER"},
+ struct {
+ lex int
+ name string
+ }{LELSE, "ELSE"},
+ struct {
+ lex int
+ name string
+ }{LEQ, "EQ"},
+ struct {
+ lex int
+ name string
+ }{LFALL, "FALL"},
+ struct {
+ lex int
+ name string
+ }{LFOR, "FOR"},
+ struct {
+ lex int
+ name string
+ }{LFUNC, "FUNC"},
+ struct {
+ lex int
+ name string
+ }{LGE, "GE"},
+ struct {
+ lex int
+ name string
+ }{LGO, "GO"},
+ struct {
+ lex int
+ name string
+ }{LGOTO, "GOTO"},
+ struct {
+ lex int
+ name string
+ }{LGT, "GT"},
+ struct {
+ lex int
+ name string
+ }{LIF, "IF"},
+ struct {
+ lex int
+ name string
+ }{LIMPORT, "IMPORT"},
+ struct {
+ lex int
+ name string
+ }{LINC, "INC"},
+ struct {
+ lex int
+ name string
+ }{LINTERFACE, "INTERFACE"},
+ struct {
+ lex int
+ name string
+ }{LLE, "LE"},
+ struct {
+ lex int
+ name string
+ }{LLITERAL, "LITERAL"},
+ struct {
+ lex int
+ name string
+ }{LLSH, "LSH"},
+ struct {
+ lex int
+ name string
+ }{LLT, "LT"},
+ struct {
+ lex int
+ name string
+ }{LMAP, "MAP"},
+ struct {
+ lex int
+ name string
+ }{LNAME, "NAME"},
+ struct {
+ lex int
+ name string
+ }{LNE, "NE"},
+ struct {
+ lex int
+ name string
+ }{LOROR, "OROR"},
+ struct {
+ lex int
+ name string
+ }{LPACKAGE, "PACKAGE"},
+ struct {
+ lex int
+ name string
+ }{LRANGE, "RANGE"},
+ struct {
+ lex int
+ name string
+ }{LRETURN, "RETURN"},
+ struct {
+ lex int
+ name string
+ }{LRSH, "RSH"},
+ struct {
+ lex int
+ name string
+ }{LSELECT, "SELECT"},
+ struct {
+ lex int
+ name string
+ }{LSTRUCT, "STRUCT"},
+ struct {
+ lex int
+ name string
+ }{LSWITCH, "SWITCH"},
+ struct {
+ lex int
+ name string
+ }{LTYPE, "TYPE"},
+ struct {
+ lex int
+ name string
+ }{LVAR, "VAR"},
+}
+
+var lexname_buf string
+
+func lexname(lex int) string {
+ var i int
+
+ for i = 0; i < len(lexn); i++ {
+ if lexn[i].lex == lex {
+ return lexn[i].name
+ }
+ }
+ lexname_buf = fmt.Sprintf("LEX-%d", lex)
+ return lexname_buf
+}
+
+var yytfix = []struct {
+ have string
+ want string
+}{
+ struct {
+ have string
+ want string
+ }{"$end", "EOF"},
+ struct {
+ have string
+ want string
+ }{"LLITERAL", "literal"},
+ struct {
+ have string
+ want string
+ }{"LASOP", "op="},
+ struct {
+ have string
+ want string
+ }{"LBREAK", "break"},
+ struct {
+ have string
+ want string
+ }{"LCASE", "case"},
+ struct {
+ have string
+ want string
+ }{"LCHAN", "chan"},
+ struct {
+ have string
+ want string
+ }{"LCOLAS", ":="},
+ struct {
+ have string
+ want string
+ }{"LCONST", "const"},
+ struct {
+ have string
+ want string
+ }{"LCONTINUE", "continue"},
+ struct {
+ have string
+ want string
+ }{"LDDD", "..."},
+ struct {
+ have string
+ want string
+ }{"LDEFAULT", "default"},
+ struct {
+ have string
+ want string
+ }{"LDEFER", "defer"},
+ struct {
+ have string
+ want string
+ }{"LELSE", "else"},
+ struct {
+ have string
+ want string
+ }{"LFALL", "fallthrough"},
+ struct {
+ have string
+ want string
+ }{"LFOR", "for"},
+ struct {
+ have string
+ want string
+ }{"LFUNC", "func"},
+ struct {
+ have string
+ want string
+ }{"LGO", "go"},
+ struct {
+ have string
+ want string
+ }{"LGOTO", "goto"},
+ struct {
+ have string
+ want string
+ }{"LIF", "if"},
+ struct {
+ have string
+ want string
+ }{"LIMPORT", "import"},
+ struct {
+ have string
+ want string
+ }{"LINTERFACE", "interface"},
+ struct {
+ have string
+ want string
+ }{"LMAP", "map"},
+ struct {
+ have string
+ want string
+ }{"LNAME", "name"},
+ struct {
+ have string
+ want string
+ }{"LPACKAGE", "package"},
+ struct {
+ have string
+ want string
+ }{"LRANGE", "range"},
+ struct {
+ have string
+ want string
+ }{"LRETURN", "return"},
+ struct {
+ have string
+ want string
+ }{"LSELECT", "select"},
+ struct {
+ have string
+ want string
+ }{"LSTRUCT", "struct"},
+ struct {
+ have string
+ want string
+ }{"LSWITCH", "switch"},
+ struct {
+ have string
+ want string
+ }{"LTYPE", "type"},
+ struct {
+ have string
+ want string
+ }{"LVAR", "var"},
+ struct {
+ have string
+ want string
+ }{"LANDAND", "&&"},
+ struct {
+ have string
+ want string
+ }{"LANDNOT", "&^"},
+ struct {
+ have string
+ want string
+ }{"LBODY", "{"},
+ struct {
+ have string
+ want string
+ }{"LCOMM", "<-"},
+ struct {
+ have string
+ want string
+ }{"LDEC", "--"},
+ struct {
+ have string
+ want string
+ }{"LINC", "++"},
+ struct {
+ have string
+ want string
+ }{"LEQ", "=="},
+ struct {
+ have string
+ want string
+ }{"LGE", ">="},
+ struct {
+ have string
+ want string
+ }{"LGT", ">"},
+ struct {
+ have string
+ want string
+ }{"LLE", "<="},
+ struct {
+ have string
+ want string
+ }{"LLT", "<"},
+ struct {
+ have string
+ want string
+ }{"LLSH", "<<"},
+ struct {
+ have string
+ want string
+ }{"LRSH", ">>"},
+ struct {
+ have string
+ want string
+ }{"LOROR", "||"},
+ struct {
+ have string
+ want string
+ }{"LNE", "!="},
+ // spell out to avoid confusion with punctuation in error messages
+ struct {
+ have string
+ want string
+ }{"';'", "semicolon or newline"},
+ struct {
+ have string
+ want string
+ }{"','", "comma"},
+}
+
+func pkgnotused(lineno int, path_ *Strlit, name string) {
+ var elem string
+
+ // If the package was imported with a name other than the final
+ // import path element, show it explicitly in the error message.
+ // Note that this handles both renamed imports and imports of
+ // packages containing unconventional package declarations.
+ // Note that this uses / always, even on Windows, because Go import
+ // paths always use forward slashes.
+ elem = path_.S
+ if i := strings.LastIndex(elem, "/"); i >= 0 {
+ elem = elem[i+1:]
+ }
+ if name == "" || elem == name {
+ yyerrorl(int(lineno), "imported and not used: \"%v\"", Zconv(path_, 0))
+ } else {
+ yyerrorl(int(lineno), "imported and not used: \"%v\" as %s", Zconv(path_, 0), name)
+ }
+}
+
+func mkpackage(pkgname string) {
+ var s *Sym
+ var h int32
+ var p string
+
+ if localpkg.Name == "" {
+ if pkgname == "_" {
+ Yyerror("invalid package name _")
+ }
+ localpkg.Name = pkgname
+ } else {
+ if pkgname != localpkg.Name {
+ Yyerror("package %s; expected %s", pkgname, localpkg.Name)
+ }
+ for h = 0; h < NHASH; h++ {
+ for s = hash[h]; s != nil; s = s.Link {
+ if s.Def == nil || s.Pkg != localpkg {
+ continue
+ }
+ if s.Def.Op == OPACK {
+ // throw away top-level package name leftover
+ // from previous file.
+ // leave s->block set to cause redeclaration
+ // errors if a conflicting top-level name is
+ // introduced by a different file.
+ if !(s.Def.Used != 0) && !(nsyntaxerrors != 0) {
+ pkgnotused(int(s.Def.Lineno), s.Def.Pkg.Path, s.Name)
+ }
+ s.Def = nil
+ continue
+ }
+
+ if s.Def.Sym != s {
+ // throw away top-level name left over
+ // from previous import . "x"
+ if s.Def.Pack != nil && !(s.Def.Pack.Used != 0) && !(nsyntaxerrors != 0) {
+ pkgnotused(int(s.Def.Pack.Lineno), s.Def.Pack.Pkg.Path, "")
+ s.Def.Pack.Used = 1
+ }
+
+ s.Def = nil
+ continue
+ }
+ }
+ }
+ }
+
+ if outfile == "" {
+ p = infile
+ if i := strings.LastIndex(p, "/"); i >= 0 {
+ p = p[i+1:]
+ }
+ if Ctxt.Windows != 0 {
+ if i := strings.LastIndex(p, `\`); i >= 0 {
+ p = p[i+1:]
+ }
+ }
+ namebuf = p
+ if i := strings.LastIndex(namebuf, "."); i >= 0 {
+ namebuf = namebuf[:i]
+ }
+ outfile = fmt.Sprintf("%s.%c", namebuf, Thearch.Thechar)
+ }
+}
diff --git a/src/cmd/internal/gc/md5.go b/src/cmd/internal/gc/md5.go
new file mode 100644
index 0000000..862fdd5
--- /dev/null
+++ b/src/cmd/internal/gc/md5.go
@@ -0,0 +1,329 @@
+// 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
+
+// 64-bit MD5 (does full MD5 but returns 64 bits only).
+// Translation of ../../crypto/md5/md5*.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.
+
+type MD5 struct {
+ s [4]uint32
+ x [64]uint8
+ nx int
+ len uint64
+}
+
+const (
+ _Chunk = 64
+)
+
+const (
+ _Init0 = 0x67452301
+ _Init1 = 0xEFCDAB89
+ _Init2 = 0x98BADCFE
+ _Init3 = 0x10325476
+)
+
+func md5reset(d *MD5) {
+ d.s[0] = _Init0
+ d.s[1] = _Init1
+ d.s[2] = _Init2
+ d.s[3] = _Init3
+ d.nx = 0
+ d.len = 0
+}
+
+func md5write(d *MD5, p []byte, nn int) {
+ var i int
+ var n int
+
+ d.len += uint64(nn)
+ if d.nx > 0 {
+ n = nn
+ if n > _Chunk-d.nx {
+ n = _Chunk - d.nx
+ }
+ for i = 0; i < n; i++ {
+ d.x[d.nx+i] = uint8(p[i])
+ }
+ d.nx += n
+ if d.nx == _Chunk {
+ md5block(d, d.x[:], _Chunk)
+ d.nx = 0
+ }
+
+ p = p[n:]
+ nn -= n
+ }
+
+ n = md5block(d, p, nn)
+ p = p[n:]
+ nn -= n
+ if nn > 0 {
+ for i = 0; i < nn; i++ {
+ d.x[i] = uint8(p[i])
+ }
+ d.nx = nn
+ }
+}
+
+func md5sum(d *MD5, hi *uint64) uint64 {
+ var tmp [64]uint8
+ var i int
+ var len uint64
+
+ // Padding. Add a 1 bit and 0 bits until 56 bytes mod 64.
+ len = d.len
+
+ tmp = [64]uint8{}
+ tmp[0] = 0x80
+ if len%64 < 56 {
+ md5write(d, tmp[:], int(56-len%64))
+ } else {
+ md5write(d, tmp[:], int(64+56-len%64))
+ }
+
+ // Length in bits.
+ len <<= 3
+
+ for i = 0; i < 8; i++ {
+ tmp[i] = uint8(len >> uint(8*i))
+ }
+ md5write(d, tmp[:], 8)
+
+ if d.nx != 0 {
+ Fatal("md5sum")
+ }
+
+ if hi != nil {
+ *hi = uint64(d.s[2]) | uint64(d.s[3])<<32
+ }
+ return uint64(d.s[0]) | uint64(d.s[1])<<32
+}
+
+// MD5 block step.
+// In its own file so that a faster assembly or C version
+// can be substituted easily.
+
+// table[i] = int((1<<32) * abs(sin(i+1 radians))).
+var table = [64]uint32{
+ // round 1
+ 0xd76aa478,
+ 0xe8c7b756,
+ 0x242070db,
+ 0xc1bdceee,
+ 0xf57c0faf,
+ 0x4787c62a,
+ 0xa8304613,
+ 0xfd469501,
+ 0x698098d8,
+ 0x8b44f7af,
+ 0xffff5bb1,
+ 0x895cd7be,
+ 0x6b901122,
+ 0xfd987193,
+ 0xa679438e,
+ 0x49b40821,
+
+ // round 2
+ 0xf61e2562,
+ 0xc040b340,
+ 0x265e5a51,
+ 0xe9b6c7aa,
+ 0xd62f105d,
+ 0x2441453,
+ 0xd8a1e681,
+ 0xe7d3fbc8,
+ 0x21e1cde6,
+ 0xc33707d6,
+ 0xf4d50d87,
+ 0x455a14ed,
+ 0xa9e3e905,
+ 0xfcefa3f8,
+ 0x676f02d9,
+ 0x8d2a4c8a,
+
+ // round3
+ 0xfffa3942,
+ 0x8771f681,
+ 0x6d9d6122,
+ 0xfde5380c,
+ 0xa4beea44,
+ 0x4bdecfa9,
+ 0xf6bb4b60,
+ 0xbebfbc70,
+ 0x289b7ec6,
+ 0xeaa127fa,
+ 0xd4ef3085,
+ 0x4881d05,
+ 0xd9d4d039,
+ 0xe6db99e5,
+ 0x1fa27cf8,
+ 0xc4ac5665,
+
+ // round 4
+ 0xf4292244,
+ 0x432aff97,
+ 0xab9423a7,
+ 0xfc93a039,
+ 0x655b59c3,
+ 0x8f0ccc92,
+ 0xffeff47d,
+ 0x85845dd1,
+ 0x6fa87e4f,
+ 0xfe2ce6e0,
+ 0xa3014314,
+ 0x4e0811a1,
+ 0xf7537e82,
+ 0xbd3af235,
+ 0x2ad7d2bb,
+ 0xeb86d391,
+}
+
+var shift1 = []uint32{7, 12, 17, 22}
+
+var shift2 = []uint32{5, 9, 14, 20}
+
+var shift3 = []uint32{4, 11, 16, 23}
+
+var shift4 = []uint32{6, 10, 15, 21}
+
+func md5block(dig *MD5, p []byte, nn int) int {
+ var a uint32
+ var b uint32
+ var c uint32
+ var d uint32
+ var aa uint32
+ var bb uint32
+ var cc uint32
+ var dd uint32
+ var i int
+ var j int
+ var n int
+ var X [16]uint32
+
+ a = dig.s[0]
+ b = dig.s[1]
+ c = dig.s[2]
+ d = dig.s[3]
+ n = 0
+
+ for nn >= _Chunk {
+ aa = a
+ bb = b
+ cc = c
+ dd = d
+
+ for i = 0; i < 16; i++ {
+ j = i * 4
+ X[i] = uint32(p[j]) | uint32(p[j+1])<<8 | uint32(p[j+2])<<16 | uint32(p[j+3])<<24
+ }
+
+ // Round 1.
+ for i = 0; i < 16; i++ {
+ var x uint32
+ var t uint32
+ var s uint32
+ var f uint32
+ x = uint32(i)
+ t = uint32(i)
+ s = shift1[i%4]
+ f = ((c ^ d) & b) ^ d
+ a += f + X[x] + table[t]
+ a = a<<s | a>>(32-s)
+ a += b
+
+ t = d
+ d = c
+ c = b
+ b = a
+ a = t
+ }
+
+ // Round 2.
+ for i = 0; i < 16; i++ {
+ var x uint32
+ var t uint32
+ var s uint32
+ var g uint32
+
+ x = (1 + 5*uint32(i)) % 16
+ t = 16 + uint32(i)
+ s = shift2[i%4]
+ g = ((b ^ c) & d) ^ c
+ a += g + X[x] + table[t]
+ a = a<<s | a>>(32-s)
+ a += b
+
+ t = d
+ d = c
+ c = b
+ b = a
+ a = t
+ }
+
+ // Round 3.
+ for i = 0; i < 16; i++ {
+ var x uint32
+ var t uint32
+ var s uint32
+ var h uint32
+
+ x = (5 + 3*uint32(i)) % 16
+ t = 32 + uint32(i)
+ s = shift3[i%4]
+ h = b ^ c ^ d
+ a += h + X[x] + table[t]
+ a = a<<s | a>>(32-s)
+ a += b
+
+ t = d
+ d = c
+ c = b
+ b = a
+ a = t
+ }
+
+ // Round 4.
+ for i = 0; i < 16; i++ {
+ var x uint32
+ var s uint32
+ var t uint32
+ var ii uint32
+
+ x = (7 * uint32(i)) % 16
+ s = shift4[i%4]
+ t = 48 + uint32(i)
+ ii = c ^ (b | ^d)
+ a += ii + X[x] + table[t]
+ a = a<<s | a>>(32-s)
+ a += b
+
+ t = d
+ d = c
+ c = b
+ b = a
+ a = t
+ }
+
+ a += aa
+ b += bb
+ c += cc
+ d += dd
+
+ p = p[_Chunk:]
+ n += _Chunk
+ nn -= _Chunk
+ }
+
+ dig.s[0] = a
+ dig.s[1] = b
+ dig.s[2] = c
+ dig.s[3] = d
+ return n
+}
diff --git a/src/cmd/internal/gc/mparith1.go b/src/cmd/internal/gc/mparith1.go
new file mode 100644
index 0000000..45f16d9
--- /dev/null
+++ b/src/cmd/internal/gc/mparith1.go
@@ -0,0 +1,698 @@
+// 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
+
+import (
+ "cmd/internal/obj"
+ "fmt"
+ "math"
+)
+
+/// uses arithmetic
+
+func mpcmpfixflt(a *Mpint, b *Mpflt) int {
+ var buf string
+ var c Mpflt
+
+ buf = fmt.Sprintf("%v", Bconv(a, 0))
+ mpatoflt(&c, buf)
+ return mpcmpfltflt(&c, b)
+}
+
+func mpcmpfltfix(a *Mpflt, b *Mpint) int {
+ var buf string
+ var c Mpflt
+
+ buf = fmt.Sprintf("%v", Bconv(b, 0))
+ mpatoflt(&c, buf)
+ return mpcmpfltflt(a, &c)
+}
+
+func Mpcmpfixfix(a *Mpint, b *Mpint) int {
+ var c Mpint
+
+ mpmovefixfix(&c, a)
+ mpsubfixfix(&c, b)
+ return mptestfix(&c)
+}
+
+func mpcmpfixc(b *Mpint, c int64) int {
+ var c1 Mpint
+
+ Mpmovecfix(&c1, c)
+ return Mpcmpfixfix(b, &c1)
+}
+
+func mpcmpfltflt(a *Mpflt, b *Mpflt) int {
+ var c Mpflt
+
+ mpmovefltflt(&c, a)
+ mpsubfltflt(&c, b)
+ return mptestflt(&c)
+}
+
+func mpcmpfltc(b *Mpflt, c float64) int {
+ var a Mpflt
+
+ Mpmovecflt(&a, c)
+ return mpcmpfltflt(b, &a)
+}
+
+func mpsubfixfix(a *Mpint, b *Mpint) {
+ mpnegfix(a)
+ mpaddfixfix(a, b, 0)
+ mpnegfix(a)
+}
+
+func mpsubfltflt(a *Mpflt, b *Mpflt) {
+ mpnegflt(a)
+ mpaddfltflt(a, b)
+ mpnegflt(a)
+}
+
+func mpaddcfix(a *Mpint, c int64) {
+ var b Mpint
+
+ Mpmovecfix(&b, c)
+ mpaddfixfix(a, &b, 0)
+}
+
+func mpaddcflt(a *Mpflt, c float64) {
+ var b Mpflt
+
+ Mpmovecflt(&b, c)
+ mpaddfltflt(a, &b)
+}
+
+func mpmulcfix(a *Mpint, c int64) {
+ var b Mpint
+
+ Mpmovecfix(&b, c)
+ mpmulfixfix(a, &b)
+}
+
+func mpmulcflt(a *Mpflt, c float64) {
+ var b Mpflt
+
+ Mpmovecflt(&b, c)
+ mpmulfltflt(a, &b)
+}
+
+func mpdivfixfix(a *Mpint, b *Mpint) {
+ var q Mpint
+ var r Mpint
+
+ mpdivmodfixfix(&q, &r, a, b)
+ mpmovefixfix(a, &q)
+}
+
+func mpmodfixfix(a *Mpint, b *Mpint) {
+ var q Mpint
+ var r Mpint
+
+ mpdivmodfixfix(&q, &r, a, b)
+ mpmovefixfix(a, &r)
+}
+
+func mpcomfix(a *Mpint) {
+ var b Mpint
+
+ Mpmovecfix(&b, 1)
+ mpnegfix(a)
+ mpsubfixfix(a, &b)
+}
+
+func Mpmovefixflt(a *Mpflt, b *Mpint) {
+ a.Val = *b
+ a.Exp = 0
+ mpnorm(a)
+}
+
+// convert (truncate) b to a.
+// return -1 (but still convert) if b was non-integer.
+func mpexactfltfix(a *Mpint, b *Mpflt) int {
+ var f Mpflt
+
+ *a = b.Val
+ Mpshiftfix(a, int(b.Exp))
+ if b.Exp < 0 {
+ f.Val = *a
+ f.Exp = 0
+ mpnorm(&f)
+ if mpcmpfltflt(b, &f) != 0 {
+ return -1
+ }
+ }
+
+ return 0
+}
+
+func mpmovefltfix(a *Mpint, b *Mpflt) int {
+ var f Mpflt
+ var i int
+
+ if mpexactfltfix(a, b) == 0 {
+ return 0
+ }
+
+ // try rounding down a little
+ f = *b
+
+ f.Val.A[0] = 0
+ if mpexactfltfix(a, &f) == 0 {
+ return 0
+ }
+
+ // try rounding up a little
+ for i = 1; i < Mpprec; i++ {
+ f.Val.A[i]++
+ if f.Val.A[i] != Mpbase {
+ break
+ }
+ f.Val.A[i] = 0
+ }
+
+ mpnorm(&f)
+ if mpexactfltfix(a, &f) == 0 {
+ return 0
+ }
+
+ return -1
+}
+
+func mpmovefixfix(a *Mpint, b *Mpint) {
+ *a = *b
+}
+
+func mpmovefltflt(a *Mpflt, b *Mpflt) {
+ *a = *b
+}
+
+var tab = []float64{1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7}
+
+func mppow10flt(a *Mpflt, p int) {
+ if p < 0 {
+ panic("abort")
+ }
+ if p < len(tab) {
+ Mpmovecflt(a, tab[p])
+ return
+ }
+
+ mppow10flt(a, p>>1)
+ mpmulfltflt(a, a)
+ if p&1 != 0 {
+ mpmulcflt(a, 10)
+ }
+}
+
+func mphextofix(a *Mpint, s string) {
+ var c int8
+ var d int
+ var bit int
+ var hexdigitp int
+ var end int
+
+ for s != "" && s[0] == '0' {
+ s = s[1:]
+ }
+
+ // overflow
+ if 4*len(s) > Mpscale*Mpprec {
+ a.Ovf = 1
+ return
+ }
+
+ end = len(s) - 1
+ for hexdigitp = end; hexdigitp >= 0; hexdigitp-- {
+ c = int8(s[hexdigitp])
+ if c >= '0' && c <= '9' {
+ d = int(c) - '0'
+ } else if c >= 'A' && c <= 'F' {
+ d = int(c) - 'A' + 10
+ } else {
+ d = int(c) - 'a' + 10
+ }
+
+ bit = 4 * (end - hexdigitp)
+ for d > 0 {
+ if d&1 != 0 {
+ a.A[bit/Mpscale] |= int(1) << uint(bit%Mpscale)
+ }
+ bit++
+ d = d >> 1
+ }
+ }
+}
+
+//
+// floating point input
+// required syntax is [+-]d*[.]d*[e[+-]d*] or [+-]0xH*[e[+-]d*]
+//
+func mpatoflt(a *Mpflt, as string) {
+ var b Mpflt
+ var dp int
+ var c int
+ var f int
+ var ef int
+ var ex int
+ var eb int
+ var base int
+ var s string
+ var start string
+
+ for as[0] == ' ' || as[0] == '\t' {
+ as = as[1:]
+ }
+
+ /* determine base */
+ s = as
+
+ base = -1
+ for base == -1 {
+ if s == "" {
+ base = 10
+ break
+ }
+ c := s[0]
+ s = s[1:]
+ switch c {
+ case '-',
+ '+':
+ break
+
+ case '0':
+ if s != "" && s[0] == 'x' {
+ base = 16
+ } else {
+ base = 10
+ }
+
+ default:
+ base = 10
+ }
+ }
+
+ s = as
+ dp = 0 /* digits after decimal point */
+ f = 0 /* sign */
+ ex = 0 /* exponent */
+ eb = 0 /* binary point */
+
+ Mpmovecflt(a, 0.0)
+ if base == 16 {
+ start = ""
+ for {
+ c, _ = intstarstringplusplus(s)
+ if c == '-' {
+ f = 1
+ s = s[1:]
+ } else if c == '+' {
+ s = s[1:]
+ } else if c == '0' && s[1] == 'x' {
+ s = s[2:]
+ start = s
+ } else if (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F') {
+ s = s[1:]
+ } else {
+ break
+ }
+ }
+
+ if start == "" {
+ Yyerror("malformed hex constant: %s", as)
+ goto bad
+ }
+
+ mphextofix(&a.Val, start[:len(start)-len(s)])
+ if a.Val.Ovf != 0 {
+ Yyerror("constant too large: %s", as)
+ goto bad
+ }
+
+ a.Exp = 0
+ mpnorm(a)
+ }
+
+ for {
+ c, s = intstarstringplusplus(s)
+ switch c {
+ default:
+ Yyerror("malformed constant: %s (at %c)", as, c)
+ goto bad
+
+ case '-':
+ f = 1
+ fallthrough
+
+ case ' ',
+ '\t',
+ '+':
+ continue
+
+ case '.':
+ if base == 16 {
+ Yyerror("decimal point in hex constant: %s", as)
+ goto bad
+ }
+
+ dp = 1
+ continue
+
+ case '1',
+ '2',
+ '3',
+ '4',
+ '5',
+ '6',
+ '7',
+ '8',
+ '9',
+ '0':
+ mpmulcflt(a, 10)
+ mpaddcflt(a, float64(c)-'0')
+ if dp != 0 {
+ dp++
+ }
+ continue
+
+ case 'P',
+ 'p':
+ eb = 1
+ fallthrough
+
+ case 'E',
+ 'e':
+ ex = 0
+ ef = 0
+ for {
+ c, s = intstarstringplusplus(s)
+ if c == '+' || c == ' ' || c == '\t' {
+ continue
+ }
+ if c == '-' {
+ ef = 1
+ continue
+ }
+
+ if c >= '0' && c <= '9' {
+ ex = ex*10 + (c - '0')
+ if ex > 1e8 {
+ Yyerror("constant exponent out of range: %s", as)
+ errorexit()
+ }
+
+ continue
+ }
+
+ break
+ }
+
+ if ef != 0 {
+ ex = -ex
+ }
+ fallthrough
+
+ case 0:
+ break
+ }
+
+ break
+ }
+
+ if eb != 0 {
+ if dp != 0 {
+ Yyerror("decimal point and binary point in constant: %s", as)
+ goto bad
+ }
+
+ mpsetexp(a, int(a.Exp)+ex)
+ goto out
+ }
+
+ if dp != 0 {
+ dp--
+ }
+ if mpcmpfltc(a, 0.0) != 0 {
+ if ex >= dp {
+ mppow10flt(&b, ex-dp)
+ mpmulfltflt(a, &b)
+ } else {
+ // 4 approximates least_upper_bound(log2(10)).
+ if dp-ex >= 1<<(32-3) || int(int16(4*(dp-ex))) != 4*(dp-ex) {
+ Mpmovecflt(a, 0.0)
+ } else {
+ mppow10flt(&b, dp-ex)
+ mpdivfltflt(a, &b)
+ }
+ }
+ }
+
+out:
+ if f != 0 {
+ mpnegflt(a)
+ }
+ return
+
+bad:
+ Mpmovecflt(a, 0.0)
+}
+
+//
+// fixed point input
+// required syntax is [+-][0[x]]d*
+//
+func mpatofix(a *Mpint, as string) {
+ var c int
+ var f int
+ var s string
+ var s0 string
+
+ s = as
+ f = 0
+ Mpmovecfix(a, 0)
+
+ c, s = intstarstringplusplus(s)
+ switch c {
+ case '-':
+ f = 1
+ fallthrough
+
+ case '+':
+ c, s = intstarstringplusplus(s)
+ if c != '0' {
+ break
+ }
+ fallthrough
+
+ case '0':
+ goto oct
+ }
+
+ for c != 0 {
+ if c >= '0' && c <= '9' {
+ mpmulcfix(a, 10)
+ mpaddcfix(a, int64(c)-'0')
+ c, s = intstarstringplusplus(s)
+ continue
+ }
+
+ Yyerror("malformed decimal constant: %s", as)
+ goto bad
+ }
+
+ goto out
+
+oct:
+ c, s = intstarstringplusplus(s)
+ if c == 'x' || c == 'X' {
+ goto hex
+ }
+ for c != 0 {
+ if c >= '0' && c <= '7' {
+ mpmulcfix(a, 8)
+ mpaddcfix(a, int64(c)-'0')
+ c, s = intstarstringplusplus(s)
+ continue
+ }
+
+ Yyerror("malformed octal constant: %s", as)
+ goto bad
+ }
+
+ goto out
+
+hex:
+ s0 = s
+ c, _ = intstarstringplusplus(s)
+ for c != 0 {
+ if (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F') {
+ s = s[1:]
+ c, _ = intstarstringplusplus(s)
+ continue
+ }
+
+ Yyerror("malformed hex constant: %s", as)
+ goto bad
+ }
+
+ mphextofix(a, s0)
+ if a.Ovf != 0 {
+ Yyerror("constant too large: %s", as)
+ goto bad
+ }
+
+out:
+ if f != 0 {
+ mpnegfix(a)
+ }
+ return
+
+bad:
+ Mpmovecfix(a, 0)
+}
+
+func Bconv(xval *Mpint, flag int) string {
+ var buf [500]byte
+ var p int
+ var fp string
+
+ var q Mpint
+ var r Mpint
+ var ten Mpint
+ var sixteen Mpint
+ var f int
+ var digit int
+
+ mpmovefixfix(&q, xval)
+ f = 0
+ if mptestfix(&q) < 0 {
+ f = 1
+ mpnegfix(&q)
+ }
+
+ p = len(buf)
+ if flag&obj.FmtSharp != 0 /*untyped*/ {
+ // Hexadecimal
+ Mpmovecfix(&sixteen, 16)
+
+ for {
+ mpdivmodfixfix(&q, &r, &q, &sixteen)
+ digit = int(Mpgetfix(&r))
+ if digit < 10 {
+ p--
+ buf[p] = byte(digit + '0')
+ } else {
+ p--
+ buf[p] = byte(digit - 10 + 'A')
+ }
+ if mptestfix(&q) <= 0 {
+ break
+ }
+ }
+
+ p--
+ buf[p] = 'x'
+ p--
+ buf[p] = '0'
+ } else {
+ // Decimal
+ Mpmovecfix(&ten, 10)
+
+ for {
+ mpdivmodfixfix(&q, &r, &q, &ten)
+ p--
+ buf[p] = byte(Mpgetfix(&r) + '0')
+ if mptestfix(&q) <= 0 {
+ break
+ }
+ }
+ }
+
+ if f != 0 {
+ p--
+ buf[p] = '-'
+ }
+ fp += string(buf[p:])
+ return fp
+}
+
+func Fconv(fvp *Mpflt, flag int) string {
+ var buf string
+ var fp string
+
+ var fv Mpflt
+ var d float64
+ var dexp float64
+ var exp int
+
+ if flag&obj.FmtSharp != 0 /*untyped*/ {
+ // alternate form - decimal for error messages.
+ // for well in range, convert to double and use print's %g
+ exp = int(fvp.Exp) + sigfig(fvp)*Mpscale
+
+ if -900 < exp && exp < 900 {
+ d = mpgetflt(fvp)
+ if d >= 0 && (flag&obj.FmtSign != 0 /*untyped*/) {
+ fp += fmt.Sprintf("+")
+ }
+ fp += fmt.Sprintf("%g", d)
+ return fp
+ }
+
+ // very out of range. compute decimal approximation by hand.
+ // decimal exponent
+ dexp = float64(fvp.Exp) * 0.301029995663981195 // log_10(2)
+ exp = int(dexp)
+
+ // decimal mantissa
+ fv = *fvp
+
+ fv.Val.Neg = 0
+ fv.Exp = 0
+ d = mpgetflt(&fv)
+ d *= math.Pow(10, dexp-float64(exp))
+ for d >= 9.99995 {
+ d /= 10
+ exp++
+ }
+
+ if fvp.Val.Neg != 0 {
+ fp += fmt.Sprintf("-")
+ } else if flag&obj.FmtSign != 0 /*untyped*/ {
+ fp += fmt.Sprintf("+")
+ }
+ fp += fmt.Sprintf("%.5fe+%d", d, exp)
+ return fp
+ }
+
+ if sigfig(fvp) == 0 {
+ buf = fmt.Sprintf("0p+0")
+ goto out
+ }
+
+ fv = *fvp
+
+ for fv.Val.A[0] == 0 {
+ Mpshiftfix(&fv.Val, -Mpscale)
+ fv.Exp += Mpscale
+ }
+
+ for fv.Val.A[0]&1 == 0 {
+ Mpshiftfix(&fv.Val, -1)
+ fv.Exp += 1
+ }
+
+ if fv.Exp >= 0 {
+ buf = fmt.Sprintf("%vp+%d", Bconv(&fv.Val, obj.FmtSharp), fv.Exp)
+ goto out
+ }
+
+ buf = fmt.Sprintf("%vp-%d", Bconv(&fv.Val, obj.FmtSharp), -fv.Exp)
+
+out:
+ fp += buf
+ return fp
+}
diff --git a/src/cmd/internal/gc/mparith2.go b/src/cmd/internal/gc/mparith2.go
new file mode 100644
index 0000000..415adf0
--- /dev/null
+++ b/src/cmd/internal/gc/mparith2.go
@@ -0,0 +1,728 @@
+// 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
+
+//
+// return the significant
+// words of the argument
+//
+func mplen(a *Mpint) int {
+ var i int
+ var n int
+
+ n = -1
+ for i = 0; i < Mpprec; i++ {
+ if a.A[i] != 0 {
+ n = i
+ }
+ }
+
+ return n + 1
+}
+
+//
+// left shift mpint by one
+// ignores sign
+//
+func mplsh(a *Mpint, quiet int) {
+ var x int
+ var i int
+ var c int
+
+ c = 0
+ for i = 0; i < Mpprec; i++ {
+ x = (a.A[i] << 1) + c
+ c = 0
+ if x >= Mpbase {
+ x -= Mpbase
+ c = 1
+ }
+
+ a.A[i] = x
+ }
+
+ a.Ovf = uint8(c)
+ if a.Ovf != 0 && !(quiet != 0) {
+ Yyerror("constant shift overflow")
+ }
+}
+
+//
+// left shift mpint by Mpscale
+// ignores sign
+//
+func mplshw(a *Mpint, quiet int) {
+ var i int
+
+ i = Mpprec - 1
+ if a.A[i] != 0 {
+ a.Ovf = 1
+ if !(quiet != 0) {
+ Yyerror("constant shift overflow")
+ }
+ }
+
+ for ; i > 0; i-- {
+ a.A[i] = a.A[i-1]
+ }
+ a.A[i] = 0
+}
+
+//
+// right shift mpint by one
+// ignores sign and overflow
+//
+func mprsh(a *Mpint) {
+ var x int
+ var lo int
+ var i int
+ var c int
+
+ c = 0
+ lo = a.A[0] & 1
+ for i = Mpprec - 1; i >= 0; i-- {
+ x = a.A[i]
+ a.A[i] = (x + c) >> 1
+ c = 0
+ if x&1 != 0 {
+ c = Mpbase
+ }
+ }
+
+ if a.Neg != 0 && lo != 0 {
+ mpaddcfix(a, -1)
+ }
+}
+
+//
+// right shift mpint by Mpscale
+// ignores sign and overflow
+//
+func mprshw(a *Mpint) {
+ var lo int
+ var i int
+
+ lo = a.A[0]
+ for i = 0; i < Mpprec-1; i++ {
+ a.A[i] = a.A[i+1]
+ }
+
+ a.A[i] = 0
+ if a.Neg != 0 && lo != 0 {
+ mpaddcfix(a, -1)
+ }
+}
+
+//
+// return the sign of (abs(a)-abs(b))
+//
+func mpcmp(a *Mpint, b *Mpint) int {
+ var x int
+ var i int
+
+ if a.Ovf != 0 || b.Ovf != 0 {
+ if nsavederrors+nerrors == 0 {
+ Yyerror("ovf in cmp")
+ }
+ return 0
+ }
+
+ for i = Mpprec - 1; i >= 0; i-- {
+ x = a.A[i] - b.A[i]
+ if x > 0 {
+ return +1
+ }
+ if x < 0 {
+ return -1
+ }
+ }
+
+ return 0
+}
+
+//
+// negate a
+// ignore sign and ovf
+//
+func mpneg(a *Mpint) {
+ var x int
+ var i int
+ var c int
+
+ c = 0
+ for i = 0; i < Mpprec; i++ {
+ x = -a.A[i] - c
+ c = 0
+ if x < 0 {
+ x += Mpbase
+ c = 1
+ }
+
+ a.A[i] = x
+ }
+}
+
+// shift left by s (or right by -s)
+func Mpshiftfix(a *Mpint, s int) {
+ if s >= 0 {
+ for s >= Mpscale {
+ mplshw(a, 0)
+ s -= Mpscale
+ }
+
+ for s > 0 {
+ mplsh(a, 0)
+ s--
+ }
+ } else {
+ s = -s
+ for s >= Mpscale {
+ mprshw(a)
+ s -= Mpscale
+ }
+
+ for s > 0 {
+ mprsh(a)
+ s--
+ }
+ }
+}
+
+/// implements fix arihmetic
+
+func mpaddfixfix(a *Mpint, b *Mpint, quiet int) {
+ var i int
+ var c int
+ var x int
+
+ if a.Ovf != 0 || b.Ovf != 0 {
+ if nsavederrors+nerrors == 0 {
+ Yyerror("ovf in mpaddxx")
+ }
+ a.Ovf = 1
+ return
+ }
+
+ c = 0
+ if a.Neg != b.Neg {
+ goto sub
+ }
+
+ // perform a+b
+ for i = 0; i < Mpprec; i++ {
+ x = a.A[i] + b.A[i] + c
+ c = 0
+ if x >= Mpbase {
+ x -= Mpbase
+ c = 1
+ }
+
+ a.A[i] = x
+ }
+
+ a.Ovf = uint8(c)
+ if a.Ovf != 0 && !(quiet != 0) {
+ Yyerror("constant addition overflow")
+ }
+
+ return
+
+ // perform a-b
+sub:
+ switch mpcmp(a, b) {
+ case 0:
+ Mpmovecfix(a, 0)
+
+ case 1:
+ for i = 0; i < Mpprec; i++ {
+ x = a.A[i] - b.A[i] - c
+ c = 0
+ if x < 0 {
+ x += Mpbase
+ c = 1
+ }
+
+ a.A[i] = x
+ }
+
+ case -1:
+ a.Neg ^= 1
+ for i = 0; i < Mpprec; i++ {
+ x = b.A[i] - a.A[i] - c
+ c = 0
+ if x < 0 {
+ x += Mpbase
+ c = 1
+ }
+
+ a.A[i] = x
+ }
+ }
+}
+
+func mpmulfixfix(a *Mpint, b *Mpint) {
+ var i int
+ var j int
+ var na int
+ var nb int
+ var x int
+ var s Mpint
+ var q Mpint
+ var c *Mpint
+
+ if a.Ovf != 0 || b.Ovf != 0 {
+ if nsavederrors+nerrors == 0 {
+ Yyerror("ovf in mpmulfixfix")
+ }
+ a.Ovf = 1
+ return
+ }
+
+ // pick the smaller
+ // to test for bits
+ na = mplen(a)
+
+ nb = mplen(b)
+ if na > nb {
+ mpmovefixfix(&s, a)
+ c = b
+ na = nb
+ } else {
+ mpmovefixfix(&s, b)
+ c = a
+ }
+
+ s.Neg = 0
+
+ Mpmovecfix(&q, 0)
+ for i = 0; i < na; i++ {
+ x = c.A[i]
+ for j = 0; j < Mpscale; j++ {
+ if x&1 != 0 {
+ if s.Ovf != 0 {
+ q.Ovf = 1
+ goto out
+ }
+
+ mpaddfixfix(&q, &s, 1)
+ if q.Ovf != 0 {
+ goto out
+ }
+ }
+
+ mplsh(&s, 1)
+ x >>= 1
+ }
+ }
+
+out:
+ q.Neg = a.Neg ^ b.Neg
+ mpmovefixfix(a, &q)
+ if a.Ovf != 0 {
+ Yyerror("constant multiplication overflow")
+ }
+}
+
+func mpmulfract(a *Mpint, b *Mpint) {
+ var i int
+ var j int
+ var x int
+ var s Mpint
+ var q Mpint
+
+ if a.Ovf != 0 || b.Ovf != 0 {
+ if nsavederrors+nerrors == 0 {
+ Yyerror("ovf in mpmulflt")
+ }
+ a.Ovf = 1
+ return
+ }
+
+ mpmovefixfix(&s, b)
+ s.Neg = 0
+ Mpmovecfix(&q, 0)
+
+ i = Mpprec - 1
+ x = a.A[i]
+ if x != 0 {
+ Yyerror("mpmulfract not normal")
+ }
+
+ for i--; i >= 0; i-- {
+ x = a.A[i]
+ if x == 0 {
+ mprshw(&s)
+ continue
+ }
+
+ for j = 0; j < Mpscale; j++ {
+ x <<= 1
+ if x&Mpbase != 0 {
+ mpaddfixfix(&q, &s, 1)
+ }
+ mprsh(&s)
+ }
+ }
+
+ q.Neg = a.Neg ^ b.Neg
+ mpmovefixfix(a, &q)
+ if a.Ovf != 0 {
+ Yyerror("constant multiplication overflow")
+ }
+}
+
+func mporfixfix(a *Mpint, b *Mpint) {
+ var i int
+ var x int
+
+ x = 0
+ if a.Ovf != 0 || b.Ovf != 0 {
+ if nsavederrors+nerrors == 0 {
+ Yyerror("ovf in mporfixfix")
+ }
+ Mpmovecfix(a, 0)
+ a.Ovf = 1
+ return
+ }
+
+ if a.Neg != 0 {
+ a.Neg = 0
+ mpneg(a)
+ }
+
+ if b.Neg != 0 {
+ mpneg(b)
+ }
+
+ for i = 0; i < Mpprec; i++ {
+ x = a.A[i] | b.A[i]
+ a.A[i] = x
+ }
+
+ if b.Neg != 0 {
+ mpneg(b)
+ }
+ if x&Mpsign != 0 {
+ a.Neg = 1
+ mpneg(a)
+ }
+}
+
+func mpandfixfix(a *Mpint, b *Mpint) {
+ var i int
+ var x int
+
+ x = 0
+ if a.Ovf != 0 || b.Ovf != 0 {
+ if nsavederrors+nerrors == 0 {
+ Yyerror("ovf in mpandfixfix")
+ }
+ Mpmovecfix(a, 0)
+ a.Ovf = 1
+ return
+ }
+
+ if a.Neg != 0 {
+ a.Neg = 0
+ mpneg(a)
+ }
+
+ if b.Neg != 0 {
+ mpneg(b)
+ }
+
+ for i = 0; i < Mpprec; i++ {
+ x = a.A[i] & b.A[i]
+ a.A[i] = x
+ }
+
+ if b.Neg != 0 {
+ mpneg(b)
+ }
+ if x&Mpsign != 0 {
+ a.Neg = 1
+ mpneg(a)
+ }
+}
+
+func mpandnotfixfix(a *Mpint, b *Mpint) {
+ var i int
+ var x int
+
+ x = 0
+ if a.Ovf != 0 || b.Ovf != 0 {
+ if nsavederrors+nerrors == 0 {
+ Yyerror("ovf in mpandnotfixfix")
+ }
+ Mpmovecfix(a, 0)
+ a.Ovf = 1
+ return
+ }
+
+ if a.Neg != 0 {
+ a.Neg = 0
+ mpneg(a)
+ }
+
+ if b.Neg != 0 {
+ mpneg(b)
+ }
+
+ for i = 0; i < Mpprec; i++ {
+ x = a.A[i] &^ b.A[i]
+ a.A[i] = x
+ }
+
+ if b.Neg != 0 {
+ mpneg(b)
+ }
+ if x&Mpsign != 0 {
+ a.Neg = 1
+ mpneg(a)
+ }
+}
+
+func mpxorfixfix(a *Mpint, b *Mpint) {
+ var i int
+ var x int
+
+ x = 0
+ if a.Ovf != 0 || b.Ovf != 0 {
+ if nsavederrors+nerrors == 0 {
+ Yyerror("ovf in mporfixfix")
+ }
+ Mpmovecfix(a, 0)
+ a.Ovf = 1
+ return
+ }
+
+ if a.Neg != 0 {
+ a.Neg = 0
+ mpneg(a)
+ }
+
+ if b.Neg != 0 {
+ mpneg(b)
+ }
+
+ for i = 0; i < Mpprec; i++ {
+ x = a.A[i] ^ b.A[i]
+ a.A[i] = x
+ }
+
+ if b.Neg != 0 {
+ mpneg(b)
+ }
+ if x&Mpsign != 0 {
+ a.Neg = 1
+ mpneg(a)
+ }
+}
+
+func mplshfixfix(a *Mpint, b *Mpint) {
+ var s int64
+
+ if a.Ovf != 0 || b.Ovf != 0 {
+ if nsavederrors+nerrors == 0 {
+ Yyerror("ovf in mporfixfix")
+ }
+ Mpmovecfix(a, 0)
+ a.Ovf = 1
+ return
+ }
+
+ s = Mpgetfix(b)
+ if s < 0 || s >= Mpprec*Mpscale {
+ Yyerror("stupid shift: %d", s)
+ Mpmovecfix(a, 0)
+ return
+ }
+
+ Mpshiftfix(a, int(s))
+}
+
+func mprshfixfix(a *Mpint, b *Mpint) {
+ var s int64
+
+ if a.Ovf != 0 || b.Ovf != 0 {
+ if nsavederrors+nerrors == 0 {
+ Yyerror("ovf in mprshfixfix")
+ }
+ Mpmovecfix(a, 0)
+ a.Ovf = 1
+ return
+ }
+
+ s = Mpgetfix(b)
+ if s < 0 || s >= Mpprec*Mpscale {
+ Yyerror("stupid shift: %d", s)
+ if a.Neg != 0 {
+ Mpmovecfix(a, -1)
+ } else {
+ Mpmovecfix(a, 0)
+ }
+ return
+ }
+
+ Mpshiftfix(a, int(-s))
+}
+
+func mpnegfix(a *Mpint) {
+ a.Neg ^= 1
+}
+
+func Mpgetfix(a *Mpint) int64 {
+ var v int64
+
+ if a.Ovf != 0 {
+ if nsavederrors+nerrors == 0 {
+ Yyerror("constant overflow")
+ }
+ return 0
+ }
+
+ v = int64(uint64(a.A[0]))
+ v |= int64(uint64(a.A[1]) << Mpscale)
+ v |= int64(uint64(a.A[2]) << (Mpscale + Mpscale))
+ if a.Neg != 0 {
+ v = int64(-uint64(v))
+ }
+ return v
+}
+
+func Mpmovecfix(a *Mpint, c int64) {
+ var i int
+ var x int64
+
+ a.Neg = 0
+ a.Ovf = 0
+
+ x = c
+ if x < 0 {
+ a.Neg = 1
+ x = int64(-uint64(x))
+ }
+
+ for i = 0; i < Mpprec; i++ {
+ a.A[i] = int(x & Mpmask)
+ x >>= Mpscale
+ }
+}
+
+func mpdivmodfixfix(q *Mpint, r *Mpint, n *Mpint, d *Mpint) {
+ var i int
+ var ns int
+ var ds int
+
+ ns = int(n.Neg)
+ ds = int(d.Neg)
+ n.Neg = 0
+ d.Neg = 0
+
+ mpmovefixfix(r, n)
+ Mpmovecfix(q, 0)
+
+ // shift denominator until it
+ // is larger than numerator
+ for i = 0; i < Mpprec*Mpscale; i++ {
+ if mpcmp(d, r) > 0 {
+ break
+ }
+ mplsh(d, 1)
+ }
+
+ // if it never happens
+ // denominator is probably zero
+ if i >= Mpprec*Mpscale {
+ q.Ovf = 1
+ r.Ovf = 1
+ n.Neg = uint8(ns)
+ d.Neg = uint8(ds)
+ Yyerror("constant division overflow")
+ return
+ }
+
+ // shift denominator back creating
+ // quotient a bit at a time
+ // when done the remaining numerator
+ // will be the remainder
+ for ; i > 0; i-- {
+ mplsh(q, 1)
+ mprsh(d)
+ if mpcmp(d, r) <= 0 {
+ mpaddcfix(q, 1)
+ mpsubfixfix(r, d)
+ }
+ }
+
+ n.Neg = uint8(ns)
+ d.Neg = uint8(ds)
+ r.Neg = uint8(ns)
+ q.Neg = uint8(ns ^ ds)
+}
+
+func mpiszero(a *Mpint) int {
+ var i int
+
+ for i = Mpprec - 1; i >= 0; i-- {
+ if a.A[i] != 0 {
+ return 0
+ }
+ }
+ return 1
+}
+
+func mpdivfract(a *Mpint, b *Mpint) {
+ var n Mpint
+ var d Mpint
+ var i int
+ var j int
+ var neg int
+ var x int
+
+ mpmovefixfix(&n, a) // numerator
+ mpmovefixfix(&d, b) // denominator
+
+ neg = int(n.Neg) ^ int(d.Neg)
+
+ n.Neg = 0
+ d.Neg = 0
+ for i = Mpprec - 1; i >= 0; i-- {
+ x = 0
+ for j = 0; j < Mpscale; j++ {
+ x <<= 1
+ if mpcmp(&d, &n) <= 0 {
+ if !(mpiszero(&d) != 0) {
+ x |= 1
+ }
+ mpsubfixfix(&n, &d)
+ }
+
+ mprsh(&d)
+ }
+
+ a.A[i] = x
+ }
+
+ a.Neg = uint8(neg)
+}
+
+func mptestfix(a *Mpint) int {
+ var b Mpint
+ var r int
+
+ Mpmovecfix(&b, 0)
+ r = mpcmp(a, &b)
+ if a.Neg != 0 {
+ if r > 0 {
+ return -1
+ }
+ if r < 0 {
+ return +1
+ }
+ }
+
+ return r
+}
diff --git a/src/cmd/internal/gc/mparith3.go b/src/cmd/internal/gc/mparith3.go
new file mode 100644
index 0000000..61bf9e9
--- /dev/null
+++ b/src/cmd/internal/gc/mparith3.go
@@ -0,0 +1,377 @@
+// 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
+
+import (
+ "fmt"
+ "math"
+)
+
+/*
+ * returns the leading non-zero
+ * word of the number
+ */
+func sigfig(a *Mpflt) int {
+ var i int
+
+ for i = Mpprec - 1; i >= 0; i-- {
+ if a.Val.A[i] != 0 {
+ break
+ }
+ }
+
+ //print("sigfig %d %d\n", i-z+1, z);
+ return i + 1
+}
+
+/*
+ * sets the exponent.
+ * a too large exponent is an error.
+ * a too small exponent rounds the number to zero.
+ */
+func mpsetexp(a *Mpflt, exp int) {
+ if int(int16(exp)) != exp {
+ if exp > 0 {
+ Yyerror("float constant is too large")
+ a.Exp = 0x7fff
+ } else {
+ Mpmovecflt(a, 0)
+ }
+ } else {
+ a.Exp = int16(exp)
+ }
+}
+
+/*
+ * shifts the leading non-zero
+ * word of the number to Mpnorm
+ */
+func mpnorm(a *Mpflt) {
+ var s int
+ var os int
+ var x int
+
+ os = sigfig(a)
+ if os == 0 {
+ // zero
+ a.Exp = 0
+
+ a.Val.Neg = 0
+ return
+ }
+
+ // this will normalize to the nearest word
+ x = a.Val.A[os-1]
+
+ s = (Mpnorm - os) * Mpscale
+
+ // further normalize to the nearest bit
+ for {
+ x <<= 1
+ if x&Mpbase != 0 {
+ break
+ }
+ s++
+ if x == 0 {
+ // this error comes from trying to
+ // convert an Inf or something
+ // where the initial x=0x80000000
+ s = (Mpnorm - os) * Mpscale
+
+ break
+ }
+ }
+
+ Mpshiftfix(&a.Val, s)
+ mpsetexp(a, int(a.Exp)-s)
+}
+
+/// implements float arihmetic
+
+func mpaddfltflt(a *Mpflt, b *Mpflt) {
+ var sa int
+ var sb int
+ var s int
+ var c Mpflt
+
+ if Mpdebug != 0 /*TypeKind(100016)*/ {
+ fmt.Printf("\n%v + %v", Fconv(a, 0), Fconv(b, 0))
+ }
+
+ sa = sigfig(a)
+ if sa == 0 {
+ mpmovefltflt(a, b)
+ goto out
+ }
+
+ sb = sigfig(b)
+ if sb == 0 {
+ goto out
+ }
+
+ s = int(a.Exp) - int(b.Exp)
+ if s > 0 {
+ // a is larger, shift b right
+ mpmovefltflt(&c, b)
+
+ Mpshiftfix(&c.Val, -s)
+ mpaddfixfix(&a.Val, &c.Val, 0)
+ goto out
+ }
+
+ if s < 0 {
+ // b is larger, shift a right
+ Mpshiftfix(&a.Val, s)
+
+ mpsetexp(a, int(a.Exp)-s)
+ mpaddfixfix(&a.Val, &b.Val, 0)
+ goto out
+ }
+
+ mpaddfixfix(&a.Val, &b.Val, 0)
+
+out:
+ mpnorm(a)
+ if Mpdebug != 0 /*TypeKind(100016)*/ {
+ fmt.Printf(" = %v\n\n", Fconv(a, 0))
+ }
+}
+
+func mpmulfltflt(a *Mpflt, b *Mpflt) {
+ var sa int
+ var sb int
+
+ if Mpdebug != 0 /*TypeKind(100016)*/ {
+ fmt.Printf("%v\n * %v\n", Fconv(a, 0), Fconv(b, 0))
+ }
+
+ sa = sigfig(a)
+ if sa == 0 {
+ // zero
+ a.Exp = 0
+
+ a.Val.Neg = 0
+ return
+ }
+
+ sb = sigfig(b)
+ if sb == 0 {
+ // zero
+ mpmovefltflt(a, b)
+
+ return
+ }
+
+ mpmulfract(&a.Val, &b.Val)
+ mpsetexp(a, (int(a.Exp)+int(b.Exp))+Mpscale*Mpprec-Mpscale-1)
+
+ mpnorm(a)
+ if Mpdebug != 0 /*TypeKind(100016)*/ {
+ fmt.Printf(" = %v\n\n", Fconv(a, 0))
+ }
+}
+
+func mpdivfltflt(a *Mpflt, b *Mpflt) {
+ var sa int
+ var sb int
+ var c Mpflt
+
+ if Mpdebug != 0 /*TypeKind(100016)*/ {
+ fmt.Printf("%v\n / %v\n", Fconv(a, 0), Fconv(b, 0))
+ }
+
+ sb = sigfig(b)
+ if sb == 0 {
+ // zero and ovfl
+ a.Exp = 0
+
+ a.Val.Neg = 0
+ a.Val.Ovf = 1
+ Yyerror("constant division by zero")
+ return
+ }
+
+ sa = sigfig(a)
+ if sa == 0 {
+ // zero
+ a.Exp = 0
+
+ a.Val.Neg = 0
+ return
+ }
+
+ // adjust b to top
+ mpmovefltflt(&c, b)
+
+ Mpshiftfix(&c.Val, Mpscale)
+
+ // divide
+ mpdivfract(&a.Val, &c.Val)
+
+ mpsetexp(a, (int(a.Exp)-int(c.Exp))-Mpscale*(Mpprec-1)+1)
+
+ mpnorm(a)
+ if Mpdebug != 0 /*TypeKind(100016)*/ {
+ fmt.Printf(" = %v\n\n", Fconv(a, 0))
+ }
+}
+
+func mpgetfltN(a *Mpflt, prec int, bias int) float64 {
+ var s int
+ var i int
+ var e int
+ var minexp int
+ var v uint64
+ var f float64
+
+ if a.Val.Ovf != 0 && nsavederrors+nerrors == 0 {
+ Yyerror("mpgetflt ovf")
+ }
+
+ s = sigfig(a)
+ if s == 0 {
+ return 0
+ }
+
+ if s != Mpnorm {
+ Yyerror("mpgetflt norm")
+ mpnorm(a)
+ }
+
+ for a.Val.A[Mpnorm-1]&Mpsign == 0 {
+ Mpshiftfix(&a.Val, 1)
+ mpsetexp(a, int(a.Exp)-1) // can set 'a' to zero
+ s = sigfig(a)
+ if s == 0 {
+ return 0
+ }
+ }
+
+ // pick up the mantissa, a rounding bit, and a tie-breaking bit in a uvlong
+ s = prec + 2
+
+ v = 0
+ for i = Mpnorm - 1; s >= Mpscale; i-- {
+ v = v<<Mpscale | uint64(a.Val.A[i])
+ s -= Mpscale
+ }
+
+ if s > 0 {
+ v = v<<uint(s) | uint64(a.Val.A[i])>>uint(Mpscale-s)
+ if a.Val.A[i]&((1<<uint(Mpscale-s))-1) != 0 {
+ v |= 1
+ }
+ i--
+ }
+
+ for ; i >= 0; i-- {
+ if a.Val.A[i] != 0 {
+ v |= 1
+ }
+ }
+
+ // gradual underflow
+ e = Mpnorm*Mpscale + int(a.Exp) - prec
+
+ minexp = bias + 1 - prec + 1
+ if e < minexp {
+ s = minexp - e
+ if s > prec+1 {
+ s = prec + 1
+ }
+ if v&((1<<uint(s))-1) != 0 {
+ v |= 1 << uint(s)
+ }
+ v >>= uint(s)
+ e = minexp
+ }
+
+ // round to even
+ v |= (v & 4) >> 2
+
+ v += v & 1
+ v >>= 2
+
+ f = float64(v)
+ f = math.Ldexp(f, e)
+
+ if a.Val.Neg != 0 {
+ f = -f
+ }
+
+ return f
+}
+
+func mpgetflt(a *Mpflt) float64 {
+ return mpgetfltN(a, 53, -1023)
+}
+
+func mpgetflt32(a *Mpflt) float64 {
+ return mpgetfltN(a, 24, -127)
+}
+
+func Mpmovecflt(a *Mpflt, c float64) {
+ var i int
+ var f float64
+ var l int
+
+ if Mpdebug != 0 /*TypeKind(100016)*/ {
+ fmt.Printf("\nconst %g", c)
+ }
+ Mpmovecfix(&a.Val, 0)
+ a.Exp = 0
+ if c == 0 {
+ goto out
+ }
+ if c < 0 {
+ a.Val.Neg = 1
+ c = -c
+ }
+
+ f, i = math.Frexp(c)
+ a.Exp = int16(i)
+
+ for i = 0; i < 10; i++ {
+ f = f * Mpbase
+ l = int(math.Floor(f))
+ f = f - float64(l)
+ a.Exp -= Mpscale
+ a.Val.A[0] = l
+ if f == 0 {
+ break
+ }
+ Mpshiftfix(&a.Val, Mpscale)
+ }
+
+out:
+ mpnorm(a)
+ if Mpdebug != 0 /*TypeKind(100016)*/ {
+ fmt.Printf(" = %v\n", Fconv(a, 0))
+ }
+}
+
+func mpnegflt(a *Mpflt) {
+ a.Val.Neg ^= 1
+}
+
+func mptestflt(a *Mpflt) int {
+ var s int
+
+ if Mpdebug != 0 /*TypeKind(100016)*/ {
+ fmt.Printf("\n%v?", Fconv(a, 0))
+ }
+ s = sigfig(a)
+ if s != 0 {
+ s = +1
+ if a.Val.Neg != 0 {
+ s = -1
+ }
+ }
+
+ if Mpdebug != 0 /*TypeKind(100016)*/ {
+ fmt.Printf(" = %d\n", s)
+ }
+ return s
+}
diff --git a/src/cmd/internal/gc/obj.go b/src/cmd/internal/gc/obj.go
new file mode 100644
index 0000000..afaf87c
--- /dev/null
+++ b/src/cmd/internal/gc/obj.go
@@ -0,0 +1,481 @@
+// 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
+
+import (
+ "cmd/internal/obj"
+ "fmt"
+)
+
+/*
+ * architecture-independent object file output
+ */
+const (
+ ArhdrSize = 60
+)
+
+func formathdr(arhdr []byte, name string, size int64) {
+ copy(arhdr[:], fmt.Sprintf("%-16s%-12d%-6d%-6d%-8o%-10d`\n", name, 0, 0, 0, 0644, size))
+}
+
+func dumpobj() {
+ var externs *NodeList
+ var tmp *NodeList
+ var arhdr [ArhdrSize]byte
+ var startobj int64
+ var size int64
+ var zero *Sym
+
+ var err error
+ bout, err = obj.Bopenw(outfile)
+ if err != nil {
+ Flusherrors()
+ fmt.Printf("can't create %s: %v\n", outfile, err)
+ errorexit()
+ }
+
+ startobj = 0
+ if writearchive != 0 {
+ obj.Bwritestring(bout, "!<arch>\n")
+ arhdr = [ArhdrSize]byte{}
+ obj.Bwrite(bout, arhdr[:])
+ startobj = obj.Boffset(bout)
+ }
+
+ fmt.Fprintf(bout, "go object %s %s %s %s\n", obj.Getgoos(), obj.Getgoarch(), obj.Getgoversion(), obj.Expstring())
+ dumpexport()
+
+ if writearchive != 0 {
+ obj.Bflush(bout)
+ size = obj.Boffset(bout) - startobj
+ if size&1 != 0 {
+ obj.Bputc(bout, 0)
+ }
+ obj.Bseek(bout, startobj-ArhdrSize, 0)
+ formathdr(arhdr[:], "__.PKGDEF", size)
+ obj.Bwrite(bout, arhdr[:])
+ obj.Bflush(bout)
+
+ obj.Bseek(bout, startobj+size+(size&1), 0)
+ arhdr = [ArhdrSize]byte{}
+ obj.Bwrite(bout, arhdr[:])
+ startobj = obj.Boffset(bout)
+ fmt.Fprintf(bout, "go object %s %s %s %s\n", obj.Getgoos(), obj.Getgoarch(), obj.Getgoversion(), obj.Expstring())
+ }
+
+ if pragcgobuf != "" {
+ if writearchive != 0 {
+ // write empty export section; must be before cgo section
+ fmt.Fprintf(bout, "\n$$\n\n$$\n\n")
+ }
+
+ fmt.Fprintf(bout, "\n$$ // cgo\n")
+ fmt.Fprintf(bout, "%s\n$$\n\n", pragcgobuf)
+ }
+
+ fmt.Fprintf(bout, "\n!\n")
+
+ externs = nil
+ if externdcl != nil {
+ externs = externdcl.End
+ }
+
+ dumpglobls()
+ dumptypestructs()
+
+ // Dump extra globals.
+ tmp = externdcl
+
+ if externs != nil {
+ externdcl = externs.Next
+ }
+ dumpglobls()
+ externdcl = tmp
+
+ zero = Pkglookup("zerovalue", Runtimepkg)
+ ggloblsym(zero, int32(zerosize), obj.DUPOK|obj.RODATA)
+
+ dumpdata()
+ obj.Writeobjdirect(Ctxt, bout)
+
+ if writearchive != 0 {
+ obj.Bflush(bout)
+ size = obj.Boffset(bout) - startobj
+ if size&1 != 0 {
+ obj.Bputc(bout, 0)
+ }
+ obj.Bseek(bout, startobj-ArhdrSize, 0)
+ namebuf = fmt.Sprintf("_go_.%c", Thearch.Thechar)
+ formathdr(arhdr[:], namebuf, size)
+ obj.Bwrite(bout, arhdr[:])
+ }
+
+ obj.Bterm(bout)
+}
+
+func dumpglobls() {
+ var n *Node
+ var l *NodeList
+
+ // add globals
+ for l = externdcl; l != nil; l = l.Next {
+ n = l.N
+ if n.Op != ONAME {
+ continue
+ }
+
+ if n.Type == nil {
+ Fatal("external %v nil type\n", Nconv(n, 0))
+ }
+ if n.Class == PFUNC {
+ continue
+ }
+ if n.Sym.Pkg != localpkg {
+ continue
+ }
+ dowidth(n.Type)
+
+ ggloblnod(n)
+ }
+
+ for l = funcsyms; l != nil; l = l.Next {
+ n = l.N
+ dsymptr(n.Sym, 0, n.Sym.Def.Shortname.Sym, 0)
+ ggloblsym(n.Sym, int32(Widthptr), obj.DUPOK|obj.RODATA)
+ }
+
+ // Do not reprocess funcsyms on next dumpglobls call.
+ funcsyms = nil
+}
+
+func Bputname(b *obj.Biobuf, s *obj.LSym) {
+ obj.Bwritestring(b, s.Name)
+ obj.Bputc(b, 0)
+}
+
+func Linksym(s *Sym) *obj.LSym {
+ var p string
+
+ if s == nil {
+ return nil
+ }
+ if s.Lsym != nil {
+ return s.Lsym
+ }
+ if isblanksym(s) {
+ s.Lsym = obj.Linklookup(Ctxt, "_", 0)
+ } else if s.Linkname != "" {
+ s.Lsym = obj.Linklookup(Ctxt, s.Linkname, 0)
+ } else {
+ p = fmt.Sprintf("%s.%s", s.Pkg.Prefix, s.Name)
+ s.Lsym = obj.Linklookup(Ctxt, p, 0)
+ }
+
+ return s.Lsym
+}
+
+func duintxx(s *Sym, off int, v uint64, wid int) int {
+ // Update symbol data directly instead of generating a
+ // DATA instruction that liblink will have to interpret later.
+ // This reduces compilation time and memory usage.
+ off = int(Rnd(int64(off), int64(wid)))
+
+ return int(obj.Setuintxx(Ctxt, Linksym(s), int64(off), v, int64(wid)))
+}
+
+func duint8(s *Sym, off int, v uint8) int {
+ return duintxx(s, off, uint64(v), 1)
+}
+
+func duint16(s *Sym, off int, v uint16) int {
+ return duintxx(s, off, uint64(v), 2)
+}
+
+func duint32(s *Sym, off int, v uint32) int {
+ return duintxx(s, off, uint64(v), 4)
+}
+
+func duint64(s *Sym, off int, v uint64) int {
+ return duintxx(s, off, v, 8)
+}
+
+func duintptr(s *Sym, off int, v uint64) int {
+ return duintxx(s, off, v, Widthptr)
+}
+
+var stringsym_gen int
+
+func stringsym(s string) *Sym {
+ var sym *Sym
+ var off int
+ var n int
+ var m int
+ var tmp struct {
+ lit Strlit
+ buf string
+ }
+ var pkg *Pkg
+
+ if len(s) > 100 {
+ // huge strings are made static to avoid long names
+ stringsym_gen++
+ namebuf = fmt.Sprintf(".gostring.%d", stringsym_gen)
+
+ pkg = localpkg
+ } else {
+ // small strings get named by their contents,
+ // so that multiple modules using the same string
+ // can share it.
+ tmp.lit.S = s
+ namebuf = fmt.Sprintf("\"%v\"", Zconv(&tmp.lit, 0))
+ pkg = gostringpkg
+ }
+
+ sym = Pkglookup(namebuf, pkg)
+
+ // SymUniq flag indicates that data is generated already
+ if sym.Flags&SymUniq != 0 {
+ return sym
+ }
+ sym.Flags |= SymUniq
+ sym.Def = newname(sym)
+
+ off = 0
+
+ // string header
+ off = dsymptr(sym, off, sym, Widthptr+Widthint)
+ off = duintxx(sym, off, uint64(len(s)), Widthint)
+
+ // string data
+ for n = 0; n < len(s); n += m {
+ m = 8
+ if m > len(s)-n {
+ m = len(s) - n
+ }
+ off = dsname(sym, off, s[n:n+m])
+ }
+
+ off = duint8(sym, off, 0) // terminating NUL for runtime
+ off = (off + Widthptr - 1) &^ (Widthptr - 1) // round to pointer alignment
+ ggloblsym(sym, int32(off), obj.DUPOK|obj.RODATA)
+
+ return sym
+}
+
+var slicebytes_gen int
+
+func slicebytes(nam *Node, s string, len int) {
+ var off int
+ var n int
+ var m int
+ var sym *Sym
+
+ slicebytes_gen++
+ namebuf = fmt.Sprintf(".gobytes.%d", slicebytes_gen)
+ sym = Pkglookup(namebuf, localpkg)
+ sym.Def = newname(sym)
+
+ off = 0
+ for n = 0; n < len; n += m {
+ m = 8
+ if m > len-n {
+ m = len - n
+ }
+ off = dsname(sym, off, s[n:n+m])
+ }
+
+ ggloblsym(sym, int32(off), obj.NOPTR)
+
+ if nam.Op != ONAME {
+ Fatal("slicebytes %v", Nconv(nam, 0))
+ }
+ off = int(nam.Xoffset)
+ off = dsymptr(nam.Sym, off, sym, 0)
+ off = duintxx(nam.Sym, off, uint64(len), Widthint)
+ duintxx(nam.Sym, off, uint64(len), Widthint)
+}
+
+func dstringptr(s *Sym, off int, str string) int {
+ var p *obj.Prog
+
+ off = int(Rnd(int64(off), int64(Widthptr)))
+ p = Thearch.Gins(obj.ADATA, nil, nil)
+ p.From.Type = obj.TYPE_MEM
+ p.From.Name = obj.NAME_EXTERN
+ p.From.Sym = Linksym(s)
+ p.From.Offset = int64(off)
+ p.From3.Type = obj.TYPE_CONST
+ p.From3.Offset = int64(Widthptr)
+
+ Datastring(str+"\x00", &p.To) // TODO(rsc): Remove NUL
+ p.To.Type = obj.TYPE_ADDR
+ p.To.Etype = Simtype[TINT]
+ off += Widthptr
+
+ return off
+}
+
+/*
+ * gobj.c
+ */
+func Datastring(s string, a *obj.Addr) {
+ var sym *Sym
+
+ sym = stringsym(s)
+ a.Type = obj.TYPE_MEM
+ a.Name = obj.NAME_EXTERN
+ a.Sym = Linksym(sym)
+ a.Node = sym.Def
+ a.Offset = int64(Widthptr) + int64(Widthint) // skip header
+ a.Etype = Simtype[TINT]
+}
+
+func datagostring(sval *Strlit, a *obj.Addr) {
+ var sym *Sym
+
+ sym = stringsym(sval.S)
+ a.Type = obj.TYPE_MEM
+ a.Name = obj.NAME_EXTERN
+ a.Sym = Linksym(sym)
+ a.Node = sym.Def
+ a.Offset = 0 // header
+ a.Etype = TSTRING
+}
+
+func dgostringptr(s *Sym, off int, str string) int {
+ var n int
+ var lit *Strlit
+
+ if str == "" {
+ return duintptr(s, off, 0)
+ }
+
+ n = len(str)
+ lit = new(Strlit)
+ lit.S = str
+ lit.S = lit.S[:n]
+ return dgostrlitptr(s, off, lit)
+}
+
+func dgostrlitptr(s *Sym, off int, lit *Strlit) int {
+ var p *obj.Prog
+
+ if lit == nil {
+ return duintptr(s, off, 0)
+ }
+
+ off = int(Rnd(int64(off), int64(Widthptr)))
+ p = Thearch.Gins(obj.ADATA, nil, nil)
+ p.From.Type = obj.TYPE_MEM
+ p.From.Name = obj.NAME_EXTERN
+ p.From.Sym = Linksym(s)
+ p.From.Offset = int64(off)
+ p.From3.Type = obj.TYPE_CONST
+ p.From3.Offset = int64(Widthptr)
+ datagostring(lit, &p.To)
+ p.To.Type = obj.TYPE_ADDR
+ p.To.Etype = Simtype[TINT]
+ off += Widthptr
+
+ return off
+}
+
+func dsname(s *Sym, off int, t string) int {
+ var p *obj.Prog
+
+ p = Thearch.Gins(obj.ADATA, nil, nil)
+ p.From.Type = obj.TYPE_MEM
+ p.From.Name = obj.NAME_EXTERN
+ p.From.Offset = int64(off)
+ p.From.Sym = Linksym(s)
+ p.From3.Type = obj.TYPE_CONST
+ p.From3.Offset = int64(len(t))
+
+ p.To.Type = obj.TYPE_SCONST
+ p.To.U.Sval = t
+ return off + len(t)
+}
+
+func dsymptr(s *Sym, off int, x *Sym, xoff int) int {
+ var p *obj.Prog
+
+ off = int(Rnd(int64(off), int64(Widthptr)))
+
+ p = Thearch.Gins(obj.ADATA, nil, nil)
+ p.From.Type = obj.TYPE_MEM
+ p.From.Name = obj.NAME_EXTERN
+ p.From.Sym = Linksym(s)
+ p.From.Offset = int64(off)
+ p.From3.Type = obj.TYPE_CONST
+ p.From3.Offset = int64(Widthptr)
+ p.To.Type = obj.TYPE_ADDR
+ p.To.Name = obj.NAME_EXTERN
+ p.To.Sym = Linksym(x)
+ p.To.Offset = int64(xoff)
+ off += Widthptr
+
+ return off
+}
+
+func gdata(nam *Node, nr *Node, wid int) {
+ var p *obj.Prog
+
+ if nr.Op == OLITERAL {
+ switch nr.Val.Ctype {
+ case CTCPLX:
+ gdatacomplex(nam, nr.Val.U.Cval)
+ return
+
+ case CTSTR:
+ gdatastring(nam, nr.Val.U.Sval)
+ return
+ }
+ }
+
+ p = Thearch.Gins(obj.ADATA, nam, nr)
+ p.From3.Type = obj.TYPE_CONST
+ p.From3.Offset = int64(wid)
+}
+
+func gdatacomplex(nam *Node, cval *Mpcplx) {
+ var p *obj.Prog
+ var w int
+
+ w = cplxsubtype(int(nam.Type.Etype))
+ w = int(Types[w].Width)
+
+ p = Thearch.Gins(obj.ADATA, nam, nil)
+ p.From3.Type = obj.TYPE_CONST
+ p.From3.Offset = int64(w)
+ p.To.Type = obj.TYPE_FCONST
+ p.To.U.Dval = mpgetflt(&cval.Real)
+
+ p = Thearch.Gins(obj.ADATA, nam, nil)
+ p.From3.Type = obj.TYPE_CONST
+ p.From3.Offset = int64(w)
+ p.From.Offset += int64(w)
+ p.To.Type = obj.TYPE_FCONST
+ p.To.U.Dval = mpgetflt(&cval.Imag)
+}
+
+func gdatastring(nam *Node, sval *Strlit) {
+ var p *obj.Prog
+ var nod1 Node
+
+ p = Thearch.Gins(obj.ADATA, nam, nil)
+ Datastring(sval.S, &p.To)
+ p.From3.Type = obj.TYPE_CONST
+ p.From3.Offset = Types[Tptr].Width
+ p.To.Type = obj.TYPE_ADDR
+
+ //print("%P\n", p);
+
+ Nodconst(&nod1, Types[TINT], int64(len(sval.S)))
+
+ p = Thearch.Gins(obj.ADATA, nam, &nod1)
+ p.From3.Type = obj.TYPE_CONST
+ p.From3.Offset = int64(Widthint)
+ p.From.Offset += int64(Widthptr)
+}
diff --git a/src/cmd/internal/gc/opnames.go b/src/cmd/internal/gc/opnames.go
new file mode 100644
index 0000000..fc03ec6
--- /dev/null
+++ b/src/cmd/internal/gc/opnames.go
@@ -0,0 +1,162 @@
+// Copyright 2011 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
+
+// auto generated by go tool dist
+var opnames = []string{
+ OXXX: "XXX",
+ ONAME: "NAME",
+ ONONAME: "NONAME",
+ OTYPE: "TYPE",
+ OPACK: "PACK",
+ OLITERAL: "LITERAL",
+ OADD: "ADD",
+ OSUB: "SUB",
+ OOR: "OR",
+ OXOR: "XOR",
+ OADDSTR: "ADDSTR",
+ OADDR: "ADDR",
+ OANDAND: "ANDAND",
+ OAPPEND: "APPEND",
+ OARRAYBYTESTR: "ARRAYBYTESTR",
+ OARRAYBYTESTRTMP: "ARRAYBYTESTRTMP",
+ OARRAYRUNESTR: "ARRAYRUNESTR",
+ OSTRARRAYBYTE: "STRARRAYBYTE",
+ OSTRARRAYBYTETMP: "STRARRAYBYTETMP",
+ OSTRARRAYRUNE: "STRARRAYRUNE",
+ OAS: "AS",
+ OAS2: "AS2",
+ OAS2FUNC: "AS2FUNC",
+ OAS2RECV: "AS2RECV",
+ OAS2MAPR: "AS2MAPR",
+ OAS2DOTTYPE: "AS2DOTTYPE",
+ OASOP: "ASOP",
+ OCALL: "CALL",
+ OCALLFUNC: "CALLFUNC",
+ OCALLMETH: "CALLMETH",
+ OCALLINTER: "CALLINTER",
+ OCALLPART: "CALLPART",
+ OCAP: "CAP",
+ OCLOSE: "CLOSE",
+ OCLOSURE: "CLOSURE",
+ OCMPIFACE: "CMPIFACE",
+ OCMPSTR: "CMPSTR",
+ OCOMPLIT: "COMPLIT",
+ OMAPLIT: "MAPLIT",
+ OSTRUCTLIT: "STRUCTLIT",
+ OARRAYLIT: "ARRAYLIT",
+ OPTRLIT: "PTRLIT",
+ OCONV: "CONV",
+ OCONVIFACE: "CONVIFACE",
+ OCONVNOP: "CONVNOP",
+ OCOPY: "COPY",
+ ODCL: "DCL",
+ ODCLFUNC: "DCLFUNC",
+ ODCLFIELD: "DCLFIELD",
+ ODCLCONST: "DCLCONST",
+ ODCLTYPE: "DCLTYPE",
+ ODELETE: "DELETE",
+ ODOT: "DOT",
+ ODOTPTR: "DOTPTR",
+ ODOTMETH: "DOTMETH",
+ ODOTINTER: "DOTINTER",
+ OXDOT: "XDOT",
+ ODOTTYPE: "DOTTYPE",
+ ODOTTYPE2: "DOTTYPE2",
+ OEQ: "EQ",
+ ONE: "NE",
+ OLT: "LT",
+ OLE: "LE",
+ OGE: "GE",
+ OGT: "GT",
+ OIND: "IND",
+ OINDEX: "INDEX",
+ OINDEXMAP: "INDEXMAP",
+ OKEY: "KEY",
+ OPARAM: "PARAM",
+ OLEN: "LEN",
+ OMAKE: "MAKE",
+ OMAKECHAN: "MAKECHAN",
+ OMAKEMAP: "MAKEMAP",
+ OMAKESLICE: "MAKESLICE",
+ OMUL: "MUL",
+ ODIV: "DIV",
+ OMOD: "MOD",
+ OLSH: "LSH",
+ ORSH: "RSH",
+ OAND: "AND",
+ OANDNOT: "ANDNOT",
+ ONEW: "NEW",
+ ONOT: "NOT",
+ OCOM: "COM",
+ OPLUS: "PLUS",
+ OMINUS: "MINUS",
+ OOROR: "OROR",
+ OPANIC: "PANIC",
+ OPRINT: "PRINT",
+ OPRINTN: "PRINTN",
+ OPAREN: "PAREN",
+ OSEND: "SEND",
+ OSLICE: "SLICE",
+ OSLICEARR: "SLICEARR",
+ OSLICESTR: "SLICESTR",
+ OSLICE3: "SLICE3",
+ OSLICE3ARR: "SLICE3ARR",
+ ORECOVER: "RECOVER",
+ ORECV: "RECV",
+ ORUNESTR: "RUNESTR",
+ OSELRECV: "SELRECV",
+ OSELRECV2: "SELRECV2",
+ OIOTA: "IOTA",
+ OREAL: "REAL",
+ OIMAG: "IMAG",
+ OCOMPLEX: "COMPLEX",
+ OBLOCK: "BLOCK",
+ OBREAK: "BREAK",
+ OCASE: "CASE",
+ OXCASE: "XCASE",
+ OCONTINUE: "CONTINUE",
+ ODEFER: "DEFER",
+ OEMPTY: "EMPTY",
+ OFALL: "FALL",
+ OXFALL: "XFALL",
+ OFOR: "FOR",
+ OGOTO: "GOTO",
+ OIF: "IF",
+ OLABEL: "LABEL",
+ OPROC: "PROC",
+ ORANGE: "RANGE",
+ ORETURN: "RETURN",
+ OSELECT: "SELECT",
+ OSWITCH: "SWITCH",
+ OTYPESW: "TYPESW",
+ OTCHAN: "TCHAN",
+ OTMAP: "TMAP",
+ OTSTRUCT: "TSTRUCT",
+ OTINTER: "TINTER",
+ OTFUNC: "TFUNC",
+ OTARRAY: "TARRAY",
+ ODDD: "DDD",
+ ODDDARG: "DDDARG",
+ OINLCALL: "INLCALL",
+ OEFACE: "EFACE",
+ OITAB: "ITAB",
+ OSPTR: "SPTR",
+ OCLOSUREVAR: "CLOSUREVAR",
+ OCFUNC: "CFUNC",
+ OCHECKNIL: "CHECKNIL",
+ OVARKILL: "VARKILL",
+ OREGISTER: "REGISTER",
+ OINDREG: "INDREG",
+ OCMP: "CMP",
+ ODEC: "DEC",
+ OINC: "INC",
+ OEXTEND: "EXTEND",
+ OHMUL: "HMUL",
+ OLROT: "LROT",
+ ORROTC: "RROTC",
+ ORETJMP: "RETJMP",
+ OEND: "END",
+}
diff --git a/src/cmd/internal/gc/order.go b/src/cmd/internal/gc/order.go
new file mode 100644
index 0000000..6f18952
--- /dev/null
+++ b/src/cmd/internal/gc/order.go
@@ -0,0 +1,1188 @@
+// Copyright 2012 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
+
+import (
+ "fmt"
+ "strings"
+)
+
+// Rewrite tree to use separate statements to enforce
+// order of evaluation. Makes walk easier, because it
+// can (after this runs) reorder at will within an expression.
+//
+// Rewrite x op= y into x = x op y.
+//
+// Introduce temporaries as needed by runtime routines.
+// For example, the map runtime routines take the map key
+// by reference, so make sure all map keys are addressable
+// by copying them to temporaries as needed.
+// The same is true for channel operations.
+//
+// Arrange that map index expressions only appear in direct
+// assignments x = m[k] or m[k] = x, never in larger expressions.
+//
+// Arrange that receive expressions only appear in direct assignments
+// x = <-c or as standalone statements <-c, never in larger expressions.
+
+// TODO(rsc): The temporary introduction during multiple assignments
+// should be moved into this file, so that the temporaries can be cleaned
+// and so that conversions implicit in the OAS2FUNC and OAS2RECV
+// nodes can be made explicit and then have their temporaries cleaned.
+
+// TODO(rsc): Goto and multilevel break/continue can jump over
+// inserted VARKILL annotations. Work out a way to handle these.
+// The current implementation is safe, in that it will execute correctly.
+// But it won't reuse temporaries as aggressively as it might, and
+// it can result in unnecessary zeroing of those variables in the function
+// prologue.
+
+// Order holds state during the ordering process.
+type Order struct {
+ out *NodeList
+ temp *NodeList
+ free *NodeList
+}
+
+// Order rewrites fn->nbody to apply the ordering constraints
+// described in the comment at the top of the file.
+func order(fn *Node) {
+ var s string
+
+ if Debug['W'] > 1 {
+ s = fmt.Sprintf("\nbefore order %v", Sconv(fn.Nname.Sym, 0))
+ dumplist(s, fn.Nbody)
+ }
+
+ orderblock(&fn.Nbody)
+}
+
+// Ordertemp allocates a new temporary with the given type,
+// pushes it onto the temp stack, and returns it.
+// If clear is true, ordertemp emits code to zero the temporary.
+func ordertemp(t *Type, order *Order, clear int) *Node {
+ var var_ *Node
+ var a *Node
+ var l *NodeList
+
+ var_ = temp(t)
+ if clear != 0 {
+ a = Nod(OAS, var_, nil)
+ typecheck(&a, Etop)
+ order.out = list(order.out, a)
+ }
+
+ l = order.free
+ if l == nil {
+ l = new(NodeList)
+ }
+ order.free = l.Next
+ l.Next = order.temp
+ l.N = var_
+ order.temp = l
+ return var_
+}
+
+// Ordercopyexpr behaves like ordertemp but also emits
+// code to initialize the temporary to the value n.
+//
+// The clear argument is provided for use when the evaluation
+// of tmp = n turns into a function call that is passed a pointer
+// to the temporary as the output space. If the call blocks before
+// tmp has been written, the garbage collector will still treat the
+// temporary as live, so we must zero it before entering that call.
+// Today, this only happens for channel receive operations.
+// (The other candidate would be map access, but map access
+// returns a pointer to the result data instead of taking a pointer
+// to be filled in.)
+func ordercopyexpr(n *Node, t *Type, order *Order, clear int) *Node {
+ var a *Node
+ var var_ *Node
+
+ var_ = ordertemp(t, order, clear)
+ a = Nod(OAS, var_, n)
+ typecheck(&a, Etop)
+ order.out = list(order.out, a)
+ return var_
+}
+
+// Ordercheapexpr returns a cheap version of n.
+// The definition of cheap is that n is a variable or constant.
+// If not, ordercheapexpr allocates a new tmp, emits tmp = n,
+// and then returns tmp.
+func ordercheapexpr(n *Node, order *Order) *Node {
+ switch n.Op {
+ case ONAME,
+ OLITERAL:
+ return n
+ }
+
+ return ordercopyexpr(n, n.Type, order, 0)
+}
+
+// Ordersafeexpr returns a safe version of n.
+// The definition of safe is that n can appear multiple times
+// without violating the semantics of the original program,
+// and that assigning to the safe version has the same effect
+// as assigning to the original n.
+//
+// The intended use is to apply to x when rewriting x += y into x = x + y.
+func ordersafeexpr(n *Node, order *Order) *Node {
+ var l *Node
+ var r *Node
+ var a *Node
+
+ switch n.Op {
+ default:
+ Fatal("ordersafeexpr %v", Oconv(int(n.Op), 0))
+ fallthrough
+
+ case ONAME,
+ OLITERAL:
+ return n
+
+ case ODOT:
+ l = ordersafeexpr(n.Left, order)
+ if l == n.Left {
+ return n
+ }
+ a = Nod(OXXX, nil, nil)
+ *a = *n
+ a.Orig = a
+ a.Left = l
+ typecheck(&a, Erv)
+ return a
+
+ case ODOTPTR,
+ OIND:
+ l = ordercheapexpr(n.Left, order)
+ if l == n.Left {
+ return n
+ }
+ a = Nod(OXXX, nil, nil)
+ *a = *n
+ a.Orig = a
+ a.Left = l
+ typecheck(&a, Erv)
+ return a
+
+ case OINDEX,
+ OINDEXMAP:
+ if Isfixedarray(n.Left.Type) != 0 {
+ l = ordersafeexpr(n.Left, order)
+ } else {
+ l = ordercheapexpr(n.Left, order)
+ }
+ r = ordercheapexpr(n.Right, order)
+ if l == n.Left && r == n.Right {
+ return n
+ }
+ a = Nod(OXXX, nil, nil)
+ *a = *n
+ a.Orig = a
+ a.Left = l
+ a.Right = r
+ typecheck(&a, Erv)
+ return a
+ }
+}
+
+// Istemp reports whether n is a temporary variable.
+func istemp(n *Node) int {
+ if n.Op != ONAME {
+ return 0
+ }
+ return bool2int(strings.HasPrefix(n.Sym.Name, "autotmp_"))
+}
+
+// Isaddrokay reports whether it is okay to pass n's address to runtime routines.
+// Taking the address of a variable makes the liveness and optimization analyses
+// lose track of where the variable's lifetime ends. To avoid hurting the analyses
+// of ordinary stack variables, those are not 'isaddrokay'. Temporaries are okay,
+// because we emit explicit VARKILL instructions marking the end of those
+// temporaries' lifetimes.
+func isaddrokay(n *Node) int {
+ return bool2int(islvalue(n) != 0 && (n.Op != ONAME || n.Class == PEXTERN || istemp(n) != 0))
+}
+
+// Orderaddrtemp ensures that *np is okay to pass by address to runtime routines.
+// If the original argument *np is not okay, orderaddrtemp creates a tmp, emits
+// tmp = *np, and then sets *np to the tmp variable.
+func orderaddrtemp(np **Node, order *Order) {
+ var n *Node
+
+ n = *np
+ if isaddrokay(n) != 0 {
+ return
+ }
+ *np = ordercopyexpr(n, n.Type, order, 0)
+}
+
+// Marktemp returns the top of the temporary variable stack.
+func marktemp(order *Order) *NodeList {
+ return order.temp
+}
+
+// Poptemp pops temporaries off the stack until reaching the mark,
+// which must have been returned by marktemp.
+func poptemp(mark *NodeList, order *Order) {
+ var l *NodeList
+
+ for {
+ l = order.temp
+ if !(l != mark) {
+ break
+ }
+ order.temp = l.Next
+ l.Next = order.free
+ order.free = l
+ }
+}
+
+// Cleantempnopop emits to *out VARKILL instructions for each temporary
+// above the mark on the temporary stack, but it does not pop them
+// from the stack.
+func cleantempnopop(mark *NodeList, order *Order, out **NodeList) {
+ var l *NodeList
+ var kill *Node
+
+ for l = order.temp; l != mark; l = l.Next {
+ kill = Nod(OVARKILL, l.N, nil)
+ typecheck(&kill, Etop)
+ *out = list(*out, kill)
+ }
+}
+
+// Cleantemp emits VARKILL instructions for each temporary above the
+// mark on the temporary stack and removes them from the stack.
+func cleantemp(top *NodeList, order *Order) {
+ cleantempnopop(top, order, &order.out)
+ poptemp(top, order)
+}
+
+// Orderstmtlist orders each of the statements in the list.
+func orderstmtlist(l *NodeList, order *Order) {
+ for ; l != nil; l = l.Next {
+ orderstmt(l.N, order)
+ }
+}
+
+// Orderblock orders the block of statements *l onto a new list,
+// and then replaces *l with that list.
+func orderblock(l **NodeList) {
+ var order Order
+ var mark *NodeList
+
+ order = Order{}
+ mark = marktemp(&order)
+ orderstmtlist(*l, &order)
+ cleantemp(mark, &order)
+ *l = order.out
+}
+
+// Orderexprinplace orders the side effects in *np and
+// leaves them as the init list of the final *np.
+func orderexprinplace(np **Node, outer *Order) {
+ var n *Node
+ var lp **NodeList
+ var order Order
+
+ n = *np
+ order = Order{}
+ orderexpr(&n, &order)
+ addinit(&n, order.out)
+
+ // insert new temporaries from order
+ // at head of outer list.
+ lp = &order.temp
+
+ for *lp != nil {
+ lp = &(*lp).Next
+ }
+ *lp = outer.temp
+ outer.temp = order.temp
+
+ *np = n
+}
+
+// Orderstmtinplace orders the side effects of the single statement *np
+// and replaces it with the resulting statement list.
+func orderstmtinplace(np **Node) {
+ var n *Node
+ var order Order
+ var mark *NodeList
+
+ n = *np
+ order = Order{}
+ mark = marktemp(&order)
+ orderstmt(n, &order)
+ cleantemp(mark, &order)
+ *np = liststmt(order.out)
+}
+
+// Orderinit moves n's init list to order->out.
+func orderinit(n *Node, order *Order) {
+ orderstmtlist(n.Ninit, order)
+ n.Ninit = nil
+}
+
+// Ismulticall reports whether the list l is f() for a multi-value function.
+// Such an f() could appear as the lone argument to a multi-arg function.
+func ismulticall(l *NodeList) int {
+ var n *Node
+
+ // one arg only
+ if l == nil || l.Next != nil {
+ return 0
+ }
+ n = l.N
+
+ // must be call
+ switch n.Op {
+ default:
+ return 0
+
+ case OCALLFUNC,
+ OCALLMETH,
+ OCALLINTER:
+ break
+ }
+
+ // call must return multiple values
+ return bool2int(n.Left.Type.Outtuple > 1)
+}
+
+// Copyret emits t1, t2, ... = n, where n is a function call,
+// and then returns the list t1, t2, ....
+func copyret(n *Node, order *Order) *NodeList {
+ var t *Type
+ var tmp *Node
+ var as *Node
+ var l1 *NodeList
+ var l2 *NodeList
+ var tl Iter
+
+ if n.Type.Etype != TSTRUCT || !(n.Type.Funarg != 0) {
+ Fatal("copyret %v %d", Tconv(n.Type, 0), n.Left.Type.Outtuple)
+ }
+
+ l1 = nil
+ l2 = nil
+ for t = Structfirst(&tl, &n.Type); t != nil; t = structnext(&tl) {
+ tmp = temp(t.Type)
+ l1 = list(l1, tmp)
+ l2 = list(l2, tmp)
+ }
+
+ as = Nod(OAS2, nil, nil)
+ as.List = l1
+ as.Rlist = list1(n)
+ typecheck(&as, Etop)
+ orderstmt(as, order)
+
+ return l2
+}
+
+// Ordercallargs orders the list of call arguments *l.
+func ordercallargs(l **NodeList, order *Order) {
+ if ismulticall(*l) != 0 {
+ // return f() where f() is multiple values.
+ *l = copyret((*l).N, order)
+ } else {
+ orderexprlist(*l, order)
+ }
+}
+
+// Ordercall orders the call expression n.
+// n->op is OCALLMETH/OCALLFUNC/OCALLINTER or a builtin like OCOPY.
+func ordercall(n *Node, order *Order) {
+ orderexpr(&n.Left, order)
+ orderexpr(&n.Right, order) // ODDDARG temp
+ ordercallargs(&n.List, order)
+}
+
+// Ordermapassign appends n to order->out, introducing temporaries
+// to make sure that all map assignments have the form m[k] = x,
+// where x is adressable.
+// (Orderexpr has already been called on n, so we know k is addressable.)
+//
+// If n is m[k] = x where x is not addressable, the rewrite is:
+// tmp = x
+// m[k] = tmp
+//
+// If n is the multiple assignment form ..., m[k], ... = ..., the rewrite is
+// t1 = m
+// t2 = k
+// ...., t3, ... = x
+// t1[t2] = t3
+//
+// The temporaries t1, t2 are needed in case the ... being assigned
+// contain m or k. They are usually unnecessary, but in the unnecessary
+// cases they are also typically registerizable, so not much harm done.
+// And this only applies to the multiple-assignment form.
+// We could do a more precise analysis if needed, like in walk.c.
+//
+// Ordermapassign also inserts these temporaries if needed for
+// calling writebarrierfat with a pointer to n->right.
+func ordermapassign(n *Node, order *Order) {
+ var m *Node
+ var a *Node
+ var l *NodeList
+ var post *NodeList
+
+ switch n.Op {
+ default:
+ Fatal("ordermapassign %v", Oconv(int(n.Op), 0))
+ fallthrough
+
+ case OAS:
+ order.out = list(order.out, n)
+
+ // We call writebarrierfat only for values > 4 pointers long. See walk.c.
+ if (n.Left.Op == OINDEXMAP || (needwritebarrier(n.Left, n.Right) != 0 && n.Left.Type.Width > int64(4*Widthptr))) && !(isaddrokay(n.Right) != 0) {
+ m = n.Left
+ n.Left = ordertemp(m.Type, order, 0)
+ a = Nod(OAS, m, n.Left)
+ typecheck(&a, Etop)
+ order.out = list(order.out, a)
+ }
+
+ case OAS2,
+ OAS2DOTTYPE,
+ OAS2MAPR,
+ OAS2FUNC:
+ post = nil
+ for l = n.List; l != nil; l = l.Next {
+ if l.N.Op == OINDEXMAP {
+ m = l.N
+ if !(istemp(m.Left) != 0) {
+ m.Left = ordercopyexpr(m.Left, m.Left.Type, order, 0)
+ }
+ if !(istemp(m.Right) != 0) {
+ m.Right = ordercopyexpr(m.Right, m.Right.Type, order, 0)
+ }
+ l.N = ordertemp(m.Type, order, 0)
+ a = Nod(OAS, m, l.N)
+ typecheck(&a, Etop)
+ post = list(post, a)
+ }
+ }
+
+ order.out = list(order.out, n)
+ order.out = concat(order.out, post)
+ }
+}
+
+// Orderstmt orders the statement n, appending to order->out.
+// Temporaries created during the statement are cleaned
+// up using VARKILL instructions as possible.
+func orderstmt(n *Node, order *Order) {
+ var lno int
+ var l *NodeList
+ var t *NodeList
+ var t1 *NodeList
+ var r *Node
+ var tmp1 *Node
+ var tmp2 *Node
+ var np **Node
+ var ch *Type
+ var typ *Type
+
+ if n == nil {
+ return
+ }
+
+ lno = int(setlineno(n))
+
+ orderinit(n, order)
+
+ switch n.Op {
+ default:
+ Fatal("orderstmt %v", Oconv(int(n.Op), 0))
+ fallthrough
+
+ case OVARKILL:
+ order.out = list(order.out, n)
+
+ case OAS,
+ OAS2,
+ OCLOSE,
+ OCOPY,
+ OPRINT,
+ OPRINTN,
+ ORECOVER,
+ ORECV:
+ t = marktemp(order)
+ orderexpr(&n.Left, order)
+ orderexpr(&n.Right, order)
+ orderexprlist(n.List, order)
+ orderexprlist(n.Rlist, order)
+ switch n.Op {
+ case OAS,
+ OAS2,
+ OAS2DOTTYPE:
+ ordermapassign(n, order)
+
+ default:
+ order.out = list(order.out, n)
+ }
+
+ cleantemp(t, order)
+
+ // Special: rewrite l op= r into l = l op r.
+ // This simplies quite a few operations;
+ // most important is that it lets us separate
+ // out map read from map write when l is
+ // a map index expression.
+ case OASOP:
+ t = marktemp(order)
+
+ orderexpr(&n.Left, order)
+ n.Left = ordersafeexpr(n.Left, order)
+ tmp1 = treecopy(n.Left)
+ if tmp1.Op == OINDEXMAP {
+ tmp1.Etype = 0 // now an rvalue not an lvalue
+ }
+ tmp1 = ordercopyexpr(tmp1, n.Left.Type, order, 0)
+ n.Right = Nod(int(n.Etype), tmp1, n.Right)
+ typecheck(&n.Right, Erv)
+ orderexpr(&n.Right, order)
+ n.Etype = 0
+ n.Op = OAS
+ ordermapassign(n, order)
+ cleantemp(t, order)
+
+ // Special: make sure key is addressable,
+ // and make sure OINDEXMAP is not copied out.
+ case OAS2MAPR:
+ t = marktemp(order)
+
+ orderexprlist(n.List, order)
+ r = n.Rlist.N
+ orderexpr(&r.Left, order)
+ orderexpr(&r.Right, order)
+
+ // See case OINDEXMAP below.
+ if r.Right.Op == OARRAYBYTESTR {
+ r.Right.Op = OARRAYBYTESTRTMP
+ }
+ orderaddrtemp(&r.Right, order)
+ ordermapassign(n, order)
+ cleantemp(t, order)
+
+ // Special: avoid copy of func call n->rlist->n.
+ case OAS2FUNC:
+ t = marktemp(order)
+
+ orderexprlist(n.List, order)
+ ordercall(n.Rlist.N, order)
+ ordermapassign(n, order)
+ cleantemp(t, order)
+
+ // Special: use temporary variables to hold result,
+ // so that assertI2Tetc can take address of temporary.
+ // No temporary for blank assignment.
+ case OAS2DOTTYPE:
+ t = marktemp(order)
+
+ orderexprlist(n.List, order)
+ orderexpr(&n.Rlist.N.Left, order) // i in i.(T)
+ if isblank(n.List.N) {
+ order.out = list(order.out, n)
+ } else {
+ typ = n.Rlist.N.Type
+ tmp1 = ordertemp(typ, order, bool2int(haspointers(typ)))
+ order.out = list(order.out, n)
+ r = Nod(OAS, n.List.N, tmp1)
+ typecheck(&r, Etop)
+ ordermapassign(r, order)
+ n.List = list(list1(tmp1), n.List.Next.N)
+ }
+
+ cleantemp(t, order)
+
+ // Special: use temporary variables to hold result,
+ // so that chanrecv can take address of temporary.
+ case OAS2RECV:
+ t = marktemp(order)
+
+ orderexprlist(n.List, order)
+ orderexpr(&n.Rlist.N.Left, order) // arg to recv
+ ch = n.Rlist.N.Left.Type
+ tmp1 = ordertemp(ch.Type, order, bool2int(haspointers(ch.Type)))
+ if !isblank(n.List.Next.N) {
+ tmp2 = ordertemp(n.List.Next.N.Type, order, 0)
+ } else {
+ tmp2 = ordertemp(Types[TBOOL], order, 0)
+ }
+ order.out = list(order.out, n)
+ r = Nod(OAS, n.List.N, tmp1)
+ typecheck(&r, Etop)
+ ordermapassign(r, order)
+ r = Nod(OAS, n.List.Next.N, tmp2)
+ typecheck(&r, Etop)
+ ordermapassign(r, order)
+ n.List = list(list1(tmp1), tmp2)
+ cleantemp(t, order)
+
+ // Special: does not save n onto out.
+ case OBLOCK,
+ OEMPTY:
+ orderstmtlist(n.List, order)
+
+ // Special: n->left is not an expression; save as is.
+ case OBREAK,
+ OCONTINUE,
+ ODCL,
+ ODCLCONST,
+ ODCLTYPE,
+ OFALL,
+ OXFALL,
+ OGOTO,
+ OLABEL,
+ ORETJMP:
+ order.out = list(order.out, n)
+
+ // Special: handle call arguments.
+ case OCALLFUNC,
+ OCALLINTER,
+ OCALLMETH:
+ t = marktemp(order)
+
+ ordercall(n, order)
+ order.out = list(order.out, n)
+ cleantemp(t, order)
+
+ // Special: order arguments to inner call but not call itself.
+ case ODEFER,
+ OPROC:
+ t = marktemp(order)
+
+ switch n.Left.Op {
+ // Delete will take the address of the key.
+ // Copy key into new temp and do not clean it
+ // (it persists beyond the statement).
+ case ODELETE:
+ orderexprlist(n.Left.List, order)
+
+ t1 = marktemp(order)
+ np = &n.Left.List.Next.N // map key
+ *np = ordercopyexpr(*np, (*np).Type, order, 0)
+ poptemp(t1, order)
+
+ default:
+ ordercall(n.Left, order)
+ }
+
+ order.out = list(order.out, n)
+ cleantemp(t, order)
+
+ case ODELETE:
+ t = marktemp(order)
+ orderexpr(&n.List.N, order)
+ orderexpr(&n.List.Next.N, order)
+ orderaddrtemp(&n.List.Next.N, order) // map key
+ order.out = list(order.out, n)
+ cleantemp(t, order)
+
+ // Clean temporaries from condition evaluation at
+ // beginning of loop body and after for statement.
+ case OFOR:
+ t = marktemp(order)
+
+ orderexprinplace(&n.Ntest, order)
+ l = nil
+ cleantempnopop(t, order, &l)
+ n.Nbody = concat(l, n.Nbody)
+ orderblock(&n.Nbody)
+ orderstmtinplace(&n.Nincr)
+ order.out = list(order.out, n)
+ cleantemp(t, order)
+
+ // Clean temporaries from condition at
+ // beginning of both branches.
+ case OIF:
+ t = marktemp(order)
+
+ orderexprinplace(&n.Ntest, order)
+ l = nil
+ cleantempnopop(t, order, &l)
+ n.Nbody = concat(l, n.Nbody)
+ l = nil
+ cleantempnopop(t, order, &l)
+ n.Nelse = concat(l, n.Nelse)
+ poptemp(t, order)
+ orderblock(&n.Nbody)
+ orderblock(&n.Nelse)
+ order.out = list(order.out, n)
+
+ // Special: argument will be converted to interface using convT2E
+ // so make sure it is an addressable temporary.
+ case OPANIC:
+ t = marktemp(order)
+
+ orderexpr(&n.Left, order)
+ if !(Isinter(n.Left.Type) != 0) {
+ orderaddrtemp(&n.Left, order)
+ }
+ order.out = list(order.out, n)
+ cleantemp(t, order)
+
+ // n->right is the expression being ranged over.
+ // order it, and then make a copy if we need one.
+ // We almost always do, to ensure that we don't
+ // see any value changes made during the loop.
+ // Usually the copy is cheap (e.g., array pointer, chan, slice, string are all tiny).
+ // The exception is ranging over an array value (not a slice, not a pointer to array),
+ // which must make a copy to avoid seeing updates made during
+ // the range body. Ranging over an array value is uncommon though.
+ case ORANGE:
+ t = marktemp(order)
+
+ orderexpr(&n.Right, order)
+ switch n.Type.Etype {
+ default:
+ Fatal("orderstmt range %v", Tconv(n.Type, 0))
+ fallthrough
+
+ // Mark []byte(str) range expression to reuse string backing storage.
+ // It is safe because the storage cannot be mutated.
+ case TARRAY:
+ if n.Right.Op == OSTRARRAYBYTE {
+ n.Right.Op = OSTRARRAYBYTETMP
+ }
+ if count(n.List) < 2 || isblank(n.List.Next.N) {
+ // for i := range x will only use x once, to compute len(x).
+ // No need to copy it.
+ break
+ }
+ fallthrough
+
+ // chan, string, slice, array ranges use value multiple times.
+ // make copy.
+ // fall through
+ case TCHAN,
+ TSTRING:
+ r = n.Right
+
+ if r.Type.Etype == TSTRING && r.Type != Types[TSTRING] {
+ r = Nod(OCONV, r, nil)
+ r.Type = Types[TSTRING]
+ typecheck(&r, Erv)
+ }
+
+ n.Right = ordercopyexpr(r, r.Type, order, 0)
+
+ // copy the map value in case it is a map literal.
+ // TODO(rsc): Make tmp = literal expressions reuse tmp.
+ // For maps tmp is just one word so it hardly matters.
+ case TMAP:
+ r = n.Right
+
+ n.Right = ordercopyexpr(r, r.Type, order, 0)
+
+ // n->alloc is the temp for the iterator.
+ n.Alloc = ordertemp(Types[TUINT8], order, 1)
+ }
+
+ for l = n.List; l != nil; l = l.Next {
+ orderexprinplace(&l.N, order)
+ }
+ orderblock(&n.Nbody)
+ order.out = list(order.out, n)
+ cleantemp(t, order)
+
+ case ORETURN:
+ ordercallargs(&n.List, order)
+ order.out = list(order.out, n)
+
+ // Special: clean case temporaries in each block entry.
+ // Select must enter one of its blocks, so there is no
+ // need for a cleaning at the end.
+ // Doubly special: evaluation order for select is stricter
+ // than ordinary expressions. Even something like p.c
+ // has to be hoisted into a temporary, so that it cannot be
+ // reordered after the channel evaluation for a different
+ // case (if p were nil, then the timing of the fault would
+ // give this away).
+ case OSELECT:
+ t = marktemp(order)
+
+ for l = n.List; l != nil; l = l.Next {
+ if l.N.Op != OXCASE {
+ Fatal("order select case %v", Oconv(int(l.N.Op), 0))
+ }
+ r = l.N.Left
+ setlineno(l.N)
+
+ // Append any new body prologue to ninit.
+ // The next loop will insert ninit into nbody.
+ if l.N.Ninit != nil {
+ Fatal("order select ninit")
+ }
+ if r != nil {
+ switch r.Op {
+ default:
+ Yyerror("unknown op in select %v", Oconv(int(r.Op), 0))
+ Dump("select case", r)
+
+ // If this is case x := <-ch or case x, y := <-ch, the case has
+ // the ODCL nodes to declare x and y. We want to delay that
+ // declaration (and possible allocation) until inside the case body.
+ // Delete the ODCL nodes here and recreate them inside the body below.
+ case OSELRECV,
+ OSELRECV2:
+ if r.Colas != 0 {
+ t = r.Ninit
+ if t != nil && t.N.Op == ODCL && t.N.Left == r.Left {
+ t = t.Next
+ }
+ if t != nil && t.N.Op == ODCL && t.N.Left == r.Ntest {
+ t = t.Next
+ }
+ if t == nil {
+ r.Ninit = nil
+ }
+ }
+
+ if r.Ninit != nil {
+ Yyerror("ninit on select recv")
+ dumplist("ninit", r.Ninit)
+ }
+
+ // case x = <-c
+ // case x, ok = <-c
+ // r->left is x, r->ntest is ok, r->right is ORECV, r->right->left is c.
+ // r->left == N means 'case <-c'.
+ // c is always evaluated; x and ok are only evaluated when assigned.
+ orderexpr(&r.Right.Left, order)
+
+ if r.Right.Left.Op != ONAME {
+ r.Right.Left = ordercopyexpr(r.Right.Left, r.Right.Left.Type, order, 0)
+ }
+
+ // Introduce temporary for receive and move actual copy into case body.
+ // avoids problems with target being addressed, as usual.
+ // NOTE: If we wanted to be clever, we could arrange for just one
+ // temporary per distinct type, sharing the temp among all receives
+ // with that temp. Similarly one ok bool could be shared among all
+ // the x,ok receives. Not worth doing until there's a clear need.
+ if r.Left != nil && isblank(r.Left) {
+ r.Left = nil
+ }
+ if r.Left != nil {
+ // use channel element type for temporary to avoid conversions,
+ // such as in case interfacevalue = <-intchan.
+ // the conversion happens in the OAS instead.
+ tmp1 = r.Left
+
+ if r.Colas != 0 {
+ tmp2 = Nod(ODCL, tmp1, nil)
+ typecheck(&tmp2, Etop)
+ l.N.Ninit = list(l.N.Ninit, tmp2)
+ }
+
+ r.Left = ordertemp(r.Right.Left.Type.Type, order, bool2int(haspointers(r.Right.Left.Type.Type)))
+ tmp2 = Nod(OAS, tmp1, r.Left)
+ typecheck(&tmp2, Etop)
+ l.N.Ninit = list(l.N.Ninit, tmp2)
+ }
+
+ if r.Ntest != nil && isblank(r.Ntest) {
+ r.Ntest = nil
+ }
+ if r.Ntest != nil {
+ tmp1 = r.Ntest
+ if r.Colas != 0 {
+ tmp2 = Nod(ODCL, tmp1, nil)
+ typecheck(&tmp2, Etop)
+ l.N.Ninit = list(l.N.Ninit, tmp2)
+ }
+
+ r.Ntest = ordertemp(tmp1.Type, order, 0)
+ tmp2 = Nod(OAS, tmp1, r.Ntest)
+ typecheck(&tmp2, Etop)
+ l.N.Ninit = list(l.N.Ninit, tmp2)
+ }
+
+ orderblock(&l.N.Ninit)
+
+ case OSEND:
+ if r.Ninit != nil {
+ Yyerror("ninit on select send")
+ dumplist("ninit", r.Ninit)
+ }
+
+ // case c <- x
+ // r->left is c, r->right is x, both are always evaluated.
+ orderexpr(&r.Left, order)
+
+ if !(istemp(r.Left) != 0) {
+ r.Left = ordercopyexpr(r.Left, r.Left.Type, order, 0)
+ }
+ orderexpr(&r.Right, order)
+ if !(istemp(r.Right) != 0) {
+ r.Right = ordercopyexpr(r.Right, r.Right.Type, order, 0)
+ }
+ }
+ }
+
+ orderblock(&l.N.Nbody)
+ }
+
+ // Now that we have accumulated all the temporaries, clean them.
+ // Also insert any ninit queued during the previous loop.
+ // (The temporary cleaning must follow that ninit work.)
+ for l = n.List; l != nil; l = l.Next {
+ cleantempnopop(t, order, &l.N.Ninit)
+ l.N.Nbody = concat(l.N.Ninit, l.N.Nbody)
+ l.N.Ninit = nil
+ }
+
+ order.out = list(order.out, n)
+ poptemp(t, order)
+
+ // Special: value being sent is passed as a pointer; make it addressable.
+ case OSEND:
+ t = marktemp(order)
+
+ orderexpr(&n.Left, order)
+ orderexpr(&n.Right, order)
+ orderaddrtemp(&n.Right, order)
+ order.out = list(order.out, n)
+ cleantemp(t, order)
+
+ // TODO(rsc): Clean temporaries more aggressively.
+ // Note that because walkswitch will rewrite some of the
+ // switch into a binary search, this is not as easy as it looks.
+ // (If we ran that code here we could invoke orderstmt on
+ // the if-else chain instead.)
+ // For now just clean all the temporaries at the end.
+ // In practice that's fine.
+ case OSWITCH:
+ t = marktemp(order)
+
+ orderexpr(&n.Ntest, order)
+ for l = n.List; l != nil; l = l.Next {
+ if l.N.Op != OXCASE {
+ Fatal("order switch case %v", Oconv(int(l.N.Op), 0))
+ }
+ orderexprlistinplace(l.N.List, order)
+ orderblock(&l.N.Nbody)
+ }
+
+ order.out = list(order.out, n)
+ cleantemp(t, order)
+ }
+
+ lineno = int32(lno)
+}
+
+// Orderexprlist orders the expression list l into order.
+func orderexprlist(l *NodeList, order *Order) {
+ for ; l != nil; l = l.Next {
+ orderexpr(&l.N, order)
+ }
+}
+
+// Orderexprlist orders the expression list l but saves
+// the side effects on the individual expression ninit lists.
+func orderexprlistinplace(l *NodeList, order *Order) {
+ for ; l != nil; l = l.Next {
+ orderexprinplace(&l.N, order)
+ }
+}
+
+// Orderexpr orders a single expression, appending side
+// effects to order->out as needed.
+func orderexpr(np **Node, order *Order) {
+ var n *Node
+ var mark *NodeList
+ var l *NodeList
+ var t *Type
+ var lno int
+ var haslit int
+ var hasbyte int
+
+ n = *np
+ if n == nil {
+ return
+ }
+
+ lno = int(setlineno(n))
+ orderinit(n, order)
+
+ switch n.Op {
+ default:
+ orderexpr(&n.Left, order)
+ orderexpr(&n.Right, order)
+ orderexprlist(n.List, order)
+ orderexprlist(n.Rlist, order)
+
+ // Addition of strings turns into a function call.
+ // Allocate a temporary to hold the strings.
+ // Fewer than 5 strings use direct runtime helpers.
+ case OADDSTR:
+ orderexprlist(n.List, order)
+
+ if count(n.List) > 5 {
+ t = typ(TARRAY)
+ t.Bound = int64(count(n.List))
+ t.Type = Types[TSTRING]
+ n.Alloc = ordertemp(t, order, 0)
+ }
+
+ // Mark string(byteSlice) arguments to reuse byteSlice backing
+ // buffer during conversion. String concatenation does not
+ // memorize the strings for later use, so it is safe.
+ // However, we can do it only if there is at least one non-empty string literal.
+ // Otherwise if all other arguments are empty strings,
+ // concatstrings will return the reference to the temp string
+ // to the caller.
+ hasbyte = 0
+
+ haslit = 0
+ for l = n.List; l != nil; l = l.Next {
+ hasbyte |= bool2int(l.N.Op == OARRAYBYTESTR)
+ haslit |= bool2int(l.N.Op == OLITERAL && len(l.N.Val.U.Sval.S) != 0)
+ }
+
+ if haslit != 0 && hasbyte != 0 {
+ for l = n.List; l != nil; l = l.Next {
+ if l.N.Op == OARRAYBYTESTR {
+ l.N.Op = OARRAYBYTESTRTMP
+ }
+ }
+ }
+
+ case OCMPSTR:
+ orderexpr(&n.Left, order)
+ orderexpr(&n.Right, order)
+
+ // Mark string(byteSlice) arguments to reuse byteSlice backing
+ // buffer during conversion. String comparison does not
+ // memorize the strings for later use, so it is safe.
+ if n.Left.Op == OARRAYBYTESTR {
+ n.Left.Op = OARRAYBYTESTRTMP
+ }
+ if n.Right.Op == OARRAYBYTESTR {
+ n.Right.Op = OARRAYBYTESTRTMP
+ }
+
+ // key must be addressable
+ case OINDEXMAP:
+ orderexpr(&n.Left, order)
+
+ orderexpr(&n.Right, order)
+
+ // For x = m[string(k)] where k is []byte, the allocation of
+ // backing bytes for the string can be avoided by reusing
+ // the []byte backing array. This is a special case that it
+ // would be nice to handle more generally, but because
+ // there are no []byte-keyed maps, this specific case comes
+ // up in important cases in practice. See issue 3512.
+ // Nothing can change the []byte we are not copying before
+ // the map index, because the map access is going to
+ // be forced to happen immediately following this
+ // conversion (by the ordercopyexpr a few lines below).
+ if n.Etype == 0 && n.Right.Op == OARRAYBYTESTR {
+ n.Right.Op = OARRAYBYTESTRTMP
+ }
+
+ orderaddrtemp(&n.Right, order)
+ if n.Etype == 0 {
+ // use of value (not being assigned);
+ // make copy in temporary.
+ n = ordercopyexpr(n, n.Type, order, 0)
+ }
+
+ // concrete type (not interface) argument must be addressable
+ // temporary to pass to runtime.
+ case OCONVIFACE:
+ orderexpr(&n.Left, order)
+
+ if !(Isinter(n.Left.Type) != 0) {
+ orderaddrtemp(&n.Left, order)
+ }
+
+ case OANDAND,
+ OOROR:
+ mark = marktemp(order)
+ orderexpr(&n.Left, order)
+
+ // Clean temporaries from first branch at beginning of second.
+ // Leave them on the stack so that they can be killed in the outer
+ // context in case the short circuit is taken.
+ l = nil
+
+ cleantempnopop(mark, order, &l)
+ n.Right.Ninit = concat(l, n.Right.Ninit)
+ orderexprinplace(&n.Right, order)
+
+ case OAPPEND,
+ OCALLFUNC,
+ OCALLINTER,
+ OCALLMETH,
+ OCAP,
+ OCOMPLEX,
+ OCOPY,
+ OIMAG,
+ OLEN,
+ OMAKECHAN,
+ OMAKEMAP,
+ OMAKESLICE,
+ ONEW,
+ OREAL,
+ ORECOVER:
+ ordercall(n, order)
+ n = ordercopyexpr(n, n.Type, order, 0)
+
+ case OCLOSURE:
+ if n.Noescape && n.Cvars != nil {
+ n.Alloc = ordertemp(Types[TUINT8], order, 0) // walk will fill in correct type
+ }
+
+ case OARRAYLIT,
+ OCALLPART:
+ orderexpr(&n.Left, order)
+ orderexpr(&n.Right, order)
+ orderexprlist(n.List, order)
+ orderexprlist(n.Rlist, order)
+ if n.Noescape {
+ n.Alloc = ordertemp(Types[TUINT8], order, 0) // walk will fill in correct type
+ }
+
+ case ODDDARG:
+ if n.Noescape {
+ // The ddd argument does not live beyond the call it is created for.
+ // Allocate a temporary that will be cleaned up when this statement
+ // completes. We could be more aggressive and try to arrange for it
+ // to be cleaned up when the call completes.
+ n.Alloc = ordertemp(n.Type.Type, order, 0)
+ }
+
+ case ORECV,
+ ODOTTYPE:
+ orderexpr(&n.Left, order)
+ n = ordercopyexpr(n, n.Type, order, 1)
+
+ case OEQ,
+ ONE:
+ orderexpr(&n.Left, order)
+ orderexpr(&n.Right, order)
+ t = n.Left.Type
+ if t.Etype == TSTRUCT || Isfixedarray(t) != 0 {
+ // for complex comparisons, we need both args to be
+ // addressable so we can pass them to the runtime.
+ orderaddrtemp(&n.Left, order)
+
+ orderaddrtemp(&n.Right, order)
+ }
+ }
+
+ lineno = int32(lno)
+
+ *np = n
+}
diff --git a/src/cmd/internal/gc/pgen.go b/src/cmd/internal/gc/pgen.go
new file mode 100644
index 0000000..052d7dc
--- /dev/null
+++ b/src/cmd/internal/gc/pgen.go
@@ -0,0 +1,597 @@
+// Copyright 2011 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
+
+import (
+ "cmd/internal/obj"
+ "fmt"
+ "strings"
+)
+
+// "Portable" code generation.
+// Compiled separately for 5g, 6g, and 8g, so allowed to use gg.h, opt.h.
+// Must code to the intersection of the three back ends.
+
+//#include "opt.h"
+
+var makefuncdatasym_nsym int32
+
+func makefuncdatasym(namefmt string, funcdatakind int64) *Sym {
+ var nod Node
+ var pnod *Node
+ var sym *Sym
+
+ namebuf = fmt.Sprintf(namefmt, makefuncdatasym_nsym)
+ makefuncdatasym_nsym++
+ sym = Lookup(namebuf)
+ pnod = newname(sym)
+ pnod.Class = PEXTERN
+ Nodconst(&nod, Types[TINT32], funcdatakind)
+ Thearch.Gins(obj.AFUNCDATA, &nod, pnod)
+ return sym
+}
+
+// gvardef inserts a VARDEF for n into the instruction stream.
+// VARDEF is an annotation for the liveness analysis, marking a place
+// where a complete initialization (definition) of a variable begins.
+// Since the liveness analysis can see initialization of single-word
+// variables quite easy, gvardef is usually only called for multi-word
+// or 'fat' variables, those satisfying isfat(n->type).
+// However, gvardef is also called when a non-fat variable is initialized
+// via a block move; the only time this happens is when you have
+// return f()
+// for a function with multiple return values exactly matching the return
+// types of the current function.
+//
+// A 'VARDEF x' annotation in the instruction stream tells the liveness
+// analysis to behave as though the variable x is being initialized at that
+// point in the instruction stream. The VARDEF must appear before the
+// actual (multi-instruction) initialization, and it must also appear after
+// any uses of the previous value, if any. For example, if compiling:
+//
+// x = x[1:]
+//
+// it is important to generate code like:
+//
+// base, len, cap = pieces of x[1:]
+// VARDEF x
+// x = {base, len, cap}
+//
+// If instead the generated code looked like:
+//
+// VARDEF x
+// base, len, cap = pieces of x[1:]
+// x = {base, len, cap}
+//
+// then the liveness analysis would decide the previous value of x was
+// unnecessary even though it is about to be used by the x[1:] computation.
+// Similarly, if the generated code looked like:
+//
+// base, len, cap = pieces of x[1:]
+// x = {base, len, cap}
+// VARDEF x
+//
+// then the liveness analysis will not preserve the new value of x, because
+// the VARDEF appears to have "overwritten" it.
+//
+// VARDEF is a bit of a kludge to work around the fact that the instruction
+// stream is working on single-word values but the liveness analysis
+// wants to work on individual variables, which might be multi-word
+// aggregates. It might make sense at some point to look into letting
+// the liveness analysis work on single-word values as well, although
+// there are complications around interface values, slices, and strings,
+// all of which cannot be treated as individual words.
+//
+// VARKILL is the opposite of VARDEF: it marks a value as no longer needed,
+// even if its address has been taken. That is, a VARKILL annotation asserts
+// that its argument is certainly dead, for use when the liveness analysis
+// would not otherwise be able to deduce that fact.
+
+func gvardefx(n *Node, as int) {
+ if n == nil {
+ Fatal("gvardef nil")
+ }
+ if n.Op != ONAME {
+ Yyerror("gvardef %v; %v", Oconv(int(n.Op), obj.FmtSharp), Nconv(n, 0))
+ return
+ }
+
+ switch n.Class {
+ case PAUTO,
+ PPARAM,
+ PPARAMOUT:
+ Thearch.Gins(as, nil, n)
+ }
+}
+
+func Gvardef(n *Node) {
+ gvardefx(n, obj.AVARDEF)
+}
+
+func gvarkill(n *Node) {
+ gvardefx(n, obj.AVARKILL)
+}
+
+func removevardef(firstp *obj.Prog) {
+ var p *obj.Prog
+
+ for p = firstp; p != nil; p = p.Link {
+ for p.Link != nil && (p.Link.As == obj.AVARDEF || p.Link.As == obj.AVARKILL) {
+ p.Link = p.Link.Link
+ }
+ if p.To.Type == obj.TYPE_BRANCH {
+ for p.To.U.Branch != nil && (p.To.U.Branch.As == obj.AVARDEF || p.To.U.Branch.As == obj.AVARKILL) {
+ p.To.U.Branch = p.To.U.Branch.Link
+ }
+ }
+ }
+}
+
+func gcsymdup(s *Sym) {
+ var ls *obj.LSym
+ var lo uint64
+ var hi uint64
+
+ ls = Linksym(s)
+ if len(ls.R) > 0 {
+ Fatal("cannot rosymdup %s with relocations", ls.Name)
+ }
+ var d MD5
+ md5reset(&d)
+ md5write(&d, ls.P, len(ls.P))
+ lo = md5sum(&d, &hi)
+ ls.Name = fmt.Sprintf("gclocals·%016x%016x", lo, hi)
+ ls.Dupok = 1
+}
+
+func emitptrargsmap() {
+ var nptr int
+ var nbitmap int
+ var j int
+ var off int
+ var xoffset int64
+ var bv *Bvec
+ var sym *Sym
+
+ sym = Lookup(fmt.Sprintf("%s.args_stackmap", Curfn.Nname.Sym.Name))
+
+ nptr = int(Curfn.Type.Argwid / int64(Widthptr))
+ bv = bvalloc(int32(nptr) * 2)
+ nbitmap = 1
+ if Curfn.Type.Outtuple > 0 {
+ nbitmap = 2
+ }
+ off = duint32(sym, 0, uint32(nbitmap))
+ off = duint32(sym, off, uint32(bv.n))
+ if Curfn.Type.Thistuple > 0 {
+ xoffset = 0
+ twobitwalktype1(getthisx(Curfn.Type), &xoffset, bv)
+ }
+
+ if Curfn.Type.Intuple > 0 {
+ xoffset = 0
+ twobitwalktype1(getinargx(Curfn.Type), &xoffset, bv)
+ }
+
+ for j = 0; int32(j) < bv.n; j += 32 {
+ off = duint32(sym, off, bv.b[j/32])
+ }
+ if Curfn.Type.Outtuple > 0 {
+ xoffset = 0
+ twobitwalktype1(getoutargx(Curfn.Type), &xoffset, bv)
+ for j = 0; int32(j) < bv.n; j += 32 {
+ off = duint32(sym, off, bv.b[j/32])
+ }
+ }
+
+ ggloblsym(sym, int32(off), obj.RODATA)
+}
+
+// Sort the list of stack variables. Autos after anything else,
+// within autos, unused after used, within used, things with
+// pointers first, zeroed things first, and then decreasing size.
+// Because autos are laid out in decreasing addresses
+// on the stack, pointers first, zeroed things first and decreasing size
+// really means, in memory, things with pointers needing zeroing at
+// the top of the stack and increasing in size.
+// Non-autos sort on offset.
+func cmpstackvar(a *Node, b *Node) int {
+ var ap int
+ var bp int
+
+ if a.Class != b.Class {
+ if a.Class == PAUTO {
+ return +1
+ }
+ return -1
+ }
+
+ if a.Class != PAUTO {
+ if a.Xoffset < b.Xoffset {
+ return -1
+ }
+ if a.Xoffset > b.Xoffset {
+ return +1
+ }
+ return 0
+ }
+
+ if (a.Used == 0) != (b.Used == 0) {
+ return int(b.Used) - int(a.Used)
+ }
+
+ ap = bool2int(haspointers(a.Type))
+ bp = bool2int(haspointers(b.Type))
+ if ap != bp {
+ return bp - ap
+ }
+
+ ap = int(a.Needzero)
+ bp = int(b.Needzero)
+ if ap != bp {
+ return bp - ap
+ }
+
+ if a.Type.Width < b.Type.Width {
+ return +1
+ }
+ if a.Type.Width > b.Type.Width {
+ return -1
+ }
+
+ return stringsCompare(a.Sym.Name, b.Sym.Name)
+}
+
+// TODO(lvd) find out where the PAUTO/OLITERAL nodes come from.
+func allocauto(ptxt *obj.Prog) {
+ var ll *NodeList
+ var n *Node
+ var w int64
+
+ Stksize = 0
+ stkptrsize = 0
+
+ if Curfn.Dcl == nil {
+ return
+ }
+
+ // Mark the PAUTO's unused.
+ for ll = Curfn.Dcl; ll != nil; ll = ll.Next {
+ if ll.N.Class == PAUTO {
+ ll.N.Used = 0
+ }
+ }
+
+ markautoused(ptxt)
+
+ listsort(&Curfn.Dcl, cmpstackvar)
+
+ // Unused autos are at the end, chop 'em off.
+ ll = Curfn.Dcl
+
+ n = ll.N
+ if n.Class == PAUTO && n.Op == ONAME && !(n.Used != 0) {
+ // No locals used at all
+ Curfn.Dcl = nil
+
+ fixautoused(ptxt)
+ return
+ }
+
+ for ll = Curfn.Dcl; ll.Next != nil; ll = ll.Next {
+ n = ll.Next.N
+ if n.Class == PAUTO && n.Op == ONAME && !(n.Used != 0) {
+ ll.Next = nil
+ Curfn.Dcl.End = ll
+ break
+ }
+ }
+
+ // Reassign stack offsets of the locals that are still there.
+ for ll = Curfn.Dcl; ll != nil; ll = ll.Next {
+ n = ll.N
+ if n.Class != PAUTO || n.Op != ONAME {
+ continue
+ }
+
+ dowidth(n.Type)
+ w = n.Type.Width
+ if w >= Thearch.MAXWIDTH || w < 0 {
+ Fatal("bad width")
+ }
+ Stksize += w
+ Stksize = Rnd(Stksize, int64(n.Type.Align))
+ if haspointers(n.Type) {
+ stkptrsize = Stksize
+ }
+ if Thearch.Thechar == '5' || Thearch.Thechar == '9' {
+ Stksize = Rnd(Stksize, int64(Widthptr))
+ }
+ if Stksize >= 1<<31 {
+ setlineno(Curfn)
+ Yyerror("stack frame too large (>2GB)")
+ }
+
+ n.Stkdelta = -Stksize - n.Xoffset
+ }
+
+ Stksize = Rnd(Stksize, int64(Widthreg))
+ stkptrsize = Rnd(stkptrsize, int64(Widthreg))
+
+ fixautoused(ptxt)
+
+ // The debug information needs accurate offsets on the symbols.
+ for ll = Curfn.Dcl; ll != nil; ll = ll.Next {
+ if ll.N.Class != PAUTO || ll.N.Op != ONAME {
+ continue
+ }
+ ll.N.Xoffset += ll.N.Stkdelta
+ ll.N.Stkdelta = 0
+ }
+}
+
+func movelarge(l *NodeList) {
+ for ; l != nil; l = l.Next {
+ if l.N.Op == ODCLFUNC {
+ movelargefn(l.N)
+ }
+ }
+}
+
+func movelargefn(fn *Node) {
+ var l *NodeList
+ var n *Node
+
+ for l = fn.Dcl; l != nil; l = l.Next {
+ n = l.N
+ if n.Class == PAUTO && n.Type != nil && n.Type.Width > MaxStackVarSize {
+ addrescapes(n)
+ }
+ }
+}
+
+func Cgen_checknil(n *Node) {
+ var reg Node
+
+ if Disable_checknil != 0 {
+ return
+ }
+
+ // Ideally we wouldn't see any integer types here, but we do.
+ if n.Type == nil || (!(Isptr[n.Type.Etype] != 0) && !(Isint[n.Type.Etype] != 0) && n.Type.Etype != TUNSAFEPTR) {
+ Dump("checknil", n)
+ Fatal("bad checknil")
+ }
+
+ if ((Thearch.Thechar == '5' || Thearch.Thechar == '9') && n.Op != OREGISTER) || !(n.Addable != 0) || n.Op == OLITERAL {
+ Thearch.Regalloc(®, Types[Tptr], n)
+ Thearch.Cgen(n, ®)
+ Thearch.Gins(obj.ACHECKNIL, ®, nil)
+ Thearch.Regfree(®)
+ return
+ }
+
+ Thearch.Gins(obj.ACHECKNIL, n, nil)
+}
+
+/*
+ * ggen.c
+ */
+func compile(fn *Node) {
+ var pl *obj.Plist
+ var nod1 Node
+ var n *Node
+ var ptxt *obj.Prog
+ var p *obj.Prog
+ var lno int32
+ var t *Type
+ var save Iter
+ var oldstksize int64
+ var l *NodeList
+ var nam *Node
+ var gcargs *Sym
+ var gclocals *Sym
+
+ if Newproc == nil {
+ Newproc = Sysfunc("newproc")
+ Deferproc = Sysfunc("deferproc")
+ Deferreturn = Sysfunc("deferreturn")
+ Panicindex = Sysfunc("panicindex")
+ panicslice = Sysfunc("panicslice")
+ throwreturn = Sysfunc("throwreturn")
+ }
+
+ lno = setlineno(fn)
+
+ Curfn = fn
+ dowidth(Curfn.Type)
+
+ if fn.Nbody == nil {
+ if pure_go != 0 || strings.HasPrefix(fn.Nname.Sym.Name, "init·") {
+ Yyerror("missing function body", fn)
+ goto ret
+ }
+
+ if Debug['A'] != 0 {
+ goto ret
+ }
+ emitptrargsmap()
+ goto ret
+ }
+
+ saveerrors()
+
+ // set up domain for labels
+ clearlabels()
+
+ if Curfn.Type.Outnamed != 0 {
+ // add clearing of the output parameters
+ t = Structfirst(&save, Getoutarg(Curfn.Type))
+
+ for t != nil {
+ if t.Nname != nil {
+ n = Nod(OAS, t.Nname, nil)
+ typecheck(&n, Etop)
+ Curfn.Nbody = concat(list1(n), Curfn.Nbody)
+ }
+
+ t = structnext(&save)
+ }
+ }
+
+ order(Curfn)
+ if nerrors != 0 {
+ goto ret
+ }
+
+ Hasdefer = 0
+ walk(Curfn)
+ if nerrors != 0 {
+ goto ret
+ }
+ if flag_race != 0 {
+ racewalk(Curfn)
+ }
+ if nerrors != 0 {
+ goto ret
+ }
+
+ continpc = nil
+ breakpc = nil
+
+ pl = newplist()
+ pl.Name = Linksym(Curfn.Nname.Sym)
+
+ setlineno(Curfn)
+
+ Nodconst(&nod1, Types[TINT32], 0)
+ nam = Curfn.Nname
+ if isblank(nam) {
+ nam = nil
+ }
+ ptxt = Thearch.Gins(obj.ATEXT, nam, &nod1)
+ if fn.Dupok != 0 {
+ ptxt.From3.Offset |= obj.DUPOK
+ }
+ if fn.Wrapper != 0 {
+ ptxt.From3.Offset |= obj.WRAPPER
+ }
+ if fn.Needctxt != 0 {
+ ptxt.From3.Offset |= obj.NEEDCTXT
+ }
+ if fn.Nosplit {
+ ptxt.From3.Offset |= obj.NOSPLIT
+ }
+
+ // Clumsy but important.
+ // See test/recover.go for test cases and src/reflect/value.go
+ // for the actual functions being considered.
+ if myimportpath != "" && myimportpath == "reflect" {
+ if Curfn.Nname.Sym.Name == "callReflect" || Curfn.Nname.Sym.Name == "callMethod" {
+ ptxt.From3.Offset |= obj.WRAPPER
+ }
+ }
+
+ Afunclit(&ptxt.From, Curfn.Nname)
+
+ Thearch.Ginit()
+
+ gcargs = makefuncdatasym("gcargs·%d", obj.FUNCDATA_ArgsPointerMaps)
+ gclocals = makefuncdatasym("gclocals·%d", obj.FUNCDATA_LocalsPointerMaps)
+
+ for t = Curfn.Paramfld; t != nil; t = t.Down {
+ gtrack(tracksym(t.Type))
+ }
+
+ for l = fn.Dcl; l != nil; l = l.Next {
+ n = l.N
+ if n.Op != ONAME { // might be OTYPE or OLITERAL
+ continue
+ }
+ switch n.Class {
+ case PAUTO,
+ PPARAM,
+ PPARAMOUT:
+ Nodconst(&nod1, Types[TUINTPTR], l.N.Type.Width)
+ p = Thearch.Gins(obj.ATYPE, l.N, &nod1)
+ p.From.Gotype = Linksym(ngotype(l.N))
+ }
+ }
+
+ Genlist(Curfn.Enter)
+ Genlist(Curfn.Nbody)
+ Thearch.Gclean()
+ checklabels()
+ if nerrors != 0 {
+ goto ret
+ }
+ if Curfn.Endlineno != 0 {
+ lineno = Curfn.Endlineno
+ }
+
+ if Curfn.Type.Outtuple != 0 {
+ Thearch.Ginscall(throwreturn, 0)
+ }
+
+ Thearch.Ginit()
+
+ // TODO: Determine when the final cgen_ret can be omitted. Perhaps always?
+ Thearch.Cgen_ret(nil)
+
+ if Hasdefer != 0 {
+ // deferreturn pretends to have one uintptr argument.
+ // Reserve space for it so stack scanner is happy.
+ if Maxarg < int64(Widthptr) {
+ Maxarg = int64(Widthptr)
+ }
+ }
+
+ Thearch.Gclean()
+ if nerrors != 0 {
+ goto ret
+ }
+
+ Pc.As = obj.ARET // overwrite AEND
+ Pc.Lineno = lineno
+
+ fixjmp(ptxt)
+ if !(Debug['N'] != 0) || Debug['R'] != 0 || Debug['P'] != 0 {
+ regopt(ptxt)
+ nilopt(ptxt)
+ }
+
+ Thearch.Expandchecks(ptxt)
+
+ oldstksize = Stksize
+ allocauto(ptxt)
+
+ if false {
+ fmt.Printf("allocauto: %d to %d\n", oldstksize, int64(Stksize))
+ }
+
+ setlineno(Curfn)
+ if int64(Stksize)+Maxarg > 1<<31 {
+ Yyerror("stack frame too large (>2GB)")
+ goto ret
+ }
+
+ // Emit garbage collection symbols.
+ liveness(Curfn, ptxt, gcargs, gclocals)
+
+ gcsymdup(gcargs)
+ gcsymdup(gclocals)
+
+ Thearch.Defframe(ptxt)
+
+ if Debug['f'] != 0 {
+ frame(0)
+ }
+
+ // Remove leftover instrumentation from the instruction stream.
+ removevardef(ptxt)
+
+ret:
+ lineno = lno
+}
diff --git a/src/cmd/internal/gc/plive.go b/src/cmd/internal/gc/plive.go
new file mode 100644
index 0000000..04173fc
--- /dev/null
+++ b/src/cmd/internal/gc/plive.go
@@ -0,0 +1,2018 @@
+// Copyright 2013 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
+
+import (
+ "cmd/internal/obj"
+ "fmt"
+ "sort"
+)
+
+const (
+ UNVISITED = 0
+ VISITED = 1
+)
+
+// An ordinary basic block.
+//
+// Instructions are threaded together in a doubly-linked list. To iterate in
+// program order follow the link pointer from the first node and stop after the
+// last node has been visited
+//
+// for(p = bb->first;; p = p->link) {
+// ...
+// if(p == bb->last)
+// break;
+// }
+//
+// To iterate in reverse program order by following the opt pointer from the
+// last node
+//
+// for(p = bb->last; p != nil; p = p->opt) {
+// ...
+// }
+type BasicBlock struct {
+ pred []*BasicBlock
+ succ []*BasicBlock
+ first *obj.Prog
+ last *obj.Prog
+ rpo int
+ mark int
+ lastbitmapindex int
+}
+
+// A collection of global state used by liveness analysis.
+type Liveness struct {
+ fn *Node
+ ptxt *obj.Prog
+ vars []*Node
+ cfg []*BasicBlock
+ uevar []*Bvec
+ varkill []*Bvec
+ livein []*Bvec
+ liveout []*Bvec
+ avarinit []*Bvec
+ avarinitany []*Bvec
+ avarinitall []*Bvec
+ argslivepointers []*Bvec
+ livepointers []*Bvec
+}
+
+func xmalloc(size uint32) interface{} {
+ var result interface{}
+
+ result = make([]byte, size)
+ if result == nil {
+ Fatal("malloc failed")
+ }
+ return result
+}
+
+// Constructs a new basic block containing a single instruction.
+func newblock(prog *obj.Prog) *BasicBlock {
+ var result *BasicBlock
+
+ if prog == nil {
+ Fatal("newblock: prog cannot be nil")
+ }
+ result = new(BasicBlock)
+ result.rpo = -1
+ result.mark = UNVISITED
+ result.first = prog
+ result.last = prog
+ result.pred = make([]*BasicBlock, 0, 2)
+ result.succ = make([]*BasicBlock, 0, 2)
+ return result
+}
+
+// Frees a basic block and all of its leaf data structures.
+func freeblock(bb *BasicBlock) {
+ if bb == nil {
+ Fatal("freeblock: cannot free nil")
+ }
+}
+
+// Adds an edge between two basic blocks by making from a predecessor of to and
+// to a successor of from.
+func addedge(from *BasicBlock, to *BasicBlock) {
+ if from == nil {
+ Fatal("addedge: from is nil")
+ }
+ if to == nil {
+ Fatal("addedge: to is nil")
+ }
+ from.succ = append(from.succ, to)
+ to.pred = append(to.pred, from)
+}
+
+// Inserts prev before curr in the instruction
+// stream. Any control flow, such as branches or fall throughs, that target the
+// existing instruction are adjusted to target the new instruction.
+func splicebefore(lv *Liveness, bb *BasicBlock, prev *obj.Prog, curr *obj.Prog) {
+ var next *obj.Prog
+ var tmp obj.Prog
+
+ // There may be other instructions pointing at curr,
+ // and we want them to now point at prev. Instead of
+ // trying to find all such instructions, swap the contents
+ // so that the problem becomes inserting next after curr.
+ // The "opt" field is the backward link in the linked list.
+
+ // Overwrite curr's data with prev, but keep the list links.
+ tmp = *curr
+
+ *curr = *prev
+ curr.Opt = tmp.Opt
+ curr.Link = tmp.Link
+
+ // Overwrite prev (now next) with curr's old data.
+ next = prev
+
+ *next = tmp
+ next.Opt = nil
+ next.Link = nil
+
+ // Now insert next after curr.
+ next.Link = curr.Link
+
+ next.Opt = curr
+ curr.Link = next
+ if next.Link != nil && next.Link.Opt == curr {
+ next.Link.Opt = next
+ }
+
+ if bb.last == curr {
+ bb.last = next
+ }
+}
+
+// A pretty printer for basic blocks.
+func printblock(bb *BasicBlock) {
+ var pred *BasicBlock
+ var succ *BasicBlock
+ var prog *obj.Prog
+ var i int
+
+ fmt.Printf("basic block %d\n", bb.rpo)
+ fmt.Printf("\tpred:")
+ for i = 0; i < len(bb.pred); i++ {
+ pred = bb.pred[i]
+ fmt.Printf(" %d", pred.rpo)
+ }
+
+ fmt.Printf("\n")
+ fmt.Printf("\tsucc:")
+ for i = 0; i < len(bb.succ); i++ {
+ succ = bb.succ[i]
+ fmt.Printf(" %d", succ.rpo)
+ }
+
+ fmt.Printf("\n")
+ fmt.Printf("\tprog:\n")
+ for prog = bb.first; ; prog = prog.Link {
+ fmt.Printf("\t\t%v\n", prog)
+ if prog == bb.last {
+ break
+ }
+ }
+}
+
+// Iterates over a basic block applying a callback to each instruction. There
+// are two criteria for termination. If the end of basic block is reached a
+// value of zero is returned. If the callback returns a non-zero value, the
+// iteration is stopped and the value of the callback is returned.
+func blockany(bb *BasicBlock, callback func(*obj.Prog) int) int {
+ var p *obj.Prog
+ var result int
+
+ for p = bb.last; p != nil; p = p.Opt.(*obj.Prog) {
+ result = callback(p)
+ if result != 0 {
+ return result
+ }
+ }
+
+ return 0
+}
+
+// Collects and returns and array of Node*s for functions arguments and local
+// variables.
+func getvariables(fn *Node) []*Node {
+ var result []*Node
+ var ll *NodeList
+
+ result = make([]*Node, 0, 0)
+ for ll = fn.Dcl; ll != nil; ll = ll.Next {
+ if ll.N.Op == ONAME {
+ // In order for GODEBUG=gcdead=1 to work, each bitmap needs
+ // to contain information about all variables covered by the bitmap.
+ // For local variables, the bitmap only covers the stkptrsize
+ // bytes in the frame where variables containing pointers live.
+ // For arguments and results, the bitmap covers all variables,
+ // so we must include all the variables, even the ones without
+ // pointers.
+ //
+ // The Node.opt field is available for use by optimization passes.
+ // We use it to hold the index of the node in the variables array, plus 1
+ // (so that 0 means the Node is not in the variables array).
+ // Each pass should clear opt when done, but you never know,
+ // so clear them all ourselves too.
+ // The Node.curfn field is supposed to be set to the current function
+ // already, but for some compiler-introduced names it seems not to be,
+ // so fix that here.
+ // Later, when we want to find the index of a node in the variables list,
+ // we will check that n->curfn == curfn and n->opt > 0. Then n->opt - 1
+ // is the index in the variables list.
+ ll.N.Opt = nil
+
+ ll.N.Curfn = Curfn
+ switch ll.N.Class {
+ case PAUTO:
+ if haspointers(ll.N.Type) {
+ ll.N.Opt = int32(len(result))
+ result = append(result, ll.N)
+ }
+
+ case PPARAM,
+ PPARAMOUT:
+ ll.N.Opt = int32(len(result))
+ result = append(result, ll.N)
+ }
+ }
+ }
+
+ return result
+}
+
+// A pretty printer for control flow graphs. Takes an array of BasicBlock*s.
+func printcfg(cfg []*BasicBlock) {
+ var bb *BasicBlock
+ var i int32
+
+ for i = 0; i < int32(len(cfg)); i++ {
+ bb = cfg[i]
+ printblock(bb)
+ }
+}
+
+// Assigns a reverse post order number to each connected basic block using the
+// standard algorithm. Unconnected blocks will not be affected.
+func reversepostorder(root *BasicBlock, rpo *int32) {
+ var bb *BasicBlock
+ var i int
+
+ root.mark = VISITED
+ for i = 0; i < len(root.succ); i++ {
+ bb = root.succ[i]
+ if bb.mark == UNVISITED {
+ reversepostorder(bb, rpo)
+ }
+ }
+
+ *rpo -= 1
+ root.rpo = int(*rpo)
+}
+
+// Comparison predicate used for sorting basic blocks by their rpo in ascending
+// order.
+type blockrpocmp []*BasicBlock
+
+func (x blockrpocmp) Len() int { return len(x) }
+func (x blockrpocmp) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
+func (x blockrpocmp) Less(i, j int) bool { return x[i].rpo < x[j].rpo }
+
+// A pattern matcher for call instructions. Returns true when the instruction
+// is a call to a specific package qualified function name.
+func iscall(prog *obj.Prog, name *obj.LSym) bool {
+ if prog == nil {
+ Fatal("iscall: prog is nil")
+ }
+ if name == nil {
+ Fatal("iscall: function name is nil")
+ }
+ if prog.As != obj.ACALL {
+ return false
+ }
+ return name == prog.To.Sym
+}
+
+// Returns true for instructions that call a runtime function implementing a
+// select communication clause.
+
+var isselectcommcasecall_names [5]*obj.LSym
+
+func isselectcommcasecall(prog *obj.Prog) int {
+ var i int32
+
+ if isselectcommcasecall_names[0] == nil {
+ isselectcommcasecall_names[0] = Linksym(Pkglookup("selectsend", Runtimepkg))
+ isselectcommcasecall_names[1] = Linksym(Pkglookup("selectrecv", Runtimepkg))
+ isselectcommcasecall_names[2] = Linksym(Pkglookup("selectrecv2", Runtimepkg))
+ isselectcommcasecall_names[3] = Linksym(Pkglookup("selectdefault", Runtimepkg))
+ }
+
+ for i = 0; isselectcommcasecall_names[i] != nil; i++ {
+ if iscall(prog, isselectcommcasecall_names[i]) {
+ return 1
+ }
+ }
+ return 0
+}
+
+// Returns true for call instructions that target runtime·newselect.
+
+var isnewselect_sym *obj.LSym
+
+func isnewselect(prog *obj.Prog) int {
+ if isnewselect_sym == nil {
+ isnewselect_sym = Linksym(Pkglookup("newselect", Runtimepkg))
+ }
+ return bool2int(iscall(prog, isnewselect_sym))
+}
+
+// Returns true for call instructions that target runtime·selectgo.
+
+var isselectgocall_sym *obj.LSym
+
+func isselectgocall(prog *obj.Prog) int {
+ if isselectgocall_sym == nil {
+ isselectgocall_sym = Linksym(Pkglookup("selectgo", Runtimepkg))
+ }
+ return bool2int(iscall(prog, isselectgocall_sym))
+}
+
+var isdeferreturn_sym *obj.LSym
+
+func isdeferreturn(prog *obj.Prog) int {
+ if isdeferreturn_sym == nil {
+ isdeferreturn_sym = Linksym(Pkglookup("deferreturn", Runtimepkg))
+ }
+ return bool2int(iscall(prog, isdeferreturn_sym))
+}
+
+// Walk backwards from a runtime·selectgo call up to its immediately dominating
+// runtime·newselect call. Any successor nodes of communication clause nodes
+// are implicit successors of the runtime·selectgo call node. The goal of this
+// analysis is to add these missing edges to complete the control flow graph.
+func addselectgosucc(selectgo *BasicBlock) {
+ var pred *BasicBlock
+ var succ *BasicBlock
+
+ pred = selectgo
+ for {
+ if len(pred.pred) == 0 {
+ Fatal("selectgo does not have a newselect")
+ }
+ pred = pred.pred[0]
+ if blockany(pred, isselectcommcasecall) != 0 {
+ // A select comm case block should have exactly one
+ // successor.
+ if len(pred.succ) != 1 {
+ Fatal("select comm case has too many successors")
+ }
+ succ = pred.succ[0]
+
+ // Its successor should have exactly two successors.
+ // The drop through should flow to the selectgo block
+ // and the branch should lead to the select case
+ // statements block.
+ if len(succ.succ) != 2 {
+ Fatal("select comm case successor has too many successors")
+ }
+
+ // Add the block as a successor of the selectgo block.
+ addedge(selectgo, succ)
+ }
+
+ if blockany(pred, isnewselect) != 0 {
+ // Reached the matching newselect.
+ break
+ }
+ }
+}
+
+// The entry point for the missing selectgo control flow algorithm. Takes an
+// array of BasicBlock*s containing selectgo calls.
+func fixselectgo(selectgo []*BasicBlock) {
+ var bb *BasicBlock
+ var i int32
+
+ for i = 0; i < int32(len(selectgo)); i++ {
+ bb = selectgo[i]
+ addselectgosucc(bb)
+ }
+}
+
+// Constructs a control flow graph from a sequence of instructions. This
+// procedure is complicated by various sources of implicit control flow that are
+// not accounted for using the standard cfg construction algorithm. Returns an
+// array of BasicBlock*s in control flow graph form (basic blocks ordered by
+// their RPO number).
+func newcfg(firstp *obj.Prog) []*BasicBlock {
+ var p *obj.Prog
+ var prev *obj.Prog
+ var bb *BasicBlock
+ var cfg []*BasicBlock
+ var selectgo []*BasicBlock
+ var i int32
+ var rpo int32
+
+ // Reset the opt field of each prog to nil. In the first and second
+ // passes, instructions that are labels temporarily use the opt field to
+ // point to their basic block. In the third pass, the opt field reset
+ // to point to the predecessor of an instruction in its basic block.
+ for p = firstp; p != nil; p = p.Link {
+ p.Opt = nil
+ }
+
+ // Allocate an array to remember where we have seen selectgo calls.
+ // These blocks will be revisited to add successor control flow edges.
+ selectgo = make([]*BasicBlock, 0, 0)
+
+ // Loop through all instructions identifying branch targets
+ // and fall-throughs and allocate basic blocks.
+ cfg = make([]*BasicBlock, 0, 0)
+
+ bb = newblock(firstp)
+ cfg = append(cfg, bb)
+ for p = firstp; p != nil; p = p.Link {
+ if p.To.Type == obj.TYPE_BRANCH {
+ if p.To.U.Branch == nil {
+ Fatal("prog branch to nil")
+ }
+ if p.To.U.Branch.Opt == nil {
+ p.To.U.Branch.Opt = newblock(p.To.U.Branch)
+ cfg = append(cfg, p.To.U.Branch.Opt.(*BasicBlock))
+ }
+
+ if p.As != obj.AJMP && p.Link != nil && p.Link.Opt == nil {
+ p.Link.Opt = newblock(p.Link)
+ cfg = append(cfg, p.Link.Opt.(*BasicBlock))
+ }
+ } else if isselectcommcasecall(p) != 0 || isselectgocall(p) != 0 {
+ // Accommodate implicit selectgo control flow.
+ if p.Link.Opt == nil {
+ p.Link.Opt = newblock(p.Link)
+ cfg = append(cfg, p.Link.Opt.(*BasicBlock))
+ }
+ }
+ }
+
+ // Loop through all basic blocks maximally growing the list of
+ // contained instructions until a label is reached. Add edges
+ // for branches and fall-through instructions.
+ for i = 0; i < int32(len(cfg)); i++ {
+ bb = cfg[i]
+ for p = bb.last; p != nil; p = p.Link {
+ if p.Opt != nil && p != bb.last {
+ break
+ }
+ bb.last = p
+
+ // Stop before an unreachable RET, to avoid creating
+ // unreachable control flow nodes.
+ if p.Link != nil && p.Link.As == obj.ARET && p.Link.Mode == 1 {
+ break
+ }
+
+ // Collect basic blocks with selectgo calls.
+ if isselectgocall(p) != 0 {
+ selectgo = append(selectgo, bb)
+ }
+ }
+
+ if bb.last.To.Type == obj.TYPE_BRANCH {
+ addedge(bb, bb.last.To.U.Branch.Opt.(*BasicBlock))
+ }
+ if bb.last.Link != nil {
+ // Add a fall-through when the instruction is
+ // not an unconditional control transfer.
+ if bb.last.As != obj.AJMP && bb.last.As != obj.ARET && bb.last.As != obj.AUNDEF {
+ addedge(bb, bb.last.Link.Opt.(*BasicBlock))
+ }
+ }
+ }
+
+ // Add back links so the instructions in a basic block can be traversed
+ // backward. This is the final state of the instruction opt field.
+ for i = 0; i < int32(len(cfg)); i++ {
+ bb = cfg[i]
+ p = bb.first
+ prev = nil
+ for {
+ p.Opt = prev
+ if p == bb.last {
+ break
+ }
+ prev = p
+ p = p.Link
+ }
+ }
+
+ // Add missing successor edges to the selectgo blocks.
+ if len(selectgo) != 0 {
+ fixselectgo([]*BasicBlock(selectgo))
+ }
+
+ // Find a depth-first order and assign a depth-first number to
+ // all basic blocks.
+ for i = 0; i < int32(len(cfg)); i++ {
+ bb = cfg[i]
+ bb.mark = UNVISITED
+ }
+
+ bb = cfg[0]
+ rpo = int32(len(cfg))
+ reversepostorder(bb, &rpo)
+
+ // Sort the basic blocks by their depth first number. The
+ // array is now a depth-first spanning tree with the first
+ // node being the root.
+ sort.Sort(blockrpocmp(cfg))
+
+ bb = cfg[0]
+
+ // Unreachable control flow nodes are indicated by a -1 in the rpo
+ // field. If we see these nodes something must have gone wrong in an
+ // upstream compilation phase.
+ if bb.rpo == -1 {
+ fmt.Printf("newcfg: unreachable basic block for %v\n", bb.last)
+ printcfg(cfg)
+ Fatal("newcfg: invalid control flow graph")
+ }
+
+ return cfg
+}
+
+// Frees a control flow graph (an array of BasicBlock*s) and all of its leaf
+// data structures.
+func freecfg(cfg []*BasicBlock) {
+ var bb *BasicBlock
+ var bb0 *BasicBlock
+ var p *obj.Prog
+ var i int32
+ var n int32
+
+ n = int32(len(cfg))
+ if n > 0 {
+ bb0 = cfg[0]
+ for p = bb0.first; p != nil; p = p.Link {
+ p.Opt = nil
+ }
+
+ for i = 0; i < n; i++ {
+ bb = cfg[i]
+ freeblock(bb)
+ }
+ }
+}
+
+// Returns true if the node names a variable that is otherwise uninteresting to
+// the liveness computation.
+func isfunny(n *Node) bool {
+ return n.Sym != nil && (n.Sym.Name == ".fp" || n.Sym.Name == ".args")
+}
+
+// Computes the effects of an instruction on a set of
+// variables. The vars argument is an array of Node*s.
+//
+// The output vectors give bits for variables:
+// uevar - used by this instruction
+// varkill - killed by this instruction
+// for variables without address taken, means variable was set
+// for variables with address taken, means variable was marked dead
+// avarinit - initialized or referred to by this instruction,
+// only for variables with address taken but not escaping to heap
+//
+// The avarinit output serves as a signal that the data has been
+// initialized, because any use of a variable must come after its
+// initialization.
+func progeffects(prog *obj.Prog, vars []*Node, uevar *Bvec, varkill *Bvec, avarinit *Bvec) {
+ var info ProgInfo
+ var from *obj.Addr
+ var to *obj.Addr
+ var node *Node
+ var i int32
+
+ bvresetall(uevar)
+ bvresetall(varkill)
+ bvresetall(avarinit)
+
+ Thearch.Proginfo(&info, prog)
+ if prog.As == obj.ARET {
+ // Return instructions implicitly read all the arguments. For
+ // the sake of correctness, out arguments must be read. For the
+ // sake of backtrace quality, we read in arguments as well.
+ //
+ // A return instruction with a p->to is a tail return, which brings
+ // the stack pointer back up (if it ever went down) and then jumps
+ // to a new function entirely. That form of instruction must read
+ // all the parameters for correctness, and similarly it must not
+ // read the out arguments - they won't be set until the new
+ // function runs.
+ for i = 0; i < int32(len(vars)); i++ {
+ node = vars[i]
+ switch node.Class &^ PHEAP {
+ case PPARAM:
+ bvset(uevar, i)
+
+ // If the result had its address taken, it is being tracked
+ // by the avarinit code, which does not use uevar.
+ // If we added it to uevar too, we'd not see any kill
+ // and decide that the varible was live entry, which it is not.
+ // So only use uevar in the non-addrtaken case.
+ // The p->to.type == thearch.D_NONE limits the bvset to
+ // non-tail-call return instructions; see note above
+ // the for loop for details.
+ case PPARAMOUT:
+ if !(node.Addrtaken != 0) && prog.To.Type == obj.TYPE_NONE {
+ bvset(uevar, i)
+ }
+ }
+ }
+
+ return
+ }
+
+ if prog.As == obj.ATEXT {
+ // A text instruction marks the entry point to a function and
+ // the definition point of all in arguments.
+ for i = 0; i < int32(len(vars)); i++ {
+ node = vars[i]
+ switch node.Class &^ PHEAP {
+ case PPARAM:
+ if node.Addrtaken != 0 {
+ bvset(avarinit, i)
+ }
+ bvset(varkill, i)
+ }
+ }
+
+ return
+ }
+
+ if info.Flags&(LeftRead|LeftWrite|LeftAddr) != 0 {
+ from = &prog.From
+ if from.Node != nil && from.Sym != nil && ((from.Node).(*Node)).Curfn == Curfn {
+ switch ((from.Node).(*Node)).Class &^ PHEAP {
+ case PAUTO,
+ PPARAM,
+ PPARAMOUT:
+ pos, ok := from.Node.(*Node).Opt.(int32) // index in vars
+ if !ok {
+ goto Next
+ }
+ if pos >= int32(len(vars)) || vars[pos] != from.Node {
+ Fatal("bad bookkeeping in liveness %v %d", Nconv(from.Node.(*Node), 0), pos)
+ }
+ if ((from.Node).(*Node)).Addrtaken != 0 {
+ bvset(avarinit, pos)
+ } else {
+ if info.Flags&(LeftRead|LeftAddr) != 0 {
+ bvset(uevar, pos)
+ }
+ if info.Flags&LeftWrite != 0 {
+ if from.Node != nil && !(Isfat(((from.Node).(*Node)).Type) != 0) {
+ bvset(varkill, pos)
+ }
+ }
+ }
+ }
+ }
+ }
+
+Next:
+ if info.Flags&(RightRead|RightWrite|RightAddr) != 0 {
+ to = &prog.To
+ if to.Node != nil && to.Sym != nil && ((to.Node).(*Node)).Curfn == Curfn {
+ switch ((to.Node).(*Node)).Class &^ PHEAP {
+ case PAUTO,
+ PPARAM,
+ PPARAMOUT:
+ pos, ok := to.Node.(*Node).Opt.(int32) // index in vars
+ if !ok {
+ goto Next1
+ }
+ if pos >= int32(len(vars)) || vars[pos] != to.Node {
+ Fatal("bad bookkeeping in liveness %v %d", Nconv(to.Node.(*Node), 0), pos)
+ }
+ if ((to.Node).(*Node)).Addrtaken != 0 {
+ if prog.As != obj.AVARKILL {
+ bvset(avarinit, pos)
+ }
+ if prog.As == obj.AVARDEF || prog.As == obj.AVARKILL {
+ bvset(varkill, pos)
+ }
+ } else {
+ // RightRead is a read, obviously.
+ // RightAddr by itself is also implicitly a read.
+ //
+ // RightAddr|RightWrite means that the address is being taken
+ // but only so that the instruction can write to the value.
+ // It is not a read. It is equivalent to RightWrite except that
+ // having the RightAddr bit set keeps the registerizer from
+ // trying to substitute a register for the memory location.
+ if (info.Flags&RightRead != 0) || info.Flags&(RightAddr|RightWrite) == RightAddr {
+ bvset(uevar, pos)
+ }
+ if info.Flags&RightWrite != 0 {
+ if to.Node != nil && (!(Isfat(((to.Node).(*Node)).Type) != 0) || prog.As == obj.AVARDEF) {
+ bvset(varkill, pos)
+ }
+ }
+ }
+ }
+ }
+ }
+
+Next1:
+}
+
+// Constructs a new liveness structure used to hold the global state of the
+// liveness computation. The cfg argument is an array of BasicBlock*s and the
+// vars argument is an array of Node*s.
+func newliveness(fn *Node, ptxt *obj.Prog, cfg []*BasicBlock, vars []*Node) *Liveness {
+ var result *Liveness
+ var i int32
+ var nblocks int32
+ var nvars int32
+
+ result = new(Liveness)
+ result.fn = fn
+ result.ptxt = ptxt
+ result.cfg = cfg
+ result.vars = vars
+
+ nblocks = int32(len(cfg))
+ result.uevar = make([]*Bvec, nblocks)
+ result.varkill = make([]*Bvec, nblocks)
+ result.livein = make([]*Bvec, nblocks)
+ result.liveout = make([]*Bvec, nblocks)
+ result.avarinit = make([]*Bvec, nblocks)
+ result.avarinitany = make([]*Bvec, nblocks)
+ result.avarinitall = make([]*Bvec, nblocks)
+
+ nvars = int32(len(vars))
+ for i = 0; i < nblocks; i++ {
+ result.uevar[i] = bvalloc(nvars)
+ result.varkill[i] = bvalloc(nvars)
+ result.livein[i] = bvalloc(nvars)
+ result.liveout[i] = bvalloc(nvars)
+ result.avarinit[i] = bvalloc(nvars)
+ result.avarinitany[i] = bvalloc(nvars)
+ result.avarinitall[i] = bvalloc(nvars)
+ }
+
+ result.livepointers = make([]*Bvec, 0, 0)
+ result.argslivepointers = make([]*Bvec, 0, 0)
+ return result
+}
+
+// Frees the liveness structure and all of its leaf data structures.
+func freeliveness(lv *Liveness) {
+ var i int32
+
+ if lv == nil {
+ Fatal("freeliveness: cannot free nil")
+ }
+
+ for i = 0; i < int32(len(lv.livepointers)); i++ {
+ }
+
+ for i = 0; i < int32(len(lv.argslivepointers)); i++ {
+ }
+
+ for i = 0; i < int32(len(lv.cfg)); i++ {
+ }
+}
+
+func printeffects(p *obj.Prog, uevar *Bvec, varkill *Bvec, avarinit *Bvec) {
+ fmt.Printf("effects of %v", p)
+ fmt.Printf("\nuevar: ")
+ bvprint(uevar)
+ fmt.Printf("\nvarkill: ")
+ bvprint(varkill)
+ fmt.Printf("\navarinit: ")
+ bvprint(avarinit)
+ fmt.Printf("\n")
+}
+
+// Pretty print a variable node. Uses Pascal like conventions for pointers and
+// addresses to avoid confusing the C like conventions used in the node variable
+// names.
+func printnode(node *Node) {
+ var p string
+ var a string
+
+ p = ""
+ if haspointers(node.Type) {
+ p = "^"
+ }
+ a = ""
+ if node.Addrtaken != 0 {
+ a = "@"
+ }
+ fmt.Printf(" %v%s%s", Nconv(node, 0), p, a)
+}
+
+// Pretty print a list of variables. The vars argument is an array of Node*s.
+func printvars(name string, bv *Bvec, vars []*Node) {
+ var i int32
+
+ fmt.Printf("%s:", name)
+ for i = 0; i < int32(len(vars)); i++ {
+ if bvget(bv, i) != 0 {
+ printnode(vars[i])
+ }
+ }
+ fmt.Printf("\n")
+}
+
+// Prints a basic block annotated with the information computed by liveness
+// analysis.
+func livenessprintblock(lv *Liveness, bb *BasicBlock) {
+ var pred *BasicBlock
+ var succ *BasicBlock
+ var prog *obj.Prog
+ var live *Bvec
+ var i int
+ var pos int32
+
+ fmt.Printf("basic block %d\n", bb.rpo)
+
+ fmt.Printf("\tpred:")
+ for i = 0; i < len(bb.pred); i++ {
+ pred = bb.pred[i]
+ fmt.Printf(" %d", pred.rpo)
+ }
+
+ fmt.Printf("\n")
+
+ fmt.Printf("\tsucc:")
+ for i = 0; i < len(bb.succ); i++ {
+ succ = bb.succ[i]
+ fmt.Printf(" %d", succ.rpo)
+ }
+
+ fmt.Printf("\n")
+
+ printvars("\tuevar", lv.uevar[bb.rpo], []*Node(lv.vars))
+ printvars("\tvarkill", lv.varkill[bb.rpo], []*Node(lv.vars))
+ printvars("\tlivein", lv.livein[bb.rpo], []*Node(lv.vars))
+ printvars("\tliveout", lv.liveout[bb.rpo], []*Node(lv.vars))
+ printvars("\tavarinit", lv.avarinit[bb.rpo], []*Node(lv.vars))
+ printvars("\tavarinitany", lv.avarinitany[bb.rpo], []*Node(lv.vars))
+ printvars("\tavarinitall", lv.avarinitall[bb.rpo], []*Node(lv.vars))
+
+ fmt.Printf("\tprog:\n")
+ for prog = bb.first; ; prog = prog.Link {
+ fmt.Printf("\t\t%v", prog)
+ if prog.As == obj.APCDATA && prog.From.Offset == obj.PCDATA_StackMapIndex {
+ pos = int32(prog.To.Offset)
+ live = lv.livepointers[pos]
+ fmt.Printf(" ")
+ bvprint(live)
+ }
+
+ fmt.Printf("\n")
+ if prog == bb.last {
+ break
+ }
+ }
+}
+
+// Prints a control flow graph annotated with any information computed by
+// liveness analysis.
+func livenessprintcfg(lv *Liveness) {
+ var bb *BasicBlock
+ var i int32
+
+ for i = 0; i < int32(len(lv.cfg)); i++ {
+ bb = lv.cfg[i]
+ livenessprintblock(lv, bb)
+ }
+}
+
+func checkauto(fn *Node, p *obj.Prog, n *Node) {
+ var l *NodeList
+
+ for l = fn.Dcl; l != nil; l = l.Next {
+ if l.N.Op == ONAME && l.N.Class == PAUTO && l.N == n {
+ return
+ }
+ }
+
+ if n == nil {
+ fmt.Printf("%v: checkauto %v: nil node in %v\n", p.Line(), Nconv(Curfn, 0), p)
+ return
+ }
+
+ fmt.Printf("checkauto %v: %v (%p; class=%d) not found in %v\n", Nconv(Curfn, 0), Nconv(n, 0), n, n.Class, p)
+ for l = fn.Dcl; l != nil; l = l.Next {
+ fmt.Printf("\t%v (%p; class=%d)\n", Nconv(l.N, 0), l.N, l.N.Class)
+ }
+ Yyerror("checkauto: invariant lost")
+}
+
+func checkparam(fn *Node, p *obj.Prog, n *Node) {
+ var l *NodeList
+ var a *Node
+ var class int
+
+ if isfunny(n) {
+ return
+ }
+ for l = fn.Dcl; l != nil; l = l.Next {
+ a = l.N
+ class = int(a.Class) &^ PHEAP
+ if a.Op == ONAME && (class == PPARAM || class == PPARAMOUT) && a == n {
+ return
+ }
+ }
+
+ fmt.Printf("checkparam %v: %v (%p; class=%d) not found in %v\n", Nconv(Curfn, 0), Nconv(n, 0), n, n.Class, p)
+ for l = fn.Dcl; l != nil; l = l.Next {
+ fmt.Printf("\t%v (%p; class=%d)\n", Nconv(l.N, 0), l.N, l.N.Class)
+ }
+ Yyerror("checkparam: invariant lost")
+}
+
+func checkprog(fn *Node, p *obj.Prog) {
+ if p.From.Name == obj.NAME_AUTO {
+ checkauto(fn, p, p.From.Node.(*Node))
+ }
+ if p.From.Name == obj.NAME_PARAM {
+ checkparam(fn, p, p.From.Node.(*Node))
+ }
+ if p.To.Name == obj.NAME_AUTO {
+ checkauto(fn, p, p.To.Node.(*Node))
+ }
+ if p.To.Name == obj.NAME_PARAM {
+ checkparam(fn, p, p.To.Node.(*Node))
+ }
+}
+
+// Check instruction invariants. We assume that the nodes corresponding to the
+// sources and destinations of memory operations will be declared in the
+// function. This is not strictly true, as is the case for the so-called funny
+// nodes and there are special cases to skip over that stuff. The analysis will
+// fail if this invariant blindly changes.
+func checkptxt(fn *Node, firstp *obj.Prog) {
+ var p *obj.Prog
+
+ if debuglive == 0 {
+ return
+ }
+
+ for p = firstp; p != nil; p = p.Link {
+ if false {
+ fmt.Printf("analyzing '%v'\n", p)
+ }
+ if p.As != obj.ADATA && p.As != obj.AGLOBL && p.As != obj.ATYPE {
+ checkprog(fn, p)
+ }
+ }
+}
+
+// NOTE: The bitmap for a specific type t should be cached in t after the first run
+// and then simply copied into bv at the correct offset on future calls with
+// the same type t. On https://rsc.googlecode.com/hg/testdata/slow.go, twobitwalktype1
+// accounts for 40% of the 6g execution time.
+func twobitwalktype1(t *Type, xoffset *int64, bv *Bvec) {
+ var fieldoffset int64
+ var i int64
+ var o int64
+ var t1 *Type
+
+ if t.Align > 0 && *xoffset&int64(t.Align-1) != 0 {
+ Fatal("twobitwalktype1: invalid initial alignment, %v", Tconv(t, 0))
+ }
+
+ switch t.Etype {
+ case TINT8,
+ TUINT8,
+ TINT16,
+ TUINT16,
+ TINT32,
+ TUINT32,
+ TINT64,
+ TUINT64,
+ TINT,
+ TUINT,
+ TUINTPTR,
+ TBOOL,
+ TFLOAT32,
+ TFLOAT64,
+ TCOMPLEX64,
+ TCOMPLEX128:
+ for i = 0; i < t.Width; i++ {
+ bvset(bv, int32(((*xoffset+i)/int64(Widthptr))*obj.BitsPerPointer)) // 1 = live scalar (BitsScalar)
+ }
+
+ *xoffset += t.Width
+
+ case TPTR32,
+ TPTR64,
+ TUNSAFEPTR,
+ TFUNC,
+ TCHAN,
+ TMAP:
+ if *xoffset&int64(Widthptr-1) != 0 {
+ Fatal("twobitwalktype1: invalid alignment, %v", Tconv(t, 0))
+ }
+ bvset(bv, int32((*xoffset/int64(Widthptr))*obj.BitsPerPointer+1)) // 2 = live ptr (BitsPointer)
+ *xoffset += t.Width
+
+ // struct { byte *str; intgo len; }
+ case TSTRING:
+ if *xoffset&int64(Widthptr-1) != 0 {
+ Fatal("twobitwalktype1: invalid alignment, %v", Tconv(t, 0))
+ }
+ bvset(bv, int32((*xoffset/int64(Widthptr))*obj.BitsPerPointer+1)) // 2 = live ptr in first slot (BitsPointer)
+ *xoffset += t.Width
+
+ // struct { Itab *tab; union { void *ptr, uintptr val } data; }
+ // or, when isnilinter(t)==true:
+ // struct { Type *type; union { void *ptr, uintptr val } data; }
+ case TINTER:
+ if *xoffset&int64(Widthptr-1) != 0 {
+ Fatal("twobitwalktype1: invalid alignment, %v", Tconv(t, 0))
+ }
+ bvset(bv, int32((*xoffset/int64(Widthptr))*obj.BitsPerPointer+1)) // 2 = live ptr in first slot (BitsPointer)
+ bvset(bv, int32((*xoffset/int64(Widthptr))*obj.BitsPerPointer+3)) // 2 = live ptr in second slot (BitsPointer)
+ *xoffset += t.Width
+
+ // The value of t->bound is -1 for slices types and >0 for
+ // for fixed array types. All other values are invalid.
+ case TARRAY:
+ if t.Bound < -1 {
+ Fatal("twobitwalktype1: invalid bound, %v", Tconv(t, 0))
+ }
+ if Isslice(t) != 0 {
+ // struct { byte *array; uintgo len; uintgo cap; }
+ if *xoffset&int64(Widthptr-1) != 0 {
+ Fatal("twobitwalktype1: invalid TARRAY alignment, %v", Tconv(t, 0))
+ }
+ bvset(bv, int32((*xoffset/int64(Widthptr))*obj.BitsPerPointer+1)) // 2 = live ptr in first slot (BitsPointer)
+ *xoffset += t.Width
+ } else {
+ for i = 0; i < t.Bound; i++ {
+ twobitwalktype1(t.Type, xoffset, bv)
+ }
+ }
+
+ case TSTRUCT:
+ o = 0
+ for t1 = t.Type; t1 != nil; t1 = t1.Down {
+ fieldoffset = t1.Width
+ *xoffset += fieldoffset - o
+ twobitwalktype1(t1.Type, xoffset, bv)
+ o = fieldoffset + t1.Type.Width
+ }
+
+ *xoffset += t.Width - o
+
+ default:
+ Fatal("twobitwalktype1: unexpected type, %v", Tconv(t, 0))
+ }
+}
+
+// Returns the number of words of local variables.
+func localswords() int32 {
+ return int32(stkptrsize / int64(Widthptr))
+}
+
+// Returns the number of words of in and out arguments.
+func argswords() int32 {
+ return int32(Curfn.Type.Argwid / int64(Widthptr))
+}
+
+// Generates live pointer value maps for arguments and local variables. The
+// this argument and the in arguments are always assumed live. The vars
+// argument is an array of Node*s.
+func twobitlivepointermap(lv *Liveness, liveout *Bvec, vars []*Node, args *Bvec, locals *Bvec) {
+ var node *Node
+ var thisargtype *Type
+ var inargtype *Type
+ var xoffset int64
+ var i int32
+
+ for i = 0; ; i++ {
+ i = int32(bvnext(liveout, i))
+ if !(i >= 0) {
+ break
+ }
+ node = vars[i]
+ switch node.Class {
+ case PAUTO:
+ xoffset = node.Xoffset + stkptrsize
+ twobitwalktype1(node.Type, &xoffset, locals)
+
+ case PPARAM,
+ PPARAMOUT:
+ xoffset = node.Xoffset
+ twobitwalktype1(node.Type, &xoffset, args)
+ }
+ }
+
+ // The node list only contains declared names.
+ // If the receiver or arguments are unnamed, they will be omitted
+ // from the list above. Preserve those values - even though they are unused -
+ // in order to keep their addresses live for use in stack traces.
+ thisargtype = getthisx(lv.fn.Type)
+
+ if thisargtype != nil {
+ xoffset = 0
+ twobitwalktype1(thisargtype, &xoffset, args)
+ }
+
+ inargtype = getinargx(lv.fn.Type)
+ if inargtype != nil {
+ xoffset = 0
+ twobitwalktype1(inargtype, &xoffset, args)
+ }
+}
+
+// Construct a disembodied instruction.
+func unlinkedprog(as int) *obj.Prog {
+ var p *obj.Prog
+
+ p = Ctxt.NewProg()
+ Clearp(p)
+ p.As = int16(as)
+ return p
+}
+
+// Construct a new PCDATA instruction associated with and for the purposes of
+// covering an existing instruction.
+func newpcdataprog(prog *obj.Prog, index int32) *obj.Prog {
+ var from Node
+ var to Node
+ var pcdata *obj.Prog
+
+ Nodconst(&from, Types[TINT32], obj.PCDATA_StackMapIndex)
+ Nodconst(&to, Types[TINT32], int64(index))
+ pcdata = unlinkedprog(obj.APCDATA)
+ pcdata.Lineno = prog.Lineno
+ Naddr(&from, &pcdata.From, 0)
+ Naddr(&to, &pcdata.To, 0)
+ return pcdata
+}
+
+// Returns true for instructions that are safe points that must be annotated
+// with liveness information.
+func issafepoint(prog *obj.Prog) int {
+ return bool2int(prog.As == obj.ATEXT || prog.As == obj.ACALL)
+}
+
+// Initializes the sets for solving the live variables. Visits all the
+// instructions in each basic block to summarizes the information at each basic
+// block
+func livenessprologue(lv *Liveness) {
+ var bb *BasicBlock
+ var uevar *Bvec
+ var varkill *Bvec
+ var avarinit *Bvec
+ var p *obj.Prog
+ var i int32
+ var nvars int32
+
+ nvars = int32(len(lv.vars))
+ uevar = bvalloc(nvars)
+ varkill = bvalloc(nvars)
+ avarinit = bvalloc(nvars)
+ for i = 0; i < int32(len(lv.cfg)); i++ {
+ bb = lv.cfg[i]
+
+ // Walk the block instructions backward and update the block
+ // effects with the each prog effects.
+ for p = bb.last; p != nil; p = p.Opt.(*obj.Prog) {
+ progeffects(p, []*Node(lv.vars), uevar, varkill, avarinit)
+ if debuglive >= 3 {
+ printeffects(p, uevar, varkill, avarinit)
+ }
+ bvor(lv.varkill[i], lv.varkill[i], varkill)
+ bvandnot(lv.uevar[i], lv.uevar[i], varkill)
+ bvor(lv.uevar[i], lv.uevar[i], uevar)
+ }
+
+ // Walk the block instructions forward to update avarinit bits.
+ // avarinit describes the effect at the end of the block, not the beginning.
+ bvresetall(varkill)
+
+ for p = bb.first; ; p = p.Link {
+ progeffects(p, []*Node(lv.vars), uevar, varkill, avarinit)
+ if debuglive >= 3 {
+ printeffects(p, uevar, varkill, avarinit)
+ }
+ bvandnot(lv.avarinit[i], lv.avarinit[i], varkill)
+ bvor(lv.avarinit[i], lv.avarinit[i], avarinit)
+ if p == bb.last {
+ break
+ }
+ }
+ }
+}
+
+// Solve the liveness dataflow equations.
+func livenesssolve(lv *Liveness) {
+ var bb *BasicBlock
+ var succ *BasicBlock
+ var pred *BasicBlock
+ var newlivein *Bvec
+ var newliveout *Bvec
+ var any *Bvec
+ var all *Bvec
+ var rpo int32
+ var i int32
+ var j int32
+ var change int32
+
+ // These temporary bitvectors exist to avoid successive allocations and
+ // frees within the loop.
+ newlivein = bvalloc(int32(len(lv.vars)))
+
+ newliveout = bvalloc(int32(len(lv.vars)))
+ any = bvalloc(int32(len(lv.vars)))
+ all = bvalloc(int32(len(lv.vars)))
+
+ // Push avarinitall, avarinitany forward.
+ // avarinitall says the addressed var is initialized along all paths reaching the block exit.
+ // avarinitany says the addressed var is initialized along some path reaching the block exit.
+ for i = 0; i < int32(len(lv.cfg)); i++ {
+ bb = lv.cfg[i]
+ rpo = int32(bb.rpo)
+ if i == 0 {
+ bvcopy(lv.avarinitall[rpo], lv.avarinit[rpo])
+ } else {
+ bvresetall(lv.avarinitall[rpo])
+ bvnot(lv.avarinitall[rpo])
+ }
+
+ bvcopy(lv.avarinitany[rpo], lv.avarinit[rpo])
+ }
+
+ change = 1
+ for change != 0 {
+ change = 0
+ for i = 0; i < int32(len(lv.cfg)); i++ {
+ bb = lv.cfg[i]
+ rpo = int32(bb.rpo)
+ bvresetall(any)
+ bvresetall(all)
+ for j = 0; j < int32(len(bb.pred)); j++ {
+ pred = bb.pred[j]
+ if j == 0 {
+ bvcopy(any, lv.avarinitany[pred.rpo])
+ bvcopy(all, lv.avarinitall[pred.rpo])
+ } else {
+ bvor(any, any, lv.avarinitany[pred.rpo])
+ bvand(all, all, lv.avarinitall[pred.rpo])
+ }
+ }
+
+ bvandnot(any, any, lv.varkill[rpo])
+ bvandnot(all, all, lv.varkill[rpo])
+ bvor(any, any, lv.avarinit[rpo])
+ bvor(all, all, lv.avarinit[rpo])
+ if bvcmp(any, lv.avarinitany[rpo]) != 0 {
+ change = 1
+ bvcopy(lv.avarinitany[rpo], any)
+ }
+
+ if bvcmp(all, lv.avarinitall[rpo]) != 0 {
+ change = 1
+ bvcopy(lv.avarinitall[rpo], all)
+ }
+ }
+ }
+
+ // Iterate through the blocks in reverse round-robin fashion. A work
+ // queue might be slightly faster. As is, the number of iterations is
+ // so low that it hardly seems to be worth the complexity.
+ change = 1
+
+ for change != 0 {
+ change = 0
+
+ // Walk blocks in the general direction of propagation. This
+ // improves convergence.
+ for i = int32(len(lv.cfg)) - 1; i >= 0; i-- {
+ // A variable is live on output from this block
+ // if it is live on input to some successor.
+ //
+ // out[b] = \bigcup_{s \in succ[b]} in[s]
+ bb = lv.cfg[i]
+
+ rpo = int32(bb.rpo)
+ bvresetall(newliveout)
+ for j = 0; j < int32(len(bb.succ)); j++ {
+ succ = bb.succ[j]
+ bvor(newliveout, newliveout, lv.livein[succ.rpo])
+ }
+
+ if bvcmp(lv.liveout[rpo], newliveout) != 0 {
+ change = 1
+ bvcopy(lv.liveout[rpo], newliveout)
+ }
+
+ // A variable is live on input to this block
+ // if it is live on output from this block and
+ // not set by the code in this block.
+ //
+ // in[b] = uevar[b] \cup (out[b] \setminus varkill[b])
+ bvandnot(newlivein, lv.liveout[rpo], lv.varkill[rpo])
+
+ bvor(lv.livein[rpo], newlivein, lv.uevar[rpo])
+ }
+ }
+}
+
+// This function is slow but it is only used for generating debug prints.
+// Check whether n is marked live in args/locals.
+func islive(n *Node, args *Bvec, locals *Bvec) int {
+ var i int
+
+ switch n.Class {
+ case PPARAM,
+ PPARAMOUT:
+ for i = 0; int64(i) < n.Type.Width/int64(Widthptr)*obj.BitsPerPointer; i++ {
+ if bvget(args, int32(n.Xoffset/int64(Widthptr)*obj.BitsPerPointer+int64(i))) != 0 {
+ return 1
+ }
+ }
+
+ case PAUTO:
+ for i = 0; int64(i) < n.Type.Width/int64(Widthptr)*obj.BitsPerPointer; i++ {
+ if bvget(locals, int32((n.Xoffset+stkptrsize)/int64(Widthptr)*obj.BitsPerPointer+int64(i))) != 0 {
+ return 1
+ }
+ }
+ }
+
+ return 0
+}
+
+// Visits all instructions in a basic block and computes a bit vector of live
+// variables at each safe point locations.
+func livenessepilogue(lv *Liveness) {
+ var bb *BasicBlock
+ var pred *BasicBlock
+ var ambig *Bvec
+ var livein *Bvec
+ var liveout *Bvec
+ var uevar *Bvec
+ var varkill *Bvec
+ var args *Bvec
+ var locals *Bvec
+ var avarinit *Bvec
+ var any *Bvec
+ var all *Bvec
+ var n *Node
+ var p *obj.Prog
+ var next *obj.Prog
+ var i int32
+ var j int32
+ var numlive int32
+ var startmsg int32
+ var nmsg int32
+ var nvars int32
+ var pos int32
+ var xoffset int64
+ var msg []string
+ var fmt_ string
+
+ nvars = int32(len(lv.vars))
+ livein = bvalloc(nvars)
+ liveout = bvalloc(nvars)
+ uevar = bvalloc(nvars)
+ varkill = bvalloc(nvars)
+ avarinit = bvalloc(nvars)
+ any = bvalloc(nvars)
+ all = bvalloc(nvars)
+ ambig = bvalloc(localswords() * obj.BitsPerPointer)
+ msg = nil
+ nmsg = 0
+ startmsg = 0
+
+ for i = 0; i < int32(len(lv.cfg)); i++ {
+ bb = lv.cfg[i]
+
+ // Compute avarinitany and avarinitall for entry to block.
+ // This duplicates information known during livenesssolve
+ // but avoids storing two more vectors for each block.
+ bvresetall(any)
+
+ bvresetall(all)
+ for j = 0; j < int32(len(bb.pred)); j++ {
+ pred = bb.pred[j]
+ if j == 0 {
+ bvcopy(any, lv.avarinitany[pred.rpo])
+ bvcopy(all, lv.avarinitall[pred.rpo])
+ } else {
+ bvor(any, any, lv.avarinitany[pred.rpo])
+ bvand(all, all, lv.avarinitall[pred.rpo])
+ }
+ }
+
+ // Walk forward through the basic block instructions and
+ // allocate liveness maps for those instructions that need them.
+ // Seed the maps with information about the addrtaken variables.
+ for p = bb.first; ; p = p.Link {
+ progeffects(p, []*Node(lv.vars), uevar, varkill, avarinit)
+ bvandnot(any, any, varkill)
+ bvandnot(all, all, varkill)
+ bvor(any, any, avarinit)
+ bvor(all, all, avarinit)
+
+ if issafepoint(p) != 0 {
+ // Annotate ambiguously live variables so that they can
+ // be zeroed at function entry.
+ // livein and liveout are dead here and used as temporaries.
+ bvresetall(livein)
+
+ bvandnot(liveout, any, all)
+ if !(bvisempty(liveout) != 0) {
+ for pos = 0; pos < liveout.n; pos++ {
+ if !(bvget(liveout, pos) != 0) {
+ continue
+ }
+ bvset(all, pos) // silence future warnings in this block
+ n = lv.vars[pos]
+ if !(n.Needzero != 0) {
+ n.Needzero = 1
+ if debuglive >= 1 {
+ Warnl(int(p.Lineno), "%v: %v is ambiguously live", Nconv(Curfn.Nname, 0), Nconv(n, obj.FmtLong))
+ }
+
+ // Record in 'ambiguous' bitmap.
+ xoffset = n.Xoffset + stkptrsize
+
+ twobitwalktype1(n.Type, &xoffset, ambig)
+ }
+ }
+ }
+
+ // Allocate a bit vector for each class and facet of
+ // value we are tracking.
+
+ // Live stuff first.
+ args = bvalloc(argswords() * obj.BitsPerPointer)
+
+ lv.argslivepointers = append(lv.argslivepointers, args)
+ locals = bvalloc(localswords() * obj.BitsPerPointer)
+ lv.livepointers = append(lv.livepointers, locals)
+
+ if debuglive >= 3 {
+ fmt.Printf("%v\n", p)
+ printvars("avarinitany", any, lv.vars)
+ }
+
+ // Record any values with an "address taken" reaching
+ // this code position as live. Must do now instead of below
+ // because the any/all calculation requires walking forward
+ // over the block (as this loop does), while the liveout
+ // requires walking backward (as the next loop does).
+ twobitlivepointermap(lv, any, lv.vars, args, locals)
+ }
+
+ if p == bb.last {
+ break
+ }
+ }
+
+ bb.lastbitmapindex = len(lv.livepointers) - 1
+ }
+
+ for i = 0; i < int32(len(lv.cfg)); i++ {
+ bb = lv.cfg[i]
+
+ if debuglive >= 1 && Curfn.Nname.Sym.Name != "init" && Curfn.Nname.Sym.Name[0] != '.' {
+ nmsg = int32(len(lv.livepointers))
+ startmsg = nmsg
+ msg = make([]string, nmsg)
+ for j = 0; j < nmsg; j++ {
+ msg[j] = ""
+ }
+ }
+
+ // walk backward, emit pcdata and populate the maps
+ pos = int32(bb.lastbitmapindex)
+
+ if pos < 0 {
+ // the first block we encounter should have the ATEXT so
+ // at no point should pos ever be less than zero.
+ Fatal("livenessepilogue")
+ }
+
+ bvcopy(livein, lv.liveout[bb.rpo])
+ for p = bb.last; p != nil; p = next {
+ next = p.Opt.(*obj.Prog) // splicebefore modifies p->opt
+
+ // Propagate liveness information
+ progeffects(p, lv.vars, uevar, varkill, avarinit)
+
+ bvcopy(liveout, livein)
+ bvandnot(livein, liveout, varkill)
+ bvor(livein, livein, uevar)
+ if debuglive >= 3 && issafepoint(p) != 0 {
+ fmt.Printf("%v\n", p)
+ printvars("uevar", uevar, lv.vars)
+ printvars("varkill", varkill, lv.vars)
+ printvars("livein", livein, lv.vars)
+ printvars("liveout", liveout, lv.vars)
+ }
+
+ if issafepoint(p) != 0 {
+ // Found an interesting instruction, record the
+ // corresponding liveness information.
+
+ // Useful sanity check: on entry to the function,
+ // the only things that can possibly be live are the
+ // input parameters.
+ if p.As == obj.ATEXT {
+ for j = 0; j < liveout.n; j++ {
+ if !(bvget(liveout, j) != 0) {
+ continue
+ }
+ n = lv.vars[j]
+ if n.Class != PPARAM {
+ yyerrorl(int(p.Lineno), "internal error: %v %v recorded as live on entry", Nconv(Curfn.Nname, 0), Nconv(n, obj.FmtLong))
+ }
+ }
+ }
+
+ // Record live pointers.
+ args = lv.argslivepointers[pos]
+
+ locals = lv.livepointers[pos]
+ twobitlivepointermap(lv, liveout, lv.vars, args, locals)
+
+ // Ambiguously live variables are zeroed immediately after
+ // function entry. Mark them live for all the non-entry bitmaps
+ // so that GODEBUG=gcdead=1 mode does not poison them.
+ if p.As == obj.ACALL {
+ bvor(locals, locals, ambig)
+ }
+
+ // Show live pointer bitmaps.
+ // We're interpreting the args and locals bitmap instead of liveout so that we
+ // include the bits added by the avarinit logic in the
+ // previous loop.
+ if msg != nil {
+ fmt_ = ""
+ fmt_ += fmt.Sprintf("%v: live at ", p.Line())
+ if p.As == obj.ACALL && p.To.Node != nil {
+ fmt_ += fmt.Sprintf("call to %s:", ((p.To.Node).(*Node)).Sym.Name)
+ } else if p.As == obj.ACALL {
+ fmt_ += fmt.Sprintf("indirect call:")
+ } else {
+ fmt_ += fmt.Sprintf("entry to %s:", ((p.From.Node).(*Node)).Sym.Name)
+ }
+ numlive = 0
+ for j = 0; j < int32(len(lv.vars)); j++ {
+ n = lv.vars[j]
+ if islive(n, args, locals) != 0 {
+ fmt_ += fmt.Sprintf(" %v", Nconv(n, 0))
+ numlive++
+ }
+ }
+
+ fmt_ += fmt.Sprintf("\n")
+ if numlive == 0 { // squelch message
+
+ } else {
+ startmsg--
+ msg[startmsg] = fmt_
+ }
+ }
+
+ // Only CALL instructions need a PCDATA annotation.
+ // The TEXT instruction annotation is implicit.
+ if p.As == obj.ACALL {
+ if isdeferreturn(p) != 0 {
+ // runtime.deferreturn modifies its return address to return
+ // back to the CALL, not to the subsequent instruction.
+ // Because the return comes back one instruction early,
+ // the PCDATA must begin one instruction early too.
+ // The instruction before a call to deferreturn is always a
+ // no-op, to keep PC-specific data unambiguous.
+ splicebefore(lv, bb, newpcdataprog(p.Opt.(*obj.Prog), pos), p.Opt.(*obj.Prog))
+ } else {
+ splicebefore(lv, bb, newpcdataprog(p, pos), p)
+ }
+ }
+
+ pos--
+ }
+ }
+
+ if msg != nil {
+ for j = startmsg; j < nmsg; j++ {
+ if msg[j] != "" {
+ fmt.Printf("%s", msg[j])
+ }
+ }
+
+ msg = nil
+ nmsg = 0
+ startmsg = 0
+ }
+ }
+
+ Flusherrors()
+}
+
+// FNV-1 hash function constants.
+const (
+ H0 = 2166136261
+ Hp = 16777619
+)
+
+func hashbitmap(h uint32, bv *Bvec) uint32 {
+ var i int
+ var n int
+ var w uint32
+
+ n = int((bv.n + 31) / 32)
+ for i = 0; i < n; i++ {
+ w = bv.b[i]
+ h = (h * Hp) ^ (w & 0xff)
+ h = (h * Hp) ^ ((w >> 8) & 0xff)
+ h = (h * Hp) ^ ((w >> 16) & 0xff)
+ h = (h * Hp) ^ ((w >> 24) & 0xff)
+ }
+
+ return h
+}
+
+// Compact liveness information by coalescing identical per-call-site bitmaps.
+// The merging only happens for a single function, not across the entire binary.
+//
+// There are actually two lists of bitmaps, one list for the local variables and one
+// list for the function arguments. Both lists are indexed by the same PCDATA
+// index, so the corresponding pairs must be considered together when
+// merging duplicates. The argument bitmaps change much less often during
+// function execution than the local variable bitmaps, so it is possible that
+// we could introduce a separate PCDATA index for arguments vs locals and
+// then compact the set of argument bitmaps separately from the set of
+// local variable bitmaps. As of 2014-04-02, doing this to the godoc binary
+// is actually a net loss: we save about 50k of argument bitmaps but the new
+// PCDATA tables cost about 100k. So for now we keep using a single index for
+// both bitmap lists.
+func livenesscompact(lv *Liveness) {
+ var table []int
+ var remap []int
+ var i int
+ var j int
+ var n int
+ var tablesize int
+ var uniq int
+ var h uint32
+ var local *Bvec
+ var arg *Bvec
+ var jlocal *Bvec
+ var jarg *Bvec
+ var p *obj.Prog
+
+ // Linear probing hash table of bitmaps seen so far.
+ // The hash table has 4n entries to keep the linear
+ // scan short. An entry of -1 indicates an empty slot.
+ n = len(lv.livepointers)
+
+ tablesize = 4 * n
+ table = make([]int, tablesize)
+ for i := range table {
+ table[i] = -1
+ }
+
+ // remap[i] = the new index of the old bit vector #i.
+ remap = make([]int, n)
+
+ for i := range remap {
+ remap[i] = -1
+ }
+ uniq = 0 // unique tables found so far
+
+ // Consider bit vectors in turn.
+ // If new, assign next number using uniq,
+ // record in remap, record in lv->livepointers and lv->argslivepointers
+ // under the new index, and add entry to hash table.
+ // If already seen, record earlier index in remap and free bitmaps.
+ for i = 0; i < n; i++ {
+ local = lv.livepointers[i]
+ arg = lv.argslivepointers[i]
+ h = hashbitmap(hashbitmap(H0, local), arg) % uint32(tablesize)
+
+ for {
+ j = table[h]
+ if j < 0 {
+ break
+ }
+ jlocal = lv.livepointers[j]
+ jarg = lv.argslivepointers[j]
+ if bvcmp(local, jlocal) == 0 && bvcmp(arg, jarg) == 0 {
+ remap[i] = j
+ goto Next
+ }
+
+ h++
+ if h == uint32(tablesize) {
+ h = 0
+ }
+ }
+
+ table[h] = uniq
+ remap[i] = uniq
+ lv.livepointers[uniq] = local
+ lv.argslivepointers[uniq] = arg
+ uniq++
+ Next:
+ }
+
+ // We've already reordered lv->livepointers[0:uniq]
+ // and lv->argslivepointers[0:uniq] and freed the bitmaps
+ // we don't need anymore. Clear the pointers later in the
+ // array so that we can tell where the coalesced bitmaps stop
+ // and so that we don't double-free when cleaning up.
+ for j = uniq; j < n; j++ {
+ lv.livepointers[j] = nil
+ lv.argslivepointers[j] = nil
+ }
+
+ // Rewrite PCDATA instructions to use new numbering.
+ for p = lv.ptxt; p != nil; p = p.Link {
+ if p.As == obj.APCDATA && p.From.Offset == obj.PCDATA_StackMapIndex {
+ i = int(p.To.Offset)
+ if i >= 0 {
+ p.To.Offset = int64(remap[i])
+ }
+ }
+ }
+}
+
+func printbitset(printed int, name string, vars []*Node, bits *Bvec) int {
+ var i int
+ var started int
+ var n *Node
+
+ started = 0
+ for i = 0; i < len(vars); i++ {
+ if !(bvget(bits, int32(i)) != 0) {
+ continue
+ }
+ if !(started != 0) {
+ if !(printed != 0) {
+ fmt.Printf("\t")
+ } else {
+ fmt.Printf(" ")
+ }
+ started = 1
+ printed = 1
+ fmt.Printf("%s=", name)
+ } else {
+ fmt.Printf(",")
+ }
+
+ n = vars[i]
+ fmt.Printf("%s", n.Sym.Name)
+ }
+
+ return printed
+}
+
+// Prints the computed liveness information and inputs, for debugging.
+// This format synthesizes the information used during the multiple passes
+// into a single presentation.
+func livenessprintdebug(lv *Liveness) {
+ var i int
+ var j int
+ var pcdata int
+ var printed int
+ var bb *BasicBlock
+ var p *obj.Prog
+ var uevar *Bvec
+ var varkill *Bvec
+ var avarinit *Bvec
+ var args *Bvec
+ var locals *Bvec
+ var n *Node
+
+ fmt.Printf("liveness: %s\n", Curfn.Nname.Sym.Name)
+
+ uevar = bvalloc(int32(len(lv.vars)))
+ varkill = bvalloc(int32(len(lv.vars)))
+ avarinit = bvalloc(int32(len(lv.vars)))
+
+ pcdata = 0
+ for i = 0; i < len(lv.cfg); i++ {
+ if i > 0 {
+ fmt.Printf("\n")
+ }
+ bb = lv.cfg[i]
+
+ // bb#0 pred=1,2 succ=3,4
+ fmt.Printf("bb#%d pred=", i)
+
+ for j = 0; j < len(bb.pred); j++ {
+ if j > 0 {
+ fmt.Printf(",")
+ }
+ fmt.Printf("%d", (bb.pred[j]).rpo)
+ }
+
+ fmt.Printf(" succ=")
+ for j = 0; j < len(bb.succ); j++ {
+ if j > 0 {
+ fmt.Printf(",")
+ }
+ fmt.Printf("%d", (bb.succ[j]).rpo)
+ }
+
+ fmt.Printf("\n")
+
+ // initial settings
+ printed = 0
+
+ printed = printbitset(printed, "uevar", lv.vars, lv.uevar[bb.rpo])
+ printed = printbitset(printed, "livein", lv.vars, lv.livein[bb.rpo])
+ if printed != 0 {
+ fmt.Printf("\n")
+ }
+
+ // program listing, with individual effects listed
+ for p = bb.first; ; p = p.Link {
+ fmt.Printf("%v\n", p)
+ if p.As == obj.APCDATA && p.From.Offset == obj.PCDATA_StackMapIndex {
+ pcdata = int(p.To.Offset)
+ }
+ progeffects(p, lv.vars, uevar, varkill, avarinit)
+ printed = 0
+ printed = printbitset(printed, "uevar", lv.vars, uevar)
+ printed = printbitset(printed, "varkill", lv.vars, varkill)
+ printed = printbitset(printed, "avarinit", lv.vars, avarinit)
+ if printed != 0 {
+ fmt.Printf("\n")
+ }
+ if issafepoint(p) != 0 {
+ args = lv.argslivepointers[pcdata]
+ locals = lv.livepointers[pcdata]
+ fmt.Printf("\tlive=")
+ printed = 0
+ for j = 0; j < len(lv.vars); j++ {
+ n = lv.vars[j]
+ if islive(n, args, locals) != 0 {
+ tmp9 := printed
+ printed++
+ if tmp9 != 0 {
+ fmt.Printf(",")
+ }
+ fmt.Printf("%v", Nconv(n, 0))
+ }
+ }
+
+ fmt.Printf("\n")
+ }
+
+ if p == bb.last {
+ break
+ }
+ }
+
+ // bb bitsets
+ fmt.Printf("end\n")
+
+ printed = printbitset(printed, "varkill", lv.vars, lv.varkill[bb.rpo])
+ printed = printbitset(printed, "liveout", lv.vars, lv.liveout[bb.rpo])
+ printed = printbitset(printed, "avarinit", lv.vars, lv.avarinit[bb.rpo])
+ printed = printbitset(printed, "avarinitany", lv.vars, lv.avarinitany[bb.rpo])
+ printed = printbitset(printed, "avarinitall", lv.vars, lv.avarinitall[bb.rpo])
+ if printed != 0 {
+ fmt.Printf("\n")
+ }
+ }
+
+ fmt.Printf("\n")
+}
+
+// Dumps an array of bitmaps to a symbol as a sequence of uint32 values. The
+// first word dumped is the total number of bitmaps. The second word is the
+// length of the bitmaps. All bitmaps are assumed to be of equal length. The
+// words that are followed are the raw bitmap words. The arr argument is an
+// array of Node*s.
+func twobitwritesymbol(arr []*Bvec, sym *Sym) {
+ var bv *Bvec
+ var off int
+ var i int
+ var j int
+ var n int
+ var word uint32
+
+ n = len(arr)
+ off = 0
+ off += 4 // number of bitmaps, to fill in later
+ bv = arr[0]
+ off = duint32(sym, off, uint32(bv.n)) // number of bits in each bitmap
+ for i = 0; i < n; i++ {
+ // bitmap words
+ bv = arr[i]
+
+ if bv == nil {
+ break
+ }
+ for j = 0; int32(j) < bv.n; j += 32 {
+ word = bv.b[j/32]
+
+ // Runtime reads the bitmaps as byte arrays. Oblige.
+ off = duint8(sym, off, uint8(word))
+
+ off = duint8(sym, off, uint8(word>>8))
+ off = duint8(sym, off, uint8(word>>16))
+ off = duint8(sym, off, uint8(word>>24))
+ }
+ }
+
+ duint32(sym, 0, uint32(i)) // number of bitmaps
+ ggloblsym(sym, int32(off), obj.RODATA)
+}
+
+func printprog(p *obj.Prog) {
+ for p != nil {
+ fmt.Printf("%v\n", p)
+ p = p.Link
+ }
+}
+
+// Entry pointer for liveness analysis. Constructs a complete CFG, solves for
+// the liveness of pointer variables in the function, and emits a runtime data
+// structure read by the garbage collector.
+func liveness(fn *Node, firstp *obj.Prog, argssym *Sym, livesym *Sym) {
+ var cfg []*BasicBlock
+ var vars []*Node
+ var lv *Liveness
+ var debugdelta int
+ var l *NodeList
+
+ // Change name to dump debugging information only for a specific function.
+ debugdelta = 0
+
+ if Curfn.Nname.Sym.Name == "!" {
+ debugdelta = 2
+ }
+
+ debuglive += debugdelta
+ if debuglive >= 3 {
+ fmt.Printf("liveness: %s\n", Curfn.Nname.Sym.Name)
+ printprog(firstp)
+ }
+
+ checkptxt(fn, firstp)
+
+ // Construct the global liveness state.
+ cfg = newcfg(firstp)
+
+ if debuglive >= 3 {
+ printcfg([]*BasicBlock(cfg))
+ }
+ vars = getvariables(fn)
+ lv = newliveness(fn, firstp, cfg, vars)
+
+ // Run the dataflow framework.
+ livenessprologue(lv)
+
+ if debuglive >= 3 {
+ livenessprintcfg(lv)
+ }
+ livenesssolve(lv)
+ if debuglive >= 3 {
+ livenessprintcfg(lv)
+ }
+ livenessepilogue(lv)
+ if debuglive >= 3 {
+ livenessprintcfg(lv)
+ }
+ livenesscompact(lv)
+
+ if debuglive >= 2 {
+ livenessprintdebug(lv)
+ }
+
+ // Emit the live pointer map data structures
+ twobitwritesymbol(lv.livepointers, livesym)
+
+ twobitwritesymbol(lv.argslivepointers, argssym)
+
+ // Free everything.
+ for l = fn.Dcl; l != nil; l = l.Next {
+ if l.N != nil {
+ l.N.Opt = nil
+ }
+ }
+ freeliveness(lv)
+
+ freecfg([]*BasicBlock(cfg))
+
+ debuglive -= debugdelta
+}
diff --git a/src/cmd/internal/gc/popt.go b/src/cmd/internal/gc/popt.go
new file mode 100644
index 0000000..6d69120
--- /dev/null
+++ b/src/cmd/internal/gc/popt.go
@@ -0,0 +1,1283 @@
+// Derived from Inferno utils/6c/reg.c
+// http://code.google.com/p/inferno-os/source/browse/utils/6c/reg.c
+//
+// Copyright © 1994-1999 Lucent Technologies Inc. All rights reserved.
+// Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+// Portions Copyright © 1997-1999 Vita Nuova Limited
+// Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
+// Portions Copyright © 2004,2006 Bruce Ellis
+// Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+// Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
+// Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package gc
+
+import (
+ "cmd/internal/obj"
+ "fmt"
+ "sort"
+ "strings"
+)
+
+// "Portable" optimizations.
+// Compiled separately for 5g, 6g, and 8g, so allowed to use gg.h, opt.h.
+// Must code to the intersection of the three back ends.
+
+// Derived from Inferno utils/6c/gc.h
+// http://code.google.com/p/inferno-os/source/browse/utils/6c/gc.h
+//
+// Copyright © 1994-1999 Lucent Technologies Inc. All rights reserved.
+// Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+// Portions Copyright © 1997-1999 Vita Nuova Limited
+// Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
+// Portions Copyright © 2004,2006 Bruce Ellis
+// Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+// Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
+// Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+const (
+ CLOAD = 5
+ CREF = 5
+ CINF = 1000
+ LOOP = 3
+)
+
+type Reg struct {
+ set Bits
+ use1 Bits
+ use2 Bits
+ refbehind Bits
+ refahead Bits
+ calbehind Bits
+ calahead Bits
+ regdiff Bits
+ act Bits
+ regu uint64
+}
+
+type Rgn struct {
+ enter *Flow
+ cost int16
+ varno int16
+ regno int16
+}
+
+var Z *Node
+
+// A Reg is a wrapper around a single Prog (one instruction) that holds
+// register optimization information while the optimizer runs.
+// r->prog is the instruction.
+
+var R *Reg
+
+const (
+ NRGN = 600
+)
+
+// A Rgn represents a single regopt variable over a region of code
+// where a register could potentially be dedicated to that variable.
+// The code encompassed by a Rgn is defined by the flow graph,
+// starting at enter, flood-filling forward while varno is refahead
+// and backward while varno is refbehind, and following branches. A
+// single variable may be represented by multiple disjoint Rgns and
+// each Rgn may choose a different register for that variable.
+// Registers are allocated to regions greedily in order of descending
+// cost.
+
+var zreg Reg
+
+var region [NRGN]Rgn
+
+var rgp *Rgn
+
+var nregion int
+
+var nvar int
+
+var regbits uint64
+
+var externs Bits
+
+var params Bits
+
+var consts Bits
+
+var addrs Bits
+
+var ivar Bits
+
+var ovar Bits
+
+var change int
+
+var maxnr int32
+
+type OptStats struct {
+ Ncvtreg int32
+ Nspill int32
+ Nreload int32
+ Ndelmov int32
+ Nvar int32
+ Naddr int32
+}
+
+var Ostats OptStats
+
+/*
+ * reg.c
+ */
+
+/*
+ * peep.c
+void peep(Prog*);
+void excise(Flow*);
+int copyu(Prog*, Adr*, Adr*);
+*/
+
+/*
+ * prog.c
+
+void proginfo(ProgInfo*, Prog*);
+*/
+// p is a call instruction. Does the call fail to return?
+
+var noreturn_symlist [10]*Sym
+
+func Noreturn(p *obj.Prog) int {
+ var s *Sym
+ var i int
+
+ if noreturn_symlist[0] == nil {
+ noreturn_symlist[0] = Pkglookup("panicindex", Runtimepkg)
+ noreturn_symlist[1] = Pkglookup("panicslice", Runtimepkg)
+ noreturn_symlist[2] = Pkglookup("throwinit", Runtimepkg)
+ noreturn_symlist[3] = Pkglookup("gopanic", Runtimepkg)
+ noreturn_symlist[4] = Pkglookup("panicwrap", Runtimepkg)
+ noreturn_symlist[5] = Pkglookup("throwreturn", Runtimepkg)
+ noreturn_symlist[6] = Pkglookup("selectgo", Runtimepkg)
+ noreturn_symlist[7] = Pkglookup("block", Runtimepkg)
+ }
+
+ if p.To.Node == nil {
+ return 0
+ }
+ s = ((p.To.Node).(*Node)).Sym
+ if s == nil {
+ return 0
+ }
+ for i = 0; noreturn_symlist[i] != nil; i++ {
+ if s == noreturn_symlist[i] {
+ return 1
+ }
+ }
+ return 0
+}
+
+// JMP chasing and removal.
+//
+// The code generator depends on being able to write out jump
+// instructions that it can jump to now but fill in later.
+// the linker will resolve them nicely, but they make the code
+// longer and more difficult to follow during debugging.
+// Remove them.
+
+/* what instruction does a JMP to p eventually land on? */
+func chasejmp(p *obj.Prog, jmploop *int) *obj.Prog {
+ var n int
+
+ n = 0
+ for p != nil && p.As == obj.AJMP && p.To.Type == obj.TYPE_BRANCH {
+ n++
+ if n > 10 {
+ *jmploop = 1
+ break
+ }
+
+ p = p.To.U.Branch
+ }
+
+ return p
+}
+
+/*
+ * reuse reg pointer for mark/sweep state.
+ * leave reg==nil at end because alive==nil.
+ */
+var alive interface{} = nil
+var dead interface{} = 1
+
+/* mark all code reachable from firstp as alive */
+func mark(firstp *obj.Prog) {
+ var p *obj.Prog
+
+ for p = firstp; p != nil; p = p.Link {
+ if p.Opt != dead {
+ break
+ }
+ p.Opt = alive
+ if p.As != obj.ACALL && p.To.Type == obj.TYPE_BRANCH && p.To.U.Branch != nil {
+ mark(p.To.U.Branch)
+ }
+ if p.As == obj.AJMP || p.As == obj.ARET || p.As == obj.AUNDEF {
+ break
+ }
+ }
+}
+
+func fixjmp(firstp *obj.Prog) {
+ var jmploop int
+ var p *obj.Prog
+ var last *obj.Prog
+
+ if Debug['R'] != 0 && Debug['v'] != 0 {
+ fmt.Printf("\nfixjmp\n")
+ }
+
+ // pass 1: resolve jump to jump, mark all code as dead.
+ jmploop = 0
+
+ for p = firstp; p != nil; p = p.Link {
+ if Debug['R'] != 0 && Debug['v'] != 0 {
+ fmt.Printf("%v\n", p)
+ }
+ if p.As != obj.ACALL && p.To.Type == obj.TYPE_BRANCH && p.To.U.Branch != nil && p.To.U.Branch.As == obj.AJMP {
+ p.To.U.Branch = chasejmp(p.To.U.Branch, &jmploop)
+ if Debug['R'] != 0 && Debug['v'] != 0 {
+ fmt.Printf("->%v\n", p)
+ }
+ }
+
+ p.Opt = dead
+ }
+
+ if Debug['R'] != 0 && Debug['v'] != 0 {
+ fmt.Printf("\n")
+ }
+
+ // pass 2: mark all reachable code alive
+ mark(firstp)
+
+ // pass 3: delete dead code (mostly JMPs).
+ last = nil
+
+ for p = firstp; p != nil; p = p.Link {
+ if p.Opt == dead {
+ if p.Link == nil && p.As == obj.ARET && last != nil && last.As != obj.ARET {
+ // This is the final ARET, and the code so far doesn't have one.
+ // Let it stay. The register allocator assumes that all live code in
+ // the function can be traversed by starting at all the RET instructions
+ // and following predecessor links. If we remove the final RET,
+ // this assumption will not hold in the case of an infinite loop
+ // at the end of a function.
+ // Keep the RET but mark it dead for the liveness analysis.
+ p.Mode = 1
+ } else {
+ if Debug['R'] != 0 && Debug['v'] != 0 {
+ fmt.Printf("del %v\n", p)
+ }
+ continue
+ }
+ }
+
+ if last != nil {
+ last.Link = p
+ }
+ last = p
+ }
+
+ last.Link = nil
+
+ // pass 4: elide JMP to next instruction.
+ // only safe if there are no jumps to JMPs anymore.
+ if !(jmploop != 0) {
+ last = nil
+ for p = firstp; p != nil; p = p.Link {
+ if p.As == obj.AJMP && p.To.Type == obj.TYPE_BRANCH && p.To.U.Branch == p.Link {
+ if Debug['R'] != 0 && Debug['v'] != 0 {
+ fmt.Printf("del %v\n", p)
+ }
+ continue
+ }
+
+ if last != nil {
+ last.Link = p
+ }
+ last = p
+ }
+
+ last.Link = nil
+ }
+
+ if Debug['R'] != 0 && Debug['v'] != 0 {
+ fmt.Printf("\n")
+ for p = firstp; p != nil; p = p.Link {
+ fmt.Printf("%v\n", p)
+ }
+ fmt.Printf("\n")
+ }
+}
+
+// Control flow analysis. The Flow structures hold predecessor and successor
+// information as well as basic loop analysis.
+//
+// graph = flowstart(firstp, 0);
+// ... use flow graph ...
+// flowend(graph); // free graph
+//
+// Typical uses of the flow graph are to iterate over all the flow-relevant instructions:
+//
+// for(f = graph->start; f != nil; f = f->link)
+//
+// or, given an instruction f, to iterate over all the predecessors, which is
+// f->p1 and this list:
+//
+// for(f2 = f->p2; f2 != nil; f2 = f2->p2link)
+//
+// The size argument to flowstart specifies an amount of zeroed memory
+// to allocate in every f->data field, for use by the client.
+// If size == 0, f->data will be nil.
+
+func Flowstart(firstp *obj.Prog, newData func() interface{}) *Graph {
+ var id int
+ var nf int
+ var f *Flow
+ var f1 *Flow
+ var start *Flow
+ var last *Flow
+ var graph *Graph
+ var p *obj.Prog
+ var info ProgInfo
+
+ // Count and mark instructions to annotate.
+ nf = 0
+
+ for p = firstp; p != nil; p = p.Link {
+ p.Opt = nil // should be already, but just in case
+ Thearch.Proginfo(&info, p)
+ if info.Flags&Skip != 0 {
+ continue
+ }
+ p.Opt = interface{}(1)
+ nf++
+ }
+
+ if nf == 0 {
+ return nil
+ }
+
+ if nf >= 20000 {
+ // fatal("%S is too big (%d instructions)", curfn->nname->sym, nf);
+ return nil
+ }
+
+ // Allocate annotations and assign to instructions.
+ graph = new(Graph)
+ ff := make([]Flow, nf)
+ start = &ff[0]
+ id = 0
+ for p = firstp; p != nil; p = p.Link {
+ if p.Opt == nil {
+ continue
+ }
+ f := &ff[0]
+ ff = ff[1:]
+ p.Opt = f
+ f.Prog = p
+ if last != nil {
+ last.Link = f
+ }
+ last = f
+ if newData != nil {
+ f.Data = newData()
+ }
+ f.Id = int32(id)
+ id++
+ }
+
+ // Fill in pred/succ information.
+ for f = start; f != nil; f = f.Link {
+ p = f.Prog
+ Thearch.Proginfo(&info, p)
+ if !(info.Flags&Break != 0) {
+ f1 = f.Link
+ f.S1 = f1
+ f1.P1 = f
+ }
+
+ if p.To.Type == obj.TYPE_BRANCH {
+ if p.To.U.Branch == nil {
+ Fatal("pnil %v", p)
+ }
+ f1 = p.To.U.Branch.Opt.(*Flow)
+ if f1 == nil {
+ Fatal("fnil %v / %v", p, p.To.U.Branch)
+ }
+ if f1 == f {
+ //fatal("self loop %P", p);
+ continue
+ }
+
+ f.S2 = f1
+ f.P2link = f1.P2
+ f1.P2 = f
+ }
+ }
+
+ graph.Start = start
+ graph.Num = nf
+ return graph
+}
+
+func Flowend(graph *Graph) {
+ var f *Flow
+
+ for f = graph.Start; f != nil; f = f.Link {
+ f.Prog.Opt = nil
+ }
+}
+
+/*
+ * find looping structure
+ *
+ * 1) find reverse postordering
+ * 2) find approximate dominators,
+ * the actual dominators if the flow graph is reducible
+ * otherwise, dominators plus some other non-dominators.
+ * See Matthew S. Hecht and Jeffrey D. Ullman,
+ * "Analysis of a Simple Algorithm for Global Data Flow Problems",
+ * Conf. Record of ACM Symp. on Principles of Prog. Langs, Boston, Massachusetts,
+ * Oct. 1-3, 1973, pp. 207-217.
+ * 3) find all nodes with a predecessor dominated by the current node.
+ * such a node is a loop head.
+ * recursively, all preds with a greater rpo number are in the loop
+ */
+func postorder(r *Flow, rpo2r []*Flow, n int32) int32 {
+ var r1 *Flow
+
+ r.Rpo = 1
+ r1 = r.S1
+ if r1 != nil && !(r1.Rpo != 0) {
+ n = postorder(r1, rpo2r, n)
+ }
+ r1 = r.S2
+ if r1 != nil && !(r1.Rpo != 0) {
+ n = postorder(r1, rpo2r, n)
+ }
+ rpo2r[n] = r
+ n++
+ return n
+}
+
+func rpolca(idom []int32, rpo1 int32, rpo2 int32) int32 {
+ var t int32
+
+ if rpo1 == -1 {
+ return rpo2
+ }
+ for rpo1 != rpo2 {
+ if rpo1 > rpo2 {
+ t = rpo2
+ rpo2 = rpo1
+ rpo1 = t
+ }
+
+ for rpo1 < rpo2 {
+ t = idom[rpo2]
+ if t >= rpo2 {
+ Fatal("bad idom")
+ }
+ rpo2 = t
+ }
+ }
+
+ return rpo1
+}
+
+func doms(idom []int32, r int32, s int32) int {
+ for s > r {
+ s = idom[s]
+ }
+ return bool2int(s == r)
+}
+
+func loophead(idom []int32, r *Flow) int {
+ var src int32
+
+ src = r.Rpo
+ if r.P1 != nil && doms(idom, src, r.P1.Rpo) != 0 {
+ return 1
+ }
+ for r = r.P2; r != nil; r = r.P2link {
+ if doms(idom, src, r.Rpo) != 0 {
+ return 1
+ }
+ }
+ return 0
+}
+
+func loopmark(rpo2r **Flow, head int32, r *Flow) {
+ if r.Rpo < head || r.Active == head {
+ return
+ }
+ r.Active = head
+ r.Loop += LOOP
+ if r.P1 != nil {
+ loopmark(rpo2r, head, r.P1)
+ }
+ for r = r.P2; r != nil; r = r.P2link {
+ loopmark(rpo2r, head, r)
+ }
+}
+
+func flowrpo(g *Graph) {
+ var r1 *Flow
+ var i int32
+ var d int32
+ var me int32
+ var nr int32
+ var idom []int32
+ var rpo2r []*Flow
+
+ g.Rpo = make([]*Flow, g.Num)
+ idom = make([]int32, g.Num)
+
+ for r1 = g.Start; r1 != nil; r1 = r1.Link {
+ r1.Active = 0
+ }
+
+ rpo2r = g.Rpo
+ d = postorder(g.Start, rpo2r, 0)
+ nr = int32(g.Num)
+ if d > nr {
+ Fatal("too many reg nodes %d %d", d, nr)
+ }
+ nr = d
+ for i = 0; i < nr/2; i++ {
+ r1 = rpo2r[i]
+ rpo2r[i] = rpo2r[nr-1-i]
+ rpo2r[nr-1-i] = r1
+ }
+
+ for i = 0; i < nr; i++ {
+ rpo2r[i].Rpo = i
+ }
+
+ idom[0] = 0
+ for i = 0; i < nr; i++ {
+ r1 = rpo2r[i]
+ me = r1.Rpo
+ d = -1
+
+ // rpo2r[r->rpo] == r protects against considering dead code,
+ // which has r->rpo == 0.
+ if r1.P1 != nil && rpo2r[r1.P1.Rpo] == r1.P1 && r1.P1.Rpo < me {
+ d = r1.P1.Rpo
+ }
+ for r1 = r1.P2; r1 != nil; r1 = r1.P2link {
+ if rpo2r[r1.Rpo] == r1 && r1.Rpo < me {
+ d = rpolca(idom, d, r1.Rpo)
+ }
+ }
+ idom[i] = d
+ }
+
+ for i = 0; i < nr; i++ {
+ r1 = rpo2r[i]
+ r1.Loop++
+ if r1.P2 != nil && loophead(idom, r1) != 0 {
+ loopmark(&rpo2r[0], i, r1)
+ }
+ }
+
+ for r1 = g.Start; r1 != nil; r1 = r1.Link {
+ r1.Active = 0
+ }
+}
+
+func Uniqp(r *Flow) *Flow {
+ var r1 *Flow
+
+ r1 = r.P1
+ if r1 == nil {
+ r1 = r.P2
+ if r1 == nil || r1.P2link != nil {
+ return nil
+ }
+ } else if r.P2 != nil {
+ return nil
+ }
+ return r1
+}
+
+func Uniqs(r *Flow) *Flow {
+ var r1 *Flow
+
+ r1 = r.S1
+ if r1 == nil {
+ r1 = r.S2
+ if r1 == nil {
+ return nil
+ }
+ } else if r.S2 != nil {
+ return nil
+ }
+ return r1
+}
+
+// The compilers assume they can generate temporary variables
+// as needed to preserve the right semantics or simplify code
+// generation and the back end will still generate good code.
+// This results in a large number of ephemeral temporary variables.
+// Merge temps with non-overlapping lifetimes and equal types using the
+// greedy algorithm in Poletto and Sarkar, "Linear Scan Register Allocation",
+// ACM TOPLAS 1999.
+
+type TempVar struct {
+ node *Node
+ def *Flow
+ use *Flow
+ freelink *TempVar
+ merge *TempVar
+ start int64
+ end int64
+ addr uint8
+ removed uint8
+}
+
+type startcmp []*TempVar
+
+func (x startcmp) Len() int {
+ return len(x)
+}
+
+func (x startcmp) Swap(i, j int) {
+ x[i], x[j] = x[j], x[i]
+}
+
+func (x startcmp) Less(i, j int) bool {
+ var a *TempVar
+ var b *TempVar
+
+ a = x[i]
+ b = x[j]
+
+ if a.start < b.start {
+ return true
+ }
+ if a.start > b.start {
+ return false
+ }
+
+ // Order what's left by id or symbol name,
+ // just so that sort is forced into a specific ordering,
+ // so that the result of the sort does not depend on
+ // the sort implementation.
+ if a.def != b.def {
+ return int(a.def.Id-b.def.Id) < 0
+ }
+ if a.node != b.node {
+ return stringsCompare(a.node.Sym.Name, b.node.Sym.Name) < 0
+ }
+ return false
+}
+
+// Is n available for merging?
+func canmerge(n *Node) int {
+ return bool2int(n.Class == PAUTO && strings.HasPrefix(n.Sym.Name, "autotmp"))
+}
+
+func mergetemp(firstp *obj.Prog) {
+ var i int
+ var j int
+ var nvar int
+ var ninuse int
+ var nfree int
+ var nkill int
+ var var_ []TempVar
+ var v *TempVar
+ var v1 *TempVar
+ var bystart []*TempVar
+ var inuse []*TempVar
+ var f *Flow
+ var l *NodeList
+ var lp **NodeList
+ var n *Node
+ var p *obj.Prog
+ var p1 *obj.Prog
+ var t *Type
+ var info ProgInfo
+ var info1 ProgInfo
+ var gen int32
+ var g *Graph
+ const (
+ debugmerge = 1
+ )
+
+ g = Flowstart(firstp, nil)
+ if g == nil {
+ return
+ }
+
+ // Build list of all mergeable variables.
+ nvar = 0
+ for l = Curfn.Dcl; l != nil; l = l.Next {
+ if canmerge(l.N) != 0 {
+ nvar++
+ }
+ }
+
+ var_ = make([]TempVar, nvar)
+ nvar = 0
+ for l = Curfn.Dcl; l != nil; l = l.Next {
+ n = l.N
+ if canmerge(n) != 0 {
+ v = &var_[nvar]
+ nvar++
+ n.Opt = v
+ v.node = n
+ }
+ }
+
+ // Build list of uses.
+ // We assume that the earliest reference to a temporary is its definition.
+ // This is not true of variables in general but our temporaries are all
+ // single-use (that's why we have so many!).
+ for f = g.Start; f != nil; f = f.Link {
+ p = f.Prog
+ Thearch.Proginfo(&info, p)
+
+ if p.From.Node != nil && ((p.From.Node).(*Node)).Opt != nil && p.To.Node != nil && ((p.To.Node).(*Node)).Opt != nil {
+ Fatal("double node %v", p)
+ }
+ v = nil
+ n, _ = p.From.Node.(*Node)
+ if n != nil {
+ v, _ = n.Opt.(*TempVar)
+ }
+ if v == nil {
+ n, _ = p.To.Node.(*Node)
+ if n != nil {
+ v, _ = n.Opt.(*TempVar)
+ }
+ }
+ if v != nil {
+ if v.def == nil {
+ v.def = f
+ }
+ f.Data = v.use
+ v.use = f
+ if n == p.From.Node && (info.Flags&LeftAddr != 0) {
+ v.addr = 1
+ }
+ }
+ }
+
+ if debugmerge > 1 && Debug['v'] != 0 {
+ Dumpit("before", g.Start, 0)
+ }
+
+ nkill = 0
+
+ // Special case.
+ for i = 0; i < len(var_); i++ {
+ v = &var_[i]
+ if v.addr != 0 {
+ continue
+ }
+
+ // Used in only one instruction, which had better be a write.
+ f = v.use
+ if f != nil && f.Data.(*Flow) == nil {
+ p = f.Prog
+ Thearch.Proginfo(&info, p)
+ if p.To.Node == v.node && (info.Flags&RightWrite != 0) && !(info.Flags&RightRead != 0) {
+ p.As = obj.ANOP
+ p.To = obj.Zprog.To
+ v.removed = 1
+ if debugmerge > 0 && Debug['v'] != 0 {
+ fmt.Printf("drop write-only %v\n", Sconv(v.node.Sym, 0))
+ }
+ } else {
+ Fatal("temp used and not set: %v", p)
+ }
+ nkill++
+ continue
+ }
+
+ // Written in one instruction, read in the next, otherwise unused,
+ // no jumps to the next instruction. Happens mainly in 386 compiler.
+ f = v.use
+ if f != nil && f.Link == f.Data.(*Flow) && (f.Data.(*Flow)).Data.(*Flow) == nil && Uniqp(f.Link) == f {
+ p = f.Prog
+ Thearch.Proginfo(&info, p)
+ p1 = f.Link.Prog
+ Thearch.Proginfo(&info1, p1)
+ const (
+ SizeAny = SizeB | SizeW | SizeL | SizeQ | SizeF | SizeD
+ )
+ if p.From.Node == v.node && p1.To.Node == v.node && (info.Flags&Move != 0) && !((info.Flags|info1.Flags)&(LeftAddr|RightAddr) != 0) && info.Flags&SizeAny == info1.Flags&SizeAny {
+ p1.From = p.From
+ Thearch.Excise(f)
+ v.removed = 1
+ if debugmerge > 0 && Debug['v'] != 0 {
+ fmt.Printf("drop immediate-use %v\n", Sconv(v.node.Sym, 0))
+ }
+ }
+
+ nkill++
+ continue
+ }
+ }
+
+ // Traverse live range of each variable to set start, end.
+ // Each flood uses a new value of gen so that we don't have
+ // to clear all the r->active words after each variable.
+ gen = 0
+
+ for i = 0; i < len(var_); i++ {
+ v = &var_[i]
+ gen++
+ for f = v.use; f != nil; f = f.Data.(*Flow) {
+ mergewalk(v, f, uint32(gen))
+ }
+ if v.addr != 0 {
+ gen++
+ for f = v.use; f != nil; f = f.Data.(*Flow) {
+ varkillwalk(v, f, uint32(gen))
+ }
+ }
+ }
+
+ // Sort variables by start.
+ bystart = make([]*TempVar, len(var_))
+
+ for i = 0; i < len(var_); i++ {
+ bystart[i] = &var_[i]
+ }
+ sort.Sort(startcmp(bystart[:len(var_)]))
+
+ // List of in-use variables, sorted by end, so that the ones that
+ // will last the longest are the earliest ones in the array.
+ // The tail inuse[nfree:] holds no-longer-used variables.
+ // In theory we should use a sorted tree so that insertions are
+ // guaranteed O(log n) and then the loop is guaranteed O(n log n).
+ // In practice, it doesn't really matter.
+ inuse = make([]*TempVar, len(var_))
+
+ ninuse = 0
+ nfree = len(var_)
+ for i = 0; i < len(var_); i++ {
+ v = bystart[i]
+ if debugmerge > 0 && Debug['v'] != 0 {
+ fmt.Printf("consider %v: removed=%d\n", Nconv(v.node, obj.FmtSharp), v.removed)
+ }
+
+ if v.removed != 0 {
+ continue
+ }
+
+ // Expire no longer in use.
+ for ninuse > 0 && inuse[ninuse-1].end < v.start {
+ ninuse--
+ v1 = inuse[ninuse]
+ nfree--
+ inuse[nfree] = v1
+ }
+
+ if debugmerge > 0 && Debug['v'] != 0 {
+ fmt.Printf("consider %v: removed=%d nfree=%d nvar=%d\n", Nconv(v.node, obj.FmtSharp), v.removed, nfree, len(var_))
+ }
+
+ // Find old temp to reuse if possible.
+ t = v.node.Type
+
+ for j = nfree; j < len(var_); j++ {
+ v1 = inuse[j]
+ if debugmerge > 0 && Debug['v'] != 0 {
+ fmt.Printf("consider %v: maybe %v: type=%v,%v addrtaken=%d,%d\n", Nconv(v.node, obj.FmtSharp), Nconv(v1.node, obj.FmtSharp), Tconv(t, 0), Tconv(v1.node.Type, 0), v.node.Addrtaken, v1.node.Addrtaken)
+ }
+
+ // Require the types to match but also require the addrtaken bits to match.
+ // If a variable's address is taken, that disables registerization for the individual
+ // words of the variable (for example, the base,len,cap of a slice).
+ // We don't want to merge a non-addressed var with an addressed one and
+ // inhibit registerization of the former.
+ if Eqtype(t, v1.node.Type) && v.node.Addrtaken == v1.node.Addrtaken {
+ inuse[j] = inuse[nfree]
+ nfree++
+ if v1.merge != nil {
+ v.merge = v1.merge
+ } else {
+ v.merge = v1
+ }
+ nkill++
+ break
+ }
+ }
+
+ // Sort v into inuse.
+ j = ninuse
+ ninuse++
+
+ for j > 0 && inuse[j-1].end < v.end {
+ inuse[j] = inuse[j-1]
+ j--
+ }
+
+ inuse[j] = v
+ }
+
+ if debugmerge > 0 && Debug['v'] != 0 {
+ fmt.Printf("%v [%d - %d]\n", Sconv(Curfn.Nname.Sym, 0), len(var_), nkill)
+ for i = 0; i < len(var_); i++ {
+ v = &var_[i]
+ fmt.Printf("var %v %v %d-%d", Nconv(v.node, obj.FmtSharp), Tconv(v.node.Type, 0), v.start, v.end)
+ if v.addr != 0 {
+ fmt.Printf(" addr=1")
+ }
+ if v.removed != 0 {
+ fmt.Printf(" dead=1")
+ }
+ if v.merge != nil {
+ fmt.Printf(" merge %v", Nconv(v.merge.node, obj.FmtSharp))
+ }
+ if v.start == v.end && v.def != nil {
+ fmt.Printf(" %v", v.def.Prog)
+ }
+ fmt.Printf("\n")
+ }
+
+ if debugmerge > 1 && Debug['v'] != 0 {
+ Dumpit("after", g.Start, 0)
+ }
+ }
+
+ // Update node references to use merged temporaries.
+ for f = g.Start; f != nil; f = f.Link {
+ p = f.Prog
+ n, _ = p.From.Node.(*Node)
+ if n != nil {
+ v, _ = n.Opt.(*TempVar)
+ if v != nil && v.merge != nil {
+ p.From.Node = v.merge.node
+ }
+ }
+ n, _ = p.To.Node.(*Node)
+ if n != nil {
+ v, _ = n.Opt.(*TempVar)
+ if v != nil && v.merge != nil {
+ p.To.Node = v.merge.node
+ }
+ }
+ }
+
+ // Delete merged nodes from declaration list.
+ for lp = &Curfn.Dcl; ; {
+ l = *lp
+ if !(l != nil) {
+ break
+ }
+
+ Curfn.Dcl.End = l
+ n = l.N
+ v, _ = n.Opt.(*TempVar)
+ if v != nil && (v.merge != nil || v.removed != 0) {
+ *lp = l.Next
+ continue
+ }
+
+ lp = &l.Next
+ }
+
+ // Clear aux structures.
+ for i = 0; i < len(var_); i++ {
+ var_[i].node.Opt = nil
+ }
+
+ Flowend(g)
+}
+
+func mergewalk(v *TempVar, f0 *Flow, gen uint32) {
+ var p *obj.Prog
+ var f1 *Flow
+ var f *Flow
+ var f2 *Flow
+
+ for f1 = f0; f1 != nil; f1 = f1.P1 {
+ if uint32(f1.Active) == gen {
+ break
+ }
+ f1.Active = int32(gen)
+ p = f1.Prog
+ if v.end < p.Pc {
+ v.end = p.Pc
+ }
+ if f1 == v.def {
+ v.start = p.Pc
+ break
+ }
+ }
+
+ for f = f0; f != f1; f = f.P1 {
+ for f2 = f.P2; f2 != nil; f2 = f2.P2link {
+ mergewalk(v, f2, gen)
+ }
+ }
+}
+
+func varkillwalk(v *TempVar, f0 *Flow, gen uint32) {
+ var p *obj.Prog
+ var f1 *Flow
+ var f *Flow
+
+ for f1 = f0; f1 != nil; f1 = f1.S1 {
+ if uint32(f1.Active) == gen {
+ break
+ }
+ f1.Active = int32(gen)
+ p = f1.Prog
+ if v.end < p.Pc {
+ v.end = p.Pc
+ }
+ if v.start > p.Pc {
+ v.start = p.Pc
+ }
+ if p.As == obj.ARET || (p.As == obj.AVARKILL && p.To.Node == v.node) {
+ break
+ }
+ }
+
+ for f = f0; f != f1; f = f.S1 {
+ varkillwalk(v, f.S2, gen)
+ }
+}
+
+// Eliminate redundant nil pointer checks.
+//
+// The code generation pass emits a CHECKNIL for every possibly nil pointer.
+// This pass removes a CHECKNIL if every predecessor path has already
+// checked this value for nil.
+//
+// Simple backwards flood from check to definition.
+// Run prog loop backward from end of program to beginning to avoid quadratic
+// behavior removing a run of checks.
+//
+// Assume that stack variables with address not taken can be loaded multiple times
+// from memory without being rechecked. Other variables need to be checked on
+// each load.
+type NilVar struct {
+}
+
+var killed int // f->data is either nil or &killed
+
+func nilopt(firstp *obj.Prog) {
+ var f *Flow
+ var p *obj.Prog
+ var g *Graph
+ var ncheck int
+ var nkill int
+
+ g = Flowstart(firstp, nil)
+ if g == nil {
+ return
+ }
+
+ if Debug_checknil > 1 { /* || strcmp(curfn->nname->sym->name, "f1") == 0 */
+ Dumpit("nilopt", g.Start, 0)
+ }
+
+ ncheck = 0
+ nkill = 0
+ for f = g.Start; f != nil; f = f.Link {
+ p = f.Prog
+ if p.As != obj.ACHECKNIL || !(Thearch.Regtyp(&p.From) != 0) {
+ continue
+ }
+ ncheck++
+ if Thearch.Stackaddr(&p.From) != 0 {
+ if Debug_checknil != 0 && p.Lineno > 1 {
+ Warnl(int(p.Lineno), "removed nil check of SP address")
+ }
+ f.Data = &killed
+ continue
+ }
+
+ nilwalkfwd(f)
+ if f.Data != nil {
+ if Debug_checknil != 0 && p.Lineno > 1 {
+ Warnl(int(p.Lineno), "removed nil check before indirect")
+ }
+ continue
+ }
+
+ nilwalkback(f)
+ if f.Data != nil {
+ if Debug_checknil != 0 && p.Lineno > 1 {
+ Warnl(int(p.Lineno), "removed repeated nil check")
+ }
+ continue
+ }
+ }
+
+ for f = g.Start; f != nil; f = f.Link {
+ if f.Data != nil {
+ nkill++
+ Thearch.Excise(f)
+ }
+ }
+
+ Flowend(g)
+
+ if Debug_checknil > 1 {
+ fmt.Printf("%v: removed %d of %d nil checks\n", Sconv(Curfn.Nname.Sym, 0), nkill, ncheck)
+ }
+}
+
+func nilwalkback(fcheck *Flow) {
+ var p *obj.Prog
+ var info ProgInfo
+ var f *Flow
+
+ for f = fcheck; f != nil; f = Uniqp(f) {
+ p = f.Prog
+ Thearch.Proginfo(&info, p)
+ if (info.Flags&RightWrite != 0) && Thearch.Sameaddr(&p.To, &fcheck.Prog.From) != 0 {
+ // Found initialization of value we're checking for nil.
+ // without first finding the check, so this one is unchecked.
+ return
+ }
+
+ if f != fcheck && p.As == obj.ACHECKNIL && Thearch.Sameaddr(&p.From, &fcheck.Prog.From) != 0 {
+ fcheck.Data = &killed
+ return
+ }
+ }
+}
+
+// Here is a more complex version that scans backward across branches.
+// It assumes fcheck->kill = 1 has been set on entry, and its job is to find a reason
+// to keep the check (setting fcheck->kill = 0).
+// It doesn't handle copying of aggregates as well as I would like,
+// nor variables with their address taken,
+// and it's too subtle to turn on this late in Go 1.2. Perhaps for Go 1.3.
+/*
+for(f1 = f0; f1 != nil; f1 = f1->p1) {
+ if(f1->active == gen)
+ break;
+ f1->active = gen;
+ p = f1->prog;
+
+ // If same check, stop this loop but still check
+ // alternate predecessors up to this point.
+ if(f1 != fcheck && p->as == ACHECKNIL && thearch.sameaddr(&p->from, &fcheck->prog->from))
+ break;
+
+ thearch.proginfo(&info, p);
+ if((info.flags & RightWrite) && thearch.sameaddr(&p->to, &fcheck->prog->from)) {
+ // Found initialization of value we're checking for nil.
+ // without first finding the check, so this one is unchecked.
+ fcheck->kill = 0;
+ return;
+ }
+
+ if(f1->p1 == nil && f1->p2 == nil) {
+ print("lost pred for %P\n", fcheck->prog);
+ for(f1=f0; f1!=nil; f1=f1->p1) {
+ thearch.proginfo(&info, f1->prog);
+ print("\t%P %d %d %D %D\n", r1->prog, info.flags&RightWrite, thearch.sameaddr(&f1->prog->to, &fcheck->prog->from), &f1->prog->to, &fcheck->prog->from);
+ }
+ fatal("lost pred trail");
+ }
+}
+
+for(f = f0; f != f1; f = f->p1)
+ for(f2 = f->p2; f2 != nil; f2 = f2->p2link)
+ nilwalkback(fcheck, f2, gen);
+*/
+func nilwalkfwd(fcheck *Flow) {
+ var f *Flow
+ var last *Flow
+ var p *obj.Prog
+ var info ProgInfo
+
+ // If the path down from rcheck dereferences the address
+ // (possibly with a small offset) before writing to memory
+ // and before any subsequent checks, it's okay to wait for
+ // that implicit check. Only consider this basic block to
+ // avoid problems like:
+ // _ = *x // should panic
+ // for {} // no writes but infinite loop may be considered visible
+ last = nil
+
+ for f = Uniqs(fcheck); f != nil; f = Uniqs(f) {
+ p = f.Prog
+ Thearch.Proginfo(&info, p)
+
+ if (info.Flags&LeftRead != 0) && Thearch.Smallindir(&p.From, &fcheck.Prog.From) != 0 {
+ fcheck.Data = &killed
+ return
+ }
+
+ if (info.Flags&(RightRead|RightWrite) != 0) && Thearch.Smallindir(&p.To, &fcheck.Prog.From) != 0 {
+ fcheck.Data = &killed
+ return
+ }
+
+ // Stop if another nil check happens.
+ if p.As == obj.ACHECKNIL {
+ return
+ }
+
+ // Stop if value is lost.
+ if (info.Flags&RightWrite != 0) && Thearch.Sameaddr(&p.To, &fcheck.Prog.From) != 0 {
+ return
+ }
+
+ // Stop if memory write.
+ if (info.Flags&RightWrite != 0) && !(Thearch.Regtyp(&p.To) != 0) {
+ return
+ }
+
+ // Stop if we jump backward.
+ if last != nil && f.Id <= last.Id {
+ return
+ }
+ last = f
+ }
+}
diff --git a/src/cmd/internal/gc/racewalk.go b/src/cmd/internal/gc/racewalk.go
new file mode 100644
index 0000000..fe7a82c
--- /dev/null
+++ b/src/cmd/internal/gc/racewalk.go
@@ -0,0 +1,681 @@
+// Copyright 2012 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
+
+import (
+ "fmt"
+ "strings"
+)
+
+// The racewalk pass modifies the code tree for the function as follows:
+//
+// 1. It inserts a call to racefuncenter at the beginning of each function.
+// 2. It inserts a call to racefuncexit at the end of each function.
+// 3. It inserts a call to raceread before each memory read.
+// 4. It inserts a call to racewrite before each memory write.
+//
+// The rewriting is not yet complete. Certain nodes are not rewritten
+// but should be.
+
+// TODO(dvyukov): do not instrument initialization as writes:
+// a := make([]int, 10)
+
+// Do not instrument the following packages at all,
+// at best instrumentation would cause infinite recursion.
+var omit_pkgs = []string{"runtime", "runtime/race"}
+
+// Only insert racefuncenter/racefuncexit into the following packages.
+// Memory accesses in the packages are either uninteresting or will cause false positives.
+var noinst_pkgs = []string{"sync", "sync/atomic"}
+
+func ispkgin(pkgs []string) int {
+ var i int
+
+ if myimportpath != "" {
+ for i = 0; i < len(pkgs); i++ {
+ if myimportpath == pkgs[i] {
+ return 1
+ }
+ }
+ }
+
+ return 0
+}
+
+func isforkfunc(fn *Node) int {
+ // Special case for syscall.forkAndExecInChild.
+ // In the child, this function must not acquire any locks, because
+ // they might have been locked at the time of the fork. This means
+ // no rescheduling, no malloc calls, and no new stack segments.
+ // Race instrumentation does all of the above.
+ return bool2int(myimportpath != "" && myimportpath == "syscall" && fn.Nname.Sym.Name == "forkAndExecInChild")
+}
+
+func racewalk(fn *Node) {
+ var nd *Node
+ var nodpc *Node
+ var s string
+
+ if ispkgin(omit_pkgs) != 0 || isforkfunc(fn) != 0 {
+ return
+ }
+
+ if !(ispkgin(noinst_pkgs) != 0) {
+ racewalklist(fn.Nbody, nil)
+
+ // nothing interesting for race detector in fn->enter
+ racewalklist(fn.Exit, nil)
+ }
+
+ // nodpc is the PC of the caller as extracted by
+ // getcallerpc. We use -widthptr(FP) for x86.
+ // BUG: this will not work on arm.
+ nodpc = Nod(OXXX, nil, nil)
+
+ *nodpc = *nodfp
+ nodpc.Type = Types[TUINTPTR]
+ nodpc.Xoffset = int64(-Widthptr)
+ nd = mkcall("racefuncenter", nil, nil, nodpc)
+ fn.Enter = concat(list1(nd), fn.Enter)
+ nd = mkcall("racefuncexit", nil, nil)
+ fn.Exit = list(fn.Exit, nd)
+
+ if Debug['W'] != 0 {
+ s = fmt.Sprintf("after racewalk %v", Sconv(fn.Nname.Sym, 0))
+ dumplist(s, fn.Nbody)
+ s = fmt.Sprintf("enter %v", Sconv(fn.Nname.Sym, 0))
+ dumplist(s, fn.Enter)
+ s = fmt.Sprintf("exit %v", Sconv(fn.Nname.Sym, 0))
+ dumplist(s, fn.Exit)
+ }
+}
+
+func racewalklist(l *NodeList, init **NodeList) {
+ var instr *NodeList
+
+ for ; l != nil; l = l.Next {
+ instr = nil
+ racewalknode(&l.N, &instr, 0, 0)
+ if init == nil {
+ l.N.Ninit = concat(l.N.Ninit, instr)
+ } else {
+ *init = concat(*init, instr)
+ }
+ }
+}
+
+// walkexpr and walkstmt combined
+// walks the tree and adds calls to the
+// instrumentation code to top-level (statement) nodes' init
+func racewalknode(np **Node, init **NodeList, wr int, skip int) {
+ var n *Node
+ var n1 *Node
+ var l *NodeList
+ var fini *NodeList
+
+ n = *np
+
+ if n == nil {
+ return
+ }
+
+ if Debug['w'] > 1 {
+ Dump("racewalk-before", n)
+ }
+ setlineno(n)
+ if init == nil {
+ Fatal("racewalk: bad init list")
+ }
+ if init == &n.Ninit {
+ // If init == &n->ninit and n->ninit is non-nil,
+ // racewalknode might append it to itself.
+ // nil it out and handle it separately before putting it back.
+ l = n.Ninit
+
+ n.Ninit = nil
+ racewalklist(l, nil)
+ racewalknode(&n, &l, wr, skip) // recurse with nil n->ninit
+ appendinit(&n, l)
+ *np = n
+ return
+ }
+
+ racewalklist(n.Ninit, nil)
+
+ switch n.Op {
+ default:
+ Fatal("racewalk: unknown node type %v", Oconv(int(n.Op), 0))
+ fallthrough
+
+ case OAS,
+ OAS2FUNC:
+ racewalknode(&n.Left, init, 1, 0)
+ racewalknode(&n.Right, init, 0, 0)
+ goto ret
+
+ // can't matter
+ case OCFUNC,
+ OVARKILL:
+ goto ret
+
+ case OBLOCK:
+ if n.List == nil {
+ goto ret
+ }
+
+ switch n.List.N.Op {
+ // Blocks are used for multiple return function calls.
+ // x, y := f() becomes BLOCK{CALL f, AS x [SP+0], AS y [SP+n]}
+ // We don't want to instrument between the statements because it will
+ // smash the results.
+ case OCALLFUNC,
+ OCALLMETH,
+ OCALLINTER:
+ racewalknode(&n.List.N, &n.List.N.Ninit, 0, 0)
+
+ fini = nil
+ racewalklist(n.List.Next, &fini)
+ n.List = concat(n.List, fini)
+
+ // Ordinary block, for loop initialization or inlined bodies.
+ default:
+ racewalklist(n.List, nil)
+ }
+
+ goto ret
+
+ case ODEFER:
+ racewalknode(&n.Left, init, 0, 0)
+ goto ret
+
+ case OPROC:
+ racewalknode(&n.Left, init, 0, 0)
+ goto ret
+
+ case OCALLINTER:
+ racewalknode(&n.Left, init, 0, 0)
+ goto ret
+
+ // Instrument dst argument of runtime.writebarrier* calls
+ // as we do not instrument runtime code.
+ // typedslicecopy is instrumented in runtime.
+ case OCALLFUNC:
+ if n.Left.Sym != nil && n.Left.Sym.Pkg == Runtimepkg && (strings.HasPrefix(n.Left.Sym.Name, "writebarrier") || n.Left.Sym.Name == "typedmemmove") {
+ // Find the dst argument.
+ // The list can be reordered, so it's not necessary just the first or the second element.
+ for l = n.List; l != nil; l = l.Next {
+ if n.Left.Sym.Name == "typedmemmove" {
+ if l.N.Left.Xoffset == int64(Widthptr) {
+ break
+ }
+ } else {
+ if l.N.Left.Xoffset == 0 {
+ break
+ }
+ }
+ }
+
+ if l == nil {
+ Fatal("racewalk: writebarrier no arg")
+ }
+ if l.N.Right.Op != OADDR {
+ Fatal("racewalk: writebarrier bad arg")
+ }
+ callinstr(&l.N.Right.Left, init, 1, 0)
+ }
+
+ racewalknode(&n.Left, init, 0, 0)
+ goto ret
+
+ case ONOT,
+ OMINUS,
+ OPLUS,
+ OREAL,
+ OIMAG,
+ OCOM:
+ racewalknode(&n.Left, init, wr, 0)
+ goto ret
+
+ case ODOTINTER:
+ racewalknode(&n.Left, init, 0, 0)
+ goto ret
+
+ case ODOT:
+ racewalknode(&n.Left, init, 0, 1)
+ callinstr(&n, init, wr, skip)
+ goto ret
+
+ case ODOTPTR: // dst = (*x).f with implicit *; otherwise it's ODOT+OIND
+ racewalknode(&n.Left, init, 0, 0)
+
+ callinstr(&n, init, wr, skip)
+ goto ret
+
+ case OIND: // *p
+ racewalknode(&n.Left, init, 0, 0)
+
+ callinstr(&n, init, wr, skip)
+ goto ret
+
+ case OSPTR,
+ OLEN,
+ OCAP:
+ racewalknode(&n.Left, init, 0, 0)
+ if Istype(n.Left.Type, TMAP) != 0 {
+ n1 = Nod(OCONVNOP, n.Left, nil)
+ n1.Type = Ptrto(Types[TUINT8])
+ n1 = Nod(OIND, n1, nil)
+ typecheck(&n1, Erv)
+ callinstr(&n1, init, 0, skip)
+ }
+
+ goto ret
+
+ case OLSH,
+ ORSH,
+ OLROT,
+ OAND,
+ OANDNOT,
+ OOR,
+ OXOR,
+ OSUB,
+ OMUL,
+ OHMUL,
+ OEQ,
+ ONE,
+ OLT,
+ OLE,
+ OGE,
+ OGT,
+ OADD,
+ OCOMPLEX:
+ racewalknode(&n.Left, init, wr, 0)
+ racewalknode(&n.Right, init, wr, 0)
+ goto ret
+
+ case OANDAND,
+ OOROR:
+ racewalknode(&n.Left, init, wr, 0)
+
+ // walk has ensured the node has moved to a location where
+ // side effects are safe.
+ // n->right may not be executed,
+ // so instrumentation goes to n->right->ninit, not init.
+ racewalknode(&n.Right, &n.Right.Ninit, wr, 0)
+
+ goto ret
+
+ case ONAME:
+ callinstr(&n, init, wr, skip)
+ goto ret
+
+ case OCONV:
+ racewalknode(&n.Left, init, wr, 0)
+ goto ret
+
+ case OCONVNOP:
+ racewalknode(&n.Left, init, wr, 0)
+ goto ret
+
+ case ODIV,
+ OMOD:
+ racewalknode(&n.Left, init, wr, 0)
+ racewalknode(&n.Right, init, wr, 0)
+ goto ret
+
+ case OINDEX:
+ if !(Isfixedarray(n.Left.Type) != 0) {
+ racewalknode(&n.Left, init, 0, 0)
+ } else if !(islvalue(n.Left) != 0) {
+ // index of unaddressable array, like Map[k][i].
+ racewalknode(&n.Left, init, wr, 0)
+
+ racewalknode(&n.Right, init, 0, 0)
+ goto ret
+ }
+
+ racewalknode(&n.Right, init, 0, 0)
+ if n.Left.Type.Etype != TSTRING {
+ callinstr(&n, init, wr, skip)
+ }
+ goto ret
+
+ // Seems to only lead to double instrumentation.
+ //racewalknode(&n->left, init, 0, 0);
+ case OSLICE,
+ OSLICEARR,
+ OSLICE3,
+ OSLICE3ARR:
+ goto ret
+
+ case OADDR:
+ racewalknode(&n.Left, init, 0, 1)
+ goto ret
+
+ // n->left is Type* which is not interesting.
+ case OEFACE:
+ racewalknode(&n.Right, init, 0, 0)
+
+ goto ret
+
+ case OITAB:
+ racewalknode(&n.Left, init, 0, 0)
+ goto ret
+
+ // should not appear in AST by now
+ case OSEND,
+ ORECV,
+ OCLOSE,
+ ONEW,
+ OXCASE,
+ OXFALL,
+ OCASE,
+ OPANIC,
+ ORECOVER,
+ OCONVIFACE,
+ OCMPIFACE,
+ OMAKECHAN,
+ OMAKEMAP,
+ OMAKESLICE,
+ OCALL,
+ OCOPY,
+ OAPPEND,
+ ORUNESTR,
+ OARRAYBYTESTR,
+ OARRAYRUNESTR,
+ OSTRARRAYBYTE,
+ OSTRARRAYRUNE,
+ OINDEXMAP,
+ // lowered to call
+ OCMPSTR,
+ OADDSTR,
+ ODOTTYPE,
+ ODOTTYPE2,
+ OAS2DOTTYPE,
+ OCALLPART,
+ // lowered to PTRLIT
+ OCLOSURE, // lowered to PTRLIT
+ ORANGE, // lowered to ordinary for loop
+ OARRAYLIT, // lowered to assignments
+ OMAPLIT,
+ OSTRUCTLIT,
+ OAS2,
+ OAS2RECV,
+ OAS2MAPR,
+ OASOP:
+ Yyerror("racewalk: %v must be lowered by now", Oconv(int(n.Op), 0))
+
+ goto ret
+
+ // impossible nodes: only appear in backend.
+ case ORROTC,
+ OEXTEND:
+ Yyerror("racewalk: %v cannot exist now", Oconv(int(n.Op), 0))
+
+ goto ret
+
+ // just do generic traversal
+ case OFOR,
+ OIF,
+ OCALLMETH,
+ ORETURN,
+ ORETJMP,
+ OSWITCH,
+ OSELECT,
+ OEMPTY,
+ OBREAK,
+ OCONTINUE,
+ OFALL,
+ OGOTO,
+ OLABEL:
+ goto ret
+
+ // does not require instrumentation
+ case OPRINT, // don't bother instrumenting it
+ OPRINTN, // don't bother instrumenting it
+ OCHECKNIL, // always followed by a read.
+ OPARAM, // it appears only in fn->exit to copy heap params back
+ OCLOSUREVAR, // immutable pointer to captured variable
+ ODOTMETH, // either part of CALLMETH or CALLPART (lowered to PTRLIT)
+ OINDREG, // at this stage, only n(SP) nodes from nodarg
+ ODCL, // declarations (without value) cannot be races
+ ODCLCONST,
+ ODCLTYPE,
+ OTYPE,
+ ONONAME,
+ OLITERAL,
+ OSLICESTR,
+ // always preceded by bounds checking, avoid double instrumentation.
+ OTYPESW: // ignored by code generation, do not instrument.
+ goto ret
+ }
+
+ret:
+ if n.Op != OBLOCK { // OBLOCK is handled above in a special way.
+ racewalklist(n.List, init)
+ }
+ if n.Ntest != nil {
+ racewalknode(&n.Ntest, &n.Ntest.Ninit, 0, 0)
+ }
+ if n.Nincr != nil {
+ racewalknode(&n.Nincr, &n.Nincr.Ninit, 0, 0)
+ }
+ racewalklist(n.Nbody, nil)
+ racewalklist(n.Nelse, nil)
+ racewalklist(n.Rlist, nil)
+ *np = n
+}
+
+func isartificial(n *Node) int {
+ // compiler-emitted artificial things that we do not want to instrument,
+ // cant' possibly participate in a data race.
+ if n.Op == ONAME && n.Sym != nil && n.Sym.Name != "" {
+ if n.Sym.Name == "_" {
+ return 1
+ }
+
+ // autotmp's are always local
+ if strings.HasPrefix(n.Sym.Name, "autotmp_") {
+ return 1
+ }
+
+ // statictmp's are read-only
+ if strings.HasPrefix(n.Sym.Name, "statictmp_") {
+ return 1
+ }
+
+ // go.itab is accessed only by the compiler and runtime (assume safe)
+ if n.Sym.Pkg != nil && n.Sym.Pkg.Name != "" && n.Sym.Pkg.Name == "go.itab" {
+ return 1
+ }
+ }
+
+ return 0
+}
+
+func callinstr(np **Node, init **NodeList, wr int, skip int) int {
+ var name string
+ var f *Node
+ var b *Node
+ var n *Node
+ var t *Type
+ var class int
+ var hascalls int
+
+ n = *np
+
+ //print("callinstr for %+N [ %O ] etype=%E class=%d\n",
+ // n, n->op, n->type ? n->type->etype : -1, n->class);
+
+ if skip != 0 || n.Type == nil || n.Type.Etype >= TIDEAL {
+ return 0
+ }
+ t = n.Type
+ if isartificial(n) != 0 {
+ return 0
+ }
+
+ b = outervalue(n)
+
+ // it skips e.g. stores to ... parameter array
+ if isartificial(b) != 0 {
+ return 0
+ }
+ class = int(b.Class)
+
+ // BUG: we _may_ want to instrument PAUTO sometimes
+ // e.g. if we've got a local variable/method receiver
+ // that has got a pointer inside. Whether it points to
+ // the heap or not is impossible to know at compile time
+ if (class&PHEAP != 0) || class == PPARAMREF || class == PEXTERN || b.Op == OINDEX || b.Op == ODOTPTR || b.Op == OIND {
+ hascalls = 0
+ foreach(n, hascallspred, &hascalls)
+ if hascalls != 0 {
+ n = detachexpr(n, init)
+ *np = n
+ }
+
+ n = treecopy(n)
+ makeaddable(n)
+ if t.Etype == TSTRUCT || Isfixedarray(t) != 0 {
+ name = "racereadrange"
+ if wr != 0 {
+ name = "racewriterange"
+ }
+ f = mkcall(name, nil, init, uintptraddr(n), Nodintconst(t.Width))
+ } else {
+ name = "raceread"
+ if wr != 0 {
+ name = "racewrite"
+ }
+ f = mkcall(name, nil, init, uintptraddr(n))
+ }
+
+ *init = list(*init, f)
+ return 1
+ }
+
+ return 0
+}
+
+// makeaddable returns a node whose memory location is the
+// same as n, but which is addressable in the Go language
+// sense.
+// This is different from functions like cheapexpr that may make
+// a copy of their argument.
+func makeaddable(n *Node) {
+ // The arguments to uintptraddr technically have an address but
+ // may not be addressable in the Go sense: for example, in the case
+ // of T(v).Field where T is a struct type and v is
+ // an addressable value.
+ switch n.Op {
+ case OINDEX:
+ if Isfixedarray(n.Left.Type) != 0 {
+ makeaddable(n.Left)
+ }
+
+ // Turn T(v).Field into v.Field
+ case ODOT,
+ OXDOT:
+ if n.Left.Op == OCONVNOP {
+ n.Left = n.Left.Left
+ }
+ makeaddable(n.Left)
+
+ // nothing to do
+ case ODOTPTR:
+ fallthrough
+ default:
+ break
+ }
+}
+
+func uintptraddr(n *Node) *Node {
+ var r *Node
+
+ r = Nod(OADDR, n, nil)
+ r.Bounded = 1
+ r = conv(r, Types[TUNSAFEPTR])
+ r = conv(r, Types[TUINTPTR])
+ return r
+}
+
+func detachexpr(n *Node, init **NodeList) *Node {
+ var addr *Node
+ var as *Node
+ var ind *Node
+ var l *Node
+
+ addr = Nod(OADDR, n, nil)
+ l = temp(Ptrto(n.Type))
+ as = Nod(OAS, l, addr)
+ typecheck(&as, Etop)
+ walkexpr(&as, init)
+ *init = list(*init, as)
+ ind = Nod(OIND, l, nil)
+ typecheck(&ind, Erv)
+ walkexpr(&ind, init)
+ return ind
+}
+
+func foreachnode(n *Node, f func(*Node, interface{}), c interface{}) {
+ if n != nil {
+ f(n, c)
+ }
+}
+
+func foreachlist(l *NodeList, f func(*Node, interface{}), c interface{}) {
+ for ; l != nil; l = l.Next {
+ foreachnode(l.N, f, c)
+ }
+}
+
+func foreach(n *Node, f func(*Node, interface{}), c interface{}) {
+ foreachlist(n.Ninit, f, c)
+ foreachnode(n.Left, f, c)
+ foreachnode(n.Right, f, c)
+ foreachlist(n.List, f, c)
+ foreachnode(n.Ntest, f, c)
+ foreachnode(n.Nincr, f, c)
+ foreachlist(n.Nbody, f, c)
+ foreachlist(n.Nelse, f, c)
+ foreachlist(n.Rlist, f, c)
+}
+
+func hascallspred(n *Node, c interface{}) {
+ switch n.Op {
+ case OCALL,
+ OCALLFUNC,
+ OCALLMETH,
+ OCALLINTER:
+ (*c.(*int))++
+ }
+}
+
+// appendinit is like addinit in subr.c
+// but appends rather than prepends.
+func appendinit(np **Node, init *NodeList) {
+ var n *Node
+
+ if init == nil {
+ return
+ }
+
+ n = *np
+ switch n.Op {
+ // There may be multiple refs to this node;
+ // introduce OCONVNOP to hold init list.
+ case ONAME,
+ OLITERAL:
+ n = Nod(OCONVNOP, n, nil)
+
+ n.Type = n.Left.Type
+ n.Typecheck = 1
+ *np = n
+ }
+
+ n.Ninit = concat(n.Ninit, init)
+ n.Ullman = UINF
+}
diff --git a/src/cmd/internal/gc/range.go b/src/cmd/internal/gc/range.go
new file mode 100644
index 0000000..1e33da3
--- /dev/null
+++ b/src/cmd/internal/gc/range.go
@@ -0,0 +1,426 @@
+// 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
+
+import "cmd/internal/obj"
+
+/*
+ * range
+ */
+func typecheckrange(n *Node) {
+ var toomany int
+ var why string
+ var t *Type
+ var t1 *Type
+ var t2 *Type
+ var v1 *Node
+ var v2 *Node
+ var ll *NodeList
+
+ // Typechecking order is important here:
+ // 0. first typecheck range expression (slice/map/chan),
+ // it is evaluated only once and so logically it is not part of the loop.
+ // 1. typcheck produced values,
+ // this part can declare new vars and so it must be typechecked before body,
+ // because body can contain a closure that captures the vars.
+ // 2. decldepth++ to denote loop body.
+ // 3. typecheck body.
+ // 4. decldepth--.
+
+ typecheck(&n.Right, Erv)
+
+ t = n.Right.Type
+ if t == nil {
+ goto out
+ }
+
+ // delicate little dance. see typecheckas2
+ for ll = n.List; ll != nil; ll = ll.Next {
+ if ll.N.Defn != n {
+ typecheck(&ll.N, Erv|Easgn)
+ }
+ }
+
+ if Isptr[t.Etype] != 0 && Isfixedarray(t.Type) != 0 {
+ t = t.Type
+ }
+ n.Type = t
+
+ toomany = 0
+ switch t.Etype {
+ default:
+ Yyerror("cannot range over %v", Nconv(n.Right, obj.FmtLong))
+ goto out
+
+ case TARRAY:
+ t1 = Types[TINT]
+ t2 = t.Type
+
+ case TMAP:
+ t1 = t.Down
+ t2 = t.Type
+
+ case TCHAN:
+ if !(t.Chan&Crecv != 0) {
+ Yyerror("invalid operation: range %v (receive from send-only type %v)", Nconv(n.Right, 0), Tconv(n.Right.Type, 0))
+ goto out
+ }
+
+ t1 = t.Type
+ t2 = nil
+ if count(n.List) == 2 {
+ toomany = 1
+ }
+
+ case TSTRING:
+ t1 = Types[TINT]
+ t2 = runetype
+ }
+
+ if count(n.List) > 2 || toomany != 0 {
+ Yyerror("too many variables in range")
+ }
+
+ v1 = nil
+ if n.List != nil {
+ v1 = n.List.N
+ }
+ v2 = nil
+ if n.List != nil && n.List.Next != nil {
+ v2 = n.List.Next.N
+ }
+
+ // this is not only a optimization but also a requirement in the spec.
+ // "if the second iteration variable is the blank identifier, the range
+ // clause is equivalent to the same clause with only the first variable
+ // present."
+ if isblank(v2) {
+ if v1 != nil {
+ n.List = list1(v1)
+ }
+ v2 = nil
+ }
+
+ if v1 != nil {
+ if v1.Defn == n {
+ v1.Type = t1
+ } else if v1.Type != nil && assignop(t1, v1.Type, &why) == 0 {
+ Yyerror("cannot assign type %v to %v in range%s", Tconv(t1, 0), Nconv(v1, obj.FmtLong), why)
+ }
+ checkassign(n, v1)
+ }
+
+ if v2 != nil {
+ if v2.Defn == n {
+ v2.Type = t2
+ } else if v2.Type != nil && assignop(t2, v2.Type, &why) == 0 {
+ Yyerror("cannot assign type %v to %v in range%s", Tconv(t2, 0), Nconv(v2, obj.FmtLong), why)
+ }
+ checkassign(n, v2)
+ }
+
+ // second half of dance
+out:
+ n.Typecheck = 1
+
+ for ll = n.List; ll != nil; ll = ll.Next {
+ if ll.N.Typecheck == 0 {
+ typecheck(&ll.N, Erv|Easgn)
+ }
+ }
+
+ decldepth++
+ typechecklist(n.Nbody, Etop)
+ decldepth--
+}
+
+func walkrange(n *Node) {
+ var ohv1 *Node
+ var hv1 *Node // hidden (old) val 1, 2 // hidden aggregate, iterator // hidden len, pointer // hidden bool // not hidden aggregate, val 1, 2
+ var hv2 *Node
+ var ha *Node
+ var hit *Node
+ var hn *Node
+ var hp *Node
+ var hb *Node
+ var a *Node
+ var v1 *Node
+ var v2 *Node
+ var fn *Node
+ var tmp *Node
+ var keyname *Node
+ var valname *Node
+ var key *Node
+ var val *Node
+ var body *NodeList
+ var init *NodeList
+ var th *Type
+ var t *Type
+ var lno int
+
+ t = n.Type
+ init = nil
+
+ a = n.Right
+ lno = int(setlineno(a))
+
+ v1 = nil
+ if n.List != nil {
+ v1 = n.List.N
+ }
+ v2 = nil
+ if n.List != nil && n.List.Next != nil && !isblank(n.List.Next.N) {
+ v2 = n.List.Next.N
+ }
+
+ // n->list has no meaning anymore, clear it
+ // to avoid erroneous processing by racewalk.
+ n.List = nil
+
+ hv2 = nil
+
+ switch t.Etype {
+ default:
+ Fatal("walkrange")
+ fallthrough
+
+ // Lower n into runtime·memclr if possible, for
+ // fast zeroing of slices and arrays (issue 5373).
+ // Look for instances of
+ //
+ // for i := range a {
+ // a[i] = zero
+ // }
+ //
+ // in which the evaluation of a is side-effect-free.
+ case TARRAY:
+ if !(Debug['N'] != 0) {
+ if !(flag_race != 0) {
+ if v1 != nil {
+ if v2 == nil {
+ if n.Nbody != nil {
+ if n.Nbody.N != nil { // at least one statement in body
+ if n.Nbody.Next == nil { // at most one statement in body
+ tmp = n.Nbody.N // first statement of body
+ if tmp.Op == OAS {
+ if tmp.Left.Op == OINDEX {
+ if samesafeexpr(tmp.Left.Left, a) != 0 {
+ if samesafeexpr(tmp.Left.Right, v1) != 0 {
+ if t.Type.Width > 0 {
+ if iszero(tmp.Right) != 0 {
+ // Convert to
+ // if len(a) != 0 {
+ // hp = &a[0]
+ // hn = len(a)*sizeof(elem(a))
+ // memclr(hp, hn)
+ // i = len(a) - 1
+ // }
+ n.Op = OIF
+
+ n.Nbody = nil
+ n.Ntest = Nod(ONE, Nod(OLEN, a, nil), Nodintconst(0))
+ n.Nincr = nil
+
+ // hp = &a[0]
+ hp = temp(Ptrto(Types[TUINT8]))
+
+ tmp = Nod(OINDEX, a, Nodintconst(0))
+ tmp.Bounded = 1
+ tmp = Nod(OADDR, tmp, nil)
+ tmp = Nod(OCONVNOP, tmp, nil)
+ tmp.Type = Ptrto(Types[TUINT8])
+ n.Nbody = list(n.Nbody, Nod(OAS, hp, tmp))
+
+ // hn = len(a) * sizeof(elem(a))
+ hn = temp(Types[TUINTPTR])
+
+ tmp = Nod(OLEN, a, nil)
+ tmp = Nod(OMUL, tmp, Nodintconst(t.Type.Width))
+ tmp = conv(tmp, Types[TUINTPTR])
+ n.Nbody = list(n.Nbody, Nod(OAS, hn, tmp))
+
+ // memclr(hp, hn)
+ fn = mkcall("memclr", nil, nil, hp, hn)
+
+ n.Nbody = list(n.Nbody, fn)
+
+ // i = len(a) - 1
+ v1 = Nod(OAS, v1, Nod(OSUB, Nod(OLEN, a, nil), Nodintconst(1)))
+
+ n.Nbody = list(n.Nbody, v1)
+
+ typecheck(&n.Ntest, Erv)
+ typechecklist(n.Nbody, Etop)
+ walkstmt(&n)
+ lineno = int32(lno)
+ return
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // orderstmt arranged for a copy of the array/slice variable if needed.
+ ha = a
+
+ hv1 = temp(Types[TINT])
+ hn = temp(Types[TINT])
+ hp = nil
+
+ init = list(init, Nod(OAS, hv1, nil))
+ init = list(init, Nod(OAS, hn, Nod(OLEN, ha, nil)))
+ if v2 != nil {
+ hp = temp(Ptrto(n.Type.Type))
+ tmp = Nod(OINDEX, ha, Nodintconst(0))
+ tmp.Bounded = 1
+ init = list(init, Nod(OAS, hp, Nod(OADDR, tmp, nil)))
+ }
+
+ n.Ntest = Nod(OLT, hv1, hn)
+ n.Nincr = Nod(OAS, hv1, Nod(OADD, hv1, Nodintconst(1)))
+ if v1 == nil {
+ body = nil
+ } else if v2 == nil {
+ body = list1(Nod(OAS, v1, hv1))
+ } else {
+ a = Nod(OAS2, nil, nil)
+ a.List = list(list1(v1), v2)
+ a.Rlist = list(list1(hv1), Nod(OIND, hp, nil))
+ body = list1(a)
+
+ // Advance pointer as part of increment.
+ // We used to advance the pointer before executing the loop body,
+ // but doing so would make the pointer point past the end of the
+ // array during the final iteration, possibly causing another unrelated
+ // piece of memory not to be garbage collected until the loop finished.
+ // 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.Type.Width))
+
+ tmp.Type = hp.Type
+ tmp.Typecheck = 1
+ tmp.Right.Type = Types[Tptr]
+ tmp.Right.Typecheck = 1
+ a = Nod(OAS, hp, tmp)
+ typecheck(&a, Etop)
+ n.Nincr.Ninit = list1(a)
+ }
+
+ // orderstmt allocated the iterator for us.
+ // we only use a once, so no copy needed.
+ case TMAP:
+ ha = a
+
+ th = hiter(t)
+ hit = n.Alloc
+ hit.Type = th
+ n.Left = nil
+ keyname = newname(th.Type.Sym) // depends on layout of iterator struct. See reflect.c:hiter
+ valname = newname(th.Type.Down.Sym) // ditto
+
+ fn = syslook("mapiterinit", 1)
+
+ argtype(fn, t.Down)
+ argtype(fn, t.Type)
+ argtype(fn, th)
+ init = list(init, mkcall1(fn, nil, nil, typename(t), ha, Nod(OADDR, hit, nil)))
+ n.Ntest = Nod(ONE, Nod(ODOT, hit, keyname), nodnil())
+
+ fn = syslook("mapiternext", 1)
+ argtype(fn, th)
+ n.Nincr = mkcall1(fn, nil, nil, Nod(OADDR, hit, nil))
+
+ key = Nod(ODOT, hit, keyname)
+ key = Nod(OIND, key, nil)
+ if v1 == nil {
+ body = nil
+ } else if v2 == nil {
+ body = list1(Nod(OAS, v1, key))
+ } else {
+ val = Nod(ODOT, hit, valname)
+ val = Nod(OIND, val, nil)
+ a = Nod(OAS2, nil, nil)
+ a.List = list(list1(v1), v2)
+ a.Rlist = list(list1(key), val)
+ body = list1(a)
+ }
+
+ // orderstmt arranged for a copy of the channel variable.
+ case TCHAN:
+ ha = a
+
+ n.Ntest = nil
+
+ hv1 = temp(t.Type)
+ hv1.Typecheck = 1
+ if haspointers(t.Type) {
+ init = list(init, Nod(OAS, hv1, nil))
+ }
+ hb = temp(Types[TBOOL])
+
+ n.Ntest = Nod(ONE, hb, Nodbool(0))
+ a = Nod(OAS2RECV, nil, nil)
+ a.Typecheck = 1
+ a.List = list(list1(hv1), hb)
+ a.Rlist = list1(Nod(ORECV, ha, nil))
+ n.Ntest.Ninit = list1(a)
+ if v1 == nil {
+ body = nil
+ } else {
+ body = list1(Nod(OAS, v1, hv1))
+ }
+
+ // orderstmt arranged for a copy of the string variable.
+ case TSTRING:
+ ha = a
+
+ ohv1 = temp(Types[TINT])
+
+ hv1 = temp(Types[TINT])
+ init = list(init, Nod(OAS, hv1, nil))
+
+ if v2 == nil {
+ a = Nod(OAS, hv1, mkcall("stringiter", Types[TINT], nil, ha, hv1))
+ } else {
+ hv2 = temp(runetype)
+ a = Nod(OAS2, nil, nil)
+ a.List = list(list1(hv1), hv2)
+ fn = syslook("stringiter2", 0)
+ a.Rlist = list1(mkcall1(fn, getoutargx(fn.Type), nil, ha, hv1))
+ }
+
+ n.Ntest = Nod(ONE, hv1, Nodintconst(0))
+ n.Ntest.Ninit = list(list1(Nod(OAS, ohv1, hv1)), a)
+
+ body = nil
+ if v1 != nil {
+ body = list1(Nod(OAS, v1, ohv1))
+ }
+ if v2 != nil {
+ body = list(body, Nod(OAS, v2, hv2))
+ }
+ }
+
+ n.Op = OFOR
+ typechecklist(init, Etop)
+ n.Ninit = concat(n.Ninit, init)
+ typechecklist(n.Ntest.Ninit, Etop)
+ typecheck(&n.Ntest, Erv)
+ typecheck(&n.Nincr, Etop)
+ typechecklist(body, Etop)
+ n.Nbody = concat(body, n.Nbody)
+ walkstmt(&n)
+
+ lineno = int32(lno)
+}
diff --git a/src/cmd/internal/gc/reflect.go b/src/cmd/internal/gc/reflect.go
new file mode 100644
index 0000000..4be0f1d
--- /dev/null
+++ b/src/cmd/internal/gc/reflect.go
@@ -0,0 +1,1746 @@
+// 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
+
+import (
+ "cmd/internal/obj"
+ "fmt"
+)
+
+/*
+ * runtime interface and reflection data structures
+ */
+var signatlist *NodeList
+
+func sigcmp(a *Sig, b *Sig) int {
+ var i int
+
+ i = stringsCompare(a.name, b.name)
+ if i != 0 {
+ return i
+ }
+ if a.pkg == b.pkg {
+ return 0
+ }
+ if a.pkg == nil {
+ return -1
+ }
+ if b.pkg == nil {
+ return +1
+ }
+ return stringsCompare(a.pkg.Path.S, b.pkg.Path.S)
+}
+
+func lsort(l *Sig, f func(*Sig, *Sig) int) *Sig {
+ var l1 *Sig
+ var l2 *Sig
+ var le *Sig
+
+ if l == nil || l.link == nil {
+ return l
+ }
+
+ l1 = l
+ l2 = l
+ for {
+ l2 = l2.link
+ if l2 == nil {
+ break
+ }
+ l2 = l2.link
+ if l2 == nil {
+ break
+ }
+ l1 = l1.link
+ }
+
+ l2 = l1.link
+ l1.link = nil
+ l1 = lsort(l, f)
+ l2 = lsort(l2, f)
+
+ /* set up lead element */
+ if f(l1, l2) < 0 {
+ l = l1
+ l1 = l1.link
+ } else {
+ l = l2
+ l2 = l2.link
+ }
+
+ le = l
+
+ for {
+ if l1 == nil {
+ for l2 != nil {
+ le.link = l2
+ le = l2
+ l2 = l2.link
+ }
+
+ le.link = nil
+ break
+ }
+
+ if l2 == nil {
+ for l1 != nil {
+ le.link = l1
+ le = l1
+ l1 = l1.link
+ }
+
+ break
+ }
+
+ if f(l1, l2) < 0 {
+ le.link = l1
+ le = l1
+ l1 = l1.link
+ } else {
+ le.link = l2
+ le = l2
+ l2 = l2.link
+ }
+ }
+
+ le.link = nil
+ return l
+}
+
+// Builds a type respresenting a Bucket structure for
+// the given map type. This type is not visible to users -
+// we include only enough information to generate a correct GC
+// program for it.
+// Make sure this stays in sync with ../../runtime/hashmap.c!
+const (
+ BUCKETSIZE = 8
+ MAXKEYSIZE = 128
+ MAXVALSIZE = 128
+)
+
+func makefield(name string, t *Type) *Type {
+ var f *Type
+
+ f = typ(TFIELD)
+ f.Type = t
+ f.Sym = new(Sym)
+ f.Sym.Name = name
+ return f
+}
+
+func mapbucket(t *Type) *Type {
+ var keytype *Type
+ var valtype *Type
+ var bucket *Type
+ var arr *Type
+ var field [4]*Type
+ var n int32
+
+ if t.Bucket != nil {
+ return t.Bucket
+ }
+
+ bucket = typ(TSTRUCT)
+ keytype = t.Down
+ valtype = t.Type
+ dowidth(keytype)
+ dowidth(valtype)
+ if keytype.Width > MAXKEYSIZE {
+ keytype = Ptrto(keytype)
+ }
+ if valtype.Width > MAXVALSIZE {
+ valtype = Ptrto(valtype)
+ }
+
+ // The first field is: uint8 topbits[BUCKETSIZE].
+ arr = typ(TARRAY)
+
+ arr.Type = Types[TUINT8]
+ arr.Bound = BUCKETSIZE
+ field[0] = makefield("topbits", arr)
+ arr = typ(TARRAY)
+ arr.Type = keytype
+ arr.Bound = BUCKETSIZE
+ field[1] = makefield("keys", arr)
+ arr = typ(TARRAY)
+ arr.Type = valtype
+ arr.Bound = BUCKETSIZE
+ field[2] = makefield("values", arr)
+ field[3] = makefield("overflow", Ptrto(bucket))
+
+ // link up fields
+ bucket.Noalg = 1
+
+ bucket.Local = t.Local
+ bucket.Type = field[0]
+ for n = 0; n < int32(len(field)-1); n++ {
+ field[n].Down = field[n+1]
+ }
+ field[len(field)-1].Down = nil
+ dowidth(bucket)
+
+ // Pad to the native integer alignment.
+ // This is usually the same as widthptr; the exception (as usual) is amd64p32.
+ if Widthreg > Widthptr {
+ bucket.Width += int64(Widthreg) - int64(Widthptr)
+ }
+
+ // See comment on hmap.overflow in ../../runtime/hashmap.go.
+ if !haspointers(t.Type) && !haspointers(t.Down) {
+ bucket.Haspointers = 1 // no pointers
+ }
+
+ t.Bucket = bucket
+
+ bucket.Map = t
+ return bucket
+}
+
+// Builds a type representing a Hmap structure for the given map type.
+// Make sure this stays in sync with ../../runtime/hashmap.go!
+func hmap(t *Type) *Type {
+ var h *Type
+ var bucket *Type
+ var field [8]*Type
+ var n int32
+
+ if t.Hmap != nil {
+ return t.Hmap
+ }
+
+ bucket = mapbucket(t)
+ field[0] = makefield("count", Types[TINT])
+ field[1] = makefield("flags", Types[TUINT8])
+ field[2] = makefield("B", Types[TUINT8])
+ field[3] = makefield("hash0", Types[TUINT32])
+ field[4] = makefield("buckets", Ptrto(bucket))
+ field[5] = makefield("oldbuckets", Ptrto(bucket))
+ field[6] = makefield("nevacuate", Types[TUINTPTR])
+ field[7] = makefield("overflow", Types[TUNSAFEPTR])
+
+ h = typ(TSTRUCT)
+ h.Noalg = 1
+ h.Local = t.Local
+ h.Type = field[0]
+ for n = 0; n < int32(len(field)-1); n++ {
+ field[n].Down = field[n+1]
+ }
+ field[len(field)-1].Down = nil
+ dowidth(h)
+ t.Hmap = h
+ h.Map = t
+ return h
+}
+
+func hiter(t *Type) *Type {
+ var n int32
+ var field [12]*Type
+ var i *Type
+
+ if t.Hiter != nil {
+ return t.Hiter
+ }
+
+ // build a struct:
+ // hash_iter {
+ // key *Key
+ // val *Value
+ // t *MapType
+ // h *Hmap
+ // buckets *Bucket
+ // bptr *Bucket
+ // overflow0 unsafe.Pointer
+ // overflow1 unsafe.Pointer
+ // startBucket uintptr
+ // stuff uintptr
+ // bucket uintptr
+ // checkBucket uintptr
+ // }
+ // must match ../../runtime/hashmap.c:hash_iter.
+ field[0] = makefield("key", Ptrto(t.Down))
+
+ field[1] = makefield("val", Ptrto(t.Type))
+ field[2] = makefield("t", Ptrto(Types[TUINT8]))
+ field[3] = makefield("h", Ptrto(hmap(t)))
+ field[4] = makefield("buckets", Ptrto(mapbucket(t)))
+ field[5] = makefield("bptr", Ptrto(mapbucket(t)))
+ field[6] = makefield("overflow0", Types[TUNSAFEPTR])
+ field[7] = makefield("overflow1", Types[TUNSAFEPTR])
+ field[8] = makefield("startBucket", Types[TUINTPTR])
+ field[9] = makefield("stuff", Types[TUINTPTR]) // offset+wrapped+B+I
+ field[10] = makefield("bucket", Types[TUINTPTR])
+ field[11] = makefield("checkBucket", Types[TUINTPTR])
+
+ // build iterator struct holding the above fields
+ i = typ(TSTRUCT)
+
+ i.Noalg = 1
+ i.Type = field[0]
+ for n = 0; n < int32(len(field)-1); n++ {
+ field[n].Down = field[n+1]
+ }
+ field[len(field)-1].Down = nil
+ dowidth(i)
+ if i.Width != int64(12*Widthptr) {
+ Yyerror("hash_iter size not correct %d %d", i.Width, 12*Widthptr)
+ }
+ t.Hiter = i
+ i.Map = t
+ return i
+}
+
+/*
+ * f is method type, with receiver.
+ * return function type, receiver as first argument (or not).
+ */
+func methodfunc(f *Type, receiver *Type) *Type {
+ var in *NodeList
+ var out *NodeList
+ var d *Node
+ var t *Type
+
+ in = nil
+ if receiver != nil {
+ d = Nod(ODCLFIELD, nil, nil)
+ d.Type = receiver
+ in = list(in, d)
+ }
+
+ for t = getinargx(f).Type; t != nil; t = t.Down {
+ d = Nod(ODCLFIELD, nil, nil)
+ d.Type = t.Type
+ d.Isddd = t.Isddd
+ in = list(in, d)
+ }
+
+ out = nil
+ for t = getoutargx(f).Type; t != nil; t = t.Down {
+ d = Nod(ODCLFIELD, nil, nil)
+ d.Type = t.Type
+ out = list(out, d)
+ }
+
+ t = functype(nil, in, out)
+ if f.Nname != nil {
+ // Link to name of original method function.
+ t.Nname = f.Nname
+ }
+
+ return t
+}
+
+/*
+ * return methods of non-interface type t, sorted by name.
+ * generates stub functions as needed.
+ */
+func methods(t *Type) *Sig {
+ var f *Type
+ var mt *Type
+ var it *Type
+ var this *Type
+ var a *Sig
+ var b *Sig
+ var method *Sym
+
+ // method type
+ mt = methtype(t, 0)
+
+ if mt == nil {
+ return nil
+ }
+ expandmeth(mt)
+
+ // type stored in interface word
+ it = t
+
+ if !(isdirectiface(it) != 0) {
+ it = Ptrto(t)
+ }
+
+ // make list of methods for t,
+ // generating code if necessary.
+ a = nil
+
+ for f = mt.Xmethod; f != nil; f = f.Down {
+ if f.Etype != TFIELD {
+ Fatal("methods: not field %v", Tconv(f, 0))
+ }
+ if f.Type.Etype != TFUNC || f.Type.Thistuple == 0 {
+ Fatal("non-method on %v method %v %v\n", Tconv(mt, 0), Sconv(f.Sym, 0), Tconv(f, 0))
+ }
+ if !(getthisx(f.Type).Type != nil) {
+ Fatal("receiver with no type on %v method %v %v\n", Tconv(mt, 0), Sconv(f.Sym, 0), Tconv(f, 0))
+ }
+ if f.Nointerface != 0 {
+ continue
+ }
+
+ method = f.Sym
+ if method == nil {
+ continue
+ }
+
+ // get receiver type for this particular method.
+ // if pointer receiver but non-pointer t and
+ // this is not an embedded pointer inside a struct,
+ // method does not apply.
+ this = getthisx(f.Type).Type.Type
+
+ if Isptr[this.Etype] != 0 && this.Type == t {
+ continue
+ }
+ if Isptr[this.Etype] != 0 && !(Isptr[t.Etype] != 0) && f.Embedded != 2 && !(isifacemethod(f.Type) != 0) {
+ continue
+ }
+
+ b = new(Sig)
+ b.link = a
+ a = b
+
+ a.name = method.Name
+ if !exportname(method.Name) {
+ if method.Pkg == nil {
+ Fatal("methods: missing package")
+ }
+ a.pkg = method.Pkg
+ }
+
+ a.isym = methodsym(method, it, 1)
+ a.tsym = methodsym(method, t, 0)
+ a.type_ = methodfunc(f.Type, t)
+ a.mtype = methodfunc(f.Type, nil)
+
+ if !(a.isym.Flags&SymSiggen != 0) {
+ a.isym.Flags |= SymSiggen
+ if !Eqtype(this, it) || this.Width < Types[Tptr].Width {
+ compiling_wrappers = 1
+ genwrapper(it, f, a.isym, 1)
+ compiling_wrappers = 0
+ }
+ }
+
+ if !(a.tsym.Flags&SymSiggen != 0) {
+ a.tsym.Flags |= SymSiggen
+ if !Eqtype(this, t) {
+ compiling_wrappers = 1
+ genwrapper(t, f, a.tsym, 0)
+ compiling_wrappers = 0
+ }
+ }
+ }
+
+ return lsort(a, sigcmp)
+}
+
+/*
+ * return methods of interface type t, sorted by name.
+ */
+func imethods(t *Type) *Sig {
+ var a *Sig
+ var all *Sig
+ var last *Sig
+ var f *Type
+ var method *Sym
+ var isym *Sym
+
+ all = nil
+ last = nil
+ for f = t.Type; f != nil; f = f.Down {
+ if f.Etype != TFIELD {
+ Fatal("imethods: not field")
+ }
+ if f.Type.Etype != TFUNC || f.Sym == nil {
+ continue
+ }
+ method = f.Sym
+ a = new(Sig)
+ a.name = method.Name
+ if !exportname(method.Name) {
+ if method.Pkg == nil {
+ Fatal("imethods: missing package")
+ }
+ a.pkg = method.Pkg
+ }
+
+ a.mtype = f.Type
+ a.offset = 0
+ a.type_ = methodfunc(f.Type, nil)
+
+ if last != nil && sigcmp(last, a) >= 0 {
+ Fatal("sigcmp vs sortinter %s %s", last.name, a.name)
+ }
+ if last == nil {
+ all = a
+ } else {
+ last.link = a
+ }
+ last = a
+
+ // Compiler can only refer to wrappers for non-blank methods.
+ if isblanksym(method) {
+ continue
+ }
+
+ // NOTE(rsc): Perhaps an oversight that
+ // IfaceType.Method is not in the reflect data.
+ // Generate the method body, so that compiled
+ // code can refer to it.
+ isym = methodsym(method, t, 0)
+
+ if !(isym.Flags&SymSiggen != 0) {
+ isym.Flags |= SymSiggen
+ genwrapper(t, f, isym, 0)
+ }
+ }
+
+ return all
+}
+
+var dimportpath_gopkg *Pkg
+
+func dimportpath(p *Pkg) {
+ var nam string
+ var n *Node
+
+ if p.Pathsym != nil {
+ return
+ }
+
+ if dimportpath_gopkg == nil {
+ dimportpath_gopkg = mkpkg(newstrlit("go"))
+ dimportpath_gopkg.Name = "go"
+ }
+
+ nam = fmt.Sprintf("importpath.%s.", p.Prefix)
+
+ n = Nod(ONAME, nil, nil)
+ n.Sym = Pkglookup(nam, dimportpath_gopkg)
+
+ n.Class = PEXTERN
+ n.Xoffset = 0
+ p.Pathsym = n.Sym
+
+ gdatastring(n, p.Path)
+ ggloblsym(n.Sym, int32(Types[TSTRING].Width), obj.DUPOK|obj.RODATA)
+}
+
+func dgopkgpath(s *Sym, ot int, pkg *Pkg) int {
+ if pkg == nil {
+ return dgostringptr(s, ot, "")
+ }
+
+ // Emit reference to go.importpath.""., which 6l will
+ // rewrite using the correct import path. Every package
+ // that imports this one directly defines the symbol.
+ if pkg == localpkg {
+ var ns *Sym
+
+ if ns == nil {
+ ns = Pkglookup("importpath.\"\".", mkpkg(newstrlit("go")))
+ }
+ return dsymptr(s, ot, ns, 0)
+ }
+
+ dimportpath(pkg)
+ return dsymptr(s, ot, pkg.Pathsym, 0)
+}
+
+/*
+ * uncommonType
+ * ../../runtime/type.go:/uncommonType
+ */
+func dextratype(sym *Sym, off int, t *Type, ptroff int) int {
+ var ot int
+ var n int
+ var s *Sym
+ var a *Sig
+ var m *Sig
+
+ m = methods(t)
+ if t.Sym == nil && m == nil {
+ return off
+ }
+
+ // fill in *extraType pointer in header
+ off = int(Rnd(int64(off), int64(Widthptr)))
+
+ dsymptr(sym, ptroff, sym, off)
+
+ n = 0
+ for a = m; a != nil; a = a.link {
+ dtypesym(a.type_)
+ n++
+ }
+
+ ot = off
+ s = sym
+ if t.Sym != nil {
+ ot = dgostringptr(s, ot, t.Sym.Name)
+ if t != Types[t.Etype] && t != errortype {
+ ot = dgopkgpath(s, ot, t.Sym.Pkg)
+ } else {
+ ot = dgostringptr(s, ot, "")
+ }
+ } else {
+ ot = dgostringptr(s, ot, "")
+ ot = dgostringptr(s, ot, "")
+ }
+
+ // slice header
+ ot = dsymptr(s, ot, s, ot+Widthptr+2*Widthint)
+
+ ot = duintxx(s, ot, uint64(n), Widthint)
+ ot = duintxx(s, ot, uint64(n), Widthint)
+
+ // methods
+ for a = m; a != nil; a = a.link {
+ // method
+ // ../../runtime/type.go:/method
+ ot = dgostringptr(s, ot, a.name)
+
+ ot = dgopkgpath(s, ot, a.pkg)
+ ot = dsymptr(s, ot, dtypesym(a.mtype), 0)
+ ot = dsymptr(s, ot, dtypesym(a.type_), 0)
+ if a.isym != nil {
+ ot = dsymptr(s, ot, a.isym, 0)
+ } else {
+ ot = duintptr(s, ot, 0)
+ }
+ if a.tsym != nil {
+ ot = dsymptr(s, ot, a.tsym, 0)
+ } else {
+ ot = duintptr(s, ot, 0)
+ }
+ }
+
+ return ot
+}
+
+var kinds = []int{
+ TINT: obj.KindInt,
+ TUINT: obj.KindUint,
+ TINT8: obj.KindInt8,
+ TUINT8: obj.KindUint8,
+ TINT16: obj.KindInt16,
+ TUINT16: obj.KindUint16,
+ TINT32: obj.KindInt32,
+ TUINT32: obj.KindUint32,
+ TINT64: obj.KindInt64,
+ TUINT64: obj.KindUint64,
+ TUINTPTR: obj.KindUintptr,
+ TFLOAT32: obj.KindFloat32,
+ TFLOAT64: obj.KindFloat64,
+ TBOOL: obj.KindBool,
+ TSTRING: obj.KindString,
+ TPTR32: obj.KindPtr,
+ TPTR64: obj.KindPtr,
+ TSTRUCT: obj.KindStruct,
+ TINTER: obj.KindInterface,
+ TCHAN: obj.KindChan,
+ TMAP: obj.KindMap,
+ TARRAY: obj.KindArray,
+ TFUNC: obj.KindFunc,
+ TCOMPLEX64: obj.KindComplex64,
+ TCOMPLEX128: obj.KindComplex128,
+ TUNSAFEPTR: obj.KindUnsafePointer,
+}
+
+func haspointers(t *Type) bool {
+ var t1 *Type
+ var ret int
+
+ if t.Haspointers != 0 {
+ return t.Haspointers-1 != 0
+ }
+
+ switch t.Etype {
+ case TINT,
+ TUINT,
+ TINT8,
+ TUINT8,
+ TINT16,
+ TUINT16,
+ TINT32,
+ TUINT32,
+ TINT64,
+ TUINT64,
+ TUINTPTR,
+ TFLOAT32,
+ TFLOAT64,
+ TCOMPLEX64,
+ TCOMPLEX128,
+ TBOOL:
+ ret = 0
+
+ case TARRAY:
+ if t.Bound < 0 { // slice
+ ret = 1
+ break
+ }
+
+ if t.Bound == 0 { // empty array
+ ret = 0
+ break
+ }
+
+ ret = bool2int(haspointers(t.Type))
+
+ case TSTRUCT:
+ ret = 0
+ for t1 = t.Type; t1 != nil; t1 = t1.Down {
+ if haspointers(t1.Type) {
+ ret = 1
+ break
+ }
+ }
+
+ case TSTRING,
+ TPTR32,
+ TPTR64,
+ TUNSAFEPTR,
+ TINTER,
+ TCHAN,
+ TMAP,
+ TFUNC:
+ fallthrough
+ default:
+ ret = 1
+ }
+
+ t.Haspointers = uint8(1 + ret)
+ return ret != 0
+}
+
+/*
+ * commonType
+ * ../../runtime/type.go:/commonType
+ */
+
+var dcommontype_algarray *Sym
+
+func dcommontype(s *Sym, ot int, t *Type) int {
+ var i int
+ var alg int
+ var sizeofAlg int
+ var gcprog int
+ var sptr *Sym
+ var algsym *Sym
+ var zero *Sym
+ var gcprog0 *Sym
+ var gcprog1 *Sym
+ var sbits *Sym
+ var gcmask [16]uint8
+ var x1 uint64
+ var x2 uint64
+ var p string
+
+ if ot != 0 {
+ Fatal("dcommontype %d", ot)
+ }
+
+ sizeofAlg = 2 * Widthptr
+ if dcommontype_algarray == nil {
+ dcommontype_algarray = Pkglookup("algarray", Runtimepkg)
+ }
+ dowidth(t)
+ alg = algtype(t)
+ algsym = nil
+ if alg < 0 || alg == AMEM {
+ algsym = dalgsym(t)
+ }
+
+ if t.Sym != nil && !(Isptr[t.Etype] != 0) {
+ sptr = dtypesym(Ptrto(t))
+ } else {
+ sptr = weaktypesym(Ptrto(t))
+ }
+
+ // All (non-reflect-allocated) Types share the same zero object.
+ // Each place in the compiler where a pointer to the zero object
+ // might be returned by a runtime call (map access return value,
+ // 2-arg type cast) declares the size of the zerovalue it needs.
+ // The linker magically takes the max of all the sizes.
+ zero = Pkglookup("zerovalue", Runtimepkg)
+
+ // We use size 0 here so we get the pointer to the zero value,
+ // but don't allocate space for the zero value unless we need it.
+ // TODO: how do we get this symbol into bss? We really want
+ // a read-only bss, but I don't think such a thing exists.
+
+ // ../../pkg/reflect/type.go:/^type.commonType
+ // actual type structure
+ // type commonType struct {
+ // size uintptr
+ // hash uint32
+ // _ uint8
+ // align uint8
+ // fieldAlign uint8
+ // kind uint8
+ // alg unsafe.Pointer
+ // gc unsafe.Pointer
+ // string *string
+ // *extraType
+ // ptrToThis *Type
+ // zero unsafe.Pointer
+ // }
+ ot = duintptr(s, ot, uint64(t.Width))
+
+ ot = duint32(s, ot, typehash(t))
+ ot = duint8(s, ot, 0) // unused
+
+ // runtime (and common sense) expects alignment to be a power of two.
+ i = int(t.Align)
+
+ if i == 0 {
+ i = 1
+ }
+ if i&(i-1) != 0 {
+ Fatal("invalid alignment %d for %v", t.Align, Tconv(t, 0))
+ }
+ ot = duint8(s, ot, t.Align) // align
+ ot = duint8(s, ot, t.Align) // fieldAlign
+
+ gcprog = usegcprog(t)
+
+ i = kinds[t.Etype]
+ if t.Etype == TARRAY && t.Bound < 0 {
+ i = obj.KindSlice
+ }
+ if !haspointers(t) {
+ i |= obj.KindNoPointers
+ }
+ if isdirectiface(t) != 0 {
+ i |= obj.KindDirectIface
+ }
+ if gcprog != 0 {
+ i |= obj.KindGCProg
+ }
+ ot = duint8(s, ot, uint8(i)) // kind
+ if algsym == nil {
+ ot = dsymptr(s, ot, dcommontype_algarray, alg*sizeofAlg)
+ } else {
+ ot = dsymptr(s, ot, algsym, 0)
+ }
+
+ // gc
+ if gcprog != 0 {
+ gengcprog(t, &gcprog0, &gcprog1)
+ if gcprog0 != nil {
+ ot = dsymptr(s, ot, gcprog0, 0)
+ } else {
+ ot = duintptr(s, ot, 0)
+ }
+ ot = dsymptr(s, ot, gcprog1, 0)
+ } else {
+ gengcmask(t, gcmask[:])
+ x1 = 0
+ for i = 0; i < 8; i++ {
+ x1 = x1<<8 | uint64(gcmask[i])
+ }
+ if Widthptr == 4 {
+ p = fmt.Sprintf("gcbits.0x%016x", x1)
+ } else {
+ x2 = 0
+ for i = 0; i < 8; i++ {
+ x2 = x2<<8 | uint64(gcmask[i+8])
+ }
+ p = fmt.Sprintf("gcbits.0x%016x%016x", x1, x2)
+ }
+
+ sbits = Pkglookup(p, Runtimepkg)
+ if sbits.Flags&SymUniq == 0 {
+ sbits.Flags |= SymUniq
+ for i = 0; i < 2*Widthptr; i++ {
+ duint8(sbits, i, gcmask[i])
+ }
+ ggloblsym(sbits, 2*int32(Widthptr), obj.DUPOK|obj.RODATA)
+ }
+
+ ot = dsymptr(s, ot, sbits, 0)
+ ot = duintptr(s, ot, 0)
+ }
+
+ p = fmt.Sprintf("%v", Tconv(t, obj.FmtLeft|obj.FmtUnsigned))
+
+ //print("dcommontype: %s\n", p);
+ ot = dgostringptr(s, ot, p) // string
+
+ // skip pointer to extraType,
+ // which follows the rest of this type structure.
+ // caller will fill in if needed.
+ // otherwise linker will assume 0.
+ ot += Widthptr
+
+ ot = dsymptr(s, ot, sptr, 0) // ptrto type
+ ot = dsymptr(s, ot, zero, 0) // ptr to zero value
+ return ot
+}
+
+func typesym(t *Type) *Sym {
+ var p string
+ var s *Sym
+
+ p = fmt.Sprintf("%v", Tconv(t, obj.FmtLeft))
+ s = Pkglookup(p, typepkg)
+
+ //print("typesym: %s -> %+S\n", p, s);
+
+ return s
+}
+
+func tracksym(t *Type) *Sym {
+ var p string
+ var s *Sym
+
+ p = fmt.Sprintf("%v.%s", Tconv(t.Outer, obj.FmtLeft), t.Sym.Name)
+ s = Pkglookup(p, trackpkg)
+
+ return s
+}
+
+func typelinksym(t *Type) *Sym {
+ var p string
+ var s *Sym
+
+ // %-uT is what the generated Type's string field says.
+ // It uses (ambiguous) package names instead of import paths.
+ // %-T is the complete, unambiguous type name.
+ // We want the types to end up sorted by string field,
+ // so use that first in the name, and then add :%-T to
+ // disambiguate. The names are a little long but they are
+ // discarded by the linker and do not end up in the symbol
+ // table of the final binary.
+ p = fmt.Sprintf("%v/%v", Tconv(t, obj.FmtLeft|obj.FmtUnsigned), Tconv(t, obj.FmtLeft))
+
+ s = Pkglookup(p, typelinkpkg)
+
+ //print("typelinksym: %s -> %+S\n", p, s);
+
+ return s
+}
+
+func typesymprefix(prefix string, t *Type) *Sym {
+ var p string
+ var s *Sym
+
+ p = fmt.Sprintf("%s.%v", prefix, Tconv(t, obj.FmtLeft))
+ s = Pkglookup(p, typepkg)
+
+ //print("algsym: %s -> %+S\n", p, s);
+
+ return s
+}
+
+func typenamesym(t *Type) *Sym {
+ var s *Sym
+ var n *Node
+
+ if t == nil || (Isptr[t.Etype] != 0 && t.Type == nil) || isideal(t) != 0 {
+ Fatal("typename %v", Tconv(t, 0))
+ }
+ s = typesym(t)
+ if s.Def == nil {
+ n = Nod(ONAME, nil, nil)
+ n.Sym = s
+ n.Type = Types[TUINT8]
+ n.Addable = 1
+ n.Ullman = 1
+ n.Class = PEXTERN
+ n.Xoffset = 0
+ n.Typecheck = 1
+ s.Def = n
+
+ signatlist = list(signatlist, typenod(t))
+ }
+
+ return s.Def.Sym
+}
+
+func typename(t *Type) *Node {
+ var s *Sym
+ var n *Node
+
+ s = typenamesym(t)
+ n = Nod(OADDR, s.Def, nil)
+ n.Type = Ptrto(s.Def.Type)
+ n.Addable = 1
+ n.Ullman = 2
+ n.Typecheck = 1
+ return n
+}
+
+func weaktypesym(t *Type) *Sym {
+ var p string
+ var s *Sym
+
+ p = fmt.Sprintf("%v", Tconv(t, obj.FmtLeft))
+ s = Pkglookup(p, weaktypepkg)
+
+ //print("weaktypesym: %s -> %+S\n", p, s);
+
+ return s
+}
+
+/*
+ * Returns 1 if t has a reflexive equality operator.
+ * That is, if x==x for all x of type t.
+ */
+func isreflexive(t *Type) int {
+ var t1 *Type
+ switch t.Etype {
+ case TBOOL,
+ TINT,
+ TUINT,
+ TINT8,
+ TUINT8,
+ TINT16,
+ TUINT16,
+ TINT32,
+ TUINT32,
+ TINT64,
+ TUINT64,
+ TUINTPTR,
+ TPTR32,
+ TPTR64,
+ TUNSAFEPTR,
+ TSTRING,
+ TCHAN:
+ return 1
+
+ case TFLOAT32,
+ TFLOAT64,
+ TCOMPLEX64,
+ TCOMPLEX128,
+ TINTER:
+ return 0
+
+ case TARRAY:
+ if Isslice(t) != 0 {
+ Fatal("slice can't be a map key: %v", Tconv(t, 0))
+ }
+ return isreflexive(t.Type)
+
+ case TSTRUCT:
+ for t1 = t.Type; t1 != nil; t1 = t1.Down {
+ if !(isreflexive(t1.Type) != 0) {
+ return 0
+ }
+ }
+
+ return 1
+
+ default:
+ Fatal("bad type for map key: %v", Tconv(t, 0))
+ return 0
+ }
+}
+
+func dtypesym(t *Type) *Sym {
+ var ot int
+ var xt int
+ var n int
+ var isddd int
+ var dupok int
+ var s *Sym
+ var s1 *Sym
+ var s2 *Sym
+ var s3 *Sym
+ var s4 *Sym
+ var slink *Sym
+ var a *Sig
+ var m *Sig
+ var t1 *Type
+ var tbase *Type
+ var t2 *Type
+
+ // Replace byte, rune aliases with real type.
+ // They've been separate internally to make error messages
+ // better, but we have to merge them in the reflect tables.
+ if t == bytetype || t == runetype {
+ t = Types[t.Etype]
+ }
+
+ if isideal(t) != 0 {
+ Fatal("dtypesym %v", Tconv(t, 0))
+ }
+
+ s = typesym(t)
+ if s.Flags&SymSiggen != 0 {
+ return s
+ }
+ s.Flags |= SymSiggen
+
+ // special case (look for runtime below):
+ // when compiling package runtime,
+ // emit the type structures for int, float, etc.
+ tbase = t
+
+ if Isptr[t.Etype] != 0 && t.Sym == nil && t.Type.Sym != nil {
+ tbase = t.Type
+ }
+ dupok = 0
+ if tbase.Sym == nil {
+ dupok = obj.DUPOK
+ }
+
+ if compiling_runtime != 0 && (tbase == Types[tbase.Etype] || tbase == bytetype || tbase == runetype || tbase == errortype) { // int, float, etc
+ goto ok
+ }
+
+ // named types from other files are defined only by those files
+ if tbase.Sym != nil && !(tbase.Local != 0) {
+ return s
+ }
+ if isforw[tbase.Etype] != 0 {
+ return s
+ }
+
+ok:
+ ot = 0
+ xt = 0
+ switch t.Etype {
+ default:
+ ot = dcommontype(s, ot, t)
+ xt = ot - 3*Widthptr
+
+ case TARRAY:
+ if t.Bound >= 0 {
+ // ../../runtime/type.go:/ArrayType
+ s1 = dtypesym(t.Type)
+
+ t2 = typ(TARRAY)
+ t2.Type = t.Type
+ t2.Bound = -1 // slice
+ s2 = dtypesym(t2)
+ ot = dcommontype(s, ot, t)
+ xt = ot - 3*Widthptr
+ ot = dsymptr(s, ot, s1, 0)
+ ot = dsymptr(s, ot, s2, 0)
+ ot = duintptr(s, ot, uint64(t.Bound))
+ } else {
+ // ../../runtime/type.go:/SliceType
+ s1 = dtypesym(t.Type)
+
+ ot = dcommontype(s, ot, t)
+ xt = ot - 3*Widthptr
+ ot = dsymptr(s, ot, s1, 0)
+ }
+
+ // ../../runtime/type.go:/ChanType
+ case TCHAN:
+ s1 = dtypesym(t.Type)
+
+ ot = dcommontype(s, ot, t)
+ xt = ot - 3*Widthptr
+ ot = dsymptr(s, ot, s1, 0)
+ ot = duintptr(s, ot, uint64(t.Chan))
+
+ case TFUNC:
+ for t1 = getthisx(t).Type; t1 != nil; t1 = t1.Down {
+ dtypesym(t1.Type)
+ }
+ isddd = 0
+ for t1 = getinargx(t).Type; t1 != nil; t1 = t1.Down {
+ isddd = int(t1.Isddd)
+ dtypesym(t1.Type)
+ }
+
+ for t1 = getoutargx(t).Type; t1 != nil; t1 = t1.Down {
+ dtypesym(t1.Type)
+ }
+
+ ot = dcommontype(s, ot, t)
+ xt = ot - 3*Widthptr
+ ot = duint8(s, ot, uint8(isddd))
+
+ // two slice headers: in and out.
+ ot = int(Rnd(int64(ot), int64(Widthptr)))
+
+ ot = dsymptr(s, ot, s, ot+2*(Widthptr+2*Widthint))
+ n = t.Thistuple + t.Intuple
+ ot = duintxx(s, ot, uint64(n), Widthint)
+ ot = duintxx(s, ot, uint64(n), Widthint)
+ ot = dsymptr(s, ot, s, ot+1*(Widthptr+2*Widthint)+n*Widthptr)
+ ot = duintxx(s, ot, uint64(t.Outtuple), Widthint)
+ ot = duintxx(s, ot, uint64(t.Outtuple), Widthint)
+
+ // slice data
+ for t1 = getthisx(t).Type; t1 != nil; (func() { t1 = t1.Down; n++ })() {
+ ot = dsymptr(s, ot, dtypesym(t1.Type), 0)
+ }
+ for t1 = getinargx(t).Type; t1 != nil; (func() { t1 = t1.Down; n++ })() {
+ ot = dsymptr(s, ot, dtypesym(t1.Type), 0)
+ }
+ for t1 = getoutargx(t).Type; t1 != nil; (func() { t1 = t1.Down; n++ })() {
+ ot = dsymptr(s, ot, dtypesym(t1.Type), 0)
+ }
+
+ case TINTER:
+ m = imethods(t)
+ n = 0
+ for a = m; a != nil; a = a.link {
+ dtypesym(a.type_)
+ n++
+ }
+
+ // ../../runtime/type.go:/InterfaceType
+ ot = dcommontype(s, ot, t)
+
+ xt = ot - 3*Widthptr
+ ot = dsymptr(s, ot, s, ot+Widthptr+2*Widthint)
+ ot = duintxx(s, ot, uint64(n), Widthint)
+ ot = duintxx(s, ot, uint64(n), Widthint)
+ for a = m; a != nil; a = a.link {
+ // ../../runtime/type.go:/imethod
+ ot = dgostringptr(s, ot, a.name)
+
+ ot = dgopkgpath(s, ot, a.pkg)
+ ot = dsymptr(s, ot, dtypesym(a.type_), 0)
+ }
+
+ // ../../runtime/type.go:/MapType
+ case TMAP:
+ s1 = dtypesym(t.Down)
+
+ s2 = dtypesym(t.Type)
+ s3 = dtypesym(mapbucket(t))
+ s4 = dtypesym(hmap(t))
+ ot = dcommontype(s, ot, t)
+ xt = ot - 3*Widthptr
+ ot = dsymptr(s, ot, s1, 0)
+ ot = dsymptr(s, ot, s2, 0)
+ ot = dsymptr(s, ot, s3, 0)
+ ot = dsymptr(s, ot, s4, 0)
+ if t.Down.Width > MAXKEYSIZE {
+ ot = duint8(s, ot, uint8(Widthptr))
+ ot = duint8(s, ot, 1) // indirect
+ } else {
+ ot = duint8(s, ot, uint8(t.Down.Width))
+ ot = duint8(s, ot, 0) // not indirect
+ }
+
+ if t.Type.Width > MAXVALSIZE {
+ ot = duint8(s, ot, uint8(Widthptr))
+ ot = duint8(s, ot, 1) // indirect
+ } else {
+ ot = duint8(s, ot, uint8(t.Type.Width))
+ ot = duint8(s, ot, 0) // not indirect
+ }
+
+ ot = duint16(s, ot, uint16(mapbucket(t).Width))
+ ot = duint8(s, ot, uint8(isreflexive(t.Down)))
+
+ case TPTR32,
+ TPTR64:
+ if t.Type.Etype == TANY {
+ // ../../runtime/type.go:/UnsafePointerType
+ ot = dcommontype(s, ot, t)
+
+ break
+ }
+
+ // ../../runtime/type.go:/PtrType
+ s1 = dtypesym(t.Type)
+
+ ot = dcommontype(s, ot, t)
+ xt = ot - 3*Widthptr
+ ot = dsymptr(s, ot, s1, 0)
+
+ // ../../runtime/type.go:/StructType
+ // for security, only the exported fields.
+ case TSTRUCT:
+ n = 0
+
+ for t1 = t.Type; t1 != nil; t1 = t1.Down {
+ dtypesym(t1.Type)
+ n++
+ }
+
+ ot = dcommontype(s, ot, t)
+ xt = ot - 3*Widthptr
+ ot = dsymptr(s, ot, s, ot+Widthptr+2*Widthint)
+ ot = duintxx(s, ot, uint64(n), Widthint)
+ ot = duintxx(s, ot, uint64(n), Widthint)
+ for t1 = t.Type; t1 != nil; t1 = t1.Down {
+ // ../../runtime/type.go:/structField
+ if t1.Sym != nil && !(t1.Embedded != 0) {
+ ot = dgostringptr(s, ot, t1.Sym.Name)
+ if exportname(t1.Sym.Name) {
+ ot = dgostringptr(s, ot, "")
+ } else {
+ ot = dgopkgpath(s, ot, t1.Sym.Pkg)
+ }
+ } else {
+ ot = dgostringptr(s, ot, "")
+ if t1.Type.Sym != nil && t1.Type.Sym.Pkg == builtinpkg {
+ ot = dgopkgpath(s, ot, localpkg)
+ } else {
+ ot = dgostringptr(s, ot, "")
+ }
+ }
+
+ ot = dsymptr(s, ot, dtypesym(t1.Type), 0)
+ ot = dgostrlitptr(s, ot, t1.Note)
+ ot = duintptr(s, ot, uint64(t1.Width)) // field offset
+ }
+ }
+
+ ot = dextratype(s, ot, t, xt)
+ ggloblsym(s, int32(ot), int8(dupok|obj.RODATA))
+
+ // generate typelink.foo pointing at s = type.foo.
+ // The linker will leave a table of all the typelinks for
+ // types in the binary, so reflect can find them.
+ // We only need the link for unnamed composites that
+ // we want be able to find.
+ if t.Sym == nil {
+ switch t.Etype {
+ case TARRAY,
+ TCHAN,
+ TMAP:
+ slink = typelinksym(t)
+ dsymptr(slink, 0, s, 0)
+ ggloblsym(slink, int32(Widthptr), int8(dupok|obj.RODATA))
+ }
+ }
+
+ return s
+}
+
+func dumptypestructs() {
+ var i int
+ var l *NodeList
+ var n *Node
+ var t *Type
+ var p *Pkg
+
+ // copy types from externdcl list to signatlist
+ for l = externdcl; l != nil; l = l.Next {
+ n = l.N
+ if n.Op != OTYPE {
+ continue
+ }
+ signatlist = list(signatlist, n)
+ }
+
+ // process signatlist
+ for l = signatlist; l != nil; l = l.Next {
+ n = l.N
+ if n.Op != OTYPE {
+ continue
+ }
+ t = n.Type
+ dtypesym(t)
+ if t.Sym != nil {
+ dtypesym(Ptrto(t))
+ }
+ }
+
+ // generate import strings for imported packages
+ for i = 0; i < len(phash); i++ {
+ for p = phash[i]; p != nil; p = p.Link {
+ if p.Direct != 0 {
+ dimportpath(p)
+ }
+ }
+ }
+
+ // do basic types if compiling package runtime.
+ // they have to be in at least one package,
+ // and runtime is always loaded implicitly,
+ // so this is as good as any.
+ // another possible choice would be package main,
+ // but using runtime means fewer copies in .6 files.
+ if compiling_runtime != 0 {
+ for i = 1; i <= TBOOL; i++ {
+ dtypesym(Ptrto(Types[i]))
+ }
+ dtypesym(Ptrto(Types[TSTRING]))
+ dtypesym(Ptrto(Types[TUNSAFEPTR]))
+
+ // emit type structs for error and func(error) string.
+ // The latter is the type of an auto-generated wrapper.
+ dtypesym(Ptrto(errortype))
+
+ dtypesym(functype(nil, list1(Nod(ODCLFIELD, nil, typenod(errortype))), list1(Nod(ODCLFIELD, nil, typenod(Types[TSTRING])))))
+
+ // add paths for runtime and main, which 6l imports implicitly.
+ dimportpath(Runtimepkg)
+
+ if flag_race != 0 {
+ dimportpath(racepkg)
+ }
+ dimportpath(mkpkg(newstrlit("main")))
+ }
+}
+
+func dalgsym(t *Type) *Sym {
+ var ot int
+ var s *Sym
+ var hash *Sym
+ var hashfunc *Sym
+ var eq *Sym
+ var eqfunc *Sym
+ var p string
+
+ // dalgsym is only called for a type that needs an algorithm table,
+ // which implies that the type is comparable (or else it would use ANOEQ).
+
+ if algtype(t) == AMEM {
+ // we use one algorithm table for all AMEM types of a given size
+ p = fmt.Sprintf(".alg%d", t.Width)
+
+ s = Pkglookup(p, typepkg)
+
+ if s.Flags&SymAlgGen != 0 {
+ return s
+ }
+ s.Flags |= SymAlgGen
+
+ // make hash closure
+ p = fmt.Sprintf(".hashfunc%d", t.Width)
+
+ hashfunc = Pkglookup(p, typepkg)
+
+ ot = 0
+ ot = dsymptr(hashfunc, ot, Pkglookup("memhash_varlen", Runtimepkg), 0)
+ ot = duintxx(hashfunc, ot, uint64(t.Width), Widthptr) // size encoded in closure
+ ggloblsym(hashfunc, int32(ot), obj.DUPOK|obj.RODATA)
+
+ // make equality closure
+ p = fmt.Sprintf(".eqfunc%d", t.Width)
+
+ eqfunc = Pkglookup(p, typepkg)
+
+ ot = 0
+ ot = dsymptr(eqfunc, ot, Pkglookup("memequal_varlen", Runtimepkg), 0)
+ ot = duintxx(eqfunc, ot, uint64(t.Width), Widthptr)
+ ggloblsym(eqfunc, int32(ot), obj.DUPOK|obj.RODATA)
+ } else {
+ // generate an alg table specific to this type
+ s = typesymprefix(".alg", t)
+
+ hash = typesymprefix(".hash", t)
+ eq = typesymprefix(".eq", t)
+ hashfunc = typesymprefix(".hashfunc", t)
+ eqfunc = typesymprefix(".eqfunc", t)
+
+ genhash(hash, t)
+ geneq(eq, t)
+
+ // make Go funcs (closures) for calling hash and equal from Go
+ dsymptr(hashfunc, 0, hash, 0)
+
+ ggloblsym(hashfunc, int32(Widthptr), obj.DUPOK|obj.RODATA)
+ dsymptr(eqfunc, 0, eq, 0)
+ ggloblsym(eqfunc, int32(Widthptr), obj.DUPOK|obj.RODATA)
+ }
+
+ // ../../runtime/alg.go:/typeAlg
+ ot = 0
+
+ ot = dsymptr(s, ot, hashfunc, 0)
+ ot = dsymptr(s, ot, eqfunc, 0)
+ ggloblsym(s, int32(ot), obj.DUPOK|obj.RODATA)
+ return s
+}
+
+func usegcprog(t *Type) int {
+ var size int64
+ var nptr int64
+
+ if !haspointers(t) {
+ return 0
+ }
+ if t.Width == BADWIDTH {
+ dowidth(t)
+ }
+
+ // Calculate size of the unrolled GC mask.
+ nptr = (t.Width + int64(Widthptr) - 1) / int64(Widthptr)
+
+ size = nptr
+ if size%2 != 0 {
+ size *= 2 // repeated
+ }
+ size = size * obj.GcBits / 8 // 4 bits per word
+
+ // Decide whether to use unrolled GC mask or GC program.
+ // We could use a more elaborate condition, but this seems to work well in practice.
+ // For small objects GC program can't give significant reduction.
+ // While large objects usually contain arrays; and even if it don't
+ // the program uses 2-bits per word while mask uses 4-bits per word,
+ // so the program is still smaller.
+ return bool2int(size > int64(2*Widthptr))
+}
+
+// Generates sparse GC bitmask (4 bits per word).
+func gengcmask(t *Type, gcmask []byte) {
+ var vec *Bvec
+ var xoffset int64
+ var nptr int64
+ var i int64
+ var j int64
+ var half int
+ var bits uint8
+ var pos []byte
+
+ for i = 0; i < 16; i++ {
+ gcmask[i] = 0
+ }
+ if !haspointers(t) {
+ return
+ }
+
+ // Generate compact mask as stacks use.
+ xoffset = 0
+
+ vec = bvalloc(2 * int32(Widthptr) * 8)
+ twobitwalktype1(t, &xoffset, vec)
+
+ // Unfold the mask for the GC bitmap format:
+ // 4 bits per word, 2 high bits encode pointer info.
+ pos = gcmask
+
+ nptr = (t.Width + int64(Widthptr) - 1) / int64(Widthptr)
+ half = 0
+
+ // If number of words is odd, repeat the mask.
+ // This makes simpler handling of arrays in runtime.
+ for j = 0; j <= (nptr % 2); j++ {
+ for i = 0; i < nptr; i++ {
+ bits = uint8(bvget(vec, int32(i*obj.BitsPerPointer)) | bvget(vec, int32(i*obj.BitsPerPointer+1))<<1)
+
+ // Some fake types (e.g. Hmap) has missing fileds.
+ // twobitwalktype1 generates BitsDead for that holes,
+ // replace BitsDead with BitsScalar.
+ if bits == obj.BitsDead {
+ bits = obj.BitsScalar
+ }
+ bits <<= 2
+ if half != 0 {
+ bits <<= 4
+ }
+ pos[0] |= byte(bits)
+ half = bool2int(!(half != 0))
+ if !(half != 0) {
+ pos = pos[1:]
+ }
+ }
+ }
+}
+
+// Helper object for generation of GC programs.
+type ProgGen struct {
+ s *Sym
+ datasize int32
+ data [256 / obj.PointersPerByte]uint8
+ ot int64
+}
+
+func proggeninit(g *ProgGen, s *Sym) {
+ g.s = s
+ g.datasize = 0
+ g.ot = 0
+ g.data = [256 / obj.PointersPerByte]uint8{}
+}
+
+func proggenemit(g *ProgGen, v uint8) {
+ g.ot = int64(duint8(g.s, int(g.ot), v))
+}
+
+// Emits insData block from g->data.
+func proggendataflush(g *ProgGen) {
+ var i int32
+ var s int32
+
+ if g.datasize == 0 {
+ return
+ }
+ proggenemit(g, obj.InsData)
+ proggenemit(g, uint8(g.datasize))
+ s = (g.datasize + obj.PointersPerByte - 1) / obj.PointersPerByte
+ for i = 0; i < s; i++ {
+ proggenemit(g, g.data[i])
+ }
+ g.datasize = 0
+ g.data = [256 / obj.PointersPerByte]uint8{}
+}
+
+func proggendata(g *ProgGen, d uint8) {
+ g.data[g.datasize/obj.PointersPerByte] |= d << uint((g.datasize%obj.PointersPerByte)*obj.BitsPerPointer)
+ g.datasize++
+ if g.datasize == 255 {
+ proggendataflush(g)
+ }
+}
+
+// Skip v bytes due to alignment, etc.
+func proggenskip(g *ProgGen, off int64, v int64) {
+ var i int64
+
+ for i = off; i < off+v; i++ {
+ if (i % int64(Widthptr)) == 0 {
+ proggendata(g, obj.BitsScalar)
+ }
+ }
+}
+
+// Emit insArray instruction.
+func proggenarray(g *ProgGen, len int64) {
+ var i int32
+
+ proggendataflush(g)
+ proggenemit(g, obj.InsArray)
+ for i = 0; i < int32(Widthptr); (func() { i++; len >>= 8 })() {
+ proggenemit(g, uint8(len))
+ }
+}
+
+func proggenarrayend(g *ProgGen) {
+ proggendataflush(g)
+ proggenemit(g, obj.InsArrayEnd)
+}
+
+func proggenfini(g *ProgGen) int64 {
+ proggendataflush(g)
+ proggenemit(g, obj.InsEnd)
+ return g.ot
+}
+
+// Generates GC program for large types.
+func gengcprog(t *Type, pgc0 **Sym, pgc1 **Sym) {
+ var gc0 *Sym
+ var gc1 *Sym
+ var nptr int64
+ var size int64
+ var ot int64
+ var xoffset int64
+ var g ProgGen
+
+ nptr = (t.Width + int64(Widthptr) - 1) / int64(Widthptr)
+ size = nptr
+ if size%2 != 0 {
+ size *= 2 // repeated twice
+ }
+ size = size * obj.PointersPerByte / 8 // 4 bits per word
+ size++ // unroll flag in the beginning, used by runtime (see runtime.markallocated)
+
+ // emity space in BSS for unrolled program
+ *pgc0 = nil
+
+ // Don't generate it if it's too large, runtime will unroll directly into GC bitmap.
+ if size <= obj.MaxGCMask {
+ gc0 = typesymprefix(".gc", t)
+ ggloblsym(gc0, int32(size), obj.DUPOK|obj.NOPTR)
+ *pgc0 = gc0
+ }
+
+ // program in RODATA
+ gc1 = typesymprefix(".gcprog", t)
+
+ proggeninit(&g, gc1)
+ xoffset = 0
+ gengcprog1(&g, t, &xoffset)
+ ot = proggenfini(&g)
+ ggloblsym(gc1, int32(ot), obj.DUPOK|obj.RODATA)
+ *pgc1 = gc1
+}
+
+// Recursively walks type t and writes GC program into g.
+func gengcprog1(g *ProgGen, t *Type, xoffset *int64) {
+ var fieldoffset int64
+ var i int64
+ var o int64
+ var n int64
+ var t1 *Type
+
+ switch t.Etype {
+ case TINT8,
+ TUINT8,
+ TINT16,
+ TUINT16,
+ TINT32,
+ TUINT32,
+ TINT64,
+ TUINT64,
+ TINT,
+ TUINT,
+ TUINTPTR,
+ TBOOL,
+ TFLOAT32,
+ TFLOAT64,
+ TCOMPLEX64,
+ TCOMPLEX128:
+ proggenskip(g, *xoffset, t.Width)
+ *xoffset += t.Width
+
+ case TPTR32,
+ TPTR64,
+ TUNSAFEPTR,
+ TFUNC,
+ TCHAN,
+ TMAP:
+ proggendata(g, obj.BitsPointer)
+ *xoffset += t.Width
+
+ case TSTRING:
+ proggendata(g, obj.BitsPointer)
+ proggendata(g, obj.BitsScalar)
+ *xoffset += t.Width
+
+ // Assuming IfacePointerOnly=1.
+ case TINTER:
+ proggendata(g, obj.BitsPointer)
+
+ proggendata(g, obj.BitsPointer)
+ *xoffset += t.Width
+
+ case TARRAY:
+ if Isslice(t) != 0 {
+ proggendata(g, obj.BitsPointer)
+ proggendata(g, obj.BitsScalar)
+ proggendata(g, obj.BitsScalar)
+ } else {
+ t1 = t.Type
+ if t1.Width == 0 {
+ }
+ // ignore
+ if t.Bound <= 1 || t.Bound*t1.Width < int64(32*Widthptr) {
+ for i = 0; i < t.Bound; i++ {
+ gengcprog1(g, t1, xoffset)
+ }
+ } else if !haspointers(t1) {
+ n = t.Width
+ n -= -*xoffset & (int64(Widthptr) - 1) // skip to next ptr boundary
+ proggenarray(g, (n+int64(Widthptr)-1)/int64(Widthptr))
+ proggendata(g, obj.BitsScalar)
+ proggenarrayend(g)
+ *xoffset -= (n+int64(Widthptr)-1)/int64(Widthptr)*int64(Widthptr) - t.Width
+ } else {
+ proggenarray(g, t.Bound)
+ gengcprog1(g, t1, xoffset)
+ *xoffset += (t.Bound - 1) * t1.Width
+ proggenarrayend(g)
+ }
+ }
+
+ case TSTRUCT:
+ o = 0
+ for t1 = t.Type; t1 != nil; t1 = t1.Down {
+ fieldoffset = t1.Width
+ proggenskip(g, *xoffset, fieldoffset-o)
+ *xoffset += fieldoffset - o
+ gengcprog1(g, t1.Type, xoffset)
+ o = fieldoffset + t1.Type.Width
+ }
+
+ proggenskip(g, *xoffset, t.Width-o)
+ *xoffset += t.Width - o
+
+ default:
+ Fatal("gengcprog1: unexpected type, %v", Tconv(t, 0))
+ }
+}
diff --git a/src/cmd/internal/gc/reg.go b/src/cmd/internal/gc/reg.go
new file mode 100644
index 0000000..4cc9286
--- /dev/null
+++ b/src/cmd/internal/gc/reg.go
@@ -0,0 +1,1401 @@
+// Derived from Inferno utils/6c/reg.c
+// http://code.google.com/p/inferno-os/source/browse/utils/6c/reg.c
+//
+// Copyright © 1994-1999 Lucent Technologies Inc. All rights reserved.
+// Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+// Portions Copyright © 1997-1999 Vita Nuova Limited
+// Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
+// Portions Copyright © 2004,2006 Bruce Ellis
+// Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+// Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
+// Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package gc
+
+import (
+ "cmd/internal/obj"
+ "fmt"
+ "sort"
+)
+
+var firstf *Flow
+
+var first int = 1
+
+type rcmp []Rgn
+
+func (x rcmp) Len() int {
+ return len(x)
+}
+
+func (x rcmp) Swap(i, j int) {
+ x[i], x[j] = x[j], x[i]
+}
+
+func (x rcmp) Less(i, j int) bool {
+ var p1 *Rgn
+ var p2 *Rgn
+
+ p1 = &x[i]
+ p2 = &x[j]
+ if p1.cost != p2.cost {
+ return int(p2.cost)-int(p1.cost) < 0
+ }
+ if p1.varno != p2.varno {
+ return int(p2.varno)-int(p1.varno) < 0
+ }
+ if p1.enter != p2.enter {
+ return int(p2.enter.Id-p1.enter.Id) < 0
+ }
+ return false
+}
+
+func setaddrs(bit Bits) {
+ var i int
+ var n int
+ var v *Var
+ var node *Node
+
+ for bany(&bit) != 0 {
+ // convert each bit to a variable
+ i = bnum(bit)
+
+ node = var_[i].node
+ n = int(var_[i].name)
+ biclr(&bit, uint(i))
+
+ // disable all pieces of that variable
+ for i = 0; i < nvar; i++ {
+ v = &var_[i:][0]
+ if v.node == node && int(v.name) == n {
+ v.addr = 2
+ }
+ }
+ }
+}
+
+var regnodes [64]*Node
+
+func walkvardef(n *Node, f *Flow, active int) {
+ var f1 *Flow
+ var f2 *Flow
+ var bn int
+ var v *Var
+
+ for f1 = f; f1 != nil; f1 = f1.S1 {
+ if f1.Active == int32(active) {
+ break
+ }
+ f1.Active = int32(active)
+ if f1.Prog.As == obj.AVARKILL && f1.Prog.To.Node == n {
+ break
+ }
+ for v, _ = n.Opt.(*Var); v != nil; v = v.nextinnode {
+ bn = v.id
+ biset(&(f1.Data.(*Reg)).act, uint(bn))
+ }
+
+ if f1.Prog.As == obj.ACALL {
+ break
+ }
+ }
+
+ for f2 = f; f2 != f1; f2 = f2.S1 {
+ if f2.S2 != nil {
+ walkvardef(n, f2.S2, active)
+ }
+ }
+}
+
+/*
+ * add mov b,rn
+ * just after r
+ */
+func addmove(r *Flow, bn int, rn int, f int) {
+ var p *obj.Prog
+ var p1 *obj.Prog
+ var a *obj.Addr
+ var v *Var
+
+ p1 = Ctxt.NewProg()
+ Clearp(p1)
+ p1.Pc = 9999
+
+ p = r.Prog
+ p1.Link = p.Link
+ p.Link = p1
+ p1.Lineno = p.Lineno
+
+ v = &var_[bn:][0]
+
+ a = &p1.To
+ a.Offset = v.offset
+ a.Etype = uint8(v.etype)
+ a.Type = obj.TYPE_MEM
+ a.Name = v.name
+ a.Node = v.node
+ a.Sym = Linksym(v.node.Sym)
+
+ /* NOTE(rsc): 9g did
+ if(a->etype == TARRAY)
+ a->type = TYPE_ADDR;
+ else if(a->sym == nil)
+ a->type = TYPE_CONST;
+ */
+ p1.As = int16(Thearch.Optoas(OAS, Types[uint8(v.etype)]))
+
+ // TODO(rsc): Remove special case here.
+ if (Thearch.Thechar == '9' || Thearch.Thechar == '5') && v.etype == TBOOL {
+ p1.As = int16(Thearch.Optoas(OAS, Types[TUINT8]))
+ }
+ p1.From.Type = obj.TYPE_REG
+ p1.From.Reg = int16(rn)
+ p1.From.Name = obj.NAME_NONE
+ if !(f != 0) {
+ p1.From = *a
+ *a = obj.Zprog.From
+ a.Type = obj.TYPE_REG
+ a.Reg = int16(rn)
+ }
+
+ if Debug['R'] != 0 && Debug['v'] != 0 {
+ fmt.Printf("%v ===add=== %v\n", p, p1)
+ }
+ Ostats.Nspill++
+}
+
+func overlap_reg(o1 int64, w1 int, o2 int64, w2 int) int {
+ var t1 int64
+ var t2 int64
+
+ t1 = o1 + int64(w1)
+ t2 = o2 + int64(w2)
+
+ if !(t1 > o2 && t2 > o1) {
+ return 0
+ }
+
+ return 1
+}
+
+func mkvar(f *Flow, a *obj.Addr) Bits {
+ var v *Var
+ var i int
+ var n int
+ var et int
+ var z int
+ var flag int
+ var w int64
+ var regu uint64
+ var o int64
+ var bit Bits
+ var node *Node
+ var r *Reg
+
+ /*
+ * mark registers used
+ */
+ if a.Type == obj.TYPE_NONE {
+ goto none
+ }
+
+ r = f.Data.(*Reg)
+ r.use1.b[0] |= Thearch.Doregbits(int(a.Index)) // TODO: Use RtoB
+
+ switch a.Type {
+ default:
+ regu = Thearch.Doregbits(int(a.Reg)) | Thearch.RtoB(int(a.Reg)) // TODO: Use RtoB
+ if regu == 0 {
+ goto none
+ }
+ bit = zbits
+ bit.b[0] = regu
+ return bit
+
+ // TODO(rsc): Remove special case here.
+ case obj.TYPE_ADDR:
+ if Thearch.Thechar == '9' || Thearch.Thechar == '5' {
+ goto memcase
+ }
+ a.Type = obj.TYPE_MEM
+ bit = mkvar(f, a)
+ setaddrs(bit)
+ a.Type = obj.TYPE_ADDR
+ Ostats.Naddr++
+ goto none
+
+ memcase:
+ fallthrough
+
+ case obj.TYPE_MEM:
+ if r != R {
+ r.use1.b[0] |= Thearch.RtoB(int(a.Reg))
+ }
+
+ /* NOTE: 5g did
+ if(r->f.prog->scond & (C_PBIT|C_WBIT))
+ r->set.b[0] |= RtoB(a->reg);
+ */
+ switch a.Name {
+ default:
+ goto none
+
+ case obj.NAME_EXTERN,
+ obj.NAME_STATIC,
+ obj.NAME_PARAM,
+ obj.NAME_AUTO:
+ n = int(a.Name)
+ }
+ }
+
+ node, _ = a.Node.(*Node)
+ if node == nil || node.Op != ONAME || node.Orig == nil {
+ goto none
+ }
+ node = node.Orig
+ if node.Orig != node {
+ Fatal("%v: bad node", Ctxt.Dconv(a))
+ }
+ if node.Sym == nil || node.Sym.Name[0] == '.' {
+ goto none
+ }
+ et = int(a.Etype)
+ o = a.Offset
+ w = a.Width
+ if w < 0 {
+ Fatal("bad width %d for %v", w, Ctxt.Dconv(a))
+ }
+
+ flag = 0
+ for i = 0; i < nvar; i++ {
+ v = &var_[i:][0]
+ if v.node == node && int(v.name) == n {
+ if v.offset == o {
+ if int(v.etype) == et {
+ if int64(v.width) == w {
+ // TODO(rsc): Remove special case for arm here.
+ if !(flag != 0) || Thearch.Thechar != '5' {
+ return blsh(uint(i))
+ }
+ }
+ }
+ }
+
+ // if they overlap, disable both
+ if overlap_reg(v.offset, v.width, o, int(w)) != 0 {
+ // print("disable overlap %s %d %d %d %d, %E != %E\n", s->name, v->offset, v->width, o, w, v->etype, et);
+ v.addr = 1
+
+ flag = 1
+ }
+ }
+ }
+
+ switch et {
+ case 0,
+ TFUNC:
+ goto none
+ }
+
+ if nvar >= NVAR {
+ if Debug['w'] > 1 && node != nil {
+ Fatal("variable not optimized: %v", Nconv(node, obj.FmtSharp))
+ }
+
+ // If we're not tracking a word in a variable, mark the rest as
+ // having its address taken, so that we keep the whole thing
+ // live at all calls. otherwise we might optimize away part of
+ // a variable but not all of it.
+ for i = 0; i < nvar; i++ {
+ v = &var_[i:][0]
+ if v.node == node {
+ v.addr = 1
+ }
+ }
+
+ goto none
+ }
+
+ i = nvar
+ nvar++
+ v = &var_[i:][0]
+ v.id = i
+ v.offset = o
+ v.name = int8(n)
+ v.etype = int8(et)
+ v.width = int(w)
+ v.addr = int8(flag) // funny punning
+ v.node = node
+
+ // node->opt is the head of a linked list
+ // of Vars within the given Node, so that
+ // we can start at a Var and find all the other
+ // Vars in the same Go variable.
+ v.nextinnode, _ = node.Opt.(*Var)
+
+ node.Opt = v
+
+ bit = blsh(uint(i))
+ if n == obj.NAME_EXTERN || n == obj.NAME_STATIC {
+ for z = 0; z < BITS; z++ {
+ externs.b[z] |= bit.b[z]
+ }
+ }
+ if n == obj.NAME_PARAM {
+ for z = 0; z < BITS; z++ {
+ params.b[z] |= bit.b[z]
+ }
+ }
+
+ if node.Class == PPARAM {
+ for z = 0; z < BITS; z++ {
+ ivar.b[z] |= bit.b[z]
+ }
+ }
+ if node.Class == PPARAMOUT {
+ for z = 0; z < BITS; z++ {
+ ovar.b[z] |= bit.b[z]
+ }
+ }
+
+ // Treat values with their address taken as live at calls,
+ // because the garbage collector's liveness analysis in ../gc/plive.c does.
+ // These must be consistent or else we will elide stores and the garbage
+ // collector will see uninitialized data.
+ // The typical case where our own analysis is out of sync is when the
+ // node appears to have its address taken but that code doesn't actually
+ // get generated and therefore doesn't show up as an address being
+ // taken when we analyze the instruction stream.
+ // One instance of this case is when a closure uses the same name as
+ // an outer variable for one of its own variables declared with :=.
+ // The parser flags the outer variable as possibly shared, and therefore
+ // sets addrtaken, even though it ends up not being actually shared.
+ // If we were better about _ elision, _ = &x would suffice too.
+ // The broader := in a closure problem is mentioned in a comment in
+ // closure.c:/^typecheckclosure and dcl.c:/^oldname.
+ if node.Addrtaken != 0 {
+ v.addr = 1
+ }
+
+ // Disable registerization for globals, because:
+ // (1) we might panic at any time and we want the recovery code
+ // to see the latest values (issue 1304).
+ // (2) we don't know what pointers might point at them and we want
+ // loads via those pointers to see updated values and vice versa (issue 7995).
+ //
+ // Disable registerization for results if using defer, because the deferred func
+ // might recover and return, causing the current values to be used.
+ if node.Class == PEXTERN || (Hasdefer != 0 && node.Class == PPARAMOUT) {
+ v.addr = 1
+ }
+
+ if Debug['R'] != 0 {
+ fmt.Printf("bit=%2d et=%v w=%d+%d %v %v flag=%d\n", i, Econv(int(et), 0), o, w, Nconv(node, obj.FmtSharp), Ctxt.Dconv(a), v.addr)
+ }
+ Ostats.Nvar++
+
+ return bit
+
+none:
+ return zbits
+}
+
+func prop(f *Flow, ref Bits, cal Bits) {
+ var f1 *Flow
+ var f2 *Flow
+ var r *Reg
+ var r1 *Reg
+ var z int
+ var i int
+ var v *Var
+ var v1 *Var
+
+ for f1 = f; f1 != nil; f1 = f1.P1 {
+ r1 = f1.Data.(*Reg)
+ for z = 0; z < BITS; z++ {
+ ref.b[z] |= r1.refahead.b[z]
+ if ref.b[z] != r1.refahead.b[z] {
+ r1.refahead.b[z] = ref.b[z]
+ change++
+ }
+
+ cal.b[z] |= r1.calahead.b[z]
+ if cal.b[z] != r1.calahead.b[z] {
+ r1.calahead.b[z] = cal.b[z]
+ change++
+ }
+ }
+
+ switch f1.Prog.As {
+ case obj.ACALL:
+ if Noreturn(f1.Prog) != 0 {
+ break
+ }
+
+ // Mark all input variables (ivar) as used, because that's what the
+ // liveness bitmaps say. The liveness bitmaps say that so that a
+ // panic will not show stale values in the parameter dump.
+ // Mark variables with a recent VARDEF (r1->act) as used,
+ // so that the optimizer flushes initializations to memory,
+ // so that if a garbage collection happens during this CALL,
+ // the collector will see initialized memory. Again this is to
+ // match what the liveness bitmaps say.
+ for z = 0; z < BITS; z++ {
+ cal.b[z] |= ref.b[z] | externs.b[z] | ivar.b[z] | r1.act.b[z]
+ ref.b[z] = 0
+ }
+
+ // cal.b is the current approximation of what's live across the call.
+ // Every bit in cal.b is a single stack word. For each such word,
+ // find all the other tracked stack words in the same Go variable
+ // (struct/slice/string/interface) and mark them live too.
+ // This is necessary because the liveness analysis for the garbage
+ // collector works at variable granularity, not at word granularity.
+ // It is fundamental for slice/string/interface: the garbage collector
+ // needs the whole value, not just some of the words, in order to
+ // interpret the other bits correctly. Specifically, slice needs a consistent
+ // ptr and cap, string needs a consistent ptr and len, and interface
+ // needs a consistent type word and data word.
+ for z = 0; z < BITS; z++ {
+ if cal.b[z] == 0 {
+ continue
+ }
+ for i = 0; i < 64; i++ {
+ if z*64+i >= nvar || (cal.b[z]>>uint(i))&1 == 0 {
+ continue
+ }
+ v = &var_[z*64+i:][0]
+ if v.node.Opt == nil { // v represents fixed register, not Go variable
+ continue
+ }
+
+ // v->node->opt is the head of a linked list of Vars
+ // corresponding to tracked words from the Go variable v->node.
+ // Walk the list and set all the bits.
+ // For a large struct this could end up being quadratic:
+ // after the first setting, the outer loop (for z, i) would see a 1 bit
+ // for all of the remaining words in the struct, and for each such
+ // word would go through and turn on all the bits again.
+ // To avoid the quadratic behavior, we only turn on the bits if
+ // v is the head of the list or if the head's bit is not yet turned on.
+ // This will set the bits at most twice, keeping the overall loop linear.
+ v1, _ = v.node.Opt.(*Var)
+
+ if v == v1 || !(btest(&cal, uint(v1.id)) != 0) {
+ for ; v1 != nil; v1 = v1.nextinnode {
+ biset(&cal, uint(v1.id))
+ }
+ }
+ }
+ }
+
+ case obj.ATEXT:
+ for z = 0; z < BITS; z++ {
+ cal.b[z] = 0
+ ref.b[z] = 0
+ }
+
+ case obj.ARET:
+ for z = 0; z < BITS; z++ {
+ cal.b[z] = externs.b[z] | ovar.b[z]
+ ref.b[z] = 0
+ }
+ }
+
+ for z = 0; z < BITS; z++ {
+ ref.b[z] = ref.b[z]&^r1.set.b[z] | r1.use1.b[z] | r1.use2.b[z]
+ cal.b[z] &^= (r1.set.b[z] | r1.use1.b[z] | r1.use2.b[z])
+ r1.refbehind.b[z] = ref.b[z]
+ r1.calbehind.b[z] = cal.b[z]
+ }
+
+ if f1.Active != 0 {
+ break
+ }
+ f1.Active = 1
+ }
+
+ for ; f != f1; f = f.P1 {
+ r = f.Data.(*Reg)
+ for f2 = f.P2; f2 != nil; f2 = f2.P2link {
+ prop(f2, r.refbehind, r.calbehind)
+ }
+ }
+}
+
+func synch(f *Flow, dif Bits) {
+ var f1 *Flow
+ var r1 *Reg
+ var z int
+
+ for f1 = f; f1 != nil; f1 = f1.S1 {
+ r1 = f1.Data.(*Reg)
+ for z = 0; z < BITS; z++ {
+ dif.b[z] = dif.b[z]&^(^r1.refbehind.b[z]&r1.refahead.b[z]) | r1.set.b[z] | r1.regdiff.b[z]
+ if dif.b[z] != r1.regdiff.b[z] {
+ r1.regdiff.b[z] = dif.b[z]
+ change++
+ }
+ }
+
+ if f1.Active != 0 {
+ break
+ }
+ f1.Active = 1
+ for z = 0; z < BITS; z++ {
+ dif.b[z] &^= (^r1.calbehind.b[z] & r1.calahead.b[z])
+ }
+ if f1.S2 != nil {
+ synch(f1.S2, dif)
+ }
+ }
+}
+
+func allreg(b uint64, r *Rgn) uint64 {
+ var v *Var
+ var i int
+
+ v = &var_[r.varno:][0]
+ r.regno = 0
+ switch v.etype {
+ default:
+ Fatal("unknown etype %d/%v", Bitno(b), Econv(int(v.etype), 0))
+
+ case TINT8,
+ TUINT8,
+ TINT16,
+ TUINT16,
+ TINT32,
+ TUINT32,
+ TINT64,
+ TUINT64,
+ TINT,
+ TUINT,
+ TUINTPTR,
+ TBOOL,
+ TPTR32,
+ TPTR64:
+ i = Thearch.BtoR(^b)
+ if i != 0 && r.cost > 0 {
+ r.regno = int16(i)
+ return Thearch.RtoB(i)
+ }
+
+ case TFLOAT32,
+ TFLOAT64:
+ i = Thearch.BtoF(^b)
+ if i != 0 && r.cost > 0 {
+ r.regno = int16(i)
+ return Thearch.FtoB(i)
+ }
+ }
+
+ return 0
+}
+
+func LOAD(r *Reg, z int) uint64 {
+ return ^r.refbehind.b[z] & r.refahead.b[z]
+}
+
+func STORE(r *Reg, z int) uint64 {
+ return ^r.calbehind.b[z] & r.calahead.b[z]
+}
+
+func paint1(f *Flow, bn int) {
+ var f1 *Flow
+ var r *Reg
+ var r1 *Reg
+ var z int
+ var bb uint64
+
+ z = bn / 64
+ bb = 1 << uint(bn%64)
+ r = f.Data.(*Reg)
+ if r.act.b[z]&bb != 0 {
+ return
+ }
+ for {
+ if !(r.refbehind.b[z]&bb != 0) {
+ break
+ }
+ f1 = f.P1
+ if f1 == nil {
+ break
+ }
+ r1 = f1.Data.(*Reg)
+ if !(r1.refahead.b[z]&bb != 0) {
+ break
+ }
+ if r1.act.b[z]&bb != 0 {
+ break
+ }
+ f = f1
+ r = r1
+ }
+
+ if LOAD(r, z)&^(r.set.b[z]&^(r.use1.b[z]|r.use2.b[z]))&bb != 0 {
+ change -= CLOAD * int(f.Loop)
+ }
+
+ for {
+ r.act.b[z] |= bb
+
+ if f.Prog.As != obj.ANOP { // don't give credit for NOPs
+ if r.use1.b[z]&bb != 0 {
+ change += CREF * int(f.Loop)
+ }
+ if (r.use2.b[z]|r.set.b[z])&bb != 0 {
+ change += CREF * int(f.Loop)
+ }
+ }
+
+ if STORE(r, z)&r.regdiff.b[z]&bb != 0 {
+ change -= CLOAD * int(f.Loop)
+ }
+
+ if r.refbehind.b[z]&bb != 0 {
+ for f1 = f.P2; f1 != nil; f1 = f1.P2link {
+ if (f1.Data.(*Reg)).refahead.b[z]&bb != 0 {
+ paint1(f1, bn)
+ }
+ }
+ }
+
+ if !(r.refahead.b[z]&bb != 0) {
+ break
+ }
+ f1 = f.S2
+ if f1 != nil {
+ if (f1.Data.(*Reg)).refbehind.b[z]&bb != 0 {
+ paint1(f1, bn)
+ }
+ }
+ f = f.S1
+ if f == nil {
+ break
+ }
+ r = f.Data.(*Reg)
+ if r.act.b[z]&bb != 0 {
+ break
+ }
+ if !(r.refbehind.b[z]&bb != 0) {
+ break
+ }
+ }
+}
+
+func paint2(f *Flow, bn int, depth int) uint64 {
+ var f1 *Flow
+ var r *Reg
+ var r1 *Reg
+ var z int
+ var bb uint64
+ var vreg uint64
+
+ z = bn / 64
+ bb = 1 << uint(bn%64)
+ vreg = regbits
+ r = f.Data.(*Reg)
+ if !(r.act.b[z]&bb != 0) {
+ return vreg
+ }
+ for {
+ if !(r.refbehind.b[z]&bb != 0) {
+ break
+ }
+ f1 = f.P1
+ if f1 == nil {
+ break
+ }
+ r1 = f1.Data.(*Reg)
+ if !(r1.refahead.b[z]&bb != 0) {
+ break
+ }
+ if !(r1.act.b[z]&bb != 0) {
+ break
+ }
+ f = f1
+ r = r1
+ }
+
+ for {
+ if Debug['R'] != 0 && Debug['v'] != 0 {
+ fmt.Printf(" paint2 %d %v\n", depth, f.Prog)
+ }
+
+ r.act.b[z] &^= bb
+
+ vreg |= r.regu
+
+ if r.refbehind.b[z]&bb != 0 {
+ for f1 = f.P2; f1 != nil; f1 = f1.P2link {
+ if (f1.Data.(*Reg)).refahead.b[z]&bb != 0 {
+ vreg |= paint2(f1, bn, depth+1)
+ }
+ }
+ }
+
+ if !(r.refahead.b[z]&bb != 0) {
+ break
+ }
+ f1 = f.S2
+ if f1 != nil {
+ if (f1.Data.(*Reg)).refbehind.b[z]&bb != 0 {
+ vreg |= paint2(f1, bn, depth+1)
+ }
+ }
+ f = f.S1
+ if f == nil {
+ break
+ }
+ r = f.Data.(*Reg)
+ if !(r.act.b[z]&bb != 0) {
+ break
+ }
+ if !(r.refbehind.b[z]&bb != 0) {
+ break
+ }
+ }
+
+ return vreg
+}
+
+func paint3(f *Flow, bn int, rb uint64, rn int) {
+ var f1 *Flow
+ var r *Reg
+ var r1 *Reg
+ var p *obj.Prog
+ var z int
+ var bb uint64
+
+ z = bn / 64
+ bb = 1 << uint(bn%64)
+ r = f.Data.(*Reg)
+ if r.act.b[z]&bb != 0 {
+ return
+ }
+ for {
+ if !(r.refbehind.b[z]&bb != 0) {
+ break
+ }
+ f1 = f.P1
+ if f1 == nil {
+ break
+ }
+ r1 = f1.Data.(*Reg)
+ if !(r1.refahead.b[z]&bb != 0) {
+ break
+ }
+ if r1.act.b[z]&bb != 0 {
+ break
+ }
+ f = f1
+ r = r1
+ }
+
+ if LOAD(r, z)&^(r.set.b[z]&^(r.use1.b[z]|r.use2.b[z]))&bb != 0 {
+ addmove(f, bn, rn, 0)
+ }
+ for {
+ r.act.b[z] |= bb
+ p = f.Prog
+
+ if r.use1.b[z]&bb != 0 {
+ if Debug['R'] != 0 && Debug['v'] != 0 {
+ fmt.Printf("%v", p)
+ }
+ addreg(&p.From, rn)
+ if Debug['R'] != 0 && Debug['v'] != 0 {
+ fmt.Printf(" ===change== %v\n", p)
+ }
+ }
+
+ if (r.use2.b[z]|r.set.b[z])&bb != 0 {
+ if Debug['R'] != 0 && Debug['v'] != 0 {
+ fmt.Printf("%v", p)
+ }
+ addreg(&p.To, rn)
+ if Debug['R'] != 0 && Debug['v'] != 0 {
+ fmt.Printf(" ===change== %v\n", p)
+ }
+ }
+
+ if STORE(r, z)&r.regdiff.b[z]&bb != 0 {
+ addmove(f, bn, rn, 1)
+ }
+ r.regu |= rb
+
+ if r.refbehind.b[z]&bb != 0 {
+ for f1 = f.P2; f1 != nil; f1 = f1.P2link {
+ if (f1.Data.(*Reg)).refahead.b[z]&bb != 0 {
+ paint3(f1, bn, rb, rn)
+ }
+ }
+ }
+
+ if !(r.refahead.b[z]&bb != 0) {
+ break
+ }
+ f1 = f.S2
+ if f1 != nil {
+ if (f1.Data.(*Reg)).refbehind.b[z]&bb != 0 {
+ paint3(f1, bn, rb, rn)
+ }
+ }
+ f = f.S1
+ if f == nil {
+ break
+ }
+ r = f.Data.(*Reg)
+ if r.act.b[z]&bb != 0 {
+ break
+ }
+ if !(r.refbehind.b[z]&bb != 0) {
+ break
+ }
+ }
+}
+
+func addreg(a *obj.Addr, rn int) {
+ a.Sym = nil
+ a.Node = nil
+ a.Offset = 0
+ a.Type = obj.TYPE_REG
+ a.Reg = int16(rn)
+ a.Name = 0
+
+ Ostats.Ncvtreg++
+}
+
+func dumpone(f *Flow, isreg int) {
+ var z int
+ var bit Bits
+ var r *Reg
+
+ fmt.Printf("%d:%v", f.Loop, f.Prog)
+ if isreg != 0 {
+ r = f.Data.(*Reg)
+ for z = 0; z < BITS; z++ {
+ bit.b[z] = r.set.b[z] | r.use1.b[z] | r.use2.b[z] | r.refbehind.b[z] | r.refahead.b[z] | r.calbehind.b[z] | r.calahead.b[z] | r.regdiff.b[z] | r.act.b[z] | 0
+ }
+ if bany(&bit) != 0 {
+ fmt.Printf("\t")
+ if bany(&r.set) != 0 {
+ fmt.Printf(" s:%v", Qconv(r.set, 0))
+ }
+ if bany(&r.use1) != 0 {
+ fmt.Printf(" u1:%v", Qconv(r.use1, 0))
+ }
+ if bany(&r.use2) != 0 {
+ fmt.Printf(" u2:%v", Qconv(r.use2, 0))
+ }
+ if bany(&r.refbehind) != 0 {
+ fmt.Printf(" rb:%v ", Qconv(r.refbehind, 0))
+ }
+ if bany(&r.refahead) != 0 {
+ fmt.Printf(" ra:%v ", Qconv(r.refahead, 0))
+ }
+ if bany(&r.calbehind) != 0 {
+ fmt.Printf(" cb:%v ", Qconv(r.calbehind, 0))
+ }
+ if bany(&r.calahead) != 0 {
+ fmt.Printf(" ca:%v ", Qconv(r.calahead, 0))
+ }
+ if bany(&r.regdiff) != 0 {
+ fmt.Printf(" d:%v ", Qconv(r.regdiff, 0))
+ }
+ if bany(&r.act) != 0 {
+ fmt.Printf(" a:%v ", Qconv(r.act, 0))
+ }
+ }
+ }
+
+ fmt.Printf("\n")
+}
+
+func Dumpit(str string, r0 *Flow, isreg int) {
+ var r *Flow
+ var r1 *Flow
+
+ fmt.Printf("\n%s\n", str)
+ for r = r0; r != nil; r = r.Link {
+ dumpone(r, isreg)
+ r1 = r.P2
+ if r1 != nil {
+ fmt.Printf("\tpred:")
+ for ; r1 != nil; r1 = r1.P2link {
+ fmt.Printf(" %.4d", uint(int(r1.Prog.Pc)))
+ }
+ if r.P1 != nil {
+ fmt.Printf(" (and %.4d)", uint(int(r.P1.Prog.Pc)))
+ } else {
+ fmt.Printf(" (only)")
+ }
+ fmt.Printf("\n")
+ }
+
+ // Print successors if it's not just the next one
+ if r.S1 != r.Link || r.S2 != nil {
+ fmt.Printf("\tsucc:")
+ if r.S1 != nil {
+ fmt.Printf(" %.4d", uint(int(r.S1.Prog.Pc)))
+ }
+ if r.S2 != nil {
+ fmt.Printf(" %.4d", uint(int(r.S2.Prog.Pc)))
+ }
+ fmt.Printf("\n")
+ }
+ }
+}
+
+func regopt(firstp *obj.Prog) {
+ var f *Flow
+ var f1 *Flow
+ var r *Reg
+ var p *obj.Prog
+ var g *Graph
+ var info ProgInfo
+ var i int
+ var z int
+ var active int
+ var vreg uint64
+ var usedreg uint64
+ var mask uint64
+ var nreg int
+ var regnames []string
+ var bit Bits
+ var rgp *Rgn
+
+ if first != 0 {
+ first = 0
+ }
+
+ mergetemp(firstp)
+
+ /*
+ * control flow is more complicated in generated go code
+ * than in generated c code. define pseudo-variables for
+ * registers, so we have complete register usage information.
+ */
+ regnames = Thearch.Regnames(&nreg)
+
+ nvar = nreg
+ for i = 0; i < nreg; i++ {
+ var_[i] = Var{}
+ }
+ for i = 0; i < nreg; i++ {
+ if regnodes[i] == nil {
+ regnodes[i] = newname(Lookup(regnames[i]))
+ }
+ var_[i].node = regnodes[i]
+ }
+
+ regbits = Thearch.Excludedregs()
+ externs = zbits
+ params = zbits
+ consts = zbits
+ addrs = zbits
+ ivar = zbits
+ ovar = zbits
+
+ /*
+ * pass 1
+ * build aux data structure
+ * allocate pcs
+ * find use and set of variables
+ */
+ g = Flowstart(firstp, func() interface{} { return new(Reg) })
+
+ if g == nil {
+ for i = 0; i < nvar; i++ {
+ var_[i].node.Opt = nil
+ }
+ return
+ }
+
+ firstf = g.Start
+
+ for f = firstf; f != nil; f = f.Link {
+ p = f.Prog
+ if p.As == obj.AVARDEF || p.As == obj.AVARKILL {
+ continue
+ }
+ Thearch.Proginfo(&info, p)
+
+ // Avoid making variables for direct-called functions.
+ if p.As == obj.ACALL && p.To.Type == obj.TYPE_MEM && p.To.Name == obj.NAME_EXTERN {
+ continue
+ }
+
+ // from vs to doesn't matter for registers.
+ r = f.Data.(*Reg)
+
+ r.use1.b[0] |= info.Reguse | info.Regindex
+ r.set.b[0] |= info.Regset
+
+ bit = mkvar(f, &p.From)
+ if bany(&bit) != 0 {
+ if info.Flags&LeftAddr != 0 {
+ setaddrs(bit)
+ }
+ if info.Flags&LeftRead != 0 {
+ for z = 0; z < BITS; z++ {
+ r.use1.b[z] |= bit.b[z]
+ }
+ }
+ if info.Flags&LeftWrite != 0 {
+ for z = 0; z < BITS; z++ {
+ r.set.b[z] |= bit.b[z]
+ }
+ }
+ }
+
+ // Compute used register for reg
+ if info.Flags&RegRead != 0 {
+ r.use1.b[0] |= Thearch.RtoB(int(p.Reg))
+ }
+
+ // Currently we never generate three register forms.
+ // If we do, this will need to change.
+ if p.From3.Type != obj.TYPE_NONE {
+ Fatal("regopt not implemented for from3")
+ }
+
+ bit = mkvar(f, &p.To)
+ if bany(&bit) != 0 {
+ if info.Flags&RightAddr != 0 {
+ setaddrs(bit)
+ }
+ if info.Flags&RightRead != 0 {
+ for z = 0; z < BITS; z++ {
+ r.use2.b[z] |= bit.b[z]
+ }
+ }
+ if info.Flags&RightWrite != 0 {
+ for z = 0; z < BITS; z++ {
+ r.set.b[z] |= bit.b[z]
+ }
+ }
+ }
+ }
+
+ for i = 0; i < nvar; i++ {
+ var v *Var
+ v = &var_[i:][0]
+ if v.addr != 0 {
+ bit = blsh(uint(i))
+ for z = 0; z < BITS; z++ {
+ addrs.b[z] |= bit.b[z]
+ }
+ }
+
+ if Debug['R'] != 0 && Debug['v'] != 0 {
+ fmt.Printf("bit=%2d addr=%d et=%v w=%-2d s=%v + %d\n", i, v.addr, Econv(int(v.etype), 0), v.width, Nconv(v.node, 0), v.offset)
+ }
+ }
+
+ if Debug['R'] != 0 && Debug['v'] != 0 {
+ Dumpit("pass1", firstf, 1)
+ }
+
+ /*
+ * pass 2
+ * find looping structure
+ */
+ flowrpo(g)
+
+ if Debug['R'] != 0 && Debug['v'] != 0 {
+ Dumpit("pass2", firstf, 1)
+ }
+
+ /*
+ * pass 2.5
+ * iterate propagating fat vardef covering forward
+ * r->act records vars with a VARDEF since the last CALL.
+ * (r->act will be reused in pass 5 for something else,
+ * but we'll be done with it by then.)
+ */
+ active = 0
+
+ for f = firstf; f != nil; f = f.Link {
+ f.Active = 0
+ r = f.Data.(*Reg)
+ r.act = zbits
+ }
+
+ for f = firstf; f != nil; f = f.Link {
+ p = f.Prog
+ if p.As == obj.AVARDEF && Isfat(((p.To.Node).(*Node)).Type) != 0 && ((p.To.Node).(*Node)).Opt != nil {
+ active++
+ walkvardef(p.To.Node.(*Node), f, active)
+ }
+ }
+
+ /*
+ * pass 3
+ * iterate propagating usage
+ * back until flow graph is complete
+ */
+loop1:
+ change = 0
+
+ for f = firstf; f != nil; f = f.Link {
+ f.Active = 0
+ }
+ for f = firstf; f != nil; f = f.Link {
+ if f.Prog.As == obj.ARET {
+ prop(f, zbits, zbits)
+ }
+ }
+
+ /* pick up unreachable code */
+loop11:
+ i = 0
+
+ for f = firstf; f != nil; f = f1 {
+ f1 = f.Link
+ if f1 != nil && f1.Active != 0 && !(f.Active != 0) {
+ prop(f, zbits, zbits)
+ i = 1
+ }
+ }
+
+ if i != 0 {
+ goto loop11
+ }
+ if change != 0 {
+ goto loop1
+ }
+
+ if Debug['R'] != 0 && Debug['v'] != 0 {
+ Dumpit("pass3", firstf, 1)
+ }
+
+ /*
+ * pass 4
+ * iterate propagating register/variable synchrony
+ * forward until graph is complete
+ */
+loop2:
+ change = 0
+
+ for f = firstf; f != nil; f = f.Link {
+ f.Active = 0
+ }
+ synch(firstf, zbits)
+ if change != 0 {
+ goto loop2
+ }
+
+ if Debug['R'] != 0 && Debug['v'] != 0 {
+ Dumpit("pass4", firstf, 1)
+ }
+
+ /*
+ * pass 4.5
+ * move register pseudo-variables into regu.
+ */
+ mask = (1 << uint(nreg)) - 1
+ for f = firstf; f != nil; f = f.Link {
+ r = f.Data.(*Reg)
+ r.regu = (r.refbehind.b[0] | r.set.b[0]) & mask
+ r.set.b[0] &^= mask
+ r.use1.b[0] &^= mask
+ r.use2.b[0] &^= mask
+ r.refbehind.b[0] &^= mask
+ r.refahead.b[0] &^= mask
+ r.calbehind.b[0] &^= mask
+ r.calahead.b[0] &^= mask
+ r.regdiff.b[0] &^= mask
+ r.act.b[0] &^= mask
+ }
+
+ if Debug['R'] != 0 && Debug['v'] != 0 {
+ Dumpit("pass4.5", firstf, 1)
+ }
+
+ /*
+ * pass 5
+ * isolate regions
+ * calculate costs (paint1)
+ */
+ f = firstf
+
+ if f != nil {
+ r = f.Data.(*Reg)
+ for z = 0; z < BITS; z++ {
+ bit.b[z] = (r.refahead.b[z] | r.calahead.b[z]) &^ (externs.b[z] | params.b[z] | addrs.b[z] | consts.b[z])
+ }
+ if bany(&bit) != 0 && !(f.Refset != 0) {
+ // should never happen - all variables are preset
+ if Debug['w'] != 0 {
+ fmt.Printf("%v: used and not set: %v\n", f.Prog.Line(), Qconv(bit, 0))
+ }
+ f.Refset = 1
+ }
+ }
+
+ for f = firstf; f != nil; f = f.Link {
+ (f.Data.(*Reg)).act = zbits
+ }
+ nregion = 0
+ for f = firstf; f != nil; f = f.Link {
+ r = f.Data.(*Reg)
+ for z = 0; z < BITS; z++ {
+ bit.b[z] = r.set.b[z] &^ (r.refahead.b[z] | r.calahead.b[z] | addrs.b[z])
+ }
+ if bany(&bit) != 0 && !(f.Refset != 0) {
+ if Debug['w'] != 0 {
+ fmt.Printf("%v: set and not used: %v\n", f.Prog.Line(), Qconv(bit, 0))
+ }
+ f.Refset = 1
+ Thearch.Excise(f)
+ }
+
+ for z = 0; z < BITS; z++ {
+ bit.b[z] = LOAD(r, z) &^ (r.act.b[z] | addrs.b[z])
+ }
+ for bany(&bit) != 0 {
+ i = bnum(bit)
+ change = 0
+ paint1(f, i)
+ biclr(&bit, uint(i))
+ if change <= 0 {
+ continue
+ }
+ if nregion >= NRGN {
+ if Debug['R'] != 0 && Debug['v'] != 0 {
+ fmt.Printf("too many regions\n")
+ }
+ goto brk
+ }
+
+ rgp = ®ion[nregion]
+ rgp.enter = f
+ rgp.varno = int16(i)
+ rgp.cost = int16(change)
+ nregion++
+ }
+ }
+
+brk:
+ sort.Sort(rcmp(region[:nregion]))
+
+ if Debug['R'] != 0 && Debug['v'] != 0 {
+ Dumpit("pass5", firstf, 1)
+ }
+
+ /*
+ * pass 6
+ * determine used registers (paint2)
+ * replace code (paint3)
+ */
+ if Debug['R'] != 0 && Debug['v'] != 0 {
+ fmt.Printf("\nregisterizing\n")
+ }
+ for i = 0; i < nregion; i++ {
+ rgp = ®ion[i]
+ if Debug['R'] != 0 && Debug['v'] != 0 {
+ fmt.Printf("region %d: cost %d varno %d enter %d\n", i, rgp.cost, rgp.varno, rgp.enter.Prog.Pc)
+ }
+ bit = blsh(uint(rgp.varno))
+ usedreg = paint2(rgp.enter, int(rgp.varno), 0)
+ vreg = allreg(usedreg, rgp)
+ if rgp.regno != 0 {
+ if Debug['R'] != 0 && Debug['v'] != 0 {
+ var v *Var
+
+ v = &var_[rgp.varno:][0]
+ fmt.Printf("registerize %v+%d (bit=%2d et=%v) in %v usedreg=%#x vreg=%#x\n", Nconv(v.node, 0), v.offset, rgp.varno, Econv(int(v.etype), 0), Ctxt.Rconv(int(rgp.regno)), usedreg, vreg)
+ }
+
+ paint3(rgp.enter, int(rgp.varno), vreg, int(rgp.regno))
+ }
+ }
+
+ /*
+ * free aux structures. peep allocates new ones.
+ */
+ for i = 0; i < nvar; i++ {
+ var_[i].node.Opt = nil
+ }
+ Flowend(g)
+ firstf = nil
+
+ if Debug['R'] != 0 && Debug['v'] != 0 {
+ // Rebuild flow graph, since we inserted instructions
+ g = Flowstart(firstp, nil)
+
+ firstf = g.Start
+ Dumpit("pass6", firstf, 0)
+ Flowend(g)
+ firstf = nil
+ }
+
+ /*
+ * pass 7
+ * peep-hole on basic block
+ */
+ if !(Debug['R'] != 0) || Debug['P'] != 0 {
+ Thearch.Peep(firstp)
+ }
+
+ /*
+ * eliminate nops
+ */
+ for p = firstp; p != nil; p = p.Link {
+ for p.Link != nil && p.Link.As == obj.ANOP {
+ p.Link = p.Link.Link
+ }
+ if p.To.Type == obj.TYPE_BRANCH {
+ for p.To.U.Branch != nil && p.To.U.Branch.As == obj.ANOP {
+ p.To.U.Branch = p.To.U.Branch.Link
+ }
+ }
+ }
+
+ if Debug['R'] != 0 {
+ if Ostats.Ncvtreg != 0 || Ostats.Nspill != 0 || Ostats.Nreload != 0 || Ostats.Ndelmov != 0 || Ostats.Nvar != 0 || Ostats.Naddr != 0 || false {
+ fmt.Printf("\nstats\n")
+ }
+
+ if Ostats.Ncvtreg != 0 {
+ fmt.Printf("\t%4d cvtreg\n", Ostats.Ncvtreg)
+ }
+ if Ostats.Nspill != 0 {
+ fmt.Printf("\t%4d spill\n", Ostats.Nspill)
+ }
+ if Ostats.Nreload != 0 {
+ fmt.Printf("\t%4d reload\n", Ostats.Nreload)
+ }
+ if Ostats.Ndelmov != 0 {
+ fmt.Printf("\t%4d delmov\n", Ostats.Ndelmov)
+ }
+ if Ostats.Nvar != 0 {
+ fmt.Printf("\t%4d var\n", Ostats.Nvar)
+ }
+ if Ostats.Naddr != 0 {
+ fmt.Printf("\t%4d addr\n", Ostats.Naddr)
+ }
+
+ Ostats = OptStats{}
+ }
+}
diff --git a/src/cmd/internal/gc/select.go b/src/cmd/internal/gc/select.go
new file mode 100644
index 0000000..9e659d1
--- /dev/null
+++ b/src/cmd/internal/gc/select.go
@@ -0,0 +1,389 @@
+// 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
+ var l *NodeList
+ var lno int
+ var count int
+
+ def = nil
+ lno = int(setlineno(sel))
+ count = 0
+ typechecklist(sel.Ninit, Etop)
+ for l = sel.List; l != nil; l = l.Next {
+ count++
+ ncase = l.N
+ setlineno(ncase)
+ if ncase.Op != OXCASE {
+ Fatal("typecheckselect %v", Oconv(int(ncase.Op), 0))
+ }
+
+ if ncase.List == nil {
+ // default
+ if def != nil {
+ Yyerror("multiple defaults in select (first at %v)", def.Line())
+ } else {
+ def = ncase
+ }
+ } else if ncase.List.Next != nil {
+ Yyerror("select cases cannot be lists")
+ } else {
+ n = typecheck(&ncase.List.N, Etop)
+ ncase.Left = n
+ ncase.List = 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 != 0 {
+ 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.N.Op != ORECV {
+ Yyerror("select assignment must have receive on right hand side")
+ break
+ }
+
+ n.Op = OSELRECV2
+ n.Left = n.List.N
+ n.Ntest = n.List.Next.N
+ n.List = nil
+ n.Right = n.Rlist.N
+ n.Rlist = nil
+
+ // convert <-c into OSELRECV(N, <-c)
+ case ORECV:
+ n = Nod(OSELRECV, nil, n)
+
+ n.Typecheck = 1
+ ncase.Left = n
+
+ case OSEND:
+ break
+ }
+ }
+
+ typechecklist(ncase.Nbody, Etop)
+ }
+
+ sel.Xoffset = int64(count)
+ lineno = int32(lno)
+}
+
+func walkselect(sel *Node) {
+ var lno int
+ var i int
+ var n *Node
+ var r *Node
+ var a *Node
+ var var_ *Node
+ var selv *Node
+ var cas *Node
+ var dflt *Node
+ var ch *Node
+ var l *NodeList
+ var init *NodeList
+
+ if sel.List == nil && sel.Xoffset != 0 {
+ Fatal("double walkselect") // already rewrote
+ }
+
+ lno = int(setlineno(sel))
+ i = count(sel.List)
+
+ // optimization: zero-case select
+ if i == 0 {
+ sel.Nbody = list1(mkcall("block", nil, nil))
+ goto out
+ }
+
+ // optimization: one-case select: single op.
+ // TODO(rsc): Reenable optimization once order.c can handle it.
+ // golang.org/issue/7672.
+ if i == 1 {
+ cas = sel.List.N
+ setlineno(cas)
+ l = cas.Ninit
+ if cas.Left != nil { // not default:
+ n = cas.Left
+ l = concat(l, n.Ninit)
+ n.Ninit = nil
+ switch n.Op {
+ default:
+ Fatal("select %v", Oconv(int(n.Op), 0))
+ fallthrough
+
+ // ok already
+ case OSEND:
+ ch = n.Left
+
+ case OSELRECV,
+ OSELRECV2:
+ ch = n.Right.Left
+ if n.Op == OSELRECV || n.Ntest == nil {
+ if n.Left == nil {
+ n = n.Right
+ } else {
+ n.Op = OAS
+ }
+ break
+ }
+
+ if n.Left == nil {
+ typecheck(&nblank, Erv|Easgn)
+ n.Left = nblank
+ }
+
+ n.Op = OAS2
+ n.List = list(list1(n.Left), n.Ntest)
+ n.Rlist = list1(n.Right)
+ n.Right = nil
+ n.Left = nil
+ n.Ntest = nil
+ n.Typecheck = 0
+ typecheck(&n, Etop)
+ }
+
+ // if ch == nil { block() }; n;
+ a = Nod(OIF, nil, nil)
+
+ a.Ntest = Nod(OEQ, ch, nodnil())
+ a.Nbody = list1(mkcall("block", nil, &l))
+ typecheck(&a, Etop)
+ l = list(l, a)
+ l = list(l, n)
+ }
+
+ l = concat(l, cas.Nbody)
+ sel.Nbody = l
+ goto out
+ }
+
+ // convert case value arguments to addresses.
+ // this rewrite is used by both the general code and the next optimization.
+ for l = sel.List; l != nil; l = l.Next {
+ cas = l.N
+ setlineno(cas)
+ n = cas.Left
+ if n == nil {
+ continue
+ }
+ switch n.Op {
+ case OSEND:
+ n.Right = Nod(OADDR, n.Right, nil)
+ typecheck(&n.Right, Erv)
+
+ case OSELRECV,
+ OSELRECV2:
+ if n.Op == OSELRECV2 && n.Ntest == nil {
+ n.Op = OSELRECV
+ }
+ if n.Op == OSELRECV2 {
+ n.Ntest = Nod(OADDR, n.Ntest, nil)
+ typecheck(&n.Ntest, Erv)
+ }
+
+ if n.Left == nil {
+ n.Left = nodnil()
+ } else {
+ n.Left = Nod(OADDR, n.Left, nil)
+ typecheck(&n.Left, Erv)
+ }
+ }
+ }
+
+ // optimization: two-case select but one is default: single non-blocking op.
+ if i == 2 && (sel.List.N.Left == nil || sel.List.Next.N.Left == nil) {
+ if sel.List.N.Left == nil {
+ cas = sel.List.Next.N
+ dflt = sel.List.N
+ } else {
+ dflt = sel.List.Next.N
+ cas = sel.List.N
+ }
+
+ n = cas.Left
+ setlineno(n)
+ r = Nod(OIF, nil, nil)
+ r.Ninit = cas.Ninit
+ switch n.Op {
+ default:
+ Fatal("select %v", Oconv(int(n.Op), 0))
+ fallthrough
+
+ // if selectnbsend(c, v) { body } else { default body }
+ case OSEND:
+ ch = n.Left
+
+ r.Ntest = mkcall1(chanfn("selectnbsend", 2, ch.Type), Types[TBOOL], &r.Ninit, typename(ch.Type), ch, n.Right)
+
+ // if c != nil && selectnbrecv(&v, c) { body } else { default body }
+ case OSELRECV:
+ r = Nod(OIF, nil, nil)
+
+ r.Ninit = cas.Ninit
+ ch = n.Right.Left
+ r.Ntest = mkcall1(chanfn("selectnbrecv", 2, ch.Type), Types[TBOOL], &r.Ninit, typename(ch.Type), n.Left, ch)
+
+ // if c != nil && selectnbrecv2(&v, c) { body } else { default body }
+ case OSELRECV2:
+ r = Nod(OIF, nil, nil)
+
+ r.Ninit = cas.Ninit
+ ch = n.Right.Left
+ r.Ntest = mkcall1(chanfn("selectnbrecv2", 2, ch.Type), Types[TBOOL], &r.Ninit, typename(ch.Type), n.Left, n.Ntest, ch)
+ }
+
+ typecheck(&r.Ntest, Erv)
+ r.Nbody = cas.Nbody
+ r.Nelse = concat(dflt.Ninit, dflt.Nbody)
+ sel.Nbody = list1(r)
+ goto out
+ }
+
+ init = sel.Ninit
+ sel.Ninit = nil
+
+ // generate sel-struct
+ setlineno(sel)
+
+ selv = temp(selecttype(int32(sel.Xoffset)))
+ r = Nod(OAS, selv, nil)
+ typecheck(&r, Etop)
+ init = list(init, r)
+ var_ = conv(conv(Nod(OADDR, selv, nil), Types[TUNSAFEPTR]), Ptrto(Types[TUINT8]))
+ r = mkcall("newselect", nil, nil, var_, Nodintconst(selv.Type.Width), Nodintconst(sel.Xoffset))
+ typecheck(&r, Etop)
+ init = list(init, r)
+
+ // register cases
+ for l = sel.List; l != nil; l = l.Next {
+ cas = l.N
+ setlineno(cas)
+ n = cas.Left
+ r = Nod(OIF, nil, nil)
+ r.Ninit = cas.Ninit
+ cas.Ninit = nil
+ if n != nil {
+ r.Ninit = concat(r.Ninit, n.Ninit)
+ n.Ninit = nil
+ }
+
+ if n == nil {
+ // selectdefault(sel *byte);
+ r.Ntest = mkcall("selectdefault", Types[TBOOL], &r.Ninit, var_)
+ } else {
+ switch n.Op {
+ default:
+ Fatal("select %v", Oconv(int(n.Op), 0))
+ fallthrough
+
+ // selectsend(sel *byte, hchan *chan any, elem *any) (selected bool);
+ case OSEND:
+ r.Ntest = mkcall1(chanfn("selectsend", 2, n.Left.Type), Types[TBOOL], &r.Ninit, var_, n.Left, n.Right)
+
+ // selectrecv(sel *byte, hchan *chan any, elem *any) (selected bool);
+ case OSELRECV:
+ r.Ntest = mkcall1(chanfn("selectrecv", 2, n.Right.Left.Type), Types[TBOOL], &r.Ninit, var_, n.Right.Left, n.Left)
+
+ // selectrecv2(sel *byte, hchan *chan any, elem *any, received *bool) (selected bool);
+ case OSELRECV2:
+ r.Ntest = mkcall1(chanfn("selectrecv2", 2, n.Right.Left.Type), Types[TBOOL], &r.Ninit, var_, n.Right.Left, n.Left, n.Ntest)
+ }
+ }
+
+ // selv is no longer alive after use.
+ r.Nbody = list(r.Nbody, Nod(OVARKILL, selv, nil))
+
+ r.Nbody = concat(r.Nbody, cas.Nbody)
+ r.Nbody = list(r.Nbody, Nod(OBREAK, nil, nil))
+ init = list(init, r)
+ }
+
+ // run the select
+ setlineno(sel)
+
+ init = list(init, mkcall("selectgo", nil, nil, var_))
+ sel.Nbody = init
+
+out:
+ sel.List = nil
+ walkstmtlist(sel.Nbody)
+ lineno = int32(lno)
+}
+
+// Keep in sync with src/runtime/chan.h.
+func selecttype(size int32) *Type {
+ var sel *Node
+ var sudog *Node
+ var scase *Node
+ var arr *Node
+
+ // TODO(dvyukov): it's possible to generate SudoG and Scase only once
+ // and then cache; and also cache Select per size.
+ sudog = Nod(OTSTRUCT, nil, nil)
+
+ sudog.List = list(sudog.List, Nod(ODCLFIELD, newname(Lookup("g")), typenod(Ptrto(Types[TUINT8]))))
+ sudog.List = list(sudog.List, Nod(ODCLFIELD, newname(Lookup("selectdone")), typenod(Ptrto(Types[TUINT8]))))
+ sudog.List = list(sudog.List, Nod(ODCLFIELD, newname(Lookup("next")), typenod(Ptrto(Types[TUINT8]))))
+ sudog.List = list(sudog.List, Nod(ODCLFIELD, newname(Lookup("prev")), typenod(Ptrto(Types[TUINT8]))))
+ sudog.List = list(sudog.List, Nod(ODCLFIELD, newname(Lookup("elem")), typenod(Ptrto(Types[TUINT8]))))
+ sudog.List = list(sudog.List, Nod(ODCLFIELD, newname(Lookup("releasetime")), typenod(Types[TUINT64])))
+ sudog.List = list(sudog.List, Nod(ODCLFIELD, newname(Lookup("nrelease")), typenod(Types[TINT32])))
+ sudog.List = list(sudog.List, Nod(ODCLFIELD, newname(Lookup("waitlink")), typenod(Ptrto(Types[TUINT8]))))
+ typecheck(&sudog, Etype)
+ sudog.Type.Noalg = 1
+ sudog.Type.Local = 1
+
+ scase = Nod(OTSTRUCT, nil, nil)
+ scase.List = list(scase.List, Nod(ODCLFIELD, newname(Lookup("elem")), typenod(Ptrto(Types[TUINT8]))))
+ scase.List = list(scase.List, Nod(ODCLFIELD, newname(Lookup("chan")), typenod(Ptrto(Types[TUINT8]))))
+ scase.List = list(scase.List, Nod(ODCLFIELD, newname(Lookup("pc")), typenod(Types[TUINTPTR])))
+ scase.List = list(scase.List, Nod(ODCLFIELD, newname(Lookup("kind")), typenod(Types[TUINT16])))
+ scase.List = list(scase.List, Nod(ODCLFIELD, newname(Lookup("so")), typenod(Types[TUINT16])))
+ scase.List = list(scase.List, Nod(ODCLFIELD, newname(Lookup("receivedp")), typenod(Ptrto(Types[TUINT8]))))
+ scase.List = list(scase.List, Nod(ODCLFIELD, newname(Lookup("releasetime")), typenod(Types[TUINT64])))
+ typecheck(&scase, Etype)
+ scase.Type.Noalg = 1
+ scase.Type.Local = 1
+
+ sel = Nod(OTSTRUCT, nil, nil)
+ sel.List = list(sel.List, Nod(ODCLFIELD, newname(Lookup("tcase")), typenod(Types[TUINT16])))
+ sel.List = list(sel.List, Nod(ODCLFIELD, newname(Lookup("ncase")), typenod(Types[TUINT16])))
+ sel.List = list(sel.List, Nod(ODCLFIELD, newname(Lookup("pollorder")), typenod(Ptrto(Types[TUINT8]))))
+ sel.List = list(sel.List, Nod(ODCLFIELD, newname(Lookup("lockorder")), typenod(Ptrto(Types[TUINT8]))))
+ arr = Nod(OTARRAY, Nodintconst(int64(size)), scase)
+ sel.List = list(sel.List, Nod(ODCLFIELD, newname(Lookup("scase")), arr))
+ arr = Nod(OTARRAY, Nodintconst(int64(size)), typenod(Ptrto(Types[TUINT8])))
+ sel.List = list(sel.List, Nod(ODCLFIELD, newname(Lookup("lockorderarr")), arr))
+ arr = Nod(OTARRAY, Nodintconst(int64(size)), typenod(Types[TUINT16]))
+ sel.List = list(sel.List, Nod(ODCLFIELD, newname(Lookup("pollorderarr")), arr))
+ typecheck(&sel, Etype)
+ sel.Type.Noalg = 1
+ sel.Type.Local = 1
+
+ return sel.Type
+}
diff --git a/src/cmd/internal/gc/sinit.go b/src/cmd/internal/gc/sinit.go
new file mode 100644
index 0000000..6d044f1
--- /dev/null
+++ b/src/cmd/internal/gc/sinit.go
@@ -0,0 +1,1602 @@
+// 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
+
+import (
+ "cmd/internal/obj"
+ "fmt"
+)
+
+/*
+ * static initialization
+ */
+const (
+ InitNotStarted = 0
+ InitDone = 1
+ InitPending = 2
+)
+
+var initlist *NodeList
+
+// init1 walks the AST starting at n, and accumulates in out
+// the list of definitions needing init code in dependency order.
+func init1(n *Node, out **NodeList) {
+ var l *NodeList
+ var nv *Node
+
+ if n == nil {
+ return
+ }
+ init1(n.Left, out)
+ init1(n.Right, out)
+ for l = n.List; l != nil; l = l.Next {
+ init1(l.N, out)
+ }
+
+ if n.Left != nil && n.Type != nil && n.Left.Op == OTYPE && n.Class == PFUNC {
+ // Methods called as Type.Method(receiver, ...).
+ // Definitions for method expressions are stored in type->nname.
+ init1(n.Type.Nname, out)
+ }
+
+ if n.Op != ONAME {
+ return
+ }
+ switch n.Class {
+ case PEXTERN,
+ PFUNC:
+ break
+
+ default:
+ if isblank(n) && n.Curfn == nil && n.Defn != nil && n.Defn.Initorder == InitNotStarted {
+ // blank names initialization is part of init() but not
+ // when they are inside a function.
+ break
+ }
+
+ return
+ }
+
+ if n.Initorder == InitDone {
+ return
+ }
+ if n.Initorder == InitPending {
+ // Since mutually recursive sets of functions are allowed,
+ // we don't necessarily raise an error if n depends on a node
+ // which is already waiting for its dependencies to be visited.
+ //
+ // initlist contains a cycle of identifiers referring to each other.
+ // If this cycle contains a variable, then this variable refers to itself.
+ // Conversely, if there exists an initialization cycle involving
+ // a variable in the program, the tree walk will reach a cycle
+ // involving that variable.
+ if n.Class != PFUNC {
+ nv = n
+ goto foundinitloop
+ }
+
+ for l = initlist; l.N != n; l = l.Next {
+ if l.N.Class != PFUNC {
+ nv = l.N
+ goto foundinitloop
+ }
+ }
+
+ // The loop involves only functions, ok.
+ return
+
+ // if there have already been errors printed,
+ // those errors probably confused us and
+ // there might not be a loop. let the user
+ // fix those first.
+ foundinitloop:
+ Flusherrors()
+
+ if nerrors > 0 {
+ errorexit()
+ }
+
+ // There is a loop involving nv. We know about
+ // n and initlist = n1 <- ... <- nv <- ... <- n <- ...
+ fmt.Printf("%v: initialization loop:\n", nv.Line())
+
+ // Build back pointers in initlist.
+ for l = initlist; l != nil; l = l.Next {
+ if l.Next != nil {
+ l.Next.End = l
+ }
+ }
+
+ // Print nv -> ... -> n1 -> n.
+ for l = initlist; l.N != nv; l = l.Next {
+ }
+ for ; l != nil; l = l.End {
+ fmt.Printf("\t%v %v refers to\n", l.N.Line(), Sconv(l.N.Sym, 0))
+ }
+
+ // Print n -> ... -> nv.
+ for l = initlist; l.N != n; l = l.Next {
+ }
+ for ; l.N != nv; l = l.End {
+ fmt.Printf("\t%v %v refers to\n", l.N.Line(), Sconv(l.N.Sym, 0))
+ }
+ fmt.Printf("\t%v %v\n", nv.Line(), Sconv(nv.Sym, 0))
+ errorexit()
+ }
+
+ // reached a new unvisited node.
+ n.Initorder = InitPending
+
+ l = new(NodeList)
+ if l == nil {
+ Flusherrors()
+ Yyerror("out of memory")
+ errorexit()
+ }
+
+ l.Next = initlist
+ l.N = n
+ l.End = nil
+ initlist = l
+
+ // make sure that everything n depends on is initialized.
+ // n->defn is an assignment to n
+ if n.Defn != nil {
+ switch n.Defn.Op {
+ default:
+ goto bad
+
+ case ODCLFUNC:
+ init2list(n.Defn.Nbody, out)
+
+ case OAS:
+ if n.Defn.Left != n {
+ goto bad
+ }
+ if isblank(n.Defn.Left) && candiscard(n.Defn.Right) != 0 {
+ n.Defn.Op = OEMPTY
+ n.Defn.Left = nil
+ n.Defn.Right = nil
+ break
+ }
+
+ init2(n.Defn.Right, out)
+ if Debug['j'] != 0 {
+ fmt.Printf("%v\n", Sconv(n.Sym, 0))
+ }
+ if isblank(n) || !(staticinit(n, out) != 0) {
+ if Debug['%'] != 0 {
+ Dump("nonstatic", n.Defn)
+ }
+ *out = list(*out, n.Defn)
+ }
+
+ case OAS2FUNC,
+ OAS2MAPR,
+ OAS2DOTTYPE,
+ OAS2RECV:
+ if n.Defn.Initorder != InitNotStarted {
+ break
+ }
+ n.Defn.Initorder = InitDone
+ for l = n.Defn.Rlist; l != nil; l = l.Next {
+ init1(l.N, out)
+ }
+ if Debug['%'] != 0 {
+ Dump("nonstatic", n.Defn)
+ }
+ *out = list(*out, n.Defn)
+ }
+ }
+
+ l = initlist
+ initlist = l.Next
+ if l.N != n {
+ Fatal("bad initlist")
+ }
+
+ n.Initorder = InitDone
+ return
+
+bad:
+ Dump("defn", n.Defn)
+ Fatal("init1: bad defn")
+}
+
+// recurse over n, doing init1 everywhere.
+func init2(n *Node, out **NodeList) {
+ if n == nil || n.Initorder == InitDone {
+ return
+ }
+
+ if n.Op == ONAME && n.Ninit != nil {
+ Fatal("name %v with ninit: %v\n", Sconv(n.Sym, 0), Nconv(n, obj.FmtSign))
+ }
+
+ init1(n, out)
+ init2(n.Left, out)
+ init2(n.Right, out)
+ init2(n.Ntest, out)
+ init2list(n.Ninit, out)
+ init2list(n.List, out)
+ init2list(n.Rlist, out)
+ init2list(n.Nbody, out)
+ init2list(n.Nelse, out)
+
+ if n.Op == OCLOSURE {
+ init2list(n.Closure.Nbody, out)
+ }
+ if n.Op == ODOTMETH || n.Op == OCALLPART {
+ init2(n.Type.Nname, out)
+ }
+}
+
+func init2list(l *NodeList, out **NodeList) {
+ for ; l != nil; l = l.Next {
+ init2(l.N, out)
+ }
+}
+
+func initreorder(l *NodeList, out **NodeList) {
+ var n *Node
+
+ for ; l != nil; l = l.Next {
+ n = l.N
+ switch n.Op {
+ case ODCLFUNC,
+ ODCLCONST,
+ ODCLTYPE:
+ continue
+ }
+
+ initreorder(n.Ninit, out)
+ n.Ninit = nil
+ init1(n, out)
+ }
+}
+
+// initfix computes initialization order for a list l of top-level
+// declarations and outputs the corresponding list of statements
+// to include in the init() function body.
+func initfix(l *NodeList) *NodeList {
+ var lout *NodeList
+ var lno int
+
+ lout = nil
+ lno = int(lineno)
+ initreorder(l, &lout)
+ lineno = int32(lno)
+ return lout
+}
+
+/*
+ * compilation of top-level (static) assignments
+ * into DATA statements if at all possible.
+ */
+func staticinit(n *Node, out **NodeList) int {
+ var l *Node
+ var r *Node
+
+ if n.Op != ONAME || n.Class != PEXTERN || n.Defn == nil || n.Defn.Op != OAS {
+ Fatal("staticinit")
+ }
+
+ lineno = n.Lineno
+ l = n.Defn.Left
+ r = n.Defn.Right
+ return staticassign(l, r, out)
+}
+
+// like staticassign but we are copying an already
+// initialized value r.
+func staticcopy(l *Node, r *Node, out **NodeList) int {
+ var i int
+ var e *InitEntry
+ var p *InitPlan
+ var a *Node
+ var ll *Node
+ var rr *Node
+ var orig *Node
+ var n1 Node
+
+ if r.Op != ONAME || r.Class != PEXTERN || r.Sym.Pkg != localpkg {
+ return 0
+ }
+ if r.Defn == nil { // probably zeroed but perhaps supplied externally and of unknown value
+ return 0
+ }
+ if r.Defn.Op != OAS {
+ return 0
+ }
+ orig = r
+ r = r.Defn.Right
+
+ switch r.Op {
+ case ONAME:
+ if staticcopy(l, r, out) != 0 {
+ return 1
+ }
+ *out = list(*out, Nod(OAS, l, r))
+ return 1
+
+ case OLITERAL:
+ if iszero(r) != 0 {
+ return 1
+ }
+ gdata(l, r, int(l.Type.Width))
+ return 1
+
+ case OADDR:
+ switch r.Left.Op {
+ case ONAME:
+ gdata(l, r, int(l.Type.Width))
+ return 1
+ }
+
+ case OPTRLIT:
+ switch r.Left.Op {
+ //dump("not static addr", r);
+ default:
+ break
+
+ // copy pointer
+ case OARRAYLIT,
+ OSTRUCTLIT,
+ OMAPLIT:
+ gdata(l, Nod(OADDR, r.Nname, nil), int(l.Type.Width))
+
+ return 1
+ }
+
+ case OARRAYLIT:
+ if Isslice(r.Type) != 0 {
+ // copy slice
+ a = r.Nname
+
+ n1 = *l
+ n1.Xoffset = l.Xoffset + int64(Array_array)
+ gdata(&n1, Nod(OADDR, a, nil), Widthptr)
+ n1.Xoffset = l.Xoffset + int64(Array_nel)
+ gdata(&n1, r.Right, Widthint)
+ n1.Xoffset = l.Xoffset + int64(Array_cap)
+ gdata(&n1, r.Right, Widthint)
+ return 1
+ }
+ fallthrough
+
+ // fall through
+ case OSTRUCTLIT:
+ p = r.Initplan
+
+ n1 = *l
+ for i = 0; i < len(p.E); i++ {
+ e = &p.E[i]
+ n1.Xoffset = l.Xoffset + e.Xoffset
+ n1.Type = e.Expr.Type
+ if e.Expr.Op == OLITERAL {
+ gdata(&n1, e.Expr, int(n1.Type.Width))
+ } else {
+ ll = Nod(OXXX, nil, nil)
+ *ll = n1
+ ll.Orig = ll // completely separate copy
+ if !(staticassign(ll, e.Expr, out) != 0) {
+ // Requires computation, but we're
+ // copying someone else's computation.
+ rr = Nod(OXXX, nil, nil)
+
+ *rr = *orig
+ rr.Orig = rr // completely separate copy
+ rr.Type = ll.Type
+ rr.Xoffset += e.Xoffset
+ *out = list(*out, Nod(OAS, ll, rr))
+ }
+ }
+ }
+
+ return 1
+ }
+
+ return 0
+}
+
+func staticassign(l *Node, r *Node, out **NodeList) int {
+ var a *Node
+ var n1 Node
+ var nam Node
+ var ta *Type
+ var p *InitPlan
+ var e *InitEntry
+ var i int
+ var sval *Strlit
+
+ switch r.Op {
+ //dump("not static", r);
+ default:
+ break
+
+ case ONAME:
+ if r.Class == PEXTERN && r.Sym.Pkg == localpkg {
+ return staticcopy(l, r, out)
+ }
+
+ case OLITERAL:
+ if iszero(r) != 0 {
+ return 1
+ }
+ gdata(l, r, int(l.Type.Width))
+ return 1
+
+ case OADDR:
+ if stataddr(&nam, r.Left) != 0 {
+ n1 = *r
+ n1.Left = &nam
+ gdata(l, &n1, int(l.Type.Width))
+ return 1
+ }
+ fallthrough
+
+ case OPTRLIT:
+ switch r.Left.Op {
+ //dump("not static ptrlit", r);
+ default:
+ break
+
+ // Init pointer.
+ case OARRAYLIT,
+ OMAPLIT,
+ OSTRUCTLIT:
+ a = staticname(r.Left.Type, 1)
+
+ r.Nname = a
+ gdata(l, Nod(OADDR, a, nil), int(l.Type.Width))
+
+ // Init underlying literal.
+ if !(staticassign(a, r.Left, out) != 0) {
+ *out = list(*out, Nod(OAS, a, r.Left))
+ }
+ return 1
+ }
+
+ case OSTRARRAYBYTE:
+ if l.Class == PEXTERN && r.Left.Op == OLITERAL {
+ sval = r.Left.Val.U.Sval
+ slicebytes(l, sval.S, len(sval.S))
+ return 1
+ }
+
+ case OARRAYLIT:
+ initplan(r)
+ if Isslice(r.Type) != 0 {
+ // Init slice.
+ ta = typ(TARRAY)
+
+ ta.Type = r.Type.Type
+ ta.Bound = Mpgetfix(r.Right.Val.U.Xval)
+ a = staticname(ta, 1)
+ r.Nname = a
+ n1 = *l
+ n1.Xoffset = l.Xoffset + int64(Array_array)
+ gdata(&n1, Nod(OADDR, a, nil), Widthptr)
+ n1.Xoffset = l.Xoffset + int64(Array_nel)
+ gdata(&n1, r.Right, Widthint)
+ n1.Xoffset = l.Xoffset + int64(Array_cap)
+ gdata(&n1, r.Right, Widthint)
+
+ // Fall through to init underlying array.
+ l = a
+ }
+ fallthrough
+
+ // fall through
+ case OSTRUCTLIT:
+ initplan(r)
+
+ p = r.Initplan
+ n1 = *l
+ for i = 0; i < len(p.E); i++ {
+ e = &p.E[i]
+ n1.Xoffset = l.Xoffset + e.Xoffset
+ n1.Type = e.Expr.Type
+ if e.Expr.Op == OLITERAL {
+ gdata(&n1, e.Expr, int(n1.Type.Width))
+ } else {
+ a = Nod(OXXX, nil, nil)
+ *a = n1
+ a.Orig = a // completely separate copy
+ if !(staticassign(a, e.Expr, out) != 0) {
+ *out = list(*out, Nod(OAS, a, e.Expr))
+ }
+ }
+ }
+
+ return 1
+
+ // TODO: Table-driven map insert.
+ case OMAPLIT:
+ break
+ }
+
+ return 0
+}
+
+/*
+ * from here down is the walk analysis
+ * of composite literals.
+ * most of the work is to generate
+ * data statements for the constant
+ * part of the composite literal.
+ */
+func staticname(t *Type, ctxt int) *Node {
+ var n *Node
+
+ namebuf = fmt.Sprintf("statictmp_%.4d", statuniqgen)
+ statuniqgen++
+ n = newname(Lookup(namebuf))
+ if !(ctxt != 0) {
+ n.Readonly = 1
+ }
+ addvar(n, t, PEXTERN)
+ return n
+}
+
+func isliteral(n *Node) int {
+ if n.Op == OLITERAL {
+ if n.Val.Ctype != CTNIL {
+ return 1
+ }
+ }
+ return 0
+}
+
+func simplename(n *Node) int {
+ if n.Op != ONAME {
+ goto no
+ }
+ if !(n.Addable != 0) {
+ goto no
+ }
+ if n.Class&PHEAP != 0 {
+ goto no
+ }
+ if n.Class == PPARAMREF {
+ goto no
+ }
+ return 1
+
+no:
+ return 0
+}
+
+func litas(l *Node, r *Node, init **NodeList) {
+ var a *Node
+
+ a = Nod(OAS, l, r)
+ typecheck(&a, Etop)
+ walkexpr(&a, init)
+ *init = list(*init, a)
+}
+
+const (
+ MODEDYNAM = 1
+ MODECONST = 2
+)
+
+func getdyn(n *Node, top int) int {
+ var nl *NodeList
+ var value *Node
+ var mode int
+
+ mode = 0
+ switch n.Op {
+ default:
+ if isliteral(n) != 0 {
+ return MODECONST
+ }
+ return MODEDYNAM
+
+ case OARRAYLIT:
+ if !(top != 0) && n.Type.Bound < 0 {
+ return MODEDYNAM
+ }
+ fallthrough
+
+ case OSTRUCTLIT:
+ break
+ }
+
+ for nl = n.List; nl != nil; nl = nl.Next {
+ value = nl.N.Right
+ mode |= getdyn(value, 0)
+ if mode == MODEDYNAM|MODECONST {
+ break
+ }
+ }
+
+ return mode
+}
+
+func structlit(ctxt int, pass int, n *Node, var_ *Node, init **NodeList) {
+ var r *Node
+ var a *Node
+ var nl *NodeList
+ var index *Node
+ var value *Node
+
+ for nl = n.List; nl != nil; nl = nl.Next {
+ r = nl.N
+ if r.Op != OKEY {
+ Fatal("structlit: rhs not OKEY: %v", Nconv(r, 0))
+ }
+ index = r.Left
+ value = r.Right
+
+ switch value.Op {
+ case OARRAYLIT:
+ if value.Type.Bound < 0 {
+ if pass == 1 && ctxt != 0 {
+ a = Nod(ODOT, var_, newname(index.Sym))
+ slicelit(ctxt, value, a, init)
+ } else if pass == 2 && ctxt == 0 {
+ a = Nod(ODOT, var_, newname(index.Sym))
+ slicelit(ctxt, value, a, init)
+ } else if pass == 3 {
+ break
+ }
+ continue
+ }
+
+ a = Nod(ODOT, var_, newname(index.Sym))
+ arraylit(ctxt, pass, value, a, init)
+ continue
+
+ case OSTRUCTLIT:
+ a = Nod(ODOT, var_, newname(index.Sym))
+ structlit(ctxt, pass, value, a, init)
+ continue
+ }
+
+ if isliteral(value) != 0 {
+ if pass == 2 {
+ continue
+ }
+ } else if pass == 1 {
+ continue
+ }
+
+ // build list of var.field = expr
+ a = Nod(ODOT, var_, newname(index.Sym))
+
+ a = Nod(OAS, a, value)
+ typecheck(&a, Etop)
+ if pass == 1 {
+ walkexpr(&a, init) // add any assignments in r to top
+ if a.Op != OAS {
+ Fatal("structlit: not as")
+ }
+ a.Dodata = 2
+ } else {
+ orderstmtinplace(&a)
+ walkstmt(&a)
+ }
+
+ *init = list(*init, a)
+ }
+}
+
+func arraylit(ctxt int, pass int, n *Node, var_ *Node, init **NodeList) {
+ var r *Node
+ var a *Node
+ var l *NodeList
+ var index *Node
+ var value *Node
+
+ for l = n.List; l != nil; l = l.Next {
+ r = l.N
+ if r.Op != OKEY {
+ Fatal("arraylit: rhs not OKEY: %v", Nconv(r, 0))
+ }
+ index = r.Left
+ value = r.Right
+
+ switch value.Op {
+ case OARRAYLIT:
+ if value.Type.Bound < 0 {
+ if pass == 1 && ctxt != 0 {
+ a = Nod(OINDEX, var_, index)
+ slicelit(ctxt, value, a, init)
+ } else if pass == 2 && ctxt == 0 {
+ a = Nod(OINDEX, var_, index)
+ slicelit(ctxt, value, a, init)
+ } else if pass == 3 {
+ break
+ }
+ continue
+ }
+
+ a = Nod(OINDEX, var_, index)
+ arraylit(ctxt, pass, value, a, init)
+ continue
+
+ case OSTRUCTLIT:
+ a = Nod(OINDEX, var_, index)
+ structlit(ctxt, pass, value, a, init)
+ continue
+ }
+
+ if isliteral(index) != 0 && isliteral(value) != 0 {
+ if pass == 2 {
+ continue
+ }
+ } else if pass == 1 {
+ continue
+ }
+
+ // build list of var[index] = value
+ a = Nod(OINDEX, var_, index)
+
+ a = Nod(OAS, a, value)
+ typecheck(&a, Etop)
+ if pass == 1 {
+ walkexpr(&a, init)
+ if a.Op != OAS {
+ Fatal("arraylit: not as")
+ }
+ a.Dodata = 2
+ } else {
+ orderstmtinplace(&a)
+ walkstmt(&a)
+ }
+
+ *init = list(*init, a)
+ }
+}
+
+func slicelit(ctxt int, n *Node, var_ *Node, init **NodeList) {
+ var r *Node
+ var a *Node
+ var l *NodeList
+ var t *Type
+ var vstat *Node
+ var vauto *Node
+ var index *Node
+ var value *Node
+ var mode int
+
+ // make an array type
+ t = shallow(n.Type)
+
+ t.Bound = Mpgetfix(n.Right.Val.U.Xval)
+ t.Width = 0
+ t.Sym = nil
+ t.Haspointers = 0
+ dowidth(t)
+
+ if ctxt != 0 {
+ // put everything into static array
+ vstat = staticname(t, ctxt)
+
+ arraylit(ctxt, 1, n, vstat, init)
+ arraylit(ctxt, 2, n, vstat, init)
+
+ // copy static to slice
+ a = Nod(OSLICE, vstat, Nod(OKEY, nil, nil))
+
+ a = Nod(OAS, var_, a)
+ typecheck(&a, Etop)
+ a.Dodata = 2
+ *init = list(*init, a)
+ return
+ }
+
+ // recipe for var = []t{...}
+ // 1. make a static array
+ // var vstat [...]t
+ // 2. assign (data statements) the constant part
+ // vstat = constpart{}
+ // 3. make an auto pointer to array and allocate heap to it
+ // var vauto *[...]t = new([...]t)
+ // 4. copy the static array to the auto array
+ // *vauto = vstat
+ // 5. assign slice of allocated heap to var
+ // var = [0:]*auto
+ // 6. for each dynamic part assign to the slice
+ // var[i] = dynamic part
+ //
+ // an optimization is done if there is no constant part
+ // 3. var vauto *[...]t = new([...]t)
+ // 5. var = [0:]*auto
+ // 6. var[i] = dynamic part
+
+ // if the literal contains constants,
+ // make static initialized array (1),(2)
+ vstat = nil
+
+ mode = getdyn(n, 1)
+ if mode&MODECONST != 0 {
+ vstat = staticname(t, ctxt)
+ arraylit(ctxt, 1, n, vstat, init)
+ }
+
+ // make new auto *array (3 declare)
+ vauto = temp(Ptrto(t))
+
+ // set auto to point at new temp or heap (3 assign)
+ if n.Alloc != nil {
+ // temp allocated during order.c for dddarg
+ n.Alloc.Type = t
+
+ if vstat == nil {
+ a = Nod(OAS, n.Alloc, nil)
+ typecheck(&a, Etop)
+ *init = list(*init, a) // zero new temp
+ }
+
+ a = Nod(OADDR, n.Alloc, nil)
+ } else if n.Esc == EscNone {
+ a = temp(t)
+ if vstat == nil {
+ a = Nod(OAS, temp(t), nil)
+ typecheck(&a, Etop)
+ *init = list(*init, a) // zero new temp
+ a = a.Left
+ }
+
+ a = Nod(OADDR, a, nil)
+ } else {
+ a = Nod(ONEW, nil, nil)
+ a.List = list1(typenod(t))
+ }
+
+ a = Nod(OAS, vauto, a)
+ typecheck(&a, Etop)
+ walkexpr(&a, init)
+ *init = list(*init, a)
+
+ if vstat != nil {
+ // copy static to heap (4)
+ a = Nod(OIND, vauto, nil)
+
+ a = Nod(OAS, a, vstat)
+ typecheck(&a, Etop)
+ walkexpr(&a, init)
+ *init = list(*init, a)
+ }
+
+ // make slice out of heap (5)
+ a = Nod(OAS, var_, Nod(OSLICE, vauto, Nod(OKEY, nil, nil)))
+
+ typecheck(&a, Etop)
+ orderstmtinplace(&a)
+ walkstmt(&a)
+ *init = list(*init, a)
+
+ // put dynamics into slice (6)
+ for l = n.List; l != nil; l = l.Next {
+ r = l.N
+ if r.Op != OKEY {
+ Fatal("slicelit: rhs not OKEY: %v", Nconv(r, 0))
+ }
+ index = r.Left
+ value = r.Right
+ a = Nod(OINDEX, var_, index)
+ a.Bounded = 1
+
+ // TODO need to check bounds?
+
+ switch value.Op {
+ case OARRAYLIT:
+ if value.Type.Bound < 0 {
+ break
+ }
+ arraylit(ctxt, 2, value, a, init)
+ continue
+
+ case OSTRUCTLIT:
+ structlit(ctxt, 2, value, a, init)
+ continue
+ }
+
+ if isliteral(index) != 0 && isliteral(value) != 0 {
+ continue
+ }
+
+ // build list of var[c] = expr
+ a = Nod(OAS, a, value)
+
+ typecheck(&a, Etop)
+ orderstmtinplace(&a)
+ walkstmt(&a)
+ *init = list(*init, a)
+ }
+}
+
+func maplit(ctxt int, n *Node, var_ *Node, init **NodeList) {
+ var r *Node
+ var a *Node
+ var l *NodeList
+ var nerr int
+ var b int64
+ var t *Type
+ var tk *Type
+ var tv *Type
+ var t1 *Type
+ var vstat *Node
+ var index *Node
+ var value *Node
+ var key *Node
+ var val *Node
+ var syma *Sym
+ var symb *Sym
+
+ ctxt = 0
+
+ // make the map var
+ nerr = nerrors
+
+ a = Nod(OMAKE, nil, nil)
+ a.List = list1(typenod(n.Type))
+ litas(var_, a, init)
+
+ // count the initializers
+ b = 0
+
+ for l = n.List; l != nil; l = l.Next {
+ r = l.N
+
+ if r.Op != OKEY {
+ Fatal("maplit: rhs not OKEY: %v", Nconv(r, 0))
+ }
+ index = r.Left
+ value = r.Right
+
+ if isliteral(index) != 0 && isliteral(value) != 0 {
+ b++
+ }
+ }
+
+ if b != 0 {
+ // build type [count]struct { a Tindex, b Tvalue }
+ t = n.Type
+
+ tk = t.Down
+ tv = t.Type
+
+ symb = Lookup("b")
+ t = typ(TFIELD)
+ t.Type = tv
+ t.Sym = symb
+
+ syma = Lookup("a")
+ t1 = t
+ t = typ(TFIELD)
+ t.Type = tk
+ t.Sym = syma
+ t.Down = t1
+
+ t1 = t
+ t = typ(TSTRUCT)
+ t.Type = t1
+
+ t1 = t
+ t = typ(TARRAY)
+ t.Bound = b
+ t.Type = t1
+
+ dowidth(t)
+
+ // make and initialize static array
+ vstat = staticname(t, ctxt)
+
+ b = 0
+ for l = n.List; l != nil; l = l.Next {
+ r = l.N
+
+ if r.Op != OKEY {
+ Fatal("maplit: rhs not OKEY: %v", Nconv(r, 0))
+ }
+ index = r.Left
+ value = r.Right
+
+ if isliteral(index) != 0 && isliteral(value) != 0 {
+ // build vstat[b].a = key;
+ a = Nodintconst(b)
+
+ a = Nod(OINDEX, vstat, a)
+ a = Nod(ODOT, a, newname(syma))
+ a = Nod(OAS, a, index)
+ typecheck(&a, Etop)
+ walkexpr(&a, init)
+ a.Dodata = 2
+ *init = list(*init, a)
+
+ // build vstat[b].b = value;
+ a = Nodintconst(b)
+
+ a = Nod(OINDEX, vstat, a)
+ a = Nod(ODOT, a, newname(symb))
+ a = Nod(OAS, a, value)
+ typecheck(&a, Etop)
+ walkexpr(&a, init)
+ a.Dodata = 2
+ *init = list(*init, a)
+
+ b++
+ }
+ }
+
+ // loop adding structure elements to map
+ // for i = 0; i < len(vstat); i++ {
+ // map[vstat[i].a] = vstat[i].b
+ // }
+ index = temp(Types[TINT])
+
+ a = Nod(OINDEX, vstat, index)
+ a.Bounded = 1
+ a = Nod(ODOT, a, newname(symb))
+
+ r = Nod(OINDEX, vstat, index)
+ r.Bounded = 1
+ r = Nod(ODOT, r, newname(syma))
+ r = Nod(OINDEX, var_, r)
+
+ r = Nod(OAS, r, a)
+
+ a = Nod(OFOR, nil, nil)
+ a.Nbody = list1(r)
+
+ a.Ninit = list1(Nod(OAS, index, Nodintconst(0)))
+ a.Ntest = Nod(OLT, index, Nodintconst(t.Bound))
+ a.Nincr = Nod(OAS, index, Nod(OADD, index, Nodintconst(1)))
+
+ typecheck(&a, Etop)
+ walkstmt(&a)
+ *init = list(*init, a)
+ }
+
+ // put in dynamic entries one-at-a-time
+ key = nil
+
+ val = nil
+ for l = n.List; l != nil; l = l.Next {
+ r = l.N
+
+ if r.Op != OKEY {
+ Fatal("maplit: rhs not OKEY: %v", Nconv(r, 0))
+ }
+ index = r.Left
+ value = r.Right
+
+ if isliteral(index) != 0 && isliteral(value) != 0 {
+ continue
+ }
+
+ // build list of var[c] = expr.
+ // use temporary so that mapassign1 can have addressable key, val.
+ if key == nil {
+ key = temp(var_.Type.Down)
+ val = temp(var_.Type.Type)
+ }
+
+ a = Nod(OAS, key, r.Left)
+ typecheck(&a, Etop)
+ walkstmt(&a)
+ *init = list(*init, a)
+ a = Nod(OAS, val, r.Right)
+ typecheck(&a, Etop)
+ walkstmt(&a)
+ *init = list(*init, a)
+
+ a = Nod(OAS, Nod(OINDEX, var_, key), val)
+ typecheck(&a, Etop)
+ walkstmt(&a)
+ *init = list(*init, a)
+
+ if nerr != nerrors {
+ break
+ }
+ }
+
+ if key != nil {
+ a = Nod(OVARKILL, key, nil)
+ typecheck(&a, Etop)
+ *init = list(*init, a)
+ a = Nod(OVARKILL, val, nil)
+ typecheck(&a, Etop)
+ *init = list(*init, a)
+ }
+}
+
+func anylit(ctxt int, n *Node, var_ *Node, init **NodeList) {
+ var t *Type
+ var a *Node
+ var vstat *Node
+ var r *Node
+
+ t = n.Type
+ switch n.Op {
+ default:
+ Fatal("anylit: not lit")
+ fallthrough
+
+ case OPTRLIT:
+ if !(Isptr[t.Etype] != 0) {
+ Fatal("anylit: not ptr")
+ }
+
+ if n.Right != nil {
+ r = Nod(OADDR, n.Right, nil)
+ typecheck(&r, Erv)
+ } else {
+ r = Nod(ONEW, nil, nil)
+ r.Typecheck = 1
+ r.Type = t
+ r.Esc = n.Esc
+ }
+
+ walkexpr(&r, init)
+ a = Nod(OAS, var_, r)
+
+ typecheck(&a, Etop)
+ *init = list(*init, a)
+
+ var_ = Nod(OIND, var_, nil)
+ typecheck(&var_, Erv|Easgn)
+ anylit(ctxt, n.Left, var_, init)
+
+ case OSTRUCTLIT:
+ if t.Etype != TSTRUCT {
+ Fatal("anylit: not struct")
+ }
+
+ if simplename(var_) != 0 && count(n.List) > 4 {
+ if ctxt == 0 {
+ // lay out static data
+ vstat = staticname(t, ctxt)
+
+ structlit(ctxt, 1, n, vstat, init)
+
+ // copy static to var
+ a = Nod(OAS, var_, vstat)
+
+ typecheck(&a, Etop)
+ walkexpr(&a, init)
+ *init = list(*init, a)
+
+ // add expressions to automatic
+ structlit(ctxt, 2, n, var_, init)
+
+ break
+ }
+
+ structlit(ctxt, 1, n, var_, init)
+ structlit(ctxt, 2, n, var_, init)
+ break
+ }
+
+ // initialize of not completely specified
+ if simplename(var_) != 0 || count(n.List) < structcount(t) {
+ a = Nod(OAS, var_, nil)
+ typecheck(&a, Etop)
+ walkexpr(&a, init)
+ *init = list(*init, a)
+ }
+
+ structlit(ctxt, 3, n, var_, init)
+
+ case OARRAYLIT:
+ if t.Etype != TARRAY {
+ Fatal("anylit: not array")
+ }
+ if t.Bound < 0 {
+ slicelit(ctxt, n, var_, init)
+ break
+ }
+
+ if simplename(var_) != 0 && count(n.List) > 4 {
+ if ctxt == 0 {
+ // lay out static data
+ vstat = staticname(t, ctxt)
+
+ arraylit(1, 1, n, vstat, init)
+
+ // copy static to automatic
+ a = Nod(OAS, var_, vstat)
+
+ typecheck(&a, Etop)
+ walkexpr(&a, init)
+ *init = list(*init, a)
+
+ // add expressions to automatic
+ arraylit(ctxt, 2, n, var_, init)
+
+ break
+ }
+
+ arraylit(ctxt, 1, n, var_, init)
+ arraylit(ctxt, 2, n, var_, init)
+ break
+ }
+
+ // initialize of not completely specified
+ if simplename(var_) != 0 || int64(count(n.List)) < t.Bound {
+ a = Nod(OAS, var_, nil)
+ typecheck(&a, Etop)
+ walkexpr(&a, init)
+ *init = list(*init, a)
+ }
+
+ arraylit(ctxt, 3, n, var_, init)
+
+ case OMAPLIT:
+ if t.Etype != TMAP {
+ Fatal("anylit: not map")
+ }
+ maplit(ctxt, n, var_, init)
+ }
+}
+
+func oaslit(n *Node, init **NodeList) int {
+ var ctxt int
+
+ if n.Left == nil || n.Right == nil {
+ goto no
+ }
+ if n.Left.Type == nil || n.Right.Type == nil {
+ goto no
+ }
+ if !(simplename(n.Left) != 0) {
+ goto no
+ }
+ if !Eqtype(n.Left.Type, n.Right.Type) {
+ goto no
+ }
+
+ // context is init() function.
+ // implies generated data executed
+ // exactly once and not subject to races.
+ ctxt = 0
+
+ // if(n->dodata == 1)
+ // ctxt = 1;
+
+ switch n.Right.Op {
+ default:
+ goto no
+
+ case OSTRUCTLIT,
+ OARRAYLIT,
+ OMAPLIT:
+ if vmatch1(n.Left, n.Right) != 0 {
+ goto no
+ }
+ anylit(ctxt, n.Right, n.Left, init)
+ }
+
+ n.Op = OEMPTY
+ return 1
+
+ // not a special composit literal assignment
+no:
+ return 0
+}
+
+func getlit(lit *Node) int {
+ if Smallintconst(lit) != 0 {
+ return int(Mpgetfix(lit.Val.U.Xval))
+ }
+ return -1
+}
+
+func stataddr(nam *Node, n *Node) int {
+ var l int
+
+ if n == nil {
+ goto no
+ }
+
+ switch n.Op {
+ case ONAME:
+ *nam = *n
+ return int(n.Addable)
+
+ case ODOT:
+ if !(stataddr(nam, n.Left) != 0) {
+ break
+ }
+ nam.Xoffset += n.Xoffset
+ nam.Type = n.Type
+ return 1
+
+ case OINDEX:
+ if n.Left.Type.Bound < 0 {
+ break
+ }
+ if !(stataddr(nam, n.Left) != 0) {
+ break
+ }
+ l = getlit(n.Right)
+ if l < 0 {
+ break
+ }
+
+ // Check for overflow.
+ if n.Type.Width != 0 && Thearch.MAXWIDTH/n.Type.Width <= int64(l) {
+ break
+ }
+ nam.Xoffset += int64(l) * n.Type.Width
+ nam.Type = n.Type
+ return 1
+ }
+
+no:
+ return 0
+}
+
+func initplan(n *Node) {
+ var p *InitPlan
+ var a *Node
+ var l *NodeList
+
+ if n.Initplan != nil {
+ return
+ }
+ p = new(InitPlan)
+ n.Initplan = p
+ switch n.Op {
+ default:
+ Fatal("initplan")
+ fallthrough
+
+ case OARRAYLIT:
+ for l = n.List; l != nil; l = l.Next {
+ a = l.N
+ if a.Op != OKEY || !(Smallintconst(a.Left) != 0) {
+ Fatal("initplan arraylit")
+ }
+ addvalue(p, n.Type.Type.Width*Mpgetfix(a.Left.Val.U.Xval), nil, a.Right)
+ }
+
+ case OSTRUCTLIT:
+ for l = n.List; l != nil; l = l.Next {
+ a = l.N
+ if a.Op != OKEY || a.Left.Type == nil {
+ Fatal("initplan structlit")
+ }
+ addvalue(p, a.Left.Type.Width, nil, a.Right)
+ }
+
+ case OMAPLIT:
+ for l = n.List; l != nil; l = l.Next {
+ a = l.N
+ if a.Op != OKEY {
+ Fatal("initplan maplit")
+ }
+ addvalue(p, -1, a.Left, a.Right)
+ }
+ }
+}
+
+func addvalue(p *InitPlan, xoffset int64, key *Node, n *Node) {
+ var i int
+ var q *InitPlan
+ var e *InitEntry
+
+ // special case: zero can be dropped entirely
+ if iszero(n) != 0 {
+ p.Zero += n.Type.Width
+ return
+ }
+
+ // special case: inline struct and array (not slice) literals
+ if isvaluelit(n) != 0 {
+ initplan(n)
+ q = n.Initplan
+ for i = 0; i < len(q.E); i++ {
+ e = entry(p)
+ *e = q.E[i]
+ e.Xoffset += xoffset
+ }
+
+ return
+ }
+
+ // add to plan
+ if n.Op == OLITERAL {
+ p.Lit += n.Type.Width
+ } else {
+ p.Expr += n.Type.Width
+ }
+
+ e = entry(p)
+ e.Xoffset = xoffset
+ e.Expr = n
+}
+
+func iszero(n *Node) int {
+ var l *NodeList
+
+ switch n.Op {
+ case OLITERAL:
+ switch n.Val.Ctype {
+ default:
+ Dump("unexpected literal", n)
+ Fatal("iszero")
+ fallthrough
+
+ case CTNIL:
+ return 1
+
+ case CTSTR:
+ return bool2int(n.Val.U.Sval == nil || len(n.Val.U.Sval.S) == 0)
+
+ case CTBOOL:
+ return bool2int(n.Val.U.Bval == 0)
+
+ case CTINT,
+ CTRUNE:
+ return bool2int(mpcmpfixc(n.Val.U.Xval, 0) == 0)
+
+ case CTFLT:
+ return bool2int(mpcmpfltc(n.Val.U.Fval, 0) == 0)
+
+ case CTCPLX:
+ return bool2int(mpcmpfltc(&n.Val.U.Cval.Real, 0) == 0 && mpcmpfltc(&n.Val.U.Cval.Imag, 0) == 0)
+ }
+
+ case OARRAYLIT:
+ if Isslice(n.Type) != 0 {
+ break
+ }
+ fallthrough
+
+ // fall through
+ case OSTRUCTLIT:
+ for l = n.List; l != nil; l = l.Next {
+ if !(iszero(l.N.Right) != 0) {
+ return 0
+ }
+ }
+ return 1
+ }
+
+ return 0
+}
+
+func isvaluelit(n *Node) int {
+ return bool2int((n.Op == OARRAYLIT && Isfixedarray(n.Type) != 0) || n.Op == OSTRUCTLIT)
+}
+
+func entry(p *InitPlan) *InitEntry {
+ p.E = append(p.E, InitEntry{})
+ return &p.E[len(p.E)-1]
+}
+
+func gen_as_init(n *Node) int {
+ var nr *Node
+ var nl *Node
+ var nam Node
+ var nod1 Node
+
+ if n.Dodata == 0 {
+ goto no
+ }
+
+ nr = n.Right
+ nl = n.Left
+ if nr == nil {
+ if !(stataddr(&nam, nl) != 0) {
+ goto no
+ }
+ if nam.Class != PEXTERN {
+ goto no
+ }
+ goto yes
+ }
+
+ if nr.Type == nil || !Eqtype(nl.Type, nr.Type) {
+ goto no
+ }
+
+ if !(stataddr(&nam, nl) != 0) {
+ goto no
+ }
+
+ if nam.Class != PEXTERN {
+ goto no
+ }
+
+ switch nr.Op {
+ default:
+ goto no
+
+ case OCONVNOP:
+ nr = nr.Left
+ if nr == nil || nr.Op != OSLICEARR {
+ goto no
+ }
+ fallthrough
+
+ // fall through
+ case OSLICEARR:
+ if nr.Right.Op == OKEY && nr.Right.Left == nil && nr.Right.Right == nil {
+ nr = nr.Left
+ goto slice
+ }
+
+ goto no
+
+ case OLITERAL:
+ break
+ }
+
+ switch nr.Type.Etype {
+ default:
+ goto no
+
+ case TBOOL,
+ TINT8,
+ TUINT8,
+ TINT16,
+ TUINT16,
+ TINT32,
+ TUINT32,
+ TINT64,
+ TUINT64,
+ TINT,
+ TUINT,
+ TUINTPTR,
+ TPTR32,
+ TPTR64,
+ TFLOAT32,
+ TFLOAT64:
+ gdata(&nam, nr, int(nr.Type.Width))
+
+ case TCOMPLEX64,
+ TCOMPLEX128:
+ gdatacomplex(&nam, nr.Val.U.Cval)
+
+ case TSTRING:
+ gdatastring(&nam, nr.Val.U.Sval)
+ }
+
+yes:
+ return 1
+
+slice:
+ gused(nil) // in case the data is the dest of a goto
+ nl = nr
+ if nr == nil || nr.Op != OADDR {
+ goto no
+ }
+ nr = nr.Left
+ if nr == nil || nr.Op != ONAME {
+ goto no
+ }
+
+ // nr is the array being converted to a slice
+ if nr.Type == nil || nr.Type.Etype != TARRAY || nr.Type.Bound < 0 {
+ goto no
+ }
+
+ nam.Xoffset += int64(Array_array)
+ gdata(&nam, nl, int(Types[Tptr].Width))
+
+ nam.Xoffset += int64(Array_nel) - int64(Array_array)
+ Nodconst(&nod1, Types[TINT], nr.Type.Bound)
+ gdata(&nam, &nod1, Widthint)
+
+ nam.Xoffset += int64(Array_cap) - int64(Array_nel)
+ gdata(&nam, &nod1, Widthint)
+
+ goto yes
+
+no:
+ if n.Dodata == 2 {
+ Dump("\ngen_as_init", n)
+ Fatal("gen_as_init couldnt make data statement")
+ }
+
+ return 0
+}
diff --git a/src/cmd/internal/gc/subr.go b/src/cmd/internal/gc/subr.go
new file mode 100644
index 0000000..c28bfbd
--- /dev/null
+++ b/src/cmd/internal/gc/subr.go
@@ -0,0 +1,3932 @@
+// 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
+
+import (
+ "bytes"
+ "cmd/internal/obj"
+ "fmt"
+ "os"
+ "sort"
+ "strings"
+ "unicode"
+ "unicode/utf8"
+)
+
+type Error struct {
+ lineno int
+ seq int
+ msg string
+}
+
+var errors []Error
+
+var nerr int
+
+var merr int
+
+func errorexit() {
+ Flusherrors()
+ if outfile != "" {
+ os.Remove(outfile)
+ }
+ os.Exit(2)
+}
+
+func parserline() int {
+ if yychar_subr != 0 && yychar_subr != -2 { // parser has one symbol lookahead
+ return int(prevlineno)
+ }
+ return int(lineno)
+}
+
+func adderrorname(n *Node) {
+ var old string
+
+ if n.Op != ODOT {
+ return
+ }
+ old = fmt.Sprintf("%v: undefined: %v\n", n.Line(), Nconv(n.Left, 0))
+ if len(errors) > 0 && int32(errors[len(errors)-1].lineno) == n.Lineno && errors[len(errors)-1].msg == old {
+ errors[len(errors)-1].msg = fmt.Sprintf("%v: undefined: %v in %v\n", n.Line(), Nconv(n.Left, 0), Nconv(n, 0))
+ }
+}
+
+func adderr(line int, format string, args []interface{}) {
+ errors = append(errors, Error{
+ seq: len(errors),
+ lineno: line,
+ msg: fmt.Sprintf("%v: %s\n", Ctxt.Line(line), fmt.Sprintf(format, args...)),
+ })
+}
+
+type errcmp []Error
+
+func (x errcmp) Len() int {
+ return len(x)
+}
+
+func (x errcmp) Swap(i, j int) {
+ x[i], x[j] = x[j], x[i]
+}
+
+func (x errcmp) Less(i, j int) bool {
+ var a *Error
+ var b *Error
+
+ a = &x[i]
+ b = &x[j]
+ if a.lineno != b.lineno {
+ return a.lineno-b.lineno < 0
+ }
+ if a.seq != b.seq {
+ return a.seq-b.seq < 0
+ }
+ return stringsCompare(a.msg, b.msg) < 0
+}
+
+func Flusherrors() {
+ var i int
+
+ obj.Bflush(&bstdout)
+ if len(errors) == 0 {
+ return
+ }
+ sort.Sort(errcmp(errors[:len(errors)]))
+ for i = 0; i < len(errors); i++ {
+ if i == 0 || errors[i].msg != errors[i-1].msg {
+ fmt.Printf("%s", errors[i].msg)
+ }
+ }
+ errors = errors[:0]
+}
+
+func hcrash() {
+ if Debug['h'] != 0 {
+ Flusherrors()
+ if outfile != "" {
+ os.Remove(outfile)
+ }
+ var x *int
+ *x = 0
+ }
+}
+
+func yyerrorl(line int, fmt_ string, args ...interface{}) {
+ adderr(line, fmt_, args)
+
+ hcrash()
+ nerrors++
+ if nsavederrors+nerrors >= 10 && !(Debug['e'] != 0) {
+ Flusherrors()
+ fmt.Printf("%v: too many errors\n", Ctxt.Line(line))
+ errorexit()
+ }
+}
+
+var yystate int
+
+var yychar_subr int
+
+var yyerror_lastsyntax int
+
+func Yyerror(fmt_ string, args ...interface{}) {
+ var i int
+
+ if strings.HasPrefix(fmt_, "syntax error") {
+ nsyntaxerrors++
+
+ if Debug['x'] != 0 {
+ fmt.Printf("yyerror: yystate=%d yychar=%d\n", yystate, yychar_subr)
+ }
+
+ // An unexpected EOF caused a syntax error. Use the previous
+ // line number since getc generated a fake newline character.
+ if curio.eofnl != 0 {
+ lexlineno = prevlineno
+ }
+
+ // only one syntax error per line
+ if int32(yyerror_lastsyntax) == lexlineno {
+ return
+ }
+ yyerror_lastsyntax = int(lexlineno)
+
+ if strings.Contains(fmt_, "{ or {") || strings.Contains(fmt_, " or ?") || strings.Contains(fmt_, " or @") {
+ // The grammar has { and LBRACE but both show up as {.
+ // Rewrite syntax error referring to "{ or {" to say just "{".
+ // The grammar has ? and @ but only for reading imports.
+ // Silence them in ordinary errors.
+ fmt_ = strings.Replace(fmt_, "{ or {", "{", -1)
+ fmt_ = strings.Replace(fmt_, " or ?", "", -1)
+ fmt_ = strings.Replace(fmt_, " or @", "", -1)
+ }
+
+ // look for parse state-specific errors in list (see go.errors).
+ for i = 0; i < len(yymsg); i++ {
+ if yymsg[i].yystate == yystate && yymsg[i].yychar == yychar_subr {
+ yyerrorl(int(lexlineno), "syntax error: %s", yymsg[i].msg)
+ return
+ }
+ }
+
+ // plain "syntax error" gets "near foo" added
+ if fmt_ == "syntax error" {
+ yyerrorl(int(lexlineno), "syntax error near %s", lexbuf.String())
+ return
+ }
+
+ // if bison says "syntax error, more info"; print "syntax error: more info".
+ if fmt_[12] == ',' {
+ yyerrorl(int(lexlineno), "syntax error:%s", fmt_[13:])
+ return
+ }
+
+ yyerrorl(int(lexlineno), "%s", fmt_)
+ return
+ }
+
+ adderr(parserline(), fmt_, args)
+
+ hcrash()
+ nerrors++
+ if nsavederrors+nerrors >= 10 && !(Debug['e'] != 0) {
+ Flusherrors()
+ fmt.Printf("%v: too many errors\n", Ctxt.Line(parserline()))
+ errorexit()
+ }
+}
+
+func Warn(fmt_ string, args ...interface{}) {
+
+ adderr(parserline(), fmt_, args)
+
+ hcrash()
+}
+
+func Warnl(line int, fmt_ string, args ...interface{}) {
+ adderr(line, fmt_, args)
+ if Debug['m'] != 0 {
+ Flusherrors()
+ }
+}
+
+func Fatal(fmt_ string, args ...interface{}) {
+
+ Flusherrors()
+
+ fmt.Printf("%v: internal compiler error: ", Ctxt.Line(int(lineno)))
+ fmt.Printf(fmt_, args...)
+ fmt.Printf("\n")
+
+ // If this is a released compiler version, ask for a bug report.
+ if strings.HasPrefix(obj.Getgoversion(), "release") {
+ fmt.Printf("\n")
+ fmt.Printf("Please file a bug report including a short program that triggers the error.\n")
+ fmt.Printf("https://golang.org/issue/new\n")
+ }
+
+ hcrash()
+ errorexit()
+}
+
+func linehist(file string, off int32, relative int) {
+ if Debug['i'] != 0 {
+ if file != "" {
+ if off < 0 {
+ fmt.Printf("pragma %s", file)
+ } else if off > 0 {
+ fmt.Printf("line %s", file)
+ } else {
+ fmt.Printf("import %s", file)
+ }
+ } else {
+ fmt.Printf("end of import")
+ }
+ fmt.Printf(" at line %v\n", Ctxt.Line(int(lexlineno)))
+ }
+
+ if off < 0 && file[0] != '/' && !(relative != 0) {
+ file = fmt.Sprintf("%s/%s", Ctxt.Pathname, file)
+ }
+ obj.Linklinehist(Ctxt, int(lexlineno), file, int(off))
+}
+
+func setlineno(n *Node) int32 {
+ var lno int32
+
+ lno = lineno
+ if n != nil {
+ switch n.Op {
+ case ONAME,
+ OTYPE,
+ OPACK,
+ OLITERAL:
+ break
+
+ default:
+ lineno = n.Lineno
+ if lineno == 0 {
+ if Debug['K'] != 0 {
+ Warn("setlineno: line 0")
+ }
+ lineno = lno
+ }
+ }
+ }
+
+ return lno
+}
+
+func stringhash(p string) uint32 {
+ var h uint32
+ var c int
+
+ h = 0
+ for {
+ c, p = intstarstringplusplus(p)
+ if c == 0 {
+ break
+ }
+ h = h*PRIME1 + uint32(c)
+ }
+
+ if int32(h) < 0 {
+ h = -h
+ if int32(h) < 0 {
+ h = 0
+ }
+ }
+
+ return h
+}
+
+func Lookup(name string) *Sym {
+ return Pkglookup(name, localpkg)
+}
+
+func Pkglookup(name string, pkg *Pkg) *Sym {
+ var s *Sym
+ var h uint32
+ var c int
+
+ h = stringhash(name) % NHASH
+ c = int(name[0])
+ for s = hash[h]; s != nil; s = s.Link {
+ if int(s.Name[0]) != c || s.Pkg != pkg {
+ continue
+ }
+ if s.Name == name {
+ return s
+ }
+ }
+
+ s = new(Sym)
+ s.Name = name
+
+ s.Pkg = pkg
+
+ s.Link = hash[h]
+ hash[h] = s
+ s.Lexical = LNAME
+
+ return s
+}
+
+func restrictlookup(name string, pkg *Pkg) *Sym {
+ if !exportname(name) && pkg != localpkg {
+ Yyerror("cannot refer to unexported name %s.%s", pkg.Name, name)
+ }
+ return Pkglookup(name, pkg)
+}
+
+// find all the exported symbols in package opkg
+// and make them available in the current package
+func importdot(opkg *Pkg, pack *Node) {
+ var s *Sym
+ var s1 *Sym
+ var h uint32
+ var n int
+ var pkgerror string
+
+ n = 0
+ for h = 0; h < NHASH; h++ {
+ for s = hash[h]; s != nil; s = s.Link {
+ if s.Pkg != opkg {
+ continue
+ }
+ if s.Def == nil {
+ continue
+ }
+ if !exportname(s.Name) || strings.ContainsRune(s.Name, 0xb7) { // 0xb7 = center dot
+ continue
+ }
+ s1 = Lookup(s.Name)
+ if s1.Def != nil {
+ pkgerror = fmt.Sprintf("during import \"%v\"", Zconv(opkg.Path, 0))
+ redeclare(s1, pkgerror)
+ continue
+ }
+
+ s1.Def = s.Def
+ s1.Block = s.Block
+ s1.Def.Pack = pack
+ s1.Origpkg = opkg
+ n++
+ }
+ }
+
+ if n == 0 {
+ // can't possibly be used - there were no symbols
+ yyerrorl(int(pack.Lineno), "imported and not used: \"%v\"", Zconv(opkg.Path, 0))
+ }
+}
+
+func Nod(op int, nleft *Node, nright *Node) *Node {
+ var n *Node
+
+ n = new(Node)
+ n.Op = uint8(op)
+ n.Left = nleft
+ n.Right = nright
+ n.Lineno = int32(parserline())
+ n.Xoffset = BADWIDTH
+ n.Orig = n
+ n.Curfn = Curfn
+ return n
+}
+
+func saveorignode(n *Node) {
+ var norig *Node
+
+ if n.Orig != nil {
+ return
+ }
+ norig = Nod(int(n.Op), nil, nil)
+ *norig = *n
+ n.Orig = norig
+}
+
+// ispaddedfield reports whether the given field
+// is followed by padding. For the case where t is
+// the last field, total gives the size of the enclosing struct.
+func ispaddedfield(t *Type, total int64) int {
+ if t.Etype != TFIELD {
+ Fatal("ispaddedfield called non-field %v", Tconv(t, 0))
+ }
+ if t.Down == nil {
+ return bool2int(t.Width+t.Type.Width != total)
+ }
+ return bool2int(t.Width+t.Type.Width != t.Down.Width)
+}
+
+func algtype1(t *Type, bad **Type) int {
+ var a int
+ var ret int
+ var t1 *Type
+
+ if bad != nil {
+ *bad = nil
+ }
+ if t.Broke != 0 {
+ return AMEM
+ }
+ if t.Noalg != 0 {
+ return ANOEQ
+ }
+
+ switch t.Etype {
+ // will be defined later.
+ case TANY,
+ TFORW:
+ *bad = t
+
+ return -1
+
+ case TINT8,
+ TUINT8,
+ TINT16,
+ TUINT16,
+ TINT32,
+ TUINT32,
+ TINT64,
+ TUINT64,
+ TINT,
+ TUINT,
+ TUINTPTR,
+ TBOOL,
+ TPTR32,
+ TPTR64,
+ TCHAN,
+ TUNSAFEPTR:
+ return AMEM
+
+ case TFUNC,
+ TMAP:
+ if bad != nil {
+ *bad = t
+ }
+ return ANOEQ
+
+ case TFLOAT32:
+ return AFLOAT32
+
+ case TFLOAT64:
+ return AFLOAT64
+
+ case TCOMPLEX64:
+ return ACPLX64
+
+ case TCOMPLEX128:
+ return ACPLX128
+
+ case TSTRING:
+ return ASTRING
+
+ case TINTER:
+ if isnilinter(t) != 0 {
+ return ANILINTER
+ }
+ return AINTER
+
+ case TARRAY:
+ if Isslice(t) != 0 {
+ if bad != nil {
+ *bad = t
+ }
+ return ANOEQ
+ }
+
+ a = algtype1(t.Type, bad)
+ if a == ANOEQ || a == AMEM {
+ if a == ANOEQ && bad != nil {
+ *bad = t
+ }
+ return a
+ }
+
+ return -1 // needs special compare
+
+ case TSTRUCT:
+ if t.Type != nil && t.Type.Down == nil && !isblanksym(t.Type.Sym) {
+ // One-field struct is same as that one field alone.
+ return algtype1(t.Type.Type, bad)
+ }
+
+ ret = AMEM
+ for t1 = t.Type; t1 != nil; t1 = t1.Down {
+ // All fields must be comparable.
+ a = algtype1(t1.Type, bad)
+
+ if a == ANOEQ {
+ return ANOEQ
+ }
+
+ // Blank fields, padded fields, fields with non-memory
+ // equality need special compare.
+ if a != AMEM || isblanksym(t1.Sym) || ispaddedfield(t1, t.Width) != 0 {
+ ret = -1
+ continue
+ }
+ }
+
+ return ret
+ }
+
+ Fatal("algtype1: unexpected type %v", Tconv(t, 0))
+ return 0
+}
+
+func algtype(t *Type) int {
+ var a int
+
+ a = algtype1(t, nil)
+ if a == AMEM || a == ANOEQ {
+ if Isslice(t) != 0 {
+ return ASLICE
+ }
+ switch t.Width {
+ case 0:
+ return a + AMEM0 - AMEM
+
+ case 1:
+ return a + AMEM8 - AMEM
+
+ case 2:
+ return a + AMEM16 - AMEM
+
+ case 4:
+ return a + AMEM32 - AMEM
+
+ case 8:
+ return a + AMEM64 - AMEM
+
+ case 16:
+ return a + AMEM128 - AMEM
+ }
+ }
+
+ return a
+}
+
+func maptype(key *Type, val *Type) *Type {
+ var t *Type
+ var bad *Type
+ var atype int
+ var mtype int
+
+ if key != nil {
+ atype = algtype1(key, &bad)
+ if bad == nil {
+ mtype = int(key.Etype)
+ } else {
+ mtype = int(bad.Etype)
+ }
+ switch mtype {
+ default:
+ if atype == ANOEQ {
+ Yyerror("invalid map key type %v", Tconv(key, 0))
+ }
+
+ // will be resolved later.
+ case TANY:
+ break
+
+ // map[key] used during definition of key.
+ // postpone check until key is fully defined.
+ // if there are multiple uses of map[key]
+ // before key is fully defined, the error
+ // will only be printed for the first one.
+ // good enough.
+ case TFORW:
+ if key.Maplineno == 0 {
+ key.Maplineno = lineno
+ }
+ }
+ }
+
+ t = typ(TMAP)
+ t.Down = key
+ t.Type = val
+ return t
+}
+
+func typ(et int) *Type {
+ var t *Type
+
+ t = new(Type)
+ t.Etype = uint8(et)
+ t.Width = BADWIDTH
+ t.Lineno = int(lineno)
+ t.Orig = t
+ return t
+}
+
+type methcmp []*Type
+
+func (x methcmp) Len() int {
+ return len(x)
+}
+
+func (x methcmp) Swap(i, j int) {
+ x[i], x[j] = x[j], x[i]
+}
+
+func (x methcmp) Less(i, j int) bool {
+ var a *Type
+ var b *Type
+ var k int
+
+ a = x[i]
+ b = x[j]
+ if a.Sym == nil && b.Sym == nil {
+ return false
+ }
+ if a.Sym == nil {
+ return true
+ }
+ if b.Sym == nil {
+ return 1 < 0
+ }
+ k = stringsCompare(a.Sym.Name, b.Sym.Name)
+ if k != 0 {
+ return k < 0
+ }
+ if !exportname(a.Sym.Name) {
+ k = stringsCompare(a.Sym.Pkg.Path.S, b.Sym.Pkg.Path.S)
+ if k != 0 {
+ return k < 0
+ }
+ }
+
+ return false
+}
+
+func sortinter(t *Type) *Type {
+ var f *Type
+ var i int
+ var a []*Type
+
+ if t.Type == nil || t.Type.Down == nil {
+ return t
+ }
+
+ i = 0
+ for f = t.Type; f != nil; f = f.Down {
+ i++
+ }
+ a = make([]*Type, i)
+ i = 0
+ for f = t.Type; f != nil; f = f.Down {
+ a[i] = f
+ i++
+ }
+ sort.Sort(methcmp(a[:i]))
+ for {
+ tmp11 := i
+ i--
+ if !(tmp11 > 0) {
+ break
+ }
+ a[i].Down = f
+ f = a[i]
+ }
+
+ t.Type = f
+ return t
+}
+
+func Nodintconst(v int64) *Node {
+ var c *Node
+
+ c = Nod(OLITERAL, nil, nil)
+ c.Addable = 1
+ c.Val.U.Xval = new(Mpint)
+ Mpmovecfix(c.Val.U.Xval, v)
+ c.Val.Ctype = CTINT
+ c.Type = Types[TIDEAL]
+ ullmancalc(c)
+ return c
+}
+
+func nodfltconst(v *Mpflt) *Node {
+ var c *Node
+
+ c = Nod(OLITERAL, nil, nil)
+ c.Addable = 1
+ c.Val.U.Fval = new(Mpflt)
+ mpmovefltflt(c.Val.U.Fval, v)
+ c.Val.Ctype = CTFLT
+ c.Type = Types[TIDEAL]
+ ullmancalc(c)
+ return c
+}
+
+func Nodconst(n *Node, t *Type, v int64) {
+ *n = Node{}
+ n.Op = OLITERAL
+ n.Addable = 1
+ ullmancalc(n)
+ n.Val.U.Xval = new(Mpint)
+ Mpmovecfix(n.Val.U.Xval, v)
+ n.Val.Ctype = CTINT
+ n.Type = t
+
+ if Isfloat[t.Etype] != 0 {
+ Fatal("nodconst: bad type %v", Tconv(t, 0))
+ }
+}
+
+func nodnil() *Node {
+ var c *Node
+
+ c = Nodintconst(0)
+ c.Val.Ctype = CTNIL
+ c.Type = Types[TNIL]
+ return c
+}
+
+func Nodbool(b int) *Node {
+ var c *Node
+
+ c = Nodintconst(0)
+ c.Val.Ctype = CTBOOL
+ c.Val.U.Bval = int16(b)
+ c.Type = idealbool
+ return c
+}
+
+func aindex(b *Node, t *Type) *Type {
+ var r *Type
+ var bound int64
+
+ bound = -1 // open bound
+ typecheck(&b, Erv)
+ if b != nil {
+ switch consttype(b) {
+ default:
+ Yyerror("array bound must be an integer expression")
+
+ case CTINT,
+ CTRUNE:
+ bound = Mpgetfix(b.Val.U.Xval)
+ if bound < 0 {
+ Yyerror("array bound must be non negative")
+ }
+ }
+ }
+
+ // fixed array
+ r = typ(TARRAY)
+
+ r.Type = t
+ r.Bound = bound
+ return r
+}
+
+func treecopy(n *Node) *Node {
+ var m *Node
+
+ if n == nil {
+ return nil
+ }
+
+ switch n.Op {
+ default:
+ m = Nod(OXXX, nil, nil)
+ *m = *n
+ m.Orig = m
+ m.Left = treecopy(n.Left)
+ m.Right = treecopy(n.Right)
+ m.List = listtreecopy(n.List)
+ if m.Defn != nil {
+ panic("abort")
+ }
+
+ case ONONAME:
+ if n.Sym == Lookup("iota") {
+ // Not sure yet whether this is the real iota,
+ // but make a copy of the Node* just in case,
+ // so that all the copies of this const definition
+ // don't have the same iota value.
+ m = Nod(OXXX, nil, nil)
+
+ *m = *n
+ m.Iota = iota_
+ break
+ }
+ fallthrough
+
+ // fall through
+ case ONAME,
+ OLITERAL,
+ OTYPE:
+ m = n
+ }
+
+ return m
+}
+
+func isnil(n *Node) int {
+ if n == nil {
+ return 0
+ }
+ if n.Op != OLITERAL {
+ return 0
+ }
+ if n.Val.Ctype != CTNIL {
+ return 0
+ }
+ return 1
+}
+
+func isptrto(t *Type, et int) int {
+ if t == nil {
+ return 0
+ }
+ if !(Isptr[t.Etype] != 0) {
+ return 0
+ }
+ t = t.Type
+ if t == nil {
+ return 0
+ }
+ if int(t.Etype) != et {
+ return 0
+ }
+ return 1
+}
+
+func Istype(t *Type, et int) int {
+ return bool2int(t != nil && int(t.Etype) == et)
+}
+
+func Isfixedarray(t *Type) int {
+ return bool2int(t != nil && t.Etype == TARRAY && t.Bound >= 0)
+}
+
+func Isslice(t *Type) int {
+ return bool2int(t != nil && t.Etype == TARRAY && t.Bound < 0)
+}
+
+func isblank(n *Node) bool {
+ if n == nil {
+ return false
+ }
+ return isblanksym(n.Sym)
+}
+
+func isblanksym(s *Sym) bool {
+ return s != nil && s.Name == "_"
+}
+
+func Isinter(t *Type) int {
+ return bool2int(t != nil && t.Etype == TINTER)
+}
+
+func isnilinter(t *Type) int {
+ if !(Isinter(t) != 0) {
+ return 0
+ }
+ if t.Type != nil {
+ return 0
+ }
+ return 1
+}
+
+func isideal(t *Type) int {
+ if t == nil {
+ return 0
+ }
+ if t == idealstring || t == idealbool {
+ return 1
+ }
+ switch t.Etype {
+ case TNIL,
+ TIDEAL:
+ return 1
+ }
+
+ return 0
+}
+
+/*
+ * given receiver of type t (t == r or t == *r)
+ * return type to hang methods off (r).
+ */
+func methtype(t *Type, mustname int) *Type {
+ if t == nil {
+ return nil
+ }
+
+ // strip away pointer if it's there
+ if Isptr[t.Etype] != 0 {
+ if t.Sym != nil {
+ return nil
+ }
+ t = t.Type
+ if t == nil {
+ return nil
+ }
+ }
+
+ // need a type name
+ if t.Sym == nil && (mustname != 0 || t.Etype != TSTRUCT) {
+ return nil
+ }
+
+ // check types
+ if !(issimple[t.Etype] != 0) {
+ switch t.Etype {
+ default:
+ return nil
+
+ case TSTRUCT,
+ TARRAY,
+ TMAP,
+ TCHAN,
+ TSTRING,
+ TFUNC:
+ break
+ }
+ }
+
+ return t
+}
+
+func cplxsubtype(et int) int {
+ switch et {
+ case TCOMPLEX64:
+ return TFLOAT32
+
+ case TCOMPLEX128:
+ return TFLOAT64
+ }
+
+ Fatal("cplxsubtype: %v\n", Econv(int(et), 0))
+ return 0
+}
+
+func eqnote(a, b *Strlit) bool {
+ return a == b || a != nil && b != nil && a.S == b.S
+}
+
+type TypePairList struct {
+ t1 *Type
+ t2 *Type
+ next *TypePairList
+}
+
+func onlist(l *TypePairList, t1 *Type, t2 *Type) int {
+ for ; l != nil; l = l.next {
+ if (l.t1 == t1 && l.t2 == t2) || (l.t1 == t2 && l.t2 == t1) {
+ return 1
+ }
+ }
+ return 0
+}
+
+// Return 1 if t1 and t2 are identical, following the spec rules.
+//
+// Any cyclic type must go through a named type, and if one is
+// named, it is only identical to the other if they are the same
+// pointer (t1 == t2), so there's no chance of chasing cycles
+// ad infinitum, so no need for a depth counter.
+func Eqtype(t1 *Type, t2 *Type) bool {
+ return eqtype1(t1, t2, nil) != 0
+}
+
+func eqtype1(t1 *Type, t2 *Type, assumed_equal *TypePairList) int {
+ var l TypePairList
+
+ if t1 == t2 {
+ return 1
+ }
+ if t1 == nil || t2 == nil || t1.Etype != t2.Etype {
+ return 0
+ }
+ if t1.Sym != nil || t2.Sym != nil {
+ // Special case: we keep byte and uint8 separate
+ // for error messages. Treat them as equal.
+ switch t1.Etype {
+ case TUINT8:
+ if (t1 == Types[TUINT8] || t1 == bytetype) && (t2 == Types[TUINT8] || t2 == bytetype) {
+ return 1
+ }
+
+ case TINT,
+ TINT32:
+ if (t1 == Types[runetype.Etype] || t1 == runetype) && (t2 == Types[runetype.Etype] || t2 == runetype) {
+ return 1
+ }
+ }
+
+ return 0
+ }
+
+ if onlist(assumed_equal, t1, t2) != 0 {
+ return 1
+ }
+ l.next = assumed_equal
+ l.t1 = t1
+ l.t2 = t2
+
+ switch t1.Etype {
+ case TINTER,
+ TSTRUCT:
+ t1 = t1.Type
+ t2 = t2.Type
+ for ; t1 != nil && t2 != nil; (func() { t1 = t1.Down; t2 = t2.Down })() {
+ if t1.Etype != TFIELD || t2.Etype != TFIELD {
+ Fatal("struct/interface missing field: %v %v", Tconv(t1, 0), Tconv(t2, 0))
+ }
+ if t1.Sym != t2.Sym || t1.Embedded != t2.Embedded || !(eqtype1(t1.Type, t2.Type, &l) != 0) || !eqnote(t1.Note, t2.Note) {
+ goto no
+ }
+ }
+
+ if t1 == nil && t2 == nil {
+ goto yes
+ }
+ goto no
+
+ // Loop over structs: receiver, in, out.
+ case TFUNC:
+ t1 = t1.Type
+ t2 = t2.Type
+ for ; t1 != nil && t2 != nil; (func() { t1 = t1.Down; t2 = t2.Down })() {
+ var ta *Type
+ var tb *Type
+
+ if t1.Etype != TSTRUCT || t2.Etype != TSTRUCT {
+ Fatal("func missing struct: %v %v", Tconv(t1, 0), Tconv(t2, 0))
+ }
+
+ // Loop over fields in structs, ignoring argument names.
+ ta = t1.Type
+ tb = t2.Type
+ for ; ta != nil && tb != nil; (func() { ta = ta.Down; tb = tb.Down })() {
+ if ta.Etype != TFIELD || tb.Etype != TFIELD {
+ Fatal("func struct missing field: %v %v", Tconv(ta, 0), Tconv(tb, 0))
+ }
+ if ta.Isddd != tb.Isddd || !(eqtype1(ta.Type, tb.Type, &l) != 0) {
+ goto no
+ }
+ }
+
+ if ta != nil || tb != nil {
+ goto no
+ }
+ }
+
+ if t1 == nil && t2 == nil {
+ goto yes
+ }
+ goto no
+
+ case TARRAY:
+ if t1.Bound != t2.Bound {
+ goto no
+ }
+
+ case TCHAN:
+ if t1.Chan != t2.Chan {
+ goto no
+ }
+ }
+
+ if eqtype1(t1.Down, t2.Down, &l) != 0 && eqtype1(t1.Type, t2.Type, &l) != 0 {
+ goto yes
+ }
+ goto no
+
+yes:
+ return 1
+
+no:
+ return 0
+}
+
+// Are t1 and t2 equal struct types when field names are ignored?
+// For deciding whether the result struct from g can be copied
+// directly when compiling f(g()).
+func eqtypenoname(t1 *Type, t2 *Type) int {
+ if t1 == nil || t2 == nil || t1.Etype != TSTRUCT || t2.Etype != TSTRUCT {
+ return 0
+ }
+
+ t1 = t1.Type
+ t2 = t2.Type
+ for {
+ if !Eqtype(t1, t2) {
+ return 0
+ }
+ if t1 == nil {
+ return 1
+ }
+ t1 = t1.Down
+ t2 = t2.Down
+ }
+}
+
+// Is type src assignment compatible to type dst?
+// If so, return op code to use in conversion.
+// If not, return 0.
+func assignop(src *Type, dst *Type, why *string) int {
+ var missing *Type
+ var have *Type
+ var ptr int
+
+ if why != nil {
+ *why = ""
+ }
+
+ // TODO(rsc,lvd): This behaves poorly in the presence of inlining.
+ // https://golang.org/issue/2795
+ if safemode != 0 && importpkg == nil && src != nil && src.Etype == TUNSAFEPTR {
+ Yyerror("cannot use unsafe.Pointer")
+ errorexit()
+ }
+
+ if src == dst {
+ return OCONVNOP
+ }
+ if src == nil || dst == nil || src.Etype == TFORW || dst.Etype == TFORW || src.Orig == nil || dst.Orig == nil {
+ return 0
+ }
+
+ // 1. src type is identical to dst.
+ if Eqtype(src, dst) {
+ return OCONVNOP
+ }
+
+ // 2. src and dst have identical underlying types
+ // and either src or dst is not a named type or
+ // both are empty interface types.
+ // For assignable but different non-empty interface types,
+ // we want to recompute the itab.
+ if Eqtype(src.Orig, dst.Orig) && (src.Sym == nil || dst.Sym == nil || isnilinter(src) != 0) {
+ return OCONVNOP
+ }
+
+ // 3. dst is an interface type and src implements dst.
+ if dst.Etype == TINTER && src.Etype != TNIL {
+ if implements(src, dst, &missing, &have, &ptr) != 0 {
+ return OCONVIFACE
+ }
+
+ // we'll have complained about this method anyway, suppress spurious messages.
+ if have != nil && have.Sym == missing.Sym && (have.Type.Broke != 0 || missing.Type.Broke != 0) {
+ return OCONVIFACE
+ }
+
+ if why != nil {
+ if isptrto(src, TINTER) != 0 {
+ *why = fmt.Sprintf(":\n\t%v is pointer to interface, not interface", Tconv(src, 0))
+ } else if have != nil && have.Sym == missing.Sym && have.Nointerface != 0 {
+ *why = fmt.Sprintf(":\n\t%v does not implement %v (%v method is marked 'nointerface')", Tconv(src, 0), Tconv(dst, 0), Sconv(missing.Sym, 0))
+ } else if have != nil && have.Sym == missing.Sym {
+ *why = fmt.Sprintf(":\n\t%v does not implement %v (wrong type for %v method)\n"+"\t\thave %v%v\n\t\twant %v%v", Tconv(src, 0), Tconv(dst, 0), Sconv(missing.Sym, 0), Sconv(have.Sym, 0), Tconv(have.Type, obj.FmtShort|obj.FmtByte), Sconv(missing.Sym, 0), Tconv(missing.Type, obj.FmtShort|obj.FmtByte))
+ } else if ptr != 0 {
+ *why = fmt.Sprintf(":\n\t%v does not implement %v (%v method has pointer receiver)", Tconv(src, 0), Tconv(dst, 0), Sconv(missing.Sym, 0))
+ } else if have != nil {
+ *why = fmt.Sprintf(":\n\t%v does not implement %v (missing %v method)\n"+"\t\thave %v%v\n\t\twant %v%v", Tconv(src, 0), Tconv(dst, 0), Sconv(missing.Sym, 0), Sconv(have.Sym, 0), Tconv(have.Type, obj.FmtShort|obj.FmtByte), Sconv(missing.Sym, 0), Tconv(missing.Type, obj.FmtShort|obj.FmtByte))
+ } else {
+ *why = fmt.Sprintf(":\n\t%v does not implement %v (missing %v method)", Tconv(src, 0), Tconv(dst, 0), Sconv(missing.Sym, 0))
+ }
+ }
+
+ return 0
+ }
+
+ if isptrto(dst, TINTER) != 0 {
+ if why != nil {
+ *why = fmt.Sprintf(":\n\t%v is pointer to interface, not interface", Tconv(dst, 0))
+ }
+ return 0
+ }
+
+ if src.Etype == TINTER && dst.Etype != TBLANK {
+ if why != nil && implements(dst, src, &missing, &have, &ptr) != 0 {
+ *why = ": need type assertion"
+ }
+ return 0
+ }
+
+ // 4. src is a bidirectional channel value, dst is a channel type,
+ // src and dst have identical element types, and
+ // either src or dst is not a named type.
+ if src.Etype == TCHAN && src.Chan == Cboth && dst.Etype == TCHAN {
+ if Eqtype(src.Type, dst.Type) && (src.Sym == nil || dst.Sym == nil) {
+ return OCONVNOP
+ }
+ }
+
+ // 5. src is the predeclared identifier nil and dst is a nillable type.
+ if src.Etype == TNIL {
+ switch dst.Etype {
+ case TARRAY:
+ if dst.Bound != -100 { // not slice
+ break
+ }
+ fallthrough
+
+ case TPTR32,
+ TPTR64,
+ TFUNC,
+ TMAP,
+ TCHAN,
+ TINTER:
+ return OCONVNOP
+ }
+ }
+
+ // 6. rule about untyped constants - already converted by defaultlit.
+
+ // 7. Any typed value can be assigned to the blank identifier.
+ if dst.Etype == TBLANK {
+ return OCONVNOP
+ }
+
+ return 0
+}
+
+// Can we convert a value of type src to a value of type dst?
+// If so, return op code to use in conversion (maybe OCONVNOP).
+// If not, return 0.
+func convertop(src *Type, dst *Type, why *string) int {
+ var op int
+
+ if why != nil {
+ *why = ""
+ }
+
+ if src == dst {
+ return OCONVNOP
+ }
+ if src == nil || dst == nil {
+ return 0
+ }
+
+ // 1. src can be assigned to dst.
+ op = assignop(src, dst, why)
+ if op != 0 {
+ return op
+ }
+
+ // The rules for interfaces are no different in conversions
+ // than assignments. If interfaces are involved, stop now
+ // with the good message from assignop.
+ // Otherwise clear the error.
+ if src.Etype == TINTER || dst.Etype == TINTER {
+ return 0
+ }
+ if why != nil {
+ *why = ""
+ }
+
+ // 2. src and dst have identical underlying types.
+ if Eqtype(src.Orig, dst.Orig) {
+ return OCONVNOP
+ }
+
+ // 3. src and dst are unnamed pointer types
+ // and their base types have identical underlying types.
+ if Isptr[src.Etype] != 0 && Isptr[dst.Etype] != 0 && src.Sym == nil && dst.Sym == nil {
+ if Eqtype(src.Type.Orig, dst.Type.Orig) {
+ return OCONVNOP
+ }
+ }
+
+ // 4. src and dst are both integer or floating point types.
+ if (Isint[src.Etype] != 0 || Isfloat[src.Etype] != 0) && (Isint[dst.Etype] != 0 || Isfloat[dst.Etype] != 0) {
+ if Simtype[src.Etype] == Simtype[dst.Etype] {
+ return OCONVNOP
+ }
+ return OCONV
+ }
+
+ // 5. src and dst are both complex types.
+ if Iscomplex[src.Etype] != 0 && Iscomplex[dst.Etype] != 0 {
+ if Simtype[src.Etype] == Simtype[dst.Etype] {
+ return OCONVNOP
+ }
+ return OCONV
+ }
+
+ // 6. src is an integer or has type []byte or []rune
+ // and dst is a string type.
+ if Isint[src.Etype] != 0 && dst.Etype == TSTRING {
+ return ORUNESTR
+ }
+
+ if Isslice(src) != 0 && dst.Etype == TSTRING {
+ if src.Type.Etype == bytetype.Etype {
+ return OARRAYBYTESTR
+ }
+ if src.Type.Etype == runetype.Etype {
+ return OARRAYRUNESTR
+ }
+ }
+
+ // 7. src is a string and dst is []byte or []rune.
+ // String to slice.
+ if src.Etype == TSTRING && Isslice(dst) != 0 {
+ if dst.Type.Etype == bytetype.Etype {
+ return OSTRARRAYBYTE
+ }
+ if dst.Type.Etype == runetype.Etype {
+ return OSTRARRAYRUNE
+ }
+ }
+
+ // 8. src is a pointer or uintptr and dst is unsafe.Pointer.
+ if (Isptr[src.Etype] != 0 || src.Etype == TUINTPTR) && dst.Etype == TUNSAFEPTR {
+ return OCONVNOP
+ }
+
+ // 9. src is unsafe.Pointer and dst is a pointer or uintptr.
+ if src.Etype == TUNSAFEPTR && (Isptr[dst.Etype] != 0 || dst.Etype == TUINTPTR) {
+ return OCONVNOP
+ }
+
+ return 0
+}
+
+// Convert node n for assignment to type t.
+func assignconv(n *Node, t *Type, context string) *Node {
+ var op int
+ var r *Node
+ var old *Node
+ var why string
+
+ if n == nil || n.Type == nil || n.Type.Broke != 0 {
+ return n
+ }
+
+ if t.Etype == TBLANK && n.Type.Etype == TNIL {
+ Yyerror("use of untyped nil")
+ }
+
+ old = n
+ old.Diag++ // silence errors about n; we'll issue one below
+ defaultlit(&n, t)
+ old.Diag--
+ if t.Etype == TBLANK {
+ return n
+ }
+
+ // Convert ideal bool from comparison to plain bool
+ // if the next step is non-bool (like interface{}).
+ if n.Type == idealbool && t.Etype != TBOOL {
+ if n.Op == ONAME || n.Op == OLITERAL {
+ r = Nod(OCONVNOP, n, nil)
+ r.Type = Types[TBOOL]
+ r.Typecheck = 1
+ r.Implicit = 1
+ n = r
+ }
+ }
+
+ if Eqtype(n.Type, t) {
+ return n
+ }
+
+ op = assignop(n.Type, t, &why)
+ if op == 0 {
+ Yyerror("cannot use %v as type %v in %s%s", Nconv(n, obj.FmtLong), Tconv(t, 0), context, why)
+ op = OCONV
+ }
+
+ r = Nod(op, n, nil)
+ r.Type = t
+ r.Typecheck = 1
+ r.Implicit = 1
+ r.Orig = n.Orig
+ return r
+}
+
+func subtype(stp **Type, t *Type, d int) int {
+ var st *Type
+
+loop:
+ st = *stp
+ if st == nil {
+ return 0
+ }
+
+ d++
+ if d >= 10 {
+ return 0
+ }
+
+ switch st.Etype {
+ default:
+ return 0
+
+ case TPTR32,
+ TPTR64,
+ TCHAN,
+ TARRAY:
+ stp = &st.Type
+ goto loop
+
+ case TANY:
+ if !(st.Copyany != 0) {
+ return 0
+ }
+ *stp = t
+
+ case TMAP:
+ if subtype(&st.Down, t, d) != 0 {
+ break
+ }
+ stp = &st.Type
+ goto loop
+
+ case TFUNC:
+ for {
+ if subtype(&st.Type, t, d) != 0 {
+ break
+ }
+ if subtype(&st.Type.Down.Down, t, d) != 0 {
+ break
+ }
+ if subtype(&st.Type.Down, t, d) != 0 {
+ break
+ }
+ return 0
+ }
+
+ case TSTRUCT:
+ for st = st.Type; st != nil; st = st.Down {
+ if subtype(&st.Type, t, d) != 0 {
+ return 1
+ }
+ }
+ return 0
+ }
+
+ return 1
+}
+
+/*
+ * Is this a 64-bit type?
+ */
+func Is64(t *Type) int {
+ if t == nil {
+ return 0
+ }
+ switch Simtype[t.Etype] {
+ case TINT64,
+ TUINT64,
+ TPTR64:
+ return 1
+ }
+
+ return 0
+}
+
+/*
+ * Is a conversion between t1 and t2 a no-op?
+ */
+func Noconv(t1 *Type, t2 *Type) int {
+ var e1 int
+ var e2 int
+
+ e1 = int(Simtype[t1.Etype])
+ e2 = int(Simtype[t2.Etype])
+
+ switch e1 {
+ case TINT8,
+ TUINT8:
+ return bool2int(e2 == TINT8 || e2 == TUINT8)
+
+ case TINT16,
+ TUINT16:
+ return bool2int(e2 == TINT16 || e2 == TUINT16)
+
+ case TINT32,
+ TUINT32,
+ TPTR32:
+ return bool2int(e2 == TINT32 || e2 == TUINT32 || e2 == TPTR32)
+
+ case TINT64,
+ TUINT64,
+ TPTR64:
+ return bool2int(e2 == TINT64 || e2 == TUINT64 || e2 == TPTR64)
+
+ case TFLOAT32:
+ return bool2int(e2 == TFLOAT32)
+
+ case TFLOAT64:
+ return bool2int(e2 == TFLOAT64)
+ }
+
+ return 0
+}
+
+func argtype(on *Node, t *Type) {
+ dowidth(t)
+ if !(subtype(&on.Type, t, 0) != 0) {
+ Fatal("argtype: failed %v %v\n", Nconv(on, 0), Tconv(t, 0))
+ }
+}
+
+func shallow(t *Type) *Type {
+ var nt *Type
+
+ if t == nil {
+ return nil
+ }
+ nt = typ(0)
+ *nt = *t
+ if t.Orig == t {
+ nt.Orig = nt
+ }
+ return nt
+}
+
+func deep(t *Type) *Type {
+ var nt *Type
+ var xt *Type
+
+ if t == nil {
+ return nil
+ }
+
+ switch t.Etype {
+ default:
+ nt = t // share from here down
+
+ case TANY:
+ nt = shallow(t)
+ nt.Copyany = 1
+
+ case TPTR32,
+ TPTR64,
+ TCHAN,
+ TARRAY:
+ nt = shallow(t)
+ nt.Type = deep(t.Type)
+
+ case TMAP:
+ nt = shallow(t)
+ nt.Down = deep(t.Down)
+ nt.Type = deep(t.Type)
+
+ case TFUNC:
+ nt = shallow(t)
+ nt.Type = deep(t.Type)
+ nt.Type.Down = deep(t.Type.Down)
+ nt.Type.Down.Down = deep(t.Type.Down.Down)
+
+ case TSTRUCT:
+ nt = shallow(t)
+ nt.Type = shallow(t.Type)
+ xt = nt.Type
+
+ for t = t.Type; t != nil; t = t.Down {
+ xt.Type = deep(t.Type)
+ xt.Down = shallow(t.Down)
+ xt = xt.Down
+ }
+ }
+
+ return nt
+}
+
+func syslook(name string, copy int) *Node {
+ var s *Sym
+ var n *Node
+
+ s = Pkglookup(name, Runtimepkg)
+ if s == nil || s.Def == nil {
+ Fatal("syslook: can't find runtime.%s", name)
+ }
+
+ if !(copy != 0) {
+ return s.Def
+ }
+
+ n = Nod(0, nil, nil)
+ *n = *s.Def
+ n.Type = deep(s.Def.Type)
+
+ return n
+}
+
+/*
+ * compute a hash value for type t.
+ * if t is a method type, ignore the receiver
+ * so that the hash can be used in interface checks.
+ * %T already contains
+ * all the necessary logic to generate a representation
+ * of the type that completely describes it.
+ * using smprint here avoids duplicating that code.
+ * using md5 here is overkill, but i got tired of
+ * accidental collisions making the runtime think
+ * two types are equal when they really aren't.
+ */
+func typehash(t *Type) uint32 {
+ var p string
+ var d MD5
+
+ if t.Thistuple != 0 {
+ // hide method receiver from Tpretty
+ t.Thistuple = 0
+
+ p = fmt.Sprintf("%v", Tconv(t, obj.FmtLeft|obj.FmtUnsigned))
+ t.Thistuple = 1
+ } else {
+ p = fmt.Sprintf("%v", Tconv(t, obj.FmtLeft|obj.FmtUnsigned))
+ }
+
+ //print("typehash: %s\n", p);
+ md5reset(&d)
+
+ md5write(&d, []byte(p), len(p))
+
+ return uint32(md5sum(&d, nil))
+}
+
+func Ptrto(t *Type) *Type {
+ var t1 *Type
+
+ if Tptr == 0 {
+ Fatal("ptrto: no tptr")
+ }
+ t1 = typ(Tptr)
+ t1.Type = t
+ t1.Width = int64(Widthptr)
+ t1.Align = uint8(Widthptr)
+ return t1
+}
+
+func frame(context int) {
+ var l *NodeList
+ var n *Node
+ var w int64
+
+ if context != 0 {
+ fmt.Printf("--- external frame ---\n")
+ l = externdcl
+ } else if Curfn != nil {
+ fmt.Printf("--- %v frame ---\n", Sconv(Curfn.Nname.Sym, 0))
+ l = Curfn.Dcl
+ } else {
+ return
+ }
+
+ for ; l != nil; l = l.Next {
+ n = l.N
+ w = -1
+ if n.Type != nil {
+ w = n.Type.Width
+ }
+ switch n.Op {
+ case ONAME:
+ fmt.Printf("%v %v G%d %v width=%d\n", Oconv(int(n.Op), 0), Sconv(n.Sym, 0), n.Vargen, Tconv(n.Type, 0), w)
+
+ case OTYPE:
+ fmt.Printf("%v %v width=%d\n", Oconv(int(n.Op), 0), Tconv(n.Type, 0), w)
+ }
+ }
+}
+
+/*
+ * calculate sethi/ullman number
+ * roughly how many registers needed to
+ * compile a node. used to compile the
+ * hardest side first to minimize registers.
+ */
+func ullmancalc(n *Node) {
+ var ul int
+ var ur int
+
+ if n == nil {
+ return
+ }
+
+ if n.Ninit != nil {
+ ul = UINF
+ goto out
+ }
+
+ switch n.Op {
+ case OREGISTER,
+ OLITERAL,
+ ONAME:
+ ul = 1
+ if n.Class == PPARAMREF || (n.Class&PHEAP != 0) {
+ ul++
+ }
+ goto out
+
+ case OCALL,
+ OCALLFUNC,
+ OCALLMETH,
+ OCALLINTER:
+ ul = UINF
+ goto out
+
+ // hard with race detector
+ case OANDAND,
+ OOROR:
+ if flag_race != 0 {
+ ul = UINF
+ goto out
+ }
+ }
+
+ ul = 1
+ if n.Left != nil {
+ ul = int(n.Left.Ullman)
+ }
+ ur = 1
+ if n.Right != nil {
+ ur = int(n.Right.Ullman)
+ }
+ if ul == ur {
+ ul += 1
+ }
+ if ur > ul {
+ ul = ur
+ }
+
+out:
+ if ul > 200 {
+ ul = 200 // clamp to uchar with room to grow
+ }
+ n.Ullman = uint8(ul)
+}
+
+func badtype(o int, tl *Type, tr *Type) {
+ var fmt_ string
+ var s string
+
+ fmt_ = ""
+ if tl != nil {
+ fmt_ += fmt.Sprintf("\n\t%v", Tconv(tl, 0))
+ }
+ if tr != nil {
+ fmt_ += fmt.Sprintf("\n\t%v", Tconv(tr, 0))
+ }
+
+ // common mistake: *struct and *interface.
+ if tl != nil && tr != nil && Isptr[tl.Etype] != 0 && Isptr[tr.Etype] != 0 {
+ if tl.Type.Etype == TSTRUCT && tr.Type.Etype == TINTER {
+ fmt_ += fmt.Sprintf("\n\t(*struct vs *interface)")
+ } else if tl.Type.Etype == TINTER && tr.Type.Etype == TSTRUCT {
+ fmt_ += fmt.Sprintf("\n\t(*interface vs *struct)")
+ }
+ }
+
+ s = fmt_
+ Yyerror("illegal types for operand: %v%s", Oconv(int(o), 0), s)
+}
+
+/*
+ * iterator to walk a structure declaration
+ */
+func Structfirst(s *Iter, nn **Type) *Type {
+ var n *Type
+ var t *Type
+
+ n = *nn
+ if n == nil {
+ goto bad
+ }
+
+ switch n.Etype {
+ default:
+ goto bad
+
+ case TSTRUCT,
+ TINTER,
+ TFUNC:
+ break
+ }
+
+ t = n.Type
+ if t == nil {
+ goto rnil
+ }
+
+ if t.Etype != TFIELD {
+ Fatal("structfirst: not field %v", Tconv(t, 0))
+ }
+
+ s.T = t
+ return t
+
+bad:
+ Fatal("structfirst: not struct %v", Tconv(n, 0))
+
+rnil:
+ return nil
+}
+
+func structnext(s *Iter) *Type {
+ var n *Type
+ var t *Type
+
+ n = s.T
+ t = n.Down
+ if t == nil {
+ goto rnil
+ }
+
+ if t.Etype != TFIELD {
+ goto bad
+ }
+
+ s.T = t
+ return t
+
+bad:
+ Fatal("structnext: not struct %v", Tconv(n, 0))
+
+rnil:
+ return nil
+}
+
+/*
+ * iterator to this and inargs in a function
+ */
+func funcfirst(s *Iter, t *Type) *Type {
+ var fp *Type
+
+ if t == nil {
+ goto bad
+ }
+
+ if t.Etype != TFUNC {
+ goto bad
+ }
+
+ s.Tfunc = t
+ s.Done = 0
+ fp = Structfirst(s, getthis(t))
+ if fp == nil {
+ s.Done = 1
+ fp = Structfirst(s, getinarg(t))
+ }
+
+ return fp
+
+bad:
+ Fatal("funcfirst: not func %v", Tconv(t, 0))
+ return nil
+}
+
+func funcnext(s *Iter) *Type {
+ var fp *Type
+
+ fp = structnext(s)
+ if fp == nil && !(s.Done != 0) {
+ s.Done = 1
+ fp = Structfirst(s, getinarg(s.Tfunc))
+ }
+
+ return fp
+}
+
+func getthis(t *Type) **Type {
+ if t.Etype != TFUNC {
+ Fatal("getthis: not a func %v", Tconv(t, 0))
+ }
+ return &t.Type
+}
+
+func Getoutarg(t *Type) **Type {
+ if t.Etype != TFUNC {
+ Fatal("getoutarg: not a func %v", Tconv(t, 0))
+ }
+ return &t.Type.Down
+}
+
+func getinarg(t *Type) **Type {
+ if t.Etype != TFUNC {
+ Fatal("getinarg: not a func %v", Tconv(t, 0))
+ }
+ return &t.Type.Down.Down
+}
+
+func getthisx(t *Type) *Type {
+ return *getthis(t)
+}
+
+func getoutargx(t *Type) *Type {
+ return *Getoutarg(t)
+}
+
+func getinargx(t *Type) *Type {
+ return *getinarg(t)
+}
+
+/*
+ * return !(op)
+ * eg == <=> !=
+ */
+func Brcom(a int) int {
+ switch a {
+ case OEQ:
+ return ONE
+ case ONE:
+ return OEQ
+ case OLT:
+ return OGE
+ case OGT:
+ return OLE
+ case OLE:
+ return OGT
+ case OGE:
+ return OLT
+ }
+
+ Fatal("brcom: no com for %v\n", Oconv(int(a), 0))
+ return a
+}
+
+/*
+ * return reverse(op)
+ * eg a op b <=> b r(op) a
+ */
+func Brrev(a int) int {
+ switch a {
+ case OEQ:
+ return OEQ
+ case ONE:
+ return ONE
+ case OLT:
+ return OGT
+ case OGT:
+ return OLT
+ case OLE:
+ return OGE
+ case OGE:
+ return OLE
+ }
+
+ Fatal("brcom: no rev for %v\n", Oconv(int(a), 0))
+ return a
+}
+
+/*
+ * return side effect-free n, appending side effects to init.
+ * result is assignable if n is.
+ */
+func safeexpr(n *Node, init **NodeList) *Node {
+ var l *Node
+ var r *Node
+ var a *Node
+
+ if n == nil {
+ return nil
+ }
+
+ if n.Ninit != nil {
+ walkstmtlist(n.Ninit)
+ *init = concat(*init, n.Ninit)
+ n.Ninit = nil
+ }
+
+ switch n.Op {
+ case ONAME,
+ OLITERAL:
+ return n
+
+ case ODOT:
+ l = safeexpr(n.Left, init)
+ if l == n.Left {
+ return n
+ }
+ r = Nod(OXXX, nil, nil)
+ *r = *n
+ r.Left = l
+ typecheck(&r, Erv)
+ walkexpr(&r, init)
+ return r
+
+ case ODOTPTR,
+ OIND:
+ l = safeexpr(n.Left, init)
+ if l == n.Left {
+ return n
+ }
+ a = Nod(OXXX, nil, nil)
+ *a = *n
+ a.Left = l
+ walkexpr(&a, init)
+ return a
+
+ case OINDEX,
+ OINDEXMAP:
+ l = safeexpr(n.Left, init)
+ r = safeexpr(n.Right, init)
+ if l == n.Left && r == n.Right {
+ return n
+ }
+ a = Nod(OXXX, nil, nil)
+ *a = *n
+ a.Left = l
+ a.Right = r
+ walkexpr(&a, init)
+ return a
+ }
+
+ // make a copy; must not be used as an lvalue
+ if islvalue(n) != 0 {
+ Fatal("missing lvalue case in safeexpr: %v", Nconv(n, 0))
+ }
+ return cheapexpr(n, init)
+}
+
+func copyexpr(n *Node, t *Type, init **NodeList) *Node {
+ var a *Node
+ var l *Node
+
+ l = temp(t)
+ a = Nod(OAS, l, n)
+ typecheck(&a, Etop)
+ walkexpr(&a, init)
+ *init = list(*init, a)
+ return l
+}
+
+/*
+ * return side-effect free and cheap n, appending side effects to init.
+ * result may not be assignable.
+ */
+func cheapexpr(n *Node, init **NodeList) *Node {
+ switch n.Op {
+ case ONAME,
+ OLITERAL:
+ return n
+ }
+
+ return copyexpr(n, n.Type, init)
+}
+
+/*
+ * return n in a local variable of type t if it is not already.
+ * the value is guaranteed not to change except by direct
+ * assignment to it.
+ */
+func localexpr(n *Node, t *Type, init **NodeList) *Node {
+ if n.Op == ONAME && (!(n.Addrtaken != 0) || strings.HasPrefix(n.Sym.Name, "autotmp_")) && (n.Class == PAUTO || n.Class == PPARAM || n.Class == PPARAMOUT) && convertop(n.Type, t, nil) == OCONVNOP {
+ return n
+ }
+
+ return copyexpr(n, t, init)
+}
+
+func Setmaxarg(t *Type, extra int32) {
+ var w int64
+
+ dowidth(t)
+ w = t.Argwid
+ if w >= Thearch.MAXWIDTH {
+ Fatal("bad argwid %v", Tconv(t, 0))
+ }
+ w += int64(extra)
+ if w >= Thearch.MAXWIDTH {
+ Fatal("bad argwid %d + %v", extra, Tconv(t, 0))
+ }
+ if w > Maxarg {
+ Maxarg = w
+ }
+}
+
+/*
+ * unicode-aware case-insensitive strcmp
+ */
+
+/*
+ * code to resolve elided DOTs
+ * in embedded types
+ */
+
+// search depth 0 --
+// return count of fields+methods
+// found with a given name
+func lookdot0(s *Sym, t *Type, save **Type, ignorecase int) int {
+ var f *Type
+ var u *Type
+ var c int
+
+ u = t
+ if Isptr[u.Etype] != 0 {
+ u = u.Type
+ }
+
+ c = 0
+ if u.Etype == TSTRUCT || u.Etype == TINTER {
+ for f = u.Type; f != nil; f = f.Down {
+ if f.Sym == s || (ignorecase != 0 && f.Type.Etype == TFUNC && f.Type.Thistuple > 0 && strings.EqualFold(f.Sym.Name, s.Name)) {
+ if save != nil {
+ *save = f
+ }
+ c++
+ }
+ }
+ }
+
+ u = methtype(t, 0)
+ if u != nil {
+ for f = u.Method; f != nil; f = f.Down {
+ if f.Embedded == 0 && (f.Sym == s || (ignorecase != 0 && strings.EqualFold(f.Sym.Name, s.Name))) {
+ if save != nil {
+ *save = f
+ }
+ c++
+ }
+ }
+ }
+
+ return c
+}
+
+// search depth d for field/method s --
+// return count of fields+methods
+// found at search depth.
+// answer is in dotlist array and
+// count of number of ways is returned.
+func adddot1(s *Sym, t *Type, d int, save **Type, ignorecase int) int {
+ var f *Type
+ var u *Type
+ var c int
+ var a int
+
+ if t.Trecur != 0 {
+ return 0
+ }
+ t.Trecur = 1
+
+ if d == 0 {
+ c = lookdot0(s, t, save, ignorecase)
+ goto out
+ }
+
+ c = 0
+ u = t
+ if Isptr[u.Etype] != 0 {
+ u = u.Type
+ }
+ if u.Etype != TSTRUCT && u.Etype != TINTER {
+ goto out
+ }
+
+ d--
+ for f = u.Type; f != nil; f = f.Down {
+ if !(f.Embedded != 0) {
+ continue
+ }
+ if f.Sym == nil {
+ continue
+ }
+ a = adddot1(s, f.Type, d, save, ignorecase)
+ if a != 0 && c == 0 {
+ dotlist[d].field = f
+ }
+ c += a
+ }
+
+out:
+ t.Trecur = 0
+ return c
+}
+
+// in T.field
+// find missing fields that
+// will give shortest unique addressing.
+// modify the tree with missing type names.
+func adddot(n *Node) *Node {
+ var t *Type
+ var s *Sym
+ var c int
+ var d int
+
+ typecheck(&n.Left, Etype|Erv)
+ n.Diag |= n.Left.Diag
+ t = n.Left.Type
+ if t == nil {
+ goto ret
+ }
+
+ if n.Left.Op == OTYPE {
+ goto ret
+ }
+
+ if n.Right.Op != ONAME {
+ goto ret
+ }
+ s = n.Right.Sym
+ if s == nil {
+ goto ret
+ }
+
+ for d = 0; d < len(dotlist); d++ {
+ c = adddot1(s, t, d, nil, 0)
+ if c > 0 {
+ goto out
+ }
+ }
+
+ goto ret
+
+out:
+ if c > 1 {
+ Yyerror("ambiguous selector %v", Nconv(n, 0))
+ n.Left = nil
+ return n
+ }
+
+ // rebuild elided dots
+ for c = d - 1; c >= 0; c-- {
+ n.Left = Nod(ODOT, n.Left, newname(dotlist[c].field.Sym))
+ }
+
+ret:
+ return n
+}
+
+/*
+ * code to help generate trampoline
+ * functions for methods on embedded
+ * subtypes.
+ * these are approx the same as
+ * the corresponding adddot routines
+ * except that they expect to be called
+ * with unique tasks and they return
+ * the actual methods.
+ */
+type Symlink struct {
+ field *Type
+ good uint8
+ followptr uint8
+ link *Symlink
+}
+
+var slist *Symlink
+
+func expand0(t *Type, followptr int) {
+ var f *Type
+ var u *Type
+ var sl *Symlink
+
+ u = t
+ if Isptr[u.Etype] != 0 {
+ followptr = 1
+ u = u.Type
+ }
+
+ if u.Etype == TINTER {
+ for f = u.Type; f != nil; f = f.Down {
+ if f.Sym.Flags&SymUniq != 0 {
+ continue
+ }
+ f.Sym.Flags |= SymUniq
+ sl = new(Symlink)
+ sl.field = f
+ sl.link = slist
+ sl.followptr = uint8(followptr)
+ slist = sl
+ }
+
+ return
+ }
+
+ u = methtype(t, 0)
+ if u != nil {
+ for f = u.Method; f != nil; f = f.Down {
+ if f.Sym.Flags&SymUniq != 0 {
+ continue
+ }
+ f.Sym.Flags |= SymUniq
+ sl = new(Symlink)
+ sl.field = f
+ sl.link = slist
+ sl.followptr = uint8(followptr)
+ slist = sl
+ }
+ }
+}
+
+func expand1(t *Type, d int, followptr int) {
+ var f *Type
+ var u *Type
+
+ if t.Trecur != 0 {
+ return
+ }
+ if d == 0 {
+ return
+ }
+ t.Trecur = 1
+
+ if d != len(dotlist)-1 {
+ expand0(t, followptr)
+ }
+
+ u = t
+ if Isptr[u.Etype] != 0 {
+ followptr = 1
+ u = u.Type
+ }
+
+ if u.Etype != TSTRUCT && u.Etype != TINTER {
+ goto out
+ }
+
+ for f = u.Type; f != nil; f = f.Down {
+ if !(f.Embedded != 0) {
+ continue
+ }
+ if f.Sym == nil {
+ continue
+ }
+ expand1(f.Type, d-1, followptr)
+ }
+
+out:
+ t.Trecur = 0
+}
+
+func expandmeth(t *Type) {
+ var sl *Symlink
+ var f *Type
+ var c int
+ var d int
+
+ if t == nil || t.Xmethod != nil {
+ return
+ }
+
+ // mark top-level method symbols
+ // so that expand1 doesn't consider them.
+ for f = t.Method; f != nil; f = f.Down {
+ f.Sym.Flags |= SymUniq
+ }
+
+ // generate all reachable methods
+ slist = nil
+
+ expand1(t, len(dotlist)-1, 0)
+
+ // check each method to be uniquely reachable
+ for sl = slist; sl != nil; sl = sl.link {
+ sl.field.Sym.Flags &^= SymUniq
+ for d = 0; d < len(dotlist); d++ {
+ c = adddot1(sl.field.Sym, t, d, &f, 0)
+ if c == 0 {
+ continue
+ }
+ if c == 1 {
+ // addot1 may have dug out arbitrary fields, we only want methods.
+ if f.Type.Etype == TFUNC && f.Type.Thistuple > 0 {
+ sl.good = 1
+ sl.field = f
+ }
+ }
+
+ break
+ }
+ }
+
+ for f = t.Method; f != nil; f = f.Down {
+ f.Sym.Flags &^= SymUniq
+ }
+
+ t.Xmethod = t.Method
+ for sl = slist; sl != nil; sl = sl.link {
+ if sl.good != 0 {
+ // add it to the base type method list
+ f = typ(TFIELD)
+
+ *f = *sl.field
+ f.Embedded = 1 // needs a trampoline
+ if sl.followptr != 0 {
+ f.Embedded = 2
+ }
+ f.Down = t.Xmethod
+ t.Xmethod = f
+ }
+ }
+}
+
+/*
+ * Given funarg struct list, return list of ODCLFIELD Node fn args.
+ */
+func structargs(tl **Type, mustname int) *NodeList {
+ var savet Iter
+ var a *Node
+ var n *Node
+ var args *NodeList
+ var t *Type
+ var buf string
+ var gen int
+
+ args = nil
+ gen = 0
+ for t = Structfirst(&savet, tl); t != nil; t = structnext(&savet) {
+ n = nil
+ if mustname != 0 && (t.Sym == nil || t.Sym.Name == "_") {
+ // invent a name so that we can refer to it in the trampoline
+ buf = fmt.Sprintf(".anon%d", gen)
+ gen++
+
+ n = newname(Lookup(buf))
+ } else if t.Sym != nil {
+ n = newname(t.Sym)
+ }
+ a = Nod(ODCLFIELD, n, typenod(t.Type))
+ a.Isddd = t.Isddd
+ if n != nil {
+ n.Isddd = t.Isddd
+ }
+ args = list(args, a)
+ }
+
+ return args
+}
+
+/*
+ * Generate a wrapper function to convert from
+ * a receiver of type T to a receiver of type U.
+ * That is,
+ *
+ * func (t T) M() {
+ * ...
+ * }
+ *
+ * already exists; this function generates
+ *
+ * func (u U) M() {
+ * u.M()
+ * }
+ *
+ * where the types T and U are such that u.M() is valid
+ * and calls the T.M method.
+ * The resulting function is for use in method tables.
+ *
+ * rcvr - U
+ * method - M func (t T)(), a TFIELD type struct
+ * newnam - the eventual mangled name of this function
+ */
+
+var genwrapper_linehistdone int = 0
+
+func genwrapper(rcvr *Type, method *Type, newnam *Sym, iface int) {
+ var this *Node
+ var fn *Node
+ var call *Node
+ var n *Node
+ var t *Node
+ var pad *Node
+ var dot *Node
+ var as *Node
+ var l *NodeList
+ var args *NodeList
+ var in *NodeList
+ var out *NodeList
+ var tpad *Type
+ var methodrcvr *Type
+ var isddd int
+ var v Val
+
+ if false && Debug['r'] != 0 {
+ fmt.Printf("genwrapper rcvrtype=%v method=%v newnam=%v\n", Tconv(rcvr, 0), Tconv(method, 0), Sconv(newnam, 0))
+ }
+
+ lexlineno++
+ lineno = lexlineno
+ if genwrapper_linehistdone == 0 {
+ // All the wrappers can share the same linehist entry.
+ linehist("<autogenerated>", 0, 0)
+
+ genwrapper_linehistdone = 1
+ }
+
+ dclcontext = PEXTERN
+ markdcl()
+
+ this = Nod(ODCLFIELD, newname(Lookup(".this")), typenod(rcvr))
+ this.Left.Ntype = this.Right
+ in = structargs(getinarg(method.Type), 1)
+ out = structargs(Getoutarg(method.Type), 0)
+
+ t = Nod(OTFUNC, nil, nil)
+ l = list1(this)
+ if iface != 0 && rcvr.Width < Types[Tptr].Width {
+ // Building method for interface table and receiver
+ // is smaller than the single pointer-sized word
+ // that the interface call will pass in.
+ // Add a dummy padding argument after the
+ // receiver to make up the difference.
+ tpad = typ(TARRAY)
+
+ tpad.Type = Types[TUINT8]
+ tpad.Bound = Types[Tptr].Width - rcvr.Width
+ pad = Nod(ODCLFIELD, newname(Lookup(".pad")), typenod(tpad))
+ l = list(l, pad)
+ }
+
+ t.List = concat(l, in)
+ t.Rlist = out
+
+ fn = Nod(ODCLFUNC, nil, nil)
+ fn.Nname = newname(newnam)
+ fn.Nname.Defn = fn
+ fn.Nname.Ntype = t
+ declare(fn.Nname, PFUNC)
+ funchdr(fn)
+
+ // arg list
+ args = nil
+
+ isddd = 0
+ for l = in; l != nil; l = l.Next {
+ args = list(args, l.N.Left)
+ isddd = int(l.N.Left.Isddd)
+ }
+
+ methodrcvr = getthisx(method.Type).Type.Type
+
+ // generate nil pointer check for better error
+ if Isptr[rcvr.Etype] != 0 && rcvr.Type == methodrcvr {
+ // generating wrapper from *T to T.
+ n = Nod(OIF, nil, nil)
+
+ n.Ntest = Nod(OEQ, this.Left, nodnil())
+
+ // these strings are already in the reflect tables,
+ // so no space cost to use them here.
+ l = nil
+
+ v.Ctype = CTSTR
+ v.U.Sval = newstrlit(rcvr.Type.Sym.Pkg.Name) // package name
+ l = list(l, nodlit(v))
+ v.U.Sval = newstrlit(rcvr.Type.Sym.Name) // type name
+ l = list(l, nodlit(v))
+ v.U.Sval = newstrlit(method.Sym.Name)
+ l = list(l, nodlit(v)) // method name
+ call = Nod(OCALL, syslook("panicwrap", 0), nil)
+ call.List = l
+ n.Nbody = list1(call)
+ fn.Nbody = list(fn.Nbody, n)
+ }
+
+ dot = adddot(Nod(OXDOT, this.Left, newname(method.Sym)))
+
+ // generate call
+ if !(flag_race != 0) && Isptr[rcvr.Etype] != 0 && Isptr[methodrcvr.Etype] != 0 && method.Embedded != 0 && !(isifacemethod(method.Type) != 0) {
+ // generate tail call: adjust pointer receiver and jump to embedded method.
+ dot = dot.Left // skip final .M
+ if !(Isptr[dotlist[0].field.Type.Etype] != 0) {
+ dot = Nod(OADDR, dot, nil)
+ }
+ as = Nod(OAS, this.Left, Nod(OCONVNOP, dot, nil))
+ as.Right.Type = rcvr
+ fn.Nbody = list(fn.Nbody, as)
+ n = Nod(ORETJMP, nil, nil)
+ n.Left = newname(methodsym(method.Sym, methodrcvr, 0))
+ fn.Nbody = list(fn.Nbody, n)
+ } else {
+ fn.Wrapper = 1 // ignore frame for panic+recover matching
+ call = Nod(OCALL, dot, nil)
+ call.List = args
+ call.Isddd = uint8(isddd)
+ if method.Type.Outtuple > 0 {
+ n = Nod(ORETURN, nil, nil)
+ n.List = list1(call)
+ call = n
+ }
+
+ fn.Nbody = list(fn.Nbody, call)
+ }
+
+ if false && Debug['r'] != 0 {
+ dumplist("genwrapper body", fn.Nbody)
+ }
+
+ funcbody(fn)
+ Curfn = fn
+
+ // wrappers where T is anonymous (struct or interface) can be duplicated.
+ if rcvr.Etype == TSTRUCT || rcvr.Etype == TINTER || Isptr[rcvr.Etype] != 0 && rcvr.Type.Etype == TSTRUCT {
+ fn.Dupok = 1
+ }
+ typecheck(&fn, Etop)
+ typechecklist(fn.Nbody, Etop)
+
+ // Set inl_nonlocal to whether we are calling a method on a
+ // type defined in a different package. Checked in inlvar.
+ if !(methodrcvr.Local != 0) {
+ inl_nonlocal = 1
+ }
+
+ inlcalls(fn)
+
+ inl_nonlocal = 0
+
+ Curfn = nil
+ funccompile(fn)
+}
+
+func hashmem(t *Type) *Node {
+ var tfn *Node
+ var n *Node
+ var sym *Sym
+
+ sym = Pkglookup("memhash", Runtimepkg)
+
+ n = newname(sym)
+ n.Class = PFUNC
+ tfn = Nod(OTFUNC, nil, nil)
+ tfn.List = list(tfn.List, Nod(ODCLFIELD, nil, typenod(Ptrto(t))))
+ tfn.List = list(tfn.List, Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
+ tfn.List = list(tfn.List, Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
+ tfn.Rlist = list(tfn.Rlist, Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
+ typecheck(&tfn, Etype)
+ n.Type = tfn.Type
+ return n
+}
+
+func hashfor(t *Type) *Node {
+ var a int
+ var sym *Sym
+ var tfn *Node
+ var n *Node
+
+ a = algtype1(t, nil)
+ switch a {
+ case AMEM:
+ Fatal("hashfor with AMEM type")
+ fallthrough
+
+ case AINTER:
+ sym = Pkglookup("interhash", Runtimepkg)
+
+ case ANILINTER:
+ sym = Pkglookup("nilinterhash", Runtimepkg)
+
+ case ASTRING:
+ sym = Pkglookup("strhash", Runtimepkg)
+
+ case AFLOAT32:
+ sym = Pkglookup("f32hash", Runtimepkg)
+
+ case AFLOAT64:
+ sym = Pkglookup("f64hash", Runtimepkg)
+
+ case ACPLX64:
+ sym = Pkglookup("c64hash", Runtimepkg)
+
+ case ACPLX128:
+ sym = Pkglookup("c128hash", Runtimepkg)
+
+ default:
+ sym = typesymprefix(".hash", t)
+ }
+
+ n = newname(sym)
+ n.Class = PFUNC
+ tfn = Nod(OTFUNC, nil, nil)
+ tfn.List = list(tfn.List, Nod(ODCLFIELD, nil, typenod(Ptrto(t))))
+ tfn.List = list(tfn.List, Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
+ tfn.Rlist = list(tfn.Rlist, Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
+ typecheck(&tfn, Etype)
+ n.Type = tfn.Type
+ return n
+}
+
+/*
+ * Generate a helper function to compute the hash of a value of type t.
+ */
+func genhash(sym *Sym, t *Type) {
+ var n *Node
+ var fn *Node
+ var np *Node
+ var nh *Node
+ var ni *Node
+ var call *Node
+ var nx *Node
+ var na *Node
+ var tfn *Node
+ var r *Node
+ var hashel *Node
+ var first *Type
+ var t1 *Type
+ var old_safemode int
+ var size int64
+ var mul int64
+ var offend int64
+
+ if Debug['r'] != 0 {
+ fmt.Printf("genhash %v %v\n", Sconv(sym, 0), Tconv(t, 0))
+ }
+
+ lineno = 1 // less confusing than end of input
+ dclcontext = PEXTERN
+ markdcl()
+
+ // func sym(p *T, h uintptr) uintptr
+ fn = Nod(ODCLFUNC, nil, nil)
+
+ fn.Nname = newname(sym)
+ fn.Nname.Class = PFUNC
+ tfn = Nod(OTFUNC, nil, nil)
+ fn.Nname.Ntype = tfn
+
+ n = Nod(ODCLFIELD, newname(Lookup("p")), typenod(Ptrto(t)))
+ tfn.List = list(tfn.List, n)
+ np = n.Left
+ n = Nod(ODCLFIELD, newname(Lookup("h")), typenod(Types[TUINTPTR]))
+ tfn.List = list(tfn.List, n)
+ nh = n.Left
+ n = Nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])) // return value
+ tfn.Rlist = list(tfn.Rlist, n)
+
+ funchdr(fn)
+ typecheck(&fn.Nname.Ntype, Etype)
+
+ // genhash is only called for types that have equality but
+ // cannot be handled by the standard algorithms,
+ // so t must be either an array or a struct.
+ switch t.Etype {
+ default:
+ Fatal("genhash %v", Tconv(t, 0))
+ fallthrough
+
+ case TARRAY:
+ if Isslice(t) != 0 {
+ Fatal("genhash %v", Tconv(t, 0))
+ }
+
+ // An array of pure memory would be handled by the
+ // standard algorithm, so the element type must not be
+ // pure memory.
+ hashel = hashfor(t.Type)
+
+ n = Nod(ORANGE, nil, Nod(OIND, np, nil))
+ ni = newname(Lookup("i"))
+ ni.Type = Types[TINT]
+ n.List = list1(ni)
+ n.Colas = 1
+ colasdefn(n.List, n)
+ ni = n.List.N
+
+ // TODO: with aeshash we don't need these shift/mul parts
+
+ // h = h<<3 | h>>61
+ n.Nbody = list(n.Nbody, Nod(OAS, nh, Nod(OOR, Nod(OLSH, nh, Nodintconst(3)), Nod(ORSH, nh, Nodintconst(int64(Widthptr)*8-3)))))
+
+ // h *= mul
+ // Same multipliers as in runtime.memhash.
+ if Widthptr == 4 {
+ mul = 3267000013
+ } else {
+ mul = 23344194077549503
+ }
+ n.Nbody = list(n.Nbody, Nod(OAS, nh, Nod(OMUL, nh, Nodintconst(mul))))
+
+ // h = hashel(&p[i], h)
+ call = Nod(OCALL, hashel, nil)
+
+ nx = Nod(OINDEX, np, ni)
+ nx.Bounded = 1
+ na = Nod(OADDR, nx, nil)
+ na.Etype = 1 // no escape to heap
+ call.List = list(call.List, na)
+ call.List = list(call.List, nh)
+ n.Nbody = list(n.Nbody, Nod(OAS, nh, call))
+
+ fn.Nbody = list(fn.Nbody, n)
+
+ // Walk the struct using memhash for runs of AMEM
+ // and calling specific hash functions for the others.
+ case TSTRUCT:
+ first = nil
+
+ offend = 0
+ for t1 = t.Type; ; t1 = t1.Down {
+ if t1 != nil && algtype1(t1.Type, nil) == AMEM && !isblanksym(t1.Sym) {
+ offend = t1.Width + t1.Type.Width
+ if first == nil {
+ first = t1
+ }
+
+ // If it's a memory field but it's padded, stop here.
+ if ispaddedfield(t1, t.Width) != 0 {
+ t1 = t1.Down
+ } else {
+ continue
+ }
+ }
+
+ // Run memhash for fields up to this one.
+ if first != nil {
+ size = offend - first.Width // first->width is offset
+ hashel = hashmem(first.Type)
+
+ // h = hashel(&p.first, size, h)
+ call = Nod(OCALL, hashel, nil)
+
+ nx = Nod(OXDOT, np, newname(first.Sym)) // TODO: fields from other packages?
+ na = Nod(OADDR, nx, nil)
+ na.Etype = 1 // no escape to heap
+ call.List = list(call.List, na)
+ call.List = list(call.List, nh)
+ call.List = list(call.List, Nodintconst(size))
+ fn.Nbody = list(fn.Nbody, Nod(OAS, nh, call))
+
+ first = nil
+ }
+
+ if t1 == nil {
+ break
+ }
+ if isblanksym(t1.Sym) {
+ continue
+ }
+
+ // Run hash for this field.
+ if algtype1(t1.Type, nil) == AMEM {
+ hashel = hashmem(t1.Type)
+
+ // h = memhash(&p.t1, h, size)
+ call = Nod(OCALL, hashel, nil)
+
+ nx = Nod(OXDOT, np, newname(t1.Sym)) // TODO: fields from other packages?
+ na = Nod(OADDR, nx, nil)
+ na.Etype = 1 // no escape to heap
+ call.List = list(call.List, na)
+ call.List = list(call.List, nh)
+ call.List = list(call.List, Nodintconst(t1.Type.Width))
+ fn.Nbody = list(fn.Nbody, Nod(OAS, nh, call))
+ } else {
+ hashel = hashfor(t1.Type)
+
+ // h = hashel(&p.t1, h)
+ call = Nod(OCALL, hashel, nil)
+
+ nx = Nod(OXDOT, np, newname(t1.Sym)) // TODO: fields from other packages?
+ na = Nod(OADDR, nx, nil)
+ na.Etype = 1 // no escape to heap
+ call.List = list(call.List, na)
+ call.List = list(call.List, nh)
+ fn.Nbody = list(fn.Nbody, Nod(OAS, nh, call))
+ }
+ }
+ }
+
+ r = Nod(ORETURN, nil, nil)
+ r.List = list(r.List, nh)
+ fn.Nbody = list(fn.Nbody, r)
+
+ if Debug['r'] != 0 {
+ dumplist("genhash body", fn.Nbody)
+ }
+
+ funcbody(fn)
+ Curfn = fn
+ fn.Dupok = 1
+ typecheck(&fn, Etop)
+ typechecklist(fn.Nbody, Etop)
+ Curfn = nil
+
+ // Disable safemode while compiling this code: the code we
+ // generate internally can refer to unsafe.Pointer.
+ // In this case it can happen if we need to generate an ==
+ // for a struct containing a reflect.Value, which itself has
+ // an unexported field of type unsafe.Pointer.
+ old_safemode = safemode
+
+ safemode = 0
+ funccompile(fn)
+ safemode = old_safemode
+}
+
+// Return node for
+// if p.field != q.field { return false }
+func eqfield(p *Node, q *Node, field *Node) *Node {
+ var nif *Node
+ var nx *Node
+ var ny *Node
+ var r *Node
+
+ nx = Nod(OXDOT, p, field)
+ ny = Nod(OXDOT, q, field)
+ nif = Nod(OIF, nil, nil)
+ nif.Ntest = Nod(ONE, nx, ny)
+ r = Nod(ORETURN, nil, nil)
+ r.List = list(r.List, Nodbool(0))
+ nif.Nbody = list(nif.Nbody, r)
+ return nif
+}
+
+func eqmemfunc(size int64, type_ *Type, needsize *int) *Node {
+ var buf string
+ var fn *Node
+
+ switch size {
+ default:
+ fn = syslook("memequal", 1)
+ *needsize = 1
+
+ case 1,
+ 2,
+ 4,
+ 8,
+ 16:
+ buf = fmt.Sprintf("memequal%d", int(size)*8)
+ fn = syslook(buf, 1)
+ *needsize = 0
+ }
+
+ argtype(fn, type_)
+ argtype(fn, type_)
+ return fn
+}
+
+// Return node for
+// if !memequal(&p.field, &q.field [, size]) { return false }
+func eqmem(p *Node, q *Node, field *Node, size int64) *Node {
+ var nif *Node
+ var nx *Node
+ var ny *Node
+ var call *Node
+ var r *Node
+ var needsize int
+
+ nx = Nod(OADDR, Nod(OXDOT, p, field), nil)
+ nx.Etype = 1 // does not escape
+ ny = Nod(OADDR, Nod(OXDOT, q, field), nil)
+ ny.Etype = 1 // does not escape
+ typecheck(&nx, Erv)
+ typecheck(&ny, Erv)
+
+ call = Nod(OCALL, eqmemfunc(size, nx.Type.Type, &needsize), nil)
+ call.List = list(call.List, nx)
+ call.List = list(call.List, ny)
+ if needsize != 0 {
+ call.List = list(call.List, Nodintconst(size))
+ }
+
+ nif = Nod(OIF, nil, nil)
+ nif.Ninit = list(nif.Ninit, call)
+ nif.Ntest = Nod(ONOT, call, nil)
+ r = Nod(ORETURN, nil, nil)
+ r.List = list(r.List, Nodbool(0))
+ nif.Nbody = list(nif.Nbody, r)
+ return nif
+}
+
+/*
+ * Generate a helper function to check equality of two values of type t.
+ */
+func geneq(sym *Sym, t *Type) {
+ var n *Node
+ var fn *Node
+ var np *Node
+ var nq *Node
+ var tfn *Node
+ var nif *Node
+ var ni *Node
+ var nx *Node
+ var ny *Node
+ var nrange *Node
+ var r *Node
+ var t1 *Type
+ var first *Type
+ var old_safemode int
+ var size int64
+ var offend int64
+
+ if Debug['r'] != 0 {
+ fmt.Printf("geneq %v %v\n", Sconv(sym, 0), Tconv(t, 0))
+ }
+
+ lineno = 1 // less confusing than end of input
+ dclcontext = PEXTERN
+ markdcl()
+
+ // func sym(p, q *T) bool
+ fn = Nod(ODCLFUNC, nil, nil)
+
+ fn.Nname = newname(sym)
+ fn.Nname.Class = PFUNC
+ tfn = Nod(OTFUNC, nil, nil)
+ fn.Nname.Ntype = tfn
+
+ n = Nod(ODCLFIELD, newname(Lookup("p")), typenod(Ptrto(t)))
+ tfn.List = list(tfn.List, n)
+ np = n.Left
+ n = Nod(ODCLFIELD, newname(Lookup("q")), typenod(Ptrto(t)))
+ tfn.List = list(tfn.List, n)
+ nq = n.Left
+ n = Nod(ODCLFIELD, nil, typenod(Types[TBOOL]))
+ tfn.Rlist = list(tfn.Rlist, n)
+
+ funchdr(fn)
+
+ // geneq is only called for types that have equality but
+ // cannot be handled by the standard algorithms,
+ // so t must be either an array or a struct.
+ switch t.Etype {
+ default:
+ Fatal("geneq %v", Tconv(t, 0))
+ fallthrough
+
+ case TARRAY:
+ if Isslice(t) != 0 {
+ Fatal("geneq %v", Tconv(t, 0))
+ }
+
+ // An array of pure memory would be handled by the
+ // standard memequal, so the element type must not be
+ // 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))
+
+ ni = newname(Lookup("i"))
+ ni.Type = Types[TINT]
+ nrange.List = list1(ni)
+ nrange.Colas = 1
+ colasdefn(nrange.List, nrange)
+ ni = nrange.List.N
+
+ // if p[i] != q[i] { return false }
+ nx = Nod(OINDEX, np, ni)
+
+ nx.Bounded = 1
+ ny = Nod(OINDEX, nq, ni)
+ ny.Bounded = 1
+
+ nif = Nod(OIF, nil, nil)
+ nif.Ntest = Nod(ONE, nx, ny)
+ r = Nod(ORETURN, nil, nil)
+ r.List = list(r.List, Nodbool(0))
+ nif.Nbody = list(nif.Nbody, r)
+ nrange.Nbody = list(nrange.Nbody, nif)
+ fn.Nbody = list(fn.Nbody, nrange)
+
+ // Walk the struct using memequal for runs of AMEM
+ // and calling specific equality tests for the others.
+ // Skip blank-named fields.
+ case TSTRUCT:
+ first = nil
+
+ offend = 0
+ for t1 = t.Type; ; t1 = t1.Down {
+ if t1 != nil && algtype1(t1.Type, nil) == AMEM && !isblanksym(t1.Sym) {
+ offend = t1.Width + t1.Type.Width
+ if first == nil {
+ first = t1
+ }
+
+ // If it's a memory field but it's padded, stop here.
+ if ispaddedfield(t1, t.Width) != 0 {
+ t1 = t1.Down
+ } else {
+ continue
+ }
+ }
+
+ // Run memequal for fields up to this one.
+ // TODO(rsc): All the calls to newname are wrong for
+ // cross-package unexported fields.
+ if first != nil {
+ if first.Down == t1 {
+ fn.Nbody = list(fn.Nbody, eqfield(np, nq, newname(first.Sym)))
+ } else if first.Down.Down == t1 {
+ fn.Nbody = list(fn.Nbody, eqfield(np, nq, newname(first.Sym)))
+ first = first.Down
+ if !isblanksym(first.Sym) {
+ fn.Nbody = list(fn.Nbody, eqfield(np, nq, newname(first.Sym)))
+ }
+ } else {
+ // More than two fields: use memequal.
+ size = offend - first.Width // first->width is offset
+ fn.Nbody = list(fn.Nbody, eqmem(np, nq, newname(first.Sym), size))
+ }
+
+ first = nil
+ }
+
+ if t1 == nil {
+ break
+ }
+ if isblanksym(t1.Sym) {
+ continue
+ }
+
+ // Check this field, which is not just memory.
+ fn.Nbody = list(fn.Nbody, eqfield(np, nq, newname(t1.Sym)))
+ }
+ }
+
+ // return true
+ r = Nod(ORETURN, nil, nil)
+
+ r.List = list(r.List, Nodbool(1))
+ fn.Nbody = list(fn.Nbody, r)
+
+ if Debug['r'] != 0 {
+ dumplist("geneq body", fn.Nbody)
+ }
+
+ funcbody(fn)
+ Curfn = fn
+ fn.Dupok = 1
+ typecheck(&fn, Etop)
+ typechecklist(fn.Nbody, Etop)
+ Curfn = nil
+
+ // Disable safemode while compiling this code: the code we
+ // generate internally can refer to unsafe.Pointer.
+ // In this case it can happen if we need to generate an ==
+ // for a struct containing a reflect.Value, which itself has
+ // an unexported field of type unsafe.Pointer.
+ old_safemode = safemode
+
+ safemode = 0
+ funccompile(fn)
+ safemode = old_safemode
+}
+
+func ifacelookdot(s *Sym, t *Type, followptr *int, ignorecase int) *Type {
+ var i int
+ var c int
+ var d int
+ var m *Type
+
+ *followptr = 0
+
+ if t == nil {
+ return nil
+ }
+
+ for d = 0; d < len(dotlist); d++ {
+ c = adddot1(s, t, d, &m, ignorecase)
+ if c > 1 {
+ Yyerror("%v.%v is ambiguous", Tconv(t, 0), Sconv(s, 0))
+ return nil
+ }
+
+ if c == 1 {
+ for i = 0; i < d; i++ {
+ if Isptr[dotlist[i].field.Type.Etype] != 0 {
+ *followptr = 1
+ break
+ }
+ }
+
+ if m.Type.Etype != TFUNC || m.Type.Thistuple == 0 {
+ Yyerror("%v.%v is a field, not a method", Tconv(t, 0), Sconv(s, 0))
+ return nil
+ }
+
+ return m
+ }
+ }
+
+ return nil
+}
+
+func implements(t *Type, iface *Type, m **Type, samename **Type, ptr *int) int {
+ var t0 *Type
+ var im *Type
+ var tm *Type
+ var rcvr *Type
+ var imtype *Type
+ var followptr int
+
+ t0 = t
+ if t == nil {
+ return 0
+ }
+
+ // if this is too slow,
+ // could sort these first
+ // and then do one loop.
+
+ if t.Etype == TINTER {
+ for im = iface.Type; im != nil; im = im.Down {
+ for tm = t.Type; tm != nil; tm = tm.Down {
+ if tm.Sym == im.Sym {
+ if Eqtype(tm.Type, im.Type) {
+ goto found
+ }
+ *m = im
+ *samename = tm
+ *ptr = 0
+ return 0
+ }
+ }
+
+ *m = im
+ *samename = nil
+ *ptr = 0
+ return 0
+ found:
+ }
+
+ return 1
+ }
+
+ t = methtype(t, 0)
+ if t != nil {
+ expandmeth(t)
+ }
+ for im = iface.Type; im != nil; im = im.Down {
+ imtype = methodfunc(im.Type, nil)
+ tm = ifacelookdot(im.Sym, t, &followptr, 0)
+ if tm == nil || tm.Nointerface != 0 || !Eqtype(methodfunc(tm.Type, nil), imtype) {
+ if tm == nil {
+ tm = ifacelookdot(im.Sym, t, &followptr, 1)
+ }
+ *m = im
+ *samename = tm
+ *ptr = 0
+ return 0
+ }
+
+ // if pointer receiver in method,
+ // the method does not exist for value types.
+ rcvr = getthisx(tm.Type).Type.Type
+
+ if Isptr[rcvr.Etype] != 0 && !(Isptr[t0.Etype] != 0) && !(followptr != 0) && !(isifacemethod(tm.Type) != 0) {
+ if false && Debug['r'] != 0 {
+ Yyerror("interface pointer mismatch")
+ }
+
+ *m = im
+ *samename = nil
+ *ptr = 1
+ return 0
+ }
+ }
+
+ return 1
+}
+
+/*
+ * even simpler simtype; get rid of ptr, bool.
+ * assuming that the front end has rejected
+ * all the invalid conversions (like ptr -> bool)
+ */
+func Simsimtype(t *Type) int {
+ var et int
+
+ if t == nil {
+ return 0
+ }
+
+ et = int(Simtype[t.Etype])
+ switch et {
+ case TPTR32:
+ et = TUINT32
+
+ case TPTR64:
+ et = TUINT64
+
+ case TBOOL:
+ et = TUINT8
+ }
+
+ return et
+}
+
+func concat(a *NodeList, b *NodeList) *NodeList {
+ if a == nil {
+ return b
+ }
+ if b == nil {
+ return a
+ }
+
+ a.End.Next = b
+ a.End = b.End
+ b.End = nil
+ return a
+}
+
+func list1(n *Node) *NodeList {
+ var l *NodeList
+
+ if n == nil {
+ return nil
+ }
+ if n.Op == OBLOCK && n.Ninit == nil {
+ // Flatten list and steal storage.
+ // Poison pointer to catch errant uses.
+ l = n.List
+
+ n.List = nil
+ return l
+ }
+
+ l = new(NodeList)
+ l.N = n
+ l.End = l
+ return l
+}
+
+func list(l *NodeList, n *Node) *NodeList {
+ return concat(l, list1(n))
+}
+
+func listsort(l **NodeList, f func(*Node, *Node) int) {
+ var l1 *NodeList
+ var l2 *NodeList
+ var le *NodeList
+
+ if *l == nil || (*l).Next == nil {
+ return
+ }
+
+ l1 = *l
+ l2 = *l
+ for {
+ l2 = l2.Next
+ if l2 == nil {
+ break
+ }
+ l2 = l2.Next
+ if l2 == nil {
+ break
+ }
+ l1 = l1.Next
+ }
+
+ l2 = l1.Next
+ l1.Next = nil
+ l2.End = (*l).End
+ (*l).End = l1
+
+ l1 = *l
+ listsort(&l1, f)
+ listsort(&l2, f)
+
+ if f(l1.N, l2.N) < 0 {
+ *l = l1
+ } else {
+ *l = l2
+ l2 = l1
+ l1 = *l
+ }
+
+ // now l1 == *l; and l1 < l2
+
+ for (l1 != nil) && (l2 != nil) {
+ for (l1.Next != nil) && f(l1.Next.N, l2.N) < 0 {
+ l1 = l1.Next
+ }
+
+ // l1 is last one from l1 that is < l2
+ le = l1.Next // le is the rest of l1, first one that is >= l2
+ if le != nil {
+ le.End = (*l).End
+ }
+
+ (*l).End = l1 // cut *l at l1
+ *l = concat(*l, l2) // glue l2 to *l's tail
+
+ l1 = l2 // l1 is the first element of *l that is < the new l2
+ l2 = le // ... because l2 now is the old tail of l1
+ }
+
+ *l = concat(*l, l2) // any remainder
+}
+
+func listtreecopy(l *NodeList) *NodeList {
+ var out *NodeList
+
+ out = nil
+ for ; l != nil; l = l.Next {
+ out = list(out, treecopy(l.N))
+ }
+ return out
+}
+
+func liststmt(l *NodeList) *Node {
+ var n *Node
+
+ n = Nod(OBLOCK, nil, nil)
+ n.List = l
+ if l != nil {
+ n.Lineno = l.N.Lineno
+ }
+ return n
+}
+
+/*
+ * return nelem of list
+ */
+func count(l *NodeList) int {
+ var n int64
+
+ n = 0
+ for ; l != nil; l = l.Next {
+ n++
+ }
+ if int64(int(n)) != n { // Overflow.
+ Yyerror("too many elements in list")
+ }
+
+ return int(n)
+}
+
+/*
+ * return nelem of list
+ */
+func structcount(t *Type) int {
+ var v int
+ var s Iter
+
+ v = 0
+ for t = Structfirst(&s, &t); t != nil; t = structnext(&s) {
+ v++
+ }
+ return v
+}
+
+/*
+ * return power of 2 of the constant
+ * operand. -1 if it is not a power of 2.
+ * 1000+ if it is a -(power of 2)
+ */
+func powtwo(n *Node) int {
+ var v uint64
+ var b uint64
+ var i int
+
+ if n == nil || n.Op != OLITERAL || n.Type == nil {
+ goto no
+ }
+ if !(Isint[n.Type.Etype] != 0) {
+ goto no
+ }
+
+ v = uint64(Mpgetfix(n.Val.U.Xval))
+ b = 1
+ for i = 0; i < 64; i++ {
+ if b == v {
+ return i
+ }
+ b = b << 1
+ }
+
+ if !(Issigned[n.Type.Etype] != 0) {
+ goto no
+ }
+
+ v = -v
+ b = 1
+ for i = 0; i < 64; i++ {
+ if b == v {
+ return i + 1000
+ }
+ b = b << 1
+ }
+
+no:
+ return -1
+}
+
+/*
+ * return the unsigned type for
+ * a signed integer type.
+ * returns T if input is not a
+ * signed integer type.
+ */
+func tounsigned(t *Type) *Type {
+ // this is types[et+1], but not sure
+ // that this relation is immutable
+ switch t.Etype {
+ default:
+ fmt.Printf("tounsigned: unknown type %v\n", Tconv(t, 0))
+ t = nil
+
+ case TINT:
+ t = Types[TUINT]
+
+ case TINT8:
+ t = Types[TUINT8]
+
+ case TINT16:
+ t = Types[TUINT16]
+
+ case TINT32:
+ t = Types[TUINT32]
+
+ case TINT64:
+ t = Types[TUINT64]
+ }
+
+ return t
+}
+
+/*
+ * magic number for signed division
+ * see hacker's delight chapter 10
+ */
+func Smagic(m *Magic) {
+ var p int
+ var ad uint64
+ var anc uint64
+ var delta uint64
+ var q1 uint64
+ var r1 uint64
+ var q2 uint64
+ var r2 uint64
+ var t uint64
+ var mask uint64
+ var two31 uint64
+
+ m.Bad = 0
+ switch m.W {
+ default:
+ m.Bad = 1
+ return
+
+ case 8:
+ mask = 0xff
+
+ case 16:
+ mask = 0xffff
+
+ case 32:
+ mask = 0xffffffff
+
+ case 64:
+ mask = 0xffffffffffffffff
+ }
+
+ two31 = mask ^ (mask >> 1)
+
+ p = m.W - 1
+ ad = uint64(m.Sd)
+ if m.Sd < 0 {
+ ad = -uint64(m.Sd)
+ }
+
+ // bad denominators
+ if ad == 0 || ad == 1 || ad == two31 {
+ m.Bad = 1
+ return
+ }
+
+ t = two31
+ ad &= mask
+
+ anc = t - 1 - t%ad
+ anc &= mask
+
+ q1 = two31 / anc
+ r1 = two31 - q1*anc
+ q1 &= mask
+ r1 &= mask
+
+ q2 = two31 / ad
+ r2 = two31 - q2*ad
+ q2 &= mask
+ r2 &= mask
+
+ for {
+ p++
+ q1 <<= 1
+ r1 <<= 1
+ q1 &= mask
+ r1 &= mask
+ if r1 >= anc {
+ q1++
+ r1 -= anc
+ q1 &= mask
+ r1 &= mask
+ }
+
+ q2 <<= 1
+ r2 <<= 1
+ q2 &= mask
+ r2 &= mask
+ if r2 >= ad {
+ q2++
+ r2 -= ad
+ q2 &= mask
+ r2 &= mask
+ }
+
+ delta = ad - r2
+ delta &= mask
+ if q1 < delta || (q1 == delta && r1 == 0) {
+ continue
+ }
+
+ break
+ }
+
+ m.Sm = int64(q2 + 1)
+ if uint64(m.Sm)&two31 != 0 {
+ m.Sm |= ^int64(mask)
+ }
+ m.S = p - m.W
+}
+
+/*
+ * magic number for unsigned division
+ * see hacker's delight chapter 10
+ */
+func Umagic(m *Magic) {
+ var p int
+ var nc uint64
+ var delta uint64
+ var q1 uint64
+ var r1 uint64
+ var q2 uint64
+ var r2 uint64
+ var mask uint64
+ var two31 uint64
+
+ m.Bad = 0
+ m.Ua = 0
+
+ switch m.W {
+ default:
+ m.Bad = 1
+ return
+
+ case 8:
+ mask = 0xff
+
+ case 16:
+ mask = 0xffff
+
+ case 32:
+ mask = 0xffffffff
+
+ case 64:
+ mask = 0xffffffffffffffff
+ }
+
+ two31 = mask ^ (mask >> 1)
+
+ m.Ud &= mask
+ if m.Ud == 0 || m.Ud == two31 {
+ m.Bad = 1
+ return
+ }
+
+ nc = mask - (-m.Ud&mask)%m.Ud
+ p = m.W - 1
+
+ q1 = two31 / nc
+ r1 = two31 - q1*nc
+ q1 &= mask
+ r1 &= mask
+
+ q2 = (two31 - 1) / m.Ud
+ r2 = (two31 - 1) - q2*m.Ud
+ q2 &= mask
+ r2 &= mask
+
+ for {
+ p++
+ if r1 >= nc-r1 {
+ q1 <<= 1
+ q1++
+ r1 <<= 1
+ r1 -= nc
+ } else {
+ q1 <<= 1
+ r1 <<= 1
+ }
+
+ q1 &= mask
+ r1 &= mask
+ if r2+1 >= m.Ud-r2 {
+ if q2 >= two31-1 {
+ m.Ua = 1
+ }
+
+ q2 <<= 1
+ q2++
+ r2 <<= 1
+ r2++
+ r2 -= m.Ud
+ } else {
+ if q2 >= two31 {
+ m.Ua = 1
+ }
+
+ q2 <<= 1
+ r2 <<= 1
+ r2++
+ }
+
+ q2 &= mask
+ r2 &= mask
+
+ delta = m.Ud - 1 - r2
+ delta &= mask
+
+ if p < m.W+m.W {
+ if q1 < delta || (q1 == delta && r1 == 0) {
+ continue
+ }
+ }
+
+ break
+ }
+
+ m.Um = q2 + 1
+ m.S = p - m.W
+}
+
+func ngotype(n *Node) *Sym {
+ if n.Type != nil {
+ return typenamesym(n.Type)
+ }
+ return nil
+}
+
+/*
+ * Convert raw string to the prefix that will be used in the symbol
+ * table. All control characters, space, '%' and '"', as well as
+ * non-7-bit clean bytes turn into %xx. The period needs escaping
+ * only in the last segment of the path, and it makes for happier
+ * users if we escape that as little as possible.
+ *
+ * If you edit this, edit ../ld/lib.c:/^pathtoprefix too.
+ * If you edit this, edit ../../debug/goobj/read.go:/importPathToPrefix too.
+ */
+func pathtoprefix(s string) string {
+ slash := strings.LastIndex(s, "/")
+ for i := 0; i < len(s); i++ {
+ c := s[i]
+ if c <= ' ' || i >= slash && c == '.' || c == '%' || c == '"' || c >= 0x7F {
+ goto escape
+ }
+ }
+ return s
+
+escape:
+ var buf bytes.Buffer
+ for i := 0; i < len(s); i++ {
+ c := s[i]
+ if c <= ' ' || i >= slash && c == '.' || c == '%' || c == '"' || c >= 0x7F {
+ fmt.Fprintf(&buf, "%%%02x", c)
+ continue
+ }
+ buf.WriteByte(c)
+ }
+ return buf.String()
+}
+
+func mkpkg(path_ *Strlit) *Pkg {
+ var p *Pkg
+ var h int
+
+ h = int(stringhash(path_.S) & uint32(len(phash)-1))
+ for p = phash[h]; p != nil; p = p.Link {
+ if p.Path.S == path_.S {
+ return p
+ }
+ }
+
+ p = new(Pkg)
+ p.Path = path_
+ p.Prefix = pathtoprefix(path_.S)
+ p.Link = phash[h]
+ phash[h] = p
+ return p
+}
+
+func newstrlit(s string) *Strlit {
+ return &Strlit{
+ S: s,
+ }
+}
+
+func addinit(np **Node, init *NodeList) {
+ var n *Node
+
+ if init == nil {
+ return
+ }
+
+ n = *np
+ switch n.Op {
+ // There may be multiple refs to this node;
+ // introduce OCONVNOP to hold init list.
+ case ONAME,
+ OLITERAL:
+ n = Nod(OCONVNOP, n, nil)
+
+ n.Type = n.Left.Type
+ n.Typecheck = 1
+ *np = n
+ }
+
+ n.Ninit = concat(init, n.Ninit)
+ n.Ullman = UINF
+}
+
+var reservedimports = []string{
+ "go",
+ "type",
+}
+
+func isbadimport(path_ *Strlit) bool {
+ var i int
+ var s string
+ var r uint
+
+ if len(path_.S) != len(path_.S) {
+ Yyerror("import path contains NUL")
+ return true
+ }
+
+ for i = 0; i < len(reservedimports); i++ {
+ if path_.S == reservedimports[i] {
+ Yyerror("import path \"%s\" is reserved and cannot be used", path_.S)
+ return true
+ }
+ }
+
+ _ = s
+ _ = r
+ for _, r := range path_.S {
+ if r == utf8.RuneError {
+ Yyerror("import path contains invalid UTF-8 sequence: \"%v\"", Zconv(path_, 0))
+ return true
+ }
+
+ if r < 0x20 || r == 0x7f {
+ Yyerror("import path contains control character: \"%v\"", Zconv(path_, 0))
+ return true
+ }
+
+ if r == '\\' {
+ Yyerror("import path contains backslash; use slash: \"%v\"", Zconv(path_, 0))
+ return true
+ }
+
+ if unicode.IsSpace(rune(r)) {
+ Yyerror("import path contains space character: \"%v\"", Zconv(path_, 0))
+ return true
+ }
+
+ if strings.ContainsRune("!\"#$%&'()*,:;<=>?[]^`{|}", r) {
+ Yyerror("import path contains invalid character '%c': \"%v\"", r, Zconv(path_, 0))
+ return true
+ }
+ }
+
+ return false
+}
+
+func checknil(x *Node, init **NodeList) {
+ var n *Node
+
+ if Isinter(x.Type) != 0 {
+ x = Nod(OITAB, x, nil)
+ typecheck(&x, Erv)
+ }
+
+ n = Nod(OCHECKNIL, x, nil)
+ n.Typecheck = 1
+ *init = list(*init, n)
+}
+
+/*
+ * Can this type be stored directly in an interface word?
+ * Yes, if the representation is a single pointer.
+ */
+func isdirectiface(t *Type) int {
+ switch t.Etype {
+ case TPTR32,
+ TPTR64,
+ TCHAN,
+ TMAP,
+ TFUNC,
+ TUNSAFEPTR:
+ return 1
+
+ // Array of 1 direct iface type can be direct.
+ case TARRAY:
+ return bool2int(t.Bound == 1 && isdirectiface(t.Type) != 0)
+
+ // Struct with 1 field of direct iface type can be direct.
+ case TSTRUCT:
+ return bool2int(t.Type != nil && t.Type.Down == nil && isdirectiface(t.Type.Type) != 0)
+ }
+
+ return 0
+}
diff --git a/src/cmd/internal/gc/swt.go b/src/cmd/internal/gc/swt.go
new file mode 100644
index 0000000..cf1f7d4
--- /dev/null
+++ b/src/cmd/internal/gc/swt.go
@@ -0,0 +1,1028 @@
+// 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
+
+import (
+ "cmd/internal/obj"
+ "fmt"
+)
+
+const (
+ Snorm = 0 + iota
+ Strue
+ Sfalse
+ Stype
+ Tdefault
+ Texprconst
+ Texprvar
+ Ttypenil
+ Ttypeconst
+ Ttypevar
+ Ncase = 4
+)
+
+type Case struct {
+ node *Node
+ hash uint32
+ type_ uint8
+ diag uint8
+ ordinal uint16
+ link *Case
+}
+
+var C *Case
+
+func dumpcase(c0 *Case) {
+ var c *Case
+
+ for c = c0; c != nil; c = c.link {
+ switch c.type_ {
+ case Tdefault:
+ fmt.Printf("case-default\n")
+ fmt.Printf("\tord=%d\n", c.ordinal)
+
+ case Texprconst:
+ fmt.Printf("case-exprconst\n")
+ fmt.Printf("\tord=%d\n", c.ordinal)
+
+ case Texprvar:
+ fmt.Printf("case-exprvar\n")
+ fmt.Printf("\tord=%d\n", c.ordinal)
+ fmt.Printf("\top=%v\n", Oconv(int(c.node.Left.Op), 0))
+
+ case Ttypenil:
+ fmt.Printf("case-typenil\n")
+ fmt.Printf("\tord=%d\n", c.ordinal)
+
+ case Ttypeconst:
+ fmt.Printf("case-typeconst\n")
+ fmt.Printf("\tord=%d\n", c.ordinal)
+ fmt.Printf("\thash=%x\n", c.hash)
+
+ case Ttypevar:
+ fmt.Printf("case-typevar\n")
+ fmt.Printf("\tord=%d\n", c.ordinal)
+
+ default:
+ fmt.Printf("case-???\n")
+ fmt.Printf("\tord=%d\n", c.ordinal)
+ fmt.Printf("\top=%v\n", Oconv(int(c.node.Left.Op), 0))
+ fmt.Printf("\thash=%x\n", c.hash)
+ }
+ }
+
+ fmt.Printf("\n")
+}
+
+func ordlcmp(c1 *Case, c2 *Case) int {
+ // sort default first
+ if c1.type_ == Tdefault {
+ return -1
+ }
+ if c2.type_ == Tdefault {
+ return +1
+ }
+
+ // sort nil second
+ if c1.type_ == Ttypenil {
+ return -1
+ }
+ if c2.type_ == Ttypenil {
+ return +1
+ }
+
+ // sort by ordinal
+ if c1.ordinal > c2.ordinal {
+ return +1
+ }
+ if c1.ordinal < c2.ordinal {
+ return -1
+ }
+ return 0
+}
+
+func exprcmp(c1 *Case, c2 *Case) int {
+ var ct int
+ var n int
+ var n1 *Node
+ var n2 *Node
+
+ // sort non-constants last
+ if c1.type_ != Texprconst {
+ return +1
+ }
+ if c2.type_ != Texprconst {
+ return -1
+ }
+
+ n1 = c1.node.Left
+ n2 = c2.node.Left
+
+ // sort by type (for switches on interface)
+ ct = int(n1.Val.Ctype)
+
+ if ct != int(n2.Val.Ctype) {
+ return ct - int(n2.Val.Ctype)
+ }
+ if !Eqtype(n1.Type, n2.Type) {
+ if n1.Type.Vargen > n2.Type.Vargen {
+ return +1
+ } else {
+ return -1
+ }
+ }
+
+ // sort by constant value
+ n = 0
+
+ switch ct {
+ case CTFLT:
+ n = mpcmpfltflt(n1.Val.U.Fval, n2.Val.U.Fval)
+
+ case CTINT,
+ CTRUNE:
+ n = Mpcmpfixfix(n1.Val.U.Xval, n2.Val.U.Xval)
+
+ case CTSTR:
+ n = cmpslit(n1, n2)
+ }
+
+ return n
+}
+
+func typecmp(c1 *Case, c2 *Case) int {
+ // sort non-constants last
+ if c1.type_ != Ttypeconst {
+ return +1
+ }
+ if c2.type_ != Ttypeconst {
+ return -1
+ }
+
+ // sort by hash code
+ if c1.hash > c2.hash {
+ return +1
+ }
+ if c1.hash < c2.hash {
+ return -1
+ }
+
+ // sort by ordinal so duplicate error
+ // happens on later case.
+ if c1.ordinal > c2.ordinal {
+ return +1
+ }
+ if c1.ordinal < c2.ordinal {
+ return -1
+ }
+ return 0
+}
+
+func csort(l *Case, f func(*Case, *Case) int) *Case {
+ var l1 *Case
+ var l2 *Case
+ var le *Case
+
+ if l == nil || l.link == nil {
+ return l
+ }
+
+ l1 = l
+ l2 = l
+ for {
+ l2 = l2.link
+ if l2 == nil {
+ break
+ }
+ l2 = l2.link
+ if l2 == nil {
+ break
+ }
+ l1 = l1.link
+ }
+
+ l2 = l1.link
+ l1.link = nil
+ l1 = csort(l, f)
+ l2 = csort(l2, f)
+
+ /* set up lead element */
+ if f(l1, l2) < 0 {
+ l = l1
+ l1 = l1.link
+ } else {
+ l = l2
+ l2 = l2.link
+ }
+
+ le = l
+
+ for {
+ if l1 == nil {
+ for l2 != nil {
+ le.link = l2
+ le = l2
+ l2 = l2.link
+ }
+
+ le.link = nil
+ break
+ }
+
+ if l2 == nil {
+ for l1 != nil {
+ le.link = l1
+ le = l1
+ l1 = l1.link
+ }
+
+ break
+ }
+
+ if f(l1, l2) < 0 {
+ le.link = l1
+ le = l1
+ l1 = l1.link
+ } else {
+ le.link = l2
+ le = l2
+ l2 = l2.link
+ }
+ }
+
+ le.link = nil
+ return l
+}
+
+var newlabel_swt_label int
+
+func newlabel_swt() *Node {
+ newlabel_swt_label++
+ namebuf = fmt.Sprintf("%.6d", newlabel_swt_label)
+ return newname(Lookup(namebuf))
+}
+
+/*
+ * build separate list of statements and cases
+ * make labels between cases and statements
+ * deal with fallthrough, break, unreachable statements
+ */
+func casebody(sw *Node, typeswvar *Node) {
+ var n *Node
+ var c *Node
+ var last *Node
+ var def *Node
+ var cas *NodeList
+ var stat *NodeList
+ var l *NodeList
+ var lc *NodeList
+ var go_ *Node
+ var br *Node
+ var lno int32
+ var needvar int32
+
+ if sw.List == nil {
+ return
+ }
+
+ lno = setlineno(sw)
+
+ cas = nil // cases
+ stat = nil // statements
+ def = nil // defaults
+ br = Nod(OBREAK, nil, nil)
+
+ for l = sw.List; l != nil; l = l.Next {
+ n = l.N
+ setlineno(n)
+ if n.Op != OXCASE {
+ Fatal("casebody %v", Oconv(int(n.Op), 0))
+ }
+ n.Op = OCASE
+ needvar = int32(bool2int(count(n.List) != 1 || n.List.N.Op == OLITERAL))
+
+ go_ = Nod(OGOTO, newlabel_swt(), nil)
+ if n.List == nil {
+ if def != nil {
+ Yyerror("more than one default case")
+ }
+
+ // reuse original default case
+ n.Right = go_
+
+ def = n
+ }
+
+ if n.List != nil && n.List.Next == nil {
+ // one case - reuse OCASE node.
+ c = n.List.N
+
+ n.Left = c
+ n.Right = go_
+ n.List = nil
+ cas = list(cas, n)
+ } else {
+ // expand multi-valued cases
+ for lc = n.List; lc != nil; lc = lc.Next {
+ c = lc.N
+ cas = list(cas, Nod(OCASE, c, go_))
+ }
+ }
+
+ stat = list(stat, Nod(OLABEL, go_.Left, nil))
+ if typeswvar != nil && needvar != 0 && n.Nname != nil {
+ var l *NodeList
+
+ l = list1(Nod(ODCL, n.Nname, nil))
+ l = list(l, Nod(OAS, n.Nname, typeswvar))
+ typechecklist(l, Etop)
+ stat = concat(stat, l)
+ }
+
+ stat = concat(stat, n.Nbody)
+
+ // botch - shouldn't fall thru declaration
+ last = stat.End.N
+
+ if last.Xoffset == n.Xoffset && last.Op == OXFALL {
+ if typeswvar != nil {
+ setlineno(last)
+ Yyerror("cannot fallthrough in type switch")
+ }
+
+ if l.Next == nil {
+ setlineno(last)
+ Yyerror("cannot fallthrough final case in switch")
+ }
+
+ last.Op = OFALL
+ } else {
+ stat = list(stat, br)
+ }
+ }
+
+ stat = list(stat, br)
+ if def != nil {
+ cas = list(cas, def)
+ }
+
+ sw.List = cas
+ sw.Nbody = stat
+ lineno = lno
+}
+
+func mkcaselist(sw *Node, arg int) *Case {
+ var n *Node
+ var c *Case
+ var c1 *Case
+ var c2 *Case
+ var l *NodeList
+ var ord int
+
+ c = nil
+ ord = 0
+
+ for l = sw.List; l != nil; l = l.Next {
+ n = l.N
+ c1 = new(Case)
+ c1.link = c
+ c = c1
+
+ ord++
+ if int(uint16(ord)) != ord {
+ Fatal("too many cases in switch")
+ }
+ c.ordinal = uint16(ord)
+ c.node = n
+
+ if n.Left == nil {
+ c.type_ = Tdefault
+ continue
+ }
+
+ switch arg {
+ case Stype:
+ c.hash = 0
+ if n.Left.Op == OLITERAL {
+ c.type_ = Ttypenil
+ continue
+ }
+
+ if Istype(n.Left.Type, TINTER) != 0 {
+ c.type_ = Ttypevar
+ continue
+ }
+
+ c.hash = typehash(n.Left.Type)
+ c.type_ = Ttypeconst
+ continue
+
+ case Snorm,
+ Strue,
+ Sfalse:
+ c.type_ = Texprvar
+ c.hash = typehash(n.Left.Type)
+ switch consttype(n.Left) {
+ case CTFLT,
+ CTINT,
+ CTRUNE,
+ CTSTR:
+ c.type_ = Texprconst
+ }
+
+ continue
+ }
+ }
+
+ if c == nil {
+ return nil
+ }
+
+ // sort by value and diagnose duplicate cases
+ switch arg {
+ case Stype:
+ c = csort(c, typecmp)
+ for c1 = c; c1 != nil; c1 = c1.link {
+ for c2 = c1.link; c2 != nil && c2.hash == c1.hash; c2 = c2.link {
+ if c1.type_ == Ttypenil || c1.type_ == Tdefault {
+ break
+ }
+ if c2.type_ == Ttypenil || c2.type_ == Tdefault {
+ break
+ }
+ if !Eqtype(c1.node.Left.Type, c2.node.Left.Type) {
+ continue
+ }
+ yyerrorl(int(c2.node.Lineno), "duplicate case %v in type switch\n\tprevious case at %v", Tconv(c2.node.Left.Type, 0), c1.node.Line())
+ }
+ }
+
+ case Snorm,
+ Strue,
+ Sfalse:
+ c = csort(c, exprcmp)
+ for c1 = c; c1.link != nil; c1 = c1.link {
+ if exprcmp(c1, c1.link) != 0 {
+ continue
+ }
+ setlineno(c1.link.node)
+ Yyerror("duplicate case %v in switch\n\tprevious case at %v", Nconv(c1.node.Left, 0), c1.node.Line())
+ }
+ }
+
+ // put list back in processing order
+ c = csort(c, ordlcmp)
+
+ return c
+}
+
+var exprname *Node
+
+func exprbsw(c0 *Case, ncase int, arg int) *Node {
+ var cas *NodeList
+ var a *Node
+ var n *Node
+ var c *Case
+ var i int
+ var half int
+ var lno int
+
+ cas = nil
+ if ncase < Ncase {
+ for i = 0; i < ncase; i++ {
+ n = c0.node
+ lno = int(setlineno(n))
+
+ if (arg != Strue && arg != Sfalse) || assignop(n.Left.Type, exprname.Type, nil) == OCONVIFACE || assignop(exprname.Type, n.Left.Type, nil) == OCONVIFACE {
+ a = Nod(OIF, nil, nil)
+ a.Ntest = Nod(OEQ, exprname, n.Left) // if name == val
+ typecheck(&a.Ntest, Erv)
+ a.Nbody = list1(n.Right) // then goto l
+ } else if arg == Strue {
+ a = Nod(OIF, nil, nil)
+ a.Ntest = n.Left // if val
+ a.Nbody = list1(n.Right) // then goto l // arg == Sfalse
+ } else {
+ a = Nod(OIF, nil, nil)
+ a.Ntest = Nod(ONOT, n.Left, nil) // if !val
+ typecheck(&a.Ntest, Erv)
+ a.Nbody = list1(n.Right) // then goto l
+ }
+
+ cas = list(cas, a)
+ c0 = c0.link
+ lineno = int32(lno)
+ }
+
+ return liststmt(cas)
+ }
+
+ // find the middle and recur
+ c = c0
+
+ half = ncase >> 1
+ for i = 1; i < half; i++ {
+ c = c.link
+ }
+ a = Nod(OIF, nil, nil)
+ a.Ntest = Nod(OLE, exprname, c.node.Left)
+ typecheck(&a.Ntest, Erv)
+ a.Nbody = list1(exprbsw(c0, half, arg))
+ a.Nelse = list1(exprbsw(c.link, ncase-half, arg))
+ return a
+}
+
+/*
+ * normal (expression) switch.
+ * rebuild case statements into if .. goto
+ */
+func exprswitch(sw *Node) {
+ var def *Node
+ var cas *NodeList
+ var a *Node
+ var c0 *Case
+ var c *Case
+ var c1 *Case
+ var t *Type
+ var arg int
+ var ncase int
+
+ casebody(sw, nil)
+
+ arg = Snorm
+ if Isconst(sw.Ntest, CTBOOL) != 0 {
+ arg = Strue
+ if sw.Ntest.Val.U.Bval == 0 {
+ arg = Sfalse
+ }
+ }
+
+ walkexpr(&sw.Ntest, &sw.Ninit)
+ t = sw.Type
+ if t == nil {
+ return
+ }
+
+ /*
+ * convert the switch into OIF statements
+ */
+ exprname = nil
+
+ cas = nil
+ if arg == Strue || arg == Sfalse {
+ exprname = Nodbool(bool2int(arg == Strue))
+ } else if consttype(sw.Ntest) >= 0 {
+ // leave constants to enable dead code elimination (issue 9608)
+ exprname = sw.Ntest
+ } else {
+ exprname = temp(sw.Ntest.Type)
+ cas = list1(Nod(OAS, exprname, sw.Ntest))
+ typechecklist(cas, Etop)
+ }
+
+ c0 = mkcaselist(sw, arg)
+ if c0 != nil && c0.type_ == Tdefault {
+ def = c0.node.Right
+ c0 = c0.link
+ } else {
+ def = Nod(OBREAK, nil, nil)
+ }
+
+loop:
+ if c0 == nil {
+ cas = list(cas, def)
+ sw.Nbody = concat(cas, sw.Nbody)
+ sw.List = nil
+ walkstmtlist(sw.Nbody)
+ return
+ }
+
+ // deal with the variables one-at-a-time
+ if !(okforcmp[t.Etype] != 0) || c0.type_ != Texprconst {
+ a = exprbsw(c0, 1, arg)
+ cas = list(cas, a)
+ c0 = c0.link
+ goto loop
+ }
+
+ // do binary search on run of constants
+ ncase = 1
+
+ for c = c0; c.link != nil; c = c.link {
+ if c.link.type_ != Texprconst {
+ break
+ }
+ ncase++
+ }
+
+ // break the chain at the count
+ c1 = c.link
+
+ c.link = nil
+
+ // sort and compile constants
+ c0 = csort(c0, exprcmp)
+
+ a = exprbsw(c0, ncase, arg)
+ cas = list(cas, a)
+
+ c0 = c1
+ goto loop
+}
+
+var hashname *Node
+
+var facename *Node
+
+var boolname *Node
+
+func typeone(t *Node) *Node {
+ var init *NodeList
+ var a *Node
+ var b *Node
+ var var_ *Node
+
+ var_ = t.Nname
+ init = nil
+ if var_ == nil {
+ typecheck(&nblank, Erv|Easgn)
+ var_ = nblank
+ } else {
+ init = list1(Nod(ODCL, var_, nil))
+ }
+
+ a = Nod(OAS2, nil, nil)
+ a.List = list(list1(var_), boolname) // var,bool =
+ b = Nod(ODOTTYPE, facename, nil)
+ b.Type = t.Left.Type // interface.(type)
+ a.Rlist = list1(b)
+ typecheck(&a, Etop)
+ init = list(init, a)
+
+ b = Nod(OIF, nil, nil)
+ b.Ntest = boolname
+ b.Nbody = list1(t.Right) // if bool { goto l }
+ a = liststmt(list(init, b))
+ return a
+}
+
+func typebsw(c0 *Case, ncase int) *Node {
+ var cas *NodeList
+ var a *Node
+ var n *Node
+ var c *Case
+ var i int
+ var half int
+
+ cas = nil
+
+ if ncase < Ncase {
+ for i = 0; i < ncase; i++ {
+ n = c0.node
+ if c0.type_ != Ttypeconst {
+ Fatal("typebsw")
+ }
+ a = Nod(OIF, nil, nil)
+ a.Ntest = Nod(OEQ, hashname, Nodintconst(int64(c0.hash)))
+ typecheck(&a.Ntest, Erv)
+ a.Nbody = list1(n.Right)
+ cas = list(cas, a)
+ c0 = c0.link
+ }
+
+ return liststmt(cas)
+ }
+
+ // find the middle and recur
+ c = c0
+
+ half = ncase >> 1
+ for i = 1; i < half; i++ {
+ c = c.link
+ }
+ a = Nod(OIF, nil, nil)
+ a.Ntest = Nod(OLE, hashname, Nodintconst(int64(c.hash)))
+ typecheck(&a.Ntest, Erv)
+ a.Nbody = list1(typebsw(c0, half))
+ a.Nelse = list1(typebsw(c.link, ncase-half))
+ return a
+}
+
+/*
+ * convert switch of the form
+ * switch v := i.(type) { case t1: ..; case t2: ..; }
+ * into if statements
+ */
+func typeswitch(sw *Node) {
+ var def *Node
+ var cas *NodeList
+ var hash *NodeList
+ var a *Node
+ var n *Node
+ var c *Case
+ var c0 *Case
+ var c1 *Case
+ var ncase int
+ var t *Type
+ var v Val
+
+ if sw.Ntest == nil {
+ return
+ }
+ if sw.Ntest.Right == nil {
+ setlineno(sw)
+ Yyerror("type switch must have an assignment")
+ return
+ }
+
+ walkexpr(&sw.Ntest.Right, &sw.Ninit)
+ if !(Istype(sw.Ntest.Right.Type, TINTER) != 0) {
+ Yyerror("type switch must be on an interface")
+ return
+ }
+
+ cas = nil
+
+ /*
+ * predeclare temporary variables
+ * and the boolean var
+ */
+ facename = temp(sw.Ntest.Right.Type)
+
+ a = Nod(OAS, facename, sw.Ntest.Right)
+ typecheck(&a, Etop)
+ cas = list(cas, a)
+
+ casebody(sw, facename)
+
+ boolname = temp(Types[TBOOL])
+ typecheck(&boolname, Erv)
+
+ hashname = temp(Types[TUINT32])
+ typecheck(&hashname, Erv)
+
+ t = sw.Ntest.Right.Type
+ if isnilinter(t) != 0 {
+ a = syslook("efacethash", 1)
+ } else {
+ a = syslook("ifacethash", 1)
+ }
+ argtype(a, t)
+ a = Nod(OCALL, a, nil)
+ a.List = list1(facename)
+ a = Nod(OAS, hashname, a)
+ typecheck(&a, Etop)
+ cas = list(cas, a)
+
+ c0 = mkcaselist(sw, Stype)
+ if c0 != nil && c0.type_ == Tdefault {
+ def = c0.node.Right
+ c0 = c0.link
+ } else {
+ def = Nod(OBREAK, nil, nil)
+ }
+
+ /*
+ * insert if statement into each case block
+ */
+ for c = c0; c != nil; c = c.link {
+ n = c.node
+ switch c.type_ {
+ case Ttypenil:
+ v.Ctype = CTNIL
+ a = Nod(OIF, nil, nil)
+ a.Ntest = Nod(OEQ, facename, nodlit(v))
+ typecheck(&a.Ntest, Erv)
+ a.Nbody = list1(n.Right) // if i==nil { goto l }
+ n.Right = a
+
+ case Ttypevar,
+ Ttypeconst:
+ n.Right = typeone(n)
+ }
+ }
+
+ /*
+ * generate list of if statements, binary search for constant sequences
+ */
+ for c0 != nil {
+ if c0.type_ != Ttypeconst {
+ n = c0.node
+ cas = list(cas, n.Right)
+ c0 = c0.link
+ continue
+ }
+
+ // identify run of constants
+ c = c0
+ c1 = c
+
+ for c.link != nil && c.link.type_ == Ttypeconst {
+ c = c.link
+ }
+ c0 = c.link
+ c.link = nil
+
+ // sort by hash
+ c1 = csort(c1, typecmp)
+
+ // for debugging: linear search
+ if false {
+ for c = c1; c != nil; c = c.link {
+ n = c.node
+ cas = list(cas, n.Right)
+ }
+
+ continue
+ }
+
+ // combine adjacent cases with the same hash
+ ncase = 0
+
+ for c = c1; c != nil; c = c.link {
+ ncase++
+ hash = list1(c.node.Right)
+ for c.link != nil && c.link.hash == c.hash {
+ hash = list(hash, c.link.node.Right)
+ c.link = c.link.link
+ }
+
+ c.node.Right = liststmt(hash)
+ }
+
+ // binary search among cases to narrow by hash
+ cas = list(cas, typebsw(c1, ncase))
+ }
+
+ if nerrors == 0 {
+ cas = list(cas, def)
+ sw.Nbody = concat(cas, sw.Nbody)
+ sw.List = nil
+ walkstmtlist(sw.Nbody)
+ }
+}
+
+func walkswitch(sw *Node) {
+ /*
+ * reorder the body into (OLIST, cases, statements)
+ * cases have OGOTO into statements.
+ * both have inserted OBREAK statements
+ */
+ if sw.Ntest == nil {
+ sw.Ntest = Nodbool(1)
+ typecheck(&sw.Ntest, Erv)
+ }
+
+ if sw.Ntest.Op == OTYPESW {
+ typeswitch(sw)
+
+ //dump("sw", sw);
+ return
+ }
+
+ exprswitch(sw)
+
+ // Discard old AST elements after a walk. They can confuse racewealk.
+ sw.Ntest = nil
+
+ sw.List = nil
+}
+
+/*
+ * type check switch statement
+ */
+func typecheckswitch(n *Node) {
+ var top int
+ var lno int
+ var ptr int
+ var nilonly string
+ var t *Type
+ var badtype *Type
+ var missing *Type
+ var have *Type
+ var l *NodeList
+ var ll *NodeList
+ var ncase *Node
+ var nvar *Node
+ var def *Node
+
+ lno = int(lineno)
+ typechecklist(n.Ninit, Etop)
+ nilonly = ""
+
+ if n.Ntest != nil && n.Ntest.Op == OTYPESW {
+ // type switch
+ top = Etype
+
+ typecheck(&n.Ntest.Right, Erv)
+ t = n.Ntest.Right.Type
+ if t != nil && t.Etype != TINTER {
+ Yyerror("cannot type switch on non-interface value %v", Nconv(n.Ntest.Right, obj.FmtLong))
+ }
+ } else {
+ // value switch
+ top = Erv
+
+ if n.Ntest != nil {
+ typecheck(&n.Ntest, Erv)
+ defaultlit(&n.Ntest, nil)
+ t = n.Ntest.Type
+ } else {
+ t = Types[TBOOL]
+ }
+ if t != nil {
+ if !(okforeq[t.Etype] != 0) {
+ Yyerror("cannot switch on %v", Nconv(n.Ntest, obj.FmtLong))
+ } else if t.Etype == TARRAY && !(Isfixedarray(t) != 0) {
+ nilonly = "slice"
+ } else if t.Etype == TARRAY && Isfixedarray(t) != 0 && algtype1(t, nil) == ANOEQ {
+ Yyerror("cannot switch on %v", Nconv(n.Ntest, obj.FmtLong))
+ } else if t.Etype == TSTRUCT && algtype1(t, &badtype) == ANOEQ {
+ Yyerror("cannot switch on %v (struct containing %v cannot be compared)", Nconv(n.Ntest, obj.FmtLong), Tconv(badtype, 0))
+ } else if t.Etype == TFUNC {
+ nilonly = "func"
+ } else if t.Etype == TMAP {
+ nilonly = "map"
+ }
+ }
+ }
+
+ n.Type = t
+
+ def = nil
+ for l = n.List; l != nil; l = l.Next {
+ ncase = l.N
+ setlineno(n)
+ if ncase.List == nil {
+ // default
+ if def != nil {
+ Yyerror("multiple defaults in switch (first at %v)", def.Line())
+ } else {
+ def = ncase
+ }
+ } else {
+ for ll = ncase.List; ll != nil; ll = ll.Next {
+ setlineno(ll.N)
+ typecheck(&ll.N, Erv|Etype)
+ if ll.N.Type == nil || t == nil {
+ continue
+ }
+ setlineno(ncase)
+ switch top {
+ case Erv: // expression switch
+ defaultlit(&ll.N, t)
+
+ if ll.N.Op == OTYPE {
+ Yyerror("type %v is not an expression", Tconv(ll.N.Type, 0))
+ } else if ll.N.Type != nil && !(assignop(ll.N.Type, t, nil) != 0) && !(assignop(t, ll.N.Type, nil) != 0) {
+ if n.Ntest != nil {
+ Yyerror("invalid case %v in switch on %v (mismatched types %v and %v)", Nconv(ll.N, 0), Nconv(n.Ntest, 0), Tconv(ll.N.Type, 0), Tconv(t, 0))
+ } else {
+ Yyerror("invalid case %v in switch (mismatched types %v and bool)", Nconv(ll.N, 0), Tconv(ll.N.Type, 0))
+ }
+ } else if nilonly != "" && !(Isconst(ll.N, CTNIL) != 0) {
+ Yyerror("invalid case %v in switch (can only compare %s %v to nil)", Nconv(ll.N, 0), nilonly, Nconv(n.Ntest, 0))
+ }
+
+ case Etype: // type switch
+ if ll.N.Op == OLITERAL && Istype(ll.N.Type, TNIL) != 0 {
+ } else if ll.N.Op != OTYPE && ll.N.Type != nil { // should this be ||?
+ Yyerror("%v is not a type", Nconv(ll.N, obj.FmtLong))
+
+ // reset to original type
+ ll.N = n.Ntest.Right
+ } else if ll.N.Type.Etype != TINTER && t.Etype == TINTER && !(implements(ll.N.Type, t, &missing, &have, &ptr) != 0) {
+ if have != nil && !(missing.Broke != 0) && !(have.Broke != 0) {
+ Yyerror("impossible type switch case: %v cannot have dynamic type %v"+" (wrong type for %v method)\n\thave %v%v\n\twant %v%v", Nconv(n.Ntest.Right, obj.FmtLong), Tconv(ll.N.Type, 0), Sconv(missing.Sym, 0), Sconv(have.Sym, 0), Tconv(have.Type, obj.FmtShort), Sconv(missing.Sym, 0), Tconv(missing.Type, obj.FmtShort))
+ } else if !(missing.Broke != 0) {
+ Yyerror("impossible type switch case: %v cannot have dynamic type %v"+" (missing %v method)", Nconv(n.Ntest.Right, obj.FmtLong), Tconv(ll.N.Type, 0), Sconv(missing.Sym, 0))
+ }
+ }
+ }
+ }
+ }
+
+ if top == Etype && n.Type != nil {
+ ll = ncase.List
+ nvar = ncase.Nname
+ if nvar != nil {
+ if ll != nil && ll.Next == nil && ll.N.Type != nil && !(Istype(ll.N.Type, TNIL) != 0) {
+ // single entry type switch
+ nvar.Ntype = typenod(ll.N.Type)
+ } else {
+ // multiple entry type switch or default
+ nvar.Ntype = typenod(n.Type)
+ }
+
+ typecheck(&nvar, Erv|Easgn)
+ ncase.Nname = nvar
+ }
+ }
+
+ typechecklist(ncase.Nbody, Etop)
+ }
+
+ lineno = int32(lno)
+}
diff --git a/src/cmd/internal/gc/typecheck.go b/src/cmd/internal/gc/typecheck.go
new file mode 100644
index 0000000..9bba6e7
--- /dev/null
+++ b/src/cmd/internal/gc/typecheck.go
@@ -0,0 +1,4076 @@
+// 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
+
+import (
+ "cmd/internal/obj"
+ "fmt"
+ "math"
+ "strings"
+)
+
+/*
+ * type check the whole tree of an expression.
+ * calculates expression types.
+ * evaluates compile time constants.
+ * marks variables that escape the local frame.
+ * rewrites n->op to be more specific in some cases.
+ */
+var typecheckdefstack *NodeList
+
+/*
+ * resolve ONONAME to definition, if any.
+ */
+func resolve(n *Node) *Node {
+ var r *Node
+
+ if n != nil && n.Op == ONONAME && n.Sym != nil {
+ r = n.Sym.Def
+ if r != nil {
+ if r.Op != OIOTA {
+ n = r
+ } else if n.Iota >= 0 {
+ n = Nodintconst(int64(n.Iota))
+ }
+ }
+ }
+
+ return n
+}
+
+func typechecklist(l *NodeList, top int) {
+ for ; l != nil; l = l.Next {
+ typecheck(&l.N, top)
+ }
+}
+
+var _typekind = []string{
+ TINT: "int",
+ TUINT: "uint",
+ TINT8: "int8",
+ TUINT8: "uint8",
+ TINT16: "int16",
+ TUINT16: "uint16",
+ TINT32: "int32",
+ TUINT32: "uint32",
+ TINT64: "int64",
+ TUINT64: "uint64",
+ TUINTPTR: "uintptr",
+ TCOMPLEX64: "complex64",
+ TCOMPLEX128: "complex128",
+ TFLOAT32: "float32",
+ TFLOAT64: "float64",
+ TBOOL: "bool",
+ TSTRING: "string",
+ TPTR32: "pointer",
+ TPTR64: "pointer",
+ TUNSAFEPTR: "unsafe.Pointer",
+ TSTRUCT: "struct",
+ TINTER: "interface",
+ TCHAN: "chan",
+ TMAP: "map",
+ TARRAY: "array",
+ TFUNC: "func",
+ TNIL: "nil",
+ TIDEAL: "untyped number",
+}
+
+var typekind_buf string
+
+func typekind(t *Type) string {
+ var et int
+ var s string
+
+ if Isslice(t) != 0 {
+ return "slice"
+ }
+ et = int(t.Etype)
+ if 0 <= et && et < len(_typekind) {
+ s = _typekind[et]
+ if s != "" {
+ return s
+ }
+ }
+ typekind_buf = fmt.Sprintf("etype=%d", et)
+ return typekind_buf
+}
+
+/*
+ * sprint_depchain prints a dependency chain
+ * of nodes into fmt.
+ * It is used by typecheck in the case of OLITERAL nodes
+ * to print constant definition loops.
+ */
+func sprint_depchain(fmt_ *string, stack *NodeList, cur *Node, first *Node) {
+ var l *NodeList
+
+ for l = stack; l != nil; l = l.Next {
+ if l.N.Op == cur.Op {
+ if l.N != first {
+ sprint_depchain(fmt_, l.Next, l.N, first)
+ }
+ *fmt_ += fmt.Sprintf("\n\t%v: %v uses %v", l.N.Line(), Nconv(l.N, 0), Nconv(cur, 0))
+ return
+ }
+ }
+}
+
+/*
+ * type check node *np.
+ * replaces *np with a new pointer in some cases.
+ * returns the final value of *np as a convenience.
+ */
+
+var typecheck_tcstack *NodeList
+var typecheck_tcfree *NodeList
+
+func typecheck(np **Node, top int) *Node {
+ var n *Node
+ var lno int
+ var fmt_ string
+ var l *NodeList
+
+ // cannot type check until all the source has been parsed
+ if !(typecheckok != 0) {
+ Fatal("early typecheck")
+ }
+
+ n = *np
+ if n == nil {
+ return nil
+ }
+
+ lno = int(setlineno(n))
+
+ // Skip over parens.
+ for n.Op == OPAREN {
+ n = n.Left
+ }
+
+ // Resolve definition of name and value of iota lazily.
+ n = resolve(n)
+
+ *np = n
+
+ // Skip typecheck if already done.
+ // But re-typecheck ONAME/OTYPE/OLITERAL/OPACK node in case context has changed.
+ if n.Typecheck == 1 {
+ switch n.Op {
+ case ONAME,
+ OTYPE,
+ OLITERAL,
+ OPACK:
+ break
+
+ default:
+ lineno = int32(lno)
+ return n
+ }
+ }
+
+ if n.Typecheck == 2 {
+ // Typechecking loop. Trying printing a meaningful message,
+ // otherwise a stack trace of typechecking.
+ switch n.Op {
+ // We can already diagnose variables used as types.
+ case ONAME:
+ if top&(Erv|Etype) == Etype {
+ Yyerror("%v is not a type", Nconv(n, 0))
+ }
+
+ case OLITERAL:
+ if top&(Erv|Etype) == Etype {
+ Yyerror("%v is not a type", Nconv(n, 0))
+ break
+ }
+
+ fmt_ = ""
+ sprint_depchain(&fmt_, typecheck_tcstack, n, n)
+ yyerrorl(int(n.Lineno), "constant definition loop%s", fmt_)
+ }
+
+ if nsavederrors+nerrors == 0 {
+ fmt_ = ""
+ for l = typecheck_tcstack; l != nil; l = l.Next {
+ fmt_ += fmt.Sprintf("\n\t%v %v", l.N.Line(), Nconv(l.N, 0))
+ }
+ Yyerror("typechecking loop involving %v%s", Nconv(n, 0), fmt_)
+ }
+
+ lineno = int32(lno)
+ return n
+ }
+
+ n.Typecheck = 2
+
+ if typecheck_tcfree != nil {
+ l = typecheck_tcfree
+ typecheck_tcfree = l.Next
+ } else {
+ l = new(NodeList)
+ }
+ l.Next = typecheck_tcstack
+ l.N = n
+ typecheck_tcstack = l
+
+ typecheck1(&n, top)
+ *np = n
+ n.Typecheck = 1
+
+ if typecheck_tcstack != l {
+ Fatal("typecheck stack out of sync")
+ }
+ typecheck_tcstack = l.Next
+ l.Next = typecheck_tcfree
+ typecheck_tcfree = l
+
+ lineno = int32(lno)
+ return n
+}
+
+/*
+ * does n contain a call or receive operation?
+ */
+func callrecv(n *Node) int {
+ if n == nil {
+ return 0
+ }
+
+ switch n.Op {
+ case OCALL,
+ OCALLMETH,
+ OCALLINTER,
+ OCALLFUNC,
+ ORECV,
+ OCAP,
+ OLEN,
+ OCOPY,
+ ONEW,
+ OAPPEND,
+ ODELETE:
+ return 1
+ }
+
+ return bool2int(callrecv(n.Left) != 0 || callrecv(n.Right) != 0 || callrecv(n.Ntest) != 0 || callrecv(n.Nincr) != 0 || callrecvlist(n.Ninit) != 0 || callrecvlist(n.Nbody) != 0 || callrecvlist(n.Nelse) != 0 || callrecvlist(n.List) != 0 || callrecvlist(n.Rlist) != 0)
+}
+
+func callrecvlist(l *NodeList) int {
+ for ; l != nil; l = l.Next {
+ if callrecv(l.N) != 0 {
+ return 1
+ }
+ }
+ return 0
+}
+
+// indexlit implements typechecking of untyped values as
+// array/slice indexes. It is equivalent to defaultlit
+// except for constants of numerical kind, which are acceptable
+// whenever they can be represented by a value of type int.
+func indexlit(np **Node) {
+ var n *Node
+
+ n = *np
+ if n == nil || !(isideal(n.Type) != 0) {
+ return
+ }
+ switch consttype(n) {
+ case CTINT,
+ CTRUNE,
+ CTFLT,
+ CTCPLX:
+ defaultlit(np, Types[TINT])
+ }
+
+ defaultlit(np, nil)
+}
+
+func typecheck1(np **Node, top int) {
+ var et int
+ var aop int
+ var op int
+ var ptr int
+ var n *Node
+ var l *Node
+ var r *Node
+ var lo *Node
+ var mid *Node
+ var hi *Node
+ var args *NodeList
+ var ok int
+ var ntop int
+ var t *Type
+ var tp *Type
+ var missing *Type
+ var have *Type
+ var badtype *Type
+ var v Val
+ var why string
+ var desc string
+ var descbuf string
+ var x int64
+
+ n = *np
+
+ if n.Sym != nil {
+ if n.Op == ONAME && n.Etype != 0 && !(top&Ecall != 0) {
+ Yyerror("use of builtin %v not in function call", Sconv(n.Sym, 0))
+ goto error
+ }
+
+ typecheckdef(n)
+ if n.Op == ONONAME {
+ goto error
+ }
+ }
+
+ *np = n
+
+reswitch:
+ ok = 0
+ switch n.Op {
+ // until typecheck is complete, do nothing.
+ default:
+ Dump("typecheck", n)
+
+ Fatal("typecheck %v", Oconv(int(n.Op), 0))
+ fallthrough
+
+ /*
+ * names
+ */
+ case OLITERAL:
+ ok |= Erv
+
+ if n.Type == nil && n.Val.Ctype == CTSTR {
+ n.Type = idealstring
+ }
+ goto ret
+
+ case ONONAME:
+ ok |= Erv
+ goto ret
+
+ case ONAME:
+ if n.Decldepth == 0 {
+ n.Decldepth = decldepth
+ }
+ if n.Etype != 0 {
+ ok |= Ecall
+ goto ret
+ }
+
+ if !(top&Easgn != 0) {
+ // not a write to the variable
+ if isblank(n) {
+ Yyerror("cannot use _ as value")
+ goto error
+ }
+
+ n.Used = 1
+ }
+
+ if !(top&Ecall != 0) && isunsafebuiltin(n) != 0 {
+ Yyerror("%v is not an expression, must be called", Nconv(n, 0))
+ goto error
+ }
+
+ ok |= Erv
+ goto ret
+
+ case OPACK:
+ Yyerror("use of package %v without selector", Sconv(n.Sym, 0))
+ goto error
+
+ case ODDD:
+ break
+
+ /*
+ * types (OIND is with exprs)
+ */
+ case OTYPE:
+ ok |= Etype
+
+ if n.Type == nil {
+ goto error
+ }
+
+ case OTARRAY:
+ ok |= Etype
+ t = typ(TARRAY)
+ l = n.Left
+ r = n.Right
+ if l == nil {
+ t.Bound = -1 // slice
+ } else if l.Op == ODDD {
+ t.Bound = -100 // to be filled in
+ if !(top&Ecomplit != 0) && !(n.Diag != 0) {
+ t.Broke = 1
+ n.Diag = 1
+ Yyerror("use of [...] array outside of array literal")
+ }
+ } else {
+ l = typecheck(&n.Left, Erv)
+ switch consttype(l) {
+ case CTINT,
+ CTRUNE:
+ v = l.Val
+
+ case CTFLT:
+ v = toint(l.Val)
+
+ default:
+ if l.Type != nil && Isint[l.Type.Etype] != 0 && l.Op != OLITERAL {
+ Yyerror("non-constant array bound %v", Nconv(l, 0))
+ } else {
+ Yyerror("invalid array bound %v", Nconv(l, 0))
+ }
+ goto error
+ }
+
+ t.Bound = Mpgetfix(v.U.Xval)
+ if doesoverflow(v, Types[TINT]) != 0 {
+ Yyerror("array bound is too large")
+ goto error
+ } else if t.Bound < 0 {
+ Yyerror("array bound must be non-negative")
+ goto error
+ }
+ }
+
+ typecheck(&r, Etype)
+ if r.Type == nil {
+ goto error
+ }
+ t.Type = r.Type
+ n.Op = OTYPE
+ n.Type = t
+ n.Left = nil
+ n.Right = nil
+ if t.Bound != -100 {
+ checkwidth(t)
+ }
+
+ case OTMAP:
+ ok |= Etype
+ l = typecheck(&n.Left, Etype)
+ r = typecheck(&n.Right, Etype)
+ if l.Type == nil || r.Type == nil {
+ goto error
+ }
+ n.Op = OTYPE
+ n.Type = maptype(l.Type, r.Type)
+ n.Left = nil
+ n.Right = nil
+
+ case OTCHAN:
+ ok |= Etype
+ l = typecheck(&n.Left, Etype)
+ if l.Type == nil {
+ goto error
+ }
+ t = typ(TCHAN)
+ t.Type = l.Type
+ t.Chan = n.Etype
+ n.Op = OTYPE
+ n.Type = t
+ n.Left = nil
+ n.Etype = 0
+
+ case OTSTRUCT:
+ ok |= Etype
+ n.Op = OTYPE
+ n.Type = tostruct(n.List)
+ if n.Type == nil || n.Type.Broke != 0 {
+ goto error
+ }
+ n.List = nil
+
+ case OTINTER:
+ ok |= Etype
+ n.Op = OTYPE
+ n.Type = tointerface(n.List)
+ if n.Type == nil {
+ goto error
+ }
+
+ case OTFUNC:
+ ok |= Etype
+ n.Op = OTYPE
+ n.Type = functype(n.Left, n.List, n.Rlist)
+ if n.Type == nil {
+ goto error
+ }
+
+ /*
+ * type or expr
+ */
+ case OIND:
+ ntop = Erv | Etype
+
+ if !(top&Eaddr != 0) { // The *x in &*x is not an indirect.
+ ntop |= Eindir
+ }
+ ntop |= top & Ecomplit
+ l = typecheck(&n.Left, ntop)
+ t = l.Type
+ if t == nil {
+ goto error
+ }
+ if l.Op == OTYPE {
+ ok |= Etype
+ n.Op = OTYPE
+ n.Type = Ptrto(l.Type)
+ n.Left = nil
+ goto ret
+ }
+
+ if !(Isptr[t.Etype] != 0) {
+ if top&(Erv|Etop) != 0 {
+ Yyerror("invalid indirect of %v", Nconv(n.Left, obj.FmtLong))
+ goto error
+ }
+
+ goto ret
+ }
+
+ ok |= Erv
+ n.Type = t.Type
+ goto ret
+
+ /*
+ * arithmetic exprs
+ */
+ case OASOP:
+ ok |= Etop
+
+ l = typecheck(&n.Left, Erv)
+ r = typecheck(&n.Right, Erv)
+ checkassign(n, n.Left)
+ if l.Type == nil || r.Type == nil {
+ goto error
+ }
+ op = int(n.Etype)
+ goto arith
+
+ case OADD,
+ OAND,
+ OANDAND,
+ OANDNOT,
+ ODIV,
+ OEQ,
+ OGE,
+ OGT,
+ OLE,
+ OLT,
+ OLSH,
+ ORSH,
+ OMOD,
+ OMUL,
+ ONE,
+ OOR,
+ OOROR,
+ OSUB,
+ OXOR:
+ ok |= Erv
+ l = typecheck(&n.Left, Erv|top&Eiota)
+ r = typecheck(&n.Right, Erv|top&Eiota)
+ if l.Type == nil || r.Type == nil {
+ goto error
+ }
+ op = int(n.Op)
+ goto arith
+
+ case OCOM,
+ OMINUS,
+ ONOT,
+ OPLUS:
+ ok |= Erv
+ l = typecheck(&n.Left, Erv|top&Eiota)
+ t = l.Type
+ if t == nil {
+ goto error
+ }
+ if !(okfor[n.Op][t.Etype] != 0) {
+ Yyerror("invalid operation: %v %v", Oconv(int(n.Op), 0), Tconv(t, 0))
+ goto error
+ }
+
+ n.Type = t
+ goto ret
+
+ /*
+ * exprs
+ */
+ case OADDR:
+ ok |= Erv
+
+ typecheck(&n.Left, Erv|Eaddr)
+ if n.Left.Type == nil {
+ goto error
+ }
+ checklvalue(n.Left, "take the address of")
+ r = outervalue(n.Left)
+ for l = n.Left; l != r; l = l.Left {
+ l.Addrtaken = 1
+ if l.Closure != nil {
+ l.Closure.Addrtaken = 1
+ }
+ }
+
+ if l.Orig != l && l.Op == ONAME {
+ Fatal("found non-orig name node %v", Nconv(l, 0))
+ }
+ l.Addrtaken = 1
+ if l.Closure != nil {
+ l.Closure.Addrtaken = 1
+ }
+ defaultlit(&n.Left, nil)
+ l = n.Left
+ t = l.Type
+ if t == nil {
+ goto error
+ }
+ n.Type = Ptrto(t)
+ goto ret
+
+ case OCOMPLIT:
+ ok |= Erv
+ typecheckcomplit(&n)
+ if n.Type == nil {
+ goto error
+ }
+ goto ret
+
+ case OXDOT:
+ n = adddot(n)
+ n.Op = ODOT
+ if n.Left == nil {
+ goto error
+ }
+ fallthrough
+
+ // fall through
+ case ODOT:
+ typecheck(&n.Left, Erv|Etype)
+
+ defaultlit(&n.Left, nil)
+ if n.Right.Op != ONAME {
+ Yyerror("rhs of . must be a name") // impossible
+ goto error
+ }
+
+ t = n.Left.Type
+ if t == nil {
+ adderrorname(n)
+ goto error
+ }
+
+ r = n.Right
+
+ if n.Left.Op == OTYPE {
+ if !(looktypedot(n, t, 0) != 0) {
+ if looktypedot(n, t, 1) != 0 {
+ Yyerror("%v undefined (cannot refer to unexported method %v)", Nconv(n, 0), Sconv(n.Right.Sym, 0))
+ } else {
+ Yyerror("%v undefined (type %v has no method %v)", Nconv(n, 0), Tconv(t, 0), Sconv(n.Right.Sym, 0))
+ }
+ goto error
+ }
+
+ if n.Type.Etype != TFUNC || n.Type.Thistuple != 1 {
+ Yyerror("type %v has no method %v", Tconv(n.Left.Type, 0), Sconv(n.Right.Sym, obj.FmtShort))
+ n.Type = nil
+ goto error
+ }
+
+ n.Op = ONAME
+ n.Sym = n.Right.Sym
+ n.Type = methodfunc(n.Type, n.Left.Type)
+ n.Xoffset = 0
+ n.Class = PFUNC
+ ok = Erv
+ goto ret
+ }
+
+ if Isptr[t.Etype] != 0 && t.Type.Etype != TINTER {
+ t = t.Type
+ if t == nil {
+ goto error
+ }
+ n.Op = ODOTPTR
+ checkwidth(t)
+ }
+
+ if isblank(n.Right) {
+ Yyerror("cannot refer to blank field or method")
+ goto error
+ }
+
+ if !(lookdot(n, t, 0) != 0) {
+ if lookdot(n, t, 1) != 0 {
+ Yyerror("%v undefined (cannot refer to unexported field or method %v)", Nconv(n, 0), Sconv(n.Right.Sym, 0))
+ } else {
+ Yyerror("%v undefined (type %v has no field or method %v)", Nconv(n, 0), Tconv(n.Left.Type, 0), Sconv(n.Right.Sym, 0))
+ }
+ goto error
+ }
+
+ switch n.Op {
+ case ODOTINTER,
+ ODOTMETH:
+ if top&Ecall != 0 {
+ ok |= Ecall
+ } else {
+ typecheckpartialcall(n, r)
+ ok |= Erv
+ }
+
+ default:
+ ok |= Erv
+ }
+
+ goto ret
+
+ case ODOTTYPE:
+ ok |= Erv
+ typecheck(&n.Left, Erv)
+ defaultlit(&n.Left, nil)
+ l = n.Left
+ t = l.Type
+ if t == nil {
+ goto error
+ }
+ if !(Isinter(t) != 0) {
+ Yyerror("invalid type assertion: %v (non-interface type %v on left)", Nconv(n, 0), Tconv(t, 0))
+ goto error
+ }
+
+ if n.Right != nil {
+ typecheck(&n.Right, Etype)
+ n.Type = n.Right.Type
+ n.Right = nil
+ if n.Type == nil {
+ goto error
+ }
+ }
+
+ if n.Type != nil && n.Type.Etype != TINTER {
+ if !(implements(n.Type, t, &missing, &have, &ptr) != 0) {
+ if have != nil && have.Sym == missing.Sym {
+ Yyerror("impossible type assertion:\n\t%v does not implement %v (wrong type for %v method)\n"+"\t\thave %v%v\n\t\twant %v%v", Tconv(n.Type, 0), Tconv(t, 0), Sconv(missing.Sym, 0), Sconv(have.Sym, 0), Tconv(have.Type, obj.FmtShort|obj.FmtByte), Sconv(missing.Sym, 0), Tconv(missing.Type, obj.FmtShort|obj.FmtByte))
+ } else if ptr != 0 {
+ Yyerror("impossible type assertion:\n\t%v does not implement %v (%v method has pointer receiver)", Tconv(n.Type, 0), Tconv(t, 0), Sconv(missing.Sym, 0))
+ } else if have != nil {
+ Yyerror("impossible type assertion:\n\t%v does not implement %v (missing %v method)\n"+"\t\thave %v%v\n\t\twant %v%v", Tconv(n.Type, 0), Tconv(t, 0), Sconv(missing.Sym, 0), Sconv(have.Sym, 0), Tconv(have.Type, obj.FmtShort|obj.FmtByte), Sconv(missing.Sym, 0), Tconv(missing.Type, obj.FmtShort|obj.FmtByte))
+ } else {
+ Yyerror("impossible type assertion:\n\t%v does not implement %v (missing %v method)", Tconv(n.Type, 0), Tconv(t, 0), Sconv(missing.Sym, 0))
+ }
+ goto error
+ }
+ }
+
+ goto ret
+
+ case OINDEX:
+ ok |= Erv
+ typecheck(&n.Left, Erv)
+ defaultlit(&n.Left, nil)
+ implicitstar(&n.Left)
+ l = n.Left
+ typecheck(&n.Right, Erv)
+ r = n.Right
+ t = l.Type
+ if t == nil || r.Type == nil {
+ goto error
+ }
+ switch t.Etype {
+ default:
+ Yyerror("invalid operation: %v (type %v does not support indexing)", Nconv(n, 0), Tconv(t, 0))
+ goto error
+
+ case TSTRING,
+ TARRAY:
+ indexlit(&n.Right)
+ if t.Etype == TSTRING {
+ n.Type = Types[TUINT8]
+ } else {
+ n.Type = t.Type
+ }
+ why = "string"
+ if t.Etype == TARRAY {
+ if Isfixedarray(t) != 0 {
+ why = "array"
+ } else {
+ why = "slice"
+ }
+ }
+
+ if n.Right.Type != nil && !(Isint[n.Right.Type.Etype] != 0) {
+ Yyerror("non-integer %s index %v", why, Nconv(n.Right, 0))
+ break
+ }
+
+ if Isconst(n.Right, CTINT) != 0 {
+ x = Mpgetfix(n.Right.Val.U.Xval)
+ if x < 0 {
+ Yyerror("invalid %s index %v (index must be non-negative)", why, Nconv(n.Right, 0))
+ } else if Isfixedarray(t) != 0 && t.Bound > 0 && x >= t.Bound {
+ Yyerror("invalid array index %v (out of bounds for %d-element array)", Nconv(n.Right, 0), t.Bound)
+ } else if Isconst(n.Left, CTSTR) != 0 && x >= int64(len(n.Left.Val.U.Sval.S)) {
+ Yyerror("invalid string index %v (out of bounds for %d-byte string)", Nconv(n.Right, 0), len(n.Left.Val.U.Sval.S))
+ } else if Mpcmpfixfix(n.Right.Val.U.Xval, Maxintval[TINT]) > 0 {
+ Yyerror("invalid %s index %v (index too large)", why, Nconv(n.Right, 0))
+ }
+ }
+
+ case TMAP:
+ n.Etype = 0
+ defaultlit(&n.Right, t.Down)
+ if n.Right.Type != nil {
+ n.Right = assignconv(n.Right, t.Down, "map index")
+ }
+ n.Type = t.Type
+ n.Op = OINDEXMAP
+ }
+
+ goto ret
+
+ case ORECV:
+ ok |= Etop | Erv
+ typecheck(&n.Left, Erv)
+ defaultlit(&n.Left, nil)
+ l = n.Left
+ t = l.Type
+ if t == nil {
+ goto error
+ }
+ if t.Etype != TCHAN {
+ Yyerror("invalid operation: %v (receive from non-chan type %v)", Nconv(n, 0), Tconv(t, 0))
+ goto error
+ }
+
+ if !(t.Chan&Crecv != 0) {
+ Yyerror("invalid operation: %v (receive from send-only type %v)", Nconv(n, 0), Tconv(t, 0))
+ goto error
+ }
+
+ n.Type = t.Type
+ goto ret
+
+ case OSEND:
+ ok |= Etop
+ l = typecheck(&n.Left, Erv)
+ typecheck(&n.Right, Erv)
+ defaultlit(&n.Left, nil)
+ l = n.Left
+ t = l.Type
+ if t == nil {
+ goto error
+ }
+ if t.Etype != TCHAN {
+ Yyerror("invalid operation: %v (send to non-chan type %v)", Nconv(n, 0), Tconv(t, 0))
+ goto error
+ }
+
+ if !(t.Chan&Csend != 0) {
+ Yyerror("invalid operation: %v (send to receive-only type %v)", Nconv(n, 0), Tconv(t, 0))
+ goto error
+ }
+
+ defaultlit(&n.Right, t.Type)
+ r = n.Right
+ if r.Type == nil {
+ goto error
+ }
+ n.Right = assignconv(r, l.Type.Type, "send")
+
+ // TODO: more aggressive
+ n.Etype = 0
+
+ n.Type = nil
+ goto ret
+
+ case OSLICE:
+ ok |= Erv
+ typecheck(&n.Left, top)
+ typecheck(&n.Right.Left, Erv)
+ typecheck(&n.Right.Right, Erv)
+ defaultlit(&n.Left, nil)
+ indexlit(&n.Right.Left)
+ indexlit(&n.Right.Right)
+ l = n.Left
+ if Isfixedarray(l.Type) != 0 {
+ if !(islvalue(n.Left) != 0) {
+ Yyerror("invalid operation %v (slice of unaddressable value)", Nconv(n, 0))
+ goto error
+ }
+
+ n.Left = Nod(OADDR, n.Left, nil)
+ n.Left.Implicit = 1
+ typecheck(&n.Left, Erv)
+ l = n.Left
+ }
+
+ t = l.Type
+ if t == nil {
+ goto error
+ }
+ tp = nil
+ if Istype(t, TSTRING) != 0 {
+ n.Type = t
+ n.Op = OSLICESTR
+ } else if Isptr[t.Etype] != 0 && Isfixedarray(t.Type) != 0 {
+ tp = t.Type
+ n.Type = typ(TARRAY)
+ n.Type.Type = tp.Type
+ n.Type.Bound = -1
+ dowidth(n.Type)
+ n.Op = OSLICEARR
+ } else if Isslice(t) != 0 {
+ n.Type = t
+ } else {
+ Yyerror("cannot slice %v (type %v)", Nconv(l, 0), Tconv(t, 0))
+ goto error
+ }
+
+ lo = n.Right.Left
+ if lo != nil && checksliceindex(l, lo, tp) < 0 {
+ goto error
+ }
+ hi = n.Right.Right
+ if hi != nil && checksliceindex(l, hi, tp) < 0 {
+ goto error
+ }
+ if checksliceconst(lo, hi) < 0 {
+ goto error
+ }
+ goto ret
+
+ case OSLICE3:
+ ok |= Erv
+ typecheck(&n.Left, top)
+ typecheck(&n.Right.Left, Erv)
+ typecheck(&n.Right.Right.Left, Erv)
+ typecheck(&n.Right.Right.Right, Erv)
+ defaultlit(&n.Left, nil)
+ indexlit(&n.Right.Left)
+ indexlit(&n.Right.Right.Left)
+ indexlit(&n.Right.Right.Right)
+ l = n.Left
+ if Isfixedarray(l.Type) != 0 {
+ if !(islvalue(n.Left) != 0) {
+ Yyerror("invalid operation %v (slice of unaddressable value)", Nconv(n, 0))
+ goto error
+ }
+
+ n.Left = Nod(OADDR, n.Left, nil)
+ n.Left.Implicit = 1
+ typecheck(&n.Left, Erv)
+ l = n.Left
+ }
+
+ t = l.Type
+ if t == nil {
+ goto error
+ }
+ tp = nil
+ if Istype(t, TSTRING) != 0 {
+ Yyerror("invalid operation %v (3-index slice of string)", Nconv(n, 0))
+ goto error
+ }
+
+ if Isptr[t.Etype] != 0 && Isfixedarray(t.Type) != 0 {
+ tp = t.Type
+ n.Type = typ(TARRAY)
+ n.Type.Type = tp.Type
+ n.Type.Bound = -1
+ dowidth(n.Type)
+ n.Op = OSLICE3ARR
+ } else if Isslice(t) != 0 {
+ n.Type = t
+ } else {
+ Yyerror("cannot slice %v (type %v)", Nconv(l, 0), Tconv(t, 0))
+ goto error
+ }
+
+ lo = n.Right.Left
+ if lo != nil && checksliceindex(l, lo, tp) < 0 {
+ goto error
+ }
+ mid = n.Right.Right.Left
+ if mid != nil && checksliceindex(l, mid, tp) < 0 {
+ goto error
+ }
+ hi = n.Right.Right.Right
+ if hi != nil && checksliceindex(l, hi, tp) < 0 {
+ goto error
+ }
+ if checksliceconst(lo, hi) < 0 || checksliceconst(lo, mid) < 0 || checksliceconst(mid, hi) < 0 {
+ goto error
+ }
+ goto ret
+
+ /*
+ * call and call like
+ */
+ case OCALL:
+ l = n.Left
+
+ if l.Op == ONAME {
+ r = unsafenmagic(n)
+ if r != nil {
+ if n.Isddd != 0 {
+ Yyerror("invalid use of ... with builtin %v", Nconv(l, 0))
+ }
+ n = r
+ goto reswitch
+ }
+ }
+
+ typecheck(&n.Left, Erv|Etype|Ecall|top&Eproc)
+ n.Diag |= n.Left.Diag
+ l = n.Left
+ if l.Op == ONAME && l.Etype != 0 {
+ if n.Isddd != 0 && l.Etype != OAPPEND {
+ Yyerror("invalid use of ... with builtin %v", Nconv(l, 0))
+ }
+
+ // builtin: OLEN, OCAP, etc.
+ n.Op = l.Etype
+
+ n.Left = n.Right
+ n.Right = nil
+ goto reswitch
+ }
+
+ defaultlit(&n.Left, nil)
+ l = n.Left
+ if l.Op == OTYPE {
+ if n.Isddd != 0 || l.Type.Bound == -100 {
+ if !(l.Type.Broke != 0) {
+ Yyerror("invalid use of ... in type conversion", l)
+ }
+ n.Diag = 1
+ }
+
+ // pick off before type-checking arguments
+ ok |= Erv
+
+ // turn CALL(type, arg) into CONV(arg) w/ type
+ n.Left = nil
+
+ n.Op = OCONV
+ n.Type = l.Type
+ if onearg(n, "conversion to %v", Tconv(l.Type, 0)) < 0 {
+ goto error
+ }
+ goto doconv
+ }
+
+ if count(n.List) == 1 && !(n.Isddd != 0) {
+ typecheck(&n.List.N, Erv|Efnstruct)
+ } else {
+ typechecklist(n.List, Erv)
+ }
+ t = l.Type
+ if t == nil {
+ goto error
+ }
+ checkwidth(t)
+
+ switch l.Op {
+ case ODOTINTER:
+ n.Op = OCALLINTER
+
+ case ODOTMETH:
+ n.Op = OCALLMETH
+
+ // typecheckaste was used here but there wasn't enough
+ // information further down the call chain to know if we
+ // were testing a method receiver for unexported fields.
+ // It isn't necessary, so just do a sanity check.
+ tp = getthisx(t).Type.Type
+
+ if l.Left == nil || !Eqtype(l.Left.Type, tp) {
+ Fatal("method receiver")
+ }
+
+ default:
+ n.Op = OCALLFUNC
+ if t.Etype != TFUNC {
+ Yyerror("cannot call non-function %v (type %v)", Nconv(l, 0), Tconv(t, 0))
+ goto error
+ }
+ }
+
+ descbuf = fmt.Sprintf("argument to %v", Nconv(n.Left, 0))
+ desc = descbuf
+ typecheckaste(OCALL, n.Left, int(n.Isddd), getinargx(t), n.List, desc)
+ ok |= Etop
+ if t.Outtuple == 0 {
+ goto ret
+ }
+ ok |= Erv
+ if t.Outtuple == 1 {
+ t = getoutargx(l.Type).Type
+ if t == nil {
+ goto error
+ }
+ if t.Etype == TFIELD {
+ t = t.Type
+ }
+ n.Type = t
+ goto ret
+ }
+
+ // multiple return
+ if !(top&(Efnstruct|Etop) != 0) {
+ Yyerror("multiple-value %v() in single-value context", Nconv(l, 0))
+ goto ret
+ }
+
+ n.Type = getoutargx(l.Type)
+ goto ret
+
+ case OCAP,
+ OLEN,
+ OREAL,
+ OIMAG:
+ ok |= Erv
+ if onearg(n, "%v", Oconv(int(n.Op), 0)) < 0 {
+ goto error
+ }
+ typecheck(&n.Left, Erv)
+ defaultlit(&n.Left, nil)
+ implicitstar(&n.Left)
+ l = n.Left
+ t = l.Type
+ if t == nil {
+ goto error
+ }
+ switch n.Op {
+ case OCAP:
+ if !(okforcap[t.Etype] != 0) {
+ goto badcall1
+ }
+
+ case OLEN:
+ if !(okforlen[t.Etype] != 0) {
+ goto badcall1
+ }
+
+ case OREAL,
+ OIMAG:
+ if !(Iscomplex[t.Etype] != 0) {
+ goto badcall1
+ }
+ if Isconst(l, CTCPLX) != 0 {
+ r = n
+ if n.Op == OREAL {
+ n = nodfltconst(&l.Val.U.Cval.Real)
+ } else {
+ n = nodfltconst(&l.Val.U.Cval.Imag)
+ }
+ n.Orig = r
+ }
+
+ n.Type = Types[cplxsubtype(int(t.Etype))]
+ goto ret
+ }
+
+ // might be constant
+ switch t.Etype {
+ case TSTRING:
+ if Isconst(l, CTSTR) != 0 {
+ r = Nod(OXXX, nil, nil)
+ Nodconst(r, Types[TINT], int64(len(l.Val.U.Sval.S)))
+ r.Orig = n
+ n = r
+ }
+
+ case TARRAY:
+ if t.Bound < 0 { // slice
+ break
+ }
+ if callrecv(l) != 0 { // has call or receive
+ break
+ }
+ r = Nod(OXXX, nil, nil)
+ Nodconst(r, Types[TINT], t.Bound)
+ r.Orig = n
+ n = r
+ }
+
+ n.Type = Types[TINT]
+ goto ret
+
+ case OCOMPLEX:
+ ok |= Erv
+ if count(n.List) == 1 {
+ typechecklist(n.List, Efnstruct)
+ if n.List.N.Op != OCALLFUNC && n.List.N.Op != OCALLMETH {
+ Yyerror("invalid operation: complex expects two arguments")
+ goto error
+ }
+
+ t = n.List.N.Left.Type
+ if t.Outtuple != 2 {
+ Yyerror("invalid operation: complex expects two arguments, %v returns %d results", Nconv(n.List.N, 0), t.Outtuple)
+ goto error
+ }
+
+ t = n.List.N.Type.Type
+ l = t.Nname
+ r = t.Down.Nname
+ } else {
+ if twoarg(n) < 0 {
+ goto error
+ }
+ l = typecheck(&n.Left, Erv|top&Eiota)
+ r = typecheck(&n.Right, Erv|top&Eiota)
+ if l.Type == nil || r.Type == nil {
+ goto error
+ }
+ defaultlit2(&l, &r, 0)
+ if l.Type == nil || r.Type == nil {
+ goto error
+ }
+ n.Left = l
+ n.Right = r
+ }
+
+ if !Eqtype(l.Type, r.Type) {
+ Yyerror("invalid operation: %v (mismatched types %v and %v)", Nconv(n, 0), Tconv(l.Type, 0), Tconv(r.Type, 0))
+ goto error
+ }
+
+ switch l.Type.Etype {
+ default:
+ Yyerror("invalid operation: %v (arguments have type %v, expected floating-point)", Nconv(n, 0), Tconv(l.Type, 0), r.Type)
+ goto error
+
+ case TIDEAL:
+ t = Types[TIDEAL]
+
+ case TFLOAT32:
+ t = Types[TCOMPLEX64]
+
+ case TFLOAT64:
+ t = Types[TCOMPLEX128]
+ }
+
+ if l.Op == OLITERAL && r.Op == OLITERAL {
+ // make it a complex literal
+ r = nodcplxlit(l.Val, r.Val)
+
+ r.Orig = n
+ n = r
+ }
+
+ n.Type = t
+ goto ret
+
+ case OCLOSE:
+ if onearg(n, "%v", Oconv(int(n.Op), 0)) < 0 {
+ goto error
+ }
+ typecheck(&n.Left, Erv)
+ defaultlit(&n.Left, nil)
+ l = n.Left
+ t = l.Type
+ if t == nil {
+ goto error
+ }
+ if t.Etype != TCHAN {
+ Yyerror("invalid operation: %v (non-chan type %v)", Nconv(n, 0), Tconv(t, 0))
+ goto error
+ }
+
+ if !(t.Chan&Csend != 0) {
+ Yyerror("invalid operation: %v (cannot close receive-only channel)", Nconv(n, 0))
+ goto error
+ }
+
+ ok |= Etop
+ goto ret
+
+ case ODELETE:
+ args = n.List
+ if args == nil {
+ Yyerror("missing arguments to delete")
+ goto error
+ }
+
+ if args.Next == nil {
+ Yyerror("missing second (key) argument to delete")
+ goto error
+ }
+
+ if args.Next.Next != nil {
+ Yyerror("too many arguments to delete")
+ goto error
+ }
+
+ ok |= Etop
+ typechecklist(args, Erv)
+ l = args.N
+ r = args.Next.N
+ if l.Type != nil && l.Type.Etype != TMAP {
+ Yyerror("first argument to delete must be map; have %v", Tconv(l.Type, obj.FmtLong))
+ goto error
+ }
+
+ args.Next.N = assignconv(r, l.Type.Down, "delete")
+ goto ret
+
+ case OAPPEND:
+ ok |= Erv
+ args = n.List
+ if args == nil {
+ Yyerror("missing arguments to append")
+ goto error
+ }
+
+ if count(args) == 1 && !(n.Isddd != 0) {
+ typecheck(&args.N, Erv|Efnstruct)
+ } else {
+ typechecklist(args, Erv)
+ }
+
+ t = args.N.Type
+ if t == nil {
+ goto error
+ }
+
+ // Unpack multiple-return result before type-checking.
+ if Istype(t, TSTRUCT) != 0 && t.Funarg != 0 {
+ t = t.Type
+ if Istype(t, TFIELD) != 0 {
+ t = t.Type
+ }
+ }
+
+ n.Type = t
+ if !(Isslice(t) != 0) {
+ if Isconst(args.N, CTNIL) != 0 {
+ Yyerror("first argument to append must be typed slice; have untyped nil", t)
+ goto error
+ }
+
+ Yyerror("first argument to append must be slice; have %v", Tconv(t, obj.FmtLong))
+ goto error
+ }
+
+ if n.Isddd != 0 {
+ if args.Next == nil {
+ Yyerror("cannot use ... on first argument to append")
+ goto error
+ }
+
+ if args.Next.Next != nil {
+ Yyerror("too many arguments to append")
+ goto error
+ }
+
+ if Istype(t.Type, TUINT8) != 0 && Istype(args.Next.N.Type, TSTRING) != 0 {
+ defaultlit(&args.Next.N, Types[TSTRING])
+ goto ret
+ }
+
+ args.Next.N = assignconv(args.Next.N, t.Orig, "append")
+ goto ret
+ }
+
+ for args = args.Next; args != nil; args = args.Next {
+ if args.N.Type == nil {
+ continue
+ }
+ args.N = assignconv(args.N, t.Type, "append")
+ }
+
+ goto ret
+
+ case OCOPY:
+ ok |= Etop | Erv
+ args = n.List
+ if args == nil || args.Next == nil {
+ Yyerror("missing arguments to copy")
+ goto error
+ }
+
+ if args.Next.Next != nil {
+ Yyerror("too many arguments to copy")
+ goto error
+ }
+
+ n.Left = args.N
+ n.Right = args.Next.N
+ n.List = nil
+ n.Type = Types[TINT]
+ typecheck(&n.Left, Erv)
+ typecheck(&n.Right, Erv)
+ if n.Left.Type == nil || n.Right.Type == nil {
+ goto error
+ }
+ defaultlit(&n.Left, nil)
+ defaultlit(&n.Right, nil)
+ if n.Left.Type == nil || n.Right.Type == nil {
+ goto error
+ }
+
+ // copy([]byte, string)
+ if Isslice(n.Left.Type) != 0 && n.Right.Type.Etype == TSTRING {
+ if Eqtype(n.Left.Type.Type, bytetype) {
+ goto ret
+ }
+ Yyerror("arguments to copy have different element types: %v and string", Tconv(n.Left.Type, obj.FmtLong))
+ goto error
+ }
+
+ if !(Isslice(n.Left.Type) != 0) || !(Isslice(n.Right.Type) != 0) {
+ if !(Isslice(n.Left.Type) != 0) && !(Isslice(n.Right.Type) != 0) {
+ Yyerror("arguments to copy must be slices; have %v, %v", Tconv(n.Left.Type, obj.FmtLong), Tconv(n.Right.Type, obj.FmtLong))
+ } else if !(Isslice(n.Left.Type) != 0) {
+ Yyerror("first argument to copy should be slice; have %v", Tconv(n.Left.Type, obj.FmtLong))
+ } else {
+ Yyerror("second argument to copy should be slice or string; have %v", Tconv(n.Right.Type, obj.FmtLong))
+ }
+ goto error
+ }
+
+ if !Eqtype(n.Left.Type.Type, n.Right.Type.Type) {
+ Yyerror("arguments to copy have different element types: %v and %v", Tconv(n.Left.Type, obj.FmtLong), Tconv(n.Right.Type, obj.FmtLong))
+ goto error
+ }
+
+ goto ret
+
+ case OCONV:
+ goto doconv
+
+ case OMAKE:
+ ok |= Erv
+ args = n.List
+ if args == nil {
+ Yyerror("missing argument to make")
+ goto error
+ }
+
+ n.List = nil
+ l = args.N
+ args = args.Next
+ typecheck(&l, Etype)
+ t = l.Type
+ if t == nil {
+ goto error
+ }
+
+ switch t.Etype {
+ default:
+ Yyerror("cannot make type %v", Tconv(t, 0))
+ goto error
+
+ case TARRAY:
+ if !(Isslice(t) != 0) {
+ Yyerror("cannot make type %v", Tconv(t, 0))
+ goto error
+ }
+
+ if args == nil {
+ Yyerror("missing len argument to make(%v)", Tconv(t, 0))
+ goto error
+ }
+
+ l = args.N
+ args = args.Next
+ typecheck(&l, Erv)
+ r = nil
+ if args != nil {
+ r = args.N
+ args = args.Next
+ typecheck(&r, Erv)
+ }
+
+ if l.Type == nil || (r != nil && r.Type == nil) {
+ goto error
+ }
+ et = bool2int(checkmake(t, "len", l) < 0)
+ et |= bool2int(r != nil && checkmake(t, "cap", r) < 0)
+ if et != 0 {
+ goto error
+ }
+ if Isconst(l, CTINT) != 0 && r != nil && Isconst(r, CTINT) != 0 && Mpcmpfixfix(l.Val.U.Xval, r.Val.U.Xval) > 0 {
+ Yyerror("len larger than cap in make(%v)", Tconv(t, 0))
+ goto error
+ }
+
+ n.Left = l
+ n.Right = r
+ n.Op = OMAKESLICE
+
+ case TMAP:
+ if args != nil {
+ l = args.N
+ args = args.Next
+ typecheck(&l, Erv)
+ defaultlit(&l, Types[TINT])
+ if l.Type == nil {
+ goto error
+ }
+ if checkmake(t, "size", l) < 0 {
+ goto error
+ }
+ n.Left = l
+ } else {
+ n.Left = Nodintconst(0)
+ }
+ n.Op = OMAKEMAP
+
+ case TCHAN:
+ l = nil
+ if args != nil {
+ l = args.N
+ args = args.Next
+ typecheck(&l, Erv)
+ defaultlit(&l, Types[TINT])
+ if l.Type == nil {
+ goto error
+ }
+ if checkmake(t, "buffer", l) < 0 {
+ goto error
+ }
+ n.Left = l
+ } else {
+ n.Left = Nodintconst(0)
+ }
+ n.Op = OMAKECHAN
+ }
+
+ if args != nil {
+ Yyerror("too many arguments to make(%v)", Tconv(t, 0))
+ n.Op = OMAKE
+ goto error
+ }
+
+ n.Type = t
+ goto ret
+
+ case ONEW:
+ ok |= Erv
+ args = n.List
+ if args == nil {
+ Yyerror("missing argument to new")
+ goto error
+ }
+
+ l = args.N
+ typecheck(&l, Etype)
+ t = l.Type
+ if t == nil {
+ goto error
+ }
+ if args.Next != nil {
+ Yyerror("too many arguments to new(%v)", Tconv(t, 0))
+ goto error
+ }
+
+ n.Left = l
+ n.Type = Ptrto(t)
+ goto ret
+
+ case OPRINT,
+ OPRINTN:
+ ok |= Etop
+ typechecklist(n.List, Erv|Eindir) // Eindir: address does not escape
+ for args = n.List; args != nil; args = args.Next {
+ // Special case for print: int constant is int64, not int.
+ if Isconst(args.N, CTINT) != 0 {
+ defaultlit(&args.N, Types[TINT64])
+ } else {
+ defaultlit(&args.N, nil)
+ }
+ }
+
+ goto ret
+
+ case OPANIC:
+ ok |= Etop
+ if onearg(n, "panic") < 0 {
+ goto error
+ }
+ typecheck(&n.Left, Erv)
+ defaultlit(&n.Left, Types[TINTER])
+ if n.Left.Type == nil {
+ goto error
+ }
+ goto ret
+
+ case ORECOVER:
+ ok |= Erv | Etop
+ if n.List != nil {
+ Yyerror("too many arguments to recover")
+ goto error
+ }
+
+ n.Type = Types[TINTER]
+ goto ret
+
+ case OCLOSURE:
+ ok |= Erv
+ typecheckclosure(n, top)
+ if n.Type == nil {
+ goto error
+ }
+ goto ret
+
+ case OITAB:
+ ok |= Erv
+ typecheck(&n.Left, Erv)
+ t = n.Left.Type
+ if t == nil {
+ goto error
+ }
+ if t.Etype != TINTER {
+ Fatal("OITAB of %v", Tconv(t, 0))
+ }
+ n.Type = Ptrto(Types[TUINTPTR])
+ goto ret
+
+ case OSPTR:
+ ok |= Erv
+ typecheck(&n.Left, Erv)
+ t = n.Left.Type
+ if t == nil {
+ goto error
+ }
+ if !(Isslice(t) != 0) && t.Etype != TSTRING {
+ Fatal("OSPTR of %v", Tconv(t, 0))
+ }
+ if t.Etype == TSTRING {
+ n.Type = Ptrto(Types[TUINT8])
+ } else {
+ n.Type = Ptrto(t.Type)
+ }
+ goto ret
+
+ case OCLOSUREVAR:
+ ok |= Erv
+ goto ret
+
+ case OCFUNC:
+ ok |= Erv
+ typecheck(&n.Left, Erv)
+ n.Type = Types[TUINTPTR]
+ goto ret
+
+ case OCONVNOP:
+ ok |= Erv
+ typecheck(&n.Left, Erv)
+ goto ret
+
+ /*
+ * statements
+ */
+ case OAS:
+ ok |= Etop
+
+ typecheckas(n)
+
+ // Code that creates temps does not bother to set defn, so do it here.
+ if n.Left.Op == ONAME && strings.HasPrefix(n.Left.Sym.Name, "autotmp_") {
+ n.Left.Defn = n
+ }
+ goto ret
+
+ case OAS2:
+ ok |= Etop
+ typecheckas2(n)
+ goto ret
+
+ case OBREAK,
+ OCONTINUE,
+ ODCL,
+ OEMPTY,
+ OGOTO,
+ OXFALL,
+ OVARKILL:
+ ok |= Etop
+ goto ret
+
+ case OLABEL:
+ ok |= Etop
+ decldepth++
+ goto ret
+
+ case ODEFER:
+ ok |= Etop
+ typecheck(&n.Left, Etop|Erv)
+ if !(n.Left.Diag != 0) {
+ checkdefergo(n)
+ }
+ goto ret
+
+ case OPROC:
+ ok |= Etop
+ typecheck(&n.Left, Etop|Eproc|Erv)
+ checkdefergo(n)
+ goto ret
+
+ case OFOR:
+ ok |= Etop
+ typechecklist(n.Ninit, Etop)
+ decldepth++
+ typecheck(&n.Ntest, Erv)
+ if n.Ntest != nil {
+ t = n.Ntest.Type
+ if t != nil && t.Etype != TBOOL {
+ Yyerror("non-bool %v used as for condition", Nconv(n.Ntest, obj.FmtLong))
+ }
+ }
+ typecheck(&n.Nincr, Etop)
+ typechecklist(n.Nbody, Etop)
+ decldepth--
+ goto ret
+
+ case OIF:
+ ok |= Etop
+ typechecklist(n.Ninit, Etop)
+ typecheck(&n.Ntest, Erv)
+ if n.Ntest != nil {
+ t = n.Ntest.Type
+ if t != nil && t.Etype != TBOOL {
+ Yyerror("non-bool %v used as if condition", Nconv(n.Ntest, obj.FmtLong))
+ }
+ }
+ typechecklist(n.Nbody, Etop)
+ typechecklist(n.Nelse, Etop)
+ goto ret
+
+ case ORETURN:
+ ok |= Etop
+ if count(n.List) == 1 {
+ typechecklist(n.List, Erv|Efnstruct)
+ } else {
+ typechecklist(n.List, Erv)
+ }
+ if Curfn == nil {
+ Yyerror("return outside function")
+ goto error
+ }
+
+ if Curfn.Type.Outnamed != 0 && n.List == nil {
+ goto ret
+ }
+ typecheckaste(ORETURN, nil, 0, getoutargx(Curfn.Type), n.List, "return argument")
+ goto ret
+
+ case ORETJMP:
+ ok |= Etop
+ goto ret
+
+ case OSELECT:
+ ok |= Etop
+ typecheckselect(n)
+ goto ret
+
+ case OSWITCH:
+ ok |= Etop
+ typecheckswitch(n)
+ goto ret
+
+ case ORANGE:
+ ok |= Etop
+ typecheckrange(n)
+ goto ret
+
+ case OTYPESW:
+ Yyerror("use of .(type) outside type switch")
+ goto error
+
+ case OXCASE:
+ ok |= Etop
+ typechecklist(n.List, Erv)
+ typechecklist(n.Nbody, Etop)
+ goto ret
+
+ case ODCLFUNC:
+ ok |= Etop
+ typecheckfunc(n)
+ goto ret
+
+ case ODCLCONST:
+ ok |= Etop
+ typecheck(&n.Left, Erv)
+ goto ret
+
+ case ODCLTYPE:
+ ok |= Etop
+ typecheck(&n.Left, Etype)
+ if !(incannedimport != 0) {
+ checkwidth(n.Left.Type)
+ }
+ goto ret
+ }
+
+ goto ret
+
+arith:
+ if op == OLSH || op == ORSH {
+ goto shift
+ }
+
+ // ideal mixed with non-ideal
+ defaultlit2(&l, &r, 0)
+
+ n.Left = l
+ n.Right = r
+ if l.Type == nil || r.Type == nil {
+ goto error
+ }
+ t = l.Type
+ if t.Etype == TIDEAL {
+ t = r.Type
+ }
+ et = int(t.Etype)
+ if et == TIDEAL {
+ et = TINT
+ }
+ aop = 0
+ if iscmp[n.Op] != 0 && t.Etype != TIDEAL && !Eqtype(l.Type, r.Type) {
+ // comparison is okay as long as one side is
+ // assignable to the other. convert so they have
+ // the same type.
+ //
+ // the only conversion that isn't a no-op is concrete == interface.
+ // in that case, check comparability of the concrete type.
+ // The conversion allocates, so only do it if the concrete type is huge.
+ if r.Type.Etype != TBLANK {
+ aop = assignop(l.Type, r.Type, nil)
+ if aop != 0 {
+ if Isinter(r.Type) != 0 && !(Isinter(l.Type) != 0) && algtype1(l.Type, nil) == ANOEQ {
+ Yyerror("invalid operation: %v (operator %v not defined on %s)", Nconv(n, 0), Oconv(int(op), 0), typekind(l.Type))
+ goto error
+ }
+
+ dowidth(l.Type)
+ if Isinter(r.Type) == Isinter(l.Type) || l.Type.Width >= 1<<16 {
+ l = Nod(aop, l, nil)
+ l.Type = r.Type
+ l.Typecheck = 1
+ n.Left = l
+ }
+
+ t = r.Type
+ goto converted
+ }
+ }
+
+ if l.Type.Etype != TBLANK {
+ aop = assignop(r.Type, l.Type, nil)
+ if aop != 0 {
+ if Isinter(l.Type) != 0 && !(Isinter(r.Type) != 0) && algtype1(r.Type, nil) == ANOEQ {
+ Yyerror("invalid operation: %v (operator %v not defined on %s)", Nconv(n, 0), Oconv(int(op), 0), typekind(r.Type))
+ goto error
+ }
+
+ dowidth(r.Type)
+ if Isinter(r.Type) == Isinter(l.Type) || r.Type.Width >= 1<<16 {
+ r = Nod(aop, r, nil)
+ r.Type = l.Type
+ r.Typecheck = 1
+ n.Right = r
+ }
+
+ t = l.Type
+ }
+ }
+
+ converted:
+ et = int(t.Etype)
+ }
+
+ if t.Etype != TIDEAL && !Eqtype(l.Type, r.Type) {
+ defaultlit2(&l, &r, 1)
+ if n.Op == OASOP && n.Implicit != 0 {
+ Yyerror("invalid operation: %v (non-numeric type %v)", Nconv(n, 0), Tconv(l.Type, 0))
+ goto error
+ }
+
+ if Isinter(r.Type) == Isinter(l.Type) || aop == 0 {
+ Yyerror("invalid operation: %v (mismatched types %v and %v)", Nconv(n, 0), Tconv(l.Type, 0), Tconv(r.Type, 0))
+ goto error
+ }
+ }
+
+ if !(okfor[op][et] != 0) {
+ Yyerror("invalid operation: %v (operator %v not defined on %s)", Nconv(n, 0), Oconv(int(op), 0), typekind(t))
+ goto error
+ }
+
+ // okfor allows any array == array, map == map, func == func.
+ // restrict to slice/map/func == nil and nil == slice/map/func.
+ if Isfixedarray(l.Type) != 0 && algtype1(l.Type, nil) == ANOEQ {
+ Yyerror("invalid operation: %v (%v cannot be compared)", Nconv(n, 0), Tconv(l.Type, 0))
+ goto error
+ }
+
+ if Isslice(l.Type) != 0 && !(isnil(l) != 0) && !(isnil(r) != 0) {
+ Yyerror("invalid operation: %v (slice can only be compared to nil)", Nconv(n, 0))
+ goto error
+ }
+
+ if l.Type.Etype == TMAP && !(isnil(l) != 0) && !(isnil(r) != 0) {
+ Yyerror("invalid operation: %v (map can only be compared to nil)", Nconv(n, 0))
+ goto error
+ }
+
+ if l.Type.Etype == TFUNC && !(isnil(l) != 0) && !(isnil(r) != 0) {
+ Yyerror("invalid operation: %v (func can only be compared to nil)", Nconv(n, 0))
+ goto error
+ }
+
+ if l.Type.Etype == TSTRUCT && algtype1(l.Type, &badtype) == ANOEQ {
+ Yyerror("invalid operation: %v (struct containing %v cannot be compared)", Nconv(n, 0), Tconv(badtype, 0))
+ goto error
+ }
+
+ t = l.Type
+ if iscmp[n.Op] != 0 {
+ evconst(n)
+ t = idealbool
+ if n.Op != OLITERAL {
+ defaultlit2(&l, &r, 1)
+ n.Left = l
+ n.Right = r
+ }
+ } else if n.Op == OANDAND || n.Op == OOROR {
+ if l.Type == r.Type {
+ t = l.Type
+ } else if l.Type == idealbool {
+ t = r.Type
+ } else if r.Type == idealbool {
+ t = l.Type
+ }
+ } else
+ // non-comparison operators on ideal bools should make them lose their ideal-ness
+ if t == idealbool {
+ t = Types[TBOOL]
+ }
+
+ if et == TSTRING {
+ if iscmp[n.Op] != 0 {
+ n.Etype = n.Op
+ n.Op = OCMPSTR
+ } else if n.Op == OADD {
+ // create OADDSTR node with list of strings in x + y + z + (w + v) + ...
+ n.Op = OADDSTR
+
+ if l.Op == OADDSTR {
+ n.List = l.List
+ } else {
+ n.List = list1(l)
+ }
+ if r.Op == OADDSTR {
+ n.List = concat(n.List, r.List)
+ } else {
+ n.List = list(n.List, r)
+ }
+ n.Left = nil
+ n.Right = nil
+ }
+ }
+
+ if et == TINTER {
+ if l.Op == OLITERAL && l.Val.Ctype == CTNIL {
+ // swap for back end
+ n.Left = r
+
+ n.Right = l
+ } else if r.Op == OLITERAL && r.Val.Ctype == CTNIL {
+ } else // leave alone for back end
+ if Isinter(r.Type) == Isinter(l.Type) {
+ n.Etype = n.Op
+ n.Op = OCMPIFACE
+ }
+ }
+
+ if (op == ODIV || op == OMOD) && Isconst(r, CTINT) != 0 {
+ if mpcmpfixc(r.Val.U.Xval, 0) == 0 {
+ Yyerror("division by zero")
+ goto error
+ }
+ }
+
+ n.Type = t
+ goto ret
+
+shift:
+ defaultlit(&r, Types[TUINT])
+ n.Right = r
+ t = r.Type
+ if !(Isint[t.Etype] != 0) || Issigned[t.Etype] != 0 {
+ Yyerror("invalid operation: %v (shift count type %v, must be unsigned integer)", Nconv(n, 0), Tconv(r.Type, 0))
+ goto error
+ }
+
+ t = l.Type
+ if t != nil && t.Etype != TIDEAL && !(Isint[t.Etype] != 0) {
+ Yyerror("invalid operation: %v (shift of type %v)", Nconv(n, 0), Tconv(t, 0))
+ goto error
+ }
+
+ // no defaultlit for left
+ // the outer context gives the type
+ n.Type = l.Type
+
+ goto ret
+
+doconv:
+ ok |= Erv
+ saveorignode(n)
+ typecheck(&n.Left, Erv|top&(Eindir|Eiota))
+ convlit1(&n.Left, n.Type, 1)
+ t = n.Left.Type
+ if t == nil || n.Type == nil {
+ goto error
+ }
+ n.Op = uint8(convertop(t, n.Type, &why))
+ if (n.Op) == 0 {
+ if !(n.Diag != 0) && !(n.Type.Broke != 0) {
+ Yyerror("cannot convert %v to type %v%s", Nconv(n.Left, obj.FmtLong), Tconv(n.Type, 0), why)
+ n.Diag = 1
+ }
+
+ n.Op = OCONV
+ }
+
+ switch n.Op {
+ case OCONVNOP:
+ if n.Left.Op == OLITERAL && n.Type != Types[TBOOL] {
+ r = Nod(OXXX, nil, nil)
+ n.Op = OCONV
+ n.Orig = r
+ *r = *n
+ n.Op = OLITERAL
+ n.Val = n.Left.Val
+ }
+
+ // do not use stringtoarraylit.
+ // generated code and compiler memory footprint is better without it.
+ case OSTRARRAYBYTE:
+ break
+
+ case OSTRARRAYRUNE:
+ if n.Left.Op == OLITERAL {
+ stringtoarraylit(&n)
+ }
+ }
+
+ goto ret
+
+ret:
+ t = n.Type
+ if t != nil && !(t.Funarg != 0) && n.Op != OTYPE {
+ switch t.Etype {
+ case TFUNC, // might have TANY; wait until its called
+ TANY,
+ TFORW,
+ TIDEAL,
+ TNIL,
+ TBLANK:
+ break
+
+ default:
+ checkwidth(t)
+ }
+ }
+
+ if safemode != 0 && !(incannedimport != 0) && !(importpkg != nil) && !(compiling_wrappers != 0) && t != nil && t.Etype == TUNSAFEPTR {
+ Yyerror("cannot use unsafe.Pointer")
+ }
+
+ evconst(n)
+ if n.Op == OTYPE && !(top&Etype != 0) {
+ Yyerror("type %v is not an expression", Tconv(n.Type, 0))
+ goto error
+ }
+
+ if top&(Erv|Etype) == Etype && n.Op != OTYPE {
+ Yyerror("%v is not a type", Nconv(n, 0))
+ goto error
+ }
+
+ // TODO(rsc): simplify
+ if (top&(Ecall|Erv|Etype) != 0) && !(top&Etop != 0) && !(ok&(Erv|Etype|Ecall) != 0) {
+ Yyerror("%v used as value", Nconv(n, 0))
+ goto error
+ }
+
+ if (top&Etop != 0) && !(top&(Ecall|Erv|Etype) != 0) && !(ok&Etop != 0) {
+ if n.Diag == 0 {
+ Yyerror("%v evaluated but not used", Nconv(n, 0))
+ n.Diag = 1
+ }
+
+ goto error
+ }
+
+ /* TODO
+ if(n->type == T)
+ fatal("typecheck nil type");
+ */
+ goto out
+
+badcall1:
+ Yyerror("invalid argument %v for %v", Nconv(n.Left, obj.FmtLong), Oconv(int(n.Op), 0))
+ goto error
+
+error:
+ n.Type = nil
+
+out:
+ *np = n
+}
+
+func checksliceindex(l *Node, r *Node, tp *Type) int {
+ var t *Type
+
+ t = r.Type
+ if t == nil {
+ return -1
+ }
+ if !(Isint[t.Etype] != 0) {
+ Yyerror("invalid slice index %v (type %v)", Nconv(r, 0), Tconv(t, 0))
+ return -1
+ }
+
+ if r.Op == OLITERAL {
+ if Mpgetfix(r.Val.U.Xval) < 0 {
+ Yyerror("invalid slice index %v (index must be non-negative)", Nconv(r, 0))
+ return -1
+ } else if tp != nil && tp.Bound > 0 && Mpgetfix(r.Val.U.Xval) > tp.Bound {
+ Yyerror("invalid slice index %v (out of bounds for %d-element array)", Nconv(r, 0), tp.Bound)
+ return -1
+ } else if Isconst(l, CTSTR) != 0 && Mpgetfix(r.Val.U.Xval) > int64(len(l.Val.U.Sval.S)) {
+ Yyerror("invalid slice index %v (out of bounds for %d-byte string)", Nconv(r, 0), len(l.Val.U.Sval.S))
+ return -1
+ } else if Mpcmpfixfix(r.Val.U.Xval, Maxintval[TINT]) > 0 {
+ Yyerror("invalid slice index %v (index too large)", Nconv(r, 0))
+ return -1
+ }
+ }
+
+ return 0
+}
+
+func checksliceconst(lo *Node, hi *Node) int {
+ if lo != nil && hi != nil && lo.Op == OLITERAL && hi.Op == OLITERAL && Mpcmpfixfix(lo.Val.U.Xval, hi.Val.U.Xval) > 0 {
+ Yyerror("invalid slice index: %v > %v", Nconv(lo, 0), Nconv(hi, 0))
+ return -1
+ }
+
+ return 0
+}
+
+func checkdefergo(n *Node) {
+ var what string
+
+ what = "defer"
+ if n.Op == OPROC {
+ what = "go"
+ }
+
+ switch n.Left.Op {
+ // ok
+ case OCALLINTER,
+ OCALLMETH,
+ OCALLFUNC,
+ OCLOSE,
+ OCOPY,
+ ODELETE,
+ OPANIC,
+ OPRINT,
+ OPRINTN,
+ ORECOVER:
+ return
+
+ case OAPPEND,
+ OCAP,
+ OCOMPLEX,
+ OIMAG,
+ OLEN,
+ OMAKE,
+ OMAKESLICE,
+ OMAKECHAN,
+ OMAKEMAP,
+ ONEW,
+ OREAL,
+ OLITERAL: // conversion or unsafe.Alignof, Offsetof, Sizeof
+ if n.Left.Orig != nil && n.Left.Orig.Op == OCONV {
+ break
+ }
+ Yyerror("%s discards result of %v", what, Nconv(n.Left, 0))
+ return
+ }
+
+ // type is broken or missing, most likely a method call on a broken type
+ // we will warn about the broken type elsewhere. no need to emit a potentially confusing error
+ if n.Left.Type == nil || n.Left.Type.Broke != 0 {
+ return
+ }
+
+ if !(n.Diag != 0) {
+ // The syntax made sure it was a call, so this must be
+ // a conversion.
+ n.Diag = 1
+
+ Yyerror("%s requires function call, not conversion", what)
+ }
+}
+
+func implicitstar(nn **Node) {
+ var t *Type
+ var n *Node
+
+ // insert implicit * if needed for fixed array
+ n = *nn
+
+ t = n.Type
+ if t == nil || !(Isptr[t.Etype] != 0) {
+ return
+ }
+ t = t.Type
+ if t == nil {
+ return
+ }
+ if !(Isfixedarray(t) != 0) {
+ return
+ }
+ n = Nod(OIND, n, nil)
+ n.Implicit = 1
+ typecheck(&n, Erv)
+ *nn = n
+}
+
+func onearg(n *Node, f string, args ...interface{}) int {
+ var p string
+
+ if n.Left != nil {
+ return 0
+ }
+ if n.List == nil {
+ p = fmt.Sprintf(f, args...)
+ Yyerror("missing argument to %s: %v", p, Nconv(n, 0))
+ return -1
+ }
+
+ if n.List.Next != nil {
+ p = fmt.Sprintf(f, args...)
+ Yyerror("too many arguments to %s: %v", p, Nconv(n, 0))
+ n.Left = n.List.N
+ n.List = nil
+ return -1
+ }
+
+ n.Left = n.List.N
+ n.List = nil
+ return 0
+}
+
+func twoarg(n *Node) int {
+ if n.Left != nil {
+ return 0
+ }
+ if n.List == nil {
+ Yyerror("missing argument to %v - %v", Oconv(int(n.Op), 0), Nconv(n, 0))
+ return -1
+ }
+
+ n.Left = n.List.N
+ if n.List.Next == nil {
+ Yyerror("missing argument to %v - %v", Oconv(int(n.Op), 0), Nconv(n, 0))
+ n.List = nil
+ return -1
+ }
+
+ if n.List.Next.Next != nil {
+ Yyerror("too many arguments to %v - %v", Oconv(int(n.Op), 0), Nconv(n, 0))
+ n.List = nil
+ return -1
+ }
+
+ n.Right = n.List.Next.N
+ n.List = nil
+ return 0
+}
+
+func lookdot1(errnode *Node, s *Sym, t *Type, f *Type, dostrcmp int) *Type {
+ var r *Type
+
+ r = nil
+ for ; f != nil; f = f.Down {
+ if dostrcmp != 0 && f.Sym.Name == s.Name {
+ return f
+ }
+ if f.Sym != s {
+ continue
+ }
+ if r != nil {
+ if errnode != nil {
+ Yyerror("ambiguous selector %v", Nconv(errnode, 0))
+ } else if Isptr[t.Etype] != 0 {
+ Yyerror("ambiguous selector (%v).%v", Tconv(t, 0), Sconv(s, 0))
+ } else {
+ Yyerror("ambiguous selector %v.%v", Tconv(t, 0), Sconv(s, 0))
+ }
+ break
+ }
+
+ r = f
+ }
+
+ return r
+}
+
+func looktypedot(n *Node, t *Type, dostrcmp int) int {
+ var f1 *Type
+ var f2 *Type
+ var s *Sym
+
+ s = n.Right.Sym
+
+ if t.Etype == TINTER {
+ f1 = lookdot1(n, s, t, t.Type, dostrcmp)
+ if f1 == nil {
+ return 0
+ }
+
+ n.Right = methodname(n.Right, t)
+ n.Xoffset = f1.Width
+ n.Type = f1.Type
+ n.Op = ODOTINTER
+ return 1
+ }
+
+ // Find the base type: methtype will fail if t
+ // is not of the form T or *T.
+ f2 = methtype(t, 0)
+
+ if f2 == nil {
+ return 0
+ }
+
+ expandmeth(f2)
+ f2 = lookdot1(n, s, f2, f2.Xmethod, dostrcmp)
+ if f2 == nil {
+ return 0
+ }
+
+ // disallow T.m if m requires *T receiver
+ if Isptr[getthisx(f2.Type).Type.Type.Etype] != 0 && !(Isptr[t.Etype] != 0) && f2.Embedded != 2 && !(isifacemethod(f2.Type) != 0) {
+ Yyerror("invalid method expression %v (needs pointer receiver: (*%v).%v)", Nconv(n, 0), Tconv(t, 0), Sconv(f2.Sym, obj.FmtShort))
+ return 0
+ }
+
+ n.Right = methodname(n.Right, t)
+ n.Xoffset = f2.Width
+ n.Type = f2.Type
+ n.Op = ODOTMETH
+ return 1
+}
+
+func derefall(t *Type) *Type {
+ for t != nil && int(t.Etype) == Tptr {
+ t = t.Type
+ }
+ return t
+}
+
+func lookdot(n *Node, t *Type, dostrcmp int) int {
+ var f1 *Type
+ var f2 *Type
+ var tt *Type
+ var rcvr *Type
+ var s *Sym
+
+ s = n.Right.Sym
+
+ dowidth(t)
+ f1 = nil
+ if t.Etype == TSTRUCT || t.Etype == TINTER {
+ f1 = lookdot1(n, s, t, t.Type, dostrcmp)
+ }
+
+ f2 = nil
+ if n.Left.Type == t || n.Left.Type.Sym == nil {
+ f2 = methtype(t, 0)
+ if f2 != nil {
+ // Use f2->method, not f2->xmethod: adddot has
+ // already inserted all the necessary embedded dots.
+ f2 = lookdot1(n, s, f2, f2.Method, dostrcmp)
+ }
+ }
+
+ if f1 != nil {
+ if f2 != nil {
+ Yyerror("%v is both field and method", Sconv(n.Right.Sym, 0))
+ }
+ if f1.Width == BADWIDTH {
+ Fatal("lookdot badwidth %v %p", Tconv(f1, 0), f1)
+ }
+ n.Xoffset = f1.Width
+ n.Type = f1.Type
+ n.Paramfld = f1
+ if t.Etype == TINTER {
+ if Isptr[n.Left.Type.Etype] != 0 {
+ n.Left = Nod(OIND, n.Left, nil) // implicitstar
+ n.Left.Implicit = 1
+ typecheck(&n.Left, Erv)
+ }
+
+ n.Op = ODOTINTER
+ }
+
+ return 1
+ }
+
+ if f2 != nil {
+ tt = n.Left.Type
+ dowidth(tt)
+ rcvr = getthisx(f2.Type).Type.Type
+ if !Eqtype(rcvr, tt) {
+ if int(rcvr.Etype) == Tptr && Eqtype(rcvr.Type, tt) {
+ checklvalue(n.Left, "call pointer method on")
+ n.Left = Nod(OADDR, n.Left, nil)
+ n.Left.Implicit = 1
+ typecheck(&n.Left, Etype|Erv)
+ } else if int(tt.Etype) == Tptr && int(rcvr.Etype) != Tptr && Eqtype(tt.Type, rcvr) {
+ n.Left = Nod(OIND, n.Left, nil)
+ n.Left.Implicit = 1
+ typecheck(&n.Left, Etype|Erv)
+ } else if int(tt.Etype) == Tptr && int(tt.Type.Etype) == Tptr && Eqtype(derefall(tt), derefall(rcvr)) {
+ Yyerror("calling method %v with receiver %v requires explicit dereference", Nconv(n.Right, 0), Nconv(n.Left, obj.FmtLong))
+ for int(tt.Etype) == Tptr {
+ // Stop one level early for method with pointer receiver.
+ if int(rcvr.Etype) == Tptr && int(tt.Type.Etype) != Tptr {
+ break
+ }
+ n.Left = Nod(OIND, n.Left, nil)
+ n.Left.Implicit = 1
+ typecheck(&n.Left, Etype|Erv)
+ tt = tt.Type
+ }
+ } else {
+ Fatal("method mismatch: %v for %v", Tconv(rcvr, 0), Tconv(tt, 0))
+ }
+ }
+
+ n.Right = methodname(n.Right, n.Left.Type)
+ n.Xoffset = f2.Width
+ n.Type = f2.Type
+
+ // print("lookdot found [%p] %T\n", f2->type, f2->type);
+ n.Op = ODOTMETH
+
+ return 1
+ }
+
+ return 0
+}
+
+func nokeys(l *NodeList) int {
+ for ; l != nil; l = l.Next {
+ if l.N.Op == OKEY {
+ return 0
+ }
+ }
+ return 1
+}
+
+func hasddd(t *Type) int {
+ var tl *Type
+
+ for tl = t.Type; tl != nil; tl = tl.Down {
+ if tl.Isddd != 0 {
+ return 1
+ }
+ }
+
+ return 0
+}
+
+func downcount(t *Type) int {
+ var tl *Type
+ var n int
+
+ n = 0
+ for tl = t.Type; tl != nil; tl = tl.Down {
+ n++
+ }
+
+ return n
+}
+
+/*
+ * typecheck assignment: type list = expression list
+ */
+func typecheckaste(op int, call *Node, isddd int, tstruct *Type, nl *NodeList, desc string) {
+ var t *Type
+ var tl *Type
+ var tn *Type
+ var n *Node
+ var lno int
+ var why string
+ var n1 int
+ var n2 int
+
+ lno = int(lineno)
+
+ if tstruct.Broke != 0 {
+ goto out
+ }
+
+ n = nil
+ if nl != nil && nl.Next == nil {
+ n = nl.N
+ if n.Type != nil {
+ if n.Type.Etype == TSTRUCT && n.Type.Funarg != 0 {
+ if !(hasddd(tstruct) != 0) {
+ n1 = downcount(tstruct)
+ n2 = downcount(n.Type)
+ if n2 > n1 {
+ goto toomany
+ }
+ if n2 < n1 {
+ goto notenough
+ }
+ }
+
+ tn = n.Type.Type
+ for tl = tstruct.Type; tl != nil; tl = tl.Down {
+ if tl.Isddd != 0 {
+ for ; tn != nil; tn = tn.Down {
+ if assignop(tn.Type, tl.Type.Type, &why) == 0 {
+ if call != nil {
+ Yyerror("cannot use %v as type %v in argument to %v%s", Tconv(tn.Type, 0), Tconv(tl.Type.Type, 0), Nconv(call, 0), why)
+ } else {
+ Yyerror("cannot use %v as type %v in %s%s", Tconv(tn.Type, 0), Tconv(tl.Type.Type, 0), desc, why)
+ }
+ }
+ }
+
+ goto out
+ }
+
+ if tn == nil {
+ goto notenough
+ }
+ if assignop(tn.Type, tl.Type, &why) == 0 {
+ if call != nil {
+ Yyerror("cannot use %v as type %v in argument to %v%s", Tconv(tn.Type, 0), Tconv(tl.Type, 0), Nconv(call, 0), why)
+ } else {
+ Yyerror("cannot use %v as type %v in %s%s", Tconv(tn.Type, 0), Tconv(tl.Type, 0), desc, why)
+ }
+ }
+
+ tn = tn.Down
+ }
+
+ if tn != nil {
+ goto toomany
+ }
+ goto out
+ }
+ }
+ }
+
+ n1 = downcount(tstruct)
+ n2 = count(nl)
+ if !(hasddd(tstruct) != 0) {
+ if n2 > n1 {
+ goto toomany
+ }
+ if n2 < n1 {
+ goto notenough
+ }
+ } else {
+ if !(isddd != 0) {
+ if n2 < n1-1 {
+ goto notenough
+ }
+ } else {
+ if n2 > n1 {
+ goto toomany
+ }
+ if n2 < n1 {
+ goto notenough
+ }
+ }
+ }
+
+ for tl = tstruct.Type; tl != nil; tl = tl.Down {
+ t = tl.Type
+ if tl.Isddd != 0 {
+ if isddd != 0 {
+ if nl == nil {
+ goto notenough
+ }
+ if nl.Next != nil {
+ goto toomany
+ }
+ n = nl.N
+ setlineno(n)
+ if n.Type != nil {
+ nl.N = assignconv(n, t, desc)
+ }
+ goto out
+ }
+
+ for ; nl != nil; nl = nl.Next {
+ n = nl.N
+ setlineno(nl.N)
+ if n.Type != nil {
+ nl.N = assignconv(n, t.Type, desc)
+ }
+ }
+
+ goto out
+ }
+
+ if nl == nil {
+ goto notenough
+ }
+ n = nl.N
+ setlineno(n)
+ if n.Type != nil {
+ nl.N = assignconv(n, t, desc)
+ }
+ nl = nl.Next
+ }
+
+ if nl != nil {
+ goto toomany
+ }
+ if isddd != 0 {
+ if call != nil {
+ Yyerror("invalid use of ... in call to %v", Nconv(call, 0))
+ } else {
+ Yyerror("invalid use of ... in %v", Oconv(int(op), 0))
+ }
+ }
+
+out:
+ lineno = int32(lno)
+ return
+
+notenough:
+ if n == nil || !(n.Diag != 0) {
+ if call != nil {
+ Yyerror("not enough arguments in call to %v", Nconv(call, 0))
+ } else {
+ Yyerror("not enough arguments to %v", Oconv(int(op), 0))
+ }
+ if n != nil {
+ n.Diag = 1
+ }
+ }
+
+ goto out
+
+toomany:
+ if call != nil {
+ Yyerror("too many arguments in call to %v", Nconv(call, 0))
+ } else {
+ Yyerror("too many arguments to %v", Oconv(int(op), 0))
+ }
+ goto out
+}
+
+/*
+ * type check composite
+ */
+func fielddup(n *Node, hash []*Node) {
+ var h uint
+ var s string
+ var a *Node
+
+ if n.Op != ONAME {
+ Fatal("fielddup: not ONAME")
+ }
+ s = n.Sym.Name
+ h = uint(stringhash(s) % uint32(len(hash)))
+ for a = hash[h]; a != nil; a = a.Ntest {
+ if a.Sym.Name == s {
+ Yyerror("duplicate field name in struct literal: %s", s)
+ return
+ }
+ }
+
+ n.Ntest = hash[h]
+ hash[h] = n
+}
+
+func keydup(n *Node, hash []*Node) {
+ var h uint
+ var b uint32
+ var d float64
+ var i int
+ var a *Node
+ var orign *Node
+ var cmp Node
+ var s string
+
+ orign = n
+ if n.Op == OCONVIFACE {
+ n = n.Left
+ }
+ evconst(n)
+ if n.Op != OLITERAL {
+ return // we dont check variables
+ }
+
+ switch n.Val.Ctype {
+ default: // unknown, bool, nil
+ b = 23
+
+ case CTINT,
+ CTRUNE:
+ b = uint32(Mpgetfix(n.Val.U.Xval))
+
+ case CTFLT:
+ d = mpgetflt(n.Val.U.Fval)
+ x := math.Float64bits(d)
+ for i := 0; i < 8; i++ {
+ b = b*PRIME1 + uint32(x&0xFF)
+ x >>= 8
+ }
+
+ case CTSTR:
+ b = 0
+ s = n.Val.U.Sval.S
+ for i = len(n.Val.U.Sval.S); i > 0; i-- {
+ b = b*PRIME1 + uint32(s[0])
+ s = s[1:]
+ }
+ }
+
+ h = uint(b % uint32(len(hash)))
+ cmp = Node{}
+ for a = hash[h]; a != nil; a = a.Ntest {
+ cmp.Op = OEQ
+ cmp.Left = n
+ b = 0
+ if a.Op == OCONVIFACE && orign.Op == OCONVIFACE {
+ if Eqtype(a.Left.Type, n.Type) {
+ cmp.Right = a.Left
+ evconst(&cmp)
+ b = uint32(cmp.Val.U.Bval)
+ }
+ } else if Eqtype(a.Type, n.Type) {
+ cmp.Right = a
+ evconst(&cmp)
+ b = uint32(cmp.Val.U.Bval)
+ }
+
+ if b != 0 {
+ Yyerror("duplicate key %v in map literal", Nconv(n, 0))
+ return
+ }
+ }
+
+ orign.Ntest = hash[h]
+ hash[h] = orign
+}
+
+func indexdup(n *Node, hash []*Node) {
+ var h uint
+ var a *Node
+ var b uint32
+ var c uint32
+
+ if n.Op != OLITERAL {
+ Fatal("indexdup: not OLITERAL")
+ }
+
+ b = uint32(Mpgetfix(n.Val.U.Xval))
+ h = uint(b % uint32(len(hash)))
+ for a = hash[h]; a != nil; a = a.Ntest {
+ c = uint32(Mpgetfix(a.Val.U.Xval))
+ if b == c {
+ Yyerror("duplicate index in array literal: %d", b)
+ return
+ }
+ }
+
+ n.Ntest = hash[h]
+ hash[h] = n
+}
+
+func prime(h uint32, sr uint32) int {
+ var n uint32
+
+ for n = 3; n <= sr; n += 2 {
+ if h%n == 0 {
+ return 0
+ }
+ }
+ return 1
+}
+
+func inithash(n *Node, autohash []*Node) []*Node {
+ var h uint32
+ var sr uint32
+ var ll *NodeList
+ var i int
+
+ // count the number of entries
+ h = 0
+
+ for ll = n.List; ll != nil; ll = ll.Next {
+ h++
+ }
+
+ // if the auto hash table is
+ // large enough use it.
+ if h <= uint32(len(autohash)) {
+ for i := range autohash {
+ autohash[i] = nil
+ }
+ return autohash
+ }
+
+ // make hash size odd and 12% larger than entries
+ h += h / 8
+
+ h |= 1
+
+ // calculate sqrt of h
+ sr = h / 2
+
+ for i = 0; i < 5; i++ {
+ sr = (sr + h/sr) / 2
+ }
+
+ // check for primeality
+ for !(prime(h, sr) != 0) {
+ h += 2
+ }
+
+ // build and return a throw-away hash table
+ return make([]*Node, h)
+}
+
+func iscomptype(t *Type) int {
+ switch t.Etype {
+ case TARRAY,
+ TSTRUCT,
+ TMAP:
+ return 1
+
+ case TPTR32,
+ TPTR64:
+ switch t.Type.Etype {
+ case TARRAY,
+ TSTRUCT,
+ TMAP:
+ return 1
+ }
+ }
+
+ return 0
+}
+
+func pushtype(n *Node, t *Type) {
+ if n == nil || n.Op != OCOMPLIT || !(iscomptype(t) != 0) {
+ return
+ }
+
+ if n.Right == nil {
+ n.Right = typenod(t)
+ n.Implicit = 1 // don't print
+ n.Right.Implicit = 1 // * is okay
+ } else if Debug['s'] != 0 {
+ typecheck(&n.Right, Etype)
+ if n.Right.Type != nil && Eqtype(n.Right.Type, t) {
+ fmt.Printf("%v: redundant type: %v\n", n.Line(), Tconv(t, 0))
+ }
+ }
+}
+
+func typecheckcomplit(np **Node) {
+ var bad int
+ var i int
+ var nerr int
+ var length int64
+ var l *Node
+ var n *Node
+ var norig *Node
+ var r *Node
+ var hash []*Node
+ var ll *NodeList
+ var t *Type
+ var f *Type
+ var s *Sym
+ var s1 *Sym
+ var lno int32
+ var autohash [101]*Node
+
+ n = *np
+ lno = lineno
+
+ if n.Right == nil {
+ if n.List != nil {
+ setlineno(n.List.N)
+ }
+ Yyerror("missing type in composite literal")
+ goto error
+ }
+
+ // Save original node (including n->right)
+ norig = Nod(int(n.Op), nil, nil)
+
+ *norig = *n
+
+ setlineno(n.Right)
+ l = typecheck(&n.Right, Etype|Ecomplit) /* sic */
+ t = l.Type
+ if t == nil {
+ goto error
+ }
+ nerr = nerrors
+ n.Type = t
+
+ if Isptr[t.Etype] != 0 {
+ // For better or worse, we don't allow pointers as the composite literal type,
+ // except when using the &T syntax, which sets implicit on the OIND.
+ if !(n.Right.Implicit != 0) {
+ Yyerror("invalid pointer type %v for composite literal (use &%v instead)", Tconv(t, 0), Tconv(t.Type, 0))
+ goto error
+ }
+
+ // Also, the underlying type must be a struct, map, slice, or array.
+ if !(iscomptype(t) != 0) {
+ Yyerror("invalid pointer type %v for composite literal", Tconv(t, 0))
+ goto error
+ }
+
+ t = t.Type
+ }
+
+ switch t.Etype {
+ default:
+ Yyerror("invalid type for composite literal: %v", Tconv(t, 0))
+ n.Type = nil
+
+ case TARRAY:
+ hash = inithash(n, autohash[:])
+
+ length = 0
+ i = 0
+ for ll = n.List; ll != nil; ll = ll.Next {
+ l = ll.N
+ setlineno(l)
+ if l.Op != OKEY {
+ l = Nod(OKEY, Nodintconst(int64(i)), l)
+ l.Left.Type = Types[TINT]
+ l.Left.Typecheck = 1
+ ll.N = l
+ }
+
+ typecheck(&l.Left, Erv)
+ evconst(l.Left)
+ i = nonnegconst(l.Left)
+ if i < 0 && !(l.Left.Diag != 0) {
+ Yyerror("array index must be non-negative integer constant")
+ l.Left.Diag = 1
+ i = -(1 << 30) // stay negative for a while
+ }
+
+ if i >= 0 {
+ indexdup(l.Left, hash)
+ }
+ i++
+ if int64(i) > length {
+ length = int64(i)
+ if t.Bound >= 0 && length > t.Bound {
+ setlineno(l)
+ Yyerror("array index %d out of bounds [0:%d]", length-1, t.Bound)
+ t.Bound = -1 // no more errors
+ }
+ }
+
+ r = l.Right
+ pushtype(r, t.Type)
+ typecheck(&r, Erv)
+ defaultlit(&r, t.Type)
+ l.Right = assignconv(r, t.Type, "array element")
+ }
+
+ if t.Bound == -100 {
+ t.Bound = length
+ }
+ if t.Bound < 0 {
+ n.Right = Nodintconst(length)
+ }
+ n.Op = OARRAYLIT
+
+ case TMAP:
+ hash = inithash(n, autohash[:])
+
+ for ll = n.List; ll != nil; ll = ll.Next {
+ l = ll.N
+ setlineno(l)
+ if l.Op != OKEY {
+ typecheck(&ll.N, Erv)
+ Yyerror("missing key in map literal")
+ continue
+ }
+
+ typecheck(&l.Left, Erv)
+ defaultlit(&l.Left, t.Down)
+ l.Left = assignconv(l.Left, t.Down, "map key")
+ if l.Left.Op != OCONV {
+ keydup(l.Left, hash)
+ }
+
+ r = l.Right
+ pushtype(r, t.Type)
+ typecheck(&r, Erv)
+ defaultlit(&r, t.Type)
+ l.Right = assignconv(r, t.Type, "map value")
+ }
+
+ n.Op = OMAPLIT
+
+ case TSTRUCT:
+ bad = 0
+ if n.List != nil && nokeys(n.List) != 0 {
+ // simple list of variables
+ f = t.Type
+
+ for ll = n.List; ll != nil; ll = ll.Next {
+ setlineno(ll.N)
+ typecheck(&ll.N, Erv)
+ if f == nil {
+ tmp12 := bad
+ bad++
+ if !(tmp12 != 0) {
+ Yyerror("too many values in struct initializer")
+ }
+ continue
+ }
+
+ s = f.Sym
+ if s != nil && !exportname(s.Name) && s.Pkg != localpkg {
+ Yyerror("implicit assignment of unexported field '%s' in %v literal", s.Name, Tconv(t, 0))
+ }
+
+ // No pushtype allowed here. Must name fields for that.
+ ll.N = assignconv(ll.N, f.Type, "field value")
+
+ ll.N = Nod(OKEY, newname(f.Sym), ll.N)
+ ll.N.Left.Type = f
+ ll.N.Left.Typecheck = 1
+ f = f.Down
+ }
+
+ if f != nil {
+ Yyerror("too few values in struct initializer")
+ }
+ } else {
+ hash = inithash(n, autohash[:])
+
+ // keyed list
+ for ll = n.List; ll != nil; ll = ll.Next {
+ l = ll.N
+ setlineno(l)
+ if l.Op != OKEY {
+ tmp13 := bad
+ bad++
+ if !(tmp13 != 0) {
+ Yyerror("mixture of field:value and value initializers")
+ }
+ typecheck(&ll.N, Erv)
+ continue
+ }
+
+ s = l.Left.Sym
+ if s == nil {
+ Yyerror("invalid field name %v in struct initializer", Nconv(l.Left, 0))
+ typecheck(&l.Right, Erv)
+ continue
+ }
+
+ // Sym might have resolved to name in other top-level
+ // package, because of import dot. Redirect to correct sym
+ // before we do the lookup.
+ if s.Pkg != localpkg && exportname(s.Name) {
+ s1 = Lookup(s.Name)
+ if s1.Origpkg == s.Pkg {
+ s = s1
+ }
+ }
+
+ f = lookdot1(nil, s, t, t.Type, 0)
+ if f == nil {
+ Yyerror("unknown %v field '%v' in struct literal", Tconv(t, 0), Sconv(s, 0))
+ continue
+ }
+
+ l.Left = newname(s)
+ l.Left.Typecheck = 1
+ l.Left.Type = f
+ s = f.Sym
+ fielddup(newname(s), hash)
+ r = l.Right
+
+ // No pushtype allowed here. Tried and rejected.
+ typecheck(&r, Erv)
+
+ l.Right = assignconv(r, f.Type, "field value")
+ }
+ }
+
+ n.Op = OSTRUCTLIT
+ }
+
+ if nerr != nerrors {
+ goto error
+ }
+
+ n.Orig = norig
+ if Isptr[n.Type.Etype] != 0 {
+ n = Nod(OPTRLIT, n, nil)
+ n.Typecheck = 1
+ n.Type = n.Left.Type
+ n.Left.Type = t
+ n.Left.Typecheck = 1
+ }
+
+ n.Orig = norig
+ *np = n
+ lineno = lno
+ return
+
+error:
+ n.Type = nil
+ *np = n
+ lineno = lno
+}
+
+/*
+ * lvalue etc
+ */
+func islvalue(n *Node) int {
+ switch n.Op {
+ case OINDEX:
+ if Isfixedarray(n.Left.Type) != 0 {
+ return islvalue(n.Left)
+ }
+ if n.Left.Type != nil && n.Left.Type.Etype == TSTRING {
+ return 0
+ }
+ fallthrough
+
+ // fall through
+ case OIND,
+ ODOTPTR,
+ OCLOSUREVAR,
+ OPARAM:
+ return 1
+
+ case ODOT:
+ return islvalue(n.Left)
+
+ case ONAME:
+ if n.Class == PFUNC {
+ return 0
+ }
+ return 1
+ }
+
+ return 0
+}
+
+func checklvalue(n *Node, verb string) {
+ if !(islvalue(n) != 0) {
+ Yyerror("cannot %s %v", verb, Nconv(n, 0))
+ }
+}
+
+func checkassign(stmt *Node, n *Node) {
+ var r *Node
+ var l *Node
+
+ // Variables declared in ORANGE are assigned on every iteration.
+ if n.Defn != stmt || stmt.Op == ORANGE {
+ r = outervalue(n)
+ for l = n; l != r; l = l.Left {
+ l.Assigned = 1
+ if l.Closure != nil {
+ l.Closure.Assigned = 1
+ }
+ }
+
+ l.Assigned = 1
+ if l.Closure != nil {
+ l.Closure.Assigned = 1
+ }
+ }
+
+ if islvalue(n) != 0 {
+ return
+ }
+ if n.Op == OINDEXMAP {
+ n.Etype = 1
+ return
+ }
+
+ // have already complained about n being undefined
+ if n.Op == ONONAME {
+ return
+ }
+
+ Yyerror("cannot assign to %v", Nconv(n, 0))
+}
+
+func checkassignlist(stmt *Node, l *NodeList) {
+ for ; l != nil; l = l.Next {
+ checkassign(stmt, l.N)
+ }
+}
+
+// Check whether l and r are the same side effect-free expression,
+// so that it is safe to reuse one instead of computing both.
+func samesafeexpr(l *Node, r *Node) int {
+ if l.Op != r.Op || !Eqtype(l.Type, r.Type) {
+ return 0
+ }
+
+ switch l.Op {
+ case ONAME,
+ OCLOSUREVAR:
+ return bool2int(l == r)
+
+ case ODOT,
+ ODOTPTR:
+ return bool2int(l.Right != nil && r.Right != nil && l.Right.Sym == r.Right.Sym && samesafeexpr(l.Left, r.Left) != 0)
+
+ case OIND:
+ return samesafeexpr(l.Left, r.Left)
+
+ case OINDEX:
+ return bool2int(samesafeexpr(l.Left, r.Left) != 0 && samesafeexpr(l.Right, r.Right) != 0)
+ }
+
+ return 0
+}
+
+/*
+ * type check assignment.
+ * if this assignment is the definition of a var on the left side,
+ * fill in the var's type.
+ */
+func typecheckas(n *Node) {
+ // delicate little dance.
+ // the definition of n may refer to this assignment
+ // as its definition, in which case it will call typecheckas.
+ // in that case, do not call typecheck back, or it will cycle.
+ // if the variable has a type (ntype) then typechecking
+ // will not look at defn, so it is okay (and desirable,
+ // so that the conversion below happens).
+ n.Left = resolve(n.Left)
+
+ if n.Left.Defn != n || n.Left.Ntype != nil {
+ typecheck(&n.Left, Erv|Easgn)
+ }
+
+ typecheck(&n.Right, Erv)
+ checkassign(n, n.Left)
+ if n.Right != nil && n.Right.Type != nil {
+ if n.Left.Type != nil {
+ n.Right = assignconv(n.Right, n.Left.Type, "assignment")
+ }
+ }
+
+ if n.Left.Defn == n && n.Left.Ntype == nil {
+ defaultlit(&n.Right, nil)
+ n.Left.Type = n.Right.Type
+ }
+
+ // second half of dance.
+ // now that right is done, typecheck the left
+ // just to get it over with. see dance above.
+ n.Typecheck = 1
+
+ if n.Left.Typecheck == 0 {
+ typecheck(&n.Left, Erv|Easgn)
+ }
+
+ // Recognize slices being updated in place, for better code generation later.
+ // Don't rewrite if using race detector, to avoid needing to teach race detector
+ // about this optimization.
+ if n.Left != nil && n.Left.Op != OINDEXMAP && n.Right != nil && !(flag_race != 0) {
+ switch n.Right.Op {
+ // For x = x[0:y], x can be updated in place, without touching pointer.
+ // TODO(rsc): Reenable once it is actually updated in place without touching the pointer.
+ case OSLICE,
+ OSLICE3,
+ OSLICESTR:
+ if false && samesafeexpr(n.Left, n.Right.Left) != 0 && (n.Right.Right.Left == nil || iszero(n.Right.Right.Left) != 0) {
+ n.Right.Reslice = 1
+ }
+
+ // For x = append(x, ...), x can be updated in place when there is capacity,
+ // without touching the pointer; otherwise the emitted code to growslice
+ // can take care of updating the pointer, and only in that case.
+ // TODO(rsc): Reenable once the emitted code does update the pointer.
+ case OAPPEND:
+ if false && n.Right.List != nil && samesafeexpr(n.Left, n.Right.List.N) != 0 {
+ n.Right.Reslice = 1
+ }
+ }
+ }
+}
+
+func checkassignto(src *Type, dst *Node) {
+ var why string
+
+ if assignop(src, dst.Type, &why) == 0 {
+ Yyerror("cannot assign %v to %v in multiple assignment%s", Tconv(src, 0), Nconv(dst, obj.FmtLong), why)
+ return
+ }
+}
+
+func typecheckas2(n *Node) {
+ var cl int
+ var cr int
+ var ll *NodeList
+ var lr *NodeList
+ var l *Node
+ var r *Node
+ var s Iter
+ var t *Type
+
+ for ll = n.List; ll != nil; ll = ll.Next {
+ // delicate little dance.
+ ll.N = resolve(ll.N)
+
+ if ll.N.Defn != n || ll.N.Ntype != nil {
+ typecheck(&ll.N, Erv|Easgn)
+ }
+ }
+
+ cl = count(n.List)
+ cr = count(n.Rlist)
+ if cl > 1 && cr == 1 {
+ typecheck(&n.Rlist.N, Erv|Efnstruct)
+ } else {
+ typechecklist(n.Rlist, Erv)
+ }
+ checkassignlist(n, n.List)
+
+ if cl == cr {
+ // easy
+ ll = n.List
+ lr = n.Rlist
+ for ; ll != nil; (func() { ll = ll.Next; lr = lr.Next })() {
+ if ll.N.Type != nil && lr.N.Type != nil {
+ lr.N = assignconv(lr.N, ll.N.Type, "assignment")
+ }
+ if ll.N.Defn == n && ll.N.Ntype == nil {
+ defaultlit(&lr.N, nil)
+ ll.N.Type = lr.N.Type
+ }
+ }
+
+ goto out
+ }
+
+ l = n.List.N
+ r = n.Rlist.N
+
+ // x,y,z = f()
+ if cr == 1 {
+ if r.Type == nil {
+ goto out
+ }
+ switch r.Op {
+ case OCALLMETH,
+ OCALLINTER,
+ OCALLFUNC:
+ if r.Type.Etype != TSTRUCT || r.Type.Funarg == 0 {
+ break
+ }
+ cr = structcount(r.Type)
+ if cr != cl {
+ goto mismatch
+ }
+ n.Op = OAS2FUNC
+ t = Structfirst(&s, &r.Type)
+ for ll = n.List; ll != nil; ll = ll.Next {
+ if t.Type != nil && ll.N.Type != nil {
+ checkassignto(t.Type, ll.N)
+ }
+ if ll.N.Defn == n && ll.N.Ntype == nil {
+ ll.N.Type = t.Type
+ }
+ t = structnext(&s)
+ }
+
+ goto out
+ }
+ }
+
+ // x, ok = y
+ if cl == 2 && cr == 1 {
+ if r.Type == nil {
+ goto out
+ }
+ switch r.Op {
+ case OINDEXMAP,
+ ORECV,
+ ODOTTYPE:
+ switch r.Op {
+ case OINDEXMAP:
+ n.Op = OAS2MAPR
+
+ case ORECV:
+ n.Op = OAS2RECV
+
+ case ODOTTYPE:
+ n.Op = OAS2DOTTYPE
+ r.Op = ODOTTYPE2
+ }
+
+ if l.Type != nil {
+ checkassignto(r.Type, l)
+ }
+ if l.Defn == n {
+ l.Type = r.Type
+ }
+ l = n.List.Next.N
+ if l.Type != nil && l.Type.Etype != TBOOL {
+ checkassignto(Types[TBOOL], l)
+ }
+ if l.Defn == n && l.Ntype == nil {
+ l.Type = Types[TBOOL]
+ }
+ goto out
+ }
+ }
+
+mismatch:
+ Yyerror("assignment count mismatch: %d = %d", cl, cr)
+
+ // second half of dance
+out:
+ n.Typecheck = 1
+
+ for ll = n.List; ll != nil; ll = ll.Next {
+ if ll.N.Typecheck == 0 {
+ typecheck(&ll.N, Erv|Easgn)
+ }
+ }
+}
+
+/*
+ * type check function definition
+ */
+func typecheckfunc(n *Node) {
+ var t *Type
+ var rcvr *Type
+ var l *NodeList
+
+ typecheck(&n.Nname, Erv|Easgn)
+ t = n.Nname.Type
+ if t == nil {
+ return
+ }
+ n.Type = t
+ t.Nname = n.Nname
+ rcvr = getthisx(t).Type
+ if rcvr != nil && n.Shortname != nil && !isblank(n.Shortname) {
+ addmethod(n.Shortname.Sym, t, true, n.Nname.Nointerface)
+ }
+
+ for l = n.Dcl; l != nil; l = l.Next {
+ if l.N.Op == ONAME && (l.N.Class == PPARAM || l.N.Class == PPARAMOUT) {
+ l.N.Decldepth = 1
+ }
+ }
+}
+
+func stringtoarraylit(np **Node) {
+ n := *np
+ if n.Left.Op != OLITERAL || n.Left.Val.Ctype != CTSTR {
+ Fatal("stringtoarraylit %N", n)
+ }
+
+ s := n.Left.Val.U.Sval.S
+ var l *NodeList
+ if n.Type.Type.Etype == TUINT8 {
+ // []byte
+ for i := 0; i < len(s); i++ {
+ l = list(l, Nod(OKEY, Nodintconst(int64(i)), Nodintconst(int64(s[0]))))
+ }
+ } else {
+ // []rune
+ i := 0
+ for _, r := range s {
+ l = list(l, Nod(OKEY, Nodintconst(int64(i)), Nodintconst(int64(r))))
+ i++
+ }
+ }
+
+ nn := Nod(OCOMPLIT, nil, typenod(n.Type))
+ nn.List = l
+ typecheck(&nn, Erv)
+ *np = nn
+}
+
+var ntypecheckdeftype int
+
+var methodqueue *NodeList
+
+func domethod(n *Node) {
+ var nt *Node
+ var t *Type
+
+ nt = n.Type.Nname
+ typecheck(&nt, Etype)
+ if nt.Type == nil {
+ // type check failed; leave empty func
+ n.Type.Etype = TFUNC
+
+ n.Type.Nod = nil
+ return
+ }
+
+ // If we have
+ // type I interface {
+ // M(_ int)
+ // }
+ // then even though I.M looks like it doesn't care about the
+ // value of its argument, a specific implementation of I may
+ // care. The _ would suppress the assignment to that argument
+ // while generating a call, so remove it.
+ for t = getinargx(nt.Type).Type; t != nil; t = t.Down {
+ if t.Sym != nil && t.Sym.Name == "_" {
+ t.Sym = nil
+ }
+ }
+
+ *n.Type = *nt.Type
+ n.Type.Nod = nil
+ checkwidth(n.Type)
+}
+
+var mapqueue *NodeList
+
+func copytype(n *Node, t *Type) {
+ var maplineno int
+ var embedlineno int
+ var lno int
+ var l *NodeList
+
+ if t.Etype == TFORW {
+ // This type isn't computed yet; when it is, update n.
+ t.Copyto = list(t.Copyto, n)
+
+ return
+ }
+
+ maplineno = int(n.Type.Maplineno)
+ embedlineno = int(n.Type.Embedlineno)
+
+ l = n.Type.Copyto
+ *n.Type = *t
+
+ t = n.Type
+ t.Sym = n.Sym
+ t.Local = n.Local
+ t.Vargen = n.Vargen
+ t.Siggen = 0
+ t.Method = nil
+ t.Xmethod = nil
+ t.Nod = nil
+ t.Printed = 0
+ t.Deferwidth = 0
+ t.Copyto = nil
+
+ // Update nodes waiting on this type.
+ for ; l != nil; l = l.Next {
+ copytype(l.N, t)
+ }
+
+ // Double-check use of type as embedded type.
+ lno = int(lineno)
+
+ if embedlineno != 0 {
+ lineno = int32(embedlineno)
+ if Isptr[t.Etype] != 0 {
+ Yyerror("embedded type cannot be a pointer")
+ }
+ }
+
+ lineno = int32(lno)
+
+ // Queue check for map until all the types are done settling.
+ if maplineno != 0 {
+ t.Maplineno = int32(maplineno)
+ mapqueue = list(mapqueue, n)
+ }
+}
+
+func typecheckdeftype(n *Node) {
+ var lno int
+ var t *Type
+ var l *NodeList
+
+ ntypecheckdeftype++
+ lno = int(lineno)
+ setlineno(n)
+ n.Type.Sym = n.Sym
+ n.Typecheck = 1
+ typecheck(&n.Ntype, Etype)
+ t = n.Ntype.Type
+ if t == nil {
+ n.Diag = 1
+ n.Type = nil
+ goto ret
+ }
+
+ if n.Type == nil {
+ n.Diag = 1
+ goto ret
+ }
+
+ // copy new type and clear fields
+ // that don't come along.
+ // anything zeroed here must be zeroed in
+ // typedcl2 too.
+ copytype(n, t)
+
+ret:
+ lineno = int32(lno)
+
+ // if there are no type definitions going on, it's safe to
+ // try to resolve the method types for the interfaces
+ // we just read.
+ if ntypecheckdeftype == 1 {
+ for {
+ l = methodqueue
+ if !(l != nil) {
+ break
+ }
+ methodqueue = nil
+ for ; l != nil; l = l.Next {
+ domethod(l.N)
+ }
+ }
+
+ for l = mapqueue; l != nil; l = l.Next {
+ lineno = l.N.Type.Maplineno
+ maptype(l.N.Type, Types[TBOOL])
+ }
+
+ lineno = int32(lno)
+ }
+
+ ntypecheckdeftype--
+}
+
+func queuemethod(n *Node) {
+ if ntypecheckdeftype == 0 {
+ domethod(n)
+ return
+ }
+
+ methodqueue = list(methodqueue, n)
+}
+
+func typecheckdef(n *Node) *Node {
+ var lno int
+ var nerrors0 int
+ var e *Node
+ var t *Type
+ var l *NodeList
+
+ lno = int(lineno)
+ setlineno(n)
+
+ if n.Op == ONONAME {
+ if !(n.Diag != 0) {
+ n.Diag = 1
+ if n.Lineno != 0 {
+ lineno = n.Lineno
+ }
+
+ // Note: adderrorname looks for this string and
+ // adds context about the outer expression
+ Yyerror("undefined: %v", Sconv(n.Sym, 0))
+ }
+
+ return n
+ }
+
+ if n.Walkdef == 1 {
+ return n
+ }
+
+ l = new(NodeList)
+ l.N = n
+ l.Next = typecheckdefstack
+ typecheckdefstack = l
+
+ if n.Walkdef == 2 {
+ Flusherrors()
+ fmt.Printf("typecheckdef loop:")
+ for l = typecheckdefstack; l != nil; l = l.Next {
+ fmt.Printf(" %v", Sconv(l.N.Sym, 0))
+ }
+ fmt.Printf("\n")
+ Fatal("typecheckdef loop")
+ }
+
+ n.Walkdef = 2
+
+ if n.Type != nil || n.Sym == nil { // builtin or no name
+ goto ret
+ }
+
+ switch n.Op {
+ default:
+ Fatal("typecheckdef %v", Oconv(int(n.Op), 0))
+ fallthrough
+
+ // not really syms
+ case OGOTO,
+ OLABEL:
+ break
+
+ case OLITERAL:
+ if n.Ntype != nil {
+ typecheck(&n.Ntype, Etype)
+ n.Type = n.Ntype.Type
+ n.Ntype = nil
+ if n.Type == nil {
+ n.Diag = 1
+ goto ret
+ }
+ }
+
+ e = n.Defn
+ n.Defn = nil
+ if e == nil {
+ lineno = n.Lineno
+ Dump("typecheckdef nil defn", n)
+ Yyerror("xxx")
+ }
+
+ typecheck(&e, Erv|Eiota)
+ if Isconst(e, CTNIL) != 0 {
+ Yyerror("const initializer cannot be nil")
+ goto ret
+ }
+
+ if e.Type != nil && e.Op != OLITERAL || !(isgoconst(e) != 0) {
+ if !(e.Diag != 0) {
+ Yyerror("const initializer %v is not a constant", Nconv(e, 0))
+ e.Diag = 1
+ }
+
+ goto ret
+ }
+
+ t = n.Type
+ if t != nil {
+ if !(okforconst[t.Etype] != 0) {
+ Yyerror("invalid constant type %v", Tconv(t, 0))
+ goto ret
+ }
+
+ if !(isideal(e.Type) != 0) && !Eqtype(t, e.Type) {
+ Yyerror("cannot use %v as type %v in const initializer", Nconv(e, obj.FmtLong), Tconv(t, 0))
+ goto ret
+ }
+
+ Convlit(&e, t)
+ }
+
+ n.Val = e.Val
+ n.Type = e.Type
+
+ case ONAME:
+ if n.Ntype != nil {
+ typecheck(&n.Ntype, Etype)
+ n.Type = n.Ntype.Type
+
+ if n.Type == nil {
+ n.Diag = 1
+ goto ret
+ }
+ }
+
+ if n.Type != nil {
+ break
+ }
+ if n.Defn == nil {
+ if n.Etype != 0 { // like OPRINTN
+ break
+ }
+ if nsavederrors+nerrors > 0 {
+ // Can have undefined variables in x := foo
+ // that make x have an n->ndefn == nil.
+ // If there are other errors anyway, don't
+ // bother adding to the noise.
+ break
+ }
+
+ Fatal("var without type, init: %v", Sconv(n.Sym, 0))
+ }
+
+ if n.Defn.Op == ONAME {
+ typecheck(&n.Defn, Erv)
+ n.Type = n.Defn.Type
+ break
+ }
+
+ typecheck(&n.Defn, Etop) // fills in n->type
+
+ case OTYPE:
+ if Curfn != nil {
+ defercheckwidth()
+ }
+ n.Walkdef = 1
+ n.Type = typ(TFORW)
+ n.Type.Sym = n.Sym
+ nerrors0 = nerrors
+ typecheckdeftype(n)
+ if n.Type.Etype == TFORW && nerrors > nerrors0 {
+ // Something went wrong during type-checking,
+ // but it was reported. Silence future errors.
+ n.Type.Broke = 1
+ }
+
+ if Curfn != nil {
+ resumecheckwidth()
+ }
+
+ // nothing to see here
+ case OPACK:
+ break
+ }
+
+ret:
+ if n.Op != OLITERAL && n.Type != nil && isideal(n.Type) != 0 {
+ Fatal("got %v for %v", Tconv(n.Type, 0), Nconv(n, 0))
+ }
+ if typecheckdefstack.N != n {
+ Fatal("typecheckdefstack mismatch")
+ }
+ l = typecheckdefstack
+ typecheckdefstack = l.Next
+
+ lineno = int32(lno)
+ n.Walkdef = 1
+ return n
+}
+
+func checkmake(t *Type, arg string, n *Node) int {
+ if n.Op == OLITERAL {
+ switch n.Val.Ctype {
+ case CTINT,
+ CTRUNE,
+ CTFLT,
+ CTCPLX:
+ n.Val = toint(n.Val)
+ if mpcmpfixc(n.Val.U.Xval, 0) < 0 {
+ Yyerror("negative %s argument in make(%v)", arg, Tconv(t, 0))
+ return -1
+ }
+
+ if Mpcmpfixfix(n.Val.U.Xval, Maxintval[TINT]) > 0 {
+ Yyerror("%s argument too large in make(%v)", arg, Tconv(t, 0))
+ return -1
+ }
+
+ // Delay defaultlit until after we've checked range, to avoid
+ // a redundant "constant NNN overflows int" error.
+ defaultlit(&n, Types[TINT])
+
+ return 0
+
+ default:
+ break
+ }
+ }
+
+ if !(Isint[n.Type.Etype] != 0) && n.Type.Etype != TIDEAL {
+ Yyerror("non-integer %s argument in make(%v) - %v", arg, Tconv(t, 0), Tconv(n.Type, 0))
+ return -1
+ }
+
+ // Defaultlit still necessary for non-constant: n might be 1<<k.
+ defaultlit(&n, Types[TINT])
+
+ return 0
+}
+
+func markbreak(n *Node, implicit *Node) {
+ var lab *Label
+
+ if n == nil {
+ return
+ }
+
+ switch n.Op {
+ case OBREAK:
+ if n.Left == nil {
+ if implicit != nil {
+ implicit.Hasbreak = 1
+ }
+ } else {
+ lab = n.Left.Sym.Label
+ if lab != nil {
+ lab.Def.Hasbreak = 1
+ }
+ }
+
+ case OFOR,
+ OSWITCH,
+ OTYPESW,
+ OSELECT,
+ ORANGE:
+ implicit = n
+ fallthrough
+
+ // fall through
+ default:
+ markbreak(n.Left, implicit)
+
+ markbreak(n.Right, implicit)
+ markbreak(n.Ntest, implicit)
+ markbreak(n.Nincr, implicit)
+ markbreaklist(n.Ninit, implicit)
+ markbreaklist(n.Nbody, implicit)
+ markbreaklist(n.Nelse, implicit)
+ markbreaklist(n.List, implicit)
+ markbreaklist(n.Rlist, implicit)
+ }
+}
+
+func markbreaklist(l *NodeList, implicit *Node) {
+ var n *Node
+ var lab *Label
+
+ for ; l != nil; l = l.Next {
+ n = l.N
+ if n.Op == OLABEL && l.Next != nil && n.Defn == l.Next.N {
+ switch n.Defn.Op {
+ case OFOR,
+ OSWITCH,
+ OTYPESW,
+ OSELECT,
+ ORANGE:
+ lab = new(Label)
+ lab.Def = n.Defn
+ n.Left.Sym.Label = lab
+ markbreak(n.Defn, n.Defn)
+ n.Left.Sym.Label = nil
+ l = l.Next
+ continue
+ }
+ }
+
+ markbreak(n, implicit)
+ }
+}
+
+func isterminating(l *NodeList, top int) int {
+ var def int
+ var n *Node
+
+ if l == nil {
+ return 0
+ }
+ if top != 0 {
+ for l.Next != nil && l.N.Op != OLABEL {
+ l = l.Next
+ }
+ markbreaklist(l, nil)
+ }
+
+ for l.Next != nil {
+ l = l.Next
+ }
+ n = l.N
+
+ if n == nil {
+ return 0
+ }
+
+ switch n.Op {
+ // NOTE: OLABEL is treated as a separate statement,
+ // not a separate prefix, so skipping to the last statement
+ // in the block handles the labeled statement case by
+ // skipping over the label. No case OLABEL here.
+
+ case OBLOCK:
+ return isterminating(n.List, 0)
+
+ case OGOTO,
+ ORETURN,
+ ORETJMP,
+ OPANIC,
+ OXFALL:
+ return 1
+
+ case OFOR:
+ if n.Ntest != nil {
+ return 0
+ }
+ if n.Hasbreak != 0 {
+ return 0
+ }
+ return 1
+
+ case OIF:
+ return bool2int(isterminating(n.Nbody, 0) != 0 && isterminating(n.Nelse, 0) != 0)
+
+ case OSWITCH,
+ OTYPESW,
+ OSELECT:
+ if n.Hasbreak != 0 {
+ return 0
+ }
+ def = 0
+ for l = n.List; l != nil; l = l.Next {
+ if !(isterminating(l.N.Nbody, 0) != 0) {
+ return 0
+ }
+ if l.N.List == nil { // default
+ def = 1
+ }
+ }
+
+ if n.Op != OSELECT && !(def != 0) {
+ return 0
+ }
+ return 1
+ }
+
+ return 0
+}
+
+func checkreturn(fn *Node) {
+ if fn.Type.Outtuple != 0 && fn.Nbody != nil {
+ if !(isterminating(fn.Nbody, 1) != 0) {
+ yyerrorl(int(fn.Endlineno), "missing return at end of function")
+ }
+ }
+}
diff --git a/src/cmd/internal/gc/unsafe.go b/src/cmd/internal/gc/unsafe.go
new file mode 100644
index 0000000..e50ea19
--- /dev/null
+++ b/src/cmd/internal/gc/unsafe.go
@@ -0,0 +1,178 @@
+// 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
+
+import "cmd/internal/obj"
+
+/*
+ * look for
+ * unsafe.Sizeof
+ * unsafe.Offsetof
+ * unsafe.Alignof
+ * rewrite with a constant
+ */
+func unsafenmagic(nn *Node) *Node {
+ var r *Node
+ var n *Node
+ var base *Node
+ var r1 *Node
+ var s *Sym
+ var t *Type
+ var tr *Type
+ var v int64
+ var val Val
+ var fn *Node
+ var args *NodeList
+
+ fn = nn.Left
+ args = nn.List
+
+ if safemode != 0 || fn == nil || fn.Op != ONAME {
+ goto no
+ }
+ s = fn.Sym
+ if s == nil {
+ goto no
+ }
+ if s.Pkg != unsafepkg {
+ goto no
+ }
+
+ if args == nil {
+ Yyerror("missing argument for %v", Sconv(s, 0))
+ goto no
+ }
+
+ r = args.N
+
+ if s.Name == "Sizeof" {
+ typecheck(&r, Erv)
+ defaultlit(&r, nil)
+ tr = r.Type
+ if tr == nil {
+ goto bad
+ }
+ dowidth(tr)
+ v = tr.Width
+ goto yes
+ }
+
+ if s.Name == "Offsetof" {
+ // must be a selector.
+ if r.Op != OXDOT {
+ goto bad
+ }
+
+ // Remember base of selector to find it back after dot insertion.
+ // Since r->left may be mutated by typechecking, check it explicitly
+ // first to track it correctly.
+ typecheck(&r.Left, Erv)
+
+ base = r.Left
+ typecheck(&r, Erv)
+ switch r.Op {
+ case ODOT,
+ ODOTPTR:
+ break
+
+ case OCALLPART:
+ Yyerror("invalid expression %v: argument is a method value", Nconv(nn, 0))
+ v = 0
+ goto ret
+
+ default:
+ goto bad
+ }
+
+ v = 0
+
+ // add offsets for inserted dots.
+ for r1 = r; r1.Left != base; r1 = r1.Left {
+ switch r1.Op {
+ case ODOT:
+ v += r1.Xoffset
+
+ case ODOTPTR:
+ Yyerror("invalid expression %v: selector implies indirection of embedded %v", Nconv(nn, 0), Nconv(r1.Left, 0))
+ goto ret
+
+ default:
+ Dump("unsafenmagic", r)
+ Fatal("impossible %v node after dot insertion", Oconv(int(r1.Op), obj.FmtSharp))
+ goto bad
+ }
+ }
+
+ v += r1.Xoffset
+ goto yes
+ }
+
+ if s.Name == "Alignof" {
+ typecheck(&r, Erv)
+ defaultlit(&r, nil)
+ tr = r.Type
+ if tr == nil {
+ goto bad
+ }
+
+ // make struct { byte; T; }
+ t = typ(TSTRUCT)
+
+ t.Type = typ(TFIELD)
+ t.Type.Type = Types[TUINT8]
+ t.Type.Down = typ(TFIELD)
+ t.Type.Down.Type = tr
+
+ // compute struct widths
+ dowidth(t)
+
+ // the offset of T is its required alignment
+ v = t.Type.Down.Width
+
+ goto yes
+ }
+
+no:
+ return nil
+
+bad:
+ Yyerror("invalid expression %v", Nconv(nn, 0))
+ v = 0
+ goto ret
+
+yes:
+ if args.Next != nil {
+ Yyerror("extra arguments for %v", Sconv(s, 0))
+ }
+
+ // any side effects disappear; ignore init
+ret:
+ val.Ctype = CTINT
+
+ val.U.Xval = new(Mpint)
+ Mpmovecfix(val.U.Xval, v)
+ n = Nod(OLITERAL, nil, nil)
+ n.Orig = nn
+ n.Val = val
+ n.Type = Types[TUINTPTR]
+ nn.Type = Types[TUINTPTR]
+ return n
+}
+
+func isunsafebuiltin(n *Node) int {
+ if n == nil || n.Op != ONAME || n.Sym == nil || n.Sym.Pkg != unsafepkg {
+ return 0
+ }
+ if n.Sym.Name == "Sizeof" {
+ return 1
+ }
+ if n.Sym.Name == "Offsetof" {
+ return 1
+ }
+ if n.Sym.Name == "Alignof" {
+ return 1
+ }
+ return 0
+}
diff --git a/src/cmd/internal/gc/util.go b/src/cmd/internal/gc/util.go
new file mode 100644
index 0000000..ceb3eea
--- /dev/null
+++ b/src/cmd/internal/gc/util.go
@@ -0,0 +1,70 @@
+package gc
+
+import (
+ "cmd/internal/obj"
+ "strconv"
+ "strings"
+)
+
+func bool2int(b bool) int {
+ if b {
+ return 1
+ }
+ return 0
+}
+
+func (n *Node) Line() string {
+ return obj.Linklinefmt(Ctxt, int(n.Lineno), false, false)
+}
+
+func atoi(s string) int {
+ // NOTE: Not strconv.Atoi, accepts hex and octal prefixes.
+ n, _ := strconv.ParseInt(s, 0, 0)
+ return int(n)
+}
+
+func isalnum(c int) bool {
+ return isalpha(c) || isdigit(c)
+}
+
+func isalpha(c int) bool {
+ return 'A' <= c && c <= 'Z' || 'a' <= c && c <= 'z'
+}
+
+func isdigit(c int) bool {
+ return '0' <= c && c <= '9'
+}
+
+func plan9quote(s string) string {
+ if s == "" {
+ goto needquote
+ }
+ for i := 0; i < len(s); i++ {
+ if s[i] <= ' ' || s[i] == '\'' {
+ goto needquote
+ }
+ }
+ return s
+
+needquote:
+ return "'" + strings.Replace(s, "'", "''", -1) + "'"
+}
+
+// simulation of int(*s++) in C
+func intstarstringplusplus(s string) (int, string) {
+ if s == "" {
+ return 0, ""
+ }
+ return int(s[0]), s[1:]
+}
+
+// strings.Compare, introduced in Go 1.5.
+func stringsCompare(a, b string) int {
+ if a == b {
+ return 0
+ }
+ if a < b {
+ return -1
+ }
+ return +1
+}
diff --git a/src/cmd/internal/gc/walk.go b/src/cmd/internal/gc/walk.go
new file mode 100644
index 0000000..37299ca
--- /dev/null
+++ b/src/cmd/internal/gc/walk.go
@@ -0,0 +1,4531 @@
+// 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
+
+import (
+ "cmd/internal/obj"
+ "fmt"
+ "strings"
+)
+
+var mpzero Mpint
+
+// The constant is known to runtime.
+const (
+ tmpstringbufsize = 32
+)
+
+func walk(fn *Node) {
+ var s string
+ var l *NodeList
+ var lno int
+
+ Curfn = fn
+
+ if Debug['W'] != 0 {
+ s = fmt.Sprintf("\nbefore %v", Sconv(Curfn.Nname.Sym, 0))
+ dumplist(s, Curfn.Nbody)
+ }
+
+ lno = int(lineno)
+
+ // Final typecheck for any unused variables.
+ // It's hard to be on the heap when not-used, but best to be consistent about &~PHEAP here and below.
+ for l = fn.Dcl; l != nil; l = l.Next {
+ if l.N.Op == ONAME && l.N.Class&^PHEAP == PAUTO {
+ typecheck(&l.N, Erv|Easgn)
+ }
+ }
+
+ // Propagate the used flag for typeswitch variables up to the NONAME in it's definition.
+ for l = fn.Dcl; l != nil; l = l.Next {
+ if l.N.Op == ONAME && l.N.Class&^PHEAP == PAUTO && l.N.Defn != nil && l.N.Defn.Op == OTYPESW && l.N.Used != 0 {
+ l.N.Defn.Left.Used++
+ }
+ }
+
+ for l = fn.Dcl; l != nil; l = l.Next {
+ if l.N.Op != ONAME || l.N.Class&^PHEAP != PAUTO || l.N.Sym.Name[0] == '&' || l.N.Used != 0 {
+ continue
+ }
+ if l.N.Defn != nil && l.N.Defn.Op == OTYPESW {
+ if l.N.Defn.Left.Used != 0 {
+ continue
+ }
+ lineno = l.N.Defn.Left.Lineno
+ Yyerror("%v declared and not used", Sconv(l.N.Sym, 0))
+ l.N.Defn.Left.Used = 1 // suppress repeats
+ } else {
+ lineno = l.N.Lineno
+ Yyerror("%v declared and not used", Sconv(l.N.Sym, 0))
+ }
+ }
+
+ lineno = int32(lno)
+ if nerrors != 0 {
+ return
+ }
+ walkstmtlist(Curfn.Nbody)
+ if Debug['W'] != 0 {
+ s = fmt.Sprintf("after walk %v", Sconv(Curfn.Nname.Sym, 0))
+ dumplist(s, Curfn.Nbody)
+ }
+
+ heapmoves()
+ if Debug['W'] != 0 && Curfn.Enter != nil {
+ s = fmt.Sprintf("enter %v", Sconv(Curfn.Nname.Sym, 0))
+ dumplist(s, Curfn.Enter)
+ }
+}
+
+func walkstmtlist(l *NodeList) {
+ for ; l != nil; l = l.Next {
+ walkstmt(&l.N)
+ }
+}
+
+func samelist(a *NodeList, b *NodeList) int {
+ for ; a != nil && b != nil; (func() { a = a.Next; b = b.Next })() {
+ if a.N != b.N {
+ return 0
+ }
+ }
+ return bool2int(a == b)
+}
+
+func paramoutheap(fn *Node) int {
+ var l *NodeList
+
+ for l = fn.Dcl; l != nil; l = l.Next {
+ switch l.N.Class {
+ case PPARAMOUT,
+ PPARAMOUT | PHEAP:
+ return int(l.N.Addrtaken)
+
+ // stop early - parameters are over
+ case PAUTO,
+ PAUTO | PHEAP:
+ return 0
+ }
+ }
+
+ return 0
+}
+
+// adds "adjust" to all the argument locations for the call n.
+// n must be a defer or go node that has already been walked.
+func adjustargs(n *Node, adjust int) {
+ var callfunc *Node
+ var arg *Node
+ var lhs *Node
+ var args *NodeList
+
+ callfunc = n.Left
+ for args = callfunc.List; args != nil; args = args.Next {
+ arg = args.N
+ if arg.Op != OAS {
+ Yyerror("call arg not assignment")
+ }
+ lhs = arg.Left
+ if lhs.Op == ONAME {
+ // This is a temporary introduced by reorder1.
+ // The real store to the stack appears later in the arg list.
+ continue
+ }
+
+ if lhs.Op != OINDREG {
+ Yyerror("call argument store does not use OINDREG")
+ }
+
+ // can't really check this in machine-indep code.
+ //if(lhs->val.u.reg != D_SP)
+ // yyerror("call arg assign not indreg(SP)");
+ lhs.Xoffset += int64(adjust)
+ }
+}
+
+func walkstmt(np **Node) {
+ var init *NodeList
+ var ll *NodeList
+ var rl *NodeList
+ var cl int
+ var n *Node
+ var f *Node
+
+ n = *np
+ if n == nil {
+ return
+ }
+ if n.Dodata == 2 { // don't walk, generated by anylit.
+ return
+ }
+
+ setlineno(n)
+
+ walkstmtlist(n.Ninit)
+
+ switch n.Op {
+ default:
+ if n.Op == ONAME {
+ Yyerror("%v is not a top level statement", Sconv(n.Sym, 0))
+ } else {
+ Yyerror("%v is not a top level statement", Oconv(int(n.Op), 0))
+ }
+ Dump("nottop", n)
+
+ case OAS,
+ OASOP,
+ OAS2,
+ OAS2DOTTYPE,
+ OAS2RECV,
+ OAS2FUNC,
+ OAS2MAPR,
+ OCLOSE,
+ OCOPY,
+ OCALLMETH,
+ OCALLINTER,
+ OCALL,
+ OCALLFUNC,
+ ODELETE,
+ OSEND,
+ OPRINT,
+ OPRINTN,
+ OPANIC,
+ OEMPTY,
+ ORECOVER:
+ if n.Typecheck == 0 {
+ Fatal("missing typecheck: %v", Nconv(n, obj.FmtSign))
+ }
+ init = n.Ninit
+ n.Ninit = nil
+ walkexpr(&n, &init)
+ addinit(&n, init)
+ if (*np).Op == OCOPY && n.Op == OCONVNOP {
+ n.Op = OEMPTY // don't leave plain values as statements.
+ }
+
+ // special case for a receive where we throw away
+ // the value received.
+ case ORECV:
+ if n.Typecheck == 0 {
+ Fatal("missing typecheck: %v", Nconv(n, obj.FmtSign))
+ }
+ init = n.Ninit
+ n.Ninit = nil
+
+ walkexpr(&n.Left, &init)
+ n = mkcall1(chanfn("chanrecv1", 2, n.Left.Type), nil, &init, typename(n.Left.Type), n.Left, nodnil())
+ walkexpr(&n, &init)
+
+ addinit(&n, init)
+
+ case OBREAK,
+ ODCL,
+ OCONTINUE,
+ OFALL,
+ OGOTO,
+ OLABEL,
+ ODCLCONST,
+ ODCLTYPE,
+ OCHECKNIL,
+ OVARKILL:
+ break
+
+ case OBLOCK:
+ walkstmtlist(n.List)
+
+ case OXCASE:
+ Yyerror("case statement out of place")
+ n.Op = OCASE
+ fallthrough
+
+ case OCASE:
+ walkstmt(&n.Right)
+
+ case ODEFER:
+ Hasdefer = 1
+ switch n.Left.Op {
+ case OPRINT,
+ OPRINTN:
+ walkprintfunc(&n.Left, &n.Ninit)
+
+ case OCOPY:
+ n.Left = copyany(n.Left, &n.Ninit, 1)
+
+ default:
+ walkexpr(&n.Left, &n.Ninit)
+ }
+
+ // make room for size & fn arguments.
+ adjustargs(n, 2*Widthptr)
+
+ case OFOR:
+ if n.Ntest != nil {
+ walkstmtlist(n.Ntest.Ninit)
+ init = n.Ntest.Ninit
+ n.Ntest.Ninit = nil
+ walkexpr(&n.Ntest, &init)
+ addinit(&n.Ntest, init)
+ }
+
+ walkstmt(&n.Nincr)
+ walkstmtlist(n.Nbody)
+
+ case OIF:
+ walkexpr(&n.Ntest, &n.Ninit)
+ walkstmtlist(n.Nbody)
+ walkstmtlist(n.Nelse)
+
+ case OPROC:
+ switch n.Left.Op {
+ case OPRINT,
+ OPRINTN:
+ walkprintfunc(&n.Left, &n.Ninit)
+
+ case OCOPY:
+ n.Left = copyany(n.Left, &n.Ninit, 1)
+
+ default:
+ walkexpr(&n.Left, &n.Ninit)
+ }
+
+ // make room for size & fn arguments.
+ adjustargs(n, 2*Widthptr)
+
+ case ORETURN:
+ walkexprlist(n.List, &n.Ninit)
+ if n.List == nil {
+ break
+ }
+ if (Curfn.Type.Outnamed != 0 && count(n.List) > 1) || paramoutheap(Curfn) != 0 {
+ // assign to the function out parameters,
+ // so that reorder3 can fix up conflicts
+ rl = nil
+
+ for ll = Curfn.Dcl; ll != nil; ll = ll.Next {
+ cl = int(ll.N.Class) &^ PHEAP
+ if cl == PAUTO {
+ break
+ }
+ if cl == PPARAMOUT {
+ rl = list(rl, ll.N)
+ }
+ }
+
+ if samelist(rl, n.List) != 0 {
+ // special return in disguise
+ n.List = nil
+
+ break
+ }
+
+ if count(n.List) == 1 && count(rl) > 1 {
+ // OAS2FUNC in disguise
+ f = n.List.N
+
+ if f.Op != OCALLFUNC && f.Op != OCALLMETH && f.Op != OCALLINTER {
+ Fatal("expected return of call, have %v", Nconv(f, 0))
+ }
+ n.List = concat(list1(f), ascompatet(int(n.Op), rl, &f.Type, 0, &n.Ninit))
+ break
+ }
+
+ // move function calls out, to make reorder3's job easier.
+ walkexprlistsafe(n.List, &n.Ninit)
+
+ ll = ascompatee(int(n.Op), rl, n.List, &n.Ninit)
+ n.List = reorder3(ll)
+ break
+ }
+
+ ll = ascompatte(int(n.Op), nil, 0, Getoutarg(Curfn.Type), n.List, 1, &n.Ninit)
+ n.List = ll
+
+ case ORETJMP:
+ break
+
+ case OSELECT:
+ walkselect(n)
+
+ case OSWITCH:
+ walkswitch(n)
+
+ case ORANGE:
+ walkrange(n)
+
+ case OXFALL:
+ Yyerror("fallthrough statement out of place")
+ n.Op = OFALL
+ }
+
+ if n.Op == ONAME {
+ Fatal("walkstmt ended up with name: %v", Nconv(n, obj.FmtSign))
+ }
+
+ *np = n
+}
+
+/*
+ * walk the whole tree of the body of an
+ * expression or simple statement.
+ * the types expressions are calculated.
+ * compile-time constants are evaluated.
+ * complex side effects like statements are appended to init
+ */
+func walkexprlist(l *NodeList, init **NodeList) {
+ for ; l != nil; l = l.Next {
+ walkexpr(&l.N, init)
+ }
+}
+
+func walkexprlistsafe(l *NodeList, init **NodeList) {
+ for ; l != nil; l = l.Next {
+ l.N = safeexpr(l.N, init)
+ walkexpr(&l.N, init)
+ }
+}
+
+func walkexprlistcheap(l *NodeList, init **NodeList) {
+ for ; l != nil; l = l.Next {
+ l.N = cheapexpr(l.N, init)
+ walkexpr(&l.N, init)
+ }
+}
+
+func walkexpr(np **Node, init **NodeList) {
+ var r *Node
+ var l *Node
+ var var_ *Node
+ var a *Node
+ var ok *Node
+ var map_ *Node
+ var key *Node
+ var ll *NodeList
+ var lr *NodeList
+ var t *Type
+ var et int
+ var old_safemode int
+ var v int64
+ var lno int32
+ var n *Node
+ var fn *Node
+ var n1 *Node
+ var n2 *Node
+ var sym *Sym
+ var buf string
+ var p string
+ var from string
+ var to string
+
+ n = *np
+
+ if n == nil {
+ return
+ }
+
+ if init == &n.Ninit {
+ // not okay to use n->ninit when walking n,
+ // because we might replace n with some other node
+ // and would lose the init list.
+ Fatal("walkexpr init == &n->ninit")
+ }
+
+ if n.Ninit != nil {
+ walkstmtlist(n.Ninit)
+ *init = concat(*init, n.Ninit)
+ n.Ninit = nil
+ }
+
+ // annoying case - not typechecked
+ if n.Op == OKEY {
+ walkexpr(&n.Left, init)
+ walkexpr(&n.Right, init)
+ return
+ }
+
+ lno = setlineno(n)
+
+ if Debug['w'] > 1 {
+ Dump("walk-before", n)
+ }
+
+ if n.Typecheck != 1 {
+ Fatal("missed typecheck: %v\n", Nconv(n, obj.FmtSign))
+ }
+
+ switch n.Op {
+ default:
+ Dump("walk", n)
+ Fatal("walkexpr: switch 1 unknown op %v", Nconv(n, obj.FmtShort|obj.FmtSign))
+
+ case OTYPE,
+ ONONAME,
+ OINDREG,
+ OEMPTY,
+ OPARAM:
+ goto ret
+
+ case ONOT,
+ OMINUS,
+ OPLUS,
+ OCOM,
+ OREAL,
+ OIMAG,
+ ODOTMETH,
+ ODOTINTER:
+ walkexpr(&n.Left, init)
+ goto ret
+
+ case OIND:
+ walkexpr(&n.Left, init)
+ goto ret
+
+ case ODOT:
+ usefield(n)
+ walkexpr(&n.Left, init)
+ goto ret
+
+ case ODOTPTR:
+ usefield(n)
+ if n.Op == ODOTPTR && n.Left.Type.Type.Width == 0 {
+ // No actual copy will be generated, so emit an explicit nil check.
+ n.Left = cheapexpr(n.Left, init)
+
+ checknil(n.Left, init)
+ }
+
+ walkexpr(&n.Left, init)
+ goto ret
+
+ case OEFACE:
+ walkexpr(&n.Left, init)
+ walkexpr(&n.Right, init)
+ goto ret
+
+ case OSPTR,
+ OITAB:
+ walkexpr(&n.Left, init)
+ goto ret
+
+ case OLEN,
+ OCAP:
+ walkexpr(&n.Left, init)
+
+ // replace len(*[10]int) with 10.
+ // delayed until now to preserve side effects.
+ t = n.Left.Type
+
+ if Isptr[t.Etype] != 0 {
+ t = t.Type
+ }
+ if Isfixedarray(t) != 0 {
+ safeexpr(n.Left, init)
+ Nodconst(n, n.Type, t.Bound)
+ n.Typecheck = 1
+ }
+
+ goto ret
+
+ case OLSH,
+ ORSH:
+ walkexpr(&n.Left, init)
+ walkexpr(&n.Right, init)
+ t = n.Left.Type
+ n.Bounded = uint8(bounded(n.Right, 8*t.Width))
+ if Debug['m'] != 0 && n.Etype != 0 && !(Isconst(n.Right, CTINT) != 0) {
+ Warn("shift bounds check elided")
+ }
+ goto ret
+
+ // Use results from call expression as arguments for complex.
+ case OAND,
+ OSUB,
+ OHMUL,
+ OLT,
+ OLE,
+ OGE,
+ OGT,
+ OADD,
+ OCOMPLEX,
+ OLROT:
+ if n.Op == OCOMPLEX && n.Left == nil && n.Right == nil {
+ n.Left = n.List.N
+ n.Right = n.List.Next.N
+ }
+
+ walkexpr(&n.Left, init)
+ walkexpr(&n.Right, init)
+ goto ret
+
+ case OOR,
+ OXOR:
+ walkexpr(&n.Left, init)
+ walkexpr(&n.Right, init)
+ walkrotate(&n)
+ goto ret
+
+ case OEQ,
+ ONE:
+ walkexpr(&n.Left, init)
+ walkexpr(&n.Right, init)
+
+ // Disable safemode while compiling this code: the code we
+ // generate internally can refer to unsafe.Pointer.
+ // In this case it can happen if we need to generate an ==
+ // for a struct containing a reflect.Value, which itself has
+ // an unexported field of type unsafe.Pointer.
+ old_safemode = safemode
+
+ safemode = 0
+ walkcompare(&n, init)
+ safemode = old_safemode
+ goto ret
+
+ case OANDAND,
+ OOROR:
+ walkexpr(&n.Left, init)
+
+ // cannot put side effects from n->right on init,
+ // because they cannot run before n->left is checked.
+ // save elsewhere and store on the eventual n->right.
+ ll = nil
+
+ walkexpr(&n.Right, &ll)
+ addinit(&n.Right, ll)
+ goto ret
+
+ case OPRINT,
+ OPRINTN:
+ walkexprlist(n.List, init)
+ n = walkprint(n, init)
+ goto ret
+
+ case OPANIC:
+ n = mkcall("gopanic", nil, init, n.Left)
+ goto ret
+
+ case ORECOVER:
+ n = mkcall("gorecover", n.Type, init, Nod(OADDR, nodfp, nil))
+ goto ret
+
+ case OLITERAL:
+ n.Addable = 1
+ goto ret
+
+ case OCLOSUREVAR,
+ OCFUNC:
+ n.Addable = 1
+ goto ret
+
+ case ONAME:
+ if !(n.Class&PHEAP != 0) && n.Class != PPARAMREF {
+ n.Addable = 1
+ }
+ goto ret
+
+ case OCALLINTER:
+ t = n.Left.Type
+ if n.List != nil && n.List.N.Op == OAS {
+ goto ret
+ }
+ walkexpr(&n.Left, init)
+ walkexprlist(n.List, init)
+ ll = ascompatte(int(n.Op), n, int(n.Isddd), getinarg(t), n.List, 0, init)
+ n.List = reorder1(ll)
+ goto ret
+
+ case OCALLFUNC:
+ if n.Left.Op == OCLOSURE {
+ // Transform direct call of a closure to call of a normal function.
+ // transformclosure already did all preparation work.
+
+ // Append captured variables to argument list.
+ n.List = concat(n.List, n.Left.Enter)
+
+ n.Left.Enter = nil
+
+ // Replace OCLOSURE with ONAME/PFUNC.
+ n.Left = n.Left.Closure.Nname
+
+ // Update type of OCALLFUNC node.
+ // Output arguments had not changed, but their offsets could.
+ if n.Left.Type.Outtuple == 1 {
+ t = getoutargx(n.Left.Type).Type
+ if t.Etype == TFIELD {
+ t = t.Type
+ }
+ n.Type = t
+ } else {
+ n.Type = getoutargx(n.Left.Type)
+ }
+ }
+
+ t = n.Left.Type
+ if n.List != nil && n.List.N.Op == OAS {
+ goto ret
+ }
+
+ walkexpr(&n.Left, init)
+ walkexprlist(n.List, init)
+
+ ll = ascompatte(int(n.Op), n, int(n.Isddd), getinarg(t), n.List, 0, init)
+ n.List = reorder1(ll)
+ goto ret
+
+ case OCALLMETH:
+ t = n.Left.Type
+ if n.List != nil && n.List.N.Op == OAS {
+ goto ret
+ }
+ walkexpr(&n.Left, init)
+ walkexprlist(n.List, init)
+ ll = ascompatte(int(n.Op), n, 0, getthis(t), list1(n.Left.Left), 0, init)
+ lr = ascompatte(int(n.Op), n, int(n.Isddd), getinarg(t), n.List, 0, init)
+ ll = concat(ll, lr)
+ n.Left.Left = nil
+ ullmancalc(n.Left)
+ n.List = reorder1(ll)
+ goto ret
+
+ case OAS:
+ *init = concat(*init, n.Ninit)
+ n.Ninit = nil
+
+ walkexpr(&n.Left, init)
+ n.Left = safeexpr(n.Left, init)
+
+ if oaslit(n, init) != 0 {
+ goto ret
+ }
+
+ if n.Right == nil || iszero(n.Right) != 0 && !(flag_race != 0) {
+ goto ret
+ }
+
+ switch n.Right.Op {
+ default:
+ walkexpr(&n.Right, init)
+
+ // x = i.(T); n->left is x, n->right->left is i.
+ // orderstmt made sure x is addressable.
+ case ODOTTYPE:
+ walkexpr(&n.Right.Left, init)
+
+ n1 = Nod(OADDR, n.Left, nil)
+ r = n.Right // i.(T)
+
+ from = "I"
+
+ to = "T"
+ if isnilinter(r.Left.Type) != 0 {
+ from = "E"
+ }
+ if isnilinter(r.Type) != 0 {
+ to = "E"
+ } else if Isinter(r.Type) != 0 {
+ to = "I"
+ }
+
+ buf = fmt.Sprintf("assert%s2%s", from, to)
+
+ fn = syslook(buf, 1)
+ argtype(fn, r.Left.Type)
+ argtype(fn, r.Type)
+
+ n = mkcall1(fn, nil, init, typename(r.Type), r.Left, n1)
+ walkexpr(&n, init)
+ goto ret
+
+ // x = <-c; n->left is x, n->right->left is c.
+ // orderstmt made sure x is addressable.
+ case ORECV:
+ walkexpr(&n.Right.Left, init)
+
+ n1 = Nod(OADDR, n.Left, nil)
+ r = n.Right.Left // the channel
+ n = mkcall1(chanfn("chanrecv1", 2, r.Type), nil, init, typename(r.Type), r, n1)
+ walkexpr(&n, init)
+ goto ret
+ }
+
+ if n.Left != nil && n.Right != nil {
+ r = convas(Nod(OAS, n.Left, n.Right), init)
+ r.Dodata = n.Dodata
+ n = r
+ n = applywritebarrier(n, init)
+ }
+
+ goto ret
+
+ case OAS2:
+ *init = concat(*init, n.Ninit)
+ n.Ninit = nil
+ walkexprlistsafe(n.List, init)
+ walkexprlistsafe(n.Rlist, init)
+ ll = ascompatee(OAS, n.List, n.Rlist, init)
+ ll = reorder3(ll)
+ for lr = ll; lr != nil; lr = lr.Next {
+ lr.N = applywritebarrier(lr.N, init)
+ }
+ n = liststmt(ll)
+ goto ret
+
+ // a,b,... = fn()
+ case OAS2FUNC:
+ *init = concat(*init, n.Ninit)
+
+ n.Ninit = nil
+ r = n.Rlist.N
+ walkexprlistsafe(n.List, init)
+ walkexpr(&r, init)
+
+ ll = ascompatet(int(n.Op), n.List, &r.Type, 0, init)
+ for lr = ll; lr != nil; lr = lr.Next {
+ lr.N = applywritebarrier(lr.N, init)
+ }
+ n = liststmt(concat(list1(r), ll))
+ goto ret
+
+ // x, y = <-c
+ // orderstmt made sure x is addressable.
+ case OAS2RECV:
+ *init = concat(*init, n.Ninit)
+
+ n.Ninit = nil
+ r = n.Rlist.N
+ walkexprlistsafe(n.List, init)
+ walkexpr(&r.Left, init)
+ if isblank(n.List.N) {
+ n1 = nodnil()
+ } else {
+ n1 = Nod(OADDR, n.List.N, nil)
+ }
+ n1.Etype = 1 // addr does not escape
+ fn = chanfn("chanrecv2", 2, r.Left.Type)
+ r = mkcall1(fn, n.List.Next.N.Type, init, typename(r.Left.Type), r.Left, n1)
+ n = Nod(OAS, n.List.Next.N, r)
+ typecheck(&n, Etop)
+ goto ret
+
+ // a,b = m[i];
+ case OAS2MAPR:
+ *init = concat(*init, n.Ninit)
+
+ n.Ninit = nil
+ r = n.Rlist.N
+ walkexprlistsafe(n.List, init)
+ walkexpr(&r.Left, init)
+ walkexpr(&r.Right, init)
+ t = r.Left.Type
+ p = ""
+ if t.Type.Width <= 128 { // Check ../../runtime/hashmap.go:maxValueSize before changing.
+ switch Simsimtype(t.Down) {
+ case TINT32,
+ TUINT32:
+ p = "mapaccess2_fast32"
+
+ case TINT64,
+ TUINT64:
+ p = "mapaccess2_fast64"
+
+ case TSTRING:
+ p = "mapaccess2_faststr"
+ }
+ }
+
+ if p != "" {
+ // fast versions take key by value
+ key = r.Right
+ } else {
+ // standard version takes key by reference
+ // orderexpr made sure key is addressable.
+ key = Nod(OADDR, r.Right, nil)
+
+ p = "mapaccess2"
+ }
+
+ // from:
+ // a,b = m[i]
+ // to:
+ // var,b = mapaccess2*(t, m, i)
+ // a = *var
+ a = n.List.N
+
+ fn = mapfn(p, t)
+ r = mkcall1(fn, getoutargx(fn.Type), init, typename(t), r.Left, key)
+
+ // mapaccess2* returns a typed bool, but due to spec changes,
+ // the boolean result of i.(T) is now untyped so we make it the
+ // same type as the variable on the lhs.
+ if !isblank(n.List.Next.N) {
+ r.Type.Type.Down.Type = n.List.Next.N.Type
+ }
+ n.Rlist = list1(r)
+ n.Op = OAS2FUNC
+
+ // don't generate a = *var if a is _
+ if !isblank(a) {
+ var_ = temp(Ptrto(t.Type))
+ var_.Typecheck = 1
+ n.List.N = var_
+ walkexpr(&n, init)
+ *init = list(*init, n)
+ n = Nod(OAS, a, Nod(OIND, var_, nil))
+ }
+
+ typecheck(&n, Etop)
+ walkexpr(&n, init)
+
+ // mapaccess needs a zero value to be at least this big.
+ if zerosize < t.Type.Width {
+ zerosize = t.Type.Width
+ }
+
+ // TODO: ptr is always non-nil, so disable nil check for this OIND op.
+ goto ret
+
+ case ODELETE:
+ *init = concat(*init, n.Ninit)
+ n.Ninit = nil
+ map_ = n.List.N
+ key = n.List.Next.N
+ walkexpr(&map_, init)
+ walkexpr(&key, init)
+
+ // orderstmt made sure key is addressable.
+ key = Nod(OADDR, key, nil)
+
+ t = map_.Type
+ n = mkcall1(mapfndel("mapdelete", t), nil, init, typename(t), map_, key)
+ goto ret
+
+ // a,b = i.(T)
+ // orderstmt made sure a is addressable.
+ case OAS2DOTTYPE:
+ *init = concat(*init, n.Ninit)
+
+ n.Ninit = nil
+ r = n.Rlist.N
+ walkexprlistsafe(n.List, init)
+ walkexpr(&r.Left, init)
+ if isblank(n.List.N) {
+ n1 = nodnil()
+ } else {
+ n1 = Nod(OADDR, n.List.N, nil)
+ }
+ n1.Etype = 1 // addr does not escape
+
+ from = "I"
+
+ to = "T"
+ if isnilinter(r.Left.Type) != 0 {
+ from = "E"
+ }
+ if isnilinter(r.Type) != 0 {
+ to = "E"
+ } else if Isinter(r.Type) != 0 {
+ to = "I"
+ }
+ buf = fmt.Sprintf("assert%s2%s2", from, to)
+
+ fn = syslook(buf, 1)
+ argtype(fn, r.Left.Type)
+ argtype(fn, r.Type)
+
+ t = Types[TBOOL]
+ ok = n.List.Next.N
+ if !isblank(ok) {
+ t = ok.Type
+ }
+ r = mkcall1(fn, t, init, typename(r.Type), r.Left, n1)
+ n = Nod(OAS, ok, r)
+ typecheck(&n, Etop)
+ goto ret
+
+ case ODOTTYPE,
+ ODOTTYPE2:
+ Fatal("walkexpr ODOTTYPE") // should see inside OAS or OAS2 only
+ fallthrough
+
+ case OCONVIFACE:
+ walkexpr(&n.Left, init)
+
+ // Optimize convT2E as a two-word copy when T is pointer-shaped.
+ if isnilinter(n.Type) != 0 && isdirectiface(n.Left.Type) != 0 {
+ l = Nod(OEFACE, typename(n.Left.Type), n.Left)
+ l.Type = n.Type
+ l.Typecheck = n.Typecheck
+ n = l
+ goto ret
+ }
+
+ // Build name of function: convI2E etc.
+ // Not all names are possible
+ // (e.g., we'll never generate convE2E or convE2I).
+ from = "T"
+
+ to = "I"
+ if isnilinter(n.Left.Type) != 0 {
+ from = "E"
+ } else if Isinter(n.Left.Type) != 0 {
+ from = "I"
+ }
+ if isnilinter(n.Type) != 0 {
+ to = "E"
+ }
+ buf = fmt.Sprintf("conv%s2%s", from, to)
+
+ fn = syslook(buf, 1)
+ ll = nil
+ if !(Isinter(n.Left.Type) != 0) {
+ ll = list(ll, typename(n.Left.Type))
+ }
+ if !(isnilinter(n.Type) != 0) {
+ ll = list(ll, typename(n.Type))
+ }
+ if !(Isinter(n.Left.Type) != 0) && !(isnilinter(n.Type) != 0) {
+ sym = Pkglookup(fmt.Sprintf("%v.%v", Tconv(n.Left.Type, obj.FmtLeft), Tconv(n.Type, obj.FmtLeft)), itabpkg)
+ if sym.Def == nil {
+ l = Nod(ONAME, nil, nil)
+ l.Sym = sym
+ l.Type = Ptrto(Types[TUINT8])
+ l.Addable = 1
+ l.Class = PEXTERN
+ l.Xoffset = 0
+ sym.Def = l
+ ggloblsym(sym, int32(Widthptr), obj.DUPOK|obj.NOPTR)
+ }
+
+ l = Nod(OADDR, sym.Def, nil)
+ l.Addable = 1
+ ll = list(ll, l)
+
+ if isdirectiface(n.Left.Type) != 0 {
+ /* For pointer types, we can make a special form of optimization
+ *
+ * These statements are put onto the expression init list:
+ * Itab *tab = atomicloadtype(&cache);
+ * if(tab == nil)
+ * tab = typ2Itab(type, itype, &cache);
+ *
+ * The CONVIFACE expression is replaced with this:
+ * OEFACE{tab, ptr};
+ */
+ l = temp(Ptrto(Types[TUINT8]))
+
+ n1 = Nod(OAS, l, sym.Def)
+ typecheck(&n1, Etop)
+ *init = list(*init, n1)
+
+ fn = syslook("typ2Itab", 1)
+ n1 = Nod(OCALL, fn, nil)
+ n1.List = ll
+ typecheck(&n1, Erv)
+ walkexpr(&n1, init)
+
+ n2 = Nod(OIF, nil, nil)
+ n2.Ntest = Nod(OEQ, l, nodnil())
+ n2.Nbody = list1(Nod(OAS, l, n1))
+ n2.Likely = -1
+ typecheck(&n2, Etop)
+ *init = list(*init, n2)
+
+ l = Nod(OEFACE, l, n.Left)
+ l.Typecheck = n.Typecheck
+ l.Type = n.Type
+ n = l
+ goto ret
+ }
+ }
+
+ if Isinter(n.Left.Type) != 0 {
+ ll = list(ll, n.Left)
+ } else {
+ // regular types are passed by reference to avoid C vararg calls
+ // orderexpr arranged for n->left to be a temporary for all
+ // the conversions it could see. comparison of an interface
+ // with a non-interface, especially in a switch on interface value
+ // with non-interface cases, is not visible to orderstmt, so we
+ // have to fall back on allocating a temp here.
+ if islvalue(n.Left) != 0 {
+ ll = list(ll, Nod(OADDR, n.Left, nil))
+ } else {
+ ll = list(ll, Nod(OADDR, copyexpr(n.Left, n.Left.Type, init), nil))
+ }
+ }
+
+ argtype(fn, n.Left.Type)
+ argtype(fn, n.Type)
+ dowidth(fn.Type)
+ n = Nod(OCALL, fn, nil)
+ n.List = ll
+ typecheck(&n, Erv)
+ walkexpr(&n, init)
+ goto ret
+
+ case OCONV,
+ OCONVNOP:
+ if Thearch.Thechar == '5' {
+ if Isfloat[n.Left.Type.Etype] != 0 {
+ if n.Type.Etype == TINT64 {
+ n = mkcall("float64toint64", n.Type, init, conv(n.Left, Types[TFLOAT64]))
+ goto ret
+ }
+
+ if n.Type.Etype == TUINT64 {
+ n = mkcall("float64touint64", n.Type, init, conv(n.Left, Types[TFLOAT64]))
+ goto ret
+ }
+ }
+
+ if Isfloat[n.Type.Etype] != 0 {
+ if n.Left.Type.Etype == TINT64 {
+ n = mkcall("int64tofloat64", n.Type, init, conv(n.Left, Types[TINT64]))
+ goto ret
+ }
+
+ if n.Left.Type.Etype == TUINT64 {
+ n = mkcall("uint64tofloat64", n.Type, init, conv(n.Left, Types[TUINT64]))
+ goto ret
+ }
+ }
+ }
+
+ walkexpr(&n.Left, init)
+ goto ret
+
+ case OANDNOT:
+ walkexpr(&n.Left, init)
+ n.Op = OAND
+ n.Right = Nod(OCOM, n.Right, nil)
+ typecheck(&n.Right, Erv)
+ walkexpr(&n.Right, init)
+ goto ret
+
+ case OMUL:
+ walkexpr(&n.Left, init)
+ walkexpr(&n.Right, init)
+ walkmul(&n, init)
+ goto ret
+
+ case ODIV,
+ OMOD:
+ walkexpr(&n.Left, init)
+ walkexpr(&n.Right, init)
+
+ /*
+ * rewrite complex div into function call.
+ */
+ et = int(n.Left.Type.Etype)
+
+ if Iscomplex[et] != 0 && n.Op == ODIV {
+ t = n.Type
+ n = mkcall("complex128div", Types[TCOMPLEX128], init, conv(n.Left, Types[TCOMPLEX128]), conv(n.Right, Types[TCOMPLEX128]))
+ n = conv(n, t)
+ goto ret
+ }
+
+ // Nothing to do for float divisions.
+ if Isfloat[et] != 0 {
+ goto ret
+ }
+
+ // Try rewriting as shifts or magic multiplies.
+ walkdiv(&n, init)
+
+ /*
+ * rewrite 64-bit div and mod into function calls
+ * on 32-bit architectures.
+ */
+ switch n.Op {
+ case OMOD,
+ ODIV:
+ if Widthreg >= 8 || (et != TUINT64 && et != TINT64) {
+ goto ret
+ }
+ if et == TINT64 {
+ namebuf = "int64"
+ } else {
+ namebuf = "uint64"
+ }
+ if n.Op == ODIV {
+ namebuf += "div"
+ } else {
+ namebuf += "mod"
+ }
+ n = mkcall(namebuf, n.Type, init, conv(n.Left, Types[et]), conv(n.Right, Types[et]))
+
+ default:
+ break
+ }
+
+ goto ret
+
+ case OINDEX:
+ walkexpr(&n.Left, init)
+
+ // save the original node for bounds checking elision.
+ // If it was a ODIV/OMOD walk might rewrite it.
+ r = n.Right
+
+ walkexpr(&n.Right, init)
+
+ // if range of type cannot exceed static array bound,
+ // disable bounds check.
+ if n.Bounded != 0 {
+ goto ret
+ }
+ t = n.Left.Type
+ if t != nil && Isptr[t.Etype] != 0 {
+ t = t.Type
+ }
+ if Isfixedarray(t) != 0 {
+ n.Bounded = uint8(bounded(r, t.Bound))
+ if Debug['m'] != 0 && n.Bounded != 0 && !(Isconst(n.Right, CTINT) != 0) {
+ Warn("index bounds check elided")
+ }
+ if Smallintconst(n.Right) != 0 && !(n.Bounded != 0) {
+ Yyerror("index out of bounds")
+ }
+ } else if Isconst(n.Left, CTSTR) != 0 {
+ n.Bounded = uint8(bounded(r, int64(len(n.Left.Val.U.Sval.S))))
+ if Debug['m'] != 0 && n.Bounded != 0 && !(Isconst(n.Right, CTINT) != 0) {
+ Warn("index bounds check elided")
+ }
+ if Smallintconst(n.Right) != 0 {
+ if !(n.Bounded != 0) {
+ Yyerror("index out of bounds")
+ } else {
+ // replace "abc"[1] with 'b'.
+ // delayed until now because "abc"[1] is not
+ // an ideal constant.
+ v = Mpgetfix(n.Right.Val.U.Xval)
+
+ Nodconst(n, n.Type, int64(n.Left.Val.U.Sval.S[v]))
+ n.Typecheck = 1
+ }
+ }
+ }
+
+ if Isconst(n.Right, CTINT) != 0 {
+ if Mpcmpfixfix(n.Right.Val.U.Xval, &mpzero) < 0 || Mpcmpfixfix(n.Right.Val.U.Xval, Maxintval[TINT]) > 0 {
+ Yyerror("index out of bounds")
+ }
+ }
+ goto ret
+
+ case OINDEXMAP:
+ if n.Etype == 1 {
+ goto ret
+ }
+ walkexpr(&n.Left, init)
+ walkexpr(&n.Right, init)
+
+ t = n.Left.Type
+ p = ""
+ if t.Type.Width <= 128 { // Check ../../runtime/hashmap.go:maxValueSize before changing.
+ switch Simsimtype(t.Down) {
+ case TINT32,
+ TUINT32:
+ p = "mapaccess1_fast32"
+
+ case TINT64,
+ TUINT64:
+ p = "mapaccess1_fast64"
+
+ case TSTRING:
+ p = "mapaccess1_faststr"
+ }
+ }
+
+ if p != "" {
+ // fast versions take key by value
+ key = n.Right
+ } else {
+ // standard version takes key by reference.
+ // orderexpr made sure key is addressable.
+ key = Nod(OADDR, n.Right, nil)
+
+ p = "mapaccess1"
+ }
+
+ n = mkcall1(mapfn(p, t), Ptrto(t.Type), init, typename(t), n.Left, key)
+ n = Nod(OIND, n, nil)
+ n.Type = t.Type
+ n.Typecheck = 1
+
+ // mapaccess needs a zero value to be at least this big.
+ if zerosize < t.Type.Width {
+ zerosize = t.Type.Width
+ }
+ goto ret
+
+ case ORECV:
+ Fatal("walkexpr ORECV") // should see inside OAS only
+ fallthrough
+
+ case OSLICE:
+ if n.Right != nil && n.Right.Left == nil && n.Right.Right == nil { // noop
+ walkexpr(&n.Left, init)
+ n = n.Left
+ goto ret
+ }
+ fallthrough
+
+ // fallthrough
+ case OSLICEARR,
+ OSLICESTR:
+ if n.Right == nil { // already processed
+ goto ret
+ }
+
+ walkexpr(&n.Left, init)
+
+ // cgen_slice can't handle string literals as source
+ // TODO the OINDEX case is a bug elsewhere that needs to be traced. it causes a crash on ([2][]int{ ... })[1][lo:hi]
+ if (n.Op == OSLICESTR && n.Left.Op == OLITERAL) || (n.Left.Op == OINDEX) {
+ n.Left = copyexpr(n.Left, n.Left.Type, init)
+ } else {
+ n.Left = safeexpr(n.Left, init)
+ }
+ walkexpr(&n.Right.Left, init)
+ n.Right.Left = safeexpr(n.Right.Left, init)
+ walkexpr(&n.Right.Right, init)
+ n.Right.Right = safeexpr(n.Right.Right, init)
+ n = sliceany(n, init) // chops n->right, sets n->list
+ goto ret
+
+ case OSLICE3,
+ OSLICE3ARR:
+ if n.Right == nil { // already processed
+ goto ret
+ }
+
+ walkexpr(&n.Left, init)
+
+ // TODO the OINDEX case is a bug elsewhere that needs to be traced. it causes a crash on ([2][]int{ ... })[1][lo:hi]
+ // TODO the comment on the previous line was copied from case OSLICE. it might not even be true.
+ if n.Left.Op == OINDEX {
+ n.Left = copyexpr(n.Left, n.Left.Type, init)
+ } else {
+ n.Left = safeexpr(n.Left, init)
+ }
+ walkexpr(&n.Right.Left, init)
+ n.Right.Left = safeexpr(n.Right.Left, init)
+ walkexpr(&n.Right.Right.Left, init)
+ n.Right.Right.Left = safeexpr(n.Right.Right.Left, init)
+ walkexpr(&n.Right.Right.Right, init)
+ n.Right.Right.Right = safeexpr(n.Right.Right.Right, init)
+ n = sliceany(n, init) // chops n->right, sets n->list
+ goto ret
+
+ case OADDR:
+ walkexpr(&n.Left, init)
+ goto ret
+
+ case ONEW:
+ if n.Esc == EscNone && n.Type.Type.Width < 1<<16 {
+ r = temp(n.Type.Type)
+ r = Nod(OAS, r, nil) // zero temp
+ typecheck(&r, Etop)
+ *init = list(*init, r)
+ r = Nod(OADDR, r.Left, nil)
+ typecheck(&r, Erv)
+ n = r
+ } else {
+ n = callnew(n.Type.Type)
+ }
+
+ goto ret
+
+ // If one argument to the comparison is an empty string,
+ // comparing the lengths instead will yield the same result
+ // without the function call.
+ case OCMPSTR:
+ if (Isconst(n.Left, CTSTR) != 0 && len(n.Left.Val.U.Sval.S) == 0) || (Isconst(n.Right, CTSTR) != 0 && len(n.Right.Val.U.Sval.S) == 0) {
+ r = Nod(int(n.Etype), Nod(OLEN, n.Left, nil), Nod(OLEN, n.Right, nil))
+ typecheck(&r, Erv)
+ walkexpr(&r, init)
+ r.Type = n.Type
+ n = r
+ goto ret
+ }
+
+ // s + "badgerbadgerbadger" == "badgerbadgerbadger"
+ if (n.Etype == OEQ || n.Etype == ONE) && Isconst(n.Right, CTSTR) != 0 && n.Left.Op == OADDSTR && count(n.Left.List) == 2 && Isconst(n.Left.List.Next.N, CTSTR) != 0 && cmpslit(n.Right, n.Left.List.Next.N) == 0 {
+ r = Nod(int(n.Etype), Nod(OLEN, n.Left.List.N, nil), Nodintconst(0))
+ typecheck(&r, Erv)
+ walkexpr(&r, init)
+ r.Type = n.Type
+ n = r
+ goto ret
+ }
+
+ if n.Etype == OEQ || n.Etype == ONE {
+ // prepare for rewrite below
+ n.Left = cheapexpr(n.Left, init)
+
+ n.Right = cheapexpr(n.Right, init)
+
+ r = mkcall("eqstring", Types[TBOOL], init, conv(n.Left, Types[TSTRING]), conv(n.Right, Types[TSTRING]))
+
+ // quick check of len before full compare for == or !=
+ // eqstring assumes that the lengths are equal
+ if 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)
+ } 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)
+ }
+
+ typecheck(&r, Erv)
+ walkexpr(&r, nil)
+ } else {
+ // sys_cmpstring(s1, s2) :: 0
+ r = mkcall("cmpstring", Types[TINT], init, conv(n.Left, Types[TSTRING]), conv(n.Right, Types[TSTRING]))
+
+ r = Nod(int(n.Etype), r, Nodintconst(0))
+ }
+
+ typecheck(&r, Erv)
+ if n.Type.Etype != TBOOL {
+ Fatal("cmp %v", Tconv(n.Type, 0))
+ }
+ r.Type = n.Type
+ n = r
+ goto ret
+
+ case OADDSTR:
+ n = addstr(n, init)
+ goto ret
+
+ case OAPPEND:
+ if n.Isddd != 0 {
+ n = appendslice(n, init) // also works for append(slice, string).
+ } else {
+ n = walkappend(n, init)
+ }
+ goto ret
+
+ case OCOPY:
+ n = copyany(n, init, flag_race)
+ goto ret
+
+ // cannot use chanfn - closechan takes any, not chan any
+ case OCLOSE:
+ fn = syslook("closechan", 1)
+
+ argtype(fn, n.Left.Type)
+ n = mkcall1(fn, nil, init, n.Left)
+ goto ret
+
+ case OMAKECHAN:
+ n = mkcall1(chanfn("makechan", 1, n.Type), n.Type, init, typename(n.Type), conv(n.Left, Types[TINT64]))
+ goto ret
+
+ case OMAKEMAP:
+ t = n.Type
+
+ fn = syslook("makemap", 1)
+
+ a = nodnil() // hmap buffer
+ r = nodnil() // bucket buffer
+ if n.Esc == EscNone {
+ // Allocate hmap buffer on stack.
+ var_ = temp(hmap(t))
+
+ a = Nod(OAS, var_, nil) // zero temp
+ typecheck(&a, Etop)
+ *init = list(*init, a)
+ 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
+ typecheck(&r, Etop)
+ *init = list(*init, r)
+ r = Nod(OADDR, var_, nil)
+ }
+
+ argtype(fn, hmap(t)) // hmap buffer
+ argtype(fn, mapbucket(t)) // bucket buffer
+ argtype(fn, t.Down) // key type
+ argtype(fn, t.Type) // value type
+ n = mkcall1(fn, n.Type, init, typename(n.Type), conv(n.Left, Types[TINT64]), a, r)
+ goto ret
+
+ case OMAKESLICE:
+ l = n.Left
+ r = n.Right
+ if r == nil {
+ r = safeexpr(l, init)
+ l = r
+ }
+ t = n.Type
+ if n.Esc == EscNone && Smallintconst(l) != 0 && Smallintconst(r) != 0 && (t.Type.Width == 0 || Mpgetfix(r.Val.U.Xval) < (1<<16)/t.Type.Width) {
+ // var arr [r]T
+ // n = arr[:l]
+ t = aindex(r, t.Type) // [r]T
+ var_ = temp(t)
+ a = Nod(OAS, var_, nil) // zero temp
+ typecheck(&a, Etop)
+ *init = list(*init, a)
+ r = Nod(OSLICE, var_, Nod(OKEY, nil, l)) // arr[:l]
+ r = conv(r, n.Type) // in case n->type is named.
+ typecheck(&r, Erv)
+ walkexpr(&r, init)
+ n = r
+ } else {
+ // makeslice(t *Type, nel int64, max int64) (ary []any)
+ fn = syslook("makeslice", 1)
+
+ argtype(fn, t.Type) // any-1
+ n = mkcall1(fn, n.Type, init, typename(n.Type), conv(l, Types[TINT64]), conv(r, Types[TINT64]))
+ }
+
+ goto ret
+
+ case ORUNESTR:
+ a = nodnil()
+ if n.Esc == EscNone {
+ t = aindex(Nodintconst(4), Types[TUINT8])
+ var_ = temp(t)
+ a = Nod(OADDR, var_, nil)
+ }
+
+ // intstring(*[4]byte, rune)
+ n = mkcall("intstring", n.Type, init, a, conv(n.Left, Types[TINT64]))
+
+ goto ret
+
+ case OARRAYBYTESTR:
+ a = nodnil()
+ if n.Esc == EscNone {
+ // Create temporary buffer for string on stack.
+ t = aindex(Nodintconst(tmpstringbufsize), Types[TUINT8])
+
+ a = Nod(OADDR, temp(t), nil)
+ }
+
+ // slicebytetostring(*[32]byte, []byte) string;
+ n = mkcall("slicebytetostring", n.Type, init, a, n.Left)
+
+ goto ret
+
+ // slicebytetostringtmp([]byte) string;
+ case OARRAYBYTESTRTMP:
+ n = mkcall("slicebytetostringtmp", n.Type, init, n.Left)
+
+ goto ret
+
+ // slicerunetostring(*[32]byte, []rune) string;
+ case OARRAYRUNESTR:
+ a = nodnil()
+
+ if n.Esc == EscNone {
+ // Create temporary buffer for string on stack.
+ t = aindex(Nodintconst(tmpstringbufsize), Types[TUINT8])
+
+ a = Nod(OADDR, temp(t), nil)
+ }
+
+ n = mkcall("slicerunetostring", n.Type, init, a, n.Left)
+ goto ret
+
+ // stringtoslicebyte(*32[byte], string) []byte;
+ case OSTRARRAYBYTE:
+ a = nodnil()
+
+ if n.Esc == EscNone {
+ // Create temporary buffer for slice on stack.
+ t = aindex(Nodintconst(tmpstringbufsize), Types[TUINT8])
+
+ a = Nod(OADDR, temp(t), nil)
+ }
+
+ n = mkcall("stringtoslicebyte", n.Type, init, a, conv(n.Left, Types[TSTRING]))
+ goto ret
+
+ // stringtoslicebytetmp(string) []byte;
+ case OSTRARRAYBYTETMP:
+ n = mkcall("stringtoslicebytetmp", n.Type, init, conv(n.Left, Types[TSTRING]))
+
+ goto ret
+
+ // stringtoslicerune(*[32]rune, string) []rune
+ case OSTRARRAYRUNE:
+ a = nodnil()
+
+ if n.Esc == EscNone {
+ // Create temporary buffer for slice on stack.
+ t = aindex(Nodintconst(tmpstringbufsize), Types[TINT32])
+
+ a = Nod(OADDR, temp(t), nil)
+ }
+
+ n = mkcall("stringtoslicerune", n.Type, init, a, n.Left)
+ goto ret
+
+ // ifaceeq(i1 any-1, i2 any-2) (ret bool);
+ case OCMPIFACE:
+ if !Eqtype(n.Left.Type, n.Right.Type) {
+ Fatal("ifaceeq %v %v %v", Oconv(int(n.Op), 0), Tconv(n.Left.Type, 0), Tconv(n.Right.Type, 0))
+ }
+ if isnilinter(n.Left.Type) != 0 {
+ fn = syslook("efaceeq", 1)
+ } else {
+ fn = syslook("ifaceeq", 1)
+ }
+
+ n.Right = cheapexpr(n.Right, init)
+ n.Left = cheapexpr(n.Left, init)
+ argtype(fn, n.Right.Type)
+ argtype(fn, n.Left.Type)
+ r = mkcall1(fn, n.Type, init, n.Left, n.Right)
+ if n.Etype == ONE {
+ r = Nod(ONOT, r, nil)
+ }
+
+ // check itable/type before full compare.
+ if n.Etype == OEQ {
+ 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)
+ }
+ typecheck(&r, Erv)
+ walkexpr(&r, init)
+ r.Type = n.Type
+ n = r
+ goto ret
+
+ case OARRAYLIT,
+ OMAPLIT,
+ OSTRUCTLIT,
+ OPTRLIT:
+ var_ = temp(n.Type)
+ anylit(0, n, var_, init)
+ n = var_
+ goto ret
+
+ case OSEND:
+ n1 = n.Right
+ n1 = assignconv(n1, n.Left.Type.Type, "chan send")
+ walkexpr(&n1, init)
+ n1 = Nod(OADDR, n1, nil)
+ n = mkcall1(chanfn("chansend1", 2, n.Left.Type), nil, init, typename(n.Left.Type), n.Left, n1)
+ goto ret
+
+ case OCLOSURE:
+ n = walkclosure(n, init)
+ goto ret
+
+ case OCALLPART:
+ n = walkpartialcall(n, init)
+ goto ret
+ }
+
+ Fatal("missing switch %v", Oconv(int(n.Op), 0))
+
+ // Expressions that are constant at run time but not
+ // considered const by the language spec are not turned into
+ // constants until walk. For example, if n is y%1 == 0, the
+ // walk of y%1 may have replaced it by 0.
+ // Check whether n with its updated args is itself now a constant.
+ret:
+ t = n.Type
+
+ evconst(n)
+ n.Type = t
+ if n.Op == OLITERAL {
+ typecheck(&n, Erv)
+ }
+
+ ullmancalc(n)
+
+ if Debug['w'] != 0 && n != nil {
+ Dump("walk", n)
+ }
+
+ lineno = lno
+ *np = n
+}
+
+func ascompatee1(op int, l *Node, r *Node, init **NodeList) *Node {
+ var n *Node
+
+ // convas will turn map assigns into function calls,
+ // making it impossible for reorder3 to work.
+ n = Nod(OAS, l, r)
+
+ if l.Op == OINDEXMAP {
+ return n
+ }
+
+ return convas(n, init)
+}
+
+func ascompatee(op int, nl *NodeList, nr *NodeList, init **NodeList) *NodeList {
+ var ll *NodeList
+ var lr *NodeList
+ var nn *NodeList
+
+ /*
+ * check assign expression list to
+ * a expression list. called in
+ * expr-list = expr-list
+ */
+
+ // ensure order of evaluation for function calls
+ for ll = nl; ll != nil; ll = ll.Next {
+ ll.N = safeexpr(ll.N, init)
+ }
+ for lr = nr; lr != nil; lr = lr.Next {
+ lr.N = safeexpr(lr.N, init)
+ }
+
+ nn = nil
+ ll = nl
+ lr = nr
+ for ; ll != nil && lr != nil; (func() { ll = ll.Next; lr = lr.Next })() {
+ // Do not generate 'x = x' during return. See issue 4014.
+ if op == ORETURN && ll.N == lr.N {
+ continue
+ }
+ nn = list(nn, ascompatee1(op, ll.N, lr.N, init))
+ }
+
+ // cannot happen: caller checked that lists had same length
+ if ll != nil || lr != nil {
+ Yyerror("error in shape across %v %v %v / %d %d [%s]", Hconv(nl, obj.FmtSign), Oconv(int(op), 0), Hconv(nr, obj.FmtSign), count(nl), count(nr), Curfn.Nname.Sym.Name)
+ }
+ return nn
+}
+
+/*
+ * l is an lv and rt is the type of an rv
+ * return 1 if this implies a function call
+ * evaluating the lv or a function call
+ * in the conversion of the types
+ */
+func fncall(l *Node, rt *Type) int {
+ var r Node
+
+ if l.Ullman >= UINF || l.Op == OINDEXMAP {
+ return 1
+ }
+ r = Node{}
+ if needwritebarrier(l, &r) != 0 {
+ return 1
+ }
+ if Eqtype(l.Type, rt) {
+ return 0
+ }
+ return 1
+}
+
+func ascompatet(op int, nl *NodeList, nr **Type, fp int, init **NodeList) *NodeList {
+ var l *Node
+ var tmp *Node
+ var a *Node
+ var ll *NodeList
+ var r *Type
+ var saver Iter
+ var ucount int
+ var nn *NodeList
+ var mm *NodeList
+
+ /*
+ * check assign type list to
+ * a expression list. called in
+ * expr-list = func()
+ */
+ r = Structfirst(&saver, nr)
+
+ nn = nil
+ mm = nil
+ ucount = 0
+ for ll = nl; ll != nil; ll = ll.Next {
+ if r == nil {
+ break
+ }
+ l = ll.N
+ if isblank(l) {
+ r = structnext(&saver)
+ continue
+ }
+
+ // any lv that causes a fn call must be
+ // deferred until all the return arguments
+ // have been pulled from the output arguments
+ if fncall(l, r.Type) != 0 {
+ tmp = temp(r.Type)
+ typecheck(&tmp, Erv)
+ a = Nod(OAS, l, tmp)
+ a = convas(a, init)
+ mm = list(mm, a)
+ l = tmp
+ }
+
+ a = Nod(OAS, l, nodarg(r, fp))
+ a = convas(a, init)
+ ullmancalc(a)
+ if a.Ullman >= UINF {
+ Dump("ascompatet ucount", a)
+ ucount++
+ }
+
+ nn = list(nn, a)
+ r = structnext(&saver)
+ }
+
+ if ll != nil || r != nil {
+ Yyerror("ascompatet: assignment count mismatch: %d = %d", count(nl), structcount(*nr))
+ }
+
+ if ucount != 0 {
+ Fatal("ascompatet: too many function calls evaluating parameters")
+ }
+ return concat(nn, mm)
+}
+
+/*
+* package all the arguments that match a ... T parameter into a []T.
+ */
+func mkdotargslice(lr0 *NodeList, nn *NodeList, l *Type, fp int, init **NodeList, ddd *Node) *NodeList {
+ var a *Node
+ var n *Node
+ var tslice *Type
+ var esc int
+
+ esc = EscUnknown
+ if ddd != nil {
+ esc = int(ddd.Esc)
+ }
+
+ tslice = typ(TARRAY)
+ tslice.Type = l.Type.Type
+ tslice.Bound = -1
+
+ if count(lr0) == 0 {
+ n = nodnil()
+ n.Type = tslice
+ } else {
+ n = Nod(OCOMPLIT, nil, typenod(tslice))
+ if ddd != nil {
+ n.Alloc = ddd.Alloc // temporary to use
+ }
+ n.List = lr0
+ n.Esc = uint(esc)
+ typecheck(&n, Erv)
+ if n.Type == nil {
+ Fatal("mkdotargslice: typecheck failed")
+ }
+ walkexpr(&n, init)
+ }
+
+ a = Nod(OAS, nodarg(l, fp), n)
+ nn = list(nn, convas(a, init))
+ return nn
+}
+
+/*
+ * helpers for shape errors
+ */
+func dumptypes(nl **Type, what string) string {
+ var first int
+ var l *Type
+ var savel Iter
+ var fmt_ string
+
+ fmt_ = ""
+ fmt_ += fmt.Sprintf("\t")
+ first = 1
+ for l = Structfirst(&savel, nl); l != nil; l = structnext(&savel) {
+ if first != 0 {
+ first = 0
+ } else {
+ fmt_ += fmt.Sprintf(", ")
+ }
+ fmt_ += fmt.Sprintf("%v", Tconv(l, 0))
+ }
+
+ if first != 0 {
+ fmt_ += fmt.Sprintf("[no arguments %s]", what)
+ }
+ return fmt_
+}
+
+func dumpnodetypes(l *NodeList, what string) string {
+ var first int
+ var r *Node
+ var fmt_ string
+
+ fmt_ = ""
+ fmt_ += fmt.Sprintf("\t")
+ first = 1
+ for ; l != nil; l = l.Next {
+ r = l.N
+ if first != 0 {
+ first = 0
+ } else {
+ fmt_ += fmt.Sprintf(", ")
+ }
+ fmt_ += fmt.Sprintf("%v", Tconv(r.Type, 0))
+ }
+
+ if first != 0 {
+ fmt_ += fmt.Sprintf("[no arguments %s]", what)
+ }
+ return fmt_
+}
+
+/*
+ * check assign expression list to
+ * a type list. called in
+ * return expr-list
+ * func(expr-list)
+ */
+func ascompatte(op int, call *Node, isddd int, nl **Type, lr *NodeList, fp int, init **NodeList) *NodeList {
+ var l *Type
+ var ll *Type
+ var r *Node
+ var a *Node
+ var nn *NodeList
+ var lr0 *NodeList
+ var alist *NodeList
+ var savel Iter
+ var l1 string
+ var l2 string
+
+ lr0 = lr
+ l = Structfirst(&savel, nl)
+ r = nil
+ if lr != nil {
+ r = lr.N
+ }
+ nn = nil
+
+ // f(g()) where g has multiple return values
+ if r != nil && lr.Next == nil && r.Type.Etype == TSTRUCT && r.Type.Funarg != 0 {
+ // optimization - can do block copy
+ if eqtypenoname(r.Type, *nl) != 0 {
+ a = nodarg(*nl, fp)
+ r = Nod(OCONVNOP, r, nil)
+ r.Type = a.Type
+ nn = list1(convas(Nod(OAS, a, r), init))
+ goto ret
+ }
+
+ // conversions involved.
+ // copy into temporaries.
+ alist = nil
+
+ for l = Structfirst(&savel, &r.Type); l != nil; l = structnext(&savel) {
+ a = temp(l.Type)
+ alist = list(alist, a)
+ }
+
+ a = Nod(OAS2, nil, nil)
+ a.List = alist
+ a.Rlist = lr
+ typecheck(&a, Etop)
+ walkstmt(&a)
+ *init = list(*init, a)
+ lr = alist
+ r = lr.N
+ l = Structfirst(&savel, nl)
+ }
+
+loop:
+ if l != nil && l.Isddd != 0 {
+ // the ddd parameter must be last
+ ll = structnext(&savel)
+
+ if ll != nil {
+ Yyerror("... must be last argument")
+ }
+
+ // special case --
+ // only if we are assigning a single ddd
+ // argument to a ddd parameter then it is
+ // passed thru unencapsulated
+ if r != nil && lr.Next == nil && isddd != 0 && Eqtype(l.Type, r.Type) {
+ a = Nod(OAS, nodarg(l, fp), r)
+ a = convas(a, init)
+ nn = list(nn, a)
+ goto ret
+ }
+
+ // normal case -- make a slice of all
+ // remaining arguments and pass it to
+ // the ddd parameter.
+ nn = mkdotargslice(lr, nn, l, fp, init, call.Right)
+
+ goto ret
+ }
+
+ if l == nil || r == nil {
+ if l != nil || r != nil {
+ l1 = dumptypes(nl, "expected")
+ l2 = dumpnodetypes(lr0, "given")
+ if l != nil {
+ Yyerror("not enough arguments to %v\n%s\n%s", Oconv(int(op), 0), l1, l2)
+ } else {
+ Yyerror("too many arguments to %v\n%s\n%s", Oconv(int(op), 0), l1, l2)
+ }
+ }
+
+ goto ret
+ }
+
+ a = Nod(OAS, nodarg(l, fp), r)
+ a = convas(a, init)
+ nn = list(nn, a)
+
+ l = structnext(&savel)
+ r = nil
+ lr = lr.Next
+ if lr != nil {
+ r = lr.N
+ }
+ goto loop
+
+ret:
+ for lr = nn; lr != nil; lr = lr.Next {
+ lr.N.Typecheck = 1
+ }
+ return nn
+}
+
+// generate code for print
+func walkprint(nn *Node, init **NodeList) *Node {
+ var r *Node
+ var n *Node
+ var l *NodeList
+ var all *NodeList
+ var on *Node
+ var t *Type
+ var notfirst int
+ var et int
+ var op int
+ var calls *NodeList
+
+ op = int(nn.Op)
+ all = nn.List
+ calls = nil
+ notfirst = 0
+
+ // Hoist all the argument evaluation up before the lock.
+ walkexprlistcheap(all, init)
+
+ calls = list(calls, mkcall("printlock", nil, init))
+
+ for l = all; l != nil; l = l.Next {
+ if notfirst != 0 {
+ calls = list(calls, mkcall("printsp", nil, init))
+ }
+
+ notfirst = bool2int(op == OPRINTN)
+
+ n = l.N
+ if n.Op == OLITERAL {
+ switch n.Val.Ctype {
+ case CTRUNE:
+ defaultlit(&n, runetype)
+
+ case CTINT:
+ defaultlit(&n, Types[TINT64])
+
+ case CTFLT:
+ defaultlit(&n, Types[TFLOAT64])
+ }
+ }
+
+ if n.Op != OLITERAL && n.Type != nil && n.Type.Etype == TIDEAL {
+ defaultlit(&n, Types[TINT64])
+ }
+ defaultlit(&n, nil)
+ l.N = n
+ if n.Type == nil || n.Type.Etype == TFORW {
+ continue
+ }
+
+ t = n.Type
+ et = int(n.Type.Etype)
+ if Isinter(n.Type) != 0 {
+ if isnilinter(n.Type) != 0 {
+ on = syslook("printeface", 1)
+ } else {
+ on = syslook("printiface", 1)
+ }
+ argtype(on, n.Type) // any-1
+ } else if Isptr[et] != 0 || et == TCHAN || et == TMAP || et == TFUNC || et == TUNSAFEPTR {
+ on = syslook("printpointer", 1)
+ argtype(on, n.Type) // any-1
+ } else if Isslice(n.Type) != 0 {
+ on = syslook("printslice", 1)
+ argtype(on, n.Type) // any-1
+ } else if Isint[et] != 0 {
+ if et == TUINT64 {
+ if (t.Sym.Pkg == Runtimepkg || compiling_runtime != 0) && t.Sym.Name == "hex" {
+ on = syslook("printhex", 0)
+ } else {
+ on = syslook("printuint", 0)
+ }
+ } else {
+ on = syslook("printint", 0)
+ }
+ } else if Isfloat[et] != 0 {
+ on = syslook("printfloat", 0)
+ } else if Iscomplex[et] != 0 {
+ on = syslook("printcomplex", 0)
+ } else if et == TBOOL {
+ on = syslook("printbool", 0)
+ } else if et == TSTRING {
+ on = syslook("printstring", 0)
+ } else {
+ badtype(OPRINT, n.Type, nil)
+ continue
+ }
+
+ t = *getinarg(on.Type)
+ if t != nil {
+ t = t.Type
+ }
+ if t != nil {
+ t = t.Type
+ }
+
+ if !Eqtype(t, n.Type) {
+ n = Nod(OCONV, n, nil)
+ n.Type = t
+ }
+
+ r = Nod(OCALL, on, nil)
+ r.List = list1(n)
+ calls = list(calls, r)
+ }
+
+ if op == OPRINTN {
+ calls = list(calls, mkcall("printnl", nil, nil))
+ }
+
+ calls = list(calls, mkcall("printunlock", nil, init))
+
+ typechecklist(calls, Etop)
+ walkexprlist(calls, init)
+
+ r = Nod(OEMPTY, nil, nil)
+ typecheck(&r, Etop)
+ walkexpr(&r, init)
+ r.Ninit = calls
+ return r
+}
+
+func callnew(t *Type) *Node {
+ var fn *Node
+
+ dowidth(t)
+ fn = syslook("newobject", 1)
+ argtype(fn, t)
+ return mkcall1(fn, Ptrto(t), nil, typename(t))
+}
+
+func isstack(n *Node) int {
+ var defn *Node
+
+ n = outervalue(n)
+
+ // If n is *autotmp and autotmp = &foo, replace n with foo.
+ // We introduce such temps when initializing struct literals.
+ if n.Op == OIND && n.Left.Op == ONAME && strings.HasPrefix(n.Left.Sym.Name, "autotmp_") {
+ defn = n.Left.Defn
+ if defn != nil && defn.Op == OAS && defn.Right.Op == OADDR {
+ n = defn.Right.Left
+ }
+ }
+
+ switch n.Op {
+ // OINDREG only ends up in walk if it's indirect of SP.
+ case OINDREG:
+ return 1
+
+ case ONAME:
+ switch n.Class {
+ case PAUTO,
+ PPARAM,
+ PPARAMOUT:
+ return 1
+ }
+ }
+
+ return 0
+}
+
+func isglobal(n *Node) int {
+ n = outervalue(n)
+
+ switch n.Op {
+ case ONAME:
+ switch n.Class {
+ case PEXTERN:
+ return 1
+ }
+ }
+
+ return 0
+}
+
+// Do we need a write barrier for the assignment l = r?
+func needwritebarrier(l *Node, r *Node) int {
+ if !(use_writebarrier != 0) {
+ return 0
+ }
+
+ if l == nil || isblank(l) {
+ return 0
+ }
+
+ // No write barrier for write of non-pointers.
+ dowidth(l.Type)
+
+ if !haspointers(l.Type) {
+ return 0
+ }
+
+ // No write barrier for write to stack.
+ if isstack(l) != 0 {
+ return 0
+ }
+
+ // No write barrier for implicit or explicit zeroing.
+ if r == nil || iszero(r) != 0 {
+ return 0
+ }
+
+ // No write barrier for initialization to constant.
+ if r.Op == OLITERAL {
+ return 0
+ }
+
+ // No write barrier for storing static (read-only) data.
+ if r.Op == ONAME && strings.HasPrefix(r.Sym.Name, "statictmp_") {
+ return 0
+ }
+
+ // No write barrier for storing address of stack values,
+ // which are guaranteed only to be written to the stack.
+ if r.Op == OADDR && isstack(r.Left) != 0 {
+ return 0
+ }
+
+ // No write barrier for storing address of global, which
+ // is live no matter what.
+ if r.Op == OADDR && isglobal(r.Left) != 0 {
+ return 0
+ }
+
+ // No write barrier for reslice: x = x[0:y] or x = append(x, ...).
+ // Both are compiled to modify x directly.
+ // In the case of append, a write barrier may still be needed
+ // if the underlying array grows, but the append code can
+ // generate the write barrier directly in that case.
+ // (It does not yet, but the cost of the write barrier will be
+ // small compared to the cost of the allocation.)
+ if r.Reslice != 0 {
+ switch r.Op {
+ case OSLICE,
+ OSLICE3,
+ OSLICESTR,
+ OAPPEND:
+ break
+
+ default:
+ Dump("bad reslice-l", l)
+ Dump("bad reslice-r", r)
+ }
+
+ return 0
+ }
+
+ // Otherwise, be conservative and use write barrier.
+ return 1
+}
+
+// TODO(rsc): Perhaps componentgen should run before this.
+
+var applywritebarrier_bv *Bvec
+
+func applywritebarrier(n *Node, init **NodeList) *Node {
+ var l *Node
+ var r *Node
+ var t *Type
+ var x int64
+ var name string
+
+ if n.Left != nil && n.Right != nil && needwritebarrier(n.Left, n.Right) != 0 {
+ if Curfn != nil && Curfn.Nowritebarrier {
+ Yyerror("write barrier prohibited")
+ }
+ t = n.Left.Type
+ l = Nod(OADDR, n.Left, nil)
+ l.Etype = 1 // addr does not escape
+ if t.Width == int64(Widthptr) {
+ n = mkcall1(writebarrierfn("writebarrierptr", t, n.Right.Type), nil, init, l, n.Right)
+ } else if t.Etype == TSTRING {
+ n = mkcall1(writebarrierfn("writebarrierstring", t, n.Right.Type), nil, init, l, n.Right)
+ } else if Isslice(t) != 0 {
+ n = mkcall1(writebarrierfn("writebarrierslice", t, n.Right.Type), nil, init, l, n.Right)
+ } else if Isinter(t) != 0 {
+ n = mkcall1(writebarrierfn("writebarrieriface", t, n.Right.Type), nil, init, l, n.Right)
+ } else if t.Width <= int64(4*Widthptr) {
+ x = 0
+ if applywritebarrier_bv == nil {
+ applywritebarrier_bv = bvalloc(obj.BitsPerPointer * 4)
+ }
+ bvresetall(applywritebarrier_bv)
+ twobitwalktype1(t, &x, applywritebarrier_bv)
+ const (
+ PtrBit = 1
+ )
+ // The bvgets are looking for BitsPointer in successive slots.
+ if obj.BitsPointer != 1<<PtrBit {
+ Fatal("wrong PtrBit")
+ }
+ switch t.Width / int64(Widthptr) {
+ default:
+ Fatal("found writebarrierfat for %d-byte object of type %v", int(t.Width), Tconv(t, 0))
+ fallthrough
+
+ case 2:
+ name = fmt.Sprintf("writebarrierfat%d%d", bvget(applywritebarrier_bv, PtrBit), bvget(applywritebarrier_bv, obj.BitsPerPointer+PtrBit))
+
+ case 3:
+ name = fmt.Sprintf("writebarrierfat%d%d%d", bvget(applywritebarrier_bv, PtrBit), bvget(applywritebarrier_bv, obj.BitsPerPointer+PtrBit), bvget(applywritebarrier_bv, 2*obj.BitsPerPointer+PtrBit))
+
+ case 4:
+ name = fmt.Sprintf("writebarrierfat%d%d%d%d", bvget(applywritebarrier_bv, PtrBit), bvget(applywritebarrier_bv, obj.BitsPerPointer+PtrBit), bvget(applywritebarrier_bv, 2*obj.BitsPerPointer+PtrBit), bvget(applywritebarrier_bv, 3*obj.BitsPerPointer+PtrBit))
+ }
+
+ n = mkcall1(writebarrierfn(name, t, n.Right.Type), nil, init, l, nodnil(), n.Right)
+ } else {
+ r = n.Right
+ for r.Op == OCONVNOP {
+ r = r.Left
+ }
+ r = Nod(OADDR, r, nil)
+ r.Etype = 1 // addr does not escape
+
+ //warnl(n->lineno, "typedmemmove %T %N", t, r);
+ n = mkcall1(writebarrierfn("typedmemmove", t, r.Left.Type), nil, init, typename(t), l, r)
+ }
+ }
+
+ return n
+}
+
+func convas(n *Node, init **NodeList) *Node {
+ var lt *Type
+ var rt *Type
+ var map_ *Node
+ var key *Node
+ var val *Node
+
+ if n.Op != OAS {
+ Fatal("convas: not OAS %v", Oconv(int(n.Op), 0))
+ }
+
+ n.Typecheck = 1
+
+ if n.Left == nil || n.Right == nil {
+ goto out
+ }
+
+ lt = n.Left.Type
+ rt = n.Right.Type
+ if lt == nil || rt == nil {
+ goto out
+ }
+
+ if isblank(n.Left) {
+ defaultlit(&n.Right, nil)
+ goto out
+ }
+
+ if n.Left.Op == OINDEXMAP {
+ map_ = n.Left.Left
+ key = n.Left.Right
+ val = n.Right
+ walkexpr(&map_, init)
+ walkexpr(&key, init)
+ walkexpr(&val, init)
+
+ // orderexpr made sure key and val are addressable.
+ key = Nod(OADDR, key, nil)
+
+ val = Nod(OADDR, val, nil)
+ n = mkcall1(mapfn("mapassign1", map_.Type), nil, init, typename(map_.Type), map_, key, val)
+ goto out
+ }
+
+ if !Eqtype(lt, rt) {
+ n.Right = assignconv(n.Right, lt, "assignment")
+ walkexpr(&n.Right, init)
+ }
+
+out:
+ ullmancalc(n)
+ return n
+}
+
+/*
+ * from ascompat[te]
+ * evaluating actual function arguments.
+ * f(a,b)
+ * if there is exactly one function expr,
+ * then it is done first. otherwise must
+ * make temp variables
+ */
+func reorder1(all *NodeList) *NodeList {
+ var f *Node
+ var a *Node
+ var n *Node
+ var l *NodeList
+ var r *NodeList
+ var g *NodeList
+ var c int
+ var d int
+ var t int
+
+ c = 0 // function calls
+ t = 0 // total parameters
+
+ for l = all; l != nil; l = l.Next {
+ n = l.N
+ t++
+ ullmancalc(n)
+ if n.Ullman >= UINF {
+ c++
+ }
+ }
+
+ if c == 0 || t == 1 {
+ return all
+ }
+
+ g = nil // fncalls assigned to tempnames
+ f = nil // last fncall assigned to stack
+ r = nil // non fncalls and tempnames assigned to stack
+ d = 0
+ for l = all; l != nil; l = l.Next {
+ n = l.N
+ if n.Ullman < UINF {
+ r = list(r, n)
+ continue
+ }
+
+ d++
+ if d == c {
+ f = n
+ continue
+ }
+
+ // make assignment of fncall to tempname
+ a = temp(n.Right.Type)
+
+ a = Nod(OAS, a, n.Right)
+ g = list(g, a)
+
+ // put normal arg assignment on list
+ // with fncall replaced by tempname
+ n.Right = a.Left
+
+ r = list(r, n)
+ }
+
+ if f != nil {
+ g = list(g, f)
+ }
+ return concat(g, r)
+}
+
+/*
+ * from ascompat[ee]
+ * a,b = c,d
+ * simultaneous assignment. there cannot
+ * be later use of an earlier lvalue.
+ *
+ * function calls have been removed.
+ */
+func reorder3(all *NodeList) *NodeList {
+ var list *NodeList
+ var early *NodeList
+ var mapinit *NodeList
+ var l *Node
+
+ // If a needed expression may be affected by an
+ // earlier assignment, make an early copy of that
+ // expression and use the copy instead.
+ early = nil
+
+ mapinit = nil
+ for list = all; list != nil; list = list.Next {
+ l = list.N.Left
+
+ // Save subexpressions needed on left side.
+ // Drill through non-dereferences.
+ for {
+ if l.Op == ODOT || l.Op == OPAREN {
+ l = l.Left
+ continue
+ }
+
+ if l.Op == OINDEX && Isfixedarray(l.Left.Type) != 0 {
+ reorder3save(&l.Right, all, list, &early)
+ l = l.Left
+ continue
+ }
+
+ break
+ }
+
+ switch l.Op {
+ default:
+ Fatal("reorder3 unexpected lvalue %v", Oconv(int(l.Op), obj.FmtSharp))
+ fallthrough
+
+ case ONAME:
+ break
+
+ case OINDEX,
+ OINDEXMAP:
+ reorder3save(&l.Left, all, list, &early)
+ reorder3save(&l.Right, all, list, &early)
+ if l.Op == OINDEXMAP {
+ list.N = convas(list.N, &mapinit)
+ }
+
+ case OIND,
+ ODOTPTR:
+ reorder3save(&l.Left, all, list, &early)
+ }
+
+ // Save expression on right side.
+ reorder3save(&list.N.Right, all, list, &early)
+ }
+
+ early = concat(mapinit, early)
+ return concat(early, all)
+}
+
+/*
+ * if the evaluation of *np would be affected by the
+ * assignments in all up to but not including stop,
+ * copy into a temporary during *early and
+ * replace *np with that temp.
+ */
+func reorder3save(np **Node, all *NodeList, stop *NodeList, early **NodeList) {
+ var n *Node
+ var q *Node
+
+ n = *np
+ if !(aliased(n, all, stop) != 0) {
+ return
+ }
+
+ q = temp(n.Type)
+ q = Nod(OAS, q, n)
+ typecheck(&q, Etop)
+ *early = list(*early, q)
+ *np = q.Left
+}
+
+/*
+ * what's the outer value that a write to n affects?
+ * outer value means containing struct or array.
+ */
+func outervalue(n *Node) *Node {
+ for {
+ if n.Op == OXDOT {
+ Fatal("OXDOT in walk")
+ }
+ if n.Op == ODOT || n.Op == OPAREN || n.Op == OCONVNOP {
+ n = n.Left
+ continue
+ }
+
+ if n.Op == OINDEX && Isfixedarray(n.Left.Type) != 0 {
+ n = n.Left
+ continue
+ }
+
+ break
+ }
+
+ return n
+}
+
+/*
+ * Is it possible that the computation of n might be
+ * affected by writes in as up to but not including stop?
+ */
+func aliased(n *Node, all *NodeList, stop *NodeList) int {
+ var memwrite int
+ var varwrite int
+ var a *Node
+ var l *NodeList
+
+ if n == nil {
+ return 0
+ }
+
+ // Look for obvious aliasing: a variable being assigned
+ // during the all list and appearing in n.
+ // Also record whether there are any writes to main memory.
+ // Also record whether there are any writes to variables
+ // whose addresses have been taken.
+ memwrite = 0
+
+ varwrite = 0
+ for l = all; l != stop; l = l.Next {
+ a = outervalue(l.N.Left)
+ if a.Op != ONAME {
+ memwrite = 1
+ continue
+ }
+
+ switch n.Class {
+ default:
+ varwrite = 1
+ continue
+
+ case PAUTO,
+ PPARAM,
+ PPARAMOUT:
+ if n.Addrtaken != 0 {
+ varwrite = 1
+ continue
+ }
+
+ if vmatch2(a, n) != 0 {
+ // Direct hit.
+ return 1
+ }
+ }
+ }
+
+ // The variables being written do not appear in n.
+ // However, n might refer to computed addresses
+ // that are being written.
+
+ // If no computed addresses are affected by the writes, no aliasing.
+ if !(memwrite != 0) && !(varwrite != 0) {
+ return 0
+ }
+
+ // If n does not refer to computed addresses
+ // (that is, if n only refers to variables whose addresses
+ // have not been taken), no aliasing.
+ if varexpr(n) != 0 {
+ return 0
+ }
+
+ // Otherwise, both the writes and n refer to computed memory addresses.
+ // Assume that they might conflict.
+ return 1
+}
+
+/*
+ * does the evaluation of n only refer to variables
+ * whose addresses have not been taken?
+ * (and no other memory)
+ */
+func varexpr(n *Node) int {
+ if n == nil {
+ return 1
+ }
+
+ switch n.Op {
+ case OLITERAL:
+ return 1
+
+ case ONAME:
+ switch n.Class {
+ case PAUTO,
+ PPARAM,
+ PPARAMOUT:
+ if !(n.Addrtaken != 0) {
+ return 1
+ }
+ }
+
+ return 0
+
+ case OADD,
+ OSUB,
+ OOR,
+ OXOR,
+ OMUL,
+ ODIV,
+ OMOD,
+ OLSH,
+ ORSH,
+ OAND,
+ OANDNOT,
+ OPLUS,
+ OMINUS,
+ OCOM,
+ OPAREN,
+ OANDAND,
+ OOROR,
+ ODOT, // but not ODOTPTR
+ OCONV,
+ OCONVNOP,
+ OCONVIFACE,
+ ODOTTYPE:
+ return bool2int(varexpr(n.Left) != 0 && varexpr(n.Right) != 0)
+ }
+
+ // Be conservative.
+ return 0
+}
+
+/*
+ * is the name l mentioned in r?
+ */
+func vmatch2(l *Node, r *Node) int {
+ var ll *NodeList
+
+ if r == nil {
+ return 0
+ }
+ switch r.Op {
+ // match each right given left
+ case ONAME:
+ return bool2int(l == r)
+
+ case OLITERAL:
+ return 0
+ }
+
+ if vmatch2(l, r.Left) != 0 {
+ return 1
+ }
+ if vmatch2(l, r.Right) != 0 {
+ return 1
+ }
+ for ll = r.List; ll != nil; ll = ll.Next {
+ if vmatch2(l, ll.N) != 0 {
+ return 1
+ }
+ }
+ return 0
+}
+
+/*
+ * is any name mentioned in l also mentioned in r?
+ * called by sinit.c
+ */
+func vmatch1(l *Node, r *Node) int {
+ var ll *NodeList
+
+ /*
+ * isolate all left sides
+ */
+ if l == nil || r == nil {
+ return 0
+ }
+ switch l.Op {
+ case ONAME:
+ switch l.Class {
+ case PPARAM,
+ PPARAMREF,
+ PAUTO:
+ break
+
+ // assignment to non-stack variable
+ // must be delayed if right has function calls.
+ default:
+ if r.Ullman >= UINF {
+ return 1
+ }
+ }
+
+ return vmatch2(l, r)
+
+ case OLITERAL:
+ return 0
+ }
+
+ if vmatch1(l.Left, r) != 0 {
+ return 1
+ }
+ if vmatch1(l.Right, r) != 0 {
+ return 1
+ }
+ for ll = l.List; ll != nil; ll = ll.Next {
+ if vmatch1(ll.N, r) != 0 {
+ return 1
+ }
+ }
+ return 0
+}
+
+/*
+ * walk through argin parameters.
+ * generate and return code to allocate
+ * copies of escaped parameters to the heap.
+ */
+func paramstoheap(argin **Type, out int) *NodeList {
+ var t *Type
+ var savet Iter
+ var v *Node
+ var as *Node
+ var nn *NodeList
+
+ nn = nil
+ for t = Structfirst(&savet, argin); t != nil; t = structnext(&savet) {
+ v = t.Nname
+ if v != nil && v.Sym != nil && v.Sym.Name[0] == '~' && v.Sym.Name[1] == 'r' { // unnamed result
+ v = nil
+ }
+
+ // For precise stacks, the garbage collector assumes results
+ // are always live, so zero them always.
+ if out != 0 {
+ // 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 = list(nn, Nod(OAS, nodarg(t, 1), nil))
+ }
+
+ if v == nil || !(v.Class&PHEAP != 0) {
+ continue
+ }
+
+ // generate allocation & copying code
+ if compiling_runtime != 0 {
+ Yyerror("%v escapes to heap, not allowed in runtime.", Nconv(v, 0))
+ }
+ if v.Alloc == nil {
+ v.Alloc = callnew(v.Type)
+ }
+ nn = list(nn, Nod(OAS, v.Heapaddr, v.Alloc))
+ if v.Class&^PHEAP != PPARAMOUT {
+ as = Nod(OAS, v, v.Stackparam)
+ v.Stackparam.Typecheck = 1
+ typecheck(&as, Etop)
+ as = applywritebarrier(as, &nn)
+ nn = list(nn, as)
+ }
+ }
+
+ return nn
+}
+
+/*
+ * walk through argout parameters copying back to stack
+ */
+func returnsfromheap(argin **Type) *NodeList {
+ var t *Type
+ var savet Iter
+ var v *Node
+ var nn *NodeList
+
+ nn = nil
+ for t = Structfirst(&savet, argin); t != nil; t = structnext(&savet) {
+ v = t.Nname
+ if v == nil || v.Class != PHEAP|PPARAMOUT {
+ continue
+ }
+ nn = list(nn, Nod(OAS, v.Stackparam, v))
+ }
+
+ return nn
+}
+
+/*
+ * take care of migrating any function in/out args
+ * between the stack and the heap. adds code to
+ * curfn's before and after lists.
+ */
+func heapmoves() {
+ var nn *NodeList
+ var lno int32
+
+ lno = lineno
+ lineno = Curfn.Lineno
+ nn = paramstoheap(getthis(Curfn.Type), 0)
+ nn = concat(nn, paramstoheap(getinarg(Curfn.Type), 0))
+ nn = concat(nn, paramstoheap(Getoutarg(Curfn.Type), 1))
+ Curfn.Enter = concat(Curfn.Enter, nn)
+ lineno = Curfn.Endlineno
+ Curfn.Exit = returnsfromheap(Getoutarg(Curfn.Type))
+ lineno = lno
+}
+
+func vmkcall(fn *Node, t *Type, init **NodeList, va []*Node) *Node {
+ var i int
+ var n int
+ var r *Node
+ var args *NodeList
+
+ if fn.Type == nil || fn.Type.Etype != TFUNC {
+ Fatal("mkcall %v %v", Nconv(fn, 0), Tconv(fn.Type, 0))
+ }
+
+ args = nil
+ n = fn.Type.Intuple
+ for i = 0; i < n; i++ {
+ args = list(args, va[i])
+ }
+
+ r = Nod(OCALL, fn, nil)
+ r.List = args
+ if fn.Type.Outtuple > 0 {
+ typecheck(&r, Erv|Efnstruct)
+ } else {
+ typecheck(&r, Etop)
+ }
+ walkexpr(&r, init)
+ r.Type = t
+ return r
+}
+
+func mkcall(name string, t *Type, init **NodeList, args ...*Node) *Node {
+ return vmkcall(syslook(name, 0), t, init, args)
+}
+
+func mkcall1(fn *Node, t *Type, init **NodeList, args ...*Node) *Node {
+ return vmkcall(fn, t, init, args)
+}
+
+func conv(n *Node, t *Type) *Node {
+ if Eqtype(n.Type, t) {
+ return n
+ }
+ n = Nod(OCONV, n, nil)
+ n.Type = t
+ typecheck(&n, Erv)
+ return n
+}
+
+func chanfn(name string, n int, t *Type) *Node {
+ var fn *Node
+ var i int
+
+ if t.Etype != TCHAN {
+ Fatal("chanfn %v", Tconv(t, 0))
+ }
+ fn = syslook(name, 1)
+ for i = 0; i < n; i++ {
+ argtype(fn, t.Type)
+ }
+ return fn
+}
+
+func mapfn(name string, t *Type) *Node {
+ var fn *Node
+
+ if t.Etype != TMAP {
+ Fatal("mapfn %v", Tconv(t, 0))
+ }
+ fn = syslook(name, 1)
+ argtype(fn, t.Down)
+ argtype(fn, t.Type)
+ argtype(fn, t.Down)
+ argtype(fn, t.Type)
+ return fn
+}
+
+func mapfndel(name string, t *Type) *Node {
+ var fn *Node
+
+ if t.Etype != TMAP {
+ Fatal("mapfn %v", Tconv(t, 0))
+ }
+ fn = syslook(name, 1)
+ argtype(fn, t.Down)
+ argtype(fn, t.Type)
+ argtype(fn, t.Down)
+ return fn
+}
+
+func writebarrierfn(name string, l *Type, r *Type) *Node {
+ var fn *Node
+
+ fn = syslook(name, 1)
+ argtype(fn, l)
+ argtype(fn, r)
+ return fn
+}
+
+func addstr(n *Node, init **NodeList) *Node {
+ var r *Node
+ var cat *Node
+ var slice *Node
+ var buf *Node
+ var args *NodeList
+ var l *NodeList
+ var c int
+ var sz int64
+ var t *Type
+
+ // orderexpr rewrote OADDSTR to have a list of strings.
+ c = count(n.List)
+
+ if c < 2 {
+ Yyerror("addstr count %d too small", c)
+ }
+
+ buf = nodnil()
+ if n.Esc == EscNone {
+ sz = 0
+ for l = n.List; l != nil; l = l.Next {
+ if n.Op == OLITERAL {
+ sz += int64(len(n.Val.U.Sval.S))
+ }
+ }
+
+ // Don't allocate the buffer if the result won't fit.
+ if sz < tmpstringbufsize {
+ // Create temporary buffer for result string on stack.
+ t = aindex(Nodintconst(tmpstringbufsize), Types[TUINT8])
+
+ buf = Nod(OADDR, temp(t), nil)
+ }
+ }
+
+ // build list of string arguments
+ args = list1(buf)
+
+ for l = n.List; l != nil; l = l.Next {
+ args = list(args, conv(l.N, Types[TSTRING]))
+ }
+
+ if c <= 5 {
+ // small numbers of strings use direct runtime helpers.
+ // note: orderexpr knows this cutoff too.
+ namebuf = fmt.Sprintf("concatstring%d", c)
+ } else {
+ // large numbers of strings are passed to the runtime as a slice.
+ namebuf = "concatstrings"
+
+ t = typ(TARRAY)
+ t.Type = Types[TSTRING]
+ t.Bound = -1
+ slice = Nod(OCOMPLIT, nil, typenod(t))
+ slice.Alloc = n.Alloc
+ slice.List = args.Next // skip buf arg
+ args = list1(buf)
+ args = list(args, slice)
+ slice.Esc = EscNone
+ }
+
+ cat = syslook(namebuf, 1)
+ r = Nod(OCALL, cat, nil)
+ r.List = args
+ typecheck(&r, Erv)
+ walkexpr(&r, init)
+ r.Type = n.Type
+
+ return r
+}
+
+// expand append(l1, l2...) to
+// init {
+// s := l1
+// if n := len(l1) + len(l2) - cap(s); n > 0 {
+// s = growslice(s, n)
+// }
+// s = s[:len(l1)+len(l2)]
+// memmove(&s[len(l1)], &l2[0], len(l2)*sizeof(T))
+// }
+// s
+//
+// l2 is allowed to be a string.
+func appendslice(n *Node, init **NodeList) *Node {
+ var l *NodeList
+ var l1 *Node
+ var l2 *Node
+ var nt *Node
+ var nif *Node
+ var fn *Node
+ var nptr1 *Node
+ var nptr2 *Node
+ var nwid *Node
+ var s *Node
+
+ walkexprlistsafe(n.List, init)
+
+ // walkexprlistsafe will leave OINDEX (s[n]) alone if both s
+ // and n are name or literal, but those may index the slice we're
+ // modifying here. Fix explicitly.
+ for l = n.List; l != nil; l = l.Next {
+ l.N = cheapexpr(l.N, init)
+ }
+
+ l1 = n.List.N
+ l2 = n.List.Next.N
+
+ s = temp(l1.Type) // var s []T
+ l = nil
+ l = list(l, Nod(OAS, s, l1)) // s = l1
+
+ nt = temp(Types[TINT])
+
+ nif = Nod(OIF, nil, nil)
+
+ // n := len(s) + len(l2) - cap(s)
+ nif.Ninit = list1(Nod(OAS, nt, Nod(OSUB, Nod(OADD, Nod(OLEN, s, nil), Nod(OLEN, l2, nil)), Nod(OCAP, s, nil))))
+
+ nif.Ntest = Nod(OGT, nt, Nodintconst(0))
+
+ // instantiate growslice(Type*, []any, int64) []any
+ fn = syslook("growslice", 1)
+
+ argtype(fn, s.Type.Type)
+ argtype(fn, s.Type.Type)
+
+ // s = growslice(T, s, n)
+ nif.Nbody = list1(Nod(OAS, s, mkcall1(fn, s.Type, &nif.Ninit, typename(s.Type), s, conv(nt, Types[TINT64]))))
+
+ l = list(l, nif)
+
+ if haspointers(l1.Type.Type) {
+ // copy(s[len(l1):len(l1)+len(l2)], l2)
+ nptr1 = Nod(OSLICE, s, Nod(OKEY, Nod(OLEN, l1, nil), Nod(OADD, Nod(OLEN, l1, nil), Nod(OLEN, l2, nil))))
+
+ nptr1.Etype = 1
+ nptr2 = l2
+ fn = syslook("typedslicecopy", 1)
+ argtype(fn, l1.Type)
+ argtype(fn, l2.Type)
+ nt = mkcall1(fn, Types[TINT], &l, typename(l1.Type.Type), nptr1, nptr2)
+ l = list(l, nt)
+ } else if flag_race != 0 {
+ // rely on runtime to instrument copy.
+ // copy(s[len(l1):len(l1)+len(l2)], l2)
+ nptr1 = Nod(OSLICE, s, Nod(OKEY, Nod(OLEN, l1, nil), Nod(OADD, Nod(OLEN, l1, nil), Nod(OLEN, l2, nil))))
+
+ nptr1.Etype = 1
+ nptr2 = l2
+ if l2.Type.Etype == TSTRING {
+ fn = syslook("slicestringcopy", 1)
+ } else {
+ fn = syslook("slicecopy", 1)
+ }
+ argtype(fn, l1.Type)
+ argtype(fn, l2.Type)
+ nt = mkcall1(fn, Types[TINT], &l, nptr1, nptr2, Nodintconst(s.Type.Type.Width))
+ l = list(l, nt)
+ } else {
+ // memmove(&s[len(l1)], &l2[0], len(l2)*sizeof(T))
+ nptr1 = Nod(OINDEX, s, Nod(OLEN, l1, nil))
+
+ nptr1.Bounded = 1
+ nptr1 = Nod(OADDR, nptr1, nil)
+
+ nptr2 = Nod(OSPTR, l2, nil)
+
+ fn = syslook("memmove", 1)
+ argtype(fn, s.Type.Type) // 1 old []any
+ argtype(fn, s.Type.Type) // 2 ret []any
+
+ nwid = cheapexpr(conv(Nod(OLEN, l2, nil), Types[TUINTPTR]), &l)
+
+ nwid = Nod(OMUL, nwid, Nodintconst(s.Type.Type.Width))
+ nt = mkcall1(fn, nil, &l, nptr1, nptr2, nwid)
+ l = list(l, nt)
+ }
+
+ // s = s[:len(l1)+len(l2)]
+ nt = Nod(OADD, Nod(OLEN, l1, nil), Nod(OLEN, l2, nil))
+
+ nt = Nod(OSLICE, s, Nod(OKEY, nil, nt))
+ nt.Etype = 1
+ l = list(l, Nod(OAS, s, nt))
+
+ typechecklist(l, Etop)
+ walkstmtlist(l)
+ *init = concat(*init, l)
+ return s
+}
+
+// expand append(src, a [, b]* ) to
+//
+// init {
+// s := src
+// const argc = len(args) - 1
+// if cap(s) - len(s) < argc {
+// s = growslice(s, argc)
+// }
+// n := len(s)
+// s = s[:n+argc]
+// s[n] = a
+// s[n+1] = b
+// ...
+// }
+// s
+func walkappend(n *Node, init **NodeList) *Node {
+ var l *NodeList
+ var a *NodeList
+ var nsrc *Node
+ var ns *Node
+ var nn *Node
+ var na *Node
+ var nx *Node
+ var fn *Node
+ var argc int
+
+ walkexprlistsafe(n.List, init)
+
+ // walkexprlistsafe will leave OINDEX (s[n]) alone if both s
+ // and n are name or literal, but those may index the slice we're
+ // modifying here. Fix explicitly.
+ for l = n.List; l != nil; l = l.Next {
+ l.N = cheapexpr(l.N, init)
+ }
+
+ nsrc = n.List.N
+
+ // Resolve slice type of multi-valued return.
+ if Istype(nsrc.Type, TSTRUCT) != 0 {
+ nsrc.Type = nsrc.Type.Type.Type
+ }
+ argc = count(n.List) - 1
+ if argc < 1 {
+ return nsrc
+ }
+
+ l = nil
+
+ ns = temp(nsrc.Type)
+ l = list(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.Ntest = Nod(OLT, Nod(OSUB, Nod(OCAP, ns, nil), Nod(OLEN, ns, nil)), na)
+
+ fn = syslook("growslice", 1) // growslice(<type>, old []T, n int64) (ret []T)
+ argtype(fn, ns.Type.Type) // 1 old []any
+ argtype(fn, ns.Type.Type) // 2 ret []any
+
+ nx.Nbody = list1(Nod(OAS, ns, mkcall1(fn, ns.Type, &nx.Ninit, typename(ns.Type), ns, conv(na, Types[TINT64]))))
+
+ l = list(l, nx)
+
+ nn = temp(Types[TINT])
+ l = list(l, Nod(OAS, nn, Nod(OLEN, ns, nil))) // n = len(s)
+
+ nx = Nod(OSLICE, ns, Nod(OKEY, nil, Nod(OADD, nn, na))) // ...s[:n+argc]
+ nx.Etype = 1
+ l = list(l, Nod(OAS, ns, nx)) // s = s[:n+argc]
+
+ for a = n.List.Next; a != nil; a = a.Next {
+ nx = Nod(OINDEX, ns, nn) // s[n] ...
+ nx.Bounded = 1
+ l = list(l, Nod(OAS, nx, a.N)) // s[n] = arg
+ if a.Next != nil {
+ l = list(l, Nod(OAS, nn, Nod(OADD, nn, Nodintconst(1)))) // n = n + 1
+ }
+ }
+
+ typechecklist(l, Etop)
+ walkstmtlist(l)
+ *init = concat(*init, l)
+ return ns
+}
+
+// Lower copy(a, b) to a memmove call or a runtime call.
+//
+// init {
+// n := len(a)
+// if n > len(b) { n = len(b) }
+// memmove(a.ptr, b.ptr, n*sizeof(elem(a)))
+// }
+// n;
+//
+// Also works if b is a string.
+//
+func copyany(n *Node, init **NodeList, runtimecall int) *Node {
+ var nl *Node
+ var nr *Node
+ var nfrm *Node
+ var nto *Node
+ var nif *Node
+ var nlen *Node
+ var nwid *Node
+ var fn *Node
+ var l *NodeList
+
+ if haspointers(n.Left.Type.Type) {
+ fn = writebarrierfn("typedslicecopy", n.Left.Type, n.Right.Type)
+ return mkcall1(fn, n.Type, init, typename(n.Left.Type.Type), n.Left, n.Right)
+ }
+
+ if runtimecall != 0 {
+ if n.Right.Type.Etype == TSTRING {
+ fn = syslook("slicestringcopy", 1)
+ } else {
+ fn = syslook("slicecopy", 1)
+ }
+ argtype(fn, n.Left.Type)
+ argtype(fn, n.Right.Type)
+ return mkcall1(fn, n.Type, init, n.Left, n.Right, Nodintconst(n.Left.Type.Type.Width))
+ }
+
+ walkexpr(&n.Left, init)
+ walkexpr(&n.Right, init)
+ nl = temp(n.Left.Type)
+ nr = temp(n.Right.Type)
+ l = nil
+ l = list(l, Nod(OAS, nl, n.Left))
+ l = list(l, Nod(OAS, nr, n.Right))
+
+ nfrm = Nod(OSPTR, nr, nil)
+ nto = Nod(OSPTR, nl, nil)
+
+ nlen = temp(Types[TINT])
+
+ // n = len(to)
+ l = list(l, Nod(OAS, nlen, Nod(OLEN, nl, nil)))
+
+ // if n > len(frm) { n = len(frm) }
+ nif = Nod(OIF, nil, nil)
+
+ nif.Ntest = Nod(OGT, nlen, Nod(OLEN, nr, nil))
+ nif.Nbody = list(nif.Nbody, Nod(OAS, nlen, Nod(OLEN, nr, nil)))
+ l = list(l, nif)
+
+ // Call memmove.
+ fn = syslook("memmove", 1)
+
+ argtype(fn, nl.Type.Type)
+ argtype(fn, nl.Type.Type)
+ nwid = temp(Types[TUINTPTR])
+ l = list(l, Nod(OAS, nwid, conv(nlen, Types[TUINTPTR])))
+ nwid = Nod(OMUL, nwid, Nodintconst(nl.Type.Type.Width))
+ l = list(l, mkcall1(fn, nil, init, nto, nfrm, nwid))
+
+ typechecklist(l, Etop)
+ walkstmtlist(l)
+ *init = concat(*init, l)
+ return nlen
+}
+
+// Generate frontend part for OSLICE[3][ARR|STR]
+//
+func sliceany(n *Node, init **NodeList) *Node {
+ var bounded int
+ var slice3 int
+ var src *Node
+ var lb *Node
+ var hb *Node
+ var cb *Node
+ var bound *Node
+ var chk *Node
+ var chk0 *Node
+ var chk1 *Node
+ var chk2 *Node
+ var lbv int64
+ var hbv int64
+ var cbv int64
+ var bv int64
+ var w int64
+ var bt *Type
+
+ // print("before sliceany: %+N\n", n);
+
+ src = n.Left
+
+ lb = n.Right.Left
+ slice3 = bool2int(n.Op == OSLICE3 || n.Op == OSLICE3ARR)
+ if slice3 != 0 {
+ hb = n.Right.Right.Left
+ cb = n.Right.Right.Right
+ } else {
+ hb = n.Right.Right
+ cb = nil
+ }
+
+ bounded = int(n.Etype)
+
+ if n.Op == OSLICESTR {
+ bound = Nod(OLEN, src, nil)
+ } else {
+ bound = Nod(OCAP, src, nil)
+ }
+
+ typecheck(&bound, Erv)
+ walkexpr(&bound, init) // if src is an array, bound will be a const now.
+
+ // static checks if possible
+ bv = 1 << 50
+
+ if Isconst(bound, CTINT) != 0 {
+ if !(Smallintconst(bound) != 0) {
+ Yyerror("array len too large")
+ } else {
+ bv = Mpgetfix(bound.Val.U.Xval)
+ }
+ }
+
+ if Isconst(cb, CTINT) != 0 {
+ cbv = Mpgetfix(cb.Val.U.Xval)
+ if cbv < 0 || cbv > bv {
+ Yyerror("slice index out of bounds")
+ }
+ }
+
+ if Isconst(hb, CTINT) != 0 {
+ hbv = Mpgetfix(hb.Val.U.Xval)
+ if hbv < 0 || hbv > bv {
+ Yyerror("slice index out of bounds")
+ }
+ }
+
+ if Isconst(lb, CTINT) != 0 {
+ lbv = Mpgetfix(lb.Val.U.Xval)
+ if lbv < 0 || lbv > bv {
+ Yyerror("slice index out of bounds")
+ lbv = -1
+ }
+
+ if lbv == 0 {
+ lb = nil
+ }
+ }
+
+ // Checking src[lb:hb:cb] or src[lb:hb].
+ // if chk0 || chk1 || chk2 { panicslice() }
+ chk = nil
+
+ chk0 = nil // cap(src) < cb
+ chk1 = nil // cb < hb for src[lb:hb:cb]; cap(src) < hb for src[lb:hb]
+ chk2 = nil // hb < lb
+
+ // All comparisons are unsigned to avoid testing < 0.
+ bt = Types[Simtype[TUINT]]
+
+ if cb != nil && cb.Type.Width > 4 {
+ bt = Types[TUINT64]
+ }
+ if hb != nil && hb.Type.Width > 4 {
+ bt = Types[TUINT64]
+ }
+ if lb != nil && lb.Type.Width > 4 {
+ bt = Types[TUINT64]
+ }
+
+ bound = cheapexpr(conv(bound, bt), init)
+
+ if cb != nil {
+ cb = cheapexpr(conv(cb, bt), init)
+ if !(bounded != 0) {
+ chk0 = Nod(OLT, bound, cb)
+ }
+ } else if slice3 != 0 {
+ // When we figure out what this means, implement it.
+ Fatal("slice3 with cb == N") // rejected by parser
+ }
+
+ if hb != nil {
+ hb = cheapexpr(conv(hb, bt), init)
+ if !(bounded != 0) {
+ if cb != nil {
+ chk1 = Nod(OLT, cb, hb)
+ } else {
+ chk1 = Nod(OLT, bound, hb)
+ }
+ }
+ } else if slice3 != 0 {
+ // When we figure out what this means, implement it.
+ Fatal("slice3 with hb == N") // rejected by parser
+ } else if n.Op == OSLICEARR {
+ hb = bound
+ } else {
+ hb = Nod(OLEN, src, nil)
+ typecheck(&hb, Erv)
+ walkexpr(&hb, init)
+ hb = cheapexpr(conv(hb, bt), init)
+ }
+
+ if lb != nil {
+ lb = cheapexpr(conv(lb, bt), init)
+ if !(bounded != 0) {
+ chk2 = Nod(OLT, hb, lb)
+ }
+ }
+
+ if chk0 != nil || chk1 != nil || chk2 != nil {
+ chk = Nod(OIF, nil, nil)
+ chk.Nbody = list1(mkcall("panicslice", nil, init))
+ chk.Likely = -1
+ if chk0 != nil {
+ chk.Ntest = chk0
+ }
+ if chk1 != nil {
+ if chk.Ntest == nil {
+ chk.Ntest = chk1
+ } else {
+ chk.Ntest = Nod(OOROR, chk.Ntest, chk1)
+ }
+ }
+
+ if chk2 != nil {
+ if chk.Ntest == nil {
+ chk.Ntest = chk2
+ } else {
+ chk.Ntest = Nod(OOROR, chk.Ntest, chk2)
+ }
+ }
+
+ typecheck(&chk, Etop)
+ walkstmt(&chk)
+ *init = concat(*init, chk.Ninit)
+ chk.Ninit = nil
+ *init = list(*init, chk)
+ }
+
+ // prepare new cap, len and offs for backend cgen_slice
+ // cap = bound [ - lo ]
+ n.Right = nil
+
+ n.List = nil
+ if !(slice3 != 0) {
+ cb = bound
+ }
+ if lb == nil {
+ bound = conv(cb, Types[Simtype[TUINT]])
+ } else {
+ bound = Nod(OSUB, conv(cb, Types[Simtype[TUINT]]), conv(lb, Types[Simtype[TUINT]]))
+ }
+ typecheck(&bound, Erv)
+ walkexpr(&bound, init)
+ n.List = list(n.List, bound)
+
+ // len = hi [ - lo]
+ if lb == nil {
+ hb = conv(hb, Types[Simtype[TUINT]])
+ } else {
+ hb = Nod(OSUB, conv(hb, Types[Simtype[TUINT]]), conv(lb, Types[Simtype[TUINT]]))
+ }
+ typecheck(&hb, Erv)
+ walkexpr(&hb, init)
+ n.List = list(n.List, hb)
+
+ // offs = [width *] lo, but omit if zero
+ if lb != nil {
+ if n.Op == OSLICESTR {
+ w = 1
+ } else {
+ w = n.Type.Type.Width
+ }
+ lb = conv(lb, Types[TUINTPTR])
+ if w > 1 {
+ lb = Nod(OMUL, Nodintconst(w), lb)
+ }
+ typecheck(&lb, Erv)
+ walkexpr(&lb, init)
+ n.List = list(n.List, lb)
+ }
+
+ // print("after sliceany: %+N\n", n);
+
+ return n
+}
+
+func eqfor(t *Type, needsize *int) *Node {
+ var a int
+ var n *Node
+ var ntype *Node
+ var sym *Sym
+
+ // Should only arrive here with large memory or
+ // a struct/array containing a non-memory field/element.
+ // Small memory is handled inline, and single non-memory
+ // is handled during type check (OCMPSTR etc).
+ a = algtype1(t, nil)
+
+ if a != AMEM && a != -1 {
+ Fatal("eqfor %v", Tconv(t, 0))
+ }
+
+ if a == AMEM {
+ n = syslook("memequal", 1)
+ argtype(n, t)
+ argtype(n, t)
+ *needsize = 1
+ return n
+ }
+
+ sym = typesymprefix(".eq", t)
+ n = newname(sym)
+ n.Class = PFUNC
+ ntype = Nod(OTFUNC, nil, nil)
+ ntype.List = list(ntype.List, Nod(ODCLFIELD, nil, typenod(Ptrto(t))))
+ ntype.List = list(ntype.List, Nod(ODCLFIELD, nil, typenod(Ptrto(t))))
+ ntype.Rlist = list(ntype.Rlist, Nod(ODCLFIELD, nil, typenod(Types[TBOOL])))
+ typecheck(&ntype, Etype)
+ n.Type = ntype.Type
+ *needsize = 0
+ return n
+}
+
+func countfield(t *Type) int {
+ var t1 *Type
+ var n int
+
+ n = 0
+ for t1 = t.Type; t1 != nil; t1 = t1.Down {
+ n++
+ }
+ return n
+}
+
+func walkcompare(np **Node, init **NodeList) {
+ var n *Node
+ var l *Node
+ var r *Node
+ var call *Node
+ var a *Node
+ var li *Node
+ var ri *Node
+ var expr *Node
+ var cmpl *Node
+ var cmpr *Node
+ var x *Node
+ var ok *Node
+ var andor int
+ var i int
+ var needsize int
+ var t *Type
+ var t1 *Type
+
+ n = *np
+
+ // Given interface value l and concrete value r, rewrite
+ // l == r
+ // to
+ // x, ok := l.(type(r)); ok && x == r
+ // Handle != similarly.
+ // This avoids the allocation that would be required
+ // to convert r to l for comparison.
+ l = nil
+
+ r = nil
+ if Isinter(n.Left.Type) != 0 && !(Isinter(n.Right.Type) != 0) {
+ l = n.Left
+ r = n.Right
+ } else if !(Isinter(n.Left.Type) != 0) && Isinter(n.Right.Type) != 0 {
+ l = n.Right
+ r = n.Left
+ }
+
+ if l != nil {
+ x = temp(r.Type)
+ ok = temp(Types[TBOOL])
+
+ // l.(type(r))
+ a = Nod(ODOTTYPE, l, nil)
+
+ a.Type = r.Type
+
+ // x, ok := l.(type(r))
+ expr = Nod(OAS2, nil, nil)
+
+ expr.List = list1(x)
+ expr.List = list(expr.List, ok)
+ expr.Rlist = list1(a)
+ typecheck(&expr, Etop)
+ walkexpr(&expr, init)
+
+ if n.Op == OEQ {
+ r = Nod(OANDAND, ok, Nod(OEQ, x, r))
+ } else {
+ r = Nod(OOROR, Nod(ONOT, ok, nil), Nod(ONE, x, r))
+ }
+ *init = list(*init, expr)
+ goto ret
+ }
+
+ // Must be comparison of array or struct.
+ // Otherwise back end handles it.
+ t = n.Left.Type
+
+ switch t.Etype {
+ default:
+ return
+
+ case TARRAY:
+ if Isslice(t) != 0 {
+ return
+ }
+
+ case TSTRUCT:
+ break
+ }
+
+ cmpl = n.Left
+ for cmpl != nil && cmpl.Op == OCONVNOP {
+ cmpl = cmpl.Left
+ }
+ cmpr = n.Right
+ for cmpr != nil && cmpr.Op == OCONVNOP {
+ cmpr = cmpr.Left
+ }
+
+ if !(islvalue(cmpl) != 0) || !(islvalue(cmpr) != 0) {
+ Fatal("arguments of comparison must be lvalues - %v %v", Nconv(cmpl, 0), Nconv(cmpr, 0))
+ }
+
+ l = temp(Ptrto(t))
+ a = Nod(OAS, l, Nod(OADDR, cmpl, nil))
+ a.Right.Etype = 1 // addr does not escape
+ typecheck(&a, Etop)
+ *init = list(*init, a)
+
+ r = temp(Ptrto(t))
+ a = Nod(OAS, r, Nod(OADDR, cmpr, nil))
+ a.Right.Etype = 1 // addr does not escape
+ typecheck(&a, Etop)
+ *init = list(*init, a)
+
+ expr = nil
+ andor = OANDAND
+ if n.Op == ONE {
+ andor = OOROR
+ }
+
+ if t.Etype == TARRAY && t.Bound <= 4 && issimple[t.Type.Etype] != 0 {
+ // Four or fewer elements of a basic type.
+ // Unroll comparisons.
+ for i = 0; int64(i) < t.Bound; i++ {
+ li = Nod(OINDEX, l, Nodintconst(int64(i)))
+ ri = Nod(OINDEX, r, Nodintconst(int64(i)))
+ a = Nod(int(n.Op), li, ri)
+ if expr == nil {
+ expr = a
+ } else {
+ expr = Nod(andor, expr, a)
+ }
+ }
+
+ if expr == nil {
+ expr = Nodbool(bool2int(n.Op == OEQ))
+ }
+ r = expr
+ goto ret
+ }
+
+ if t.Etype == TSTRUCT && countfield(t) <= 4 {
+ // Struct of four or fewer fields.
+ // Inline comparisons.
+ for t1 = t.Type; t1 != nil; t1 = t1.Down {
+ if isblanksym(t1.Sym) {
+ continue
+ }
+ li = Nod(OXDOT, l, newname(t1.Sym))
+ ri = Nod(OXDOT, r, newname(t1.Sym))
+ a = Nod(int(n.Op), li, ri)
+ if expr == nil {
+ expr = a
+ } else {
+ expr = Nod(andor, expr, a)
+ }
+ }
+
+ if expr == nil {
+ expr = Nodbool(bool2int(n.Op == OEQ))
+ }
+ r = expr
+ goto ret
+ }
+
+ // Chose not to inline. Call equality function directly.
+ call = Nod(OCALL, eqfor(t, &needsize), nil)
+
+ call.List = list(call.List, l)
+ call.List = list(call.List, r)
+ if needsize != 0 {
+ call.List = list(call.List, Nodintconst(t.Width))
+ }
+ r = call
+ if n.Op != OEQ {
+ r = Nod(ONOT, r, nil)
+ }
+ goto ret
+
+ret:
+ typecheck(&r, Erv)
+ walkexpr(&r, init)
+ if r.Type != n.Type {
+ r = Nod(OCONVNOP, r, nil)
+ r.Type = n.Type
+ r.Typecheck = 1
+ }
+
+ *np = r
+ return
+}
+
+func samecheap(a *Node, b *Node) int {
+ var ar *Node
+ var br *Node
+ for a != nil && b != nil && a.Op == b.Op {
+ switch a.Op {
+ default:
+ return 0
+
+ case ONAME:
+ return bool2int(a == b)
+
+ case ODOT,
+ ODOTPTR:
+ ar = a.Right
+ br = b.Right
+ if ar.Op != ONAME || br.Op != ONAME || ar.Sym != br.Sym {
+ return 0
+ }
+
+ case OINDEX:
+ ar = a.Right
+ br = b.Right
+ if !(Isconst(ar, CTINT) != 0) || !(Isconst(br, CTINT) != 0) || Mpcmpfixfix(ar.Val.U.Xval, br.Val.U.Xval) != 0 {
+ return 0
+ }
+ }
+
+ a = a.Left
+ b = b.Left
+ }
+
+ return 0
+}
+
+func walkrotate(np **Node) {
+ var w int
+ var sl int
+ var sr int
+ var s int
+ var l *Node
+ var r *Node
+ var n *Node
+
+ if Thearch.Thechar == '9' {
+ return
+ }
+
+ n = *np
+
+ // Want << | >> or >> | << or << ^ >> or >> ^ << on unsigned value.
+ l = n.Left
+
+ r = n.Right
+ if (n.Op != OOR && n.Op != OXOR) || (l.Op != OLSH && l.Op != ORSH) || (r.Op != OLSH && r.Op != ORSH) || n.Type == nil || Issigned[n.Type.Etype] != 0 || l.Op == r.Op {
+ return
+ }
+
+ // Want same, side effect-free expression on lhs of both shifts.
+ if !(samecheap(l.Left, r.Left) != 0) {
+ return
+ }
+
+ // Constants adding to width?
+ w = int(l.Type.Width * 8)
+
+ if Smallintconst(l.Right) != 0 && Smallintconst(r.Right) != 0 {
+ sl = int(Mpgetfix(l.Right.Val.U.Xval))
+ if sl >= 0 {
+ sr = int(Mpgetfix(r.Right.Val.U.Xval))
+ if sr >= 0 && sl+sr == w {
+ goto yes
+ }
+ }
+ return
+ }
+
+ // TODO: Could allow s and 32-s if s is bounded (maybe s&31 and 32-s&31).
+ return
+
+ // Rewrite left shift half to left rotate.
+yes:
+ if l.Op == OLSH {
+ n = l
+ } else {
+ n = r
+ }
+ n.Op = OLROT
+
+ // Remove rotate 0 and rotate w.
+ s = int(Mpgetfix(n.Right.Val.U.Xval))
+
+ if s == 0 || s == w {
+ n = n.Left
+ }
+
+ *np = n
+ return
+}
+
+/*
+ * walkmul rewrites integer multiplication by powers of two as shifts.
+ */
+func walkmul(np **Node, init **NodeList) {
+ var n *Node
+ var nl *Node
+ var nr *Node
+ var pow int
+ var neg int
+ var w int
+
+ n = *np
+ if !(Isint[n.Type.Etype] != 0) {
+ return
+ }
+
+ if n.Right.Op == OLITERAL {
+ nl = n.Left
+ nr = n.Right
+ } else if n.Left.Op == OLITERAL {
+ nl = n.Right
+ nr = n.Left
+ } else {
+ return
+ }
+
+ neg = 0
+
+ // x*0 is 0 (and side effects of x).
+ if Mpgetfix(nr.Val.U.Xval) == 0 {
+ cheapexpr(nl, init)
+ Nodconst(n, n.Type, 0)
+ goto ret
+ }
+
+ // nr is a constant.
+ pow = powtwo(nr)
+
+ if pow < 0 {
+ return
+ }
+ if pow >= 1000 {
+ // negative power of 2, like -16
+ neg = 1
+
+ pow -= 1000
+ }
+
+ w = int(nl.Type.Width * 8)
+ if pow+1 >= w { // too big, shouldn't happen
+ return
+ }
+
+ nl = cheapexpr(nl, init)
+
+ if pow == 0 {
+ // x*1 is x
+ n = nl
+
+ goto ret
+ }
+
+ n = Nod(OLSH, nl, Nodintconst(int64(pow)))
+
+ret:
+ if neg != 0 {
+ n = Nod(OMINUS, n, nil)
+ }
+
+ typecheck(&n, Erv)
+ walkexpr(&n, init)
+ *np = n
+}
+
+/*
+ * walkdiv rewrites division by a constant as less expensive
+ * operations.
+ */
+func walkdiv(np **Node, init **NodeList) {
+ var n *Node
+ var nl *Node
+ var nr *Node
+ // if >= 0, nr is 1<<pow // 1 if nr is negative.
+ var nc *Node
+ var n1 *Node
+ var n2 *Node
+ var n3 *Node
+ var n4 *Node
+ var pow int
+ var s int
+ var w int
+ var twide *Type
+ var m Magic
+
+ // TODO(minux)
+ if Thearch.Thechar == '9' {
+ return
+ }
+
+ n = *np
+ if n.Right.Op != OLITERAL {
+ return
+ }
+
+ // nr is a constant.
+ nl = cheapexpr(n.Left, init)
+
+ nr = n.Right
+
+ // special cases of mod/div
+ // by a constant
+ w = int(nl.Type.Width * 8)
+
+ s = 0
+ pow = powtwo(nr)
+ if pow >= 1000 {
+ // negative power of 2
+ s = 1
+
+ pow -= 1000
+ }
+
+ if pow+1 >= w {
+ // divisor too large.
+ return
+ }
+
+ if pow < 0 {
+ goto divbymul
+ }
+
+ switch pow {
+ case 0:
+ if n.Op == OMOD {
+ // nl % 1 is zero.
+ Nodconst(n, n.Type, 0)
+ } else if s != 0 {
+ // divide by -1
+ n.Op = OMINUS
+
+ n.Right = nil
+ } else {
+ // divide by 1
+ n = nl
+ }
+
+ default:
+ if Issigned[n.Type.Etype] != 0 {
+ if n.Op == OMOD {
+ // signed modulo 2^pow is like ANDing
+ // with the last pow bits, but if nl < 0,
+ // nl & (2^pow-1) is (nl+1)%2^pow - 1.
+ nc = Nod(OXXX, nil, nil)
+
+ Nodconst(nc, Types[Simtype[TUINT]], int64(w)-1)
+ n1 = Nod(ORSH, nl, nc) // n1 = -1 iff nl < 0.
+ if pow == 1 {
+ typecheck(&n1, Erv)
+ n1 = cheapexpr(n1, init)
+
+ // n = (nl+ε)&1 -ε where ε=1 iff nl<0.
+ n2 = Nod(OSUB, nl, n1)
+
+ nc = Nod(OXXX, nil, nil)
+ Nodconst(nc, nl.Type, 1)
+ n3 = Nod(OAND, n2, nc)
+ n = Nod(OADD, n3, n1)
+ } else {
+ // n = (nl+ε)&(nr-1) - ε where ε=2^pow-1 iff nl<0.
+ nc = Nod(OXXX, nil, nil)
+
+ Nodconst(nc, nl.Type, (1<<uint(pow))-1)
+ n2 = Nod(OAND, n1, nc) // n2 = 2^pow-1 iff nl<0.
+ typecheck(&n2, Erv)
+ n2 = cheapexpr(n2, init)
+
+ n3 = Nod(OADD, nl, n2)
+ n4 = Nod(OAND, n3, nc)
+ n = Nod(OSUB, n4, n2)
+ }
+
+ break
+ } else {
+ // arithmetic right shift does not give the correct rounding.
+ // if nl >= 0, nl >> n == nl / nr
+ // if nl < 0, we want to add 2^n-1 first.
+ nc = Nod(OXXX, nil, nil)
+
+ Nodconst(nc, Types[Simtype[TUINT]], int64(w)-1)
+ n1 = Nod(ORSH, nl, nc) // n1 = -1 iff nl < 0.
+ if pow == 1 {
+ // nl+1 is nl-(-1)
+ n.Left = Nod(OSUB, nl, n1)
+ } else {
+ // Do a logical right right on -1 to keep pow bits.
+ nc = Nod(OXXX, nil, nil)
+
+ Nodconst(nc, Types[Simtype[TUINT]], int64(w)-int64(pow))
+ n2 = Nod(ORSH, conv(n1, tounsigned(nl.Type)), nc)
+ n.Left = Nod(OADD, nl, conv(n2, nl.Type))
+ }
+
+ // n = (nl + 2^pow-1) >> pow
+ n.Op = ORSH
+
+ nc = Nod(OXXX, nil, nil)
+ Nodconst(nc, Types[Simtype[TUINT]], int64(pow))
+ n.Right = nc
+ n.Typecheck = 0
+ }
+
+ if s != 0 {
+ n = Nod(OMINUS, n, nil)
+ }
+ break
+ }
+
+ nc = Nod(OXXX, nil, nil)
+ if n.Op == OMOD {
+ // n = nl & (nr-1)
+ n.Op = OAND
+
+ Nodconst(nc, nl.Type, Mpgetfix(nr.Val.U.Xval)-1)
+ } else {
+ // n = nl >> pow
+ n.Op = ORSH
+
+ Nodconst(nc, Types[Simtype[TUINT]], int64(pow))
+ }
+
+ n.Typecheck = 0
+ n.Right = nc
+ }
+
+ goto ret
+
+ // try to do division by multiply by (2^w)/d
+ // see hacker's delight chapter 10
+ // TODO: support 64-bit magic multiply here.
+divbymul:
+ m.W = w
+
+ if Issigned[nl.Type.Etype] != 0 {
+ m.Sd = Mpgetfix(nr.Val.U.Xval)
+ Smagic(&m)
+ } else {
+ m.Ud = uint64(Mpgetfix(nr.Val.U.Xval))
+ Umagic(&m)
+ }
+
+ if m.Bad != 0 {
+ return
+ }
+
+ // We have a quick division method so use it
+ // for modulo too.
+ if n.Op == OMOD {
+ goto longmod
+ }
+
+ switch Simtype[nl.Type.Etype] {
+ default:
+ return
+
+ // n1 = nl * magic >> w (HMUL)
+ case TUINT8,
+ TUINT16,
+ TUINT32:
+ nc = Nod(OXXX, nil, nil)
+
+ Nodconst(nc, nl.Type, int64(m.Um))
+ n1 = Nod(OMUL, nl, nc)
+ typecheck(&n1, Erv)
+ n1.Op = OHMUL
+ if m.Ua != 0 {
+ // Select a Go type with (at least) twice the width.
+ switch Simtype[nl.Type.Etype] {
+ default:
+ return
+
+ case TUINT8,
+ TUINT16:
+ twide = Types[TUINT32]
+
+ case TUINT32:
+ twide = Types[TUINT64]
+
+ case TINT8,
+ TINT16:
+ twide = Types[TINT32]
+
+ case TINT32:
+ twide = Types[TINT64]
+ }
+
+ // add numerator (might overflow).
+ // n2 = (n1 + nl)
+ n2 = Nod(OADD, conv(n1, twide), conv(nl, twide))
+
+ // shift by m.s
+ nc = Nod(OXXX, nil, nil)
+
+ Nodconst(nc, Types[TUINT], int64(m.S))
+ n = conv(Nod(ORSH, n2, nc), nl.Type)
+ } else {
+ // n = n1 >> m.s
+ nc = Nod(OXXX, nil, nil)
+
+ Nodconst(nc, Types[TUINT], int64(m.S))
+ n = Nod(ORSH, n1, nc)
+ }
+
+ // n1 = nl * magic >> w
+ case TINT8,
+ TINT16,
+ TINT32:
+ nc = Nod(OXXX, nil, nil)
+
+ Nodconst(nc, nl.Type, m.Sm)
+ n1 = Nod(OMUL, nl, nc)
+ typecheck(&n1, Erv)
+ n1.Op = OHMUL
+ if m.Sm < 0 {
+ // add the numerator.
+ n1 = Nod(OADD, n1, nl)
+ }
+
+ // shift by m.s
+ nc = Nod(OXXX, nil, nil)
+
+ Nodconst(nc, Types[TUINT], int64(m.S))
+ n2 = conv(Nod(ORSH, n1, nc), nl.Type)
+
+ // add 1 iff n1 is negative.
+ nc = Nod(OXXX, nil, nil)
+
+ Nodconst(nc, Types[TUINT], int64(w)-1)
+ n3 = Nod(ORSH, nl, nc) // n4 = -1 iff n1 is negative.
+ n = Nod(OSUB, n2, n3)
+
+ // apply sign.
+ if m.Sd < 0 {
+ n = Nod(OMINUS, n, nil)
+ }
+ }
+
+ goto ret
+
+ // rewrite as A%B = A - (A/B*B).
+longmod:
+ n1 = Nod(ODIV, nl, nr)
+
+ n2 = Nod(OMUL, n1, nr)
+ n = Nod(OSUB, nl, n2)
+ goto ret
+
+ret:
+ typecheck(&n, Erv)
+ walkexpr(&n, init)
+ *np = n
+}
+
+// return 1 if integer n must be in range [0, max), 0 otherwise
+func bounded(n *Node, max int64) int {
+ var v int64
+ var bits int32
+ var sign int
+
+ if n.Type == nil || !(Isint[n.Type.Etype] != 0) {
+ return 0
+ }
+
+ sign = int(Issigned[n.Type.Etype])
+ bits = int32(8 * n.Type.Width)
+
+ if Smallintconst(n) != 0 {
+ v = Mpgetfix(n.Val.U.Xval)
+ return bool2int(0 <= v && v < max)
+ }
+
+ switch n.Op {
+ case OAND:
+ v = -1
+ if Smallintconst(n.Left) != 0 {
+ v = Mpgetfix(n.Left.Val.U.Xval)
+ } else if Smallintconst(n.Right) != 0 {
+ v = Mpgetfix(n.Right.Val.U.Xval)
+ }
+
+ if 0 <= v && v < max {
+ return 1
+ }
+
+ case OMOD:
+ if !(sign != 0) && Smallintconst(n.Right) != 0 {
+ v = Mpgetfix(n.Right.Val.U.Xval)
+ if 0 <= v && v <= max {
+ return 1
+ }
+ }
+
+ case ODIV:
+ if !(sign != 0) && Smallintconst(n.Right) != 0 {
+ v = Mpgetfix(n.Right.Val.U.Xval)
+ for bits > 0 && v >= 2 {
+ bits--
+ v >>= 1
+ }
+ }
+
+ case ORSH:
+ if !(sign != 0) && Smallintconst(n.Right) != 0 {
+ v = Mpgetfix(n.Right.Val.U.Xval)
+ if v > int64(bits) {
+ return 1
+ }
+ bits -= int32(v)
+ }
+ }
+
+ if !(sign != 0) && bits <= 62 && 1<<uint(bits) <= max {
+ return 1
+ }
+
+ return 0
+}
+
+func usefield(n *Node) {
+ var field *Type
+ var l *Type
+
+ if !(obj.Fieldtrack_enabled != 0) {
+ return
+ }
+
+ switch n.Op {
+ default:
+ Fatal("usefield %v", Oconv(int(n.Op), 0))
+ fallthrough
+
+ case ODOT,
+ ODOTPTR:
+ break
+ }
+
+ field = n.Paramfld
+ if field == nil {
+ Fatal("usefield %v %v without paramfld", Tconv(n.Left.Type, 0), Sconv(n.Right.Sym, 0))
+ }
+ if field.Note == nil || !strings.Contains(field.Note.S, "go:\"track\"") {
+ return
+ }
+
+ // dedup on list
+ if field.Lastfn == Curfn {
+ return
+ }
+ field.Lastfn = Curfn
+ field.Outer = n.Left.Type
+ if Isptr[field.Outer.Etype] != 0 {
+ field.Outer = field.Outer.Type
+ }
+ if field.Outer.Sym == nil {
+ Yyerror("tracked field must be in named struct type")
+ }
+ if !exportname(field.Sym.Name) {
+ Yyerror("tracked field must be exported (upper case)")
+ }
+
+ l = typ(0)
+ l.Type = field
+ l.Down = Curfn.Paramfld
+ Curfn.Paramfld = l
+}
+
+func candiscardlist(l *NodeList) int {
+ for ; l != nil; l = l.Next {
+ if !(candiscard(l.N) != 0) {
+ return 0
+ }
+ }
+ return 1
+}
+
+func candiscard(n *Node) int {
+ if n == nil {
+ return 1
+ }
+
+ switch n.Op {
+ default:
+ return 0
+
+ // Discardable as long as the subpieces are.
+ case ONAME,
+ ONONAME,
+ OTYPE,
+ OPACK,
+ OLITERAL,
+ OADD,
+ OSUB,
+ OOR,
+ OXOR,
+ OADDSTR,
+ OADDR,
+ OANDAND,
+ OARRAYBYTESTR,
+ OARRAYRUNESTR,
+ OSTRARRAYBYTE,
+ OSTRARRAYRUNE,
+ OCAP,
+ OCMPIFACE,
+ OCMPSTR,
+ OCOMPLIT,
+ OMAPLIT,
+ OSTRUCTLIT,
+ OARRAYLIT,
+ OPTRLIT,
+ OCONV,
+ OCONVIFACE,
+ OCONVNOP,
+ ODOT,
+ OEQ,
+ ONE,
+ OLT,
+ OLE,
+ OGT,
+ OGE,
+ OKEY,
+ OLEN,
+ OMUL,
+ OLSH,
+ ORSH,
+ OAND,
+ OANDNOT,
+ ONEW,
+ ONOT,
+ OCOM,
+ OPLUS,
+ OMINUS,
+ OOROR,
+ OPAREN,
+ ORUNESTR,
+ OREAL,
+ OIMAG,
+ OCOMPLEX:
+ break
+
+ // Discardable as long as we know it's not division by zero.
+ case ODIV,
+ OMOD:
+ if Isconst(n.Right, CTINT) != 0 && mpcmpfixc(n.Right.Val.U.Xval, 0) != 0 {
+ break
+ }
+ if Isconst(n.Right, CTFLT) != 0 && mpcmpfltc(n.Right.Val.U.Fval, 0) != 0 {
+ break
+ }
+ return 0
+
+ // Discardable as long as we know it won't fail because of a bad size.
+ case OMAKECHAN,
+ OMAKEMAP:
+ if Isconst(n.Left, CTINT) != 0 && mpcmpfixc(n.Left.Val.U.Xval, 0) == 0 {
+ break
+ }
+ return 0
+
+ // Difficult to tell what sizes are okay.
+ case OMAKESLICE:
+ return 0
+ }
+
+ if !(candiscard(n.Left) != 0) || !(candiscard(n.Right) != 0) || !(candiscard(n.Ntest) != 0) || !(candiscard(n.Nincr) != 0) || !(candiscardlist(n.Ninit) != 0) || !(candiscardlist(n.Nbody) != 0) || !(candiscardlist(n.Nelse) != 0) || !(candiscardlist(n.List) != 0) || !(candiscardlist(n.Rlist) != 0) {
+ return 0
+ }
+
+ return 1
+}
+
+// rewrite
+// print(x, y, z)
+// into
+// func(a1, a2, a3) {
+// print(a1, a2, a3)
+// }(x, y, z)
+// and same for println.
+
+var walkprintfunc_prgen int
+
+func walkprintfunc(np **Node, init **NodeList) {
+ var n *Node
+ var a *Node
+ var fn *Node
+ var t *Node
+ var oldfn *Node
+ var l *NodeList
+ var printargs *NodeList
+ var num int
+ var buf string
+
+ n = *np
+
+ if n.Ninit != nil {
+ walkstmtlist(n.Ninit)
+ *init = concat(*init, n.Ninit)
+ n.Ninit = nil
+ }
+
+ t = Nod(OTFUNC, nil, nil)
+ num = 0
+ printargs = nil
+ for l = n.List; l != nil; l = l.Next {
+ buf = fmt.Sprintf("a%d", num)
+ num++
+ a = Nod(ODCLFIELD, newname(Lookup(buf)), typenod(l.N.Type))
+ t.List = list(t.List, a)
+ printargs = list(printargs, a.Left)
+ }
+
+ fn = Nod(ODCLFUNC, nil, nil)
+ walkprintfunc_prgen++
+ buf = fmt.Sprintf("print·%d", walkprintfunc_prgen)
+ fn.Nname = newname(Lookup(buf))
+ fn.Nname.Defn = fn
+ fn.Nname.Ntype = t
+ declare(fn.Nname, PFUNC)
+
+ oldfn = Curfn
+ Curfn = nil
+ funchdr(fn)
+
+ a = Nod(int(n.Op), nil, nil)
+ a.List = printargs
+ typecheck(&a, Etop)
+ walkstmt(&a)
+
+ fn.Nbody = list1(a)
+
+ funcbody(fn)
+
+ typecheck(&fn, Etop)
+ typechecklist(fn.Nbody, Etop)
+ xtop = list(xtop, fn)
+ Curfn = oldfn
+
+ a = Nod(OCALL, nil, nil)
+ a.Left = fn.Nname
+ a.List = n.List
+ typecheck(&a, Etop)
+ walkexpr(&a, init)
+ *np = a
+}
diff --git a/src/cmd/internal/gc/y.go b/src/cmd/internal/gc/y.go
new file mode 100644
index 0000000..0e9157c
--- /dev/null
+++ b/src/cmd/internal/gc/y.go
@@ -0,0 +1,3524 @@
+//line go.y:21
+package gc
+
+import __yyfmt__ "fmt"
+
+//line go.y:21
+import (
+ "strings"
+)
+
+//line go.y:27
+type yySymType struct {
+ yys int
+ node *Node
+ list *NodeList
+ typ *Type
+ sym *Sym
+ val Val
+ i int
+}
+
+const LLITERAL = 57346
+const LASOP = 57347
+const LCOLAS = 57348
+const LBREAK = 57349
+const LCASE = 57350
+const LCHAN = 57351
+const LCONST = 57352
+const LCONTINUE = 57353
+const LDDD = 57354
+const LDEFAULT = 57355
+const LDEFER = 57356
+const LELSE = 57357
+const LFALL = 57358
+const LFOR = 57359
+const LFUNC = 57360
+const LGO = 57361
+const LGOTO = 57362
+const LIF = 57363
+const LIMPORT = 57364
+const LINTERFACE = 57365
+const LMAP = 57366
+const LNAME = 57367
+const LPACKAGE = 57368
+const LRANGE = 57369
+const LRETURN = 57370
+const LSELECT = 57371
+const LSTRUCT = 57372
+const LSWITCH = 57373
+const LTYPE = 57374
+const LVAR = 57375
+const LANDAND = 57376
+const LANDNOT = 57377
+const LBODY = 57378
+const LCOMM = 57379
+const LDEC = 57380
+const LEQ = 57381
+const LGE = 57382
+const LGT = 57383
+const LIGNORE = 57384
+const LINC = 57385
+const LLE = 57386
+const LLSH = 57387
+const LLT = 57388
+const LNE = 57389
+const LOROR = 57390
+const LRSH = 57391
+const NotPackage = 57392
+const NotParen = 57393
+const PreferToRightParen = 57394
+
+var yyToknames = []string{
+ "LLITERAL",
+ "LASOP",
+ "LCOLAS",
+ "LBREAK",
+ "LCASE",
+ "LCHAN",
+ "LCONST",
+ "LCONTINUE",
+ "LDDD",
+ "LDEFAULT",
+ "LDEFER",
+ "LELSE",
+ "LFALL",
+ "LFOR",
+ "LFUNC",
+ "LGO",
+ "LGOTO",
+ "LIF",
+ "LIMPORT",
+ "LINTERFACE",
+ "LMAP",
+ "LNAME",
+ "LPACKAGE",
+ "LRANGE",
+ "LRETURN",
+ "LSELECT",
+ "LSTRUCT",
+ "LSWITCH",
+ "LTYPE",
+ "LVAR",
+ "LANDAND",
+ "LANDNOT",
+ "LBODY",
+ "LCOMM",
+ "LDEC",
+ "LEQ",
+ "LGE",
+ "LGT",
+ "LIGNORE",
+ "LINC",
+ "LLE",
+ "LLSH",
+ "LLT",
+ "LNE",
+ "LOROR",
+ "LRSH",
+ "'+'",
+ "'-'",
+ "'|'",
+ "'^'",
+ "'*'",
+ "'/'",
+ "'%'",
+ "'&'",
+ "NotPackage",
+ "NotParen",
+ "'('",
+ "')'",
+ "PreferToRightParen",
+}
+var yyStatenames = []string{}
+
+const yyEofCode = 1
+const yyErrCode = 2
+const yyMaxDepth = 200
+
+//line go.y:2242
+func fixlbrace(lbr int) {
+ // If the opening brace was an LBODY,
+ // set up for another one now that we're done.
+ // See comment in lex.C about loophack.
+ if lbr == LBODY {
+ loophack = 1
+ }
+}
+
+//line yacctab:1
+var yyExca = []int{
+ -1, 1,
+ 1, -1,
+ -2, 0,
+ -1, 17,
+ 1, 1,
+ 63, 23,
+ -2, 0,
+ -1, 48,
+ 6, 276,
+ 66, 276,
+ 76, 276,
+ -2, 49,
+ -1, 56,
+ 67, 153,
+ -2, 162,
+ -1, 74,
+ 60, 181,
+ -2, 215,
+ -1, 75,
+ 60, 182,
+ -2, 183,
+ -1, 121,
+ 60, 134,
+ 64, 134,
+ 68, 134,
+ 72, 134,
+ -2, 266,
+ -1, 125,
+ 60, 134,
+ 64, 134,
+ 68, 134,
+ 72, 134,
+ -2, 267,
+ -1, 176,
+ 2, 215,
+ 36, 215,
+ 60, 181,
+ 68, 215,
+ -2, 173,
+ -1, 177,
+ 36, 183,
+ 60, 182,
+ 68, 183,
+ -2, 174,
+ -1, 184,
+ 63, 251,
+ 69, 251,
+ -2, 0,
+ -1, 242,
+ 63, 251,
+ 69, 251,
+ -2, 0,
+ -1, 252,
+ 8, 251,
+ 13, 251,
+ 63, 251,
+ 69, 251,
+ -2, 0,
+ -1, 325,
+ 4, 236,
+ 63, 236,
+ 69, 236,
+ -2, 157,
+ -1, 407,
+ 36, 176,
+ 60, 176,
+ 68, 176,
+ -2, 167,
+ -1, 408,
+ 36, 177,
+ 60, 177,
+ 68, 177,
+ -2, 168,
+ -1, 409,
+ 36, 178,
+ 60, 178,
+ 68, 178,
+ -2, 169,
+ -1, 410,
+ 36, 179,
+ 60, 179,
+ 68, 179,
+ -2, 170,
+ -1, 416,
+ 8, 251,
+ 13, 251,
+ 63, 251,
+ 69, 251,
+ -2, 0,
+ -1, 417,
+ 63, 251,
+ 69, 251,
+ -2, 0,
+ -1, 497,
+ 63, 251,
+ 69, 251,
+ -2, 0,
+ -1, 552,
+ 60, 157,
+ -2, 318,
+ -1, 553,
+ 60, 158,
+ -2, 317,
+ -1, 578,
+ 8, 251,
+ 13, 251,
+ 63, 251,
+ 69, 251,
+ -2, 0,
+ -1, 592,
+ 36, 180,
+ 60, 180,
+ 68, 180,
+ -2, 171,
+}
+
+const yyNprod = 352
+const yyPrivate = 57344
+
+var yyTokenNames []string
+var yyStates []string
+
+const yyLast = 2282
+
+var yyAct = []int{
+
+ 74, 381, 304, 285, 291, 486, 610, 398, 545, 478,
+ 549, 296, 186, 75, 400, 229, 302, 401, 103, 389,
+ 458, 356, 290, 318, 457, 34, 303, 338, 230, 245,
+ 466, 109, 339, 101, 337, 332, 85, 104, 374, 248,
+ 246, 174, 467, 286, 14, 324, 479, 328, 241, 212,
+ 108, 6, 325, 155, 243, 469, 226, 181, 468, 516,
+ 413, 320, 373, 392, 325, 219, 13, 208, 176, 10,
+ 11, 584, 172, 469, 651, 385, 599, 583, 106, 191,
+ 13, 177, 460, 541, 422, 160, 310, 331, 613, 161,
+ 309, 446, 192, 322, 193, 626, 327, 162, 198, 321,
+ 88, 12, 13, 10, 227, 238, 662, 194, 317, 227,
+ 632, 448, 227, 12, 13, 227, 209, 228, 12, 13,
+ 447, 10, 228, 203, 175, 228, 108, 393, 228, 461,
+ 54, 660, 205, 445, 184, 384, 222, 460, 459, 204,
+ 199, 200, 239, 88, 506, 155, 214, 216, 218, 507,
+ 427, 631, 12, 13, 233, 625, 624, 202, 10, 88,
+ 90, 176, 55, 288, 10, 627, 213, 213, 213, 213,
+ 12, 13, 118, 118, 177, 295, 126, 154, 308, 176,
+ 10, 416, 282, 282, 461, 282, 603, 620, 416, 10,
+ 600, 227, 177, 301, 593, 416, 227, 227, 404, 227,
+ 280, 484, 444, 90, 228, 622, 536, 12, 13, 228,
+ 228, 506, 228, 12, 13, 86, 507, 175, 527, 90,
+ 298, 163, 164, 165, 166, 167, 168, 169, 170, 12,
+ 13, 523, 227, 580, 515, 175, 182, 153, 12, 13,
+ 242, 171, 325, 397, 416, 228, 330, 155, 227, 334,
+ 415, 227, 227, 116, 227, 185, 358, 367, 463, 371,
+ 360, 228, 355, 362, 228, 228, 353, 228, 183, 365,
+ 210, 322, 504, 369, 434, 314, 68, 321, 91, 379,
+ 614, 78, 416, 340, 609, 340, 340, 376, 375, 182,
+ 124, 12, 13, 604, 176, 83, 79, 10, 394, 325,
+ 407, 336, 82, 351, 352, 10, 378, 177, 380, 414,
+ 227, 227, 601, 408, 574, 409, 608, 10, 568, 558,
+ 227, 183, 48, 228, 228, 465, 10, 464, 410, 391,
+ 323, 329, 67, 228, 331, 348, 443, 656, 442, 412,
+ 293, 163, 170, 605, 77, 436, 12, 13, 12, 13,
+ 175, 424, 423, 234, 12, 13, 388, 383, 370, 366,
+ 359, 114, 435, 333, 655, 227, 12, 13, 100, 129,
+ 441, 99, 10, 490, 227, 12, 13, 439, 228, 84,
+ 454, 20, 453, 429, 432, 480, 491, 228, 492, 654,
+ 173, 10, 508, 473, 176, 10, 653, 645, 511, 619,
+ 188, 493, 483, 494, 616, 607, 227, 177, 221, 282,
+ 514, 606, 227, 597, 282, 519, 520, 340, 340, 228,
+ 596, 12, 13, 227, 595, 228, 110, 498, 340, 489,
+ 107, 510, 502, 592, 525, 449, 228, 582, 517, 227,
+ 12, 13, 562, 524, 12, 13, 470, 539, 528, 531,
+ 175, 522, 228, 254, 513, 512, 255, 256, 257, 258,
+ 259, 260, 261, 262, 263, 264, 265, 266, 267, 268,
+ 269, 270, 271, 272, 273, 274, 129, 129, 277, 554,
+ 559, 227, 330, 173, 537, 294, 509, 557, 561, 227,
+ 69, 564, 532, 538, 228, 534, 490, 490, 496, 495,
+ 482, 572, 228, 300, 476, 475, 472, 176, 440, 491,
+ 491, 492, 492, 567, 573, 340, 10, 340, 420, 553,
+ 177, 577, 372, 340, 493, 493, 340, 590, 591, 579,
+ 297, 585, 570, 540, 586, 542, 456, 551, 431, 438,
+ 249, 555, 340, 571, 556, 354, 253, 129, 251, 180,
+ 431, 102, 489, 489, 382, 323, 501, 530, 287, 129,
+ 566, 117, 7, 175, 70, 12, 13, 329, 5, 197,
+ 431, 227, 211, 433, 24, 16, 529, 19, 617, 430,
+ 650, 455, 364, 533, 228, 428, 560, 480, 305, 335,
+ 207, 206, 21, 93, 197, 623, 252, 629, 490, 197,
+ 282, 630, 197, 635, 120, 197, 26, 386, 121, 125,
+ 637, 491, 340, 492, 641, 639, 173, 340, 621, 402,
+ 57, 565, 306, 76, 402, 618, 493, 158, 176, 642,
+ 598, 387, 511, 340, 157, 602, 640, 665, 652, 581,
+ 28, 177, 390, 643, 223, 644, 490, 159, 156, 235,
+ 96, 657, 240, 661, 489, 497, 578, 417, 98, 491,
+ 663, 492, 94, 664, 122, 122, 31, 22, 667, 666,
+ 340, 15, 97, 95, 493, 553, 23, 201, 340, 49,
+ 18, 197, 594, 129, 175, 3, 197, 197, 636, 197,
+ 129, 282, 8, 551, 4, 2, 1, 450, 215, 543,
+ 544, 547, 489, 548, 611, 92, 487, 129, 129, 189,
+ 80, 81, 437, 72, 71, 237, 173, 615, 477, 316,
+ 188, 220, 197, 326, 340, 244, 128, 340, 648, 628,
+ 649, 311, 127, 17, 399, 319, 312, 313, 197, 315,
+ 25, 197, 197, 27, 197, 36, 633, 634, 78, 37,
+ 281, 66, 111, 638, 39, 38, 35, 124, 279, 278,
+ 73, 217, 83, 79, 10, 113, 587, 149, 503, 82,
+ 505, 87, 363, 0, 123, 0, 232, 150, 0, 0,
+ 9, 151, 141, 142, 143, 144, 145, 146, 147, 148,
+ 197, 377, 56, 196, 89, 0, 0, 0, 0, 231,
+ 197, 197, 0, 0, 0, 105, 105, 112, 115, 0,
+ 197, 77, 0, 12, 13, 426, 119, 119, 0, 0,
+ 119, 0, 575, 576, 0, 0, 0, 0, 0, 173,
+ 0, 0, 0, 275, 276, 0, 283, 0, 0, 402,
+ 406, 588, 402, 402, 0, 0, 0, 0, 0, 0,
+ 418, 419, 0, 0, 0, 197, 0, 0, 78, 0,
+ 425, 89, 0, 197, 197, 0, 0, 124, 0, 0,
+ 0, 0, 83, 79, 10, 0, 0, 105, 149, 82,
+ 0, 0, 105, 0, 0, 112, 232, 0, 150, 247,
+ 0, 0, 151, 0, 0, 0, 197, 145, 146, 147,
+ 148, 0, 197, 196, 361, 406, 0, 188, 0, 231,
+ 0, 0, 0, 197, 0, 236, 368, 78, 0, 0,
+ 250, 77, 0, 12, 13, 225, 124, 0, 0, 197,
+ 0, 83, 79, 10, 0, 0, 292, 0, 82, 0,
+ 0, 0, 0, 0, 0, 232, 311, 0, 646, 647,
+ 173, 0, 521, 402, 0, 0, 0, 0, 0, 56,
+ 0, 0, 196, 526, 0, 0, 0, 0, 231, 0,
+ 0, 197, 0, 0, 119, 119, 0, 0, 0, 197,
+ 77, 0, 12, 13, 0, 0, 197, 197, 0, 0,
+ 0, 0, 134, 149, 357, 152, 0, 135, 139, 140,
+ 105, 0, 138, 150, 137, 136, 133, 151, 141, 142,
+ 143, 144, 145, 146, 147, 148, 0, 56, 0, 0,
+ 0, 569, 0, 0, 0, 0, 247, 56, 247, 0,
+ 68, 0, 0, 0, 413, 78, 0, 0, 0, 78,
+ 474, 0, 0, 0, 124, 0, 0, 481, 124, 83,
+ 79, 10, 0, 83, 79, 10, 82, 0, 0, 0,
+ 82, 197, 0, 65, 275, 276, 0, 232, 0, 0,
+ 0, 0, 0, 0, 0, 0, 60, 61, 0, 64,
+ 58, 0, 0, 59, 196, 0, 67, 0, 197, 421,
+ 488, 0, 0, 0, 403, 0, 62, 63, 77, 0,
+ 12, 13, 77, 0, 12, 13, 0, 68, 89, 0,
+ 0, 0, 78, 0, 0, 0, 0, 0, 0, 0,
+ 0, 124, 0, 347, 0, 462, 83, 79, 10, 357,
+ 0, 0, 349, 82, 105, 0, 197, 345, 343, 341,
+ 65, 105, 0, 0, 344, 112, 0, 485, 247, 0,
+ 0, 348, 0, 60, 61, 0, 64, 58, 0, 0,
+ 59, 0, 0, 67, 0, 0, 0, 78, 346, 0,
+ 0, 589, 0, 62, 63, 77, 124, 12, 13, 0,
+ 350, 83, 79, 10, 0, 0, 342, 0, 82, 13,
+ 0, 56, 56, 0, 0, 232, 0, 0, 0, 119,
+ 0, 119, 0, 0, 0, 0, 0, 0, 0, 535,
+ 0, 119, 196, 247, 0, 0, 0, 0, 231, 0,
+ 0, 0, 546, 550, 0, 0, 0, 0, 0, 0,
+ 77, 357, 12, 13, 462, 0, 0, 0, 462, 0,
+ 0, 0, 0, 563, 357, 0, 0, 0, 0, 0,
+ 0, 0, 307, 0, 68, 0, 0, 41, 0, 78,
+ 47, 42, 0, 247, 44, 0, 40, 50, 124, 43,
+ 45, 53, 56, 83, 79, 10, 0, 0, 46, 52,
+ 82, 51, 32, 30, 0, 0, 0, 65, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 60, 61, 0, 64, 58, 0, 0, 59, 0, 0,
+ 67, 0, 0, 0, 0, 0, 0, 0, 308, 0,
+ 62, 63, 77, 0, 12, 13, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 29, 105, 68, 247, 0, 41, 0, 78,
+ 47, 42, 0, 56, 44, 0, 40, 50, 33, 43,
+ 45, 53, 0, 83, 79, 10, 0, 0, 46, 52,
+ 82, 51, 32, 30, 0, 0, 546, 65, 0, 550,
+ 357, 0, 0, 462, 0, 0, 0, 357, 0, 357,
+ 60, 61, 0, 64, 58, 0, 0, 59, 0, 68,
+ 67, 0, 0, 0, 78, 0, 0, 0, 0, 0,
+ 62, 63, 77, 124, 12, 13, 0, 0, 83, 79,
+ 10, 0, 500, 0, 0, 82, 0, 0, 0, 0,
+ 0, 0, 65, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 60, 61, 0, 64, 58,
+ 0, 0, 59, 0, 68, 67, 0, 0, 0, 78,
+ 0, 0, 0, 0, 0, 62, 63, 77, 124, 12,
+ 13, 0, 0, 83, 79, 10, 0, 499, 0, 0,
+ 82, 0, 0, 0, 0, 0, 0, 65, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 60, 61, 0, 64, 58, 0, 0, 59, 0, 68,
+ 67, 0, 0, 0, 78, 0, 0, 0, 299, 0,
+ 62, 63, 77, 124, 12, 13, 0, 124, 83, 79,
+ 10, 0, 83, 79, 10, 82, 0, 395, 0, 82,
+ 0, 0, 179, 0, 0, 0, 232, 0, 0, 0,
+ 0, 0, 68, 0, 0, 60, 61, 78, 64, 178,
+ 0, 0, 59, 196, 0, 67, 124, 0, 0, 231,
+ 0, 83, 79, 10, 0, 62, 63, 77, 82, 12,
+ 13, 77, 0, 12, 13, 179, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 60, 61,
+ 0, 64, 178, 0, 0, 59, 0, 68, 67, 289,
+ 0, 0, 78, 0, 0, 0, 0, 0, 62, 63,
+ 77, 124, 12, 13, 0, 0, 83, 79, 10, 0,
+ 284, 0, 0, 82, 0, 0, 0, 0, 0, 0,
+ 65, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 68, 0, 0, 60, 61, 78, 64, 58, 187, 0,
+ 59, 0, 0, 67, 124, 0, 0, 0, 0, 83,
+ 79, 10, 0, 62, 63, 77, 82, 12, 13, 0,
+ 0, 0, 0, 65, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 68, 0, 0, 60, 61, 78, 64,
+ 58, 0, 0, 59, 0, 0, 67, 124, 0, 0,
+ 0, 0, 83, 79, 10, 0, 62, 63, 77, 82,
+ 12, 13, 0, 0, 0, 0, 65, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 68, 0, 0, 60,
+ 61, 78, 64, 58, 0, 0, 59, 0, 0, 67,
+ 124, 0, 0, 0, 0, 83, 79, 10, 0, 62,
+ 63, 77, 82, 12, 13, 0, 0, 0, 0, 179,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 60, 61, 0, 64, 178, 0, 0, 59,
+ 0, 0, 67, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 62, 63, 77, 0, 12, 13, 134, 149,
+ 0, 152, 0, 135, 139, 140, 0, 0, 138, 150,
+ 137, 136, 133, 151, 141, 142, 143, 144, 145, 146,
+ 147, 148, 68, 0, 0, 0, 0, 299, 0, 0,
+ 0, 0, 0, 0, 0, 0, 124, 396, 347, 0,
+ 0, 83, 79, 10, 0, 0, 0, 349, 82, 78,
+ 0, 0, 345, 343, 552, 65, 0, 0, 124, 344,
+ 0, 0, 0, 83, 79, 10, 348, 0, 60, 61,
+ 82, 64, 58, 0, 0, 59, 0, 232, 67, 0,
+ 0, 0, 0, 346, 0, 0, 0, 0, 62, 63,
+ 77, 0, 12, 13, 196, 0, 0, 0, 0, 0,
+ 231, 342, 0, 12, 13, 0, 224, 0, 0, 0,
+ 0, 0, 77, 0, 12, 13, 225, 134, 149, 0,
+ 152, 0, 135, 139, 140, 0, 0, 138, 150, 137,
+ 136, 133, 151, 141, 142, 143, 144, 145, 146, 147,
+ 148, 134, 149, 0, 152, 0, 135, 139, 140, 0,
+ 659, 138, 150, 137, 136, 133, 151, 141, 142, 143,
+ 144, 145, 146, 147, 148, 134, 149, 0, 152, 0,
+ 135, 139, 140, 0, 658, 138, 150, 137, 136, 133,
+ 151, 141, 142, 143, 144, 145, 146, 147, 148, 0,
+ 78, 0, 0, 0, 78, 0, 0, 0, 518, 124,
+ 0, 0, 0, 124, 83, 79, 10, 0, 83, 79,
+ 10, 82, 0, 0, 0, 82, 347, 0, 405, 0,
+ 0, 0, 190, 0, 0, 349, 0, 0, 0, 0,
+ 345, 343, 341, 0, 0, 196, 0, 344, 0, 196,
+ 0, 411, 0, 0, 348, 195, 0, 0, 0, 347,
+ 0, 0, 471, 77, 0, 12, 13, 77, 349, 12,
+ 13, 346, 0, 345, 343, 341, 0, 612, 0, 347,
+ 344, 0, 0, 0, 0, 0, 0, 348, 349, 342,
+ 0, 0, 13, 345, 343, 341, 0, 0, 0, 347,
+ 344, 0, 0, 0, 346, 0, 0, 452, 349, 0,
+ 0, 0, 0, 345, 343, 341, 0, 0, 0, 0,
+ 344, 0, 342, 0, 346, 13, 0, 348, 0, 0,
+ 451, 0, 0, 0, 130, 0, 0, 0, 0, 0,
+ 0, 0, 342, 0, 346, 13, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 342, 134, 149, 13, 152, 132, 135, 139,
+ 140, 0, 131, 138, 150, 137, 136, 133, 151, 141,
+ 142, 143, 144, 145, 146, 147, 148, 134, 149, 0,
+ 152, 0, 135, 139, 140, 0, 0, 138, 150, 137,
+ 136, 133, 151, 141, 142, 143, 144, 145, 146, 147,
+ 148, 134, 149, 0, 0, 0, 135, 139, 140, 0,
+ 0, 138, 150, 137, 136, 133, 151, 141, 142, 143,
+ 144, 145, 146, 147, 148, 134, 149, 0, 0, 0,
+ 135, 139, 140, 0, 0, 138, 150, 137, 136, 0,
+ 151, 141, 142, 143, 144, 145, 146, 147, 148, 149,
+ 0, 0, 0, 135, 139, 140, 0, 0, 138, 150,
+ 137, 136, 0, 151, 141, 142, 143, 144, 145, 146,
+ 147, 148,
+}
+var yyPact = []int{
+
+ -1000, -1000, 542, 536, -1000, 164, -1000, 550, 555, 318,
+ -1000, -1000, -1000, 588, -1000, -1000, 549, 1340, 316, 155,
+ -1000, 214, 640, 308, -1000, 305, -1000, -1000, -1000, -1000,
+ 491, 370, 366, 301, -1000, -1000, -1000, -1000, -1000, 186,
+ -1000, 164, 164, 272, 272, 164, 1689, -1000, 2129, 171,
+ -1000, -1000, -1000, -1000, -1000, -1000, -1000, 25, 1689, 1689,
+ 1689, 1689, 1689, 1689, 1689, 1689, 173, 1732, -1000, -1000,
+ -1000, 489, 200, -1000, -1000, -1000, 253, 1646, 1995, 26,
+ -1000, -1000, 200, 200, -1000, -1000, 96, 536, -1000, 587,
+ 586, 42, 205, -1000, 547, -9, -9, -9, 5, -1000,
+ -1000, -1000, 347, 1850, -1000, -1000, -1000, 292, 849, -1000,
+ 44, 1158, -1000, 172, 908, 488, -1000, -1000, -1000, -1000,
+ -1000, -1000, 25, -1000, 486, -1000, -1000, -1000, -23, 2153,
+ 1689, -1000, -1000, 1689, 1689, 1689, 1689, 1689, 1689, 1689,
+ 1689, 1689, 1689, 1689, 1689, 1689, 1689, 1689, 1689, 1689,
+ 1689, 1689, 1689, 1689, 1689, 1689, 1603, 1689, 522, 1689,
+ 1548, 280, 1689, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
+ -1000, -1000, 469, 2153, -1000, -1000, -1000, -1000, 1732, 1828,
+ 1689, -1000, -1000, -1000, 1250, -1000, 17, 13, 2153, -1000,
+ 1158, -1000, -1000, -1000, -1000, 1158, 1158, 211, 1158, 39,
+ 27, 300, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
+ -1000, 585, 2090, -1000, 1114, 2090, -1000, 172, 485, 164,
+ 297, -1000, -1000, 194, 1689, 164, -1000, -1000, -1000, -1000,
+ -1000, 1158, 573, 296, -1000, 191, 1689, 295, -1000, -1000,
+ -1000, -1000, 1250, 461, -14, -1000, -1000, 908, -1000, -1000,
+ 1158, 908, 1250, 908, 2153, 2201, 2224, 732, 732, 732,
+ 732, 732, 732, 843, 843, 843, 843, -1000, -1000, -1000,
+ -1000, -1000, -1000, -1000, 2177, -23, -23, 2153, -1000, 518,
+ 294, -1000, -1000, 69, 1689, -1000, 293, -1000, -1000, -1000,
+ 51, -1000, -1000, 1505, 1774, 176, 1026, 130, -1000, 1991,
+ 958, 1026, 181, -1000, -1000, -1000, -1000, -1000, -1000, 1158,
+ 1158, -1000, 457, -1000, 164, 11, 288, -1000, -1000, 739,
+ 581, 525, 513, -1000, -1000, 210, 282, -1000, -1000, 479,
+ -1000, 545, 447, 139, -1000, 275, 273, -1000, -1000, -1000,
+ -1000, -1000, 129, 19, 52, 43, 2090, 2070, 572, 476,
+ 78, 192, 264, 262, 164, -3, -1000, 2050, 445, 164,
+ 1689, -23, -1000, 444, 1158, 443, 164, 1689, -23, 439,
+ 164, 132, 1030, 908, -1000, -1000, -1000, -1000, 438, -1000,
+ 437, -1000, -1000, 1689, 1450, 1395, 2153, 520, 1689, 203,
+ 518, 425, -16, 1732, 394, 393, -1000, 1689, 165, -17,
+ -1000, -1000, 1941, -1000, -1000, 1509, -1000, -1000, -1000, -1000,
+ -1000, 1158, 390, -1000, 162, -1000, 1250, 1250, -1000, -1000,
+ -1000, -1000, 1158, 149, 217, 581, 164, -1000, -1000, 388,
+ 545, 210, 581, 545, 164, 137, 274, -1000, 908, 386,
+ -1000, -1000, -1000, -1000, 2090, 10, 2090, 164, 1839, -1000,
+ -1000, 298, 2090, -1000, -1000, 2090, 164, 256, -1000, 133,
+ -1000, 582, -1000, 78, -1000, -1000, 381, -21, 164, 164,
+ 581, 2090, -1000, -1000, -23, -1000, -1000, 255, -1000, -1000,
+ 849, -23, -1000, -1000, -1000, 472, -1000, -1000, 908, -1000,
+ -1000, -1000, -1000, -1000, -1000, 1030, 1030, 1250, 251, 1689,
+ 1689, -1000, -1000, -1000, -1000, -1000, 1732, 166, -1000, -1000,
+ 376, -1000, -1000, -1000, 4, -1000, 1026, -1000, 1103, 1026,
+ 1026, 372, -1000, -1000, -1000, 125, -1000, -1000, -1000, -1000,
+ -1000, 581, 363, -1000, 359, -1000, -1000, -1000, 352, -1000,
+ -1000, 2090, 3, 121, 249, -1000, 2090, 117, 230, -1000,
+ 283, -1000, -1000, -1000, 350, -1000, -1000, 344, -1000, 266,
+ -1000, 221, 2017, 220, -1000, -1000, 581, 343, 164, 191,
+ 908, 338, -1000, 118, 1689, 2153, 2153, 136, 1250, 89,
+ -1000, -1000, -1000, -1000, 1689, -1000, -1000, -1000, 2153, -1000,
+ 82, 41, -1000, -1000, -1000, 581, 581, 1030, -1000, 2090,
+ -1000, 164, 581, -1000, 1839, 164, -1000, 2017, 133, -1000,
+ -1000, -1000, 164, -1000, 164, -1000, -1000, -1000, 336, -1000,
+ -1000, -1000, -1000, 219, -1000, 1689, 1689, 1732, 565, 1,
+ 1026, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
+ 335, -1000, 328, 303, 276, 1030, 1917, 1893, -1000, -1000,
+ 110, -1000, 37, 2017, -1000, -1000, 2017, -1000, -1000, -1000,
+ -1000, -1000, -1000, -1000, -1000, 1689, 518, -1000,
+}
+var yyPgo = []int{
+
+ 0, 57, 771, 774, 45, 150, 26, 540, 29, 770,
+ 768, 2, 28, 61, 322, 766, 17, 4, 765, 761,
+ 760, 759, 758, 756, 3, 755, 622, 47, 14, 754,
+ 490, 40, 41, 130, 37, 12, 752, 561, 43, 620,
+ 751, 564, 750, 749, 25, 745, 162, 743, 31, 11,
+ 740, 48, 5, 1, 18, 735, 679, 734, 7, 22,
+ 733, 732, 19, 730, 729, 728, 16, 54, 725, 723,
+ 33, 721, 23, 719, 588, 46, 9, 718, 715, 714,
+ 713, 39, 712, 711, 710, 15, 56, 709, 13, 706,
+ 0, 70, 49, 24, 20, 21, 10, 8, 704, 6,
+ 42, 30, 703, 701, 700, 699, 88, 34, 698, 32,
+ 27, 697, 696, 695, 694, 692, 685, 51, 44, 680,
+ 36, 677, 35, 676, 671, 667, 666, 657, 656, 655,
+ 648, 647, 642, 639, 637, 634, 631, 627, 38, 623,
+ 596, 593,
+}
+var yyR1 = []int{
+
+ 0, 112, 114, 114, 116, 113, 115, 115, 119, 119,
+ 119, 120, 120, 121, 121, 2, 2, 2, 117, 123,
+ 123, 124, 118, 50, 50, 50, 50, 50, 74, 74,
+ 74, 74, 74, 74, 74, 74, 74, 74, 126, 70,
+ 70, 70, 75, 75, 76, 76, 76, 36, 48, 44,
+ 44, 44, 44, 44, 44, 9, 9, 9, 9, 127,
+ 11, 128, 10, 62, 62, 129, 53, 42, 42, 42,
+ 22, 22, 22, 21, 130, 23, 24, 24, 131, 132,
+ 133, 25, 134, 63, 64, 64, 65, 65, 135, 136,
+ 45, 137, 43, 14, 14, 14, 14, 14, 14, 14,
+ 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+ 14, 14, 14, 14, 46, 46, 46, 46, 46, 46,
+ 46, 46, 46, 41, 41, 41, 40, 40, 40, 40,
+ 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
+ 49, 28, 16, 16, 15, 15, 39, 39, 17, 17,
+ 31, 1, 1, 33, 34, 37, 37, 3, 3, 3,
+ 91, 91, 30, 29, 81, 81, 7, 7, 7, 7,
+ 7, 7, 32, 32, 32, 32, 87, 87, 87, 87,
+ 87, 79, 79, 80, 89, 89, 89, 89, 89, 12,
+ 12, 88, 88, 88, 88, 88, 88, 88, 85, 86,
+ 84, 84, 83, 83, 47, 18, 18, 19, 19, 90,
+ 51, 51, 52, 52, 52, 139, 20, 20, 60, 60,
+ 71, 71, 77, 77, 78, 78, 73, 73, 69, 69,
+ 72, 72, 72, 72, 72, 72, 4, 4, 13, 27,
+ 27, 27, 82, 8, 8, 8, 8, 68, 68, 67,
+ 67, 6, 6, 6, 6, 6, 26, 26, 26, 26,
+ 26, 140, 26, 26, 26, 26, 26, 26, 26, 26,
+ 66, 66, 55, 55, 54, 54, 56, 56, 59, 59,
+ 57, 57, 57, 57, 58, 58, 122, 122, 138, 138,
+ 35, 35, 61, 61, 38, 38, 101, 101, 105, 105,
+ 103, 103, 5, 5, 141, 141, 141, 141, 141, 141,
+ 92, 108, 106, 106, 106, 111, 111, 107, 107, 107,
+ 107, 107, 107, 107, 107, 107, 107, 107, 110, 109,
+ 95, 95, 97, 96, 96, 99, 99, 98, 98, 94,
+ 94, 94, 93, 93, 125, 125, 100, 100, 104, 104,
+ 102, 102,
+}
+var yyR2 = []int{
+
+ 0, 4, 0, 3, 0, 3, 0, 3, 2, 5,
+ 3, 3, 2, 1, 3, 1, 2, 2, 4, 0,
+ 1, 0, 4, 0, 1, 1, 1, 1, 2, 5,
+ 3, 2, 5, 7, 3, 2, 5, 3, 1, 2,
+ 4, 3, 4, 3, 1, 2, 1, 1, 2, 1,
+ 3, 3, 3, 2, 2, 3, 5, 5, 2, 0,
+ 4, 0, 3, 0, 2, 0, 4, 4, 4, 2,
+ 5, 1, 1, 2, 0, 3, 1, 3, 0, 0,
+ 0, 8, 0, 5, 0, 2, 0, 2, 0, 0,
+ 7, 0, 5, 1, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 1, 2, 2, 2, 2, 2,
+ 2, 2, 2, 3, 5, 6, 1, 1, 3, 5,
+ 5, 4, 6, 8, 1, 5, 5, 5, 7, 1,
+ 0, 3, 1, 4, 1, 4, 1, 3, 1, 1,
+ 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,
+ 4, 4, 1, 1, 1, 2, 1, 1, 1, 1,
+ 1, 3, 1, 1, 1, 2, 1, 1, 1, 1,
+ 3, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 3, 4, 4, 2, 3, 5, 1, 1, 2, 3,
+ 5, 3, 5, 3, 3, 5, 8, 5, 8, 5,
+ 0, 3, 0, 1, 3, 1, 4, 2, 0, 3,
+ 1, 3, 1, 3, 1, 3, 1, 3, 1, 3,
+ 3, 2, 4, 3, 5, 5, 1, 3, 1, 2,
+ 1, 3, 4, 1, 2, 2, 1, 1, 3, 0,
+ 2, 0, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 0, 4, 1, 2, 2, 2, 2, 2, 2,
+ 1, 3, 1, 3, 1, 3, 1, 3, 1, 3,
+ 1, 1, 3, 3, 0, 2, 0, 1, 0, 1,
+ 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,
+ 0, 1, 0, 1, 4, 4, 5, 6, 4, 4,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 3,
+ 4, 5, 4, 4, 2, 2, 4, 3, 3, 5,
+ 3, 4, 3, 5, 1, 0, 1, 3, 1, 1,
+ 2, 1, 1, 5, 0, 2, 1, 3, 1, 3,
+ 1, 3,
+}
+var yyChk = []int{
+
+ -1000, -112, -113, -116, -114, 26, -117, 26, -115, -3,
+ 25, -91, 74, 75, -118, -124, 25, -60, -119, 22,
+ 63, 4, -125, -123, 25, -50, -74, -47, -26, 2,
+ 33, -126, 32, 18, -44, -23, -45, -43, -25, -29,
+ 16, 7, 11, 19, 14, 20, 28, 10, -14, -56,
+ 17, 31, 29, 21, -33, -46, -3, -39, 54, 57,
+ 50, 51, 70, 71, 53, 37, -40, 60, 4, -30,
+ -41, -79, -80, -20, -90, -88, -139, 72, 9, 24,
+ -84, -83, 30, 23, 63, -120, 60, -2, 4, -3,
+ 64, 64, 65, -141, 22, 33, 10, 32, 18, 63,
+ 63, -70, 60, -54, -34, -3, -75, 60, -54, -48,
+ 60, -36, -3, -18, 60, -3, 67, -37, -33, -3,
+ -37, -41, -39, -3, 18, -41, -33, -61, -56, -14,
+ 5, 43, 38, 48, 34, 39, 47, 46, 44, 40,
+ 41, 50, 51, 52, 53, 54, 55, 56, 57, 35,
+ 45, 49, 37, 66, 6, 76, -130, -135, -137, -131,
+ 60, 64, 72, -46, -46, -46, -46, -46, -46, -46,
+ -46, 68, -17, -14, -32, -86, -90, -88, 54, 37,
+ 60, -1, 36, 68, -1, 2, -35, 12, -14, -87,
+ 37, -90, -88, -85, -12, 60, 54, -30, 72, -1,
+ -1, -121, 61, -120, -117, -118, 4, 4, 25, 74,
+ 65, 25, -92, -91, -92, -108, -92, -19, -92, 60,
+ -71, 61, -70, -7, 66, 76, -86, -90, -88, -85,
+ -12, 60, 37, -75, 61, -7, 66, -78, 61, -48,
+ -7, -51, 68, -67, -68, -8, -31, -3, -81, -7,
+ 12, 60, -140, 60, -14, -14, -14, -14, -14, -14,
+ -14, -14, -14, -14, -14, -14, -14, -14, -14, -14,
+ -14, -14, -14, -14, -14, -56, -56, -14, -21, -22,
+ -38, -42, -44, -56, 27, -24, -38, 36, -24, 61,
+ -59, -17, -3, 60, -14, -35, -49, 61, -32, 9,
+ -14, -49, -66, -6, -11, -74, -26, 2, 68, 73,
+ 73, -7, -7, -7, 64, -7, -73, 69, -72, -55,
+ -13, 60, 54, -33, -4, 25, -69, 69, -27, -33,
+ -4, 60, -122, 63, -118, 4, -106, -107, -110, -109,
+ -91, 25, 72, 24, 30, 23, 54, 9, 37, 18,
+ 66, -106, -106, -51, 60, -100, -95, -3, -122, 63,
+ 66, -56, -34, -7, 9, -122, 63, 66, -56, -122,
+ 63, -66, 61, 76, -138, -31, -81, -7, -67, -6,
+ -67, -53, 36, 63, 66, 6, -14, -136, 63, -62,
+ -132, -138, 12, 76, -17, 32, 73, 67, -58, -57,
+ -28, -16, -14, 68, 68, 37, -7, -90, -88, -85,
+ -12, 60, -138, 76, -58, 69, 63, -127, -7, -7,
+ 61, -3, 73, -122, 63, -7, 76, -5, 4, -13,
+ 54, 25, -13, 60, 64, -122, 63, -82, 60, -4,
+ 61, -120, 63, 63, 73, 4, 72, 68, 68, -106,
+ -111, 60, 37, -107, -109, 9, 60, -93, -94, 60,
+ 4, 51, -3, 66, 63, 63, -101, -100, 61, 76,
+ -106, 12, 61, -70, -56, 61, 61, -77, -76, -75,
+ -54, -56, 61, -48, 69, -3, -52, -89, 60, -86,
+ -90, -88, -85, -12, -8, 61, 61, -129, -38, 27,
+ 27, 36, -38, -10, 69, -9, 8, 13, -53, 61,
+ -138, -17, 61, 61, -35, 69, 76, -138, 67, -49,
+ -49, -7, 61, 69, -6, -66, -7, 69, -72, -5,
+ -33, 61, -13, -5, -13, -3, 69, -27, -67, 61,
+ -106, 73, -106, -105, -104, -97, -3, -103, -102, -96,
+ -3, -106, 25, -91, -110, -106, -106, -101, 63, -94,
+ 4, -93, 61, -3, -95, -5, -106, -122, 63, -7,
+ 60, -67, -52, -66, 63, -14, -14, -62, -128, -59,
+ 67, -133, 61, 73, 67, -28, -16, -15, -14, 68,
+ -58, -58, 61, 69, -5, 61, 61, 61, -106, 73,
+ 69, 63, -106, 69, 63, 60, 61, 61, 50, 63,
+ -99, -98, 60, -106, 60, -5, 61, -76, -67, 61,
+ 69, -38, 69, -66, 67, 66, 6, 76, -64, -35,
+ -49, 69, 69, -5, -5, -52, -106, -97, -5, -96,
+ -101, -99, -94, -101, -101, 61, -14, -14, -65, -63,
+ 15, 73, -58, 61, 61, 61, 61, -52, 67, 67,
+ 21, -11, 69, -99, -99, -134, -24, -53,
+}
+var yyDef = []int{
+
+ 4, -2, 2, 0, 6, 0, 21, 0, 218, 0,
+ 157, 158, 159, 0, 5, 344, 19, -2, 0, 0,
+ 3, 0, 0, 0, 20, 0, 24, 25, 26, 27,
+ 0, 0, 0, 0, 256, 257, 258, 259, 260, 0,
+ 263, 155, 155, 0, 0, 0, 292, 38, -2, 0,
+ 74, 88, 91, 78, 163, 93, -2, 114, 0, 0,
+ 0, 0, 0, 0, 0, 0, 146, 0, 126, 127,
+ 134, 0, 0, 139, -2, -2, 0, 290, 0, 0,
+ 196, 197, 0, 0, 7, 8, 0, 21, 15, 0,
+ 0, 0, 0, 345, 0, 0, 0, 0, 0, 18,
+ 219, 28, 0, 0, 274, 154, 31, 0, 0, 35,
+ 0, 0, 47, 210, 249, 0, 261, 264, 156, 153,
+ 265, -2, 0, 162, 0, -2, 268, 269, 293, 276,
+ 0, 53, 54, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 294, 294, 0, 294,
+ 0, 0, 290, 115, 116, 117, 118, 119, 120, 121,
+ 122, 140, 0, 148, 149, 172, -2, -2, 0, 0,
+ 0, 140, 151, 152, -2, 217, 0, 0, 291, 193,
+ 0, 176, 177, 178, 179, 0, 0, 189, 0, 0,
+ 0, 286, 10, 13, 21, 12, 16, 17, 160, 161,
+ 22, 0, 0, 310, 0, 0, 311, 210, 0, 0,
+ 286, 30, 220, 39, 0, 0, 166, 167, 168, 169,
+ 170, 0, 0, 286, 34, 0, 0, 286, 37, 224,
+ 48, 204, -2, 0, 288, 247, 243, 162, 246, 150,
+ 164, 249, -2, 249, 50, 94, 95, 96, 97, 98,
+ 99, 100, 101, 102, 103, 104, 105, 106, 107, 108,
+ 109, 110, 111, 112, 113, 51, 52, 277, 75, 0,
+ 71, 72, 295, 0, 0, 89, 76, 63, 79, 123,
+ 288, 278, 128, 0, 291, 0, 284, 147, 175, 0,
+ 288, 284, 0, 270, 252, 253, 254, 255, 59, 0,
+ 0, 194, 0, 198, 0, 0, 286, 201, 226, 0,
+ 302, 0, 0, 272, 238, -2, 286, 203, 228, 0,
+ 240, 0, 0, 287, 11, 0, 0, 312, 313, 314,
+ 317, 318, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 296, 0, 346, 0, 0, 287,
+ 0, 41, 275, 0, 0, 0, 287, 0, 43, 0,
+ 287, 0, 212, 289, 250, 244, 245, 165, 0, 262,
+ 0, 73, 65, 294, 0, 0, 69, 0, 294, 0,
+ 0, 0, 288, 289, 0, 0, 131, 290, 0, 288,
+ 280, 281, 142, 140, 140, 0, 199, -2, -2, -2,
+ -2, 0, 0, 289, 0, 216, -2, -2, 191, 192,
+ 180, 190, 0, 0, 287, 302, 0, 231, 303, 0,
+ 0, 236, 302, 0, 0, 0, 287, 239, 249, 0,
+ 9, 14, 304, 305, 0, 0, 0, 298, 300, 324,
+ 325, 0, 0, 315, 316, 0, 296, 0, 342, 0,
+ 339, 0, 341, 0, 308, 309, 0, 297, 0, 0,
+ 302, 0, 29, 221, 40, 171, 32, 286, 222, 44,
+ 46, 42, 36, 225, 211, 162, 209, 213, 249, 184,
+ 185, 186, 187, 188, 248, 212, 212, -2, 0, 0,
+ 0, 63, 77, 64, 92, 61, 0, 0, 80, 124,
+ 0, 279, 129, 130, 0, 137, 289, 285, 0, 284,
+ 284, 0, 135, 136, 271, 0, 195, 200, 227, 230,
+ 273, 302, 0, 233, 0, 237, 202, 229, 0, 241,
+ 319, 0, 0, 0, 299, 348, 0, 0, 301, 350,
+ 0, 334, -2, -2, 0, 327, 328, 0, 306, 0,
+ 340, 0, 335, 0, 347, 330, 302, 0, 287, 45,
+ 249, 0, 205, 0, 294, 67, 68, 0, -2, 0,
+ 58, 84, 125, 132, 290, 282, 283, 141, 144, 140,
+ 0, 0, -2, 60, 232, 302, 302, 212, 320, 0,
+ 322, 0, 302, 323, 0, 296, 326, 335, 0, 307,
+ 207, 336, 296, 338, 296, 331, 33, 223, 0, 214,
+ 66, 70, 90, 62, 55, 0, 0, 0, 86, 0,
+ 284, 143, 138, 234, 235, 242, 321, 349, 332, 351,
+ 0, 329, 0, 0, 0, 212, 0, 0, 81, 85,
+ 0, 133, 0, 335, 343, 337, 335, 206, 56, 57,
+ 82, 87, 145, 333, 208, 294, 0, 83,
+}
+var yyTok1 = []int{
+
+ 1, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 70, 3, 3, 65, 56, 57, 3,
+ 60, 61, 54, 50, 76, 51, 64, 55, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 67, 63,
+ 3, 66, 3, 74, 75, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 72, 3, 73, 53, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 68, 52, 69, 71,
+}
+var yyTok2 = []int{
+
+ 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
+ 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
+ 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+ 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
+ 42, 43, 44, 45, 46, 47, 48, 49, 58, 59,
+ 62,
+}
+var yyTok3 = []int{
+ 0,
+}
+
+//line yaccpar:1
+
+/* parser for yacc output */
+
+var yyDebug = 0
+
+type yyLexer interface {
+ Lex(lval *yySymType) int
+ Error(s string)
+}
+
+type yyParser interface {
+ Lookahead() int
+}
+
+type yyParserImpl struct {
+ lookahead func() int
+}
+
+func (p *yyParserImpl) Lookahead() int {
+ return p.lookahead()
+}
+
+const yyFlag = -1000
+
+func yyTokname(c int) string {
+ // 4 is TOKSTART above
+ if c >= 4 && c-4 < len(yyToknames) {
+ if yyToknames[c-4] != "" {
+ return yyToknames[c-4]
+ }
+ }
+ return __yyfmt__.Sprintf("tok-%v", c)
+}
+
+func yyStatname(s int) string {
+ if s >= 0 && s < len(yyStatenames) {
+ if yyStatenames[s] != "" {
+ return yyStatenames[s]
+ }
+ }
+ return __yyfmt__.Sprintf("state-%v", s)
+}
+
+func yylex1(lex yyLexer, lval *yySymType) (char, token int) {
+ token = 0
+ char = lex.Lex(lval)
+ if char <= 0 {
+ token = yyTok1[0]
+ goto out
+ }
+ if char < len(yyTok1) {
+ token = yyTok1[char]
+ goto out
+ }
+ if char >= yyPrivate {
+ if char < yyPrivate+len(yyTok2) {
+ token = yyTok2[char-yyPrivate]
+ goto out
+ }
+ }
+ for i := 0; i < len(yyTok3); i += 2 {
+ token = yyTok3[i+0]
+ if token == char {
+ token = yyTok3[i+1]
+ goto out
+ }
+ }
+
+out:
+ if token == 0 {
+ token = yyTok2[1] /* unknown char */
+ }
+ if yyDebug >= 3 {
+ __yyfmt__.Printf("lex %s(%d)\n", yyTokname(token), uint(char))
+ }
+ return char, token
+}
+
+func yyParse(yylex yyLexer) int {
+ var yyn int
+ var yylval yySymType
+ var yyVAL yySymType
+ var yyDollar []yySymType
+ yyS := make([]yySymType, yyMaxDepth)
+
+ Nerrs := 0 /* number of errors */
+ Errflag := 0 /* error recovery flag */
+ yystate := 0
+ yychar := -1
+ yytoken := -1 // yychar translated into internal numbering
+ if lx, ok := yylex.(interface {
+ SetParser(yyParser)
+ }); ok {
+ p := &yyParserImpl{
+ lookahead: func() int { return yychar },
+ }
+ lx.SetParser(p)
+ defer func() {
+ // Make sure we report no lookahead when not parsing.
+ yychar = -1
+ yytoken = -1
+ }()
+ }
+ yyp := -1
+ goto yystack
+
+ret0:
+ return 0
+
+ret1:
+ return 1
+
+yystack:
+ /* put a state and value onto the stack */
+ if yyDebug >= 4 {
+ __yyfmt__.Printf("char %v in %v\n", yyTokname(yytoken), yyStatname(yystate))
+ }
+
+ yyp++
+ if yyp >= len(yyS) {
+ nyys := make([]yySymType, len(yyS)*2)
+ copy(nyys, yyS)
+ yyS = nyys
+ }
+ yyS[yyp] = yyVAL
+ yyS[yyp].yys = yystate
+
+yynewstate:
+ yyn = yyPact[yystate]
+ if yyn <= yyFlag {
+ goto yydefault /* simple state */
+ }
+ if yychar < 0 {
+ yychar, yytoken = yylex1(yylex, &yylval)
+ }
+ yyn += yytoken
+ if yyn < 0 || yyn >= yyLast {
+ goto yydefault
+ }
+ yyn = yyAct[yyn]
+ if yyChk[yyn] == yytoken { /* valid shift */
+ yychar = -1
+ yytoken = -1
+ yyVAL = yylval
+ yystate = yyn
+ if Errflag > 0 {
+ Errflag--
+ }
+ goto yystack
+ }
+
+yydefault:
+ /* default state action */
+ yyn = yyDef[yystate]
+ if yyn == -2 {
+ if yychar < 0 {
+ yychar, yytoken = yylex1(yylex, &yylval)
+ }
+
+ /* look through exception table */
+ xi := 0
+ for {
+ if yyExca[xi+0] == -1 && yyExca[xi+1] == yystate {
+ break
+ }
+ xi += 2
+ }
+ for xi += 2; ; xi += 2 {
+ yyn = yyExca[xi+0]
+ if yyn < 0 || yyn == yytoken {
+ break
+ }
+ }
+ yyn = yyExca[xi+1]
+ if yyn < 0 {
+ goto ret0
+ }
+ }
+ if yyn == 0 {
+ /* error ... attempt to resume parsing */
+ switch Errflag {
+ case 0: /* brand new error */
+ yylex.Error("syntax error")
+ Nerrs++
+ if yyDebug >= 1 {
+ __yyfmt__.Printf("%s", yyStatname(yystate))
+ __yyfmt__.Printf(" saw %s\n", yyTokname(yytoken))
+ }
+ fallthrough
+
+ case 1, 2: /* incompletely recovered error ... try again */
+ Errflag = 3
+
+ /* find a state where "error" is a legal shift action */
+ for yyp >= 0 {
+ yyn = yyPact[yyS[yyp].yys] + yyErrCode
+ if yyn >= 0 && yyn < yyLast {
+ yystate = yyAct[yyn] /* simulate a shift of "error" */
+ if yyChk[yystate] == yyErrCode {
+ goto yystack
+ }
+ }
+
+ /* the current p has no shift on "error", pop stack */
+ if yyDebug >= 2 {
+ __yyfmt__.Printf("error recovery pops state %d\n", yyS[yyp].yys)
+ }
+ yyp--
+ }
+ /* there is no state on the stack with an error shift ... abort */
+ goto ret1
+
+ case 3: /* no shift yet; clobber input char */
+ if yyDebug >= 2 {
+ __yyfmt__.Printf("error recovery discards %s\n", yyTokname(yytoken))
+ }
+ if yytoken == yyEofCode {
+ goto ret1
+ }
+ yychar = -1
+ yytoken = -1
+ goto yynewstate /* try again in the same state */
+ }
+ }
+
+ /* reduction by production yyn */
+ if yyDebug >= 2 {
+ __yyfmt__.Printf("reduce %v in:\n\t%v\n", yyn, yyStatname(yystate))
+ }
+
+ yynt := yyn
+ yypt := yyp
+ _ = yypt // guard against "declared and not used"
+
+ yyp -= yyR2[yyn]
+ // yyp is now the index of $0. Perform the default action. Iff the
+ // reduced production is ε, $1 is possibly out of range.
+ if yyp+1 >= len(yyS) {
+ nyys := make([]yySymType, len(yyS)*2)
+ copy(nyys, yyS)
+ yyS = nyys
+ }
+ yyVAL = yyS[yyp+1]
+
+ /* consult goto table to find next state */
+ yyn = yyR1[yyn]
+ yyg := yyPgo[yyn]
+ yyj := yyg + yyS[yyp].yys + 1
+
+ if yyj >= yyLast {
+ yystate = yyAct[yyg]
+ } else {
+ yystate = yyAct[yyj]
+ if yyChk[yystate] != -yyn {
+ yystate = yyAct[yyg]
+ }
+ }
+ // dummy call; replaced with literal code
+ switch yynt {
+
+ case 1:
+ yyDollar = yyS[yypt-4 : yypt+1]
+ //line go.y:127
+ {
+ xtop = concat(xtop, yyDollar[4].list)
+ }
+ case 2:
+ yyDollar = yyS[yypt-0 : yypt+1]
+ //line go.y:133
+ {
+ prevlineno = lineno
+ Yyerror("package statement must be first")
+ errorexit()
+ }
+ case 3:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:139
+ {
+ mkpackage(yyDollar[2].sym.Name)
+ }
+ case 4:
+ yyDollar = yyS[yypt-0 : yypt+1]
+ //line go.y:149
+ {
+ importpkg = Runtimepkg
+
+ if Debug['A'] != 0 {
+ cannedimports("runtime.Builtin", "package runtime\n\n$$\n\n")
+ } else {
+ cannedimports("runtime.Builtin", runtimeimport)
+ }
+ curio.importsafe = true
+ }
+ case 5:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:161
+ {
+ importpkg = nil
+ }
+ case 11:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:175
+ {
+ ipkg := importpkg
+ my := importmyname
+ importpkg = nil
+ importmyname = nil
+
+ if my == nil {
+ my = Lookup(ipkg.Name)
+ }
+
+ pack := Nod(OPACK, nil, nil)
+ pack.Sym = my
+ pack.Pkg = ipkg
+ pack.Lineno = int32(yyDollar[1].i)
+
+ if strings.HasPrefix(my.Name, ".") {
+ importdot(ipkg, pack)
+ break
+ }
+ if my.Name == "init" {
+ Yyerror("cannot import package as init - init must be a func")
+ break
+ }
+ if my.Name == "_" {
+ break
+ }
+ if my.Def != nil {
+ lineno = int32(yyDollar[1].i)
+ redeclare(my, "as imported package name")
+ }
+ my.Def = pack
+ my.Lastlineno = int32(yyDollar[1].i)
+ my.Block = 1 // at top level
+ }
+ case 12:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:210
+ {
+ // When an invalid import path is passed to importfile,
+ // it calls Yyerror and then sets up a fake import with
+ // no package statement. This allows us to test more
+ // than one invalid import statement in a single file.
+ if nerrors == 0 {
+ Fatal("phase error in import")
+ }
+ }
+ case 15:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:226
+ {
+ // import with original name
+ yyVAL.i = parserline()
+ importmyname = nil
+ importfile(&yyDollar[1].val, yyVAL.i)
+ }
+ case 16:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:233
+ {
+ // import with given name
+ yyVAL.i = parserline()
+ importmyname = yyDollar[1].sym
+ importfile(&yyDollar[2].val, yyVAL.i)
+ }
+ case 17:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:240
+ {
+ // import into my name space
+ yyVAL.i = parserline()
+ importmyname = Lookup(".")
+ importfile(&yyDollar[2].val, yyVAL.i)
+ }
+ case 18:
+ yyDollar = yyS[yypt-4 : yypt+1]
+ //line go.y:249
+ {
+ if importpkg.Name == "" {
+ importpkg.Name = yyDollar[2].sym.Name
+ Pkglookup(yyDollar[2].sym.Name, nil).Npkg++
+ } else if importpkg.Name != yyDollar[2].sym.Name {
+ Yyerror("conflicting names %s and %s for package \"%v\"", importpkg.Name, yyDollar[2].sym.Name, Zconv(importpkg.Path, 0))
+ }
+ importpkg.Direct = 1
+ importpkg.Safe = curio.importsafe
+
+ if safemode != 0 && !curio.importsafe {
+ Yyerror("cannot import unsafe package \"%v\"", Zconv(importpkg.Path, 0))
+ }
+ }
+ case 20:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:266
+ {
+ if yyDollar[1].sym.Name == "safe" {
+ curio.importsafe = true
+ }
+ }
+ case 21:
+ yyDollar = yyS[yypt-0 : yypt+1]
+ //line go.y:273
+ {
+ defercheckwidth()
+ }
+ case 22:
+ yyDollar = yyS[yypt-4 : yypt+1]
+ //line go.y:277
+ {
+ resumecheckwidth()
+ unimportfile()
+ }
+ case 23:
+ yyDollar = yyS[yypt-0 : yypt+1]
+ //line go.y:286
+ {
+ Yyerror("empty top-level declaration")
+ yyVAL.list = nil
+ }
+ case 24:
+ yyVAL.list = yyS[yypt-0].list
+ case 25:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:292
+ {
+ yyVAL.list = list1(yyDollar[1].node)
+ }
+ case 26:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:296
+ {
+ Yyerror("non-declaration statement outside function body")
+ yyVAL.list = nil
+ }
+ case 27:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:301
+ {
+ yyVAL.list = nil
+ }
+ case 28:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:307
+ {
+ yyVAL.list = yyDollar[2].list
+ }
+ case 29:
+ yyDollar = yyS[yypt-5 : yypt+1]
+ //line go.y:311
+ {
+ yyVAL.list = yyDollar[3].list
+ }
+ case 30:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:315
+ {
+ yyVAL.list = nil
+ }
+ case 31:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:319
+ {
+ yyVAL.list = yyDollar[2].list
+ iota_ = -100000
+ lastconst = nil
+ }
+ case 32:
+ yyDollar = yyS[yypt-5 : yypt+1]
+ //line go.y:325
+ {
+ yyVAL.list = yyDollar[3].list
+ iota_ = -100000
+ lastconst = nil
+ }
+ case 33:
+ yyDollar = yyS[yypt-7 : yypt+1]
+ //line go.y:331
+ {
+ yyVAL.list = concat(yyDollar[3].list, yyDollar[5].list)
+ iota_ = -100000
+ lastconst = nil
+ }
+ case 34:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:337
+ {
+ yyVAL.list = nil
+ iota_ = -100000
+ }
+ case 35:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:342
+ {
+ yyVAL.list = list1(yyDollar[2].node)
+ }
+ case 36:
+ yyDollar = yyS[yypt-5 : yypt+1]
+ //line go.y:346
+ {
+ yyVAL.list = yyDollar[3].list
+ }
+ case 37:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:350
+ {
+ yyVAL.list = nil
+ }
+ case 38:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:356
+ {
+ iota_ = 0
+ }
+ case 39:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:362
+ {
+ yyVAL.list = variter(yyDollar[1].list, yyDollar[2].node, nil)
+ }
+ case 40:
+ yyDollar = yyS[yypt-4 : yypt+1]
+ //line go.y:366
+ {
+ yyVAL.list = variter(yyDollar[1].list, yyDollar[2].node, yyDollar[4].list)
+ }
+ case 41:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:370
+ {
+ yyVAL.list = variter(yyDollar[1].list, nil, yyDollar[3].list)
+ }
+ case 42:
+ yyDollar = yyS[yypt-4 : yypt+1]
+ //line go.y:376
+ {
+ yyVAL.list = constiter(yyDollar[1].list, yyDollar[2].node, yyDollar[4].list)
+ }
+ case 43:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:380
+ {
+ yyVAL.list = constiter(yyDollar[1].list, nil, yyDollar[3].list)
+ }
+ case 44:
+ yyVAL.list = yyS[yypt-0].list
+ case 45:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:387
+ {
+ yyVAL.list = constiter(yyDollar[1].list, yyDollar[2].node, nil)
+ }
+ case 46:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:391
+ {
+ yyVAL.list = constiter(yyDollar[1].list, nil, nil)
+ }
+ case 47:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:397
+ {
+ // different from dclname because the name
+ // becomes visible right here, not at the end
+ // of the declaration.
+ yyVAL.node = typedcl0(yyDollar[1].sym)
+ }
+ case 48:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:406
+ {
+ yyVAL.node = typedcl1(yyDollar[1].node, yyDollar[2].node, 1)
+ }
+ case 49:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:412
+ {
+ yyVAL.node = yyDollar[1].node
+
+ // These nodes do not carry line numbers.
+ // Since a bare name used as an expression is an error,
+ // introduce a wrapper node to give the correct line.
+ switch yyVAL.node.Op {
+ case ONAME, ONONAME, OTYPE, OPACK, OLITERAL:
+ yyVAL.node = Nod(OPAREN, yyVAL.node, nil)
+ yyVAL.node.Implicit = 1
+ break
+ }
+ }
+ case 50:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:426
+ {
+ yyVAL.node = Nod(OASOP, yyDollar[1].node, yyDollar[3].node)
+ yyVAL.node.Etype = uint8(yyDollar[2].i) // rathole to pass opcode
+ }
+ case 51:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:431
+ {
+ if yyDollar[1].list.Next == nil && yyDollar[3].list.Next == nil {
+ // simple
+ yyVAL.node = Nod(OAS, yyDollar[1].list.N, yyDollar[3].list.N)
+ break
+ }
+ // multiple
+ yyVAL.node = Nod(OAS2, nil, nil)
+ yyVAL.node.List = yyDollar[1].list
+ yyVAL.node.Rlist = yyDollar[3].list
+ }
+ case 52:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:443
+ {
+ if yyDollar[3].list.N.Op == OTYPESW {
+ yyVAL.node = Nod(OTYPESW, nil, yyDollar[3].list.N.Right)
+ if yyDollar[3].list.Next != nil {
+ Yyerror("expr.(type) must be alone in list")
+ }
+ if yyDollar[1].list.Next != nil {
+ Yyerror("argument count mismatch: %d = %d", count(yyDollar[1].list), 1)
+ } else if (yyDollar[1].list.N.Op != ONAME && yyDollar[1].list.N.Op != OTYPE && yyDollar[1].list.N.Op != ONONAME) || isblank(yyDollar[1].list.N) {
+ Yyerror("invalid variable name %nil in type switch", yyDollar[1].list.N)
+ } else {
+ yyVAL.node.Left = dclname(yyDollar[1].list.N.Sym)
+ } // it's a colas, so must not re-use an oldname.
+ break
+ }
+ yyVAL.node = colas(yyDollar[1].list, yyDollar[3].list, int32(yyDollar[2].i))
+ }
+ case 53:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:461
+ {
+ yyVAL.node = Nod(OASOP, yyDollar[1].node, Nodintconst(1))
+ yyVAL.node.Implicit = 1
+ yyVAL.node.Etype = OADD
+ }
+ case 54:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:467
+ {
+ yyVAL.node = Nod(OASOP, yyDollar[1].node, Nodintconst(1))
+ yyVAL.node.Implicit = 1
+ yyVAL.node.Etype = OSUB
+ }
+ case 55:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:475
+ {
+ var n, nn *Node
+
+ // will be converted to OCASE
+ // right will point to next case
+ // done in casebody()
+ markdcl()
+ yyVAL.node = Nod(OXCASE, nil, nil)
+ yyVAL.node.List = yyDollar[2].list
+ if typesw != nil && typesw.Right != nil {
+ n = typesw.Right.Left
+ if n != nil {
+ // type switch - declare variable
+ nn = newname(n.Sym)
+ declare(nn, dclcontext)
+ yyVAL.node.Nname = nn
+
+ // keep track of the instances for reporting unused
+ nn.Defn = typesw.Right
+ }
+ }
+ }
+ case 56:
+ yyDollar = yyS[yypt-5 : yypt+1]
+ //line go.y:498
+ {
+ var n *Node
+
+ // will be converted to OCASE
+ // right will point to next case
+ // done in casebody()
+ markdcl()
+ yyVAL.node = Nod(OXCASE, nil, nil)
+ if yyDollar[2].list.Next == nil {
+ n = Nod(OAS, yyDollar[2].list.N, yyDollar[4].node)
+ } else {
+ n = Nod(OAS2, nil, nil)
+ n.List = yyDollar[2].list
+ n.Rlist = list1(yyDollar[4].node)
+ }
+ yyVAL.node.List = list1(n)
+ }
+ case 57:
+ yyDollar = yyS[yypt-5 : yypt+1]
+ //line go.y:516
+ {
+ // will be converted to OCASE
+ // right will point to next case
+ // done in casebody()
+ markdcl()
+ yyVAL.node = Nod(OXCASE, nil, nil)
+ yyVAL.node.List = list1(colas(yyDollar[2].list, list1(yyDollar[4].node), int32(yyDollar[3].i)))
+ }
+ case 58:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:525
+ {
+ var n, nn *Node
+
+ markdcl()
+ yyVAL.node = Nod(OXCASE, nil, nil)
+ if typesw != nil && typesw.Right != nil {
+ n = typesw.Right.Left
+ if n != nil {
+ // type switch - declare variable
+ nn = newname(n.Sym)
+ declare(nn, dclcontext)
+ yyVAL.node.Nname = nn
+
+ // keep track of the instances for reporting unused
+ nn.Defn = typesw.Right
+ }
+ }
+ }
+ case 59:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:546
+ {
+ markdcl()
+ }
+ case 60:
+ yyDollar = yyS[yypt-4 : yypt+1]
+ //line go.y:550
+ {
+ if yyDollar[3].list == nil {
+ yyVAL.node = Nod(OEMPTY, nil, nil)
+ } else {
+ yyVAL.node = liststmt(yyDollar[3].list)
+ }
+ popdcl()
+ }
+ case 61:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:561
+ {
+ // If the last token read by the lexer was consumed
+ // as part of the case, clear it (parser has cleared yychar).
+ // If the last token read by the lexer was the lookahead
+ // leave it alone (parser has it cached in yychar).
+ // This is so that the stmt_list action doesn't look at
+ // the case tokens if the stmt_list is empty.
+ yylast = yychar
+ yyDollar[1].node.Xoffset = int64(block)
+ }
+ case 62:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:572
+ {
+ // This is the only place in the language where a statement
+ // list is not allowed to drop the final semicolon, because
+ // it's the only place where a statement list is not followed
+ // by a closing brace. Handle the error for pedantry.
+
+ // Find the final token of the statement list.
+ // yylast is lookahead; yyprev is last of stmt_list
+ last := yyprev
+
+ if last > 0 && last != ';' && yychar != '}' {
+ Yyerror("missing statement after label")
+ }
+ yyVAL.node = yyDollar[1].node
+ yyVAL.node.Nbody = yyDollar[3].list
+ popdcl()
+ }
+ case 63:
+ yyDollar = yyS[yypt-0 : yypt+1]
+ //line go.y:591
+ {
+ yyVAL.list = nil
+ }
+ case 64:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:595
+ {
+ yyVAL.list = list(yyDollar[1].list, yyDollar[2].node)
+ }
+ case 65:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:601
+ {
+ markdcl()
+ }
+ case 66:
+ yyDollar = yyS[yypt-4 : yypt+1]
+ //line go.y:605
+ {
+ yyVAL.list = yyDollar[3].list
+ popdcl()
+ }
+ case 67:
+ yyDollar = yyS[yypt-4 : yypt+1]
+ //line go.y:612
+ {
+ yyVAL.node = Nod(ORANGE, nil, yyDollar[4].node)
+ yyVAL.node.List = yyDollar[1].list
+ yyVAL.node.Etype = 0 // := flag
+ }
+ case 68:
+ yyDollar = yyS[yypt-4 : yypt+1]
+ //line go.y:618
+ {
+ yyVAL.node = Nod(ORANGE, nil, yyDollar[4].node)
+ yyVAL.node.List = yyDollar[1].list
+ yyVAL.node.Colas = 1
+ colasdefn(yyDollar[1].list, yyVAL.node)
+ }
+ case 69:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:625
+ {
+ yyVAL.node = Nod(ORANGE, nil, yyDollar[2].node)
+ yyVAL.node.Etype = 0 // := flag
+ }
+ case 70:
+ yyDollar = yyS[yypt-5 : yypt+1]
+ //line go.y:632
+ {
+ // init ; test ; incr
+ if yyDollar[5].node != nil && yyDollar[5].node.Colas != 0 {
+ Yyerror("cannot declare in the for-increment")
+ }
+ yyVAL.node = Nod(OFOR, nil, nil)
+ if yyDollar[1].node != nil {
+ yyVAL.node.Ninit = list1(yyDollar[1].node)
+ }
+ yyVAL.node.Ntest = yyDollar[3].node
+ yyVAL.node.Nincr = yyDollar[5].node
+ }
+ case 71:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:645
+ {
+ // normal test
+ yyVAL.node = Nod(OFOR, nil, nil)
+ yyVAL.node.Ntest = yyDollar[1].node
+ }
+ case 72:
+ yyVAL.node = yyS[yypt-0].node
+ case 73:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:654
+ {
+ yyVAL.node = yyDollar[1].node
+ yyVAL.node.Nbody = concat(yyVAL.node.Nbody, yyDollar[2].list)
+ }
+ case 74:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:661
+ {
+ markdcl()
+ }
+ case 75:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:665
+ {
+ yyVAL.node = yyDollar[3].node
+ popdcl()
+ }
+ case 76:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:672
+ {
+ // test
+ yyVAL.node = Nod(OIF, nil, nil)
+ yyVAL.node.Ntest = yyDollar[1].node
+ }
+ case 77:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:678
+ {
+ // init ; test
+ yyVAL.node = Nod(OIF, nil, nil)
+ if yyDollar[1].node != nil {
+ yyVAL.node.Ninit = list1(yyDollar[1].node)
+ }
+ yyVAL.node.Ntest = yyDollar[3].node
+ }
+ case 78:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:690
+ {
+ markdcl()
+ }
+ case 79:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:694
+ {
+ if yyDollar[3].node.Ntest == nil {
+ Yyerror("missing condition in if statement")
+ }
+ }
+ case 80:
+ yyDollar = yyS[yypt-5 : yypt+1]
+ //line go.y:700
+ {
+ yyDollar[3].node.Nbody = yyDollar[5].list
+ }
+ case 81:
+ yyDollar = yyS[yypt-8 : yypt+1]
+ //line go.y:704
+ {
+ var n *Node
+ var nn *NodeList
+
+ yyVAL.node = yyDollar[3].node
+ n = yyDollar[3].node
+ popdcl()
+ for nn = concat(yyDollar[7].list, yyDollar[8].list); nn != nil; nn = nn.Next {
+ if nn.N.Op == OIF {
+ popdcl()
+ }
+ n.Nelse = list1(nn.N)
+ n = nn.N
+ }
+ }
+ case 82:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:722
+ {
+ markdcl()
+ }
+ case 83:
+ yyDollar = yyS[yypt-5 : yypt+1]
+ //line go.y:726
+ {
+ if yyDollar[4].node.Ntest == nil {
+ Yyerror("missing condition in if statement")
+ }
+ yyDollar[4].node.Nbody = yyDollar[5].list
+ yyVAL.list = list1(yyDollar[4].node)
+ }
+ case 84:
+ yyDollar = yyS[yypt-0 : yypt+1]
+ //line go.y:735
+ {
+ yyVAL.list = nil
+ }
+ case 85:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:739
+ {
+ yyVAL.list = concat(yyDollar[1].list, yyDollar[2].list)
+ }
+ case 86:
+ yyDollar = yyS[yypt-0 : yypt+1]
+ //line go.y:744
+ {
+ yyVAL.list = nil
+ }
+ case 87:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:748
+ {
+ l := &NodeList{N: yyDollar[2].node}
+ l.End = l
+ yyVAL.list = l
+ }
+ case 88:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:756
+ {
+ markdcl()
+ }
+ case 89:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:760
+ {
+ var n *Node
+ n = yyDollar[3].node.Ntest
+ if n != nil && n.Op != OTYPESW {
+ n = nil
+ }
+ typesw = Nod(OXXX, typesw, n)
+ }
+ case 90:
+ yyDollar = yyS[yypt-7 : yypt+1]
+ //line go.y:769
+ {
+ yyVAL.node = yyDollar[3].node
+ yyVAL.node.Op = OSWITCH
+ yyVAL.node.List = yyDollar[6].list
+ typesw = typesw.Left
+ popdcl()
+ }
+ case 91:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:779
+ {
+ typesw = Nod(OXXX, typesw, nil)
+ }
+ case 92:
+ yyDollar = yyS[yypt-5 : yypt+1]
+ //line go.y:783
+ {
+ yyVAL.node = Nod(OSELECT, nil, nil)
+ yyVAL.node.Lineno = typesw.Lineno
+ yyVAL.node.List = yyDollar[4].list
+ typesw = typesw.Left
+ }
+ case 93:
+ yyVAL.node = yyS[yypt-0].node
+ case 94:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:796
+ {
+ yyVAL.node = Nod(OOROR, yyDollar[1].node, yyDollar[3].node)
+ }
+ case 95:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:800
+ {
+ yyVAL.node = Nod(OANDAND, yyDollar[1].node, yyDollar[3].node)
+ }
+ case 96:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:804
+ {
+ yyVAL.node = Nod(OEQ, yyDollar[1].node, yyDollar[3].node)
+ }
+ case 97:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:808
+ {
+ yyVAL.node = Nod(ONE, yyDollar[1].node, yyDollar[3].node)
+ }
+ case 98:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:812
+ {
+ yyVAL.node = Nod(OLT, yyDollar[1].node, yyDollar[3].node)
+ }
+ case 99:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:816
+ {
+ yyVAL.node = Nod(OLE, yyDollar[1].node, yyDollar[3].node)
+ }
+ case 100:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:820
+ {
+ yyVAL.node = Nod(OGE, yyDollar[1].node, yyDollar[3].node)
+ }
+ case 101:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:824
+ {
+ yyVAL.node = Nod(OGT, yyDollar[1].node, yyDollar[3].node)
+ }
+ case 102:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:828
+ {
+ yyVAL.node = Nod(OADD, yyDollar[1].node, yyDollar[3].node)
+ }
+ case 103:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:832
+ {
+ yyVAL.node = Nod(OSUB, yyDollar[1].node, yyDollar[3].node)
+ }
+ case 104:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:836
+ {
+ yyVAL.node = Nod(OOR, yyDollar[1].node, yyDollar[3].node)
+ }
+ case 105:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:840
+ {
+ yyVAL.node = Nod(OXOR, yyDollar[1].node, yyDollar[3].node)
+ }
+ case 106:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:844
+ {
+ yyVAL.node = Nod(OMUL, yyDollar[1].node, yyDollar[3].node)
+ }
+ case 107:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:848
+ {
+ yyVAL.node = Nod(ODIV, yyDollar[1].node, yyDollar[3].node)
+ }
+ case 108:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:852
+ {
+ yyVAL.node = Nod(OMOD, yyDollar[1].node, yyDollar[3].node)
+ }
+ case 109:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:856
+ {
+ yyVAL.node = Nod(OAND, yyDollar[1].node, yyDollar[3].node)
+ }
+ case 110:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:860
+ {
+ yyVAL.node = Nod(OANDNOT, yyDollar[1].node, yyDollar[3].node)
+ }
+ case 111:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:864
+ {
+ yyVAL.node = Nod(OLSH, yyDollar[1].node, yyDollar[3].node)
+ }
+ case 112:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:868
+ {
+ yyVAL.node = Nod(ORSH, yyDollar[1].node, yyDollar[3].node)
+ }
+ case 113:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:873
+ {
+ yyVAL.node = Nod(OSEND, yyDollar[1].node, yyDollar[3].node)
+ }
+ case 114:
+ yyVAL.node = yyS[yypt-0].node
+ case 115:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:880
+ {
+ yyVAL.node = Nod(OIND, yyDollar[2].node, nil)
+ }
+ case 116:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:884
+ {
+ if yyDollar[2].node.Op == OCOMPLIT {
+ // Special case for &T{...}: turn into (*T){...}.
+ yyVAL.node = yyDollar[2].node
+ yyVAL.node.Right = Nod(OIND, yyVAL.node.Right, nil)
+ yyVAL.node.Right.Implicit = 1
+ } else {
+ yyVAL.node = Nod(OADDR, yyDollar[2].node, nil)
+ }
+ }
+ case 117:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:895
+ {
+ yyVAL.node = Nod(OPLUS, yyDollar[2].node, nil)
+ }
+ case 118:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:899
+ {
+ yyVAL.node = Nod(OMINUS, yyDollar[2].node, nil)
+ }
+ case 119:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:903
+ {
+ yyVAL.node = Nod(ONOT, yyDollar[2].node, nil)
+ }
+ case 120:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:907
+ {
+ Yyerror("the bitwise complement operator is ^")
+ yyVAL.node = Nod(OCOM, yyDollar[2].node, nil)
+ }
+ case 121:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:912
+ {
+ yyVAL.node = Nod(OCOM, yyDollar[2].node, nil)
+ }
+ case 122:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:916
+ {
+ yyVAL.node = Nod(ORECV, yyDollar[2].node, nil)
+ }
+ case 123:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:926
+ {
+ yyVAL.node = Nod(OCALL, yyDollar[1].node, nil)
+ }
+ case 124:
+ yyDollar = yyS[yypt-5 : yypt+1]
+ //line go.y:930
+ {
+ yyVAL.node = Nod(OCALL, yyDollar[1].node, nil)
+ yyVAL.node.List = yyDollar[3].list
+ }
+ case 125:
+ yyDollar = yyS[yypt-6 : yypt+1]
+ //line go.y:935
+ {
+ yyVAL.node = Nod(OCALL, yyDollar[1].node, nil)
+ yyVAL.node.List = yyDollar[3].list
+ yyVAL.node.Isddd = 1
+ }
+ case 126:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:943
+ {
+ yyVAL.node = nodlit(yyDollar[1].val)
+ }
+ case 127:
+ yyVAL.node = yyS[yypt-0].node
+ case 128:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:948
+ {
+ if yyDollar[1].node.Op == OPACK {
+ var s *Sym
+ s = restrictlookup(yyDollar[3].sym.Name, yyDollar[1].node.Pkg)
+ yyDollar[1].node.Used = 1
+ yyVAL.node = oldname(s)
+ break
+ }
+ yyVAL.node = Nod(OXDOT, yyDollar[1].node, newname(yyDollar[3].sym))
+ }
+ case 129:
+ yyDollar = yyS[yypt-5 : yypt+1]
+ //line go.y:959
+ {
+ yyVAL.node = Nod(ODOTTYPE, yyDollar[1].node, yyDollar[4].node)
+ }
+ case 130:
+ yyDollar = yyS[yypt-5 : yypt+1]
+ //line go.y:963
+ {
+ yyVAL.node = Nod(OTYPESW, nil, yyDollar[1].node)
+ }
+ case 131:
+ yyDollar = yyS[yypt-4 : yypt+1]
+ //line go.y:967
+ {
+ yyVAL.node = Nod(OINDEX, yyDollar[1].node, yyDollar[3].node)
+ }
+ case 132:
+ yyDollar = yyS[yypt-6 : yypt+1]
+ //line go.y:971
+ {
+ yyVAL.node = Nod(OSLICE, yyDollar[1].node, Nod(OKEY, yyDollar[3].node, yyDollar[5].node))
+ }
+ case 133:
+ yyDollar = yyS[yypt-8 : yypt+1]
+ //line go.y:975
+ {
+ if yyDollar[5].node == nil {
+ Yyerror("middle index required in 3-index slice")
+ }
+ if yyDollar[7].node == nil {
+ Yyerror("final index required in 3-index slice")
+ }
+ yyVAL.node = Nod(OSLICE3, yyDollar[1].node, Nod(OKEY, yyDollar[3].node, Nod(OKEY, yyDollar[5].node, yyDollar[7].node)))
+ }
+ case 134:
+ yyVAL.node = yyS[yypt-0].node
+ case 135:
+ yyDollar = yyS[yypt-5 : yypt+1]
+ //line go.y:986
+ {
+ // conversion
+ yyVAL.node = Nod(OCALL, yyDollar[1].node, nil)
+ yyVAL.node.List = list1(yyDollar[3].node)
+ }
+ case 136:
+ yyDollar = yyS[yypt-5 : yypt+1]
+ //line go.y:992
+ {
+ yyVAL.node = yyDollar[3].node
+ yyVAL.node.Right = yyDollar[1].node
+ yyVAL.node.List = yyDollar[4].list
+ fixlbrace(yyDollar[2].i)
+ }
+ case 137:
+ yyDollar = yyS[yypt-5 : yypt+1]
+ //line go.y:999
+ {
+ yyVAL.node = yyDollar[3].node
+ yyVAL.node.Right = yyDollar[1].node
+ yyVAL.node.List = yyDollar[4].list
+ }
+ case 138:
+ yyDollar = yyS[yypt-7 : yypt+1]
+ //line go.y:1005
+ {
+ Yyerror("cannot parenthesize type in composite literal")
+ yyVAL.node = yyDollar[5].node
+ yyVAL.node.Right = yyDollar[2].node
+ yyVAL.node.List = yyDollar[6].list
+ }
+ case 139:
+ yyVAL.node = yyS[yypt-0].node
+ case 140:
+ yyDollar = yyS[yypt-0 : yypt+1]
+ //line go.y:1014
+ {
+ // composite expression.
+ // make node early so we get the right line number.
+ yyVAL.node = Nod(OCOMPLIT, nil, nil)
+ }
+ case 141:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:1022
+ {
+ yyVAL.node = Nod(OKEY, yyDollar[1].node, yyDollar[3].node)
+ }
+ case 142:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:1028
+ {
+ // These nodes do not carry line numbers.
+ // Since a composite literal commonly spans several lines,
+ // the line number on errors may be misleading.
+ // Introduce a wrapper node to give the correct line.
+ yyVAL.node = yyDollar[1].node
+ switch yyVAL.node.Op {
+ case ONAME, ONONAME, OTYPE, OPACK, OLITERAL:
+ yyVAL.node = Nod(OPAREN, yyVAL.node, nil)
+ yyVAL.node.Implicit = 1
+ }
+ }
+ case 143:
+ yyDollar = yyS[yypt-4 : yypt+1]
+ //line go.y:1041
+ {
+ yyVAL.node = yyDollar[2].node
+ yyVAL.node.List = yyDollar[3].list
+ }
+ case 144:
+ yyVAL.node = yyS[yypt-0].node
+ case 145:
+ yyDollar = yyS[yypt-4 : yypt+1]
+ //line go.y:1049
+ {
+ yyVAL.node = yyDollar[2].node
+ yyVAL.node.List = yyDollar[3].list
+ }
+ case 146:
+ yyVAL.node = yyS[yypt-0].node
+ case 147:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:1057
+ {
+ yyVAL.node = yyDollar[2].node
+
+ // Need to know on lhs of := whether there are ( ).
+ // Don't bother with the OPAREN in other cases:
+ // it's just a waste of memory and time.
+ switch yyVAL.node.Op {
+ case ONAME, ONONAME, OPACK, OTYPE, OLITERAL, OTYPESW:
+ yyVAL.node = Nod(OPAREN, yyVAL.node, nil)
+ }
+ }
+ case 148:
+ yyVAL.node = yyS[yypt-0].node
+ case 149:
+ yyVAL.node = yyS[yypt-0].node
+ case 150:
+ yyVAL.node = yyS[yypt-0].node
+ case 151:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:1078
+ {
+ yyVAL.i = LBODY
+ }
+ case 152:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:1082
+ {
+ yyVAL.i = '{'
+ }
+ case 153:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:1093
+ {
+ if yyDollar[1].sym == nil {
+ yyVAL.node = nil
+ } else {
+ yyVAL.node = newname(yyDollar[1].sym)
+ }
+ }
+ case 154:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:1103
+ {
+ yyVAL.node = dclname(yyDollar[1].sym)
+ }
+ case 155:
+ yyDollar = yyS[yypt-0 : yypt+1]
+ //line go.y:1108
+ {
+ yyVAL.node = nil
+ }
+ case 156:
+ yyVAL.node = yyS[yypt-0].node
+ case 157:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:1115
+ {
+ yyVAL.sym = yyDollar[1].sym
+ // during imports, unqualified non-exported identifiers are from builtinpkg
+ if importpkg != nil && !exportname(yyDollar[1].sym.Name) {
+ yyVAL.sym = Pkglookup(yyDollar[1].sym.Name, builtinpkg)
+ }
+ }
+ case 158:
+ yyVAL.sym = yyS[yypt-0].sym
+ case 159:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:1124
+ {
+ yyVAL.sym = nil
+ }
+ case 160:
+ yyDollar = yyS[yypt-4 : yypt+1]
+ //line go.y:1130
+ {
+ var p *Pkg
+
+ if yyDollar[2].val.U.Sval.S == "" {
+ p = importpkg
+ } else {
+ if isbadimport(yyDollar[2].val.U.Sval) {
+ errorexit()
+ }
+ p = mkpkg(yyDollar[2].val.U.Sval)
+ }
+ yyVAL.sym = Pkglookup(yyDollar[4].sym.Name, p)
+ }
+ case 161:
+ yyDollar = yyS[yypt-4 : yypt+1]
+ //line go.y:1144
+ {
+ var p *Pkg
+
+ if yyDollar[2].val.U.Sval.S == "" {
+ p = importpkg
+ } else {
+ if isbadimport(yyDollar[2].val.U.Sval) {
+ errorexit()
+ }
+ p = mkpkg(yyDollar[2].val.U.Sval)
+ }
+ yyVAL.sym = Pkglookup("?", p)
+ }
+ case 162:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:1160
+ {
+ yyVAL.node = oldname(yyDollar[1].sym)
+ if yyVAL.node.Pack != nil {
+ yyVAL.node.Pack.Used = 1
+ }
+ }
+ case 163:
+ yyVAL.node = yyS[yypt-0].node
+ case 164:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:1181
+ {
+ Yyerror("final argument in variadic function missing type")
+ yyVAL.node = Nod(ODDD, typenod(typ(TINTER)), nil)
+ }
+ case 165:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:1186
+ {
+ yyVAL.node = Nod(ODDD, yyDollar[2].node, nil)
+ }
+ case 166:
+ yyVAL.node = yyS[yypt-0].node
+ case 167:
+ yyVAL.node = yyS[yypt-0].node
+ case 168:
+ yyVAL.node = yyS[yypt-0].node
+ case 169:
+ yyVAL.node = yyS[yypt-0].node
+ case 170:
+ yyVAL.node = yyS[yypt-0].node
+ case 171:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:1197
+ {
+ yyVAL.node = yyDollar[2].node
+ }
+ case 172:
+ yyVAL.node = yyS[yypt-0].node
+ case 173:
+ yyVAL.node = yyS[yypt-0].node
+ case 174:
+ yyVAL.node = yyS[yypt-0].node
+ case 175:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:1206
+ {
+ yyVAL.node = Nod(OIND, yyDollar[2].node, nil)
+ }
+ case 176:
+ yyVAL.node = yyS[yypt-0].node
+ case 177:
+ yyVAL.node = yyS[yypt-0].node
+ case 178:
+ yyVAL.node = yyS[yypt-0].node
+ case 179:
+ yyVAL.node = yyS[yypt-0].node
+ case 180:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:1216
+ {
+ yyVAL.node = yyDollar[2].node
+ }
+ case 181:
+ yyVAL.node = yyS[yypt-0].node
+ case 182:
+ yyVAL.node = yyS[yypt-0].node
+ case 183:
+ yyVAL.node = yyS[yypt-0].node
+ case 184:
+ yyVAL.node = yyS[yypt-0].node
+ case 185:
+ yyVAL.node = yyS[yypt-0].node
+ case 186:
+ yyVAL.node = yyS[yypt-0].node
+ case 187:
+ yyVAL.node = yyS[yypt-0].node
+ case 188:
+ yyVAL.node = yyS[yypt-0].node
+ case 189:
+ yyVAL.node = yyS[yypt-0].node
+ case 190:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:1237
+ {
+ if yyDollar[1].node.Op == OPACK {
+ var s *Sym
+ s = restrictlookup(yyDollar[3].sym.Name, yyDollar[1].node.Pkg)
+ yyDollar[1].node.Used = 1
+ yyVAL.node = oldname(s)
+ break
+ }
+ yyVAL.node = Nod(OXDOT, yyDollar[1].node, newname(yyDollar[3].sym))
+ }
+ case 191:
+ yyDollar = yyS[yypt-4 : yypt+1]
+ //line go.y:1250
+ {
+ yyVAL.node = Nod(OTARRAY, yyDollar[2].node, yyDollar[4].node)
+ }
+ case 192:
+ yyDollar = yyS[yypt-4 : yypt+1]
+ //line go.y:1254
+ {
+ // array literal of nelem
+ yyVAL.node = Nod(OTARRAY, Nod(ODDD, nil, nil), yyDollar[4].node)
+ }
+ case 193:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:1259
+ {
+ yyVAL.node = Nod(OTCHAN, yyDollar[2].node, nil)
+ yyVAL.node.Etype = Cboth
+ }
+ case 194:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:1264
+ {
+ yyVAL.node = Nod(OTCHAN, yyDollar[3].node, nil)
+ yyVAL.node.Etype = Csend
+ }
+ case 195:
+ yyDollar = yyS[yypt-5 : yypt+1]
+ //line go.y:1269
+ {
+ yyVAL.node = Nod(OTMAP, yyDollar[3].node, yyDollar[5].node)
+ }
+ case 196:
+ yyVAL.node = yyS[yypt-0].node
+ case 197:
+ yyVAL.node = yyS[yypt-0].node
+ case 198:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:1277
+ {
+ yyVAL.node = Nod(OIND, yyDollar[2].node, nil)
+ }
+ case 199:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:1283
+ {
+ yyVAL.node = Nod(OTCHAN, yyDollar[3].node, nil)
+ yyVAL.node.Etype = Crecv
+ }
+ case 200:
+ yyDollar = yyS[yypt-5 : yypt+1]
+ //line go.y:1290
+ {
+ yyVAL.node = Nod(OTSTRUCT, nil, nil)
+ yyVAL.node.List = yyDollar[3].list
+ fixlbrace(yyDollar[2].i)
+ }
+ case 201:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:1296
+ {
+ yyVAL.node = Nod(OTSTRUCT, nil, nil)
+ fixlbrace(yyDollar[2].i)
+ }
+ case 202:
+ yyDollar = yyS[yypt-5 : yypt+1]
+ //line go.y:1303
+ {
+ yyVAL.node = Nod(OTINTER, nil, nil)
+ yyVAL.node.List = yyDollar[3].list
+ fixlbrace(yyDollar[2].i)
+ }
+ case 203:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:1309
+ {
+ yyVAL.node = Nod(OTINTER, nil, nil)
+ fixlbrace(yyDollar[2].i)
+ }
+ case 204:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:1320
+ {
+ yyVAL.node = yyDollar[2].node
+ if yyVAL.node == nil {
+ break
+ }
+ if noescape && yyDollar[3].list != nil {
+ Yyerror("can only use //go:noescape with external func implementations")
+ }
+ yyVAL.node.Nbody = yyDollar[3].list
+ yyVAL.node.Endlineno = lineno
+ yyVAL.node.Noescape = noescape
+ yyVAL.node.Nosplit = nosplit
+ yyVAL.node.Nowritebarrier = nowritebarrier
+ funcbody(yyVAL.node)
+ }
+ case 205:
+ yyDollar = yyS[yypt-5 : yypt+1]
+ //line go.y:1338
+ {
+ var t *Node
+
+ yyVAL.node = nil
+ yyDollar[3].list = checkarglist(yyDollar[3].list, 1)
+
+ if yyDollar[1].sym.Name == "init" {
+ yyDollar[1].sym = renameinit()
+ if yyDollar[3].list != nil || yyDollar[5].list != nil {
+ Yyerror("func init must have no arguments and no return values")
+ }
+ }
+ if localpkg.Name == "main" && yyDollar[1].sym.Name == "main" {
+ if yyDollar[3].list != nil || yyDollar[5].list != nil {
+ Yyerror("func main must have no arguments and no return values")
+ }
+ }
+
+ t = Nod(OTFUNC, nil, nil)
+ t.List = yyDollar[3].list
+ t.Rlist = yyDollar[5].list
+
+ yyVAL.node = Nod(ODCLFUNC, nil, nil)
+ yyVAL.node.Nname = newname(yyDollar[1].sym)
+ yyVAL.node.Nname.Defn = yyVAL.node
+ yyVAL.node.Nname.Ntype = t // TODO: check if nname already has an ntype
+ declare(yyVAL.node.Nname, PFUNC)
+
+ funchdr(yyVAL.node)
+ }
+ case 206:
+ yyDollar = yyS[yypt-8 : yypt+1]
+ //line go.y:1369
+ {
+ var rcvr, t *Node
+
+ yyVAL.node = nil
+ yyDollar[2].list = checkarglist(yyDollar[2].list, 0)
+ yyDollar[6].list = checkarglist(yyDollar[6].list, 1)
+
+ if yyDollar[2].list == nil {
+ Yyerror("method has no receiver")
+ break
+ }
+ if yyDollar[2].list.Next != nil {
+ Yyerror("method has multiple receivers")
+ break
+ }
+ rcvr = yyDollar[2].list.N
+ if rcvr.Op != ODCLFIELD {
+ Yyerror("bad receiver in method")
+ break
+ }
+
+ t = Nod(OTFUNC, rcvr, nil)
+ t.List = yyDollar[6].list
+ t.Rlist = yyDollar[8].list
+
+ yyVAL.node = Nod(ODCLFUNC, nil, nil)
+ yyVAL.node.Shortname = newname(yyDollar[4].sym)
+ yyVAL.node.Nname = methodname1(yyVAL.node.Shortname, rcvr.Right)
+ yyVAL.node.Nname.Defn = yyVAL.node
+ yyVAL.node.Nname.Ntype = t
+ yyVAL.node.Nname.Nointerface = nointerface
+ declare(yyVAL.node.Nname, PFUNC)
+
+ funchdr(yyVAL.node)
+ }
+ case 207:
+ yyDollar = yyS[yypt-5 : yypt+1]
+ //line go.y:1407
+ {
+ var s *Sym
+ var t *Type
+
+ yyVAL.node = nil
+
+ s = yyDollar[1].sym
+ t = functype(nil, yyDollar[3].list, yyDollar[5].list)
+
+ importsym(s, ONAME)
+ if s.Def != nil && s.Def.Op == ONAME {
+ if Eqtype(t, s.Def.Type) {
+ dclcontext = PDISCARD // since we skip funchdr below
+ break
+ }
+ Yyerror("inconsistent definition for func %v during import\n\t%v\n\t%v", Sconv(s, 0), Tconv(s.Def.Type, 0), Tconv(t, 0))
+ }
+
+ yyVAL.node = newname(s)
+ yyVAL.node.Type = t
+ declare(yyVAL.node, PFUNC)
+
+ funchdr(yyVAL.node)
+ }
+ case 208:
+ yyDollar = yyS[yypt-8 : yypt+1]
+ //line go.y:1432
+ {
+ yyVAL.node = methodname1(newname(yyDollar[4].sym), yyDollar[2].list.N.Right)
+ yyVAL.node.Type = functype(yyDollar[2].list.N, yyDollar[6].list, yyDollar[8].list)
+
+ checkwidth(yyVAL.node.Type)
+ addmethod(yyDollar[4].sym, yyVAL.node.Type, false, nointerface)
+ nointerface = false
+ funchdr(yyVAL.node)
+
+ // inl.C's inlnode in on a dotmeth node expects to find the inlineable body as
+ // (dotmeth's type).Nname.Inl, and dotmeth's type has been pulled
+ // out by typecheck's lookdot as this $$.ttype. So by providing
+ // this back link here we avoid special casing there.
+ yyVAL.node.Type.Nname = yyVAL.node
+ }
+ case 209:
+ yyDollar = yyS[yypt-5 : yypt+1]
+ //line go.y:1450
+ {
+ yyDollar[3].list = checkarglist(yyDollar[3].list, 1)
+ yyVAL.node = Nod(OTFUNC, nil, nil)
+ yyVAL.node.List = yyDollar[3].list
+ yyVAL.node.Rlist = yyDollar[5].list
+ }
+ case 210:
+ yyDollar = yyS[yypt-0 : yypt+1]
+ //line go.y:1458
+ {
+ yyVAL.list = nil
+ }
+ case 211:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:1462
+ {
+ yyVAL.list = yyDollar[2].list
+ if yyVAL.list == nil {
+ yyVAL.list = list1(Nod(OEMPTY, nil, nil))
+ }
+ }
+ case 212:
+ yyDollar = yyS[yypt-0 : yypt+1]
+ //line go.y:1471
+ {
+ yyVAL.list = nil
+ }
+ case 213:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:1475
+ {
+ yyVAL.list = list1(Nod(ODCLFIELD, nil, yyDollar[1].node))
+ }
+ case 214:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:1479
+ {
+ yyDollar[2].list = checkarglist(yyDollar[2].list, 0)
+ yyVAL.list = yyDollar[2].list
+ }
+ case 215:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:1486
+ {
+ closurehdr(yyDollar[1].node)
+ }
+ case 216:
+ yyDollar = yyS[yypt-4 : yypt+1]
+ //line go.y:1492
+ {
+ yyVAL.node = closurebody(yyDollar[3].list)
+ fixlbrace(yyDollar[2].i)
+ }
+ case 217:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:1497
+ {
+ yyVAL.node = closurebody(nil)
+ }
+ case 218:
+ yyDollar = yyS[yypt-0 : yypt+1]
+ //line go.y:1508
+ {
+ yyVAL.list = nil
+ }
+ case 219:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:1512
+ {
+ yyVAL.list = concat(yyDollar[1].list, yyDollar[2].list)
+ if nsyntaxerrors == 0 {
+ testdclstack()
+ }
+ nointerface = false
+ noescape = false
+ nosplit = false
+ nowritebarrier = false
+ }
+ case 220:
+ yyVAL.list = yyS[yypt-0].list
+ case 221:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:1526
+ {
+ yyVAL.list = concat(yyDollar[1].list, yyDollar[3].list)
+ }
+ case 222:
+ yyVAL.list = yyS[yypt-0].list
+ case 223:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:1533
+ {
+ yyVAL.list = concat(yyDollar[1].list, yyDollar[3].list)
+ }
+ case 224:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:1539
+ {
+ yyVAL.list = list1(yyDollar[1].node)
+ }
+ case 225:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:1543
+ {
+ yyVAL.list = list(yyDollar[1].list, yyDollar[3].node)
+ }
+ case 226:
+ yyVAL.list = yyS[yypt-0].list
+ case 227:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:1550
+ {
+ yyVAL.list = concat(yyDollar[1].list, yyDollar[3].list)
+ }
+ case 228:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:1556
+ {
+ yyVAL.list = list1(yyDollar[1].node)
+ }
+ case 229:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:1560
+ {
+ yyVAL.list = list(yyDollar[1].list, yyDollar[3].node)
+ }
+ case 230:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:1566
+ {
+ var l *NodeList
+
+ var n *Node
+ l = yyDollar[1].list
+ if l == nil {
+ // ? symbol, during import (list1(nil) == nil)
+ n = yyDollar[2].node
+ if n.Op == OIND {
+ n = n.Left
+ }
+ n = embedded(n.Sym, importpkg)
+ n.Right = yyDollar[2].node
+ n.Val = yyDollar[3].val
+ yyVAL.list = list1(n)
+ break
+ }
+
+ for l = yyDollar[1].list; l != nil; l = l.Next {
+ l.N = Nod(ODCLFIELD, l.N, yyDollar[2].node)
+ l.N.Val = yyDollar[3].val
+ }
+ }
+ case 231:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:1590
+ {
+ yyDollar[1].node.Val = yyDollar[2].val
+ yyVAL.list = list1(yyDollar[1].node)
+ }
+ case 232:
+ yyDollar = yyS[yypt-4 : yypt+1]
+ //line go.y:1595
+ {
+ yyDollar[2].node.Val = yyDollar[4].val
+ yyVAL.list = list1(yyDollar[2].node)
+ Yyerror("cannot parenthesize embedded type")
+ }
+ case 233:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:1601
+ {
+ yyDollar[2].node.Right = Nod(OIND, yyDollar[2].node.Right, nil)
+ yyDollar[2].node.Val = yyDollar[3].val
+ yyVAL.list = list1(yyDollar[2].node)
+ }
+ case 234:
+ yyDollar = yyS[yypt-5 : yypt+1]
+ //line go.y:1607
+ {
+ yyDollar[3].node.Right = Nod(OIND, yyDollar[3].node.Right, nil)
+ yyDollar[3].node.Val = yyDollar[5].val
+ yyVAL.list = list1(yyDollar[3].node)
+ Yyerror("cannot parenthesize embedded type")
+ }
+ case 235:
+ yyDollar = yyS[yypt-5 : yypt+1]
+ //line go.y:1614
+ {
+ yyDollar[3].node.Right = Nod(OIND, yyDollar[3].node.Right, nil)
+ yyDollar[3].node.Val = yyDollar[5].val
+ yyVAL.list = list1(yyDollar[3].node)
+ Yyerror("cannot parenthesize embedded type")
+ }
+ case 236:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:1623
+ {
+ var n *Node
+
+ yyVAL.sym = yyDollar[1].sym
+ n = oldname(yyDollar[1].sym)
+ if n.Pack != nil {
+ n.Pack.Used = 1
+ }
+ }
+ case 237:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:1633
+ {
+ var pkg *Pkg
+
+ if yyDollar[1].sym.Def == nil || yyDollar[1].sym.Def.Op != OPACK {
+ Yyerror("%v is not a package", Sconv(yyDollar[1].sym, 0))
+ pkg = localpkg
+ } else {
+ yyDollar[1].sym.Def.Used = 1
+ pkg = yyDollar[1].sym.Def.Pkg
+ }
+ yyVAL.sym = restrictlookup(yyDollar[3].sym.Name, pkg)
+ }
+ case 238:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:1648
+ {
+ yyVAL.node = embedded(yyDollar[1].sym, localpkg)
+ }
+ case 239:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:1654
+ {
+ yyVAL.node = Nod(ODCLFIELD, yyDollar[1].node, yyDollar[2].node)
+ ifacedcl(yyVAL.node)
+ }
+ case 240:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:1659
+ {
+ yyVAL.node = Nod(ODCLFIELD, nil, oldname(yyDollar[1].sym))
+ }
+ case 241:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:1663
+ {
+ yyVAL.node = Nod(ODCLFIELD, nil, oldname(yyDollar[2].sym))
+ Yyerror("cannot parenthesize embedded type")
+ }
+ case 242:
+ yyDollar = yyS[yypt-4 : yypt+1]
+ //line go.y:1670
+ {
+ // without func keyword
+ yyDollar[2].list = checkarglist(yyDollar[2].list, 1)
+ yyVAL.node = Nod(OTFUNC, fakethis(), nil)
+ yyVAL.node.List = yyDollar[2].list
+ yyVAL.node.Rlist = yyDollar[4].list
+ }
+ case 243:
+ yyVAL.node = yyS[yypt-0].node
+ case 244:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:1684
+ {
+ yyVAL.node = Nod(ONONAME, nil, nil)
+ yyVAL.node.Sym = yyDollar[1].sym
+ yyVAL.node = Nod(OKEY, yyVAL.node, yyDollar[2].node)
+ }
+ case 245:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:1690
+ {
+ yyVAL.node = Nod(ONONAME, nil, nil)
+ yyVAL.node.Sym = yyDollar[1].sym
+ yyVAL.node = Nod(OKEY, yyVAL.node, yyDollar[2].node)
+ }
+ case 246:
+ yyVAL.node = yyS[yypt-0].node
+ case 247:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:1699
+ {
+ yyVAL.list = list1(yyDollar[1].node)
+ }
+ case 248:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:1703
+ {
+ yyVAL.list = list(yyDollar[1].list, yyDollar[3].node)
+ }
+ case 249:
+ yyDollar = yyS[yypt-0 : yypt+1]
+ //line go.y:1708
+ {
+ yyVAL.list = nil
+ }
+ case 250:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:1712
+ {
+ yyVAL.list = yyDollar[1].list
+ }
+ case 251:
+ yyDollar = yyS[yypt-0 : yypt+1]
+ //line go.y:1720
+ {
+ yyVAL.node = nil
+ }
+ case 252:
+ yyVAL.node = yyS[yypt-0].node
+ case 253:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:1725
+ {
+ yyVAL.node = liststmt(yyDollar[1].list)
+ }
+ case 254:
+ yyVAL.node = yyS[yypt-0].node
+ case 255:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:1730
+ {
+ yyVAL.node = nil
+ }
+ case 256:
+ yyVAL.node = yyS[yypt-0].node
+ case 257:
+ yyVAL.node = yyS[yypt-0].node
+ case 258:
+ yyVAL.node = yyS[yypt-0].node
+ case 259:
+ yyVAL.node = yyS[yypt-0].node
+ case 260:
+ yyVAL.node = yyS[yypt-0].node
+ case 261:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:1741
+ {
+ yyDollar[1].node = Nod(OLABEL, yyDollar[1].node, nil)
+ yyDollar[1].node.Sym = dclstack // context, for goto restrictions
+ }
+ case 262:
+ yyDollar = yyS[yypt-4 : yypt+1]
+ //line go.y:1746
+ {
+ var l *NodeList
+
+ yyDollar[1].node.Defn = yyDollar[4].node
+ l = list1(yyDollar[1].node)
+ if yyDollar[4].node != nil {
+ l = list(l, yyDollar[4].node)
+ }
+ yyVAL.node = liststmt(l)
+ }
+ case 263:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:1757
+ {
+ // will be converted to OFALL
+ yyVAL.node = Nod(OXFALL, nil, nil)
+ yyVAL.node.Xoffset = int64(block)
+ }
+ case 264:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:1763
+ {
+ yyVAL.node = Nod(OBREAK, yyDollar[2].node, nil)
+ }
+ case 265:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:1767
+ {
+ yyVAL.node = Nod(OCONTINUE, yyDollar[2].node, nil)
+ }
+ case 266:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:1771
+ {
+ yyVAL.node = Nod(OPROC, yyDollar[2].node, nil)
+ }
+ case 267:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:1775
+ {
+ yyVAL.node = Nod(ODEFER, yyDollar[2].node, nil)
+ }
+ case 268:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:1779
+ {
+ yyVAL.node = Nod(OGOTO, yyDollar[2].node, nil)
+ yyVAL.node.Sym = dclstack // context, for goto restrictions
+ }
+ case 269:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:1784
+ {
+ yyVAL.node = Nod(ORETURN, nil, nil)
+ yyVAL.node.List = yyDollar[2].list
+ if yyVAL.node.List == nil && Curfn != nil {
+ var l *NodeList
+
+ for l = Curfn.Dcl; l != nil; l = l.Next {
+ if l.N.Class == PPARAM {
+ continue
+ }
+ if l.N.Class != PPARAMOUT {
+ break
+ }
+ if l.N.Sym.Def != l.N {
+ Yyerror("%s is shadowed during return", l.N.Sym.Name)
+ }
+ }
+ }
+ }
+ case 270:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:1806
+ {
+ yyVAL.list = nil
+ if yyDollar[1].node != nil {
+ yyVAL.list = list1(yyDollar[1].node)
+ }
+ }
+ case 271:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:1813
+ {
+ yyVAL.list = yyDollar[1].list
+ if yyDollar[3].node != nil {
+ yyVAL.list = list(yyVAL.list, yyDollar[3].node)
+ }
+ }
+ case 272:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:1822
+ {
+ yyVAL.list = list1(yyDollar[1].node)
+ }
+ case 273:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:1826
+ {
+ yyVAL.list = list(yyDollar[1].list, yyDollar[3].node)
+ }
+ case 274:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:1832
+ {
+ yyVAL.list = list1(yyDollar[1].node)
+ }
+ case 275:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:1836
+ {
+ yyVAL.list = list(yyDollar[1].list, yyDollar[3].node)
+ }
+ case 276:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:1842
+ {
+ yyVAL.list = list1(yyDollar[1].node)
+ }
+ case 277:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:1846
+ {
+ yyVAL.list = list(yyDollar[1].list, yyDollar[3].node)
+ }
+ case 278:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:1852
+ {
+ yyVAL.list = list1(yyDollar[1].node)
+ }
+ case 279:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:1856
+ {
+ yyVAL.list = list(yyDollar[1].list, yyDollar[3].node)
+ }
+ case 280:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:1865
+ {
+ yyVAL.list = list1(yyDollar[1].node)
+ }
+ case 281:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:1869
+ {
+ yyVAL.list = list1(yyDollar[1].node)
+ }
+ case 282:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:1873
+ {
+ yyVAL.list = list(yyDollar[1].list, yyDollar[3].node)
+ }
+ case 283:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:1877
+ {
+ yyVAL.list = list(yyDollar[1].list, yyDollar[3].node)
+ }
+ case 284:
+ yyDollar = yyS[yypt-0 : yypt+1]
+ //line go.y:1882
+ {
+ yyVAL.list = nil
+ }
+ case 285:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:1886
+ {
+ yyVAL.list = yyDollar[1].list
+ }
+ case 290:
+ yyDollar = yyS[yypt-0 : yypt+1]
+ //line go.y:1900
+ {
+ yyVAL.node = nil
+ }
+ case 291:
+ yyVAL.node = yyS[yypt-0].node
+ case 292:
+ yyDollar = yyS[yypt-0 : yypt+1]
+ //line go.y:1906
+ {
+ yyVAL.list = nil
+ }
+ case 293:
+ yyVAL.list = yyS[yypt-0].list
+ case 294:
+ yyDollar = yyS[yypt-0 : yypt+1]
+ //line go.y:1912
+ {
+ yyVAL.node = nil
+ }
+ case 295:
+ yyVAL.node = yyS[yypt-0].node
+ case 296:
+ yyDollar = yyS[yypt-0 : yypt+1]
+ //line go.y:1918
+ {
+ yyVAL.list = nil
+ }
+ case 297:
+ yyVAL.list = yyS[yypt-0].list
+ case 298:
+ yyDollar = yyS[yypt-0 : yypt+1]
+ //line go.y:1924
+ {
+ yyVAL.list = nil
+ }
+ case 299:
+ yyVAL.list = yyS[yypt-0].list
+ case 300:
+ yyDollar = yyS[yypt-0 : yypt+1]
+ //line go.y:1930
+ {
+ yyVAL.list = nil
+ }
+ case 301:
+ yyVAL.list = yyS[yypt-0].list
+ case 302:
+ yyDollar = yyS[yypt-0 : yypt+1]
+ //line go.y:1936
+ {
+ yyVAL.val.Ctype = CTxxx
+ }
+ case 303:
+ yyVAL.val = yyS[yypt-0].val
+ case 304:
+ yyDollar = yyS[yypt-4 : yypt+1]
+ //line go.y:1946
+ {
+ importimport(yyDollar[2].sym, yyDollar[3].val.U.Sval)
+ }
+ case 305:
+ yyDollar = yyS[yypt-4 : yypt+1]
+ //line go.y:1950
+ {
+ importvar(yyDollar[2].sym, yyDollar[3].typ)
+ }
+ case 306:
+ yyDollar = yyS[yypt-5 : yypt+1]
+ //line go.y:1954
+ {
+ importconst(yyDollar[2].sym, Types[TIDEAL], yyDollar[4].node)
+ }
+ case 307:
+ yyDollar = yyS[yypt-6 : yypt+1]
+ //line go.y:1958
+ {
+ importconst(yyDollar[2].sym, yyDollar[3].typ, yyDollar[5].node)
+ }
+ case 308:
+ yyDollar = yyS[yypt-4 : yypt+1]
+ //line go.y:1962
+ {
+ importtype(yyDollar[2].typ, yyDollar[3].typ)
+ }
+ case 309:
+ yyDollar = yyS[yypt-4 : yypt+1]
+ //line go.y:1966
+ {
+ if yyDollar[2].node == nil {
+ dclcontext = PEXTERN // since we skip the funcbody below
+ break
+ }
+
+ yyDollar[2].node.Inl = yyDollar[3].list
+
+ funcbody(yyDollar[2].node)
+ importlist = list(importlist, yyDollar[2].node)
+
+ if Debug['E'] > 0 {
+ print("import [%v] func %lN \n", Zconv(importpkg.Path, 0), yyDollar[2].node)
+ if Debug['m'] > 2 && yyDollar[2].node.Inl != nil {
+ print("inl body:%+H\n", yyDollar[2].node.Inl)
+ }
+ }
+ }
+ case 310:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:1987
+ {
+ yyVAL.sym = yyDollar[1].sym
+ structpkg = yyVAL.sym.Pkg
+ }
+ case 311:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:1994
+ {
+ yyVAL.typ = pkgtype(yyDollar[1].sym)
+ importsym(yyDollar[1].sym, OTYPE)
+ }
+ case 312:
+ yyVAL.typ = yyS[yypt-0].typ
+ case 313:
+ yyVAL.typ = yyS[yypt-0].typ
+ case 314:
+ yyVAL.typ = yyS[yypt-0].typ
+ case 315:
+ yyVAL.typ = yyS[yypt-0].typ
+ case 316:
+ yyVAL.typ = yyS[yypt-0].typ
+ case 317:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:2014
+ {
+ yyVAL.typ = pkgtype(yyDollar[1].sym)
+ }
+ case 318:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:2018
+ {
+ // predefined name like uint8
+ yyDollar[1].sym = Pkglookup(yyDollar[1].sym.Name, builtinpkg)
+ if yyDollar[1].sym.Def == nil || yyDollar[1].sym.Def.Op != OTYPE {
+ Yyerror("%s is not a type", yyDollar[1].sym.Name)
+ yyVAL.typ = nil
+ } else {
+ yyVAL.typ = yyDollar[1].sym.Def.Type
+ }
+ }
+ case 319:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:2029
+ {
+ yyVAL.typ = aindex(nil, yyDollar[3].typ)
+ }
+ case 320:
+ yyDollar = yyS[yypt-4 : yypt+1]
+ //line go.y:2033
+ {
+ yyVAL.typ = aindex(nodlit(yyDollar[2].val), yyDollar[4].typ)
+ }
+ case 321:
+ yyDollar = yyS[yypt-5 : yypt+1]
+ //line go.y:2037
+ {
+ yyVAL.typ = maptype(yyDollar[3].typ, yyDollar[5].typ)
+ }
+ case 322:
+ yyDollar = yyS[yypt-4 : yypt+1]
+ //line go.y:2041
+ {
+ yyVAL.typ = tostruct(yyDollar[3].list)
+ }
+ case 323:
+ yyDollar = yyS[yypt-4 : yypt+1]
+ //line go.y:2045
+ {
+ yyVAL.typ = tointerface(yyDollar[3].list)
+ }
+ case 324:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:2049
+ {
+ yyVAL.typ = Ptrto(yyDollar[2].typ)
+ }
+ case 325:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:2053
+ {
+ yyVAL.typ = typ(TCHAN)
+ yyVAL.typ.Type = yyDollar[2].typ
+ yyVAL.typ.Chan = Cboth
+ }
+ case 326:
+ yyDollar = yyS[yypt-4 : yypt+1]
+ //line go.y:2059
+ {
+ yyVAL.typ = typ(TCHAN)
+ yyVAL.typ.Type = yyDollar[3].typ
+ yyVAL.typ.Chan = Cboth
+ }
+ case 327:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:2065
+ {
+ yyVAL.typ = typ(TCHAN)
+ yyVAL.typ.Type = yyDollar[3].typ
+ yyVAL.typ.Chan = Csend
+ }
+ case 328:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:2073
+ {
+ yyVAL.typ = typ(TCHAN)
+ yyVAL.typ.Type = yyDollar[3].typ
+ yyVAL.typ.Chan = Crecv
+ }
+ case 329:
+ yyDollar = yyS[yypt-5 : yypt+1]
+ //line go.y:2081
+ {
+ yyVAL.typ = functype(nil, yyDollar[3].list, yyDollar[5].list)
+ }
+ case 330:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:2087
+ {
+ yyVAL.node = Nod(ODCLFIELD, nil, typenod(yyDollar[2].typ))
+ if yyDollar[1].sym != nil {
+ yyVAL.node.Left = newname(yyDollar[1].sym)
+ }
+ yyVAL.node.Val = yyDollar[3].val
+ }
+ case 331:
+ yyDollar = yyS[yypt-4 : yypt+1]
+ //line go.y:2095
+ {
+ var t *Type
+
+ t = typ(TARRAY)
+ t.Bound = -1
+ t.Type = yyDollar[3].typ
+
+ yyVAL.node = Nod(ODCLFIELD, nil, typenod(t))
+ if yyDollar[1].sym != nil {
+ yyVAL.node.Left = newname(yyDollar[1].sym)
+ }
+ yyVAL.node.Isddd = 1
+ yyVAL.node.Val = yyDollar[4].val
+ }
+ case 332:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:2112
+ {
+ var s *Sym
+ var p *Pkg
+
+ if yyDollar[1].sym != nil && yyDollar[1].sym.Name != "?" {
+ yyVAL.node = Nod(ODCLFIELD, newname(yyDollar[1].sym), typenod(yyDollar[2].typ))
+ yyVAL.node.Val = yyDollar[3].val
+ } else {
+ s = yyDollar[2].typ.Sym
+ if s == nil && Isptr[yyDollar[2].typ.Etype] != 0 {
+ s = yyDollar[2].typ.Type.Sym
+ }
+ p = importpkg
+ if yyDollar[1].sym != nil {
+ p = yyDollar[1].sym.Pkg
+ }
+ yyVAL.node = embedded(s, p)
+ yyVAL.node.Right = typenod(yyDollar[2].typ)
+ yyVAL.node.Val = yyDollar[3].val
+ }
+ }
+ case 333:
+ yyDollar = yyS[yypt-5 : yypt+1]
+ //line go.y:2136
+ {
+ yyVAL.node = Nod(ODCLFIELD, newname(yyDollar[1].sym), typenod(functype(fakethis(), yyDollar[3].list, yyDollar[5].list)))
+ }
+ case 334:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:2140
+ {
+ yyVAL.node = Nod(ODCLFIELD, nil, typenod(yyDollar[1].typ))
+ }
+ case 335:
+ yyDollar = yyS[yypt-0 : yypt+1]
+ //line go.y:2145
+ {
+ yyVAL.list = nil
+ }
+ case 336:
+ yyVAL.list = yyS[yypt-0].list
+ case 337:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:2152
+ {
+ yyVAL.list = yyDollar[2].list
+ }
+ case 338:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:2156
+ {
+ yyVAL.list = list1(Nod(ODCLFIELD, nil, typenod(yyDollar[1].typ)))
+ }
+ case 339:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:2166
+ {
+ yyVAL.node = nodlit(yyDollar[1].val)
+ }
+ case 340:
+ yyDollar = yyS[yypt-2 : yypt+1]
+ //line go.y:2170
+ {
+ yyVAL.node = nodlit(yyDollar[2].val)
+ switch yyVAL.node.Val.Ctype {
+ case CTINT, CTRUNE:
+ mpnegfix(yyVAL.node.Val.U.Xval)
+ break
+ case CTFLT:
+ mpnegflt(yyVAL.node.Val.U.Fval)
+ break
+ case CTCPLX:
+ mpnegflt(&yyVAL.node.Val.U.Cval.Real)
+ mpnegflt(&yyVAL.node.Val.U.Cval.Imag)
+ break
+ default:
+ Yyerror("bad negated constant")
+ }
+ }
+ case 341:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:2188
+ {
+ yyVAL.node = oldname(Pkglookup(yyDollar[1].sym.Name, builtinpkg))
+ if yyVAL.node.Op != OLITERAL {
+ Yyerror("bad constant %v", Sconv(yyVAL.node.Sym, 0))
+ }
+ }
+ case 342:
+ yyVAL.node = yyS[yypt-0].node
+ case 343:
+ yyDollar = yyS[yypt-5 : yypt+1]
+ //line go.y:2198
+ {
+ if yyDollar[2].node.Val.Ctype == CTRUNE && yyDollar[4].node.Val.Ctype == CTINT {
+ yyVAL.node = yyDollar[2].node
+ mpaddfixfix(yyDollar[2].node.Val.U.Xval, yyDollar[4].node.Val.U.Xval, 0)
+ break
+ }
+ yyDollar[4].node.Val.U.Cval.Real = yyDollar[4].node.Val.U.Cval.Imag
+ Mpmovecflt(&yyDollar[4].node.Val.U.Cval.Imag, 0.0)
+ yyVAL.node = nodcplxlit(yyDollar[2].node.Val, yyDollar[4].node.Val)
+ }
+ case 346:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:2214
+ {
+ yyVAL.list = list1(yyDollar[1].node)
+ }
+ case 347:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:2218
+ {
+ yyVAL.list = list(yyDollar[1].list, yyDollar[3].node)
+ }
+ case 348:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:2224
+ {
+ yyVAL.list = list1(yyDollar[1].node)
+ }
+ case 349:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:2228
+ {
+ yyVAL.list = list(yyDollar[1].list, yyDollar[3].node)
+ }
+ case 350:
+ yyDollar = yyS[yypt-1 : yypt+1]
+ //line go.y:2234
+ {
+ yyVAL.list = list1(yyDollar[1].node)
+ }
+ case 351:
+ yyDollar = yyS[yypt-3 : yypt+1]
+ //line go.y:2238
+ {
+ yyVAL.list = list(yyDollar[1].list, yyDollar[3].node)
+ }
+ }
+ goto yystack /* stack new state and value */
+}
diff --git a/src/cmd/internal/gc/y.output b/src/cmd/internal/gc/y.output
new file mode 100644
index 0000000..e4a5e5c
--- /dev/null
+++ b/src/cmd/internal/gc/y.output
@@ -0,0 +1,10411 @@
+
+state 0
+ $accept: .file $end
+ $$4: . (4)
+
+ . reduce 4 (src line 148)
+
+ file goto 1
+ loadsys goto 2
+ $$4 goto 3
+
+state 1
+ $accept: file.$end
+
+ $end accept
+ . error
+
+
+state 2
+ file: loadsys.package imports xdcl_list
+ package: . (2)
+
+ LPACKAGE shift 5
+ . reduce 2 (src line 131)
+
+ package goto 4
+
+state 3
+ loadsys: $$4.import_package import_there
+
+ LPACKAGE shift 7
+ . error
+
+ import_package goto 6
+
+state 4
+ file: loadsys package.imports xdcl_list
+ imports: . (6)
+
+ . reduce 6 (src line 165)
+
+ imports goto 8
+
+state 5
+ package: LPACKAGE.sym ';'
+
+ LNAME shift 10
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 9
+ hidden_importsym goto 11
+
+state 6
+ loadsys: $$4 import_package.import_there
+ $$21: . (21)
+
+ . reduce 21 (src line 272)
+
+ import_there goto 14
+ $$21 goto 15
+
+state 7
+ import_package: LPACKAGE.LNAME import_safety ';'
+
+ LNAME shift 16
+ . error
+
+
+state 8
+ file: loadsys package imports.xdcl_list
+ imports: imports.import ';'
+ xdcl_list: . (218)
+
+ LIMPORT shift 19
+ . reduce 218 (src line 1507)
+
+ xdcl_list goto 17
+ import goto 18
+
+state 9
+ package: LPACKAGE sym.';'
+
+ ';' shift 20
+ . error
+
+
+state 10
+ sym: LNAME. (157)
+
+ . reduce 157 (src line 1113)
+
+
+state 11
+ sym: hidden_importsym. (158)
+
+ . reduce 158 (src line 1122)
+
+
+state 12
+ sym: '?'. (159)
+
+ . reduce 159 (src line 1123)
+
+
+state 13
+ hidden_importsym: '@'.LLITERAL '.' LNAME
+ hidden_importsym: '@'.LLITERAL '.' '?'
+
+ LLITERAL shift 21
+ . error
+
+
+state 14
+ loadsys: $$4 import_package import_there. (5)
+
+ . reduce 5 (src line 159)
+
+
+state 15
+ import_there: $$21.hidden_import_list '$' '$'
+ hidden_import_list: . (344)
+
+ . reduce 344 (src line 2209)
+
+ hidden_import_list goto 22
+
+state 16
+ import_package: LPACKAGE LNAME.import_safety ';'
+ import_safety: . (19)
+
+ LNAME shift 24
+ . reduce 19 (src line 264)
+
+ import_safety goto 23
+
+state 17
+ file: loadsys package imports xdcl_list. (1)
+ xdcl_list: xdcl_list.xdcl ';'
+ xdcl: . (23)
+
+ $end reduce 1 (src line 122)
+ error shift 29
+ LLITERAL shift 68
+ LBREAK shift 41
+ LCHAN shift 78
+ LCONST shift 47
+ LCONTINUE shift 42
+ LDEFER shift 44
+ LFALL shift 40
+ LFOR shift 50
+ LFUNC shift 33
+ LGO shift 43
+ LGOTO shift 45
+ LIF shift 53
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LRETURN shift 46
+ LSELECT shift 52
+ LSTRUCT shift 82
+ LSWITCH shift 51
+ LTYPE shift 32
+ LVAR shift 30
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ ';' reduce 23 (src line 285)
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 56
+ expr goto 48
+ fnliteral goto 73
+ for_stmt goto 35
+ if_stmt goto 38
+ non_dcl_stmt goto 28
+ labelname goto 39
+ name goto 69
+ new_name goto 54
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ select_stmt goto 37
+ simple_stmt goto 34
+ switch_stmt goto 36
+ uexpr goto 55
+ xfndcl goto 27
+ xdcl goto 25
+ expr_list goto 49
+ common_dcl goto 26
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ lconst goto 31
+ fnlitdcl goto 76
+
+state 18
+ imports: imports import.';'
+
+ ';' shift 84
+ . error
+
+
+state 19
+ import: LIMPORT.import_stmt
+ import: LIMPORT.'(' import_stmt_list osemi ')'
+ import: LIMPORT.'(' ')'
+
+ LLITERAL shift 88
+ LNAME shift 10
+ '(' shift 86
+ '.' shift 90
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ import_here goto 87
+ sym goto 89
+ hidden_importsym goto 11
+ import_stmt goto 85
+
+state 20
+ package: LPACKAGE sym ';'. (3)
+
+ . reduce 3 (src line 138)
+
+
+state 21
+ hidden_importsym: '@' LLITERAL.'.' LNAME
+ hidden_importsym: '@' LLITERAL.'.' '?'
+
+ '.' shift 91
+ . error
+
+
+state 22
+ import_there: $$21 hidden_import_list.'$' '$'
+ hidden_import_list: hidden_import_list.hidden_import
+
+ LCONST shift 96
+ LFUNC shift 98
+ LIMPORT shift 94
+ LTYPE shift 97
+ LVAR shift 95
+ '$' shift 92
+ . error
+
+ hidden_import goto 93
+
+state 23
+ import_package: LPACKAGE LNAME import_safety.';'
+
+ ';' shift 99
+ . error
+
+
+state 24
+ import_safety: LNAME. (20)
+
+ . reduce 20 (src line 265)
+
+
+state 25
+ xdcl_list: xdcl_list xdcl.';'
+
+ ';' shift 100
+ . error
+
+
+state 26
+ xdcl: common_dcl. (24)
+
+ . reduce 24 (src line 290)
+
+
+state 27
+ xdcl: xfndcl. (25)
+
+ . reduce 25 (src line 291)
+
+
+state 28
+ xdcl: non_dcl_stmt. (26)
+
+ . reduce 26 (src line 295)
+
+
+state 29
+ xdcl: error. (27)
+
+ . reduce 27 (src line 300)
+
+
+state 30
+ common_dcl: LVAR.vardcl
+ common_dcl: LVAR.'(' vardcl_list osemi ')'
+ common_dcl: LVAR.'(' ')'
+
+ LNAME shift 10
+ '(' shift 102
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 105
+ dcl_name goto 104
+ dcl_name_list goto 103
+ vardcl goto 101
+ hidden_importsym goto 11
+
+state 31
+ common_dcl: lconst.constdcl
+ common_dcl: lconst.'(' constdcl osemi ')'
+ common_dcl: lconst.'(' constdcl ';' constdcl_list osemi ')'
+ common_dcl: lconst.'(' ')'
+
+ LNAME shift 10
+ '(' shift 107
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 105
+ dcl_name goto 104
+ dcl_name_list goto 108
+ constdcl goto 106
+ hidden_importsym goto 11
+
+state 32
+ common_dcl: LTYPE.typedcl
+ common_dcl: LTYPE.'(' typedcl_list osemi ')'
+ common_dcl: LTYPE.'(' ')'
+
+ LNAME shift 10
+ '(' shift 110
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 112
+ typedclname goto 111
+ typedcl goto 109
+ hidden_importsym goto 11
+
+state 33
+ xfndcl: LFUNC.fndcl fnbody
+ fntype: LFUNC.'(' oarg_type_list_ocomma ')' fnres
+
+ LNAME shift 10
+ '(' shift 114
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 115
+ fndcl goto 113
+ hidden_importsym goto 11
+
+state 34
+ non_dcl_stmt: simple_stmt. (256)
+
+ . reduce 256 (src line 1734)
+
+
+state 35
+ non_dcl_stmt: for_stmt. (257)
+
+ . reduce 257 (src line 1736)
+
+
+state 36
+ non_dcl_stmt: switch_stmt. (258)
+
+ . reduce 258 (src line 1737)
+
+
+state 37
+ non_dcl_stmt: select_stmt. (259)
+
+ . reduce 259 (src line 1738)
+
+
+state 38
+ non_dcl_stmt: if_stmt. (260)
+
+ . reduce 260 (src line 1739)
+
+
+state 39
+ non_dcl_stmt: labelname.':' $$261 stmt
+
+ ':' shift 116
+ . error
+
+
+state 40
+ non_dcl_stmt: LFALL. (263)
+
+ . reduce 263 (src line 1756)
+
+
+state 41
+ non_dcl_stmt: LBREAK.onew_name
+ onew_name: . (155)
+
+ LNAME shift 10
+ '?' shift 12
+ '@' shift 13
+ . reduce 155 (src line 1107)
+
+ sym goto 119
+ new_name goto 118
+ onew_name goto 117
+ hidden_importsym goto 11
+
+state 42
+ non_dcl_stmt: LCONTINUE.onew_name
+ onew_name: . (155)
+
+ LNAME shift 10
+ '?' shift 12
+ '@' shift 13
+ . reduce 155 (src line 1107)
+
+ sym goto 119
+ new_name goto 118
+ onew_name goto 120
+ hidden_importsym goto 11
+
+state 43
+ non_dcl_stmt: LGO.pseudocall
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ '(' shift 67
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 122
+ pexpr_no_paren goto 66
+ pseudocall goto 121
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 44
+ non_dcl_stmt: LDEFER.pseudocall
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ '(' shift 67
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 122
+ pexpr_no_paren goto 66
+ pseudocall goto 125
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 45
+ non_dcl_stmt: LGOTO.new_name
+
+ LNAME shift 10
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 119
+ new_name goto 126
+ hidden_importsym goto 11
+
+state 46
+ non_dcl_stmt: LRETURN.oexpr_list
+ oexpr_list: . (292)
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . reduce 292 (src line 1905)
+
+ sym goto 123
+ expr goto 129
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ expr_list goto 128
+ oexpr_list goto 127
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 47
+ lconst: LCONST. (38)
+
+ . reduce 38 (src line 354)
+
+
+state 48
+ simple_stmt: expr. (49)
+ simple_stmt: expr.LASOP expr
+ simple_stmt: expr.LINC
+ simple_stmt: expr.LDEC
+ expr: expr.LOROR expr
+ expr: expr.LANDAND expr
+ expr: expr.LEQ expr
+ expr: expr.LNE expr
+ expr: expr.LLT expr
+ expr: expr.LLE expr
+ expr: expr.LGE expr
+ expr: expr.LGT expr
+ expr: expr.'+' expr
+ expr: expr.'-' expr
+ expr: expr.'|' expr
+ expr: expr.'^' expr
+ expr: expr.'*' expr
+ expr: expr.'/' expr
+ expr: expr.'%' expr
+ expr: expr.'&' expr
+ expr: expr.LANDNOT expr
+ expr: expr.LLSH expr
+ expr: expr.LRSH expr
+ expr: expr.LCOMM expr
+ expr_list: expr. (276)
+
+ LASOP shift 130
+ LCOLAS reduce 276 (src line 1840)
+ LANDAND shift 134
+ LANDNOT shift 149
+ LCOMM shift 152
+ LDEC shift 132
+ LEQ shift 135
+ LGE shift 139
+ LGT shift 140
+ LINC shift 131
+ LLE shift 138
+ LLSH shift 150
+ LLT shift 137
+ LNE shift 136
+ LOROR shift 133
+ LRSH shift 151
+ '+' shift 141
+ '-' shift 142
+ '|' shift 143
+ '^' shift 144
+ '*' shift 145
+ '/' shift 146
+ '%' shift 147
+ '&' shift 148
+ '=' reduce 276 (src line 1840)
+ ',' reduce 276 (src line 1840)
+ . reduce 49 (src line 410)
+
+
+state 49
+ simple_stmt: expr_list.'=' expr_list
+ simple_stmt: expr_list.LCOLAS expr_list
+ expr_list: expr_list.',' expr
+
+ LCOLAS shift 154
+ '=' shift 153
+ ',' shift 155
+ . error
+
+
+state 50
+ for_stmt: LFOR.$$74 for_body
+ $$74: . (74)
+
+ . reduce 74 (src line 659)
+
+ $$74 goto 156
+
+state 51
+ switch_stmt: LSWITCH.$$88 if_header $$89 LBODY caseblock_list '}'
+ $$88: . (88)
+
+ . reduce 88 (src line 754)
+
+ $$88 goto 157
+
+state 52
+ select_stmt: LSELECT.$$91 LBODY caseblock_list '}'
+ $$91: . (91)
+
+ . reduce 91 (src line 777)
+
+ $$91 goto 158
+
+state 53
+ if_stmt: LIF.$$78 if_header $$79 loop_body $$80 elseif_list else
+ $$78: . (78)
+
+ . reduce 78 (src line 688)
+
+ $$78 goto 159
+
+state 54
+ labelname: new_name. (163)
+
+ . reduce 163 (src line 1167)
+
+
+state 55
+ expr: uexpr. (93)
+
+ . reduce 93 (src line 793)
+
+
+state 56
+ new_name: sym. (153)
+ name: sym. (162)
+
+ ':' reduce 153 (src line 1091)
+ . reduce 162 (src line 1158)
+
+
+state 57
+ uexpr: pexpr. (114)
+ pseudocall: pexpr.'(' ')'
+ pseudocall: pexpr.'(' expr_or_type_list ocomma ')'
+ pseudocall: pexpr.'(' expr_or_type_list LDDD ocomma ')'
+ pexpr_no_paren: pexpr.'.' sym
+ pexpr_no_paren: pexpr.'.' '(' expr_or_type ')'
+ pexpr_no_paren: pexpr.'.' '(' LTYPE ')'
+ pexpr_no_paren: pexpr.'[' expr ']'
+ pexpr_no_paren: pexpr.'[' oexpr ':' oexpr ']'
+ pexpr_no_paren: pexpr.'[' oexpr ':' oexpr ':' oexpr ']'
+
+ '(' shift 160
+ '.' shift 161
+ '[' shift 162
+ . reduce 114 (src line 877)
+
+
+state 58
+ uexpr: '*'.uexpr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 163
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 59
+ uexpr: '&'.uexpr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 164
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 60
+ uexpr: '+'.uexpr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 165
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 61
+ uexpr: '-'.uexpr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 166
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 62
+ uexpr: '!'.uexpr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 167
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 63
+ uexpr: '~'.uexpr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 168
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 64
+ uexpr: '^'.uexpr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 169
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 65
+ uexpr: LCOMM.uexpr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 170
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 66
+ pexpr_no_paren: pexpr_no_paren.'{' start_complit braced_keyval_list '}'
+ pexpr: pexpr_no_paren. (146)
+
+ '{' shift 171
+ . reduce 146 (src line 1054)
+
+
+state 67
+ pexpr_no_paren: '('.expr_or_type ')' '{' start_complit braced_keyval_list '}'
+ pexpr: '('.expr_or_type ')'
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 179
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 178
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 173
+ expr_or_type goto 172
+ fnliteral goto 73
+ name goto 69
+ non_expr_type goto 174
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ recvchantype goto 175
+ othertype goto 177
+ fntype goto 176
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 68
+ pexpr_no_paren: LLITERAL. (126)
+
+ . reduce 126 (src line 941)
+
+
+state 69
+ pexpr_no_paren: name. (127)
+
+ . reduce 127 (src line 946)
+
+
+state 70
+ pexpr_no_paren: pseudocall. (134)
+
+ . reduce 134 (src line 984)
+
+
+state 71
+ pexpr_no_paren: convtype.'(' expr ocomma ')'
+
+ '(' shift 180
+ . error
+
+
+state 72
+ pexpr_no_paren: comptype.lbrace start_complit braced_keyval_list '}'
+
+ LBODY shift 182
+ '{' shift 183
+ . error
+
+ lbrace goto 181
+
+state 73
+ pexpr_no_paren: fnliteral. (139)
+
+ . reduce 139 (src line 1011)
+
+
+state 74
+ convtype: fntype. (181)
+ fnlitdcl: fntype. (215)
+
+ '(' reduce 181 (src line 1220)
+ . reduce 215 (src line 1484)
+
+
+state 75
+ convtype: othertype. (182)
+ comptype: othertype. (183)
+
+ '(' reduce 182 (src line 1222)
+ . reduce 183 (src line 1224)
+
+
+state 76
+ fnliteral: fnlitdcl.lbrace stmt_list '}'
+ fnliteral: fnlitdcl.error
+
+ error shift 185
+ LBODY shift 182
+ '{' shift 183
+ . error
+
+ lbrace goto 184
+
+state 77
+ othertype: '['.oexpr ']' ntype
+ othertype: '['.LDDD ']' ntype
+ oexpr: . (290)
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LDDD shift 187
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . reduce 290 (src line 1899)
+
+ sym goto 123
+ expr goto 188
+ fnliteral goto 73
+ name goto 69
+ oexpr goto 186
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 78
+ othertype: LCHAN.non_recvchantype
+ othertype: LCHAN.LCOMM ntype
+
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 190
+ '*' shift 196
+ '(' shift 195
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ dotname goto 194
+ name goto 197
+ interfacetype goto 81
+ structtype goto 80
+ ptrtype goto 193
+ non_recvchantype goto 189
+ othertype goto 192
+ fntype goto 191
+ hidden_importsym goto 11
+
+state 79
+ othertype: LMAP.'[' ntype ']' ntype
+
+ '[' shift 198
+ . error
+
+
+state 80
+ othertype: structtype. (196)
+
+ . reduce 196 (src line 1272)
+
+
+state 81
+ othertype: interfacetype. (197)
+
+ . reduce 197 (src line 1273)
+
+
+state 82
+ structtype: LSTRUCT.lbrace structdcl_list osemi '}'
+ structtype: LSTRUCT.lbrace '}'
+
+ LBODY shift 182
+ '{' shift 183
+ . error
+
+ lbrace goto 199
+
+state 83
+ interfacetype: LINTERFACE.lbrace interfacedcl_list osemi '}'
+ interfacetype: LINTERFACE.lbrace '}'
+
+ LBODY shift 182
+ '{' shift 183
+ . error
+
+ lbrace goto 200
+
+state 84
+ imports: imports import ';'. (7)
+
+ . reduce 7 (src line 166)
+
+
+state 85
+ import: LIMPORT import_stmt. (8)
+
+ . reduce 8 (src line 168)
+
+
+state 86
+ import: LIMPORT '('.import_stmt_list osemi ')'
+ import: LIMPORT '('.')'
+
+ LLITERAL shift 88
+ LNAME shift 10
+ ')' shift 202
+ '.' shift 90
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ import_here goto 87
+ sym goto 89
+ hidden_importsym goto 11
+ import_stmt goto 203
+ import_stmt_list goto 201
+
+state 87
+ import_stmt: import_here.import_package import_there
+ import_stmt: import_here.import_there
+ $$21: . (21)
+
+ LPACKAGE shift 7
+ . reduce 21 (src line 272)
+
+ import_package goto 204
+ import_there goto 205
+ $$21 goto 15
+
+state 88
+ import_here: LLITERAL. (15)
+
+ . reduce 15 (src line 224)
+
+
+state 89
+ import_here: sym.LLITERAL
+
+ LLITERAL shift 206
+ . error
+
+
+state 90
+ import_here: '.'.LLITERAL
+
+ LLITERAL shift 207
+ . error
+
+
+state 91
+ hidden_importsym: '@' LLITERAL '.'.LNAME
+ hidden_importsym: '@' LLITERAL '.'.'?'
+
+ LNAME shift 208
+ '?' shift 209
+ . error
+
+
+state 92
+ import_there: $$21 hidden_import_list '$'.'$'
+
+ '$' shift 210
+ . error
+
+
+state 93
+ hidden_import_list: hidden_import_list hidden_import. (345)
+
+ . reduce 345 (src line 2210)
+
+
+state 94
+ hidden_import: LIMPORT.LNAME LLITERAL ';'
+
+ LNAME shift 211
+ . error
+
+
+state 95
+ hidden_import: LVAR.hidden_pkg_importsym hidden_type ';'
+
+ '@' shift 13
+ . error
+
+ hidden_importsym goto 213
+ hidden_pkg_importsym goto 212
+
+state 96
+ hidden_import: LCONST.hidden_pkg_importsym '=' hidden_constant ';'
+ hidden_import: LCONST.hidden_pkg_importsym hidden_type '=' hidden_constant ';'
+
+ '@' shift 13
+ . error
+
+ hidden_importsym goto 213
+ hidden_pkg_importsym goto 214
+
+state 97
+ hidden_import: LTYPE.hidden_pkgtype hidden_type ';'
+
+ '@' shift 13
+ . error
+
+ hidden_importsym goto 213
+ hidden_pkg_importsym goto 216
+ hidden_pkgtype goto 215
+
+state 98
+ hidden_import: LFUNC.hidden_fndcl fnbody ';'
+
+ '(' shift 219
+ '@' shift 13
+ . error
+
+ hidden_fndcl goto 217
+ hidden_importsym goto 213
+ hidden_pkg_importsym goto 218
+
+state 99
+ import_package: LPACKAGE LNAME import_safety ';'. (18)
+
+ . reduce 18 (src line 247)
+
+
+state 100
+ xdcl_list: xdcl_list xdcl ';'. (219)
+
+ . reduce 219 (src line 1511)
+
+
+state 101
+ common_dcl: LVAR vardcl. (28)
+
+ . reduce 28 (src line 305)
+
+
+state 102
+ common_dcl: LVAR '('.vardcl_list osemi ')'
+ common_dcl: LVAR '('.')'
+
+ LNAME shift 10
+ ')' shift 221
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 105
+ dcl_name goto 104
+ dcl_name_list goto 103
+ vardcl goto 222
+ vardcl_list goto 220
+ hidden_importsym goto 11
+
+state 103
+ vardcl: dcl_name_list.ntype
+ vardcl: dcl_name_list.ntype '=' expr_list
+ vardcl: dcl_name_list.'=' expr_list
+ dcl_name_list: dcl_name_list.',' dcl_name
+
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 232
+ '*' shift 196
+ '(' shift 231
+ '=' shift 224
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ ',' shift 225
+ . error
+
+ sym goto 123
+ ntype goto 223
+ dotname goto 230
+ name goto 197
+ interfacetype goto 81
+ structtype goto 80
+ ptrtype goto 229
+ recvchantype goto 226
+ othertype goto 228
+ fntype goto 227
+ hidden_importsym goto 11
+
+state 104
+ dcl_name_list: dcl_name. (274)
+
+ . reduce 274 (src line 1830)
+
+
+state 105
+ dcl_name: sym. (154)
+
+ . reduce 154 (src line 1101)
+
+
+state 106
+ common_dcl: lconst constdcl. (31)
+
+ . reduce 31 (src line 318)
+
+
+state 107
+ common_dcl: lconst '('.constdcl osemi ')'
+ common_dcl: lconst '('.constdcl ';' constdcl_list osemi ')'
+ common_dcl: lconst '('.')'
+
+ LNAME shift 10
+ ')' shift 234
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 105
+ dcl_name goto 104
+ dcl_name_list goto 108
+ constdcl goto 233
+ hidden_importsym goto 11
+
+state 108
+ constdcl: dcl_name_list.ntype '=' expr_list
+ constdcl: dcl_name_list.'=' expr_list
+ dcl_name_list: dcl_name_list.',' dcl_name
+
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 232
+ '*' shift 196
+ '(' shift 231
+ '=' shift 236
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ ',' shift 225
+ . error
+
+ sym goto 123
+ ntype goto 235
+ dotname goto 230
+ name goto 197
+ interfacetype goto 81
+ structtype goto 80
+ ptrtype goto 229
+ recvchantype goto 226
+ othertype goto 228
+ fntype goto 227
+ hidden_importsym goto 11
+
+state 109
+ common_dcl: LTYPE typedcl. (35)
+
+ . reduce 35 (src line 341)
+
+
+state 110
+ common_dcl: LTYPE '('.typedcl_list osemi ')'
+ common_dcl: LTYPE '('.')'
+
+ LNAME shift 10
+ ')' shift 238
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 112
+ typedclname goto 111
+ typedcl goto 239
+ typedcl_list goto 237
+ hidden_importsym goto 11
+
+state 111
+ typedcl: typedclname.ntype
+
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 232
+ '*' shift 196
+ '(' shift 231
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ ntype goto 240
+ dotname goto 230
+ name goto 197
+ interfacetype goto 81
+ structtype goto 80
+ ptrtype goto 229
+ recvchantype goto 226
+ othertype goto 228
+ fntype goto 227
+ hidden_importsym goto 11
+
+state 112
+ typedclname: sym. (47)
+
+ . reduce 47 (src line 395)
+
+
+state 113
+ xfndcl: LFUNC fndcl.fnbody
+ fnbody: . (210)
+
+ '{' shift 242
+ . reduce 210 (src line 1457)
+
+ fnbody goto 241
+
+state 114
+ fndcl: '('.oarg_type_list_ocomma ')' sym '(' oarg_type_list_ocomma ')' fnres
+ fntype: LFUNC '('.oarg_type_list_ocomma ')' fnres
+ oarg_type_list_ocomma: . (249)
+
+ LCHAN shift 78
+ LDDD shift 250
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 232
+ '*' shift 196
+ '(' shift 231
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . reduce 249 (src line 1707)
+
+ sym goto 247
+ ntype goto 249
+ arg_type goto 245
+ dotname goto 230
+ name goto 197
+ name_or_type goto 246
+ oarg_type_list_ocomma goto 243
+ arg_type_list goto 244
+ dotdotdot goto 248
+ interfacetype goto 81
+ structtype goto 80
+ ptrtype goto 229
+ recvchantype goto 226
+ othertype goto 228
+ fntype goto 227
+ hidden_importsym goto 11
+
+state 115
+ fndcl: sym.'(' oarg_type_list_ocomma ')' fnres
+
+ '(' shift 251
+ . error
+
+
+state 116
+ non_dcl_stmt: labelname ':'.$$261 stmt
+ $$261: . (261)
+
+ . reduce 261 (src line 1740)
+
+ $$261 goto 252
+
+state 117
+ non_dcl_stmt: LBREAK onew_name. (264)
+
+ . reduce 264 (src line 1762)
+
+
+state 118
+ onew_name: new_name. (156)
+
+ . reduce 156 (src line 1111)
+
+
+state 119
+ new_name: sym. (153)
+
+ . reduce 153 (src line 1091)
+
+
+state 120
+ non_dcl_stmt: LCONTINUE onew_name. (265)
+
+ . reduce 265 (src line 1766)
+
+
+state 121
+ pexpr_no_paren: pseudocall. (134)
+ non_dcl_stmt: LGO pseudocall. (266)
+
+ '(' reduce 134 (src line 984)
+ '.' reduce 134 (src line 984)
+ '{' reduce 134 (src line 984)
+ '[' reduce 134 (src line 984)
+ . reduce 266 (src line 1770)
+
+
+state 122
+ pseudocall: pexpr.'(' ')'
+ pseudocall: pexpr.'(' expr_or_type_list ocomma ')'
+ pseudocall: pexpr.'(' expr_or_type_list LDDD ocomma ')'
+ pexpr_no_paren: pexpr.'.' sym
+ pexpr_no_paren: pexpr.'.' '(' expr_or_type ')'
+ pexpr_no_paren: pexpr.'.' '(' LTYPE ')'
+ pexpr_no_paren: pexpr.'[' expr ']'
+ pexpr_no_paren: pexpr.'[' oexpr ':' oexpr ']'
+ pexpr_no_paren: pexpr.'[' oexpr ':' oexpr ':' oexpr ']'
+
+ '(' shift 160
+ '.' shift 161
+ '[' shift 162
+ . error
+
+
+state 123
+ name: sym. (162)
+
+ . reduce 162 (src line 1158)
+
+
+state 124
+ fntype: LFUNC.'(' oarg_type_list_ocomma ')' fnres
+
+ '(' shift 253
+ . error
+
+
+state 125
+ pexpr_no_paren: pseudocall. (134)
+ non_dcl_stmt: LDEFER pseudocall. (267)
+
+ '(' reduce 134 (src line 984)
+ '.' reduce 134 (src line 984)
+ '{' reduce 134 (src line 984)
+ '[' reduce 134 (src line 984)
+ . reduce 267 (src line 1774)
+
+
+state 126
+ non_dcl_stmt: LGOTO new_name. (268)
+
+ . reduce 268 (src line 1778)
+
+
+state 127
+ non_dcl_stmt: LRETURN oexpr_list. (269)
+
+ . reduce 269 (src line 1783)
+
+
+state 128
+ expr_list: expr_list.',' expr
+ oexpr_list: expr_list. (293)
+
+ ',' shift 155
+ . reduce 293 (src line 1909)
+
+
+state 129
+ expr: expr.LOROR expr
+ expr: expr.LANDAND expr
+ expr: expr.LEQ expr
+ expr: expr.LNE expr
+ expr: expr.LLT expr
+ expr: expr.LLE expr
+ expr: expr.LGE expr
+ expr: expr.LGT expr
+ expr: expr.'+' expr
+ expr: expr.'-' expr
+ expr: expr.'|' expr
+ expr: expr.'^' expr
+ expr: expr.'*' expr
+ expr: expr.'/' expr
+ expr: expr.'%' expr
+ expr: expr.'&' expr
+ expr: expr.LANDNOT expr
+ expr: expr.LLSH expr
+ expr: expr.LRSH expr
+ expr: expr.LCOMM expr
+ expr_list: expr. (276)
+
+ LANDAND shift 134
+ LANDNOT shift 149
+ LCOMM shift 152
+ LEQ shift 135
+ LGE shift 139
+ LGT shift 140
+ LLE shift 138
+ LLSH shift 150
+ LLT shift 137
+ LNE shift 136
+ LOROR shift 133
+ LRSH shift 151
+ '+' shift 141
+ '-' shift 142
+ '|' shift 143
+ '^' shift 144
+ '*' shift 145
+ '/' shift 146
+ '%' shift 147
+ '&' shift 148
+ . reduce 276 (src line 1840)
+
+
+state 130
+ simple_stmt: expr LASOP.expr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 254
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 131
+ simple_stmt: expr LINC. (53)
+
+ . reduce 53 (src line 460)
+
+
+state 132
+ simple_stmt: expr LDEC. (54)
+
+ . reduce 54 (src line 466)
+
+
+state 133
+ expr: expr LOROR.expr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 255
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 134
+ expr: expr LANDAND.expr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 256
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 135
+ expr: expr LEQ.expr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 257
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 136
+ expr: expr LNE.expr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 258
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 137
+ expr: expr LLT.expr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 259
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 138
+ expr: expr LLE.expr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 260
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 139
+ expr: expr LGE.expr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 261
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 140
+ expr: expr LGT.expr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 262
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 141
+ expr: expr '+'.expr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 263
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 142
+ expr: expr '-'.expr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 264
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 143
+ expr: expr '|'.expr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 265
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 144
+ expr: expr '^'.expr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 266
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 145
+ expr: expr '*'.expr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 267
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 146
+ expr: expr '/'.expr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 268
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 147
+ expr: expr '%'.expr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 269
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 148
+ expr: expr '&'.expr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 270
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 149
+ expr: expr LANDNOT.expr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 271
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 150
+ expr: expr LLSH.expr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 272
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 151
+ expr: expr LRSH.expr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 273
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 152
+ expr: expr LCOMM.expr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 274
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 153
+ simple_stmt: expr_list '='.expr_list
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 129
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ expr_list goto 275
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 154
+ simple_stmt: expr_list LCOLAS.expr_list
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 129
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ expr_list goto 276
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 155
+ expr_list: expr_list ','.expr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 277
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 156
+ for_stmt: LFOR $$74.for_body
+ osimple_stmt: . (294)
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LRANGE shift 284
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . reduce 294 (src line 1911)
+
+ sym goto 123
+ expr goto 48
+ fnliteral goto 73
+ for_body goto 278
+ for_header goto 279
+ name goto 69
+ osimple_stmt goto 280
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ range_stmt goto 281
+ simple_stmt goto 282
+ uexpr goto 55
+ expr_list goto 283
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 157
+ switch_stmt: LSWITCH $$88.if_header $$89 LBODY caseblock_list '}'
+ osimple_stmt: . (294)
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . reduce 294 (src line 1911)
+
+ sym goto 123
+ expr goto 48
+ fnliteral goto 73
+ if_header goto 285
+ name goto 69
+ osimple_stmt goto 286
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ simple_stmt goto 282
+ uexpr goto 55
+ expr_list goto 49
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 158
+ select_stmt: LSELECT $$91.LBODY caseblock_list '}'
+
+ LBODY shift 287
+ . error
+
+
+state 159
+ if_stmt: LIF $$78.if_header $$79 loop_body $$80 elseif_list else
+ osimple_stmt: . (294)
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . reduce 294 (src line 1911)
+
+ sym goto 123
+ expr goto 48
+ fnliteral goto 73
+ if_header goto 288
+ name goto 69
+ osimple_stmt goto 286
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ simple_stmt goto 282
+ uexpr goto 55
+ expr_list goto 49
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 160
+ pseudocall: pexpr '('.')'
+ pseudocall: pexpr '('.expr_or_type_list ocomma ')'
+ pseudocall: pexpr '('.expr_or_type_list LDDD ocomma ')'
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 179
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 178
+ '&' shift 59
+ '(' shift 67
+ ')' shift 289
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 173
+ expr_or_type goto 291
+ fnliteral goto 73
+ name goto 69
+ non_expr_type goto 174
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ expr_or_type_list goto 290
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ recvchantype goto 175
+ othertype goto 177
+ fntype goto 176
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 161
+ pexpr_no_paren: pexpr '.'.sym
+ pexpr_no_paren: pexpr '.'.'(' expr_or_type ')'
+ pexpr_no_paren: pexpr '.'.'(' LTYPE ')'
+
+ LNAME shift 10
+ '(' shift 293
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 292
+ hidden_importsym goto 11
+
+state 162
+ pexpr_no_paren: pexpr '['.expr ']'
+ pexpr_no_paren: pexpr '['.oexpr ':' oexpr ']'
+ pexpr_no_paren: pexpr '['.oexpr ':' oexpr ':' oexpr ']'
+ oexpr: . (290)
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . reduce 290 (src line 1899)
+
+ sym goto 123
+ expr goto 294
+ fnliteral goto 73
+ name goto 69
+ oexpr goto 295
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 163
+ uexpr: '*' uexpr. (115)
+
+ . reduce 115 (src line 879)
+
+
+state 164
+ uexpr: '&' uexpr. (116)
+
+ . reduce 116 (src line 883)
+
+
+state 165
+ uexpr: '+' uexpr. (117)
+
+ . reduce 117 (src line 894)
+
+
+state 166
+ uexpr: '-' uexpr. (118)
+
+ . reduce 118 (src line 898)
+
+
+state 167
+ uexpr: '!' uexpr. (119)
+
+ . reduce 119 (src line 902)
+
+
+state 168
+ uexpr: '~' uexpr. (120)
+
+ . reduce 120 (src line 906)
+
+
+state 169
+ uexpr: '^' uexpr. (121)
+
+ . reduce 121 (src line 911)
+
+
+state 170
+ uexpr: LCOMM uexpr. (122)
+
+ . reduce 122 (src line 915)
+
+
+state 171
+ pexpr_no_paren: pexpr_no_paren '{'.start_complit braced_keyval_list '}'
+ start_complit: . (140)
+
+ . reduce 140 (src line 1013)
+
+ start_complit goto 296
+
+state 172
+ pexpr_no_paren: '(' expr_or_type.')' '{' start_complit braced_keyval_list '}'
+ pexpr: '(' expr_or_type.')'
+
+ ')' shift 297
+ . error
+
+
+state 173
+ expr: expr.LOROR expr
+ expr: expr.LANDAND expr
+ expr: expr.LEQ expr
+ expr: expr.LNE expr
+ expr: expr.LLT expr
+ expr: expr.LLE expr
+ expr: expr.LGE expr
+ expr: expr.LGT expr
+ expr: expr.'+' expr
+ expr: expr.'-' expr
+ expr: expr.'|' expr
+ expr: expr.'^' expr
+ expr: expr.'*' expr
+ expr: expr.'/' expr
+ expr: expr.'%' expr
+ expr: expr.'&' expr
+ expr: expr.LANDNOT expr
+ expr: expr.LLSH expr
+ expr: expr.LRSH expr
+ expr: expr.LCOMM expr
+ expr_or_type: expr. (148)
+
+ LANDAND shift 134
+ LANDNOT shift 149
+ LCOMM shift 152
+ LEQ shift 135
+ LGE shift 139
+ LGT shift 140
+ LLE shift 138
+ LLSH shift 150
+ LLT shift 137
+ LNE shift 136
+ LOROR shift 133
+ LRSH shift 151
+ '+' shift 141
+ '-' shift 142
+ '|' shift 143
+ '^' shift 144
+ '*' shift 145
+ '/' shift 146
+ '%' shift 147
+ '&' shift 148
+ . reduce 148 (src line 1069)
+
+
+state 174
+ expr_or_type: non_expr_type. (149)
+
+ . reduce 149 (src line 1071)
+
+
+state 175
+ non_expr_type: recvchantype. (172)
+
+ . reduce 172 (src line 1201)
+
+
+state 176
+ non_expr_type: fntype. (173)
+ convtype: fntype. (181)
+ fnlitdcl: fntype. (215)
+
+ error reduce 215 (src line 1484)
+ LBODY reduce 215 (src line 1484)
+ '(' reduce 181 (src line 1220)
+ '{' reduce 215 (src line 1484)
+ . reduce 173 (src line 1203)
+
+
+state 177
+ non_expr_type: othertype. (174)
+ convtype: othertype. (182)
+ comptype: othertype. (183)
+
+ LBODY reduce 183 (src line 1224)
+ '(' reduce 182 (src line 1222)
+ '{' reduce 183 (src line 1224)
+ . reduce 174 (src line 1204)
+
+
+state 178
+ uexpr: '*'.uexpr
+ non_expr_type: '*'.non_expr_type
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 179
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 178
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ fnliteral goto 73
+ name goto 69
+ non_expr_type goto 298
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 163
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ recvchantype goto 175
+ othertype goto 177
+ fntype goto 176
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 179
+ uexpr: LCOMM.uexpr
+ recvchantype: LCOMM.LCHAN ntype
+
+ LLITERAL shift 68
+ LCHAN shift 299
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 170
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 180
+ pexpr_no_paren: convtype '('.expr ocomma ')'
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 300
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 181
+ pexpr_no_paren: comptype lbrace.start_complit braced_keyval_list '}'
+ start_complit: . (140)
+
+ . reduce 140 (src line 1013)
+
+ start_complit goto 301
+
+state 182
+ lbrace: LBODY. (151)
+
+ . reduce 151 (src line 1076)
+
+
+state 183
+ lbrace: '{'. (152)
+
+ . reduce 152 (src line 1081)
+
+
+state 184
+ fnliteral: fnlitdcl lbrace.stmt_list '}'
+ stmt: . (251)
+
+ error shift 307
+ LLITERAL shift 68
+ LBREAK shift 41
+ LCHAN shift 78
+ LCONST shift 47
+ LCONTINUE shift 42
+ LDEFER shift 44
+ LFALL shift 40
+ LFOR shift 50
+ LFUNC shift 124
+ LGO shift 43
+ LGOTO shift 45
+ LIF shift 53
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LRETURN shift 46
+ LSELECT shift 52
+ LSTRUCT shift 82
+ LSWITCH shift 51
+ LTYPE shift 32
+ LVAR shift 30
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ ';' reduce 251 (src line 1719)
+ '{' shift 308
+ '}' reduce 251 (src line 1719)
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 56
+ stmt goto 303
+ compound_stmt goto 304
+ expr goto 48
+ fnliteral goto 73
+ for_stmt goto 35
+ if_stmt goto 38
+ non_dcl_stmt goto 306
+ labelname goto 39
+ name goto 69
+ new_name goto 54
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ select_stmt goto 37
+ simple_stmt goto 34
+ switch_stmt goto 36
+ uexpr goto 55
+ expr_list goto 49
+ stmt_list goto 302
+ common_dcl goto 305
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ lconst goto 31
+ fnlitdcl goto 76
+
+state 185
+ fnliteral: fnlitdcl error. (217)
+
+ . reduce 217 (src line 1496)
+
+
+state 186
+ othertype: '[' oexpr.']' ntype
+
+ ']' shift 309
+ . error
+
+
+state 187
+ othertype: '[' LDDD.']' ntype
+
+ ']' shift 310
+ . error
+
+
+state 188
+ expr: expr.LOROR expr
+ expr: expr.LANDAND expr
+ expr: expr.LEQ expr
+ expr: expr.LNE expr
+ expr: expr.LLT expr
+ expr: expr.LLE expr
+ expr: expr.LGE expr
+ expr: expr.LGT expr
+ expr: expr.'+' expr
+ expr: expr.'-' expr
+ expr: expr.'|' expr
+ expr: expr.'^' expr
+ expr: expr.'*' expr
+ expr: expr.'/' expr
+ expr: expr.'%' expr
+ expr: expr.'&' expr
+ expr: expr.LANDNOT expr
+ expr: expr.LLSH expr
+ expr: expr.LRSH expr
+ expr: expr.LCOMM expr
+ oexpr: expr. (291)
+
+ LANDAND shift 134
+ LANDNOT shift 149
+ LCOMM shift 152
+ LEQ shift 135
+ LGE shift 139
+ LGT shift 140
+ LLE shift 138
+ LLSH shift 150
+ LLT shift 137
+ LNE shift 136
+ LOROR shift 133
+ LRSH shift 151
+ '+' shift 141
+ '-' shift 142
+ '|' shift 143
+ '^' shift 144
+ '*' shift 145
+ '/' shift 146
+ '%' shift 147
+ '&' shift 148
+ . reduce 291 (src line 1903)
+
+
+state 189
+ othertype: LCHAN non_recvchantype. (193)
+
+ . reduce 193 (src line 1258)
+
+
+state 190
+ othertype: LCHAN LCOMM.ntype
+
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 232
+ '*' shift 196
+ '(' shift 231
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ ntype goto 311
+ dotname goto 230
+ name goto 197
+ interfacetype goto 81
+ structtype goto 80
+ ptrtype goto 229
+ recvchantype goto 226
+ othertype goto 228
+ fntype goto 227
+ hidden_importsym goto 11
+
+state 191
+ non_recvchantype: fntype. (176)
+
+ . reduce 176 (src line 1210)
+
+
+state 192
+ non_recvchantype: othertype. (177)
+
+ . reduce 177 (src line 1212)
+
+
+state 193
+ non_recvchantype: ptrtype. (178)
+
+ . reduce 178 (src line 1213)
+
+
+state 194
+ non_recvchantype: dotname. (179)
+
+ . reduce 179 (src line 1214)
+
+
+state 195
+ non_recvchantype: '('.ntype ')'
+
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 232
+ '*' shift 196
+ '(' shift 231
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ ntype goto 312
+ dotname goto 230
+ name goto 197
+ interfacetype goto 81
+ structtype goto 80
+ ptrtype goto 229
+ recvchantype goto 226
+ othertype goto 228
+ fntype goto 227
+ hidden_importsym goto 11
+
+state 196
+ ptrtype: '*'.ntype
+
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 232
+ '*' shift 196
+ '(' shift 231
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ ntype goto 313
+ dotname goto 230
+ name goto 197
+ interfacetype goto 81
+ structtype goto 80
+ ptrtype goto 229
+ recvchantype goto 226
+ othertype goto 228
+ fntype goto 227
+ hidden_importsym goto 11
+
+state 197
+ dotname: name. (189)
+ dotname: name.'.' sym
+
+ '.' shift 314
+ . reduce 189 (src line 1234)
+
+
+state 198
+ othertype: LMAP '['.ntype ']' ntype
+
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 232
+ '*' shift 196
+ '(' shift 231
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ ntype goto 315
+ dotname goto 230
+ name goto 197
+ interfacetype goto 81
+ structtype goto 80
+ ptrtype goto 229
+ recvchantype goto 226
+ othertype goto 228
+ fntype goto 227
+ hidden_importsym goto 11
+
+state 199
+ structtype: LSTRUCT lbrace.structdcl_list osemi '}'
+ structtype: LSTRUCT lbrace.'}'
+
+ LNAME shift 325
+ '*' shift 322
+ '(' shift 321
+ '}' shift 317
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 119
+ packname goto 324
+ embed goto 320
+ new_name goto 323
+ new_name_list goto 319
+ structdcl goto 318
+ structdcl_list goto 316
+ hidden_importsym goto 11
+
+state 200
+ interfacetype: LINTERFACE lbrace.interfacedcl_list osemi '}'
+ interfacetype: LINTERFACE lbrace.'}'
+
+ LNAME shift 325
+ '(' shift 331
+ '}' shift 327
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 119
+ packname goto 330
+ interfacedcl goto 328
+ new_name goto 329
+ interfacedcl_list goto 326
+ hidden_importsym goto 11
+
+state 201
+ import: LIMPORT '(' import_stmt_list.osemi ')'
+ import_stmt_list: import_stmt_list.';' import_stmt
+ osemi: . (286)
+
+ ';' shift 333
+ . reduce 286 (src line 1893)
+
+ osemi goto 332
+
+state 202
+ import: LIMPORT '(' ')'. (10)
+
+ . reduce 10 (src line 171)
+
+
+state 203
+ import_stmt_list: import_stmt. (13)
+
+ . reduce 13 (src line 220)
+
+
+state 204
+ import_stmt: import_here import_package.import_there
+ $$21: . (21)
+
+ . reduce 21 (src line 272)
+
+ import_there goto 334
+ $$21 goto 15
+
+state 205
+ import_stmt: import_here import_there. (12)
+
+ . reduce 12 (src line 209)
+
+
+state 206
+ import_here: sym LLITERAL. (16)
+
+ . reduce 16 (src line 232)
+
+
+state 207
+ import_here: '.' LLITERAL. (17)
+
+ . reduce 17 (src line 239)
+
+
+state 208
+ hidden_importsym: '@' LLITERAL '.' LNAME. (160)
+
+ . reduce 160 (src line 1128)
+
+
+state 209
+ hidden_importsym: '@' LLITERAL '.' '?'. (161)
+
+ . reduce 161 (src line 1143)
+
+
+state 210
+ import_there: $$21 hidden_import_list '$' '$'. (22)
+
+ . reduce 22 (src line 276)
+
+
+state 211
+ hidden_import: LIMPORT LNAME.LLITERAL ';'
+
+ LLITERAL shift 335
+ . error
+
+
+state 212
+ hidden_import: LVAR hidden_pkg_importsym.hidden_type ';'
+
+ LCHAN shift 347
+ LFUNC shift 349
+ LINTERFACE shift 345
+ LMAP shift 343
+ LNAME shift 341
+ LSTRUCT shift 344
+ LCOMM shift 348
+ '*' shift 346
+ '[' shift 342
+ '@' shift 13
+ . error
+
+ hidden_importsym goto 340
+ hidden_type goto 336
+ hidden_type_misc goto 337
+ hidden_type_func goto 339
+ hidden_type_recv_chan goto 338
+
+state 213
+ hidden_pkg_importsym: hidden_importsym. (310)
+
+ . reduce 310 (src line 1985)
+
+
+state 214
+ hidden_import: LCONST hidden_pkg_importsym.'=' hidden_constant ';'
+ hidden_import: LCONST hidden_pkg_importsym.hidden_type '=' hidden_constant ';'
+
+ LCHAN shift 347
+ LFUNC shift 349
+ LINTERFACE shift 345
+ LMAP shift 343
+ LNAME shift 341
+ LSTRUCT shift 344
+ LCOMM shift 348
+ '*' shift 346
+ '=' shift 350
+ '[' shift 342
+ '@' shift 13
+ . error
+
+ hidden_importsym goto 340
+ hidden_type goto 351
+ hidden_type_misc goto 337
+ hidden_type_func goto 339
+ hidden_type_recv_chan goto 338
+
+state 215
+ hidden_import: LTYPE hidden_pkgtype.hidden_type ';'
+
+ LCHAN shift 347
+ LFUNC shift 349
+ LINTERFACE shift 345
+ LMAP shift 343
+ LNAME shift 341
+ LSTRUCT shift 344
+ LCOMM shift 348
+ '*' shift 346
+ '[' shift 342
+ '@' shift 13
+ . error
+
+ hidden_importsym goto 340
+ hidden_type goto 352
+ hidden_type_misc goto 337
+ hidden_type_func goto 339
+ hidden_type_recv_chan goto 338
+
+state 216
+ hidden_pkgtype: hidden_pkg_importsym. (311)
+
+ . reduce 311 (src line 1992)
+
+
+state 217
+ hidden_import: LFUNC hidden_fndcl.fnbody ';'
+ fnbody: . (210)
+
+ '{' shift 242
+ . reduce 210 (src line 1457)
+
+ fnbody goto 353
+
+state 218
+ hidden_fndcl: hidden_pkg_importsym.'(' ohidden_funarg_list ')' ohidden_funres
+
+ '(' shift 354
+ . error
+
+
+state 219
+ hidden_fndcl: '('.hidden_funarg_list ')' sym '(' ohidden_funarg_list ')' ohidden_funres
+
+ LNAME shift 10
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 357
+ hidden_importsym goto 11
+ hidden_funarg goto 356
+ hidden_funarg_list goto 355
+
+state 220
+ common_dcl: LVAR '(' vardcl_list.osemi ')'
+ vardcl_list: vardcl_list.';' vardcl
+ osemi: . (286)
+
+ ';' shift 359
+ . reduce 286 (src line 1893)
+
+ osemi goto 358
+
+state 221
+ common_dcl: LVAR '(' ')'. (30)
+
+ . reduce 30 (src line 314)
+
+
+state 222
+ vardcl_list: vardcl. (220)
+
+ . reduce 220 (src line 1523)
+
+
+state 223
+ vardcl: dcl_name_list ntype. (39)
+ vardcl: dcl_name_list ntype.'=' expr_list
+
+ '=' shift 360
+ . reduce 39 (src line 360)
+
+
+state 224
+ vardcl: dcl_name_list '='.expr_list
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 129
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ expr_list goto 361
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 225
+ dcl_name_list: dcl_name_list ','.dcl_name
+
+ LNAME shift 10
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 105
+ dcl_name goto 362
+ hidden_importsym goto 11
+
+state 226
+ ntype: recvchantype. (166)
+
+ . reduce 166 (src line 1190)
+
+
+state 227
+ ntype: fntype. (167)
+
+ . reduce 167 (src line 1192)
+
+
+state 228
+ ntype: othertype. (168)
+
+ . reduce 168 (src line 1193)
+
+
+state 229
+ ntype: ptrtype. (169)
+
+ . reduce 169 (src line 1194)
+
+
+state 230
+ ntype: dotname. (170)
+
+ . reduce 170 (src line 1195)
+
+
+state 231
+ ntype: '('.ntype ')'
+
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 232
+ '*' shift 196
+ '(' shift 231
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ ntype goto 363
+ dotname goto 230
+ name goto 197
+ interfacetype goto 81
+ structtype goto 80
+ ptrtype goto 229
+ recvchantype goto 226
+ othertype goto 228
+ fntype goto 227
+ hidden_importsym goto 11
+
+state 232
+ recvchantype: LCOMM.LCHAN ntype
+
+ LCHAN shift 364
+ . error
+
+
+state 233
+ common_dcl: lconst '(' constdcl.osemi ')'
+ common_dcl: lconst '(' constdcl.';' constdcl_list osemi ')'
+ osemi: . (286)
+
+ ';' shift 366
+ . reduce 286 (src line 1893)
+
+ osemi goto 365
+
+state 234
+ common_dcl: lconst '(' ')'. (34)
+
+ . reduce 34 (src line 336)
+
+
+state 235
+ constdcl: dcl_name_list ntype.'=' expr_list
+
+ '=' shift 367
+ . error
+
+
+state 236
+ constdcl: dcl_name_list '='.expr_list
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 129
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ expr_list goto 368
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 237
+ common_dcl: LTYPE '(' typedcl_list.osemi ')'
+ typedcl_list: typedcl_list.';' typedcl
+ osemi: . (286)
+
+ ';' shift 370
+ . reduce 286 (src line 1893)
+
+ osemi goto 369
+
+state 238
+ common_dcl: LTYPE '(' ')'. (37)
+
+ . reduce 37 (src line 349)
+
+
+state 239
+ typedcl_list: typedcl. (224)
+
+ . reduce 224 (src line 1537)
+
+
+state 240
+ typedcl: typedclname ntype. (48)
+
+ . reduce 48 (src line 404)
+
+
+state 241
+ xfndcl: LFUNC fndcl fnbody. (204)
+
+ . reduce 204 (src line 1318)
+
+
+state 242
+ fnbody: '{'.stmt_list '}'
+ stmt: . (251)
+
+ error shift 307
+ LLITERAL shift 68
+ LBREAK shift 41
+ LCHAN shift 78
+ LCONST shift 47
+ LCONTINUE shift 42
+ LDEFER shift 44
+ LFALL shift 40
+ LFOR shift 50
+ LFUNC shift 124
+ LGO shift 43
+ LGOTO shift 45
+ LIF shift 53
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LRETURN shift 46
+ LSELECT shift 52
+ LSTRUCT shift 82
+ LSWITCH shift 51
+ LTYPE shift 32
+ LVAR shift 30
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ ';' reduce 251 (src line 1719)
+ '{' shift 308
+ '}' reduce 251 (src line 1719)
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 56
+ stmt goto 303
+ compound_stmt goto 304
+ expr goto 48
+ fnliteral goto 73
+ for_stmt goto 35
+ if_stmt goto 38
+ non_dcl_stmt goto 306
+ labelname goto 39
+ name goto 69
+ new_name goto 54
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ select_stmt goto 37
+ simple_stmt goto 34
+ switch_stmt goto 36
+ uexpr goto 55
+ expr_list goto 49
+ stmt_list goto 371
+ common_dcl goto 305
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ lconst goto 31
+ fnlitdcl goto 76
+
+state 243
+ fndcl: '(' oarg_type_list_ocomma.')' sym '(' oarg_type_list_ocomma ')' fnres
+ fntype: LFUNC '(' oarg_type_list_ocomma.')' fnres
+
+ ')' shift 372
+ . error
+
+
+state 244
+ arg_type_list: arg_type_list.',' arg_type
+ oarg_type_list_ocomma: arg_type_list.ocomma
+ ocomma: . (288)
+
+ ',' shift 373
+ . reduce 288 (src line 1896)
+
+ ocomma goto 374
+
+state 245
+ arg_type_list: arg_type. (247)
+
+ . reduce 247 (src line 1697)
+
+
+state 246
+ arg_type: name_or_type. (243)
+
+ . reduce 243 (src line 1681)
+
+
+state 247
+ name: sym. (162)
+ arg_type: sym.name_or_type
+ arg_type: sym.dotdotdot
+
+ LCHAN shift 78
+ LDDD shift 250
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 232
+ '*' shift 196
+ '(' shift 231
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . reduce 162 (src line 1158)
+
+ sym goto 123
+ ntype goto 249
+ dotname goto 230
+ name goto 197
+ name_or_type goto 375
+ dotdotdot goto 376
+ interfacetype goto 81
+ structtype goto 80
+ ptrtype goto 229
+ recvchantype goto 226
+ othertype goto 228
+ fntype goto 227
+ hidden_importsym goto 11
+
+state 248
+ arg_type: dotdotdot. (246)
+
+ . reduce 246 (src line 1695)
+
+
+state 249
+ name_or_type: ntype. (150)
+
+ . reduce 150 (src line 1073)
+
+
+state 250
+ dotdotdot: LDDD. (164)
+ dotdotdot: LDDD.ntype
+
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 232
+ '*' shift 196
+ '(' shift 231
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . reduce 164 (src line 1179)
+
+ sym goto 123
+ ntype goto 377
+ dotname goto 230
+ name goto 197
+ interfacetype goto 81
+ structtype goto 80
+ ptrtype goto 229
+ recvchantype goto 226
+ othertype goto 228
+ fntype goto 227
+ hidden_importsym goto 11
+
+state 251
+ fndcl: sym '('.oarg_type_list_ocomma ')' fnres
+ oarg_type_list_ocomma: . (249)
+
+ LCHAN shift 78
+ LDDD shift 250
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 232
+ '*' shift 196
+ '(' shift 231
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . reduce 249 (src line 1707)
+
+ sym goto 247
+ ntype goto 249
+ arg_type goto 245
+ dotname goto 230
+ name goto 197
+ name_or_type goto 246
+ oarg_type_list_ocomma goto 378
+ arg_type_list goto 244
+ dotdotdot goto 248
+ interfacetype goto 81
+ structtype goto 80
+ ptrtype goto 229
+ recvchantype goto 226
+ othertype goto 228
+ fntype goto 227
+ hidden_importsym goto 11
+
+state 252
+ non_dcl_stmt: labelname ':' $$261.stmt
+ stmt: . (251)
+
+ error shift 307
+ LLITERAL shift 68
+ LBREAK shift 41
+ LCASE reduce 251 (src line 1719)
+ LCHAN shift 78
+ LCONST shift 47
+ LCONTINUE shift 42
+ LDEFAULT reduce 251 (src line 1719)
+ LDEFER shift 44
+ LFALL shift 40
+ LFOR shift 50
+ LFUNC shift 124
+ LGO shift 43
+ LGOTO shift 45
+ LIF shift 53
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LRETURN shift 46
+ LSELECT shift 52
+ LSTRUCT shift 82
+ LSWITCH shift 51
+ LTYPE shift 32
+ LVAR shift 30
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ ';' reduce 251 (src line 1719)
+ '{' shift 308
+ '}' reduce 251 (src line 1719)
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 56
+ stmt goto 379
+ compound_stmt goto 304
+ expr goto 48
+ fnliteral goto 73
+ for_stmt goto 35
+ if_stmt goto 38
+ non_dcl_stmt goto 306
+ labelname goto 39
+ name goto 69
+ new_name goto 54
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ select_stmt goto 37
+ simple_stmt goto 34
+ switch_stmt goto 36
+ uexpr goto 55
+ expr_list goto 49
+ common_dcl goto 305
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ lconst goto 31
+ fnlitdcl goto 76
+
+state 253
+ fntype: LFUNC '('.oarg_type_list_ocomma ')' fnres
+ oarg_type_list_ocomma: . (249)
+
+ LCHAN shift 78
+ LDDD shift 250
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 232
+ '*' shift 196
+ '(' shift 231
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . reduce 249 (src line 1707)
+
+ sym goto 247
+ ntype goto 249
+ arg_type goto 245
+ dotname goto 230
+ name goto 197
+ name_or_type goto 246
+ oarg_type_list_ocomma goto 380
+ arg_type_list goto 244
+ dotdotdot goto 248
+ interfacetype goto 81
+ structtype goto 80
+ ptrtype goto 229
+ recvchantype goto 226
+ othertype goto 228
+ fntype goto 227
+ hidden_importsym goto 11
+
+state 254
+ simple_stmt: expr LASOP expr. (50)
+ expr: expr.LOROR expr
+ expr: expr.LANDAND expr
+ expr: expr.LEQ expr
+ expr: expr.LNE expr
+ expr: expr.LLT expr
+ expr: expr.LLE expr
+ expr: expr.LGE expr
+ expr: expr.LGT expr
+ expr: expr.'+' expr
+ expr: expr.'-' expr
+ expr: expr.'|' expr
+ expr: expr.'^' expr
+ expr: expr.'*' expr
+ expr: expr.'/' expr
+ expr: expr.'%' expr
+ expr: expr.'&' expr
+ expr: expr.LANDNOT expr
+ expr: expr.LLSH expr
+ expr: expr.LRSH expr
+ expr: expr.LCOMM expr
+
+ LANDAND shift 134
+ LANDNOT shift 149
+ LCOMM shift 152
+ LEQ shift 135
+ LGE shift 139
+ LGT shift 140
+ LLE shift 138
+ LLSH shift 150
+ LLT shift 137
+ LNE shift 136
+ LOROR shift 133
+ LRSH shift 151
+ '+' shift 141
+ '-' shift 142
+ '|' shift 143
+ '^' shift 144
+ '*' shift 145
+ '/' shift 146
+ '%' shift 147
+ '&' shift 148
+ . reduce 50 (src line 425)
+
+
+state 255
+ expr: expr.LOROR expr
+ expr: expr LOROR expr. (94)
+ expr: expr.LANDAND expr
+ expr: expr.LEQ expr
+ expr: expr.LNE expr
+ expr: expr.LLT expr
+ expr: expr.LLE expr
+ expr: expr.LGE expr
+ expr: expr.LGT expr
+ expr: expr.'+' expr
+ expr: expr.'-' expr
+ expr: expr.'|' expr
+ expr: expr.'^' expr
+ expr: expr.'*' expr
+ expr: expr.'/' expr
+ expr: expr.'%' expr
+ expr: expr.'&' expr
+ expr: expr.LANDNOT expr
+ expr: expr.LLSH expr
+ expr: expr.LRSH expr
+ expr: expr.LCOMM expr
+
+ LANDAND shift 134
+ LANDNOT shift 149
+ LEQ shift 135
+ LGE shift 139
+ LGT shift 140
+ LLE shift 138
+ LLSH shift 150
+ LLT shift 137
+ LNE shift 136
+ LRSH shift 151
+ '+' shift 141
+ '-' shift 142
+ '|' shift 143
+ '^' shift 144
+ '*' shift 145
+ '/' shift 146
+ '%' shift 147
+ '&' shift 148
+ . reduce 94 (src line 795)
+
+
+state 256
+ expr: expr.LOROR expr
+ expr: expr.LANDAND expr
+ expr: expr LANDAND expr. (95)
+ expr: expr.LEQ expr
+ expr: expr.LNE expr
+ expr: expr.LLT expr
+ expr: expr.LLE expr
+ expr: expr.LGE expr
+ expr: expr.LGT expr
+ expr: expr.'+' expr
+ expr: expr.'-' expr
+ expr: expr.'|' expr
+ expr: expr.'^' expr
+ expr: expr.'*' expr
+ expr: expr.'/' expr
+ expr: expr.'%' expr
+ expr: expr.'&' expr
+ expr: expr.LANDNOT expr
+ expr: expr.LLSH expr
+ expr: expr.LRSH expr
+ expr: expr.LCOMM expr
+
+ LANDNOT shift 149
+ LEQ shift 135
+ LGE shift 139
+ LGT shift 140
+ LLE shift 138
+ LLSH shift 150
+ LLT shift 137
+ LNE shift 136
+ LRSH shift 151
+ '+' shift 141
+ '-' shift 142
+ '|' shift 143
+ '^' shift 144
+ '*' shift 145
+ '/' shift 146
+ '%' shift 147
+ '&' shift 148
+ . reduce 95 (src line 799)
+
+
+state 257
+ expr: expr.LOROR expr
+ expr: expr.LANDAND expr
+ expr: expr.LEQ expr
+ expr: expr LEQ expr. (96)
+ expr: expr.LNE expr
+ expr: expr.LLT expr
+ expr: expr.LLE expr
+ expr: expr.LGE expr
+ expr: expr.LGT expr
+ expr: expr.'+' expr
+ expr: expr.'-' expr
+ expr: expr.'|' expr
+ expr: expr.'^' expr
+ expr: expr.'*' expr
+ expr: expr.'/' expr
+ expr: expr.'%' expr
+ expr: expr.'&' expr
+ expr: expr.LANDNOT expr
+ expr: expr.LLSH expr
+ expr: expr.LRSH expr
+ expr: expr.LCOMM expr
+
+ LANDNOT shift 149
+ LLSH shift 150
+ LRSH shift 151
+ '+' shift 141
+ '-' shift 142
+ '|' shift 143
+ '^' shift 144
+ '*' shift 145
+ '/' shift 146
+ '%' shift 147
+ '&' shift 148
+ . reduce 96 (src line 803)
+
+
+state 258
+ expr: expr.LOROR expr
+ expr: expr.LANDAND expr
+ expr: expr.LEQ expr
+ expr: expr.LNE expr
+ expr: expr LNE expr. (97)
+ expr: expr.LLT expr
+ expr: expr.LLE expr
+ expr: expr.LGE expr
+ expr: expr.LGT expr
+ expr: expr.'+' expr
+ expr: expr.'-' expr
+ expr: expr.'|' expr
+ expr: expr.'^' expr
+ expr: expr.'*' expr
+ expr: expr.'/' expr
+ expr: expr.'%' expr
+ expr: expr.'&' expr
+ expr: expr.LANDNOT expr
+ expr: expr.LLSH expr
+ expr: expr.LRSH expr
+ expr: expr.LCOMM expr
+
+ LANDNOT shift 149
+ LLSH shift 150
+ LRSH shift 151
+ '+' shift 141
+ '-' shift 142
+ '|' shift 143
+ '^' shift 144
+ '*' shift 145
+ '/' shift 146
+ '%' shift 147
+ '&' shift 148
+ . reduce 97 (src line 807)
+
+
+state 259
+ expr: expr.LOROR expr
+ expr: expr.LANDAND expr
+ expr: expr.LEQ expr
+ expr: expr.LNE expr
+ expr: expr.LLT expr
+ expr: expr LLT expr. (98)
+ expr: expr.LLE expr
+ expr: expr.LGE expr
+ expr: expr.LGT expr
+ expr: expr.'+' expr
+ expr: expr.'-' expr
+ expr: expr.'|' expr
+ expr: expr.'^' expr
+ expr: expr.'*' expr
+ expr: expr.'/' expr
+ expr: expr.'%' expr
+ expr: expr.'&' expr
+ expr: expr.LANDNOT expr
+ expr: expr.LLSH expr
+ expr: expr.LRSH expr
+ expr: expr.LCOMM expr
+
+ LANDNOT shift 149
+ LLSH shift 150
+ LRSH shift 151
+ '+' shift 141
+ '-' shift 142
+ '|' shift 143
+ '^' shift 144
+ '*' shift 145
+ '/' shift 146
+ '%' shift 147
+ '&' shift 148
+ . reduce 98 (src line 811)
+
+
+state 260
+ expr: expr.LOROR expr
+ expr: expr.LANDAND expr
+ expr: expr.LEQ expr
+ expr: expr.LNE expr
+ expr: expr.LLT expr
+ expr: expr.LLE expr
+ expr: expr LLE expr. (99)
+ expr: expr.LGE expr
+ expr: expr.LGT expr
+ expr: expr.'+' expr
+ expr: expr.'-' expr
+ expr: expr.'|' expr
+ expr: expr.'^' expr
+ expr: expr.'*' expr
+ expr: expr.'/' expr
+ expr: expr.'%' expr
+ expr: expr.'&' expr
+ expr: expr.LANDNOT expr
+ expr: expr.LLSH expr
+ expr: expr.LRSH expr
+ expr: expr.LCOMM expr
+
+ LANDNOT shift 149
+ LLSH shift 150
+ LRSH shift 151
+ '+' shift 141
+ '-' shift 142
+ '|' shift 143
+ '^' shift 144
+ '*' shift 145
+ '/' shift 146
+ '%' shift 147
+ '&' shift 148
+ . reduce 99 (src line 815)
+
+
+state 261
+ expr: expr.LOROR expr
+ expr: expr.LANDAND expr
+ expr: expr.LEQ expr
+ expr: expr.LNE expr
+ expr: expr.LLT expr
+ expr: expr.LLE expr
+ expr: expr.LGE expr
+ expr: expr LGE expr. (100)
+ expr: expr.LGT expr
+ expr: expr.'+' expr
+ expr: expr.'-' expr
+ expr: expr.'|' expr
+ expr: expr.'^' expr
+ expr: expr.'*' expr
+ expr: expr.'/' expr
+ expr: expr.'%' expr
+ expr: expr.'&' expr
+ expr: expr.LANDNOT expr
+ expr: expr.LLSH expr
+ expr: expr.LRSH expr
+ expr: expr.LCOMM expr
+
+ LANDNOT shift 149
+ LLSH shift 150
+ LRSH shift 151
+ '+' shift 141
+ '-' shift 142
+ '|' shift 143
+ '^' shift 144
+ '*' shift 145
+ '/' shift 146
+ '%' shift 147
+ '&' shift 148
+ . reduce 100 (src line 819)
+
+
+state 262
+ expr: expr.LOROR expr
+ expr: expr.LANDAND expr
+ expr: expr.LEQ expr
+ expr: expr.LNE expr
+ expr: expr.LLT expr
+ expr: expr.LLE expr
+ expr: expr.LGE expr
+ expr: expr.LGT expr
+ expr: expr LGT expr. (101)
+ expr: expr.'+' expr
+ expr: expr.'-' expr
+ expr: expr.'|' expr
+ expr: expr.'^' expr
+ expr: expr.'*' expr
+ expr: expr.'/' expr
+ expr: expr.'%' expr
+ expr: expr.'&' expr
+ expr: expr.LANDNOT expr
+ expr: expr.LLSH expr
+ expr: expr.LRSH expr
+ expr: expr.LCOMM expr
+
+ LANDNOT shift 149
+ LLSH shift 150
+ LRSH shift 151
+ '+' shift 141
+ '-' shift 142
+ '|' shift 143
+ '^' shift 144
+ '*' shift 145
+ '/' shift 146
+ '%' shift 147
+ '&' shift 148
+ . reduce 101 (src line 823)
+
+
+state 263
+ expr: expr.LOROR expr
+ expr: expr.LANDAND expr
+ expr: expr.LEQ expr
+ expr: expr.LNE expr
+ expr: expr.LLT expr
+ expr: expr.LLE expr
+ expr: expr.LGE expr
+ expr: expr.LGT expr
+ expr: expr.'+' expr
+ expr: expr '+' expr. (102)
+ expr: expr.'-' expr
+ expr: expr.'|' expr
+ expr: expr.'^' expr
+ expr: expr.'*' expr
+ expr: expr.'/' expr
+ expr: expr.'%' expr
+ expr: expr.'&' expr
+ expr: expr.LANDNOT expr
+ expr: expr.LLSH expr
+ expr: expr.LRSH expr
+ expr: expr.LCOMM expr
+
+ LANDNOT shift 149
+ LLSH shift 150
+ LRSH shift 151
+ '*' shift 145
+ '/' shift 146
+ '%' shift 147
+ '&' shift 148
+ . reduce 102 (src line 827)
+
+
+state 264
+ expr: expr.LOROR expr
+ expr: expr.LANDAND expr
+ expr: expr.LEQ expr
+ expr: expr.LNE expr
+ expr: expr.LLT expr
+ expr: expr.LLE expr
+ expr: expr.LGE expr
+ expr: expr.LGT expr
+ expr: expr.'+' expr
+ expr: expr.'-' expr
+ expr: expr '-' expr. (103)
+ expr: expr.'|' expr
+ expr: expr.'^' expr
+ expr: expr.'*' expr
+ expr: expr.'/' expr
+ expr: expr.'%' expr
+ expr: expr.'&' expr
+ expr: expr.LANDNOT expr
+ expr: expr.LLSH expr
+ expr: expr.LRSH expr
+ expr: expr.LCOMM expr
+
+ LANDNOT shift 149
+ LLSH shift 150
+ LRSH shift 151
+ '*' shift 145
+ '/' shift 146
+ '%' shift 147
+ '&' shift 148
+ . reduce 103 (src line 831)
+
+
+state 265
+ expr: expr.LOROR expr
+ expr: expr.LANDAND expr
+ expr: expr.LEQ expr
+ expr: expr.LNE expr
+ expr: expr.LLT expr
+ expr: expr.LLE expr
+ expr: expr.LGE expr
+ expr: expr.LGT expr
+ expr: expr.'+' expr
+ expr: expr.'-' expr
+ expr: expr.'|' expr
+ expr: expr '|' expr. (104)
+ expr: expr.'^' expr
+ expr: expr.'*' expr
+ expr: expr.'/' expr
+ expr: expr.'%' expr
+ expr: expr.'&' expr
+ expr: expr.LANDNOT expr
+ expr: expr.LLSH expr
+ expr: expr.LRSH expr
+ expr: expr.LCOMM expr
+
+ LANDNOT shift 149
+ LLSH shift 150
+ LRSH shift 151
+ '*' shift 145
+ '/' shift 146
+ '%' shift 147
+ '&' shift 148
+ . reduce 104 (src line 835)
+
+
+state 266
+ expr: expr.LOROR expr
+ expr: expr.LANDAND expr
+ expr: expr.LEQ expr
+ expr: expr.LNE expr
+ expr: expr.LLT expr
+ expr: expr.LLE expr
+ expr: expr.LGE expr
+ expr: expr.LGT expr
+ expr: expr.'+' expr
+ expr: expr.'-' expr
+ expr: expr.'|' expr
+ expr: expr.'^' expr
+ expr: expr '^' expr. (105)
+ expr: expr.'*' expr
+ expr: expr.'/' expr
+ expr: expr.'%' expr
+ expr: expr.'&' expr
+ expr: expr.LANDNOT expr
+ expr: expr.LLSH expr
+ expr: expr.LRSH expr
+ expr: expr.LCOMM expr
+
+ LANDNOT shift 149
+ LLSH shift 150
+ LRSH shift 151
+ '*' shift 145
+ '/' shift 146
+ '%' shift 147
+ '&' shift 148
+ . reduce 105 (src line 839)
+
+
+state 267
+ expr: expr.LOROR expr
+ expr: expr.LANDAND expr
+ expr: expr.LEQ expr
+ expr: expr.LNE expr
+ expr: expr.LLT expr
+ expr: expr.LLE expr
+ expr: expr.LGE expr
+ expr: expr.LGT expr
+ expr: expr.'+' expr
+ expr: expr.'-' expr
+ expr: expr.'|' expr
+ expr: expr.'^' expr
+ expr: expr.'*' expr
+ expr: expr '*' expr. (106)
+ expr: expr.'/' expr
+ expr: expr.'%' expr
+ expr: expr.'&' expr
+ expr: expr.LANDNOT expr
+ expr: expr.LLSH expr
+ expr: expr.LRSH expr
+ expr: expr.LCOMM expr
+
+ . reduce 106 (src line 843)
+
+
+state 268
+ expr: expr.LOROR expr
+ expr: expr.LANDAND expr
+ expr: expr.LEQ expr
+ expr: expr.LNE expr
+ expr: expr.LLT expr
+ expr: expr.LLE expr
+ expr: expr.LGE expr
+ expr: expr.LGT expr
+ expr: expr.'+' expr
+ expr: expr.'-' expr
+ expr: expr.'|' expr
+ expr: expr.'^' expr
+ expr: expr.'*' expr
+ expr: expr.'/' expr
+ expr: expr '/' expr. (107)
+ expr: expr.'%' expr
+ expr: expr.'&' expr
+ expr: expr.LANDNOT expr
+ expr: expr.LLSH expr
+ expr: expr.LRSH expr
+ expr: expr.LCOMM expr
+
+ . reduce 107 (src line 847)
+
+
+state 269
+ expr: expr.LOROR expr
+ expr: expr.LANDAND expr
+ expr: expr.LEQ expr
+ expr: expr.LNE expr
+ expr: expr.LLT expr
+ expr: expr.LLE expr
+ expr: expr.LGE expr
+ expr: expr.LGT expr
+ expr: expr.'+' expr
+ expr: expr.'-' expr
+ expr: expr.'|' expr
+ expr: expr.'^' expr
+ expr: expr.'*' expr
+ expr: expr.'/' expr
+ expr: expr.'%' expr
+ expr: expr '%' expr. (108)
+ expr: expr.'&' expr
+ expr: expr.LANDNOT expr
+ expr: expr.LLSH expr
+ expr: expr.LRSH expr
+ expr: expr.LCOMM expr
+
+ . reduce 108 (src line 851)
+
+
+state 270
+ expr: expr.LOROR expr
+ expr: expr.LANDAND expr
+ expr: expr.LEQ expr
+ expr: expr.LNE expr
+ expr: expr.LLT expr
+ expr: expr.LLE expr
+ expr: expr.LGE expr
+ expr: expr.LGT expr
+ expr: expr.'+' expr
+ expr: expr.'-' expr
+ expr: expr.'|' expr
+ expr: expr.'^' expr
+ expr: expr.'*' expr
+ expr: expr.'/' expr
+ expr: expr.'%' expr
+ expr: expr.'&' expr
+ expr: expr '&' expr. (109)
+ expr: expr.LANDNOT expr
+ expr: expr.LLSH expr
+ expr: expr.LRSH expr
+ expr: expr.LCOMM expr
+
+ . reduce 109 (src line 855)
+
+
+state 271
+ expr: expr.LOROR expr
+ expr: expr.LANDAND expr
+ expr: expr.LEQ expr
+ expr: expr.LNE expr
+ expr: expr.LLT expr
+ expr: expr.LLE expr
+ expr: expr.LGE expr
+ expr: expr.LGT expr
+ expr: expr.'+' expr
+ expr: expr.'-' expr
+ expr: expr.'|' expr
+ expr: expr.'^' expr
+ expr: expr.'*' expr
+ expr: expr.'/' expr
+ expr: expr.'%' expr
+ expr: expr.'&' expr
+ expr: expr.LANDNOT expr
+ expr: expr LANDNOT expr. (110)
+ expr: expr.LLSH expr
+ expr: expr.LRSH expr
+ expr: expr.LCOMM expr
+
+ . reduce 110 (src line 859)
+
+
+state 272
+ expr: expr.LOROR expr
+ expr: expr.LANDAND expr
+ expr: expr.LEQ expr
+ expr: expr.LNE expr
+ expr: expr.LLT expr
+ expr: expr.LLE expr
+ expr: expr.LGE expr
+ expr: expr.LGT expr
+ expr: expr.'+' expr
+ expr: expr.'-' expr
+ expr: expr.'|' expr
+ expr: expr.'^' expr
+ expr: expr.'*' expr
+ expr: expr.'/' expr
+ expr: expr.'%' expr
+ expr: expr.'&' expr
+ expr: expr.LANDNOT expr
+ expr: expr.LLSH expr
+ expr: expr LLSH expr. (111)
+ expr: expr.LRSH expr
+ expr: expr.LCOMM expr
+
+ . reduce 111 (src line 863)
+
+
+state 273
+ expr: expr.LOROR expr
+ expr: expr.LANDAND expr
+ expr: expr.LEQ expr
+ expr: expr.LNE expr
+ expr: expr.LLT expr
+ expr: expr.LLE expr
+ expr: expr.LGE expr
+ expr: expr.LGT expr
+ expr: expr.'+' expr
+ expr: expr.'-' expr
+ expr: expr.'|' expr
+ expr: expr.'^' expr
+ expr: expr.'*' expr
+ expr: expr.'/' expr
+ expr: expr.'%' expr
+ expr: expr.'&' expr
+ expr: expr.LANDNOT expr
+ expr: expr.LLSH expr
+ expr: expr.LRSH expr
+ expr: expr LRSH expr. (112)
+ expr: expr.LCOMM expr
+
+ . reduce 112 (src line 867)
+
+
+state 274
+ expr: expr.LOROR expr
+ expr: expr.LANDAND expr
+ expr: expr.LEQ expr
+ expr: expr.LNE expr
+ expr: expr.LLT expr
+ expr: expr.LLE expr
+ expr: expr.LGE expr
+ expr: expr.LGT expr
+ expr: expr.'+' expr
+ expr: expr.'-' expr
+ expr: expr.'|' expr
+ expr: expr.'^' expr
+ expr: expr.'*' expr
+ expr: expr.'/' expr
+ expr: expr.'%' expr
+ expr: expr.'&' expr
+ expr: expr.LANDNOT expr
+ expr: expr.LLSH expr
+ expr: expr.LRSH expr
+ expr: expr.LCOMM expr
+ expr: expr LCOMM expr. (113)
+
+ LANDAND shift 134
+ LANDNOT shift 149
+ LEQ shift 135
+ LGE shift 139
+ LGT shift 140
+ LLE shift 138
+ LLSH shift 150
+ LLT shift 137
+ LNE shift 136
+ LOROR shift 133
+ LRSH shift 151
+ '+' shift 141
+ '-' shift 142
+ '|' shift 143
+ '^' shift 144
+ '*' shift 145
+ '/' shift 146
+ '%' shift 147
+ '&' shift 148
+ . reduce 113 (src line 872)
+
+
+state 275
+ simple_stmt: expr_list '=' expr_list. (51)
+ expr_list: expr_list.',' expr
+
+ ',' shift 155
+ . reduce 51 (src line 430)
+
+
+state 276
+ simple_stmt: expr_list LCOLAS expr_list. (52)
+ expr_list: expr_list.',' expr
+
+ ',' shift 155
+ . reduce 52 (src line 442)
+
+
+state 277
+ expr: expr.LOROR expr
+ expr: expr.LANDAND expr
+ expr: expr.LEQ expr
+ expr: expr.LNE expr
+ expr: expr.LLT expr
+ expr: expr.LLE expr
+ expr: expr.LGE expr
+ expr: expr.LGT expr
+ expr: expr.'+' expr
+ expr: expr.'-' expr
+ expr: expr.'|' expr
+ expr: expr.'^' expr
+ expr: expr.'*' expr
+ expr: expr.'/' expr
+ expr: expr.'%' expr
+ expr: expr.'&' expr
+ expr: expr.LANDNOT expr
+ expr: expr.LLSH expr
+ expr: expr.LRSH expr
+ expr: expr.LCOMM expr
+ expr_list: expr_list ',' expr. (277)
+
+ LANDAND shift 134
+ LANDNOT shift 149
+ LCOMM shift 152
+ LEQ shift 135
+ LGE shift 139
+ LGT shift 140
+ LLE shift 138
+ LLSH shift 150
+ LLT shift 137
+ LNE shift 136
+ LOROR shift 133
+ LRSH shift 151
+ '+' shift 141
+ '-' shift 142
+ '|' shift 143
+ '^' shift 144
+ '*' shift 145
+ '/' shift 146
+ '%' shift 147
+ '&' shift 148
+ . reduce 277 (src line 1845)
+
+
+state 278
+ for_stmt: LFOR $$74 for_body. (75)
+
+ . reduce 75 (src line 664)
+
+
+state 279
+ for_body: for_header.loop_body
+
+ LBODY shift 382
+ . error
+
+ loop_body goto 381
+
+state 280
+ for_header: osimple_stmt.';' osimple_stmt ';' osimple_stmt
+ for_header: osimple_stmt. (71)
+
+ ';' shift 383
+ . reduce 71 (src line 644)
+
+
+state 281
+ for_header: range_stmt. (72)
+
+ . reduce 72 (src line 650)
+
+
+state 282
+ osimple_stmt: simple_stmt. (295)
+
+ . reduce 295 (src line 1915)
+
+
+state 283
+ simple_stmt: expr_list.'=' expr_list
+ simple_stmt: expr_list.LCOLAS expr_list
+ range_stmt: expr_list.'=' LRANGE expr
+ range_stmt: expr_list.LCOLAS LRANGE expr
+ expr_list: expr_list.',' expr
+
+ LCOLAS shift 385
+ '=' shift 384
+ ',' shift 155
+ . error
+
+
+state 284
+ range_stmt: LRANGE.expr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 386
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 285
+ switch_stmt: LSWITCH $$88 if_header.$$89 LBODY caseblock_list '}'
+ $$89: . (89)
+
+ . reduce 89 (src line 759)
+
+ $$89 goto 387
+
+state 286
+ if_header: osimple_stmt. (76)
+ if_header: osimple_stmt.';' osimple_stmt
+
+ ';' shift 388
+ . reduce 76 (src line 670)
+
+
+state 287
+ select_stmt: LSELECT $$91 LBODY.caseblock_list '}'
+ caseblock_list: . (63)
+
+ . reduce 63 (src line 590)
+
+ caseblock_list goto 389
+
+state 288
+ if_stmt: LIF $$78 if_header.$$79 loop_body $$80 elseif_list else
+ $$79: . (79)
+
+ . reduce 79 (src line 693)
+
+ $$79 goto 390
+
+state 289
+ pseudocall: pexpr '(' ')'. (123)
+
+ . reduce 123 (src line 924)
+
+
+state 290
+ pseudocall: pexpr '(' expr_or_type_list.ocomma ')'
+ pseudocall: pexpr '(' expr_or_type_list.LDDD ocomma ')'
+ expr_or_type_list: expr_or_type_list.',' expr_or_type
+ ocomma: . (288)
+
+ LDDD shift 392
+ ',' shift 393
+ . reduce 288 (src line 1896)
+
+ ocomma goto 391
+
+state 291
+ expr_or_type_list: expr_or_type. (278)
+
+ . reduce 278 (src line 1850)
+
+
+state 292
+ pexpr_no_paren: pexpr '.' sym. (128)
+
+ . reduce 128 (src line 947)
+
+
+state 293
+ pexpr_no_paren: pexpr '.' '('.expr_or_type ')'
+ pexpr_no_paren: pexpr '.' '('.LTYPE ')'
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LTYPE shift 395
+ LCOMM shift 179
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 178
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 173
+ expr_or_type goto 394
+ fnliteral goto 73
+ name goto 69
+ non_expr_type goto 174
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ recvchantype goto 175
+ othertype goto 177
+ fntype goto 176
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 294
+ expr: expr.LOROR expr
+ expr: expr.LANDAND expr
+ expr: expr.LEQ expr
+ expr: expr.LNE expr
+ expr: expr.LLT expr
+ expr: expr.LLE expr
+ expr: expr.LGE expr
+ expr: expr.LGT expr
+ expr: expr.'+' expr
+ expr: expr.'-' expr
+ expr: expr.'|' expr
+ expr: expr.'^' expr
+ expr: expr.'*' expr
+ expr: expr.'/' expr
+ expr: expr.'%' expr
+ expr: expr.'&' expr
+ expr: expr.LANDNOT expr
+ expr: expr.LLSH expr
+ expr: expr.LRSH expr
+ expr: expr.LCOMM expr
+ pexpr_no_paren: pexpr '[' expr.']'
+ oexpr: expr. (291)
+
+ LANDAND shift 134
+ LANDNOT shift 149
+ LCOMM shift 152
+ LEQ shift 135
+ LGE shift 139
+ LGT shift 140
+ LLE shift 138
+ LLSH shift 150
+ LLT shift 137
+ LNE shift 136
+ LOROR shift 133
+ LRSH shift 151
+ '+' shift 141
+ '-' shift 142
+ '|' shift 143
+ '^' shift 144
+ '*' shift 145
+ '/' shift 146
+ '%' shift 147
+ '&' shift 148
+ ']' shift 396
+ . reduce 291 (src line 1903)
+
+
+state 295
+ pexpr_no_paren: pexpr '[' oexpr.':' oexpr ']'
+ pexpr_no_paren: pexpr '[' oexpr.':' oexpr ':' oexpr ']'
+
+ ':' shift 397
+ . error
+
+
+state 296
+ pexpr_no_paren: pexpr_no_paren '{' start_complit.braced_keyval_list '}'
+ braced_keyval_list: . (284)
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '{' shift 403
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . reduce 284 (src line 1881)
+
+ sym goto 123
+ expr goto 402
+ bare_complitexpr goto 401
+ fnliteral goto 73
+ keyval goto 400
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ keyval_list goto 399
+ braced_keyval_list goto 398
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 297
+ pexpr_no_paren: '(' expr_or_type ')'.'{' start_complit braced_keyval_list '}'
+ pexpr: '(' expr_or_type ')'. (147)
+
+ '{' shift 404
+ . reduce 147 (src line 1056)
+
+
+state 298
+ non_expr_type: '*' non_expr_type. (175)
+
+ . reduce 175 (src line 1205)
+
+
+state 299
+ othertype: LCHAN.non_recvchantype
+ othertype: LCHAN.LCOMM ntype
+ recvchantype: LCOMM LCHAN.ntype
+
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 405
+ '*' shift 196
+ '(' shift 411
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ ntype goto 406
+ dotname goto 410
+ name goto 197
+ interfacetype goto 81
+ structtype goto 80
+ ptrtype goto 409
+ recvchantype goto 226
+ non_recvchantype goto 189
+ othertype goto 408
+ fntype goto 407
+ hidden_importsym goto 11
+
+state 300
+ expr: expr.LOROR expr
+ expr: expr.LANDAND expr
+ expr: expr.LEQ expr
+ expr: expr.LNE expr
+ expr: expr.LLT expr
+ expr: expr.LLE expr
+ expr: expr.LGE expr
+ expr: expr.LGT expr
+ expr: expr.'+' expr
+ expr: expr.'-' expr
+ expr: expr.'|' expr
+ expr: expr.'^' expr
+ expr: expr.'*' expr
+ expr: expr.'/' expr
+ expr: expr.'%' expr
+ expr: expr.'&' expr
+ expr: expr.LANDNOT expr
+ expr: expr.LLSH expr
+ expr: expr.LRSH expr
+ expr: expr.LCOMM expr
+ pexpr_no_paren: convtype '(' expr.ocomma ')'
+ ocomma: . (288)
+
+ LANDAND shift 134
+ LANDNOT shift 149
+ LCOMM shift 152
+ LEQ shift 135
+ LGE shift 139
+ LGT shift 140
+ LLE shift 138
+ LLSH shift 150
+ LLT shift 137
+ LNE shift 136
+ LOROR shift 133
+ LRSH shift 151
+ '+' shift 141
+ '-' shift 142
+ '|' shift 143
+ '^' shift 144
+ '*' shift 145
+ '/' shift 146
+ '%' shift 147
+ '&' shift 148
+ ',' shift 413
+ . reduce 288 (src line 1896)
+
+ ocomma goto 412
+
+state 301
+ pexpr_no_paren: comptype lbrace start_complit.braced_keyval_list '}'
+ braced_keyval_list: . (284)
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '{' shift 403
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . reduce 284 (src line 1881)
+
+ sym goto 123
+ expr goto 402
+ bare_complitexpr goto 401
+ fnliteral goto 73
+ keyval goto 400
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ keyval_list goto 399
+ braced_keyval_list goto 414
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 302
+ fnliteral: fnlitdcl lbrace stmt_list.'}'
+ stmt_list: stmt_list.';' stmt
+
+ ';' shift 416
+ '}' shift 415
+ . error
+
+
+state 303
+ stmt_list: stmt. (270)
+
+ . reduce 270 (src line 1804)
+
+
+state 304
+ stmt: compound_stmt. (252)
+
+ . reduce 252 (src line 1723)
+
+
+state 305
+ stmt: common_dcl. (253)
+
+ . reduce 253 (src line 1724)
+
+
+state 306
+ stmt: non_dcl_stmt. (254)
+
+ . reduce 254 (src line 1728)
+
+
+state 307
+ stmt: error. (255)
+
+ . reduce 255 (src line 1729)
+
+
+state 308
+ compound_stmt: '{'.$$59 stmt_list '}'
+ $$59: . (59)
+
+ . reduce 59 (src line 544)
+
+ $$59 goto 417
+
+state 309
+ othertype: '[' oexpr ']'.ntype
+
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 232
+ '*' shift 196
+ '(' shift 231
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ ntype goto 418
+ dotname goto 230
+ name goto 197
+ interfacetype goto 81
+ structtype goto 80
+ ptrtype goto 229
+ recvchantype goto 226
+ othertype goto 228
+ fntype goto 227
+ hidden_importsym goto 11
+
+state 310
+ othertype: '[' LDDD ']'.ntype
+
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 232
+ '*' shift 196
+ '(' shift 231
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ ntype goto 419
+ dotname goto 230
+ name goto 197
+ interfacetype goto 81
+ structtype goto 80
+ ptrtype goto 229
+ recvchantype goto 226
+ othertype goto 228
+ fntype goto 227
+ hidden_importsym goto 11
+
+state 311
+ othertype: LCHAN LCOMM ntype. (194)
+
+ . reduce 194 (src line 1263)
+
+
+state 312
+ non_recvchantype: '(' ntype.')'
+
+ ')' shift 420
+ . error
+
+
+state 313
+ ptrtype: '*' ntype. (198)
+
+ . reduce 198 (src line 1275)
+
+
+state 314
+ dotname: name '.'.sym
+
+ LNAME shift 10
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 421
+ hidden_importsym goto 11
+
+state 315
+ othertype: LMAP '[' ntype.']' ntype
+
+ ']' shift 422
+ . error
+
+
+state 316
+ structtype: LSTRUCT lbrace structdcl_list.osemi '}'
+ structdcl_list: structdcl_list.';' structdcl
+ osemi: . (286)
+
+ ';' shift 424
+ . reduce 286 (src line 1893)
+
+ osemi goto 423
+
+state 317
+ structtype: LSTRUCT lbrace '}'. (201)
+
+ . reduce 201 (src line 1295)
+
+
+state 318
+ structdcl_list: structdcl. (226)
+
+ . reduce 226 (src line 1547)
+
+
+state 319
+ structdcl: new_name_list.ntype oliteral
+ new_name_list: new_name_list.',' new_name
+
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 232
+ '*' shift 196
+ '(' shift 231
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ ',' shift 426
+ . error
+
+ sym goto 123
+ ntype goto 425
+ dotname goto 230
+ name goto 197
+ interfacetype goto 81
+ structtype goto 80
+ ptrtype goto 229
+ recvchantype goto 226
+ othertype goto 228
+ fntype goto 227
+ hidden_importsym goto 11
+
+state 320
+ structdcl: embed.oliteral
+ oliteral: . (302)
+
+ LLITERAL shift 428
+ . reduce 302 (src line 1935)
+
+ oliteral goto 427
+
+state 321
+ structdcl: '('.embed ')' oliteral
+ structdcl: '('.'*' embed ')' oliteral
+
+ LNAME shift 431
+ '*' shift 430
+ . error
+
+ packname goto 324
+ embed goto 429
+
+state 322
+ structdcl: '*'.embed oliteral
+ structdcl: '*'.'(' embed ')' oliteral
+
+ LNAME shift 431
+ '(' shift 433
+ . error
+
+ packname goto 324
+ embed goto 432
+
+state 323
+ new_name_list: new_name. (272)
+
+ . reduce 272 (src line 1820)
+
+
+state 324
+ embed: packname. (238)
+
+ . reduce 238 (src line 1646)
+
+
+state 325
+ sym: LNAME. (157)
+ packname: LNAME. (236)
+ packname: LNAME.'.' sym
+
+ LLITERAL reduce 236 (src line 1621)
+ ';' reduce 236 (src line 1621)
+ '.' shift 434
+ '}' reduce 236 (src line 1621)
+ . reduce 157 (src line 1113)
+
+
+state 326
+ interfacetype: LINTERFACE lbrace interfacedcl_list.osemi '}'
+ interfacedcl_list: interfacedcl_list.';' interfacedcl
+ osemi: . (286)
+
+ ';' shift 436
+ . reduce 286 (src line 1893)
+
+ osemi goto 435
+
+state 327
+ interfacetype: LINTERFACE lbrace '}'. (203)
+
+ . reduce 203 (src line 1308)
+
+
+state 328
+ interfacedcl_list: interfacedcl. (228)
+
+ . reduce 228 (src line 1554)
+
+
+state 329
+ interfacedcl: new_name.indcl
+
+ '(' shift 438
+ . error
+
+ indcl goto 437
+
+state 330
+ interfacedcl: packname. (240)
+
+ . reduce 240 (src line 1658)
+
+
+state 331
+ interfacedcl: '('.packname ')'
+
+ LNAME shift 431
+ . error
+
+ packname goto 439
+
+state 332
+ import: LIMPORT '(' import_stmt_list osemi.')'
+
+ ')' shift 440
+ . error
+
+
+state 333
+ import_stmt_list: import_stmt_list ';'.import_stmt
+ osemi: ';'. (287)
+
+ LLITERAL shift 88
+ LNAME shift 10
+ '.' shift 90
+ '?' shift 12
+ '@' shift 13
+ . reduce 287 (src line 1894)
+
+ import_here goto 87
+ sym goto 89
+ hidden_importsym goto 11
+ import_stmt goto 441
+
+state 334
+ import_stmt: import_here import_package import_there. (11)
+
+ . reduce 11 (src line 173)
+
+
+state 335
+ hidden_import: LIMPORT LNAME LLITERAL.';'
+
+ ';' shift 442
+ . error
+
+
+state 336
+ hidden_import: LVAR hidden_pkg_importsym hidden_type.';'
+
+ ';' shift 443
+ . error
+
+
+state 337
+ hidden_type: hidden_type_misc. (312)
+
+ . reduce 312 (src line 2003)
+
+
+state 338
+ hidden_type: hidden_type_recv_chan. (313)
+
+ . reduce 313 (src line 2005)
+
+
+state 339
+ hidden_type: hidden_type_func. (314)
+
+ . reduce 314 (src line 2006)
+
+
+state 340
+ hidden_type_misc: hidden_importsym. (317)
+
+ . reduce 317 (src line 2012)
+
+
+state 341
+ hidden_type_misc: LNAME. (318)
+
+ . reduce 318 (src line 2017)
+
+
+state 342
+ hidden_type_misc: '['.']' hidden_type
+ hidden_type_misc: '['.LLITERAL ']' hidden_type
+
+ LLITERAL shift 445
+ ']' shift 444
+ . error
+
+
+state 343
+ hidden_type_misc: LMAP.'[' hidden_type ']' hidden_type
+
+ '[' shift 446
+ . error
+
+
+state 344
+ hidden_type_misc: LSTRUCT.'{' ohidden_structdcl_list '}'
+
+ '{' shift 447
+ . error
+
+
+state 345
+ hidden_type_misc: LINTERFACE.'{' ohidden_interfacedcl_list '}'
+
+ '{' shift 448
+ . error
+
+
+state 346
+ hidden_type_misc: '*'.hidden_type
+
+ LCHAN shift 347
+ LFUNC shift 349
+ LINTERFACE shift 345
+ LMAP shift 343
+ LNAME shift 341
+ LSTRUCT shift 344
+ LCOMM shift 348
+ '*' shift 346
+ '[' shift 342
+ '@' shift 13
+ . error
+
+ hidden_importsym goto 340
+ hidden_type goto 449
+ hidden_type_misc goto 337
+ hidden_type_func goto 339
+ hidden_type_recv_chan goto 338
+
+state 347
+ hidden_type_misc: LCHAN.hidden_type_non_recv_chan
+ hidden_type_misc: LCHAN.'(' hidden_type_recv_chan ')'
+ hidden_type_misc: LCHAN.LCOMM hidden_type
+
+ LCHAN shift 347
+ LFUNC shift 349
+ LINTERFACE shift 345
+ LMAP shift 343
+ LNAME shift 341
+ LSTRUCT shift 344
+ LCOMM shift 452
+ '*' shift 346
+ '(' shift 451
+ '[' shift 342
+ '@' shift 13
+ . error
+
+ hidden_importsym goto 340
+ hidden_type_misc goto 453
+ hidden_type_func goto 454
+ hidden_type_non_recv_chan goto 450
+
+state 348
+ hidden_type_recv_chan: LCOMM.LCHAN hidden_type
+
+ LCHAN shift 455
+ . error
+
+
+state 349
+ hidden_type_func: LFUNC.'(' ohidden_funarg_list ')' ohidden_funres
+
+ '(' shift 456
+ . error
+
+
+state 350
+ hidden_import: LCONST hidden_pkg_importsym '='.hidden_constant ';'
+
+ LLITERAL shift 460
+ LNAME shift 10
+ '-' shift 461
+ '(' shift 459
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 462
+ hidden_importsym goto 11
+ hidden_constant goto 457
+ hidden_literal goto 458
+
+state 351
+ hidden_import: LCONST hidden_pkg_importsym hidden_type.'=' hidden_constant ';'
+
+ '=' shift 463
+ . error
+
+
+state 352
+ hidden_import: LTYPE hidden_pkgtype hidden_type.';'
+
+ ';' shift 464
+ . error
+
+
+state 353
+ hidden_import: LFUNC hidden_fndcl fnbody.';'
+
+ ';' shift 465
+ . error
+
+
+state 354
+ hidden_fndcl: hidden_pkg_importsym '('.ohidden_funarg_list ')' ohidden_funres
+ ohidden_funarg_list: . (296)
+
+ LNAME shift 10
+ '?' shift 12
+ '@' shift 13
+ . reduce 296 (src line 1917)
+
+ sym goto 357
+ hidden_importsym goto 11
+ hidden_funarg goto 356
+ hidden_funarg_list goto 467
+ ohidden_funarg_list goto 466
+
+state 355
+ hidden_fndcl: '(' hidden_funarg_list.')' sym '(' ohidden_funarg_list ')' ohidden_funres
+ hidden_funarg_list: hidden_funarg_list.',' hidden_funarg
+
+ ')' shift 468
+ ',' shift 469
+ . error
+
+
+state 356
+ hidden_funarg_list: hidden_funarg. (346)
+
+ . reduce 346 (src line 2212)
+
+
+state 357
+ hidden_funarg: sym.hidden_type oliteral
+ hidden_funarg: sym.LDDD hidden_type oliteral
+
+ LCHAN shift 347
+ LDDD shift 471
+ LFUNC shift 349
+ LINTERFACE shift 345
+ LMAP shift 343
+ LNAME shift 341
+ LSTRUCT shift 344
+ LCOMM shift 348
+ '*' shift 346
+ '[' shift 342
+ '@' shift 13
+ . error
+
+ hidden_importsym goto 340
+ hidden_type goto 470
+ hidden_type_misc goto 337
+ hidden_type_func goto 339
+ hidden_type_recv_chan goto 338
+
+state 358
+ common_dcl: LVAR '(' vardcl_list osemi.')'
+
+ ')' shift 472
+ . error
+
+
+state 359
+ vardcl_list: vardcl_list ';'.vardcl
+ osemi: ';'. (287)
+
+ LNAME shift 10
+ '?' shift 12
+ '@' shift 13
+ . reduce 287 (src line 1894)
+
+ sym goto 105
+ dcl_name goto 104
+ dcl_name_list goto 103
+ vardcl goto 473
+ hidden_importsym goto 11
+
+state 360
+ vardcl: dcl_name_list ntype '='.expr_list
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 129
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ expr_list goto 474
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 361
+ vardcl: dcl_name_list '=' expr_list. (41)
+ expr_list: expr_list.',' expr
+
+ ',' shift 155
+ . reduce 41 (src line 369)
+
+
+state 362
+ dcl_name_list: dcl_name_list ',' dcl_name. (275)
+
+ . reduce 275 (src line 1835)
+
+
+state 363
+ ntype: '(' ntype.')'
+
+ ')' shift 475
+ . error
+
+
+state 364
+ recvchantype: LCOMM LCHAN.ntype
+
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 232
+ '*' shift 196
+ '(' shift 231
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ ntype goto 406
+ dotname goto 230
+ name goto 197
+ interfacetype goto 81
+ structtype goto 80
+ ptrtype goto 229
+ recvchantype goto 226
+ othertype goto 228
+ fntype goto 227
+ hidden_importsym goto 11
+
+state 365
+ common_dcl: lconst '(' constdcl osemi.')'
+
+ ')' shift 476
+ . error
+
+
+state 366
+ common_dcl: lconst '(' constdcl ';'.constdcl_list osemi ')'
+ osemi: ';'. (287)
+
+ LNAME shift 10
+ '?' shift 12
+ '@' shift 13
+ . reduce 287 (src line 1894)
+
+ sym goto 105
+ dcl_name goto 104
+ dcl_name_list goto 480
+ constdcl goto 479
+ constdcl1 goto 478
+ constdcl_list goto 477
+ hidden_importsym goto 11
+
+state 367
+ constdcl: dcl_name_list ntype '='.expr_list
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 129
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ expr_list goto 481
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 368
+ constdcl: dcl_name_list '=' expr_list. (43)
+ expr_list: expr_list.',' expr
+
+ ',' shift 155
+ . reduce 43 (src line 379)
+
+
+state 369
+ common_dcl: LTYPE '(' typedcl_list osemi.')'
+
+ ')' shift 482
+ . error
+
+
+state 370
+ typedcl_list: typedcl_list ';'.typedcl
+ osemi: ';'. (287)
+
+ LNAME shift 10
+ '?' shift 12
+ '@' shift 13
+ . reduce 287 (src line 1894)
+
+ sym goto 112
+ typedclname goto 111
+ typedcl goto 483
+ hidden_importsym goto 11
+
+state 371
+ fnbody: '{' stmt_list.'}'
+ stmt_list: stmt_list.';' stmt
+
+ ';' shift 416
+ '}' shift 484
+ . error
+
+
+state 372
+ fndcl: '(' oarg_type_list_ocomma ')'.sym '(' oarg_type_list_ocomma ')' fnres
+ fntype: LFUNC '(' oarg_type_list_ocomma ')'.fnres
+ fnres: . (212)
+
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 232
+ '*' shift 196
+ '(' shift 488
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . reduce 212 (src line 1469)
+
+ sym goto 485
+ dotname goto 493
+ name goto 197
+ fnres goto 486
+ interfacetype goto 81
+ structtype goto 80
+ ptrtype goto 492
+ recvchantype goto 489
+ othertype goto 491
+ fnret_type goto 487
+ fntype goto 490
+ hidden_importsym goto 11
+
+state 373
+ arg_type_list: arg_type_list ','.arg_type
+ ocomma: ','. (289)
+
+ LCHAN shift 78
+ LDDD shift 250
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 232
+ '*' shift 196
+ '(' shift 231
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . reduce 289 (src line 1897)
+
+ sym goto 247
+ ntype goto 249
+ arg_type goto 494
+ dotname goto 230
+ name goto 197
+ name_or_type goto 246
+ dotdotdot goto 248
+ interfacetype goto 81
+ structtype goto 80
+ ptrtype goto 229
+ recvchantype goto 226
+ othertype goto 228
+ fntype goto 227
+ hidden_importsym goto 11
+
+state 374
+ oarg_type_list_ocomma: arg_type_list ocomma. (250)
+
+ . reduce 250 (src line 1711)
+
+
+state 375
+ arg_type: sym name_or_type. (244)
+
+ . reduce 244 (src line 1683)
+
+
+state 376
+ arg_type: sym dotdotdot. (245)
+
+ . reduce 245 (src line 1689)
+
+
+state 377
+ dotdotdot: LDDD ntype. (165)
+
+ . reduce 165 (src line 1185)
+
+
+state 378
+ fndcl: sym '(' oarg_type_list_ocomma.')' fnres
+
+ ')' shift 495
+ . error
+
+
+state 379
+ non_dcl_stmt: labelname ':' $$261 stmt. (262)
+
+ . reduce 262 (src line 1745)
+
+
+state 380
+ fntype: LFUNC '(' oarg_type_list_ocomma.')' fnres
+
+ ')' shift 496
+ . error
+
+
+state 381
+ for_body: for_header loop_body. (73)
+
+ . reduce 73 (src line 652)
+
+
+state 382
+ loop_body: LBODY.$$65 stmt_list '}'
+ $$65: . (65)
+
+ . reduce 65 (src line 599)
+
+ $$65 goto 497
+
+state 383
+ for_header: osimple_stmt ';'.osimple_stmt ';' osimple_stmt
+ osimple_stmt: . (294)
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . reduce 294 (src line 1911)
+
+ sym goto 123
+ expr goto 48
+ fnliteral goto 73
+ name goto 69
+ osimple_stmt goto 498
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ simple_stmt goto 282
+ uexpr goto 55
+ expr_list goto 49
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 384
+ simple_stmt: expr_list '='.expr_list
+ range_stmt: expr_list '='.LRANGE expr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LRANGE shift 499
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 129
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ expr_list goto 275
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 385
+ simple_stmt: expr_list LCOLAS.expr_list
+ range_stmt: expr_list LCOLAS.LRANGE expr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LRANGE shift 500
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 129
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ expr_list goto 276
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 386
+ range_stmt: LRANGE expr. (69)
+ expr: expr.LOROR expr
+ expr: expr.LANDAND expr
+ expr: expr.LEQ expr
+ expr: expr.LNE expr
+ expr: expr.LLT expr
+ expr: expr.LLE expr
+ expr: expr.LGE expr
+ expr: expr.LGT expr
+ expr: expr.'+' expr
+ expr: expr.'-' expr
+ expr: expr.'|' expr
+ expr: expr.'^' expr
+ expr: expr.'*' expr
+ expr: expr.'/' expr
+ expr: expr.'%' expr
+ expr: expr.'&' expr
+ expr: expr.LANDNOT expr
+ expr: expr.LLSH expr
+ expr: expr.LRSH expr
+ expr: expr.LCOMM expr
+
+ LANDAND shift 134
+ LANDNOT shift 149
+ LCOMM shift 152
+ LEQ shift 135
+ LGE shift 139
+ LGT shift 140
+ LLE shift 138
+ LLSH shift 150
+ LLT shift 137
+ LNE shift 136
+ LOROR shift 133
+ LRSH shift 151
+ '+' shift 141
+ '-' shift 142
+ '|' shift 143
+ '^' shift 144
+ '*' shift 145
+ '/' shift 146
+ '%' shift 147
+ '&' shift 148
+ . reduce 69 (src line 624)
+
+
+state 387
+ switch_stmt: LSWITCH $$88 if_header $$89.LBODY caseblock_list '}'
+
+ LBODY shift 501
+ . error
+
+
+state 388
+ if_header: osimple_stmt ';'.osimple_stmt
+ osimple_stmt: . (294)
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . reduce 294 (src line 1911)
+
+ sym goto 123
+ expr goto 48
+ fnliteral goto 73
+ name goto 69
+ osimple_stmt goto 502
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ simple_stmt goto 282
+ uexpr goto 55
+ expr_list goto 49
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 389
+ caseblock_list: caseblock_list.caseblock
+ select_stmt: LSELECT $$91 LBODY caseblock_list.'}'
+
+ LCASE shift 506
+ LDEFAULT shift 507
+ '}' shift 504
+ . error
+
+ case goto 505
+ caseblock goto 503
+
+state 390
+ if_stmt: LIF $$78 if_header $$79.loop_body $$80 elseif_list else
+
+ LBODY shift 382
+ . error
+
+ loop_body goto 508
+
+state 391
+ pseudocall: pexpr '(' expr_or_type_list ocomma.')'
+
+ ')' shift 509
+ . error
+
+
+state 392
+ pseudocall: pexpr '(' expr_or_type_list LDDD.ocomma ')'
+ ocomma: . (288)
+
+ ',' shift 413
+ . reduce 288 (src line 1896)
+
+ ocomma goto 510
+
+state 393
+ expr_or_type_list: expr_or_type_list ','.expr_or_type
+ ocomma: ','. (289)
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 179
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 178
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . reduce 289 (src line 1897)
+
+ sym goto 123
+ expr goto 173
+ expr_or_type goto 511
+ fnliteral goto 73
+ name goto 69
+ non_expr_type goto 174
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ recvchantype goto 175
+ othertype goto 177
+ fntype goto 176
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 394
+ pexpr_no_paren: pexpr '.' '(' expr_or_type.')'
+
+ ')' shift 512
+ . error
+
+
+state 395
+ pexpr_no_paren: pexpr '.' '(' LTYPE.')'
+
+ ')' shift 513
+ . error
+
+
+state 396
+ pexpr_no_paren: pexpr '[' expr ']'. (131)
+
+ . reduce 131 (src line 966)
+
+
+state 397
+ pexpr_no_paren: pexpr '[' oexpr ':'.oexpr ']'
+ pexpr_no_paren: pexpr '[' oexpr ':'.oexpr ':' oexpr ']'
+ oexpr: . (290)
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . reduce 290 (src line 1899)
+
+ sym goto 123
+ expr goto 188
+ fnliteral goto 73
+ name goto 69
+ oexpr goto 514
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 398
+ pexpr_no_paren: pexpr_no_paren '{' start_complit braced_keyval_list.'}'
+
+ '}' shift 515
+ . error
+
+
+state 399
+ keyval_list: keyval_list.',' keyval
+ keyval_list: keyval_list.',' bare_complitexpr
+ braced_keyval_list: keyval_list.ocomma
+ ocomma: . (288)
+
+ ',' shift 516
+ . reduce 288 (src line 1896)
+
+ ocomma goto 517
+
+state 400
+ keyval_list: keyval. (280)
+
+ . reduce 280 (src line 1863)
+
+
+state 401
+ keyval_list: bare_complitexpr. (281)
+
+ . reduce 281 (src line 1868)
+
+
+state 402
+ expr: expr.LOROR expr
+ expr: expr.LANDAND expr
+ expr: expr.LEQ expr
+ expr: expr.LNE expr
+ expr: expr.LLT expr
+ expr: expr.LLE expr
+ expr: expr.LGE expr
+ expr: expr.LGT expr
+ expr: expr.'+' expr
+ expr: expr.'-' expr
+ expr: expr.'|' expr
+ expr: expr.'^' expr
+ expr: expr.'*' expr
+ expr: expr.'/' expr
+ expr: expr.'%' expr
+ expr: expr.'&' expr
+ expr: expr.LANDNOT expr
+ expr: expr.LLSH expr
+ expr: expr.LRSH expr
+ expr: expr.LCOMM expr
+ keyval: expr.':' complitexpr
+ bare_complitexpr: expr. (142)
+
+ LANDAND shift 134
+ LANDNOT shift 149
+ LCOMM shift 152
+ LEQ shift 135
+ LGE shift 139
+ LGT shift 140
+ LLE shift 138
+ LLSH shift 150
+ LLT shift 137
+ LNE shift 136
+ LOROR shift 133
+ LRSH shift 151
+ '+' shift 141
+ '-' shift 142
+ '|' shift 143
+ '^' shift 144
+ '*' shift 145
+ '/' shift 146
+ '%' shift 147
+ '&' shift 148
+ ':' shift 518
+ . reduce 142 (src line 1026)
+
+
+state 403
+ bare_complitexpr: '{'.start_complit braced_keyval_list '}'
+ start_complit: . (140)
+
+ . reduce 140 (src line 1013)
+
+ start_complit goto 519
+
+state 404
+ pexpr_no_paren: '(' expr_or_type ')' '{'.start_complit braced_keyval_list '}'
+ start_complit: . (140)
+
+ . reduce 140 (src line 1013)
+
+ start_complit goto 520
+
+state 405
+ othertype: LCHAN LCOMM.ntype
+ recvchantype: LCOMM.LCHAN ntype
+
+ LCHAN shift 299
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 232
+ '*' shift 196
+ '(' shift 231
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ ntype goto 311
+ dotname goto 230
+ name goto 197
+ interfacetype goto 81
+ structtype goto 80
+ ptrtype goto 229
+ recvchantype goto 226
+ othertype goto 228
+ fntype goto 227
+ hidden_importsym goto 11
+
+state 406
+ recvchantype: LCOMM LCHAN ntype. (199)
+
+ . reduce 199 (src line 1281)
+
+
+state 407
+ ntype: fntype. (167)
+ non_recvchantype: fntype. (176)
+
+ LBODY reduce 176 (src line 1210)
+ '(' reduce 176 (src line 1210)
+ '{' reduce 176 (src line 1210)
+ . reduce 167 (src line 1192)
+
+
+state 408
+ ntype: othertype. (168)
+ non_recvchantype: othertype. (177)
+
+ LBODY reduce 177 (src line 1212)
+ '(' reduce 177 (src line 1212)
+ '{' reduce 177 (src line 1212)
+ . reduce 168 (src line 1193)
+
+
+state 409
+ ntype: ptrtype. (169)
+ non_recvchantype: ptrtype. (178)
+
+ LBODY reduce 178 (src line 1213)
+ '(' reduce 178 (src line 1213)
+ '{' reduce 178 (src line 1213)
+ . reduce 169 (src line 1194)
+
+
+state 410
+ ntype: dotname. (170)
+ non_recvchantype: dotname. (179)
+
+ LBODY reduce 179 (src line 1214)
+ '(' reduce 179 (src line 1214)
+ '{' reduce 179 (src line 1214)
+ . reduce 170 (src line 1195)
+
+
+state 411
+ ntype: '('.ntype ')'
+ non_recvchantype: '('.ntype ')'
+
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 232
+ '*' shift 196
+ '(' shift 231
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ ntype goto 521
+ dotname goto 230
+ name goto 197
+ interfacetype goto 81
+ structtype goto 80
+ ptrtype goto 229
+ recvchantype goto 226
+ othertype goto 228
+ fntype goto 227
+ hidden_importsym goto 11
+
+state 412
+ pexpr_no_paren: convtype '(' expr ocomma.')'
+
+ ')' shift 522
+ . error
+
+
+state 413
+ ocomma: ','. (289)
+
+ . reduce 289 (src line 1897)
+
+
+state 414
+ pexpr_no_paren: comptype lbrace start_complit braced_keyval_list.'}'
+
+ '}' shift 523
+ . error
+
+
+state 415
+ fnliteral: fnlitdcl lbrace stmt_list '}'. (216)
+
+ . reduce 216 (src line 1490)
+
+
+state 416
+ stmt_list: stmt_list ';'.stmt
+ stmt: . (251)
+
+ error shift 307
+ LLITERAL shift 68
+ LBREAK shift 41
+ LCASE reduce 251 (src line 1719)
+ LCHAN shift 78
+ LCONST shift 47
+ LCONTINUE shift 42
+ LDEFAULT reduce 251 (src line 1719)
+ LDEFER shift 44
+ LFALL shift 40
+ LFOR shift 50
+ LFUNC shift 124
+ LGO shift 43
+ LGOTO shift 45
+ LIF shift 53
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LRETURN shift 46
+ LSELECT shift 52
+ LSTRUCT shift 82
+ LSWITCH shift 51
+ LTYPE shift 32
+ LVAR shift 30
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ ';' reduce 251 (src line 1719)
+ '{' shift 308
+ '}' reduce 251 (src line 1719)
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 56
+ stmt goto 524
+ compound_stmt goto 304
+ expr goto 48
+ fnliteral goto 73
+ for_stmt goto 35
+ if_stmt goto 38
+ non_dcl_stmt goto 306
+ labelname goto 39
+ name goto 69
+ new_name goto 54
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ select_stmt goto 37
+ simple_stmt goto 34
+ switch_stmt goto 36
+ uexpr goto 55
+ expr_list goto 49
+ common_dcl goto 305
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ lconst goto 31
+ fnlitdcl goto 76
+
+state 417
+ compound_stmt: '{' $$59.stmt_list '}'
+ stmt: . (251)
+
+ error shift 307
+ LLITERAL shift 68
+ LBREAK shift 41
+ LCHAN shift 78
+ LCONST shift 47
+ LCONTINUE shift 42
+ LDEFER shift 44
+ LFALL shift 40
+ LFOR shift 50
+ LFUNC shift 124
+ LGO shift 43
+ LGOTO shift 45
+ LIF shift 53
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LRETURN shift 46
+ LSELECT shift 52
+ LSTRUCT shift 82
+ LSWITCH shift 51
+ LTYPE shift 32
+ LVAR shift 30
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ ';' reduce 251 (src line 1719)
+ '{' shift 308
+ '}' reduce 251 (src line 1719)
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 56
+ stmt goto 303
+ compound_stmt goto 304
+ expr goto 48
+ fnliteral goto 73
+ for_stmt goto 35
+ if_stmt goto 38
+ non_dcl_stmt goto 306
+ labelname goto 39
+ name goto 69
+ new_name goto 54
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ select_stmt goto 37
+ simple_stmt goto 34
+ switch_stmt goto 36
+ uexpr goto 55
+ expr_list goto 49
+ stmt_list goto 525
+ common_dcl goto 305
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ lconst goto 31
+ fnlitdcl goto 76
+
+state 418
+ othertype: '[' oexpr ']' ntype. (191)
+
+ . reduce 191 (src line 1248)
+
+
+state 419
+ othertype: '[' LDDD ']' ntype. (192)
+
+ . reduce 192 (src line 1253)
+
+
+state 420
+ non_recvchantype: '(' ntype ')'. (180)
+
+ . reduce 180 (src line 1215)
+
+
+state 421
+ dotname: name '.' sym. (190)
+
+ . reduce 190 (src line 1236)
+
+
+state 422
+ othertype: LMAP '[' ntype ']'.ntype
+
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 232
+ '*' shift 196
+ '(' shift 231
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ ntype goto 526
+ dotname goto 230
+ name goto 197
+ interfacetype goto 81
+ structtype goto 80
+ ptrtype goto 229
+ recvchantype goto 226
+ othertype goto 228
+ fntype goto 227
+ hidden_importsym goto 11
+
+state 423
+ structtype: LSTRUCT lbrace structdcl_list osemi.'}'
+
+ '}' shift 527
+ . error
+
+
+state 424
+ structdcl_list: structdcl_list ';'.structdcl
+ osemi: ';'. (287)
+
+ LNAME shift 325
+ '*' shift 322
+ '(' shift 321
+ '?' shift 12
+ '@' shift 13
+ . reduce 287 (src line 1894)
+
+ sym goto 119
+ packname goto 324
+ embed goto 320
+ new_name goto 323
+ new_name_list goto 319
+ structdcl goto 528
+ hidden_importsym goto 11
+
+state 425
+ structdcl: new_name_list ntype.oliteral
+ oliteral: . (302)
+
+ LLITERAL shift 428
+ . reduce 302 (src line 1935)
+
+ oliteral goto 529
+
+state 426
+ new_name_list: new_name_list ','.new_name
+
+ LNAME shift 10
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 119
+ new_name goto 530
+ hidden_importsym goto 11
+
+state 427
+ structdcl: embed oliteral. (231)
+
+ . reduce 231 (src line 1589)
+
+
+state 428
+ oliteral: LLITERAL. (303)
+
+ . reduce 303 (src line 1939)
+
+
+state 429
+ structdcl: '(' embed.')' oliteral
+
+ ')' shift 531
+ . error
+
+
+state 430
+ structdcl: '(' '*'.embed ')' oliteral
+
+ LNAME shift 431
+ . error
+
+ packname goto 324
+ embed goto 532
+
+state 431
+ packname: LNAME. (236)
+ packname: LNAME.'.' sym
+
+ '.' shift 434
+ . reduce 236 (src line 1621)
+
+
+state 432
+ structdcl: '*' embed.oliteral
+ oliteral: . (302)
+
+ LLITERAL shift 428
+ . reduce 302 (src line 1935)
+
+ oliteral goto 533
+
+state 433
+ structdcl: '*' '('.embed ')' oliteral
+
+ LNAME shift 431
+ . error
+
+ packname goto 324
+ embed goto 534
+
+state 434
+ packname: LNAME '.'.sym
+
+ LNAME shift 10
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 535
+ hidden_importsym goto 11
+
+state 435
+ interfacetype: LINTERFACE lbrace interfacedcl_list osemi.'}'
+
+ '}' shift 536
+ . error
+
+
+state 436
+ interfacedcl_list: interfacedcl_list ';'.interfacedcl
+ osemi: ';'. (287)
+
+ LNAME shift 325
+ '(' shift 331
+ '?' shift 12
+ '@' shift 13
+ . reduce 287 (src line 1894)
+
+ sym goto 119
+ packname goto 330
+ interfacedcl goto 537
+ new_name goto 329
+ hidden_importsym goto 11
+
+state 437
+ interfacedcl: new_name indcl. (239)
+
+ . reduce 239 (src line 1652)
+
+
+state 438
+ indcl: '('.oarg_type_list_ocomma ')' fnres
+ oarg_type_list_ocomma: . (249)
+
+ LCHAN shift 78
+ LDDD shift 250
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 232
+ '*' shift 196
+ '(' shift 231
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . reduce 249 (src line 1707)
+
+ sym goto 247
+ ntype goto 249
+ arg_type goto 245
+ dotname goto 230
+ name goto 197
+ name_or_type goto 246
+ oarg_type_list_ocomma goto 538
+ arg_type_list goto 244
+ dotdotdot goto 248
+ interfacetype goto 81
+ structtype goto 80
+ ptrtype goto 229
+ recvchantype goto 226
+ othertype goto 228
+ fntype goto 227
+ hidden_importsym goto 11
+
+state 439
+ interfacedcl: '(' packname.')'
+
+ ')' shift 539
+ . error
+
+
+state 440
+ import: LIMPORT '(' import_stmt_list osemi ')'. (9)
+
+ . reduce 9 (src line 170)
+
+
+state 441
+ import_stmt_list: import_stmt_list ';' import_stmt. (14)
+
+ . reduce 14 (src line 222)
+
+
+state 442
+ hidden_import: LIMPORT LNAME LLITERAL ';'. (304)
+
+ . reduce 304 (src line 1944)
+
+
+state 443
+ hidden_import: LVAR hidden_pkg_importsym hidden_type ';'. (305)
+
+ . reduce 305 (src line 1949)
+
+
+state 444
+ hidden_type_misc: '[' ']'.hidden_type
+
+ LCHAN shift 347
+ LFUNC shift 349
+ LINTERFACE shift 345
+ LMAP shift 343
+ LNAME shift 341
+ LSTRUCT shift 344
+ LCOMM shift 348
+ '*' shift 346
+ '[' shift 342
+ '@' shift 13
+ . error
+
+ hidden_importsym goto 340
+ hidden_type goto 540
+ hidden_type_misc goto 337
+ hidden_type_func goto 339
+ hidden_type_recv_chan goto 338
+
+state 445
+ hidden_type_misc: '[' LLITERAL.']' hidden_type
+
+ ']' shift 541
+ . error
+
+
+state 446
+ hidden_type_misc: LMAP '['.hidden_type ']' hidden_type
+
+ LCHAN shift 347
+ LFUNC shift 349
+ LINTERFACE shift 345
+ LMAP shift 343
+ LNAME shift 341
+ LSTRUCT shift 344
+ LCOMM shift 348
+ '*' shift 346
+ '[' shift 342
+ '@' shift 13
+ . error
+
+ hidden_importsym goto 340
+ hidden_type goto 542
+ hidden_type_misc goto 337
+ hidden_type_func goto 339
+ hidden_type_recv_chan goto 338
+
+state 447
+ hidden_type_misc: LSTRUCT '{'.ohidden_structdcl_list '}'
+ ohidden_structdcl_list: . (298)
+
+ LNAME shift 10
+ '?' shift 12
+ '@' shift 13
+ . reduce 298 (src line 1923)
+
+ sym goto 546
+ hidden_importsym goto 11
+ hidden_structdcl goto 545
+ hidden_structdcl_list goto 544
+ ohidden_structdcl_list goto 543
+
+state 448
+ hidden_type_misc: LINTERFACE '{'.ohidden_interfacedcl_list '}'
+ ohidden_interfacedcl_list: . (300)
+
+ LCHAN shift 347
+ LFUNC shift 349
+ LINTERFACE shift 345
+ LMAP shift 343
+ LNAME shift 552
+ LSTRUCT shift 344
+ LCOMM shift 348
+ '*' shift 346
+ '[' shift 342
+ '?' shift 12
+ '@' shift 13
+ . reduce 300 (src line 1929)
+
+ sym goto 550
+ hidden_importsym goto 553
+ hidden_interfacedcl goto 549
+ hidden_interfacedcl_list goto 548
+ ohidden_interfacedcl_list goto 547
+ hidden_type goto 551
+ hidden_type_misc goto 337
+ hidden_type_func goto 339
+ hidden_type_recv_chan goto 338
+
+state 449
+ hidden_type_misc: '*' hidden_type. (324)
+
+ . reduce 324 (src line 2048)
+
+
+state 450
+ hidden_type_misc: LCHAN hidden_type_non_recv_chan. (325)
+
+ . reduce 325 (src line 2052)
+
+
+state 451
+ hidden_type_misc: LCHAN '('.hidden_type_recv_chan ')'
+
+ LCOMM shift 348
+ . error
+
+ hidden_type_recv_chan goto 554
+
+state 452
+ hidden_type_misc: LCHAN LCOMM.hidden_type
+
+ LCHAN shift 347
+ LFUNC shift 349
+ LINTERFACE shift 345
+ LMAP shift 343
+ LNAME shift 341
+ LSTRUCT shift 344
+ LCOMM shift 348
+ '*' shift 346
+ '[' shift 342
+ '@' shift 13
+ . error
+
+ hidden_importsym goto 340
+ hidden_type goto 555
+ hidden_type_misc goto 337
+ hidden_type_func goto 339
+ hidden_type_recv_chan goto 338
+
+state 453
+ hidden_type_non_recv_chan: hidden_type_misc. (315)
+
+ . reduce 315 (src line 2008)
+
+
+state 454
+ hidden_type_non_recv_chan: hidden_type_func. (316)
+
+ . reduce 316 (src line 2010)
+
+
+state 455
+ hidden_type_recv_chan: LCOMM LCHAN.hidden_type
+
+ LCHAN shift 347
+ LFUNC shift 349
+ LINTERFACE shift 345
+ LMAP shift 343
+ LNAME shift 341
+ LSTRUCT shift 344
+ LCOMM shift 348
+ '*' shift 346
+ '[' shift 342
+ '@' shift 13
+ . error
+
+ hidden_importsym goto 340
+ hidden_type goto 556
+ hidden_type_misc goto 337
+ hidden_type_func goto 339
+ hidden_type_recv_chan goto 338
+
+state 456
+ hidden_type_func: LFUNC '('.ohidden_funarg_list ')' ohidden_funres
+ ohidden_funarg_list: . (296)
+
+ LNAME shift 10
+ '?' shift 12
+ '@' shift 13
+ . reduce 296 (src line 1917)
+
+ sym goto 357
+ hidden_importsym goto 11
+ hidden_funarg goto 356
+ hidden_funarg_list goto 467
+ ohidden_funarg_list goto 557
+
+state 457
+ hidden_import: LCONST hidden_pkg_importsym '=' hidden_constant.';'
+
+ ';' shift 558
+ . error
+
+
+state 458
+ hidden_constant: hidden_literal. (342)
+
+ . reduce 342 (src line 2195)
+
+
+state 459
+ hidden_constant: '('.hidden_literal '+' hidden_literal ')'
+
+ LLITERAL shift 460
+ LNAME shift 10
+ '-' shift 461
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 462
+ hidden_importsym goto 11
+ hidden_literal goto 559
+
+state 460
+ hidden_literal: LLITERAL. (339)
+
+ . reduce 339 (src line 2164)
+
+
+state 461
+ hidden_literal: '-'.LLITERAL
+
+ LLITERAL shift 560
+ . error
+
+
+state 462
+ hidden_literal: sym. (341)
+
+ . reduce 341 (src line 2187)
+
+
+state 463
+ hidden_import: LCONST hidden_pkg_importsym hidden_type '='.hidden_constant ';'
+
+ LLITERAL shift 460
+ LNAME shift 10
+ '-' shift 461
+ '(' shift 459
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 462
+ hidden_importsym goto 11
+ hidden_constant goto 561
+ hidden_literal goto 458
+
+state 464
+ hidden_import: LTYPE hidden_pkgtype hidden_type ';'. (308)
+
+ . reduce 308 (src line 1961)
+
+
+state 465
+ hidden_import: LFUNC hidden_fndcl fnbody ';'. (309)
+
+ . reduce 309 (src line 1965)
+
+
+state 466
+ hidden_fndcl: hidden_pkg_importsym '(' ohidden_funarg_list.')' ohidden_funres
+
+ ')' shift 562
+ . error
+
+
+state 467
+ ohidden_funarg_list: hidden_funarg_list. (297)
+ hidden_funarg_list: hidden_funarg_list.',' hidden_funarg
+
+ ',' shift 469
+ . reduce 297 (src line 1921)
+
+
+state 468
+ hidden_fndcl: '(' hidden_funarg_list ')'.sym '(' ohidden_funarg_list ')' ohidden_funres
+
+ LNAME shift 10
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 563
+ hidden_importsym goto 11
+
+state 469
+ hidden_funarg_list: hidden_funarg_list ','.hidden_funarg
+
+ LNAME shift 10
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 357
+ hidden_importsym goto 11
+ hidden_funarg goto 564
+
+state 470
+ hidden_funarg: sym hidden_type.oliteral
+ oliteral: . (302)
+
+ LLITERAL shift 428
+ . reduce 302 (src line 1935)
+
+ oliteral goto 565
+
+state 471
+ hidden_funarg: sym LDDD.hidden_type oliteral
+
+ LCHAN shift 347
+ LFUNC shift 349
+ LINTERFACE shift 345
+ LMAP shift 343
+ LNAME shift 341
+ LSTRUCT shift 344
+ LCOMM shift 348
+ '*' shift 346
+ '[' shift 342
+ '@' shift 13
+ . error
+
+ hidden_importsym goto 340
+ hidden_type goto 566
+ hidden_type_misc goto 337
+ hidden_type_func goto 339
+ hidden_type_recv_chan goto 338
+
+state 472
+ common_dcl: LVAR '(' vardcl_list osemi ')'. (29)
+
+ . reduce 29 (src line 310)
+
+
+state 473
+ vardcl_list: vardcl_list ';' vardcl. (221)
+
+ . reduce 221 (src line 1525)
+
+
+state 474
+ vardcl: dcl_name_list ntype '=' expr_list. (40)
+ expr_list: expr_list.',' expr
+
+ ',' shift 155
+ . reduce 40 (src line 365)
+
+
+state 475
+ ntype: '(' ntype ')'. (171)
+
+ . reduce 171 (src line 1196)
+
+
+state 476
+ common_dcl: lconst '(' constdcl osemi ')'. (32)
+
+ . reduce 32 (src line 324)
+
+
+state 477
+ common_dcl: lconst '(' constdcl ';' constdcl_list.osemi ')'
+ constdcl_list: constdcl_list.';' constdcl1
+ osemi: . (286)
+
+ ';' shift 568
+ . reduce 286 (src line 1893)
+
+ osemi goto 567
+
+state 478
+ constdcl_list: constdcl1. (222)
+
+ . reduce 222 (src line 1530)
+
+
+state 479
+ constdcl1: constdcl. (44)
+
+ . reduce 44 (src line 384)
+
+
+state 480
+ constdcl: dcl_name_list.ntype '=' expr_list
+ constdcl: dcl_name_list.'=' expr_list
+ constdcl1: dcl_name_list.ntype
+ constdcl1: dcl_name_list. (46)
+ dcl_name_list: dcl_name_list.',' dcl_name
+
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 232
+ '*' shift 196
+ '(' shift 231
+ '=' shift 236
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ ',' shift 225
+ . reduce 46 (src line 390)
+
+ sym goto 123
+ ntype goto 569
+ dotname goto 230
+ name goto 197
+ interfacetype goto 81
+ structtype goto 80
+ ptrtype goto 229
+ recvchantype goto 226
+ othertype goto 228
+ fntype goto 227
+ hidden_importsym goto 11
+
+state 481
+ constdcl: dcl_name_list ntype '=' expr_list. (42)
+ expr_list: expr_list.',' expr
+
+ ',' shift 155
+ . reduce 42 (src line 374)
+
+
+state 482
+ common_dcl: LTYPE '(' typedcl_list osemi ')'. (36)
+
+ . reduce 36 (src line 345)
+
+
+state 483
+ typedcl_list: typedcl_list ';' typedcl. (225)
+
+ . reduce 225 (src line 1542)
+
+
+state 484
+ fnbody: '{' stmt_list '}'. (211)
+
+ . reduce 211 (src line 1461)
+
+
+state 485
+ name: sym. (162)
+ fndcl: '(' oarg_type_list_ocomma ')' sym.'(' oarg_type_list_ocomma ')' fnres
+
+ '(' shift 570
+ . reduce 162 (src line 1158)
+
+
+state 486
+ fntype: LFUNC '(' oarg_type_list_ocomma ')' fnres. (209)
+
+ . reduce 209 (src line 1448)
+
+
+state 487
+ fnres: fnret_type. (213)
+
+ . reduce 213 (src line 1474)
+
+
+state 488
+ fnres: '('.oarg_type_list_ocomma ')'
+ oarg_type_list_ocomma: . (249)
+
+ LCHAN shift 78
+ LDDD shift 250
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 232
+ '*' shift 196
+ '(' shift 231
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . reduce 249 (src line 1707)
+
+ sym goto 247
+ ntype goto 249
+ arg_type goto 245
+ dotname goto 230
+ name goto 197
+ name_or_type goto 246
+ oarg_type_list_ocomma goto 571
+ arg_type_list goto 244
+ dotdotdot goto 248
+ interfacetype goto 81
+ structtype goto 80
+ ptrtype goto 229
+ recvchantype goto 226
+ othertype goto 228
+ fntype goto 227
+ hidden_importsym goto 11
+
+state 489
+ fnret_type: recvchantype. (184)
+
+ . reduce 184 (src line 1227)
+
+
+state 490
+ fnret_type: fntype. (185)
+
+ . reduce 185 (src line 1229)
+
+
+state 491
+ fnret_type: othertype. (186)
+
+ . reduce 186 (src line 1230)
+
+
+state 492
+ fnret_type: ptrtype. (187)
+
+ . reduce 187 (src line 1231)
+
+
+state 493
+ fnret_type: dotname. (188)
+
+ . reduce 188 (src line 1232)
+
+
+state 494
+ arg_type_list: arg_type_list ',' arg_type. (248)
+
+ . reduce 248 (src line 1702)
+
+
+state 495
+ fndcl: sym '(' oarg_type_list_ocomma ')'.fnres
+ fnres: . (212)
+
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 232
+ '*' shift 196
+ '(' shift 488
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . reduce 212 (src line 1469)
+
+ sym goto 123
+ dotname goto 493
+ name goto 197
+ fnres goto 572
+ interfacetype goto 81
+ structtype goto 80
+ ptrtype goto 492
+ recvchantype goto 489
+ othertype goto 491
+ fnret_type goto 487
+ fntype goto 490
+ hidden_importsym goto 11
+
+state 496
+ fntype: LFUNC '(' oarg_type_list_ocomma ')'.fnres
+ fnres: . (212)
+
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 232
+ '*' shift 196
+ '(' shift 488
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . reduce 212 (src line 1469)
+
+ sym goto 123
+ dotname goto 493
+ name goto 197
+ fnres goto 486
+ interfacetype goto 81
+ structtype goto 80
+ ptrtype goto 492
+ recvchantype goto 489
+ othertype goto 491
+ fnret_type goto 487
+ fntype goto 490
+ hidden_importsym goto 11
+
+state 497
+ loop_body: LBODY $$65.stmt_list '}'
+ stmt: . (251)
+
+ error shift 307
+ LLITERAL shift 68
+ LBREAK shift 41
+ LCHAN shift 78
+ LCONST shift 47
+ LCONTINUE shift 42
+ LDEFER shift 44
+ LFALL shift 40
+ LFOR shift 50
+ LFUNC shift 124
+ LGO shift 43
+ LGOTO shift 45
+ LIF shift 53
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LRETURN shift 46
+ LSELECT shift 52
+ LSTRUCT shift 82
+ LSWITCH shift 51
+ LTYPE shift 32
+ LVAR shift 30
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ ';' reduce 251 (src line 1719)
+ '{' shift 308
+ '}' reduce 251 (src line 1719)
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 56
+ stmt goto 303
+ compound_stmt goto 304
+ expr goto 48
+ fnliteral goto 73
+ for_stmt goto 35
+ if_stmt goto 38
+ non_dcl_stmt goto 306
+ labelname goto 39
+ name goto 69
+ new_name goto 54
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ select_stmt goto 37
+ simple_stmt goto 34
+ switch_stmt goto 36
+ uexpr goto 55
+ expr_list goto 49
+ stmt_list goto 573
+ common_dcl goto 305
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ lconst goto 31
+ fnlitdcl goto 76
+
+state 498
+ for_header: osimple_stmt ';' osimple_stmt.';' osimple_stmt
+
+ ';' shift 574
+ . error
+
+
+state 499
+ range_stmt: expr_list '=' LRANGE.expr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 575
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 500
+ range_stmt: expr_list LCOLAS LRANGE.expr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 576
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 501
+ switch_stmt: LSWITCH $$88 if_header $$89 LBODY.caseblock_list '}'
+ caseblock_list: . (63)
+
+ . reduce 63 (src line 590)
+
+ caseblock_list goto 577
+
+state 502
+ if_header: osimple_stmt ';' osimple_stmt. (77)
+
+ . reduce 77 (src line 677)
+
+
+state 503
+ caseblock_list: caseblock_list caseblock. (64)
+
+ . reduce 64 (src line 594)
+
+
+state 504
+ select_stmt: LSELECT $$91 LBODY caseblock_list '}'. (92)
+
+ . reduce 92 (src line 782)
+
+
+state 505
+ caseblock: case.$$61 stmt_list
+ $$61: . (61)
+
+ . reduce 61 (src line 559)
+
+ $$61 goto 578
+
+state 506
+ case: LCASE.expr_or_type_list ':'
+ case: LCASE.expr_or_type_list '=' expr ':'
+ case: LCASE.expr_or_type_list LCOLAS expr ':'
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 179
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 178
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 173
+ expr_or_type goto 291
+ fnliteral goto 73
+ name goto 69
+ non_expr_type goto 174
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ expr_or_type_list goto 579
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ recvchantype goto 175
+ othertype goto 177
+ fntype goto 176
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 507
+ case: LDEFAULT.':'
+
+ ':' shift 580
+ . error
+
+
+state 508
+ if_stmt: LIF $$78 if_header $$79 loop_body.$$80 elseif_list else
+ $$80: . (80)
+
+ . reduce 80 (src line 699)
+
+ $$80 goto 581
+
+state 509
+ pseudocall: pexpr '(' expr_or_type_list ocomma ')'. (124)
+
+ . reduce 124 (src line 929)
+
+
+state 510
+ pseudocall: pexpr '(' expr_or_type_list LDDD ocomma.')'
+
+ ')' shift 582
+ . error
+
+
+state 511
+ expr_or_type_list: expr_or_type_list ',' expr_or_type. (279)
+
+ . reduce 279 (src line 1855)
+
+
+state 512
+ pexpr_no_paren: pexpr '.' '(' expr_or_type ')'. (129)
+
+ . reduce 129 (src line 958)
+
+
+state 513
+ pexpr_no_paren: pexpr '.' '(' LTYPE ')'. (130)
+
+ . reduce 130 (src line 962)
+
+
+state 514
+ pexpr_no_paren: pexpr '[' oexpr ':' oexpr.']'
+ pexpr_no_paren: pexpr '[' oexpr ':' oexpr.':' oexpr ']'
+
+ ':' shift 584
+ ']' shift 583
+ . error
+
+
+state 515
+ pexpr_no_paren: pexpr_no_paren '{' start_complit braced_keyval_list '}'. (137)
+
+ . reduce 137 (src line 998)
+
+
+state 516
+ keyval_list: keyval_list ','.keyval
+ keyval_list: keyval_list ','.bare_complitexpr
+ ocomma: ','. (289)
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '{' shift 403
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . reduce 289 (src line 1897)
+
+ sym goto 123
+ expr goto 402
+ bare_complitexpr goto 586
+ fnliteral goto 73
+ keyval goto 585
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 517
+ braced_keyval_list: keyval_list ocomma. (285)
+
+ . reduce 285 (src line 1885)
+
+
+state 518
+ keyval: expr ':'.complitexpr
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '{' shift 589
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 588
+ complitexpr goto 587
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 519
+ bare_complitexpr: '{' start_complit.braced_keyval_list '}'
+ braced_keyval_list: . (284)
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '{' shift 403
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . reduce 284 (src line 1881)
+
+ sym goto 123
+ expr goto 402
+ bare_complitexpr goto 401
+ fnliteral goto 73
+ keyval goto 400
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ keyval_list goto 399
+ braced_keyval_list goto 590
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 520
+ pexpr_no_paren: '(' expr_or_type ')' '{' start_complit.braced_keyval_list '}'
+ braced_keyval_list: . (284)
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '{' shift 403
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . reduce 284 (src line 1881)
+
+ sym goto 123
+ expr goto 402
+ bare_complitexpr goto 401
+ fnliteral goto 73
+ keyval goto 400
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ keyval_list goto 399
+ braced_keyval_list goto 591
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 521
+ ntype: '(' ntype.')'
+ non_recvchantype: '(' ntype.')'
+
+ ')' shift 592
+ . error
+
+
+state 522
+ pexpr_no_paren: convtype '(' expr ocomma ')'. (135)
+
+ . reduce 135 (src line 985)
+
+
+state 523
+ pexpr_no_paren: comptype lbrace start_complit braced_keyval_list '}'. (136)
+
+ . reduce 136 (src line 991)
+
+
+state 524
+ stmt_list: stmt_list ';' stmt. (271)
+
+ . reduce 271 (src line 1812)
+
+
+state 525
+ compound_stmt: '{' $$59 stmt_list.'}'
+ stmt_list: stmt_list.';' stmt
+
+ ';' shift 416
+ '}' shift 593
+ . error
+
+
+state 526
+ othertype: LMAP '[' ntype ']' ntype. (195)
+
+ . reduce 195 (src line 1268)
+
+
+state 527
+ structtype: LSTRUCT lbrace structdcl_list osemi '}'. (200)
+
+ . reduce 200 (src line 1288)
+
+
+state 528
+ structdcl_list: structdcl_list ';' structdcl. (227)
+
+ . reduce 227 (src line 1549)
+
+
+state 529
+ structdcl: new_name_list ntype oliteral. (230)
+
+ . reduce 230 (src line 1564)
+
+
+state 530
+ new_name_list: new_name_list ',' new_name. (273)
+
+ . reduce 273 (src line 1825)
+
+
+state 531
+ structdcl: '(' embed ')'.oliteral
+ oliteral: . (302)
+
+ LLITERAL shift 428
+ . reduce 302 (src line 1935)
+
+ oliteral goto 594
+
+state 532
+ structdcl: '(' '*' embed.')' oliteral
+
+ ')' shift 595
+ . error
+
+
+state 533
+ structdcl: '*' embed oliteral. (233)
+
+ . reduce 233 (src line 1600)
+
+
+state 534
+ structdcl: '*' '(' embed.')' oliteral
+
+ ')' shift 596
+ . error
+
+
+state 535
+ packname: LNAME '.' sym. (237)
+
+ . reduce 237 (src line 1632)
+
+
+state 536
+ interfacetype: LINTERFACE lbrace interfacedcl_list osemi '}'. (202)
+
+ . reduce 202 (src line 1301)
+
+
+state 537
+ interfacedcl_list: interfacedcl_list ';' interfacedcl. (229)
+
+ . reduce 229 (src line 1559)
+
+
+state 538
+ indcl: '(' oarg_type_list_ocomma.')' fnres
+
+ ')' shift 597
+ . error
+
+
+state 539
+ interfacedcl: '(' packname ')'. (241)
+
+ . reduce 241 (src line 1662)
+
+
+state 540
+ hidden_type_misc: '[' ']' hidden_type. (319)
+
+ . reduce 319 (src line 2028)
+
+
+state 541
+ hidden_type_misc: '[' LLITERAL ']'.hidden_type
+
+ LCHAN shift 347
+ LFUNC shift 349
+ LINTERFACE shift 345
+ LMAP shift 343
+ LNAME shift 341
+ LSTRUCT shift 344
+ LCOMM shift 348
+ '*' shift 346
+ '[' shift 342
+ '@' shift 13
+ . error
+
+ hidden_importsym goto 340
+ hidden_type goto 598
+ hidden_type_misc goto 337
+ hidden_type_func goto 339
+ hidden_type_recv_chan goto 338
+
+state 542
+ hidden_type_misc: LMAP '[' hidden_type.']' hidden_type
+
+ ']' shift 599
+ . error
+
+
+state 543
+ hidden_type_misc: LSTRUCT '{' ohidden_structdcl_list.'}'
+
+ '}' shift 600
+ . error
+
+
+state 544
+ ohidden_structdcl_list: hidden_structdcl_list. (299)
+ hidden_structdcl_list: hidden_structdcl_list.';' hidden_structdcl
+
+ ';' shift 601
+ . reduce 299 (src line 1927)
+
+
+state 545
+ hidden_structdcl_list: hidden_structdcl. (348)
+
+ . reduce 348 (src line 2222)
+
+
+state 546
+ hidden_structdcl: sym.hidden_type oliteral
+
+ LCHAN shift 347
+ LFUNC shift 349
+ LINTERFACE shift 345
+ LMAP shift 343
+ LNAME shift 341
+ LSTRUCT shift 344
+ LCOMM shift 348
+ '*' shift 346
+ '[' shift 342
+ '@' shift 13
+ . error
+
+ hidden_importsym goto 340
+ hidden_type goto 602
+ hidden_type_misc goto 337
+ hidden_type_func goto 339
+ hidden_type_recv_chan goto 338
+
+state 547
+ hidden_type_misc: LINTERFACE '{' ohidden_interfacedcl_list.'}'
+
+ '}' shift 603
+ . error
+
+
+state 548
+ ohidden_interfacedcl_list: hidden_interfacedcl_list. (301)
+ hidden_interfacedcl_list: hidden_interfacedcl_list.';' hidden_interfacedcl
+
+ ';' shift 604
+ . reduce 301 (src line 1933)
+
+
+state 549
+ hidden_interfacedcl_list: hidden_interfacedcl. (350)
+
+ . reduce 350 (src line 2232)
+
+
+state 550
+ hidden_interfacedcl: sym.'(' ohidden_funarg_list ')' ohidden_funres
+
+ '(' shift 605
+ . error
+
+
+state 551
+ hidden_interfacedcl: hidden_type. (334)
+
+ . reduce 334 (src line 2139)
+
+
+state 552
+ sym: LNAME. (157)
+ hidden_type_misc: LNAME. (318)
+
+ '(' reduce 157 (src line 1113)
+ . reduce 318 (src line 2017)
+
+
+state 553
+ sym: hidden_importsym. (158)
+ hidden_type_misc: hidden_importsym. (317)
+
+ '(' reduce 158 (src line 1122)
+ . reduce 317 (src line 2012)
+
+
+state 554
+ hidden_type_misc: LCHAN '(' hidden_type_recv_chan.')'
+
+ ')' shift 606
+ . error
+
+
+state 555
+ hidden_type_misc: LCHAN LCOMM hidden_type. (327)
+
+ . reduce 327 (src line 2064)
+
+
+state 556
+ hidden_type_recv_chan: LCOMM LCHAN hidden_type. (328)
+
+ . reduce 328 (src line 2071)
+
+
+state 557
+ hidden_type_func: LFUNC '(' ohidden_funarg_list.')' ohidden_funres
+
+ ')' shift 607
+ . error
+
+
+state 558
+ hidden_import: LCONST hidden_pkg_importsym '=' hidden_constant ';'. (306)
+
+ . reduce 306 (src line 1953)
+
+
+state 559
+ hidden_constant: '(' hidden_literal.'+' hidden_literal ')'
+
+ '+' shift 608
+ . error
+
+
+state 560
+ hidden_literal: '-' LLITERAL. (340)
+
+ . reduce 340 (src line 2169)
+
+
+state 561
+ hidden_import: LCONST hidden_pkg_importsym hidden_type '=' hidden_constant.';'
+
+ ';' shift 609
+ . error
+
+
+state 562
+ hidden_fndcl: hidden_pkg_importsym '(' ohidden_funarg_list ')'.ohidden_funres
+ ohidden_funres: . (335)
+
+ LCHAN shift 347
+ LFUNC shift 349
+ LINTERFACE shift 345
+ LMAP shift 343
+ LNAME shift 341
+ LSTRUCT shift 344
+ LCOMM shift 348
+ '*' shift 346
+ '(' shift 612
+ '[' shift 342
+ '@' shift 13
+ . reduce 335 (src line 2144)
+
+ hidden_importsym goto 340
+ hidden_funres goto 611
+ ohidden_funres goto 610
+ hidden_type goto 613
+ hidden_type_misc goto 337
+ hidden_type_func goto 339
+ hidden_type_recv_chan goto 338
+
+state 563
+ hidden_fndcl: '(' hidden_funarg_list ')' sym.'(' ohidden_funarg_list ')' ohidden_funres
+
+ '(' shift 614
+ . error
+
+
+state 564
+ hidden_funarg_list: hidden_funarg_list ',' hidden_funarg. (347)
+
+ . reduce 347 (src line 2217)
+
+
+state 565
+ hidden_funarg: sym hidden_type oliteral. (330)
+
+ . reduce 330 (src line 2085)
+
+
+state 566
+ hidden_funarg: sym LDDD hidden_type.oliteral
+ oliteral: . (302)
+
+ LLITERAL shift 428
+ . reduce 302 (src line 1935)
+
+ oliteral goto 615
+
+state 567
+ common_dcl: lconst '(' constdcl ';' constdcl_list osemi.')'
+
+ ')' shift 616
+ . error
+
+
+state 568
+ constdcl_list: constdcl_list ';'.constdcl1
+ osemi: ';'. (287)
+
+ LNAME shift 10
+ '?' shift 12
+ '@' shift 13
+ . reduce 287 (src line 1894)
+
+ sym goto 105
+ dcl_name goto 104
+ dcl_name_list goto 480
+ constdcl goto 479
+ constdcl1 goto 617
+ hidden_importsym goto 11
+
+state 569
+ constdcl: dcl_name_list ntype.'=' expr_list
+ constdcl1: dcl_name_list ntype. (45)
+
+ '=' shift 367
+ . reduce 45 (src line 386)
+
+
+state 570
+ fndcl: '(' oarg_type_list_ocomma ')' sym '('.oarg_type_list_ocomma ')' fnres
+ oarg_type_list_ocomma: . (249)
+
+ LCHAN shift 78
+ LDDD shift 250
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 232
+ '*' shift 196
+ '(' shift 231
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . reduce 249 (src line 1707)
+
+ sym goto 247
+ ntype goto 249
+ arg_type goto 245
+ dotname goto 230
+ name goto 197
+ name_or_type goto 246
+ oarg_type_list_ocomma goto 618
+ arg_type_list goto 244
+ dotdotdot goto 248
+ interfacetype goto 81
+ structtype goto 80
+ ptrtype goto 229
+ recvchantype goto 226
+ othertype goto 228
+ fntype goto 227
+ hidden_importsym goto 11
+
+state 571
+ fnres: '(' oarg_type_list_ocomma.')'
+
+ ')' shift 619
+ . error
+
+
+state 572
+ fndcl: sym '(' oarg_type_list_ocomma ')' fnres. (205)
+
+ . reduce 205 (src line 1336)
+
+
+state 573
+ loop_body: LBODY $$65 stmt_list.'}'
+ stmt_list: stmt_list.';' stmt
+
+ ';' shift 416
+ '}' shift 620
+ . error
+
+
+state 574
+ for_header: osimple_stmt ';' osimple_stmt ';'.osimple_stmt
+ osimple_stmt: . (294)
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . reduce 294 (src line 1911)
+
+ sym goto 123
+ expr goto 48
+ fnliteral goto 73
+ name goto 69
+ osimple_stmt goto 621
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ simple_stmt goto 282
+ uexpr goto 55
+ expr_list goto 49
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 575
+ range_stmt: expr_list '=' LRANGE expr. (67)
+ expr: expr.LOROR expr
+ expr: expr.LANDAND expr
+ expr: expr.LEQ expr
+ expr: expr.LNE expr
+ expr: expr.LLT expr
+ expr: expr.LLE expr
+ expr: expr.LGE expr
+ expr: expr.LGT expr
+ expr: expr.'+' expr
+ expr: expr.'-' expr
+ expr: expr.'|' expr
+ expr: expr.'^' expr
+ expr: expr.'*' expr
+ expr: expr.'/' expr
+ expr: expr.'%' expr
+ expr: expr.'&' expr
+ expr: expr.LANDNOT expr
+ expr: expr.LLSH expr
+ expr: expr.LRSH expr
+ expr: expr.LCOMM expr
+
+ LANDAND shift 134
+ LANDNOT shift 149
+ LCOMM shift 152
+ LEQ shift 135
+ LGE shift 139
+ LGT shift 140
+ LLE shift 138
+ LLSH shift 150
+ LLT shift 137
+ LNE shift 136
+ LOROR shift 133
+ LRSH shift 151
+ '+' shift 141
+ '-' shift 142
+ '|' shift 143
+ '^' shift 144
+ '*' shift 145
+ '/' shift 146
+ '%' shift 147
+ '&' shift 148
+ . reduce 67 (src line 610)
+
+
+state 576
+ range_stmt: expr_list LCOLAS LRANGE expr. (68)
+ expr: expr.LOROR expr
+ expr: expr.LANDAND expr
+ expr: expr.LEQ expr
+ expr: expr.LNE expr
+ expr: expr.LLT expr
+ expr: expr.LLE expr
+ expr: expr.LGE expr
+ expr: expr.LGT expr
+ expr: expr.'+' expr
+ expr: expr.'-' expr
+ expr: expr.'|' expr
+ expr: expr.'^' expr
+ expr: expr.'*' expr
+ expr: expr.'/' expr
+ expr: expr.'%' expr
+ expr: expr.'&' expr
+ expr: expr.LANDNOT expr
+ expr: expr.LLSH expr
+ expr: expr.LRSH expr
+ expr: expr.LCOMM expr
+
+ LANDAND shift 134
+ LANDNOT shift 149
+ LCOMM shift 152
+ LEQ shift 135
+ LGE shift 139
+ LGT shift 140
+ LLE shift 138
+ LLSH shift 150
+ LLT shift 137
+ LNE shift 136
+ LOROR shift 133
+ LRSH shift 151
+ '+' shift 141
+ '-' shift 142
+ '|' shift 143
+ '^' shift 144
+ '*' shift 145
+ '/' shift 146
+ '%' shift 147
+ '&' shift 148
+ . reduce 68 (src line 617)
+
+
+state 577
+ caseblock_list: caseblock_list.caseblock
+ switch_stmt: LSWITCH $$88 if_header $$89 LBODY caseblock_list.'}'
+
+ LCASE shift 506
+ LDEFAULT shift 507
+ '}' shift 622
+ . error
+
+ case goto 505
+ caseblock goto 503
+
+state 578
+ caseblock: case $$61.stmt_list
+ stmt: . (251)
+
+ error shift 307
+ LLITERAL shift 68
+ LBREAK shift 41
+ LCASE reduce 251 (src line 1719)
+ LCHAN shift 78
+ LCONST shift 47
+ LCONTINUE shift 42
+ LDEFAULT reduce 251 (src line 1719)
+ LDEFER shift 44
+ LFALL shift 40
+ LFOR shift 50
+ LFUNC shift 124
+ LGO shift 43
+ LGOTO shift 45
+ LIF shift 53
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LRETURN shift 46
+ LSELECT shift 52
+ LSTRUCT shift 82
+ LSWITCH shift 51
+ LTYPE shift 32
+ LVAR shift 30
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ ';' reduce 251 (src line 1719)
+ '{' shift 308
+ '}' reduce 251 (src line 1719)
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 56
+ stmt goto 303
+ compound_stmt goto 304
+ expr goto 48
+ fnliteral goto 73
+ for_stmt goto 35
+ if_stmt goto 38
+ non_dcl_stmt goto 306
+ labelname goto 39
+ name goto 69
+ new_name goto 54
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ select_stmt goto 37
+ simple_stmt goto 34
+ switch_stmt goto 36
+ uexpr goto 55
+ expr_list goto 49
+ stmt_list goto 623
+ common_dcl goto 305
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ lconst goto 31
+ fnlitdcl goto 76
+
+state 579
+ case: LCASE expr_or_type_list.':'
+ case: LCASE expr_or_type_list.'=' expr ':'
+ case: LCASE expr_or_type_list.LCOLAS expr ':'
+ expr_or_type_list: expr_or_type_list.',' expr_or_type
+
+ LCOLAS shift 626
+ '=' shift 625
+ ':' shift 624
+ ',' shift 627
+ . error
+
+
+state 580
+ case: LDEFAULT ':'. (58)
+
+ . reduce 58 (src line 524)
+
+
+state 581
+ if_stmt: LIF $$78 if_header $$79 loop_body $$80.elseif_list else
+ elseif_list: . (84)
+
+ . reduce 84 (src line 734)
+
+ elseif_list goto 628
+
+state 582
+ pseudocall: pexpr '(' expr_or_type_list LDDD ocomma ')'. (125)
+
+ . reduce 125 (src line 934)
+
+
+state 583
+ pexpr_no_paren: pexpr '[' oexpr ':' oexpr ']'. (132)
+
+ . reduce 132 (src line 970)
+
+
+state 584
+ pexpr_no_paren: pexpr '[' oexpr ':' oexpr ':'.oexpr ']'
+ oexpr: . (290)
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . reduce 290 (src line 1899)
+
+ sym goto 123
+ expr goto 188
+ fnliteral goto 73
+ name goto 69
+ oexpr goto 629
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 585
+ keyval_list: keyval_list ',' keyval. (282)
+
+ . reduce 282 (src line 1872)
+
+
+state 586
+ keyval_list: keyval_list ',' bare_complitexpr. (283)
+
+ . reduce 283 (src line 1876)
+
+
+state 587
+ keyval: expr ':' complitexpr. (141)
+
+ . reduce 141 (src line 1020)
+
+
+state 588
+ expr: expr.LOROR expr
+ expr: expr.LANDAND expr
+ expr: expr.LEQ expr
+ expr: expr.LNE expr
+ expr: expr.LLT expr
+ expr: expr.LLE expr
+ expr: expr.LGE expr
+ expr: expr.LGT expr
+ expr: expr.'+' expr
+ expr: expr.'-' expr
+ expr: expr.'|' expr
+ expr: expr.'^' expr
+ expr: expr.'*' expr
+ expr: expr.'/' expr
+ expr: expr.'%' expr
+ expr: expr.'&' expr
+ expr: expr.LANDNOT expr
+ expr: expr.LLSH expr
+ expr: expr.LRSH expr
+ expr: expr.LCOMM expr
+ complitexpr: expr. (144)
+
+ LANDAND shift 134
+ LANDNOT shift 149
+ LCOMM shift 152
+ LEQ shift 135
+ LGE shift 139
+ LGT shift 140
+ LLE shift 138
+ LLSH shift 150
+ LLT shift 137
+ LNE shift 136
+ LOROR shift 133
+ LRSH shift 151
+ '+' shift 141
+ '-' shift 142
+ '|' shift 143
+ '^' shift 144
+ '*' shift 145
+ '/' shift 146
+ '%' shift 147
+ '&' shift 148
+ . reduce 144 (src line 1046)
+
+
+state 589
+ complitexpr: '{'.start_complit braced_keyval_list '}'
+ start_complit: . (140)
+
+ . reduce 140 (src line 1013)
+
+ start_complit goto 630
+
+state 590
+ bare_complitexpr: '{' start_complit braced_keyval_list.'}'
+
+ '}' shift 631
+ . error
+
+
+state 591
+ pexpr_no_paren: '(' expr_or_type ')' '{' start_complit braced_keyval_list.'}'
+
+ '}' shift 632
+ . error
+
+
+state 592
+ ntype: '(' ntype ')'. (171)
+ non_recvchantype: '(' ntype ')'. (180)
+
+ LBODY reduce 180 (src line 1215)
+ '(' reduce 180 (src line 1215)
+ '{' reduce 180 (src line 1215)
+ . reduce 171 (src line 1196)
+
+
+state 593
+ compound_stmt: '{' $$59 stmt_list '}'. (60)
+
+ . reduce 60 (src line 549)
+
+
+state 594
+ structdcl: '(' embed ')' oliteral. (232)
+
+ . reduce 232 (src line 1594)
+
+
+state 595
+ structdcl: '(' '*' embed ')'.oliteral
+ oliteral: . (302)
+
+ LLITERAL shift 428
+ . reduce 302 (src line 1935)
+
+ oliteral goto 633
+
+state 596
+ structdcl: '*' '(' embed ')'.oliteral
+ oliteral: . (302)
+
+ LLITERAL shift 428
+ . reduce 302 (src line 1935)
+
+ oliteral goto 634
+
+state 597
+ indcl: '(' oarg_type_list_ocomma ')'.fnres
+ fnres: . (212)
+
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 232
+ '*' shift 196
+ '(' shift 488
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . reduce 212 (src line 1469)
+
+ sym goto 123
+ dotname goto 493
+ name goto 197
+ fnres goto 635
+ interfacetype goto 81
+ structtype goto 80
+ ptrtype goto 492
+ recvchantype goto 489
+ othertype goto 491
+ fnret_type goto 487
+ fntype goto 490
+ hidden_importsym goto 11
+
+state 598
+ hidden_type_misc: '[' LLITERAL ']' hidden_type. (320)
+
+ . reduce 320 (src line 2032)
+
+
+state 599
+ hidden_type_misc: LMAP '[' hidden_type ']'.hidden_type
+
+ LCHAN shift 347
+ LFUNC shift 349
+ LINTERFACE shift 345
+ LMAP shift 343
+ LNAME shift 341
+ LSTRUCT shift 344
+ LCOMM shift 348
+ '*' shift 346
+ '[' shift 342
+ '@' shift 13
+ . error
+
+ hidden_importsym goto 340
+ hidden_type goto 636
+ hidden_type_misc goto 337
+ hidden_type_func goto 339
+ hidden_type_recv_chan goto 338
+
+state 600
+ hidden_type_misc: LSTRUCT '{' ohidden_structdcl_list '}'. (322)
+
+ . reduce 322 (src line 2040)
+
+
+state 601
+ hidden_structdcl_list: hidden_structdcl_list ';'.hidden_structdcl
+
+ LNAME shift 10
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 546
+ hidden_importsym goto 11
+ hidden_structdcl goto 637
+
+state 602
+ hidden_structdcl: sym hidden_type.oliteral
+ oliteral: . (302)
+
+ LLITERAL shift 428
+ . reduce 302 (src line 1935)
+
+ oliteral goto 638
+
+state 603
+ hidden_type_misc: LINTERFACE '{' ohidden_interfacedcl_list '}'. (323)
+
+ . reduce 323 (src line 2044)
+
+
+state 604
+ hidden_interfacedcl_list: hidden_interfacedcl_list ';'.hidden_interfacedcl
+
+ LCHAN shift 347
+ LFUNC shift 349
+ LINTERFACE shift 345
+ LMAP shift 343
+ LNAME shift 552
+ LSTRUCT shift 344
+ LCOMM shift 348
+ '*' shift 346
+ '[' shift 342
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 550
+ hidden_importsym goto 553
+ hidden_interfacedcl goto 639
+ hidden_type goto 551
+ hidden_type_misc goto 337
+ hidden_type_func goto 339
+ hidden_type_recv_chan goto 338
+
+state 605
+ hidden_interfacedcl: sym '('.ohidden_funarg_list ')' ohidden_funres
+ ohidden_funarg_list: . (296)
+
+ LNAME shift 10
+ '?' shift 12
+ '@' shift 13
+ . reduce 296 (src line 1917)
+
+ sym goto 357
+ hidden_importsym goto 11
+ hidden_funarg goto 356
+ hidden_funarg_list goto 467
+ ohidden_funarg_list goto 640
+
+state 606
+ hidden_type_misc: LCHAN '(' hidden_type_recv_chan ')'. (326)
+
+ . reduce 326 (src line 2058)
+
+
+state 607
+ hidden_type_func: LFUNC '(' ohidden_funarg_list ')'.ohidden_funres
+ ohidden_funres: . (335)
+
+ LCHAN shift 347
+ LFUNC shift 349
+ LINTERFACE shift 345
+ LMAP shift 343
+ LNAME shift 341
+ LSTRUCT shift 344
+ LCOMM shift 348
+ '*' shift 346
+ '(' shift 612
+ '[' shift 342
+ '@' shift 13
+ . reduce 335 (src line 2144)
+
+ hidden_importsym goto 340
+ hidden_funres goto 611
+ ohidden_funres goto 641
+ hidden_type goto 613
+ hidden_type_misc goto 337
+ hidden_type_func goto 339
+ hidden_type_recv_chan goto 338
+
+state 608
+ hidden_constant: '(' hidden_literal '+'.hidden_literal ')'
+
+ LLITERAL shift 460
+ LNAME shift 10
+ '-' shift 461
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 462
+ hidden_importsym goto 11
+ hidden_literal goto 642
+
+state 609
+ hidden_import: LCONST hidden_pkg_importsym hidden_type '=' hidden_constant ';'. (307)
+
+ . reduce 307 (src line 1957)
+
+
+state 610
+ hidden_fndcl: hidden_pkg_importsym '(' ohidden_funarg_list ')' ohidden_funres. (207)
+
+ . reduce 207 (src line 1405)
+
+
+state 611
+ ohidden_funres: hidden_funres. (336)
+
+ . reduce 336 (src line 2148)
+
+
+state 612
+ hidden_funres: '('.ohidden_funarg_list ')'
+ ohidden_funarg_list: . (296)
+
+ LNAME shift 10
+ '?' shift 12
+ '@' shift 13
+ . reduce 296 (src line 1917)
+
+ sym goto 357
+ hidden_importsym goto 11
+ hidden_funarg goto 356
+ hidden_funarg_list goto 467
+ ohidden_funarg_list goto 643
+
+state 613
+ hidden_funres: hidden_type. (338)
+
+ . reduce 338 (src line 2155)
+
+
+state 614
+ hidden_fndcl: '(' hidden_funarg_list ')' sym '('.ohidden_funarg_list ')' ohidden_funres
+ ohidden_funarg_list: . (296)
+
+ LNAME shift 10
+ '?' shift 12
+ '@' shift 13
+ . reduce 296 (src line 1917)
+
+ sym goto 357
+ hidden_importsym goto 11
+ hidden_funarg goto 356
+ hidden_funarg_list goto 467
+ ohidden_funarg_list goto 644
+
+state 615
+ hidden_funarg: sym LDDD hidden_type oliteral. (331)
+
+ . reduce 331 (src line 2094)
+
+
+state 616
+ common_dcl: lconst '(' constdcl ';' constdcl_list osemi ')'. (33)
+
+ . reduce 33 (src line 330)
+
+
+state 617
+ constdcl_list: constdcl_list ';' constdcl1. (223)
+
+ . reduce 223 (src line 1532)
+
+
+state 618
+ fndcl: '(' oarg_type_list_ocomma ')' sym '(' oarg_type_list_ocomma.')' fnres
+
+ ')' shift 645
+ . error
+
+
+state 619
+ fnres: '(' oarg_type_list_ocomma ')'. (214)
+
+ . reduce 214 (src line 1478)
+
+
+state 620
+ loop_body: LBODY $$65 stmt_list '}'. (66)
+
+ . reduce 66 (src line 604)
+
+
+state 621
+ for_header: osimple_stmt ';' osimple_stmt ';' osimple_stmt. (70)
+
+ . reduce 70 (src line 630)
+
+
+state 622
+ switch_stmt: LSWITCH $$88 if_header $$89 LBODY caseblock_list '}'. (90)
+
+ . reduce 90 (src line 768)
+
+
+state 623
+ caseblock: case $$61 stmt_list. (62)
+ stmt_list: stmt_list.';' stmt
+
+ ';' shift 416
+ . reduce 62 (src line 571)
+
+
+state 624
+ case: LCASE expr_or_type_list ':'. (55)
+
+ . reduce 55 (src line 473)
+
+
+state 625
+ case: LCASE expr_or_type_list '='.expr ':'
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 646
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 626
+ case: LCASE expr_or_type_list LCOLAS.expr ':'
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 647
+ fnliteral goto 73
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 627
+ expr_or_type_list: expr_or_type_list ','.expr_or_type
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 179
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 178
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . error
+
+ sym goto 123
+ expr goto 173
+ expr_or_type goto 511
+ fnliteral goto 73
+ name goto 69
+ non_expr_type goto 174
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ recvchantype goto 175
+ othertype goto 177
+ fntype goto 176
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 628
+ if_stmt: LIF $$78 if_header $$79 loop_body $$80 elseif_list.else
+ elseif_list: elseif_list.elseif
+ else: . (86)
+
+ LELSE shift 650
+ . reduce 86 (src line 743)
+
+ elseif goto 649
+ else goto 648
+
+state 629
+ pexpr_no_paren: pexpr '[' oexpr ':' oexpr ':' oexpr.']'
+
+ ']' shift 651
+ . error
+
+
+state 630
+ complitexpr: '{' start_complit.braced_keyval_list '}'
+ braced_keyval_list: . (284)
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '{' shift 403
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . reduce 284 (src line 1881)
+
+ sym goto 123
+ expr goto 402
+ bare_complitexpr goto 401
+ fnliteral goto 73
+ keyval goto 400
+ name goto 69
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ uexpr goto 55
+ keyval_list goto 399
+ braced_keyval_list goto 652
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 631
+ bare_complitexpr: '{' start_complit braced_keyval_list '}'. (143)
+
+ . reduce 143 (src line 1040)
+
+
+state 632
+ pexpr_no_paren: '(' expr_or_type ')' '{' start_complit braced_keyval_list '}'. (138)
+
+ . reduce 138 (src line 1004)
+
+
+state 633
+ structdcl: '(' '*' embed ')' oliteral. (234)
+
+ . reduce 234 (src line 1606)
+
+
+state 634
+ structdcl: '*' '(' embed ')' oliteral. (235)
+
+ . reduce 235 (src line 1613)
+
+
+state 635
+ indcl: '(' oarg_type_list_ocomma ')' fnres. (242)
+
+ . reduce 242 (src line 1668)
+
+
+state 636
+ hidden_type_misc: LMAP '[' hidden_type ']' hidden_type. (321)
+
+ . reduce 321 (src line 2036)
+
+
+state 637
+ hidden_structdcl_list: hidden_structdcl_list ';' hidden_structdcl. (349)
+
+ . reduce 349 (src line 2227)
+
+
+state 638
+ hidden_structdcl: sym hidden_type oliteral. (332)
+
+ . reduce 332 (src line 2110)
+
+
+state 639
+ hidden_interfacedcl_list: hidden_interfacedcl_list ';' hidden_interfacedcl. (351)
+
+ . reduce 351 (src line 2237)
+
+
+state 640
+ hidden_interfacedcl: sym '(' ohidden_funarg_list.')' ohidden_funres
+
+ ')' shift 653
+ . error
+
+
+state 641
+ hidden_type_func: LFUNC '(' ohidden_funarg_list ')' ohidden_funres. (329)
+
+ . reduce 329 (src line 2079)
+
+
+state 642
+ hidden_constant: '(' hidden_literal '+' hidden_literal.')'
+
+ ')' shift 654
+ . error
+
+
+state 643
+ hidden_funres: '(' ohidden_funarg_list.')'
+
+ ')' shift 655
+ . error
+
+
+state 644
+ hidden_fndcl: '(' hidden_funarg_list ')' sym '(' ohidden_funarg_list.')' ohidden_funres
+
+ ')' shift 656
+ . error
+
+
+state 645
+ fndcl: '(' oarg_type_list_ocomma ')' sym '(' oarg_type_list_ocomma ')'.fnres
+ fnres: . (212)
+
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 232
+ '*' shift 196
+ '(' shift 488
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . reduce 212 (src line 1469)
+
+ sym goto 123
+ dotname goto 493
+ name goto 197
+ fnres goto 657
+ interfacetype goto 81
+ structtype goto 80
+ ptrtype goto 492
+ recvchantype goto 489
+ othertype goto 491
+ fnret_type goto 487
+ fntype goto 490
+ hidden_importsym goto 11
+
+state 646
+ case: LCASE expr_or_type_list '=' expr.':'
+ expr: expr.LOROR expr
+ expr: expr.LANDAND expr
+ expr: expr.LEQ expr
+ expr: expr.LNE expr
+ expr: expr.LLT expr
+ expr: expr.LLE expr
+ expr: expr.LGE expr
+ expr: expr.LGT expr
+ expr: expr.'+' expr
+ expr: expr.'-' expr
+ expr: expr.'|' expr
+ expr: expr.'^' expr
+ expr: expr.'*' expr
+ expr: expr.'/' expr
+ expr: expr.'%' expr
+ expr: expr.'&' expr
+ expr: expr.LANDNOT expr
+ expr: expr.LLSH expr
+ expr: expr.LRSH expr
+ expr: expr.LCOMM expr
+
+ LANDAND shift 134
+ LANDNOT shift 149
+ LCOMM shift 152
+ LEQ shift 135
+ LGE shift 139
+ LGT shift 140
+ LLE shift 138
+ LLSH shift 150
+ LLT shift 137
+ LNE shift 136
+ LOROR shift 133
+ LRSH shift 151
+ '+' shift 141
+ '-' shift 142
+ '|' shift 143
+ '^' shift 144
+ '*' shift 145
+ '/' shift 146
+ '%' shift 147
+ '&' shift 148
+ ':' shift 658
+ . error
+
+
+state 647
+ case: LCASE expr_or_type_list LCOLAS expr.':'
+ expr: expr.LOROR expr
+ expr: expr.LANDAND expr
+ expr: expr.LEQ expr
+ expr: expr.LNE expr
+ expr: expr.LLT expr
+ expr: expr.LLE expr
+ expr: expr.LGE expr
+ expr: expr.LGT expr
+ expr: expr.'+' expr
+ expr: expr.'-' expr
+ expr: expr.'|' expr
+ expr: expr.'^' expr
+ expr: expr.'*' expr
+ expr: expr.'/' expr
+ expr: expr.'%' expr
+ expr: expr.'&' expr
+ expr: expr.LANDNOT expr
+ expr: expr.LLSH expr
+ expr: expr.LRSH expr
+ expr: expr.LCOMM expr
+
+ LANDAND shift 134
+ LANDNOT shift 149
+ LCOMM shift 152
+ LEQ shift 135
+ LGE shift 139
+ LGT shift 140
+ LLE shift 138
+ LLSH shift 150
+ LLT shift 137
+ LNE shift 136
+ LOROR shift 133
+ LRSH shift 151
+ '+' shift 141
+ '-' shift 142
+ '|' shift 143
+ '^' shift 144
+ '*' shift 145
+ '/' shift 146
+ '%' shift 147
+ '&' shift 148
+ ':' shift 659
+ . error
+
+
+state 648
+ if_stmt: LIF $$78 if_header $$79 loop_body $$80 elseif_list else. (81)
+
+ . reduce 81 (src line 703)
+
+
+state 649
+ elseif_list: elseif_list elseif. (85)
+
+ . reduce 85 (src line 738)
+
+
+state 650
+ elseif: LELSE.LIF $$82 if_header loop_body
+ else: LELSE.compound_stmt
+
+ LIF shift 660
+ '{' shift 308
+ . error
+
+ compound_stmt goto 661
+
+state 651
+ pexpr_no_paren: pexpr '[' oexpr ':' oexpr ':' oexpr ']'. (133)
+
+ . reduce 133 (src line 974)
+
+
+state 652
+ complitexpr: '{' start_complit braced_keyval_list.'}'
+
+ '}' shift 662
+ . error
+
+
+state 653
+ hidden_interfacedcl: sym '(' ohidden_funarg_list ')'.ohidden_funres
+ ohidden_funres: . (335)
+
+ LCHAN shift 347
+ LFUNC shift 349
+ LINTERFACE shift 345
+ LMAP shift 343
+ LNAME shift 341
+ LSTRUCT shift 344
+ LCOMM shift 348
+ '*' shift 346
+ '(' shift 612
+ '[' shift 342
+ '@' shift 13
+ . reduce 335 (src line 2144)
+
+ hidden_importsym goto 340
+ hidden_funres goto 611
+ ohidden_funres goto 663
+ hidden_type goto 613
+ hidden_type_misc goto 337
+ hidden_type_func goto 339
+ hidden_type_recv_chan goto 338
+
+state 654
+ hidden_constant: '(' hidden_literal '+' hidden_literal ')'. (343)
+
+ . reduce 343 (src line 2197)
+
+
+state 655
+ hidden_funres: '(' ohidden_funarg_list ')'. (337)
+
+ . reduce 337 (src line 2150)
+
+
+state 656
+ hidden_fndcl: '(' hidden_funarg_list ')' sym '(' ohidden_funarg_list ')'.ohidden_funres
+ ohidden_funres: . (335)
+
+ LCHAN shift 347
+ LFUNC shift 349
+ LINTERFACE shift 345
+ LMAP shift 343
+ LNAME shift 341
+ LSTRUCT shift 344
+ LCOMM shift 348
+ '*' shift 346
+ '(' shift 612
+ '[' shift 342
+ '@' shift 13
+ . reduce 335 (src line 2144)
+
+ hidden_importsym goto 340
+ hidden_funres goto 611
+ ohidden_funres goto 664
+ hidden_type goto 613
+ hidden_type_misc goto 337
+ hidden_type_func goto 339
+ hidden_type_recv_chan goto 338
+
+state 657
+ fndcl: '(' oarg_type_list_ocomma ')' sym '(' oarg_type_list_ocomma ')' fnres. (206)
+
+ . reduce 206 (src line 1368)
+
+
+state 658
+ case: LCASE expr_or_type_list '=' expr ':'. (56)
+
+ . reduce 56 (src line 497)
+
+
+state 659
+ case: LCASE expr_or_type_list LCOLAS expr ':'. (57)
+
+ . reduce 57 (src line 515)
+
+
+state 660
+ elseif: LELSE LIF.$$82 if_header loop_body
+ $$82: . (82)
+
+ . reduce 82 (src line 720)
+
+ $$82 goto 665
+
+state 661
+ else: LELSE compound_stmt. (87)
+
+ . reduce 87 (src line 747)
+
+
+state 662
+ complitexpr: '{' start_complit braced_keyval_list '}'. (145)
+
+ . reduce 145 (src line 1048)
+
+
+state 663
+ hidden_interfacedcl: sym '(' ohidden_funarg_list ')' ohidden_funres. (333)
+
+ . reduce 333 (src line 2134)
+
+
+state 664
+ hidden_fndcl: '(' hidden_funarg_list ')' sym '(' ohidden_funarg_list ')' ohidden_funres. (208)
+
+ . reduce 208 (src line 1431)
+
+
+state 665
+ elseif: LELSE LIF $$82.if_header loop_body
+ osimple_stmt: . (294)
+
+ LLITERAL shift 68
+ LCHAN shift 78
+ LFUNC shift 124
+ LINTERFACE shift 83
+ LMAP shift 79
+ LNAME shift 10
+ LSTRUCT shift 82
+ LCOMM shift 65
+ '+' shift 60
+ '-' shift 61
+ '^' shift 64
+ '*' shift 58
+ '&' shift 59
+ '(' shift 67
+ '!' shift 62
+ '~' shift 63
+ '[' shift 77
+ '?' shift 12
+ '@' shift 13
+ . reduce 294 (src line 1911)
+
+ sym goto 123
+ expr goto 48
+ fnliteral goto 73
+ if_header goto 666
+ name goto 69
+ osimple_stmt goto 286
+ pexpr goto 57
+ pexpr_no_paren goto 66
+ pseudocall goto 70
+ simple_stmt goto 282
+ uexpr goto 55
+ expr_list goto 49
+ convtype goto 71
+ comptype goto 72
+ interfacetype goto 81
+ structtype goto 80
+ othertype goto 75
+ fntype goto 74
+ hidden_importsym goto 11
+ fnlitdcl goto 76
+
+state 666
+ elseif: LELSE LIF $$82 if_header.loop_body
+
+ LBODY shift 382
+ . error
+
+ loop_body goto 667
+
+state 667
+ elseif: LELSE LIF $$82 if_header loop_body. (83)
+
+ . reduce 83 (src line 725)
+
+
+76 terminals, 142 nonterminals
+352 grammar rules, 668/2000 states
+0 shift/reduce, 0 reduce/reduce conflicts reported
+191 working sets used
+memory: parser 3749/30000
+446 extra closures
+3093 shift entries, 64 exceptions
+603 goto entries
+1650 entries saved by goto default
+Optimizer space used: output 2282/30000
+2282 table entries, 722 zero
+maximum spread: 76, maximum offset: 666
