ipointer.c

来自「CC386 is a general-purpose 32-bit C comp」· C语言 代码 · 共 819 行 · 第 1/2 页

                        if (!list->dc.right)
                        {
                            sp = varsp(list->dc.left->offset);
                            if (list->dc.left->mode == i_immed)
                            {
                                if (sp)
                                {
                                    setbit(temparray4 + pi * sourcebytes, list
                                        ->sourceindx);
                                }
                            }
                            else if (list->dc.left->mode == i_direct)
                            {
                                if (sp && sp->ipointerindx)
                                    memcpy(temparray4 + pi * sourcebytes,
                                        temparray4 + (sp->ipointerindx - 1)
                                        *sourcebytes, sourcebytes);
                            }
                        }
                        else
                        {
                            done = FALSE;
                            sp = varsp(list->dc.right->offset);
                            if (list->dc.right->mode == i_immed)
                            {
                                if (sp)
                                {
                                    sp2 = varsp(list->dc.left->offset);
                                    if (!sp2 || list->dc.left->mode != i_immed)
                                    {
                                        setbit(temparray4 + pi * sourcebytes,
                                            list->sourceindx);
                                        done = TRUE;
                                    }
                                }
                            }
                            else if (list->dc.right->mode == i_direct)
                            {
                                if (sp && sp->ipointerindx)
                                {
                                    sp2 = varsp(list->dc.left->offset);
                                    if (!sp2 || list->dc.left->mode != i_immed)
                                    {
                                        memcpy(temparray4 + pi * sourcebytes,
                                            temparray4 + (sp->ipointerindx - 1)
                                            *sourcebytes, sourcebytes);
                                        done = TRUE;
                                    }
                                }
                            }
                            if (!done)
                            {
                                sp = varsp(list->dc.left->offset);
                                if (list->dc.left->mode == i_immed)
                                {
                                    if (sp)
                                    {
                                        sp2 = varsp(list->dc.right->offset);
                                        if (!sp2 || list->dc.right->mode !=
                                            i_immed)
                                        {
                                            setbit(temparray4 + pi *
                                                sourcebytes, list->sourceindx);
                                        }
                                    }
                                }
                                else if (list->dc.left->mode == i_direct)
                                {
                                    if (sp && sp->ipointerindx)
                                    {
                                        sp2 = varsp(list->dc.right->offset);
                                        if (!sp2 || list->dc.right->mode !=
                                            i_immed)
                                            memcpy(temparray4 + pi *
                                                sourcebytes, temparray4 + (sp
                                                ->ipointerindx - 1)
                                                *sourcebytes, sourcebytes);
                                    }
                                }
                            }
                        }
                    }
                    else if (list->ans->mode == i_ind)
                    {
                        if (isset(temparray4 + pi * sourcebytes, 0))
                        {
                            for (i = 0; i < pointer_count; i++)
                            {
                                memset(temparray4 + i * sourcebytes, 0,
                                    sourcebytes);
                                setbit(temparray4 + i * sourcebytes, 0);
                            }
                        }
                        else
                        for (i = 1; i < source_count; i++)
                        {
                            if (isset(temparray4 + pi * sourcebytes, i))
                            {
                                int pi1 =  - 1;
                                QUAD *q = sourcearray[i];
                                sp = varsp(q->dc.left->offset);
                                if (sp && q->dc.left->mode == i_immed && sp
                                    ->ipointerindx)
                                {
                                    pi1 = sp->ipointerindx - 1;
                                }
                                else
                                {
                                    if (q->dc.right)
                                    {
                                        sp = varsp(q->dc.right->offset);
                                        if (sp && q->dc.right->mode == i_immed
                                            && sp->ipointerindx)
                                        {
                                            pi1 = sp->ipointerindx - 1;
                                        }
                                    }
                                }
                                if (pi1 !=  - 1)
                                {
                                    memset(temparray4 + pi1 * sourcebytes, 0,
                                        sourcebytes);
                                    if (!list->dc.right)
                                    {
                                        sp = varsp(list->dc.left->offset);
                                        if (list->dc.left->mode == i_immed)
                                        {
                                            if (sp)
                                            {
                                                setbit(temparray4 + pi1 *
                                                    sourcebytes, list
                                                    ->sourceindx);
                                            }
                                        }
                                        else if (list->dc.left->mode ==
                                            i_direct)
                                        {
                                            if (sp && sp->ipointerindx)
                                                memcpy(temparray4 + pi1 *
                                                    sourcebytes, temparray4 + 
                                                    (sp->ipointerindx - 1)
                                                    *sourcebytes, sourcebytes);
                                        }
                                    }
                                    else
                                    {
                                        done = FALSE;
                                        sp = varsp(list->dc.right->offset);
                                        if (list->dc.right->mode == i_immed)
                                        {
                                            if (sp)
                                            {
                                                sp2 = varsp(list->dc.left
                                                    ->offset);
                                                if (!sp2 || list->dc.left->mode
                                                    != i_immed)
                                                {
                                                    setbit(temparray4 + pi1 *
                                                        sourcebytes, list
                                                        ->sourceindx);
                                                    done = TRUE;
                                                }
                                            }
                                        }
                                        else if (list->dc.right->mode ==
                                            i_direct)
                                        {
                                            if (sp && sp->ipointerindx)
                                            {
                                                sp2 = varsp(list->dc.left
                                                    ->offset);
                                                if (!sp2 || list->dc.left->mode
                                                    != i_immed)
                                                {
                                                    memcpy(temparray4 + pi1 *
                                                        sourcebytes, temparray4
                                                        + (sp->ipointerindx - 1)
                                                        *sourcebytes,
                                                        sourcebytes);
                                                    done = TRUE;
                                                }
                                            }
                                        }
                                        if (!done)
                                        {
                                            sp = varsp(list->dc.left->offset);
                                            if (list->dc.left->mode == i_immed)
                                            {
                                                if (sp)
                                                {
                                                    sp2 = varsp(list->dc.right
                                                        ->offset);
                                                    if (!sp2 || list->dc.right
                                                        ->mode != i_immed)
                                                    {
                                                        setbit(temparray4 + pi1
                                                            * sourcebytes, list
                                                            ->sourceindx);
                                                    }
                                                }
                                            }
                                            else if (list->dc.left->mode ==
                                                i_direct)
                                            {
                                                if (sp && sp->ipointerindx)
                                                {
                                                    sp2 = varsp(list->dc.right
                                                        ->offset);
                                                    if (!sp2 || list->dc.right
                                                        ->mode != i_immed)
                                                        memcpy(temparray4 + pi1
                                                            * sourcebytes,
                                                            temparray4 + (sp
                                                            ->ipointerindx - 1)
                                                            *sourcebytes,
                                                            sourcebytes);
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            break;
        case i_parm:
            // This needs work for pointers to pointers
            sp = varsp(list->dc.left->offset);
            if (sp)
            {
                pi = sp->ipointerindx;
                if (pi)
                {
                    pi--;
                    if (list->dc.left->mode == i_immed)
                    {
                        memset(temparray4 + pi * sourcebytes, 0, sourcebytes);
                        setbit(temparray4 + pi * sourcebytes, 0); // everything
                    }
                    else if (list->dc.left->mode == i_direct)
                    {
                        if (isset(temparray4 + pi * sourcebytes, 0))
                        {
                            for (i = 0; i < pointer_count; i++)
                            {
                                memset(temparray4 + i * sourcebytes, 0,
                                    sourcebytes);
                                setbit(temparray4 + i * sourcebytes, 0);
                            }
                        }
                        else
                        for (i = 1; i < source_count; i++)
                        {
                            if (isset(temparray4 + pi * sourcebytes, i))
                            {
                                int pi1;
                                QUAD *q = sourcearray[i];
                                sp = varsp(q->dc.left->offset);
                                if (sp && q->dc.left->mode == i_immed && sp
                                    ->ipointerindx)
                                {
                                    pi1 = sp->ipointerindx - 1;
                                    memset(temparray4 + pi1 * sourcebytes, 0,
                                        sourcebytes);
                                    setbit(temparray4 + pi1 * sourcebytes, 0);
                                }
                                else
                                {
                                    if (q->dc.right)
                                    {
                                        sp = varsp(q->dc.right->offset);
                                        if (sp && q->dc.right->mode == i_immed
                                            && sp->ipointerindx)
                                        {
                                            pi1 = sp->ipointerindx - 1;
                                            memset(temparray4 + pi1 *
                                                sourcebytes, 0, sourcebytes);
                                            setbit(temparray4 + pi1 *
                                                sourcebytes, 0);
                                        }
                                    }
                                }
                            }
                        }

                    }
                }
            }
            break;
        case i_gosub:
            for (i = 0; i < pointer_count; i++)
            switch (pointerarray[i]->offset->nodetype)
            {
            case en_nacon:
            case en_nalabcon:
            case en_napccon:
            case en_labcon:
            case en_absacon:
                memset(temparray4 + i * sourcebytes, 0, sourcebytes);
                setbit(temparray4 + i * sourcebytes, 0);
                break;
            }
            break;

    }
}

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

static int ptr_transform(BLOCK *t)
{
    int changed = FALSE, i, j;
    SYM *sp,  *sp2;
    QUAD *list = t->head;
    memcpy(temparray4, t->p_pin, sourcebytes *pointer_count);
    while (list && list->back != t->tail)
    {
        ptrindex(list, t, temparray4);
        list = list->fwd;
    }
    for (i = 0; i < pointer_count; i++)
    {
        int pos = i * sourcebytes;
        for (j = 0; j < sourcebytes; j++)
        if (temparray4[pos + j] != t->p_pout[pos + j])
        {
            t->p_pout[pos + j] = temparray4[pos + j];
            changed = TRUE;
        }
    }
    return changed;

}

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

static void CalculateUsage(void)
{
    int changed, i, j, k;
    int size = pointer_count * sourcebytes;
    // Global pointers start by pointing to everything
    // technically they shouldn't be able to point to locals.  Oh well...
    for (i = 0; i < pointer_count; i++)
    switch (pointerarray[i]->offset->nodetype)
    {
        case en_nacon:
        case en_nalabcon:
        case en_napccon:
        case en_labcon:
        case en_absacon:
            setbit(blockarray[0]->block->p_pin + i * sourcebytes, 0);
            break;
    }

    do
    {
        changed = FALSE;
        for (i = 0; i < blocknum; i++)
        {
            BLOCK *t = blockarray[dfst[i]]->block;
            BLOCKLIST *l = t->flowback;
            if (t->flowback)
            {
                memset(t->p_pin, 0, size);
                while (l)
                {
                    /* I hand optimized this because BCxx has lousy loop optimization */
                    BYTE *pin = t->p_pin;
                    BYTE *pout = l->block->p_pout;
                    for (j = 0; j < size; j += 4)*((unsigned*)(pin + j))
                         |= *((unsigned*)(pout + j));
                    l = l->link;
                }
            }
            changed |= ptr_transform(t);
        }
    }
    while (changed)
        ;
}

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

void CalculatePointers(void)
{
    FindPointers();
    FindSources();
    CreateBitmaps();
    CalculateUsage();
    #ifdef DUMP_GCSE_INFO
        dumpPointers();
    #endif 
}

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

void RundownPointers(void)
{
    int i;
    for (i = 0; i < pointer_count; i++)
    {
        SYM *sp = varsp(pointerarray[i]->offset);
        if (sp)
            sp->ipointerindx = 0;
    }
}