gexpr386.c

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

                        ap->tempflag = TRUE;
                        ap->seg = 0;
                    }
                }
            }
            else
            {
                int seg = 0;
                if (osize !=  BESZ_FARPTR && isize ==  BESZ_FARPTR)
                {
                    isize = BESZ_DWORD ;
                    ap->length = 0;
                    seg = temp_seg();
                }
                if (osize ==  BESZ_FARPTR)
                {
                    seg = temp_seg();
                    if (ap->mode == am_immed)
                    {
                        #if sizeof(ULLONG_TYPE) == 4
                            gen_code(op_mov, ap2, make_immed(0));
                        #else 
                            gen_code(op_mov, ap2, make_immed(ap->offset->v.i >>
                                32));
                        #endif 
                        ap3 = xalloc(sizeof(AMODE));
                        ap3->mode = am_seg;
                        ap3->seg = seg;
                        gen_code2(op_mov, BESZ_WORD, BESZ_DWORD , ap3, ap2);
                        gen_code(op_mov, ap2, make_immed(ap->offset->v.i
                            &0xffffffff));
                    }
                    else
                    {
                        ap2->length = BESZ_DWORD ;
                        ap->length = 0;
                        gen_code(ldx[seg], ap2, ap);
                        ap->length = BESZ_DWORD ;
                    }

                    ap->mode = ap2->mode;
                    ap->preg = ap2->preg;
                    ap->seg = seg;
                    ap->tempflag = ap2->tempflag;
                }
                else if (ap->mode != am_dreg || ap->preg != ap2->preg)
                {
                    if (isize == BESZ_QWORD || isize ==  - BESZ_QWORD)
                    if (ap->mode == am_axdx)
                    {
                        if (ap2->preg != EAX)
                        {
                            regs[ap2->preg]--;
                            regs[EAX]++;
                        }
                        ap2->mode = am_dreg;
                        ap2->preg = EAX;
                        ap2->tempflag = 1;
                    }
                    else
                    {
                        if (seg == 0)
                            ap2->length = ap->length = BESZ_DWORD ;
                        else
                        {
                            ap2->length = BESZ_DWORD ;
                            ap->length = 0;
                        }
                        gen_code(ldx[seg], ap2, ap);
                        ap->length = BESZ_DWORD ;
                    }
                    else
                    {
                        if (seg == 0)
                            ap2->length = ap->length = isize;
                        else
                        {
                            ap2->length = BESZ_DWORD ;
                            ap->length = 0;
                        }
                        gen_code(ldx[seg], ap2, ap);
                        if (seg)
                            ap->length = BESZ_DWORD ;
                    }

                    ap->mode = ap2->mode;
                    ap->preg = ap2->preg;
                    ap->seg = seg;
                    ap->tempflag = ap2->tempflag;
                }
            }
        }
        else
        {
            /* moving up in type */
            if (isize > BESZ_QWORD)
            {
                if (isize >= BESZ_CFLOAT) {
                    complexload(ap,TRUE);
                    freeop(ap2);
                } else if (isize >=BESZ_IFLOAT)
                    if (osize >= BESZ_CFLOAT)
                    {
                        freeop(ap2);
                        if (ap->mode != am_freg)
                            floatload(ap, TRUE);
                        gen_codef(op_fldz,0,0);
                        ap->mode = am_frfr;
                        ap->length = BESZ_CLDOUBLE;
                    }
                    else if (osize < BESZ_IFLOAT)
                    {
                        if (ap->mode == am_freg)
                            gen_codefs(op_fstp,BESZ_LDOUBLE,floatconvpos(),0);
                        freeop(ap2);
                        gen_codef(op_fldz,0,0) ;
                        ap->mode = am_freg;
                        ap->length = BESZ_LDOUBLE;
                    }
                    else 
                    {
                        if (ap->mode != am_freg) 
                        {
                            floatload(ap, TRUE);
                            ap->length = osize;
                            freeop(ap2);
                        }
                    }
                else if (osize >= BESZ_CFLOAT)
                {
                    freeop(ap2);
                    gen_codef(op_fldz,0,0);
                    if (ap->mode != am_freg)
                        floatload(ap, TRUE);
                    else
                        gen_codef(op_fxch,0,0);
                    ap->mode = am_frfr;
                    ap->length = BESZ_CLDOUBLE;
                }
                else if (osize >= BESZ_IFLOAT)
                {
                    freeop(ap2);
                    if (ap->mode == am_freg)
                            gen_codefs(op_fstp,BESZ_LDOUBLE,floatconvpos(),0);
                    gen_codef(op_fldz,0,0);
                    ap->mode = am_freg;
                    ap->length = osize;
                }
                else
                {
                    if (ap->mode != am_freg)
                        floatload(ap, TRUE);
                    freeop(ap2);
                    ap->mode = am_freg;
                    ap->length = osize;
                }
            }
            else if (isize == BESZ_QWORD || isize ==  - BESZ_QWORD)
            {
                if (ap->mode == am_axdx)
                {
                    freeop(ap2);
                    ap1 = floatconvpos();
                    gen_codes(op_mov, BESZ_DWORD , ap1, makedreg(EAX));
                    ap1->offset = makenode(en_add, ap1->offset, makeintnode
                        (en_icon, 4));
                    gen_codes(op_mov, BESZ_DWORD , ap1, makedreg(EDX));
                }
                else
                    ap1 = ap;
                if (osize >= BESZ_CFLOAT) 
                {
                    gen_codef(op_fldz,0,0);
                    gen_codes(op_fild, BESZ_DOUBLE, ap1, 0);
                    freeop(ap2);
                    ap->mode = am_frfr;
                    ap->length = BESZ_CLDOUBLE;
                }
                else if (osize >= BESZ_IFLOAT)
                {
                    gen_codes(op_fild, BESZ_DOUBLE, ap1, 0);
                    freeop(ap2);
                    gen_codef(op_fldz,0,0);
                    ap->mode = am_freg;
                    ap->length = osize;
                } 
                else 
                {
                    gen_codes(op_fild, BESZ_DOUBLE, ap1, 0);
                    freeop(ap2);
                    ap->mode = am_freg;
                    ap->length = osize;
                }
            }
            else if (isize ==  BESZ_FARPTR)
            {
                freeop(ap2);
                if (ap->mode == am_dreg)
                {
                    if (ap->preg != EAX)
                        gen_codes(op_mov, BESZ_DWORD , makedreg(EAX), ap);
                    ap3 = xalloc(sizeof(AMODE));
                    ap3->mode = am_seg;
                    ap3->seg = ap->seg;
                    gen_codes(op_mov, BESZ_DWORD , makedreg(EDX), ap3);
                }
                else if (ap->mode == am_immed)
                {
                    #if sizeof(ULLONG_TYPE) == 4
                        gen_codes(op_mov, BESZ_DWORD , makedreg(EDX), make_immed(0));
                    #else 
                        gen_codes(op_mov, BESZ_DWORD , makedreg(EDX), make_immed((ap
                            ->offset->v.i >> 32) &0xffff));
                    #endif 
                    gen_codes(op_mov, BESZ_DWORD , makedreg(EAX), make_immed(ap->offset
                        ->v.i &0xffffffff));
                }
                else
                {
                    ap3 = copy_addr(ap);
                    ap3->offset = makenode(en_add, ap3->offset, makeintnode
                        (en_icon, 4));
                    gen_code2(op_movzx, BESZ_DWORD , BESZ_WORD, makedreg(EDX), ap3);
                    gen_codes(op_mov, BESZ_DWORD , makedreg(EAX), ap);
                }
                ap->seg = 0;
                ap->mode = am_axdx;
            }
            else if (osize > BESZ_QWORD)
            {
                if (osize >= BESZ_IFLOAT && osize < BESZ_CFLOAT) 
                {
                    freeop(ap2);
                    gen_codef(op_fldz,0,0);
                    ap->mode = am_freg;
                    ap->length = osize;
                }
                else
                {
                    if (isize != BESZ_DWORD  && isize !=  - BESZ_DWORD )
                    {
                        ap1 = floatconvpos();
                        if (ap->mode == am_seg)
                            gen_code2(op_movzx, BESZ_DWORD , isize, ap2, ap);
                        else if (isize < 0)
                            gen_code2(op_movsx, BESZ_DWORD , isize, ap2, ap);
                        else
                            gen_code2(op_mov, BESZ_DWORD , BESZ_DWORD , ap2, ap);
                        gen_codes(op_mov, BESZ_DWORD , ap1, ap2);
                        gen_codefs(op_fild, BESZ_DWORD, ap1, 0);
                    }
                    else
                        if (ap->mode == am_direct || ap->mode == am_indisp || ap
                            ->mode == am_indispscale)
                            gen_codefs(op_fild, BESZ_DWORD , ap, 0);
                        else
                    {
                        ap1 = floatconvpos();
                        gen_codes(op_mov, BESZ_DWORD , ap1, ap);
                        gen_codefs(op_fild, BESZ_DWORD , ap1, 0);
                    }
                    if (osize >= BESZ_CFLOAT)
                    {
                        freeop(ap2);
                        gen_codef(op_fldz,0,0);
                        gen_codef(op_fxch,0,0);
                        ap->mode = am_frfr;
                        ap->length = BESZ_CLDOUBLE;
                    }
                    else
                    {
                        freeop(ap2);
                        ap->mode = am_freg;
                        ap->length = osize;
                    }
                }
            }
            else
            {
                int size6 = osize == BESZ_QWORD || osize ==  - BESZ_QWORD;
                if (osize == BESZ_QWORD || osize ==  - BESZ_QWORD)
                    osize = BESZ_DWORD ;
                if (ap->mode == am_dreg && ap->preg > 3 && (isize == BESZ_BYTE || isize
                    ==  - BESZ_BYTE))
                    gen_codes(op_mov, BESZ_DWORD , ap2, ap);
                if (size6 && (isize == BESZ_DWORD  || isize ==  - BESZ_DWORD ))
                    gen_codes(op_mov, isize, ap2, ap);
                else if (ap->mode == am_seg)
                {
                    gen_codes(op_mov, BESZ_DWORD , ap2, ap);
                }
                else if ((isize ==  - BESZ_DWORD  || isize == BESZ_DWORD ) && osize ==  BESZ_FARPTR)
                {
                    gen_codes(op_mov, BESZ_DWORD , ap2, ap);
                    ; // nothing here
                }
                else
                {
                    if (osize ==  BESZ_FARPTR)
                        osize = BESZ_DWORD ;
                    if (isize < 0)
                        gen_code2(op_movsx, osize, isize, ap2, ap);
                    else
                        gen_code2(op_movzx, osize, isize, ap2, ap);
                }
                if (size6)
                {
                    freeop(ap2);
                    tempaxdx();
                    if (ap2->preg != EAX)
                        gen_codes(op_mov, BESZ_DWORD , makedreg(EAX), ap2);
                    if (isize < 0)
                        gen_code(op_cdq, 0, 0);
                    else
                        gen_codes(op_sub, BESZ_DWORD , makedreg(EDX), makedreg(EDX));
                    ap->mode = am_axdx;
                    ap->length = BESZ_QWORD;
                    ap->seg = 0;
                    osize = BESZ_QWORD;
                }
                else
                {
                    ap->seg = 0;
                    ap->mode = am_dreg;
                    ap->preg = ap2->preg;
                    ap->tempflag = ap2->tempflag;
                }
            }
        }
    }
    if (flags &(F_FREG | F_DREG))
    {
        if (flags &F_DREG)
        {
            if (ap->mode != am_dreg || !ap->tempflag && (flags &F_VOL))
            if (isize == osize || isize ==  - osize || ap->mode == am_immed)
            {
                if (osize < BESZ_FLOAT)
                {
                    int seg = 0;
                    freeop(ap);
                    ap2 = temp_data();
                    ap2->length = osize;
                    if (isize ==  BESZ_FARPTR)
                    {
                        seg = temp_seg();
                        ap2->length = BESZ_DWORD ;
                        ap->length = 0;
                        gen_code(ldx[seg], ap2, ap);
                        osize =  BESZ_FARPTR;
                    }
                    else
                    {
                        gen_code(op_mov, ap2, ap);
                    }
                    ap->mode = ap2->mode;
                    ap->preg = ap2->preg;
                    ap->seg = seg;
                    ap->tempflag = ap2->tempflag;
                }
                else
                {
                    if (ap->mode == am_immed)
                        make_floatconst(ap);
                    floatload(ap, TRUE);
                }
            }
        }
        else if (ap->mode != am_freg)
        {
            if (ap->mode == am_immed)
                make_floatconst(ap);
            floatload(ap, TRUE);
        }
    }
    if ((flags &F_AXDX) && !(flags &(F_MEM | F_IMMED)) && ap->mode != am_axdx)
        loadaxdx(ap);
    if (osize != isize && osize == BESZ_BOOL)
    {
        int lab = nextlabel++;
        if (isize != BESZ_QWORD && isize !=  - BESZ_QWORD)
        {
            ap2 = temp_data();
            gen_codes(op_mov, ap->length, ap2, ap);
            gen_codes(op_or, ap->length, ap2, ap2);
        }
        else
        {
            if (ap->mode != am_axdx)
                loadaxdx(ap);
            gen_codes(op_or, BESZ_DWORD , makedreg(EAX), makedreg(EDX));
            freeop(ap);
            ap2 = temp_data();
        }
        ap2->length = BESZ_BYTE;
        gen_code(op_setne, ap2, 0);
        freeop(ap);
        ap->mode = ap2->mode;
        ap->tempflag = ap2->tempflag;
        ap->length = ap2->length;
        ap->preg = ap2->preg;
        ap->seg = 0;
    }
    if (ap->mode == am_screg || ap->mode == am_sdreg || ap->mode == am_streg ||
        ap->mode == am_seg)
    {
        ap2 = temp_data();
        gen_codes(op_mov, BESZ_DWORD , ap2, ap);
        ap->mode = ap2->mode;
        ap->tempflag = ap2->tempflag;
        ap->length = ap2->length;
        ap->preg = ap2->preg;
        ap->seg = 0;
    }
    ap->length = osize;
    if (osize == BESZ_BOOL)
        ap->length = BESZ_BOOL;
}