cmd/5a, cmd/5g, cmd/5l, liblink: update for portable Prog, Addr

Change-Id: I06762d4fb3bb2616087339b6ae1eb5267a39c46a
Reviewed-on: https://go-review.googlesource.com/3516Reviewed-by: Austin Clements <austin@google.com>

src/cmd/5a/a.y

@@ -111,53 +111,53 @@ inst:
 	}
 |	LTYPE1 cond imsr ',' reg
 	{
-		outcode($1, $2, &$3, NREG, &$5);
+		outcode($1, $2, &$3, 0, &$5);
 	}
 /*
  * MVN
  */
 |	LTYPE2 cond imsr ',' reg
 	{
-		outcode($1, $2, &$3, NREG, &$5);
+		outcode($1, $2, &$3, 0, &$5);
 	}
 /*
  * MOVW
  */
 |	LTYPE3 cond gen ',' gen
 	{
-		outcode($1, $2, &$3, NREG, &$5);
+		outcode($1, $2, &$3, 0, &$5);
 	}
 /*
  * B/BL
  */
 |	LTYPE4 cond comma rel
 	{
-		outcode($1, $2, &nullgen, NREG, &$4);
+		outcode($1, $2, &nullgen, 0, &$4);
 	}
 |	LTYPE4 cond comma nireg
 	{
-		outcode($1, $2, &nullgen, NREG, &$4);
+		outcode($1, $2, &nullgen, 0, &$4);
 	}
 /*
  * BX
  */
 |	LTYPEBX comma ireg
 	{
-		outcode($1, Always, &nullgen, NREG, &$3);
+		outcode($1, Always, &nullgen, 0, &$3);
 	}
 /*
  * BEQ
  */
 |	LTYPE5 comma rel
 	{
-		outcode($1, Always, &nullgen, NREG, &$3);
+		outcode($1, Always, &nullgen, 0, &$3);
 	}
 /*
  * SWI
  */
 |	LTYPE6 cond comma gen
 	{
-		outcode($1, $2, &nullgen, NREG, &$4);
+		outcode($1, $2, &nullgen, 0, &$4);
 	}
 /*
  * CMP
@@ -174,18 +174,18 @@ inst:
 		Addr g;
 
 		g = nullgen;
-		g.type = D_CONST;
+		g.type = TYPE_CONST;
 		g.offset = $6;
-		outcode($1, $2, &$3, NREG, &g);
+		outcode($1, $2, &$3, 0, &g);
 	}
 |	LTYPE8 cond '[' reglist ']' ',' ioreg
 	{
 		Addr g;
 
 		g = nullgen;
-		g.type = D_CONST;
+		g.type = TYPE_CONST;
 		g.offset = $4;
-		outcode($1, $2, &g, NREG, &$7);
+		outcode($1, $2, &g, 0, &$7);
 	}
 /*
  * SWAP
@@ -207,7 +207,7 @@ inst:
  */
 |	LTYPEA cond comma
 	{
-		outcode($1, $2, &nullgen, NREG, &nullgen);
+		outcode($1, $2, &nullgen, 0, &nullgen);
 	}
 /*
  * TEXT/GLOBL
@@ -215,22 +215,22 @@ inst:
 |	LTYPEB name ',' imm
 	{
 		settext($2.sym);
-		$4.type = D_CONST2;
-		$4.offset2 = ArgsSizeUnknown;
+		$4.type = TYPE_TEXTSIZE;
+		$4.u.argsize = ArgsSizeUnknown;
 		outcode($1, Always, &$2, 0, &$4);
 	}
 |	LTYPEB name ',' con ',' imm
 	{
 		settext($2.sym);
-		$6.type = D_CONST2;
-		$6.offset2 = ArgsSizeUnknown;
+		$6.type = TYPE_TEXTSIZE;
+		$6.u.argsize = ArgsSizeUnknown;
 		outcode($1, Always, &$2, $4, &$6);
 	}
 |	LTYPEB name ',' con ',' imm '-' con
 	{
 		settext($2.sym);
-		$6.type = D_CONST2;
-		$6.offset2 = $8;
+		$6.type = TYPE_TEXTSIZE;
+		$6.u.argsize = $8;
 		outcode($1, Always, &$2, $4, &$6);
 	}
 /*
@@ -245,25 +245,25 @@ inst:
  */
 |	LTYPED cond reg comma
 	{
-		outcode($1, $2, &$3, NREG, &nullgen);
+		outcode($1, $2, &$3, 0, &nullgen);
 	}
 /*
  * word
  */
 |	LTYPEH comma ximm
 	{
-		outcode($1, Always, &nullgen, NREG, &$3);
+		outcode($1, Always, &nullgen, 0, &$3);
 	}
 /*
  * floating-point coprocessor
  */
 |	LTYPEI cond freg ',' freg
 	{
-		outcode($1, $2, &$3, NREG, &$5);
+		outcode($1, $2, &$3, 0, &$5);
 	}
 |	LTYPEK cond frcon ',' freg
 	{
-		outcode($1, $2, &$3, NREG, &$5);
+		outcode($1, $2, &$3, 0, &$5);
 	}
 |	LTYPEK cond frcon ',' LFREG ',' freg
 	{
@@ -281,7 +281,7 @@ inst:
 		Addr g;
 
 		g = nullgen;
-		g.type = D_CONST;
+		g.type = TYPE_CONST;
 		g.offset =
 			(0xe << 24) |		/* opcode */
 			($1 << 20) |		/* MCR/MRC */
@@ -293,7 +293,7 @@ inst:
 			(($11 & 15) << 0) |	/* Crm */
 			(($12 & 7) << 5) |	/* coprocessor information */
 			(1<<4);			/* must be set */
-		outcode(AMRC, Always, &nullgen, NREG, &g);
+		outcode(AMRC, Always, &nullgen, 0, &g);
 	}
 /*
  * MULL r1,r2,(hi,lo)
@@ -308,7 +308,7 @@ inst:
  */
 |	LTYPEN cond reg ',' reg ',' reg ',' spreg
 	{
-		$7.type = D_REGREG2;
+		$7.type = TYPE_REGREG2;
 		$7.offset = $9;
 		outcode($1, $2, &$3, $5.reg, &$7);
 	}
@@ -317,34 +317,34 @@ inst:
  */
 |	LTYPEPLD oreg
 	{
-		outcode($1, Always, &$2, NREG, &nullgen);
+		outcode($1, Always, &$2, 0, &nullgen);
 	}
 /*
  * PCDATA
  */
 |	LTYPEPC gen ',' gen
 	{
-		if($2.type != D_CONST || $4.type != D_CONST)
+		if($2.type != TYPE_CONST || $4.type != TYPE_CONST)
 			yyerror("arguments to PCDATA must be integer constants");
-		outcode($1, Always, &$2, NREG, &$4);
+		outcode($1, Always, &$2, 0, &$4);
 	}
 /*
  * FUNCDATA
  */
 |	LTYPEF gen ',' gen
 	{
-		if($2.type != D_CONST)
+		if($2.type != TYPE_CONST)
 			yyerror("index for FUNCDATA must be integer constant");
-		if($4.type != D_EXTERN && $4.type != D_STATIC && $4.type != D_OREG)
+		if($4.type != NAME_EXTERN && $4.type != NAME_STATIC && $4.type != TYPE_MEM)
 			yyerror("value for FUNCDATA must be symbol reference");
- 		outcode($1, Always, &$2, NREG, &$4);
+ 		outcode($1, Always, &$2, 0, &$4);
 	}
 /*
  * END
  */
 |	LTYPEE comma
 	{
-		outcode($1, Always, &nullgen, NREG, &nullgen);
+		outcode($1, Always, &nullgen, 0, &nullgen);
 	}
 
 cond:
@@ -367,7 +367,7 @@ rel:
 	con '(' LPC ')'
 	{
 		$$ = nullgen;
-		$$.type = D_BRANCH;
+		$$.type = TYPE_BRANCH;
 		$$.offset = $1 + pc;
 	}
 |	LNAME offset
@@ -376,30 +376,25 @@ rel:
 		$$ = nullgen;
 		if(pass == 2 && $1->type != LLAB)
 			yyerror("undefined label: %s", $1->labelname);
-		$$.type = D_BRANCH;
+		$$.type = TYPE_BRANCH;
 		$$.offset = $1->value + $2;
 	}
 
 ximm:	'$' con
 	{
 		$$ = nullgen;
-		$$.type = D_CONST;
+		$$.type = TYPE_CONST;
 		$$.offset = $2;
 	}
 |	'$' oreg
 	{
 		$$ = $2;
-		$$.type = D_CONST;
-	}
-|	'$' '*' '$' oreg
-	{
-		$$ = $4;
-		$$.type = D_OCONST;
+		$$.type = TYPE_CONST;
 	}
 |	'$' LSCONST
 	{
 		$$ = nullgen;
-		$$.type = D_SCONST;
+		$$.type = TYPE_SCONST;
 		memcpy($$.u.sval, $2, sizeof($$.u.sval));
 	}
 |	fcon
@@ -408,13 +403,13 @@ fcon:
 	'$' LFCONST
 	{
 		$$ = nullgen;
-		$$.type = D_FCONST;
+		$$.type = TYPE_FCONST;
 		$$.u.dval = $2;
 	}
 |	'$' '-' LFCONST
 	{
 		$$ = nullgen;
-		$$.type = D_FCONST;
+		$$.type = TYPE_FCONST;
 		$$.u.dval = -$3;
 	}
 
@@ -449,19 +444,19 @@ gen:
 |	LPSR
 	{
 		$$ = nullgen;
-		$$.type = D_PSR;
+		$$.type = TYPE_REG;
 		$$.reg = $1;
 	}
 |	LFCR
 	{
 		$$ = nullgen;
-		$$.type = D_FPCR;
+		$$.type = TYPE_REG;
 		$$.reg = $1;
 	}
 |	con
 	{
 		$$ = nullgen;
-		$$.type = D_OREG;
+		$$.type = TYPE_MEM;
 		$$.offset = $1;
 	}
 |	oreg
@@ -472,7 +467,7 @@ nireg:
 |	name
 	{
 		$$ = $1;
-		if($1.name != D_EXTERN && $1.name != D_STATIC) {
+		if($1.name != NAME_EXTERN && $1.name != NAME_STATIC) {
 		}
 	}
 
@@ -480,7 +475,7 @@ ireg:
 	'(' spreg ')'
 	{
 		$$ = nullgen;
-		$$.type = D_OREG;
+		$$.type = TYPE_MEM;
 		$$.reg = $2;
 		$$.offset = 0;
 	}
@@ -490,7 +485,7 @@ ioreg:
 |	con '(' sreg ')'
 	{
 		$$ = nullgen;
-		$$.type = D_OREG;
+		$$.type = TYPE_MEM;
 		$$.reg = $3;
 		$$.offset = $1;
 	}
@@ -500,7 +495,7 @@ oreg:
 |	name '(' sreg ')'
 	{
 		$$ = $1;
-		$$.type = D_OREG;
+		$$.type = TYPE_MEM;
 		$$.reg = $3;
 	}
 |	ioreg
@@ -513,7 +508,7 @@ imsr:
 imm:	'$' con
 	{
 		$$ = nullgen;
-		$$.type = D_CONST;
+		$$.type = TYPE_CONST;
 		$$.offset = $2;
 	}
 
@@ -521,7 +516,7 @@ reg:
 	spreg
 	{
 		$$ = nullgen;
-		$$.type = D_REG;
+		$$.type = TYPE_REG;
 		$$.reg = $1;
 	}
 
@@ -529,7 +524,7 @@ regreg:
 	'(' spreg ',' spreg ')'
 	{
 		$$ = nullgen;
-		$$.type = D_REGREG;
+		$$.type = TYPE_REGREG;
 		$$.reg = $2;
 		$$.offset = $4;
 	}
@@ -538,33 +533,33 @@ shift:
 	spreg '<' '<' rcon
 	{
 		$$ = nullgen;
-		$$.type = D_SHIFT;
-		$$.offset = $1 | $4 | (0 << 5);
+		$$.type = TYPE_SHIFT;
+		$$.offset = $1&15 | $4 | (0 << 5);
 	}
 |	spreg '>' '>' rcon
 	{
 		$$ = nullgen;
-		$$.type = D_SHIFT;
-		$$.offset = $1 | $4 | (1 << 5);
+		$$.type = TYPE_SHIFT;
+		$$.offset = $1&15 | $4 | (1 << 5);
 	}
 |	spreg '-' '>' rcon
 	{
 		$$ = nullgen;
-		$$.type = D_SHIFT;
-		$$.offset = $1 | $4 | (2 << 5);
+		$$.type = TYPE_SHIFT;
+		$$.offset = $1&15 | $4 | (2 << 5);
 	}
 |	spreg LAT '>' rcon
 	{
 		$$ = nullgen;
-		$$.type = D_SHIFT;
-		$$.offset = $1 | $4 | (3 << 5);
+		$$.type = TYPE_SHIFT;
+		$$.offset = $1&15 | $4 | (3 << 5);
 	}
 
 rcon:
 	spreg
 	{
-		if($$ < 0 || $$ >= 16)
-			print("register value out of range\n");
+		if($$ < REG_R0 || $$ > REG_R15)
+			print("register value out of range in shift\n");
 		$$ = (($1&15) << 8) | (1 << 4);
 	}
 |	con
@@ -583,8 +578,8 @@ sreg:
 |	LR '(' expr ')'
 	{
 		if($3 < 0 || $3 >= NREG)
-			print("register value out of range\n");
-		$$ = $3;
+			print("register value out of range in R(...)\n");
+		$$ = REG_R0 + $3;
 	}
 
 spreg:
@@ -599,8 +594,8 @@ creg:
 |	LC '(' expr ')'
 	{
 		if($3 < 0 || $3 >= NREG)
-			print("register value out of range\n");
-		$$ = $3;
+			print("register value out of range in C(...)\n");
+		$$ = $3; // TODO(rsc): REG_C0+$3
 	}
 
 frcon:
@@ -611,21 +606,21 @@ freg:
 	LFREG
 	{
 		$$ = nullgen;
-		$$.type = D_FREG;
+		$$.type = TYPE_REG;
 		$$.reg = $1;
 	}
 |	LF '(' con ')'
 	{
 		$$ = nullgen;
-		$$.type = D_FREG;
-		$$.reg = $3;
+		$$.type = TYPE_REG;
+		$$.reg = REG_F0 + $3;
 	}
 
 name:
 	con '(' pointer ')'
 	{
 		$$ = nullgen;
-		$$.type = D_OREG;
+		$$.type = TYPE_MEM;
 		$$.name = $3;
 		$$.sym = nil;
 		$$.offset = $1;
@@ -633,7 +628,7 @@ name:
 |	LNAME offset '(' pointer ')'
 	{
 		$$ = nullgen;
-		$$.type = D_OREG;
+		$$.type = TYPE_MEM;
 		$$.name = $4;
 		$$.sym = linklookup(ctxt, $1->name, 0);
 		$$.offset = $2;
@@ -641,8 +636,8 @@ name:
 |	LNAME '<' '>' offset '(' LSB ')'
 	{
 		$$ = nullgen;
-		$$.type = D_OREG;
-		$$.name = D_STATIC;
+		$$.type = TYPE_MEM;
+		$$.name = NAME_STATIC;
 		$$.sym = linklookup(ctxt, $1->name, 1);
 		$$.offset = $4;
 	}

src/cmd/5a/lex.c

@@ -187,47 +187,48 @@ struct
 	ushort	value;
 } itab[] =
 {
-	"SP",		LSP,	D_AUTO,
-	"SB",		LSB,	D_EXTERN,
-	"FP",		LFP,	D_PARAM,
-	"PC",		LPC,	D_BRANCH,
-
-	"R",		LR,	0,
-	"R0",		LREG,	0,
-	"R1",		LREG,	1,
-	"R2",		LREG,	2,
-	"R3",		LREG,	3,
-	"R4",		LREG,	4,
-	"R5",		LREG,	5,
-	"R6",		LREG,	6,
-	"R7",		LREG,	7,
-	"R8",		LREG,	8,
-	"R9",		LREG,	9,
-	"g",		LREG,	10, // avoid unintentionally clobber g using R10
-	"R11",		LREG,	11,
-	"R12",		LREG,	12,
-	"R13",		LREG,	13,
-	"R14",		LREG,	14,
-	"R15",		LREG,	15,
-
-	"F",		LF,	0,
-
-	"F0",		LFREG,	0,
-	"F1",		LFREG,	1,
-	"F2",		LFREG,	2,
-	"F3",		LFREG,	3,
-	"F4",		LFREG,	4,
-	"F5",		LFREG,	5,
-	"F6",		LFREG,	6,
-	"F7",		LFREG,	7,
-	"F8",		LFREG,	8,
-	"F9",		LFREG,	9,
-	"F10",		LFREG,	10,
-	"F11",		LFREG,	11,
-	"F12",		LFREG,	12,
-	"F13",		LFREG,	13,
-	"F14",		LFREG,	14,
-	"F15",		LFREG,	15,
+	"SP",		LSP,	NAME_AUTO,
+	"SB",		LSB,	NAME_EXTERN,
+	"FP",		LFP,	NAME_PARAM,
+	"PC",		LPC,	TYPE_BRANCH,
+
+	"R",		LR,	REG_F0,
+
+	"R0",		LREG,	REG_R0,
+	"R1",		LREG,	REG_R1,
+	"R2",		LREG,	REG_R2,
+	"R3",		LREG,	REG_R3,
+	"R4",		LREG,	REG_R4,
+	"R5",		LREG,	REG_R5,
+	"R6",		LREG,	REG_R6,
+	"R7",		LREG,	REG_R7,
+	"R8",		LREG,	REG_R8,
+	"R9",		LREG,	REG_R9,
+	"g",		LREG,	REG_R10, // avoid unintentionally clobber g using R10
+	"R11",		LREG,	REG_R11,
+	"R12",		LREG,	REG_R12,
+	"R13",		LREG,	REG_R13,
+	"R14",		LREG,	REG_R14,
+	"R15",		LREG,	REG_R15,
+
+	"F",		LF,	REG_F0,
+
+	"F0",		LFREG,	REG_F0,
+	"F1",		LFREG,	REG_F1,
+	"F2",		LFREG,	REG_F2,
+	"F3",		LFREG,	REG_F3,
+	"F4",		LFREG,	REG_F4,
+	"F5",		LFREG,	REG_F5,
+	"F6",		LFREG,	REG_F6,
+	"F7",		LFREG,	REG_F7,
+	"F8",		LFREG,	REG_F8,
+	"F9",		LFREG,	REG_F9,
+	"F10",		LFREG,	REG_F10,
+	"F11",		LFREG,	REG_F11,
+	"F12",		LFREG,	REG_F12,
+	"F13",		LFREG,	REG_F13,
+	"F14",		LFREG,	REG_F14,
+	"F15",		LFREG,	REG_F15,
 
 	"C",		LC,	0,
 
@@ -248,11 +249,11 @@ struct
 	"C14",		LCREG,	14,
 	"C15",		LCREG,	15,
 
-	"CPSR",		LPSR,	0,
-	"SPSR",		LPSR,	1,
+	"CPSR",		LPSR,	REG_CPSR,
+	"SPSR",		LPSR,	REG_SPSR,
 
-	"FPSR",		LFCR,	0,
-	"FPCR",		LFCR,	1,
+	"FPSR",		LFCR,	REG_FPSR,
+	"FPCR",		LFCR,	REG_FPCR,
 
 	".EQ",		LCOND,	0,
 	".NE",		LCOND,	1,
@@ -437,9 +438,8 @@ cinit(void)
 	Sym *s;
 	int i;
 
-	nullgen.type = D_NONE;
-	nullgen.name = D_NONE;
-	nullgen.reg = NREG;
+	nullgen.type = TYPE_NONE;
+	nullgen.name = NAME_NONE;
 
 	nerrors = 0;
 	iostack = I;
@@ -474,7 +474,7 @@ isreg(Addr *g)
 void
 cclean(void)
 {
-	outcode(AEND, Always, &nullgen, NREG, &nullgen);
+	outcode(AEND, Always, &nullgen, 0, &nullgen);
 }
 
 static int bcode[] =

src/cmd/5g/cgen.c

@@ -1029,7 +1029,7 @@ agenr(Node *n, Node *a, Node *res)
 			regalloc(&n3, types[tptr], res);
 			p1 = gins(AMOVW, N, &n3);
 			datastring(nl->val.u.sval->s, nl->val.u.sval->len, &p1->from);
-			p1->from.type = D_CONST;
+			p1->from.type = TYPE_CONST;
 		} else
 		if(isslice(nl->type) || nl->type->etype == TSTRING) {
 			n1 = n3;
@@ -1552,7 +1552,7 @@ sgen(Node *n, Node *res, int64 w)
 		regalloc(&nend, types[TUINT32], N);
 
 		p = gins(AMOVW, &src, &nend);
-		p->from.type = D_CONST;
+		p->from.type = TYPE_CONST;
 		if(dir < 0)
 			p->from.offset = dir;
 		else
@@ -1562,24 +1562,24 @@ sgen(Node *n, Node *res, int64 w)
 	// move src and dest to the end of block if necessary
 	if(dir < 0) {
 		p = gins(AMOVW, &src, &src);
-		p->from.type = D_CONST;
+		p->from.type = TYPE_CONST;
 		p->from.offset = w + dir;
 
 		p = gins(AMOVW, &dst, &dst);
-		p->from.type = D_CONST;
+		p->from.type = TYPE_CONST;
 		p->from.offset = w + dir;
 	}
 	
 	// move
 	if(c >= 4) {
 		p = gins(op, &src, &tmp);
-		p->from.type = D_OREG;
+		p->from.type = TYPE_MEM;
 		p->from.offset = dir;
 		p->scond |= C_PBIT;
 		ploop = p;
 
 		p = gins(op, &tmp, &dst);
-		p->to.type = D_OREG;
+		p->to.type = TYPE_MEM;
 		p->to.offset = dir;
 		p->scond |= C_PBIT;
 
@@ -1591,12 +1591,12 @@ sgen(Node *n, Node *res, int64 w)
 	} else {
 		while(c-- > 0) {
 			p = gins(op, &src, &tmp);
-			p->from.type = D_OREG;
+			p->from.type = TYPE_MEM;
 			p->from.offset = dir;
 			p->scond |= C_PBIT;
 	
 			p = gins(op, &tmp, &dst);
-			p->to.type = D_OREG;
+			p->to.type = TYPE_MEM;
 			p->to.offset = dir;
 			p->scond |= C_PBIT;
 		}

src/cmd/5g/cgen64.c

@@ -163,30 +163,30 @@ cgen64(Node *n, Node *res)
 
 		// bl * cl -> ah al
 		p1 = gins(AMULLU, N, N);
-		p1->from.type = D_REG;
+		p1->from.type = TYPE_REG;
 		p1->from.reg = bl.val.u.reg;
 		p1->reg = cl.val.u.reg;
-		p1->to.type = D_REGREG;
+		p1->to.type = TYPE_REGREG;
 		p1->to.reg = ah.val.u.reg;
 		p1->to.offset = al.val.u.reg;
 //print("%P\n", p1);
 
 		// bl * ch + ah -> ah
 		p1 = gins(AMULA, N, N);
-		p1->from.type = D_REG;
+		p1->from.type = TYPE_REG;
 		p1->from.reg = bl.val.u.reg;
 		p1->reg = ch.val.u.reg;
-		p1->to.type = D_REGREG2;
+		p1->to.type = TYPE_REGREG2;
 		p1->to.reg = ah.val.u.reg;
 		p1->to.offset = ah.val.u.reg;
 //print("%P\n", p1);
 
 		// bh * cl + ah -> ah
 		p1 = gins(AMULA, N, N);
-		p1->from.type = D_REG;
+		p1->from.type = TYPE_REG;
 		p1->from.reg = bh.val.u.reg;
 		p1->reg = cl.val.u.reg;
-		p1->to.type = D_REGREG2;
+		p1->to.type = TYPE_REGREG2;
 		p1->to.reg = ah.val.u.reg;
 		p1->to.offset = ah.val.u.reg;
 //print("%P\n", p1);

src/cmd/5g/galign.c

@@ -36,14 +36,8 @@ betypeinit(void)
 	widthint = 4;
 	widthreg = 4;
 
-	zprog.link = P;
 	zprog.as = AGOK;
 	zprog.scond = C_SCOND_NONE;
-	zprog.reg = NREG;
-	zprog.from.type = D_NONE;
-	zprog.from.name = D_NONE;
-	zprog.from.reg = NREG;
-	zprog.to = zprog.from;
 	arch.zprog = zprog;
 
 	listinit5();
@@ -73,10 +67,6 @@ main(int argc, char **argv)
 	arch.AUNDEF = AUNDEF;
 	arch.AVARDEF = AVARDEF;
 	arch.AVARKILL = AVARKILL;
-	arch.D_AUTO = D_AUTO;
-	arch.D_BRANCH = D_BRANCH;
-	arch.D_NONE = D_NONE;
-	arch.D_PARAM = D_PARAM;
 	arch.MAXWIDTH = MAXWIDTH;
 	arch.afunclit = afunclit;
 	arch.anyregalloc = anyregalloc;

src/cmd/5g/gg.h

@@ -13,10 +13,10 @@
 
 enum
 {
-	REGALLOC_R0 = 0,
+	REGALLOC_R0 = REG_R0,
 	REGALLOC_RMAX = REGEXT,
-	REGALLOC_F0 = NREG,
-	REGALLOC_FMAX = REGALLOC_F0 + FREGEXT,
+	REGALLOC_F0 = REG_F0,
+	REGALLOC_FMAX = FREGEXT,
 };
 
 EXTERN	int32	dynloc;

src/cmd/5g/ggen.c

@@ -22,8 +22,8 @@ defframe(Prog *ptxt)
 	Node *n;
 
 	// fill in argument size
-	ptxt->to.type = D_CONST2;
-	ptxt->to.offset2 = rnd(curfn->type->argwid, widthptr);
+	ptxt->to.type = TYPE_TEXTSIZE;
+	ptxt->to.u.argsize = rnd(curfn->type->argwid, widthptr);
 
 	// fill in final stack size
 	frame = rnd(stksize+maxarg, widthptr);
@@ -70,30 +70,30 @@ zerorange(Prog *p, vlong frame, vlong lo, vlong hi, uint32 *r0)
 	if(cnt == 0)
 		return p;
 	if(*r0 == 0) {
-		p = appendpp(p, AMOVW, D_CONST, NREG, 0, D_REG, 0, 0);
+		p = appendpp(p, AMOVW, TYPE_CONST, 0, 0, TYPE_REG, REG_R0, 0);
 		*r0 = 1;
 	}
 	if(cnt < 4*widthptr) {
 		for(i = 0; i < cnt; i += widthptr) 
-			p = appendpp(p, AMOVW, D_REG, 0, 0, D_OREG, REGSP, 4+frame+lo+i);
+			p = appendpp(p, AMOVW, TYPE_REG, REG_R0, 0, TYPE_MEM, REGSP, 4+frame+lo+i);
 	} else if(!nacl && (cnt <= 128*widthptr)) {
-		p = appendpp(p, AADD, D_CONST, NREG, 4+frame+lo, D_REG, 1, 0);
+		p = appendpp(p, AADD, TYPE_CONST, 0, 4+frame+lo, TYPE_REG, REG_R1, 0);
 		p->reg = REGSP;
-		p = appendpp(p, ADUFFZERO, D_NONE, NREG, 0, D_OREG, NREG, 0);
+		p = appendpp(p, ADUFFZERO, TYPE_NONE, 0, 0, TYPE_MEM, 0, 0);
 		f = sysfunc("duffzero");
 		naddr(f, &p->to, 1);
 		afunclit(&p->to, f);
 		p->to.offset = 4*(128-cnt/widthptr);
 	} else {
-		p = appendpp(p, AADD, D_CONST, NREG, 4+frame+lo, D_REG, 1, 0);
+		p = appendpp(p, AADD, TYPE_CONST, 0, 4+frame+lo, TYPE_REG, REG_R1, 0);
 		p->reg = REGSP;
-		p = appendpp(p, AADD, D_CONST, NREG, cnt, D_REG, 2, 0);
-		p->reg = 1;
-		p1 = p = appendpp(p, AMOVW, D_REG, 0, 0, D_OREG, 1, 4);
+		p = appendpp(p, AADD, TYPE_CONST, 0, cnt, TYPE_REG, REG_R2, 0);
+		p->reg = REG_R1;
+		p1 = p = appendpp(p, AMOVW, TYPE_REG, REG_R0, 0, TYPE_MEM, REG_R1, 4);
 		p->scond |= C_PBIT;
-		p = appendpp(p, ACMP, D_REG, 1, 0, D_NONE, 0, 0);
-		p->reg = 2;
-		p = appendpp(p, ABNE, D_NONE, NREG, 0, D_BRANCH, NREG, 0);
+		p = appendpp(p, ACMP, TYPE_REG, REG_R1, 0, TYPE_NONE, 0, 0);
+		p->reg = REG_R2;
+		p = appendpp(p, ABNE, TYPE_NONE, 0, 0, TYPE_BRANCH, 0, 0);
 		patch(p, p1);
 	}
 	return p;
@@ -142,7 +142,7 @@ fixautoused(Prog* p)
 	Prog **lp;
 
 	for (lp=&p; (p=*lp) != P; ) {
-		if (p->as == ATYPE && p->from.node && p->from.name == D_AUTO && !((Node*)(p->from.node))->used) {
+		if (p->as == ATYPE && p->from.node && p->from.name == NAME_AUTO && !((Node*)(p->from.node))->used) {
 			*lp = p->link;
 			continue;
 		}
@@ -151,16 +151,14 @@ fixautoused(Prog* p)
 			// VARDEFs are interspersed with other code, and a jump might be using the
 			// VARDEF as a target. Replace with a no-op instead. A later pass will remove
 			// the no-ops.
-			p->to.type = D_NONE;
-			p->to.node = N;
-			p->as = ANOP;
+			nopout(p);
 			continue;
 		}
 
-		if (p->from.name == D_AUTO && p->from.node)
+		if (p->from.name == NAME_AUTO && p->from.node)
 			p->from.offset += ((Node*)(p->from.node))->stkdelta;
 
-		if (p->to.name == D_AUTO && p->to.node)
+		if (p->to.name == NAME_AUTO && p->to.node)
 			p->to.offset += ((Node*)(p->to.node))->stkdelta;
 
 		lp = &p->link;
@@ -208,7 +206,7 @@ ginscall(Node *f, int proc)
 				// ARM NOP 0x00000000 is really AND.EQ R0, R0, R0.
 				// Use the latter form because the NOP pseudo-instruction
 				// would be removed by the linker.
-				nodreg(&r, types[TINT], 0);
+				nodreg(&r, types[TINT], REG_R0);
 				p = gins(AAND, &r, &r);
 				p->scond = C_SCOND_EQ;
 			}
@@ -218,8 +216,8 @@ ginscall(Node *f, int proc)
 				gins(AUNDEF, N, N);
 			break;
 		}
-		nodreg(&r, types[tptr], 7);
-		nodreg(&r1, types[tptr], 1);
+		nodreg(&r, types[tptr], REG_R7);
+		nodreg(&r1, types[tptr], REG_R1);
 		gmove(f, &r);
 		r.op = OINDREG;
 		gmove(&r, &r1);
@@ -238,7 +236,7 @@ ginscall(Node *f, int proc)
 		nodconst(&con, types[TINT32], argsize(f->type));
 		gins(AMOVW, &con, &r);
 		p = gins(AMOVW, &r, N);
-		p->to.type = D_OREG;
+		p->to.type = TYPE_MEM;
 		p->to.reg = REGSP;
 		p->to.offset = 4;
 
@@ -247,7 +245,7 @@ ginscall(Node *f, int proc)
 		n1.left = f;
 		gins(AMOVW, &n1, &r);
 		p = gins(AMOVW, &r, N);
-		p->to.type = D_OREG;
+		p->to.type = TYPE_MEM;
 		p->to.reg = REGSP;
 		p->to.offset = 8;
 
@@ -261,7 +259,7 @@ ginscall(Node *f, int proc)
 		if(proc == 2) {
 			nodconst(&con, types[TINT32], 0);
 			p = gins(ACMP, &con, N);
-			p->reg = 0;
+			p->reg = REG_R0;
 			p = gbranch(ABEQ, T, +1);
 			cgen_ret(N);
 			patch(p, pc);
@@ -337,7 +335,7 @@ cgen_callinter(Node *n, Node *res, int proc)
 	} else {
 		// go/defer. generate go func value.
 		p = gins(AMOVW, &nodo, &nodr);
-		p->from.type = D_CONST;	// REG = &(20+offset(REG)) -- i.tab->fun[f]
+		p->from.type = TYPE_CONST;	// REG = &(20+offset(REG)) -- i.tab->fun[f]
 	}
 
 	nodr.type = n->left->type;
@@ -484,8 +482,8 @@ cgen_ret(Node *n)
 	genlist(curfn->exit);
 	p = gins(ARET, N, N);
 	if(n != N && n->op == ORETJMP) {
-		p->to.name = D_EXTERN;
-		p->to.type = D_CONST;
+		p->to.name = NAME_EXTERN;
+		p->to.type = TYPE_CONST;
 		p->to.sym = linksym(n->left->sym);
 	}
 }
@@ -674,7 +672,7 @@ cgen_hmul(Node *nl, Node *nr, Node *res)
 			p = gins(AMULLU, &n2, N);
 		// n2 * n1 -> (n1 n2)
 		p->reg = n1.val.u.reg;
-		p->to.type = D_REGREG;
+		p->to.type = TYPE_REGREG;
 		p->to.reg = n1.val.u.reg;
 		p->to.offset = n2.val.u.reg;
 		break;
@@ -862,11 +860,11 @@ clearfat(Node *nl)
 	if(q > 128) {
 		regalloc(&end, types[tptr], N);
 		p = gins(AMOVW, &dst, &end);
-		p->from.type = D_CONST;
+		p->from.type = TYPE_CONST;
 		p->from.offset = q*4;
 
 		p = gins(AMOVW, &nz, &dst);
-		p->to.type = D_OREG;
+		p->to.type = TYPE_MEM;
 		p->to.offset = 4;
 		p->scond |= C_PBIT;
 		pl = p;
@@ -885,7 +883,7 @@ clearfat(Node *nl)
 	} else
 	while(q > 0) {
 		p = gins(AMOVW, &nz, &dst);
-		p->to.type = D_OREG;
+		p->to.type = TYPE_MEM;
 		p->to.offset = 4;
  		p->scond |= C_PBIT;
 //print("1. %P\n", p);
@@ -894,7 +892,7 @@ clearfat(Node *nl)
 
 	while(c > 0) {
 		p = gins(AMOVB, &nz, &dst);
-		p->to.type = D_OREG;
+		p->to.type = TYPE_MEM;
 		p->to.offset = 1;
  		p->scond |= C_PBIT;
 //print("2. %P\n", p);
@@ -917,7 +915,7 @@ expandchecks(Prog *firstp)
 			continue;
 		if(debug_checknil && p->lineno > 1) // p->lineno==1 in generated wrappers
 			warnl(p->lineno, "generated nil check");
-		if(p->from.type != D_REG)
+		if(p->from.type != TYPE_REG)
 			fatal("invalid nil check %P", p);
 		reg = p->from.reg;
 		// check is
@@ -930,15 +928,15 @@ expandchecks(Prog *firstp)
 		p1->lineno = p->lineno;
 		p1->pc = 9999;
 		p1->as = AMOVW;
-		p1->from.type = D_REG;
+		p1->from.type = TYPE_REG;
 		p1->from.reg = reg;
-		p1->to.type = D_OREG;
+		p1->to.type = TYPE_MEM;
 		p1->to.reg = reg;
 		p1->to.offset = 0;
 		p1->scond = C_SCOND_EQ;
 		p->as = ACMP;
-		p->from.type = D_CONST;
-		p->from.reg = NREG;
+		p->from.type = TYPE_CONST;
+		p->from.reg = 0;
 		p->from.offset = 0;
 		p->reg = reg;
 	}

src/cmd/5g/gobj.c

@@ -38,18 +38,18 @@ dsname(Sym *sym, int off, char *t, int n)
 	Prog *p;
 
 	p = gins(ADATA, N, N);
-	p->from.type = D_OREG;
-	p->from.name = D_EXTERN;
+	p->from.type = TYPE_MEM;
+	p->from.name = NAME_EXTERN;
 	p->from.etype = TINT32;
 	p->from.offset = off;
-	p->from.reg = NREG;
+	p->from.reg = 0;
 	p->from.sym = linksym(sym);
 	
 	p->reg = n;
 	
-	p->to.type = D_SCONST;
-	p->to.name = D_NONE;
-	p->to.reg = NREG;
+	p->to.type = TYPE_SCONST;
+	p->to.name = NAME_NONE;
+	p->to.reg = 0;
 	p->to.offset = 0;
 	memmove(p->to.u.sval, t, n);
 	return off + n;
@@ -65,11 +65,11 @@ datastring(char *s, int len, Addr *a)
 	Sym *sym;
 	
 	sym = stringsym(s, len);
-	a->type = D_OREG;
-	a->name = D_EXTERN;
+	a->type = TYPE_MEM;
+	a->name = NAME_EXTERN;
 	a->etype = TINT32;
 	a->offset = widthptr+4;  // skip header
-	a->reg = NREG;
+	a->reg = 0;
 	a->sym = linksym(sym);
 	a->node = sym->def;
 }
@@ -84,11 +84,11 @@ datagostring(Strlit *sval, Addr *a)
 	Sym *sym;
 	
 	sym = stringsym(sval->s, sval->len);
-	a->type = D_OREG;
-	a->name = D_EXTERN;
+	a->type = TYPE_MEM;
+	a->name = NAME_EXTERN;
 	a->etype = TSTRING;
 	a->offset = 0;  // header
-	a->reg = NREG;
+	a->reg = 0;
 	a->sym = linksym(sym);
 	a->node = sym->def;
 }
@@ -134,13 +134,13 @@ gdatacomplex(Node *nam, Mpcplx *cval)
 
 	p = gins(ADATA, nam, N);
 	p->reg = w;
-	p->to.type = D_FCONST;
+	p->to.type = TYPE_FCONST;
 	p->to.u.dval = mpgetflt(&cval->real);
 
 	p = gins(ADATA, nam, N);
 	p->reg = w;
 	p->from.offset += w;
-	p->to.type = D_FCONST;
+	p->to.type = TYPE_FCONST;
 	p->to.u.dval = mpgetflt(&cval->imag);
 }
 
@@ -153,7 +153,7 @@ gdatastring(Node *nam, Strlit *sval)
 	p = gins(ADATA, nam, N);
 	datastring(sval->s, sval->len, &p->to);
 	p->reg = types[tptr]->width;
-	p->to.type = D_CONST;
+	p->to.type = TYPE_CONST;
 	p->to.etype = TINT32;
 //print("%P\n", p);
 
@@ -170,14 +170,14 @@ dstringptr(Sym *s, int off, char *str)
 
 	off = rnd(off, widthptr);
 	p = gins(ADATA, N, N);
-	p->from.type = D_OREG;
-	p->from.name = D_EXTERN;
+	p->from.type = TYPE_MEM;
+	p->from.name = NAME_EXTERN;
 	p->from.sym = linksym(s);
 	p->from.offset = off;
 	p->reg = widthptr;
 
 	datastring(str, strlen(str)+1, &p->to);
-	p->to.type = D_CONST;
+	p->to.type = TYPE_CONST;
 	p->to.etype = TINT32;
 	off += widthptr;
 
@@ -194,13 +194,13 @@ dgostrlitptr(Sym *s, int off, Strlit *lit)
 
 	off = rnd(off, widthptr);
 	p = gins(ADATA, N, N);
-	p->from.type = D_OREG;
-	p->from.name = D_EXTERN;
+	p->from.type = TYPE_MEM;
+	p->from.name = NAME_EXTERN;
 	p->from.sym = linksym(s);
 	p->from.offset = off;
 	p->reg = widthptr;
 	datagostring(lit, &p->to);
-	p->to.type = D_CONST;
+	p->to.type = TYPE_CONST;
 	p->to.etype = TINT32;
 	off += widthptr;
 
@@ -231,13 +231,13 @@ dsymptr(Sym *s, int off, Sym *x, int xoff)
 	off = rnd(off, widthptr);
 
 	p = gins(ADATA, N, N);
-	p->from.type = D_OREG;
-	p->from.name = D_EXTERN;
+	p->from.type = TYPE_MEM;
+	p->from.name = NAME_EXTERN;
 	p->from.sym = linksym(s);
 	p->from.offset = off;
 	p->reg = widthptr;
-	p->to.type = D_CONST;
-	p->to.name = D_EXTERN;
+	p->to.type = TYPE_CONST;
+	p->to.name = NAME_EXTERN;
 	p->to.sym = linksym(x);
 	p->to.offset = xoff;
 	off += widthptr;
@@ -249,4 +249,8 @@ void
 nopout(Prog *p)
 {
 	p->as = ANOP;
+	p->scond = zprog.scond;
+	p->from = zprog.from;
+	p->to = zprog.to;
+	p->reg = zprog.reg;
 }

src/cmd/5g/gsubr.c

@@ -42,14 +42,14 @@ void
 clearp(Prog *p)
 {
 	p->as = AEND;
-	p->reg = NREG;
+	p->reg = 0;
 	p->scond = C_SCOND_NONE;
-	p->from.type = D_NONE;
-	p->from.name = D_NONE;
-	p->from.reg = NREG;
-	p->to.type = D_NONE;
-	p->to.name = D_NONE;
-	p->to.reg = NREG;
+	p->from.type = TYPE_NONE;
+	p->from.name = NAME_NONE;
+	p->from.reg = 0;
+	p->to.type = TYPE_NONE;
+	p->to.name = NAME_NONE;
+	p->to.reg = 0;
 	p->pc = pcloc;
 	pcloc++;
 }
@@ -124,7 +124,7 @@ gbranch(int as, Type *t, int likely)
 	USED(likely);  // TODO: record this for linker
 
 	p = prog(as);
-	p->to.type = D_BRANCH;
+	p->to.type = TYPE_BRANCH;
 	p->to.u.branch = P;
 	return p;
 }
@@ -135,7 +135,7 @@ gbranch(int as, Type *t, int likely)
 void
 patch(Prog *p, Prog *to)
 {
-	if(p->to.type != D_BRANCH)
+	if(p->to.type != TYPE_BRANCH)
 		fatal("patch: not a branch");
 	p->to.u.branch = to;
 	p->to.offset = to->pc;
@@ -146,7 +146,7 @@ unpatch(Prog *p)
 {
 	Prog *q;
 
-	if(p->to.type != D_BRANCH)
+	if(p->to.type != TYPE_BRANCH)
 		fatal("unpatch: not a branch");
 	q = p->to.u.branch;
 	p->to.u.branch = P;
@@ -197,7 +197,7 @@ ggloblnod(Node *nam)
 	p->lineno = nam->lineno;
 	p->from.sym->gotype = linksym(ngotype(nam));
 	p->to.sym = nil;
-	p->to.type = D_CONST;
+	p->to.type = TYPE_CONST;
 	p->to.offset = nam->type->width;
 	if(nam->readonly)
 		p->reg = RODATA;
@@ -211,11 +211,11 @@ ggloblsym(Sym *s, int32 width, int8 flags)
 	Prog *p;
 
 	p = gins(AGLOBL, N, N);
-	p->from.type = D_OREG;
-	p->from.name = D_EXTERN;
+	p->from.type = TYPE_MEM;
+	p->from.name = NAME_EXTERN;
 	p->from.sym = linksym(s);
-	p->to.type = D_CONST;
-	p->to.name = D_NONE;
+	p->to.type = TYPE_CONST;
+	p->to.name = NAME_NONE;
 	p->to.offset = width;
 	p->reg = flags;
 }
@@ -226,8 +226,8 @@ gtrack(Sym *s)
 	Prog *p;
 	
 	p = gins(AUSEFIELD, N, N);
-	p->from.type = D_OREG;
-	p->from.name = D_EXTERN;
+	p->from.type = TYPE_MEM;
+	p->from.name = NAME_EXTERN;
 	p->from.sym = linksym(s);
 }
 
@@ -249,13 +249,13 @@ isfat(Type *t)
  * naddr of func generates code for address of func.
  * if using opcode that can take address implicitly,
  * call afunclit to fix up the argument.
- * also fix up direct register references to be D_OREG.
+ * also fix up direct register references to be TYPE_MEM.
  */
 void
 afunclit(Addr *a, Node *n)
 {
-	if(a->type == D_CONST && a->name == D_EXTERN || a->type == D_REG) {
-		a->type = D_OREG;
+	if(a->type == TYPE_CONST && a->name == NAME_EXTERN || a->type == TYPE_REG) {
+		a->type = TYPE_MEM;
 		if(n->op == ONAME)
 			a->sym = linksym(n->sym);
 	}
@@ -385,7 +385,7 @@ regalloc(Node *n, Type *t, Node *o)
 	yyerror("regalloc: unknown type %T", t);
 
 err:
-	nodreg(n, t, 0);
+	nodreg(n, t, REG_R0);
 	return;
 
 out:
@@ -852,9 +852,9 @@ gmove(Node *f, Node *t)
 		regalloc(&r2, thi.type, N);
 		gmove(f, &r1);
 		p1 = gins(AMOVW, &r1, &r2);
-		p1->from.type = D_SHIFT;
-		p1->from.offset = 2 << 5 | 31 << 7 | r1.val.u.reg; // r1->31
-		p1->from.reg = NREG;
+		p1->from.type = TYPE_SHIFT;
+		p1->from.offset = 2 << 5 | 31 << 7 | (r1.val.u.reg&15); // r1->31
+		p1->from.reg = 0;
 //print("gmove: %P\n", p1);
 		gins(AMOVW, &r1, &tlo);
 		gins(AMOVW, &r2, &thi);
@@ -1124,12 +1124,12 @@ raddr(Node *n, Prog *p)
 	Addr a;
 
 	naddr(n, &a, 1);
-	if(a.type != D_REG && a.type != D_FREG) {
+	if(a.type != TYPE_REG) {
 		if(n)
 			fatal("bad in raddr: %O", n->op);
 		else
 			fatal("bad in raddr: <null>");
-		p->reg = NREG;
+		p->reg = 0;
 	} else
 		p->reg = a.reg;
 }
@@ -1164,8 +1164,8 @@ gshift(int as, Node *lhs, int32 stype, int32 sval, Node *rhs)
 	sval = sval&0x1f;
 
 	p = gins(as, N, rhs);
-	p->from.type = D_SHIFT;
-	p->from.offset = stype | sval<<7 | lhs->val.u.reg;
+	p->from.type = TYPE_SHIFT;
+	p->from.offset = stype | sval<<7 | (lhs->val.u.reg&15);
 	return p;
 }
 
@@ -1176,8 +1176,8 @@ gregshift(int as, Node *lhs, int32 stype, Node *reg, Node *rhs)
 {
 	Prog *p;
 	p = gins(as, N, rhs);
-	p->from.type = D_SHIFT;
-	p->from.offset = stype | reg->val.u.reg << 8 | 1<<4 | lhs->val.u.reg;
+	p->from.type = TYPE_SHIFT;
+	p->from.offset = stype | (reg->val.u.reg&15) << 8 | 1<<4 | (lhs->val.u.reg&15);
 	return p;
 }
 
@@ -1190,9 +1190,9 @@ naddr(Node *n, Addr *a, int canemitcode)
 {
 	Sym *s;
 
-	a->type = D_NONE;
-	a->name = D_NONE;
-	a->reg = NREG;
+	a->type = TYPE_NONE;
+	a->name = NAME_NONE;
+	a->reg = 0;
 	a->gotype = nil;
 	a->node = N;
 	a->etype = 0;
@@ -1210,13 +1210,8 @@ naddr(Node *n, Addr *a, int canemitcode)
 		break;
 
 	case OREGISTER:
-		if(n->val.u.reg <= REGALLOC_RMAX) {
-			a->type = D_REG;
-			a->reg = n->val.u.reg;
-		} else {
-			a->type = D_FREG;
-			a->reg = n->val.u.reg - REGALLOC_F0;
-		}
+		a->type = TYPE_REG;
+		a->reg = n->val.u.reg;
 		a->sym = nil;
 		break;
 
@@ -1227,12 +1222,12 @@ naddr(Node *n, Addr *a, int canemitcode)
 //		if(a->type >= D_AX && a->type <= D_DI)
 //			a->type += D_INDIR;
 //		else
-//		if(a->type == D_CONST)
-//			a->type = D_NONE+D_INDIR;
+//		if(a->type == TYPE_CONST)
+//			a->type = TYPE_NONE+D_INDIR;
 //		else
-//		if(a->type == D_ADDR) {
+//		if(a->type == TYPE_ADDR) {
 //			a->type = a->index;
-//			a->index = D_NONE;
+//			a->index = TYPE_NONE;
 //		} else
 //			goto bad;
 //		if(n->op == OINDEX) {
@@ -1242,7 +1237,7 @@ naddr(Node *n, Addr *a, int canemitcode)
 //		break;
 
 	case OINDREG:
-		a->type = D_OREG;
+		a->type = TYPE_MEM;
 		a->reg = n->val.u.reg;
 		a->sym = linksym(n->sym);
 		a->offset = n->xoffset;
@@ -1255,16 +1250,16 @@ naddr(Node *n, Addr *a, int canemitcode)
 		a->width = n->left->type->width;
 		a->offset = n->xoffset;
 		a->sym = linksym(n->left->sym);
-		a->type = D_OREG;
-		a->name = D_PARAM;
+		a->type = TYPE_MEM;
+		a->name = NAME_PARAM;
 		a->node = n->left->orig;
 		break;
 	
 	case OCLOSUREVAR:
 		if(!curfn->needctxt)
 			fatal("closurevar without needctxt");
-		a->type = D_OREG;
-		a->reg = 7;
+		a->type = TYPE_MEM;
+		a->reg = REG_R7;
 		a->offset = n->xoffset;
 		a->sym = nil;
 		break;		
@@ -1277,7 +1272,7 @@ naddr(Node *n, Addr *a, int canemitcode)
 	case ONAME:
 		a->etype = 0;
 		a->width = 0;
-		a->reg = NREG;
+		a->reg = 0;
 		if(n->type != T) {
 			a->etype = simtype[n->type->etype];
 			a->width = n->type->width;
@@ -1296,23 +1291,23 @@ naddr(Node *n, Addr *a, int canemitcode)
 				s = pkglookup(s->name, n->type->sym->pkg);
 		}
 
-		a->type = D_OREG;
+		a->type = TYPE_MEM;
 		switch(n->class) {
 		default:
 			fatal("naddr: ONAME class %S %d\n", n->sym, n->class);
 		case PEXTERN:
-			a->name = D_EXTERN;
+			a->name = NAME_EXTERN;
 			break;
 		case PAUTO:
-			a->name = D_AUTO;
+			a->name = NAME_AUTO;
 			break;
 		case PPARAM:
 		case PPARAMOUT:
-			a->name = D_PARAM;
+			a->name = NAME_PARAM;
 			break;
 		case PFUNC:
-			a->name = D_EXTERN;
-			a->type = D_CONST;
+			a->name = NAME_EXTERN;
+			a->type = TYPE_CONST;
 			s = funcsym(s);
 			break;
 		}
@@ -1325,13 +1320,13 @@ naddr(Node *n, Addr *a, int canemitcode)
 			fatal("naddr: const %lT", n->type);
 			break;
 		case CTFLT:
-			a->type = D_FCONST;
+			a->type = TYPE_FCONST;
 			a->u.dval = mpgetflt(n->val.u.fval);
 			break;
 		case CTINT:
 		case CTRUNE:
 			a->sym = nil;
-			a->type = D_CONST;
+			a->type = TYPE_CONST;
 			a->offset = mpgetfix(n->val.u.xval);
 			break;
 		case CTSTR:
@@ -1339,12 +1334,12 @@ naddr(Node *n, Addr *a, int canemitcode)
 			break;
 		case CTBOOL:
 			a->sym = nil;
-			a->type = D_CONST;
+			a->type = TYPE_CONST;
 			a->offset = n->val.u.bval;
 			break;
 		case CTNIL:
 			a->sym = nil;
-			a->type = D_CONST;
+			a->type = TYPE_CONST;
 			a->offset = 0;
 			break;
 		}
@@ -1354,7 +1349,7 @@ naddr(Node *n, Addr *a, int canemitcode)
 		// itable of interface value
 		naddr(n->left, a, canemitcode);
 		a->etype = simtype[tptr];
-		if(a->type == D_CONST && a->offset == 0)
+		if(a->type == TYPE_CONST && a->offset == 0)
 			break;	// len(nil)
 		a->width = widthptr;
 		break;
@@ -1362,7 +1357,7 @@ naddr(Node *n, Addr *a, int canemitcode)
 	case OSPTR:
 		// pointer in a string or slice
 		naddr(n->left, a, canemitcode);
-		if(a->type == D_CONST && a->offset == 0)
+		if(a->type == TYPE_CONST && a->offset == 0)
 			break;	// ptr(nil)
 		a->etype = simtype[tptr];
 		a->offset += Array_array;
@@ -1373,7 +1368,7 @@ naddr(Node *n, Addr *a, int canemitcode)
 		// len of string or slice
 		naddr(n->left, a, canemitcode);
 		a->etype = TINT32;
-		if(a->type == D_CONST && a->offset == 0)
+		if(a->type == TYPE_CONST && a->offset == 0)
 			break;	// len(nil)
 		a->offset += Array_nel;
 		break;
@@ -1382,7 +1377,7 @@ naddr(Node *n, Addr *a, int canemitcode)
 		// cap of string or slice
 		naddr(n->left, a, canemitcode);
 		a->etype = TINT32;
-		if(a->type == D_CONST && a->offset == 0)
+		if(a->type == TYPE_CONST && a->offset == 0)
 			break;	// cap(nil)
 		a->offset += Array_cap;
 		break;
@@ -1391,12 +1386,12 @@ naddr(Node *n, Addr *a, int canemitcode)
 		naddr(n->left, a, canemitcode);
 		a->etype = tptr;
 		switch(a->type) {
-		case D_OREG:
-			a->type = D_CONST;
+		case TYPE_MEM:
+			a->type = TYPE_CONST;
 			break;
 
-		case D_REG:
-		case D_CONST:
+		case TYPE_REG:
+		case TYPE_CONST:
 			break;
 		
 		default:
@@ -1903,8 +1898,8 @@ odot:
 		n1.xoffset = -(oary[i]+1);
 	}
 
-	a->type = D_NONE;
-	a->name = D_NONE;
+	a->type = TYPE_NONE;
+	a->name = NAME_NONE;
 	n1.type = n->type;
 	naddr(&n1, a, 1);
 	goto yes;
@@ -2022,7 +2017,7 @@ oindex:
 	}
 
 	naddr(reg1, a, 1);
-	a->type = D_OREG;
+	a->type = TYPE_MEM;
 	a->reg = reg->val.u.reg;
 	a->offset = 0;
 	goto yes;
@@ -2069,8 +2064,8 @@ oindex_const:
 	n2 = *reg;
 	n2.op = OINDREG;
 	n2.xoffset = v * (*w);
-	a->type = D_NONE;
-	a->name = D_NONE;
+	a->type = TYPE_NONE;
+	a->name = NAME_NONE;
 	naddr(&n2, a, 1);
 	goto yes;
 

src/cmd/5g/opt.h

@@ -32,8 +32,8 @@
 #define	Z	N
 #define	Adr	Addr
 
-#define	D_HI	D_NONE
-#define	D_LO	D_NONE
+#define	D_HI	TYPE_NONE
+#define	D_LO	TYPE_NONE
 
 #define	BLOAD(r)	band(bnot(r->refbehind), r->refahead)
 #define	BSTORE(r)	band(bnot(r->calbehind), r->calahead)
@@ -52,8 +52,8 @@ typedef	struct	Rgn	Rgn;
 extern Node *Z;
 enum
 {
-	D_HI = D_NONE,
-	D_LO = D_NONE,
+	D_HI = TYPE_NONE,
+	D_LO = TYPE_NONE,
 	CLOAD = 5,
 	CREF = 5,
 	CINF = 1000,
@@ -116,8 +116,6 @@ struct	Rgn
 	short	regno;
 };
 
-EXTERN	int32	exregoffset;		// not set
-EXTERN	int32	exfregoffset;		// not set
 EXTERN	Reg	zreg;
 EXTERN	Reg*	freer;
 EXTERN	Reg**	rpo2r;
@@ -126,7 +124,6 @@ EXTERN	Rgn*	rgp;
 EXTERN	int	nregion;
 EXTERN	int	nvar;
 EXTERN	int32	regbits;
-EXTERN	int32	exregbits;
 EXTERN	Bits	externs;
 EXTERN	Bits	params;
 EXTERN	Bits	consts;

src/cmd/5g/prog.c

@@ -136,12 +136,12 @@ proginfo(ProgInfo *info, Prog *p)
 	if(info->flags == 0)
 		fatal("unknown instruction %P", p);
 
-	if(p->from.type == D_CONST && p->from.sym != nil && (info->flags & LeftRead)) {
+	if(p->from.type == TYPE_CONST && p->from.sym != nil && (info->flags & LeftRead)) {
 		info->flags &= ~LeftRead;
 		info->flags |= LeftAddr;
 	}
 
-	if((info->flags & RegRead) && p->reg == NREG) {
+	if((info->flags & RegRead) && p->reg == 0) {
 		info->flags &= ~RegRead;
 		info->flags |= CanRegRead | RightRead;
 	}

src/cmd/5g/reg.c

@@ -67,11 +67,7 @@ excise(Flow *r)
 	Prog *p;
 
 	p = r->prog;
-	p->as = ANOP;
-	p->scond = zprog.scond;
-	p->from = zprog.from;
-	p->to = zprog.to;
-	p->reg = zprog.reg;
+	nopout(p);
 }
 
 static void
@@ -199,7 +195,7 @@ regopt(Prog *firstp)
 		proginfo(&info, p);
 
 		// Avoid making variables for direct-called functions.
-		if(p->as == ABL && p->to.name == D_EXTERN)
+		if(p->as == ABL && p->to.name == NAME_EXTERN)
 			continue;
 
 		bit = mkvar(r, &p->from);
@@ -209,12 +205,8 @@ regopt(Prog *firstp)
 		if(info.flags & LeftAddr)
 			setaddrs(bit);
 
-		if(info.flags & RegRead) {	
-			if(p->from.type != D_FREG)
-				r->use1.b[0] |= RtoB(p->reg);
-			else
-				r->use1.b[0] |= FtoB(p->reg);
-		}
+		if(info.flags & RegRead)	
+			r->use1.b[0] |= RtoB(p->reg);
 
 		if(info.flags & (RightAddr | RightRead | RightWrite)) {
 			bit = mkvar(r, &p->to);
@@ -230,7 +222,7 @@ regopt(Prog *firstp)
 
 		/* the mod/div runtime routines smash R12 */
 		if(p->as == ADIV || p->as == ADIVU || p->as == AMOD || p->as == AMODU)
-			r->set.b[0] |= RtoB(12);
+			r->set.b[0] |= RtoB(REG_R12);
 	}
 	if(firstr == R)
 		return;
@@ -463,18 +455,11 @@ brk:
 		vreg = paint2(rgp->enter, rgp->varno, 0);
 		vreg = allreg(vreg, rgp);
 		if(debug['R']) {
-			if(rgp->regno >= NREG)
-				print("%L $%d F%d: %Q\n",
-					rgp->enter->f.prog->lineno,
-					rgp->cost,
-					rgp->regno-NREG,
-					bit);
-			else
-				print("%L $%d R%d: %Q\n",
-					rgp->enter->f.prog->lineno,
-					rgp->cost,
-					rgp->regno,
-					bit);
+			print("%L $%d %R: %Q\n",
+				rgp->enter->f.prog->lineno,
+				rgp->cost,
+				rgp->regno,
+				bit);
 		}
 		if(rgp->regno != 0)
 			paint3(rgp->enter, rgp->varno, vreg, rgp->regno);
@@ -529,7 +514,7 @@ brk:
 	for(p = firstp; p != P; p = p->link) {
 		while(p->link != P && p->link->as == ANOP)
 			p->link = p->link->link;
-		if(p->to.type == D_BRANCH)
+		if(p->to.type == TYPE_BRANCH)
 			while(p->to.u.branch != P && p->to.u.branch->as == ANOP)
 				p->to.u.branch = p->to.u.branch->link;
 		if(p->as == AMOVW && p->to.reg == 13) {
@@ -538,7 +523,7 @@ brk:
 //				print("%P adjusting %d\n", p, vreg);
 				continue;
 			}
-			if(p->from.type == D_CONST && p->to.type == D_REG) {
+			if(p->from.type == TYPE_CONST && p->to.type == TYPE_REG) {
 				if(p->from.offset != vreg)
 					print("in and out different\n");
 //				print("%P finish %d\n", p, vreg);
@@ -546,18 +531,18 @@ brk:
 				continue;
 			}
 
-//			print("%P %d %d from type\n", p, p->from.type, D_CONST);
-//			print("%P %d %d to type\n\n", p, p->to.type, D_REG);
+//			print("%P %d %d from type\n", p, p->from.type, TYPE_CONST);
+//			print("%P %d %d to type\n\n", p, p->to.type, TYPE_REG);
 		}
 
 		if(p->as == AMOVW && vreg != 0) {
 			if(p->from.sym != nil)
-			if(p->from.name == D_AUTO || p->from.name == D_PARAM) {
+			if(p->from.name == NAME_AUTO || p->from.name == NAME_PARAM) {
 				p->from.offset += vreg;
 //				print("%P adjusting from %d %d\n", p, vreg, p->from.type);
 			}
 			if(p->to.sym != nil)
-			if(p->to.name == D_AUTO || p->to.name == D_PARAM) {
+			if(p->to.name == NAME_AUTO || p->to.name == NAME_PARAM) {
 				p->to.offset += vreg;
 //				print("%P adjusting to %d %d\n", p, vreg, p->from.type);
 			}
@@ -640,7 +625,7 @@ addmove(Reg *r, int bn, int rn, int f)
 	// If there's a stack fixup coming (after BL newproc or BL deferproc),
 	// delay the load until after the fixup.
 	p2 = p->link;
-	if(p2 && p2->as == AMOVW && p2->from.type == D_CONST && p2->from.reg == REGSP && p2->to.reg == REGSP && p2->to.type == D_REG)
+	if(p2 && p2->as == AMOVW && p2->from.type == TYPE_CONST && p2->from.reg == REGSP && p2->to.reg == REGSP && p2->to.type == TYPE_REG)
 		p = p2;
 
 	p1->link = p->link;
@@ -655,9 +640,9 @@ addmove(Reg *r, int bn, int rn, int f)
 	a->sym = linksym(v->node->sym);
 	a->offset = v->offset;
 	a->etype = v->etype;
-	a->type = D_OREG;
+	a->type = TYPE_MEM;
 	if(a->etype == TARRAY || a->sym == nil)
-		a->type = D_CONST;
+		a->type = TYPE_CONST;
 
 	if(v->addr)
 		fatal("addmove: shouldn't be doing this %A\n", a);
@@ -693,21 +678,13 @@ addmove(Reg *r, int bn, int rn, int f)
 		break;
 	}
 
-	p1->from.type = D_REG;
+	p1->from.type = TYPE_REG;
 	p1->from.reg = rn;
-	if(rn >= NREG) {
-		p1->from.type = D_FREG;
-		p1->from.reg = rn-NREG;
-	}
 	if(!f) {
 		p1->from = *a;
 		*a = zprog.from;
-		a->type = D_REG;
+		a->type = TYPE_REG;
 		a->reg = rn;
-		if(rn >= NREG) {
-			a->type = D_FREG;
-			a->reg = rn-NREG;
-		}
 		if(v->etype == TUINT8 || v->etype == TBOOL)
 			p1->as = AMOVBU;
 		if(v->etype == TUINT16)
@@ -749,33 +726,33 @@ mkvar(Reg *r, Adr *a)
 		print("type %d %d %D\n", t, a->name, a);
 		goto none;
 
-	case D_NONE:
-	case D_FCONST:
-	case D_BRANCH:
+	case TYPE_NONE:
+	case TYPE_FCONST:
+	case TYPE_BRANCH:
 		break;
 
 
-	case D_REGREG:
-	case D_REGREG2:
+	case TYPE_REGREG:
+	case TYPE_REGREG2:
 		bit = zbits;
-		if(a->offset != NREG)
+		if(a->offset != 0)
 			bit.b[0] |= RtoB(a->offset);
-		if(a->reg != NREG)
+		if(a->reg != 0)
 			bit.b[0] |= RtoB(a->reg);
 		return bit;
 
-	case D_CONST:
-	case D_REG:
-	case D_SHIFT:
-		if(a->reg != NREG) {
+	case TYPE_CONST:
+	case TYPE_REG:
+	case TYPE_SHIFT:
+		if(a->reg != 0) {
 			bit = zbits;
 			bit.b[0] = RtoB(a->reg);
 			return bit;
 		}
 		break;
 
-	case D_OREG:
-		if(a->reg != NREG) {
+	case TYPE_MEM:
+		if(a->reg != 0) {
 			if(a == &r->f.prog->from)
 				r->use1.b[0] |= RtoB(a->reg);
 			else
@@ -784,24 +761,16 @@ mkvar(Reg *r, Adr *a)
 				r->set.b[0] |= RtoB(a->reg);
 		}
 		break;
-
-	case D_FREG:
-		if(a->reg != NREG) {
-			bit = zbits;
-			bit.b[0] = FtoB(a->reg);
-			return bit;
-		}
-		break;
 	}
 
 	switch(a->name) {
 	default:
 		goto none;
 
-	case D_EXTERN:
-	case D_STATIC:
-	case D_AUTO:
-	case D_PARAM:
+	case NAME_EXTERN:
+	case NAME_STATIC:
+	case NAME_AUTO:
+	case NAME_PARAM:
 		n = a->name;
 		break;
 	}
@@ -878,10 +847,10 @@ mkvar(Reg *r, Adr *a)
 	node->opt = v;
 	
 	bit = blsh(i);
-	if(n == D_EXTERN || n == D_STATIC)
+	if(n == NAME_EXTERN || n == NAME_STATIC)
 		for(z=0; z<BITS; z++)
 			externs.b[z] |= bit.b[z];
-	if(n == D_PARAM)
+	if(n == NAME_PARAM)
 		for(z=0; z<BITS; z++)
 			params.b[z] |= bit.b[z];
 
@@ -1103,8 +1072,8 @@ allreg(uint32 b, Rgn *r)
 	case TFLOAT64:
 		i = BtoF(~b);
 		if(i && r->cost >= 0) {
-			r->regno = i+NREG;
-			return FtoB(i);
+			r->regno = i;
+			return RtoB(i);
 		}
 		break;
 
@@ -1329,13 +1298,9 @@ addreg(Adr *a, int rn)
 {
 	a->sym = nil;
 	a->node = nil;
-	a->name = D_NONE;
-	a->type = D_REG;
+	a->name = NAME_NONE;
+	a->type = TYPE_REG;
 	a->reg = rn;
-	if(rn >= NREG) {
-		a->type = D_FREG;
-		a->reg = rn-NREG;
-	}
 }
 
 /*
@@ -1345,13 +1310,29 @@ addreg(Adr *a, int rn)
  *	...	...
  *	10	R10
  *	12  R12
+ *
+ *	bit	reg
+ *	18	F2
+ *	19	F3
+ *	...	...
+ *	31	F15
  */
 uint32
 RtoB(int r)
 {
-	if(r >= REGTMP-2 && r != 12)	// excluded R9 and R10 for m and g, but not R12
-		return 0;
-	return 1L << r;
+	if(REG_R0 <= r && r <= REG_R15) {
+		if(r >= REGTMP-2 && r != REG_R12)	// excluded R9 and R10 for m and g, but not R12
+			return 0;
+		return 1L << (r - REG_R0);
+	}
+	
+	if(REG_F0 <= r && r <= REG_F15) {
+		if(r < REG_F2 || r > REG_F0+NFREG-1)
+			return 0;
+		return 1L << ((r - REG_F0) + 16);
+	}
+	
+	return 0;
 }
 
 int
@@ -1362,33 +1343,16 @@ BtoR(uint32 b)
 	b &= 0x11fcL;	// excluded R9 and R10 for m and g, but not R12
 	if(b == 0)
 		return 0;
-	return bitno(b);
-}
-
-/*
- *	bit	reg
- *	18	F2
- *	19	F3
- *	...	...
- *	31	F15
- */
-uint32
-FtoB(int f)
-{
-
-	if(f < 2 || f > NFREG-1)
-		return 0;
-	return 1L << (f + 16);
+	return bitno(b) + REG_R0;
 }
 
 int
 BtoF(uint32 b)
 {
-
 	b &= 0xfffc0000L;
 	if(b == 0)
 		return 0;
-	return bitno(b) - 16;
+	return bitno(b) - 16 + REG_F0;
 }
 
 void

src/cmd/5l/5.out.h

@@ -42,24 +42,64 @@ enum
 
 enum
 {
-	REGRET = 0,
+	REG_R0 = 32, // must be 16-aligned
+	REG_R1,
+	REG_R2,
+	REG_R3,
+	REG_R4,
+	REG_R5,
+	REG_R6,
+	REG_R7,
+	REG_R8,
+	REG_R9,
+	REG_R10,
+	REG_R11,
+	REG_R12,
+	REG_R13,
+	REG_R14,
+	REG_R15,
+	
+	REG_F0, // must be 16-aligned
+	REG_F1,
+	REG_F2,
+	REG_F3,
+	REG_F4,
+	REG_F5,
+	REG_F6,
+	REG_F7,
+	REG_F8,
+	REG_F9,
+	REG_F10,
+	REG_F11,
+	REG_F12,
+	REG_F13,
+	REG_F14,
+	REG_F15,
+
+	REG_FPSR, // must be 2-aligned
+	REG_FPCR,
+
+	REG_CPSR, // must be 2-aligned
+	REG_SPSR,
+
+	REGRET = REG_R0,
 	/* compiler allocates R1 up as temps */
 	/* compiler allocates register variables R3 up */
 	/* compiler allocates external registers R10 down */
-	REGEXT = 10,
+	REGEXT = REG_R10,
 	/* these two registers are declared in runtime.h */
 	REGG = REGEXT-0,
 	REGM = REGEXT-1,
 
-	REGTMP = 11,
-	REGSP = 13,
-	REGLINK = 14,
-	REGPC = 15,
+	REGTMP = REG_R11,
+	REGSP = REG_R13,
+	REGLINK = REG_R14,
+	REGPC = REG_R15,
 	
 	NFREG = 16,
-	FREGRET = 0,
-	FREGEXT = 7,
-	FREGTMP = 15,
+	FREGRET = REG_F0,
+	FREGEXT = REG_F7,
+	FREGTMP = REG_F15,
 };
 /* compiler allocates register variables F0 up */
 /* compiler allocates external registers F7 down */
@@ -304,43 +344,6 @@ enum
 	SHIFT_RR = 3<<5,
 };
 
-enum
-{
-/* type/name */
-	D_GOK = 0,
-	D_NONE = 1,
-
-/* type */
-	D_BRANCH = (D_NONE+1),
-	D_OREG = (D_NONE+2),
-	D_CONST = (D_NONE+7),
-	D_FCONST = (D_NONE+8),
-	D_SCONST = (D_NONE+9),
-	D_PSR = (D_NONE+10),
-	D_REG = (D_NONE+12),
-	D_FREG = (D_NONE+13),
-	D_FILE = (D_NONE+16),
-	D_OCONST = (D_NONE+17),
-	D_FILE1 = (D_NONE+18),
-
-	D_SHIFT = (D_NONE+19),
-	D_FPCR = (D_NONE+20),
-	D_REGREG = (D_NONE+21), // (reg, reg)
-	D_ADDR = (D_NONE+22),
-
-	D_SBIG = (D_NONE+23),
-	D_CONST2 = (D_NONE+24),
-
-	D_REGREG2 = (D_NONE+25), // reg, reg
-
-/* name */
-	D_EXTERN = (D_NONE+3),
-	D_STATIC = (D_NONE+4),
-	D_AUTO = (D_NONE+5),
-	D_PARAM = (D_NONE+6),
-
-	D_LAST = (D_NONE+26),
-};
 
 /*
  * this is the ranlib header