Я не понимаю инструкции JG/JNLE/JL/JNGE, которые следуют за CMP.
например, если у меня есть:
CMP al,dl
jg label1
Когда al=101; dl =200 al=101; dl =200.
На что мы спрашиваем jg? Это на все al>dl? или al-dl>0?
Тот же пролбем на следующий код:
test al,dl
jg label1
Я не понимаю, что мы сравниваем, и о чем мы спрашиваем " jg ".
Другими словами, я не понимаю, когда мы перейдем к label1, а когда - нет.
Когда вы выполняете cmp a,b, флаги устанавливаются так, как если бы вы рассчитали a - b.
Затем инструкции jmp -type проверяют эти флаги, чтобы увидеть, должен ли выполняться переход.
Другими словами, первый блок кода, который у вас есть (с добавленными комментариями):
cmp al,dl ; set flags based on the comparison
jg label1 ; then jump based on the flags
будет прыгать на label1 тогда и только тогда, когда al больше, чем dl.
Вероятно, вам лучше подумать об этом как al > dl, но два варианта, которые у вас есть, математически эквивалентны:
al > dl
al - dl > dl - dl (subtract dl from both sides)
al - dl > 0 (cancel the terms on the right hand side)
Вам нужно быть осторожным при использовании jg, поскольку он предполагает, что ваши значения были подписаны. Итак, если вы сравните байты 101 (101 в двух дополнениях) с 200 (-56 в двух долях), первый будет фактически больше. Если это не то, что было желательно, вы должны использовать эквивалентное сравнение без знака.
См. здесь для более подробной информации о выборе прыжка, приведенном ниже для полноты. Сначала те, где подпись не подходит:
+--------+------------------------------+-------------+--------------------+
|Instr | Description | signed-ness | Flags |
+--------+------------------------------+-------------+--------------------+
| JO | Jump if overflow | | OF = 1 |
+--------+------------------------------+-------------+--------------------+
| JNO | Jump if not overflow | | OF = 0 |
+--------+------------------------------+-------------+--------------------+
| JS | Jump if sign | | SF = 1 |
+--------+------------------------------+-------------+--------------------+
| JNS | Jump if not sign | | SF = 0 |
+--------+------------------------------+-------------+--------------------+
| JE/ | Jump if equal | | ZF = 1 |
| JZ | Jump if zero | | |
+--------+------------------------------+-------------+--------------------+
| JNE/ | Jump if not equal | | ZF = 0 |
| JNZ | Jump if not zero | | |
+--------+------------------------------+-------------+--------------------+
| JP/ | Jump if parity | | PF = 1 |
| JPE | Jump if parity even | | |
+--------+------------------------------+-------------+--------------------+
| JNP/ | Jump if no parity | | PF = 0 |
| JPO | Jump if parity odd | | |
+--------+------------------------------+-------------+--------------------+
| JCXZ/ | Jump if CX is zero | | CX = 0 |
| JECXZ | Jump if ECX is zero | | ECX = 0 |
+--------+------------------------------+-------------+--------------------+
Тогда беззнаковые:
+--------+------------------------------+-------------+--------------------+
|Instr | Description | signed-ness | Flags |
+--------+------------------------------+-------------+--------------------+
| JB/ | Jump if below | unsigned | CF = 1 |
| JNAE/ | Jump if not above or equal | | |
| JC | Jump if carry | | |
+--------+------------------------------+-------------+--------------------+
| JNB/ | Jump if not below | unsigned | CF = 0 |
| JAE/ | Jump if above or equal | | |
| JNC | Jump if not carry | | |
+--------+------------------------------+-------------+--------------------+
| JBE/ | Jump if below or equal | unsigned | CF = 1 or ZF = 1 |
| JNA | Jump if not above | | |
+--------+------------------------------+-------------+--------------------+
| JA/ | Jump if above | unsigned | CF = 0 and ZF = 0 |
| JNBE | Jump if not below or equal | | |
+--------+------------------------------+-------------+--------------------+
И, наконец, подписанные:
+--------+------------------------------+-------------+--------------------+
|Instr | Description | signed-ness | Flags |
+--------+------------------------------+-------------+--------------------+
| JL/ | Jump if less | signed | SF <> OF |
| JNGE | Jump if not greater or equal | | |
+--------+------------------------------+-------------+--------------------+
| JGE/ | Jump if greater or equal | signed | SF = OF |
| JNL | Jump if not less | | |
+--------+------------------------------+-------------+--------------------+
| JLE/ | Jump if less or equal | signed | ZF = 1 or SF <> OF |
| JNG | Jump if not greater | | |
+--------+------------------------------+-------------+--------------------+
| JG/ | Jump if greater | signed | ZF = 0 and SF = OF |
| JNLE | Jump if not less or equal | | |
+--------+------------------------------+-------------+--------------------+
У Wikibooks есть довольно хорошее резюме инструкции перехода. В принципе, есть фактически два этапа:
cmp_instruction op1, op2
Что устанавливает различные флаги на основе результата, а
jmp_conditional_instruction address
который выполнит скачок на основе результатов этих флагов.
Compare (cmp) будет в основном вычислять вычитание op1-op2, однако это не сохраняется; вместо этого устанавливаются только результаты флага. Так что, если вы сделали cmp eax, ebx, то же самое, что и сказать eax-ebx, а затем решите, будет ли это положительный, отрицательный или нулевой флаги для установки.
Более подробная ссылка здесь.
Сложение и вычитание в двух дополнениях одинаковы для чисел со знаком и без знака
Ключевое наблюдение заключается в том, что CMP в основном вычитание, и:
В двух дополнениях (целочисленное представление, используемое в x86), сложение со знаком и без знака является абсолютно одинаковой операцией.
Это позволяет, например, разработчикам аппаратного обеспечения реализовать его более эффективно с помощью всего одной схемы.
Так, например, когда вы передаете входные байты инструкции xDD ADD, все равно, подписаны они или нет.
Однако ADD устанавливает несколько флагов в зависимости от того, что произошло во время операции:
перенос: результат сложения или вычитания без знака не соответствует размеру бита, например: 0xFF + 0x01 или 0x00 - 0x01
Кроме того, нам нужно перенести 1 на следующий уровень.
знак: результат имеет старший бит установлен. Т.е.: отрицательно, если интерпретируется как подписанное.
переполнение: входные верхние биты равны 0 и 0 или 1 и 1, а инвертированный выход противоположен.
Т.е. подписанная операция изменила подпись невозможным способом (например, положительный + положительный или отрицательный
Затем мы можем интерпретировать эти флаги таким образом, чтобы сравнение соответствовало нашим ожиданиям в отношении чисел со знаком или без знака.
Именно это толкование и делает для нас JA против JG и JB против JL!
Пример кода
Вот GNU GAS, фрагмент кода, чтобы сделать это более конкретным:
/* 0x0 ==
*
* * 0 in 2 complement signed
* * 0 in 2 complement unsigned
*/
mov $0, %al
/* 0xFF ==
*
* * -1 in 2 complement signed
* * 255 in 2 complement unsigned
*/
mov $0xFF, %bl
/* Do the operation "Is al < bl?" */
cmp %bl, %al
Обратите внимание, что AT & T синтаксис "назад": mov src, dst. Таким образом, вы должны мысленно обратить операнды для кодов условий, чтобы иметь смысл с помощью cmp. В синтаксисе Intel это будет cmp al, bl
После этого будут сделаны следующие прыжки:
Обратите внимание, как в этом конкретном примере имеет значение подпись, например, берется JB, но не JL.
Работоспособный пример с утверждениями.
Равные/отрицательные версии, такие как JLE/JNG, являются просто псевдонимами
Изучив раздел 2 " Руководства разработчика программного обеспечения для архитектуры Intel 64 и IA-32", раздел "Jcc - переход, если выполняется условие", мы видим, что кодировки идентичны, например:
Opcode Instruction Description
7E cb JLE rel8 Jump short if less or equal (ZF=1 or SF ≠ OF).
7E cb JNG rel8 Jump short if not greater (ZF=1 or SF ≠ OF).
Команда JG просто означает: Перейти, если больше. Результат предыдущих инструкций хранится в определенных флагах процессора (в этом случае он будет проверять, действуют ли ZF = 0 и SF = OF), и команда перехода в соответствии с их состоянием.