Программирование на УКНЦ как?

Цитата:

---

Сообщение от Patron

Получается, что флаг V итоговой операции можно определять через флаг C, но для этого нужно повторить операцию, предварительно сместив биты операндов.

А как нужно сместить операнды, чтобы "суммарный" бит C новой операции соответствовал суммарному биту V "оригинала" ?

---

Думаю, что это очень накладно. Есть легче способы. Я предложил один из них.

Цитата:

---

Сообщение от Titus

смею предположить, что корректно будет брать флаги V с двух последних каскадов сложенные по xor.

---

Т.е. C по OR, V по XOR, Z по AND и N по результату - выглядит красиво :)

Цитата:

---

Сообщение от Patron

Т.е. C по OR, V по XOR, Z по AND и N по результату - выглядит красиво :)

---

А в конце процедуры CCC и наполненный битами ноп-260 :)

В таком случае программа точной имитации 32-разрядного сложения может выглядеть так:

MOV #<NOP>,SETPSW
CLR Cflag
CLR Vflag
CLR Zflag
ADD L1,L2
BNE 1$
BIS #4,Zflag
1$:
ADC H2
BVC 2$
BIS #2,Vflag
2$:
ADC Cflag
ADD H1,H2
BMI 3$
BNE 4$
BVC 5$
BIS #2,SETPSW
5$:
BR DONE
3$:
BVC 6$
BIS #2,SETPSW
6$:
BIS #10,SETPSW
BR 7$
4$:
BVC 7$
BIS #2,SETPSW
7$:
BIC #4,Zflag
DONE:
ADC SETPSW
BIS Cflag,SETPSW
ADD Vflag,SETPSW
BIC #4,SETPSW
BIS Zflag,SETPSW
CCC
SETPSW:
NOP

Цитата:

---

Сообщение от Patron

В таком случае программа точной имитации 32-разрядного сложения может выглядеть так

---

Лень думать, но как вариант: добавить к приемнику неявную 16битную старшую часть сверх значения и посмотреть что получится :)

Обдумывать сил нет уже - спать хочу :)

Для проверки правильности работы программы имитации 32-разрядного сложения - добавил в эмулятор команду Add32, выполняющую прибавление 32-разрядного числа с адресом в R0 к 32-разрядному числу с адресом в R1:

Код:

---

if( nWord == 040 )
{ // Add_32_32  --  Add32 (R0),(R1)

        word addr00 = R0 &(~1);
        word addr02 = addr00 + 2;
                       
        dword src = WORD(addr02);
        src <<= 16;
        src |= WORD(addr00);
                   
        word addr10 = R1 &(~1);
        word addr12 = addr10 + 2;

        dword dst = WORD(addr12);
        dst <<= 16;
        dst |= WORD(addr10);
                   
        word flags;
                   
        __asm {
                mov  EAX, dst
                add  EAX, src
                pushf
                mov  dst, EAX
                pop  AX
                mov  flags,AX
        }

        WORD(addr10) = (word)dst;
        WORD(addr12) = (word)(dst>>16);
                   
        PSW &= ~(N|Z|V|C);
                   
        if( flags & BIT_0  ) { PSW |= C; }
        if( flags & BIT_11 ) { PSW |= V; }
        if( flags & BIT_6 )  { PSW |= Z; }
        if( flags & BIT_7 )  { PSW |= N; }
           
        continue;
}

---

В приложении - программа тестирования.

Результат запуска:

Код:

---

.RU ADD32
Add32 Test v1.0
 
******************************
 
SRC: 0x0000'0000 (0)
DST: 0x0000'0000 (0)
 
 Add32 : 0x0000'0000 (0)  ; PSW: 004 : N[0] Z[1] V[0] C[0]
$Add32 : 0x0000'0000 (0)  ; PSW: 004 : N[0] Z[1] V[0] C[0]
 
******************************
 
SRC: 0x0000'0001 (1)
DST: 0x0000'0000 (0)
 
 Add32 : 0x0000'0001 (1)  ; PSW: 000 : N[0] Z[0] V[0] C[0]
$Add32 : 0x0000'0001 (1)  ; PSW: 000 : N[0] Z[0] V[0] C[0]
 
******************************
 
SRC: 0x0000'0001 (1)
DST: 0x0000'0001 (1)
 
 Add32 : 0x0000'0002 (2)  ; PSW: 000 : N[0] Z[0] V[0] C[0]
$Add32 : 0x0000'0002 (2)  ; PSW: 000 : N[0] Z[0] V[0] C[0]
 
******************************
 
SRC: 0x0000'0001 (1)
DST: 0xFFFF'FFFF (-1)
 
 Add32 : 0x0000'0000 (0)  ; PSW: 005 : N[0] Z[1] V[0] C[1]
$Add32 : 0x0000'0000 (0)  ; PSW: 005 : N[0] Z[1] V[0] C[1]
 
******************************
 
SRC: 0x0000'0002 (2)
DST: 0xFFFF'FFFF (-1)
 
 Add32 : 0x0000'0001 (1)  ; PSW: 001 : N[0] Z[0] V[0] C[1]
$Add32 : 0x0000'0001 (1)  ; PSW: 001 : N[0] Z[0] V[0] C[1]
 
******************************
 
SRC: 0xFFFF'FFFF (-1)
DST: 0x0000'0001 (1)
 
 Add32 : 0x0000'0000 (0)  ; PSW: 005 : N[0] Z[1] V[0] C[1]
$Add32 : 0x0000'0000 (0)  ; PSW: 005 : N[0] Z[1] V[0] C[1]
 
******************************
 
SRC: 0xFFFF'FFFF (-1)
DST: 0xFFFF'FFFF (-1)
 
 Add32 : 0xFFFF'FFFE (-2)  ; PSW: 011 : N[1] Z[0] V[0] C[1]
$Add32 : 0xFFFF'FFFE (-2)  ; PSW: 011 : N[1] Z[0] V[0] C[1]
 
******************************
 
SRC: 0x7FFF'FFFF (2'147'483'647)
DST: 0x8001'0001 (-2'147'418'111)
 
 Add32 : 0x0001'0000 (65'536)  ; PSW: 001 : N[0] Z[0] V[0] C[1]
$Add32 : 0x0001'0000 (65'536)  ; PSW: 001 : N[0] Z[0] V[0] C[1]
 
******************************
 
SRC: 0x8001'0001 (-2'147'418'111)
DST: 0x7FFF'FFFF (2'147'483'647)
 
 Add32 : 0x0001'0000 (65'536)  ; PSW: 001 : N[0] Z[0] V[0] C[1]
$Add32 : 0x0001'0000 (65'536)  ; PSW: 001 : N[0] Z[0] V[0] C[1]
 
******************************
 
SRC: 0x0000'0001 (1)
DST: 0x7FFF'FFFE (2'147'483'646)
 
 Add32 : 0x7FFF'FFFF (2'147'483'647)  ; PSW: 000 : N[0] Z[0] V[0] C[0]
$Add32 : 0x7FFF'FFFF (2'147'483'647)  ; PSW: 000 : N[0] Z[0] V[0] C[0]
 
******************************
 
SRC: 0x0000'0001 (1)
DST: 0x7FFF'FFFF (2'147'483'647)
 
 Add32 : 0x8000'0000 (-2'147'483'648)  ; PSW: 012 : N[1] Z[0] V[1] C[0]
$Add32 : 0x8000'0000 (-2'147'483'648)  ; PSW: 012 : N[1] Z[0] V[1] C[0]
 
******************************
 
SRC: 0xFFFF'FFFF (-1)
DST: 0x8000'0001 (-2'147'483'647)
 
 Add32 : 0x8000'0000 (-2'147'483'648)  ; PSW: 011 : N[1] Z[0] V[0] C[1]
$Add32 : 0x8000'0000 (-2'147'483'648)  ; PSW: 011 : N[1] Z[0] V[0] C[1]
 
******************************
 
SRC: 0xFFFF'FFFF (-1)
DST: 0x8000'0000 (-2'147'483'648)
 
 Add32 : 0x7FFF'FFFF (2'147'483'647)  ; PSW: 003 : N[0] Z[0] V[1] C[1]
$Add32 : 0x7FFF'FFFF (2'147'483'647)  ; PSW: 003 : N[0] Z[0] V[1] C[1]
 
******************************

---

Вроде, всё правильно.

Есть ещё какие-то граничные случаи, которые нужно протестировать дополнительно ?

Цитата:

---

Сообщение от Patron

Есть ещё какие-то граничные случаи, которые нужно протестировать дополнительно ?

---

Для проверки просто перебирают все комбинации, и все)

Цитата:

---

Сообщение от Titus

Для проверки просто перебирают все комбинации, и все)

---

Я не очень силён в арифметике, но 2**32**32 циклов эмуляции полного выполнения подпрограммы тестирования могут (как мне кажется ) занять больше времени, чем хотелось бы :)

Цитата:

---

Сообщение от Patron

Я не очень силён в арифметике, но 2**32**32 циклов эмуляции полного выполнения подпрограммы тестирования могут (как мне кажется ) занять больше времени, чем хотелось бы :)

---

Да)
Поэтому как вариант, выкидывать перебор бит в диапазоне, допустим, 3..29 бита, таким образом числа редуцируются до 5-6 бит)

Проверил ещё немного входных данных:

Код:

---

        .W3232        0000 8000        7fff 8000
        .W3232        0002 0000        7ffe 0000
        .W3232        0001 0000        7ffe 0000
        .W3232        0001 8000        7ffe 8000
        .W3232        7fff 0000        7fff 0000
        .W3232        8000 0000        7fff 0000
        .W3232        8001 0001        7fff ffff
        .W3232        7fff ffff        8001 0001
        .W3232        8000 0000        8000 0000
        .W3232        ffff 0000        8000 0000
        .W3232        ffff 8000        8000 8000

---

Ошибок нет:

Код:

---

.RU ADD32
Add32 Test v1.1
 
******************************
 
SRC: 0x0000'8000 (32'768)
DST: 0x7FFF'8000 (2'147'450'880)
 
 Add32 : 0x8000'0000 (-2'147'483'648)  ; PSW: 012 : N[1] Z[0] V[1] C[0]
$Add32 : 0x8000'0000 (-2'147'483'648)  ; PSW: 012 : N[1] Z[0] V[1] C[0]
 
******************************
 
SRC: 0x0002'0000 (131'072)
DST: 0x7FFE'0000 (2'147'352'576)
 
 Add32 : 0x8000'0000 (-2'147'483'648)  ; PSW: 012 : N[1] Z[0] V[1] C[0]
$Add32 : 0x8000'0000 (-2'147'483'648)  ; PSW: 012 : N[1] Z[0] V[1] C[0]
 
******************************
 
SRC: 0x0001'0000 (65'536)
DST: 0x7FFE'0000 (2'147'352'576)
 
 Add32 : 0x7FFF'0000 (2'147'418'112)  ; PSW: 000 : N[0] Z[0] V[0] C[0]
$Add32 : 0x7FFF'0000 (2'147'418'112)  ; PSW: 000 : N[0] Z[0] V[0] C[0]
 
******************************
 
SRC: 0x0001'8000 (98'304)
DST: 0x7FFE'8000 (2'147'385'344)
 
 Add32 : 0x8000'0000 (-2'147'483'648)  ; PSW: 012 : N[1] Z[0] V[1] C[0]
$Add32 : 0x8000'0000 (-2'147'483'648)  ; PSW: 012 : N[1] Z[0] V[1] C[0]
 
******************************
 
SRC: 0x7FFF'0000 (2'147'418'112)
DST: 0x7FFF'0000 (2'147'418'112)
 
 Add32 : 0xFFFE'0000 (-131'072)  ; PSW: 012 : N[1] Z[0] V[1] C[0]
$Add32 : 0xFFFE'0000 (-131'072)  ; PSW: 012 : N[1] Z[0] V[1] C[0]
 
******************************
 
SRC: 0x8000'0000 (-2'147'483'648)
DST: 0x7FFF'0000 (2'147'418'112)
 
 Add32 : 0xFFFF'0000 (-65'536)  ; PSW: 010 : N[1] Z[0] V[0] C[0]
$Add32 : 0xFFFF'0000 (-65'536)  ; PSW: 010 : N[1] Z[0] V[0] C[0]
 
******************************
 
SRC: 0x8001'0001 (-2'147'418'111)
DST: 0x7FFF'FFFF (2'147'483'647)
 
 Add32 : 0x0001'0000 (65'536)  ; PSW: 001 : N[0] Z[0] V[0] C[1]
$Add32 : 0x0001'0000 (65'536)  ; PSW: 001 : N[0] Z[0] V[0] C[1]
 
******************************
 
SRC: 0x7FFF'FFFF (2'147'483'647)
DST: 0x8001'0001 (-2'147'418'111)
 
 Add32 : 0x0001'0000 (65'536)  ; PSW: 001 : N[0] Z[0] V[0] C[1]
$Add32 : 0x0001'0000 (65'536)  ; PSW: 001 : N[0] Z[0] V[0] C[1]
 
******************************
 
SRC: 0x8000'0000 (-2'147'483'648)
DST: 0x8000'0000 (-2'147'483'648)
 
 Add32 : 0x0000'0000 (0)  ; PSW: 007 : N[0] Z[1] V[1] C[1]
$Add32 : 0x0000'0000 (0)  ; PSW: 007 : N[0] Z[1] V[1] C[1]
 
******************************
 
SRC: 0xFFFF'0000 (-65'536)
DST: 0x8000'0000 (-2'147'483'648)
 
 Add32 : 0x7FFF'0000 (2'147'418'112)  ; PSW: 003 : N[0] Z[0] V[1] C[1]
$Add32 : 0x7FFF'0000 (2'147'418'112)  ; PSW: 003 : N[0] Z[0] V[1] C[1]
 
******************************
 
SRC: 0xFFFF'8000 (-32'768)
DST: 0x8000'8000 (-2'147'450'880)
 
 Add32 : 0x8000'0000 (-2'147'483'648)  ; PSW: 011 : N[1] Z[0] V[0] C[1]
$Add32 : 0x8000'0000 (-2'147'483'648)  ; PSW: 011 : N[1] Z[0] V[0] C[1]
 
******************************

---