/*
 * 68K/386 32-bit C compiler.
 *
 * copyright (c) 1997, David Lindauer
 * 
 * This compiler is intended for educational use.  It may not be used
 * for profit without the express written consent of the author.
 *
 * It may be freely redistributed, as long as this notice remains intact
 * and either the original sources or derived sources 
 * are distributed along with any executables derived from the originals.
 *
 * The author is not responsible for any damages that may arise from use
 * of this software, either idirect or consequential.
 *
 * v1.35 March 1997
 * David Lindauer, gclind01@starbase.spd.louisville.edu
 *
 * Credits to Mathew Brandt for original K&R C compiler
 *
 */
#include        <stdio.h>
#include        "expr.h"
#include        "c.h"
#include        "gen386.h"
#include 				"diag.h"

/*
 *      this module contains all of the code generation routines
 *      for evaluating expressions and conditions.
 */
extern int stdinttype,stdunstype,stdintsize, stdldoublesize,stdaddrsize;
extern int stackadd,stackmod;
extern int prm_largedata, prm_linkreg;
extern AMODE     push[], pop[];
extern int prm_68020;
extern long framedepth, stackdepth;
extern int regs[3];
extern long nextlabel;
extern long lc_maxauto;
extern char regstack[],rsold[],rsodepth,rsdepth;
AMODE freg0[] = { { am_freg, 0 } };
AMODE sreg[] = { { am_dreg,4 } };

long bittab[32] = { 1,0x3,0x7,0xf,0x1f,0x3f,0x7f,0xff,
			0x1ff,0x3ff,0x7ff,0xfff,0x1fff,0x3fff,0x7fff,0xffff,
			0x1ffffL,0x3ffffL,0x7ffffL,0xfffffL,0x1fffffL,0x3fffffL,0x7fffffL,0xffffffL,
			0x1ffffffL,0x3ffffffL,0x7ffffffL,0xfffffffL,0x1fffffffL,0x3fffffffL,0x7fffffffL,0xffffffffL
};

void gen_f10code(int op, int size, AMODE *ap1, AMODE *ap2)
{
	if (size != 10) 
		gen_code(op,size,ap1,ap2);
	else {
		gen_code(op_fld,size,ap1,ap2);
		gen_code(op,size,0,0);
	}
}
int chksize(int lsize, int rsize)
{
	int l,r;
	l = lsize;
	r = rsize;
	if (l < 0) l = - l;
	if (r < 0) r = - r;
	return(l > r);
}
AMODE *fstack(void)
{
	AMODE *ap = xalloc(sizeof(AMODE));
	ap->mode = am_freg;
	ap->preg = 0;
	ap->sreg = 0;
	ap->offset = 0;
	ap->tempflag = TRUE;
	return(ap);
}
AMODE		*make_muldivval(AMODE *ap)
{
			int temp;
			AMODE *ap1 = make_label(temp = nextlabel++);
			queue_muldivval(temp,ap->offset->v.i);
			ap1->mode = am_direct;
			return(ap1);
}
void make_floatconst(AMODE *ap, int size)
{
	int temp;
	AMODE *ap1 = make_label(temp = nextlabel++);
	if (isintconst(ap->offset->nodetype))
		ap->offset->v.f = ap->offset->v.i;
	queue_floatval(temp,ap->offset->v.f,size);
	ap->mode = am_direct;
	ap->length = 8;
	ap->offset = ap1->offset;
}
AMODE    *make_label(int lab)
/*
 *      construct a reference node for an internal label number.
 */
{       ENODE    *lnode;
        AMODE    *ap;
        lnode = xalloc(sizeof(ENODE));
        lnode->nodetype = en_labcon;
        lnode->v.i = lab;
        ap = xalloc(sizeof(AMODE));
        ap->mode = am_immed;
        ap->offset = lnode;
        return ap;
}

AMODE    *make_immed(long i)
/*
 *      make a node to reference an immediate value i.
 */
{       AMODE    *ap;
        ENODE    *ep;
        ep = xalloc(sizeof(ENODE));
        ep->nodetype = en_icon;
        ep->v.i = i;
        ap = xalloc(sizeof(AMODE));
        ap->mode = am_immed;
        ap->offset = ep;
        return ap;
}
AMODE    *make_immedt(long i, int size)
/*
 *      make a node to reference an immediate value i.
 */
{
				switch (size) {
					case 1:
					case -1:
						i &= 0xff;
						break;
					case 2:
					case -2:
						i &= 0xffff;
						break;
				}
				return make_immed(i);
}

AMODE    *make_offset(ENODE *node)
/*
 *      make a direct reference to a node.
 */
{       AMODE    *ap;
        ap = xalloc(sizeof(AMODE));
        ap->mode = am_direct;
        ap->offset = node;
        return ap;
}
AMODE *make_stack(int number)
{
	AMODE *ap = xalloc(sizeof(AMODE));        
	ENODE *ep = xalloc(sizeof(ENODE));
	ep->nodetype = en_icon;
	ep->v.i = -number;
	ap->mode = am_indisp;
	ap->preg = ESP;
	ap->offset = ep;
	return(ap);
}
void make_legal(AMODE *ap,int flags,int size)
/*
 *      make_legal will coerce the addressing mode in ap1 into a
 *      mode that is satisfactory for the flag word.
 */
{       AMODE    *ap2,*ap1;
        if( ((flags & F_VOL) == 0) || ap->tempflag )
                {
                switch( ap->mode )
                        {
												case am_freg:
																if (flags & F_FREG && size > 4)
																		return;
																break;
                        case am_immed:
																if (size > 4) {
																	make_floatconst(ap,size);
								                  if (flags & F_MEM)
																		return;
																}
																else
                                	if( flags & F_IMMED )
                                        return;         /* mode ok */
																
                                break;
                        case am_dreg:
                                if( flags & F_DREG) {
                                  return;
																}
                                break;
												case am_indisp: case am_indispscale: 
												case am_direct:
																if (flags & F_INDX)
																	return;
                                if( flags & F_MEM)
                                        return;
                                break;
                        }
                }
				if (!(flags & F_DREG)) {
					if (flags & F_FREG && ap->mode != am_freg && !(flags & F_MEM)) {
						freeop(ap);
						if (size <=4) 
							if (size == 1 || size == -1) {
								ap1 = temp_data();
								if (size < 0)
									gen_code2(op_movsx,4,1,ap1,ap);
								else
									gen_code2(op_movzx,4,1,ap1,ap);
								gen_code(op_push,4,ap1,0);
								gen_code(op_fild,2,make_stack(0),0);
								gen_code(op_add,4,sreg,make_immed(4));
								freeop(ap1);
							}
							else
								gen_code(op_fild,size,ap,0);
						else
							gen_code(op_fld,size,ap,0);
						ap->mode = am_freg;
						ap->preg = 0;
						return;
					}
				}
				else if (size > 4) {
					freeop(ap);
					gen_code(op_fld,size,ap,0);
					if (flags & F_FREG) {
						ap->mode = am_freg;
						ap->preg = 0;
						return;
					}
					else {
						gen_code(op_push,4,makedreg(3),0);
						gen_code(op_fistp,4,make_stack(0),0);
						ap1 = temp_data();
						gen_code(op_pop,4,ap1,make_stack(0));
						ap->mode = ap1->mode;
						ap->preg = ap1->preg;
						return;
					}
				}
        if( size == -1 )
                {
                freeop(ap);
                ap2 = temp_data();
								if (ap->mode == am_immed)
                	gen_code(op_mov,1,ap2,ap);
								else if (ap->mode == am_dreg && ap->preg > 3)
                	gen_code(op_mov,4,ap2,ap);
								else
                	gen_code2(op_movsx,4,1,ap2,ap);
                ap->mode = ap2->mode;
                ap->preg = ap2->preg;
								ap->tempflag = TRUE;
                size = -2;
                }
				
        else if( size == 1 )
                {
                freeop(ap);
                ap2 = temp_data();
								if (ap->mode == am_immed)
                	gen_code(op_mov,1,ap2,ap);
								else if (ap->mode == am_dreg && ap->preg > 3)
                	gen_code(op_mov,4,ap2,ap);
								else
                	gen_code2(op_movzx,4,1,ap2,ap);
                ap->mode = ap2->mode;
                ap->preg = ap2->preg;
								ap->tempflag = TRUE;
                size = 2;
                }
        else if( size == -2 )
                {
                freeop(ap);
                ap2 = temp_data();
								if (ap->mode == am_immed)
                	gen_code(op_mov,2,ap2,ap);
								else if (ap->mode == am_dreg && ap->preg > 3)
                	gen_code(op_mov,4,ap2,ap);
								else
                	gen_code2(op_movsx,4,2,ap2,ap);
                ap->mode = ap2->mode;
                ap->preg = ap2->preg;
								ap->tempflag = TRUE;
                size = -4;
                }
				
        else if( size == 2 )
                {
                freeop(ap);
                ap2 = temp_data();
								if (ap->mode == am_immed)
                	gen_code(op_mov,2,ap2,ap);
								else if (ap->mode == am_dreg && ap->preg > 3)
                	gen_code(op_mov,4,ap2,ap);
								else
                	gen_code2(op_movzx,4,2,ap2,ap);
                ap->mode = ap2->mode;
                ap->preg = ap2->preg;
								ap->tempflag = TRUE;
                size = 4;
                }
				else if (size == 4 || size == -4) {
        	freeop(ap);
        	ap2 = temp_data();
        	gen_code(op_mov,size,ap2,ap);
        	ap->mode = am_dreg;
        	ap->preg = ap2->preg;
        	ap->tempflag = 1;
				}
}
void bit_legal(AMODE *ap,ENODE *node, int size)
{
	if (node->bits != -1) {
			make_legal(ap,F_DREG | F_VOL,size);
			if (node->startbit)
				gen_code(op_shr,size,ap,make_immed(node->startbit));
			gen_code(op_and,4,ap,make_immed(bittab[node->bits-1]));
	}
}
AMODE *get_bitval(AMODE *ap,ENODE *node, int size)
{
	AMODE *ap1 = temp_data();
	ap1->tempflag = TRUE;
		gen_code(op_mov,size,ap1,ap);
		if (node->startbit)
			gen_code(op_shr,size,ap1,make_immed(node->startbit));
		gen_code(op_and,4,ap1,make_immed(bittab[node->bits-1]));
		return ap1;
}
void bit_move(AMODE *ap2, AMODE *ap1, ENODE *node, int flags, int sizein, int sizeout)
{
		gen_code(op_and,sizeout,ap2,make_immed(~(bittab[node->bits-1]<<node->startbit)));
		if (ap1->mode == am_immed) {
			ap1->offset->v.i &= bittab[node->bits-1];
			if (ap1->offset->v.i) {
				ap1->offset->v.i <<= node->startbit;
				gen_code(op_or,sizeout,ap2,ap1);
				if (!(flags & F_NOVALUE)) {
					make_legal(ap2,flags,sizeout);
					ap1->offset->v.i >>= node->startbit;
					gen_code(op_mov,sizeout,ap2,ap1);
				}
			}
		}
		else {
			make_legal(ap1,F_DREG | F_VOL,sizein);
			gen_code(op_and,sizein,ap1,make_immed(bittab[node->bits-1]));
			if (node->startbit)
				gen_code(op_shl,sizein,ap1,make_immed(node->startbit));
			gen_code(op_or,sizeout,ap2,ap1);
			if (!(flags & F_NOVALUE)) {
				if (node->startbit)
					gen_code(op_shr,sizein,ap1,make_immed(node->startbit));
			}
		}
}
void do_extend(AMODE *ap,int isize,int osize,int flags)
/*
 *      if isize is not equal to osize then the operand ap will be
 *      loaded into a register (if not already) and if osize is
 *      greater than isize it will be extended to match.
 */
{				AMODE *ap2;
				if (isize == 0)
					return;
       	if( isize == osize || isize == -osize)
                return;
        if( ap->mode != am_dreg && osize <=4) {
									if (flags & F_DEST)
                		make_legal(ap,flags,isize);
									else
                		make_legal(ap,F_DREG | F_FREG,isize);
									if (flags & F_DEST)
										return;
									if (chksize(osize,isize))
										return;
				}
				switch(isize)
								{
doextend:
								case -1:
								case 1:
                case -2:
								case 2:
												if (osize < isize) {
														gen_code2(op_movsx,osize,isize,ap,ap);
												}
												else if (osize <=4 && osize > isize) {
														gen_code2(op_movzx,osize,isize,ap,ap);
												}
								case 4:
								case -4:
do4:
												if (osize <= 4)
													return;
												else {
													if (ap->mode != am_freg) {
														do_extend(ap,isize,4,F_ALL | F_VOL);
														ap2 = make_stack(0);
														gen_code(op_push,4,ap,0);
														freeop(ap);
														gen_codef(op_fild,4,ap2,0);
														gen_code(op_add,4,sreg,make_immed(4));
														freeop(ap);
													}
													ap->mode = am_freg;
													ap->preg = 0;
													ap->tempflag = TRUE;
												}
												break;
								case 6:
								case 8:
												if (osize > isize) {
													if (ap->mode != am_freg) {
														gen_codef(op_fld,osize,ap,0);	
														freeop(ap);
														ap->mode = am_freg;
														ap->preg = 0;
														ap->tempflag = TRUE;
													}
													return;
												}
												
								case 10: