outco68.c

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

    val = val + 0xf080 + (fpcop << 9);
    if (prm_68020)
    {
        val |= 0x40;
        size = 4;
        ins->branched = BR_LONG | BR_FLOAT;
    }
    else
        ins->branched = BR_SHORT | BR_FLOAT;
    PUTWORD(p, val);
    addr = ResolveOffset(ins, ins->oper1->offset, &resolved);
    ins->ofs[ins->rescount] = addr;
    ins->pcrelofs = 2;
    ins->reloffset = ins->oper1;
    ins->resobyte[ins->rescount] = size;
    ins->addroffset[ins->rescount++] =  *p - ins->outbuf;
    if (size == 4)
        PUTWORD(p, addr >> 16);
    PUTWORD(p, addr);
}

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

static void putfdbranch(int val, OCODE *ins, unsigned char **p)
{
    int resolved = 1;
    long addr;
    PUTWORD(p, 0xf048 + (fpcop << 9) + (ins->oper1->preg));
    PUTWORD(p, val);
    addr = ResolveOffset(ins, ins->oper2->offset, &resolved);
    ins->branched = BR_SHORT | BR_FLOAT;
    ins->ofs[ins->rescount] = addr;
    ins->pcrelofs = 4;
    ins->reloffset = ins->oper1;
    ins->resobyte[ins->rescount] = 2;
    ins->addroffset[ins->rescount++] =  *p - ins->outbuf;
    PUTWORD(p, addr);
}

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

static void putfscc(int val, OCODE *ins, unsigned char **p)
{
    PUTWORD(p, 0xf040 + (fpcop << 9));
    PUTWORD(p, val);
    putam(ins->length, ins, ins->oper1, p);
}

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

int putftrapcc(int val, OCODE *ins, unsigned char **p)
{
    int dword = FALSE;
    int select = 0xf078 + (fpcop << 9);
    if (!ins->oper1)
        select |= 4;
    else if (ins->oper1->length == 4)
    {
        select |= 3;
        dword = TRUE;
    }
    else
        select |= 2;
    PUTWORD(p, select);
    PUTWORD(p, val);
    if (ins->oper1)
    {
        int resolved = 1;
        int adr = ResolveOffset(ins, ins->oper1->offset, &resolved);
        if (resolved)
        {
            if (dword)
                PUTWORD(p, ins->oper1->offset->v.i >> 16);
            PUTWORD(p, ins->oper1->offset->v.i &0xffff);
        }
        else
        {
            ins->ofs[ins->rescount] = adr;
            ins->resobyte[ins->rescount] = dword ? 4 : 2;
            ins->addroffset[ins->rescount++] =  *p - ins->outbuf;
            if (dword)
                PUTWORD(p, adr >> 16);
            PUTWORD(p, adr &0xffff);
        }

    }
}

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

static void putmath(int val, OCODE *ins, unsigned char **p)
{
    if (ins->oper2->mode == am_dreg)
    {
        PUTWORD(p, val + (ins->oper2->preg << 9) + ((ins->length / 2) << 6));
        putam(ins->length, ins, ins->oper1, p);
    }
    else
    {
        PUTWORD(p, val + 0x100 + (ins->oper1->preg << 9) + ((ins->length / 2)
            << 6));
        putam(ins->length, ins, ins->oper2, p);
    }
}

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

static void putmathimm(int val, OCODE *ins, unsigned char **p)
{
    int resolved = 1;
    int adr = 0;
    adr = ResolveOffset(ins, ins->oper1->offset, &resolved);

    PUTWORD(p, val + ((ins->length / 2) << 6));
    switch (ins->length)
    {
        case 1:
            if (resolved)
            {
                PUTWORD(p, ins->oper1->offset->v.i &0xff);
            }
            else
            {
                PUTWORD(p, adr &255);
                ins->ofs[ins->rescount] = adr &255;
                ins->resobyte[ins->rescount] = 2;
                ins->addroffset[ins->rescount++] =  *p - ins->outbuf;
            }
            break;
        case 2:
            if (resolved)
            {
                PUTWORD(p, ins->oper1->offset->v.i);
            }
            else
            {
                PUTWORD(p, adr);
                ins->ofs[ins->rescount] = adr;
                ins->resobyte[ins->rescount] = 2;
                ins->addroffset[ins->rescount++] =  *p - ins->outbuf;
            }
            break;
        case 4:
            if (resolved)
            {
                PUTWORD(p, ins->oper1->offset->v.i >> 16);
                PUTWORD(p, ins->oper1->offset->v.i &65535);
            }
            else
            {
                PUTWORD(p, adr >> 16);
                PUTWORD(p, adr);
                ins->ofs[ins->rescount] = adr;
                ins->resobyte[ins->rescount] = 4;
                ins->addroffset[ins->rescount++] =  *p - ins->outbuf;
            }
            break;
    }
    putam(ins->length, ins, ins->oper2, p);
}

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

static void putshift(int val, OCODE *ins, unsigned char **p)
{
    if (!ins->oper2)
    {
        val |= 0xc0;
        val |= (val &0x18) << 6;
        val &= ~0x18;
        PUTWORD(p, val);
        putam(ins->length, ins, ins->oper1, p);
    }
    else
    {
        switch (ins->oper1->mode)
        {

            case am_dreg:
                val |= ins->length / 2 << 6;
                val |= 0x20 + (ins->oper1->preg << 9) + ins->oper2->preg;
                PUTWORD(p, val);
                break;
            case am_immed:
                val |= ins->length / 2 << 6;
                val |= ((ins->oper1->offset->v.i &7) << 9) + ins->oper2->preg;
                PUTWORD(p, val);
                break;
        }
    }
}

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

static void putmuldiv(int longv, int wval, int lval, int ltrail, OCODE *ins,
    unsigned char **p)
{
    int temp;
    if (longv)
    {
        /* divsl & divul */
        PUTWORD(p, 0x4c40);
        if (ins->oper2->mode == am_divsl)
        {
            PUTWORD(p, ltrail | ins->oper2->preg | (ins->oper2->sreg << 12));
        }
        else
            PUTWORD(p, ltrail | ins->oper2->preg | (ins->oper2->preg << 12));
        putam(ins->length, ins, ins->oper1, p);
    }
    else
    {
        if (ins->length == 2)
        {
            PUTWORD(p, wval | (ins->oper2->preg << 9));
            putam(ins->length, ins, ins->oper1, p);
        }
        else
        {
            PUTWORD(p, lval);
            if (ins->oper2->mode == am_divsl)
                temp = 0x400 | ltrail | ins->oper2->preg | (ins->oper2->sreg <<
                    12);
            else
                temp = ltrail | ins->oper2->preg | (ins->oper2->preg << 12);
            PUTWORD(p, temp)putam(ins->length, ins, ins->oper1, p);
        }
    }
}

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

static void putsbit(int reg, int immed, OCODE *ins, unsigned char **p)
{
    if (ins->oper1->mode == am_immed)
    {
        PUTWORD(p, immed);
        PUTWORD(p, ins->oper1->offset->v.i);
    }
    else
        PUTWORD(p, reg | (ins->oper1->preg << 9));
    putam(ins->length, ins, ins->oper2, p);
}

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

static void putfbit(int val, OCODE *ins, AMODE *reg, AMODE *data, AMODE *bf,
    unsigned char **p)
{
    PUTWORD(p, val);
    if (reg)
        val = reg->preg << 12;
    else
        val = 0;
    if (bf->mode == am_bf)
    {
        val += bf->preg << 6;
        val += bf->sreg;
    }
    else
    {
        val += bf->preg << 6;
        val += bf->sreg;
        val += 0x0820;
    }
    PUTWORD(p, val);
    putam(4, ins, data, p);
}

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

static int fsize(int size)
{
    int val;
    switch (size)
    {
        case 1:
            val = 6 << 10;
            break;
        case 2:
            val = 4 << 10;
            break;
        case 4:
            val = 0 << 10;
            break;
        case 7:
            val = 1 << 10;
            break;
        case 8:
            val = 5 << 10;
            break;
        case 10:
        default:
            val = 2 << 10;
            break;
    }
    return val;
}

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

static void putfloat(int val, int size, OCODE *ins, AMODE *o1, AMODE *o2,
    unsigned char **p)
{
    int doam = FALSE;
    PUTWORD(p, 0xf000 + (fpcop << 9));
    if (!o1)
    {
        if (o2->mode == am_freg)
        {
            //        val |= o2->preg << 7 ; 
            val |= o2->preg << 10;
        }
        else
        {
            val |= fsize(size);
            val |= 0x4000;
            doam = TRUE;
        }
    }
    else if (!o2)
    {
        if (o1->mode == am_freg)
        {
            val |= o1->preg << 7;
            val |= o1->preg << 10;
        }
        else
        {
            val |= fsize(size);
            val |= 0x4000;
            doam = TRUE;
        }
    }
    else
    {
        if (o1->mode == am_freg)
        {
            val |= o1->preg << 10;
        }
        else
        {
            val |= fsize(size);
            val |= 0x4000;
            doam = TRUE;
        }
        val |= o2->preg << 7;
    }
    PUTWORD(p, val);
    if (doam)
        putam(size, ins, ins->oper1, p);
}

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

int putdecimal(int val, OCODE *ins, unsigned char **p)
{
    if (ins->oper1->mode == ins->oper2->mode)
    {
        if (ins->oper1->mode == am_dreg)
        {
            PUTWORD(p, val + ins->oper1->preg + (ins->oper2->preg << 9));
        }
        else if (ins->oper1->mode == am_adec)
            PUTWORD(p, val + 8+ins->oper1->preg + (ins->oper2->preg << 9));
    }
}

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

int putaddx(int val, OCODE *ins, unsigned char **p)
{
    putdecimal(val, ins, p);
    ins->outbuf[1] |= (ins->length / 2) << 6;
}

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

int puttrapcc(OCODE *ins, int val, unsigned char **p)
{
    int dword = FALSE;
    if (!ins->oper1)
        val |= 4;
    else if (ins->oper1->length == 4)
    {
        val |= 3;
        dword = TRUE;
    }
    else
        val |= 2;
    PUTWORD(p, val);
    if (ins->oper1)
    {
        int resolved = 1;
        int adr = ResolveOffset(ins, ins->oper1->offset, &resolved);
        if (resolved)
        {
            if (dword)
                PUTWORD(p, ins->oper1->offset->v.i >> 16);
            PUTWORD(p, ins->oper1->offset->v.i &0xffff);
        }
        else
        {
            ins->ofs[ins->rescount] = adr;
            ins->resobyte[ins->rescount] = dword ? 4 : 2;
            ins->addroffset[ins->rescount++] =  *p - ins->outbuf;
            if (dword)
                PUTWORD(p, adr >> 16);
            PUTWORD(p, adr &0xffff);
        }

    }
}

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

int putpack(int val, OCODE *ins, unsigned char **p)
{
    val |= ins->oper1->preg;
    val |= ins->oper2->preg << 9;
    if (ins->oper1->mode != am_dreg)
        val |= 8;
    PUTWORD(p, val);
    PUTWORD(p, ins->oper3->offset->v.i);
}

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

int putfsincos(OCODE *ins, unsigned char **p)
{
    int val = 0x30;
    PUTWORD(p, 0xf000 + (fpcop << 9));
    if (ins->oper1->mode == am_freg)
    {
        val |= ins->oper1->preg << 10;
    }
    else
    {
        val |= fsize(ins->length);
        val |= 0x4000;
    }
    val |= ins->oper2->preg;
    val |= ins->oper3->preg << 7;