Изучаем отладчик, часть первая

Я думаю, вы знаете, что взлом программного обеспечения производится не какими-то мистическими «хакерами» – его осуществляют такие же программисты, как и большинство читающих данную статью. При этом они пользуются тем же инструментарием что и сами разработчики ПО. Конечно, с оговорками, поскольку по большей части инструментарий достаточно специфичен, но, так или иначе, при анализе ПО используется отладчик.

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

Поэтому в данной статье будет рассмотрен один из базовых инструментов программиста – отладчик. Цели статьи: рассмотреть основные методы работы с отладчиком, показать его расширенные и редко используемые возможности, дать понимание работы механизмов отладчика на примерах и рассмотреть некоторый набор методов противодействия.

Объем статьи получился неожиданно большим, поэтому я разбил ее на три части:

1. В первой части будут рассмотрены возможности интегрированного в IDE Delphi отладчика, даны рекомендации по наиболее оптимальному его использованию и общие советы по конфигурации среды. Материал данного раздела предназначен как начинающим разработчикам, так и более подготовленным специалистам.
2. Во второй части статьи будет рассмотрена изнаночная сторона работы отладчика на примере его исходного кода, подробно рассмотрены механизмы, используемые им при отладке приложения, показаны варианты модификаций памяти приложения, производимые отладчиком во время работы.
3. В третьей части статьи будет рассмотрено практическое использование отладчика на примере обхода защиты приложения, использующего некоторый набор антиотладочных трюков.

Собственно, приступим.

1.1. Применение точек остановки и модификация локальных переменных

Одним из наиболее часто используемых инструментов встроенного отладчика является точка остановки (BreakPoint – далее BP). После установки BP, программа будет работать до тех пор, пока не достигнет точки остановки, после чего ее работа будет прервана и управление будет передано отладчику.

Самым простым способом установки и снятия BP является горячая клавиша «F5» (или ее аналог в меню «Debug->Toggle breakpoint»). Есть и другие способы, но о них позже.

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

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

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

Давайте рассмотрим следующий пример.

Есть задача: написать код, который 5 раз увеличит значение изначально обниленной переменной на единицу и еще один раз на число 123, после чего выведет результат в виде 10-тичного и 16-тиричного значения. Ожидаемые значения будут следующими: 128 и 00000080.

Допустим, код будет написан с ошибкой:

var
  B: Integer = 123;
 
procedure TForm1.FormCreate(Sender: TObject);
var
  A: Integer;
begin
  Inc(A);
  Inc(A);
  Inc(A, B);
  Inc(A);
  Inc(A);
  Inc(A);
  ShowMessage(IntToStr(A));
  ShowMessage(IntToHex(A, 8));
end;

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

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

Должно получится примерно так, как на картинке. BP установлен на строчке Inc(A). Слева внизу можно наблюдать значение всех локальных переменных процедуры FormCreate (окно называется «Local Variables»), а именно, переменной Self (она передается неявно и всегда присутствует в методах класса), параметра Sender, и непосредственно локальной переменной "А". Ее значение 19079581. Слева в центре в «WatchList» значение переменной "B".

Даже бегло взглянув на значения обеих переменных и выполненные три строчки кода, мы сможем понять, что значение переменной "А" не соответствует ожидаемому. Так как должно было выполнится два инкремента на единицу и еще одно увеличение на число 123, мы должны были увидеть значением переменной "А" число 125, а раз там другое значение, то это может означать только одно – изначальное значение переменной "А" было не верным.

Для проверки правильности нашего предположения, давайте изменим текущее значение переменной "A" на верное и продолжим выполнение программы, чтобы проверить – те ли результаты вернет процедура, которые ожидались.

Для изменения значений переменных в отладчике предусмотрено два инструмента.

Первый – «Evaluate/Modify», вызывается либо через меню, либо по горячей клавише «Ctrl+F7». Это очень простой инструмент с минимумом функционала, он наиболее часто используется.

Выглядит так:

Для изменения в нем значения переменной, достаточно указать новое значение в поле «New value» и нажать клавишу «Enter» или кнопку «Modify».

Второй инструмент – «Inspect», доступен так же либо через меню «Run», либо уже непосредственно из диалога «Evaluate/Modify». Это более продвинутый редактор параметров, о нем чуть позже.

После изменения значения переменной "А", обратите внимание на изменения в списке значений локальных переменных:

Переменная "А" приняла правильное значение, и теперь мы можем продолжить выполнение нашего приложения нажатием «F9» или через меню, выбрав пункт «Run». В результате такого вмешательства с помощью отладчика, процедура выдаст нам ожидаемые числа 128 и 00000080, и мы уже можем смело исправлять код процедуры, т. к. мы нашли в нём причину ошибки и проверили его исполнение с правильно заданным значением переменной "A".

Теперь вернемся к «Inspect». Помимо двух указанных способов его вызова, он так же вызывается двойным кликом на переменной в окне «Local Variables», либо через контекстное меню при правом клике на ней, либо по горячей клавише «Alt+F5».

Это более «продвинутый» редактор свойств переменных, но его использование оправдано при изменении свойств объектов. Для изменения обычной переменной он несколько не удобен, и вот почему.

При его вызове сначала вы увидите вот такой диалог:

В нем будет указано описание переменной, ее расположение в памяти и ее текущее значение, а для изменения нужно будет еще раз нажать на кнопку с троеточием, после чего появится дополнительное окно:

Лишние телодвижения для такой простой операции, как изменения значения обычной переменной, явно избыточны. Но если его использовать для изменения свойств объектов, то картинка немного поменяется.

Через «Evaluate/Modify» доступ к свойствам объекта несколько затруднен тем, что он не предоставляет информации непосредственно об исследуемом объекте. Например, для получения хэндла канваса формы, нам придется в нем набрать следующий текст: «(Sender as TForm1).Canvas.Handle» – что несколько не удобно, ведь мы можем и опечататься, да и просто банально забыть название того или иного свойства.

В случае с «Inspect» такой проблемы не будет.

К примеру, давайте откроем диалог «Inspect» не для переменной "А", а для переменной Self (которая, как я и говорил ранее, всегда неявно присутствует для всех методов объектов).

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

1.2. Трассировка (пошаговая отладка)

Суть трассировки заключается в пошаговом выполнении каждой строчки кода.

Допустим, мы остановились на заранее установленной нами ВР, проанализировали код и хотим перейти к следующий строчке. В принципе мы можем на ней так же поставить ВР и запустить программу. И для следующей, и для тех, кто после неё.

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

А умеет он следующее:

1. Команда «Trace Into» («F7») – отладчик выполнит код текущей строчки кода и остановится на следующей. Если текущая строчка кода вызывает какую либо процедуру, то следующей строчкой будет первая строка вызываемой процедуры.
2. Команда «Step Over» («F8») – аналогично первой команде, но вход в тело вызываемой процедуры не происходит.
3. Команда «Trace to Next Source Line» («Shift+F7») – так же практически полный аналог первой команды, но используется в окне «CPU-View» (данный режим отладки не рассматривается в статье).
4. Команда «Run to Cursor» («F4») – отладчик будет выполнять код программы до той строчки, на которой сейчас находится курсор (с условием, что в процессе выполнения не встретилось других ВР).
5. Команда «Run Until Return» («Shift+F8») – отладчик будет выполнять код текущей процедуры до тех пор, пока не произойдет выход из нее. (Часто используется в качестве контрприема на случайно нажатую «F7» и так же с условием, что в процессе выполнения не встретилось других ВР).
6. В старших версиях Delphi доступна команда «Set Next Statement», при помощи которой мы можем изменить ход выполнения программы, установив в качестве текущей любую строку кода. Так же эта возможность доступна в редакторе кода там, где можно перетащить стрелочку, указывающую на текущую активную строчку в новую позицию.

Подробного рассмотрения данные команды не требуют. Остановимся только на команда «Trace Into» («F7»).

Для примера возьмем такой код:

procedure TForm1.FormCreate(Sender: TObject);
var
  S: TStringList;
begin
  S := TStringList.Create;
  try
    S.Add('My value');
  finally
    S.Free;
  end;
end;

При выполнении трассировки, в тот момент, когда мы находимся на строчке S.Add(), у нас могут быть два варианта реакции отладчика:

1. мы войдём внутрь метода TStringList.Add,
2. мы туда не войдём.

Обусловлено данное поведение настройками вашего компилятора. Дело в том что в составе Delphi поставляется два набора DCU для системных модулей. Один с отладочной информацией, второй - без. Если у нас подключен второй модуль, то команда «Trace Into» («F7»)  в данном случае отработает как «Step Over» («F8»). Настраивается переключение между модулями в настройках компилятора:

И отвечает за данный функционал параметр «Use Debug DCUs».

1.3. Подробнее о настройках компилятора

Опции в закладке с настройками компилятора влияют непосредственно на то, какой код будет генерироваться при сборке вашего проекта. Очень важно не забывать, что при изменении любого из пунктов данной вкладки, требуется полная пересборка проекта («Project > Build») для того, чтобы изменения вступили в силу. Данные настройки непосредственно влияют на поведение вашего кода в различных ситуациях, а так же на состав информации, доступной вам при отладке проекта.

Рассмотрим их поподробнее:

Группа «Code generation»

Параметр «Optimization»

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

В качестве примера, возьмем код из первой главы и остановимся на той же ВР, но с включенной оптимизацией.

Как видите, значения ранее доступных переменных Self и Sender, более не доступны. Так же из-за отключенного параметра «Use Debug DCUs» произошло кардинальное изменение в окне «Call Stack», ранее заполненного более подробной информацией о списке вызовов.

Более того, инструмент «Inspect» так же отказывается работать с объектом Self, выдавая следующую ошибку:

Параметры «Stack Frames» и «Pentiom-safe FDIV»

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

Параметр «Record field alignment»

Глобальная настройка выравнивания неупакованных записей, которая может быть изменена локально в пределах модуля директивой «{$Align x}» или «{$A x}»

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

type
  T = record
    a: Int64;
    b: Byte;
    c: Integer;
    d: Byte;
  end;

Размер данной записи, который мы можем получить через SizeOf(T), будет для каждой из настроек выравнивания свой:

{$Align 1} = 14
{$Align 2} = 16
{$Align 4} = 20
{$Align 8} = 24

Группа «Syntax options»

Тут лучше вообще ничего не трогать. Ибо, если постараться, то можно сделать даже так, что стандартная VCL откажется собираться.

Единственно остановлюсь на параметре «Complete boolen eval», ибо периодически некоторые его включают. Он грозит ошибкой при выполнении следующего кода:

function IsListDataPresent(Value: TList): Boolean;
begin
  Result := (Value <> nil) and (Value.Count > 0);
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  if IsListDataPresent(nil) then
    ShowMessage('boo...');
end;

Так как, при включении данной настройки, булево выражение будет проверяться целиком, то произойдет ошибка при обращении к Value.Count, не смотря на то, что первая проверка определила, что параметр Value обнилен. А если вы включите (например) параметр «Extended syntax», то данный код у вас вообще не соберется, пожаловавшись на необъявленную переменную Result.

Группа «Runtime errors»

Параметр «Range checking»

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

В самом простом случае вам будет сгенерировано исключение при выполнении вот такого кода:

const
  A: array [0..1] of Char = ('A', 'B');

procedure TForm1.FormCreate(Sender: TObject);
var
  I: Integer;
begin
  for I := 0 to 100 do
    Caption := Caption + A[I];
end;

Здесь мы просто пытаемся обратится к элементу массива, и в принципе, при отключенной опции «Range checking», если мы не выйдем за границу выделенной памяти, данный код нам грозит только тем, что в заголовке формы появится некая непонятная строка.

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

Рассмотрим такой пример, оптимизацию отключим:

type
  TMyEnum1 = (en1, en2, en3, en4, en5);
  TMyEnum2 = en1..en3;

procedure TForm1.FormCreate(Sender: TObject);
var
  I: TMyEnum1;
  HazardVariable: Integer;
  Buff: array [TMyEnum2] of Integer;
begin
  HazardVariable := 100;
  for I := Low(I) to High(I) do
    Buff[I] := Integer(I);
  ShowMessage(IntToStr(HazardVariable));
end;

Как вы думаете, чему будет равно значение числа HazardVariable после выполнения данного кода? Нет, не 100. Оно будет равно 4. Так как мы ошиблись при выборе типа итератора и вместо TMyEnum2 написали TMyEnum1, произошел выход за диапазон границ массива и затерлись данные на стеке, изменив значения локальных переменных хранящихся на нём же.

С включенной оптимизацией ситуация будет еще хуже. Мы получим следующую ошибку:

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

Поэтому возьмите себе за правило – отладка приложения всегда должна происходить с включенной настройкой «Range checking»!

Так же данный параметр контролирует выход за границы допустимых значений при изменении значения переменных. Например, будет поднято исключение при попытке присвоения отрицательного значения беззнаковым типам наподобие Cardinal/DWORD, или при попытке присвоить значение большее, чем может содержать переменная данного типа, например, при присвоении 500 переменной типа Byte и т. п..

Параметр «I/O cheking»

Отвечает за проверку результатов ввода/вывода при работе с файлами в стиле Pascal.

Не уверен, что еще остался софт, использующий данный подход, но если вы вдруг все еще работаете с Append/Assign/Rewrite и т. п., то включайте данный параметр при отладке приложения.

Параметр «Overflow cheking»

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

Чтобы было проще понять различия между данным параметром и «Range checking», рассмотрим следующий код:

procedure TForm1.FormCreate(Sender: TObject);
var
  C: Cardinal;
  B: Byte;
  I: Integer;
begin
  I := -1;
  B := I;
  C := I;
  ShowMessage(IntToStr(C - B));
end;

Данный код не поднимет исключения при включенном параметре «Overflow cheking». Хоть здесь и присваиваются переменным не допустимые значения, но не производится математических операций над ними. Однако исключение будет поднято при включенном параметре «Range checking».

А теперь рассмотрим второй вариант кода:

procedure TForm1.FormCreate(Sender: TObject);
var
  C: Cardinal;
  B: Byte;
begin
  B := 255;
  Inc(B);
  C := 0;
  C := C - 1;
  ShowMessage(IntToStr(C - B));
end;

Здесь уже не будет реакции от параметра «Range checking», но произойдет поднятие исключения EIntegerOverflow, за который отвечает «Overflow cheking», на строчках Inc(B) и C := C - 1 из-за того, что результат арифметической операции не может быть сохранен в соответствующей переменной.

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

«Overflow cheking» не настолько критичен, как «Range checking», но всё же желательно держать его включенным при отладке приложения.

Небольшой нюанс: если вы вдруг реализуете криптографические алгоритмы, то в них, как правило, операция переполнения является штатной. В таких ситуациях выносите код в отдельный модуль и в начале модуля прописывайте директиву «{$OVERFLOWCHECKS OFF}» для отключения проверки переполнений в текущем модуле.

 Группа «Debugging»

С данной вкладкой все очень просто. Все параметры, за исключением параметра «Assertions», никоим образом не влияют на финальный код вашего приложения. В зависимости от активности тех или иных параметров изменяется полнота отладочной информации в DCU файле для каждого модуля. На основе данной информации отладчик производит синхронизацию ассемблерного листинга программы с ее реальным кодом, реализованным программистом, распознает локальные переменные и т. п. При компиляции приложения данная отладочная информация не помещается в теле приложения.

Единственным исключением является параметр «Assertions» – он отвечает за работу процедуры Assert(). Если данный параметр отключен – Assert не выполняется, в противном случае – выполняется, причем его код так же будет помещен в тело приложения на этапе компиляции.

Резюмируя.

На этапе отладки приложения желательно держать все параметры из групп «Runtime errors» и «Debugging» включенными, и отключать их при финальной компиляции релизного приложения. В Delphi 7 и ниже это придется делать руками, но, начиная с Delphi 2005 и выше, появилась нормальная поддержка билдов проекта, в которой можно указывать данные комбинации флагов персонально для каждого типа сборки.

1.4. Окно стека вызовов («Call Stack»)

Если ВР является нашим основным инструментом при отладке приложения, то «Call Stack» второй по значимости.

Выглядит данное окно следующим образом:

Он содержит полное описание вызовов, которые были выполнены до того, как отладчик прервал выполнение программы на установленном ВР (или остановился из-за возникновения ошибки). Например, на скриншоте изображен стек вызовов, произошедших при нажатии кнопки на форме. Начался он с прихода сообщения WM_COMMAND (273) в процедуру TWinControl.DefaultHandler.

Имея на руках данный список, мы можем быстро переключаться между вызовами двойным кликом (или через меню «View Source»), просматривать список локальных переменных для каждого вызова («View Locals»), устанавливать ВР на любом вызове.

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

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

В данном случае достаточно найти самый первый сверху вызов, код которого расположен не в системных модулях Delphi, чтобы с большой долей вероятности сказать, что ошибка именно в нём. Таким вызовом является Unit1.TForm1.Button1Click() - это обработчик кнопки Button1 в котором выполнялся следующий код:

procedure TForm1.Button1Click(Sender: TObject);
begin
  TStrings.Create.Add('qwe');
end;

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

1. перейти в модуль, где объявлен вызов интересующей нас функции (в данном случае это windows.pas),
2. найти её объявление (строка с синей точкой function MessageBox; external user32...),
3. установить на данной строке ВР и запустить программу.

Как только из любого места программы произойдет вызов MessageBox, сработает наш ВР и мы сможем – на основании данных «Call Stack» – выяснить точное место его вызова.

1.5. Работа с расширенными свойствами точек остановки

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

Делается это посредством диалога настроек свойств точки остановки. Вызывается он либо через свойства BP в коде приложения.

Либо в окне «Breakpoint list» так же через свойства выбранной BP.

Выглядит диалог настроек следующим образом:

Параметр «Condition» отвечает за условие срабатывания точки остановки.

Параметр «Pass count» указывает, сколько таких условий нужно пропустить, прежде чем ВР будет активирована, причем подсчёт количества срабатываний ведется от самого первого, с учетом значения параметра "Condition".

Рассмотрим абстрактный пример:

procedure TForm1.FormCreate(Sender: TObject);
var
  I, RandomValue: Integer;
begin
  RandomValue := Random(100);
  for I := 1 to 100 do
    RandomValue := RandomValue + I;
  ShowMessage(IntToStr(RandomValue));
end;

Допустим, ВР установлена на седьмой строчке. Если программу просто запустить, то мы получим на руки ровно 100 срабатываний ВР. Для того чтобы данная ВР срабатывала каждый десятый вызов необходимо в свойстве «Pass count» выставить значение 10. В этом случае мы получим ровно десять срабатываний ВР, в тот момент кода итератор "I" будет кратен десяти.

Допустим, теперь мы хотим начать анализ после 75 итерации включительно, для этого выставим следующее условие в параметре «Condition»: I > 75. В этом случае данная ВР сработает всего два раза: в тот момент, когда итератор "I" будет равен 85, и второй раз, при значении 95.

Произошло это по следующим причинам:

В первом случае, когда у нас не было условия, ВР срабатывала на каждой итерации цикла, но т. к. был указан параметр «Pass count», управление не переходило к отладчику, а происходило всего лишь увеличение количество срабатываний ВР до тех пор, пока их количество не становилось равным заданному в «Pass count». Поэтому мы получали управление только каждую десятую итерацию (после чего счетчик обнулялся).

Во втором случае увеличение счетчика сработок начало происходить только после выполнения изначального условия «Condition», т. е., пока итератор "I" был меньше или равен числу 75, отладчик считал, что условие не выполнено и продолжал выполнение программы. Как только первое условие выполнилось, началось увеличение количества срабатываний, которое стало равным значению параметра «Pass count» именно в тот момент, когда итератор "I" достиг значения 85.

Естественно, если мы хотим, чтобы ВР начала срабатывать сразу после превышения итератором "I" числа 75, то параметр «Pass count» необходимо выставить в ноль.

Группируя эти два параметра мы можем более гибко настроить условия срабатывания наших ВР.

Теперь рассмотрим один небольшой нюанс.

Условия передачи управления отладчику, указанные в свойствах ВР, рассчитываются самим отладчиком. Т.е. грубо (взяв за основу вышеописанный пример), не смотря на то, что мы прервались на ВР всего лишь два раза, на самом деле прерывание произошло все 100 раз, просто мы не получали управление в те моменты, которые не соответствовали заданным нами условиям.

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

Можно проверить на следующем коде:

procedure TForm1.FormCreate(Sender: TObject);
var
  I, RandomValue: Integer;
begin
  RandomValue := Random(100);
  for I := 1 to 10000 do
    RandomValue := RandomValue + I;
  ShowMessage(IntToStr(RandomValue));
end;

Установим ВР на той же седьмой строчке и укажем в параметре «Condition» значение I=9999. Даже на таком маленьком цикле нам придётся ждать срабатывания условия в районе 3-5 секунд. Конечно же, это не удобно. В таких случаях проще модифицировать код следующим образом:

procedure TForm1.FormCreate(Sender: TObject);
var
  I, RandomValue: Integer;
begin
  RandomValue := Random(100);
  for I := 1 to 10000 do
  begin
    RandomValue := RandomValue + I;
    {$IFDEF DEBUG}
    if I = 9999 then
      Beep;
    {$ENDIF}
  end;
  ShowMessage(IntToStr(RandomValue));
end;

... и поставить ВР на Beep, чем ждать столь продолжительное время. В этом случае мы получим управление на практически мгновенно.

(В релизной сборке проекта директива DEBUG будет отсутствовать и отладочный код не попадет в неё, но лучше, после отладки, все же не забывать удалять все эти отладочные Beep-ы. )

Подобные «тормоза» обусловлены тем, что всё взаимодействия отладчика с отлаживаемым приложением происходит через механизм структурной обработки исключений (SEH), более известный Delphi программистам через куцую обертку над ним в виде try..finally..except. Работа с SEH является одной из наиболее «тяжелых» операций для приложения. Дабы не быть голословным и показать его влияние на работу программы наглядно, рассмотрим такой код:

function Test1(var Value: Integer): Cardinal;
var
  I: Integer;
begin
  Result := GetTickCount;
  for I := 1 to 100000000 do
    Inc(Value);
  Result := GetTickCount - Result;
end;

function Test2(var Value: Integer): Cardinal;
var
  I: Integer;
begin
  Result := GetTickCount;
  for I := 1 to 100000000 do
    try
      Inc(Value);
    finally
    end;
  Result := GetTickCount - Result;
end;

procedure TForm1.FormCreate(Sender: TObject);
var
  A: Integer;
begin
  A := 0;
  ShowMessage(IntToStr(Test1(A)));
  A := 0;
  ShowMessage(IntToStr(Test2(A)));
end;

В функции Test1 и Test2 происходит инкремент переданного значения 100 миллионов раз.

В первом случае она выполняется в районе 210 миллисекунд, тогда как во втором случае – в четыре с небольшим раза дольше, а изменений между ними по сути нет – всего лишь глухой try..finally.

Это, кстати тоже вам в «копилочку» – по возможности не вставляйте обработку исключений внутрь циклов, лучше выносите её за пределы...

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

Групповые операции настраиваются в расширенных настройках ВР:

Отвечают за это параметры: «Enable group» – активирующий все ВР группы, и «Disable group» – отключающий все ВР входящие в группу.

Так же при групповых операциях часто применяется параметр «Break», который отвечает за действия отладчика при достижении ВР. Если данный параметр не активен, то прерывания выполнения программы при достижении данной ВР не происходит.

Важно – данный параметр не отключает саму ВР.

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

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

Перед компиляцией примера обязательно включите в настройках компилятора опцию «Overflow cheking» и отключите оптимизацию.

function Level3(Value: Integer): Integer;
var
  I: Integer;
begin
  Result := Value;
  for I := 0 to 9 do
    Inc(Result);
end;
 
function Level2(Value: Integer): Integer;
var
  I: Integer;
begin
  Result := Value;
  for I := 0 to 9 do
    Inc(Result, Level3(Result) shr 1);
end;
 
function Level1(Value: Integer): Integer;
var
  I: Integer;
begin
  Result := Value;
  for I := 0 to 9 do
    Inc(Result, Level2(Result) shr 3);
end;
 
procedure TForm1.FormCreate(Sender: TObject);
begin
  ShowMessage(IntToStr(Level1(0)));
end;

После запуска данного кода, произойдет исключение на шестнадцатой строчке.

Обычно, для того чтобы разобраться в причинах ошибки, ставят ВР на строку, в которой произошло поднятие исключения, но в данном конкретном примере нам это не поможет. Причина проста: данная строчка десятки раз подряд будет выполнена успешно, и, если мы поставим ВР на ней, то все эти десятки раз нам придется нажимать «F9» до тех пор, пока мы не достигнем непосредственно самого исключения.

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

Сделаем это следующим образом:

1. Поставим ВР на шестнадцатой строчке и назначим ей группу «level2BP».
2. Отключим данную группу, чтобы установленная ВР не срабатывала раньше времени. Для этого в процедуре FormCreate поставим новую ВР на ShowMessage и в параметре «Disable group» укажем группу «level2BP». Чтобы не прерываться на новой ВР, в его настройках отключим параметр «Break».
3. В функции Level1 устанавливаем ВР на строчке №25. Посчитаем, сколько раз выполнится данная ВР перед появлением ошибки.
4. Выясняем, что было 9 прерываний (итератор I в этот момент равен восьми). Значит, нам нужно пропустить первые 8 прерываний, в которых ошибок не обнаружено, и на девятом включить ВР из группы «level2BP». Для этого заходим в свойства текущей ВР и выставляем в параметре «Condition» значение I=8, после чего исключаем его из обработки через отключение параметра «Break» и в настройках «Enable group» прописываем «level2BP».
5. Перезапустив приложение, мы сразу прервемся в процедуре Level2, но не в момент самой ошибки – ошибка произойдет через несколько итераций. Несколько раз нажмем F9, считая количество итераций, и выясним, что это происходит в тот момент, когда итератор I был равен 5. В параметре «Condition» текущей ВР установим условие I=5, после чего можно смело перезапускать приложение.
6. Первое же прерывание в отладчике произойдет непосредственно в месте возникновения ошибки, откуда и можно приступать к разбору причин ее возникновения.

Если из описания примера не все понятно — посмотрите ролик, демонстрирующий всю последовательность действий: http://rouse.drkb.ru/blog/bp3.mp4 (17 Мб).

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

Почему в примере не использовался параметр «Pass Count», а условия задавались через параметр «Condition»? Дело в том, что «Pass Count» просто отключает прерывание на ВР. Сама же ВР выполняется (т. к. условия её выполнения описаны в параметре «Condition») и раз она выполнилась, то выполняются и её групповые операции.

Осталось рассмотреть еще несколько параметров.

Параметр «Ignore subsequent exceptions» отключает реакцию отладчика на любое исключение, возникшее после выполнения ВР с включенным данным параметром.

Параметр «Handle subsequent exceptions» отменяет действие предыдущего параметра, возвращая отладчик в нормальный режим работы.

Чтобы посмотреть как это выглядит, создадим такой код:

procedure TForm1.Button1Click(Sender: TObject);
begin
  ShowMessage('All exceptions ignored');
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  PInteger(0)^ := 123;
end;

procedure TForm1.Button3Click(Sender: TObject);
var
  S: TStrings;
begin
  S := TStrings.Create;
  try
    S.Add('abstract')
  finally
    S.Free;
  end;
end;

procedure TForm1.Button4Click(Sender: TObject);
begin
  ShowMessage('All exceptions handled');
end;

На первом ShowMessage поставьте ВР, отключите его, сняв галку с параметра «Break», и включите параметр «Ignore subsequent exceptions».

На втором ShowMessage сделайте то же самое, только включите параметр «Handle subsequent exceptions».

Запустите приложение из отладчика и пощелкайте по кнопкам в следующем порядке:

1. Button1
2. Button2
3. Button3
4. Button4
5. Button2
6. Button3

Не смотря на то, что кнопки Button2 и Button3 генерируют исключение, на этапе 2 и 3 отладчик на них никак не прореагирует, мы дождемся от него реакции только на этапах 5 и 6 после того, как активируем нормальную обработку исключений нажатием кнопки Button4.

Осталось 2 параметра:

«Log message» –  любая текстовая строчка, которая будет выводится в лог событий при достижении ВР.

«Eval expression» – при достижении ВР, отладчик вычисляет значение данного параметра и (в случае если включен флаг «Log result») выводит его в лог событий. Значение для вычисления может быть любым, хоть тот же "123 * 2".

1.6. Использование «Data breakpoint», «Watch List» и «Call Stack»

Все, что мы рассматривали ранее, относилось к так называемым «Source Breakpoint». Т. е. к точкам остановки, устанавливаемым непосредственно в коде приложения.

Но, помимо кода, мы работаем с данными (переменными, массивами, просто с участками выделенной памяти) и у отладчика есть возможность устанавливать BP на адреса, по которым эти данные расположены в памяти, при помощи «Data breakpoint».

Установка ВР на адрес памяти производится через «Watch List» (не во всех версиях Delphi) или в окне «Breakpoint List» при помощи «Add Breakpoint->Data Breakpoint», где, в появившемся диалоге, указываем требуемый адрес, размер контролируемой области или имя переменной. В случае указания имени переменной, отладчик попробует вычислить ее расположение в памяти и (если это возможно) установит ВР.

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

Что такое область видимости переменной – вы должны знать. Глобальные переменные доступны нам всегда, и, даже без запуска приложения, отладчик предоставляет нам возможность устанавливать «Data breakpoint» на изменения в таких переменных. Правда, в данном случае он рассчитывает адрес такой переменной на основании предыдущей сборки приложения, и не факт, что он совпадет с ее расположением при следующем запуске. Ситуация гораздо хуже с локальными переменными. Область видимости переменной – это не просто так введенное понятие, локальные переменные расположены на стеке, и, как только они выходят из области видимости, место, занимаемое ими ранее, используется под хранение совершенно других данных. Таким образом установить «Data breakpoint» на локальную переменную можно только в тот момент, пока она не вышла из области видимости.

Те, кто ранее работал с профессиональными отладчиками, вероятно узнают в «Data breakpoint» один из базовых инструментов анализа приложения – «Memory Breakpoint».

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

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

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

type
  TTest = class
    Data: array [0..10] of Char;
    Caption: string;
    Description: string;
    procedure ShowCaption;
    procedure ShowDescription;
    procedure ShowData;
  end;

  TForm1 = class(TForm)
    procedure FormCreate(Sender: TObject);
  private
    FT: TTest;
    procedure InitData(Value: PChar);
  end;

var
  Form1: TForm1;

implementation

{$R *.DFM}

{ TTest }

procedure TTest.ShowCaption;
begin
  ShowMessage(Caption);
end;

procedure TTest.ShowData;
begin
  ShowMessage(PChar(@Data[0]));
end;

procedure TTest.ShowDescription;
begin
  ShowMessage(Description);
end;

{ TForm1 }

procedure TForm1.FormCreate(Sender: TObject);
begin
  FT := TTest.Create;
  try
    FT.Caption := 'Test caption';
    FT.Description := 'Test Description';
    InitData(@FT.Data[0]);
    FT.ShowCaption;
    FT.ShowDescription;
    FT.ShowData;
  finally
    FT.Free;
  end;
end;

procedure TForm1.InitData(Value: PChar);
const
  ValueData = 'Test data value';
var
  I: Integer;
begin
  for I := 1 to Length(ValueData) do
  begin
    Value^ := ValueData[I];
    Inc(Value);
  end;
end;

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

Нажав на «Break», мы окажемся где-то внутри модуля «system»:

Код, на котором мы прервались, ничего нам не может сказать о причине возникновения ошибки, но у нас есть окно «Call Stack», на основании которого мы можем сделать вывод, что ошибка произошла при вызове процедуры ShowCaption в главном модуле программы.
Если установить BP в данной процедуре и перезапустить программу, а затем, при срабатывании ВР, проверить значение переменной Caption, то окажется что данная переменная не доступна:

Это означает, что где-то произошло разрушение памяти и затерлись данные по адресу переменной Caption. Определить это место нам поможет «Data breakpoint». 

1. Дождемся инициализации переменной Caption, для этого установим ВР на строчке №49.
2. При срабатывании ВР, добавим переменную FP.Caption в «Watch List» и в свойствах этой переменной выберем «Break When Changed». Если данного пункта меню у вас нет (например, в Delphi 2010 он отсутствует), то установим «Data breakpoint» немного другим способом. В «Breakpoint List» выбираем «Add->Data Breakpoint», в появившемся диалоге указываем имя переменной FP.Caption и нажимаем ОК.
3. Запускаем программу на выполнение.

После выполнения этих действий, программа остановится на строчке №68 – Inc(Value). Особенность «Data breakpoint» в том, что остановка происходит сразу после произошедших изменений, а не при попытке изменения контролируемой памяти, поэтому место, где происходит запись по адресу переменной FP.Caption, находится строчкой выше – это строка Value^ := ValueData[I].

Теперь, найдя проблемное место, мы можем исправить и саму ошибку. Она заключается в том, что длина строки ValueData, которую мы пишем в буфер Data, превышает размер буфера, из-за чего происходит перезапись памяти, в которой расположены переменные Caption и Description.

1.7. В заключение

На этом я заканчиваю краткий обзор возможностей интегрированного отладчика. Осталось несколько нерассмотренных нюансов, как то: настройка игнорируемых исключений, ВР при загрузке модуля и т.п., но они несущественны и крайне редко применяются на практике.

Так же нерассмотренным остался режим отладки в окне «CPU-View» и связанные с ним Address Breakpoint. Его я так же решил пропустить, т.к. читателям не знакомым с ассемблером мое объяснение не даст ничего, а более подкованные специалисты и без меня знают что такое CPU-View и как его правильно применять :)

Во второй части статьи, будет рассмотрена программная реализация отладчика. В ней будет показано, что именно происходит при установке BreakPoint, показана обратная сторона Data Breakpoint, не реализованная в отладчике Delphi, показано как в действительности производится трассировка (двумя методами, классический через TF флаг и на основе GUARD страниц), а так же рассмотрен механизм Hardware Breakpoint, тоже отсутствующий в интегрированном отладчике Delphi.

Отдельная благодарность сообществу форума "Мастера Дельфи" за помощь при подготовке статьи, а также персональное спасибо Андрею Васильеву aka Inovet, Тимуру Вильданову aka Palladin и Дмитрию aka Брат Птибурдукова за вычитку материала и ценные советы.

---

© Александр (Rouse_) Багель
Москва, октябрь 2012

При перепечатке статьи указывайте ссылку на первоисточник: http://alexander-bagel.blogspot.com/2012/10/debugger-1.html.html