--- /dev/null
+// 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)
+}
--- /dev/null
+// 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
+)
--- /dev/null
+// 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
+}
--- /dev/null
+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"
--- /dev/null
+// 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
+}
--- /dev/null
+// 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
+}
--- /dev/null
+// 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
+}
--- /dev/null
+// 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)
+ }
+}
--- /dev/null
+// 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
+}
--- /dev/null
+// 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
+}
--- /dev/null
+// 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)
+}
--- /dev/null
+// 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))
+}
--- /dev/null
+// 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)
+ }
+ }
+}
--- /dev/null
+// 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
--- /dev/null
+// 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
+ }
+}
+
--- /dev/null
+// 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
+}
--- /dev/null
+// 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)
+}
--- /dev/null
+// 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)
+}
--- /dev/null
+// 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)
+ }
+}
--- /dev/null
+// 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
+}
--- /dev/null
+// 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
+}
--- /dev/null
+// 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
+}
--- /dev/null
+// 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
+}
--- /dev/null
+// 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)
+}
--- /dev/null
+// 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",
+}
--- /dev/null
+// 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
+}
--- /dev/null
+// 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
+}
--- /dev/null
+// 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
+}
--- /dev/null
+// 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
+ }
+}
--- /dev/null
+// 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
+}
--- /dev/null
+// 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)
+}
--- /dev/null
+// 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))
+ }
+}
--- /dev/null
+// 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{}
+ }
+}
--- /dev/null
+// 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
+}
--- /dev/null
+// 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
+}
--- /dev/null
+// 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
+}
--- /dev/null
+// 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)
+}
--- /dev/null
+// 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")
+ }
+ }
+}
--- /dev/null
+// 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
+}
--- /dev/null
+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
+}
--- /dev/null
+// 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
+}
--- /dev/null
+//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 */
+}
--- /dev/null
+
+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
--- /dev/null
+// 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 obj
+
+// Inferno utils/include/ar.h
+// http://code.google.com/p/inferno-os/source/browse/utils/include/ar.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.
+
+type ar_hdr struct {
+ Name string
+ Date string
+ Uid string
+ Gid string
+ Mode string
+ Size string
+ Fmag string
+}
REGEXT = REG_R10
REGG = REGEXT - 0
REGM = REGEXT - 1
+ REGCTXT = REG_R7
REGTMP = REG_R11
REGSP = REG_R13
REGLINK = REG_R14
package arm
var Anames = []string{
- "XXX ",
+ "XXX",
"CALL",
"CHECKNIL",
"DATA",
Optab{ABL, C_NONE, C_NONE, C_SBRA, 5, 4, 0, 0, 0},
Optab{ABX, C_NONE, C_NONE, C_SBRA, 74, 20, 0, 0, 0},
Optab{ABEQ, C_NONE, C_NONE, C_SBRA, 5, 4, 0, 0, 0},
+ Optab{ABEQ, C_RCON, C_NONE, C_SBRA, 5, 4, 0, 0, 0}, // prediction hinted form, hint ignored
+
Optab{AB, C_NONE, C_NONE, C_ROREG, 6, 4, 0, LPOOL, 0},
Optab{ABL, C_NONE, C_NONE, C_ROREG, 7, 4, 0, 0, 0},
Optab{ABL, C_REG, C_NONE, C_ROREG, 7, 4, 0, 0, 0},
var deferreturn *obj.LSym
-func nocache(p *obj.Prog) {
- p.Optab = 0
- p.From.Class = 0
- p.To.Class = 0
-}
-
/* size of a case statement including jump table */
func casesz(ctxt *obj.Link, p *obj.Prog) int32 {
var jt int = 0
case APLD:
out[0] = 0xe1a01001 // (MOVW R1, R1)
- break
}
}
} else {
a2 = &q.From
}
- nocache(q)
- nocache(p)
+ obj.Nocache(q)
+ obj.Nocache(p)
// insert q after p
q.Link = p.Link
} else {
a2 = &q.From
}
- nocache(q)
- nocache(p)
+ obj.Nocache(q)
+ obj.Nocache(p)
// insert q after p
q.Link = p.Link
} else if out != nil {
asmout(ctxt, p, o, out)
}
- break
}
// destination register specific
p.Pc += 4
}
size += 4
- break
}
}
if p.Scond&C_SCOND == C_SCOND_NONE {
flushpool(ctxt, p, 0, 0)
}
- break
}
if p.As == AMOVW && p.To.Type == obj.TYPE_REG && p.To.Reg == REGPC && p.Scond&C_SCOND == C_SCOND_NONE {
C_LACON:
t.To.Type = obj.TYPE_CONST
t.To.Offset = ctxt.Instoffset
- break
}
if t.Pcrel == nil {
// runtime.tlsg is special.
// Its "address" is the offset from the TLS thread pointer
// to the thread-local g and m pointers.
- // Emit a TLS relocation instead of a standard one.
- if rel.Sym == ctxt.Tlsg {
+ // Emit a TLS relocation instead of a standard one if its
+ // type is not explicitly set by runtime. This assumes that
+ // all references to runtime.tlsg should be accompanied with
+ // its type declaration if necessary.
+ if rel.Sym == ctxt.Tlsg && ctxt.Tlsg.Type == 0 {
rel.Type = obj.R_TLS
if ctxt.Flag_shared != 0 {
rel.Add += ctxt.Pc - p.Pcrel.Pc - 8 - int64(rel.Siz)
o1 |= uint32(p.To.Offset & 0xffff)
o1 |= (uint32(p.From.Reg) & 15) << 16
aclass(ctxt, &p.From)
- break
}
if ctxt.Instoffset != 0 {
if p.As == ADATABUNDLE {
o1 = 0xe125be70
}
- break
}
out[0] = o1
str = fmt.Sprintf("$%.17g", a.U.Dval)
case obj.TYPE_SCONST:
- str = fmt.Sprintf("$\"%q\"", a.U.Sval)
+ str = fmt.Sprintf("$%q", a.U.Sval)
case obj.TYPE_REGREG:
str = fmt.Sprintf("(%v, %v)", Rconv(int(a.Reg)), Rconv(int(a.Offset)))
case obj.NAME_PARAM:
str = fmt.Sprintf("%s+%d(FP)", s.Name, int(a.Offset))
- break
}
out:
"math"
)
+var progedit_tlsfallback *obj.LSym
+
func progedit(ctxt *obj.Link, p *obj.Prog) {
var literal string
var s *obj.LSym
- var tlsfallback *obj.LSym
p.From.Class = 0
p.To.Class = 0
if p.To.Type == obj.TYPE_MEM && (p.To.Name == obj.NAME_EXTERN || p.To.Name == obj.NAME_STATIC) && p.To.Sym != nil {
p.To.Type = obj.TYPE_BRANCH
}
- break
}
// Replace TLS register fetches on older ARM procesors.
if ctxt.Goarm < 7 {
// Replace it with BL runtime.read_tls_fallback(SB) for ARM CPUs that lack the tls extension.
- if tlsfallback == nil {
- tlsfallback = obj.Linklookup(ctxt, "runtime.read_tls_fallback", 0)
+ if progedit_tlsfallback == nil {
+ progedit_tlsfallback = obj.Linklookup(ctxt, "runtime.read_tls_fallback", 0)
}
// MOVW LR, R11
p.As = ABL
p.To.Type = obj.TYPE_BRANCH
- p.To.Sym = tlsfallback
+ p.To.Sym = progedit_tlsfallback
p.To.Offset = 0
// MOVW R11, LR
// Otherwise, MRC/MCR instructions need no further treatment.
p.As = AWORD
-
- break
}
// Rewrite float constants to values stored in memory.
p.From.Name = obj.NAME_EXTERN
p.From.Offset = 0
}
-
- break
}
if ctxt.Flag_shared != 0 {
}
}
-func nocache5(p *obj.Prog) {
- p.Optab = 0
- p.From.Class = 0
- p.To.Class = 0
-}
-
func preprocess(ctxt *obj.Link, cursym *obj.LSym) {
var p *obj.Prog
var pl *obj.Prog
p.Pcond = q1
}
}
-
- break
}
q = p
}
case obj.ARET:
- nocache5(p)
+ obj.Nocache(p)
if cursym.Text.Mark&LEAF != 0 {
if !(autosize != 0) {
p.As = AB
case AMODU:
p.To.Sym = ctxt.Sym_modu
- break
}
/* MOV REGTMP, b */
if p.From.Type == obj.TYPE_ADDR && p.From.Reg == REGSP && p.To.Type == obj.TYPE_REG && p.To.Reg == REGSP {
p.Spadj = int32(-p.From.Offset)
}
- break
}
}
}
}
var Linkarm = obj.LinkArch{
+ Dconv: Dconv,
+ Rconv: Rconv,
ByteOrder: binary.LittleEndian,
Pconv: Pconv,
Name: "arm",
return off + wid
}
-func adduintxx(ctxt *Link, s *LSym, v uint64, wid int) int64 {
+func Adduintxx(ctxt *Link, s *LSym, v uint64, wid int) int64 {
var off int64
off = s.Size
return off
}
-func adduint8(ctxt *Link, s *LSym, v uint8) int64 {
- return adduintxx(ctxt, s, uint64(v), 1)
+func Adduint8(ctxt *Link, s *LSym, v uint8) int64 {
+ return Adduintxx(ctxt, s, uint64(v), 1)
}
-func adduint16(ctxt *Link, s *LSym, v uint16) int64 {
- return adduintxx(ctxt, s, uint64(v), 2)
+func Adduint16(ctxt *Link, s *LSym, v uint16) int64 {
+ return Adduintxx(ctxt, s, uint64(v), 2)
}
func Adduint32(ctxt *Link, s *LSym, v uint32) int64 {
- return adduintxx(ctxt, s, uint64(v), 4)
+ return Adduintxx(ctxt, s, uint64(v), 4)
}
func Adduint64(ctxt *Link, s *LSym, v uint64) int64 {
- return adduintxx(ctxt, s, v, 8)
+ return Adduintxx(ctxt, s, v, 8)
}
-func setuint8(ctxt *Link, s *LSym, r int64, v uint8) int64 {
+func Setuint8(ctxt *Link, s *LSym, r int64, v uint8) int64 {
return Setuintxx(ctxt, s, r, uint64(v), 1)
}
return Setuintxx(ctxt, s, r, uint64(v), 2)
}
-func setuint32(ctxt *Link, s *LSym, r int64, v uint32) int64 {
+func Setuint32(ctxt *Link, s *LSym, r int64, v uint32) int64 {
return Setuintxx(ctxt, s, r, uint64(v), 4)
}
return Setuintxx(ctxt, s, r, v, 8)
}
-func addaddrplus(ctxt *Link, s *LSym, t *LSym, add int64) int64 {
+func Addaddrplus(ctxt *Link, s *LSym, t *LSym, add int64) int64 {
var i int64
var r *Reloc
return i + int64(r.Siz)
}
-func addaddr(ctxt *Link, s *LSym, t *LSym) int64 {
- return addaddrplus(ctxt, s, t, 0)
+func Addaddr(ctxt *Link, s *LSym, t *LSym) int64 {
+ return Addaddrplus(ctxt, s, t, 0)
}
-func setaddrplus(ctxt *Link, s *LSym, off int64, t *LSym, add int64) int64 {
+func Setaddrplus(ctxt *Link, s *LSym, off int64, t *LSym, add int64) int64 {
var r *Reloc
if s.Type == 0 {
return off + int64(r.Siz)
}
-func setaddr(ctxt *Link, s *LSym, off int64, t *LSym) int64 {
- return setaddrplus(ctxt, s, off, t, 0)
+func Setaddr(ctxt *Link, s *LSym, off int64, t *LSym) int64 {
+ return Setaddrplus(ctxt, s, off, t, 0)
}
-func addsize(ctxt *Link, s *LSym, t *LSym) int64 {
+func Addsize(ctxt *Link, s *LSym, t *LSym) int64 {
var i int64
var r *Reloc
return i + int64(r.Siz)
}
-func addaddrplus4(ctxt *Link, s *LSym, t *LSym, add int64) int64 {
+func Addaddrplus4(ctxt *Link, s *LSym, t *LSym, add int64) int64 {
var i int64
var r *Reloc
--- /dev/null
+// Copyright 2015 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 obj
+
+import (
+ "flag"
+ "fmt"
+ "os"
+ "strconv"
+)
+
+func Flagfn2(string, string, func(string, string)) { panic("flag") }
+
+func Flagcount(name, usage string, val *int) {
+ flag.Var((*count)(val), name, usage)
+}
+
+func Flagint32(name, usage string, val *int32) {
+ flag.Var((*int32Value)(val), name, usage)
+}
+
+func Flagint64(name, usage string, val *int64) {
+ flag.Int64Var(val, name, *val, usage)
+}
+
+func Flagstr(name, usage string, val *string) {
+ flag.StringVar(val, name, *val, usage)
+}
+
+func Flagfn0(name, usage string, f func()) {
+ flag.Var(fn0(f), name, usage)
+}
+
+func Flagfn1(name, usage string, f func(string)) {
+ flag.Var(fn1(f), name, usage)
+}
+
+func Flagprint(fd int) {
+ if fd == 1 {
+ flag.CommandLine.SetOutput(os.Stdout)
+ }
+ flag.PrintDefaults()
+}
+
+func Flagparse(usage func()) {
+ flag.Usage = usage
+ flag.Parse()
+}
+
+// count is a flag.Value that is like a flag.Bool and a flag.Int.
+// If used as -name, it increments the count, but -name=x sets the count.
+// Used for verbose flag -v.
+type count int
+
+func (c *count) String() string {
+ return fmt.Sprint(int(*c))
+}
+
+func (c *count) Set(s string) error {
+ switch s {
+ case "true":
+ *c++
+ case "false":
+ *c = 0
+ default:
+ n, err := strconv.Atoi(s)
+ if err != nil {
+ return fmt.Errorf("invalid count %q", s)
+ }
+ *c = count(n)
+ }
+ return nil
+}
+
+func (c *count) IsBoolFlag() bool {
+ return true
+}
+
+type int32Value int32
+
+func newIntValue(val int32, p *int32) *int32Value {
+ *p = val
+ return (*int32Value)(p)
+}
+
+func (i *int32Value) Set(s string) error {
+ v, err := strconv.ParseInt(s, 0, 64)
+ *i = int32Value(v)
+ return err
+}
+
+func (i *int32Value) Get() interface{} { return int32(*i) }
+
+func (i *int32Value) String() string { return fmt.Sprintf("%v", *i) }
+
+type fn0 func()
+
+func (f fn0) Set(s string) error {
+ f()
+ return nil
+}
+
+func (f fn0) Get() interface{} { return nil }
+
+func (f fn0) String() string { return "" }
+
+func (f fn0) IsBoolFlag() bool {
+ return true
+}
+
+type fn1 func(string)
+
+func (f fn1) Set(s string) error {
+ f(s)
+ return nil
+}
+
+func (f fn1) String() string { return "" }
package obj
-// (The comments in this file were copied from the manpage files rune.3,
-// isalpharune.3, and runestrcat.3. Some formatting changes were also made
-// to conform to Google style. /JRM 11/11/05)
-
-type Fmt struct {
- runes uint8
- start interface{}
- to interface{}
- stop interface{}
- flush func(*Fmt) int
- farg interface{}
- nfmt int
- args []interface{}
- r uint
- width int
- prec int
- flags uint32
- decimal string
- thousands string
- grouping string
-}
-
const (
FmtWidth = 1
FmtLeft = FmtWidth << 1
FmtLDouble = FmtByte << 1
FmtFlag = FmtLDouble << 1
)
-
-var fmtdoquote func(int) int
-
-/* Edit .+1,/^$/ | cfn $PLAN9/src/lib9/fmt/?*.c | grep -v static |grep -v __ */
var Framepointer_enabled int
-var fieldtrack_enabled int
+var Fieldtrack_enabled int
var Zprog Prog
struct {
name string
val *int
- }{"fieldtrack", &fieldtrack_enabled},
+ }{"fieldtrack", &Fieldtrack_enabled},
struct {
name string
val *int
}
}
-func expstring() string {
+// replace all "". with pkg.
+func Expandpkg(t0 string, pkg string) string {
+ return strings.Replace(t0, `"".`, pkg+".", -1)
+}
+
+func double2ieee(ieee *uint64, f float64) {
+ *ieee = math.Float64bits(f)
+}
+
+func Nopout(p *Prog) {
+ p.As = ANOP
+ p.Scond = Zprog.Scond
+ p.From = Zprog.From
+ p.From3 = Zprog.From3
+ p.Reg = Zprog.Reg
+ p.To = Zprog.To
+}
+
+func Nocache(p *Prog) {
+ p.Optab = 0
+ p.From.Class = 0
+ p.From3.Class = 0
+ p.To.Class = 0
+}
+
+/*
+ * bv.c
+ */
+
+/*
+ * closure.c
+ */
+
+/*
+ * const.c
+ */
+
+/*
+ * cplx.c
+ */
+
+/*
+ * dcl.c
+ */
+
+/*
+ * esc.c
+ */
+
+/*
+ * export.c
+ */
+
+/*
+ * fmt.c
+ */
+
+/*
+ * gen.c
+ */
+
+/*
+ * init.c
+ */
+
+/*
+ * inl.c
+ */
+
+/*
+ * lex.c
+ */
+func Expstring() string {
buf := "X"
for i := range exper {
if *exper[i].val != 0 {
}
return "X:" + buf[2:]
}
-
-// replace all "". with pkg.
-func expandpkg(t0 string, pkg string) string {
- return strings.Replace(t0, `"".`, pkg+".", -1)
-}
-
-func double2ieee(ieee *uint64, f float64) {
- *ieee = math.Float64bits(f)
-}
FREGRET = REG_F0
REGSP = REG_SP
REGTMP = REG_DI
+ REGCTXT = REG_DX
)
* this is the ranlib header
*/
var Anames = []string{
- "XXX ",
+ "XXX",
"CALL",
"CHECKNIL",
"DATA",
"USEFIELD",
"VARDEF",
"VARKILL",
- "AAA ",
+ "AAA",
"AAD",
"AAM",
"AAS",
REG_SI,
REG_DI:
i = reg[index] << 3
- break
}
switch scale {
case 8:
i |= 3 << 6
- break
}
bas:
REG_SI,
REG_DI:
i |= reg[base]
- break
}
ctxt.Andptr[0] = byte(i)
case obj.NAME_AUTO,
obj.NAME_PARAM:
base = REG_SP
- break
}
if base == REG_NONE {
case obj.NAME_AUTO,
obj.NAME_PARAM:
base = REG_SP
- break
}
if base == REG_TLS {
REG_DL,
REG_DH:
cand = 0
- break
}
}
case REG_DX:
cand = 0
- break
}
}
ctxt.Andptr[0] = Pm
ctxt.Andptr = ctxt.Andptr[1:]
}
- break
}
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = 0xb5
ctxt.Andptr = ctxt.Andptr[1:]
- break
}
asmand(ctxt, p, &p.From, reg[p.To.Reg])
ctxt.Andptr[0] = t[5]
ctxt.Andptr = ctxt.Andptr[1:]
asmand(ctxt, p, &p.To, reg[p.From.Index])
- break
}
-
- break
}
case 7: /* imul rm,r */
ctxt.Andptr[0] = 0x8B
ctxt.Andptr = ctxt.Andptr[1:]
asmand(ctxt, p, &pp.From, reg[p.To.Reg])
- break
}
-
- break
}
}
default:
str = fmt.Sprintf("%.5d (%v)\t%v\t%v,%v", p.Pc, p.Line(), Aconv(int(p.As)), Dconv(p, 0, &p.From), Dconv(p, 0, &p.To))
+
// TODO(rsc): This special case is for SHRQ $32, AX:DX, which encodes as
// SHRQ $32(DX*0), AX
// Remove.
if (p.From.Type == obj.TYPE_REG || p.From.Type == obj.TYPE_CONST) && p.From.Index != 0 {
- str += fmt.Sprintf(":%s", Rconv(int(p.From.Index)))
+ str += fmt.Sprintf(":%v", Rconv(int(p.From.Index)))
}
- break
}
fp += str
} else {
str = fmt.Sprintf("%d(FP)", a.Offset)
}
- break
}
if a.Index != REG_NONE {
str = fmt.Sprintf("$(%.17g)", a.U.Dval)
case obj.TYPE_SCONST:
- str = fmt.Sprintf("$\"%q\"", a.U.Sval)
+ str = fmt.Sprintf("$%q", a.U.Sval)
case obj.TYPE_ADDR:
a.Type = obj.TYPE_MEM
str = fmt.Sprintf("$%v", Dconv(p, 0, a))
a.Type = obj.TYPE_ADDR
- break
}
fp += str
if p.To.Type == obj.TYPE_MEM && (p.To.Name == obj.NAME_EXTERN || p.To.Name == obj.NAME_STATIC) && p.To.Sym != nil {
p.To.Type = obj.TYPE_BRANCH
}
- break
}
// Rewrite float constants to values stored in memory.
p.From.Sym = s
p.From.Offset = 0
}
-
- break
}
}
}
var Link386 = obj.LinkArch{
+ Dconv: Dconv,
+ Rconv: Rconv,
ByteOrder: binary.LittleEndian,
Pconv: Pconv,
Name: "386",
package i386
-const (
- fmtLong = 1 << iota
-)
-
func bool2int(b bool) int {
if b {
return 1
if ctxt.Debugvlog > 1 && ctxt.Bso != nil {
fmt.Fprintf(ctxt.Bso, "%5.2f addlib: %s %s pulls in %s\n", Cputime(), obj, src, pname)
}
- addlibpath(ctxt, src, obj, pname, name)
+ Addlibpath(ctxt, src, obj, pname, name)
}
/*
* file: object file, e.g., /home/rsc/go/pkg/container/vector.a
* pkg: package import path, e.g. container/vector
*/
-func addlibpath(ctxt *Link, srcref, objref, file, pkg string) {
+func Addlibpath(ctxt *Link, srcref, objref, file, pkg string) {
for _, lib := range ctxt.Library {
if lib.File == file {
return
--- /dev/null
+package obj
+
+const (
+ AEXIST = 0
+)
+
+var GOEXPERIMENT string
+
+const (
+ OREAD = iota
+ OWRITE
+ ORDWR
+ SIGBUS
+ SIGSEGV
+ NDFLT
+ FPPDBL
+ FPRNR
+ HEADER_IO
+ BOM = 0xFEFF
+)
type LinkArch struct {
Pconv func(*Prog) string
+ Dconv func(*Prog, int, *Addr) string
+ Rconv func(int) string
ByteOrder binary.ByteOrder
Name string
Thechar int
}
type Pciter struct {
- d Pcdata
- p []byte
- pc uint32
- nextpc uint32
- pcscale uint32
- value int32
- start int
- done int
+ D Pcdata
+ P []byte
+ Pc uint32
+ Nextpc uint32
+ Pcscale uint32
+ Value int32
+ Start int
+ Done int
}
// An Addr is an argument to an instruction.
--- /dev/null
+// 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 obj
+
+// Garbage collector liveness bitmap generation.
+
+// The command line flag -live causes this code to print debug information.
+// The levels are:
+//
+// -live (aka -live=1): print liveness lists as code warnings at safe points
+// -live=2: print an assembly listing with liveness annotations
+// -live=3: print information during each computation phase (much chattier)
+//
+// Each level includes the earlier output as well.
+
+// 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.
+
+// Used by cmd/gc.
+
+const (
+ GcBits = 4
+ BitsPerPointer = 2
+ BitsDead = 0
+ BitsScalar = 1
+ BitsPointer = 2
+ BitsMask = 3
+ PointersPerByte = 8 / BitsPerPointer
+ InsData = 1 + iota - 7
+ InsArray
+ InsArrayEnd
+ InsEnd
+ MaxGCMask = 65536
+)
return v
}
-func pciternext(it *Pciter) {
+func Pciternext(it *Pciter) {
var v uint32
var dv int32
- it.pc = it.nextpc
- if it.done != 0 {
+ it.Pc = it.Nextpc
+ if it.Done != 0 {
return
}
- if -cap(it.p) >= -cap(it.d.P[len(it.d.P):]) {
- it.done = 1
+ if -cap(it.P) >= -cap(it.D.P[len(it.D.P):]) {
+ it.Done = 1
return
}
// value delta
- v = getvarint(&it.p)
+ v = getvarint(&it.P)
- if v == 0 && !(it.start != 0) {
- it.done = 1
+ if v == 0 && !(it.Start != 0) {
+ it.Done = 1
return
}
- it.start = 0
+ it.Start = 0
dv = int32(v>>1) ^ (int32(v<<31) >> 31)
- it.value += dv
+ it.Value += dv
// pc delta
- v = getvarint(&it.p)
+ v = getvarint(&it.P)
- it.nextpc = it.pc + v*it.pcscale
+ it.Nextpc = it.Pc + v*it.Pcscale
}
-func pciterinit(ctxt *Link, it *Pciter, d *Pcdata) {
- it.d = *d
- it.p = it.d.P
- it.pc = 0
- it.nextpc = 0
- it.value = -1
- it.start = 1
- it.done = 0
- it.pcscale = uint32(ctxt.Arch.Minlc)
- pciternext(it)
+func Pciterinit(ctxt *Link, it *Pciter, d *Pcdata) {
+ it.D = *d
+ it.P = it.D.P
+ it.Pc = 0
+ it.Nextpc = 0
+ it.Value = -1
+ it.Start = 1
+ it.Done = 0
+ it.Pcscale = uint32(ctxt.Arch.Minlc)
+ Pciternext(it)
}
REGRT1 = REG_R3
REGRT2 = REG_R4
REGMIN = REG_R7
- REGENV = REG_R11
+ REGCTXT = REG_R11
REGTLS = REG_R13
REGMAX = REG_R27
REGEXT = REG_R30
* this is the ranlib header
*/
var Anames = []string{
- "XXX ",
+ "XXX",
"CALL",
"CHECKNIL",
"DATA",
"USEFIELD",
"VARDEF",
"VARKILL",
- "ADD ",
+ "ADD",
"ADDCC",
"ADDV",
"ADDVCC",
o3 = LOP_RRR(OP_EXTSB, uint32(p.To.Reg), uint32(p.To.Reg), 0)
//if(dlm) reloc(&p->from, p->pc, 1);
- break
+
}
out[0] = o1
str = fmt.Sprintf("$%.17g", a.U.Dval)
case obj.TYPE_SCONST:
- str = fmt.Sprintf("$\"%q\"", a.U.Sval)
- break
+ str = fmt.Sprintf("$%q", a.U.Sval)
}
fp += str
} else {
str = fmt.Sprintf("%s+%d(FP)", s.Name, a.Offset)
}
- break
}
//out:
if p.To.Sym != nil {
p.To.Type = obj.TYPE_BRANCH
}
- break
}
// Rewrite float constants to values stored in memory.
p.From.Offset = -p.From.Offset
p.As = AADD
}
-
- break
}
}
if p.To.Type == obj.TYPE_REG && p.To.Reg == REGSP && p.From.Type == obj.TYPE_CONST {
p.Spadj = int32(-p.From.Offset)
}
- break
}
}
}
}
var Linkppc64 = obj.LinkArch{
+ Dconv: Dconv,
+ Rconv: Rconv,
ByteOrder: binary.BigEndian,
Pconv: Pconv,
Name: "ppc64",
}
var Linkppc64le = obj.LinkArch{
+ Dconv: Dconv,
+ Rconv: Rconv,
ByteOrder: binary.LittleEndian,
Pconv: Pconv,
Name: "ppc64le",
package ppc64
-const (
- fmtLong = 1 << iota
-)
-
func bool2int(b bool) int {
if b {
return 1
// TODO(rsc): Share Go definitions with linkers directly.
const (
- StackSystem = 0
+ STACKSYSTEM = 0
+ StackSystem = STACKSYSTEM
StackBig = 4096
StackGuard = 640 + StackSystem
StackSmall = 128
}{"windowsgui", Hwindows},
}
-func headtype(name string) int {
+func Headtype(name string) int {
var i int
for i = 0; i < len(headers); i++ {
return -1
}
+var headstr_buf string
+
func Headstr(v int) string {
- var buf string
var i int
for i = 0; i < len(headers); i++ {
return headers[i].name
}
}
- buf = fmt.Sprintf("%d", v)
- return buf
+ headstr_buf = fmt.Sprintf("%d", v)
+ return headstr_buf
}
func Linknew(arch *LinkArch) *Link {
ctxt.Pathname = buf
- ctxt.Headtype = headtype(Getgoos())
+ ctxt.Headtype = Headtype(Getgoos())
if ctxt.Headtype < 0 {
log.Fatalf("unknown goos %s", Getgoos())
}
default:
log.Fatalf("unknown thread-local storage offset for nacl/%s", ctxt.Arch.Name)
+ case '5':
+ ctxt.Tlsoffset = 0
+
case '6':
ctxt.Tlsoffset = 0
case '8':
ctxt.Tlsoffset = -8
-
- case '5':
- ctxt.Tlsoffset = 0
- break
}
/*
case '8':
ctxt.Tlsoffset = 0x468
- break
- }
- break
+ case '5':
+ ctxt.Tlsoffset = 0 // dummy value, not needed
+ }
}
// On arm, record goarm.
return ctxt
}
-func linknewsym(ctxt *Link, symb string, v int) *LSym {
+func Linknewsym(ctxt *Link, symb string, v int) *LSym {
var s *LSym
s = new(LSym)
return nil
}
- s = linknewsym(ctxt, symb, v)
+ s = Linknewsym(ctxt, symb, v)
s.Extname = s.Name
s.Hash = ctxt.Hash[h]
ctxt.Hash[h] = s
}
// read-only lookup
-func linkrlookup(ctxt *Link, name string, v int) *LSym {
+func Linkrlookup(ctxt *Link, name string, v int) *LSym {
return _lookup(ctxt, name, v, 0)
}
+
+func Linksymfmt(s *LSym) string {
+ if s == nil {
+ return "<nil>"
+ }
+ return s.Name
+}
--- /dev/null
+// 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 obj
+
+// 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.
+
+// Must match runtime and reflect.
+// Included by cmd/gc.
+
+const (
+ KindBool = 1 + iota
+ KindInt
+ KindInt8
+ KindInt16
+ KindInt32
+ KindInt64
+ KindUint
+ KindUint8
+ KindUint16
+ KindUint32
+ KindUint64
+ KindUintptr
+ KindFloat32
+ KindFloat64
+ KindComplex64
+ KindComplex128
+ KindArray
+ KindChan
+ KindFunc
+ KindInterface
+ KindMap
+ KindPtr
+ KindSlice
+ KindString
+ KindStruct
+ KindUnsafePointer
+ KindDirectIface = 1 << 5
+ KindGCProg = 1 << 6
+ KindNoPointers = 1 << 7
+ KindMask = (1 << 5) - 1
+)
"bufio"
"fmt"
"io"
+ "log"
"os"
"strconv"
"time"
}
type Biobuf struct {
- unget int
- haveUnget bool
- f *os.File
- r *bufio.Reader
- w *bufio.Writer
+ unget [2]int
+ numUnget int
+ f *os.File
+ r *bufio.Reader
+ w *bufio.Writer
+ linelen int
}
func Bopenw(name string) (*Biobuf, error) {
- f, err := os.Open(name)
+ f, err := os.Create(name)
if err != nil {
return nil, err
}
return &Biobuf{f: f, w: bufio.NewWriter(f)}, nil
}
+func Bopenr(name string) (*Biobuf, error) {
+ f, err := os.Open(name)
+ if err != nil {
+ return nil, err
+ }
+ return &Biobuf{f: f, r: bufio.NewReader(f)}, nil
+}
+
func Binitw(w io.Writer) *Biobuf {
return &Biobuf{w: bufio.NewWriter(w)}
}
return b.w.Write(p)
}
+func Bwritestring(b *Biobuf, p string) (int, error) {
+ return b.w.WriteString(p)
+}
+
+func Bseek(b *Biobuf, offset int64, whence int) int64 {
+ if b.w != nil {
+ if err := b.w.Flush(); err != nil {
+ log.Fatal("writing output: %v", err)
+ }
+ } else if b.r != nil {
+ if whence == 1 {
+ offset -= int64(b.r.Buffered())
+ }
+ }
+ off, err := b.f.Seek(offset, whence)
+ if err != nil {
+ log.Fatal("seeking in output: %v", err)
+ }
+ if b.r != nil {
+ b.r.Reset(b.f)
+ }
+ return off
+}
+
+func Boffset(b *Biobuf) int64 {
+ if err := b.w.Flush(); err != nil {
+ log.Fatal("writing output: %v", err)
+ }
+ off, err := b.f.Seek(0, 1)
+ if err != nil {
+ log.Fatal("seeking in output: %v", err)
+ }
+ return off
+}
+
func (b *Biobuf) Flush() error {
return b.w.Flush()
}
b.w.WriteByte(c)
}
+const Beof = -1
+
+func Bread(b *Biobuf, p []byte) int {
+ n, err := io.ReadFull(b.r, p)
+ if n == 0 {
+ if err != nil && err != io.EOF {
+ n = -1
+ }
+ }
+ return n
+}
+
func Bgetc(b *Biobuf) int {
- if b.haveUnget {
- b.haveUnget = false
- return int(b.unget)
+ if b.numUnget > 0 {
+ b.numUnget--
+ return int(b.unget[b.numUnget])
}
c, err := b.r.ReadByte()
+ r := int(c)
+ if err != nil {
+ r = -1
+ }
+ b.unget[1] = b.unget[0]
+ b.unget[0] = r
+ return r
+}
+
+func Bgetrune(b *Biobuf) int {
+ r, _, err := b.r.ReadRune()
if err != nil {
- b.unget = -1
return -1
}
- b.unget = int(c)
- return int(c)
+ return int(r)
}
-func Bungetc(b *Biobuf) {
- b.haveUnget = true
+func Bungetrune(b *Biobuf) {
+ b.r.UnreadRune()
}
-func Boffset(b *Biobuf) int64 {
- panic("Boffset")
+func (b *Biobuf) Read(p []byte) (int, error) {
+ return b.r.Read(p)
+}
+
+func Brdline(b *Biobuf, delim int) string {
+ s, err := b.r.ReadBytes(byte(delim))
+ if err != nil {
+ log.Fatalf("reading input: %v", err)
+ }
+ b.linelen = len(s)
+ return string(s)
+}
+
+func Brdstr(b *Biobuf, delim int, cut int) string {
+ s, err := b.r.ReadString(byte(delim))
+ if err != nil {
+ log.Fatalf("reading input: %v", err)
+ }
+ if len(s) > 0 && cut > 0 {
+ s = s[:len(s)-1]
+ }
+ return s
+}
+
+func Access(name string, mode int) int {
+ if mode != 0 {
+ panic("bad access")
+ }
+ _, err := os.Stat(name)
+ if err != nil {
+ return -1
+ }
+ return 0
+}
+
+func Blinelen(b *Biobuf) int {
+ return b.linelen
+}
+
+func Bungetc(b *Biobuf) {
+ b.numUnget++
}
func Bflush(b *Biobuf) error {
}
func Bterm(b *Biobuf) error {
- err := b.w.Flush()
+ var err error
+ if b.w != nil {
+ err = b.w.Flush()
+ }
err1 := b.f.Close()
if err == nil {
err = err1
return envOr("GOARM", defaultGOARM)
}
+func Getgo386() string {
+ return envOr("GO386", defaultGO386)
+}
+
func Getgoversion() string {
return version
}
func (ctxt *Link) Line(n int) string {
return Linklinefmt(ctxt, n, false, false)
}
+
+func (ctxt *Link) Dconv(a *Addr) string {
+ return ctxt.Arch.Dconv(nil, 0, a)
+}
+
+func (ctxt *Link) Rconv(reg int) string {
+ return ctxt.Arch.Rconv(reg)
+}
+
+func Getcallerpc(interface{}) uintptr {
+ return 1
+}
FREGRET = REG_X0
REGSP = REG_SP
REGTMP = REG_DI
+ REGCTXT = REG_DX
REGEXT = REG_R15
FREGMIN = REG_X0 + 5
FREGEXT = REG_X0 + 15
* this is the ranlib header
*/
var Anames = []string{
- "XXX ",
+ "XXX",
"CALL",
"CHECKNIL",
"DATA",
"USEFIELD",
"VARDEF",
"VARKILL",
- "AAA ",
+ "AAA",
"AAD",
"AAM",
"AAS",
REG_SI,
REG_DI:
i = reg[index] << 3
- break
}
switch scale {
case 8:
i |= 3 << 6
- break
}
bas:
REG_SI,
REG_DI:
i |= reg[base]
- break
}
ctxt.Andptr[0] = byte(i)
case obj.NAME_AUTO,
obj.NAME_PARAM:
base = REG_SP
- break
}
ctxt.Rexflag |= regrex[int(a.Index)]&Rxx | regrex[base]&Rxb | rex
case obj.NAME_AUTO,
obj.NAME_PARAM:
base = REG_SP
- break
}
if base == REG_TLS {
ctxt.Andptr[0] = Pm
ctxt.Andptr = ctxt.Andptr[1:]
}
- break
}
ctxt.Andptr[0] = byte(op)
if p.Mode != 64 {
ctxt.Diag("asmins: illegal in %d-bit mode: %v", p.Mode, p)
}
- break
}
if z >= len(o.op) {
}
}
}
-
- break
}
return
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = 0xb5
ctxt.Andptr = ctxt.Andptr[1:]
- break
}
asmand(ctxt, p, &p.From, &p.To)
ctxt.Andptr[0] = t[1]
ctxt.Andptr = ctxt.Andptr[1:]
asmandsz(ctxt, p, &p.To, reg[int(p.From.Index)], regrex[int(p.From.Index)], 0)
- break
}
}
ctxt.Andptr[0] = 0x8B
ctxt.Andptr = ctxt.Andptr[1:]
asmand(ctxt, p, &pp.From, &p.To)
- break
}
-
- break
}
}
AMOVSQ:
copy(ctxt.Andptr, naclmovs)
ctxt.Andptr = ctxt.Andptr[len(naclmovs):]
- break
}
if ctxt.Rep != 0 {
case REG_BP:
copy(ctxt.Andptr, naclbpfix)
ctxt.Andptr = ctxt.Andptr[len(naclbpfix):]
- break
}
}
}
default:
str = fmt.Sprintf("%.5d (%v)\t%v\t%v,%v", p.Pc, p.Line(), Aconv(int(p.As)), Dconv(p, 0, &p.From), Dconv(p, 0, &p.To))
+
// TODO(rsc): This special case is for SHRQ $32, AX:DX, which encodes as
// SHRQ $32(DX*0), AX
// Remove.
- if (p.From.Type == obj.TYPE_REG || p.From.Type == obj.TYPE_CONST) && p.From.Index != 0 {
- str += fmt.Sprintf(":%s", Rconv(int(p.From.Index)))
+ if (p.From.Type == obj.TYPE_REG || p.From.Type == obj.TYPE_CONST) && p.From.Index != REG_NONE {
+ str += fmt.Sprintf(":%v", Rconv(int(p.From.Index)))
}
- break
}
fp += str
} else {
str = fmt.Sprintf("%d(FP)", a.Offset)
}
- break
}
if a.Index != REG_NONE {
str = fmt.Sprintf("$(%.17g)", a.U.Dval)
case obj.TYPE_SCONST:
- str = fmt.Sprintf("$\"%q\"", a.U.Sval)
+ str = fmt.Sprintf("$%q", a.U.Sval)
case obj.TYPE_ADDR:
a.Type = obj.TYPE_MEM
str = fmt.Sprintf("$%v", Dconv(p, 0, a))
a.Type = obj.TYPE_ADDR
- break
}
fp += str
"math"
)
-func nopout(p *obj.Prog) {
- p.As = obj.ANOP
- p.From.Type = obj.TYPE_NONE
- p.From.Reg = 0
- p.From.Name = 0
- p.To.Type = obj.TYPE_NONE
- p.To.Reg = 0
- p.To.Name = 0
-}
-
func canuselocaltls(ctxt *obj.Link) int {
switch ctxt.Headtype {
case obj.Hplan9,
// guarantee we are producing byte-identical binaries as before this code.
// But it should be unnecessary.
if (p.As == AMOVQ || p.As == AMOVL) && p.From.Type == obj.TYPE_REG && p.From.Reg == REG_TLS && p.To.Type == obj.TYPE_REG && REG_AX <= p.To.Reg && p.To.Reg <= REG_R15 && ctxt.Headtype != obj.Hsolaris {
- nopout(p)
+ obj.Nopout(p)
}
if p.From.Type == obj.TYPE_MEM && p.From.Index == REG_TLS && REG_AX <= p.From.Reg && p.From.Reg <= REG_R15 {
p.From.Reg = REG_TLS
32,
64:
ctxt.Mode = int(p.From.Offset)
- break
}
}
- nopout(p)
- break
+ obj.Nopout(p)
}
// Rewrite CALL/JMP/RET to symbol as TYPE_BRANCH.
if p.To.Type == obj.TYPE_MEM && (p.To.Name == obj.NAME_EXTERN || p.To.Name == obj.NAME_STATIC) && p.To.Sym != nil {
p.To.Type = obj.TYPE_BRANCH
}
- break
}
// Rewrite float constants to values stored in memory.
p.From.Sym = s
p.From.Offset = 0
}
-
- break
}
}
a.Scale = 1
}
a.Reg = REG_R15
- break
}
}
}
q.To.Type = obj.TYPE_BRANCH
q.To.Offset = p.Pc
q.Pcond = p
- q.Ctxt = p.Ctxt
p = q
}
}
var Linkamd64 = obj.LinkArch{
+ Dconv: Dconv,
+ Rconv: Rconv,
ByteOrder: binary.LittleEndian,
Pconv: Pconv,
Name: "amd64",
}
var Linkamd64p32 = obj.LinkArch{
+ Dconv: Dconv,
+ Rconv: Rconv,
ByteOrder: binary.LittleEndian,
Pconv: Pconv,
Name: "amd64p32",
package x86
-const (
- fmtLong = 1 << iota
-)
-
func bool2int(b bool) int {
if b {
return 1
--- /dev/null
+// 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 main
+
+import (
+ "cmd/internal/obj"
+ "cmd/internal/obj/arm"
+ "fmt"
+)
+import "cmd/internal/gc"
+
+/*
+ * peep.c
+ */
+/*
+ * generate:
+ * res = n;
+ * simplifies and calls gmove.
+ */
+func cgen(n *gc.Node, res *gc.Node) {
+ var nl *gc.Node
+ var nr *gc.Node
+ var r *gc.Node
+ var n1 gc.Node
+ var n2 gc.Node
+ var f0 gc.Node
+ var f1 gc.Node
+ var a int
+ var w int
+ var rg int
+ var p1 *obj.Prog
+ var p2 *obj.Prog
+ var p3 *obj.Prog
+ var addr obj.Addr
+
+ if gc.Debug['g'] != 0 {
+ gc.Dump("\ncgen-n", n)
+ gc.Dump("cgen-res", res)
+ }
+
+ if n == nil || n.Type == nil {
+ goto ret
+ }
+
+ if res == nil || res.Type == nil {
+ gc.Fatal("cgen: res nil")
+ }
+
+ switch n.Op {
+ case gc.OSLICE,
+ gc.OSLICEARR,
+ gc.OSLICESTR,
+ gc.OSLICE3,
+ gc.OSLICE3ARR:
+ if res.Op != gc.ONAME || !(res.Addable != 0) {
+ gc.Tempname(&n1, n.Type)
+ gc.Cgen_slice(n, &n1)
+ cgen(&n1, res)
+ } else {
+ gc.Cgen_slice(n, res)
+ }
+ return
+
+ case gc.OEFACE:
+ if res.Op != gc.ONAME || !(res.Addable != 0) {
+ gc.Tempname(&n1, n.Type)
+ gc.Cgen_eface(n, &n1)
+ cgen(&n1, res)
+ } else {
+ gc.Cgen_eface(n, res)
+ }
+ return
+ }
+
+ for n.Op == gc.OCONVNOP {
+ n = n.Left
+ }
+
+ if n.Ullman >= gc.UINF {
+ if n.Op == gc.OINDREG {
+ gc.Fatal("cgen: this is going to misscompile")
+ }
+ if res.Ullman >= gc.UINF {
+ gc.Tempname(&n1, n.Type)
+ cgen(n, &n1)
+ cgen(&n1, res)
+ goto ret
+ }
+ }
+
+ if gc.Isfat(n.Type) != 0 {
+ if n.Type.Width < 0 {
+ gc.Fatal("forgot to compute width for %v", gc.Tconv(n.Type, 0))
+ }
+ sgen(n, res, n.Type.Width)
+ goto ret
+ }
+
+ // update addressability for string, slice
+ // can't do in walk because n->left->addable
+ // changes if n->left is an escaping local variable.
+ switch n.Op {
+ case gc.OSPTR,
+ gc.OLEN:
+ if gc.Isslice(n.Left.Type) != 0 || gc.Istype(n.Left.Type, gc.TSTRING) != 0 {
+ n.Addable = n.Left.Addable
+ }
+
+ case gc.OCAP:
+ if gc.Isslice(n.Left.Type) != 0 {
+ n.Addable = n.Left.Addable
+ }
+
+ case gc.OITAB:
+ n.Addable = n.Left.Addable
+ }
+
+ // if both are addressable, move
+ if n.Addable != 0 && res.Addable != 0 {
+ if gc.Is64(n.Type) != 0 || gc.Is64(res.Type) != 0 || n.Op == gc.OREGISTER || res.Op == gc.OREGISTER || gc.Iscomplex[n.Type.Etype] != 0 || gc.Iscomplex[res.Type.Etype] != 0 {
+ gmove(n, res)
+ } else {
+ regalloc(&n1, n.Type, nil)
+ gmove(n, &n1)
+ cgen(&n1, res)
+ regfree(&n1)
+ }
+
+ goto ret
+ }
+
+ // if both are not addressable, use a temporary.
+ if !(n.Addable != 0) && !(res.Addable != 0) {
+ // could use regalloc here sometimes,
+ // but have to check for ullman >= UINF.
+ gc.Tempname(&n1, n.Type)
+
+ cgen(n, &n1)
+ cgen(&n1, res)
+ return
+ }
+
+ // if result is not addressable directly but n is,
+ // compute its address and then store via the address.
+ if !(res.Addable != 0) {
+ igen(res, &n1, nil)
+ cgen(n, &n1)
+ regfree(&n1)
+ return
+ }
+
+ if gc.Complexop(n, res) != 0 {
+ gc.Complexgen(n, res)
+ return
+ }
+
+ // if n is sudoaddable generate addr and move
+ if !(gc.Is64(n.Type) != 0) && !(gc.Is64(res.Type) != 0) && !(gc.Iscomplex[n.Type.Etype] != 0) && !(gc.Iscomplex[res.Type.Etype] != 0) {
+ a = optoas(gc.OAS, n.Type)
+ if sudoaddable(a, n, &addr, &w) != 0 {
+ if res.Op != gc.OREGISTER {
+ regalloc(&n2, res.Type, nil)
+ p1 = gins(a, nil, &n2)
+ p1.From = addr
+ if gc.Debug['g'] != 0 {
+ fmt.Printf("%v [ignore previous line]\n", p1)
+ }
+ gmove(&n2, res)
+ regfree(&n2)
+ } else {
+ p1 = gins(a, nil, res)
+ p1.From = addr
+ if gc.Debug['g'] != 0 {
+ fmt.Printf("%v [ignore previous line]\n", p1)
+ }
+ }
+
+ sudoclean()
+ goto ret
+ }
+ }
+
+ // otherwise, the result is addressable but n is not.
+ // let's do some computation.
+
+ nl = n.Left
+
+ nr = n.Right
+
+ if nl != nil && nl.Ullman >= gc.UINF {
+ if nr != nil && nr.Ullman >= gc.UINF {
+ gc.Tempname(&n1, nl.Type)
+ cgen(nl, &n1)
+ n2 = *n
+ n2.Left = &n1
+ cgen(&n2, res)
+ goto ret
+ }
+ }
+
+ // 64-bit ops are hard on 32-bit machine.
+ if gc.Is64(n.Type) != 0 || gc.Is64(res.Type) != 0 || n.Left != nil && gc.Is64(n.Left.Type) != 0 {
+ switch n.Op {
+ // math goes to cgen64.
+ case gc.OMINUS,
+ gc.OCOM,
+ gc.OADD,
+ gc.OSUB,
+ gc.OMUL,
+ gc.OLROT,
+ gc.OLSH,
+ gc.ORSH,
+ gc.OAND,
+ gc.OOR,
+ gc.OXOR:
+ cgen64(n, res)
+
+ return
+ }
+ }
+
+ if nl != nil && gc.Isfloat[n.Type.Etype] != 0 && gc.Isfloat[nl.Type.Etype] != 0 {
+ goto flt
+ }
+ switch n.Op {
+ default:
+ gc.Dump("cgen", n)
+ gc.Fatal("cgen: unknown op %v", gc.Nconv(n, obj.FmtShort|obj.FmtSign))
+
+ case gc.OREAL,
+ gc.OIMAG,
+ gc.OCOMPLEX:
+ gc.Fatal("unexpected complex")
+
+ // these call bgen to get a bool value
+ case gc.OOROR,
+ gc.OANDAND,
+ gc.OEQ,
+ gc.ONE,
+ gc.OLT,
+ gc.OLE,
+ gc.OGE,
+ gc.OGT,
+ gc.ONOT:
+ p1 = gc.Gbranch(arm.AB, nil, 0)
+
+ p2 = gc.Pc
+ gmove(gc.Nodbool(1), res)
+ p3 = gc.Gbranch(arm.AB, nil, 0)
+ gc.Patch(p1, gc.Pc)
+ bgen(n, true, 0, p2)
+ gmove(gc.Nodbool(0), res)
+ gc.Patch(p3, gc.Pc)
+ goto ret
+
+ case gc.OPLUS:
+ cgen(nl, res)
+ goto ret
+
+ // unary
+ case gc.OCOM:
+ a = optoas(gc.OXOR, nl.Type)
+
+ regalloc(&n1, nl.Type, nil)
+ cgen(nl, &n1)
+ gc.Nodconst(&n2, nl.Type, -1)
+ gins(a, &n2, &n1)
+ goto norm
+
+ case gc.OMINUS:
+ regalloc(&n1, nl.Type, nil)
+ cgen(nl, &n1)
+ gc.Nodconst(&n2, nl.Type, 0)
+ gins(optoas(gc.OMINUS, nl.Type), &n2, &n1)
+ goto norm
+
+ // symmetric binary
+ case gc.OAND,
+ gc.OOR,
+ gc.OXOR,
+ gc.OADD,
+ gc.OMUL:
+ a = optoas(int(n.Op), nl.Type)
+
+ goto sbop
+
+ // asymmetric binary
+ case gc.OSUB:
+ a = optoas(int(n.Op), nl.Type)
+
+ goto abop
+
+ case gc.OHMUL:
+ cgen_hmul(nl, nr, res)
+
+ case gc.OLROT,
+ gc.OLSH,
+ gc.ORSH:
+ cgen_shift(int(n.Op), int(n.Bounded), nl, nr, res)
+
+ case gc.OCONV:
+ if gc.Eqtype(n.Type, nl.Type) || gc.Noconv(n.Type, nl.Type) != 0 {
+ cgen(nl, res)
+ break
+ }
+
+ if nl.Addable != 0 && !(gc.Is64(nl.Type) != 0) {
+ regalloc(&n1, nl.Type, res)
+ gmove(nl, &n1)
+ } else {
+ if n.Type.Width > int64(gc.Widthptr) || gc.Is64(nl.Type) != 0 || gc.Isfloat[nl.Type.Etype] != 0 {
+ gc.Tempname(&n1, nl.Type)
+ } else {
+ regalloc(&n1, nl.Type, res)
+ }
+ cgen(nl, &n1)
+ }
+
+ if n.Type.Width > int64(gc.Widthptr) || gc.Is64(n.Type) != 0 || gc.Isfloat[n.Type.Etype] != 0 {
+ gc.Tempname(&n2, n.Type)
+ } else {
+ regalloc(&n2, n.Type, nil)
+ }
+ gmove(&n1, &n2)
+ gmove(&n2, res)
+ if n1.Op == gc.OREGISTER {
+ regfree(&n1)
+ }
+ if n2.Op == gc.OREGISTER {
+ regfree(&n2)
+ }
+
+ case gc.ODOT,
+ gc.ODOTPTR,
+ gc.OINDEX,
+ gc.OIND,
+ gc.ONAME: // PHEAP or PPARAMREF var
+ igen(n, &n1, res)
+
+ gmove(&n1, res)
+ regfree(&n1)
+
+ // interface table is first word of interface value
+ case gc.OITAB:
+ igen(nl, &n1, res)
+
+ n1.Type = n.Type
+ gmove(&n1, res)
+ regfree(&n1)
+
+ // pointer is the first word of string or slice.
+ case gc.OSPTR:
+ if gc.Isconst(nl, gc.CTSTR) != 0 {
+ regalloc(&n1, gc.Types[gc.Tptr], res)
+ p1 = gins(arm.AMOVW, nil, &n1)
+ gc.Datastring(nl.Val.U.Sval.S, &p1.From)
+ gmove(&n1, res)
+ regfree(&n1)
+ break
+ }
+
+ igen(nl, &n1, res)
+ n1.Type = n.Type
+ gmove(&n1, res)
+ regfree(&n1)
+
+ case gc.OLEN:
+ if gc.Istype(nl.Type, gc.TMAP) != 0 || gc.Istype(nl.Type, gc.TCHAN) != 0 {
+ // map has len in the first 32-bit word.
+ // a zero pointer means zero length
+ regalloc(&n1, gc.Types[gc.Tptr], res)
+
+ cgen(nl, &n1)
+
+ gc.Nodconst(&n2, gc.Types[gc.Tptr], 0)
+ gcmp(optoas(gc.OCMP, gc.Types[gc.Tptr]), &n1, &n2)
+ p1 = gc.Gbranch(optoas(gc.OEQ, gc.Types[gc.Tptr]), nil, -1)
+
+ n2 = n1
+ n2.Op = gc.OINDREG
+ n2.Type = gc.Types[gc.TINT32]
+ gmove(&n2, &n1)
+
+ gc.Patch(p1, gc.Pc)
+
+ gmove(&n1, res)
+ regfree(&n1)
+ break
+ }
+
+ if gc.Istype(nl.Type, gc.TSTRING) != 0 || gc.Isslice(nl.Type) != 0 {
+ // both slice and string have len one pointer into the struct.
+ igen(nl, &n1, res)
+
+ n1.Type = gc.Types[gc.TUINT32]
+ n1.Xoffset += int64(gc.Array_nel)
+ gmove(&n1, res)
+ regfree(&n1)
+ break
+ }
+
+ gc.Fatal("cgen: OLEN: unknown type %v", gc.Tconv(nl.Type, obj.FmtLong))
+
+ case gc.OCAP:
+ if gc.Istype(nl.Type, gc.TCHAN) != 0 {
+ // chan has cap in the second 32-bit word.
+ // a zero pointer means zero length
+ regalloc(&n1, gc.Types[gc.Tptr], res)
+
+ cgen(nl, &n1)
+
+ gc.Nodconst(&n2, gc.Types[gc.Tptr], 0)
+ gcmp(optoas(gc.OCMP, gc.Types[gc.Tptr]), &n1, &n2)
+ p1 = gc.Gbranch(optoas(gc.OEQ, gc.Types[gc.Tptr]), nil, -1)
+
+ n2 = n1
+ n2.Op = gc.OINDREG
+ n2.Xoffset = 4
+ n2.Type = gc.Types[gc.TINT32]
+ gmove(&n2, &n1)
+
+ gc.Patch(p1, gc.Pc)
+
+ gmove(&n1, res)
+ regfree(&n1)
+ break
+ }
+
+ if gc.Isslice(nl.Type) != 0 {
+ igen(nl, &n1, res)
+ n1.Type = gc.Types[gc.TUINT32]
+ n1.Xoffset += int64(gc.Array_cap)
+ gmove(&n1, res)
+ regfree(&n1)
+ break
+ }
+
+ gc.Fatal("cgen: OCAP: unknown type %v", gc.Tconv(nl.Type, obj.FmtLong))
+
+ case gc.OADDR:
+ agen(nl, res)
+
+ // Release res so that it is available for cgen_call.
+ // Pick it up again after the call.
+ case gc.OCALLMETH,
+ gc.OCALLFUNC:
+ rg = -1
+
+ if n.Ullman >= gc.UINF {
+ if res != nil && (res.Op == gc.OREGISTER || res.Op == gc.OINDREG) {
+ rg = int(res.Val.U.Reg)
+ reg[rg]--
+ }
+ }
+
+ if n.Op == gc.OCALLMETH {
+ gc.Cgen_callmeth(n, 0)
+ } else {
+ cgen_call(n, 0)
+ }
+ if rg >= 0 {
+ reg[rg]++
+ }
+ cgen_callret(n, res)
+
+ case gc.OCALLINTER:
+ cgen_callinter(n, res, 0)
+ cgen_callret(n, res)
+
+ case gc.OMOD,
+ gc.ODIV:
+ a = optoas(int(n.Op), nl.Type)
+ goto abop
+ }
+
+ goto ret
+
+sbop: // symmetric binary
+ if nl.Ullman < nr.Ullman {
+ r = nl
+ nl = nr
+ nr = r
+ }
+
+ // TODO(kaib): use fewer registers here.
+abop: // asymmetric binary
+ if nl.Ullman >= nr.Ullman {
+ regalloc(&n1, nl.Type, res)
+ cgen(nl, &n1)
+ switch n.Op {
+ case gc.OADD,
+ gc.OSUB,
+ gc.OAND,
+ gc.OOR,
+ gc.OXOR:
+ if gc.Smallintconst(nr) != 0 {
+ n2 = *nr
+ break
+ }
+ fallthrough
+
+ default:
+ regalloc(&n2, nr.Type, nil)
+ cgen(nr, &n2)
+ }
+ } else {
+ switch n.Op {
+ case gc.OADD,
+ gc.OSUB,
+ gc.OAND,
+ gc.OOR,
+ gc.OXOR:
+ if gc.Smallintconst(nr) != 0 {
+ n2 = *nr
+ break
+ }
+ fallthrough
+
+ default:
+ regalloc(&n2, nr.Type, res)
+ cgen(nr, &n2)
+ }
+
+ regalloc(&n1, nl.Type, nil)
+ cgen(nl, &n1)
+ }
+
+ gins(a, &n2, &n1)
+
+ // Normalize result for types smaller than word.
+norm:
+ if n.Type.Width < int64(gc.Widthptr) {
+ switch n.Op {
+ case gc.OADD,
+ gc.OSUB,
+ gc.OMUL,
+ gc.OCOM,
+ gc.OMINUS:
+ gins(optoas(gc.OAS, n.Type), &n1, &n1)
+ }
+ }
+
+ gmove(&n1, res)
+ regfree(&n1)
+ if n2.Op != gc.OLITERAL {
+ regfree(&n2)
+ }
+ goto ret
+
+flt: // floating-point.
+ regalloc(&f0, nl.Type, res)
+
+ if nr != nil {
+ goto flt2
+ }
+
+ if n.Op == gc.OMINUS {
+ nr = gc.Nodintconst(-1)
+ gc.Convlit(&nr, n.Type)
+ n.Op = gc.OMUL
+ goto flt2
+ }
+
+ // unary
+ cgen(nl, &f0)
+
+ if n.Op != gc.OCONV && n.Op != gc.OPLUS {
+ gins(optoas(int(n.Op), n.Type), &f0, &f0)
+ }
+ gmove(&f0, res)
+ regfree(&f0)
+ goto ret
+
+flt2: // binary
+ if nl.Ullman >= nr.Ullman {
+ cgen(nl, &f0)
+ regalloc(&f1, n.Type, nil)
+ gmove(&f0, &f1)
+ cgen(nr, &f0)
+ gins(optoas(int(n.Op), n.Type), &f0, &f1)
+ } else {
+ cgen(nr, &f0)
+ regalloc(&f1, n.Type, nil)
+ cgen(nl, &f1)
+ gins(optoas(int(n.Op), n.Type), &f0, &f1)
+ }
+
+ gmove(&f1, res)
+ regfree(&f0)
+ regfree(&f1)
+ goto ret
+
+ret:
+}
+
+/*
+ * generate array index into res.
+ * n might be any size; res is 32-bit.
+ * returns Prog* to patch to panic call.
+ */
+func cgenindex(n *gc.Node, res *gc.Node, bounded int) *obj.Prog {
+ var tmp gc.Node
+ var lo gc.Node
+ var hi gc.Node
+ var zero gc.Node
+ var n1 gc.Node
+ var n2 gc.Node
+
+ if !(gc.Is64(n.Type) != 0) {
+ cgen(n, res)
+ return nil
+ }
+
+ gc.Tempname(&tmp, gc.Types[gc.TINT64])
+ cgen(n, &tmp)
+ split64(&tmp, &lo, &hi)
+ gmove(&lo, res)
+ if bounded != 0 {
+ splitclean()
+ return nil
+ }
+
+ regalloc(&n1, gc.Types[gc.TINT32], nil)
+ regalloc(&n2, gc.Types[gc.TINT32], nil)
+ gc.Nodconst(&zero, gc.Types[gc.TINT32], 0)
+ gmove(&hi, &n1)
+ gmove(&zero, &n2)
+ gcmp(arm.ACMP, &n1, &n2)
+ regfree(&n2)
+ regfree(&n1)
+ splitclean()
+ return gc.Gbranch(arm.ABNE, nil, -1)
+}
+
+/*
+ * generate:
+ * res = &n;
+ * The generated code checks that the result is not nil.
+ */
+func agen(n *gc.Node, res *gc.Node) {
+ var nl *gc.Node
+ var n1 gc.Node
+ var n2 gc.Node
+ var n3 gc.Node
+ var r int
+
+ if gc.Debug['g'] != 0 {
+ gc.Dump("\nagen-res", res)
+ gc.Dump("agen-r", n)
+ }
+
+ if n == nil || n.Type == nil || res == nil || res.Type == nil {
+ gc.Fatal("agen")
+ }
+
+ for n.Op == gc.OCONVNOP {
+ n = n.Left
+ }
+
+ if gc.Isconst(n, gc.CTNIL) != 0 && n.Type.Width > int64(gc.Widthptr) {
+ // Use of a nil interface or nil slice.
+ // Create a temporary we can take the address of and read.
+ // The generated code is just going to panic, so it need not
+ // be terribly efficient. See issue 3670.
+ gc.Tempname(&n1, n.Type)
+
+ gc.Gvardef(&n1)
+ clearfat(&n1)
+ regalloc(&n2, gc.Types[gc.Tptr], res)
+ gins(arm.AMOVW, &n1, &n2)
+ gmove(&n2, res)
+ regfree(&n2)
+ goto ret
+ }
+
+ if n.Addable != 0 {
+ n1 = gc.Node{}
+ n1.Op = gc.OADDR
+ n1.Left = n
+ regalloc(&n2, gc.Types[gc.Tptr], res)
+ gins(arm.AMOVW, &n1, &n2)
+ gmove(&n2, res)
+ regfree(&n2)
+ goto ret
+ }
+
+ nl = n.Left
+
+ switch n.Op {
+ default:
+ gc.Fatal("agen: unknown op %v", gc.Nconv(n, obj.FmtShort|obj.FmtSign))
+
+ // Release res so that it is available for cgen_call.
+ // Pick it up again after the call.
+ case gc.OCALLMETH,
+ gc.OCALLFUNC:
+ r = -1
+
+ if n.Ullman >= gc.UINF {
+ if res.Op == gc.OREGISTER || res.Op == gc.OINDREG {
+ r = int(res.Val.U.Reg)
+ reg[r]--
+ }
+ }
+
+ if n.Op == gc.OCALLMETH {
+ gc.Cgen_callmeth(n, 0)
+ } else {
+ cgen_call(n, 0)
+ }
+ if r >= 0 {
+ reg[r]++
+ }
+ cgen_aret(n, res)
+
+ case gc.OCALLINTER:
+ cgen_callinter(n, res, 0)
+ cgen_aret(n, res)
+
+ case gc.OSLICE,
+ gc.OSLICEARR,
+ gc.OSLICESTR,
+ gc.OSLICE3,
+ gc.OSLICE3ARR:
+ gc.Tempname(&n1, n.Type)
+ gc.Cgen_slice(n, &n1)
+ agen(&n1, res)
+
+ case gc.OEFACE:
+ gc.Tempname(&n1, n.Type)
+ gc.Cgen_eface(n, &n1)
+ agen(&n1, res)
+
+ case gc.OINDEX:
+ agenr(n, &n1, res)
+ gmove(&n1, res)
+ regfree(&n1)
+
+ // should only get here with names in this func.
+ case gc.ONAME:
+ if n.Funcdepth > 0 && n.Funcdepth != gc.Funcdepth {
+ gc.Dump("bad agen", n)
+ gc.Fatal("agen: bad ONAME funcdepth %d != %d", n.Funcdepth, gc.Funcdepth)
+ }
+
+ // should only get here for heap vars or paramref
+ if !(n.Class&gc.PHEAP != 0) && n.Class != gc.PPARAMREF {
+ gc.Dump("bad agen", n)
+ gc.Fatal("agen: bad ONAME class %#x", n.Class)
+ }
+
+ cgen(n.Heapaddr, res)
+ if n.Xoffset != 0 {
+ gc.Nodconst(&n1, gc.Types[gc.TINT32], n.Xoffset)
+ regalloc(&n2, n1.Type, nil)
+ regalloc(&n3, gc.Types[gc.TINT32], nil)
+ gmove(&n1, &n2)
+ gmove(res, &n3)
+ gins(optoas(gc.OADD, gc.Types[gc.Tptr]), &n2, &n3)
+ gmove(&n3, res)
+ regfree(&n2)
+ regfree(&n3)
+ }
+
+ case gc.OIND:
+ cgen(nl, res)
+ gc.Cgen_checknil(res)
+
+ case gc.ODOT:
+ agen(nl, res)
+ if n.Xoffset != 0 {
+ gc.Nodconst(&n1, gc.Types[gc.TINT32], n.Xoffset)
+ regalloc(&n2, n1.Type, nil)
+ regalloc(&n3, gc.Types[gc.TINT32], nil)
+ gmove(&n1, &n2)
+ gmove(res, &n3)
+ gins(optoas(gc.OADD, gc.Types[gc.Tptr]), &n2, &n3)
+ gmove(&n3, res)
+ regfree(&n2)
+ regfree(&n3)
+ }
+
+ case gc.ODOTPTR:
+ cgen(nl, res)
+ gc.Cgen_checknil(res)
+ if n.Xoffset != 0 {
+ gc.Nodconst(&n1, gc.Types[gc.TINT32], n.Xoffset)
+ regalloc(&n2, n1.Type, nil)
+ regalloc(&n3, gc.Types[gc.Tptr], nil)
+ gmove(&n1, &n2)
+ gmove(res, &n3)
+ gins(optoas(gc.OADD, gc.Types[gc.Tptr]), &n2, &n3)
+ gmove(&n3, res)
+ regfree(&n2)
+ regfree(&n3)
+ }
+ }
+
+ret:
+}
+
+/*
+ * generate:
+ * newreg = &n;
+ * res = newreg
+ *
+ * on exit, a has been changed to be *newreg.
+ * caller must regfree(a).
+ * The generated code checks that the result is not *nil.
+ */
+func igen(n *gc.Node, a *gc.Node, res *gc.Node) {
+ var n1 gc.Node
+ var r int
+
+ if gc.Debug['g'] != 0 {
+ gc.Dump("\nigen-n", n)
+ }
+
+ switch n.Op {
+ case gc.ONAME:
+ if (n.Class&gc.PHEAP != 0) || n.Class == gc.PPARAMREF {
+ break
+ }
+ *a = *n
+ return
+
+ // Increase the refcount of the register so that igen's caller
+ // has to call regfree.
+ case gc.OINDREG:
+ if n.Val.U.Reg != arm.REGSP {
+ reg[n.Val.U.Reg]++
+ }
+ *a = *n
+ return
+
+ case gc.ODOT:
+ igen(n.Left, a, res)
+ a.Xoffset += n.Xoffset
+ a.Type = n.Type
+ return
+
+ case gc.ODOTPTR:
+ if n.Left.Addable != 0 || n.Left.Op == gc.OCALLFUNC || n.Left.Op == gc.OCALLMETH || n.Left.Op == gc.OCALLINTER {
+ // igen-able nodes.
+ igen(n.Left, &n1, res)
+
+ regalloc(a, gc.Types[gc.Tptr], &n1)
+ gmove(&n1, a)
+ regfree(&n1)
+ } else {
+ regalloc(a, gc.Types[gc.Tptr], res)
+ cgen(n.Left, a)
+ }
+
+ gc.Cgen_checknil(a)
+ a.Op = gc.OINDREG
+ a.Xoffset = n.Xoffset
+ a.Type = n.Type
+ return
+
+ // Release res so that it is available for cgen_call.
+ // Pick it up again after the call.
+ case gc.OCALLMETH,
+ gc.OCALLFUNC,
+ gc.OCALLINTER:
+ r = -1
+
+ if n.Ullman >= gc.UINF {
+ if res != nil && (res.Op == gc.OREGISTER || res.Op == gc.OINDREG) {
+ r = int(res.Val.U.Reg)
+ reg[r]--
+ }
+ }
+
+ switch n.Op {
+ case gc.OCALLMETH:
+ gc.Cgen_callmeth(n, 0)
+
+ case gc.OCALLFUNC:
+ cgen_call(n, 0)
+
+ case gc.OCALLINTER:
+ cgen_callinter(n, nil, 0)
+ }
+
+ if r >= 0 {
+ reg[r]++
+ }
+ regalloc(a, gc.Types[gc.Tptr], res)
+ cgen_aret(n, a)
+ a.Op = gc.OINDREG
+ a.Type = n.Type
+ return
+ }
+
+ agenr(n, a, res)
+ a.Op = gc.OINDREG
+ a.Type = n.Type
+}
+
+/*
+ * allocate a register in res and generate
+ * newreg = &n
+ * The caller must call regfree(a).
+ */
+func cgenr(n *gc.Node, a *gc.Node, res *gc.Node) {
+ var n1 gc.Node
+
+ if gc.Debug['g'] != 0 {
+ gc.Dump("cgenr-n", n)
+ }
+
+ if gc.Isfat(n.Type) != 0 {
+ gc.Fatal("cgenr on fat node")
+ }
+
+ if n.Addable != 0 {
+ regalloc(a, gc.Types[gc.Tptr], res)
+ gmove(n, a)
+ return
+ }
+
+ switch n.Op {
+ case gc.ONAME,
+ gc.ODOT,
+ gc.ODOTPTR,
+ gc.OINDEX,
+ gc.OCALLFUNC,
+ gc.OCALLMETH,
+ gc.OCALLINTER:
+ igen(n, &n1, res)
+ regalloc(a, gc.Types[gc.Tptr], &n1)
+ gmove(&n1, a)
+ regfree(&n1)
+
+ default:
+ regalloc(a, n.Type, res)
+ cgen(n, a)
+ }
+}
+
+/*
+ * generate:
+ * newreg = &n;
+ *
+ * caller must regfree(a).
+ * The generated code checks that the result is not nil.
+ */
+func agenr(n *gc.Node, a *gc.Node, res *gc.Node) {
+ var nl *gc.Node
+ var nr *gc.Node
+ var n1 gc.Node
+ var n2 gc.Node
+ var n3 gc.Node
+ var n4 gc.Node
+ var tmp gc.Node
+ var p1 *obj.Prog
+ var p2 *obj.Prog
+ var w uint32
+ var v uint64
+ var bounded int
+
+ if gc.Debug['g'] != 0 {
+ gc.Dump("agenr-n", n)
+ }
+
+ nl = n.Left
+ nr = n.Right
+
+ switch n.Op {
+ case gc.ODOT,
+ gc.ODOTPTR,
+ gc.OCALLFUNC,
+ gc.OCALLMETH,
+ gc.OCALLINTER:
+ igen(n, &n1, res)
+ regalloc(a, gc.Types[gc.Tptr], &n1)
+ agen(&n1, a)
+ regfree(&n1)
+
+ case gc.OIND:
+ cgenr(n.Left, a, res)
+ gc.Cgen_checknil(a)
+
+ case gc.OINDEX:
+ p2 = nil // to be patched to panicindex.
+ w = uint32(n.Type.Width)
+ bounded = bool2int(gc.Debug['B'] != 0 || n.Bounded != 0)
+ if nr.Addable != 0 {
+ if !(gc.Isconst(nr, gc.CTINT) != 0) {
+ gc.Tempname(&tmp, gc.Types[gc.TINT32])
+ }
+ if !(gc.Isconst(nl, gc.CTSTR) != 0) {
+ agenr(nl, &n3, res)
+ }
+ if !(gc.Isconst(nr, gc.CTINT) != 0) {
+ p2 = cgenindex(nr, &tmp, bounded)
+ regalloc(&n1, tmp.Type, nil)
+ gmove(&tmp, &n1)
+ }
+ } else if nl.Addable != 0 {
+ if !(gc.Isconst(nr, gc.CTINT) != 0) {
+ gc.Tempname(&tmp, gc.Types[gc.TINT32])
+ p2 = cgenindex(nr, &tmp, bounded)
+ regalloc(&n1, tmp.Type, nil)
+ gmove(&tmp, &n1)
+ }
+
+ if !(gc.Isconst(nl, gc.CTSTR) != 0) {
+ agenr(nl, &n3, res)
+ }
+ } else {
+ gc.Tempname(&tmp, gc.Types[gc.TINT32])
+ p2 = cgenindex(nr, &tmp, bounded)
+ nr = &tmp
+ if !(gc.Isconst(nl, gc.CTSTR) != 0) {
+ agenr(nl, &n3, res)
+ }
+ regalloc(&n1, tmp.Type, nil)
+ gins(optoas(gc.OAS, tmp.Type), &tmp, &n1)
+ }
+
+ // &a is in &n3 (allocated in res)
+ // i is in &n1 (if not constant)
+ // w is width
+
+ // constant index
+ if gc.Isconst(nr, gc.CTINT) != 0 {
+ if gc.Isconst(nl, gc.CTSTR) != 0 {
+ gc.Fatal("constant string constant index")
+ }
+ v = uint64(gc.Mpgetfix(nr.Val.U.Xval))
+ if gc.Isslice(nl.Type) != 0 || nl.Type.Etype == gc.TSTRING {
+ if !(gc.Debug['B'] != 0) && !(n.Bounded != 0) {
+ n1 = n3
+ n1.Op = gc.OINDREG
+ n1.Type = gc.Types[gc.Tptr]
+ n1.Xoffset = int64(gc.Array_nel)
+ regalloc(&n4, n1.Type, nil)
+ gmove(&n1, &n4)
+ gc.Nodconst(&n2, gc.Types[gc.TUINT32], int64(v))
+ gcmp(optoas(gc.OCMP, gc.Types[gc.TUINT32]), &n4, &n2)
+ regfree(&n4)
+ p1 = gc.Gbranch(optoas(gc.OGT, gc.Types[gc.TUINT32]), nil, +1)
+ ginscall(gc.Panicindex, 0)
+ gc.Patch(p1, gc.Pc)
+ }
+
+ n1 = n3
+ n1.Op = gc.OINDREG
+ n1.Type = gc.Types[gc.Tptr]
+ n1.Xoffset = int64(gc.Array_array)
+ gmove(&n1, &n3)
+ }
+
+ gc.Nodconst(&n2, gc.Types[gc.Tptr], int64(v*uint64(w)))
+ gins(optoas(gc.OADD, gc.Types[gc.Tptr]), &n2, &n3)
+ *a = n3
+ break
+ }
+
+ regalloc(&n2, gc.Types[gc.TINT32], &n1) // i
+ gmove(&n1, &n2)
+ regfree(&n1)
+
+ if !(gc.Debug['B'] != 0) && !(n.Bounded != 0) {
+ // check bounds
+ if gc.Isconst(nl, gc.CTSTR) != 0 {
+ gc.Nodconst(&n4, gc.Types[gc.TUINT32], int64(len(nl.Val.U.Sval.S)))
+ } else if gc.Isslice(nl.Type) != 0 || nl.Type.Etype == gc.TSTRING {
+ n1 = n3
+ n1.Op = gc.OINDREG
+ n1.Type = gc.Types[gc.Tptr]
+ n1.Xoffset = int64(gc.Array_nel)
+ regalloc(&n4, gc.Types[gc.TUINT32], nil)
+ gmove(&n1, &n4)
+ } else {
+ gc.Nodconst(&n4, gc.Types[gc.TUINT32], nl.Type.Bound)
+ }
+
+ gcmp(optoas(gc.OCMP, gc.Types[gc.TUINT32]), &n2, &n4)
+ if n4.Op == gc.OREGISTER {
+ regfree(&n4)
+ }
+ p1 = gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TUINT32]), nil, +1)
+ if p2 != nil {
+ gc.Patch(p2, gc.Pc)
+ }
+ ginscall(gc.Panicindex, 0)
+ gc.Patch(p1, gc.Pc)
+ }
+
+ if gc.Isconst(nl, gc.CTSTR) != 0 {
+ regalloc(&n3, gc.Types[gc.Tptr], res)
+ p1 = gins(arm.AMOVW, nil, &n3)
+ gc.Datastring(nl.Val.U.Sval.S, &p1.From)
+ p1.From.Type = obj.TYPE_ADDR
+ } else if gc.Isslice(nl.Type) != 0 || nl.Type.Etype == gc.TSTRING {
+ n1 = n3
+ n1.Op = gc.OINDREG
+ n1.Type = gc.Types[gc.Tptr]
+ n1.Xoffset = int64(gc.Array_array)
+ gmove(&n1, &n3)
+ }
+
+ if w == 0 {
+ } else // nothing to do
+ if w == 1 || w == 2 || w == 4 || w == 8 {
+ n4 = gc.Node{}
+ n4.Op = gc.OADDR
+ n4.Left = &n2
+ cgen(&n4, &n3)
+ if w == 1 {
+ gins(arm.AADD, &n2, &n3)
+ } else if w == 2 {
+ gshift(arm.AADD, &n2, arm.SHIFT_LL, 1, &n3)
+ } else if w == 4 {
+ gshift(arm.AADD, &n2, arm.SHIFT_LL, 2, &n3)
+ } else if w == 8 {
+ gshift(arm.AADD, &n2, arm.SHIFT_LL, 3, &n3)
+ }
+ } else {
+ regalloc(&n4, gc.Types[gc.TUINT32], nil)
+ gc.Nodconst(&n1, gc.Types[gc.TUINT32], int64(w))
+ gmove(&n1, &n4)
+ gins(optoas(gc.OMUL, gc.Types[gc.TUINT32]), &n4, &n2)
+ gins(optoas(gc.OADD, gc.Types[gc.Tptr]), &n2, &n3)
+ regfree(&n4)
+ }
+
+ *a = n3
+ regfree(&n2)
+
+ default:
+ regalloc(a, gc.Types[gc.Tptr], res)
+ agen(n, a)
+ }
+}
+
+func gencmp0(n *gc.Node, t *gc.Type, o int, likely int, to *obj.Prog) {
+ var n1 gc.Node
+ var n2 gc.Node
+ var n3 gc.Node
+ var a int
+
+ regalloc(&n1, t, nil)
+ cgen(n, &n1)
+ a = optoas(gc.OCMP, t)
+ if a != arm.ACMP {
+ gc.Nodconst(&n2, t, 0)
+ regalloc(&n3, t, nil)
+ gmove(&n2, &n3)
+ gcmp(a, &n1, &n3)
+ regfree(&n3)
+ } else {
+ gins(arm.ATST, &n1, nil)
+ }
+ a = optoas(o, t)
+ gc.Patch(gc.Gbranch(a, t, likely), to)
+ regfree(&n1)
+}
+
+/*
+ * generate:
+ * if(n == true) goto to;
+ */
+func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) {
+ var et int
+ var a int
+ var nl *gc.Node
+ var nr *gc.Node
+ var r *gc.Node
+ var n1 gc.Node
+ var n2 gc.Node
+ var n3 gc.Node
+ var tmp gc.Node
+ var ll *gc.NodeList
+ var p1 *obj.Prog
+ var p2 *obj.Prog
+
+ if gc.Debug['g'] != 0 {
+ gc.Dump("\nbgen", n)
+ }
+
+ if n == nil {
+ n = gc.Nodbool(1)
+ }
+
+ if n.Ninit != nil {
+ gc.Genlist(n.Ninit)
+ }
+
+ if n.Type == nil {
+ gc.Convlit(&n, gc.Types[gc.TBOOL])
+ if n.Type == nil {
+ goto ret
+ }
+ }
+
+ et = int(n.Type.Etype)
+ if et != gc.TBOOL {
+ gc.Yyerror("cgen: bad type %v for %v", gc.Tconv(n.Type, 0), gc.Oconv(int(n.Op), 0))
+ gc.Patch(gins(obj.AEND, nil, nil), to)
+ goto ret
+ }
+
+ nr = nil
+
+ switch n.Op {
+ default:
+ a = gc.ONE
+ if !true_ {
+ a = gc.OEQ
+ }
+ gencmp0(n, n.Type, a, likely, to)
+ goto ret
+
+ // need to ask if it is bool?
+ case gc.OLITERAL:
+ if !true_ == !(n.Val.U.Bval != 0) {
+ gc.Patch(gc.Gbranch(arm.AB, nil, 0), to)
+ }
+ goto ret
+
+ case gc.OANDAND,
+ gc.OOROR:
+ if (n.Op == gc.OANDAND) == true_ {
+ p1 = gc.Gbranch(obj.AJMP, nil, 0)
+ p2 = gc.Gbranch(obj.AJMP, nil, 0)
+ gc.Patch(p1, gc.Pc)
+ bgen(n.Left, !true_, -likely, p2)
+ bgen(n.Right, !true_, -likely, p2)
+ p1 = gc.Gbranch(obj.AJMP, nil, 0)
+ gc.Patch(p1, to)
+ gc.Patch(p2, gc.Pc)
+ } else {
+ bgen(n.Left, true_, likely, to)
+ bgen(n.Right, true_, likely, to)
+ }
+
+ goto ret
+
+ case gc.OEQ,
+ gc.ONE,
+ gc.OLT,
+ gc.OGT,
+ gc.OLE,
+ gc.OGE:
+ nr = n.Right
+ if nr == nil || nr.Type == nil {
+ goto ret
+ }
+ fallthrough
+
+ case gc.ONOT: // unary
+ nl = n.Left
+
+ if nl == nil || nl.Type == nil {
+ goto ret
+ }
+ }
+
+ switch n.Op {
+ case gc.ONOT:
+ bgen(nl, !true_, likely, to)
+ goto ret
+
+ case gc.OEQ,
+ gc.ONE,
+ gc.OLT,
+ gc.OGT,
+ gc.OLE,
+ gc.OGE:
+ a = int(n.Op)
+ if !true_ {
+ if gc.Isfloat[nl.Type.Etype] != 0 {
+ // brcom is not valid on floats when NaN is involved.
+ p1 = gc.Gbranch(arm.AB, nil, 0)
+
+ p2 = gc.Gbranch(arm.AB, nil, 0)
+ gc.Patch(p1, gc.Pc)
+ ll = n.Ninit
+ n.Ninit = nil
+ bgen(n, true, -likely, p2)
+ n.Ninit = ll
+ gc.Patch(gc.Gbranch(arm.AB, nil, 0), to)
+ gc.Patch(p2, gc.Pc)
+ goto ret
+ }
+
+ a = gc.Brcom(a)
+ true_ = !true_
+ }
+
+ // make simplest on right
+ if nl.Op == gc.OLITERAL || (nl.Ullman < gc.UINF && nl.Ullman < nr.Ullman) {
+ a = gc.Brrev(a)
+ r = nl
+ nl = nr
+ nr = r
+ }
+
+ if gc.Isslice(nl.Type) != 0 {
+ // only valid to cmp darray to literal nil
+ if (a != gc.OEQ && a != gc.ONE) || nr.Op != gc.OLITERAL {
+ gc.Yyerror("illegal array comparison")
+ break
+ }
+
+ igen(nl, &n1, nil)
+ n1.Xoffset += int64(gc.Array_array)
+ n1.Type = gc.Types[gc.Tptr]
+ gencmp0(&n1, gc.Types[gc.Tptr], a, likely, to)
+ regfree(&n1)
+ break
+ }
+
+ if gc.Isinter(nl.Type) != 0 {
+ // front end shold only leave cmp to literal nil
+ if (a != gc.OEQ && a != gc.ONE) || nr.Op != gc.OLITERAL {
+ gc.Yyerror("illegal interface comparison")
+ break
+ }
+
+ igen(nl, &n1, nil)
+ n1.Type = gc.Types[gc.Tptr]
+ n1.Xoffset += 0
+ gencmp0(&n1, gc.Types[gc.Tptr], a, likely, to)
+ regfree(&n1)
+ break
+ }
+
+ if gc.Iscomplex[nl.Type.Etype] != 0 {
+ gc.Complexbool(a, nl, nr, true_, likely, to)
+ break
+ }
+
+ if gc.Is64(nr.Type) != 0 {
+ if !(nl.Addable != 0) {
+ gc.Tempname(&n1, nl.Type)
+ cgen(nl, &n1)
+ nl = &n1
+ }
+
+ if !(nr.Addable != 0) {
+ gc.Tempname(&n2, nr.Type)
+ cgen(nr, &n2)
+ nr = &n2
+ }
+
+ cmp64(nl, nr, a, likely, to)
+ break
+ }
+
+ if nr.Op == gc.OLITERAL {
+ if gc.Isconst(nr, gc.CTINT) != 0 && gc.Mpgetfix(nr.Val.U.Xval) == 0 {
+ gencmp0(nl, nl.Type, a, likely, to)
+ break
+ }
+
+ if nr.Val.Ctype == gc.CTNIL {
+ gencmp0(nl, nl.Type, a, likely, to)
+ break
+ }
+ }
+
+ a = optoas(a, nr.Type)
+
+ if nr.Ullman >= gc.UINF {
+ regalloc(&n1, nl.Type, nil)
+ cgen(nl, &n1)
+
+ gc.Tempname(&tmp, nl.Type)
+ gmove(&n1, &tmp)
+ regfree(&n1)
+
+ regalloc(&n2, nr.Type, nil)
+ cgen(nr, &n2)
+
+ regalloc(&n1, nl.Type, nil)
+ cgen(&tmp, &n1)
+
+ gcmp(optoas(gc.OCMP, nr.Type), &n1, &n2)
+ gc.Patch(gc.Gbranch(a, nr.Type, likely), to)
+
+ regfree(&n1)
+ regfree(&n2)
+ break
+ }
+
+ gc.Tempname(&n3, nl.Type)
+ cgen(nl, &n3)
+
+ gc.Tempname(&tmp, nr.Type)
+ cgen(nr, &tmp)
+
+ regalloc(&n1, nl.Type, nil)
+ gmove(&n3, &n1)
+
+ regalloc(&n2, nr.Type, nil)
+ gmove(&tmp, &n2)
+
+ gcmp(optoas(gc.OCMP, nr.Type), &n1, &n2)
+ if gc.Isfloat[nl.Type.Etype] != 0 {
+ if n.Op == gc.ONE {
+ p1 = gc.Gbranch(arm.ABVS, nr.Type, likely)
+ gc.Patch(gc.Gbranch(a, nr.Type, likely), to)
+ gc.Patch(p1, to)
+ } else {
+ p1 = gc.Gbranch(arm.ABVS, nr.Type, -likely)
+ gc.Patch(gc.Gbranch(a, nr.Type, likely), to)
+ gc.Patch(p1, gc.Pc)
+ }
+ } else {
+ gc.Patch(gc.Gbranch(a, nr.Type, likely), to)
+ }
+
+ regfree(&n1)
+ regfree(&n2)
+ }
+
+ goto ret
+
+ret:
+}
+
+/*
+ * n is on stack, either local variable
+ * or return value from function call.
+ * return n's offset from SP.
+ */
+func stkof(n *gc.Node) int32 {
+ var t *gc.Type
+ var flist gc.Iter
+ var off int32
+
+ switch n.Op {
+ case gc.OINDREG:
+ return int32(n.Xoffset)
+
+ case gc.ODOT:
+ t = n.Left.Type
+ if gc.Isptr[t.Etype] != 0 {
+ break
+ }
+ off = stkof(n.Left)
+ if off == -1000 || off == 1000 {
+ return off
+ }
+ return int32(int64(off) + n.Xoffset)
+
+ case gc.OINDEX:
+ t = n.Left.Type
+ if !(gc.Isfixedarray(t) != 0) {
+ break
+ }
+ off = stkof(n.Left)
+ if off == -1000 || off == 1000 {
+ return off
+ }
+ if gc.Isconst(n.Right, gc.CTINT) != 0 {
+ return int32(int64(off) + t.Type.Width*gc.Mpgetfix(n.Right.Val.U.Xval))
+ }
+ return 1000
+
+ case gc.OCALLMETH,
+ gc.OCALLINTER,
+ gc.OCALLFUNC:
+ t = n.Left.Type
+ if gc.Isptr[t.Etype] != 0 {
+ t = t.Type
+ }
+
+ t = gc.Structfirst(&flist, gc.Getoutarg(t))
+ if t != nil {
+ return int32(t.Width + 4) // correct for LR
+ }
+ }
+
+ // botch - probably failing to recognize address
+ // arithmetic on the above. eg INDEX and DOT
+ return -1000
+}
+
+/*
+ * block copy:
+ * memmove(&res, &n, w);
+ * NB: character copy assumed little endian architecture
+ */
+func sgen(n *gc.Node, res *gc.Node, w int64) {
+ var dst gc.Node
+ var src gc.Node
+ var tmp gc.Node
+ var nend gc.Node
+ var r0 gc.Node
+ var r1 gc.Node
+ var r2 gc.Node
+ var f *gc.Node
+ var c int32
+ var odst int32
+ var osrc int32
+ var dir int
+ var align int
+ var op int
+ var p *obj.Prog
+ var ploop *obj.Prog
+ var l *gc.NodeList
+
+ if gc.Debug['g'] != 0 {
+ fmt.Printf("\nsgen w=%d\n", w)
+ gc.Dump("r", n)
+ gc.Dump("res", res)
+ }
+
+ if n.Ullman >= gc.UINF && res.Ullman >= gc.UINF {
+ gc.Fatal("sgen UINF")
+ }
+
+ if w < 0 || int64(int32(w)) != w {
+ gc.Fatal("sgen copy %d", w)
+ }
+
+ if n.Type == nil {
+ gc.Fatal("sgen: missing type")
+ }
+
+ if w == 0 {
+ // evaluate side effects only.
+ regalloc(&dst, gc.Types[gc.Tptr], nil)
+
+ agen(res, &dst)
+ agen(n, &dst)
+ regfree(&dst)
+ return
+ }
+
+ // If copying .args, that's all the results, so record definition sites
+ // for them for the liveness analysis.
+ if res.Op == gc.ONAME && res.Sym.Name == ".args" {
+ for l = gc.Curfn.Dcl; l != nil; l = l.Next {
+ if l.N.Class == gc.PPARAMOUT {
+ gc.Gvardef(l.N)
+ }
+ }
+ }
+
+ // Avoid taking the address for simple enough types.
+ if componentgen(n, res) != 0 {
+ return
+ }
+
+ // determine alignment.
+ // want to avoid unaligned access, so have to use
+ // smaller operations for less aligned types.
+ // for example moving [4]byte must use 4 MOVB not 1 MOVW.
+ align = int(n.Type.Align)
+
+ switch align {
+ default:
+ gc.Fatal("sgen: invalid alignment %d for %v", align, gc.Tconv(n.Type, 0))
+ fallthrough
+
+ case 1:
+ op = arm.AMOVB
+
+ case 2:
+ op = arm.AMOVH
+
+ case 4:
+ op = arm.AMOVW
+ }
+
+ if w%int64(align) != 0 {
+ gc.Fatal("sgen: unaligned size %d (align=%d) for %v", w, align, gc.Tconv(n.Type, 0))
+ }
+ c = int32(w / int64(align))
+
+ // offset on the stack
+ osrc = stkof(n)
+
+ odst = stkof(res)
+ if osrc != -1000 && odst != -1000 && (osrc == 1000 || odst == 1000) {
+ // osrc and odst both on stack, and at least one is in
+ // an unknown position. Could generate code to test
+ // for forward/backward copy, but instead just copy
+ // to a temporary location first.
+ gc.Tempname(&tmp, n.Type)
+
+ sgen(n, &tmp, w)
+ sgen(&tmp, res, w)
+ return
+ }
+
+ if osrc%int32(align) != 0 || odst%int32(align) != 0 {
+ gc.Fatal("sgen: unaligned offset src %d or dst %d (align %d)", osrc, odst, align)
+ }
+
+ // if we are copying forward on the stack and
+ // the src and dst overlap, then reverse direction
+ dir = align
+
+ if osrc < odst && int64(odst) < int64(osrc)+w {
+ dir = -dir
+ }
+
+ if op == arm.AMOVW && !gc.Nacl && dir > 0 && c >= 4 && c <= 128 {
+ r0.Op = gc.OREGISTER
+ r0.Val.U.Reg = REGALLOC_R0
+ r1.Op = gc.OREGISTER
+ r1.Val.U.Reg = REGALLOC_R0 + 1
+ r2.Op = gc.OREGISTER
+ r2.Val.U.Reg = REGALLOC_R0 + 2
+
+ regalloc(&src, gc.Types[gc.Tptr], &r1)
+ regalloc(&dst, gc.Types[gc.Tptr], &r2)
+ if n.Ullman >= res.Ullman {
+ // eval n first
+ agen(n, &src)
+
+ if res.Op == gc.ONAME {
+ gc.Gvardef(res)
+ }
+ agen(res, &dst)
+ } else {
+ // eval res first
+ if res.Op == gc.ONAME {
+ gc.Gvardef(res)
+ }
+ agen(res, &dst)
+ agen(n, &src)
+ }
+
+ regalloc(&tmp, gc.Types[gc.Tptr], &r0)
+ f = gc.Sysfunc("duffcopy")
+ p = gins(obj.ADUFFCOPY, nil, f)
+ gc.Afunclit(&p.To, f)
+
+ // 8 and 128 = magic constants: see ../../runtime/asm_arm.s
+ p.To.Offset = 8 * (128 - int64(c))
+
+ regfree(&tmp)
+ regfree(&src)
+ regfree(&dst)
+ return
+ }
+
+ if n.Ullman >= res.Ullman {
+ agenr(n, &dst, res) // temporarily use dst
+ regalloc(&src, gc.Types[gc.Tptr], nil)
+ gins(arm.AMOVW, &dst, &src)
+ if res.Op == gc.ONAME {
+ gc.Gvardef(res)
+ }
+ agen(res, &dst)
+ } else {
+ if res.Op == gc.ONAME {
+ gc.Gvardef(res)
+ }
+ agenr(res, &dst, res)
+ agenr(n, &src, nil)
+ }
+
+ regalloc(&tmp, gc.Types[gc.TUINT32], nil)
+
+ // set up end marker
+ nend = gc.Node{}
+
+ if c >= 4 {
+ regalloc(&nend, gc.Types[gc.TUINT32], nil)
+
+ p = gins(arm.AMOVW, &src, &nend)
+ p.From.Type = obj.TYPE_ADDR
+ if dir < 0 {
+ p.From.Offset = int64(dir)
+ } else {
+ p.From.Offset = w
+ }
+ }
+
+ // move src and dest to the end of block if necessary
+ if dir < 0 {
+ p = gins(arm.AMOVW, &src, &src)
+ p.From.Type = obj.TYPE_ADDR
+ p.From.Offset = w + int64(dir)
+
+ p = gins(arm.AMOVW, &dst, &dst)
+ p.From.Type = obj.TYPE_ADDR
+ p.From.Offset = w + int64(dir)
+ }
+
+ // move
+ if c >= 4 {
+ p = gins(op, &src, &tmp)
+ p.From.Type = obj.TYPE_MEM
+ p.From.Offset = int64(dir)
+ p.Scond |= arm.C_PBIT
+ ploop = p
+
+ p = gins(op, &tmp, &dst)
+ p.To.Type = obj.TYPE_MEM
+ p.To.Offset = int64(dir)
+ p.Scond |= arm.C_PBIT
+
+ p = gins(arm.ACMP, &src, nil)
+ raddr(&nend, p)
+
+ gc.Patch(gc.Gbranch(arm.ABNE, nil, 0), ploop)
+ regfree(&nend)
+ } else {
+ for {
+ tmp14 := c
+ c--
+ if !(tmp14 > 0) {
+ break
+ }
+ p = gins(op, &src, &tmp)
+ p.From.Type = obj.TYPE_MEM
+ p.From.Offset = int64(dir)
+ p.Scond |= arm.C_PBIT
+
+ p = gins(op, &tmp, &dst)
+ p.To.Type = obj.TYPE_MEM
+ p.To.Offset = int64(dir)
+ p.Scond |= arm.C_PBIT
+ }
+ }
+
+ regfree(&dst)
+ regfree(&src)
+ regfree(&tmp)
+}
+
+func cadable(n *gc.Node) int {
+ if !(n.Addable != 0) {
+ // dont know how it happens,
+ // but it does
+ return 0
+ }
+
+ switch n.Op {
+ case gc.ONAME:
+ return 1
+ }
+
+ return 0
+}
+
+/*
+ * copy a composite value by moving its individual components.
+ * Slices, strings and interfaces are supported.
+ * Small structs or arrays with elements of basic type are
+ * also supported.
+ * nr is N when assigning a zero value.
+ * return 1 if can do, 0 if cant.
+ */
+func componentgen(nr *gc.Node, nl *gc.Node) int {
+ var nodl gc.Node
+ var nodr gc.Node
+ var tmp gc.Node
+ var t *gc.Type
+ var freel int
+ var freer int
+ var fldcount int64
+ var loffset int64
+ var roffset int64
+
+ freel = 0
+ freer = 0
+
+ switch nl.Type.Etype {
+ default:
+ goto no
+
+ case gc.TARRAY:
+ t = nl.Type
+
+ // Slices are ok.
+ if gc.Isslice(t) != 0 {
+ break
+ }
+
+ // Small arrays are ok.
+ if t.Bound > 0 && t.Bound <= 3 && !(gc.Isfat(t.Type) != 0) {
+ break
+ }
+
+ goto no
+
+ // Small structs with non-fat types are ok.
+ // Zero-sized structs are treated separately elsewhere.
+ case gc.TSTRUCT:
+ fldcount = 0
+
+ for t = nl.Type.Type; t != nil; t = t.Down {
+ if gc.Isfat(t.Type) != 0 {
+ goto no
+ }
+ if t.Etype != gc.TFIELD {
+ gc.Fatal("componentgen: not a TFIELD: %v", gc.Tconv(t, obj.FmtLong))
+ }
+ fldcount++
+ }
+
+ if fldcount == 0 || fldcount > 4 {
+ goto no
+ }
+
+ case gc.TSTRING,
+ gc.TINTER:
+ break
+ }
+
+ nodl = *nl
+ if !(cadable(nl) != 0) {
+ if nr != nil && !(cadable(nr) != 0) {
+ goto no
+ }
+ igen(nl, &nodl, nil)
+ freel = 1
+ }
+
+ if nr != nil {
+ nodr = *nr
+ if !(cadable(nr) != 0) {
+ igen(nr, &nodr, nil)
+ freer = 1
+ }
+ } else {
+ // When zeroing, prepare a register containing zero.
+ gc.Nodconst(&tmp, nl.Type, 0)
+
+ regalloc(&nodr, gc.Types[gc.TUINT], nil)
+ gmove(&tmp, &nodr)
+ freer = 1
+ }
+
+ // nl and nr are 'cadable' which basically means they are names (variables) now.
+ // If they are the same variable, don't generate any code, because the
+ // VARDEF we generate will mark the old value as dead incorrectly.
+ // (And also the assignments are useless.)
+ if nr != nil && nl.Op == gc.ONAME && nr.Op == gc.ONAME && nl == nr {
+ goto yes
+ }
+
+ switch nl.Type.Etype {
+ // componentgen for arrays.
+ case gc.TARRAY:
+ if nl.Op == gc.ONAME {
+ gc.Gvardef(nl)
+ }
+ t = nl.Type
+ if !(gc.Isslice(t) != 0) {
+ nodl.Type = t.Type
+ nodr.Type = nodl.Type
+ for fldcount = 0; fldcount < t.Bound; fldcount++ {
+ if nr == nil {
+ gc.Clearslim(&nodl)
+ } else {
+ gmove(&nodr, &nodl)
+ }
+ nodl.Xoffset += t.Type.Width
+ nodr.Xoffset += t.Type.Width
+ }
+
+ goto yes
+ }
+
+ // componentgen for slices.
+ nodl.Xoffset += int64(gc.Array_array)
+
+ nodl.Type = gc.Ptrto(nl.Type.Type)
+
+ if nr != nil {
+ nodr.Xoffset += int64(gc.Array_array)
+ nodr.Type = nodl.Type
+ }
+
+ gmove(&nodr, &nodl)
+
+ nodl.Xoffset += int64(gc.Array_nel) - int64(gc.Array_array)
+ nodl.Type = gc.Types[gc.Simtype[gc.TUINT]]
+
+ if nr != nil {
+ nodr.Xoffset += int64(gc.Array_nel) - int64(gc.Array_array)
+ nodr.Type = nodl.Type
+ }
+
+ gmove(&nodr, &nodl)
+
+ nodl.Xoffset += int64(gc.Array_cap) - int64(gc.Array_nel)
+ nodl.Type = gc.Types[gc.Simtype[gc.TUINT]]
+
+ if nr != nil {
+ nodr.Xoffset += int64(gc.Array_cap) - int64(gc.Array_nel)
+ nodr.Type = nodl.Type
+ }
+
+ gmove(&nodr, &nodl)
+
+ goto yes
+
+ case gc.TSTRING:
+ if nl.Op == gc.ONAME {
+ gc.Gvardef(nl)
+ }
+ nodl.Xoffset += int64(gc.Array_array)
+ nodl.Type = gc.Ptrto(gc.Types[gc.TUINT8])
+
+ if nr != nil {
+ nodr.Xoffset += int64(gc.Array_array)
+ nodr.Type = nodl.Type
+ }
+
+ gmove(&nodr, &nodl)
+
+ nodl.Xoffset += int64(gc.Array_nel) - int64(gc.Array_array)
+ nodl.Type = gc.Types[gc.Simtype[gc.TUINT]]
+
+ if nr != nil {
+ nodr.Xoffset += int64(gc.Array_nel) - int64(gc.Array_array)
+ nodr.Type = nodl.Type
+ }
+
+ gmove(&nodr, &nodl)
+
+ goto yes
+
+ case gc.TINTER:
+ if nl.Op == gc.ONAME {
+ gc.Gvardef(nl)
+ }
+ nodl.Xoffset += int64(gc.Array_array)
+ nodl.Type = gc.Ptrto(gc.Types[gc.TUINT8])
+
+ if nr != nil {
+ nodr.Xoffset += int64(gc.Array_array)
+ nodr.Type = nodl.Type
+ }
+
+ gmove(&nodr, &nodl)
+
+ nodl.Xoffset += int64(gc.Array_nel) - int64(gc.Array_array)
+ nodl.Type = gc.Ptrto(gc.Types[gc.TUINT8])
+
+ if nr != nil {
+ nodr.Xoffset += int64(gc.Array_nel) - int64(gc.Array_array)
+ nodr.Type = nodl.Type
+ }
+
+ gmove(&nodr, &nodl)
+
+ goto yes
+
+ case gc.TSTRUCT:
+ if nl.Op == gc.ONAME {
+ gc.Gvardef(nl)
+ }
+ loffset = nodl.Xoffset
+ roffset = nodr.Xoffset
+
+ // funarg structs may not begin at offset zero.
+ if nl.Type.Etype == gc.TSTRUCT && nl.Type.Funarg != 0 && nl.Type.Type != nil {
+ loffset -= nl.Type.Type.Width
+ }
+ if nr != nil && nr.Type.Etype == gc.TSTRUCT && nr.Type.Funarg != 0 && nr.Type.Type != nil {
+ roffset -= nr.Type.Type.Width
+ }
+
+ for t = nl.Type.Type; t != nil; t = t.Down {
+ nodl.Xoffset = loffset + t.Width
+ nodl.Type = t.Type
+
+ if nr == nil {
+ gc.Clearslim(&nodl)
+ } else {
+ nodr.Xoffset = roffset + t.Width
+ nodr.Type = nodl.Type
+ gmove(&nodr, &nodl)
+ }
+ }
+
+ goto yes
+ }
+
+no:
+ if freer != 0 {
+ regfree(&nodr)
+ }
+ if freel != 0 {
+ regfree(&nodl)
+ }
+ return 0
+
+yes:
+ if freer != 0 {
+ regfree(&nodr)
+ }
+ if freel != 0 {
+ regfree(&nodl)
+ }
+ return 1
+}
--- /dev/null
+// 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 main
+
+import (
+ "cmd/internal/obj"
+ "cmd/internal/obj/arm"
+)
+import "cmd/internal/gc"
+
+/*
+ * attempt to generate 64-bit
+ * res = n
+ * return 1 on success, 0 if op not handled.
+ */
+func cgen64(n *gc.Node, res *gc.Node) {
+ var t1 gc.Node
+ var t2 gc.Node
+ var l *gc.Node
+ var r *gc.Node
+ var lo1 gc.Node
+ var lo2 gc.Node
+ var hi1 gc.Node
+ var hi2 gc.Node
+ var al gc.Node
+ var ah gc.Node
+ var bl gc.Node
+ var bh gc.Node
+ var cl gc.Node
+ var ch gc.Node
+ var s gc.Node
+ var n1 gc.Node
+ var creg gc.Node
+ var p1 *obj.Prog
+ var p2 *obj.Prog
+ var p3 *obj.Prog
+ var p4 *obj.Prog
+ var p5 *obj.Prog
+ var p6 *obj.Prog
+ var v uint64
+
+ if res.Op != gc.OINDREG && res.Op != gc.ONAME {
+ gc.Dump("n", n)
+ gc.Dump("res", res)
+ gc.Fatal("cgen64 %v of %v", gc.Oconv(int(n.Op), 0), gc.Oconv(int(res.Op), 0))
+ }
+
+ l = n.Left
+ if !(l.Addable != 0) {
+ gc.Tempname(&t1, l.Type)
+ cgen(l, &t1)
+ l = &t1
+ }
+
+ split64(l, &lo1, &hi1)
+ switch n.Op {
+ default:
+ gc.Fatal("cgen64 %v", gc.Oconv(int(n.Op), 0))
+ fallthrough
+
+ case gc.OMINUS:
+ split64(res, &lo2, &hi2)
+
+ regalloc(&t1, lo1.Type, nil)
+ regalloc(&al, lo1.Type, nil)
+ regalloc(&ah, hi1.Type, nil)
+
+ gins(arm.AMOVW, &lo1, &al)
+ gins(arm.AMOVW, &hi1, &ah)
+
+ gmove(ncon(0), &t1)
+ p1 = gins(arm.ASUB, &al, &t1)
+ p1.Scond |= arm.C_SBIT
+ gins(arm.AMOVW, &t1, &lo2)
+
+ gmove(ncon(0), &t1)
+ gins(arm.ASBC, &ah, &t1)
+ gins(arm.AMOVW, &t1, &hi2)
+
+ regfree(&t1)
+ regfree(&al)
+ regfree(&ah)
+ splitclean()
+ splitclean()
+ return
+
+ case gc.OCOM:
+ regalloc(&t1, lo1.Type, nil)
+ gmove(ncon(^uint32(0)), &t1)
+
+ split64(res, &lo2, &hi2)
+ regalloc(&n1, lo1.Type, nil)
+
+ gins(arm.AMOVW, &lo1, &n1)
+ gins(arm.AEOR, &t1, &n1)
+ gins(arm.AMOVW, &n1, &lo2)
+
+ gins(arm.AMOVW, &hi1, &n1)
+ gins(arm.AEOR, &t1, &n1)
+ gins(arm.AMOVW, &n1, &hi2)
+
+ regfree(&t1)
+ regfree(&n1)
+ splitclean()
+ splitclean()
+ return
+
+ // binary operators.
+ // common setup below.
+ case gc.OADD,
+ gc.OSUB,
+ gc.OMUL,
+ gc.OLSH,
+ gc.ORSH,
+ gc.OAND,
+ gc.OOR,
+ gc.OXOR,
+ gc.OLROT:
+ break
+ }
+
+ // setup for binary operators
+ r = n.Right
+
+ if r != nil && !(r.Addable != 0) {
+ gc.Tempname(&t2, r.Type)
+ cgen(r, &t2)
+ r = &t2
+ }
+
+ if gc.Is64(r.Type) != 0 {
+ split64(r, &lo2, &hi2)
+ }
+
+ regalloc(&al, lo1.Type, nil)
+ regalloc(&ah, hi1.Type, nil)
+
+ // Do op. Leave result in ah:al.
+ switch n.Op {
+ default:
+ gc.Fatal("cgen64: not implemented: %v\n", gc.Nconv(n, 0))
+ fallthrough
+
+ // TODO: Constants
+ case gc.OADD:
+ regalloc(&bl, gc.Types[gc.TPTR32], nil)
+
+ regalloc(&bh, gc.Types[gc.TPTR32], nil)
+ gins(arm.AMOVW, &hi1, &ah)
+ gins(arm.AMOVW, &lo1, &al)
+ gins(arm.AMOVW, &hi2, &bh)
+ gins(arm.AMOVW, &lo2, &bl)
+ p1 = gins(arm.AADD, &bl, &al)
+ p1.Scond |= arm.C_SBIT
+ gins(arm.AADC, &bh, &ah)
+ regfree(&bl)
+ regfree(&bh)
+
+ // TODO: Constants.
+ case gc.OSUB:
+ regalloc(&bl, gc.Types[gc.TPTR32], nil)
+
+ regalloc(&bh, gc.Types[gc.TPTR32], nil)
+ gins(arm.AMOVW, &lo1, &al)
+ gins(arm.AMOVW, &hi1, &ah)
+ gins(arm.AMOVW, &lo2, &bl)
+ gins(arm.AMOVW, &hi2, &bh)
+ p1 = gins(arm.ASUB, &bl, &al)
+ p1.Scond |= arm.C_SBIT
+ gins(arm.ASBC, &bh, &ah)
+ regfree(&bl)
+ regfree(&bh)
+
+ // TODO(kaib): this can be done with 4 regs and does not need 6
+ case gc.OMUL:
+ regalloc(&bl, gc.Types[gc.TPTR32], nil)
+
+ regalloc(&bh, gc.Types[gc.TPTR32], nil)
+ regalloc(&cl, gc.Types[gc.TPTR32], nil)
+ regalloc(&ch, gc.Types[gc.TPTR32], nil)
+
+ // load args into bh:bl and bh:bl.
+ gins(arm.AMOVW, &hi1, &bh)
+
+ gins(arm.AMOVW, &lo1, &bl)
+ gins(arm.AMOVW, &hi2, &ch)
+ gins(arm.AMOVW, &lo2, &cl)
+
+ // bl * cl -> ah al
+ p1 = gins(arm.AMULLU, nil, nil)
+
+ p1.From.Type = obj.TYPE_REG
+ p1.From.Reg = bl.Val.U.Reg
+ p1.Reg = cl.Val.U.Reg
+ p1.To.Type = obj.TYPE_REGREG
+ p1.To.Reg = ah.Val.U.Reg
+ p1.To.Offset = int64(al.Val.U.Reg)
+
+ //print("%P\n", p1);
+
+ // bl * ch + ah -> ah
+ p1 = gins(arm.AMULA, nil, nil)
+
+ p1.From.Type = obj.TYPE_REG
+ p1.From.Reg = bl.Val.U.Reg
+ p1.Reg = ch.Val.U.Reg
+ p1.To.Type = obj.TYPE_REGREG2
+ p1.To.Reg = ah.Val.U.Reg
+ p1.To.Offset = int64(ah.Val.U.Reg)
+
+ //print("%P\n", p1);
+
+ // bh * cl + ah -> ah
+ p1 = gins(arm.AMULA, nil, nil)
+
+ p1.From.Type = obj.TYPE_REG
+ p1.From.Reg = bh.Val.U.Reg
+ p1.Reg = cl.Val.U.Reg
+ p1.To.Type = obj.TYPE_REGREG2
+ p1.To.Reg = ah.Val.U.Reg
+ p1.To.Offset = int64(ah.Val.U.Reg)
+
+ //print("%P\n", p1);
+
+ regfree(&bh)
+
+ regfree(&bl)
+ regfree(&ch)
+ regfree(&cl)
+
+ // We only rotate by a constant c in [0,64).
+ // if c >= 32:
+ // lo, hi = hi, lo
+ // c -= 32
+ // if c == 0:
+ // no-op
+ // else:
+ // t = hi
+ // shld hi:lo, c
+ // shld lo:t, c
+ case gc.OLROT:
+ v = uint64(gc.Mpgetfix(r.Val.U.Xval))
+
+ regalloc(&bl, lo1.Type, nil)
+ regalloc(&bh, hi1.Type, nil)
+ if v >= 32 {
+ // reverse during load to do the first 32 bits of rotate
+ v -= 32
+
+ gins(arm.AMOVW, &hi1, &bl)
+ gins(arm.AMOVW, &lo1, &bh)
+ } else {
+ gins(arm.AMOVW, &hi1, &bh)
+ gins(arm.AMOVW, &lo1, &bl)
+ }
+
+ if v == 0 {
+ gins(arm.AMOVW, &bh, &ah)
+ gins(arm.AMOVW, &bl, &al)
+ } else {
+ // rotate by 1 <= v <= 31
+ // MOVW bl<<v, al
+ // MOVW bh<<v, ah
+ // OR bl>>(32-v), ah
+ // OR bh>>(32-v), al
+ gshift(arm.AMOVW, &bl, arm.SHIFT_LL, int32(v), &al)
+
+ gshift(arm.AMOVW, &bh, arm.SHIFT_LL, int32(v), &ah)
+ gshift(arm.AORR, &bl, arm.SHIFT_LR, int32(32-v), &ah)
+ gshift(arm.AORR, &bh, arm.SHIFT_LR, int32(32-v), &al)
+ }
+
+ regfree(&bl)
+ regfree(&bh)
+
+ case gc.OLSH:
+ regalloc(&bl, lo1.Type, nil)
+ regalloc(&bh, hi1.Type, nil)
+ gins(arm.AMOVW, &hi1, &bh)
+ gins(arm.AMOVW, &lo1, &bl)
+
+ if r.Op == gc.OLITERAL {
+ v = uint64(gc.Mpgetfix(r.Val.U.Xval))
+ if v >= 64 {
+ // TODO(kaib): replace with gins(AMOVW, nodintconst(0), &al)
+ // here and below (verify it optimizes to EOR)
+ gins(arm.AEOR, &al, &al)
+
+ gins(arm.AEOR, &ah, &ah)
+ } else if v > 32 {
+ gins(arm.AEOR, &al, &al)
+
+ // MOVW bl<<(v-32), ah
+ gshift(arm.AMOVW, &bl, arm.SHIFT_LL, int32(v-32), &ah)
+ } else if v == 32 {
+ gins(arm.AEOR, &al, &al)
+ gins(arm.AMOVW, &bl, &ah)
+ } else if v > 0 {
+ // MOVW bl<<v, al
+ gshift(arm.AMOVW, &bl, arm.SHIFT_LL, int32(v), &al)
+
+ // MOVW bh<<v, ah
+ gshift(arm.AMOVW, &bh, arm.SHIFT_LL, int32(v), &ah)
+
+ // OR bl>>(32-v), ah
+ gshift(arm.AORR, &bl, arm.SHIFT_LR, int32(32-v), &ah)
+ } else {
+ gins(arm.AMOVW, &bl, &al)
+ gins(arm.AMOVW, &bh, &ah)
+ }
+
+ goto olsh_break
+ }
+
+ regalloc(&s, gc.Types[gc.TUINT32], nil)
+ regalloc(&creg, gc.Types[gc.TUINT32], nil)
+ if gc.Is64(r.Type) != 0 {
+ // shift is >= 1<<32
+ split64(r, &cl, &ch)
+
+ gmove(&ch, &s)
+ gins(arm.ATST, &s, nil)
+ p6 = gc.Gbranch(arm.ABNE, nil, 0)
+ gmove(&cl, &s)
+ splitclean()
+ } else {
+ gmove(r, &s)
+ p6 = nil
+ }
+
+ gins(arm.ATST, &s, nil)
+
+ // shift == 0
+ p1 = gins(arm.AMOVW, &bl, &al)
+
+ p1.Scond = arm.C_SCOND_EQ
+ p1 = gins(arm.AMOVW, &bh, &ah)
+ p1.Scond = arm.C_SCOND_EQ
+ p2 = gc.Gbranch(arm.ABEQ, nil, 0)
+
+ // shift is < 32
+ gc.Nodconst(&n1, gc.Types[gc.TUINT32], 32)
+
+ gmove(&n1, &creg)
+ gcmp(arm.ACMP, &s, &creg)
+
+ // MOVW.LO bl<<s, al
+ p1 = gregshift(arm.AMOVW, &bl, arm.SHIFT_LL, &s, &al)
+
+ p1.Scond = arm.C_SCOND_LO
+
+ // MOVW.LO bh<<s, ah
+ p1 = gregshift(arm.AMOVW, &bh, arm.SHIFT_LL, &s, &ah)
+
+ p1.Scond = arm.C_SCOND_LO
+
+ // SUB.LO s, creg
+ p1 = gins(arm.ASUB, &s, &creg)
+
+ p1.Scond = arm.C_SCOND_LO
+
+ // OR.LO bl>>creg, ah
+ p1 = gregshift(arm.AORR, &bl, arm.SHIFT_LR, &creg, &ah)
+
+ p1.Scond = arm.C_SCOND_LO
+
+ // BLO end
+ p3 = gc.Gbranch(arm.ABLO, nil, 0)
+
+ // shift == 32
+ p1 = gins(arm.AEOR, &al, &al)
+
+ p1.Scond = arm.C_SCOND_EQ
+ p1 = gins(arm.AMOVW, &bl, &ah)
+ p1.Scond = arm.C_SCOND_EQ
+ p4 = gc.Gbranch(arm.ABEQ, nil, 0)
+
+ // shift is < 64
+ gc.Nodconst(&n1, gc.Types[gc.TUINT32], 64)
+
+ gmove(&n1, &creg)
+ gcmp(arm.ACMP, &s, &creg)
+
+ // EOR.LO al, al
+ p1 = gins(arm.AEOR, &al, &al)
+
+ p1.Scond = arm.C_SCOND_LO
+
+ // MOVW.LO creg>>1, creg
+ p1 = gshift(arm.AMOVW, &creg, arm.SHIFT_LR, 1, &creg)
+
+ p1.Scond = arm.C_SCOND_LO
+
+ // SUB.LO creg, s
+ p1 = gins(arm.ASUB, &creg, &s)
+
+ p1.Scond = arm.C_SCOND_LO
+
+ // MOVW bl<<s, ah
+ p1 = gregshift(arm.AMOVW, &bl, arm.SHIFT_LL, &s, &ah)
+
+ p1.Scond = arm.C_SCOND_LO
+
+ p5 = gc.Gbranch(arm.ABLO, nil, 0)
+
+ // shift >= 64
+ if p6 != nil {
+ gc.Patch(p6, gc.Pc)
+ }
+ gins(arm.AEOR, &al, &al)
+ gins(arm.AEOR, &ah, &ah)
+
+ gc.Patch(p2, gc.Pc)
+ gc.Patch(p3, gc.Pc)
+ gc.Patch(p4, gc.Pc)
+ gc.Patch(p5, gc.Pc)
+ regfree(&s)
+ regfree(&creg)
+
+ olsh_break:
+ regfree(&bl)
+ regfree(&bh)
+
+ case gc.ORSH:
+ regalloc(&bl, lo1.Type, nil)
+ regalloc(&bh, hi1.Type, nil)
+ gins(arm.AMOVW, &hi1, &bh)
+ gins(arm.AMOVW, &lo1, &bl)
+
+ if r.Op == gc.OLITERAL {
+ v = uint64(gc.Mpgetfix(r.Val.U.Xval))
+ if v >= 64 {
+ if bh.Type.Etype == gc.TINT32 {
+ // MOVW bh->31, al
+ gshift(arm.AMOVW, &bh, arm.SHIFT_AR, 31, &al)
+
+ // MOVW bh->31, ah
+ gshift(arm.AMOVW, &bh, arm.SHIFT_AR, 31, &ah)
+ } else {
+ gins(arm.AEOR, &al, &al)
+ gins(arm.AEOR, &ah, &ah)
+ }
+ } else if v > 32 {
+ if bh.Type.Etype == gc.TINT32 {
+ // MOVW bh->(v-32), al
+ gshift(arm.AMOVW, &bh, arm.SHIFT_AR, int32(v-32), &al)
+
+ // MOVW bh->31, ah
+ gshift(arm.AMOVW, &bh, arm.SHIFT_AR, 31, &ah)
+ } else {
+ // MOVW bh>>(v-32), al
+ gshift(arm.AMOVW, &bh, arm.SHIFT_LR, int32(v-32), &al)
+
+ gins(arm.AEOR, &ah, &ah)
+ }
+ } else if v == 32 {
+ gins(arm.AMOVW, &bh, &al)
+ if bh.Type.Etype == gc.TINT32 {
+ // MOVW bh->31, ah
+ gshift(arm.AMOVW, &bh, arm.SHIFT_AR, 31, &ah)
+ } else {
+ gins(arm.AEOR, &ah, &ah)
+ }
+ } else if v > 0 {
+ // MOVW bl>>v, al
+ gshift(arm.AMOVW, &bl, arm.SHIFT_LR, int32(v), &al)
+
+ // OR bh<<(32-v), al
+ gshift(arm.AORR, &bh, arm.SHIFT_LL, int32(32-v), &al)
+
+ if bh.Type.Etype == gc.TINT32 {
+ // MOVW bh->v, ah
+ gshift(arm.AMOVW, &bh, arm.SHIFT_AR, int32(v), &ah)
+ } else {
+ // MOVW bh>>v, ah
+ gshift(arm.AMOVW, &bh, arm.SHIFT_LR, int32(v), &ah)
+ }
+ } else {
+ gins(arm.AMOVW, &bl, &al)
+ gins(arm.AMOVW, &bh, &ah)
+ }
+
+ goto orsh_break
+ }
+
+ regalloc(&s, gc.Types[gc.TUINT32], nil)
+ regalloc(&creg, gc.Types[gc.TUINT32], nil)
+ if gc.Is64(r.Type) != 0 {
+ // shift is >= 1<<32
+ split64(r, &cl, &ch)
+
+ gmove(&ch, &s)
+ gins(arm.ATST, &s, nil)
+ if bh.Type.Etype == gc.TINT32 {
+ p1 = gshift(arm.AMOVW, &bh, arm.SHIFT_AR, 31, &ah)
+ } else {
+ p1 = gins(arm.AEOR, &ah, &ah)
+ }
+ p1.Scond = arm.C_SCOND_NE
+ p6 = gc.Gbranch(arm.ABNE, nil, 0)
+ gmove(&cl, &s)
+ splitclean()
+ } else {
+ gmove(r, &s)
+ p6 = nil
+ }
+
+ gins(arm.ATST, &s, nil)
+
+ // shift == 0
+ p1 = gins(arm.AMOVW, &bl, &al)
+
+ p1.Scond = arm.C_SCOND_EQ
+ p1 = gins(arm.AMOVW, &bh, &ah)
+ p1.Scond = arm.C_SCOND_EQ
+ p2 = gc.Gbranch(arm.ABEQ, nil, 0)
+
+ // check if shift is < 32
+ gc.Nodconst(&n1, gc.Types[gc.TUINT32], 32)
+
+ gmove(&n1, &creg)
+ gcmp(arm.ACMP, &s, &creg)
+
+ // MOVW.LO bl>>s, al
+ p1 = gregshift(arm.AMOVW, &bl, arm.SHIFT_LR, &s, &al)
+
+ p1.Scond = arm.C_SCOND_LO
+
+ // SUB.LO s,creg
+ p1 = gins(arm.ASUB, &s, &creg)
+
+ p1.Scond = arm.C_SCOND_LO
+
+ // OR.LO bh<<(32-s), al
+ p1 = gregshift(arm.AORR, &bh, arm.SHIFT_LL, &creg, &al)
+
+ p1.Scond = arm.C_SCOND_LO
+
+ if bh.Type.Etype == gc.TINT32 {
+ // MOVW bh->s, ah
+ p1 = gregshift(arm.AMOVW, &bh, arm.SHIFT_AR, &s, &ah)
+ } else {
+ // MOVW bh>>s, ah
+ p1 = gregshift(arm.AMOVW, &bh, arm.SHIFT_LR, &s, &ah)
+ }
+
+ p1.Scond = arm.C_SCOND_LO
+
+ // BLO end
+ p3 = gc.Gbranch(arm.ABLO, nil, 0)
+
+ // shift == 32
+ p1 = gins(arm.AMOVW, &bh, &al)
+
+ p1.Scond = arm.C_SCOND_EQ
+ if bh.Type.Etype == gc.TINT32 {
+ gshift(arm.AMOVW, &bh, arm.SHIFT_AR, 31, &ah)
+ } else {
+ gins(arm.AEOR, &ah, &ah)
+ }
+ p4 = gc.Gbranch(arm.ABEQ, nil, 0)
+
+ // check if shift is < 64
+ gc.Nodconst(&n1, gc.Types[gc.TUINT32], 64)
+
+ gmove(&n1, &creg)
+ gcmp(arm.ACMP, &s, &creg)
+
+ // MOVW.LO creg>>1, creg
+ p1 = gshift(arm.AMOVW, &creg, arm.SHIFT_LR, 1, &creg)
+
+ p1.Scond = arm.C_SCOND_LO
+
+ // SUB.LO creg, s
+ p1 = gins(arm.ASUB, &creg, &s)
+
+ p1.Scond = arm.C_SCOND_LO
+
+ if bh.Type.Etype == gc.TINT32 {
+ // MOVW bh->(s-32), al
+ p1 = gregshift(arm.AMOVW, &bh, arm.SHIFT_AR, &s, &al)
+
+ p1.Scond = arm.C_SCOND_LO
+ } else {
+ // MOVW bh>>(v-32), al
+ p1 = gregshift(arm.AMOVW, &bh, arm.SHIFT_LR, &s, &al)
+
+ p1.Scond = arm.C_SCOND_LO
+ }
+
+ // BLO end
+ p5 = gc.Gbranch(arm.ABLO, nil, 0)
+
+ // s >= 64
+ if p6 != nil {
+ gc.Patch(p6, gc.Pc)
+ }
+ if bh.Type.Etype == gc.TINT32 {
+ // MOVW bh->31, al
+ gshift(arm.AMOVW, &bh, arm.SHIFT_AR, 31, &al)
+ } else {
+ gins(arm.AEOR, &al, &al)
+ }
+
+ gc.Patch(p2, gc.Pc)
+ gc.Patch(p3, gc.Pc)
+ gc.Patch(p4, gc.Pc)
+ gc.Patch(p5, gc.Pc)
+ regfree(&s)
+ regfree(&creg)
+
+ orsh_break:
+ regfree(&bl)
+ regfree(&bh)
+
+ // TODO(kaib): literal optimizations
+ // make constant the right side (it usually is anyway).
+ // if(lo1.op == OLITERAL) {
+ // nswap(&lo1, &lo2);
+ // nswap(&hi1, &hi2);
+ // }
+ // if(lo2.op == OLITERAL) {
+ // // special cases for constants.
+ // lv = mpgetfix(lo2.val.u.xval);
+ // hv = mpgetfix(hi2.val.u.xval);
+ // splitclean(); // right side
+ // split64(res, &lo2, &hi2);
+ // switch(n->op) {
+ // case OXOR:
+ // gmove(&lo1, &lo2);
+ // gmove(&hi1, &hi2);
+ // switch(lv) {
+ // case 0:
+ // break;
+ // case 0xffffffffu:
+ // gins(ANOTL, N, &lo2);
+ // break;
+ // default:
+ // gins(AXORL, ncon(lv), &lo2);
+ // break;
+ // }
+ // switch(hv) {
+ // case 0:
+ // break;
+ // case 0xffffffffu:
+ // gins(ANOTL, N, &hi2);
+ // break;
+ // default:
+ // gins(AXORL, ncon(hv), &hi2);
+ // break;
+ // }
+ // break;
+
+ // case OAND:
+ // switch(lv) {
+ // case 0:
+ // gins(AMOVL, ncon(0), &lo2);
+ // break;
+ // default:
+ // gmove(&lo1, &lo2);
+ // if(lv != 0xffffffffu)
+ // gins(AANDL, ncon(lv), &lo2);
+ // break;
+ // }
+ // switch(hv) {
+ // case 0:
+ // gins(AMOVL, ncon(0), &hi2);
+ // break;
+ // default:
+ // gmove(&hi1, &hi2);
+ // if(hv != 0xffffffffu)
+ // gins(AANDL, ncon(hv), &hi2);
+ // break;
+ // }
+ // break;
+
+ // case OOR:
+ // switch(lv) {
+ // case 0:
+ // gmove(&lo1, &lo2);
+ // break;
+ // case 0xffffffffu:
+ // gins(AMOVL, ncon(0xffffffffu), &lo2);
+ // break;
+ // default:
+ // gmove(&lo1, &lo2);
+ // gins(AORL, ncon(lv), &lo2);
+ // break;
+ // }
+ // switch(hv) {
+ // case 0:
+ // gmove(&hi1, &hi2);
+ // break;
+ // case 0xffffffffu:
+ // gins(AMOVL, ncon(0xffffffffu), &hi2);
+ // break;
+ // default:
+ // gmove(&hi1, &hi2);
+ // gins(AORL, ncon(hv), &hi2);
+ // break;
+ // }
+ // break;
+ // }
+ // splitclean();
+ // splitclean();
+ // goto out;
+ // }
+ case gc.OXOR,
+ gc.OAND,
+ gc.OOR:
+ regalloc(&n1, lo1.Type, nil)
+
+ gins(arm.AMOVW, &lo1, &al)
+ gins(arm.AMOVW, &hi1, &ah)
+ gins(arm.AMOVW, &lo2, &n1)
+ gins(optoas(int(n.Op), lo1.Type), &n1, &al)
+ gins(arm.AMOVW, &hi2, &n1)
+ gins(optoas(int(n.Op), lo1.Type), &n1, &ah)
+ regfree(&n1)
+ }
+
+ if gc.Is64(r.Type) != 0 {
+ splitclean()
+ }
+ splitclean()
+
+ split64(res, &lo1, &hi1)
+ gins(arm.AMOVW, &al, &lo1)
+ gins(arm.AMOVW, &ah, &hi1)
+ splitclean()
+
+ //out:
+ regfree(&al)
+
+ regfree(&ah)
+}
+
+/*
+ * generate comparison of nl, nr, both 64-bit.
+ * nl is memory; nr is constant or memory.
+ */
+func cmp64(nl *gc.Node, nr *gc.Node, op int, likely int, to *obj.Prog) {
+ var lo1 gc.Node
+ var hi1 gc.Node
+ var lo2 gc.Node
+ var hi2 gc.Node
+ var r1 gc.Node
+ var r2 gc.Node
+ var br *obj.Prog
+ var t *gc.Type
+
+ split64(nl, &lo1, &hi1)
+ split64(nr, &lo2, &hi2)
+
+ // compare most significant word;
+ // if they differ, we're done.
+ t = hi1.Type
+
+ regalloc(&r1, gc.Types[gc.TINT32], nil)
+ regalloc(&r2, gc.Types[gc.TINT32], nil)
+ gins(arm.AMOVW, &hi1, &r1)
+ gins(arm.AMOVW, &hi2, &r2)
+ gcmp(arm.ACMP, &r1, &r2)
+ regfree(&r1)
+ regfree(&r2)
+
+ br = nil
+ switch op {
+ default:
+ gc.Fatal("cmp64 %v %v", gc.Oconv(int(op), 0), gc.Tconv(t, 0))
+ fallthrough
+
+ // cmp hi
+ // bne L
+ // cmp lo
+ // beq to
+ // L:
+ case gc.OEQ:
+ br = gc.Gbranch(arm.ABNE, nil, -likely)
+
+ // cmp hi
+ // bne to
+ // cmp lo
+ // bne to
+ case gc.ONE:
+ gc.Patch(gc.Gbranch(arm.ABNE, nil, likely), to)
+
+ // cmp hi
+ // bgt to
+ // blt L
+ // cmp lo
+ // bge to (or bgt to)
+ // L:
+ case gc.OGE,
+ gc.OGT:
+ gc.Patch(gc.Gbranch(optoas(gc.OGT, t), nil, likely), to)
+
+ br = gc.Gbranch(optoas(gc.OLT, t), nil, -likely)
+
+ // cmp hi
+ // blt to
+ // bgt L
+ // cmp lo
+ // ble to (or jlt to)
+ // L:
+ case gc.OLE,
+ gc.OLT:
+ gc.Patch(gc.Gbranch(optoas(gc.OLT, t), nil, likely), to)
+
+ br = gc.Gbranch(optoas(gc.OGT, t), nil, -likely)
+ }
+
+ // compare least significant word
+ t = lo1.Type
+
+ regalloc(&r1, gc.Types[gc.TINT32], nil)
+ regalloc(&r2, gc.Types[gc.TINT32], nil)
+ gins(arm.AMOVW, &lo1, &r1)
+ gins(arm.AMOVW, &lo2, &r2)
+ gcmp(arm.ACMP, &r1, &r2)
+ regfree(&r1)
+ regfree(&r2)
+
+ // jump again
+ gc.Patch(gc.Gbranch(optoas(op, t), nil, likely), to)
+
+ // point first branch down here if appropriate
+ if br != nil {
+ gc.Patch(br, gc.Pc)
+ }
+
+ splitclean()
+ splitclean()
+}
--- /dev/null
+// 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 main
+
+import (
+ "cmd/internal/obj"
+ "cmd/internal/obj/arm"
+)
+import "cmd/internal/gc"
+
+var thechar int = '5'
+
+var thestring string = "arm"
+
+var thelinkarch *obj.LinkArch = &arm.Linkarm
+
+func linkarchinit() {
+}
+
+var MAXWIDTH int64 = (1 << 32) - 1
+
+/*
+ * go declares several platform-specific type aliases:
+ * int, uint, float, and uintptr
+ */
+var typedefs = []gc.Typedef{
+ gc.Typedef{"int", gc.TINT, gc.TINT32},
+ gc.Typedef{"uint", gc.TUINT, gc.TUINT32},
+ gc.Typedef{"uintptr", gc.TUINTPTR, gc.TUINT32},
+}
+
+func betypeinit() {
+ gc.Widthptr = 4
+ gc.Widthint = 4
+ gc.Widthreg = 4
+
+}
+
+func main() {
+ gc.Thearch.Thechar = thechar
+ gc.Thearch.Thestring = thestring
+ gc.Thearch.Thelinkarch = thelinkarch
+ gc.Thearch.Typedefs = typedefs
+ gc.Thearch.REGSP = arm.REGSP
+ gc.Thearch.REGCTXT = arm.REGCTXT
+ gc.Thearch.MAXWIDTH = MAXWIDTH
+ gc.Thearch.Anyregalloc = anyregalloc
+ gc.Thearch.Betypeinit = betypeinit
+ gc.Thearch.Bgen = bgen
+ gc.Thearch.Cgen = cgen
+ gc.Thearch.Cgen_call = cgen_call
+ gc.Thearch.Cgen_callinter = cgen_callinter
+ gc.Thearch.Cgen_ret = cgen_ret
+ gc.Thearch.Clearfat = clearfat
+ gc.Thearch.Defframe = defframe
+ gc.Thearch.Excise = excise
+ gc.Thearch.Expandchecks = expandchecks
+ gc.Thearch.Gclean = gclean
+ gc.Thearch.Ginit = ginit
+ gc.Thearch.Gins = gins
+ gc.Thearch.Ginscall = ginscall
+ gc.Thearch.Igen = igen
+ gc.Thearch.Linkarchinit = linkarchinit
+ gc.Thearch.Peep = peep
+ gc.Thearch.Proginfo = proginfo
+ gc.Thearch.Regalloc = regalloc
+ gc.Thearch.Regfree = regfree
+ gc.Thearch.Regtyp = regtyp
+ gc.Thearch.Sameaddr = sameaddr
+ gc.Thearch.Smallindir = smallindir
+ gc.Thearch.Stackaddr = stackaddr
+ gc.Thearch.Excludedregs = excludedregs
+ gc.Thearch.RtoB = RtoB
+ gc.Thearch.FtoB = RtoB
+ gc.Thearch.BtoR = BtoR
+ gc.Thearch.BtoF = BtoF
+ gc.Thearch.Optoas = optoas
+ gc.Thearch.Doregbits = doregbits
+ gc.Thearch.Regnames = regnames
+
+ gc.Main()
+}
--- /dev/null
+// 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 main
+
+import "cmd/internal/obj/arm"
+
+// 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.
+
+const (
+ REGALLOC_R0 = arm.REG_R0
+ REGALLOC_RMAX = arm.REGEXT
+ REGALLOC_F0 = arm.REG_F0
+ REGALLOC_FMAX = arm.FREGEXT
+)
+
+var reg [REGALLOC_FMAX + 1]uint8
+
+/*
+ * cgen
+ */
+
+/*
+ * list.c
+ */
+
+/*
+ * reg.c
+ */
--- /dev/null
+// 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 main
+
+import (
+ "cmd/internal/obj"
+ "cmd/internal/obj/arm"
+)
+import "cmd/internal/gc"
+
+func defframe(ptxt *obj.Prog) {
+ var frame uint32
+ var r0 uint32
+ var p *obj.Prog
+ var hi int64
+ var lo int64
+ var l *gc.NodeList
+ var n *gc.Node
+
+ // fill in argument size, stack size
+ ptxt.To.Type = obj.TYPE_TEXTSIZE
+
+ ptxt.To.U.Argsize = int32(gc.Rnd(gc.Curfn.Type.Argwid, int64(gc.Widthptr)))
+ frame = uint32(gc.Rnd(gc.Stksize+gc.Maxarg, int64(gc.Widthreg)))
+ ptxt.To.Offset = int64(frame)
+
+ // insert code to contain ambiguously live variables
+ // so that garbage collector only sees initialized values
+ // when it looks for pointers.
+ p = ptxt
+
+ hi = 0
+ lo = hi
+ r0 = 0
+ for l = gc.Curfn.Dcl; l != nil; l = l.Next {
+ n = l.N
+ if !(n.Needzero != 0) {
+ continue
+ }
+ if n.Class != gc.PAUTO {
+ gc.Fatal("needzero class %d", n.Class)
+ }
+ if n.Type.Width%int64(gc.Widthptr) != 0 || n.Xoffset%int64(gc.Widthptr) != 0 || n.Type.Width == 0 {
+ gc.Fatal("var %v has size %d offset %d", gc.Nconv(n, obj.FmtLong), int(n.Type.Width), int(n.Xoffset))
+ }
+ if lo != hi && n.Xoffset+n.Type.Width >= lo-int64(2*gc.Widthptr) {
+ // merge with range we already have
+ lo = gc.Rnd(n.Xoffset, int64(gc.Widthptr))
+
+ continue
+ }
+
+ // zero old range
+ p = zerorange(p, int64(frame), lo, hi, &r0)
+
+ // set new range
+ hi = n.Xoffset + n.Type.Width
+
+ lo = n.Xoffset
+ }
+
+ // zero final range
+ zerorange(p, int64(frame), lo, hi, &r0)
+}
+
+func zerorange(p *obj.Prog, frame int64, lo int64, hi int64, r0 *uint32) *obj.Prog {
+ var cnt int64
+ var i int64
+ var p1 *obj.Prog
+ var f *gc.Node
+
+ cnt = hi - lo
+ if cnt == 0 {
+ return p
+ }
+ if *r0 == 0 {
+ p = appendpp(p, arm.AMOVW, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, arm.REG_R0, 0)
+ *r0 = 1
+ }
+
+ if cnt < int64(4*gc.Widthptr) {
+ for i = 0; i < cnt; i += int64(gc.Widthptr) {
+ p = appendpp(p, arm.AMOVW, obj.TYPE_REG, arm.REG_R0, 0, obj.TYPE_MEM, arm.REGSP, int32(4+frame+lo+i))
+ }
+ } else if !gc.Nacl && (cnt <= int64(128*gc.Widthptr)) {
+ p = appendpp(p, arm.AADD, obj.TYPE_CONST, 0, int32(4+frame+lo), obj.TYPE_REG, arm.REG_R1, 0)
+ p.Reg = arm.REGSP
+ p = appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
+ f = gc.Sysfunc("duffzero")
+ gc.Naddr(f, &p.To, 1)
+ gc.Afunclit(&p.To, f)
+ p.To.Offset = 4 * (128 - cnt/int64(gc.Widthptr))
+ } else {
+ p = appendpp(p, arm.AADD, obj.TYPE_CONST, 0, int32(4+frame+lo), obj.TYPE_REG, arm.REG_R1, 0)
+ p.Reg = arm.REGSP
+ p = appendpp(p, arm.AADD, obj.TYPE_CONST, 0, int32(cnt), obj.TYPE_REG, arm.REG_R2, 0)
+ p.Reg = arm.REG_R1
+ p = appendpp(p, arm.AMOVW, obj.TYPE_REG, arm.REG_R0, 0, obj.TYPE_MEM, arm.REG_R1, 4)
+ p1 = p
+ p.Scond |= arm.C_PBIT
+ p = appendpp(p, arm.ACMP, obj.TYPE_REG, arm.REG_R1, 0, obj.TYPE_NONE, 0, 0)
+ p.Reg = arm.REG_R2
+ p = appendpp(p, arm.ABNE, obj.TYPE_NONE, 0, 0, obj.TYPE_BRANCH, 0, 0)
+ gc.Patch(p, p1)
+ }
+
+ return p
+}
+
+func appendpp(p *obj.Prog, as int, ftype int, freg int, foffset int32, ttype int, treg int, toffset int32) *obj.Prog {
+ var q *obj.Prog
+
+ q = gc.Ctxt.NewProg()
+ gc.Clearp(q)
+ q.As = int16(as)
+ q.Lineno = p.Lineno
+ q.From.Type = int16(ftype)
+ q.From.Reg = int16(freg)
+ q.From.Offset = int64(foffset)
+ q.To.Type = int16(ttype)
+ q.To.Reg = int16(treg)
+ q.To.Offset = int64(toffset)
+ q.Link = p.Link
+ p.Link = q
+ return q
+}
+
+/*
+ * generate:
+ * call f
+ * proc=-1 normal call but no return
+ * proc=0 normal call
+ * proc=1 goroutine run in new proc
+ * proc=2 defer call save away stack
+ * proc=3 normal call to C pointer (not Go func value)
+*/
+func ginscall(f *gc.Node, proc int) {
+ var p *obj.Prog
+ var r gc.Node
+ var r1 gc.Node
+ var con gc.Node
+ var extra int32
+
+ if f.Type != nil {
+ extra = 0
+ if proc == 1 || proc == 2 {
+ extra = 2 * int32(gc.Widthptr)
+ }
+ gc.Setmaxarg(f.Type, extra)
+ }
+
+ switch proc {
+ default:
+ gc.Fatal("ginscall: bad proc %d", proc)
+
+ case 0, // normal call
+ -1: // normal call but no return
+ if f.Op == gc.ONAME && f.Class == gc.PFUNC {
+ if f == gc.Deferreturn {
+ // Deferred calls will appear to be returning to
+ // the BL deferreturn(SB) that we are about to emit.
+ // However, the stack trace code will show the line
+ // of the instruction before that return PC.
+ // To avoid that instruction being an unrelated instruction,
+ // insert a NOP so that we will have the right line number.
+ // ARM NOP 0x00000000 is really AND.EQ R0, R0, R0.
+ // Use the latter form because the NOP pseudo-instruction
+ // would be removed by the linker.
+ gc.Nodreg(&r, gc.Types[gc.TINT], arm.REG_R0)
+
+ p = gins(arm.AAND, &r, &r)
+ p.Scond = arm.C_SCOND_EQ
+ }
+
+ p = gins(arm.ABL, nil, f)
+ gc.Afunclit(&p.To, f)
+ if proc == -1 || gc.Noreturn(p) != 0 {
+ gins(obj.AUNDEF, nil, nil)
+ }
+ break
+ }
+
+ gc.Nodreg(&r, gc.Types[gc.Tptr], arm.REG_R7)
+ gc.Nodreg(&r1, gc.Types[gc.Tptr], arm.REG_R1)
+ gmove(f, &r)
+ r.Op = gc.OINDREG
+ gmove(&r, &r1)
+ r.Op = gc.OREGISTER
+ r1.Op = gc.OINDREG
+ gins(arm.ABL, &r, &r1)
+
+ case 3: // normal call of c function pointer
+ gins(arm.ABL, nil, f)
+
+ case 1, // call in new proc (go)
+ 2: // deferred call (defer)
+ regalloc(&r, gc.Types[gc.Tptr], nil)
+
+ gc.Nodconst(&con, gc.Types[gc.TINT32], int64(gc.Argsize(f.Type)))
+ gins(arm.AMOVW, &con, &r)
+ p = gins(arm.AMOVW, &r, nil)
+ p.To.Type = obj.TYPE_MEM
+ p.To.Reg = arm.REGSP
+ p.To.Offset = 4
+
+ gins(arm.AMOVW, f, &r)
+ p = gins(arm.AMOVW, &r, nil)
+ p.To.Type = obj.TYPE_MEM
+ p.To.Reg = arm.REGSP
+ p.To.Offset = 8
+
+ regfree(&r)
+
+ if proc == 1 {
+ ginscall(gc.Newproc, 0)
+ } else {
+ ginscall(gc.Deferproc, 0)
+ }
+
+ if proc == 2 {
+ gc.Nodconst(&con, gc.Types[gc.TINT32], 0)
+ p = gins(arm.ACMP, &con, nil)
+ p.Reg = arm.REG_R0
+ p = gc.Gbranch(arm.ABEQ, nil, +1)
+ cgen_ret(nil)
+ gc.Patch(p, gc.Pc)
+ }
+ }
+}
+
+/*
+ * n is call to interface method.
+ * generate res = n.
+ */
+func cgen_callinter(n *gc.Node, res *gc.Node, proc int) {
+ var r int
+ var i *gc.Node
+ var f *gc.Node
+ var tmpi gc.Node
+ var nodo gc.Node
+ var nodr gc.Node
+ var nodsp gc.Node
+ var p *obj.Prog
+
+ i = n.Left
+ if i.Op != gc.ODOTINTER {
+ gc.Fatal("cgen_callinter: not ODOTINTER %v", gc.Oconv(int(i.Op), 0))
+ }
+
+ f = i.Right // field
+ if f.Op != gc.ONAME {
+ gc.Fatal("cgen_callinter: not ONAME %v", gc.Oconv(int(f.Op), 0))
+ }
+
+ i = i.Left // interface
+
+ // Release res register during genlist and cgen,
+ // which might have their own function calls.
+ r = -1
+
+ if res != nil && (res.Op == gc.OREGISTER || res.Op == gc.OINDREG) {
+ r = int(res.Val.U.Reg)
+ reg[r]--
+ }
+
+ if !(i.Addable != 0) {
+ gc.Tempname(&tmpi, i.Type)
+ cgen(i, &tmpi)
+ i = &tmpi
+ }
+
+ gc.Genlist(n.List) // args
+ if r >= 0 {
+ reg[r]++
+ }
+
+ regalloc(&nodr, gc.Types[gc.Tptr], res)
+ regalloc(&nodo, gc.Types[gc.Tptr], &nodr)
+ nodo.Op = gc.OINDREG
+
+ agen(i, &nodr) // REG = &inter
+
+ gc.Nodindreg(&nodsp, gc.Types[gc.Tptr], arm.REGSP)
+
+ nodsp.Xoffset = int64(gc.Widthptr)
+ if proc != 0 {
+ nodsp.Xoffset += 2 * int64(gc.Widthptr) // leave room for size & fn
+ }
+ nodo.Xoffset += int64(gc.Widthptr)
+ cgen(&nodo, &nodsp) // {4 or 12}(SP) = 4(REG) -- i.data
+
+ nodo.Xoffset -= int64(gc.Widthptr)
+
+ cgen(&nodo, &nodr) // REG = 0(REG) -- i.tab
+ gc.Cgen_checknil(&nodr) // in case offset is huge
+
+ nodo.Xoffset = n.Left.Xoffset + 3*int64(gc.Widthptr) + 8
+
+ if proc == 0 {
+ // plain call: use direct c function pointer - more efficient
+ cgen(&nodo, &nodr) // REG = 20+offset(REG) -- i.tab->fun[f]
+ nodr.Op = gc.OINDREG
+ proc = 3
+ } else {
+ // go/defer. generate go func value.
+ p = gins(arm.AMOVW, &nodo, &nodr)
+
+ p.From.Type = obj.TYPE_ADDR // REG = &(20+offset(REG)) -- i.tab->fun[f]
+ }
+
+ nodr.Type = n.Left.Type
+ ginscall(&nodr, proc)
+
+ regfree(&nodr)
+ regfree(&nodo)
+}
+
+/*
+ * generate function call;
+ * proc=0 normal call
+ * proc=1 goroutine run in new proc
+ * proc=2 defer call save away stack
+ */
+func cgen_call(n *gc.Node, proc int) {
+ var t *gc.Type
+ var nod gc.Node
+ var afun gc.Node
+
+ if n == nil {
+ return
+ }
+
+ if n.Left.Ullman >= gc.UINF {
+ // if name involves a fn call
+ // precompute the address of the fn
+ gc.Tempname(&afun, gc.Types[gc.Tptr])
+
+ cgen(n.Left, &afun)
+ }
+
+ gc.Genlist(n.List) // assign the args
+ t = n.Left.Type
+
+ // call tempname pointer
+ if n.Left.Ullman >= gc.UINF {
+ regalloc(&nod, gc.Types[gc.Tptr], nil)
+ gc.Cgen_as(&nod, &afun)
+ nod.Type = t
+ ginscall(&nod, proc)
+ regfree(&nod)
+ goto ret
+ }
+
+ // call pointer
+ if n.Left.Op != gc.ONAME || n.Left.Class != gc.PFUNC {
+ regalloc(&nod, gc.Types[gc.Tptr], nil)
+ gc.Cgen_as(&nod, n.Left)
+ nod.Type = t
+ ginscall(&nod, proc)
+ regfree(&nod)
+ goto ret
+ }
+
+ // call direct
+ n.Left.Method = 1
+
+ ginscall(n.Left, proc)
+
+ret:
+}
+
+/*
+ * call to n has already been generated.
+ * generate:
+ * res = return value from call.
+ */
+func cgen_callret(n *gc.Node, res *gc.Node) {
+ var nod gc.Node
+ var fp *gc.Type
+ var t *gc.Type
+ var flist gc.Iter
+
+ t = n.Left.Type
+ if t.Etype == gc.TPTR32 || t.Etype == gc.TPTR64 {
+ t = t.Type
+ }
+
+ fp = gc.Structfirst(&flist, gc.Getoutarg(t))
+ if fp == nil {
+ gc.Fatal("cgen_callret: nil")
+ }
+
+ nod = gc.Node{}
+ nod.Op = gc.OINDREG
+ nod.Val.U.Reg = arm.REGSP
+ nod.Addable = 1
+
+ nod.Xoffset = fp.Width + 4 // +4: saved lr at 0(SP)
+ nod.Type = fp.Type
+ gc.Cgen_as(res, &nod)
+}
+
+/*
+ * call to n has already been generated.
+ * generate:
+ * res = &return value from call.
+ */
+func cgen_aret(n *gc.Node, res *gc.Node) {
+ var nod1 gc.Node
+ var nod2 gc.Node
+ var fp *gc.Type
+ var t *gc.Type
+ var flist gc.Iter
+
+ t = n.Left.Type
+ if gc.Isptr[t.Etype] != 0 {
+ t = t.Type
+ }
+
+ fp = gc.Structfirst(&flist, gc.Getoutarg(t))
+ if fp == nil {
+ gc.Fatal("cgen_aret: nil")
+ }
+
+ nod1 = gc.Node{}
+ nod1.Op = gc.OINDREG
+ nod1.Val.U.Reg = arm.REGSP
+ nod1.Addable = 1
+
+ nod1.Xoffset = fp.Width + 4 // +4: saved lr at 0(SP)
+ nod1.Type = fp.Type
+
+ if res.Op != gc.OREGISTER {
+ regalloc(&nod2, gc.Types[gc.Tptr], res)
+ agen(&nod1, &nod2)
+ gins(arm.AMOVW, &nod2, res)
+ regfree(&nod2)
+ } else {
+ agen(&nod1, res)
+ }
+}
+
+/*
+ * generate return.
+ * n->left is assignments to return values.
+ */
+func cgen_ret(n *gc.Node) {
+ var p *obj.Prog
+
+ if n != nil {
+ gc.Genlist(n.List) // copy out args
+ }
+ if gc.Hasdefer != 0 {
+ ginscall(gc.Deferreturn, 0)
+ }
+ gc.Genlist(gc.Curfn.Exit)
+ p = gins(obj.ARET, nil, nil)
+ if n != nil && n.Op == gc.ORETJMP {
+ p.To.Name = obj.NAME_EXTERN
+ p.To.Type = obj.TYPE_ADDR
+ p.To.Sym = gc.Linksym(n.Left.Sym)
+ }
+}
+
+/*
+ * generate high multiply
+ * res = (nl * nr) >> wordsize
+ */
+func cgen_hmul(nl *gc.Node, nr *gc.Node, res *gc.Node) {
+ var w int
+ var n1 gc.Node
+ var n2 gc.Node
+ var tmp *gc.Node
+ var t *gc.Type
+ var p *obj.Prog
+
+ if nl.Ullman < nr.Ullman {
+ tmp = nl
+ nl = nr
+ nr = tmp
+ }
+
+ t = nl.Type
+ w = int(t.Width * 8)
+ regalloc(&n1, t, res)
+ cgen(nl, &n1)
+ regalloc(&n2, t, nil)
+ cgen(nr, &n2)
+ switch gc.Simtype[t.Etype] {
+ case gc.TINT8,
+ gc.TINT16:
+ gins(optoas(gc.OMUL, t), &n2, &n1)
+ gshift(arm.AMOVW, &n1, arm.SHIFT_AR, int32(w), &n1)
+
+ case gc.TUINT8,
+ gc.TUINT16:
+ gins(optoas(gc.OMUL, t), &n2, &n1)
+ gshift(arm.AMOVW, &n1, arm.SHIFT_LR, int32(w), &n1)
+
+ // perform a long multiplication.
+ case gc.TINT32,
+ gc.TUINT32:
+ if gc.Issigned[t.Etype] != 0 {
+ p = gins(arm.AMULL, &n2, nil)
+ } else {
+ p = gins(arm.AMULLU, &n2, nil)
+ }
+
+ // n2 * n1 -> (n1 n2)
+ p.Reg = n1.Val.U.Reg
+
+ p.To.Type = obj.TYPE_REGREG
+ p.To.Reg = n1.Val.U.Reg
+ p.To.Offset = int64(n2.Val.U.Reg)
+
+ default:
+ gc.Fatal("cgen_hmul %v", gc.Tconv(t, 0))
+ }
+
+ cgen(&n1, res)
+ regfree(&n1)
+ regfree(&n2)
+}
+
+/*
+ * generate shift according to op, one of:
+ * res = nl << nr
+ * res = nl >> nr
+ */
+func cgen_shift(op int, bounded int, nl *gc.Node, nr *gc.Node, res *gc.Node) {
+ var n1 gc.Node
+ var n2 gc.Node
+ var n3 gc.Node
+ var nt gc.Node
+ var t gc.Node
+ var lo gc.Node
+ var hi gc.Node
+ var w int
+ var v int
+ var p1 *obj.Prog
+ var p2 *obj.Prog
+ var p3 *obj.Prog
+ var tr *gc.Type
+ var sc uint64
+
+ if nl.Type.Width > 4 {
+ gc.Fatal("cgen_shift %v", gc.Tconv(nl.Type, 0))
+ }
+
+ w = int(nl.Type.Width * 8)
+
+ if op == gc.OLROT {
+ v = int(gc.Mpgetfix(nr.Val.U.Xval))
+ regalloc(&n1, nl.Type, res)
+ if w == 32 {
+ cgen(nl, &n1)
+ gshift(arm.AMOVW, &n1, arm.SHIFT_RR, int32(w)-int32(v), &n1)
+ } else {
+ regalloc(&n2, nl.Type, nil)
+ cgen(nl, &n2)
+ gshift(arm.AMOVW, &n2, arm.SHIFT_LL, int32(v), &n1)
+ gshift(arm.AORR, &n2, arm.SHIFT_LR, int32(w)-int32(v), &n1)
+ regfree(&n2)
+
+ // Ensure sign/zero-extended result.
+ gins(optoas(gc.OAS, nl.Type), &n1, &n1)
+ }
+
+ gmove(&n1, res)
+ regfree(&n1)
+ return
+ }
+
+ if nr.Op == gc.OLITERAL {
+ regalloc(&n1, nl.Type, res)
+ cgen(nl, &n1)
+ sc = uint64(gc.Mpgetfix(nr.Val.U.Xval))
+ if sc == 0 {
+ } else // nothing to do
+ if sc >= uint64(nl.Type.Width*8) {
+ if op == gc.ORSH && gc.Issigned[nl.Type.Etype] != 0 {
+ gshift(arm.AMOVW, &n1, arm.SHIFT_AR, int32(w), &n1)
+ } else {
+ gins(arm.AEOR, &n1, &n1)
+ }
+ } else {
+ if op == gc.ORSH && gc.Issigned[nl.Type.Etype] != 0 {
+ gshift(arm.AMOVW, &n1, arm.SHIFT_AR, int32(sc), &n1)
+ } else if op == gc.ORSH {
+ gshift(arm.AMOVW, &n1, arm.SHIFT_LR, int32(sc), &n1) // OLSH
+ } else {
+ gshift(arm.AMOVW, &n1, arm.SHIFT_LL, int32(sc), &n1)
+ }
+ }
+
+ if w < 32 && op == gc.OLSH {
+ gins(optoas(gc.OAS, nl.Type), &n1, &n1)
+ }
+ gmove(&n1, res)
+ regfree(&n1)
+ return
+ }
+
+ tr = nr.Type
+ if tr.Width > 4 {
+ gc.Tempname(&nt, nr.Type)
+ if nl.Ullman >= nr.Ullman {
+ regalloc(&n2, nl.Type, res)
+ cgen(nl, &n2)
+ cgen(nr, &nt)
+ n1 = nt
+ } else {
+ cgen(nr, &nt)
+ regalloc(&n2, nl.Type, res)
+ cgen(nl, &n2)
+ }
+
+ split64(&nt, &lo, &hi)
+ regalloc(&n1, gc.Types[gc.TUINT32], nil)
+ regalloc(&n3, gc.Types[gc.TUINT32], nil)
+ gmove(&lo, &n1)
+ gmove(&hi, &n3)
+ splitclean()
+ gins(arm.ATST, &n3, nil)
+ gc.Nodconst(&t, gc.Types[gc.TUINT32], int64(w))
+ p1 = gins(arm.AMOVW, &t, &n1)
+ p1.Scond = arm.C_SCOND_NE
+ tr = gc.Types[gc.TUINT32]
+ regfree(&n3)
+ } else {
+ if nl.Ullman >= nr.Ullman {
+ regalloc(&n2, nl.Type, res)
+ cgen(nl, &n2)
+ regalloc(&n1, nr.Type, nil)
+ cgen(nr, &n1)
+ } else {
+ regalloc(&n1, nr.Type, nil)
+ cgen(nr, &n1)
+ regalloc(&n2, nl.Type, res)
+ cgen(nl, &n2)
+ }
+ }
+
+ // test for shift being 0
+ gins(arm.ATST, &n1, nil)
+
+ p3 = gc.Gbranch(arm.ABEQ, nil, -1)
+
+ // test and fix up large shifts
+ // TODO: if(!bounded), don't emit some of this.
+ regalloc(&n3, tr, nil)
+
+ gc.Nodconst(&t, gc.Types[gc.TUINT32], int64(w))
+ gmove(&t, &n3)
+ gcmp(arm.ACMP, &n1, &n3)
+ if op == gc.ORSH {
+ if gc.Issigned[nl.Type.Etype] != 0 {
+ p1 = gshift(arm.AMOVW, &n2, arm.SHIFT_AR, int32(w)-1, &n2)
+ p2 = gregshift(arm.AMOVW, &n2, arm.SHIFT_AR, &n1, &n2)
+ } else {
+ p1 = gins(arm.AEOR, &n2, &n2)
+ p2 = gregshift(arm.AMOVW, &n2, arm.SHIFT_LR, &n1, &n2)
+ }
+
+ p1.Scond = arm.C_SCOND_HS
+ p2.Scond = arm.C_SCOND_LO
+ } else {
+ p1 = gins(arm.AEOR, &n2, &n2)
+ p2 = gregshift(arm.AMOVW, &n2, arm.SHIFT_LL, &n1, &n2)
+ p1.Scond = arm.C_SCOND_HS
+ p2.Scond = arm.C_SCOND_LO
+ }
+
+ regfree(&n3)
+
+ gc.Patch(p3, gc.Pc)
+
+ // Left-shift of smaller word must be sign/zero-extended.
+ if w < 32 && op == gc.OLSH {
+ gins(optoas(gc.OAS, nl.Type), &n2, &n2)
+ }
+ gmove(&n2, res)
+
+ regfree(&n1)
+ regfree(&n2)
+}
+
+func clearfat(nl *gc.Node) {
+ var w uint32
+ var c uint32
+ var q uint32
+ var dst gc.Node
+ var nc gc.Node
+ var nz gc.Node
+ var end gc.Node
+ var r0 gc.Node
+ var r1 gc.Node
+ var f *gc.Node
+ var p *obj.Prog
+ var pl *obj.Prog
+
+ /* clear a fat object */
+ if gc.Debug['g'] != 0 {
+ gc.Dump("\nclearfat", nl)
+ }
+
+ w = uint32(nl.Type.Width)
+
+ // Avoid taking the address for simple enough types.
+ if componentgen(nil, nl) != 0 {
+ return
+ }
+
+ c = w % 4 // bytes
+ q = w / 4 // quads
+
+ r0.Op = gc.OREGISTER
+
+ r0.Val.U.Reg = REGALLOC_R0
+ r1.Op = gc.OREGISTER
+ r1.Val.U.Reg = REGALLOC_R0 + 1
+ regalloc(&dst, gc.Types[gc.Tptr], &r1)
+ agen(nl, &dst)
+ gc.Nodconst(&nc, gc.Types[gc.TUINT32], 0)
+ regalloc(&nz, gc.Types[gc.TUINT32], &r0)
+ cgen(&nc, &nz)
+
+ if q > 128 {
+ regalloc(&end, gc.Types[gc.Tptr], nil)
+ p = gins(arm.AMOVW, &dst, &end)
+ p.From.Type = obj.TYPE_ADDR
+ p.From.Offset = int64(q) * 4
+
+ p = gins(arm.AMOVW, &nz, &dst)
+ p.To.Type = obj.TYPE_MEM
+ p.To.Offset = 4
+ p.Scond |= arm.C_PBIT
+ pl = p
+
+ p = gins(arm.ACMP, &dst, nil)
+ raddr(&end, p)
+ gc.Patch(gc.Gbranch(arm.ABNE, nil, 0), pl)
+
+ regfree(&end)
+ } else if q >= 4 && !gc.Nacl {
+ f = gc.Sysfunc("duffzero")
+ p = gins(obj.ADUFFZERO, nil, f)
+ gc.Afunclit(&p.To, f)
+
+ // 4 and 128 = magic constants: see ../../runtime/asm_arm.s
+ p.To.Offset = 4 * (128 - int64(q))
+ } else {
+ for q > 0 {
+ p = gins(arm.AMOVW, &nz, &dst)
+ p.To.Type = obj.TYPE_MEM
+ p.To.Offset = 4
+ p.Scond |= arm.C_PBIT
+
+ //print("1. %P\n", p);
+ q--
+ }
+ }
+
+ for c > 0 {
+ p = gins(arm.AMOVB, &nz, &dst)
+ p.To.Type = obj.TYPE_MEM
+ p.To.Offset = 1
+ p.Scond |= arm.C_PBIT
+
+ //print("2. %P\n", p);
+ c--
+ }
+
+ regfree(&dst)
+ regfree(&nz)
+}
+
+// Called after regopt and peep have run.
+// Expand CHECKNIL pseudo-op into actual nil pointer check.
+func expandchecks(firstp *obj.Prog) {
+ var reg int
+ var p *obj.Prog
+ var p1 *obj.Prog
+
+ for p = firstp; p != nil; p = p.Link {
+ if p.As != obj.ACHECKNIL {
+ continue
+ }
+ if gc.Debug_checknil != 0 && p.Lineno > 1 { // p->lineno==1 in generated wrappers
+ gc.Warnl(int(p.Lineno), "generated nil check")
+ }
+ if p.From.Type != obj.TYPE_REG {
+ gc.Fatal("invalid nil check %v", p)
+ }
+ reg = int(p.From.Reg)
+
+ // check is
+ // CMP arg, $0
+ // MOV.EQ arg, 0(arg)
+ p1 = gc.Ctxt.NewProg()
+
+ gc.Clearp(p1)
+ p1.Link = p.Link
+ p.Link = p1
+ p1.Lineno = p.Lineno
+ p1.Pc = 9999
+ p1.As = arm.AMOVW
+ p1.From.Type = obj.TYPE_REG
+ p1.From.Reg = int16(reg)
+ p1.To.Type = obj.TYPE_MEM
+ p1.To.Reg = int16(reg)
+ p1.To.Offset = 0
+ p1.Scond = arm.C_SCOND_EQ
+ p.As = arm.ACMP
+ p.From.Type = obj.TYPE_CONST
+ p.From.Reg = 0
+ p.From.Offset = 0
+ p.Reg = int16(reg)
+ }
+}
--- /dev/null
+// Derived from Inferno utils/5c/txt.c
+// http://code.google.com/p/inferno-os/source/browse/utils/5c/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 main
+
+import (
+ "cmd/internal/obj"
+ "cmd/internal/obj/arm"
+ "fmt"
+)
+import "cmd/internal/gc"
+
+// TODO(rsc): Can make this bigger if we move
+// the text segment up higher in 5l for all GOOS.
+// At the same time, can raise StackBig in ../../runtime/stack.h.
+var unmappedzero int = 4096
+
+var resvd = []int{
+ 9, // reserved for m
+ 10, // reserved for g
+ arm.REGSP, // reserved for SP
+}
+
+func ginit() {
+ var i int
+
+ for i = 0; i < len(reg); i++ {
+ reg[i] = 0
+ }
+ for i = 0; i < len(resvd); i++ {
+ reg[resvd[i]]++
+ }
+}
+
+func gclean() {
+ var i int
+
+ for i = 0; i < len(resvd); i++ {
+ reg[resvd[i]]--
+ }
+
+ for i = 0; i < len(reg); i++ {
+ if reg[i] != 0 {
+ gc.Yyerror("reg %v left allocated\n", gc.Ctxt.Rconv(i))
+ }
+ }
+}
+
+func anyregalloc() int {
+ var i int
+ var j int
+
+ for i = 0; i < len(reg); i++ {
+ if reg[i] == 0 {
+ goto ok
+ }
+ for j = 0; j < len(resvd); j++ {
+ if resvd[j] == i {
+ goto ok
+ }
+ }
+ return 1
+ ok:
+ }
+
+ return 0
+}
+
+var regpc [REGALLOC_FMAX + 1]uint32
+
+/*
+ * allocate register of type t, leave in n.
+ * if o != N, o is desired fixed register.
+ * caller must regfree(n).
+ */
+func regalloc(n *gc.Node, t *gc.Type, o *gc.Node) {
+ var i int
+ var et int
+ var fixfree int
+ var floatfree int
+
+ if false && gc.Debug['r'] != 0 {
+ fixfree = 0
+ for i = REGALLOC_R0; i <= REGALLOC_RMAX; i++ {
+ if reg[i] == 0 {
+ fixfree++
+ }
+ }
+ floatfree = 0
+ for i = REGALLOC_F0; i <= REGALLOC_FMAX; i++ {
+ if reg[i] == 0 {
+ floatfree++
+ }
+ }
+ fmt.Printf("regalloc fix %d float %d\n", fixfree, floatfree)
+ }
+
+ if t == nil {
+ gc.Fatal("regalloc: t nil")
+ }
+ et = int(gc.Simtype[t.Etype])
+ if gc.Is64(t) != 0 {
+ gc.Fatal("regalloc: 64 bit type %v")
+ }
+
+ switch et {
+ case gc.TINT8,
+ gc.TUINT8,
+ gc.TINT16,
+ gc.TUINT16,
+ gc.TINT32,
+ gc.TUINT32,
+ gc.TPTR32,
+ gc.TBOOL:
+ if o != nil && o.Op == gc.OREGISTER {
+ i = int(o.Val.U.Reg)
+ if i >= REGALLOC_R0 && i <= REGALLOC_RMAX {
+ goto out
+ }
+ }
+
+ for i = REGALLOC_R0; i <= REGALLOC_RMAX; i++ {
+ if reg[i] == 0 {
+ regpc[i] = uint32(obj.Getcallerpc(&n))
+ goto out
+ }
+ }
+
+ fmt.Printf("registers allocated at\n")
+ for i = REGALLOC_R0; i <= REGALLOC_RMAX; i++ {
+ fmt.Printf("%d %p\n", i, regpc[i])
+ }
+ gc.Fatal("out of fixed registers")
+ goto err
+
+ case gc.TFLOAT32,
+ gc.TFLOAT64:
+ if o != nil && o.Op == gc.OREGISTER {
+ i = int(o.Val.U.Reg)
+ if i >= REGALLOC_F0 && i <= REGALLOC_FMAX {
+ goto out
+ }
+ }
+
+ for i = REGALLOC_F0; i <= REGALLOC_FMAX; i++ {
+ if reg[i] == 0 {
+ goto out
+ }
+ }
+ gc.Fatal("out of floating point registers")
+ goto err
+
+ case gc.TCOMPLEX64,
+ gc.TCOMPLEX128:
+ gc.Tempname(n, t)
+ return
+ }
+
+ gc.Yyerror("regalloc: unknown type %v", gc.Tconv(t, 0))
+
+err:
+ gc.Nodreg(n, t, arm.REG_R0)
+ return
+
+out:
+ reg[i]++
+ gc.Nodreg(n, t, i)
+}
+
+func regfree(n *gc.Node) {
+ var i int
+ var fixfree int
+ var floatfree int
+
+ if false && gc.Debug['r'] != 0 {
+ fixfree = 0
+ for i = REGALLOC_R0; i <= REGALLOC_RMAX; i++ {
+ if reg[i] == 0 {
+ fixfree++
+ }
+ }
+ floatfree = 0
+ for i = REGALLOC_F0; i <= REGALLOC_FMAX; i++ {
+ if reg[i] == 0 {
+ floatfree++
+ }
+ }
+ fmt.Printf("regalloc fix %d float %d\n", fixfree, floatfree)
+ }
+
+ if n.Op == gc.ONAME {
+ return
+ }
+ if n.Op != gc.OREGISTER && n.Op != gc.OINDREG {
+ gc.Fatal("regfree: not a register")
+ }
+ i = int(n.Val.U.Reg)
+ if i == arm.REGSP {
+ return
+ }
+ if i < 0 || i >= len(reg) || i >= len(regpc) {
+ gc.Fatal("regfree: reg out of range")
+ }
+ if reg[i] <= 0 {
+ gc.Fatal("regfree: reg %v not allocated", gc.Ctxt.Rconv(i))
+ }
+ reg[i]--
+ if reg[i] == 0 {
+ regpc[i] = 0
+ }
+}
+
+/*
+ * return constant i node.
+ * overwritten by next call, but useful in calls to gins.
+ */
+
+var ncon_n gc.Node
+
+func ncon(i uint32) *gc.Node {
+ if ncon_n.Type == nil {
+ gc.Nodconst(&ncon_n, gc.Types[gc.TUINT32], 0)
+ }
+ gc.Mpmovecfix(ncon_n.Val.U.Xval, int64(i))
+ return &ncon_n
+}
+
+var sclean [10]gc.Node
+
+var nsclean int
+
+/*
+ * n is a 64-bit value. fill in lo and hi to refer to its 32-bit halves.
+ */
+func split64(n *gc.Node, lo *gc.Node, hi *gc.Node) {
+ var n1 gc.Node
+ var i int64
+
+ if !(gc.Is64(n.Type) != 0) {
+ gc.Fatal("split64 %v", gc.Tconv(n.Type, 0))
+ }
+
+ if nsclean >= len(sclean) {
+ gc.Fatal("split64 clean")
+ }
+ sclean[nsclean].Op = gc.OEMPTY
+ nsclean++
+ switch n.Op {
+ default:
+ switch n.Op {
+ default:
+ if !(dotaddable(n, &n1) != 0) {
+ igen(n, &n1, nil)
+ sclean[nsclean-1] = n1
+ }
+
+ n = &n1
+
+ case gc.ONAME:
+ if n.Class == gc.PPARAMREF {
+ cgen(n.Heapaddr, &n1)
+ sclean[nsclean-1] = n1
+ n = &n1
+ }
+
+ // nothing
+ case gc.OINDREG:
+ break
+ }
+
+ *lo = *n
+ *hi = *n
+ lo.Type = gc.Types[gc.TUINT32]
+ if n.Type.Etype == gc.TINT64 {
+ hi.Type = gc.Types[gc.TINT32]
+ } else {
+ hi.Type = gc.Types[gc.TUINT32]
+ }
+ hi.Xoffset += 4
+
+ case gc.OLITERAL:
+ gc.Convconst(&n1, n.Type, &n.Val)
+ i = gc.Mpgetfix(n1.Val.U.Xval)
+ gc.Nodconst(lo, gc.Types[gc.TUINT32], int64(uint32(i)))
+ i >>= 32
+ if n.Type.Etype == gc.TINT64 {
+ gc.Nodconst(hi, gc.Types[gc.TINT32], int64(int32(i)))
+ } else {
+ gc.Nodconst(hi, gc.Types[gc.TUINT32], int64(uint32(i)))
+ }
+ }
+}
+
+func splitclean() {
+ if nsclean <= 0 {
+ gc.Fatal("splitclean")
+ }
+ nsclean--
+ if sclean[nsclean].Op != gc.OEMPTY {
+ regfree(&sclean[nsclean])
+ }
+}
+
+func gmove(f *gc.Node, t *gc.Node) {
+ var a int
+ var ft int
+ var tt int
+ var fa int
+ var ta int
+ var cvt *gc.Type
+ var r1 gc.Node
+ var r2 gc.Node
+ var flo gc.Node
+ var fhi gc.Node
+ var tlo gc.Node
+ var thi gc.Node
+ var con gc.Node
+ var p1 *obj.Prog
+
+ if gc.Debug['M'] != 0 {
+ fmt.Printf("gmove %v -> %v\n", gc.Nconv(f, 0), gc.Nconv(t, 0))
+ }
+
+ ft = gc.Simsimtype(f.Type)
+ tt = gc.Simsimtype(t.Type)
+ cvt = t.Type
+
+ if gc.Iscomplex[ft] != 0 || gc.Iscomplex[tt] != 0 {
+ gc.Complexmove(f, t)
+ return
+ }
+
+ // cannot have two memory operands;
+ // except 64-bit, which always copies via registers anyway.
+ if !(gc.Is64(f.Type) != 0) && !(gc.Is64(t.Type) != 0) && gc.Ismem(f) != 0 && gc.Ismem(t) != 0 {
+ goto hard
+ }
+
+ // convert constant to desired type
+ if f.Op == gc.OLITERAL {
+ switch tt {
+ default:
+ gc.Convconst(&con, t.Type, &f.Val)
+
+ case gc.TINT16,
+ gc.TINT8:
+ gc.Convconst(&con, gc.Types[gc.TINT32], &f.Val)
+ regalloc(&r1, con.Type, t)
+ gins(arm.AMOVW, &con, &r1)
+ gmove(&r1, t)
+ regfree(&r1)
+ return
+
+ case gc.TUINT16,
+ gc.TUINT8:
+ gc.Convconst(&con, gc.Types[gc.TUINT32], &f.Val)
+ regalloc(&r1, con.Type, t)
+ gins(arm.AMOVW, &con, &r1)
+ gmove(&r1, t)
+ regfree(&r1)
+ return
+ }
+
+ f = &con
+ ft = gc.Simsimtype(con.Type)
+
+ // constants can't move directly to memory
+ if gc.Ismem(t) != 0 && !(gc.Is64(t.Type) != 0) {
+ goto hard
+ }
+ }
+
+ // value -> value copy, only one memory operand.
+ // figure out the instruction to use.
+ // break out of switch for one-instruction gins.
+ // goto rdst for "destination must be register".
+ // goto hard for "convert to cvt type first".
+ // otherwise handle and return.
+
+ switch uint32(ft)<<16 | uint32(tt) {
+ default:
+ goto fatal
+
+ /*
+ * integer copy and truncate
+ */
+ case gc.TINT8<<16 | gc.TINT8: // same size
+ if !(gc.Ismem(f) != 0) {
+ a = arm.AMOVB
+ break
+ }
+ fallthrough
+
+ case gc.TUINT8<<16 | gc.TINT8,
+ gc.TINT16<<16 | gc.TINT8, // truncate
+ gc.TUINT16<<16 | gc.TINT8,
+ gc.TINT32<<16 | gc.TINT8,
+ gc.TUINT32<<16 | gc.TINT8:
+ a = arm.AMOVBS
+
+ case gc.TUINT8<<16 | gc.TUINT8:
+ if !(gc.Ismem(f) != 0) {
+ a = arm.AMOVB
+ break
+ }
+ fallthrough
+
+ case gc.TINT8<<16 | gc.TUINT8,
+ gc.TINT16<<16 | gc.TUINT8,
+ gc.TUINT16<<16 | gc.TUINT8,
+ gc.TINT32<<16 | gc.TUINT8,
+ gc.TUINT32<<16 | gc.TUINT8:
+ a = arm.AMOVBU
+
+ case gc.TINT64<<16 | gc.TINT8, // truncate low word
+ gc.TUINT64<<16 | gc.TINT8:
+ a = arm.AMOVBS
+
+ goto trunc64
+
+ case gc.TINT64<<16 | gc.TUINT8,
+ gc.TUINT64<<16 | gc.TUINT8:
+ a = arm.AMOVBU
+ goto trunc64
+
+ case gc.TINT16<<16 | gc.TINT16: // same size
+ if !(gc.Ismem(f) != 0) {
+ a = arm.AMOVH
+ break
+ }
+ fallthrough
+
+ case gc.TUINT16<<16 | gc.TINT16,
+ gc.TINT32<<16 | gc.TINT16, // truncate
+ gc.TUINT32<<16 | gc.TINT16:
+ a = arm.AMOVHS
+
+ case gc.TUINT16<<16 | gc.TUINT16:
+ if !(gc.Ismem(f) != 0) {
+ a = arm.AMOVH
+ break
+ }
+ fallthrough
+
+ case gc.TINT16<<16 | gc.TUINT16,
+ gc.TINT32<<16 | gc.TUINT16,
+ gc.TUINT32<<16 | gc.TUINT16:
+ a = arm.AMOVHU
+
+ case gc.TINT64<<16 | gc.TINT16, // truncate low word
+ gc.TUINT64<<16 | gc.TINT16:
+ a = arm.AMOVHS
+
+ goto trunc64
+
+ case gc.TINT64<<16 | gc.TUINT16,
+ gc.TUINT64<<16 | gc.TUINT16:
+ a = arm.AMOVHU
+ goto trunc64
+
+ case gc.TINT32<<16 | gc.TINT32, // same size
+ gc.TINT32<<16 | gc.TUINT32,
+ gc.TUINT32<<16 | gc.TINT32,
+ gc.TUINT32<<16 | gc.TUINT32:
+ a = arm.AMOVW
+
+ case gc.TINT64<<16 | gc.TINT32, // truncate
+ gc.TUINT64<<16 | gc.TINT32,
+ gc.TINT64<<16 | gc.TUINT32,
+ gc.TUINT64<<16 | gc.TUINT32:
+ split64(f, &flo, &fhi)
+
+ regalloc(&r1, t.Type, nil)
+ gins(arm.AMOVW, &flo, &r1)
+ gins(arm.AMOVW, &r1, t)
+ regfree(&r1)
+ splitclean()
+ return
+
+ case gc.TINT64<<16 | gc.TINT64, // same size
+ gc.TINT64<<16 | gc.TUINT64,
+ gc.TUINT64<<16 | gc.TINT64,
+ gc.TUINT64<<16 | gc.TUINT64:
+ split64(f, &flo, &fhi)
+
+ split64(t, &tlo, &thi)
+ regalloc(&r1, flo.Type, nil)
+ regalloc(&r2, fhi.Type, nil)
+ gins(arm.AMOVW, &flo, &r1)
+ gins(arm.AMOVW, &fhi, &r2)
+ gins(arm.AMOVW, &r1, &tlo)
+ gins(arm.AMOVW, &r2, &thi)
+ regfree(&r1)
+ regfree(&r2)
+ splitclean()
+ splitclean()
+ return
+
+ /*
+ * integer up-conversions
+ */
+ case gc.TINT8<<16 | gc.TINT16, // sign extend int8
+ gc.TINT8<<16 | gc.TUINT16,
+ gc.TINT8<<16 | gc.TINT32,
+ gc.TINT8<<16 | gc.TUINT32:
+ a = arm.AMOVBS
+
+ goto rdst
+
+ case gc.TINT8<<16 | gc.TINT64, // convert via int32
+ gc.TINT8<<16 | gc.TUINT64:
+ cvt = gc.Types[gc.TINT32]
+
+ goto hard
+
+ case gc.TUINT8<<16 | gc.TINT16, // zero extend uint8
+ gc.TUINT8<<16 | gc.TUINT16,
+ gc.TUINT8<<16 | gc.TINT32,
+ gc.TUINT8<<16 | gc.TUINT32:
+ a = arm.AMOVBU
+
+ goto rdst
+
+ case gc.TUINT8<<16 | gc.TINT64, // convert via uint32
+ gc.TUINT8<<16 | gc.TUINT64:
+ cvt = gc.Types[gc.TUINT32]
+
+ goto hard
+
+ case gc.TINT16<<16 | gc.TINT32, // sign extend int16
+ gc.TINT16<<16 | gc.TUINT32:
+ a = arm.AMOVHS
+
+ goto rdst
+
+ case gc.TINT16<<16 | gc.TINT64, // convert via int32
+ gc.TINT16<<16 | gc.TUINT64:
+ cvt = gc.Types[gc.TINT32]
+
+ goto hard
+
+ case gc.TUINT16<<16 | gc.TINT32, // zero extend uint16
+ gc.TUINT16<<16 | gc.TUINT32:
+ a = arm.AMOVHU
+
+ goto rdst
+
+ case gc.TUINT16<<16 | gc.TINT64, // convert via uint32
+ gc.TUINT16<<16 | gc.TUINT64:
+ cvt = gc.Types[gc.TUINT32]
+
+ goto hard
+
+ case gc.TINT32<<16 | gc.TINT64, // sign extend int32
+ gc.TINT32<<16 | gc.TUINT64:
+ split64(t, &tlo, &thi)
+
+ regalloc(&r1, tlo.Type, nil)
+ regalloc(&r2, thi.Type, nil)
+ gmove(f, &r1)
+ p1 = gins(arm.AMOVW, &r1, &r2)
+ p1.From.Type = obj.TYPE_SHIFT
+ p1.From.Offset = 2<<5 | 31<<7 | int64(r1.Val.U.Reg)&15 // r1->31
+ p1.From.Reg = 0
+
+ //print("gmove: %P\n", p1);
+ gins(arm.AMOVW, &r1, &tlo)
+
+ gins(arm.AMOVW, &r2, &thi)
+ regfree(&r1)
+ regfree(&r2)
+ splitclean()
+ return
+
+ case gc.TUINT32<<16 | gc.TINT64, // zero extend uint32
+ gc.TUINT32<<16 | gc.TUINT64:
+ split64(t, &tlo, &thi)
+
+ gmove(f, &tlo)
+ regalloc(&r1, thi.Type, nil)
+ gins(arm.AMOVW, ncon(0), &r1)
+ gins(arm.AMOVW, &r1, &thi)
+ regfree(&r1)
+ splitclean()
+ return
+
+ // case CASE(TFLOAT64, TUINT64):
+ /*
+ * float to integer
+ */
+ case gc.TFLOAT32<<16 | gc.TINT8,
+ gc.TFLOAT32<<16 | gc.TUINT8,
+ gc.TFLOAT32<<16 | gc.TINT16,
+ gc.TFLOAT32<<16 | gc.TUINT16,
+ gc.TFLOAT32<<16 | gc.TINT32,
+ gc.TFLOAT32<<16 | gc.TUINT32,
+
+ // case CASE(TFLOAT32, TUINT64):
+
+ gc.TFLOAT64<<16 | gc.TINT8,
+ gc.TFLOAT64<<16 | gc.TUINT8,
+ gc.TFLOAT64<<16 | gc.TINT16,
+ gc.TFLOAT64<<16 | gc.TUINT16,
+ gc.TFLOAT64<<16 | gc.TINT32,
+ gc.TFLOAT64<<16 | gc.TUINT32:
+ fa = arm.AMOVF
+
+ a = arm.AMOVFW
+ if ft == gc.TFLOAT64 {
+ fa = arm.AMOVD
+ a = arm.AMOVDW
+ }
+
+ ta = arm.AMOVW
+ switch tt {
+ case gc.TINT8:
+ ta = arm.AMOVBS
+
+ case gc.TUINT8:
+ ta = arm.AMOVBU
+
+ case gc.TINT16:
+ ta = arm.AMOVHS
+
+ case gc.TUINT16:
+ ta = arm.AMOVHU
+ }
+
+ regalloc(&r1, gc.Types[ft], f)
+ regalloc(&r2, gc.Types[tt], t)
+ gins(fa, f, &r1) // load to fpu
+ p1 = gins(a, &r1, &r1) // convert to w
+ switch tt {
+ case gc.TUINT8,
+ gc.TUINT16,
+ gc.TUINT32:
+ p1.Scond |= arm.C_UBIT
+ }
+
+ gins(arm.AMOVW, &r1, &r2) // copy to cpu
+ gins(ta, &r2, t) // store
+ regfree(&r1)
+ regfree(&r2)
+ return
+
+ /*
+ * integer to float
+ */
+ case gc.TINT8<<16 | gc.TFLOAT32,
+ gc.TUINT8<<16 | gc.TFLOAT32,
+ gc.TINT16<<16 | gc.TFLOAT32,
+ gc.TUINT16<<16 | gc.TFLOAT32,
+ gc.TINT32<<16 | gc.TFLOAT32,
+ gc.TUINT32<<16 | gc.TFLOAT32,
+ gc.TINT8<<16 | gc.TFLOAT64,
+ gc.TUINT8<<16 | gc.TFLOAT64,
+ gc.TINT16<<16 | gc.TFLOAT64,
+ gc.TUINT16<<16 | gc.TFLOAT64,
+ gc.TINT32<<16 | gc.TFLOAT64,
+ gc.TUINT32<<16 | gc.TFLOAT64:
+ fa = arm.AMOVW
+
+ switch ft {
+ case gc.TINT8:
+ fa = arm.AMOVBS
+
+ case gc.TUINT8:
+ fa = arm.AMOVBU
+
+ case gc.TINT16:
+ fa = arm.AMOVHS
+
+ case gc.TUINT16:
+ fa = arm.AMOVHU
+ }
+
+ a = arm.AMOVWF
+ ta = arm.AMOVF
+ if tt == gc.TFLOAT64 {
+ a = arm.AMOVWD
+ ta = arm.AMOVD
+ }
+
+ regalloc(&r1, gc.Types[ft], f)
+ regalloc(&r2, gc.Types[tt], t)
+ gins(fa, f, &r1) // load to cpu
+ gins(arm.AMOVW, &r1, &r2) // copy to fpu
+ p1 = gins(a, &r2, &r2) // convert
+ switch ft {
+ case gc.TUINT8,
+ gc.TUINT16,
+ gc.TUINT32:
+ p1.Scond |= arm.C_UBIT
+ }
+
+ gins(ta, &r2, t) // store
+ regfree(&r1)
+ regfree(&r2)
+ return
+
+ case gc.TUINT64<<16 | gc.TFLOAT32,
+ gc.TUINT64<<16 | gc.TFLOAT64:
+ gc.Fatal("gmove UINT64, TFLOAT not implemented")
+ return
+
+ /*
+ * float to float
+ */
+ case gc.TFLOAT32<<16 | gc.TFLOAT32:
+ a = arm.AMOVF
+
+ case gc.TFLOAT64<<16 | gc.TFLOAT64:
+ a = arm.AMOVD
+
+ case gc.TFLOAT32<<16 | gc.TFLOAT64:
+ regalloc(&r1, gc.Types[gc.TFLOAT64], t)
+ gins(arm.AMOVF, f, &r1)
+ gins(arm.AMOVFD, &r1, &r1)
+ gins(arm.AMOVD, &r1, t)
+ regfree(&r1)
+ return
+
+ case gc.TFLOAT64<<16 | gc.TFLOAT32:
+ regalloc(&r1, gc.Types[gc.TFLOAT64], t)
+ gins(arm.AMOVD, f, &r1)
+ gins(arm.AMOVDF, &r1, &r1)
+ gins(arm.AMOVF, &r1, t)
+ regfree(&r1)
+ return
+ }
+
+ gins(a, f, t)
+ return
+
+ // TODO(kaib): we almost always require a register dest anyway, this can probably be
+ // removed.
+ // requires register destination
+rdst:
+ regalloc(&r1, t.Type, t)
+
+ gins(a, f, &r1)
+ gmove(&r1, t)
+ regfree(&r1)
+ return
+
+ // requires register intermediate
+hard:
+ regalloc(&r1, cvt, t)
+
+ gmove(f, &r1)
+ gmove(&r1, t)
+ regfree(&r1)
+ return
+
+ // truncate 64 bit integer
+trunc64:
+ split64(f, &flo, &fhi)
+
+ regalloc(&r1, t.Type, nil)
+ gins(a, &flo, &r1)
+ gins(a, &r1, t)
+ regfree(&r1)
+ splitclean()
+ return
+
+ // should not happen
+fatal:
+ gc.Fatal("gmove %v -> %v", gc.Nconv(f, 0), gc.Nconv(t, 0))
+}
+
+func samaddr(f *gc.Node, t *gc.Node) int {
+ if f.Op != t.Op {
+ return 0
+ }
+
+ switch f.Op {
+ case gc.OREGISTER:
+ if f.Val.U.Reg != t.Val.U.Reg {
+ break
+ }
+ return 1
+ }
+
+ return 0
+}
+
+/*
+ * generate one instruction:
+ * as f, t
+ */
+func gins(as int, f *gc.Node, t *gc.Node) *obj.Prog {
+ var p *obj.Prog
+ var af obj.Addr
+ // Node nod;
+ // int32 v;
+
+ var at obj.Addr
+
+ if f != nil && f.Op == gc.OINDEX {
+ gc.Fatal("gins OINDEX not implemented")
+ }
+
+ // regalloc(&nod, ®node, Z);
+ // v = constnode.vconst;
+ // cgen(f->right, &nod);
+ // constnode.vconst = v;
+ // idx.reg = nod.reg;
+ // regfree(&nod);
+ if t != nil && t.Op == gc.OINDEX {
+ gc.Fatal("gins OINDEX not implemented")
+ }
+
+ // regalloc(&nod, ®node, Z);
+ // v = constnode.vconst;
+ // cgen(t->right, &nod);
+ // constnode.vconst = v;
+ // idx.reg = nod.reg;
+ // regfree(&nod);
+ af = obj.Addr{}
+
+ at = obj.Addr{}
+ if f != nil {
+ gc.Naddr(f, &af, 1)
+ }
+ if t != nil {
+ gc.Naddr(t, &at, 1)
+ }
+ p = gc.Prog(as)
+ if f != nil {
+ p.From = af
+ }
+ if t != nil {
+ p.To = at
+ }
+ if gc.Debug['g'] != 0 {
+ fmt.Printf("%v\n", p)
+ }
+ return p
+}
+
+/*
+ * insert n into reg slot of p
+ */
+func raddr(n *gc.Node, p *obj.Prog) {
+ var a obj.Addr
+
+ gc.Naddr(n, &a, 1)
+ if a.Type != obj.TYPE_REG {
+ if n != nil {
+ gc.Fatal("bad in raddr: %v", gc.Oconv(int(n.Op), 0))
+ } else {
+ gc.Fatal("bad in raddr: <null>")
+ }
+ p.Reg = 0
+ } else {
+ p.Reg = a.Reg
+ }
+}
+
+/* generate a comparison
+TODO(kaib): one of the args can actually be a small constant. relax the constraint and fix call sites.
+*/
+func gcmp(as int, lhs *gc.Node, rhs *gc.Node) *obj.Prog {
+ var p *obj.Prog
+
+ if lhs.Op != gc.OREGISTER {
+ gc.Fatal("bad operands to gcmp: %v %v", gc.Oconv(int(lhs.Op), 0), gc.Oconv(int(rhs.Op), 0))
+ }
+
+ p = gins(as, rhs, nil)
+ raddr(lhs, p)
+ return p
+}
+
+/* generate a constant shift
+ * arm encodes a shift by 32 as 0, thus asking for 0 shift is illegal.
+ */
+func gshift(as int, lhs *gc.Node, stype int32, sval int32, rhs *gc.Node) *obj.Prog {
+ var p *obj.Prog
+
+ if sval <= 0 || sval > 32 {
+ gc.Fatal("bad shift value: %d", sval)
+ }
+
+ sval = sval & 0x1f
+
+ p = gins(as, nil, rhs)
+ p.From.Type = obj.TYPE_SHIFT
+ p.From.Offset = int64(stype) | int64(sval)<<7 | int64(lhs.Val.U.Reg)&15
+ return p
+}
+
+/* generate a register shift
+ */
+func gregshift(as int, lhs *gc.Node, stype int32, reg *gc.Node, rhs *gc.Node) *obj.Prog {
+ var p *obj.Prog
+ p = gins(as, nil, rhs)
+ p.From.Type = obj.TYPE_SHIFT
+ p.From.Offset = int64(stype) | (int64(reg.Val.U.Reg)&15)<<8 | 1<<4 | int64(lhs.Val.U.Reg)&15
+ return p
+}
+
+/*
+ * return Axxx for Oxxx on type t.
+ */
+func optoas(op int, t *gc.Type) int {
+ var a int
+
+ if t == nil {
+ gc.Fatal("optoas: t is nil")
+ }
+
+ a = obj.AXXX
+ switch uint32(op)<<16 | uint32(gc.Simtype[t.Etype]) {
+ default:
+ gc.Fatal("optoas: no entry %v-%v etype %v simtype %v", gc.Oconv(int(op), 0), gc.Tconv(t, 0), gc.Tconv(gc.Types[t.Etype], 0), gc.Tconv(gc.Types[gc.Simtype[t.Etype]], 0))
+
+ /* case CASE(OADDR, TPTR32):
+ a = ALEAL;
+ break;
+
+ case CASE(OADDR, TPTR64):
+ a = ALEAQ;
+ break;
+ */
+ // TODO(kaib): make sure the conditional branches work on all edge cases
+ case gc.OEQ<<16 | gc.TBOOL,
+ gc.OEQ<<16 | gc.TINT8,
+ gc.OEQ<<16 | gc.TUINT8,
+ gc.OEQ<<16 | gc.TINT16,
+ gc.OEQ<<16 | gc.TUINT16,
+ gc.OEQ<<16 | gc.TINT32,
+ gc.OEQ<<16 | gc.TUINT32,
+ gc.OEQ<<16 | gc.TINT64,
+ gc.OEQ<<16 | gc.TUINT64,
+ gc.OEQ<<16 | gc.TPTR32,
+ gc.OEQ<<16 | gc.TPTR64,
+ gc.OEQ<<16 | gc.TFLOAT32,
+ gc.OEQ<<16 | gc.TFLOAT64:
+ a = arm.ABEQ
+
+ case gc.ONE<<16 | gc.TBOOL,
+ gc.ONE<<16 | gc.TINT8,
+ gc.ONE<<16 | gc.TUINT8,
+ gc.ONE<<16 | gc.TINT16,
+ gc.ONE<<16 | gc.TUINT16,
+ gc.ONE<<16 | gc.TINT32,
+ gc.ONE<<16 | gc.TUINT32,
+ gc.ONE<<16 | gc.TINT64,
+ gc.ONE<<16 | gc.TUINT64,
+ gc.ONE<<16 | gc.TPTR32,
+ gc.ONE<<16 | gc.TPTR64,
+ gc.ONE<<16 | gc.TFLOAT32,
+ gc.ONE<<16 | gc.TFLOAT64:
+ a = arm.ABNE
+
+ case gc.OLT<<16 | gc.TINT8,
+ gc.OLT<<16 | gc.TINT16,
+ gc.OLT<<16 | gc.TINT32,
+ gc.OLT<<16 | gc.TINT64,
+ gc.OLT<<16 | gc.TFLOAT32,
+ gc.OLT<<16 | gc.TFLOAT64:
+ a = arm.ABLT
+
+ case gc.OLT<<16 | gc.TUINT8,
+ gc.OLT<<16 | gc.TUINT16,
+ gc.OLT<<16 | gc.TUINT32,
+ gc.OLT<<16 | gc.TUINT64:
+ a = arm.ABLO
+
+ case gc.OLE<<16 | gc.TINT8,
+ gc.OLE<<16 | gc.TINT16,
+ gc.OLE<<16 | gc.TINT32,
+ gc.OLE<<16 | gc.TINT64,
+ gc.OLE<<16 | gc.TFLOAT32,
+ gc.OLE<<16 | gc.TFLOAT64:
+ a = arm.ABLE
+
+ case gc.OLE<<16 | gc.TUINT8,
+ gc.OLE<<16 | gc.TUINT16,
+ gc.OLE<<16 | gc.TUINT32,
+ gc.OLE<<16 | gc.TUINT64:
+ a = arm.ABLS
+
+ case gc.OGT<<16 | gc.TINT8,
+ gc.OGT<<16 | gc.TINT16,
+ gc.OGT<<16 | gc.TINT32,
+ gc.OGT<<16 | gc.TINT64,
+ gc.OGT<<16 | gc.TFLOAT32,
+ gc.OGT<<16 | gc.TFLOAT64:
+ a = arm.ABGT
+
+ case gc.OGT<<16 | gc.TUINT8,
+ gc.OGT<<16 | gc.TUINT16,
+ gc.OGT<<16 | gc.TUINT32,
+ gc.OGT<<16 | gc.TUINT64:
+ a = arm.ABHI
+
+ case gc.OGE<<16 | gc.TINT8,
+ gc.OGE<<16 | gc.TINT16,
+ gc.OGE<<16 | gc.TINT32,
+ gc.OGE<<16 | gc.TINT64,
+ gc.OGE<<16 | gc.TFLOAT32,
+ gc.OGE<<16 | gc.TFLOAT64:
+ a = arm.ABGE
+
+ case gc.OGE<<16 | gc.TUINT8,
+ gc.OGE<<16 | gc.TUINT16,
+ gc.OGE<<16 | gc.TUINT32,
+ gc.OGE<<16 | gc.TUINT64:
+ a = arm.ABHS
+
+ case gc.OCMP<<16 | gc.TBOOL,
+ gc.OCMP<<16 | gc.TINT8,
+ gc.OCMP<<16 | gc.TUINT8,
+ gc.OCMP<<16 | gc.TINT16,
+ gc.OCMP<<16 | gc.TUINT16,
+ gc.OCMP<<16 | gc.TINT32,
+ gc.OCMP<<16 | gc.TUINT32,
+ gc.OCMP<<16 | gc.TPTR32:
+ a = arm.ACMP
+
+ case gc.OCMP<<16 | gc.TFLOAT32:
+ a = arm.ACMPF
+
+ case gc.OCMP<<16 | gc.TFLOAT64:
+ a = arm.ACMPD
+
+ case gc.OAS<<16 | gc.TBOOL:
+ a = arm.AMOVB
+
+ case gc.OAS<<16 | gc.TINT8:
+ a = arm.AMOVBS
+
+ case gc.OAS<<16 | gc.TUINT8:
+ a = arm.AMOVBU
+
+ case gc.OAS<<16 | gc.TINT16:
+ a = arm.AMOVHS
+
+ case gc.OAS<<16 | gc.TUINT16:
+ a = arm.AMOVHU
+
+ case gc.OAS<<16 | gc.TINT32,
+ gc.OAS<<16 | gc.TUINT32,
+ gc.OAS<<16 | gc.TPTR32:
+ a = arm.AMOVW
+
+ case gc.OAS<<16 | gc.TFLOAT32:
+ a = arm.AMOVF
+
+ case gc.OAS<<16 | gc.TFLOAT64:
+ a = arm.AMOVD
+
+ case gc.OADD<<16 | gc.TINT8,
+ gc.OADD<<16 | gc.TUINT8,
+ gc.OADD<<16 | gc.TINT16,
+ gc.OADD<<16 | gc.TUINT16,
+ gc.OADD<<16 | gc.TINT32,
+ gc.OADD<<16 | gc.TUINT32,
+ gc.OADD<<16 | gc.TPTR32:
+ a = arm.AADD
+
+ case gc.OADD<<16 | gc.TFLOAT32:
+ a = arm.AADDF
+
+ case gc.OADD<<16 | gc.TFLOAT64:
+ a = arm.AADDD
+
+ case gc.OSUB<<16 | gc.TINT8,
+ gc.OSUB<<16 | gc.TUINT8,
+ gc.OSUB<<16 | gc.TINT16,
+ gc.OSUB<<16 | gc.TUINT16,
+ gc.OSUB<<16 | gc.TINT32,
+ gc.OSUB<<16 | gc.TUINT32,
+ gc.OSUB<<16 | gc.TPTR32:
+ a = arm.ASUB
+
+ case gc.OSUB<<16 | gc.TFLOAT32:
+ a = arm.ASUBF
+
+ case gc.OSUB<<16 | gc.TFLOAT64:
+ a = arm.ASUBD
+
+ case gc.OMINUS<<16 | gc.TINT8,
+ gc.OMINUS<<16 | gc.TUINT8,
+ gc.OMINUS<<16 | gc.TINT16,
+ gc.OMINUS<<16 | gc.TUINT16,
+ gc.OMINUS<<16 | gc.TINT32,
+ gc.OMINUS<<16 | gc.TUINT32,
+ gc.OMINUS<<16 | gc.TPTR32:
+ a = arm.ARSB
+
+ case gc.OAND<<16 | gc.TINT8,
+ gc.OAND<<16 | gc.TUINT8,
+ gc.OAND<<16 | gc.TINT16,
+ gc.OAND<<16 | gc.TUINT16,
+ gc.OAND<<16 | gc.TINT32,
+ gc.OAND<<16 | gc.TUINT32,
+ gc.OAND<<16 | gc.TPTR32:
+ a = arm.AAND
+
+ case gc.OOR<<16 | gc.TINT8,
+ gc.OOR<<16 | gc.TUINT8,
+ gc.OOR<<16 | gc.TINT16,
+ gc.OOR<<16 | gc.TUINT16,
+ gc.OOR<<16 | gc.TINT32,
+ gc.OOR<<16 | gc.TUINT32,
+ gc.OOR<<16 | gc.TPTR32:
+ a = arm.AORR
+
+ case gc.OXOR<<16 | gc.TINT8,
+ gc.OXOR<<16 | gc.TUINT8,
+ gc.OXOR<<16 | gc.TINT16,
+ gc.OXOR<<16 | gc.TUINT16,
+ gc.OXOR<<16 | gc.TINT32,
+ gc.OXOR<<16 | gc.TUINT32,
+ gc.OXOR<<16 | gc.TPTR32:
+ a = arm.AEOR
+
+ case gc.OLSH<<16 | gc.TINT8,
+ gc.OLSH<<16 | gc.TUINT8,
+ gc.OLSH<<16 | gc.TINT16,
+ gc.OLSH<<16 | gc.TUINT16,
+ gc.OLSH<<16 | gc.TINT32,
+ gc.OLSH<<16 | gc.TUINT32,
+ gc.OLSH<<16 | gc.TPTR32:
+ a = arm.ASLL
+
+ case gc.ORSH<<16 | gc.TUINT8,
+ gc.ORSH<<16 | gc.TUINT16,
+ gc.ORSH<<16 | gc.TUINT32,
+ gc.ORSH<<16 | gc.TPTR32:
+ a = arm.ASRL
+
+ case gc.ORSH<<16 | gc.TINT8,
+ gc.ORSH<<16 | gc.TINT16,
+ gc.ORSH<<16 | gc.TINT32:
+ a = arm.ASRA
+
+ case gc.OMUL<<16 | gc.TUINT8,
+ gc.OMUL<<16 | gc.TUINT16,
+ gc.OMUL<<16 | gc.TUINT32,
+ gc.OMUL<<16 | gc.TPTR32:
+ a = arm.AMULU
+
+ case gc.OMUL<<16 | gc.TINT8,
+ gc.OMUL<<16 | gc.TINT16,
+ gc.OMUL<<16 | gc.TINT32:
+ a = arm.AMUL
+
+ case gc.OMUL<<16 | gc.TFLOAT32:
+ a = arm.AMULF
+
+ case gc.OMUL<<16 | gc.TFLOAT64:
+ a = arm.AMULD
+
+ case gc.ODIV<<16 | gc.TUINT8,
+ gc.ODIV<<16 | gc.TUINT16,
+ gc.ODIV<<16 | gc.TUINT32,
+ gc.ODIV<<16 | gc.TPTR32:
+ a = arm.ADIVU
+
+ case gc.ODIV<<16 | gc.TINT8,
+ gc.ODIV<<16 | gc.TINT16,
+ gc.ODIV<<16 | gc.TINT32:
+ a = arm.ADIV
+
+ case gc.OMOD<<16 | gc.TUINT8,
+ gc.OMOD<<16 | gc.TUINT16,
+ gc.OMOD<<16 | gc.TUINT32,
+ gc.OMOD<<16 | gc.TPTR32:
+ a = arm.AMODU
+
+ case gc.OMOD<<16 | gc.TINT8,
+ gc.OMOD<<16 | gc.TINT16,
+ gc.OMOD<<16 | gc.TINT32:
+ a = arm.AMOD
+
+ // case CASE(OEXTEND, TINT16):
+ // a = ACWD;
+ // break;
+
+ // case CASE(OEXTEND, TINT32):
+ // a = ACDQ;
+ // break;
+
+ // case CASE(OEXTEND, TINT64):
+ // a = ACQO;
+ // break;
+
+ case gc.ODIV<<16 | gc.TFLOAT32:
+ a = arm.ADIVF
+
+ case gc.ODIV<<16 | gc.TFLOAT64:
+ a = arm.ADIVD
+ }
+
+ return a
+}
+
+const (
+ ODynam = 1 << 0
+ OPtrto = 1 << 1
+)
+
+var clean [20]gc.Node
+
+var cleani int = 0
+
+func sudoclean() {
+ if clean[cleani-1].Op != gc.OEMPTY {
+ regfree(&clean[cleani-1])
+ }
+ if clean[cleani-2].Op != gc.OEMPTY {
+ regfree(&clean[cleani-2])
+ }
+ cleani -= 2
+}
+
+func dotaddable(n *gc.Node, n1 *gc.Node) int {
+ var o int
+ var oary [10]int64
+ var nn *gc.Node
+
+ if n.Op != gc.ODOT {
+ return 0
+ }
+
+ o = gc.Dotoffset(n, oary[:], &nn)
+ if nn != nil && nn.Addable != 0 && o == 1 && oary[0] >= 0 {
+ *n1 = *nn
+ n1.Type = n.Type
+ n1.Xoffset += oary[0]
+ return 1
+ }
+
+ return 0
+}
+
+/*
+ * generate code to compute address of n,
+ * a reference to a (perhaps nested) field inside
+ * an array or struct.
+ * return 0 on failure, 1 on success.
+ * on success, leaves usable address in a.
+ *
+ * caller is responsible for calling sudoclean
+ * after successful sudoaddable,
+ * to release the register used for a.
+ */
+func sudoaddable(as int, n *gc.Node, a *obj.Addr, w *int) int {
+ var o int
+ var i int
+ var oary [10]int64
+ var v int64
+ var n1 gc.Node
+ var n2 gc.Node
+ var n3 gc.Node
+ var n4 gc.Node
+ var nn *gc.Node
+ var l *gc.Node
+ var r *gc.Node
+ var reg *gc.Node
+ var reg1 *gc.Node
+ var p1 *obj.Prog
+ var p2 *obj.Prog
+ var t *gc.Type
+
+ if n.Type == nil {
+ return 0
+ }
+
+ *a = obj.Addr{}
+
+ switch n.Op {
+ case gc.OLITERAL:
+ if !(gc.Isconst(n, gc.CTINT) != 0) {
+ break
+ }
+ v = gc.Mpgetfix(n.Val.U.Xval)
+ if v >= 32000 || v <= -32000 {
+ break
+ }
+ goto lit
+
+ case gc.ODOT,
+ gc.ODOTPTR:
+ cleani += 2
+ reg = &clean[cleani-1]
+ reg1 = &clean[cleani-2]
+ reg.Op = gc.OEMPTY
+ reg1.Op = gc.OEMPTY
+ goto odot
+
+ case gc.OINDEX:
+ return 0
+
+ // disabled: OINDEX case is now covered by agenr
+ // for a more suitable register allocation pattern.
+ if n.Left.Type.Etype == gc.TSTRING {
+ return 0
+ }
+ cleani += 2
+ reg = &clean[cleani-1]
+ reg1 = &clean[cleani-2]
+ reg.Op = gc.OEMPTY
+ reg1.Op = gc.OEMPTY
+ goto oindex
+ }
+
+ return 0
+
+lit:
+ switch as {
+ default:
+ return 0
+
+ case arm.AADD,
+ arm.ASUB,
+ arm.AAND,
+ arm.AORR,
+ arm.AEOR,
+ arm.AMOVB,
+ arm.AMOVBS,
+ arm.AMOVBU,
+ arm.AMOVH,
+ arm.AMOVHS,
+ arm.AMOVHU,
+ arm.AMOVW:
+ break
+ }
+
+ cleani += 2
+ reg = &clean[cleani-1]
+ reg1 = &clean[cleani-2]
+ reg.Op = gc.OEMPTY
+ reg1.Op = gc.OEMPTY
+ gc.Naddr(n, a, 1)
+ goto yes
+
+odot:
+ o = gc.Dotoffset(n, oary[:], &nn)
+ if nn == nil {
+ goto no
+ }
+
+ if nn.Addable != 0 && o == 1 && oary[0] >= 0 {
+ // directly addressable set of DOTs
+ n1 = *nn
+
+ n1.Type = n.Type
+ n1.Xoffset += oary[0]
+ gc.Naddr(&n1, a, 1)
+ goto yes
+ }
+
+ regalloc(reg, gc.Types[gc.Tptr], nil)
+ n1 = *reg
+ n1.Op = gc.OINDREG
+ if oary[0] >= 0 {
+ agen(nn, reg)
+ n1.Xoffset = oary[0]
+ } else {
+ cgen(nn, reg)
+ gc.Cgen_checknil(reg)
+ n1.Xoffset = -(oary[0] + 1)
+ }
+
+ for i = 1; i < o; i++ {
+ if oary[i] >= 0 {
+ gc.Fatal("can't happen")
+ }
+ gins(arm.AMOVW, &n1, reg)
+ gc.Cgen_checknil(reg)
+ n1.Xoffset = -(oary[i] + 1)
+ }
+
+ a.Type = obj.TYPE_NONE
+ a.Name = obj.NAME_NONE
+ n1.Type = n.Type
+ gc.Naddr(&n1, a, 1)
+ goto yes
+
+oindex:
+ l = n.Left
+ r = n.Right
+ if l.Ullman >= gc.UINF && r.Ullman >= gc.UINF {
+ goto no
+ }
+
+ // set o to type of array
+ o = 0
+
+ if gc.Isptr[l.Type.Etype] != 0 {
+ o += OPtrto
+ if l.Type.Type.Etype != gc.TARRAY {
+ gc.Fatal("not ptr ary")
+ }
+ if l.Type.Type.Bound < 0 {
+ o += ODynam
+ }
+ } else {
+ if l.Type.Etype != gc.TARRAY {
+ gc.Fatal("not ary")
+ }
+ if l.Type.Bound < 0 {
+ o += ODynam
+ }
+ }
+
+ *w = int(n.Type.Width)
+ if gc.Isconst(r, gc.CTINT) != 0 {
+ goto oindex_const
+ }
+
+ switch *w {
+ default:
+ goto no
+
+ case 1,
+ 2,
+ 4,
+ 8:
+ break
+ }
+
+ // load the array (reg)
+ if l.Ullman > r.Ullman {
+ regalloc(reg, gc.Types[gc.Tptr], nil)
+ if o&OPtrto != 0 {
+ cgen(l, reg)
+ gc.Cgen_checknil(reg)
+ } else {
+ agen(l, reg)
+ }
+ }
+
+ // load the index (reg1)
+ t = gc.Types[gc.TUINT32]
+
+ if gc.Issigned[r.Type.Etype] != 0 {
+ t = gc.Types[gc.TINT32]
+ }
+ regalloc(reg1, t, nil)
+ regalloc(&n3, gc.Types[gc.TINT32], reg1)
+ p2 = cgenindex(r, &n3, bool2int(gc.Debug['B'] != 0 || n.Bounded != 0))
+ gmove(&n3, reg1)
+ regfree(&n3)
+
+ // load the array (reg)
+ if l.Ullman <= r.Ullman {
+ regalloc(reg, gc.Types[gc.Tptr], nil)
+ if o&OPtrto != 0 {
+ cgen(l, reg)
+ gc.Cgen_checknil(reg)
+ } else {
+ agen(l, reg)
+ }
+ }
+
+ // check bounds
+ if !(gc.Debug['B'] != 0) {
+ if o&ODynam != 0 {
+ n2 = *reg
+ n2.Op = gc.OINDREG
+ n2.Type = gc.Types[gc.Tptr]
+ n2.Xoffset = int64(gc.Array_nel)
+ } else {
+ if o&OPtrto != 0 {
+ gc.Nodconst(&n2, gc.Types[gc.TUINT32], l.Type.Type.Bound)
+ } else {
+ gc.Nodconst(&n2, gc.Types[gc.TUINT32], l.Type.Bound)
+ }
+ }
+
+ regalloc(&n3, n2.Type, nil)
+ cgen(&n2, &n3)
+ gcmp(optoas(gc.OCMP, gc.Types[gc.TUINT32]), reg1, &n3)
+ regfree(&n3)
+ p1 = gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TUINT32]), nil, +1)
+ if p2 != nil {
+ gc.Patch(p2, gc.Pc)
+ }
+ ginscall(gc.Panicindex, 0)
+ gc.Patch(p1, gc.Pc)
+ }
+
+ if o&ODynam != 0 {
+ n2 = *reg
+ n2.Op = gc.OINDREG
+ n2.Type = gc.Types[gc.Tptr]
+ n2.Xoffset = int64(gc.Array_array)
+ gmove(&n2, reg)
+ }
+
+ switch *w {
+ case 1:
+ gins(arm.AADD, reg1, reg)
+
+ case 2:
+ gshift(arm.AADD, reg1, arm.SHIFT_LL, 1, reg)
+
+ case 4:
+ gshift(arm.AADD, reg1, arm.SHIFT_LL, 2, reg)
+
+ case 8:
+ gshift(arm.AADD, reg1, arm.SHIFT_LL, 3, reg)
+ }
+
+ gc.Naddr(reg1, a, 1)
+ a.Type = obj.TYPE_MEM
+ a.Reg = reg.Val.U.Reg
+ a.Offset = 0
+ goto yes
+
+ // index is constant
+ // can check statically and
+ // can multiply by width statically
+
+oindex_const:
+ regalloc(reg, gc.Types[gc.Tptr], nil)
+
+ if o&OPtrto != 0 {
+ cgen(l, reg)
+ gc.Cgen_checknil(reg)
+ } else {
+ agen(l, reg)
+ }
+
+ v = gc.Mpgetfix(r.Val.U.Xval)
+ if o&ODynam != 0 {
+ if !(gc.Debug['B'] != 0) && !(n.Bounded != 0) {
+ n1 = *reg
+ n1.Op = gc.OINDREG
+ n1.Type = gc.Types[gc.Tptr]
+ n1.Xoffset = int64(gc.Array_nel)
+ gc.Nodconst(&n2, gc.Types[gc.TUINT32], v)
+ regalloc(&n3, gc.Types[gc.TUINT32], nil)
+ cgen(&n2, &n3)
+ regalloc(&n4, n1.Type, nil)
+ cgen(&n1, &n4)
+ gcmp(optoas(gc.OCMP, gc.Types[gc.TUINT32]), &n4, &n3)
+ regfree(&n4)
+ regfree(&n3)
+ p1 = gc.Gbranch(optoas(gc.OGT, gc.Types[gc.TUINT32]), nil, +1)
+ ginscall(gc.Panicindex, 0)
+ gc.Patch(p1, gc.Pc)
+ }
+
+ n1 = *reg
+ n1.Op = gc.OINDREG
+ n1.Type = gc.Types[gc.Tptr]
+ n1.Xoffset = int64(gc.Array_array)
+ gmove(&n1, reg)
+ }
+
+ n2 = *reg
+ n2.Op = gc.OINDREG
+ n2.Xoffset = v * int64(*w)
+ a.Type = obj.TYPE_NONE
+ a.Name = obj.NAME_NONE
+ gc.Naddr(&n2, a, 1)
+ goto yes
+
+yes:
+ return 1
+
+no:
+ sudoclean()
+ return 0
+}
--- /dev/null
+// Inferno utils/5c/peep.c
+// http://code.google.com/p/inferno-os/source/browse/utils/5c/peep.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 main
+
+import (
+ "cmd/internal/obj"
+ "cmd/internal/obj/arm"
+ "fmt"
+)
+import "cmd/internal/gc"
+
+var gactive uint32
+
+// UNUSED
+func peep(firstp *obj.Prog) {
+ var r *gc.Flow
+ var g *gc.Graph
+ var p *obj.Prog
+ var t int
+
+ g = gc.Flowstart(firstp, nil)
+ if g == nil {
+ return
+ }
+ gactive = 0
+
+loop1:
+ if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 {
+ gc.Dumpit("loop1", g.Start, 0)
+ }
+
+ t = 0
+ for r = g.Start; r != nil; r = r.Link {
+ p = r.Prog
+ switch p.As {
+ /*
+ * elide shift into TYPE_SHIFT operand of subsequent instruction
+ */
+ // if(shiftprop(r)) {
+ // excise(r);
+ // t++;
+ // break;
+ // }
+ case arm.ASLL,
+ arm.ASRL,
+ arm.ASRA:
+ break
+
+ case arm.AMOVB,
+ arm.AMOVH,
+ arm.AMOVW,
+ arm.AMOVF,
+ arm.AMOVD:
+ if regtyp(&p.From) != 0 {
+ if p.From.Type == p.To.Type && isfloatreg(&p.From) == isfloatreg(&p.To) {
+ if p.Scond == arm.C_SCOND_NONE {
+ if copyprop(g, r) != 0 {
+ excise(r)
+ t++
+ break
+ }
+
+ if subprop(r) != 0 && copyprop(g, r) != 0 {
+ excise(r)
+ t++
+ break
+ }
+ }
+ }
+ }
+
+ case arm.AMOVHS,
+ arm.AMOVHU,
+ arm.AMOVBS,
+ arm.AMOVBU:
+ if p.From.Type == obj.TYPE_REG {
+ if shortprop(r) != 0 {
+ t++
+ }
+ }
+ }
+ }
+
+ /*
+ if(p->scond == C_SCOND_NONE)
+ if(regtyp(&p->to))
+ if(isdconst(&p->from)) {
+ constprop(&p->from, &p->to, r->s1);
+ }
+ break;
+ */
+ if t != 0 {
+ goto loop1
+ }
+
+ for r = g.Start; r != nil; r = r.Link {
+ p = r.Prog
+ switch p.As {
+ /*
+ * EOR -1,x,y => MVN x,y
+ */
+ case arm.AEOR:
+ if isdconst(&p.From) != 0 && p.From.Offset == -1 {
+ p.As = arm.AMVN
+ p.From.Type = obj.TYPE_REG
+ if p.Reg != 0 {
+ p.From.Reg = p.Reg
+ } else {
+ p.From.Reg = p.To.Reg
+ }
+ p.Reg = 0
+ }
+ }
+ }
+
+ for r = g.Start; r != nil; r = r.Link {
+ p = r.Prog
+ switch p.As {
+ case arm.AMOVW,
+ arm.AMOVB,
+ arm.AMOVBS,
+ arm.AMOVBU:
+ if p.From.Type == obj.TYPE_MEM && p.From.Offset == 0 {
+ xtramodes(g, r, &p.From)
+ } else if p.To.Type == obj.TYPE_MEM && p.To.Offset == 0 {
+ xtramodes(g, r, &p.To)
+ } else {
+ continue
+ }
+ }
+ }
+
+ // case ACMP:
+ // /*
+ // * elide CMP $0,x if calculation of x can set condition codes
+ // */
+ // if(isdconst(&p->from) || p->from.offset != 0)
+ // continue;
+ // r2 = r->s1;
+ // if(r2 == nil)
+ // continue;
+ // t = r2->prog->as;
+ // switch(t) {
+ // default:
+ // continue;
+ // case ABEQ:
+ // case ABNE:
+ // case ABMI:
+ // case ABPL:
+ // break;
+ // case ABGE:
+ // t = ABPL;
+ // break;
+ // case ABLT:
+ // t = ABMI;
+ // break;
+ // case ABHI:
+ // t = ABNE;
+ // break;
+ // case ABLS:
+ // t = ABEQ;
+ // break;
+ // }
+ // r1 = r;
+ // do
+ // r1 = uniqp(r1);
+ // while (r1 != nil && r1->prog->as == ANOP);
+ // if(r1 == nil)
+ // continue;
+ // p1 = r1->prog;
+ // if(p1->to.type != TYPE_REG)
+ // continue;
+ // if(p1->to.reg != p->reg)
+ // if(!(p1->as == AMOVW && p1->from.type == TYPE_REG && p1->from.reg == p->reg))
+ // continue;
+ //
+ // switch(p1->as) {
+ // default:
+ // continue;
+ // case AMOVW:
+ // if(p1->from.type != TYPE_REG)
+ // continue;
+ // case AAND:
+ // case AEOR:
+ // case AORR:
+ // case ABIC:
+ // case AMVN:
+ // case ASUB:
+ // case ARSB:
+ // case AADD:
+ // case AADC:
+ // case ASBC:
+ // case ARSC:
+ // break;
+ // }
+ // p1->scond |= C_SBIT;
+ // r2->prog->as = t;
+ // excise(r);
+ // continue;
+
+ // predicate(g);
+
+ gc.Flowend(g)
+}
+
+func regtyp(a *obj.Addr) int {
+ return bool2int(a.Type == obj.TYPE_REG && (arm.REG_R0 <= a.Reg && a.Reg <= arm.REG_R15 || arm.REG_F0 <= a.Reg && a.Reg <= arm.REG_F15))
+}
+
+/*
+ * the idea is to substitute
+ * one register for another
+ * from one MOV to another
+ * MOV a, R0
+ * ADD b, R0 / no use of R1
+ * MOV R0, R1
+ * would be converted to
+ * MOV a, R1
+ * ADD b, R1
+ * MOV R1, R0
+ * hopefully, then the former or latter MOV
+ * will be eliminated by copy propagation.
+ */
+func subprop(r0 *gc.Flow) int {
+ var p *obj.Prog
+ var v1 *obj.Addr
+ var v2 *obj.Addr
+ var r *gc.Flow
+ var t int
+ var info gc.ProgInfo
+
+ p = r0.Prog
+ v1 = &p.From
+ if !(regtyp(v1) != 0) {
+ return 0
+ }
+ v2 = &p.To
+ if !(regtyp(v2) != 0) {
+ return 0
+ }
+ for r = gc.Uniqp(r0); r != nil; r = gc.Uniqp(r) {
+ if gc.Uniqs(r) == nil {
+ break
+ }
+ p = r.Prog
+ if p.As == obj.AVARDEF || p.As == obj.AVARKILL {
+ continue
+ }
+ proginfo(&info, p)
+ if info.Flags&gc.Call != 0 {
+ return 0
+ }
+
+ if (info.Flags&gc.CanRegRead != 0) && p.To.Type == obj.TYPE_REG {
+ info.Flags |= gc.RegRead
+ info.Flags &^= (gc.CanRegRead | gc.RightRead)
+ p.Reg = p.To.Reg
+ }
+
+ switch p.As {
+ case arm.AMULLU,
+ arm.AMULA,
+ arm.AMVN:
+ return 0
+ }
+
+ if info.Flags&(gc.RightRead|gc.RightWrite) == gc.RightWrite {
+ if p.To.Type == v1.Type {
+ if p.To.Reg == v1.Reg {
+ if p.Scond == arm.C_SCOND_NONE {
+ goto gotit
+ }
+ }
+ }
+ }
+
+ if copyau(&p.From, v2) != 0 || copyau1(p, v2) != 0 || copyau(&p.To, v2) != 0 {
+ break
+ }
+ if copysub(&p.From, v1, v2, 0) != 0 || copysub1(p, v1, v2, 0) != 0 || copysub(&p.To, v1, v2, 0) != 0 {
+ break
+ }
+ }
+
+ return 0
+
+gotit:
+ copysub(&p.To, v1, v2, 1)
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("gotit: %v->%v\n%v", gc.Ctxt.Dconv(v1), gc.Ctxt.Dconv(v2), r.Prog)
+ if p.From.Type == v2.Type {
+ fmt.Printf(" excise")
+ }
+ fmt.Printf("\n")
+ }
+
+ for r = gc.Uniqs(r); r != r0; r = gc.Uniqs(r) {
+ p = r.Prog
+ copysub(&p.From, v1, v2, 1)
+ copysub1(p, v1, v2, 1)
+ copysub(&p.To, v1, v2, 1)
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("%v\n", r.Prog)
+ }
+ }
+
+ t = int(v1.Reg)
+ v1.Reg = v2.Reg
+ v2.Reg = int16(t)
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("%v last\n", r.Prog)
+ }
+ return 1
+}
+
+/*
+ * The idea is to remove redundant copies.
+ * v1->v2 F=0
+ * (use v2 s/v2/v1/)*
+ * set v1 F=1
+ * use v2 return fail
+ * -----------------
+ * v1->v2 F=0
+ * (use v2 s/v2/v1/)*
+ * set v1 F=1
+ * set v2 return success
+ */
+func copyprop(g *gc.Graph, r0 *gc.Flow) int {
+ var p *obj.Prog
+ var v1 *obj.Addr
+ var v2 *obj.Addr
+
+ p = r0.Prog
+ v1 = &p.From
+ v2 = &p.To
+ if copyas(v1, v2) != 0 {
+ return 1
+ }
+ gactive++
+ return copy1(v1, v2, r0.S1, 0)
+}
+
+func copy1(v1 *obj.Addr, v2 *obj.Addr, r *gc.Flow, f int) int {
+ var t int
+ var p *obj.Prog
+
+ if uint32(r.Active) == gactive {
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("act set; return 1\n")
+ }
+ return 1
+ }
+
+ r.Active = int32(gactive)
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("copy %v->%v f=%d\n", gc.Ctxt.Dconv(v1), gc.Ctxt.Dconv(v2), f)
+ }
+ for ; r != nil; r = r.S1 {
+ p = r.Prog
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("%v", p)
+ }
+ if !(f != 0) && gc.Uniqp(r) == nil {
+ f = 1
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("; merge; f=%d", f)
+ }
+ }
+
+ t = copyu(p, v2, nil)
+ switch t {
+ case 2: /* rar, can't split */
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("; %vrar; return 0\n", gc.Ctxt.Dconv(v2))
+ }
+ return 0
+
+ case 3: /* set */
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("; %vset; return 1\n", gc.Ctxt.Dconv(v2))
+ }
+ return 1
+
+ case 1, /* used, substitute */
+ 4: /* use and set */
+ if f != 0 {
+ if !(gc.Debug['P'] != 0) {
+ return 0
+ }
+ if t == 4 {
+ fmt.Printf("; %vused+set and f=%d; return 0\n", gc.Ctxt.Dconv(v2), f)
+ } else {
+ fmt.Printf("; %vused and f=%d; return 0\n", gc.Ctxt.Dconv(v2), f)
+ }
+ return 0
+ }
+
+ if copyu(p, v2, v1) != 0 {
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("; sub fail; return 0\n")
+ }
+ return 0
+ }
+
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("; sub%v/%v", gc.Ctxt.Dconv(v2), gc.Ctxt.Dconv(v1))
+ }
+ if t == 4 {
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("; %vused+set; return 1\n", gc.Ctxt.Dconv(v2))
+ }
+ return 1
+ }
+ }
+
+ if !(f != 0) {
+ t = copyu(p, v1, nil)
+ if !(f != 0) && (t == 2 || t == 3 || t == 4) {
+ f = 1
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("; %vset and !f; f=%d", gc.Ctxt.Dconv(v1), f)
+ }
+ }
+ }
+
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("\n")
+ }
+ if r.S2 != nil {
+ if !(copy1(v1, v2, r.S2, f) != 0) {
+ return 0
+ }
+ }
+ }
+
+ return 1
+}
+
+// UNUSED
+/*
+ * The idea is to remove redundant constants.
+ * $c1->v1
+ * ($c1->v2 s/$c1/v1)*
+ * set v1 return
+ * The v1->v2 should be eliminated by copy propagation.
+ */
+func constprop(c1 *obj.Addr, v1 *obj.Addr, r *gc.Flow) {
+ var p *obj.Prog
+
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("constprop %v->%v\n", gc.Ctxt.Dconv(c1), gc.Ctxt.Dconv(v1))
+ }
+ for ; r != nil; r = r.S1 {
+ p = r.Prog
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("%v", p)
+ }
+ if gc.Uniqp(r) == nil {
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("; merge; return\n")
+ }
+ return
+ }
+
+ if p.As == arm.AMOVW && copyas(&p.From, c1) != 0 {
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("; sub%v/%v", gc.Ctxt.Dconv(&p.From), gc.Ctxt.Dconv(v1))
+ }
+ p.From = *v1
+ } else if copyu(p, v1, nil) > 1 {
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("; %vset; return\n", gc.Ctxt.Dconv(v1))
+ }
+ return
+ }
+
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("\n")
+ }
+ if r.S2 != nil {
+ constprop(c1, v1, r.S2)
+ }
+ }
+}
+
+/*
+ * shortprop eliminates redundant zero/sign extensions.
+ *
+ * MOVBS x, R
+ * <no use R>
+ * MOVBS R, R'
+ *
+ * changed to
+ *
+ * MOVBS x, R
+ * ...
+ * MOVB R, R' (compiled to mov)
+ *
+ * MOVBS above can be a MOVBS, MOVBU, MOVHS or MOVHU.
+ */
+func shortprop(r *gc.Flow) int {
+ var p *obj.Prog
+ var p1 *obj.Prog
+ var r1 *gc.Flow
+
+ p = r.Prog
+ r1 = findpre(r, &p.From)
+ if r1 == nil {
+ return 0
+ }
+
+ p1 = r1.Prog
+ if p1.As == p.As {
+ // Two consecutive extensions.
+ goto gotit
+ }
+
+ if p1.As == arm.AMOVW && isdconst(&p1.From) != 0 && p1.From.Offset >= 0 && p1.From.Offset < 128 {
+ // Loaded an immediate.
+ goto gotit
+ }
+
+ return 0
+
+gotit:
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("shortprop\n%v\n%v", p1, p)
+ }
+ switch p.As {
+ case arm.AMOVBS,
+ arm.AMOVBU:
+ p.As = arm.AMOVB
+
+ case arm.AMOVHS,
+ arm.AMOVHU:
+ p.As = arm.AMOVH
+ }
+
+ if gc.Debug['P'] != 0 {
+ fmt.Printf(" => %v\n", arm.Aconv(int(p.As)))
+ }
+ return 1
+}
+
+// UNUSED
+/*
+ * ASLL x,y,w
+ * .. (not use w, not set x y w)
+ * AXXX w,a,b (a != w)
+ * .. (not use w)
+ * (set w)
+ * ----------- changed to
+ * ..
+ * AXXX (x<<y),a,b
+ * ..
+ */
+func shiftprop(r *gc.Flow) int {
+ var r1 *gc.Flow
+ var p *obj.Prog
+ var p1 *obj.Prog
+ var p2 *obj.Prog
+ var n int
+ var o int
+ var a obj.Addr
+
+ p = r.Prog
+ if p.To.Type != obj.TYPE_REG {
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("\tBOTCH: result not reg; FAILURE\n")
+ }
+ return 0
+ }
+
+ n = int(p.To.Reg)
+ a = obj.Zprog.From
+ if p.Reg != 0 && p.Reg != p.To.Reg {
+ a.Type = obj.TYPE_REG
+ a.Reg = p.Reg
+ }
+
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("shiftprop\n%v", p)
+ }
+ r1 = r
+ for {
+ /* find first use of shift result; abort if shift operands or result are changed */
+ r1 = gc.Uniqs(r1)
+
+ if r1 == nil {
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("\tbranch; FAILURE\n")
+ }
+ return 0
+ }
+
+ if gc.Uniqp(r1) == nil {
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("\tmerge; FAILURE\n")
+ }
+ return 0
+ }
+
+ p1 = r1.Prog
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("\n%v", p1)
+ }
+ switch copyu(p1, &p.To, nil) {
+ case 0: /* not used or set */
+ if (p.From.Type == obj.TYPE_REG && copyu(p1, &p.From, nil) > 1) || (a.Type == obj.TYPE_REG && copyu(p1, &a, nil) > 1) {
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("\targs modified; FAILURE\n")
+ }
+ return 0
+ }
+
+ continue
+ case 3: /* set, not used */
+ {
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("\tBOTCH: noref; FAILURE\n")
+ }
+ return 0
+ }
+ }
+
+ break
+ }
+
+ /* check whether substitution can be done */
+ switch p1.As {
+ default:
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("\tnon-dpi; FAILURE\n")
+ }
+ return 0
+
+ case arm.AAND,
+ arm.AEOR,
+ arm.AADD,
+ arm.AADC,
+ arm.AORR,
+ arm.ASUB,
+ arm.ASBC,
+ arm.ARSB,
+ arm.ARSC:
+ if int(p1.Reg) == n || (p1.Reg == 0 && p1.To.Type == obj.TYPE_REG && int(p1.To.Reg) == n) {
+ if p1.From.Type != obj.TYPE_REG {
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("\tcan't swap; FAILURE\n")
+ }
+ return 0
+ }
+
+ p1.Reg = p1.From.Reg
+ p1.From.Reg = int16(n)
+ switch p1.As {
+ case arm.ASUB:
+ p1.As = arm.ARSB
+
+ case arm.ARSB:
+ p1.As = arm.ASUB
+
+ case arm.ASBC:
+ p1.As = arm.ARSC
+
+ case arm.ARSC:
+ p1.As = arm.ASBC
+ }
+
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("\t=>%v", p1)
+ }
+ }
+ fallthrough
+
+ case arm.ABIC,
+ arm.ATST,
+ arm.ACMP,
+ arm.ACMN:
+ if int(p1.Reg) == n {
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("\tcan't swap; FAILURE\n")
+ }
+ return 0
+ }
+
+ if p1.Reg == 0 && int(p1.To.Reg) == n {
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("\tshift result used twice; FAILURE\n")
+ }
+ return 0
+ }
+
+ // case AMVN:
+ if p1.From.Type == obj.TYPE_SHIFT {
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("\tshift result used in shift; FAILURE\n")
+ }
+ return 0
+ }
+
+ if p1.From.Type != obj.TYPE_REG || int(p1.From.Reg) != n {
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("\tBOTCH: where is it used?; FAILURE\n")
+ }
+ return 0
+ }
+ }
+
+ /* check whether shift result is used subsequently */
+ p2 = p1
+
+ if int(p1.To.Reg) != n {
+ for {
+ r1 = gc.Uniqs(r1)
+ if r1 == nil {
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("\tinconclusive; FAILURE\n")
+ }
+ return 0
+ }
+
+ p1 = r1.Prog
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("\n%v", p1)
+ }
+ switch copyu(p1, &p.To, nil) {
+ case 0: /* not used or set */
+ continue
+
+ case 3: /* set, not used */
+ break
+
+ default: /* used */
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("\treused; FAILURE\n")
+ }
+ return 0
+ }
+
+ break
+ }
+ }
+
+ /* make the substitution */
+ p2.From.Reg = 0
+
+ o = int(p.Reg)
+ if o == 0 {
+ o = int(p.To.Reg)
+ }
+ o &= 15
+
+ switch p.From.Type {
+ case obj.TYPE_CONST:
+ o |= int((p.From.Offset & 0x1f) << 7)
+
+ case obj.TYPE_REG:
+ o |= 1<<4 | (int(p.From.Reg)&15)<<8
+ }
+
+ switch p.As {
+ case arm.ASLL:
+ o |= 0 << 5
+
+ case arm.ASRL:
+ o |= 1 << 5
+
+ case arm.ASRA:
+ o |= 2 << 5
+ }
+
+ p2.From = obj.Zprog.From
+ p2.From.Type = obj.TYPE_SHIFT
+ p2.From.Offset = int64(o)
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("\t=>%v\tSUCCEED\n", p2)
+ }
+ return 1
+}
+
+/*
+ * findpre returns the last instruction mentioning v
+ * before r. It must be a set, and there must be
+ * a unique path from that instruction to r.
+ */
+func findpre(r *gc.Flow, v *obj.Addr) *gc.Flow {
+ var r1 *gc.Flow
+
+ for r1 = gc.Uniqp(r); r1 != nil; (func() { r = r1; r1 = gc.Uniqp(r) })() {
+ if gc.Uniqs(r1) != r {
+ return nil
+ }
+ switch copyu(r1.Prog, v, nil) {
+ case 1, /* used */
+ 2: /* read-alter-rewrite */
+ return nil
+
+ case 3, /* set */
+ 4: /* set and used */
+ return r1
+ }
+ }
+
+ return nil
+}
+
+/*
+ * findinc finds ADD instructions with a constant
+ * argument which falls within the immed_12 range.
+ */
+func findinc(r *gc.Flow, r2 *gc.Flow, v *obj.Addr) *gc.Flow {
+ var r1 *gc.Flow
+ var p *obj.Prog
+
+ for r1 = gc.Uniqs(r); r1 != nil && r1 != r2; (func() { r = r1; r1 = gc.Uniqs(r) })() {
+ if gc.Uniqp(r1) != r {
+ return nil
+ }
+ switch copyu(r1.Prog, v, nil) {
+ case 0: /* not touched */
+ continue
+
+ case 4: /* set and used */
+ p = r1.Prog
+
+ if p.As == arm.AADD {
+ if isdconst(&p.From) != 0 {
+ if p.From.Offset > -4096 && p.From.Offset < 4096 {
+ return r1
+ }
+ }
+ }
+ fallthrough
+
+ default:
+ return nil
+ }
+ }
+
+ return nil
+}
+
+func nochange(r *gc.Flow, r2 *gc.Flow, p *obj.Prog) int {
+ var a [3]obj.Addr
+ var i int
+ var n int
+
+ if r == r2 {
+ return 1
+ }
+ n = 0
+ if p.Reg != 0 && p.Reg != p.To.Reg {
+ a[n].Type = obj.TYPE_REG
+ a[n].Reg = p.Reg
+ n++
+ }
+
+ switch p.From.Type {
+ case obj.TYPE_SHIFT:
+ a[n].Type = obj.TYPE_REG
+ a[n].Reg = int16(arm.REG_R0 + (p.From.Offset & 0xf))
+ n++
+ fallthrough
+
+ case obj.TYPE_REG:
+ a[n].Type = obj.TYPE_REG
+ a[n].Reg = p.From.Reg
+ n++
+ }
+
+ if n == 0 {
+ return 1
+ }
+ for ; r != nil && r != r2; r = gc.Uniqs(r) {
+ p = r.Prog
+ for i = 0; i < n; i++ {
+ if copyu(p, &a[i], nil) > 1 {
+ return 0
+ }
+ }
+ }
+
+ return 1
+}
+
+func findu1(r *gc.Flow, v *obj.Addr) int {
+ for ; r != nil; r = r.S1 {
+ if r.Active != 0 {
+ return 0
+ }
+ r.Active = 1
+ switch copyu(r.Prog, v, nil) {
+ case 1, /* used */
+ 2, /* read-alter-rewrite */
+ 4: /* set and used */
+ return 1
+
+ case 3: /* set */
+ return 0
+ }
+
+ if r.S2 != nil {
+ if findu1(r.S2, v) != 0 {
+ return 1
+ }
+ }
+ }
+
+ return 0
+}
+
+func finduse(g *gc.Graph, r *gc.Flow, v *obj.Addr) int {
+ var r1 *gc.Flow
+
+ for r1 = g.Start; r1 != nil; r1 = r1.Link {
+ r1.Active = 0
+ }
+ return findu1(r, v)
+}
+
+/*
+ * xtramodes enables the ARM post increment and
+ * shift offset addressing modes to transform
+ * MOVW 0(R3),R1
+ * ADD $4,R3,R3
+ * into
+ * MOVW.P 4(R3),R1
+ * and
+ * ADD R0,R1
+ * MOVBU 0(R1),R0
+ * into
+ * MOVBU R0<<0(R1),R0
+ */
+func xtramodes(g *gc.Graph, r *gc.Flow, a *obj.Addr) int {
+ var r1 *gc.Flow
+ var r2 *gc.Flow
+ var r3 *gc.Flow
+ var p *obj.Prog
+ var p1 *obj.Prog
+ var v obj.Addr
+
+ p = r.Prog
+ v = *a
+ v.Type = obj.TYPE_REG
+ r1 = findpre(r, &v)
+ if r1 != nil {
+ p1 = r1.Prog
+ if p1.To.Type == obj.TYPE_REG && p1.To.Reg == v.Reg {
+ switch p1.As {
+ case arm.AADD:
+ if p1.Scond&arm.C_SBIT != 0 {
+ // avoid altering ADD.S/ADC sequences.
+ break
+ }
+
+ if p1.From.Type == obj.TYPE_REG || (p1.From.Type == obj.TYPE_SHIFT && p1.From.Offset&(1<<4) == 0 && ((p.As != arm.AMOVB && p.As != arm.AMOVBS) || (a == &p.From && p1.From.Offset&^0xf == 0))) || ((p1.From.Type == obj.TYPE_ADDR || p1.From.Type == obj.TYPE_CONST) && p1.From.Offset > -4096 && p1.From.Offset < 4096) {
+ if nochange(gc.Uniqs(r1), r, p1) != 0 {
+ if a != &p.From || v.Reg != p.To.Reg {
+ if finduse(g, r.S1, &v) != 0 {
+ if p1.Reg == 0 || p1.Reg == v.Reg {
+ /* pre-indexing */
+ p.Scond |= arm.C_WBIT
+ } else {
+ return 0
+ }
+ }
+ }
+
+ switch p1.From.Type {
+ /* register offset */
+ case obj.TYPE_REG:
+ if gc.Nacl {
+ return 0
+ }
+ *a = obj.Zprog.From
+ a.Type = obj.TYPE_SHIFT
+ a.Offset = int64(p1.From.Reg) & 15
+
+ /* scaled register offset */
+ case obj.TYPE_SHIFT:
+ if gc.Nacl {
+ return 0
+ }
+ *a = obj.Zprog.From
+ a.Type = obj.TYPE_SHIFT
+ fallthrough
+
+ /* immediate offset */
+ case obj.TYPE_CONST,
+ obj.TYPE_ADDR:
+ a.Offset = p1.From.Offset
+ }
+
+ if p1.Reg != 0 {
+ a.Reg = p1.Reg
+ }
+ excise(r1)
+ return 1
+ }
+ }
+
+ case arm.AMOVW:
+ if p1.From.Type == obj.TYPE_REG {
+ r2 = findinc(r1, r, &p1.From)
+ if r2 != nil {
+ for r3 = gc.Uniqs(r2); r3.Prog.As == obj.ANOP; r3 = gc.Uniqs(r3) {
+ }
+ if r3 == r {
+ /* post-indexing */
+ p1 = r2.Prog
+
+ a.Reg = p1.To.Reg
+ a.Offset = p1.From.Offset
+ p.Scond |= arm.C_PBIT
+ if !(finduse(g, r, &r1.Prog.To) != 0) {
+ excise(r1)
+ }
+ excise(r2)
+ return 1
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if a != &p.From || a.Reg != p.To.Reg {
+ r1 = findinc(r, nil, &v)
+ if r1 != nil {
+ /* post-indexing */
+ p1 = r1.Prog
+
+ a.Offset = p1.From.Offset
+ p.Scond |= arm.C_PBIT
+ excise(r1)
+ return 1
+ }
+ }
+
+ return 0
+}
+
+/*
+ * return
+ * 1 if v only used (and substitute),
+ * 2 if read-alter-rewrite
+ * 3 if set
+ * 4 if set and used
+ * 0 otherwise (not touched)
+ */
+func copyu(p *obj.Prog, v *obj.Addr, s *obj.Addr) int {
+ switch p.As {
+ default:
+ fmt.Printf("copyu: can't find %v\n", arm.Aconv(int(p.As)))
+ return 2
+
+ case arm.AMOVM:
+ if v.Type != obj.TYPE_REG {
+ return 0
+ }
+ if p.From.Type == obj.TYPE_CONST { /* read reglist, read/rar */
+ if s != nil {
+ if p.From.Offset&(1<<uint(v.Reg)) != 0 {
+ return 1
+ }
+ if copysub(&p.To, v, s, 1) != 0 {
+ return 1
+ }
+ return 0
+ }
+
+ if copyau(&p.To, v) != 0 {
+ if p.Scond&arm.C_WBIT != 0 {
+ return 2
+ }
+ return 1
+ }
+
+ if p.From.Offset&(1<<uint(v.Reg)) != 0 {
+ return 1 /* read/rar, write reglist */
+ }
+ } else {
+ if s != nil {
+ if p.To.Offset&(1<<uint(v.Reg)) != 0 {
+ return 1
+ }
+ if copysub(&p.From, v, s, 1) != 0 {
+ return 1
+ }
+ return 0
+ }
+
+ if copyau(&p.From, v) != 0 {
+ if p.Scond&arm.C_WBIT != 0 {
+ return 2
+ }
+ if p.To.Offset&(1<<uint(v.Reg)) != 0 {
+ return 4
+ }
+ return 1
+ }
+
+ if p.To.Offset&(1<<uint(v.Reg)) != 0 {
+ return 3
+ }
+ }
+
+ return 0
+
+ case obj.ANOP, /* read,, write */
+ arm.AMOVW,
+ arm.AMOVF,
+ arm.AMOVD,
+ arm.AMOVH,
+ arm.AMOVHS,
+ arm.AMOVHU,
+ arm.AMOVB,
+ arm.AMOVBS,
+ arm.AMOVBU,
+ arm.AMOVFW,
+ arm.AMOVWF,
+ arm.AMOVDW,
+ arm.AMOVWD,
+ arm.AMOVFD,
+ arm.AMOVDF:
+ if p.Scond&(arm.C_WBIT|arm.C_PBIT) != 0 {
+ if v.Type == obj.TYPE_REG {
+ if p.From.Type == obj.TYPE_MEM || p.From.Type == obj.TYPE_SHIFT {
+ if p.From.Reg == v.Reg {
+ return 2
+ }
+ } else {
+ if p.To.Reg == v.Reg {
+ return 2
+ }
+ }
+ }
+ }
+
+ if s != nil {
+ if copysub(&p.From, v, s, 1) != 0 {
+ return 1
+ }
+ if !(copyas(&p.To, v) != 0) {
+ if copysub(&p.To, v, s, 1) != 0 {
+ return 1
+ }
+ }
+ return 0
+ }
+
+ if copyas(&p.To, v) != 0 {
+ if p.Scond != arm.C_SCOND_NONE {
+ return 2
+ }
+ if copyau(&p.From, v) != 0 {
+ return 4
+ }
+ return 3
+ }
+
+ if copyau(&p.From, v) != 0 {
+ return 1
+ }
+ if copyau(&p.To, v) != 0 {
+ return 1
+ }
+ return 0
+
+ case arm.AMULLU, /* read, read, write, write */
+ arm.AMULL,
+ arm.AMULA,
+ arm.AMVN:
+ return 2
+
+ case arm.AADD, /* read, read, write */
+ arm.AADC,
+ arm.ASUB,
+ arm.ASBC,
+ arm.ARSB,
+ arm.ASLL,
+ arm.ASRL,
+ arm.ASRA,
+ arm.AORR,
+ arm.AAND,
+ arm.AEOR,
+ arm.AMUL,
+ arm.AMULU,
+ arm.ADIV,
+ arm.ADIVU,
+ arm.AMOD,
+ arm.AMODU,
+ arm.AADDF,
+ arm.AADDD,
+ arm.ASUBF,
+ arm.ASUBD,
+ arm.AMULF,
+ arm.AMULD,
+ arm.ADIVF,
+ arm.ADIVD,
+ obj.ACHECKNIL,
+ /* read */
+ arm.ACMPF, /* read, read, */
+ arm.ACMPD,
+ arm.ACMP,
+ arm.ACMN,
+ arm.ACASE,
+ arm.ATST:
+ /* read,, */
+ if s != nil {
+ if copysub(&p.From, v, s, 1) != 0 {
+ return 1
+ }
+ if copysub1(p, v, s, 1) != 0 {
+ return 1
+ }
+ if !(copyas(&p.To, v) != 0) {
+ if copysub(&p.To, v, s, 1) != 0 {
+ return 1
+ }
+ }
+ return 0
+ }
+
+ if copyas(&p.To, v) != 0 {
+ if p.Scond != arm.C_SCOND_NONE {
+ return 2
+ }
+ if p.Reg == 0 {
+ p.Reg = p.To.Reg
+ }
+ if copyau(&p.From, v) != 0 {
+ return 4
+ }
+ if copyau1(p, v) != 0 {
+ return 4
+ }
+ return 3
+ }
+
+ if copyau(&p.From, v) != 0 {
+ return 1
+ }
+ if copyau1(p, v) != 0 {
+ return 1
+ }
+ if copyau(&p.To, v) != 0 {
+ return 1
+ }
+ return 0
+
+ case arm.ABEQ, /* read, read */
+ arm.ABNE,
+ arm.ABCS,
+ arm.ABHS,
+ arm.ABCC,
+ arm.ABLO,
+ arm.ABMI,
+ arm.ABPL,
+ arm.ABVS,
+ arm.ABVC,
+ arm.ABHI,
+ arm.ABLS,
+ arm.ABGE,
+ arm.ABLT,
+ arm.ABGT,
+ arm.ABLE:
+ if s != nil {
+ if copysub(&p.From, v, s, 1) != 0 {
+ return 1
+ }
+ return copysub1(p, v, s, 1)
+ }
+
+ if copyau(&p.From, v) != 0 {
+ return 1
+ }
+ if copyau1(p, v) != 0 {
+ return 1
+ }
+ return 0
+
+ case arm.AB: /* funny */
+ if s != nil {
+ if copysub(&p.To, v, s, 1) != 0 {
+ return 1
+ }
+ return 0
+ }
+
+ if copyau(&p.To, v) != 0 {
+ return 1
+ }
+ return 0
+
+ case obj.ARET: /* funny */
+ if s != nil {
+ return 1
+ }
+ return 3
+
+ case arm.ABL: /* funny */
+ if v.Type == obj.TYPE_REG {
+ // TODO(rsc): REG_R0 and REG_F0 used to be
+ // (when register numbers started at 0) exregoffset and exfregoffset,
+ // which are unset entirely.
+ // It's strange that this handles R0 and F0 differently from the other
+ // registers. Possible failure to optimize?
+ if arm.REG_R0 < v.Reg && v.Reg <= arm.REGEXT {
+ return 2
+ }
+ if v.Reg == arm.REGARG {
+ return 2
+ }
+ if arm.REG_F0 < v.Reg && v.Reg <= arm.FREGEXT {
+ return 2
+ }
+ }
+
+ if p.From.Type == obj.TYPE_REG && v.Type == obj.TYPE_REG && p.From.Reg == v.Reg {
+ return 2
+ }
+
+ if s != nil {
+ if copysub(&p.To, v, s, 1) != 0 {
+ return 1
+ }
+ return 0
+ }
+
+ if copyau(&p.To, v) != 0 {
+ return 4
+ }
+ return 3
+
+ // R0 is zero, used by DUFFZERO, cannot be substituted.
+ // R1 is ptr to memory, used and set, cannot be substituted.
+ case obj.ADUFFZERO:
+ if v.Type == obj.TYPE_REG {
+ if v.Reg == REGALLOC_R0 {
+ return 1
+ }
+ if v.Reg == REGALLOC_R0+1 {
+ return 2
+ }
+ }
+
+ return 0
+
+ // R0 is scratch, set by DUFFCOPY, cannot be substituted.
+ // R1, R2 areptr to src, dst, used and set, cannot be substituted.
+ case obj.ADUFFCOPY:
+ if v.Type == obj.TYPE_REG {
+ if v.Reg == REGALLOC_R0 {
+ return 3
+ }
+ if v.Reg == REGALLOC_R0+1 || v.Reg == REGALLOC_R0+2 {
+ return 2
+ }
+ }
+
+ return 0
+
+ case obj.ATEXT: /* funny */
+ if v.Type == obj.TYPE_REG {
+ if v.Reg == arm.REGARG {
+ return 3
+ }
+ }
+ return 0
+
+ case obj.APCDATA,
+ obj.AFUNCDATA,
+ obj.AVARDEF,
+ obj.AVARKILL:
+ return 0
+ }
+}
+
+/*
+ * direct reference,
+ * could be set/use depending on
+ * semantics
+ */
+func copyas(a *obj.Addr, v *obj.Addr) int {
+ if regtyp(v) != 0 {
+ if a.Type == v.Type {
+ if a.Reg == v.Reg {
+ return 1
+ }
+ }
+ } else if v.Type == obj.TYPE_CONST { /* for constprop */
+ if a.Type == v.Type {
+ if a.Name == v.Name {
+ if a.Sym == v.Sym {
+ if a.Reg == v.Reg {
+ if a.Offset == v.Offset {
+ return 1
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return 0
+}
+
+func sameaddr(a *obj.Addr, v *obj.Addr) int {
+ if a.Type != v.Type {
+ return 0
+ }
+ if regtyp(v) != 0 && a.Reg == v.Reg {
+ return 1
+ }
+
+ // TODO(rsc): Change v->type to v->name and enable.
+ //if(v->type == NAME_AUTO || v->type == NAME_PARAM) {
+ // if(v->offset == a->offset)
+ // return 1;
+ //}
+ return 0
+}
+
+/*
+ * either direct or indirect
+ */
+func copyau(a *obj.Addr, v *obj.Addr) int {
+ if copyas(a, v) != 0 {
+ return 1
+ }
+ if v.Type == obj.TYPE_REG {
+ if a.Type == obj.TYPE_ADDR && a.Reg != 0 {
+ if a.Reg == v.Reg {
+ return 1
+ }
+ } else if a.Type == obj.TYPE_MEM {
+ if a.Reg == v.Reg {
+ return 1
+ }
+ } else if a.Type == obj.TYPE_REGREG || a.Type == obj.TYPE_REGREG2 {
+ if a.Reg == v.Reg {
+ return 1
+ }
+ if a.Offset == int64(v.Reg) {
+ return 1
+ }
+ } else if a.Type == obj.TYPE_SHIFT {
+ if a.Offset&0xf == int64(v.Reg-arm.REG_R0) {
+ return 1
+ }
+ if (a.Offset&(1<<4) != 0) && (a.Offset>>8)&0xf == int64(v.Reg-arm.REG_R0) {
+ return 1
+ }
+ }
+ }
+
+ return 0
+}
+
+/*
+ * compare v to the center
+ * register in p (p->reg)
+ */
+func copyau1(p *obj.Prog, v *obj.Addr) int {
+ if v.Type == obj.TYPE_REG && v.Reg == 0 {
+ return 0
+ }
+ return bool2int(p.Reg == v.Reg)
+}
+
+/*
+ * substitute s for v in a
+ * return failure to substitute
+ */
+func copysub(a *obj.Addr, v *obj.Addr, s *obj.Addr, f int) int {
+ if f != 0 {
+ if copyau(a, v) != 0 {
+ if a.Type == obj.TYPE_SHIFT {
+ if a.Offset&0xf == int64(v.Reg-arm.REG_R0) {
+ a.Offset = a.Offset&^0xf | int64(s.Reg)&0xf
+ }
+ if (a.Offset&(1<<4) != 0) && (a.Offset>>8)&0xf == int64(v.Reg-arm.REG_R0) {
+ a.Offset = a.Offset&^(0xf<<8) | (int64(s.Reg)&0xf)<<8
+ }
+ } else if a.Type == obj.TYPE_REGREG || a.Type == obj.TYPE_REGREG2 {
+ if a.Offset == int64(v.Reg) {
+ a.Offset = int64(s.Reg)
+ }
+ if a.Reg == v.Reg {
+ a.Reg = s.Reg
+ }
+ } else {
+ a.Reg = s.Reg
+ }
+ }
+ }
+
+ return 0
+}
+
+func copysub1(p1 *obj.Prog, v *obj.Addr, s *obj.Addr, f int) int {
+ if f != 0 {
+ if copyau1(p1, v) != 0 {
+ p1.Reg = s.Reg
+ }
+ }
+ return 0
+}
+
+var predinfo = []struct {
+ opcode int
+ notopcode int
+ scond int
+ notscond int
+}{
+ struct {
+ opcode int
+ notopcode int
+ scond int
+ notscond int
+ }{arm.ABEQ, arm.ABNE, 0x0, 0x1},
+ struct {
+ opcode int
+ notopcode int
+ scond int
+ notscond int
+ }{arm.ABNE, arm.ABEQ, 0x1, 0x0},
+ struct {
+ opcode int
+ notopcode int
+ scond int
+ notscond int
+ }{arm.ABCS, arm.ABCC, 0x2, 0x3},
+ struct {
+ opcode int
+ notopcode int
+ scond int
+ notscond int
+ }{arm.ABHS, arm.ABLO, 0x2, 0x3},
+ struct {
+ opcode int
+ notopcode int
+ scond int
+ notscond int
+ }{arm.ABCC, arm.ABCS, 0x3, 0x2},
+ struct {
+ opcode int
+ notopcode int
+ scond int
+ notscond int
+ }{arm.ABLO, arm.ABHS, 0x3, 0x2},
+ struct {
+ opcode int
+ notopcode int
+ scond int
+ notscond int
+ }{arm.ABMI, arm.ABPL, 0x4, 0x5},
+ struct {
+ opcode int
+ notopcode int
+ scond int
+ notscond int
+ }{arm.ABPL, arm.ABMI, 0x5, 0x4},
+ struct {
+ opcode int
+ notopcode int
+ scond int
+ notscond int
+ }{arm.ABVS, arm.ABVC, 0x6, 0x7},
+ struct {
+ opcode int
+ notopcode int
+ scond int
+ notscond int
+ }{arm.ABVC, arm.ABVS, 0x7, 0x6},
+ struct {
+ opcode int
+ notopcode int
+ scond int
+ notscond int
+ }{arm.ABHI, arm.ABLS, 0x8, 0x9},
+ struct {
+ opcode int
+ notopcode int
+ scond int
+ notscond int
+ }{arm.ABLS, arm.ABHI, 0x9, 0x8},
+ struct {
+ opcode int
+ notopcode int
+ scond int
+ notscond int
+ }{arm.ABGE, arm.ABLT, 0xA, 0xB},
+ struct {
+ opcode int
+ notopcode int
+ scond int
+ notscond int
+ }{arm.ABLT, arm.ABGE, 0xB, 0xA},
+ struct {
+ opcode int
+ notopcode int
+ scond int
+ notscond int
+ }{arm.ABGT, arm.ABLE, 0xC, 0xD},
+ struct {
+ opcode int
+ notopcode int
+ scond int
+ notscond int
+ }{arm.ABLE, arm.ABGT, 0xD, 0xC},
+}
+
+type Joininfo struct {
+ start *gc.Flow
+ last *gc.Flow
+ end *gc.Flow
+ len int
+}
+
+const (
+ Join = iota
+ Split
+ End
+ Branch
+ Setcond
+ Toolong
+)
+
+const (
+ Falsecond = iota
+ Truecond
+ Delbranch
+ Keepbranch
+)
+
+func isbranch(p *obj.Prog) int {
+ return bool2int((arm.ABEQ <= p.As) && (p.As <= arm.ABLE))
+}
+
+func predicable(p *obj.Prog) int {
+ switch p.As {
+ case obj.ANOP,
+ obj.AXXX,
+ obj.ADATA,
+ obj.AGLOBL,
+ obj.ATEXT,
+ arm.AWORD,
+ arm.ABCASE,
+ arm.ACASE:
+ return 0
+ }
+
+ if isbranch(p) != 0 {
+ return 0
+ }
+ return 1
+}
+
+/*
+ * Depends on an analysis of the encodings performed by 5l.
+ * These seem to be all of the opcodes that lead to the "S" bit
+ * being set in the instruction encodings.
+ *
+ * C_SBIT may also have been set explicitly in p->scond.
+ */
+func modifiescpsr(p *obj.Prog) int {
+ switch p.As {
+ case arm.AMULLU,
+ arm.AMULA,
+ arm.AMULU,
+ arm.ADIVU,
+ arm.ATEQ,
+ arm.ACMN,
+ arm.ATST,
+ arm.ACMP,
+ arm.AMUL,
+ arm.ADIV,
+ arm.AMOD,
+ arm.AMODU,
+ arm.ABL:
+ return 1
+ }
+
+ if p.Scond&arm.C_SBIT != 0 {
+ return 1
+ }
+ return 0
+}
+
+/*
+ * Find the maximal chain of instructions starting with r which could
+ * be executed conditionally
+ */
+func joinsplit(r *gc.Flow, j *Joininfo) int {
+ j.start = r
+ j.last = r
+ j.len = 0
+ for {
+ if r.P2 != nil && (r.P1 != nil || r.P2.P2link != nil) {
+ j.end = r
+ return Join
+ }
+
+ if r.S1 != nil && r.S2 != nil {
+ j.end = r
+ return Split
+ }
+
+ j.last = r
+ if r.Prog.As != obj.ANOP {
+ j.len++
+ }
+ if !(r.S1 != nil) && !(r.S2 != nil) {
+ j.end = r.Link
+ return End
+ }
+
+ if r.S2 != nil {
+ j.end = r.S2
+ return Branch
+ }
+
+ if modifiescpsr(r.Prog) != 0 {
+ j.end = r.S1
+ return Setcond
+ }
+
+ r = r.S1
+ if !(j.len < 4) {
+ break
+ }
+ }
+
+ j.end = r
+ return Toolong
+}
+
+func successor(r *gc.Flow) *gc.Flow {
+ if r.S1 != nil {
+ return r.S1
+ } else {
+ return r.S2
+ }
+}
+
+func applypred(rstart *gc.Flow, j *Joininfo, cond int, branch int) {
+ var pred int
+ var r *gc.Flow
+
+ if j.len == 0 {
+ return
+ }
+ if cond == Truecond {
+ pred = predinfo[rstart.Prog.As-arm.ABEQ].scond
+ } else {
+ pred = predinfo[rstart.Prog.As-arm.ABEQ].notscond
+ }
+
+ for r = j.start; ; r = successor(r) {
+ if r.Prog.As == arm.AB {
+ if r != j.last || branch == Delbranch {
+ excise(r)
+ } else {
+ if cond == Truecond {
+ r.Prog.As = int16(predinfo[rstart.Prog.As-arm.ABEQ].opcode)
+ } else {
+ r.Prog.As = int16(predinfo[rstart.Prog.As-arm.ABEQ].notopcode)
+ }
+ }
+ } else if predicable(r.Prog) != 0 {
+ r.Prog.Scond = uint8(int(r.Prog.Scond&^arm.C_SCOND) | pred)
+ }
+ if r.S1 != r.Link {
+ r.S1 = r.Link
+ r.Link.P1 = r
+ }
+
+ if r == j.last {
+ break
+ }
+ }
+}
+
+func predicate(g *gc.Graph) {
+ var r *gc.Flow
+ var t1 int
+ var t2 int
+ var j1 Joininfo
+ var j2 Joininfo
+
+ for r = g.Start; r != nil; r = r.Link {
+ if isbranch(r.Prog) != 0 {
+ t1 = joinsplit(r.S1, &j1)
+ t2 = joinsplit(r.S2, &j2)
+ if j1.last.Link != j2.start {
+ continue
+ }
+ if j1.end == j2.end {
+ if (t1 == Branch && (t2 == Join || t2 == Setcond)) || (t2 == Join && (t1 == Join || t1 == Setcond)) {
+ applypred(r, &j1, Falsecond, Delbranch)
+ applypred(r, &j2, Truecond, Delbranch)
+ excise(r)
+ continue
+ }
+ }
+
+ if t1 == End || t1 == Branch {
+ applypred(r, &j1, Falsecond, Keepbranch)
+ excise(r)
+ continue
+ }
+ }
+ }
+}
+
+func isdconst(a *obj.Addr) int {
+ return bool2int(a.Type == obj.TYPE_CONST)
+}
+
+func isfloatreg(a *obj.Addr) int {
+ return bool2int(arm.REG_F0 <= a.Reg && a.Reg <= arm.REG_F15)
+}
+
+func stackaddr(a *obj.Addr) int {
+ return bool2int(regtyp(a) != 0 && a.Reg == arm.REGSP)
+}
+
+func smallindir(a *obj.Addr, reg *obj.Addr) int {
+ return bool2int(reg.Type == obj.TYPE_REG && a.Type == obj.TYPE_MEM && a.Reg == reg.Reg && 0 <= a.Offset && a.Offset < 4096)
+}
+
+func excise(r *gc.Flow) {
+ var p *obj.Prog
+
+ p = r.Prog
+ obj.Nopout(p)
+}
--- /dev/null
+// 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 main
+
+import (
+ "cmd/internal/obj"
+ "cmd/internal/obj/arm"
+)
+import "cmd/internal/gc"
+
+const (
+ RightRdwr = gc.RightRead | gc.RightWrite
+)
+
+// This table gives the basic information about instruction
+// generated by the compiler and processed in the optimizer.
+// See opt.h for bit definitions.
+//
+// Instructions not generated need not be listed.
+// As an exception to that rule, we typically write down all the
+// size variants of an operation even if we just use a subset.
+//
+// The table is formatted for 8-space tabs.
+var progtable = [arm.ALAST]gc.ProgInfo{
+ obj.ATYPE: gc.ProgInfo{gc.Pseudo | gc.Skip, 0, 0, 0},
+ obj.ATEXT: gc.ProgInfo{gc.Pseudo, 0, 0, 0},
+ obj.AFUNCDATA: gc.ProgInfo{gc.Pseudo, 0, 0, 0},
+ obj.APCDATA: gc.ProgInfo{gc.Pseudo, 0, 0, 0},
+ obj.AUNDEF: gc.ProgInfo{gc.Break, 0, 0, 0},
+ obj.AUSEFIELD: gc.ProgInfo{gc.OK, 0, 0, 0},
+ obj.ACHECKNIL: gc.ProgInfo{gc.LeftRead, 0, 0, 0},
+ obj.AVARDEF: gc.ProgInfo{gc.Pseudo | gc.RightWrite, 0, 0, 0},
+ obj.AVARKILL: gc.ProgInfo{gc.Pseudo | gc.RightWrite, 0, 0, 0},
+
+ // NOP is an internal no-op that also stands
+ // for USED and SET annotations, not the Intel opcode.
+ obj.ANOP: gc.ProgInfo{gc.LeftRead | gc.RightWrite, 0, 0, 0},
+
+ // Integer.
+ arm.AADC: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ arm.AADD: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ arm.AAND: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ arm.ABIC: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ arm.ACMN: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightRead, 0, 0, 0},
+ arm.ACMP: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightRead, 0, 0, 0},
+ arm.ADIVU: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ arm.ADIV: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ arm.AEOR: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ arm.AMODU: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ arm.AMOD: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ arm.AMULALU: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | RightRdwr, 0, 0, 0},
+ arm.AMULAL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | RightRdwr, 0, 0, 0},
+ arm.AMULA: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | RightRdwr, 0, 0, 0},
+ arm.AMULU: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ arm.AMUL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ arm.AMULL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ arm.AMULLU: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ arm.AMVN: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite, 0, 0, 0},
+ arm.AORR: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ arm.ARSB: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ arm.ARSC: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ arm.ASBC: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ arm.ASLL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ arm.ASRA: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ arm.ASRL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ arm.ASUB: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ arm.ATEQ: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightRead, 0, 0, 0},
+ arm.ATST: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightRead, 0, 0, 0},
+
+ // Floating point.
+ arm.AADDD: gc.ProgInfo{gc.SizeD | gc.LeftRead | RightRdwr, 0, 0, 0},
+ arm.AADDF: gc.ProgInfo{gc.SizeF | gc.LeftRead | RightRdwr, 0, 0, 0},
+ arm.ACMPD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightRead, 0, 0, 0},
+ arm.ACMPF: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightRead, 0, 0, 0},
+ arm.ADIVD: gc.ProgInfo{gc.SizeD | gc.LeftRead | RightRdwr, 0, 0, 0},
+ arm.ADIVF: gc.ProgInfo{gc.SizeF | gc.LeftRead | RightRdwr, 0, 0, 0},
+ arm.AMULD: gc.ProgInfo{gc.SizeD | gc.LeftRead | RightRdwr, 0, 0, 0},
+ arm.AMULF: gc.ProgInfo{gc.SizeF | gc.LeftRead | RightRdwr, 0, 0, 0},
+ arm.ASUBD: gc.ProgInfo{gc.SizeD | gc.LeftRead | RightRdwr, 0, 0, 0},
+ arm.ASUBF: gc.ProgInfo{gc.SizeF | gc.LeftRead | RightRdwr, 0, 0, 0},
+
+ // Conversions.
+ arm.AMOVWD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ arm.AMOVWF: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ arm.AMOVDF: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ arm.AMOVDW: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ arm.AMOVFD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ arm.AMOVFW: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+
+ // Moves.
+ arm.AMOVB: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
+ arm.AMOVD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
+ arm.AMOVF: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
+ arm.AMOVH: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
+ arm.AMOVW: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
+
+ // In addtion, duffzero reads R0,R1 and writes R1. This fact is
+ // encoded in peep.c
+ obj.ADUFFZERO: gc.ProgInfo{gc.Call, 0, 0, 0},
+
+ // In addtion, duffcopy reads R1,R2 and writes R0,R1,R2. This fact is
+ // encoded in peep.c
+ obj.ADUFFCOPY: gc.ProgInfo{gc.Call, 0, 0, 0},
+
+ // These should be split into the two different conversions instead
+ // of overloading the one.
+ arm.AMOVBS: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ arm.AMOVBU: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ arm.AMOVHS: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ arm.AMOVHU: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+
+ // Jumps.
+ arm.AB: gc.ProgInfo{gc.Jump | gc.Break, 0, 0, 0},
+ arm.ABL: gc.ProgInfo{gc.Call, 0, 0, 0},
+ arm.ABEQ: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+ arm.ABNE: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+ arm.ABCS: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+ arm.ABHS: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+ arm.ABCC: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+ arm.ABLO: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+ arm.ABMI: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+ arm.ABPL: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+ arm.ABVS: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+ arm.ABVC: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+ arm.ABHI: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+ arm.ABLS: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+ arm.ABGE: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+ arm.ABLT: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+ arm.ABGT: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+ arm.ABLE: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+ obj.ARET: gc.ProgInfo{gc.Break, 0, 0, 0},
+}
+
+func proginfo(info *gc.ProgInfo, p *obj.Prog) {
+ *info = progtable[p.As]
+ if info.Flags == 0 {
+ gc.Fatal("unknown instruction %v", p)
+ }
+
+ if p.From.Type == obj.TYPE_ADDR && p.From.Sym != nil && (info.Flags&gc.LeftRead != 0) {
+ info.Flags &^= gc.LeftRead
+ info.Flags |= gc.LeftAddr
+ }
+
+ if (info.Flags&gc.RegRead != 0) && p.Reg == 0 {
+ info.Flags &^= gc.RegRead
+ info.Flags |= gc.CanRegRead | gc.RightRead
+ }
+
+ if (p.Scond&arm.C_SCOND != arm.C_SCOND_NONE) && (info.Flags&gc.RightWrite != 0) {
+ info.Flags |= gc.RightRead
+ }
+
+ switch p.As {
+ case arm.ADIV,
+ arm.ADIVU,
+ arm.AMOD,
+ arm.AMODU:
+ info.Regset |= RtoB(arm.REG_R12)
+ }
+}
--- /dev/null
+// Inferno utils/5c/reg.c
+// http://code.google.com/p/inferno-os/source/browse/utils/5c/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 main
+
+import "cmd/internal/obj/arm"
+import "cmd/internal/gc"
+
+const (
+ NREGVAR = 32
+)
+
+var regname = []string{
+ ".R0",
+ ".R1",
+ ".R2",
+ ".R3",
+ ".R4",
+ ".R5",
+ ".R6",
+ ".R7",
+ ".R8",
+ ".R9",
+ ".R10",
+ ".R11",
+ ".R12",
+ ".R13",
+ ".R14",
+ ".R15",
+ ".F0",
+ ".F1",
+ ".F2",
+ ".F3",
+ ".F4",
+ ".F5",
+ ".F6",
+ ".F7",
+ ".F8",
+ ".F9",
+ ".F10",
+ ".F11",
+ ".F12",
+ ".F13",
+ ".F14",
+ ".F15",
+}
+
+func regnames(n *int) []string {
+ *n = NREGVAR
+ return regname
+}
+
+func excludedregs() uint64 {
+ return RtoB(arm.REGSP) | RtoB(arm.REGLINK) | RtoB(arm.REGPC)
+}
+
+func doregbits(r int) uint64 {
+ return 0
+}
+
+/*
+ * bit reg
+ * 0 R0
+ * 1 R1
+ * ... ...
+ * 10 R10
+ * 12 R12
+ *
+ * bit reg
+ * 18 F2
+ * 19 F3
+ * ... ...
+ * 31 F15
+ */
+func RtoB(r int) uint64 {
+ if arm.REG_R0 <= r && r <= arm.REG_R15 {
+ if r >= arm.REGTMP-2 && r != arm.REG_R12 { // excluded R9 and R10 for m and g, but not R12
+ return 0
+ }
+ return 1 << uint(r-arm.REG_R0)
+ }
+
+ if arm.REG_F0 <= r && r <= arm.REG_F15 {
+ if r < arm.REG_F2 || r > arm.REG_F0+arm.NFREG-1 {
+ return 0
+ }
+ return 1 << uint((r-arm.REG_F0)+16)
+ }
+
+ return 0
+}
+
+func BtoR(b uint64) int {
+ // TODO Allow R0 and R1, but be careful with a 0 return
+ // TODO Allow R9. Only R10 is reserved now (just g, not m).
+ b &= 0x11fc // excluded R9 and R10 for m and g, but not R12
+ if b == 0 {
+ return 0
+ }
+ return gc.Bitno(b) + arm.REG_R0
+}
+
+func BtoF(b uint64) int {
+ b &= 0xfffc0000
+ if b == 0 {
+ return 0
+ }
+ return gc.Bitno(b) - 16 + arm.REG_F0
+}
--- /dev/null
+// Copyright 2015 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 main
+
+func bool2int(b bool) int {
+ if b {
+ return 1
+ }
+ return 0
+}
--- /dev/null
+// 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 main
+
+import (
+ "cmd/internal/obj"
+ "cmd/internal/obj/x86"
+ "fmt"
+)
+import "cmd/internal/gc"
+
+/*
+ * reg.c
+ */
+
+/*
+ * peep.c
+ */
+/*
+ * generate:
+ * res = n;
+ * simplifies and calls gmove.
+ */
+func cgen(n *gc.Node, res *gc.Node) {
+ var nl *gc.Node
+ var nr *gc.Node
+ var r *gc.Node
+ var n1 gc.Node
+ var n2 gc.Node
+ var a int
+ var f int
+ var p1 *obj.Prog
+ var p2 *obj.Prog
+ var p3 *obj.Prog
+ var addr obj.Addr
+
+ if gc.Debug['g'] != 0 {
+ gc.Dump("\ncgen-n", n)
+ gc.Dump("cgen-res", res)
+ }
+
+ if n == nil || n.Type == nil {
+ goto ret
+ }
+
+ if res == nil || res.Type == nil {
+ gc.Fatal("cgen: res nil")
+ }
+
+ for n.Op == gc.OCONVNOP {
+ n = n.Left
+ }
+
+ switch n.Op {
+ case gc.OSLICE,
+ gc.OSLICEARR,
+ gc.OSLICESTR,
+ gc.OSLICE3,
+ gc.OSLICE3ARR:
+ if res.Op != gc.ONAME || !(res.Addable != 0) {
+ gc.Tempname(&n1, n.Type)
+ gc.Cgen_slice(n, &n1)
+ cgen(&n1, res)
+ } else {
+ gc.Cgen_slice(n, res)
+ }
+ goto ret
+
+ case gc.OEFACE:
+ if res.Op != gc.ONAME || !(res.Addable != 0) {
+ gc.Tempname(&n1, n.Type)
+ gc.Cgen_eface(n, &n1)
+ cgen(&n1, res)
+ } else {
+ gc.Cgen_eface(n, res)
+ }
+ goto ret
+ }
+
+ if n.Ullman >= gc.UINF {
+ if n.Op == gc.OINDREG {
+ gc.Fatal("cgen: this is going to misscompile")
+ }
+ if res.Ullman >= gc.UINF {
+ gc.Tempname(&n1, n.Type)
+ cgen(n, &n1)
+ cgen(&n1, res)
+ goto ret
+ }
+ }
+
+ if gc.Isfat(n.Type) != 0 {
+ if n.Type.Width < 0 {
+ gc.Fatal("forgot to compute width for %v", gc.Tconv(n.Type, 0))
+ }
+ sgen(n, res, n.Type.Width)
+ goto ret
+ }
+
+ if !(res.Addable != 0) {
+ if n.Ullman > res.Ullman {
+ regalloc(&n1, n.Type, res)
+ cgen(n, &n1)
+ if n1.Ullman > res.Ullman {
+ gc.Dump("n1", &n1)
+ gc.Dump("res", res)
+ gc.Fatal("loop in cgen")
+ }
+
+ cgen(&n1, res)
+ regfree(&n1)
+ goto ret
+ }
+
+ if res.Ullman >= gc.UINF {
+ goto gen
+ }
+
+ if gc.Complexop(n, res) != 0 {
+ gc.Complexgen(n, res)
+ goto ret
+ }
+
+ f = 1 // gen thru register
+ switch n.Op {
+ case gc.OLITERAL:
+ if gc.Smallintconst(n) != 0 {
+ f = 0
+ }
+
+ case gc.OREGISTER:
+ f = 0
+ }
+
+ if !(gc.Iscomplex[n.Type.Etype] != 0) {
+ a = optoas(gc.OAS, res.Type)
+ if sudoaddable(a, res, &addr) != 0 {
+ if f != 0 {
+ regalloc(&n2, res.Type, nil)
+ cgen(n, &n2)
+ p1 = gins(a, &n2, nil)
+ regfree(&n2)
+ } else {
+ p1 = gins(a, n, nil)
+ }
+ p1.To = addr
+ if gc.Debug['g'] != 0 {
+ fmt.Printf("%v [ignore previous line]\n", p1)
+ }
+ sudoclean()
+ goto ret
+ }
+ }
+
+ gen:
+ igen(res, &n1, nil)
+ cgen(n, &n1)
+ regfree(&n1)
+ goto ret
+ }
+
+ // update addressability for string, slice
+ // can't do in walk because n->left->addable
+ // changes if n->left is an escaping local variable.
+ switch n.Op {
+ case gc.OSPTR,
+ gc.OLEN:
+ if gc.Isslice(n.Left.Type) != 0 || gc.Istype(n.Left.Type, gc.TSTRING) != 0 {
+ n.Addable = n.Left.Addable
+ }
+
+ case gc.OCAP:
+ if gc.Isslice(n.Left.Type) != 0 {
+ n.Addable = n.Left.Addable
+ }
+
+ case gc.OITAB:
+ n.Addable = n.Left.Addable
+ }
+
+ if gc.Complexop(n, res) != 0 {
+ gc.Complexgen(n, res)
+ goto ret
+ }
+
+ if n.Addable != 0 {
+ gmove(n, res)
+ goto ret
+ }
+
+ nl = n.Left
+ nr = n.Right
+
+ if nl != nil && nl.Ullman >= gc.UINF {
+ if nr != nil && nr.Ullman >= gc.UINF {
+ gc.Tempname(&n1, nl.Type)
+ cgen(nl, &n1)
+ n2 = *n
+ n2.Left = &n1
+ cgen(&n2, res)
+ goto ret
+ }
+ }
+
+ if !(gc.Iscomplex[n.Type.Etype] != 0) {
+ a = optoas(gc.OAS, n.Type)
+ if sudoaddable(a, n, &addr) != 0 {
+ if res.Op == gc.OREGISTER {
+ p1 = gins(a, nil, res)
+ p1.From = addr
+ } else {
+ regalloc(&n2, n.Type, nil)
+ p1 = gins(a, nil, &n2)
+ p1.From = addr
+ gins(a, &n2, res)
+ regfree(&n2)
+ }
+
+ sudoclean()
+ goto ret
+ }
+ }
+
+ switch n.Op {
+ default:
+ gc.Dump("cgen", n)
+ gc.Fatal("cgen: unknown op %v", gc.Nconv(n, obj.FmtShort|obj.FmtSign))
+
+ // these call bgen to get a bool value
+ case gc.OOROR,
+ gc.OANDAND,
+ gc.OEQ,
+ gc.ONE,
+ gc.OLT,
+ gc.OLE,
+ gc.OGE,
+ gc.OGT,
+ gc.ONOT:
+ p1 = gc.Gbranch(obj.AJMP, nil, 0)
+
+ p2 = gc.Pc
+ gmove(gc.Nodbool(1), res)
+ p3 = gc.Gbranch(obj.AJMP, nil, 0)
+ gc.Patch(p1, gc.Pc)
+ bgen(n, true, 0, p2)
+ gmove(gc.Nodbool(0), res)
+ gc.Patch(p3, gc.Pc)
+ goto ret
+
+ case gc.OPLUS:
+ cgen(nl, res)
+ goto ret
+
+ // unary
+ case gc.OCOM:
+ a = optoas(gc.OXOR, nl.Type)
+
+ regalloc(&n1, nl.Type, nil)
+ cgen(nl, &n1)
+ gc.Nodconst(&n2, nl.Type, -1)
+ gins(a, &n2, &n1)
+ gmove(&n1, res)
+ regfree(&n1)
+ goto ret
+
+ case gc.OMINUS:
+ if gc.Isfloat[nl.Type.Etype] != 0 {
+ nr = gc.Nodintconst(-1)
+ gc.Convlit(&nr, n.Type)
+ a = optoas(gc.OMUL, nl.Type)
+ goto sbop
+ }
+
+ a = optoas(int(n.Op), nl.Type)
+ goto uop
+
+ // symmetric binary
+ case gc.OAND,
+ gc.OOR,
+ gc.OXOR,
+ gc.OADD,
+ gc.OMUL:
+ a = optoas(int(n.Op), nl.Type)
+
+ if a == x86.AIMULB {
+ cgen_bmul(int(n.Op), nl, nr, res)
+ break
+ }
+
+ goto sbop
+
+ // asymmetric binary
+ case gc.OSUB:
+ a = optoas(int(n.Op), nl.Type)
+
+ goto abop
+
+ case gc.OHMUL:
+ cgen_hmul(nl, nr, res)
+
+ case gc.OCONV:
+ if n.Type.Width > nl.Type.Width {
+ // If loading from memory, do conversion during load,
+ // so as to avoid use of 8-bit register in, say, int(*byteptr).
+ switch nl.Op {
+ case gc.ODOT,
+ gc.ODOTPTR,
+ gc.OINDEX,
+ gc.OIND,
+ gc.ONAME:
+ igen(nl, &n1, res)
+ regalloc(&n2, n.Type, res)
+ gmove(&n1, &n2)
+ gmove(&n2, res)
+ regfree(&n2)
+ regfree(&n1)
+ goto ret
+ }
+ }
+
+ regalloc(&n1, nl.Type, res)
+ regalloc(&n2, n.Type, &n1)
+ cgen(nl, &n1)
+
+ // if we do the conversion n1 -> n2 here
+ // reusing the register, then gmove won't
+ // have to allocate its own register.
+ gmove(&n1, &n2)
+
+ gmove(&n2, res)
+ regfree(&n2)
+ regfree(&n1)
+
+ case gc.ODOT,
+ gc.ODOTPTR,
+ gc.OINDEX,
+ gc.OIND,
+ gc.ONAME: // PHEAP or PPARAMREF var
+ igen(n, &n1, res)
+
+ gmove(&n1, res)
+ regfree(&n1)
+
+ // interface table is first word of interface value
+ case gc.OITAB:
+ igen(nl, &n1, res)
+
+ n1.Type = n.Type
+ gmove(&n1, res)
+ regfree(&n1)
+
+ // pointer is the first word of string or slice.
+ case gc.OSPTR:
+ if gc.Isconst(nl, gc.CTSTR) != 0 {
+ regalloc(&n1, gc.Types[gc.Tptr], res)
+ p1 = gins(x86.ALEAQ, nil, &n1)
+ gc.Datastring(nl.Val.U.Sval.S, &p1.From)
+ gmove(&n1, res)
+ regfree(&n1)
+ break
+ }
+
+ igen(nl, &n1, res)
+ n1.Type = n.Type
+ gmove(&n1, res)
+ regfree(&n1)
+
+ case gc.OLEN:
+ if gc.Istype(nl.Type, gc.TMAP) != 0 || gc.Istype(nl.Type, gc.TCHAN) != 0 {
+ // map and chan have len in the first int-sized word.
+ // a zero pointer means zero length
+ regalloc(&n1, gc.Types[gc.Tptr], res)
+
+ cgen(nl, &n1)
+
+ gc.Nodconst(&n2, gc.Types[gc.Tptr], 0)
+ gins(optoas(gc.OCMP, gc.Types[gc.Tptr]), &n1, &n2)
+ p1 = gc.Gbranch(optoas(gc.OEQ, gc.Types[gc.Tptr]), nil, 0)
+
+ n2 = n1
+ n2.Op = gc.OINDREG
+ n2.Type = gc.Types[gc.Simtype[gc.TINT]]
+ gmove(&n2, &n1)
+
+ gc.Patch(p1, gc.Pc)
+
+ gmove(&n1, res)
+ regfree(&n1)
+ break
+ }
+
+ if gc.Istype(nl.Type, gc.TSTRING) != 0 || gc.Isslice(nl.Type) != 0 {
+ // both slice and string have len one pointer into the struct.
+ // a zero pointer means zero length
+ igen(nl, &n1, res)
+
+ n1.Type = gc.Types[gc.Simtype[gc.TUINT]]
+ n1.Xoffset += int64(gc.Array_nel)
+ gmove(&n1, res)
+ regfree(&n1)
+ break
+ }
+
+ gc.Fatal("cgen: OLEN: unknown type %v", gc.Tconv(nl.Type, obj.FmtLong))
+
+ case gc.OCAP:
+ if gc.Istype(nl.Type, gc.TCHAN) != 0 {
+ // chan has cap in the second int-sized word.
+ // a zero pointer means zero length
+ regalloc(&n1, gc.Types[gc.Tptr], res)
+
+ cgen(nl, &n1)
+
+ gc.Nodconst(&n2, gc.Types[gc.Tptr], 0)
+ gins(optoas(gc.OCMP, gc.Types[gc.Tptr]), &n1, &n2)
+ p1 = gc.Gbranch(optoas(gc.OEQ, gc.Types[gc.Tptr]), nil, 0)
+
+ n2 = n1
+ n2.Op = gc.OINDREG
+ n2.Xoffset = int64(gc.Widthint)
+ n2.Type = gc.Types[gc.Simtype[gc.TINT]]
+ gmove(&n2, &n1)
+
+ gc.Patch(p1, gc.Pc)
+
+ gmove(&n1, res)
+ regfree(&n1)
+ break
+ }
+
+ if gc.Isslice(nl.Type) != 0 {
+ igen(nl, &n1, res)
+ n1.Type = gc.Types[gc.Simtype[gc.TUINT]]
+ n1.Xoffset += int64(gc.Array_cap)
+ gmove(&n1, res)
+ regfree(&n1)
+ break
+ }
+
+ gc.Fatal("cgen: OCAP: unknown type %v", gc.Tconv(nl.Type, obj.FmtLong))
+
+ case gc.OADDR:
+ if n.Bounded != 0 { // let race detector avoid nil checks
+ gc.Disable_checknil++
+ }
+ agen(nl, res)
+ if n.Bounded != 0 {
+ gc.Disable_checknil--
+ }
+
+ case gc.OCALLMETH:
+ gc.Cgen_callmeth(n, 0)
+ cgen_callret(n, res)
+
+ case gc.OCALLINTER:
+ cgen_callinter(n, res, 0)
+ cgen_callret(n, res)
+
+ case gc.OCALLFUNC:
+ cgen_call(n, 0)
+ cgen_callret(n, res)
+
+ case gc.OMOD,
+ gc.ODIV:
+ if gc.Isfloat[n.Type.Etype] != 0 {
+ a = optoas(int(n.Op), nl.Type)
+ goto abop
+ }
+
+ if nl.Ullman >= nr.Ullman {
+ regalloc(&n1, nl.Type, res)
+ cgen(nl, &n1)
+ cgen_div(int(n.Op), &n1, nr, res)
+ regfree(&n1)
+ } else {
+ if !(gc.Smallintconst(nr) != 0) {
+ regalloc(&n2, nr.Type, res)
+ cgen(nr, &n2)
+ } else {
+ n2 = *nr
+ }
+
+ cgen_div(int(n.Op), nl, &n2, res)
+ if n2.Op != gc.OLITERAL {
+ regfree(&n2)
+ }
+ }
+
+ case gc.OLSH,
+ gc.ORSH,
+ gc.OLROT:
+ cgen_shift(int(n.Op), int(n.Bounded), nl, nr, res)
+ }
+
+ goto ret
+
+ /*
+ * put simplest on right - we'll generate into left
+ * and then adjust it using the computation of right.
+ * constants and variables have the same ullman
+ * count, so look for constants specially.
+ *
+ * an integer constant we can use as an immediate
+ * is simpler than a variable - we can use the immediate
+ * in the adjustment instruction directly - so it goes
+ * on the right.
+ *
+ * other constants, like big integers or floating point
+ * constants, require a mov into a register, so those
+ * might as well go on the left, so we can reuse that
+ * register for the computation.
+ */
+sbop: // symmetric binary
+ if nl.Ullman < nr.Ullman || (nl.Ullman == nr.Ullman && (gc.Smallintconst(nl) != 0 || (nr.Op == gc.OLITERAL && !(gc.Smallintconst(nr) != 0)))) {
+ r = nl
+ nl = nr
+ nr = r
+ }
+
+abop: // asymmetric binary
+ if nl.Ullman >= nr.Ullman {
+ regalloc(&n1, nl.Type, res)
+ cgen(nl, &n1)
+
+ /*
+ * This generates smaller code - it avoids a MOV - but it's
+ * easily 10% slower due to not being able to
+ * optimize/manipulate the move.
+ * To see, run: go test -bench . crypto/md5
+ * with and without.
+ *
+ if(sudoaddable(a, nr, &addr)) {
+ p1 = gins(a, N, &n1);
+ p1->from = addr;
+ gmove(&n1, res);
+ sudoclean();
+ regfree(&n1);
+ goto ret;
+ }
+ *
+ */
+ if gc.Smallintconst(nr) != 0 {
+ n2 = *nr
+ } else {
+ regalloc(&n2, nr.Type, nil)
+ cgen(nr, &n2)
+ }
+ } else {
+ if gc.Smallintconst(nr) != 0 {
+ n2 = *nr
+ } else {
+ regalloc(&n2, nr.Type, res)
+ cgen(nr, &n2)
+ }
+
+ regalloc(&n1, nl.Type, nil)
+ cgen(nl, &n1)
+ }
+
+ gins(a, &n2, &n1)
+ gmove(&n1, res)
+ regfree(&n1)
+ if n2.Op != gc.OLITERAL {
+ regfree(&n2)
+ }
+ goto ret
+
+uop: // unary
+ regalloc(&n1, nl.Type, res)
+
+ cgen(nl, &n1)
+ gins(a, nil, &n1)
+ gmove(&n1, res)
+ regfree(&n1)
+ goto ret
+
+ret:
+}
+
+/*
+ * allocate a register (reusing res if possible) and generate
+ * a = n
+ * The caller must call regfree(a).
+ */
+func cgenr(n *gc.Node, a *gc.Node, res *gc.Node) {
+ var n1 gc.Node
+
+ if gc.Debug['g'] != 0 {
+ gc.Dump("cgenr-n", n)
+ }
+
+ if gc.Isfat(n.Type) != 0 {
+ gc.Fatal("cgenr on fat node")
+ }
+
+ if n.Addable != 0 {
+ regalloc(a, n.Type, res)
+ gmove(n, a)
+ return
+ }
+
+ switch n.Op {
+ case gc.ONAME,
+ gc.ODOT,
+ gc.ODOTPTR,
+ gc.OINDEX,
+ gc.OCALLFUNC,
+ gc.OCALLMETH,
+ gc.OCALLINTER:
+ igen(n, &n1, res)
+ regalloc(a, gc.Types[gc.Tptr], &n1)
+ gmove(&n1, a)
+ regfree(&n1)
+
+ default:
+ regalloc(a, n.Type, res)
+ cgen(n, a)
+ }
+}
+
+/*
+ * allocate a register (reusing res if possible) and generate
+ * a = &n
+ * The caller must call regfree(a).
+ * The generated code checks that the result is not nil.
+ */
+func agenr(n *gc.Node, a *gc.Node, res *gc.Node) {
+ var nl *gc.Node
+ var nr *gc.Node
+ var n1 gc.Node
+ var n2 gc.Node
+ var n3 gc.Node
+ var n5 gc.Node
+ var tmp gc.Node
+ var tmp2 gc.Node
+ var nlen gc.Node
+ var p1 *obj.Prog
+ var t *gc.Type
+ var w uint64
+ var v uint64
+ var freelen int
+
+ if gc.Debug['g'] != 0 {
+ gc.Dump("\nagenr-n", n)
+ }
+
+ nl = n.Left
+ nr = n.Right
+
+ switch n.Op {
+ case gc.ODOT,
+ gc.ODOTPTR,
+ gc.OCALLFUNC,
+ gc.OCALLMETH,
+ gc.OCALLINTER:
+ igen(n, &n1, res)
+ regalloc(a, gc.Types[gc.Tptr], &n1)
+ agen(&n1, a)
+ regfree(&n1)
+
+ case gc.OIND:
+ cgenr(n.Left, a, res)
+ gc.Cgen_checknil(a)
+
+ case gc.OINDEX:
+ freelen = 0
+ w = uint64(n.Type.Width)
+
+ // Generate the non-addressable child first.
+ if nr.Addable != 0 {
+ goto irad
+ }
+ if nl.Addable != 0 {
+ cgenr(nr, &n1, nil)
+ if !(gc.Isconst(nl, gc.CTSTR) != 0) {
+ if gc.Isfixedarray(nl.Type) != 0 {
+ agenr(nl, &n3, res)
+ } else {
+ igen(nl, &nlen, res)
+ freelen = 1
+ nlen.Type = gc.Types[gc.Tptr]
+ nlen.Xoffset += int64(gc.Array_array)
+ regalloc(&n3, gc.Types[gc.Tptr], res)
+ gmove(&nlen, &n3)
+ nlen.Type = gc.Types[gc.Simtype[gc.TUINT]]
+ nlen.Xoffset += int64(gc.Array_nel) - int64(gc.Array_array)
+ }
+ }
+
+ goto index
+ }
+
+ gc.Tempname(&tmp, nr.Type)
+ cgen(nr, &tmp)
+ nr = &tmp
+
+ irad:
+ if !(gc.Isconst(nl, gc.CTSTR) != 0) {
+ if gc.Isfixedarray(nl.Type) != 0 {
+ agenr(nl, &n3, res)
+ } else {
+ if !(nl.Addable != 0) {
+ // igen will need an addressable node.
+ gc.Tempname(&tmp2, nl.Type)
+
+ cgen(nl, &tmp2)
+ nl = &tmp2
+ }
+
+ igen(nl, &nlen, res)
+ freelen = 1
+ nlen.Type = gc.Types[gc.Tptr]
+ nlen.Xoffset += int64(gc.Array_array)
+ regalloc(&n3, gc.Types[gc.Tptr], res)
+ gmove(&nlen, &n3)
+ nlen.Type = gc.Types[gc.Simtype[gc.TUINT]]
+ nlen.Xoffset += int64(gc.Array_nel) - int64(gc.Array_array)
+ }
+ }
+
+ if !(gc.Isconst(nr, gc.CTINT) != 0) {
+ cgenr(nr, &n1, nil)
+ }
+
+ goto index
+
+ // &a is in &n3 (allocated in res)
+ // i is in &n1 (if not constant)
+ // len(a) is in nlen (if needed)
+ // w is width
+
+ // constant index
+ index:
+ if gc.Isconst(nr, gc.CTINT) != 0 {
+ if gc.Isconst(nl, gc.CTSTR) != 0 {
+ gc.Fatal("constant string constant index") // front end should handle
+ }
+ v = uint64(gc.Mpgetfix(nr.Val.U.Xval))
+ if gc.Isslice(nl.Type) != 0 || nl.Type.Etype == gc.TSTRING {
+ if !(gc.Debug['B'] != 0) && !(n.Bounded != 0) {
+ gc.Nodconst(&n2, gc.Types[gc.Simtype[gc.TUINT]], int64(v))
+ if gc.Smallintconst(nr) != 0 {
+ gins(optoas(gc.OCMP, gc.Types[gc.Simtype[gc.TUINT]]), &nlen, &n2)
+ } else {
+ regalloc(&tmp, gc.Types[gc.Simtype[gc.TUINT]], nil)
+ gmove(&n2, &tmp)
+ gins(optoas(gc.OCMP, gc.Types[gc.Simtype[gc.TUINT]]), &nlen, &tmp)
+ regfree(&tmp)
+ }
+
+ p1 = gc.Gbranch(optoas(gc.OGT, gc.Types[gc.Simtype[gc.TUINT]]), nil, +1)
+ ginscall(gc.Panicindex, -1)
+ gc.Patch(p1, gc.Pc)
+ }
+
+ regfree(&nlen)
+ }
+
+ if v*w != 0 {
+ ginscon(optoas(gc.OADD, gc.Types[gc.Tptr]), int64(v*w), &n3)
+ }
+ *a = n3
+ break
+ }
+
+ // type of the index
+ t = gc.Types[gc.TUINT64]
+
+ if gc.Issigned[n1.Type.Etype] != 0 {
+ t = gc.Types[gc.TINT64]
+ }
+
+ regalloc(&n2, t, &n1) // i
+ gmove(&n1, &n2)
+ regfree(&n1)
+
+ if !(gc.Debug['B'] != 0) && !(n.Bounded != 0) {
+ // check bounds
+ t = gc.Types[gc.Simtype[gc.TUINT]]
+
+ if gc.Is64(nr.Type) != 0 {
+ t = gc.Types[gc.TUINT64]
+ }
+ if gc.Isconst(nl, gc.CTSTR) != 0 {
+ gc.Nodconst(&nlen, t, int64(len(nl.Val.U.Sval.S)))
+ } else if gc.Isslice(nl.Type) != 0 || nl.Type.Etype == gc.TSTRING {
+ if gc.Is64(nr.Type) != 0 {
+ regalloc(&n5, t, nil)
+ gmove(&nlen, &n5)
+ regfree(&nlen)
+ nlen = n5
+ }
+ } else {
+ gc.Nodconst(&nlen, t, nl.Type.Bound)
+ if !(gc.Smallintconst(&nlen) != 0) {
+ regalloc(&n5, t, nil)
+ gmove(&nlen, &n5)
+ nlen = n5
+ freelen = 1
+ }
+ }
+
+ gins(optoas(gc.OCMP, t), &n2, &nlen)
+ p1 = gc.Gbranch(optoas(gc.OLT, t), nil, +1)
+ ginscall(gc.Panicindex, -1)
+ gc.Patch(p1, gc.Pc)
+ }
+
+ if gc.Isconst(nl, gc.CTSTR) != 0 {
+ regalloc(&n3, gc.Types[gc.Tptr], res)
+ p1 = gins(x86.ALEAQ, nil, &n3)
+ gc.Datastring(nl.Val.U.Sval.S, &p1.From)
+ gins(x86.AADDQ, &n2, &n3)
+ goto indexdone
+ }
+
+ if w == 0 {
+ } else // nothing to do
+ if w == 1 || w == 2 || w == 4 || w == 8 {
+ p1 = gins(x86.ALEAQ, &n2, &n3)
+ p1.From.Type = obj.TYPE_MEM
+ p1.From.Scale = int8(w)
+ p1.From.Index = p1.From.Reg
+ p1.From.Reg = p1.To.Reg
+ } else {
+ ginscon(optoas(gc.OMUL, t), int64(w), &n2)
+ gins(optoas(gc.OADD, gc.Types[gc.Tptr]), &n2, &n3)
+ }
+
+ indexdone:
+ *a = n3
+ regfree(&n2)
+ if freelen != 0 {
+ regfree(&nlen)
+ }
+
+ default:
+ regalloc(a, gc.Types[gc.Tptr], res)
+ agen(n, a)
+ }
+}
+
+/*
+ * generate:
+ * res = &n;
+ * The generated code checks that the result is not nil.
+ */
+func agen(n *gc.Node, res *gc.Node) {
+ var nl *gc.Node
+ var n1 gc.Node
+ var n2 gc.Node
+
+ if gc.Debug['g'] != 0 {
+ gc.Dump("\nagen-res", res)
+ gc.Dump("agen-r", n)
+ }
+
+ if n == nil || n.Type == nil {
+ return
+ }
+
+ for n.Op == gc.OCONVNOP {
+ n = n.Left
+ }
+
+ if gc.Isconst(n, gc.CTNIL) != 0 && n.Type.Width > int64(gc.Widthptr) {
+ // Use of a nil interface or nil slice.
+ // Create a temporary we can take the address of and read.
+ // The generated code is just going to panic, so it need not
+ // be terribly efficient. See issue 3670.
+ gc.Tempname(&n1, n.Type)
+
+ gc.Gvardef(&n1)
+ clearfat(&n1)
+ regalloc(&n2, gc.Types[gc.Tptr], res)
+ gins(x86.ALEAQ, &n1, &n2)
+ gmove(&n2, res)
+ regfree(&n2)
+ goto ret
+ }
+
+ if n.Addable != 0 {
+ regalloc(&n1, gc.Types[gc.Tptr], res)
+ gins(x86.ALEAQ, n, &n1)
+ gmove(&n1, res)
+ regfree(&n1)
+ goto ret
+ }
+
+ nl = n.Left
+
+ switch n.Op {
+ default:
+ gc.Fatal("agen: unknown op %v", gc.Nconv(n, obj.FmtShort|obj.FmtSign))
+
+ case gc.OCALLMETH:
+ gc.Cgen_callmeth(n, 0)
+ cgen_aret(n, res)
+
+ case gc.OCALLINTER:
+ cgen_callinter(n, res, 0)
+ cgen_aret(n, res)
+
+ case gc.OCALLFUNC:
+ cgen_call(n, 0)
+ cgen_aret(n, res)
+
+ case gc.OSLICE,
+ gc.OSLICEARR,
+ gc.OSLICESTR,
+ gc.OSLICE3,
+ gc.OSLICE3ARR:
+ gc.Tempname(&n1, n.Type)
+ gc.Cgen_slice(n, &n1)
+ agen(&n1, res)
+
+ case gc.OEFACE:
+ gc.Tempname(&n1, n.Type)
+ gc.Cgen_eface(n, &n1)
+ agen(&n1, res)
+
+ case gc.OINDEX:
+ agenr(n, &n1, res)
+ gmove(&n1, res)
+ regfree(&n1)
+
+ // should only get here with names in this func.
+ case gc.ONAME:
+ if n.Funcdepth > 0 && n.Funcdepth != gc.Funcdepth {
+ gc.Dump("bad agen", n)
+ gc.Fatal("agen: bad ONAME funcdepth %d != %d", n.Funcdepth, gc.Funcdepth)
+ }
+
+ // should only get here for heap vars or paramref
+ if !(n.Class&gc.PHEAP != 0) && n.Class != gc.PPARAMREF {
+ gc.Dump("bad agen", n)
+ gc.Fatal("agen: bad ONAME class %#x", n.Class)
+ }
+
+ cgen(n.Heapaddr, res)
+ if n.Xoffset != 0 {
+ ginscon(optoas(gc.OADD, gc.Types[gc.Tptr]), n.Xoffset, res)
+ }
+
+ case gc.OIND:
+ cgen(nl, res)
+ gc.Cgen_checknil(res)
+
+ case gc.ODOT:
+ agen(nl, res)
+ if n.Xoffset != 0 {
+ ginscon(optoas(gc.OADD, gc.Types[gc.Tptr]), n.Xoffset, res)
+ }
+
+ case gc.ODOTPTR:
+ cgen(nl, res)
+ gc.Cgen_checknil(res)
+ if n.Xoffset != 0 {
+ ginscon(optoas(gc.OADD, gc.Types[gc.Tptr]), n.Xoffset, res)
+ }
+ }
+
+ret:
+}
+
+/*
+ * generate:
+ * newreg = &n;
+ * res = newreg
+ *
+ * on exit, a has been changed to be *newreg.
+ * caller must regfree(a).
+ * The generated code checks that the result is not *nil.
+ */
+func igen(n *gc.Node, a *gc.Node, res *gc.Node) {
+ var fp *gc.Type
+ var flist gc.Iter
+ var n1 gc.Node
+
+ if gc.Debug['g'] != 0 {
+ gc.Dump("\nigen-n", n)
+ }
+
+ switch n.Op {
+ case gc.ONAME:
+ if (n.Class&gc.PHEAP != 0) || n.Class == gc.PPARAMREF {
+ break
+ }
+ *a = *n
+ return
+
+ // Increase the refcount of the register so that igen's caller
+ // has to call regfree.
+ case gc.OINDREG:
+ if n.Val.U.Reg != x86.REG_SP {
+ reg[n.Val.U.Reg]++
+ }
+ *a = *n
+ return
+
+ case gc.ODOT:
+ igen(n.Left, a, res)
+ a.Xoffset += n.Xoffset
+ a.Type = n.Type
+ fixlargeoffset(a)
+ return
+
+ case gc.ODOTPTR:
+ cgenr(n.Left, a, res)
+ gc.Cgen_checknil(a)
+ a.Op = gc.OINDREG
+ a.Xoffset += n.Xoffset
+ a.Type = n.Type
+ fixlargeoffset(a)
+ return
+
+ case gc.OCALLFUNC,
+ gc.OCALLMETH,
+ gc.OCALLINTER:
+ switch n.Op {
+ case gc.OCALLFUNC:
+ cgen_call(n, 0)
+
+ case gc.OCALLMETH:
+ gc.Cgen_callmeth(n, 0)
+
+ case gc.OCALLINTER:
+ cgen_callinter(n, nil, 0)
+ }
+
+ fp = gc.Structfirst(&flist, gc.Getoutarg(n.Left.Type))
+ *a = gc.Node{}
+ a.Op = gc.OINDREG
+ a.Val.U.Reg = x86.REG_SP
+ a.Addable = 1
+ a.Xoffset = fp.Width
+ a.Type = n.Type
+ return
+
+ // Index of fixed-size array by constant can
+ // put the offset in the addressing.
+ // Could do the same for slice except that we need
+ // to use the real index for the bounds checking.
+ case gc.OINDEX:
+ if gc.Isfixedarray(n.Left.Type) != 0 || (gc.Isptr[n.Left.Type.Etype] != 0 && gc.Isfixedarray(n.Left.Left.Type) != 0) {
+ if gc.Isconst(n.Right, gc.CTINT) != 0 {
+ // Compute &a.
+ if !(gc.Isptr[n.Left.Type.Etype] != 0) {
+ igen(n.Left, a, res)
+ } else {
+ igen(n.Left, &n1, res)
+ gc.Cgen_checknil(&n1)
+ regalloc(a, gc.Types[gc.Tptr], res)
+ gmove(&n1, a)
+ regfree(&n1)
+ a.Op = gc.OINDREG
+ }
+
+ // Compute &a[i] as &a + i*width.
+ a.Type = n.Type
+
+ a.Xoffset += gc.Mpgetfix(n.Right.Val.U.Xval) * n.Type.Width
+ fixlargeoffset(a)
+ return
+ }
+ }
+ }
+
+ agenr(n, a, res)
+ a.Op = gc.OINDREG
+ a.Type = n.Type
+}
+
+/*
+ * generate:
+ * if(n == true) goto to;
+ */
+func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) {
+ var et int
+ var a int
+ var nl *gc.Node
+ var nr *gc.Node
+ var l *gc.Node
+ var r *gc.Node
+ var n1 gc.Node
+ var n2 gc.Node
+ var tmp gc.Node
+ var ll *gc.NodeList
+ var p1 *obj.Prog
+ var p2 *obj.Prog
+
+ if gc.Debug['g'] != 0 {
+ gc.Dump("\nbgen", n)
+ }
+
+ if n == nil {
+ n = gc.Nodbool(1)
+ }
+
+ if n.Ninit != nil {
+ gc.Genlist(n.Ninit)
+ }
+
+ if n.Type == nil {
+ gc.Convlit(&n, gc.Types[gc.TBOOL])
+ if n.Type == nil {
+ goto ret
+ }
+ }
+
+ et = int(n.Type.Etype)
+ if et != gc.TBOOL {
+ gc.Yyerror("cgen: bad type %v for %v", gc.Tconv(n.Type, 0), gc.Oconv(int(n.Op), 0))
+ gc.Patch(gins(obj.AEND, nil, nil), to)
+ goto ret
+ }
+
+ nr = nil
+
+ for n.Op == gc.OCONVNOP {
+ n = n.Left
+ if n.Ninit != nil {
+ gc.Genlist(n.Ninit)
+ }
+ }
+
+ switch n.Op {
+ default:
+ goto def
+
+ // need to ask if it is bool?
+ case gc.OLITERAL:
+ if !true_ == !(n.Val.U.Bval != 0) {
+ gc.Patch(gc.Gbranch(obj.AJMP, nil, likely), to)
+ }
+ goto ret
+
+ case gc.ONAME:
+ if n.Addable == 0 {
+ goto def
+ }
+ gc.Nodconst(&n1, n.Type, 0)
+ gins(optoas(gc.OCMP, n.Type), n, &n1)
+ a = x86.AJNE
+ if !true_ {
+ a = x86.AJEQ
+ }
+ gc.Patch(gc.Gbranch(a, n.Type, likely), to)
+ goto ret
+
+ case gc.OANDAND,
+ gc.OOROR:
+ if (n.Op == gc.OANDAND) == true_ {
+ p1 = gc.Gbranch(obj.AJMP, nil, 0)
+ p2 = gc.Gbranch(obj.AJMP, nil, 0)
+ gc.Patch(p1, gc.Pc)
+ bgen(n.Left, !true_, -likely, p2)
+ bgen(n.Right, !true_, -likely, p2)
+ p1 = gc.Gbranch(obj.AJMP, nil, 0)
+ gc.Patch(p1, to)
+ gc.Patch(p2, gc.Pc)
+ } else {
+ bgen(n.Left, true_, likely, to)
+ bgen(n.Right, true_, likely, to)
+ }
+
+ goto ret
+
+ case gc.OEQ,
+ gc.ONE,
+ gc.OLT,
+ gc.OGT,
+ gc.OLE,
+ gc.OGE:
+ nr = n.Right
+ if nr == nil || nr.Type == nil {
+ goto ret
+ }
+ fallthrough
+
+ case gc.ONOT: // unary
+ nl = n.Left
+
+ if nl == nil || nl.Type == nil {
+ goto ret
+ }
+ }
+
+ switch n.Op {
+ case gc.ONOT:
+ bgen(nl, !true_, likely, to)
+ goto ret
+
+ case gc.OEQ,
+ gc.ONE,
+ gc.OLT,
+ gc.OGT,
+ gc.OLE,
+ gc.OGE:
+ a = int(n.Op)
+ if !true_ {
+ if gc.Isfloat[nr.Type.Etype] != 0 {
+ // brcom is not valid on floats when NaN is involved.
+ p1 = gc.Gbranch(obj.AJMP, nil, 0)
+
+ p2 = gc.Gbranch(obj.AJMP, nil, 0)
+ gc.Patch(p1, gc.Pc)
+ ll = n.Ninit // avoid re-genning ninit
+ n.Ninit = nil
+ bgen(n, true, -likely, p2)
+ n.Ninit = ll
+ gc.Patch(gc.Gbranch(obj.AJMP, nil, 0), to)
+ gc.Patch(p2, gc.Pc)
+ goto ret
+ }
+
+ a = gc.Brcom(a)
+ true_ = !true_
+ }
+
+ // make simplest on right
+ if nl.Op == gc.OLITERAL || (nl.Ullman < nr.Ullman && nl.Ullman < gc.UINF) {
+ a = gc.Brrev(a)
+ r = nl
+ nl = nr
+ nr = r
+ }
+
+ if gc.Isslice(nl.Type) != 0 {
+ // front end should only leave cmp to literal nil
+ if (a != gc.OEQ && a != gc.ONE) || nr.Op != gc.OLITERAL {
+ gc.Yyerror("illegal slice comparison")
+ break
+ }
+
+ a = optoas(a, gc.Types[gc.Tptr])
+ igen(nl, &n1, nil)
+ n1.Xoffset += int64(gc.Array_array)
+ n1.Type = gc.Types[gc.Tptr]
+ gc.Nodconst(&tmp, gc.Types[gc.Tptr], 0)
+ gins(optoas(gc.OCMP, gc.Types[gc.Tptr]), &n1, &tmp)
+ gc.Patch(gc.Gbranch(a, gc.Types[gc.Tptr], likely), to)
+ regfree(&n1)
+ break
+ }
+
+ if gc.Isinter(nl.Type) != 0 {
+ // front end should only leave cmp to literal nil
+ if (a != gc.OEQ && a != gc.ONE) || nr.Op != gc.OLITERAL {
+ gc.Yyerror("illegal interface comparison")
+ break
+ }
+
+ a = optoas(a, gc.Types[gc.Tptr])
+ igen(nl, &n1, nil)
+ n1.Type = gc.Types[gc.Tptr]
+ gc.Nodconst(&tmp, gc.Types[gc.Tptr], 0)
+ gins(optoas(gc.OCMP, gc.Types[gc.Tptr]), &n1, &tmp)
+ gc.Patch(gc.Gbranch(a, gc.Types[gc.Tptr], likely), to)
+ regfree(&n1)
+ break
+ }
+
+ if gc.Iscomplex[nl.Type.Etype] != 0 {
+ gc.Complexbool(a, nl, nr, true_, likely, to)
+ break
+ }
+
+ if nr.Ullman >= gc.UINF {
+ regalloc(&n1, nl.Type, nil)
+ cgen(nl, &n1)
+
+ gc.Tempname(&tmp, nl.Type)
+ gmove(&n1, &tmp)
+ regfree(&n1)
+
+ regalloc(&n2, nr.Type, nil)
+ cgen(nr, &n2)
+
+ regalloc(&n1, nl.Type, nil)
+ cgen(&tmp, &n1)
+
+ goto cmp
+ }
+
+ regalloc(&n1, nl.Type, nil)
+ cgen(nl, &n1)
+
+ if gc.Smallintconst(nr) != 0 {
+ gins(optoas(gc.OCMP, nr.Type), &n1, nr)
+ gc.Patch(gc.Gbranch(optoas(a, nr.Type), nr.Type, likely), to)
+ regfree(&n1)
+ break
+ }
+
+ regalloc(&n2, nr.Type, nil)
+ cgen(nr, &n2)
+
+ // only < and <= work right with NaN; reverse if needed
+ cmp:
+ l = &n1
+
+ r = &n2
+ if gc.Isfloat[nl.Type.Etype] != 0 && (a == gc.OGT || a == gc.OGE) {
+ l = &n2
+ r = &n1
+ a = gc.Brrev(a)
+ }
+
+ gins(optoas(gc.OCMP, nr.Type), l, r)
+
+ if gc.Isfloat[nr.Type.Etype] != 0 && (n.Op == gc.OEQ || n.Op == gc.ONE) {
+ if n.Op == gc.OEQ {
+ // neither NE nor P
+ p1 = gc.Gbranch(x86.AJNE, nil, -likely)
+
+ p2 = gc.Gbranch(x86.AJPS, nil, -likely)
+ gc.Patch(gc.Gbranch(obj.AJMP, nil, 0), to)
+ gc.Patch(p1, gc.Pc)
+ gc.Patch(p2, gc.Pc)
+ } else {
+ // either NE or P
+ gc.Patch(gc.Gbranch(x86.AJNE, nil, likely), to)
+
+ gc.Patch(gc.Gbranch(x86.AJPS, nil, likely), to)
+ }
+ } else {
+ gc.Patch(gc.Gbranch(optoas(a, nr.Type), nr.Type, likely), to)
+ }
+ regfree(&n1)
+ regfree(&n2)
+ }
+
+ goto ret
+
+def:
+ regalloc(&n1, n.Type, nil)
+ cgen(n, &n1)
+ gc.Nodconst(&n2, n.Type, 0)
+ gins(optoas(gc.OCMP, n.Type), &n1, &n2)
+ a = x86.AJNE
+ if !true_ {
+ a = x86.AJEQ
+ }
+ gc.Patch(gc.Gbranch(a, n.Type, likely), to)
+ regfree(&n1)
+ goto ret
+
+ret:
+}
+
+/*
+ * n is on stack, either local variable
+ * or return value from function call.
+ * return n's offset from SP.
+ */
+func stkof(n *gc.Node) int64 {
+ var t *gc.Type
+ var flist gc.Iter
+ var off int64
+
+ switch n.Op {
+ case gc.OINDREG:
+ return n.Xoffset
+
+ case gc.ODOT:
+ t = n.Left.Type
+ if gc.Isptr[t.Etype] != 0 {
+ break
+ }
+ off = stkof(n.Left)
+ if off == -1000 || off == 1000 {
+ return off
+ }
+ return off + n.Xoffset
+
+ case gc.OINDEX:
+ t = n.Left.Type
+ if !(gc.Isfixedarray(t) != 0) {
+ break
+ }
+ off = stkof(n.Left)
+ if off == -1000 || off == 1000 {
+ return off
+ }
+ if gc.Isconst(n.Right, gc.CTINT) != 0 {
+ return off + t.Type.Width*gc.Mpgetfix(n.Right.Val.U.Xval)
+ }
+ return 1000
+
+ case gc.OCALLMETH,
+ gc.OCALLINTER,
+ gc.OCALLFUNC:
+ t = n.Left.Type
+ if gc.Isptr[t.Etype] != 0 {
+ t = t.Type
+ }
+
+ t = gc.Structfirst(&flist, gc.Getoutarg(t))
+ if t != nil {
+ return t.Width
+ }
+ }
+
+ // botch - probably failing to recognize address
+ // arithmetic on the above. eg INDEX and DOT
+ return -1000
+}
+
+/*
+ * block copy:
+ * memmove(&ns, &n, w);
+ */
+func sgen(n *gc.Node, ns *gc.Node, w int64) {
+ var nodl gc.Node
+ var nodr gc.Node
+ var nodsi gc.Node
+ var noddi gc.Node
+ var cx gc.Node
+ var oldcx gc.Node
+ var tmp gc.Node
+ var c int64
+ var q int64
+ var odst int64
+ var osrc int64
+ var l *gc.NodeList
+ var p *obj.Prog
+
+ if gc.Debug['g'] != 0 {
+ fmt.Printf("\nsgen w=%d\n", w)
+ gc.Dump("r", n)
+ gc.Dump("res", ns)
+ }
+
+ if n.Ullman >= gc.UINF && ns.Ullman >= gc.UINF {
+ gc.Fatal("sgen UINF")
+ }
+
+ if w < 0 {
+ gc.Fatal("sgen copy %d", w)
+ }
+
+ // If copying .args, that's all the results, so record definition sites
+ // for them for the liveness analysis.
+ if ns.Op == gc.ONAME && ns.Sym.Name == ".args" {
+ for l = gc.Curfn.Dcl; l != nil; l = l.Next {
+ if l.N.Class == gc.PPARAMOUT {
+ gc.Gvardef(l.N)
+ }
+ }
+ }
+
+ // Avoid taking the address for simple enough types.
+ if componentgen(n, ns) != 0 {
+ return
+ }
+
+ if w == 0 {
+ // evaluate side effects only
+ regalloc(&nodr, gc.Types[gc.Tptr], nil)
+
+ agen(ns, &nodr)
+ agen(n, &nodr)
+ regfree(&nodr)
+ return
+ }
+
+ // offset on the stack
+ osrc = stkof(n)
+
+ odst = stkof(ns)
+
+ if osrc != -1000 && odst != -1000 && (osrc == 1000 || odst == 1000) {
+ // osrc and odst both on stack, and at least one is in
+ // an unknown position. Could generate code to test
+ // for forward/backward copy, but instead just copy
+ // to a temporary location first.
+ gc.Tempname(&tmp, n.Type)
+
+ sgen(n, &tmp, w)
+ sgen(&tmp, ns, w)
+ return
+ }
+
+ gc.Nodreg(&noddi, gc.Types[gc.Tptr], x86.REG_DI)
+ gc.Nodreg(&nodsi, gc.Types[gc.Tptr], x86.REG_SI)
+
+ if n.Ullman >= ns.Ullman {
+ agenr(n, &nodr, &nodsi)
+ if ns.Op == gc.ONAME {
+ gc.Gvardef(ns)
+ }
+ agenr(ns, &nodl, &noddi)
+ } else {
+ if ns.Op == gc.ONAME {
+ gc.Gvardef(ns)
+ }
+ agenr(ns, &nodl, &noddi)
+ agenr(n, &nodr, &nodsi)
+ }
+
+ if nodl.Val.U.Reg != x86.REG_DI {
+ gmove(&nodl, &noddi)
+ }
+ if nodr.Val.U.Reg != x86.REG_SI {
+ gmove(&nodr, &nodsi)
+ }
+ regfree(&nodl)
+ regfree(&nodr)
+
+ c = w % 8 // bytes
+ q = w / 8 // quads
+
+ savex(x86.REG_CX, &cx, &oldcx, nil, gc.Types[gc.TINT64])
+
+ // if we are copying forward on the stack and
+ // the src and dst overlap, then reverse direction
+ if osrc < odst && odst < osrc+w {
+ // reverse direction
+ gins(x86.ASTD, nil, nil) // set direction flag
+ if c > 0 {
+ gconreg(addptr, w-1, x86.REG_SI)
+ gconreg(addptr, w-1, x86.REG_DI)
+
+ gconreg(movptr, c, x86.REG_CX)
+ gins(x86.AREP, nil, nil) // repeat
+ gins(x86.AMOVSB, nil, nil) // MOVB *(SI)-,*(DI)-
+ }
+
+ if q > 0 {
+ if c > 0 {
+ gconreg(addptr, -7, x86.REG_SI)
+ gconreg(addptr, -7, x86.REG_DI)
+ } else {
+ gconreg(addptr, w-8, x86.REG_SI)
+ gconreg(addptr, w-8, x86.REG_DI)
+ }
+
+ gconreg(movptr, q, x86.REG_CX)
+ gins(x86.AREP, nil, nil) // repeat
+ gins(x86.AMOVSQ, nil, nil) // MOVQ *(SI)-,*(DI)-
+ }
+
+ // we leave with the flag clear
+ gins(x86.ACLD, nil, nil)
+ } else {
+ // normal direction
+ if q > 128 || (gc.Nacl && q >= 4) {
+ gconreg(movptr, q, x86.REG_CX)
+ gins(x86.AREP, nil, nil) // repeat
+ gins(x86.AMOVSQ, nil, nil) // MOVQ *(SI)+,*(DI)+
+ } else if q >= 4 {
+ p = gins(obj.ADUFFCOPY, nil, nil)
+ p.To.Type = obj.TYPE_ADDR
+ p.To.Sym = gc.Linksym(gc.Pkglookup("duffcopy", gc.Runtimepkg))
+
+ // 14 and 128 = magic constants: see ../../runtime/asm_amd64.s
+ p.To.Offset = 14 * (128 - q)
+ } else if !gc.Nacl && c == 0 {
+ // We don't need the MOVSQ side-effect of updating SI and DI,
+ // and issuing a sequence of MOVQs directly is faster.
+ nodsi.Op = gc.OINDREG
+
+ noddi.Op = gc.OINDREG
+ for q > 0 {
+ gmove(&nodsi, &cx) // MOVQ x+(SI),CX
+ gmove(&cx, &noddi) // MOVQ CX,x+(DI)
+ nodsi.Xoffset += 8
+ noddi.Xoffset += 8
+ q--
+ }
+ } else {
+ for q > 0 {
+ gins(x86.AMOVSQ, nil, nil) // MOVQ *(SI)+,*(DI)+
+ q--
+ }
+ }
+
+ // copy the remaining c bytes
+ if w < 4 || c <= 1 || (odst < osrc && osrc < odst+w) {
+ for c > 0 {
+ gins(x86.AMOVSB, nil, nil) // MOVB *(SI)+,*(DI)+
+ c--
+ }
+ } else if w < 8 || c <= 4 {
+ nodsi.Op = gc.OINDREG
+ noddi.Op = gc.OINDREG
+ cx.Type = gc.Types[gc.TINT32]
+ nodsi.Type = gc.Types[gc.TINT32]
+ noddi.Type = gc.Types[gc.TINT32]
+ if c > 4 {
+ nodsi.Xoffset = 0
+ noddi.Xoffset = 0
+ gmove(&nodsi, &cx)
+ gmove(&cx, &noddi)
+ }
+
+ nodsi.Xoffset = c - 4
+ noddi.Xoffset = c - 4
+ gmove(&nodsi, &cx)
+ gmove(&cx, &noddi)
+ } else {
+ nodsi.Op = gc.OINDREG
+ noddi.Op = gc.OINDREG
+ cx.Type = gc.Types[gc.TINT64]
+ nodsi.Type = gc.Types[gc.TINT64]
+ noddi.Type = gc.Types[gc.TINT64]
+ nodsi.Xoffset = c - 8
+ noddi.Xoffset = c - 8
+ gmove(&nodsi, &cx)
+ gmove(&cx, &noddi)
+ }
+ }
+
+ restx(&cx, &oldcx)
+}
+
+func cadable(n *gc.Node) int {
+ if !(n.Addable != 0) {
+ // dont know how it happens,
+ // but it does
+ return 0
+ }
+
+ switch n.Op {
+ case gc.ONAME:
+ return 1
+ }
+
+ return 0
+}
+
+/*
+ * copy a composite value by moving its individual components.
+ * Slices, strings and interfaces are supported.
+ * Small structs or arrays with elements of basic type are
+ * also supported.
+ * nr is N when assigning a zero value.
+ * return 1 if can do, 0 if can't.
+ */
+func componentgen(nr *gc.Node, nl *gc.Node) int {
+ var nodl gc.Node
+ var nodr gc.Node
+ var tmp gc.Node
+ var t *gc.Type
+ var freel int
+ var freer int
+ var fldcount int64
+ var loffset int64
+ var roffset int64
+
+ freel = 0
+ freer = 0
+
+ switch nl.Type.Etype {
+ default:
+ goto no
+
+ case gc.TARRAY:
+ t = nl.Type
+
+ // Slices are ok.
+ if gc.Isslice(t) != 0 {
+ break
+ }
+
+ // Small arrays are ok.
+ if t.Bound > 0 && t.Bound <= 3 && !(gc.Isfat(t.Type) != 0) {
+ break
+ }
+
+ goto no
+
+ // Small structs with non-fat types are ok.
+ // Zero-sized structs are treated separately elsewhere.
+ case gc.TSTRUCT:
+ fldcount = 0
+
+ for t = nl.Type.Type; t != nil; t = t.Down {
+ if gc.Isfat(t.Type) != 0 {
+ goto no
+ }
+ if t.Etype != gc.TFIELD {
+ gc.Fatal("componentgen: not a TFIELD: %v", gc.Tconv(t, obj.FmtLong))
+ }
+ fldcount++
+ }
+
+ if fldcount == 0 || fldcount > 4 {
+ goto no
+ }
+
+ case gc.TSTRING,
+ gc.TINTER:
+ break
+ }
+
+ nodl = *nl
+ if !(cadable(nl) != 0) {
+ if nr != nil && !(cadable(nr) != 0) {
+ goto no
+ }
+ igen(nl, &nodl, nil)
+ freel = 1
+ }
+
+ if nr != nil {
+ nodr = *nr
+ if !(cadable(nr) != 0) {
+ igen(nr, &nodr, nil)
+ freer = 1
+ }
+ } else {
+ // When zeroing, prepare a register containing zero.
+ gc.Nodconst(&tmp, nl.Type, 0)
+
+ regalloc(&nodr, gc.Types[gc.TUINT], nil)
+ gmove(&tmp, &nodr)
+ freer = 1
+ }
+
+ // nl and nr are 'cadable' which basically means they are names (variables) now.
+ // If they are the same variable, don't generate any code, because the
+ // VARDEF we generate will mark the old value as dead incorrectly.
+ // (And also the assignments are useless.)
+ if nr != nil && nl.Op == gc.ONAME && nr.Op == gc.ONAME && nl == nr {
+ goto yes
+ }
+
+ switch nl.Type.Etype {
+ // componentgen for arrays.
+ case gc.TARRAY:
+ if nl.Op == gc.ONAME {
+ gc.Gvardef(nl)
+ }
+ t = nl.Type
+ if !(gc.Isslice(t) != 0) {
+ nodl.Type = t.Type
+ nodr.Type = nodl.Type
+ for fldcount = 0; fldcount < t.Bound; fldcount++ {
+ if nr == nil {
+ gc.Clearslim(&nodl)
+ } else {
+ gmove(&nodr, &nodl)
+ }
+ nodl.Xoffset += t.Type.Width
+ nodr.Xoffset += t.Type.Width
+ }
+
+ goto yes
+ }
+
+ // componentgen for slices.
+ nodl.Xoffset += int64(gc.Array_array)
+
+ nodl.Type = gc.Ptrto(nl.Type.Type)
+
+ if nr != nil {
+ nodr.Xoffset += int64(gc.Array_array)
+ nodr.Type = nodl.Type
+ }
+
+ gmove(&nodr, &nodl)
+
+ nodl.Xoffset += int64(gc.Array_nel) - int64(gc.Array_array)
+ nodl.Type = gc.Types[gc.Simtype[gc.TUINT]]
+
+ if nr != nil {
+ nodr.Xoffset += int64(gc.Array_nel) - int64(gc.Array_array)
+ nodr.Type = nodl.Type
+ }
+
+ gmove(&nodr, &nodl)
+
+ nodl.Xoffset += int64(gc.Array_cap) - int64(gc.Array_nel)
+ nodl.Type = gc.Types[gc.Simtype[gc.TUINT]]
+
+ if nr != nil {
+ nodr.Xoffset += int64(gc.Array_cap) - int64(gc.Array_nel)
+ nodr.Type = nodl.Type
+ }
+
+ gmove(&nodr, &nodl)
+
+ goto yes
+
+ case gc.TSTRING:
+ if nl.Op == gc.ONAME {
+ gc.Gvardef(nl)
+ }
+ nodl.Xoffset += int64(gc.Array_array)
+ nodl.Type = gc.Ptrto(gc.Types[gc.TUINT8])
+
+ if nr != nil {
+ nodr.Xoffset += int64(gc.Array_array)
+ nodr.Type = nodl.Type
+ }
+
+ gmove(&nodr, &nodl)
+
+ nodl.Xoffset += int64(gc.Array_nel) - int64(gc.Array_array)
+ nodl.Type = gc.Types[gc.Simtype[gc.TUINT]]
+
+ if nr != nil {
+ nodr.Xoffset += int64(gc.Array_nel) - int64(gc.Array_array)
+ nodr.Type = nodl.Type
+ }
+
+ gmove(&nodr, &nodl)
+
+ goto yes
+
+ case gc.TINTER:
+ if nl.Op == gc.ONAME {
+ gc.Gvardef(nl)
+ }
+ nodl.Xoffset += int64(gc.Array_array)
+ nodl.Type = gc.Ptrto(gc.Types[gc.TUINT8])
+
+ if nr != nil {
+ nodr.Xoffset += int64(gc.Array_array)
+ nodr.Type = nodl.Type
+ }
+
+ gmove(&nodr, &nodl)
+
+ nodl.Xoffset += int64(gc.Array_nel) - int64(gc.Array_array)
+ nodl.Type = gc.Ptrto(gc.Types[gc.TUINT8])
+
+ if nr != nil {
+ nodr.Xoffset += int64(gc.Array_nel) - int64(gc.Array_array)
+ nodr.Type = nodl.Type
+ }
+
+ gmove(&nodr, &nodl)
+
+ goto yes
+
+ case gc.TSTRUCT:
+ if nl.Op == gc.ONAME {
+ gc.Gvardef(nl)
+ }
+ loffset = nodl.Xoffset
+ roffset = nodr.Xoffset
+
+ // funarg structs may not begin at offset zero.
+ if nl.Type.Etype == gc.TSTRUCT && nl.Type.Funarg != 0 && nl.Type.Type != nil {
+ loffset -= nl.Type.Type.Width
+ }
+ if nr != nil && nr.Type.Etype == gc.TSTRUCT && nr.Type.Funarg != 0 && nr.Type.Type != nil {
+ roffset -= nr.Type.Type.Width
+ }
+
+ for t = nl.Type.Type; t != nil; t = t.Down {
+ nodl.Xoffset = loffset + t.Width
+ nodl.Type = t.Type
+
+ if nr == nil {
+ gc.Clearslim(&nodl)
+ } else {
+ nodr.Xoffset = roffset + t.Width
+ nodr.Type = nodl.Type
+ gmove(&nodr, &nodl)
+ }
+ }
+
+ goto yes
+ }
+
+no:
+ if freer != 0 {
+ regfree(&nodr)
+ }
+ if freel != 0 {
+ regfree(&nodl)
+ }
+ return 0
+
+yes:
+ if freer != 0 {
+ regfree(&nodr)
+ }
+ if freel != 0 {
+ regfree(&nodl)
+ }
+ return 1
+}
--- /dev/null
+// 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 main
+
+import (
+ "cmd/internal/obj"
+ "cmd/internal/obj/x86"
+)
+import "cmd/internal/gc"
+
+var thechar int = '6'
+
+var thestring string = "amd64"
+
+var thelinkarch *obj.LinkArch = &x86.Linkamd64
+
+func linkarchinit() {
+ if obj.Getgoarch() == "amd64p32" {
+ thelinkarch = &x86.Linkamd64p32
+ gc.Thearch.Thelinkarch = thelinkarch
+ thestring = "amd64p32"
+ gc.Thearch.Thestring = "amd64p32"
+ }
+}
+
+var MAXWIDTH int64 = 1 << 50
+
+var addptr int = x86.AADDQ
+
+var movptr int = x86.AMOVQ
+
+var leaptr int = x86.ALEAQ
+
+var cmpptr int = x86.ACMPQ
+
+/*
+ * go declares several platform-specific type aliases:
+ * int, uint, float, and uintptr
+ */
+var typedefs = []gc.Typedef{
+ gc.Typedef{"int", gc.TINT, gc.TINT64},
+ gc.Typedef{"uint", gc.TUINT, gc.TUINT64},
+ gc.Typedef{"uintptr", gc.TUINTPTR, gc.TUINT64},
+}
+
+func betypeinit() {
+ gc.Widthptr = 8
+ gc.Widthint = 8
+ gc.Widthreg = 8
+ if obj.Getgoarch() == "amd64p32" {
+ gc.Widthptr = 4
+ gc.Widthint = 4
+ addptr = x86.AADDL
+ movptr = x86.AMOVL
+ leaptr = x86.ALEAL
+ cmpptr = x86.ACMPL
+ typedefs[0].Sameas = gc.TINT32
+ typedefs[1].Sameas = gc.TUINT32
+ typedefs[2].Sameas = gc.TUINT32
+ }
+
+}
+
+func main() {
+ gc.Thearch.Thechar = thechar
+ gc.Thearch.Thestring = thestring
+ gc.Thearch.Thelinkarch = thelinkarch
+ gc.Thearch.Typedefs = typedefs
+ gc.Thearch.REGSP = x86.REGSP
+ gc.Thearch.REGCTXT = x86.REGCTXT
+ gc.Thearch.MAXWIDTH = MAXWIDTH
+ gc.Thearch.Anyregalloc = anyregalloc
+ gc.Thearch.Betypeinit = betypeinit
+ gc.Thearch.Bgen = bgen
+ gc.Thearch.Cgen = cgen
+ gc.Thearch.Cgen_call = cgen_call
+ gc.Thearch.Cgen_callinter = cgen_callinter
+ gc.Thearch.Cgen_ret = cgen_ret
+ gc.Thearch.Clearfat = clearfat
+ gc.Thearch.Defframe = defframe
+ gc.Thearch.Excise = excise
+ gc.Thearch.Expandchecks = expandchecks
+ gc.Thearch.Gclean = gclean
+ gc.Thearch.Ginit = ginit
+ gc.Thearch.Gins = gins
+ gc.Thearch.Ginscall = ginscall
+ gc.Thearch.Igen = igen
+ gc.Thearch.Linkarchinit = linkarchinit
+ gc.Thearch.Peep = peep
+ gc.Thearch.Proginfo = proginfo
+ gc.Thearch.Regalloc = regalloc
+ gc.Thearch.Regfree = regfree
+ gc.Thearch.Regtyp = regtyp
+ gc.Thearch.Sameaddr = sameaddr
+ gc.Thearch.Smallindir = smallindir
+ gc.Thearch.Stackaddr = stackaddr
+ gc.Thearch.Excludedregs = excludedregs
+ gc.Thearch.RtoB = RtoB
+ gc.Thearch.FtoB = FtoB
+ gc.Thearch.BtoR = BtoR
+ gc.Thearch.BtoF = BtoF
+ gc.Thearch.Optoas = optoas
+ gc.Thearch.Doregbits = doregbits
+ gc.Thearch.Regnames = regnames
+
+ gc.Main()
+}
--- /dev/null
+// 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 main
+
+import "cmd/internal/obj/x86"
+import "cmd/internal/gc"
+
+// 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.
+
+var reg [x86.MAXREG]uint8
+
+var panicdiv *gc.Node
+
+/*
+ * cgen.c
+ */
+
+/*
+ * list.c
+ */
--- /dev/null
+// 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 main
+
+import (
+ "cmd/internal/obj"
+ "cmd/internal/obj/x86"
+)
+import "cmd/internal/gc"
+
+func defframe(ptxt *obj.Prog) {
+ var frame uint32
+ var ax uint32
+ var p *obj.Prog
+ var hi int64
+ var lo int64
+ var l *gc.NodeList
+ var n *gc.Node
+
+ // fill in argument size, stack size
+ ptxt.To.Type = obj.TYPE_TEXTSIZE
+
+ ptxt.To.U.Argsize = int32(gc.Rnd(gc.Curfn.Type.Argwid, int64(gc.Widthptr)))
+ frame = uint32(gc.Rnd(gc.Stksize+gc.Maxarg, int64(gc.Widthreg)))
+ ptxt.To.Offset = int64(frame)
+
+ // insert code to zero ambiguously live variables
+ // so that the garbage collector only sees initialized values
+ // when it looks for pointers.
+ p = ptxt
+
+ hi = 0
+ lo = hi
+ ax = 0
+
+ // iterate through declarations - they are sorted in decreasing xoffset order.
+ for l = gc.Curfn.Dcl; l != nil; l = l.Next {
+ n = l.N
+ if !(n.Needzero != 0) {
+ continue
+ }
+ if n.Class != gc.PAUTO {
+ gc.Fatal("needzero class %d", n.Class)
+ }
+ if n.Type.Width%int64(gc.Widthptr) != 0 || n.Xoffset%int64(gc.Widthptr) != 0 || n.Type.Width == 0 {
+ gc.Fatal("var %v has size %d offset %d", gc.Nconv(n, obj.FmtLong), int(n.Type.Width), int(n.Xoffset))
+ }
+
+ if lo != hi && n.Xoffset+n.Type.Width >= lo-int64(2*gc.Widthreg) {
+ // merge with range we already have
+ lo = n.Xoffset
+
+ continue
+ }
+
+ // zero old range
+ p = zerorange(p, int64(frame), lo, hi, &ax)
+
+ // set new range
+ hi = n.Xoffset + n.Type.Width
+
+ lo = n.Xoffset
+ }
+
+ // zero final range
+ zerorange(p, int64(frame), lo, hi, &ax)
+}
+
+func zerorange(p *obj.Prog, frame int64, lo int64, hi int64, ax *uint32) *obj.Prog {
+ var cnt int64
+ var i int64
+
+ cnt = hi - lo
+ if cnt == 0 {
+ return p
+ }
+ if *ax == 0 {
+ p = appendpp(p, x86.AMOVQ, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, x86.REG_AX, 0)
+ *ax = 1
+ }
+
+ if cnt%int64(gc.Widthreg) != 0 {
+ // should only happen with nacl
+ if cnt%int64(gc.Widthptr) != 0 {
+ gc.Fatal("zerorange count not a multiple of widthptr %d", cnt)
+ }
+ p = appendpp(p, x86.AMOVL, obj.TYPE_REG, x86.REG_AX, 0, obj.TYPE_MEM, x86.REG_SP, frame+lo)
+ lo += int64(gc.Widthptr)
+ cnt -= int64(gc.Widthptr)
+ }
+
+ if cnt <= int64(4*gc.Widthreg) {
+ for i = 0; i < cnt; i += int64(gc.Widthreg) {
+ p = appendpp(p, x86.AMOVQ, obj.TYPE_REG, x86.REG_AX, 0, obj.TYPE_MEM, x86.REG_SP, frame+lo+i)
+ }
+ } else if !gc.Nacl && (cnt <= int64(128*gc.Widthreg)) {
+ p = appendpp(p, leaptr, obj.TYPE_MEM, x86.REG_SP, frame+lo, obj.TYPE_REG, x86.REG_DI, 0)
+ p = appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_ADDR, 0, 2*(128-cnt/int64(gc.Widthreg)))
+ p.To.Sym = gc.Linksym(gc.Pkglookup("duffzero", gc.Runtimepkg))
+ } else {
+ p = appendpp(p, x86.AMOVQ, obj.TYPE_CONST, 0, cnt/int64(gc.Widthreg), obj.TYPE_REG, x86.REG_CX, 0)
+ p = appendpp(p, leaptr, obj.TYPE_MEM, x86.REG_SP, frame+lo, obj.TYPE_REG, x86.REG_DI, 0)
+ p = appendpp(p, x86.AREP, obj.TYPE_NONE, 0, 0, obj.TYPE_NONE, 0, 0)
+ p = appendpp(p, x86.ASTOSQ, obj.TYPE_NONE, 0, 0, obj.TYPE_NONE, 0, 0)
+ }
+
+ return p
+}
+
+func appendpp(p *obj.Prog, as int, ftype int, freg int, foffset int64, ttype int, treg int, toffset int64) *obj.Prog {
+ var q *obj.Prog
+ q = gc.Ctxt.NewProg()
+ gc.Clearp(q)
+ q.As = int16(as)
+ q.Lineno = p.Lineno
+ q.From.Type = int16(ftype)
+ q.From.Reg = int16(freg)
+ q.From.Offset = foffset
+ q.To.Type = int16(ttype)
+ q.To.Reg = int16(treg)
+ q.To.Offset = toffset
+ q.Link = p.Link
+ p.Link = q
+ return q
+}
+
+/*
+ * generate:
+ * call f
+ * proc=-1 normal call but no return
+ * proc=0 normal call
+ * proc=1 goroutine run in new proc
+ * proc=2 defer call save away stack
+ * proc=3 normal call to C pointer (not Go func value)
+*/
+func ginscall(f *gc.Node, proc int) {
+ var p *obj.Prog
+ var reg gc.Node
+ var stk gc.Node
+ var r1 gc.Node
+ var extra int32
+
+ if f.Type != nil {
+ extra = 0
+ if proc == 1 || proc == 2 {
+ extra = 2 * int32(gc.Widthptr)
+ }
+ gc.Setmaxarg(f.Type, extra)
+ }
+
+ switch proc {
+ default:
+ gc.Fatal("ginscall: bad proc %d", proc)
+
+ case 0, // normal call
+ -1: // normal call but no return
+ if f.Op == gc.ONAME && f.Class == gc.PFUNC {
+ if f == gc.Deferreturn {
+ // Deferred calls will appear to be returning to
+ // the CALL deferreturn(SB) that we are about to emit.
+ // However, the stack trace code will show the line
+ // of the instruction byte before the return PC.
+ // To avoid that being an unrelated instruction,
+ // insert an x86 NOP that we will have the right line number.
+ // x86 NOP 0x90 is really XCHG AX, AX; use that description
+ // because the NOP pseudo-instruction would be removed by
+ // the linker.
+ gc.Nodreg(®, gc.Types[gc.TINT], x86.REG_AX)
+
+ gins(x86.AXCHGL, ®, ®)
+ }
+
+ p = gins(obj.ACALL, nil, f)
+ gc.Afunclit(&p.To, f)
+ if proc == -1 || gc.Noreturn(p) != 0 {
+ gins(obj.AUNDEF, nil, nil)
+ }
+ break
+ }
+
+ gc.Nodreg(®, gc.Types[gc.Tptr], x86.REG_DX)
+ gc.Nodreg(&r1, gc.Types[gc.Tptr], x86.REG_BX)
+ gmove(f, ®)
+ reg.Op = gc.OINDREG
+ gmove(®, &r1)
+ reg.Op = gc.OREGISTER
+ gins(obj.ACALL, ®, &r1)
+
+ case 3: // normal call of c function pointer
+ gins(obj.ACALL, nil, f)
+
+ case 1, // call in new proc (go)
+ 2: // deferred call (defer)
+ stk = gc.Node{}
+
+ stk.Op = gc.OINDREG
+ stk.Val.U.Reg = x86.REG_SP
+ stk.Xoffset = 0
+
+ if gc.Widthptr == 8 {
+ // size of arguments at 0(SP)
+ ginscon(x86.AMOVQ, int64(gc.Argsize(f.Type)), &stk)
+
+ // FuncVal* at 8(SP)
+ stk.Xoffset = int64(gc.Widthptr)
+
+ gc.Nodreg(®, gc.Types[gc.TINT64], x86.REG_AX)
+ gmove(f, ®)
+ gins(x86.AMOVQ, ®, &stk)
+ } else {
+ // size of arguments at 0(SP)
+ ginscon(x86.AMOVL, int64(gc.Argsize(f.Type)), &stk)
+
+ // FuncVal* at 4(SP)
+ stk.Xoffset = int64(gc.Widthptr)
+
+ gc.Nodreg(®, gc.Types[gc.TINT32], x86.REG_AX)
+ gmove(f, ®)
+ gins(x86.AMOVL, ®, &stk)
+ }
+
+ if proc == 1 {
+ ginscall(gc.Newproc, 0)
+ } else {
+ if !(gc.Hasdefer != 0) {
+ gc.Fatal("hasdefer=0 but has defer")
+ }
+ ginscall(gc.Deferproc, 0)
+ }
+
+ if proc == 2 {
+ gc.Nodreg(®, gc.Types[gc.TINT32], x86.REG_AX)
+ gins(x86.ATESTL, ®, ®)
+ p = gc.Gbranch(x86.AJEQ, nil, +1)
+ cgen_ret(nil)
+ gc.Patch(p, gc.Pc)
+ }
+ }
+}
+
+/*
+ * n is call to interface method.
+ * generate res = n.
+ */
+func cgen_callinter(n *gc.Node, res *gc.Node, proc int) {
+ var i *gc.Node
+ var f *gc.Node
+ var tmpi gc.Node
+ var nodi gc.Node
+ var nodo gc.Node
+ var nodr gc.Node
+ var nodsp gc.Node
+
+ i = n.Left
+ if i.Op != gc.ODOTINTER {
+ gc.Fatal("cgen_callinter: not ODOTINTER %v", gc.Oconv(int(i.Op), 0))
+ }
+
+ f = i.Right // field
+ if f.Op != gc.ONAME {
+ gc.Fatal("cgen_callinter: not ONAME %v", gc.Oconv(int(f.Op), 0))
+ }
+
+ i = i.Left // interface
+
+ if !(i.Addable != 0) {
+ gc.Tempname(&tmpi, i.Type)
+ cgen(i, &tmpi)
+ i = &tmpi
+ }
+
+ gc.Genlist(n.List) // assign the args
+
+ // i is now addable, prepare an indirected
+ // register to hold its address.
+ igen(i, &nodi, res) // REG = &inter
+
+ gc.Nodindreg(&nodsp, gc.Types[gc.Tptr], x86.REG_SP)
+
+ nodsp.Xoffset = 0
+ if proc != 0 {
+ nodsp.Xoffset += 2 * int64(gc.Widthptr) // leave room for size & fn
+ }
+ nodi.Type = gc.Types[gc.Tptr]
+ nodi.Xoffset += int64(gc.Widthptr)
+ cgen(&nodi, &nodsp) // {0, 8(nacl), or 16}(SP) = 8(REG) -- i.data
+
+ regalloc(&nodo, gc.Types[gc.Tptr], res)
+
+ nodi.Type = gc.Types[gc.Tptr]
+ nodi.Xoffset -= int64(gc.Widthptr)
+ cgen(&nodi, &nodo) // REG = 0(REG) -- i.tab
+ regfree(&nodi)
+
+ regalloc(&nodr, gc.Types[gc.Tptr], &nodo)
+ if n.Left.Xoffset == gc.BADWIDTH {
+ gc.Fatal("cgen_callinter: badwidth")
+ }
+ gc.Cgen_checknil(&nodo) // in case offset is huge
+ nodo.Op = gc.OINDREG
+ nodo.Xoffset = n.Left.Xoffset + 3*int64(gc.Widthptr) + 8
+ if proc == 0 {
+ // plain call: use direct c function pointer - more efficient
+ cgen(&nodo, &nodr) // REG = 32+offset(REG) -- i.tab->fun[f]
+ proc = 3
+ } else {
+ // go/defer. generate go func value.
+ gins(x86.ALEAQ, &nodo, &nodr) // REG = &(32+offset(REG)) -- i.tab->fun[f]
+ }
+
+ nodr.Type = n.Left.Type
+ ginscall(&nodr, proc)
+
+ regfree(&nodr)
+ regfree(&nodo)
+}
+
+/*
+ * generate function call;
+ * proc=0 normal call
+ * proc=1 goroutine run in new proc
+ * proc=2 defer call save away stack
+ */
+func cgen_call(n *gc.Node, proc int) {
+ var t *gc.Type
+ var nod gc.Node
+ var afun gc.Node
+
+ if n == nil {
+ return
+ }
+
+ if n.Left.Ullman >= gc.UINF {
+ // if name involves a fn call
+ // precompute the address of the fn
+ gc.Tempname(&afun, gc.Types[gc.Tptr])
+
+ cgen(n.Left, &afun)
+ }
+
+ gc.Genlist(n.List) // assign the args
+ t = n.Left.Type
+
+ // call tempname pointer
+ if n.Left.Ullman >= gc.UINF {
+ regalloc(&nod, gc.Types[gc.Tptr], nil)
+ gc.Cgen_as(&nod, &afun)
+ nod.Type = t
+ ginscall(&nod, proc)
+ regfree(&nod)
+ return
+ }
+
+ // call pointer
+ if n.Left.Op != gc.ONAME || n.Left.Class != gc.PFUNC {
+ regalloc(&nod, gc.Types[gc.Tptr], nil)
+ gc.Cgen_as(&nod, n.Left)
+ nod.Type = t
+ ginscall(&nod, proc)
+ regfree(&nod)
+ return
+ }
+
+ // call direct
+ n.Left.Method = 1
+
+ ginscall(n.Left, proc)
+}
+
+/*
+ * call to n has already been generated.
+ * generate:
+ * res = return value from call.
+ */
+func cgen_callret(n *gc.Node, res *gc.Node) {
+ var nod gc.Node
+ var fp *gc.Type
+ var t *gc.Type
+ var flist gc.Iter
+
+ t = n.Left.Type
+ if t.Etype == gc.TPTR32 || t.Etype == gc.TPTR64 {
+ t = t.Type
+ }
+
+ fp = gc.Structfirst(&flist, gc.Getoutarg(t))
+ if fp == nil {
+ gc.Fatal("cgen_callret: nil")
+ }
+
+ nod = gc.Node{}
+ nod.Op = gc.OINDREG
+ nod.Val.U.Reg = x86.REG_SP
+ nod.Addable = 1
+
+ nod.Xoffset = fp.Width
+ nod.Type = fp.Type
+ gc.Cgen_as(res, &nod)
+}
+
+/*
+ * call to n has already been generated.
+ * generate:
+ * res = &return value from call.
+ */
+func cgen_aret(n *gc.Node, res *gc.Node) {
+ var nod1 gc.Node
+ var nod2 gc.Node
+ var fp *gc.Type
+ var t *gc.Type
+ var flist gc.Iter
+
+ t = n.Left.Type
+ if gc.Isptr[t.Etype] != 0 {
+ t = t.Type
+ }
+
+ fp = gc.Structfirst(&flist, gc.Getoutarg(t))
+ if fp == nil {
+ gc.Fatal("cgen_aret: nil")
+ }
+
+ nod1 = gc.Node{}
+ nod1.Op = gc.OINDREG
+ nod1.Val.U.Reg = x86.REG_SP
+ nod1.Addable = 1
+
+ nod1.Xoffset = fp.Width
+ nod1.Type = fp.Type
+
+ if res.Op != gc.OREGISTER {
+ regalloc(&nod2, gc.Types[gc.Tptr], res)
+ gins(leaptr, &nod1, &nod2)
+ gins(movptr, &nod2, res)
+ regfree(&nod2)
+ } else {
+ gins(leaptr, &nod1, res)
+ }
+}
+
+/*
+ * generate return.
+ * n->left is assignments to return values.
+ */
+func cgen_ret(n *gc.Node) {
+ var p *obj.Prog
+
+ if n != nil {
+ gc.Genlist(n.List) // copy out args
+ }
+ if gc.Hasdefer != 0 {
+ ginscall(gc.Deferreturn, 0)
+ }
+ gc.Genlist(gc.Curfn.Exit)
+ p = gins(obj.ARET, nil, nil)
+ if n != nil && n.Op == gc.ORETJMP {
+ p.To.Type = obj.TYPE_MEM
+ p.To.Name = obj.NAME_EXTERN
+ p.To.Sym = gc.Linksym(n.Left.Sym)
+ }
+}
+
+/*
+ * generate division.
+ * generates one of:
+ * res = nl / nr
+ * res = nl % nr
+ * according to op.
+ */
+func dodiv(op int, nl *gc.Node, nr *gc.Node, res *gc.Node) {
+ var a int
+ var check int
+ var n3 gc.Node
+ var n4 gc.Node
+ var t *gc.Type
+ var t0 *gc.Type
+ var ax gc.Node
+ var dx gc.Node
+ var ax1 gc.Node
+ var n31 gc.Node
+ var oldax gc.Node
+ var olddx gc.Node
+ var p1 *obj.Prog
+ var p2 *obj.Prog
+
+ // Have to be careful about handling
+ // most negative int divided by -1 correctly.
+ // The hardware will trap.
+ // Also the byte divide instruction needs AH,
+ // which we otherwise don't have to deal with.
+ // Easiest way to avoid for int8, int16: use int32.
+ // For int32 and int64, use explicit test.
+ // Could use int64 hw for int32.
+ t = nl.Type
+
+ t0 = t
+ check = 0
+ if gc.Issigned[t.Etype] != 0 {
+ check = 1
+ if gc.Isconst(nl, gc.CTINT) != 0 && gc.Mpgetfix(nl.Val.U.Xval) != -(1<<uint64(t.Width*8-1)) {
+ check = 0
+ } else if gc.Isconst(nr, gc.CTINT) != 0 && gc.Mpgetfix(nr.Val.U.Xval) != -1 {
+ check = 0
+ }
+ }
+
+ if t.Width < 4 {
+ if gc.Issigned[t.Etype] != 0 {
+ t = gc.Types[gc.TINT32]
+ } else {
+ t = gc.Types[gc.TUINT32]
+ }
+ check = 0
+ }
+
+ a = optoas(op, t)
+
+ regalloc(&n3, t0, nil)
+ if nl.Ullman >= nr.Ullman {
+ savex(x86.REG_AX, &ax, &oldax, res, t0)
+ cgen(nl, &ax)
+ regalloc(&ax, t0, &ax) // mark ax live during cgen
+ cgen(nr, &n3)
+ regfree(&ax)
+ } else {
+ cgen(nr, &n3)
+ savex(x86.REG_AX, &ax, &oldax, res, t0)
+ cgen(nl, &ax)
+ }
+
+ if t != t0 {
+ // Convert
+ ax1 = ax
+
+ n31 = n3
+ ax.Type = t
+ n3.Type = t
+ gmove(&ax1, &ax)
+ gmove(&n31, &n3)
+ }
+
+ p2 = nil
+ if gc.Nacl {
+ // Native Client does not relay the divide-by-zero trap
+ // to the executing program, so we must insert a check
+ // for ourselves.
+ gc.Nodconst(&n4, t, 0)
+
+ gins(optoas(gc.OCMP, t), &n3, &n4)
+ p1 = gc.Gbranch(optoas(gc.ONE, t), nil, +1)
+ if panicdiv == nil {
+ panicdiv = gc.Sysfunc("panicdivide")
+ }
+ ginscall(panicdiv, -1)
+ gc.Patch(p1, gc.Pc)
+ }
+
+ if check != 0 {
+ gc.Nodconst(&n4, t, -1)
+ gins(optoas(gc.OCMP, t), &n3, &n4)
+ p1 = gc.Gbranch(optoas(gc.ONE, t), nil, +1)
+ if op == gc.ODIV {
+ // a / (-1) is -a.
+ gins(optoas(gc.OMINUS, t), nil, &ax)
+
+ gmove(&ax, res)
+ } else {
+ // a % (-1) is 0.
+ gc.Nodconst(&n4, t, 0)
+
+ gmove(&n4, res)
+ }
+
+ p2 = gc.Gbranch(obj.AJMP, nil, 0)
+ gc.Patch(p1, gc.Pc)
+ }
+
+ savex(x86.REG_DX, &dx, &olddx, res, t)
+ if !(gc.Issigned[t.Etype] != 0) {
+ gc.Nodconst(&n4, t, 0)
+ gmove(&n4, &dx)
+ } else {
+ gins(optoas(gc.OEXTEND, t), nil, nil)
+ }
+ gins(a, &n3, nil)
+ regfree(&n3)
+ if op == gc.ODIV {
+ gmove(&ax, res)
+ } else {
+ gmove(&dx, res)
+ }
+ restx(&dx, &olddx)
+ if check != 0 {
+ gc.Patch(p2, gc.Pc)
+ }
+ restx(&ax, &oldax)
+}
+
+/*
+ * register dr is one of the special ones (AX, CX, DI, SI, etc.).
+ * we need to use it. if it is already allocated as a temporary
+ * (r > 1; can only happen if a routine like sgen passed a
+ * special as cgen's res and then cgen used regalloc to reuse
+ * it as its own temporary), then move it for now to another
+ * register. caller must call restx to move it back.
+ * the move is not necessary if dr == res, because res is
+ * known to be dead.
+ */
+func savex(dr int, x *gc.Node, oldx *gc.Node, res *gc.Node, t *gc.Type) {
+ var r int
+
+ r = int(reg[dr])
+
+ // save current ax and dx if they are live
+ // and not the destination
+ *oldx = gc.Node{}
+
+ gc.Nodreg(x, t, dr)
+ if r > 1 && !(gc.Samereg(x, res) != 0) {
+ regalloc(oldx, gc.Types[gc.TINT64], nil)
+ x.Type = gc.Types[gc.TINT64]
+ gmove(x, oldx)
+ x.Type = t
+ oldx.Ostk = int32(r) // squirrel away old r value
+ reg[dr] = 1
+ }
+}
+
+func restx(x *gc.Node, oldx *gc.Node) {
+ if oldx.Op != 0 {
+ x.Type = gc.Types[gc.TINT64]
+ reg[x.Val.U.Reg] = uint8(oldx.Ostk)
+ gmove(oldx, x)
+ regfree(oldx)
+ }
+}
+
+/*
+ * generate division according to op, one of:
+ * res = nl / nr
+ * res = nl % nr
+ */
+func cgen_div(op int, nl *gc.Node, nr *gc.Node, res *gc.Node) {
+ var n1 gc.Node
+ var n2 gc.Node
+ var n3 gc.Node
+ var w int
+ var a int
+ var m gc.Magic
+
+ if nr.Op != gc.OLITERAL {
+ goto longdiv
+ }
+ w = int(nl.Type.Width * 8)
+
+ // Front end handled 32-bit division. We only need to handle 64-bit.
+ // try to do division by multiply by (2^w)/d
+ // see hacker's delight chapter 10
+ switch gc.Simtype[nl.Type.Etype] {
+ default:
+ goto longdiv
+
+ case gc.TUINT64:
+ m.W = w
+ m.Ud = uint64(gc.Mpgetfix(nr.Val.U.Xval))
+ gc.Umagic(&m)
+ if m.Bad != 0 {
+ break
+ }
+ if op == gc.OMOD {
+ goto longmod
+ }
+
+ cgenr(nl, &n1, nil)
+ gc.Nodconst(&n2, nl.Type, int64(m.Um))
+ regalloc(&n3, nl.Type, res)
+ cgen_hmul(&n1, &n2, &n3)
+
+ if m.Ua != 0 {
+ // need to add numerator accounting for overflow
+ gins(optoas(gc.OADD, nl.Type), &n1, &n3)
+
+ gc.Nodconst(&n2, nl.Type, 1)
+ gins(optoas(gc.ORROTC, nl.Type), &n2, &n3)
+ gc.Nodconst(&n2, nl.Type, int64(m.S)-1)
+ gins(optoas(gc.ORSH, nl.Type), &n2, &n3)
+ } else {
+ gc.Nodconst(&n2, nl.Type, int64(m.S))
+ gins(optoas(gc.ORSH, nl.Type), &n2, &n3) // shift dx
+ }
+
+ gmove(&n3, res)
+ regfree(&n1)
+ regfree(&n3)
+ return
+
+ case gc.TINT64:
+ m.W = w
+ m.Sd = gc.Mpgetfix(nr.Val.U.Xval)
+ gc.Smagic(&m)
+ if m.Bad != 0 {
+ break
+ }
+ if op == gc.OMOD {
+ goto longmod
+ }
+
+ cgenr(nl, &n1, res)
+ gc.Nodconst(&n2, nl.Type, m.Sm)
+ regalloc(&n3, nl.Type, nil)
+ cgen_hmul(&n1, &n2, &n3)
+
+ if m.Sm < 0 {
+ // need to add numerator
+ gins(optoas(gc.OADD, nl.Type), &n1, &n3)
+ }
+
+ gc.Nodconst(&n2, nl.Type, int64(m.S))
+ gins(optoas(gc.ORSH, nl.Type), &n2, &n3) // shift n3
+
+ gc.Nodconst(&n2, nl.Type, int64(w)-1)
+
+ gins(optoas(gc.ORSH, nl.Type), &n2, &n1) // -1 iff num is neg
+ gins(optoas(gc.OSUB, nl.Type), &n1, &n3) // added
+
+ if m.Sd < 0 {
+ // this could probably be removed
+ // by factoring it into the multiplier
+ gins(optoas(gc.OMINUS, nl.Type), nil, &n3)
+ }
+
+ gmove(&n3, res)
+ regfree(&n1)
+ regfree(&n3)
+ return
+ }
+
+ goto longdiv
+
+ // division and mod using (slow) hardware instruction
+longdiv:
+ dodiv(op, nl, nr, res)
+
+ return
+
+ // mod using formula A%B = A-(A/B*B) but
+ // we know that there is a fast algorithm for A/B
+longmod:
+ regalloc(&n1, nl.Type, res)
+
+ cgen(nl, &n1)
+ regalloc(&n2, nl.Type, nil)
+ cgen_div(gc.ODIV, &n1, nr, &n2)
+ a = optoas(gc.OMUL, nl.Type)
+ if w == 8 {
+ // use 2-operand 16-bit multiply
+ // because there is no 2-operand 8-bit multiply
+ a = x86.AIMULW
+ }
+
+ if !(gc.Smallintconst(nr) != 0) {
+ regalloc(&n3, nl.Type, nil)
+ cgen(nr, &n3)
+ gins(a, &n3, &n2)
+ regfree(&n3)
+ } else {
+ gins(a, nr, &n2)
+ }
+ gins(optoas(gc.OSUB, nl.Type), &n2, &n1)
+ gmove(&n1, res)
+ regfree(&n1)
+ regfree(&n2)
+}
+
+/*
+ * generate high multiply:
+ * res = (nl*nr) >> width
+ */
+func cgen_hmul(nl *gc.Node, nr *gc.Node, res *gc.Node) {
+ var t *gc.Type
+ var a int
+ var n1 gc.Node
+ var n2 gc.Node
+ var ax gc.Node
+ var dx gc.Node
+ var tmp *gc.Node
+
+ t = nl.Type
+ a = optoas(gc.OHMUL, t)
+ if nl.Ullman < nr.Ullman {
+ tmp = nl
+ nl = nr
+ nr = tmp
+ }
+
+ cgenr(nl, &n1, res)
+ cgenr(nr, &n2, nil)
+ gc.Nodreg(&ax, t, x86.REG_AX)
+ gmove(&n1, &ax)
+ gins(a, &n2, nil)
+ regfree(&n2)
+ regfree(&n1)
+
+ if t.Width == 1 {
+ // byte multiply behaves differently.
+ gc.Nodreg(&ax, t, x86.REG_AH)
+
+ gc.Nodreg(&dx, t, x86.REG_DX)
+ gmove(&ax, &dx)
+ }
+
+ gc.Nodreg(&dx, t, x86.REG_DX)
+ gmove(&dx, res)
+}
+
+/*
+ * generate shift according to op, one of:
+ * res = nl << nr
+ * res = nl >> nr
+ */
+func cgen_shift(op int, bounded int, nl *gc.Node, nr *gc.Node, res *gc.Node) {
+ var n1 gc.Node
+ var n2 gc.Node
+ var n3 gc.Node
+ var n4 gc.Node
+ var n5 gc.Node
+ var cx gc.Node
+ var oldcx gc.Node
+ var a int
+ var rcx int
+ var p1 *obj.Prog
+ var sc uint64
+ var tcount *gc.Type
+
+ a = optoas(op, nl.Type)
+
+ if nr.Op == gc.OLITERAL {
+ regalloc(&n1, nl.Type, res)
+ cgen(nl, &n1)
+ sc = uint64(gc.Mpgetfix(nr.Val.U.Xval))
+ if sc >= uint64(nl.Type.Width*8) {
+ // large shift gets 2 shifts by width-1
+ gc.Nodconst(&n3, gc.Types[gc.TUINT32], nl.Type.Width*8-1)
+
+ gins(a, &n3, &n1)
+ gins(a, &n3, &n1)
+ } else {
+ gins(a, nr, &n1)
+ }
+ gmove(&n1, res)
+ regfree(&n1)
+ goto ret
+ }
+
+ if nl.Ullman >= gc.UINF {
+ gc.Tempname(&n4, nl.Type)
+ cgen(nl, &n4)
+ nl = &n4
+ }
+
+ if nr.Ullman >= gc.UINF {
+ gc.Tempname(&n5, nr.Type)
+ cgen(nr, &n5)
+ nr = &n5
+ }
+
+ rcx = int(reg[x86.REG_CX])
+ gc.Nodreg(&n1, gc.Types[gc.TUINT32], x86.REG_CX)
+
+ // Allow either uint32 or uint64 as shift type,
+ // to avoid unnecessary conversion from uint32 to uint64
+ // just to do the comparison.
+ tcount = gc.Types[gc.Simtype[nr.Type.Etype]]
+
+ if tcount.Etype < gc.TUINT32 {
+ tcount = gc.Types[gc.TUINT32]
+ }
+
+ regalloc(&n1, nr.Type, &n1) // to hold the shift type in CX
+ regalloc(&n3, tcount, &n1) // to clear high bits of CX
+
+ gc.Nodreg(&cx, gc.Types[gc.TUINT64], x86.REG_CX)
+
+ oldcx = gc.Node{}
+ if rcx > 0 && !(gc.Samereg(&cx, res) != 0) {
+ regalloc(&oldcx, gc.Types[gc.TUINT64], nil)
+ gmove(&cx, &oldcx)
+ }
+
+ cx.Type = tcount
+
+ if gc.Samereg(&cx, res) != 0 {
+ regalloc(&n2, nl.Type, nil)
+ } else {
+ regalloc(&n2, nl.Type, res)
+ }
+ if nl.Ullman >= nr.Ullman {
+ cgen(nl, &n2)
+ cgen(nr, &n1)
+ gmove(&n1, &n3)
+ } else {
+ cgen(nr, &n1)
+ gmove(&n1, &n3)
+ cgen(nl, &n2)
+ }
+
+ regfree(&n3)
+
+ // test and fix up large shifts
+ if !(bounded != 0) {
+ gc.Nodconst(&n3, tcount, nl.Type.Width*8)
+ gins(optoas(gc.OCMP, tcount), &n1, &n3)
+ p1 = gc.Gbranch(optoas(gc.OLT, tcount), nil, +1)
+ if op == gc.ORSH && gc.Issigned[nl.Type.Etype] != 0 {
+ gc.Nodconst(&n3, gc.Types[gc.TUINT32], nl.Type.Width*8-1)
+ gins(a, &n3, &n2)
+ } else {
+ gc.Nodconst(&n3, nl.Type, 0)
+ gmove(&n3, &n2)
+ }
+
+ gc.Patch(p1, gc.Pc)
+ }
+
+ gins(a, &n1, &n2)
+
+ if oldcx.Op != 0 {
+ cx.Type = gc.Types[gc.TUINT64]
+ gmove(&oldcx, &cx)
+ regfree(&oldcx)
+ }
+
+ gmove(&n2, res)
+
+ regfree(&n1)
+ regfree(&n2)
+
+ret:
+}
+
+/*
+ * generate byte multiply:
+ * res = nl * nr
+ * there is no 2-operand byte multiply instruction so
+ * we do a full-width multiplication and truncate afterwards.
+ */
+func cgen_bmul(op int, nl *gc.Node, nr *gc.Node, res *gc.Node) {
+ var n1 gc.Node
+ var n2 gc.Node
+ var n1b gc.Node
+ var n2b gc.Node
+ var tmp *gc.Node
+ var t *gc.Type
+ var a int
+
+ // largest ullman on left.
+ if nl.Ullman < nr.Ullman {
+ tmp = nl
+ nl = nr
+ nr = tmp
+ }
+
+ // generate operands in "8-bit" registers.
+ regalloc(&n1b, nl.Type, res)
+
+ cgen(nl, &n1b)
+ regalloc(&n2b, nr.Type, nil)
+ cgen(nr, &n2b)
+
+ // perform full-width multiplication.
+ t = gc.Types[gc.TUINT64]
+
+ if gc.Issigned[nl.Type.Etype] != 0 {
+ t = gc.Types[gc.TINT64]
+ }
+ gc.Nodreg(&n1, t, int(n1b.Val.U.Reg))
+ gc.Nodreg(&n2, t, int(n2b.Val.U.Reg))
+ a = optoas(op, t)
+ gins(a, &n2, &n1)
+
+ // truncate.
+ gmove(&n1, res)
+
+ regfree(&n1b)
+ regfree(&n2b)
+}
+
+func clearfat(nl *gc.Node) {
+ var w int64
+ var c int64
+ var q int64
+ var n1 gc.Node
+ var oldn1 gc.Node
+ var ax gc.Node
+ var oldax gc.Node
+ var di gc.Node
+ var z gc.Node
+ var p *obj.Prog
+
+ /* clear a fat object */
+ if gc.Debug['g'] != 0 {
+ gc.Dump("\nclearfat", nl)
+ }
+
+ w = nl.Type.Width
+
+ // Avoid taking the address for simple enough types.
+ if componentgen(nil, nl) != 0 {
+ return
+ }
+
+ c = w % 8 // bytes
+ q = w / 8 // quads
+
+ if q < 4 {
+ // Write sequence of MOV 0, off(base) instead of using STOSQ.
+ // The hope is that although the code will be slightly longer,
+ // the MOVs will have no dependencies and pipeline better
+ // than the unrolled STOSQ loop.
+ // NOTE: Must use agen, not igen, so that optimizer sees address
+ // being taken. We are not writing on field boundaries.
+ agenr(nl, &n1, nil)
+
+ n1.Op = gc.OINDREG
+ gc.Nodconst(&z, gc.Types[gc.TUINT64], 0)
+ for {
+ tmp14 := q
+ q--
+ if !(tmp14 > 0) {
+ break
+ }
+ n1.Type = z.Type
+ gins(x86.AMOVQ, &z, &n1)
+ n1.Xoffset += 8
+ }
+
+ if c >= 4 {
+ gc.Nodconst(&z, gc.Types[gc.TUINT32], 0)
+ n1.Type = z.Type
+ gins(x86.AMOVL, &z, &n1)
+ n1.Xoffset += 4
+ c -= 4
+ }
+
+ gc.Nodconst(&z, gc.Types[gc.TUINT8], 0)
+ for {
+ tmp15 := c
+ c--
+ if !(tmp15 > 0) {
+ break
+ }
+ n1.Type = z.Type
+ gins(x86.AMOVB, &z, &n1)
+ n1.Xoffset++
+ }
+
+ regfree(&n1)
+ return
+ }
+
+ savex(x86.REG_DI, &n1, &oldn1, nil, gc.Types[gc.Tptr])
+ agen(nl, &n1)
+
+ savex(x86.REG_AX, &ax, &oldax, nil, gc.Types[gc.Tptr])
+ gconreg(x86.AMOVL, 0, x86.REG_AX)
+
+ if q > 128 || gc.Nacl {
+ gconreg(movptr, q, x86.REG_CX)
+ gins(x86.AREP, nil, nil) // repeat
+ gins(x86.ASTOSQ, nil, nil) // STOQ AL,*(DI)+
+ } else {
+ p = gins(obj.ADUFFZERO, nil, nil)
+ p.To.Type = obj.TYPE_ADDR
+ p.To.Sym = gc.Linksym(gc.Pkglookup("duffzero", gc.Runtimepkg))
+
+ // 2 and 128 = magic constants: see ../../runtime/asm_amd64.s
+ p.To.Offset = 2 * (128 - q)
+ }
+
+ z = ax
+ di = n1
+ if w >= 8 && c >= 4 {
+ di.Op = gc.OINDREG
+ z.Type = gc.Types[gc.TINT64]
+ di.Type = z.Type
+ p = gins(x86.AMOVQ, &z, &di)
+ p.To.Scale = 1
+ p.To.Offset = c - 8
+ } else if c >= 4 {
+ di.Op = gc.OINDREG
+ z.Type = gc.Types[gc.TINT32]
+ di.Type = z.Type
+ p = gins(x86.AMOVL, &z, &di)
+ if c > 4 {
+ p = gins(x86.AMOVL, &z, &di)
+ p.To.Scale = 1
+ p.To.Offset = c - 4
+ }
+ } else {
+ for c > 0 {
+ gins(x86.ASTOSB, nil, nil) // STOB AL,*(DI)+
+ c--
+ }
+ }
+
+ restx(&n1, &oldn1)
+ restx(&ax, &oldax)
+}
+
+// Called after regopt and peep have run.
+// Expand CHECKNIL pseudo-op into actual nil pointer check.
+func expandchecks(firstp *obj.Prog) {
+ var p *obj.Prog
+ var p1 *obj.Prog
+ var p2 *obj.Prog
+
+ for p = firstp; p != nil; p = p.Link {
+ if p.As != obj.ACHECKNIL {
+ continue
+ }
+ if gc.Debug_checknil != 0 && p.Lineno > 1 { // p->lineno==1 in generated wrappers
+ gc.Warnl(int(p.Lineno), "generated nil check")
+ }
+
+ // check is
+ // CMP arg, $0
+ // JNE 2(PC) (likely)
+ // MOV AX, 0
+ p1 = gc.Ctxt.NewProg()
+
+ p2 = gc.Ctxt.NewProg()
+ gc.Clearp(p1)
+ gc.Clearp(p2)
+ p1.Link = p2
+ p2.Link = p.Link
+ p.Link = p1
+ p1.Lineno = p.Lineno
+ p2.Lineno = p.Lineno
+ p1.Pc = 9999
+ p2.Pc = 9999
+ p.As = int16(cmpptr)
+ p.To.Type = obj.TYPE_CONST
+ p.To.Offset = 0
+ p1.As = x86.AJNE
+ p1.From.Type = obj.TYPE_CONST
+ p1.From.Offset = 1 // likely
+ p1.To.Type = obj.TYPE_BRANCH
+ p1.To.U.Branch = p2.Link
+
+ // crash by write to memory address 0.
+ // if possible, since we know arg is 0, use 0(arg),
+ // which will be shorter to encode than plain 0.
+ p2.As = x86.AMOVL
+
+ p2.From.Type = obj.TYPE_REG
+ p2.From.Reg = x86.REG_AX
+ if regtyp(&p.From) != 0 {
+ p2.To.Type = obj.TYPE_MEM
+ p2.To.Reg = p.From.Reg
+ } else {
+ p2.To.Type = obj.TYPE_MEM
+ p2.To.Reg = x86.REG_NONE
+ }
+
+ p2.To.Offset = 0
+ }
+}
--- /dev/null
+// 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 main
+
+import (
+ "cmd/internal/obj"
+ "cmd/internal/obj/x86"
+ "fmt"
+)
+import "cmd/internal/gc"
+
+// TODO(rsc): Can make this bigger if we move
+// the text segment up higher in 6l for all GOOS.
+// At the same time, can raise StackBig in ../../runtime/stack.h.
+var unmappedzero int64 = 4096
+
+var resvd = []int{
+ x86.REG_DI, // for movstring
+ x86.REG_SI, // for movstring
+
+ x86.REG_AX, // for divide
+ x86.REG_CX, // for shift
+ x86.REG_DX, // for divide
+ x86.REG_SP, // for stack
+}
+
+func ginit() {
+ var i int
+
+ for i = 0; i < len(reg); i++ {
+ reg[i] = 1
+ }
+ for i = x86.REG_AX; i <= x86.REG_R15; i++ {
+ reg[i] = 0
+ }
+ for i = x86.REG_X0; i <= x86.REG_X15; i++ {
+ reg[i] = 0
+ }
+
+ for i = 0; i < len(resvd); i++ {
+ reg[resvd[i]]++
+ }
+
+ if gc.Nacl {
+ reg[x86.REG_BP]++
+ reg[x86.REG_R15]++
+ } else if obj.Framepointer_enabled != 0 {
+ // BP is part of the calling convention of framepointer_enabled.
+ reg[x86.REG_BP]++
+ }
+}
+
+func gclean() {
+ var i int
+
+ for i = 0; i < len(resvd); i++ {
+ reg[resvd[i]]--
+ }
+ if gc.Nacl {
+ reg[x86.REG_BP]--
+ reg[x86.REG_R15]--
+ } else if obj.Framepointer_enabled != 0 {
+ reg[x86.REG_BP]--
+ }
+
+ for i = x86.REG_AX; i <= x86.REG_R15; i++ {
+ if reg[i] != 0 {
+ gc.Yyerror("reg %v left allocated\n", gc.Ctxt.Rconv(i))
+ }
+ }
+ for i = x86.REG_X0; i <= x86.REG_X15; i++ {
+ if reg[i] != 0 {
+ gc.Yyerror("reg %v left allocated\n", gc.Ctxt.Rconv(i))
+ }
+ }
+}
+
+func anyregalloc() int {
+ var i int
+ var j int
+
+ for i = x86.REG_AX; i <= x86.REG_R15; i++ {
+ if reg[i] == 0 {
+ goto ok
+ }
+ for j = 0; j < len(resvd); j++ {
+ if resvd[j] == i {
+ goto ok
+ }
+ }
+ return 1
+ ok:
+ }
+
+ return 0
+}
+
+var regpc [x86.REG_R15 + 1 - x86.REG_AX]uint32
+
+/*
+ * allocate register of type t, leave in n.
+ * if o != N, o is desired fixed register.
+ * caller must regfree(n).
+ */
+func regalloc(n *gc.Node, t *gc.Type, o *gc.Node) {
+ var i int
+ var et int
+
+ if t == nil {
+ gc.Fatal("regalloc: t nil")
+ }
+ et = int(gc.Simtype[t.Etype])
+
+ switch et {
+ case gc.TINT8,
+ gc.TUINT8,
+ gc.TINT16,
+ gc.TUINT16,
+ gc.TINT32,
+ gc.TUINT32,
+ gc.TINT64,
+ gc.TUINT64,
+ gc.TPTR32,
+ gc.TPTR64,
+ gc.TBOOL:
+ if o != nil && o.Op == gc.OREGISTER {
+ i = int(o.Val.U.Reg)
+ if i >= x86.REG_AX && i <= x86.REG_R15 {
+ goto out
+ }
+ }
+
+ for i = x86.REG_AX; i <= x86.REG_R15; i++ {
+ if reg[i] == 0 {
+ regpc[i-x86.REG_AX] = uint32(obj.Getcallerpc(&n))
+ goto out
+ }
+ }
+
+ gc.Flusherrors()
+ for i = 0; i+x86.REG_AX <= x86.REG_R15; i++ {
+ fmt.Printf("%d %p\n", i, regpc[i])
+ }
+ gc.Fatal("out of fixed registers")
+ fallthrough
+
+ case gc.TFLOAT32,
+ gc.TFLOAT64:
+ if o != nil && o.Op == gc.OREGISTER {
+ i = int(o.Val.U.Reg)
+ if i >= x86.REG_X0 && i <= x86.REG_X15 {
+ goto out
+ }
+ }
+
+ for i = x86.REG_X0; i <= x86.REG_X15; i++ {
+ if reg[i] == 0 {
+ goto out
+ }
+ }
+ gc.Fatal("out of floating registers")
+ fallthrough
+
+ case gc.TCOMPLEX64,
+ gc.TCOMPLEX128:
+ gc.Tempname(n, t)
+ return
+ }
+
+ gc.Fatal("regalloc: unknown type %v", gc.Tconv(t, 0))
+ return
+
+out:
+ reg[i]++
+ gc.Nodreg(n, t, i)
+}
+
+func regfree(n *gc.Node) {
+ var i int
+
+ if n.Op == gc.ONAME {
+ return
+ }
+ if n.Op != gc.OREGISTER && n.Op != gc.OINDREG {
+ gc.Fatal("regfree: not a register")
+ }
+ i = int(n.Val.U.Reg)
+ if i == x86.REG_SP {
+ return
+ }
+ if i < 0 || i >= len(reg) {
+ gc.Fatal("regfree: reg out of range")
+ }
+ if reg[i] <= 0 {
+ gc.Fatal("regfree: reg not allocated")
+ }
+ reg[i]--
+ if reg[i] == 0 && x86.REG_AX <= i && i <= x86.REG_R15 {
+ regpc[i-x86.REG_AX] = 0
+ }
+}
+
+/*
+ * generate
+ * as $c, reg
+ */
+func gconreg(as int, c int64, reg int) {
+ var nr gc.Node
+
+ switch as {
+ case x86.AADDL,
+ x86.AMOVL,
+ x86.ALEAL:
+ gc.Nodreg(&nr, gc.Types[gc.TINT32], reg)
+
+ default:
+ gc.Nodreg(&nr, gc.Types[gc.TINT64], reg)
+ }
+
+ ginscon(as, c, &nr)
+}
+
+/*
+ * generate
+ * as $c, n
+ */
+func ginscon(as int, c int64, n2 *gc.Node) {
+ var n1 gc.Node
+ var ntmp gc.Node
+
+ switch as {
+ case x86.AADDL,
+ x86.AMOVL,
+ x86.ALEAL:
+ gc.Nodconst(&n1, gc.Types[gc.TINT32], c)
+
+ default:
+ gc.Nodconst(&n1, gc.Types[gc.TINT64], c)
+ }
+
+ if as != x86.AMOVQ && (c < -(1<<31) || c >= 1<<31) {
+ // cannot have 64-bit immediate in ADD, etc.
+ // instead, MOV into register first.
+ regalloc(&ntmp, gc.Types[gc.TINT64], nil)
+
+ gins(x86.AMOVQ, &n1, &ntmp)
+ gins(as, &ntmp, n2)
+ regfree(&ntmp)
+ return
+ }
+
+ gins(as, &n1, n2)
+}
+
+/*
+ * set up nodes representing 2^63
+ */
+var bigi gc.Node
+
+var bigf gc.Node
+
+var bignodes_did int
+
+func bignodes() {
+ if bignodes_did != 0 {
+ return
+ }
+ bignodes_did = 1
+
+ gc.Nodconst(&bigi, gc.Types[gc.TUINT64], 1)
+ gc.Mpshiftfix(bigi.Val.U.Xval, 63)
+
+ bigf = bigi
+ bigf.Type = gc.Types[gc.TFLOAT64]
+ bigf.Val.Ctype = gc.CTFLT
+ bigf.Val.U.Fval = new(gc.Mpflt)
+ gc.Mpmovefixflt(bigf.Val.U.Fval, bigi.Val.U.Xval)
+}
+
+/*
+ * generate move:
+ * t = f
+ * hard part is conversions.
+ */
+func gmove(f *gc.Node, t *gc.Node) {
+ var a int
+ var ft int
+ var tt int
+ var cvt *gc.Type
+ var r1 gc.Node
+ var r2 gc.Node
+ var r3 gc.Node
+ var r4 gc.Node
+ var zero gc.Node
+ var one gc.Node
+ var con gc.Node
+ var p1 *obj.Prog
+ var p2 *obj.Prog
+
+ if gc.Debug['M'] != 0 {
+ fmt.Printf("gmove %v -> %v\n", gc.Nconv(f, obj.FmtLong), gc.Nconv(t, obj.FmtLong))
+ }
+
+ ft = gc.Simsimtype(f.Type)
+ tt = gc.Simsimtype(t.Type)
+ cvt = t.Type
+
+ if gc.Iscomplex[ft] != 0 || gc.Iscomplex[tt] != 0 {
+ gc.Complexmove(f, t)
+ return
+ }
+
+ // cannot have two memory operands
+ if gc.Ismem(f) != 0 && gc.Ismem(t) != 0 {
+ goto hard
+ }
+
+ // convert constant to desired type
+ if f.Op == gc.OLITERAL {
+ gc.Convconst(&con, t.Type, &f.Val)
+ f = &con
+ ft = tt // so big switch will choose a simple mov
+
+ // some constants can't move directly to memory.
+ if gc.Ismem(t) != 0 {
+ // float constants come from memory.
+ if gc.Isfloat[tt] != 0 {
+ goto hard
+ }
+
+ // 64-bit immediates are really 32-bit sign-extended
+ // unless moving into a register.
+ if gc.Isint[tt] != 0 {
+ if gc.Mpcmpfixfix(con.Val.U.Xval, gc.Minintval[gc.TINT32]) < 0 {
+ goto hard
+ }
+ if gc.Mpcmpfixfix(con.Val.U.Xval, gc.Maxintval[gc.TINT32]) > 0 {
+ goto hard
+ }
+ }
+ }
+ }
+
+ // value -> value copy, only one memory operand.
+ // figure out the instruction to use.
+ // break out of switch for one-instruction gins.
+ // goto rdst for "destination must be register".
+ // goto hard for "convert to cvt type first".
+ // otherwise handle and return.
+
+ switch uint32(ft)<<16 | uint32(tt) {
+ default:
+ gc.Fatal("gmove %v -> %v", gc.Tconv(f.Type, obj.FmtLong), gc.Tconv(t.Type, obj.FmtLong))
+ fallthrough
+
+ /*
+ * integer copy and truncate
+ */
+ case gc.TINT8<<16 | gc.TINT8, // same size
+ gc.TINT8<<16 | gc.TUINT8,
+ gc.TUINT8<<16 | gc.TINT8,
+ gc.TUINT8<<16 | gc.TUINT8,
+ gc.TINT16<<16 | gc.TINT8,
+ // truncate
+ gc.TUINT16<<16 | gc.TINT8,
+ gc.TINT32<<16 | gc.TINT8,
+ gc.TUINT32<<16 | gc.TINT8,
+ gc.TINT64<<16 | gc.TINT8,
+ gc.TUINT64<<16 | gc.TINT8,
+ gc.TINT16<<16 | gc.TUINT8,
+ gc.TUINT16<<16 | gc.TUINT8,
+ gc.TINT32<<16 | gc.TUINT8,
+ gc.TUINT32<<16 | gc.TUINT8,
+ gc.TINT64<<16 | gc.TUINT8,
+ gc.TUINT64<<16 | gc.TUINT8:
+ a = x86.AMOVB
+
+ case gc.TINT16<<16 | gc.TINT16, // same size
+ gc.TINT16<<16 | gc.TUINT16,
+ gc.TUINT16<<16 | gc.TINT16,
+ gc.TUINT16<<16 | gc.TUINT16,
+ gc.TINT32<<16 | gc.TINT16,
+ // truncate
+ gc.TUINT32<<16 | gc.TINT16,
+ gc.TINT64<<16 | gc.TINT16,
+ gc.TUINT64<<16 | gc.TINT16,
+ gc.TINT32<<16 | gc.TUINT16,
+ gc.TUINT32<<16 | gc.TUINT16,
+ gc.TINT64<<16 | gc.TUINT16,
+ gc.TUINT64<<16 | gc.TUINT16:
+ a = x86.AMOVW
+
+ case gc.TINT32<<16 | gc.TINT32, // same size
+ gc.TINT32<<16 | gc.TUINT32,
+ gc.TUINT32<<16 | gc.TINT32,
+ gc.TUINT32<<16 | gc.TUINT32:
+ a = x86.AMOVL
+
+ case gc.TINT64<<16 | gc.TINT32, // truncate
+ gc.TUINT64<<16 | gc.TINT32,
+ gc.TINT64<<16 | gc.TUINT32,
+ gc.TUINT64<<16 | gc.TUINT32:
+ a = x86.AMOVQL
+
+ case gc.TINT64<<16 | gc.TINT64, // same size
+ gc.TINT64<<16 | gc.TUINT64,
+ gc.TUINT64<<16 | gc.TINT64,
+ gc.TUINT64<<16 | gc.TUINT64:
+ a = x86.AMOVQ
+
+ /*
+ * integer up-conversions
+ */
+ case gc.TINT8<<16 | gc.TINT16, // sign extend int8
+ gc.TINT8<<16 | gc.TUINT16:
+ a = x86.AMOVBWSX
+
+ goto rdst
+
+ case gc.TINT8<<16 | gc.TINT32,
+ gc.TINT8<<16 | gc.TUINT32:
+ a = x86.AMOVBLSX
+ goto rdst
+
+ case gc.TINT8<<16 | gc.TINT64,
+ gc.TINT8<<16 | gc.TUINT64:
+ a = x86.AMOVBQSX
+ goto rdst
+
+ case gc.TUINT8<<16 | gc.TINT16, // zero extend uint8
+ gc.TUINT8<<16 | gc.TUINT16:
+ a = x86.AMOVBWZX
+
+ goto rdst
+
+ case gc.TUINT8<<16 | gc.TINT32,
+ gc.TUINT8<<16 | gc.TUINT32:
+ a = x86.AMOVBLZX
+ goto rdst
+
+ case gc.TUINT8<<16 | gc.TINT64,
+ gc.TUINT8<<16 | gc.TUINT64:
+ a = x86.AMOVBQZX
+ goto rdst
+
+ case gc.TINT16<<16 | gc.TINT32, // sign extend int16
+ gc.TINT16<<16 | gc.TUINT32:
+ a = x86.AMOVWLSX
+
+ goto rdst
+
+ case gc.TINT16<<16 | gc.TINT64,
+ gc.TINT16<<16 | gc.TUINT64:
+ a = x86.AMOVWQSX
+ goto rdst
+
+ case gc.TUINT16<<16 | gc.TINT32, // zero extend uint16
+ gc.TUINT16<<16 | gc.TUINT32:
+ a = x86.AMOVWLZX
+
+ goto rdst
+
+ case gc.TUINT16<<16 | gc.TINT64,
+ gc.TUINT16<<16 | gc.TUINT64:
+ a = x86.AMOVWQZX
+ goto rdst
+
+ case gc.TINT32<<16 | gc.TINT64, // sign extend int32
+ gc.TINT32<<16 | gc.TUINT64:
+ a = x86.AMOVLQSX
+
+ goto rdst
+
+ // AMOVL into a register zeros the top of the register,
+ // so this is not always necessary, but if we rely on AMOVL
+ // the optimizer is almost certain to screw with us.
+ case gc.TUINT32<<16 | gc.TINT64, // zero extend uint32
+ gc.TUINT32<<16 | gc.TUINT64:
+ a = x86.AMOVLQZX
+
+ goto rdst
+
+ /*
+ * float to integer
+ */
+ case gc.TFLOAT32<<16 | gc.TINT32:
+ a = x86.ACVTTSS2SL
+
+ goto rdst
+
+ case gc.TFLOAT64<<16 | gc.TINT32:
+ a = x86.ACVTTSD2SL
+ goto rdst
+
+ case gc.TFLOAT32<<16 | gc.TINT64:
+ a = x86.ACVTTSS2SQ
+ goto rdst
+
+ case gc.TFLOAT64<<16 | gc.TINT64:
+ a = x86.ACVTTSD2SQ
+ goto rdst
+
+ // convert via int32.
+ case gc.TFLOAT32<<16 | gc.TINT16,
+ gc.TFLOAT32<<16 | gc.TINT8,
+ gc.TFLOAT32<<16 | gc.TUINT16,
+ gc.TFLOAT32<<16 | gc.TUINT8,
+ gc.TFLOAT64<<16 | gc.TINT16,
+ gc.TFLOAT64<<16 | gc.TINT8,
+ gc.TFLOAT64<<16 | gc.TUINT16,
+ gc.TFLOAT64<<16 | gc.TUINT8:
+ cvt = gc.Types[gc.TINT32]
+
+ goto hard
+
+ // convert via int64.
+ case gc.TFLOAT32<<16 | gc.TUINT32,
+ gc.TFLOAT64<<16 | gc.TUINT32:
+ cvt = gc.Types[gc.TINT64]
+
+ goto hard
+
+ // algorithm is:
+ // if small enough, use native float64 -> int64 conversion.
+ // otherwise, subtract 2^63, convert, and add it back.
+ case gc.TFLOAT32<<16 | gc.TUINT64,
+ gc.TFLOAT64<<16 | gc.TUINT64:
+ a = x86.ACVTTSS2SQ
+
+ if ft == gc.TFLOAT64 {
+ a = x86.ACVTTSD2SQ
+ }
+ bignodes()
+ regalloc(&r1, gc.Types[ft], nil)
+ regalloc(&r2, gc.Types[tt], t)
+ regalloc(&r3, gc.Types[ft], nil)
+ regalloc(&r4, gc.Types[tt], nil)
+ gins(optoas(gc.OAS, f.Type), f, &r1)
+ gins(optoas(gc.OCMP, f.Type), &bigf, &r1)
+ p1 = gc.Gbranch(optoas(gc.OLE, f.Type), nil, +1)
+ gins(a, &r1, &r2)
+ p2 = gc.Gbranch(obj.AJMP, nil, 0)
+ gc.Patch(p1, gc.Pc)
+ gins(optoas(gc.OAS, f.Type), &bigf, &r3)
+ gins(optoas(gc.OSUB, f.Type), &r3, &r1)
+ gins(a, &r1, &r2)
+ gins(x86.AMOVQ, &bigi, &r4)
+ gins(x86.AXORQ, &r4, &r2)
+ gc.Patch(p2, gc.Pc)
+ gmove(&r2, t)
+ regfree(&r4)
+ regfree(&r3)
+ regfree(&r2)
+ regfree(&r1)
+ return
+
+ /*
+ * integer to float
+ */
+ case gc.TINT32<<16 | gc.TFLOAT32:
+ a = x86.ACVTSL2SS
+
+ goto rdst
+
+ case gc.TINT32<<16 | gc.TFLOAT64:
+ a = x86.ACVTSL2SD
+ goto rdst
+
+ case gc.TINT64<<16 | gc.TFLOAT32:
+ a = x86.ACVTSQ2SS
+ goto rdst
+
+ case gc.TINT64<<16 | gc.TFLOAT64:
+ a = x86.ACVTSQ2SD
+ goto rdst
+
+ // convert via int32
+ case gc.TINT16<<16 | gc.TFLOAT32,
+ gc.TINT16<<16 | gc.TFLOAT64,
+ gc.TINT8<<16 | gc.TFLOAT32,
+ gc.TINT8<<16 | gc.TFLOAT64,
+ gc.TUINT16<<16 | gc.TFLOAT32,
+ gc.TUINT16<<16 | gc.TFLOAT64,
+ gc.TUINT8<<16 | gc.TFLOAT32,
+ gc.TUINT8<<16 | gc.TFLOAT64:
+ cvt = gc.Types[gc.TINT32]
+
+ goto hard
+
+ // convert via int64.
+ case gc.TUINT32<<16 | gc.TFLOAT32,
+ gc.TUINT32<<16 | gc.TFLOAT64:
+ cvt = gc.Types[gc.TINT64]
+
+ goto hard
+
+ // algorithm is:
+ // if small enough, use native int64 -> uint64 conversion.
+ // otherwise, halve (rounding to odd?), convert, and double.
+ case gc.TUINT64<<16 | gc.TFLOAT32,
+ gc.TUINT64<<16 | gc.TFLOAT64:
+ a = x86.ACVTSQ2SS
+
+ if tt == gc.TFLOAT64 {
+ a = x86.ACVTSQ2SD
+ }
+ gc.Nodconst(&zero, gc.Types[gc.TUINT64], 0)
+ gc.Nodconst(&one, gc.Types[gc.TUINT64], 1)
+ regalloc(&r1, f.Type, f)
+ regalloc(&r2, t.Type, t)
+ regalloc(&r3, f.Type, nil)
+ regalloc(&r4, f.Type, nil)
+ gmove(f, &r1)
+ gins(x86.ACMPQ, &r1, &zero)
+ p1 = gc.Gbranch(x86.AJLT, nil, +1)
+ gins(a, &r1, &r2)
+ p2 = gc.Gbranch(obj.AJMP, nil, 0)
+ gc.Patch(p1, gc.Pc)
+ gmove(&r1, &r3)
+ gins(x86.ASHRQ, &one, &r3)
+ gmove(&r1, &r4)
+ gins(x86.AANDL, &one, &r4)
+ gins(x86.AORQ, &r4, &r3)
+ gins(a, &r3, &r2)
+ gins(optoas(gc.OADD, t.Type), &r2, &r2)
+ gc.Patch(p2, gc.Pc)
+ gmove(&r2, t)
+ regfree(&r4)
+ regfree(&r3)
+ regfree(&r2)
+ regfree(&r1)
+ return
+
+ /*
+ * float to float
+ */
+ case gc.TFLOAT32<<16 | gc.TFLOAT32:
+ a = x86.AMOVSS
+
+ case gc.TFLOAT64<<16 | gc.TFLOAT64:
+ a = x86.AMOVSD
+
+ case gc.TFLOAT32<<16 | gc.TFLOAT64:
+ a = x86.ACVTSS2SD
+ goto rdst
+
+ case gc.TFLOAT64<<16 | gc.TFLOAT32:
+ a = x86.ACVTSD2SS
+ goto rdst
+ }
+
+ gins(a, f, t)
+ return
+
+ // requires register destination
+rdst:
+ regalloc(&r1, t.Type, t)
+
+ gins(a, f, &r1)
+ gmove(&r1, t)
+ regfree(&r1)
+ return
+
+ // requires register intermediate
+hard:
+ regalloc(&r1, cvt, t)
+
+ gmove(f, &r1)
+ gmove(&r1, t)
+ regfree(&r1)
+ return
+}
+
+func samaddr(f *gc.Node, t *gc.Node) int {
+ if f.Op != t.Op {
+ return 0
+ }
+
+ switch f.Op {
+ case gc.OREGISTER:
+ if f.Val.U.Reg != t.Val.U.Reg {
+ break
+ }
+ return 1
+ }
+
+ return 0
+}
+
+/*
+ * generate one instruction:
+ * as f, t
+ */
+func gins(as int, f *gc.Node, t *gc.Node) *obj.Prog {
+ var w int32
+ var p *obj.Prog
+ // Node nod;
+
+ var af obj.Addr
+ var at obj.Addr
+
+ // if(f != N && f->op == OINDEX) {
+ // regalloc(&nod, ®node, Z);
+ // v = constnode.vconst;
+ // cgen(f->right, &nod);
+ // constnode.vconst = v;
+ // idx.reg = nod.reg;
+ // regfree(&nod);
+ // }
+ // if(t != N && t->op == OINDEX) {
+ // regalloc(&nod, ®node, Z);
+ // v = constnode.vconst;
+ // cgen(t->right, &nod);
+ // constnode.vconst = v;
+ // idx.reg = nod.reg;
+ // regfree(&nod);
+ // }
+
+ switch as {
+ case x86.AMOVB,
+ x86.AMOVW,
+ x86.AMOVL,
+ x86.AMOVQ,
+ x86.AMOVSS,
+ x86.AMOVSD:
+ if f != nil && t != nil && samaddr(f, t) != 0 {
+ return nil
+ }
+
+ case x86.ALEAQ:
+ if f != nil && gc.Isconst(f, gc.CTNIL) != 0 {
+ gc.Fatal("gins LEAQ nil %v", gc.Tconv(f.Type, 0))
+ }
+ }
+
+ af = obj.Addr{}
+ at = obj.Addr{}
+ if f != nil {
+ gc.Naddr(f, &af, 1)
+ }
+ if t != nil {
+ gc.Naddr(t, &at, 1)
+ }
+ p = gc.Prog(as)
+ if f != nil {
+ p.From = af
+ }
+ if t != nil {
+ p.To = at
+ }
+ if gc.Debug['g'] != 0 {
+ fmt.Printf("%v\n", p)
+ }
+
+ w = 0
+ switch as {
+ case x86.AMOVB:
+ w = 1
+
+ case x86.AMOVW:
+ w = 2
+
+ case x86.AMOVL:
+ w = 4
+
+ case x86.AMOVQ:
+ w = 8
+ }
+
+ if w != 0 && ((f != nil && af.Width < int64(w)) || (t != nil && at.Width > int64(w))) {
+ gc.Dump("f", f)
+ gc.Dump("t", t)
+ gc.Fatal("bad width: %v (%d, %d)\n", p, af.Width, at.Width)
+ }
+
+ if p.To.Type == obj.TYPE_ADDR && w > 0 {
+ gc.Fatal("bad use of addr: %v", p)
+ }
+
+ return p
+}
+
+func fixlargeoffset(n *gc.Node) {
+ var a gc.Node
+
+ if n == nil {
+ return
+ }
+ if n.Op != gc.OINDREG {
+ return
+ }
+ if n.Val.U.Reg == x86.REG_SP { // stack offset cannot be large
+ return
+ }
+ if n.Xoffset != int64(int32(n.Xoffset)) {
+ // offset too large, add to register instead.
+ a = *n
+
+ a.Op = gc.OREGISTER
+ a.Type = gc.Types[gc.Tptr]
+ a.Xoffset = 0
+ gc.Cgen_checknil(&a)
+ ginscon(optoas(gc.OADD, gc.Types[gc.Tptr]), n.Xoffset, &a)
+ n.Xoffset = 0
+ }
+}
+
+/*
+ * return Axxx for Oxxx on type t.
+ */
+func optoas(op int, t *gc.Type) int {
+ var a int
+
+ if t == nil {
+ gc.Fatal("optoas: t is nil")
+ }
+
+ a = obj.AXXX
+ switch uint32(op)<<16 | uint32(gc.Simtype[t.Etype]) {
+ default:
+ gc.Fatal("optoas: no entry %v-%v", gc.Oconv(int(op), 0), gc.Tconv(t, 0))
+
+ case gc.OADDR<<16 | gc.TPTR32:
+ a = x86.ALEAL
+
+ case gc.OADDR<<16 | gc.TPTR64:
+ a = x86.ALEAQ
+
+ case gc.OEQ<<16 | gc.TBOOL,
+ gc.OEQ<<16 | gc.TINT8,
+ gc.OEQ<<16 | gc.TUINT8,
+ gc.OEQ<<16 | gc.TINT16,
+ gc.OEQ<<16 | gc.TUINT16,
+ gc.OEQ<<16 | gc.TINT32,
+ gc.OEQ<<16 | gc.TUINT32,
+ gc.OEQ<<16 | gc.TINT64,
+ gc.OEQ<<16 | gc.TUINT64,
+ gc.OEQ<<16 | gc.TPTR32,
+ gc.OEQ<<16 | gc.TPTR64,
+ gc.OEQ<<16 | gc.TFLOAT32,
+ gc.OEQ<<16 | gc.TFLOAT64:
+ a = x86.AJEQ
+
+ case gc.ONE<<16 | gc.TBOOL,
+ gc.ONE<<16 | gc.TINT8,
+ gc.ONE<<16 | gc.TUINT8,
+ gc.ONE<<16 | gc.TINT16,
+ gc.ONE<<16 | gc.TUINT16,
+ gc.ONE<<16 | gc.TINT32,
+ gc.ONE<<16 | gc.TUINT32,
+ gc.ONE<<16 | gc.TINT64,
+ gc.ONE<<16 | gc.TUINT64,
+ gc.ONE<<16 | gc.TPTR32,
+ gc.ONE<<16 | gc.TPTR64,
+ gc.ONE<<16 | gc.TFLOAT32,
+ gc.ONE<<16 | gc.TFLOAT64:
+ a = x86.AJNE
+
+ case gc.OLT<<16 | gc.TINT8,
+ gc.OLT<<16 | gc.TINT16,
+ gc.OLT<<16 | gc.TINT32,
+ gc.OLT<<16 | gc.TINT64:
+ a = x86.AJLT
+
+ case gc.OLT<<16 | gc.TUINT8,
+ gc.OLT<<16 | gc.TUINT16,
+ gc.OLT<<16 | gc.TUINT32,
+ gc.OLT<<16 | gc.TUINT64:
+ a = x86.AJCS
+
+ case gc.OLE<<16 | gc.TINT8,
+ gc.OLE<<16 | gc.TINT16,
+ gc.OLE<<16 | gc.TINT32,
+ gc.OLE<<16 | gc.TINT64:
+ a = x86.AJLE
+
+ case gc.OLE<<16 | gc.TUINT8,
+ gc.OLE<<16 | gc.TUINT16,
+ gc.OLE<<16 | gc.TUINT32,
+ gc.OLE<<16 | gc.TUINT64:
+ a = x86.AJLS
+
+ case gc.OGT<<16 | gc.TINT8,
+ gc.OGT<<16 | gc.TINT16,
+ gc.OGT<<16 | gc.TINT32,
+ gc.OGT<<16 | gc.TINT64:
+ a = x86.AJGT
+
+ case gc.OGT<<16 | gc.TUINT8,
+ gc.OGT<<16 | gc.TUINT16,
+ gc.OGT<<16 | gc.TUINT32,
+ gc.OGT<<16 | gc.TUINT64,
+ gc.OLT<<16 | gc.TFLOAT32,
+ gc.OLT<<16 | gc.TFLOAT64:
+ a = x86.AJHI
+
+ case gc.OGE<<16 | gc.TINT8,
+ gc.OGE<<16 | gc.TINT16,
+ gc.OGE<<16 | gc.TINT32,
+ gc.OGE<<16 | gc.TINT64:
+ a = x86.AJGE
+
+ case gc.OGE<<16 | gc.TUINT8,
+ gc.OGE<<16 | gc.TUINT16,
+ gc.OGE<<16 | gc.TUINT32,
+ gc.OGE<<16 | gc.TUINT64,
+ gc.OLE<<16 | gc.TFLOAT32,
+ gc.OLE<<16 | gc.TFLOAT64:
+ a = x86.AJCC
+
+ case gc.OCMP<<16 | gc.TBOOL,
+ gc.OCMP<<16 | gc.TINT8,
+ gc.OCMP<<16 | gc.TUINT8:
+ a = x86.ACMPB
+
+ case gc.OCMP<<16 | gc.TINT16,
+ gc.OCMP<<16 | gc.TUINT16:
+ a = x86.ACMPW
+
+ case gc.OCMP<<16 | gc.TINT32,
+ gc.OCMP<<16 | gc.TUINT32,
+ gc.OCMP<<16 | gc.TPTR32:
+ a = x86.ACMPL
+
+ case gc.OCMP<<16 | gc.TINT64,
+ gc.OCMP<<16 | gc.TUINT64,
+ gc.OCMP<<16 | gc.TPTR64:
+ a = x86.ACMPQ
+
+ case gc.OCMP<<16 | gc.TFLOAT32:
+ a = x86.AUCOMISS
+
+ case gc.OCMP<<16 | gc.TFLOAT64:
+ a = x86.AUCOMISD
+
+ case gc.OAS<<16 | gc.TBOOL,
+ gc.OAS<<16 | gc.TINT8,
+ gc.OAS<<16 | gc.TUINT8:
+ a = x86.AMOVB
+
+ case gc.OAS<<16 | gc.TINT16,
+ gc.OAS<<16 | gc.TUINT16:
+ a = x86.AMOVW
+
+ case gc.OAS<<16 | gc.TINT32,
+ gc.OAS<<16 | gc.TUINT32,
+ gc.OAS<<16 | gc.TPTR32:
+ a = x86.AMOVL
+
+ case gc.OAS<<16 | gc.TINT64,
+ gc.OAS<<16 | gc.TUINT64,
+ gc.OAS<<16 | gc.TPTR64:
+ a = x86.AMOVQ
+
+ case gc.OAS<<16 | gc.TFLOAT32:
+ a = x86.AMOVSS
+
+ case gc.OAS<<16 | gc.TFLOAT64:
+ a = x86.AMOVSD
+
+ case gc.OADD<<16 | gc.TINT8,
+ gc.OADD<<16 | gc.TUINT8:
+ a = x86.AADDB
+
+ case gc.OADD<<16 | gc.TINT16,
+ gc.OADD<<16 | gc.TUINT16:
+ a = x86.AADDW
+
+ case gc.OADD<<16 | gc.TINT32,
+ gc.OADD<<16 | gc.TUINT32,
+ gc.OADD<<16 | gc.TPTR32:
+ a = x86.AADDL
+
+ case gc.OADD<<16 | gc.TINT64,
+ gc.OADD<<16 | gc.TUINT64,
+ gc.OADD<<16 | gc.TPTR64:
+ a = x86.AADDQ
+
+ case gc.OADD<<16 | gc.TFLOAT32:
+ a = x86.AADDSS
+
+ case gc.OADD<<16 | gc.TFLOAT64:
+ a = x86.AADDSD
+
+ case gc.OSUB<<16 | gc.TINT8,
+ gc.OSUB<<16 | gc.TUINT8:
+ a = x86.ASUBB
+
+ case gc.OSUB<<16 | gc.TINT16,
+ gc.OSUB<<16 | gc.TUINT16:
+ a = x86.ASUBW
+
+ case gc.OSUB<<16 | gc.TINT32,
+ gc.OSUB<<16 | gc.TUINT32,
+ gc.OSUB<<16 | gc.TPTR32:
+ a = x86.ASUBL
+
+ case gc.OSUB<<16 | gc.TINT64,
+ gc.OSUB<<16 | gc.TUINT64,
+ gc.OSUB<<16 | gc.TPTR64:
+ a = x86.ASUBQ
+
+ case gc.OSUB<<16 | gc.TFLOAT32:
+ a = x86.ASUBSS
+
+ case gc.OSUB<<16 | gc.TFLOAT64:
+ a = x86.ASUBSD
+
+ case gc.OINC<<16 | gc.TINT8,
+ gc.OINC<<16 | gc.TUINT8:
+ a = x86.AINCB
+
+ case gc.OINC<<16 | gc.TINT16,
+ gc.OINC<<16 | gc.TUINT16:
+ a = x86.AINCW
+
+ case gc.OINC<<16 | gc.TINT32,
+ gc.OINC<<16 | gc.TUINT32,
+ gc.OINC<<16 | gc.TPTR32:
+ a = x86.AINCL
+
+ case gc.OINC<<16 | gc.TINT64,
+ gc.OINC<<16 | gc.TUINT64,
+ gc.OINC<<16 | gc.TPTR64:
+ a = x86.AINCQ
+
+ case gc.ODEC<<16 | gc.TINT8,
+ gc.ODEC<<16 | gc.TUINT8:
+ a = x86.ADECB
+
+ case gc.ODEC<<16 | gc.TINT16,
+ gc.ODEC<<16 | gc.TUINT16:
+ a = x86.ADECW
+
+ case gc.ODEC<<16 | gc.TINT32,
+ gc.ODEC<<16 | gc.TUINT32,
+ gc.ODEC<<16 | gc.TPTR32:
+ a = x86.ADECL
+
+ case gc.ODEC<<16 | gc.TINT64,
+ gc.ODEC<<16 | gc.TUINT64,
+ gc.ODEC<<16 | gc.TPTR64:
+ a = x86.ADECQ
+
+ case gc.OMINUS<<16 | gc.TINT8,
+ gc.OMINUS<<16 | gc.TUINT8:
+ a = x86.ANEGB
+
+ case gc.OMINUS<<16 | gc.TINT16,
+ gc.OMINUS<<16 | gc.TUINT16:
+ a = x86.ANEGW
+
+ case gc.OMINUS<<16 | gc.TINT32,
+ gc.OMINUS<<16 | gc.TUINT32,
+ gc.OMINUS<<16 | gc.TPTR32:
+ a = x86.ANEGL
+
+ case gc.OMINUS<<16 | gc.TINT64,
+ gc.OMINUS<<16 | gc.TUINT64,
+ gc.OMINUS<<16 | gc.TPTR64:
+ a = x86.ANEGQ
+
+ case gc.OAND<<16 | gc.TINT8,
+ gc.OAND<<16 | gc.TUINT8:
+ a = x86.AANDB
+
+ case gc.OAND<<16 | gc.TINT16,
+ gc.OAND<<16 | gc.TUINT16:
+ a = x86.AANDW
+
+ case gc.OAND<<16 | gc.TINT32,
+ gc.OAND<<16 | gc.TUINT32,
+ gc.OAND<<16 | gc.TPTR32:
+ a = x86.AANDL
+
+ case gc.OAND<<16 | gc.TINT64,
+ gc.OAND<<16 | gc.TUINT64,
+ gc.OAND<<16 | gc.TPTR64:
+ a = x86.AANDQ
+
+ case gc.OOR<<16 | gc.TINT8,
+ gc.OOR<<16 | gc.TUINT8:
+ a = x86.AORB
+
+ case gc.OOR<<16 | gc.TINT16,
+ gc.OOR<<16 | gc.TUINT16:
+ a = x86.AORW
+
+ case gc.OOR<<16 | gc.TINT32,
+ gc.OOR<<16 | gc.TUINT32,
+ gc.OOR<<16 | gc.TPTR32:
+ a = x86.AORL
+
+ case gc.OOR<<16 | gc.TINT64,
+ gc.OOR<<16 | gc.TUINT64,
+ gc.OOR<<16 | gc.TPTR64:
+ a = x86.AORQ
+
+ case gc.OXOR<<16 | gc.TINT8,
+ gc.OXOR<<16 | gc.TUINT8:
+ a = x86.AXORB
+
+ case gc.OXOR<<16 | gc.TINT16,
+ gc.OXOR<<16 | gc.TUINT16:
+ a = x86.AXORW
+
+ case gc.OXOR<<16 | gc.TINT32,
+ gc.OXOR<<16 | gc.TUINT32,
+ gc.OXOR<<16 | gc.TPTR32:
+ a = x86.AXORL
+
+ case gc.OXOR<<16 | gc.TINT64,
+ gc.OXOR<<16 | gc.TUINT64,
+ gc.OXOR<<16 | gc.TPTR64:
+ a = x86.AXORQ
+
+ case gc.OLROT<<16 | gc.TINT8,
+ gc.OLROT<<16 | gc.TUINT8:
+ a = x86.AROLB
+
+ case gc.OLROT<<16 | gc.TINT16,
+ gc.OLROT<<16 | gc.TUINT16:
+ a = x86.AROLW
+
+ case gc.OLROT<<16 | gc.TINT32,
+ gc.OLROT<<16 | gc.TUINT32,
+ gc.OLROT<<16 | gc.TPTR32:
+ a = x86.AROLL
+
+ case gc.OLROT<<16 | gc.TINT64,
+ gc.OLROT<<16 | gc.TUINT64,
+ gc.OLROT<<16 | gc.TPTR64:
+ a = x86.AROLQ
+
+ case gc.OLSH<<16 | gc.TINT8,
+ gc.OLSH<<16 | gc.TUINT8:
+ a = x86.ASHLB
+
+ case gc.OLSH<<16 | gc.TINT16,
+ gc.OLSH<<16 | gc.TUINT16:
+ a = x86.ASHLW
+
+ case gc.OLSH<<16 | gc.TINT32,
+ gc.OLSH<<16 | gc.TUINT32,
+ gc.OLSH<<16 | gc.TPTR32:
+ a = x86.ASHLL
+
+ case gc.OLSH<<16 | gc.TINT64,
+ gc.OLSH<<16 | gc.TUINT64,
+ gc.OLSH<<16 | gc.TPTR64:
+ a = x86.ASHLQ
+
+ case gc.ORSH<<16 | gc.TUINT8:
+ a = x86.ASHRB
+
+ case gc.ORSH<<16 | gc.TUINT16:
+ a = x86.ASHRW
+
+ case gc.ORSH<<16 | gc.TUINT32,
+ gc.ORSH<<16 | gc.TPTR32:
+ a = x86.ASHRL
+
+ case gc.ORSH<<16 | gc.TUINT64,
+ gc.ORSH<<16 | gc.TPTR64:
+ a = x86.ASHRQ
+
+ case gc.ORSH<<16 | gc.TINT8:
+ a = x86.ASARB
+
+ case gc.ORSH<<16 | gc.TINT16:
+ a = x86.ASARW
+
+ case gc.ORSH<<16 | gc.TINT32:
+ a = x86.ASARL
+
+ case gc.ORSH<<16 | gc.TINT64:
+ a = x86.ASARQ
+
+ case gc.ORROTC<<16 | gc.TINT8,
+ gc.ORROTC<<16 | gc.TUINT8:
+ a = x86.ARCRB
+
+ case gc.ORROTC<<16 | gc.TINT16,
+ gc.ORROTC<<16 | gc.TUINT16:
+ a = x86.ARCRW
+
+ case gc.ORROTC<<16 | gc.TINT32,
+ gc.ORROTC<<16 | gc.TUINT32:
+ a = x86.ARCRL
+
+ case gc.ORROTC<<16 | gc.TINT64,
+ gc.ORROTC<<16 | gc.TUINT64:
+ a = x86.ARCRQ
+
+ case gc.OHMUL<<16 | gc.TINT8,
+ gc.OMUL<<16 | gc.TINT8,
+ gc.OMUL<<16 | gc.TUINT8:
+ a = x86.AIMULB
+
+ case gc.OHMUL<<16 | gc.TINT16,
+ gc.OMUL<<16 | gc.TINT16,
+ gc.OMUL<<16 | gc.TUINT16:
+ a = x86.AIMULW
+
+ case gc.OHMUL<<16 | gc.TINT32,
+ gc.OMUL<<16 | gc.TINT32,
+ gc.OMUL<<16 | gc.TUINT32,
+ gc.OMUL<<16 | gc.TPTR32:
+ a = x86.AIMULL
+
+ case gc.OHMUL<<16 | gc.TINT64,
+ gc.OMUL<<16 | gc.TINT64,
+ gc.OMUL<<16 | gc.TUINT64,
+ gc.OMUL<<16 | gc.TPTR64:
+ a = x86.AIMULQ
+
+ case gc.OHMUL<<16 | gc.TUINT8:
+ a = x86.AMULB
+
+ case gc.OHMUL<<16 | gc.TUINT16:
+ a = x86.AMULW
+
+ case gc.OHMUL<<16 | gc.TUINT32,
+ gc.OHMUL<<16 | gc.TPTR32:
+ a = x86.AMULL
+
+ case gc.OHMUL<<16 | gc.TUINT64,
+ gc.OHMUL<<16 | gc.TPTR64:
+ a = x86.AMULQ
+
+ case gc.OMUL<<16 | gc.TFLOAT32:
+ a = x86.AMULSS
+
+ case gc.OMUL<<16 | gc.TFLOAT64:
+ a = x86.AMULSD
+
+ case gc.ODIV<<16 | gc.TINT8,
+ gc.OMOD<<16 | gc.TINT8:
+ a = x86.AIDIVB
+
+ case gc.ODIV<<16 | gc.TUINT8,
+ gc.OMOD<<16 | gc.TUINT8:
+ a = x86.ADIVB
+
+ case gc.ODIV<<16 | gc.TINT16,
+ gc.OMOD<<16 | gc.TINT16:
+ a = x86.AIDIVW
+
+ case gc.ODIV<<16 | gc.TUINT16,
+ gc.OMOD<<16 | gc.TUINT16:
+ a = x86.ADIVW
+
+ case gc.ODIV<<16 | gc.TINT32,
+ gc.OMOD<<16 | gc.TINT32:
+ a = x86.AIDIVL
+
+ case gc.ODIV<<16 | gc.TUINT32,
+ gc.ODIV<<16 | gc.TPTR32,
+ gc.OMOD<<16 | gc.TUINT32,
+ gc.OMOD<<16 | gc.TPTR32:
+ a = x86.ADIVL
+
+ case gc.ODIV<<16 | gc.TINT64,
+ gc.OMOD<<16 | gc.TINT64:
+ a = x86.AIDIVQ
+
+ case gc.ODIV<<16 | gc.TUINT64,
+ gc.ODIV<<16 | gc.TPTR64,
+ gc.OMOD<<16 | gc.TUINT64,
+ gc.OMOD<<16 | gc.TPTR64:
+ a = x86.ADIVQ
+
+ case gc.OEXTEND<<16 | gc.TINT16:
+ a = x86.ACWD
+
+ case gc.OEXTEND<<16 | gc.TINT32:
+ a = x86.ACDQ
+
+ case gc.OEXTEND<<16 | gc.TINT64:
+ a = x86.ACQO
+
+ case gc.ODIV<<16 | gc.TFLOAT32:
+ a = x86.ADIVSS
+
+ case gc.ODIV<<16 | gc.TFLOAT64:
+ a = x86.ADIVSD
+ }
+
+ return a
+}
+
+const (
+ ODynam = 1 << 0
+ OAddable = 1 << 1
+)
+
+var clean [20]gc.Node
+
+var cleani int = 0
+
+func xgen(n *gc.Node, a *gc.Node, o int) int {
+ regalloc(a, gc.Types[gc.Tptr], nil)
+
+ if o&ODynam != 0 {
+ if n.Addable != 0 {
+ if n.Op != gc.OINDREG {
+ if n.Op != gc.OREGISTER {
+ return 1
+ }
+ }
+ }
+ }
+
+ agen(n, a)
+ return 0
+}
+
+func sudoclean() {
+ if clean[cleani-1].Op != gc.OEMPTY {
+ regfree(&clean[cleani-1])
+ }
+ if clean[cleani-2].Op != gc.OEMPTY {
+ regfree(&clean[cleani-2])
+ }
+ cleani -= 2
+}
+
+/*
+ * generate code to compute address of n,
+ * a reference to a (perhaps nested) field inside
+ * an array or struct.
+ * return 0 on failure, 1 on success.
+ * on success, leaves usable address in a.
+ *
+ * caller is responsible for calling sudoclean
+ * after successful sudoaddable,
+ * to release the register used for a.
+ */
+func sudoaddable(as int, n *gc.Node, a *obj.Addr) int {
+ var o int
+ var i int
+ var oary [10]int64
+ var v int64
+ var w int64
+ var n1 gc.Node
+ var n2 gc.Node
+ var n3 gc.Node
+ var n4 gc.Node
+ var nn *gc.Node
+ var l *gc.Node
+ var r *gc.Node
+ var reg *gc.Node
+ var reg1 *gc.Node
+ var p1 *obj.Prog
+ var t *gc.Type
+
+ if n.Type == nil {
+ return 0
+ }
+
+ *a = obj.Addr{}
+
+ switch n.Op {
+ case gc.OLITERAL:
+ if !(gc.Isconst(n, gc.CTINT) != 0) {
+ break
+ }
+ v = gc.Mpgetfix(n.Val.U.Xval)
+ if v >= 32000 || v <= -32000 {
+ break
+ }
+ goto lit
+
+ case gc.ODOT,
+ gc.ODOTPTR:
+ cleani += 2
+ reg = &clean[cleani-1]
+ reg1 = &clean[cleani-2]
+ reg.Op = gc.OEMPTY
+ reg1.Op = gc.OEMPTY
+ goto odot
+
+ case gc.OINDEX:
+ return 0
+
+ // disabled: OINDEX case is now covered by agenr
+ // for a more suitable register allocation pattern.
+ if n.Left.Type.Etype == gc.TSTRING {
+ return 0
+ }
+ goto oindex
+ }
+
+ return 0
+
+lit:
+ switch as {
+ default:
+ return 0
+
+ case x86.AADDB,
+ x86.AADDW,
+ x86.AADDL,
+ x86.AADDQ,
+ x86.ASUBB,
+ x86.ASUBW,
+ x86.ASUBL,
+ x86.ASUBQ,
+ x86.AANDB,
+ x86.AANDW,
+ x86.AANDL,
+ x86.AANDQ,
+ x86.AORB,
+ x86.AORW,
+ x86.AORL,
+ x86.AORQ,
+ x86.AXORB,
+ x86.AXORW,
+ x86.AXORL,
+ x86.AXORQ,
+ x86.AINCB,
+ x86.AINCW,
+ x86.AINCL,
+ x86.AINCQ,
+ x86.ADECB,
+ x86.ADECW,
+ x86.ADECL,
+ x86.ADECQ,
+ x86.AMOVB,
+ x86.AMOVW,
+ x86.AMOVL,
+ x86.AMOVQ:
+ break
+ }
+
+ cleani += 2
+ reg = &clean[cleani-1]
+ reg1 = &clean[cleani-2]
+ reg.Op = gc.OEMPTY
+ reg1.Op = gc.OEMPTY
+ gc.Naddr(n, a, 1)
+ goto yes
+
+odot:
+ o = gc.Dotoffset(n, oary[:], &nn)
+ if nn == nil {
+ goto no
+ }
+
+ if nn.Addable != 0 && o == 1 && oary[0] >= 0 {
+ // directly addressable set of DOTs
+ n1 = *nn
+
+ n1.Type = n.Type
+ n1.Xoffset += oary[0]
+ gc.Naddr(&n1, a, 1)
+ goto yes
+ }
+
+ regalloc(reg, gc.Types[gc.Tptr], nil)
+ n1 = *reg
+ n1.Op = gc.OINDREG
+ if oary[0] >= 0 {
+ agen(nn, reg)
+ n1.Xoffset = oary[0]
+ } else {
+ cgen(nn, reg)
+ gc.Cgen_checknil(reg)
+ n1.Xoffset = -(oary[0] + 1)
+ }
+
+ for i = 1; i < o; i++ {
+ if oary[i] >= 0 {
+ gc.Fatal("can't happen")
+ }
+ gins(movptr, &n1, reg)
+ gc.Cgen_checknil(reg)
+ n1.Xoffset = -(oary[i] + 1)
+ }
+
+ a.Type = obj.TYPE_NONE
+ a.Index = obj.TYPE_NONE
+ fixlargeoffset(&n1)
+ gc.Naddr(&n1, a, 1)
+ goto yes
+
+oindex:
+ l = n.Left
+ r = n.Right
+ if l.Ullman >= gc.UINF && r.Ullman >= gc.UINF {
+ return 0
+ }
+
+ // set o to type of array
+ o = 0
+
+ if gc.Isptr[l.Type.Etype] != 0 {
+ gc.Fatal("ptr ary")
+ }
+ if l.Type.Etype != gc.TARRAY {
+ gc.Fatal("not ary")
+ }
+ if l.Type.Bound < 0 {
+ o |= ODynam
+ }
+
+ w = n.Type.Width
+ if gc.Isconst(r, gc.CTINT) != 0 {
+ goto oindex_const
+ }
+
+ switch w {
+ default:
+ return 0
+
+ case 1,
+ 2,
+ 4,
+ 8:
+ break
+ }
+
+ cleani += 2
+ reg = &clean[cleani-1]
+ reg1 = &clean[cleani-2]
+ reg.Op = gc.OEMPTY
+ reg1.Op = gc.OEMPTY
+
+ // load the array (reg)
+ if l.Ullman > r.Ullman {
+ if xgen(l, reg, o) != 0 {
+ o |= OAddable
+ }
+ }
+
+ // load the index (reg1)
+ t = gc.Types[gc.TUINT64]
+
+ if gc.Issigned[r.Type.Etype] != 0 {
+ t = gc.Types[gc.TINT64]
+ }
+ regalloc(reg1, t, nil)
+ regalloc(&n3, r.Type, reg1)
+ cgen(r, &n3)
+ gmove(&n3, reg1)
+ regfree(&n3)
+
+ // load the array (reg)
+ if l.Ullman <= r.Ullman {
+ if xgen(l, reg, o) != 0 {
+ o |= OAddable
+ }
+ }
+
+ // check bounds
+ if !(gc.Debug['B'] != 0) && !(n.Bounded != 0) {
+ // check bounds
+ n4.Op = gc.OXXX
+
+ t = gc.Types[gc.Simtype[gc.TUINT]]
+ if o&ODynam != 0 {
+ if o&OAddable != 0 {
+ n2 = *l
+ n2.Xoffset += int64(gc.Array_nel)
+ n2.Type = gc.Types[gc.Simtype[gc.TUINT]]
+ } else {
+ n2 = *reg
+ n2.Xoffset = int64(gc.Array_nel)
+ n2.Op = gc.OINDREG
+ n2.Type = gc.Types[gc.Simtype[gc.TUINT]]
+ }
+ } else {
+ if gc.Is64(r.Type) != 0 {
+ t = gc.Types[gc.TUINT64]
+ }
+ gc.Nodconst(&n2, gc.Types[gc.TUINT64], l.Type.Bound)
+ }
+
+ gins(optoas(gc.OCMP, t), reg1, &n2)
+ p1 = gc.Gbranch(optoas(gc.OLT, t), nil, +1)
+ if n4.Op != gc.OXXX {
+ regfree(&n4)
+ }
+ ginscall(gc.Panicindex, -1)
+ gc.Patch(p1, gc.Pc)
+ }
+
+ if o&ODynam != 0 {
+ if o&OAddable != 0 {
+ n2 = *l
+ n2.Xoffset += int64(gc.Array_array)
+ n2.Type = gc.Types[gc.Tptr]
+ gmove(&n2, reg)
+ } else {
+ n2 = *reg
+ n2.Op = gc.OINDREG
+ n2.Xoffset = int64(gc.Array_array)
+ n2.Type = gc.Types[gc.Tptr]
+ gmove(&n2, reg)
+ }
+ }
+
+ if o&OAddable != 0 {
+ gc.Naddr(reg1, a, 1)
+ a.Offset = 0
+ a.Scale = int8(w)
+ a.Index = a.Reg
+ a.Type = obj.TYPE_MEM
+ a.Reg = reg.Val.U.Reg
+ } else {
+ gc.Naddr(reg1, a, 1)
+ a.Offset = 0
+ a.Scale = int8(w)
+ a.Index = a.Reg
+ a.Type = obj.TYPE_MEM
+ a.Reg = reg.Val.U.Reg
+ }
+
+ goto yes
+
+ // index is constant
+ // can check statically and
+ // can multiply by width statically
+
+oindex_const:
+ v = gc.Mpgetfix(r.Val.U.Xval)
+
+ if sudoaddable(as, l, a) != 0 {
+ goto oindex_const_sudo
+ }
+
+ cleani += 2
+ reg = &clean[cleani-1]
+ reg1 = &clean[cleani-2]
+ reg.Op = gc.OEMPTY
+ reg1.Op = gc.OEMPTY
+
+ if o&ODynam != 0 {
+ regalloc(reg, gc.Types[gc.Tptr], nil)
+ agen(l, reg)
+
+ if !(gc.Debug['B'] != 0) && !(n.Bounded != 0) {
+ n1 = *reg
+ n1.Op = gc.OINDREG
+ n1.Type = gc.Types[gc.Tptr]
+ n1.Xoffset = int64(gc.Array_nel)
+ gc.Nodconst(&n2, gc.Types[gc.TUINT64], v)
+ gins(optoas(gc.OCMP, gc.Types[gc.Simtype[gc.TUINT]]), &n1, &n2)
+ p1 = gc.Gbranch(optoas(gc.OGT, gc.Types[gc.Simtype[gc.TUINT]]), nil, +1)
+ ginscall(gc.Panicindex, -1)
+ gc.Patch(p1, gc.Pc)
+ }
+
+ n1 = *reg
+ n1.Op = gc.OINDREG
+ n1.Type = gc.Types[gc.Tptr]
+ n1.Xoffset = int64(gc.Array_array)
+ gmove(&n1, reg)
+
+ n2 = *reg
+ n2.Op = gc.OINDREG
+ n2.Xoffset = v * w
+ fixlargeoffset(&n2)
+ a.Type = obj.TYPE_NONE
+ a.Index = obj.TYPE_NONE
+ gc.Naddr(&n2, a, 1)
+ goto yes
+ }
+
+ igen(l, &n1, nil)
+ if n1.Op == gc.OINDREG {
+ *reg = n1
+ reg.Op = gc.OREGISTER
+ }
+
+ n1.Xoffset += v * w
+ fixlargeoffset(&n1)
+ a.Type = obj.TYPE_NONE
+ a.Index = obj.TYPE_NONE
+ gc.Naddr(&n1, a, 1)
+ goto yes
+
+oindex_const_sudo:
+ if o&ODynam == 0 {
+ // array indexed by a constant
+ a.Offset += v * w
+
+ goto yes
+ }
+
+ // slice indexed by a constant
+ if !(gc.Debug['B'] != 0) && !(n.Bounded != 0) {
+ a.Offset += int64(gc.Array_nel)
+ gc.Nodconst(&n2, gc.Types[gc.TUINT64], v)
+ p1 = gins(optoas(gc.OCMP, gc.Types[gc.Simtype[gc.TUINT]]), nil, &n2)
+ p1.From = *a
+ p1 = gc.Gbranch(optoas(gc.OGT, gc.Types[gc.Simtype[gc.TUINT]]), nil, +1)
+ ginscall(gc.Panicindex, -1)
+ gc.Patch(p1, gc.Pc)
+ a.Offset -= int64(gc.Array_nel)
+ }
+
+ a.Offset += int64(gc.Array_array)
+ reg = &clean[cleani-1]
+ if reg.Op == gc.OEMPTY {
+ regalloc(reg, gc.Types[gc.Tptr], nil)
+ }
+
+ p1 = gins(movptr, nil, reg)
+ p1.From = *a
+
+ n2 = *reg
+ n2.Op = gc.OINDREG
+ n2.Xoffset = v * w
+ fixlargeoffset(&n2)
+ a.Type = obj.TYPE_NONE
+ a.Index = obj.TYPE_NONE
+ gc.Naddr(&n2, a, 1)
+ goto yes
+
+yes:
+ return 1
+
+no:
+ sudoclean()
+ return 0
+}
--- /dev/null
+// Derived from Inferno utils/6c/peep.c
+// http://code.google.com/p/inferno-os/source/browse/utils/6c/peep.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 main
+
+import (
+ "cmd/internal/obj"
+ "cmd/internal/obj/x86"
+ "fmt"
+)
+import "cmd/internal/gc"
+
+var gactive uint32
+
+const (
+ exregoffset = x86.REG_R15
+)
+
+// do we need the carry bit
+func needc(p *obj.Prog) int {
+ var info gc.ProgInfo
+
+ for p != nil {
+ proginfo(&info, p)
+ if info.Flags&gc.UseCarry != 0 {
+ return 1
+ }
+ if info.Flags&(gc.SetCarry|gc.KillCarry) != 0 {
+ return 0
+ }
+ p = p.Link
+ }
+
+ return 0
+}
+
+func rnops(r *gc.Flow) *gc.Flow {
+ var p *obj.Prog
+ var r1 *gc.Flow
+
+ if r != nil {
+ for {
+ p = r.Prog
+ if p.As != obj.ANOP || p.From.Type != obj.TYPE_NONE || p.To.Type != obj.TYPE_NONE {
+ break
+ }
+ r1 = gc.Uniqs(r)
+ if r1 == nil {
+ break
+ }
+ r = r1
+ }
+ }
+
+ return r
+}
+
+func peep(firstp *obj.Prog) {
+ var r *gc.Flow
+ var r1 *gc.Flow
+ var g *gc.Graph
+ var p *obj.Prog
+ var p1 *obj.Prog
+ var t int
+
+ g = gc.Flowstart(firstp, nil)
+ if g == nil {
+ return
+ }
+ gactive = 0
+
+ // byte, word arithmetic elimination.
+ elimshortmov(g)
+
+ // constant propagation
+ // find MOV $con,R followed by
+ // another MOV $con,R without
+ // setting R in the interim
+ for r = g.Start; r != nil; r = r.Link {
+ p = r.Prog
+ switch p.As {
+ case x86.ALEAL,
+ x86.ALEAQ:
+ if regtyp(&p.To) != 0 {
+ if p.From.Sym != nil {
+ if p.From.Index == x86.REG_NONE {
+ conprop(r)
+ }
+ }
+ }
+
+ case x86.AMOVB,
+ x86.AMOVW,
+ x86.AMOVL,
+ x86.AMOVQ,
+ x86.AMOVSS,
+ x86.AMOVSD:
+ if regtyp(&p.To) != 0 {
+ if p.From.Type == obj.TYPE_CONST || p.From.Type == obj.TYPE_FCONST {
+ conprop(r)
+ }
+ }
+ }
+ }
+
+loop1:
+ if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 {
+ gc.Dumpit("loop1", g.Start, 0)
+ }
+
+ t = 0
+ for r = g.Start; r != nil; r = r.Link {
+ p = r.Prog
+ switch p.As {
+ case x86.AMOVL,
+ x86.AMOVQ,
+ x86.AMOVSS,
+ x86.AMOVSD:
+ if regtyp(&p.To) != 0 {
+ if regtyp(&p.From) != 0 {
+ if copyprop(g, r) != 0 {
+ excise(r)
+ t++
+ } else if subprop(r) != 0 && copyprop(g, r) != 0 {
+ excise(r)
+ t++
+ }
+ }
+ }
+
+ case x86.AMOVBLZX,
+ x86.AMOVWLZX,
+ x86.AMOVBLSX,
+ x86.AMOVWLSX:
+ if regtyp(&p.To) != 0 {
+ r1 = rnops(gc.Uniqs(r))
+ if r1 != nil {
+ p1 = r1.Prog
+ if p.As == p1.As && p.To.Type == p1.From.Type && p.To.Reg == p1.From.Reg {
+ p1.As = x86.AMOVL
+ t++
+ }
+ }
+ }
+
+ case x86.AMOVBQSX,
+ x86.AMOVBQZX,
+ x86.AMOVWQSX,
+ x86.AMOVWQZX,
+ x86.AMOVLQSX,
+ x86.AMOVLQZX,
+ x86.AMOVQL:
+ if regtyp(&p.To) != 0 {
+ r1 = rnops(gc.Uniqs(r))
+ if r1 != nil {
+ p1 = r1.Prog
+ if p.As == p1.As && p.To.Type == p1.From.Type && p.To.Reg == p1.From.Reg {
+ p1.As = x86.AMOVQ
+ t++
+ }
+ }
+ }
+
+ case x86.AADDL,
+ x86.AADDQ,
+ x86.AADDW:
+ if p.From.Type != obj.TYPE_CONST || needc(p.Link) != 0 {
+ break
+ }
+ if p.From.Offset == -1 {
+ if p.As == x86.AADDQ {
+ p.As = x86.ADECQ
+ } else if p.As == x86.AADDL {
+ p.As = x86.ADECL
+ } else {
+ p.As = x86.ADECW
+ }
+ p.From = obj.Zprog.From
+ break
+ }
+
+ if p.From.Offset == 1 {
+ if p.As == x86.AADDQ {
+ p.As = x86.AINCQ
+ } else if p.As == x86.AADDL {
+ p.As = x86.AINCL
+ } else {
+ p.As = x86.AINCW
+ }
+ p.From = obj.Zprog.From
+ break
+ }
+
+ case x86.ASUBL,
+ x86.ASUBQ,
+ x86.ASUBW:
+ if p.From.Type != obj.TYPE_CONST || needc(p.Link) != 0 {
+ break
+ }
+ if p.From.Offset == -1 {
+ if p.As == x86.ASUBQ {
+ p.As = x86.AINCQ
+ } else if p.As == x86.ASUBL {
+ p.As = x86.AINCL
+ } else {
+ p.As = x86.AINCW
+ }
+ p.From = obj.Zprog.From
+ break
+ }
+
+ if p.From.Offset == 1 {
+ if p.As == x86.ASUBQ {
+ p.As = x86.ADECQ
+ } else if p.As == x86.ASUBL {
+ p.As = x86.ADECL
+ } else {
+ p.As = x86.ADECW
+ }
+ p.From = obj.Zprog.From
+ break
+ }
+ }
+ }
+
+ if t != 0 {
+ goto loop1
+ }
+
+ // MOVLQZX removal.
+ // The MOVLQZX exists to avoid being confused for a
+ // MOVL that is just copying 32-bit data around during
+ // copyprop. Now that copyprop is done, remov MOVLQZX R1, R2
+ // if it is dominated by an earlier ADDL/MOVL/etc into R1 that
+ // will have already cleared the high bits.
+ //
+ // MOVSD removal.
+ // We never use packed registers, so a MOVSD between registers
+ // can be replaced by MOVAPD, which moves the pair of float64s
+ // instead of just the lower one. We only use the lower one, but
+ // the processor can do better if we do moves using both.
+ for r = g.Start; r != nil; r = r.Link {
+ p = r.Prog
+ if p.As == x86.AMOVLQZX {
+ if regtyp(&p.From) != 0 {
+ if p.From.Type == p.To.Type && p.From.Reg == p.To.Reg {
+ if prevl(r, int(p.From.Reg)) != 0 {
+ excise(r)
+ }
+ }
+ }
+ }
+
+ if p.As == x86.AMOVSD {
+ if regtyp(&p.From) != 0 {
+ if regtyp(&p.To) != 0 {
+ p.As = x86.AMOVAPD
+ }
+ }
+ }
+ }
+
+ // load pipelining
+ // push any load from memory as early as possible
+ // to give it time to complete before use.
+ for r = g.Start; r != nil; r = r.Link {
+ p = r.Prog
+ switch p.As {
+ case x86.AMOVB,
+ x86.AMOVW,
+ x86.AMOVL,
+ x86.AMOVQ,
+ x86.AMOVLQZX:
+ if regtyp(&p.To) != 0 && !(regconsttyp(&p.From) != 0) {
+ pushback(r)
+ }
+ }
+ }
+
+ gc.Flowend(g)
+}
+
+func pushback(r0 *gc.Flow) {
+ var r *gc.Flow
+ var b *gc.Flow
+ var p0 *obj.Prog
+ var p *obj.Prog
+ var t obj.Prog
+
+ b = nil
+ p0 = r0.Prog
+ for r = gc.Uniqp(r0); r != nil && gc.Uniqs(r) != nil; r = gc.Uniqp(r) {
+ p = r.Prog
+ if p.As != obj.ANOP {
+ if !(regconsttyp(&p.From) != 0) || !(regtyp(&p.To) != 0) {
+ break
+ }
+ if copyu(p, &p0.To, nil) != 0 || copyu(p0, &p.To, nil) != 0 {
+ break
+ }
+ }
+
+ if p.As == obj.ACALL {
+ break
+ }
+ b = r
+ }
+
+ if b == nil {
+ if gc.Debug['v'] != 0 {
+ fmt.Printf("no pushback: %v\n", r0.Prog)
+ if r != nil {
+ fmt.Printf("\t%v [%d]\n", r.Prog, gc.Uniqs(r) != nil)
+ }
+ }
+
+ return
+ }
+
+ if gc.Debug['v'] != 0 {
+ fmt.Printf("pushback\n")
+ for r = b; ; r = r.Link {
+ fmt.Printf("\t%v\n", r.Prog)
+ if r == r0 {
+ break
+ }
+ }
+ }
+
+ t = *r0.Prog
+ for r = gc.Uniqp(r0); ; r = gc.Uniqp(r) {
+ p0 = r.Link.Prog
+ p = r.Prog
+ p0.As = p.As
+ p0.Lineno = p.Lineno
+ p0.From = p.From
+ p0.To = p.To
+
+ if r == b {
+ break
+ }
+ }
+
+ p0 = r.Prog
+ p0.As = t.As
+ p0.Lineno = t.Lineno
+ p0.From = t.From
+ p0.To = t.To
+
+ if gc.Debug['v'] != 0 {
+ fmt.Printf("\tafter\n")
+ for r = b; ; r = r.Link {
+ fmt.Printf("\t%v\n", r.Prog)
+ if r == r0 {
+ break
+ }
+ }
+ }
+}
+
+func excise(r *gc.Flow) {
+ var p *obj.Prog
+
+ p = r.Prog
+ if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 {
+ fmt.Printf("%v ===delete===\n", p)
+ }
+
+ obj.Nopout(p)
+
+ gc.Ostats.Ndelmov++
+}
+
+func regtyp(a *obj.Addr) int {
+ return bool2int(a.Type == obj.TYPE_REG && (x86.REG_AX <= a.Reg && a.Reg <= x86.REG_R15 || x86.REG_X0 <= a.Reg && a.Reg <= x86.REG_X15))
+}
+
+// movb elimination.
+// movb is simulated by the linker
+// when a register other than ax, bx, cx, dx
+// is used, so rewrite to other instructions
+// when possible. a movb into a register
+// can smash the entire 32-bit register without
+// causing any trouble.
+//
+// TODO: Using the Q forms here instead of the L forms
+// seems unnecessary, and it makes the instructions longer.
+func elimshortmov(g *gc.Graph) {
+ var p *obj.Prog
+ var r *gc.Flow
+
+ for r = g.Start; r != nil; r = r.Link {
+ p = r.Prog
+ if regtyp(&p.To) != 0 {
+ switch p.As {
+ case x86.AINCB,
+ x86.AINCW:
+ p.As = x86.AINCQ
+
+ case x86.ADECB,
+ x86.ADECW:
+ p.As = x86.ADECQ
+
+ case x86.ANEGB,
+ x86.ANEGW:
+ p.As = x86.ANEGQ
+
+ case x86.ANOTB,
+ x86.ANOTW:
+ p.As = x86.ANOTQ
+ }
+
+ if regtyp(&p.From) != 0 || p.From.Type == obj.TYPE_CONST {
+ // move or artihmetic into partial register.
+ // from another register or constant can be movl.
+ // we don't switch to 64-bit arithmetic if it can
+ // change how the carry bit is set (and the carry bit is needed).
+ switch p.As {
+ case x86.AMOVB,
+ x86.AMOVW:
+ p.As = x86.AMOVQ
+
+ case x86.AADDB,
+ x86.AADDW:
+ if !(needc(p.Link) != 0) {
+ p.As = x86.AADDQ
+ }
+
+ case x86.ASUBB,
+ x86.ASUBW:
+ if !(needc(p.Link) != 0) {
+ p.As = x86.ASUBQ
+ }
+
+ case x86.AMULB,
+ x86.AMULW:
+ p.As = x86.AMULQ
+
+ case x86.AIMULB,
+ x86.AIMULW:
+ p.As = x86.AIMULQ
+
+ case x86.AANDB,
+ x86.AANDW:
+ p.As = x86.AANDQ
+
+ case x86.AORB,
+ x86.AORW:
+ p.As = x86.AORQ
+
+ case x86.AXORB,
+ x86.AXORW:
+ p.As = x86.AXORQ
+
+ case x86.ASHLB,
+ x86.ASHLW:
+ p.As = x86.ASHLQ
+ }
+ } else if p.From.Type != obj.TYPE_REG {
+ // explicit zero extension, but don't
+ // do that if source is a byte register
+ // (only AH can occur and it's forbidden).
+ switch p.As {
+ case x86.AMOVB:
+ p.As = x86.AMOVBQZX
+
+ case x86.AMOVW:
+ p.As = x86.AMOVWQZX
+ }
+ }
+ }
+ }
+}
+
+// is 'a' a register or constant?
+func regconsttyp(a *obj.Addr) int {
+ if regtyp(a) != 0 {
+ return 1
+ }
+ switch a.Type {
+ case obj.TYPE_CONST,
+ obj.TYPE_FCONST,
+ obj.TYPE_SCONST,
+ obj.TYPE_ADDR: // TODO(rsc): Not all TYPE_ADDRs are constants.
+ return 1
+ }
+
+ return 0
+}
+
+// is reg guaranteed to be truncated by a previous L instruction?
+func prevl(r0 *gc.Flow, reg int) int {
+ var p *obj.Prog
+ var r *gc.Flow
+ var info gc.ProgInfo
+
+ for r = gc.Uniqp(r0); r != nil; r = gc.Uniqp(r) {
+ p = r.Prog
+ if p.To.Type == obj.TYPE_REG && int(p.To.Reg) == reg {
+ proginfo(&info, p)
+ if info.Flags&gc.RightWrite != 0 {
+ if info.Flags&gc.SizeL != 0 {
+ return 1
+ }
+ return 0
+ }
+ }
+ }
+
+ return 0
+}
+
+/*
+ * the idea is to substitute
+ * one register for another
+ * from one MOV to another
+ * MOV a, R0
+ * ADD b, R0 / no use of R1
+ * MOV R0, R1
+ * would be converted to
+ * MOV a, R1
+ * ADD b, R1
+ * MOV R1, R0
+ * hopefully, then the former or latter MOV
+ * will be eliminated by copy propagation.
+ */
+func subprop(r0 *gc.Flow) int {
+ var p *obj.Prog
+ var info gc.ProgInfo
+ var v1 *obj.Addr
+ var v2 *obj.Addr
+ var r *gc.Flow
+ var t int
+
+ if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 {
+ fmt.Printf("subprop %v\n", r0.Prog)
+ }
+ p = r0.Prog
+ v1 = &p.From
+ if !(regtyp(v1) != 0) {
+ if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 {
+ fmt.Printf("\tnot regtype %v; return 0\n", gc.Ctxt.Dconv(v1))
+ }
+ return 0
+ }
+
+ v2 = &p.To
+ if !(regtyp(v2) != 0) {
+ if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 {
+ fmt.Printf("\tnot regtype %v; return 0\n", gc.Ctxt.Dconv(v2))
+ }
+ return 0
+ }
+
+ for r = gc.Uniqp(r0); r != nil; r = gc.Uniqp(r) {
+ if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 {
+ fmt.Printf("\t? %v\n", r.Prog)
+ }
+ if gc.Uniqs(r) == nil {
+ if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 {
+ fmt.Printf("\tno unique successor\n")
+ }
+ break
+ }
+
+ p = r.Prog
+ if p.As == obj.AVARDEF || p.As == obj.AVARKILL {
+ continue
+ }
+ proginfo(&info, p)
+ if info.Flags&gc.Call != 0 {
+ if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 {
+ fmt.Printf("\tfound %v; return 0\n", p)
+ }
+ return 0
+ }
+
+ if info.Reguse|info.Regset != 0 {
+ if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 {
+ fmt.Printf("\tfound %v; return 0\n", p)
+ }
+ return 0
+ }
+
+ if (info.Flags&gc.Move != 0) && (info.Flags&(gc.SizeL|gc.SizeQ|gc.SizeF|gc.SizeD) != 0) && p.To.Type == v1.Type && p.To.Reg == v1.Reg {
+ goto gotit
+ }
+
+ if copyau(&p.From, v2) != 0 || copyau(&p.To, v2) != 0 {
+ if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 {
+ fmt.Printf("\tcopyau %v failed\n", gc.Ctxt.Dconv(v2))
+ }
+ break
+ }
+
+ if copysub(&p.From, v1, v2, 0) != 0 || copysub(&p.To, v1, v2, 0) != 0 {
+ if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 {
+ fmt.Printf("\tcopysub failed\n")
+ }
+ break
+ }
+ }
+
+ if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 {
+ fmt.Printf("\tran off end; return 0\n")
+ }
+ return 0
+
+gotit:
+ copysub(&p.To, v1, v2, 1)
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("gotit: %v->%v\n%v", gc.Ctxt.Dconv(v1), gc.Ctxt.Dconv(v2), r.Prog)
+ if p.From.Type == v2.Type && p.From.Reg == v2.Reg {
+ fmt.Printf(" excise")
+ }
+ fmt.Printf("\n")
+ }
+
+ for r = gc.Uniqs(r); r != r0; r = gc.Uniqs(r) {
+ p = r.Prog
+ copysub(&p.From, v1, v2, 1)
+ copysub(&p.To, v1, v2, 1)
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("%v\n", r.Prog)
+ }
+ }
+
+ t = int(v1.Reg)
+ v1.Reg = v2.Reg
+ v2.Reg = int16(t)
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("%v last\n", r.Prog)
+ }
+ return 1
+}
+
+/*
+ * The idea is to remove redundant copies.
+ * v1->v2 F=0
+ * (use v2 s/v2/v1/)*
+ * set v1 F=1
+ * use v2 return fail
+ * -----------------
+ * v1->v2 F=0
+ * (use v2 s/v2/v1/)*
+ * set v1 F=1
+ * set v2 return success
+ */
+func copyprop(g *gc.Graph, r0 *gc.Flow) int {
+ var p *obj.Prog
+ var v1 *obj.Addr
+ var v2 *obj.Addr
+
+ if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 {
+ fmt.Printf("copyprop %v\n", r0.Prog)
+ }
+ p = r0.Prog
+ v1 = &p.From
+ v2 = &p.To
+ if copyas(v1, v2) != 0 {
+ return 1
+ }
+ gactive++
+ return copy1(v1, v2, r0.S1, 0)
+}
+
+func copy1(v1 *obj.Addr, v2 *obj.Addr, r *gc.Flow, f int) int {
+ var t int
+ var p *obj.Prog
+
+ if uint32(r.Active) == gactive {
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("act set; return 1\n")
+ }
+ return 1
+ }
+
+ r.Active = int32(gactive)
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("copy %v->%v f=%d\n", gc.Ctxt.Dconv(v1), gc.Ctxt.Dconv(v2), f)
+ }
+ for ; r != nil; r = r.S1 {
+ p = r.Prog
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("%v", p)
+ }
+ if !(f != 0) && gc.Uniqp(r) == nil {
+ f = 1
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("; merge; f=%d", f)
+ }
+ }
+
+ t = copyu(p, v2, nil)
+ switch t {
+ case 2: /* rar, can't split */
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("; %v rar; return 0\n", gc.Ctxt.Dconv(v2))
+ }
+ return 0
+
+ case 3: /* set */
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("; %v set; return 1\n", gc.Ctxt.Dconv(v2))
+ }
+ return 1
+
+ case 1, /* used, substitute */
+ 4: /* use and set */
+ if f != 0 {
+ if !(gc.Debug['P'] != 0) {
+ return 0
+ }
+ if t == 4 {
+ fmt.Printf("; %v used+set and f=%d; return 0\n", gc.Ctxt.Dconv(v2), f)
+ } else {
+ fmt.Printf("; %v used and f=%d; return 0\n", gc.Ctxt.Dconv(v2), f)
+ }
+ return 0
+ }
+
+ if copyu(p, v2, v1) != 0 {
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("; sub fail; return 0\n")
+ }
+ return 0
+ }
+
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("; sub %v/%v", gc.Ctxt.Dconv(v2), gc.Ctxt.Dconv(v1))
+ }
+ if t == 4 {
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("; %v used+set; return 1\n", gc.Ctxt.Dconv(v2))
+ }
+ return 1
+ }
+ }
+
+ if !(f != 0) {
+ t = copyu(p, v1, nil)
+ if !(f != 0) && (t == 2 || t == 3 || t == 4) {
+ f = 1
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("; %v set and !f; f=%d", gc.Ctxt.Dconv(v1), f)
+ }
+ }
+ }
+
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("\n")
+ }
+ if r.S2 != nil {
+ if !(copy1(v1, v2, r.S2, f) != 0) {
+ return 0
+ }
+ }
+ }
+
+ return 1
+}
+
+/*
+ * return
+ * 1 if v only used (and substitute),
+ * 2 if read-alter-rewrite
+ * 3 if set
+ * 4 if set and used
+ * 0 otherwise (not touched)
+ */
+func copyu(p *obj.Prog, v *obj.Addr, s *obj.Addr) int {
+ var info gc.ProgInfo
+
+ switch p.As {
+ case obj.AJMP:
+ if s != nil {
+ if copysub(&p.To, v, s, 1) != 0 {
+ return 1
+ }
+ return 0
+ }
+
+ if copyau(&p.To, v) != 0 {
+ return 1
+ }
+ return 0
+
+ case obj.ARET:
+ if s != nil {
+ return 1
+ }
+ return 3
+
+ case obj.ACALL:
+ if x86.REGEXT != 0 /*TypeKind(100016)*/ && v.Type == obj.TYPE_REG && v.Reg <= x86.REGEXT && v.Reg > exregoffset {
+ return 2
+ }
+ if x86.REGARG >= 0 && v.Type == obj.TYPE_REG && v.Reg == x86.REGARG {
+ return 2
+ }
+ if v.Type == p.From.Type && v.Reg == p.From.Reg {
+ return 2
+ }
+
+ if s != nil {
+ if copysub(&p.To, v, s, 1) != 0 {
+ return 1
+ }
+ return 0
+ }
+
+ if copyau(&p.To, v) != 0 {
+ return 4
+ }
+ return 3
+
+ case obj.ATEXT:
+ if x86.REGARG >= 0 && v.Type == obj.TYPE_REG && v.Reg == x86.REGARG {
+ return 3
+ }
+ return 0
+ }
+
+ if p.As == obj.AVARDEF || p.As == obj.AVARKILL {
+ return 0
+ }
+ proginfo(&info, p)
+
+ if (info.Reguse|info.Regset)&RtoB(int(v.Reg)) != 0 {
+ return 2
+ }
+
+ if info.Flags&gc.LeftAddr != 0 {
+ if copyas(&p.From, v) != 0 {
+ return 2
+ }
+ }
+
+ if info.Flags&(gc.RightRead|gc.RightWrite) == gc.RightRead|gc.RightWrite {
+ if copyas(&p.To, v) != 0 {
+ return 2
+ }
+ }
+
+ if info.Flags&gc.RightWrite != 0 {
+ if copyas(&p.To, v) != 0 {
+ if s != nil {
+ return copysub(&p.From, v, s, 1)
+ }
+ if copyau(&p.From, v) != 0 {
+ return 4
+ }
+ return 3
+ }
+ }
+
+ if info.Flags&(gc.LeftAddr|gc.LeftRead|gc.LeftWrite|gc.RightAddr|gc.RightRead|gc.RightWrite) != 0 {
+ if s != nil {
+ if copysub(&p.From, v, s, 1) != 0 {
+ return 1
+ }
+ return copysub(&p.To, v, s, 1)
+ }
+
+ if copyau(&p.From, v) != 0 {
+ return 1
+ }
+ if copyau(&p.To, v) != 0 {
+ return 1
+ }
+ }
+
+ return 0
+}
+
+/*
+ * direct reference,
+ * could be set/use depending on
+ * semantics
+ */
+func copyas(a *obj.Addr, v *obj.Addr) int {
+ if x86.REG_AL <= a.Reg && a.Reg <= x86.REG_R15B {
+ gc.Fatal("use of byte register")
+ }
+ if x86.REG_AL <= v.Reg && v.Reg <= x86.REG_R15B {
+ gc.Fatal("use of byte register")
+ }
+
+ if a.Type != v.Type || a.Name != v.Name || a.Reg != v.Reg {
+ return 0
+ }
+ if regtyp(v) != 0 {
+ return 1
+ }
+ if v.Type == obj.TYPE_MEM && (v.Name == obj.NAME_AUTO || v.Name == obj.NAME_PARAM) {
+ if v.Offset == a.Offset {
+ return 1
+ }
+ }
+ return 0
+}
+
+func sameaddr(a *obj.Addr, v *obj.Addr) int {
+ if a.Type != v.Type || a.Name != v.Name || a.Reg != v.Reg {
+ return 0
+ }
+ if regtyp(v) != 0 {
+ return 1
+ }
+ if v.Type == obj.TYPE_MEM && (v.Name == obj.NAME_AUTO || v.Name == obj.NAME_PARAM) {
+ if v.Offset == a.Offset {
+ return 1
+ }
+ }
+ return 0
+}
+
+/*
+ * either direct or indirect
+ */
+func copyau(a *obj.Addr, v *obj.Addr) int {
+ if copyas(a, v) != 0 {
+ if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 {
+ fmt.Printf("\tcopyau: copyas returned 1\n")
+ }
+ return 1
+ }
+
+ if regtyp(v) != 0 {
+ if a.Type == obj.TYPE_MEM && a.Reg == v.Reg {
+ if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 {
+ fmt.Printf("\tcopyau: found indir use - return 1\n")
+ }
+ return 1
+ }
+
+ if a.Index == v.Reg {
+ if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 {
+ fmt.Printf("\tcopyau: found index use - return 1\n")
+ }
+ return 1
+ }
+ }
+
+ return 0
+}
+
+/*
+ * substitute s for v in a
+ * return failure to substitute
+ */
+func copysub(a *obj.Addr, v *obj.Addr, s *obj.Addr, f int) int {
+ var reg int
+
+ if copyas(a, v) != 0 {
+ reg = int(s.Reg)
+ if reg >= x86.REG_AX && reg <= x86.REG_R15 || reg >= x86.REG_X0 && reg <= x86.REG_X0+15 {
+ if f != 0 {
+ a.Reg = int16(reg)
+ }
+ }
+
+ return 0
+ }
+
+ if regtyp(v) != 0 {
+ reg = int(v.Reg)
+ if a.Type == obj.TYPE_MEM && int(a.Reg) == reg {
+ if (s.Reg == x86.REG_BP || s.Reg == x86.REG_R13) && a.Index != x86.REG_NONE {
+ return 1 /* can't use BP-base with index */
+ }
+ if f != 0 {
+ a.Reg = s.Reg
+ }
+ }
+
+ // return 0;
+ if int(a.Index) == reg {
+ if f != 0 {
+ a.Index = s.Reg
+ }
+ return 0
+ }
+
+ return 0
+ }
+
+ return 0
+}
+
+func conprop(r0 *gc.Flow) {
+ var r *gc.Flow
+ var p *obj.Prog
+ var p0 *obj.Prog
+ var t int
+ var v0 *obj.Addr
+
+ p0 = r0.Prog
+ v0 = &p0.To
+ r = r0
+
+loop:
+ r = gc.Uniqs(r)
+ if r == nil || r == r0 {
+ return
+ }
+ if gc.Uniqp(r) == nil {
+ return
+ }
+
+ p = r.Prog
+ t = copyu(p, v0, nil)
+ switch t {
+ case 0, // miss
+ 1: // use
+ goto loop
+
+ case 2, // rar
+ 4: // use and set
+ break
+
+ case 3: // set
+ if p.As == p0.As {
+ if p.From.Type == p0.From.Type {
+ if p.From.Reg == p0.From.Reg {
+ if p.From.Node == p0.From.Node {
+ if p.From.Offset == p0.From.Offset {
+ if p.From.Scale == p0.From.Scale {
+ if p.From.Type == obj.TYPE_FCONST && p.From.U.Dval == p0.From.U.Dval {
+ if p.From.Index == p0.From.Index {
+ excise(r)
+ goto loop
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+}
+
+func smallindir(a *obj.Addr, reg *obj.Addr) int {
+ return bool2int(regtyp(reg) != 0 && a.Type == obj.TYPE_MEM && a.Reg == reg.Reg && a.Index == x86.REG_NONE && 0 <= a.Offset && a.Offset < 4096)
+}
+
+func stackaddr(a *obj.Addr) int {
+ return bool2int(a.Type == obj.TYPE_REG && a.Reg == x86.REG_SP)
+}
--- /dev/null
+// 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 main
+
+import (
+ "cmd/internal/obj"
+ "cmd/internal/obj/x86"
+)
+import "cmd/internal/gc"
+
+var (
+ AX = RtoB(x86.REG_AX)
+ BX = RtoB(x86.REG_BX)
+ CX = RtoB(x86.REG_CX)
+ DX = RtoB(x86.REG_DX)
+ DI = RtoB(x86.REG_DI)
+ SI = RtoB(x86.REG_SI)
+ LeftRdwr uint32 = gc.LeftRead | gc.LeftWrite
+ RightRdwr uint32 = gc.RightRead | gc.RightWrite
+)
+
+// This table gives the basic information about instruction
+// generated by the compiler and processed in the optimizer.
+// See opt.h for bit definitions.
+//
+// Instructions not generated need not be listed.
+// As an exception to that rule, we typically write down all the
+// size variants of an operation even if we just use a subset.
+//
+// The table is formatted for 8-space tabs.
+var progtable = [x86.ALAST]gc.ProgInfo{
+ obj.ATYPE: gc.ProgInfo{gc.Pseudo | gc.Skip, 0, 0, 0},
+ obj.ATEXT: gc.ProgInfo{gc.Pseudo, 0, 0, 0},
+ obj.AFUNCDATA: gc.ProgInfo{gc.Pseudo, 0, 0, 0},
+ obj.APCDATA: gc.ProgInfo{gc.Pseudo, 0, 0, 0},
+ obj.AUNDEF: gc.ProgInfo{gc.Break, 0, 0, 0},
+ obj.AUSEFIELD: gc.ProgInfo{gc.OK, 0, 0, 0},
+ obj.ACHECKNIL: gc.ProgInfo{gc.LeftRead, 0, 0, 0},
+ obj.AVARDEF: gc.ProgInfo{gc.Pseudo | gc.RightWrite, 0, 0, 0},
+ obj.AVARKILL: gc.ProgInfo{gc.Pseudo | gc.RightWrite, 0, 0, 0},
+
+ // NOP is an internal no-op that also stands
+ // for USED and SET annotations, not the Intel opcode.
+ obj.ANOP: gc.ProgInfo{gc.LeftRead | gc.RightWrite, 0, 0, 0},
+ x86.AADCL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ x86.AADCQ: gc.ProgInfo{gc.SizeQ | gc.LeftRead | RightRdwr | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ x86.AADCW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ x86.AADDB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.AADDL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.AADDW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.AADDQ: gc.ProgInfo{gc.SizeQ | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.AADDSD: gc.ProgInfo{gc.SizeD | gc.LeftRead | RightRdwr, 0, 0, 0},
+ x86.AADDSS: gc.ProgInfo{gc.SizeF | gc.LeftRead | RightRdwr, 0, 0, 0},
+ x86.AANDB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.AANDL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.AANDQ: gc.ProgInfo{gc.SizeQ | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.AANDW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ obj.ACALL: gc.ProgInfo{gc.RightAddr | gc.Call | gc.KillCarry, 0, 0, 0},
+ x86.ACDQ: gc.ProgInfo{gc.OK, AX, AX | DX, 0},
+ x86.ACQO: gc.ProgInfo{gc.OK, AX, AX | DX, 0},
+ x86.ACWD: gc.ProgInfo{gc.OK, AX, AX | DX, 0},
+ x86.ACLD: gc.ProgInfo{gc.OK, 0, 0, 0},
+ x86.ASTD: gc.ProgInfo{gc.OK, 0, 0, 0},
+ x86.ACMPB: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0},
+ x86.ACMPL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0},
+ x86.ACMPQ: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0},
+ x86.ACMPW: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0},
+ x86.ACOMISD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0},
+ x86.ACOMISS: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0},
+ x86.ACVTSD2SL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.ACVTSD2SQ: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.ACVTSD2SS: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.ACVTSL2SD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.ACVTSL2SS: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.ACVTSQ2SD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.ACVTSQ2SS: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.ACVTSS2SD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.ACVTSS2SL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.ACVTSS2SQ: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.ACVTTSD2SL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.ACVTTSD2SQ: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.ACVTTSS2SL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.ACVTTSS2SQ: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.ADECB: gc.ProgInfo{gc.SizeB | RightRdwr, 0, 0, 0},
+ x86.ADECL: gc.ProgInfo{gc.SizeL | RightRdwr, 0, 0, 0},
+ x86.ADECQ: gc.ProgInfo{gc.SizeQ | RightRdwr, 0, 0, 0},
+ x86.ADECW: gc.ProgInfo{gc.SizeW | RightRdwr, 0, 0, 0},
+ x86.ADIVB: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.SetCarry, AX, AX, 0},
+ x86.ADIVL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.SetCarry, AX | DX, AX | DX, 0},
+ x86.ADIVQ: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.SetCarry, AX | DX, AX | DX, 0},
+ x86.ADIVW: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.SetCarry, AX | DX, AX | DX, 0},
+ x86.ADIVSD: gc.ProgInfo{gc.SizeD | gc.LeftRead | RightRdwr, 0, 0, 0},
+ x86.ADIVSS: gc.ProgInfo{gc.SizeF | gc.LeftRead | RightRdwr, 0, 0, 0},
+ x86.AIDIVB: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.SetCarry, AX, AX, 0},
+ x86.AIDIVL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.SetCarry, AX | DX, AX | DX, 0},
+ x86.AIDIVQ: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.SetCarry, AX | DX, AX | DX, 0},
+ x86.AIDIVW: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.SetCarry, AX | DX, AX | DX, 0},
+ x86.AIMULB: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.SetCarry, AX, AX, 0},
+ x86.AIMULL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.ImulAXDX | gc.SetCarry, 0, 0, 0},
+ x86.AIMULQ: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.ImulAXDX | gc.SetCarry, 0, 0, 0},
+ x86.AIMULW: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.ImulAXDX | gc.SetCarry, 0, 0, 0},
+ x86.AINCB: gc.ProgInfo{gc.SizeB | RightRdwr, 0, 0, 0},
+ x86.AINCL: gc.ProgInfo{gc.SizeL | RightRdwr, 0, 0, 0},
+ x86.AINCQ: gc.ProgInfo{gc.SizeQ | RightRdwr, 0, 0, 0},
+ x86.AINCW: gc.ProgInfo{gc.SizeW | RightRdwr, 0, 0, 0},
+ x86.AJCC: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ x86.AJCS: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ x86.AJEQ: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ x86.AJGE: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ x86.AJGT: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ x86.AJHI: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ x86.AJLE: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ x86.AJLS: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ x86.AJLT: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ x86.AJMI: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ x86.AJNE: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ x86.AJOC: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ x86.AJOS: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ x86.AJPC: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ x86.AJPL: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ x86.AJPS: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ obj.AJMP: gc.ProgInfo{gc.Jump | gc.Break | gc.KillCarry, 0, 0, 0},
+ x86.ALEAL: gc.ProgInfo{gc.LeftAddr | gc.RightWrite, 0, 0, 0},
+ x86.ALEAQ: gc.ProgInfo{gc.LeftAddr | gc.RightWrite, 0, 0, 0},
+ x86.AMOVBLSX: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.AMOVBLZX: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.AMOVBQSX: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.AMOVBQZX: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.AMOVBWSX: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.AMOVBWZX: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.AMOVLQSX: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.AMOVLQZX: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.AMOVWLSX: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.AMOVWLZX: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.AMOVWQSX: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.AMOVWQZX: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.AMOVQL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.AMOVB: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
+ x86.AMOVL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
+ x86.AMOVQ: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
+ x86.AMOVW: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
+ x86.AMOVSB: gc.ProgInfo{gc.OK, DI | SI, DI | SI, 0},
+ x86.AMOVSL: gc.ProgInfo{gc.OK, DI | SI, DI | SI, 0},
+ x86.AMOVSQ: gc.ProgInfo{gc.OK, DI | SI, DI | SI, 0},
+ x86.AMOVSW: gc.ProgInfo{gc.OK, DI | SI, DI | SI, 0},
+ obj.ADUFFCOPY: gc.ProgInfo{gc.OK, DI | SI, DI | SI | CX, 0},
+ x86.AMOVSD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
+ x86.AMOVSS: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
+
+ // We use MOVAPD as a faster synonym for MOVSD.
+ x86.AMOVAPD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
+ x86.AMULB: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.SetCarry, AX, AX, 0},
+ x86.AMULL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.SetCarry, AX, AX | DX, 0},
+ x86.AMULQ: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.SetCarry, AX, AX | DX, 0},
+ x86.AMULW: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.SetCarry, AX, AX | DX, 0},
+ x86.AMULSD: gc.ProgInfo{gc.SizeD | gc.LeftRead | RightRdwr, 0, 0, 0},
+ x86.AMULSS: gc.ProgInfo{gc.SizeF | gc.LeftRead | RightRdwr, 0, 0, 0},
+ x86.ANEGB: gc.ProgInfo{gc.SizeB | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.ANEGL: gc.ProgInfo{gc.SizeL | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.ANEGQ: gc.ProgInfo{gc.SizeQ | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.ANEGW: gc.ProgInfo{gc.SizeW | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.ANOTB: gc.ProgInfo{gc.SizeB | RightRdwr, 0, 0, 0},
+ x86.ANOTL: gc.ProgInfo{gc.SizeL | RightRdwr, 0, 0, 0},
+ x86.ANOTQ: gc.ProgInfo{gc.SizeQ | RightRdwr, 0, 0, 0},
+ x86.ANOTW: gc.ProgInfo{gc.SizeW | RightRdwr, 0, 0, 0},
+ x86.AORB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.AORL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.AORQ: gc.ProgInfo{gc.SizeQ | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.AORW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.APOPQ: gc.ProgInfo{gc.SizeQ | gc.RightWrite, 0, 0, 0},
+ x86.APUSHQ: gc.ProgInfo{gc.SizeQ | gc.LeftRead, 0, 0, 0},
+ x86.ARCLB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ x86.ARCLL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ x86.ARCLQ: gc.ProgInfo{gc.SizeQ | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ x86.ARCLW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ x86.ARCRB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ x86.ARCRL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ x86.ARCRQ: gc.ProgInfo{gc.SizeQ | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ x86.ARCRW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ x86.AREP: gc.ProgInfo{gc.OK, CX, CX, 0},
+ x86.AREPN: gc.ProgInfo{gc.OK, CX, CX, 0},
+ obj.ARET: gc.ProgInfo{gc.Break | gc.KillCarry, 0, 0, 0},
+ x86.AROLB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.AROLL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.AROLQ: gc.ProgInfo{gc.SizeQ | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.AROLW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ARORB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ARORL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ARORQ: gc.ProgInfo{gc.SizeQ | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ARORW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ASALB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ASALL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ASALQ: gc.ProgInfo{gc.SizeQ | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ASALW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ASARB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ASARL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ASARQ: gc.ProgInfo{gc.SizeQ | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ASARW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ASBBB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ x86.ASBBL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ x86.ASBBQ: gc.ProgInfo{gc.SizeQ | gc.LeftRead | RightRdwr | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ x86.ASBBW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ x86.ASHLB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ASHLL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ASHLQ: gc.ProgInfo{gc.SizeQ | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ASHLW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ASHRB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ASHRL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ASHRQ: gc.ProgInfo{gc.SizeQ | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ASHRW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ASTOSB: gc.ProgInfo{gc.OK, AX | DI, DI, 0},
+ x86.ASTOSL: gc.ProgInfo{gc.OK, AX | DI, DI, 0},
+ x86.ASTOSQ: gc.ProgInfo{gc.OK, AX | DI, DI, 0},
+ x86.ASTOSW: gc.ProgInfo{gc.OK, AX | DI, DI, 0},
+ obj.ADUFFZERO: gc.ProgInfo{gc.OK, AX | DI, DI, 0},
+ x86.ASUBB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.ASUBL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.ASUBQ: gc.ProgInfo{gc.SizeQ | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.ASUBW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.ASUBSD: gc.ProgInfo{gc.SizeD | gc.LeftRead | RightRdwr, 0, 0, 0},
+ x86.ASUBSS: gc.ProgInfo{gc.SizeF | gc.LeftRead | RightRdwr, 0, 0, 0},
+ x86.ATESTB: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0},
+ x86.ATESTL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0},
+ x86.ATESTQ: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0},
+ x86.ATESTW: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0},
+ x86.AUCOMISD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightRead, 0, 0, 0},
+ x86.AUCOMISS: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightRead, 0, 0, 0},
+ x86.AXCHGB: gc.ProgInfo{gc.SizeB | LeftRdwr | RightRdwr, 0, 0, 0},
+ x86.AXCHGL: gc.ProgInfo{gc.SizeL | LeftRdwr | RightRdwr, 0, 0, 0},
+ x86.AXCHGQ: gc.ProgInfo{gc.SizeQ | LeftRdwr | RightRdwr, 0, 0, 0},
+ x86.AXCHGW: gc.ProgInfo{gc.SizeW | LeftRdwr | RightRdwr, 0, 0, 0},
+ x86.AXORB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.AXORL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.AXORQ: gc.ProgInfo{gc.SizeQ | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.AXORW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+}
+
+func proginfo(info *gc.ProgInfo, p *obj.Prog) {
+ *info = progtable[p.As]
+ if info.Flags == 0 {
+ gc.Fatal("unknown instruction %v", p)
+ }
+
+ if (info.Flags&gc.ShiftCX != 0) && p.From.Type != obj.TYPE_CONST {
+ info.Reguse |= CX
+ }
+
+ if info.Flags&gc.ImulAXDX != 0 {
+ if p.To.Type == obj.TYPE_NONE {
+ info.Reguse |= AX
+ info.Regset |= AX | DX
+ } else {
+ info.Flags |= RightRdwr
+ }
+ }
+
+ // Addressing makes some registers used.
+ if p.From.Type == obj.TYPE_MEM && p.From.Name == obj.NAME_NONE {
+ info.Regindex |= RtoB(int(p.From.Reg))
+ }
+ if p.From.Index != x86.REG_NONE {
+ info.Regindex |= RtoB(int(p.From.Index))
+ }
+ if p.To.Type == obj.TYPE_MEM && p.To.Name == obj.NAME_NONE {
+ info.Regindex |= RtoB(int(p.To.Reg))
+ }
+ if p.To.Index != x86.REG_NONE {
+ info.Regindex |= RtoB(int(p.To.Index))
+ }
+}
--- /dev/null
+// 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 main
+
+import (
+ "cmd/internal/obj"
+ "cmd/internal/obj/x86"
+)
+import "cmd/internal/gc"
+
+const (
+ NREGVAR = 32
+)
+
+var regname = []string{
+ ".AX",
+ ".CX",
+ ".DX",
+ ".BX",
+ ".SP",
+ ".BP",
+ ".SI",
+ ".DI",
+ ".R8",
+ ".R9",
+ ".R10",
+ ".R11",
+ ".R12",
+ ".R13",
+ ".R14",
+ ".R15",
+ ".X0",
+ ".X1",
+ ".X2",
+ ".X3",
+ ".X4",
+ ".X5",
+ ".X6",
+ ".X7",
+ ".X8",
+ ".X9",
+ ".X10",
+ ".X11",
+ ".X12",
+ ".X13",
+ ".X14",
+ ".X15",
+}
+
+func regnames(n *int) []string {
+ *n = NREGVAR
+ return regname
+}
+
+func excludedregs() uint64 {
+ return RtoB(x86.REG_SP)
+}
+
+func doregbits(r int) uint64 {
+ var b uint64
+
+ b = 0
+ if r >= x86.REG_AX && r <= x86.REG_R15 {
+ b |= RtoB(r)
+ } else if r >= x86.REG_AL && r <= x86.REG_R15B {
+ b |= RtoB(r - x86.REG_AL + x86.REG_AX)
+ } else if r >= x86.REG_AH && r <= x86.REG_BH {
+ b |= RtoB(r - x86.REG_AH + x86.REG_AX)
+ } else if r >= x86.REG_X0 && r <= x86.REG_X0+15 {
+ b |= FtoB(r)
+ }
+ return b
+}
+
+func RtoB(r int) uint64 {
+ if r < x86.REG_AX || r > x86.REG_R15 {
+ return 0
+ }
+ return 1 << uint(r-x86.REG_AX)
+}
+
+func BtoR(b uint64) int {
+ b &= 0xffff
+ if gc.Nacl {
+ b &^= (1<<(x86.REG_BP-x86.REG_AX) | 1<<(x86.REG_R15-x86.REG_AX))
+ } else if obj.Framepointer_enabled != 0 {
+ // BP is part of the calling convention if framepointer_enabled.
+ b &^= (1 << (x86.REG_BP - x86.REG_AX))
+ }
+
+ if b == 0 {
+ return 0
+ }
+ return gc.Bitno(b) + x86.REG_AX
+}
+
+/*
+ * bit reg
+ * 16 X0
+ * ...
+ * 31 X15
+ */
+func FtoB(f int) uint64 {
+ if f < x86.REG_X0 || f > x86.REG_X15 {
+ return 0
+ }
+ return 1 << uint(f-x86.REG_X0+16)
+}
+
+func BtoF(b uint64) int {
+ b &= 0xFFFF0000
+ if b == 0 {
+ return 0
+ }
+ return gc.Bitno(b) - 16 + x86.REG_X0
+}
--- /dev/null
+// Copyright 2015 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 main
+
+func bool2int(b bool) int {
+ if b {
+ return 1
+ }
+ return 0
+}
--- /dev/null
+// 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 main
+
+import (
+ "cmd/internal/obj"
+ "cmd/internal/obj/i386"
+ "fmt"
+)
+import "cmd/internal/gc"
+
+/*
+ * reg.c
+ */
+
+/*
+ * peep.c
+ */
+func mgen(n *gc.Node, n1 *gc.Node, rg *gc.Node) {
+ var n2 gc.Node
+
+ n1.Op = gc.OEMPTY
+
+ if n.Addable != 0 {
+ *n1 = *n
+ if n1.Op == gc.OREGISTER || n1.Op == gc.OINDREG {
+ reg[n.Val.U.Reg]++
+ }
+ return
+ }
+
+ gc.Tempname(n1, n.Type)
+ cgen(n, n1)
+ if n.Type.Width <= int64(gc.Widthptr) || gc.Isfloat[n.Type.Etype] != 0 {
+ n2 = *n1
+ regalloc(n1, n.Type, rg)
+ gmove(&n2, n1)
+ }
+}
+
+func mfree(n *gc.Node) {
+ if n.Op == gc.OREGISTER {
+ regfree(n)
+ }
+}
+
+/*
+ * generate:
+ * res = n;
+ * simplifies and calls gmove.
+ *
+ * TODO:
+ * sudoaddable
+ */
+func cgen(n *gc.Node, res *gc.Node) {
+ var nl *gc.Node
+ var nr *gc.Node
+ var r *gc.Node
+ var n1 gc.Node
+ var n2 gc.Node
+ var nt gc.Node
+ var p1 *obj.Prog
+ var p2 *obj.Prog
+ var p3 *obj.Prog
+ var a int
+
+ if gc.Debug['g'] != 0 {
+ gc.Dump("\ncgen-n", n)
+ gc.Dump("cgen-res", res)
+ }
+
+ if n == nil || n.Type == nil {
+ gc.Fatal("cgen: n nil")
+ }
+ if res == nil || res.Type == nil {
+ gc.Fatal("cgen: res nil")
+ }
+
+ switch n.Op {
+ case gc.OSLICE,
+ gc.OSLICEARR,
+ gc.OSLICESTR,
+ gc.OSLICE3,
+ gc.OSLICE3ARR:
+ if res.Op != gc.ONAME || !(res.Addable != 0) {
+ gc.Tempname(&n1, n.Type)
+ gc.Cgen_slice(n, &n1)
+ cgen(&n1, res)
+ } else {
+ gc.Cgen_slice(n, res)
+ }
+ return
+
+ case gc.OEFACE:
+ if res.Op != gc.ONAME || !(res.Addable != 0) {
+ gc.Tempname(&n1, n.Type)
+ gc.Cgen_eface(n, &n1)
+ cgen(&n1, res)
+ } else {
+ gc.Cgen_eface(n, res)
+ }
+ return
+ }
+
+ for n.Op == gc.OCONVNOP {
+ n = n.Left
+ }
+
+ // function calls on both sides? introduce temporary
+ if n.Ullman >= gc.UINF && res.Ullman >= gc.UINF {
+ gc.Tempname(&n1, n.Type)
+ cgen(n, &n1)
+ cgen(&n1, res)
+ return
+ }
+
+ // structs etc get handled specially
+ if gc.Isfat(n.Type) != 0 {
+ if n.Type.Width < 0 {
+ gc.Fatal("forgot to compute width for %v", gc.Tconv(n.Type, 0))
+ }
+ sgen(n, res, n.Type.Width)
+ return
+ }
+
+ // update addressability for string, slice
+ // can't do in walk because n->left->addable
+ // changes if n->left is an escaping local variable.
+ switch n.Op {
+ case gc.OSPTR,
+ gc.OLEN:
+ if gc.Isslice(n.Left.Type) != 0 || gc.Istype(n.Left.Type, gc.TSTRING) != 0 {
+ n.Addable = n.Left.Addable
+ }
+
+ case gc.OCAP:
+ if gc.Isslice(n.Left.Type) != 0 {
+ n.Addable = n.Left.Addable
+ }
+
+ case gc.OITAB:
+ n.Addable = n.Left.Addable
+ }
+
+ // if both are addressable, move
+ if n.Addable != 0 && res.Addable != 0 {
+ gmove(n, res)
+ return
+ }
+
+ // if both are not addressable, use a temporary.
+ if !(n.Addable != 0) && !(res.Addable != 0) {
+ // could use regalloc here sometimes,
+ // but have to check for ullman >= UINF.
+ gc.Tempname(&n1, n.Type)
+
+ cgen(n, &n1)
+ cgen(&n1, res)
+ return
+ }
+
+ // if result is not addressable directly but n is,
+ // compute its address and then store via the address.
+ if !(res.Addable != 0) {
+ igen(res, &n1, nil)
+ cgen(n, &n1)
+ regfree(&n1)
+ return
+ }
+
+ // complex types
+ if gc.Complexop(n, res) != 0 {
+ gc.Complexgen(n, res)
+ return
+ }
+
+ // otherwise, the result is addressable but n is not.
+ // let's do some computation.
+
+ // use ullman to pick operand to eval first.
+ nl = n.Left
+
+ nr = n.Right
+ if nl != nil && nl.Ullman >= gc.UINF {
+ if nr != nil && nr.Ullman >= gc.UINF {
+ // both are hard
+ gc.Tempname(&n1, nl.Type)
+
+ cgen(nl, &n1)
+ n2 = *n
+ n2.Left = &n1
+ cgen(&n2, res)
+ return
+ }
+ }
+
+ // 64-bit ops are hard on 32-bit machine.
+ if gc.Is64(n.Type) != 0 || gc.Is64(res.Type) != 0 || n.Left != nil && gc.Is64(n.Left.Type) != 0 {
+ switch n.Op {
+ // math goes to cgen64.
+ case gc.OMINUS,
+ gc.OCOM,
+ gc.OADD,
+ gc.OSUB,
+ gc.OMUL,
+ gc.OLROT,
+ gc.OLSH,
+ gc.ORSH,
+ gc.OAND,
+ gc.OOR,
+ gc.OXOR:
+ cgen64(n, res)
+
+ return
+ }
+ }
+
+ if nl != nil && gc.Isfloat[n.Type.Etype] != 0 && gc.Isfloat[nl.Type.Etype] != 0 {
+ cgen_float(n, res)
+ return
+ }
+
+ switch n.Op {
+ default:
+ gc.Dump("cgen", n)
+ gc.Fatal("cgen %v", gc.Oconv(int(n.Op), 0))
+
+ case gc.OREAL,
+ gc.OIMAG,
+ gc.OCOMPLEX:
+ gc.Fatal("unexpected complex")
+ return
+
+ // these call bgen to get a bool value
+ case gc.OOROR,
+ gc.OANDAND,
+ gc.OEQ,
+ gc.ONE,
+ gc.OLT,
+ gc.OLE,
+ gc.OGE,
+ gc.OGT,
+ gc.ONOT:
+ p1 = gc.Gbranch(obj.AJMP, nil, 0)
+
+ p2 = gc.Pc
+ gmove(gc.Nodbool(1), res)
+ p3 = gc.Gbranch(obj.AJMP, nil, 0)
+ gc.Patch(p1, gc.Pc)
+ bgen(n, true, 0, p2)
+ gmove(gc.Nodbool(0), res)
+ gc.Patch(p3, gc.Pc)
+ return
+
+ case gc.OPLUS:
+ cgen(nl, res)
+ return
+
+ case gc.OMINUS,
+ gc.OCOM:
+ a = optoas(int(n.Op), nl.Type)
+ goto uop
+
+ // symmetric binary
+ case gc.OAND,
+ gc.OOR,
+ gc.OXOR,
+ gc.OADD,
+ gc.OMUL:
+ a = optoas(int(n.Op), nl.Type)
+
+ if a == i386.AIMULB {
+ cgen_bmul(int(n.Op), nl, nr, res)
+ break
+ }
+
+ goto sbop
+
+ // asymmetric binary
+ case gc.OSUB:
+ a = optoas(int(n.Op), nl.Type)
+
+ goto abop
+
+ case gc.OHMUL:
+ cgen_hmul(nl, nr, res)
+
+ case gc.OCONV:
+ if gc.Eqtype(n.Type, nl.Type) || gc.Noconv(n.Type, nl.Type) != 0 {
+ cgen(nl, res)
+ break
+ }
+
+ gc.Tempname(&n2, n.Type)
+ mgen(nl, &n1, res)
+ gmove(&n1, &n2)
+ gmove(&n2, res)
+ mfree(&n1)
+
+ case gc.ODOT,
+ gc.ODOTPTR,
+ gc.OINDEX,
+ gc.OIND,
+ gc.ONAME: // PHEAP or PPARAMREF var
+ igen(n, &n1, res)
+
+ gmove(&n1, res)
+ regfree(&n1)
+
+ case gc.OITAB:
+ igen(nl, &n1, res)
+ n1.Type = gc.Ptrto(gc.Types[gc.TUINTPTR])
+ gmove(&n1, res)
+ regfree(&n1)
+
+ // pointer is the first word of string or slice.
+ case gc.OSPTR:
+ if gc.Isconst(nl, gc.CTSTR) != 0 {
+ regalloc(&n1, gc.Types[gc.Tptr], res)
+ p1 = gins(i386.ALEAL, nil, &n1)
+ gc.Datastring(nl.Val.U.Sval.S, &p1.From)
+ gmove(&n1, res)
+ regfree(&n1)
+ break
+ }
+
+ igen(nl, &n1, res)
+ n1.Type = n.Type
+ gmove(&n1, res)
+ regfree(&n1)
+
+ case gc.OLEN:
+ if gc.Istype(nl.Type, gc.TMAP) != 0 || gc.Istype(nl.Type, gc.TCHAN) != 0 {
+ // map has len in the first 32-bit word.
+ // a zero pointer means zero length
+ gc.Tempname(&n1, gc.Types[gc.Tptr])
+
+ cgen(nl, &n1)
+ regalloc(&n2, gc.Types[gc.Tptr], nil)
+ gmove(&n1, &n2)
+ n1 = n2
+
+ gc.Nodconst(&n2, gc.Types[gc.Tptr], 0)
+ gins(optoas(gc.OCMP, gc.Types[gc.Tptr]), &n1, &n2)
+ p1 = gc.Gbranch(optoas(gc.OEQ, gc.Types[gc.Tptr]), nil, -1)
+
+ n2 = n1
+ n2.Op = gc.OINDREG
+ n2.Type = gc.Types[gc.TINT32]
+ gmove(&n2, &n1)
+
+ gc.Patch(p1, gc.Pc)
+
+ gmove(&n1, res)
+ regfree(&n1)
+ break
+ }
+
+ if gc.Istype(nl.Type, gc.TSTRING) != 0 || gc.Isslice(nl.Type) != 0 {
+ // both slice and string have len one pointer into the struct.
+ igen(nl, &n1, res)
+
+ n1.Type = gc.Types[gc.TUINT32]
+ n1.Xoffset += int64(gc.Array_nel)
+ gmove(&n1, res)
+ regfree(&n1)
+ break
+ }
+
+ gc.Fatal("cgen: OLEN: unknown type %v", gc.Tconv(nl.Type, obj.FmtLong))
+
+ case gc.OCAP:
+ if gc.Istype(nl.Type, gc.TCHAN) != 0 {
+ // chan has cap in the second 32-bit word.
+ // a zero pointer means zero length
+ gc.Tempname(&n1, gc.Types[gc.Tptr])
+
+ cgen(nl, &n1)
+ regalloc(&n2, gc.Types[gc.Tptr], nil)
+ gmove(&n1, &n2)
+ n1 = n2
+
+ gc.Nodconst(&n2, gc.Types[gc.Tptr], 0)
+ gins(optoas(gc.OCMP, gc.Types[gc.Tptr]), &n1, &n2)
+ p1 = gc.Gbranch(optoas(gc.OEQ, gc.Types[gc.Tptr]), nil, -1)
+
+ n2 = n1
+ n2.Op = gc.OINDREG
+ n2.Xoffset = 4
+ n2.Type = gc.Types[gc.TINT32]
+ gmove(&n2, &n1)
+
+ gc.Patch(p1, gc.Pc)
+
+ gmove(&n1, res)
+ regfree(&n1)
+ break
+ }
+
+ if gc.Isslice(nl.Type) != 0 {
+ igen(nl, &n1, res)
+ n1.Type = gc.Types[gc.TUINT32]
+ n1.Xoffset += int64(gc.Array_cap)
+ gmove(&n1, res)
+ regfree(&n1)
+ break
+ }
+
+ gc.Fatal("cgen: OCAP: unknown type %v", gc.Tconv(nl.Type, obj.FmtLong))
+
+ case gc.OADDR:
+ agen(nl, res)
+
+ case gc.OCALLMETH:
+ gc.Cgen_callmeth(n, 0)
+ cgen_callret(n, res)
+
+ case gc.OCALLINTER:
+ cgen_callinter(n, res, 0)
+ cgen_callret(n, res)
+
+ case gc.OCALLFUNC:
+ cgen_call(n, 0)
+ cgen_callret(n, res)
+
+ case gc.OMOD,
+ gc.ODIV:
+ cgen_div(int(n.Op), nl, nr, res)
+
+ case gc.OLSH,
+ gc.ORSH,
+ gc.OLROT:
+ cgen_shift(int(n.Op), int(n.Bounded), nl, nr, res)
+ }
+
+ return
+
+sbop: // symmetric binary
+ if nl.Ullman < nr.Ullman || nl.Op == gc.OLITERAL {
+ r = nl
+ nl = nr
+ nr = r
+ }
+
+abop: // asymmetric binary
+ if gc.Smallintconst(nr) != 0 {
+ mgen(nl, &n1, res)
+ regalloc(&n2, nl.Type, &n1)
+ gmove(&n1, &n2)
+ gins(a, nr, &n2)
+ gmove(&n2, res)
+ regfree(&n2)
+ mfree(&n1)
+ } else if nl.Ullman >= nr.Ullman {
+ gc.Tempname(&nt, nl.Type)
+ cgen(nl, &nt)
+ mgen(nr, &n2, nil)
+ regalloc(&n1, nl.Type, res)
+ gmove(&nt, &n1)
+ gins(a, &n2, &n1)
+ gmove(&n1, res)
+ regfree(&n1)
+ mfree(&n2)
+ } else {
+ regalloc(&n2, nr.Type, res)
+ cgen(nr, &n2)
+ regalloc(&n1, nl.Type, nil)
+ cgen(nl, &n1)
+ gins(a, &n2, &n1)
+ regfree(&n2)
+ gmove(&n1, res)
+ regfree(&n1)
+ }
+
+ return
+
+uop: // unary
+ gc.Tempname(&n1, nl.Type)
+
+ cgen(nl, &n1)
+ gins(a, nil, &n1)
+ gmove(&n1, res)
+ return
+}
+
+/*
+ * generate an addressable node in res, containing the value of n.
+ * n is an array index, and might be any size; res width is <= 32-bit.
+ * returns Prog* to patch to panic call.
+ */
+func igenindex(n *gc.Node, res *gc.Node, bounded int) *obj.Prog {
+ var tmp gc.Node
+ var lo gc.Node
+ var hi gc.Node
+ var zero gc.Node
+
+ if !(gc.Is64(n.Type) != 0) {
+ if n.Addable != 0 {
+ // nothing to do.
+ *res = *n
+ } else {
+ gc.Tempname(res, gc.Types[gc.TUINT32])
+ cgen(n, res)
+ }
+
+ return nil
+ }
+
+ gc.Tempname(&tmp, gc.Types[gc.TINT64])
+ cgen(n, &tmp)
+ split64(&tmp, &lo, &hi)
+ gc.Tempname(res, gc.Types[gc.TUINT32])
+ gmove(&lo, res)
+ if bounded != 0 {
+ splitclean()
+ return nil
+ }
+
+ gc.Nodconst(&zero, gc.Types[gc.TINT32], 0)
+ gins(i386.ACMPL, &hi, &zero)
+ splitclean()
+ return gc.Gbranch(i386.AJNE, nil, +1)
+}
+
+/*
+ * address gen
+ * res = &n;
+ * The generated code checks that the result is not nil.
+ */
+func agen(n *gc.Node, res *gc.Node) {
+ var nl *gc.Node
+ var nr *gc.Node
+ var n1 gc.Node
+ var n2 gc.Node
+ var n3 gc.Node
+ var tmp gc.Node
+ var nlen gc.Node
+ var t *gc.Type
+ var w uint32
+ var v uint64
+ var p1 *obj.Prog
+ var p2 *obj.Prog
+ var bounded int
+
+ if gc.Debug['g'] != 0 {
+ gc.Dump("\nagen-res", res)
+ gc.Dump("agen-r", n)
+ }
+
+ if n == nil || n.Type == nil || res == nil || res.Type == nil {
+ gc.Fatal("agen")
+ }
+
+ for n.Op == gc.OCONVNOP {
+ n = n.Left
+ }
+
+ if gc.Isconst(n, gc.CTNIL) != 0 && n.Type.Width > int64(gc.Widthptr) {
+ // Use of a nil interface or nil slice.
+ // Create a temporary we can take the address of and read.
+ // The generated code is just going to panic, so it need not
+ // be terribly efficient. See issue 3670.
+ gc.Tempname(&n1, n.Type)
+
+ gc.Gvardef(&n1)
+ clearfat(&n1)
+ regalloc(&n2, gc.Types[gc.Tptr], res)
+ gins(i386.ALEAL, &n1, &n2)
+ gmove(&n2, res)
+ regfree(&n2)
+ return
+ }
+
+ // addressable var is easy
+ if n.Addable != 0 {
+ if n.Op == gc.OREGISTER {
+ gc.Fatal("agen OREGISTER")
+ }
+ regalloc(&n1, gc.Types[gc.Tptr], res)
+ gins(i386.ALEAL, n, &n1)
+ gmove(&n1, res)
+ regfree(&n1)
+ return
+ }
+
+ // let's compute
+ nl = n.Left
+
+ nr = n.Right
+
+ switch n.Op {
+ default:
+ gc.Fatal("agen %v", gc.Oconv(int(n.Op), 0))
+ fallthrough
+
+ case gc.OCALLMETH:
+ gc.Cgen_callmeth(n, 0)
+ cgen_aret(n, res)
+
+ case gc.OCALLINTER:
+ cgen_callinter(n, res, 0)
+ cgen_aret(n, res)
+
+ case gc.OCALLFUNC:
+ cgen_call(n, 0)
+ cgen_aret(n, res)
+
+ case gc.OSLICE,
+ gc.OSLICEARR,
+ gc.OSLICESTR,
+ gc.OSLICE3,
+ gc.OSLICE3ARR:
+ gc.Tempname(&n1, n.Type)
+ gc.Cgen_slice(n, &n1)
+ agen(&n1, res)
+
+ case gc.OEFACE:
+ gc.Tempname(&n1, n.Type)
+ gc.Cgen_eface(n, &n1)
+ agen(&n1, res)
+
+ case gc.OINDEX:
+ p2 = nil // to be patched to panicindex.
+ w = uint32(n.Type.Width)
+ bounded = bool2int(gc.Debug['B'] != 0 || n.Bounded != 0)
+ if nr.Addable != 0 {
+ // Generate &nl first, and move nr into register.
+ if !(gc.Isconst(nl, gc.CTSTR) != 0) {
+ igen(nl, &n3, res)
+ }
+ if !(gc.Isconst(nr, gc.CTINT) != 0) {
+ p2 = igenindex(nr, &tmp, bounded)
+ regalloc(&n1, tmp.Type, nil)
+ gmove(&tmp, &n1)
+ }
+ } else if nl.Addable != 0 {
+ // Generate nr first, and move &nl into register.
+ if !(gc.Isconst(nr, gc.CTINT) != 0) {
+ p2 = igenindex(nr, &tmp, bounded)
+ regalloc(&n1, tmp.Type, nil)
+ gmove(&tmp, &n1)
+ }
+
+ if !(gc.Isconst(nl, gc.CTSTR) != 0) {
+ igen(nl, &n3, res)
+ }
+ } else {
+ p2 = igenindex(nr, &tmp, bounded)
+ nr = &tmp
+ if !(gc.Isconst(nl, gc.CTSTR) != 0) {
+ igen(nl, &n3, res)
+ }
+ regalloc(&n1, tmp.Type, nil)
+ gins(optoas(gc.OAS, tmp.Type), &tmp, &n1)
+ }
+
+ // For fixed array we really want the pointer in n3.
+ if gc.Isfixedarray(nl.Type) != 0 {
+ regalloc(&n2, gc.Types[gc.Tptr], &n3)
+ agen(&n3, &n2)
+ regfree(&n3)
+ n3 = n2
+ }
+
+ // &a[0] is in n3 (allocated in res)
+ // i is in n1 (if not constant)
+ // len(a) is in nlen (if needed)
+ // w is width
+
+ // constant index
+ if gc.Isconst(nr, gc.CTINT) != 0 {
+ if gc.Isconst(nl, gc.CTSTR) != 0 {
+ gc.Fatal("constant string constant index") // front end should handle
+ }
+ v = uint64(gc.Mpgetfix(nr.Val.U.Xval))
+ if gc.Isslice(nl.Type) != 0 || nl.Type.Etype == gc.TSTRING {
+ if !(gc.Debug['B'] != 0) && !(n.Bounded != 0) {
+ nlen = n3
+ nlen.Type = gc.Types[gc.TUINT32]
+ nlen.Xoffset += int64(gc.Array_nel)
+ gc.Nodconst(&n2, gc.Types[gc.TUINT32], int64(v))
+ gins(optoas(gc.OCMP, gc.Types[gc.TUINT32]), &nlen, &n2)
+ p1 = gc.Gbranch(optoas(gc.OGT, gc.Types[gc.TUINT32]), nil, +1)
+ ginscall(gc.Panicindex, -1)
+ gc.Patch(p1, gc.Pc)
+ }
+ }
+
+ // Load base pointer in n2 = n3.
+ regalloc(&n2, gc.Types[gc.Tptr], &n3)
+
+ n3.Type = gc.Types[gc.Tptr]
+ n3.Xoffset += int64(gc.Array_array)
+ gmove(&n3, &n2)
+ regfree(&n3)
+ if v*uint64(w) != 0 {
+ gc.Nodconst(&n1, gc.Types[gc.Tptr], int64(v*uint64(w)))
+ gins(optoas(gc.OADD, gc.Types[gc.Tptr]), &n1, &n2)
+ }
+
+ gmove(&n2, res)
+ regfree(&n2)
+ break
+ }
+
+ // i is in register n1, extend to 32 bits.
+ t = gc.Types[gc.TUINT32]
+
+ if gc.Issigned[n1.Type.Etype] != 0 {
+ t = gc.Types[gc.TINT32]
+ }
+
+ regalloc(&n2, t, &n1) // i
+ gmove(&n1, &n2)
+ regfree(&n1)
+
+ if !(gc.Debug['B'] != 0) && !(n.Bounded != 0) {
+ // check bounds
+ t = gc.Types[gc.TUINT32]
+
+ if gc.Isconst(nl, gc.CTSTR) != 0 {
+ gc.Nodconst(&nlen, t, int64(len(nl.Val.U.Sval.S)))
+ } else if gc.Isslice(nl.Type) != 0 || nl.Type.Etype == gc.TSTRING {
+ nlen = n3
+ nlen.Type = t
+ nlen.Xoffset += int64(gc.Array_nel)
+ } else {
+ gc.Nodconst(&nlen, t, nl.Type.Bound)
+ }
+
+ gins(optoas(gc.OCMP, t), &n2, &nlen)
+ p1 = gc.Gbranch(optoas(gc.OLT, t), nil, +1)
+ if p2 != nil {
+ gc.Patch(p2, gc.Pc)
+ }
+ ginscall(gc.Panicindex, -1)
+ gc.Patch(p1, gc.Pc)
+ }
+
+ if gc.Isconst(nl, gc.CTSTR) != 0 {
+ regalloc(&n3, gc.Types[gc.Tptr], res)
+ p1 = gins(i386.ALEAL, nil, &n3)
+ gc.Datastring(nl.Val.U.Sval.S, &p1.From)
+ p1.From.Scale = 1
+ p1.From.Index = n2.Val.U.Reg
+ goto indexdone
+ }
+
+ // Load base pointer in n3.
+ regalloc(&tmp, gc.Types[gc.Tptr], &n3)
+
+ if gc.Isslice(nl.Type) != 0 || nl.Type.Etype == gc.TSTRING {
+ n3.Type = gc.Types[gc.Tptr]
+ n3.Xoffset += int64(gc.Array_array)
+ gmove(&n3, &tmp)
+ }
+
+ regfree(&n3)
+ n3 = tmp
+
+ if w == 0 {
+ } else // nothing to do
+ if w == 1 || w == 2 || w == 4 || w == 8 {
+ // LEAL (n3)(n2*w), n3
+ p1 = gins(i386.ALEAL, &n2, &n3)
+
+ p1.From.Scale = int8(w)
+ p1.From.Type = obj.TYPE_MEM
+ p1.From.Index = p1.From.Reg
+ p1.From.Reg = p1.To.Reg
+ } else {
+ gc.Nodconst(&tmp, gc.Types[gc.TUINT32], int64(w))
+ gins(optoas(gc.OMUL, gc.Types[gc.TUINT32]), &tmp, &n2)
+ gins(optoas(gc.OADD, gc.Types[gc.Tptr]), &n2, &n3)
+ }
+
+ indexdone:
+ gmove(&n3, res)
+ regfree(&n2)
+ regfree(&n3)
+
+ // should only get here with names in this func.
+ case gc.ONAME:
+ if n.Funcdepth > 0 && n.Funcdepth != gc.Funcdepth {
+ gc.Dump("bad agen", n)
+ gc.Fatal("agen: bad ONAME funcdepth %d != %d", n.Funcdepth, gc.Funcdepth)
+ }
+
+ // should only get here for heap vars or paramref
+ if !(n.Class&gc.PHEAP != 0) && n.Class != gc.PPARAMREF {
+ gc.Dump("bad agen", n)
+ gc.Fatal("agen: bad ONAME class %#x", n.Class)
+ }
+
+ cgen(n.Heapaddr, res)
+ if n.Xoffset != 0 {
+ gc.Nodconst(&n1, gc.Types[gc.Tptr], n.Xoffset)
+ gins(optoas(gc.OADD, gc.Types[gc.Tptr]), &n1, res)
+ }
+
+ case gc.OIND:
+ cgen(nl, res)
+ gc.Cgen_checknil(res)
+
+ case gc.ODOT:
+ agen(nl, res)
+ if n.Xoffset != 0 {
+ gc.Nodconst(&n1, gc.Types[gc.Tptr], n.Xoffset)
+ gins(optoas(gc.OADD, gc.Types[gc.Tptr]), &n1, res)
+ }
+
+ case gc.ODOTPTR:
+ t = nl.Type
+ if !(gc.Isptr[t.Etype] != 0) {
+ gc.Fatal("agen: not ptr %v", gc.Nconv(n, 0))
+ }
+ cgen(nl, res)
+ gc.Cgen_checknil(res)
+ if n.Xoffset != 0 {
+ gc.Nodconst(&n1, gc.Types[gc.Tptr], n.Xoffset)
+ gins(optoas(gc.OADD, gc.Types[gc.Tptr]), &n1, res)
+ }
+ }
+}
+
+/*
+ * generate:
+ * newreg = &n;
+ * res = newreg
+ *
+ * on exit, a has been changed to be *newreg.
+ * caller must regfree(a).
+ * The generated code checks that the result is not *nil.
+ */
+func igen(n *gc.Node, a *gc.Node, res *gc.Node) {
+ var fp *gc.Type
+ var flist gc.Iter
+ var n1 gc.Node
+
+ if gc.Debug['g'] != 0 {
+ gc.Dump("\nigen-n", n)
+ }
+
+ switch n.Op {
+ case gc.ONAME:
+ if (n.Class&gc.PHEAP != 0) || n.Class == gc.PPARAMREF {
+ break
+ }
+ *a = *n
+ return
+
+ // Increase the refcount of the register so that igen's caller
+ // has to call regfree.
+ case gc.OINDREG:
+ if n.Val.U.Reg != i386.REG_SP {
+ reg[n.Val.U.Reg]++
+ }
+ *a = *n
+ return
+
+ case gc.ODOT:
+ igen(n.Left, a, res)
+ a.Xoffset += n.Xoffset
+ a.Type = n.Type
+ return
+
+ case gc.ODOTPTR:
+ switch n.Left.Op {
+ // igen-able nodes.
+ case gc.ODOT,
+ gc.ODOTPTR,
+ gc.OCALLFUNC,
+ gc.OCALLMETH,
+ gc.OCALLINTER:
+ igen(n.Left, &n1, res)
+
+ regalloc(a, gc.Types[gc.Tptr], &n1)
+ gmove(&n1, a)
+ regfree(&n1)
+
+ default:
+ regalloc(a, gc.Types[gc.Tptr], res)
+ cgen(n.Left, a)
+ }
+
+ gc.Cgen_checknil(a)
+ a.Op = gc.OINDREG
+ a.Xoffset += n.Xoffset
+ a.Type = n.Type
+ return
+
+ case gc.OCALLFUNC,
+ gc.OCALLMETH,
+ gc.OCALLINTER:
+ switch n.Op {
+ case gc.OCALLFUNC:
+ cgen_call(n, 0)
+
+ case gc.OCALLMETH:
+ gc.Cgen_callmeth(n, 0)
+
+ case gc.OCALLINTER:
+ cgen_callinter(n, nil, 0)
+ }
+
+ fp = gc.Structfirst(&flist, gc.Getoutarg(n.Left.Type))
+ *a = gc.Node{}
+ a.Op = gc.OINDREG
+ a.Val.U.Reg = i386.REG_SP
+ a.Addable = 1
+ a.Xoffset = fp.Width
+ a.Type = n.Type
+ return
+
+ // Index of fixed-size array by constant can
+ // put the offset in the addressing.
+ // Could do the same for slice except that we need
+ // to use the real index for the bounds checking.
+ case gc.OINDEX:
+ if gc.Isfixedarray(n.Left.Type) != 0 || (gc.Isptr[n.Left.Type.Etype] != 0 && gc.Isfixedarray(n.Left.Left.Type) != 0) {
+ if gc.Isconst(n.Right, gc.CTINT) != 0 {
+ // Compute &a.
+ if !(gc.Isptr[n.Left.Type.Etype] != 0) {
+ igen(n.Left, a, res)
+ } else {
+ igen(n.Left, &n1, res)
+ gc.Cgen_checknil(&n1)
+ regalloc(a, gc.Types[gc.Tptr], res)
+ gmove(&n1, a)
+ regfree(&n1)
+ a.Op = gc.OINDREG
+ }
+
+ // Compute &a[i] as &a + i*width.
+ a.Type = n.Type
+
+ a.Xoffset += gc.Mpgetfix(n.Right.Val.U.Xval) * n.Type.Width
+ return
+ }
+ }
+ }
+
+ // release register for now, to avoid
+ // confusing tempname.
+ if res != nil && res.Op == gc.OREGISTER {
+ reg[res.Val.U.Reg]--
+ }
+ gc.Tempname(&n1, gc.Types[gc.Tptr])
+ agen(n, &n1)
+ if res != nil && res.Op == gc.OREGISTER {
+ reg[res.Val.U.Reg]++
+ }
+ regalloc(a, gc.Types[gc.Tptr], res)
+ gmove(&n1, a)
+ a.Op = gc.OINDREG
+ a.Type = n.Type
+}
+
+/*
+ * branch gen
+ * if(n == true) goto to;
+ */
+func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) {
+ var et int
+ var a int
+ var nl *gc.Node
+ var nr *gc.Node
+ var r *gc.Node
+ var n1 gc.Node
+ var n2 gc.Node
+ var tmp gc.Node
+ var p1 *obj.Prog
+ var p2 *obj.Prog
+
+ if gc.Debug['g'] != 0 {
+ gc.Dump("\nbgen", n)
+ }
+
+ if n == nil {
+ n = gc.Nodbool(1)
+ }
+
+ if n.Ninit != nil {
+ gc.Genlist(n.Ninit)
+ }
+
+ if n.Type == nil {
+ gc.Convlit(&n, gc.Types[gc.TBOOL])
+ if n.Type == nil {
+ return
+ }
+ }
+
+ et = int(n.Type.Etype)
+ if et != gc.TBOOL {
+ gc.Yyerror("cgen: bad type %v for %v", gc.Tconv(n.Type, 0), gc.Oconv(int(n.Op), 0))
+ gc.Patch(gins(obj.AEND, nil, nil), to)
+ return
+ }
+
+ for n.Op == gc.OCONVNOP {
+ n = n.Left
+ if n.Ninit != nil {
+ gc.Genlist(n.Ninit)
+ }
+ }
+
+ nl = n.Left
+ nr = nil
+
+ if nl != nil && gc.Isfloat[nl.Type.Etype] != 0 {
+ bgen_float(n, bool2int(true_), likely, to)
+ return
+ }
+
+ switch n.Op {
+ default:
+ goto def
+
+ // need to ask if it is bool?
+ case gc.OLITERAL:
+ if !true_ == !(n.Val.U.Bval != 0) {
+ gc.Patch(gc.Gbranch(obj.AJMP, nil, 0), to)
+ }
+ return
+
+ case gc.ONAME:
+ if !(n.Addable != 0) {
+ goto def
+ }
+ gc.Nodconst(&n1, n.Type, 0)
+ gins(optoas(gc.OCMP, n.Type), n, &n1)
+ a = i386.AJNE
+ if !true_ {
+ a = i386.AJEQ
+ }
+ gc.Patch(gc.Gbranch(a, n.Type, likely), to)
+ return
+
+ case gc.OANDAND,
+ gc.OOROR:
+ if (n.Op == gc.OANDAND) == true_ {
+ p1 = gc.Gbranch(obj.AJMP, nil, 0)
+ p2 = gc.Gbranch(obj.AJMP, nil, 0)
+ gc.Patch(p1, gc.Pc)
+ bgen(n.Left, !true_, -likely, p2)
+ bgen(n.Right, !true_, -likely, p2)
+ p1 = gc.Gbranch(obj.AJMP, nil, 0)
+ gc.Patch(p1, to)
+ gc.Patch(p2, gc.Pc)
+ } else {
+ bgen(n.Left, true_, likely, to)
+ bgen(n.Right, true_, likely, to)
+ }
+
+ return
+
+ case gc.OEQ,
+ gc.ONE,
+ gc.OLT,
+ gc.OGT,
+ gc.OLE,
+ gc.OGE:
+ nr = n.Right
+ if nr == nil || nr.Type == nil {
+ return
+ }
+ fallthrough
+
+ case gc.ONOT: // unary
+ nl = n.Left
+
+ if nl == nil || nl.Type == nil {
+ return
+ }
+ }
+
+ switch n.Op {
+ case gc.ONOT:
+ bgen(nl, !true_, likely, to)
+
+ case gc.OEQ,
+ gc.ONE,
+ gc.OLT,
+ gc.OGT,
+ gc.OLE,
+ gc.OGE:
+ a = int(n.Op)
+ if !true_ {
+ a = gc.Brcom(a)
+ true_ = !true_
+ }
+
+ // make simplest on right
+ if nl.Op == gc.OLITERAL || (nl.Ullman < nr.Ullman && nl.Ullman < gc.UINF) {
+ a = gc.Brrev(a)
+ r = nl
+ nl = nr
+ nr = r
+ }
+
+ if gc.Isslice(nl.Type) != 0 {
+ // front end should only leave cmp to literal nil
+ if (a != gc.OEQ && a != gc.ONE) || nr.Op != gc.OLITERAL {
+ gc.Yyerror("illegal slice comparison")
+ break
+ }
+
+ a = optoas(a, gc.Types[gc.Tptr])
+ igen(nl, &n1, nil)
+ n1.Xoffset += int64(gc.Array_array)
+ n1.Type = gc.Types[gc.Tptr]
+ gc.Nodconst(&tmp, gc.Types[gc.Tptr], 0)
+ gins(optoas(gc.OCMP, gc.Types[gc.Tptr]), &n1, &tmp)
+ gc.Patch(gc.Gbranch(a, gc.Types[gc.Tptr], likely), to)
+ regfree(&n1)
+ break
+ }
+
+ if gc.Isinter(nl.Type) != 0 {
+ // front end should only leave cmp to literal nil
+ if (a != gc.OEQ && a != gc.ONE) || nr.Op != gc.OLITERAL {
+ gc.Yyerror("illegal interface comparison")
+ break
+ }
+
+ a = optoas(a, gc.Types[gc.Tptr])
+ igen(nl, &n1, nil)
+ n1.Type = gc.Types[gc.Tptr]
+ gc.Nodconst(&tmp, gc.Types[gc.Tptr], 0)
+ gins(optoas(gc.OCMP, gc.Types[gc.Tptr]), &n1, &tmp)
+ gc.Patch(gc.Gbranch(a, gc.Types[gc.Tptr], likely), to)
+ regfree(&n1)
+ break
+ }
+
+ if gc.Iscomplex[nl.Type.Etype] != 0 {
+ gc.Complexbool(a, nl, nr, true_, likely, to)
+ break
+ }
+
+ if gc.Is64(nr.Type) != 0 {
+ if !(nl.Addable != 0) || gc.Isconst(nl, gc.CTINT) != 0 {
+ gc.Tempname(&n1, nl.Type)
+ cgen(nl, &n1)
+ nl = &n1
+ }
+
+ if !(nr.Addable != 0) {
+ gc.Tempname(&n2, nr.Type)
+ cgen(nr, &n2)
+ nr = &n2
+ }
+
+ cmp64(nl, nr, a, likely, to)
+ break
+ }
+
+ if nr.Ullman >= gc.UINF {
+ if !(nl.Addable != 0) {
+ gc.Tempname(&n1, nl.Type)
+ cgen(nl, &n1)
+ nl = &n1
+ }
+
+ if !(nr.Addable != 0) {
+ gc.Tempname(&tmp, nr.Type)
+ cgen(nr, &tmp)
+ nr = &tmp
+ }
+
+ regalloc(&n2, nr.Type, nil)
+ cgen(nr, &n2)
+ nr = &n2
+ goto cmp
+ }
+
+ if !(nl.Addable != 0) {
+ gc.Tempname(&n1, nl.Type)
+ cgen(nl, &n1)
+ nl = &n1
+ }
+
+ if gc.Smallintconst(nr) != 0 {
+ gins(optoas(gc.OCMP, nr.Type), nl, nr)
+ gc.Patch(gc.Gbranch(optoas(a, nr.Type), nr.Type, likely), to)
+ break
+ }
+
+ if !(nr.Addable != 0) {
+ gc.Tempname(&tmp, nr.Type)
+ cgen(nr, &tmp)
+ nr = &tmp
+ }
+
+ regalloc(&n2, nr.Type, nil)
+ gmove(nr, &n2)
+ nr = &n2
+
+ cmp:
+ gins(optoas(gc.OCMP, nr.Type), nl, nr)
+ gc.Patch(gc.Gbranch(optoas(a, nr.Type), nr.Type, likely), to)
+
+ if nl.Op == gc.OREGISTER {
+ regfree(nl)
+ }
+ regfree(nr)
+ }
+
+ return
+
+def:
+ regalloc(&n1, n.Type, nil)
+ cgen(n, &n1)
+ gc.Nodconst(&n2, n.Type, 0)
+ gins(optoas(gc.OCMP, n.Type), &n1, &n2)
+ a = i386.AJNE
+ if !true_ {
+ a = i386.AJEQ
+ }
+ gc.Patch(gc.Gbranch(a, n.Type, likely), to)
+ regfree(&n1)
+ return
+}
+
+/*
+ * n is on stack, either local variable
+ * or return value from function call.
+ * return n's offset from SP.
+ */
+func stkof(n *gc.Node) int32 {
+ var t *gc.Type
+ var flist gc.Iter
+ var off int32
+
+ switch n.Op {
+ case gc.OINDREG:
+ return int32(n.Xoffset)
+
+ case gc.ODOT:
+ t = n.Left.Type
+ if gc.Isptr[t.Etype] != 0 {
+ break
+ }
+ off = stkof(n.Left)
+ if off == -1000 || off == 1000 {
+ return off
+ }
+ return int32(int64(off) + n.Xoffset)
+
+ case gc.OINDEX:
+ t = n.Left.Type
+ if !(gc.Isfixedarray(t) != 0) {
+ break
+ }
+ off = stkof(n.Left)
+ if off == -1000 || off == 1000 {
+ return off
+ }
+ if gc.Isconst(n.Right, gc.CTINT) != 0 {
+ return int32(int64(off) + t.Type.Width*gc.Mpgetfix(n.Right.Val.U.Xval))
+ }
+ return 1000
+
+ case gc.OCALLMETH,
+ gc.OCALLINTER,
+ gc.OCALLFUNC:
+ t = n.Left.Type
+ if gc.Isptr[t.Etype] != 0 {
+ t = t.Type
+ }
+
+ t = gc.Structfirst(&flist, gc.Getoutarg(t))
+ if t != nil {
+ return int32(t.Width)
+ }
+ }
+
+ // botch - probably failing to recognize address
+ // arithmetic on the above. eg INDEX and DOT
+ return -1000
+}
+
+/*
+ * struct gen
+ * memmove(&res, &n, w);
+ */
+func sgen(n *gc.Node, res *gc.Node, w int64) {
+ var dst gc.Node
+ var src gc.Node
+ var tdst gc.Node
+ var tsrc gc.Node
+ var cx gc.Node
+ var c int32
+ var q int32
+ var odst int32
+ var osrc int32
+ var l *gc.NodeList
+ var p *obj.Prog
+
+ if gc.Debug['g'] != 0 {
+ fmt.Printf("\nsgen w=%d\n", w)
+ gc.Dump("r", n)
+ gc.Dump("res", res)
+ }
+
+ if n.Ullman >= gc.UINF && res.Ullman >= gc.UINF {
+ gc.Fatal("sgen UINF")
+ }
+
+ if w < 0 || int64(int32(w)) != w {
+ gc.Fatal("sgen copy %d", w)
+ }
+
+ if w == 0 {
+ // evaluate side effects only.
+ gc.Tempname(&tdst, gc.Types[gc.Tptr])
+
+ agen(res, &tdst)
+ agen(n, &tdst)
+ return
+ }
+
+ // If copying .args, that's all the results, so record definition sites
+ // for them for the liveness analysis.
+ if res.Op == gc.ONAME && res.Sym.Name == ".args" {
+ for l = gc.Curfn.Dcl; l != nil; l = l.Next {
+ if l.N.Class == gc.PPARAMOUT {
+ gc.Gvardef(l.N)
+ }
+ }
+ }
+
+ // Avoid taking the address for simple enough types.
+ if componentgen(n, res) != 0 {
+ return
+ }
+
+ // offset on the stack
+ osrc = stkof(n)
+
+ odst = stkof(res)
+
+ if osrc != -1000 && odst != -1000 && (osrc == 1000 || odst == 1000) {
+ // osrc and odst both on stack, and at least one is in
+ // an unknown position. Could generate code to test
+ // for forward/backward copy, but instead just copy
+ // to a temporary location first.
+ gc.Tempname(&tsrc, n.Type)
+
+ sgen(n, &tsrc, w)
+ sgen(&tsrc, res, w)
+ return
+ }
+
+ gc.Nodreg(&dst, gc.Types[gc.Tptr], i386.REG_DI)
+ gc.Nodreg(&src, gc.Types[gc.Tptr], i386.REG_SI)
+
+ gc.Tempname(&tsrc, gc.Types[gc.Tptr])
+ gc.Tempname(&tdst, gc.Types[gc.Tptr])
+ if !(n.Addable != 0) {
+ agen(n, &tsrc)
+ }
+ if !(res.Addable != 0) {
+ agen(res, &tdst)
+ }
+ if n.Addable != 0 {
+ agen(n, &src)
+ } else {
+ gmove(&tsrc, &src)
+ }
+
+ if res.Op == gc.ONAME {
+ gc.Gvardef(res)
+ }
+
+ if res.Addable != 0 {
+ agen(res, &dst)
+ } else {
+ gmove(&tdst, &dst)
+ }
+
+ c = int32(w % 4) // bytes
+ q = int32(w / 4) // doublewords
+
+ // if we are copying forward on the stack and
+ // the src and dst overlap, then reverse direction
+ if osrc < odst && int64(odst) < int64(osrc)+w {
+ // reverse direction
+ gins(i386.ASTD, nil, nil) // set direction flag
+ if c > 0 {
+ gconreg(i386.AADDL, w-1, i386.REG_SI)
+ gconreg(i386.AADDL, w-1, i386.REG_DI)
+
+ gconreg(i386.AMOVL, int64(c), i386.REG_CX)
+ gins(i386.AREP, nil, nil) // repeat
+ gins(i386.AMOVSB, nil, nil) // MOVB *(SI)-,*(DI)-
+ }
+
+ if q > 0 {
+ if c > 0 {
+ gconreg(i386.AADDL, -3, i386.REG_SI)
+ gconreg(i386.AADDL, -3, i386.REG_DI)
+ } else {
+ gconreg(i386.AADDL, w-4, i386.REG_SI)
+ gconreg(i386.AADDL, w-4, i386.REG_DI)
+ }
+
+ gconreg(i386.AMOVL, int64(q), i386.REG_CX)
+ gins(i386.AREP, nil, nil) // repeat
+ gins(i386.AMOVSL, nil, nil) // MOVL *(SI)-,*(DI)-
+ }
+
+ // we leave with the flag clear
+ gins(i386.ACLD, nil, nil)
+ } else {
+ gins(i386.ACLD, nil, nil) // paranoia. TODO(rsc): remove?
+
+ // normal direction
+ if q > 128 || (q >= 4 && gc.Nacl) {
+ gconreg(i386.AMOVL, int64(q), i386.REG_CX)
+ gins(i386.AREP, nil, nil) // repeat
+ gins(i386.AMOVSL, nil, nil) // MOVL *(SI)+,*(DI)+
+ } else if q >= 4 {
+ p = gins(obj.ADUFFCOPY, nil, nil)
+ p.To.Type = obj.TYPE_ADDR
+ p.To.Sym = gc.Linksym(gc.Pkglookup("duffcopy", gc.Runtimepkg))
+
+ // 10 and 128 = magic constants: see ../../runtime/asm_386.s
+ p.To.Offset = 10 * (128 - int64(q))
+ } else if !gc.Nacl && c == 0 {
+ gc.Nodreg(&cx, gc.Types[gc.TINT32], i386.REG_CX)
+
+ // We don't need the MOVSL side-effect of updating SI and DI,
+ // and issuing a sequence of MOVLs directly is faster.
+ src.Op = gc.OINDREG
+
+ dst.Op = gc.OINDREG
+ for q > 0 {
+ gmove(&src, &cx) // MOVL x+(SI),CX
+ gmove(&cx, &dst) // MOVL CX,x+(DI)
+ src.Xoffset += 4
+ dst.Xoffset += 4
+ q--
+ }
+ } else {
+ for q > 0 {
+ gins(i386.AMOVSL, nil, nil) // MOVL *(SI)+,*(DI)+
+ q--
+ }
+ }
+
+ for c > 0 {
+ gins(i386.AMOVSB, nil, nil) // MOVB *(SI)+,*(DI)+
+ c--
+ }
+ }
+}
+
+func cadable(n *gc.Node) int {
+ if !(n.Addable != 0) {
+ // dont know how it happens,
+ // but it does
+ return 0
+ }
+
+ switch n.Op {
+ case gc.ONAME:
+ return 1
+ }
+
+ return 0
+}
+
+/*
+ * copy a composite value by moving its individual components.
+ * Slices, strings and interfaces are supported.
+ * Small structs or arrays with elements of basic type are
+ * also supported.
+ * nr is N when assigning a zero value.
+ * return 1 if can do, 0 if can't.
+ */
+func componentgen(nr *gc.Node, nl *gc.Node) int {
+ var nodl gc.Node
+ var nodr gc.Node
+ var tmp gc.Node
+ var t *gc.Type
+ var freel int
+ var freer int
+ var fldcount int64
+ var loffset int64
+ var roffset int64
+
+ freel = 0
+ freer = 0
+
+ switch nl.Type.Etype {
+ default:
+ goto no
+
+ case gc.TARRAY:
+ t = nl.Type
+
+ // Slices are ok.
+ if gc.Isslice(t) != 0 {
+ break
+ }
+
+ // Small arrays are ok.
+ if t.Bound > 0 && t.Bound <= 3 && !(gc.Isfat(t.Type) != 0) {
+ break
+ }
+
+ goto no
+
+ // Small structs with non-fat types are ok.
+ // Zero-sized structs are treated separately elsewhere.
+ case gc.TSTRUCT:
+ fldcount = 0
+
+ for t = nl.Type.Type; t != nil; t = t.Down {
+ if gc.Isfat(t.Type) != 0 {
+ goto no
+ }
+ if t.Etype != gc.TFIELD {
+ gc.Fatal("componentgen: not a TFIELD: %v", gc.Tconv(t, obj.FmtLong))
+ }
+ fldcount++
+ }
+
+ if fldcount == 0 || fldcount > 4 {
+ goto no
+ }
+
+ case gc.TSTRING,
+ gc.TINTER:
+ break
+ }
+
+ nodl = *nl
+ if !(cadable(nl) != 0) {
+ if nr != nil && !(cadable(nr) != 0) {
+ goto no
+ }
+ igen(nl, &nodl, nil)
+ freel = 1
+ }
+
+ if nr != nil {
+ nodr = *nr
+ if !(cadable(nr) != 0) {
+ igen(nr, &nodr, nil)
+ freer = 1
+ }
+ } else {
+ // When zeroing, prepare a register containing zero.
+ gc.Nodconst(&tmp, nl.Type, 0)
+
+ regalloc(&nodr, gc.Types[gc.TUINT], nil)
+ gmove(&tmp, &nodr)
+ freer = 1
+ }
+
+ // nl and nr are 'cadable' which basically means they are names (variables) now.
+ // If they are the same variable, don't generate any code, because the
+ // VARDEF we generate will mark the old value as dead incorrectly.
+ // (And also the assignments are useless.)
+ if nr != nil && nl.Op == gc.ONAME && nr.Op == gc.ONAME && nl == nr {
+ goto yes
+ }
+
+ switch nl.Type.Etype {
+ // componentgen for arrays.
+ case gc.TARRAY:
+ if nl.Op == gc.ONAME {
+ gc.Gvardef(nl)
+ }
+ t = nl.Type
+ if !(gc.Isslice(t) != 0) {
+ nodl.Type = t.Type
+ nodr.Type = nodl.Type
+ for fldcount = 0; fldcount < t.Bound; fldcount++ {
+ if nr == nil {
+ gc.Clearslim(&nodl)
+ } else {
+ gmove(&nodr, &nodl)
+ }
+ nodl.Xoffset += t.Type.Width
+ nodr.Xoffset += t.Type.Width
+ }
+
+ goto yes
+ }
+
+ // componentgen for slices.
+ nodl.Xoffset += int64(gc.Array_array)
+
+ nodl.Type = gc.Ptrto(nl.Type.Type)
+
+ if nr != nil {
+ nodr.Xoffset += int64(gc.Array_array)
+ nodr.Type = nodl.Type
+ }
+
+ gmove(&nodr, &nodl)
+
+ nodl.Xoffset += int64(gc.Array_nel) - int64(gc.Array_array)
+ nodl.Type = gc.Types[gc.Simtype[gc.TUINT]]
+
+ if nr != nil {
+ nodr.Xoffset += int64(gc.Array_nel) - int64(gc.Array_array)
+ nodr.Type = nodl.Type
+ }
+
+ gmove(&nodr, &nodl)
+
+ nodl.Xoffset += int64(gc.Array_cap) - int64(gc.Array_nel)
+ nodl.Type = gc.Types[gc.Simtype[gc.TUINT]]
+
+ if nr != nil {
+ nodr.Xoffset += int64(gc.Array_cap) - int64(gc.Array_nel)
+ nodr.Type = nodl.Type
+ }
+
+ gmove(&nodr, &nodl)
+
+ goto yes
+
+ case gc.TSTRING:
+ if nl.Op == gc.ONAME {
+ gc.Gvardef(nl)
+ }
+ nodl.Xoffset += int64(gc.Array_array)
+ nodl.Type = gc.Ptrto(gc.Types[gc.TUINT8])
+
+ if nr != nil {
+ nodr.Xoffset += int64(gc.Array_array)
+ nodr.Type = nodl.Type
+ }
+
+ gmove(&nodr, &nodl)
+
+ nodl.Xoffset += int64(gc.Array_nel) - int64(gc.Array_array)
+ nodl.Type = gc.Types[gc.Simtype[gc.TUINT]]
+
+ if nr != nil {
+ nodr.Xoffset += int64(gc.Array_nel) - int64(gc.Array_array)
+ nodr.Type = nodl.Type
+ }
+
+ gmove(&nodr, &nodl)
+
+ goto yes
+
+ case gc.TINTER:
+ if nl.Op == gc.ONAME {
+ gc.Gvardef(nl)
+ }
+ nodl.Xoffset += int64(gc.Array_array)
+ nodl.Type = gc.Ptrto(gc.Types[gc.TUINT8])
+
+ if nr != nil {
+ nodr.Xoffset += int64(gc.Array_array)
+ nodr.Type = nodl.Type
+ }
+
+ gmove(&nodr, &nodl)
+
+ nodl.Xoffset += int64(gc.Array_nel) - int64(gc.Array_array)
+ nodl.Type = gc.Ptrto(gc.Types[gc.TUINT8])
+
+ if nr != nil {
+ nodr.Xoffset += int64(gc.Array_nel) - int64(gc.Array_array)
+ nodr.Type = nodl.Type
+ }
+
+ gmove(&nodr, &nodl)
+
+ goto yes
+
+ case gc.TSTRUCT:
+ if nl.Op == gc.ONAME {
+ gc.Gvardef(nl)
+ }
+ loffset = nodl.Xoffset
+ roffset = nodr.Xoffset
+
+ // funarg structs may not begin at offset zero.
+ if nl.Type.Etype == gc.TSTRUCT && nl.Type.Funarg != 0 && nl.Type.Type != nil {
+ loffset -= nl.Type.Type.Width
+ }
+ if nr != nil && nr.Type.Etype == gc.TSTRUCT && nr.Type.Funarg != 0 && nr.Type.Type != nil {
+ roffset -= nr.Type.Type.Width
+ }
+
+ for t = nl.Type.Type; t != nil; t = t.Down {
+ nodl.Xoffset = loffset + t.Width
+ nodl.Type = t.Type
+
+ if nr == nil {
+ gc.Clearslim(&nodl)
+ } else {
+ nodr.Xoffset = roffset + t.Width
+ nodr.Type = nodl.Type
+ gmove(&nodr, &nodl)
+ }
+ }
+
+ goto yes
+ }
+
+no:
+ if freer != 0 {
+ regfree(&nodr)
+ }
+ if freel != 0 {
+ regfree(&nodl)
+ }
+ return 0
+
+yes:
+ if freer != 0 {
+ regfree(&nodr)
+ }
+ if freel != 0 {
+ regfree(&nodl)
+ }
+ return 1
+}
--- /dev/null
+// 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 main
+
+import (
+ "cmd/internal/obj"
+ "cmd/internal/obj/i386"
+)
+import "cmd/internal/gc"
+
+/*
+ * attempt to generate 64-bit
+ * res = n
+ * return 1 on success, 0 if op not handled.
+ */
+func cgen64(n *gc.Node, res *gc.Node) {
+ var t1 gc.Node
+ var t2 gc.Node
+ var ax gc.Node
+ var dx gc.Node
+ var cx gc.Node
+ var ex gc.Node
+ var fx gc.Node
+ var l *gc.Node
+ var r *gc.Node
+ var lo1 gc.Node
+ var lo2 gc.Node
+ var hi1 gc.Node
+ var hi2 gc.Node
+ var p1 *obj.Prog
+ var p2 *obj.Prog
+ var v uint64
+ var lv uint32
+ var hv uint32
+
+ if res.Op != gc.OINDREG && res.Op != gc.ONAME {
+ gc.Dump("n", n)
+ gc.Dump("res", res)
+ gc.Fatal("cgen64 %v of %v", gc.Oconv(int(n.Op), 0), gc.Oconv(int(res.Op), 0))
+ }
+
+ switch n.Op {
+ default:
+ gc.Fatal("cgen64 %v", gc.Oconv(int(n.Op), 0))
+ fallthrough
+
+ case gc.OMINUS:
+ cgen(n.Left, res)
+ split64(res, &lo1, &hi1)
+ gins(i386.ANEGL, nil, &lo1)
+ gins(i386.AADCL, ncon(0), &hi1)
+ gins(i386.ANEGL, nil, &hi1)
+ splitclean()
+ return
+
+ case gc.OCOM:
+ cgen(n.Left, res)
+ split64(res, &lo1, &hi1)
+ gins(i386.ANOTL, nil, &lo1)
+ gins(i386.ANOTL, nil, &hi1)
+ splitclean()
+ return
+
+ // binary operators.
+ // common setup below.
+ case gc.OADD,
+ gc.OSUB,
+ gc.OMUL,
+ gc.OLROT,
+ gc.OLSH,
+ gc.ORSH,
+ gc.OAND,
+ gc.OOR,
+ gc.OXOR:
+ break
+ }
+
+ l = n.Left
+ r = n.Right
+ if !(l.Addable != 0) {
+ gc.Tempname(&t1, l.Type)
+ cgen(l, &t1)
+ l = &t1
+ }
+
+ if r != nil && !(r.Addable != 0) {
+ gc.Tempname(&t2, r.Type)
+ cgen(r, &t2)
+ r = &t2
+ }
+
+ gc.Nodreg(&ax, gc.Types[gc.TINT32], i386.REG_AX)
+ gc.Nodreg(&cx, gc.Types[gc.TINT32], i386.REG_CX)
+ gc.Nodreg(&dx, gc.Types[gc.TINT32], i386.REG_DX)
+
+ // Setup for binary operation.
+ split64(l, &lo1, &hi1)
+
+ if gc.Is64(r.Type) != 0 {
+ split64(r, &lo2, &hi2)
+ }
+
+ // Do op. Leave result in DX:AX.
+ switch n.Op {
+ // TODO: Constants
+ case gc.OADD:
+ gins(i386.AMOVL, &lo1, &ax)
+
+ gins(i386.AMOVL, &hi1, &dx)
+ gins(i386.AADDL, &lo2, &ax)
+ gins(i386.AADCL, &hi2, &dx)
+
+ // TODO: Constants.
+ case gc.OSUB:
+ gins(i386.AMOVL, &lo1, &ax)
+
+ gins(i386.AMOVL, &hi1, &dx)
+ gins(i386.ASUBL, &lo2, &ax)
+ gins(i386.ASBBL, &hi2, &dx)
+
+ // let's call the next two EX and FX.
+ case gc.OMUL:
+ regalloc(&ex, gc.Types[gc.TPTR32], nil)
+
+ regalloc(&fx, gc.Types[gc.TPTR32], nil)
+
+ // load args into DX:AX and EX:CX.
+ gins(i386.AMOVL, &lo1, &ax)
+
+ gins(i386.AMOVL, &hi1, &dx)
+ gins(i386.AMOVL, &lo2, &cx)
+ gins(i386.AMOVL, &hi2, &ex)
+
+ // if DX and EX are zero, use 32 x 32 -> 64 unsigned multiply.
+ gins(i386.AMOVL, &dx, &fx)
+
+ gins(i386.AORL, &ex, &fx)
+ p1 = gc.Gbranch(i386.AJNE, nil, 0)
+ gins(i386.AMULL, &cx, nil) // implicit &ax
+ p2 = gc.Gbranch(obj.AJMP, nil, 0)
+ gc.Patch(p1, gc.Pc)
+
+ // full 64x64 -> 64, from 32x32 -> 64.
+ gins(i386.AIMULL, &cx, &dx)
+
+ gins(i386.AMOVL, &ax, &fx)
+ gins(i386.AIMULL, &ex, &fx)
+ gins(i386.AADDL, &dx, &fx)
+ gins(i386.AMOVL, &cx, &dx)
+ gins(i386.AMULL, &dx, nil) // implicit &ax
+ gins(i386.AADDL, &fx, &dx)
+ gc.Patch(p2, gc.Pc)
+
+ regfree(&ex)
+ regfree(&fx)
+
+ // We only rotate by a constant c in [0,64).
+ // if c >= 32:
+ // lo, hi = hi, lo
+ // c -= 32
+ // if c == 0:
+ // no-op
+ // else:
+ // t = hi
+ // shld hi:lo, c
+ // shld lo:t, c
+ case gc.OLROT:
+ v = uint64(gc.Mpgetfix(r.Val.U.Xval))
+
+ if v >= 32 {
+ // reverse during load to do the first 32 bits of rotate
+ v -= 32
+
+ gins(i386.AMOVL, &lo1, &dx)
+ gins(i386.AMOVL, &hi1, &ax)
+ } else {
+ gins(i386.AMOVL, &lo1, &ax)
+ gins(i386.AMOVL, &hi1, &dx)
+ }
+
+ if v == 0 {
+ } else // done
+ {
+ gins(i386.AMOVL, &dx, &cx)
+ p1 = gins(i386.ASHLL, ncon(uint32(v)), &dx)
+ p1.From.Index = i386.REG_AX // double-width shift
+ p1.From.Scale = 0
+ p1 = gins(i386.ASHLL, ncon(uint32(v)), &ax)
+ p1.From.Index = i386.REG_CX // double-width shift
+ p1.From.Scale = 0
+ }
+
+ case gc.OLSH:
+ if r.Op == gc.OLITERAL {
+ v = uint64(gc.Mpgetfix(r.Val.U.Xval))
+ if v >= 64 {
+ if gc.Is64(r.Type) != 0 {
+ splitclean()
+ }
+ splitclean()
+ split64(res, &lo2, &hi2)
+ gins(i386.AMOVL, ncon(0), &lo2)
+ gins(i386.AMOVL, ncon(0), &hi2)
+ splitclean()
+ goto out
+ }
+
+ if v >= 32 {
+ if gc.Is64(r.Type) != 0 {
+ splitclean()
+ }
+ split64(res, &lo2, &hi2)
+ gmove(&lo1, &hi2)
+ if v > 32 {
+ gins(i386.ASHLL, ncon(uint32(v-32)), &hi2)
+ }
+
+ gins(i386.AMOVL, ncon(0), &lo2)
+ splitclean()
+ splitclean()
+ goto out
+ }
+
+ // general shift
+ gins(i386.AMOVL, &lo1, &ax)
+
+ gins(i386.AMOVL, &hi1, &dx)
+ p1 = gins(i386.ASHLL, ncon(uint32(v)), &dx)
+ p1.From.Index = i386.REG_AX // double-width shift
+ p1.From.Scale = 0
+ gins(i386.ASHLL, ncon(uint32(v)), &ax)
+ break
+ }
+
+ // load value into DX:AX.
+ gins(i386.AMOVL, &lo1, &ax)
+
+ gins(i386.AMOVL, &hi1, &dx)
+
+ // load shift value into register.
+ // if high bits are set, zero value.
+ p1 = nil
+
+ if gc.Is64(r.Type) != 0 {
+ gins(i386.ACMPL, &hi2, ncon(0))
+ p1 = gc.Gbranch(i386.AJNE, nil, +1)
+ gins(i386.AMOVL, &lo2, &cx)
+ } else {
+ cx.Type = gc.Types[gc.TUINT32]
+ gmove(r, &cx)
+ }
+
+ // if shift count is >=64, zero value
+ gins(i386.ACMPL, &cx, ncon(64))
+
+ p2 = gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TUINT32]), nil, +1)
+ if p1 != nil {
+ gc.Patch(p1, gc.Pc)
+ }
+ gins(i386.AXORL, &dx, &dx)
+ gins(i386.AXORL, &ax, &ax)
+ gc.Patch(p2, gc.Pc)
+
+ // if shift count is >= 32, zero low.
+ gins(i386.ACMPL, &cx, ncon(32))
+
+ p1 = gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TUINT32]), nil, +1)
+ gins(i386.AMOVL, &ax, &dx)
+ gins(i386.ASHLL, &cx, &dx) // SHLL only uses bottom 5 bits of count
+ gins(i386.AXORL, &ax, &ax)
+ p2 = gc.Gbranch(obj.AJMP, nil, 0)
+ gc.Patch(p1, gc.Pc)
+
+ // general shift
+ p1 = gins(i386.ASHLL, &cx, &dx)
+
+ p1.From.Index = i386.REG_AX // double-width shift
+ p1.From.Scale = 0
+ gins(i386.ASHLL, &cx, &ax)
+ gc.Patch(p2, gc.Pc)
+
+ case gc.ORSH:
+ if r.Op == gc.OLITERAL {
+ v = uint64(gc.Mpgetfix(r.Val.U.Xval))
+ if v >= 64 {
+ if gc.Is64(r.Type) != 0 {
+ splitclean()
+ }
+ splitclean()
+ split64(res, &lo2, &hi2)
+ if hi1.Type.Etype == gc.TINT32 {
+ gmove(&hi1, &lo2)
+ gins(i386.ASARL, ncon(31), &lo2)
+ gmove(&hi1, &hi2)
+ gins(i386.ASARL, ncon(31), &hi2)
+ } else {
+ gins(i386.AMOVL, ncon(0), &lo2)
+ gins(i386.AMOVL, ncon(0), &hi2)
+ }
+
+ splitclean()
+ goto out
+ }
+
+ if v >= 32 {
+ if gc.Is64(r.Type) != 0 {
+ splitclean()
+ }
+ split64(res, &lo2, &hi2)
+ gmove(&hi1, &lo2)
+ if v > 32 {
+ gins(optoas(gc.ORSH, hi1.Type), ncon(uint32(v-32)), &lo2)
+ }
+ if hi1.Type.Etype == gc.TINT32 {
+ gmove(&hi1, &hi2)
+ gins(i386.ASARL, ncon(31), &hi2)
+ } else {
+ gins(i386.AMOVL, ncon(0), &hi2)
+ }
+ splitclean()
+ splitclean()
+ goto out
+ }
+
+ // general shift
+ gins(i386.AMOVL, &lo1, &ax)
+
+ gins(i386.AMOVL, &hi1, &dx)
+ p1 = gins(i386.ASHRL, ncon(uint32(v)), &ax)
+ p1.From.Index = i386.REG_DX // double-width shift
+ p1.From.Scale = 0
+ gins(optoas(gc.ORSH, hi1.Type), ncon(uint32(v)), &dx)
+ break
+ }
+
+ // load value into DX:AX.
+ gins(i386.AMOVL, &lo1, &ax)
+
+ gins(i386.AMOVL, &hi1, &dx)
+
+ // load shift value into register.
+ // if high bits are set, zero value.
+ p1 = nil
+
+ if gc.Is64(r.Type) != 0 {
+ gins(i386.ACMPL, &hi2, ncon(0))
+ p1 = gc.Gbranch(i386.AJNE, nil, +1)
+ gins(i386.AMOVL, &lo2, &cx)
+ } else {
+ cx.Type = gc.Types[gc.TUINT32]
+ gmove(r, &cx)
+ }
+
+ // if shift count is >=64, zero or sign-extend value
+ gins(i386.ACMPL, &cx, ncon(64))
+
+ p2 = gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TUINT32]), nil, +1)
+ if p1 != nil {
+ gc.Patch(p1, gc.Pc)
+ }
+ if hi1.Type.Etype == gc.TINT32 {
+ gins(i386.ASARL, ncon(31), &dx)
+ gins(i386.AMOVL, &dx, &ax)
+ } else {
+ gins(i386.AXORL, &dx, &dx)
+ gins(i386.AXORL, &ax, &ax)
+ }
+
+ gc.Patch(p2, gc.Pc)
+
+ // if shift count is >= 32, sign-extend hi.
+ gins(i386.ACMPL, &cx, ncon(32))
+
+ p1 = gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TUINT32]), nil, +1)
+ gins(i386.AMOVL, &dx, &ax)
+ if hi1.Type.Etype == gc.TINT32 {
+ gins(i386.ASARL, &cx, &ax) // SARL only uses bottom 5 bits of count
+ gins(i386.ASARL, ncon(31), &dx)
+ } else {
+ gins(i386.ASHRL, &cx, &ax)
+ gins(i386.AXORL, &dx, &dx)
+ }
+
+ p2 = gc.Gbranch(obj.AJMP, nil, 0)
+ gc.Patch(p1, gc.Pc)
+
+ // general shift
+ p1 = gins(i386.ASHRL, &cx, &ax)
+
+ p1.From.Index = i386.REG_DX // double-width shift
+ p1.From.Scale = 0
+ gins(optoas(gc.ORSH, hi1.Type), &cx, &dx)
+ gc.Patch(p2, gc.Pc)
+
+ // make constant the right side (it usually is anyway).
+ case gc.OXOR,
+ gc.OAND,
+ gc.OOR:
+ if lo1.Op == gc.OLITERAL {
+ nswap(&lo1, &lo2)
+ nswap(&hi1, &hi2)
+ }
+
+ if lo2.Op == gc.OLITERAL {
+ // special cases for constants.
+ lv = uint32(gc.Mpgetfix(lo2.Val.U.Xval))
+
+ hv = uint32(gc.Mpgetfix(hi2.Val.U.Xval))
+ splitclean() // right side
+ split64(res, &lo2, &hi2)
+ switch n.Op {
+ case gc.OXOR:
+ gmove(&lo1, &lo2)
+ gmove(&hi1, &hi2)
+ switch lv {
+ case 0:
+ break
+
+ case 0xffffffff:
+ gins(i386.ANOTL, nil, &lo2)
+
+ default:
+ gins(i386.AXORL, ncon(lv), &lo2)
+ }
+
+ switch hv {
+ case 0:
+ break
+
+ case 0xffffffff:
+ gins(i386.ANOTL, nil, &hi2)
+
+ default:
+ gins(i386.AXORL, ncon(hv), &hi2)
+ }
+
+ case gc.OAND:
+ switch lv {
+ case 0:
+ gins(i386.AMOVL, ncon(0), &lo2)
+
+ default:
+ gmove(&lo1, &lo2)
+ if lv != 0xffffffff {
+ gins(i386.AANDL, ncon(lv), &lo2)
+ }
+ }
+
+ switch hv {
+ case 0:
+ gins(i386.AMOVL, ncon(0), &hi2)
+
+ default:
+ gmove(&hi1, &hi2)
+ if hv != 0xffffffff {
+ gins(i386.AANDL, ncon(hv), &hi2)
+ }
+ }
+
+ case gc.OOR:
+ switch lv {
+ case 0:
+ gmove(&lo1, &lo2)
+
+ case 0xffffffff:
+ gins(i386.AMOVL, ncon(0xffffffff), &lo2)
+
+ default:
+ gmove(&lo1, &lo2)
+ gins(i386.AORL, ncon(lv), &lo2)
+ }
+
+ switch hv {
+ case 0:
+ gmove(&hi1, &hi2)
+
+ case 0xffffffff:
+ gins(i386.AMOVL, ncon(0xffffffff), &hi2)
+
+ default:
+ gmove(&hi1, &hi2)
+ gins(i386.AORL, ncon(hv), &hi2)
+ }
+ }
+
+ splitclean()
+ splitclean()
+ goto out
+ }
+
+ gins(i386.AMOVL, &lo1, &ax)
+ gins(i386.AMOVL, &hi1, &dx)
+ gins(optoas(int(n.Op), lo1.Type), &lo2, &ax)
+ gins(optoas(int(n.Op), lo1.Type), &hi2, &dx)
+ }
+
+ if gc.Is64(r.Type) != 0 {
+ splitclean()
+ }
+ splitclean()
+
+ split64(res, &lo1, &hi1)
+ gins(i386.AMOVL, &ax, &lo1)
+ gins(i386.AMOVL, &dx, &hi1)
+ splitclean()
+
+out:
+}
+
+/*
+ * generate comparison of nl, nr, both 64-bit.
+ * nl is memory; nr is constant or memory.
+ */
+func cmp64(nl *gc.Node, nr *gc.Node, op int, likely int, to *obj.Prog) {
+ var lo1 gc.Node
+ var hi1 gc.Node
+ var lo2 gc.Node
+ var hi2 gc.Node
+ var rr gc.Node
+ var br *obj.Prog
+ var t *gc.Type
+
+ split64(nl, &lo1, &hi1)
+ split64(nr, &lo2, &hi2)
+
+ // compare most significant word;
+ // if they differ, we're done.
+ t = hi1.Type
+
+ if nl.Op == gc.OLITERAL || nr.Op == gc.OLITERAL {
+ gins(i386.ACMPL, &hi1, &hi2)
+ } else {
+ regalloc(&rr, gc.Types[gc.TINT32], nil)
+ gins(i386.AMOVL, &hi1, &rr)
+ gins(i386.ACMPL, &rr, &hi2)
+ regfree(&rr)
+ }
+
+ br = nil
+ switch op {
+ default:
+ gc.Fatal("cmp64 %v %v", gc.Oconv(int(op), 0), gc.Tconv(t, 0))
+ fallthrough
+
+ // cmp hi
+ // jne L
+ // cmp lo
+ // jeq to
+ // L:
+ case gc.OEQ:
+ br = gc.Gbranch(i386.AJNE, nil, -likely)
+
+ // cmp hi
+ // jne to
+ // cmp lo
+ // jne to
+ case gc.ONE:
+ gc.Patch(gc.Gbranch(i386.AJNE, nil, likely), to)
+
+ // cmp hi
+ // jgt to
+ // jlt L
+ // cmp lo
+ // jge to (or jgt to)
+ // L:
+ case gc.OGE,
+ gc.OGT:
+ gc.Patch(gc.Gbranch(optoas(gc.OGT, t), nil, likely), to)
+
+ br = gc.Gbranch(optoas(gc.OLT, t), nil, -likely)
+
+ // cmp hi
+ // jlt to
+ // jgt L
+ // cmp lo
+ // jle to (or jlt to)
+ // L:
+ case gc.OLE,
+ gc.OLT:
+ gc.Patch(gc.Gbranch(optoas(gc.OLT, t), nil, likely), to)
+
+ br = gc.Gbranch(optoas(gc.OGT, t), nil, -likely)
+ }
+
+ // compare least significant word
+ t = lo1.Type
+
+ if nl.Op == gc.OLITERAL || nr.Op == gc.OLITERAL {
+ gins(i386.ACMPL, &lo1, &lo2)
+ } else {
+ regalloc(&rr, gc.Types[gc.TINT32], nil)
+ gins(i386.AMOVL, &lo1, &rr)
+ gins(i386.ACMPL, &rr, &lo2)
+ regfree(&rr)
+ }
+
+ // jump again
+ gc.Patch(gc.Gbranch(optoas(op, t), nil, likely), to)
+
+ // point first branch down here if appropriate
+ if br != nil {
+ gc.Patch(br, gc.Pc)
+ }
+
+ splitclean()
+ splitclean()
+}
--- /dev/null
+// 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 main
+
+import (
+ "cmd/internal/obj"
+ "cmd/internal/obj/i386"
+)
+import "cmd/internal/gc"
+
+var thechar int = '8'
+
+var thestring string = "386"
+
+var thelinkarch *obj.LinkArch = &i386.Link386
+
+func linkarchinit() {
+}
+
+var MAXWIDTH int64 = (1 << 32) - 1
+
+/*
+ * go declares several platform-specific type aliases:
+ * int, uint, float, and uintptr
+ */
+var typedefs = []gc.Typedef{
+ gc.Typedef{"int", gc.TINT, gc.TINT32},
+ gc.Typedef{"uint", gc.TUINT, gc.TUINT32},
+ gc.Typedef{"uintptr", gc.TUINTPTR, gc.TUINT32},
+}
+
+func betypeinit() {
+ gc.Widthptr = 4
+ gc.Widthint = 4
+ gc.Widthreg = 4
+
+}
+
+func main() {
+ gc.Thearch.Thechar = thechar
+ gc.Thearch.Thestring = thestring
+ gc.Thearch.Thelinkarch = thelinkarch
+ gc.Thearch.Typedefs = typedefs
+ gc.Thearch.REGSP = i386.REGSP
+ gc.Thearch.REGCTXT = i386.REGCTXT
+ gc.Thearch.MAXWIDTH = MAXWIDTH
+ gc.Thearch.Anyregalloc = anyregalloc
+ gc.Thearch.Betypeinit = betypeinit
+ gc.Thearch.Bgen = bgen
+ gc.Thearch.Cgen = cgen
+ gc.Thearch.Cgen_call = cgen_call
+ gc.Thearch.Cgen_callinter = cgen_callinter
+ gc.Thearch.Cgen_ret = cgen_ret
+ gc.Thearch.Clearfat = clearfat
+ gc.Thearch.Defframe = defframe
+ gc.Thearch.Excise = excise
+ gc.Thearch.Expandchecks = expandchecks
+ gc.Thearch.Gclean = gclean
+ gc.Thearch.Ginit = ginit
+ gc.Thearch.Gins = gins
+ gc.Thearch.Ginscall = ginscall
+ gc.Thearch.Igen = igen
+ gc.Thearch.Linkarchinit = linkarchinit
+ gc.Thearch.Peep = peep
+ gc.Thearch.Proginfo = proginfo
+ gc.Thearch.Regalloc = regalloc
+ gc.Thearch.Regfree = regfree
+ gc.Thearch.Regtyp = regtyp
+ gc.Thearch.Sameaddr = sameaddr
+ gc.Thearch.Smallindir = smallindir
+ gc.Thearch.Stackaddr = stackaddr
+ gc.Thearch.Excludedregs = excludedregs
+ gc.Thearch.RtoB = RtoB
+ gc.Thearch.FtoB = FtoB
+ gc.Thearch.BtoR = BtoR
+ gc.Thearch.BtoF = BtoF
+ gc.Thearch.Optoas = optoas
+ gc.Thearch.Doregbits = doregbits
+ gc.Thearch.Regnames = regnames
+
+ gc.Main()
+}
--- /dev/null
+// 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 main
+
+import "cmd/internal/obj/i386"
+import "cmd/internal/gc"
+
+// TODO(rsc):
+// assume CLD?
+
+// 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.
+
+// foptoas flags
+const (
+ Frev = 1 << 0
+ Fpop = 1 << 1
+ Fpop2 = 1 << 2
+)
+
+var reg [i386.MAXREG]uint8
+
+var panicdiv *gc.Node
+
+/*
+ * cgen.c
+ */
+
+/*
+ * list.c
+ */
--- /dev/null
+// 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 main
+
+import (
+ "cmd/internal/obj"
+ "cmd/internal/obj/i386"
+)
+import "cmd/internal/gc"
+
+func defframe(ptxt *obj.Prog) {
+ var frame uint32
+ var ax uint32
+ var p *obj.Prog
+ var lo int64
+ var hi int64
+ var l *gc.NodeList
+ var n *gc.Node
+
+ // fill in argument size, stack size
+ ptxt.To.Type = obj.TYPE_TEXTSIZE
+
+ ptxt.To.U.Argsize = int32(gc.Rnd(gc.Curfn.Type.Argwid, int64(gc.Widthptr)))
+ frame = uint32(gc.Rnd(gc.Stksize+gc.Maxarg, int64(gc.Widthreg)))
+ ptxt.To.Offset = int64(frame)
+
+ // insert code to zero ambiguously live variables
+ // so that the garbage collector only sees initialized values
+ // when it looks for pointers.
+ p = ptxt
+
+ hi = 0
+ lo = hi
+ ax = 0
+ for l = gc.Curfn.Dcl; l != nil; l = l.Next {
+ n = l.N
+ if !(n.Needzero != 0) {
+ continue
+ }
+ if n.Class != gc.PAUTO {
+ gc.Fatal("needzero class %d", n.Class)
+ }
+ if n.Type.Width%int64(gc.Widthptr) != 0 || n.Xoffset%int64(gc.Widthptr) != 0 || n.Type.Width == 0 {
+ gc.Fatal("var %v has size %d offset %d", gc.Nconv(n, obj.FmtLong), int(n.Type.Width), int(n.Xoffset))
+ }
+ if lo != hi && n.Xoffset+n.Type.Width == lo-int64(2*gc.Widthptr) {
+ // merge with range we already have
+ lo = n.Xoffset
+
+ continue
+ }
+
+ // zero old range
+ p = zerorange(p, int64(frame), lo, hi, &ax)
+
+ // set new range
+ hi = n.Xoffset + n.Type.Width
+
+ lo = n.Xoffset
+ }
+
+ // zero final range
+ zerorange(p, int64(frame), lo, hi, &ax)
+}
+
+func zerorange(p *obj.Prog, frame int64, lo int64, hi int64, ax *uint32) *obj.Prog {
+ var cnt int64
+ var i int64
+
+ cnt = hi - lo
+ if cnt == 0 {
+ return p
+ }
+ if *ax == 0 {
+ p = appendpp(p, i386.AMOVL, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, i386.REG_AX, 0)
+ *ax = 1
+ }
+
+ if cnt <= int64(4*gc.Widthreg) {
+ for i = 0; i < cnt; i += int64(gc.Widthreg) {
+ p = appendpp(p, i386.AMOVL, obj.TYPE_REG, i386.REG_AX, 0, obj.TYPE_MEM, i386.REG_SP, frame+lo+i)
+ }
+ } else if !gc.Nacl && cnt <= int64(128*gc.Widthreg) {
+ p = appendpp(p, i386.ALEAL, obj.TYPE_MEM, i386.REG_SP, frame+lo, obj.TYPE_REG, i386.REG_DI, 0)
+ p = appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_ADDR, 0, 1*(128-cnt/int64(gc.Widthreg)))
+ p.To.Sym = gc.Linksym(gc.Pkglookup("duffzero", gc.Runtimepkg))
+ } else {
+ p = appendpp(p, i386.AMOVL, obj.TYPE_CONST, 0, cnt/int64(gc.Widthreg), obj.TYPE_REG, i386.REG_CX, 0)
+ p = appendpp(p, i386.ALEAL, obj.TYPE_MEM, i386.REG_SP, frame+lo, obj.TYPE_REG, i386.REG_DI, 0)
+ p = appendpp(p, i386.AREP, obj.TYPE_NONE, 0, 0, obj.TYPE_NONE, 0, 0)
+ p = appendpp(p, i386.ASTOSL, obj.TYPE_NONE, 0, 0, obj.TYPE_NONE, 0, 0)
+ }
+
+ return p
+}
+
+func appendpp(p *obj.Prog, as int, ftype int, freg int, foffset int64, ttype int, treg int, toffset int64) *obj.Prog {
+ var q *obj.Prog
+ q = gc.Ctxt.NewProg()
+ gc.Clearp(q)
+ q.As = int16(as)
+ q.Lineno = p.Lineno
+ q.From.Type = int16(ftype)
+ q.From.Reg = int16(freg)
+ q.From.Offset = foffset
+ q.To.Type = int16(ttype)
+ q.To.Reg = int16(treg)
+ q.To.Offset = toffset
+ q.Link = p.Link
+ p.Link = q
+ return q
+}
+
+func clearfat(nl *gc.Node) {
+ var w uint32
+ var c uint32
+ var q uint32
+ var n1 gc.Node
+ var z gc.Node
+ var p *obj.Prog
+
+ /* clear a fat object */
+ if gc.Debug['g'] != 0 {
+ gc.Dump("\nclearfat", nl)
+ }
+
+ w = uint32(nl.Type.Width)
+
+ // Avoid taking the address for simple enough types.
+ if componentgen(nil, nl) != 0 {
+ return
+ }
+
+ c = w % 4 // bytes
+ q = w / 4 // quads
+
+ if q < 4 {
+ // Write sequence of MOV 0, off(base) instead of using STOSL.
+ // The hope is that although the code will be slightly longer,
+ // the MOVs will have no dependencies and pipeline better
+ // than the unrolled STOSL loop.
+ // NOTE: Must use agen, not igen, so that optimizer sees address
+ // being taken. We are not writing on field boundaries.
+ regalloc(&n1, gc.Types[gc.Tptr], nil)
+
+ agen(nl, &n1)
+ n1.Op = gc.OINDREG
+ gc.Nodconst(&z, gc.Types[gc.TUINT64], 0)
+ for {
+ tmp14 := q
+ q--
+ if !(tmp14 > 0) {
+ break
+ }
+ n1.Type = z.Type
+ gins(i386.AMOVL, &z, &n1)
+ n1.Xoffset += 4
+ }
+
+ gc.Nodconst(&z, gc.Types[gc.TUINT8], 0)
+ for {
+ tmp15 := c
+ c--
+ if !(tmp15 > 0) {
+ break
+ }
+ n1.Type = z.Type
+ gins(i386.AMOVB, &z, &n1)
+ n1.Xoffset++
+ }
+
+ regfree(&n1)
+ return
+ }
+
+ gc.Nodreg(&n1, gc.Types[gc.Tptr], i386.REG_DI)
+ agen(nl, &n1)
+ gconreg(i386.AMOVL, 0, i386.REG_AX)
+
+ if q > 128 || (q >= 4 && gc.Nacl) {
+ gconreg(i386.AMOVL, int64(q), i386.REG_CX)
+ gins(i386.AREP, nil, nil) // repeat
+ gins(i386.ASTOSL, nil, nil) // STOL AL,*(DI)+
+ } else if q >= 4 {
+ p = gins(obj.ADUFFZERO, nil, nil)
+ p.To.Type = obj.TYPE_ADDR
+ p.To.Sym = gc.Linksym(gc.Pkglookup("duffzero", gc.Runtimepkg))
+
+ // 1 and 128 = magic constants: see ../../runtime/asm_386.s
+ p.To.Offset = 1 * (128 - int64(q))
+ } else {
+ for q > 0 {
+ gins(i386.ASTOSL, nil, nil) // STOL AL,*(DI)+
+ q--
+ }
+ }
+
+ for c > 0 {
+ gins(i386.ASTOSB, nil, nil) // STOB AL,*(DI)+
+ c--
+ }
+}
+
+/*
+ * generate:
+ * call f
+ * proc=-1 normal call but no return
+ * proc=0 normal call
+ * proc=1 goroutine run in new proc
+ * proc=2 defer call save away stack
+ * proc=3 normal call to C pointer (not Go func value)
+*/
+func ginscall(f *gc.Node, proc int) {
+ var p *obj.Prog
+ var reg gc.Node
+ var r1 gc.Node
+ var con gc.Node
+ var stk gc.Node
+ var extra int32
+
+ if f.Type != nil {
+ extra = 0
+ if proc == 1 || proc == 2 {
+ extra = 2 * int32(gc.Widthptr)
+ }
+ gc.Setmaxarg(f.Type, extra)
+ }
+
+ switch proc {
+ default:
+ gc.Fatal("ginscall: bad proc %d", proc)
+
+ case 0, // normal call
+ -1: // normal call but no return
+ if f.Op == gc.ONAME && f.Class == gc.PFUNC {
+ if f == gc.Deferreturn {
+ // Deferred calls will appear to be returning to
+ // the CALL deferreturn(SB) that we are about to emit.
+ // However, the stack trace code will show the line
+ // of the instruction byte before the return PC.
+ // To avoid that being an unrelated instruction,
+ // insert an x86 NOP that we will have the right line number.
+ // x86 NOP 0x90 is really XCHG AX, AX; use that description
+ // because the NOP pseudo-instruction will be removed by
+ // the linker.
+ gc.Nodreg(®, gc.Types[gc.TINT], i386.REG_AX)
+
+ gins(i386.AXCHGL, ®, ®)
+ }
+
+ p = gins(obj.ACALL, nil, f)
+ gc.Afunclit(&p.To, f)
+ if proc == -1 || gc.Noreturn(p) != 0 {
+ gins(obj.AUNDEF, nil, nil)
+ }
+ break
+ }
+
+ gc.Nodreg(®, gc.Types[gc.Tptr], i386.REG_DX)
+ gc.Nodreg(&r1, gc.Types[gc.Tptr], i386.REG_BX)
+ gmove(f, ®)
+ reg.Op = gc.OINDREG
+ gmove(®, &r1)
+ reg.Op = gc.OREGISTER
+ gins(obj.ACALL, ®, &r1)
+
+ case 3: // normal call of c function pointer
+ gins(obj.ACALL, nil, f)
+
+ case 1, // call in new proc (go)
+ 2: // deferred call (defer)
+ stk = gc.Node{}
+
+ stk.Op = gc.OINDREG
+ stk.Val.U.Reg = i386.REG_SP
+ stk.Xoffset = 0
+
+ // size of arguments at 0(SP)
+ gc.Nodconst(&con, gc.Types[gc.TINT32], int64(gc.Argsize(f.Type)))
+
+ gins(i386.AMOVL, &con, &stk)
+
+ // FuncVal* at 4(SP)
+ stk.Xoffset = int64(gc.Widthptr)
+
+ gins(i386.AMOVL, f, &stk)
+
+ if proc == 1 {
+ ginscall(gc.Newproc, 0)
+ } else {
+ ginscall(gc.Deferproc, 0)
+ }
+ if proc == 2 {
+ gc.Nodreg(®, gc.Types[gc.TINT32], i386.REG_AX)
+ gins(i386.ATESTL, ®, ®)
+ p = gc.Gbranch(i386.AJEQ, nil, +1)
+ cgen_ret(nil)
+ gc.Patch(p, gc.Pc)
+ }
+ }
+}
+
+/*
+ * n is call to interface method.
+ * generate res = n.
+ */
+func cgen_callinter(n *gc.Node, res *gc.Node, proc int) {
+ var i *gc.Node
+ var f *gc.Node
+ var tmpi gc.Node
+ var nodi gc.Node
+ var nodo gc.Node
+ var nodr gc.Node
+ var nodsp gc.Node
+
+ i = n.Left
+ if i.Op != gc.ODOTINTER {
+ gc.Fatal("cgen_callinter: not ODOTINTER %v", gc.Oconv(int(i.Op), 0))
+ }
+
+ f = i.Right // field
+ if f.Op != gc.ONAME {
+ gc.Fatal("cgen_callinter: not ONAME %v", gc.Oconv(int(f.Op), 0))
+ }
+
+ i = i.Left // interface
+
+ if !(i.Addable != 0) {
+ gc.Tempname(&tmpi, i.Type)
+ cgen(i, &tmpi)
+ i = &tmpi
+ }
+
+ gc.Genlist(n.List) // assign the args
+
+ // i is now addable, prepare an indirected
+ // register to hold its address.
+ igen(i, &nodi, res) // REG = &inter
+
+ gc.Nodindreg(&nodsp, gc.Types[gc.Tptr], i386.REG_SP)
+
+ nodsp.Xoffset = 0
+ if proc != 0 {
+ nodsp.Xoffset += 2 * int64(gc.Widthptr) // leave room for size & fn
+ }
+ nodi.Type = gc.Types[gc.Tptr]
+ nodi.Xoffset += int64(gc.Widthptr)
+ cgen(&nodi, &nodsp) // {0 or 8}(SP) = 4(REG) -- i.data
+
+ regalloc(&nodo, gc.Types[gc.Tptr], res)
+
+ nodi.Type = gc.Types[gc.Tptr]
+ nodi.Xoffset -= int64(gc.Widthptr)
+ cgen(&nodi, &nodo) // REG = 0(REG) -- i.tab
+ regfree(&nodi)
+
+ regalloc(&nodr, gc.Types[gc.Tptr], &nodo)
+ if n.Left.Xoffset == gc.BADWIDTH {
+ gc.Fatal("cgen_callinter: badwidth")
+ }
+ gc.Cgen_checknil(&nodo)
+ nodo.Op = gc.OINDREG
+ nodo.Xoffset = n.Left.Xoffset + 3*int64(gc.Widthptr) + 8
+
+ if proc == 0 {
+ // plain call: use direct c function pointer - more efficient
+ cgen(&nodo, &nodr) // REG = 20+offset(REG) -- i.tab->fun[f]
+ proc = 3
+ } else {
+ // go/defer. generate go func value.
+ gins(i386.ALEAL, &nodo, &nodr) // REG = &(20+offset(REG)) -- i.tab->fun[f]
+ }
+
+ nodr.Type = n.Left.Type
+ ginscall(&nodr, proc)
+
+ regfree(&nodr)
+ regfree(&nodo)
+}
+
+/*
+ * generate function call;
+ * proc=0 normal call
+ * proc=1 goroutine run in new proc
+ * proc=2 defer call save away stack
+ */
+func cgen_call(n *gc.Node, proc int) {
+ var t *gc.Type
+ var nod gc.Node
+ var afun gc.Node
+
+ if n == nil {
+ return
+ }
+
+ if n.Left.Ullman >= gc.UINF {
+ // if name involves a fn call
+ // precompute the address of the fn
+ gc.Tempname(&afun, gc.Types[gc.Tptr])
+
+ cgen(n.Left, &afun)
+ }
+
+ gc.Genlist(n.List) // assign the args
+ t = n.Left.Type
+
+ // call tempname pointer
+ if n.Left.Ullman >= gc.UINF {
+ regalloc(&nod, gc.Types[gc.Tptr], nil)
+ gc.Cgen_as(&nod, &afun)
+ nod.Type = t
+ ginscall(&nod, proc)
+ regfree(&nod)
+ return
+ }
+
+ // call pointer
+ if n.Left.Op != gc.ONAME || n.Left.Class != gc.PFUNC {
+ regalloc(&nod, gc.Types[gc.Tptr], nil)
+ gc.Cgen_as(&nod, n.Left)
+ nod.Type = t
+ ginscall(&nod, proc)
+ regfree(&nod)
+ return
+ }
+
+ // call direct
+ n.Left.Method = 1
+
+ ginscall(n.Left, proc)
+}
+
+/*
+ * call to n has already been generated.
+ * generate:
+ * res = return value from call.
+ */
+func cgen_callret(n *gc.Node, res *gc.Node) {
+ var nod gc.Node
+ var fp *gc.Type
+ var t *gc.Type
+ var flist gc.Iter
+
+ t = n.Left.Type
+ if t.Etype == gc.TPTR32 || t.Etype == gc.TPTR64 {
+ t = t.Type
+ }
+
+ fp = gc.Structfirst(&flist, gc.Getoutarg(t))
+ if fp == nil {
+ gc.Fatal("cgen_callret: nil")
+ }
+
+ nod = gc.Node{}
+ nod.Op = gc.OINDREG
+ nod.Val.U.Reg = i386.REG_SP
+ nod.Addable = 1
+
+ nod.Xoffset = fp.Width
+ nod.Type = fp.Type
+ gc.Cgen_as(res, &nod)
+}
+
+/*
+ * call to n has already been generated.
+ * generate:
+ * res = &return value from call.
+ */
+func cgen_aret(n *gc.Node, res *gc.Node) {
+ var nod1 gc.Node
+ var nod2 gc.Node
+ var fp *gc.Type
+ var t *gc.Type
+ var flist gc.Iter
+
+ t = n.Left.Type
+ if gc.Isptr[t.Etype] != 0 {
+ t = t.Type
+ }
+
+ fp = gc.Structfirst(&flist, gc.Getoutarg(t))
+ if fp == nil {
+ gc.Fatal("cgen_aret: nil")
+ }
+
+ nod1 = gc.Node{}
+ nod1.Op = gc.OINDREG
+ nod1.Val.U.Reg = i386.REG_SP
+ nod1.Addable = 1
+
+ nod1.Xoffset = fp.Width
+ nod1.Type = fp.Type
+
+ if res.Op != gc.OREGISTER {
+ regalloc(&nod2, gc.Types[gc.Tptr], res)
+ gins(i386.ALEAL, &nod1, &nod2)
+ gins(i386.AMOVL, &nod2, res)
+ regfree(&nod2)
+ } else {
+ gins(i386.ALEAL, &nod1, res)
+ }
+}
+
+/*
+ * generate return.
+ * n->left is assignments to return values.
+ */
+func cgen_ret(n *gc.Node) {
+ var p *obj.Prog
+
+ if n != nil {
+ gc.Genlist(n.List) // copy out args
+ }
+ if gc.Hasdefer != 0 {
+ ginscall(gc.Deferreturn, 0)
+ }
+ gc.Genlist(gc.Curfn.Exit)
+ p = gins(obj.ARET, nil, nil)
+ if n != nil && n.Op == gc.ORETJMP {
+ p.To.Type = obj.TYPE_MEM
+ p.To.Name = obj.NAME_EXTERN
+ p.To.Sym = gc.Linksym(n.Left.Sym)
+ }
+}
+
+/*
+ * generate division.
+ * caller must set:
+ * ax = allocated AX register
+ * dx = allocated DX register
+ * generates one of:
+ * res = nl / nr
+ * res = nl % nr
+ * according to op.
+ */
+func dodiv(op int, nl *gc.Node, nr *gc.Node, res *gc.Node, ax *gc.Node, dx *gc.Node) {
+ var check int
+ var n1 gc.Node
+ var t1 gc.Node
+ var t2 gc.Node
+ var t3 gc.Node
+ var t4 gc.Node
+ var n4 gc.Node
+ var nz gc.Node
+ var t *gc.Type
+ var t0 *gc.Type
+ var p1 *obj.Prog
+ var p2 *obj.Prog
+
+ // Have to be careful about handling
+ // most negative int divided by -1 correctly.
+ // The hardware will trap.
+ // Also the byte divide instruction needs AH,
+ // which we otherwise don't have to deal with.
+ // Easiest way to avoid for int8, int16: use int32.
+ // For int32 and int64, use explicit test.
+ // Could use int64 hw for int32.
+ t = nl.Type
+
+ t0 = t
+ check = 0
+ if gc.Issigned[t.Etype] != 0 {
+ check = 1
+ if gc.Isconst(nl, gc.CTINT) != 0 && gc.Mpgetfix(nl.Val.U.Xval) != -1<<uint64(t.Width*8-1) {
+ check = 0
+ } else if gc.Isconst(nr, gc.CTINT) != 0 && gc.Mpgetfix(nr.Val.U.Xval) != -1 {
+ check = 0
+ }
+ }
+
+ if t.Width < 4 {
+ if gc.Issigned[t.Etype] != 0 {
+ t = gc.Types[gc.TINT32]
+ } else {
+ t = gc.Types[gc.TUINT32]
+ }
+ check = 0
+ }
+
+ gc.Tempname(&t1, t)
+ gc.Tempname(&t2, t)
+ if t0 != t {
+ gc.Tempname(&t3, t0)
+ gc.Tempname(&t4, t0)
+ cgen(nl, &t3)
+ cgen(nr, &t4)
+
+ // Convert.
+ gmove(&t3, &t1)
+
+ gmove(&t4, &t2)
+ } else {
+ cgen(nl, &t1)
+ cgen(nr, &t2)
+ }
+
+ if !(gc.Samereg(ax, res) != 0) && !(gc.Samereg(dx, res) != 0) {
+ regalloc(&n1, t, res)
+ } else {
+ regalloc(&n1, t, nil)
+ }
+ gmove(&t2, &n1)
+ gmove(&t1, ax)
+ p2 = nil
+ if gc.Nacl {
+ // Native Client does not relay the divide-by-zero trap
+ // to the executing program, so we must insert a check
+ // for ourselves.
+ gc.Nodconst(&n4, t, 0)
+
+ gins(optoas(gc.OCMP, t), &n1, &n4)
+ p1 = gc.Gbranch(optoas(gc.ONE, t), nil, +1)
+ if panicdiv == nil {
+ panicdiv = gc.Sysfunc("panicdivide")
+ }
+ ginscall(panicdiv, -1)
+ gc.Patch(p1, gc.Pc)
+ }
+
+ if check != 0 {
+ gc.Nodconst(&n4, t, -1)
+ gins(optoas(gc.OCMP, t), &n1, &n4)
+ p1 = gc.Gbranch(optoas(gc.ONE, t), nil, +1)
+ if op == gc.ODIV {
+ // a / (-1) is -a.
+ gins(optoas(gc.OMINUS, t), nil, ax)
+
+ gmove(ax, res)
+ } else {
+ // a % (-1) is 0.
+ gc.Nodconst(&n4, t, 0)
+
+ gmove(&n4, res)
+ }
+
+ p2 = gc.Gbranch(obj.AJMP, nil, 0)
+ gc.Patch(p1, gc.Pc)
+ }
+
+ if !(gc.Issigned[t.Etype] != 0) {
+ gc.Nodconst(&nz, t, 0)
+ gmove(&nz, dx)
+ } else {
+ gins(optoas(gc.OEXTEND, t), nil, nil)
+ }
+ gins(optoas(op, t), &n1, nil)
+ regfree(&n1)
+
+ if op == gc.ODIV {
+ gmove(ax, res)
+ } else {
+ gmove(dx, res)
+ }
+ if check != 0 {
+ gc.Patch(p2, gc.Pc)
+ }
+}
+
+func savex(dr int, x *gc.Node, oldx *gc.Node, res *gc.Node, t *gc.Type) {
+ var r int
+
+ r = int(reg[dr])
+ gc.Nodreg(x, gc.Types[gc.TINT32], dr)
+
+ // save current ax and dx if they are live
+ // and not the destination
+ *oldx = gc.Node{}
+
+ if r > 0 && !(gc.Samereg(x, res) != 0) {
+ gc.Tempname(oldx, gc.Types[gc.TINT32])
+ gmove(x, oldx)
+ }
+
+ regalloc(x, t, x)
+}
+
+func restx(x *gc.Node, oldx *gc.Node) {
+ regfree(x)
+
+ if oldx.Op != 0 {
+ x.Type = gc.Types[gc.TINT32]
+ gmove(oldx, x)
+ }
+}
+
+/*
+ * generate division according to op, one of:
+ * res = nl / nr
+ * res = nl % nr
+ */
+func cgen_div(op int, nl *gc.Node, nr *gc.Node, res *gc.Node) {
+ var ax gc.Node
+ var dx gc.Node
+ var oldax gc.Node
+ var olddx gc.Node
+ var t *gc.Type
+
+ if gc.Is64(nl.Type) != 0 {
+ gc.Fatal("cgen_div %v", gc.Tconv(nl.Type, 0))
+ }
+
+ if gc.Issigned[nl.Type.Etype] != 0 {
+ t = gc.Types[gc.TINT32]
+ } else {
+ t = gc.Types[gc.TUINT32]
+ }
+ savex(i386.REG_AX, &ax, &oldax, res, t)
+ savex(i386.REG_DX, &dx, &olddx, res, t)
+ dodiv(op, nl, nr, res, &ax, &dx)
+ restx(&dx, &olddx)
+ restx(&ax, &oldax)
+}
+
+/*
+ * generate shift according to op, one of:
+ * res = nl << nr
+ * res = nl >> nr
+ */
+func cgen_shift(op int, bounded int, nl *gc.Node, nr *gc.Node, res *gc.Node) {
+ var n1 gc.Node
+ var n2 gc.Node
+ var nt gc.Node
+ var cx gc.Node
+ var oldcx gc.Node
+ var hi gc.Node
+ var lo gc.Node
+ var a int
+ var w int
+ var p1 *obj.Prog
+ var p2 *obj.Prog
+ var sc uint64
+
+ if nl.Type.Width > 4 {
+ gc.Fatal("cgen_shift %v", gc.Tconv(nl.Type, 0))
+ }
+
+ w = int(nl.Type.Width * 8)
+
+ a = optoas(op, nl.Type)
+
+ if nr.Op == gc.OLITERAL {
+ gc.Tempname(&n2, nl.Type)
+ cgen(nl, &n2)
+ regalloc(&n1, nl.Type, res)
+ gmove(&n2, &n1)
+ sc = uint64(gc.Mpgetfix(nr.Val.U.Xval))
+ if sc >= uint64(nl.Type.Width*8) {
+ // large shift gets 2 shifts by width-1
+ gins(a, ncon(uint32(w)-1), &n1)
+
+ gins(a, ncon(uint32(w)-1), &n1)
+ } else {
+ gins(a, nr, &n1)
+ }
+ gmove(&n1, res)
+ regfree(&n1)
+ return
+ }
+
+ oldcx = gc.Node{}
+ gc.Nodreg(&cx, gc.Types[gc.TUINT32], i386.REG_CX)
+ if reg[i386.REG_CX] > 1 && !(gc.Samereg(&cx, res) != 0) {
+ gc.Tempname(&oldcx, gc.Types[gc.TUINT32])
+ gmove(&cx, &oldcx)
+ }
+
+ if nr.Type.Width > 4 {
+ gc.Tempname(&nt, nr.Type)
+ n1 = nt
+ } else {
+ gc.Nodreg(&n1, gc.Types[gc.TUINT32], i386.REG_CX)
+ regalloc(&n1, nr.Type, &n1) // to hold the shift type in CX
+ }
+
+ if gc.Samereg(&cx, res) != 0 {
+ regalloc(&n2, nl.Type, nil)
+ } else {
+ regalloc(&n2, nl.Type, res)
+ }
+ if nl.Ullman >= nr.Ullman {
+ cgen(nl, &n2)
+ cgen(nr, &n1)
+ } else {
+ cgen(nr, &n1)
+ cgen(nl, &n2)
+ }
+
+ // test and fix up large shifts
+ if bounded != 0 {
+ if nr.Type.Width > 4 {
+ // delayed reg alloc
+ gc.Nodreg(&n1, gc.Types[gc.TUINT32], i386.REG_CX)
+
+ regalloc(&n1, gc.Types[gc.TUINT32], &n1) // to hold the shift type in CX
+ split64(&nt, &lo, &hi)
+ gmove(&lo, &n1)
+ splitclean()
+ }
+ } else {
+ if nr.Type.Width > 4 {
+ // delayed reg alloc
+ gc.Nodreg(&n1, gc.Types[gc.TUINT32], i386.REG_CX)
+
+ regalloc(&n1, gc.Types[gc.TUINT32], &n1) // to hold the shift type in CX
+ split64(&nt, &lo, &hi)
+ gmove(&lo, &n1)
+ gins(optoas(gc.OCMP, gc.Types[gc.TUINT32]), &hi, ncon(0))
+ p2 = gc.Gbranch(optoas(gc.ONE, gc.Types[gc.TUINT32]), nil, +1)
+ gins(optoas(gc.OCMP, gc.Types[gc.TUINT32]), &n1, ncon(uint32(w)))
+ p1 = gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TUINT32]), nil, +1)
+ splitclean()
+ gc.Patch(p2, gc.Pc)
+ } else {
+ gins(optoas(gc.OCMP, nr.Type), &n1, ncon(uint32(w)))
+ p1 = gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TUINT32]), nil, +1)
+ }
+
+ if op == gc.ORSH && gc.Issigned[nl.Type.Etype] != 0 {
+ gins(a, ncon(uint32(w)-1), &n2)
+ } else {
+ gmove(ncon(0), &n2)
+ }
+
+ gc.Patch(p1, gc.Pc)
+ }
+
+ gins(a, &n1, &n2)
+
+ if oldcx.Op != 0 {
+ gmove(&oldcx, &cx)
+ }
+
+ gmove(&n2, res)
+
+ regfree(&n1)
+ regfree(&n2)
+}
+
+/*
+ * generate byte multiply:
+ * res = nl * nr
+ * there is no 2-operand byte multiply instruction so
+ * we do a full-width multiplication and truncate afterwards.
+ */
+func cgen_bmul(op int, nl *gc.Node, nr *gc.Node, res *gc.Node) {
+ var n1 gc.Node
+ var n2 gc.Node
+ var nt gc.Node
+ var tmp *gc.Node
+ var t *gc.Type
+ var a int
+
+ // copy from byte to full registers
+ t = gc.Types[gc.TUINT32]
+
+ if gc.Issigned[nl.Type.Etype] != 0 {
+ t = gc.Types[gc.TINT32]
+ }
+
+ // largest ullman on left.
+ if nl.Ullman < nr.Ullman {
+ tmp = nl
+ nl = nr
+ nr = tmp
+ }
+
+ gc.Tempname(&nt, nl.Type)
+ cgen(nl, &nt)
+ regalloc(&n1, t, res)
+ cgen(nr, &n1)
+ regalloc(&n2, t, nil)
+ gmove(&nt, &n2)
+ a = optoas(op, t)
+ gins(a, &n2, &n1)
+ regfree(&n2)
+ gmove(&n1, res)
+ regfree(&n1)
+}
+
+/*
+ * generate high multiply:
+ * res = (nl*nr) >> width
+ */
+func cgen_hmul(nl *gc.Node, nr *gc.Node, res *gc.Node) {
+ var t *gc.Type
+ var a int
+ var n1 gc.Node
+ var n2 gc.Node
+ var ax gc.Node
+ var dx gc.Node
+
+ t = nl.Type
+ a = optoas(gc.OHMUL, t)
+
+ // gen nl in n1.
+ gc.Tempname(&n1, t)
+
+ cgen(nl, &n1)
+
+ // gen nr in n2.
+ regalloc(&n2, t, res)
+
+ cgen(nr, &n2)
+
+ // multiply.
+ gc.Nodreg(&ax, t, i386.REG_AX)
+
+ gmove(&n2, &ax)
+ gins(a, &n1, nil)
+ regfree(&n2)
+
+ if t.Width == 1 {
+ // byte multiply behaves differently.
+ gc.Nodreg(&ax, t, i386.REG_AH)
+
+ gc.Nodreg(&dx, t, i386.REG_DX)
+ gmove(&ax, &dx)
+ }
+
+ gc.Nodreg(&dx, t, i386.REG_DX)
+ gmove(&dx, res)
+}
+
+/*
+ * generate floating-point operation.
+ */
+func cgen_float(n *gc.Node, res *gc.Node) {
+ var nl *gc.Node
+ var n1 gc.Node
+ var n2 gc.Node
+ var p1 *obj.Prog
+ var p2 *obj.Prog
+ var p3 *obj.Prog
+
+ nl = n.Left
+ switch n.Op {
+ case gc.OEQ,
+ gc.ONE,
+ gc.OLT,
+ gc.OLE,
+ gc.OGE:
+ p1 = gc.Gbranch(obj.AJMP, nil, 0)
+ p2 = gc.Pc
+ gmove(gc.Nodbool(1), res)
+ p3 = gc.Gbranch(obj.AJMP, nil, 0)
+ gc.Patch(p1, gc.Pc)
+ bgen(n, true, 0, p2)
+ gmove(gc.Nodbool(0), res)
+ gc.Patch(p3, gc.Pc)
+ return
+
+ case gc.OPLUS:
+ cgen(nl, res)
+ return
+
+ case gc.OCONV:
+ if gc.Eqtype(n.Type, nl.Type) || gc.Noconv(n.Type, nl.Type) != 0 {
+ cgen(nl, res)
+ return
+ }
+
+ gc.Tempname(&n2, n.Type)
+ mgen(nl, &n1, res)
+ gmove(&n1, &n2)
+ gmove(&n2, res)
+ mfree(&n1)
+ return
+ }
+
+ if gc.Use_sse != 0 {
+ cgen_floatsse(n, res)
+ } else {
+ cgen_float387(n, res)
+ }
+}
+
+// floating-point. 387 (not SSE2)
+func cgen_float387(n *gc.Node, res *gc.Node) {
+ var f0 gc.Node
+ var f1 gc.Node
+ var nl *gc.Node
+ var nr *gc.Node
+
+ nl = n.Left
+ nr = n.Right
+ gc.Nodreg(&f0, nl.Type, i386.REG_F0)
+ gc.Nodreg(&f1, n.Type, i386.REG_F0+1)
+ if nr != nil {
+ goto flt2
+ }
+
+ // unary
+ cgen(nl, &f0)
+
+ if n.Op != gc.OCONV && n.Op != gc.OPLUS {
+ gins(foptoas(int(n.Op), n.Type, 0), nil, nil)
+ }
+ gmove(&f0, res)
+ return
+
+flt2: // binary
+ if nl.Ullman >= nr.Ullman {
+ cgen(nl, &f0)
+ if nr.Addable != 0 {
+ gins(foptoas(int(n.Op), n.Type, 0), nr, &f0)
+ } else {
+ cgen(nr, &f0)
+ gins(foptoas(int(n.Op), n.Type, Fpop), &f0, &f1)
+ }
+ } else {
+ cgen(nr, &f0)
+ if nl.Addable != 0 {
+ gins(foptoas(int(n.Op), n.Type, Frev), nl, &f0)
+ } else {
+ cgen(nl, &f0)
+ gins(foptoas(int(n.Op), n.Type, Frev|Fpop), &f0, &f1)
+ }
+ }
+
+ gmove(&f0, res)
+ return
+}
+
+func cgen_floatsse(n *gc.Node, res *gc.Node) {
+ var nl *gc.Node
+ var nr *gc.Node
+ var r *gc.Node
+ var n1 gc.Node
+ var n2 gc.Node
+ var nt gc.Node
+ var a int
+
+ nl = n.Left
+ nr = n.Right
+ switch n.Op {
+ default:
+ gc.Dump("cgen_floatsse", n)
+ gc.Fatal("cgen_floatsse %v", gc.Oconv(int(n.Op), 0))
+ return
+
+ case gc.OMINUS,
+ gc.OCOM:
+ nr = gc.Nodintconst(-1)
+ gc.Convlit(&nr, n.Type)
+ a = foptoas(gc.OMUL, nl.Type, 0)
+ goto sbop
+
+ // symmetric binary
+ case gc.OADD,
+ gc.OMUL:
+ a = foptoas(int(n.Op), nl.Type, 0)
+
+ goto sbop
+
+ // asymmetric binary
+ case gc.OSUB,
+ gc.OMOD,
+ gc.ODIV:
+ a = foptoas(int(n.Op), nl.Type, 0)
+
+ goto abop
+ }
+
+sbop: // symmetric binary
+ if nl.Ullman < nr.Ullman || nl.Op == gc.OLITERAL {
+ r = nl
+ nl = nr
+ nr = r
+ }
+
+abop: // asymmetric binary
+ if nl.Ullman >= nr.Ullman {
+ gc.Tempname(&nt, nl.Type)
+ cgen(nl, &nt)
+ mgen(nr, &n2, nil)
+ regalloc(&n1, nl.Type, res)
+ gmove(&nt, &n1)
+ gins(a, &n2, &n1)
+ gmove(&n1, res)
+ regfree(&n1)
+ mfree(&n2)
+ } else {
+ regalloc(&n2, nr.Type, res)
+ cgen(nr, &n2)
+ regalloc(&n1, nl.Type, nil)
+ cgen(nl, &n1)
+ gins(a, &n2, &n1)
+ regfree(&n2)
+ gmove(&n1, res)
+ regfree(&n1)
+ }
+
+ return
+}
+
+func bgen_float(n *gc.Node, true_ int, likely int, to *obj.Prog) {
+ var et int
+ var a int
+ var nl *gc.Node
+ var nr *gc.Node
+ var r *gc.Node
+ var n1 gc.Node
+ var n2 gc.Node
+ var n3 gc.Node
+ var tmp gc.Node
+ var t1 gc.Node
+ var t2 gc.Node
+ var ax gc.Node
+ var p1 *obj.Prog
+ var p2 *obj.Prog
+
+ nl = n.Left
+ nr = n.Right
+ a = int(n.Op)
+ if !(true_ != 0) {
+ // brcom is not valid on floats when NaN is involved.
+ p1 = gc.Gbranch(obj.AJMP, nil, 0)
+
+ p2 = gc.Gbranch(obj.AJMP, nil, 0)
+ gc.Patch(p1, gc.Pc)
+
+ // No need to avoid re-genning ninit.
+ bgen_float(n, 1, -likely, p2)
+
+ gc.Patch(gc.Gbranch(obj.AJMP, nil, 0), to)
+ gc.Patch(p2, gc.Pc)
+ return
+ }
+
+ if gc.Use_sse != 0 {
+ goto sse
+ } else {
+ goto x87
+ }
+
+x87:
+ a = gc.Brrev(a) // because the args are stacked
+ if a == gc.OGE || a == gc.OGT {
+ // only < and <= work right with NaN; reverse if needed
+ r = nr
+
+ nr = nl
+ nl = r
+ a = gc.Brrev(a)
+ }
+
+ gc.Nodreg(&tmp, nr.Type, i386.REG_F0)
+ gc.Nodreg(&n2, nr.Type, i386.REG_F0+1)
+ gc.Nodreg(&ax, gc.Types[gc.TUINT16], i386.REG_AX)
+ et = gc.Simsimtype(nr.Type)
+ if et == gc.TFLOAT64 {
+ if nl.Ullman > nr.Ullman {
+ cgen(nl, &tmp)
+ cgen(nr, &tmp)
+ gins(i386.AFXCHD, &tmp, &n2)
+ } else {
+ cgen(nr, &tmp)
+ cgen(nl, &tmp)
+ }
+
+ gins(i386.AFUCOMIP, &tmp, &n2)
+ gins(i386.AFMOVDP, &tmp, &tmp) // annoying pop but still better than STSW+SAHF
+ } else {
+ // TODO(rsc): The moves back and forth to memory
+ // here are for truncating the value to 32 bits.
+ // This handles 32-bit comparison but presumably
+ // all the other ops have the same problem.
+ // We need to figure out what the right general
+ // solution is, besides telling people to use float64.
+ gc.Tempname(&t1, gc.Types[gc.TFLOAT32])
+
+ gc.Tempname(&t2, gc.Types[gc.TFLOAT32])
+ cgen(nr, &t1)
+ cgen(nl, &t2)
+ gmove(&t2, &tmp)
+ gins(i386.AFCOMFP, &t1, &tmp)
+ gins(i386.AFSTSW, nil, &ax)
+ gins(i386.ASAHF, nil, nil)
+ }
+
+ goto ret
+
+sse:
+ if !(nl.Addable != 0) {
+ gc.Tempname(&n1, nl.Type)
+ cgen(nl, &n1)
+ nl = &n1
+ }
+
+ if !(nr.Addable != 0) {
+ gc.Tempname(&tmp, nr.Type)
+ cgen(nr, &tmp)
+ nr = &tmp
+ }
+
+ regalloc(&n2, nr.Type, nil)
+ gmove(nr, &n2)
+ nr = &n2
+
+ if nl.Op != gc.OREGISTER {
+ regalloc(&n3, nl.Type, nil)
+ gmove(nl, &n3)
+ nl = &n3
+ }
+
+ if a == gc.OGE || a == gc.OGT {
+ // only < and <= work right with NaN; reverse if needed
+ r = nr
+
+ nr = nl
+ nl = r
+ a = gc.Brrev(a)
+ }
+
+ gins(foptoas(gc.OCMP, nr.Type, 0), nl, nr)
+ if nl.Op == gc.OREGISTER {
+ regfree(nl)
+ }
+ regfree(nr)
+
+ret:
+ if a == gc.OEQ {
+ // neither NE nor P
+ p1 = gc.Gbranch(i386.AJNE, nil, -likely)
+
+ p2 = gc.Gbranch(i386.AJPS, nil, -likely)
+ gc.Patch(gc.Gbranch(obj.AJMP, nil, 0), to)
+ gc.Patch(p1, gc.Pc)
+ gc.Patch(p2, gc.Pc)
+ } else if a == gc.ONE {
+ // either NE or P
+ gc.Patch(gc.Gbranch(i386.AJNE, nil, likely), to)
+
+ gc.Patch(gc.Gbranch(i386.AJPS, nil, likely), to)
+ } else {
+ gc.Patch(gc.Gbranch(optoas(a, nr.Type), nil, likely), to)
+ }
+}
+
+// Called after regopt and peep have run.
+// Expand CHECKNIL pseudo-op into actual nil pointer check.
+func expandchecks(firstp *obj.Prog) {
+ var p *obj.Prog
+ var p1 *obj.Prog
+ var p2 *obj.Prog
+
+ for p = firstp; p != nil; p = p.Link {
+ if p.As != obj.ACHECKNIL {
+ continue
+ }
+ if gc.Debug_checknil != 0 && p.Lineno > 1 { // p->lineno==1 in generated wrappers
+ gc.Warnl(int(p.Lineno), "generated nil check")
+ }
+
+ // check is
+ // CMP arg, $0
+ // JNE 2(PC) (likely)
+ // MOV AX, 0
+ p1 = gc.Ctxt.NewProg()
+
+ p2 = gc.Ctxt.NewProg()
+ gc.Clearp(p1)
+ gc.Clearp(p2)
+ p1.Link = p2
+ p2.Link = p.Link
+ p.Link = p1
+ p1.Lineno = p.Lineno
+ p2.Lineno = p.Lineno
+ p1.Pc = 9999
+ p2.Pc = 9999
+ p.As = i386.ACMPL
+ p.To.Type = obj.TYPE_CONST
+ p.To.Offset = 0
+ p1.As = i386.AJNE
+ p1.From.Type = obj.TYPE_CONST
+ p1.From.Offset = 1 // likely
+ p1.To.Type = obj.TYPE_BRANCH
+ p1.To.U.Branch = p2.Link
+
+ // crash by write to memory address 0.
+ // if possible, since we know arg is 0, use 0(arg),
+ // which will be shorter to encode than plain 0.
+ p2.As = i386.AMOVL
+
+ p2.From.Type = obj.TYPE_REG
+ p2.From.Reg = i386.REG_AX
+ if regtyp(&p.From) != 0 {
+ p2.To.Type = obj.TYPE_MEM
+ p2.To.Reg = p.From.Reg
+ } else {
+ p2.To.Type = obj.TYPE_MEM
+ }
+ p2.To.Offset = 0
+ }
+}
--- /dev/null
+// Derived from Inferno utils/8c/txt.c
+// http://code.google.com/p/inferno-os/source/browse/utils/8c/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 main
+
+import (
+ "cmd/internal/obj"
+ "cmd/internal/obj/i386"
+ "fmt"
+)
+import "cmd/internal/gc"
+
+// TODO(rsc): Can make this bigger if we move
+// the text segment up higher in 8l for all GOOS.
+// At the same time, can raise StackBig in ../../runtime/stack.h.
+var unmappedzero uint32 = 4096
+
+/*
+ * return Axxx for Oxxx on type t.
+ */
+func optoas(op int, t *gc.Type) int {
+ var a int
+
+ if t == nil {
+ gc.Fatal("optoas: t is nil")
+ }
+
+ a = obj.AXXX
+ switch uint32(op)<<16 | uint32(gc.Simtype[t.Etype]) {
+ default:
+ gc.Fatal("optoas: no entry %v-%v", gc.Oconv(int(op), 0), gc.Tconv(t, 0))
+
+ case gc.OADDR<<16 | gc.TPTR32:
+ a = i386.ALEAL
+
+ case gc.OEQ<<16 | gc.TBOOL,
+ gc.OEQ<<16 | gc.TINT8,
+ gc.OEQ<<16 | gc.TUINT8,
+ gc.OEQ<<16 | gc.TINT16,
+ gc.OEQ<<16 | gc.TUINT16,
+ gc.OEQ<<16 | gc.TINT32,
+ gc.OEQ<<16 | gc.TUINT32,
+ gc.OEQ<<16 | gc.TINT64,
+ gc.OEQ<<16 | gc.TUINT64,
+ gc.OEQ<<16 | gc.TPTR32,
+ gc.OEQ<<16 | gc.TPTR64,
+ gc.OEQ<<16 | gc.TFLOAT32,
+ gc.OEQ<<16 | gc.TFLOAT64:
+ a = i386.AJEQ
+
+ case gc.ONE<<16 | gc.TBOOL,
+ gc.ONE<<16 | gc.TINT8,
+ gc.ONE<<16 | gc.TUINT8,
+ gc.ONE<<16 | gc.TINT16,
+ gc.ONE<<16 | gc.TUINT16,
+ gc.ONE<<16 | gc.TINT32,
+ gc.ONE<<16 | gc.TUINT32,
+ gc.ONE<<16 | gc.TINT64,
+ gc.ONE<<16 | gc.TUINT64,
+ gc.ONE<<16 | gc.TPTR32,
+ gc.ONE<<16 | gc.TPTR64,
+ gc.ONE<<16 | gc.TFLOAT32,
+ gc.ONE<<16 | gc.TFLOAT64:
+ a = i386.AJNE
+
+ case gc.OLT<<16 | gc.TINT8,
+ gc.OLT<<16 | gc.TINT16,
+ gc.OLT<<16 | gc.TINT32,
+ gc.OLT<<16 | gc.TINT64:
+ a = i386.AJLT
+
+ case gc.OLT<<16 | gc.TUINT8,
+ gc.OLT<<16 | gc.TUINT16,
+ gc.OLT<<16 | gc.TUINT32,
+ gc.OLT<<16 | gc.TUINT64:
+ a = i386.AJCS
+
+ case gc.OLE<<16 | gc.TINT8,
+ gc.OLE<<16 | gc.TINT16,
+ gc.OLE<<16 | gc.TINT32,
+ gc.OLE<<16 | gc.TINT64:
+ a = i386.AJLE
+
+ case gc.OLE<<16 | gc.TUINT8,
+ gc.OLE<<16 | gc.TUINT16,
+ gc.OLE<<16 | gc.TUINT32,
+ gc.OLE<<16 | gc.TUINT64:
+ a = i386.AJLS
+
+ case gc.OGT<<16 | gc.TINT8,
+ gc.OGT<<16 | gc.TINT16,
+ gc.OGT<<16 | gc.TINT32,
+ gc.OGT<<16 | gc.TINT64:
+ a = i386.AJGT
+
+ case gc.OGT<<16 | gc.TUINT8,
+ gc.OGT<<16 | gc.TUINT16,
+ gc.OGT<<16 | gc.TUINT32,
+ gc.OGT<<16 | gc.TUINT64,
+ gc.OLT<<16 | gc.TFLOAT32,
+ gc.OLT<<16 | gc.TFLOAT64:
+ a = i386.AJHI
+
+ case gc.OGE<<16 | gc.TINT8,
+ gc.OGE<<16 | gc.TINT16,
+ gc.OGE<<16 | gc.TINT32,
+ gc.OGE<<16 | gc.TINT64:
+ a = i386.AJGE
+
+ case gc.OGE<<16 | gc.TUINT8,
+ gc.OGE<<16 | gc.TUINT16,
+ gc.OGE<<16 | gc.TUINT32,
+ gc.OGE<<16 | gc.TUINT64,
+ gc.OLE<<16 | gc.TFLOAT32,
+ gc.OLE<<16 | gc.TFLOAT64:
+ a = i386.AJCC
+
+ case gc.OCMP<<16 | gc.TBOOL,
+ gc.OCMP<<16 | gc.TINT8,
+ gc.OCMP<<16 | gc.TUINT8:
+ a = i386.ACMPB
+
+ case gc.OCMP<<16 | gc.TINT16,
+ gc.OCMP<<16 | gc.TUINT16:
+ a = i386.ACMPW
+
+ case gc.OCMP<<16 | gc.TINT32,
+ gc.OCMP<<16 | gc.TUINT32,
+ gc.OCMP<<16 | gc.TPTR32:
+ a = i386.ACMPL
+
+ case gc.OAS<<16 | gc.TBOOL,
+ gc.OAS<<16 | gc.TINT8,
+ gc.OAS<<16 | gc.TUINT8:
+ a = i386.AMOVB
+
+ case gc.OAS<<16 | gc.TINT16,
+ gc.OAS<<16 | gc.TUINT16:
+ a = i386.AMOVW
+
+ case gc.OAS<<16 | gc.TINT32,
+ gc.OAS<<16 | gc.TUINT32,
+ gc.OAS<<16 | gc.TPTR32:
+ a = i386.AMOVL
+
+ case gc.OAS<<16 | gc.TFLOAT32:
+ a = i386.AMOVSS
+
+ case gc.OAS<<16 | gc.TFLOAT64:
+ a = i386.AMOVSD
+
+ case gc.OADD<<16 | gc.TINT8,
+ gc.OADD<<16 | gc.TUINT8:
+ a = i386.AADDB
+
+ case gc.OADD<<16 | gc.TINT16,
+ gc.OADD<<16 | gc.TUINT16:
+ a = i386.AADDW
+
+ case gc.OADD<<16 | gc.TINT32,
+ gc.OADD<<16 | gc.TUINT32,
+ gc.OADD<<16 | gc.TPTR32:
+ a = i386.AADDL
+
+ case gc.OSUB<<16 | gc.TINT8,
+ gc.OSUB<<16 | gc.TUINT8:
+ a = i386.ASUBB
+
+ case gc.OSUB<<16 | gc.TINT16,
+ gc.OSUB<<16 | gc.TUINT16:
+ a = i386.ASUBW
+
+ case gc.OSUB<<16 | gc.TINT32,
+ gc.OSUB<<16 | gc.TUINT32,
+ gc.OSUB<<16 | gc.TPTR32:
+ a = i386.ASUBL
+
+ case gc.OINC<<16 | gc.TINT8,
+ gc.OINC<<16 | gc.TUINT8:
+ a = i386.AINCB
+
+ case gc.OINC<<16 | gc.TINT16,
+ gc.OINC<<16 | gc.TUINT16:
+ a = i386.AINCW
+
+ case gc.OINC<<16 | gc.TINT32,
+ gc.OINC<<16 | gc.TUINT32,
+ gc.OINC<<16 | gc.TPTR32:
+ a = i386.AINCL
+
+ case gc.ODEC<<16 | gc.TINT8,
+ gc.ODEC<<16 | gc.TUINT8:
+ a = i386.ADECB
+
+ case gc.ODEC<<16 | gc.TINT16,
+ gc.ODEC<<16 | gc.TUINT16:
+ a = i386.ADECW
+
+ case gc.ODEC<<16 | gc.TINT32,
+ gc.ODEC<<16 | gc.TUINT32,
+ gc.ODEC<<16 | gc.TPTR32:
+ a = i386.ADECL
+
+ case gc.OCOM<<16 | gc.TINT8,
+ gc.OCOM<<16 | gc.TUINT8:
+ a = i386.ANOTB
+
+ case gc.OCOM<<16 | gc.TINT16,
+ gc.OCOM<<16 | gc.TUINT16:
+ a = i386.ANOTW
+
+ case gc.OCOM<<16 | gc.TINT32,
+ gc.OCOM<<16 | gc.TUINT32,
+ gc.OCOM<<16 | gc.TPTR32:
+ a = i386.ANOTL
+
+ case gc.OMINUS<<16 | gc.TINT8,
+ gc.OMINUS<<16 | gc.TUINT8:
+ a = i386.ANEGB
+
+ case gc.OMINUS<<16 | gc.TINT16,
+ gc.OMINUS<<16 | gc.TUINT16:
+ a = i386.ANEGW
+
+ case gc.OMINUS<<16 | gc.TINT32,
+ gc.OMINUS<<16 | gc.TUINT32,
+ gc.OMINUS<<16 | gc.TPTR32:
+ a = i386.ANEGL
+
+ case gc.OAND<<16 | gc.TINT8,
+ gc.OAND<<16 | gc.TUINT8:
+ a = i386.AANDB
+
+ case gc.OAND<<16 | gc.TINT16,
+ gc.OAND<<16 | gc.TUINT16:
+ a = i386.AANDW
+
+ case gc.OAND<<16 | gc.TINT32,
+ gc.OAND<<16 | gc.TUINT32,
+ gc.OAND<<16 | gc.TPTR32:
+ a = i386.AANDL
+
+ case gc.OOR<<16 | gc.TINT8,
+ gc.OOR<<16 | gc.TUINT8:
+ a = i386.AORB
+
+ case gc.OOR<<16 | gc.TINT16,
+ gc.OOR<<16 | gc.TUINT16:
+ a = i386.AORW
+
+ case gc.OOR<<16 | gc.TINT32,
+ gc.OOR<<16 | gc.TUINT32,
+ gc.OOR<<16 | gc.TPTR32:
+ a = i386.AORL
+
+ case gc.OXOR<<16 | gc.TINT8,
+ gc.OXOR<<16 | gc.TUINT8:
+ a = i386.AXORB
+
+ case gc.OXOR<<16 | gc.TINT16,
+ gc.OXOR<<16 | gc.TUINT16:
+ a = i386.AXORW
+
+ case gc.OXOR<<16 | gc.TINT32,
+ gc.OXOR<<16 | gc.TUINT32,
+ gc.OXOR<<16 | gc.TPTR32:
+ a = i386.AXORL
+
+ case gc.OLROT<<16 | gc.TINT8,
+ gc.OLROT<<16 | gc.TUINT8:
+ a = i386.AROLB
+
+ case gc.OLROT<<16 | gc.TINT16,
+ gc.OLROT<<16 | gc.TUINT16:
+ a = i386.AROLW
+
+ case gc.OLROT<<16 | gc.TINT32,
+ gc.OLROT<<16 | gc.TUINT32,
+ gc.OLROT<<16 | gc.TPTR32:
+ a = i386.AROLL
+
+ case gc.OLSH<<16 | gc.TINT8,
+ gc.OLSH<<16 | gc.TUINT8:
+ a = i386.ASHLB
+
+ case gc.OLSH<<16 | gc.TINT16,
+ gc.OLSH<<16 | gc.TUINT16:
+ a = i386.ASHLW
+
+ case gc.OLSH<<16 | gc.TINT32,
+ gc.OLSH<<16 | gc.TUINT32,
+ gc.OLSH<<16 | gc.TPTR32:
+ a = i386.ASHLL
+
+ case gc.ORSH<<16 | gc.TUINT8:
+ a = i386.ASHRB
+
+ case gc.ORSH<<16 | gc.TUINT16:
+ a = i386.ASHRW
+
+ case gc.ORSH<<16 | gc.TUINT32,
+ gc.ORSH<<16 | gc.TPTR32:
+ a = i386.ASHRL
+
+ case gc.ORSH<<16 | gc.TINT8:
+ a = i386.ASARB
+
+ case gc.ORSH<<16 | gc.TINT16:
+ a = i386.ASARW
+
+ case gc.ORSH<<16 | gc.TINT32:
+ a = i386.ASARL
+
+ case gc.OHMUL<<16 | gc.TINT8,
+ gc.OMUL<<16 | gc.TINT8,
+ gc.OMUL<<16 | gc.TUINT8:
+ a = i386.AIMULB
+
+ case gc.OHMUL<<16 | gc.TINT16,
+ gc.OMUL<<16 | gc.TINT16,
+ gc.OMUL<<16 | gc.TUINT16:
+ a = i386.AIMULW
+
+ case gc.OHMUL<<16 | gc.TINT32,
+ gc.OMUL<<16 | gc.TINT32,
+ gc.OMUL<<16 | gc.TUINT32,
+ gc.OMUL<<16 | gc.TPTR32:
+ a = i386.AIMULL
+
+ case gc.OHMUL<<16 | gc.TUINT8:
+ a = i386.AMULB
+
+ case gc.OHMUL<<16 | gc.TUINT16:
+ a = i386.AMULW
+
+ case gc.OHMUL<<16 | gc.TUINT32,
+ gc.OHMUL<<16 | gc.TPTR32:
+ a = i386.AMULL
+
+ case gc.ODIV<<16 | gc.TINT8,
+ gc.OMOD<<16 | gc.TINT8:
+ a = i386.AIDIVB
+
+ case gc.ODIV<<16 | gc.TUINT8,
+ gc.OMOD<<16 | gc.TUINT8:
+ a = i386.ADIVB
+
+ case gc.ODIV<<16 | gc.TINT16,
+ gc.OMOD<<16 | gc.TINT16:
+ a = i386.AIDIVW
+
+ case gc.ODIV<<16 | gc.TUINT16,
+ gc.OMOD<<16 | gc.TUINT16:
+ a = i386.ADIVW
+
+ case gc.ODIV<<16 | gc.TINT32,
+ gc.OMOD<<16 | gc.TINT32:
+ a = i386.AIDIVL
+
+ case gc.ODIV<<16 | gc.TUINT32,
+ gc.ODIV<<16 | gc.TPTR32,
+ gc.OMOD<<16 | gc.TUINT32,
+ gc.OMOD<<16 | gc.TPTR32:
+ a = i386.ADIVL
+
+ case gc.OEXTEND<<16 | gc.TINT16:
+ a = i386.ACWD
+
+ case gc.OEXTEND<<16 | gc.TINT32:
+ a = i386.ACDQ
+ }
+
+ return a
+}
+
+func foptoas(op int, t *gc.Type, flg int) int {
+ var et int
+ var a int
+
+ a = obj.AXXX
+ et = int(gc.Simtype[t.Etype])
+
+ if gc.Use_sse != 0 {
+ goto sse
+ }
+
+ // If we need Fpop, it means we're working on
+ // two different floating-point registers, not memory.
+ // There the instruction only has a float64 form.
+ if flg&Fpop != 0 {
+ et = gc.TFLOAT64
+ }
+
+ // clear Frev if unneeded
+ switch op {
+ case gc.OADD,
+ gc.OMUL:
+ flg &^= Frev
+ }
+
+ switch uint32(op)<<16 | (uint32(et)<<8 | uint32(flg)) {
+ case gc.OADD<<16 | (gc.TFLOAT32<<8 | 0):
+ return i386.AFADDF
+
+ case gc.OADD<<16 | (gc.TFLOAT64<<8 | 0):
+ return i386.AFADDD
+
+ case gc.OADD<<16 | (gc.TFLOAT64<<8 | Fpop):
+ return i386.AFADDDP
+
+ case gc.OSUB<<16 | (gc.TFLOAT32<<8 | 0):
+ return i386.AFSUBF
+
+ case gc.OSUB<<16 | (gc.TFLOAT32<<8 | Frev):
+ return i386.AFSUBRF
+
+ case gc.OSUB<<16 | (gc.TFLOAT64<<8 | 0):
+ return i386.AFSUBD
+
+ case gc.OSUB<<16 | (gc.TFLOAT64<<8 | Frev):
+ return i386.AFSUBRD
+
+ case gc.OSUB<<16 | (gc.TFLOAT64<<8 | Fpop):
+ return i386.AFSUBDP
+
+ case gc.OSUB<<16 | (gc.TFLOAT64<<8 | (Fpop | Frev)):
+ return i386.AFSUBRDP
+
+ case gc.OMUL<<16 | (gc.TFLOAT32<<8 | 0):
+ return i386.AFMULF
+
+ case gc.OMUL<<16 | (gc.TFLOAT64<<8 | 0):
+ return i386.AFMULD
+
+ case gc.OMUL<<16 | (gc.TFLOAT64<<8 | Fpop):
+ return i386.AFMULDP
+
+ case gc.ODIV<<16 | (gc.TFLOAT32<<8 | 0):
+ return i386.AFDIVF
+
+ case gc.ODIV<<16 | (gc.TFLOAT32<<8 | Frev):
+ return i386.AFDIVRF
+
+ case gc.ODIV<<16 | (gc.TFLOAT64<<8 | 0):
+ return i386.AFDIVD
+
+ case gc.ODIV<<16 | (gc.TFLOAT64<<8 | Frev):
+ return i386.AFDIVRD
+
+ case gc.ODIV<<16 | (gc.TFLOAT64<<8 | Fpop):
+ return i386.AFDIVDP
+
+ case gc.ODIV<<16 | (gc.TFLOAT64<<8 | (Fpop | Frev)):
+ return i386.AFDIVRDP
+
+ case gc.OCMP<<16 | (gc.TFLOAT32<<8 | 0):
+ return i386.AFCOMF
+
+ case gc.OCMP<<16 | (gc.TFLOAT32<<8 | Fpop):
+ return i386.AFCOMFP
+
+ case gc.OCMP<<16 | (gc.TFLOAT64<<8 | 0):
+ return i386.AFCOMD
+
+ case gc.OCMP<<16 | (gc.TFLOAT64<<8 | Fpop):
+ return i386.AFCOMDP
+
+ case gc.OCMP<<16 | (gc.TFLOAT64<<8 | Fpop2):
+ return i386.AFCOMDPP
+
+ case gc.OMINUS<<16 | (gc.TFLOAT32<<8 | 0):
+ return i386.AFCHS
+
+ case gc.OMINUS<<16 | (gc.TFLOAT64<<8 | 0):
+ return i386.AFCHS
+ }
+
+ gc.Fatal("foptoas %v %v %#x", gc.Oconv(int(op), 0), gc.Tconv(t, 0), flg)
+ return 0
+
+sse:
+ switch uint32(op)<<16 | uint32(et) {
+ default:
+ gc.Fatal("foptoas-sse: no entry %v-%v", gc.Oconv(int(op), 0), gc.Tconv(t, 0))
+
+ case gc.OCMP<<16 | gc.TFLOAT32:
+ a = i386.AUCOMISS
+
+ case gc.OCMP<<16 | gc.TFLOAT64:
+ a = i386.AUCOMISD
+
+ case gc.OAS<<16 | gc.TFLOAT32:
+ a = i386.AMOVSS
+
+ case gc.OAS<<16 | gc.TFLOAT64:
+ a = i386.AMOVSD
+
+ case gc.OADD<<16 | gc.TFLOAT32:
+ a = i386.AADDSS
+
+ case gc.OADD<<16 | gc.TFLOAT64:
+ a = i386.AADDSD
+
+ case gc.OSUB<<16 | gc.TFLOAT32:
+ a = i386.ASUBSS
+
+ case gc.OSUB<<16 | gc.TFLOAT64:
+ a = i386.ASUBSD
+
+ case gc.OMUL<<16 | gc.TFLOAT32:
+ a = i386.AMULSS
+
+ case gc.OMUL<<16 | gc.TFLOAT64:
+ a = i386.AMULSD
+
+ case gc.ODIV<<16 | gc.TFLOAT32:
+ a = i386.ADIVSS
+
+ case gc.ODIV<<16 | gc.TFLOAT64:
+ a = i386.ADIVSD
+ }
+
+ return a
+}
+
+var resvd = []int{
+ // REG_DI, // for movstring
+ // REG_SI, // for movstring
+
+ i386.REG_AX, // for divide
+ i386.REG_CX, // for shift
+ i386.REG_DX, // for divide
+ i386.REG_SP, // for stack
+
+ i386.REG_BL, // because REG_BX can be allocated
+ i386.REG_BH,
+}
+
+func ginit() {
+ var i int
+
+ for i = 0; i < len(reg); i++ {
+ reg[i] = 1
+ }
+ for i = i386.REG_AX; i <= i386.REG_DI; i++ {
+ reg[i] = 0
+ }
+ for i = i386.REG_X0; i <= i386.REG_X7; i++ {
+ reg[i] = 0
+ }
+ for i = 0; i < len(resvd); i++ {
+ reg[resvd[i]]++
+ }
+}
+
+var regpc [i386.MAXREG]uint32
+
+func gclean() {
+ var i int
+
+ for i = 0; i < len(resvd); i++ {
+ reg[resvd[i]]--
+ }
+
+ for i = i386.REG_AX; i <= i386.REG_DI; i++ {
+ if reg[i] != 0 {
+ gc.Yyerror("reg %v left allocated at %x", gc.Ctxt.Rconv(i), regpc[i])
+ }
+ }
+ for i = i386.REG_X0; i <= i386.REG_X7; i++ {
+ if reg[i] != 0 {
+ gc.Yyerror("reg %v left allocated\n", gc.Ctxt.Rconv(i))
+ }
+ }
+}
+
+func anyregalloc() int {
+ var i int
+ var j int
+
+ for i = i386.REG_AX; i <= i386.REG_DI; i++ {
+ if reg[i] == 0 {
+ goto ok
+ }
+ for j = 0; j < len(resvd); j++ {
+ if resvd[j] == i {
+ goto ok
+ }
+ }
+ return 1
+ ok:
+ }
+
+ for i = i386.REG_X0; i <= i386.REG_X7; i++ {
+ if reg[i] != 0 {
+ return 1
+ }
+ }
+ return 0
+}
+
+/*
+ * allocate register of type t, leave in n.
+ * if o != N, o is desired fixed register.
+ * caller must regfree(n).
+ */
+func regalloc(n *gc.Node, t *gc.Type, o *gc.Node) {
+ var i int
+ var et int
+
+ if t == nil {
+ gc.Fatal("regalloc: t nil")
+ }
+ et = int(gc.Simtype[t.Etype])
+
+ switch et {
+ case gc.TINT64,
+ gc.TUINT64:
+ gc.Fatal("regalloc64")
+ fallthrough
+
+ case gc.TINT8,
+ gc.TUINT8,
+ gc.TINT16,
+ gc.TUINT16,
+ gc.TINT32,
+ gc.TUINT32,
+ gc.TPTR32,
+ gc.TPTR64,
+ gc.TBOOL:
+ if o != nil && o.Op == gc.OREGISTER {
+ i = int(o.Val.U.Reg)
+ if i >= i386.REG_AX && i <= i386.REG_DI {
+ goto out
+ }
+ }
+
+ for i = i386.REG_AX; i <= i386.REG_DI; i++ {
+ if reg[i] == 0 {
+ goto out
+ }
+ }
+
+ fmt.Printf("registers allocated at\n")
+ for i = i386.REG_AX; i <= i386.REG_DI; i++ {
+ fmt.Printf("\t%v\t%#x\n", gc.Ctxt.Rconv(i), regpc[i])
+ }
+ gc.Fatal("out of fixed registers")
+ goto err
+
+ case gc.TFLOAT32,
+ gc.TFLOAT64:
+ if !(gc.Use_sse != 0) {
+ i = i386.REG_F0
+ goto out
+ }
+
+ if o != nil && o.Op == gc.OREGISTER {
+ i = int(o.Val.U.Reg)
+ if i >= i386.REG_X0 && i <= i386.REG_X7 {
+ goto out
+ }
+ }
+
+ for i = i386.REG_X0; i <= i386.REG_X7; i++ {
+ if reg[i] == 0 {
+ goto out
+ }
+ }
+ fmt.Printf("registers allocated at\n")
+ for i = i386.REG_X0; i <= i386.REG_X7; i++ {
+ fmt.Printf("\t%v\t%#x\n", gc.Ctxt.Rconv(i), regpc[i])
+ }
+ gc.Fatal("out of floating registers")
+ }
+
+ gc.Yyerror("regalloc: unknown type %v", gc.Tconv(t, 0))
+
+err:
+ gc.Nodreg(n, t, 0)
+ return
+
+out:
+ if i == i386.REG_SP {
+ fmt.Printf("alloc SP\n")
+ }
+ if reg[i] == 0 {
+ regpc[i] = uint32(obj.Getcallerpc(&n))
+ if i == i386.REG_AX || i == i386.REG_CX || i == i386.REG_DX || i == i386.REG_SP {
+ gc.Dump("regalloc-o", o)
+ gc.Fatal("regalloc %v", gc.Ctxt.Rconv(i))
+ }
+ }
+
+ reg[i]++
+ gc.Nodreg(n, t, i)
+}
+
+func regfree(n *gc.Node) {
+ var i int
+
+ if n.Op == gc.ONAME {
+ return
+ }
+ if n.Op != gc.OREGISTER && n.Op != gc.OINDREG {
+ gc.Fatal("regfree: not a register")
+ }
+ i = int(n.Val.U.Reg)
+ if i == i386.REG_SP {
+ return
+ }
+ if i < 0 || i >= len(reg) {
+ gc.Fatal("regfree: reg out of range")
+ }
+ if reg[i] <= 0 {
+ gc.Fatal("regfree: reg not allocated")
+ }
+ reg[i]--
+ if reg[i] == 0 && (i == i386.REG_AX || i == i386.REG_CX || i == i386.REG_DX || i == i386.REG_SP) {
+ gc.Fatal("regfree %v", gc.Ctxt.Rconv(i))
+ }
+}
+
+/*
+ * generate
+ * as $c, reg
+ */
+func gconreg(as int, c int64, reg int) {
+ var n1 gc.Node
+ var n2 gc.Node
+
+ gc.Nodconst(&n1, gc.Types[gc.TINT64], c)
+ gc.Nodreg(&n2, gc.Types[gc.TINT64], reg)
+ gins(as, &n1, &n2)
+}
+
+/*
+ * swap node contents
+ */
+func nswap(a *gc.Node, b *gc.Node) {
+ var t gc.Node
+
+ t = *a
+ *a = *b
+ *b = t
+}
+
+/*
+ * return constant i node.
+ * overwritten by next call, but useful in calls to gins.
+ */
+
+var ncon_n gc.Node
+
+func ncon(i uint32) *gc.Node {
+ if ncon_n.Type == nil {
+ gc.Nodconst(&ncon_n, gc.Types[gc.TUINT32], 0)
+ }
+ gc.Mpmovecfix(ncon_n.Val.U.Xval, int64(i))
+ return &ncon_n
+}
+
+var sclean [10]gc.Node
+
+var nsclean int
+
+/*
+ * n is a 64-bit value. fill in lo and hi to refer to its 32-bit halves.
+ */
+func split64(n *gc.Node, lo *gc.Node, hi *gc.Node) {
+ var n1 gc.Node
+ var i int64
+
+ if !(gc.Is64(n.Type) != 0) {
+ gc.Fatal("split64 %v", gc.Tconv(n.Type, 0))
+ }
+
+ if nsclean >= len(sclean) {
+ gc.Fatal("split64 clean")
+ }
+ sclean[nsclean].Op = gc.OEMPTY
+ nsclean++
+ switch n.Op {
+ default:
+ switch n.Op {
+ default:
+ if !(dotaddable(n, &n1) != 0) {
+ igen(n, &n1, nil)
+ sclean[nsclean-1] = n1
+ }
+
+ n = &n1
+
+ case gc.ONAME:
+ if n.Class == gc.PPARAMREF {
+ cgen(n.Heapaddr, &n1)
+ sclean[nsclean-1] = n1
+ n = &n1
+ }
+
+ // nothing
+ case gc.OINDREG:
+ break
+ }
+
+ *lo = *n
+ *hi = *n
+ lo.Type = gc.Types[gc.TUINT32]
+ if n.Type.Etype == gc.TINT64 {
+ hi.Type = gc.Types[gc.TINT32]
+ } else {
+ hi.Type = gc.Types[gc.TUINT32]
+ }
+ hi.Xoffset += 4
+
+ case gc.OLITERAL:
+ gc.Convconst(&n1, n.Type, &n.Val)
+ i = gc.Mpgetfix(n1.Val.U.Xval)
+ gc.Nodconst(lo, gc.Types[gc.TUINT32], int64(uint32(i)))
+ i >>= 32
+ if n.Type.Etype == gc.TINT64 {
+ gc.Nodconst(hi, gc.Types[gc.TINT32], int64(int32(i)))
+ } else {
+ gc.Nodconst(hi, gc.Types[gc.TUINT32], int64(uint32(i)))
+ }
+ }
+}
+
+func splitclean() {
+ if nsclean <= 0 {
+ gc.Fatal("splitclean")
+ }
+ nsclean--
+ if sclean[nsclean].Op != gc.OEMPTY {
+ regfree(&sclean[nsclean])
+ }
+}
+
+/*
+ * set up nodes representing fp constants
+ */
+var zerof gc.Node
+
+var two64f gc.Node
+
+var two63f gc.Node
+
+var bignodes_did int
+
+func bignodes() {
+ if bignodes_did != 0 {
+ return
+ }
+ bignodes_did = 1
+
+ two64f = *ncon(0)
+ two64f.Type = gc.Types[gc.TFLOAT64]
+ two64f.Val.Ctype = gc.CTFLT
+ two64f.Val.U.Fval = new(gc.Mpflt)
+ gc.Mpmovecflt(two64f.Val.U.Fval, 18446744073709551616.)
+
+ two63f = two64f
+ two63f.Val.U.Fval = new(gc.Mpflt)
+ gc.Mpmovecflt(two63f.Val.U.Fval, 9223372036854775808.)
+
+ zerof = two64f
+ zerof.Val.U.Fval = new(gc.Mpflt)
+ gc.Mpmovecflt(zerof.Val.U.Fval, 0)
+}
+
+func memname(n *gc.Node, t *gc.Type) {
+ gc.Tempname(n, t)
+ n.Sym = gc.Lookup("." + n.Sym.Name[1:]) // keep optimizer from registerizing
+ n.Orig.Sym = n.Sym
+}
+
+func gmove(f *gc.Node, t *gc.Node) {
+ var a int
+ var ft int
+ var tt int
+ var cvt *gc.Type
+ var r1 gc.Node
+ var r2 gc.Node
+ var flo gc.Node
+ var fhi gc.Node
+ var tlo gc.Node
+ var thi gc.Node
+ var con gc.Node
+
+ if gc.Debug['M'] != 0 {
+ fmt.Printf("gmove %v -> %v\n", gc.Nconv(f, 0), gc.Nconv(t, 0))
+ }
+
+ ft = gc.Simsimtype(f.Type)
+ tt = gc.Simsimtype(t.Type)
+ cvt = t.Type
+
+ if gc.Iscomplex[ft] != 0 || gc.Iscomplex[tt] != 0 {
+ gc.Complexmove(f, t)
+ return
+ }
+
+ if gc.Isfloat[ft] != 0 || gc.Isfloat[tt] != 0 {
+ floatmove(f, t)
+ return
+ }
+
+ // cannot have two integer memory operands;
+ // except 64-bit, which always copies via registers anyway.
+ if gc.Isint[ft] != 0 && gc.Isint[tt] != 0 && !(gc.Is64(f.Type) != 0) && !(gc.Is64(t.Type) != 0) && gc.Ismem(f) != 0 && gc.Ismem(t) != 0 {
+ goto hard
+ }
+
+ // convert constant to desired type
+ if f.Op == gc.OLITERAL {
+ gc.Convconst(&con, t.Type, &f.Val)
+ f = &con
+ ft = gc.Simsimtype(con.Type)
+ }
+
+ // value -> value copy, only one memory operand.
+ // figure out the instruction to use.
+ // break out of switch for one-instruction gins.
+ // goto rdst for "destination must be register".
+ // goto hard for "convert to cvt type first".
+ // otherwise handle and return.
+
+ switch uint32(ft)<<16 | uint32(tt) {
+ default:
+ goto fatal
+
+ /*
+ * integer copy and truncate
+ */
+ case gc.TINT8<<16 | gc.TINT8, // same size
+ gc.TINT8<<16 | gc.TUINT8,
+ gc.TUINT8<<16 | gc.TINT8,
+ gc.TUINT8<<16 | gc.TUINT8:
+ a = i386.AMOVB
+
+ case gc.TINT16<<16 | gc.TINT8, // truncate
+ gc.TUINT16<<16 | gc.TINT8,
+ gc.TINT32<<16 | gc.TINT8,
+ gc.TUINT32<<16 | gc.TINT8,
+ gc.TINT16<<16 | gc.TUINT8,
+ gc.TUINT16<<16 | gc.TUINT8,
+ gc.TINT32<<16 | gc.TUINT8,
+ gc.TUINT32<<16 | gc.TUINT8:
+ a = i386.AMOVB
+
+ goto rsrc
+
+ case gc.TINT64<<16 | gc.TINT8, // truncate low word
+ gc.TUINT64<<16 | gc.TINT8,
+ gc.TINT64<<16 | gc.TUINT8,
+ gc.TUINT64<<16 | gc.TUINT8:
+ split64(f, &flo, &fhi)
+
+ gc.Nodreg(&r1, t.Type, i386.REG_AX)
+ gmove(&flo, &r1)
+ gins(i386.AMOVB, &r1, t)
+ splitclean()
+ return
+
+ case gc.TINT16<<16 | gc.TINT16, // same size
+ gc.TINT16<<16 | gc.TUINT16,
+ gc.TUINT16<<16 | gc.TINT16,
+ gc.TUINT16<<16 | gc.TUINT16:
+ a = i386.AMOVW
+
+ case gc.TINT32<<16 | gc.TINT16, // truncate
+ gc.TUINT32<<16 | gc.TINT16,
+ gc.TINT32<<16 | gc.TUINT16,
+ gc.TUINT32<<16 | gc.TUINT16:
+ a = i386.AMOVW
+
+ goto rsrc
+
+ case gc.TINT64<<16 | gc.TINT16, // truncate low word
+ gc.TUINT64<<16 | gc.TINT16,
+ gc.TINT64<<16 | gc.TUINT16,
+ gc.TUINT64<<16 | gc.TUINT16:
+ split64(f, &flo, &fhi)
+
+ gc.Nodreg(&r1, t.Type, i386.REG_AX)
+ gmove(&flo, &r1)
+ gins(i386.AMOVW, &r1, t)
+ splitclean()
+ return
+
+ case gc.TINT32<<16 | gc.TINT32, // same size
+ gc.TINT32<<16 | gc.TUINT32,
+ gc.TUINT32<<16 | gc.TINT32,
+ gc.TUINT32<<16 | gc.TUINT32:
+ a = i386.AMOVL
+
+ case gc.TINT64<<16 | gc.TINT32, // truncate
+ gc.TUINT64<<16 | gc.TINT32,
+ gc.TINT64<<16 | gc.TUINT32,
+ gc.TUINT64<<16 | gc.TUINT32:
+ split64(f, &flo, &fhi)
+
+ gc.Nodreg(&r1, t.Type, i386.REG_AX)
+ gmove(&flo, &r1)
+ gins(i386.AMOVL, &r1, t)
+ splitclean()
+ return
+
+ case gc.TINT64<<16 | gc.TINT64, // same size
+ gc.TINT64<<16 | gc.TUINT64,
+ gc.TUINT64<<16 | gc.TINT64,
+ gc.TUINT64<<16 | gc.TUINT64:
+ split64(f, &flo, &fhi)
+
+ split64(t, &tlo, &thi)
+ if f.Op == gc.OLITERAL {
+ gins(i386.AMOVL, &flo, &tlo)
+ gins(i386.AMOVL, &fhi, &thi)
+ } else {
+ gc.Nodreg(&r1, gc.Types[gc.TUINT32], i386.REG_AX)
+ gc.Nodreg(&r2, gc.Types[gc.TUINT32], i386.REG_DX)
+ gins(i386.AMOVL, &flo, &r1)
+ gins(i386.AMOVL, &fhi, &r2)
+ gins(i386.AMOVL, &r1, &tlo)
+ gins(i386.AMOVL, &r2, &thi)
+ }
+
+ splitclean()
+ splitclean()
+ return
+
+ /*
+ * integer up-conversions
+ */
+ case gc.TINT8<<16 | gc.TINT16, // sign extend int8
+ gc.TINT8<<16 | gc.TUINT16:
+ a = i386.AMOVBWSX
+
+ goto rdst
+
+ case gc.TINT8<<16 | gc.TINT32,
+ gc.TINT8<<16 | gc.TUINT32:
+ a = i386.AMOVBLSX
+ goto rdst
+
+ case gc.TINT8<<16 | gc.TINT64, // convert via int32
+ gc.TINT8<<16 | gc.TUINT64:
+ cvt = gc.Types[gc.TINT32]
+
+ goto hard
+
+ case gc.TUINT8<<16 | gc.TINT16, // zero extend uint8
+ gc.TUINT8<<16 | gc.TUINT16:
+ a = i386.AMOVBWZX
+
+ goto rdst
+
+ case gc.TUINT8<<16 | gc.TINT32,
+ gc.TUINT8<<16 | gc.TUINT32:
+ a = i386.AMOVBLZX
+ goto rdst
+
+ case gc.TUINT8<<16 | gc.TINT64, // convert via uint32
+ gc.TUINT8<<16 | gc.TUINT64:
+ cvt = gc.Types[gc.TUINT32]
+
+ goto hard
+
+ case gc.TINT16<<16 | gc.TINT32, // sign extend int16
+ gc.TINT16<<16 | gc.TUINT32:
+ a = i386.AMOVWLSX
+
+ goto rdst
+
+ case gc.TINT16<<16 | gc.TINT64, // convert via int32
+ gc.TINT16<<16 | gc.TUINT64:
+ cvt = gc.Types[gc.TINT32]
+
+ goto hard
+
+ case gc.TUINT16<<16 | gc.TINT32, // zero extend uint16
+ gc.TUINT16<<16 | gc.TUINT32:
+ a = i386.AMOVWLZX
+
+ goto rdst
+
+ case gc.TUINT16<<16 | gc.TINT64, // convert via uint32
+ gc.TUINT16<<16 | gc.TUINT64:
+ cvt = gc.Types[gc.TUINT32]
+
+ goto hard
+
+ case gc.TINT32<<16 | gc.TINT64, // sign extend int32
+ gc.TINT32<<16 | gc.TUINT64:
+ split64(t, &tlo, &thi)
+
+ gc.Nodreg(&flo, tlo.Type, i386.REG_AX)
+ gc.Nodreg(&fhi, thi.Type, i386.REG_DX)
+ gmove(f, &flo)
+ gins(i386.ACDQ, nil, nil)
+ gins(i386.AMOVL, &flo, &tlo)
+ gins(i386.AMOVL, &fhi, &thi)
+ splitclean()
+ return
+
+ case gc.TUINT32<<16 | gc.TINT64, // zero extend uint32
+ gc.TUINT32<<16 | gc.TUINT64:
+ split64(t, &tlo, &thi)
+
+ gmove(f, &tlo)
+ gins(i386.AMOVL, ncon(0), &thi)
+ splitclean()
+ return
+ }
+
+ gins(a, f, t)
+ return
+
+ // requires register source
+rsrc:
+ regalloc(&r1, f.Type, t)
+
+ gmove(f, &r1)
+ gins(a, &r1, t)
+ regfree(&r1)
+ return
+
+ // requires register destination
+rdst:
+ regalloc(&r1, t.Type, t)
+
+ gins(a, f, &r1)
+ gmove(&r1, t)
+ regfree(&r1)
+ return
+
+ // requires register intermediate
+hard:
+ regalloc(&r1, cvt, t)
+
+ gmove(f, &r1)
+ gmove(&r1, t)
+ regfree(&r1)
+ return
+
+ // should not happen
+fatal:
+ gc.Fatal("gmove %v -> %v", gc.Nconv(f, 0), gc.Nconv(t, 0))
+}
+
+func floatmove(f *gc.Node, t *gc.Node) {
+ var r1 gc.Node
+ var r2 gc.Node
+ var t1 gc.Node
+ var t2 gc.Node
+ var tlo gc.Node
+ var thi gc.Node
+ var con gc.Node
+ var f0 gc.Node
+ var f1 gc.Node
+ var ax gc.Node
+ var dx gc.Node
+ var cx gc.Node
+ var cvt *gc.Type
+ var ft int
+ var tt int
+ var p1 *obj.Prog
+ var p2 *obj.Prog
+ var p3 *obj.Prog
+
+ ft = gc.Simsimtype(f.Type)
+ tt = gc.Simsimtype(t.Type)
+ cvt = t.Type
+
+ // cannot have two floating point memory operands.
+ if gc.Isfloat[ft] != 0 && gc.Isfloat[tt] != 0 && gc.Ismem(f) != 0 && gc.Ismem(t) != 0 {
+ goto hard
+ }
+
+ // convert constant to desired type
+ if f.Op == gc.OLITERAL {
+ gc.Convconst(&con, t.Type, &f.Val)
+ f = &con
+ ft = gc.Simsimtype(con.Type)
+
+ // some constants can't move directly to memory.
+ if gc.Ismem(t) != 0 {
+ // float constants come from memory.
+ if gc.Isfloat[tt] != 0 {
+ goto hard
+ }
+ }
+ }
+
+ // value -> value copy, only one memory operand.
+ // figure out the instruction to use.
+ // break out of switch for one-instruction gins.
+ // goto rdst for "destination must be register".
+ // goto hard for "convert to cvt type first".
+ // otherwise handle and return.
+
+ switch uint32(ft)<<16 | uint32(tt) {
+ default:
+ if gc.Use_sse != 0 {
+ floatmove_sse(f, t)
+ } else {
+ floatmove_387(f, t)
+ }
+ return
+
+ // float to very long integer.
+ case gc.TFLOAT32<<16 | gc.TINT64,
+ gc.TFLOAT64<<16 | gc.TINT64:
+ if f.Op == gc.OREGISTER {
+ cvt = f.Type
+ goto hardmem
+ }
+
+ gc.Nodreg(&r1, gc.Types[ft], i386.REG_F0)
+ if ft == gc.TFLOAT32 {
+ gins(i386.AFMOVF, f, &r1)
+ } else {
+ gins(i386.AFMOVD, f, &r1)
+ }
+
+ // set round to zero mode during conversion
+ memname(&t1, gc.Types[gc.TUINT16])
+
+ memname(&t2, gc.Types[gc.TUINT16])
+ gins(i386.AFSTCW, nil, &t1)
+ gins(i386.AMOVW, ncon(0xf7f), &t2)
+ gins(i386.AFLDCW, &t2, nil)
+ if tt == gc.TINT16 {
+ gins(i386.AFMOVWP, &r1, t)
+ } else if tt == gc.TINT32 {
+ gins(i386.AFMOVLP, &r1, t)
+ } else {
+ gins(i386.AFMOVVP, &r1, t)
+ }
+ gins(i386.AFLDCW, &t1, nil)
+ return
+
+ case gc.TFLOAT32<<16 | gc.TUINT64,
+ gc.TFLOAT64<<16 | gc.TUINT64:
+ if !(gc.Ismem(f) != 0) {
+ cvt = f.Type
+ goto hardmem
+ }
+
+ bignodes()
+ gc.Nodreg(&f0, gc.Types[ft], i386.REG_F0)
+ gc.Nodreg(&f1, gc.Types[ft], i386.REG_F0+1)
+ gc.Nodreg(&ax, gc.Types[gc.TUINT16], i386.REG_AX)
+
+ if ft == gc.TFLOAT32 {
+ gins(i386.AFMOVF, f, &f0)
+ } else {
+ gins(i386.AFMOVD, f, &f0)
+ }
+
+ // if 0 > v { answer = 0 }
+ gins(i386.AFMOVD, &zerof, &f0)
+
+ gins(i386.AFUCOMIP, &f0, &f1)
+ p1 = gc.Gbranch(optoas(gc.OGT, gc.Types[tt]), nil, 0)
+
+ // if 1<<64 <= v { answer = 0 too }
+ gins(i386.AFMOVD, &two64f, &f0)
+
+ gins(i386.AFUCOMIP, &f0, &f1)
+ p2 = gc.Gbranch(optoas(gc.OGT, gc.Types[tt]), nil, 0)
+ gc.Patch(p1, gc.Pc)
+ gins(i386.AFMOVVP, &f0, t) // don't care about t, but will pop the stack
+ split64(t, &tlo, &thi)
+ gins(i386.AMOVL, ncon(0), &tlo)
+ gins(i386.AMOVL, ncon(0), &thi)
+ splitclean()
+ p1 = gc.Gbranch(obj.AJMP, nil, 0)
+ gc.Patch(p2, gc.Pc)
+
+ // in range; algorithm is:
+ // if small enough, use native float64 -> int64 conversion.
+ // otherwise, subtract 2^63, convert, and add it back.
+
+ // set round to zero mode during conversion
+ memname(&t1, gc.Types[gc.TUINT16])
+
+ memname(&t2, gc.Types[gc.TUINT16])
+ gins(i386.AFSTCW, nil, &t1)
+ gins(i386.AMOVW, ncon(0xf7f), &t2)
+ gins(i386.AFLDCW, &t2, nil)
+
+ // actual work
+ gins(i386.AFMOVD, &two63f, &f0)
+
+ gins(i386.AFUCOMIP, &f0, &f1)
+ p2 = gc.Gbranch(optoas(gc.OLE, gc.Types[tt]), nil, 0)
+ gins(i386.AFMOVVP, &f0, t)
+ p3 = gc.Gbranch(obj.AJMP, nil, 0)
+ gc.Patch(p2, gc.Pc)
+ gins(i386.AFMOVD, &two63f, &f0)
+ gins(i386.AFSUBDP, &f0, &f1)
+ gins(i386.AFMOVVP, &f0, t)
+ split64(t, &tlo, &thi)
+ gins(i386.AXORL, ncon(0x80000000), &thi) // + 2^63
+ gc.Patch(p3, gc.Pc)
+ splitclean()
+
+ // restore rounding mode
+ gins(i386.AFLDCW, &t1, nil)
+
+ gc.Patch(p1, gc.Pc)
+ return
+
+ /*
+ * integer to float
+ */
+ case gc.TINT64<<16 | gc.TFLOAT32,
+ gc.TINT64<<16 | gc.TFLOAT64:
+ if t.Op == gc.OREGISTER {
+ goto hardmem
+ }
+ gc.Nodreg(&f0, t.Type, i386.REG_F0)
+ gins(i386.AFMOVV, f, &f0)
+ if tt == gc.TFLOAT32 {
+ gins(i386.AFMOVFP, &f0, t)
+ } else {
+ gins(i386.AFMOVDP, &f0, t)
+ }
+ return
+
+ // algorithm is:
+ // if small enough, use native int64 -> float64 conversion.
+ // otherwise, halve (rounding to odd?), convert, and double.
+ case gc.TUINT64<<16 | gc.TFLOAT32,
+ gc.TUINT64<<16 | gc.TFLOAT64:
+ gc.Nodreg(&ax, gc.Types[gc.TUINT32], i386.REG_AX)
+
+ gc.Nodreg(&dx, gc.Types[gc.TUINT32], i386.REG_DX)
+ gc.Nodreg(&cx, gc.Types[gc.TUINT32], i386.REG_CX)
+ gc.Tempname(&t1, f.Type)
+ split64(&t1, &tlo, &thi)
+ gmove(f, &t1)
+ gins(i386.ACMPL, &thi, ncon(0))
+ p1 = gc.Gbranch(i386.AJLT, nil, 0)
+
+ // native
+ gc.Nodreg(&r1, gc.Types[tt], i386.REG_F0)
+
+ gins(i386.AFMOVV, &t1, &r1)
+ if tt == gc.TFLOAT32 {
+ gins(i386.AFMOVFP, &r1, t)
+ } else {
+ gins(i386.AFMOVDP, &r1, t)
+ }
+ p2 = gc.Gbranch(obj.AJMP, nil, 0)
+
+ // simulated
+ gc.Patch(p1, gc.Pc)
+
+ gmove(&tlo, &ax)
+ gmove(&thi, &dx)
+ p1 = gins(i386.ASHRL, ncon(1), &ax)
+ p1.From.Index = i386.REG_DX // double-width shift DX -> AX
+ p1.From.Scale = 0
+ gins(i386.AMOVL, ncon(0), &cx)
+ gins(i386.ASETCC, nil, &cx)
+ gins(i386.AORL, &cx, &ax)
+ gins(i386.ASHRL, ncon(1), &dx)
+ gmove(&dx, &thi)
+ gmove(&ax, &tlo)
+ gc.Nodreg(&r1, gc.Types[tt], i386.REG_F0)
+ gc.Nodreg(&r2, gc.Types[tt], i386.REG_F0+1)
+ gins(i386.AFMOVV, &t1, &r1)
+ gins(i386.AFMOVD, &r1, &r1)
+ gins(i386.AFADDDP, &r1, &r2)
+ if tt == gc.TFLOAT32 {
+ gins(i386.AFMOVFP, &r1, t)
+ } else {
+ gins(i386.AFMOVDP, &r1, t)
+ }
+ gc.Patch(p2, gc.Pc)
+ splitclean()
+ return
+ }
+
+ // requires register intermediate
+hard:
+ regalloc(&r1, cvt, t)
+
+ gmove(f, &r1)
+ gmove(&r1, t)
+ regfree(&r1)
+ return
+
+ // requires memory intermediate
+hardmem:
+ gc.Tempname(&r1, cvt)
+
+ gmove(f, &r1)
+ gmove(&r1, t)
+ return
+}
+
+func floatmove_387(f *gc.Node, t *gc.Node) {
+ var r1 gc.Node
+ var t1 gc.Node
+ var t2 gc.Node
+ var cvt *gc.Type
+ var p1 *obj.Prog
+ var p2 *obj.Prog
+ var p3 *obj.Prog
+ var a int
+ var ft int
+ var tt int
+
+ ft = gc.Simsimtype(f.Type)
+ tt = gc.Simsimtype(t.Type)
+ cvt = t.Type
+
+ switch uint32(ft)<<16 | uint32(tt) {
+ default:
+ goto fatal
+
+ /*
+ * float to integer
+ */
+ case gc.TFLOAT32<<16 | gc.TINT16,
+ gc.TFLOAT32<<16 | gc.TINT32,
+ gc.TFLOAT32<<16 | gc.TINT64,
+ gc.TFLOAT64<<16 | gc.TINT16,
+ gc.TFLOAT64<<16 | gc.TINT32,
+ gc.TFLOAT64<<16 | gc.TINT64:
+ if t.Op == gc.OREGISTER {
+ goto hardmem
+ }
+ gc.Nodreg(&r1, gc.Types[ft], i386.REG_F0)
+ if f.Op != gc.OREGISTER {
+ if ft == gc.TFLOAT32 {
+ gins(i386.AFMOVF, f, &r1)
+ } else {
+ gins(i386.AFMOVD, f, &r1)
+ }
+ }
+
+ // set round to zero mode during conversion
+ memname(&t1, gc.Types[gc.TUINT16])
+
+ memname(&t2, gc.Types[gc.TUINT16])
+ gins(i386.AFSTCW, nil, &t1)
+ gins(i386.AMOVW, ncon(0xf7f), &t2)
+ gins(i386.AFLDCW, &t2, nil)
+ if tt == gc.TINT16 {
+ gins(i386.AFMOVWP, &r1, t)
+ } else if tt == gc.TINT32 {
+ gins(i386.AFMOVLP, &r1, t)
+ } else {
+ gins(i386.AFMOVVP, &r1, t)
+ }
+ gins(i386.AFLDCW, &t1, nil)
+ return
+
+ // convert via int32.
+ case gc.TFLOAT32<<16 | gc.TINT8,
+ gc.TFLOAT32<<16 | gc.TUINT16,
+ gc.TFLOAT32<<16 | gc.TUINT8,
+ gc.TFLOAT64<<16 | gc.TINT8,
+ gc.TFLOAT64<<16 | gc.TUINT16,
+ gc.TFLOAT64<<16 | gc.TUINT8:
+ gc.Tempname(&t1, gc.Types[gc.TINT32])
+
+ gmove(f, &t1)
+ switch tt {
+ default:
+ gc.Fatal("gmove %v", gc.Nconv(t, 0))
+ fallthrough
+
+ case gc.TINT8:
+ gins(i386.ACMPL, &t1, ncon(-0x80&(1<<32-1)))
+ p1 = gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TINT32]), nil, -1)
+ gins(i386.ACMPL, &t1, ncon(0x7f))
+ p2 = gc.Gbranch(optoas(gc.OGT, gc.Types[gc.TINT32]), nil, -1)
+ p3 = gc.Gbranch(obj.AJMP, nil, 0)
+ gc.Patch(p1, gc.Pc)
+ gc.Patch(p2, gc.Pc)
+ gmove(ncon(-0x80&(1<<32-1)), &t1)
+ gc.Patch(p3, gc.Pc)
+ gmove(&t1, t)
+
+ case gc.TUINT8:
+ gins(i386.ATESTL, ncon(0xffffff00), &t1)
+ p1 = gc.Gbranch(i386.AJEQ, nil, +1)
+ gins(i386.AMOVL, ncon(0), &t1)
+ gc.Patch(p1, gc.Pc)
+ gmove(&t1, t)
+
+ case gc.TUINT16:
+ gins(i386.ATESTL, ncon(0xffff0000), &t1)
+ p1 = gc.Gbranch(i386.AJEQ, nil, +1)
+ gins(i386.AMOVL, ncon(0), &t1)
+ gc.Patch(p1, gc.Pc)
+ gmove(&t1, t)
+ }
+
+ return
+
+ // convert via int64.
+ case gc.TFLOAT32<<16 | gc.TUINT32,
+ gc.TFLOAT64<<16 | gc.TUINT32:
+ cvt = gc.Types[gc.TINT64]
+
+ goto hardmem
+
+ /*
+ * integer to float
+ */
+ case gc.TINT16<<16 | gc.TFLOAT32,
+ gc.TINT16<<16 | gc.TFLOAT64,
+ gc.TINT32<<16 | gc.TFLOAT32,
+ gc.TINT32<<16 | gc.TFLOAT64,
+ gc.TINT64<<16 | gc.TFLOAT32,
+ gc.TINT64<<16 | gc.TFLOAT64:
+ if t.Op != gc.OREGISTER {
+ goto hard
+ }
+ if f.Op == gc.OREGISTER {
+ cvt = f.Type
+ goto hardmem
+ }
+
+ switch ft {
+ case gc.TINT16:
+ a = i386.AFMOVW
+
+ case gc.TINT32:
+ a = i386.AFMOVL
+
+ default:
+ a = i386.AFMOVV
+ }
+
+ // convert via int32 memory
+ case gc.TINT8<<16 | gc.TFLOAT32,
+ gc.TINT8<<16 | gc.TFLOAT64,
+ gc.TUINT16<<16 | gc.TFLOAT32,
+ gc.TUINT16<<16 | gc.TFLOAT64,
+ gc.TUINT8<<16 | gc.TFLOAT32,
+ gc.TUINT8<<16 | gc.TFLOAT64:
+ cvt = gc.Types[gc.TINT32]
+
+ goto hardmem
+
+ // convert via int64 memory
+ case gc.TUINT32<<16 | gc.TFLOAT32,
+ gc.TUINT32<<16 | gc.TFLOAT64:
+ cvt = gc.Types[gc.TINT64]
+
+ goto hardmem
+
+ // The way the code generator uses floating-point
+ // registers, a move from F0 to F0 is intended as a no-op.
+ // On the x86, it's not: it pushes a second copy of F0
+ // on the floating point stack. So toss it away here.
+ // Also, F0 is the *only* register we ever evaluate
+ // into, so we should only see register/register as F0/F0.
+ /*
+ * float to float
+ */
+ case gc.TFLOAT32<<16 | gc.TFLOAT32,
+ gc.TFLOAT64<<16 | gc.TFLOAT64:
+ if gc.Ismem(f) != 0 && gc.Ismem(t) != 0 {
+ goto hard
+ }
+ if f.Op == gc.OREGISTER && t.Op == gc.OREGISTER {
+ if f.Val.U.Reg != i386.REG_F0 || t.Val.U.Reg != i386.REG_F0 {
+ goto fatal
+ }
+ return
+ }
+
+ a = i386.AFMOVF
+ if ft == gc.TFLOAT64 {
+ a = i386.AFMOVD
+ }
+ if gc.Ismem(t) != 0 {
+ if f.Op != gc.OREGISTER || f.Val.U.Reg != i386.REG_F0 {
+ gc.Fatal("gmove %v", gc.Nconv(f, 0))
+ }
+ a = i386.AFMOVFP
+ if ft == gc.TFLOAT64 {
+ a = i386.AFMOVDP
+ }
+ }
+
+ case gc.TFLOAT32<<16 | gc.TFLOAT64:
+ if gc.Ismem(f) != 0 && gc.Ismem(t) != 0 {
+ goto hard
+ }
+ if f.Op == gc.OREGISTER && t.Op == gc.OREGISTER {
+ if f.Val.U.Reg != i386.REG_F0 || t.Val.U.Reg != i386.REG_F0 {
+ goto fatal
+ }
+ return
+ }
+
+ if f.Op == gc.OREGISTER {
+ gins(i386.AFMOVDP, f, t)
+ } else {
+ gins(i386.AFMOVF, f, t)
+ }
+ return
+
+ case gc.TFLOAT64<<16 | gc.TFLOAT32:
+ if gc.Ismem(f) != 0 && gc.Ismem(t) != 0 {
+ goto hard
+ }
+ if f.Op == gc.OREGISTER && t.Op == gc.OREGISTER {
+ gc.Tempname(&r1, gc.Types[gc.TFLOAT32])
+ gins(i386.AFMOVFP, f, &r1)
+ gins(i386.AFMOVF, &r1, t)
+ return
+ }
+
+ if f.Op == gc.OREGISTER {
+ gins(i386.AFMOVFP, f, t)
+ } else {
+ gins(i386.AFMOVD, f, t)
+ }
+ return
+ }
+
+ gins(a, f, t)
+ return
+
+ // requires register intermediate
+hard:
+ regalloc(&r1, cvt, t)
+
+ gmove(f, &r1)
+ gmove(&r1, t)
+ regfree(&r1)
+ return
+
+ // requires memory intermediate
+hardmem:
+ gc.Tempname(&r1, cvt)
+
+ gmove(f, &r1)
+ gmove(&r1, t)
+ return
+
+ // should not happen
+fatal:
+ gc.Fatal("gmove %v -> %v", gc.Nconv(f, obj.FmtLong), gc.Nconv(t, obj.FmtLong))
+
+ return
+}
+
+func floatmove_sse(f *gc.Node, t *gc.Node) {
+ var r1 gc.Node
+ var cvt *gc.Type
+ var a int
+ var ft int
+ var tt int
+
+ ft = gc.Simsimtype(f.Type)
+ tt = gc.Simsimtype(t.Type)
+
+ switch uint32(ft)<<16 | uint32(tt) {
+ // should not happen
+ default:
+ gc.Fatal("gmove %v -> %v", gc.Nconv(f, 0), gc.Nconv(t, 0))
+
+ return
+
+ // convert via int32.
+ /*
+ * float to integer
+ */
+ case gc.TFLOAT32<<16 | gc.TINT16,
+ gc.TFLOAT32<<16 | gc.TINT8,
+ gc.TFLOAT32<<16 | gc.TUINT16,
+ gc.TFLOAT32<<16 | gc.TUINT8,
+ gc.TFLOAT64<<16 | gc.TINT16,
+ gc.TFLOAT64<<16 | gc.TINT8,
+ gc.TFLOAT64<<16 | gc.TUINT16,
+ gc.TFLOAT64<<16 | gc.TUINT8:
+ cvt = gc.Types[gc.TINT32]
+
+ goto hard
+
+ // convert via int64.
+ case gc.TFLOAT32<<16 | gc.TUINT32,
+ gc.TFLOAT64<<16 | gc.TUINT32:
+ cvt = gc.Types[gc.TINT64]
+
+ goto hardmem
+
+ case gc.TFLOAT32<<16 | gc.TINT32:
+ a = i386.ACVTTSS2SL
+ goto rdst
+
+ case gc.TFLOAT64<<16 | gc.TINT32:
+ a = i386.ACVTTSD2SL
+ goto rdst
+
+ // convert via int32 memory
+ /*
+ * integer to float
+ */
+ case gc.TINT8<<16 | gc.TFLOAT32,
+ gc.TINT8<<16 | gc.TFLOAT64,
+ gc.TINT16<<16 | gc.TFLOAT32,
+ gc.TINT16<<16 | gc.TFLOAT64,
+ gc.TUINT16<<16 | gc.TFLOAT32,
+ gc.TUINT16<<16 | gc.TFLOAT64,
+ gc.TUINT8<<16 | gc.TFLOAT32,
+ gc.TUINT8<<16 | gc.TFLOAT64:
+ cvt = gc.Types[gc.TINT32]
+
+ goto hard
+
+ // convert via int64 memory
+ case gc.TUINT32<<16 | gc.TFLOAT32,
+ gc.TUINT32<<16 | gc.TFLOAT64:
+ cvt = gc.Types[gc.TINT64]
+
+ goto hardmem
+
+ case gc.TINT32<<16 | gc.TFLOAT32:
+ a = i386.ACVTSL2SS
+ goto rdst
+
+ case gc.TINT32<<16 | gc.TFLOAT64:
+ a = i386.ACVTSL2SD
+ goto rdst
+
+ /*
+ * float to float
+ */
+ case gc.TFLOAT32<<16 | gc.TFLOAT32:
+ a = i386.AMOVSS
+
+ case gc.TFLOAT64<<16 | gc.TFLOAT64:
+ a = i386.AMOVSD
+
+ case gc.TFLOAT32<<16 | gc.TFLOAT64:
+ a = i386.ACVTSS2SD
+ goto rdst
+
+ case gc.TFLOAT64<<16 | gc.TFLOAT32:
+ a = i386.ACVTSD2SS
+ goto rdst
+ }
+
+ gins(a, f, t)
+ return
+
+ // requires register intermediate
+hard:
+ regalloc(&r1, cvt, t)
+
+ gmove(f, &r1)
+ gmove(&r1, t)
+ regfree(&r1)
+ return
+
+ // requires memory intermediate
+hardmem:
+ gc.Tempname(&r1, cvt)
+
+ gmove(f, &r1)
+ gmove(&r1, t)
+ return
+
+ // requires register destination
+rdst:
+ regalloc(&r1, t.Type, t)
+
+ gins(a, f, &r1)
+ gmove(&r1, t)
+ regfree(&r1)
+ return
+}
+
+func samaddr(f *gc.Node, t *gc.Node) int {
+ if f.Op != t.Op {
+ return 0
+ }
+
+ switch f.Op {
+ case gc.OREGISTER:
+ if f.Val.U.Reg != t.Val.U.Reg {
+ break
+ }
+ return 1
+ }
+
+ return 0
+}
+
+/*
+ * generate one instruction:
+ * as f, t
+ */
+func gins(as int, f *gc.Node, t *gc.Node) *obj.Prog {
+ var p *obj.Prog
+ var af obj.Addr
+ var at obj.Addr
+ var w int
+
+ if as == i386.AFMOVF && f != nil && f.Op == gc.OREGISTER && t != nil && t.Op == gc.OREGISTER {
+ gc.Fatal("gins MOVF reg, reg")
+ }
+ if as == i386.ACVTSD2SS && f != nil && f.Op == gc.OLITERAL {
+ gc.Fatal("gins CVTSD2SS const")
+ }
+ if as == i386.AMOVSD && t != nil && t.Op == gc.OREGISTER && t.Val.U.Reg == i386.REG_F0 {
+ gc.Fatal("gins MOVSD into F0")
+ }
+
+ switch as {
+ case i386.AMOVB,
+ i386.AMOVW,
+ i386.AMOVL:
+ if f != nil && t != nil && samaddr(f, t) != 0 {
+ return nil
+ }
+
+ case i386.ALEAL:
+ if f != nil && gc.Isconst(f, gc.CTNIL) != 0 {
+ gc.Fatal("gins LEAL nil %v", gc.Tconv(f.Type, 0))
+ }
+ }
+
+ af = obj.Addr{}
+ at = obj.Addr{}
+ if f != nil {
+ gc.Naddr(f, &af, 1)
+ }
+ if t != nil {
+ gc.Naddr(t, &at, 1)
+ }
+ p = gc.Prog(as)
+ if f != nil {
+ p.From = af
+ }
+ if t != nil {
+ p.To = at
+ }
+ if gc.Debug['g'] != 0 {
+ fmt.Printf("%v\n", p)
+ }
+
+ w = 0
+ switch as {
+ case i386.AMOVB:
+ w = 1
+
+ case i386.AMOVW:
+ w = 2
+
+ case i386.AMOVL:
+ w = 4
+ }
+
+ if true && w != 0 && f != nil && (af.Width > int64(w) || at.Width > int64(w)) {
+ gc.Dump("bad width from:", f)
+ gc.Dump("bad width to:", t)
+ gc.Fatal("bad width: %v (%d, %d)\n", p, af.Width, at.Width)
+ }
+
+ if p.To.Type == obj.TYPE_ADDR && w > 0 {
+ gc.Fatal("bad use of addr: %v", p)
+ }
+
+ return p
+}
+
+func dotaddable(n *gc.Node, n1 *gc.Node) int {
+ var o int
+ var oary [10]int64
+ var nn *gc.Node
+
+ if n.Op != gc.ODOT {
+ return 0
+ }
+
+ o = gc.Dotoffset(n, oary[:], &nn)
+ if nn != nil && nn.Addable != 0 && o == 1 && oary[0] >= 0 {
+ *n1 = *nn
+ n1.Type = n.Type
+ n1.Xoffset += oary[0]
+ return 1
+ }
+
+ return 0
+}
+
+func sudoclean() {
+}
+
+func sudoaddable(as int, n *gc.Node, a *obj.Addr) int {
+ *a = obj.Addr{}
+ return 0
+}
--- /dev/null
+// Derived from Inferno utils/6c/peep.c
+// http://code.google.com/p/inferno-os/source/browse/utils/6c/peep.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 main
+
+import (
+ "cmd/internal/obj"
+ "cmd/internal/obj/i386"
+ "fmt"
+)
+import "cmd/internal/gc"
+
+const (
+ REGEXT = 0
+ exregoffset = i386.REG_DI
+)
+
+var gactive uint32
+
+// do we need the carry bit
+func needc(p *obj.Prog) int {
+ var info gc.ProgInfo
+
+ for p != nil {
+ proginfo(&info, p)
+ if info.Flags&gc.UseCarry != 0 {
+ return 1
+ }
+ if info.Flags&(gc.SetCarry|gc.KillCarry) != 0 {
+ return 0
+ }
+ p = p.Link
+ }
+
+ return 0
+}
+
+func rnops(r *gc.Flow) *gc.Flow {
+ var p *obj.Prog
+ var r1 *gc.Flow
+
+ if r != nil {
+ for {
+ p = r.Prog
+ if p.As != obj.ANOP || p.From.Type != obj.TYPE_NONE || p.To.Type != obj.TYPE_NONE {
+ break
+ }
+ r1 = gc.Uniqs(r)
+ if r1 == nil {
+ break
+ }
+ r = r1
+ }
+ }
+
+ return r
+}
+
+func peep(firstp *obj.Prog) {
+ var r *gc.Flow
+ var r1 *gc.Flow
+ var g *gc.Graph
+ var p *obj.Prog
+ var p1 *obj.Prog
+ var t int
+
+ g = gc.Flowstart(firstp, nil)
+ if g == nil {
+ return
+ }
+ gactive = 0
+
+ // byte, word arithmetic elimination.
+ elimshortmov(g)
+
+ // constant propagation
+ // find MOV $con,R followed by
+ // another MOV $con,R without
+ // setting R in the interim
+ for r = g.Start; r != nil; r = r.Link {
+ p = r.Prog
+ switch p.As {
+ case i386.ALEAL:
+ if regtyp(&p.To) != 0 {
+ if p.From.Sym != nil {
+ if p.From.Index == i386.REG_NONE {
+ conprop(r)
+ }
+ }
+ }
+
+ case i386.AMOVB,
+ i386.AMOVW,
+ i386.AMOVL,
+ i386.AMOVSS,
+ i386.AMOVSD:
+ if regtyp(&p.To) != 0 {
+ if p.From.Type == obj.TYPE_CONST || p.From.Type == obj.TYPE_FCONST {
+ conprop(r)
+ }
+ }
+ }
+ }
+
+loop1:
+ if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 {
+ gc.Dumpit("loop1", g.Start, 0)
+ }
+
+ t = 0
+ for r = g.Start; r != nil; r = r.Link {
+ p = r.Prog
+ switch p.As {
+ case i386.AMOVL,
+ i386.AMOVSS,
+ i386.AMOVSD:
+ if regtyp(&p.To) != 0 {
+ if regtyp(&p.From) != 0 {
+ if copyprop(g, r) != 0 {
+ excise(r)
+ t++
+ } else if subprop(r) != 0 && copyprop(g, r) != 0 {
+ excise(r)
+ t++
+ }
+ }
+ }
+
+ case i386.AMOVBLZX,
+ i386.AMOVWLZX,
+ i386.AMOVBLSX,
+ i386.AMOVWLSX:
+ if regtyp(&p.To) != 0 {
+ r1 = rnops(gc.Uniqs(r))
+ if r1 != nil {
+ p1 = r1.Prog
+ if p.As == p1.As && p.To.Type == p1.From.Type && p.To.Reg == p1.From.Reg {
+ p1.As = i386.AMOVL
+ t++
+ }
+ }
+ }
+
+ case i386.AADDL,
+ i386.AADDW:
+ if p.From.Type != obj.TYPE_CONST || needc(p.Link) != 0 {
+ break
+ }
+ if p.From.Offset == -1 {
+ if p.As == i386.AADDL {
+ p.As = i386.ADECL
+ } else {
+ p.As = i386.ADECW
+ }
+ p.From = obj.Zprog.From
+ break
+ }
+
+ if p.From.Offset == 1 {
+ if p.As == i386.AADDL {
+ p.As = i386.AINCL
+ } else {
+ p.As = i386.AINCW
+ }
+ p.From = obj.Zprog.From
+ break
+ }
+
+ case i386.ASUBL,
+ i386.ASUBW:
+ if p.From.Type != obj.TYPE_CONST || needc(p.Link) != 0 {
+ break
+ }
+ if p.From.Offset == -1 {
+ if p.As == i386.ASUBL {
+ p.As = i386.AINCL
+ } else {
+ p.As = i386.AINCW
+ }
+ p.From = obj.Zprog.From
+ break
+ }
+
+ if p.From.Offset == 1 {
+ if p.As == i386.ASUBL {
+ p.As = i386.ADECL
+ } else {
+ p.As = i386.ADECW
+ }
+ p.From = obj.Zprog.From
+ break
+ }
+ }
+ }
+
+ if t != 0 {
+ goto loop1
+ }
+
+ // MOVSD removal.
+ // We never use packed registers, so a MOVSD between registers
+ // can be replaced by MOVAPD, which moves the pair of float64s
+ // instead of just the lower one. We only use the lower one, but
+ // the processor can do better if we do moves using both.
+ for r = g.Start; r != nil; r = r.Link {
+ p = r.Prog
+ if p.As == i386.AMOVSD {
+ if regtyp(&p.From) != 0 {
+ if regtyp(&p.To) != 0 {
+ p.As = i386.AMOVAPD
+ }
+ }
+ }
+ }
+
+ gc.Flowend(g)
+}
+
+func excise(r *gc.Flow) {
+ var p *obj.Prog
+
+ p = r.Prog
+ if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 {
+ fmt.Printf("%v ===delete===\n", p)
+ }
+
+ obj.Nopout(p)
+
+ gc.Ostats.Ndelmov++
+}
+
+func regtyp(a *obj.Addr) int {
+ return bool2int(a.Type == obj.TYPE_REG && (i386.REG_AX <= a.Reg && a.Reg <= i386.REG_DI || i386.REG_X0 <= a.Reg && a.Reg <= i386.REG_X7))
+}
+
+// movb elimination.
+// movb is simulated by the linker
+// when a register other than ax, bx, cx, dx
+// is used, so rewrite to other instructions
+// when possible. a movb into a register
+// can smash the entire 64-bit register without
+// causing any trouble.
+func elimshortmov(g *gc.Graph) {
+ var p *obj.Prog
+ var r *gc.Flow
+
+ for r = g.Start; r != nil; r = r.Link {
+ p = r.Prog
+ if regtyp(&p.To) != 0 {
+ switch p.As {
+ case i386.AINCB,
+ i386.AINCW:
+ p.As = i386.AINCL
+
+ case i386.ADECB,
+ i386.ADECW:
+ p.As = i386.ADECL
+
+ case i386.ANEGB,
+ i386.ANEGW:
+ p.As = i386.ANEGL
+
+ case i386.ANOTB,
+ i386.ANOTW:
+ p.As = i386.ANOTL
+ }
+
+ if regtyp(&p.From) != 0 || p.From.Type == obj.TYPE_CONST {
+ // move or artihmetic into partial register.
+ // from another register or constant can be movl.
+ // we don't switch to 32-bit arithmetic if it can
+ // change how the carry bit is set (and the carry bit is needed).
+ switch p.As {
+ case i386.AMOVB,
+ i386.AMOVW:
+ p.As = i386.AMOVL
+
+ case i386.AADDB,
+ i386.AADDW:
+ if !(needc(p.Link) != 0) {
+ p.As = i386.AADDL
+ }
+
+ case i386.ASUBB,
+ i386.ASUBW:
+ if !(needc(p.Link) != 0) {
+ p.As = i386.ASUBL
+ }
+
+ case i386.AMULB,
+ i386.AMULW:
+ p.As = i386.AMULL
+
+ case i386.AIMULB,
+ i386.AIMULW:
+ p.As = i386.AIMULL
+
+ case i386.AANDB,
+ i386.AANDW:
+ p.As = i386.AANDL
+
+ case i386.AORB,
+ i386.AORW:
+ p.As = i386.AORL
+
+ case i386.AXORB,
+ i386.AXORW:
+ p.As = i386.AXORL
+
+ case i386.ASHLB,
+ i386.ASHLW:
+ p.As = i386.ASHLL
+ }
+ } else {
+ // explicit zero extension
+ switch p.As {
+ case i386.AMOVB:
+ p.As = i386.AMOVBLZX
+
+ case i386.AMOVW:
+ p.As = i386.AMOVWLZX
+ }
+ }
+ }
+ }
+}
+
+/*
+ * the idea is to substitute
+ * one register for another
+ * from one MOV to another
+ * MOV a, R0
+ * ADD b, R0 / no use of R1
+ * MOV R0, R1
+ * would be converted to
+ * MOV a, R1
+ * ADD b, R1
+ * MOV R1, R0
+ * hopefully, then the former or latter MOV
+ * will be eliminated by copy propagation.
+ */
+func subprop(r0 *gc.Flow) int {
+ var p *obj.Prog
+ var v1 *obj.Addr
+ var v2 *obj.Addr
+ var r *gc.Flow
+ var t int
+ var info gc.ProgInfo
+
+ p = r0.Prog
+ v1 = &p.From
+ if !(regtyp(v1) != 0) {
+ return 0
+ }
+ v2 = &p.To
+ if !(regtyp(v2) != 0) {
+ return 0
+ }
+ for r = gc.Uniqp(r0); r != nil; r = gc.Uniqp(r) {
+ if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 {
+ fmt.Printf("\t? %v\n", r.Prog)
+ }
+ if gc.Uniqs(r) == nil {
+ break
+ }
+ p = r.Prog
+ if p.As == obj.AVARDEF || p.As == obj.AVARKILL {
+ continue
+ }
+ proginfo(&info, p)
+ if info.Flags&gc.Call != 0 {
+ return 0
+ }
+
+ if info.Reguse|info.Regset != 0 {
+ return 0
+ }
+
+ if (info.Flags&gc.Move != 0) && (info.Flags&(gc.SizeL|gc.SizeQ|gc.SizeF|gc.SizeD) != 0) && p.To.Type == v1.Type && p.To.Reg == v1.Reg {
+ goto gotit
+ }
+
+ if copyau(&p.From, v2) != 0 || copyau(&p.To, v2) != 0 {
+ break
+ }
+ if copysub(&p.From, v1, v2, 0) != 0 || copysub(&p.To, v1, v2, 0) != 0 {
+ break
+ }
+ }
+
+ return 0
+
+gotit:
+ copysub(&p.To, v1, v2, 1)
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("gotit: %v->%v\n%v", gc.Ctxt.Dconv(v1), gc.Ctxt.Dconv(v2), r.Prog)
+ if p.From.Type == v2.Type && p.From.Reg == v2.Reg {
+ fmt.Printf(" excise")
+ }
+ fmt.Printf("\n")
+ }
+
+ for r = gc.Uniqs(r); r != r0; r = gc.Uniqs(r) {
+ p = r.Prog
+ copysub(&p.From, v1, v2, 1)
+ copysub(&p.To, v1, v2, 1)
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("%v\n", r.Prog)
+ }
+ }
+
+ t = int(v1.Reg)
+ v1.Reg = v2.Reg
+ v2.Reg = int16(t)
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("%v last\n", r.Prog)
+ }
+ return 1
+}
+
+/*
+ * The idea is to remove redundant copies.
+ * v1->v2 F=0
+ * (use v2 s/v2/v1/)*
+ * set v1 F=1
+ * use v2 return fail
+ * -----------------
+ * v1->v2 F=0
+ * (use v2 s/v2/v1/)*
+ * set v1 F=1
+ * set v2 return success
+ */
+func copyprop(g *gc.Graph, r0 *gc.Flow) int {
+ var p *obj.Prog
+ var v1 *obj.Addr
+ var v2 *obj.Addr
+
+ p = r0.Prog
+ v1 = &p.From
+ v2 = &p.To
+ if copyas(v1, v2) != 0 {
+ return 1
+ }
+ gactive++
+ return copy1(v1, v2, r0.S1, 0)
+}
+
+func copy1(v1 *obj.Addr, v2 *obj.Addr, r *gc.Flow, f int) int {
+ var t int
+ var p *obj.Prog
+
+ if uint32(r.Active) == gactive {
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("act set; return 1\n")
+ }
+ return 1
+ }
+
+ r.Active = int32(gactive)
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("copy %v->%v f=%d\n", gc.Ctxt.Dconv(v1), gc.Ctxt.Dconv(v2), f)
+ }
+ for ; r != nil; r = r.S1 {
+ p = r.Prog
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("%v", p)
+ }
+ if !(f != 0) && gc.Uniqp(r) == nil {
+ f = 1
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("; merge; f=%d", f)
+ }
+ }
+
+ t = copyu(p, v2, nil)
+ switch t {
+ case 2: /* rar, can't split */
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("; %v rar; return 0\n", gc.Ctxt.Dconv(v2))
+ }
+ return 0
+
+ case 3: /* set */
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("; %v set; return 1\n", gc.Ctxt.Dconv(v2))
+ }
+ return 1
+
+ case 1, /* used, substitute */
+ 4: /* use and set */
+ if f != 0 {
+ if !(gc.Debug['P'] != 0) {
+ return 0
+ }
+ if t == 4 {
+ fmt.Printf("; %v used+set and f=%d; return 0\n", gc.Ctxt.Dconv(v2), f)
+ } else {
+ fmt.Printf("; %v used and f=%d; return 0\n", gc.Ctxt.Dconv(v2), f)
+ }
+ return 0
+ }
+
+ if copyu(p, v2, v1) != 0 {
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("; sub fail; return 0\n")
+ }
+ return 0
+ }
+
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("; sub %v/%v", gc.Ctxt.Dconv(v2), gc.Ctxt.Dconv(v1))
+ }
+ if t == 4 {
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("; %v used+set; return 1\n", gc.Ctxt.Dconv(v2))
+ }
+ return 1
+ }
+ }
+
+ if !(f != 0) {
+ t = copyu(p, v1, nil)
+ if !(f != 0) && (t == 2 || t == 3 || t == 4) {
+ f = 1
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("; %v set and !f; f=%d", gc.Ctxt.Dconv(v1), f)
+ }
+ }
+ }
+
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("\n")
+ }
+ if r.S2 != nil {
+ if !(copy1(v1, v2, r.S2, f) != 0) {
+ return 0
+ }
+ }
+ }
+
+ return 1
+}
+
+/*
+ * return
+ * 1 if v only used (and substitute),
+ * 2 if read-alter-rewrite
+ * 3 if set
+ * 4 if set and used
+ * 0 otherwise (not touched)
+ */
+func copyu(p *obj.Prog, v *obj.Addr, s *obj.Addr) int {
+ var info gc.ProgInfo
+
+ switch p.As {
+ case obj.AJMP:
+ if s != nil {
+ if copysub(&p.To, v, s, 1) != 0 {
+ return 1
+ }
+ return 0
+ }
+
+ if copyau(&p.To, v) != 0 {
+ return 1
+ }
+ return 0
+
+ case obj.ARET:
+ if s != nil {
+ return 1
+ }
+ return 3
+
+ case obj.ACALL:
+ if REGEXT != 0 /*TypeKind(100016)*/ && v.Type == obj.TYPE_REG && v.Reg <= REGEXT && v.Reg > exregoffset {
+ return 2
+ }
+ if i386.REGARG >= 0 && v.Type == obj.TYPE_REG && v.Reg == i386.REGARG {
+ return 2
+ }
+ if v.Type == p.From.Type && v.Reg == p.From.Reg {
+ return 2
+ }
+
+ if s != nil {
+ if copysub(&p.To, v, s, 1) != 0 {
+ return 1
+ }
+ return 0
+ }
+
+ if copyau(&p.To, v) != 0 {
+ return 4
+ }
+ return 3
+
+ case obj.ATEXT:
+ if i386.REGARG >= 0 && v.Type == obj.TYPE_REG && v.Reg == i386.REGARG {
+ return 3
+ }
+ return 0
+ }
+
+ if p.As == obj.AVARDEF || p.As == obj.AVARKILL {
+ return 0
+ }
+ proginfo(&info, p)
+
+ if (info.Reguse|info.Regset)&RtoB(int(v.Reg)) != 0 {
+ return 2
+ }
+
+ if info.Flags&gc.LeftAddr != 0 {
+ if copyas(&p.From, v) != 0 {
+ return 2
+ }
+ }
+
+ if info.Flags&(gc.RightRead|gc.RightWrite) == gc.RightRead|gc.RightWrite {
+ if copyas(&p.To, v) != 0 {
+ return 2
+ }
+ }
+
+ if info.Flags&gc.RightWrite != 0 {
+ if copyas(&p.To, v) != 0 {
+ if s != nil {
+ return copysub(&p.From, v, s, 1)
+ }
+ if copyau(&p.From, v) != 0 {
+ return 4
+ }
+ return 3
+ }
+ }
+
+ if info.Flags&(gc.LeftAddr|gc.LeftRead|gc.LeftWrite|gc.RightAddr|gc.RightRead|gc.RightWrite) != 0 {
+ if s != nil {
+ if copysub(&p.From, v, s, 1) != 0 {
+ return 1
+ }
+ return copysub(&p.To, v, s, 1)
+ }
+
+ if copyau(&p.From, v) != 0 {
+ return 1
+ }
+ if copyau(&p.To, v) != 0 {
+ return 1
+ }
+ }
+
+ return 0
+}
+
+/*
+ * direct reference,
+ * could be set/use depending on
+ * semantics
+ */
+func copyas(a *obj.Addr, v *obj.Addr) int {
+ if i386.REG_AL <= a.Reg && a.Reg <= i386.REG_BL {
+ gc.Fatal("use of byte register")
+ }
+ if i386.REG_AL <= v.Reg && v.Reg <= i386.REG_BL {
+ gc.Fatal("use of byte register")
+ }
+
+ if a.Type != v.Type || a.Name != v.Name || a.Reg != v.Reg {
+ return 0
+ }
+ if regtyp(v) != 0 {
+ return 1
+ }
+ if v.Type == obj.TYPE_MEM && (v.Name == obj.NAME_AUTO || v.Name == obj.NAME_PARAM) {
+ if v.Offset == a.Offset {
+ return 1
+ }
+ }
+ return 0
+}
+
+func sameaddr(a *obj.Addr, v *obj.Addr) int {
+ if a.Type != v.Type || a.Name != v.Name || a.Reg != v.Reg {
+ return 0
+ }
+ if regtyp(v) != 0 {
+ return 1
+ }
+ if v.Type == obj.TYPE_MEM && (v.Name == obj.NAME_AUTO || v.Name == obj.NAME_PARAM) {
+ if v.Offset == a.Offset {
+ return 1
+ }
+ }
+ return 0
+}
+
+/*
+ * either direct or indirect
+ */
+func copyau(a *obj.Addr, v *obj.Addr) int {
+ if copyas(a, v) != 0 {
+ return 1
+ }
+ if regtyp(v) != 0 {
+ if a.Type == obj.TYPE_MEM && a.Reg == v.Reg {
+ return 1
+ }
+ if a.Index == v.Reg {
+ return 1
+ }
+ }
+
+ return 0
+}
+
+/*
+ * substitute s for v in a
+ * return failure to substitute
+ */
+func copysub(a *obj.Addr, v *obj.Addr, s *obj.Addr, f int) int {
+ var reg int
+
+ if copyas(a, v) != 0 {
+ reg = int(s.Reg)
+ if reg >= i386.REG_AX && reg <= i386.REG_DI || reg >= i386.REG_X0 && reg <= i386.REG_X7 {
+ if f != 0 {
+ a.Reg = int16(reg)
+ }
+ }
+
+ return 0
+ }
+
+ if regtyp(v) != 0 {
+ reg = int(v.Reg)
+ if a.Type == obj.TYPE_MEM && int(a.Reg) == reg {
+ if (s.Reg == i386.REG_BP) && a.Index != obj.TYPE_NONE {
+ return 1 /* can't use BP-base with index */
+ }
+ if f != 0 {
+ a.Reg = s.Reg
+ }
+ }
+
+ // return 0;
+ if int(a.Index) == reg {
+ if f != 0 {
+ a.Index = s.Reg
+ }
+ return 0
+ }
+
+ return 0
+ }
+
+ return 0
+}
+
+func conprop(r0 *gc.Flow) {
+ var r *gc.Flow
+ var p *obj.Prog
+ var p0 *obj.Prog
+ var t int
+ var v0 *obj.Addr
+
+ p0 = r0.Prog
+ v0 = &p0.To
+ r = r0
+
+loop:
+ r = gc.Uniqs(r)
+ if r == nil || r == r0 {
+ return
+ }
+ if gc.Uniqp(r) == nil {
+ return
+ }
+
+ p = r.Prog
+ t = copyu(p, v0, nil)
+ switch t {
+ case 0, // miss
+ 1: // use
+ goto loop
+
+ case 2, // rar
+ 4: // use and set
+ break
+
+ case 3: // set
+ if p.As == p0.As {
+ if p.From.Type == p0.From.Type {
+ if p.From.Reg == p0.From.Reg {
+ if p.From.Node == p0.From.Node {
+ if p.From.Offset == p0.From.Offset {
+ if p.From.Scale == p0.From.Scale {
+ if p.From.Type == obj.TYPE_FCONST && p.From.U.Dval == p0.From.U.Dval {
+ if p.From.Index == p0.From.Index {
+ excise(r)
+ goto loop
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+}
+
+func smallindir(a *obj.Addr, reg *obj.Addr) int {
+ return bool2int(regtyp(reg) != 0 && a.Type == obj.TYPE_MEM && a.Reg == reg.Reg && a.Index == i386.REG_NONE && 0 <= a.Offset && a.Offset < 4096)
+}
+
+func stackaddr(a *obj.Addr) int {
+ return bool2int(a.Type == obj.TYPE_REG && a.Reg == i386.REG_SP)
+}
--- /dev/null
+// 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 main
+
+import (
+ "cmd/internal/obj"
+ "cmd/internal/obj/i386"
+)
+import "cmd/internal/gc"
+
+var (
+ AX = RtoB(i386.REG_AX)
+ BX = RtoB(i386.REG_BX)
+ CX = RtoB(i386.REG_CX)
+ DX = RtoB(i386.REG_DX)
+ DI = RtoB(i386.REG_DI)
+ SI = RtoB(i386.REG_SI)
+ LeftRdwr uint32 = gc.LeftRead | gc.LeftWrite
+ RightRdwr uint32 = gc.RightRead | gc.RightWrite
+)
+
+// This table gives the basic information about instruction
+// generated by the compiler and processed in the optimizer.
+// See opt.h for bit definitions.
+//
+// Instructions not generated need not be listed.
+// As an exception to that rule, we typically write down all the
+// size variants of an operation even if we just use a subset.
+//
+// The table is formatted for 8-space tabs.
+var progtable = [i386.ALAST]gc.ProgInfo{
+ obj.ATYPE: gc.ProgInfo{gc.Pseudo | gc.Skip, 0, 0, 0},
+ obj.ATEXT: gc.ProgInfo{gc.Pseudo, 0, 0, 0},
+ obj.AFUNCDATA: gc.ProgInfo{gc.Pseudo, 0, 0, 0},
+ obj.APCDATA: gc.ProgInfo{gc.Pseudo, 0, 0, 0},
+ obj.AUNDEF: gc.ProgInfo{gc.Break, 0, 0, 0},
+ obj.AUSEFIELD: gc.ProgInfo{gc.OK, 0, 0, 0},
+ obj.ACHECKNIL: gc.ProgInfo{gc.LeftRead, 0, 0, 0},
+ obj.AVARDEF: gc.ProgInfo{gc.Pseudo | gc.RightWrite, 0, 0, 0},
+ obj.AVARKILL: gc.ProgInfo{gc.Pseudo | gc.RightWrite, 0, 0, 0},
+
+ // NOP is an internal no-op that also stands
+ // for USED and SET annotations, not the Intel opcode.
+ obj.ANOP: gc.ProgInfo{gc.LeftRead | gc.RightWrite, 0, 0, 0},
+ i386.AADCL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ i386.AADCW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ i386.AADDB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ i386.AADDL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ i386.AADDW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ i386.AADDSD: gc.ProgInfo{gc.SizeD | gc.LeftRead | RightRdwr, 0, 0, 0},
+ i386.AADDSS: gc.ProgInfo{gc.SizeF | gc.LeftRead | RightRdwr, 0, 0, 0},
+ i386.AANDB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ i386.AANDL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ i386.AANDW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ obj.ACALL: gc.ProgInfo{gc.RightAddr | gc.Call | gc.KillCarry, 0, 0, 0},
+ i386.ACDQ: gc.ProgInfo{gc.OK, AX, AX | DX, 0},
+ i386.ACWD: gc.ProgInfo{gc.OK, AX, AX | DX, 0},
+ i386.ACLD: gc.ProgInfo{gc.OK, 0, 0, 0},
+ i386.ASTD: gc.ProgInfo{gc.OK, 0, 0, 0},
+ i386.ACMPB: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0},
+ i386.ACMPL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0},
+ i386.ACMPW: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0},
+ i386.ACOMISD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0},
+ i386.ACOMISS: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0},
+ i386.ACVTSD2SL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ i386.ACVTSD2SS: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ i386.ACVTSL2SD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ i386.ACVTSL2SS: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ i386.ACVTSS2SD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ i386.ACVTSS2SL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ i386.ACVTTSD2SL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ i386.ACVTTSS2SL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ i386.ADECB: gc.ProgInfo{gc.SizeB | RightRdwr, 0, 0, 0},
+ i386.ADECL: gc.ProgInfo{gc.SizeL | RightRdwr, 0, 0, 0},
+ i386.ADECW: gc.ProgInfo{gc.SizeW | RightRdwr, 0, 0, 0},
+ i386.ADIVB: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.SetCarry, AX, AX, 0},
+ i386.ADIVL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.SetCarry, AX | DX, AX | DX, 0},
+ i386.ADIVW: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.SetCarry, AX | DX, AX | DX, 0},
+ i386.ADIVSD: gc.ProgInfo{gc.SizeD | gc.LeftRead | RightRdwr, 0, 0, 0},
+ i386.ADIVSS: gc.ProgInfo{gc.SizeF | gc.LeftRead | RightRdwr, 0, 0, 0},
+ i386.AFLDCW: gc.ProgInfo{gc.SizeW | gc.LeftAddr, 0, 0, 0},
+ i386.AFSTCW: gc.ProgInfo{gc.SizeW | gc.RightAddr, 0, 0, 0},
+ i386.AFSTSW: gc.ProgInfo{gc.SizeW | gc.RightAddr | gc.RightWrite, 0, 0, 0},
+ i386.AFADDD: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ i386.AFADDDP: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ i386.AFADDF: gc.ProgInfo{gc.SizeF | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ i386.AFCOMD: gc.ProgInfo{gc.SizeD | gc.LeftAddr | gc.RightRead, 0, 0, 0},
+ i386.AFCOMDP: gc.ProgInfo{gc.SizeD | gc.LeftAddr | gc.RightRead, 0, 0, 0},
+ i386.AFCOMDPP: gc.ProgInfo{gc.SizeD | gc.LeftAddr | gc.RightRead, 0, 0, 0},
+ i386.AFCOMF: gc.ProgInfo{gc.SizeF | gc.LeftAddr | gc.RightRead, 0, 0, 0},
+ i386.AFCOMFP: gc.ProgInfo{gc.SizeF | gc.LeftAddr | gc.RightRead, 0, 0, 0},
+ i386.AFUCOMIP: gc.ProgInfo{gc.SizeF | gc.LeftAddr | gc.RightRead, 0, 0, 0},
+ i386.AFCHS: gc.ProgInfo{gc.SizeD | RightRdwr, 0, 0, 0}, // also SizeF
+
+ i386.AFDIVDP: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ i386.AFDIVF: gc.ProgInfo{gc.SizeF | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ i386.AFDIVD: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ i386.AFDIVRDP: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ i386.AFDIVRF: gc.ProgInfo{gc.SizeF | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ i386.AFDIVRD: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ i386.AFXCHD: gc.ProgInfo{gc.SizeD | LeftRdwr | RightRdwr, 0, 0, 0},
+ i386.AFSUBD: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ i386.AFSUBDP: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ i386.AFSUBF: gc.ProgInfo{gc.SizeF | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ i386.AFSUBRD: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ i386.AFSUBRDP: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ i386.AFSUBRF: gc.ProgInfo{gc.SizeF | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ i386.AFMOVD: gc.ProgInfo{gc.SizeD | gc.LeftAddr | gc.RightWrite, 0, 0, 0},
+ i386.AFMOVF: gc.ProgInfo{gc.SizeF | gc.LeftAddr | gc.RightWrite, 0, 0, 0},
+ i386.AFMOVL: gc.ProgInfo{gc.SizeL | gc.LeftAddr | gc.RightWrite, 0, 0, 0},
+ i386.AFMOVW: gc.ProgInfo{gc.SizeW | gc.LeftAddr | gc.RightWrite, 0, 0, 0},
+ i386.AFMOVV: gc.ProgInfo{gc.SizeQ | gc.LeftAddr | gc.RightWrite, 0, 0, 0},
+
+ // These instructions are marked as RightAddr
+ // so that the register optimizer does not try to replace the
+ // memory references with integer register references.
+ // But they do not use the previous value at the address, so
+ // we also mark them RightWrite.
+ i386.AFMOVDP: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightWrite | gc.RightAddr, 0, 0, 0},
+ i386.AFMOVFP: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightWrite | gc.RightAddr, 0, 0, 0},
+ i386.AFMOVLP: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.RightAddr, 0, 0, 0},
+ i386.AFMOVWP: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightWrite | gc.RightAddr, 0, 0, 0},
+ i386.AFMOVVP: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.RightWrite | gc.RightAddr, 0, 0, 0},
+ i386.AFMULD: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ i386.AFMULDP: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ i386.AFMULF: gc.ProgInfo{gc.SizeF | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ i386.AIDIVB: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.SetCarry, AX, AX, 0},
+ i386.AIDIVL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.SetCarry, AX | DX, AX | DX, 0},
+ i386.AIDIVW: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.SetCarry, AX | DX, AX | DX, 0},
+ i386.AIMULB: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.SetCarry, AX, AX, 0},
+ i386.AIMULL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.ImulAXDX | gc.SetCarry, 0, 0, 0},
+ i386.AIMULW: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.ImulAXDX | gc.SetCarry, 0, 0, 0},
+ i386.AINCB: gc.ProgInfo{gc.SizeB | RightRdwr, 0, 0, 0},
+ i386.AINCL: gc.ProgInfo{gc.SizeL | RightRdwr, 0, 0, 0},
+ i386.AINCW: gc.ProgInfo{gc.SizeW | RightRdwr, 0, 0, 0},
+ i386.AJCC: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ i386.AJCS: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ i386.AJEQ: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ i386.AJGE: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ i386.AJGT: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ i386.AJHI: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ i386.AJLE: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ i386.AJLS: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ i386.AJLT: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ i386.AJMI: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ i386.AJNE: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ i386.AJOC: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ i386.AJOS: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ i386.AJPC: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ i386.AJPL: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ i386.AJPS: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ obj.AJMP: gc.ProgInfo{gc.Jump | gc.Break | gc.KillCarry, 0, 0, 0},
+ i386.ALEAL: gc.ProgInfo{gc.LeftAddr | gc.RightWrite, 0, 0, 0},
+ i386.AMOVBLSX: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ i386.AMOVBLZX: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ i386.AMOVBWSX: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ i386.AMOVBWZX: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ i386.AMOVWLSX: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ i386.AMOVWLZX: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ i386.AMOVB: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
+ i386.AMOVL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
+ i386.AMOVW: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
+ i386.AMOVSB: gc.ProgInfo{gc.OK, DI | SI, DI | SI, 0},
+ i386.AMOVSL: gc.ProgInfo{gc.OK, DI | SI, DI | SI, 0},
+ i386.AMOVSW: gc.ProgInfo{gc.OK, DI | SI, DI | SI, 0},
+ obj.ADUFFCOPY: gc.ProgInfo{gc.OK, DI | SI, DI | SI | CX, 0},
+ i386.AMOVSD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
+ i386.AMOVSS: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
+
+ // We use MOVAPD as a faster synonym for MOVSD.
+ i386.AMOVAPD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
+ i386.AMULB: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.SetCarry, AX, AX, 0},
+ i386.AMULL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.SetCarry, AX, AX | DX, 0},
+ i386.AMULW: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.SetCarry, AX, AX | DX, 0},
+ i386.AMULSD: gc.ProgInfo{gc.SizeD | gc.LeftRead | RightRdwr, 0, 0, 0},
+ i386.AMULSS: gc.ProgInfo{gc.SizeF | gc.LeftRead | RightRdwr, 0, 0, 0},
+ i386.ANEGB: gc.ProgInfo{gc.SizeB | RightRdwr | gc.SetCarry, 0, 0, 0},
+ i386.ANEGL: gc.ProgInfo{gc.SizeL | RightRdwr | gc.SetCarry, 0, 0, 0},
+ i386.ANEGW: gc.ProgInfo{gc.SizeW | RightRdwr | gc.SetCarry, 0, 0, 0},
+ i386.ANOTB: gc.ProgInfo{gc.SizeB | RightRdwr, 0, 0, 0},
+ i386.ANOTL: gc.ProgInfo{gc.SizeL | RightRdwr, 0, 0, 0},
+ i386.ANOTW: gc.ProgInfo{gc.SizeW | RightRdwr, 0, 0, 0},
+ i386.AORB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ i386.AORL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ i386.AORW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ i386.APOPL: gc.ProgInfo{gc.SizeL | gc.RightWrite, 0, 0, 0},
+ i386.APUSHL: gc.ProgInfo{gc.SizeL | gc.LeftRead, 0, 0, 0},
+ i386.ARCLB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ i386.ARCLL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ i386.ARCLW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ i386.ARCRB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ i386.ARCRL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ i386.ARCRW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ i386.AREP: gc.ProgInfo{gc.OK, CX, CX, 0},
+ i386.AREPN: gc.ProgInfo{gc.OK, CX, CX, 0},
+ obj.ARET: gc.ProgInfo{gc.Break | gc.KillCarry, 0, 0, 0},
+ i386.AROLB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ i386.AROLL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ i386.AROLW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ i386.ARORB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ i386.ARORL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ i386.ARORW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ i386.ASAHF: gc.ProgInfo{gc.OK, AX, AX, 0},
+ i386.ASALB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ i386.ASALL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ i386.ASALW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ i386.ASARB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ i386.ASARL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ i386.ASARW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ i386.ASBBB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ i386.ASBBL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ i386.ASBBW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ i386.ASETCC: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
+ i386.ASETCS: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
+ i386.ASETEQ: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
+ i386.ASETGE: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
+ i386.ASETGT: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
+ i386.ASETHI: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
+ i386.ASETLE: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
+ i386.ASETLS: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
+ i386.ASETLT: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
+ i386.ASETMI: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
+ i386.ASETNE: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
+ i386.ASETOC: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
+ i386.ASETOS: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
+ i386.ASETPC: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
+ i386.ASETPL: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
+ i386.ASETPS: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
+ i386.ASHLB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ i386.ASHLL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ i386.ASHLW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ i386.ASHRB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ i386.ASHRL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ i386.ASHRW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ i386.ASTOSB: gc.ProgInfo{gc.OK, AX | DI, DI, 0},
+ i386.ASTOSL: gc.ProgInfo{gc.OK, AX | DI, DI, 0},
+ i386.ASTOSW: gc.ProgInfo{gc.OK, AX | DI, DI, 0},
+ obj.ADUFFZERO: gc.ProgInfo{gc.OK, AX | DI, DI, 0},
+ i386.ASUBB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ i386.ASUBL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ i386.ASUBW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ i386.ASUBSD: gc.ProgInfo{gc.SizeD | gc.LeftRead | RightRdwr, 0, 0, 0},
+ i386.ASUBSS: gc.ProgInfo{gc.SizeF | gc.LeftRead | RightRdwr, 0, 0, 0},
+ i386.ATESTB: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0},
+ i386.ATESTL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0},
+ i386.ATESTW: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0},
+ i386.AUCOMISD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightRead, 0, 0, 0},
+ i386.AUCOMISS: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightRead, 0, 0, 0},
+ i386.AXCHGB: gc.ProgInfo{gc.SizeB | LeftRdwr | RightRdwr, 0, 0, 0},
+ i386.AXCHGL: gc.ProgInfo{gc.SizeL | LeftRdwr | RightRdwr, 0, 0, 0},
+ i386.AXCHGW: gc.ProgInfo{gc.SizeW | LeftRdwr | RightRdwr, 0, 0, 0},
+ i386.AXORB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ i386.AXORL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ i386.AXORW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+}
+
+func proginfo(info *gc.ProgInfo, p *obj.Prog) {
+ *info = progtable[p.As]
+ if info.Flags == 0 {
+ gc.Fatal("unknown instruction %v", p)
+ }
+
+ if (info.Flags&gc.ShiftCX != 0) && p.From.Type != obj.TYPE_CONST {
+ info.Reguse |= CX
+ }
+
+ if info.Flags&gc.ImulAXDX != 0 {
+ if p.To.Type == obj.TYPE_NONE {
+ info.Reguse |= AX
+ info.Regset |= AX | DX
+ } else {
+ info.Flags |= RightRdwr
+ }
+ }
+
+ // Addressing makes some registers used.
+ if p.From.Type == obj.TYPE_MEM && p.From.Name == obj.NAME_NONE {
+ info.Regindex |= RtoB(int(p.From.Reg))
+ }
+ if p.From.Index != i386.REG_NONE {
+ info.Regindex |= RtoB(int(p.From.Index))
+ }
+ if p.To.Type == obj.TYPE_MEM && p.To.Name == obj.NAME_NONE {
+ info.Regindex |= RtoB(int(p.To.Reg))
+ }
+ if p.To.Index != i386.REG_NONE {
+ info.Regindex |= RtoB(int(p.To.Index))
+ }
+}
--- /dev/null
+// 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 main
+
+import "cmd/internal/obj/i386"
+import "cmd/internal/gc"
+
+const (
+ NREGVAR = 16
+)
+
+var regname = []string{
+ ".ax",
+ ".cx",
+ ".dx",
+ ".bx",
+ ".sp",
+ ".bp",
+ ".si",
+ ".di",
+ ".x0",
+ ".x1",
+ ".x2",
+ ".x3",
+ ".x4",
+ ".x5",
+ ".x6",
+ ".x7",
+}
+
+func regnames(n *int) []string {
+ *n = NREGVAR
+ return regname
+}
+
+func excludedregs() uint64 {
+ return RtoB(i386.REG_SP)
+}
+
+func doregbits(r int) uint64 {
+ var b uint64
+
+ b = 0
+ if r >= i386.REG_AX && r <= i386.REG_DI {
+ b |= RtoB(r)
+ } else if r >= i386.REG_AL && r <= i386.REG_BL {
+ b |= RtoB(r - i386.REG_AL + i386.REG_AX)
+ } else if r >= i386.REG_AH && r <= i386.REG_BH {
+ b |= RtoB(r - i386.REG_AH + i386.REG_AX)
+ } else if r >= i386.REG_X0 && r <= i386.REG_X0+7 {
+ b |= FtoB(r)
+ }
+ return b
+}
+
+func RtoB(r int) uint64 {
+ if r < i386.REG_AX || r > i386.REG_DI {
+ return 0
+ }
+ return 1 << uint(r-i386.REG_AX)
+}
+
+func BtoR(b uint64) int {
+ b &= 0xff
+ if b == 0 {
+ return 0
+ }
+ return gc.Bitno(b) + i386.REG_AX
+}
+
+func FtoB(f int) uint64 {
+ if f < i386.REG_X0 || f > i386.REG_X7 {
+ return 0
+ }
+ return 1 << uint(f-i386.REG_X0+8)
+}
+
+func BtoF(b uint64) int {
+ b &= 0xFF00
+ if b == 0 {
+ return 0
+ }
+ return gc.Bitno(b) - 8 + i386.REG_X0
+}
--- /dev/null
+// Copyright 2015 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 main
+
+func bool2int(b bool) int {
+ if b {
+ return 1
+ }
+ return 0
+}
--- /dev/null
+// 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 main
+
+import (
+ "cmd/internal/obj"
+ "cmd/internal/obj/ppc64"
+ "fmt"
+)
+import "cmd/internal/gc"
+
+/*
+ * peep.c
+ */
+/*
+ * generate:
+ * res = n;
+ * simplifies and calls gmove.
+ */
+func cgen(n *gc.Node, res *gc.Node) {
+ var nl *gc.Node
+ var nr *gc.Node
+ var r *gc.Node
+ var n1 gc.Node
+ var n2 gc.Node
+ var a int
+ var f int
+ var p1 *obj.Prog
+ var p2 *obj.Prog
+ var p3 *obj.Prog
+ var addr obj.Addr
+
+ //print("cgen %N(%d) -> %N(%d)\n", n, n->addable, res, res->addable);
+ if gc.Debug['g'] != 0 {
+ gc.Dump("\ncgen-n", n)
+ gc.Dump("cgen-res", res)
+ }
+
+ if n == nil || n.Type == nil {
+ goto ret
+ }
+
+ if res == nil || res.Type == nil {
+ gc.Fatal("cgen: res nil")
+ }
+
+ for n.Op == gc.OCONVNOP {
+ n = n.Left
+ }
+
+ switch n.Op {
+ case gc.OSLICE,
+ gc.OSLICEARR,
+ gc.OSLICESTR,
+ gc.OSLICE3,
+ gc.OSLICE3ARR:
+ if res.Op != gc.ONAME || !(res.Addable != 0) {
+ gc.Tempname(&n1, n.Type)
+ gc.Cgen_slice(n, &n1)
+ cgen(&n1, res)
+ } else {
+ gc.Cgen_slice(n, res)
+ }
+ goto ret
+
+ case gc.OEFACE:
+ if res.Op != gc.ONAME || !(res.Addable != 0) {
+ gc.Tempname(&n1, n.Type)
+ gc.Cgen_eface(n, &n1)
+ cgen(&n1, res)
+ } else {
+ gc.Cgen_eface(n, res)
+ }
+ goto ret
+ }
+
+ if n.Ullman >= gc.UINF {
+ if n.Op == gc.OINDREG {
+ gc.Fatal("cgen: this is going to misscompile")
+ }
+ if res.Ullman >= gc.UINF {
+ gc.Tempname(&n1, n.Type)
+ cgen(n, &n1)
+ cgen(&n1, res)
+ goto ret
+ }
+ }
+
+ if gc.Isfat(n.Type) != 0 {
+ if n.Type.Width < 0 {
+ gc.Fatal("forgot to compute width for %v", gc.Tconv(n.Type, 0))
+ }
+ sgen(n, res, n.Type.Width)
+ goto ret
+ }
+
+ if !(res.Addable != 0) {
+ if n.Ullman > res.Ullman {
+ regalloc(&n1, n.Type, res)
+ cgen(n, &n1)
+ if n1.Ullman > res.Ullman {
+ gc.Dump("n1", &n1)
+ gc.Dump("res", res)
+ gc.Fatal("loop in cgen")
+ }
+
+ cgen(&n1, res)
+ regfree(&n1)
+ goto ret
+ }
+
+ if res.Ullman >= gc.UINF {
+ goto gen
+ }
+
+ if gc.Complexop(n, res) != 0 {
+ gc.Complexgen(n, res)
+ goto ret
+ }
+
+ f = 1 // gen thru register
+ switch n.Op {
+ case gc.OLITERAL:
+ if gc.Smallintconst(n) != 0 {
+ f = 0
+ }
+
+ case gc.OREGISTER:
+ f = 0
+ }
+
+ if !(gc.Iscomplex[n.Type.Etype] != 0) {
+ a = optoas(gc.OAS, res.Type)
+ if sudoaddable(a, res, &addr) != 0 {
+ if f != 0 {
+ regalloc(&n2, res.Type, nil)
+ cgen(n, &n2)
+ p1 = gins(a, &n2, nil)
+ regfree(&n2)
+ } else {
+ p1 = gins(a, n, nil)
+ }
+ p1.To = addr
+ if gc.Debug['g'] != 0 {
+ fmt.Printf("%v [ignore previous line]\n", p1)
+ }
+ sudoclean()
+ goto ret
+ }
+ }
+
+ gen:
+ igen(res, &n1, nil)
+ cgen(n, &n1)
+ regfree(&n1)
+ goto ret
+ }
+
+ // update addressability for string, slice
+ // can't do in walk because n->left->addable
+ // changes if n->left is an escaping local variable.
+ switch n.Op {
+ case gc.OSPTR,
+ gc.OLEN:
+ if gc.Isslice(n.Left.Type) != 0 || gc.Istype(n.Left.Type, gc.TSTRING) != 0 {
+ n.Addable = n.Left.Addable
+ }
+
+ case gc.OCAP:
+ if gc.Isslice(n.Left.Type) != 0 {
+ n.Addable = n.Left.Addable
+ }
+
+ case gc.OITAB:
+ n.Addable = n.Left.Addable
+ }
+
+ if gc.Complexop(n, res) != 0 {
+ gc.Complexgen(n, res)
+ goto ret
+ }
+
+ // if both are addressable, move
+ if n.Addable != 0 {
+ if n.Op == gc.OREGISTER || res.Op == gc.OREGISTER {
+ gmove(n, res)
+ } else {
+ regalloc(&n1, n.Type, nil)
+ gmove(n, &n1)
+ cgen(&n1, res)
+ regfree(&n1)
+ }
+
+ goto ret
+ }
+
+ nl = n.Left
+ nr = n.Right
+
+ if nl != nil && nl.Ullman >= gc.UINF {
+ if nr != nil && nr.Ullman >= gc.UINF {
+ gc.Tempname(&n1, nl.Type)
+ cgen(nl, &n1)
+ n2 = *n
+ n2.Left = &n1
+ cgen(&n2, res)
+ goto ret
+ }
+ }
+
+ if !(gc.Iscomplex[n.Type.Etype] != 0) {
+ a = optoas(gc.OAS, n.Type)
+ if sudoaddable(a, n, &addr) != 0 {
+ if res.Op == gc.OREGISTER {
+ p1 = gins(a, nil, res)
+ p1.From = addr
+ } else {
+ regalloc(&n2, n.Type, nil)
+ p1 = gins(a, nil, &n2)
+ p1.From = addr
+ gins(a, &n2, res)
+ regfree(&n2)
+ }
+
+ sudoclean()
+ goto ret
+ }
+ }
+
+ // TODO(minux): we shouldn't reverse FP comparisons, but then we need to synthesize
+ // OGE, OLE, and ONE ourselves.
+ // if(nl != N && isfloat[n->type->etype] && isfloat[nl->type->etype]) goto flt;
+
+ switch n.Op {
+ default:
+ gc.Dump("cgen", n)
+ gc.Fatal("cgen: unknown op %v", gc.Nconv(n, obj.FmtShort|obj.FmtSign))
+
+ // these call bgen to get a bool value
+ case gc.OOROR,
+ gc.OANDAND,
+ gc.OEQ,
+ gc.ONE,
+ gc.OLT,
+ gc.OLE,
+ gc.OGE,
+ gc.OGT,
+ gc.ONOT:
+ p1 = gc.Gbranch(ppc64.ABR, nil, 0)
+
+ p2 = gc.Pc
+ gmove(gc.Nodbool(1), res)
+ p3 = gc.Gbranch(ppc64.ABR, nil, 0)
+ gc.Patch(p1, gc.Pc)
+ bgen(n, true, 0, p2)
+ gmove(gc.Nodbool(0), res)
+ gc.Patch(p3, gc.Pc)
+ goto ret
+
+ case gc.OPLUS:
+ cgen(nl, res)
+ goto ret
+
+ // unary
+ case gc.OCOM:
+ a = optoas(gc.OXOR, nl.Type)
+
+ regalloc(&n1, nl.Type, nil)
+ cgen(nl, &n1)
+ gc.Nodconst(&n2, nl.Type, -1)
+ gins(a, &n2, &n1)
+ gmove(&n1, res)
+ regfree(&n1)
+ goto ret
+
+ case gc.OMINUS:
+ if gc.Isfloat[nl.Type.Etype] != 0 {
+ nr = gc.Nodintconst(-1)
+ gc.Convlit(&nr, n.Type)
+ a = optoas(gc.OMUL, nl.Type)
+ goto sbop
+ }
+
+ a = optoas(int(n.Op), nl.Type)
+ goto uop
+
+ // symmetric binary
+ case gc.OAND,
+ gc.OOR,
+ gc.OXOR,
+ gc.OADD,
+ gc.OMUL:
+ a = optoas(int(n.Op), nl.Type)
+
+ goto sbop
+
+ // asymmetric binary
+ case gc.OSUB:
+ a = optoas(int(n.Op), nl.Type)
+
+ goto abop
+
+ case gc.OHMUL:
+ cgen_hmul(nl, nr, res)
+
+ case gc.OCONV:
+ if n.Type.Width > nl.Type.Width {
+ // If loading from memory, do conversion during load,
+ // so as to avoid use of 8-bit register in, say, int(*byteptr).
+ switch nl.Op {
+ case gc.ODOT,
+ gc.ODOTPTR,
+ gc.OINDEX,
+ gc.OIND,
+ gc.ONAME:
+ igen(nl, &n1, res)
+ regalloc(&n2, n.Type, res)
+ gmove(&n1, &n2)
+ gmove(&n2, res)
+ regfree(&n2)
+ regfree(&n1)
+ goto ret
+ }
+ }
+
+ regalloc(&n1, nl.Type, res)
+ regalloc(&n2, n.Type, &n1)
+ cgen(nl, &n1)
+
+ // if we do the conversion n1 -> n2 here
+ // reusing the register, then gmove won't
+ // have to allocate its own register.
+ gmove(&n1, &n2)
+
+ gmove(&n2, res)
+ regfree(&n2)
+ regfree(&n1)
+
+ case gc.ODOT,
+ gc.ODOTPTR,
+ gc.OINDEX,
+ gc.OIND,
+ gc.ONAME: // PHEAP or PPARAMREF var
+ igen(n, &n1, res)
+
+ gmove(&n1, res)
+ regfree(&n1)
+
+ // interface table is first word of interface value
+ case gc.OITAB:
+ igen(nl, &n1, res)
+
+ n1.Type = n.Type
+ gmove(&n1, res)
+ regfree(&n1)
+
+ // pointer is the first word of string or slice.
+ case gc.OSPTR:
+ if gc.Isconst(nl, gc.CTSTR) != 0 {
+ regalloc(&n1, gc.Types[gc.Tptr], res)
+ p1 = gins(ppc64.AMOVD, nil, &n1)
+ gc.Datastring(nl.Val.U.Sval.S, &p1.From)
+ gmove(&n1, res)
+ regfree(&n1)
+ break
+ }
+
+ igen(nl, &n1, res)
+ n1.Type = n.Type
+ gmove(&n1, res)
+ regfree(&n1)
+
+ case gc.OLEN:
+ if gc.Istype(nl.Type, gc.TMAP) != 0 || gc.Istype(nl.Type, gc.TCHAN) != 0 {
+ // map and chan have len in the first int-sized word.
+ // a zero pointer means zero length
+ regalloc(&n1, gc.Types[gc.Tptr], res)
+
+ cgen(nl, &n1)
+
+ gc.Nodconst(&n2, gc.Types[gc.Tptr], 0)
+ gins(optoas(gc.OCMP, gc.Types[gc.Tptr]), &n1, &n2)
+ p1 = gc.Gbranch(optoas(gc.OEQ, gc.Types[gc.Tptr]), nil, 0)
+
+ n2 = n1
+ n2.Op = gc.OINDREG
+ n2.Type = gc.Types[gc.Simtype[gc.TINT]]
+ gmove(&n2, &n1)
+
+ gc.Patch(p1, gc.Pc)
+
+ gmove(&n1, res)
+ regfree(&n1)
+ break
+ }
+
+ if gc.Istype(nl.Type, gc.TSTRING) != 0 || gc.Isslice(nl.Type) != 0 {
+ // both slice and string have len one pointer into the struct.
+ // a zero pointer means zero length
+ igen(nl, &n1, res)
+
+ n1.Type = gc.Types[gc.Simtype[gc.TUINT]]
+ n1.Xoffset += int64(gc.Array_nel)
+ gmove(&n1, res)
+ regfree(&n1)
+ break
+ }
+
+ gc.Fatal("cgen: OLEN: unknown type %v", gc.Tconv(nl.Type, obj.FmtLong))
+
+ case gc.OCAP:
+ if gc.Istype(nl.Type, gc.TCHAN) != 0 {
+ // chan has cap in the second int-sized word.
+ // a zero pointer means zero length
+ regalloc(&n1, gc.Types[gc.Tptr], res)
+
+ cgen(nl, &n1)
+
+ gc.Nodconst(&n2, gc.Types[gc.Tptr], 0)
+ gins(optoas(gc.OCMP, gc.Types[gc.Tptr]), &n1, &n2)
+ p1 = gc.Gbranch(optoas(gc.OEQ, gc.Types[gc.Tptr]), nil, 0)
+
+ n2 = n1
+ n2.Op = gc.OINDREG
+ n2.Xoffset = int64(gc.Widthint)
+ n2.Type = gc.Types[gc.Simtype[gc.TINT]]
+ gmove(&n2, &n1)
+
+ gc.Patch(p1, gc.Pc)
+
+ gmove(&n1, res)
+ regfree(&n1)
+ break
+ }
+
+ if gc.Isslice(nl.Type) != 0 {
+ igen(nl, &n1, res)
+ n1.Type = gc.Types[gc.Simtype[gc.TUINT]]
+ n1.Xoffset += int64(gc.Array_cap)
+ gmove(&n1, res)
+ regfree(&n1)
+ break
+ }
+
+ gc.Fatal("cgen: OCAP: unknown type %v", gc.Tconv(nl.Type, obj.FmtLong))
+
+ case gc.OADDR:
+ if n.Bounded != 0 { // let race detector avoid nil checks
+ gc.Disable_checknil++
+ }
+ agen(nl, res)
+ if n.Bounded != 0 {
+ gc.Disable_checknil--
+ }
+
+ case gc.OCALLMETH:
+ gc.Cgen_callmeth(n, 0)
+ cgen_callret(n, res)
+
+ case gc.OCALLINTER:
+ cgen_callinter(n, res, 0)
+ cgen_callret(n, res)
+
+ case gc.OCALLFUNC:
+ cgen_call(n, 0)
+ cgen_callret(n, res)
+
+ case gc.OMOD,
+ gc.ODIV:
+ if gc.Isfloat[n.Type.Etype] != 0 {
+ a = optoas(int(n.Op), nl.Type)
+ goto abop
+ }
+
+ if nl.Ullman >= nr.Ullman {
+ regalloc(&n1, nl.Type, res)
+ cgen(nl, &n1)
+ cgen_div(int(n.Op), &n1, nr, res)
+ regfree(&n1)
+ } else {
+ if !(gc.Smallintconst(nr) != 0) {
+ regalloc(&n2, nr.Type, res)
+ cgen(nr, &n2)
+ } else {
+ n2 = *nr
+ }
+
+ cgen_div(int(n.Op), nl, &n2, res)
+ if n2.Op != gc.OLITERAL {
+ regfree(&n2)
+ }
+ }
+
+ case gc.OLSH,
+ gc.ORSH,
+ gc.OLROT:
+ cgen_shift(int(n.Op), int(n.Bounded), nl, nr, res)
+ }
+
+ goto ret
+
+ /*
+ * put simplest on right - we'll generate into left
+ * and then adjust it using the computation of right.
+ * constants and variables have the same ullman
+ * count, so look for constants specially.
+ *
+ * an integer constant we can use as an immediate
+ * is simpler than a variable - we can use the immediate
+ * in the adjustment instruction directly - so it goes
+ * on the right.
+ *
+ * other constants, like big integers or floating point
+ * constants, require a mov into a register, so those
+ * might as well go on the left, so we can reuse that
+ * register for the computation.
+ */
+sbop: // symmetric binary
+ if nl.Ullman < nr.Ullman || (nl.Ullman == nr.Ullman && (gc.Smallintconst(nl) != 0 || (nr.Op == gc.OLITERAL && !(gc.Smallintconst(nr) != 0)))) {
+ r = nl
+ nl = nr
+ nr = r
+ }
+
+abop: // asymmetric binary
+ if nl.Ullman >= nr.Ullman {
+ regalloc(&n1, nl.Type, res)
+ cgen(nl, &n1)
+
+ /*
+ * This generates smaller code - it avoids a MOV - but it's
+ * easily 10% slower due to not being able to
+ * optimize/manipulate the move.
+ * To see, run: go test -bench . crypto/md5
+ * with and without.
+ *
+ if(sudoaddable(a, nr, &addr)) {
+ p1 = gins(a, N, &n1);
+ p1->from = addr;
+ gmove(&n1, res);
+ sudoclean();
+ regfree(&n1);
+ goto ret;
+ }
+ *
+ */
+ // TODO(minux): enable using constants directly in certain instructions.
+ //if(smallintconst(nr))
+ // n2 = *nr;
+ //else {
+ regalloc(&n2, nr.Type, nil)
+
+ cgen(nr, &n2)
+ } else //}
+ {
+ //if(smallintconst(nr))
+ // n2 = *nr;
+ //else {
+ regalloc(&n2, nr.Type, res)
+
+ cgen(nr, &n2)
+
+ //}
+ regalloc(&n1, nl.Type, nil)
+
+ cgen(nl, &n1)
+ }
+
+ gins(a, &n2, &n1)
+
+ // Normalize result for types smaller than word.
+ if n.Type.Width < int64(gc.Widthreg) {
+ switch n.Op {
+ case gc.OADD,
+ gc.OSUB,
+ gc.OMUL,
+ gc.OLSH:
+ gins(optoas(gc.OAS, n.Type), &n1, &n1)
+ }
+ }
+
+ gmove(&n1, res)
+ regfree(&n1)
+ if n2.Op != gc.OLITERAL {
+ regfree(&n2)
+ }
+ goto ret
+
+uop: // unary
+ regalloc(&n1, nl.Type, res)
+
+ cgen(nl, &n1)
+ gins(a, nil, &n1)
+ gmove(&n1, res)
+ regfree(&n1)
+ goto ret
+
+ret:
+}
+
+/*
+ * allocate a register (reusing res if possible) and generate
+ * a = n
+ * The caller must call regfree(a).
+ */
+func cgenr(n *gc.Node, a *gc.Node, res *gc.Node) {
+ var n1 gc.Node
+
+ if gc.Debug['g'] != 0 {
+ gc.Dump("cgenr-n", n)
+ }
+
+ if gc.Isfat(n.Type) != 0 {
+ gc.Fatal("cgenr on fat node")
+ }
+
+ if n.Addable != 0 {
+ regalloc(a, n.Type, res)
+ gmove(n, a)
+ return
+ }
+
+ switch n.Op {
+ case gc.ONAME,
+ gc.ODOT,
+ gc.ODOTPTR,
+ gc.OINDEX,
+ gc.OCALLFUNC,
+ gc.OCALLMETH,
+ gc.OCALLINTER:
+ igen(n, &n1, res)
+ regalloc(a, gc.Types[gc.Tptr], &n1)
+ gmove(&n1, a)
+ regfree(&n1)
+
+ default:
+ regalloc(a, n.Type, res)
+ cgen(n, a)
+ }
+}
+
+/*
+ * allocate a register (reusing res if possible) and generate
+ * a = &n
+ * The caller must call regfree(a).
+ * The generated code checks that the result is not nil.
+ */
+func agenr(n *gc.Node, a *gc.Node, res *gc.Node) {
+ var nl *gc.Node
+ var nr *gc.Node
+ var n1 gc.Node
+ var n2 gc.Node
+ var n3 gc.Node
+ var n4 gc.Node
+ var tmp gc.Node
+ var p1 *obj.Prog
+ var p2 *obj.Prog
+ var w uint32
+ var v uint64
+
+ if gc.Debug['g'] != 0 {
+ gc.Dump("agenr-n", n)
+ }
+
+ nl = n.Left
+ nr = n.Right
+
+ switch n.Op {
+ case gc.ODOT,
+ gc.ODOTPTR,
+ gc.OCALLFUNC,
+ gc.OCALLMETH,
+ gc.OCALLINTER:
+ igen(n, &n1, res)
+ regalloc(a, gc.Types[gc.Tptr], &n1)
+ agen(&n1, a)
+ regfree(&n1)
+
+ case gc.OIND:
+ cgenr(n.Left, a, res)
+ gc.Cgen_checknil(a)
+
+ case gc.OINDEX:
+ p2 = nil // to be patched to panicindex.
+ w = uint32(n.Type.Width)
+
+ //bounded = debug['B'] || n->bounded;
+ if nr.Addable != 0 {
+ if !(gc.Isconst(nr, gc.CTINT) != 0) {
+ gc.Tempname(&tmp, gc.Types[gc.TINT64])
+ }
+ if !(gc.Isconst(nl, gc.CTSTR) != 0) {
+ agenr(nl, &n3, res)
+ }
+ if !(gc.Isconst(nr, gc.CTINT) != 0) {
+ cgen(nr, &tmp)
+ regalloc(&n1, tmp.Type, nil)
+ gmove(&tmp, &n1)
+ }
+ } else if nl.Addable != 0 {
+ if !(gc.Isconst(nr, gc.CTINT) != 0) {
+ gc.Tempname(&tmp, gc.Types[gc.TINT64])
+ cgen(nr, &tmp)
+ regalloc(&n1, tmp.Type, nil)
+ gmove(&tmp, &n1)
+ }
+
+ if !(gc.Isconst(nl, gc.CTSTR) != 0) {
+ agenr(nl, &n3, res)
+ }
+ } else {
+ gc.Tempname(&tmp, gc.Types[gc.TINT64])
+ cgen(nr, &tmp)
+ nr = &tmp
+ if !(gc.Isconst(nl, gc.CTSTR) != 0) {
+ agenr(nl, &n3, res)
+ }
+ regalloc(&n1, tmp.Type, nil)
+ gins(optoas(gc.OAS, tmp.Type), &tmp, &n1)
+ }
+
+ // &a is in &n3 (allocated in res)
+ // i is in &n1 (if not constant)
+ // w is width
+
+ // constant index
+ if gc.Isconst(nr, gc.CTINT) != 0 {
+ if gc.Isconst(nl, gc.CTSTR) != 0 {
+ gc.Fatal("constant string constant index")
+ }
+ v = uint64(gc.Mpgetfix(nr.Val.U.Xval))
+ if gc.Isslice(nl.Type) != 0 || nl.Type.Etype == gc.TSTRING {
+ if !(gc.Debug['B'] != 0) && !(n.Bounded != 0) {
+ n1 = n3
+ n1.Op = gc.OINDREG
+ n1.Type = gc.Types[gc.Tptr]
+ n1.Xoffset = int64(gc.Array_nel)
+ regalloc(&n4, n1.Type, nil)
+ gmove(&n1, &n4)
+ ginscon2(optoas(gc.OCMP, gc.Types[gc.TUINT64]), &n4, int64(v))
+ regfree(&n4)
+ p1 = gc.Gbranch(optoas(gc.OGT, gc.Types[gc.TUINT64]), nil, +1)
+ ginscall(gc.Panicindex, 0)
+ gc.Patch(p1, gc.Pc)
+ }
+
+ n1 = n3
+ n1.Op = gc.OINDREG
+ n1.Type = gc.Types[gc.Tptr]
+ n1.Xoffset = int64(gc.Array_array)
+ gmove(&n1, &n3)
+ }
+
+ if v*uint64(w) != 0 {
+ ginscon(optoas(gc.OADD, gc.Types[gc.Tptr]), int64(v*uint64(w)), &n3)
+ }
+
+ *a = n3
+ break
+ }
+
+ regalloc(&n2, gc.Types[gc.TINT64], &n1) // i
+ gmove(&n1, &n2)
+ regfree(&n1)
+
+ if !(gc.Debug['B'] != 0) && !(n.Bounded != 0) {
+ // check bounds
+ if gc.Isconst(nl, gc.CTSTR) != 0 {
+ gc.Nodconst(&n4, gc.Types[gc.TUINT64], int64(len(nl.Val.U.Sval.S)))
+ } else if gc.Isslice(nl.Type) != 0 || nl.Type.Etype == gc.TSTRING {
+ n1 = n3
+ n1.Op = gc.OINDREG
+ n1.Type = gc.Types[gc.Tptr]
+ n1.Xoffset = int64(gc.Array_nel)
+ regalloc(&n4, gc.Types[gc.TUINT64], nil)
+ gmove(&n1, &n4)
+ } else {
+ if nl.Type.Bound < (1<<15)-1 {
+ gc.Nodconst(&n4, gc.Types[gc.TUINT64], nl.Type.Bound)
+ } else {
+ regalloc(&n4, gc.Types[gc.TUINT64], nil)
+ p1 = gins(ppc64.AMOVD, nil, &n4)
+ p1.From.Type = obj.TYPE_CONST
+ p1.From.Offset = nl.Type.Bound
+ }
+ }
+
+ gins(optoas(gc.OCMP, gc.Types[gc.TUINT64]), &n2, &n4)
+ if n4.Op == gc.OREGISTER {
+ regfree(&n4)
+ }
+ p1 = gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TUINT64]), nil, +1)
+ if p2 != nil {
+ gc.Patch(p2, gc.Pc)
+ }
+ ginscall(gc.Panicindex, 0)
+ gc.Patch(p1, gc.Pc)
+ }
+
+ if gc.Isconst(nl, gc.CTSTR) != 0 {
+ regalloc(&n3, gc.Types[gc.Tptr], res)
+ p1 = gins(ppc64.AMOVD, nil, &n3)
+ gc.Datastring(nl.Val.U.Sval.S, &p1.From)
+ p1.From.Type = obj.TYPE_ADDR
+ } else if gc.Isslice(nl.Type) != 0 || nl.Type.Etype == gc.TSTRING {
+ n1 = n3
+ n1.Op = gc.OINDREG
+ n1.Type = gc.Types[gc.Tptr]
+ n1.Xoffset = int64(gc.Array_array)
+ gmove(&n1, &n3)
+ }
+
+ if w == 0 {
+ } else // nothing to do
+ if w == 1 {
+ /* w already scaled */
+ gins(optoas(gc.OADD, gc.Types[gc.Tptr]), &n2, &n3)
+ /* else if(w == 2 || w == 4 || w == 8) {
+ // TODO(minux): scale using shift
+ } */
+ } else {
+ regalloc(&n4, gc.Types[gc.TUINT64], nil)
+ gc.Nodconst(&n1, gc.Types[gc.TUINT64], int64(w))
+ gmove(&n1, &n4)
+ gins(optoas(gc.OMUL, gc.Types[gc.TUINT64]), &n4, &n2)
+ gins(optoas(gc.OADD, gc.Types[gc.Tptr]), &n2, &n3)
+ regfree(&n4)
+ }
+
+ *a = n3
+ regfree(&n2)
+
+ default:
+ regalloc(a, gc.Types[gc.Tptr], res)
+ agen(n, a)
+ }
+}
+
+func ginsadd(as int, off int64, dst *gc.Node) {
+ var n1 gc.Node
+
+ regalloc(&n1, gc.Types[gc.Tptr], dst)
+ gmove(dst, &n1)
+ ginscon(as, off, &n1)
+ gmove(&n1, dst)
+ regfree(&n1)
+}
+
+/*
+ * generate:
+ * res = &n;
+ * The generated code checks that the result is not nil.
+ */
+func agen(n *gc.Node, res *gc.Node) {
+ var nl *gc.Node
+ var n1 gc.Node
+ var n2 gc.Node
+ var n3 gc.Node
+
+ if gc.Debug['g'] != 0 {
+ gc.Dump("\nagen-res", res)
+ gc.Dump("agen-r", n)
+ }
+
+ if n == nil || n.Type == nil {
+ return
+ }
+
+ for n.Op == gc.OCONVNOP {
+ n = n.Left
+ }
+
+ if gc.Isconst(n, gc.CTNIL) != 0 && n.Type.Width > int64(gc.Widthptr) {
+ // Use of a nil interface or nil slice.
+ // Create a temporary we can take the address of and read.
+ // The generated code is just going to panic, so it need not
+ // be terribly efficient. See issue 3670.
+ gc.Tempname(&n1, n.Type)
+
+ gc.Gvardef(&n1)
+ clearfat(&n1)
+ regalloc(&n2, gc.Types[gc.Tptr], res)
+ n3 = gc.Node{}
+ n3.Op = gc.OADDR
+ n3.Left = &n1
+ gins(ppc64.AMOVD, &n3, &n2)
+ gmove(&n2, res)
+ regfree(&n2)
+ goto ret
+ }
+
+ if n.Addable != 0 {
+ n1 = gc.Node{}
+ n1.Op = gc.OADDR
+ n1.Left = n
+ regalloc(&n2, gc.Types[gc.Tptr], res)
+ gins(ppc64.AMOVD, &n1, &n2)
+ gmove(&n2, res)
+ regfree(&n2)
+ goto ret
+ }
+
+ nl = n.Left
+
+ switch n.Op {
+ default:
+ gc.Fatal("agen: unknown op %v", gc.Nconv(n, obj.FmtShort|obj.FmtSign))
+
+ // TODO(minux): 5g has this: Release res so that it is available for cgen_call.
+ // Pick it up again after the call for OCALLMETH and OCALLFUNC.
+ case gc.OCALLMETH:
+ gc.Cgen_callmeth(n, 0)
+
+ cgen_aret(n, res)
+
+ case gc.OCALLINTER:
+ cgen_callinter(n, res, 0)
+ cgen_aret(n, res)
+
+ case gc.OCALLFUNC:
+ cgen_call(n, 0)
+ cgen_aret(n, res)
+
+ case gc.OSLICE,
+ gc.OSLICEARR,
+ gc.OSLICESTR,
+ gc.OSLICE3,
+ gc.OSLICE3ARR:
+ gc.Tempname(&n1, n.Type)
+ gc.Cgen_slice(n, &n1)
+ agen(&n1, res)
+
+ case gc.OEFACE:
+ gc.Tempname(&n1, n.Type)
+ gc.Cgen_eface(n, &n1)
+ agen(&n1, res)
+
+ case gc.OINDEX:
+ agenr(n, &n1, res)
+ gmove(&n1, res)
+ regfree(&n1)
+
+ // should only get here with names in this func.
+ case gc.ONAME:
+ if n.Funcdepth > 0 && n.Funcdepth != gc.Funcdepth {
+ gc.Dump("bad agen", n)
+ gc.Fatal("agen: bad ONAME funcdepth %d != %d", n.Funcdepth, gc.Funcdepth)
+ }
+
+ // should only get here for heap vars or paramref
+ if !(n.Class&gc.PHEAP != 0) && n.Class != gc.PPARAMREF {
+ gc.Dump("bad agen", n)
+ gc.Fatal("agen: bad ONAME class %#x", n.Class)
+ }
+
+ cgen(n.Heapaddr, res)
+ if n.Xoffset != 0 {
+ ginsadd(optoas(gc.OADD, gc.Types[gc.Tptr]), n.Xoffset, res)
+ }
+
+ case gc.OIND:
+ cgen(nl, res)
+ gc.Cgen_checknil(res)
+
+ case gc.ODOT:
+ agen(nl, res)
+ if n.Xoffset != 0 {
+ ginsadd(optoas(gc.OADD, gc.Types[gc.Tptr]), n.Xoffset, res)
+ }
+
+ case gc.ODOTPTR:
+ cgen(nl, res)
+ gc.Cgen_checknil(res)
+ if n.Xoffset != 0 {
+ ginsadd(optoas(gc.OADD, gc.Types[gc.Tptr]), n.Xoffset, res)
+ }
+ }
+
+ret:
+}
+
+/*
+ * generate:
+ * newreg = &n;
+ * res = newreg
+ *
+ * on exit, a has been changed to be *newreg.
+ * caller must regfree(a).
+ * The generated code checks that the result is not *nil.
+ */
+func igen(n *gc.Node, a *gc.Node, res *gc.Node) {
+ var fp *gc.Type
+ var flist gc.Iter
+ var n1 gc.Node
+
+ if gc.Debug['g'] != 0 {
+ gc.Dump("\nigen-n", n)
+ }
+
+ switch n.Op {
+ case gc.ONAME:
+ if (n.Class&gc.PHEAP != 0) || n.Class == gc.PPARAMREF {
+ break
+ }
+ *a = *n
+ return
+
+ // Increase the refcount of the register so that igen's caller
+ // has to call regfree.
+ case gc.OINDREG:
+ if n.Val.U.Reg != ppc64.REGSP {
+ reg[n.Val.U.Reg]++
+ }
+ *a = *n
+ return
+
+ case gc.ODOT:
+ igen(n.Left, a, res)
+ a.Xoffset += n.Xoffset
+ a.Type = n.Type
+ fixlargeoffset(a)
+ return
+
+ case gc.ODOTPTR:
+ cgenr(n.Left, a, res)
+ gc.Cgen_checknil(a)
+ a.Op = gc.OINDREG
+ a.Xoffset += n.Xoffset
+ a.Type = n.Type
+ fixlargeoffset(a)
+ return
+
+ case gc.OCALLFUNC,
+ gc.OCALLMETH,
+ gc.OCALLINTER:
+ switch n.Op {
+ case gc.OCALLFUNC:
+ cgen_call(n, 0)
+
+ case gc.OCALLMETH:
+ gc.Cgen_callmeth(n, 0)
+
+ case gc.OCALLINTER:
+ cgen_callinter(n, nil, 0)
+ }
+
+ fp = gc.Structfirst(&flist, gc.Getoutarg(n.Left.Type))
+ *a = gc.Node{}
+ a.Op = gc.OINDREG
+ a.Val.U.Reg = ppc64.REGSP
+ a.Addable = 1
+ a.Xoffset = fp.Width + int64(gc.Widthptr) // +widthptr: saved lr at 0(SP)
+ a.Type = n.Type
+ return
+
+ // Index of fixed-size array by constant can
+ // put the offset in the addressing.
+ // Could do the same for slice except that we need
+ // to use the real index for the bounds checking.
+ case gc.OINDEX:
+ if gc.Isfixedarray(n.Left.Type) != 0 || (gc.Isptr[n.Left.Type.Etype] != 0 && gc.Isfixedarray(n.Left.Left.Type) != 0) {
+ if gc.Isconst(n.Right, gc.CTINT) != 0 {
+ // Compute &a.
+ if !(gc.Isptr[n.Left.Type.Etype] != 0) {
+ igen(n.Left, a, res)
+ } else {
+ igen(n.Left, &n1, res)
+ gc.Cgen_checknil(&n1)
+ regalloc(a, gc.Types[gc.Tptr], res)
+ gmove(&n1, a)
+ regfree(&n1)
+ a.Op = gc.OINDREG
+ }
+
+ // Compute &a[i] as &a + i*width.
+ a.Type = n.Type
+
+ a.Xoffset += gc.Mpgetfix(n.Right.Val.U.Xval) * n.Type.Width
+ fixlargeoffset(a)
+ return
+ }
+ }
+ }
+
+ agenr(n, a, res)
+ a.Op = gc.OINDREG
+ a.Type = n.Type
+}
+
+/*
+ * generate:
+ * if(n == true) goto to;
+ */
+func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) {
+ var et int
+ var a int
+ var nl *gc.Node
+ var nr *gc.Node
+ var l *gc.Node
+ var r *gc.Node
+ var n1 gc.Node
+ var n2 gc.Node
+ var tmp gc.Node
+ var ll *gc.NodeList
+ var p1 *obj.Prog
+ var p2 *obj.Prog
+
+ if gc.Debug['g'] != 0 {
+ gc.Dump("\nbgen", n)
+ }
+
+ if n == nil {
+ n = gc.Nodbool(1)
+ }
+
+ if n.Ninit != nil {
+ gc.Genlist(n.Ninit)
+ }
+
+ if n.Type == nil {
+ gc.Convlit(&n, gc.Types[gc.TBOOL])
+ if n.Type == nil {
+ goto ret
+ }
+ }
+
+ et = int(n.Type.Etype)
+ if et != gc.TBOOL {
+ gc.Yyerror("cgen: bad type %v for %v", gc.Tconv(n.Type, 0), gc.Oconv(int(n.Op), 0))
+ gc.Patch(gins(obj.AEND, nil, nil), to)
+ goto ret
+ }
+
+ nr = nil
+
+ for n.Op == gc.OCONVNOP {
+ n = n.Left
+ if n.Ninit != nil {
+ gc.Genlist(n.Ninit)
+ }
+ }
+
+ switch n.Op {
+ default:
+ regalloc(&n1, n.Type, nil)
+ cgen(n, &n1)
+ gc.Nodconst(&n2, n.Type, 0)
+ gins(optoas(gc.OCMP, n.Type), &n1, &n2)
+ a = ppc64.ABNE
+ if !true_ {
+ a = ppc64.ABEQ
+ }
+ gc.Patch(gc.Gbranch(a, n.Type, likely), to)
+ regfree(&n1)
+ goto ret
+
+ // need to ask if it is bool?
+ case gc.OLITERAL:
+ if !true_ == !(n.Val.U.Bval != 0) {
+ gc.Patch(gc.Gbranch(ppc64.ABR, nil, likely), to)
+ }
+ goto ret
+
+ case gc.OANDAND,
+ gc.OOROR:
+ if (n.Op == gc.OANDAND) == true_ {
+ p1 = gc.Gbranch(obj.AJMP, nil, 0)
+ p2 = gc.Gbranch(obj.AJMP, nil, 0)
+ gc.Patch(p1, gc.Pc)
+ bgen(n.Left, !true_, -likely, p2)
+ bgen(n.Right, !true_, -likely, p2)
+ p1 = gc.Gbranch(obj.AJMP, nil, 0)
+ gc.Patch(p1, to)
+ gc.Patch(p2, gc.Pc)
+ } else {
+ bgen(n.Left, true_, likely, to)
+ bgen(n.Right, true_, likely, to)
+ }
+
+ goto ret
+
+ case gc.OEQ,
+ gc.ONE,
+ gc.OLT,
+ gc.OGT,
+ gc.OLE,
+ gc.OGE:
+ nr = n.Right
+ if nr == nil || nr.Type == nil {
+ goto ret
+ }
+ fallthrough
+
+ case gc.ONOT: // unary
+ nl = n.Left
+
+ if nl == nil || nl.Type == nil {
+ goto ret
+ }
+ }
+
+ switch n.Op {
+ case gc.ONOT:
+ bgen(nl, !true_, likely, to)
+ goto ret
+
+ case gc.OEQ,
+ gc.ONE,
+ gc.OLT,
+ gc.OGT,
+ gc.OLE,
+ gc.OGE:
+ a = int(n.Op)
+ if !true_ {
+ if gc.Isfloat[nr.Type.Etype] != 0 {
+ // brcom is not valid on floats when NaN is involved.
+ p1 = gc.Gbranch(ppc64.ABR, nil, 0)
+
+ p2 = gc.Gbranch(ppc64.ABR, nil, 0)
+ gc.Patch(p1, gc.Pc)
+ ll = n.Ninit // avoid re-genning ninit
+ n.Ninit = nil
+ bgen(n, true, -likely, p2)
+ n.Ninit = ll
+ gc.Patch(gc.Gbranch(ppc64.ABR, nil, 0), to)
+ gc.Patch(p2, gc.Pc)
+ goto ret
+ }
+
+ a = gc.Brcom(a)
+ true_ = !true_
+ }
+
+ // make simplest on right
+ if nl.Op == gc.OLITERAL || (nl.Ullman < nr.Ullman && nl.Ullman < gc.UINF) {
+ a = gc.Brrev(a)
+ r = nl
+ nl = nr
+ nr = r
+ }
+
+ if gc.Isslice(nl.Type) != 0 {
+ // front end should only leave cmp to literal nil
+ if (a != gc.OEQ && a != gc.ONE) || nr.Op != gc.OLITERAL {
+ gc.Yyerror("illegal slice comparison")
+ break
+ }
+
+ a = optoas(a, gc.Types[gc.Tptr])
+ igen(nl, &n1, nil)
+ n1.Xoffset += int64(gc.Array_array)
+ n1.Type = gc.Types[gc.Tptr]
+ gc.Nodconst(&tmp, gc.Types[gc.Tptr], 0)
+ regalloc(&n2, gc.Types[gc.Tptr], &n1)
+ gmove(&n1, &n2)
+ gins(optoas(gc.OCMP, gc.Types[gc.Tptr]), &n2, &tmp)
+ regfree(&n2)
+ gc.Patch(gc.Gbranch(a, gc.Types[gc.Tptr], likely), to)
+ regfree(&n1)
+ break
+ }
+
+ if gc.Isinter(nl.Type) != 0 {
+ // front end should only leave cmp to literal nil
+ if (a != gc.OEQ && a != gc.ONE) || nr.Op != gc.OLITERAL {
+ gc.Yyerror("illegal interface comparison")
+ break
+ }
+
+ a = optoas(a, gc.Types[gc.Tptr])
+ igen(nl, &n1, nil)
+ n1.Type = gc.Types[gc.Tptr]
+ gc.Nodconst(&tmp, gc.Types[gc.Tptr], 0)
+ regalloc(&n2, gc.Types[gc.Tptr], &n1)
+ gmove(&n1, &n2)
+ gins(optoas(gc.OCMP, gc.Types[gc.Tptr]), &n2, &tmp)
+ regfree(&n2)
+ gc.Patch(gc.Gbranch(a, gc.Types[gc.Tptr], likely), to)
+ regfree(&n1)
+ break
+ }
+
+ if gc.Iscomplex[nl.Type.Etype] != 0 {
+ gc.Complexbool(a, nl, nr, true_, likely, to)
+ break
+ }
+
+ if nr.Ullman >= gc.UINF {
+ regalloc(&n1, nl.Type, nil)
+ cgen(nl, &n1)
+
+ gc.Tempname(&tmp, nl.Type)
+ gmove(&n1, &tmp)
+ regfree(&n1)
+
+ regalloc(&n2, nr.Type, nil)
+ cgen(nr, &n2)
+
+ regalloc(&n1, nl.Type, nil)
+ cgen(&tmp, &n1)
+
+ goto cmp
+ }
+
+ regalloc(&n1, nl.Type, nil)
+ cgen(nl, &n1)
+
+ // TODO(minux): cmpi does accept 16-bit signed immediate as p->to.
+ // and cmpli accepts 16-bit unsigned immediate.
+ //if(smallintconst(nr)) {
+ // gins(optoas(OCMP, nr->type), &n1, nr);
+ // patch(gbranch(optoas(a, nr->type), nr->type, likely), to);
+ // regfree(&n1);
+ // break;
+ //}
+
+ regalloc(&n2, nr.Type, nil)
+
+ cgen(nr, &n2)
+
+ cmp:
+ l = &n1
+ r = &n2
+ gins(optoas(gc.OCMP, nr.Type), l, r)
+ if gc.Isfloat[nr.Type.Etype] != 0 && (a == gc.OLE || a == gc.OGE) {
+ // To get NaN right, must rewrite x <= y into separate x < y or x = y.
+ switch a {
+ case gc.OLE:
+ a = gc.OLT
+
+ case gc.OGE:
+ a = gc.OGT
+ }
+
+ gc.Patch(gc.Gbranch(optoas(a, nr.Type), nr.Type, likely), to)
+ gc.Patch(gc.Gbranch(optoas(gc.OEQ, nr.Type), nr.Type, likely), to)
+ } else {
+ gc.Patch(gc.Gbranch(optoas(a, nr.Type), nr.Type, likely), to)
+ }
+
+ regfree(&n1)
+ regfree(&n2)
+ }
+
+ goto ret
+
+ret:
+}
+
+/*
+ * n is on stack, either local variable
+ * or return value from function call.
+ * return n's offset from SP.
+ */
+func stkof(n *gc.Node) int64 {
+ var t *gc.Type
+ var flist gc.Iter
+ var off int64
+
+ switch n.Op {
+ case gc.OINDREG:
+ return n.Xoffset
+
+ case gc.ODOT:
+ t = n.Left.Type
+ if gc.Isptr[t.Etype] != 0 {
+ break
+ }
+ off = stkof(n.Left)
+ if off == -1000 || off == 1000 {
+ return off
+ }
+ return off + n.Xoffset
+
+ case gc.OINDEX:
+ t = n.Left.Type
+ if !(gc.Isfixedarray(t) != 0) {
+ break
+ }
+ off = stkof(n.Left)
+ if off == -1000 || off == 1000 {
+ return off
+ }
+ if gc.Isconst(n.Right, gc.CTINT) != 0 {
+ return off + t.Type.Width*gc.Mpgetfix(n.Right.Val.U.Xval)
+ }
+ return 1000
+
+ case gc.OCALLMETH,
+ gc.OCALLINTER,
+ gc.OCALLFUNC:
+ t = n.Left.Type
+ if gc.Isptr[t.Etype] != 0 {
+ t = t.Type
+ }
+
+ t = gc.Structfirst(&flist, gc.Getoutarg(t))
+ if t != nil {
+ return t.Width + int64(gc.Widthptr) // +widthptr: correct for saved LR
+ }
+ }
+
+ // botch - probably failing to recognize address
+ // arithmetic on the above. eg INDEX and DOT
+ return -1000
+}
+
+/*
+ * block copy:
+ * memmove(&ns, &n, w);
+ */
+func sgen(n *gc.Node, ns *gc.Node, w int64) {
+ var dst gc.Node
+ var src gc.Node
+ var tmp gc.Node
+ var nend gc.Node
+ var c int32
+ var odst int32
+ var osrc int32
+ var dir int
+ var align int
+ var op int
+ var p *obj.Prog
+ var ploop *obj.Prog
+ var l *gc.NodeList
+ var res *gc.Node = ns
+
+ if gc.Debug['g'] != 0 {
+ fmt.Printf("\nsgen w=%d\n", w)
+ gc.Dump("r", n)
+ gc.Dump("res", ns)
+ }
+
+ if n.Ullman >= gc.UINF && ns.Ullman >= gc.UINF {
+ gc.Fatal("sgen UINF")
+ }
+
+ if w < 0 {
+ gc.Fatal("sgen copy %d", w)
+ }
+
+ // If copying .args, that's all the results, so record definition sites
+ // for them for the liveness analysis.
+ if ns.Op == gc.ONAME && ns.Sym.Name == ".args" {
+ for l = gc.Curfn.Dcl; l != nil; l = l.Next {
+ if l.N.Class == gc.PPARAMOUT {
+ gc.Gvardef(l.N)
+ }
+ }
+ }
+
+ // Avoid taking the address for simple enough types.
+ //if(componentgen(n, ns))
+ // return;
+ if w == 0 {
+ // evaluate side effects only.
+ regalloc(&dst, gc.Types[gc.Tptr], nil)
+
+ agen(res, &dst)
+ agen(n, &dst)
+ regfree(&dst)
+ return
+ }
+
+ // determine alignment.
+ // want to avoid unaligned access, so have to use
+ // smaller operations for less aligned types.
+ // for example moving [4]byte must use 4 MOVB not 1 MOVW.
+ align = int(n.Type.Align)
+
+ switch align {
+ default:
+ gc.Fatal("sgen: invalid alignment %d for %v", align, gc.Tconv(n.Type, 0))
+ fallthrough
+
+ case 1:
+ op = ppc64.AMOVBU
+
+ case 2:
+ op = ppc64.AMOVHU
+
+ case 4:
+ op = ppc64.AMOVWZU // there is no lwau, only lwaux
+
+ case 8:
+ op = ppc64.AMOVDU
+ }
+
+ if w%int64(align) != 0 {
+ gc.Fatal("sgen: unaligned size %d (align=%d) for %v", w, align, gc.Tconv(n.Type, 0))
+ }
+ c = int32(w / int64(align))
+
+ // offset on the stack
+ osrc = int32(stkof(n))
+
+ odst = int32(stkof(res))
+ if osrc != -1000 && odst != -1000 && (osrc == 1000 || odst == 1000) {
+ // osrc and odst both on stack, and at least one is in
+ // an unknown position. Could generate code to test
+ // for forward/backward copy, but instead just copy
+ // to a temporary location first.
+ gc.Tempname(&tmp, n.Type)
+
+ sgen(n, &tmp, w)
+ sgen(&tmp, res, w)
+ return
+ }
+
+ if osrc%int32(align) != 0 || odst%int32(align) != 0 {
+ gc.Fatal("sgen: unaligned offset src %d or dst %d (align %d)", osrc, odst, align)
+ }
+
+ // if we are copying forward on the stack and
+ // the src and dst overlap, then reverse direction
+ dir = align
+
+ if osrc < odst && int64(odst) < int64(osrc)+w {
+ dir = -dir
+ }
+
+ if n.Ullman >= res.Ullman {
+ agenr(n, &dst, res) // temporarily use dst
+ regalloc(&src, gc.Types[gc.Tptr], nil)
+ gins(ppc64.AMOVD, &dst, &src)
+ if res.Op == gc.ONAME {
+ gc.Gvardef(res)
+ }
+ agen(res, &dst)
+ } else {
+ if res.Op == gc.ONAME {
+ gc.Gvardef(res)
+ }
+ agenr(res, &dst, res)
+ agenr(n, &src, nil)
+ }
+
+ regalloc(&tmp, gc.Types[gc.Tptr], nil)
+
+ // set up end marker
+ nend = gc.Node{}
+
+ // move src and dest to the end of block if necessary
+ if dir < 0 {
+ if c >= 4 {
+ regalloc(&nend, gc.Types[gc.Tptr], nil)
+ p = gins(ppc64.AMOVD, &src, &nend)
+ }
+
+ p = gins(ppc64.AADD, nil, &src)
+ p.From.Type = obj.TYPE_CONST
+ p.From.Offset = w
+
+ p = gins(ppc64.AADD, nil, &dst)
+ p.From.Type = obj.TYPE_CONST
+ p.From.Offset = w
+ } else {
+ p = gins(ppc64.AADD, nil, &src)
+ p.From.Type = obj.TYPE_CONST
+ p.From.Offset = int64(-dir)
+
+ p = gins(ppc64.AADD, nil, &dst)
+ p.From.Type = obj.TYPE_CONST
+ p.From.Offset = int64(-dir)
+
+ if c >= 4 {
+ regalloc(&nend, gc.Types[gc.Tptr], nil)
+ p = gins(ppc64.AMOVD, &src, &nend)
+ p.From.Type = obj.TYPE_ADDR
+ p.From.Offset = w
+ }
+ }
+
+ // move
+ // TODO: enable duffcopy for larger copies.
+ if c >= 4 {
+ p = gins(op, &src, &tmp)
+ p.From.Type = obj.TYPE_MEM
+ p.From.Offset = int64(dir)
+ ploop = p
+
+ p = gins(op, &tmp, &dst)
+ p.To.Type = obj.TYPE_MEM
+ p.To.Offset = int64(dir)
+
+ p = gins(ppc64.ACMP, &src, &nend)
+
+ gc.Patch(gc.Gbranch(ppc64.ABNE, nil, 0), ploop)
+ regfree(&nend)
+ } else {
+ // TODO(austin): Instead of generating ADD $-8,R8; ADD
+ // $-8,R7; n*(MOVDU 8(R8),R9; MOVDU R9,8(R7);) just
+ // generate the offsets directly and eliminate the
+ // ADDs. That will produce shorter, more
+ // pipeline-able code.
+ for {
+ tmp14 := c
+ c--
+ if !(tmp14 > 0) {
+ break
+ }
+
+ p = gins(op, &src, &tmp)
+ p.From.Type = obj.TYPE_MEM
+ p.From.Offset = int64(dir)
+
+ p = gins(op, &tmp, &dst)
+ p.To.Type = obj.TYPE_MEM
+ p.To.Offset = int64(dir)
+ }
+ }
+
+ regfree(&dst)
+ regfree(&src)
+ regfree(&tmp)
+}
+
+func cadable(n *gc.Node) int {
+ if !(n.Addable != 0) {
+ // dont know how it happens,
+ // but it does
+ return 0
+ }
+
+ switch n.Op {
+ case gc.ONAME:
+ return 1
+ }
+
+ return 0
+}
+
+/*
+ * copy a composite value by moving its individual components.
+ * Slices, strings and interfaces are supported.
+ * Small structs or arrays with elements of basic type are
+ * also supported.
+ * nr is N when assigning a zero value.
+ * return 1 if can do, 0 if can't.
+ */
+func componentgen(nr *gc.Node, nl *gc.Node) int {
+ var nodl gc.Node
+ var nodr gc.Node
+ var tmp gc.Node
+ var t *gc.Type
+ var freel int
+ var freer int
+ var fldcount int64
+ var loffset int64
+ var roffset int64
+
+ freel = 0
+ freer = 0
+
+ switch nl.Type.Etype {
+ default:
+ goto no
+
+ case gc.TARRAY:
+ t = nl.Type
+
+ // Slices are ok.
+ if gc.Isslice(t) != 0 {
+ break
+ }
+
+ // Small arrays are ok.
+ if t.Bound > 0 && t.Bound <= 3 && !(gc.Isfat(t.Type) != 0) {
+ break
+ }
+
+ goto no
+
+ // Small structs with non-fat types are ok.
+ // Zero-sized structs are treated separately elsewhere.
+ case gc.TSTRUCT:
+ fldcount = 0
+
+ for t = nl.Type.Type; t != nil; t = t.Down {
+ if gc.Isfat(t.Type) != 0 {
+ goto no
+ }
+ if t.Etype != gc.TFIELD {
+ gc.Fatal("componentgen: not a TFIELD: %v", gc.Tconv(t, obj.FmtLong))
+ }
+ fldcount++
+ }
+
+ if fldcount == 0 || fldcount > 4 {
+ goto no
+ }
+
+ case gc.TSTRING,
+ gc.TINTER:
+ break
+ }
+
+ nodl = *nl
+ if !(cadable(nl) != 0) {
+ if nr != nil && !(cadable(nr) != 0) {
+ goto no
+ }
+ igen(nl, &nodl, nil)
+ freel = 1
+ }
+
+ if nr != nil {
+ nodr = *nr
+ if !(cadable(nr) != 0) {
+ igen(nr, &nodr, nil)
+ freer = 1
+ }
+ } else {
+ // When zeroing, prepare a register containing zero.
+ gc.Nodconst(&tmp, nl.Type, 0)
+
+ regalloc(&nodr, gc.Types[gc.TUINT], nil)
+ gmove(&tmp, &nodr)
+ freer = 1
+ }
+
+ // nl and nr are 'cadable' which basically means they are names (variables) now.
+ // If they are the same variable, don't generate any code, because the
+ // VARDEF we generate will mark the old value as dead incorrectly.
+ // (And also the assignments are useless.)
+ if nr != nil && nl.Op == gc.ONAME && nr.Op == gc.ONAME && nl == nr {
+ goto yes
+ }
+
+ switch nl.Type.Etype {
+ // componentgen for arrays.
+ case gc.TARRAY:
+ if nl.Op == gc.ONAME {
+ gc.Gvardef(nl)
+ }
+ t = nl.Type
+ if !(gc.Isslice(t) != 0) {
+ nodl.Type = t.Type
+ nodr.Type = nodl.Type
+ for fldcount = 0; fldcount < t.Bound; fldcount++ {
+ if nr == nil {
+ gc.Clearslim(&nodl)
+ } else {
+ gmove(&nodr, &nodl)
+ }
+ nodl.Xoffset += t.Type.Width
+ nodr.Xoffset += t.Type.Width
+ }
+
+ goto yes
+ }
+
+ // componentgen for slices.
+ nodl.Xoffset += int64(gc.Array_array)
+
+ nodl.Type = gc.Ptrto(nl.Type.Type)
+
+ if nr != nil {
+ nodr.Xoffset += int64(gc.Array_array)
+ nodr.Type = nodl.Type
+ }
+
+ gmove(&nodr, &nodl)
+
+ nodl.Xoffset += int64(gc.Array_nel) - int64(gc.Array_array)
+ nodl.Type = gc.Types[gc.Simtype[gc.TUINT]]
+
+ if nr != nil {
+ nodr.Xoffset += int64(gc.Array_nel) - int64(gc.Array_array)
+ nodr.Type = nodl.Type
+ }
+
+ gmove(&nodr, &nodl)
+
+ nodl.Xoffset += int64(gc.Array_cap) - int64(gc.Array_nel)
+ nodl.Type = gc.Types[gc.Simtype[gc.TUINT]]
+
+ if nr != nil {
+ nodr.Xoffset += int64(gc.Array_cap) - int64(gc.Array_nel)
+ nodr.Type = nodl.Type
+ }
+
+ gmove(&nodr, &nodl)
+
+ goto yes
+
+ case gc.TSTRING:
+ if nl.Op == gc.ONAME {
+ gc.Gvardef(nl)
+ }
+ nodl.Xoffset += int64(gc.Array_array)
+ nodl.Type = gc.Ptrto(gc.Types[gc.TUINT8])
+
+ if nr != nil {
+ nodr.Xoffset += int64(gc.Array_array)
+ nodr.Type = nodl.Type
+ }
+
+ gmove(&nodr, &nodl)
+
+ nodl.Xoffset += int64(gc.Array_nel) - int64(gc.Array_array)
+ nodl.Type = gc.Types[gc.Simtype[gc.TUINT]]
+
+ if nr != nil {
+ nodr.Xoffset += int64(gc.Array_nel) - int64(gc.Array_array)
+ nodr.Type = nodl.Type
+ }
+
+ gmove(&nodr, &nodl)
+
+ goto yes
+
+ case gc.TINTER:
+ if nl.Op == gc.ONAME {
+ gc.Gvardef(nl)
+ }
+ nodl.Xoffset += int64(gc.Array_array)
+ nodl.Type = gc.Ptrto(gc.Types[gc.TUINT8])
+
+ if nr != nil {
+ nodr.Xoffset += int64(gc.Array_array)
+ nodr.Type = nodl.Type
+ }
+
+ gmove(&nodr, &nodl)
+
+ nodl.Xoffset += int64(gc.Array_nel) - int64(gc.Array_array)
+ nodl.Type = gc.Ptrto(gc.Types[gc.TUINT8])
+
+ if nr != nil {
+ nodr.Xoffset += int64(gc.Array_nel) - int64(gc.Array_array)
+ nodr.Type = nodl.Type
+ }
+
+ gmove(&nodr, &nodl)
+
+ goto yes
+
+ case gc.TSTRUCT:
+ if nl.Op == gc.ONAME {
+ gc.Gvardef(nl)
+ }
+ loffset = nodl.Xoffset
+ roffset = nodr.Xoffset
+
+ // funarg structs may not begin at offset zero.
+ if nl.Type.Etype == gc.TSTRUCT && nl.Type.Funarg != 0 && nl.Type.Type != nil {
+ loffset -= nl.Type.Type.Width
+ }
+ if nr != nil && nr.Type.Etype == gc.TSTRUCT && nr.Type.Funarg != 0 && nr.Type.Type != nil {
+ roffset -= nr.Type.Type.Width
+ }
+
+ for t = nl.Type.Type; t != nil; t = t.Down {
+ nodl.Xoffset = loffset + t.Width
+ nodl.Type = t.Type
+
+ if nr == nil {
+ gc.Clearslim(&nodl)
+ } else {
+ nodr.Xoffset = roffset + t.Width
+ nodr.Type = nodl.Type
+ gmove(&nodr, &nodl)
+ }
+ }
+
+ goto yes
+ }
+
+no:
+ if freer != 0 {
+ regfree(&nodr)
+ }
+ if freel != 0 {
+ regfree(&nodl)
+ }
+ return 0
+
+yes:
+ if freer != 0 {
+ regfree(&nodr)
+ }
+ if freel != 0 {
+ regfree(&nodl)
+ }
+ return 1
+}
--- /dev/null
+// 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 main
+
+import (
+ "cmd/internal/obj"
+ "cmd/internal/obj/ppc64"
+)
+import "cmd/internal/gc"
+
+var thechar int = '9'
+
+var thestring string = "ppc64"
+
+var thelinkarch *obj.LinkArch
+
+func linkarchinit() {
+ thestring = obj.Getgoarch()
+ gc.Thearch.Thestring = thestring
+ if thestring == "ppc64le" {
+ thelinkarch = &ppc64.Linkppc64le
+ } else {
+ thelinkarch = &ppc64.Linkppc64
+ }
+ gc.Thearch.Thelinkarch = thelinkarch
+}
+
+var MAXWIDTH int64 = 1 << 50
+
+/*
+ * go declares several platform-specific type aliases:
+ * int, uint, float, and uintptr
+ */
+var typedefs = []gc.Typedef{
+ gc.Typedef{"int", gc.TINT, gc.TINT64},
+ gc.Typedef{"uint", gc.TUINT, gc.TUINT64},
+ gc.Typedef{"uintptr", gc.TUINTPTR, gc.TUINT64},
+}
+
+func betypeinit() {
+ gc.Widthptr = 8
+ gc.Widthint = 8
+ gc.Widthreg = 8
+
+}
+
+func main() {
+ gc.Thearch.Thechar = thechar
+ gc.Thearch.Thestring = thestring
+ gc.Thearch.Thelinkarch = thelinkarch
+ gc.Thearch.Typedefs = typedefs
+ gc.Thearch.REGSP = ppc64.REGSP
+ gc.Thearch.REGCTXT = ppc64.REGCTXT
+ gc.Thearch.MAXWIDTH = MAXWIDTH
+ gc.Thearch.Anyregalloc = anyregalloc
+ gc.Thearch.Betypeinit = betypeinit
+ gc.Thearch.Bgen = bgen
+ gc.Thearch.Cgen = cgen
+ gc.Thearch.Cgen_call = cgen_call
+ gc.Thearch.Cgen_callinter = cgen_callinter
+ gc.Thearch.Cgen_ret = cgen_ret
+ gc.Thearch.Clearfat = clearfat
+ gc.Thearch.Defframe = defframe
+ gc.Thearch.Excise = excise
+ gc.Thearch.Expandchecks = expandchecks
+ gc.Thearch.Gclean = gclean
+ gc.Thearch.Ginit = ginit
+ gc.Thearch.Gins = gins
+ gc.Thearch.Ginscall = ginscall
+ gc.Thearch.Igen = igen
+ gc.Thearch.Linkarchinit = linkarchinit
+ gc.Thearch.Peep = peep
+ gc.Thearch.Proginfo = proginfo
+ gc.Thearch.Regalloc = regalloc
+ gc.Thearch.Regfree = regfree
+ gc.Thearch.Regtyp = regtyp
+ gc.Thearch.Sameaddr = sameaddr
+ gc.Thearch.Smallindir = smallindir
+ gc.Thearch.Stackaddr = stackaddr
+ gc.Thearch.Excludedregs = excludedregs
+ gc.Thearch.RtoB = RtoB
+ gc.Thearch.FtoB = RtoB
+ gc.Thearch.BtoR = BtoR
+ gc.Thearch.BtoF = BtoF
+ gc.Thearch.Optoas = optoas
+ gc.Thearch.Doregbits = doregbits
+ gc.Thearch.Regnames = regnames
+
+ gc.Main()
+}
--- /dev/null
+// 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 main
+
+import "cmd/internal/obj/ppc64"
+import "cmd/internal/gc"
+
+// Copyright 2014 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.
+
+var reg [ppc64.NREG + ppc64.NFREG]uint8
+
+var panicdiv *gc.Node
+
+/*
+ * cgen.c
+ */
+
+/*
+ * list.c
+ */
+
+/*
+ * reg.c
+ */
--- /dev/null
+// 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 main
+
+import (
+ "cmd/internal/obj"
+ "cmd/internal/obj/ppc64"
+ "fmt"
+)
+import "cmd/internal/gc"
+
+func defframe(ptxt *obj.Prog) {
+ var frame uint32
+ var p *obj.Prog
+ var hi int64
+ var lo int64
+ var l *gc.NodeList
+ var n *gc.Node
+
+ // fill in argument size, stack size
+ ptxt.To.Type = obj.TYPE_TEXTSIZE
+
+ ptxt.To.U.Argsize = int32(gc.Rnd(gc.Curfn.Type.Argwid, int64(gc.Widthptr)))
+ frame = uint32(gc.Rnd(gc.Stksize+gc.Maxarg, int64(gc.Widthreg)))
+ ptxt.To.Offset = int64(frame)
+
+ // insert code to zero ambiguously live variables
+ // so that the garbage collector only sees initialized values
+ // when it looks for pointers.
+ p = ptxt
+
+ hi = 0
+ lo = hi
+
+ // iterate through declarations - they are sorted in decreasing xoffset order.
+ for l = gc.Curfn.Dcl; l != nil; l = l.Next {
+ n = l.N
+ if !(n.Needzero != 0) {
+ continue
+ }
+ if n.Class != gc.PAUTO {
+ gc.Fatal("needzero class %d", n.Class)
+ }
+ if n.Type.Width%int64(gc.Widthptr) != 0 || n.Xoffset%int64(gc.Widthptr) != 0 || n.Type.Width == 0 {
+ gc.Fatal("var %v has size %d offset %d", gc.Nconv(n, obj.FmtLong), int(n.Type.Width), int(n.Xoffset))
+ }
+
+ if lo != hi && n.Xoffset+n.Type.Width >= lo-int64(2*gc.Widthreg) {
+ // merge with range we already have
+ lo = n.Xoffset
+
+ continue
+ }
+
+ // zero old range
+ p = zerorange(p, int64(frame), lo, hi)
+
+ // set new range
+ hi = n.Xoffset + n.Type.Width
+
+ lo = n.Xoffset
+ }
+
+ // zero final range
+ zerorange(p, int64(frame), lo, hi)
+}
+
+func zerorange(p *obj.Prog, frame int64, lo int64, hi int64) *obj.Prog {
+ var cnt int64
+ var i int64
+ var p1 *obj.Prog
+ var f *gc.Node
+
+ cnt = hi - lo
+ if cnt == 0 {
+ return p
+ }
+ if cnt < int64(4*gc.Widthptr) {
+ for i = 0; i < cnt; i += int64(gc.Widthptr) {
+ p = appendpp(p, ppc64.AMOVD, obj.TYPE_REG, ppc64.REGZERO, 0, obj.TYPE_MEM, ppc64.REGSP, 8+frame+lo+i)
+ }
+ } else if cnt <= int64(128*gc.Widthptr) {
+ p = appendpp(p, ppc64.AADD, obj.TYPE_CONST, 0, 8+frame+lo-8, obj.TYPE_REG, ppc64.REGRT1, 0)
+ p.Reg = ppc64.REGSP
+ p = appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
+ f = gc.Sysfunc("duffzero")
+ gc.Naddr(f, &p.To, 1)
+ gc.Afunclit(&p.To, f)
+ p.To.Offset = 4 * (128 - cnt/int64(gc.Widthptr))
+ } else {
+ p = appendpp(p, ppc64.AMOVD, obj.TYPE_CONST, 0, 8+frame+lo-8, obj.TYPE_REG, ppc64.REGTMP, 0)
+ p = appendpp(p, ppc64.AADD, obj.TYPE_REG, ppc64.REGTMP, 0, obj.TYPE_REG, ppc64.REGRT1, 0)
+ p.Reg = ppc64.REGSP
+ p = appendpp(p, ppc64.AMOVD, obj.TYPE_CONST, 0, cnt, obj.TYPE_REG, ppc64.REGTMP, 0)
+ p = appendpp(p, ppc64.AADD, obj.TYPE_REG, ppc64.REGTMP, 0, obj.TYPE_REG, ppc64.REGRT2, 0)
+ p.Reg = ppc64.REGRT1
+ p = appendpp(p, ppc64.AMOVDU, obj.TYPE_REG, ppc64.REGZERO, 0, obj.TYPE_MEM, ppc64.REGRT1, int64(gc.Widthptr))
+ p1 = p
+ p = appendpp(p, ppc64.ACMP, obj.TYPE_REG, ppc64.REGRT1, 0, obj.TYPE_REG, ppc64.REGRT2, 0)
+ p = appendpp(p, ppc64.ABNE, obj.TYPE_NONE, 0, 0, obj.TYPE_BRANCH, 0, 0)
+ gc.Patch(p, p1)
+ }
+
+ return p
+}
+
+func appendpp(p *obj.Prog, as int, ftype int, freg int, foffset int64, ttype int, treg int, toffset int64) *obj.Prog {
+ var q *obj.Prog
+ q = gc.Ctxt.NewProg()
+ gc.Clearp(q)
+ q.As = int16(as)
+ q.Lineno = p.Lineno
+ q.From.Type = int16(ftype)
+ q.From.Reg = int16(freg)
+ q.From.Offset = foffset
+ q.To.Type = int16(ttype)
+ q.To.Reg = int16(treg)
+ q.To.Offset = toffset
+ q.Link = p.Link
+ p.Link = q
+ return q
+}
+
+/*
+ * generate: BL reg, f
+ * where both reg and f are registers.
+ * On power, f must be moved to CTR first.
+ */
+func ginsBL(reg *gc.Node, f *gc.Node) {
+ var p *obj.Prog
+ p = gins(ppc64.AMOVD, f, nil)
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = ppc64.REG_CTR
+ p = gins(ppc64.ABL, reg, nil)
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = ppc64.REG_CTR
+}
+
+/*
+ * generate:
+ * call f
+ * proc=-1 normal call but no return
+ * proc=0 normal call
+ * proc=1 goroutine run in new proc
+ * proc=2 defer call save away stack
+ * proc=3 normal call to C pointer (not Go func value)
+*/
+func ginscall(f *gc.Node, proc int) {
+ var p *obj.Prog
+ var reg gc.Node
+ var con gc.Node
+ var reg2 gc.Node
+ var r1 gc.Node
+ var extra int32
+
+ if f.Type != nil {
+ extra = 0
+ if proc == 1 || proc == 2 {
+ extra = 2 * int32(gc.Widthptr)
+ }
+ gc.Setmaxarg(f.Type, extra)
+ }
+
+ switch proc {
+ default:
+ gc.Fatal("ginscall: bad proc %d", proc)
+
+ case 0, // normal call
+ -1: // normal call but no return
+ if f.Op == gc.ONAME && f.Class == gc.PFUNC {
+ if f == gc.Deferreturn {
+ // Deferred calls will appear to be returning to
+ // the CALL deferreturn(SB) that we are about to emit.
+ // However, the stack trace code will show the line
+ // of the instruction byte before the return PC.
+ // To avoid that being an unrelated instruction,
+ // insert a ppc64 NOP that we will have the right line number.
+ // The ppc64 NOP is really or r0, r0, r0; use that description
+ // because the NOP pseudo-instruction would be removed by
+ // the linker.
+ gc.Nodreg(®, gc.Types[gc.TINT], ppc64.REG_R0)
+
+ gins(ppc64.AOR, ®, ®)
+ }
+
+ p = gins(ppc64.ABL, nil, f)
+ gc.Afunclit(&p.To, f)
+ if proc == -1 || gc.Noreturn(p) != 0 {
+ gins(obj.AUNDEF, nil, nil)
+ }
+ break
+ }
+
+ gc.Nodreg(®, gc.Types[gc.Tptr], ppc64.REGCTXT)
+ gc.Nodreg(&r1, gc.Types[gc.Tptr], ppc64.REG_R3)
+ gmove(f, ®)
+ reg.Op = gc.OINDREG
+ gmove(®, &r1)
+ reg.Op = gc.OREGISTER
+ ginsBL(®, &r1)
+
+ case 3: // normal call of c function pointer
+ ginsBL(nil, f)
+
+ case 1, // call in new proc (go)
+ 2: // deferred call (defer)
+ gc.Nodconst(&con, gc.Types[gc.TINT64], int64(gc.Argsize(f.Type)))
+
+ gc.Nodreg(®, gc.Types[gc.TINT64], ppc64.REG_R3)
+ gc.Nodreg(®2, gc.Types[gc.TINT64], ppc64.REG_R4)
+ gmove(f, ®)
+
+ gmove(&con, ®2)
+ p = gins(ppc64.AMOVW, ®2, nil)
+ p.To.Type = obj.TYPE_MEM
+ p.To.Reg = ppc64.REGSP
+ p.To.Offset = 8
+
+ p = gins(ppc64.AMOVD, ®, nil)
+ p.To.Type = obj.TYPE_MEM
+ p.To.Reg = ppc64.REGSP
+ p.To.Offset = 16
+
+ if proc == 1 {
+ ginscall(gc.Newproc, 0)
+ } else {
+ if !(gc.Hasdefer != 0) {
+ gc.Fatal("hasdefer=0 but has defer")
+ }
+ ginscall(gc.Deferproc, 0)
+ }
+
+ if proc == 2 {
+ gc.Nodreg(®, gc.Types[gc.TINT64], ppc64.REG_R3)
+ p = gins(ppc64.ACMP, ®, nil)
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = ppc64.REG_R0
+ p = gc.Gbranch(ppc64.ABEQ, nil, +1)
+ cgen_ret(nil)
+ gc.Patch(p, gc.Pc)
+ }
+ }
+}
+
+/*
+ * n is call to interface method.
+ * generate res = n.
+ */
+func cgen_callinter(n *gc.Node, res *gc.Node, proc int) {
+ var i *gc.Node
+ var f *gc.Node
+ var tmpi gc.Node
+ var nodi gc.Node
+ var nodo gc.Node
+ var nodr gc.Node
+ var nodsp gc.Node
+ var p *obj.Prog
+
+ i = n.Left
+ if i.Op != gc.ODOTINTER {
+ gc.Fatal("cgen_callinter: not ODOTINTER %v", gc.Oconv(int(i.Op), 0))
+ }
+
+ f = i.Right // field
+ if f.Op != gc.ONAME {
+ gc.Fatal("cgen_callinter: not ONAME %v", gc.Oconv(int(f.Op), 0))
+ }
+
+ i = i.Left // interface
+
+ if !(i.Addable != 0) {
+ gc.Tempname(&tmpi, i.Type)
+ cgen(i, &tmpi)
+ i = &tmpi
+ }
+
+ gc.Genlist(n.List) // assign the args
+
+ // i is now addable, prepare an indirected
+ // register to hold its address.
+ igen(i, &nodi, res) // REG = &inter
+
+ gc.Nodindreg(&nodsp, gc.Types[gc.Tptr], ppc64.REGSP)
+
+ nodsp.Xoffset = int64(gc.Widthptr)
+ if proc != 0 {
+ nodsp.Xoffset += 2 * int64(gc.Widthptr) // leave room for size & fn
+ }
+ nodi.Type = gc.Types[gc.Tptr]
+ nodi.Xoffset += int64(gc.Widthptr)
+ cgen(&nodi, &nodsp) // {8 or 24}(SP) = 8(REG) -- i.data
+
+ regalloc(&nodo, gc.Types[gc.Tptr], res)
+
+ nodi.Type = gc.Types[gc.Tptr]
+ nodi.Xoffset -= int64(gc.Widthptr)
+ cgen(&nodi, &nodo) // REG = 0(REG) -- i.tab
+ regfree(&nodi)
+
+ regalloc(&nodr, gc.Types[gc.Tptr], &nodo)
+ if n.Left.Xoffset == gc.BADWIDTH {
+ gc.Fatal("cgen_callinter: badwidth")
+ }
+ gc.Cgen_checknil(&nodo) // in case offset is huge
+ nodo.Op = gc.OINDREG
+ nodo.Xoffset = n.Left.Xoffset + 3*int64(gc.Widthptr) + 8
+ if proc == 0 {
+ // plain call: use direct c function pointer - more efficient
+ cgen(&nodo, &nodr) // REG = 32+offset(REG) -- i.tab->fun[f]
+ proc = 3
+ } else {
+ // go/defer. generate go func value.
+ p = gins(ppc64.AMOVD, &nodo, &nodr) // REG = &(32+offset(REG)) -- i.tab->fun[f]
+ p.From.Type = obj.TYPE_ADDR
+ }
+
+ nodr.Type = n.Left.Type
+ ginscall(&nodr, proc)
+
+ regfree(&nodr)
+ regfree(&nodo)
+}
+
+/*
+ * generate function call;
+ * proc=0 normal call
+ * proc=1 goroutine run in new proc
+ * proc=2 defer call save away stack
+ */
+func cgen_call(n *gc.Node, proc int) {
+ var t *gc.Type
+ var nod gc.Node
+ var afun gc.Node
+
+ if n == nil {
+ return
+ }
+
+ if n.Left.Ullman >= gc.UINF {
+ // if name involves a fn call
+ // precompute the address of the fn
+ gc.Tempname(&afun, gc.Types[gc.Tptr])
+
+ cgen(n.Left, &afun)
+ }
+
+ gc.Genlist(n.List) // assign the args
+ t = n.Left.Type
+
+ // call tempname pointer
+ if n.Left.Ullman >= gc.UINF {
+ regalloc(&nod, gc.Types[gc.Tptr], nil)
+ gc.Cgen_as(&nod, &afun)
+ nod.Type = t
+ ginscall(&nod, proc)
+ regfree(&nod)
+ return
+ }
+
+ // call pointer
+ if n.Left.Op != gc.ONAME || n.Left.Class != gc.PFUNC {
+ regalloc(&nod, gc.Types[gc.Tptr], nil)
+ gc.Cgen_as(&nod, n.Left)
+ nod.Type = t
+ ginscall(&nod, proc)
+ regfree(&nod)
+ return
+ }
+
+ // call direct
+ n.Left.Method = 1
+
+ ginscall(n.Left, proc)
+}
+
+/*
+ * call to n has already been generated.
+ * generate:
+ * res = return value from call.
+ */
+func cgen_callret(n *gc.Node, res *gc.Node) {
+ var nod gc.Node
+ var fp *gc.Type
+ var t *gc.Type
+ var flist gc.Iter
+
+ t = n.Left.Type
+ if t.Etype == gc.TPTR32 || t.Etype == gc.TPTR64 {
+ t = t.Type
+ }
+
+ fp = gc.Structfirst(&flist, gc.Getoutarg(t))
+ if fp == nil {
+ gc.Fatal("cgen_callret: nil")
+ }
+
+ nod = gc.Node{}
+ nod.Op = gc.OINDREG
+ nod.Val.U.Reg = ppc64.REGSP
+ nod.Addable = 1
+
+ nod.Xoffset = fp.Width + int64(gc.Widthptr) // +widthptr: saved LR at 0(R1)
+ nod.Type = fp.Type
+ gc.Cgen_as(res, &nod)
+}
+
+/*
+ * call to n has already been generated.
+ * generate:
+ * res = &return value from call.
+ */
+func cgen_aret(n *gc.Node, res *gc.Node) {
+ var nod1 gc.Node
+ var nod2 gc.Node
+ var fp *gc.Type
+ var t *gc.Type
+ var flist gc.Iter
+
+ t = n.Left.Type
+ if gc.Isptr[t.Etype] != 0 {
+ t = t.Type
+ }
+
+ fp = gc.Structfirst(&flist, gc.Getoutarg(t))
+ if fp == nil {
+ gc.Fatal("cgen_aret: nil")
+ }
+
+ nod1 = gc.Node{}
+ nod1.Op = gc.OINDREG
+ nod1.Val.U.Reg = ppc64.REGSP
+ nod1.Addable = 1
+
+ nod1.Xoffset = fp.Width + int64(gc.Widthptr) // +widthptr: saved lr at 0(SP)
+ nod1.Type = fp.Type
+
+ if res.Op != gc.OREGISTER {
+ regalloc(&nod2, gc.Types[gc.Tptr], res)
+ agen(&nod1, &nod2)
+ gins(ppc64.AMOVD, &nod2, res)
+ regfree(&nod2)
+ } else {
+ agen(&nod1, res)
+ }
+}
+
+/*
+ * generate return.
+ * n->left is assignments to return values.
+ */
+func cgen_ret(n *gc.Node) {
+ var p *obj.Prog
+
+ if n != nil {
+ gc.Genlist(n.List) // copy out args
+ }
+ if gc.Hasdefer != 0 {
+ ginscall(gc.Deferreturn, 0)
+ }
+ gc.Genlist(gc.Curfn.Exit)
+ p = gins(obj.ARET, nil, nil)
+ if n != nil && n.Op == gc.ORETJMP {
+ p.To.Name = obj.NAME_EXTERN
+ p.To.Type = obj.TYPE_ADDR
+ p.To.Sym = gc.Linksym(n.Left.Sym)
+ }
+}
+
+/*
+ * generate division.
+ * generates one of:
+ * res = nl / nr
+ * res = nl % nr
+ * according to op.
+ */
+func dodiv(op int, nl *gc.Node, nr *gc.Node, res *gc.Node) {
+ var a int
+ var check int
+ var t *gc.Type
+ var t0 *gc.Type
+ var tl gc.Node
+ var tr gc.Node
+ var tl2 gc.Node
+ var tr2 gc.Node
+ var nm1 gc.Node
+ var nz gc.Node
+ var tm gc.Node
+ var p1 *obj.Prog
+ var p2 *obj.Prog
+
+ // Have to be careful about handling
+ // most negative int divided by -1 correctly.
+ // The hardware will generate undefined result.
+ // Also need to explicitly trap on division on zero,
+ // the hardware will silently generate undefined result.
+ // DIVW will leave unpredicable result in higher 32-bit,
+ // so always use DIVD/DIVDU.
+ t = nl.Type
+
+ t0 = t
+ check = 0
+ if gc.Issigned[t.Etype] != 0 {
+ check = 1
+ if gc.Isconst(nl, gc.CTINT) != 0 && gc.Mpgetfix(nl.Val.U.Xval) != -(1<<uint64(t.Width*8-1)) {
+ check = 0
+ } else if gc.Isconst(nr, gc.CTINT) != 0 && gc.Mpgetfix(nr.Val.U.Xval) != -1 {
+ check = 0
+ }
+ }
+
+ if t.Width < 8 {
+ if gc.Issigned[t.Etype] != 0 {
+ t = gc.Types[gc.TINT64]
+ } else {
+ t = gc.Types[gc.TUINT64]
+ }
+ check = 0
+ }
+
+ a = optoas(gc.ODIV, t)
+
+ regalloc(&tl, t0, nil)
+ regalloc(&tr, t0, nil)
+ if nl.Ullman >= nr.Ullman {
+ cgen(nl, &tl)
+ cgen(nr, &tr)
+ } else {
+ cgen(nr, &tr)
+ cgen(nl, &tl)
+ }
+
+ if t != t0 {
+ // Convert
+ tl2 = tl
+
+ tr2 = tr
+ tl.Type = t
+ tr.Type = t
+ gmove(&tl2, &tl)
+ gmove(&tr2, &tr)
+ }
+
+ // Handle divide-by-zero panic.
+ p1 = gins(optoas(gc.OCMP, t), &tr, nil)
+
+ p1.To.Type = obj.TYPE_REG
+ p1.To.Reg = ppc64.REGZERO
+ p1 = gc.Gbranch(optoas(gc.ONE, t), nil, +1)
+ if panicdiv == nil {
+ panicdiv = gc.Sysfunc("panicdivide")
+ }
+ ginscall(panicdiv, -1)
+ gc.Patch(p1, gc.Pc)
+
+ if check != 0 {
+ gc.Nodconst(&nm1, t, -1)
+ gins(optoas(gc.OCMP, t), &tr, &nm1)
+ p1 = gc.Gbranch(optoas(gc.ONE, t), nil, +1)
+ if op == gc.ODIV {
+ // a / (-1) is -a.
+ gins(optoas(gc.OMINUS, t), nil, &tl)
+
+ gmove(&tl, res)
+ } else {
+ // a % (-1) is 0.
+ gc.Nodconst(&nz, t, 0)
+
+ gmove(&nz, res)
+ }
+
+ p2 = gc.Gbranch(obj.AJMP, nil, 0)
+ gc.Patch(p1, gc.Pc)
+ }
+
+ p1 = gins(a, &tr, &tl)
+ if op == gc.ODIV {
+ regfree(&tr)
+ gmove(&tl, res)
+ } else {
+ // A%B = A-(A/B*B)
+ regalloc(&tm, t, nil)
+
+ // patch div to use the 3 register form
+ // TODO(minux): add gins3?
+ p1.Reg = p1.To.Reg
+
+ p1.To.Reg = tm.Val.U.Reg
+ gins(optoas(gc.OMUL, t), &tr, &tm)
+ regfree(&tr)
+ gins(optoas(gc.OSUB, t), &tm, &tl)
+ regfree(&tm)
+ gmove(&tl, res)
+ }
+
+ regfree(&tl)
+ if check != 0 {
+ gc.Patch(p2, gc.Pc)
+ }
+}
+
+/*
+ * generate division according to op, one of:
+ * res = nl / nr
+ * res = nl % nr
+ */
+func cgen_div(op int, nl *gc.Node, nr *gc.Node, res *gc.Node) {
+ var n1 gc.Node
+ var n2 gc.Node
+ var n3 gc.Node
+ var w int
+ var a int
+ var m gc.Magic
+
+ // TODO(minux): enable division by magic multiply (also need to fix longmod below)
+ //if(nr->op != OLITERAL)
+ goto longdiv
+
+ w = int(nl.Type.Width * 8)
+
+ // Front end handled 32-bit division. We only need to handle 64-bit.
+ // try to do division by multiply by (2^w)/d
+ // see hacker's delight chapter 10
+ switch gc.Simtype[nl.Type.Etype] {
+ default:
+ goto longdiv
+
+ case gc.TUINT64:
+ m.W = w
+ m.Ud = uint64(gc.Mpgetfix(nr.Val.U.Xval))
+ gc.Umagic(&m)
+ if m.Bad != 0 {
+ break
+ }
+ if op == gc.OMOD {
+ goto longmod
+ }
+
+ cgenr(nl, &n1, nil)
+ gc.Nodconst(&n2, nl.Type, int64(m.Um))
+ regalloc(&n3, nl.Type, res)
+ cgen_hmul(&n1, &n2, &n3)
+
+ if m.Ua != 0 {
+ // need to add numerator accounting for overflow
+ gins(optoas(gc.OADD, nl.Type), &n1, &n3)
+
+ gc.Nodconst(&n2, nl.Type, 1)
+ gins(optoas(gc.ORROTC, nl.Type), &n2, &n3)
+ gc.Nodconst(&n2, nl.Type, int64(m.S)-1)
+ gins(optoas(gc.ORSH, nl.Type), &n2, &n3)
+ } else {
+ gc.Nodconst(&n2, nl.Type, int64(m.S))
+ gins(optoas(gc.ORSH, nl.Type), &n2, &n3) // shift dx
+ }
+
+ gmove(&n3, res)
+ regfree(&n1)
+ regfree(&n3)
+ return
+
+ case gc.TINT64:
+ m.W = w
+ m.Sd = gc.Mpgetfix(nr.Val.U.Xval)
+ gc.Smagic(&m)
+ if m.Bad != 0 {
+ break
+ }
+ if op == gc.OMOD {
+ goto longmod
+ }
+
+ cgenr(nl, &n1, res)
+ gc.Nodconst(&n2, nl.Type, m.Sm)
+ regalloc(&n3, nl.Type, nil)
+ cgen_hmul(&n1, &n2, &n3)
+
+ if m.Sm < 0 {
+ // need to add numerator
+ gins(optoas(gc.OADD, nl.Type), &n1, &n3)
+ }
+
+ gc.Nodconst(&n2, nl.Type, int64(m.S))
+ gins(optoas(gc.ORSH, nl.Type), &n2, &n3) // shift n3
+
+ gc.Nodconst(&n2, nl.Type, int64(w)-1)
+
+ gins(optoas(gc.ORSH, nl.Type), &n2, &n1) // -1 iff num is neg
+ gins(optoas(gc.OSUB, nl.Type), &n1, &n3) // added
+
+ if m.Sd < 0 {
+ // this could probably be removed
+ // by factoring it into the multiplier
+ gins(optoas(gc.OMINUS, nl.Type), nil, &n3)
+ }
+
+ gmove(&n3, res)
+ regfree(&n1)
+ regfree(&n3)
+ return
+ }
+
+ goto longdiv
+
+ // division and mod using (slow) hardware instruction
+longdiv:
+ dodiv(op, nl, nr, res)
+
+ return
+
+ // mod using formula A%B = A-(A/B*B) but
+ // we know that there is a fast algorithm for A/B
+longmod:
+ regalloc(&n1, nl.Type, res)
+
+ cgen(nl, &n1)
+ regalloc(&n2, nl.Type, nil)
+ cgen_div(gc.ODIV, &n1, nr, &n2)
+ a = optoas(gc.OMUL, nl.Type)
+ if w == 8 {
+ }
+ // use 2-operand 16-bit multiply
+ // because there is no 2-operand 8-bit multiply
+ //a = AIMULW;
+ if !(gc.Smallintconst(nr) != 0) {
+ regalloc(&n3, nl.Type, nil)
+ cgen(nr, &n3)
+ gins(a, &n3, &n2)
+ regfree(&n3)
+ } else {
+ gins(a, nr, &n2)
+ }
+ gins(optoas(gc.OSUB, nl.Type), &n2, &n1)
+ gmove(&n1, res)
+ regfree(&n1)
+ regfree(&n2)
+}
+
+/*
+ * generate high multiply:
+ * res = (nl*nr) >> width
+ */
+func cgen_hmul(nl *gc.Node, nr *gc.Node, res *gc.Node) {
+ var w int
+ var n1 gc.Node
+ var n2 gc.Node
+ var tmp *gc.Node
+ var t *gc.Type
+ var p *obj.Prog
+
+ // largest ullman on left.
+ if nl.Ullman < nr.Ullman {
+ tmp = nl
+ nl = nr
+ nr = tmp
+ }
+
+ t = nl.Type
+ w = int(t.Width * 8)
+ cgenr(nl, &n1, res)
+ cgenr(nr, &n2, nil)
+ switch gc.Simtype[t.Etype] {
+ case gc.TINT8,
+ gc.TINT16,
+ gc.TINT32:
+ gins(optoas(gc.OMUL, t), &n2, &n1)
+ p = gins(ppc64.ASRAD, nil, &n1)
+ p.From.Type = obj.TYPE_CONST
+ p.From.Offset = int64(w)
+
+ case gc.TUINT8,
+ gc.TUINT16,
+ gc.TUINT32:
+ gins(optoas(gc.OMUL, t), &n2, &n1)
+ p = gins(ppc64.ASRD, nil, &n1)
+ p.From.Type = obj.TYPE_CONST
+ p.From.Offset = int64(w)
+
+ case gc.TINT64,
+ gc.TUINT64:
+ if gc.Issigned[t.Etype] != 0 {
+ p = gins(ppc64.AMULHD, &n2, &n1)
+ } else {
+ p = gins(ppc64.AMULHDU, &n2, &n1)
+ }
+
+ default:
+ gc.Fatal("cgen_hmul %v", gc.Tconv(t, 0))
+ }
+
+ cgen(&n1, res)
+ regfree(&n1)
+ regfree(&n2)
+}
+
+/*
+ * generate shift according to op, one of:
+ * res = nl << nr
+ * res = nl >> nr
+ */
+func cgen_shift(op int, bounded int, nl *gc.Node, nr *gc.Node, res *gc.Node) {
+ var n1 gc.Node
+ var n2 gc.Node
+ var n3 gc.Node
+ var n4 gc.Node
+ var n5 gc.Node
+ var a int
+ var p1 *obj.Prog
+ var sc uint64
+ var tcount *gc.Type
+
+ a = optoas(op, nl.Type)
+
+ if nr.Op == gc.OLITERAL {
+ regalloc(&n1, nl.Type, res)
+ cgen(nl, &n1)
+ sc = uint64(gc.Mpgetfix(nr.Val.U.Xval))
+ if sc >= uint64(nl.Type.Width*8) {
+ // large shift gets 2 shifts by width-1
+ gc.Nodconst(&n3, gc.Types[gc.TUINT32], nl.Type.Width*8-1)
+
+ gins(a, &n3, &n1)
+ gins(a, &n3, &n1)
+ } else {
+ gins(a, nr, &n1)
+ }
+ gmove(&n1, res)
+ regfree(&n1)
+ goto ret
+ }
+
+ if nl.Ullman >= gc.UINF {
+ gc.Tempname(&n4, nl.Type)
+ cgen(nl, &n4)
+ nl = &n4
+ }
+
+ if nr.Ullman >= gc.UINF {
+ gc.Tempname(&n5, nr.Type)
+ cgen(nr, &n5)
+ nr = &n5
+ }
+
+ // Allow either uint32 or uint64 as shift type,
+ // to avoid unnecessary conversion from uint32 to uint64
+ // just to do the comparison.
+ tcount = gc.Types[gc.Simtype[nr.Type.Etype]]
+
+ if tcount.Etype < gc.TUINT32 {
+ tcount = gc.Types[gc.TUINT32]
+ }
+
+ regalloc(&n1, nr.Type, nil) // to hold the shift type in CX
+ regalloc(&n3, tcount, &n1) // to clear high bits of CX
+
+ regalloc(&n2, nl.Type, res)
+
+ if nl.Ullman >= nr.Ullman {
+ cgen(nl, &n2)
+ cgen(nr, &n1)
+ gmove(&n1, &n3)
+ } else {
+ cgen(nr, &n1)
+ gmove(&n1, &n3)
+ cgen(nl, &n2)
+ }
+
+ regfree(&n3)
+
+ // test and fix up large shifts
+ if !(bounded != 0) {
+ gc.Nodconst(&n3, tcount, nl.Type.Width*8)
+ gins(optoas(gc.OCMP, tcount), &n1, &n3)
+ p1 = gc.Gbranch(optoas(gc.OLT, tcount), nil, +1)
+ if op == gc.ORSH && gc.Issigned[nl.Type.Etype] != 0 {
+ gc.Nodconst(&n3, gc.Types[gc.TUINT32], nl.Type.Width*8-1)
+ gins(a, &n3, &n2)
+ } else {
+ gc.Nodconst(&n3, nl.Type, 0)
+ gmove(&n3, &n2)
+ }
+
+ gc.Patch(p1, gc.Pc)
+ }
+
+ gins(a, &n1, &n2)
+
+ gmove(&n2, res)
+
+ regfree(&n1)
+ regfree(&n2)
+
+ret:
+}
+
+func clearfat(nl *gc.Node) {
+ var w uint64
+ var c uint64
+ var q uint64
+ var t uint64
+ var boff uint64
+ var dst gc.Node
+ var end gc.Node
+ var r0 gc.Node
+ var f *gc.Node
+ var p *obj.Prog
+ var pl *obj.Prog
+
+ /* clear a fat object */
+ if gc.Debug['g'] != 0 {
+ fmt.Printf("clearfat %v (%v, size: %d)\n", gc.Nconv(nl, 0), gc.Tconv(nl.Type, 0), nl.Type.Width)
+ }
+
+ w = uint64(nl.Type.Width)
+
+ // Avoid taking the address for simple enough types.
+ //if(componentgen(N, nl))
+ // return;
+
+ c = w % 8 // bytes
+ q = w / 8 // dwords
+
+ if reg[ppc64.REGRT1] > 0 {
+ gc.Fatal("R%d in use during clearfat", ppc64.REGRT1)
+ }
+
+ gc.Nodreg(&r0, gc.Types[gc.TUINT64], ppc64.REG_R0) // r0 is always zero
+ gc.Nodreg(&dst, gc.Types[gc.Tptr], ppc64.REGRT1)
+ reg[ppc64.REGRT1]++
+ agen(nl, &dst)
+
+ if q > 128 {
+ p = gins(ppc64.ASUB, nil, &dst)
+ p.From.Type = obj.TYPE_CONST
+ p.From.Offset = 8
+
+ regalloc(&end, gc.Types[gc.Tptr], nil)
+ p = gins(ppc64.AMOVD, &dst, &end)
+ p.From.Type = obj.TYPE_ADDR
+ p.From.Offset = int64(q * 8)
+
+ p = gins(ppc64.AMOVDU, &r0, &dst)
+ p.To.Type = obj.TYPE_MEM
+ p.To.Offset = 8
+ pl = p
+
+ p = gins(ppc64.ACMP, &dst, &end)
+ gc.Patch(gc.Gbranch(ppc64.ABNE, nil, 0), pl)
+
+ regfree(&end)
+
+ // The loop leaves R3 on the last zeroed dword
+ boff = 8
+ } else if q >= 4 {
+ p = gins(ppc64.ASUB, nil, &dst)
+ p.From.Type = obj.TYPE_CONST
+ p.From.Offset = 8
+ f = gc.Sysfunc("duffzero")
+ p = gins(obj.ADUFFZERO, nil, f)
+ gc.Afunclit(&p.To, f)
+
+ // 4 and 128 = magic constants: see ../../runtime/asm_ppc64x.s
+ p.To.Offset = int64(4 * (128 - q))
+
+ // duffzero leaves R3 on the last zeroed dword
+ boff = 8
+ } else {
+ for t = 0; t < q; t++ {
+ p = gins(ppc64.AMOVD, &r0, &dst)
+ p.To.Type = obj.TYPE_MEM
+ p.To.Offset = int64(8 * t)
+ }
+
+ boff = 8 * q
+ }
+
+ for t = 0; t < c; t++ {
+ p = gins(ppc64.AMOVB, &r0, &dst)
+ p.To.Type = obj.TYPE_MEM
+ p.To.Offset = int64(t + boff)
+ }
+
+ reg[ppc64.REGRT1]--
+}
+
+// Called after regopt and peep have run.
+// Expand CHECKNIL pseudo-op into actual nil pointer check.
+func expandchecks(firstp *obj.Prog) {
+ var p *obj.Prog
+ var p1 *obj.Prog
+ var p2 *obj.Prog
+
+ for p = firstp; p != nil; p = p.Link {
+ if gc.Debug_checknil != 0 && gc.Ctxt.Debugvlog != 0 {
+ fmt.Printf("expandchecks: %v\n", p)
+ }
+ if p.As != obj.ACHECKNIL {
+ continue
+ }
+ if gc.Debug_checknil != 0 && p.Lineno > 1 { // p->lineno==1 in generated wrappers
+ gc.Warnl(int(p.Lineno), "generated nil check")
+ }
+ if p.From.Type != obj.TYPE_REG {
+ gc.Fatal("invalid nil check %v\n", p)
+ }
+
+ /*
+ // check is
+ // TD $4, R0, arg (R0 is always zero)
+ // eqv. to:
+ // tdeq r0, arg
+ // NOTE: this needs special runtime support to make SIGTRAP recoverable.
+ reg = p->from.reg;
+ p->as = ATD;
+ p->from = p->to = p->from3 = zprog.from;
+ p->from.type = TYPE_CONST;
+ p->from.offset = 4;
+ p->from.reg = 0;
+ p->reg = REG_R0;
+ p->to.type = TYPE_REG;
+ p->to.reg = reg;
+ */
+ // check is
+ // CMP arg, R0
+ // BNE 2(PC) [likely]
+ // MOVD R0, 0(R0)
+ p1 = gc.Ctxt.NewProg()
+
+ p2 = gc.Ctxt.NewProg()
+ gc.Clearp(p1)
+ gc.Clearp(p2)
+ p1.Link = p2
+ p2.Link = p.Link
+ p.Link = p1
+ p1.Lineno = p.Lineno
+ p2.Lineno = p.Lineno
+ p1.Pc = 9999
+ p2.Pc = 9999
+ p.As = ppc64.ACMP
+ p.To.Type = obj.TYPE_REG
+ p.To.Reg = ppc64.REGZERO
+ p1.As = ppc64.ABNE
+
+ //p1->from.type = TYPE_CONST;
+ //p1->from.offset = 1; // likely
+ p1.To.Type = obj.TYPE_BRANCH
+
+ p1.To.U.Branch = p2.Link
+
+ // crash by write to memory address 0.
+ p2.As = ppc64.AMOVD
+
+ p2.From.Type = obj.TYPE_REG
+ p2.From.Reg = ppc64.REG_R0
+ p2.To.Type = obj.TYPE_MEM
+ p2.To.Reg = ppc64.REG_R0
+ p2.To.Offset = 0
+ }
+}
--- /dev/null
+// 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 main
+
+import (
+ "cmd/internal/obj"
+ "cmd/internal/obj/ppc64"
+ "fmt"
+)
+import "cmd/internal/gc"
+
+// TODO(rsc): Can make this bigger if we move
+// the text segment up higher in 6l for all GOOS.
+// At the same time, can raise StackBig in ../../runtime/stack.h.
+var unmappedzero int64 = 4096
+
+var resvd = []int{
+ ppc64.REGZERO,
+ ppc64.REGSP, // reserved for SP
+ // We need to preserve the C ABI TLS pointer because sigtramp
+ // may happen during C code and needs to access the g. C
+ // clobbers REGG, so if Go were to clobber REGTLS, sigtramp
+ // won't know which convention to use. By preserving REGTLS,
+ // we can just retrieve g from TLS when we aren't sure.
+ ppc64.REGTLS,
+
+ // TODO(austin): Consolidate REGTLS and REGG?
+ ppc64.REGG,
+ ppc64.REGTMP, // REGTMP
+ ppc64.FREGCVI,
+ ppc64.FREGZERO,
+ ppc64.FREGHALF,
+ ppc64.FREGONE,
+ ppc64.FREGTWO,
+}
+
+func ginit() {
+ var i int
+
+ for i = 0; i < len(reg); i++ {
+ reg[i] = 1
+ }
+ for i = 0; i < ppc64.NREG+ppc64.NFREG; i++ {
+ reg[i] = 0
+ }
+
+ for i = 0; i < len(resvd); i++ {
+ reg[resvd[i]-ppc64.REG_R0]++
+ }
+}
+
+var regpc [len(reg)]uint32
+
+func gclean() {
+ var i int
+
+ for i = 0; i < len(resvd); i++ {
+ reg[resvd[i]-ppc64.REG_R0]--
+ }
+
+ for i = 0; i < len(reg); i++ {
+ if reg[i] != 0 {
+ gc.Yyerror("reg %v left allocated, %p\n", gc.Ctxt.Rconv(i+ppc64.REG_R0), regpc[i])
+ }
+ }
+}
+
+func anyregalloc() int {
+ var i int
+ var j int
+
+ for i = 0; i < len(reg); i++ {
+ if reg[i] == 0 {
+ goto ok
+ }
+ for j = 0; j < len(resvd); j++ {
+ if resvd[j] == i {
+ goto ok
+ }
+ }
+ return 1
+ ok:
+ }
+
+ return 0
+}
+
+/*
+ * allocate register of type t, leave in n.
+ * if o != N, o is desired fixed register.
+ * caller must regfree(n).
+ */
+func regalloc(n *gc.Node, t *gc.Type, o *gc.Node) {
+ var i int
+ var et int
+ var fixfree int
+ var fltfree int
+
+ if t == nil {
+ gc.Fatal("regalloc: t nil")
+ }
+ et = int(gc.Simtype[t.Etype])
+
+ if gc.Debug['r'] != 0 {
+ fixfree = 0
+ fltfree = 0
+ for i = ppc64.REG_R0; i < ppc64.REG_F31; i++ {
+ if reg[i-ppc64.REG_R0] == 0 {
+ if i < ppc64.REG_F0 {
+ fixfree++
+ } else {
+ fltfree++
+ }
+ }
+ }
+
+ fmt.Printf("regalloc fix %d flt %d free\n", fixfree, fltfree)
+ }
+
+ switch et {
+ case gc.TINT8,
+ gc.TUINT8,
+ gc.TINT16,
+ gc.TUINT16,
+ gc.TINT32,
+ gc.TUINT32,
+ gc.TINT64,
+ gc.TUINT64,
+ gc.TPTR32,
+ gc.TPTR64,
+ gc.TBOOL:
+ if o != nil && o.Op == gc.OREGISTER {
+ i = int(o.Val.U.Reg)
+ if i >= ppc64.REGMIN && i <= ppc64.REGMAX {
+ goto out
+ }
+ }
+
+ for i = ppc64.REGMIN; i <= ppc64.REGMAX; i++ {
+ if reg[i-ppc64.REG_R0] == 0 {
+ regpc[i-ppc64.REG_R0] = uint32(obj.Getcallerpc(&n))
+ goto out
+ }
+ }
+
+ gc.Flusherrors()
+ for i = ppc64.REG_R0; i < ppc64.REG_R0+ppc64.NREG; i++ {
+ fmt.Printf("R%d %p\n", i, regpc[i-ppc64.REG_R0])
+ }
+ gc.Fatal("out of fixed registers")
+ fallthrough
+
+ case gc.TFLOAT32,
+ gc.TFLOAT64:
+ if o != nil && o.Op == gc.OREGISTER {
+ i = int(o.Val.U.Reg)
+ if i >= ppc64.FREGMIN && i <= ppc64.FREGMAX {
+ goto out
+ }
+ }
+
+ for i = ppc64.FREGMIN; i <= ppc64.FREGMAX; i++ {
+ if reg[i-ppc64.REG_R0] == 0 {
+ regpc[i-ppc64.REG_R0] = uint32(obj.Getcallerpc(&n))
+ goto out
+ }
+ }
+
+ gc.Flusherrors()
+ for i = ppc64.REG_F0; i < ppc64.REG_F0+ppc64.NREG; i++ {
+ fmt.Printf("F%d %p\n", i, regpc[i-ppc64.REG_R0])
+ }
+ gc.Fatal("out of floating registers")
+ fallthrough
+
+ case gc.TCOMPLEX64,
+ gc.TCOMPLEX128:
+ gc.Tempname(n, t)
+ return
+ }
+
+ gc.Fatal("regalloc: unknown type %v", gc.Tconv(t, 0))
+ return
+
+out:
+ reg[i-ppc64.REG_R0]++
+ gc.Nodreg(n, t, i)
+}
+
+func regfree(n *gc.Node) {
+ var i int
+
+ if n.Op == gc.ONAME {
+ return
+ }
+ if n.Op != gc.OREGISTER && n.Op != gc.OINDREG {
+ gc.Fatal("regfree: not a register")
+ }
+ i = int(n.Val.U.Reg) - ppc64.REG_R0
+ if i == ppc64.REGSP-ppc64.REG_R0 {
+ return
+ }
+ if i < 0 || i >= len(reg) {
+ gc.Fatal("regfree: reg out of range")
+ }
+ if reg[i] <= 0 {
+ gc.Fatal("regfree: reg not allocated")
+ }
+ reg[i]--
+ if reg[i] == 0 {
+ regpc[i] = 0
+ }
+}
+
+/*
+ * generate
+ * as $c, n
+ */
+func ginscon(as int, c int64, n2 *gc.Node) {
+ var n1 gc.Node
+ var ntmp gc.Node
+
+ gc.Nodconst(&n1, gc.Types[gc.TINT64], c)
+
+ if as != ppc64.AMOVD && (c < -ppc64.BIG || c > ppc64.BIG) {
+ // cannot have more than 16-bit of immediate in ADD, etc.
+ // instead, MOV into register first.
+ regalloc(&ntmp, gc.Types[gc.TINT64], nil)
+
+ gins(ppc64.AMOVD, &n1, &ntmp)
+ gins(as, &ntmp, n2)
+ regfree(&ntmp)
+ return
+ }
+
+ gins(as, &n1, n2)
+}
+
+/*
+ * generate
+ * as n, $c (CMP/CMPU)
+ */
+func ginscon2(as int, n2 *gc.Node, c int64) {
+ var n1 gc.Node
+ var ntmp gc.Node
+
+ gc.Nodconst(&n1, gc.Types[gc.TINT64], c)
+
+ switch as {
+ default:
+ gc.Fatal("ginscon2")
+ fallthrough
+
+ case ppc64.ACMP:
+ if -ppc64.BIG <= c && c <= ppc64.BIG {
+ gins(as, n2, &n1)
+ return
+ }
+
+ case ppc64.ACMPU:
+ if 0 <= c && c <= 2*ppc64.BIG {
+ gins(as, n2, &n1)
+ return
+ }
+ }
+
+ // MOV n1 into register first
+ regalloc(&ntmp, gc.Types[gc.TINT64], nil)
+
+ gins(ppc64.AMOVD, &n1, &ntmp)
+ gins(as, n2, &ntmp)
+ regfree(&ntmp)
+}
+
+/*
+ * set up nodes representing 2^63
+ */
+var bigi gc.Node
+
+var bigf gc.Node
+
+var bignodes_did int
+
+func bignodes() {
+ if bignodes_did != 0 {
+ return
+ }
+ bignodes_did = 1
+
+ gc.Nodconst(&bigi, gc.Types[gc.TUINT64], 1)
+ gc.Mpshiftfix(bigi.Val.U.Xval, 63)
+
+ bigf = bigi
+ bigf.Type = gc.Types[gc.TFLOAT64]
+ bigf.Val.Ctype = gc.CTFLT
+ bigf.Val.U.Fval = new(gc.Mpflt)
+ gc.Mpmovefixflt(bigf.Val.U.Fval, bigi.Val.U.Xval)
+}
+
+/*
+ * generate move:
+ * t = f
+ * hard part is conversions.
+ */
+func gmove(f *gc.Node, t *gc.Node) {
+ var a int
+ var ft int
+ var tt int
+ var cvt *gc.Type
+ var r1 gc.Node
+ var r2 gc.Node
+ var r3 gc.Node
+ var con gc.Node
+ var p1 *obj.Prog
+ var p2 *obj.Prog
+
+ if gc.Debug['M'] != 0 {
+ fmt.Printf("gmove %v -> %v\n", gc.Nconv(f, obj.FmtLong), gc.Nconv(t, obj.FmtLong))
+ }
+
+ ft = gc.Simsimtype(f.Type)
+ tt = gc.Simsimtype(t.Type)
+ cvt = t.Type
+
+ if gc.Iscomplex[ft] != 0 || gc.Iscomplex[tt] != 0 {
+ gc.Complexmove(f, t)
+ return
+ }
+
+ // cannot have two memory operands
+ if gc.Ismem(f) != 0 && gc.Ismem(t) != 0 {
+ goto hard
+ }
+
+ // convert constant to desired type
+ if f.Op == gc.OLITERAL {
+ switch tt {
+ default:
+ gc.Convconst(&con, t.Type, &f.Val)
+
+ case gc.TINT32,
+ gc.TINT16,
+ gc.TINT8:
+ gc.Convconst(&con, gc.Types[gc.TINT64], &f.Val)
+ regalloc(&r1, con.Type, t)
+ gins(ppc64.AMOVD, &con, &r1)
+ gmove(&r1, t)
+ regfree(&r1)
+ return
+
+ case gc.TUINT32,
+ gc.TUINT16,
+ gc.TUINT8:
+ gc.Convconst(&con, gc.Types[gc.TUINT64], &f.Val)
+ regalloc(&r1, con.Type, t)
+ gins(ppc64.AMOVD, &con, &r1)
+ gmove(&r1, t)
+ regfree(&r1)
+ return
+ }
+
+ f = &con
+ ft = tt // so big switch will choose a simple mov
+
+ // constants can't move directly to memory.
+ if gc.Ismem(t) != 0 {
+ goto hard
+ }
+ }
+
+ // float constants come from memory.
+ //if(isfloat[tt])
+ // goto hard;
+
+ // 64-bit immediates are also from memory.
+ //if(isint[tt])
+ // goto hard;
+ //// 64-bit immediates are really 32-bit sign-extended
+ //// unless moving into a register.
+ //if(isint[tt]) {
+ // if(mpcmpfixfix(con.val.u.xval, minintval[TINT32]) < 0)
+ // goto hard;
+ // if(mpcmpfixfix(con.val.u.xval, maxintval[TINT32]) > 0)
+ // goto hard;
+ //}
+
+ // value -> value copy, only one memory operand.
+ // figure out the instruction to use.
+ // break out of switch for one-instruction gins.
+ // goto rdst for "destination must be register".
+ // goto hard for "convert to cvt type first".
+ // otherwise handle and return.
+
+ switch uint32(ft)<<16 | uint32(tt) {
+ default:
+ gc.Fatal("gmove %v -> %v", gc.Tconv(f.Type, obj.FmtLong), gc.Tconv(t.Type, obj.FmtLong))
+ fallthrough
+
+ /*
+ * integer copy and truncate
+ */
+ case gc.TINT8<<16 | gc.TINT8, // same size
+ gc.TUINT8<<16 | gc.TINT8,
+ gc.TINT16<<16 | gc.TINT8,
+ // truncate
+ gc.TUINT16<<16 | gc.TINT8,
+ gc.TINT32<<16 | gc.TINT8,
+ gc.TUINT32<<16 | gc.TINT8,
+ gc.TINT64<<16 | gc.TINT8,
+ gc.TUINT64<<16 | gc.TINT8:
+ a = ppc64.AMOVB
+
+ case gc.TINT8<<16 | gc.TUINT8, // same size
+ gc.TUINT8<<16 | gc.TUINT8,
+ gc.TINT16<<16 | gc.TUINT8,
+ // truncate
+ gc.TUINT16<<16 | gc.TUINT8,
+ gc.TINT32<<16 | gc.TUINT8,
+ gc.TUINT32<<16 | gc.TUINT8,
+ gc.TINT64<<16 | gc.TUINT8,
+ gc.TUINT64<<16 | gc.TUINT8:
+ a = ppc64.AMOVBZ
+
+ case gc.TINT16<<16 | gc.TINT16, // same size
+ gc.TUINT16<<16 | gc.TINT16,
+ gc.TINT32<<16 | gc.TINT16,
+ // truncate
+ gc.TUINT32<<16 | gc.TINT16,
+ gc.TINT64<<16 | gc.TINT16,
+ gc.TUINT64<<16 | gc.TINT16:
+ a = ppc64.AMOVH
+
+ case gc.TINT16<<16 | gc.TUINT16, // same size
+ gc.TUINT16<<16 | gc.TUINT16,
+ gc.TINT32<<16 | gc.TUINT16,
+ // truncate
+ gc.TUINT32<<16 | gc.TUINT16,
+ gc.TINT64<<16 | gc.TUINT16,
+ gc.TUINT64<<16 | gc.TUINT16:
+ a = ppc64.AMOVHZ
+
+ case gc.TINT32<<16 | gc.TINT32, // same size
+ gc.TUINT32<<16 | gc.TINT32,
+ gc.TINT64<<16 | gc.TINT32,
+ // truncate
+ gc.TUINT64<<16 | gc.TINT32:
+ a = ppc64.AMOVW
+
+ case gc.TINT32<<16 | gc.TUINT32, // same size
+ gc.TUINT32<<16 | gc.TUINT32,
+ gc.TINT64<<16 | gc.TUINT32,
+ gc.TUINT64<<16 | gc.TUINT32:
+ a = ppc64.AMOVWZ
+
+ case gc.TINT64<<16 | gc.TINT64, // same size
+ gc.TINT64<<16 | gc.TUINT64,
+ gc.TUINT64<<16 | gc.TINT64,
+ gc.TUINT64<<16 | gc.TUINT64:
+ a = ppc64.AMOVD
+
+ /*
+ * integer up-conversions
+ */
+ case gc.TINT8<<16 | gc.TINT16, // sign extend int8
+ gc.TINT8<<16 | gc.TUINT16,
+ gc.TINT8<<16 | gc.TINT32,
+ gc.TINT8<<16 | gc.TUINT32,
+ gc.TINT8<<16 | gc.TINT64,
+ gc.TINT8<<16 | gc.TUINT64:
+ a = ppc64.AMOVB
+
+ goto rdst
+
+ case gc.TUINT8<<16 | gc.TINT16, // zero extend uint8
+ gc.TUINT8<<16 | gc.TUINT16,
+ gc.TUINT8<<16 | gc.TINT32,
+ gc.TUINT8<<16 | gc.TUINT32,
+ gc.TUINT8<<16 | gc.TINT64,
+ gc.TUINT8<<16 | gc.TUINT64:
+ a = ppc64.AMOVBZ
+
+ goto rdst
+
+ case gc.TINT16<<16 | gc.TINT32, // sign extend int16
+ gc.TINT16<<16 | gc.TUINT32,
+ gc.TINT16<<16 | gc.TINT64,
+ gc.TINT16<<16 | gc.TUINT64:
+ a = ppc64.AMOVH
+
+ goto rdst
+
+ case gc.TUINT16<<16 | gc.TINT32, // zero extend uint16
+ gc.TUINT16<<16 | gc.TUINT32,
+ gc.TUINT16<<16 | gc.TINT64,
+ gc.TUINT16<<16 | gc.TUINT64:
+ a = ppc64.AMOVHZ
+
+ goto rdst
+
+ case gc.TINT32<<16 | gc.TINT64, // sign extend int32
+ gc.TINT32<<16 | gc.TUINT64:
+ a = ppc64.AMOVW
+
+ goto rdst
+
+ case gc.TUINT32<<16 | gc.TINT64, // zero extend uint32
+ gc.TUINT32<<16 | gc.TUINT64:
+ a = ppc64.AMOVWZ
+
+ goto rdst
+
+ //warn("gmove: convert float to int not implemented: %N -> %N\n", f, t);
+ //return;
+ // algorithm is:
+ // if small enough, use native float64 -> int64 conversion.
+ // otherwise, subtract 2^63, convert, and add it back.
+ /*
+ * float to integer
+ */
+ case gc.TFLOAT32<<16 | gc.TINT32,
+ gc.TFLOAT64<<16 | gc.TINT32,
+ gc.TFLOAT32<<16 | gc.TINT64,
+ gc.TFLOAT64<<16 | gc.TINT64,
+ gc.TFLOAT32<<16 | gc.TINT16,
+ gc.TFLOAT32<<16 | gc.TINT8,
+ gc.TFLOAT32<<16 | gc.TUINT16,
+ gc.TFLOAT32<<16 | gc.TUINT8,
+ gc.TFLOAT64<<16 | gc.TINT16,
+ gc.TFLOAT64<<16 | gc.TINT8,
+ gc.TFLOAT64<<16 | gc.TUINT16,
+ gc.TFLOAT64<<16 | gc.TUINT8,
+ gc.TFLOAT32<<16 | gc.TUINT32,
+ gc.TFLOAT64<<16 | gc.TUINT32,
+ gc.TFLOAT32<<16 | gc.TUINT64,
+ gc.TFLOAT64<<16 | gc.TUINT64:
+ bignodes()
+
+ regalloc(&r1, gc.Types[ft], f)
+ gmove(f, &r1)
+ if tt == gc.TUINT64 {
+ regalloc(&r2, gc.Types[gc.TFLOAT64], nil)
+ gmove(&bigf, &r2)
+ gins(ppc64.AFCMPU, &r1, &r2)
+ p1 = gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TFLOAT64]), nil, +1)
+ gins(ppc64.AFSUB, &r2, &r1)
+ gc.Patch(p1, gc.Pc)
+ regfree(&r2)
+ }
+
+ regalloc(&r2, gc.Types[gc.TFLOAT64], nil)
+ regalloc(&r3, gc.Types[gc.TINT64], t)
+ gins(ppc64.AFCTIDZ, &r1, &r2)
+ p1 = gins(ppc64.AFMOVD, &r2, nil)
+ p1.To.Type = obj.TYPE_MEM
+ p1.To.Reg = ppc64.REGSP
+ p1.To.Offset = -8
+ p1 = gins(ppc64.AMOVD, nil, &r3)
+ p1.From.Type = obj.TYPE_MEM
+ p1.From.Reg = ppc64.REGSP
+ p1.From.Offset = -8
+ regfree(&r2)
+ regfree(&r1)
+ if tt == gc.TUINT64 {
+ p1 = gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TFLOAT64]), nil, +1) // use CR0 here again
+ gc.Nodreg(&r1, gc.Types[gc.TINT64], ppc64.REGTMP)
+ gins(ppc64.AMOVD, &bigi, &r1)
+ gins(ppc64.AADD, &r1, &r3)
+ gc.Patch(p1, gc.Pc)
+ }
+
+ gmove(&r3, t)
+ regfree(&r3)
+ return
+
+ //warn("gmove: convert int to float not implemented: %N -> %N\n", f, t);
+ //return;
+ // algorithm is:
+ // if small enough, use native int64 -> uint64 conversion.
+ // otherwise, halve (rounding to odd?), convert, and double.
+ /*
+ * integer to float
+ */
+ case gc.TINT32<<16 | gc.TFLOAT32,
+ gc.TINT32<<16 | gc.TFLOAT64,
+ gc.TINT64<<16 | gc.TFLOAT32,
+ gc.TINT64<<16 | gc.TFLOAT64,
+ gc.TINT16<<16 | gc.TFLOAT32,
+ gc.TINT16<<16 | gc.TFLOAT64,
+ gc.TINT8<<16 | gc.TFLOAT32,
+ gc.TINT8<<16 | gc.TFLOAT64,
+ gc.TUINT16<<16 | gc.TFLOAT32,
+ gc.TUINT16<<16 | gc.TFLOAT64,
+ gc.TUINT8<<16 | gc.TFLOAT32,
+ gc.TUINT8<<16 | gc.TFLOAT64,
+ gc.TUINT32<<16 | gc.TFLOAT32,
+ gc.TUINT32<<16 | gc.TFLOAT64,
+ gc.TUINT64<<16 | gc.TFLOAT32,
+ gc.TUINT64<<16 | gc.TFLOAT64:
+ bignodes()
+
+ regalloc(&r1, gc.Types[gc.TINT64], nil)
+ gmove(f, &r1)
+ if ft == gc.TUINT64 {
+ gc.Nodreg(&r2, gc.Types[gc.TUINT64], ppc64.REGTMP)
+ gmove(&bigi, &r2)
+ gins(ppc64.ACMPU, &r1, &r2)
+ p1 = gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TUINT64]), nil, +1)
+ p2 = gins(ppc64.ASRD, nil, &r1)
+ p2.From.Type = obj.TYPE_CONST
+ p2.From.Offset = 1
+ gc.Patch(p1, gc.Pc)
+ }
+
+ regalloc(&r2, gc.Types[gc.TFLOAT64], t)
+ p1 = gins(ppc64.AMOVD, &r1, nil)
+ p1.To.Type = obj.TYPE_MEM
+ p1.To.Reg = ppc64.REGSP
+ p1.To.Offset = -8
+ p1 = gins(ppc64.AFMOVD, nil, &r2)
+ p1.From.Type = obj.TYPE_MEM
+ p1.From.Reg = ppc64.REGSP
+ p1.From.Offset = -8
+ gins(ppc64.AFCFID, &r2, &r2)
+ regfree(&r1)
+ if ft == gc.TUINT64 {
+ p1 = gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TUINT64]), nil, +1) // use CR0 here again
+ gc.Nodreg(&r1, gc.Types[gc.TFLOAT64], ppc64.FREGTWO)
+ gins(ppc64.AFMUL, &r1, &r2)
+ gc.Patch(p1, gc.Pc)
+ }
+
+ gmove(&r2, t)
+ regfree(&r2)
+ return
+
+ /*
+ * float to float
+ */
+ case gc.TFLOAT32<<16 | gc.TFLOAT32:
+ a = ppc64.AFMOVS
+
+ case gc.TFLOAT64<<16 | gc.TFLOAT64:
+ a = ppc64.AFMOVD
+
+ case gc.TFLOAT32<<16 | gc.TFLOAT64:
+ a = ppc64.AFMOVS
+ goto rdst
+
+ case gc.TFLOAT64<<16 | gc.TFLOAT32:
+ a = ppc64.AFRSP
+ goto rdst
+ }
+
+ gins(a, f, t)
+ return
+
+ // requires register destination
+rdst:
+ regalloc(&r1, t.Type, t)
+
+ gins(a, f, &r1)
+ gmove(&r1, t)
+ regfree(&r1)
+ return
+
+ // requires register intermediate
+hard:
+ regalloc(&r1, cvt, t)
+
+ gmove(f, &r1)
+ gmove(&r1, t)
+ regfree(&r1)
+ return
+}
+
+/*
+ * generate one instruction:
+ * as f, t
+ */
+func gins(as int, f *gc.Node, t *gc.Node) *obj.Prog {
+ var w int32
+ var p *obj.Prog
+ var af obj.Addr
+ var at obj.Addr
+
+ // TODO(austin): Add self-move test like in 6g (but be careful
+ // of truncation moves)
+
+ af = obj.Addr{}
+
+ at = obj.Addr{}
+ if f != nil {
+ gc.Naddr(f, &af, 1)
+ }
+ if t != nil {
+ gc.Naddr(t, &at, 1)
+ }
+ p = gc.Prog(as)
+ if f != nil {
+ p.From = af
+ }
+ if t != nil {
+ p.To = at
+ }
+ if gc.Debug['g'] != 0 {
+ fmt.Printf("%v\n", p)
+ }
+
+ w = 0
+ switch as {
+ case ppc64.AMOVB,
+ ppc64.AMOVBU,
+ ppc64.AMOVBZ,
+ ppc64.AMOVBZU:
+ w = 1
+
+ case ppc64.AMOVH,
+ ppc64.AMOVHU,
+ ppc64.AMOVHZ,
+ ppc64.AMOVHZU:
+ w = 2
+
+ case ppc64.AMOVW,
+ ppc64.AMOVWU,
+ ppc64.AMOVWZ,
+ ppc64.AMOVWZU:
+ w = 4
+
+ case ppc64.AMOVD,
+ ppc64.AMOVDU:
+ if af.Type == obj.TYPE_CONST || af.Type == obj.TYPE_ADDR {
+ break
+ }
+ w = 8
+ }
+
+ if w != 0 && ((f != nil && af.Width < int64(w)) || (t != nil && at.Type != obj.TYPE_REG && at.Width > int64(w))) {
+ gc.Dump("f", f)
+ gc.Dump("t", t)
+ gc.Fatal("bad width: %v (%d, %d)\n", p, af.Width, at.Width)
+ }
+
+ return p
+}
+
+func fixlargeoffset(n *gc.Node) {
+ var a gc.Node
+
+ if n == nil {
+ return
+ }
+ if n.Op != gc.OINDREG {
+ return
+ }
+ if n.Val.U.Reg == ppc64.REGSP { // stack offset cannot be large
+ return
+ }
+ if n.Xoffset != int64(int32(n.Xoffset)) {
+ // TODO(minux): offset too large, move into R31 and add to R31 instead.
+ // this is used only in test/fixedbugs/issue6036.go.
+ gc.Fatal("offset too large: %v", gc.Nconv(n, 0))
+
+ a = *n
+ a.Op = gc.OREGISTER
+ a.Type = gc.Types[gc.Tptr]
+ a.Xoffset = 0
+ gc.Cgen_checknil(&a)
+ ginscon(optoas(gc.OADD, gc.Types[gc.Tptr]), n.Xoffset, &a)
+ n.Xoffset = 0
+ }
+}
+
+/*
+ * return Axxx for Oxxx on type t.
+ */
+func optoas(op int, t *gc.Type) int {
+ var a int
+
+ if t == nil {
+ gc.Fatal("optoas: t is nil")
+ }
+
+ a = obj.AXXX
+ switch uint32(op)<<16 | uint32(gc.Simtype[t.Etype]) {
+ default:
+ gc.Fatal("optoas: no entry for op=%v type=%v", gc.Oconv(int(op), 0), gc.Tconv(t, 0))
+
+ case gc.OEQ<<16 | gc.TBOOL,
+ gc.OEQ<<16 | gc.TINT8,
+ gc.OEQ<<16 | gc.TUINT8,
+ gc.OEQ<<16 | gc.TINT16,
+ gc.OEQ<<16 | gc.TUINT16,
+ gc.OEQ<<16 | gc.TINT32,
+ gc.OEQ<<16 | gc.TUINT32,
+ gc.OEQ<<16 | gc.TINT64,
+ gc.OEQ<<16 | gc.TUINT64,
+ gc.OEQ<<16 | gc.TPTR32,
+ gc.OEQ<<16 | gc.TPTR64,
+ gc.OEQ<<16 | gc.TFLOAT32,
+ gc.OEQ<<16 | gc.TFLOAT64:
+ a = ppc64.ABEQ
+
+ case gc.ONE<<16 | gc.TBOOL,
+ gc.ONE<<16 | gc.TINT8,
+ gc.ONE<<16 | gc.TUINT8,
+ gc.ONE<<16 | gc.TINT16,
+ gc.ONE<<16 | gc.TUINT16,
+ gc.ONE<<16 | gc.TINT32,
+ gc.ONE<<16 | gc.TUINT32,
+ gc.ONE<<16 | gc.TINT64,
+ gc.ONE<<16 | gc.TUINT64,
+ gc.ONE<<16 | gc.TPTR32,
+ gc.ONE<<16 | gc.TPTR64,
+ gc.ONE<<16 | gc.TFLOAT32,
+ gc.ONE<<16 | gc.TFLOAT64:
+ a = ppc64.ABNE
+
+ case gc.OLT<<16 | gc.TINT8, // ACMP
+ gc.OLT<<16 | gc.TINT16,
+ gc.OLT<<16 | gc.TINT32,
+ gc.OLT<<16 | gc.TINT64,
+ gc.OLT<<16 | gc.TUINT8,
+ // ACMPU
+ gc.OLT<<16 | gc.TUINT16,
+ gc.OLT<<16 | gc.TUINT32,
+ gc.OLT<<16 | gc.TUINT64,
+ gc.OLT<<16 | gc.TFLOAT32,
+ // AFCMPU
+ gc.OLT<<16 | gc.TFLOAT64:
+ a = ppc64.ABLT
+
+ case gc.OLE<<16 | gc.TINT8, // ACMP
+ gc.OLE<<16 | gc.TINT16,
+ gc.OLE<<16 | gc.TINT32,
+ gc.OLE<<16 | gc.TINT64,
+ gc.OLE<<16 | gc.TUINT8,
+ // ACMPU
+ gc.OLE<<16 | gc.TUINT16,
+ gc.OLE<<16 | gc.TUINT32,
+ gc.OLE<<16 | gc.TUINT64,
+ gc.OLE<<16 | gc.TFLOAT32,
+ // AFCMPU
+ gc.OLE<<16 | gc.TFLOAT64:
+ a = ppc64.ABLE
+
+ case gc.OGT<<16 | gc.TINT8,
+ gc.OGT<<16 | gc.TINT16,
+ gc.OGT<<16 | gc.TINT32,
+ gc.OGT<<16 | gc.TINT64,
+ gc.OGT<<16 | gc.TUINT8,
+ gc.OGT<<16 | gc.TUINT16,
+ gc.OGT<<16 | gc.TUINT32,
+ gc.OGT<<16 | gc.TUINT64,
+ gc.OGT<<16 | gc.TFLOAT32,
+ gc.OGT<<16 | gc.TFLOAT64:
+ a = ppc64.ABGT
+
+ case gc.OGE<<16 | gc.TINT8,
+ gc.OGE<<16 | gc.TINT16,
+ gc.OGE<<16 | gc.TINT32,
+ gc.OGE<<16 | gc.TINT64,
+ gc.OGE<<16 | gc.TUINT8,
+ gc.OGE<<16 | gc.TUINT16,
+ gc.OGE<<16 | gc.TUINT32,
+ gc.OGE<<16 | gc.TUINT64,
+ gc.OGE<<16 | gc.TFLOAT32,
+ gc.OGE<<16 | gc.TFLOAT64:
+ a = ppc64.ABGE
+
+ case gc.OCMP<<16 | gc.TBOOL,
+ gc.OCMP<<16 | gc.TINT8,
+ gc.OCMP<<16 | gc.TINT16,
+ gc.OCMP<<16 | gc.TINT32,
+ gc.OCMP<<16 | gc.TPTR32,
+ gc.OCMP<<16 | gc.TINT64:
+ a = ppc64.ACMP
+
+ case gc.OCMP<<16 | gc.TUINT8,
+ gc.OCMP<<16 | gc.TUINT16,
+ gc.OCMP<<16 | gc.TUINT32,
+ gc.OCMP<<16 | gc.TUINT64,
+ gc.OCMP<<16 | gc.TPTR64:
+ a = ppc64.ACMPU
+
+ case gc.OCMP<<16 | gc.TFLOAT32,
+ gc.OCMP<<16 | gc.TFLOAT64:
+ a = ppc64.AFCMPU
+
+ case gc.OAS<<16 | gc.TBOOL,
+ gc.OAS<<16 | gc.TINT8:
+ a = ppc64.AMOVB
+
+ case gc.OAS<<16 | gc.TUINT8:
+ a = ppc64.AMOVBZ
+
+ case gc.OAS<<16 | gc.TINT16:
+ a = ppc64.AMOVH
+
+ case gc.OAS<<16 | gc.TUINT16:
+ a = ppc64.AMOVHZ
+
+ case gc.OAS<<16 | gc.TINT32:
+ a = ppc64.AMOVW
+
+ case gc.OAS<<16 | gc.TUINT32,
+ gc.OAS<<16 | gc.TPTR32:
+ a = ppc64.AMOVWZ
+
+ case gc.OAS<<16 | gc.TINT64,
+ gc.OAS<<16 | gc.TUINT64,
+ gc.OAS<<16 | gc.TPTR64:
+ a = ppc64.AMOVD
+
+ case gc.OAS<<16 | gc.TFLOAT32:
+ a = ppc64.AFMOVS
+
+ case gc.OAS<<16 | gc.TFLOAT64:
+ a = ppc64.AFMOVD
+
+ case gc.OADD<<16 | gc.TINT8,
+ gc.OADD<<16 | gc.TUINT8,
+ gc.OADD<<16 | gc.TINT16,
+ gc.OADD<<16 | gc.TUINT16,
+ gc.OADD<<16 | gc.TINT32,
+ gc.OADD<<16 | gc.TUINT32,
+ gc.OADD<<16 | gc.TPTR32,
+ gc.OADD<<16 | gc.TINT64,
+ gc.OADD<<16 | gc.TUINT64,
+ gc.OADD<<16 | gc.TPTR64:
+ a = ppc64.AADD
+
+ case gc.OADD<<16 | gc.TFLOAT32:
+ a = ppc64.AFADDS
+
+ case gc.OADD<<16 | gc.TFLOAT64:
+ a = ppc64.AFADD
+
+ case gc.OSUB<<16 | gc.TINT8,
+ gc.OSUB<<16 | gc.TUINT8,
+ gc.OSUB<<16 | gc.TINT16,
+ gc.OSUB<<16 | gc.TUINT16,
+ gc.OSUB<<16 | gc.TINT32,
+ gc.OSUB<<16 | gc.TUINT32,
+ gc.OSUB<<16 | gc.TPTR32,
+ gc.OSUB<<16 | gc.TINT64,
+ gc.OSUB<<16 | gc.TUINT64,
+ gc.OSUB<<16 | gc.TPTR64:
+ a = ppc64.ASUB
+
+ case gc.OSUB<<16 | gc.TFLOAT32:
+ a = ppc64.AFSUBS
+
+ case gc.OSUB<<16 | gc.TFLOAT64:
+ a = ppc64.AFSUB
+
+ case gc.OMINUS<<16 | gc.TINT8,
+ gc.OMINUS<<16 | gc.TUINT8,
+ gc.OMINUS<<16 | gc.TINT16,
+ gc.OMINUS<<16 | gc.TUINT16,
+ gc.OMINUS<<16 | gc.TINT32,
+ gc.OMINUS<<16 | gc.TUINT32,
+ gc.OMINUS<<16 | gc.TPTR32,
+ gc.OMINUS<<16 | gc.TINT64,
+ gc.OMINUS<<16 | gc.TUINT64,
+ gc.OMINUS<<16 | gc.TPTR64:
+ a = ppc64.ANEG
+
+ case gc.OAND<<16 | gc.TINT8,
+ gc.OAND<<16 | gc.TUINT8,
+ gc.OAND<<16 | gc.TINT16,
+ gc.OAND<<16 | gc.TUINT16,
+ gc.OAND<<16 | gc.TINT32,
+ gc.OAND<<16 | gc.TUINT32,
+ gc.OAND<<16 | gc.TPTR32,
+ gc.OAND<<16 | gc.TINT64,
+ gc.OAND<<16 | gc.TUINT64,
+ gc.OAND<<16 | gc.TPTR64:
+ a = ppc64.AAND
+
+ case gc.OOR<<16 | gc.TINT8,
+ gc.OOR<<16 | gc.TUINT8,
+ gc.OOR<<16 | gc.TINT16,
+ gc.OOR<<16 | gc.TUINT16,
+ gc.OOR<<16 | gc.TINT32,
+ gc.OOR<<16 | gc.TUINT32,
+ gc.OOR<<16 | gc.TPTR32,
+ gc.OOR<<16 | gc.TINT64,
+ gc.OOR<<16 | gc.TUINT64,
+ gc.OOR<<16 | gc.TPTR64:
+ a = ppc64.AOR
+
+ case gc.OXOR<<16 | gc.TINT8,
+ gc.OXOR<<16 | gc.TUINT8,
+ gc.OXOR<<16 | gc.TINT16,
+ gc.OXOR<<16 | gc.TUINT16,
+ gc.OXOR<<16 | gc.TINT32,
+ gc.OXOR<<16 | gc.TUINT32,
+ gc.OXOR<<16 | gc.TPTR32,
+ gc.OXOR<<16 | gc.TINT64,
+ gc.OXOR<<16 | gc.TUINT64,
+ gc.OXOR<<16 | gc.TPTR64:
+ a = ppc64.AXOR
+
+ // TODO(minux): handle rotates
+ //case CASE(OLROT, TINT8):
+ //case CASE(OLROT, TUINT8):
+ //case CASE(OLROT, TINT16):
+ //case CASE(OLROT, TUINT16):
+ //case CASE(OLROT, TINT32):
+ //case CASE(OLROT, TUINT32):
+ //case CASE(OLROT, TPTR32):
+ //case CASE(OLROT, TINT64):
+ //case CASE(OLROT, TUINT64):
+ //case CASE(OLROT, TPTR64):
+ // a = 0//???; RLDC?
+ // break;
+
+ case gc.OLSH<<16 | gc.TINT8,
+ gc.OLSH<<16 | gc.TUINT8,
+ gc.OLSH<<16 | gc.TINT16,
+ gc.OLSH<<16 | gc.TUINT16,
+ gc.OLSH<<16 | gc.TINT32,
+ gc.OLSH<<16 | gc.TUINT32,
+ gc.OLSH<<16 | gc.TPTR32,
+ gc.OLSH<<16 | gc.TINT64,
+ gc.OLSH<<16 | gc.TUINT64,
+ gc.OLSH<<16 | gc.TPTR64:
+ a = ppc64.ASLD
+
+ case gc.ORSH<<16 | gc.TUINT8,
+ gc.ORSH<<16 | gc.TUINT16,
+ gc.ORSH<<16 | gc.TUINT32,
+ gc.ORSH<<16 | gc.TPTR32,
+ gc.ORSH<<16 | gc.TUINT64,
+ gc.ORSH<<16 | gc.TPTR64:
+ a = ppc64.ASRD
+
+ case gc.ORSH<<16 | gc.TINT8,
+ gc.ORSH<<16 | gc.TINT16,
+ gc.ORSH<<16 | gc.TINT32,
+ gc.ORSH<<16 | gc.TINT64:
+ a = ppc64.ASRAD
+
+ // TODO(minux): handle rotates
+ //case CASE(ORROTC, TINT8):
+ //case CASE(ORROTC, TUINT8):
+ //case CASE(ORROTC, TINT16):
+ //case CASE(ORROTC, TUINT16):
+ //case CASE(ORROTC, TINT32):
+ //case CASE(ORROTC, TUINT32):
+ //case CASE(ORROTC, TINT64):
+ //case CASE(ORROTC, TUINT64):
+ // a = 0//??? RLDC??
+ // break;
+
+ case gc.OHMUL<<16 | gc.TINT64:
+ a = ppc64.AMULHD
+
+ case gc.OHMUL<<16 | gc.TUINT64,
+ gc.OHMUL<<16 | gc.TPTR64:
+ a = ppc64.AMULHDU
+
+ case gc.OMUL<<16 | gc.TINT8,
+ gc.OMUL<<16 | gc.TINT16,
+ gc.OMUL<<16 | gc.TINT32,
+ gc.OMUL<<16 | gc.TINT64:
+ a = ppc64.AMULLD
+
+ case gc.OMUL<<16 | gc.TUINT8,
+ gc.OMUL<<16 | gc.TUINT16,
+ gc.OMUL<<16 | gc.TUINT32,
+ gc.OMUL<<16 | gc.TPTR32,
+ // don't use word multiply, the high 32-bit are undefined.
+ // fallthrough
+ gc.OMUL<<16 | gc.TUINT64,
+ gc.OMUL<<16 | gc.TPTR64:
+ a = ppc64.AMULLD
+ // for 64-bit multiplies, signedness doesn't matter.
+
+ case gc.OMUL<<16 | gc.TFLOAT32:
+ a = ppc64.AFMULS
+
+ case gc.OMUL<<16 | gc.TFLOAT64:
+ a = ppc64.AFMUL
+
+ case gc.ODIV<<16 | gc.TINT8,
+ gc.ODIV<<16 | gc.TINT16,
+ gc.ODIV<<16 | gc.TINT32,
+ gc.ODIV<<16 | gc.TINT64:
+ a = ppc64.ADIVD
+
+ case gc.ODIV<<16 | gc.TUINT8,
+ gc.ODIV<<16 | gc.TUINT16,
+ gc.ODIV<<16 | gc.TUINT32,
+ gc.ODIV<<16 | gc.TPTR32,
+ gc.ODIV<<16 | gc.TUINT64,
+ gc.ODIV<<16 | gc.TPTR64:
+ a = ppc64.ADIVDU
+
+ case gc.ODIV<<16 | gc.TFLOAT32:
+ a = ppc64.AFDIVS
+
+ case gc.ODIV<<16 | gc.TFLOAT64:
+ a = ppc64.AFDIV
+ }
+
+ return a
+}
+
+const (
+ ODynam = 1 << 0
+ OAddable = 1 << 1
+)
+
+func xgen(n *gc.Node, a *gc.Node, o int) int {
+ // TODO(minux)
+
+ return -1
+}
+
+func sudoclean() {
+ return
+}
+
+/*
+ * generate code to compute address of n,
+ * a reference to a (perhaps nested) field inside
+ * an array or struct.
+ * return 0 on failure, 1 on success.
+ * on success, leaves usable address in a.
+ *
+ * caller is responsible for calling sudoclean
+ * after successful sudoaddable,
+ * to release the register used for a.
+ */
+func sudoaddable(as int, n *gc.Node, a *obj.Addr) int {
+ // TODO(minux)
+
+ *a = obj.Addr{}
+ return 0
+}
--- /dev/null
+// Derived from Inferno utils/6c/peep.c
+// http://code.google.com/p/inferno-os/source/browse/utils/6c/peep.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 main
+
+// Copyright 2014 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.
+
+// Many Power ISA arithmetic and logical instructions come in four
+// standard variants. These bits let us map between variants.
+const (
+ V_CC = 1 << 0
+ V_V = 1 << 1
+)
--- /dev/null
+// Derived from Inferno utils/6c/peep.c
+// http://code.google.com/p/inferno-os/source/browse/utils/6c/peep.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 main
+
+import (
+ "cmd/internal/obj"
+ "cmd/internal/obj/ppc64"
+ "fmt"
+)
+import "cmd/internal/gc"
+
+var gactive uint32
+
+func peep(firstp *obj.Prog) {
+ var g *gc.Graph
+ var r *gc.Flow
+ var r1 *gc.Flow
+ var p *obj.Prog
+ var p1 *obj.Prog
+ var t int
+
+ g = gc.Flowstart(firstp, nil)
+ if g == nil {
+ return
+ }
+ gactive = 0
+
+loop1:
+ if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 {
+ gc.Dumpit("loop1", g.Start, 0)
+ }
+
+ t = 0
+ for r = g.Start; r != nil; r = r.Link {
+ p = r.Prog
+
+ // TODO(austin) Handle smaller moves. arm and amd64
+ // distinguish between moves that moves that *must*
+ // sign/zero extend and moves that don't care so they
+ // can eliminate moves that don't care without
+ // breaking moves that do care. This might let us
+ // simplify or remove the next peep loop, too.
+ if p.As == ppc64.AMOVD || p.As == ppc64.AFMOVD {
+ if regtyp(&p.To) != 0 {
+ // Try to eliminate reg->reg moves
+ if regtyp(&p.From) != 0 {
+ if p.From.Type == p.To.Type {
+ if copyprop(r) != 0 {
+ excise(r)
+ t++
+ } else if subprop(r) != 0 && copyprop(r) != 0 {
+ excise(r)
+ t++
+ }
+ }
+ }
+
+ // Convert uses to $0 to uses of R0 and
+ // propagate R0
+ if regzer(&p.From) != 0 {
+ if p.To.Type == obj.TYPE_REG {
+ p.From.Type = obj.TYPE_REG
+ p.From.Reg = ppc64.REGZERO
+ if copyprop(r) != 0 {
+ excise(r)
+ t++
+ } else if subprop(r) != 0 && copyprop(r) != 0 {
+ excise(r)
+ t++
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if t != 0 {
+ goto loop1
+ }
+
+ /*
+ * look for MOVB x,R; MOVB R,R (for small MOVs not handled above)
+ */
+ for r = g.Start; r != nil; r = r.Link {
+ p = r.Prog
+ switch p.As {
+ default:
+ continue
+
+ case ppc64.AMOVH,
+ ppc64.AMOVHZ,
+ ppc64.AMOVB,
+ ppc64.AMOVBZ,
+ ppc64.AMOVW,
+ ppc64.AMOVWZ:
+ if p.To.Type != obj.TYPE_REG {
+ continue
+ }
+ }
+
+ r1 = r.Link
+ if r1 == nil {
+ continue
+ }
+ p1 = r1.Prog
+ if p1.As != p.As {
+ continue
+ }
+ if p1.From.Type != obj.TYPE_REG || p1.From.Reg != p.To.Reg {
+ continue
+ }
+ if p1.To.Type != obj.TYPE_REG || p1.To.Reg != p.To.Reg {
+ continue
+ }
+ excise(r1)
+ }
+
+ if gc.Debug['D'] > 1 {
+ goto ret /* allow following code improvement to be suppressed */
+ }
+
+ /*
+ * look for OP x,y,R; CMP R, $0 -> OPCC x,y,R
+ * when OP can set condition codes correctly
+ */
+ for r = g.Start; r != nil; r = r.Link {
+ p = r.Prog
+ switch p.As {
+ case ppc64.ACMP,
+ ppc64.ACMPW: /* always safe? */
+ if !(regzer(&p.To) != 0) {
+ continue
+ }
+ r1 = r.S1
+ if r1 == nil {
+ continue
+ }
+ switch r1.Prog.As {
+ default:
+ continue
+
+ /* the conditions can be complex and these are currently little used */
+ case ppc64.ABCL,
+ ppc64.ABC:
+ continue
+
+ case ppc64.ABEQ,
+ ppc64.ABGE,
+ ppc64.ABGT,
+ ppc64.ABLE,
+ ppc64.ABLT,
+ ppc64.ABNE,
+ ppc64.ABVC,
+ ppc64.ABVS:
+ break
+ }
+
+ r1 = r
+ for {
+ r1 = gc.Uniqp(r1)
+ if !(r1 != nil && r1.Prog.As == obj.ANOP) {
+ break
+ }
+ }
+
+ if r1 == nil {
+ continue
+ }
+ p1 = r1.Prog
+ if p1.To.Type != obj.TYPE_REG || p1.To.Reg != p.From.Reg {
+ continue
+ }
+ switch p1.As {
+ /* irregular instructions */
+ case ppc64.ASUB,
+ ppc64.AADD,
+ ppc64.AXOR,
+ ppc64.AOR:
+ if p1.From.Type == obj.TYPE_CONST || p1.From.Type == obj.TYPE_ADDR {
+ continue
+ }
+ }
+
+ switch p1.As {
+ default:
+ continue
+
+ case ppc64.AMOVW,
+ ppc64.AMOVD:
+ if p1.From.Type != obj.TYPE_REG {
+ continue
+ }
+ continue
+
+ case ppc64.AANDCC,
+ ppc64.AANDNCC,
+ ppc64.AORCC,
+ ppc64.AORNCC,
+ ppc64.AXORCC,
+ ppc64.ASUBCC,
+ ppc64.ASUBECC,
+ ppc64.ASUBMECC,
+ ppc64.ASUBZECC,
+ ppc64.AADDCC,
+ ppc64.AADDCCC,
+ ppc64.AADDECC,
+ ppc64.AADDMECC,
+ ppc64.AADDZECC,
+ ppc64.ARLWMICC,
+ ppc64.ARLWNMCC,
+ /* don't deal with floating point instructions for now */
+ /*
+ case AFABS:
+ case AFADD:
+ case AFADDS:
+ case AFCTIW:
+ case AFCTIWZ:
+ case AFDIV:
+ case AFDIVS:
+ case AFMADD:
+ case AFMADDS:
+ case AFMOVD:
+ case AFMSUB:
+ case AFMSUBS:
+ case AFMUL:
+ case AFMULS:
+ case AFNABS:
+ case AFNEG:
+ case AFNMADD:
+ case AFNMADDS:
+ case AFNMSUB:
+ case AFNMSUBS:
+ case AFRSP:
+ case AFSUB:
+ case AFSUBS:
+ case ACNTLZW:
+ case AMTFSB0:
+ case AMTFSB1:
+ */
+ ppc64.AADD,
+ ppc64.AADDV,
+ ppc64.AADDC,
+ ppc64.AADDCV,
+ ppc64.AADDME,
+ ppc64.AADDMEV,
+ ppc64.AADDE,
+ ppc64.AADDEV,
+ ppc64.AADDZE,
+ ppc64.AADDZEV,
+ ppc64.AAND,
+ ppc64.AANDN,
+ ppc64.ADIVW,
+ ppc64.ADIVWV,
+ ppc64.ADIVWU,
+ ppc64.ADIVWUV,
+ ppc64.ADIVD,
+ ppc64.ADIVDV,
+ ppc64.ADIVDU,
+ ppc64.ADIVDUV,
+ ppc64.AEQV,
+ ppc64.AEXTSB,
+ ppc64.AEXTSH,
+ ppc64.AEXTSW,
+ ppc64.AMULHW,
+ ppc64.AMULHWU,
+ ppc64.AMULLW,
+ ppc64.AMULLWV,
+ ppc64.AMULHD,
+ ppc64.AMULHDU,
+ ppc64.AMULLD,
+ ppc64.AMULLDV,
+ ppc64.ANAND,
+ ppc64.ANEG,
+ ppc64.ANEGV,
+ ppc64.ANOR,
+ ppc64.AOR,
+ ppc64.AORN,
+ ppc64.AREM,
+ ppc64.AREMV,
+ ppc64.AREMU,
+ ppc64.AREMUV,
+ ppc64.AREMD,
+ ppc64.AREMDV,
+ ppc64.AREMDU,
+ ppc64.AREMDUV,
+ ppc64.ARLWMI,
+ ppc64.ARLWNM,
+ ppc64.ASLW,
+ ppc64.ASRAW,
+ ppc64.ASRW,
+ ppc64.ASLD,
+ ppc64.ASRAD,
+ ppc64.ASRD,
+ ppc64.ASUB,
+ ppc64.ASUBV,
+ ppc64.ASUBC,
+ ppc64.ASUBCV,
+ ppc64.ASUBME,
+ ppc64.ASUBMEV,
+ ppc64.ASUBE,
+ ppc64.ASUBEV,
+ ppc64.ASUBZE,
+ ppc64.ASUBZEV,
+ ppc64.AXOR:
+ t = variant2as(int(p1.As), as2variant(int(p1.As))|V_CC)
+ }
+
+ if gc.Debug['D'] != 0 {
+ fmt.Printf("cmp %v; %v -> ", p1, p)
+ }
+ p1.As = int16(t)
+ if gc.Debug['D'] != 0 {
+ fmt.Printf("%v\n", p1)
+ }
+ excise(r)
+ continue
+ }
+ }
+
+ret:
+ gc.Flowend(g)
+}
+
+func excise(r *gc.Flow) {
+ var p *obj.Prog
+
+ p = r.Prog
+ if gc.Debug['P'] != 0 && gc.Debug['v'] != 0 {
+ fmt.Printf("%v ===delete===\n", p)
+ }
+ obj.Nopout(p)
+ gc.Ostats.Ndelmov++
+}
+
+/*
+ * regzer returns 1 if a's value is 0 (a is R0 or $0)
+ */
+func regzer(a *obj.Addr) int {
+ if a.Type == obj.TYPE_CONST || a.Type == obj.TYPE_ADDR {
+ if a.Sym == nil && a.Reg == 0 {
+ if a.Offset == 0 {
+ return 1
+ }
+ }
+ }
+ if a.Type == obj.TYPE_REG {
+ if a.Reg == ppc64.REGZERO {
+ return 1
+ }
+ }
+ return 0
+}
+
+func regtyp(a *obj.Addr) int {
+ // TODO(rsc): Floating point register exclusions?
+ return bool2int(a.Type == obj.TYPE_REG && ppc64.REG_R0 <= a.Reg && a.Reg <= ppc64.REG_F31 && a.Reg != ppc64.REGZERO)
+}
+
+/*
+ * the idea is to substitute
+ * one register for another
+ * from one MOV to another
+ * MOV a, R1
+ * ADD b, R1 / no use of R2
+ * MOV R1, R2
+ * would be converted to
+ * MOV a, R2
+ * ADD b, R2
+ * MOV R2, R1
+ * hopefully, then the former or latter MOV
+ * will be eliminated by copy propagation.
+ *
+ * r0 (the argument, not the register) is the MOV at the end of the
+ * above sequences. This returns 1 if it modified any instructions.
+ */
+func subprop(r0 *gc.Flow) int {
+ var p *obj.Prog
+ var v1 *obj.Addr
+ var v2 *obj.Addr
+ var r *gc.Flow
+ var t int
+ var info gc.ProgInfo
+
+ p = r0.Prog
+ v1 = &p.From
+ if !(regtyp(v1) != 0) {
+ return 0
+ }
+ v2 = &p.To
+ if !(regtyp(v2) != 0) {
+ return 0
+ }
+ for r = gc.Uniqp(r0); r != nil; r = gc.Uniqp(r) {
+ if gc.Uniqs(r) == nil {
+ break
+ }
+ p = r.Prog
+ if p.As == obj.AVARDEF || p.As == obj.AVARKILL {
+ continue
+ }
+ proginfo(&info, p)
+ if info.Flags&gc.Call != 0 {
+ return 0
+ }
+
+ if info.Flags&(gc.RightRead|gc.RightWrite) == gc.RightWrite {
+ if p.To.Type == v1.Type {
+ if p.To.Reg == v1.Reg {
+ goto gotit
+ }
+ }
+ }
+
+ if copyau(&p.From, v2) != 0 || copyau1(p, v2) != 0 || copyau(&p.To, v2) != 0 {
+ break
+ }
+ if copysub(&p.From, v1, v2, 0) != 0 || copysub1(p, v1, v2, 0) != 0 || copysub(&p.To, v1, v2, 0) != 0 {
+ break
+ }
+ }
+
+ return 0
+
+gotit:
+ copysub(&p.To, v1, v2, 1)
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("gotit: %v->%v\n%v", gc.Ctxt.Dconv(v1), gc.Ctxt.Dconv(v2), r.Prog)
+ if p.From.Type == v2.Type {
+ fmt.Printf(" excise")
+ }
+ fmt.Printf("\n")
+ }
+
+ for r = gc.Uniqs(r); r != r0; r = gc.Uniqs(r) {
+ p = r.Prog
+ copysub(&p.From, v1, v2, 1)
+ copysub1(p, v1, v2, 1)
+ copysub(&p.To, v1, v2, 1)
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("%v\n", r.Prog)
+ }
+ }
+
+ t = int(v1.Reg)
+ v1.Reg = v2.Reg
+ v2.Reg = int16(t)
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("%v last\n", r.Prog)
+ }
+ return 1
+}
+
+/*
+ * The idea is to remove redundant copies.
+ * v1->v2 F=0
+ * (use v2 s/v2/v1/)*
+ * set v1 F=1
+ * use v2 return fail (v1->v2 move must remain)
+ * -----------------
+ * v1->v2 F=0
+ * (use v2 s/v2/v1/)*
+ * set v1 F=1
+ * set v2 return success (caller can remove v1->v2 move)
+ */
+func copyprop(r0 *gc.Flow) int {
+ var p *obj.Prog
+ var v1 *obj.Addr
+ var v2 *obj.Addr
+
+ p = r0.Prog
+ v1 = &p.From
+ v2 = &p.To
+ if copyas(v1, v2) != 0 {
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("eliminating self-move\n", r0.Prog)
+ }
+ return 1
+ }
+
+ gactive++
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("trying to eliminate %v->%v move from:\n%v\n", gc.Ctxt.Dconv(v1), gc.Ctxt.Dconv(v2), r0.Prog)
+ }
+ return copy1(v1, v2, r0.S1, 0)
+}
+
+// copy1 replaces uses of v2 with v1 starting at r and returns 1 if
+// all uses were rewritten.
+func copy1(v1 *obj.Addr, v2 *obj.Addr, r *gc.Flow, f int) int {
+ var t int
+ var p *obj.Prog
+
+ if uint32(r.Active) == gactive {
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("act set; return 1\n")
+ }
+ return 1
+ }
+
+ r.Active = int32(gactive)
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("copy1 replace %v with %v f=%d\n", gc.Ctxt.Dconv(v2), gc.Ctxt.Dconv(v1), f)
+ }
+ for ; r != nil; r = r.S1 {
+ p = r.Prog
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("%v", p)
+ }
+ if !(f != 0) && gc.Uniqp(r) == nil {
+ // Multiple predecessors; conservatively
+ // assume v1 was set on other path
+ f = 1
+
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("; merge; f=%d", f)
+ }
+ }
+
+ t = copyu(p, v2, nil)
+ switch t {
+ case 2: /* rar, can't split */
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("; %v rar; return 0\n", gc.Ctxt.Dconv(v2))
+ }
+ return 0
+
+ case 3: /* set */
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("; %v set; return 1\n", gc.Ctxt.Dconv(v2))
+ }
+ return 1
+
+ case 1, /* used, substitute */
+ 4: /* use and set */
+ if f != 0 {
+ if !(gc.Debug['P'] != 0) {
+ return 0
+ }
+ if t == 4 {
+ fmt.Printf("; %v used+set and f=%d; return 0\n", gc.Ctxt.Dconv(v2), f)
+ } else {
+ fmt.Printf("; %v used and f=%d; return 0\n", gc.Ctxt.Dconv(v2), f)
+ }
+ return 0
+ }
+
+ if copyu(p, v2, v1) != 0 {
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("; sub fail; return 0\n")
+ }
+ return 0
+ }
+
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("; sub %v->%v\n => %v", gc.Ctxt.Dconv(v2), gc.Ctxt.Dconv(v1), p)
+ }
+ if t == 4 {
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("; %v used+set; return 1\n", gc.Ctxt.Dconv(v2))
+ }
+ return 1
+ }
+ }
+
+ if !(f != 0) {
+ t = copyu(p, v1, nil)
+ if !(f != 0) && (t == 2 || t == 3 || t == 4) {
+ f = 1
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("; %v set and !f; f=%d", gc.Ctxt.Dconv(v1), f)
+ }
+ }
+ }
+
+ if gc.Debug['P'] != 0 {
+ fmt.Printf("\n")
+ }
+ if r.S2 != nil {
+ if !(copy1(v1, v2, r.S2, f) != 0) {
+ return 0
+ }
+ }
+ }
+
+ return 1
+}
+
+// If s==nil, copyu returns the set/use of v in p; otherwise, it
+// modifies p to replace reads of v with reads of s and returns 0 for
+// success or non-zero for failure.
+//
+// If s==nil, copy returns one of the following values:
+// 1 if v only used
+// 2 if v is set and used in one address (read-alter-rewrite;
+// can't substitute)
+// 3 if v is only set
+// 4 if v is set in one address and used in another (so addresses
+// can be rewritten independently)
+// 0 otherwise (not touched)
+func copyu(p *obj.Prog, v *obj.Addr, s *obj.Addr) int {
+ if p.From3.Type != obj.TYPE_NONE {
+ // 9g never generates a from3
+ fmt.Printf("copyu: from3 (%v) not implemented\n", gc.Ctxt.Dconv(&p.From3))
+ }
+
+ switch p.As {
+ default:
+ fmt.Printf("copyu: can't find %v\n", ppc64.Aconv(int(p.As)))
+ return 2
+
+ case obj.ANOP, /* read p->from, write p->to */
+ ppc64.AMOVH,
+ ppc64.AMOVHZ,
+ ppc64.AMOVB,
+ ppc64.AMOVBZ,
+ ppc64.AMOVW,
+ ppc64.AMOVWZ,
+ ppc64.AMOVD,
+ ppc64.ANEG,
+ ppc64.ANEGCC,
+ ppc64.AADDME,
+ ppc64.AADDMECC,
+ ppc64.AADDZE,
+ ppc64.AADDZECC,
+ ppc64.ASUBME,
+ ppc64.ASUBMECC,
+ ppc64.ASUBZE,
+ ppc64.ASUBZECC,
+ ppc64.AFCTIW,
+ ppc64.AFCTIWZ,
+ ppc64.AFCTID,
+ ppc64.AFCTIDZ,
+ ppc64.AFCFID,
+ ppc64.AFCFIDCC,
+ ppc64.AFMOVS,
+ ppc64.AFMOVD,
+ ppc64.AFRSP,
+ ppc64.AFNEG,
+ ppc64.AFNEGCC:
+ if s != nil {
+ if copysub(&p.From, v, s, 1) != 0 {
+ return 1
+ }
+
+ // Update only indirect uses of v in p->to
+ if !(copyas(&p.To, v) != 0) {
+ if copysub(&p.To, v, s, 1) != 0 {
+ return 1
+ }
+ }
+ return 0
+ }
+
+ if copyas(&p.To, v) != 0 {
+ // Fix up implicit from
+ if p.From.Type == obj.TYPE_NONE {
+ p.From = p.To
+ }
+ if copyau(&p.From, v) != 0 {
+ return 4
+ }
+ return 3
+ }
+
+ if copyau(&p.From, v) != 0 {
+ return 1
+ }
+ if copyau(&p.To, v) != 0 {
+ // p->to only indirectly uses v
+ return 1
+ }
+
+ return 0
+
+ case ppc64.AMOVBU, /* rar p->from, write p->to or read p->from, rar p->to */
+ ppc64.AMOVBZU,
+ ppc64.AMOVHU,
+ ppc64.AMOVHZU,
+ ppc64.AMOVWZU,
+ ppc64.AMOVDU:
+ if p.From.Type == obj.TYPE_MEM {
+ if copyas(&p.From, v) != 0 {
+ // No s!=nil check; need to fail
+ // anyway in that case
+ return 2
+ }
+
+ if s != nil {
+ if copysub(&p.To, v, s, 1) != 0 {
+ return 1
+ }
+ return 0
+ }
+
+ if copyas(&p.To, v) != 0 {
+ return 3
+ }
+ } else if p.To.Type == obj.TYPE_MEM {
+ if copyas(&p.To, v) != 0 {
+ return 2
+ }
+ if s != nil {
+ if copysub(&p.From, v, s, 1) != 0 {
+ return 1
+ }
+ return 0
+ }
+
+ if copyau(&p.From, v) != 0 {
+ return 1
+ }
+ } else {
+ fmt.Printf("copyu: bad %v\n", p)
+ }
+
+ return 0
+
+ case ppc64.ARLWMI, /* read p->from, read p->reg, rar p->to */
+ ppc64.ARLWMICC:
+ if copyas(&p.To, v) != 0 {
+ return 2
+ }
+ fallthrough
+
+ /* fall through */
+ case ppc64.AADD,
+ /* read p->from, read p->reg, write p->to */
+ ppc64.AADDC,
+ ppc64.AADDE,
+ ppc64.ASUB,
+ ppc64.ASLW,
+ ppc64.ASRW,
+ ppc64.ASRAW,
+ ppc64.ASLD,
+ ppc64.ASRD,
+ ppc64.ASRAD,
+ ppc64.AOR,
+ ppc64.AORCC,
+ ppc64.AORN,
+ ppc64.AORNCC,
+ ppc64.AAND,
+ ppc64.AANDCC,
+ ppc64.AANDN,
+ ppc64.AANDNCC,
+ ppc64.ANAND,
+ ppc64.ANANDCC,
+ ppc64.ANOR,
+ ppc64.ANORCC,
+ ppc64.AXOR,
+ ppc64.AMULHW,
+ ppc64.AMULHWU,
+ ppc64.AMULLW,
+ ppc64.AMULLD,
+ ppc64.ADIVW,
+ ppc64.ADIVD,
+ ppc64.ADIVWU,
+ ppc64.ADIVDU,
+ ppc64.AREM,
+ ppc64.AREMU,
+ ppc64.AREMD,
+ ppc64.AREMDU,
+ ppc64.ARLWNM,
+ ppc64.ARLWNMCC,
+ ppc64.AFADDS,
+ ppc64.AFADD,
+ ppc64.AFSUBS,
+ ppc64.AFSUB,
+ ppc64.AFMULS,
+ ppc64.AFMUL,
+ ppc64.AFDIVS,
+ ppc64.AFDIV:
+ if s != nil {
+ if copysub(&p.From, v, s, 1) != 0 {
+ return 1
+ }
+ if copysub1(p, v, s, 1) != 0 {
+ return 1
+ }
+
+ // Update only indirect uses of v in p->to
+ if !(copyas(&p.To, v) != 0) {
+ if copysub(&p.To, v, s, 1) != 0 {
+ return 1
+ }
+ }
+ return 0
+ }
+
+ if copyas(&p.To, v) != 0 {
+ if p.Reg == 0 {
+ // Fix up implicit reg (e.g., ADD
+ // R3,R4 -> ADD R3,R4,R4) so we can
+ // update reg and to separately.
+ p.Reg = p.To.Reg
+ }
+
+ if copyau(&p.From, v) != 0 {
+ return 4
+ }
+ if copyau1(p, v) != 0 {
+ return 4
+ }
+ return 3
+ }
+
+ if copyau(&p.From, v) != 0 {
+ return 1
+ }
+ if copyau1(p, v) != 0 {
+ return 1
+ }
+ if copyau(&p.To, v) != 0 {
+ return 1
+ }
+ return 0
+
+ case ppc64.ABEQ,
+ ppc64.ABGT,
+ ppc64.ABGE,
+ ppc64.ABLT,
+ ppc64.ABLE,
+ ppc64.ABNE,
+ ppc64.ABVC,
+ ppc64.ABVS:
+ return 0
+
+ case obj.ACHECKNIL, /* read p->from */
+ ppc64.ACMP, /* read p->from, read p->to */
+ ppc64.ACMPU,
+ ppc64.ACMPW,
+ ppc64.ACMPWU,
+ ppc64.AFCMPO,
+ ppc64.AFCMPU:
+ if s != nil {
+ if copysub(&p.From, v, s, 1) != 0 {
+ return 1
+ }
+ return copysub(&p.To, v, s, 1)
+ }
+
+ if copyau(&p.From, v) != 0 {
+ return 1
+ }
+ if copyau(&p.To, v) != 0 {
+ return 1
+ }
+ return 0
+
+ // 9g never generates a branch to a GPR (this isn't
+ // even a normal instruction; liblink turns it in to a
+ // mov and a branch).
+ case ppc64.ABR: /* read p->to */
+ if s != nil {
+ if copysub(&p.To, v, s, 1) != 0 {
+ return 1
+ }
+ return 0
+ }
+
+ if copyau(&p.To, v) != 0 {
+ return 1
+ }
+ return 0
+
+ case ppc64.ARETURN: /* funny */
+ if s != nil {
+ return 0
+ }
+
+ // All registers die at this point, so claim
+ // everything is set (and not used).
+ return 3
+
+ case ppc64.ABL: /* funny */
+ if v.Type == obj.TYPE_REG {
+ // TODO(rsc): REG_R0 and REG_F0 used to be
+ // (when register numbers started at 0) exregoffset and exfregoffset,
+ // which are unset entirely.
+ // It's strange that this handles R0 and F0 differently from the other
+ // registers. Possible failure to optimize?
+ if ppc64.REG_R0 < v.Reg && v.Reg <= ppc64.REGEXT {
+ return 2
+ }
+ if v.Reg == ppc64.REGARG {
+ return 2
+ }
+ if ppc64.REG_F0 < v.Reg && v.Reg <= ppc64.FREGEXT {
+ return 2
+ }
+ }
+
+ if p.From.Type == obj.TYPE_REG && v.Type == obj.TYPE_REG && p.From.Reg == v.Reg {
+ return 2
+ }
+
+ if s != nil {
+ if copysub(&p.To, v, s, 1) != 0 {
+ return 1
+ }
+ return 0
+ }
+
+ if copyau(&p.To, v) != 0 {
+ return 4
+ }
+ return 3
+
+ // R0 is zero, used by DUFFZERO, cannot be substituted.
+ // R3 is ptr to memory, used and set, cannot be substituted.
+ case obj.ADUFFZERO:
+ if v.Type == obj.TYPE_REG {
+ if v.Reg == 0 {
+ return 1
+ }
+ if v.Reg == 3 {
+ return 2
+ }
+ }
+
+ return 0
+
+ // R3, R4 are ptr to src, dst, used and set, cannot be substituted.
+ // R5 is scratch, set by DUFFCOPY, cannot be substituted.
+ case obj.ADUFFCOPY:
+ if v.Type == obj.TYPE_REG {
+ if v.Reg == 3 || v.Reg == 4 {
+ return 2
+ }
+ if v.Reg == 5 {
+ return 3
+ }
+ }
+
+ return 0
+
+ case obj.ATEXT: /* funny */
+ if v.Type == obj.TYPE_REG {
+ if v.Reg == ppc64.REGARG {
+ return 3
+ }
+ }
+ return 0
+
+ case obj.APCDATA,
+ obj.AFUNCDATA,
+ obj.AVARDEF,
+ obj.AVARKILL:
+ return 0
+ }
+}
+
+// copyas returns 1 if a and v address the same register.
+//
+// If a is the from operand, this means this operation reads the
+// register in v. If a is the to operand, this means this operation
+// writes the register in v.
+func copyas(a *obj.Addr, v *obj.Addr) int {
+ if regtyp(v) != 0 {
+ if a.Type == v.Type {
+ if a.Reg == v.Reg {
+ return 1
+ }
+ }
+ }
+ return 0
+}
+
+// copyau returns 1 if a either directly or indirectly addresses the
+// same register as v.
+//
+// If a is the from operand, this means this operation reads the
+// register in v. If a is the to operand, this means the operation
+// either reads or writes the register in v (if !copyas(a, v), then
+// the operation reads the register in v).
+func copyau(a *obj.Addr, v *obj.Addr) int {
+ if copyas(a, v) != 0 {
+ return 1
+ }
+ if v.Type == obj.TYPE_REG {
+ if a.Type == obj.TYPE_MEM || (a.Type == obj.TYPE_ADDR && a.Reg != 0) {
+ if v.Reg == a.Reg {
+ return 1
+ }
+ }
+ }
+ return 0
+}
+
+// copyau1 returns 1 if p->reg references the same register as v and v
+// is a direct reference.
+func copyau1(p *obj.Prog, v *obj.Addr) int {
+ if regtyp(v) != 0 && v.Reg != 0 {
+ if p.Reg == v.Reg {
+ return 1
+ }
+ }
+ return 0
+}
+
+// copysub replaces v with s in a if f!=0 or indicates it if could if f==0.
+// Returns 1 on failure to substitute (it always succeeds on ppc64).
+func copysub(a *obj.Addr, v *obj.Addr, s *obj.Addr, f int) int {
+ if f != 0 {
+ if copyau(a, v) != 0 {
+ a.Reg = s.Reg
+ }
+ }
+ return 0
+}
+
+// copysub1 replaces v with s in p1->reg if f!=0 or indicates if it could if f==0.
+// Returns 1 on failure to substitute (it always succeeds on ppc64).
+func copysub1(p1 *obj.Prog, v *obj.Addr, s *obj.Addr, f int) int {
+ if f != 0 {
+ if copyau1(p1, v) != 0 {
+ p1.Reg = s.Reg
+ }
+ }
+ return 0
+}
+
+func sameaddr(a *obj.Addr, v *obj.Addr) int {
+ if a.Type != v.Type {
+ return 0
+ }
+ if regtyp(v) != 0 && a.Reg == v.Reg {
+ return 1
+ }
+ if v.Type == obj.NAME_AUTO || v.Type == obj.NAME_PARAM {
+ if v.Offset == a.Offset {
+ return 1
+ }
+ }
+ return 0
+}
+
+func smallindir(a *obj.Addr, reg *obj.Addr) int {
+ return bool2int(reg.Type == obj.TYPE_REG && a.Type == obj.TYPE_MEM && a.Reg == reg.Reg && 0 <= a.Offset && a.Offset < 4096)
+}
+
+func stackaddr(a *obj.Addr) int {
+ return bool2int(a.Type == obj.TYPE_REG && a.Reg == ppc64.REGSP)
+}
--- /dev/null
+// Copyright 2014 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 main
+
+import (
+ "cmd/internal/obj"
+ "cmd/internal/obj/ppc64"
+)
+import "cmd/internal/gc"
+
+const (
+ LeftRdwr uint32 = gc.LeftRead | gc.LeftWrite
+ RightRdwr uint32 = gc.RightRead | gc.RightWrite
+)
+
+// This table gives the basic information about instruction
+// generated by the compiler and processed in the optimizer.
+// See opt.h for bit definitions.
+//
+// Instructions not generated need not be listed.
+// As an exception to that rule, we typically write down all the
+// size variants of an operation even if we just use a subset.
+//
+// The table is formatted for 8-space tabs.
+var progtable = [ppc64.ALAST]gc.ProgInfo{
+ obj.ATYPE: gc.ProgInfo{gc.Pseudo | gc.Skip, 0, 0, 0},
+ obj.ATEXT: gc.ProgInfo{gc.Pseudo, 0, 0, 0},
+ obj.AFUNCDATA: gc.ProgInfo{gc.Pseudo, 0, 0, 0},
+ obj.APCDATA: gc.ProgInfo{gc.Pseudo, 0, 0, 0},
+ obj.AUNDEF: gc.ProgInfo{gc.Break, 0, 0, 0},
+ obj.AUSEFIELD: gc.ProgInfo{gc.OK, 0, 0, 0},
+ obj.ACHECKNIL: gc.ProgInfo{gc.LeftRead, 0, 0, 0},
+ obj.AVARDEF: gc.ProgInfo{gc.Pseudo | gc.RightWrite, 0, 0, 0},
+ obj.AVARKILL: gc.ProgInfo{gc.Pseudo | gc.RightWrite, 0, 0, 0},
+
+ // NOP is an internal no-op that also stands
+ // for USED and SET annotations, not the Power opcode.
+ obj.ANOP: gc.ProgInfo{gc.LeftRead | gc.RightWrite, 0, 0, 0},
+
+ // Integer
+ ppc64.AADD: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ ppc64.ASUB: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ ppc64.ANEG: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ ppc64.AAND: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ ppc64.AOR: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ ppc64.AXOR: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ ppc64.AMULLD: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ ppc64.AMULLW: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ ppc64.AMULHD: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ ppc64.AMULHDU: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ ppc64.ADIVD: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ ppc64.ADIVDU: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ ppc64.ASLD: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ ppc64.ASRD: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ ppc64.ASRAD: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ ppc64.ACMP: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.RightRead, 0, 0, 0},
+ ppc64.ACMPU: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.RightRead, 0, 0, 0},
+ ppc64.ATD: gc.ProgInfo{gc.SizeQ | gc.RightRead, 0, 0, 0},
+
+ // Floating point.
+ ppc64.AFADD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ ppc64.AFADDS: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ ppc64.AFSUB: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ ppc64.AFSUBS: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ ppc64.AFMUL: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ ppc64.AFMULS: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ ppc64.AFDIV: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ ppc64.AFDIVS: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ ppc64.AFCTIDZ: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ ppc64.AFCFID: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+ ppc64.AFCMPU: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightRead, 0, 0, 0},
+ ppc64.AFRSP: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+
+ // Moves
+ ppc64.AMOVB: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.RightWrite | gc.Move | gc.Conv, 0, 0, 0},
+ ppc64.AMOVBU: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.RightWrite | gc.Move | gc.Conv | gc.PostInc, 0, 0, 0},
+ ppc64.AMOVBZ: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.RightWrite | gc.Move | gc.Conv, 0, 0, 0},
+ ppc64.AMOVH: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightWrite | gc.Move | gc.Conv, 0, 0, 0},
+ ppc64.AMOVHU: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightWrite | gc.Move | gc.Conv | gc.PostInc, 0, 0, 0},
+ ppc64.AMOVHZ: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightWrite | gc.Move | gc.Conv, 0, 0, 0},
+ ppc64.AMOVW: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Move | gc.Conv, 0, 0, 0},
+
+ // there is no AMOVWU.
+ ppc64.AMOVWZU: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Move | gc.Conv | gc.PostInc, 0, 0, 0},
+ ppc64.AMOVWZ: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Move | gc.Conv, 0, 0, 0},
+ ppc64.AMOVD: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
+ ppc64.AMOVDU: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.RightWrite | gc.Move | gc.PostInc, 0, 0, 0},
+ ppc64.AFMOVS: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightWrite | gc.Move | gc.Conv, 0, 0, 0},
+ ppc64.AFMOVD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
+
+ // Jumps
+ ppc64.ABR: gc.ProgInfo{gc.Jump | gc.Break, 0, 0, 0},
+ ppc64.ABL: gc.ProgInfo{gc.Call, 0, 0, 0},
+ ppc64.ABEQ: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+ ppc64.ABNE: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+ ppc64.ABGE: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+ ppc64.ABLT: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+ ppc64.ABGT: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+ ppc64.ABLE: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+ ppc64.ARETURN: gc.ProgInfo{gc.Break, 0, 0, 0},
+ obj.ADUFFZERO: gc.ProgInfo{gc.Call, 0, 0, 0},
+ obj.ADUFFCOPY: gc.ProgInfo{gc.Call, 0, 0, 0},
+}
+
+var initproginfo_initialized int
+
+func initproginfo() {
+ var addvariant = []int{V_CC, V_V, V_CC | V_V}
+ var as int
+ var as2 int
+ var i int
+ var variant int
+
+ if initproginfo_initialized != 0 {
+ return
+ }
+ initproginfo_initialized = 1
+
+ // Perform one-time expansion of instructions in progtable to
+ // their CC, V, and VCC variants
+ for as = 0; as < len(progtable); as++ {
+ if progtable[as].Flags == 0 {
+ continue
+ }
+ variant = as2variant(as)
+ for i = 0; i < len(addvariant); i++ {
+ as2 = variant2as(as, variant|addvariant[i])
+ if as2 != 0 && progtable[as2].Flags == 0 {
+ progtable[as2] = progtable[as]
+ }
+ }
+ }
+}
+
+func proginfo(info *gc.ProgInfo, p *obj.Prog) {
+ initproginfo()
+
+ *info = progtable[p.As]
+ if info.Flags == 0 {
+ *info = progtable[ppc64.AADD]
+ gc.Fatal("proginfo: unknown instruction %v", p)
+ }
+
+ if (info.Flags&gc.RegRead != 0) && p.Reg == 0 {
+ info.Flags &^= gc.RegRead
+ info.Flags |= gc.RightRead /*CanRegRead |*/
+ }
+
+ if (p.From.Type == obj.TYPE_MEM || p.From.Type == obj.TYPE_ADDR) && p.From.Reg != 0 {
+ info.Regindex |= RtoB(int(p.From.Reg))
+ if info.Flags&gc.PostInc != 0 {
+ info.Regset |= RtoB(int(p.From.Reg))
+ }
+ }
+
+ if (p.To.Type == obj.TYPE_MEM || p.To.Type == obj.TYPE_ADDR) && p.To.Reg != 0 {
+ info.Regindex |= RtoB(int(p.To.Reg))
+ if info.Flags&gc.PostInc != 0 {
+ info.Regset |= RtoB(int(p.To.Reg))
+ }
+ }
+
+ if p.From.Type == obj.TYPE_ADDR && p.From.Sym != nil && (info.Flags&gc.LeftRead != 0) {
+ info.Flags &^= gc.LeftRead
+ info.Flags |= gc.LeftAddr
+ }
+
+ if p.As == obj.ADUFFZERO {
+ info.Reguse |= 1<<0 | RtoB(ppc64.REG_R3)
+ info.Regset |= RtoB(ppc64.REG_R3)
+ }
+
+ if p.As == obj.ADUFFCOPY {
+ // TODO(austin) Revisit when duffcopy is implemented
+ info.Reguse |= RtoB(ppc64.REG_R3) | RtoB(ppc64.REG_R4) | RtoB(ppc64.REG_R5)
+
+ info.Regset |= RtoB(ppc64.REG_R3) | RtoB(ppc64.REG_R4)
+ }
+}
+
+// Instruction variants table. Initially this contains entries only
+// for the "base" form of each instruction. On the first call to
+// as2variant or variant2as, we'll add the variants to the table.
+var varianttable = [ppc64.ALAST][4]int{
+ ppc64.AADD: [4]int{ppc64.AADD, ppc64.AADDCC, ppc64.AADDV, ppc64.AADDVCC},
+ ppc64.AADDC: [4]int{ppc64.AADDC, ppc64.AADDCCC, ppc64.AADDCV, ppc64.AADDCVCC},
+ ppc64.AADDE: [4]int{ppc64.AADDE, ppc64.AADDECC, ppc64.AADDEV, ppc64.AADDEVCC},
+ ppc64.AADDME: [4]int{ppc64.AADDME, ppc64.AADDMECC, ppc64.AADDMEV, ppc64.AADDMEVCC},
+ ppc64.AADDZE: [4]int{ppc64.AADDZE, ppc64.AADDZECC, ppc64.AADDZEV, ppc64.AADDZEVCC},
+ ppc64.AAND: [4]int{ppc64.AAND, ppc64.AANDCC, 0, 0},
+ ppc64.AANDN: [4]int{ppc64.AANDN, ppc64.AANDNCC, 0, 0},
+ ppc64.ACNTLZD: [4]int{ppc64.ACNTLZD, ppc64.ACNTLZDCC, 0, 0},
+ ppc64.ACNTLZW: [4]int{ppc64.ACNTLZW, ppc64.ACNTLZWCC, 0, 0},
+ ppc64.ADIVD: [4]int{ppc64.ADIVD, ppc64.ADIVDCC, ppc64.ADIVDV, ppc64.ADIVDVCC},
+ ppc64.ADIVDU: [4]int{ppc64.ADIVDU, ppc64.ADIVDUCC, ppc64.ADIVDUV, ppc64.ADIVDUVCC},
+ ppc64.ADIVW: [4]int{ppc64.ADIVW, ppc64.ADIVWCC, ppc64.ADIVWV, ppc64.ADIVWVCC},
+ ppc64.ADIVWU: [4]int{ppc64.ADIVWU, ppc64.ADIVWUCC, ppc64.ADIVWUV, ppc64.ADIVWUVCC},
+ ppc64.AEQV: [4]int{ppc64.AEQV, ppc64.AEQVCC, 0, 0},
+ ppc64.AEXTSB: [4]int{ppc64.AEXTSB, ppc64.AEXTSBCC, 0, 0},
+ ppc64.AEXTSH: [4]int{ppc64.AEXTSH, ppc64.AEXTSHCC, 0, 0},
+ ppc64.AEXTSW: [4]int{ppc64.AEXTSW, ppc64.AEXTSWCC, 0, 0},
+ ppc64.AFABS: [4]int{ppc64.AFABS, ppc64.AFABSCC, 0, 0},
+ ppc64.AFADD: [4]int{ppc64.AFADD, ppc64.AFADDCC, 0, 0},
+ ppc64.AFADDS: [4]int{ppc64.AFADDS, ppc64.AFADDSCC, 0, 0},
+ ppc64.AFCFID: [4]int{ppc64.AFCFID, ppc64.AFCFIDCC, 0, 0},
+ ppc64.AFCTID: [4]int{ppc64.AFCTID, ppc64.AFCTIDCC, 0, 0},
+ ppc64.AFCTIDZ: [4]int{ppc64.AFCTIDZ, ppc64.AFCTIDZCC, 0, 0},
+ ppc64.AFCTIW: [4]int{ppc64.AFCTIW, ppc64.AFCTIWCC, 0, 0},
+ ppc64.AFCTIWZ: [4]int{ppc64.AFCTIWZ, ppc64.AFCTIWZCC, 0, 0},
+ ppc64.AFDIV: [4]int{ppc64.AFDIV, ppc64.AFDIVCC, 0, 0},
+ ppc64.AFDIVS: [4]int{ppc64.AFDIVS, ppc64.AFDIVSCC, 0, 0},
+ ppc64.AFMADD: [4]int{ppc64.AFMADD, ppc64.AFMADDCC, 0, 0},
+ ppc64.AFMADDS: [4]int{ppc64.AFMADDS, ppc64.AFMADDSCC, 0, 0},
+ ppc64.AFMOVD: [4]int{ppc64.AFMOVD, ppc64.AFMOVDCC, 0, 0},
+ ppc64.AFMSUB: [4]int{ppc64.AFMSUB, ppc64.AFMSUBCC, 0, 0},
+ ppc64.AFMSUBS: [4]int{ppc64.AFMSUBS, ppc64.AFMSUBSCC, 0, 0},
+ ppc64.AFMUL: [4]int{ppc64.AFMUL, ppc64.AFMULCC, 0, 0},
+ ppc64.AFMULS: [4]int{ppc64.AFMULS, ppc64.AFMULSCC, 0, 0},
+ ppc64.AFNABS: [4]int{ppc64.AFNABS, ppc64.AFNABSCC, 0, 0},
+ ppc64.AFNEG: [4]int{ppc64.AFNEG, ppc64.AFNEGCC, 0, 0},
+ ppc64.AFNMADD: [4]int{ppc64.AFNMADD, ppc64.AFNMADDCC, 0, 0},
+ ppc64.AFNMADDS: [4]int{ppc64.AFNMADDS, ppc64.AFNMADDSCC, 0, 0},
+ ppc64.AFNMSUB: [4]int{ppc64.AFNMSUB, ppc64.AFNMSUBCC, 0, 0},
+ ppc64.AFNMSUBS: [4]int{ppc64.AFNMSUBS, ppc64.AFNMSUBSCC, 0, 0},
+ ppc64.AFRES: [4]int{ppc64.AFRES, ppc64.AFRESCC, 0, 0},
+ ppc64.AFRSP: [4]int{ppc64.AFRSP, ppc64.AFRSPCC, 0, 0},
+ ppc64.AFRSQRTE: [4]int{ppc64.AFRSQRTE, ppc64.AFRSQRTECC, 0, 0},
+ ppc64.AFSEL: [4]int{ppc64.AFSEL, ppc64.AFSELCC, 0, 0},
+ ppc64.AFSQRT: [4]int{ppc64.AFSQRT, ppc64.AFSQRTCC, 0, 0},
+ ppc64.AFSQRTS: [4]int{ppc64.AFSQRTS, ppc64.AFSQRTSCC, 0, 0},
+ ppc64.AFSUB: [4]int{ppc64.AFSUB, ppc64.AFSUBCC, 0, 0},
+ ppc64.AFSUBS: [4]int{ppc64.AFSUBS, ppc64.AFSUBSCC, 0, 0},
+ ppc64.AMTFSB0: [4]int{ppc64.AMTFSB0, ppc64.AMTFSB0CC, 0, 0},
+ ppc64.AMTFSB1: [4]int{ppc64.AMTFSB1, ppc64.AMTFSB1CC, 0, 0},
+ ppc64.AMULHD: [4]int{ppc64.AMULHD, ppc64.AMULHDCC, 0, 0},
+ ppc64.AMULHDU: [4]int{ppc64.AMULHDU, ppc64.AMULHDUCC, 0, 0},
+ ppc64.AMULHW: [4]int{ppc64.AMULHW, ppc64.AMULHWCC, 0, 0},
+ ppc64.AMULHWU: [4]int{ppc64.AMULHWU, ppc64.AMULHWUCC, 0, 0},
+ ppc64.AMULLD: [4]int{ppc64.AMULLD, ppc64.AMULLDCC, ppc64.AMULLDV, ppc64.AMULLDVCC},
+ ppc64.AMULLW: [4]int{ppc64.AMULLW, ppc64.AMULLWCC, ppc64.AMULLWV, ppc64.AMULLWVCC},
+ ppc64.ANAND: [4]int{ppc64.ANAND, ppc64.ANANDCC, 0, 0},
+ ppc64.ANEG: [4]int{ppc64.ANEG, ppc64.ANEGCC, ppc64.ANEGV, ppc64.ANEGVCC},
+ ppc64.ANOR: [4]int{ppc64.ANOR, ppc64.ANORCC, 0, 0},
+ ppc64.AOR: [4]int{ppc64.AOR, ppc64.AORCC, 0, 0},
+ ppc64.AORN: [4]int{ppc64.AORN, ppc64.AORNCC, 0, 0},
+ ppc64.AREM: [4]int{ppc64.AREM, ppc64.AREMCC, ppc64.AREMV, ppc64.AREMVCC},
+ ppc64.AREMD: [4]int{ppc64.AREMD, ppc64.AREMDCC, ppc64.AREMDV, ppc64.AREMDVCC},
+ ppc64.AREMDU: [4]int{ppc64.AREMDU, ppc64.AREMDUCC, ppc64.AREMDUV, ppc64.AREMDUVCC},
+ ppc64.AREMU: [4]int{ppc64.AREMU, ppc64.AREMUCC, ppc64.AREMUV, ppc64.AREMUVCC},
+ ppc64.ARLDC: [4]int{ppc64.ARLDC, ppc64.ARLDCCC, 0, 0},
+ ppc64.ARLDCL: [4]int{ppc64.ARLDCL, ppc64.ARLDCLCC, 0, 0},
+ ppc64.ARLDCR: [4]int{ppc64.ARLDCR, ppc64.ARLDCRCC, 0, 0},
+ ppc64.ARLDMI: [4]int{ppc64.ARLDMI, ppc64.ARLDMICC, 0, 0},
+ ppc64.ARLWMI: [4]int{ppc64.ARLWMI, ppc64.ARLWMICC, 0, 0},
+ ppc64.ARLWNM: [4]int{ppc64.ARLWNM, ppc64.ARLWNMCC, 0, 0},
+ ppc64.ASLD: [4]int{ppc64.ASLD, ppc64.ASLDCC, 0, 0},
+ ppc64.ASLW: [4]int{ppc64.ASLW, ppc64.ASLWCC, 0, 0},
+ ppc64.ASRAD: [4]int{ppc64.ASRAD, ppc64.ASRADCC, 0, 0},
+ ppc64.ASRAW: [4]int{ppc64.ASRAW, ppc64.ASRAWCC, 0, 0},
+ ppc64.ASRD: [4]int{ppc64.ASRD, ppc64.ASRDCC, 0, 0},
+ ppc64.ASRW: [4]int{ppc64.ASRW, ppc64.ASRWCC, 0, 0},
+ ppc64.ASUB: [4]int{ppc64.ASUB, ppc64.ASUBCC, ppc64.ASUBV, ppc64.ASUBVCC},
+ ppc64.ASUBC: [4]int{ppc64.ASUBC, ppc64.ASUBCCC, ppc64.ASUBCV, ppc64.ASUBCVCC},
+ ppc64.ASUBE: [4]int{ppc64.ASUBE, ppc64.ASUBECC, ppc64.ASUBEV, ppc64.ASUBEVCC},
+ ppc64.ASUBME: [4]int{ppc64.ASUBME, ppc64.ASUBMECC, ppc64.ASUBMEV, ppc64.ASUBMEVCC},
+ ppc64.ASUBZE: [4]int{ppc64.ASUBZE, ppc64.ASUBZECC, ppc64.ASUBZEV, ppc64.ASUBZEVCC},
+ ppc64.AXOR: [4]int{ppc64.AXOR, ppc64.AXORCC, 0, 0},
+}
+
+var initvariants_initialized int
+
+func initvariants() {
+ var i int
+ var j int
+
+ if initvariants_initialized != 0 {
+ return
+ }
+ initvariants_initialized = 1
+
+ for i = 0; i < len(varianttable); i++ {
+ if varianttable[i][0] == 0 {
+ // Instruction has no variants
+ varianttable[i][0] = i
+
+ continue
+ }
+
+ // Copy base form to other variants
+ if varianttable[i][0] == i {
+ for j = 0; j < len(varianttable[i]); j++ {
+ varianttable[varianttable[i][j]] = varianttable[i]
+ }
+ }
+ }
+}
+
+// as2variant returns the variant (V_*) flags of instruction as.
+func as2variant(as int) int {
+ var i int
+ initvariants()
+ for i = 0; i < len(varianttable[as]); i++ {
+ if varianttable[as][i] == as {
+ return i
+ }
+ }
+ gc.Fatal("as2variant: instruction %v is not a variant of itself", ppc64.Aconv(as))
+ return 0
+}
+
+// variant2as returns the instruction as with the given variant (V_*) flags.
+// If no such variant exists, this returns 0.
+func variant2as(as int, flags int) int {
+ initvariants()
+ return varianttable[as][flags]
+}
--- /dev/null
+// 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 main
+
+import "cmd/internal/obj/ppc64"
+import "cmd/internal/gc"
+
+const (
+ NREGVAR = 64
+)
+
+var regname = []string{
+ ".R0",
+ ".R1",
+ ".R2",
+ ".R3",
+ ".R4",
+ ".R5",
+ ".R6",
+ ".R7",
+ ".R8",
+ ".R9",
+ ".R10",
+ ".R11",
+ ".R12",
+ ".R13",
+ ".R14",
+ ".R15",
+ ".R16",
+ ".R17",
+ ".R18",
+ ".R19",
+ ".R20",
+ ".R21",
+ ".R22",
+ ".R23",
+ ".R24",
+ ".R25",
+ ".R26",
+ ".R27",
+ ".R28",
+ ".R29",
+ ".R30",
+ ".R31",
+ ".F0",
+ ".F1",
+ ".F2",
+ ".F3",
+ ".F4",
+ ".F5",
+ ".F6",
+ ".F7",
+ ".F8",
+ ".F9",
+ ".F10",
+ ".F11",
+ ".F12",
+ ".F13",
+ ".F14",
+ ".F15",
+ ".F16",
+ ".F17",
+ ".F18",
+ ".F19",
+ ".F20",
+ ".F21",
+ ".F22",
+ ".F23",
+ ".F24",
+ ".F25",
+ ".F26",
+ ".F27",
+ ".F28",
+ ".F29",
+ ".F30",
+ ".F31",
+}
+
+func regnames(n *int) []string {
+ *n = NREGVAR
+ return regname
+}
+
+func excludedregs() uint64 {
+ var regbits uint64
+
+ // Exclude registers with fixed functions
+ regbits = 1<<0 | RtoB(ppc64.REGSP) | RtoB(ppc64.REGG) | RtoB(ppc64.REGTLS)
+
+ // Also exclude floating point registers with fixed constants
+ regbits |= RtoB(ppc64.REG_F27) | RtoB(ppc64.REG_F28) | RtoB(ppc64.REG_F29) | RtoB(ppc64.REG_F30) | RtoB(ppc64.REG_F31)
+
+ return regbits
+}
+
+func doregbits(r int) uint64 {
+ return 0
+}
+
+/*
+ * track register variables including external registers:
+ * bit reg
+ * 0 R0
+ * 1 R1
+ * ... ...
+ * 31 R31
+ * 32+0 F0
+ * 32+1 F1
+ * ... ...
+ * 32+31 F31
+ */
+func RtoB(r int) uint64 {
+ if r > ppc64.REG_R0 && r <= ppc64.REG_R31 {
+ return 1 << uint(r-ppc64.REG_R0)
+ }
+ if r >= ppc64.REG_F0 && r <= ppc64.REG_F31 {
+ return 1 << uint(32+r-ppc64.REG_F0)
+ }
+ return 0
+}
+
+func BtoR(b uint64) int {
+ b &= 0xffffffff
+ if b == 0 {
+ return 0
+ }
+ return gc.Bitno(b) + ppc64.REG_R0
+}
+
+func BtoF(b uint64) int {
+ b >>= 32
+ if b == 0 {
+ return 0
+ }
+ return gc.Bitno(b) + ppc64.REG_F0
+}
--- /dev/null
+// Copyright 2015 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 main
+
+func bool2int(b bool) int {
+ if b {
+ return 1
+ }
+ return 0
+}