an386.c

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

                freeop(ap);
                if (lvalue(exptr) && ((SYM*)exptr->v.p[0]->v.p[0])->funcparm)
                {
                    ((SYM*)exptr->v.p[0]->v.p[0])->mainsym->inreg = TRUE;
                    ((SYM*)exptr->v.p[0]->v.p[0])->mainsym->value.i =  - csp
                        ->reg - (csp->size < 0 ?  - csp->size: csp->size) *256;
                }
            }
        }
        csp = csp->next;
    }
    gen_label(startlab);
}

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

void asm_scannode(ENODE *node)
{
    CSE *csp;
    if (node->nodetype == en_add || node->nodetype == en_addstruc)
    {
        asm_scannode(node->v.p[0]);
        asm_scannode(node->v.p[1]);
    }
    else
    {
        switch (node->nodetype)
        {
            case en_icon:
            case en_lcon:
            case en_iucon:
            case en_lucon:
            case en_ccon:
            case en_cucon:
            case en_boolcon:
                break;
            case en_napccon:
            case en_nacon:
            case en_absacon:
            case en_autocon:
            case en_autoreg:
                csp = enternode(node, 0, 0);
                csp->voidf = TRUE;
                break;
            case en_labcon:
            case en_nalabcon:
                break;
            default:
                DIAG("Invalid node in assembler line");
                break;
        }
    }
}

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

void asm_scan1(AMODE *ap)
{
    if (!ap || !ap->offset)
        return ;
    asm_scannode(ap->offset);
}

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

void asm_scan(OCODE *cd)
{
    asm_scan1(cd->oper1);
    asm_scan1(cd->oper2);
    asm_scan1(cd->oper3);
}

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

void asm_repnode(ENODE **node)
{
    if ((*node)->nodetype == en_add || (*node)->nodetype == en_addstruc)
    {
        asm_repnode(&(*node)->v.p[0]);
        asm_repnode(&(*node)->v.p[1]);
    }
    else
    if ((*node)->nodetype == en_autocon || (*node)->nodetype == en_autoreg)
    {
        *node = makeintnode(en_icon, (*node)->v.sp->value.i);
    }
    else if ((*node)->nodetype == en_nacon || (*node)->nodetype == en_napccon)
    {
        *node = makenode((*node)->nodetype, (*node)->v.sp, 0);
    }
    else if ((*node)->nodetype == en_nalabcon)
    {
        *node = makenode((*node)->nodetype, (*node)->v.sp, 0);
    }
    else if ((*node)->nodetype == en_labcon)
    {
        *node = makeintnode((*node)->nodetype, (*node)->v.i);
    }
    else if ((*node)->nodetype == en_absacon)
    {
        *node = makeintnode(en_absacon, ((SYM*)(*node)->v.p[0])->value.i);

    }
}

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

int voidexpr(ENODE *node)
{
    CSE *csp;
    if (node == 0)
        return 0;
    switch (node->nodetype)
    {
        case en_conslabel:
        case en_destlabel:
        case en_movebyref:
            return voidexpr(node->v.p[0]);
        case en_structret:
            return 0;
        case en_rcon:
        case en_lrcon:
        case en_fcon:
        case en_rcomplexcon:
        case en_lrcomplexcon:
        case en_fcomplexcon:
        case en_rimaginarycon:
        case en_lrimaginarycon:
        case en_fimaginarycon:
            return 1;
        case en_boolcon:
        case en_icon:
        case en_lcon:
        case en_iucon:
        case en_lucon:
        case en_ccon:
        case en_cucon:
        case en_llcon:
        case en_llucon:
        case en_nacon:
        case en_napccon:
        case en_absacon:
        case en_autocon:
        case en_autoreg:
            return 0;
        case en_floatref:
        case en_doubleref:
        case en_longdoubleref:
        case en_fimaginaryref:
        case en_rimaginaryref:
        case en_lrimaginaryref:
        case en_fcomplexref:
        case en_rcomplexref:
        case en_lrcomplexref:
            return 1;
        case en_bool_ref:
        case en_ub_ref:
        case en_uw_ref:
        case en_b_ref:
        case en_w_ref:
        case en_l_ref:
        case en_ul_ref:
        case en_ll_ref:
        case en_ull_ref:
        case en_fp_ref:
			case en_i_ref:
			case en_ui_ref:
			case en_a_ref: case en_ua_ref:
            return 0;
        case en_uminus:
        case en_bits:
        case en_asuminus:
        case en_ascompl:
        case en_not:
        case en_compl:
        case en_cl_reg:
            return voidexpr(node->v.p[0]);
        case en_fcall:
        case en_pfcall:
        case en_pfcallb:
        case en_sfcall:
        case en_sfcallb:
        case en_fcallb:
            {
                SYM *sp;
                ENODE *node2 = node->v.p[1]->v.p[0]->v.p[0];
                if (node2->nodetype == en_nacon || node2->nodetype ==
                    en_napccon)
                {
                    sp = node2->v.sp;
                    if (sp && (sp->value.classdata.cppflags &PF_INLINE))
                        voidfloat(sp->value.classdata.inlinefunc->stmt);
                }
            }
        case en_cfc:
        case en_crc:
        case en_clrc:
        case en_cfi:
        case en_cri:
        case en_clri:
        case en_cb:
        case en_cub:
        case en_cbool:
        case en_cw:
        case en_cuw:
        case en_cl:
        case en_cul:
		case en_ci:
		case en_cui:
        case en_cll:
        case en_cull:
        case en_cf:
        case en_cd:
        case en_cp:
        case en_cld:
        case en_cfp:
        case en_csp:
        case en_thiscall:
        case en_ainc:
        case en_adec:
        case en_add:
        case en_sub:
        case en_addstruc:
        en_addcast: case en_umul:
        case en_udiv:
        case en_umod:
        case en_mul:
        case en_div:
        case en_mod:
        case en_lsh:
        case en_asalsh:
        case en_asarsh:
        case en_alsh:
        case en_arsh:
        case en_arshd:
        case en_asarshd:
        case en_rsh:
        case en_and:
        case en_or:
        case en_xor:
        case en_land:
        case en_lor:
        case en_eq:
        case en_ne:
        case en_lt:
        case en_le:
        case en_ugt:
        case en_uge:
        case en_ult:
        case en_ule:
        case en_gt:
        case en_ge:
        case en_cond:
        case en_void:
        case en_voidnz:
        case en_dvoid:
        case en_pmul:
		case en_arrayindex:
        case en_moveblock:
        case en_stackblock:
        case en_intcall:
        case en_pdiv:
        case en_repcons:
        case en_scallblock:
        case en_callblock:
        case en_pcallblock:
		case en_array:
            return voidexpr(node->v.p[0]) || voidexpr(node->v.p[1]);
        case en_trapcall:
        case en_substack:
        case en_clearblock:
            return voidexpr(node->v.p[0]);
            //												return voidexpr(node->v.p[1]);
        case en_asadd:
        case en_assub:
        case en_asmul:
        case en_asdiv:
        case en_asor:
        case en_asand:
        case en_asxor:
        case en_asmod:
        case en_aslsh:
        case en_asumod:
        case en_asudiv:
        case en_asumul:
        case en_asrsh:
        case en_assign:
        case en_refassign:
        case en_lassign:
            if (voidexpr(node->v.p[1]))
            {
                csp = searchnode(node->v.p[0]);
                if (csp)
                    csp->voidf = 1;
            }
            return voidexpr(node->v.p[0]);
        default:
            return 0;
    }

}

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

void voidfloat(SNODE *block)
/*
 * Scan through a block and void all CSEs which do asadd, asmul, asmodiv
 * of float to int
 */
{
    while (block != 0)
    {
        switch (block->stype)
        {
            case st_return:
            case st_expr:
                voidexpr(block->exp);
                break;
            case st_while:
            case st_do:
                voidexpr(block->exp);
                voidfloat(block->s1);
                break;
            case st_for:
                voidexpr(block->label);
                voidexpr(block->exp);
                voidfloat(block->s1);
                voidexpr(block->s2);
                break;
            case st_if:
                voidexpr(block->exp);
                voidfloat(block->s1);
                voidfloat(block->s2);
                break;
            case st_switch:
                voidexpr(block->exp);
                voidfloat(block->s1);
                break;
            case st_case:
                voidfloat(block->s1);
                break;
            case st_block:
                voidfloat(block->exp);
                break;
        }
        block = block->next;
    }
}

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

void asm_repcse1(AMODE *ap)
{
    if (!ap || !ap->offset)
        return ;
    asm_repnode(&ap->offset);
}

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

void asm_repcse(OCODE *cd)
{
    asm_repcse1(cd->oper1);
    asm_repcse1(cd->oper2);
    asm_repcse1(cd->oper3);
}