Subversion Repositories thor

// ============================================================================

//        __

//   \\__/ o\    (C) 2012-2018  Robert Finch, Waterloo

//    \  __ /    All rights reserved.

//     \/_//     robfinch<remove>@finitron.ca

//       ||

//

// CC64 - '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 "stdafx.h"

extern void initFPRegStack();

extern void ReleaseTempFPRegister(Operand *);

/*

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 unsigned short int next_reg;

static unsigned short int next_fpreg;

static unsigned short int next_vreg;

static unsigned short int next_vmreg;

static short int next_breg;

#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 reg_in_use[256];       // 0 to 15

static short int fpreg_in_use[256];     // 0 to 15

static short int breg_in_use[16];       // 0 to 15

static short int save_reg_in_use[256];

static short int save_fpreg_in_use[256];

static short int vreg_in_use[256];      // 0 to 15

static short int save_vreg_in_use[256];

static short int vmreg_in_use[256];     // 0 to 15

static int wrapno, save_wrapno;

static struct {

        Operand *Operand;

    short int reg;

        struct {

        char isPushed;  /* flags if pushed or corresponding reg_alloc * number */

        char allocnum;

        } f;

}

        reg_stack[MAX_REG_STACK + 1],

        reg_alloc[MAX_REG_STACK + 1],

        save_reg_alloc[MAX_REG_STACK + 1],

        fpreg_stack[MAX_REG_STACK + 1],

        fpreg_alloc[MAX_REG_STACK + 1],

        save_fpreg_alloc[MAX_REG_STACK + 1],

        stacked_regs[MAX_REG_STACK + 1],

        stacked_fpregs[MAX_REG_STACK + 1],

        breg_stack[MAX_REG_STACK + 1],

        breg_alloc[MAX_REG_STACK + 1],

        vreg_stack[MAX_REG_STACK + 1],

        vreg_alloc[MAX_REG_STACK + 1],

        vmreg_stack[MAX_REG_STACK + 1],

        vmreg_alloc[MAX_REG_STACK + 1],

        save_vreg_alloc[MAX_REG_STACK + 1],

        save_vmreg_alloc[MAX_REG_STACK + 1],

        stacked_vregs[MAX_REG_STACK + 1],

        stacked_vmregs[MAX_REG_STACK + 1]

;

static short int reg_stack_ptr;

static short int reg_alloc_ptr;

static short int save_reg_alloc_ptr;

static short int fpreg_stack_ptr;

static short int fpreg_alloc_ptr;

static short int save_fpreg_alloc_ptr;

static short int vreg_stack_ptr;

static short int vreg_alloc_ptr;

static short int save_vreg_alloc_ptr;

static short int vmreg_stack_ptr;

static short int vmreg_alloc_ptr;

static short int save_vmreg_alloc_ptr;

static short int breg_stack_ptr;

static short int breg_alloc_ptr;

char tmpregs[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};

char tmpfpregs[] = {1,2,3,4,5,6,7,8,9,10};

char tmpvregs[] = {1,2,3,4,5,6,7,8,9,10};

char tmpvmregs[] = {1,2,3};

char tmpbregs[] = {5,6,7};

char regstack[18];

char fpregstack[18];

char bregstack[18];

int rsp=17;

int regmask=0;

int brsp=17;

int bregmask=0;

int rap[20];

int save_rap[20];

int NumTempRegs()

{

        if (currentFn->IsLeaf)

                return (regLastTemp - 1 + 1);

        else

                return (regLastTemp - regFirstTemp + 1);

}

void initRegStack()

{

        int i;

        Function *sym = currentFn;

        next_reg = sym->IsLeaf ? 1 : regFirstTemp;

        next_fpreg = sym->IsLeaf ? 1 : regFirstTemp;

        next_vreg = sym->IsLeaf ? 1 : regFirstTemp;

        next_vmreg = 1;

    next_breg = 5;

        //for (rsp=0; rsp < 3; rsp=rsp+1)

        //      regstack[rsp] = tmpregs[rsp];

        //rsp = 0;

        for (i = 0; i <= 255; i++) {

                reg_in_use[i] = -1;

                fpreg_in_use[i] = -1;

                vreg_in_use[i] = -1;

                vmreg_in_use[i] = -1;

                breg_in_use[i&15] = -1;

        }

    reg_stack_ptr = 0;

    reg_alloc_ptr = 0;

    fpreg_stack_ptr = 0;

    fpreg_alloc_ptr = 0;

    vreg_stack_ptr = 0;

    vreg_alloc_ptr = 0;

    vmreg_stack_ptr = 0;

    vmreg_alloc_ptr = 0;

    breg_stack_ptr = 0;

    breg_alloc_ptr = 0;

//    act_scratch = 0;

    memset(reg_stack,0,sizeof(reg_stack));

    memset(reg_alloc,0,sizeof(reg_alloc));

    memset(fpreg_stack,0,sizeof(fpreg_stack));

    memset(fpreg_alloc,0,sizeof(fpreg_alloc));

    memset(vreg_stack,0,sizeof(vreg_stack));

    memset(vreg_alloc,0,sizeof(vreg_alloc));

    memset(vmreg_stack,0,sizeof(vmreg_stack));

    memset(vmreg_alloc,0,sizeof(vmreg_alloc));

    memset(breg_stack,0,sizeof(breg_stack));

    memset(breg_alloc,0,sizeof(breg_alloc));

    memset(stacked_regs,0,sizeof(stacked_regs));

    memset(stacked_fpregs,0,sizeof(stacked_fpregs));

    memset(save_reg_alloc,0,sizeof(save_reg_alloc));

    memset(save_fpreg_alloc,0,sizeof(save_fpreg_alloc));

    memset(stacked_vregs,0,sizeof(stacked_vregs));

    memset(save_vreg_alloc,0,sizeof(save_vreg_alloc));

    memset(save_vmreg_alloc,0,sizeof(save_vmreg_alloc));

        wrapno = 0;

        ZeroMemory(rap, sizeof(rap));

}

// Spill a register to memory.

void SpillRegister(Operand *ap, int number)

{

        GenerateDiadic(op_sw,0,ap,make_indexed(currentFn->GetTempBot()-ap->deep*sizeOfWord,regFP));

    //reg_stack[reg_stack_ptr].Operand = ap;

    //reg_stack[reg_stack_ptr].f.allocnum = number;

    if (reg_alloc[number].f.isPushed=='T')

                fatal("SpillRegister(): register already spilled");

    reg_alloc[number].f.isPushed = 'T';

}

void SpillFPRegister(Operand *ap, int number)

{

        GenerateDiadic(op_sf,'d',ap,make_indexed(currentFn->GetTempBot()-ap->deep*sizeOfWord,regFP));

    fpreg_stack[fpreg_stack_ptr].Operand = ap;

    fpreg_stack[fpreg_stack_ptr].f.allocnum = number;

    if (fpreg_alloc[number].f.isPushed=='T')

                fatal("SpillRegister(): register already spilled");

    reg_alloc[number].f.isPushed = 'T';

}

// Load register from memory.

void LoadRegister(int regno, int number)

{

        if (reg_in_use[regno] >= 0)

                fatal("LoadRegister():register still in use");

        reg_in_use[regno] = number;

        GenerateDiadic(op_lw,0,makereg(regno),make_indexed(currentFn->GetTempBot()-number*sizeOfWord,regFP));

    reg_alloc[number].f.isPushed = 'F';

}

void LoadFPRegister(int regno, int number)

{

        if (fpreg_in_use[regno] >= 0)

                fatal("LoadRegister():register still in use");

        fpreg_in_use[regno] = number;

        GenerateDiadic(op_lf,'d',makefpreg(regno),make_indexed(currentFn->GetTempBot()-number*sizeOfWord,regFP));

    fpreg_alloc[number].f.isPushed = 'F';

}

void GenerateTempRegPush(int reg, int rmode, int number, int stkpos)

{

        Operand *ap1;

    ap1 = allocOperand();

    ap1->preg = reg;

    ap1->mode = rmode;

        GenerateMonadic(op_push,0,ap1);

        TRACE(printf("pushing r%d\r\n", reg);)

    reg_stack[reg_stack_ptr].Operand = ap1;

    reg_stack[reg_stack_ptr].reg = reg;

    reg_stack[reg_stack_ptr].f.allocnum = number;

    if (reg_alloc[number].f.isPushed=='T')

                fatal("GenerateTempRegPush(): register already pushed");

    reg_alloc[number].f.isPushed = 'T';

        if (++reg_stack_ptr > MAX_REG_STACK)

                fatal("GenerateTempRegPush(): register stack overflow");

}

void GenerateTempVectorRegPush(int reg, int rmode, int number, int stkpos)

{

        Operand *ap1;

    ap1 = allocOperand();

    ap1->preg = reg;

    ap1->mode = rmode;

        GenerateMonadic(op_push,0,ap1);

        TRACE(printf("pushing r%d\r\n", reg);)

    vreg_stack[vreg_stack_ptr].Operand = ap1;

    vreg_stack[vreg_stack_ptr].reg = reg;

    vreg_stack[vreg_stack_ptr].f.allocnum = number;

    if (vreg_alloc[number].f.isPushed=='T')

                fatal("GenerateTempRegPush(): register already pushed");

    vreg_alloc[number].f.isPushed = 'T';

        if (++vreg_stack_ptr > MAX_REG_STACK)

                fatal("GenerateTempRegPush(): register stack overflow");

}

void GenerateTempRegPop(int reg, int rmode, int number, int stkpos)

{

        Operand *ap1;

    if (reg_stack_ptr-- == -1)

                fatal("GenerateTempRegPop(): register stack underflow");

    /* check if the desired register really is on stack */

    if (reg_stack[reg_stack_ptr].f.allocnum != number)

                fatal("GenerateTempRegPop()/2");

        if (reg_in_use[reg] >= 0)

                fatal("GenerateTempRegPop():register still in use");

        TRACE(printf("popped r%d\r\n", reg);)

        reg_in_use[reg] = number;

        ap1 = allocOperand();

        ap1->preg = reg;

        ap1->mode = rmode;

        GenerateMonadic(op_pop,0,ap1);

    reg_alloc[number].f.isPushed = 'F';

}

void initstack()

{

        initRegStack();

        //initFPRegStack();

}

Operand *GetTempRegister()

{

        Operand *ap;

    Function *sym = currentFn;

        int number;

        number = reg_in_use[next_reg];

        if (number >= 0) {// && number < rap[wrapno]) {

                SpillRegister(makereg(next_reg),number);

        }

        TRACE(printf("GetTempRegister:r%d\r\n", next_reg);)

    reg_in_use[next_reg] = reg_alloc_ptr;

    ap = allocOperand();

    ap->mode = am_reg;

    ap->preg = next_reg;

        ap->pdeep = ap->deep;

    ap->deep = reg_alloc_ptr;

    reg_alloc[reg_alloc_ptr].reg = next_reg;

    reg_alloc[reg_alloc_ptr].Operand = ap;

    reg_alloc[reg_alloc_ptr].f.isPushed = 'F';

        if (next_reg++ >= regLastTemp) {

                wrapno++;

                rap[wrapno] = reg_alloc_ptr;

                next_reg = sym->IsLeaf ? 1 : regFirstTemp;              /* wrap around */

        }

    if (reg_alloc_ptr++ == MAX_REG_STACK)

                fatal("GetTempRegister(): register stack overflow");

        return (ap);

}

Operand *GetTempVectorRegister()

{

        Operand *ap;

    Function *sym = currentFn;

        if (vreg_in_use[next_vreg] >= 0) {

//              if (isThor)     

//                      GenerateTriadic(op_addui,0,makereg(regSP),makereg(regSP),make_immed(-8));

                GenerateTempVectorRegPush(next_vreg, am_reg, vreg_in_use[next_vreg],0);

        }

        TRACE(printf("GetTempRegister:r%d\r\n", next_vreg);)

    vreg_in_use[next_vreg] = vreg_alloc_ptr;

    ap = allocOperand();

    ap->mode = am_reg;

    ap->preg = next_vreg;

    ap->deep = vreg_alloc_ptr;

        ap->type = stdvector.GetIndex();

    vreg_alloc[vreg_alloc_ptr].reg = next_vreg;

    vreg_alloc[vreg_alloc_ptr].Operand = ap;

    vreg_alloc[vreg_alloc_ptr].f.isPushed = 'F';

    if (next_vreg++ >= 10)

                next_vreg = sym->IsLeaf ? 1 : 3;                /* wrap around */

    if (vreg_alloc_ptr++ == MAX_REG_STACK)

                fatal("GetTempVectorRegister(): register stack overflow");

        return ap;

}

Operand *GetTempVectorMaskRegister()

{

        Operand *ap;

    SYM *sym = currentFn->sym;

        if (vmreg_in_use[next_vmreg] >= 0) {

//              GenerateTempVectorMaskRegPush(next_vreg, am_reg, vreg_in_use[next_vreg],0);

        }

        TRACE(printf("GetTempRegister:r%d\r\n", next_vmreg);)

    vmreg_in_use[next_vreg] = vmreg_alloc_ptr;

    ap = allocOperand();

    ap->mode = am_vmreg;

    ap->preg = next_vmreg;

    ap->deep = vmreg_alloc_ptr;

        ap->type = stdvectormask->GetIndex();

    vmreg_alloc[vmreg_alloc_ptr].reg = next_vmreg;

    vmreg_alloc[vmreg_alloc_ptr].Operand = ap;

    vmreg_alloc[vmreg_alloc_ptr].f.isPushed = 'F';

    if (next_vmreg++ >= 3)

                next_vmreg = 1;         /* wrap around */

    if (vmreg_alloc_ptr++ == MAX_REG_STACK)

                fatal("GetTempVectorRegister(): register stack overflow");

        return (ap);

}

Operand *GetTempFPRegister()

{

        Operand *ap;

    Function *sym = currentFn;

        int number;

        number = fpreg_in_use[next_fpreg];

        if (number >= 0) {

                SpillFPRegister(fpreg_alloc[number].Operand,number);

        }

//      if (reg_in_use[next_reg] >= 0) {

//              GenerateTempRegPush(next_reg, am_reg, reg_in_use[next_reg],0);

//      }

        TRACE(printf("GetTempFPRegister:r%d\r\n", next_fpreg);)

    fpreg_in_use[next_fpreg] = fpreg_alloc_ptr;

    ap = allocOperand();

    ap->mode = am_fpreg;

    ap->preg = next_fpreg;

    ap->deep = fpreg_alloc_ptr;

        ap->type = stddouble.GetIndex();

    fpreg_alloc[fpreg_alloc_ptr].reg = next_fpreg;

    fpreg_alloc[fpreg_alloc_ptr].Operand = ap;

    fpreg_alloc[fpreg_alloc_ptr].f.isPushed = 'F';

    if (next_fpreg++ >= regLastTemp)

        next_fpreg = sym->IsLeaf ? 1 : regFirstTemp;            /* wrap around */

    if (fpreg_alloc_ptr++ == MAX_REG_STACK)

                fatal("GetTempFPRegister(): register stack overflow");

        return (ap);

}

//void RestoreTempRegs(int rgmask)

//{

//      int nn;

//      int rm;

//      int i;

//

//      nn = 0;

// 

//      for(nn = rgmask; nn > 0; nn--)

//              GenerateTempRegPop(0,0,0);

//      //if (rgmask != 0) {

//      //      for (nn = 1, rm = rgmask; nn <= 15; nn = nn + 1)

//      //              if ((rm>>nn) & 1) {

//      //                      GenerateMonadic(op_pop,0,makereg(nn));

//      //                      reg_in_use[nn] = 0;

//      //              }

//      //}

//}

//void RestoreTempBrRegs(int brgmask)

//{

//      int nn;

//      int rm;

//      int i;

//

//      nn = 0;

// 

//      for(nn = brgmask; nn > 0; nn--)

//              GenerateTempBrRegPop(0,0,0);

//}

/*

 * this routines checks if all allocated registers were freed

 */

void checkstack()

{

    int i;

    Function *sym = currentFn;

    for (i=1; i<= regLastTemp; i++)

        if (reg_in_use[i] != -1)

            fatal("checkstack()/1");

        if (next_reg != sym->IsLeaf ? 1 : regFirstTemp) {

                //printf("Nextreg: %d\r\n", next_reg);

        fatal("checkstack()/3");

        }

    if (reg_stack_ptr != 0)

        fatal("checkstack()/5");

    if (reg_alloc_ptr != 0)

        fatal("checkstack()/6");

}

void checkbrstack()

{

    int i;

    for (i=5; i<= 8; i++)

        if (breg_in_use[i] != -1)

            fatal("checkbstack()/1");

        if (next_breg != 5) {

                //printf("Nextreg: %d\r\n", next_breg);

        fatal("checkbstack()/3");

        }

    if (breg_stack_ptr != 0)

        fatal("checkbstack()/5");

    if (breg_alloc_ptr != 0)

        fatal("checkbstack()/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 validate(Operand *ap)

{

    Function *sym = currentFn;

        unsigned int frg = sym->IsLeaf ? 1 : (unsigned)regFirstTemp;

        if (ap->type!=stdvector.GetIndex())

    switch (ap->mode) {

        case am_reg:

                if ((ap->preg >= frg && ap->preg <= (unsigned)regLastTemp) && reg_alloc[ap->pdeep].f.isPushed == 'T' ) {

                        LoadRegister(ap->preg, (int) ap->pdeep);

                }

                break;

        case am_fpreg:

                if ((ap->preg >= frg && ap->preg <= (unsigned)regLastTemp) && fpreg_alloc[ap->deep].f.isPushed == 'T' ) {

                        LoadFPRegister(ap->preg, (int) ap->deep);

                }

                break;

    case am_indx2:

                if ((ap->preg >= frg && ap->preg <= (unsigned)regLastTemp) && reg_alloc[ap->deep].f.isPushed == 'T') {

                        LoadRegister(ap->preg, (int) ap->deep);

                }

                if ((ap->sreg >= frg && ap->sreg <= (unsigned)regLastTemp) && reg_alloc[ap->deep2].f.isPushed  == 'T') {

                        LoadRegister(ap->sreg, (int) ap->deep2);

                }

                break;

    case am_ind:

    case am_indx:

    case am_ainc:

    case am_adec:

                if ((ap->preg >= frg && ap->preg <= (unsigned)regLastTemp) && reg_alloc[ap->deep].f.isPushed == 'T') {

                        LoadRegister(ap->preg, (int) ap->deep);

                }

                break;

    }

}

/*

 * release any temporary registers used in an addressing mode.

 */

void ReleaseTempRegister(Operand *ap)

{

        int nn;

    int number;

    Function *sym = currentFn;

        unsigned int frg = sym->IsLeaf ? 1 : regFirstTemp;

        TRACE(printf("ReleaseTempRegister:r%d r%d\r\n", ap->preg, ap->sreg);)

        if (ap==NULL) {

                printf("DIAG - NULL pointer in ReleaseTempRegister\r\n");

                return;

        }

        // Kludgy here. The register is being release so at the moment it

        // is in use until it's released. The in_use flag will cause

        // validate not to work. Need to keep the value of in_use for later.

        nn = reg_in_use[ap->preg];

        if (ap->type != stdvector.GetIndex() && ap->mode != am_fpreg)

                reg_in_use[ap->preg] = -1;

        validate(ap);

        reg_in_use[ap->preg] = nn;

        if (ap->type==stdvector.GetIndex()) {

                switch (ap->mode) {

                case am_vmreg:

                        if (ap->preg >= 1 && ap->preg <= 3) {

                                if (vmreg_in_use[ap->preg]==-1)

                                        return;

                                if (next_vmreg-- <= 1)

                                        next_vmreg = 3;

                                number = vmreg_in_use[ap->preg];

                                vmreg_in_use[ap->preg] = -1;

                                break;

                        }

                        return;

                case am_ind:

                case am_indx:

                case am_ainc:

                case am_adec:

                case am_reg:

        commonv:

                        if (ap->preg >= frg && ap->preg <= 10) {

                                if (vreg_in_use[ap->preg]==-1)

                                        return;

                                if (next_vreg-- <= frg)

                                        next_vreg = 10;

                                number = vreg_in_use[ap->preg];

                                vreg_in_use[ap->preg] = -1;

                                break;

                        }

                        return;

                case am_indx2:

                        if (ap->sreg >= frg && ap->sreg <= 10) {

                                if (vreg_in_use[ap->sreg]==-1)

                                        return;

                                if (next_vreg-- <= frg)

                                        next_vreg = 10;

                                number = vreg_in_use[ap->sreg];

                                vreg_in_use[ap->sreg] = -1;

                                //break;

                        }

                        goto commonv;

                default:

                        return;

                }

                if (vreg_alloc_ptr-- == 0)

                        fatal("ReleaseTempRegister(): no registers are allocated");

          //  if (reg_alloc_ptr != number)

                        //fatal("ReleaseTempRegister()/3");

                if (vreg_alloc[number].f.isPushed=='T')

                        fatal("ReleaseTempRegister(): register on stack");

                return;

        }

        else

    switch (ap->mode) {

        case am_fpreg:

                if (ap->preg >= frg && ap->preg <= (unsigned)regLastTemp) {

                        if (fpreg_in_use[ap->preg]==-1)

                                return;

                        if (next_fpreg-- <= frg)

                                next_fpreg = regLastTemp;

                        number = fpreg_in_use[ap->preg];

                        fpreg_in_use[ap->preg] = -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");

                        return;

                }

                return;

        case am_ind:

        case am_indx:

        case am_ainc: