Как в сборке присваивается отрицательное число неподписанной работе int?

Question

Я узнал о 2's Complement и неподписанных и подписанных int. Поэтому я решил проверить свои знания, насколько я знаю, что отрицательное число хранится в 2's complement так, чтобы сложение и вычитание не имели бы другого алгоритма и схемы были бы простыми.

Теперь, если я пишу

int main() 
{ 
    int a = -1 ; 
    unsigned int b = - 1 ; 

    printf("%d %u \n %d %u" , a ,a , b, b); 
} 

Выходной Comes To Be -1 4294967295 -1 4294967295. Теперь я посмотрел на схему битов и различные вещи, а затем понял, что -1 в дополнении 2: 11111111 11111111 11111111 11111111, поэтому, когда я интерпретирую его с использованием% d, он дает -1, но когда я интерпретирую с использованием %u, он обрабатывает его как положительное число и поэтому он дает 4294967295. Я проверил, скопище код

.LC0: 
    .string "%d %u \n %d %u" 
main: 
    push rbp 
    mov  rbp, rsp 
    sub  rsp, 16 
    mov  DWORD PTR [rbp-4], -1 
    mov  DWORD PTR [rbp-8], -1 
    mov  esi, DWORD PTR [rbp-8] 
    mov  ecx, DWORD PTR [rbp-8] 
    mov  edx, DWORD PTR [rbp-4] 
    mov  eax, DWORD PTR [rbp-4] 
    mov  r8d, esi 
    mov  esi, eax 
    mov  edi, OFFSET FLAT:.LC0 
    mov  eax, 0 
    call printf 
    mov  eax, 0 
    leave 
    ret 

Теперь здесь -1 перемещается в регистр оба раза в беззнаковое и знаковое. То, что я хочу знать, если реинтерпретация только имеет значение, то почему у нас есть два типа: unsigned и signed, это printf формат строки %d и %u, что имеет значение?

Дальше, что действительно происходит, когда я назначаю отрицательное число целому числу без знака (я узнал, что инициализатор преобразует это значение из int в unsigned int.), Но в коде сборки я не видел такой вещи. Так что же происходит на самом деле?

И как машина знает, когда она должна делать 2's complement, а когда нет, она видит отрицательный знак и выполняет 2's complement?

Я прочитал почти каждый вопрос и ответ, вы можете подумать, что этот вопрос дублируется, но я не мог найти удовлетворительного решения.

Answer 1

Оба подписанных и неподписанных являются фрагментами памяти, и в соответствии с операциями важно, как они себя ведут.

Это не имеет никакого значения при добавлении или вычитании из-за того, что из-за 2-дополнения операции точно такие же.

Это имеет значение, когда мы сравниваем два числа: -1 меньше 0, а 4294967295 - нет.

О преобразовании - для того же размера он просто принимает переменное содержимое и перемещает его в другое - так 4294967295 становится -1. Для большего размера он сначала подписан расширенным, а затем содержимое перемещается.

Как работает машина - согласно инструкции, которую мы используем. Машины имеют либо разные инструкции для сравнения подписанных и неподписанных, либо предоставляют разные флаги для него (x86 имеет перенос для неподписанного переполнения и переполнение для переполнения подписей).

Кроме того, обратите внимание, что C расслаблен, как хранятся подписанные числа, они не должны быть 2-дополнениями. Но в настоящее время все распространенные архитектуры хранят подписанные таким образом.

Answer 2

Есть несколько различий между подписанных и неподписанных типов:

1. Поведение операторов <, <=, >, >=, /, % и >> все разные при работе с подписанных и неподписанных номера.

2. Компиляторы не обязаны вести себя предсказуемо, если любое вычисление по значению знака превышает диапазон его типа. Даже при использовании операторов, которые будут вести себя одинаково со значениями со знаком и без знака во всех определенных случаях, некоторые компиляторы будут вести себя «интересным» способом. Например, компилятор, заданный x+1 > y, может заменить его x>=y, если x подписан, но нет, если x не имеет знака.

Как более интересный пример, в системе, где «короткая» составляет 16 бит и «INT» 32 бита, компилятор заданной функции:

unsigned mul(unsigned short x, unsigned short y) { return x*y; } 

можно предположить, что не ситуация может когда возникает, когда продукт будет превышать 2147483647. Например, если он видел, функция вызывается как unsigned x = mul(y,65535); и y был unsigned short, он может опустить код в другом месте, что было бы актуально, если только y были больше, чем 37268.

Answer 3

Выбор знакового целочисленного представления остается на платформе. Представление применяется как к отрицательным, так и к неотрицательным значениям, например, если 11012 (-5) является дополнением двух от 01012 (5), то 01012 (5) равно также дополнение 2 11012 (-5).

Платформа может или не может содержать отдельные инструкции для операций с целыми числами с подписью и без знака. Например, x86 предоставляет различные команды умножения и деления для подписанных (и imul) и целых чисел без знака (div и mul), но использует то же самое дополнение (add) и вычитание (sub) для обоих.

Аналогичным образом, x86 предоставляет команду сравнения (cmp) для целых чисел с подписью и без знака.

Арифметические и сравнительные операции будут устанавливать один или несколько флагов регистров состояния (перенос, переполнение, ноль и т. Д.). Они могут использоваться по-разному, когда речь идет о словах, которые должны представлять подписанные значения vs. unsigned.

Насколько printf обеспокоен, вы абсолютно правильно, что спецификатор преобразования определяет битовый шаблон 0xFFFF ли отображается в -1 или 4294967295, хотя помните, что если тип аргумента не совпадает с тем, что спецификатор преобразования ожидает, то поведение не определено. Использование %u для отображения отрицательного signed int может или не может дать ожидаемое эквивалентное значение без знака.

Answer 4

Кажется, что вы пропустили факты, которые, во-первых, 0101 = 5 как в знаках целого числа, так и без знака, а во-вторых, вы присвоили отрицательное число неподписанному int - то, что ваш компилятор может быть достаточно умным, чтобы реализовать и , поправьте на подписанный int.

Установка неподписанных Int -5 должна технически вызвать ошибку, потому что без знака Интс не может хранить значения под 0.

Answer 5

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

see this blog post for assembly level explanation.