Идентификация математических операторов — Архив WASM.RU

"…если вы обессилены, то не удивительно,
что вся ваша жизнь - не развлечение. У вас…
так много вычислений, расчетов, которые
необходимо сделать в вашей жизни, что она
просто не может быть развлечением."
Ошо "Пустая Лодка"
Беседы по высказываниям Чжуан Цзы

  Идентификация оператора "+". В общем случае оператор "+" транслируется либо в машинную инструкцию ADD, "перемалывающую" целочисленные операнды, либо в инструкцию FADDx, обрабатывающую вещественные значения. Оптимизирующие компиляторы могут заменять "ADD xxx, 1" более компактной командой "INC xxx", а конструкцию "c = a + b + const" транслировать в машинную инструкцию "LEA c, [a + b + const]". Такой трюк позволяет одним махом складывать несколько переменных, возвратив полученную сумму в любом регистре общего назначения, - не обязательно в левом слагаемом как это требует мнемоника команды ADD. Однако, "LEA" не может быть непосредственно декомпилирована в оператор "+", поскольку она используется не только для оптимизированного сложения (что, в общем-то, побочный продукт ее деятельности), но и по своему непосредственному назначению - вычислению эффективного смещения. (подробнее об этом см. "Идентификация констант и смещений", "Идентификация типов"). Рассмотрим следующий пример:

main()
{
int a, b,c;
c = a + b;
printf("%x\n",c);
c=c+1;
printf("%x\n",c);
}

  Листинг 204 Демонстрация оператора "+"

  Результат его компиляции компилятором Microsoft Visual C++ 6.0 с настройками по умолчанию должен выглядеть так:

main		proc near		; CODE XREF: start+AF p

var_c		= dword	ptr -0Ch
var_b		= dword	ptr -8
var_a		= dword	ptr -4

push	ebp
mov	ebp, esp
; Открываем кадр стека

sub	esp, 0Ch
; Резервируем память для локальных переменных

mov	eax, [ebp+var_a]
; Загружаем в EAX значение переменной var_a

add	eax, [ebp+var_b]
; Складываем EAX со значением переменной var_b и записываем результат в EAX

mov	[ebp+var_c], eax
; Копируем сумму var_a и var_b в переменную var_c, следовательно:
; var_c = var_a + var_b

mov	ecx, [ebp+var_c]
push	ecx
push	offset asc_406030 ; "%x\n"
call	_printf
add	esp, 8
; printf("%x\n", var_c)

mov	edx, [ebp+var_c]
; Загружаем в EDX значение переменной var_c

add	edx, 1
; Складываем EDX со значением 0х1, записывая результат в EDX

mov	[ebp+var_c], edx
; Обновляем var_c
; var_c = var_c +1

mov	eax, [ebp+var_c]
push	eax
push	offset asc_406034 ; "%x\n"
call	_printf
add	esp, 8
; printf("%\n",var_c)

mov	esp, ebp
pop	ebp
; Закрываем кадр стека

retn
main		endp

  Листинг 205

  А теперь посмотрим, как будет выглядеть тот же самый пример, скомпилированный с ключом "/Ox" (максимальная оптимизация):

main		proc near		; CODE XREF: start+AF p
push	ecx
; Резервируем место для одной локальной переменной
; (компилятор посчитал, что три переменные можно ужать в одну и это дейст. так)

mov	eax, [esp+0]
; Загружаем в EAX значение переменной var_a

mov	ecx, [esp+0]
; Загружаем в EAX значение переменной var_b
; (т.к .переменная не инициализирована загружать можно откуда угодно)

push	esi
; Сохраняем регистр ESI в стеке

lea	esi, [ecx+eax]
; Используем LEA для быстрого сложения ECX и EAX с последующей записью суммы
; в регистр ESI
; "Быстрое сложение" следует понимать не в смысле, что команда LEA выполняется
; быстрее чем ADD, - количество тактов той и другой одинаково, но LEA
; позволяет избавиться от создания временной переменной для сохранения
; промежуточного результата сложения, сразу направляя результат в ESI
; Таким образом, эта команда декомпилируется как
; reg_ESI = var_a + var_b

push	esi
push	offset asc_406030 ; "%x\n"
call	_printf
; printf("%x\n", reg_ESI)

inc	esi
; Увеличиваем ESI на единицу
; reg_ESI = reg_ESI + 1

push	esi
push	offset asc_406034 ; "%x\n"
call	_printf
add	esp, 10h
; printf("%x\n", reg_ESI)

pop	esi
pop	ecx
retn
main		endp

  Листинг 206

  Остальные компиляторы (Borland C++, WATCOM C) генерируют приблизительно идентичный код, поэтому, приводить результаты бессмысленно - никаких новых "изюминок" они в себе не несут.

  Идентификация оператора "-". В общем случае оператор "- " транслируется либо в машинную инструкцию SUB (если операнды - целочисленные значения), либо в инструкцию FSUBx (если операнды - вещественные значения). Оптимизирующие компиляторы могут заменять "SUB xxx, 1" более компактной командой "DEC xxx", а конструкцию "SUB a, const" транслировать в "ADD a, -const", которая ничуть не компактнее и ни сколь не быстрей (и та, и другая укладываться в один так), однако, хозяин (компилятор) - барин. Покажем это на следующем примере:

main()
{
int a,b,c;

c = a - b;
printf("%x\n",c);

c = c - 10;
printf("%x\n",c);
}

  Листинг 207 Демонстрация идентификации оператора "-"

  Не оптимизированный вариант будет выглядеть приблизительно так:

main		proc near		; CODE XREF: start+AF p

var_c		= dword	ptr -0Ch
var_b		= dword	ptr -8
var_a		= dword	ptr -4
	
push	ebp
	mov	ebp, esp
	; Открываем кадр стека
	
	sub	esp, 0Ch
	; Резервируем память под локальные переменные
	
	mov	eax, [ebp+var_a]
	; Загружаем в EAX значение переменной var_a

	sub	eax, [ebp+var_b]
	; Вычитаем из var_a значением переменной var_b, записывая результат в EAX
	
	mov	[ebp+var_c], eax
	; Записываем в var_c разность var_a и var_b
	; var_c = var_a - var_b
	
	mov	ecx, [ebp+var_c]
	push	ecx
	push	offset asc_406030 ; "%x\n"
	call	_printf
	add	esp, 8
	; printf("%x\n", var_c)
	
	mov	edx, [ebp+var_c]
	; Загружаем в EDX значение переменной var_c
	
	sub	edx, 0Ah
	; Вычитаем из var_c значение 0xA, записывая результат в EDX
	
	mov	[ebp+var_c], edx
	; Обновляем var_c
	; var_c = var_c - 0xA

	mov	eax, [ebp+var_c]
	push	eax
	push	offset asc_406034 ; "%x\n"
	call	_printf
	add	esp, 8
	; printf("%x\n",var_c)

	mov	esp, ebp
	pop	ebp
	; Закрываем кадр стека
	retn
main		endp

  Листинг 208

  А теперь рассмотрим оптимизированный вариант того же примера:

main		proc near		; CODE XREF: start+AF p
push	ecx
; Резервируем место для локальной переменной var_a

mov	eax, [esp+var_a]
; Загружаем в EAX значение локальной переменной var_a

push	esi
; Резервируем место для локальной переменной var_b

mov	esi, [esp+var_b]
; Загружаем в ESI значение переменной var_b

sub	esi, eax
; Вычитаем из var_a значение var_b, записывая результат в ESI

push	esi
push	offset asc_406030 ; "%x\n"
call	_printf
; printf("%x\n", var_a - var_b)

add	esi, 0FFFFFFF6h
; Добавляем к ESI (разности var_a и var_b) значение  0хFFFFFFF6
; Поскольку, 0xFFFFFFF6 == -0xA, данная строка кода выглядит так:
; ESI = (var_a - var_b) + (- 0xA) = (var_a - var_b) - 0xA

push	esi
push	offset asc_406034 ; "%x\n"
call	_printf
add	esp, 10h
; printf("%x\n", var_a - var_b - 0xA)

pop	esi
pop	ecx
; Закрываем кадр стека

retn
main		endp

  Листинг 209

  Остальные компиляторы (Borland, WATCOM) генерируют практически идентичный код, поэтому здесь не рассматриваются.

  Идентификация оператора "/". В общем случае оператор "/" транслируется либо в машинную инструкцию "DIV" (беззнаковое целочисленное деление), либо в "IDIV" (целочисленное деление со знаком), либо в "FDIVx" (вещественное деление). Если делитель кратен степени двойки, то "DIV" заменяется на более быстродействующую инструкцию битового сдвига вправо "SHR a, N", где a - делимое, а N - показатель степени с основанием два.

  Несколько сложнее происходит быстрое деление знаковых чисел. Совершенно недостаточно выполнить арифметический сдвиг вправо (команда арифметического сдвига вправо SAR заполняет старшие биты с учетом знака числа), ведь если модуль делимого меньше модуля делителя, то арифметический сдвиг вправо сбросит все значащие биты в "битовую корзину", в результате чего получиться 0xFFFFFFFF, т.е. -1, в то время как правильный ответ - ноль. Вообще же, деление знаковых чисел арифметическим сдвигом вправо дает округление в большую сторону, что совсем не входит в наши планы. Для округления знаковых чисел в меньшую сторону необходимо перед выполнением сдвига добавить к делимому число 2^N- 1, где N - количество битов, на которые сдвигается число при делении. Легко видеть, что это приводит к увеличению всех сдвигаемых битов на единицу и переносу в старший разряд, если хотя бы один из них не равен нулю.

  Следует отметить: деление очень медленная операция, гораздо более медленная чем умножение (выполнение DIV может занять свыше 40 тактов, в то время как MUL обычно укладываться в 4), поэтому, продвинутые оптимизирующие компиляторы заменяют деление умножением. Существует множество формул подобных преобразований, вот, например, она (самая популярная из них): a/b = 2^N/b * a/2^N', где N' - разрядность числа. Выходит, грань между умножением и делением очень тока, а их идентификация довольно сложна. Рассмотрим следующий пример:

main()
{
int a;
printf("%x %x\n",a / 32, a / 10);
}

  Листинг 210 Идентификация оператора "/"

  Результат его компиляции компилятором Microsoft Visual C++ с настройками по умолчанию должен выглядеть так:

main		proc near		; CODE XREF: start+AF p

var_a		= dword	ptr -4

push	ebp
mov	ebp, esp
; Открываем кадр стека

push	ecx
; Резервируем память для локальной переменной

mov	eax, [ebp+var_a]
; Копируем в EAX значение переменной var_a

cdq
; Расширяем EAX до четверного слова EDX:EAX

mov	ecx, 0Ah
; Заносим в ECX значение 0xA

idiv	ecx
; Делим (учитывая знак) EDX:EAX на 0xA, занося частное в EAX
; EAX = var_a / 0xA

push	eax
; Передаем результат вычислений функции printf

mov	eax, [ebp+var_a]
; Загружаем в EAX значение var_a

cdq
; Расширяем EAX до четверного слова EDX:EAX

and	edx, 1Fh
; Выделяем пять младших бит EDX

add	eax, edx
; Складываем знак числа для выполнения округления отрицательных значений
; в меньшую сторону

sar	eax, 5
; Арифметический сдвиг вправо на 5 позиций
; эквивалентен делению числа на 2^5 = 32
; Таким образом, последние четыре инструкции расшифровываются как:
; EAX = var_a / 32
; Обратите внимание: даже при выключенном режиме оптимизации компилятор
; оптимизировал деление

push	eax
push	offset aXX	; "%x %x\n"
call	_printf
add	esp, 0Ch
; printf("%x %x\n", var_a / 0xA, var_a / 32)

mov	esp, ebp
pop	ebp
; Закрываем кадр стека

retn
main		endp

  Листинг 211

  А теперь, засучив рукава и глотнув пустырника (или валерьянки) рассмотрим оптимизированный вариант того же примера:

main		proc near		; CODE XREF: start+AF p
push	ecx
; Резервируем память для локальной переменной var_a

mov	ecx, [esp+var_a]
; Загружаем в ECX значение переменной var_a

mov	eax, 66666667h
; Так, что это за зверское число?!
; В исходном коде ничего подобного и близко не было!

imul	ecx
; Умножаем это зверское число на переменную var_a
; Обратите внимание: именно умножаем, а не делим.
; Однако притворимся на время, что у нас нет исходного кода примера, потому
; ничего странного в операции умножения мы не видим

sar	edx, 2
; Выполняем арифметический сдвиг всех битов EDX на две позиции вправо, что
; в первом приближении эквивалентно его делению на 4
; Однако ведь в EDX находятся старшее двойное слово результата умножения!
; Поэтому, три предыдущих команды фактически расшифровываются так:
; EDX = (66666667h * var_a) >> (32 + 2) = (66666667h * var_a) / 0x400000000
; 
; Понюхайте эту строчку - не пахнет ли паленым? Как так не пахнет?! Смотрите:
; (66666667h * var_a) / 0x400000000 = var_a * 66666667h / 0x400000000 =
; = var_a * 0,10000000003492459654808044433594
; Заменяя по всем правилам математики умножение на деление и одновременно
; выполняя округление до меньшего целого получаем:
; var_a * 0,1000000000 = var_a * (1/0,1000000000) = var_a/10
;
; Согласитесь, от такого преобразования код стал намного понятнее!
; Как можно распознать такую ситуацию в чужой программе, исходный текст которой
; неизвестен? Да очень просто - если встречается умножение, а следом за ним
; сдвиг вправо, обозначающий деление, то каждый нормальный математик сочтет
; своим долгом такую конструкцию сократить, по методике показанной выше!

mov	eax, edx
; Копируем полученное частное в EAX

shr	eax, 1Fh
; Сдвигаем на 31 позицию вправо

add	edx, eax
; Складываем: EDX = EDX + (EDX >> 31)
; Чтобы это значило? Нетрудно понять, что после сдвига EDX на 31 бит вправо
; в нем останется лишь знаковый бит числа
; Тогда - если число отрицательно, мы добавляем к результату деления один,
; округляя его в меньшую сторону. Таким образом, весь этот хитрый код
; обозначает ни что иное как тривиальную операцию знакового деления:
; EDX = var_a / 10
; Не слишком ли много кода для одного лишь деления? Конечно, программа
; здорово "распухает", зато весь этот код выполняется всего лишь за 9 тактов,
; в то время как в не оптимизированном варианте аж за 28!
; /* Измерения проводились на процессоре CLERION с ядром P6, на других
; процессорах количество тактов может отличается */
; Т.е. оптимизация дала более чем трехкратный выигрыш, браво Microsoft!

mov	eax, ecx
; Вспомним: что находится в ECX? Ох, уж эта наша дырявая память, более дырявая
; чем дуршлаг без дна… Прокручиваем экран дизассемблера вверх. Ага, в ECX
; последний раз разгружалось значение переменной var_a

push	edx
; Передаем функции printf результат деления var_a на 10

cdq
; Расширяем EAX (var_a) до четверного слова EDX:EAX

and	edx, 1Fh
; Выбираем младшие 5 бит регистра EDX, содержащие знак var_a

add	eax, edx
; Округляем до меньшего

sar	eax, 5
; Арифметический сдвиг на 5 эквивалентен делению var_a на 32

push	eax
push	offset aXX	; "%x %x\n"
call	_printf
add	esp, 10h
; printf("%x %x\n", var_a / 10, var_a / 32)

retn
main		endp

  Листинг 212

  Ну, а другие компиляторы, насколько они продвинуты в плане оптимизации? Увы, ни Borland, ни WATCOM не умеют заменять деление более быстрым умножением для чисел отличных от степени двойки. В подтверждении тому рассмотрим результат компиляции того же примера компилятором Borland C++:

_main		proc near		; DATA XREF: DATA:00407044 o

push	ebp
mov	ebp, esp
; Открываем кадр стека

push	ebx
; Сохраняем EBX

mov	eax, ecx
; Копируем в EAX содержимое неинициализированной регистровой переменной ECX

mov	ebx, 0Ah
; Заносим в EBX значение 0xA

cdq
; Расширяем EAX до четверного слова EDX:EAX

idiv	ebx
; Делим ECX на 0xA (долго делим - тактов 20, а то и больше)

push	eax
; Передаем полученное значение функции printf

test	ecx, ecx
jns	short loc_401092
; Если делимое не отрицательно, то переход на loc_401092

add	ecx, 1Fh
; Если делимое положительно, то добавляем к нему 0x1F для округления

loc_401092:				; CODE XREF: _main+11 j
sar	ecx, 5
; Сдвигом на пять позиций вправо делим число на 32

push	ecx
push	offset aXX	; "%x %x\n"
call	_printf
add	esp, 0Ch
; printf("%x %x\n", var_a / 10, var_a / 32)

xor	eax, eax
; Возвращаем ноль

pop	ebx
pop	ebp
; Закрываем кадр стека

retn
_main		endp

  Листинг 213

  Идентификация оператора "%". Специальной инструкции для вычисления остатка в наборе команд микропроцессоров серии 80x86 нет, - вместо этого остаток вместе с частным возвращается инструкциями деления DIV, IDIV и FDIVx (см. идентификация оператора "/").

  Если делитель представляет собой степень двойки (2^N = b), а делимое беззнаковое число, то остаток будет равен N младшим битам делимого числа. Если же делимое - знаковое, необходимо установить все биты, кроме первых N равными знаковому биту для сохранения знака числа. Причем, если N первых битов равно нулю, все биты результата должны быть сброшены независимо от значения знакового бита.

  Таким образом, если делимое - беззнаковое число, то выражение a % 2^N транслируется в конструкцию: "AND a, N", в противном случае трансляция становится неоднозначна - компилятор может вставлять явную проверку на равенство нулю с ветвлением, а может использовать хитрые математические алгоритмы, самый популярный из которых выглядит так: DEC x\ OR x, -N\ INC x. Весь фокус в том, что если первые N бит числа x равны нулю, то все биты результата кроме старшего, знакового бита, будут гарантированно равны одному, а OR x, -N принудительно установит в единицу и старший бит, т.е. получится значение, равное, -1. А INC -1 даст ноль! Напротив, если хотя бы один из N младших битов равен одному, заема из старших битов не происходит и INC x возвращает значению первоначальный результат.

  Продвинутые оптимизирующие компиляторы могут путем сложных преобразований заменять деление на ряд других, более быстродействующих операций. К сожалению, алгоритмов для быстрого вычисления остатка для всех делителей не существует и делитель должен быть кратен k * 2^t, где k и t - некоторые целые числа. Тогда остаток можно вычислить по следующей формуле: a % b = a % k*2^t = a -((2^N/k * a/2^N) & -2^t)*k

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

  Рассмотрим следующий пример:

main()
{

int a;
printf("%x %x\n",a % 16, a % 10);
}

  Листинг 214 Идентификация оператора "%"

  Результат его компиляции компилятором Microsoft Visual C++ с настройками по умолчанию должен выглядеть так:

main		proc near		; CODE XREF: start+AF p

var_4		= dword	ptr -4
push	ebp
mov	ebp, esp
; Открываем кадр стека

push	ecx
; Резервируем память для локальной переменной

mov	eax, [ebp+var_a]
; Заносим в EAX значение переменной var_a

cdq
; Расширяем EAX до четвертного слова EDX:EAX

mov	ecx, 0Ah
; Заносим в ECX значение 0xA

idiv	ecx
; Делим EDX:EAX (var_a) на ECX (0xA)


push	edx
; Передаем остаток от деления var_a на 0xA функции printf

mov	edx, [ebp+var_a]
; Заносим в EDX значение переменной var_a

and	edx, 8000000Fh
; "Вырезаем" знаковый бит и четыре младших бита числа
; в четырех младших битах содержится остаток от деления EDX на 16

jns	short loc_401020
; Если число не отрицательно, то прыгаем на loc_401020

dec	edx
or	edx, 0FFFFFFF0h
inc	edx
; Последовательность сия, как говорилось выше характера для быстрого
; расчета отставка знакового числа
; Следовательно, последние шесть инструкций расшифровываются как:
; EDX = var_a % 16

loc_401020:				; CODE XREF: main+19 j
push	edx
push	offset aXX	; "%x %x\n"
call	_printf
add	esp, 0Ch
; printf("%x %x\n",var_a % 0xA, var_a % 16)

mov	esp, ebp
pop	ebp
; Закрываем кадр стека
retn
main		endp

  Листинг 215

  Любопытно, что оптимизация не влияет на алгоритм вычисления остатка. Увы, ни Microsoft Visual C++, ни остальные известные мне компиляторы не умеют вычислять остаток умножением.

  Идентификация оператора "*". В общем случае оператор "*" транслируется либо в машинную инструкцию "MUL" (беззнаковое целочисленное умножение), либо в "IMUL" (целочисленное умножение со знаком), либо в "FMULx" (вещественное умножение). Если один из множителей кратен степени двойки, то "MUL" ("IMUL") обычно заменяется командой битового сдвига влево "SHL" или инструкцией "LEA", способной умножать содержимое регистров на 2, 4 и 8. Обе последних команды выполняются за один такт, в то время как MUL требует в зависимости от модели процессора от двух до девяти тактов. К тому же LEA за тот же такт успевает сложить результат умножение с содержимым регистра общего назначения и/или константой в придачу. Это позволяет умножать на 3, 5 и 9 просто добавляя к умножаемому регистру его значение. Ну, разве это не сказка? Правда, у LEA есть один недочет - она может вызывать остановку AGI, в конечном счете "съедающую" весь выигрыш в быстродействии на нет.

  Рассмотрим следующий пример:

main()
{

int a;
printf("%x %x %x\n",a * 16, a * 4 + 5, a * 13);
}

  Листинг 216 Идентификация оператора "*"

  Результат его компиляции компилятором Microsoft Visual C++ с настройками по умолчанию должен выглядеть так:

main		proc near		; CODE XREF: start+AF p

var_a		= dword	ptr -4

push	ebp
mov	ebp, esp
; Открываем кадр стека

push	ecx
; Резервируем место для локальной переменной var_a

mov	eax, [ebp+var_a]
; Загружаем в EAX значение переменной var_a

imul	eax, 0Dh
; Умножаем var_a на 0xD, записывая результат в EAX

push	eax
; Передаем функции printf произведение var_a * 0xD

mov	ecx, [ebp+var_a]
; Загружаем в ECX значение var_a

lea	edx, ds:5[ecx*4]
; Умножаем ECX на 4 и добавляем к полученному результату 5, записывая его в EDX
; И все это выполняется за один такт!

push	edx
; Передаем функции printf результат var_a * 4 + 5

mov	eax, [ebp+var_a]
; Загружаем в EAX значение переменной var_a

shl	eax, 4
; Умножаем var_a на 16

push	eax
; Передаем функции printf произведение var_a * 16

push	offset aXXX	; "%x %x %x\n"
call	_printf
add	esp, 10h
; printf("%x %x %x\n", var_a * 16, var_a * 4 + 5, var_a * 0xD)

mov	esp, ebp
pop	ebp
; Закрываем кадр стека
retn
main		endp

  Листинг 217

  За вычетом вызова функции printf и загрузки переменной var_a из памяти на все про все требуется лишь три такта процессора. А что будет, если скомпилировать этот пример с ключиком "/Ox"? А будет вот что:

main		proc near		; CODE XREF: start+AF p
push	ecx
; Выделяем память для локальной переменной var_a

mov	eax, [esp+var_a]
; Загружаем в EAX значение переменной var_a

lea	ecx, [eax+eax*2]
; ECX = var_a * 2 + var_a = var_a * 3

lea	edx, [eax+ecx*4]
; EDX = (var_a * 3)* 4 + var_a = var_a * 13!
; Вот так компилятор ухитрился умножить var_a на 13,
; причем всего за один (!) такт. Да, обе инструкции LEA прекрасно спариваются
; на Pentium MMX и Pentium Pro!

lea	ecx, ds:5[eax*4]
; ECX = EAX*4 + 5

push	edx
push	ecx
; Передаем функции printf var_a * 13 и var_a * 4 +5

shl	eax, 4
; Умножаем var_a на 16

push	eax
push	offset aXXX	; "%x %x %x\n"
call	_printf
add	esp, 14h
; printf("%x %x %x\n", var_a * 16, var_a * 4 + 5, var_a * 13)

retn
main		endp

  Листинг 218

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

  Другие компиляторы так же используют LEA для быстрого умножения чисел. Вот, к примеру, Borland поступает так:

_main		proc near		; DATA XREF: DATA:00407044 o
lea	edx, [eax+eax*2]
; EDX = var_a*3

mov	ecx, eax
; Загружаем в ECX неинициализированную регистровую переменную var_a

shl	ecx, 2
; ECX = var_a * 4

push	ebp
; Сохраняем EBP

add	ecx, 5
; Добавляем к var_a * 4 значение 5
; Borland не использует LEA для сложения. А жаль…

lea	edx, [eax+edx*4]
; EDX = var_a + (var_a *3) *4 = var_a * 13
; А вот в этом Borland и MS единодушны 

mov	ebp, esp
; Открываем кадр стека
; Да, да… вот так посреди функции и открываем…
; Выше, кстати, "потерянная" команда push EBP

push	edx
; Передаем printf произведение var_a * 13

shl	eax, 4
; Умножаем ((var_a *4) + 5) на 16
; Что такое?! Да, это глюк компилятора, посчитавшего: раз переменная var_a
; неинициализирована, то ее можно и не загружать…

push	ecx
push	eax
push	offset aXXX	; "%x %x %x\n"
call	printf
add	esp, 10h
xor	eax, eax
pop	ebp
retn
_main		endp

  Листинг 219

  Хотя "визуально" Borland генерирует более "тупой" код, его выполнение укладывается в те же три такта процессора. Другое дело WATCOM, показывающий удручающе отсталый результат на фоне двух предыдущих компиляторов:

main		proc near
push	ebx
; Сохраняем EBX в стеке

mov	eax, ebx
; Загружаем в EAX значение неинициализированной регистровой переменной var_a

shl	eax, 2
; EAX = var_a * 4

sub	eax, ebx
; EAX = var_a * 4 - var_a = var_a * 3
; Вот каков WATCOM! Сначала умножает "с запасом", а потом лишнее отнимает!

shl	eax, 2
; EAX = var_a * 3 * 4 = var_a * 12

add	eax, ebx
; EAX = var_a * 12 + var_a = var_a * 13
; Вот так, да? Четыре инструкции, в то время как "ненавистный" многим
; Microsoft Visual C++ вполне обходится и двумя!

push	eax
; Передаем printf значение var_a * 13

mov	eax, ebx
; Загружаем в EAX значение неинициализированной регистровой переменной var_a

shl	eax, 2
; EAX = var_a * 4

add	eax, 5
; EAX = var_a * 4 + 5 
; Ага! Пользоваться LEA WATCOM то же не умеет!

push	eax
; Передаем printf значение var_a * 4 + 5

shl	ebx, 4
; EBX = var_a * 16

push	ebx
; Передаем printf значение var_a * 16

push	offset aXXX	; "%x %x %x\n"
call	printf_
add	esp, 10h
; printf("%x %x %x\n",var_a * 16, var_a * 4 + 5, var_a*13)

pop	ebx

retn
main_		endp

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

  ::Комплексные операторы. Язык Си\Си++ выгодно отличается от большинства своих конкурентов поддержкой комплексных операторов: x= (где x - любой элементарный оператор), ++ и - -. Комплексные операторы семейства "a x= b" транслируются в "a = a x b" и они идентифицируются так же, как и элементарные операторы (см. "элементарные операторы"). Операторы "++" и "--": в префиксной форме они выражаются в тривиальные конструкции "a = a +1" и "a = a - 1" не представляющие для нас никакого интереса, но вот постфиксная форма - дело другое.

  Продолжение следует... © Крис Касперски