Subversion Repositories raptor64

// ============================================================================
// (C) 2012 Robert Finch
// All Rights Reserved.
// robfinch<remove>@opencores.org
//
// C64 - Raptor64 'C' derived language compiler
//  - 64 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 <stdio.h>
#include "c.h"
#include "expr.h"
#include "Statement.h"
#include "gen.h"
#include "cglbdec.h"
 
int tmpregs[] = {3,4,5,6,7,8,9,10};
int regstack[8];
int rsp=7;
int regmask=0;
 
void initRegStack()
{
	for (rsp=0; rsp < 8; rsp=rsp+1)
		regstack[rsp] = tmpregs[rsp];
	rsp = 0;
}
 
void GenerateTempRegPush(int reg, int rmode)
{
	AMODE *ap1;
    ap1 = allocAmode();
    ap1->preg = reg;
    ap1->mode = rmode;
	GenerateTriadic(op_subui,0,makereg(30),makereg(30),make_immed(8));
	GenerateTriadic(op_sw,0,ap1,make_indirect(30),NULL);
}
 
void GenerateTempRegPop(int reg, int rmode)
{
	AMODE *ap1;
    ap1 = allocAmode();
    ap1->preg = reg;
    ap1->mode = rmode;
	GenerateTriadic(op_lw,0,ap1,make_indirect(30),NULL);
	GenerateTriadic(op_addui,0,makereg(30),makereg(30),make_immed(8));
}
 
void initstack()
{
	initRegStack();
}
 
AMODE *GetTempRegister()
{
	AMODE *ap;
    ap = allocAmode();
    ap->mode = am_reg;
    ap->preg = PopFromRstk();
    ap->deep = rsp;
    return ap;
}
 
int PopFromRstk()
{
	int reg = 0;
 
	if (rsp < 8) {
		reg = regstack[rsp];
		rsp = rsp + 1;
		regmask |= (1 << (reg));
	}
	else
		error(ERR_EXPRTOOCOMPLEX);
	return reg;
}
 
void PushOnRstk(int reg)
{
	if (rsp > 0) {
		rsp = rsp - 1;
		regstack[rsp] = reg;
		regmask &= ~(1 << (reg));
	}
	else
		printf("DIAG - register stack underflow.\r\n");
}
 
//int SaveTempRegs()
//{
//	if (popcnt(regmask)==1) {
//		GenerateTriadic(op_subui,0,makereg(30),makereg(30),make_immed(8));
//		GenerateTriadic(op_sw,0,make_mask(regmask),make_indirect(30),NULL);
//	}
//	else if (regmask != 0) {
//		GenerateTriadic(op_subui,0,makereg(30),makereg(30),make_immed(popcnt(regmask)*8));
//		GenerateTriadic(op_sm,0,make_indirect(30),make_mask(regmask),NULL);
//	}
//	return regmask;
//}
//
 
int SaveTempRegs()
{
	int n;
	int rm;
 
	if (regmask != 0) {
		GenerateTriadic(op_subui,0,makereg(30),makereg(30),make_immed(popcnt(regmask)*8));
		for (n = 1, rm = regmask; rm != 0; n = n + 1,rm = rm >> 1)
			if (rm & 1)
				GenerateDiadic(op_sw,0,makereg(n),make_indexed((popcnt(rm)-1)*8,30));
	}
	return regmask;
}
 
 
void RestoreTempRegs(int rgmask)
{
	int n;
	int rm;
 
	if (rgmask != 0) {
		for (n = 1, rm = rgmask; rm != 0; n = n + 1,rm = rm >> 1)
			if (rm & 1)
				GenerateDiadic(op_lw,0,makereg(n),make_indexed((popcnt(rm)-1)*8,30));
		GenerateTriadic(op_addui,0,makereg(30),makereg(30),make_immed(popcnt(rgmask)*8));
	}
}
 
 
//void RestoreTempRegs(int rgmask)
//{
//	if (popcnt(rgmask)==1) {
//		GenerateTriadic(op_lw,0,make_mask(rgmask),make_indirect(30),NULL);
//		GenerateTriadic(op_addui,0,makereg(30),makereg(30),make_immed(8));
//	}
//	else if (rgmask != 0) {
//		GenerateTriadic(op_lm,0,make_indirect(30),make_mask(rgmask),NULL);
//		GenerateTriadic(op_addui,0,makereg(30),makereg(30),make_immed(popcnt(rgmask)*8));
//	}
//}
//
void ReleaseTempRegister(struct amode *ap)
{
	if (ap==NULL) {
		printf("DIAG - NULL pointer in ReleaseTempRegister\r\n");
		return;
	}
	if( ap->mode == am_immed || ap->mode == am_direct )
        return;         // no registers used
	if(ap->preg < 11 && ap->preg >= 3)
		PushOnRstk(ap->preg);
}