optimize.c

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

            if (isintconst(ep->v.p[0]->nodetype))
            {
                *node = makeintnode(en_icon, (!ep->v.p[0]->v.i));
                rv = TRUE;
            }
            break;
        case en_eq:
            rv |= opt0(&(ep->v.p[0]));
            rv |= opt0(&(ep->v.p[1]));
            mode = getmode(ep->v.p[0], ep->v.p[1]);
            switch (mode)
            {
            case 1:
                *node = makeintnode(en_icon, (ep->v.p[0]->v.i == ep->v.p[1]
                    ->v.i));
                rv = TRUE;

                break;
            }
            break;
        case en_ne:
            rv |= opt0(&(ep->v.p[0]));
            rv |= opt0(&(ep->v.p[1]));
            mode = getmode(ep->v.p[0], ep->v.p[1]);
            switch (mode)
            {
            case 1:
                *node = makeintnode(en_icon, (ep->v.p[0]->v.i != ep->v.p[1]
                    ->v.i));
                rv = TRUE;
                break;
            }
            break;
        case en_lt:
            rv |= opt0(&(ep->v.p[0]));
            rv |= opt0(&(ep->v.p[1]));
            mode = getmode(ep->v.p[0], ep->v.p[1]);
            switch (mode)
            {
            case 1:
                *node = makeintnode(en_icon, (ep->v.p[0]->v.i < ep->v.p[1]->v.i)
                    );
                rv = TRUE;
                break;
            }
            break;
        case en_le:
            rv |= opt0(&(ep->v.p[0]));
            rv |= opt0(&(ep->v.p[1]));
            mode = getmode(ep->v.p[0], ep->v.p[1]);
            switch (mode)
            {
            case 1:
                *node = makeintnode(en_icon, (ep->v.p[0]->v.i <= ep->v.p[1]
                    ->v.i));
                rv = TRUE;
                break;
            }
            break;
        case en_ugt:
            rv |= opt0(&(ep->v.p[0]));
            rv |= opt0(&(ep->v.p[1]));
            mode = getmode(ep->v.p[0], ep->v.p[1]);
            switch (mode)
            {
            case 1:
                *node = makeintnode(en_icon, ((ULLONG_TYPE)ep->v.p[0]->v.i > 
                    (ULLONG_TYPE)ep->v.p[1]->v.i));
                rv = TRUE;
                break;
            }
            break;
        case en_uge:
            rv |= opt0(&(ep->v.p[0]));
            rv |= opt0(&(ep->v.p[1]));
            mode = getmode(ep->v.p[0], ep->v.p[1]);
            switch (mode)
            {
            case 1:
                *node = makeintnode(en_icon, ((ULLONG_TYPE)ep->v.p[0]->v.i >= 
                    (ULLONG_TYPE)ep->v.p[1]->v.i));
                rv = TRUE;
                break;
            }
            break;
        case en_ult:
            rv |= opt0(&(ep->v.p[0]));
            rv |= opt0(&(ep->v.p[1]));
            mode = getmode(ep->v.p[0], ep->v.p[1]);
            switch (mode)
            {
            case 1:
                *node = makeintnode(en_icon, ((ULLONG_TYPE)ep->v.p[0]->v.i < 
                    (ULLONG_TYPE)ep->v.p[1]->v.i));
                rv = TRUE;
                break;
            }
            break;
        case en_ule:
            rv |= opt0(&(ep->v.p[0]));
            rv |= opt0(&(ep->v.p[1]));
            mode = getmode(ep->v.p[0], ep->v.p[1]);
            switch (mode)
            {
            case 1:
                *node = makeintnode(en_icon, ((ULLONG_TYPE)ep->v.p[0]->v.i <= 
                    (ULLONG_TYPE)ep->v.p[1]->v.i));
                rv = TRUE;
                break;
            }
            break;
        case en_gt:
            rv |= opt0(&(ep->v.p[0]));
            rv |= opt0(&(ep->v.p[1]));
            mode = getmode(ep->v.p[0], ep->v.p[1]);
            switch (mode)
            {
            case 1:
                *node = makeintnode(en_icon, (ep->v.p[0]->v.i > ep->v.p[1]->v.i)
                    );
                rv = TRUE;
                break;
            }
            break;
        case en_ge:
            rv |= opt0(&(ep->v.p[0]));
            rv |= opt0(&(ep->v.p[1]));
            mode = getmode(ep->v.p[0], ep->v.p[1]);
            switch (mode)
            {
            case 1:
                *node = makeintnode(en_icon, (ep->v.p[0]->v.i >= ep->v.p[1]
                    ->v.i));
                rv = TRUE;
                break;
            }
            break;


        case en_cond:
            if (isoptconst(ep->v.p[0])) {
                if (isfloatconst(ep->v.p[0]->nodetype)) {
                    if (ep->v.p[0]->v.f)
                        *node = ep->v.p[1]->v.p[0];
                    else
                        *node = ep->v.p[1]->v.p[1];
                    rv |= opt0(node);
                    break;
                } else if (isintconst(ep->v.p[0]->nodetype)) {
                    if (ep->v.p[0]->v.i)
                        *node = ep->v.p[1]->v.p[0];
                    else
                        *node = ep->v.p[1]->v.p[1];
                    rv |= opt0(node);
                    break;
                }
            }
            // Fall Through
        case en_fcall:
        case en_void:
        case en_intcall:
        case en_voidnz:
        case en_dvoid:
        case en_pfcall:
        case en_pfcallb:
        case en_sfcall:
        case en_sfcallb:
        case en_scallblock:
        case en_assign:
        case en_moveblock:
        case en_stackblock:
        case en_callblock:
        case en_fcallb:
        case en_refassign:
        case en_pcallblock:
        case en_lassign:
        case en_thiscall:
        case en_repcons:
        case en_ainc:
        case en_adec:
            rv |= opt0(&(ep->v.p[1]));
        case en_trapcall:
        case en_conslabel:
        case en_destlabel:
        case en_movebyref:
        case en_substack:
        case en_clearblock:
            rv |= opt0(&(ep->v.p[0]));
            break;
    }
    return rv;
}

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

void enswap(ENODE **one, ENODE **two)
{
    ENODE *temp =  *one;
    *one =  *two;
    *two = temp;
}

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

int fold_const(ENODE *node)
/*
 *      fold_const will remove constant nodes and return the values to
 *      the calling routines.
 */
{
    int rv = FALSE;
    ENODE temp;
    if (node == 0)
        return 0;
    switch (node->nodetype)
    {
        case en_add:
        case en_addstruc:
		case en_array:
            rv |= fold_const(node->v.p[0]);
            rv |= fold_const(node->v.p[1]);
            if (isoptconst(node->v.p[1]))
            {
                switch (node->v.p[0]->nodetype)
                {
                case en_add:
                case en_addstruc:
				case en_array:
                    if (isoptconst(node->v.p[0]->v.p[0]))
                    {
                        int type = en_add;
                        if (node->nodetype == en_addstruc || node->v.p[0]
   	                        ->nodetype == en_addstruc)
       	                    type = en_addstruc;
                        node->nodetype = type;
                        node->v.p[0]->nodetype = en_add;
                        enswap(&node->v.p[0]->v.p[1], &node->v.p[1]);
                        rv = TRUE;
                    }
                    else if (isoptconst(node->v.p[0]->v.p[1]))
                    {
                        int type = en_add;

                        if (node->nodetype == en_addstruc || node->v.p[0]
   	                        ->nodetype == en_addstruc)
                            type = en_addstruc;
                        node->nodetype = type;
                        node->v.p[0]->nodetype = en_add;
                        enswap(&node->v.p[0]->v.p[0], &node->v.p[1]);
                        rv = TRUE;
                    }
                    break;
                case en_sub:
                    if (isoptconst(node->v.p[0]->v.p[0]))
                    {
                        int type = en_add;
                        if (node->nodetype == en_addstruc)
                            type = en_addstruc;
                        node->nodetype = en_sub;
                        node->v.p[0]->nodetype = type;
                        enswap(&node->v.p[0]->v.p[1], &node->v.p[1]);
                        rv = TRUE;
                    }
                    else if (isoptconst(node->v.p[0]->v.p[1]))
                    {
                        int type = en_add;
                        if (node->nodetype == en_addstruc)
                            type = en_addstruc;
                        node->nodetype = type;
                        node->v.p[0]->nodetype = en_sub;
                        enswap(&node->v.p[0]->v.p[0], &node->v.p[1]);
                        rv = TRUE;
                    }
                    break;
                }
            }
            else if (isoptconst(node->v.p[0]))
            {
                switch (node->v.p[1]->nodetype)
                {
                case en_add:
                case en_addstruc:
				case en_array:
                    if (isoptconst(node->v.p[1]->v.p[0]))
                    {
                        int type = en_add;
                        if (node->nodetype == en_addstruc || node->v.p[1]
                            ->nodetype == en_addstruc)
                            type = en_addstruc;
                        node->nodetype = type;
                        node->v.p[1]->nodetype = en_add;
                        enswap(&node->v.p[1]->v.p[1], &node->v.p[0]);
                        rv = TRUE;
                    }
                    else if (isoptconst(node->v.p[1]->v.p[1]))
                    {
                        int type = en_add;
                        if (node->nodetype == en_addstruc || node->v.p[1]
                            ->nodetype == en_addstruc)
                            type = en_addstruc;
                        node->nodetype = type;
                        node->v.p[1]->nodetype = en_add;
                        enswap(&node->v.p[1]->v.p[0], &node->v.p[0]);
                        rv = TRUE;
                    }
                    break;
                case en_sub:
                    if (isoptconst(node->v.p[1]->v.p[0]))
                    {
                        node->nodetype = en_sub;
                        node->v.p[1]->nodetype = en_add;
                        enswap(&node->v.p[0], &node->v.p[1]);
                        enswap(&node->v.p[0]->v.p[1], &node->v.p[1]);
                        rv = TRUE;
                    }
                    else if (isoptconst(node->v.p[1]->v.p[1]))
                    {
                        int type = en_add;
                        if (node->nodetype == en_addstruc)
                            type = en_addstruc;
                        node->nodetype = type;
                        node->v.p[1]->nodetype = en_sub;
                        enswap(&node->v.p[1]->v.p[0], &node->v.p[0]);
                        rv = TRUE;
                    }
                    break;
                }
            }
            break;
        case en_sub:
            rv |= fold_const(node->v.p[0]);
            rv |= fold_const(node->v.p[1]);
            if (isoptconst(node->v.p[1]))
            {
                switch (node->v.p[0]->nodetype)
                {
                case en_add:
                case en_addstruc:
				case en_array:
                    if (isoptconst(node->v.p[0]->v.p[0]))
                    {
                        int type = en_add;
                        if (node->nodetype == en_addstruc || node->v.p[0]
                            ->nodetype == en_addstruc)
                            type = en_addstruc;
                        node->nodetype = en_add;
                        node->v.p[0]->nodetype = en_sub;
                        enswap(&node->v.p[0]->v.p[1], &node->v.p[1]);
                        rv = TRUE;
                    }
                    else if (isoptconst(node->v.p[0]->v.p[1]))
                    {
                        int type = en_add;
                        if (node->nodetype == en_addstruc || node->v.p[0]
                            ->nodetype == en_addstruc)
                            type = en_addstruc;
                        node->nodetype = en_add;
                        node->v.p[0]->nodetype = en_sub;
                        enswap(&node->v.p[0]->v.p[0], &node->v.p[0]->v.p[1]);
                        enswap(&node->v.p[0]->v.p[1], &node->v.p[1]);
                        rv = TRUE;
                    }
                    break;
                case en_sub:
                    if (isoptconst(node->v.p[0]->v.p[0]))
                    {
                        enswap(&node->v.p[0]->v.p[1], &node->v.p[1]);
                        rv = TRUE;
                    }
                    else if (isoptconst(node->v.p[0]->v.p[1]))
                    {
                        enswap(&node->v.p[0], &node->v.p[1]);
                        enswap(&node->v.p[1]->v.p[0], &node->v.p[0]);
                        node->nodetype = en_add;