Ассемблер je: Инструкция JE

— Любое число, представленное в двоичной системе, можно воспринимать как битовую информацию,
и очень часто в этом есть математический смысл. Например, нулевой бит определяет нечётность числа.
Также старший бит числа может трактоваться как знаковый бит. Если он включен, число можно воспринимать как отрицательное.
Обо всём этом мы поговорим в витке1 и следующих Чтивах.

Bitfry

Как ввести и вывести число в assembler(AT&T, GAS синтаксис)? — Хабр Q&A

Приветствую всех.
Учусь разработке на Assembler
При обучении возникла задача — написание калькулятора.
Пишу под Linux(Ubuntu), следовательно приходится осваивать синтаксис GAS(AT&T)
Возникла проблема с выводом, а именно при компиляции этого кода:

.data
number:
  .long 0x00000595
str:
  .space 4, 0
i:
  .byte 0

str_len =.-str

.text
  .global _start
_start:

  0:
    addb $str, i
    movb $0x30, (%eax)
    incb %al
    movb %al, (i)
    jmp logic

  1:
    addb $str, i
    movb $0x31, (%eax)
    incb %al
    movb %al, (i)
    jmp logic

  2:
    addb $str, i
    movb $0x32, (%eax)
    incb %al
    movb %al, (i)
    jmp logic

  3:
    addb $str, i
    movb $0x33, (%eax)
    incb %al
    movb %al, (i)
    jmp logic

  4:
    addb $str, i
    movb $0x34, (%eax)
    incb %al
    movb %al, (i)
    jmp logic

  5:
    addb $str, i
    movb $0x35, (%eax)
    incb %al
    movb %al, (i)
    jmp logic

  6:
    addb $str, i
    movb $0x36, (%eax)
    incb %al
    movb %al, (i)
    jmp logic

  7:
    addb $str, i
    movb $0x37, (%eax)
    incb %al
    movb %al, (i)
    jmp logic

  8:
    addb $str, i
    movb $0x38, (%eax)
    incb %al
    movb %al, (i)
    jmp logic

  9:
    addb $str, i
    movb $0x39, (%eax)
    incb %al
    movb %al, (i)
    jmp logic


  logic:
    movl $number, %eax
    cdq
    movl $10, %ebx
    idivl %ebx

    cmpl $0, %edx
    je 0
    cmpl $1, %edx
    je 1
    cmpl $2, %edx
    je 2
    cmpl $3, %edx
    je 3
    cmpl $4, %edx
    je 4
    cmpl $5, %edx
    je 5
    cmpl $6, %edx
    je 6
    cmpl $7, %edx
    je 7
    cmpl $8, %edx
    je 8
    cmpl $9, %edx
    je 9

    movl $4, %eax
    movl $1, %ebx
    movl $str, %ecx
    movl $str_len, %edx
    int $0x80

    movl $1, %eax
    xor %ebx, %ebx
    int $0x80

При компиляции появляется такая ошибка:

$ as --64 test_print.s -o test_print.o
$ ld -melf_x86_64 -s test_print.o -o test_print
test_print.o: In function `_start':
(.text+0x7): relocation truncated to fit: R_X86_64_8 against `.data'
(.text+0x21): relocation truncated to fit: R_X86_64_8 against `.data'
(.text+0x3b): relocation truncated to fit: R_X86_64_8 against `.data'
(.text+0x55): relocation truncated to fit: R_X86_64_8 against `.data'
(.text+0x6f): relocation truncated to fit: R_X86_64_8 against `.data'
(.text+0x86): relocation truncated to fit: R_X86_64_8 against `.data'
(.text+0x9d): relocation truncated to fit: R_X86_64_8 against `.data'
(.text+0xb4): relocation truncated to fit: R_X86_64_8 against `.data'
(.text+0xcb): relocation truncated to fit: R_X86_64_8 against `.data'
(.text+0xe2): relocation truncated to fit: R_X86_64_8 against `.data'

Помогите разобраться, сломал себе весь мозг.
P.S. Буду очень благодарен, если подскажите на основе скрипта вывода способ получения числа из символьного массива при вводе

Размер окна приложения на ассемблере

format          PE GUI 4.0                                                      ; Формат PE

entry           start                                                           ; Точка входа

include         ‘%include%\win32a.inc’                                          ; Включение описателей

_style          equ             WS_VISIBLE+WS_DLGFRAME+WS_SYSMENU+WS_THICKFRAME ; Стиль окна.

;=== сегмент кода ============================================================

section         ‘.text’ code readable executable

  start:

                invoke          GetModuleHandle,0                               ; Получим дескриптор приложения.

                mov             [wc.hInstance],eax                              ; Сохраним дескриптор в структуру wc

                mov             [wc.style], CS_HREDRAW or CS_VREDRAW            ; Стили перерисовки окна полностью

                invoke          LoadIcon,0,IDI_ASTERISK                         ; Загружаем иконку IDI_ASTERISK из ресурсов исполняемого файла

                mov             [wc.hIcon],eax                                  ; Сохраним в структуре окна

                invoke          LoadCursor,0,IDC_ARROW                          ; Загружаем курсор IDC_ARROW из ресурсов исполняемого файла

                mov             [wc.hCursor],eax                                ; Сохраним дескриптор курсора в структуре окна

                mov             [wc.lpfnWndProc],WindowProc                     ; Адрес нашей процедуры обработки окна

                mov             [wc.lpszClassName],_class                       ; Имя класса окна

                mov             [wc.hbrBackground],COLOR_WINDOW+1               ; Цвет кисти

                invoke          RegisterClass,wc                                ; Регистрируем наш класс окна

                test            eax,eax                                         ; Проверим выходной eax

                jz              error                                           ; Если 0 — то ошибка. Выводим и выходим.

                invoke          CreateWindowEx,0,_class,_title,_style,128,128,512,512,NULL,NULL,[wc.hInstance],NULL  ; Создаем экземпляр окна на основе зарегистрированного класса

                test            eax,eax                                         ; Проверим выходной eax.

                jz              error                                           ; Если 0 — то ошибка. Выводим и выходим.

                mov             [wHMain],eax                                    ; сохраним дескриптор окна

;— цикл обработки сообщений ————————————————

  msg_loop:

                invoke          GetMessage,msg,NULL,0,0                         ; Получаем сообщение из очереди сообщений приложения, помещает его в структуру msg

                or              eax,eax                                         ; Проверяем eax

                jz              end_loop                                        ; 0 = пришло сообщение WM_QUIT (выходим из цикла ожидания сообщений), не 0 = продолжаем обрабатывать очередь

  msg_loop_2:

                invoke          TranslateMessage,msg                            ; Дополнительная функция обработки сообщения. Конвертирует некоторые сообщения и отправляет их обратно в очередь.

                invoke          DispatchMessage,msg                             ; Пересылает сообщения соответствующим процедурам обработки сообщений (WindowProc …).

                jmp             short msg_loop                                  ; Цикл

  error:

                invoke          MessageBox,NULL,_error,NULL,MB_ICONERROR+MB_OK  ; Вывод сообщения об ошибке

  end_loop:

                invoke          ExitProcess,[msg.wParam]                        ; Выход из программы. Код выхода сохраняется в msg.wParam. Его надо передать системе

;— процедура обработки окна (функция окна, оконная процедура) —————

proc            WindowProc      hWnd,wMsg,wParam,lParam

                push            ebx esi edi                                     ; сохраним все регистры

                cmp             [wMsg],WM_CREATE                                ; Проверим на WM_CREATE

                je              .wmcreate                                       ; на обработчик wmcreate

                cmp             [wMsg],WM_DESTROY                               ; Проверим на WM_DESTROY

                je              .wmdestroy                                      ; на обработчик wmdestroy

                cmp             [wMsg],WM_PAINT                                 ; Проверим на WM_PAINT

                je              .wmpaint                                        ; на обработчик wmpaint

  .defwndproc:

                invoke          DefWindowProc,[hWnd],[wMsg],[wParam],[lParam]   ; Дефолтная функция. Обрабатывает сообщения, которые наша программа не использует.

                jmp             .finish

  .wmcreate:

                xor             eax,eax

                jmp             .finish

  .wmpaint:

                invoke          BeginPaint,[hWnd],pnt

                mov             [pHMain],eax ; Сохранить контекст (дескриптор) устройства

                invoke          GetClientRect,[hWnd],rect_client                ; Запрашиваем координаты клиентской области окна

                mov             ebx,[rect_client.bottom]

                sub             ebx,[rect_client.top]                           ; EBX = высота клиентской области

                mov             ecx,[rect_client.right]

                sub             ecx,[rect_client.left]                          ; ECX = ширина клиентской области

                invoke          wsprintf,szValue1,szFmt,ecx,ebx                 ; Записываем в буфер десятичные эквиваленты ширины и высоты

                invoke          lstrlen,_message1                               ; Вычислим длину выводимой строки

                invoke          TextOut,[pHMain],2,10,_message1,eax             ; Выведем текст в клиентскую область окна

                invoke          GetWindowRect,[hWnd],rect_nonclient             ; Запрашиваем координаты неклиентской области окна

                mov             ebx,[rect_nonclient.bottom]

                sub             ebx,[rect_nonclient.top]                        ; EBX = высота неклиентской области

                mov             ecx,[rect_nonclient.right]

                sub             ecx,[rect_nonclient.left]                       ; ECX = ширина неклиентской области

                invoke          wsprintf,szValue2,szFmt,ecx,ebx                 ; Записываем в буфер десятичные эквиваленты ширины и высоты

                invoke          lstrlen,_message2                               ; Вычислим длину выводимой строки

                invoke          TextOut,[pHMain],2,30,_message2,eax             ; Выведем текст в клиентскую область окна

                invoke          EndPaint,[hWnd],pnt                             ; Освободить контекст устройства

                xor             eax,eax

                jmp             .finish

  .wmdestroy:                                                                   ; Обработчик сообщения WM_DESTROY.

                invoke          PostQuitMessage,0                               ; Посылает сообщение WM_QUIT в очередь сообщений, что вынуждает GetMessage вернуть 0. Посылается для выхода из программы. Посылается только основным окном.

                xor             eax,eax                                         ; Если наша процедура окна обрабатывает какое-либо сообщение, то она должна вернуть 0 в eax.

  .finish:

                pop             edi esi ebx                                     ; восстановим все регистры

                ret

endp

;=== сегмент данных ==========================================================

section         ‘.data’ data readable writeable

_class          db              ‘FASMWIN32’,0                                   ; Название собственного класса. Мы будем регистрировать свой.

_title          db              ‘Win32 get window size’,0                       ; Текст в заголовке окна.

_error          db              ‘Startup failed.’,0                             ; Текст ошибки

szFmt           db              ‘%04u,%04u’,0                                   ; шаблон формата для wsprintf

_message1       db              ‘ClientSizeXY: ‘

szValue1        db              ‘XXXXXXXXX’,0

_message2       db              ‘NonClientSizeXY: ‘

szValue2        db              ‘XXXXXXXXX’,0

wHMain          dd              ?                                               ; дескриптор окна

pHMain          dd              ?                                               ; дескриптор контекста устройства

wc              WNDCLASS                                                        ; Структура окна. Для функции RegisterClass

msg             MSG                                                             ; Структура системного сообщения. Структура содержится в INCLUDE\EQUATES\USER32.INC

pnt             PAINTSTRUCT                                                     ; Структура отрисовки клиентской области окна.

rect_client     RECT                                                            ; Структура RECT клиентской части окна

rect_nonclient  RECT                                                            ; Структура RECT неклиентской части окна

;=== таблица импорта =========================================================

section         ‘.idata’ import data readable writeable

library         kernel32,’KERNEL32.DLL’,user32,’USER32.DLL’,gdi32,’GDI32.DLL’

include         ‘api\kernel32.inc’

include         ‘api\user32.inc’

include         ‘api\gdi32.inc’

Перейти, если условие выполнено

JE — Перейти, если условие выполнено

Описание
Проверяет состояние одного или нескольких флагов состояния в регистре EFLAGS (CF, OF, PF, SF и ZF) и, если флаги находятся в указанном состоянии (условии), выполняет переход к целевой инструкции, указанной в операнд назначения.Код условия (cc) связан с каждой инструкцией, чтобы указать условие, которое проверяется. Если условие не выполняется, переход не выполняется, и выполнение продолжается с инструкции, следующей за инструкцией Jcc.

Целевая инструкция указывается с относительным смещением (смещение со знаком относительно текущего значения указателя инструкции в регистре EIP). Относительное смещение (rel8, rel16 или rel32) обычно указывается как метка в ассемблерном коде, но на уровне машинного кода оно кодируется как подписанное, 8-битное или 32-битное непосредственное значение, которое добавляется к указатель инструкции.Кодирование инструкций наиболее эффективно для смещений от 128 до +127. Если атрибут размера операнда равен 16, два старших байта регистра EIP очищаются до 0, в результате чего максимальный размер указателя инструкции составляет 16 бит.

Условия для каждой мнемоники Jcc приведены в столбце «Описание» таблицы на предыдущей странице. Термины «меньше» и «больше» используются для сравнения целых чисел со знаком, а термины «выше» и «ниже» используются для целых чисел без знака.

Поскольку конкретное состояние флагов состояния иногда можно интерпретировать двояко, для некоторых кодов операций определены две мнемоники.Например, инструкция JA (переход, если выше) и инструкция JNBE (переход, если не ниже или равно) являются альтернативными мнемониками для кода операции 77H.

Инструкция Jcc не поддерживает далекие переходы (переходы к другим сегментам кода). Когда цель для условного перехода находится в другом сегменте, используйте условие, противоположное проверяемому условию для инструкции Jcc, а затем получите доступ к цели с безусловным дальним переходом (инструкция JMP) к другому сегменту. Например, следующий условный дальний прыжок недопустим:
JZ FARLABEL;

Чтобы совершить этот дальний прыжок, используйте следующие две инструкции:

JNZ BEYOND;
JMP FARLABEL;
ВНЕ:


Инструкции JECXZ и JCXZ отличаются от других инструкций Jcc, поскольку они не проверяют флаги состояния.Вместо этого они проверяют содержимое регистров ECX и CX, соответственно, на 0. В соответствии с атрибутом размера адреса выбирается регистр CX или ECX. Эти инструкции полезны в начале условного цикла, который завершается инструкцией условного цикла (например, LOOPNE). Они предотвращают вход в цикл, когда регистр ECX или CX равен 0, что приведет к тому, что цикл будет выполняться 2 32 или 64 К раз, соответственно, вместо нуля раз.

Все условные переходы преобразуются в выборки кода одной или двух строк кэша, независимо от адреса перехода или кэшируемости.

циклы применяются к прыжку и без прыжка

Флаги

Лекция по языку ассемблера и компьютерной архитектуре (CS 301)

Лекция по языку ассемблера и компьютерной архитектуре (CS
301)

CS 301:
Лекция по программированию на языке ассемблера, д-р.Лоулор

Прыжок
инструкция, такая как «jmp», просто переключает ЦП на выполнение
другой фрагмент кода. Это ассемблерный эквивалент
«goto», но, в отличие от goto, прыжки не считаются постыдными в
сборка. (Дейкстра написал в 1968 году статью под названием «Goto
Считается вредным «. С тех пор goto обычно
считались вредными, за исключением
Linux.)

Вы говорите, куда перейти, используя «ярлык перехода», который может быть любым
имя строки с двоеточием после него.(Такой же точный синтаксис
используется в C / C ++)

В обоих случаях мы возвращаем 3, потому что мы перепрыгиваем через 999
назначение. Прыжки несколько полезны для перепрыгивания через плохие
код, но он действительно становится полезным, когда вы добавляете условный
прыгает. Они используются после инструкции «cmp» для сравнения
два значения.

Есть также
«n» версий НЕ для каждого прыжка; например «jno» прыгает, если есть
НЕ переполнение.

Условный
Прыжки: разветвление в сборке

В сборе,
все ветвления выполняются с использованием двух типов инструкций:

• Команда сравнения, такая как «cmp», сравнивает два значения.
  Внутри он делает это путем их вычитания.
• Инструкция условного перехода, например «je» (переход, если равен),
  делает переход где-нибудь, если два значения удовлетворяют
  правильное состояние. Например, если значения равны,
  их вычитание дает ноль, поэтому «je» то же самое, что «jz».

Вот как
используйте сравнение и прыжок, если равно («je»):

 mov eax, 3 
 cmp eax, 3; как eax по сравнению с 3? 
 je lemme_outta_here; если равно, то перейти на 
 mov eax, 999; <- не выполняется * если * перепрыгиваем через него 
 lemme_outta_here: 
 ret 

(Попробуйте
это сейчас в NetRun!)

Вот сравнить
и jump-if-less-than («jl»):

 mov eax, 1 
 cmp eax, 3; как eax по сравнению с 3? 
 jl lemme_outta_here; если меньше, то перейти на 
 mov eax, 999; <- не выполняется * если * перепрыгиваем через него 
 lemme_outta_here: 
 ret 

(Попробуйте
это сейчас в NetRun!)

C ++
эквивалентно сравнить-и-прыгать-если-что бы то ни было «если (что-то) перейти
где-то;».

Петли

Чтобы зациклиться, вы
просто вернитесь к началу кода. Где-то ты делаешь
нужно условное выражение, или вы создали бесконечный цикл!

В этом
Например, мы отсчитываем edi, пока он не достигнет нуля.

; edi - наш первый аргумент функции 
 mov eax, 0; сумма добавлена ​​здесь

Начните: ; цикл начинается здесь
  добавить eax, 10; добавлять каждый раз по петле

  sub edi, 1; приращение цикла
  cmp edi, 0; петлевой тест
  jg start; продолжить цикл, если edi> 0

ret 

(Попробуйте
это сейчас в NetRun!)

Это
построчно эквивалентно этому коду C ++:

 int foo (int bar) {
int sum = 0;

Начните:
сумма + = 10;
бар--;
если (bar> 0) перейти к началу;

сумма возврата;
} 

 (Попробуйте сейчас в NetRun!) 

Оф
конечно, это очень уродливый код на C ++! Это более идиоматично
напишите здесь цикл «for»:

 int foo (int bar) {
int sum = 0;
for (int count = bar; count> 0; count--)
сумма + = 10;
сумма возврата;
} 

(Попробуйте
это сейчас в NetRun!)

Подробнее
Сложный поток управления: C-

Можно
на самом деле написать очень своеобразный вариант C ++, где «если»
операторы содержат только операторы goto.Мое шутливое название для
этот C ++ в стиле сборки — «C—»: вы используете только «+ =» и «* =»
арифметика и «если (простой тест) перейти куда-нибудь»; управление потоком.

Например, это совершенно допустимый C ++ в стиле «C—«:

 int main () {
 int я = 0; 
 if (i> = 10) goto byebye; 
 std :: cout << "Не слишком большой! \ N"; 
 до свидания: возврат 0; 
} 

Этот способ
написание C ++ очень похоже на сборку — фактически, есть
взаимно однозначное соответствие между строками кода C, написанными таким образом
и инструкции на машинном языке.Более сложный C ++,
подобно конструкции «for», расширяется до многих линий сборки.

 int i, n = 10; 
 for (i = 0; i  std :: cout << "В цикле: i ==" << i << "\ n"; 
} 

Вот один
расширенная версия этого C / C ++ цикла «for»:

 int i = 0, n = 10; 
 start: std :: cout << "В цикле: i ==" << i << "\ n"; 
 i ++; 
, если (i 
 (исполняемый
 Ссылка NetRun)
 Вы должны убедить себя, что это действительно эквивалентно
 цикл «for» во всех случаях.Осторожно - если n - параметр,
 это не! (Что, если n> = i?)
 Все конструкции управления потоком C могут быть написаны с использованием только «if» и
 "goto", которые обычно сопоставляют "один к одному" для сравнения и перехода.
 последовательность в сборке.
 Нормальный C
 Расширенный C
 если (A) {
 ... 
}
 if (! A) goto END; 
 {
 ... 
} 
 КОНЕЦ:
 если (! A) {
... 
}
 if (A) goto END; 
 {
 ... 
} 
 КОНЕЦ:
 если (A && B) {
 ... 
}
 if (! A) goto END; 
 if (! B) goto END; 
 {
 ... 
} 
 КОНЕЦ:
 если (A || B) {
 ... 
}
 if (A) goto STUFF; 
 if (B) goto STUFF; 
 goto END; 
 ВЕЩЕСТВО: 
 {
 ... 
} 
 КОНЕЦ:
, а (A) {
... 
}
 goto TEST; 
 НАЧАЛО: 
 {
 ... 
} 
 ТЕСТ: если (A) перейти к НАЧАЛУ;
 делать {
 ... 
}, а (A)
 START: 
 {
 ... 
} 
 if (A) перейти к START;
 для (i = 0; i  {
 ... 
}
 я = 0;
 / * Версия A * / 
 goto TEST; 
 НАЧАЛО: 
 {
 ... 
} 
 i ++; 
 ТЕСТ: if (i 
 для (i = 0; i  {
... 
}
 я = 0;
 / * Версия B * / 
 START: if (i> = n) goto END; 
 {
 ... 
} 
 i ++; 
 goto START; 
 КОНЕЦ:
 Обратите внимание, что два последних перевода понятия «для» (помечены
 Версия A и версия B) вычисляют одно и то же. Который
 один быстрее? Если цикл повторяется много раз, я требую версию
 (A) обычно быстрее, так как есть только один (условный) goto
 каждый раз по циклу вместо двух goto в версии
 (Б) - одно условное и одно безусловное.Но версия (B)
 вероятно, быстрее, если n часто равно 0, потому что в этом случае
 быстро переходит в END (за один условный переход).
 ВНИМАНИЕ:
 Философское содержание 
 Ядерная
 оружие настолько мощное, что обычно считается плохой идеей
 используйте их для решения большинства задач.
 Аналогично,
 Операторы goto настолько мощны, что обычно считаются плохими
 идея использовать их для большинства задач. Проблема в том, когда ты
 увидеть goto, вы не можете сказать, используется ли он для имитации for,
 while, вызов функции или какой-то более странный их гибрид.Таким образом
 goto может быть достаточно легко написать, но его труднее читать,
 и поскольку код в больших проектах пишется только один раз, но получает
 прочитал много раз много разных людей за эти годы, это больше
 важно сделать ваш код легко читаемым.
 Я больше всего замечаю
 программисты-самоучки (включая меня), как правило, предпочитают goto или
 его немного более классный кузен, цикл while, потому что они более
 Общее. Но после того, как вы испортили цикл "while" достаточно раз,
 например, отказавшись от приращения цикла и непреднамеренно сделав
 бесконечный цикл, вы в конечном итоге по умолчанию используете циклы "for",
 потому что синтаксис, предписанный компилятором ("for (int i = 0; i 
 Петли и ответвления в сборке 
 CS 301 Лекция
CS 301 Лекция, доктор Лоулор
 Инструкция перехода, такая как "jmp", просто переключает CPU на выполнение
 другой фрагмент кода. Это ассемблерный эквивалент goto,
 но, в отличие от goto, при сборке прыжки не считаются зазорными. (Дейкстра написал в 1968 году статью под названием «Goto, которая считается вредной». С тех пор goto в целом считалась вредной, за исключением Linux.)
 Вы указываете, куда перейти, используя «метку перехода», которая представляет собой любую строку
 с двоеточием после него.(Такой же точный синтаксис используется в C / C ++)
 В обоих случаях мы возвращаем 3, потому что мы перепрыгиваем через 999
 назначение. Прыжки несколько полезны для перепрыгивания через плохие
 код, но он действительно становится полезным, когда вы добавляете условные переходы.
 Они используются после инструкции «cmp» для сравнения двух значений.
 Инструкция
 Полезно для ...
 jmp
 Всегда прыгать
 и
 Без знака>
 иэ
 Без знака> =
 сп
 Без знака <
 jbe
 Без знака <=
 jc
 Беззнаковое переполнение, 
 или сложение multiprecision
 jecxz
 Сравните ecx с 0 
 (Серьезно !?)
 je
 Равенство
 jg
 Подписано>
 jge
 Подпись> =
 jl
 Подписано <
 ил
 Подпись <=
 иен
 Неравенство
 jo
 Переполнение со знаком
Также существует "n" версий НЕ для каждого прыжка; например "jno" перескакивает, если НЕ происходит переполнения.
 Условные переходы: разветвление в сборке 
В сборке все ветвления выполняются с использованием двух типов инструкций:
 Команда сравнения, такая как «cmp», сравнивает два значения.
 Команда условного перехода, такая как «je» (переход, если равно), выполняет переход где-нибудь, если два значения удовлетворяют правильному условию.
Вот как использовать сравнение и переход при равном ("je"):
 mov eax, 3 
 cmp eax, 3; как eax по сравнению с 3? 
 je lemme_outta_here; если равно, то перейти на 
 mov eax, 999; <- не выполняется * если * перепрыгиваем через него 
 lemme_outta_here: 
 ret 
 
 (Попробуйте сейчас в NetRun!)
Вот сравнение и прыжок, если меньше ("jl"):
 mov eax, 1 
 cmp eax, 3; как eax по сравнению с 3? 
 jl lemme_outta_here; если меньше, то перейти на 
 mov eax, 999; <- не выполняется * если * перепрыгиваем через него 
 lemme_outta_here: 
 ret 
 
 (Попробуйте сейчас в NetRun!)
Эквивалент C ++ для compare-and-jump-if-something - «if (something) gotowhere;».
 Также проверьте машинный код, сгенерированный для условного
 jump - назначение перехода кодируется как количество байтов машины
 код, который нужно пропустить. Например, "jl" выше кодируется в
 машинный код вроде этого:
 0: b8 01 00 00 00 mov eax, 0x1 
 5:83 f8 03 cmp eax, 0x3 
 8: 7c 05 jl f  
 a: b8 e7 03 00 00 mov eax, 0x3e7 
 f: c3 ret 
 
Расстояние для прыжка, показанное красным выше, составляет пять байтов, потому что
 код, который мы пропускаем, имеет длину пять байтов.Обратите внимание, что прыжок
 метка вообще не отображается в машинном коде - она ​​просто используется
 ассемблер, чтобы выяснить, как далеко прыгнуть.
 Более сложный поток управления: C-- 
На самом деле вы можете написать очень своеобразный вариант C ++, где
 Операторы if содержат только операторы goto. Мое шутливое название для
 этот C ++ в стиле сборки, в котором используются только арифметические операции "+ =" и "* =",
 и "если (простой тест) перейти куда-нибудь;" управление потоком - "C--"!
 Например, это совершенно допустимый C ++ в стиле "C--":
 int main () {
 int i = 0; 
 if (i> = 10) goto byebye; 
 std :: cout << "Не слишком большой! \ N"; 
 до свидания: возврат 0; 
} 
 
Этот способ написания C ++ очень похож на сборку - фактически, есть
 взаимно однозначное соответствие между строками кода C, написанного здесь
 путь и инструкции на машинном языке.Более сложный C ++, например
 конструкция «for» расширяется до многих линий сборки.
 int i, n = 10; 
 for (i = 0; i  std :: cout << "В цикле: i ==" << i << "\ n"; 
} 
Вот одна расширенная версия этого цикла C / C ++ "for":
 int i = 0, n = 10; 
 start: std :: cout << "В цикле: i ==" << i << "\ n"; 
 i ++; 
, если (i  
(исполняемая ссылка NetRun)
 Вы должны убедить себя, что это действительно эквивалентно
 цикл "for" во всех случаях.Осторожно - если n - параметр, это не так! (Что, если n> = i?)
 Все конструкции управления потоком C могут быть написаны с использованием только «if» и
 "goto", который обычно однозначно отображает последовательность сравнения и перехода в сборке.
 Нормальный C
 Расширенный C
 если (A) {
 ... 
}
 if (! A) goto END; 
 {
 ... 
} 
 КОНЕЦ:
 если (! A) {
... 
}
 if (A) goto END; 
 {
 ... 
} 
 КОНЕЦ:
 если (A && B) {
 ... 
}
 if (! A) goto END; 
 if (! B) goto END; 
 {
 ... 
} 
 КОНЕЦ:
 если (A || B) {
 ... 
}
 if (A) goto STUFF; 
 if (B) goto STUFF; 
 goto END; 
 STUFF: 
 {
 ... 
} 
 КОНЕЦ:
, а (A) {
... 
}
 goto TEST; 
 НАЧАЛО: 
 {
 ... 
} 
 ТЕСТ: если (A) перейти к НАЧАЛУ;
 делать {
 ... 
}, а (A)
 START: 
 {
 ... 
} 
 if (A) перейти к START;
 для (i = 0; i  {
 ... 
}
 я = 0; / * Версия A * / 
 goto TEST; 
 НАЧАЛО: 
 {
 ... 
} 
 i ++; 
 ТЕСТ: if (i 
 для (i = 0; i  {
... 
}
 я = 0; / * Версия B * / 
 START: if (i> = n) goto END; 
 {
 ... 
} 
 i ++; 
 goto START; 
 КОНЕЦ:
 Обратите внимание, что два последних перевода понятия «для» (помечены
 Версия A и версия B) вычисляют одно и то же. Который из
 быстрее? Если цикл повторяется много раз, я утверждаю, что версия (A) равна
 быстрее, так как есть только один
 (условно) goto каждый раз по циклу вместо двух goto в
 версия (B) - одна
 условный и один безусловный.Но версия (B), вероятно,
 быстрее, если n часто равно 0, потому что в этом случае он быстро переходит в END
 (в одном условном прыжке).
 Инструкция по сравнению 
Итак, вы хотите знать, как какое-то число A соотносится с другим числом B. Итак, вы вычитаете их.
 Если A-B = 0, то A = B. 
 Если A-B> 0, то A> B. 
 Если A-B <0, то A 
 Ага, поэтому "cmp eax, 10" фактически внутренне вычитает 10 из значения в
 eax. Если разница равна нулю, CPU устанавливает флаг ZF (Zero
 Флаг).Если разница положительная или отрицательная, ЦП устанавливает
 некоторые другие отвратительные флаги, чтобы указать на это (ЦП устанавливает различные флаги
 как для знаковых, так и для беззнаковых сравнений).
 Оказывается, «sub eax, 10» на самом деле устанавливает все одинаковые флаги. Таким образом, вы можете сравнить два числа с «cmp A, B» или «sub A, B», и вы получите тот же результат (но они не полностью взаимозаменяемы: «cmp» не изменит A!).
 Итак, вы хотите прыгнуть, если предыдущее сравнение оказалось равным. Вы используете инструкцию «je» (прыгать, если равно).
 Или вы хотите прыгнуть, если предыдущее вычитание оказалось нулевым. Вы используете инструкцию «jz» (переход, если ноль).
 Оказывается, «je» и «jz» - это одна и та же инструкция машинного языка, потому что они оба делают одно и то же.
 Суть в том, чтобы выполнить сравнение в сборке, сначала вы выполняете либо команду cmp, либо вспомогательную инструкцию, а затем:
 Английский язык
 Менее
 Меньше или равно
 равно
 Больше или равно
 Больше
 Не равно
 К / С ++
 <
 <=
 ==
> =
>
! =
 Сборка 
 (с подписью)
 мкл
 ил
 je или jz
 jge
 jg
 jne или jnz
 Сборка 
 (без знака)
 jb
 jbe
 je или jz
 дже
 и
 jne или jnz
Буква «b» в инструкциях сравнения без знака означает «внизу», а «a» - «вверху».
 В C / C ++ компилятор может определить, нужны ли вам подписанные и неподписанные
 сравнение по типам переменных. Нет никаких типов
 в сборке, так что подбирать инструкцию вам решать!
 Сравнить против вычесть: примеры 
Subtract устанавливает все те же флаги сравнения, что и "cmp". Таким образом, этот код возвращает 1, потому что 5 <7.
 mov ecx, 5 
 sub ecx, 7 
 jl yes_it_jumped 
; ... иначе нет, не прыгнул: return 0 
 mov eax, 0 
 ret 
 
 yes_it_jumped:; ... так что верните 1 
 mov eax, 1 
 ret 
 
 
(исполняемая ссылка NetRun)
 Subtract также устанавливает нулевой флаг, поэтому вот очень маленький цикл с обратным отсчетом:
 mov edx, 5 
 mov eax, 0 
 loop_start: 
 add eax, 7 
 sub edx, 1 
 jnz loop_start; Выполняется переход, если edx все еще не равен нулю 
 
 ret 
 
 
(исполняемая ссылка NetRun)
 Бесполезная информация: флаги и подробности о кровопролитии 
Условные переходы фактически используют регистр EFLAGS:
 Инструкция
 Полезно для…
 Флаги (см. Ниже)
 jmp
 Всегда прыгать
 Нет
 и
 Без знака>
 CF = 0 и ZF = 0
 иэ
 Без знака> =
 CF = 0
 сп
 Без знака <
 CF = 1
 jbe
 Без знака <=
 CF = 1 или ZF = 1
 jc
 Беззнаковое переполнение, 
 или сложение multiprecision
 CF = 1
 jecxz
 Сравнить ecx с 0
 эккс = 0
 je или jz
 Равенство
 ZF = 1
 jg
 Подписано>
 ZF = 0 и SF = OF
 jge
 Подпись> =
 SF = OF
 jl
 Подписано <
 SF! = OF
 ил
 Подпись <=
 ZF = 1 или SF! = OF
 jne или jnz
 Неравенство
 ZF = 0
 jo
 Переполнение со знаком
 OF = 1
 jp или jpe
 Проверка четности (четность)
 ПФ = 1
 ипо
 Проверка четности (нечетная)
 ПФ = 0
 js
 Перейти при отрицательном значении
 SF = 1
 Регистр «EFLAGS» на x86 хранит набор флагов, как показано на странице 73 тома руководства Intel Arch.
 1.К важным флагам относятся:
 ZF — «нулевой флаг». Устанавливается всякий раз, когда предыдущий арифметический результат
 был нулевым. Может использоваться с помощью «jz» (переход, если последний результат был нулевым) или
 «jnz» инструкция. «je» (прыгать, если равны) и «jne» (прыгать, если не равны)
 являются просто псевдонимами jz и jnz, потому что, если разница равна нулю,
 тогда два значения равны. Например, этот код проверяет, равен ли ввод 4: 
 extern read_input 
 вызов read_input 
 cmp eax, 4 
 je равно 
 add eax, 20; Если не равно, прибавить 
 равно: ret; Если равно, просто верните
 CF — The
 «нести флаг».Установлен в
 указать бит, который выполняет сложение или вычитание.
 Для чисел со знаком это на самом деле не указывает на проблему, но для
 беззнаковые числа, это указывает на переполнение.
 Может использоваться командой «jc» (переход, если установлен флаг переноса).
 Устанавливается по всем арифметическим инструкциям.
 Можно добавить в другую арифметическую операцию с помощью «adc» (добавить с помощью
 нести). Например, вы можете сохранить бит, выходящий за пределы
 большое добавление вроде этого: 
 mov ecx, 0x8000ff00 
 add ecx, ecx 
 mov eax, 0 
 adc eax, eax; Добавляет eax, eax и флаг переноса вместе
 
 «adc» используется в реализации компилятора 64-битного «long».
 long «тип данных, и вообще в» арифметике с множественной точностью »
 программное обеспечение, такое как арифметическая библиотека множественной точности GNU.
 Его также можно было бы использовать для реализации проверки переполнения путем тщательного
 компилятор. Флаги переноса и нуля также используются беззнаковыми
 сравнение
 инструкции: «jb» (перейти, если ниже без знака), «jbe» (перейти, если без знака
 ниже или равно), «ja» (переходить, если выше без знака), и «jae» (переходить, если
 без знака выше или равно) обычным способом.
 SF — «флаг знака», который указывает отрицательный знак
 результат. Это просто самый высокий бит результата, и он игнорирует любые
 переполнение. Поскольку переполнение может испортить ваш ответ, «jl» смотрит на
 как SF, так и OF для реализации сравнения со знаком.
 OF—
 Подписанный «флаг переполнения». Устанавливается путем вычитания, сложения и сравнения в
 на удивление умный способ: например, если вы сложите два положительных числа,
 и получили отрицательное число, то произошло переполнение. Если вы добавите
 положительное и отрицательное число, переполнения быть не может. Если добавить два
 отрицательные числа и получить положительное число, то произошло переполнение. ИЗ
 является
 используется в подписанных инструкциях сравнения «jl» (перейти, если меньше чем),
 «jle» (переходить, если меньше или равно), «jg» (переходить, если больше) и
 «jge» (переход, если больше или равно) инструкции.См. Ниже, как именно используются OF и SF. Например:
 jae: unsigned> =. Прыгает, если CF == 0. Хорошо, мы только что
 вычисляет a-b и хочет прыгнуть, если a> = b. Если a-b положительный (или
 ноль), тогда CF == 0 и a> = b, поэтому мы должны прыгнуть и сделать. Если а-б
 отрицательно, мы получим перенос, CF == 1, и мы не прыгаем.
 jge: подписано> =. Прыгает, если SF == OF. Обычно мы
 не переполнялся, поэтому OF равно нулю, и это в точности то же самое, что и jae
 случай выше. Напомним, что это сравнение со знаком, поэтому мы можем получить
 переносить, если мы сравниваем отрицательные числа, поэтому не стоит смотреть на
 CF.Любопытно, что если мы переполнились, знаковый бит теперь неверен, поэтому, если
 OF — один, мы сравниваем SF с одним, что переворачивает сравнение
 правильный путь снова.
 PF и AF — действительно причудливые древние флаги, пережитки 8
 битые дни. Оба они работают только с младшими 8 битами
 результат. PF возвращает нечетную четность, как для серийного
 коммуникация. AF указывает перенос из младших 4 бит в
 старшие 4 бита, которые использовались для древней техники «двоичного
 кодированная десятичная дробь «(BCD), где» 0x23 «означает двадцать три десятичной дроби, а не
 тридцать пять, как нормальный гекс.Это противно, теперь прошло и хорошо
 избавление!
Если вы пытаетесь представить себе условный jmp, вы должны знать, какие инструкции устанавливают какие
 флаги. Например, «cmp», «and» (побитовое И), «sub» и
 инструкция «добавить» устанавливает все флаги; «inc» (увеличение на 1) и «dec»
 (уменьшение на 1) установить все, кроме CF; пока «мов» и все прыгают
 инструкции не связываются с флагами. Легко случайно
 перезаписать флаги, которые вам нужны, если вы оставите слишком много вещей между
 время установки флага и время его чтения!
 Фактически вы можете посмотреть на флаги с помощью инструкции «lahf», которая
 копирует важные биты EFLAGS в регистр ah, то есть биты
 8-16 eax
 получить EFLAGS (SF: ZF: 0: AF: 0: PF: 1: CF).Вот код, который распечатывает
 странная шестнадцатеричная константа в зависимости от флагов, хотя она выполняет
 многократные сравнения:
 mov ecx, 4; значения для сравнения 
 mov edx, 7 
 mov eax, 0 
 
 cmp ecx, edx 
 jne skipe; Флаг равно нулю 
 добавить eax, 0xE 
 skipe: 
 
 cmp ecx, edx 
 jno skipo; Флаг переполнения (при условии подписи) 
 add eax, 0x80 
 skipo: 
 
 cmp ecx, edx 
 jns пропускает; Флаг подписи (отрицательный результат) 
 add eax, 0x500 
 skips: 
 
 cmp ecx, edx 
 jnc skipc; Флаг переноса (33-й бит результата) 
 add eax, 0xC000 
 skipc: 
 
 ret 
 
 (Попробуйте сейчас в NetRun!)
 Различные команды фанк-перехода, такие как «jc» (переход, если установлен CF), или
 «jo» (переход, если установлен OF), также читайте флаги.Обратите внимание, что нет возможности
 добраться до флагов или напрямую вызвать
 инструкции по использованию флагов на C ++! Никто! Компиляторы C / C ++ игнорируют
 целочисленное переполнение, и это невозможно исправить в C / C ++, но в
 сборка так же проста как «жо»!
 Бонусный ужас! Кровавые подробности сравнений 
Достаточно внимательно посмотреть, чтобы убедиться, что различные
 прыжки на самом деле делают правильное сравнение.
 Легкий футляр для
 беззнаковые числа, где ja и jb обозначают флаг переноса, CF:
 v минус ->
 4000000000
 3000000000
 2000000000
 1000000000
 0
 4000000000
 0 
 ZF
 1000000000
 2000000000
 3000000000
 4000000000
 3000000000
 3294967296 
 (32-разрядная версия -1000000000) 
 CF
 0 
 ZF
 1000000000
 2000000000
 3000000000
 2000000000
 2294967296 
 (32-разрядная версия -2000000000) 
 CF
 3294967296 
 (32-разрядная версия -1000000000) 
 CF
 0 
 ZF
 1000000000
 2000000000
 1000000000
 1294967296 
 (32-разрядная версия -3000000000) 
 CF
 2294967296 
 (32-разрядная версия -2000000000) 
 CF
 3294967296 
 (32-разрядная версия -1000000000) 
 CF
 0 
 ZF
 1000000000
 0
 294967296 
 (32-битная версия -4000000000) 
 CF
 1294967296 
 (32-разрядная версия -3000000000) 
 CF
 2294967296 
 (32-разрядная версия -2000000000) 
 CF
 3294967296 
 (32-разрядная версия -1000000000) 
 CF
 0 
 ZF
Таблица беззнакового вычитания.Обратите внимание, что CF устанавливается, когда ответ должен
 быть отрицательным; это означает, что первое число меньше (беззнаковый
 ниже), поэтому «jb» проверяет CF == 1. «jbe» проверяет CF == 1 или ZF == 1. Вот уменьшенная версия приведенной выше таблицы:
 v минус ->
 4млн
 3млн
 2млн
 1млрд
 0
 4млн
 ZF (=)
 нет флагов (>)
 нет флагов (>)
без флагов (>)
без флагов (>)
 3млн
 CF (<)
 ZF (=)
без флагов (>)
без флагов (>)
без флагов (>)
 2млрд
 CF (<)
 CF (<)
 ZF (=)
без флагов (>)
без флагов (>)
 1млрд
 CF (<)
 CF (<)
 CF (<)
 ZF (=)
без флагов (>)
 0
 CF (<)
 CF (<)
 CF (<)
 CF (<)
 ZF (=)
Не так уж и плохо, правда? Для беззнакового CF означает меньше.Обратите внимание, что SF
 и OF сходят с ума во время этой таблицы, но для неподписанных мы можем
 игнорируй их.
 Вот та же таблица для чисел со знаком:
 v минус ->
 2000000000
 1000000000
 0
 -1000000000
 -2000000000
 2000000000
 0 
 ZF
 1000000000
 2000000000
 -1294967296 
 (32-битная версия 3000000000) 
 SF OF
 -294967296 
 (32-битная версия 4000000000) 
 SF OF
 1000000000
 -1000000000 
 SF
 0 
 ZF
 1000000000
 2000000000
 -1294967296 
 (32-битная версия 3000000000) 
 SF OF
 0
 -2000000000 
 SF
 -1000000000 
 SF
 0 
 ZF
 1000000000
 2000000000
 -1000000000
 1294967296 
 (32-битная версия -3000000000) 
 OF
 -2000000000 
 SF
 -1000000000 
 SF
 0 
 ZF
 1000000000
 -2000000000
 294967296 
 (32-битная версия -4000000000) 
 OF
 1294967296 
 (32-битная версия -3000000000) 
 OF
 -2000000000 
 SF
 -1000000000 
 SF
 0 
 ZF
Таблица вычитания со знаком.Если первое число меньше, чем
 второе число, вы получите либо SF (отрицательный ответ), либо просто OF
 (переполнение). Если он больше, вы либо не получите флагов (положительный ответ,
 нет переполнения), или как SF, так и OF (отрицательный ответ из-за переполнения). Вот уменьшенная версия приведенной выше таблицы:
 v минус ->
 + 2млн
 + 1млн
 0
 -1млрд
 -2млрд
 + 2млн
 ZF (=)
 нет флагов (>)
без флагов (>)
 СФ ОФ (>)
 SF OF (>)
 + 1млн
 SF (<)
 ZF (=)
без флагов (>)
без флагов (>)
 SF OF (>)
 0
 SF (<)
 SF (<)
 ZF (=)
без флагов (>)
без флагов (>)
 -1млрд
 OF (<)
 SF (<)
 SF (<)
 ZF (=)
без флагов (>)
 -2млрд
 OF (<)
 OF (<)
 SF (<)
 SF (<)
 ZF (=)
Опять же, для чисел со знаком * либо * SF, либо OF означает <(поэтому jl указан как «SF! = OF»).Нет
flags, или * оба * SF и OF означают> (поэтому jg указан как «SF == OF»). Итак, «jl» и «jg» поступают правильно.
 Вы, наверное, проживете всю свою жизнь и непременно сдадите этот класс,
 не помня точно, почему «jl» проверяет SF! = OF. Ты сделаешь,
 однако необходимо знать, что SF и OF существуют, потому что они действительно
 полезны сами по себе.
 Intel x86 JUMP краткий справочник 
 Восприятие прыжков и флажков долгое время было проблемой.
 область для меня, тем более что книга ассемблера Intel показывает 32 из
 все с похожими именами.Присмотревшись, я
 обнаружил, что многие инструкции являются синонимами друг друга,
 и на практике вся гамма не нужна, а в процессе
 обнаружил, что моя копия Справочника программиста Intel  80386
 Руководство  дало неверное описание одной из инструкций.
 Итак, я сгруппировал их функционально, со всеми инструкциями
 синонимы в одном ряду.
 Инструкция
 Описание
 подпись
 Флаги
 короткий 
 переход 
 коды операций
 около 
 скачок 
 коды операций
 JO
 Перейти при переполнении
 OF = 1
 70
 0F 80
 JNO
 Перейти, если не переполнение
 OF = 0
 71
 0F 81
 JS
 Перейти, если знак
 SF = 1
 78
 0F 88
 JNS
 Перейти, если не подписать
 SF = 0
 79
 0F 89
 JE 
 JZ
 Перейти, если равно
 
 Перейти, если ноль
 ZF = 1
 74
 0F 84
 JNE
 
 JNZ
 Перейти, если не равно
 
 Перейти, если не ноль
 ZF = 0
 75
 0F 85
 JB
 
 JNAE
 
 JC
 Перейти, если ниже
 
 Перейти, если не больше или равно
 
 Прыгать, если переносить
 без знака
 CF = 1
 72
 0F 82
 JNB
 
 JAE
 
 JNC
 Перейти если не ниже
 
 Перейти, если больше или равно
 
 Прыгай, если не несешь
 без знака
 CF = 0
 73
 0F 83
 JBE
 
 JNA
 Перейти, если меньше или равно
 
 Перейти, если не выше
 без знака
 CF = 1 или ZF = 1
 76
 0F 86
 JA
 
 JNBE
 Перейти, если выше
 
 Перейти, если не меньше или равно
 без знака
 CF = 0 и ZF = 0
 77
 0F 87
 JL
 
 JNGE
 Перейти если меньше
 
 Перейти, если не больше или равно
 подписано
 SF <> OF
 7C
 0F 8C
 JGE
 
 JNL
 Перейти, если больше или равно
 
 Перейти, если не менее
 подписано
 SF = OF
 7D
 0F 8D
 JLE
 
 JNG
 Перейти, если меньше или равно
 
 Перейти, если не больше
 подписано
 ZF = 1 или SF <> OF
 7E
 0F 8E
 JG
 
 JNLE
 Перейти, если больше
 
 Прыжок, если не меньше или равно
 подписано
 ZF = 0 и SF = OF
 7F
 0F 8F
 JP
 
 JPE
 Перейти, если четность
 
 Перейти, если четность даже
 ПФ = 1
 7A
 0F 8A
 JNP
 
 JPO
 Перейти, если не четность
 
 Перейти, если четность нечетная
 ПФ = 0
 7Б
 0F 8B
 JCXZ
 
 JECXZ
 Перейти, если регистр% CX равен 0
 
 Перейти, если регистр% ECX равен 0
% CX = 0
 
% ECX = 0
 E3
 Процессоры x86 имеют большой набор флагов, которые представляют состояние
 процессора, а инструкции условного перехода могут
 от них в сочетании.
 CF — флаг переноски
 Установить на перенос или заимствование старшего бита; растаможен в противном случае
 PF — флаг четности
 Устанавливается, если младшие восемь бит результата содержат четное число
 бит «1»; растаможен в противном случае
 ZF — нулевые флаги
 Устанавливается, если результат равен нулю; растаможен в противном случае
 SF — знак флага
 Установить равным старшему биту результата (0, если положительный, 1, если отрицательный)
 OF — флаг переполнения
 Устанавливается, если результат слишком большое положительное число или слишком мало
 отрицательное число (исключая знаковый бит), чтобы соответствовать операнду назначения;
 очищено иначе
 8086 Руководство по ассемблеру для начинающих (часть 7) 
  Короткие условные переходы 
 В отличие от инструкции  JMP , которая выполняет безусловный переход, есть инструкции
 которые делают условные прыжки (прыжки только при выполнении некоторых условий).Эти инструкции разделены на три группы: первая группа просто проверяет один флаг, вторая
 сравнивает числа как знаковые, а третий сравнивает числа как беззнаковые.
  Инструкции перехода, которые проверяют одиночный флаг 
 Инструкция
 Описание
 Состояние
 Противоположная инструкция
 JZ, JE
 Перейти, если ноль (равно).
 ZF = 1
 JNZ, JNE
 JC, JB, JNAE
 Прыгать при переносе (ниже, не выше равно).
 CF = 1
 JNC, JNB, JAE
 JS
 Перейти, если подпись.
 SF = 1
 JNS
 JO
 Перейти при переполнении.
 OF = 1
 JNO
 JPE, JP
 Перейти, если четность.
 PF = 1
 JPO
 JNZ, JNE
 Перейти, если не ноль (не равно).
 ZF = 0
 JZ, JE
 JNC, JNB, JAE
 Перейти, если не переносится (не ниже, выше).
 CF = 0
 JC, JB, JNAE
 JNS
 Перейти, если не подписать.
 SF = 0
 JS
 JNO
 Перейти, если нет переполнения.
 OF = 0
 JO
 JPO, JNP
 Перейти, если четность нечетная (без четности).
 PF = 0
 JPE, JP
 как вы уже могли заметить, есть некоторые инструкции, которые делают то же самое, это правильно,
 они даже собраны в один и тот же машинный код, поэтому хорошо помнить, что
 когда вы скомпилируете инструкцию  JE  — вы получите ее в разобранном виде:  JZ ,  JC  собирается так же, как  JB  и т. д… 
 различных названия используются, чтобы упростить понимание программ, их кодирование и, самое главное, запоминание. очень смещенный диссемблер понятия не имеет, как выглядела исходная инструкция, поэтому он использует наиболее распространенное имя.
, если вы имитируете этот код, вы увидите, что все инструкции собраны в  JNB , рабочий код (код операции) для этой инструкции —  73h  эта инструкция имеет фиксированную длину в два байта, второй байт — это количество байтов для добавить в регистр  IP , если условие верно.поскольку инструкция имеет только 1 байт для сохранения смещения, она ограничена передачей управления до -128 байтов назад или 127 байтов вперед, это значение всегда подписано.
   jnc a
   jnb a
   чжэ

   мов топор, 4
a: mov ax, 5
   Ret

 
  Инструкции перехода для чисел со знаком 
 Инструкция
 Описание
 Состояние
 Противоположная инструкция
 JE, JZ
 Перейти, если равно (=).
 Перейти, если ноль.
 ZF = 1
 JNE, JNZ
 JNE, JNZ
 Перейти, если не равно (<>). 
 Перейти, если не ноль.
 ZF = 0
 JE, JZ
 JG, JNLE
 Перейти, если больше (>). 
 Перейти, если не меньше или равно (не <=).
 ZF = 0 
 и 
 SF = OF
 JNG, JLE
 JL, JNGE
 Перейти, если меньше ().
 Перейти, если не больше или равно (не> =).
 SF <> OF
 JNL, JGE
 JGE, JNL
 Перейти, если больше или равно (> =). 
 Перейти, если не меньше (не <).
 SF = OF
 JNGE, JL
 JLE, JNG
 Перейти, если меньше или равно (<=). 
 Перейти, если не больше (не>).
 ZF = 1 
 или 
 SF <> OF
 JNLE, JG
 <> — знак означает не равно.
  Инструкции перехода для чисел без знака 
 Инструкция
 Описание
 Состояние
 Противоположная инструкция
 JE, JZ
 Перейти, если равно (=). 
 Перейти, если ноль.
 ZF = 1
 JNE, JNZ
 JNE, JNZ
 Перейти, если не равно (). 
 Перейти, если не ноль.
 ZF = 0
 JE, JZ
 JA, JNBE
 Перейти, если вверху (>).
 Перейти, если не ниже или равно (не <=).
 CF = 0 
 и 
 ZF = 0
 JNA, JBE
 JB, JNAE, JC
 Перейти, если ниже (<). 
 Перейти, если не выше или равно (not> =). 
 Прыгай, если несешь.
 CF = 1
 JNB, JAE, JNC
 JAE, JNB, JNC
 Перейти, если выше или равно (> =). 
 Перейти, если не ниже (не <). 
 Прыгай, если не несешь.
 CF = 0
 JNAE, JB
 JBE, JNA
 Перейти, если ниже или равно (<=). 
 Перейти, если не выше (not>).
 CF = 1 
 или 
 ZF = 1
 JNBE, JA
 Обычно, когда требуется сравнить числовые значения  Инструкция CMP 
 используется (выполняет то же самое, что и инструкция  SUB  (вычитание), но не сохраняет
 результат, просто влияет на флаги).
 Логика очень простая, например: 
 нужно сравнить
 5 и 2, 
 5-2 = 3 
 результат не равен нулю (нулевой флаг
 установлен на 0).
 Другой пример: 
 требуется сравнить 7 и
 7, 
 7-7 = 0 
 результат равен нулю! (Нулевой флаг
 установлен на 1 и  JZ  или  JE  выполнит прыжок).
 вот пример инструкции  CMP  и условного перехода:
включить "emu8086.inc"

org 100h

mov al, 25; установите al на 25.mov bl, 10; установите bl на 10.

cmp al, bl; сравнить al - bl.

Je равный; перейти, если al = bl (zf = 1).

putc 'n'; если он попадает сюда, то al <> bl,
jmp stop; так что напечатайте «n» и прыгайте, чтобы остановиться.

равный:            ; если попадет сюда,
putc 'y'; тогда al = bl, поэтому выведите 'y'.

останавливаться:

ret; попадает сюда несмотря ни на что.

 
 попробуйте приведенный выше пример с разными номерами для  AL  и  BL ,
 открыть флаги, нажав на кнопку флажков, использовать пошаговый
 и посмотрим, что получится.вы можете использовать горячую клавишу  F5  для перекомпиляции и перезагрузки программы в эмулятор.
  петель 
 инструкция
 срабатывание и условие перехода
 напротив инструкции
 LOOP
 уменьшить cx, перейти к метке, если cx не равно нулю.
 DEC CX и JCXZ
 LOOPE
 уменьшить cx, перейти к метке, если cx не равно нулю и равно (zf = 1).
 ПЕТЛЯ
 LOOPNE
 уменьшить cx, перейти к метке, если cx не ноль и не равно (zf = 0).
 ПЕТЛЯ
 LOOPNZ
 уменьшить cx, перейти к метке, если cx не равно нулю и zf = 0.
 LOOPZ
 LOOPZ
 уменьшить cx, перейти к метке, если cx не равно нулю и zf = 1.
 LOOPNZ
 JCXZ
 перейти к метке, если cx равно нулю.
 ИЛИ CX, CX и JNZ
 Циклы
 — это в основном те же переходы, циклы можно кодировать без использования инструкции цикла, просто
 используя условные переходы и сравнение, и это именно то, что делает цикл.все инструкции цикла используют регистр  CX  для подсчета шагов, поскольку вы знаете, что регистр CX имеет 16 бит и максимальное значение, которое он может удерживать, составляет 65535 или FFFF, однако с некоторой гибкостью можно поместить один цикл в другой, а другой — в другой. два, три и т.д … и получить хорошее значение 65535 * 65535 * 65535 …. до бесконечности …. или до конца оперативной памяти или стека. можно сохранить исходное значение регистра cx с помощью инструкции  push cx  и вернуть его к исходному, когда внутренний цикл закончится на  pop cx , например:
org 100h

mov bx, 0; общий счетчик шагов.mov cx, 5
k1: добавить bx, 1
    mov al, '1'
    mov ах, 0эх
    int 10h
    нажать cx
    mov cx, 5
      k2: добавить bx, 1
      mov al, '2'
      mov ах, 0эх
      int 10h
      нажать cx
         mov cx, 5
         k3: добавить bx, 1
         mov al, '3'
         mov ах, 0эх
         int 10h
         петля k3; внутренний во внутреннем контуре.
      поп cx
      петля k2; внутренний цикл.
    поп cx
петля k1; внешний контур.

Ret

 
bx подсчитывает общее количество шагов, по умолчанию эмулятор показывает значения в шестнадцатеричном формате, вы можете дважды щелкнуть регистр, чтобы увидеть значение во всех доступных базах.
, как и все другие циклы условных переходов, имеют противоположного компаньона, который может помочь в создании обходных путей, когда адрес желаемого места слишком далек от ассемблера, автоматически собирает инструкцию обратного и длинного перехода, что составляет всего 5 байтов вместо 2, это может быть видел и в дизассемблере.
 для более подробного описания и примеров см.  полный набор инструкций 8086 
 Все условные переходы имеют одно большое ограничение, в отличие от инструкции  JMP 
 они могут перемещаться только на 127  байтов вперед и на 128  байтов назад (обратите внимание, что большинство
 инструкции собираются в 3 и более байта).
 Мы можем легко обойти это ограничение, используя забавный трюк:
 Получите противоположную инструкцию условного перехода из таблицы выше,
 заставьте его перейти на  label_x .
 Используйте команду  JMP  для перехода в желаемое место.
 Определите  label_x:  сразу после инструкции  JMP .
  label_x:  — может быть любое допустимое имя метки, но не должно быть двух или более меток с одинаковым именем.
 вот пример:
включить "emu8086.inc"

org 100h

mov al, 5
mov bl, 5

cmp al, bl; сравнить al - bl.


jne not_equal; перейти, если al <> bl (zf = 0).
jmp равно
не равный:

добавить bl, al
sub al, 10
xor al, bl

jmp skip_data
db 256 dup (0); 256 байт
skip_data:

putc 'n'; если он попадает сюда, то al <> bl,
jmp stop; так что напечатайте «n» и прыгайте, чтобы остановиться.

равный:            ; если попадет сюда,
putc 'y'; тогда al = bl, поэтому выведите 'y'.останавливаться:

Ret
 
 Примечание: последняя версия встроенного ассемблера 8086 автоматически создает обходной путь, заменяя условный переход на противоположный и добавляя большой безусловный переход. Чтобы проверить, установлена ​​ли у вас последняя версия emu8086, нажмите  help-> проверьте наличие обновлений  в меню.
 Другой, но редко используемый метод — получение вместо этого немедленного значения.
 этикетки. Когда немедленное значение начинается с $ относительного скачка
 выполняется, иначе компилятор вычисляет инструкцию, которая перескакивает напрямую
 к заданному смещению.Например:
org 100h

; безусловный переход вперед:
; пропустить следующие 3 байта + себя
; машинный код короткой инструкции jmp занимает 2 байта.
jmp $ 3 + 2
db 3; 1 байт.
b db 4; 1 байт.
c db 4; 1 байт.

; условный переход назад на 5 байтов:
mov bl, 9
dec bl; 2 байта.
cmp bl, 0; 3 байта.
jne $ -5; перейти на 5 байтов назад

Ret
 
  <<< предыдущая часть <<< 
  >>> Следующая часть >>> 
% PDF-1.4
 %
 7146 0 объект
 >
 эндобдж
 xref
 7146 528
 0000000015 00000 н.
 0000010892 00000 п.
 0000016546 00000 п.
 0000016683 00000 п.
 0000016744 00000 п.
 0000016851 00000 п.
 0000016972 00000 п.
 0000017092 00000 п.
 0000017264 00000 п.
 0000017391 00000 п.
 0000017539 00000 п.
 0000017681 00000 п.
 0000017868 00000 п.
 0000017981 00000 п.
 0000018097 00000 п.
 0000018232 00000 п.
 0000018348 00000 п.
 0000018533 00000 п.
 0000018651 00000 п.
 0000018784 00000 п.
 0000018960 00000 п.
 0000019083 00000 п.
 0000019254 00000 п.
 0000019374 00000 п.
 0000019511 00000 п.
 0000019630 00000 п.
 0000019799 00000 п.
 0000019915 00000 п.
 0000020045 00000 п.
 0000020184 00000 п.
 0000020304 00000 п.
 0000020464 00000 п.
 0000020635 00000 п.
 0000020779 00000 п.
 0000020924 00000 п.
 0000021069 00000 п.
 0000021198 00000 п.
 0000021333 00000 п.
 0000021478 00000 п.
 0000021609 00000 п.
 0000021733 00000 п.
 0000021868 00000 п.
 0000022052 00000 п.
 0000022204 00000 п.
 0000022327 00000 п.
 0000022467 00000 п.
 0000022632 00000 п.
 0000022750 00000 п.
 0000022940 00000 п.
 0000023095 00000 п.
 0000023211 00000 п.
 0000023354 00000 п.
 0000023484 00000 п.
 0000023655 00000 п.
 0000023784 00000 п.
 0000023917 00000 п.
 0000024043 00000 п.
 0000024182 00000 п.
 0000024349 00000 п.
 0000024458 00000 п.
 0000024639 00000 п.
 0000024780 00000 п.
 0000024915 00000 п.
 0000025052 00000 п.
 0000025200 00000 н.
 0000025333 00000 п.
 0000025447 00000 п.
 0000025618 00000 п.
 0000025762 00000 п.
 0000025883 00000 п.
 0000026005 00000 п.
 0000026139 00000 п.
 0000026270 00000 п.
 0000026417 00000 п.
 0000026544 00000 п.
 0000026705 00000 п.
 0000026850 00000 п.
 0000026997 00000 п.
 0000027110 00000 п.
 0000027260 00000 н.
 0000027389 00000 н.
 0000027529 00000 п.
 0000027666 00000 п.
 0000027863 00000 п.
 0000027989 00000 п.
 0000028166 00000 п.
 0000028318 00000 п.
 0000028447 00000 п.
 0000028570 00000 п.
 0000028714 00000 п.
 0000028874 00000 п.
 0000028996 00000 н.
 0000029111 00000 п.
 0000029290 00000 н.
 0000029413 00000 п.
 0000029551 00000 п.
 0000029675 00000 п.
 0000029852 00000 п.
 0000029989 00000 н.
 0000030115 00000 п.
 0000030252 00000 п.
 0000030415 00000 п.
 0000030550 00000 п.
 0000030684 00000 п.
 0000030834 00000 п.
 0000031034 00000 п.
 0000031152 00000 п.
 0000031293 00000 п.
 0000031428 00000 п.
 0000031563 00000 п.
 0000031697 00000 п.
 0000031824 00000 п.
 0000031981 00000 п.
 0000032151 00000 п.
 0000032281 00000 п.
 0000032422 00000 п.
 0000032569 00000 п.
 0000032707 00000 п.
 0000032856 00000 п.
 0000033004 00000 п.
 0000033199 00000 п.
 0000033320 00000 п.
 0000033455 00000 п.
 0000033597 00000 п.
 0000033732 00000 п.
 0000033869 00000 п.
 0000034060 00000 п.
 0000034206 00000 п.
 0000034338 00000 п.
 0000034477 00000 п.
 0000034645 00000 п.
 0000034793 00000 п.
 0000034931 00000 п.
 0000035056 00000 п.
 0000035250 00000 п.
 0000035367 00000 п.
 0000035498 00000 п.
 0000035629 00000 п.
 0000035771 00000 п.
 0000035901 00000 п.
 0000036023 00000 п.
 0000036137 00000 п.
 0000036314 00000 п.
 0000036424 00000 п.
 0000036548 00000 н.
 0000036672 00000 н.
 0000036797 00000 п.
 0000036921 00000 п.
 0000037045 00000 п.
 0000037155 00000 п.
 0000037352 00000 п.
 0000037475 00000 п.
 0000037608 00000 п.
 0000037743 00000 п.
 0000037875 00000 п.
 0000038009 00000 п.
 0000038141 00000 п.
 0000038273 00000 п.
 0000038422 00000 п.
 0000038562 00000 п.
 0000038693 00000 п.
 0000038826 00000 п.
 0000038957 00000 п.
 0000039087 00000 п.
 0000039218 00000 п.
 0000039350 00000 п.
 0000039480 00000 п.
 0000039647 00000 п.
 0000039769 00000 п.
 0000039957 00000 н.
 0000040108 00000 п.
 0000040230 00000 п.
 0000040415 00000 п.
 0000040523 00000 п.
 0000040634 00000 п.
 0000040779 00000 п.
 0000040910 00000 п.
 0000041050 00000 п.
 0000041189 00000 п.
 0000041362 00000 п.
 0000041479 00000 п.
 0000041608 00000 п.
 0000041726 00000 п.
 0000041891 00000 п.
 0000042008 00000 п.
 0000042143 00000 п.
 0000042276 00000 п.
 0000042413 00000 п.
 0000042557 00000 п.
 0000042697 00000 п.
 0000042829 00000 п.
 0000042971 00000 п.
 0000043146 00000 п.
 0000043303 00000 п.
 0000043461 00000 п.
 0000043643 00000 п.
 0000043787 00000 п.
 0000043905 00000 п.
 0000044074 00000 п.
 0000044188 00000 п.
 0000044304 00000 п.
 0000044471 00000 п.
 0000044599 00000 п.
 0000044767 00000 п.
 0000044886 00000 п.
 0000045019 00000 п.
 0000045148 00000 п.
 0000045280 00000 п.
 0000045410 00000 п.
 0000045542 00000 п.
 0000045672 00000 п.
 0000045804 00000 п.
 0000045972 00000 п.
 0000046092 00000 п.
 0000046226 00000 п.
 0000046358 00000 п.
 0000046489 00000 п.
 0000046620 00000 н.
 0000046752 00000 п.
 0000046922 00000 п.
 0000047035 00000 п.
 0000047175 00000 п.
 0000047294 00000 п.
 0000047426 00000 п.
 0000047596 00000 п.
 0000047727 00000 п.
 0000047857 00000 п.
 0000047987 00000 п.
 0000048119 00000 н.
 0000048251 00000 п.
 0000048383 00000 п.
 0000048514 00000 п.
 0000048646 00000 н.
 0000048778 00000 п.
 0000048910 00000 п.
 0000049042 00000 н.
 0000049174 00000 п.
 0000049344 00000 п.
 0000049470 00000 п.
 0000049604 00000 п.
 0000049747 00000 п.
 0000049904 00000 н.
 0000050029 00000 п.
 0000050146 00000 п.
 0000050316 00000 п.
 0000050429 00000 п.
 0000050576 00000 п.
 0000050728 00000 п.
 0000050907 00000 п.
 0000051030 00000 п.
 0000051172 00000 п.
 0000051325 00000 п.
 0000051465 00000 п.
 0000051643 00000 п.
 0000051780 00000 п.
 0000051918 00000 п.
 0000052084 00000 п.
 0000052223 00000 п.
 0000052363 00000 п.
 0000052495 00000 п.
 0000052668 00000 п.
 0000052806 00000 п.
 0000053000 00000 п.
 0000053113 00000 п.
 0000053282 00000 п.
 0000053399 00000 п.
 0000053535 00000 п.
 0000053654 00000 п.
 0000053786 00000 п.
 0000053975 00000 п.
 0000054089 00000 п.
 0000054215 00000 п.
 0000054345 00000 п.
 0000054542 00000 п.
 0000054685 00000 п.
 0000054828 00000 н.
 0000055016 00000 п.
 0000055132 00000 п.
 0000055247 00000 п.
 0000055427 00000 п.
 0000055561 00000 п.
 0000055702 00000 п.
 0000055871 00000 п.
 0000056014 00000 п.
 0000056194 00000 п.
 0000056335 00000 п.
 0000056510 00000 п.
 0000056648 00000 н.
 0000056819 00000 п.
 0000056930 00000 п.
 0000057060 00000 п.
 0000057188 ​​00000 п.
 0000057316 00000 п.
 0000057429 00000 п.
 0000057601 00000 п.
 0000057723 00000 п.
 0000057856 00000 п.
 0000058014 00000 п.
 0000058146 00000 п.
 0000058320 00000 п.
 0000058454 00000 п.
 0000058593 00000 п.
 0000058747 00000 п.
 0000058879 00000 п.
 0000059013 00000 п.
 0000059183 00000 п.
 0000059313 00000 п.
 0000059438 00000 п.
 0000059571 00000 п.
 0000059702 00000 п.
 0000059819 00000 п.
 0000059989 00000 н.
 0000060117 00000 п.
 0000060251 00000 п.
 0000060414 00000 п.
 0000060563 00000 п.
 0000060715 00000 п.
 0000060867 00000 п.
 0000061018 00000 п.
 0000061172 00000 п.
 0000061326 00000 п.
 0000061470 00000 п.
 0000061617 00000 п.
 0000061763 00000 п.
 0000061909 00000 п.
 0000062054 00000 п.
 0000062202 00000 п.
 0000062353 00000 п.
 0000062504 00000 п.
 0000062648 00000 п.
 0000062797 00000 н.
 0000062949 00000 п.
 0000063101 00000 п.
 0000063250 00000 п.
 0000063402 00000 п.
 0000063554 00000 п.
 0000063700 00000 п.
 0000063845 00000 п.
 0000063990 00000 п.
 0000064138 00000 п.
 0000064285 00000 п.
 0000064430 00000 н.
 0000064576 00000 п.
 0000064734 00000 п.
 0000064883 00000 п.
 0000065036 00000 п.
 0000065186 00000 п.
 0000065339 00000 п.
 0000065485 00000 п.
 0000065636 00000 п.
 0000065790 00000 п.
 0000065944 00000 п.
 0000066095 00000 п.
 0000066249 00000 п.
 0000066403 00000 п.
 0000066549 00000 п.
 0000066695 00000 п.
 0000066841 00000 п.
 0000066987 00000 п.
 0000067135 00000 п.
 0000067285 00000 п.
 0000067438 00000 п.
 0000067590 00000 н.
 0000067736 00000 п.
 0000067867 00000 п.
 0000068062 00000 п.
 0000068225 00000 п.
 0000068367 00000 п.
 0000068492 00000 п.
 0000068622 00000 п.
 0000068773 00000 п.
 0000068893 00000 п.
 0000069024 00000 н.
 0000069166 00000 п.
 0000069339 00000 п.
 0000069459 00000 п.
 0000069604 00000 п.
 0000069775 00000 п.
 0000069892 00000 п.
 0000070024 00000 п.
 0000070182 00000 п.
 0000070293 00000 п.
 0000070419 00000 п.
 0000070570 00000 п.
 0000070721 00000 п.
 0000070864 00000 п.
 0000070990 00000 н.
 0000071111 00000 п.
 0000071232 00000 п.
 0000071358 00000 п.
 0000071466 00000 п.
 0000071618 00000 п.
 0000071767 00000 п.
 0000071934 00000 п.
 0000072044 00000 п.
 0000072189 00000 п.
 0000072341 00000 п.
 0000072482 00000 п.
 0000072693 00000 п.
 0000072816 00000 п.
 0000072980 00000 п.
 0000073104 00000 п.
 0000073239 00000 п.
 0000073382 00000 п.
 0000073522 00000 п.
 0000073673 00000 п.
 0000073793 00000 п.
 0000073961 00000 п.
 0000074099 00000 п.
 0000074235 00000 п.
 0000074373 00000 п.
 0000074509 00000 п.
 0000074647 00000 п.
 0000074784 00000 п.
 0000074922 00000 п.
 0000075061 00000 п.
 0000075193 00000 п.
 0000075324 00000 п.
 0000075485 00000 п.
 0000075611 00000 п.
 0000075748 00000 п.
 0000075865 00000 п.
 0000075988 00000 п.
 0000076136 00000 п.
 0000076310 00000 п.
 0000076482 00000 п.
 0000076613 00000 п.
 0000076752 00000 п.
 0000076924 00000 п.
 0000077054 00000 п.
 0000077193 00000 п.
 0000077377 00000 п.
 0000077508 00000 п.
 0000077677 00000 п.
 0000077802 00000 п.
 0000077948 00000 п.
 0000078067 00000 п.
 0000078236 00000 п.
 0000078360 00000 п.
 0000078489 00000 п.
 0000078658 00000 п.
 0000078783 00000 п.
 0000078928 00000 п.
 0000079047 00000 п.
 0000079223 00000 п.
 0000079338 00000 п.
 0000079470 00000 п.
 0000079588 00000 п.
 0000079736 00000 п.
 0000079890 00000 н.
 0000080015 00000 п.
 0000080168 00000 п.
 0000080304 00000 п.
 0000080472 00000 п.
 0000080597 00000 п.
 0000080750 00000 п.
 0000080887 00000 п.
 0000081056 00000 п.
 0000081167 00000 п.
 0000081282 00000 п.
 0000081464 00000 п.
 0000081578 00000 п.
 0000081714 00000 п.
 0000081832 00000 п.
 0000081981 00000 п.
 0000082128 00000 п.
 0000082302 00000 п.
 0000082462 00000 п.
 0000082559 00000 п.
 0000082686 00000 п.
 0000082831 00000 п.
 0000082950 00000 п.
 0000083073 00000 п.
 0000083189 00000 п.
 0000083305 00000 п.
 0000083421 00000 п.
 0000083536 00000 п.
 0000083652 00000 п.
 0000083768 00000 п.
 0000083884 00000 п.
 0000084000 00000 п.
 0000084116 00000 п.
 0000084232 00000 п.
 0000084348 00000 п.
 0000084464 00000 н.
 0000084580 00000 п.
 0000084696 00000 н.
 0000084812 00000 п.
 0000084928 00000 п.
 0000085044 00000 п.
 0000085160 00000 п.
 0000085276 00000 п.
 0000085392 00000 п.
 0000085508 00000 п.
 0000085624 00000 п.
 0000085740 00000 п.
 0000085856 00000 п.
 0000085971 00000 п.
 0000086073 00000 п.
 0000086182 00000 п.
 0000086233 00000 п.
 0000087300 00000 п.
 0000087516 00000 п.
 0000119143 00000 н.
 0000120296 00000 н.
 0000121079 00000 н.
 0000122148 00000 н.
 0000122366 00000 н.
 0000154282 00000 н.
 0000155435 00000 н.
 0000156218 00000 н.
 0000157293 00000 н.
 0000157516 00000 н.
 00001
 00000 н.
 00001
 00000 н.
 00001
 00000 н.
 00001
 00000 н.
 00001
 00000 н.
 0000221681 00000 н.
 0000222834 00000 н.
 0000223617 00000 н.
 0000223790 00000 н.
 0000223999 00000 н.
 0000227969 00000 н.
 0000228067 00000 н.
 0000228372 00000 н.
 0000016523 00000 п.
 0000011056 00000 п.
 трейлер
 ] / Информация 7143 0 R / Назад 3554921 >>
 startxref
 0
 %% EOF
 7147 0 объект
 > / PageMode / UseOutlines / Outlines 7149 0 R / OpenAction [7148 0 R / FitH 1000] / Метаданные 7144 0 R >>
 эндобдж
 7673 0 объект
 >
 транслировать
 x = {| U ߜ Idi
 A Руководство по сборке x86 
  Ассемблер  (или  ассемблер ) — это любой язык программирования низкого уровня, на котором существует очень строгое соответствие между операторами программы и инструкциями машинного кода архитектуры.«Некоторые из вас могут знать это из своих курсов по информатике, где вы должны были прочитать много единиц и нулей.
 Что такое язык программирования низкого уровня? 
 Язык программирования низкого уровня — это язык программирования, который мало что дает к отсутствию абстракции от архитектуры набора команд компьютера.Языки низкого уровня обычно работают на  инструкциях , а команды или функции на этом языке низкого уровня тесно сопоставляются с набором команд процессора.Слово «Низкий» означает, что между языком и процессором практически нет абстракции.
 Языки программирования второго поколения обычно кодируют программы на Ассемблере, который, в свою очередь, генерирует машинный код для выполнения. Машинный код — единственный язык, который компьютеры могут понимать без какой-либо обработки. Ниже приведен пример машинного кода в шестнадцатеричной форме для генерации членов ряда Фибоначчи.
 Машинный код X86
 Точно так же, как мы не можем понять машинный код, компьютерный процессор не может понять наш язык, вот где в игру вступает язык ассемблера.
 Ассемблер + компоновщик
 Ассемблер + компоновщик вместе называются транслятором, который принимает предоставленную нами мнемонику ассемблера и преобразует их в машинный код, который мы затем можем выполнить.
 Что такое мнемоника? 
 В программировании мнемоника — это имя, присвоенное машинной функции, или сокращение для операции. Каждая мнемоника представляет собой машинную команду низкого уровня или код операции в сборке.  add ,  mul ,  lea ,  cmp  и  je  являются примерами мнемоники.
 Что такое регистры? 
 Регистры в программировании на ассемблере можно рассматривать как глобальные переменные, которые мы используем в языках программирования более высокого уровня для общих операций.
 Некоторые различные типы регистров:
 Общего назначения — Eax, Ebx, Esp, Ebp
 Сегмент — CS, CD
 Управление — EIP
 Регистры общего назначения 
 Регистры общего назначения
 Это некоторые из общих целевые регистры в архитектуре x86, каждый из вышеуказанных регистров может хранить 32 бита данных.Подумайте о регистре EAX с 32 битами, нижняя часть EAX называется AX, которая содержит 16 бит данных, AX также делится на две части AH и AL, каждая из которых имеет размер 8 бит, то же самое касается EBX, ECX и EDX.
 EAX — регистр накопителя — используется для хранения операндов и данных результатов
 EBX — базовый регистр — указывает на данные
 ECX — регистр счетчика — операции цикла
 В отличие от регистров, которые мы видели ранее, вышеуказанные регистры (ESP, EBP, ESI , EDI не может быть разделен на малые 8 бит, однако они делятся на старшие и младшие 16 бит регистра.Регистры в процессоре ограничены, вы не можете использовать их для хранения больших фрагментов данных, и здесь в игру вступает память. Данные могут храниться в памяти в структуре данных стека, регистр ESP служит операндом  косвенной памяти , указывающим на вершину стека в любое время. Рассмотрим стек, содержащий данные, ESP указывает на вершину этого стека. Учтите, что в настоящее время стек содержит только целочисленное значение 2. так что 2 будет наверху стека. Регистр ESP будет указывать на целочисленное значение 2, и точно так же EBP указывает на основание стека.
 То, что не помещается в регистры, живет в памяти 
 Доступ к памяти осуществляется либо путем загрузки и сохранения по адресам, как если бы это был большой массив, либо посредством операций PUSH и POP в стеке.
 Это общая иерархия памяти компьютера, регистры находятся наверху, они быстрее остальных, но также меньше по размеру, при движении вниз по иерархии размер хранилища увеличивается, а скорость уменьшается
 Как хранятся типы данных в памяти? 
 Существует несколько способов хранения многобайтовых типов данных. Двумя наиболее распространенными способами хранения типов данных в памяти являются Little Endian и Big Endian.
 Тип хранилища данных Little Endian обычно используется в процессорах Intel, где основное внимание уделяется скорости обработки, а не количеству потребляемой мощности. Однако Arm производит процессоры для мобильных устройств, в которых аккумулятор и энергопотребление играют важную роль, поэтому Big Endian используется с процессорами Arm.
 Сохранение 0x01234567
 На изображении выше показано, как 0x01234567 будет храниться в памяти. В Big Endian данные хранятся как дано, но в Little Endian байты записываются в другом порядке, начиная с 0x01234567, сначала записывается 67, затем 45, затем 23 и, наконец, 01.
 Более простое объяснение хранения CAFEBABE
  Давайте поговорим о сегментах памяти! 
 Текст
 Содержит инструкции для программы
 Данные
 Содержит данные для программы, например строки сообщений
 BSS
 Содержит все неинициализированные глобальные переменные
 Hello World
 На изображении выше представлена ​​структура программы Hello World на ассемблере.
 Точкой входа в программу является глобальная переменная с именем _start:, и выполнение программы начинается оттуда. Раздел «Текст» содержит инструкции по печати и выходу из программы, раздел «Данные» содержит строку сообщения «Hello World!». который используется в инструкции печати в текстовом разделе.
 Один из наиболее важных регистров: EIP 
 Как мы обсуждали ранее, сборка выполняется в соответствии с инструкциями, а инструкции записываются упорядоченным образом.
 _start:
 mov $ 5, ecx
 mov $ 5, edx
 cmp ecx, edx
 В приведенной выше ассемблерной программе выполнение начинается с символа _start:
 EIP указывает на следующую инструкцию для выполнения
 Перед выполнением 1-й инструкции «mov $ 5, ecx» EIP указывает на адрес первой инструкция.После выполнения EIP увеличивается на 1, так что теперь он будет указывать на вторую инструкцию. Выполнение программы будет происходить таким образом, как злоумышленник, если мы хотим получить контроль над программой, мы должны манипулировать значением EIP. Так же, как операторы if else в языках программирования более высокого уровня, ассемблер также предоставляет мнемонику для управления потоком программы, но давайте сначала разберемся с некоторыми основными мнемониками ассемблера.
 Это некоторые из многих, оснащенных процессором, и они в значительной степени говорят сами за себя.Обсудим инструкцию  Jmp .
 jmp — это как функция goto в C, она безоговорочно переместится в указанное место. Рассмотрим этот код, который я привожу ниже.
 mov $ 5, ecx
 mov $ 5, edx
 jmp 5
 mov $ 6, ecx
 cmp ecx, edx
 je функция
 функция:
 В приведенном выше фрагменте кода 1-я инструкция и 2-я инструкция будут выполняться одна за другой, в результате получается 5 в ecx и edx.Встречается инструкция jmp 5, поэтому поток напрямую передается инструкции номер 5. Таким образом, инструкция номер 4 никогда не будет выполнена. Теперь посмотрим на инструкцию cmp, после выполнения 3-й инструкции выполнение переходит к 5-й инструкции.
 cmp ecx, edx
 Которая будет сравнивать ecx и edx, вычитая одно из другого, если вычитание равно нулю, это означает, что оба значения, хранящиеся в регистрах ecx и edx, одинаковы.
 Итак, нулевой флаг установлен в единицу, что указывает на то, что результат равен нулю.
 Теперь обнаружена инструкция JE.
 Инструкция JE проверит наличие нулевого флага в выполненной выше инструкции. JE просто означает переход, если он равен приведенной выше инструкции, если ecx и eds равны, je перенаправляет поток в функцию:
 Компьютеры содержат многоуровневую структуру 
 Уровень 3
 Библиотеки прикладного уровня
 Уровень 2
 Уровень 1
 Уровень 0
 ОС содержит библиотеки и драйверы 
 Чтобы взаимодействовать с ОС, мы должны использовать системный вызов (syscall), операционная система предлагает некоторые службы для приложения, работающего на ней.Эти службы доступны с помощью этих системных вызовов для открытия файлов, отображения памяти, чтения содержимого каталога и т. Д. Все эти действия требуют взаимодействия с оборудованием (жесткий диск, блок управления памятью) и управляются ОС.
 Все возможные системные вызовы linux перечислены, поэтому на них можно ссылаться по номерам при выполнении вызовов в сборке.
 т.е. EXIT — 1
 WRITE — 4
 Как работают системные вызовы? 
 На изображении ниже представлена ​​краткая информация о том, как работают системные вызовы.
 Управление системными вызовами
 Программа пользовательского пространства вызывает системный вызов, вызывая прерывание. Затем это прерывание передается в таблицу обработчиков прерываний, которая вызывает обработчик системного вызова, который, в свою очередь, вызывает определенный системный вызов. В основном существует два режима вызова SystemCall
 Int 0x8; и
 SYSENTER
 Каждый системный вызов принимает некоторые аргументы, поэтому перед выполнением системного вызова нам нужно, чтобы наши параметры были готовы в регистрах.
 EAX содержит номер системного вызова, а остальные регистры содержат другие аргументы, мы можем получить подробную информацию о конкретном системном вызове, посетив его справочную страницу в Linux с помощью «man (имя системного вызова)».
 Т.е. man write
 Итак, для системного вызова write нам нужно сохранить номер нашего системного вызова в EAX, который равен 4, затем сохранить EBX, дескриптор файла, и нам понадобится ECX, чтобы указать на нашу строку, которую нам нужно напечатать. и, наконец, edx, чтобы содержать длину, которую нам нужно напечатать. После сохранения всего этого мы просто вызываем прерывание с int 0x80.
 То же самое, выход
 Теперь давайте попробуем написать нашу первую программу печати Hello world! в сборке
 global _start
 раздел .text
 _start: 
 mov eax, 0x4 
 mov ebx, 0x1 
 mov ecx, сообщение 
 mov edx, 12 
 int 0x80
  mov eax, 0x1
mov ebx, 0x5
int 0x80
  
 раздел.данные
  сообщение: db "Hello, World!"; определить байт  
 Сначала мы объявили _start как нашу глобальную переменную,
, затем начали текстовый раздел с .text
 для выполнения записи, мы поместили номер системного вызова записи, равный «4», в eax
, затем дескриптор файла «1» в ebx .
 затем из нашего раздела .data, указатель сообщения на ecx.
 нам нужно напечатать 12 байтов, поэтому вставляем 12 в edx
, затем вызываем прерывание, в результате чего печатаем Hello world!
 Теперь мы вставили 1 в eax, который является номером системного вызова для выхода.
Добавить комментарий Отменить ответ
Ваш адрес email не будет опубликован. Обязательные поля помечены *
Комментарий *
Имя * 
Email * 
Сайт