Div1 sh7750

rdc

Господа, кто-нибудь разбирался с данной инструкцией?
В мануале заявляется, что это ones-tep division integer instruction.
Суть работы этой инструкции том, что она выполняет как бы не полное деление целочсленных операндов, а как бы один шаг алгоритма деления, и благодаря этому, процессор, якобы, во время выполнения инструкции деления может отвечать на прерывания и прочие вещи, требующие незамедлительной обработки (http://resource.renesas.com/lib/eng/e_l ... index.html, "Division instructions").
Сам же алгоритм деления заключается в следующем:
1. Делимое сдвигается влево (в сторону старших разрядов) на один бит.
2. Из получившегося числа вычитается делитель (сложение в complementary-two).

Предположим есть два числа, 79 (0100 1111) и 5 (0101).
1. сдвигаем 79 влево на 1 бит. ((0100 1111)<<1 == 1001 1110).
2. вычитаем 3 (1001 1110 + 1 0011 == 1011 0001 == B1(16)== 177(10), имхо, не сильно похоже на остаток)

Цитата:

In 1-step division, the dividend is shifted 1 bit to the left, the divisor is subtracted from this, and
the quotient bit is reflected in the Q bit according to whether the result is positive or negative.

Я вручную попробовал поделить, и у меня не вышло ничего похожего на результат целочисленного деления.
Пробовал также и псевдокод из мануала гонять, так же ничего похоже на результат не получается, даже после нескольких выполнений инструкции (сначала думал что неправильно перевел псевдокод, я заменял все свичи на if'ы, потом все-таки взял компилятор C и запустил пример из мануала как есть - тот же результат).
Логика работы тоже непонятна.

Код для вставки:

Код:

#include <stdio.h>

static signed int R[15];

static unsigned int Q,M,T,PC;
//m - divisor, n - dividented number
//Rn = Rn/Rm;
void DIV1(char m, char n) /* DIV1 Rm,Rn */
{
    unsigned long tmp0, tmp2;
    unsigned char old_q, tmp1;
    old_q=Q;
    //sign into Q
    if(((0x80000000 & R[n])!=0))
        { Q=1; }
    tmp2 = R[m]; //divisor
    R[n]<<=1; //divident<<=1;
    R[n]|=(unsigned long)T; //or with T bit. wtf is that needed. carry?
    switch(old_q)
    {
        case 0:
            switch(M){
            case 0:
                tmp0=R[n]; //divident
                R[n]-=tmp2; //divident -=divisor
                tmp1=(R[n]>tmp0); //if (divident - divisor)> divident, then 1 to tmp1
                switch(Q){
                case 0:
                    Q=tmp1;
                    break;
                case 1:
                    Q=(unsigned char)(tmp1==0);
                    break;
                }
        break;
        case 1:
            tmp0=R[n];
            R[n]+=tmp2;
            tmp1=(R[n]<tmp0);
                switch(Q){
                    case 0:
                        Q=(unsigned char)(tmp1==0);
                    break;
                    case 1:
                        Q=tmp1;
                    break;
                }
            break;
        }
    break;
    case 1:

        switch(M)
        {
            case 0:
                tmp0=R[n];
                R[n]+=tmp2;
                tmp1=(R[n]<tmp0);
                switch(Q){
                case 0:
                    Q=tmp1;
                break;
                case 1:
                    Q=(unsigned char)(tmp1==0);
                break;
                }
            break;
            case 1:
                tmp0=R[n];
                R[n]-=tmp2;
                tmp1=(R[n]>tmp0);
                    switch(Q){
                        case 0:Q=(unsigned char)(tmp1==0);
                    break;
                        case 1:Q=tmp1;
                    break;
                    }
            break;
        }
        break;
    }
if(Q==M) T=1; 
else T=0;
PC+=2;

}

void DIV0U() {
 M=Q=T=0;
}

void SHLL16(int reg) {
 R[reg]<<=16;
}

void EXTUW(char src, char dest) {
    R[dest] = R[src]&0x0000FFFF;
}

main()
{
    const int divident = 35;
    const int divisor = 5;
    R[0] = divisor;
    R[1] = divident;
    printf("Before:\n");
    printf("Divisor, R[0]=%d\n", R[0]);
    printf("Divident, R[1]=%d\n", R[1]);
    SHLL16(0);// R0 ;Set divisor in upper 16 bits, clear lower 16 bits to 0
              //TST R0,R0 ;Check for division by zero
              //BT ZERO_DIV ;
              //CMP/HS R0,R1 ;Check for overflow
              //BT OVER_DIV ;
            printf("R[0] after SHLL 0x%x\n", R[0]);
            DIV0U();    //DIV0U ;Flag initialization
            //.arepeat 16 ;
            int i=0;
            for (i = 0; i < 16; i++)
            {
                    DIV1(0, 1);    //DIV1 R0,R1 ;Repeat 16 times
                    //.aendr ;
                    //ROTCL R1 ;
            }
            EXTUW(1, 1);  //R1 = quotient
    //Result in regsiter #1
    printf("After:\n");
    printf("R[0]=%d\n", R[0]);
    printf("Quotient: R[1]=%d, while must be %d\n", R[1], divident/divisor);

}

Буду благодарен любой помощи или наводке, ибо я не вкуриваю алгоритм этой инструкции вообще.

Div1 sh7750

Кто сейчас на конференции