Обзор специальных инструкций

17.1 LEA
--------
Инструкция LEA используется для многих целей, поскольку она может делать
сдвиг, сложение/вычитание, и загрузку помимо этого она спариваемая и
исполняется за один такт. Например:
LEA EAX,[EBX+8*ECX-1000]
намного быстрее, чем
MOV EAX,ECX / SHL EAX,3 / ADD EAX,EBX / SUB EAX,1000
Инструкция LEA может быть также быть использована для сложения или сдвига без
изменения флагов. Источник и приемник не должны иметь тоже размер слова, таким
образом LEA EAX,[BX] лучше заменить на MOVZX EAX,BX.

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

А с тех пор как инструкция LEA может спариваться и в V-трубе, а инструкции
сдвига нет, то вы можете использовать LEA как заменитель SHL на 1, 2, 3 если
вы хотите, что бы эта операция выполнилась в V-трубе.

У 32 битных процессоров нет документированного способа адресации масштабом
индексного регистра, так например LEA EAX,[EAX*2] в действительности
кодируется как LEA EAX,[EAX*2+00000000] с добавлением 4 байт к смещению. Вы
можете уменьшить размер кода записав так: LEA EAX,[EAX+EAX] или лучше
ADD EAX,EAX. Последняя версия кода не может вызвать остановку AGI. А если
вам везет и у вас есть регистр с нулевым значением(например счетчик цикла,
после его завершения), то вы можете использовать его как базовый для
уменьшения размера кода:

LEA EAX,[EBX*4]     ; 7 байт
LEA EAX,[ECX+EBX*4] ; 3 байта

17.2 TEST
---------
Инструкция TEST с непосредственным значением операнда, только если сравнение
идет с AL, AX или EAX.

TEST регистр,регистр или TEST регистр,память всегда спаривается.

Примеры:
TEST ECX,ECX                ; спариться
TEST [mem],EBX              ; спариться
TEST EDX,256                ; не спариться
TEST DWORD PTR [EBX],8000H  ; не спариться
Что бы сделать их спариваемыми, используйте любой из следующих методов:
MOV EAX,[EBX] / TEST EAX,8000H
MOV EDX,[EBX] / AND  EDX,8000H
MOV AL,[EBX+1] / TEST AL,80H
MOV AL,[EBX+1] / TEST AL,AL  ; (результат в флаге знака(SF))
Так же можно сдвинуть тестовый бит в флаг переноса(CF):
MOV EAX,[EBX] / SHR EAX,16   ; (результат в флаге переноса(CF))
но этот метод приведет к потерям на PentiumPro, если переносится более одного
бита.

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

17.3 XCHG
---------
Сочетание XCHG регистр,память - опасно, т.к. по умолчанию эта инструкция
имеет префикс LOCK, для предотвращения использования кеша. Следовательно эта
инструкция поглощает много времени и от нее надо избавляться.

17.4 сдвиги через перенос
-------------------------
RCL и RCR, с количеством сдвигаемых байт больше чем один очень медленные и
от них надо избавляться.

17.5 строковые инструкции
-------------------------
Строковые инструкции без префикса повторения тоже медленные и должны
заменяться более простыми инструкциями. То же относиться к LOOP и JECXZ.

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

REP MOVSD - является самым быстрым способом перемещать блоки данных, когда
приемник находится в кеше. Для альтернативы см. раздел 19.

REP STOSD - оптимален, когда приемник в кеше.

REP LOADS, REP SCAS и REP CMPS - не оптимальны и могут быть замещены циклами.
См. раздел 16, пример 10 как альтернативу REP SCASB.

17.6 битовое сканирование
-------------------------
BSF и BSR - самые плохо оптимизированные инструкции на Pentium, беря на
исполнение 11 + 2*n тактов, где n - число пропущенных нулей.
(на поздних процессорах берут только 1 или 2)

Следующий код эмулирует BSR ECX,EAX:
        TEST    EAX,EAX
        JZ      SHORT BS1
        MOV     DWORD PTR [TEMP],EAX
        MOV     DWORD PTR [TEMP+4],0
        FILD    QWORD PTR [TEMP]
        FSTP    QWORD PTR [TEMP]
        WAIT    ; для совместимости с ранними процессорами
        MOV     ECX, DWORD PTR [TEMP+4]
        SHR     ECX,20
        SUB     ECX,3FFH
        TEST    EAX,EAX       ; сбрасываем флаг нуля
BS1:

Следующий пример эмулирует BSF ECX,EAX:
        TEST    EAX,EAX
        JZ      SHORT BS2
        XOR     ECX,ECX
        MOV     DWORD PTR [TEMP+4],ECX
        SUB     ECX,EAX
        AND     EAX,ECX
        MOV     DWORD PTR [TEMP],EAX
        FILD    QWORD PTR [TEMP]
        FSTP    QWORD PTR [TEMP]
        WAIT    ; для совместимости с ранними процессорами
        MOV     ECX, DWORD PTR [TEMP+4]
        SHR     ECX,20
        SUB     ECX,3FFH
        TEST    EAX,EAX       ; сбрасываем флаг нуля
BS2:

17.7 битовый тест
-----------------
BT, BTC, BTR и BTS предпочтительно должны заменяться инструкциями вроде
TEST, AND, OR, XOR или сдвигов.

17.8 умножения целых
--------------------
Целочисленное умножение занимает примерно 9 тактов. Следовательно выгоднее
заменить умножение константы на одну из следующих инструкций: SHL, ADD, SUB и
LEA. Например:
IMUL EAX,10
можно заменить на
MOV EBX,EAX / ADD EAX,EAX / SHL EBX,3 / ADD EAX,EBX
или
LEA EAX,[EAX+4*EAX] / ADD EAX,EAX

Умножение с плавающей точкой быстрее чем целочисленная операция на Pentium
без MMX, но время затрачиваемое на преобразование целого в вещественное и
преобразования результата назад обычно намного больше, чем время сохраненное
при использовании умножения с плавающей точкой, кроме одного случая, когда
количество умножений гораздо больше количества преобразований.

17.9 деление
------------
Деление поглощает очень много времени. Инструкция DIV берет 17, 25 или 41
такт для байта, слова или двойного слова, соответственно. Инструкция IDIV
использует на 5 тактов больше. Следовательно, предпочтительно использовать
наименьший из возможных операндов, который не вызовет переполнения, даже если
придется пожертвовать префиксом размера и использовать без значное деление,
если возможно.

Без значное деление, если делитель кратен 2, может быть заменено на SHR. Деление
числа со знаком может быть заменено на SAR, но результат, при делении на ноль,
округлиться к минус бесконечности.

Деля положительное число, N (< 2^16) на константу D, не кратную 2 может быть
заменена умножением N с 2^16 / D, а затем разделить на 2^16. Например, что бы
разделить число на 5 вы должны умножения умножить его на 2^16 / 5 = 3333H, а
затем разделить на 2^16:

INC EAX  /  IMUL EAX,3333H  /  SHR EAX,16

INC EAX добавлен для компенсации двойной ошибки от округления.
Этот метод работает при 0 <= N <= 2^16. Вы должны протестировать этот код
тщательно, что бы убедиться, что округление правильно.

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

        LEA     EBX,[EAX+2*EAX+3]
        LEA     ECX,[EAX+2*EAX+3]
        SHL     EBX,4
        MOV     EAX,ECX
        SHL     ECX,8
        ADD     EAX,EBX
        SHL     EBX,8
        ADD     EAX,ECX
        ADD     EAX,EBX
        SHR     EAX,16

Вы можете использовать то же код, что бы разделить на 10. Просто измените
сдвиг 16 на 17 в конце.

Делению с плавающей точкой требуется 39 тактов, при максимальной точности. Вы
можете сохранить время, определив для числа более низкую точность в
управляющем слове. (Только на инструкции FDIV и FIDIV распространяется
ускорение, ни какие други инструкции не выполняются быстрее).

Возможно делать деление с плавающей точкой и целочисленное деление
параллельным, что бы сохранить время. Например: A = A1 / A2;  B = B1 / B2

FILD [B1]
FILD [B2]
MOV EAX,[A1]
MOV EBX,[A2]
CDQ
FDIV
DIV EBX
FISTP [B]
MOV [A],EAX
(убедитесь, что вы правильно устанавливаете слово управления операций с
плавающей точкой, что вы используете приемлимое округление)

Очевидно, что вы должны пытаться минимизировать количество делений. Деления
чисел с плавающей точкой на константу должно заменяться умножением на обратную
величину. Но есть много других ситуаций, когда вы можете уменьшить количество
делений. Например:
if (A/B > C)...  можно представить как if (A > B*C)...  тогда B
положительный, иначе - отрицательный.

A/B + C/D  можно переписать как (A*D + C*B) / (B*D)

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

17.10 WAIT
----------
Вы часто можете увеличить скорость, опуская эту инструкцию.
У инструкции WAIT есть три функции:

  а. Процессор 8087 требовал WAIT перед _любой_ инструкцией с плавающей
     точкой.

  б. WAIT используется для координации доступа к памяти после инструкции
     с плавающей точкой и между целочисленной инструкцией. Примеры:
     б.1.  FISTP [mem32]
           WAIT             ; ждем пока сопроцессор запишет результат
           MOV EAX,[mem32]  ; читаем результат его работы

     б.2.  FILD [mem32]
           WAIT             ; ждем сопроцессор, что бы прочитать значение...
           MOV [mem32],EAX  ; и используем его

     б.3.  FLD DWORD PTR [ESP]
           WAIT             ; для получения аппаратного прерывания...
           ADD ESP,4        ; изменяем значение стека до его чтения

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

Относительно а:
Эта функция никогда не нужна в любом процессоре, более поздним, чем 8087. Если
вы не хотите, что бы ваш код был совместим с 8087, то вы должны указать
вашему ассемблеру не помещать эти инструкции автоматически, выбрав более
поздний процессор.

Относительно б:
Инструкция WAIT, координирующая доступ к памяти требуется на 8087 и 80287
процессорах. Суперскалярный процессор Pentium имеет специальную схему,
обнаруживающую подобные ситуации и вам не требуется помещать данную инструкцию,
если ваша программа будет запускаться на процессорах Pentium или более
современных. Я протестировал другие Intel процессоры и ни на каком не было
никаких проблем при опускании WAIT на любых 32 битных, хотя Intel утверждает,
что там WAIT необходим, за исключением FNSTSW и FNSTCW. Если вы хотите быть
уверенным, что бы ваш код работал на любом 32 битном процессоре (в том числе
и не Intel), то я рекомендую устанавливать WAIT, для безопасности.

Относительно в:
Ассемблер автоматически вставляет WAIT перед следующими инструкциями:
FCLEX, FINIT, FSAVE, FSTCW, FSTENV, FSTSW
Вы можете опускать WAIT используя FCLEX, мои тесты показывают, что
использование WAIT не необходимо, поскольку здесь и без WAIT будет
генерироваться прерывание, за исключением FNCLEX и FNINIT на 80387. (есть
некоторая несовместимость инструкции IRET и  последующих инструкций FN..).

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

Вам потребуется WAIT, если вы хотите узнать, где точно произошло исключение.
Рассмотрим например б.3: Если вы хотите получить возможность
восстанавливаться из исключения генерируемого FLD, то вам потребуется WAIT,
поскольку для ADD ESP,4 величина должна быть загружена.

17.11 FCOM + FSTSW AX
---------------------
Обычный путь сравнения чисел с плавающей точкой это:
FLD [a]
FCOMP [b]
FSTSW AX
SAHF
JB ASmallerThanB

Вы можете улучшить этот код, используя FNSTSW AX вместо FSTSW AX и тестируя
AH непосредственно, вместо использования неспариваемой SAHF.
(У TASM версии 3.0 есть баг инструкции FNSTSW AX)

FLD [a]
FCOMP [b]
FNSTSW AX
SHR AH,1
JC ASmallerThanB

Тестируем на ноль или равенство:

FTST
FNSTSW AX
AND AH,40H
JNZ IsZero     ; (флаг нуля(ZF) инвертирован!)

Тест на "больше":

FLD [a]
FCOMP [b]
FNSTSW AX
AND AH,41H
JZ AGreaterThanB

Не используйте TEST AH,41H - эта инструкция не спариться. Не используйте
TEST AX, 4100H - он вызывает потери на PentiumPro. Не тестируйте флаги после
многократных сдвигов, т.к. это приводит к потерям на PentiumPro.

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

17.12 FISTP
-----------
Конвертирование чисел с плавающей точкой обычно делается так:
        FISTP   DWORD PTR [TEMP]
        MOV     EAX, [TEMP]

А вот - альтернативный метод:

.DATA
ALIGN 8
TEMP    DQ      ?
MAGIC   DD      59C00000H   ; п.т. представление 2^51 + 2^52

.CODE
        FADD    [MAGIC]
        FSTP    QWORD PTR [TEMP]
        MOV     EAX, DWORD PTR [TEMP]

Добавляя "волшебное число" 2^51 + 2^52 мы получим эффект, при котором целое
число, лежащее в пределах -2^31 до +2^31 будет выравненно в младших 32 битах,
храня при этом двойную точность в виде с плавающей точкой. Результат
аналогичен FISTP, при всех методах округления, кроме округления к нулю.
Результат отличается от FISTP, если управляющее слово определяет округление в
случае переполнения. Вам может потребоваться инструкция WAIT для
совместимости с другими процессорами. См. раздел 17.10.

Этот метод не быстрее FISTP, но он дает больше возможности для планирования,
т.к. есть 3 такта между FADD и FSTP, которые можно занять другими инструкциями.
Вы можете многократно умножить или разделить число, кратное 2, используя
"волшебное число". Вы можете, также, добавить константу, добавляя ее к
"волшебному числу", результат получиться с двойной точностью.

17.13 FPTAN
-----------
Согласно описанию FPTAN возвращает два значения X и Y, оставляя програмисту
деление, что бы получить результат. Фактически же в X всегда возвращается
1, так что можно обойтись без деления. Мои тесты показывают, что на всех
32 битных Intel процессорах, сопроцессор всегда возвращает 1 в X, не зависимо
от аргумента. Если вы хотите быть абсолютно уверенным, что ваш код будет
работать на любых процессорах, вы можете проверить равенство X единице, что,
конечно, будет быстрее чем деление. Значение Y может быть очень большим, но
никогда не бесконечность, так что вы не должны тестироваться что Y содержит
допустимое значение.