/*
 * 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        "gen68.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 cf_freeaddress, cf_freedata;
extern int linkreg,basereg;
extern long stackdepth,framedepth;
extern int prm_largedata, prm_68020,prm_phiform,prm_linkreg;
extern int prm_smallcode, prm_rel, prm_smalldata;
extern AMODE     push[], pop[];
extern int prm_68020;
extern SYM *currentfunc;
extern long lc_maxauto;
extern long nextlabel;
extern char regstack[], rsold[], rsodepth,rsdepth;

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
};

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    *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_direct;
        ap->offset = lnode;
        return ap;
}
AMODE    *makebf(ENODE *node, AMODE *ap1, int size)
/*
 *      construct a bit field reference for 68020 bit field instructions
 */
{
        AMODE    *ap;
				if (node->startbit == -1)
					DIAG("Illegal bit field");
        ap = xalloc(sizeof(AMODE));
        ap->mode = am_bf;
				ap->preg = node->startbit;
				ap->sreg = node->bits;
				switch (size) {
					case 1:
					case -1:
				 		ap->preg =8-node->startbit-node->bits;
						break;
					case 2:
					case -2:
				 		ap->preg =16-node->startbit-node->bits;
						break;
					case 4:
					case -4:
				 		ap->preg =32-node->startbit-node->bits;
						break;
				}
        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_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;
}
        
void tofloat(AMODE *ap,int size)
{
	AMODE *ap2;
								freeop(ap);
								ap2 = temp_float();
                gen_codef(op_fmove,size,ap,ap2);
                ap->mode = am_freg;
                ap->preg = ap2->preg;
                ap->tempflag = 1;
}
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;
        if( ((flags & F_VOL) == 0) || ap->tempflag )
                {
                switch( ap->mode )
                        {
												case am_freg:
																if (flags & F_FREG)
																		return;
																break;
                        case am_immed:
                                if( flags & F_IMMED )
                                        return;         /* mode ok */
                                break;
                        case am_areg:
                                if( flags & F_AREG )
                                        return;
                                break;
                        case am_dreg:
                                if( flags & F_DREG )
                                        return;
                                break;
												case am_indx:
												case am_ind:
                        case am_baseindxdata: 
                        case am_baseindxaddr:
												case am_adirect:
												case am_ainc: case am_adec:
																if (flags & F_INDX)
																				return;
												case am_direct:
                        case am_pcindx:
                                if( flags & F_INDX )
                                        return;
                                break;
                        }
                }
				if (size > 4) {
						tofloat(ap,size);
						return;
                }
        if( flags & F_DREG )
                {
								if (ap->mode == am_dreg && ap->tempflag)
									return;
                freeop(ap);             /* maybe we can use it... */
                ap2 = temp_data();      /* allocate to dreg */
                gen_code(op_move,size,ap,ap2);
                ap->mode = am_dreg;
                ap->preg = ap2->preg;
                ap->tempflag = 1;
                return;
                }
        if( size == -1 )
                {
                freeop(ap);
                ap2 = temp_data();
                gen_code(op_move,1,ap,ap2);
                gen_code(op_ext,2,ap2,0);
                ap->mode = ap2->mode;
                ap->preg = ap2->preg;
                size = -2;
                }
        if( size == 1 )
                {
                freeop(ap);
                ap2 = temp_data();
                gen_code(op_move,1,ap,ap2);
                gen_code(op_and,2,make_immed(0xff),ap2);
                ap->mode = ap2->mode;
                ap->preg = ap2->preg;
                size = 2;
                }
        	freeop(ap);
        	ap2 = temp_addr();
        	gen_code(op_move,size,ap,ap2);
        	ap->mode = am_areg;
        	ap->preg = ap2->preg;
        	ap->tempflag = 1;
}
void doshift(int op, AMODE *ap2, AMODE *ap1, int size)
{
				if (ap2->mode == am_immed) {
					int temp = ap2->offset->v.i;
					while (temp >8) {
						temp = temp-8;
        		gen_code(op,size,make_immed(8),ap1);
					}
					if (temp != 0) {
						ap2->offset->v.i = temp;
        		gen_code(op,size,ap2,ap1);
					}
				}
				else
        	gen_code(op,size,ap2,ap1);
}
void bit_legal(AMODE *ap,ENODE *node, int size)
{
	if (node->bits != -1) {
		if (prm_68020) {
			AMODE *ap1;
			if (ap->mode != am_dreg || !ap->tempflag) {
				ap1 = temp_data();
				ap1->tempflag = 1;
			}
			else
				ap1 = copy_addr(ap);
			gen_code3(op_bfextu,0,ap,makebf(node,ap1,size),ap1);	
			ap->mode = ap1->mode;
			ap->preg = ap1->preg;
			ap->tempflag = ap1->tempflag;
		}
		else {
			make_legal(ap,F_DREG | F_VOL,size);
			if (node->startbit)
				doshift(op_asr,make_immed(node->startbit),ap,size);
				gen_code(op_asr,size,make_immed(node->startbit),ap);
			gen_code(op_andi,4,make_immed(bittab[node->bits-1]),ap);
		}
	}
}
AMODE *get_bitval(AMODE *ap,ENODE *node, int size)
{
	AMODE *ap1 = temp_data();
	ap1->tempflag = TRUE;
	if (prm_68020) {
		gen_code3(op_bfextu,0,ap,makebf(node,ap,size),ap1);
		return ap1;
	}
	else {
		gen_code(op_move,size,ap,ap1);
		if (node->startbit)
			doshift(op_asr,make_immed(node->startbit),ap1,size);
		gen_code(op_andi,4,make_immed(bittab[node->bits-1]),ap1);
		return ap1;
	}
}
void bit_move(AMODE *ap1, AMODE *ap2, ENODE *node, int flags, int sizein, int sizeout)
{
	if (prm_68020) {
		make_legal(ap1,F_DREG,sizein);
		gen_code3(op_bfins,0,ap1,ap2,makebf(node,ap2,sizeout));
	}
	else {
		gen_code(op_andi,sizeout,make_immed(~(bittab[node->bits-1]<<node->startbit)), ap2);
		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_ori,sizeout,ap1,ap2);
				if (!(flags & F_NOVALUE)) {
					make_legal(ap2,flags,sizeout);
					ap1->offset->v.i >>= node->startbit;
					gen_code(op_move,sizeout,ap1,ap2);
				}
			}
		}
		else {
			make_legal(ap1,F_DREG | F_VOL,sizein);
			gen_code(op_andi,sizein,make_immed(bittab[node->bits-1]), ap1);
			if (node->startbit)
				doshift(op_asl,make_immed(node->startbit),ap1,sizein);
			gen_code(op_or,sizeout,ap2,ap1);
			if (!(flags & F_NOVALUE)) {
				if (node->startbit)
					doshift(op_asr,make_immed(node->startbit),ap1,sizein);
			}
		}
	}
}

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 (osize == 0 || isize == 0)
					return;
       if( isize == osize || isize == -osize)
                return;
				if (chksize(osize,isize) && osize <=4)
					if (isize ^ osize < 0)
						osize = -osize;
        if( ap->mode != am_areg && ap->mode != am_dreg && isize <= 4) {
								if (flags&F_DREG) {
									freeop(ap);
									gen_code(op_move,isize,ap,ap2=temp_data());
									ap->mode = am_dreg;
									ap->preg = ap2->preg;
								}
								else if (isize ==1 || isize == -1) {
									freeop(ap);
									gen_code(op_move,isize,ap,ap2=temp_data());
									ap->mode = am_dreg;
									ap->preg = ap2->preg;
									freeop(ap);
									gen_code(op_ext,2,ap,0);
									gen_code(op_move,2,ap,ap2=temp_addr());
									ap->mode = am_areg;
									ap->preg = ap2->preg;
								}
								else {
									freeop(ap);
									gen_code(op_move,isize,ap,ap2=temp_addr());
									ap = ap2;
								}
				}
        if( ap->mode == am_areg )
                return;         /* extend is automagic */
					
				switch(isize)
								{
                case -1:
								case 1:
												if (osize < 0)
													if (osize <= -4 && prm_68020)
														gen_code(op_extb,4,ap,0);
													else
                        		gen_code(op_ext,2,ap,0);
												else {
													int t = osize;
													if (osize > 4) t = 4;
													gen_code(op_andi,t,make_immed(0xff),ap);
												}
                case -2:
								case 2:
													if (osize == 1 || osize == -1)
														break;
                        	if( osize <-2 && !(prm_68020 && (isize == -1 || isize == 1))) {
                          	gen_code(op_ext,4,ap,0);
													}
													else
														if (isize == 2 || isize == -2) {
															gen_code(op_andi,4,make_immed(0xffff),ap);
														}
								case 4:
								case -4:
												if  (osize <=4)
													break;
												isize = -4;
								case 6:
								case 8: 
												if (osize > 4) {
													if (ap->mode != am_freg)
														tofloat(ap,isize);
												}
												else {
													freeop(ap);
													ap2 = temp_data();
													gen_codef(op_fmove,osize,ap,ap2);
													ap->mode = am_dreg;
													ap->preg = ap2->preg;
												}
												break;
				}
}

int     isshort(ENODE *node)
/*
 *      return true if the node passed can be generated as a short
 *      offset.
 */
{       return (isintconst(node->nodetype) || node->nodetype == en_absacon)&&
                (node->v.i >= -32768L && node->v.i <= 32767L);
}

int     isbyte(ENODE *node)
/*
 *      return true if the node passed can be evaluated as a byte
 *      offset.
 */
{       return isintconst(node->nodetype) &&
                (-128 <= node->v.i && node->v.i <= 127);
}

int isamshort(AMODE *ap)
{
	long v;
	if (ap->offset->nodetype != en_icon)
		return TRUE;
	v = ap->offset->v.i;
	return (v >=-32768L && v < 32767);
}
int isamshort2(AMODE *ap, AMODE *ap2)
{
	long v;
	if (ap->offset->nodetype != en_icon || ap2->offset->nodetype != en_icon)
		return TRUE;
	v = ap->offset->v.i + ap2->offset->v.i;
	return (v >=-32768L && v < 32767);
}
int isambyte(AMODE *ap)
{
	long v;