отладка программ АСДиП ЯП ЯиМП 3GL 4GL 5GL технологии программирования

Отладка программ

Отладка средствами языка ассемблера х86
и окна Disassembly отладчика Visual C++

Манипуляции с данными

Манипуляции с указателями
Сравнение и проверка
Инструкции переходов и ветвлений
Циклы
Манипуляции со строками
Общие конструкции языка ассемблера
Доступ через регистр FS
Создание или уничтожение SEH-кадра.
Ссылки на структуры и классы
Полный пример

AND логическое И
OR логическое ИЛИ-(включающее)

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

NOT отрицание с поразрядным дополнением до 1
NEG отрицание с поразрядным дополнением до 2

Инструкции NOT и NEG иногда вызывают некоторое замешательство, потому что по виду они похожи, но, конечно, не выполняют одну и ту же операцию. Инструкция NOT — поразрядная операция, которая устанавливает каждую двоичную 1 в 0 и каждый двоичный 0 в 1. Инструкция NEG выполняет вычитание операнда из 0. Следующий фрагмент кода показывает различия между этими двумя инструкциями:

void NOTExample { void )

{

_asm {

MOV EAX , OFFh

MOV EBX , 1

NOT EAX // EAX теперь содержит OFFFFFFOOh.

NOT EBX // ЕВХ теперь содержит OFFFFFFFEh.

}

}

void NEGExample ( void ) (

_asm

{

MOV EAX , OFFh MOV EBX , 1

NEG EAX // EAX теперь содержит OFFFFFFOlh ( 0 - OFFh ).

NEC EBX // EBX теперь содержит OFFFFFFFFh ( 0 - 1 ).

}

}

XOR логическое ИЛИ (исключающее)

Инструкция XOR — это самый быстрый способ обнулить значение. XOR с двумя операндами установит каждый разряд в 1, если одинаковые разряды в каждом операнде различны. Если все разряды одинаковы, то результат равен 0. Поскольку операция

XOR ЕАХ,ЕАХ

выполняется быстрее, чем

MOV EAX,0

(потому что первая занимает меньшее количество машинных тактов), компиляторы Microsoft используют XOR для обнуления регистров.

INC инкремент (увеличение) на 1
DEC декремент (уменьшение) на 1

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

SHL сдвиг влево, умножение на 2
SHR сдвиг вправо, деление на 2

При двоичных манипуляциях поразрядные сдвиги выполняются быстрее, чем соответствующие инструкции умножения и деления в CPU x86. Эти инструкции родственны поразрядным С-операциям « и », соответственно.

DIV беззнаковое деление
MUL беззнаковое умножение

Эти простые с виду инструкции фактически немного странны. Обе инструкции выполняют беззнаковые действия на регистре ЕАХ. Но вывод неявно использует регистр EDX. Старшие байты двойного слова и большие по величине множители помещаются в регистр EDX. Инструкция DIV сохраняет остаток в EDX, а частное — в ЕАХ. Обе инструкции оперируют значением из ЕАХ, используя в качестве второго операнда только значения из регистра или из памяти.

IDIV деление со знаком
IUML умножение со знаком

Эти инструкции подобны инструкциям DIV и MUL, за исключением того, что они обращаются с операндами как со знаковыми значениями. Старшие байты двойного слова и большие по величине множители помещаются в регистр EDX. Инструкция IDIV сохраняет остаток в EDX, а частное — в ЕАХ. Обе инструкции оперируют значением из ЕАХ, используя в качестве второго операнда только значения из регистра или из памяти. Инструкция IMUL иногда имеет три операнда. Первый операнд — целевой (в нем сохраняется результат), а два последних — исходные операнды. В наборе инструкций х86 IMUL — единственная инструкция с тремя операндами.

LOCK устанавливает сигнальный префикс LOCK#

LOCK — не реальная инструкция, а скорее префикс к другим инструкциям. Префикс LOCK сообщает CPU, что действие с памятью, к которой обращается следующая инструкций, должно быть атомарной операцией, когда CPU, выполняющий такую инструкцию, блокирует шину памяти и тем самым запрещает любому другому CPU в системе обращаться к этой памяти.

MOVSX пересылка с расширением знакового разряда
MDVZX пересылка с расширением нулем

Эти две инструкции копируют значения меньшего размера в значения большего размера и указывают, как в больших значениях заполняются старшие разряды. MOVSX указывает, что знаковое значение исходного операнда будет расширено на все верхние разряды регистра-приемника (т. е. регистра результата). MOVZX заполняет, верхние разряды регистра-приемника нулями. Эти две инструкции предназначены для наблюдений за значениями при прослеживании ошибок в знаках.

Манипуляции с указателями

LEA загрузить эффективный адрес

LEA загружает целевой регистр адресом исходного операнда. Следующий фрагмент кода содержит два примера с инструкцией LEA. Первый показывает, как следует назначать адрес целому указателю, а второй — как извлекать адрес локального символьного массива с помощью инструкции LEA и передавать адрес как параметр API-функции GetwindowsDirectory.

void LEAExamples ( void )

{

int * pint ;

int iVal ;

// Следующие инструкции эквивалентны С-коду

// pint = siVal ;.

_asm

{

LEA EAX , iVal

MOV [pint] , EAX

}

///////////////////////////////////////////////////////////////////

char szBuff [ MAX_PATH ] ;

// Другой пример доступа к указателю через LEA.

// Эта последовательность инструкций идентична С-коду

// GetWindowsDirectory ( szBuff , МАХ_РАТН ) ;.

_asm

{

PUSH 104h // Поместить МАХ_РАТН в стек как

// второй параметр.

LEA ЕСХ , szBuff // Получить адрес szBuff.

PUSH ECX // Поместить адрес szBuff в стек как

// первый параметр.

CALL DWORD PTR [GetWindowsDirectory]

}

}

Сравнение и проверка

СМР сравнить два операнда

Инструкция СМР сравнивает первый и второй операнды, вычитая второй из первого, сбрасывая результаты и устанавливая соответствующие флаги в регистре EFLAGS. Можно представлять инструкцию СМР как условную часть С-оператора if. В табл. 6.4 приведены различные флаги и значения, которым они соответствуют при выполнении инструкции СМР.

Таблица 6.4. Результирующие значения и установки флажков инструкции СМР

Результат (сравнения первого операнда со вторым)	Установки флажков регистра EFLAGS	Установки флажков руководства Intel
Равно Меньше чем	ZR = 1 PL != OV	ZF=1 SF != OF

Больше чем	ZR = 0 and PL = 0V	ZF = 0 и SF = OF
Не равно	ZR = 0	ZF = 0
Больше чем или равно	PL = OV	SF = OF
Меньше чем или равно	ZR = 1 или PL != 0V	ZF = 1 или SF != OF

TEST логическое сравнение

Инструкция TEST выполняет поразрядную операцию "логическое И" над своими операндами и устанавливает флажки PL, ZR и РЕ (SF, ZF и PF для руководств Intel) соответственно. Инструкция TEST проверяет, было ли установлено разрядное значение.

Инструкции переходов и ветвлений

JMP абсолютный переход

Как указано в названии, JMP передает управление по абсолютному адресу.

JE переход, если равно
JL переход, если меньше чем
JG переход, если больше чем
JNE переход, если не равно
JGE переход, если больше или равно
OLE переход, если меньше или равно

От инструкций СМР и TEST немного пользы, если программист не имеет возможности воздействовать на их результаты. Условные переходы позволяют выполнять соответствующие ветвления программы. Показанные выше инструкции — это наиболее общие условные переходы, с которыми вы встретитесь в окне Disassembly, хотя всего существует более трех десятков (точнее — 31) различных условных переходов, многие из которых выполняют те же самые действия за исключением того, что в мнемонике используется слово "NOT". Например, инструкция JLE (переход, если меньше или равно) имеет тот же код операции, что JNG (переход, если не больше чем). Работая с другим дизассемблером (не из отладчика Visual C++), можно увидеть иные инструкции. Чтобы расшифровывать все инструкции переходов, можно найти jcc-коды в руководствах Intel.

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

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

void JumpExamples ( int i )

{

// Здесь показан оператор С-кода. Заметьте, что условие записано как

// "i > 0", но компилятор генерирует противоположное условие. Код

// ассемблера, который показан в следующей секции, похож на тот,

// что генерирует компилятор.

// Разные методы оптимизации генерируют различный код.

// if ( i > 0 )

// {

// printf ( "i > 0\n" ) ;

// }

char szGreaterThan[] = "i > 0\n" ;

_asm

{

CMP i , 0 // Сравнить i с 0 вычитанием (i - 0).

JLE JE_LessThanOne // Если i меньше чем или равно 0, перейти

// к метке.

PUSH i // Поместить параметр в стек.

LEA ЕАХ , szGreaterThan // Поместить в стек форматную строку.

PUSH ЕАХ CALL DWORD PTR [printf] // Вызвать printf. Заметьте, что printf,

// вероятно, приходит из DLL, потому что

// вызов выполняется через указатель.

ADD ESP ,8 // для printf действует соглашение _cdecl,

поэтому

// нужно очистить стек в вызывающей

// программе.

JE_LessThanOne: //Во встроенном ассемблере можно

// перейти к любой С-метке.

}

////////////////////////////////////////////////////////////////////

// Взять абсолютное значение параметра и снова проверить.

// С-код:

// int у = abs ( i ) ;

// if. ( у >=5 )

// {

// printf ( "abs(i) >= 5\n" ) ;

// }

// else

// {

// printf ( "abs(i) < 5\n" ) ;

// }

char szAbsGTEFive [] = "abs(i) >= 5\n" ;

char szAbsLTFive[] = "abs(i) < 5\n" ;

_asm

{

MOV EBX , i // Переместить значение i в ЕВХ.

СМР ЕВХ , 0 // Сравнить ЕВХ с 0 (ЕВХ - 0).

JG JE_PosNum // Если результат больше 0, то ЕВХ

// содержит положительное значение.

NEG ЕВХ // Преобразовать отрицательное в положительное.

JE_PosNum:

СМР ЕВХ , 5 // Сравнить ЕВХ с 5 (ЕВХ - 5).

JL JE_LessThan5 // Переход, если меньше 5.

LEA ЕАХ , szAbsGTEFive // Получить в ЕАХ указатель на правильную

// форматную строку.

JMP JE_DoPrintf // Перейти к вызову printf.

JE_LessThan5:

LEA ЕАХ , szAbsLTFive // Получить в ЕАХ указатель на правильную

// форматную строку.

JE_DoPrintf:

PUSH ЕАХ // Поместить строку в стек.

CALL DWORD PTR [printf] // Напечатать ее.

ADD ESP , 4 .. // Восстановить стек.

}

Нетрудно видеть, что результат в первом примере правилен. Идея состоит в" том, что выгоднее проверить противоположное условие и затем выполнить переход, чем сначала выполнить переход, проверить условие внутри оператора if и потом перейти обратно.

JА переход, если выше
JBE переход, если ниже или равно
JC переход, если есть перенос
JNC переход, если нет переноса
JNZ переход, если не О
JZ переход, если О

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

Циклы

LOOP цикл по счетчику ЕСХ

Нельзя слишком сосредотачиваться на инструкции LOOP, потому что компиляторы Microsoft генерируют их не так много. Однако в некоторых частях ядра операционной системы (которые выглядят так, как если бы разработчики Microsoft написали их на языке ассемблера) их иногда можно увидеть. Применять инструкцию LOOP довольно просто. Установите ЕСХ равным числу шагов цикла, и затем выполните блок кода. Сразу после блока кода разместите инструкцию LOOP. Если ЕСХ не равен нулю, то она выполнит декремент ЕСХ и затем перейдет к вершине блока. Когда ЕСХ достигает нуля, инструкция LOOP пропускается (и выполняется следующая за ней инструкция).

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

void LoopingExample ( int q )

{

// С-код:

// for ( ; q < 10 ; q++ )

// {

// printf ( "q = %d\n" , q ) ;

// }

char szEmt[] = "q = %d\n" ;

_asm

{

JMP LE_CompareStep // При первом проходе выполнить

// прямую проверку 10.

LE_IncrementStep:

INC q // Инкремент q.

LE_CompareStep:

CMP q , OAh // Сравнить q с 10.

JGE LE_End // Если q >= 10, эта функция выполнена.

MOV ЕСХ , DWORD PTR [q] // Переместить значение q в ЕСХ.

PUSH ЕСХ // Поместить значение в стек.

LEA ЕСХ , szFmt // Получить форматную строку.

PUSH ЕСХ // Поместить форматную строку в стек.

CALL DWORD PTR [printf] // Напечатать текущую итерацию.

ADD ESP , 8 // Очистить стек.

JMP LE_IncrementStep // Инкремент q, и начать сначала.

LE_End: // Цикл выполнен.

}

}

Манипуляции со строками

Intel CPU обладают большими возможностями для манипуляций со строками, т. е. поддерживают обработку больших участков памяти в отдельной инструкции. Все рассмотренные здесь строчные инструкции имеют несколько мнемоник, которые можно найти в справочных руководствах Intel. Однако окно Disassembly в Visual C++ всегда дизассемблирует строчные инструкции только в те формы, которые показаны ниже. Все эти инструкции могут работать на областях памяти размером в байт, слово и двойное слово.

MOVS перемещают данные из строки в строку

Инструкция MOVS перемещает адрес памяти из регистра ESI в регистр EDI. Эта инструкция работает только на значениях, на которые указывают ESI и EDI. Инструкцию MOVS можно представить себе как реализацию С-функции memcpy. Окно Disassembly из Visual C++ всегда показывает размер операции со спецификатором размера, так сразу видно, сколько памяти было перемещено. После того как перемещение заканчивается, регистры ESI и EDI инкрементируются или декрементируются, в зависимости от флажка направления (DF) в регистре EFLAGS (отображаемого как поле UP в окне Registers Visual C++). Если поле UP равно 0, то регистры инкрементируются, а если равно 1, регистры декрементируются. Величина инкремента и декремента зависит от размера памяти, с которой работает операция: 1 — для байт, 2 — для слов и 4 — для двойных слов.

SCAS сканировать строку

Инструкция SCAS сравнивает значение по адресу памяти, указанному в регистре EDI, со значением в регистрах AL, АХ или ЕАХ (в зависимости от требуемого размера). Результаты сравнения устанавливают значения различных флажков в регистре EFLAGS. Установки флажков — те же, что показаны в табл. 6.4. Если вы сканируете строку в поисках NULL-терминатора (пустого указателя), то инструкцию SCAS можно использовать, чтобы дублировать возможности С-функции strien. Подобно инструкции MOVS, SCAS выполняет автоинкремент или автодекремент регистра EDI.

STOS сохранить строку

Инструкция STOS сохраняет значение регистров AL, АХ или ЕАХ (в зависимости от требуемого размера) по адресу, указанному регистром EDI. Инструкция STOS похожа на С-функцию memset. Подобно инструкциям MOVS и SCAS, инструкция STOS автоинкрементирует или автодекрементирует регистр EDI.

CMPS сравнить строки

Инструкция CMPS сравнивает два строчных значения и устанавливает соответствующие флажки в EFLAGS. Тогда как SCAS выполняет сравнения символов в единственной строке, CMPS проходит символы в двух строках. Инструкция CMPS похожа на С-функцию memcmp. Подобно остальным строчным манипуляторам, инструкция CMPS сравнивает значения различных размеров, а также выполняет автоинкремент и автодекремент указателей обеих строк.

ВЕР повторять по счетчику в EСХ
REPE повторять, пока равно или счетчик ЕСХ не станет равен 0
REPNE повторять, пока не равно или счетчик ЕСХ не станет равен 0

Строчные инструкции, хотя и удобны, но не много стоят, когда манипулируют элементом только один раз. Префиксы повторения позволяют выполнять строчные инструкции заданное (в ЕСХ) количество раз или пока не будет выполнено указанное условие. При пошаговом проходе окна Disassembly командой Step Into выполнение такой инструкции повторяется необходимое число раз. Если же при этом используется команда Step Over, то такая инструкция не выполняется повторно. При отладке можно с помощью команды Step Into проверять строки в регистрах ESI или EDI. Другой прием: при поиске аварийного останова в строчной инструкции с префиксом повторения нужно взглянуть на регистр ЕСХ, чтобы увидеть, на какой итерации случился останов.

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

void MemCPY ( char * szSrc , char * szDest , int iLen )

{

_asm

{

MOV ESI , szSrc // Установить исходную строку.

MOV EDI , szDest // Установить целевую строку ng.

MOV ЕСХ , iLen // Установить длину копирования.

// Копировать немедленно!

REP MOVS BYTE PTR [EDI] , BYTE PTR [ESI]

}

}

int StrLEN (char * szSrc )

{

int iReturn ; _asm

{

XOR EAX , EAX // Обнулить ЕАХ.

MOV EDI , szSrc // Поместить проверяемую строку в EDI.

MOV ECX , 0FFFFFFFFh // Максимальное число проверяемых

// символов.

REPNE SCAS BYTE PTR [EDI] // Сравнивать, пока ЕСХ не станет

// равным 0 или не будет найден конец

// строки .

СМР ЕСХ ,0 // Если ЕСХ равен 0, то

JE StrLEN_NoNull // в строке не был найден NULL.

NOT ECX // Преобразовать ЕСХ в положительное число,

// поскольку он был просчитан.

DEC ЕСХ ' // Подсчет для Попадания на NULL.

MOV EAX , ЕСХ // Возврат счета.

JMP StrLen_Done .// Возврат. StrLENJNoNull:

MOV EAX , OFFFFFFFFh // Поскольку NULL не был найден,

И возвратить -1.

StrLEN_Done:

}

_asm MOV iReturn , EAX ;

return ( iReturn ) ;

}

void MemSET ( char * szDest , irit iVal , int iLen )

{ _asm

{

MOV EAX , iVal // EAX содержит полное значение.

MOV EDI , szDest // Переместить строку в EDI.

MOV ECX , iLen // Переместить счет в ЕСХ.

REP STOS BYTE PTR [EDI] // Заполнить память.

}

}

int MemCMP ( char * szMeml , char * szMem2 , int iLen )

{

int iReturn ;

_asm

{

MOV ESI , szMeml // ESI содержит первый блок памяти.

MOV EDI , szMem2 // EDI содержит второй блок памяти.

MOV ECX , iLen // Максимальное число байт для сравнения

// Сравнить блоки памяти.

REPE CMPS BYTE PTR.

[ESI], BYTE PTR [EDI]

JL MemCMP_LessThan // Если szSrc < szDest

JG MemCMP_GreaterThan // Если szSrc > szDest

// Блоки памяти равны.

XOR EAX', EAX // Возвратить 0.

JMP MemCMP_Done

MemCMP_Les sThan:

MOV EAX , 0FFFFFFFFh // Возвратить -1.

JMP MemCMP_Done

MemCMP_GreaterThan:

MOV EAX , 1 // Возвратить 1.

JMP MemCMP_Done

XemCMP_Done:

}

_asm MOV iReturn ,

EAX return ( iReturn ) ;

}

Общие конструкции языка ассемблера

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

Доступ через регистр FS

Регистру FS в операционных системах Win32 отведена специальная роль: в нем хранится указатель на блок информации потока (Thread Information Block — TIB). TIB называют также блоком среды потока (Thread Environment Block — ТЕВ). TIB содержит все специфические данные, которые позволяют операционной системе выполнять прямой доступ к потоку. Эти специфические поточные данные включают все цепочки структурированной обработки исключений (SEH), локальное хранилище потока и другую необходимую внутреннюю информацию. Подробные сведения о SEH-цепочках можно найти в главе 9. Пример с локальным хранилищем потока рассмотрен в главе 15 при обсуждении Memstress-расширений.

Блок TIB хранится в специальном сегменте памяти, и когда операционной системе нужен доступ к TIB, она переводит содержимое регистра FS и смещение в нормальный линейный адрес. Инструкция, обращающаяся к регистру FS, может реализовать одну из следующих операций: создание или уничтожение SEH-кадра, обращение к блоку TIB или к локальному хранилищу потока.

Создание или уничтожение SEH-кадра

Первые инструкции после установки кадра стека часто похожи на следующий фрагмент, который является стандартным кодом, начинающим _try-блок. Первый узел в цепочке SEH-обработчиков расположен в TIB со смещением 0. В показанном ниже фрагменте кода дизассемблера компилятор помещает в стек значение данных и указатель на функцию _except_ handlers. Первая инструкция MOV обращается к TIB. Смещение 0 указывает, что узел добавляется к вершине цепочки исключений. Две последних инструкции показывают, каким образом код перемещает фактический узел в цепочку

PUSH 004060d0

PUSH 004014a0

MOV EAX , FS:[00000000]

PUSH EAX

MOV DWORD PTR FS:[0] , ESP

Хотя этот пример довольно прост и понятен, компилятор не всегда производит такой аккуратный код. Иногда он расширяет область создания SEH-кадра. В зависимости от флажков генерации кода и оптимизации, компилятор перемещает окружающие инструкции так, чтобы усилить преимущества конвейерной обработки CPU. Следующий пример дизассемблерного кода, в котором загружены символы библиотеки KERNEL32.DLL, демонстрирует запуск функции IsBadReadPtr из Microsoft Windows NT 4.

MOV EAX , FS:[00000000h]

PUSH EBP

MOV EBP , ESP

PUSH 0FFh

PUSH 77F3DlE8h

PUSH _except_handler3

PUSH EAX

MOV EAX , [BaseStaticServerData];

MOV DWORD PTR FS:[0000000h] , ESP

Как показывает следующий фрагмент кода, уничтожение SEH-кадра намного проще, чем его создание. Основной момент, который нужно запомнить, это то, что запись FS: [0] означает доступ к SEH.

MOV ЕСХ , DWORD PTR [EBP-lOh] .

MOV DWORD PTR FS:[0] , ECX

Организация доступа к TIB

Значение в FS:[18] является линейным адресом структуры TIB. В следующем фрагменте кода реализация GetCurrentThreadid (из Windows 2000) получает сначала линейный адрес TIB-блока и затем, в позиции со смещением 0x24 (в Т1В-блоке) — фактический идентификатор (ID) потока.

GetCurrentThreadid:

MOV EAX , FS:[00000018h]

MOV EAX , DWORD PTR [EAX+024h]

RET

Доступ к локальному хранилищу потока

Локальное хранилище потока (Thread Local Storage — TLS) — это механизм Win32, который позволяет каждому потоку (в многопоточной ситуации) иметь свой собственный экземпляр глобальных переменных. Указатель на массив локального хранилища потока размещается в структуре TIB со смещением 0х2С. Следующий фрагмент кода дизассемблера показывает, как получить доступ к указателю локального хранилища потока.

MOV ЕСХ , DWORD PTR FS:[2Ch]

MOV EDX , DWORD PTR [ECX+EAX*4]

Ссылки на структуры и классы

Поскольку структуры и классы играют значительную роль в Windows-разработках, потратим некоторое время на обсуждение проблем доступа к соответствующей памяти. Хотя со структурами и классами удобно иметь дело на языках высокого уровня, на уровне языка ассемблера они, вообще говоря, не существуют. На языках высокого уровня структура и класс — это просто краткие способы указывать смещения в "блобе" памяти.

"Блоб" (Binary Large Object — BLOB). Во-первых, этим термином разработчики баз данных обозначают любой произвольный битовый блок, который следует сохранить в БД, например картинку или звуковой файл. Существенно, что BLOB является объектом, который не может быть интерпретирован средствами СУБД. Во-вторых, употребляется в значении глагола (to blob) и в этом случае переводится как "послать огромный e-mail", обычно в ответ на нанесенное серьезное оскорбление. Часто используется в качестве умеренной угрозы. Например: "If that program crashes again, I'm going to BLOB the core dump to you" (Если эта программа опять "грохнется", я тебе вышлю дамп ядра по мэйлу). См. Файл Жаргона (The Jargon File). -Ред.

Компиляторы, в основном, размещают память для пользовательских структур и классов так, как указано в спецификациях. Иногда компилятор дополняет поля заполнителями, чтобы сохранять их на естественных границах памяти, которые для CPU x86 кратны 4 или 8 байтам.

Ссылки на структуры и классы обозначаются регистром и смещением памяти. В структуре Mystruct, приведенной ниже, комментарии справа показывают смещение каждого элемента от начала структуры. За определением MyStruct расположены различные способы доступа к полям структуры.

typedef struct tag_MyStruct

{

DWORD dwFirst ; // 0-байтное смещение

char szBuff[ 256 ] ; // 4-байтное смещение

int iVal ; // 260-байтное смещение

} MyStruct , * PMyStruct ;

void FillStruct ( PMyStruct pSt )

{

char szName[] = "Pam\n" ;

_asm

{

MOV EAX , pSt // Поместить pSt в EAX. Ниже используются прямые

// смещения на языке ассемблера, чтобы показать,

// на что они похожи в дизассемблере.

// Встроенный ассемблер позволяет применять

// нормальные ссылки формата <struct>.<field>.

// С-код: pSt->dwFirst = 23 ;

MOV DWORD PTR [EAX] , 17h.

// С-код: pSt->iVal = 0x33 ;

MOV DWORD PTR [EAX + 0104h] , 0x33

// С-код: strcpy ( pSt->szBuff , szName ) ;

LEA ECX , szName // Поместить szName в стек.

PUSH ECX .

LEA ECX , [EAX + 4] //. Получить доступ к полю szBuff.

PUSH ECX

CALL strcpy

ADD ESP ,8 // strcpy есть _cdecl функция.

// С-код: pSt->szBuff[ 1 ] = 'A' ;

MOV BYTE PTR [EAX + 5] , 41h

// С-код: printf ( pSt->szBuff ) ;

MOV EAX , pSt // Получить pSt обратно. EAX был разрушен

// при обращении к strcpy.

LEA ECX , [EAX + 4]

PUSH ECX

CALL DWORD PTR [printf]

ADD ESP , 4 // printf есть _cdecl-функция.

}

}

Полный пример

Представив все важные части языка Intel-ассемблера, обратимся к полному примеру одной из API-функций операционных систем Win32. В листинге 6.2 показан полностью прокомментированный дизассемблерный код функции IstrcpyA из библиотеки KERNEL32.DLL пакета обслуживания Service Pack 4 операционной системы Windows NT 4. Функция IstrcpyA копирует одну строку в другую. Эту функция выбрана потому, что она показывает понемногу все, что обсуждалось до сих пор в этой главе, а также потому, что цель этой функции легко понять. Комментарии, выделенные точками с запятой, делают их настолько подробными, насколько это возможно.

Листинг 6-2. IstrcpyA- полный пример на языке ассемблера

; Прототип функции:

; LPTSTR Istrcpy ( LPTSTR IpStringl , LPCTSTR lpString2 )

IstrcpyA:

; Начать подготовку к установке SEH-кадра.

77F127E6: MOV EAX , ES:[00000000h]

; Установить регулярный кадр стека.

77F127EC: PUSH EBP

77F127ED: MOV EBP , ESP

; Продолжить установку SEH-кадра.

77F127EF: PUSH OFFh

77F127F1: PUSH 77F3CD48h

77F127F6: PUSH _except_handler3

77F127FB: PUSH EAX

77F127FC: MOV DWORD PTR FS:[00000000h] , ESP

; Сохранить 12 байтов для локальных переменных.

77F12803: SUB ESP , 00Ch

; Сохранить значения регистра, которые будут разрушены

; как часть этой функции

77F12806: PUSH EBX

77F12807: PUSH ESI

77F12808: PUSH EDI

Сохранить текущую вершину стека в локальной переменной.

Эта строка - также часть установки SEH.

7F12809: MOV DWORD PTR [EBP-018h] , ESP

Инициализировать эту локальную переменную к 0. Эта строка указывает,

что функция входит в блок _try.

77F1280C: MOV DWORD PTR [EBP-004h] , 00000000h

Первый шаг после установки должен получить длину строки

копирования. Строка копирования - второй параметр.

Переместить второй параметр (строку, которая будет скопирована) в EDI.

77F12813: MOV EDI , DWORD PTR [EBP+OOCh]

Istrcpy будет просматривать 4,294,967,295 байтов до NULL-терминатора.

EDX используется позже со значением -1, а здесь он инициализируется.

Помните, что REPNE SCAS использует регистр ЕСХ как счетчик цикла.

77F12816: MOV EDX , FFFFFFFFh

77F1281B: MOV ЕСХ , EDX

; Обнуление EAX, так что SCAS будет искать символ NULL.

77F1281D: SUB EAX , EAX ; Поиск символа NULL.

77F1281F: REPNE SCAS BYTE PTR [EDI]

; Поскольку ЕСХ считает в обратном направлении, переключить все биты так,

; чтобы длина строки оказалась в ЕСХ. Эта длина включает символ NULL.

77F12821: NOT ЕСХ

;Поскольку REPNE SCAS инкрементирует также и EDI, вычесть длину строки

;из EDI так, чтобы EDI указывал обратно, на начало строки.

77F12823: SUB EDI , ЕСХ

Держать длину строки в ЕАХ.

77F12825: MOV ЕАХ , ЕСХ

;Переместить второй параметр в ESI, т.к. ESI является исходным

;операндом строчных инструкций.

77F12827: MOV ESI , EDI

;Переместить первый параметр (целевую строку) в EDI.

77F12829: MOV EDI , DWORD PTR [EBP+008h]

;Длина строки была подсчитана в байтах. Делите длину строки на 4,

;чтобы получить число двойных слов (DWORDS). Если число символов

;нечетное, REPE MOVS не будет копировать их всех.

;Любые остающиеся байты

;копируются прямо после REPE MOVS.

77F1282C: shr ЕСХ , 002h

;Копировать строку второго параметра в строку первого.

77F1282F: REPE MOVS DWORD PTR [EDI] , DWORD PTR [ESI]

;Переместить сохраненную длину строки в ЕСХ.

77F12831: MOV ЕСХ , ЕАХ

;Операция AND счетчика с числом 3, чтобы получить

;остающиеся байты для копирования

77F12833: AND ЕСХ , 00Зh

;Копировать остающиеся байты из строки в строку.

77F12836: REPE MOVS BYTE PTR [EDI] , BYTE PTR [ESI]

Istrcpy возвращает первый параметр, поэтому переместить

;возвращаемое значение в ЕАХ

77F12838: MOV ЕАХ , DWORD PTR [EBP+008h]

;Установить локальную переменную в -1, указывая, что функция

;покидает этот блок try/except.

77F1283B: MOV DWORD PTR [EBP-004h] , EDX

;Функция завершена; выйдите и переместитесь домой.

77F1283E: JMP 77F12852h

;Если вы просмотрите эту функцию, то заметите, что фактически нет

;инструкции, которая переходит или ветвится по адресу 0x77F12840. Этот

;адрес является частью фильтра исключений кадра SEH. Фильтр исключений -

;это часть кода, которая сообщает возврату из SEH, что нужно делать.

;Здесь фильтр исключений эквивалентен функции

;_except (EXCEPTION_EXECUTE_HANDLER). Код возврата должен выполнить

;обработчик, который расположен справа от инструкции RET. Подробные

;сведения о фильтрах исключений можно найти в MSDN

;или в книге Джеффри Рихтера

;"Программирование приложений для Microsoft Windows" (Jeffrey Richter,

;"Programming Applications for Microsoft Windows".-

;Microsoft Press, 1999)

77F12840: MOV EAX , 00000001h

77F12845: RET

; Следующие три инструкции — блок исключения для функции.

; Восстановить стек, сохраненный ранее.

77F12846: MOV ESP , DWORD PTR [EBP-018h]

; Установить локальную переменную в -1, указывая, что функция

; покидает этот блок try/except.

77F12849: MOV DWORD PTR [EBP-004h] , FFFFFFFFh

; Установить 0 в качестве неуспешного возвращаемого значения.

77F12850: XOR ЕАХ , ЕАХ

; Получить предыдущий SEH-кадр.

77F12852: MOV ECX , DWORD PTR [EBP-010h]

; Восстановить предварительно сохраненный в стеке EDI.

77F12855: POP EDI

; Отменить SHE-кадр.

"7F12856: MOV DWORD PTR FS: [00000000h] , ECX

; Восстановить предварительно сохраненный в стеке ESI.

77F1285D: POP ESI

; Восстановить EBI, предварительно сохраненный в стеке.

77F1285E: POP EBX

; Отменить установку нормального стекового кадра

77F1285F: MOV ESP , ЕВР

77F12861: POP EBP

; Возврат в вызывающую программу и очистка 8 байтов стека.

; Istrcpy is a __sdtcall function.

77F12862: RET 00008h

отладка программ АСДиП ЯП ЯиМП 3GL 4GL 5GL технологии программирования

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

НОВОСТИ ФОРУМА

Рыцари теории эфира

Отладка программ

Отладка средствами языка ассемблера х86 и окна Disassembly отладчика Visual C++

Манипуляции с данными

Отладка средствами языка ассемблера х86
и окна Disassembly отладчика Visual C++