Google Git
Sign in
go / go / f86c6f673e6de1fd57c8b0d79a833e0880a92aa3 / . / src / cmd / 6g / gsubr.c
blob: 7b534467cf1cea6b5385591c5f0ff7203a3d5832 [file] [log] [blame]
// Derived from Inferno utils/6c/txt.c
// http://code.google.com/p/inferno-os/source/browse/utils/6c/txt.c
//
// Copyright © 1994-1999 Lucent Technologies Inc. All rights reserved.
// Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
// Portions Copyright © 1997-1999 Vita Nuova Limited
// Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
// Portions Copyright © 2004,2006 Bruce Ellis
// Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
// Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
// Portions Copyright © 2009 The Go Authors. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include "gg.h"
void
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->loc = pcloc;
pcloc++;
}
Prog*
prog(int as)
{
Prog *p;
p = pc;
pc = mal(sizeof(*pc));
clearp(pc);
if(lineno == 0) {
if(debug['K'])
warn("prog: line 0");
}
p->as = as;
p->lineno = lineno;
p->link = pc;
return p;
}
Prog*
gbranch(int as, Type *t)
{
Prog *p;
p = prog(as);
p->to.type = D_BRANCH;
p->to.branch = P;
return p;
}
void
patch(Prog *p, Prog *to)
{
if(p->to.type != D_BRANCH)
fatal("patch: not a branch");
p->to.branch = to;
p->to.offset = to->loc;
}
Plist*
newplist(void)
{
Plist *pl;
pl = mal(sizeof(*pl));
if(plist == nil)
plist = pl;
else
plast->link = pl;
plast = pl;
pc = mal(sizeof(*pc));
clearp(pc);
pl->firstpc = pc;
return pl;
}
void
ginit(void)
{
int i;
for(i=0; i<nelem(reg); i++)
reg[i] = 1;
for(i=D_AX; i<=D_R15; i++)
reg[i] = 0;
for(i=D_X0; i<=D_X7; i++)
reg[i] = 0;
reg[D_SP]++;
}
void
gclean(void)
{
int i;
reg[D_SP]--;
for(i=D_AX; i<=D_R15; i++)
if(reg[i])
yyerror("reg %R left allocated\n", i);
for(i=D_X0; i<=D_X7; i++)
if(reg[i])
yyerror("reg %R left allocated\n", i);
}
void
regalloc(Node *n, Type *t, Node *o)
{
int i;
if(t == T)
fatal("regalloc: t nil");
switch(t->etype) {
case TINT8:
case TUINT8:
case TINT16:
case TUINT16:
case TINT32:
case TUINT32:
case TINT64:
case TUINT64:
case TPTR32:
case TPTR64:
case TBOOL:
if(o != N && o->op == OREGISTER) {
i = o->val.vval;
if(i >= D_AX && i <= D_R15)
goto out;
}
for(i=D_AX; i<=D_R15; i++)
if(reg[i] == 0)
goto out;
yyerror("out of fixed registers");
goto err;
case TFLOAT32:
case TFLOAT64:
case TFLOAT80:
if(o != N && o->op == OREGISTER) {
i = o->val.vval;
if(i >= D_X0 && i <= D_X7)
goto out;
}
for(i=D_X0; i<=D_X7; i++)
if(reg[i] == 0)
goto out;
yyerror("out of floating registers");
goto err;
}
yyerror("regalloc: unknown type %T", t);
err:
nodreg(n, t, 0);
return;
out:
reg[i]++;
nodreg(n, t, i);
}
void
regfree(Node *n)
{
int i;
if(n->op != OREGISTER && n->op != OINDREG)
fatal("regfree: not a register");
i = n->val.vval;
if(i < 0 || i >= sizeof(reg))
fatal("regfree: reg out of range");
if(reg[i] <= 0)
fatal("regfree: reg not allocated");
reg[i]--;
}
void
regret(Node *n, Type *t)
{
if(t == T)
fatal("regret: t nil");
fatal("regret");
}
void
nodreg(Node *n, Type *t, int r)
{
if(t == T)
fatal("nodreg: t nil");
memset(n, 0, sizeof(*n));
n->op = OREGISTER;
n->addable = 1;
ullmancalc(n);
n->val.vval = r;
n->type = t;
}
void
nodindreg(Node *n, Type *t, int r)
{
nodreg(n, t, r);
n->op = OINDREG;
}
Node*
nodarg(Type *t, int fp)
{
Node *n;
if(t->etype != TFIELD)
fatal("nodarg: not field %T", t);
n = nod(ONAME, N, N);
n->type = t->type;
n->sym = t->sym;
n->xoffset = t->width;
n->addable = 1;
switch(fp) {
case 0: // output arg
n->op = OINDREG;
n->val.vval = D_SP;
break;
case 1: // input arg
n->class = PPARAM;
break;
case 2: // offset output arg
fatal("shpuldnt be used");
n->op = OINDREG;
n->val.vval = D_SP;
n->xoffset += types[tptr]->width;
break;
}
return n;
}
void
nodconst(Node *n, Type *t, vlong v)
{
memset(n, 0, sizeof(*n));
n->op = OLITERAL;
n->addable = 1;
ullmancalc(n);
n->val.vval = v;
n->val.ctype = CTINT;
n->type = t;
switch(t->etype) {
case TFLOAT32:
case TFLOAT64:
case TFLOAT80:
fatal("nodconst: bad type %T", t);
case TPTR32:
case TPTR64:
case TUINT8:
case TUINT16:
case TUINT32:
case TUINT64:
n->val.ctype = CTUINT;
break;
}
}
Sym*
signame(Type *t)
{
Sym *s;
char *e;
loop:
if(t == T)
fatal("signame: nil type");
switch(t->etype) {
default:
fatal("signame: unknown type %T", t);
case TPTR32:
case TPTR64:
t = t->type;
goto loop;
case TSTRUCT:
e = "sigs";
break;
case TINTER:
e = "sigi";
break;
}
s = t->sym;
if(s == S)
fatal("nodtypesig: no sym for type");
snprint(namebuf, sizeof(namebuf), "%s_%s", e, s->name);
s = pkglookup(namebuf, s->package);
return s;
}
void
nodtypesig(Node *n, Type *t)
{
memset(n, 0, sizeof(*n));
n->op = ONAME;
n->type = types[TUINT8];
n->etype = TUINT8;
n->xoffset = 0;
n->sym = signame(t);
n->class = PEXTERN;
n->addable = 1;
n->ullman = 0;
}
void
gconreg(int as, vlong c, int reg)
{
Node n1, n2;
nodconst(&n1, types[TINT64], c);
nodreg(&n2, types[TINT64], reg);
gins(as, &n1, &n2);
}
#define CASE(a,b) (((a)<<16)|((b)<<0))
void
gmove(Node *f, Node *t)
{
int ft, tt, t64, a;
Node nod, nod1, nod2, nod3, nodc;
Prog *p1, *p2;
ft = f->type->etype;
tt = t->type->etype;
t64 = 0;
if(tt == TINT64 || tt == TUINT64 || tt == TPTR64)
t64 = 1;
if(debug['M'])
print("gop: %O %O[%E],%O[%E]\n", OAS,
f->op, ft, t->op, tt);
if(isfloat[ft] && f->op == OCONST) {
/* TO DO: pick up special constants, possibly preloaded */
if(f->val.dval == 0.0){
regalloc(&nod, t->type, t);
gins(AXORPD, &nod, &nod);
gmove(&nod, t);
regfree(&nod);
return;
}
}
/*
* load
*/
if(f->op == ONAME || f->op == OINDREG ||
f->op == OIND || f->op == OINDEX)
switch(ft) {
case TINT8:
a = AMOVBLSX;
if(t64)
a = AMOVBQSX;
goto ld;
case TBOOL:
case TUINT8:
a = AMOVBLZX;
if(t64)
a = AMOVBQZX;
goto ld;
case TINT16:
a = AMOVWLSX;
if(t64)
a = AMOVWQSX;
goto ld;
case TUINT16:
a = AMOVWLZX;
if(t64)
a = AMOVWQZX;
goto ld;
case TINT32:
if(isfloat[tt]) {
regalloc(&nod, t->type, t);
if(tt == TFLOAT64)
a = ACVTSL2SD;
else
a = ACVTSL2SS;
gins(a, f, &nod);
gmove(&nod, t);
regfree(&nod);
return;
}
a = AMOVL;
if(t64)
a = AMOVLQSX;
goto ld;
case TUINT32:
case TPTR32:
a = AMOVL;
if(t64)
a = AMOVLQZX; /* could probably use plain MOVL */
goto ld;
case TINT64:
if(isfloat[tt]) {
regalloc(&nod, t->type, t);
if(tt == TFLOAT64)
a = ACVTSQ2SD;
else
a = ACVTSQ2SS;
gins(a, f, &nod);
gmove(&nod, t);
regfree(&nod);
return;
}
case TUINT64:
case TPTR64:
a = AMOVQ;
ld:
regalloc(&nod, f->type, t);
nod.type = t64? types[TINT64]: types[TINT32];
gins(a, f, &nod);
gmove(&nod, t);
regfree(&nod);
return;
case TFLOAT32:
a = AMOVSS;
goto fld;
case TFLOAT64:
a = AMOVSD;
fld:
regalloc(&nod, f->type, t);
if(tt != TFLOAT64 && tt != TFLOAT32){ /* TO DO: why is this here */
dump("odd tree", f);
nod.type = t64? types[TINT64]: types[TINT32];
}
gins(a, f, &nod);
gmove(&nod, t);
regfree(&nod);
return;
}
/*
* store
*/
if(t->op == ONAME || t->op == OINDREG ||
t->op == OIND || t->op == OINDEX)
switch(tt) {
case TBOOL:
case TINT8:
case TUINT8:
a = AMOVB;
goto st;
case TINT16:
case TUINT16:
a = AMOVW;
goto st;
case TINT32:
case TUINT32:
case TPTR32:
a = AMOVL;
goto st;
case TINT64:
case TUINT64:
case TPTR64:
a = AMOVQ;
goto st;
st:
if(f->op == OCONST) {
gins(a, f, t);
return;
}
fst:
regalloc(&nod, t->type, f);
gmove(f, &nod);
gins(a, &nod, t);
regfree(&nod);
return;
case TFLOAT32:
a = AMOVSS;
goto fst;
case TFLOAT64:
a = AMOVSD;
goto fst;
}
/*
* convert
*/
switch(CASE(ft, tt)) {
default:
/*
* integer to integer
********
a = AGOK; break;
case CASE(TBOOL, TBOOL):
case CASE(TINT8, TBOOL):
case CASE(TUINT8, TBOOL):
case CASE(TINT16, TBOOL):
case CASE(TUINT16, TBOOL):
case CASE(TINT32, TBOOL):
case CASE(TUINT32, TBOOL):
case CASE(TPTR64, TBOOL):
case CASE(TBOOL, TINT8):
case CASE(TINT8, TINT8):
case CASE(TUINT8, TINT8):
case CASE(TINT16, TINT8):
case CASE(TUINT16, TINT8):
case CASE(TINT32, TINT8):
case CASE(TUINT32, TINT8):
case CASE(TPTR64, TINT8):
case CASE(TBOOL, TUINT8):
case CASE(TINT8, TUINT8):
case CASE(TUINT8, TUINT8):
case CASE(TINT16, TUINT8):
case CASE(TUINT16, TUINT8):
case CASE(TINT32, TUINT8):
case CASE(TUINT32, TUINT8):
case CASE(TPTR64, TUINT8):
case CASE(TINT16, TINT16):
case CASE(TUINT16, TINT16):
case CASE(TINT32, TINT16):
case CASE(TUINT32, TINT16):
case CASE(TPTR64, TINT16):
case CASE(TINT16, TUINT16):
case CASE(TUINT16, TUINT16):
case CASE(TINT32, TUINT16):
case CASE(TUINT32, TUINT16):
case CASE(TPTR64, TUINT16):
case CASE(TINT64, TUINT):
case CASE(TINT64, TUINT32):
case CASE(TUINT64, TUINT32):
*****/
a = AMOVL;
break;
case CASE(TINT64, TINT8):
case CASE(TINT64, TINT16):
case CASE(TINT64, TINT32):
case CASE(TUINT64, TINT8):
case CASE(TUINT64, TINT16):
case CASE(TUINT64, TINT32):
case CASE(TINT32, TINT64):
case CASE(TINT32, TPTR64):
a = AMOVLQSX;
if(f->op == OCONST) {
f->val.vval &= (uvlong)0xffffffffU;
if(f->val.vval & 0x80000000)
f->val.vval |= (vlong)0xffffffff << 32;
a = AMOVQ;
}
break;
case CASE(TUINT32, TINT64):
case CASE(TUINT32, TUINT64):
case CASE(TUINT32, TPTR64):
a = AMOVL; /* same effect as AMOVLQZX */
if(f->op == OCONST) {
f->val.vval &= (uvlong)0xffffffffU;
a = AMOVQ;
}
break;
case CASE(TPTR64, TINT64):
case CASE(TINT64, TINT64):
case CASE(TUINT64, TINT64):
case CASE(TINT64, TUINT64):
case CASE(TUINT64, TUINT64):
case CASE(TPTR64, TUINT64):
case CASE(TINT64, TPTR64):
case CASE(TUINT64, TPTR64):
case CASE(TPTR64, TPTR64):
a = AMOVQ;
break;
case CASE(TINT16, TINT32):
case CASE(TINT16, TUINT32):
a = AMOVWLSX;
if(f->op == OCONST) {
f->val.vval &= 0xffff;
if(f->val.vval & 0x8000)
f->val.vval |= 0xffff0000;
a = AMOVL;
}
break;
case CASE(TINT16, TINT64):
case CASE(TINT16, TUINT64):
case CASE(TINT16, TPTR64):
a = AMOVWQSX;
if(f->op == OCONST) {
f->val.vval &= 0xffff;
if(f->val.vval & 0x8000){
f->val.vval |= 0xffff0000;
f->val.vval |= (vlong)~0 << 32;
}
a = AMOVL;
}
break;
case CASE(TUINT16, TINT32):
case CASE(TUINT16, TUINT32):
a = AMOVWLZX;
if(f->op == OCONST) {
f->val.vval &= 0xffff;
a = AMOVL;
}
break;
case CASE(TUINT16, TINT64):
case CASE(TUINT16, TUINT64):
case CASE(TUINT16, TPTR64):
a = AMOVWQZX;
if(f->op == OCONST) {
f->val.vval &= 0xffff;
a = AMOVL; /* MOVL also zero-extends to 64 bits */
}
break;
case CASE(TINT8, TINT16):
case CASE(TINT8, TUINT16):
case CASE(TINT8, TINT32):
case CASE(TINT8, TUINT32):
a = AMOVBLSX;
if(f->op == OCONST) {
f->val.vval &= 0xff;
if(f->val.vval & 0x80)
f->val.vval |= 0xffffff00;
a = AMOVL;
}
break;
case CASE(TINT8, TINT64):
case CASE(TINT8, TUINT64):
case CASE(TINT8, TPTR64):
a = AMOVBQSX;
if(f->op == OCONST) {
f->val.vval &= 0xff;
if(f->val.vval & 0x80){
f->val.vval |= 0xffffff00;
f->val.vval |= (vlong)~0 << 32;
}
a = AMOVQ;
}
break;
case CASE(TBOOL, TINT16):
case CASE(TBOOL, TUINT16):
case CASE(TBOOL, TINT32):
case CASE(TBOOL, TUINT32):
case CASE(TUINT8, TINT16):
case CASE(TUINT8, TUINT16):
case CASE(TUINT8, TINT32):
case CASE(TUINT8, TUINT32):
a = AMOVBLZX;
if(f->op == OCONST) {
f->val.vval &= 0xff;
a = AMOVL;
}
break;
case CASE(TBOOL, TINT64):
case CASE(TBOOL, TUINT64):
case CASE(TBOOL, TPTR64):
case CASE(TUINT8, TINT64):
case CASE(TUINT8, TUINT64):
case CASE(TUINT8, TPTR64):
a = AMOVBQZX;
if(f->op == OCONST) {
f->val.vval &= 0xff;
a = AMOVL; /* zero-extends to 64-bits */
}
break;
/*
* float to fix
*/
case CASE(TFLOAT32, TINT8):
case CASE(TFLOAT32, TINT16):
case CASE(TFLOAT32, TINT32):
regalloc(&nod, t->type, N);
gins(ACVTTSS2SL, f, &nod);
gmove(&nod, t);
regfree(&nod);
return;
case CASE(TFLOAT32, TBOOL):
case CASE(TFLOAT32, TUINT8):
case CASE(TFLOAT32, TUINT16):
case CASE(TFLOAT32, TUINT32):
case CASE(TFLOAT32, TINT64):
case CASE(TFLOAT32, TUINT64):
case CASE(TFLOAT32, TPTR64):
regalloc(&nod, t->type, N);
gins(ACVTTSS2SQ, f, &nod);
gmove(&nod, t);
regfree(&nod);
return;
case CASE(TFLOAT64, TINT8):
case CASE(TFLOAT64, TINT16):
case CASE(TFLOAT64, TINT32):
regalloc(&nod, t->type, N);
gins(ACVTTSD2SL, f, &nod);
gmove(&nod, t);
regfree(&nod);
return;
case CASE(TFLOAT64, TBOOL):
case CASE(TFLOAT64, TUINT8):
case CASE(TFLOAT64, TUINT16):
case CASE(TFLOAT64, TUINT32):
case CASE(TFLOAT64, TINT64):
case CASE(TFLOAT64, TUINT64):
case CASE(TFLOAT64, TPTR64):
regalloc(&nod, t->type, N);
gins(ACVTTSD2SQ, f, &nod);
gmove(&nod, t);
regfree(&nod);
return;
/*
* ulong to float
*/
case CASE(TUINT64, TFLOAT64):
case CASE(TUINT64, TFLOAT32):
a = ACVTSQ2SS;
if(tt == TFLOAT64)
a = ACVTSQ2SD;
regalloc(&nod, f->type, f);
gmove(f, &nod);
regalloc(&nod1, t->type, t);
nodconst(&nodc, types[TUINT64], 0);
gins(ACMPQ, &nod, &nodc);
p1 = pc;
gins(AJLT, N, N);
gins(a, &nod, &nod1);
p2 = pc;
gins(AJMP, N, N);
patch(p1, pc);
regalloc(&nod2, f->type, N);
regalloc(&nod3, f->type, N);
gmove(&nod, &nod2);
nodconst(&nodc, types[TUINT64], 1);
gins(ASHRQ, &nodc, &nod2);
gmove(&nod, &nod3);
gins(AANDL, &nodc, &nod3);
gins(AORQ, &nod3, &nod2);
gins(a, &nod2, &nod1);
gins(tt == TFLOAT64? AADDSD: AADDSS, &nod1, &nod1);
regfree(&nod2);
regfree(&nod3);
patch(p2, pc);
regfree(&nod);
regfree(&nod1);
return;
case CASE(TUINT32, TFLOAT64):
case CASE(TUINT32, TFLOAT32):
a = ACVTSQ2SS;
if(tt == TFLOAT64)
a = ACVTSQ2SD;
regalloc(&nod, f->type, f);
gins(AMOVLQZX, f, &nod);
regalloc(&nod1, t->type, t);
gins(a, &nod, &nod1);
gmove(&nod1, t);
regfree(&nod);
regfree(&nod1);
return;
/*
* fix to float
*/
case CASE(TINT64, TFLOAT32):
case CASE(TPTR64, TFLOAT32):
regalloc(&nod, t->type, t);
gins(ACVTSQ2SS, f, &nod);
gmove(&nod, t);
regfree(&nod);
return;
case CASE(TINT64, TFLOAT64):
case CASE(TPTR64, TFLOAT64):
regalloc(&nod, t->type, t);
gins(ACVTSQ2SD, f, &nod);
gmove(&nod, t);
regfree(&nod);
return;
case CASE(TBOOL, TFLOAT32):
case CASE(TINT8, TFLOAT32):
case CASE(TUINT8, TFLOAT32):
case CASE(TINT16, TFLOAT32):
case CASE(TUINT16, TFLOAT32):
case CASE(TINT32, TFLOAT32):
regalloc(&nod, t->type, t);
gins(ACVTSL2SS, f, &nod);
gmove(&nod, t);
regfree(&nod);
return;
case CASE(TBOOL, TFLOAT64):
case CASE(TINT8, TFLOAT64):
case CASE(TUINT8, TFLOAT64):
case CASE(TINT16, TFLOAT64):
case CASE(TUINT16, TFLOAT64):
case CASE(TINT32, TFLOAT64):
regalloc(&nod, t->type, t);
gins(ACVTSL2SD, f, &nod);
gmove(&nod, t);
regfree(&nod);
return;
/*
* float to float
*/
case CASE(TFLOAT32, TFLOAT32):
a = AMOVSS;
break;
case CASE(TFLOAT64, TFLOAT32):
a = ACVTSD2SS;
break;
case CASE(TFLOAT32, TFLOAT64):
a = ACVTSS2SD;
break;
case CASE(TFLOAT64, TFLOAT64):
a = AMOVSD;
break;
}
if(a == AMOVQ ||
a == AMOVSD ||
a == AMOVSS ||
a == AMOVL && f->type->width == t->type->width) /* TO DO: check AMOVL */
if(samaddr(f, t))
return;
gins(a, f, t);
}
void
buildtxt(void)
{
Type t1, t2;
int i, j, a;
memset(&t1, 0, sizeof(t1));
memset(&t2, 0, sizeof(t2));
for(i=0; i<NTYPE; i++)
for(j=0; j<NTYPE; j++) {
a = AGOK;
txt[i*NTYPE+j] = a;
t1.etype = i;
t2.etype = j;
if(isint[i] || isptr[i] || i==TBOOL) {
if(isint[j] || isptr[j] || j==TBOOL) {
dowidth(&t1);
dowidth(&t2);
if(t1.width >= t2.width) {
a = AMOVL;
if(t1.width >= 8)
a = AMOVQ;
txt[i*NTYPE+j] = a;
continue;
}
switch(i) {
case TINT8:
a = AMOVBLSX;
if(t1.width >= 8)
a = AMOVBQSX;
break;
case TINT16:
a = AMOVWLSX;
if(t1.width >= 8)
a = AMOVWQSX;
break;
case TINT32:
a = AMOVLQSX;
break;
case TBOOL:
case TUINT8:
a = AMOVBLZX;
if(t1.width >= 8)
a = AMOVBQZX;
break;
case TUINT16:
a = AMOVWLZX;
if(t1.width >= 8)
a = AMOVLQZX;
break;
case TPTR32:
case TUINT32:
a = AMOVWQZX;
break;
}
txt[i*NTYPE+j] = a;
continue;
}
if(isfloat[j]) {
}
}
if(isint[j] || isptr[j] || j==TBOOL) {
if(isfloat[i]) {
}
}
}
}
void
regsalloc(Node *f, Type *t)
{
fatal("regsalloc");
}
int
samaddr(Node *f, Node *t)
{
if(f->op != t->op)
return 0;
switch(f->op) {
case OREGISTER:
if(f->val.vval != t->val.vval)
break;
return 1;
}
return 0;
}
Prog*
gins(int as, Node *f, Node *t)
{
// Node nod;
// long v;
Prog *p;
// if(f != N && f->op == OINDEX) {
// regalloc(&nod, &regnode, Z);
// v = constnode.vconst;
// cgen(f->right, &nod);
// constnode.vconst = v;
// idx.reg = nod.reg;
// regfree(&nod);
// }
// if(t != N && t->op == OINDEX) {
// regalloc(&nod, &regnode, Z);
// v = constnode.vconst;
// cgen(t->right, &nod);
// constnode.vconst = v;
// idx.reg = nod.reg;
// regfree(&nod);
// }
p = prog(as);
if(f != N)
naddr(f, &p->from);
if(t != N)
naddr(t, &p->to);
if(debug['g'])
print("%P\n", p);
return p;
}
void
naddr(Node *n, Addr *a)
{
a->type = D_NONE;
if(n == N)
return;
switch(n->op) {
default:
fatal("naddr: bad %O %D", n->op, a);
break;
case OREGISTER:
a->type = n->val.vval;
a->sym = S;
break;
// case OINDEX:
// case OIND:
// naddr(n->left, a);
// if(a->type >= D_AX && a->type <= D_DI)
// a->type += D_INDIR;
// else
// if(a->type == D_CONST)
// a->type = D_NONE+D_INDIR;
// else
// if(a->type == D_ADDR) {
// a->type = a->index;
// a->index = D_NONE;
// } else
// goto bad;
// if(n->op == OINDEX) {
// a->index = idx.reg;
// a->scale = n->scale;
// }
// break;
case OINDREG:
a->type = n->val.vval+D_INDIR;
a->sym = n->sym;
a->offset = n->xoffset;
break;
case ONAME:
a->etype = n->etype;
a->offset = n->xoffset;
a->sym = n->sym;
if(a->sym == S)
a->sym = lookup(".noname");
if(n->method) {
if(n->type != T)
if(n->type->sym != S)
if(n->type->sym->opackage != nil)
a->sym = pkglookup(a->sym->name, n->type->sym->opackage);
}
switch(n->class) {
default:
fatal("naddr: ONAME class %S %d\n", n->sym, n->class);
case PEXTERN:
a->type = D_EXTERN;
break;
case PAUTO:
a->type = D_AUTO;
break;
case PPARAM:
a->type = D_PARAM;
break;
case PSTATIC:
a->type = D_STATIC;
break;
}
break;
case OLITERAL:
if(isfloat[n->type->etype]) {
a->type = D_FCONST;
a->dval = n->val.dval;
break;
}
if(isptrto(n->type, TSTRING)) {
a->etype = n->etype;
a->sym = symstringo;
a->type = D_ADDR;
a->index = D_STATIC;
a->offset = symstringo->offset;
stringpool(n);
break;
}
if(isint[n->type->etype] ||
isptr[n->type->etype] ||
n->type->etype == TBOOL) {
a->sym = S;
a->type = D_CONST;
a->offset = n->val.vval;
break;
}
fatal("naddr: const %lT", n->type);
break;
case OADDR:
naddr(n->left, a);
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");
// case OADD:
// if(n->right->op == OLITERAL) {
// v = n->right->vconst;
// naddr(n->left, a);
// } else
// if(n->left->op == OLITERAL) {
// v = n->left->vconst;
// naddr(n->right, a);
// } else
// goto bad;
// a->offset += v;
// break;
}
}
int
optoas(int op, Type *t)
{
int a;
if(t == T)
fatal("optoas: t is nil");
a = AGOK;
switch(CASE(op, t->etype)) {
default:
fatal("optoas: no entry %O-%T", op, t);
break;
case CASE(OADDR, TPTR32):
a = ALEAL;
break;
case CASE(OADDR, TPTR64):
a = ALEAQ;
break;
case CASE(OEQ, TBOOL):
case CASE(OEQ, TINT8):
case CASE(OEQ, TUINT8):
case CASE(OEQ, TINT16):
case CASE(OEQ, TUINT16):
case CASE(OEQ, TINT32):
case CASE(OEQ, TUINT32):
case CASE(OEQ, TINT64):
case CASE(OEQ, TUINT64):
case CASE(OEQ, TPTR32):
case CASE(OEQ, TPTR64):
case CASE(OEQ, TFLOAT32):
case CASE(OEQ, TFLOAT64):
a = AJEQ;
break;
case CASE(ONE, TBOOL):
case CASE(ONE, TINT8):
case CASE(ONE, TUINT8):
case CASE(ONE, TINT16):
case CASE(ONE, TUINT16):
case CASE(ONE, TINT32):
case CASE(ONE, TUINT32):
case CASE(ONE, TINT64):
case CASE(ONE, TUINT64):
case CASE(ONE, TPTR32):
case CASE(ONE, TPTR64):
case CASE(ONE, TFLOAT32):
case CASE(ONE, TFLOAT64):
a = AJNE;
break;
case CASE(OLT, TINT8):
case CASE(OLT, TINT16):
case CASE(OLT, TINT32):
case CASE(OLT, TINT64):
a = AJLT;
break;
case CASE(OLT, TUINT8):
case CASE(OLT, TUINT16):
case CASE(OLT, TUINT32):
case CASE(OLT, TUINT64):
case CASE(OGE, TFLOAT32):
case CASE(OGE, TFLOAT64):
a = AJCS;
break;
case CASE(OLE, TINT8):
case CASE(OLE, TINT16):
case CASE(OLE, TINT32):
case CASE(OLE, TINT64):
a = AJLE;
break;
case CASE(OLE, TUINT8):
case CASE(OLE, TUINT16):
case CASE(OLE, TUINT32):
case CASE(OLE, TUINT64):
case CASE(OGT, TFLOAT32):
case CASE(OGT, TFLOAT64):
a = AJLS;
break;
case CASE(OGT, TINT8):
case CASE(OGT, TINT16):
case CASE(OGT, TINT32):
case CASE(OGT, TINT64):
a = AJGT;
break;
case CASE(OGT, TUINT8):
case CASE(OGT, TUINT16):
case CASE(OGT, TUINT32):
case CASE(OGT, TUINT64):
case CASE(OLE, TFLOAT32):
case CASE(OLE, TFLOAT64):
a = AJHI;
break;
case CASE(OGE, TINT8):
case CASE(OGE, TINT16):
case CASE(OGE, TINT32):
case CASE(OGE, TINT64):
a = AJGE;
break;
case CASE(OGE, TUINT8):
case CASE(OGE, TUINT16):
case CASE(OGE, TUINT32):
case CASE(OGE, TUINT64):
case CASE(OLT, TFLOAT32):
case CASE(OLT, TFLOAT64):
a = AJCC;
break;
case CASE(OCMP, TBOOL):
case CASE(OCMP, TINT8):
case CASE(OCMP, TUINT8):
a = ACMPB;
break;
case CASE(OCMP, TINT16):
case CASE(OCMP, TUINT16):
a = ACMPW;
break;
case CASE(OCMP, TINT32):
case CASE(OCMP, TUINT32):
case CASE(OCMP, TPTR32):
a = ACMPL;
break;
case CASE(OCMP, TINT64):
case CASE(OCMP, TUINT64):
case CASE(OCMP, TPTR64):
a = ACMPQ;
break;
case CASE(OCMP, TFLOAT32):
a = AUCOMISS;
break;
case CASE(OCMP, TFLOAT64):
a = AUCOMISD;
break;
case CASE(OADD, TINT8):
case CASE(OADD, TUINT8):
a = AADDB;
break;
case CASE(OADD, TINT16):
case CASE(OADD, TUINT16):
a = AADDW;
break;
case CASE(OADD, TINT32):
case CASE(OADD, TUINT32):
case CASE(OADD, TPTR32):
a = AADDL;
break;
case CASE(OADD, TINT64):
case CASE(OADD, TUINT64):
case CASE(OADD, TPTR64):
a = AADDQ;
break;
case CASE(OADD, TFLOAT32):
a = AADDSS;
break;
case CASE(OADD, TFLOAT64):
a = AADDSD;
break;
case CASE(OSUB, TINT8):
case CASE(OSUB, TUINT8):
a = ASUBB;
break;
case CASE(OSUB, TINT16):
case CASE(OSUB, TUINT16):
a = ASUBW;
break;
case CASE(OSUB, TINT32):
case CASE(OSUB, TUINT32):
case CASE(OSUB, TPTR32):
a = ASUBL;
break;
case CASE(OSUB, TINT64):
case CASE(OSUB, TUINT64):
case CASE(OSUB, TPTR64):
a = ASUBQ;
break;
case CASE(OSUB, TFLOAT32):
a = ASUBSS;
break;
case CASE(OSUB, TFLOAT64):
a = ASUBSD;
break;
case CASE(OMINUS, TINT8):
case CASE(OMINUS, TUINT8):
a = ANEGB;
break;
case CASE(OMINUS, TINT16):
case CASE(OMINUS, TUINT16):
a = ANEGW;
break;
case CASE(OMINUS, TINT32):
case CASE(OMINUS, TUINT32):
case CASE(OMINUS, TPTR32):
a = ANEGL;
break;
case CASE(OMINUS, TINT64):
case CASE(OMINUS, TUINT64):
case CASE(OMINUS, TPTR64):
a = ANEGQ;
break;
case CASE(OAND, TINT8):
case CASE(OAND, TUINT8):
a = AANDB;
break;
case CASE(OAND, TINT16):
case CASE(OAND, TUINT16):
a = AANDW;
break;
case CASE(OAND, TINT32):
case CASE(OAND, TUINT32):
case CASE(OAND, TPTR32):
a = AANDL;
break;
case CASE(OAND, TINT64):
case CASE(OAND, TUINT64):
case CASE(OAND, TPTR64):
a = AANDQ;
break;
case CASE(OOR, TINT8):
case CASE(OOR, TUINT8):
a = AORB;
break;
case CASE(OOR, TINT16):
case CASE(OOR, TUINT16):
a = AORW;
break;
case CASE(OOR, TINT32):
case CASE(OOR, TUINT32):
case CASE(OOR, TPTR32):
a = AORL;
break;
case CASE(OOR, TINT64):
case CASE(OOR, TUINT64):
case CASE(OOR, TPTR64):
a = AORQ;
break;
case CASE(OXOR, TINT8):
case CASE(OXOR, TUINT8):
a = AXORB;
break;
case CASE(OXOR, TINT16):
case CASE(OXOR, TUINT16):
a = AXORW;
break;
case CASE(OXOR, TINT32):
case CASE(OXOR, TUINT32):
case CASE(OXOR, TPTR32):
a = AXORL;
break;
case CASE(OXOR, TINT64):
case CASE(OXOR, TUINT64):
case CASE(OXOR, TPTR64):
a = AXORQ;
break;
case CASE(OLSH, TINT8):
case CASE(OLSH, TUINT8):
a = ASHLB;
break;
case CASE(OLSH, TINT16):
case CASE(OLSH, TUINT16):
a = ASHLW;
break;
case CASE(OLSH, TINT32):
case CASE(OLSH, TUINT32):
case CASE(OLSH, TPTR32):
a = ASHLL;
break;
case CASE(OLSH, TINT64):
case CASE(OLSH, TUINT64):
case CASE(OLSH, TPTR64):
a = ASHLQ;
break;
case CASE(ORSH, TUINT8):
a = ASHRB;
break;
case CASE(ORSH, TUINT16):
a = ASHRW;
break;
case CASE(ORSH, TUINT32):
case CASE(ORSH, TPTR32):
a = ASHRL;
break;
case CASE(ORSH, TUINT64):
case CASE(ORSH, TPTR64):
a = ASHRQ;
break;
case CASE(ORSH, TINT8):
a = ASARB;
break;
case CASE(ORSH, TINT16):
a = ASARW;
break;
case CASE(ORSH, TINT32):
a = ASARL;
break;
case CASE(ORSH, TINT64):
a = ASARQ;
break;
case CASE(OMUL, TINT8):
case CASE(OMUL, TUINT8):
a = AIMULB;
break;
case CASE(OMUL, TINT16):
case CASE(OMUL, TUINT16):
a = AIMULW;
break;
case CASE(OMUL, TINT32):
case CASE(OMUL, TUINT32):
case CASE(OMUL, TPTR32):
a = AIMULL;
break;
case CASE(OMUL, TINT64):
case CASE(OMUL, TUINT64):
case CASE(OMUL, TPTR64):
a = AIMULQ;
break;
case CASE(OMUL, TFLOAT32):
a = AMULSS;
break;
case CASE(OMUL, TFLOAT64):
a = AMULSD;
break;
case CASE(ODIV, TINT8):
case CASE(OMOD, TINT8):
a = AIDIVB;
break;
case CASE(ODIV, TUINT8):
case CASE(OMOD, TUINT8):
a = ADIVB;
break;
case CASE(ODIV, TINT16):
case CASE(OMOD, TINT16):
a = AIDIVW;
break;
case CASE(ODIV, TUINT16):
case CASE(OMOD, TUINT16):
a = ADIVW;
break;
case CASE(ODIV, TINT32):
case CASE(OMOD, TINT32):
a = AIDIVL;
break;
case CASE(ODIV, TUINT32):
case CASE(ODIV, TPTR32):
case CASE(OMOD, TUINT32):
case CASE(OMOD, TPTR32):
a = ADIVL;
break;
case CASE(ODIV, TINT64):
case CASE(OMOD, TINT64):
a = AIDIVQ;
break;
case CASE(ODIV, TUINT64):
case CASE(ODIV, TPTR64):
case CASE(OMOD, TUINT64):
case CASE(OMOD, TPTR64):
a = ADIVQ;
break;
case CASE(OFOR, TINT16):
a = ACWD;
break;
case CASE(OFOR, TINT32):
a = ACDQ;
break;
case CASE(OFOR, TINT64):
a = ACQO;
break;
case CASE(ODIV, TFLOAT32):
a = ADIVSS;
break;
case CASE(ODIV, TFLOAT64):
a = ADIVSD;
break;
}
return a;
}
int
isfat(Type *t)
{
if(t != T)
switch(t->etype) {
case TSTRUCT:
case TARRAY:
case TDARRAY:
case TINTER: // maybe remove later
return 1;
}
return 0;
}
/*
* return unsigned(op)
* eg GT -> HS
*/
int
brunsigned(int a)
{
switch(a) {
case AJLT: return AJGE;
case AJGT: return AJLE;
case AJLE: return AJGT;
case AJGE: return AJLT;
}
return a;
}
/*
* return !(op)
* eg == <=> !=
*/
int
brcom(int a)
{
switch(a) {
case OEQ: return ONE;
case ONE: return OEQ;
case OLT: return OGE;
case OGT: return OLE;
case OLE: return OGT;
case OGE: return OLT;
}
fatal("brcom: no com for %A\n", a);
return a;
}
/*
* return reverse(op)
* eg a op b <=> b r(op) a
*/
int
brrev(int a)
{
switch(a) {
case OEQ: return OEQ;
case ONE: return ONE;
case OLT: return OGT;
case OGT: return OLT;
case OLE: return OGE;
case OGE: return OLE;
}
fatal("brcom: no rev for %A\n", a);
return a;
}
/*
* make a new off the books
*/
void
tempname(Node *n, Type *t)
{
Sym *s;
ulong w;
if(t == T) {
yyerror("tempname called with nil type");
t = types[TINT32];
}
s = lookup("!tmpname!");
memset(n, 0, sizeof(*n));
n->op = ONAME;
n->sym = s;
n->type = t;
n->sym = s;
n->etype = t->etype;
n->class = PAUTO;
n->addable = 1;
n->ullman = 0;
dowidth(t);
w = t->width;
stksize += w;
stksize = rnd(stksize, w);
n->xoffset = -stksize;
}
void
stringpool(Node *n)
{
Pool *p;
int w;
if(n->op != OLITERAL || n->val.ctype != CTSTR) {
if(n->val.ctype == CTNIL)
return;
fatal("stringpool: not string %N", n);
}
p = mal(sizeof(*p));
p->sval = n->val.sval;
p->link = nil;
if(poolist == nil)
poolist = p;
else
poolast->link = p;
poolast = p;
w = types[TINT32]->width;
symstringo->offset += w; // len
symstringo->offset += p->sval->len; // str[len]
symstringo->offset = rnd(symstringo->offset, w);
}
Sig*
lsort(Sig *l, int(*f)(Sig*, Sig*))
{
Sig *l1, *l2, *le;
if(l == 0 || l->link == 0)
return l;
l1 = l;
l2 = l;
for(;;) {
l2 = l2->link;
if(l2 == 0)
break;
l2 = l2->link;
if(l2 == 0)
break;
l1 = l1->link;
}
l2 = l1->link;
l1->link = 0;
l1 = lsort(l, f);
l2 = lsort(l2, f);
/* set up lead element */
if((*f)(l1, l2) < 0) {
l = l1;
l1 = l1->link;
} else {
l = l2;
l2 = l2->link;
}
le = l;
for(;;) {
if(l1 == 0) {
while(l2) {
le->link = l2;
le = l2;
l2 = l2->link;
}
le->link = 0;
break;
}
if(l2 == 0) {
while(l1) {
le->link = l1;
le = l1;
l1 = l1->link;
}
break;
}
if((*f)(l1, l2) < 0) {
le->link = l1;
le = l1;
l1 = l1->link;
} else {
le->link = l2;
le = l2;
l2 = l2->link;
}
}
le->link = 0;
return l;
}
void
setmaxarg(Type *t)
{
Type *to;
long w;
to = *getoutarg(t);
w = to->width;
if(w > maxarg)
maxarg = w;
}