cmd/internal/obj: make Rconv a global function

Clean up the obj API by making Rconv (register pretty printer) a top-level
function. This means that Dconv (operand pretty printer) doesn't need
an Rconv argument.

To do this, we make the register numbers, which are arbitrary inside an
operand (obj.Addr), disjoint sets for each architecture. Each architecture
registers (ha) a piece of the space and then the global Rconv knows which
architecture-specific printer to use.

Clean up all the code that uses Dconv.

Now register numbers are large, so a couple of fields in Addr need to go
from int8 to int16 because they sometimes hold register numbers. Clean
up their uses, which meant regenerating the yacc grammars for the
assemblers. There are changes in this CL triggered by earlier changes
to yacc, which had not been run in this directory.

There is still cleanup to do in Addr, but we're getting closer to that being
easy to do.

Change-Id: I9290ebee013b62f7d24e886743ea5a6b232990ab
Reviewed-on: https://go-review.googlesource.com/6220
Reviewed-by: Russ Cox <rsc@golang.org>

diff --git a/src/cmd/5a/y.go b/src/cmd/5a/y.go
index 17ee80ee51f22a5b270040e9e98785e1f5c72314..7c7de64b15df73bcb379ab64ad5eab0fad84fdfd 100644 (file)
--- a/src/cmd/5a/y.go
+++ b/src/cmd/5a/y.go
@@ -424,6 +424,26 @@ type yyLexer interface {
        Error(s string)
 }
 
+type yyParser interface {
+       Parse(yyLexer) int
+       Lookahead() int
+}
+
+type yyParserImpl struct {
+       lookahead func() int
+}
+
+func (p *yyParserImpl) Lookahead() int {
+       return p.lookahead()
+}
+
+func yyNewParser() yyParser {
+       p := &yyParserImpl{
+               lookahead: func() int { return -1 },
+       }
+       return p
+}
+
 const yyFlag = -1000
 
 func yyTokname(c int) string {
@@ -445,51 +465,63 @@ func yyStatname(s int) string {
        return __yyfmt__.Sprintf("state-%v", s)
 }
 
-func yylex1(lex yyLexer, lval *yySymType) int {
-       c := 0
-       char := lex.Lex(lval)
+func yylex1(lex yyLexer, lval *yySymType) (char, token int) {
+       token = 0
+       char = lex.Lex(lval)
        if char <= 0 {
-               c = yyTok1[0]
+               token = yyTok1[0]
                goto out
        }
        if char < len(yyTok1) {
-               c = yyTok1[char]
+               token = yyTok1[char]
                goto out
        }
        if char >= yyPrivate {
                if char < yyPrivate+len(yyTok2) {
-                       c = yyTok2[char-yyPrivate]
+                       token = yyTok2[char-yyPrivate]
                        goto out
                }
        }
        for i := 0; i < len(yyTok3); i += 2 {
-               c = yyTok3[i+0]
-               if c == char {
-                       c = yyTok3[i+1]
+               token = yyTok3[i+0]
+               if token == char {
+                       token = yyTok3[i+1]
                        goto out
                }
        }
 
 out:
-       if c == 0 {
-               c = yyTok2[1] /* unknown char */
+       if token == 0 {
+               token = yyTok2[1] /* unknown char */
        }
        if yyDebug >= 3 {
-               __yyfmt__.Printf("lex %s(%d)\n", yyTokname(c), uint(char))
+               __yyfmt__.Printf("lex %s(%d)\n", yyTokname(token), uint(char))
        }
-       return c
+       return char, token
 }
 
 func yyParse(yylex yyLexer) int {
+       return yyNewParser().Parse(yylex)
+}
+
+func (yyrcvr *yyParserImpl) Parse(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
+       yyrcvr.lookahead = func() int { return yychar }
+       defer func() {
+               // Make sure we report no lookahead when not parsing.
+               yychar = -1
+               yytoken = -1
+       }()
        yyp := -1
        goto yystack
 
@@ -502,7 +534,7 @@ ret1:
 yystack:
        /* put a state and value onto the stack */
        if yyDebug >= 4 {
-               __yyfmt__.Printf("char %v in %v\n", yyTokname(yychar), yyStatname(yystate))
+               __yyfmt__.Printf("char %v in %v\n", yyTokname(yytoken), yyStatname(yystate))
        }
 
        yyp++
@@ -520,15 +552,16 @@ yynewstate:
                goto yydefault /* simple state */
        }
        if yychar < 0 {
-               yychar = yylex1(yylex, &yylval)
+               yychar, yytoken = yylex1(yylex, &yylval)
        }
-       yyn += yychar
+       yyn += yytoken
        if yyn < 0 || yyn >= yyLast {
                goto yydefault
        }
        yyn = yyAct[yyn]
-       if yyChk[yyn] == yychar { /* valid shift */
+       if yyChk[yyn] == yytoken { /* valid shift */
                yychar = -1
+               yytoken = -1
                yyVAL = yylval
                yystate = yyn
                if Errflag > 0 {
@@ -542,7 +575,7 @@ yydefault:
        yyn = yyDef[yystate]
        if yyn == -2 {
                if yychar < 0 {
-                       yychar = yylex1(yylex, &yylval)
+                       yychar, yytoken = yylex1(yylex, &yylval)
                }
 
                /* look through exception table */
@@ -555,7 +588,7 @@ yydefault:
                }
                for xi += 2; ; xi += 2 {
                        yyn = yyExca[xi+0]
-                       if yyn < 0 || yyn == yychar {
+                       if yyn < 0 || yyn == yytoken {
                                break
                        }
                }
@@ -572,7 +605,7 @@ yydefault:
                        Nerrs++
                        if yyDebug >= 1 {
                                __yyfmt__.Printf("%s", yyStatname(yystate))
-                               __yyfmt__.Printf(" saw %s\n", yyTokname(yychar))
+                               __yyfmt__.Printf(" saw %s\n", yyTokname(yytoken))
                        }
                        fallthrough
 
@@ -600,12 +633,13 @@ yydefault:
 
                case 3: /* no shift yet; clobber input char */
                        if yyDebug >= 2 {
-                               __yyfmt__.Printf("error recovery discards %s\n", yyTokname(yychar))
+                               __yyfmt__.Printf("error recovery discards %s\n", yyTokname(yytoken))
                        }
-                       if yychar == yyEofCode {
+                       if yytoken == yyEofCode {
                                goto ret1
                        }
                        yychar = -1
+                       yytoken = -1
                        goto yynewstate /* try again in the same state */
                }
        }
@@ -646,201 +680,234 @@ yydefault:
        switch yynt {
 
        case 2:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:73
                {
                        stmtline = asm.Lineno
                }
        case 4:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:80
                {
-                       yyS[yypt-1].sym = asm.LabelLookup(yyS[yypt-1].sym)
-                       if yyS[yypt-1].sym.Type == LLAB && yyS[yypt-1].sym.Value != int64(asm.PC) {
-                               yyerror("redeclaration of %s", yyS[yypt-1].sym.Labelname)
+                       yyDollar[1].sym = asm.LabelLookup(yyDollar[1].sym)
+                       if yyDollar[1].sym.Type == LLAB && yyDollar[1].sym.Value != int64(asm.PC) {
+                               yyerror("redeclaration of %s", yyDollar[1].sym.Labelname)
                        }
-                       yyS[yypt-1].sym.Type = LLAB
-                       yyS[yypt-1].sym.Value = int64(asm.PC)
+                       yyDollar[1].sym.Type = LLAB
+                       yyDollar[1].sym.Value = int64(asm.PC)
                }
        case 6:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:90
                {
-                       yyS[yypt-3].sym.Type = LVAR
-                       yyS[yypt-3].sym.Value = int64(yyS[yypt-1].lval)
+                       yyDollar[1].sym.Type = LVAR
+                       yyDollar[1].sym.Value = int64(yyDollar[3].lval)
                }
        case 7:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:95
                {
-                       if yyS[yypt-3].sym.Value != int64(yyS[yypt-1].lval) {
-                               yyerror("redeclaration of %s", yyS[yypt-3].sym.Name)
+                       if yyDollar[1].sym.Value != int64(yyDollar[3].lval) {
+                               yyerror("redeclaration of %s", yyDollar[1].sym.Name)
                        }
-                       yyS[yypt-3].sym.Value = int64(yyS[yypt-1].lval)
+                       yyDollar[1].sym.Value = int64(yyDollar[3].lval)
                }
        case 11:
+               yyDollar = yyS[yypt-7 : yypt+1]
                //line a.y:110
                {
-                       outcode(yyS[yypt-6].lval, yyS[yypt-5].lval, &yyS[yypt-4].addr, yyS[yypt-2].lval, &yyS[yypt-0].addr)
+                       outcode(yyDollar[1].lval, yyDollar[2].lval, &yyDollar[3].addr, yyDollar[5].lval, &yyDollar[7].addr)
                }
        case 12:
+               yyDollar = yyS[yypt-6 : yypt+1]
                //line a.y:114
                {
-                       outcode(yyS[yypt-5].lval, yyS[yypt-4].lval, &yyS[yypt-3].addr, yyS[yypt-1].lval, &nullgen)
+                       outcode(yyDollar[1].lval, yyDollar[2].lval, &yyDollar[3].addr, yyDollar[5].lval, &nullgen)
                }
        case 13:
+               yyDollar = yyS[yypt-5 : yypt+1]
                //line a.y:118
                {
-                       outcode(yyS[yypt-4].lval, yyS[yypt-3].lval, &yyS[yypt-2].addr, 0, &yyS[yypt-0].addr)
+                       outcode(yyDollar[1].lval, yyDollar[2].lval, &yyDollar[3].addr, 0, &yyDollar[5].addr)
                }
        case 14:
+               yyDollar = yyS[yypt-5 : yypt+1]
                //line a.y:125
                {
-                       outcode(yyS[yypt-4].lval, yyS[yypt-3].lval, &yyS[yypt-2].addr, 0, &yyS[yypt-0].addr)
+                       outcode(yyDollar[1].lval, yyDollar[2].lval, &yyDollar[3].addr, 0, &yyDollar[5].addr)
                }
        case 15:
+               yyDollar = yyS[yypt-5 : yypt+1]
                //line a.y:132
                {
-                       outcode(yyS[yypt-4].lval, yyS[yypt-3].lval, &yyS[yypt-2].addr, 0, &yyS[yypt-0].addr)
+                       outcode(yyDollar[1].lval, yyDollar[2].lval, &yyDollar[3].addr, 0, &yyDollar[5].addr)
                }
        case 16:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:139
                {
-                       outcode(yyS[yypt-3].lval, yyS[yypt-2].lval, &nullgen, 0, &yyS[yypt-0].addr)
+                       outcode(yyDollar[1].lval, yyDollar[2].lval, &nullgen, 0, &yyDollar[4].addr)
                }
        case 17:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:143
                {
-                       outcode(yyS[yypt-3].lval, yyS[yypt-2].lval, &nullgen, 0, &yyS[yypt-0].addr)
+                       outcode(yyDollar[1].lval, yyDollar[2].lval, &nullgen, 0, &yyDollar[4].addr)
                }
        case 18:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:150
                {
-                       outcode(yyS[yypt-2].lval, Always, &nullgen, 0, &yyS[yypt-0].addr)
+                       outcode(yyDollar[1].lval, Always, &nullgen, 0, &yyDollar[3].addr)
                }
        case 19:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:157
                {
-                       outcode(yyS[yypt-2].lval, Always, &nullgen, 0, &yyS[yypt-0].addr)
+                       outcode(yyDollar[1].lval, Always, &nullgen, 0, &yyDollar[3].addr)
                }
        case 20:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:164
                {
-                       outcode(yyS[yypt-3].lval, yyS[yypt-2].lval, &nullgen, 0, &yyS[yypt-0].addr)
+                       outcode(yyDollar[1].lval, yyDollar[2].lval, &nullgen, 0, &yyDollar[4].addr)
                }
        case 21:
+               yyDollar = yyS[yypt-6 : yypt+1]
                //line a.y:171
                {
-                       outcode(yyS[yypt-5].lval, yyS[yypt-4].lval, &yyS[yypt-3].addr, yyS[yypt-1].lval, &nullgen)
+                       outcode(yyDollar[1].lval, yyDollar[2].lval, &yyDollar[3].addr, yyDollar[5].lval, &nullgen)
                }
        case 22:
+               yyDollar = yyS[yypt-7 : yypt+1]
                //line a.y:178
                {
                        var g obj.Addr
 
                        g = nullgen
                        g.Type = obj.TYPE_CONST
-                       g.Offset = int64(yyS[yypt-1].lval)
-                       outcode(yyS[yypt-6].lval, yyS[yypt-5].lval, &yyS[yypt-4].addr, 0, &g)
+                       g.Offset = int64(yyDollar[6].lval)
+                       outcode(yyDollar[1].lval, yyDollar[2].lval, &yyDollar[3].addr, 0, &g)
                }
        case 23:
+               yyDollar = yyS[yypt-7 : yypt+1]
                //line a.y:187
                {
                        var g obj.Addr
 
                        g = nullgen
                        g.Type = obj.TYPE_CONST
-                       g.Offset = int64(yyS[yypt-3].lval)
-                       outcode(yyS[yypt-6].lval, yyS[yypt-5].lval, &g, 0, &yyS[yypt-0].addr)
+                       g.Offset = int64(yyDollar[4].lval)
+                       outcode(yyDollar[1].lval, yyDollar[2].lval, &g, 0, &yyDollar[7].addr)
                }
        case 24:
+               yyDollar = yyS[yypt-7 : yypt+1]
                //line a.y:199
                {
-                       outcode(yyS[yypt-6].lval, yyS[yypt-5].lval, &yyS[yypt-2].addr, int32(yyS[yypt-4].addr.Reg), &yyS[yypt-0].addr)
+                       outcode(yyDollar[1].lval, yyDollar[2].lval, &yyDollar[5].addr, int32(yyDollar[3].addr.Reg), &yyDollar[7].addr)
                }
        case 25:
+               yyDollar = yyS[yypt-6 : yypt+1]
                //line a.y:203
                {
-                       outcode(yyS[yypt-5].lval, yyS[yypt-4].lval, &yyS[yypt-1].addr, int32(yyS[yypt-3].addr.Reg), &yyS[yypt-3].addr)
+                       outcode(yyDollar[1].lval, yyDollar[2].lval, &yyDollar[5].addr, int32(yyDollar[3].addr.Reg), &yyDollar[3].addr)
                }
        case 26:
+               yyDollar = yyS[yypt-6 : yypt+1]
                //line a.y:207
                {
-                       outcode(yyS[yypt-5].lval, yyS[yypt-4].lval, &yyS[yypt-2].addr, int32(yyS[yypt-0].addr.Reg), &yyS[yypt-0].addr)
+                       outcode(yyDollar[1].lval, yyDollar[2].lval, &yyDollar[4].addr, int32(yyDollar[6].addr.Reg), &yyDollar[6].addr)
                }
        case 27:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:214
                {
-                       outcode(yyS[yypt-2].lval, yyS[yypt-1].lval, &nullgen, 0, &nullgen)
+                       outcode(yyDollar[1].lval, yyDollar[2].lval, &nullgen, 0, &nullgen)
                }
        case 28:
+               yyDollar = yyS[yypt-5 : yypt+1]
                //line a.y:221
                {
-                       asm.Settext(yyS[yypt-3].addr.Sym)
-                       outcode(yyS[yypt-4].lval, Always, &yyS[yypt-3].addr, 0, &yyS[yypt-0].addr)
+                       asm.Settext(yyDollar[2].addr.Sym)
+                       outcode(yyDollar[1].lval, Always, &yyDollar[2].addr, 0, &yyDollar[5].addr)
                }
        case 29:
+               yyDollar = yyS[yypt-7 : yypt+1]
                //line a.y:226
                {
-                       asm.Settext(yyS[yypt-5].addr.Sym)
-                       outcode(yyS[yypt-6].lval, Always, &yyS[yypt-5].addr, 0, &yyS[yypt-0].addr)
+                       asm.Settext(yyDollar[2].addr.Sym)
+                       outcode(yyDollar[1].lval, Always, &yyDollar[2].addr, 0, &yyDollar[7].addr)
                        if asm.Pass > 1 {
                                lastpc.From3.Type = obj.TYPE_CONST
-                               lastpc.From3.Offset = int64(yyS[yypt-3].lval)
+                               lastpc.From3.Offset = int64(yyDollar[4].lval)
                        }
                }
        case 30:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:238
                {
-                       asm.Settext(yyS[yypt-2].addr.Sym)
-                       outcode(yyS[yypt-3].lval, Always, &yyS[yypt-2].addr, 0, &yyS[yypt-0].addr)
+                       asm.Settext(yyDollar[2].addr.Sym)
+                       outcode(yyDollar[1].lval, Always, &yyDollar[2].addr, 0, &yyDollar[4].addr)
                }
        case 31:
+               yyDollar = yyS[yypt-6 : yypt+1]
                //line a.y:243
                {
-                       asm.Settext(yyS[yypt-4].addr.Sym)
-                       outcode(yyS[yypt-5].lval, Always, &yyS[yypt-4].addr, 0, &yyS[yypt-0].addr)
+                       asm.Settext(yyDollar[2].addr.Sym)
+                       outcode(yyDollar[1].lval, Always, &yyDollar[2].addr, 0, &yyDollar[6].addr)
                        if asm.Pass > 1 {
                                lastpc.From3.Type = obj.TYPE_CONST
-                               lastpc.From3.Offset = int64(yyS[yypt-2].lval)
+                               lastpc.From3.Offset = int64(yyDollar[4].lval)
                        }
                }
        case 32:
+               yyDollar = yyS[yypt-6 : yypt+1]
                //line a.y:256
                {
-                       outcode(yyS[yypt-5].lval, Always, &yyS[yypt-4].addr, 0, &yyS[yypt-0].addr)
+                       outcode(yyDollar[1].lval, Always, &yyDollar[2].addr, 0, &yyDollar[6].addr)
                        if asm.Pass > 1 {
                                lastpc.From3.Type = obj.TYPE_CONST
-                               lastpc.From3.Offset = int64(yyS[yypt-2].lval)
+                               lastpc.From3.Offset = int64(yyDollar[4].lval)
                        }
                }
        case 33:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:267
                {
-                       outcode(yyS[yypt-3].lval, yyS[yypt-2].lval, &yyS[yypt-1].addr, 0, &nullgen)
+                       outcode(yyDollar[1].lval, yyDollar[2].lval, &yyDollar[3].addr, 0, &nullgen)
                }
        case 34:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:274
                {
-                       outcode(yyS[yypt-2].lval, Always, &nullgen, 0, &yyS[yypt-0].addr)
+                       outcode(yyDollar[1].lval, Always, &nullgen, 0, &yyDollar[3].addr)
                }
        case 35:
+               yyDollar = yyS[yypt-5 : yypt+1]
                //line a.y:281
                {
-                       outcode(yyS[yypt-4].lval, yyS[yypt-3].lval, &yyS[yypt-2].addr, 0, &yyS[yypt-0].addr)
+                       outcode(yyDollar[1].lval, yyDollar[2].lval, &yyDollar[3].addr, 0, &yyDollar[5].addr)
                }
        case 36:
+               yyDollar = yyS[yypt-5 : yypt+1]
                //line a.y:285
                {
-                       outcode(yyS[yypt-4].lval, yyS[yypt-3].lval, &yyS[yypt-2].addr, 0, &yyS[yypt-0].addr)
+                       outcode(yyDollar[1].lval, yyDollar[2].lval, &yyDollar[3].addr, 0, &yyDollar[5].addr)
                }
        case 37:
+               yyDollar = yyS[yypt-7 : yypt+1]
                //line a.y:289
                {
-                       outcode(yyS[yypt-6].lval, yyS[yypt-5].lval, &yyS[yypt-4].addr, yyS[yypt-2].lval, &yyS[yypt-0].addr)
+                       outcode(yyDollar[1].lval, yyDollar[2].lval, &yyDollar[3].addr, yyDollar[5].lval, &yyDollar[7].addr)
                }
        case 38:
+               yyDollar = yyS[yypt-6 : yypt+1]
                //line a.y:293
                {
-                       outcode(yyS[yypt-5].lval, yyS[yypt-4].lval, &yyS[yypt-3].addr, int32(yyS[yypt-1].addr.Reg), &nullgen)
+                       outcode(yyDollar[1].lval, yyDollar[2].lval, &yyDollar[3].addr, int32(yyDollar[5].addr.Reg), &nullgen)
                }
        case 39:
+               yyDollar = yyS[yypt-12 : yypt+1]
                //line a.y:300
                {
                        var g obj.Addr
@@ -849,179 +916,202 @@ yydefault:
                        g.Type = obj.TYPE_CONST
                        g.Offset = int64(
                                (0xe << 24) | /* opcode */
-                                       (yyS[yypt-11].lval << 20) | /* MCR/MRC */
-                                       ((yyS[yypt-10].lval ^ C_SCOND_XOR) << 28) | /* scond */
-                                       ((yyS[yypt-9].lval & 15) << 8) | /* coprocessor number */
-                                       ((yyS[yypt-7].lval & 7) << 21) | /* coprocessor operation */
-                                       ((yyS[yypt-5].lval & 15) << 12) | /* arm register */
-                                       ((yyS[yypt-3].lval & 15) << 16) | /* Crn */
-                                       ((yyS[yypt-1].lval & 15) << 0) | /* Crm */
-                                       ((yyS[yypt-0].lval & 7) << 5) | /* coprocessor information */
+                                       (yyDollar[1].lval << 20) | /* MCR/MRC */
+                                       ((yyDollar[2].lval ^ C_SCOND_XOR) << 28) | /* scond */
+                                       ((yyDollar[3].lval & 15) << 8) | /* coprocessor number */
+                                       ((yyDollar[5].lval & 7) << 21) | /* coprocessor operation */
+                                       ((yyDollar[7].lval & 15) << 12) | /* arm register */
+                                       ((yyDollar[9].lval & 15) << 16) | /* Crn */
+                                       ((yyDollar[11].lval & 15) << 0) | /* Crm */
+                                       ((yyDollar[12].lval & 7) << 5) | /* coprocessor information */
                                        (1 << 4)) /* must be set */
                        outcode(AMRC, Always, &nullgen, 0, &g)
                }
        case 40:
+               yyDollar = yyS[yypt-7 : yypt+1]
                //line a.y:312
                {
-                       outcode(yyS[yypt-6].lval, yyS[yypt-5].lval, &yyS[yypt-4].addr, int32(yyS[yypt-2].addr.Reg), &yyS[yypt-0].addr)
+                       outcode(yyDollar[1].lval, yyDollar[2].lval, &yyDollar[3].addr, int32(yyDollar[5].addr.Reg), &yyDollar[7].addr)
                }
        case 41:
+               yyDollar = yyS[yypt-9 : yypt+1]
                //line a.y:320
                {
-                       yyS[yypt-2].addr.Type = obj.TYPE_REGREG2
-                       yyS[yypt-2].addr.Offset = int64(yyS[yypt-0].lval)
-                       outcode(yyS[yypt-8].lval, yyS[yypt-7].lval, &yyS[yypt-6].addr, int32(yyS[yypt-4].addr.Reg), &yyS[yypt-2].addr)
+                       yyDollar[7].addr.Type = obj.TYPE_REGREG2
+                       yyDollar[7].addr.Offset = int64(yyDollar[9].lval)
+                       outcode(yyDollar[1].lval, yyDollar[2].lval, &yyDollar[3].addr, int32(yyDollar[5].addr.Reg), &yyDollar[7].addr)
                }
        case 42:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:329
                {
-                       outcode(yyS[yypt-1].lval, Always, &yyS[yypt-0].addr, 0, &nullgen)
+                       outcode(yyDollar[1].lval, Always, &yyDollar[2].addr, 0, &nullgen)
                }
        case 43:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:336
                {
-                       if yyS[yypt-2].addr.Type != obj.TYPE_CONST || yyS[yypt-0].addr.Type != obj.TYPE_CONST {
+                       if yyDollar[2].addr.Type != obj.TYPE_CONST || yyDollar[4].addr.Type != obj.TYPE_CONST {
                                yyerror("arguments to PCDATA must be integer constants")
                        }
-                       outcode(yyS[yypt-3].lval, Always, &yyS[yypt-2].addr, 0, &yyS[yypt-0].addr)
+                       outcode(yyDollar[1].lval, Always, &yyDollar[2].addr, 0, &yyDollar[4].addr)
                }
        case 44:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:346
                {
-                       if yyS[yypt-2].addr.Type != obj.TYPE_CONST {
+                       if yyDollar[2].addr.Type != obj.TYPE_CONST {
                                yyerror("index for FUNCDATA must be integer constant")
                        }
-                       if yyS[yypt-0].addr.Type != obj.NAME_EXTERN && yyS[yypt-0].addr.Type != obj.NAME_STATIC && yyS[yypt-0].addr.Type != obj.TYPE_MEM {
+                       if yyDollar[4].addr.Type != obj.NAME_EXTERN && yyDollar[4].addr.Type != obj.NAME_STATIC && yyDollar[4].addr.Type != obj.TYPE_MEM {
                                yyerror("value for FUNCDATA must be symbol reference")
                        }
-                       outcode(yyS[yypt-3].lval, Always, &yyS[yypt-2].addr, 0, &yyS[yypt-0].addr)
+                       outcode(yyDollar[1].lval, Always, &yyDollar[2].addr, 0, &yyDollar[4].addr)
                }
        case 45:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:359
                {
-                       outcode(yyS[yypt-1].lval, Always, &nullgen, 0, &nullgen)
+                       outcode(yyDollar[1].lval, Always, &nullgen, 0, &nullgen)
                }
        case 46:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:365
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_TEXTSIZE
-                       yyVAL.addr.Offset = int64(yyS[yypt-0].lval)
+                       yyVAL.addr.Offset = int64(yyDollar[1].lval)
                        yyVAL.addr.U.Argsize = obj.ArgsSizeUnknown
                }
        case 47:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:372
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_TEXTSIZE
-                       yyVAL.addr.Offset = -int64(yyS[yypt-0].lval)
+                       yyVAL.addr.Offset = -int64(yyDollar[2].lval)
                        yyVAL.addr.U.Argsize = obj.ArgsSizeUnknown
                }
        case 48:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:379
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_TEXTSIZE
-                       yyVAL.addr.Offset = int64(yyS[yypt-2].lval)
-                       yyVAL.addr.U.Argsize = int32(yyS[yypt-0].lval)
+                       yyVAL.addr.Offset = int64(yyDollar[1].lval)
+                       yyVAL.addr.U.Argsize = int32(yyDollar[3].lval)
                }
        case 49:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:386
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_TEXTSIZE
-                       yyVAL.addr.Offset = -int64(yyS[yypt-2].lval)
-                       yyVAL.addr.U.Argsize = int32(yyS[yypt-0].lval)
+                       yyVAL.addr.Offset = -int64(yyDollar[2].lval)
+                       yyVAL.addr.U.Argsize = int32(yyDollar[4].lval)
                }
        case 50:
+               yyDollar = yyS[yypt-0 : yypt+1]
                //line a.y:394
                {
                        yyVAL.lval = Always
                }
        case 51:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:398
                {
-                       yyVAL.lval = (yyS[yypt-1].lval & ^C_SCOND) | yyS[yypt-0].lval
+                       yyVAL.lval = (yyDollar[1].lval & ^C_SCOND) | yyDollar[2].lval
                }
        case 52:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:402
                {
-                       yyVAL.lval = yyS[yypt-1].lval | yyS[yypt-0].lval
+                       yyVAL.lval = yyDollar[1].lval | yyDollar[2].lval
                }
        case 55:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:411
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_BRANCH
-                       yyVAL.addr.Offset = int64(yyS[yypt-3].lval) + int64(asm.PC)
+                       yyVAL.addr.Offset = int64(yyDollar[1].lval) + int64(asm.PC)
                }
        case 56:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:417
                {
-                       yyS[yypt-1].sym = asm.LabelLookup(yyS[yypt-1].sym)
+                       yyDollar[1].sym = asm.LabelLookup(yyDollar[1].sym)
                        yyVAL.addr = nullgen
-                       if asm.Pass == 2 && yyS[yypt-1].sym.Type != LLAB {
-                               yyerror("undefined label: %s", yyS[yypt-1].sym.Labelname)
+                       if asm.Pass == 2 && yyDollar[1].sym.Type != LLAB {
+                               yyerror("undefined label: %s", yyDollar[1].sym.Labelname)
                        }
                        yyVAL.addr.Type = obj.TYPE_BRANCH
-                       yyVAL.addr.Offset = yyS[yypt-1].sym.Value + int64(yyS[yypt-0].lval)
+                       yyVAL.addr.Offset = yyDollar[1].sym.Value + int64(yyDollar[2].lval)
                }
        case 57:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:428
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_CONST
-                       yyVAL.addr.Offset = int64(yyS[yypt-0].lval)
+                       yyVAL.addr.Offset = int64(yyDollar[2].lval)
                }
        case 58:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:434
                {
-                       yyVAL.addr = yyS[yypt-0].addr
+                       yyVAL.addr = yyDollar[2].addr
                        yyVAL.addr.Type = obj.TYPE_ADDR
                }
        case 59:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:439
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_SCONST
-                       yyVAL.addr.U.Sval = yyS[yypt-0].sval
+                       yyVAL.addr.U.Sval = yyDollar[2].sval
                }
        case 60:
                yyVAL.addr = yyS[yypt-0].addr
        case 61:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:448
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_FCONST
-                       yyVAL.addr.U.Dval = yyS[yypt-0].dval
+                       yyVAL.addr.U.Dval = yyDollar[2].dval
                }
        case 62:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:454
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_FCONST
-                       yyVAL.addr.U.Dval = -yyS[yypt-0].dval
+                       yyVAL.addr.U.Dval = -yyDollar[3].dval
                }
        case 63:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:462
                {
-                       yyVAL.lval = 1 << uint(yyS[yypt-0].lval&15)
+                       yyVAL.lval = 1 << uint(yyDollar[1].lval&15)
                }
        case 64:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:466
                {
                        yyVAL.lval = 0
-                       for i := yyS[yypt-2].lval; i <= yyS[yypt-0].lval; i++ {
+                       for i := yyDollar[1].lval; i <= yyDollar[3].lval; i++ {
                                yyVAL.lval |= 1 << uint(i&15)
                        }
-                       for i := yyS[yypt-0].lval; i <= yyS[yypt-2].lval; i++ {
+                       for i := yyDollar[3].lval; i <= yyDollar[1].lval; i++ {
                                yyVAL.lval |= 1 << uint(i&15)
                        }
                }
        case 65:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:476
                {
-                       yyVAL.lval = (1 << uint(yyS[yypt-2].lval&15)) | yyS[yypt-0].lval
+                       yyVAL.lval = (1 << uint(yyDollar[1].lval&15)) | yyDollar[3].lval
                }
        case 66:
                yyVAL.addr = yyS[yypt-0].addr
@@ -1030,31 +1120,35 @@ yydefault:
        case 68:
                yyVAL.addr = yyS[yypt-0].addr
        case 69:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:485
                {
-                       yyVAL.addr = yyS[yypt-3].addr
-                       yyVAL.addr.Reg = int16(yyS[yypt-1].lval)
+                       yyVAL.addr = yyDollar[1].addr
+                       yyVAL.addr.Reg = int16(yyDollar[3].lval)
                }
        case 70:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:490
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_REG
-                       yyVAL.addr.Reg = int16(yyS[yypt-0].lval)
+                       yyVAL.addr.Reg = int16(yyDollar[1].lval)
                }
        case 71:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:496
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_REG
-                       yyVAL.addr.Reg = int16(yyS[yypt-0].lval)
+                       yyVAL.addr.Reg = int16(yyDollar[1].lval)
                }
        case 72:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:502
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_MEM
-                       yyVAL.addr.Offset = int64(yyS[yypt-0].lval)
+                       yyVAL.addr.Offset = int64(yyDollar[1].lval)
                }
        case 73:
                yyVAL.addr = yyS[yypt-0].addr
@@ -1063,38 +1157,42 @@ yydefault:
        case 75:
                yyVAL.addr = yyS[yypt-0].addr
        case 76:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:513
                {
-                       yyVAL.addr = yyS[yypt-0].addr
-                       if yyS[yypt-0].addr.Name != obj.NAME_EXTERN && yyS[yypt-0].addr.Name != obj.NAME_STATIC {
+                       yyVAL.addr = yyDollar[1].addr
+                       if yyDollar[1].addr.Name != obj.NAME_EXTERN && yyDollar[1].addr.Name != obj.NAME_STATIC {
                        }
                }
        case 77:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:521
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_MEM
-                       yyVAL.addr.Reg = int16(yyS[yypt-1].lval)
+                       yyVAL.addr.Reg = int16(yyDollar[2].lval)
                        yyVAL.addr.Offset = 0
                }
        case 78:
                yyVAL.addr = yyS[yypt-0].addr
        case 79:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:531
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_MEM
-                       yyVAL.addr.Reg = int16(yyS[yypt-1].lval)
-                       yyVAL.addr.Offset = int64(yyS[yypt-3].lval)
+                       yyVAL.addr.Reg = int16(yyDollar[3].lval)
+                       yyVAL.addr.Offset = int64(yyDollar[1].lval)
                }
        case 80:
                yyVAL.addr = yyS[yypt-0].addr
        case 81:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:541
                {
-                       yyVAL.addr = yyS[yypt-3].addr
+                       yyVAL.addr = yyDollar[1].addr
                        yyVAL.addr.Type = obj.TYPE_MEM
-                       yyVAL.addr.Reg = int16(yyS[yypt-1].lval)
+                       yyVAL.addr.Reg = int16(yyDollar[3].lval)
                }
        case 82:
                yyVAL.addr = yyS[yypt-0].addr
@@ -1105,89 +1203,101 @@ yydefault:
        case 85:
                yyVAL.addr = yyS[yypt-0].addr
        case 86:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:554
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_CONST
-                       yyVAL.addr.Offset = int64(yyS[yypt-0].lval)
+                       yyVAL.addr.Offset = int64(yyDollar[2].lval)
                }
        case 87:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:562
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_REG
-                       yyVAL.addr.Reg = int16(yyS[yypt-0].lval)
+                       yyVAL.addr.Reg = int16(yyDollar[1].lval)
                }
        case 88:
+               yyDollar = yyS[yypt-5 : yypt+1]
                //line a.y:570
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_REGREG
-                       yyVAL.addr.Reg = int16(yyS[yypt-3].lval)
-                       yyVAL.addr.Offset = int64(yyS[yypt-1].lval)
+                       yyVAL.addr.Reg = int16(yyDollar[2].lval)
+                       yyVAL.addr.Offset = int64(yyDollar[4].lval)
                }
        case 89:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:579
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_SHIFT
-                       yyVAL.addr.Offset = int64(yyS[yypt-3].lval&15) | int64(yyS[yypt-0].lval) | (0 << 5)
+                       yyVAL.addr.Offset = int64(yyDollar[1].lval&15) | int64(yyDollar[4].lval) | (0 << 5)
                }
        case 90:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:585
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_SHIFT
-                       yyVAL.addr.Offset = int64(yyS[yypt-3].lval&15) | int64(yyS[yypt-0].lval) | (1 << 5)
+                       yyVAL.addr.Offset = int64(yyDollar[1].lval&15) | int64(yyDollar[4].lval) | (1 << 5)
                }
        case 91:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:591
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_SHIFT
-                       yyVAL.addr.Offset = int64(yyS[yypt-3].lval&15) | int64(yyS[yypt-0].lval) | (2 << 5)
+                       yyVAL.addr.Offset = int64(yyDollar[1].lval&15) | int64(yyDollar[4].lval) | (2 << 5)
                }
        case 92:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:597
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_SHIFT
-                       yyVAL.addr.Offset = int64(yyS[yypt-3].lval&15) | int64(yyS[yypt-0].lval) | (3 << 5)
+                       yyVAL.addr.Offset = int64(yyDollar[1].lval&15) | int64(yyDollar[4].lval) | (3 << 5)
                }
        case 93:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:605
                {
                        if yyVAL.lval < REG_R0 || yyVAL.lval > REG_R15 {
                                print("register value out of range\n")
                        }
-                       yyVAL.lval = ((yyS[yypt-0].lval & 15) << 8) | (1 << 4)
+                       yyVAL.lval = ((yyDollar[1].lval & 15) << 8) | (1 << 4)
                }
        case 94:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:612
                {
                        if yyVAL.lval < 0 || yyVAL.lval >= 32 {
                                print("shift value out of range\n")
                        }
-                       yyVAL.lval = (yyS[yypt-0].lval & 31) << 7
+                       yyVAL.lval = (yyDollar[1].lval & 31) << 7
                }
        case 95:
                yyVAL.lval = yyS[yypt-0].lval
        case 96:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:622
                {
                        yyVAL.lval = REGPC
                }
        case 97:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:626
                {
-                       if yyS[yypt-1].lval < 0 || yyS[yypt-1].lval >= NREG {
+                       if yyDollar[3].lval < 0 || yyDollar[3].lval >= NREG {
                                print("register value out of range\n")
                        }
-                       yyVAL.lval = REG_R0 + yyS[yypt-1].lval
+                       yyVAL.lval = REG_R0 + yyDollar[3].lval
                }
        case 98:
                yyVAL.lval = yyS[yypt-0].lval
        case 99:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:636
                {
                        yyVAL.lval = REGSP
@@ -1195,72 +1305,81 @@ yydefault:
        case 100:
                yyVAL.lval = yyS[yypt-0].lval
        case 101:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:643
                {
-                       if yyS[yypt-1].lval < 0 || yyS[yypt-1].lval >= NREG {
+                       if yyDollar[3].lval < 0 || yyDollar[3].lval >= NREG {
                                print("register value out of range\n")
                        }
-                       yyVAL.lval = yyS[yypt-1].lval // TODO(rsc): REG_C0+$3
+                       yyVAL.lval = yyDollar[3].lval // TODO(rsc): REG_C0+$3
                }
        case 102:
                yyVAL.addr = yyS[yypt-0].addr
        case 103:
                yyVAL.addr = yyS[yypt-0].addr
        case 104:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:656
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_REG
-                       yyVAL.addr.Reg = int16(yyS[yypt-0].lval)
+                       yyVAL.addr.Reg = int16(yyDollar[1].lval)
                }
        case 105:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:662
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_REG
-                       yyVAL.addr.Reg = int16(REG_F0 + yyS[yypt-1].lval)
+                       yyVAL.addr.Reg = int16(REG_F0 + yyDollar[3].lval)
                }
        case 106:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:670
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_MEM
-                       yyVAL.addr.Name = int8(yyS[yypt-1].lval)
+                       yyVAL.addr.Name = int8(yyDollar[3].lval)
                        yyVAL.addr.Sym = nil
-                       yyVAL.addr.Offset = int64(yyS[yypt-3].lval)
+                       yyVAL.addr.Offset = int64(yyDollar[1].lval)
                }
        case 107:
+               yyDollar = yyS[yypt-5 : yypt+1]
                //line a.y:678
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_MEM
-                       yyVAL.addr.Name = int8(yyS[yypt-1].lval)
-                       yyVAL.addr.Sym = obj.Linklookup(asm.Ctxt, yyS[yypt-4].sym.Name, 0)
-                       yyVAL.addr.Offset = int64(yyS[yypt-3].lval)
+                       yyVAL.addr.Name = int8(yyDollar[4].lval)
+                       yyVAL.addr.Sym = obj.Linklookup(asm.Ctxt, yyDollar[1].sym.Name, 0)
+                       yyVAL.addr.Offset = int64(yyDollar[2].lval)
                }
        case 108:
+               yyDollar = yyS[yypt-7 : yypt+1]
                //line a.y:686
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_MEM
                        yyVAL.addr.Name = obj.NAME_STATIC
-                       yyVAL.addr.Sym = obj.Linklookup(asm.Ctxt, yyS[yypt-6].sym.Name, 1)
-                       yyVAL.addr.Offset = int64(yyS[yypt-3].lval)
+                       yyVAL.addr.Sym = obj.Linklookup(asm.Ctxt, yyDollar[1].sym.Name, 1)
+                       yyVAL.addr.Offset = int64(yyDollar[4].lval)
                }
        case 109:
+               yyDollar = yyS[yypt-0 : yypt+1]
                //line a.y:695
                {
                        yyVAL.lval = 0
                }
        case 110:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:699
                {
-                       yyVAL.lval = yyS[yypt-0].lval
+                       yyVAL.lval = yyDollar[2].lval
                }
        case 111:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:703
                {
-                       yyVAL.lval = -yyS[yypt-0].lval
+                       yyVAL.lval = -yyDollar[2].lval
                }
        case 112:
                yyVAL.lval = yyS[yypt-0].lval
@@ -1271,91 +1390,108 @@ yydefault:
        case 115:
                yyVAL.lval = yyS[yypt-0].lval
        case 116:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:715
                {
-                       yyVAL.lval = int32(yyS[yypt-0].sym.Value)
+                       yyVAL.lval = int32(yyDollar[1].sym.Value)
                }
        case 117:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:719
                {
-                       yyVAL.lval = -yyS[yypt-0].lval
+                       yyVAL.lval = -yyDollar[2].lval
                }
        case 118:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:723
                {
-                       yyVAL.lval = yyS[yypt-0].lval
+                       yyVAL.lval = yyDollar[2].lval
                }
        case 119:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:727
                {
-                       yyVAL.lval = ^yyS[yypt-0].lval
+                       yyVAL.lval = ^yyDollar[2].lval
                }
        case 120:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:731
                {
-                       yyVAL.lval = yyS[yypt-1].lval
+                       yyVAL.lval = yyDollar[2].lval
                }
        case 121:
+               yyDollar = yyS[yypt-0 : yypt+1]
                //line a.y:736
                {
                        yyVAL.lval = 0
                }
        case 122:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:740
                {
-                       yyVAL.lval = yyS[yypt-0].lval
+                       yyVAL.lval = yyDollar[2].lval
                }
        case 123:
                yyVAL.lval = yyS[yypt-0].lval
        case 124:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:747
                {
-                       yyVAL.lval = yyS[yypt-2].lval + yyS[yypt-0].lval
+                       yyVAL.lval = yyDollar[1].lval + yyDollar[3].lval
                }
        case 125:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:751
                {
-                       yyVAL.lval = yyS[yypt-2].lval - yyS[yypt-0].lval
+                       yyVAL.lval = yyDollar[1].lval - yyDollar[3].lval
                }
        case 126:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:755
                {
-                       yyVAL.lval = yyS[yypt-2].lval * yyS[yypt-0].lval
+                       yyVAL.lval = yyDollar[1].lval * yyDollar[3].lval
                }
        case 127:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:759
                {
-                       yyVAL.lval = yyS[yypt-2].lval / yyS[yypt-0].lval
+                       yyVAL.lval = yyDollar[1].lval / yyDollar[3].lval
                }
        case 128:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:763
                {
-                       yyVAL.lval = yyS[yypt-2].lval % yyS[yypt-0].lval
+                       yyVAL.lval = yyDollar[1].lval % yyDollar[3].lval
                }
        case 129:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:767
                {
-                       yyVAL.lval = yyS[yypt-3].lval << uint(yyS[yypt-0].lval)
+                       yyVAL.lval = yyDollar[1].lval << uint(yyDollar[4].lval)
                }
        case 130:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:771
                {
-                       yyVAL.lval = yyS[yypt-3].lval >> uint(yyS[yypt-0].lval)
+                       yyVAL.lval = yyDollar[1].lval >> uint(yyDollar[4].lval)
                }
        case 131:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:775
                {
-                       yyVAL.lval = yyS[yypt-2].lval & yyS[yypt-0].lval
+                       yyVAL.lval = yyDollar[1].lval & yyDollar[3].lval
                }
        case 132:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:779
                {
-                       yyVAL.lval = yyS[yypt-2].lval ^ yyS[yypt-0].lval
+                       yyVAL.lval = yyDollar[1].lval ^ yyDollar[3].lval
                }
        case 133:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:783
                {
-                       yyVAL.lval = yyS[yypt-2].lval | yyS[yypt-0].lval
+                       yyVAL.lval = yyDollar[1].lval | yyDollar[3].lval
                }
        }
        goto yystack /* stack new state and value */

diff --git a/src/cmd/5g/gsubr.go b/src/cmd/5g/gsubr.go
index a8b8ed554d77466b250c27283cbe21802dada519..ce0d5e8094c563cd58953d2c0dac1dc5efc915bc 100644 (file)
--- a/src/cmd/5g/gsubr.go
+++ b/src/cmd/5g/gsubr.go
@@ -64,7 +64,7 @@ func gclean() {
 
        for i := 0; i < len(reg); i++ {
                if reg[i] != 0 {
-                       gc.Yyerror("reg %v left allocated\n", gc.Ctxt.Rconv(i))
+                       gc.Yyerror("reg %v left allocated\n", obj.Rconv(i))
                }
        }
 }
@@ -216,7 +216,7 @@ func regfree(n *gc.Node) {
                gc.Fatal("regfree: reg out of range")
        }
        if reg[i] <= 0 {
-               gc.Fatal("regfree: reg %v not allocated", gc.Ctxt.Rconv(i))
+               gc.Fatal("regfree: reg %v not allocated", obj.Rconv(i))
        }
        reg[i]--
        if reg[i] == 0 {

diff --git a/src/cmd/6a/a.y b/src/cmd/6a/a.y
index bd59a1faba4e115a3b4f8a9ff311fe13b1c61302..671e79cc15609d42b93a0fcba0dd262d9d579927 100644 (file)
--- a/src/cmd/6a/a.y
+++ b/src/cmd/6a/a.y
@@ -521,7 +521,7 @@ omem:
                $$.Type = obj.TYPE_MEM
                $$.Offset = $1;
                $$.Index = int16($3);
-               $$.Scale = int8($5);
+               $$.Scale = int16($5);
                checkscale($$.Scale);
        }
 |      con '(' LLREG ')' '(' LLREG '*' con ')'
@@ -531,7 +531,7 @@ omem:
                $$.Reg = int16($3)
                $$.Offset = $1;
                $$.Index = int16($6);
-               $$.Scale = int8($8);
+               $$.Scale = int16($8);
                checkscale($$.Scale);
        }
 |      con '(' LLREG ')' '(' LSREG '*' con ')'
@@ -541,7 +541,7 @@ omem:
                $$.Reg = int16($3)
                $$.Offset = $1;
                $$.Index = int16($6);
-               $$.Scale = int8($8);
+               $$.Scale = int16($8);
                checkscale($$.Scale);
        }
 |      '(' LLREG ')'
@@ -561,7 +561,7 @@ omem:
                $$ = nullgen;
                $$.Type = obj.TYPE_MEM
                $$.Index = int16($2);
-               $$.Scale = int8($4);
+               $$.Scale = int16($4);
                checkscale($$.Scale);
        }
 |      '(' LLREG ')' '(' LLREG '*' con ')'
@@ -570,7 +570,7 @@ omem:
                $$.Type = obj.TYPE_MEM
                $$.Reg = int16($2)
                $$.Index = int16($5);
-               $$.Scale = int8($7);
+               $$.Scale = int16($7);
                checkscale($$.Scale);
        }
 
@@ -583,7 +583,7 @@ nmem:
        {
                $$ = $1;
                $$.Index = int16($3);
-               $$.Scale = int8($5);
+               $$.Scale = int16($5);
                checkscale($$.Scale);
        }
 

diff --git a/src/cmd/6a/lex.go b/src/cmd/6a/lex.go
index db4247f045af96380d9d6321352f81175c5d9169..9e58446c88c30adafb714d37f1f6e913798f3e0b 100644 (file)
--- a/src/cmd/6a/lex.go
+++ b/src/cmd/6a/lex.go
@@ -918,7 +918,7 @@ var lexinit = []asm.Lextab{
 func cinit() {
 }
 
-func checkscale(scale int8) {
+func checkscale(scale int16) {
        switch scale {
        case 1,
                2,

diff --git a/src/cmd/6a/y.go b/src/cmd/6a/y.go
index 0b78d2e1e2ff954a1fd84f84ea39b2e4af3b97e4..730fb7803eb00a65163fd821ea7ec7f1b3631100 100644 (file)
--- a/src/cmd/6a/y.go
+++ b/src/cmd/6a/y.go
@@ -357,6 +357,26 @@ type yyLexer interface {
        Error(s string)
 }
 
+type yyParser interface {
+       Parse(yyLexer) int
+       Lookahead() int
+}
+
+type yyParserImpl struct {
+       lookahead func() int
+}
+
+func (p *yyParserImpl) Lookahead() int {
+       return p.lookahead()
+}
+
+func yyNewParser() yyParser {
+       p := &yyParserImpl{
+               lookahead: func() int { return -1 },
+       }
+       return p
+}
+
 const yyFlag = -1000
 
 func yyTokname(c int) string {
@@ -378,51 +398,63 @@ func yyStatname(s int) string {
        return __yyfmt__.Sprintf("state-%v", s)
 }
 
-func yylex1(lex yyLexer, lval *yySymType) int {
-       c := 0
-       char := lex.Lex(lval)
+func yylex1(lex yyLexer, lval *yySymType) (char, token int) {
+       token = 0
+       char = lex.Lex(lval)
        if char <= 0 {
-               c = yyTok1[0]
+               token = yyTok1[0]
                goto out
        }
        if char < len(yyTok1) {
-               c = yyTok1[char]
+               token = yyTok1[char]
                goto out
        }
        if char >= yyPrivate {
                if char < yyPrivate+len(yyTok2) {
-                       c = yyTok2[char-yyPrivate]
+                       token = yyTok2[char-yyPrivate]
                        goto out
                }
        }
        for i := 0; i < len(yyTok3); i += 2 {
-               c = yyTok3[i+0]
-               if c == char {
-                       c = yyTok3[i+1]
+               token = yyTok3[i+0]
+               if token == char {
+                       token = yyTok3[i+1]
                        goto out
                }
        }
 
 out:
-       if c == 0 {
-               c = yyTok2[1] /* unknown char */
+       if token == 0 {
+               token = yyTok2[1] /* unknown char */
        }
        if yyDebug >= 3 {
-               __yyfmt__.Printf("lex %s(%d)\n", yyTokname(c), uint(char))
+               __yyfmt__.Printf("lex %s(%d)\n", yyTokname(token), uint(char))
        }
-       return c
+       return char, token
 }
 
 func yyParse(yylex yyLexer) int {
+       return yyNewParser().Parse(yylex)
+}
+
+func (yyrcvr *yyParserImpl) Parse(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
+       yyrcvr.lookahead = func() int { return yychar }
+       defer func() {
+               // Make sure we report no lookahead when not parsing.
+               yychar = -1
+               yytoken = -1
+       }()
        yyp := -1
        goto yystack
 
@@ -435,7 +467,7 @@ ret1:
 yystack:
        /* put a state and value onto the stack */
        if yyDebug >= 4 {
-               __yyfmt__.Printf("char %v in %v\n", yyTokname(yychar), yyStatname(yystate))
+               __yyfmt__.Printf("char %v in %v\n", yyTokname(yytoken), yyStatname(yystate))
        }
 
        yyp++
@@ -453,15 +485,16 @@ yynewstate:
                goto yydefault /* simple state */
        }
        if yychar < 0 {
-               yychar = yylex1(yylex, &yylval)
+               yychar, yytoken = yylex1(yylex, &yylval)
        }
-       yyn += yychar
+       yyn += yytoken
        if yyn < 0 || yyn >= yyLast {
                goto yydefault
        }
        yyn = yyAct[yyn]
-       if yyChk[yyn] == yychar { /* valid shift */
+       if yyChk[yyn] == yytoken { /* valid shift */
                yychar = -1
+               yytoken = -1
                yyVAL = yylval
                yystate = yyn
                if Errflag > 0 {
@@ -475,7 +508,7 @@ yydefault:
        yyn = yyDef[yystate]
        if yyn == -2 {
                if yychar < 0 {
-                       yychar = yylex1(yylex, &yylval)
+                       yychar, yytoken = yylex1(yylex, &yylval)
                }
 
                /* look through exception table */
@@ -488,7 +521,7 @@ yydefault:
                }
                for xi += 2; ; xi += 2 {
                        yyn = yyExca[xi+0]
-                       if yyn < 0 || yyn == yychar {
+                       if yyn < 0 || yyn == yytoken {
                                break
                        }
                }
@@ -505,7 +538,7 @@ yydefault:
                        Nerrs++
                        if yyDebug >= 1 {
                                __yyfmt__.Printf("%s", yyStatname(yystate))
-                               __yyfmt__.Printf(" saw %s\n", yyTokname(yychar))
+                               __yyfmt__.Printf(" saw %s\n", yyTokname(yytoken))
                        }
                        fallthrough
 
@@ -533,12 +566,13 @@ yydefault:
 
                case 3: /* no shift yet; clobber input char */
                        if yyDebug >= 2 {
-                               __yyfmt__.Printf("error recovery discards %s\n", yyTokname(yychar))
+                               __yyfmt__.Printf("error recovery discards %s\n", yyTokname(yytoken))
                        }
-                       if yychar == yyEofCode {
+                       if yytoken == yyEofCode {
                                goto ret1
                        }
                        yychar = -1
+                       yytoken = -1
                        goto yynewstate /* try again in the same state */
                }
        }
@@ -579,339 +613,390 @@ yydefault:
        switch yynt {
 
        case 2:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:72
                {
                        stmtline = asm.Lineno
                }
        case 4:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:79
                {
-                       yyS[yypt-1].sym = asm.LabelLookup(yyS[yypt-1].sym)
-                       if yyS[yypt-1].sym.Type == LLAB && yyS[yypt-1].sym.Value != int64(asm.PC) {
-                               yyerror("redeclaration of %s (%s)", yyS[yypt-1].sym.Labelname, yyS[yypt-1].sym.Name)
+                       yyDollar[1].sym = asm.LabelLookup(yyDollar[1].sym)
+                       if yyDollar[1].sym.Type == LLAB && yyDollar[1].sym.Value != int64(asm.PC) {
+                               yyerror("redeclaration of %s (%s)", yyDollar[1].sym.Labelname, yyDollar[1].sym.Name)
                        }
-                       yyS[yypt-1].sym.Type = LLAB
-                       yyS[yypt-1].sym.Value = int64(asm.PC)
+                       yyDollar[1].sym.Type = LLAB
+                       yyDollar[1].sym.Value = int64(asm.PC)
                }
        case 9:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:94
                {
-                       yyS[yypt-2].sym.Type = LVAR
-                       yyS[yypt-2].sym.Value = yyS[yypt-0].lval
+                       yyDollar[1].sym.Type = LVAR
+                       yyDollar[1].sym.Value = yyDollar[3].lval
                }
        case 10:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:99
                {
-                       if yyS[yypt-2].sym.Value != yyS[yypt-0].lval {
-                               yyerror("redeclaration of %s", yyS[yypt-2].sym.Name)
+                       if yyDollar[1].sym.Value != yyDollar[3].lval {
+                               yyerror("redeclaration of %s", yyDollar[1].sym.Name)
                        }
-                       yyS[yypt-2].sym.Value = yyS[yypt-0].lval
+                       yyDollar[1].sym.Value = yyDollar[3].lval
                }
        case 11:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:105
                {
-                       outcode(int(yyS[yypt-1].lval), &yyS[yypt-0].addr2)
+                       outcode(int(yyDollar[1].lval), &yyDollar[2].addr2)
                }
        case 12:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:106
                {
-                       outcode(int(yyS[yypt-1].lval), &yyS[yypt-0].addr2)
+                       outcode(int(yyDollar[1].lval), &yyDollar[2].addr2)
                }
        case 13:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:107
                {
-                       outcode(int(yyS[yypt-1].lval), &yyS[yypt-0].addr2)
+                       outcode(int(yyDollar[1].lval), &yyDollar[2].addr2)
                }
        case 14:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:108
                {
-                       outcode(int(yyS[yypt-1].lval), &yyS[yypt-0].addr2)
+                       outcode(int(yyDollar[1].lval), &yyDollar[2].addr2)
                }
        case 15:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:109
                {
-                       outcode(int(yyS[yypt-1].lval), &yyS[yypt-0].addr2)
+                       outcode(int(yyDollar[1].lval), &yyDollar[2].addr2)
                }
        case 16:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:110
                {
-                       outcode(int(yyS[yypt-1].lval), &yyS[yypt-0].addr2)
+                       outcode(int(yyDollar[1].lval), &yyDollar[2].addr2)
                }
        case 19:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:113
                {
-                       outcode(int(yyS[yypt-1].lval), &yyS[yypt-0].addr2)
+                       outcode(int(yyDollar[1].lval), &yyDollar[2].addr2)
                }
        case 20:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:114
                {
-                       outcode(int(yyS[yypt-1].lval), &yyS[yypt-0].addr2)
+                       outcode(int(yyDollar[1].lval), &yyDollar[2].addr2)
                }
        case 21:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:115
                {
-                       outcode(int(yyS[yypt-1].lval), &yyS[yypt-0].addr2)
+                       outcode(int(yyDollar[1].lval), &yyDollar[2].addr2)
                }
        case 22:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:116
                {
-                       outcode(int(yyS[yypt-1].lval), &yyS[yypt-0].addr2)
+                       outcode(int(yyDollar[1].lval), &yyDollar[2].addr2)
                }
        case 23:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:117
                {
-                       outcode(int(yyS[yypt-1].lval), &yyS[yypt-0].addr2)
+                       outcode(int(yyDollar[1].lval), &yyDollar[2].addr2)
                }
        case 24:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:118
                {
-                       outcode(int(yyS[yypt-1].lval), &yyS[yypt-0].addr2)
+                       outcode(int(yyDollar[1].lval), &yyDollar[2].addr2)
                }
        case 25:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:119
                {
-                       outcode(int(yyS[yypt-1].lval), &yyS[yypt-0].addr2)
+                       outcode(int(yyDollar[1].lval), &yyDollar[2].addr2)
                }
        case 26:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:120
                {
-                       outcode(int(yyS[yypt-1].lval), &yyS[yypt-0].addr2)
+                       outcode(int(yyDollar[1].lval), &yyDollar[2].addr2)
                }
        case 28:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:122
                {
-                       outcode(int(yyS[yypt-1].lval), &yyS[yypt-0].addr2)
+                       outcode(int(yyDollar[1].lval), &yyDollar[2].addr2)
                }
        case 29:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:123
                {
-                       outcode(int(yyS[yypt-1].lval), &yyS[yypt-0].addr2)
+                       outcode(int(yyDollar[1].lval), &yyDollar[2].addr2)
                }
        case 30:
+               yyDollar = yyS[yypt-0 : yypt+1]
                //line a.y:126
                {
                        yyVAL.addr2.from = nullgen
                        yyVAL.addr2.to = nullgen
                }
        case 31:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:131
                {
                        yyVAL.addr2.from = nullgen
                        yyVAL.addr2.to = nullgen
                }
        case 32:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:138
                {
-                       yyVAL.addr2.from = yyS[yypt-2].addr
-                       yyVAL.addr2.to = yyS[yypt-0].addr
+                       yyVAL.addr2.from = yyDollar[1].addr
+                       yyVAL.addr2.to = yyDollar[3].addr
                }
        case 33:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:145
                {
-                       yyVAL.addr2.from = yyS[yypt-2].addr
-                       yyVAL.addr2.to = yyS[yypt-0].addr
+                       yyVAL.addr2.from = yyDollar[1].addr
+                       yyVAL.addr2.to = yyDollar[3].addr
                }
        case 34:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:152
                {
-                       yyVAL.addr2.from = yyS[yypt-1].addr
+                       yyVAL.addr2.from = yyDollar[1].addr
                        yyVAL.addr2.to = nullgen
                }
        case 35:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:157
                {
-                       yyVAL.addr2.from = yyS[yypt-0].addr
+                       yyVAL.addr2.from = yyDollar[1].addr
                        yyVAL.addr2.to = nullgen
                }
        case 36:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:164
                {
                        yyVAL.addr2.from = nullgen
-                       yyVAL.addr2.to = yyS[yypt-0].addr
+                       yyVAL.addr2.to = yyDollar[2].addr
                }
        case 37:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:169
                {
                        yyVAL.addr2.from = nullgen
-                       yyVAL.addr2.to = yyS[yypt-0].addr
+                       yyVAL.addr2.to = yyDollar[1].addr
                }
        case 38:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:176
                {
                        yyVAL.addr2.from = nullgen
-                       yyVAL.addr2.to = yyS[yypt-0].addr
+                       yyVAL.addr2.to = yyDollar[2].addr
                }
        case 39:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:181
                {
                        yyVAL.addr2.from = nullgen
-                       yyVAL.addr2.to = yyS[yypt-0].addr
+                       yyVAL.addr2.to = yyDollar[1].addr
                }
        case 40:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:186
                {
-                       yyVAL.addr2.from = yyS[yypt-2].addr
-                       yyVAL.addr2.to = yyS[yypt-0].addr
+                       yyVAL.addr2.from = yyDollar[1].addr
+                       yyVAL.addr2.to = yyDollar[3].addr
                }
        case 41:
+               yyDollar = yyS[yypt-6 : yypt+1]
                //line a.y:193
                {
                        var a Addr2
-                       a.from = yyS[yypt-4].addr
-                       a.to = yyS[yypt-0].addr
+                       a.from = yyDollar[2].addr
+                       a.to = yyDollar[6].addr
                        outcode(obj.ADATA, &a)
                        if asm.Pass > 1 {
                                lastpc.From3.Type = obj.TYPE_CONST
-                               lastpc.From3.Offset = yyS[yypt-2].lval
+                               lastpc.From3.Offset = yyDollar[4].lval
                        }
                }
        case 42:
+               yyDollar = yyS[yypt-5 : yypt+1]
                //line a.y:206
                {
-                       asm.Settext(yyS[yypt-3].addr.Sym)
-                       outcode(obj.ATEXT, &Addr2{yyS[yypt-3].addr, yyS[yypt-0].addr})
+                       asm.Settext(yyDollar[2].addr.Sym)
+                       outcode(obj.ATEXT, &Addr2{yyDollar[2].addr, yyDollar[5].addr})
                }
        case 43:
+               yyDollar = yyS[yypt-7 : yypt+1]
                //line a.y:211
                {
-                       asm.Settext(yyS[yypt-5].addr.Sym)
-                       outcode(obj.ATEXT, &Addr2{yyS[yypt-5].addr, yyS[yypt-0].addr})
+                       asm.Settext(yyDollar[2].addr.Sym)
+                       outcode(obj.ATEXT, &Addr2{yyDollar[2].addr, yyDollar[7].addr})
                        if asm.Pass > 1 {
                                lastpc.From3.Type = obj.TYPE_CONST
-                               lastpc.From3.Offset = yyS[yypt-3].lval
+                               lastpc.From3.Offset = yyDollar[4].lval
                        }
                }
        case 44:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:222
                {
-                       asm.Settext(yyS[yypt-2].addr.Sym)
-                       outcode(obj.AGLOBL, &Addr2{yyS[yypt-2].addr, yyS[yypt-0].addr})
+                       asm.Settext(yyDollar[2].addr.Sym)
+                       outcode(obj.AGLOBL, &Addr2{yyDollar[2].addr, yyDollar[4].addr})
                }
        case 45:
+               yyDollar = yyS[yypt-6 : yypt+1]
                //line a.y:227
                {
-                       asm.Settext(yyS[yypt-4].addr.Sym)
-                       outcode(obj.AGLOBL, &Addr2{yyS[yypt-4].addr, yyS[yypt-0].addr})
+                       asm.Settext(yyDollar[2].addr.Sym)
+                       outcode(obj.AGLOBL, &Addr2{yyDollar[2].addr, yyDollar[6].addr})
                        if asm.Pass > 1 {
                                lastpc.From3.Type = obj.TYPE_CONST
-                               lastpc.From3.Offset = yyS[yypt-2].lval
+                               lastpc.From3.Offset = yyDollar[4].lval
                        }
                }
        case 46:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:238
                {
                        yyVAL.addr2.from = nullgen
-                       yyVAL.addr2.to = yyS[yypt-0].addr
+                       yyVAL.addr2.to = yyDollar[2].addr
                }
        case 47:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:243
                {
                        yyVAL.addr2.from = nullgen
-                       yyVAL.addr2.to = yyS[yypt-0].addr
+                       yyVAL.addr2.to = yyDollar[1].addr
                }
        case 48:
                yyVAL.addr2 = yyS[yypt-0].addr2
        case 49:
                yyVAL.addr2 = yyS[yypt-0].addr2
        case 50:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:254
                {
-                       yyVAL.addr2.from = yyS[yypt-2].addr
-                       yyVAL.addr2.to = yyS[yypt-0].addr
+                       yyVAL.addr2.from = yyDollar[1].addr
+                       yyVAL.addr2.to = yyDollar[3].addr
                }
        case 51:
+               yyDollar = yyS[yypt-5 : yypt+1]
                //line a.y:259
                {
-                       yyVAL.addr2.from = yyS[yypt-4].addr
-                       yyVAL.addr2.to = yyS[yypt-2].addr
+                       yyVAL.addr2.from = yyDollar[1].addr
+                       yyVAL.addr2.to = yyDollar[3].addr
                        if yyVAL.addr2.from.Index != obj.TYPE_NONE {
                                yyerror("dp shift with lhs index")
                        }
-                       yyVAL.addr2.from.Index = int16(yyS[yypt-0].lval)
+                       yyVAL.addr2.from.Index = int16(yyDollar[5].lval)
                }
        case 52:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:270
                {
-                       yyVAL.addr2.from = yyS[yypt-2].addr
-                       yyVAL.addr2.to = yyS[yypt-0].addr
+                       yyVAL.addr2.from = yyDollar[1].addr
+                       yyVAL.addr2.to = yyDollar[3].addr
                }
        case 53:
+               yyDollar = yyS[yypt-5 : yypt+1]
                //line a.y:275
                {
-                       yyVAL.addr2.from = yyS[yypt-4].addr
-                       yyVAL.addr2.to = yyS[yypt-2].addr
+                       yyVAL.addr2.from = yyDollar[1].addr
+                       yyVAL.addr2.to = yyDollar[3].addr
                        if yyVAL.addr2.to.Index != obj.TYPE_NONE {
                                yyerror("dp move with lhs index")
                        }
-                       yyVAL.addr2.to.Index = int16(yyS[yypt-0].lval)
+                       yyVAL.addr2.to.Index = int16(yyDollar[5].lval)
                }
        case 54:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:286
                {
-                       yyVAL.addr2.from = yyS[yypt-1].addr
+                       yyVAL.addr2.from = yyDollar[1].addr
                        yyVAL.addr2.to = nullgen
                }
        case 55:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:291
                {
-                       yyVAL.addr2.from = yyS[yypt-0].addr
+                       yyVAL.addr2.from = yyDollar[1].addr
                        yyVAL.addr2.to = nullgen
                }
        case 56:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:296
                {
-                       yyVAL.addr2.from = yyS[yypt-2].addr
-                       yyVAL.addr2.to = yyS[yypt-0].addr
+                       yyVAL.addr2.from = yyDollar[1].addr
+                       yyVAL.addr2.to = yyDollar[3].addr
                }
        case 57:
+               yyDollar = yyS[yypt-5 : yypt+1]
                //line a.y:303
                {
-                       yyVAL.addr2.from = yyS[yypt-4].addr
-                       yyVAL.addr2.to = yyS[yypt-2].addr
-                       yyVAL.addr2.to.Offset = yyS[yypt-0].lval
+                       yyVAL.addr2.from = yyDollar[1].addr
+                       yyVAL.addr2.to = yyDollar[3].addr
+                       yyVAL.addr2.to.Offset = yyDollar[5].lval
                }
        case 58:
+               yyDollar = yyS[yypt-5 : yypt+1]
                //line a.y:311
                {
-                       yyVAL.addr2.from = yyS[yypt-2].addr
-                       yyVAL.addr2.to = yyS[yypt-0].addr
-                       if yyS[yypt-4].addr.Type != obj.TYPE_CONST {
+                       yyVAL.addr2.from = yyDollar[3].addr
+                       yyVAL.addr2.to = yyDollar[5].addr
+                       if yyDollar[1].addr.Type != obj.TYPE_CONST {
                                yyerror("illegal constant")
                        }
-                       yyVAL.addr2.to.Offset = yyS[yypt-4].addr.Offset
+                       yyVAL.addr2.to.Offset = yyDollar[1].addr.Offset
                }
        case 59:
+               yyDollar = yyS[yypt-0 : yypt+1]
                //line a.y:321
                {
                        yyVAL.addr2.from = nullgen
                        yyVAL.addr2.to = nullgen
                }
        case 60:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:326
                {
-                       yyVAL.addr2.from = yyS[yypt-0].addr
+                       yyVAL.addr2.from = yyDollar[1].addr
                        yyVAL.addr2.to = nullgen
                }
        case 61:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:333
                {
-                       if yyS[yypt-2].addr.Type != obj.TYPE_CONST || yyS[yypt-0].addr.Type != obj.TYPE_CONST {
+                       if yyDollar[1].addr.Type != obj.TYPE_CONST || yyDollar[3].addr.Type != obj.TYPE_CONST {
                                yyerror("arguments to asm.PCDATA must be integer constants")
                        }
-                       yyVAL.addr2.from = yyS[yypt-2].addr
-                       yyVAL.addr2.to = yyS[yypt-0].addr
+                       yyVAL.addr2.from = yyDollar[1].addr
+                       yyVAL.addr2.to = yyDollar[3].addr
                }
        case 62:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:343
                {
-                       if yyS[yypt-2].addr.Type != obj.TYPE_CONST {
+                       if yyDollar[1].addr.Type != obj.TYPE_CONST {
                                yyerror("index for FUNCDATA must be integer constant")
                        }
-                       if yyS[yypt-0].addr.Type != obj.TYPE_MEM || (yyS[yypt-0].addr.Name != obj.NAME_EXTERN && yyS[yypt-0].addr.Name != obj.NAME_STATIC) {
+                       if yyDollar[3].addr.Type != obj.TYPE_MEM || (yyDollar[3].addr.Name != obj.NAME_EXTERN && yyDollar[3].addr.Name != obj.NAME_STATIC) {
                                yyerror("value for FUNCDATA must be symbol reference")
                        }
-                       yyVAL.addr2.from = yyS[yypt-2].addr
-                       yyVAL.addr2.to = yyS[yypt-0].addr
+                       yyVAL.addr2.from = yyDollar[1].addr
+                       yyVAL.addr2.to = yyDollar[3].addr
                }
        case 63:
                yyVAL.addr = yyS[yypt-0].addr
@@ -922,14 +1007,16 @@ yydefault:
        case 66:
                yyVAL.addr = yyS[yypt-0].addr
        case 67:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:362
                {
-                       yyVAL.addr = yyS[yypt-0].addr
+                       yyVAL.addr = yyDollar[2].addr
                }
        case 68:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:366
                {
-                       yyVAL.addr = yyS[yypt-0].addr
+                       yyVAL.addr = yyDollar[2].addr
                }
        case 69:
                yyVAL.addr = yyS[yypt-0].addr
@@ -940,52 +1027,59 @@ yydefault:
        case 72:
                yyVAL.addr = yyS[yypt-0].addr
        case 73:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:378
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_BRANCH
-                       yyVAL.addr.Offset = yyS[yypt-3].lval + int64(asm.PC)
+                       yyVAL.addr.Offset = yyDollar[1].lval + int64(asm.PC)
                }
        case 74:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:384
                {
-                       yyS[yypt-1].sym = asm.LabelLookup(yyS[yypt-1].sym)
+                       yyDollar[1].sym = asm.LabelLookup(yyDollar[1].sym)
                        yyVAL.addr = nullgen
-                       if asm.Pass == 2 && yyS[yypt-1].sym.Type != LLAB {
-                               yyerror("undefined label: %s", yyS[yypt-1].sym.Labelname)
+                       if asm.Pass == 2 && yyDollar[1].sym.Type != LLAB {
+                               yyerror("undefined label: %s", yyDollar[1].sym.Labelname)
                        }
                        yyVAL.addr.Type = obj.TYPE_BRANCH
-                       yyVAL.addr.Offset = yyS[yypt-1].sym.Value + yyS[yypt-0].lval
+                       yyVAL.addr.Offset = yyDollar[1].sym.Value + yyDollar[2].lval
                }
        case 75:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:396
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_REG
-                       yyVAL.addr.Reg = int16(yyS[yypt-0].lval)
+                       yyVAL.addr.Reg = int16(yyDollar[1].lval)
                }
        case 76:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:402
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_REG
-                       yyVAL.addr.Reg = int16(yyS[yypt-0].lval)
+                       yyVAL.addr.Reg = int16(yyDollar[1].lval)
                }
        case 77:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:408
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_REG
-                       yyVAL.addr.Reg = int16(yyS[yypt-0].lval)
+                       yyVAL.addr.Reg = int16(yyDollar[1].lval)
                }
        case 78:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:414
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_REG
-                       yyVAL.addr.Reg = int16(yyS[yypt-0].lval)
+                       yyVAL.addr.Reg = int16(yyDollar[1].lval)
                }
        case 79:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:420
                {
                        yyVAL.addr = nullgen
@@ -993,30 +1087,34 @@ yydefault:
                        yyVAL.addr.Reg = x86.REG_SP
                }
        case 80:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:426
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_REG
-                       yyVAL.addr.Reg = int16(yyS[yypt-0].lval)
+                       yyVAL.addr.Reg = int16(yyDollar[1].lval)
                }
        case 81:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:432
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_REG
-                       yyVAL.addr.Reg = int16(yyS[yypt-0].lval)
+                       yyVAL.addr.Reg = int16(yyDollar[1].lval)
                }
        case 82:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:440
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_CONST
-                       yyVAL.addr.Offset = yyS[yypt-0].lval
+                       yyVAL.addr.Offset = yyDollar[2].lval
                }
        case 83:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:446
                {
-                       yyVAL.addr = yyS[yypt-0].addr
+                       yyVAL.addr = yyDollar[2].addr
                        yyVAL.addr.Type = obj.TYPE_ADDR
                        /*
                                if($2.Type == x86.D_AUTO || $2.Type == x86.D_PARAM)
@@ -1025,115 +1123,129 @@ yydefault:
                        */
                }
        case 84:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:455
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_SCONST
-                       yyVAL.addr.U.Sval = (yyS[yypt-0].sval + "\x00\x00\x00\x00\x00\x00\x00\x00")[:8]
+                       yyVAL.addr.U.Sval = (yyDollar[2].sval + "\x00\x00\x00\x00\x00\x00\x00\x00")[:8]
                }
        case 85:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:461
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_FCONST
-                       yyVAL.addr.U.Dval = yyS[yypt-0].dval
+                       yyVAL.addr.U.Dval = yyDollar[2].dval
                }
        case 86:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:467
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_FCONST
-                       yyVAL.addr.U.Dval = yyS[yypt-1].dval
+                       yyVAL.addr.U.Dval = yyDollar[3].dval
                }
        case 87:
+               yyDollar = yyS[yypt-5 : yypt+1]
                //line a.y:473
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_FCONST
-                       yyVAL.addr.U.Dval = -yyS[yypt-1].dval
+                       yyVAL.addr.U.Dval = -yyDollar[4].dval
                }
        case 88:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:479
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_FCONST
-                       yyVAL.addr.U.Dval = -yyS[yypt-0].dval
+                       yyVAL.addr.U.Dval = -yyDollar[3].dval
                }
        case 89:
                yyVAL.addr = yyS[yypt-0].addr
        case 90:
                yyVAL.addr = yyS[yypt-0].addr
        case 91:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:491
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_MEM
-                       yyVAL.addr.Offset = yyS[yypt-0].lval
+                       yyVAL.addr.Offset = yyDollar[1].lval
                }
        case 92:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:497
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_MEM
-                       yyVAL.addr.Reg = int16(yyS[yypt-1].lval)
-                       yyVAL.addr.Offset = yyS[yypt-3].lval
+                       yyVAL.addr.Reg = int16(yyDollar[3].lval)
+                       yyVAL.addr.Offset = yyDollar[1].lval
                }
        case 93:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:504
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_MEM
                        yyVAL.addr.Reg = x86.REG_SP
-                       yyVAL.addr.Offset = yyS[yypt-3].lval
+                       yyVAL.addr.Offset = yyDollar[1].lval
                }
        case 94:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:511
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_MEM
-                       yyVAL.addr.Reg = int16(yyS[yypt-1].lval)
-                       yyVAL.addr.Offset = yyS[yypt-3].lval
+                       yyVAL.addr.Reg = int16(yyDollar[3].lval)
+                       yyVAL.addr.Offset = yyDollar[1].lval
                }
        case 95:
+               yyDollar = yyS[yypt-6 : yypt+1]
                //line a.y:518
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_MEM
-                       yyVAL.addr.Offset = yyS[yypt-5].lval
-                       yyVAL.addr.Index = int16(yyS[yypt-3].lval)
-                       yyVAL.addr.Scale = int8(yyS[yypt-1].lval)
+                       yyVAL.addr.Offset = yyDollar[1].lval
+                       yyVAL.addr.Index = int16(yyDollar[3].lval)
+                       yyVAL.addr.Scale = int16(yyDollar[5].lval)
                        checkscale(yyVAL.addr.Scale)
                }
        case 96:
+               yyDollar = yyS[yypt-9 : yypt+1]
                //line a.y:527
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_MEM
-                       yyVAL.addr.Reg = int16(yyS[yypt-6].lval)
-                       yyVAL.addr.Offset = yyS[yypt-8].lval
-                       yyVAL.addr.Index = int16(yyS[yypt-3].lval)
-                       yyVAL.addr.Scale = int8(yyS[yypt-1].lval)
+                       yyVAL.addr.Reg = int16(yyDollar[3].lval)
+                       yyVAL.addr.Offset = yyDollar[1].lval
+                       yyVAL.addr.Index = int16(yyDollar[6].lval)
+                       yyVAL.addr.Scale = int16(yyDollar[8].lval)
                        checkscale(yyVAL.addr.Scale)
                }
        case 97:
+               yyDollar = yyS[yypt-9 : yypt+1]
                //line a.y:537
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_MEM
-                       yyVAL.addr.Reg = int16(yyS[yypt-6].lval)
-                       yyVAL.addr.Offset = yyS[yypt-8].lval
-                       yyVAL.addr.Index = int16(yyS[yypt-3].lval)
-                       yyVAL.addr.Scale = int8(yyS[yypt-1].lval)
+                       yyVAL.addr.Reg = int16(yyDollar[3].lval)
+                       yyVAL.addr.Offset = yyDollar[1].lval
+                       yyVAL.addr.Index = int16(yyDollar[6].lval)
+                       yyVAL.addr.Scale = int16(yyDollar[8].lval)
                        checkscale(yyVAL.addr.Scale)
                }
        case 98:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:547
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_MEM
-                       yyVAL.addr.Reg = int16(yyS[yypt-1].lval)
+                       yyVAL.addr.Reg = int16(yyDollar[2].lval)
                }
        case 99:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:553
                {
                        yyVAL.addr = nullgen
@@ -1141,73 +1253,83 @@ yydefault:
                        yyVAL.addr.Reg = x86.REG_SP
                }
        case 100:
+               yyDollar = yyS[yypt-5 : yypt+1]
                //line a.y:559
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_MEM
-                       yyVAL.addr.Index = int16(yyS[yypt-3].lval)
-                       yyVAL.addr.Scale = int8(yyS[yypt-1].lval)
+                       yyVAL.addr.Index = int16(yyDollar[2].lval)
+                       yyVAL.addr.Scale = int16(yyDollar[4].lval)
                        checkscale(yyVAL.addr.Scale)
                }
        case 101:
+               yyDollar = yyS[yypt-8 : yypt+1]
                //line a.y:567
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_MEM
-                       yyVAL.addr.Reg = int16(yyS[yypt-6].lval)
-                       yyVAL.addr.Index = int16(yyS[yypt-3].lval)
-                       yyVAL.addr.Scale = int8(yyS[yypt-1].lval)
+                       yyVAL.addr.Reg = int16(yyDollar[2].lval)
+                       yyVAL.addr.Index = int16(yyDollar[5].lval)
+                       yyVAL.addr.Scale = int16(yyDollar[7].lval)
                        checkscale(yyVAL.addr.Scale)
                }
        case 102:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:578
                {
-                       yyVAL.addr = yyS[yypt-0].addr
+                       yyVAL.addr = yyDollar[1].addr
                }
        case 103:
+               yyDollar = yyS[yypt-6 : yypt+1]
                //line a.y:582
                {
-                       yyVAL.addr = yyS[yypt-5].addr
-                       yyVAL.addr.Index = int16(yyS[yypt-3].lval)
-                       yyVAL.addr.Scale = int8(yyS[yypt-1].lval)
+                       yyVAL.addr = yyDollar[1].addr
+                       yyVAL.addr.Index = int16(yyDollar[3].lval)
+                       yyVAL.addr.Scale = int16(yyDollar[5].lval)
                        checkscale(yyVAL.addr.Scale)
                }
        case 104:
+               yyDollar = yyS[yypt-5 : yypt+1]
                //line a.y:591
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_MEM
-                       yyVAL.addr.Name = int8(yyS[yypt-1].lval)
-                       yyVAL.addr.Sym = obj.Linklookup(asm.Ctxt, yyS[yypt-4].sym.Name, 0)
-                       yyVAL.addr.Offset = yyS[yypt-3].lval
+                       yyVAL.addr.Name = int8(yyDollar[4].lval)
+                       yyVAL.addr.Sym = obj.Linklookup(asm.Ctxt, yyDollar[1].sym.Name, 0)
+                       yyVAL.addr.Offset = yyDollar[2].lval
                }
        case 105:
+               yyDollar = yyS[yypt-7 : yypt+1]
                //line a.y:599
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_MEM
                        yyVAL.addr.Name = obj.NAME_STATIC
-                       yyVAL.addr.Sym = obj.Linklookup(asm.Ctxt, yyS[yypt-6].sym.Name, 1)
-                       yyVAL.addr.Offset = yyS[yypt-3].lval
+                       yyVAL.addr.Sym = obj.Linklookup(asm.Ctxt, yyDollar[1].sym.Name, 1)
+                       yyVAL.addr.Offset = yyDollar[4].lval
                }
        case 106:
+               yyDollar = yyS[yypt-0 : yypt+1]
                //line a.y:608
                {
                        yyVAL.lval = 0
                }
        case 107:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:612
                {
-                       yyVAL.lval = yyS[yypt-0].lval
+                       yyVAL.lval = yyDollar[2].lval
                }
        case 108:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:616
                {
-                       yyVAL.lval = -yyS[yypt-0].lval
+                       yyVAL.lval = -yyDollar[2].lval
                }
        case 109:
                yyVAL.lval = yyS[yypt-0].lval
        case 110:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:623
                {
                        yyVAL.lval = obj.NAME_AUTO
@@ -1217,113 +1339,132 @@ yydefault:
        case 112:
                yyVAL.lval = yyS[yypt-0].lval
        case 113:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:631
                {
-                       yyVAL.lval = yyS[yypt-0].sym.Value
+                       yyVAL.lval = yyDollar[1].sym.Value
                }
        case 114:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:635
                {
-                       yyVAL.lval = -yyS[yypt-0].lval
+                       yyVAL.lval = -yyDollar[2].lval
                }
        case 115:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:639
                {
-                       yyVAL.lval = yyS[yypt-0].lval
+                       yyVAL.lval = yyDollar[2].lval
                }
        case 116:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:643
                {
-                       yyVAL.lval = ^yyS[yypt-0].lval
+                       yyVAL.lval = ^yyDollar[2].lval
                }
        case 117:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:647
                {
-                       yyVAL.lval = yyS[yypt-1].lval
+                       yyVAL.lval = yyDollar[2].lval
                }
        case 118:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:653
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_TEXTSIZE
-                       yyVAL.addr.Offset = yyS[yypt-0].lval
+                       yyVAL.addr.Offset = yyDollar[1].lval
                        yyVAL.addr.U.Argsize = obj.ArgsSizeUnknown
                }
        case 119:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:660
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_TEXTSIZE
-                       yyVAL.addr.Offset = -yyS[yypt-0].lval
+                       yyVAL.addr.Offset = -yyDollar[2].lval
                        yyVAL.addr.U.Argsize = obj.ArgsSizeUnknown
                }
        case 120:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:667
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_TEXTSIZE
-                       yyVAL.addr.Offset = yyS[yypt-2].lval
-                       yyVAL.addr.U.Argsize = int32(yyS[yypt-0].lval)
+                       yyVAL.addr.Offset = yyDollar[1].lval
+                       yyVAL.addr.U.Argsize = int32(yyDollar[3].lval)
                }
        case 121:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:674
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_TEXTSIZE
-                       yyVAL.addr.Offset = -yyS[yypt-2].lval
-                       yyVAL.addr.U.Argsize = int32(yyS[yypt-0].lval)
+                       yyVAL.addr.Offset = -yyDollar[2].lval
+                       yyVAL.addr.U.Argsize = int32(yyDollar[4].lval)
                }
        case 122:
                yyVAL.lval = yyS[yypt-0].lval
        case 123:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:684
                {
-                       yyVAL.lval = yyS[yypt-2].lval + yyS[yypt-0].lval
+                       yyVAL.lval = yyDollar[1].lval + yyDollar[3].lval
                }
        case 124:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:688
                {
-                       yyVAL.lval = yyS[yypt-2].lval - yyS[yypt-0].lval
+                       yyVAL.lval = yyDollar[1].lval - yyDollar[3].lval
                }
        case 125:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:692
                {
-                       yyVAL.lval = yyS[yypt-2].lval * yyS[yypt-0].lval
+                       yyVAL.lval = yyDollar[1].lval * yyDollar[3].lval
                }
        case 126:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:696
                {
-                       yyVAL.lval = yyS[yypt-2].lval / yyS[yypt-0].lval
+                       yyVAL.lval = yyDollar[1].lval / yyDollar[3].lval
                }
        case 127:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:700
                {
-                       yyVAL.lval = yyS[yypt-2].lval % yyS[yypt-0].lval
+                       yyVAL.lval = yyDollar[1].lval % yyDollar[3].lval
                }
        case 128:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:704
                {
-                       yyVAL.lval = yyS[yypt-3].lval << uint(yyS[yypt-0].lval)
+                       yyVAL.lval = yyDollar[1].lval << uint(yyDollar[4].lval)
                }
        case 129:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:708
                {
-                       yyVAL.lval = yyS[yypt-3].lval >> uint(yyS[yypt-0].lval)
+                       yyVAL.lval = yyDollar[1].lval >> uint(yyDollar[4].lval)
                }
        case 130:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:712
                {
-                       yyVAL.lval = yyS[yypt-2].lval & yyS[yypt-0].lval
+                       yyVAL.lval = yyDollar[1].lval & yyDollar[3].lval
                }
        case 131:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:716
                {
-                       yyVAL.lval = yyS[yypt-2].lval ^ yyS[yypt-0].lval
+                       yyVAL.lval = yyDollar[1].lval ^ yyDollar[3].lval
                }
        case 132:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:720
                {
-                       yyVAL.lval = yyS[yypt-2].lval | yyS[yypt-0].lval
+                       yyVAL.lval = yyDollar[1].lval | yyDollar[3].lval
                }
        }
        goto yystack /* stack new state and value */

diff --git a/src/cmd/6g/cgen.go b/src/cmd/6g/cgen.go
index 58deffa6edfe229ec43338f865c64002da2e0ddb..cb16039dff42d4eff2fd26a12a1e2355367da241 100644 (file)
--- a/src/cmd/6g/cgen.go
+++ b/src/cmd/6g/cgen.go
@@ -838,7 +838,7 @@ func agenr(n *gc.Node, a *gc.Node, res *gc.Node) {
                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.Scale = int16(w)
                        p1.From.Index = p1.From.Reg
                        p1.From.Reg = p1.To.Reg
                } else {

diff --git a/src/cmd/6g/gsubr.go b/src/cmd/6g/gsubr.go
index a8e47d3fd7520a05129aa014c4ad80fbd7652d9d..4a1edf777a6ac9e1098a0ea4ba87fd2e4dba8275 100644 (file)
--- a/src/cmd/6g/gsubr.go
+++ b/src/cmd/6g/gsubr.go
@@ -89,12 +89,12 @@ func gclean() {
 
        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))
+                       gc.Yyerror("reg %v left allocated\n", obj.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))
+                       gc.Yyerror("reg %v left allocated\n", obj.Rconv(i))
                }
        }
 }

diff --git a/src/cmd/8a/a.y b/src/cmd/8a/a.y
index 906ad331df3d91b6175074414f583045546b1165..384d8e648f626f0cd5f2aa295970530256a5a2ec 100644 (file)
--- a/src/cmd/8a/a.y
+++ b/src/cmd/8a/a.y
@@ -534,7 +534,7 @@ omem:
                $$.Type = obj.TYPE_MEM
                $$.Offset = $1;
                $$.Index = int16($3);
-               $$.Scale = int8($5);
+               $$.Scale = int16($5);
                checkscale($$.Scale);
        }
 |      con '(' LLREG ')' '(' LLREG '*' con ')'
@@ -544,7 +544,7 @@ omem:
                $$.Reg = int16($3)
                $$.Offset = $1;
                $$.Index = int16($6);
-               $$.Scale = int8($8);
+               $$.Scale = int16($8);
                checkscale($$.Scale);
        }
 |      con '(' LLREG ')' '(' LSREG '*' con ')'
@@ -554,7 +554,7 @@ omem:
                $$.Reg = int16($3)
                $$.Offset = $1;
                $$.Index = int16($6);
-               $$.Scale = int8($8);
+               $$.Scale = int16($8);
                checkscale($$.Scale);
        }
 |      '(' LLREG ')'
@@ -581,7 +581,7 @@ omem:
                $$ = nullgen;
                $$.Type = obj.TYPE_MEM
                $$.Index = int16($2);
-               $$.Scale = int8($4);
+               $$.Scale = int16($4);
                checkscale($$.Scale);
        }
 |      '(' LLREG ')' '(' LLREG '*' con ')'
@@ -590,7 +590,7 @@ omem:
                $$.Type = obj.TYPE_MEM
                $$.Reg = int16($2)
                $$.Index = int16($5);
-               $$.Scale = int8($7);
+               $$.Scale = int16($7);
                checkscale($$.Scale);
        }
 
@@ -603,7 +603,7 @@ nmem:
        {
                $$ = $1;
                $$.Index = int16($3);
-               $$.Scale = int8($5);
+               $$.Scale = int16($5);
                checkscale($$.Scale);
        }
 

diff --git a/src/cmd/8a/lex.go b/src/cmd/8a/lex.go
index bbd8610ec4f05df977a4d87b7ddfe0f1dba38e46..d4b81108d6fd97f615e33221def7c5b63dd8c466 100644 (file)
--- a/src/cmd/8a/lex.go
+++ b/src/cmd/8a/lex.go
@@ -706,7 +706,7 @@ func cinit() {
        nullgen.Index = i386.REG_NONE
 }
 
-func checkscale(scale int8) {
+func checkscale(scale int16) {
        switch scale {
        case 1,
                2,

diff --git a/src/cmd/8a/y.go b/src/cmd/8a/y.go
index 82c8a5fb2e5769667958a368bbb20aff7672f4f1..19751780d77aa5e1b74952bfd755cfebec75e355 100644 (file)
--- a/src/cmd/8a/y.go
+++ b/src/cmd/8a/y.go
@@ -353,6 +353,26 @@ type yyLexer interface {
        Error(s string)
 }
 
+type yyParser interface {
+       Parse(yyLexer) int
+       Lookahead() int
+}
+
+type yyParserImpl struct {
+       lookahead func() int
+}
+
+func (p *yyParserImpl) Lookahead() int {
+       return p.lookahead()
+}
+
+func yyNewParser() yyParser {
+       p := &yyParserImpl{
+               lookahead: func() int { return -1 },
+       }
+       return p
+}
+
 const yyFlag = -1000
 
 func yyTokname(c int) string {
@@ -374,51 +394,63 @@ func yyStatname(s int) string {
        return __yyfmt__.Sprintf("state-%v", s)
 }
 
-func yylex1(lex yyLexer, lval *yySymType) int {
-       c := 0
-       char := lex.Lex(lval)
+func yylex1(lex yyLexer, lval *yySymType) (char, token int) {
+       token = 0
+       char = lex.Lex(lval)
        if char <= 0 {
-               c = yyTok1[0]
+               token = yyTok1[0]
                goto out
        }
        if char < len(yyTok1) {
-               c = yyTok1[char]
+               token = yyTok1[char]
                goto out
        }
        if char >= yyPrivate {
                if char < yyPrivate+len(yyTok2) {
-                       c = yyTok2[char-yyPrivate]
+                       token = yyTok2[char-yyPrivate]
                        goto out
                }
        }
        for i := 0; i < len(yyTok3); i += 2 {
-               c = yyTok3[i+0]
-               if c == char {
-                       c = yyTok3[i+1]
+               token = yyTok3[i+0]
+               if token == char {
+                       token = yyTok3[i+1]
                        goto out
                }
        }
 
 out:
-       if c == 0 {
-               c = yyTok2[1] /* unknown char */
+       if token == 0 {
+               token = yyTok2[1] /* unknown char */
        }
        if yyDebug >= 3 {
-               __yyfmt__.Printf("lex %s(%d)\n", yyTokname(c), uint(char))
+               __yyfmt__.Printf("lex %s(%d)\n", yyTokname(token), uint(char))
        }
-       return c
+       return char, token
 }
 
 func yyParse(yylex yyLexer) int {
+       return yyNewParser().Parse(yylex)
+}
+
+func (yyrcvr *yyParserImpl) Parse(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
+       yyrcvr.lookahead = func() int { return yychar }
+       defer func() {
+               // Make sure we report no lookahead when not parsing.
+               yychar = -1
+               yytoken = -1
+       }()
        yyp := -1
        goto yystack
 
@@ -431,7 +463,7 @@ ret1:
 yystack:
        /* put a state and value onto the stack */
        if yyDebug >= 4 {
-               __yyfmt__.Printf("char %v in %v\n", yyTokname(yychar), yyStatname(yystate))
+               __yyfmt__.Printf("char %v in %v\n", yyTokname(yytoken), yyStatname(yystate))
        }
 
        yyp++
@@ -449,15 +481,16 @@ yynewstate:
                goto yydefault /* simple state */
        }
        if yychar < 0 {
-               yychar = yylex1(yylex, &yylval)
+               yychar, yytoken = yylex1(yylex, &yylval)
        }
-       yyn += yychar
+       yyn += yytoken
        if yyn < 0 || yyn >= yyLast {
                goto yydefault
        }
        yyn = yyAct[yyn]
-       if yyChk[yyn] == yychar { /* valid shift */
+       if yyChk[yyn] == yytoken { /* valid shift */
                yychar = -1
+               yytoken = -1
                yyVAL = yylval
                yystate = yyn
                if Errflag > 0 {
@@ -471,7 +504,7 @@ yydefault:
        yyn = yyDef[yystate]
        if yyn == -2 {
                if yychar < 0 {
-                       yychar = yylex1(yylex, &yylval)
+                       yychar, yytoken = yylex1(yylex, &yylval)
                }
 
                /* look through exception table */
@@ -484,7 +517,7 @@ yydefault:
                }
                for xi += 2; ; xi += 2 {
                        yyn = yyExca[xi+0]
-                       if yyn < 0 || yyn == yychar {
+                       if yyn < 0 || yyn == yytoken {
                                break
                        }
                }
@@ -501,7 +534,7 @@ yydefault:
                        Nerrs++
                        if yyDebug >= 1 {
                                __yyfmt__.Printf("%s", yyStatname(yystate))
-                               __yyfmt__.Printf(" saw %s\n", yyTokname(yychar))
+                               __yyfmt__.Printf(" saw %s\n", yyTokname(yytoken))
                        }
                        fallthrough
 
@@ -529,12 +562,13 @@ yydefault:
 
                case 3: /* no shift yet; clobber input char */
                        if yyDebug >= 2 {
-                               __yyfmt__.Printf("error recovery discards %s\n", yyTokname(yychar))
+                               __yyfmt__.Printf("error recovery discards %s\n", yyTokname(yytoken))
                        }
-                       if yychar == yyEofCode {
+                       if yytoken == yyEofCode {
                                goto ret1
                        }
                        yychar = -1
+                       yytoken = -1
                        goto yynewstate /* try again in the same state */
                }
        }
@@ -575,233 +609,271 @@ yydefault:
        switch yynt {
 
        case 2:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:74
                {
                        stmtline = asm.Lineno
                }
        case 4:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:81
                {
-                       yyS[yypt-1].sym = asm.LabelLookup(yyS[yypt-1].sym)
-                       if yyS[yypt-1].sym.Type == LLAB && yyS[yypt-1].sym.Value != int64(asm.PC) {
-                               yyerror("redeclaration of %s", yyS[yypt-1].sym.Labelname)
+                       yyDollar[1].sym = asm.LabelLookup(yyDollar[1].sym)
+                       if yyDollar[1].sym.Type == LLAB && yyDollar[1].sym.Value != int64(asm.PC) {
+                               yyerror("redeclaration of %s", yyDollar[1].sym.Labelname)
                        }
-                       yyS[yypt-1].sym.Type = LLAB
-                       yyS[yypt-1].sym.Value = int64(asm.PC)
+                       yyDollar[1].sym.Type = LLAB
+                       yyDollar[1].sym.Value = int64(asm.PC)
                }
        case 9:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:96
                {
-                       yyS[yypt-2].sym.Type = LVAR
-                       yyS[yypt-2].sym.Value = yyS[yypt-0].lval
+                       yyDollar[1].sym.Type = LVAR
+                       yyDollar[1].sym.Value = yyDollar[3].lval
                }
        case 10:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:101
                {
-                       if yyS[yypt-2].sym.Value != int64(yyS[yypt-0].lval) {
-                               yyerror("redeclaration of %s", yyS[yypt-2].sym.Name)
+                       if yyDollar[1].sym.Value != int64(yyDollar[3].lval) {
+                               yyerror("redeclaration of %s", yyDollar[1].sym.Name)
                        }
-                       yyS[yypt-2].sym.Value = yyS[yypt-0].lval
+                       yyDollar[1].sym.Value = yyDollar[3].lval
                }
        case 11:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:107
                {
-                       outcode(int(yyS[yypt-1].lval), &yyS[yypt-0].addr2)
+                       outcode(int(yyDollar[1].lval), &yyDollar[2].addr2)
                }
        case 12:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:108
                {
-                       outcode(int(yyS[yypt-1].lval), &yyS[yypt-0].addr2)
+                       outcode(int(yyDollar[1].lval), &yyDollar[2].addr2)
                }
        case 13:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:109
                {
-                       outcode(int(yyS[yypt-1].lval), &yyS[yypt-0].addr2)
+                       outcode(int(yyDollar[1].lval), &yyDollar[2].addr2)
                }
        case 14:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:110
                {
-                       outcode(int(yyS[yypt-1].lval), &yyS[yypt-0].addr2)
+                       outcode(int(yyDollar[1].lval), &yyDollar[2].addr2)
                }
        case 15:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:111
                {
-                       outcode(int(yyS[yypt-1].lval), &yyS[yypt-0].addr2)
+                       outcode(int(yyDollar[1].lval), &yyDollar[2].addr2)
                }
        case 16:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:112
                {
-                       outcode(int(yyS[yypt-1].lval), &yyS[yypt-0].addr2)
+                       outcode(int(yyDollar[1].lval), &yyDollar[2].addr2)
                }
        case 19:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:115
                {
-                       outcode(int(yyS[yypt-1].lval), &yyS[yypt-0].addr2)
+                       outcode(int(yyDollar[1].lval), &yyDollar[2].addr2)
                }
        case 20:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:116
                {
-                       outcode(int(yyS[yypt-1].lval), &yyS[yypt-0].addr2)
+                       outcode(int(yyDollar[1].lval), &yyDollar[2].addr2)
                }
        case 21:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:117
                {
-                       outcode(int(yyS[yypt-1].lval), &yyS[yypt-0].addr2)
+                       outcode(int(yyDollar[1].lval), &yyDollar[2].addr2)
                }
        case 22:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:118
                {
-                       outcode(int(yyS[yypt-1].lval), &yyS[yypt-0].addr2)
+                       outcode(int(yyDollar[1].lval), &yyDollar[2].addr2)
                }
        case 23:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:119
                {
-                       outcode(int(yyS[yypt-1].lval), &yyS[yypt-0].addr2)
+                       outcode(int(yyDollar[1].lval), &yyDollar[2].addr2)
                }
        case 25:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:121
                {
-                       outcode(int(yyS[yypt-1].lval), &yyS[yypt-0].addr2)
+                       outcode(int(yyDollar[1].lval), &yyDollar[2].addr2)
                }
        case 26:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:122
                {
-                       outcode(int(yyS[yypt-1].lval), &yyS[yypt-0].addr2)
+                       outcode(int(yyDollar[1].lval), &yyDollar[2].addr2)
                }
        case 27:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:123
                {
-                       outcode(int(yyS[yypt-1].lval), &yyS[yypt-0].addr2)
+                       outcode(int(yyDollar[1].lval), &yyDollar[2].addr2)
                }
        case 28:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:124
                {
-                       outcode(int(yyS[yypt-1].lval), &yyS[yypt-0].addr2)
+                       outcode(int(yyDollar[1].lval), &yyDollar[2].addr2)
                }
        case 29:
+               yyDollar = yyS[yypt-0 : yypt+1]
                //line a.y:127
                {
                        yyVAL.addr2.from = nullgen
                        yyVAL.addr2.to = nullgen
                }
        case 30:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:132
                {
                        yyVAL.addr2.from = nullgen
                        yyVAL.addr2.to = nullgen
                }
        case 31:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:139
                {
-                       yyVAL.addr2.from = yyS[yypt-2].addr
-                       yyVAL.addr2.to = yyS[yypt-0].addr
+                       yyVAL.addr2.from = yyDollar[1].addr
+                       yyVAL.addr2.to = yyDollar[3].addr
                }
        case 32:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:146
                {
-                       yyVAL.addr2.from = yyS[yypt-2].addr
-                       yyVAL.addr2.to = yyS[yypt-0].addr
+                       yyVAL.addr2.from = yyDollar[1].addr
+                       yyVAL.addr2.to = yyDollar[3].addr
                }
        case 33:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:153
                {
-                       yyVAL.addr2.from = yyS[yypt-1].addr
+                       yyVAL.addr2.from = yyDollar[1].addr
                        yyVAL.addr2.to = nullgen
                }
        case 34:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:158
                {
-                       yyVAL.addr2.from = yyS[yypt-0].addr
+                       yyVAL.addr2.from = yyDollar[1].addr
                        yyVAL.addr2.to = nullgen
                }
        case 35:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:165
                {
                        yyVAL.addr2.from = nullgen
-                       yyVAL.addr2.to = yyS[yypt-0].addr
+                       yyVAL.addr2.to = yyDollar[2].addr
                }
        case 36:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:170
                {
                        yyVAL.addr2.from = nullgen
-                       yyVAL.addr2.to = yyS[yypt-0].addr
+                       yyVAL.addr2.to = yyDollar[1].addr
                }
        case 37:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:177
                {
                        yyVAL.addr2.from = nullgen
-                       yyVAL.addr2.to = yyS[yypt-0].addr
+                       yyVAL.addr2.to = yyDollar[2].addr
                }
        case 38:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:182
                {
                        yyVAL.addr2.from = nullgen
-                       yyVAL.addr2.to = yyS[yypt-0].addr
+                       yyVAL.addr2.to = yyDollar[1].addr
                }
        case 39:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:187
                {
-                       yyVAL.addr2.from = yyS[yypt-2].addr
-                       yyVAL.addr2.to = yyS[yypt-0].addr
+                       yyVAL.addr2.from = yyDollar[1].addr
+                       yyVAL.addr2.to = yyDollar[3].addr
                }
        case 40:
+               yyDollar = yyS[yypt-6 : yypt+1]
                //line a.y:194
                {
-                       outcode(obj.ADATA, &Addr2{yyS[yypt-4].addr, yyS[yypt-0].addr})
+                       outcode(obj.ADATA, &Addr2{yyDollar[2].addr, yyDollar[6].addr})
                        if asm.Pass > 1 {
                                lastpc.From3.Type = obj.TYPE_CONST
-                               lastpc.From3.Offset = yyS[yypt-2].lval
+                               lastpc.From3.Offset = yyDollar[4].lval
                        }
                }
        case 41:
+               yyDollar = yyS[yypt-5 : yypt+1]
                //line a.y:204
                {
-                       asm.Settext(yyS[yypt-3].addr.Sym)
-                       outcode(obj.ATEXT, &Addr2{yyS[yypt-3].addr, yyS[yypt-0].addr})
+                       asm.Settext(yyDollar[2].addr.Sym)
+                       outcode(obj.ATEXT, &Addr2{yyDollar[2].addr, yyDollar[5].addr})
                }
        case 42:
+               yyDollar = yyS[yypt-7 : yypt+1]
                //line a.y:209
                {
-                       asm.Settext(yyS[yypt-5].addr.Sym)
-                       outcode(obj.ATEXT, &Addr2{yyS[yypt-5].addr, yyS[yypt-0].addr})
+                       asm.Settext(yyDollar[2].addr.Sym)
+                       outcode(obj.ATEXT, &Addr2{yyDollar[2].addr, yyDollar[7].addr})
                        if asm.Pass > 1 {
                                lastpc.From3.Type = obj.TYPE_CONST
-                               lastpc.From3.Offset = yyS[yypt-3].lval
+                               lastpc.From3.Offset = yyDollar[4].lval
                        }
                }
        case 43:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:220
                {
-                       asm.Settext(yyS[yypt-2].addr.Sym)
-                       outcode(obj.AGLOBL, &Addr2{yyS[yypt-2].addr, yyS[yypt-0].addr})
+                       asm.Settext(yyDollar[2].addr.Sym)
+                       outcode(obj.AGLOBL, &Addr2{yyDollar[2].addr, yyDollar[4].addr})
                }
        case 44:
+               yyDollar = yyS[yypt-6 : yypt+1]
                //line a.y:225
                {
-                       asm.Settext(yyS[yypt-4].addr.Sym)
-                       outcode(obj.AGLOBL, &Addr2{yyS[yypt-4].addr, yyS[yypt-0].addr})
+                       asm.Settext(yyDollar[2].addr.Sym)
+                       outcode(obj.AGLOBL, &Addr2{yyDollar[2].addr, yyDollar[6].addr})
                        if asm.Pass > 1 {
                                lastpc.From3.Type = obj.TYPE_CONST
-                               lastpc.From3.Offset = yyS[yypt-2].lval
+                               lastpc.From3.Offset = yyDollar[4].lval
                        }
                }
        case 45:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:237
                {
                        yyVAL.addr2.from = nullgen
-                       yyVAL.addr2.to = yyS[yypt-0].addr
+                       yyVAL.addr2.to = yyDollar[2].addr
                }
        case 46:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:242
                {
                        yyVAL.addr2.from = nullgen
-                       yyVAL.addr2.to = yyS[yypt-0].addr
+                       yyVAL.addr2.to = yyDollar[1].addr
                }
        case 47:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:247
                {
                        yyVAL.addr2.from = nullgen
-                       yyVAL.addr2.to = yyS[yypt-0].addr
+                       yyVAL.addr2.to = yyDollar[2].addr
                        yyVAL.addr2.to.Type = obj.TYPE_INDIR
                }
        case 48:
@@ -809,92 +881,103 @@ yydefault:
        case 49:
                yyVAL.addr2 = yyS[yypt-0].addr2
        case 50:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:259
                {
-                       yyVAL.addr2.from = yyS[yypt-2].addr
-                       yyVAL.addr2.to = yyS[yypt-0].addr
+                       yyVAL.addr2.from = yyDollar[1].addr
+                       yyVAL.addr2.to = yyDollar[3].addr
                }
        case 51:
+               yyDollar = yyS[yypt-5 : yypt+1]
                //line a.y:264
                {
-                       yyVAL.addr2.from = yyS[yypt-4].addr
-                       yyVAL.addr2.to = yyS[yypt-2].addr
+                       yyVAL.addr2.from = yyDollar[1].addr
+                       yyVAL.addr2.to = yyDollar[3].addr
                        if yyVAL.addr2.from.Index != obj.TYPE_NONE {
                                yyerror("dp shift with lhs index")
                        }
-                       yyVAL.addr2.from.Index = int16(yyS[yypt-0].lval)
+                       yyVAL.addr2.from.Index = int16(yyDollar[5].lval)
                }
        case 52:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:275
                {
-                       yyVAL.addr2.from = yyS[yypt-2].addr
-                       yyVAL.addr2.to = yyS[yypt-0].addr
+                       yyVAL.addr2.from = yyDollar[1].addr
+                       yyVAL.addr2.to = yyDollar[3].addr
                }
        case 53:
+               yyDollar = yyS[yypt-5 : yypt+1]
                //line a.y:280
                {
-                       yyVAL.addr2.from = yyS[yypt-4].addr
-                       yyVAL.addr2.to = yyS[yypt-2].addr
+                       yyVAL.addr2.from = yyDollar[1].addr
+                       yyVAL.addr2.to = yyDollar[3].addr
                        if yyVAL.addr2.to.Index != obj.TYPE_NONE {
                                yyerror("dp move with lhs index")
                        }
-                       yyVAL.addr2.to.Index = int16(yyS[yypt-0].lval)
+                       yyVAL.addr2.to.Index = int16(yyDollar[5].lval)
                }
        case 54:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:291
                {
-                       yyVAL.addr2.from = yyS[yypt-1].addr
+                       yyVAL.addr2.from = yyDollar[1].addr
                        yyVAL.addr2.to = nullgen
                }
        case 55:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:296
                {
-                       yyVAL.addr2.from = yyS[yypt-0].addr
+                       yyVAL.addr2.from = yyDollar[1].addr
                        yyVAL.addr2.to = nullgen
                }
        case 56:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:301
                {
-                       yyVAL.addr2.from = yyS[yypt-2].addr
-                       yyVAL.addr2.to = yyS[yypt-0].addr
+                       yyVAL.addr2.from = yyDollar[1].addr
+                       yyVAL.addr2.to = yyDollar[3].addr
                }
        case 57:
+               yyDollar = yyS[yypt-5 : yypt+1]
                //line a.y:308
                {
-                       yyVAL.addr2.from = yyS[yypt-4].addr
-                       yyVAL.addr2.to = yyS[yypt-2].addr
-                       yyVAL.addr2.to.Offset = yyS[yypt-0].lval
+                       yyVAL.addr2.from = yyDollar[1].addr
+                       yyVAL.addr2.to = yyDollar[3].addr
+                       yyVAL.addr2.to.Offset = yyDollar[5].lval
                }
        case 58:
+               yyDollar = yyS[yypt-5 : yypt+1]
                //line a.y:316
                {
-                       yyVAL.addr2.from = yyS[yypt-2].addr
-                       yyVAL.addr2.to = yyS[yypt-0].addr
-                       if yyS[yypt-4].addr.Type != obj.TYPE_CONST {
+                       yyVAL.addr2.from = yyDollar[3].addr
+                       yyVAL.addr2.to = yyDollar[5].addr
+                       if yyDollar[1].addr.Type != obj.TYPE_CONST {
                                yyerror("illegal constant")
                        }
-                       yyVAL.addr2.to.Offset = yyS[yypt-4].addr.Offset
+                       yyVAL.addr2.to.Offset = yyDollar[1].addr.Offset
                }
        case 59:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:327
                {
-                       if yyS[yypt-2].addr.Type != obj.TYPE_CONST || yyS[yypt-0].addr.Type != obj.TYPE_CONST {
+                       if yyDollar[1].addr.Type != obj.TYPE_CONST || yyDollar[3].addr.Type != obj.TYPE_CONST {
                                yyerror("arguments to PCDATA must be integer constants")
                        }
-                       yyVAL.addr2.from = yyS[yypt-2].addr
-                       yyVAL.addr2.to = yyS[yypt-0].addr
+                       yyVAL.addr2.from = yyDollar[1].addr
+                       yyVAL.addr2.to = yyDollar[3].addr
                }
        case 60:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:337
                {
-                       if yyS[yypt-2].addr.Type != obj.TYPE_CONST {
+                       if yyDollar[1].addr.Type != obj.TYPE_CONST {
                                yyerror("index for FUNCDATA must be integer constant")
                        }
-                       if yyS[yypt-0].addr.Type != obj.TYPE_MEM || (yyS[yypt-0].addr.Name != obj.NAME_EXTERN && yyS[yypt-0].addr.Name != obj.NAME_STATIC) {
+                       if yyDollar[3].addr.Type != obj.TYPE_MEM || (yyDollar[3].addr.Name != obj.NAME_EXTERN && yyDollar[3].addr.Name != obj.NAME_STATIC) {
                                yyerror("value for FUNCDATA must be symbol reference")
                        }
-                       yyVAL.addr2.from = yyS[yypt-2].addr
-                       yyVAL.addr2.to = yyS[yypt-0].addr
+                       yyVAL.addr2.from = yyDollar[1].addr
+                       yyVAL.addr2.to = yyDollar[3].addr
                }
        case 61:
                yyVAL.addr = yyS[yypt-0].addr
@@ -905,14 +988,16 @@ yydefault:
        case 64:
                yyVAL.addr = yyS[yypt-0].addr
        case 65:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:356
                {
-                       yyVAL.addr = yyS[yypt-0].addr
+                       yyVAL.addr = yyDollar[2].addr
                }
        case 66:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:360
                {
-                       yyVAL.addr = yyS[yypt-0].addr
+                       yyVAL.addr = yyDollar[2].addr
                }
        case 67:
                yyVAL.addr = yyS[yypt-0].addr
@@ -925,52 +1010,59 @@ yydefault:
        case 71:
                yyVAL.addr = yyS[yypt-0].addr
        case 72:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:373
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_BRANCH
-                       yyVAL.addr.Offset = yyS[yypt-3].lval + int64(asm.PC)
+                       yyVAL.addr.Offset = yyDollar[1].lval + int64(asm.PC)
                }
        case 73:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:379
                {
-                       yyS[yypt-1].sym = asm.LabelLookup(yyS[yypt-1].sym)
+                       yyDollar[1].sym = asm.LabelLookup(yyDollar[1].sym)
                        yyVAL.addr = nullgen
-                       if asm.Pass == 2 && yyS[yypt-1].sym.Type != LLAB {
-                               yyerror("undefined label: %s", yyS[yypt-1].sym.Labelname)
+                       if asm.Pass == 2 && yyDollar[1].sym.Type != LLAB {
+                               yyerror("undefined label: %s", yyDollar[1].sym.Labelname)
                        }
                        yyVAL.addr.Type = obj.TYPE_BRANCH
-                       yyVAL.addr.Offset = yyS[yypt-1].sym.Value + yyS[yypt-0].lval
+                       yyVAL.addr.Offset = yyDollar[1].sym.Value + yyDollar[2].lval
                }
        case 74:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:391
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_REG
-                       yyVAL.addr.Reg = int16(yyS[yypt-0].lval)
+                       yyVAL.addr.Reg = int16(yyDollar[1].lval)
                }
        case 75:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:397
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_REG
-                       yyVAL.addr.Reg = int16(yyS[yypt-0].lval)
+                       yyVAL.addr.Reg = int16(yyDollar[1].lval)
                }
        case 76:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:403
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_REG
-                       yyVAL.addr.Reg = int16(yyS[yypt-0].lval)
+                       yyVAL.addr.Reg = int16(yyDollar[1].lval)
                }
        case 77:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:409
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_REG
-                       yyVAL.addr.Reg = int16(yyS[yypt-0].lval)
+                       yyVAL.addr.Reg = int16(yyDollar[1].lval)
                }
        case 78:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:415
                {
                        yyVAL.addr = nullgen
@@ -978,23 +1070,26 @@ yydefault:
                        yyVAL.addr.Reg = REG_SP
                }
        case 79:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:421
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_REG
-                       yyVAL.addr.Reg = int16(yyS[yypt-0].lval)
+                       yyVAL.addr.Reg = int16(yyDollar[1].lval)
                }
        case 80:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:429
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_CONST
-                       yyVAL.addr.Offset = yyS[yypt-0].lval
+                       yyVAL.addr.Offset = yyDollar[2].lval
                }
        case 81:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:435
                {
-                       yyVAL.addr = yyS[yypt-0].addr
+                       yyVAL.addr = yyDollar[2].addr
                        yyVAL.addr.Type = obj.TYPE_ADDR
                        /*
                                if($2.Type == D_AUTO || $2.Type == D_PARAM)
@@ -1003,139 +1098,156 @@ yydefault:
                        */
                }
        case 82:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:444
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_SCONST
-                       yyVAL.addr.U.Sval = yyS[yypt-0].sval
+                       yyVAL.addr.U.Sval = yyDollar[2].sval
                }
        case 83:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:450
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_FCONST
-                       yyVAL.addr.U.Dval = yyS[yypt-0].dval
+                       yyVAL.addr.U.Dval = yyDollar[2].dval
                }
        case 84:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:456
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_FCONST
-                       yyVAL.addr.U.Dval = yyS[yypt-1].dval
+                       yyVAL.addr.U.Dval = yyDollar[3].dval
                }
        case 85:
+               yyDollar = yyS[yypt-5 : yypt+1]
                //line a.y:462
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_FCONST
-                       yyVAL.addr.U.Dval = -yyS[yypt-1].dval
+                       yyVAL.addr.U.Dval = -yyDollar[4].dval
                }
        case 86:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:468
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_FCONST
-                       yyVAL.addr.U.Dval = -yyS[yypt-0].dval
+                       yyVAL.addr.U.Dval = -yyDollar[3].dval
                }
        case 87:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:476
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_TEXTSIZE
-                       yyVAL.addr.Offset = yyS[yypt-0].lval
+                       yyVAL.addr.Offset = yyDollar[1].lval
                        yyVAL.addr.U.Argsize = obj.ArgsSizeUnknown
                }
        case 88:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:483
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_TEXTSIZE
-                       yyVAL.addr.Offset = -yyS[yypt-0].lval
+                       yyVAL.addr.Offset = -yyDollar[2].lval
                        yyVAL.addr.U.Argsize = obj.ArgsSizeUnknown
                }
        case 89:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:490
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_TEXTSIZE
-                       yyVAL.addr.Offset = yyS[yypt-2].lval
-                       yyVAL.addr.U.Argsize = int32(yyS[yypt-0].lval)
+                       yyVAL.addr.Offset = yyDollar[1].lval
+                       yyVAL.addr.U.Argsize = int32(yyDollar[3].lval)
                }
        case 90:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:497
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_TEXTSIZE
-                       yyVAL.addr.Offset = -yyS[yypt-2].lval
-                       yyVAL.addr.U.Argsize = int32(yyS[yypt-0].lval)
+                       yyVAL.addr.Offset = -yyDollar[2].lval
+                       yyVAL.addr.U.Argsize = int32(yyDollar[4].lval)
                }
        case 91:
                yyVAL.addr = yyS[yypt-0].addr
        case 92:
                yyVAL.addr = yyS[yypt-0].addr
        case 93:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:511
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_MEM
-                       yyVAL.addr.Offset = yyS[yypt-0].lval
+                       yyVAL.addr.Offset = yyDollar[1].lval
                }
        case 94:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:517
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_MEM
-                       yyVAL.addr.Reg = int16(yyS[yypt-1].lval)
-                       yyVAL.addr.Offset = yyS[yypt-3].lval
+                       yyVAL.addr.Reg = int16(yyDollar[3].lval)
+                       yyVAL.addr.Offset = yyDollar[1].lval
                }
        case 95:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:524
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_MEM
                        yyVAL.addr.Reg = REG_SP
-                       yyVAL.addr.Offset = yyS[yypt-3].lval
+                       yyVAL.addr.Offset = yyDollar[1].lval
                }
        case 96:
+               yyDollar = yyS[yypt-6 : yypt+1]
                //line a.y:531
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_MEM
-                       yyVAL.addr.Offset = yyS[yypt-5].lval
-                       yyVAL.addr.Index = int16(yyS[yypt-3].lval)
-                       yyVAL.addr.Scale = int8(yyS[yypt-1].lval)
+                       yyVAL.addr.Offset = yyDollar[1].lval
+                       yyVAL.addr.Index = int16(yyDollar[3].lval)
+                       yyVAL.addr.Scale = int16(yyDollar[5].lval)
                        checkscale(yyVAL.addr.Scale)
                }
        case 97:
+               yyDollar = yyS[yypt-9 : yypt+1]
                //line a.y:540
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_MEM
-                       yyVAL.addr.Reg = int16(yyS[yypt-6].lval)
-                       yyVAL.addr.Offset = yyS[yypt-8].lval
-                       yyVAL.addr.Index = int16(yyS[yypt-3].lval)
-                       yyVAL.addr.Scale = int8(yyS[yypt-1].lval)
+                       yyVAL.addr.Reg = int16(yyDollar[3].lval)
+                       yyVAL.addr.Offset = yyDollar[1].lval
+                       yyVAL.addr.Index = int16(yyDollar[6].lval)
+                       yyVAL.addr.Scale = int16(yyDollar[8].lval)
                        checkscale(yyVAL.addr.Scale)
                }
        case 98:
+               yyDollar = yyS[yypt-9 : yypt+1]
                //line a.y:550
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_MEM
-                       yyVAL.addr.Reg = int16(yyS[yypt-6].lval)
-                       yyVAL.addr.Offset = yyS[yypt-8].lval
-                       yyVAL.addr.Index = int16(yyS[yypt-3].lval)
-                       yyVAL.addr.Scale = int8(yyS[yypt-1].lval)
+                       yyVAL.addr.Reg = int16(yyDollar[3].lval)
+                       yyVAL.addr.Offset = yyDollar[1].lval
+                       yyVAL.addr.Index = int16(yyDollar[6].lval)
+                       yyVAL.addr.Scale = int16(yyDollar[8].lval)
                        checkscale(yyVAL.addr.Scale)
                }
        case 99:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:560
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_MEM
-                       yyVAL.addr.Reg = int16(yyS[yypt-1].lval)
+                       yyVAL.addr.Reg = int16(yyDollar[2].lval)
                }
        case 100:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:566
                {
                        yyVAL.addr = nullgen
@@ -1143,81 +1255,92 @@ yydefault:
                        yyVAL.addr.Reg = REG_SP
                }
        case 101:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:572
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_MEM
-                       yyVAL.addr.Reg = int16(yyS[yypt-1].lval)
-                       yyVAL.addr.Offset = yyS[yypt-3].lval
+                       yyVAL.addr.Reg = int16(yyDollar[3].lval)
+                       yyVAL.addr.Offset = yyDollar[1].lval
                }
        case 102:
+               yyDollar = yyS[yypt-5 : yypt+1]
                //line a.y:579
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_MEM
-                       yyVAL.addr.Index = int16(yyS[yypt-3].lval)
-                       yyVAL.addr.Scale = int8(yyS[yypt-1].lval)
+                       yyVAL.addr.Index = int16(yyDollar[2].lval)
+                       yyVAL.addr.Scale = int16(yyDollar[4].lval)
                        checkscale(yyVAL.addr.Scale)
                }
        case 103:
+               yyDollar = yyS[yypt-8 : yypt+1]
                //line a.y:587
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_MEM
-                       yyVAL.addr.Reg = int16(yyS[yypt-6].lval)
-                       yyVAL.addr.Index = int16(yyS[yypt-3].lval)
-                       yyVAL.addr.Scale = int8(yyS[yypt-1].lval)
+                       yyVAL.addr.Reg = int16(yyDollar[2].lval)
+                       yyVAL.addr.Index = int16(yyDollar[5].lval)
+                       yyVAL.addr.Scale = int16(yyDollar[7].lval)
                        checkscale(yyVAL.addr.Scale)
                }
        case 104:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:598
                {
-                       yyVAL.addr = yyS[yypt-0].addr
+                       yyVAL.addr = yyDollar[1].addr
                }
        case 105:
+               yyDollar = yyS[yypt-6 : yypt+1]
                //line a.y:602
                {
-                       yyVAL.addr = yyS[yypt-5].addr
-                       yyVAL.addr.Index = int16(yyS[yypt-3].lval)
-                       yyVAL.addr.Scale = int8(yyS[yypt-1].lval)
+                       yyVAL.addr = yyDollar[1].addr
+                       yyVAL.addr.Index = int16(yyDollar[3].lval)
+                       yyVAL.addr.Scale = int16(yyDollar[5].lval)
                        checkscale(yyVAL.addr.Scale)
                }
        case 106:
+               yyDollar = yyS[yypt-5 : yypt+1]
                //line a.y:611
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_MEM
-                       yyVAL.addr.Name = int8(yyS[yypt-1].lval)
-                       yyVAL.addr.Sym = obj.Linklookup(asm.Ctxt, yyS[yypt-4].sym.Name, 0)
-                       yyVAL.addr.Offset = yyS[yypt-3].lval
+                       yyVAL.addr.Name = int8(yyDollar[4].lval)
+                       yyVAL.addr.Sym = obj.Linklookup(asm.Ctxt, yyDollar[1].sym.Name, 0)
+                       yyVAL.addr.Offset = yyDollar[2].lval
                }
        case 107:
+               yyDollar = yyS[yypt-7 : yypt+1]
                //line a.y:619
                {
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_MEM
                        yyVAL.addr.Name = obj.NAME_STATIC
-                       yyVAL.addr.Sym = obj.Linklookup(asm.Ctxt, yyS[yypt-6].sym.Name, 1)
-                       yyVAL.addr.Offset = yyS[yypt-3].lval
+                       yyVAL.addr.Sym = obj.Linklookup(asm.Ctxt, yyDollar[1].sym.Name, 1)
+                       yyVAL.addr.Offset = yyDollar[4].lval
                }
        case 108:
+               yyDollar = yyS[yypt-0 : yypt+1]
                //line a.y:628
                {
                        yyVAL.lval = 0
                }
        case 109:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:632
                {
-                       yyVAL.lval = yyS[yypt-0].lval
+                       yyVAL.lval = yyDollar[2].lval
                }
        case 110:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:636
                {
-                       yyVAL.lval = -yyS[yypt-0].lval
+                       yyVAL.lval = -yyDollar[2].lval
                }
        case 111:
                yyVAL.lval = yyS[yypt-0].lval
        case 112:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:643
                {
                        yyVAL.lval = obj.NAME_AUTO
@@ -1227,81 +1350,96 @@ yydefault:
        case 114:
                yyVAL.lval = yyS[yypt-0].lval
        case 115:
+               yyDollar = yyS[yypt-1 : yypt+1]
                //line a.y:651
                {
-                       yyVAL.lval = yyS[yypt-0].sym.Value
+                       yyVAL.lval = yyDollar[1].sym.Value
                }
        case 116:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:655
                {
-                       yyVAL.lval = -yyS[yypt-0].lval
+                       yyVAL.lval = -yyDollar[2].lval
                }
        case 117:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:659
                {
-                       yyVAL.lval = yyS[yypt-0].lval
+                       yyVAL.lval = yyDollar[2].lval
                }
        case 118:
+               yyDollar = yyS[yypt-2 : yypt+1]
                //line a.y:663
                {
-                       yyVAL.lval = ^yyS[yypt-0].lval
+                       yyVAL.lval = ^yyDollar[2].lval
                }
        case 119:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:667
                {
-                       yyVAL.lval = yyS[yypt-1].lval
+                       yyVAL.lval = yyDollar[2].lval
                }
        case 120:
                yyVAL.lval = yyS[yypt-0].lval
        case 121:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:674
                {
-                       yyVAL.lval = yyS[yypt-2].lval + yyS[yypt-0].lval
+                       yyVAL.lval = yyDollar[1].lval + yyDollar[3].lval
                }
        case 122:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:678
                {
-                       yyVAL.lval = yyS[yypt-2].lval - yyS[yypt-0].lval
+                       yyVAL.lval = yyDollar[1].lval - yyDollar[3].lval
                }
        case 123:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:682
                {
-                       yyVAL.lval = yyS[yypt-2].lval * yyS[yypt-0].lval
+                       yyVAL.lval = yyDollar[1].lval * yyDollar[3].lval
                }
        case 124:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:686
                {
-                       yyVAL.lval = yyS[yypt-2].lval / yyS[yypt-0].lval
+                       yyVAL.lval = yyDollar[1].lval / yyDollar[3].lval
                }
        case 125:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:690
                {
-                       yyVAL.lval = yyS[yypt-2].lval % yyS[yypt-0].lval
+                       yyVAL.lval = yyDollar[1].lval % yyDollar[3].lval
                }
        case 126:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:694
                {
-                       yyVAL.lval = yyS[yypt-3].lval << uint(yyS[yypt-0].lval)
+                       yyVAL.lval = yyDollar[1].lval << uint(yyDollar[4].lval)
                }
        case 127:
+               yyDollar = yyS[yypt-4 : yypt+1]
                //line a.y:698
                {
-                       yyVAL.lval = yyS[yypt-3].lval >> uint(yyS[yypt-0].lval)
+                       yyVAL.lval = yyDollar[1].lval >> uint(yyDollar[4].lval)
                }
        case 128:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:702
                {
-                       yyVAL.lval = yyS[yypt-2].lval & yyS[yypt-0].lval
+                       yyVAL.lval = yyDollar[1].lval & yyDollar[3].lval
                }
        case 129:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:706
                {
-                       yyVAL.lval = yyS[yypt-2].lval ^ yyS[yypt-0].lval
+                       yyVAL.lval = yyDollar[1].lval ^ yyDollar[3].lval
                }
        case 130:
+               yyDollar = yyS[yypt-3 : yypt+1]
                //line a.y:710
                {
-                       yyVAL.lval = yyS[yypt-2].lval | yyS[yypt-0].lval
+                       yyVAL.lval = yyDollar[1].lval | yyDollar[3].lval
                }
        }
        goto yystack /* stack new state and value */

diff --git a/src/cmd/8g/cgen.go b/src/cmd/8g/cgen.go
index d36bef7f01311ac667112ed7c8e08410b594351d..ba8953a403c2e10a82224122775297bbf4ede58b 100644 (file)
--- a/src/cmd/8g/cgen.go
+++ b/src/cmd/8g/cgen.go
@@ -774,7 +774,7 @@ func agen(n *gc.Node, res *gc.Node) {
                        // LEAL (n3)(n2*w), n3
                        p1 := gins(i386.ALEAL, &n2, &n3)
 
-                       p1.From.Scale = int8(w)
+                       p1.From.Scale = int16(w)
                        p1.From.Type = obj.TYPE_MEM
                        p1.From.Index = p1.From.Reg
                        p1.From.Reg = p1.To.Reg

diff --git a/src/cmd/8g/gsubr.go b/src/cmd/8g/gsubr.go
index ac3ad4111cfee33ba78f74400ba90cd0c6f7e561..841f4dc66c90f64b0efd63d351e0551ca48b90f9 100644 (file)
--- a/src/cmd/8g/gsubr.go
+++ b/src/cmd/8g/gsubr.go
@@ -582,12 +582,12 @@ func gclean() {
 
        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])
+                       gc.Yyerror("reg %v left allocated at %x", obj.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))
+                       gc.Yyerror("reg %v left allocated\n", obj.Rconv(i))
                }
        }
 }
@@ -657,7 +657,7 @@ func regalloc(n *gc.Node, t *gc.Type, o *gc.Node) {
 
                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])
+                       fmt.Printf("\t%v\t%#x\n", obj.Rconv(i), regpc[i])
                }
                gc.Fatal("out of fixed registers")
                goto err
@@ -683,7 +683,7 @@ func regalloc(n *gc.Node, t *gc.Type, o *gc.Node) {
                }
                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])
+                       fmt.Printf("\t%v\t%#x\n", obj.Rconv(i), regpc[i])
                }
                gc.Fatal("out of floating registers")
        }
@@ -702,7 +702,7 @@ out:
                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))
+                       gc.Fatal("regalloc %v", obj.Rconv(i))
                }
        }
 
@@ -729,7 +729,7 @@ func regfree(n *gc.Node) {
        }
        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))
+               gc.Fatal("regfree %v", obj.Rconv(i))
        }
 }
 

diff --git a/src/cmd/9a/a.y b/src/cmd/9a/a.y
index db733c59871eee2d68bed5256f3b57d2bd25c659..2ca6e9063ba8a457ca08ac3f9da9afdfac56fef7 100644 (file)
--- a/src/cmd/9a/a.y
+++ b/src/cmd/9a/a.y
@@ -927,7 +927,7 @@ regaddr:
                $$ = nullgen;
                $$.Type = obj.TYPE_MEM;
                $$.Reg = int16($2);
-               $$.Scale = int8($4);
+               $$.Scale = int16($4);
                $$.Offset = 0;
        }
 

diff --git a/src/cmd/9a/y.go b/src/cmd/9a/y.go
index 2e42378059491b15ac1db14444a561864ec39c89..3e62619cb2e36d6b488f8dbcd7d94c75fe395a70 100644 (file)
--- a/src/cmd/9a/y.go
+++ b/src/cmd/9a/y.go
@@ -1786,7 +1786,7 @@ yydefault:
                        yyVAL.addr = nullgen
                        yyVAL.addr.Type = obj.TYPE_MEM
                        yyVAL.addr.Reg = int16(yyDollar[2].lval)
-                       yyVAL.addr.Scale = int8(yyDollar[4].lval)
+                       yyVAL.addr.Scale = int16(yyDollar[4].lval)
                        yyVAL.addr.Offset = 0
                }
        case 157:

diff --git a/src/cmd/9g/ggen.go b/src/cmd/9g/ggen.go
index 3197e4643db255ed338689cb7e9e823dc47ab0a2..2a3dbcbfb38fef543791bbe0785fcd5667ecdd5b 100644 (file)
--- a/src/cmd/9g/ggen.go
+++ b/src/cmd/9g/ggen.go
@@ -747,15 +747,15 @@ func clearfat(nl *gc.Node) {
        c := uint64(w % 8) // bytes
        q := uint64(w / 8) // dwords
 
-       if reg[ppc64.REGRT1] > 0 {
-               gc.Fatal("R%d in use during clearfat", ppc64.REGRT1)
+       if reg[ppc64.REGRT1-ppc64.REG_R0] > 0 {
+               gc.Fatal("R%d in use during clearfat", ppc64.REGRT1-ppc64.REG_R0)
        }
 
        var r0 gc.Node
        gc.Nodreg(&r0, gc.Types[gc.TUINT64], ppc64.REG_R0) // r0 is always zero
        var dst gc.Node
        gc.Nodreg(&dst, gc.Types[gc.Tptr], ppc64.REGRT1)
-       reg[ppc64.REGRT1]++
+       reg[ppc64.REGRT1-ppc64.REG_R0]++
        agen(nl, &dst)
 
        var boff uint64
@@ -812,7 +812,7 @@ func clearfat(nl *gc.Node) {
                p.To.Offset = int64(t + boff)
        }
 
-       reg[ppc64.REGRT1]--
+       reg[ppc64.REGRT1-ppc64.REG_R0]--
 }
 
 // Called after regopt and peep have run.

diff --git a/src/cmd/9g/gsubr.go b/src/cmd/9g/gsubr.go
index 9a00434735c67a303ebaa05e753711f8f33fa0a3..74a312a3db75b5920a37e1a5457bbd19e586ebdf 100644 (file)
--- a/src/cmd/9g/gsubr.go
+++ b/src/cmd/9g/gsubr.go
@@ -63,14 +63,14 @@ var resvd = []int{
 }
 
 func ginit() {
-       for i := int(0); i < len(reg); i++ {
+       for i := 0; i < len(reg); i++ {
                reg[i] = 1
        }
-       for i := int(0); i < ppc64.NREG+ppc64.NFREG; i++ {
+       for i := 0; i < ppc64.NREG+ppc64.NFREG; i++ {
                reg[i] = 0
        }
 
-       for i := int(0); i < len(resvd); i++ {
+       for i := 0; i < len(resvd); i++ {
                reg[resvd[i]-ppc64.REG_R0]++
        }
 }
@@ -84,7 +84,7 @@ func gclean() {
 
        for i := int(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])
+                       gc.Yyerror("reg %v left allocated, %p\n", obj.Rconv(i+ppc64.REG_R0), regpc[i])
                }
        }
 }

diff --git a/src/cmd/asm/internal/arch/arch.go b/src/cmd/asm/internal/arch/arch.go
index 3b69ebe87d2d04402db28a130f37673cb0b834fa..0e31f34afcd9ca4e32b5ddb4ce2545b709a8b139 100644 (file)
--- a/src/cmd/asm/internal/arch/arch.go
+++ b/src/cmd/asm/internal/arch/arch.go
@@ -38,8 +38,6 @@ type Arch struct {
        IsJump func(word string) bool
        // Aconv pretty-prints an instruction opcode for this architecture.
        Aconv func(int) string
-       // Rconv pretty-prints a register for this architecture.
-       Rconv func(int) string
 }
 
 // nilRegisterNumber is the register number function for architectures
@@ -188,7 +186,6 @@ func arch386() *Arch {
                UnaryDestination: unaryDestination,
                IsJump:           jump386,
                Aconv:            i386.Aconv,
-               Rconv:            i386.Rconv,
        }
 }
 
@@ -309,7 +306,6 @@ func archAmd64() *Arch {
                UnaryDestination: unaryDestination,
                IsJump:           jump386,
                Aconv:            x86.Aconv,
-               Rconv:            x86.Rconv,
        }
 }
 
@@ -320,7 +316,7 @@ func archArm() *Arch {
        // Note that there is no list of names as there is for 386 and amd64.
        // TODO: Are there aliases we need to add?
        for i := arm.REG_R0; i < arm.REG_SPSR; i++ {
-               register[arm.Rconv(i)] = int16(i)
+               register[obj.Rconv(i)] = int16(i)
        }
        // Avoid unintentionally clobbering g using R10.
        delete(register, "R10")
@@ -362,7 +358,6 @@ func archArm() *Arch {
                UnaryDestination: unaryDestination,
                IsJump:           jumpArm,
                Aconv:            arm.Aconv,
-               Rconv:            arm.Rconv,
        }
 }
 
@@ -372,17 +367,17 @@ func archPPC64() *Arch {
        // TODO: Should this be done in obj for us?
        // Note that there is no list of names as there is for 386 and amd64.
        for i := ppc64.REG_R0; i <= ppc64.REG_R31; i++ {
-               register[ppc64.Rconv(i)] = int16(i)
+               register[obj.Rconv(i)] = int16(i)
        }
        for i := ppc64.REG_F0; i <= ppc64.REG_F31; i++ {
-               register[ppc64.Rconv(i)] = int16(i)
+               register[obj.Rconv(i)] = int16(i)
        }
        for i := ppc64.REG_C0; i <= ppc64.REG_C7; i++ {
                // TODO: Rconv prints these as C7 but the input syntax requires CR7.
                register[fmt.Sprintf("CR%d", i-ppc64.REG_C0)] = int16(i)
        }
        for i := ppc64.REG_MSR; i <= ppc64.REG_CR; i++ {
-               register[ppc64.Rconv(i)] = int16(i)
+               register[obj.Rconv(i)] = int16(i)
        }
        register["CR"] = ppc64.REG_CR
        register["XER"] = ppc64.REG_XER
@@ -422,6 +417,5 @@ func archPPC64() *Arch {
                UnaryDestination: nil,
                IsJump:           jumpPPC64,
                Aconv:            ppc64.Aconv,
-               Rconv:            ppc64.Rconv,
        }
 }

diff --git a/src/cmd/asm/internal/asm/asm.go b/src/cmd/asm/internal/asm/asm.go
index 5682bd0df331b69864cec6f9b89a761cfcf6f3b6..6487e7c750ea2f90885fdeded66399a2b57e204c 100644 (file)
--- a/src/cmd/asm/internal/asm/asm.go
+++ b/src/cmd/asm/internal/asm/asm.go
@@ -73,7 +73,7 @@ func (p *Parser) evalInteger(pseudo string, operands []lex.Token) int64 {
 // validateImmediate checks that addr represents an immediate constant.
 func (p *Parser) validateImmediate(pseudo string, addr *obj.Addr) {
        if addr.Type != obj.TYPE_CONST || addr.Name != 0 || addr.Reg != 0 || addr.Index != 0 {
-               p.errorf("%s: expected immediate constant; found %s", pseudo, obj.Dconv(&emptyProg, p.arch.Rconv, addr))
+               p.errorf("%s: expected immediate constant; found %s", pseudo, obj.Dconv(&emptyProg, addr))
        }
 }
 
@@ -461,12 +461,12 @@ func (p *Parser) asmInstruction(op int, cond string, a []obj.Addr) {
                        // DX:AX as a register pair can only appear on the RHS.
                        // Bizarrely, to obj it's specified by setting index on the LHS.
                        // TODO: can we fix this?
-                       if a[1].Class != 0 {
-                               if a[0].Class != 0 {
+                       if a[1].Reg2 != 0 {
+                               if a[0].Reg2 != 0 {
                                        p.errorf("register pair must be on LHS")
                                }
-                               prog.From.Index = int16(a[1].Class)
-                               prog.To.Class = 0
+                               prog.From.Index = int16(a[1].Reg2)
+                               prog.To.Reg2 = 0
                        }
                case '9':
                        var reg0, reg1 int16
@@ -642,7 +642,7 @@ var emptyProg obj.Prog
 // getConstantPseudo checks that addr represents a plain constant and returns its value.
 func (p *Parser) getConstantPseudo(pseudo string, addr *obj.Addr) int64 {
        if addr.Type != obj.TYPE_MEM || addr.Name != 0 || addr.Reg != 0 || addr.Index != 0 {
-               p.errorf("%s: expected integer constant; found %s", pseudo, obj.Dconv(&emptyProg, p.arch.Rconv, addr))
+               p.errorf("%s: expected integer constant; found %s", pseudo, obj.Dconv(&emptyProg, addr))
        }
        return addr.Offset
 }
@@ -650,7 +650,7 @@ func (p *Parser) getConstantPseudo(pseudo string, addr *obj.Addr) int64 {
 // getConstant checks that addr represents a plain constant and returns its value.
 func (p *Parser) getConstant(prog *obj.Prog, op int, addr *obj.Addr) int64 {
        if addr.Type != obj.TYPE_MEM || addr.Name != 0 || addr.Reg != 0 || addr.Index != 0 {
-               p.errorf("%s: expected integer constant; found %s", p.arch.Aconv(op), obj.Dconv(prog, p.arch.Rconv, addr))
+               p.errorf("%s: expected integer constant; found %s", p.arch.Aconv(op), obj.Dconv(prog, addr))
        }
        return addr.Offset
 }
@@ -658,7 +658,7 @@ func (p *Parser) getConstant(prog *obj.Prog, op int, addr *obj.Addr) int64 {
 // getImmediate checks that addr represents an immediate constant and returns its value.
 func (p *Parser) getImmediate(prog *obj.Prog, op int, addr *obj.Addr) int64 {
        if addr.Type != obj.TYPE_CONST || addr.Name != 0 || addr.Reg != 0 || addr.Index != 0 {
-               p.errorf("%s: expected immediate constant; found %s", p.arch.Aconv(op), obj.Dconv(prog, p.arch.Rconv, addr))
+               p.errorf("%s: expected immediate constant; found %s", p.arch.Aconv(op), obj.Dconv(prog, addr))
        }
        return addr.Offset
 }
@@ -666,7 +666,7 @@ func (p *Parser) getImmediate(prog *obj.Prog, op int, addr *obj.Addr) int64 {
 // getRegister checks that addr represents a register and returns its value.
 func (p *Parser) getRegister(prog *obj.Prog, op int, addr *obj.Addr) int16 {
        if addr.Type != obj.TYPE_REG || addr.Offset != 0 || addr.Name != 0 || addr.Index != 0 {
-               p.errorf("%s: expected register; found %s", p.arch.Aconv(op), obj.Dconv(prog, p.arch.Rconv, addr))
+               p.errorf("%s: expected register; found %s", p.arch.Aconv(op), obj.Dconv(prog, addr))
        }
        return addr.Reg
 }

diff --git a/src/cmd/asm/internal/asm/operand_test.go b/src/cmd/asm/internal/asm/operand_test.go
index e1deea398510fe40dd7158bc1728e2c99819e947..62b2280fc338a7b5731a8063704701a28f609728 100644 (file)
--- a/src/cmd/asm/internal/asm/operand_test.go
+++ b/src/cmd/asm/internal/asm/operand_test.go
@@ -34,7 +34,7 @@ func testOperandParser(t *testing.T, parser *Parser, tests []operandTest) {
                parser.start(lex.Tokenize(test.input))
                addr := obj.Addr{}
                parser.operand(&addr)
-               result := obj.Dconv(&emptyProg, parser.arch.Rconv, &addr)
+               result := obj.Dconv(&emptyProg, &addr)
                if result != test.output {
                        t.Errorf("fail at %s: got %s; expected %s\n", test.input, result, test.output)
                }
@@ -48,9 +48,9 @@ func testX86RegisterPair(t *testing.T, parser *Parser) {
        addr := obj.Addr{}
        parser.operand(&addr)
        want := obj.Addr{
-               Type:  obj.TYPE_REG,
-               Reg:   parser.arch.Register["AX"],
-               Class: int8(parser.arch.Register["BX"]), // TODO: clean up how this is encoded in parse.go
+               Type: obj.TYPE_REG,
+               Reg:  parser.arch.Register["AX"],
+               Reg2: parser.arch.Register["BX"], // TODO: clean up how this is encoded in parse.go
        }
        if want != addr {
                t.Errorf("AX:DX: expected %+v got %+v", want, addr)
@@ -65,7 +65,7 @@ func testX86RegisterPair(t *testing.T, parser *Parser) {
                Name:   obj.NAME_EXTERN,
                Offset: 4,
                Sym:    obj.Linklookup(parser.ctxt, "foo", 0),
-               Class:  int8(parser.arch.Register["AX"]), // TODO: clean up how this is encoded in parse.go
+               Reg2:   parser.arch.Register["AX"], // TODO: clean up how this is encoded in parse.go
        }
        if want != addr {
                t.Errorf("foo+4(SB):AX: expected %+v got %+v", want, addr)
@@ -99,7 +99,7 @@ func TestPPC64OperandParser(t *testing.T) {
        want := obj.Addr{
                Type:  obj.TYPE_MEM,
                Reg:   parser.arch.Register["R1"],
-               Scale: int8(parser.arch.Register["R2"]), // TODO: clean up how this is encoded in parse.go
+               Scale: parser.arch.Register["R2"], // TODO: clean up how this is encoded in parse.go
        }
        if want != addr {
                t.Errorf("(R1+R2): expected %+v got %+v", want, addr)

diff --git a/src/cmd/asm/internal/asm/parse.go b/src/cmd/asm/internal/asm/parse.go
index 9cacffc84d262be6b26d5c8182026cdd087a6246..9048cca9849c37beda726d601ae5bbb9e6d8c92d 100644 (file)
--- a/src/cmd/asm/internal/asm/parse.go
+++ b/src/cmd/asm/internal/asm/parse.go
@@ -255,7 +255,7 @@ func (p *Parser) operand(a *obj.Addr) bool {
        if tok.ScanToken == scanner.Ident && !p.atStartOfRegister(name) {
                // We have a symbol. Parse $sym±offset(symkind)
                p.symbolReference(a, name, prefix)
-               // fmt.Printf("SYM %s\n", obj.Dconv(&emptyProg, 0, p.arch.Rconv, a))
+               // fmt.Printf("SYM %s\n", obj.Dconv(&emptyProg, 0, a))
                if p.peek() == scanner.EOF {
                        return true
                }
@@ -297,10 +297,10 @@ func (p *Parser) operand(a *obj.Addr) bool {
                        if r2 != 0 {
                                // Form is R1:R2. It is on RHS and the second register
                                // needs to go into the LHS. This is a horrible hack. TODO.
-                               a.Class = int8(r2)
+                               a.Reg2 = r2
                        }
                }
-               // fmt.Printf("REG %s\n", obj.Dconv(&emptyProg, 0, p.arch.Rconv, a))
+               // fmt.Printf("REG %s\n", obj.Dconv(&emptyProg, 0, a))
                p.expect(scanner.EOF)
                return true
        }
@@ -327,7 +327,7 @@ func (p *Parser) operand(a *obj.Addr) bool {
                        }
                        a.Type = obj.TYPE_FCONST
                        a.U.Dval = p.floatExpr()
-                       // fmt.Printf("FCONST %s\n", obj.Dconv(&emptyProg, 0, p.arch.Rconv, a))
+                       // fmt.Printf("FCONST %s\n", obj.Dconv(&emptyProg, 0, a))
                        p.expect(scanner.EOF)
                        return true
                }
@@ -341,7 +341,7 @@ func (p *Parser) operand(a *obj.Addr) bool {
                        }
                        a.Type = obj.TYPE_SCONST
                        a.U.Sval = str
-                       // fmt.Printf("SCONST %s\n", obj.Dconv(&emptyProg, 0, p.arch.Rconv, a))
+                       // fmt.Printf("SCONST %s\n", obj.Dconv(&emptyProg, 0, a))
                        p.expect(scanner.EOF)
                        return true
                }
@@ -355,7 +355,7 @@ func (p *Parser) operand(a *obj.Addr) bool {
                        default:
                                a.Type = obj.TYPE_MEM
                        }
-                       // fmt.Printf("CONST %d %s\n", a.Offset, obj.Dconv(&emptyProg, 0, p.arch.Rconv, a))
+                       // fmt.Printf("CONST %d %s\n", a.Offset, obj.Dconv(&emptyProg, 0, a))
                        p.expect(scanner.EOF)
                        return true
                }
@@ -363,13 +363,13 @@ func (p *Parser) operand(a *obj.Addr) bool {
        }
 
        // Odd x86 case: sym+4(SB):AX. Have name, colon, register.
-       if p.peek() == ':' && a.Name != obj.NAME_NONE && a.Class == 0 && (p.arch.Thechar == '6' || p.arch.Thechar == '8') {
+       if p.peek() == ':' && a.Name != obj.NAME_NONE && a.Reg2 == 0 && (p.arch.Thechar == '6' || p.arch.Thechar == '8') {
                p.get(':')
                r2, ok := p.registerReference(p.next().String())
                if !ok {
                        return false
                }
-               a.Class = int8(r2) // TODO: See comment about Class above.
+               a.Reg2 = r2 // TODO: See comment about Reg3 above.
        } else {
                // Register indirection: (reg) or (index*scale). We are on the opening paren.
                p.registerIndirect(a, prefix)
@@ -646,7 +646,7 @@ func (p *Parser) registerIndirect(a *obj.Addr, prefix rune) {
                        }
                        // TODO: This is rewritten in asm. Clumsy.
                        a.Type = obj.TYPE_MEM
-                       a.Scale = int8(r2)
+                       a.Scale = r2
                        // Nothing may follow.
                        return
                }
@@ -672,13 +672,13 @@ func (p *Parser) registerIndirect(a *obj.Addr, prefix rune) {
                        p.errorf("unimplemented two-register form")
                }
                a.Index = r1
-               a.Scale = scale
+               a.Scale = int16(scale)
                p.get(')')
        } else if scale != 0 {
                // First (R) was missing, all we have is (R*scale).
                a.Reg = 0
                a.Index = r1
-               a.Scale = scale
+               a.Scale = int16(scale)
        }
 }
 

diff --git a/src/cmd/internal/gc/fmt.go b/src/cmd/internal/gc/fmt.go
index 97907229d4803c243becd09f21b0c695ee2357d9..ab902b3b70423224602c576218fc5462a818e1fe 100644 (file)
--- a/src/cmd/internal/gc/fmt.go
+++ b/src/cmd/internal/gc/fmt.go
@@ -1257,7 +1257,7 @@ func exprfmt(n *Node, prec int) string {
 
        case OREGISTER:
                var f string
-               f += fmt.Sprintf("%v", Ctxt.Rconv(int(n.Val.U.Reg)))
+               f += fmt.Sprintf("%v", obj.Rconv(int(n.Val.U.Reg)))
                return f
 
        case OLITERAL: // this is a bit of a mess
@@ -1787,7 +1787,7 @@ func nodedump(n *Node, flag int) string {
 
        case OREGISTER,
                OINDREG:
-               fp += fmt.Sprintf("%v-%v%v", Oconv(int(n.Op), 0), Ctxt.Rconv(int(n.Val.U.Reg)), Jconv(n, 0))
+               fp += fmt.Sprintf("%v-%v%v", Oconv(int(n.Op), 0), obj.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))

diff --git a/src/cmd/internal/gc/reg.go b/src/cmd/internal/gc/reg.go
index 42a65daf54c7c7e3ce5efe5a325df981dbe04bd3..5f9586bd413b69c463c650d70e412025494a281e 100644 (file)
--- a/src/cmd/internal/gc/reg.go
+++ b/src/cmd/internal/gc/reg.go
@@ -1283,7 +1283,7 @@ brk:
                if rgp.regno != 0 {
                        if Debug['R'] != 0 && Debug['v'] != 0 {
                                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)
+                               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), obj.Rconv(int(rgp.regno)), usedreg, vreg)
                        }
 
                        paint3(rgp.enter, int(rgp.varno), vreg, int(rgp.regno))

diff --git a/src/cmd/internal/obj/arm/5.out.go b/src/cmd/internal/obj/arm/5.out.go
index 11c9fb92f2e5306aea5096782123b6ea14bb3ec8..bebc091a88e9a359de22030076b635f968ece273 100644 (file)
--- a/src/cmd/internal/obj/arm/5.out.go
+++ b/src/cmd/internal/obj/arm/5.out.go
@@ -47,7 +47,7 @@ const (
 )
 
 const (
-       REG_R0 = 32 + iota
+       REG_R0 = obj.RBaseARM + iota
        REG_R1
        REG_R2
        REG_R3
@@ -83,6 +83,7 @@ const (
        REG_FPCR
        REG_CPSR
        REG_SPSR
+       MAXREG
        REGRET  = REG_R0
        REGEXT  = REG_R10
        REGG    = REGEXT - 0

diff --git a/src/cmd/internal/obj/arm/asm5.go b/src/cmd/internal/obj/arm/asm5.go
index 8e42d6b527dea1b7fd1eb919954ec96a5b7b1131..236b2418ce7bdbf1d94c957b9e87838595bff935 100644 (file)
--- a/src/cmd/internal/obj/arm/asm5.go
+++ b/src/cmd/internal/obj/arm/asm5.go
@@ -45,7 +45,7 @@ type Optab struct {
        a3       uint8
        type_    uint8
        size     int8
-       param    int8
+       param    int16
        flag     int8
        pcrelsiz uint8
 }

diff --git a/src/cmd/internal/obj/arm/list5.go b/src/cmd/internal/obj/arm/list5.go
index c525a29f9b74ef3cb9956d5459d795859cba5867..1570948575c150ec1fd99810baf76d6d56b6f34d 100644 (file)
--- a/src/cmd/internal/obj/arm/list5.go
+++ b/src/cmd/internal/obj/arm/list5.go
@@ -86,26 +86,26 @@ func Pconv(p *obj.Prog) string {
        if a == AMOVM {
                if p.From.Type == obj.TYPE_CONST {
                        str = fmt.Sprintf("%.5d (%v)\t%v%s\t%v,%v",
-                               p.Pc, p.Line(), Aconv(a), sc, RAconv(&p.From), obj.Dconv(p, Rconv, &p.To))
+                               p.Pc, p.Line(), Aconv(a), sc, RAconv(&p.From), obj.Dconv(p, &p.To))
                } else if p.To.Type == obj.TYPE_CONST {
                        str = fmt.Sprintf("%.5d (%v)\t%v%s\t%v,%v",
-                               p.Pc, p.Line(), Aconv(a), sc, obj.Dconv(p, Rconv, &p.From), RAconv(&p.To))
+                               p.Pc, p.Line(), Aconv(a), sc, obj.Dconv(p, &p.From), RAconv(&p.To))
                } else {
                        str = fmt.Sprintf("%.5d (%v)\t%v%s\t%v,%v",
-                               p.Pc, p.Line(), Aconv(a), sc, obj.Dconv(p, Rconv, &p.From), obj.Dconv(p, Rconv, &p.To))
+                               p.Pc, p.Line(), Aconv(a), sc, obj.Dconv(p, &p.From), obj.Dconv(p, &p.To))
                }
        } else if a == obj.ADATA {
                str = fmt.Sprintf("%.5d (%v)\t%v\t%v/%d,%v",
-                       p.Pc, p.Line(), Aconv(a), obj.Dconv(p, Rconv, &p.From), p.From3.Offset, obj.Dconv(p, Rconv, &p.To))
+                       p.Pc, p.Line(), Aconv(a), obj.Dconv(p, &p.From), p.From3.Offset, obj.Dconv(p, &p.To))
        } else if p.As == obj.ATEXT {
                str = fmt.Sprintf("%.5d (%v)\t%v\t%v,%d,%v",
-                       p.Pc, p.Line(), Aconv(a), obj.Dconv(p, Rconv, &p.From), p.From3.Offset, obj.Dconv(p, Rconv, &p.To))
+                       p.Pc, p.Line(), Aconv(a), obj.Dconv(p, &p.From), p.From3.Offset, obj.Dconv(p, &p.To))
        } else if p.Reg == 0 {
                str = fmt.Sprintf("%.5d (%v)\t%v%s\t%v,%v",
-                       p.Pc, p.Line(), Aconv(a), sc, obj.Dconv(p, Rconv, &p.From), obj.Dconv(p, Rconv, &p.To))
+                       p.Pc, p.Line(), Aconv(a), sc, obj.Dconv(p, &p.From), obj.Dconv(p, &p.To))
        } else {
                str = fmt.Sprintf("%.5d (%v)\t%v%s\t%v,%v,%v",
-                       p.Pc, p.Line(), Aconv(a), sc, obj.Dconv(p, Rconv, &p.From), Rconv(int(p.Reg)), obj.Dconv(p, Rconv, &p.To))
+                       p.Pc, p.Line(), Aconv(a), sc, obj.Dconv(p, &p.From), Rconv(int(p.Reg)), obj.Dconv(p, &p.To))
        }
 
        fp += str
@@ -160,42 +160,36 @@ func RAconv(a *obj.Addr) string {
        return fp
 }
 
-func Rconv(r int) string {
-       var fp string
+func init() {
+       obj.RegisterRegister(obj.RBaseARM, MAXREG, Rconv)
+}
 
+func Rconv(r int) string {
        if r == 0 {
-               fp += "NONE"
-               return fp
+               return "NONE"
        }
        if REG_R0 <= r && r <= REG_R15 {
-               fp += fmt.Sprintf("R%d", r-REG_R0)
-               return fp
+               return fmt.Sprintf("R%d", r-REG_R0)
        }
        if REG_F0 <= r && r <= REG_F15 {
-               fp += fmt.Sprintf("F%d", r-REG_F0)
-               return fp
+               return fmt.Sprintf("F%d", r-REG_F0)
        }
 
        switch r {
        case REG_FPSR:
-               fp += "FPSR"
-               return fp
+               return "FPSR"
 
        case REG_FPCR:
-               fp += "FPCR"
-               return fp
+               return "FPCR"
 
        case REG_CPSR:
-               fp += "CPSR"
-               return fp
+               return "CPSR"
 
        case REG_SPSR:
-               fp += "SPSR"
-               return fp
+               return "SPSR"
        }
 
-       fp += fmt.Sprintf("badreg(%d)", r)
-       return fp
+       return fmt.Sprintf("Rgok(%d)", r-obj.RBaseARM)
 }
 
 func DRconv(a int) string {

diff --git a/src/cmd/internal/obj/i386/8.out.go b/src/cmd/internal/obj/i386/8.out.go
index d6c01cd5ffa1089c57155b60dba09ffa10afb116..ab58cc1f0c8113faaefd989535b969ec171259f4 100644 (file)
--- a/src/cmd/internal/obj/i386/8.out.go
+++ b/src/cmd/internal/obj/i386/8.out.go
@@ -535,15 +535,15 @@ const (
 
 const (
        REG_NONE = 0
-       REG_AL   = 0 + 16 + iota - 1
+       REG_AL   = obj.RBase386 + 0 + iota - 1
        REG_CL
        REG_DL
        REG_BL
-       REG_AH = 4 + 16 + iota - 5
+       REG_AH = obj.RBase386 + 4 + iota - 5
        REG_CH
        REG_DH
        REG_BH
-       REG_AX = 8 + 16 + iota - 9
+       REG_AX = obj.RBase386 + 8 + iota - 9
        REG_CX
        REG_DX
        REG_BX
@@ -551,9 +551,9 @@ const (
        REG_BP
        REG_SI
        REG_DI
-       REG_F0 = 16 + 16
-       REG_F7 = REG_F0 + 7 + 16
-       REG_CS = 24 + 16 + iota - 19
+       REG_F0 = obj.RBase386 + 16
+       REG_F7 = obj.RBase386 + REG_F0 + 7
+       REG_CS = obj.RBase386 + 24 + iota - 19
        REG_SS
        REG_DS
        REG_ES
@@ -564,10 +564,10 @@ const (
        REG_LDTR
        REG_MSW
        REG_TASK
-       REG_CR = 35 + 16
-       REG_DR = 43 + 16
-       REG_TR = 51 + 16
-       REG_X0 = 59 + 16 + iota - 33
+       REG_CR = obj.RBase386 + 35
+       REG_DR = obj.RBase386 + 43
+       REG_TR = obj.RBase386 + 51
+       REG_X0 = obj.RBase386 + 59 + iota - 33
        REG_X1
        REG_X2
        REG_X3
@@ -575,8 +575,8 @@ const (
        REG_X5
        REG_X6
        REG_X7
-       REG_TLS   = 67 + 16
-       MAXREG    = 68 + 16
+       REG_TLS   = obj.RBase386 + 67
+       MAXREG    = obj.RBase386 + 68
        T_TYPE    = 1 << 0
        T_INDEX   = 1 << 1
        T_OFFSET  = 1 << 2

diff --git a/src/cmd/internal/obj/i386/asm8.go b/src/cmd/internal/obj/i386/asm8.go
index 495c2dce82815e1f8dc72da7e6515aad06ccc803..428458614a2cc64ea76e411293de7cb61fd9ac65 100644 (file)
--- a/src/cmd/internal/obj/i386/asm8.go
+++ b/src/cmd/internal/obj/i386/asm8.go
@@ -1501,7 +1501,7 @@ func oclass(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) int {
                }
 
                if a.Sym != nil || a.Name != obj.NAME_NONE {
-                       ctxt.Diag("unexpected addr: %v", obj.Dconv(p, Rconv, a))
+                       ctxt.Diag("unexpected addr: %v", obj.Dconv(p, a))
                }
                fallthrough
 
@@ -1509,7 +1509,7 @@ func oclass(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) int {
 
        case obj.TYPE_CONST:
                if a.Sym != nil {
-                       ctxt.Diag("TYPE_CONST with symbol: %v", obj.Dconv(p, Rconv, a))
+                       ctxt.Diag("TYPE_CONST with symbol: %v", obj.Dconv(p, a))
                }
 
                v = int32(a.Offset)
@@ -1529,7 +1529,7 @@ func oclass(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) int {
        }
 
        if a.Type != obj.TYPE_REG {
-               ctxt.Diag("unexpected addr1: type=%d %v", a.Type, obj.Dconv(p, Rconv, a))
+               ctxt.Diag("unexpected addr1: type=%d %v", a.Type, obj.Dconv(p, a))
                return Yxxx
        }
 
@@ -1772,7 +1772,7 @@ func vaddr(ctxt *obj.Link, p *obj.Prog, a *obj.Addr, r *obj.Reloc) int32 {
                s = a.Sym
                if s != nil {
                        if r == nil {
-                               ctxt.Diag("need reloc for %v", obj.Dconv(p, Rconv, a))
+                               ctxt.Diag("need reloc for %v", obj.Dconv(p, a))
                                log.Fatalf("bad code")
                        }
 
@@ -1789,7 +1789,7 @@ func vaddr(ctxt *obj.Link, p *obj.Prog, a *obj.Addr, r *obj.Reloc) int32 {
 
        if (a.Type == obj.TYPE_MEM || a.Type == obj.TYPE_ADDR) && a.Reg == REG_TLS {
                if r == nil {
-                       ctxt.Diag("need reloc for %v", obj.Dconv(p, Rconv, a))
+                       ctxt.Diag("need reloc for %v", obj.Dconv(p, a))
                        log.Fatalf("bad code")
                }
 
@@ -1972,7 +1972,7 @@ putrelv:
        return
 
 bad:
-       ctxt.Diag("asmand: bad address %v", obj.Dconv(p, Rconv, a))
+       ctxt.Diag("asmand: bad address %v", obj.Dconv(p, a))
        return
 }
 

diff --git a/src/cmd/internal/obj/i386/list8.go b/src/cmd/internal/obj/i386/list8.go
index ad09679ae59b4cd83664737f88adcb0613100613..e849c81cf3dc6ad7afbbe810ddb57dfd90988cb8 100644 (file)
--- a/src/cmd/internal/obj/i386/list8.go
+++ b/src/cmd/internal/obj/i386/list8.go
@@ -48,21 +48,21 @@ func Pconv(p *obj.Prog) string {
        switch p.As {
        case obj.ADATA:
                str = fmt.Sprintf("%.5d (%v)\t%v\t%v/%d,%v",
-                       p.Pc, p.Line(), Aconv(int(p.As)), obj.Dconv(p, Rconv, &p.From), p.From3.Offset, obj.Dconv(p, Rconv, &p.To))
+                       p.Pc, p.Line(), Aconv(int(p.As)), obj.Dconv(p, &p.From), p.From3.Offset, obj.Dconv(p, &p.To))
 
        case obj.ATEXT:
                if p.From3.Offset != 0 {
                        str = fmt.Sprintf("%.5d (%v)\t%v\t%v,%d,%v",
-                               p.Pc, p.Line(), Aconv(int(p.As)), obj.Dconv(p, Rconv, &p.From), p.From3.Offset, obj.Dconv(p, Rconv, &p.To))
+                               p.Pc, p.Line(), Aconv(int(p.As)), obj.Dconv(p, &p.From), p.From3.Offset, obj.Dconv(p, &p.To))
                        break
                }
 
                str = fmt.Sprintf("%.5d (%v)\t%v\t%v,%v",
-                       p.Pc, p.Line(), Aconv(int(p.As)), obj.Dconv(p, Rconv, &p.From), obj.Dconv(p, Rconv, &p.To))
+                       p.Pc, p.Line(), Aconv(int(p.As)), obj.Dconv(p, &p.From), obj.Dconv(p, &p.To))
 
        default:
                str = fmt.Sprintf("%.5d (%v)\t%v\t%v,%v",
-                       p.Pc, p.Line(), Aconv(int(p.As)), obj.Dconv(p, Rconv, &p.From), obj.Dconv(p, Rconv, &p.To))
+                       p.Pc, p.Line(), Aconv(int(p.As)), obj.Dconv(p, &p.From), obj.Dconv(p, &p.To))
 
                // TODO(rsc): This special case is for SHRQ $32, AX:DX, which encodes as
                //      SHRQ $32(DX*0), AX
@@ -155,20 +155,13 @@ var Register = []string{
        "MAXREG", /* [MAXREG] */
 }
 
-func Rconv(r int) string {
-       var str string
-       var fp string
+func init() {
+       obj.RegisterRegister(obj.RBase386, obj.RBase386+len(Register), Rconv)
+}
 
-       if r == REG_NONE {
-               fp += "NONE"
-               return fp
-       }
+func Rconv(r int) string {
        if r >= REG_AL && r-REG_AL < len(Register) {
-               str = fmt.Sprintf("%s", Register[r-REG_AL])
-       } else {
-               str = fmt.Sprintf("gok(%d)", r)
+               return fmt.Sprintf("%s", Register[r-REG_AL])
        }
-
-       fp += str
-       return fp
+       return fmt.Sprintf("Rgok(%d)", r-obj.RBase386)
 }

diff --git a/src/cmd/internal/obj/link.go b/src/cmd/internal/obj/link.go
index f4b0b64931809ee262548defb544761e2b036d57..a2baec4021cd9c2eca5b10d265b7f3d9a3826fc7 100644 (file)
--- a/src/cmd/internal/obj/link.go
+++ b/src/cmd/internal/obj/link.go
@@ -35,8 +35,9 @@ import "encoding/binary"
 type Addr struct {
        Type   int16
        Reg    int16
+       Reg2   int16 // RHS of register pair. AX:DX (386)
        Index  int16
-       Scale  int8
+       Scale  int16 // Sometimes holds a register.
        Name   int8
        Offset int64
        Sym    *LSym

diff --git a/src/cmd/internal/obj/ppc64/9.out.go b/src/cmd/internal/obj/ppc64/9.out.go
index bcc99ba59e078c79077d05c041f75e202c7d0744..8858a9fe6e239cfbeb0cb35041934c0a234fd94c 100644 (file)
--- a/src/cmd/internal/obj/ppc64/9.out.go
+++ b/src/cmd/internal/obj/ppc64/9.out.go
@@ -45,7 +45,7 @@ const (
 
 // avoid conflict with ucontext.h. sigh.
 const (
-       REG_R0 = 32 + iota
+       REG_R0 = obj.RBasePPC64 + iota
        REG_R1
        REG_R2
        REG_R3
@@ -77,7 +77,7 @@ const (
        REG_R29
        REG_R30
        REG_R31
-       REG_F0 = 64 + iota - 32
+       REG_F0 = obj.RBasePPC64 + 32 + iota - 32
        REG_F1
        REG_F2
        REG_F3
@@ -109,8 +109,8 @@ const (
        REG_F29
        REG_F30
        REG_F31
-       REG_SPECIAL = 96
-       REG_C0      = 96 + iota - 65
+       REG_SPECIAL = obj.RBasePPC64 + 64
+       REG_C0      = obj.RBasePPC64 + 64 + iota - 65
        REG_C1
        REG_C2
        REG_C3
@@ -118,11 +118,11 @@ const (
        REG_C5
        REG_C6
        REG_C7
-       REG_MSR = 104 + iota - 73
+       REG_MSR = obj.RBasePPC64 + 72 + iota - 73
        REG_FPSCR
        REG_CR
-       REG_SPR0 = 1024
-       REG_DCR0 = 2048
+       REG_SPR0 = obj.RBasePPC64 + 1024
+       REG_DCR0 = obj.RBasePPC64 + 2048
        REG_XER  = REG_SPR0 + 1
        REG_LR   = REG_SPR0 + 8
        REG_CTR  = REG_SPR0 + 9

diff --git a/src/cmd/internal/obj/ppc64/asm9.go b/src/cmd/internal/obj/ppc64/asm9.go
index a4e46be9e2cb295e3bd3fd90acaa9f8c6e77b6a6..e5b43968fceb9b96ded0529bd8b4ae0586eed55f 100644 (file)
--- a/src/cmd/internal/obj/ppc64/asm9.go
+++ b/src/cmd/internal/obj/ppc64/asm9.go
@@ -54,7 +54,7 @@ type Optab struct {
        a4    uint8
        type_ int8
        size  int8
-       param int8
+       param int16
 }
 
 var optab = []Optab{

diff --git a/src/cmd/internal/obj/ppc64/list9.go b/src/cmd/internal/obj/ppc64/list9.go
index 171a47327f4d950d6611a47755a16cc9d5ce703b..ad0326bdd00550da1e3161fb23b0a959765bf422 100644 (file)
--- a/src/cmd/internal/obj/ppc64/list9.go
+++ b/src/cmd/internal/obj/ppc64/list9.go
@@ -64,14 +64,14 @@ func Pconv(p *obj.Prog) string {
        str = ""
        if a == obj.ADATA {
                str = fmt.Sprintf("%.5d (%v)\t%v\t%v/%d,%v",
-                       p.Pc, p.Line(), Aconv(a), obj.Dconv(p, Rconv, &p.From), p.From3.Offset, obj.Dconv(p, Rconv, &p.To))
+                       p.Pc, p.Line(), Aconv(a), obj.Dconv(p, &p.From), p.From3.Offset, obj.Dconv(p, &p.To))
        } else if a == obj.ATEXT || a == obj.AGLOBL {
                if p.From3.Offset != 0 {
                        str = fmt.Sprintf("%.5d (%v)\t%v\t%v,%d,%v",
-                               p.Pc, p.Line(), Aconv(a), obj.Dconv(p, Rconv, &p.From), p.From3.Offset, obj.Dconv(p, Rconv, &p.To))
+                               p.Pc, p.Line(), Aconv(a), obj.Dconv(p, &p.From), p.From3.Offset, obj.Dconv(p, &p.To))
                } else {
                        str = fmt.Sprintf("%.5d (%v)\t%v\t%v,%v",
-                               p.Pc, p.Line(), Aconv(a), obj.Dconv(p, Rconv, &p.From), obj.Dconv(p, Rconv, &p.To))
+                               p.Pc, p.Line(), Aconv(a), obj.Dconv(p, &p.From), obj.Dconv(p, &p.To))
                }
        } else {
                if p.Mark&NOSCHED != 0 {
@@ -79,31 +79,31 @@ func Pconv(p *obj.Prog) string {
                }
                if p.Reg == 0 && p.From3.Type == obj.TYPE_NONE {
                        str += fmt.Sprintf("%.5d (%v)\t%v\t%v,%v",
-                               p.Pc, p.Line(), Aconv(a), obj.Dconv(p, Rconv, &p.From), obj.Dconv(p, Rconv, &p.To))
+                               p.Pc, p.Line(), Aconv(a), obj.Dconv(p, &p.From), obj.Dconv(p, &p.To))
                } else if a != obj.ATEXT && p.From.Type == obj.TYPE_MEM {
                        off := ""
                        if p.From.Offset != 0 {
                                off = fmt.Sprintf("%d", p.From.Offset)
                        }
                        str += fmt.Sprintf("%.5d (%v)\t%v\t%s(%v+%v),%v",
-                               p.Pc, p.Line(), Aconv(a), off, Rconv(int(p.From.Reg)), Rconv(int(p.Reg)), obj.Dconv(p, Rconv, &p.To))
+                               p.Pc, p.Line(), Aconv(a), off, Rconv(int(p.From.Reg)), Rconv(int(p.Reg)), obj.Dconv(p, &p.To))
                } else if p.To.Type == obj.TYPE_MEM {
                        off := ""
                        if p.From.Offset != 0 {
                                off = fmt.Sprintf("%d", p.From.Offset)
                        }
                        str += fmt.Sprintf("%.5d (%v)\t%v\t%v,%s(%v+%v)",
-                               p.Pc, p.Line(), Aconv(a), obj.Dconv(p, Rconv, &p.From), off, Rconv(int(p.To.Reg)), Rconv(int(p.Reg)))
+                               p.Pc, p.Line(), Aconv(a), obj.Dconv(p, &p.From), off, Rconv(int(p.To.Reg)), Rconv(int(p.Reg)))
                } else {
                        str += fmt.Sprintf("%.5d (%v)\t%v\t%v",
-                               p.Pc, p.Line(), Aconv(a), obj.Dconv(p, Rconv, &p.From))
+                               p.Pc, p.Line(), Aconv(a), obj.Dconv(p, &p.From))
                        if p.Reg != 0 {
                                str += fmt.Sprintf(",%v", Rconv(int(p.Reg)))
                        }
                        if p.From3.Type != obj.TYPE_NONE {
-                               str += fmt.Sprintf(",%v", obj.Dconv(p, Rconv, &p.From3))
+                               str += fmt.Sprintf(",%v", obj.Dconv(p, &p.From3))
                        }
-                       str += fmt.Sprintf(",%v", obj.Dconv(p, Rconv, &p.To))
+                       str += fmt.Sprintf(",%v", obj.Dconv(p, &p.To))
                }
 
                if p.Spadj != 0 {
@@ -128,63 +128,52 @@ func Aconv(a int) string {
        return fp
 }
 
-func Rconv(r int) string {
-       var fp string
+func init() {
+       obj.RegisterRegister(obj.RBasePPC64, REG_DCR0+1024, Rconv)
+}
 
+func Rconv(r int) string {
        if r == 0 {
-               fp += "NONE"
-               return fp
+               return "NONE"
        }
        if REG_R0 <= r && r <= REG_R31 {
-               fp += fmt.Sprintf("R%d", r-REG_R0)
-               return fp
+               return fmt.Sprintf("R%d", r-REG_R0)
        }
        if REG_F0 <= r && r <= REG_F31 {
-               fp += fmt.Sprintf("F%d", r-REG_F0)
-               return fp
+               return fmt.Sprintf("F%d", r-REG_F0)
        }
        if REG_C0 <= r && r <= REG_C7 {
-               fp += fmt.Sprintf("C%d", r-REG_C0)
-               return fp
+               return fmt.Sprintf("C%d", r-REG_C0)
        }
        if r == REG_CR {
-               fp += "CR"
-               return fp
+               return "CR"
        }
        if REG_SPR0 <= r && r <= REG_SPR0+1023 {
                switch r {
                case REG_XER:
-                       fp += "XER"
-                       return fp
+                       return "XER"
 
                case REG_LR:
-                       fp += "LR"
-                       return fp
+                       return "LR"
 
                case REG_CTR:
-                       fp += "CTR"
-                       return fp
+                       return "CTR"
                }
 
-               fp += fmt.Sprintf("SPR(%d)", r-REG_SPR0)
-               return fp
+               return fmt.Sprintf("SPR(%d)", r-REG_SPR0)
        }
 
        if REG_DCR0 <= r && r <= REG_DCR0+1023 {
-               fp += fmt.Sprintf("DCR(%d)", r-REG_DCR0)
-               return fp
+               return fmt.Sprintf("DCR(%d)", r-REG_DCR0)
        }
        if r == REG_FPSCR {
-               fp += "FPSCR"
-               return fp
+               return "FPSCR"
        }
        if r == REG_MSR {
-               fp += "MSR"
-               return fp
+               return "MSR"
        }
 
-       fp += fmt.Sprintf("badreg(%d)", r)
-       return fp
+       return fmt.Sprintf("Rgok(%d)", r-obj.RBasePPC64)
 }
 
 func DRconv(a int) string {

diff --git a/src/cmd/internal/obj/util.go b/src/cmd/internal/obj/util.go
index 4dad7904dbee067bdc853e013c1b1c06f2cdd7d7..4a7578b2573f76e42973f081de725c422e09941e 100644 (file)
--- a/src/cmd/internal/obj/util.go
+++ b/src/cmd/internal/obj/util.go
@@ -261,19 +261,15 @@ func (ctxt *Link) Line(n int) string {
        return Linklinefmt(ctxt, n, false, false)
 }
 
-func (ctxt *Link) Rconv(reg int) string {
-       return ctxt.Arch.Rconv(reg)
-}
-
 func Getcallerpc(interface{}) uintptr {
        return 1
 }
 
 func (ctxt *Link) Dconv(a *Addr) string {
-       return Dconv(nil, ctxt.Rconv, a)
+       return Dconv(nil, a)
 }
 
-func Dconv(p *Prog, Rconv func(int) string, a *Addr) string {
+func Dconv(p *Prog, a *Addr) string {
        var str string
 
        switch a.Type {
@@ -283,7 +279,7 @@ func Dconv(p *Prog, Rconv func(int) string, a *Addr) string {
        case TYPE_NONE:
                str = ""
                if a.Name != NAME_NONE || a.Reg != 0 || a.Sym != nil {
-                       str = fmt.Sprintf("%v(%v)(NONE)", Mconv(Rconv, a), Rconv(int(a.Reg)))
+                       str = fmt.Sprintf("%v(%v)(NONE)", Mconv(a), Rconv(int(a.Reg)))
                }
 
        case TYPE_REG:
@@ -298,7 +294,7 @@ func Dconv(p *Prog, Rconv func(int) string, a *Addr) string {
 
                str = fmt.Sprintf("%v", Rconv(int(a.Reg)))
                if a.Name != TYPE_NONE || a.Sym != nil {
-                       str = fmt.Sprintf("%v(%v)(REG)", Mconv(Rconv, a), Rconv(int(a.Reg)))
+                       str = fmt.Sprintf("%v(%v)(REG)", Mconv(a), Rconv(int(a.Reg)))
                }
 
        case TYPE_BRANCH:
@@ -313,19 +309,19 @@ func Dconv(p *Prog, Rconv func(int) string, a *Addr) string {
                }
 
        case TYPE_INDIR:
-               str = fmt.Sprintf("*%s", Mconv(Rconv, a))
+               str = fmt.Sprintf("*%s", Mconv(a))
 
        case TYPE_MEM:
-               str = Mconv(Rconv, a)
+               str = Mconv(a)
                if a.Index != REG_NONE {
                        str += fmt.Sprintf("(%v*%d)", Rconv(int(a.Index)), int(a.Scale))
                }
 
        case TYPE_CONST:
                if a.Reg != 0 {
-                       str = fmt.Sprintf("$%v(%v)", Mconv(Rconv, a), Rconv(int(a.Reg)))
+                       str = fmt.Sprintf("$%v(%v)", Mconv(a), Rconv(int(a.Reg)))
                } else {
-                       str = fmt.Sprintf("$%v", Mconv(Rconv, a))
+                       str = fmt.Sprintf("$%v", Mconv(a))
                }
 
        case TYPE_TEXTSIZE:
@@ -347,7 +343,7 @@ func Dconv(p *Prog, Rconv func(int) string, a *Addr) string {
                str = fmt.Sprintf("$%q", a.U.Sval)
 
        case TYPE_ADDR:
-               str = fmt.Sprintf("$%s", Mconv(Rconv, a))
+               str = fmt.Sprintf("$%s", Mconv(a))
 
        case TYPE_SHIFT:
                v := int(a.Offset)
@@ -371,7 +367,7 @@ func Dconv(p *Prog, Rconv func(int) string, a *Addr) string {
        return str
 }
 
-func Mconv(Rconv func(int) string, a *Addr) string {
+func Mconv(a *Addr) string {
        var str string
 
        switch a.Name {
@@ -417,3 +413,49 @@ func offConv(off int64) string {
        }
        return fmt.Sprintf("%+d", off)
 }
+
+type regSet struct {
+       lo    int
+       hi    int
+       Rconv func(int) string
+}
+
+// Few enough architectures that a linear scan is fastest.
+// Not even worth sorting.
+var regSpace []regSet
+
+/*
+       Each architecture defines a register space as a unique
+       integer range.
+       Here is the list of architectures and the base of their register spaces.
+*/
+
+const (
+       // Because of masking operations in the encodings, each register
+       // space should start at 0 modulo some power of 2.
+       RBase386   = 1 * 1024
+       RBaseAMD64 = 2 * 1024
+       RBaseARM   = 3 * 1024
+       RBasePPC64 = 4 * 1024
+       // The next free base is 8*1024 (PPC64 has many registers).
+)
+
+// RegisterRegister binds a pretty-printer (Rconv) for register
+// numbers to a given register number range.  Lo is inclusive,
+// hi exclusive (valid registers are lo through hi-1).
+func RegisterRegister(lo, hi int, Rconv func(int) string) {
+       regSpace = append(regSpace, regSet{lo, hi, Rconv})
+}
+
+func Rconv(reg int) string {
+       if reg == REG_NONE {
+               return "NONE"
+       }
+       for i := range regSpace {
+               rs := &regSpace[i]
+               if rs.lo <= reg && reg < rs.hi {
+                       return rs.Rconv(reg)
+               }
+       }
+       return fmt.Sprintf("R???%d", reg)
+}

diff --git a/src/cmd/internal/obj/x86/6.out.go b/src/cmd/internal/obj/x86/6.out.go
index 9a6cef32276a96338a5ba573ad9731c93b961a76..82f9291d61b399a70adeef28bc6c4f6311d1d218 100644 (file)
--- a/src/cmd/internal/obj/x86/6.out.go
+++ b/src/cmd/internal/obj/x86/6.out.go
@@ -714,7 +714,7 @@ const (
 
 const (
        REG_NONE = 0
-       REG_AL   = 0 + 16 + iota - 1
+       REG_AL   = obj.RBaseAMD64 + 0 + iota - 1
        REG_CL
        REG_DL
        REG_BL
@@ -730,7 +730,7 @@ const (
        REG_R13B
        REG_R14B
        REG_R15B
-       REG_AX = 16 + 16 + iota - 17
+       REG_AX = obj.RBaseAMD64 + 16 + iota - 17
        REG_CX
        REG_DX
        REG_BX
@@ -746,13 +746,13 @@ const (
        REG_R13
        REG_R14
        REG_R15
-       REG_AH = 32 + 16 + iota - 33
+       REG_AH = obj.RBaseAMD64 + 32 + iota - 33
        REG_CH
        REG_DH
        REG_BH
-       REG_F0 = 36 + 16
-       REG_M0 = 44 + 16
-       REG_X0 = 52 + 16 + iota - 39
+       REG_F0 = obj.RBaseAMD64 + 36
+       REG_M0 = obj.RBaseAMD64 + 44
+       REG_X0 = obj.RBaseAMD64 + 52 + iota - 39
        REG_X1
        REG_X2
        REG_X3
@@ -768,7 +768,7 @@ const (
        REG_X13
        REG_X14
        REG_X15
-       REG_CS = 68 + 16 + iota - 55
+       REG_CS = obj.RBaseAMD64 + 68 + iota - 55
        REG_SS
        REG_DS
        REG_ES
@@ -779,10 +779,10 @@ const (
        REG_LDTR
        REG_MSW
        REG_TASK
-       REG_CR  = 79 + 16
-       REG_DR  = 95 + 16
-       REG_TR  = 103 + 16
-       REG_TLS = 111 + 16 + iota - 69
+       REG_CR  = obj.RBaseAMD64 + 79
+       REG_DR  = obj.RBaseAMD64 + 95
+       REG_TR  = obj.RBaseAMD64 + 103
+       REG_TLS = obj.RBaseAMD64 + 111 + iota - 69
        MAXREG
        REGARG   = -1
        REGRET   = REG_AX

diff --git a/src/cmd/internal/obj/x86/asm6.go b/src/cmd/internal/obj/x86/asm6.go
index 37a5d18ea6a5d2a4c233bd1c4ae60652c08f3264..5af037f90f45073f0ebbc9bce26c028ba4c2df86 100644 (file)
--- a/src/cmd/internal/obj/x86/asm6.go
+++ b/src/cmd/internal/obj/x86/asm6.go
@@ -1931,7 +1931,7 @@ func oclass(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) int {
                }
 
                if a.Sym != nil || a.Name != obj.NAME_NONE {
-                       ctxt.Diag("unexpected addr: %v", obj.Dconv(p, Rconv, a))
+                       ctxt.Diag("unexpected addr: %v", obj.Dconv(p, a))
                }
                fallthrough
 
@@ -1939,7 +1939,7 @@ func oclass(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) int {
 
        case obj.TYPE_CONST:
                if a.Sym != nil {
-                       ctxt.Diag("TYPE_CONST with symbol: %v", obj.Dconv(p, Rconv, a))
+                       ctxt.Diag("TYPE_CONST with symbol: %v", obj.Dconv(p, a))
                }
 
                v = a.Offset
@@ -1966,7 +1966,7 @@ func oclass(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) int {
        }
 
        if a.Type != obj.TYPE_REG {
-               ctxt.Diag("unexpected addr1: type=%d %v", a.Type, obj.Dconv(p, Rconv, a))
+               ctxt.Diag("unexpected addr1: type=%d %v", a.Type, obj.Dconv(p, a))
                return Yxxx
        }
 
@@ -2317,7 +2317,7 @@ func vaddr(ctxt *obj.Link, p *obj.Prog, a *obj.Addr, r *obj.Reloc) int64 {
                obj.NAME_EXTERN:
                s = a.Sym
                if r == nil {
-                       ctxt.Diag("need reloc for %v", obj.Dconv(p, Rconv, a))
+                       ctxt.Diag("need reloc for %v", obj.Dconv(p, a))
                        log.Fatalf("reloc")
                }
 
@@ -2343,7 +2343,7 @@ func vaddr(ctxt *obj.Link, p *obj.Prog, a *obj.Addr, r *obj.Reloc) int64 {
 
        if (a.Type == obj.TYPE_MEM || a.Type == obj.TYPE_ADDR) && a.Reg == REG_TLS {
                if r == nil {
-                       ctxt.Diag("need reloc for %v", obj.Dconv(p, Rconv, a))
+                       ctxt.Diag("need reloc for %v", obj.Dconv(p, a))
                        log.Fatalf("reloc")
                }
 
@@ -2545,7 +2545,7 @@ putrelv:
        return
 
 bad:
-       ctxt.Diag("asmand: bad address %v", obj.Dconv(p, Rconv, a))
+       ctxt.Diag("asmand: bad address %v", obj.Dconv(p, a))
        return
 }
 

diff --git a/src/cmd/internal/obj/x86/list6.go b/src/cmd/internal/obj/x86/list6.go
index b628bb2a7146fe77afbec3034e792399906c5a6e..eb32266b97c0fffe2c6c683f417ce491ece31349 100644 (file)
--- a/src/cmd/internal/obj/x86/list6.go
+++ b/src/cmd/internal/obj/x86/list6.go
@@ -60,21 +60,21 @@ func Pconv(p *obj.Prog) string {
        switch p.As {
        case obj.ADATA:
                str = fmt.Sprintf("%.5d (%v)\t%v\t%v/%d,%v",
-                       p.Pc, p.Line(), Aconv(int(p.As)), obj.Dconv(p, Rconv, &p.From), p.From3.Offset, obj.Dconv(p, Rconv, &p.To))
+                       p.Pc, p.Line(), Aconv(int(p.As)), obj.Dconv(p, &p.From), p.From3.Offset, obj.Dconv(p, &p.To))
 
        case obj.ATEXT:
                if p.From3.Offset != 0 {
                        str = fmt.Sprintf("%.5d (%v)\t%v\t%v,%d,%v",
-                               p.Pc, p.Line(), Aconv(int(p.As)), obj.Dconv(p, Rconv, &p.From), p.From3.Offset, obj.Dconv(p, Rconv, &p.To))
+                               p.Pc, p.Line(), Aconv(int(p.As)), obj.Dconv(p, &p.From), p.From3.Offset, obj.Dconv(p, &p.To))
                        break
                }
 
                str = fmt.Sprintf("%.5d (%v)\t%v\t%v,%v",
-                       p.Pc, p.Line(), Aconv(int(p.As)), obj.Dconv(p, Rconv, &p.From), obj.Dconv(p, Rconv, &p.To))
+                       p.Pc, p.Line(), Aconv(int(p.As)), obj.Dconv(p, &p.From), obj.Dconv(p, &p.To))
 
        default:
                str = fmt.Sprintf("%.5d (%v)\t%v\t%v,%v",
-                       p.Pc, p.Line(), Aconv(int(p.As)), obj.Dconv(p, Rconv, &p.From), obj.Dconv(p, Rconv, &p.To))
+                       p.Pc, p.Line(), Aconv(int(p.As)), obj.Dconv(p, &p.From), obj.Dconv(p, &p.To))
 
                // TODO(rsc): This special case is for SHRQ $32, AX:DX, which encodes as
                //      SHRQ $32(DX*0), AX
@@ -211,21 +211,13 @@ var Register = []string{
        "MAXREG", /* [MAXREG] */
 }
 
-func Rconv(r int) string {
-       var str string
-       var fp string
-
-       if r == REG_NONE {
-               fp += "NONE"
-               return fp
-       }
+func init() {
+       obj.RegisterRegister(REG_AL, REG_AL+len(Register), Rconv)
+}
 
+func Rconv(r int) string {
        if REG_AL <= r && r-REG_AL < len(Register) {
-               str = fmt.Sprintf("%s", Register[r-REG_AL])
-       } else {
-               str = fmt.Sprintf("gok(%d)", r)
+               return fmt.Sprintf("%s", Register[r-REG_AL])
        }
-
-       fp += str
-       return fp
+       return fmt.Sprintf("Rgok(%d)", r-obj.RBaseAMD64)
 }