Затык с понятием «overflow»

Эээээээ товарищи прогеры. Что-то здесь не то.
Переполнение флаг OF имеет отношение только к старшему разряду и только 8,16,32 битных чисел в процессоре, то есть от разрядности числа это ЗАВИСИТ.
например складываем в процессоре такого типа числа до двух разрядов менее 8,16,32 бит, что бы при сложении старший разряд числа не занимал старший разряд регистра.

01b
+01b
=10b OF=0
...
010000
+010000
=100000 OF=1
и т.д.

а если складывать именно 8,16,32 битные то

00100000b
+00100000b
=01000000b OF=1
0010000000000000b
+0010000000000000b
=0100000000000000b OF=1
00100000000000000000000000000000b
+00100000000000000000000000000000b
=01000000000000000000000000000000b OF=1

Или Вы меня не так поняли. Или опять я туплю?

 

aptyp

Откуда вы это взяли? OF будет 0!

 

l_inc
Да не заметил в сонном состоянии

Mikl___
Нет, не изменяет. Например, Ваш пример для байтового сложения: 5 + 126 = 05h + 7Eh = 83h. В результате выполнения операции имеется перенос в старший разряд (из 6-го в 7-й), но отсутствует перенос из старшего разряда (из 7-го). Флаг CF равен нулю (он и содержит перенос из старшего разряда), флаг OF = перенос в старший XOR перенос из старшего = 1.

 

aptyp

Флаги CF и OF зависят от разрядности данных в том смысле, что они исходят из переносов в старший и из старшего разряда результата. Поэтому для байтовых операций они смотрят переносы в 7-й и из 7-го разряда, для словных -- в 15-й и из 15-го и т.д. Но логика формирования значений этих флажков остаётся одной и той же.

 

Mikl___
Переполнение в реальных электронных схемах вычисляется именно как XOR между переносом в старший (знаковый) разряд результата и из него. Это проще всего, поскольку оба переноса в любом случае вычисляются.

 

Booster

Ой. да точно, скопипастил, не отредактировал. Вот пример того что OF зависит от разряда

01b
+01b
=10b OF=0

00100000
+00100000
=01000000 OF=0

0010000000000000
+0010000000000000
=0100000000000000 OF=0

и т.д.

а если складывать именно 8,16,32 битные то

01000000b
+01000000b
=10000000b OF=1

0100000000000000b
+0100000000000000b
=1000000000000000b OF=1

01000000000000000000000000000000b
+01000000000000000000000000000000b
=10000000000000000000000000000000b OF=1

 

aptyp
Всё верно. Почему смущает, что зависит от разрядности?

 

Итог получается такой, если старший разряд регистра при сложении двух однотипных чисел меняет знак, происходит переполнение, не важно был ли перенос из разрядной сетки, всё равно процессор это делает зачем-то, на всякий случай? Учитывая что я задавал вопрос о том зачем это происходит и какой смысл, вопрос исчерпан?

 

aptyp

Переполнение происходит не если старший разряд меняет знак, а если в нём получается неверный знак Например, если складываются положительное и отрицательное число, то какой знак должен получиться? Понятное дело, это зависит от самих чисел.

 

Mikl___, уже обратил внимание на это статью.

А вот ещё это интересно, то есть, в данном случае можно считать что перенос из разрядной сетки БЫЛ, и это был ноль из старшего разряда который заняла единица?

 

Проглядываем #20, смотрим столбец -/+dec, символ "_" и вправду соответствует переполнениям столбца bin, говорим автору #20 спасибо &
Кому трудно с xor, просто суммируйте n бит, забирая последний от результата.

Код (Text):

1.                                   +dec              -/+dec
2. bin_ocs__ocs__ocs__ocs_           --------------    --------------
3.       00   00   00   00           +0  +0  +0  +0    +0  +0  +0  +0
4. +     00   01   10   11           +0  +1  +2  +3    +0  +1  -2  -1
5. =   -000 -001 -010 -011           +0  +1  +2  +3    +0  +1  -2  -1
6.  
7.       01   01   01   01           +1  +1  +1  +1    +1  +1  +1  +1
8. +     00   01   10   11           +0  +1  +2  +3    +0  +1  -2  -1
9. =   -001 +010 -011 -100           +1  +2  +3 _+0    +1 _-2  -1  +0
10.  
11.       10   10   10   10           +2  +2  +2  +2    -2  -2  -2  -2
12. +     00   01   10   11           +0  +1  +2  +3    +0  +1  -2  -1
13. =   -010 -011 +100 +101           +2  +3 _+0 _+1    -2  -1 _+0 _+1
14.  
15.       11   11   11   11           +3  +3  +3  +3    -1  -1  -1  -1
16. +     00   01   10   11           +0  +1  +2  +3    +0  +1  -2  -1
17. =   -011 -100 +101 -110           +3 _+0 _+1 _+2    -1  +0 _+1  -2

 

aptyp

OF это знаковое переполнение. Переносом из разрядной сетки, как ты выразился, занимается СF. Что-то ещё не ясно?

 

Не не не, туплю, не было переноса, так можно тупить долго.

 

..те. нулевой

 

Вы пример то смотрите

0100000000000000b
+0100000000000000b
=1000000000000000b OF=1

В данном случае переполнение есть, а числа складываются без знаковые 32 битные. Без знакового переноса CF естественно нет. Почему же на это реагирует OF флаг?