Как я получил значение размером больше 8 бит из 8-битного целого числа?

Я обнаружил чрезвычайно неприятную ошибку, скрывающуюся за этой маленькой жемчужиной. Я знаю, что согласно спецификации C ++ подписанные переполнения являются неопределенным поведением, но только когда переполнение происходит, когда значение расширяется до разрядности sizeof(int). Насколько я понимаю, увеличение a charникогда не должно быть неопределенным, пока sizeof(char) < sizeof(int). Но это не объясняет, как cполучить невозможную ценность. Как 8-битное целое число может cсодержать значения, превышающие его разрядность?

Код

// Compiled with gcc-4.7.2
#include <cstdio>
#include <stdint.h>
#include <climits>

int main()
{
   int8_t c = 0;
   printf("SCHAR_MIN: %i\n", SCHAR_MIN);
   printf("SCHAR_MAX: %i\n", SCHAR_MAX);

   for (int32_t i = 0; i <= 300; i++)
      printf("c: %i\n", c--);

   printf("c: %i\n", c);

   return 0;
}

Вывод

SCHAR_MIN: -128
SCHAR_MAX: 127
c: 0
c: -1
c: -2
c: -3
...
c: -127
c: -128  // <= The next value should still be an 8-bit value.
c: -129  // <= What? That's more than 8 bits!
c: -130  // <= Uh...
c: -131
...
c: -297
c: -298  // <= Getting ridiculous now.
c: -299
c: -300
c: -45   // <= ..........

Зацените на идеоне.

Это ошибка компилятора.

Хотя получение невозможных результатов для неопределенного поведения является допустимым следствием, на самом деле в вашем коде нет неопределенного поведения. Что происходит, так это то, что компилятор считает, что поведение не определено, и соответственно оптимизирует его.

Если cопределено как int8_t, и int8_tповышает до int, то c--предполагается, что c - 1в intарифметике выполняется вычитание и преобразование результата обратно в int8_t. Вычитание intне приводит к переполнению, и преобразование целочисленных значений вне диапазона в другой целочисленный тип допустимо. Если тип назначения подписан, результат определяется реализацией, но он должен быть допустимым значением для типа назначения. (И если тип назначения беззнаковый, результат четко определен, но здесь это не применяется.)

В компиляторе могут быть ошибки, отличные от несоответствия стандарту, потому что есть другие требования. Компилятор должен быть совместим с другими версиями самого себя. Также можно ожидать, что он будет в некоторой степени совместим с другими компиляторами, а также будет соответствовать некоторым представлениям о поведении, которых придерживается большая часть его пользовательской базы.

В этом случае это похоже на ошибку соответствия. Выражение c--должно обрабатываться cаналогично c = c - 1. Здесь значение cсправа повышается до типа int, а затем происходит вычитание. Поскольку cнаходится в диапазоне int8_t, это вычитание не приведет к переполнению, но может дать значение, выходящее за пределы диапазона int8_t. Когда это значение присваивается, происходит обратное преобразование к типу, int8_tчтобы результат снова соответствовал c. В случае выхода за пределы допустимого диапазона преобразование имеет значение, определяемое реализацией. Но значение вне диапазона int8_tне является допустимым значением, определяемым реализацией. Реализация не может «определить», что 8-битный тип внезапно содержит 9 или более бит. Значение, определяемое реализацией, означает, что int8_tсоздается что-то в диапазоне от , и программа продолжается. Таким образом, стандарт C допускает такие варианты поведения, как арифметика насыщения (обычная для DSP) или циклическая обработка (обычные архитектуры).

Компилятор использует более широкий базовый тип машины при манипулировании значениями небольших целочисленных типов, таких как int8_tили char. Когда выполняется арифметика, результаты, выходящие за пределы диапазона малых целых чисел, могут быть надежно зафиксированы в этом более широком типе. Чтобы сохранить внешне видимое поведение, когда переменная является 8-битным типом, более широкий результат должен быть усечен до 8-битного диапазона. Для этого требуется явный код, так как ячейки памяти машины (регистры) шире 8 бит и подходят для больших значений. Здесь компилятор не позаботился о нормализации значения и просто передал его printfкак есть. Спецификатор преобразования %iв printfне знает, что аргумент изначально получен в результате int8_tвычислений; он просто работает сint аргумент.

Я не могу вписать это в комментарий, поэтому отправляю его как ответ.

По какой-то очень странной причине --виновником оказывается оператор.

Я протестировал код, опубликованный на Ideone, и заменил его c--на, c = c - 1а значения остались в диапазоне [-128 ... 127]:

c: -123
c: -124
c: -125
c: -126
c: -127
c: -128 // about to overflow
c: 127  // woop
c: 126
c: 125
c: 124
c: 123
c: 122

Странный эй? Я мало что знаю о том, что компилятор делает с такими выражениями, как i++или i--. Вероятно, он продвигает возвращаемое значение в intи передает его. Это единственный логический вывод, который я могу сделать, потому что вы на самом деле получаете значения, которые не могут поместиться в 8-битные.

Я предполагаю, что базовое оборудование все еще использует 32-битный регистр для хранения этого int8_t. Поскольку спецификация не налагает поведения на переполнение, реализация не проверяет переполнение и позволяет также сохранять большие значения.

Если вы помечаете локальную переменную, поскольку volatileвы заставляете использовать для нее память и, следовательно, получаете ожидаемые значения в пределах диапазона.

Код ассемблера раскрывает проблему:

:loop
mov esi, ebx
xor eax, eax
mov edi, OFFSET FLAT:.LC2   ;"c: %i\n"
sub ebx, 1
call    printf
cmp ebx, -301
jne loop

mov esi, -45
mov edi, OFFSET FLAT:.LC2   ;"c: %i\n"
xor eax, eax
call    printf

EBX следует дополнить пост-декрементом FF, или следует использовать только BL с оставшейся частью EBX. Любопытно, что он использует sub вместо dec. -45 просто загадочна. Это побитовая инверсия 300 & 255 = 44. -45 = ~ 44. Где-то есть связь.

При использовании c = c - 1 требуется гораздо больше работы:

mov eax, ebx
mov edi, OFFSET FLAT:.LC2   ;"c: %i\n"
add ebx, 1
not eax
movsx   ebp, al                 ;uses only the lower 8 bits
xor eax, eax
mov esi, ebp

Затем он использует только нижнюю часть RAX, поэтому он ограничен значениями от -128 до 127. Параметры компилятора «-g -O2».

Без оптимизации он производит правильный код:

movzx   eax, BYTE PTR [rbp-1]
sub eax, 1
mov BYTE PTR [rbp-1], al
movsx   edx, BYTE PTR [rbp-1]
mov eax, OFFSET FLAT:.LC2   ;"c: %i\n"
mov esi, edx

Так это ошибка оптимизатора.

Используйте %hhdвместо %i! Должен решить вашу проблему.

То, что вы видите, является результатом оптимизации компилятора в сочетании с вашим указанием printf напечатать 32-битное число, а затем помещением (предположительно 8-битного) числа в стек, который на самом деле имеет размер указателя, потому что именно так работает код операции push в x86.

Я думаю, это происходит за счет оптимизации кода:

for (int32_t i = 0; i <= 300; i++)
      printf("c: %i\n", c--);

Компилятор использует int32_t iпеременную как для, так iи для c. Отключите оптимизацию или сделайте прямую трансляцию printf("c: %i\n", (int8_t)c--);

cсам определяется как int8_t, но при работе ++или --выше int8_tон сначала неявно преобразуется в, intи вместо этого в результате операции внутреннее значение c печатается с помощью printf, что и есть int.

См фактического значения из cпосле всего цикла, особенно после последнего декремента

-301 + 256 = -45 (since it revolved entire 8 bit range once)

это правильное значение, которое напоминает поведение -128 + 1 = 127

cначинает использовать intпамять размеров, но печатается как int8_tпри печати, как сама, используя только 8 bits. 32 bitsИспользует все, когда используется какint

[Ошибка компилятора]

Я думаю, это произошло, потому что ваш цикл будет идти до тех пор, пока int i не станет 300, а c станет -300. И последнее значение потому, что

printf("c: %i\n", c);