Subversion Repositories thor

// ============================================================================
//        __
//   \\__/ o\    (C) 2012-2016  Robert Finch, Waterloo
//    \  __ /    All rights reserved.
//     \/_//     robfinch<remove>@finitron.ca
//       ||
//
// C32 - 'C' derived language compiler
//  - 32 bit CPU
//
// This source file is free software: you can redistribute it and/or modify 
// it under the terms of the GNU Lesser General Public License as published 
// by the Free Software Foundation, either version 3 of the License, or     
// (at your option) any later version.                                      
//                                                                          
// This source file is distributed in the hope that it will be useful,      
// but WITHOUT ANY WARRANTY; without even the implied warranty of           
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            
// GNU General Public License for more details.                             
//                                                                          
// You should have received a copy of the GNU General Public License        
// along with this program.  If not, see <http://www.gnu.org/licenses/>.    
//                                                                          
// ============================================================================
//
#include "stdafx.h"
/*
int tmpregs[] = {3,4,5,6,7,8,9,10};
int regstack[8];
int rsp=7;
int regmask=0;
 
int tmpbregs[] = {3,4,5,6,7,8};
int bregstack[6];
int brsp=5;
int bregmask = 0;
*/
static short int next_fpreg;
#define MAX_REG 4			/* max. scratch data	register (D2) */
#define	MAX_REG_STACK	30
 
// Only registers 5,6,7 and 8 are used for temporaries
static short int fpreg_in_use[256];	// 0 to 15
static short int save_fpreg_in_use[256];
 
static struct {
    enum e_am mode;
    short int reg;
	union {
		char isPushed;	/* flags if pushed or corresponding reg_alloc * number */
		char allocnum;
	} f;
} 
	fpreg_stack[MAX_REG_STACK + 1],
	fpreg_alloc[MAX_REG_STACK + 1],
	save_fpreg_alloc[MAX_REG_STACK + 1],
	stacked_fpregs[MAX_REG_STACK + 1];
 
static short int fpreg_stack_ptr;
static short int fpreg_alloc_ptr;
static short int save_fpreg_alloc_ptr;
 
char tmpfpregs[] = {3,4,5,6,7,8,9,10};
char regfpstack[18];
int fprsp=17;
int fpregmask=0;
 
void initFPRegStack()
{
	int i;
 
    next_fpreg = 3;
	//for (rsp=0; rsp < 3; rsp=rsp+1)
	//	regstack[rsp] = tmpregs[rsp];
	//rsp = 0;
	for (i = 0; i <= 255; i++) {
		fpreg_in_use[i] = -1;
	}
    fpreg_stack_ptr = 0;
    fpreg_alloc_ptr = 0;
//    act_scratch = 0;
    memset(fpreg_stack,0,sizeof(fpreg_stack));
    memset(fpreg_alloc,0,sizeof(fpreg_alloc));
    memset(stacked_fpregs,0,sizeof(stacked_fpregs));
    memset(save_fpreg_alloc,0,sizeof(save_fpreg_alloc));
}
 
void GenerateTempFPRegPush(int reg, int rmode, int number)
{
	AMODE *ap1;
    ap1 = allocAmode();
    ap1->preg = reg;
    ap1->mode = rmode;
    ap1->isFloat = TRUE;
 
	GenerateMonadic(op_push,'t',ap1);
	TRACE(printf("pushing r%d\r\n", reg);)
    fpreg_stack[fpreg_stack_ptr].mode = (enum e_am)rmode;
    fpreg_stack[fpreg_stack_ptr].reg = reg;
    fpreg_stack[fpreg_stack_ptr].f.allocnum = number;
    if (fpreg_alloc[number].f.isPushed=='T')
		fatal("GenerateTempRegPush(): register already pushed");
    fpreg_alloc[number].f.isPushed = 'T';
	if (++fpreg_stack_ptr > MAX_REG_STACK)
		fatal("GenerateTempRegPush(): register stack overflow");
}
 
void GenerateTempFPRegPop(int reg, int rmode, int number)
{
	AMODE *ap1;
 
    if (fpreg_stack_ptr-- == -1)
		fatal("GenerateTempRegPop(): register stack underflow");
    /* check if the desired register really is on stack */
    if (fpreg_stack[fpreg_stack_ptr].f.allocnum != number)
		fatal("GenerateTempRegPop()/2");
	if (fpreg_in_use[reg] >= 0)
		fatal("GenerateTempRegPop():register still in use");
	TRACE(printf("popped r%d\r\n", reg);)
	fpreg_in_use[reg] = number;
	ap1 = allocAmode();
	ap1->preg = reg;
	ap1->mode = rmode;
	ap1->isFloat = TRUE;
	GenerateMonadic(op_pop,'t',ap1);
    fpreg_alloc[number].f.isPushed = 'F';
}
 
void initfpstack()
{
	initFPRegStack();
}
 
AMODE *GetTempFPRegister()
{
	AMODE *ap;
 
	if (fpreg_in_use[next_fpreg] >= 0)
		GenerateTempFPRegPush(next_fpreg, am_fpreg, fpreg_in_use[next_fpreg]);
	TRACE(printf("GetTempRegister:r%d\r\n", next_fpreg);)
    fpreg_in_use[next_fpreg] = fpreg_alloc_ptr;
    ap = allocAmode();
    ap->mode = am_fpreg;
    ap->preg = next_fpreg;
    ap->deep = fpreg_alloc_ptr;
    ap->isFloat = TRUE;
    fpreg_alloc[fpreg_alloc_ptr].reg = next_fpreg;
    fpreg_alloc[fpreg_alloc_ptr].mode = am_fpreg;
    fpreg_alloc[fpreg_alloc_ptr].f.isPushed = 'F';
    if (next_fpreg++ >= 10)
  		next_fpreg = 3;		/* wrap around */
    if (fpreg_alloc_ptr++ == MAX_REG_STACK)
		fatal("GetTempRegister(): register stack overflow");
	return ap;
}
 
/*
 * this routines checks if all allocated registers were freed
 */
void checkfpstack()
{
    int i;
    for (i=3; i<= 10; i++)
        if (fpreg_in_use[i] != -1)
            fatal("checkstack()/1");
	if (next_fpreg != 3) {
		//printf("Nextreg: %d\r\n", next_reg);
        fatal("checkstack()/3");
	}
    if (fpreg_stack_ptr != 0)
        fatal("checkstack()/5");
    if (fpreg_alloc_ptr != 0)
        fatal("checkstack()/6");
}
 
/*
 * validate will make sure that if a register within an address mode has been
 * pushed onto the stack that it is popped back at this time.
 */
void validateFP(AMODE *ap)
{
    switch (ap->mode) {
	case am_fpreg:
		if ((ap->preg >= 3 && ap->preg <= 10) && fpreg_alloc[ap->deep].f.isPushed == 'T' ) {
			GenerateTempFPRegPop(ap->preg, am_fpreg, (int) ap->deep);
		}
		break;
    }
}
 
 
/*
 * release any temporary registers used in an addressing mode.
 */
void ReleaseTempFPRegister(AMODE *ap)
{
    int number;
 
	TRACE(printf("ReleaseTempFPRegister:r%d r%d\r\n", ap->preg, ap->sreg);)
 
	if (ap==NULL) {
		printf("DIAG - NULL pointer in ReleaseTempRegister\r\n");
		return;
	}
 
//	validate(ap);
    switch (ap->mode) {
	case am_fpreg:
		if (ap->preg >= 3 && ap->preg <= 10) {
			if (fpreg_in_use[ap->preg]==-1)
				return;
			if (next_fpreg-- <= 3)
				next_fpreg = 10;
			number = fpreg_in_use[ap->preg];
			fpreg_in_use[ap->preg] = -1;
			break;
		}
		return;
    default:
		return;
    }
 //   /* some consistency checks */
	//if (number != ap->deep) {
	//	printf("number %d ap->deep %d\r\n", number, ap->deep);
	//	//fatal("ReleaseTempRegister()/1");
	//}
	if (fpreg_alloc_ptr-- == 0)
		fatal("ReleaseTempRegister(): no registers are allocated");
  //  if (reg_alloc_ptr != number)
		//fatal("ReleaseTempRegister()/3");
    if (fpreg_alloc[number].f.isPushed=='T')
		fatal("ReleaseTempRegister(): register on stack");
}
 
// The following is used to save temporary registers across function calls.
// Save the list of allocated registers and registers in use.
// Go through the allocated register list and generate a push instruction to
// put the register on the stack if it isn't already on the stack.
 
int TempFPInvalidate()
{
    int i;
	int sp;
 
	sp = 0;
	TRACE(printf("TempFPInvalidate()\r\n");)
	save_fpreg_alloc_ptr = fpreg_alloc_ptr;
	memcpy(save_fpreg_alloc, fpreg_alloc, sizeof(save_fpreg_alloc));
	memcpy(save_fpreg_in_use, fpreg_in_use, sizeof(save_fpreg_in_use));
	for (i = 0; i < fpreg_alloc_ptr; i++) {
        if (fpreg_in_use[fpreg_alloc[i].reg] != -1) {
    		if (fpreg_alloc[i].f.isPushed == 'F') {
    			GenerateTempFPRegPush(fpreg_alloc[i].reg, fpreg_alloc[i].mode, i);
    			stacked_fpregs[sp].reg = fpreg_alloc[i].reg;
    			stacked_fpregs[sp].mode = fpreg_alloc[i].mode;
    			stacked_fpregs[sp].f.allocnum = i;
    			sp++;
    			// mark the register void
    			fpreg_in_use[fpreg_alloc[i].reg] = -1;
    		}
        }
	}
	return sp;
}
 
// Pop back any temporary registers that were pushed before the function call.
// Restore the allocated and in use register lists.
 
void TempFPRevalidate(int sp)
{
	int nn;
 
	for (nn = sp-1; nn >= 0; nn--)
		GenerateTempFPRegPop(stacked_fpregs[nn].reg, stacked_fpregs[nn].mode, stacked_fpregs[nn].f.allocnum);
	fpreg_alloc_ptr = save_fpreg_alloc_ptr;
	memcpy(fpreg_alloc, save_fpreg_alloc, sizeof(fpreg_alloc));
	memcpy(fpreg_in_use, save_fpreg_in_use, sizeof(fpreg_in_use));
}