cmd/compile: change Oconv to take an Op parameter

Eliminates type conversions in a bunch of Oconv(int(n.Op), ...) calls.

Notably, this identified a misuse of Oconv in amd64/gsubr.go to try to
print an assembly instruction op instead of a compiler node op.

Change-Id: I93b5aa49fe14a5eaf868b05426d3b8cd8ab52bc5
Reviewed-on: https://go-review.googlesource.com/20298
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>

diff --git a/src/cmd/compile/internal/amd64/gsubr.go b/src/cmd/compile/internal/amd64/gsubr.go
index b2fa11388be7ef74a8140ec63c139fc90b47a7ea..d3050766c5f19fa822f9eb4e99488f97f958a2f7 100644 (file)
--- a/src/cmd/compile/internal/amd64/gsubr.go
+++ b/src/cmd/compile/internal/amd64/gsubr.go
@@ -722,7 +722,7 @@ func optoas(op gc.Op, t *gc.Type) int {
        a := obj.AXXX
        switch uint32(op)<<16 | uint32(gc.Simtype[t.Etype]) {
        default:
-               gc.Fatalf("optoas: no entry %v-%v", gc.Oconv(int(op), 0), t)
+               gc.Fatalf("optoas: no entry %v-%v", gc.Oconv(op, 0), t)
 
        case OADDR_ | gc.TPTR32:
                a = x86.ALEAL
@@ -1264,7 +1264,7 @@ func jmptoset(jmp int) int {
        case x86.AJPS:
                return x86.ASETPS
        }
-       gc.Fatalf("jmptoset: no entry for %v", gc.Oconv(jmp, 0))
+       gc.Fatalf("jmptoset: no entry for %v", jmp)
        panic("unreachable")
 }
 

diff --git a/src/cmd/compile/internal/arm/cgen64.go b/src/cmd/compile/internal/arm/cgen64.go
index 9cda56106941af65410cc9cae8fd61e15ad4b55c..b9bd53ea9dac1bb300b02cc8498a87168125b764 100644 (file)
--- a/src/cmd/compile/internal/arm/cgen64.go
+++ b/src/cmd/compile/internal/arm/cgen64.go
@@ -19,7 +19,7 @@ func cgen64(n *gc.Node, res *gc.Node) {
        if res.Op != gc.OINDREG && res.Op != gc.ONAME {
                gc.Dump("n", n)
                gc.Dump("res", res)
-               gc.Fatalf("cgen64 %v of %v", gc.Oconv(int(n.Op), 0), gc.Oconv(int(res.Op), 0))
+               gc.Fatalf("cgen64 %v of %v", gc.Oconv(n.Op, 0), gc.Oconv(res.Op, 0))
        }
 
        l := n.Left
@@ -35,7 +35,7 @@ func cgen64(n *gc.Node, res *gc.Node) {
        split64(l, &lo1, &hi1)
        switch n.Op {
        default:
-               gc.Fatalf("cgen64 %v", gc.Oconv(int(n.Op), 0))
+               gc.Fatalf("cgen64 %v", gc.Oconv(n.Op, 0))
 
        case gc.OMINUS:
                var lo2 gc.Node
@@ -793,7 +793,7 @@ func cmp64(nl *gc.Node, nr *gc.Node, op gc.Op, likely int, to *obj.Prog) {
        var br *obj.Prog
        switch op {
        default:
-               gc.Fatalf("cmp64 %v %v", gc.Oconv(int(op), 0), t)
+               gc.Fatalf("cmp64 %v %v", gc.Oconv(op, 0), t)
 
                // cmp hi
        // bne L

diff --git a/src/cmd/compile/internal/arm/gsubr.go b/src/cmd/compile/internal/arm/gsubr.go
index 108d78ac0440e178fc514ebdacb8bc3ddef23d21..97ca0cd93c707336a1a2022945a1f80ba8b15e17 100644 (file)
--- a/src/cmd/compile/internal/arm/gsubr.go
+++ b/src/cmd/compile/internal/arm/gsubr.go
@@ -719,7 +719,7 @@ func raddr(n *gc.Node, p *obj.Prog) {
        gc.Naddr(&a, n)
        if a.Type != obj.TYPE_REG {
                if n != nil {
-                       gc.Fatalf("bad in raddr: %v", gc.Oconv(int(n.Op), 0))
+                       gc.Fatalf("bad in raddr: %v", gc.Oconv(n.Op, 0))
                } else {
                        gc.Fatalf("bad in raddr: <null>")
                }
@@ -790,7 +790,7 @@ func optoas(op gc.Op, t *gc.Type) int {
        a := obj.AXXX
        switch uint32(op)<<16 | uint32(gc.Simtype[t.Etype]) {
        default:
-               gc.Fatalf("optoas: no entry %v-%v etype %v simtype %v", gc.Oconv(int(op), 0), t, gc.Types[t.Etype], gc.Types[gc.Simtype[t.Etype]])
+               gc.Fatalf("optoas: no entry %v-%v etype %v simtype %v", gc.Oconv(op, 0), t, gc.Types[t.Etype], gc.Types[gc.Simtype[t.Etype]])
 
                /*      case CASE(OADDR, TPTR32):
                                a = ALEAL;

diff --git a/src/cmd/compile/internal/arm64/gsubr.go b/src/cmd/compile/internal/arm64/gsubr.go
index 97f73f591e84d10fe39630985e40b9091d20e4e8..86d6530670e10ebc78434aa10e68202409a7c59b 100644 (file)
--- a/src/cmd/compile/internal/arm64/gsubr.go
+++ b/src/cmd/compile/internal/arm64/gsubr.go
@@ -567,7 +567,7 @@ func raddr(n *gc.Node, p *obj.Prog) {
        gc.Naddr(&a, n)
        if a.Type != obj.TYPE_REG {
                if n != nil {
-                       gc.Fatalf("bad in raddr: %v", gc.Oconv(int(n.Op), 0))
+                       gc.Fatalf("bad in raddr: %v", gc.Oconv(n.Op, 0))
                } else {
                        gc.Fatalf("bad in raddr: <null>")
                }
@@ -579,7 +579,7 @@ func raddr(n *gc.Node, p *obj.Prog) {
 
 func gcmp(as int, lhs *gc.Node, rhs *gc.Node) *obj.Prog {
        if lhs.Op != gc.OREGISTER {
-               gc.Fatalf("bad operands to gcmp: %v %v", gc.Oconv(int(lhs.Op), 0), gc.Oconv(int(rhs.Op), 0))
+               gc.Fatalf("bad operands to gcmp: %v %v", gc.Oconv(lhs.Op, 0), gc.Oconv(rhs.Op, 0))
        }
 
        p := rawgins(as, rhs, nil)
@@ -622,7 +622,7 @@ func optoas(op gc.Op, t *gc.Type) int {
        a := int(obj.AXXX)
        switch uint32(op)<<16 | uint32(gc.Simtype[t.Etype]) {
        default:
-               gc.Fatalf("optoas: no entry for op=%v type=%v", gc.Oconv(int(op), 0), t)
+               gc.Fatalf("optoas: no entry for op=%v type=%v", gc.Oconv(op, 0), t)
 
        case OEQ_ | gc.TBOOL,
                OEQ_ | gc.TINT8,

diff --git a/src/cmd/compile/internal/gc/bexport.go b/src/cmd/compile/internal/gc/bexport.go
index 4cbcadb96144054611418f12de9db3869778d2df..830b3be7544effe363818c9a39b434393a2da79d 100644 (file)
--- a/src/cmd/compile/internal/gc/bexport.go
+++ b/src/cmd/compile/internal/gc/bexport.go
@@ -221,7 +221,7 @@ func Export(out *obj.Biobuf, trace bool) int {
                                types = append(types, t)
 
                        default:
-                               Fatalf("exporter: unexpected export symbol: %v %v", Oconv(int(n.Op), 0), sym)
+                               Fatalf("exporter: unexpected export symbol: %v %v", Oconv(n.Op, 0), sym)
                        }
                }
        }

diff --git a/src/cmd/compile/internal/gc/cgen.go b/src/cmd/compile/internal/gc/cgen.go
index 43bb4c17c5b4f800194137877fccb09fea0eccab..389764c8af138f679c14fff122a4cb09aa1b8092 100644 (file)
--- a/src/cmd/compile/internal/gc/cgen.go
+++ b/src/cmd/compile/internal/gc/cgen.go
@@ -1792,7 +1792,7 @@ func bgenx(n, res *Node, wantTrue bool, likely int, to *obj.Prog) {
        }
 
        if n.Type.Etype != TBOOL {
-               Fatalf("bgen: bad type %v for %v", n.Type, Oconv(int(n.Op), 0))
+               Fatalf("bgen: bad type %v for %v", n.Type, Oconv(n.Op, 0))
        }
 
        for n.Op == OCONVNOP {
@@ -2439,12 +2439,12 @@ func Ginscall(f *Node, proc int) {
 func cgen_callinter(n *Node, res *Node, proc int) {
        i := n.Left
        if i.Op != ODOTINTER {
-               Fatalf("cgen_callinter: not ODOTINTER %v", Oconv(int(i.Op), 0))
+               Fatalf("cgen_callinter: not ODOTINTER %v", Oconv(i.Op, 0))
        }
 
        f := i.Right // field
        if f.Op != ONAME {
-               Fatalf("cgen_callinter: not ONAME %v", Oconv(int(f.Op), 0))
+               Fatalf("cgen_callinter: not ONAME %v", Oconv(f.Op, 0))
        }
 
        i = i.Left // interface

diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index b825fa76525ca8b5d84b348941932ef94b054196..7cd25c720c521dee3aa6a9c086b388139982befb 100644 (file)
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -648,7 +648,7 @@ func evconst(n *Node) {
                switch uint32(n.Op)<<16 | uint32(v.Ctype()) {
                default:
                        if n.Diag == 0 {
-                               Yyerror("illegal constant expression %v %v", Oconv(int(n.Op), 0), nl.Type)
+                               Yyerror("illegal constant expression %v %v", Oconv(n.Op, 0), nl.Type)
                                n.Diag = 1
                        }
                        return
@@ -1135,7 +1135,7 @@ setfalse:
 
 illegal:
        if n.Diag == 0 {
-               Yyerror("illegal constant expression: %v %v %v", nl.Type, Oconv(int(n.Op), 0), nr.Type)
+               Yyerror("illegal constant expression: %v %v %v", nl.Type, Oconv(n.Op, 0), nr.Type)
                n.Diag = 1
        }
 }

diff --git a/src/cmd/compile/internal/gc/cplx.go b/src/cmd/compile/internal/gc/cplx.go
index b692456cfdb9ec728c7955595b89a09d10fe1aaa..4d89fb71a0aad727c6c92c2a08a3ffe9a874685a 100644 (file)
--- a/src/cmd/compile/internal/gc/cplx.go
+++ b/src/cmd/compile/internal/gc/cplx.go
@@ -398,7 +398,7 @@ func Complexgen(n *Node, res *Node) {
        switch n.Op {
        default:
                Dump("complexgen: unknown op", n)
-               Fatalf("complexgen: unknown op %v", Oconv(int(n.Op), 0))
+               Fatalf("complexgen: unknown op %v", Oconv(n.Op, 0))
 
        case ODOT,
                ODOTPTR,
@@ -457,7 +457,7 @@ func Complexgen(n *Node, res *Node) {
 
        switch n.Op {
        default:
-               Fatalf("complexgen: unknown op %v", Oconv(int(n.Op), 0))
+               Fatalf("complexgen: unknown op %v", Oconv(n.Op, 0))
 
        case OCONV:
                Complexmove(nl, res)

diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 94c4bebec107635fd76668369a26ab6a67675163..5681ecef526499332207a9b9cabf1d12e21df825 100644 (file)
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -564,7 +564,7 @@ func funchdr(n *Node) {
 
 func funcargs(nt *Node) {
        if nt.Op != OTFUNC {
-               Fatalf("funcargs %v", Oconv(int(nt.Op), 0))
+               Fatalf("funcargs %v", Oconv(nt.Op, 0))
        }
 
        // re-start the variable generation number
@@ -578,7 +578,7 @@ func funcargs(nt *Node) {
        if nt.Left != nil {
                n := nt.Left
                if n.Op != ODCLFIELD {
-                       Fatalf("funcargs receiver %v", Oconv(int(n.Op), 0))
+                       Fatalf("funcargs receiver %v", Oconv(n.Op, 0))
                }
                if n.Left != nil {
                        n.Left.Op = ONAME
@@ -595,7 +595,7 @@ func funcargs(nt *Node) {
        for it := nodeSeqIterate(nt.List); !it.Done(); it.Next() {
                n = it.N()
                if n.Op != ODCLFIELD {
-                       Fatalf("funcargs in %v", Oconv(int(n.Op), 0))
+                       Fatalf("funcargs in %v", Oconv(n.Op, 0))
                }
                if n.Left != nil {
                        n.Left.Op = ONAME
@@ -616,7 +616,7 @@ func funcargs(nt *Node) {
                n = it.N()
 
                if n.Op != ODCLFIELD {
-                       Fatalf("funcargs out %v", Oconv(int(n.Op), 0))
+                       Fatalf("funcargs out %v", Oconv(n.Op, 0))
                }
 
                if n.Left == nil {

diff --git a/src/cmd/compile/internal/gc/esc.go b/src/cmd/compile/internal/gc/esc.go
index b6e47e7112aca1b6ad972ed8ba394930bd84e7c2..7054249f940a53da3fc6f6172ac2b6f4b31273bd 100644 (file)
--- a/src/cmd/compile/internal/gc/esc.go
+++ b/src/cmd/compile/internal/gc/esc.go
@@ -943,8 +943,8 @@ func escassign(e *EscState, dst *Node, src *Node) {
        if Debug['m'] > 1 {
                fmt.Printf("%v:[%d] %v escassign: %v(%v)[%v] = %v(%v)[%v]\n",
                        linestr(lineno), e.loopdepth, funcSym(Curfn),
-                       Nconv(dst, obj.FmtShort), Jconv(dst, obj.FmtShort), Oconv(int(dst.Op), 0),
-                       Nconv(src, obj.FmtShort), Jconv(src, obj.FmtShort), Oconv(int(src.Op), 0))
+                       Nconv(dst, obj.FmtShort), Jconv(dst, obj.FmtShort), Oconv(dst.Op, 0),
+                       Nconv(src, obj.FmtShort), Jconv(src, obj.FmtShort), Oconv(src.Op, 0))
        }
 
        setlineno(dst)
@@ -1639,7 +1639,7 @@ func escwalkBody(e *EscState, level Level, dst *Node, src *Node, extraloopdepth
 
        if Debug['m'] > 1 {
                fmt.Printf("escwalk: level:%d depth:%d %.*s op=%v %v(%v) scope:%v[%d] extraloopdepth=%v\n",
-                       level, e.pdepth, e.pdepth, "\t\t\t\t\t\t\t\t\t\t", Oconv(int(src.Op), 0), Nconv(src, obj.FmtShort), Jconv(src, obj.FmtShort), e.curfnSym(src), srcE.Escloopdepth, extraloopdepth)
+                       level, e.pdepth, e.pdepth, "\t\t\t\t\t\t\t\t\t\t", Oconv(src.Op, 0), Nconv(src, obj.FmtShort), Jconv(src, obj.FmtShort), e.curfnSym(src), srcE.Escloopdepth, extraloopdepth)
        }
 
        e.pdepth++

diff --git a/src/cmd/compile/internal/gc/export.go b/src/cmd/compile/internal/gc/export.go
index b20f8264fc4b14385d36b46d2a9aca2acb183cb5..b62c13e28120a94faac32bb9bd9e65c4de9b0c9e 100644 (file)
--- a/src/cmd/compile/internal/gc/export.go
+++ b/src/cmd/compile/internal/gc/export.go
@@ -338,7 +338,7 @@ func dumpsym(s *Sym) {
 
        switch s.Def.Op {
        default:
-               Yyerror("unexpected export symbol: %v %v", Oconv(int(s.Def.Op), 0), s)
+               Yyerror("unexpected export symbol: %v %v", Oconv(s.Def.Op, 0), s)
 
        case OLITERAL:
                dumpexportconst(s)

diff --git a/src/cmd/compile/internal/gc/fmt.go b/src/cmd/compile/internal/gc/fmt.go
index ef2719514870689bfb946079bf62a4027fc64c8a..fb18a39624f7c7a54079ca1350abd5901b469ce2 100644 (file)
--- a/src/cmd/compile/internal/gc/fmt.go
+++ b/src/cmd/compile/internal/gc/fmt.go
@@ -174,14 +174,14 @@ var goopnames = []string{
 }
 
 // Fmt "%O":  Node opcodes
-func Oconv(o int, flag int) string {
+func Oconv(o Op, flag int) string {
        if (flag&obj.FmtSharp != 0) || fmtmode != FDbg {
-               if o >= 0 && o < len(goopnames) && goopnames[o] != "" {
+               if o >= 0 && int(o) < len(goopnames) && goopnames[o] != "" {
                        return goopnames[o]
                }
        }
 
-       if o >= 0 && o < len(opnames) && opnames[o] != "" {
+       if o >= 0 && int(o) < len(opnames) && opnames[o] != "" {
                return opnames[o]
        }
 
@@ -859,7 +859,7 @@ func stmtfmt(n *Node) string {
                        break
                }
 
-               f += fmt.Sprintf("%v %v= %v", n.Left, Oconv(int(n.Etype), obj.FmtSharp), n.Right)
+               f += fmt.Sprintf("%v %v= %v", n.Left, Oconv(Op(n.Etype), obj.FmtSharp), n.Right)
 
        case OAS2:
                if n.Colas && !complexinit {
@@ -933,11 +933,11 @@ func stmtfmt(n *Node) string {
 
        case OSELECT, OSWITCH:
                if fmtmode == FErr {
-                       f += fmt.Sprintf("%v statement", Oconv(int(n.Op), 0))
+                       f += fmt.Sprintf("%v statement", Oconv(n.Op, 0))
                        break
                }
 
-               f += Oconv(int(n.Op), obj.FmtSharp)
+               f += Oconv(n.Op, obj.FmtSharp)
                if simpleinit {
                        f += fmt.Sprintf(" %v;", nodeSeqFirst(n.Ninit))
                }
@@ -960,9 +960,9 @@ func stmtfmt(n *Node) string {
                OFALL,
                OXFALL:
                if n.Left != nil {
-                       f += fmt.Sprintf("%v %v", Oconv(int(n.Op), obj.FmtSharp), n.Left)
+                       f += fmt.Sprintf("%v %v", Oconv(n.Op, obj.FmtSharp), n.Left)
                } else {
-                       f += Oconv(int(n.Op), obj.FmtSharp)
+                       f += Oconv(n.Op, obj.FmtSharp)
                }
 
        case OEMPTY:
@@ -1341,7 +1341,7 @@ func exprfmt(n *Node, prec int) string {
                return f
 
        case OCOPY, OCOMPLEX:
-               return fmt.Sprintf("%v(%v, %v)", Oconv(int(n.Op), obj.FmtSharp), n.Left, n.Right)
+               return fmt.Sprintf("%v(%v, %v)", Oconv(n.Op, obj.FmtSharp), n.Left, n.Right)
 
        case OCONV,
                OCONVIFACE,
@@ -1373,12 +1373,12 @@ func exprfmt(n *Node, prec int) string {
                OPRINT,
                OPRINTN:
                if n.Left != nil {
-                       return fmt.Sprintf("%v(%v)", Oconv(int(n.Op), obj.FmtSharp), n.Left)
+                       return fmt.Sprintf("%v(%v)", Oconv(n.Op, obj.FmtSharp), n.Left)
                }
                if n.Isddd {
-                       return fmt.Sprintf("%v(%v...)", Oconv(int(n.Op), obj.FmtSharp), Hconv(n.List, obj.FmtComma))
+                       return fmt.Sprintf("%v(%v...)", Oconv(n.Op, obj.FmtSharp), Hconv(n.List, obj.FmtComma))
                }
-               return fmt.Sprintf("%v(%v)", Oconv(int(n.Op), obj.FmtSharp), Hconv(n.List, obj.FmtComma))
+               return fmt.Sprintf("%v(%v)", Oconv(n.Op, obj.FmtSharp), Hconv(n.List, obj.FmtComma))
 
        case OCALL, OCALLFUNC, OCALLINTER, OCALLMETH, OGETG:
                var f string
@@ -1412,9 +1412,9 @@ func exprfmt(n *Node, prec int) string {
                ORECV:
                var f string
                if n.Left.Op == n.Op {
-                       f += fmt.Sprintf("%v ", Oconv(int(n.Op), obj.FmtSharp))
+                       f += fmt.Sprintf("%v ", Oconv(n.Op, obj.FmtSharp))
                } else {
-                       f += Oconv(int(n.Op), obj.FmtSharp)
+                       f += Oconv(n.Op, obj.FmtSharp)
                }
                f += exprfmt(n.Left, nprec+1)
                return f
@@ -1443,7 +1443,7 @@ func exprfmt(n *Node, prec int) string {
                var f string
                f += exprfmt(n.Left, nprec)
 
-               f += fmt.Sprintf(" %v ", Oconv(int(n.Op), obj.FmtSharp))
+               f += fmt.Sprintf(" %v ", Oconv(n.Op, obj.FmtSharp))
                f += exprfmt(n.Right, nprec+1)
                return f
 
@@ -1464,12 +1464,12 @@ func exprfmt(n *Node, prec int) string {
                var f string
                f += exprfmt(n.Left, nprec)
                // TODO(marvin): Fix Node.EType type union.
-               f += fmt.Sprintf(" %v ", Oconv(int(n.Etype), obj.FmtSharp))
+               f += fmt.Sprintf(" %v ", Oconv(Op(n.Etype), obj.FmtSharp))
                f += exprfmt(n.Right, nprec+1)
                return f
        }
 
-       return fmt.Sprintf("<node %v>", Oconv(int(n.Op), 0))
+       return fmt.Sprintf("<node %v>", Oconv(n.Op, 0))
 }
 
 func nodefmt(n *Node, flag int) string {
@@ -1524,40 +1524,40 @@ func nodedump(n *Node, flag int) string {
                }
 
                if nodeSeqLen(n.Ninit) != 0 {
-                       fmt.Fprintf(&buf, "%v-init%v", Oconv(int(n.Op), 0), n.Ninit)
+                       fmt.Fprintf(&buf, "%v-init%v", Oconv(n.Op, 0), n.Ninit)
                        indent(&buf)
                }
        }
 
        switch n.Op {
        default:
-               fmt.Fprintf(&buf, "%v%v", Oconv(int(n.Op), 0), Jconv(n, 0))
+               fmt.Fprintf(&buf, "%v%v", Oconv(n.Op, 0), Jconv(n, 0))
 
        case OREGISTER, OINDREG:
-               fmt.Fprintf(&buf, "%v-%v%v", Oconv(int(n.Op), 0), obj.Rconv(int(n.Reg)), Jconv(n, 0))
+               fmt.Fprintf(&buf, "%v-%v%v", Oconv(n.Op, 0), obj.Rconv(int(n.Reg)), Jconv(n, 0))
 
        case OLITERAL:
-               fmt.Fprintf(&buf, "%v-%v%v", Oconv(int(n.Op), 0), Vconv(n.Val(), 0), Jconv(n, 0))
+               fmt.Fprintf(&buf, "%v-%v%v", Oconv(n.Op, 0), Vconv(n.Val(), 0), Jconv(n, 0))
 
        case ONAME, ONONAME:
                if n.Sym != nil {
-                       fmt.Fprintf(&buf, "%v-%v%v", Oconv(int(n.Op), 0), n.Sym, Jconv(n, 0))
+                       fmt.Fprintf(&buf, "%v-%v%v", Oconv(n.Op, 0), n.Sym, Jconv(n, 0))
                } else {
-                       fmt.Fprintf(&buf, "%v%v", Oconv(int(n.Op), 0), Jconv(n, 0))
+                       fmt.Fprintf(&buf, "%v%v", Oconv(n.Op, 0), Jconv(n, 0))
                }
                if recur && n.Type == nil && n.Name != nil && n.Name.Param != nil && n.Name.Param.Ntype != nil {
                        indent(&buf)
-                       fmt.Fprintf(&buf, "%v-ntype%v", Oconv(int(n.Op), 0), n.Name.Param.Ntype)
+                       fmt.Fprintf(&buf, "%v-ntype%v", Oconv(n.Op, 0), n.Name.Param.Ntype)
                }
 
        case OASOP:
-               fmt.Fprintf(&buf, "%v-%v%v", Oconv(int(n.Op), 0), Oconv(int(n.Etype), 0), Jconv(n, 0))
+               fmt.Fprintf(&buf, "%v-%v%v", Oconv(n.Op, 0), Oconv(Op(n.Etype), 0), Jconv(n, 0))
 
        case OTYPE:
-               fmt.Fprintf(&buf, "%v %v%v type=%v", Oconv(int(n.Op), 0), n.Sym, Jconv(n, 0), n.Type)
+               fmt.Fprintf(&buf, "%v %v%v type=%v", Oconv(n.Op, 0), n.Sym, Jconv(n, 0), n.Type)
                if recur && n.Type == nil && n.Name.Param.Ntype != nil {
                        indent(&buf)
-                       fmt.Fprintf(&buf, "%v-ntype%v", Oconv(int(n.Op), 0), n.Name.Param.Ntype)
+                       fmt.Fprintf(&buf, "%v-ntype%v", Oconv(n.Op, 0), n.Name.Param.Ntype)
                }
        }
 
@@ -1578,17 +1578,17 @@ func nodedump(n *Node, flag int) string {
                }
                if nodeSeqLen(n.List) != 0 {
                        indent(&buf)
-                       fmt.Fprintf(&buf, "%v-list%v", Oconv(int(n.Op), 0), n.List)
+                       fmt.Fprintf(&buf, "%v-list%v", Oconv(n.Op, 0), n.List)
                }
 
                if nodeSeqLen(n.Rlist) != 0 {
                        indent(&buf)
-                       fmt.Fprintf(&buf, "%v-rlist%v", Oconv(int(n.Op), 0), n.Rlist)
+                       fmt.Fprintf(&buf, "%v-rlist%v", Oconv(n.Op, 0), n.Rlist)
                }
 
                if len(n.Nbody.Slice()) != 0 {
                        indent(&buf)
-                       fmt.Fprintf(&buf, "%v-body%v", Oconv(int(n.Op), 0), n.Nbody)
+                       fmt.Fprintf(&buf, "%v-body%v", Oconv(n.Op, 0), n.Nbody)
                }
        }
 

diff --git a/src/cmd/compile/internal/gc/gen.go b/src/cmd/compile/internal/gc/gen.go
index d0217497d26d370f5651dd4d75cf3d5a3a46211b..0b69f73ce2c6dc51a77c4b2163fa361941ed9e8b 100644 (file)
--- a/src/cmd/compile/internal/gc/gen.go
+++ b/src/cmd/compile/internal/gc/gen.go
@@ -225,7 +225,7 @@ func Genlist(l nodesOrNodeList) {
 func cgen_proc(n *Node, proc int) {
        switch n.Left.Op {
        default:
-               Fatalf("cgen_proc: unknown call %v", Oconv(int(n.Left.Op), 0))
+               Fatalf("cgen_proc: unknown call %v", Oconv(n.Left.Op, 0))
 
        case OCALLMETH:
                cgen_callmeth(n.Left, proc)

diff --git a/src/cmd/compile/internal/gc/gsubr.go b/src/cmd/compile/internal/gc/gsubr.go
index 73f71dd0fbe7ae13297e24e1fc699e5b1f778000..c533bd1cbeeb857d30c07757a5dac84769cb7b40 100644 (file)
--- a/src/cmd/compile/internal/gc/gsubr.go
+++ b/src/cmd/compile/internal/gc/gsubr.go
@@ -322,7 +322,7 @@ func Naddr(a *obj.Addr, n *Node) {
                a := a // copy to let escape into Ctxt.Dconv
                Debug['h'] = 1
                Dump("naddr", n)
-               Fatalf("naddr: bad %v %v", Oconv(int(n.Op), 0), Ctxt.Dconv(a))
+               Fatalf("naddr: bad %v %v", Oconv(n.Op, 0), Ctxt.Dconv(a))
 
        case OREGISTER:
                a.Type = obj.TYPE_REG
@@ -423,7 +423,7 @@ func Naddr(a *obj.Addr, n *Node) {
                if n.Left.Type.Etype != TSTRUCT || n.Left.Type.Type.Sym != n.Right.Sym {
                        Debug['h'] = 1
                        Dump("naddr", n)
-                       Fatalf("naddr: bad %v %v", Oconv(int(n.Op), 0), Ctxt.Dconv(a))
+                       Fatalf("naddr: bad %v %v", Oconv(n.Op, 0), Ctxt.Dconv(a))
                }
                Naddr(a, n.Left)
 
@@ -466,7 +466,7 @@ func Naddr(a *obj.Addr, n *Node) {
                }
                if a.Type != obj.TYPE_MEM {
                        a := a // copy to let escape into Ctxt.Dconv
-                       Fatalf("naddr: OADDR %v (from %v)", Ctxt.Dconv(a), Oconv(int(n.Left.Op), 0))
+                       Fatalf("naddr: OADDR %v (from %v)", Ctxt.Dconv(a), Oconv(n.Left.Op, 0))
                }
                a.Type = obj.TYPE_ADDR
 

diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index da81f2d872a655285d5a17673f3d8c776a84a74d..b9e4b7817af390ac92eb1bb27ba7c71f1117105d 100644 (file)
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -174,7 +174,7 @@ func ordersafeexpr(n *Node, order *Order) *Node {
                return a
        }
 
-       Fatalf("ordersafeexpr %v", Oconv(int(n.Op), 0))
+       Fatalf("ordersafeexpr %v", Oconv(n.Op, 0))
        return nil // not reached
 }
 
@@ -427,7 +427,7 @@ func ordercall(n *Node, order *Order) {
 func ordermapassign(n *Node, order *Order) {
        switch n.Op {
        default:
-               Fatalf("ordermapassign %v", Oconv(int(n.Op), 0))
+               Fatalf("ordermapassign %v", Oconv(n.Op, 0))
 
        case OAS:
                order.out = append(order.out, n)
@@ -486,7 +486,7 @@ func orderstmt(n *Node, order *Order) {
 
        switch n.Op {
        default:
-               Fatalf("orderstmt %v", Oconv(int(n.Op), 0))
+               Fatalf("orderstmt %v", Oconv(n.Op, 0))
 
        case OVARKILL, OVARLIVE:
                order.out = append(order.out, n)
@@ -802,7 +802,7 @@ func orderstmt(n *Node, order *Order) {
                var r *Node
                for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
                        if it.N().Op != OXCASE {
-                               Fatalf("order select case %v", Oconv(int(it.N().Op), 0))
+                               Fatalf("order select case %v", Oconv(it.N().Op, 0))
                        }
                        r = it.N().Left
                        setlineno(it.N())
@@ -815,7 +815,7 @@ func orderstmt(n *Node, order *Order) {
                        if r != nil {
                                switch r.Op {
                                default:
-                                       Yyerror("unknown op in select %v", Oconv(int(r.Op), 0))
+                                       Yyerror("unknown op in select %v", Oconv(r.Op, 0))
                                        Dump("select case", r)
 
                                        // If this is case x := <-ch or case x, y := <-ch, the case has
@@ -957,7 +957,7 @@ func orderstmt(n *Node, order *Order) {
                orderexpr(&n.Left, order, nil)
                for it := nodeSeqIterate(n.List); !it.Done(); it.Next() {
                        if it.N().Op != OXCASE {
-                               Fatalf("order switch case %v", Oconv(int(it.N().Op), 0))
+                               Fatalf("order switch case %v", Oconv(it.N().Op, 0))
                        }
                        orderexprlistinplace(it.N().List, order)
                        orderblockNodes(&it.N().Nbody)

diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index 963d59fcba7ea9b8b3e1a7592aea5b81dc7f4e06..c41d7fe28b10cf60061616e672db94ac4227bc43 100644 (file)
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -90,7 +90,7 @@ func gvardefx(n *Node, as int) {
                Fatalf("gvardef nil")
        }
        if n.Op != ONAME {
-               Yyerror("gvardef %v; %v", Oconv(int(n.Op), obj.FmtSharp), n)
+               Yyerror("gvardef %v; %v", Oconv(n.Op, obj.FmtSharp), n)
                return
        }
 

diff --git a/src/cmd/compile/internal/gc/racewalk.go b/src/cmd/compile/internal/gc/racewalk.go
index 433c0b08db92b0cf8512e5ccab4a46779f00379d..b25f6d3ff0d58fd8abaa433cbb73439242949b98 100644 (file)
--- a/src/cmd/compile/internal/gc/racewalk.go
+++ b/src/cmd/compile/internal/gc/racewalk.go
@@ -135,7 +135,7 @@ func instrumentnode(np **Node, init nodesOrNodeListPtr, wr int, skip int) {
 
        switch n.Op {
        default:
-               Fatalf("instrument: unknown node type %v", Oconv(int(n.Op), 0))
+               Fatalf("instrument: unknown node type %v", Oconv(n.Op, 0))
 
        case OAS, OASWB, OAS2FUNC:
                instrumentnode(&n.Left, init, 1, 0)
@@ -364,13 +364,13 @@ func instrumentnode(np **Node, init nodesOrNodeListPtr, wr int, skip int) {
                OAS2RECV,
                OAS2MAPR,
                OASOP:
-               Yyerror("instrument: %v must be lowered by now", Oconv(int(n.Op), 0))
+               Yyerror("instrument: %v must be lowered by now", Oconv(n.Op, 0))
 
                goto ret
 
                // impossible nodes: only appear in backend.
        case ORROTC, OEXTEND:
-               Yyerror("instrument: %v cannot exist now", Oconv(int(n.Op), 0))
+               Yyerror("instrument: %v cannot exist now", Oconv(n.Op, 0))
                goto ret
 
        case OGETG:

diff --git a/src/cmd/compile/internal/gc/select.go b/src/cmd/compile/internal/gc/select.go
index 1319efb1405a2185da227899e58e6c7030e3209d..7c0afb74a08f5c834fd6541febee6f3132111693 100644 (file)
--- a/src/cmd/compile/internal/gc/select.go
+++ b/src/cmd/compile/internal/gc/select.go
@@ -18,7 +18,7 @@ func typecheckselect(sel *Node) {
                ncase = it.N()
                setlineno(ncase)
                if ncase.Op != OXCASE {
-                       Fatalf("typecheckselect %v", Oconv(int(ncase.Op), 0))
+                       Fatalf("typecheckselect %v", Oconv(ncase.Op, 0))
                }
 
                if nodeSeqLen(ncase.List) == 0 {
@@ -121,7 +121,7 @@ func walkselect(sel *Node) {
                        var ch *Node
                        switch n.Op {
                        default:
-                               Fatalf("select %v", Oconv(int(n.Op), 0))
+                               Fatalf("select %v", Oconv(n.Op, 0))
 
                                // ok already
                        case OSEND:
@@ -218,7 +218,7 @@ func walkselect(sel *Node) {
                setNodeSeq(&r.Ninit, cas.Ninit)
                switch n.Op {
                default:
-                       Fatalf("select %v", Oconv(int(n.Op), 0))
+                       Fatalf("select %v", Oconv(n.Op, 0))
 
                        // if selectnbsend(c, v) { body } else { default body }
                case OSEND:
@@ -284,7 +284,7 @@ func walkselect(sel *Node) {
                } else {
                        switch n.Op {
                        default:
-                               Fatalf("select %v", Oconv(int(n.Op), 0))
+                               Fatalf("select %v", Oconv(n.Op, 0))
 
                                // selectsend(sel *byte, hchan *chan any, elem *any) (selected bool);
                        case OSEND:

diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index df5e969c135a34f2040504b1bc82148074a41ec4..66792e7306362d5a36f4cd6422d7e1245655aff9 100644 (file)
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -2328,7 +2328,7 @@ func (s *state) call(n *Node, k callKind) *ssa.Value {
                // want to set it here.
        case OCALLINTER:
                if fn.Op != ODOTINTER {
-                       Fatalf("OCALLINTER: n.Left not an ODOTINTER: %v", Oconv(int(fn.Op), 0))
+                       Fatalf("OCALLINTER: n.Left not an ODOTINTER: %v", Oconv(fn.Op, 0))
                }
                i := s.expr(fn.Left)
                itab := s.newValue1(ssa.OpITab, Types[TUINTPTR], i)
@@ -2558,7 +2558,7 @@ func (s *state) addr(n *Node, bounded bool) *ssa.Value {
                return s.call(n, callNormal)
 
        default:
-               s.Unimplementedf("unhandled addr %v", Oconv(int(n.Op), 0))
+               s.Unimplementedf("unhandled addr %v", Oconv(n.Op, 0))
                return nil
        }
 }

diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 24ee47bbc43a067695225998b030f867f4034f75..96abb3b13f7a9aa12a27944bcc4f22f1ea0aad79 100644 (file)
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -1376,9 +1376,9 @@ func printframenode(n *Node) {
        }
        switch n.Op {
        case ONAME:
-               fmt.Printf("%v %v G%d %v width=%d\n", Oconv(int(n.Op), 0), n.Sym, n.Name.Vargen, n.Type, w)
+               fmt.Printf("%v %v G%d %v width=%d\n", Oconv(n.Op, 0), n.Sym, n.Name.Vargen, n.Type, w)
        case OTYPE:
-               fmt.Printf("%v %v width=%d\n", Oconv(int(n.Op), 0), n.Type, w)
+               fmt.Printf("%v %v width=%d\n", Oconv(n.Op, 0), n.Type, w)
        }
 }
 
@@ -1459,7 +1459,7 @@ func badtype(op Op, tl *Type, tr *Type) {
        }
 
        s := fmt_
-       Yyerror("illegal types for operand: %v%s", Oconv(int(op), 0), s)
+       Yyerror("illegal types for operand: %v%s", Oconv(op, 0), s)
 }
 
 // iterator to walk a structure declaration
@@ -1601,7 +1601,7 @@ func Brcom(op Op) Op {
        case OGE:
                return OLT
        }
-       Fatalf("brcom: no com for %v\n", Oconv(int(op), 0))
+       Fatalf("brcom: no com for %v\n", Oconv(op, 0))
        return op
 }
 
@@ -1622,7 +1622,7 @@ func Brrev(op Op) Op {
        case OGE:
                return OLE
        }
-       Fatalf("brrev: no rev for %v\n", Oconv(int(op), 0))
+       Fatalf("brrev: no rev for %v\n", Oconv(op, 0))
        return op
 }
 

diff --git a/src/cmd/compile/internal/gc/swt.go b/src/cmd/compile/internal/gc/swt.go
index 9870614f72d7af7ebabce9f573ac81359a089a2c..137be94161f45f20b665b0c48a6bf9185acf4c79 100644 (file)
--- a/src/cmd/compile/internal/gc/swt.go
+++ b/src/cmd/compile/internal/gc/swt.go
@@ -349,7 +349,7 @@ func casebody(sw *Node, typeswvar *Node) {
                n := it.N()
                setlineno(n)
                if n.Op != OXCASE {
-                       Fatalf("casebody %v", Oconv(int(n.Op), 0))
+                       Fatalf("casebody %v", Oconv(n.Op, 0))
                }
                n.Op = OCASE
                needvar := nodeSeqLen(n.List) != 1 || nodeSeqFirst(n.List).Op == OLITERAL

diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index ea613220e2e7e5b8622655f282b11a85cbc04cb4..e5d5a5986cc944c6a18485071fabc0eb66bb1cb2 100644 (file)
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -273,7 +273,7 @@ OpSwitch:
        default:
                Dump("typecheck", n)
 
-               Fatalf("typecheck %v", Oconv(int(n.Op), 0))
+               Fatalf("typecheck %v", Oconv(n.Op, 0))
 
        // names
        case OLITERAL:
@@ -592,7 +592,7 @@ OpSwitch:
                                aop = assignop(l.Type, r.Type, nil)
                                if aop != 0 {
                                        if Isinter(r.Type) && !Isinter(l.Type) && algtype1(l.Type, nil) == ANOEQ {
-                                               Yyerror("invalid operation: %v (operator %v not defined on %s)", n, Oconv(int(op), 0), typekind(l.Type))
+                                               Yyerror("invalid operation: %v (operator %v not defined on %s)", n, Oconv(op, 0), typekind(l.Type))
                                                n.Type = nil
                                                return
                                        }
@@ -614,7 +614,7 @@ OpSwitch:
                                aop = assignop(r.Type, l.Type, nil)
                                if aop != 0 {
                                        if Isinter(l.Type) && !Isinter(r.Type) && algtype1(r.Type, nil) == ANOEQ {
-                                               Yyerror("invalid operation: %v (operator %v not defined on %s)", n, Oconv(int(op), 0), typekind(r.Type))
+                                               Yyerror("invalid operation: %v (operator %v not defined on %s)", n, Oconv(op, 0), typekind(r.Type))
                                                n.Type = nil
                                                return
                                        }
@@ -645,7 +645,7 @@ OpSwitch:
                }
 
                if !okfor[op][et] {
-                       Yyerror("invalid operation: %v (operator %v not defined on %s)", n, Oconv(int(op), 0), typekind(t))
+                       Yyerror("invalid operation: %v (operator %v not defined on %s)", n, Oconv(op, 0), typekind(t))
                        n.Type = nil
                        return
                }
@@ -753,7 +753,7 @@ OpSwitch:
                        return
                }
                if !okfor[n.Op][t.Etype] {
-                       Yyerror("invalid operation: %v %v", Oconv(int(n.Op), 0), t)
+                       Yyerror("invalid operation: %v %v", Oconv(n.Op, 0), t)
                        n.Type = nil
                        return
                }
@@ -1369,7 +1369,7 @@ OpSwitch:
 
        case OCAP, OLEN, OREAL, OIMAG:
                ok |= Erv
-               if !onearg(n, "%v", Oconv(int(n.Op), 0)) {
+               if !onearg(n, "%v", Oconv(n.Op, 0)) {
                        n.Type = nil
                        return
                }
@@ -1438,7 +1438,7 @@ OpSwitch:
                break OpSwitch
 
        badcall1:
-               Yyerror("invalid argument %v for %v", Nconv(n.Left, obj.FmtLong), Oconv(int(n.Op), 0))
+               Yyerror("invalid argument %v for %v", Nconv(n.Left, obj.FmtLong), Oconv(n.Op, 0))
                n.Type = nil
                return
 
@@ -1519,7 +1519,7 @@ OpSwitch:
                break OpSwitch
 
        case OCLOSE:
-               if !onearg(n, "%v", Oconv(int(n.Op), 0)) {
+               if !onearg(n, "%v", Oconv(n.Op, 0)) {
                        n.Type = nil
                        return
                }
@@ -2356,19 +2356,19 @@ func twoarg(n *Node) bool {
                return true
        }
        if nodeSeqLen(n.List) == 0 {
-               Yyerror("missing argument to %v - %v", Oconv(int(n.Op), 0), n)
+               Yyerror("missing argument to %v - %v", Oconv(n.Op, 0), n)
                return false
        }
 
        n.Left = nodeSeqFirst(n.List)
        if nodeSeqLen(n.List) == 1 {
-               Yyerror("missing argument to %v - %v", Oconv(int(n.Op), 0), n)
+               Yyerror("missing argument to %v - %v", Oconv(n.Op, 0), n)
                setNodeSeq(&n.List, nil)
                return false
        }
 
        if nodeSeqLen(n.List) > 2 {
-               Yyerror("too many arguments to %v - %v", Oconv(int(n.Op), 0), n)
+               Yyerror("too many arguments to %v - %v", Oconv(n.Op, 0), n)
                setNodeSeq(&n.List, nil)
                return false
        }
@@ -2744,7 +2744,7 @@ func typecheckaste(op Op, call *Node, isddd bool, tstruct *Type, nl *NodeList, d
                if call != nil {
                        Yyerror("invalid use of ... in call to %v", call)
                } else {
-                       Yyerror("invalid use of ... in %v", Oconv(int(op), 0))
+                       Yyerror("invalid use of ... in %v", Oconv(op, 0))
                }
        }
 
@@ -2764,7 +2764,7 @@ notenough:
                                Yyerror("not enough arguments in call to %v", call)
                        }
                } else {
-                       Yyerror("not enough arguments to %v", Oconv(int(op), 0))
+                       Yyerror("not enough arguments to %v", Oconv(op, 0))
                }
                if n != nil {
                        n.Diag = 1
@@ -2777,7 +2777,7 @@ toomany:
        if call != nil {
                Yyerror("too many arguments in call to %v", call)
        } else {
-               Yyerror("too many arguments to %v", Oconv(int(op), 0))
+               Yyerror("too many arguments to %v", Oconv(op, 0))
        }
        goto out
 }
@@ -3679,7 +3679,7 @@ func typecheckdef(n *Node) *Node {
 
        switch n.Op {
        default:
-               Fatalf("typecheckdef %v", Oconv(int(n.Op), 0))
+               Fatalf("typecheckdef %v", Oconv(n.Op, 0))
 
                // not really syms
        case OGOTO, OLABEL:

diff --git a/src/cmd/compile/internal/gc/unsafe.go b/src/cmd/compile/internal/gc/unsafe.go
index 8884374bd5c2261bbc2a939b51269b968105a72d..f775d6b2f63a9fb6c1a6b0a12f8bfa7cec67f7d3 100644 (file)
--- a/src/cmd/compile/internal/gc/unsafe.go
+++ b/src/cmd/compile/internal/gc/unsafe.go
@@ -87,7 +87,7 @@ func unsafenmagic(nn *Node) *Node {
 
                        default:
                                Dump("unsafenmagic", r)
-                               Fatalf("impossible %v node after dot insertion", Oconv(int(r1.Op), obj.FmtSharp))
+                               Fatalf("impossible %v node after dot insertion", Oconv(r1.Op, obj.FmtSharp))
                                goto bad
                        }
                }

diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index a63387a1a68fac6377a1332cc4b8278d56137c3d..9e5e26bdb963bd16a7b6520cd4c9c8fd4445580a 100644 (file)
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -163,7 +163,7 @@ func walkstmt(np **Node) {
                if n.Op == ONAME {
                        Yyerror("%v is not a top level statement", n.Sym)
                } else {
-                       Yyerror("%v is not a top level statement", Oconv(int(n.Op), 0))
+                       Yyerror("%v is not a top level statement", Oconv(n.Op, 0))
                }
                Dump("nottop", n)
 
@@ -1559,7 +1559,7 @@ opswitch:
                // ifaceeq(i1 any-1, i2 any-2) (ret bool);
        case OCMPIFACE:
                if !Eqtype(n.Left.Type, n.Right.Type) {
-                       Fatalf("ifaceeq %v %v %v", Oconv(int(n.Op), 0), n.Left.Type, n.Right.Type)
+                       Fatalf("ifaceeq %v %v %v", Oconv(n.Op, 0), n.Left.Type, n.Right.Type)
                }
                var fn *Node
                if isnilinter(n.Left.Type) {
@@ -1685,7 +1685,7 @@ func ascompatee(op Op, nl *NodeList, nr *NodeList, init nodesOrNodeListPtr) *Nod
 
        // 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.Func.Nname.Sym.Name)
+               Yyerror("error in shape across %v %v %v / %d %d [%s]", Hconv(nl, obj.FmtSign), Oconv(op, 0), Hconv(nr, obj.FmtSign), count(nl), count(nr), Curfn.Func.Nname.Sym.Name)
        }
        return nn
 }
@@ -1930,9 +1930,9 @@ loop:
                        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)
+                               Yyerror("not enough arguments to %v\n%s\n%s", Oconv(op, 0), l1, l2)
                        } else {
-                               Yyerror("too many arguments to %v\n%s\n%s", Oconv(int(op), 0), l1, l2)
+                               Yyerror("too many arguments to %v\n%s\n%s", Oconv(op, 0), l1, l2)
                        }
                }
 
@@ -2205,7 +2205,7 @@ func applywritebarrier(n *Node) *Node {
 
 func convas(n *Node, init nodesOrNodeListPtr) *Node {
        if n.Op != OAS {
-               Fatalf("convas: not OAS %v", Oconv(int(n.Op), 0))
+               Fatalf("convas: not OAS %v", Oconv(n.Op, 0))
        }
 
        n.Typecheck = 1
@@ -2352,7 +2352,7 @@ func reorder3(all *NodeList) *NodeList {
 
                switch l.Op {
                default:
-                       Fatalf("reorder3 unexpected lvalue %v", Oconv(int(l.Op), obj.FmtSharp))
+                       Fatalf("reorder3 unexpected lvalue %v", Oconv(l.Op, obj.FmtSharp))
 
                case ONAME:
                        break
@@ -3813,7 +3813,7 @@ func usefield(n *Node) {
 
        switch n.Op {
        default:
-               Fatalf("usefield %v", Oconv(int(n.Op), 0))
+               Fatalf("usefield %v", Oconv(n.Op, 0))
 
        case ODOT, ODOTPTR:
                break

diff --git a/src/cmd/compile/internal/mips64/gsubr.go b/src/cmd/compile/internal/mips64/gsubr.go
index c0ed63672d3692531932efd84473d31c223bd7f6..caa4a61304712cc629123935792a7e22490a1b25 100644 (file)
--- a/src/cmd/compile/internal/mips64/gsubr.go
+++ b/src/cmd/compile/internal/mips64/gsubr.go
@@ -148,7 +148,7 @@ func ginscmp(op gc.Op, t *gc.Type, n1, n2 *gc.Node, likely int) *obj.Prog {
        case gc.TFLOAT32:
                switch op {
                default:
-                       gc.Fatalf("ginscmp: no entry for op=%v type=%v", gc.Oconv(int(op), 0), t)
+                       gc.Fatalf("ginscmp: no entry for op=%v type=%v", gc.Oconv(op, 0), t)
 
                case gc.OEQ,
                        gc.ONE:
@@ -165,7 +165,7 @@ func ginscmp(op gc.Op, t *gc.Type, n1, n2 *gc.Node, likely int) *obj.Prog {
        case gc.TFLOAT64:
                switch op {
                default:
-                       gc.Fatalf("ginscmp: no entry for op=%v type=%v", gc.Oconv(int(op), 0), t)
+                       gc.Fatalf("ginscmp: no entry for op=%v type=%v", gc.Oconv(op, 0), t)
 
                case gc.OEQ,
                        gc.ONE:
@@ -715,7 +715,7 @@ func optoas(op gc.Op, t *gc.Type) int {
        a := int(obj.AXXX)
        switch uint32(op)<<16 | uint32(gc.Simtype[t.Etype]) {
        default:
-               gc.Fatalf("optoas: no entry for op=%v type=%v", gc.Oconv(int(op), 0), t)
+               gc.Fatalf("optoas: no entry for op=%v type=%v", gc.Oconv(op, 0), t)
 
        case OEQ_ | gc.TBOOL,
                OEQ_ | gc.TINT8,

diff --git a/src/cmd/compile/internal/ppc64/gsubr.go b/src/cmd/compile/internal/ppc64/gsubr.go
index 71ae7e38731cc4c01136452413dc627f7bda4daa..3ec81cd53badb81025d8802e8eed8a3c556b312a 100644 (file)
--- a/src/cmd/compile/internal/ppc64/gsubr.go
+++ b/src/cmd/compile/internal/ppc64/gsubr.go
@@ -711,7 +711,7 @@ func optoas(op gc.Op, t *gc.Type) int {
        a := int(obj.AXXX)
        switch uint32(op)<<16 | uint32(gc.Simtype[t.Etype]) {
        default:
-               gc.Fatalf("optoas: no entry for op=%v type=%v", gc.Oconv(int(op), 0), t)
+               gc.Fatalf("optoas: no entry for op=%v type=%v", gc.Oconv(op, 0), t)
 
        case OEQ_ | gc.TBOOL,
                OEQ_ | gc.TINT8,

diff --git a/src/cmd/compile/internal/x86/cgen64.go b/src/cmd/compile/internal/x86/cgen64.go
index 8bb7d371a37ccb7f2b86c5ed3b0b3b27989b0f38..e59784b1f8b65e2398066bfa9789871ab5237547 100644 (file)
--- a/src/cmd/compile/internal/x86/cgen64.go
+++ b/src/cmd/compile/internal/x86/cgen64.go
@@ -19,12 +19,12 @@ func cgen64(n *gc.Node, res *gc.Node) {
        if res.Op != gc.OINDREG && res.Op != gc.ONAME {
                gc.Dump("n", n)
                gc.Dump("res", res)
-               gc.Fatalf("cgen64 %v of %v", gc.Oconv(int(n.Op), 0), gc.Oconv(int(res.Op), 0))
+               gc.Fatalf("cgen64 %v of %v", gc.Oconv(n.Op, 0), gc.Oconv(res.Op, 0))
        }
 
        switch n.Op {
        default:
-               gc.Fatalf("cgen64 %v", gc.Oconv(int(n.Op), 0))
+               gc.Fatalf("cgen64 %v", gc.Oconv(n.Op, 0))
 
        case gc.OMINUS:
                gc.Cgen(n.Left, res)
@@ -531,7 +531,7 @@ func cmp64(nl *gc.Node, nr *gc.Node, op gc.Op, likely int, to *obj.Prog) {
        var br *obj.Prog
        switch op {
        default:
-               gc.Fatalf("cmp64 %v %v", gc.Oconv(int(op), 0), t)
+               gc.Fatalf("cmp64 %v %v", gc.Oconv(op, 0), t)
 
                // cmp hi
        // jne L

diff --git a/src/cmd/compile/internal/x86/ggen.go b/src/cmd/compile/internal/x86/ggen.go
index f3481c3b875f364d8090fa84cd97fe8bee3c489e..fccb5531bf84fe4bf86c41842c656b8277d26bcf 100644 (file)
--- a/src/cmd/compile/internal/x86/ggen.go
+++ b/src/cmd/compile/internal/x86/ggen.go
@@ -661,7 +661,7 @@ func cgen_floatsse(n *gc.Node, res *gc.Node) {
        switch n.Op {
        default:
                gc.Dump("cgen_floatsse", n)
-               gc.Fatalf("cgen_floatsse %v", gc.Oconv(int(n.Op), 0))
+               gc.Fatalf("cgen_floatsse %v", gc.Oconv(n.Op, 0))
                return
 
        case gc.OMINUS,

diff --git a/src/cmd/compile/internal/x86/gsubr.go b/src/cmd/compile/internal/x86/gsubr.go
index 4fd6680cb4ddc2243facd05c4428b7c8576f01cd..555606c654e0de390d4a4e968edf93fa78f8f45d 100644 (file)
--- a/src/cmd/compile/internal/x86/gsubr.go
+++ b/src/cmd/compile/internal/x86/gsubr.go
@@ -91,7 +91,7 @@ func optoas(op gc.Op, t *gc.Type) int {
        a := obj.AXXX
        switch uint32(op)<<16 | uint32(gc.Simtype[t.Etype]) {
        default:
-               gc.Fatalf("optoas: no entry %v-%v", gc.Oconv(int(op), 0), t)
+               gc.Fatalf("optoas: no entry %v-%v", gc.Oconv(op, 0), t)
 
        case OADDR_ | gc.TPTR32:
                a = x86.ALEAL
@@ -454,7 +454,7 @@ func foptoas(op gc.Op, t *gc.Type, flg int) int {
        if !gc.Thearch.Use387 {
                switch uint32(op)<<16 | uint32(et) {
                default:
-                       gc.Fatalf("foptoas-sse: no entry %v-%v", gc.Oconv(int(op), 0), t)
+                       gc.Fatalf("foptoas-sse: no entry %v-%v", gc.Oconv(op, 0), t)
 
                case OCMP_ | gc.TFLOAT32:
                        a = x86.AUCOMISS
@@ -587,7 +587,7 @@ func foptoas(op gc.Op, t *gc.Type, flg int) int {
                return x86.AFCHS
        }
 
-       gc.Fatalf("foptoas %v %v %#x", gc.Oconv(int(op), 0), t, flg)
+       gc.Fatalf("foptoas %v %v %#x", gc.Oconv(op, 0), t, flg)
        return 0
 }