separated i386 code generator
This commit is contained in:
bellard
parent
9cebd0617f
commit
3917389449
1 changed files with 531 additions and 0 deletions
531
i386-gen.c
Normal file
531
i386-gen.c
Normal file
|
|
@ -0,0 +1,531 @@
|
||||||
|
/******************************************************/
|
||||||
|
/* X86 code generator */
|
||||||
|
|
||||||
|
|
||||||
|
/* number of available registers */
|
||||||
|
#define NB_REGS 4
|
||||||
|
|
||||||
|
#define NB_REG_CLASSES 2
|
||||||
|
|
||||||
|
/* a register can belong to several classes */
|
||||||
|
#define REG_CLASS_INT 0x0001
|
||||||
|
#define REG_CLASS_FLOAT 0x0002
|
||||||
|
|
||||||
|
/* pretty names for the registers */
|
||||||
|
enum {
|
||||||
|
REG_EAX = 0,
|
||||||
|
REG_ECX,
|
||||||
|
REG_EDX,
|
||||||
|
REG_ST0,
|
||||||
|
};
|
||||||
|
|
||||||
|
int reg_classes[NB_REGS] = {
|
||||||
|
REG_CLASS_INT, /* eax */
|
||||||
|
REG_CLASS_INT, /* ecx */
|
||||||
|
REG_CLASS_INT, /* edx */
|
||||||
|
REG_CLASS_FLOAT, /* st0 */
|
||||||
|
};
|
||||||
|
|
||||||
|
/* integer return register for functions */
|
||||||
|
#define FUNC_RET_REG 0
|
||||||
|
/* float return register for functions */
|
||||||
|
#define FUNC_RET_FREG 3
|
||||||
|
|
||||||
|
/* defined if function parameters must be evaluated in reverse order */
|
||||||
|
#define INVERT_FUNC_PARAMS
|
||||||
|
|
||||||
|
/* defined if structures are passed as pointers. Otherwise structures
|
||||||
|
are directly pushed on stack. */
|
||||||
|
//#define FUNC_STRUCT_PARAM_AS_PTR
|
||||||
|
|
||||||
|
/* function call context */
|
||||||
|
typedef struct GFuncContext {
|
||||||
|
int args_size;
|
||||||
|
} GFuncContext;
|
||||||
|
|
||||||
|
/******************************************************/
|
||||||
|
|
||||||
|
void g(int c)
|
||||||
|
{
|
||||||
|
*(char *)ind++ = c;
|
||||||
|
}
|
||||||
|
|
||||||
|
void o(int c)
|
||||||
|
{
|
||||||
|
while (c) {
|
||||||
|
g(c);
|
||||||
|
c = c / 256;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void gen_le32(int c)
|
||||||
|
{
|
||||||
|
g(c);
|
||||||
|
g(c >> 8);
|
||||||
|
g(c >> 16);
|
||||||
|
g(c >> 24);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* add a new relocation entry to symbol 's' */
|
||||||
|
void greloc(Sym *s, int addr, int type)
|
||||||
|
{
|
||||||
|
Reloc *p;
|
||||||
|
p = malloc(sizeof(Reloc));
|
||||||
|
if (!p)
|
||||||
|
error("memory full");
|
||||||
|
p->type = type;
|
||||||
|
p->addr = addr;
|
||||||
|
p->next = (Reloc *)s->c;
|
||||||
|
s->c = (int)p;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* patch each relocation entry with value 'val' */
|
||||||
|
void greloc_patch(Sym *s, int val)
|
||||||
|
{
|
||||||
|
Reloc *p, *p1;
|
||||||
|
|
||||||
|
p = (Reloc *)s->c;
|
||||||
|
while (p != NULL) {
|
||||||
|
p1 = p->next;
|
||||||
|
switch(p->type) {
|
||||||
|
case RELOC_ADDR32:
|
||||||
|
*(int *)p->addr = val;
|
||||||
|
break;
|
||||||
|
case RELOC_REL32:
|
||||||
|
*(int *)p->addr = val - p->addr - 4;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
free(p);
|
||||||
|
p = p1;
|
||||||
|
}
|
||||||
|
s->c = val;
|
||||||
|
s->t &= ~VT_FORWARD;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* output a symbol and patch all calls to it */
|
||||||
|
void gsym_addr(t, a)
|
||||||
|
{
|
||||||
|
int n;
|
||||||
|
while (t) {
|
||||||
|
n = *(int *)t; /* next value */
|
||||||
|
*(int *)t = a - t - 4;
|
||||||
|
t = n;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void gsym(t)
|
||||||
|
{
|
||||||
|
gsym_addr(t, ind);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* psym is used to put an instruction with a data field which is a
|
||||||
|
reference to a symbol. It is in fact the same as oad ! */
|
||||||
|
#define psym oad
|
||||||
|
|
||||||
|
/* instruction + 4 bytes data. Return the address of the data */
|
||||||
|
int oad(int c, int s)
|
||||||
|
{
|
||||||
|
o(c);
|
||||||
|
*(int *)ind = s;
|
||||||
|
s = ind;
|
||||||
|
ind = ind + 4;
|
||||||
|
return s;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* output constant with relocation if 't & VT_FORWARD' is true */
|
||||||
|
void gen_addr32(int c, int t)
|
||||||
|
{
|
||||||
|
if (!(t & VT_FORWARD)) {
|
||||||
|
gen_le32(c);
|
||||||
|
} else {
|
||||||
|
greloc((Sym *)c, ind, RELOC_ADDR32);
|
||||||
|
gen_le32(0);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* XXX: generate correct pointer for forward references to functions */
|
||||||
|
/* r = (ft, fc) */
|
||||||
|
void load(int r, int ft, int fc)
|
||||||
|
{
|
||||||
|
int v, t;
|
||||||
|
|
||||||
|
v = ft & VT_VALMASK;
|
||||||
|
if (ft & VT_LVAL) {
|
||||||
|
if (v == VT_LLOCAL) {
|
||||||
|
load(r, VT_LOCAL | VT_LVAL, fc);
|
||||||
|
v = r;
|
||||||
|
}
|
||||||
|
if ((ft & VT_BTYPE) == VT_FLOAT) {
|
||||||
|
o(0xd9); /* flds */
|
||||||
|
r = 0;
|
||||||
|
} else if ((ft & VT_BTYPE) == VT_DOUBLE) {
|
||||||
|
o(0xdd); /* fldl */
|
||||||
|
r = 0;
|
||||||
|
} else if ((ft & VT_TYPE) == VT_BYTE)
|
||||||
|
o(0xbe0f); /* movsbl */
|
||||||
|
else if ((ft & VT_TYPE) == (VT_BYTE | VT_UNSIGNED))
|
||||||
|
o(0xb60f); /* movzbl */
|
||||||
|
else if ((ft & VT_TYPE) == VT_SHORT)
|
||||||
|
o(0xbf0f); /* movswl */
|
||||||
|
else if ((ft & VT_TYPE) == (VT_SHORT | VT_UNSIGNED))
|
||||||
|
o(0xb70f); /* movzwl */
|
||||||
|
else
|
||||||
|
o(0x8b); /* movl */
|
||||||
|
|
||||||
|
if (v == VT_CONST) {
|
||||||
|
o(0x05 + r * 8); /* 0xXX, r */
|
||||||
|
gen_addr32(fc, ft);
|
||||||
|
} else if (v == VT_LOCAL) {
|
||||||
|
oad(0x85 + r * 8, fc); /* xx(%ebp), r */
|
||||||
|
} else {
|
||||||
|
g(0x00 + r * 8 + v); /* (v), r */
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
if (v == VT_CONST) {
|
||||||
|
o(0xb8 + r); /* mov $xx, r */
|
||||||
|
gen_addr32(fc, ft);
|
||||||
|
} else if (v == VT_LOCAL) {
|
||||||
|
o(0x8d);
|
||||||
|
oad(0x85 + r * 8, fc); /* lea xxx(%ebp), r */
|
||||||
|
} else if (v == VT_CMP) {
|
||||||
|
oad(0xb8 + r, 0); /* mov $0, r */
|
||||||
|
o(0x0f); /* setxx %br */
|
||||||
|
o(fc);
|
||||||
|
o(0xc0 + r);
|
||||||
|
} else if (v == VT_JMP || v == VT_JMPI) {
|
||||||
|
t = v & 1;
|
||||||
|
oad(0xb8 + r, t); /* mov $1, r */
|
||||||
|
oad(0xe9, 5); /* jmp after */
|
||||||
|
gsym(fc);
|
||||||
|
oad(0xb8 + r, t ^ 1); /* mov $0, r */
|
||||||
|
} else if (v != r) {
|
||||||
|
o(0x89);
|
||||||
|
o(0xc0 + r + v * 8); /* mov v, r */
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* (ft, fc) = r */
|
||||||
|
/* WARNING: r must not be allocated on the stack */
|
||||||
|
void store(r, ft, fc)
|
||||||
|
{
|
||||||
|
int fr, bt;
|
||||||
|
|
||||||
|
fr = ft & VT_VALMASK;
|
||||||
|
bt = ft & VT_BTYPE;
|
||||||
|
/* XXX: incorrect if reg to reg */
|
||||||
|
if (bt == VT_FLOAT) {
|
||||||
|
o(0xd9); /* fstps */
|
||||||
|
r = 3;
|
||||||
|
} else if (bt == VT_DOUBLE) {
|
||||||
|
o(0xdd); /* fstpl */
|
||||||
|
r = 3;
|
||||||
|
} else {
|
||||||
|
if (bt == VT_SHORT)
|
||||||
|
o(0x66);
|
||||||
|
if (bt == VT_BYTE)
|
||||||
|
o(0x88);
|
||||||
|
else
|
||||||
|
o(0x89);
|
||||||
|
}
|
||||||
|
if (fr == VT_CONST) {
|
||||||
|
o(0x05 + r * 8); /* mov r,xxx */
|
||||||
|
gen_addr32(fc, ft);
|
||||||
|
} else if (fr == VT_LOCAL) {
|
||||||
|
oad(0x85 + r * 8, fc); /* mov r,xxx(%ebp) */
|
||||||
|
} else if (ft & VT_LVAL) {
|
||||||
|
g(fr + r * 8); /* mov r, (fr) */
|
||||||
|
} else if (fr != r) {
|
||||||
|
o(0xc0 + fr + r * 8); /* mov r, fr */
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* start function call and return function call context */
|
||||||
|
void gfunc_start(GFuncContext *c)
|
||||||
|
{
|
||||||
|
c->args_size = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* push function parameter which is in (vt, vc) */
|
||||||
|
void gfunc_param(GFuncContext *c)
|
||||||
|
{
|
||||||
|
int size, align, ft, fc, r;
|
||||||
|
|
||||||
|
if ((vt & (VT_BTYPE | VT_LVAL)) == (VT_STRUCT | VT_LVAL)) {
|
||||||
|
size = type_size(vt, &align);
|
||||||
|
/* align to stack align size */
|
||||||
|
size = (size + 3) & ~3;
|
||||||
|
/* allocate the necessary size on stack */
|
||||||
|
oad(0xec81, size); /* sub $xxx, %esp */
|
||||||
|
/* generate structure store */
|
||||||
|
r = get_reg(REG_CLASS_INT);
|
||||||
|
o(0x89); /* mov %esp, r */
|
||||||
|
o(0xe0 + r);
|
||||||
|
ft = vt;
|
||||||
|
fc = vc;
|
||||||
|
vset(VT_INT | r, 0);
|
||||||
|
vpush();
|
||||||
|
vt = ft;
|
||||||
|
vc = fc;
|
||||||
|
vstore();
|
||||||
|
c->args_size += size;
|
||||||
|
} else if ((vt & VT_BTYPE) == VT_DOUBLE ||
|
||||||
|
(vt & VT_BTYPE) == VT_FLOAT) {
|
||||||
|
gv(); /* only one float register */
|
||||||
|
if ((vt & VT_BTYPE) == VT_FLOAT)
|
||||||
|
size = 4;
|
||||||
|
else
|
||||||
|
size = 8;
|
||||||
|
oad(0xec81, size); /* sub $xxx, %esp */
|
||||||
|
o(0x245cd9 + size - 4); /* fstp[s|l] 0(%esp) */
|
||||||
|
g(0x00);
|
||||||
|
c->args_size += 8;
|
||||||
|
} else {
|
||||||
|
/* simple type (currently always same size) */
|
||||||
|
/* XXX: implicit cast ? */
|
||||||
|
r = gv();
|
||||||
|
o(0x50 + r); /* push r */
|
||||||
|
c->args_size += 4;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* generate function call with address in (vt, vc) and free function
|
||||||
|
context */
|
||||||
|
void gfunc_call(GFuncContext *c)
|
||||||
|
{
|
||||||
|
int r;
|
||||||
|
if ((vt & (VT_VALMASK | VT_LVAL)) == VT_CONST) {
|
||||||
|
/* constant case */
|
||||||
|
/* forward reference */
|
||||||
|
if (vt & VT_FORWARD) {
|
||||||
|
greloc((Sym *)vc, ind + 1, RELOC_REL32);
|
||||||
|
oad(0xe8, 0);
|
||||||
|
} else {
|
||||||
|
oad(0xe8, vc - ind - 5);
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
/* otherwise, indirect call */
|
||||||
|
r = gv();
|
||||||
|
o(0xff); /* call *r */
|
||||||
|
o(0xd0 + r);
|
||||||
|
}
|
||||||
|
if (c->args_size)
|
||||||
|
oad(0xc481, c->args_size); /* add $xxx, %esp */
|
||||||
|
}
|
||||||
|
|
||||||
|
int gjmp(int t)
|
||||||
|
{
|
||||||
|
return psym(0xe9, t);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* generate a test. set 'inv' to invert test */
|
||||||
|
int gtst(int inv, int t)
|
||||||
|
{
|
||||||
|
int v, *p;
|
||||||
|
v = vt & VT_VALMASK;
|
||||||
|
if (v == VT_CMP) {
|
||||||
|
/* fast case : can jump directly since flags are set */
|
||||||
|
g(0x0f);
|
||||||
|
t = psym((vc - 16) ^ inv, t);
|
||||||
|
} else if (v == VT_JMP || v == VT_JMPI) {
|
||||||
|
/* && or || optimization */
|
||||||
|
if ((v & 1) == inv) {
|
||||||
|
/* insert vc jump list in t */
|
||||||
|
p = &vc;
|
||||||
|
while (*p != 0)
|
||||||
|
p = (int *)*p;
|
||||||
|
*p = t;
|
||||||
|
t = vc;
|
||||||
|
} else {
|
||||||
|
t = gjmp(t);
|
||||||
|
gsym(vc);
|
||||||
|
}
|
||||||
|
} else if ((vt & (VT_VALMASK | VT_LVAL)) == VT_CONST) {
|
||||||
|
/* constant jmp optimization */
|
||||||
|
if ((vc != 0) != inv)
|
||||||
|
t = gjmp(t);
|
||||||
|
} else {
|
||||||
|
v = gv();
|
||||||
|
o(0x85);
|
||||||
|
o(0xc0 + v * 9);
|
||||||
|
g(0x0f);
|
||||||
|
t = psym(0x85 ^ inv, t);
|
||||||
|
}
|
||||||
|
return t;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* generate an integer binary operation 'v = r op fr' instruction and
|
||||||
|
modifies (vt,vc) if needed */
|
||||||
|
void gen_opi(int op, int r, int fr)
|
||||||
|
{
|
||||||
|
int t;
|
||||||
|
if (op == '+') {
|
||||||
|
o(0x01);
|
||||||
|
o(0xc0 + r + fr * 8);
|
||||||
|
} else if (op == '-') {
|
||||||
|
o(0x29);
|
||||||
|
o(0xc0 + r + fr * 8);
|
||||||
|
} else if (op == '&') {
|
||||||
|
o(0x21);
|
||||||
|
o(0xc0 + r + fr * 8);
|
||||||
|
} else if (op == '^') {
|
||||||
|
o(0x31);
|
||||||
|
o(0xc0 + r + fr * 8);
|
||||||
|
} else if (op == '|') {
|
||||||
|
o(0x09);
|
||||||
|
o(0xc0 + r + fr * 8);
|
||||||
|
} else if (op == '*') {
|
||||||
|
o(0xaf0f); /* imul fr, r */
|
||||||
|
o(0xc0 + fr + r * 8);
|
||||||
|
} else if (op == TOK_SHL | op == TOK_SHR | op == TOK_SAR) {
|
||||||
|
/* op2 is %ecx */
|
||||||
|
if (fr != 1) {
|
||||||
|
if (r == 1) {
|
||||||
|
r = fr;
|
||||||
|
fr = 1;
|
||||||
|
o(0x87); /* xchg r, %ecx */
|
||||||
|
o(0xc1 + r * 8);
|
||||||
|
} else
|
||||||
|
move_reg(1, fr);
|
||||||
|
}
|
||||||
|
o(0xd3); /* shl/shr/sar %cl, r */
|
||||||
|
if (op == TOK_SHL)
|
||||||
|
o(0xe0 + r);
|
||||||
|
else if (op == TOK_SHR)
|
||||||
|
o(0xe8 + r);
|
||||||
|
else
|
||||||
|
o(0xf8 + r);
|
||||||
|
vt = (vt & VT_TYPE) | r;
|
||||||
|
} else if (op == '/' | op == TOK_UDIV | op == TOK_PDIV |
|
||||||
|
op == '%' | op == TOK_UMOD) {
|
||||||
|
save_reg(2); /* save edx */
|
||||||
|
t = save_reg_forced(fr); /* save fr and get op2 location */
|
||||||
|
move_reg(0, r); /* op1 is %eax */
|
||||||
|
if (op == TOK_UDIV | op == TOK_UMOD) {
|
||||||
|
o(0xf7d231); /* xor %edx, %edx, div t(%ebp), %eax */
|
||||||
|
oad(0xb5, t);
|
||||||
|
} else {
|
||||||
|
o(0xf799); /* cltd, idiv t(%ebp), %eax */
|
||||||
|
oad(0xbd, t);
|
||||||
|
}
|
||||||
|
if (op == '%' | op == TOK_UMOD)
|
||||||
|
r = 2;
|
||||||
|
else
|
||||||
|
r = 0;
|
||||||
|
vt = (vt & VT_TYPE) | r;
|
||||||
|
} else {
|
||||||
|
o(0x39);
|
||||||
|
o(0xc0 + r + fr * 8); /* cmp fr, r */
|
||||||
|
vset(VT_CMP, op);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* generate a floating point operation 'v = t1 op t2' instruction and
|
||||||
|
modifies (vt,vc) if needed */
|
||||||
|
/* NOTE: floats can only be lvalues */
|
||||||
|
void gen_opf(int op)
|
||||||
|
{
|
||||||
|
int a, ft, fc, swapped, r;
|
||||||
|
|
||||||
|
/* must put at least one value in the floating point register */
|
||||||
|
if ((vstack_ptr[-4] & VT_LVAL) &&
|
||||||
|
(vstack_ptr[-2] & VT_LVAL)) {
|
||||||
|
vswap();
|
||||||
|
vpop(&vt, &vc);
|
||||||
|
gv();
|
||||||
|
vpush();
|
||||||
|
vswap();
|
||||||
|
}
|
||||||
|
if (op >= TOK_EQ && op <= TOK_GT) {
|
||||||
|
/* load on stack second operand */
|
||||||
|
load(REG_ST0, vstack_ptr[-2], vstack_ptr[-1]);
|
||||||
|
if (op == TOK_GE || op == TOK_GT)
|
||||||
|
o(0xc9d9); /* fxch %st(1) */
|
||||||
|
o(0xe9da); /* fucompp */
|
||||||
|
o(0xe0df); /* fnstsw %ax */
|
||||||
|
if (op == TOK_EQ) {
|
||||||
|
o(0x45e480); /* and $0x45, %ah */
|
||||||
|
o(0x40fC80); /* cmp $0x40, %ah */
|
||||||
|
} else if (op == TOK_NE) {
|
||||||
|
o(0x45e480); /* and $0x45, %ah */
|
||||||
|
o(0x40f480); /* xor $0x40, %ah */
|
||||||
|
op = TOK_NE;
|
||||||
|
} else if (op == TOK_GE || op == TOK_LE) {
|
||||||
|
o(0x05c4f6); /* test $0x05, %ah */
|
||||||
|
op = TOK_EQ;
|
||||||
|
} else {
|
||||||
|
o(0x45c4f6); /* test $0x45, %ah */
|
||||||
|
op = TOK_EQ;
|
||||||
|
}
|
||||||
|
vstack_ptr[-4] = (vstack_ptr[-4] & VT_TYPE) | VT_CMP;
|
||||||
|
vstack_ptr[-3] = op;
|
||||||
|
} else {
|
||||||
|
/* swap the stack if needed so that t1 is the register and t2 is
|
||||||
|
the memory reference */
|
||||||
|
swapped = 0;
|
||||||
|
if (vstack_ptr[-4] & VT_LVAL) {
|
||||||
|
vswap();
|
||||||
|
swapped = 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
switch(op) {
|
||||||
|
default:
|
||||||
|
case '+':
|
||||||
|
a = 0;
|
||||||
|
break;
|
||||||
|
case '-':
|
||||||
|
a = 0x20;
|
||||||
|
if (swapped)
|
||||||
|
a += 8;
|
||||||
|
break;
|
||||||
|
case '*':
|
||||||
|
a = 0x08;
|
||||||
|
break;
|
||||||
|
case '/':
|
||||||
|
a = 0x30;
|
||||||
|
if (swapped)
|
||||||
|
a += 8;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
ft = vstack_ptr[-2];
|
||||||
|
fc = vstack_ptr[-1];
|
||||||
|
if ((ft & VT_BTYPE) == VT_DOUBLE)
|
||||||
|
o(0xdc);
|
||||||
|
else
|
||||||
|
o(0xd8);
|
||||||
|
|
||||||
|
r = ft & VT_VALMASK;
|
||||||
|
if (r == VT_CONST) {
|
||||||
|
o(0x05 + a);
|
||||||
|
gen_addr32(fc, ft);
|
||||||
|
} else if (r == VT_LOCAL) {
|
||||||
|
oad(0x85 + a, fc);
|
||||||
|
} else {
|
||||||
|
g(0x00 + a + r);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
vstack_ptr -= 2;
|
||||||
|
vpop(&vt, &vc);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* convert integers to floating point (float or double) */
|
||||||
|
void gen_cvtf(int t)
|
||||||
|
{
|
||||||
|
if ((vt & (VT_BTYPE | VT_UNSIGNED)) == (VT_INT | VT_UNSIGNED)) {
|
||||||
|
/* unsigned int to float/double */
|
||||||
|
o(0x6a); /* push $0 */
|
||||||
|
g(0x00);
|
||||||
|
o(0x50 + (vt & VT_VALMASK)); /* push r */
|
||||||
|
o(0x242cdf); /* fildll (%esp) */
|
||||||
|
o(0x08c483); /* add $8, %esp */
|
||||||
|
} else {
|
||||||
|
/* int to float/double */
|
||||||
|
o(0x50 + (vt & VT_VALMASK)); /* push r */
|
||||||
|
o(0x2404db); /* fildl (%esp) */
|
||||||
|
o(0x04c483); /* add $4, %esp */
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* end of X86 code generator */
|
||||||
|
/*************************************************************/
|
||||||
|
|
||||||
Loading…
Add table
Reference in a new issue