Бинар 5б инструкция: Бинар 5 инструкция по установке – АвтоТоп

Не рекомендуется писать подпись только для наличия метода GetPC. Эти методы также используются многими законными приложениями в случаях, когда важна компактность кода. Хотя это наблюдается не во всех исполняемых файлах, наличия независимого от позиции кода недостаточно, чтобы сделать вывод о том, что двоичный файл является «злым».

Эта техника может быть немного сложной для освоения ванильной логики Yara.Как правило, при рассмотрении такой проблемы проще использовать универсальный дизассемблер / ассемблер для:

• Определить местонахождение JMP
• Проверить инструкцию
• Определить место назначения (если инструкция — ЗВОНОК)
• Убедитесь, что это POP

В Python и при использовании Radare2 базовой реализацией этой проверки будет следующая логика:

import r2pipe
import sys
r2 = r2pipe.open (sys.argv [1])
r2.cmd (‘aa’)
для местоположения в r2.cmdj (‘/ cj pop’):
для pop в r2.cmdj (‘pdj 1 @% s’% location [‘offset’]):
для xref в pop .get (‘xrefs’, []):
if xref [‘type’] == «CALL»:
call_xrefs = r2.cmdj (‘pdj 1 @% s’% xref [‘addr’]) [0]
для cxref в call_xrefs.get (‘xrefs’, []):
если cxref [‘type’] == «CODE»:
jmp_instruction = r2.cmdj (‘pdj 1 @% s’% cxref [‘addr’ ]) [0]
если jmp_instruction [‘type’] == «jmp»:
print («% s ->% s ->% s»% (jmp_instruction [‘opcode’], call_xrefs [‘opcode’], pop [‘opcode’]))

Это наивная реализация, которая будет искать последовательность от JMP до CALL к инструкции POP.Хотя это не самое эффективное решение, оно должно дать некоторое представление о методе достижения этой цели с помощью Python + Radare2.

Взять этот сценарий и преобразовать его в логику Yara — неудобное, но удобное условие.

rule jump_forward_call_back {
meta:
author = «Nick Hoffman / Jeremy Humble»
description = «Логика POP Shellcode для переадресации / обратного вызова JMP»

строк:
/ *
012C1000 | EB 19 | jmp x32dbg. 12C101B
012C1002 | 5E | pop esi
012C1003 | 8B FE | mov edi, esi
012C1005 | 83 C7 4C | добавить edi, 4C
012C1008 | 8B D7 | mov edx, edi
012C100A | 3B F2 | cmp esi, edx
012C100C | 7D 0B | jge x32dbg.12C1019
012C100E | B0 7B | mov al, 7B
012C1010 | F2 AE | repne scasb al, byte ptr es: [edi]
012C1012 | FF CF | dec edi
012C1014 | AC | lodsb al, byte ptr ds: [esi]
012C1015 | 28 07 | суббайт ptr ds: [edi], al
012C1017 | EB F1 | jmp x32dbg.12C100A
012C1019 | EB 51 | jmp x32dbg.12C106C
012C101B | E8 E2 FF FF FF | позвоните x32dbg.12C1002

Условие для этого правила немного сложное, но оно необходимо для поддержания управляемости уровней FP. Он проверяет, что начальное смещение в первом jmp приводит к вызову и что вызов ведет обратно к pop после первого прыжка.

* /
$ jmp_fwd_call_back = {eb ?? (58 | 59 | 5A | 5B | 5C | 5D | 5E | 5F) [10-200] e8 ?? ff ff ff}
условие:
для любого i в (1.. #jmp_fwd_call_back): (((256 — uint8 (@jmp_fwd_call_back [i] +
uint8 (@jmp_fwd_call_back [i] +1) + 3)) — int8 (@jmp_fwd_call_back [i] +1)) == 5) и
uint8 (@jmp_fwd_call_back [i] + uint8 (@jmp_fwd_call_back [i] +1) + 2) == 0xe8)
}

Позвонить $ +? / Поп

Call + Pop — один из самых распространенных механизмов, для которого не очень сложно написать подпись. Однако нам нужно знать регистр, в который мы вставляем значение, так как это единственный код операции, и он будет меняться в зависимости от регистра.

В x86 все возможные перестановки «pop » в конечном итоге обобщаются в следующее регулярное выражение Yara: {(58 | 59 | 5a | 5b | 5c | 5d | 5e | 5f)}. Соединение этого с инструкцией call (в данном случае Call $ + 4) даст правило Yara ниже.

rule getpc_method_call_pop
{
meta:
author = «Nick Hoffman / Jeremy Humble»
description = «Shellcode CALL / POP GetPC methods»

строки:
$ call_4_pop = {e8 ff ff ff ff ?? (58 | 59 | 5a | 5b | 5c | 5d | 5e | 5f)}
$ call_5_pop = {e8 00 00 00 00 (58 | 59 | 5a | 5b | 5c | 5d | 5e | 5f)}

условие:
любой из них
}

— WebAssembly 1.

Инструкции кодируются кодами операций . Каждый код операции представлен одним байтом, и сопровождается непосредственными аргументами инструкции, если они есть. Единственное исключение — это структурированные команды управления, которые состоят из нескольких кодов операций, заключенных в скобки их вложенных последовательностей команд.

Примечание

Пробелы в диапазонах байтового кода для инструкций кодирования зарезервированы для будущих расширений.

Инструкции по управлению

Команды управления имеют разные кодировки.Для структурированных инструкций последовательности инструкций, образующие вложенные блоки, заканчиваются явными кодами операций для \ (\ href {../ syntax / instructions.html # syntax-instr-control} {\ mathsf {end}} \) и \ (\ href {../ syntax / instructions.html # syntax-instr-control} {\ mathsf {else}} \).

Типы блоков кодируются в специальной сжатой форме либо байтом \ (\ def \ mathdef760 # 1 {\ mathtt {0x # 1}} \ mathdef760 {40} \), указывающим пустой тип, как тип с одним значением, либо как индекс типа, закодированный как положительное целое число со знаком.

\ [\ begin {split} \ begin {array} {llcllll} \ def \ mathdef723 # 1 {{}} \ mathdef723 {тип блока} & \ href {../ binary / instructions.html # binary-blocktype} {\ mathtt {blocktype}} & :: = & \ def \ mathdef761 # 1 {\ mathtt {0x # 1}} \ mathdef761 {40} & \ Rightarrow & \ epsilon \\ && | & t {:} \ href {../ binary / types.html # binary-valtype} {\ mathtt {valtype}} & \ Rightarrow & t \\ && | & x {:} \ href {../ binary / values.html # binary-int} {\ def \ mathdef733 # 1 {{\ mathtt {s} # 1}} \ mathdef733 {\ mathtt {33}}} & \ Стрелка вправо & x & (\ mathrel {\ mbox {if}} x \ geq 0) \\ \ def \ mathdef723 # 1 {{}} \ mathdef723 {инструкция} & \ href {../binary/instructions.html#binary-instr}{\mathtt{instr}} & :: = & \ def \ mathdef762 # 1 {\ mathtt {0x # 1}} \ mathdef762 {00} & \ Rightarrow & \ href {../ syntax / instructions. \ ast {:} \ href {.\ ast ~ l_N \\ && | & \ def \ mathdef776 # 1 {\ mathtt {0x # 1}} \ mathdef776 {0F} & \ Rightarrow & \ href {../ syntax / instructions.html # syntax-instr-control} {\ mathsf {return}} \\ && | & \ def \ mathdef777 # 1 {\ mathtt {0x # 1}} \ mathdef777 {10} ~~ x {:} \ href {../ binary / modules.html # binary-funcidx} {\ mathtt {funcidx}} & \ Rightarrow & \ href {../ syntax / instructions.html # syntax-instr-control} {\ mathsf {call}} ~ x \\ && | & \ def \ mathdef778 # 1 {\ mathtt {0x # 1}} \ mathdef778 {11} ~~ y {:} \ href {../ binary / modules.html # binary-typeidx} {\ mathtt {typeidx}} ~~ x {:} \ href {../ binary / modules.html # binary-tableidx} {\ mathtt {tableidx}} & \ Rightarrow & \ href {.. /syntax/instructions.html#syntax-instr-control}{\mathsf{call\_indirect}}~x~y \\ \ end {array} \ end {split} \]

Примечание

Код операции \ (\ href {../ syntax / instructions.html # syntax-instr-control} {\ mathsf {else}} \) \ (\ def \ mathdef779 # 1 {\ mathtt {0x # 1}} \ mathdef779 {05} \) в кодировке \ (\ href {../ syntax / instructions.html # syntax-instr-control} {\ mathsf {if}} \) инструкцию можно опустить, если следующая последовательность инструкций пустой.

В отличие от любого другого случая, индекс типа в типе блока кодируется как положительное целое число со знаком, так что его битовый шаблон со знаком LEB128 не может конфликтовать с кодировкой типов значений или специальным кодом \ (\ def \ mathdef780 # 1 {\ mathtt {0x # 1}} \ mathdef780 {40} \), которые соответствуют кодировке отрицательных целых чисел LEB128. Чтобы избежать потерь в диапазоне допустимых индексов, оно обрабатывается как 33-битовое целое число со знаком.

В будущих версиях WebAssembly нулевой байт, встречающийся в кодировке из \ (\ href {../syntax/instructions.html#syntax-instr-control} {\ mathsf {call \ _indirect}} \) может использоваться для индексации дополнительных таблиц.

Справочные инструкции

Справочные инструкции представлены однобайтовыми кодами.

\ [\ begin {split} \ begin {array} {llclll} \ def \ mathdef723 # 1 {{}} \ mathdef723 {инструкция} & \ href {../ binary / instructions.html # binary-instr} {\ mathtt {instr}} & :: = & \ dots \\ && | & \ def \ mathdef781 # 1 {\ mathtt {0x # 1}} \ mathdef781 {D0} ~~ t {:} \ href {../binary/types.html#binary-reftype}{\mathtt{reftype}} & \ Rightarrow & \ href {../ syntax / instructions.html # syntax-instr-ref} {\ mathsf {ref {.} null} } ~ t \\ && | & \ def \ mathdef782 # 1 {\ mathtt {0x # 1}} \ mathdef782 {D1} & \ Rightarrow & \ href {../ syntax / instructions.html # syntax-instr-ref} {\ mathsf {ref {.} \ _null}} \\ && | & \ def \ mathdef783 # 1 {\ mathtt {0x # 1}} \ mathdef783 {D2} ~~ x {:} \ href {../ binary / modules.html # binary-funcidx} {\ mathtt {funcidx}} & \ Rightarrow & \ href {../ синтаксис / инструкции.html # syntax-instr-ref} {\ mathsf {ref {.} func}} ~ x \\ \ end {array} \ end {split} \]

Примечание

Эти присвоения кода операции являются предварительными.

Параметрические инструкции

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

\ [\ begin {split} \ begin {array} {llclll} \ def \ mathdef723 # 1 {{}} \ mathdef723 {инструкция} & \ href {../ binary / instructions.html # binary-instr} {\ mathtt {instr}} & :: = & \ dots \\ && | & \ def \ mathdef784 # 1 {\ mathtt {0x # 1}} \ mathdef784 {1A} & \ Rightarrow & \ href {.\ ast \\ \ end {array} \ end {split} \]

Переменные инструкции

Команды переменных представлены байтовыми кодами, за которыми следует кодирование соответствующего индекса.

\ [\ begin {split} \ begin {array} {llclll} \ def \ mathdef723 # 1 {{}} \ mathdef723 {инструкция} & \ href {../ binary / instructions.html # binary-instr} {\ mathtt {instr}} & :: = & \ dots \\ && | & \ def \ mathdef787 # 1 {\ mathtt {0x # 1}} \ mathdef787 {20} ~~ x {:} \ href {../ binary / modules.html # binary-localidx} {\ mathtt {localidx}} & \ Rightarrow & \ href {. ./syntax/instructions.html#syntax-instr-variable}{\mathsf{local.get}}~x \\ && | & \ def \ mathdef788 # 1 {\ mathtt {0x # 1}} \ mathdef788 {21} ~~ x {:} \ href {../ binary / modules.html # binary-localidx} {\ mathtt {localidx}} & \ Rightarrow & \ href {../ syntax / instructions.html # syntax-instr-variable} {\ mathsf {local.set}} ~ x \\ && | & \ def \ mathdef789 # 1 {\ mathtt {0x # 1}} \ mathdef789 {22} ~~ x {:} \ href {../ binary / modules.html # binary-localidx} {\ mathtt {localidx}} & \ Rightarrow & \ href {../ синтаксис / инструкции.html # syntax-instr-variable} {\ mathsf {local.tee}} ~ x \\ && | & \ def \ mathdef790 # 1 {\ mathtt {0x # 1}} \ mathdef790 {23} ~~ x {:} \ href {../ binary / modules.html # binary-globalidx} {\ mathtt {globalidx}} & \ Rightarrow & \ href {../ syntax / instructions.html # syntax-instr-variable} {\ mathsf {global.get}} ~ x \\ && | & \ def \ mathdef791 # 1 {\ mathtt {0x # 1}} \ mathdef791 {24} ~~ x {:} \ href {../ binary / modules.html # binary-globalidx} {\ mathtt {globalidx}} & \ Rightarrow & \ href {../ syntax / instructions.html # syntax-instr-variable} {\ mathsf {global.set}} ~ x \\ \ end {array} \ end {split} \]

Таблица инструкций

Табличные инструкции представлены однобайтовыми или двухбайтовыми кодами.

\ [\ begin {split} \ begin {array} {llclll} \ def \ mathdef723 # 1 {{}} \ mathdef723 {инструкция} & \ href {../ binary / instructions.html # binary-instr} {\ mathtt {instr}} & :: = & \ dots \\ && | & \ def \ mathdef792 # 1 {\ mathtt {0x # 1}} \ mathdef792 {25} ~~ x {:} \ href {../ binary / modules.html # binary-tableidx} {\ mathtt {tableidx}} & \ Rightarrow & \ href {../syntax/instructions.html#syntax-instr-table}{\mathsf{table.get}}~x \\ && | & \ def \ mathdef793 # 1 {\ mathtt {0x # 1}} \ mathdef793 {26} ~~ x {:} \ href {../ binary / modules.html # binary-tableidx} {\ mathtt {tableidx}} & \ Rightarrow & \ href {../ syntax / instructions.html # syntax-instr-table} {\ mathsf {table.set}} ~ x \\ && | & \ def \ mathdef794 # 1 {\ mathtt {0x # 1}} \ mathdef794 {FC} ~~ 12 {:} \ href {. ./ binary / values.html # binary-int} {\ def \ mathdef728 # 1 { {\ mathtt {u} # 1}} \ mathdef728 {\ mathtt {32}}} ~~ y {:} \ href {../ binary / modules.html # binary-elemidx} {\ mathtt {elemidx}} ~~ x {:} \ href {../ binary / modules.html # binary-tableidx} {\ mathtt {tableidx}} & \ Rightarrow & \ href {.. /syntax/instructions.html#syntax-instr-table}{\mathsf{table.init}}~x~y \\ && | & \ def \ mathdef795 # 1 {\ mathtt {0x # 1}} \ mathdef795 {FC} ~~ 13 {:} \ href {../ binary / values.html # binary-int} {\ def \ mathdef728 # 1 { {\ mathtt {u} # 1}} \ mathdef728 {\ mathtt {32}}} ~~ x {:} \ href {../ binary / modules.html # binary-elemidx} {\ mathtt {elemidx}} & \ Rightarrow & \ href {../ синтаксис / инструкции.html # syntax-instr-table} {\ mathsf {elem.drop}} ~ x \\ && | & \ def \ mathdef796 # 1 {\ mathtt {0x # 1}} \ mathdef796 {FC} ~~ 14 {:} \ href {../ binary / values.html # binary-int} {\ def \ mathdef728 # 1 { {\ mathtt {u} # 1}} \ mathdef728 {\ mathtt {32}}} ~~ x {:} \ href {../ binary / modules.html # binary-tableidx} {\ mathtt {tableidx}} ~ ~ y {:} \ href {../ binary / modules.html # binary-tableidx} {\ mathtt {tableidx}} & \ Rightarrow & \ href {../ syntax / instructions.html # syntax-instr-table} { \ mathsf {table.copy}} ~ x ~ y \\ && | & \ def \ mathdef797 # 1 {\ mathtt {0x # 1}} \ mathdef797 {FC} ~~ 15 {:} \ href {../binary/values.html#binary-int} {\ def \ mathdef728 # 1 {{\ mathtt {u} # 1}} \ mathdef728 {\ mathtt {32}}} ~~ x {:} \ href {. ./binary/modules.html#binary-tableidx}{\mathtt{tableidx}} & \ Rightarrow & \ href {../ syntax / instructions.html # syntax-instr-table} {\ mathsf {table.grow}} ~ х \\ && | & \ def \ mathdef798 # 1 {\ mathtt {0x # 1}} \ mathdef798 {FC} ~~ 16 {:} \ href {../ binary / values.html # binary-int} {\ def \ mathdef728 # 1 { {\ mathtt {u} # 1}} \ mathdef728 {\ mathtt {32}}} ~~ x {:} \ href {../ binary / modules.html # binary-tableidx} {\ mathtt {tableidx}} & \ Rightarrow & \ href {../syntax/instructions.html#syntax-instr-table}{\mathsf{table. size}}~x \\ && | & \ def \ mathdef799 # 1 {\ mathtt {0x # 1}} \ mathdef799 {FC} ~~ 17 {:} \ href {../ binary / values.html # binary-int} {\ def \ mathdef728 # 1 { {\ mathtt {u} # 1}} \ mathdef728 {\ mathtt {32}}} ~~ x {:} \ href {../ binary / modules.html # binary-tableidx} {\ mathtt {tableidx}} & \ Rightarrow & \ href {../ syntax / instructions.html # syntax-instr-table} {\ mathsf {table.fill}} ~ x \\ \ end {array} \ end {split} \]

Инструкции памяти

Каждый вариант инструкции памяти кодируется различным байтовым кодом.Загрузка и сохранение сопровождаются кодировкой их \ (\ href {../ syntax / instructions.html # syntax-memarg} {\ mathit {memarg}} \) немедленно.

\ [\ begin {split} \ begin {array} {llclll} \ def \ mathdef723 # 1 {{}} \ mathdef723 {аргумент памяти} & \ href {../ binary / instructions.html # binary-memarg} {\ mathtt {memarg}} & :: = & a {:} \ href {../ binary / values.html # binary-int} {\ def \ mathdef728 # 1 {{\ mathtt {u} # 1}} \ mathdef728 {\ mathtt {32}}} ~~ o {:} \ href {../ binary / values.html # binary-int} {\ def \ mathdef728 # 1 {{\ mathtt {u} # 1}} \ mathdef728 {\ mathtt {32}}} & \ Стрелка вправо & \ {\ href {../syntax/instructions.html#syntax-instr-memory}{\mathsf{align}}~a,~\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{offset}} ~ о \} \\ \ def \ mathdef723 # 1 {{}} \ mathdef723 {инструкция} & \ href {../ binary / instructions.html # binary-instr} {\ mathtt {instr}} & :: = & \ dots \\ && | & \ def \ mathdef800 # 1 {\ mathtt {0x # 1}} \ mathdef800 {28} ~~ m {:} \ href {../ binary / instructions.html # binary-memarg} {\ mathtt {memarg}} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}.\ href {../ syntax / instructions.html # syntax-instr-memory} {\ mathsf {load}} ~ m \\ && | & \ def \ mathdef801 # 1 {\ mathtt {0x # 1}} \ mathdef801 {29} ~~ m {:} \ href {../ binary / instructions.html # binary-memarg} {\ mathtt {memarg}} & \ Rightarrow & \ href {../ syntax / types. html # syntax-valtype} {\ mathsf {i64}}. \ Href {../ syntax / instructions.html # syntax-instr-memory} {\ mathsf {load} } ~ m \\ && | & \ def \ mathdef802 # 1 {\ mathtt {0x # 1}} \ mathdef802 {2A} ~~ m {:} \ href {../ binary / instructions.html # binary-memarg} {\ mathtt {memarg}} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{f32}}.\href{../syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}~m \\ && | & \ def \ mathdef803 # 1 {\ mathtt {0x # 1}} \ mathdef803 {2B} ~~ m {:} \ href {../ binary / instructions.html # binary-memarg} {\ mathtt {memarg}} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f64}}. \ Href {../ syntax / instructions.html # syntax-instr-memory} {\ mathsf {load} } ~ m \\ && | & \ def \ mathdef804 # 1 {\ mathtt {0x # 1}} \ mathdef804 {2C} ~~ m {:} \ href {../ двоичный / инструкции.html # binary-memarg} {\ mathtt {memarg}} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}. \ href {../ синтаксис / инструкции. html # syntax-instr-memory} {\ mathsf {load}} \ mathsf {8 \ _s} ~ m \\ && | & \ def \ mathdef805 # 1 {\ mathtt {0x # 1}} \ mathdef805 {2D} ~~ m {:} \ href {../ binary / instructions.html # binary-memarg} {\ mathtt {memarg}} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}. \ Href {../ syntax / instructions.html # syntax-instr-memory} {\ mathsf {load} } \ mathsf {8 \ _u} ~ m \\ && | & \ def \ mathdef806 # 1 {\ mathtt {0x # 1}} \ mathdef806 {2E} ~~ m {:} \ href {../binary/instructions.html#binary-memarg}{\mathtt{memarg}} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}. \ href {. ./syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}\mathsf{16\_s}~m \\ && | & \ def \ mathdef807 # 1 {\ mathtt {0x # 1}} \ mathdef807 {2F} ~~ m {:} \ href {../ binary / instructions.html # binary-memarg} {\ mathtt {memarg}} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}. \ Href {../ syntax / instructions.html # syntax-instr-memory} {\ mathsf {load} } \ mathsf {16 \ _u} ~ m \\ && | & \ def \ mathdef808 # 1 {\ mathtt {0x # 1}} \ mathdef808 {30} ~~ m {:} \ href {../binary/instructions.html#binary-memarg}{\mathtt{memarg}} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ href {. ./syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}\mathsf{8\_s}~m \\ && | & \ def \ mathdef809 # 1 {\ mathtt {0x # 1}} \ mathdef809 {31} ~~ m {:} \ href {../ binary / instructions.html # binary-memarg} {\ mathtt {memarg}} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ Href {../ syntax / instructions.html # syntax-instr-memory} {\ mathsf {load} } \ mathsf {8 \ _u} ~ m \\ && | & \ def \ mathdef810 # 1 {\ mathtt {0x # 1}} \ mathdef810 {32} ~~ m {:} \ href {../binary/instructions.html#binary-memarg}{\mathtt{memarg}} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ href {. ./syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}\mathsf{16\_s}~m \\ && | & \ def \ mathdef811 # 1 {\ mathtt {0x # 1}} \ mathdef811 {33} ~~ m {:} \ href {../ binary / instructions.html # binary-memarg} {\ mathtt {memarg}} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ Href {../ syntax / instructions.html # syntax-instr-memory} {\ mathsf {load} } \ mathsf {16 \ _u} ~ m \\ && | & \ def \ mathdef812 # 1 {\ mathtt {0x # 1}} \ mathdef812 {34} ~~ m {:} \ href {../binary/instructions.html#binary-memarg}{\mathtt{memarg}} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ href {. ./syntax/instructions.html#syntax-instr-memory}{\mathsf{load}}\mathsf{32\_s}~m \\ && | & \ def \ mathdef813 # 1 {\ mathtt {0x # 1}} \ mathdef813 {35} ~~ m {:} \ href {../ binary / instructions.html # binary-memarg} {\ mathtt {memarg}} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ Href {../ syntax / instructions.html # syntax-instr-memory} {\ mathsf {load} } \ mathsf {32 \ _u} ~ m \\ && | & \ def \ mathdef814 # 1 {\ mathtt {0x # 1}} \ mathdef814 {36} ~~ m {:} \ href {../binary/instructions.html#binary-memarg}{\mathtt{memarg}} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}. \ href {. ./syntax/instructions.html#syntax-instr-memory}{\mathsf{store}}~m \\ && | & \ def \ mathdef815 # 1 {\ mathtt {0x # 1}} \ mathdef815 {37} ~~ m {:} \ href {../ binary / instructions.html # binary-memarg} {\ mathtt {memarg}} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ Href {../ syntax / instructions.html # syntax-instr-memory} {\ mathsf {store} } ~ m \\ && | & \ def \ mathdef816 # 1 {\ mathtt {0x # 1}} \ mathdef816 {38} ~~ m {:} \ href {../binary/instructions.html#binary-memarg}{\mathtt{memarg}} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f32}}. \ href {. ./syntax/instructions.html#syntax-instr-memory}{\mathsf{store}}~m \\ && | & \ def \ mathdef817 # 1 {\ mathtt {0x # 1}} \ mathdef817 {39} ~~ m {:} \ href {../ binary / instructions.html # binary-memarg} {\ mathtt {memarg}} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f64}}. \ Href {../ syntax / instructions.html # syntax-instr-memory} {\ mathsf {store} } ~ m \\ && | & \ def \ mathdef818 # 1 {\ mathtt {0x # 1}} \ mathdef818 {3A} ~~ m {:} \ href {../binary/instructions.html#binary-memarg}{\mathtt{memarg}} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}. \ href {. ./syntax/instructions.html#syntax-instr-memory}{\mathsf{store}}\mathsf{8}~m \\ && | & \ def \ mathdef819 # 1 {\ mathtt {0x # 1}} \ mathdef819 {3B} ~~ m {:} \ href {../ binary / instructions.html # binary-memarg} {\ mathtt {memarg}} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}. \ Href {../ syntax / instructions.html # syntax-instr-memory} {\ mathsf {store} } \ mathsf {16} ~ m \\ && | & \ def \ mathdef820 # 1 {\ mathtt {0x # 1}} \ mathdef820 {3C} ~~ m {:} \ href {../binary/instructions.html#binary-memarg}{\mathtt{memarg}} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ href {. ./syntax/instructions.html#syntax-instr-memory}{\mathsf{store}}\mathsf{8}~m \\ && | & \ def \ mathdef821 # 1 {\ mathtt {0x # 1}} \ mathdef821 {3D} ~~ m {:} \ href {../ binary / instructions.html # binary-memarg} {\ mathtt {memarg}} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ Href {../ syntax / instructions.html # syntax-instr-memory} {\ mathsf {store} } \ mathsf {16} ~ m \\ && | & \ def \ mathdef822 # 1 {\ mathtt {0x # 1}} \ mathdef822 {3E} ~~ m {:} \ href {../binary/instructions.html#binary-memarg}{\mathtt{memarg}} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ href {. ./syntax/instructions.html#syntax-instr-memory}{\mathsf{store}}\mathsf{32}~m \\ && | & \ def \ mathdef823 # 1 {\ mathtt {0x # 1}} \ mathdef823 {3F} ~~ \ def \ mathdef824 # 1 {\ mathtt {0x # 1}} \ mathdef824 {00} & \ Rightarrow & \ href {.. /syntax/instructions.html#syntax-instr-memory}{\mathsf{memory.size}} \\ && | & \ def \ mathdef825 # 1 {\ mathtt {0x # 1}} \ mathdef825 {40} ~~ \ def \ mathdef826 # 1 {\ mathtt {0x # 1}} \ mathdef826 {00} & \ Rightarrow & \ href {../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory.grow}} \\ && | & \ def \ mathdef827 # 1 {\ mathtt {0x # 1}} \ mathdef827 {FC} ~~ 8 {:} \ href {../ binary / values.html # binary-int} {\ def \ mathdef728 # 1 { {\ mathtt {u} # 1}} \ mathdef728 {\ mathtt {32}}} ~~ x {:} \ href {../ binary / modules.html # binary-dataidx} {\ mathtt {dataidx}} ~ \ def \ mathdef828 # 1 {\ mathtt {0x # 1}} \ mathdef828 {00} & \ Rightarrow & \ href {../ syntax / instructions.html # syntax-instr-memory} {\ mathsf {memory.init}} ~ х \\ && | & \ def \ mathdef829 # 1 {\ mathtt {0x # 1}} \ mathdef829 {FC} ~~ 9 {:} \ href {../binary/values.html#binary-int} {\ def \ mathdef728 # 1 {{\ mathtt {u} # 1}} \ mathdef728 {\ mathtt {32}}} ~~ x {:} \ href {. ./binary/modules.html#binary-dataidx}{\mathtt{dataidx}} & \ Rightarrow & \ href {../ syntax / instructions.html # syntax-instr-memory} {\ mathsf {data.drop}} ~ х \\ && | & \ def \ mathdef830 # 1 {\ mathtt {0x # 1}} \ mathdef830 {FC} ~~ 10 {:} \ href {../ binary / values.html # binary-int} {\ def \ mathdef728 # 1 { {\ mathtt {u} # 1}} \ mathdef728 {\ mathtt {32}}} ~~ \ def \ mathdef831 # 1 {\ mathtt {0x # 1}} \ mathdef831 {00} ~~ \ def \ mathdef832 # 1 {\ mathtt {0x # 1}} \ mathdef832 {00} & \ Rightarrow & \ href {../syntax/instructions.html#syntax-instr-memory}{\mathsf{memory.copy}} \\ && | & \ def \ mathdef833 # 1 {\ mathtt {0x # 1}} \ mathdef833 {FC} ~~ 11 {:} \ href {../ binary / values.html # binary-int} {\ def \ mathdef728 # 1 { {\ mathtt {u} # 1}} \ mathdef728 {\ mathtt {32}}} ~~ \ def \ mathdef834 # 1 {\ mathtt {0x # 1}} \ mathdef834 {00} & \ Rightarrow & \ href {.. /syntax/instructions.html#syntax-instr-memory}{\mathsf{memory.fill}} \\ \ end {array} \ end {split} \]

Примечание

В будущих версиях WebAssembly дополнительные нулевые байты, встречающиеся в кодировке \ (\ href {../syntax/instructions.html#syntax-instr-memory} {\ mathsf {memory.size}} \), \ (\ href {../ syntax / instructions.html # syntax-instr-memory} {\ mathsf { memory.grow}} \), \ (\ href {../ syntax / instructions.html # syntax-instr-memory} {\ mathsf {memory.copy}} \) и \ (\ href {../ синтаксис /instructions.html#syntax-instr-memory} {\ mathsf {memory.fill}} \) могут использоваться для индексации дополнительных воспоминаний.

Цифровые инструкции

Все варианты числовых инструкций представлены отдельными байтовыми кодами.

За инструкциями \ (\ href {../ syntax / instructions.html # syntax-instr-numeric} {\ mathsf {const}} \) следует соответствующий литерал.

\ [\ begin {split} \ begin {array} {llclll} \ def \ mathdef723 # 1 {{}} \ mathdef723 {инструкция} & \ href {../ binary / instructions.html # binary-instr} {\ mathtt {instr}} & :: = & \ dots \\ && | & \ def \ mathdef835 # 1 {\ mathtt {0x # 1}} \ mathdef835 {41} ~~ n {:} \ href {../ binary / values.html # binary-int} {\ def \ mathdef736 # 1 { {\ mathtt {i} # 1}} \ mathdef736 {\ mathtt {32}}} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n \\ && | & \ def \ mathdef836 # 1 {\ mathtt {0x # 1}} \ mathdef836 {42} ~~ n {:} \ href {../ binary / values.html # binary-int} {\ def \ mathdef737 # 1 { {\ mathtt {i} # 1}} \ mathdef737 {\ mathtt {64}}} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~n \\ && | & \ def \ mathdef837 # 1 {\ mathtt {0x # 1}} \ mathdef837 {43} ~~ z {:} \ href {../binary/values.html#binary-float}{\def\mathdef739#1{{\mathtt{f}#1}}\mathdef739{\mathtt{32}}} & \ Rightarrow & \ href {../ синтаксис /types.html#syntax-valtype}{\mathsf{f32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{const}}~z \\ && | & \ def \ mathdef838 # 1 {\ mathtt {0x # 1}} \ mathdef838 {44} ~~ z {:} \ href {../ binary / values.html # binary-float} {\ def \ mathdef740 # 1 { {\ mathtt {f} # 1}} \ mathdef740 {\ mathtt {64}}} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f64}}.\ href {../ syntax / instructions.html # syntax-instr-numeric} {\ mathsf {const}} ~ z \\ \ end {array} \ end {split} \]

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

\ [\ begin {split} \ begin {array} {llclll} \ def \ mathdef723 # 1 {{}} \ mathdef723 {инструкция} & \ href {../ binary / instructions.html # binary-instr} {\ mathtt {instr}} & :: = & \ dots && \ phantom { этого должно быть достаточно} \\ && | & \ def \ mathdef839 # 1 {\ mathtt {0x # 1}} \ mathdef839 {45} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{eqz}} \\ && | & \ def \ mathdef840 # 1 {\ mathtt {0x # 1}} \ mathdef840 {46} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{eq}} \\ && | & \ def \ mathdef841 # 1 {\ mathtt {0x # 1}} \ mathdef841 {47} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}. \ href { ../syntax/instructions.html # syntax-instr-numeric} {\ mathsf {ne}} \\ && | & \ def \ mathdef842 # 1 {\ mathtt {0x # 1}} \ mathdef842 {48} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{lt}}\mathsf{\_s} \\ && | & \ def \ mathdef843 # 1 {\ mathtt {0x # 1}} \ mathdef843 {49} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{lt}}\mathsf{\_u} \\ && | & \ def \ mathdef844 # 1 {\ mathtt {0x # 1}} \ mathdef844 {4A} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{gt}}\mathsf{\_s } \\ && | & \ def \ mathdef845 # 1 {\ mathtt {0x # 1}} \ mathdef845 {4B} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{gt}}\mathsf{\_u} \\ && | & \ def \ mathdef846 # 1 {\ mathtt {0x # 1}} \ mathdef846 {4C} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}.\ href {../ syntax / instructions.html # syntax-instr-numeric} {\ mathsf {le}} \ mathsf {\ _ s} \\ && | & \ def \ mathdef847 # 1 {\ mathtt {0x # 1}} \ mathdef847 {4D} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{le}}\mathsf{\_u} \\ && | & \ def \ mathdef848 # 1 {\ mathtt {0x # 1}} \ mathdef848 {4E} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{ge}}\mathsf{\_s} \\ && | & \ def \ mathdef849 # 1 {\ mathtt {0x # 1}} \ mathdef849 {4F} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{ge}}\mathsf{\_u } \\ \ end {array} \ end {split} \]

\ [\ begin {split} \ begin {array} {llclll} \ phantom {\ def \ mathdef723 # 1 {{}} \ mathdef723 {инструкция}} & \ phantom {\ href {../ binary / instructions.html # binary-instr} {\ mathtt {instr}}} & \ phantom {:: =} & \ phantom {\ dots} && \ phantom {этого должно быть достаточно} \\ [- 2ex] && | & \ def \ mathdef850 # 1 {\ mathtt {0x # 1}} \ mathdef850 {50} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{i64}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{eqz}} \\ && | & \ def \ mathdef851 # 1 {\ mathtt {0x # 1}} \ mathdef851 {51} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{eq}} \\ && | & \ def \ mathdef852 # 1 {\ mathtt {0x # 1}} \ mathdef852 {52} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ href { ../syntax/instructions.html # syntax-instr-numeric} {\ mathsf {ne}} \\ && | & \ def \ mathdef853 # 1 {\ mathtt {0x # 1}} \ mathdef853 {53} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{lt}}\mathsf{\_s} \\ && | & \ def \ mathdef854 # 1 {\ mathtt {0x # 1}} \ mathdef854 {54} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{lt}}\mathsf{\_u} \\ && | & \ def \ mathdef855 # 1 {\ mathtt {0x # 1}} \ mathdef855 {55} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{i64}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{gt}}\mathsf{\_s } \\ && | & \ def \ mathdef856 # 1 {\ mathtt {0x # 1}} \ mathdef856 {56} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{gt}}\mathsf{\_u} \\ && | & \ def \ mathdef857 # 1 {\ mathtt {0x # 1}} \ mathdef857 {57} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}.\ href {../ syntax / instructions.html # syntax-instr-numeric} {\ mathsf {le}} \ mathsf {\ _ s} \\ && | & \ def \ mathdef858 # 1 {\ mathtt {0x # 1}} \ mathdef858 {58} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{le}}\mathsf{\_u} \\ && | & \ def \ mathdef859 # 1 {\ mathtt {0x # 1}} \ mathdef859 {59} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{ge}}\mathsf{\_s} \\ && | & \ def \ mathdef860 # 1 {\ mathtt {0x # 1}} \ mathdef860 {5A} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{i64}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{ge}}\mathsf{\_u } \\ \ end {array} \ end {split} \]

\ [\ begin {split} \ begin {array} {llclll} \ phantom {\ def \ mathdef723 # 1 {{}} \ mathdef723 {инструкция}} & \ phantom {\ href {../ binary / instructions.html # binary-instr} {\ mathtt {instr}}} & \ phantom {:: =} & \ phantom {\ dots} && \ phantom {этого должно быть достаточно} \\ [- 2ex] && | & \ def \ mathdef861 # 1 {\ mathtt {0x # 1}} \ mathdef861 {5B} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{f32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{eq}} \\ && | & \ def \ mathdef862 # 1 {\ mathtt {0x # 1}} \ mathdef862 {5C} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{ne}} \\ && | & \ def \ mathdef863 # 1 {\ mathtt {0x # 1}} \ mathdef863 {5D} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f32}}. \ href { ../syntax/instructions.html # syntax-instr-numeric} {\ mathsf {lt}} \\ && | & \ def \ mathdef864 # 1 {\ mathtt {0x # 1}} \ mathdef864 {5E} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{gt}} \\ && | & \ def \ mathdef865 # 1 {\ mathtt {0x # 1}} \ mathdef865 {5F} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{le}} \\ && | & \ def \ mathdef866 # 1 {\ mathtt {0x # 1}} \ mathdef866 {60} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{f32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{ge}} \\ \ end {array} \ end {split} \]

\ [\ begin {split} \ begin {array} {llclll} \ phantom {\ def \ mathdef723 # 1 {{}} \ mathdef723 {инструкция}} & \ phantom {\ href {../ binary / instructions.html # binary-instr} {\ mathtt {instr}}} & \ phantom {:: =} & \ phantom {\ dots} && \ phantom {этого должно быть достаточно} \\ [- 2ex] && | & \ def \ mathdef867 # 1 {\ mathtt {0x # 1}} \ mathdef867 {61} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{f64}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{eq}} \\ && | & \ def \ mathdef868 # 1 {\ mathtt {0x # 1}} \ mathdef868 {62} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{ne}} \\ && | & \ def \ mathdef869 # 1 {\ mathtt {0x # 1}} \ mathdef869 {63} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f64}}. \ href { ../syntax/instructions.html # syntax-instr-numeric} {\ mathsf {lt}} \\ && | & \ def \ mathdef870 # 1 {\ mathtt {0x # 1}} \ mathdef870 {64} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{gt}} \\ && | & \ def \ mathdef871 # 1 {\ mathtt {0x # 1}} \ mathdef871 {65} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{le}} \\ && | & \ def \ mathdef872 # 1 {\ mathtt {0x # 1}} \ mathdef872 {66} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{f64}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{ge}} \\ \ end {array} \ end {split} \]

\ [\ begin {split} \ begin {array} {llclll} \ phantom {\ def \ mathdef723 # 1 {{}} \ mathdef723 {инструкция}} & \ phantom {\ href {../ binary / instructions.html # binary-instr} {\ mathtt {instr}}} & \ phantom {:: =} & \ phantom {\ dots} && \ phantom {этого должно быть достаточно} \\ [- 2ex] && | & \ def \ mathdef873 # 1 {\ mathtt {0x # 1}} \ mathdef873 {67} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{clz}} \\ && | & \ def \ mathdef874 # 1 {\ mathtt {0x # 1}} \ mathdef874 {68} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{ctz}} \\ && | & \ def \ mathdef875 # 1 {\ mathtt {0x # 1}} \ mathdef875 {69} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}. \ href { ../syntax/instructions.html # syntax-instr-numeric} {\ mathsf {popcnt}} \\ && | & \ def \ mathdef876 # 1 {\ mathtt {0x # 1}} \ mathdef876 {6A} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{add}} \\ && | & \ def \ mathdef877 # 1 {\ mathtt {0x # 1}} \ mathdef877 {6B} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{sub}} \\ && | & \ def \ mathdef878 # 1 {\ mathtt {0x # 1}} \ mathdef878 {6C} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{mul}} \\ && | & \ def \ mathdef879 # 1 {\ mathtt {0x # 1}} \ mathdef879 {6D} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{div}}\mathsf{\_s} \\ && | & \ def \ mathdef880 # 1 {\ mathtt {0x # 1}} \ mathdef880 {6E} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{div}}\mathsf{\_u} \\ && | & \ def \ mathdef881 # 1 {\ mathtt {0x # 1}} \ mathdef881 {6F} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{rem}}\mathsf{\_s} \\ && | & \ def \ mathdef882 # 1 {\ mathtt {0x # 1}} \ mathdef882 {70} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{rem}}\mathsf{\_u} \\ && | & \ def \ mathdef883 # 1 {\ mathtt {0x # 1}} \ mathdef883 {71} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{and}} \\ && | & \ def \ mathdef884 # 1 {\ mathtt {0x # 1}} \ mathdef884 {72} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{or}} \\ && | & \ def \ mathdef885 # 1 {\ mathtt {0x # 1}} \ mathdef885 {73} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}. \ href { ../syntax/instructions.html # syntax-instr-numeric} {\ mathsf {xor}} \\ && | & \ def \ mathdef886 # 1 {\ mathtt {0x # 1}} \ mathdef886 {74} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{shl}} \\ && | & \ def \ mathdef887 # 1 {\ mathtt {0x # 1}} \ mathdef887 {75} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{shr}}\mathsf{\_s} \\ && | & \ def \ mathdef888 # 1 {\ mathtt {0x # 1}} \ mathdef888 {76} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{shr}}\mathsf{\_u } \\ && | & \ def \ mathdef889 # 1 {\ mathtt {0x # 1}} \ mathdef889 {77} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{rotl}} \\ && | & \ def \ mathdef890 # 1 {\ mathtt {0x # 1}} \ mathdef890 {78} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}.\ href {../ syntax / instructions.html # syntax-instr-numeric} {\ mathsf {rotr}} \\ \ end {array} \ end {split} \]

\ [\ begin {split} \ begin {array} {llclll} \ phantom {\ def \ mathdef723 # 1 {{}} \ mathdef723 {инструкция}} & \ phantom {\ href {../ binary / instructions.html # binary-instr} {\ mathtt {instr}}} & \ phantom {:: =} & \ phantom {\ dots} && \ phantom {этого должно быть достаточно} \\ [- 2ex] && | & \ def \ mathdef891 # 1 {\ mathtt {0x # 1}} \ mathdef891 {79} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}.\ href {../ syntax / instructions.html # syntax-instr-numeric} {\ mathsf {clz}} \\ && | & \ def \ mathdef892 # 1 {\ mathtt {0x # 1}} \ mathdef892 {7A} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{ctz}} \\ && | & \ def \ mathdef893 # 1 {\ mathtt {0x # 1}} \ mathdef893 {7B} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{popcnt}} \\ && | & \ def \ mathdef894 # 1 {\ mathtt {0x # 1}} \ mathdef894 {7C} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{i64}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{add}} \\ && | & \ def \ mathdef895 # 1 {\ mathtt {0x # 1}} \ mathdef895 {7D} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{sub}} \\ && | & \ def \ mathdef896 # 1 {\ mathtt {0x # 1}} \ mathdef896 {7E} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ href { ../syntax/instructions.html # syntax-instr-numeric} {\ mathsf {mul}} \\ && | & \ def \ mathdef897 # 1 {\ mathtt {0x # 1}} \ mathdef897 {7F} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{div}}\mathsf{\_s} \\ && | & \ def \ mathdef898 # 1 {\ mathtt {0x # 1}} \ mathdef898 {80} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{div}}\mathsf{\_u} \\ && | & \ def \ mathdef899 # 1 {\ mathtt {0x # 1}} \ mathdef899 {81} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{i64}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{rem}}\mathsf{\_s } \\ && | & \ def \ mathdef900 # 1 {\ mathtt {0x # 1}} \ mathdef900 {82} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{rem}}\mathsf{\_u} \\ && | & \ def \ mathdef901 # 1 {\ mathtt {0x # 1}} \ mathdef901 {83} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}.\ href {../ syntax / instructions.html # syntax-instr-numeric} {\ mathsf {and}} \\ && | & \ def \ mathdef902 # 1 {\ mathtt {0x # 1}} \ mathdef902 {84} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{or}} \\ && | & \ def \ mathdef903 # 1 {\ mathtt {0x # 1}} \ mathdef903 {85} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{xor}} \\ && | & \ def \ mathdef904 # 1 {\ mathtt {0x # 1}} \ mathdef904 {86} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{i64}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{shl}} \\ && | & \ def \ mathdef905 # 1 {\ mathtt {0x # 1}} \ mathdef905 {87} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{shr}}\mathsf{\_s} \\ && | & \ def \ mathdef906 # 1 {\ mathtt {0x # 1}} \ mathdef906 {88} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{shr}}\mathsf{\_u} \\ && | & \ def \ mathdef907 # 1 {\ mathtt {0x # 1}} \ mathdef907 {89} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{rotl}} \\ && | & \ def \ mathdef908 # 1 {\ mathtt {0x # 1}} \ mathdef908 {8A} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{rotr}} \\ \ end {array} \ end {split} \]

\ [\ begin {split} \ begin {array} {llclll} \ phantom {\ def \ mathdef723 # 1 {{}} \ mathdef723 {инструкция}} & \ phantom {\ href {../binary/instructions.html#binary-instr}{\mathtt{instr}}} & \ phantom {:: =} & \ phantom {\ dots} && \ phantom {thisshouldbeenough} \\ [- 2ex] && | & \ def \ mathdef909 # 1 {\ mathtt {0x # 1}} \ mathdef909 {8B} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{abs}} \\ && | & \ def \ mathdef910 # 1 {\ mathtt {0x # 1}} \ mathdef910 {8C} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f32}}.\ href {../ syntax / instructions.html # syntax-instr-numeric} {\ mathsf {neg}} \\ && | & \ def \ mathdef911 # 1 {\ mathtt {0x # 1}} \ mathdef911 {8D} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{ceil}} \\ && | & \ def \ mathdef912 # 1 {\ mathtt {0x # 1}} \ mathdef912 {8E} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{floor}} \\ && | & \ def \ mathdef913 # 1 {\ mathtt {0x # 1}} \ mathdef913 {8F} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{f32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{trunc}} \\ && | & \ def \ mathdef914 # 1 {\ mathtt {0x # 1}} \ mathdef914 {90} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{nearest}} \\ && | & \ def \ mathdef915 # 1 {\ mathtt {0x # 1}} \ mathdef915 {91} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{sqrt}} \\ && | & \ def \ mathdef916 # 1 {\ mathtt {0x # 1}} \ mathdef916 {92} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{add}} \\ && | & \ def \ mathdef917 # 1 {\ mathtt {0x # 1}} \ mathdef917 {93} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{sub}} \\ && | & \ def \ mathdef918 # 1 {\ mathtt {0x # 1}} \ mathdef918 {94} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{f32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{mul}} \\ && | & \ def \ mathdef919 # 1 {\ mathtt {0x # 1}} \ mathdef919 {95} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{div}} \\ && | & \ def \ mathdef920 # 1 {\ mathtt {0x # 1}} \ mathdef920 {96} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f32}}. \ href { ../syntax/instructions.html # syntax-instr-numeric} {\ mathsf {min}} \\ && | & \ def \ mathdef921 # 1 {\ mathtt {0x # 1}} \ mathdef921 {97} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{max}} \\ && | & \ def \ mathdef922 # 1 {\ mathtt {0x # 1}} \ mathdef922 {98} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{copysign}} \\ \ end {array} \ end {split} \]

\ [\ begin {split} \ begin {array} {llclll} \ phantom {\ def \ mathdef723 # 1 {{}} \ mathdef723 {инструкция}} & \ phantom {\ href {../binary/instructions.html#binary-instr}{\mathtt{instr}}} & \ phantom {:: =} & \ phantom {\ dots} && \ phantom {thisshouldbeenough} \\ [- 2ex] && | & \ def \ mathdef923 # 1 {\ mathtt {0x # 1}} \ mathdef923 {99} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{abs}} \\ && | & \ def \ mathdef924 # 1 {\ mathtt {0x # 1}} \ mathdef924 {9A} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f64}}.\ href {../ syntax / instructions.html # syntax-instr-numeric} {\ mathsf {neg}} \\ && | & \ def \ mathdef925 # 1 {\ mathtt {0x # 1}} \ mathdef925 {9B} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{ceil}} \\ && | & \ def \ mathdef926 # 1 {\ mathtt {0x # 1}} \ mathdef926 {9C} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{floor}} \\ && | & \ def \ mathdef927 # 1 {\ mathtt {0x # 1}} \ mathdef927 {9D} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{f64}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{trunc}} \\ && | & \ def \ mathdef928 # 1 {\ mathtt {0x # 1}} \ mathdef928 {9E} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{nearest}} \\ && | & \ def \ mathdef929 # 1 {\ mathtt {0x # 1}} \ mathdef929 {9F} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{sqrt}} \\ && | & \ def \ mathdef930 # 1 {\ mathtt {0x # 1}} \ mathdef930 {A0} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{add}} \\ && | & \ def \ mathdef931 # 1 {\ mathtt {0x # 1}} \ mathdef931 {A1} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{sub}} \\ && | & \ def \ mathdef932 # 1 {\ mathtt {0x # 1}} \ mathdef932 {A2} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{f64}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{mul}} \\ && | & \ def \ mathdef933 # 1 {\ mathtt {0x # 1}} \ mathdef933 {A3} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{div}} \\ && | & \ def \ mathdef934 # 1 {\ mathtt {0x # 1}} \ mathdef934 {A4} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f64}}. \ href { ../syntax/instructions.html # syntax-instr-numeric} {\ mathsf {min}} \\ && | & \ def \ mathdef935 # 1 {\ mathtt {0x # 1}} \ mathdef935 {A5} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{max}} \\ && | & \ def \ mathdef936 # 1 {\ mathtt {0x # 1}} \ mathdef936 {A6} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{copysign}} \\ \ end {array} \ end {split} \]

\ [\ begin {split} \ begin {array} {llclll} \ phantom {\ def \ mathdef723 # 1 {{}} \ mathdef723 {инструкция}} & \ phantom {\ href {../binary/instructions.html#binary-instr}{\mathtt{instr}}} & \ phantom {:: =} & \ phantom {\ dots} && \ phantom {thisshouldbeenough} \\ [- 2ex] && | & \ def \ mathdef937 # 1 {\ mathtt {0x # 1}} \ mathdef937 {A7} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{wrap}}\mathsf{\_}\href{../syntax/types.html#syntax-valtype}{\mathsf{i64} } \\ && | & \ def \ mathdef938 # 1 {\ mathtt {0x # 1}} \ mathdef938 {A8} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{trunc}}\mathsf{\_ } \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f32}} \ mathsf {\ _ s} \\ && | & \ def \ mathdef939 # 1 {\ mathtt {0x # 1}} \ mathdef939 {A9} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{trunc}}\mathsf{\_}\href{../syntax/types.html#syntax-valtype}{\mathsf{f32} } \ mathsf {\ _ u} \\ && | & \ def \ mathdef940 # 1 {\ mathtt {0x # 1}} \ mathdef940 {AA} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{trunc}}\mathsf{\_ } \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f64}} \ mathsf {\ _ s} \\ && | & \ def \ mathdef941 # 1 {\ mathtt {0x # 1}} \ mathdef941 {AB} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{trunc}}\mathsf{\_}\href{../syntax/types.html#syntax-valtype}{\mathsf{f64} } \ mathsf {\ _ u} \\ && | & \ def \ mathdef942 # 1 {\ mathtt {0x # 1}} \ mathdef942 {AC} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{i64}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{extend}}\mathsf{\_ } \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}} \ mathsf {\ _ s} \\ && | & \ def \ mathdef943 # 1 {\ mathtt {0x # 1}} \ mathdef943 {AD} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{extend}}\mathsf{\_}\href{../syntax/types.html#syntax-valtype}{\mathsf{i32} } \ mathsf {\ _ u} \\ && | & \ def \ mathdef944 # 1 {\ mathtt {0x # 1}} \ mathdef944 {AE} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{i64}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{trunc}}\mathsf{\_ } \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f32}} \ mathsf {\ _ s} \\ && | & \ def \ mathdef945 # 1 {\ mathtt {0x # 1}} \ mathdef945 {AF} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{trunc}}\mathsf{\_}\href{../syntax/types.html#syntax-valtype}{\mathsf{f32} } \ mathsf {\ _ u} \\ && | & \ def \ mathdef946 # 1 {\ mathtt {0x # 1}} \ mathdef946 {B0} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{i64}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{trunc}}\mathsf{\_ } \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f64}} \ mathsf {\ _ s} \\ && | & \ def \ mathdef947 # 1 {\ mathtt {0x # 1}} \ mathdef947 {B1} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{trunc}}\mathsf{\_}\href{../syntax/types.html#syntax-valtype}{\mathsf{f64} } \ mathsf {\ _ u} \\ && | & \ def \ mathdef948 # 1 {\ mathtt {0x # 1}} \ mathdef948 {B2} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{f32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{convert}}\mathsf{\_ } \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}} \ mathsf {\ _ s} \\ && | & \ def \ mathdef949 # 1 {\ mathtt {0x # 1}} \ mathdef949 {B3} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{convert}}\mathsf{\_}\href{../syntax/types.html#syntax-valtype}{\mathsf{i32} } \ mathsf {\ _ u} \\ && | & \ def \ mathdef950 # 1 {\ mathtt {0x # 1}} \ mathdef950 {B4} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{f32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{convert}}\mathsf{\_ } \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}} \ mathsf {\ _ s} \\ && | & \ def \ mathdef951 # 1 {\ mathtt {0x # 1}} \ mathdef951 {B5} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{convert}}\mathsf{\_}\href{../syntax/types.html#syntax-valtype}{\mathsf{i64} } \ mathsf {\ _ u} \\ && | & \ def \ mathdef952 # 1 {\ mathtt {0x # 1}} \ mathdef952 {B6} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{f32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{demote}}\mathsf{\_ } \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f64}} \\ && | & \ def \ mathdef953 # 1 {\ mathtt {0x # 1}} \ mathdef953 {B7} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{convert}}\mathsf{\_}\href{../syntax/types.html#syntax-valtype}{\mathsf{i32} } \ mathsf {\ _ s} \\ && | & \ def \ mathdef954 # 1 {\ mathtt {0x # 1}} \ mathdef954 {B8} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{f64}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{convert}}\mathsf{\_ } \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}} \ mathsf {\ _ u} \\ && | & \ def \ mathdef955 # 1 {\ mathtt {0x # 1}} \ mathdef955 {B9} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{convert}}\mathsf{\_}\href{../syntax/types.html#syntax-valtype}{\mathsf{i64} } \ mathsf {\ _ s} \\ && | & \ def \ mathdef956 # 1 {\ mathtt {0x # 1}} \ mathdef956 {BA} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{f64}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{convert}}\mathsf{\_ } \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}} \ mathsf {\ _ u} \\ && | & \ def \ mathdef957 # 1 {\ mathtt {0x # 1}} \ mathdef957 {BB} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{promote}}\mathsf{\_}\href{../syntax/types.html#syntax-valtype}{\mathsf{f32} } \\ && | & \ def \ mathdef958 # 1 {\ mathtt {0x # 1}} \ mathdef958 {BC} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{reinterpret}}\mathsf{\_ } \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f32}} \\ && | & \ def \ mathdef959 # 1 {\ mathtt {0x # 1}} \ mathdef959 {BD} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{reinterpret}}\mathsf{\_}\href{../syntax/types.html#syntax-valtype}{\mathsf{f64} } \\ && | & \ def \ mathdef960 # 1 {\ mathtt {0x # 1}} \ mathdef960 {BE} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{f32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{reinterpret}}\mathsf{\_ } \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}} \\ && | & \ def \ mathdef961 # 1 {\ mathtt {0x # 1}} \ mathdef961 {BF} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{reinterpret}}\mathsf{\_}\href{../syntax/types.html#syntax-valtype}{\mathsf{i64} } \\ \ end {array} \ end {split} \]

\ [\ begin {split} \ begin {array} {llclll} \ phantom {\ def \ mathdef723 # 1 {{}} \ mathdef723 {инструкция}} & \ phantom {\ href {../binary/instructions.html#binary-instr}{\mathtt{instr}}} & \ phantom {:: =} & \ phantom {\ dots} && \ phantom {thisshouldbeenough} \\ [- 2ex] && | & \ def \ mathdef962 # 1 {\ mathtt {0x # 1}} \ mathdef962 {C0} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{extend}}\mathsf{8\_s} \\ && | & \ def \ mathdef963 # 1 {\ mathtt {0x # 1}} \ mathdef963 {C1} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}.\ href {../ syntax / instructions.html # syntax-instr-numeric} {\ mathsf {extend}} \ mathsf {16 \ _s} \\ && | & \ def \ mathdef964 # 1 {\ mathtt {0x # 1}} \ mathdef964 {C2} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{extend}}\mathsf{8\_s} \\ && | & \ def \ mathdef965 # 1 {\ mathtt {0x # 1}} \ mathdef965 {C3} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ href { ../syntax/instructions.html#syntax-instr-numeric}{\mathsf{extend}}\mathsf{16\_s} \\ && | & \ def \ mathdef966 # 1 {\ mathtt {0x # 1}} \ mathdef966 {C4} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype} {\ mathsf {i64}}. \ href {../ syntax / instructions.html # syntax-instr-numeric} {\ mathsf {extend}} \ mathsf {32 \ _s} \\ \ end {array} \ end {split} \]

Все инструкции усечения с насыщением имеют однобайтовый префикс, тогда как фактический код операции кодируется беззнаковым целым числом переменной длины.

\ [\ begin {split} \ begin {array} {llclll} \ def \ mathdef723 # 1 {{}} \ mathdef723 {инструкция} & \ href {../ binary / instructions.html # binary-instr} {\ mathtt {instr}} & :: = & \ dots && \ phantom { этого должно быть достаточно} \\ && | & \ def \ mathdef967 # 1 {\ mathtt {0x # 1}} \ mathdef967 {FC} ~~ 0 {:} \ href {../binary/values.html#binary-int}{\def\mathdef728#1{{\mathtt{u}#1}}\mathdef728{\mathtt{32}}} & \ Rightarrow & \ href {../ синтаксис /types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{trunc}}\mathsf{\_sat\_} \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f32}} \ mathsf {\ _ s} \\ && | & \ def \ mathdef968 # 1 {\ mathtt {0x # 1}} \ mathdef968 {FC} ~~ 1 {:} \ href {../ binary / values.html # binary-int} {\ def \ mathdef728 # 1 { {\ mathtt {u} # 1}} \ mathdef728 {\ mathtt {32}}} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{i32}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{trunc}}\mathsf{\_sat \ _} \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f32}} \ mathsf {\ _ u} \\ && | & \ def \ mathdef969 # 1 {\ mathtt {0x # 1}} \ mathdef969 {FC} ~~ 2 {:} \ href {../ binary / values.html # binary-int} {\ def \ mathdef728 # 1 { {\ mathtt {u} # 1}} \ mathdef728 {\ mathtt {32}}} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}. \ href { ../ syntax / instructions.html # syntax-instr-numeric} {\ mathsf {trunc}} \ mathsf {\ _ sat \ _} \ href {../syntax/types.html#syntax-valtype}{\mathsf{f64}}\mathsf{\_s} \\ && | & \ def \ mathdef970 # 1 {\ mathtt {0x # 1}} \ mathdef970 {FC} ~~ 3 {:} \ href {../ binary / values.html # binary-int} {\ def \ mathdef728 # 1 { {\ mathtt {u} # 1}} \ mathdef728 {\ mathtt {32}}} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i32}}. \ href { ../ syntax / instructions.html # syntax-instr-numeric} {\ mathsf {trunc}} \ mathsf {\ _ sat \ _} \ href {../ syntax / types.html # syntax-valtype} {\ mathsf { f64}} \ mathsf {\ _ u} \\ && | & \ def \ mathdef971 # 1 {\ mathtt {0x # 1}} \ mathdef971 {FC} ~~ 4 {:} \ href {../binary/values.html#binary-int}{\def\mathdef728#1{{\mathtt{u}#1}}\mathdef728{\mathtt{32}}} & \ Rightarrow & \ href {../ синтаксис /types.html#syntax-valtype}{\mathsf{i64}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{trunc}}\mathsf{\_sat\_} \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f32}} \ mathsf {\ _ s} \\ && | & \ def \ mathdef972 # 1 {\ mathtt {0x # 1}} \ mathdef972 {FC} ~~ 5 {:} \ href {../ binary / values.html # binary-int} {\ def \ mathdef728 # 1 { {\ mathtt {u} # 1}} \ mathdef728 {\ mathtt {32}}} & \ Rightarrow & \ href {../syntax/types.html#syntax-valtype}{\mathsf{i64}}.\href{../syntax/instructions.html#syntax-instr-numeric}{\mathsf{trunc}}\mathsf{\_sat \ _} \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {f32}} \ mathsf {\ _ u} \\ && | & \ def \ mathdef973 # 1 {\ mathtt {0x # 1}} \ mathdef973 {FC} ~~ 6 {:} \ href {../ binary / values.html # binary-int} {\ def \ mathdef728 # 1 { {\ mathtt {u} # 1}} \ mathdef728 {\ mathtt {32}}} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ href { ../ syntax / instructions.html # syntax-instr-numeric} {\ mathsf {trunc}} \ mathsf {\ _ sat \ _} \ href {../syntax/types.html#syntax-valtype}{\mathsf{f64}}\mathsf{\_s} \\ && | & \ def \ mathdef974 # 1 {\ mathtt {0x # 1}} \ mathdef974 {FC} ~~ 7 {:} \ href {../ binary / values.html # binary-int} {\ def \ mathdef728 # 1 { {\ mathtt {u} # 1}} \ mathdef728 {\ mathtt {32}}} & \ Rightarrow & \ href {../ syntax / types.html # syntax-valtype} {\ mathsf {i64}}. \ href { ../ syntax / instructions.html # syntax-instr-numeric} {\ mathsf {trunc}} \ mathsf {\ _ sat \ _} \ href {../ syntax / types.html # syntax-valtype} {\ mathsf { f64}} \ mathsf {\ _ u} \\ \ end {array} \ end {split} \]

Выражения

Выражения кодируются последовательностью их инструкций, заканчивающейся явным кодом операции \ (\ def \ mathdef975 # 1 {\ mathtt {0x # 1}} \ mathdef975 {0B} \) для \ (\ href {.\ ast ~ \ href {../ syntax / instructions.html # syntax-instr-control} {\ mathsf {end}} \\ \ end {array} \ end {split} \]

АРИФМЕТИЧЕСКИХ ИНСТРУКЦИЙ

В этой главе описаны все арифметические и логические инструкции 8051. Примеры программ приведены для иллюстрации применения этих инструкций. В Разделе 6.1 мы обсуждаем инструкции и программы, относящиеся к сложению, вычитанию, умножению и делению беззнаковых чисел. Числа со знаком обсуждаются в разделе 6.2. В разделе 6.3 мы обсуждаем логические инструкции AND, OR и XOR, а также инструкцию COMPARE.Инструкция ROTATE и сериализация данных обсуждаются в Разделе 6.4. В Разделе 6.5 мы приводим некоторые реальные приложения, такие как преобразование BCD и ASCII и тестирование байтов контрольной суммы.

РАЗДЕЛ 6.1: АРИФМЕТИЧЕСКИЕ ИНСТРУКЦИИ

Беззнаковые числа определяются как данные, в которых все биты используются для представления данных, и никакие биты не зарезервированы для положительного или отрицательного знака. Это означает, что операнд может находиться в диапазоне от 00 до FFH (от 0 до 255 в десятичном формате) для 8-битных данных.

Сложение беззнаковых чисел

В 8051 для сложения чисел должен быть задействован регистр аккумулятора (A). Форма инструкции ADD:

Инструкция ADD используется для добавления двух операндов. Операнд-адресат всегда находится в регистре A, тогда как операнд-источник может быть регистром, непосредственными данными или в памяти. Помните, что арифметические операции с преобразованием памяти в память никогда не допускаются в языке Ассемблер 8051.Команда может изменить любой из битов AF, CF или P регистра флага, в зависимости от задействованных операндов. Влияние инструкции ADD на флаг переполнения обсуждается в разделе 6.3, поскольку он используется в основном в операциях с числами со знаком. Посмотрите на Пример 6.1.

Пример 6-1

Покажите, как следующие инструкции влияют на регистр флагов.

После сложения регистр A (адресат) содержит 00 и следующие флаги:

CY = 1, так как есть выход из D7.

P = 0, потому что количество Is равно нулю (четное число).

AC = 1, поскольку есть перенос с D3 на D4.

Сложение отдельных байтов

Глава 2 содержала программу, которая добавляла 5 байтов данных. Сумма была намеренно меньше FFH, максимального значения, которое может содержать 8-битный регистр. Чтобы вычислить сумму любого количества операндов, флаг переноса должен быть проверен после добавления каждого операнда.В примере 6-2 R7 используется для накопления переносов при добавлении операндов к A.

Пример 6-2

Предположим, что ячейки ОЗУ 40–44 имеют следующие значения. Напишите программу, чтобы найти сумму значений. В конце программы регистр A должен содержать младший байт, а R7 — старший. Все значения в шестнадцатеричном формате.

40 = (7D) 41 = (EB) 42 = (C5) 43 = (5B) 44 = (30)

Решение:

Анализ примера 6-2

Три итерации цикла показаны ниже.Трассировка программы предоставляется читателю в качестве упражнения.

1. В первой итерации цикла 7DH добавляется к A с CY = 0 и R7 = 00,
   и счетчик R2 = 04.
   

2. Во второй итерации цикла EBH добавляется к A, в результате получается A –
   68H и CY = 1. Поскольку произошел перенос, R7 увеличивается. Теперь счетчик
   R2 = 03.
   

3. На третьей итерации C5H добавляется к A, что делает A = 2DH.Снова произошел перенос
   , поэтому R7 снова увеличивается. Теперь счетчик R2 = 02.
   

В конце, когда цикл завершен, сумма сохраняется в регистрах A и R7, где A имеет младший байт, а R7 — старший байт.

ADDC и сложение 16-битных чисел

При добавлении двух 16-битных операндов данных необходимо учитывать распространение переноса от младшего байта к старшему. В таких случаях используется инструкция ADDC (добавить с переносом).Например, посмотрите на добавление 3CE7H + 3B8DH, как показано ниже.

Когда добавляется первый байт (E7 + 8D = 74, CY = 1). Перенос распространяется на старший байт, в результате чего получается 3C + 3B + 1 = 78 (все в шестнадцатеричном формате). Пример 6-3 показывает вышеуказанные шаги в программе 8051.

Пример 6-3

Напишите программу для сложения двух 16-битных чисел. Цифры — 3CE7H и 3B8DH. Поместите сумму в R7 и R6; R6 должен иметь младший байт.

BCD (двоично-десятичная) система счисления

BCD означает двоично-десятичную дробь.BCD необходим, потому что в повседневной жизни мы используем цифры от 0 до 9 для чисел, а не двоичные или шестнадцатеричные числа. Двоичное представление от 0 до 9 называется BCD (см. Рисунок 6-1). В компьютерной литературе встречаются два термина для чисел BCD: (1) распакованный BCD и (2) упакованный BCD. Опишем каждый следующий.

BCD без упаковки

В распакованном BCD младшие 4 бита числа представляют номер BCD, а остальные биты равны 0. Например, «0000 1001 ″ и« 0000 0101 ″ — это распакованные BCD для 9 и 5, соответственно.Для распакованного BCD требуется 1 байт памяти или 8-битный регистр.

Рисунок 6-1. Код BCD

BCD в упаковке

В упакованном двоично-десятичном коде один байт содержит два двоично-десятичных числа: одно в нижних 4 битах и ​​одно в верхних 4 битах. Например, «0101 1001» упакован в BCD для 59H. Для хранения упакованных операндов BCD требуется всего 1 байт памяти. Таким образом, одна из причин использования упакованного BCD заключается в том, что он вдвое эффективнее хранит данные.

Возникла проблема с добавлением чисел BCD, которую необходимо исправить. Проблема в том, что после добавления упакованных чисел BCD результат больше не BCD. Посмотрите на следующее.

Сложение этих двух чисел дает 0011 111 IB (3FH), что не является BCD! Номер BCD может состоять только из цифр от 0000 до 1001 (или от 0 до 9). Другими словами, сложение двух чисел BCD должно дать результат BCD. Результат должен был быть 17 + 28 = 45 (0100 0101). Чтобы исправить эту проблему, программист должен добавить 6 (0110) к младшей цифре: 3F + 06 = 45H.Та же проблема могла возникнуть в верхнем разряде (например, в 52H + 87H = D9H). Опять же, чтобы решить эту проблему, нужно добавить 6 к верхней цифре (D9H + 60H = 139H), чтобы результат был двоично-десятичным (52 + 87 = 139). Эта проблема настолько распространена, что у большинства микропроцессоров, таких как 8051, есть инструкции по ее решению. В 8051 инструкция «DA A» предназначена для исправления проблемы сложения BCD. Это обсуждается далее.

Инструкция DA

Инструкция DA (десятичная корректировка для сложения) в 8051 предназначена для исправления вышеупомянутой проблемы, связанной со сложением BCD.Мнемоника «DA» имеет в качестве единственного операнда аккумулятор «A». Команда DA добавит 6 к младшему полубайту или большему полубайту, если необходимо; в противном случае он оставит результат в покое. Следующий пример проясняет эти моменты.

После выполнения программы регистр A будет содержать 72H (47 + 25 = 72). Инструкция «DA» работает только с A. Другими словами, хотя источник может быть операндом любого режима адресации, адресат должен находиться в регистре A, чтобы DA работал.Также необходимо подчеркнуть, что DA должен использоваться после добавления операндов BCD и что операнды BCD никогда не могут иметь цифру больше 9. Другими словами, цифры A — F не допускаются. Также важно отметить, что DA работает только после инструкции ADD; он не будет работать после инструкции INC.

Краткое изложение действий DA

После инструкции ADD или ADDC,

1. Если младший полубайт (4 бита) больше 9, или если AC = 1, добавьте 0110 к младшим
   4 битам.
   

1. Если верхний полубайт больше 9 или если CY = 1, добавьте 0110 к старшим 4 битам.
   

В действительности бит флага AC (вспомогательный перенос) не используется иначе, кроме как для сложения и коррекции BCD. Например, добавление 29H и 18H приведет к 41H, что неверно с точки зрения BCD.

Поскольку AC = 1 после сложения, «DA A» прибавит 6 к младшему полубайту. Окончательный результат — в формате BCD.Две разные инструкции для вычитания: SUB и SUBB (вычитание с заимствованием). В 8051 есть только SUBB. Чтобы сделать SUB из SUBB, мы должны сделать CY = 0 до выполнения инструкции. Следовательно, есть два случая для инструкции SUBB: (1) с CY = 0 и (2) с CY = 1. Сначала мы рассмотрим случай, когда CY = 0 до выполнения SUBB. Обратите внимание, что мы используем флаг CY для заимствования.

SUBB (вычесть с займом), когда CY = 0

При вычитании микропроцессоры 8051 (действительно, все современные процессоры) используют метод дополнения до 2.Хотя каждый ЦП содержит схему сумматора, было бы слишком громоздко (и потребовалось бы слишком много транзисторов) разработать отдельную схему вычитателя. По этой причине 8051 использует схему сумматора для выполнения команды вычитания. Предполагая, что 8051 выполняет простую команду вычитания и что CY = 0 перед выполнением инструкции, можно суммировать шаги аппаратного обеспечения ЦП при выполнении инструкции SUBB для чисел без знака следующим образом.

1. Возьмите дополнение до 2 вычитаемого (исходный операнд).
   

2. Добавьте его в список (A).
   

3. Инвертировать перенос.
   

Эти три шага выполняются для каждой команды SUBB внутренним оборудованием ЦП 8051, независимо от источника операндов, при условии, что поддерживается режим адресации. После этих трех шагов результат получен и флаги установлены. Пример 6-5 иллюстрирует три шага.

Пример 6-5

Флаги должны быть установлены следующим образом: CY = 0, AC — 0, и программист должен посмотреть на флаг переноса, чтобы определить, положительный или отрицательный результат.

Покажите шаги, необходимые для следующего.

Если C Y = 0 после выполнения SUBB, результат положительный; если C Y = 1, результат отрицательный, и адресат имеет дополнение результата до 2. Обычно результат остается в дополнении до 2, но для его изменения можно использовать инструкции CPL (дополнение) и INC. Инструкция CPL выполняет дополнение операнда до 1; затем операнд увеличивается на единицу (INC), чтобы получить дополнение до 2. См. Пример 6-6.

Пример 6-6

SUBB (вычесть с займом), когда CY = 1

Эта инструкция используется для многобайтовых чисел и берет на себя заимствование младшего операнда. Если CY = 1 до выполнения инструкции SUBB, он также вычитает 1 из результата. См. Пример 6-7.

Пример 6-7

Проанализируйте следующую программу:

Решение:

После SUBB A = 62H — 96H = CCH, и флаг переноса устанавливается в высокий уровень, указывающий на наличие заимствования.Поскольку CY = 1, когда SUBB выполняется второй раз, A = 27H — 12H -1 = 14H. Следовательно, имеем 2762H — 1296H = 14CCH.

НЕПОДПИСАННОЕ УМНОЖЕНИЕ И ПОДРАЗДЕЛЕНИЕ

При умножении или делении двух чисел в 8051 требуется использование регистров A и B, поскольку инструкции умножения и деления работают только с этими двумя регистрами. Сначала обсудим умножение.

Умножение беззнаковых чисел

8051 поддерживает только побайтовое умножение.Предполагается, что байты являются данными без знака. Синтаксис следующий:

При побайтовом умножении один из операндов должен находиться в регистре A, а второй операнд должен находиться в регистре B. После умножения результат находится в регистрах A и B; младший байт находится в A, а старший байт — в B. В следующем примере 25H умножается на 65H. Результатом являются 16-битные данные, которые хранятся в регистрах A и B.

Примечание: Умножение операндов размером более 8 бит требует некоторых манипуляций.Читателю предоставляется возможность поэкспериментировать.

Деление беззнаковых чисел

При делении беззнаковых чисел 8051 поддерживает только побайтовую передачу. Синтаксис следующий.

При делении байта на байт числитель должен быть в регистре A, а знаменатель — в B. После выполнения инструкции DIV частное будет в A, а остаток — в B. См. Следующий пример.

Обратите внимание на следующие моменты для инструкции «DIV AB».

1. Эта инструкция всегда делает CY = 0 и OV = 0, если знаменатель не равен 0.
   

   1. Если знаменатель равен 0 (B = 0), OV = 1 указывает на ошибку, а CY = 0. Стандартная практика
      во всех микропроцессорах при делении числа на 0 — до
      каким-то образом указывает на неверный результат бесконечности. В 8051 флаг OV
      установлен на 1.
      

   Таблица 6-2: Сводка беззнакового деления (DIV AB)
   

Приложение для инструкций DIV

Бывают случаи, когда АЦП (аналого-цифровой преобразователь) подключен к порту, и АЦП представляет некоторую величину, например температуру или давление.8-битный АЦП предоставляет данные в шестнадцатеричном формате в диапазоне от 00 до FFH. Эти шестнадцатеричные данные необходимо преобразовать в десятичные. Мы делаем это путем многократного деления на 10, сохраняя остаток, как показано в Примере 6-8.

Пример 6-8

Напишите программу (a), чтобы сделать PI входным портом, (b) получить байт шестнадцатеричных данных в диапазоне 00 — FFH из PI и преобразовать его в десятичное. Сохраните цифры в R7, R6 и R5, где младшая цифра находится в R7.

Решение:

Входное значение PI находится в шестнадцатеричном диапазоне от 00 до FFH или в двоичном формате от 00000000 до 11111111.Эта программа не будет работать, если входные данные в BCD. Другими словами, эта программа преобразует двоичный код в десятичный. Чтобы преобразовать одну десятичную цифру в формат ASCII, мы используем OR с 30H, как показано в разделах 6.4 и 6.5.

Пример 6-9

Проанализируйте программу из примера 6-8, предполагая, что PI имеет значение FDH для данных. Решение:

Чтобы преобразовать двоичное (шестнадцатеричное) значение в десятичное, мы многократно делим его на 10, пока частное не станет меньше 10.После каждого деления остаток сохраняется. В случае 8-битного двоичного файла, такого как FDH, у нас есть 253 десятичных числа, как показано ниже (все в шестнадцатеричном формате).

Следовательно, мы имеем FDH = 253. Чтобы отобразить эти данные, они должны быть преобразованы в ASCII, что описано в следующем разделе этой главы.

Само рандомизирующиеся адреса инструкций устаревшего двоичного кода x86

[4]

С. Андерсен. Часть 3: Технологии защиты памяти. В

В.Абелла, редактор, Изменения в функциональности Windows XP

Service Pack 2. Microsoft TechNet, 2004. http: // technet.

microsoft.com/en-us/library/bb457155.aspx.

[5]

Э. Г. Баррантес, Д. Х. Экли, Т. С. Палмер, Д. Стефанович,

и Д. Д. Зови. Эмуляция рандомизированного набора команд до

предотвращает атаки с внедрением двоичного кода. В Proc. 10-я конференция ACM.

по безопасности компьютеров и связи, страницы 281–289,

2003.

[6]

Л. Бауэр, Дж. Лигатти и Д. Уокер. Составление политик безопасности

с помощью Polymer. В Proc. ACM SIGPLAN Conf. на

Проектирование и реализация языков программирования, страницы

305–314, 2005.

[7]

Э. Д. Бергер и Б. Г. Цорн. DieHard: Вероятностная память

безопасность для небезопасных языков. В Proc. ACM SIGPLAN Conf.

по проектированию и реализации языков программирования,

страниц 158–168, 2006.

[8]

С. Бхаткар и Р. Секар. Рандомизация пространства данных. В

Proc. Int. Конф. по обнаружению вторжений и вредоносного ПО и

Оценка уязвимости, страницы 1–22, 2008 г.

[9]

С. Бхаткар, Д. К. ДюВарни и Р. Секар. Обфускация адреса

: эффективный подход к борьбе с широким спектром эксплойтов ошибок памяти

. В Proc. 12-й симпозиум по безопасности USENIX

, страницы 105–120, 2003 г.

[10]

S.Бхаткар, Р. Секар и Д. К. ДюВарни. Эффективные

техники комплексной защиты от ошибок памяти

эксплойтов. В Proc. 14-й симпозиум по безопасности USENIX, страницы

255–270, 2005.

[11]

Д. Бруски, Л. Кавалларо и А. Ланци. Диверсифицированный процесс

реплик для защиты от эксплойтов ошибок памяти. В Proc. IEEE

Int. Performance, Computing, and Communications Conf.,

pages 434–441, 2007.

[12]

E.Бьюкенен, Р. Ремер, Х. Шахем и С. Сэвидж. Когда

хорошие инструкции становятся плохими: Обобщение ориентированного на возврат программирования

на RISC. В Proc. 15-я конференция ACM. на

Компьютерная и коммуникационная безопасность, страницы 27–38,

2008.

[13]

К. Кадар, В. Ганеш, П. М. Павловски, Д. Л. Дилл и Д. Р.

Энглер. EXE: автоматическая генерация данных о смерти. В

Proc. 13-я конференция ACM. по компьютерам и коммуникациям

Безопасность, страницы 322–335, 2006.

[14]

К. Кадар, П. Акритидис, М. Коста, Ж.-П. Мартин и М. Кастро.

Рандомизация данных. Технический отчет MSR-TR-2008-120,

Microsoft Research, 2008.

[15]

С. Чековей, Л. Дави, А. Дмитриенко, А.-Р. Sadeghi,

H. Shacham и M. Winandy. Возвратное программирование

без возврата. В Proc. 17-я конференция ACM. on Computer and

Communications Security, страницы 559–572, 2010.

[16]

F.Чен и Г. Роосу. Java-MOP: ориентированная на мониторинг среда программирования

для Java. В Proc. 11-е межд. Конф.

об инструментах и ​​алгоритмах построения и анализа

систем, страницы 546–550, 2005 г.

[17]

П. Чен, Х. Сяо, X. Шен, X. Инь, Б. Мао, и Л. Се.

DROP: обнаружение вредоносного программного кода, ориентированного на возврат.

. В Proc. 5-й Int. Конф. по безопасности информационных систем,

стр. 163–177, 2009.

[18]

W. Cheng, Q. Zhao, B. Yu и S. Hiroshige. TaintTrace:

Эффективная трассировка потоков с динамической двоичной перезаписью. В Proc.

11-й симпозиум IEEE по компьютерам и коммуникациям,

стр. 749–754, 2006 г.

[19]

М. Чу и Д. Сонг. Снижение переполнения буфера за счет

рандомизации операционной системы. Технический отчет CMU-CS-

02-197, Университет Карнеги-Меллона, 2002.

[20]

Команда Corelan.Мона, 2012. http://redmine.corelan.be/

проектов / мона.

[21]

К. Коуэн, С. Битти, Дж. Йохансен и П. Вагл.

PointGuard

TM

: защита указателей от переполнения буфера

уязвимостей. В Proc. 12-й симпозиум по безопасности USENIX,

страницы 91–104, 2003.

[22]

Б. Кокс, Д. Эванс, А. Филипи, Дж. Роуэнхилл, У. Ху,

Дж. Дэвидсон, Дж. Найт , А. Нгуен-Туонг и Дж. Хисер.

N-Variant Systems: бессекретная структура для обеспечения безопасности

посредством разнообразия.В Proc. 15-й симпозиум по безопасности USENIX,

2006.

[23]

L. Davi, A.-R. Садеги и М. Винанди. ROPdefender: средство обнаружения

для защиты от атак программирования

, ориентированных на возврат. В Proc. 6-й симпозиум ACM по информации,

Компьютерная и коммуникационная безопасность, страницы 40–51,

2011.

[24]

У. Дреппер. Улучшения безопасности в Red Hat Enterprise

Linux (кроме SELinux), версия 1.6, раздел 5: Позиция

независимых исполняемых файлов, декабрь 2005 г. http: // www.

akkadia.org/drepper/nonselsec.pdf.

[25]

Ú. Эрлингссон и Ф. Б. Шнайдер. Применение SASI

политик безопасности: ретроспектива. В Proc. New Security

Paradigms Workshop, 1999.

[26]

С. Форрест, А. Сомаяджи и Д. Х. Экли. Создание разнообразных компьютерных систем

. В Proc. 6-й семинар по актуальным темам в операционных системах

, стр. 67, 1997.

[27]

П. Годфроид, М. Ю. Левин и Д. Мольнар. Автоматизированное тестирование фаззинга

whitebox. В Proc. 15-й ежегодный симпозиум по безопасности сетей и

распределенных систем, 2008 г.

[28]

Hex-Rays. Дизассемблер и отладчик IDA Pro, 2012.

http://www.hex-rays.com/idapro.

[29]

Дж. Д. Хисер, А. Нгуен-Туонг, М. Ко, М. Холл и Дж. У.

Дэвидсон. ILR: Куда пропали мои гаджеты? В Proc. IEEE

Симпозиум по безопасности и конфиденциальности, страницы 571–585, 2012.

[30]

Г. Хоглунд и Дж. Батлер. Руткиты: подрыв ядра Windows

, глава 4: Вековое искусство перехвата, страницы 73–

74. Pearson Education, Inc., 2006.

[31]

Дж. К. Холлингсворт, Б. П. Миллер и Дж. Каргилль. Программный инструментарий Dynamic

для масштабируемых инструментов производительности. В

Proc. Scalable High Performance Computing Conf., Страницы

841–850, 1994.

[32]

G.Хант и Д. Брубахер. Объезды: бинарный перехват

функций Win32. В Proc. 3-й симпозиум USENIX Windows NT

, 1999.

[33]

X. Jiang, H. J. Wang, D. Xu, and Y.-M. Ван. RandSys:

Противодействие атакам внедрения кода с помощью системной службы

рандомизация интерфейса. В Proc. 26-я IEEE Int. Симпозиум

по надежным распределенным системам, страницы 209–218, 2007.

[34]

G. S. Kc, A. D. Keromytis и V.Превелакис. Противодействие атакам с внедрением кода

с рандомизацией набора команд. В

Proc. 10-я конференция ACM. по компьютерам и коммуникациям

Безопасность, страницы 272–280, 2003.

[35]

В. Кириански, Д. Брюнинг и С. Амарасингхе. Secure

8051 Руководство по набору инструкций: коды операций