{
$$.from = nullgen;
$$.to = $2;
- $$.to.index = $2.type;
- $$.to.type = D_INDIR+D_ADDR;
+ $$.to.type = TYPE_INDIR;
}
spec4: /* NOP */
{
$$.from = $1;
$$.to = $3;
- if($$.from.index != D_NONE)
+ if($$.from.index != TYPE_NONE)
yyerror("dp shift with lhs index");
$$.from.index = $5;
}
{
$$.from = $1;
$$.to = $3;
- if($$.to.index != D_NONE)
+ if($$.to.index != TYPE_NONE)
yyerror("dp move with lhs index");
$$.to.index = $5;
}
{
$$.from = $3;
$$.to = $5;
- if($1.type != D_CONST)
+ if($1.type != TYPE_CONST)
yyerror("illegal constant");
$$.to.offset = $1.offset;
}
spec11: /* PCDATA */
rim ',' rim
{
- if($1.type != D_CONST || $3.type != D_CONST)
+ if($1.type != TYPE_CONST || $3.type != TYPE_CONST)
yyerror("arguments to PCDATA must be integer constants");
$$.from = $1;
$$.to = $3;
spec12: /* FUNCDATA */
rim ',' rim
{
- if($1.type != D_CONST)
+ if($1.type != TYPE_CONST)
yyerror("index for FUNCDATA must be integer constant");
- if($3.type != D_EXTERN && $3.type != D_STATIC)
+ if($3.type != TYPE_MEM || ($3.name != NAME_EXTERN && $3.name != NAME_STATIC))
yyerror("value for FUNCDATA must be symbol reference");
$$.from = $1;
$$.to = $3;
con '(' LPC ')'
{
$$ = nullgen;
- $$.type = D_BRANCH;
+ $$.type = TYPE_BRANCH;
$$.offset = $1 + pc;
}
| LNAME offset
$$ = nullgen;
if(pass == 2 && $1->type != LLAB)
yyerror("undefined label: %s", $1->labelname);
- $$.type = D_BRANCH;
+ $$.type = TYPE_BRANCH;
$$.offset = $1->value + $2;
}
LBREG
{
$$ = nullgen;
- $$.type = $1;
+ $$.type = TYPE_REG;
+ $$.reg = $1;
}
| LFREG
{
$$ = nullgen;
- $$.type = $1;
+ $$.type = TYPE_REG;
+ $$.reg = $1;
}
| LLREG
{
$$ = nullgen;
- $$.type = $1;
+ $$.type = TYPE_REG;
+ $$.reg = $1;
}
| LXREG
{
$$ = nullgen;
- $$.type = $1;
+ $$.type = TYPE_REG;
+ $$.reg = $1;
}
| LSP
{
$$ = nullgen;
- $$.type = D_SP;
+ $$.type = TYPE_REG;
+ $$.reg = REG_SP;
}
| LSREG
{
$$ = nullgen;
- $$.type = $1;
+ $$.type = TYPE_REG;
+ $$.reg = $1;
}
imm:
'$' con
{
$$ = nullgen;
- $$.type = D_CONST;
+ $$.type = TYPE_CONST;
$$.offset = $2;
}
| '$' nam
{
$$ = $2;
- $$.index = $2.type;
- $$.type = D_ADDR;
+ $$.type = TYPE_ADDR;
/*
- if($2.type == D_AUTO || $2.type == D_PARAM)
+ if($2.name == NAME_AUTO || $2.name == NAME_PARAM)
yyerror("constant cannot be automatic: %s",
$2.sym->name);
*/
| '$' LSCONST
{
$$ = nullgen;
- $$.type = D_SCONST;
+ $$.type = TYPE_SCONST;
memcpy($$.u.sval, $2, sizeof($$.u.sval));
}
| '$' LFCONST
{
$$ = nullgen;
- $$.type = D_FCONST;
+ $$.type = TYPE_FCONST;
$$.u.dval = $2;
}
| '$' '(' LFCONST ')'
{
$$ = nullgen;
- $$.type = D_FCONST;
+ $$.type = TYPE_FCONST;
$$.u.dval = $3;
}
| '$' '(' '-' LFCONST ')'
{
$$ = nullgen;
- $$.type = D_FCONST;
+ $$.type = TYPE_FCONST;
$$.u.dval = -$4;
}
| '$' '-' LFCONST
{
$$ = nullgen;
- $$.type = D_FCONST;
+ $$.type = TYPE_FCONST;
$$.u.dval = -$3;
}
'$' con2
{
$$ = nullgen;
- $$.type = D_CONST2;
+ $$.type = TYPE_TEXTSIZE;
$$.offset = $2.v1;
- $$.offset2 = $2.v2;
+ $$.u.argsize = $2.v2;
}
con2:
con
{
$$ = nullgen;
- $$.type = D_INDIR+D_NONE;
+ $$.type = TYPE_MEM;
+ $$.reg = REG_NONE;
$$.offset = $1;
}
| con '(' LLREG ')'
{
$$ = nullgen;
- $$.type = D_INDIR+$3;
+ $$.type = TYPE_MEM;
+ $$.reg = $3;
$$.offset = $1;
}
| con '(' LSP ')'
{
$$ = nullgen;
- $$.type = D_INDIR+D_SP;
+ $$.type = TYPE_MEM;
+ $$.reg = REG_SP;
$$.offset = $1;
}
| con '(' LLREG '*' con ')'
{
$$ = nullgen;
- $$.type = D_INDIR+D_NONE;
+ $$.type = TYPE_MEM;
+ $$.reg = REG_NONE;
$$.offset = $1;
$$.index = $3;
$$.scale = $5;
| con '(' LLREG ')' '(' LLREG '*' con ')'
{
$$ = nullgen;
- $$.type = D_INDIR+$3;
+ $$.type = TYPE_MEM;
+ $$.reg = $3;
$$.offset = $1;
$$.index = $6;
$$.scale = $8;
| con '(' LLREG ')' '(' LSREG '*' con ')'
{
$$ = nullgen;
- $$.type = D_INDIR+$3;
+ $$.type = TYPE_MEM;
+ $$.reg = $3;
$$.offset = $1;
$$.index = $6;
$$.scale = $8;
| '(' LLREG ')'
{
$$ = nullgen;
- $$.type = D_INDIR+$2;
+ $$.type = TYPE_MEM;
+ $$.reg = $2;
}
| '(' LSP ')'
{
$$ = nullgen;
- $$.type = D_INDIR+D_SP;
+ $$.type = TYPE_MEM;
+ $$.reg = REG_SP;
}
| con '(' LSREG ')'
{
$$ = nullgen;
- $$.type = D_INDIR+$3;
+ $$.type = TYPE_MEM;
+ $$.reg = $3;
$$.offset = $1;
}
| '(' LLREG '*' con ')'
{
$$ = nullgen;
- $$.type = D_INDIR+D_NONE;
+ $$.type = TYPE_MEM;
+ $$.reg = REG_NONE;
$$.index = $2;
$$.scale = $4;
checkscale($$.scale);
| '(' LLREG ')' '(' LLREG '*' con ')'
{
$$ = nullgen;
- $$.type = D_INDIR+$2;
+ $$.type = TYPE_MEM;
+ $$.reg = $2;
$$.index = $5;
$$.scale = $7;
checkscale($$.scale);
LNAME offset '(' pointer ')'
{
$$ = nullgen;
- $$.type = $4;
+ $$.type = TYPE_MEM;
+ $$.name = $4;
$$.sym = linklookup(ctxt, $1->name, 0);
$$.offset = $2;
}
| LNAME '<' '>' offset '(' LSB ')'
{
$$ = nullgen;
- $$.type = D_STATIC;
+ $$.type = TYPE_MEM;
+ $$.name = NAME_STATIC;
$$.sym = linklookup(ctxt, $1->name, 1);
$$.offset = $4;
}
LSB
| LSP
{
- $$ = D_AUTO;
+ $$ = NAME_AUTO;
}
| LFP
ushort value;
} itab[] =
{
- "SP", LSP, D_AUTO,
- "SB", LSB, D_EXTERN,
- "FP", LFP, D_PARAM,
- "PC", LPC, D_BRANCH,
-
- "AL", LBREG, D_AL,
- "CL", LBREG, D_CL,
- "DL", LBREG, D_DL,
- "BL", LBREG, D_BL,
- "AH", LBREG, D_AH,
- "CH", LBREG, D_CH,
- "DH", LBREG, D_DH,
- "BH", LBREG, D_BH,
-
- "AX", LLREG, D_AX,
- "CX", LLREG, D_CX,
- "DX", LLREG, D_DX,
- "BX", LLREG, D_BX,
-/* "SP", LLREG, D_SP, */
- "BP", LLREG, D_BP,
- "SI", LLREG, D_SI,
- "DI", LLREG, D_DI,
-
- "F0", LFREG, D_F0+0,
- "F1", LFREG, D_F0+1,
- "F2", LFREG, D_F0+2,
- "F3", LFREG, D_F0+3,
- "F4", LFREG, D_F0+4,
- "F5", LFREG, D_F0+5,
- "F6", LFREG, D_F0+6,
- "F7", LFREG, D_F0+7,
-
- "X0", LXREG, D_X0+0,
- "X1", LXREG, D_X0+1,
- "X2", LXREG, D_X0+2,
- "X3", LXREG, D_X0+3,
- "X4", LXREG, D_X0+4,
- "X5", LXREG, D_X0+5,
- "X6", LXREG, D_X0+6,
- "X7", LXREG, D_X0+7,
-
- "CS", LSREG, D_CS,
- "SS", LSREG, D_SS,
- "DS", LSREG, D_DS,
- "ES", LSREG, D_ES,
- "FS", LSREG, D_FS,
- "GS", LSREG, D_GS,
- "TLS", LSREG, D_TLS,
-
- "GDTR", LBREG, D_GDTR,
- "IDTR", LBREG, D_IDTR,
- "LDTR", LBREG, D_LDTR,
- "MSW", LBREG, D_MSW,
- "TASK", LBREG, D_TASK,
-
- "CR0", LBREG, D_CR+0,
- "CR1", LBREG, D_CR+1,
- "CR2", LBREG, D_CR+2,
- "CR3", LBREG, D_CR+3,
- "CR4", LBREG, D_CR+4,
- "CR5", LBREG, D_CR+5,
- "CR6", LBREG, D_CR+6,
- "CR7", LBREG, D_CR+7,
-
- "DR0", LBREG, D_DR+0,
- "DR1", LBREG, D_DR+1,
- "DR2", LBREG, D_DR+2,
- "DR3", LBREG, D_DR+3,
- "DR4", LBREG, D_DR+4,
- "DR5", LBREG, D_DR+5,
- "DR6", LBREG, D_DR+6,
- "DR7", LBREG, D_DR+7,
-
- "TR0", LBREG, D_TR+0,
- "TR1", LBREG, D_TR+1,
- "TR2", LBREG, D_TR+2,
- "TR3", LBREG, D_TR+3,
- "TR4", LBREG, D_TR+4,
- "TR5", LBREG, D_TR+5,
- "TR6", LBREG, D_TR+6,
- "TR7", LBREG, D_TR+7,
+ "SP", LSP, NAME_AUTO,
+ "SB", LSB, NAME_EXTERN,
+ "FP", LFP, NAME_PARAM,
+
+ "PC", LPC, TYPE_BRANCH,
+
+ "AL", LBREG, REG_AL,
+ "CL", LBREG, REG_CL,
+ "DL", LBREG, REG_DL,
+ "BL", LBREG, REG_BL,
+ "AH", LBREG, REG_AH,
+ "CH", LBREG, REG_CH,
+ "DH", LBREG, REG_DH,
+ "BH", LBREG, REG_BH,
+
+ "AX", LLREG, REG_AX,
+ "CX", LLREG, REG_CX,
+ "DX", LLREG, REG_DX,
+ "BX", LLREG, REG_BX,
+/* "SP", LLREG, REG_SP, */
+ "BP", LLREG, REG_BP,
+ "SI", LLREG, REG_SI,
+ "DI", LLREG, REG_DI,
+
+ "F0", LFREG, REG_F0+0,
+ "F1", LFREG, REG_F0+1,
+ "F2", LFREG, REG_F0+2,
+ "F3", LFREG, REG_F0+3,
+ "F4", LFREG, REG_F0+4,
+ "F5", LFREG, REG_F0+5,
+ "F6", LFREG, REG_F0+6,
+ "F7", LFREG, REG_F0+7,
+
+ "X0", LXREG, REG_X0+0,
+ "X1", LXREG, REG_X0+1,
+ "X2", LXREG, REG_X0+2,
+ "X3", LXREG, REG_X0+3,
+ "X4", LXREG, REG_X0+4,
+ "X5", LXREG, REG_X0+5,
+ "X6", LXREG, REG_X0+6,
+ "X7", LXREG, REG_X0+7,
+
+ "CS", LSREG, REG_CS,
+ "SS", LSREG, REG_SS,
+ "DS", LSREG, REG_DS,
+ "ES", LSREG, REG_ES,
+ "FS", LSREG, REG_FS,
+ "GS", LSREG, REG_GS,
+ "TLS", LSREG, REG_TLS,
+
+ "GDTR", LBREG, REG_GDTR,
+ "IDTR", LBREG, REG_IDTR,
+ "LDTR", LBREG, REG_LDTR,
+ "MSW", LBREG, REG_MSW,
+ "TASK", LBREG, REG_TASK,
+
+ "CR0", LBREG, REG_CR+0,
+ "CR1", LBREG, REG_CR+1,
+ "CR2", LBREG, REG_CR+2,
+ "CR3", LBREG, REG_CR+3,
+ "CR4", LBREG, REG_CR+4,
+ "CR5", LBREG, REG_CR+5,
+ "CR6", LBREG, REG_CR+6,
+ "CR7", LBREG, REG_CR+7,
+
+ "DR0", LBREG, REG_DR+0,
+ "DR1", LBREG, REG_DR+1,
+ "DR2", LBREG, REG_DR+2,
+ "DR3", LBREG, REG_DR+3,
+ "DR4", LBREG, REG_DR+4,
+ "DR5", LBREG, REG_DR+5,
+ "DR6", LBREG, REG_DR+6,
+ "DR7", LBREG, REG_DR+7,
+
+ "TR0", LBREG, REG_TR+0,
+ "TR1", LBREG, REG_TR+1,
+ "TR2", LBREG, REG_TR+2,
+ "TR3", LBREG, REG_TR+3,
+ "TR4", LBREG, REG_TR+4,
+ "TR5", LBREG, REG_TR+5,
+ "TR6", LBREG, REG_TR+6,
+ "TR7", LBREG, REG_TR+7,
"AAA", LTYPE0, AAAA,
"AAD", LTYPE0, AAAD,
Sym *s;
int i;
- nullgen.type = D_NONE;
- nullgen.index = D_NONE;
+ nullgen.type = TYPE_NONE;
+ nullgen.index = TYPE_NONE;
nerrors = 0;
iostack = I;
91, 96, 102, 103, 104, 105, 106, 107, 108, 109,
110, 111, 112, 113, 114, 115, 116, 117, 118, 119,
122, 126, 133, 140, 147, 152, 159, 164, 171, 176,
- 181, 188, 196, 202, 211, 216, 221, 230, 231, 234,
- 239, 249, 254, 264, 269, 274, 281, 286, 294, 302,
- 312, 321, 332, 333, 336, 337, 338, 342, 346, 347,
- 348, 351, 352, 355, 361, 372, 377, 382, 387, 392,
- 397, 404, 410, 421, 427, 433, 439, 445, 453, 462,
- 467, 472, 477, 484, 485, 488, 494, 500, 506, 515,
- 524, 533, 538, 543, 549, 557, 567, 571, 580, 587,
- 596, 599, 603, 609, 610, 614, 617, 618, 622, 626,
- 630, 634, 640, 641, 645, 649, 653, 657, 661, 665,
- 669, 673, 677
+ 181, 188, 196, 202, 211, 216, 221, 229, 230, 233,
+ 238, 248, 253, 263, 268, 273, 280, 285, 293, 301,
+ 311, 320, 331, 332, 335, 336, 337, 341, 345, 346,
+ 347, 350, 351, 354, 360, 371, 377, 383, 389, 395,
+ 401, 409, 415, 425, 431, 437, 443, 449, 457, 466,
+ 471, 476, 481, 488, 489, 492, 499, 506, 513, 523,
+ 533, 543, 549, 555, 562, 571, 582, 586, 595, 603,
+ 613, 616, 620, 626, 627, 631, 634, 635, 639, 643,
+ 647, 651, 657, 658, 662, 666, 670, 674, 678, 682,
+ 686, 690, 694
};
#endif
{
(yyval.addr2).from = nullgen;
(yyval.addr2).to = (yyvsp[(2) - (2)].addr);
- (yyval.addr2).to.index = (yyvsp[(2) - (2)].addr).type;
- (yyval.addr2).to.type = D_INDIR+D_ADDR;
+ (yyval.addr2).to.type = TYPE_INDIR;
}
break;
case 49:
-#line 235 "a.y"
+#line 234 "a.y"
{
(yyval.addr2).from = (yyvsp[(1) - (3)].addr);
(yyval.addr2).to = (yyvsp[(3) - (3)].addr);
break;
case 50:
-#line 240 "a.y"
+#line 239 "a.y"
{
(yyval.addr2).from = (yyvsp[(1) - (5)].addr);
(yyval.addr2).to = (yyvsp[(3) - (5)].addr);
- if((yyval.addr2).from.index != D_NONE)
+ if((yyval.addr2).from.index != TYPE_NONE)
yyerror("dp shift with lhs index");
(yyval.addr2).from.index = (yyvsp[(5) - (5)].lval);
}
break;
case 51:
-#line 250 "a.y"
+#line 249 "a.y"
{
(yyval.addr2).from = (yyvsp[(1) - (3)].addr);
(yyval.addr2).to = (yyvsp[(3) - (3)].addr);
break;
case 52:
-#line 255 "a.y"
+#line 254 "a.y"
{
(yyval.addr2).from = (yyvsp[(1) - (5)].addr);
(yyval.addr2).to = (yyvsp[(3) - (5)].addr);
- if((yyval.addr2).to.index != D_NONE)
+ if((yyval.addr2).to.index != TYPE_NONE)
yyerror("dp move with lhs index");
(yyval.addr2).to.index = (yyvsp[(5) - (5)].lval);
}
break;
case 53:
-#line 265 "a.y"
+#line 264 "a.y"
{
(yyval.addr2).from = (yyvsp[(1) - (2)].addr);
(yyval.addr2).to = nullgen;
break;
case 54:
-#line 270 "a.y"
+#line 269 "a.y"
{
(yyval.addr2).from = (yyvsp[(1) - (1)].addr);
(yyval.addr2).to = nullgen;
break;
case 55:
-#line 275 "a.y"
+#line 274 "a.y"
{
(yyval.addr2).from = (yyvsp[(1) - (3)].addr);
(yyval.addr2).to = (yyvsp[(3) - (3)].addr);
break;
case 56:
-#line 282 "a.y"
+#line 281 "a.y"
{
(yyval.addr2).from = (yyvsp[(1) - (3)].addr);
(yyval.addr2).to = (yyvsp[(3) - (3)].addr);
break;
case 57:
-#line 287 "a.y"
+#line 286 "a.y"
{
(yyval.addr2).from = (yyvsp[(1) - (5)].addr);
(yyval.addr2).from.scale = (yyvsp[(3) - (5)].lval);
break;
case 58:
-#line 295 "a.y"
+#line 294 "a.y"
{
(yyval.addr2).from = (yyvsp[(1) - (5)].addr);
(yyval.addr2).to = (yyvsp[(3) - (5)].addr);
break;
case 59:
-#line 303 "a.y"
+#line 302 "a.y"
{
(yyval.addr2).from = (yyvsp[(3) - (5)].addr);
(yyval.addr2).to = (yyvsp[(5) - (5)].addr);
- if((yyvsp[(1) - (5)].addr).type != D_CONST)
+ if((yyvsp[(1) - (5)].addr).type != TYPE_CONST)
yyerror("illegal constant");
(yyval.addr2).to.offset = (yyvsp[(1) - (5)].addr).offset;
}
break;
case 60:
-#line 313 "a.y"
+#line 312 "a.y"
{
- if((yyvsp[(1) - (3)].addr).type != D_CONST || (yyvsp[(3) - (3)].addr).type != D_CONST)
+ if((yyvsp[(1) - (3)].addr).type != TYPE_CONST || (yyvsp[(3) - (3)].addr).type != TYPE_CONST)
yyerror("arguments to PCDATA must be integer constants");
(yyval.addr2).from = (yyvsp[(1) - (3)].addr);
(yyval.addr2).to = (yyvsp[(3) - (3)].addr);
break;
case 61:
-#line 322 "a.y"
+#line 321 "a.y"
{
- if((yyvsp[(1) - (3)].addr).type != D_CONST)
+ if((yyvsp[(1) - (3)].addr).type != TYPE_CONST)
yyerror("index for FUNCDATA must be integer constant");
- if((yyvsp[(3) - (3)].addr).type != D_EXTERN && (yyvsp[(3) - (3)].addr).type != D_STATIC)
+ if((yyvsp[(3) - (3)].addr).type != TYPE_MEM || ((yyvsp[(3) - (3)].addr).name != NAME_EXTERN && (yyvsp[(3) - (3)].addr).name != NAME_STATIC))
yyerror("value for FUNCDATA must be symbol reference");
(yyval.addr2).from = (yyvsp[(1) - (3)].addr);
(yyval.addr2).to = (yyvsp[(3) - (3)].addr);
break;
case 66:
-#line 339 "a.y"
+#line 338 "a.y"
{
(yyval.addr) = (yyvsp[(2) - (2)].addr);
}
break;
case 67:
-#line 343 "a.y"
+#line 342 "a.y"
{
(yyval.addr) = (yyvsp[(2) - (2)].addr);
}
break;
case 73:
-#line 356 "a.y"
+#line 355 "a.y"
{
(yyval.addr) = nullgen;
- (yyval.addr).type = D_BRANCH;
+ (yyval.addr).type = TYPE_BRANCH;
(yyval.addr).offset = (yyvsp[(1) - (4)].lval) + pc;
}
break;
case 74:
-#line 362 "a.y"
+#line 361 "a.y"
{
(yyvsp[(1) - (2)].sym) = labellookup((yyvsp[(1) - (2)].sym));
(yyval.addr) = nullgen;
if(pass == 2 && (yyvsp[(1) - (2)].sym)->type != LLAB)
yyerror("undefined label: %s", (yyvsp[(1) - (2)].sym)->labelname);
- (yyval.addr).type = D_BRANCH;
+ (yyval.addr).type = TYPE_BRANCH;
(yyval.addr).offset = (yyvsp[(1) - (2)].sym)->value + (yyvsp[(2) - (2)].lval);
}
break;
case 75:
-#line 373 "a.y"
+#line 372 "a.y"
{
(yyval.addr) = nullgen;
- (yyval.addr).type = (yyvsp[(1) - (1)].lval);
+ (yyval.addr).type = TYPE_REG;
+ (yyval.addr).reg = (yyvsp[(1) - (1)].lval);
}
break;
#line 378 "a.y"
{
(yyval.addr) = nullgen;
- (yyval.addr).type = (yyvsp[(1) - (1)].lval);
+ (yyval.addr).type = TYPE_REG;
+ (yyval.addr).reg = (yyvsp[(1) - (1)].lval);
}
break;
case 77:
-#line 383 "a.y"
+#line 384 "a.y"
{
(yyval.addr) = nullgen;
- (yyval.addr).type = (yyvsp[(1) - (1)].lval);
+ (yyval.addr).type = TYPE_REG;
+ (yyval.addr).reg = (yyvsp[(1) - (1)].lval);
}
break;
case 78:
-#line 388 "a.y"
+#line 390 "a.y"
{
(yyval.addr) = nullgen;
- (yyval.addr).type = (yyvsp[(1) - (1)].lval);
+ (yyval.addr).type = TYPE_REG;
+ (yyval.addr).reg = (yyvsp[(1) - (1)].lval);
}
break;
case 79:
-#line 393 "a.y"
+#line 396 "a.y"
{
(yyval.addr) = nullgen;
- (yyval.addr).type = D_SP;
+ (yyval.addr).type = TYPE_REG;
+ (yyval.addr).reg = REG_SP;
}
break;
case 80:
-#line 398 "a.y"
+#line 402 "a.y"
{
(yyval.addr) = nullgen;
- (yyval.addr).type = (yyvsp[(1) - (1)].lval);
+ (yyval.addr).type = TYPE_REG;
+ (yyval.addr).reg = (yyvsp[(1) - (1)].lval);
}
break;
case 81:
-#line 405 "a.y"
+#line 410 "a.y"
{
(yyval.addr) = nullgen;
- (yyval.addr).type = D_CONST;
+ (yyval.addr).type = TYPE_CONST;
(yyval.addr).offset = (yyvsp[(2) - (2)].lval);
}
break;
case 82:
-#line 411 "a.y"
+#line 416 "a.y"
{
(yyval.addr) = (yyvsp[(2) - (2)].addr);
- (yyval.addr).index = (yyvsp[(2) - (2)].addr).type;
- (yyval.addr).type = D_ADDR;
+ (yyval.addr).type = TYPE_ADDR;
/*
- if($2.type == D_AUTO || $2.type == D_PARAM)
+ if($2.name == D_AUTO || $2.name == D_PARAM)
yyerror("constant cannot be automatic: %s",
$2.sym->name);
*/
break;
case 83:
-#line 422 "a.y"
+#line 426 "a.y"
{
(yyval.addr) = nullgen;
- (yyval.addr).type = D_SCONST;
+ (yyval.addr).type = TYPE_SCONST;
memcpy((yyval.addr).u.sval, (yyvsp[(2) - (2)].sval), sizeof((yyval.addr).u.sval));
}
break;
case 84:
-#line 428 "a.y"
+#line 432 "a.y"
{
(yyval.addr) = nullgen;
- (yyval.addr).type = D_FCONST;
+ (yyval.addr).type = TYPE_FCONST;
(yyval.addr).u.dval = (yyvsp[(2) - (2)].dval);
}
break;
case 85:
-#line 434 "a.y"
+#line 438 "a.y"
{
(yyval.addr) = nullgen;
- (yyval.addr).type = D_FCONST;
+ (yyval.addr).type = TYPE_FCONST;
(yyval.addr).u.dval = (yyvsp[(3) - (4)].dval);
}
break;
case 86:
-#line 440 "a.y"
+#line 444 "a.y"
{
(yyval.addr) = nullgen;
- (yyval.addr).type = D_FCONST;
+ (yyval.addr).type = TYPE_FCONST;
(yyval.addr).u.dval = -(yyvsp[(4) - (5)].dval);
}
break;
case 87:
-#line 446 "a.y"
+#line 450 "a.y"
{
(yyval.addr) = nullgen;
- (yyval.addr).type = D_FCONST;
+ (yyval.addr).type = TYPE_FCONST;
(yyval.addr).u.dval = -(yyvsp[(3) - (3)].dval);
}
break;
case 88:
-#line 454 "a.y"
+#line 458 "a.y"
{
(yyval.addr) = nullgen;
- (yyval.addr).type = D_CONST2;
+ (yyval.addr).type = TYPE_TEXTSIZE;
(yyval.addr).offset = (yyvsp[(2) - (2)].con2).v1;
- (yyval.addr).offset2 = (yyvsp[(2) - (2)].con2).v2;
+ (yyval.addr).u.argsize = (yyvsp[(2) - (2)].con2).v2;
}
break;
case 89:
-#line 463 "a.y"
+#line 467 "a.y"
{
(yyval.con2).v1 = (yyvsp[(1) - (1)].lval);
(yyval.con2).v2 = ArgsSizeUnknown;
break;
case 90:
-#line 468 "a.y"
+#line 472 "a.y"
{
(yyval.con2).v1 = -(yyvsp[(2) - (2)].lval);
(yyval.con2).v2 = ArgsSizeUnknown;
break;
case 91:
-#line 473 "a.y"
+#line 477 "a.y"
{
(yyval.con2).v1 = (yyvsp[(1) - (3)].lval);
(yyval.con2).v2 = (yyvsp[(3) - (3)].lval);
break;
case 92:
-#line 478 "a.y"
+#line 482 "a.y"
{
(yyval.con2).v1 = -(yyvsp[(2) - (4)].lval);
(yyval.con2).v2 = (yyvsp[(4) - (4)].lval);
break;
case 95:
-#line 489 "a.y"
+#line 493 "a.y"
{
(yyval.addr) = nullgen;
- (yyval.addr).type = D_INDIR+D_NONE;
+ (yyval.addr).type = TYPE_MEM;
+ (yyval.addr).reg = REG_NONE;
(yyval.addr).offset = (yyvsp[(1) - (1)].lval);
}
break;
case 96:
-#line 495 "a.y"
+#line 500 "a.y"
{
(yyval.addr) = nullgen;
- (yyval.addr).type = D_INDIR+(yyvsp[(3) - (4)].lval);
+ (yyval.addr).type = TYPE_MEM;
+ (yyval.addr).reg = (yyvsp[(3) - (4)].lval);
(yyval.addr).offset = (yyvsp[(1) - (4)].lval);
}
break;
case 97:
-#line 501 "a.y"
+#line 507 "a.y"
{
(yyval.addr) = nullgen;
- (yyval.addr).type = D_INDIR+D_SP;
+ (yyval.addr).type = TYPE_MEM;
+ (yyval.addr).reg = REG_SP;
(yyval.addr).offset = (yyvsp[(1) - (4)].lval);
}
break;
case 98:
-#line 507 "a.y"
+#line 514 "a.y"
{
(yyval.addr) = nullgen;
- (yyval.addr).type = D_INDIR+D_NONE;
+ (yyval.addr).type = TYPE_MEM;
+ (yyval.addr).reg = REG_NONE;
(yyval.addr).offset = (yyvsp[(1) - (6)].lval);
(yyval.addr).index = (yyvsp[(3) - (6)].lval);
(yyval.addr).scale = (yyvsp[(5) - (6)].lval);
break;
case 99:
-#line 516 "a.y"
+#line 524 "a.y"
{
(yyval.addr) = nullgen;
- (yyval.addr).type = D_INDIR+(yyvsp[(3) - (9)].lval);
+ (yyval.addr).type = TYPE_MEM;
+ (yyval.addr).reg = (yyvsp[(3) - (9)].lval);
(yyval.addr).offset = (yyvsp[(1) - (9)].lval);
(yyval.addr).index = (yyvsp[(6) - (9)].lval);
(yyval.addr).scale = (yyvsp[(8) - (9)].lval);
break;
case 100:
-#line 525 "a.y"
+#line 534 "a.y"
{
(yyval.addr) = nullgen;
- (yyval.addr).type = D_INDIR+(yyvsp[(3) - (9)].lval);
+ (yyval.addr).type = TYPE_MEM;
+ (yyval.addr).reg = (yyvsp[(3) - (9)].lval);
(yyval.addr).offset = (yyvsp[(1) - (9)].lval);
(yyval.addr).index = (yyvsp[(6) - (9)].lval);
(yyval.addr).scale = (yyvsp[(8) - (9)].lval);
break;
case 101:
-#line 534 "a.y"
+#line 544 "a.y"
{
(yyval.addr) = nullgen;
- (yyval.addr).type = D_INDIR+(yyvsp[(2) - (3)].lval);
+ (yyval.addr).type = TYPE_MEM;
+ (yyval.addr).reg = (yyvsp[(2) - (3)].lval);
}
break;
case 102:
-#line 539 "a.y"
+#line 550 "a.y"
{
(yyval.addr) = nullgen;
- (yyval.addr).type = D_INDIR+D_SP;
+ (yyval.addr).type = TYPE_MEM;
+ (yyval.addr).reg = REG_SP;
}
break;
case 103:
-#line 544 "a.y"
+#line 556 "a.y"
{
(yyval.addr) = nullgen;
- (yyval.addr).type = D_INDIR+(yyvsp[(3) - (4)].lval);
+ (yyval.addr).type = TYPE_MEM;
+ (yyval.addr).reg = (yyvsp[(3) - (4)].lval);
(yyval.addr).offset = (yyvsp[(1) - (4)].lval);
}
break;
case 104:
-#line 550 "a.y"
+#line 563 "a.y"
{
(yyval.addr) = nullgen;
- (yyval.addr).type = D_INDIR+D_NONE;
+ (yyval.addr).type = TYPE_MEM;
+ (yyval.addr).reg = REG_NONE;
(yyval.addr).index = (yyvsp[(2) - (5)].lval);
(yyval.addr).scale = (yyvsp[(4) - (5)].lval);
checkscale((yyval.addr).scale);
break;
case 105:
-#line 558 "a.y"
+#line 572 "a.y"
{
(yyval.addr) = nullgen;
- (yyval.addr).type = D_INDIR+(yyvsp[(2) - (8)].lval);
+ (yyval.addr).type = TYPE_MEM;
+ (yyval.addr).reg = (yyvsp[(2) - (8)].lval);
(yyval.addr).index = (yyvsp[(5) - (8)].lval);
(yyval.addr).scale = (yyvsp[(7) - (8)].lval);
checkscale((yyval.addr).scale);
break;
case 106:
-#line 568 "a.y"
+#line 583 "a.y"
{
(yyval.addr) = (yyvsp[(1) - (1)].addr);
}
break;
case 107:
-#line 572 "a.y"
+#line 587 "a.y"
{
(yyval.addr) = (yyvsp[(1) - (6)].addr);
(yyval.addr).index = (yyvsp[(3) - (6)].lval);
break;
case 108:
-#line 581 "a.y"
+#line 596 "a.y"
{
(yyval.addr) = nullgen;
- (yyval.addr).type = (yyvsp[(4) - (5)].lval);
+ (yyval.addr).type = TYPE_MEM;
+ (yyval.addr).name = (yyvsp[(4) - (5)].lval);
(yyval.addr).sym = linklookup(ctxt, (yyvsp[(1) - (5)].sym)->name, 0);
(yyval.addr).offset = (yyvsp[(2) - (5)].lval);
}
break;
case 109:
-#line 588 "a.y"
+#line 604 "a.y"
{
(yyval.addr) = nullgen;
- (yyval.addr).type = D_STATIC;
+ (yyval.addr).type = TYPE_MEM;
+ (yyval.addr).name = NAME_STATIC;
(yyval.addr).sym = linklookup(ctxt, (yyvsp[(1) - (7)].sym)->name, 1);
(yyval.addr).offset = (yyvsp[(4) - (7)].lval);
}
break;
case 110:
-#line 596 "a.y"
+#line 613 "a.y"
{
(yyval.lval) = 0;
}
break;
case 111:
-#line 600 "a.y"
+#line 617 "a.y"
{
(yyval.lval) = (yyvsp[(2) - (2)].lval);
}
break;
case 112:
-#line 604 "a.y"
+#line 621 "a.y"
{
(yyval.lval) = -(yyvsp[(2) - (2)].lval);
}
break;
case 114:
-#line 611 "a.y"
+#line 628 "a.y"
{
- (yyval.lval) = D_AUTO;
+ (yyval.lval) = NAME_AUTO;
}
break;
case 117:
-#line 619 "a.y"
+#line 636 "a.y"
{
(yyval.lval) = (yyvsp[(1) - (1)].sym)->value;
}
break;
case 118:
-#line 623 "a.y"
+#line 640 "a.y"
{
(yyval.lval) = -(yyvsp[(2) - (2)].lval);
}
break;
case 119:
-#line 627 "a.y"
+#line 644 "a.y"
{
(yyval.lval) = (yyvsp[(2) - (2)].lval);
}
break;
case 120:
-#line 631 "a.y"
+#line 648 "a.y"
{
(yyval.lval) = ~(yyvsp[(2) - (2)].lval);
}
break;
case 121:
-#line 635 "a.y"
+#line 652 "a.y"
{
(yyval.lval) = (yyvsp[(2) - (3)].lval);
}
break;
case 123:
-#line 642 "a.y"
+#line 659 "a.y"
{
(yyval.lval) = (yyvsp[(1) - (3)].lval) + (yyvsp[(3) - (3)].lval);
}
break;
case 124:
-#line 646 "a.y"
+#line 663 "a.y"
{
(yyval.lval) = (yyvsp[(1) - (3)].lval) - (yyvsp[(3) - (3)].lval);
}
break;
case 125:
-#line 650 "a.y"
+#line 667 "a.y"
{
(yyval.lval) = (yyvsp[(1) - (3)].lval) * (yyvsp[(3) - (3)].lval);
}
break;
case 126:
-#line 654 "a.y"
+#line 671 "a.y"
{
(yyval.lval) = (yyvsp[(1) - (3)].lval) / (yyvsp[(3) - (3)].lval);
}
break;
case 127:
-#line 658 "a.y"
+#line 675 "a.y"
{
(yyval.lval) = (yyvsp[(1) - (3)].lval) % (yyvsp[(3) - (3)].lval);
}
break;
case 128:
-#line 662 "a.y"
+#line 679 "a.y"
{
(yyval.lval) = (yyvsp[(1) - (4)].lval) << (yyvsp[(4) - (4)].lval);
}
break;
case 129:
-#line 666 "a.y"
+#line 683 "a.y"
{
(yyval.lval) = (yyvsp[(1) - (4)].lval) >> (yyvsp[(4) - (4)].lval);
}
break;
case 130:
-#line 670 "a.y"
+#line 687 "a.y"
{
(yyval.lval) = (yyvsp[(1) - (3)].lval) & (yyvsp[(3) - (3)].lval);
}
break;
case 131:
-#line 674 "a.y"
+#line 691 "a.y"
{
(yyval.lval) = (yyvsp[(1) - (3)].lval) ^ (yyvsp[(3) - (3)].lval);
}
break;
case 132:
-#line 678 "a.y"
+#line 695 "a.y"
{
(yyval.lval) = (yyvsp[(1) - (3)].lval) | (yyvsp[(3) - (3)].lval);
}
/* Line 1267 of yacc.c. */
-#line 2552 "y.tab.c"
+#line 2569 "y.tab.c"
default: break;
}
YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
// LEAL (n3)(n2*w), n3
p1 = gins(ALEAL, &n2, &n3);
p1->from.scale = w;
- p1->from.index = p1->from.type;
- p1->from.type = p1->to.type + D_INDIR;
+ p1->from.type = TYPE_MEM;
+ p1->from.index = p1->from.reg;
+ p1->from.reg = p1->to.reg;
} else {
nodconst(&tmp, types[TUINT32], w);
gins(optoas(OMUL, types[TUINT32]), &tmp, &n2);
case OINDREG:
// Increase the refcount of the register so that igen's caller
// has to call regfree.
- if(n->val.u.reg != D_SP)
+ if(n->val.u.reg != REG_SP)
reg[n->val.u.reg]++;
*a = *n;
return;
fp = structfirst(&flist, getoutarg(n->left->type));
memset(a, 0, sizeof *a);
a->op = OINDREG;
- a->val.u.reg = D_SP;
+ a->val.u.reg = REG_SP;
a->addable = 1;
a->xoffset = fp->width;
a->type = n->type;
return;
}
- nodreg(&dst, types[tptr], D_DI);
- nodreg(&src, types[tptr], D_SI);
+ nodreg(&dst, types[tptr], REG_DI);
+ nodreg(&src, types[tptr], REG_SI);
tempname(&tsrc, types[tptr]);
tempname(&tdst, types[tptr]);
// reverse direction
gins(ASTD, N, N); // set direction flag
if(c > 0) {
- gconreg(AADDL, w-1, D_SI);
- gconreg(AADDL, w-1, D_DI);
+ gconreg(AADDL, w-1, REG_SI);
+ gconreg(AADDL, w-1, REG_DI);
- gconreg(AMOVL, c, D_CX);
+ gconreg(AMOVL, c, REG_CX);
gins(AREP, N, N); // repeat
gins(AMOVSB, N, N); // MOVB *(SI)-,*(DI)-
}
if(q > 0) {
if(c > 0) {
- gconreg(AADDL, -3, D_SI);
- gconreg(AADDL, -3, D_DI);
+ gconreg(AADDL, -3, REG_SI);
+ gconreg(AADDL, -3, REG_DI);
} else {
- gconreg(AADDL, w-4, D_SI);
- gconreg(AADDL, w-4, D_DI);
+ gconreg(AADDL, w-4, REG_SI);
+ gconreg(AADDL, w-4, REG_DI);
}
- gconreg(AMOVL, q, D_CX);
+ gconreg(AMOVL, q, REG_CX);
gins(AREP, N, N); // repeat
gins(AMOVSL, N, N); // MOVL *(SI)-,*(DI)-
}
gins(ACLD, N, N); // paranoia. TODO(rsc): remove?
// normal direction
if(q > 128 || (q >= 4 && nacl)) {
- gconreg(AMOVL, q, D_CX);
+ gconreg(AMOVL, q, REG_CX);
gins(AREP, N, N); // repeat
gins(AMOVSL, N, N); // MOVL *(SI)+,*(DI)+
} else if(q >= 4) {
p = gins(ADUFFCOPY, N, N);
- p->to.type = D_ADDR;
+ p->to.type = TYPE_ADDR;
p->to.sym = linksym(pkglookup("duffcopy", runtimepkg));
// 10 and 128 = magic constants: see ../../runtime/asm_386.s
p->to.offset = 10*(128-q);
r = &t2;
}
- nodreg(&ax, types[TINT32], D_AX);
- nodreg(&cx, types[TINT32], D_CX);
- nodreg(&dx, types[TINT32], D_DX);
+ nodreg(&ax, types[TINT32], REG_AX);
+ nodreg(&cx, types[TINT32], REG_CX);
+ nodreg(&dx, types[TINT32], REG_DX);
// Setup for binary operation.
split64(l, &lo1, &hi1);
} else {
gins(AMOVL, &dx, &cx);
p1 = gins(ASHLL, ncon(v), &dx);
- p1->from.index = D_AX; // double-width shift
+ p1->from.index = REG_AX; // double-width shift
p1->from.scale = 0;
p1 = gins(ASHLL, ncon(v), &ax);
- p1->from.index = D_CX; // double-width shift
+ p1->from.index = REG_CX; // double-width shift
p1->from.scale = 0;
}
break;
gins(AMOVL, &lo1, &ax);
gins(AMOVL, &hi1, &dx);
p1 = gins(ASHLL, ncon(v), &dx);
- p1->from.index = D_AX; // double-width shift
+ p1->from.index = REG_AX; // double-width shift
p1->from.scale = 0;
gins(ASHLL, ncon(v), &ax);
break;
// general shift
p1 = gins(ASHLL, &cx, &dx);
- p1->from.index = D_AX; // double-width shift
+ p1->from.index = REG_AX; // double-width shift
p1->from.scale = 0;
gins(ASHLL, &cx, &ax);
patch(p2, pc);
gins(AMOVL, &lo1, &ax);
gins(AMOVL, &hi1, &dx);
p1 = gins(ASHRL, ncon(v), &ax);
- p1->from.index = D_DX; // double-width shift
+ p1->from.index = REG_DX; // double-width shift
p1->from.scale = 0;
gins(optoas(ORSH, hi1.type), ncon(v), &dx);
break;
// general shift
p1 = gins(ASHRL, &cx, &ax);
- p1->from.index = D_DX; // double-width shift
+ p1->from.index = REG_DX; // double-width shift
p1->from.scale = 0;
gins(optoas(ORSH, hi1.type), &cx, &dx);
patch(p2, pc);
zprog.link = P;
zprog.as = AGOK;
- zprog.from.type = D_NONE;
- zprog.from.index = D_NONE;
+ zprog.from.type = TYPE_NONE;
+ zprog.from.index = TYPE_NONE;
zprog.from.scale = 0;
zprog.to = zprog.from;
arch.zprog = zprog;
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;
};
EXTERN int32 dynloc;
-EXTERN uchar reg[D_NONE];
+EXTERN uchar reg[MAXREG];
EXTERN int32 pcloc; // instruction counter
EXTERN Strlit emptystring;
EXTERN Prog zprog;
#include "gg.h"
#include "opt.h"
-static Prog *appendpp(Prog*, int, int, vlong, int, vlong);
+static Prog *appendpp(Prog*, int, int, int, vlong, int, int, vlong);
static Prog *zerorange(Prog *p, vlong frame, vlong lo, vlong hi, uint32 *ax);
void
Node *n;
// fill in argument size
- ptxt->to.offset2 = rnd(curfn->type->argwid, widthptr);
+ ptxt->to.u.argsize = rnd(curfn->type->argwid, widthptr);
// fill in final stack size
frame = rnd(stksize+maxarg, widthptr);
if(cnt == 0)
return p;
if(*ax == 0) {
- p = appendpp(p, AMOVL, D_CONST, 0, D_AX, 0);
+ p = appendpp(p, AMOVL, TYPE_CONST, 0, 0, TYPE_REG, REG_AX, 0);
*ax = 1;
}
if(cnt <= 4*widthreg) {
for(i = 0; i < cnt; i += widthreg) {
- p = appendpp(p, AMOVL, D_AX, 0, D_SP+D_INDIR, frame+lo+i);
+ p = appendpp(p, AMOVL, TYPE_REG, REG_AX, 0, TYPE_MEM, REG_SP, frame+lo+i);
}
} else if(!nacl && cnt <= 128*widthreg) {
- p = appendpp(p, ALEAL, D_SP+D_INDIR, frame+lo, D_DI, 0);
- p = appendpp(p, ADUFFZERO, D_NONE, 0, D_ADDR, 1*(128-cnt/widthreg));
+ p = appendpp(p, ALEAL, TYPE_MEM, REG_SP, frame+lo, TYPE_REG, REG_DI, 0);
+ p = appendpp(p, ADUFFZERO, TYPE_NONE, 0, 0, TYPE_ADDR, 0, 1*(128-cnt/widthreg));
p->to.sym = linksym(pkglookup("duffzero", runtimepkg));
} else {
- p = appendpp(p, AMOVL, D_CONST, cnt/widthreg, D_CX, 0);
- p = appendpp(p, ALEAL, D_SP+D_INDIR, frame+lo, D_DI, 0);
- p = appendpp(p, AREP, D_NONE, 0, D_NONE, 0);
- p = appendpp(p, ASTOSL, D_NONE, 0, D_NONE, 0);
+ p = appendpp(p, AMOVL, TYPE_CONST, 0, cnt/widthreg, TYPE_REG, REG_CX, 0);
+ p = appendpp(p, ALEAL, TYPE_MEM, REG_SP, frame+lo, TYPE_REG, REG_DI, 0);
+ p = appendpp(p, AREP, TYPE_NONE, 0, 0, TYPE_NONE, 0, 0);
+ p = appendpp(p, ASTOSL, TYPE_NONE, 0, 0, TYPE_NONE, 0, 0);
}
return p;
}
static Prog*
-appendpp(Prog *p, int as, int ftype, vlong foffset, int ttype, vlong toffset)
+appendpp(Prog *p, int as, int ftype, int freg, vlong foffset, int ttype, int treg, vlong toffset)
{
Prog *q;
q = mal(sizeof(*q));
q->as = as;
q->lineno = p->lineno;
q->from.type = ftype;
+ q->from.reg = freg;
q->from.offset = foffset;
q->to.type = ttype;
+ q->to.reg = treg;
q->to.offset = toffset;
q->link = p->link;
p->link = q;
Prog **lp;
for (lp=&p; (p=*lp) != P; ) {
- if (p->as == ATYPE && p->from.node && p->from.type == 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;
}
// 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.type == D_AUTO && p->from.node)
+ if (p->from.type == TYPE_MEM && p->from.name == NAME_AUTO && p->from.node)
p->from.offset += ((Node*)(p->from.node))->stkdelta;
- if (p->to.type == D_AUTO && p->to.node)
+ if (p->to.type == TYPE_MEM && p->to.name == NAME_AUTO && p->to.node)
p->to.offset += ((Node*)(p->to.node))->stkdelta;
lp = &p->link;
return;
}
- nodreg(&n1, types[tptr], D_DI);
+ nodreg(&n1, types[tptr], REG_DI);
agen(nl, &n1);
- gconreg(AMOVL, 0, D_AX);
+ gconreg(AMOVL, 0, REG_AX);
if(q > 128 || (q >= 4 && nacl)) {
- gconreg(AMOVL, q, D_CX);
+ gconreg(AMOVL, q, REG_CX);
gins(AREP, N, N); // repeat
gins(ASTOSL, N, N); // STOL AL,*(DI)+
} else if(q >= 4) {
p = gins(ADUFFZERO, N, N);
- p->to.type = D_ADDR;
+ p->to.type = TYPE_ADDR;
p->to.sym = linksym(pkglookup("duffzero", runtimepkg));
// 1 and 128 = magic constants: see ../../runtime/asm_386.s
p->to.offset = 1*(128-q);
// x86 NOP 0x90 is really XCHG AX, AX; use that description
// because the NOP pseudo-instruction will be removed by
// the linker.
- nodreg(®, types[TINT], D_AX);
+ nodreg(®, types[TINT], REG_AX);
gins(AXCHGL, ®, ®);
}
p = gins(ACALL, N, f);
gins(AUNDEF, N, N);
break;
}
- nodreg(®, types[tptr], D_DX);
- nodreg(&r1, types[tptr], D_BX);
+ nodreg(®, types[tptr], REG_DX);
+ nodreg(&r1, types[tptr], REG_BX);
gmove(f, ®);
reg.op = OINDREG;
gmove(®, &r1);
case 2: // deferred call (defer)
memset(&stk, 0, sizeof(stk));
stk.op = OINDREG;
- stk.val.u.reg = D_SP;
+ stk.val.u.reg = REG_SP;
stk.xoffset = 0;
// size of arguments at 0(SP)
else
ginscall(deferproc, 0);
if(proc == 2) {
- nodreg(®, types[TINT32], D_AX);
+ nodreg(®, types[TINT32], REG_AX);
gins(ATESTL, ®, ®);
p = gbranch(AJEQ, T, +1);
cgen_ret(N);
// register to hold its address.
igen(i, &nodi, res); // REG = &inter
- nodindreg(&nodsp, types[tptr], D_SP);
+ nodindreg(&nodsp, types[tptr], REG_SP);
nodsp.xoffset = 0;
if(proc != 0)
nodsp.xoffset += 2 * widthptr; // leave room for size & fn
memset(&nod, 0, sizeof(nod));
nod.op = OINDREG;
- nod.val.u.reg = D_SP;
+ nod.val.u.reg = REG_SP;
nod.addable = 1;
nod.xoffset = fp->width;
memset(&nod1, 0, sizeof(nod1));
nod1.op = OINDREG;
- nod1.val.u.reg = D_SP;
+ nod1.val.u.reg = REG_SP;
nod1.addable = 1;
nod1.xoffset = fp->width;
genlist(curfn->exit);
p = gins(ARET, N, N);
if(n != N && n->op == ORETJMP) {
- p->to.type = D_EXTERN;
+ p->to.type = TYPE_MEM;
+ p->to.name = NAME_EXTERN;
p->to.sym = linksym(n->left->sym);
}
}
t = types[TINT32];
else
t = types[TUINT32];
- savex(D_AX, &ax, &oldax, res, t);
- savex(D_DX, &dx, &olddx, res, t);
+ savex(REG_AX, &ax, &oldax, res, t);
+ savex(REG_DX, &dx, &olddx, res, t);
dodiv(op, nl, nr, res, &ax, &dx);
restx(&dx, &olddx);
restx(&ax, &oldax);
}
memset(&oldcx, 0, sizeof oldcx);
- nodreg(&cx, types[TUINT32], D_CX);
- if(reg[D_CX] > 1 && !samereg(&cx, res)) {
+ nodreg(&cx, types[TUINT32], REG_CX);
+ if(reg[REG_CX] > 1 && !samereg(&cx, res)) {
tempname(&oldcx, types[TUINT32]);
gmove(&cx, &oldcx);
}
tempname(&nt, nr->type);
n1 = nt;
} else {
- nodreg(&n1, types[TUINT32], D_CX);
+ nodreg(&n1, types[TUINT32], REG_CX);
regalloc(&n1, nr->type, &n1); // to hold the shift type in CX
}
if(bounded) {
if(nr->type->width > 4) {
// delayed reg alloc
- nodreg(&n1, types[TUINT32], D_CX);
+ nodreg(&n1, types[TUINT32], REG_CX);
regalloc(&n1, types[TUINT32], &n1); // to hold the shift type in CX
split64(&nt, &lo, &hi);
gmove(&lo, &n1);
} else {
if(nr->type->width > 4) {
// delayed reg alloc
- nodreg(&n1, types[TUINT32], D_CX);
+ nodreg(&n1, types[TUINT32], REG_CX);
regalloc(&n1, types[TUINT32], &n1); // to hold the shift type in CX
split64(&nt, &lo, &hi);
gmove(&lo, &n1);
cgen(nr, &n2);
// multiply.
- nodreg(&ax, t, D_AX);
+ nodreg(&ax, t, REG_AX);
gmove(&n2, &ax);
gins(a, &n1, N);
regfree(&n2);
if(t->width == 1) {
// byte multiply behaves differently.
- nodreg(&ax, t, D_AH);
- nodreg(&dx, t, D_DX);
+ nodreg(&ax, t, REG_AH);
+ nodreg(&dx, t, REG_DX);
gmove(&ax, &dx);
}
- nodreg(&dx, t, D_DX);
+ nodreg(&dx, t, REG_DX);
gmove(&dx, res);
}
nl = n->left;
nr = n->right;
- nodreg(&f0, nl->type, D_F0);
- nodreg(&f1, n->type, D_F0+1);
+ nodreg(&f0, nl->type, REG_F0);
+ nodreg(&f1, n->type, REG_F0+1);
if(nr != N)
goto flt2;
a = brrev(a);
}
- nodreg(&tmp, nr->type, D_F0);
- nodreg(&n2, nr->type, D_F0 + 1);
- nodreg(&ax, types[TUINT16], D_AX);
+ nodreg(&tmp, nr->type, REG_F0);
+ nodreg(&n2, nr->type, REG_F0 + 1);
+ nodreg(&ax, types[TUINT16], REG_AX);
et = simsimtype(nr->type);
if(et == TFLOAT64) {
if(nl->ullman > nr->ullman) {
p1->pc = 9999;
p2->pc = 9999;
p->as = ACMPL;
- p->to.type = D_CONST;
+ p->to.type = TYPE_CONST;
p->to.offset = 0;
p1->as = AJNE;
- p1->from.type = D_CONST;
+ p1->from.type = TYPE_CONST;
p1->from.offset = 1; // likely
- p1->to.type = D_BRANCH;
+ p1->to.type = TYPE_BRANCH;
p1->to.u.branch = p2->link;
// crash by write to memory address 0.
// if possible, since we know arg is 0, use 0(arg),
// which will be shorter to encode than plain 0.
p2->as = AMOVL;
- p2->from.type = D_AX;
- if(regtyp(&p->from))
- p2->to.type = p->from.type + D_INDIR;
- else
- p2->to.type = D_INDIR+D_NONE;
+ p2->from.type = TYPE_REG;
+ p2->from.reg = REG_AX;
+ if(regtyp(&p->from)) {
+ p2->to.type = TYPE_MEM;
+ p2->to.reg = p->from.reg;
+ } else
+ p2->to.type = TYPE_MEM;
p2->to.offset = 0;
}
}
Prog *p;
p = gins(ADATA, N, N);
- p->from.type = D_EXTERN;
- p->from.index = D_NONE;
+ p->from.type = TYPE_MEM;
+ p->from.name = NAME_EXTERN;
p->from.offset = off;
p->from.scale = n;
p->from.sym = linksym(s);
- p->to.type = D_SCONST;
- p->to.index = D_NONE;
+ p->to.type = TYPE_SCONST;
memmove(p->to.u.sval, t, n);
return off + n;
}
Sym *sym;
sym = stringsym(s, len);
- a->type = D_EXTERN;
+ a->type = TYPE_MEM;
+ a->name = NAME_EXTERN;
a->sym = linksym(sym);
a->node = sym->def;
a->offset = widthptr+4; // skip header
Sym *sym;
sym = stringsym(sval->s, sval->len);
- a->type = D_EXTERN;
+ a->type = TYPE_MEM;
+ a->name = NAME_EXTERN;
a->sym = linksym(sym);
a->node = sym->def;
a->offset = 0; // header
p = gins(ADATA, nam, N);
p->from.scale = w;
- p->to.type = D_FCONST;
+ p->to.type = TYPE_FCONST;
p->to.u.dval = mpgetflt(&cval->real);
p = gins(ADATA, nam, N);
p->from.scale = w;
p->from.offset += w;
- p->to.type = D_FCONST;
+ p->to.type = TYPE_FCONST;
p->to.u.dval = mpgetflt(&cval->imag);
}
p = gins(ADATA, nam, N);
datastring(sval->s, sval->len, &p->to);
p->from.scale = types[tptr]->width;
- p->to.index = p->to.type;
- p->to.type = D_ADDR;
+ p->to.type = TYPE_ADDR;
//print("%P\n", p);
nodconst(&nod1, types[TINT32], sval->len);
off = rnd(off, widthptr);
p = gins(ADATA, N, N);
- p->from.type = D_EXTERN;
- p->from.index = D_NONE;
+ p->from.type = TYPE_MEM;
+ p->from.name = NAME_EXTERN;
p->from.sym = linksym(s);
p->from.offset = off;
p->from.scale = widthptr;
datastring(str, strlen(str)+1, &p->to);
- p->to.index = p->to.type;
- p->to.type = D_ADDR;
+ p->to.type = TYPE_ADDR;
p->to.etype = TINT32;
off += widthptr;
off = rnd(off, widthptr);
p = gins(ADATA, N, N);
- p->from.type = D_EXTERN;
- p->from.index = D_NONE;
+ p->from.type = TYPE_MEM;
+ p->from.name = NAME_EXTERN;
p->from.sym = linksym(s);
p->from.offset = off;
p->from.scale = widthptr;
datagostring(lit, &p->to);
- p->to.index = p->to.type;
- p->to.type = D_ADDR;
+ p->to.type = TYPE_ADDR;
p->to.etype = TINT32;
off += widthptr;
off = rnd(off, widthptr);
p = gins(ADATA, N, N);
- p->from.type = D_EXTERN;
- p->from.index = D_NONE;
+ p->from.type = TYPE_MEM;
+ p->from.name = NAME_EXTERN;
p->from.sym = linksym(s);
p->from.offset = off;
p->from.scale = widthptr;
- p->to.type = D_ADDR;
- p->to.index = D_EXTERN;
+ p->to.type = TYPE_ADDR;
+ p->to.name = NAME_EXTERN;
p->to.sym = linksym(x);
p->to.offset = xoff;
off += widthptr;
nopout(Prog *p)
{
p->as = ANOP;
+ p->from = zprog.from;
+ p->to = zprog.to;
}
clearp(Prog *p)
{
p->as = AEND;
- p->from.type = D_NONE;
- p->from.index = D_NONE;
- p->to.type = D_NONE;
- p->to.index = D_NONE;
+ p->from.type = TYPE_NONE;
+ p->from.index = TYPE_NONE;
+ p->to.type = TYPE_NONE;
+ p->to.index = TYPE_NONE;
p->pc = pcloc;
pcloc++;
}
USED(t);
p = prog(as);
- p->to.type = D_BRANCH;
+ p->to.type = TYPE_BRANCH;
p->to.u.branch = P;
if(likely != 0) {
- p->from.type = D_CONST;
+ p->from.type = TYPE_CONST;
p->from.offset = likely > 0;
}
return p;
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;
{
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;
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->from.scale = RODATA;
Prog *p;
p = gins(AGLOBL, N, N);
- p->from.type = D_EXTERN;
- p->from.index = D_NONE;
+ p->from.type = TYPE_MEM;
+ p->from.name = NAME_EXTERN;
+ p->from.index = REG_NONE;
p->from.sym = linksym(s);
- p->to.type = D_CONST;
- p->to.index = D_NONE;
+ p->to.type = TYPE_CONST;
+ p->to.index = REG_NONE;
p->to.offset = width;
p->from.scale = flags;
}
Prog *p;
p = gins(AUSEFIELD, N, N);
- p->from.type = D_EXTERN;
- p->from.index = D_NONE;
+ p->from.type = TYPE_MEM;
+ p->from.name = NAME_EXTERN;
p->from.sym = linksym(s);
}
void
afunclit(Addr *a, Node *n)
{
- if(a->type == D_ADDR && a->index == D_EXTERN) {
- a->type = D_EXTERN;
- a->index = D_NONE;
+ if(a->type == TYPE_ADDR && a->name == NAME_EXTERN) {
+ a->type = TYPE_MEM;
a->sym = linksym(n->sym);
}
}
static int resvd[] =
{
-// D_DI, // for movstring
-// D_SI, // for movstring
+// REG_DI, // for movstring
+// REG_SI, // for movstring
- D_AX, // for divide
- D_CX, // for shift
- D_DX, // for divide
- D_SP, // for stack
+ REG_AX, // for divide
+ REG_CX, // for shift
+ REG_DX, // for divide
+ REG_SP, // for stack
- D_BL, // because D_BX can be allocated
- D_BH,
+ REG_BL, // because REG_BX can be allocated
+ REG_BH,
};
void
for(i=0; i<nelem(reg); i++)
reg[i] = 1;
- for(i=D_AX; i<=D_DI; i++)
+ for(i=REG_AX; i<=REG_DI; i++)
reg[i] = 0;
- for(i=D_X0; i<=D_X7; i++)
+ for(i=REG_X0; i<=REG_X7; i++)
reg[i] = 0;
for(i=0; i<nelem(resvd); i++)
reg[resvd[i]]++;
}
-uintptr regpc[D_NONE];
+uintptr regpc[MAXREG];
void
gclean(void)
for(i=0; i<nelem(resvd); i++)
reg[resvd[i]]--;
- for(i=D_AX; i<=D_DI; i++)
+ for(i=REG_AX; i<=REG_DI; i++)
if(reg[i])
yyerror("reg %R left allocated at %ux", i, regpc[i]);
- for(i=D_X0; i<=D_X7; i++)
+ for(i=REG_X0; i<=REG_X7; i++)
if(reg[i])
yyerror("reg %R left allocated\n", i);
}
{
int i, j;
- for(i=D_AX; i<=D_DI; i++) {
+ for(i=REG_AX; i<=REG_DI; i++) {
if(reg[i] == 0)
goto ok;
for(j=0; j<nelem(resvd); j++)
return 1;
ok:;
}
- for(i=D_X0; i<=D_X7; i++)
+ for(i=REG_X0; i<=REG_X7; i++)
if(reg[i])
return 1;
return 0;
case TBOOL:
if(o != N && o->op == OREGISTER) {
i = o->val.u.reg;
- if(i >= D_AX && i <= D_DI)
+ if(i >= REG_AX && i <= REG_DI)
goto out;
}
- for(i=D_AX; i<=D_DI; i++)
+ for(i=REG_AX; i<=REG_DI; i++)
if(reg[i] == 0)
goto out;
fprint(2, "registers allocated at\n");
- for(i=D_AX; i<=D_DI; i++)
+ for(i=REG_AX; i<=REG_DI; i++)
fprint(2, "\t%R\t%#lux\n", i, regpc[i]);
fatal("out of fixed registers");
goto err;
case TFLOAT32:
case TFLOAT64:
if(!use_sse) {
- i = D_F0;
+ i = REG_F0;
goto out;
}
if(o != N && o->op == OREGISTER) {
i = o->val.u.reg;
- if(i >= D_X0 && i <= D_X7)
+ if(i >= REG_X0 && i <= REG_X7)
goto out;
}
- for(i=D_X0; i<=D_X7; i++)
+ for(i=REG_X0; i<=REG_X7; i++)
if(reg[i] == 0)
goto out;
fprint(2, "registers allocated at\n");
- for(i=D_X0; i<=D_X7; i++)
+ for(i=REG_X0; i<=REG_X7; i++)
fprint(2, "\t%R\t%#lux\n", i, regpc[i]);
fatal("out of floating registers");
}
return;
out:
- if (i == D_SP)
+ if(i == REG_SP)
print("alloc SP\n");
if(reg[i] == 0) {
regpc[i] = (uintptr)getcallerpc(&n);
- if(i == D_AX || i == D_CX || i == D_DX || i == D_SP) {
+ if(i == REG_AX || i == REG_CX || i == REG_DX || i == REG_SP) {
dump("regalloc-o", o);
fatal("regalloc %R", i);
}
if(n->op != OREGISTER && n->op != OINDREG)
fatal("regfree: not a register");
i = n->val.u.reg;
- if(i == D_SP)
+ if(i == REG_SP)
return;
if(i < 0 || i >= nelem(reg))
fatal("regfree: reg out of range");
if(reg[i] <= 0)
fatal("regfree: reg not allocated");
reg[i]--;
- if(reg[i] == 0 && (i == D_AX || i == D_CX || i == D_DX || i == D_SP))
+ if(reg[i] == 0 && (i == REG_AX || i == REG_CX || i == REG_DX || i == REG_SP))
fatal("regfree %R", i);
}
case 0: // output arg
n->op = OINDREG;
- n->val.u.reg = D_SP;
+ n->val.u.reg = REG_SP;
break;
case 1: // input arg
case CASE(TINT64, TUINT8):
case CASE(TUINT64, TUINT8):
split64(f, &flo, &fhi);
- nodreg(&r1, t->type, D_AX);
+ nodreg(&r1, t->type, REG_AX);
gmove(&flo, &r1);
gins(AMOVB, &r1, t);
splitclean();
case CASE(TINT64, TUINT16):
case CASE(TUINT64, TUINT16):
split64(f, &flo, &fhi);
- nodreg(&r1, t->type, D_AX);
+ nodreg(&r1, t->type, REG_AX);
gmove(&flo, &r1);
gins(AMOVW, &r1, t);
splitclean();
case CASE(TINT64, TUINT32):
case CASE(TUINT64, TUINT32):
split64(f, &flo, &fhi);
- nodreg(&r1, t->type, D_AX);
+ nodreg(&r1, t->type, REG_AX);
gmove(&flo, &r1);
gins(AMOVL, &r1, t);
splitclean();
gins(AMOVL, &flo, &tlo);
gins(AMOVL, &fhi, &thi);
} else {
- nodreg(&r1, t->type, D_AX);
- nodreg(&r2, t->type, D_DX);
+ nodreg(&r1, t->type, REG_AX);
+ nodreg(&r2, t->type, REG_DX);
gins(AMOVL, &flo, &r1);
gins(AMOVL, &fhi, &r2);
gins(AMOVL, &r1, &tlo);
case CASE(TINT32, TINT64): // sign extend int32
case CASE(TINT32, TUINT64):
split64(t, &tlo, &thi);
- nodreg(&flo, tlo.type, D_AX);
- nodreg(&fhi, thi.type, D_DX);
+ nodreg(&flo, tlo.type, REG_AX);
+ nodreg(&fhi, thi.type, REG_DX);
gmove(f, &flo);
gins(ACDQ, N, N);
gins(AMOVL, &flo, &tlo);
cvt = f->type;
goto hardmem;
}
- nodreg(&r1, types[ft], D_F0);
+ nodreg(&r1, types[ft], REG_F0);
if(ft == TFLOAT32)
gins(AFMOVF, f, &r1);
else
goto hardmem;
}
bignodes();
- nodreg(&f0, types[ft], D_F0);
- nodreg(&f1, types[ft], D_F0 + 1);
- nodreg(&ax, types[TUINT16], D_AX);
+ nodreg(&f0, types[ft], REG_F0);
+ nodreg(&f1, types[ft], REG_F0 + 1);
+ nodreg(&ax, types[TUINT16], REG_AX);
if(ft == TFLOAT32)
gins(AFMOVF, f, &f0);
case CASE(TINT64, TFLOAT64):
if(t->op == OREGISTER)
goto hardmem;
- nodreg(&f0, t->type, D_F0);
+ nodreg(&f0, t->type, REG_F0);
gins(AFMOVV, f, &f0);
if(tt == TFLOAT32)
gins(AFMOVFP, &f0, t);
// algorithm is:
// if small enough, use native int64 -> float64 conversion.
// otherwise, halve (rounding to odd?), convert, and double.
- nodreg(&ax, types[TUINT32], D_AX);
- nodreg(&dx, types[TUINT32], D_DX);
- nodreg(&cx, types[TUINT32], D_CX);
+ nodreg(&ax, types[TUINT32], REG_AX);
+ nodreg(&dx, types[TUINT32], REG_DX);
+ nodreg(&cx, types[TUINT32], REG_CX);
tempname(&t1, f->type);
split64(&t1, &tlo, &thi);
gmove(f, &t1);
gins(ACMPL, &thi, ncon(0));
p1 = gbranch(AJLT, T, 0);
// native
- nodreg(&r1, types[tt], D_F0);
+ nodreg(&r1, types[tt], REG_F0);
gins(AFMOVV, &t1, &r1);
if(tt == TFLOAT32)
gins(AFMOVFP, &r1, t);
gmove(&tlo, &ax);
gmove(&thi, &dx);
p1 = gins(ASHRL, ncon(1), &ax);
- p1->from.index = D_DX; // double-width shift DX -> AX
+ p1->from.index = REG_DX; // double-width shift DX -> AX
p1->from.scale = 0;
gins(AMOVL, ncon(0), &cx);
gins(ASETCC, N, &cx);
gins(ASHRL, ncon(1), &dx);
gmove(&dx, &thi);
gmove(&ax, &tlo);
- nodreg(&r1, types[tt], D_F0);
- nodreg(&r2, types[tt], D_F0 + 1);
+ nodreg(&r1, types[tt], REG_F0);
+ nodreg(&r2, types[tt], REG_F0 + 1);
gins(AFMOVV, &t1, &r1);
gins(AFMOVD, &r1, &r1);
gins(AFADDDP, &r1, &r2);
case CASE(TFLOAT64, TINT64):
if(t->op == OREGISTER)
goto hardmem;
- nodreg(&r1, types[ft], D_F0);
+ nodreg(&r1, types[ft], REG_F0);
if(f->op != OREGISTER) {
if(ft == TFLOAT32)
gins(AFMOVF, f, &r1);
if(ismem(f) && ismem(t))
goto hard;
if(f->op == OREGISTER && t->op == OREGISTER) {
- if(f->val.u.reg != D_F0 || t->val.u.reg != D_F0)
+ if(f->val.u.reg != REG_F0 || t->val.u.reg != REG_F0)
goto fatal;
return;
}
if(ft == TFLOAT64)
a = AFMOVD;
if(ismem(t)) {
- if(f->op != OREGISTER || f->val.u.reg != D_F0)
+ if(f->op != OREGISTER || f->val.u.reg != REG_F0)
fatal("gmove %N", f);
a = AFMOVFP;
if(ft == TFLOAT64)
if(ismem(f) && ismem(t))
goto hard;
if(f->op == OREGISTER && t->op == OREGISTER) {
- if(f->val.u.reg != D_F0 || t->val.u.reg != D_F0)
+ if(f->val.u.reg != REG_F0 || t->val.u.reg != REG_F0)
goto fatal;
return;
}
fatal("gins MOVF reg, reg");
if(as == ACVTSD2SS && f && f->op == OLITERAL)
fatal("gins CVTSD2SS const");
- if(as == AMOVSD && t && t->op == OREGISTER && t->val.u.reg == D_F0)
+ if(as == AMOVSD && t && t->op == OREGISTER && t->val.u.reg == REG_F0)
fatal("gins MOVSD into F0");
switch(as) {
dump("bad width to:", t);
fatal("bad width: %P (%d, %d)\n", p, af.width, at.width);
}
+ if(p->to.type == TYPE_ADDR && w > 0)
+ fatal("bad use of addr: %P", p);
return p;
}
Sym *s;
a->scale = 0;
- a->index = D_NONE;
- a->type = D_NONE;
+ a->reg = REG_NONE;
+ a->index = REG_NONE;
+ a->type = TYPE_NONE;
+ a->name = NAME_NONE;
a->gotype = nil;
a->node = N;
if(n == N)
break;
case OREGISTER:
- a->type = n->val.u.reg;
+ a->type = TYPE_REG;
+ a->reg = n->val.u.reg;
a->sym = nil;
break;
case OINDREG:
- a->type = n->val.u.reg+D_INDIR;
+ a->type = TYPE_MEM;
+ a->reg = n->val.u.reg;
a->sym = linksym(n->sym);
a->offset = n->xoffset;
break;
a->width = n->left->type->width;
a->offset = n->xoffset;
a->sym = linksym(n->left->sym);
- a->type = 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_DX+D_INDIR;
+ a->type = TYPE_MEM;
+ a->reg = REG_DX;
a->offset = n->xoffset;
a->sym = nil;
break;
default:
fatal("naddr: ONAME class %S %d\n", n->sym, n->class);
case PEXTERN:
- a->type = D_EXTERN;
+ a->type = TYPE_MEM;
+ a->name = NAME_EXTERN;
break;
case PAUTO:
- a->type = D_AUTO;
+ a->type = TYPE_MEM;
+ a->name = NAME_AUTO;
break;
case PPARAM:
case PPARAMOUT:
- a->type = D_PARAM;
+ a->type = TYPE_MEM;
+ a->name = NAME_PARAM;
break;
case PFUNC:
- a->index = D_EXTERN;
- a->type = D_ADDR;
+ a->type = TYPE_ADDR;
+ a->name = NAME_EXTERN;
s = funcsym(s);
break;
}
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:
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;
}
case OADDR:
naddr(n->left, a, canemitcode);
- if(a->type >= D_INDIR) {
- a->type -= D_INDIR;
- break;
- }
- if(a->type == D_EXTERN || a->type == D_STATIC ||
- a->type == D_AUTO || a->type == D_PARAM)
- if(a->index == D_NONE) {
- a->index = a->type;
- a->type = D_ADDR;
- break;
- }
- fatal("naddr: OADDR\n");
+ if(a->type != TYPE_MEM)
+ fatal("naddr: OADDR %D", a);
+ a->type = TYPE_ADDR;
+ break;
case OITAB:
// itable of interface value
naddr(n->left, a, canemitcode);
- if(a->type == D_CONST && a->offset == 0)
+ if(a->type == TYPE_CONST && a->offset == 0)
break; // len(nil)
a->etype = tptr;
a->width = widthptr;
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;
case OLEN:
// len of 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; // len(nil)
a->etype = TUINT32;
a->offset += Array_nel;
case OCAP:
// cap of 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; // cap(nil)
a->etype = TUINT32;
a->offset += Array_cap;
#define Z N
#define Adr Addr
-#define D_HI D_NONE
-#define D_LO D_NONE
-
#define BLOAD(r) band(bnot(r->refbehind), r->refahead)
#define BSTORE(r) band(bnot(r->calbehind), r->calahead)
#define LOAD(r) (~r->refbehind.b[z] & r->refahead.b[z])
extern Node *Z;
enum
{
- D_HI = D_NONE,
- D_LO = D_NONE,
CLOAD = 5,
CREF = 5,
CINF = 1000,
if(r != nil)
for(;;) {
p = r->prog;
- if(p->as != ANOP || p->from.type != D_NONE || p->to.type != D_NONE)
+ if(p->as != ANOP || p->from.type != TYPE_NONE || p->to.type != TYPE_NONE)
break;
r1 = uniqs(r);
if(r1 == nil)
case ALEAL:
if(regtyp(&p->to))
if(p->from.sym != nil)
- if(p->from.index == D_NONE || p->from.index == D_CONST)
+ if(p->from.index == REG_NONE)
conprop(r);
break;
case AMOVSS:
case AMOVSD:
if(regtyp(&p->to))
- if(p->from.type == D_CONST || p->from.type == D_FCONST)
+ if(p->from.type == TYPE_CONST || p->from.type == TYPE_FCONST)
conprop(r);
break;
}
r1 = rnops(uniqs(r));
if(r1 != nil) {
p1 = r1->prog;
- if(p->as == p1->as && p->to.type == p1->from.type){
+ if(p->as == p1->as && p->to.type == p1->from.type && p->to.reg == p1->from.reg){
p1->as = AMOVL;
t++;
}
case AADDL:
case AADDW:
- if(p->from.type != D_CONST || needc(p->link))
+ if(p->from.type != TYPE_CONST || needc(p->link))
break;
if(p->from.offset == -1){
if(p->as == AADDL)
case ASUBL:
case ASUBW:
- if(p->from.type != D_CONST || needc(p->link))
+ if(p->from.type != TYPE_CONST || needc(p->link))
break;
if(p->from.offset == -1) {
if(p->as == ASUBL)
if(debug['P'] && debug['v'])
print("%P ===delete===\n", p);
- p->as = ANOP;
- p->from = zprog.from;
- p->to = zprog.to;
+ nopout(p);
ostats.ndelmov++;
}
int
regtyp(Adr *a)
{
- int t;
-
- t = a->type;
- if(t >= D_AX && t <= D_DI)
- return 1;
- if(t >= D_X0 && t <= D_X7)
- return 1;
- return 0;
+ return a->type == TYPE_REG && (REG_AX <= a->reg && a->reg <= REG_DI || REG_X0 <= a->reg && a->reg <= REG_X7);
}
// movb elimination.
p->as = ANOTL;
break;
}
- if(regtyp(&p->from) || p->from.type == D_CONST) {
+ if(regtyp(&p->from) || p->from.type == TYPE_CONST) {
// move or artihmetic into partial register.
// from another register or constant can be movl.
// we don't switch to 32-bit arithmetic if it can
if(info.reguse | info.regset)
return 0;
- if((info.flags & Move) && (info.flags & (SizeL|SizeQ|SizeF|SizeD)) && p->to.type == v1->type)
+ if((info.flags & Move) && (info.flags & (SizeL|SizeQ|SizeF|SizeD)) && p->to.type == v1->type && p->to.reg == v1->reg)
goto gotit;
if(copyau(&p->from, v2) || copyau(&p->to, v2))
copysub(&p->to, v1, v2, 1);
if(debug['P']) {
print("gotit: %D->%D\n%P", v1, v2, r->prog);
- if(p->from.type == v2->type)
+ if(p->from.type == v2->type && p->from.reg == v2->reg)
print(" excise");
print("\n");
}
if(debug['P'])
print("%P\n", r->prog);
}
- t = v1->type;
- v1->type = v2->type;
- v2->type = t;
+ t = v1->reg;
+ v1->reg = v2->reg;
+ v2->reg = t;
if(debug['P'])
print("%P last\n", r->prog);
return 1;
return 3;
case ACALL:
- if(REGEXT && v->type <= REGEXT && v->type > exregoffset)
+ if(REGEXT && v->type == TYPE_REG && v->reg <= REGEXT && v->reg > exregoffset)
return 2;
- if(REGARG >= 0 && v->type == (uchar)REGARG)
+ if(REGARG >= 0 && v->type == TYPE_REG && v->reg == (uchar)REGARG)
return 2;
- if(v->type == p->from.type)
+ if(v->type == p->from.type && v->reg == p->from.reg)
return 2;
if(s != nil) {
return 3;
case ATEXT:
- if(REGARG >= 0 && v->type == (uchar)REGARG)
+ if(REGARG >= 0 && v->type == TYPE_REG && v->reg == (uchar)REGARG)
return 3;
return 0;
}
return 0;
proginfo(&info, p);
- if((info.reguse|info.regset) & RtoB(v->type))
+ if((info.reguse|info.regset) & RtoB(v->reg))
return 2;
if(info.flags & LeftAddr)
static int
copyas(Adr *a, Adr *v)
{
- if(D_AL <= a->type && a->type <= D_BL)
+ if(REG_AL <= a->reg && a->reg <= REG_BL)
fatal("use of byte register");
- if(D_AL <= v->type && v->type <= D_BL)
+ if(REG_AL <= v->reg && v->reg <= REG_BL)
fatal("use of byte register");
- if(a->type != v->type)
+ if(a->type != v->type || a->name != v->name || a->reg != v->reg)
return 0;
if(regtyp(v))
return 1;
- if(v->type == D_AUTO || v->type == D_PARAM)
+ if(v->type == TYPE_MEM && (v->name == NAME_AUTO || v->name == NAME_PARAM))
if(v->offset == a->offset)
return 1;
return 0;
int
sameaddr(Addr *a, Addr *v)
{
- if(a->type != v->type)
+ if(a->type != v->type || a->name != v->name || a->reg != v->reg)
return 0;
if(regtyp(v))
return 1;
- if(v->type == D_AUTO || v->type == D_PARAM)
+ if(v->type == TYPE_MEM && (v->name == NAME_AUTO || v->name == NAME_PARAM))
if(v->offset == a->offset)
return 1;
return 0;
if(copyas(a, v))
return 1;
if(regtyp(v)) {
- if(a->type-D_INDIR == v->type)
+ if(a->type == TYPE_MEM && a->reg == v->reg)
return 1;
- if(a->index == v->type)
+ if(a->index == v->reg)
return 1;
}
return 0;
static int
copysub(Adr *a, Adr *v, Adr *s, int f)
{
- int t;
+ int reg;
if(copyas(a, v)) {
- t = s->type;
- if(t >= D_AX && t <= D_DI || t >= D_X0 && t <= D_X7) {
+ reg = s->reg;
+ if(reg >= REG_AX && reg <= REG_DI || reg >= REG_X0 && reg <= REG_X7) {
if(f)
- a->type = t;
+ a->reg = reg;
}
return 0;
}
if(regtyp(v)) {
- t = v->type;
- if(a->type == t+D_INDIR) {
- if((s->type == D_BP) && a->index != D_NONE)
+ reg = v->reg;
+ if(a->type == TYPE_MEM && a->reg == reg) {
+ if((s->reg == REG_BP) && a->index != TYPE_NONE)
return 1; /* can't use BP-base with index */
if(f)
- a->type = s->type+D_INDIR;
+ a->reg = s->reg;
// return 0;
}
- if(a->index == t) {
+ if(a->index == reg) {
if(f)
- a->index = s->type;
+ a->index = s->reg;
return 0;
}
return 0;
case 3: // set
if(p->as == p0->as)
if(p->from.type == p0->from.type)
+ if(p->from.reg == p0->from.reg)
if(p->from.node == p0->from.node)
if(p->from.offset == p0->from.offset)
if(p->from.scale == p0->from.scale)
- if(p->from.type == D_FCONST && p->from.u.dval == p0->from.u.dval)
+ if(p->from.type == TYPE_FCONST && p->from.u.dval == p0->from.u.dval)
if(p->from.index == p0->from.index) {
excise(r);
goto loop;
smallindir(Addr *a, Addr *reg)
{
return regtyp(reg) &&
- a->type == D_INDIR + reg->type &&
- a->index == D_NONE &&
+ a->type == TYPE_MEM && a->reg == reg->reg &&
+ a->index == REG_NONE &&
0 <= a->offset && a->offset < 4096;
}
int
stackaddr(Addr *a)
{
- return regtyp(a) && a->type == D_SP;
+ return a->type == TYPE_REG && a->reg == REG_SP;
}
#include "opt.h"
// Matches real RtoB but can be used in global initializer.
-#define RtoB(r) (1<<((r)-D_AX))
+#define RtoB(r) (1<<((r)-REG_AX))
enum {
- AX = RtoB(D_AX),
- BX = RtoB(D_BX),
- CX = RtoB(D_CX),
- DX = RtoB(D_DX),
- DI = RtoB(D_DI),
- SI = RtoB(D_SI),
+ AX = RtoB(REG_AX),
+ BX = RtoB(REG_BX),
+ CX = RtoB(REG_CX),
+ DX = RtoB(REG_DX),
+ DI = RtoB(REG_DI),
+ SI = RtoB(REG_SI),
LeftRdwr = LeftRead | LeftWrite,
RightRdwr = RightRead | RightWrite,
if(info->flags == 0)
fatal("unknown instruction %P", p);
- if((info->flags & ShiftCX) && p->from.type != D_CONST)
+ if((info->flags & ShiftCX) && p->from.type != TYPE_CONST)
info->reguse |= CX;
if(info->flags & ImulAXDX) {
- if(p->to.type == D_NONE) {
+ if(p->to.type == TYPE_NONE) {
info->reguse |= AX;
info->regset |= AX | DX;
} else {
}
// Addressing makes some registers used.
- if(p->from.type >= D_INDIR)
- info->regindex |= RtoB(p->from.type-D_INDIR);
- if(p->from.index != D_NONE)
+ if(p->from.type == TYPE_MEM && p->from.name == NAME_NONE)
+ info->regindex |= RtoB(p->from.reg);
+ if(p->from.index != REG_NONE)
info->regindex |= RtoB(p->from.index);
- if(p->to.type >= D_INDIR)
- info->regindex |= RtoB(p->to.type-D_INDIR);
- if(p->to.index != D_NONE)
+ if(p->to.type == TYPE_MEM && p->to.name == NAME_NONE)
+ info->regindex |= RtoB(p->to.reg);
+ if(p->to.index != REG_NONE)
info->regindex |= RtoB(p->to.index);
}
if(first) {
fmtinstall('Q', Qconv);
- exregoffset = D_DI; // no externals
+ exregoffset = REG_DI; // no externals
first = 0;
}
var[i].node = regnodes[i];
}
- regbits = RtoB(D_SP);
+ regbits = RtoB(REG_SP);
for(z=0; z<BITS; z++) {
externs.b[z] = 0;
params.b[z] = 0;
proginfo(&info, p);
// Avoid making variables for direct-called functions.
- if(p->as == ACALL && p->to.type == D_EXTERN)
+ if(p->as == ACALL && p->to.type == TYPE_MEM && p->to.name == NAME_EXTERN)
continue;
r->use1.b[0] |= info.reguse | info.regindex;
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(!use_sse)
for(p=firstp; p!=P; p=p->link) {
- if(p->from.type >= D_X0 && p->from.type <= D_X7)
- fatal("invalid use of %R with GO386=387: %P", p->from.type, p);
- if(p->to.type >= D_X0 && p->to.type <= D_X7)
- fatal("invalid use of %R with GO386=387: %P", p->to.type, p);
+ if(p->from.reg >= REG_X0 && p->from.reg <= REG_X7)
+ fatal("invalid use of %R with GO386=387: %P", p->from.reg, p);
+ if(p->to.reg >= REG_X0 && p->to.reg <= REG_X7)
+ fatal("invalid use of %R with GO386=387: %P", p->to.reg, p);
}
if(debug['R']) {
a = &p1->to;
a->offset = v->offset;
a->etype = v->etype;
- a->type = v->name;
+ a->type = TYPE_MEM;
+ a->name = v->name;
a->node = v->node;
a->sym = linksym(v->node->sym);
break;
}
- p1->from.type = rn;
+ p1->from.type = TYPE_REG;
+ p1->from.reg = rn;
+ p1->from.name = 0;
if(!f) {
p1->from = *a;
*a = zprog.from;
- a->type = rn;
+ a->type = TYPE_REG;
+ a->reg = rn;
if(v->etype == TUINT8)
p1->as = AMOVB;
if(v->etype == TUINT16)
uint32 b;
b = 0;
- if(r >= D_INDIR)
- r -= D_INDIR;
- if(r >= D_AX && r <= D_DI)
+ if(r >= REG_AX && r <= REG_DI)
b |= RtoB(r);
else
- if(r >= D_AL && r <= D_BL)
- b |= RtoB(r-D_AL+D_AX);
+ if(r >= REG_AL && r <= REG_BL)
+ b |= RtoB(r-REG_AL+REG_AX);
else
- if(r >= D_AH && r <= D_BH)
- b |= RtoB(r-D_AH+D_AX);
+ if(r >= REG_AH && r <= REG_BH)
+ b |= RtoB(r-REG_AH+REG_AX);
else
- if(r >= D_X0 && r <= D_X0+7)
+ if(r >= REG_X0 && r <= REG_X0+7)
b |= FtoB(r);
return b;
}
mkvar(Reg *r, Adr *a)
{
Var *v;
- int i, t, n, et, z, w, flag, regu;
+ int i, n, et, z, w, flag, regu;
int32 o;
Bits bit;
Node *node;
/*
* mark registers used
*/
- t = a->type;
- if(t == D_NONE)
+ if(a->type == TYPE_NONE)
goto none;
if(r != R)
r->use1.b[0] |= doregbits(a->index);
- switch(t) {
+ switch(a->type) {
default:
- regu = doregbits(t);
+ regu = doregbits(a->reg);
if(regu == 0)
goto none;
bit = zbits;
bit.b[0] = regu;
return bit;
- case D_ADDR:
- a->type = a->index;
+ case TYPE_ADDR:
+ a->type = TYPE_MEM;
bit = mkvar(r, a);
setaddrs(bit);
- a->type = t;
+ a->type = TYPE_ADDR;
ostats.naddr++;
goto none;
- case D_EXTERN:
- case D_STATIC:
- case D_PARAM:
- case D_AUTO:
- n = t;
- break;
+ case TYPE_MEM:
+ switch(a->name) {
+ case NAME_EXTERN:
+ case NAME_STATIC:
+ case NAME_PARAM:
+ case NAME_AUTO:
+ n = a->name;
+ break;
+ }
}
node = a->node;
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];
if(r->use1.b[z] & bb) {
change += CREF * r->f.loop;
if(p->as == AFMOVL || p->as == AFMOVW)
- if(BtoR(bb) != D_F0)
+ if(BtoR(bb) != REG_F0)
change = -CINF;
}
if((r->use2.b[z]|r->set.b[z]) & bb) {
change += CREF * r->f.loop;
if(p->as == AFMOVL || p->as == AFMOVW)
- if(BtoR(bb) != D_F0)
+ if(BtoR(bb) != REG_F0)
change = -CINF;
}
}
if(STORE(r) & r->regdiff.b[z] & bb) {
change -= CLOAD * r->f.loop;
if(p->as == AFMOVL || p->as == AFMOVW)
- if(BtoR(bb) != D_F0)
+ if(BtoR(bb) != REG_F0)
change = -CINF;
}
a->sym = nil;
a->node = nil;
a->offset = 0;
- a->type = rn;
+ a->type = TYPE_REG;
+ a->reg = rn;
+ a->name = 0;
ostats.ncvtreg++;
}
RtoB(int r)
{
- if(r < D_AX || r > D_DI)
+ if(r < REG_AX || r > REG_DI)
return 0;
- return 1L << (r-D_AX);
+ return 1L << (r-REG_AX);
}
int
b &= 0xffL;
if(b == 0)
return 0;
- return bitno(b) + D_AX;
+ return bitno(b) + REG_AX;
}
uint32
FtoB(int f)
{
- if(f < D_X0 || f > D_X7)
+ if(f < REG_X0 || f > REG_X7)
return 0;
- return 1L << (f - D_X0 + 8);
+ return 1L << (f - REG_X0 + 8);
}
int
b &= 0xFF00L;
if(b == 0)
return 0;
- return bitno(b) - 8 + D_X0;
+ return bitno(b) - 8 + REG_X0;
}
void
enum
{
- D_AL = 0,
- D_CL,
- D_DL,
- D_BL,
-
- D_AH = 4,
- D_CH,
- D_DH,
- D_BH,
-
- D_AX = 8,
- D_CX,
- D_DX,
- D_BX,
- D_SP,
- D_BP,
- D_SI,
- D_DI,
-
- D_F0 = 16,
- D_F7 = D_F0 + 7,
-
- D_CS = 24,
- D_SS,
- D_DS,
- D_ES,
- D_FS,
- D_GS,
-
- D_GDTR, /* global descriptor table register */
- D_IDTR, /* interrupt descriptor table register */
- D_LDTR, /* local descriptor table register */
- D_MSW, /* machine status word */
- D_TASK, /* task register */
-
- D_CR = 35,
- D_DR = 43,
- D_TR = 51,
-
- D_X0 = 59,
- D_X1,
- D_X2,
- D_X3,
- D_X4,
- D_X5,
- D_X6,
- D_X7,
+ REG_NONE = 0,
+
+ REG_AL = 0+16,
+ REG_CL,
+ REG_DL,
+ REG_BL,
+
+ REG_AH = 4+16,
+ REG_CH,
+ REG_DH,
+ REG_BH,
+
+ REG_AX = 8+16,
+ REG_CX,
+ REG_DX,
+ REG_BX,
+ REG_SP,
+ REG_BP,
+ REG_SI,
+ REG_DI,
+
+ REG_F0 = 16+16,
+ REG_F7 = REG_F0 + 7+16,
+
+ REG_CS = 24+16,
+ REG_SS,
+ REG_DS,
+ REG_ES,
+ REG_FS,
+ REG_GS,
+
+ REG_GDTR, /* global descriptor table register */
+ REG_IDTR, /* interrupt descriptor table register */
+ REG_LDTR, /* local descriptor table register */
+ REG_MSW, /* machine status word */
+ REG_TASK, /* task register */
+
+ REG_CR = 35+16,
+ REG_DR = 43+16,
+ REG_TR = 51+16,
+
+ REG_X0 = 59+16,
+ REG_X1,
+ REG_X2,
+ REG_X3,
+ REG_X4,
+ REG_X5,
+ REG_X6,
+ REG_X7,
- D_TLS = 67,
- D_NONE = 68,
-
- D_BRANCH = 69,
- D_EXTERN = 70,
- D_STATIC = 71,
- D_AUTO = 72,
- D_PARAM = 73,
- D_CONST = 74,
- D_FCONST = 75,
- D_SCONST = 76,
- D_ADDR = 77,
-
- D_INDIR, /* additive */
-
- D_CONST2 = D_INDIR+D_INDIR,
-
- D_LAST,
+ REG_TLS = 67+16,
+ MAXREG = 68+16,
T_TYPE = 1<<0,
T_INDEX = 1<<1,
T_GOTYPE = 1<<7,
REGARG = -1,
- REGRET = D_AX,
- FREGRET = D_F0,
- REGSP = D_SP,
- REGTMP = D_DI,
+ REGRET = REG_AX,
+ FREGRET = REG_F0,
+ REGSP = REG_SP,
+ REGTMP = REG_DI,
};
/*
};
static uchar ycover[Ymax*Ymax];
-static int reg[D_NONE];
+static int reg[MAXREG];
static void asmins(Link *ctxt, Prog *p);
static uchar ynone[] =
{ AMULW, ydivl, Pe, {0xf7,(04)} },
{ ANAME },
{ ANEGB, yscond, Px, {0xf6,(03)} },
- { ANEGL, yscond, Px, {0xf7,(03)} },
- { ANEGW, yscond, Pe, {0xf7,(03)} },
+ { ANEGL, yscond, Px, {0xf7,(03)} }, // TODO(rsc): yscond is wrong here.
+ { ANEGW, yscond, Pe, {0xf7,(03)} }, // TODO(rsc): yscond is wrong here.
{ ANOP, ynop, Px, {0,0} },
{ ANOTB, yscond, Px, {0xf6,(02)} },
- { ANOTL, yscond, Px, {0xf7,(02)} },
- { ANOTW, yscond, Pe, {0xf7,(02)} },
+ { ANOTL, yscond, Px, {0xf7,(02)} }, // TODO(rsc): yscond is wrong here.
+ { ANOTW, yscond, Pe, {0xf7,(02)} }, // TODO(rsc): yscond is wrong here.
{ AORB, yxorb, Pb, {0x0c,0x80,(01),0x08,0x0a} },
{ AORL, yxorl, Px, {0x83,(01),0x0d,0x81,(01),0x09,0x0b} },
{ AORW, yxorl, Pe, {0x83,(01),0x0d,0x81,(01),0x09,0x0b} },
{ ACMPXCHGB, yrb_mb, Pm, {0xb0} },
{ ACMPXCHGL, yrl_ml, Pm, {0xb1} },
{ ACMPXCHGW, yrl_ml, Pm, {0xb1} },
- { ACMPXCHG8B, yscond, Pm, {0xc7,(01)} },
+ { ACMPXCHG8B, yscond, Pm, {0xc7,(01)} }, // TODO(rsc): yscond is wrong here.
{ ACPUID, ynone, Pm, {0xa2} },
{ ARDTSC, ynone, Pm, {0x31} },
for(p = s->text; p != nil; p = p->link) {
n = 0;
- if(p->to.type == D_BRANCH)
+ if(p->to.type == TYPE_BRANCH)
if(p->pcond == nil)
p->pcond = p;
if((q = p->pcond) != nil)
n = 1;
p->back = n;
if(p->as == AADJSP) {
- p->to.type = D_SP;
+ p->to.type = TYPE_REG;
+ p->to.reg = REG_SP;
v = -p->from.offset;
p->from.offset = v;
p->as = AADDL;
p->back |= 1; // backward jump
if(p->as == AADJSP) {
- p->to.type = D_SP;
+ p->to.type = TYPE_REG;
+ p->to.reg = REG_SP;
v = -p->from.offset;
p->from.offset = v;
p->as = AADDL;
ycover[Ym*Ymax + Yxm] = 1;
ycover[Yxr*Ymax + Yxm] = 1;
- for(i=0; i<D_NONE; i++) {
+ for(i=0; i<MAXREG; i++) {
reg[i] = -1;
- if(i >= D_AL && i <= D_BH)
- reg[i] = (i-D_AL) & 7;
- if(i >= D_AX && i <= D_DI)
- reg[i] = (i-D_AX) & 7;
- if(i >= D_F0 && i <= D_F0+7)
- reg[i] = (i-D_F0) & 7;
- if(i >= D_X0 && i <= D_X0+7)
- reg[i] = (i-D_X0) & 7;
+ if(i >= REG_AL && i <= REG_BH)
+ reg[i] = (i-REG_AL) & 7;
+ if(i >= REG_AX && i <= REG_DI)
+ reg[i] = (i-REG_AX) & 7;
+ if(i >= REG_F0 && i <= REG_F0+7)
+ reg[i] = (i-REG_F0) & 7;
+ if(i >= REG_X0 && i <= REG_X0+7)
+ reg[i] = (i-REG_X0) & 7;
}
}
static int
prefixof(Link *ctxt, Addr *a)
{
- switch(a->type) {
- case D_INDIR+D_CS:
- return 0x2e;
- case D_INDIR+D_DS:
- return 0x3e;
- case D_INDIR+D_ES:
- return 0x26;
- case D_INDIR+D_FS:
- return 0x64;
- case D_INDIR+D_GS:
- return 0x65;
- case D_INDIR+D_TLS:
- // NOTE: Systems listed here should be only systems that
- // support direct TLS references like 8(TLS) implemented as
- // direct references from FS or GS. Systems that require
- // the initial-exec model, where you load the TLS base into
- // a register and then index from that register, do not reach
- // this code and should not be listed.
- switch(ctxt->headtype) {
- default:
- sysfatal("unknown TLS base register for %s", headstr(ctxt->headtype));
- case Hdarwin:
- case Hdragonfly:
- case Hfreebsd:
- case Hnetbsd:
- case Hopenbsd:
- return 0x65; // GS
+ if(a->type == TYPE_MEM && a->name == NAME_NONE) {
+ switch(a->reg) {
+ case REG_CS:
+ return 0x2e;
+ case REG_DS:
+ return 0x3e;
+ case REG_ES:
+ return 0x26;
+ case REG_FS:
+ return 0x64;
+ case REG_GS:
+ return 0x65;
+ case REG_TLS:
+ // NOTE: Systems listed here should be only systems that
+ // support direct TLS references like 8(TLS) implemented as
+ // direct references from FS or GS. Systems that require
+ // the initial-exec model, where you load the TLS base into
+ // a register and then index from that register, do not reach
+ // this code and should not be listed.
+ switch(ctxt->headtype) {
+ default:
+ sysfatal("unknown TLS base register for %s", headstr(ctxt->headtype));
+ case Hdarwin:
+ case Hdragonfly:
+ case Hfreebsd:
+ case Hnetbsd:
+ case Hopenbsd:
+ return 0x65; // GS
+ }
}
}
return 0;
}
static int
-oclass(Addr *a)
+oclass(Link *ctxt, Addr *a)
{
int32 v;
- if((a->type >= D_INDIR && a->type < 2*D_INDIR) || a->index != D_NONE) {
- if(a->index != D_NONE && a->scale == 0) {
- if(a->type == D_ADDR) {
- switch(a->index) {
- case D_EXTERN:
- case D_STATIC:
- return Yi32;
- case D_AUTO:
- case D_PARAM:
- return Yiauto;
- }
- return Yxxx;
- }
- //if(a->type == D_INDIR+D_ADDR)
- // print("*Ycol\n");
+ // TODO(rsc): This special case is for SHRQ $3, AX:DX,
+ // which encodes as SHRQ $32(DX*0), AX.
+ // Similarly SHRQ CX, AX:DX is really SHRQ CX(DX*0), AX.
+ // Change encoding and remove.
+ if((a->type == TYPE_CONST || a->type == TYPE_REG) && a->index != REG_NONE && a->scale == 0)
+ return Ycol;
+
+ switch(a->type) {
+ case TYPE_NONE:
+ return Ynone;
+
+ case TYPE_BRANCH:
+ return Ybr;
+
+ case TYPE_INDIR:
+ // TODO(rsc): Why this is also Ycol is a mystery. Should split the two meanings.
+ if(a->name != NAME_NONE && a->reg == REG_NONE && a->index == REG_NONE && a->scale == 0)
return Ycol;
- }
+ return Yxxx;
+
+ case TYPE_MEM:
return Ym;
+
+ case TYPE_ADDR:
+ switch(a->name) {
+ case NAME_EXTERN:
+ case NAME_STATIC:
+ return Yi32;
+ case NAME_AUTO:
+ case NAME_PARAM:
+ return Yiauto;
+ }
+
+ // DUFFZERO/DUFFCOPY encoding forgot to set a->index
+ // and got Yi32 in an earlier version of this code.
+ // Keep doing that until we fix yduff etc.
+ if(a->sym != nil && strncmp(a->sym->name, "runtime.duff", 12) == 0)
+ return Yi32;
+
+ if(a->sym != nil || a->name != NAME_NONE)
+ ctxt->diag("unexpected addr: %D", a);
+ // fall through
+
+ case TYPE_CONST:
+ case TYPE_TEXTSIZE:
+ if(a->sym != nil)
+ ctxt->diag("TYPE_CONST with symbol: %D", a);
+
+ v = a->offset;
+ if(v == 0)
+ return Yi0;
+ if(v == 1)
+ return Yi1;
+ if(v >= -128 && v <= 127)
+ return Yi8;
+ return Yi32;
+ }
+
+ if(a->type != TYPE_REG) {
+ ctxt->diag("unexpected addr1: type=%d %D", a->type, a);
+ return Yxxx;
}
- switch(a->type)
- {
- case D_AL:
+
+ switch(a->reg) {
+ case REG_AL:
return Yal;
- case D_AX:
+ case REG_AX:
return Yax;
- case D_CL:
- case D_DL:
- case D_BL:
- case D_AH:
- case D_CH:
- case D_DH:
- case D_BH:
+ case REG_CL:
+ case REG_DL:
+ case REG_BL:
+ case REG_AH:
+ case REG_CH:
+ case REG_DH:
+ case REG_BH:
return Yrb;
- case D_CX:
+ case REG_CX:
return Ycx;
- case D_DX:
- case D_BX:
+ case REG_DX:
+ case REG_BX:
return Yrx;
- case D_SP:
- case D_BP:
- case D_SI:
- case D_DI:
+ case REG_SP:
+ case REG_BP:
+ case REG_SI:
+ case REG_DI:
return Yrl;
- case D_F0+0:
+ case REG_F0+0:
return Yf0;
- case D_F0+1:
- case D_F0+2:
- case D_F0+3:
- case D_F0+4:
- case D_F0+5:
- case D_F0+6:
- case D_F0+7:
+ case REG_F0+1:
+ case REG_F0+2:
+ case REG_F0+3:
+ case REG_F0+4:
+ case REG_F0+5:
+ case REG_F0+6:
+ case REG_F0+7:
return Yrf;
- case D_X0+0:
- case D_X0+1:
- case D_X0+2:
- case D_X0+3:
- case D_X0+4:
- case D_X0+5:
- case D_X0+6:
- case D_X0+7:
+ case REG_X0+0:
+ case REG_X0+1:
+ case REG_X0+2:
+ case REG_X0+3:
+ case REG_X0+4:
+ case REG_X0+5:
+ case REG_X0+6:
+ case REG_X0+7:
return Yxr;
- case D_NONE:
- return Ynone;
-
- case D_CS: return Ycs;
- case D_SS: return Yss;
- case D_DS: return Yds;
- case D_ES: return Yes;
- case D_FS: return Yfs;
- case D_GS: return Ygs;
- case D_TLS: return Ytls;
-
- case D_GDTR: return Ygdtr;
- case D_IDTR: return Yidtr;
- case D_LDTR: return Yldtr;
- case D_MSW: return Ymsw;
- case D_TASK: return Ytask;
-
- case D_CR+0: return Ycr0;
- case D_CR+1: return Ycr1;
- case D_CR+2: return Ycr2;
- case D_CR+3: return Ycr3;
- case D_CR+4: return Ycr4;
- case D_CR+5: return Ycr5;
- case D_CR+6: return Ycr6;
- case D_CR+7: return Ycr7;
-
- case D_DR+0: return Ydr0;
- case D_DR+1: return Ydr1;
- case D_DR+2: return Ydr2;
- case D_DR+3: return Ydr3;
- case D_DR+4: return Ydr4;
- case D_DR+5: return Ydr5;
- case D_DR+6: return Ydr6;
- case D_DR+7: return Ydr7;
-
- case D_TR+0: return Ytr0;
- case D_TR+1: return Ytr1;
- case D_TR+2: return Ytr2;
- case D_TR+3: return Ytr3;
- case D_TR+4: return Ytr4;
- case D_TR+5: return Ytr5;
- case D_TR+6: return Ytr6;
- case D_TR+7: return Ytr7;
-
- case D_EXTERN:
- case D_STATIC:
- case D_AUTO:
- case D_PARAM:
- return Ym;
+ case REG_CS: return Ycs;
+ case REG_SS: return Yss;
+ case REG_DS: return Yds;
+ case REG_ES: return Yes;
+ case REG_FS: return Yfs;
+ case REG_GS: return Ygs;
+ case REG_TLS: return Ytls;
+
+ case REG_GDTR: return Ygdtr;
+ case REG_IDTR: return Yidtr;
+ case REG_LDTR: return Yldtr;
+ case REG_MSW: return Ymsw;
+ case REG_TASK: return Ytask;
+
+ case REG_CR+0: return Ycr0;
+ case REG_CR+1: return Ycr1;
+ case REG_CR+2: return Ycr2;
+ case REG_CR+3: return Ycr3;
+ case REG_CR+4: return Ycr4;
+ case REG_CR+5: return Ycr5;
+ case REG_CR+6: return Ycr6;
+ case REG_CR+7: return Ycr7;
+
+ case REG_DR+0: return Ydr0;
+ case REG_DR+1: return Ydr1;
+ case REG_DR+2: return Ydr2;
+ case REG_DR+3: return Ydr3;
+ case REG_DR+4: return Ydr4;
+ case REG_DR+5: return Ydr5;
+ case REG_DR+6: return Ydr6;
+ case REG_DR+7: return Ydr7;
+
+ case REG_TR+0: return Ytr0;
+ case REG_TR+1: return Ytr1;
+ case REG_TR+2: return Ytr2;
+ case REG_TR+3: return Ytr3;
+ case REG_TR+4: return Ytr4;
+ case REG_TR+5: return Ytr5;
+ case REG_TR+6: return Ytr6;
+ case REG_TR+7: return Ytr7;
- case D_CONST:
- case D_CONST2:
- case D_ADDR:
- if(a->sym == nil) {
- v = a->offset;
- if(v == 0)
- return Yi0;
- if(v == 1)
- return Yi1;
- if(v >= -128 && v <= 127)
- return Yi8;
- }
- return Yi32;
-
- case D_BRANCH:
- return Ybr;
}
return Yxxx;
}
default:
goto bad;
- case D_NONE:
+ case TYPE_NONE:
i = 4 << 3;
goto bas;
- case D_AX:
- case D_CX:
- case D_DX:
- case D_BX:
- case D_BP:
- case D_SI:
- case D_DI:
+ case REG_AX:
+ case REG_CX:
+ case REG_DX:
+ case REG_BX:
+ case REG_BP:
+ case REG_SI:
+ case REG_DI:
i = reg[index] << 3;
break;
}
switch(base) {
default:
goto bad;
- case D_NONE: /* must be mod=00 */
+ case REG_NONE: /* must be mod=00 */
i |= 5;
break;
- case D_AX:
- case D_CX:
- case D_DX:
- case D_BX:
- case D_SP:
- case D_BP:
- case D_SI:
- case D_DI:
+ case REG_AX:
+ case REG_CX:
+ case REG_DX:
+ case REG_BX:
+ case REG_SP:
+ case REG_BP:
+ case REG_SI:
+ case REG_DI:
i |= reg[base];
break;
}
static int32
vaddr(Link *ctxt, Prog *p, Addr *a, Reloc *r)
{
- int t;
- int32 v;
LSym *s;
USED(p);
if(r != nil)
memset(r, 0, sizeof *r);
- t = a->type;
- v = a->offset;
- if(t == D_ADDR)
- t = a->index;
- switch(t) {
- case D_STATIC:
- case D_EXTERN:
+ switch(a->name) {
+ case NAME_STATIC:
+ case NAME_EXTERN:
s = a->sym;
if(s != nil) {
if(r == nil) {
r->siz = 4;
r->off = -1;
r->sym = s;
- r->add = v;
- v = 0;
+ r->add = a->offset;
+ return 0;
}
- break;
+ return a->offset;
+ }
- case D_INDIR+D_TLS:
+ if((a->type == TYPE_MEM || a->type == TYPE_ADDR) && a->reg == REG_TLS) {
if(r == nil) {
ctxt->diag("need reloc for %D", a);
sysfatal("bad code");
r->type = R_TLS_LE;
r->siz = 4;
r->off = -1; // caller must fill in
- r->add = v;
- v = 0;
- break;
+ r->add = a->offset;
+ return 0;
}
- return v;
+
+ return a->offset;
}
static void
asmand(Link *ctxt, Prog *p, Addr *a, int r)
{
int32 v;
- int t, scale;
+ int base;
Reloc rel;
USED(p);
v = a->offset;
- t = a->type;
rel.siz = 0;
- if(a->index != D_NONE && a->index != D_TLS) {
- if(t < D_INDIR || t >= 2*D_INDIR) {
- switch(t) {
- default:
- goto bad;
- case D_STATIC:
- case D_EXTERN:
- t = D_NONE;
- v = vaddr(ctxt, p, a, &rel);
- break;
- case D_AUTO:
- case D_PARAM:
- t = D_SP;
- break;
- }
- } else
- t -= D_INDIR;
- if(t == D_NONE) {
+ switch(a->type) {
+ case TYPE_ADDR:
+ if(a->name == NAME_NONE)
+ ctxt->diag("unexpected TYPE_ADDR with NAME_NONE");
+ if(a->index == REG_TLS)
+ ctxt->diag("unexpected TYPE_ADDR with index==REG_TLS");
+ goto bad;
+
+ case TYPE_REG:
+ if((a->reg < REG_AL || REG_F7 < a->reg) && (a->reg < REG_X0 || REG_X0+7 < a->reg))
+ goto bad;
+ if(v)
+ goto bad;
+ *ctxt->andptr++ = (3 << 6) | (reg[a->reg] << 0) | (r << 3);
+ return;
+ }
+
+ if(a->type != TYPE_MEM)
+ goto bad;
+
+ if(a->index != REG_NONE && a->index != REG_TLS) {
+ base = a->reg;
+ switch(a->name) {
+ case NAME_EXTERN:
+ case NAME_STATIC:
+ base = REG_NONE;
+ v = vaddr(ctxt, p, a, &rel);
+ break;
+ case NAME_AUTO:
+ case NAME_PARAM:
+ base = REG_SP;
+ break;
+ }
+
+ if(base == REG_NONE) {
*ctxt->andptr++ = (0 << 6) | (4 << 0) | (r << 3);
- asmidx(ctxt, a->scale, a->index, t);
+ asmidx(ctxt, a->scale, a->index, base);
goto putrelv;
}
- if(v == 0 && rel.siz == 0 && t != D_BP) {
+ if(v == 0 && rel.siz == 0 && base != REG_BP) {
*ctxt->andptr++ = (0 << 6) | (4 << 0) | (r << 3);
- asmidx(ctxt, a->scale, a->index, t);
+ asmidx(ctxt, a->scale, a->index, base);
return;
}
if(v >= -128 && v < 128 && rel.siz == 0) {
*ctxt->andptr++ = (1 << 6) | (4 << 0) | (r << 3);
- asmidx(ctxt, a->scale, a->index, t);
+ asmidx(ctxt, a->scale, a->index, base);
*ctxt->andptr++ = v;
return;
}
*ctxt->andptr++ = (2 << 6) | (4 << 0) | (r << 3);
- asmidx(ctxt, a->scale, a->index, t);
+ asmidx(ctxt, a->scale, a->index, base);
goto putrelv;
}
- if(t >= D_AL && t <= D_F7 || t >= D_X0 && t <= D_X7) {
- if(v)
- goto bad;
- *ctxt->andptr++ = (3 << 6) | (reg[t] << 0) | (r << 3);
- return;
+
+ base = a->reg;
+ switch(a->name) {
+ case NAME_STATIC:
+ case NAME_EXTERN:
+ base = REG_NONE;
+ v = vaddr(ctxt, p, a, &rel);
+ break;
+ case NAME_AUTO:
+ case NAME_PARAM:
+ base = REG_SP;
+ break;
}
- scale = a->scale;
- if(t < D_INDIR || t >= 2*D_INDIR) {
- switch(a->type) {
- default:
- goto bad;
- case D_STATIC:
- case D_EXTERN:
- t = D_NONE;
- v = vaddr(ctxt, p, a, &rel);
- break;
- case D_AUTO:
- case D_PARAM:
- t = D_SP;
- break;
- }
- scale = 1;
- } else
- t -= D_INDIR;
- if(t == D_TLS)
+ if(base == REG_TLS)
v = vaddr(ctxt, p, a, &rel);
-
- if(t == D_NONE || (D_CS <= t && t <= D_GS) || t == D_TLS) {
+
+ if(base == REG_NONE || (REG_CS <= base && base <= REG_GS) || base == REG_TLS) {
*ctxt->andptr++ = (0 << 6) | (5 << 0) | (r << 3);
goto putrelv;
}
- if(t == D_SP) {
+
+ if(base == REG_SP) {
if(v == 0 && rel.siz == 0) {
*ctxt->andptr++ = (0 << 6) | (4 << 0) | (r << 3);
- asmidx(ctxt, scale, D_NONE, t);
+ asmidx(ctxt, a->scale, REG_NONE, base);
return;
}
if(v >= -128 && v < 128 && rel.siz == 0) {
*ctxt->andptr++ = (1 << 6) | (4 << 0) | (r << 3);
- asmidx(ctxt, scale, D_NONE, t);
+ asmidx(ctxt, a->scale, REG_NONE, base);
*ctxt->andptr++ = v;
return;
}
*ctxt->andptr++ = (2 << 6) | (4 << 0) | (r << 3);
- asmidx(ctxt, scale, D_NONE, t);
+ asmidx(ctxt, a->scale, REG_NONE, base);
goto putrelv;
}
- if(t >= D_AX && t <= D_DI) {
- if(a->index == D_TLS) {
+
+ if(REG_AX <= base && base <= REG_DI) {
+ if(a->index == REG_TLS) {
memset(&rel, 0, sizeof rel);
rel.type = R_TLS_IE;
rel.siz = 4;
rel.add = v;
v = 0;
}
- if(v == 0 && rel.siz == 0 && t != D_BP) {
- *ctxt->andptr++ = (0 << 6) | (reg[t] << 0) | (r << 3);
+ if(v == 0 && rel.siz == 0 && base != REG_BP) {
+ *ctxt->andptr++ = (0 << 6) | (reg[base] << 0) | (r << 3);
return;
}
if(v >= -128 && v < 128 && rel.siz == 0) {
- ctxt->andptr[0] = (1 << 6) | (reg[t] << 0) | (r << 3);
+ ctxt->andptr[0] = (1 << 6) | (reg[base] << 0) | (r << 3);
ctxt->andptr[1] = v;
ctxt->andptr += 2;
return;
}
- *ctxt->andptr++ = (2 << 6) | (reg[t] << 0) | (r << 3);
+ *ctxt->andptr++ = (2 << 6) | (reg[base] << 0) | (r << 3);
goto putrelv;
}
goto bad;
};
// byteswapreg returns a byte-addressable register (AX, BX, CX, DX)
-// which is not referenced in a->type.
+// which is not referenced in a.
// If a is empty, it returns BX to account for MULB-like instructions
// that might use DX and AX.
static int
cana = canb = canc = cand = 1;
- switch(a->type) {
- case D_NONE:
+ if(a->type == TYPE_NONE)
cana = cand = 0;
- break;
- case D_AX:
- case D_AL:
- case D_AH:
- case D_INDIR+D_AX:
- cana = 0;
- break;
- case D_BX:
- case D_BL:
- case D_BH:
- case D_INDIR+D_BX:
- canb = 0;
- break;
- case D_CX:
- case D_CL:
- case D_CH:
- case D_INDIR+D_CX:
- canc = 0;
- break;
- case D_DX:
- case D_DL:
- case D_DH:
- case D_INDIR+D_DX:
- cand = 0;
- break;
+
+ if(a->type == TYPE_REG || ((a->type == TYPE_MEM || a->type == TYPE_ADDR) && a->name == NAME_NONE)) {
+ switch(a->reg) {
+ case REG_NONE:
+ cana = cand = 0;
+ break;
+ case REG_AX:
+ case REG_AL:
+ case REG_AH:
+ cana = 0;
+ break;
+ case REG_BX:
+ case REG_BL:
+ case REG_BH:
+ canb = 0;
+ break;
+ case REG_CX:
+ case REG_CL:
+ case REG_CH:
+ canc = 0;
+ break;
+ case REG_DX:
+ case REG_DL:
+ case REG_DH:
+ cand = 0;
+ break;
+ }
}
- switch(a->index) {
- case D_AX:
- cana = 0;
- break;
- case D_BX:
- canb = 0;
- break;
- case D_CX:
- canc = 0;
- break;
- case D_DX:
- cand = 0;
- break;
+ if(a->type == TYPE_MEM || a->type == TYPE_ADDR) {
+ switch(a->index) {
+ case REG_AX:
+ cana = 0;
+ break;
+ case REG_BX:
+ canb = 0;
+ break;
+ case REG_CX:
+ canc = 0;
+ break;
+ case REG_DX:
+ cand = 0;
+ break;
+ }
}
if(cana)
- return D_AX;
+ return REG_AX;
if(canb)
- return D_BX;
+ return REG_BX;
if(canc)
- return D_CX;
+ return REG_CX;
if(cand)
- return D_DX;
+ return REG_DX;
ctxt->diag("impossible byte register");
sysfatal("bad code");
static void
subreg(Prog *p, int from, int to)
{
-
if(0 /* debug['Q'] */)
print("\n%P s/%R/%R/\n", p, from, to);
- if(p->from.type == from) {
- p->from.type = to;
+ if(p->from.reg == from) {
+ p->from.reg = to;
p->ft = 0;
}
- if(p->to.type == from) {
- p->to.type = to;
+ if(p->to.reg == from) {
+ p->to.reg = to;
p->tt = 0;
}
p->tt = 0;
}
- from += D_INDIR;
- if(p->from.type == from) {
- p->from.type = to+D_INDIR;
- p->ft = 0;
- }
- if(p->to.type == from) {
- p->to.type = to+D_INDIR;
- p->tt = 0;
- }
-
if(0 /* debug['Q'] */)
print("%P\n", p);
}
*ctxt->andptr++ = pre;
if(p->ft == 0)
- p->ft = oclass(&p->from);
+ p->ft = oclass(ctxt, &p->from);
if(p->tt == 0)
- p->tt = oclass(&p->to);
+ p->tt = oclass(ctxt, &p->to);
ft = p->ft * Ymax;
tt = p->tt * Ymax;
case Zlitm_r:
for(; op = o->op[z]; z++)
*ctxt->andptr++ = op;
- asmand(ctxt, p, &p->from, reg[p->to.type]);
+ asmand(ctxt, p, &p->from, reg[p->to.reg]);
break;
case Zm_r:
*ctxt->andptr++ = op;
- asmand(ctxt, p, &p->from, reg[p->to.type]);
+ asmand(ctxt, p, &p->from, reg[p->to.reg]);
break;
case Zm2_r:
*ctxt->andptr++ = op;
*ctxt->andptr++ = o->op[z+1];
- asmand(ctxt, p, &p->from, reg[p->to.type]);
+ asmand(ctxt, p, &p->from, reg[p->to.reg]);
break;
case Zm_r_xm:
mediaop(ctxt, o, op, t[3], z);
- asmand(ctxt, p, &p->from, reg[p->to.type]);
+ asmand(ctxt, p, &p->from, reg[p->to.reg]);
break;
case Zm_r_i_xm:
mediaop(ctxt, o, op, t[3], z);
- asmand(ctxt, p, &p->from, reg[p->to.type]);
+ asmand(ctxt, p, &p->from, reg[p->to.reg]);
*ctxt->andptr++ = p->to.offset;
break;
case Zibm_r:
while ((op = o->op[z++]) != 0)
*ctxt->andptr++ = op;
- asmand(ctxt, p, &p->from, reg[p->to.type]);
+ asmand(ctxt, p, &p->from, reg[p->to.reg]);
*ctxt->andptr++ = p->to.offset;
break;
case Zaut_r:
*ctxt->andptr++ = 0x8d; /* leal */
- if(p->from.type != D_ADDR)
+ if(p->from.type != TYPE_ADDR)
ctxt->diag("asmins: Zaut sb type ADDR");
- p->from.type = p->from.index;
- p->from.index = D_NONE;
+ p->from.type = TYPE_MEM;
p->ft = 0;
- asmand(ctxt, p, &p->from, reg[p->to.type]);
- p->from.index = p->from.type;
- p->from.type = D_ADDR;
+ asmand(ctxt, p, &p->from, reg[p->to.reg]);
+ p->from.type = TYPE_ADDR;
p->ft = 0;
break;
case Zr_m:
*ctxt->andptr++ = op;
- asmand(ctxt, p, &p->to, reg[p->from.type]);
+ asmand(ctxt, p, &p->to, reg[p->from.reg]);
break;
case Zr_m_xm:
mediaop(ctxt, o, op, t[3], z);
- asmand(ctxt, p, &p->to, reg[p->from.type]);
+ asmand(ctxt, p, &p->to, reg[p->from.reg]);
break;
case Zr_m_i_xm:
mediaop(ctxt, o, op, t[3], z);
- asmand(ctxt, p, &p->to, reg[p->from.type]);
+ asmand(ctxt, p, &p->to, reg[p->from.reg]);
*ctxt->andptr++ = p->from.offset;
break;
break;
case Zib_rp:
- *ctxt->andptr++ = op + reg[p->to.type];
+ *ctxt->andptr++ = op + reg[p->to.reg];
*ctxt->andptr++ = vaddr(ctxt, p, &p->from, nil);
break;
case Zil_rp:
- *ctxt->andptr++ = op + reg[p->to.type];
+ *ctxt->andptr++ = op + reg[p->to.reg];
if(o->prefix == Pe) {
v = vaddr(ctxt, p, &p->from, nil);
*ctxt->andptr++ = v;
case Zib_rr:
*ctxt->andptr++ = op;
- asmand(ctxt, p, &p->to, reg[p->to.type]);
+ asmand(ctxt, p, &p->to, reg[p->to.reg]);
*ctxt->andptr++ = vaddr(ctxt, p, &p->from, nil);
break;
case Zil_rr:
*ctxt->andptr++ = op;
- asmand(ctxt, p, &p->to, reg[p->to.type]);
+ asmand(ctxt, p, &p->to, reg[p->to.reg]);
if(o->prefix == Pe) {
v = vaddr(ctxt, p, &p->from, nil);
*ctxt->andptr++ = v;
break;
case Z_rp:
- *ctxt->andptr++ = op + reg[p->to.type];
+ *ctxt->andptr++ = op + reg[p->to.reg];
break;
case Zrp_:
- *ctxt->andptr++ = op + reg[p->from.type];
+ *ctxt->andptr++ = op + reg[p->from.reg];
break;
case Zclr:
*ctxt->andptr++ = op;
- asmand(ctxt, p, &p->to, reg[p->to.type]);
+ asmand(ctxt, p, &p->to, reg[p->to.reg]);
break;
case Zcall:
* instruction with the operands renamed.
*/
pp = *p;
- z = p->from.type;
- if(z >= D_BP && z <= D_DI) {
- if((breg = byteswapreg(ctxt, &p->to)) != D_AX) {
+ z = p->from.reg;
+ if(p->from.type == TYPE_REG && z >= REG_BP && z <= REG_DI) {
+ if((breg = byteswapreg(ctxt, &p->to)) != REG_AX) {
*ctxt->andptr++ = 0x87; /* xchg lhs,bx */
asmand(ctxt, p, &p->from, reg[breg]);
subreg(&pp, z, breg);
asmand(ctxt, p, &p->from, reg[breg]);
} else {
*ctxt->andptr++ = 0x90 + reg[z]; /* xchg lsh,ax */
- subreg(&pp, z, D_AX);
+ subreg(&pp, z, REG_AX);
doasm(ctxt, &pp);
*ctxt->andptr++ = 0x90 + reg[z]; /* xchg lsh,ax */
}
return;
}
- z = p->to.type;
- if(z >= D_BP && z <= D_DI) {
- if((breg = byteswapreg(ctxt, &p->from)) != D_AX) {
+ z = p->to.reg;
+ if(p->to.type == TYPE_REG && z >= REG_BP && z <= REG_DI) {
+ if((breg = byteswapreg(ctxt, &p->from)) != REG_AX) {
*ctxt->andptr++ = 0x87; /* xchg rhs,bx */
asmand(ctxt, p, &p->to, reg[breg]);
subreg(&pp, z, breg);
asmand(ctxt, p, &p->to, reg[breg]);
} else {
*ctxt->andptr++ = 0x90 + reg[z]; /* xchg rsh,ax */
- subreg(&pp, z, D_AX);
+ subreg(&pp, z, REG_AX);
doasm(ctxt, &pp);
*ctxt->andptr++ = 0x90 + reg[z]; /* xchg rsh,ax */
}
return;
}
- ctxt->diag("doasm: notfound t2=%ux from=%ux to=%ux %P", t[2], p->from.type, p->to.type, p);
+ ctxt->diag("doasm: notfound t2=%d from=%d to=%d %P", t[2], p->ft, p->tt, p);
return;
mfound:
switch(p->to.index) {
default:
goto bad;
- case D_DS:
+ case REG_DS:
*ctxt->andptr++ = 0xc5;
break;
- case D_SS:
+ case REG_SS:
*ctxt->andptr++ = 0x0f;
*ctxt->andptr++ = 0xb2;
break;
- case D_ES:
+ case REG_ES:
*ctxt->andptr++ = 0xc4;
break;
- case D_FS:
+ case REG_FS:
*ctxt->andptr++ = 0x0f;
*ctxt->andptr++ = 0xb4;
break;
- case D_GS:
+ case REG_GS:
*ctxt->andptr++ = 0x0f;
*ctxt->andptr++ = 0xb5;
break;
}
- asmand(ctxt, p, &p->from, reg[p->to.type]);
+ asmand(ctxt, p, &p->from, reg[p->to.reg]);
break;
case 6: /* double shift */
- z = p->from.type;
- switch(z) {
+ switch(p->from.type) {
default:
goto bad;
- case D_CONST:
+
+ case TYPE_CONST:
*ctxt->andptr++ = 0x0f;
*ctxt->andptr++ = t[4];
asmand(ctxt, p, &p->to, reg[p->from.index]);
*ctxt->andptr++ = p->from.offset;
break;
- case D_CL:
- case D_CX:
- *ctxt->andptr++ = 0x0f;
- *ctxt->andptr++ = t[5];
- asmand(ctxt, p, &p->to, reg[p->from.index]);
+
+ case TYPE_REG:
+ switch(p->from.reg) {
+ default:
+ goto bad;
+ case REG_CL:
+ case REG_CX:
+ *ctxt->andptr++ = 0x0f;
+ *ctxt->andptr++ = t[5];
+ asmand(ctxt, p, &p->to, reg[p->from.index]);
+ break;
+ }
break;
}
break;
} else
*ctxt->andptr++ = t[4];
*ctxt->andptr++ = t[5];
- asmand(ctxt, p, &p->from, reg[p->to.type]);
+ asmand(ctxt, p, &p->from, reg[p->to.reg]);
break;
case 8: /* mov tls, r */
case Hnacl:
// ELF TLS base is 0(GS).
pp.from = p->from;
- pp.from.type = D_INDIR+D_GS;
+ pp.from.type = TYPE_MEM;
+ pp.from.reg = REG_GS;
pp.from.offset = 0;
- pp.from.index = D_NONE;
+ pp.from.index = REG_NONE;
pp.from.scale = 0;
*ctxt->andptr++ = 0x65; // GS
*ctxt->andptr++ = 0x8B;
- asmand(ctxt, p, &pp.from, reg[p->to.type]);
+ asmand(ctxt, p, &pp.from, reg[p->to.reg]);
break;
case Hplan9:
if(ctxt->plan9privates == nil)
ctxt->plan9privates = linklookup(ctxt, "_privates", 0);
memset(&pp.from, 0, sizeof pp.from);
- pp.from.type = D_EXTERN;
+ pp.from.type = TYPE_MEM;
+ pp.from.name = NAME_EXTERN;
pp.from.sym = ctxt->plan9privates;
pp.from.offset = 0;
- pp.from.index = D_NONE;
+ pp.from.index = REG_NONE;
*ctxt->andptr++ = 0x8B;
- asmand(ctxt, p, &pp.from, reg[p->to.type]);
+ asmand(ctxt, p, &pp.from, reg[p->to.reg]);
break;
case Hwindows:
// Windows TLS base is always 0x14(FS).
pp.from = p->from;
- pp.from.type = D_INDIR+D_FS;
+ pp.from.type = TYPE_MEM;
+ pp.from.reg = REG_FS;
pp.from.offset = 0x14;
- pp.from.index = D_NONE;
+ pp.from.index = REG_NONE;
pp.from.scale = 0;
*ctxt->andptr++ = 0x64; // FS
*ctxt->andptr++ = 0x8B;
- asmand(ctxt, p, &pp.from, reg[p->to.type]);
+ asmand(ctxt, p, &pp.from, reg[p->to.reg]);
break;
}
break;
return;
case ACALL:
case AJMP:
- if(D_AX <= p->to.type && p->to.type <= D_DI) {
+ if(p->to.type == TYPE_REG && REG_AX <= p->to.reg && p->to.reg <= REG_DI) {
*ctxt->andptr++ = 0x83;
- *ctxt->andptr++ = 0xe0 | (p->to.type - D_AX);
+ *ctxt->andptr++ = 0xe0 | (p->to.reg - REG_AX);
*ctxt->andptr++ = 0xe0;
}
break;
{
char str[STRINGSZ], s[STRINGSZ];
Addr *a;
- int i;
a = va_arg(fp->args, Addr*);
- i = a->type;
-
- if(fp->flags & FmtLong) {
- if(i == D_CONST2)
- sprint(str, "$%lld-%d", a->offset, a->offset2);
- else {
- // ATEXT dst is not constant
- sprint(str, "!!%D", a);
- }
- goto brk;
- }
-
- if(i >= D_INDIR) {
- if(a->offset)
- sprint(str, "%lld(%R)", a->offset, i-D_INDIR);
- else
- sprint(str, "(%R)", i-D_INDIR);
- goto brk;
- }
- switch(i) {
+
+ switch(a->type) {
default:
- if(a->offset)
- sprint(str, "$%lld,%R", a->offset, i);
- else
- sprint(str, "%R", i);
+ sprint(str, "type=%d", a->type);
break;
- case D_NONE:
+ case TYPE_NONE:
str[0] = 0;
break;
+
+ case TYPE_REG:
+ // TODO(rsc): This special case is for instructions like
+ // PINSRQ CX,$1,X6
+ // where the $1 is included in the p->to Addr.
+ // Move into a new field.
+ if(a->offset != 0) {
+ sprint(str, "$%lld,%R", a->offset, a->reg);
+ break;
+ }
+ sprint(str, "%R", a->reg);
+ // TODO(rsc): This special case is for SHRQ $32, AX:DX, which encodes as
+ // SHRQ $32(DX*0), AX
+ // Remove.
+ if(a->index != REG_NONE) {
+ sprint(s, "(%R*%d)", (int)a->index, (int)a->scale);
+ strcat(str, s);
+ }
+ break;
- case D_BRANCH:
+ case TYPE_BRANCH:
if(a->sym != nil)
sprint(str, "%s(SB)", a->sym->name);
else if(bigP != nil && bigP->pcond != nil)
sprint(str, "%lld(PC)", a->offset);
break;
- case D_EXTERN:
- sprint(str, "%s+%lld(SB)", a->sym->name, a->offset);
- break;
-
- case D_STATIC:
- sprint(str, "%s<>+%lld(SB)", a->sym->name, a->offset);
- break;
-
- case D_AUTO:
- if(a->sym)
- sprint(str, "%s+%lld(SP)", a->sym->name, a->offset);
- else
- sprint(str, "%lld(SP)", a->offset);
- break;
-
- case D_PARAM:
- if(a->sym)
- sprint(str, "%s+%lld(FP)", a->sym->name, a->offset);
- else
- sprint(str, "%lld(FP)", a->offset);
+ case TYPE_MEM:
+ switch(a->name) {
+ default:
+ sprint(str, "name=%d", a->name);
+ break;
+ case NAME_NONE:
+ if(a->offset)
+ sprint(str, "%lld(%R)", a->offset, a->reg);
+ else
+ sprint(str, "(%R)", a->reg);
+ break;
+ case NAME_EXTERN:
+ sprint(str, "%s+%lld(SB)", a->sym->name, a->offset);
+ break;
+ case NAME_STATIC:
+ sprint(str, "%s<>+%lld(SB)", a->sym->name, a->offset);
+ break;
+ case NAME_AUTO:
+ if(a->sym)
+ sprint(str, "%s+%lld(SP)", a->sym->name, a->offset);
+ else
+ sprint(str, "%lld(SP)", a->offset);
+ break;
+ case NAME_PARAM:
+ if(a->sym)
+ sprint(str, "%s+%lld(FP)", a->sym->name, a->offset);
+ else
+ sprint(str, "%lld(FP)", a->offset);
+ break;
+ }
+ if(a->index != REG_NONE) {
+ sprint(s, "(%R*%d)", (int)a->index, (int)a->scale);
+ strcat(str, s);
+ }
break;
- case D_CONST:
+ case TYPE_CONST:
sprint(str, "$%lld", a->offset);
+ // TODO(rsc): This special case is for SHRQ $32, AX:DX, which encodes as
+ // SHRQ $32(DX*0), AX
+ // Remove.
+ if(a->index != REG_NONE) {
+ sprint(s, "(%R*%d)", (int)a->index, (int)a->scale);
+ strcat(str, s);
+ }
break;
- case D_CONST2:
- if(!(fp->flags & FmtLong)) {
- // D_CONST2 outside of ATEXT should not happen
- sprint(str, "!!$%lld-%d", a->offset, a->offset2);
- }
+ case TYPE_TEXTSIZE:
+ sprint(str, "$%lld-%d", a->offset, a->u.argsize);
break;
- case D_FCONST:
+ case TYPE_FCONST:
sprint(str, "$(%.17g)", a->u.dval);
break;
- case D_SCONST:
+ case TYPE_SCONST:
sprint(str, "$\"%$\"", a->u.sval);
break;
- case D_ADDR:
- a->type = a->index;
- a->index = D_NONE;
+ case TYPE_ADDR:
+ a->type = TYPE_MEM;
sprint(str, "$%D", a);
- a->index = a->type;
- a->type = D_ADDR;
- goto conv;
- }
-brk:
- if(a->index != D_NONE) {
- sprint(s, "(%R*%d)", (int)a->index, (int)a->scale);
- strcat(str, s);
+ a->type = TYPE_ADDR;
+ break;
}
-conv:
+
return fmtstrcpy(fp, str);
}
static char* regstr[] =
{
- "AL", /* [D_AL] */
+ "AL", /* [REG_AL] */
"CL",
"DL",
"BL",
"DH",
"BH",
- "AX", /* [D_AX] */
+ "AX", /* [REG_AX] */
"CX",
"DX",
"BX",
"SI",
"DI",
- "F0", /* [D_F0] */
+ "F0", /* [REG_F0] */
"F1",
"F2",
"F3",
"F6",
"F7",
- "CS", /* [D_CS] */
+ "CS", /* [REG_CS] */
"SS",
"DS",
"ES",
"FS",
"GS",
- "GDTR", /* [D_GDTR] */
- "IDTR", /* [D_IDTR] */
- "LDTR", /* [D_LDTR] */
- "MSW", /* [D_MSW] */
- "TASK", /* [D_TASK] */
+ "GDTR", /* [REG_GDTR] */
+ "IDTR", /* [REG_IDTR] */
+ "LDTR", /* [REG_LDTR] */
+ "MSW", /* [REG_MSW] */
+ "TASK", /* [REG_TASK] */
- "CR0", /* [D_CR] */
+ "CR0", /* [REG_CR] */
"CR1",
"CR2",
"CR3",
"CR6",
"CR7",
- "DR0", /* [D_DR] */
+ "DR0", /* [REG_DR] */
"DR1",
"DR2",
"DR3",
"DR6",
"DR7",
- "TR0", /* [D_TR] */
+ "TR0", /* [REG_TR] */
"TR1",
"TR2",
"TR3",
"TR6",
"TR7",
- "X0", /* [D_X0] */
+ "X0", /* [REG_X0] */
"X1",
"X2",
"X3",
"X6",
"X7",
- "TLS", /* [D_TLS] */
- "NONE", /* [D_NONE] */
+ "TLS", /* [REG_TLS] */
+ "MAXREG", /* [MAXREG] */
};
static int
int r;
r = va_arg(fp->args, int);
- if(r >= D_AL && r <= D_NONE)
- sprint(str, "%s", regstr[r-D_AL]);
+ if(r == REG_NONE)
+ return fmtstrcpy(fp, "NONE");
+ if(r >= REG_AL && r-REG_AL < nelem(regstr))
+ sprint(str, "%s", regstr[r-REG_AL]);
else
sprint(str, "gok(%d)", r);
.back = 2,
.as = AGOK,
.from = {
- .type = D_NONE,
- .index = D_NONE,
+ .type = TYPE_NONE,
+ .index = REG_NONE,
.scale = 1,
},
.to = {
- .type = D_NONE,
- .index = D_NONE,
+ .type = TYPE_NONE,
+ .index = REG_NONE,
.scale = 1,
},
};
-static int
-symtype(Addr *a)
-{
- int t;
-
- t = a->type;
- if(t == D_ADDR)
- t = a->index;
- return t;
-}
-
static int
isdata(Prog *p)
{
// become
// NOP
// ... off(TLS) ...
- if(p->as == AMOVL && p->from.type == D_TLS && D_AX <= p->to.type && p->to.type <= D_DI) {
+ if(p->as == AMOVL && p->from.type == TYPE_REG && p->from.reg == REG_TLS && p->to.type == TYPE_REG && REG_AX <= p->to.reg && p->to.reg <= REG_DI) {
p->as = ANOP;
- p->from.type = D_NONE;
- p->to.type = D_NONE;
+ p->from.type = TYPE_NONE;
+ p->to.type = TYPE_NONE;
}
- if(p->from.index == D_TLS && D_INDIR+D_AX <= p->from.type && p->from.type <= D_INDIR+D_DI) {
- p->from.type = D_INDIR+D_TLS;
+ if(p->from.type == TYPE_MEM && p->from.index == REG_TLS && REG_AX <= p->from.reg && p->from.reg <= REG_DI) {
+ p->from.type = TYPE_MEM;
+ p->from.reg = REG_TLS;
p->from.scale = 0;
- p->from.index = D_NONE;
+ p->from.index = REG_NONE;
}
- if(p->to.index == D_TLS && D_INDIR+D_AX <= p->to.type && p->to.type <= D_INDIR+D_DI) {
- p->to.type = D_INDIR+D_TLS;
+ if(p->to.type == TYPE_MEM && p->to.index == REG_TLS && REG_AX <= p->to.reg && p->to.reg <= REG_DI) {
+ p->to.type = TYPE_MEM;
+ p->to.reg = REG_TLS;
p->to.scale = 0;
- p->to.index = D_NONE;
+ p->to.index = REG_NONE;
}
} else {
// As a courtesy to the C compilers, rewrite TLS local exec load as TLS initial exec load.
// MOVL TLS, BX
// MOVL off(BX)(TLS*1), BX
// This allows the C compilers to emit references to m and g using the direct off(TLS) form.
- if(p->as == AMOVL && p->from.type == D_INDIR+D_TLS && D_AX <= p->to.type && p->to.type <= D_DI) {
+ if(p->as == AMOVL && p->from.type == TYPE_MEM && p->from.reg == REG_TLS && p->to.type == TYPE_REG && REG_AX <= p->to.reg && p->to.reg <= REG_DI) {
q = appendp(ctxt, p);
q->as = p->as;
- q->from = p->from;
- q->from.type = D_INDIR + p->to.type;
- q->from.index = D_TLS;
+ q->from.type = TYPE_MEM;
+ q->from.reg = p->to.reg;
+ q->from.index = REG_TLS;
q->from.scale = 2; // TODO: use 1
q->to = p->to;
- p->from.type = D_TLS;
- p->from.index = D_NONE;
+ p->from.type = TYPE_REG;
+ p->from.reg = REG_TLS;
+ p->from.index = REG_NONE;
p->from.offset = 0;
}
}
// TODO: Remove.
if(ctxt->headtype == Hplan9) {
- if(p->from.scale == 1 && p->from.index == D_TLS)
+ if(p->from.scale == 1 && p->from.index == REG_TLS)
p->from.scale = 2;
- if(p->to.scale == 1 && p->to.index == D_TLS)
+ if(p->to.scale == 1 && p->to.index == REG_TLS)
p->to.scale = 2;
}
- // Rewrite CALL/JMP/RET to symbol as D_BRANCH.
+ // Rewrite CALL/JMP/RET to symbol as TYPE_BRANCH.
switch(p->as) {
case ACALL:
case AJMP:
case ARET:
- if((p->to.type == D_EXTERN || p->to.type == D_STATIC) && p->to.sym != nil)
- p->to.type = D_BRANCH;
+ if(p->to.type == TYPE_MEM && (p->to.name == NAME_EXTERN || p->to.name == NAME_STATIC) && p->to.sym != nil)
+ p->to.type = TYPE_BRANCH;
break;
}
switch(p->as) {
case AMOVSS:
// Convert AMOVSS $(0), Xx to AXORPS Xx, Xx
- if(p->from.type == D_FCONST)
+ if(p->from.type == TYPE_FCONST)
if(p->from.u.dval == 0)
- if(p->to.type >= D_X0)
- if(p->to.type <= D_X7) {
+ if(p->to.type == TYPE_REG && REG_X0 <= p->to.reg && p->to.reg <= REG_X7) {
p->as = AXORPS;
- p->from.type = p->to.type;
- p->from.index = p->to.index;
+ p->from = p->to;
break;
}
// fallthrough
case ADIVSS:
case ACOMISS:
case AUCOMISS:
- if(p->from.type == D_FCONST) {
+ if(p->from.type == TYPE_FCONST) {
uint32 i32;
float32 f32;
f32 = p->from.u.dval;
adduint32(ctxt, s, i32);
s->reachable = 0;
}
- p->from.type = D_EXTERN;
+ p->from.type = TYPE_MEM;
+ p->from.name = NAME_EXTERN;
p->from.sym = s;
p->from.offset = 0;
}
case AMOVSD:
// Convert AMOVSD $(0), Xx to AXORPS Xx, Xx
- if(p->from.type == D_FCONST)
+ if(p->from.type == TYPE_FCONST)
if(p->from.u.dval == 0)
- if(p->to.type >= D_X0)
- if(p->to.type <= D_X7) {
+ if(p->to.type == TYPE_REG && REG_X0 <= p->to.reg && p->to.reg <= REG_X7) {
p->as = AXORPS;
- p->from.type = p->to.type;
- p->from.index = p->to.index;
+ p->from = p->to;
break;
}
// fallthrough
case ADIVSD:
case ACOMISD:
case AUCOMISD:
- if(p->from.type == D_FCONST) {
+ if(p->from.type == TYPE_FCONST) {
uint64 i64;
memmove(&i64, &p->from.u.dval, 8);
sprint(literal, "$f64.%016llux", i64);
adduint64(ctxt, s, i64);
s->reachable = 0;
}
- p->from.type = D_EXTERN;
+ p->from.type = TYPE_MEM;
+ p->from.name = NAME_EXTERN;
p->from.sym = s;
p->from.offset = 0;
}
static Prog* stacksplit(Link*, Prog*, int32, int, Prog**);
static void
-addstacksplit(Link *ctxt, LSym *cursym)
+preprocess(Link *ctxt, LSym *cursym)
{
Prog *p, *q, *p1, *p2;
int32 autoffset, deltasp;
autoffset = 0;
cursym->locals = autoffset;
- cursym->args = p->to.offset2;
+ cursym->args = p->to.u.argsize;
q = nil;
if(autoffset) {
p = appendp(ctxt, p);
p->as = AADJSP;
- p->from.type = D_CONST;
+ p->from.type = TYPE_CONST;
p->from.offset = autoffset;
p->spadj = autoffset;
} else {
p = appendp(ctxt, p);
p->as = AMOVL;
- p->from.type = D_INDIR+D_CX;
+ p->from.type = TYPE_MEM;
+ p->from.reg = REG_CX;
p->from.offset = 4*ctxt->arch->ptrsize; // G.panic
- p->to.type = D_BX;
+ p->to.type = TYPE_REG;
+ p->to.reg = REG_BX;
p = appendp(ctxt, p);
p->as = ATESTL;
- p->from.type = D_BX;
- p->to.type = D_BX;
+ p->from.type = TYPE_REG;
+ p->from.reg = REG_BX;
+ p->to.type = TYPE_REG;
+ p->to.reg = REG_BX;
p = appendp(ctxt, p);
p->as = AJEQ;
- p->to.type = D_BRANCH;
+ p->to.type = TYPE_BRANCH;
p1 = p;
p = appendp(ctxt, p);
p->as = ALEAL;
- p->from.type = D_INDIR+D_SP;
+ p->from.type = TYPE_MEM;
+ p->from.reg = REG_SP;
p->from.offset = autoffset+4;
- p->to.type = D_DI;
+ p->to.type = TYPE_REG;
+ p->to.reg = REG_DI;
p = appendp(ctxt, p);
p->as = ACMPL;
- p->from.type = D_INDIR+D_BX;
+ p->from.type = TYPE_MEM;
+ p->from.reg = REG_BX;
p->from.offset = 0; // Panic.argp
- p->to.type = D_DI;
+ p->to.type = TYPE_REG;
+ p->to.reg = REG_DI;
p = appendp(ctxt, p);
p->as = AJNE;
- p->to.type = D_BRANCH;
+ p->to.type = TYPE_BRANCH;
p2 = p;
p = appendp(ctxt, p);
p->as = AMOVL;
- p->from.type = D_SP;
- p->to.type = D_INDIR+D_BX;
+ p->from.type = TYPE_REG;
+ p->from.reg = REG_SP;
+ p->to.type = TYPE_MEM;
+ p->to.reg = REG_BX;
p->to.offset = 0; // Panic.argp
p = appendp(ctxt, p);
// false positives in garbage collection.
p = appendp(ctxt, p);
p->as = AMOVL;
- p->from.type = D_SP;
- p->to.type = D_DI;
+ p->from.type = TYPE_REG;
+ p->from.reg = REG_SP;
+ p->to.type = TYPE_REG;
+ p->to.reg = REG_DI;
p = appendp(ctxt, p);
p->as = AMOVL;
- p->from.type = D_CONST;
+ p->from.type = TYPE_CONST;
p->from.offset = autoffset/4;
- p->to.type = D_CX;
+ p->to.type = TYPE_REG;
+ p->to.reg = REG_CX;
p = appendp(ctxt, p);
p->as = AMOVL;
- p->from.type = D_CONST;
+ p->from.type = TYPE_CONST;
p->from.offset = 0;
- p->to.type = D_AX;
+ p->to.type = TYPE_REG;
+ p->to.reg = REG_AX;
p = appendp(ctxt, p);
p->as = AREP;
}
for(; p != nil; p = p->link) {
- a = p->from.type;
- if(a == D_AUTO)
+ a = p->from.name;
+ if(a == NAME_AUTO)
p->from.offset += deltasp;
- if(a == D_PARAM)
+ if(a == NAME_PARAM)
p->from.offset += deltasp + 4;
- a = p->to.type;
- if(a == D_AUTO)
+ a = p->to.name;
+ if(a == NAME_AUTO)
p->to.offset += deltasp;
- if(a == D_PARAM)
+ if(a == NAME_PARAM)
p->to.offset += deltasp + 4;
switch(p->as) {
if(autoffset) {
p->as = AADJSP;
- p->from.type = D_CONST;
+ p->from.type = TYPE_CONST;
p->from.offset = -autoffset;
p->spadj = -autoffset;
p = appendp(ctxt, p);
Prog *next;
p->as = AMOVL;
- p->from.type = D_INDIR+D_TLS;
+ p->from.type = TYPE_MEM;
+ p->from.reg = REG_TLS;
p->from.offset = 0;
- p->to.type = D_CX;
+ p->to.type = TYPE_REG;
+ p->to.reg = REG_CX;
next = p->link;
progedit(ctxt, p);
while(p->link != next)
p = p->link;
- if(p->from.index == D_TLS)
+ if(p->from.index == REG_TLS)
p->from.scale = 2;
return p;
// catches out-of-sync stack guard info.
p = appendp(ctxt, p);
p->as = ACMPL;
- p->from.type = D_INDIR+D_CX;
+ p->from.type = TYPE_MEM;
+ p->from.reg = REG_CX;
p->from.offset = 4;
- p->to.type = D_SP;
+ p->to.type = TYPE_REG;
+ p->to.reg = REG_SP;
p = appendp(ctxt, p);
p->as = AJCC;
- p->to.type = D_BRANCH;
+ p->to.type = TYPE_BRANCH;
p->to.offset = 4;
q1 = p;
p = appendp(ctxt, p);
p->as = AINT;
- p->from.type = D_CONST;
+ p->from.type = TYPE_CONST;
p->from.offset = 3;
p = appendp(ctxt, p);
// CMPL SP, stackguard
p = appendp(ctxt, p);
p->as = ACMPL;
- p->from.type = D_SP;
- p->to.type = D_INDIR+D_CX;
+ p->from.type = TYPE_REG;
+ p->from.reg = REG_SP;
+ p->to.type = TYPE_MEM;
+ p->to.reg = REG_CX;
p->to.offset = 2*ctxt->arch->ptrsize; // G.stackguard0
if(ctxt->cursym->cfunc)
p->to.offset = 3*ctxt->arch->ptrsize; // G.stackguard1
// CMPL AX, stackguard
p = appendp(ctxt, p);
p->as = ALEAL;
- p->from.type = D_INDIR+D_SP;
+ p->from.type = TYPE_MEM;
+ p->from.reg = REG_SP;
p->from.offset = -(framesize-StackSmall);
- p->to.type = D_AX;
+ p->to.type = TYPE_REG;
+ p->to.reg = REG_AX;
p = appendp(ctxt, p);
p->as = ACMPL;
- p->from.type = D_AX;
- p->to.type = D_INDIR+D_CX;
+ p->from.type = TYPE_REG;
+ p->from.reg = REG_AX;
+ p->to.type = TYPE_MEM;
+ p->to.reg = REG_CX;
p->to.offset = 2*ctxt->arch->ptrsize; // G.stackguard0
if(ctxt->cursym->cfunc)
p->to.offset = 3*ctxt->arch->ptrsize; // G.stackguard1
// CMPL AX, $(framesize+(StackGuard-StackSmall))
p = appendp(ctxt, p);
p->as = AMOVL;
- p->from.type = D_INDIR+D_CX;
+ p->from.type = TYPE_MEM;
+ p->from.reg = REG_CX;
p->from.offset = 0;
p->from.offset = 2*ctxt->arch->ptrsize; // G.stackguard0
if(ctxt->cursym->cfunc)
p->from.offset = 3*ctxt->arch->ptrsize; // G.stackguard1
- p->to.type = D_SI;
+ p->to.type = TYPE_REG;
+ p->to.reg = REG_SI;
p = appendp(ctxt, p);
p->as = ACMPL;
- p->from.type = D_SI;
- p->to.type = D_CONST;
+ p->from.type = TYPE_REG;
+ p->from.reg = REG_SI;
+ p->to.type = TYPE_CONST;
p->to.offset = (uint32)StackPreempt;
p = appendp(ctxt, p);
p->as = AJEQ;
- p->to.type = D_BRANCH;
+ p->to.type = TYPE_BRANCH;
q1 = p;
p = appendp(ctxt, p);
p->as = ALEAL;
- p->from.type = D_INDIR+D_SP;
+ p->from.type = TYPE_MEM;
+ p->from.reg = REG_SP;
p->from.offset = StackGuard;
- p->to.type = D_AX;
+ p->to.type = TYPE_REG;
+ p->to.reg = REG_AX;
p = appendp(ctxt, p);
p->as = ASUBL;
- p->from.type = D_SI;
+ p->from.type = TYPE_REG;
+ p->from.reg = REG_SI;
p->from.offset = 0;
- p->to.type = D_AX;
+ p->to.type = TYPE_REG;
+ p->to.reg = REG_AX;
p = appendp(ctxt, p);
p->as = ACMPL;
- p->from.type = D_AX;
- p->to.type = D_CONST;
+ p->from.type = TYPE_REG;
+ p->from.reg = REG_AX;
+ p->to.type = TYPE_CONST;
p->to.offset = framesize+(StackGuard-StackSmall);
}
// common
p = appendp(ctxt, p);
p->as = AJHI;
- p->to.type = D_BRANCH;
+ p->to.type = TYPE_BRANCH;
p->to.offset = 4;
q = p;
p = appendp(ctxt, p);
p->as = ACALL;
- p->to.type = D_BRANCH;
+ p->to.type = TYPE_BRANCH;
if(ctxt->cursym->cfunc)
p->to.sym = linklookup(ctxt, "runtime.morestackc", 0);
else
p = appendp(ctxt, p);
p->as = AJMP;
- p->to.type = D_BRANCH;
+ p->to.type = TYPE_BRANCH;
p->pcond = ctxt->cursym->text->link;
if(q != nil)
q = ctxt->arch->prg();
q->as = AJMP;
q->lineno = p->lineno;
- q->to.type = D_BRANCH;
+ q->to.type = TYPE_BRANCH;
q->to.offset = p->pc;
q->pcond = p;
p = q;
p->pcond = q;
if((q = brchain(ctxt, p->link)) != nil)
p->link = q;
- if(p->from.type == D_CONST) {
+ if(p->from.type == TYPE_CONST) {
if(p->from.offset == 1) {
/*
* expect conditional jump to be taken.
.thechar = '8',
.endian = LittleEndian,
- .addstacksplit = addstacksplit,
+ .preprocess = preprocess,
.assemble = span8,
.datasize = datasize,
.follow = follow,
.prg = prg,
.progedit = progedit,
.settextflag = settextflag,
- .symtype = symtype,
.textflag = textflag,
.minlc = 1,
.ptrsize = 4,
.regsize = 4,
- .D_ADDR = D_ADDR,
- .D_AUTO = D_AUTO,
- .D_BRANCH = D_BRANCH,
- .D_CONST = D_CONST,
- .D_EXTERN = D_EXTERN,
- .D_FCONST = D_FCONST,
- .D_NONE = D_NONE,
- .D_PARAM = D_PARAM,
- .D_SCONST = D_SCONST,
- .D_STATIC = D_STATIC,
-
.ACALL = ACALL,
.ADATA = ADATA,
.AEND = AEND,