aboutsummaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/c.c6
-rw-r--r--src/c_builtin.c18
-rw-r--r--src/c_eval.c3
-rw-r--r--src/ir.c2
-rw-r--r--src/ir.h15
-rw-r--r--src/ir_abi0.c38
-rw-r--r--src/ir_builder.c6
-rw-r--r--src/ir_dump.c2
-rw-r--r--src/ir_inliner.c12
-rw-r--r--src/ir_intrin.c10
-rw-r--r--src/ir_mem2reg.c4
-rw-r--r--src/ir_op.def12
-rw-r--r--src/ir_regalloc.c31
-rw-r--r--src/ir_simpl.c20
-rw-r--r--src/ir_ssa.c2
-rw-r--r--src/ir_stack.c2
-rw-r--r--src/t_aarch64_isel.c50
-rw-r--r--src/t_x86-64_isel.c65
-rw-r--r--src/t_x86-64_sysv.c40
19 files changed, 171 insertions, 167 deletions
diff --git a/src/c.c b/src/c.c
index 90ff923..248a095 100644
--- a/src/c.c
+++ b/src/c.c
@@ -3121,7 +3121,7 @@ geninit(Function *fn, Type t, Ref dst, const Expr *src)
/* write individual zeros at non initialized gaps */
for (uint i = 0; bsiter(&i, azero, countof(azero)) && i < siz; i += align) {
adr = irbinop(fn, Oadd, KPTR, dst, mkref(RICON, i));
- addinstr(fn, mkinstr(Ostorei8 + ilog2(align), 0, .l = adr, .r = ZEROREF));
+ addinstr(fn, mkinstr2(Ostorei8 + ilog2(align), 0, adr, ZEROREF));
}
} else {
goto Memset0;
@@ -4564,7 +4564,7 @@ function(CComp *cm, Function *fn, internstr *pnames, const Span *pspans, uchar *
EMITS {
for (int i = 0; i < td->nmemb; ++i) {
IRType pty = mkirtype(td->param[i]);
- Ref r = addinstr(fn, mkinstr(Oparam, pty.isagg ? KPTR : pty.cls,
+ Ref r = addinstr(fn, mkinstr2(Oparam, pty.isagg ? KPTR : pty.cls,
mkref(RICON, i), mktyperef(pty)));
assert(r.t == RTMP && r.i == i);
}
@@ -4579,7 +4579,7 @@ function(CComp *cm, Function *fn, internstr *pnames, const Span *pspans, uchar *
arg.id = addinstr(fn, mkalloca(typesize(arg.ty), typealign(arg.ty))).i;
genstore(fn, arg.ty, mkref(RTMP, arg.id), mkref(RTMP, i));
} else {
- arg.id = addinstr(fn, mkinstr(Ocopy, KPTR, mkref(RTMP, i))).i;
+ arg.id = addinstr(fn, mkinstr1(Ocopy, KPTR, mkref(RTMP, i))).i;
}
}
putdecl(cm, &arg);
diff --git a/src/c_builtin.c b/src/c_builtin.c
index a8d4f4f..522c4dc 100644
--- a/src/c_builtin.c
+++ b/src/c_builtin.c
@@ -46,7 +46,7 @@ va_start_comp(Function *fn, Expr *ex, bool discard)
assert(typedecay(ex->sub[1].ty).bits == typedecay(cvalistty).bits);
if (!typedata[fn->fnty.dat].variadic)
error(&ex->span, "va_start used in non-variadic function");
- addinstr(fn, mkinstr(Ovastart, 0, compileexpr(fn, &ex->sub[1], 0)));
+ addinstr(fn, mkinstr1(Ovastart, 0, compileexpr(fn, &ex->sub[1], 0)));
return NOREF;
}
@@ -89,20 +89,6 @@ trap_comp(Function *fn, Expr *ex, bool discard)
return NOREF;
}
-static inline Ref
-cvtintref(Function *fn, enum irclass dst, Ref src)
-{
- if (src.t == RTMP) {
- if (insrescls(instrtab[src.i]) != dst)
- return addinstr(fn, mkinstr(Ocopy, dst, src));
- return src;
- } else if (isintcon(src)) {
- vlong x = intconval(src);
- return mkintcon(dst, cls2siz[dst] == 4 ? (int)x : x);
- }
- assert(!"int ref?");
-}
-
/* __builtin_bswap16 */
DEF_FNLIKE_SEMA(bswap16, mktype(TYUSHORT), mktype(TYUSHORT))
static Ref
@@ -162,7 +148,7 @@ builtin_va_arg_comp(Function *fn, const Expr *ex, bool discard)
{
assert(ex->t == EVAARG && ex->ty.t);
enum irclass k = isagg(ex->ty) ? KPTR : type2cls[scalartypet(ex->ty)];
- return addinstr(fn, mkinstr(Ovaarg, k, compileexpr(fn, ex->sub, 0), mktyperef(mkirtype(ex->ty))));
+ return addinstr(fn, mkinstr2(Ovaarg, k, compileexpr(fn, ex->sub, 0), mktyperef(mkirtype(ex->ty))));
}
bool
diff --git a/src/c_eval.c b/src/c_eval.c
index 20a5a12..927ea05 100644
--- a/src/c_eval.c
+++ b/src/c_eval.c
@@ -83,7 +83,8 @@ lit2ssym(Expr *ex)
{
ex->ssym.sym = xcon2sym(expraddr(NULL, ex).i);
ex->ssym.local = 1;
- ex->ssym.func = ex->ssym.off = 0;
+ ex->ssym.func = 0;
+ ex->ssym.off = 0;
ex->t = ESSYMREF;
return ex;
}
diff --git a/src/ir.c b/src/ir.c
index ce36e64..6cdb43d 100644
--- a/src/ir.c
+++ b/src/ir.c
@@ -484,7 +484,7 @@ insertphi(Block *blk, enum irclass cls)
assert(blk->npred > 0);
xbgrowz(&refs, blk->npred);
vpush(&phitab, refs);
- instrtab[new] = mkinstr(Ophi, cls, mkref(RXXX, phitab.n - 1));
+ instrtab[new] = mkinstr1(Ophi, cls, {.i = phitab.n - 1});
vpush(&blk->phi, new);
return mkref(RTMP, new);
}
diff --git a/src/ir.h b/src/ir.h
index f54c2fb..fef38b5 100644
--- a/src/ir.h
+++ b/src/ir.h
@@ -122,9 +122,12 @@ typedef struct Instr {
keep : 1; /* for codegen, keep instr even if result seems unused */
uchar inplace : 1; /* set (by isel) for instructions which modify its first arg in place */
uchar reg; /* 0 -> no reg; else reg + 1 */
- Ref l, r; /* args */
+ union { /* operands */
+ struct { Ref l, r; };
+ Ref oper[3];
+ };
} Instr;
-static_assert(sizeof(Instr) == 4*3);
+static_assert(sizeof(Instr) == 4*4);
enum jumpkind { JXXX, Jb, Jret, Jtrap, };
@@ -253,8 +256,10 @@ extern struct dattab {vec_of(IRDat);} dattab;
extern struct contab {vec_of(IRCon);} contab;
extern struct addrtab {vec_of(IRAddr);} addrtab;
extern int visitmark;
-#define mkinstr(O, C, ...) ((Instr) { .op = (O), .cls = (C), .reg=0, __VA_ARGS__ })
-#define mkarginstr(ty, x) mkinstr(Oarg, 0, mktyperef(ty), (x))
+#define mkinstr0(O, C) ((Instr) { .op = (O), .cls = (C), .reg=0 })
+#define mkinstr1(O, C, x) ((Instr) { .op = (O), .cls = (C), .reg=0, .l = x})
+#define mkinstr2(O, C, x,y) ((Instr) { .op = (O), .cls = (C), .reg=0, .l = x, .r = y})
+#define mkarginstr(ty, x) mkinstr2(Oarg, 0, mktyperef(ty), (x))
void irinit(Function *);
void irfini(Function *);
#define cls2type(k) ((IRType){.cls=(k)})
@@ -276,7 +281,7 @@ Ref mkdatref(internstr sym, Type ctype, uint siz, uint align,
internstr xcon2sym(int ref);
Instr mkalloca(uint siz, uint align);
Ref mkcallarg(IRType ret, uint narg, int vararg);
-#define mkintrin(B, C, N) mkinstr(Ointrin, C, {{.t=RICON,B}}, mkcallarg((IRType){{0}},N,-1))
+#define mkintrin(B, C, N) mkinstr2(Ointrin, C, mkref(RICON, B), mkcallarg((IRType){{0}},N,-1))
Ref mkaddr(IRAddr);
void addpred(Block *blk, Block *p);
diff --git a/src/ir_abi0.c b/src/ir_abi0.c
index cd7ce27..61a310f 100644
--- a/src/ir_abi0.c
+++ b/src/ir_abi0.c
@@ -58,7 +58,7 @@ abiarg(ABIArgVec *abiargs, uchar *r2off, int *ni, int *nf, int *ns, IRType ty)
static Instr
copyparam(Function *fn, int *curi, int param, ABIArg abi)
{
- Instr par = mkinstr(Oparam, abi.ty.cls, mkref(RICON, param), mktyperef(abi.ty));
+ Instr par = mkinstr2(Oparam, abi.ty.cls, mkref(RICON, param), mktyperef(abi.ty));
if (!abi.isstk) { /* reg */
assert(!abi.ty.isagg);
return par;
@@ -75,7 +75,7 @@ copyparam(Function *fn, int *curi, int param, ABIArg abi)
case KF32: ld = Oloadf32; break;
case KF64: ld = Oloadf64; break;
}
- return mkinstr(ld, abi.ty.cls, insertinstr(fn->entry, (*curi)++, par));
+ return mkinstr1(ld, abi.ty.cls, insertinstr(fn->entry, (*curi)++, par));
} else { /* aggregate in stack */
par.cls = KPTR;
return par;
@@ -109,7 +109,7 @@ patchparam(Function *fn, int *curi, int *param, int tydat, int nabi, ABIArg abi[
assert(td->siz <= 16 && td->align <= 16);
align = td->siz <= 4 ? 4 : alignup(td->align, 8);
nalloc = td->siz/align + (td->siz%align != 0);
- *ins = mkinstr(Oalloca1 + ilog2(align), KPTR, mkref(RICON, nalloc));
+ *ins = mkinstr1(Oalloca1 + ilog2(align), KPTR, mkref(RICON, nalloc));
alloc = mkref(RTMP, ins - instrtab);
r[0] = insertinstr(blk, ++*curi, copyparam(fn, NULL, *param, abi[0]));
if (nabi > 1)
@@ -121,11 +121,11 @@ patchparam(Function *fn, int *curi, int *param, int tydat, int nabi, ABIArg abi[
* store* %x, %a
* store* %x + N, %b
*/
- st = mkinstr(cls2store[abi[0].ty.cls], 0, alloc, r[0]);
+ st = mkinstr2(cls2store[abi[0].ty.cls], 0, alloc, r[0]);
insertinstr(blk, ++*curi, st);
if (nabi > 1) {
- Instr tmp = mkinstr(Oadd, KPTR, alloc, mkref(RICON, r2off));
- st = mkinstr(cls2store[abi[1].ty.cls], 0, insertinstr(blk, ++*curi, tmp), r[1]);
+ Instr tmp = mkinstr2(Oadd, KPTR, alloc, mkref(RICON, r2off));
+ st = mkinstr2(cls2store[abi[1].ty.cls], 0, insertinstr(blk, ++*curi, tmp), r[1]);
insertinstr(blk, ++*curi, st);
}
}
@@ -165,7 +165,7 @@ load2regs(Ref out[2], IRType typ, Ref src, int nabi, ABIArg abi[2], uchar r2off,
if (i == 0)
ins.l = src;
else {
- Instr adr = mkinstr(Oadd, KPTR, src, mkref(RICON, r2off));
+ Instr adr = mkinstr2(Oadd, KPTR, src, mkref(RICON, r2off));
ins.l = insertinstr(blk, (*curi)++, adr);
}
temp = insertinstr(blk, (*curi)++, ins);
@@ -184,13 +184,13 @@ load2regs(Ref out[2], IRType typ, Ref src, int nabi, ABIArg abi[2], uchar r2off,
if (i+o == 0)
ld.l = src;
else {
- Instr adr = mkinstr(Oadd, KPTR, src, mkref(RICON, (i == 0 ? 0 : r2off) + o*align));
+ Instr adr = mkinstr2(Oadd, KPTR, src, mkref(RICON, (i == 0 ? 0 : r2off) + o*align));
ld.l = insertinstr(blk, (*curi)++, adr);
}
temp = insertinstr(blk, (*curi)++, ld);
if (o > 0) {
- Ref t = insertinstr(blk, (*curi)++, mkinstr(Oshl, ld.cls, temp, mkref(RICON, o*align*8)));
- reg = insertinstr(blk, (*curi)++, mkinstr(Oior, ld.cls, reg, t));
+ Ref t = insertinstr(blk, (*curi)++, mkinstr2(Oshl, ld.cls, temp, mkref(RICON, o*align*8)));
+ reg = insertinstr(blk, (*curi)++, mkinstr2(Oior, ld.cls, reg, t));
} else {
reg = temp;
}
@@ -223,10 +223,10 @@ patcharg(Block *blk, int *icall, IRCall *call,
arg->cls = KPTR;
arg->r = mkref(RICON, abi->stk);
for (uint off = 0; off < siz; off += align) {
- Ref sadr = off == 0 ? src : insertinstr(blk, ++arginst, mkinstr(Oadd, KPTR, src, mkref(RICON, off)));
- Ref tmp = insertinstr(blk, ++arginst, mkinstr(Oloads8+2*ilog2(align), align < 8 ? KI32 : KI64, sadr));
- Ref dadr = off == 0 ? dst : insertinstr(blk, ++arginst, mkinstr(Oadd, KPTR, dst, mkref(RICON, off)));
- insertinstr(blk, ++arginst, mkinstr(Ostorei8+ilog2(align), 0, dadr, tmp));
+ Ref sadr = off == 0 ? src : insertinstr(blk, ++arginst, mkinstr2(Oadd, KPTR, src, mkref(RICON, off)));
+ Ref tmp = insertinstr(blk, ++arginst, mkinstr1(Oloads8+2*ilog2(align), align < 8 ? KI32 : KI64, sadr));
+ Ref dadr = off == 0 ? dst : insertinstr(blk, ++arginst, mkinstr2(Oadd, KPTR, dst, mkref(RICON, off)));
+ insertinstr(blk, ++arginst, mkinstr2(Ostorei8+ilog2(align), 0, dadr, tmp));
}
*icall = arginst + (call->narg - argidx);
return 1;
@@ -238,7 +238,7 @@ patcharg(Block *blk, int *icall, IRCall *call,
delinstr(blk, arginst);
load2regs(r, ref2type(arg->l), arg->r, nabi, abi, r2off, blk, &arginst);
for (int i = 0; i < nabi; ++i)
- insertinstr(blk, arginst++, mkinstr(Oarg, 0, mktyperef(abi[i].ty), r[i]));
+ insertinstr(blk, arginst++, mkinstr2(Oarg, 0, mktyperef(abi[i].ty), r[i]));
*icall = arginst + (call->narg - argidx - 1);
return nabi;
}
@@ -281,7 +281,7 @@ abi0_call(Function *fn, Instr *ins, Block *blk, int *curi)
if (!nret) /* hidden pointer argument */
insertinstr(blk, (*curi)++ - call->narg,
- mkinstr(Oarg, 0, mktyperef((IRType){.cls=KPTR}), retmem));
+ mkinstr2(Oarg, 0, mktyperef((IRType){.cls=KPTR}), retmem));
}
/* adjust args */
@@ -316,7 +316,7 @@ abi0_call(Function *fn, Instr *ins, Block *blk, int *curi)
ins->cls = call->abiret[0].ty.cls;
r[0] = mkref(RTMP, ins - instrtab);
if (nret == 2) {
- ret2 = mkinstr(Ocall2r, call->abiret[1].ty.cls, r[0]);
+ ret2 = mkinstr1(Ocall2r, call->abiret[1].ty.cls, r[0]);
r[1] = insertinstr(blk, ++*curi, ret2);
}
for (int i = 0; i < nret; ++i) {
@@ -324,7 +324,7 @@ abi0_call(Function *fn, Instr *ins, Block *blk, int *curi)
if (i == 0) {
store.l = retmem;
} else {
- Instr addr = mkinstr(Oadd, KPTR, retmem, mkref(RICON, call->r2off));
+ Instr addr = mkinstr2(Oadd, KPTR, retmem, mkref(RICON, call->r2off));
store.l = insertinstr(blk, ++*curi, addr);
}
store.r = r[i];
@@ -404,7 +404,7 @@ abi0(Function *fn)
}
} while ((blk = blk->lnext) != fn->entry);
if (rvovar != -1)
- instrtab[rvovar] = mkinstr(Ocopy, KPTR, sret);
+ instrtab[rvovar] = mkinstr1(Ocopy, KPTR, sret);
}
blk = fn->entry->lnext;
diff --git a/src/ir_builder.c b/src/ir_builder.c
index 0c4b910..7f46574 100644
--- a/src/ir_builder.c
+++ b/src/ir_builder.c
@@ -100,7 +100,7 @@ irbinop(Function *fn, enum op op, enum irclass k, Ref l, Ref r)
default:
assert(!"binop?");
}
- return fn ? addinstr(fn, mkinstr(op, k, l, r)) : NOREF;
+ return fn ? addinstr(fn, mkinstr2(op, k, l, r)) : NOREF;
}
/* implements f32/f64 -> u64 conversion */
@@ -195,7 +195,7 @@ irunop(Function *fn, enum op op, enum irclass k, Ref a)
break;
default: assert(!"unop?");
}
- return fn ? addinstr(fn, mkinstr(op, k, a)) : NOREF;
+ return fn ? addinstr(fn, mkinstr1(op, k, a)) : NOREF;
}
int allocinstr(void);
@@ -242,7 +242,7 @@ addphi(Function *fn, enum irclass cls, Ref *r)
vpush(&phitab, refs);
/*assert(fn->curblk->ins.n == 0);*/
int new = allocinstr();
- instrtab[new] = mkinstr(Ophi, cls, .l.i = phitab.n-1);
+ instrtab[new] = mkinstr1(Ophi, cls, {.i=phitab.n-1});
for (int i = 0; i < fn->curblk->npred; ++i) {
adduse(fn->curblk, new, r[i]);
}
diff --git a/src/ir_dump.c b/src/ir_dump.c
index 7534370..89d34d4 100644
--- a/src/ir_dump.c
+++ b/src/ir_dump.c
@@ -215,7 +215,7 @@ dumpinst(const Instr *ins)
if (i == 1 && (ins->op == Ocall || ins->op == Ointrin)) {
dumpcall(&calltab.p[ins->r.i]);
} else {
- dumpref(ins->op, (&ins->l)[i]);
+ dumpref(ins->op, ins->oper[i]);
}
}
if (oisalloca(ins->op) && ins->l.t == RICON) {
diff --git a/src/ir_inliner.c b/src/ir_inliner.c
index c3e0777..db89479 100644
--- a/src/ir_inliner.c
+++ b/src/ir_inliner.c
@@ -125,7 +125,7 @@ inlcall(Function *fn, Block *blk, int curi, SavedFunc *sv)
Instr *ins = &instrtab[blk->ins.p[i]];
if (ins->op == Oarg) {
args[--n] = ins->r;
- *ins = mkinstr(Onop,0,);
+ *ins = mkinstr0(Onop,0);
}
}
if (call->abiret[1].ty.bits) {
@@ -135,14 +135,14 @@ inlcall(Function *fn, Block *blk, int curi, SavedFunc *sv)
}
Block *exit = blksplitafter(fn, blk, curi-1);
if (!ins->cls) {
- *ins = mkinstr(Onop,0,);
+ *ins = mkinstr0(Onop,0);
} else {
if (sv->nretpoints == 1) {
- *ins = mkinstr(Ocopy, ins->cls, );
+ *ins = mkinstr1(Ocopy, ins->cls, NOREF);
} else {
/* turn into a phi */
- *ins = mkinstr(Ophi, ins->cls, );
- exit->ins.p[0] = newinstr(blk, mkinstr(Onop,0,));
+ *ins = mkinstr1(Ophi, ins->cls, NOREF);
+ exit->ins.p[0] = newinstr(blk, mkinstr0(Onop,0));
vpush(&exit->phi, res);
}
}
@@ -187,7 +187,7 @@ inlcall(Function *fn, Block *blk, int curi, SavedFunc *sv)
for (int i = 0; i < b->npred; ++i)
refs[i] = mapref(instrmap, sv, src[i]);
vpush(&phitab, refs);
- instrtab[instrmap[t]] = mkinstr(Ophi, sv->instrtab[t].cls, .l.i = phitab.n-1);
+ instrtab[instrmap[t]] = mkinstr1(Ophi, sv->instrtab[t].cls, {.i = phitab.n-1});
new->phi.p[i] = instrmap[t];
}
vresize(&new->ins, b->ins.n);
diff --git a/src/ir_intrin.c b/src/ir_intrin.c
index 6c73784..e2ea1d0 100644
--- a/src/ir_intrin.c
+++ b/src/ir_intrin.c
@@ -24,7 +24,7 @@ intrin(Block *blk, int *curi, enum intrin in, Arg *args, int narg, IRType ret)
/* memcpy */
*args[1].ty = *args[0].ty = mktyperef(cls2type(KPTR));
insertinstr(blk, (*curi)++, mkarginstr(cls2type(cls), mkintcon(cls, td->siz)));
- *this = mkinstr(Ocall, 0, mksymref(intern("memcpy"), SFUNC), this->r);
+ *this = mkinstr2(Ocall, 0, mksymref(intern("memcpy"), SFUNC), this->r);
calltab.p[this->r.i].narg = 3;
calltab.p[this->r.i].ret = cls2type(0);
return 0;
@@ -33,11 +33,11 @@ intrin(Block *blk, int *curi, enum intrin in, Arg *args, int narg, IRType ret)
for (int off = 0; off < td->siz; off += step) {
Ref psrc = *args[1].arg, pdst = *args[0].arg, src;
if (off) {
- pdst = insertinstr(blk, ++*curi, mkinstr(Oadd, KPTR, *args[0].arg, mkref(RICON, off)));
- psrc = insertinstr(blk, ++*curi, mkinstr(Oadd, KPTR, *args[1].arg, mkref(RICON, off)));
+ pdst = insertinstr(blk, ++*curi, mkinstr2(Oadd, KPTR, *args[0].arg, mkref(RICON, off)));
+ psrc = insertinstr(blk, ++*curi, mkinstr2(Oadd, KPTR, *args[1].arg, mkref(RICON, off)));
}
- src = insertinstr(blk, ++*curi, mkinstr(Oloads8 + 2*ilog2(step), step < 8 ? KI32 : KI64, psrc));
- insertinstr(blk, ++*curi, mkinstr(Ostorei8 + ilog2(step), 0, pdst, src));
+ src = insertinstr(blk, ++*curi, mkinstr1(Oloads8 + 2*ilog2(step), step < 8 ? KI32 : KI64, psrc));
+ insertinstr(blk, ++*curi, mkinstr2(Ostorei8 + ilog2(step), 0, pdst, src));
}
return 1;
}
diff --git a/src/ir_mem2reg.c b/src/ir_mem2reg.c
index 8890439..ae41833 100644
--- a/src/ir_mem2reg.c
+++ b/src/ir_mem2reg.c
@@ -276,7 +276,7 @@ mem2reg(Function *fn)
if (oisstore(ins->op)) {
writevar(&sb, var, use->blk, ins->r);
- *ins = mkinstr(Onop,0,);
+ *ins = mkinstr0(Onop,0);
} else if (oisload(ins->op)) {
Ref val = readvar(&sb, var, k = ins->cls, use->blk);
adduse(use->blk, use->u, val);
@@ -285,7 +285,7 @@ mem2reg(Function *fn)
assert(val.bits);
ext = Ocopy;
}
- *ins = mkinstr(ext, k, val);
+ *ins = mkinstr1(ext, k, val);
}
}
/* remove alloca */
diff --git a/src/ir_op.def b/src/ir_op.def
index 4a18b4b..4e775a1 100644
--- a/src/ir_op.def
+++ b/src/ir_op.def
@@ -60,12 +60,12 @@ _(loadu32, 1)
_(loadi64, 1)
_(loadf32, 1)
_(loadf64, 1)
-_(storei8, 2)
-_(storei16, 2)
-_(storei32, 2)
-_(storei64, 2)
-_(storef32, 2)
-_(storef64, 2)
+_(storei8, 2)
+_(storei16, 2)
+_(storei32, 2)
+_(storei64, 2)
+_(storef32, 2)
+_(storef64, 2)
_(param, 2)
_(arg, 2)
_(call, 2)
diff --git a/src/ir_regalloc.c b/src/ir_regalloc.c
index 54f5d59..41a4026 100644
--- a/src/ir_regalloc.c
+++ b/src/ir_regalloc.c
@@ -215,7 +215,7 @@ pmadd(PMState *pms, enum irclass k, Alloc dst, Alloc src)
pms->pmove[pms->npmove++] = (struct PMove) { k, PMTOMOVE, dst, src };
}
-#define mkmove(k, rd, rs) mkinstr(Omove, k, mkref(RREG, rd), mkref(RREG, rs))
+#define mkmove(k, rd, rs) mkinstr2(Omove, k, mkref(RREG, rd), mkref(RREG, rs))
static void
emitmove(Function *fn, enum irclass k, Alloc dst, Alloc src, Block *blk, int curi)
{
@@ -243,7 +243,7 @@ emitmove(Function *fn, enum irclass k, Alloc dst, Alloc src, Block *blk, int cur
insertinstr(blk, curi++, mv);
} else reg = src.a;
if (dst.t == ASTACK) {
- mv = mkinstr(cls2store[k], 0, stkslotref(fn, dst.a*8), mkref(RREG, reg));
+ mv = mkinstr2(cls2store[k], 0, stkslotref(fn, dst.a*8), mkref(RREG, reg));
insertinstr(blk, curi, mv);
}
}
@@ -275,7 +275,7 @@ pmrec(PMState *pms, int i, Block *blk, int curi, enum irclass *k)
Swap:
if (pm->src.t == AREG && pm->dst.t == AREG) {
insertinstr(blk, curi,
- mkinstr(Oswap, *k, mkref(RREG, pm->dst.a), mkref(RREG, pm->src.a), .keep = 1));
+ (Instr){Oswap, *k, .keep=1, .l = mkref(RREG, pm->dst.a), .r = mkref(RREG, pm->src.a)});
} else if (pm->src.t != pm->dst.t) {
Alloc reg, stk, regtmp;
if (pm->src.t == AREG)
@@ -286,7 +286,7 @@ pmrec(PMState *pms, int i, Block *blk, int curi, enum irclass *k)
regtmp = areg(kisint(*k) ? mctarg->gprscratch : mctarg->fprscratch);
emitmove(pms->fn, *k, regtmp, stk, blk, curi++);
insertinstr(blk, curi++,
- mkinstr(Oswap, *k, mkref(RREG, reg.a), mkref(RREG, regtmp.a), .keep = 1));
+ (Instr){Oswap, *k, .keep=1, .l = mkref(RREG, reg.a), .r = mkref(RREG, regtmp.a)});
emitmove(pms->fn, *k, stk, regtmp, blk, curi++);
} else {
/* FIXME using scratch gpr and fpr for this is hackish */
@@ -411,7 +411,7 @@ fixcssa(Function *fn)
for (int i = 0; i < blk->phi.n; ++i) {
int phi = blk->phi.p[i];
Ref *args = phitab.p[instrtab[phi].l.i];
- args[p] = insertinstr(n, n->ins.n, mkinstr(Ocopy, instrtab[phi].cls, args[p]));
+ args[p] = insertinstr(n, n->ins.n, mkinstr1(Ocopy, instrtab[phi].cls, args[p]));
}
}
} while ((blk = blk->lnext) != fn->entry);
@@ -660,7 +660,7 @@ buildintervals(RegAlloc *ra)
if (!intervaldef(ra, out, blk, pos, reghint)) {
if (insrescls(*ins) && ins->op != Omove && !ins->keep && !(ins->op == Ocopy && ins->l.t == RREG)) {
/* dead */
- *ins = mkinstr(Onop,0,);
+ *ins = mkinstr0(Onop,0);
}
}
bsclr(live, out);
@@ -680,7 +680,7 @@ buildintervals(RegAlloc *ra)
* move RCX, %1
* %2 = shl 1, RCX
* and %2 is dead, the move to RCX can be killed */
- *ins = mkinstr(Onop,0,);
+ *ins = mkinstr0(Onop,0);
}
} else {
rsset(&ra->fn->regusage, ins->l.i);
@@ -719,14 +719,25 @@ buildintervals(RegAlloc *ra)
* live.add(opd)
*/
reghint = (ins && ins->op == Omove && ins->l.t == RREG) ? ins->l.i : -1;
- queue[0] = ins->r, queue[1] = ins->l;
+ int nqueue;
+ if (ins->op == Omove) {
+ nqueue = 1;
+ queue[0] = ins->r;
+ } else {
+ switch ((nqueue = opnarg[ins->op])) {
+ case 2: queue[2] = ins->oper[2];
+ case 1: queue[1] = ins->oper[1];
+ case 0: queue[0] = ins->oper[0];
+ }
+ }
if (0) {
Branchopd:
reghint = -1;
curi = blk->ins.n;
pos = blk->inumstart + blk->ins.n + 1;
+ nqueue = 2;
}
- for (int nqueue = ins && ins->op == Omove ? 1 : 2; nqueue > 0;) {
+ while (nqueue > 0) {
Ref r = queue[--nqueue];
/* do not allocate a reg for a cmp op used as branch argument, since it's a pseudo op */
@@ -1252,7 +1263,7 @@ devirt(RegAlloc *ra, Block *blk)
}
ins->reg = reg+1;
insertinstr(blk, ++curi,
- mkinstr(store, 0, stkslotref(fn, alloc->a*8), mkref(RREG, reg)));
+ mkinstr2(store, 0, stkslotref(fn, alloc->a*8), mkref(RREG, reg)));
if (nspill > 0 && dosave) {
emitmove(fn, isgpr(reg) ? KPTR : KF64, areg(reg),
spillsave[nspill-1], blk, ++curi);
diff --git a/src/ir_simpl.c b/src/ir_simpl.c
index 8bf8c98..ad25a9f 100644
--- a/src/ir_simpl.c
+++ b/src/ir_simpl.c
@@ -21,12 +21,12 @@ mulk(Instr *ins, Block *blk, int *curi)
/* x * 5 ==> (x << 2) + x */
ins->op = Oadd;
ins->r = ins->l;
- ins->l = insertinstr(blk, (*curi)++, mkinstr(Oshl, cls, ins->l, mkref(RICON, ilog2(iv-1))));
+ ins->l = insertinstr(blk, (*curi)++, mkinstr2(Oshl, cls, ins->l, mkref(RICON, ilog2(iv-1))));
} else if (ispo2(iv+1)) {
/* x * 7 ==> (x << 3) - x */
ins->op = Osub;
ins->r = ins->l;
- ins->l = insertinstr(blk, (*curi)++, mkinstr(Oshl, cls, ins->l, mkref(RICON, ilog2(iv+1))));
+ ins->l = insertinstr(blk, (*curi)++, mkinstr2(Oshl, cls, ins->l, mkref(RICON, ilog2(iv+1))));
} else return 0;
if (neg) {
ins->l = insertinstr(blk, (*curi)++, *ins);
@@ -58,12 +58,12 @@ divmodk(Instr *ins, Block *blk, int *curi)
case Odiv: case Orem:
/* have to adjust to round negatives toward zero */
/* x' = (((x < 0 ? -1 : 0) >>> (Nbit - s)) + x) */
- temp = insertinstr(blk, (*curi)++, mkinstr(Osar, cls, ins->l, mkref(RICON, nbit - 1)));
- temp = insertinstr(blk, (*curi)++, mkinstr(Oslr, cls, temp, mkref(RICON, nbit - s)));
- temp = insertinstr(blk, (*curi)++, mkinstr(Oadd, cls, ins->l, temp));
+ temp = insertinstr(blk, (*curi)++, mkinstr2(Osar, cls, ins->l, mkref(RICON, nbit - 1)));
+ temp = insertinstr(blk, (*curi)++, mkinstr2(Oslr, cls, temp, mkref(RICON, nbit - s)));
+ temp = insertinstr(blk, (*curi)++, mkinstr2(Oadd, cls, ins->l, temp));
if (op == Odiv) {
/* (-) (x' >> s) */
- Instr sar = mkinstr(Osar, cls, temp, mkref(RICON, s));
+ Instr sar = mkinstr2(Osar, cls, temp, mkref(RICON, s));
if (!neg) *ins = sar;
else {
temp = insertinstr(blk, (*curi)++, sar);
@@ -71,7 +71,7 @@ divmodk(Instr *ins, Block *blk, int *curi)
}
} else {
/* x - (x' & -(2^s)) */
- temp = insertinstr(blk, (*curi)++, mkinstr(Oand, cls, temp, mkintcon(cls, neg ? iv : -iv)));
+ temp = insertinstr(blk, (*curi)++, mkinstr2(Oand, cls, temp, mkintcon(cls, neg ? iv : -iv)));
ins->op = Osub, ins->r = temp;
}
break;
@@ -89,7 +89,7 @@ doins(Instr *ins, Block *blk, int *curi)
Ref r = narg == 1 ? irunop(NULL, ins->op, ins->cls, ins->l)
: irbinop(NULL, ins->op, ins->cls, ins->l, ins->r);
if (r.bits) {
- *ins = mkinstr(Onop,0,);
+ *ins = mkinstr0(Onop,0);
replcuses(mkref(RTMP, ins - instrtab), r);
return 1;
}
@@ -101,7 +101,7 @@ doins(Instr *ins, Block *blk, int *curi)
|| (isnumcon(ins->l) && k == concls(ins->l))
|| (kisint(k) && ins->l.t == RICON)) {
Ref it = ins->l;
- *ins = mkinstr(Onop,0,);
+ *ins = mkinstr0(Onop,0);
replcuses(mkref(RTMP, ins - instrtab), it);
return 1;
}
@@ -130,7 +130,7 @@ doins(Instr *ins, Block *blk, int *curi)
}
ins->l = lhs->l, ins->r = mkintcon(ins->cls, c);
deluse(blk, ins - instrtab, mkref(RTMP, lhs - instrtab));
- if (!instruse[lhs - instrtab]) *lhs = mkinstr(Onop,0,);
+ if (!instruse[lhs - instrtab]) *lhs = mkinstr0(Onop,0);
return 1;
}
}
diff --git a/src/ir_ssa.c b/src/ir_ssa.c
index f3fcb5d..6e7945b 100644
--- a/src/ir_ssa.c
+++ b/src/ir_ssa.c
@@ -35,7 +35,7 @@ copyopt(Function *fn)
if (ins->cls != k) continue;
replcuses(var, arg);
- *ins = mkinstr(Onop,0,);
+ *ins = mkinstr0(Onop,0);
deluses(var.i);
}
}
diff --git a/src/ir_stack.c b/src/ir_stack.c
index d15a764..ff49805 100644
--- a/src/ir_stack.c
+++ b/src/ir_stack.c
@@ -18,7 +18,7 @@ lowerstack(Function *fn)
fn->stksiz += siz;
fn->stksiz = alignup(fn->stksiz, 1 << alignlog2);
if (fn->stksiz > (1<<20)-1) error(NULL, "'%s' stack frame too big", fn->name);
- *ins = mkinstr(Onop,0,);
+ *ins = mkinstr0(Onop,0);
replcuses(mkref(RTMP, t), mkref(RSTACK, fn->stksiz));
}
}
diff --git a/src/t_aarch64_isel.c b/src/t_aarch64_isel.c
index 16eb022..381a57d 100644
--- a/src/t_aarch64_isel.c
+++ b/src/t_aarch64_isel.c
@@ -74,7 +74,7 @@ static void
regarg(Ref *r, enum irclass k, Block *blk, int *curi)
{
if (r->t != RTMP) {
- *r = insertinstr(blk, (*curi)++, mkinstr(Ocopy, k, *r));
+ *r = insertinstr(blk, (*curi)++, mkinstr1(Ocopy, k, *r));
if (kisflt(k) || instrtab[r->i].l.t == RSTACK) {
int iprev = *curi-1;
fixarg(&instrtab[r->i].l, &instrtab[r->i], blk, &iprev);
@@ -123,15 +123,15 @@ fixarg(Ref *r, Instr *ins, Block *blk, int *curi)
pun.f64 = contab.p[r->i].f;
i = pun.i64;
}
- Ref gpr = insertinstr(blk, (*curi)++, mkinstr(Ocopy, ki, mkintcon(ki, i)));
- *r = insertinstr(blk, (*curi)++, mkinstr(Ocopy, k, gpr));
+ Ref gpr = insertinstr(blk, (*curi)++, mkinstr1(Ocopy, ki, mkintcon(ki, i)));
+ *r = insertinstr(blk, (*curi)++, mkinstr1(Ocopy, k, gpr));
} else if (oiscmp(op)) {
return;
} else {
- *r = insertinstr(blk, (*curi)++, mkinstr(Ocopy, k, *r));
+ *r = insertinstr(blk, (*curi)++, mkinstr1(Ocopy, k, *r));
}
} else if (r->t == RSTACK) {
- Instr adr = mkinstr(Osub, KPTR, mkref(RREG, FP), mkintcon(KI32, r->i));
+ Instr adr = mkinstr2(Osub, KPTR, mkref(RREG, FP), mkintcon(KI32, r->i));
if (op == Ocopy)
*ins = adr;
else
@@ -148,7 +148,7 @@ arithfold(Instr *ins)
Ref r;
bool ok = ins->r.t ? foldbinop(&r, ins->op, ins->cls, ins->l, ins->r) : foldunop(&r, ins->op, ins->cls, ins->l);
assert(ok && "fold?");
- *ins = mkinstr(Ocopy, insrescls(*ins), r);
+ *ins = mkinstr1(Ocopy, insrescls(*ins), r);
return 1;
}
return 0;
@@ -173,44 +173,44 @@ selcall(Function *fn, Instr *ins, Block *blk, int *curi)
if (!abi.isstk) {
assert(!abi.ty.isagg);
- *arg = mkinstr(Omove, call->abiarg[i].ty.cls, mkref(RREG, abi.reg), arg->r);
+ *arg = mkinstr2(Omove, call->abiarg[i].ty.cls, mkref(RREG, abi.reg), arg->r);
} else {
Ref adr = mkaddr((IRAddr){mkref(RREG, SP), .disp = abi.stk});
int iargsave = iarg;
if (!abi.ty.isagg) { /* scalar arg in stack */
- *arg = mkinstr(cls2store[abi.ty.cls], 0, adr, arg->r);
+ *arg = mkinstr2(cls2store[abi.ty.cls], 0, adr, arg->r);
if (isaddrcon(arg->r,1) || arg->r.t == RADDR)
- arg->r = insertinstr(blk, iarg++, mkinstr(Ocopy, abi.ty.cls, arg->r));
+ arg->r = insertinstr(blk, iarg++, mkinstr1(Ocopy, abi.ty.cls, arg->r));
else
fixarg(&ins->r, ins, blk, &iarg);
} else { /* aggregate arg in stack, callee stack frame destination address */
- *arg = mkinstr(Ocopy, KPTR, adr);
+ *arg = mkinstr1(Ocopy, KPTR, adr);
}
*curi += iarg - iargsave;
}
}
if (call->argstksiz) {
Ref disp = mkref(RICON, argstksiz);
- insertinstr(blk, iarg--, (Instr){Osub, KPTR, .keep=1, .reg = SP+1, .l=mkref(RREG,SP), disp});
+ insertinstr(blk, iarg--, (Instr){Osub, KPTR, .keep=1, .reg = SP+1, .l=mkref(RREG,SP), .r=disp});
++*curi;
- insertinstr(blk, *curi+1, (Instr){Oadd, KPTR, .keep=1, .reg = SP+1, .l=mkref(RREG,SP), disp});
+ insertinstr(blk, *curi+1, (Instr){Oadd, KPTR, .keep=1, .reg = SP+1, .l=mkref(RREG,SP), .r=disp});
}
if (isimm32(ins->l))
ins->l = mkaddr((IRAddr){.base = ins->l});
else if (isintcon(ins->l))
- ins->l = insertinstr(blk, (*curi)++, mkinstr(Ocopy, KPTR, ins->l));
+ ins->l = insertinstr(blk, (*curi)++, mkinstr1(Ocopy, KPTR, ins->l));
cls = ins->cls;
ins->cls = 0;
if (cls) {
/* duplicate to reuse same TMP ref */
insertinstr(blk, (*curi)++, *ins);
- *ins = mkinstr(Ocopy, cls, mkref(RREG, call->abiret[0].reg));
+ *ins = mkinstr1(Ocopy, cls, mkref(RREG, call->abiret[0].reg));
for (int i = 1; i <= 2; ++i) {
if (*curi + i >= blk->ins.n) break;
if (instrtab[blk->ins.p[*curi + i]].op == Ocall2r) {
ins = &instrtab[blk->ins.p[*curi += i]];
- *ins = mkinstr(Ocopy, ins->cls, mkref(RREG, call->abiret[1].reg));
+ *ins = mkinstr1(Ocopy, ins->cls, mkref(RREG, call->abiret[1].reg));
break;
}
}
@@ -280,7 +280,7 @@ aadd(IRAddr *addr, Block *blk, int *curi, Ref r, uint siz/*1,2,4,8*/)
if (!rstest(mctarg->rglob, r.i)) return 0;
Ref:
if (r.t == RSTACK && (addr->base.bits || addr->index.bits)) {
- r = insertinstr(blk, (*curi)++, mkinstr(Oadd, KPTR, mkref(RREG, FP), mkref(RICON, -r.i)));
+ r = insertinstr(blk, (*curi)++, mkinstr2(Oadd, KPTR, mkref(RREG, FP), mkref(RICON, -r.i)));
}
if (!addr->base.bits) addr->base = r;
else if (!addr->index.bits) addr->index = r;
@@ -304,9 +304,9 @@ fuseaddr(Ref *r, Block *blk, int *curi, uint siz/*1,2,4,8*/)
if (isaddrcon(addr.base,0) && (!(contab.p[addr.base.i].flag & SLOCAL) || addr.index.bits)) {
/* first load symbol address into a temp register */
if (addr.disp && (ccopt.pic || (contab.p[addr.base.i].flag & SFUNC)) && !addr.index.bits) {
- addr.base = insertinstr(blk, (*curi)++, mkinstr(Ocopy, KPTR, .l = addr.base));
+ addr.base = insertinstr(blk, (*curi)++, mkinstr1(Ocopy, KPTR, addr.base));
} else {
- addr.base = insertinstr(blk, (*curi)++, mkinstr(Ocopy, KPTR,
+ addr.base = insertinstr(blk, (*curi)++, mkinstr1(Ocopy, KPTR,
mkaddr((IRAddr){addr.base, .disp = addr.disp})));
addr.disp = 0;
}
@@ -344,7 +344,7 @@ loadstoreaddr(Block *blk, Ref *r, int *curi, enum op op)
} else if (r->t == RTMP || r->t == RSTACK) {
fuseaddr(r, blk, curi, siz);
} else if (r->t != RREG) {
- *r = insertinstr(blk, (*curi)++, mkinstr(Ocopy, KPTR, *r));
+ *r = insertinstr(blk, (*curi)++, mkinstr1(Ocopy, KPTR, *r));
}
}
@@ -371,9 +371,9 @@ sel(Function *fn, Instr *ins, Block *blk, int *curi)
case Oparam:
assert(ins->l.t == RICON && ins->l.i < fn->nabiarg);
if (!fn->abiarg[ins->l.i].isstk)
- *ins = mkinstr(Ocopy, ins->cls, mkref(RREG, fn->abiarg[ins->l.i].reg));
+ *ins = mkinstr1(Ocopy, ins->cls, mkref(RREG, fn->abiarg[ins->l.i].reg));
else /* stack */
- *ins = mkinstr(Oadd, KPTR, mkref(RREG, FP), mkref(RICON, 16+fn->abiarg[ins->l.i].stk));
+ *ins = mkinstr2(Oadd, KPTR, mkref(RREG, FP), mkref(RICON, 16+fn->abiarg[ins->l.i].stk));
break;
case Oneg: case Onot:
case Ocvtf32s: case Ocvtf32u:
@@ -456,12 +456,12 @@ seljmp(Function *fn, Block *blk)
enum irclass cls = c.t == RICON ? KI32 : c.t == RXCON && contab.p[c.i].cls ? contab.p[c.i].cls : KPTR;
int curi = blk->ins.n;
- c = insertinstr(blk, blk->ins.n, mkinstr(Ocopy, cls, c));
+ c = insertinstr(blk, blk->ins.n, mkinstr1(Ocopy, cls, c));
sel(fn, &instrtab[c.i], blk, &curi);
}
if (!oiscmp(instrtab[c.i].op)) {
enum irclass k = insrescls(instrtab[c.i]);
- blk->jmp.arg[0] = insertinstr(blk, blk->ins.n, mkinstr(Oneq, k, c, kisint(k) ? ZEROREF : mkfltcon(k, 0)));
+ blk->jmp.arg[0] = insertinstr(blk, blk->ins.n, mkinstr2(Oneq, k, c, kisint(k) ? ZEROREF : mkfltcon(k, 0)));
Instr *ins = &instrtab[blk->jmp.arg[0].i];
ins->keep = 1;
} else {
@@ -470,13 +470,13 @@ seljmp(Function *fn, Block *blk)
} else if (blk->jmp.t == Jret) {
if (blk->jmp.arg[0].bits) {
Ref r = mkref(RREG, fn->abiret[0].reg);
- Instr *ins = &instrtab[insertinstr(blk, blk->ins.n, mkinstr(Omove, fn->abiret[0].ty.cls, r, blk->jmp.arg[0])).i];
+ Instr *ins = &instrtab[insertinstr(blk, blk->ins.n, mkinstr2(Omove, fn->abiret[0].ty.cls, r, blk->jmp.arg[0])).i];
int curi = blk->ins.n-1;
fixarg(&ins->r, ins, blk, &curi);
blk->jmp.arg[0] = r;
if (blk->jmp.arg[1].bits) {
r = mkref(RREG, fn->abiret[1].reg);
- ins = &instrtab[insertinstr(blk, blk->ins.n, mkinstr(Omove, fn->abiret[1].ty.cls, r, blk->jmp.arg[1])).i];
+ ins = &instrtab[insertinstr(blk, blk->ins.n, mkinstr2(Omove, fn->abiret[1].ty.cls, r, blk->jmp.arg[1])).i];
}
}
}
diff --git a/src/t_x86-64_isel.c b/src/t_x86-64_isel.c
index ac3950c..d4a22d4 100644
--- a/src/t_x86-64_isel.c
+++ b/src/t_x86-64_isel.c
@@ -40,7 +40,7 @@ static const uchar opflags[NOPER] = {
static int iflagsrc = -1;
-#define inscopy(blk, pcuri, k, r) insertinstr((blk), (*(pcuri))++, mkinstr(Ocopy, k, .l = (r)))
+#define inscopy(blk, pcuri, k, r) insertinstr((blk), (*(pcuri))++, mkinstr1(Ocopy, k, (r)))
static void
picfixsym(Ref *r, Block *blk, int *curi)
{
@@ -110,7 +110,7 @@ Begin:
ShiftImm: /* shift immediate is always 8bit */
*r = mkref(RICON, sh & 255);
} else if (r->t == RSTACK) {
- Instr adr = mkinstr(Oadd, KPTR, mkref(RREG, RBP), mkintcon(KI32, -r->i));
+ Instr adr = mkinstr2(Oadd, KPTR, mkref(RREG, RBP), mkintcon(KI32, -r->i));
if (op == Ocopy)
*ins = adr;
else
@@ -143,28 +143,28 @@ selcall(Function *fn, Instr *ins, Block *blk, int *curi)
if (!abi.isstk) {
assert(!abi.ty.isagg);
- *arg = mkinstr(Omove, call->abiarg[i].ty.cls, mkref(RREG, abi.reg), arg->r);
+ *arg = mkinstr2(Omove, call->abiarg[i].ty.cls, mkref(RREG, abi.reg), arg->r);
if (abi.reg >= XMM0) ++nsse;
} else {
Ref adr = mkaddr((IRAddr){mkref(RREG, RSP), .disp = abi.stk});
int iargsave = iarg;
if (!abi.ty.isagg) { /* scalar arg in stack */
- *arg = mkinstr(cls2store[abi.ty.cls], 0, adr, arg->r);
+ *arg = mkinstr2(cls2store[abi.ty.cls], 0, adr, arg->r);
if (isaddrcon(arg->r,1) || arg->r.t == RADDR)
- arg->r = insertinstr(blk, iarg++, mkinstr(Ocopy, abi.ty.cls, arg->r));
+ arg->r = insertinstr(blk, iarg++, mkinstr1(Ocopy, abi.ty.cls, arg->r));
else
fixarg(&ins->r, ins, blk, &iarg);
} else { /* aggregate arg in stack, callee stack frame destination address */
- *arg = mkinstr(Ocopy, KPTR, adr);
+ *arg = mkinstr1(Ocopy, KPTR, adr);
}
*curi += iarg - iargsave;
}
}
if (call->argstksiz) {
Ref disp = mkref(RICON, argstksiz);
- insertinstr(blk, iarg--, (Instr){Osub, KPTR, .keep=1, .reg = RSP+1, .l=mkref(RREG,RSP), disp});
+ insertinstr(blk, iarg--, (Instr){Osub, KPTR, .keep=1, .reg = RSP+1, .l=mkref(RREG,RSP), .r=disp});
++*curi;
- insertinstr(blk, *curi+1, (Instr){Oadd, KPTR, .keep=1, .reg = RSP+1, .l=mkref(RREG,RSP), disp});
+ insertinstr(blk, *curi+1, (Instr){Oadd, KPTR, .keep=1, .reg = RSP+1, .l=mkref(RREG,RSP), .r=disp});
}
if (isimm32(ins->l))
ins->l = mkaddr((IRAddr){.base = ins->l});
@@ -173,19 +173,20 @@ selcall(Function *fn, Instr *ins, Block *blk, int *curi)
if (call->vararg >= 0) {
/* variadic calls write number of sse regs used to AL */
- insertinstr(blk, (*curi)++, mkinstr(Omove, KI32, mkref(RREG, RAX), mkref(RICON, nsse), .keep=1));
+ insertinstr(blk, (*curi)++,
+ (Instr){Omove, KI32, .keep = 1, .l = mkref(RREG, RAX), .r = mkref(RICON, nsse)});
}
cls = ins->cls;
ins->cls = 0;
if (cls) {
/* duplicate to reuse same TMP ref */
insertinstr(blk, (*curi)++, *ins);
- *ins = mkinstr(Ocopy, cls, mkref(RREG, call->abiret[0].reg));
+ *ins = mkinstr1(Ocopy, cls, mkref(RREG, call->abiret[0].reg));
for (int i = 1; i <= 2; ++i) {
if (*curi + i >= blk->ins.n) break;
if (instrtab[blk->ins.p[*curi + i]].op == Ocall2r) {
ins = &instrtab[blk->ins.p[*curi += i]];
- *ins = mkinstr(Ocopy, ins->cls, mkref(RREG, call->abiret[1].reg));
+ *ins = mkinstr1(Ocopy, ins->cls, mkref(RREG, call->abiret[1].reg));
break;
}
}
@@ -239,7 +240,7 @@ aadd(IRAddr *out, Block *blk, int *curi, Ref r, bool recurring)
{
if (r.t == RSTACK) {
if (out->base.bits || !aimm(out, -r.i)) {
- r = insertinstr(blk, (*curi)++, mkinstr(Oadd, KPTR, mkref(RREG, RBP), mkref(RICON, -r.i)));
+ r = insertinstr(blk, (*curi)++, mkinstr2(Oadd, KPTR, mkref(RREG, RBP), mkref(RICON, -r.i)));
goto Ref;
}
out->base = mkref(RREG, RBP);
@@ -344,7 +345,7 @@ loadstoreaddr(Block *blk, Ref *r, int *curi)
} else if (r->t == RSTACK || (r->t == RTMP && addarg4addrp(*r))) {
fuseaddr(r, blk, curi);
} else if (r->t != RREG) {
- *r = insertinstr(blk, (*curi)++, mkinstr(Ocopy, KPTR, *r));
+ *r = insertinstr(blk, (*curi)++, mkinstr1(Ocopy, KPTR, *r));
}
}
@@ -355,7 +356,7 @@ arithfold(Instr *ins)
Ref r;
bool ok = ins->r.t ? foldbinop(&r, ins->op, ins->cls, ins->l, ins->r) : foldunop(&r, ins->op, ins->cls, ins->l);
if (ok) {
- *ins = mkinstr(Ocopy, insrescls(*ins), r);
+ *ins = mkinstr1(Ocopy, insrescls(*ins), r);
return 1;
}
}
@@ -383,9 +384,9 @@ sel(Function *fn, Instr *ins, Block *blk, int *curi)
case Oparam:
assert(ins->l.t == RICON && ins->l.i < fn->nabiarg);
if (!fn->abiarg[ins->l.i].isstk)
- *ins = mkinstr(Ocopy, ins->cls, mkref(RREG, fn->abiarg[ins->l.i].reg));
+ *ins = mkinstr1(Ocopy, ins->cls, mkref(RREG, fn->abiarg[ins->l.i].reg));
else /* stack */
- *ins = mkinstr(Oadd, KPTR, mkref(RREG, RBP), mkref(RICON, 16+fn->abiarg[ins->l.i].stk));
+ *ins = mkinstr2(Oadd, KPTR, mkref(RREG, RBP), mkref(RICON, 16+fn->abiarg[ins->l.i].stk));
break;
case Oarg:
fixarg(&ins->r, ins, blk, curi);
@@ -398,7 +399,7 @@ sel(Function *fn, Instr *ins, Block *blk, int *curi)
case Oshl: case Osar: case Oslr:
if (!isintcon(ins->r)) {
/* shift amount register is always CL */
- insertinstr(blk, (*curi)++, mkinstr(Omove, KI32, mkref(RREG, RCX), ins->r));
+ insertinstr(blk, (*curi)++, mkinstr2(Omove, KI32, mkref(RREG, RCX), ins->r));
ins->r = mkref(RREG, RCX);
}
goto ALU;
@@ -422,17 +423,17 @@ sel(Function *fn, Instr *ins, Block *blk, int *curi)
/* TODO fuse div/rem pair */
/* (I)DIV dividend is always in RDX:RAX, output also in those regs */
- insertinstr(blk, (*curi)++, mkinstr(Omove, ins->cls, mkref(RREG, RAX), ins->l));
+ insertinstr(blk, (*curi)++, mkinstr2(Omove, ins->cls, mkref(RREG, RAX), ins->l));
/* mark RDX as clobbered. sign/zero-extending RAX into RDX is handled in emit() */
- insertinstr(blk, (*curi)++, mkinstr(Omove, ins->cls, mkref(RREG, RDX), mkref(RREG, RDX)));
+ insertinstr(blk, (*curi)++, mkinstr2(Omove, ins->cls, mkref(RREG, RDX), mkref(RREG, RDX)));
fixarg(&ins->r, ins, blk, curi); /* make sure rhs is memory or reg */
ins->l = mkref(RREG, RAX);
ins->keep = 1;
if (op == Orem) ins->op = Odiv;
else if (op == Ourem) ins->op = Oudiv;
insertinstr(blk, (*curi)++, *ins); /* duplicate ins to reuse tmp ref */
- *ins = mkinstr(Ocopy, ins->cls, mkref(RREG, op < Orem ? RAX : RDX)); /* get output */
- temp = mkinstr(Ocopy, ins->cls, mkref(RREG, op < Orem ? RDX : RAX)); /* clobber other reg*/
+ *ins = mkinstr1(Ocopy, ins->cls, mkref(RREG, op < Orem ? RAX : RDX)); /* get output */
+ temp = mkinstr1(Ocopy, ins->cls, mkref(RREG, op < Orem ? RDX : RAX)); /* clobber other reg*/
insertinstr(blk, ++(*curi), temp);
/* swap instrs so that clobber goes first */
t = blk->ins.p[*curi - 1];
@@ -461,7 +462,7 @@ sel(Function *fn, Instr *ins, Block *blk, int *curi)
if (kisint(ins->cls) && (addarg4addrp(ins->l) || addarg4addrp(ins->r))) {
Ref it = mkref(RTMP, ins - instrtab);
if (fuseaddr(&it, blk, curi)) {
- *ins = mkinstr(Ocopy, ins->cls, it);
+ *ins = mkinstr1(Ocopy, ins->cls, it);
break;
}
}
@@ -490,7 +491,7 @@ sel(Function *fn, Instr *ins, Block *blk, int *curi)
ins->inplace = 1;
if (iscon(ins->l) || ins->l.t == RSTACK) {
fixarg(&ins->l, ins, blk, curi);
- ins->l = insertinstr(blk, (*curi)++, mkinstr(Ocopy, ins->cls, ins->l));
+ ins->l = insertinstr(blk, (*curi)++, mkinstr1(Ocopy, ins->cls, ins->l));
}
if (ins->r.bits)
case Omove:
@@ -505,19 +506,19 @@ sel(Function *fn, Instr *ins, Block *blk, int *curi)
case Ostorei8: case Ostorei16: case Ostorei32: case Ostorei64: case Ostoref32: case Ostoref64:
loadstoreaddr(blk, &ins->l, curi);
if (isaddrcon(ins->r,1) || ins->r.t == RADDR)
- ins->r = insertinstr(blk, (*curi)++, mkinstr(Ocopy, KPTR, ins->r));
+ ins->r = insertinstr(blk, (*curi)++, mkinstr1(Ocopy, KPTR, ins->r));
else
fixarg(&ins->r, ins, blk, curi);
break;
case Ocvtu32f:
fixarg(&ins->l, ins, blk, curi);
- ins->l = insertinstr(blk, (*curi)++, mkinstr(Oextu32, KI64, ins->l));
+ ins->l = insertinstr(blk, (*curi)++, mkinstr1(Oextu32, KI64, ins->l));
ins->op = Ocvts64f;
break;
case Ocvtf32u: case Ocvtf64u:
fixarg(&ins->l, ins, blk, curi);
if (ins->cls == KI32) {
- ins->l = insertinstr(blk, (*curi)++, mkinstr(ins->op == Ocvtf32u ? Ocvtf32s : Ocvtf64s, KI64, ins->l));
+ ins->l = insertinstr(blk, (*curi)++, mkinstr1(ins->op == Ocvtf32u ? Ocvtf32s : Ocvtf64s, KI64, ins->l));
ins->op = Oextu32;
} else assert(!"nyi flt -> u64");
break;
@@ -546,7 +547,7 @@ sel(Function *fn, Instr *ins, Block *blk, int *curi)
case Obswap16: case Obswap32: case Obswap64:
ins->inplace = 1;
if (ins->l.t != RTMP) {
- ins->l = insertinstr(blk, *curi, mkinstr(Ocopy, ins->cls, ins->l));
+ ins->l = insertinstr(blk, *curi, mkinstr1(Ocopy, ins->cls, ins->l));
fixarg(&instrtab[ins->l.i].l, ins, blk, curi);
++*curi;
}
@@ -575,7 +576,7 @@ seljmp(Function *fn, Block *blk)
enum irclass cls = c.t == RICON ? KI32 : c.t == RXCON && contab.p[c.i].cls ? contab.p[c.i].cls : KPTR;
int curi = blk->ins.n;
- c = insertinstr(blk, blk->ins.n, mkinstr(Ocopy, cls, c));
+ c = insertinstr(blk, blk->ins.n, mkinstr1(Ocopy, cls, c));
sel(fn, &instrtab[c.i], blk, &curi);
}
if (iflagsrc == c.i /* test cmp */
@@ -585,10 +586,10 @@ seljmp(Function *fn, Block *blk)
if (kisflt(instrtab[c.i].cls) || !(opflags[instrtab[c.i].op] & ZF) || blk->ins.n == 0 || c.i != blk->ins.p[blk->ins.n - 1]) {
Instr *ins;
int curi = blk->ins.n;
- blk->jmp.arg[0] = insertinstr(blk, blk->ins.n, mkinstr(Oneq, insrescls(instrtab[c.i]), c, ZEROREF));
+ blk->jmp.arg[0] = insertinstr(blk, blk->ins.n, mkinstr2(Oneq, insrescls(instrtab[c.i]), c, ZEROREF));
ins = &instrtab[blk->jmp.arg[0].i];
if (kisflt(ins->cls)) {
- ins->r = insertinstr(blk, curi, mkinstr(Ocopy, ins->cls, ZEROREF));
+ ins->r = insertinstr(blk, curi, mkinstr1(Ocopy, ins->cls, ZEROREF));
}
ins->keep = 1;
} else if (instrtab[c.i].op == Oadd) {
@@ -600,13 +601,13 @@ seljmp(Function *fn, Block *blk)
if (blk->jmp.arg[0].bits) {
int curi;
Ref r = mkref(RREG, fn->abiret[0].reg);
- Instr *ins = &instrtab[insertinstr(blk, blk->ins.n, mkinstr(Omove, fn->abiret[0].ty.cls, r, blk->jmp.arg[0])).i];
+ Instr *ins = &instrtab[insertinstr(blk, blk->ins.n, mkinstr2(Omove, fn->abiret[0].ty.cls, r, blk->jmp.arg[0])).i];
curi = blk->ins.n-1;
fixarg(&ins->r, ins, blk, &curi);
blk->jmp.arg[0] = r;
if (blk->jmp.arg[1].bits) {
r = mkref(RREG, fn->abiret[1].reg);
- ins = &instrtab[insertinstr(blk, blk->ins.n, mkinstr(Omove, fn->abiret[1].ty.cls, r, blk->jmp.arg[1])).i];
+ ins = &instrtab[insertinstr(blk, blk->ins.n, mkinstr2(Omove, fn->abiret[1].ty.cls, r, blk->jmp.arg[1])).i];
curi = blk->ins.n-1;
fixarg(&ins->r, ins, blk, &curi);
blk->jmp.arg[1] = r;
diff --git a/src/t_x86-64_sysv.c b/src/t_x86-64_sysv.c
index 6477af2..852aa24 100644
--- a/src/t_x86-64_sysv.c
+++ b/src/t_x86-64_sysv.c
@@ -179,7 +179,7 @@ vastart(Function *fn, Block *blk, int *curi)
assert(instrtab[rsave.i].op == Oalloca16);
} else {
rsave = insertinstr(fn->entry, 0, mkalloca(192, 16));
- insertinstr(fn->entry, 1, mkinstr(Oxvaprologue, 0, rsave, .keep=1));
+ insertinstr(fn->entry, 1, (Instr){Oxvaprologue, 0, .keep=1, .l=rsave});
}
/* find first unnamed gpr and fpr */
for (int i = 0; i < fn->nabiarg; ++i) {
@@ -192,19 +192,19 @@ vastart(Function *fn, Block *blk, int *curi)
}
}
/* set ap->reg_save_area */
- *ins = mkinstr(Oadd, KPTR, ap, mkref(RICON, 16));
+ *ins = mkinstr2(Oadd, KPTR, ap, mkref(RICON, 16));
dst = mkref(RTMP, ins - instrtab);
int i = *curi + 1;
- insertinstr(blk, i++, mkinstr(Ostorei64, 0, dst, rsave));
+ insertinstr(blk, i++, mkinstr2(Ostorei64, 0, dst, rsave));
/* set ap->overflow_arg_area */
- src = insertinstr(blk, i++, mkinstr(Oadd, KPTR, mkref(RREG, RBP), mkref(RICON, 16+stk0)));
- dst = insertinstr(blk, i++, mkinstr(Oadd, KPTR, ap, mkref(RICON, 8)));
- insertinstr(blk, i++, mkinstr(Ostorei64, 0, dst, src));
+ src = insertinstr(blk, i++, mkinstr2(Oadd, KPTR, mkref(RREG, RBP), mkref(RICON, 16+stk0)));
+ dst = insertinstr(blk, i++, mkinstr2(Oadd, KPTR, ap, mkref(RICON, 8)));
+ insertinstr(blk, i++, mkinstr2(Ostorei64, 0, dst, src));
/* set ap->gp_offset */
- insertinstr(blk, i++, mkinstr(Ostorei32, 0, ap, mkref(RICON, gpr0*8)));
+ insertinstr(blk, i++, mkinstr2(Ostorei32, 0, ap, mkref(RICON, gpr0*8)));
/* set ap->fp_offset */
- dst = insertinstr(blk, i++, mkinstr(Oadd, KPTR, ap, mkref(RICON, 4)));
- insertinstr(blk, i++, mkinstr(Ostorei32, 0, dst, mkref(RICON, 6*8 + fpr0*16)));
+ dst = insertinstr(blk, i++, mkinstr2(Oadd, KPTR, ap, mkref(RICON, 4)));
+ insertinstr(blk, i++, mkinstr2(Ostorei32, 0, dst, mkref(RICON, 6*8 + fpr0*16)));
*curi = i-1;
}
@@ -231,9 +231,9 @@ vaarg(Function *fn, Block *blk, int *curi)
Ref phi, phiargs[2];
/* int: l->gp_offset < 48 - num_gp * 8 */
/* sse: l->fp_offset < 304 - num_gp * 16 (why 304? ... 176) */
- tmp = ni ? ap : insertinstr(blk, (*curi)++, mkinstr(Oadd, KPTR, ap, mkref(RICON, 4)));
- tmp = insertinstr(blk, (*curi)++, mkinstr(Oloadu32, KI32, tmp));
- tmp = insertinstr(blk, (*curi)++, mkinstr(Oulte, KI32, tmp, mkref(RICON, ni ? 48 - ni*8 : 176 - nf*16)));
+ tmp = ni ? ap : insertinstr(blk, (*curi)++, mkinstr2(Oadd, KPTR, ap, mkref(RICON, 4)));
+ tmp = insertinstr(blk, (*curi)++, mkinstr1(Oloadu32, KI32, tmp));
+ tmp = insertinstr(blk, (*curi)++, mkinstr2(Oulte, KI32, tmp, mkref(RICON, ni ? 48 - ni*8 : 176 - nf*16)));
merge = blksplitafter(fn, blk, *curi);
blk->jmp.t = 0;
useblk(fn, blk);
@@ -241,12 +241,12 @@ vaarg(Function *fn, Block *blk, int *curi)
useblk(fn, blk->s1);
{
/* phi0: &l->reg_save_area[l->gp/fp_offset] */
- Ref sav = addinstr(fn, mkinstr(Oloadi64, KPTR, irbinop(fn, Oadd, KPTR, ap, mkref(RICON, 16))));
- Ref roff = addinstr(fn, mkinstr(Oloadu32, KI32, irbinop(fn, Oadd, KPTR, ap, mkref(RICON, ni ? 0 : 4))));
+ Ref sav = addinstr(fn, mkinstr1(Oloadi64, KPTR, irbinop(fn, Oadd, KPTR, ap, mkref(RICON, 16))));
+ Ref roff = addinstr(fn, mkinstr1(Oloadu32, KI32, irbinop(fn, Oadd, KPTR, ap, mkref(RICON, ni ? 0 : 4))));
phiargs[0] = irbinop(fn, Oadd, KPTR, sav, roff);
/* l->gp/fp_offset += num_gp/fp * 8(16) */
roff = irbinop(fn, Oadd, KI32, roff, mkref(RICON, ni ? ni * 8 : nf * 16));
- addinstr(fn, mkinstr(Ostorei32, 0, irbinop(fn, Oadd, KPTR, ap, mkref(RICON, ni ? 0 : 4)), roff));
+ addinstr(fn, mkinstr2(Ostorei32, 0, irbinop(fn, Oadd, KPTR, ap, mkref(RICON, ni ? 0 : 4)), roff));
assert(merge->npred == 1);
blkpred(merge, 0) = blk->s1;
blk->s1->jmp.t = Jb;
@@ -256,13 +256,13 @@ vaarg(Function *fn, Block *blk, int *curi)
{
/* phi1: l->overflow_arg_area */
Ref adr = irbinop(fn, Oadd, KPTR, ap, mkref(RICON, 8));
- Ref ovf = addinstr(fn, mkinstr(Oloadi64, KPTR, adr));
+ Ref ovf = addinstr(fn, mkinstr1(Oloadi64, KPTR, adr));
/* align no-op */
phiargs[1] = ovf;
/* update l->overflow_arg_area += size */
int siz = 8;
- addinstr(fn, mkinstr(Ostorei64, 0, adr, irbinop(fn, Oadd, KPTR, ovf, mkref(RICON, siz))));
+ addinstr(fn, mkinstr2(Ostorei64, 0, adr, irbinop(fn, Oadd, KPTR, ovf, mkref(RICON, siz))));
putbranch(fn, merge);
}
assert(merge->npred == 2);
@@ -272,11 +272,11 @@ vaarg(Function *fn, Block *blk, int *curi)
phi = insertphi(merge, KPTR);
memcpy(phitab.p[instrtab[phi.i].l.i], phiargs, sizeof phiargs);
if (!ty.isagg) {
- instrtab[var] = mkinstr(cls2load[cls[0]], cls[0], phi);
+ instrtab[var] = mkinstr1(cls2load[cls[0]], cls[0], phi);
} else {
instrtab[var] = mkalloca(8, 8);
- tmp = insertinstr(merge, 1, mkinstr(Oloadi64, KI64, phi));
- insertinstr(merge, 2, mkinstr(Ostorei64, 0, mkref(RTMP, var), tmp));
+ tmp = insertinstr(merge, 1, mkinstr1(Oloadi64, KI64, phi));
+ insertinstr(merge, 2, mkinstr2(Ostorei64, 0, mkref(RTMP, var), tmp));
}
fn->prop &= ~FNUSE;
} else {
generated by cgit v1.2.3 (git 2.39.1) at 2026-05-01 21:14:31 +0000