istmt.c

CC386 is a general-purpose 32-bit C compiler. It is not an optimizing compiler but given that the co

/* 
Copyright 1994-2003 Free Software Foundation, Inc.

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program 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, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA.  

This program is derived from the cc68k complier by 
Matthew Brandt ([e-mail]) 

You may contact the author of this derivative at:

mailto::[e-mail]

or by snail mail at:

David Lindauer
850 Washburn Ave Apt 99
Louisville, KY 40222
 */
/*
 * istmt.c
 *
 * channge the statement list to icode
 */
#include <stdio.h>
#include <limits.h>
#include "utype.h"
#include "lists.h"
#include "expr.h"
#include "c.h"
#include "iexpr.h"
#include "iopt.h"
#include "diag.h"

extern IMODE *structret_imode ;
extern int global_flag;
extern TABLE gsyms;
extern long nextlabel;
extern TYP stdfunc;
extern SYM *currentfunc;
extern int prm_cplusplus;
extern int prm_locsub, prm_globsub, prm_copyprop, prm_foldconst;
extern int prm_optcode, prm_optdead, prm_optlive;
extern BLOCKLIST *blockhead;
extern int blocknum;
extern QUAD *intermed_head;
extern TABLE tempsyms;
extern int firstlabel;
#ifdef DUMP_GCSE_INFO
    extern FILE *icdFile;
#endif 
/*

 * virtual registers
 */
IMODE rlink = 
{
    i_rlink, 0, 0
};
IMODE rsp = 
{
    i_rsp, 0, 0
};
IMODE rstruct = 
{
    i_rstruct, 0, 0
};
IMODE rstructstar = 
{
    i_rstructstar, 0, 0
};
IMODE rret = 
{
    i_rret, 0, 0
};
int tempnum;
static int diddef; /* True if did default */
/*
 * current label values 
 */
static int breaklab;
static int contlab;
int retlab;
static int deflab;

void genstmtini(void)
{
    rsp.size = rlink.size = ISZ_ADDR;
}

//-------------------------------------------------------------------------

IMODE *tempreg(int size, int mode)
/*
 * create a temporary register
 */
{
    SYM *sp;
    IMODE *ap;
    char buf[10];
    ap = xalloc(sizeof(IMODE));
    sp = makesym(sc_temp);
    sprintf(buf, "$$t%d", tempnum);
    sp->name = litlate(buf);
    sp->value.i = tempnum++;
    if (prm_locsub)
        insert(sp, &tempsyms);
    ap->offset = makenode(en_tempref, sp, 0);
    ap->size = size;
    if (mode)
    {
        ap->mode = i_immed;
        sp->imaddress = ap;
    }
    else
    {
        ap->mode = i_direct;
        sp->imvalue = ap;
    }
    return ap;
}

//-------------------------------------------------------------------------

IMODE *make_direct(int i)
/*
 *      make a direct reference to an immediate value.
 */
{
    return make_offset(makenode(en_icon, (char*)i, 0));
}

//-------------------------------------------------------------------------

IMODE *make_strlab(char *s)
/*
 *      generate a direct reference to a string label.
 */
{
    IMODE *ap;
    ap = xalloc(sizeof(IMODE));
    ap->size = ISZ_ADDR;
    ap->mode = i_direct;
    ap->offset = makenode(en_nacon, s, 0);
    return ap;
}

//-------------------------------------------------------------------------

void genwhile(SNODE *stmt)
/*
 *      generate code to evaluate a while statement.
 */
{
    int lab1, lab2, lab3;
    lab1 = contlab; /* save old continue label */
    contlab = nextlabel++; /* new continue label */
    if (stmt->s1 != 0)
     /* has block */
    {
        lab2 = breaklab; /* save old break label */
        breaklab = nextlabel++;
        gen_igoto(contlab);
        lab3 = nextlabel++;
        gen_label(lab3);
        genstmt(stmt->s1);
        gen_label(contlab);
        if (stmt->lst)
            gen_line(stmt->lst);
        truejp(stmt->exp, lab3);
        gen_label(breaklab);
        breaklab = lab2; /* restore old break label */
    }
    else
     /* no loop code */
    {
        if (stmt->lst)
            gen_line(stmt->lst);
        gen_label(contlab);
        truejp(stmt->exp, contlab);
    }
    contlab = lab1; /* restore old continue label */
}

//-------------------------------------------------------------------------

void gen_for(SNODE *stmt)
/*
 *      generate code to evaluate a for loop
 */
{
    int old_break, old_cont, exit_label, loop_label, start_label;
    old_break = breaklab;
    old_cont = contlab;
    loop_label = nextlabel++;
    contlab = nextlabel++;
    start_label = nextlabel++;
    exit_label = nextlabel++;
    if (stmt->label != 0)
        gen_expr(stmt->label, F_NOVALUE, natural_size(stmt->label));

    gen_igoto(start_label);
    gen_label(loop_label);
    if (stmt->s1 != 0)
    {
        breaklab = exit_label;
        genstmt(stmt->s1);
    }
    gen_label(contlab);
    if (stmt->s2 != 0)
        gen_expr(stmt->s2, F_NOVALUE, natural_size(stmt->s2));
    gen_label(start_label);
    if (stmt->lst)
        gen_line(stmt->lst);
    if (stmt->exp != 0)
        truejp(stmt->exp, loop_label);
    else
        gen_igoto(loop_label);
    gen_label(exit_label);
    breaklab = old_break;
    contlab = old_cont;
}

//-------------------------------------------------------------------------

void genif(SNODE *stmt)
/*
 *      generate code to evaluate an if statement.
 */
{
    int lab1, lab2;
    lab1 = nextlabel++; /* else label */
    lab2 = nextlabel++; /* exit label */
    falsejp(stmt->exp, lab1);
    genstmt(stmt->s1);
    if (stmt->s2 != 0)
     /* else part exists */
    {
        gen_igoto(lab2);
        gen_label(lab1);
        genstmt(stmt->s2);
        gen_label(lab2);
    }
    else
     /* no else code */
        gen_label(lab1);
}

//-------------------------------------------------------------------------

void gendo(SNODE *stmt)
/*
 *      generate code for a do - while loop.
 */
{
    int oldcont, oldbreak, looplab;
    oldcont = contlab;
    oldbreak = breaklab;
	looplab = nextlabel++;
	gen_label(looplab);
    if (stmt->s1 != 0)
    {
		breaklab = nextlabel++;
	    contlab = nextlabel++;
        genstmt(stmt->s1); /* generate body */
	    gen_label(contlab);
        truejp(stmt->exp, looplab);
        gen_label(breaklab);
    }
    else
    {
        genstmt(stmt->s1);
        truejp(stmt->exp, looplab);
    }
    breaklab = oldbreak;
    contlab = oldcont;
}

//-------------------------------------------------------------------------

void gen_genword(SNODE *stmt)
/*
 * generate data in the code seg
 */
{
    gen_icode(i_genword, 0, make_immed((int)stmt->exp), 0);
}

//-------------------------------------------------------------------------

IMODE *set_symbol(char *name, int isproc)
/*
 *      generate a call to a library routine.
 */
{
    SYM *sp;
    IMODE *result;
    sp = gsearch(name);
    if (sp == 0)
    {
        ++global_flag;
        sp = makesym(sc_external);
        sp->tp = &stdfunc;
        sp->name = name;
        sp->extflag = TRUE;
        insert(sp, &gsyms);
        --global_flag;
    }
    result = make_strlab(name);
    return result;
}

//-------------------------------------------------------------------------

IMODE *call_library(char *lib_name, int size)
/*
 *      generate a call to a library routine.
 */
{
    IMODE *result;
    result = set_symbol(lib_name, 1);
    gen_icode(i_gosub, 0, result, 0);
    if (size != 0)
    {
//        gen_icode(i_parmadj, 0, make_immed(size), 0);
    }
    result = tempreg(ISZ_UINT, 0);
    gen_icode(i_assn, result, &rret, 0);
    return result;
}

//-------------------------------------------------------------------------
void count_cases(SNODE *stmt, struct cases *cs)
{
    while (stmt)
    {
        switch(stmt->stype) {        
             case st_tryblock:
                break;
            case st_throw:
                break;
            case st_return:
            case st_expr:
                break;
            case st_while:
            case st_do:
                count_cases(stmt->s1,cs);
                break;
            case st_for:
                count_cases(stmt->s1,cs);
                break;
            case st_if:
                count_cases(stmt->s1,cs);
                count_cases(stmt->s2,cs);
                break;
            case st_switch:
                break;
            case st_block:
                count_cases(stmt->exp,cs);
                break;
            case st_asm:
                break;
            case st_case:
               if (!stmt->s2)
                {
                    cs->count++;
                    
                    if (stmt->switchid < cs->bottom)
                        cs->bottom = stmt->switchid;
                    if (stmt->switchid > cs->top)
                        cs->top = stmt->switchid;
                }
                break;
        }
        stmt = stmt->next;
    }
}
//-------------------------------------------------------------------------
void gather_cases(SNODE *stmt, struct cases *cs, int compact)
{
    if (!cs->ptrs) {
        global_flag++;
        cs->ptrs = xalloc((cs->top - cs->bottom) * sizeof(struct cases));
        if (compact) {
            int i;
            for (i = cs->bottom; i < cs->top; i++)
                cs->ptrs[i - cs->bottom].label = cs->deflab;
        }
        global_flag--;
    }
    while (stmt)