1. Если вы только начинаете программировать на ассемблере и не знаете с чего начать, тогда попробуйте среду разработки ASM Visual IDE
    (c) на правах рекламы
    Скрыть объявление

Программирование на языке Assembler в FASM

Тема в разделе "FASM", создана пользователем Mikl___, 10 дек 2016.

  1. Mikl___

    Mikl___ Супермодератор Команда форума

    Публикаций:
    14
    Регистрация:
    25 июн 2008
    Сообщения:
    2.784
    Программирование на языке Assembler
    в FASM
    — Архив WASM.RU

    автор pas
    Введение
    В начале было слово... Если точнее то было просто предложение от KiNDeR-а написать статью посвящённую макросам в FASM. Я согласился попробовать, но рассматривать макросы отдельно от синтаксиса как-то не очень правильно, а синтаксис без примеров разобрать сложно и в результате получилось сочинение о том как писать программы в FASM.
    В этом сочинении будут рассмотрены основные моменты отличающие FASM от других компиляторов, правила по которым пишутся макросы и форматы выходных файлов создаваемые FASM-ом. Так же, в рамках данного сочинения, мы создадим несколько элементов управления в виде макросов.
    Основы
    Данный раздел является вольным пересказом соответствующего раздела руководства, поставляемого с компилятором.
    Данная статья посвящена использованию макросов в компиляторе FASM. Для начала вопрос: "Что такое макрос?" (поскольку я не могу услышать Ваш ответ прямо сейчас, когда пишу эту статью, отправляйте свои ответы мне по электронной почте, если Ваше мнение отличается от моего мнения).
    Макрос - это инструкция препроцессору компилятора развернуть, встретившееся в коде программы, имя макроса (возможно с параметрами) в последовательность строк кода ассемблера с использованием переданных параметров (если таковые заданы).
    Далее предлагаю Вам ознакомиться с основными директивами, используемыми внутри определений макросов.
    Внутри определений макросов можно использовать инструкции if и else при этом каждая инструкция if должна закрываться инструкцией end if. Пример из руководства, поставляемого вместе с компилятором:
    Код (ASM):
    1. macro mov op1,op2
    2. {
    3. if op1 in  & op2 in
    4.    push op2
    5.    pop op1
    6. else
    7.    mov op1,op2
    8. end if
    9. }
    Этот макрос является расширением инструкции процессора mov. В данном случае если оба операнда макроса являются сегментными регистрами используется связка "push - pop", в любом другом случае используется стандартная инструкция "mov op1,op2". Оператор in позволяет проверить соответствие операнда нескольким значениям в угловых скобках.
    Можно ещё более расширить эту инструкцию для пересылки трёх значений второго в первый, а третьего во второй:
    Код (ASM):
    1. macro mov op1,op2,op3
    2. {
    3.    if arg3 eq
    4.       mov op1,op2
    5.    else
    6.       mov op1,op2
    7.       mov op2,op3
    8.    end if
    9. }
    В данном случае нас интересует инструкция eq, которая позволяет проверить эквивалентен ли операнд какому либо значению, в нашем случае мы проверяем его отсутствие, и если он отсутствует, то подставляется ветвь if иначе подставляется ветвь else.
    Директива purge позволяет отменить последнее определение макроса.
    Кроме уже изложенного в определение макроса можно передавать заранее неизвестное количество операндов (пар операндов и т.д.), для этого необходимо заключить операнды, количество которых заранее неизвестно, в квадратные скобки. Например для вызова процедур написан макрос STDCALL:
    Код (ASM):
    1. macro stdcall proc,[arg];
    2.  { reverse
    3.     push arg
    4.    common
    5.     call proc }
    Операндами этого макроса служат один обязательный (proc) и несколько необязательных параметров (arg). Директива reverse сообщает препроцессору, что следующие строки необходимо повторить столько раз, сколько параметров argпередано макросу начиная с последнего параметра. Директива common сообщает препроцессору, что следующие строки необходимо повторить только один раз. Директива forward сообщает препроцессору, что следующие строки необходимо повторить столько раз, сколько параметров arg передано макросу начиная с первого параметра. Действие директив common, forward и reverse заканчивается другой директивой common, forward или reverseсоответственно или закрывающейся фигурной скобкой. Если ни одна из этих директив не встречается в определении макроса, то макрос развернётся для всех параметров начиная с первого. Неизвестное количество параметров можно передать и другому макросу:
    Код (ASM):
    1. macro invoke proc,[arg]
    2.  { common
    3.     if ~ arg eq
    4.      stdcall [proc],arg
    5.     else
    6.      call [proc]
    7.     end if }
    В этом примере при выполнении ветви if в макрос stdcall кроме параметра [proc] передаются все полученные параметры arg.
    Внутри макроопределения может использоваться оператор #, который может использоваться для составления операторов ассемблера, например условного перехода:
    Код (ASM):
    1. macro jif op1,cond,op2,label
    2. {
    3.   cmp op1,op2
    4.   j#cond label
    5. }
    При выполнении макроса jif ax,ae,10h,exit макрос будет развёрнут в следующую конструкцию:
    Код (ASM):
    1. cmp ax,10h
    2. jae exit
    Так же этот оператор можно использовать и для составления имён переменных или макросов внутри макроопределений:
    Код (ASM):
    1. macro ver [name]
    2. {
    3.  name#.mas: times 10 db 0
    4. }
    Теперь при вызове данного макроса в секции данных
    Код (ASM):
    1. ver Chif,Rab
    Мы будем иметь два массива из 10 байт каждый, с именами Chif.mas и Rab.mas.

    Аналогично можно создать и переменные и макросы внутри определения макроса. Однако определить макрос внутри макроса обычным путём:
    Код (ASM):
    1. Macro mac1
    2. {
    3.  macro mac2
    4.   {
    5.   ... ... ...
    6.   }
    7. }
    препроцессор не позволит использовать данную конструкцию, выход в использовании директивы fix она эквивалентна директиве equ, но препроцессор обрабатывает fix позже чем equ, что и позволяет использовать подобную конструкцию:
    Код (ASM):
    1. Macro mac1
    2. {
    3.  macro mac2
    4. m_
    5.   ... ... ...
    6. _m
    7. }
    8. m_ fix {
    9. _m fix }
    Синтаксис компилятора FASM несколько отличается от синтаксиса других компиляторов, но отличия незначительны и в основном касаются макроязыка.

    Средства макроязыка мы рассмотрим ниже, здесь же я хотел бы отметить только то, что передача адреса переменной производится указанием имени переменной без каких либо скобок или префиксов, а её содержимого написанием имени переменной в квадратных скобках.
    Код (ASM):
    1. mov eax,var; записываем в регистр еах адрес переменной
    2. var mov eax,[var]; записываем в регистр еах значение переменной var
    Структура каркасного приложения на FASM'е

    В этой части мы рассмотрим, основы синтаксиса данного компилятора и рассмотрим каркасные приложения для основных форматов исполняемых файлов.

    Итак, что необходимо для работающего приложения?

    Во-первых мы должны указать компилятору какого формата должен быть создаваемый файл. Это делается директивой format после, которой следует указание форматов:
    • PE формат исполняемых файлов Windows. Далее должно следовать уточнение GUI (графический интерфейс), console (консольное приложение) и native (если Вы знаете, что это такое сообщите мне). Если выбран графический интерфейс, то следует также указать версию графического интерфейса 4.0, а так же зарезервированное слово DLL, если собирается динамическая библиотека.
    • MZ формат исполняемых файлов MS DOS.
    • COFF или MS COFF (для линковки продуктами Microsoft) для создания объектного файла, который в дальнейшем будет линковаться к другому проекту или к ресурсам.
    • ELF формат для создания исполняемых файлов UNIX подобных систем (Linux).
    Как Вы наверно поняли, я не знаком с файлами ELF типа и в данной статье мы не будем его рассматривать. Если директива format не указана, компилятор соберёт файл в формате com.

    После указания формата выходного файла мы должны указать компилятору точку начала программы. Это делается с помощью директивы entry после которой указывается метка, с которой начинается код программы. Например entry start.

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


    Форматы PE исполняемых файлов Windows.
    Консольные приложения

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

    Вот простой пример консольного приложения:
    Код (ASM):
    1. format PE console
    2. entry start
    3. include 'include\kernel.inc'
    4. include 'include\macro\stdcall.inc'
    5. include 'include\macro\import.inc'
    6. section '.data' data readable writeable
    7.   h4    db Консоль'
    8.  w1 dd 0
    9.  output dd 0
    10.  input dd 0
    11.  _class db 'FCAPTION',0
    12.  podskazka db 'Консоль',0
    13. section '.code' code readable executable
    14.  start:
    15.    invoke    GetStdHandle,STD_OUTPUT_HANDLE
    16.    mov       [output],eax
    17.    invoke    GetStdHandle,STD_INPUT_HANDLE
    18.    mov       [input],eax
    19.    invoke    WriteConsole,[output],h4,7,w1,0
    20.    invoke    ReadConsole,[input],_class,2,w1,0
    21.    invoke  ExitProcess,0
    22. section '.idata' import data readable
    23.  
    24.  _library kernel32,'KERNEL32.DLL',\
    25.         user32,'USER32.DLL',\
    26.         gdi32,'GDI32.DLL',\
    27.         advapi32,'ADVAPI32.DLL',\
    28.         comctl32,'COMCTL32.DLL',\
    29.         comdlg32,'COMDLG32.DLL',\
    30.         shell32,'SHELL32.DLL',\
    31.         wsock32,'WSOCK32.DLL';,\
    32.     include 'C:\FASM135\147\INCLUDE\apia\kernel32.inc'
    33.     include 'C:\FASM135\147\INCLUDE\apia\user32.inc'
    34.     include 'C:\FASM135\147\INCLUDE\apia\gdi32.inc'
    35.     include 'C:\FASM135\147\INCLUDE\apia\advapi32.inc'
    36.     include 'C:\FASM135\147\INCLUDE\apia\comctl32.inc'
    37.     include 'C:\FASM135\147\INCLUDE\apia\comdlg32.inc'
    38.     include 'C:\FASM135\147\INCLUDE\apia\shell32.inc'
    39.     include 'C:\FASM135\147\INCLUDE\apia\wsock32.inc'
     
    Последнее редактирование: 2 июн 2019
    psh3nka нравится это.
  2. Mikl___

    Mikl___ Супермодератор Команда форума

    Публикаций:
    14
    Регистрация:
    25 июн 2008
    Сообщения:
    2.784
    В данном примере создаётся три секции: данных, кода и секция импортируемых функций. Секцию импорта я создаю при помощи макроса _library, в стандартной поставке такого макроса нет, но если написать без подчёркивания перед library то всё скомпилируется правильно. Причина проста, я пользуюсь FASM-ом с версии 1.35, а тогда такого макроса еще не было (а сам я ещё не смог бы его написать) и для совместимости с ранее написанными программами я включил два варианта этого макроса. В ранней версии, необходимо было записывать все используемые в приложении функции вручную, теперь же работу по подключению только используемых функций берёт на себя компилятор, хотя за такое удобство приходится платить некоторым увеличением времени компиляции. Более подробно о принципе работы этого и других макросов будет написано в соответствующем разделе ниже.
    Название секции импорта ".idata", хотя название можно изменить и это не повлияет на работоспособность программы, так как мы указали назначение этой секции import data, далее следует указание атрибутов, в данном случае readable, что означает для чтения и этого достаточно, если Вы не собираетесь менять содержимое этой секции.
    Следующей рассмотрим секцию данных. У нас секция данных имеет название ".data", далее следует указание назначения секции data, что означает секцию данных, атрибуты указаны readable writeable, то есть эта область памяти будет доступна для чтения и записи. Если указать только первый атрибут (readable) при выполнении программы произойдёт ошибка "Программа выполнила недопустимую операцию".
    Последней рассмотрим секцию кода, она имеет название ".code" назначение секции code, т.е. исполняемая часть программы, атрибуты readable executable, что означает, что из секции кода мы можем читать данные (под данными может подразумеваться и коды инструкций и определённые в этой секции данные) и можем выполнять содержимое этой секции.
    Кроме рассмотренных секций, консольное приложение может иметь секции экспортируемых функций и секцию ресурсов.
    Это пожалуй всё, что необходимо знать для начала о консольных приложениях. Да ещё я считаю лишний раз напомнить, что хоть консольное приложение и напоминает внешне программы DOS-а, использование прерываний в нём не допускается так как это всё же приложение Windows, естественно выполняться такое приложение может только в Windows.
    Графическое приложение
    Графические приложения Windows это оконные приложения, такие как Word, Excel, Notepad и так далее.
    В отличии от консольных приложений, GUI приложения должны содержать как минимум одну процедуру обработки сообщений, приходящих к окну. Вот простой пример оконного приложения:
    Код (ASM):
    1. format PE GUI 4.0
    2. entry start
    3. include 'include\kernel.inc'
    4. include 'include\user.inc'
    5. include 'include\macro\stdcall.inc'
    6. include 'include\macro\import.inc'
    7. include 'include\macro\resource.inc'
    8. section '.data' data readable writeable
    9.   Progr db 'Программа построения графиков',0
    10.   MyMessage db 'Отклик',0
    11.   hinstance dd 0
    12.   h4    db 'Сообщение',0
    13.   w1 dd 0
    14.   msg MSG
    15.   wc WNDCLASS
    16.   pt dd 0
    17.   hDC dd 0
    18.   ws equ  WS_VISIBLE+WS_CAPTION+WS_MINIMIZEBOX+WS_SYSMENU
    19.   _class db 'FCAPTION',0
    20.   podskazka db 'Графическое приложение',0
    21. section '.code' code readable executable
    22.   start:
    23.     invoke  GetModuleHandle,0
    24.     mov [hinstance],eax
    25.     invoke  LoadIcon,eax,17
    26.     mov [wc.hIcon],eax
    27.     invoke  LoadCursor,0,IDC_ARROW
    28.     mov [wc.hCursor],eax
    29.     mov [wc.style],0
    30.     mov [wc.lpfnWndProc],WindowProc
    31.     mov [wc.cbClsExtra],0
    32.     mov [wc.cbWndExtra],0
    33.     mov eax,[hinstance]
    34.     mov [wc.hInstance],eax
    35.     mov [wc.hbrBackground],6;COLOR_BTNFACE+1
    36.     mov [wc.lpszMenuName],0
    37.     mov [wc.lpszClassName],_class
    38.     invoke  RegisterClass,wc
    39.     invoke  CreateWindowEx,0,_class,podskazka,ws,10,10,680,450,NULL,NULL,[hinstance],NULL
    40.  
    41.   msg_loop:
    42.     invoke  GetMessage,msg,NULL,0,0
    43.     or  eax,eax
    44.     jz  end_loop
    45.     invoke  TranslateMessage,msg
    46.     invoke  DispatchMessage,msg
    47.  
    48.     jmp msg_loop
    49.  
    50.   end_loop:
    51.     invoke  ExitProcess,[msg.wParam]
    52. ;include 'include\macro\lib.asm'
    53. proc WindowProc, hwnd,wmsg,wparam,lparam
    54.     enter
    55.     push    ebx esi edi
    56.           cmp   [wmsg],WM_DESTROY
    57.     je  wmdestroy
    58.     cmp [wmsg],WM_CREATE
    59.     je  wmcreate
    60.   defwndproc:
    61.     invoke  DefWindowProc,[hwnd],[wmsg],[wparam],[lparam]
    62.     jmp finish
    63. wmcreate:
    64.  
    65.     jmp ext
    66.  
    67.   wmdestroy:
    68.     invoke  PostQuitMessage,0
    69. ext:    xor eax,eax
    70.   finish:
    71.     pop edi esi ebx
    72.     return
    73. section '.idata' import data readable writeable
    74.   library kernel,'KERNEL32.DLL',\
    75.       user,'USER32.DLL'
    76.       ;shell,'SHELL32.DLL',\
    77.       ;gdi,'gdi32.dll'
    78.   kernel:
    79.   import GetModuleHandle,'GetModuleHandleA',\
    80.      ExitProcess,'ExitProcess',lstrcpy,'lstrcpyA',\
    81.      FindFirstChangeNotification,'FindFirstChangeNotificationA',\
    82.      FindNextChangeNotification,'FindNextChangeNotification',\
    83.      FindCloseChangeNotification,'FindCloseChangeNotification'
    84.   user:
    85.   import RegisterClass,'RegisterClassA',\
    86.      CreateWindowEx,'CreateWindowExA',\
    87.      DefWindowProc,'DefWindowProcA',\
    88.      SetWindowLong,'SetWindowLongA',\
    89.      RedrawWindow,'RedrawWindow',\
    90.      GetMessage,'GetMessageA',\
    91.      MessageBox,'MessageBoxA',\
    92.      TranslateMessage,'TranslateMessage',\
    93.      DispatchMessage,'DispatchMessageA',\
    94.      SendMessage,'SendMessageA',\
    95.      LoadCursor,'LoadCursorA',\
    96.      LoadIcon,'LoadIconA',\
    97.      LoadMenu,'LoadMenuA',\
    98.      SetMenu,'SetMenu',\
    99.      InsertMenu,'InsertMenuA',\
    100.      CreateMenu,'CreateMenu',\
    101.      DrawMenuBar,'DrawMenuBar',\
    102.      PostQuitMessage,'PostQuitMessage',\
    103.      FindWindow,'FindWindowA',\
    104.      FindWindowEx,'FindWindowExA',\
    105.      LoadImageA,'LoadImageA',\
    106.      CreatePopupMenu,'CreatePopupMenu',\
    107.      AppendMenu,'AppendMenuA',\
    108.      DestroyMenu,'DestroyMenu',\
    109.      GetCursorPos,'GetCursorPos',\
    110.      SetForegroundWindow,'SetForegroundWindow',\
    111.      TrackPopupMenu,'TrackPopupMenu',\
    112.      PostMessage,'PostMessageA',\
    113.      DestroyWindow,'DestroyWindow',\
    114.      ShowWindow,'ShowWindow',GetDC,'GetDC'
    115. section '.rsrc' resource data readable
    116.   directory   RT_ICON,icons,\
    117.         RT_GROUP_ICON,group_icons
    118.   icons:
    119.   resource 1,LANG_NEUTRAL,icon_data
    120.   group_icons:
    121.   resource 17,LANG_NEUTRAL,main_icon
    122.   icon main_icon,icon_data,'mp\lv\lv.ico'
    Так же, как и в примере с консольным приложением, в первой строке указана директива format PE, но вместо console, как в предыдущем примере, дано указание GUI 4.0 компилятору собирать приложение с графическим интерфейсом версии 4.0.

    Приложение из нашего примера ничего полезного не делает, оно просто создаёт окно, которое реагирует только на нажатие двух системных кнопок в верхнем правом углу окна "Свернуть" и "Закрыть". Приложение содержит секции данных, кода, импорта и ресурсов. После указания точки входа в программу entry start подключаются файлы содержащие макросы и определения констант и структур Windows. Затем следует секция данных, определение которой дано в предыдущем разделе, и секция кода. В секции кода мы получаем хендл нашего модуля (GetModuleHandle), загружаем иконку (LoadIcon), определённую в секции ресурсов, загружаем стандартный курсор Windows (LoadCursor) и заполняем структуру wc для дальнейшей регистрации класса нашего окна (RegisterClass). После регистрации класса окна мы создаём окно зарегистрированного класса (CreateWindowEx). В структуре wc имеется член .lpfnWndProc, в который мы записываем адрес начала процедуры обработки событий окна WindowProc. Далее следует цикл обработки сообщений, посылаемых окну системой Windows.

    Процедура обработки сообщений получает от Windows четыре параметра:
    Код (ASM):
    1. proc WindowProc, hwnd, wmsg, wparam, lparam
    где:
    • hwnd - хендл нашего окна
    • wmsg - код сообщения, которое Windows послало нашему окну
    • wparam и lparam - уточняющие параметры посланного сообщения.
    proc это не директива компилятора, а макрос содержащий, часть пролога процедуры. Он определён следующим образом:
    Код (ASM):
    1. macro proc name,[arg]
    2.  { common
    3.     name:
    4.     virtual at ebp+8
    5.     if ~ arg eq
    6.    forward
    7.      local ..arg
    8.      ..arg dd ?
    9.      arg equ ..arg
    10.    common
    11.      end if
    12.      ..ret = $ - (ebp+8)
    13.     end virtual
    14.     local ..dynamic_data,..dynamic_size
    15.     dynamic_data equ ..dynamic_data
    16.     dynamic_size equ ..dynamic_size
    17.     virtual at ebp - dynamic_size
    18.      dynamic_data: }
    Таким образом следующая строка proc Win,param будет развёрнута в следующую конструкцию:
    Код (ASM):
    1.     Win:
    2.     virtual at ebp+8
    3.         local ..param
    4.         ..param dd ?
    5.         param equ ..param
    6.         ..ret = $ - (ebp+8)
    7.     end virtual
    8.     local ..dynamic_data,..dynamic_size
    9.     dynamic_data equ ..dynamic_data
    10.     dynamic_size equ ..dynamic_size
    11.     virtual at ebp - dynamic_size
    12.      dynamic_data: }
    Более подробно это означает, что мы определяем метку Win, которая означает начало процедуры. В следующей строке записана директива virtual at ebp+8, которая должна заканчиваться директивой end virtual. Внутри этого определения помещаются переменные, которые будут размещаться с адреса указанного после at, в нашем примере это ebp+8. Это означает, что в нашем примере запись "mov param,eax" будет заменена на "mov [ebp+8],eax". Если бы в определении процедуры было две или более переменных, то адрес каждой последующей переменной увеличивался бы на размер предыдущей переменной. Таким образом:
    Код (ASM):
    1. virtual at ebp+8
    2.    param1 dd ?
    3.    param2 db ?
    4.    param3 dd ?
    5. end virtual
     
    Последнее редактирование: 10 дек 2016
    rococo795 нравится это.
  3. Mikl___

    Mikl___ Супермодератор Команда форума

    Публикаций:
    14
    Регистрация:
    25 июн 2008
    Сообщения:
    2.784
    определит три переменные с адресами
    Код (ASM):
    1. param1 = ebp+8+0,
    2. param2 = ebp+8+4, param2 = ebp+8+5.
    У некоторых читателей может возникнуть вопрос: "А зачем все эти пляски?". Ответ прост: регистр ebp указывает на вершину стека и все переменные, передаваемые в процедуру, находятся выше (в смысле в памяти с адресами больше чем вершина стека так как вершина стека сдвигается вниз когда в стек помещаются данные и вверх, когда данные из стека изымаются) текущей вершины стека.
    Первой, в определении переменных внутри virtual - end virtual записана директива local, которая указывает компилятору, что следующие за ней через запятую метки, локальны в данном макросе.
    Последней, внутри описания виртуальных переменных, следует определение макропеременной
    Код (ASM):
    1. ..ret = $ - (ebp+8)
    которая фактически содержит количество переданных процедуре байт параметров. Она используется при написании эпилога процедуры для очистки стека при возврате управления инструкции, следующей за вызовом данной процедуры.
    После определения виртуальных переменных, передаваемых процедуре в качестве параметров, определяются локальные макропеременные, которые используются во второй части пролога процедуры. Я уже несколько раз использовал термин - макропеременная. Макропеременная отличается от переменных, используемых в программе, тем, что она существует только во время компиляции и используется как константа, которая может иметь разные значения в разных частях программы.
    После определения макропеременных начинается блок определения виртуальных переменных, однако переменных в этом макросе нет. После макроса proc необходимо ставить макрос enter, который содержит заключительную часть пролога, а между ними могут располагаться локальные переменные. Для того, что бы имена переменных были локальными перед ними ставится точка. Например .param. Макрос enter определён следующим образом:
    Код (ASM):
    1. macro enter
    2. {  dynamic_size = $ - dynamic_data
    3.    end virtual
    4.    enter dynamic_size,0
    5. }
    Таким образом dynamic_size - это размер памяти отведённой под локальные переменные. Последняя инструкция, в прологе процедуры, enter dynamic_size,0. Это единственная строка, которая попадёт в исполняемый код программы. Завершаться процедура должна макросом return, который определён следующим образом:
    Код (ASM):
    1. macro return                
    2. { leave
    3.    ret ..ret }
    Полагаю здесь не должно быть сложностей с пониманием макроса.
    Процедура должна правильно обрабатывать поступившие сообщения. Те сообщения, которые мы хотим обработать сами, выделяются в первых строках процедуры и управление передаётся на те участки кода, которые должны производить необходимые действия, а те сообщения, которые нам нет необходимости обрабатывать, мы доверяем обработать системе Windows (Def-WindowProc).
    Хочу обратить Ваше внимание на то, что в данной программе используются глобальные метки (wmdestroy, wmcreate, defwndproc), что не очень удобно в программах содержащих несколько процедур (большинство оконных процедур обрабатывают одни и те же сообщения), поэтому рекомендуется внутри процедур использовать локальные метки (.wmdestroy, .wmcreate, .defwndproc).
    Теперь пришло время посмотреть на секцию импорта. Она отличается от рассмотренной в предыдущем разделе здесь мы используем макрос library, который определён следующим образом:
    Код (ASM):
    1. macro library [label,string]
    2.  { forward
    3.     local _label
    4.     dd 0,0,0,rva _label,rva label
    5.    common
    6.     dd 0,0,0,0,0
    7.    forward
    8.     _label db string,0 }
    Для того, чтобы было более понятно вспомним, как в нашем примере используется этот макрос:
    Код (ASM):
    1. library kernel,'KERNEL32.DLL',\
    2.       user,'USER32.DLL'
    Таким образом, макрос library создаёт заголовок таблицы импорта, вначале записывая смещение названия библиотеки DLL, а затем смещение, с которого начинаются имена импортируемых функций.
    Далее следуют макросы import, определённые следующим образом:
    Код (ASM):
    1. macro import [label,string]
    2.  { forward
    3.     local _label
    4.     label dd rva _label
    5.    common
    6.     dd 0
    7.    forward
    8.     _label dw 0
    9.        db string,0 }
    Он создаёт тело таблицы импорта для каждой из импортируемых библиотек.
    Вначале создавая таблицу смещений имён импортируемых функций, а затем записывая имена импортируемых функций. Более подробно о структуре PE-файла Вы должны прочитать в соответствующей литературе (например в туториалах, которые написал Iczelion).
    После таблицы импорта создаётся таблица ресурсов:
    Код (ASM):
    1. section '.rsrc' resource data readable
    2.   directory   RT_ICON,icons,\
    3.         RT_GROUP_ICON,group_icons
    4.   icons:
    5.   resource 1,LANG_NEUTRAL,icon_data
    6.   group_icons:
    7.   resource 17,LANG_NEUTRAL,main_icon
    8.   icon main_icon,icon_data,'mp\lv\lv.ico'
    В нашем примере мы используем только одну иконку.
    Динамические библиотеки (DLL)
    Последним в данном разделе рассмотрим простую динамическую библиотеку.
    Динамическая библиотека - это приложение GUI, который может содержать как исполняемый код, так и ресурсы. Это приложение не предназначено для самостоятельного запуска, оно используется другими приложениями для хранения часто используемых процедур, шрифтов и многого другого.
    Мы рассмотрим создание динамической библиотеки на примере процедуры, возвращающей строку, содержащую текущую дату. Мы создадим два модуля один файл динамической библиотеки (dll2.dll) и файл использующий созданную нами библиотеку (usedll.exe).
    Вот файл динамической библиотеки:
    Код (ASM):
    1. format PE GUI 4.0 DLL
    2. entry DllEntryPoint
    3. include 'include\kernel.inc'
    4. include 'include\user.inc'
    5. include 'include\macro\stdcall.inc'
    6. include 'include\macro\import.inc'
    7. include 'c:\fasm135\include\lib\strings.mac'
    8. include 'include\macro\export.inc'
    9. section '.data' data readable writeable
    10.   _outs: times 60 db 0
    11.   Date SYSTEMTIME
    12.   day db 'День:',0
    13.   mon db ' Месяц:',0
    14.   year db ' Год:',0
    15.   h4: times 20 db 0
    16.   DllState db 'Состояние библиотеки DLL',0
    17.   DllStart db 'Загружена',0
    18.   DllStop  db 'Выгружена',0
    19.   bf: times 20 db 0
    20. section '.code' code readable executable
    21. proc DllEntryPoint, hinstDLL,fdwReason,lpvReserved
    22.     enter
    23.     cmp       [fdwReason],DLL_PROCESS_ATTACH
    24.     je    .start
    25.     cmp       [fdwReason],DLL_PROCESS_DETACH
    26.     je    .stop
    27.     jmp   .stp
    28.     .start:
    29.     invoke    MessageBox,0,DllStart,DllState,MB_OK
    30.     jmp   .stp
    31.     .stop:
    32.     invoke    MessageBox,0,DllStop,DllState,MB_OK
    33.     jmp   .stp
    34.    .stp:    
    35.     mov    eax,TRUE
    36.     return
    37. proc Wind
    38. enter
    39.     push    ebx esi edi
    40.     invoke     GetLocalTime,Date
    41.     mov     ebx,_outs
    42.     StringCopyHTML ebx,day
    43.     add     ebx,eax
    44.     xor     eax,eax
    45.     mov     ax,[Date.wDay]
    46.     stdcall  IntToString,h4,eax
    47.     StringCopyHTML ebx,h4
    48.     add     ebx,eax
    49.     StringCopyHTML ebx,mon
    50.     add     ebx,eax
    51.     xor     eax,eax
    52.     mov     ax,[Date.wMonth]
    53.     stdcall  IntToString,h4,eax
    54.     StringCopyHTML ebx,h4
    55.     add     ebx,eax
    56.     StringCopyHTML ebx,year
    57.     add     ebx,eax
    58.     xor     eax,eax
    59.     mov     ax,[Date.wYear]
    60.     stdcall  IntToString,h4,eax
    61.     StringCopyHTML ebx,h4
    62.     mov     eax,_outs
    63.     pop    edi esi ebx
    64. return
    65. proc IntToString,lpOutBuf,var
    66.    len dd 0
    67.        enter
    68.        push    ebx esi edx ecx esi
    69.        ;jmp .ex
    70.        cmp  [var],0
    71.        jne  .norr
    72.        mov   eax,[lpOutBuf]
    73.        mov   dx,030h
    74.        mov   [eax],dx
    75.        jmp  .ex
    76.        .norr:
    77.       mov  eax,10
    78.        mov  [len],eax  
    79.        xor eax,eax
    80.        xor edx,edx
    81.        xor ecx,ecx
    82.        mov  esi,bf
    83.        mov  eax,[var]
    84.        cmp eax,0
    85.        jne .ll
    86.        mov eax,48
    87.        mov [esi],al
    88.        inc esi
    89.        jmp .ext
    90.  .ll:  
    91.        div  [len]
    92.        add  dl,48
    93.        mov  [esi],dl
    94.        inc  esi
    95.        inc ecx
    96.        xor  edx,edx
    97.        cmp  eax,0
    98.        jne   .ll
    99.  .ext:
    100.       mov [esi],dl
    101.       mov eax,[lpOutBuf]
    102.       cmp ecx,0
    103.       je .ex
    104.   .l: dec esi
    105.       mov dl,[esi]
    106.       mov [eax],dl
    107.       inc  eax
    108.       dec  ecx
    109.       cmp  ecx,0
    110.       jne .l
    111.       mov  dl,0
    112.       mov  [eax],dl
    113.  .ex:     pop   esi    ecx edx esi ebx
    114. return
    115. section '.idata' import data readable writeable
    116.      _library kernel32,'KERNEL32.DLL',\
    117.          user32,'USER32.DLL';,\
    118.      include 'C:\FASM135\147\INCLUDE\apia\kernel32.inc'
    119.      include 'C:\FASM135\147\INCLUDE\apia\user32.inc'
    120. section '.edata' export data readable
    121.   export 'dll2.dll',Wind,'Wind'
    122. section '.reloc' fixups data discardable
    Первые строки format PE GUI 4.0 DLL и entry DllEntryPoint указывают компилятору создать РЕ-файл динамической библиотеки с точкой входа на метке DllEntryPoint.
    Как Вы могли заметить динамическая библиотека практически ни чем не отличается от обычной программы Windows, кроме того, что входная процедура вызывается системой в четырёх случаях:
    1. Когда динамическая библиотека загружается в адресное пространство процесса fdwReason = DLL_PROCESS_ATTACH
    2. Когда динамическая библиотека выгружается из адресного пространства процесса fdwReason = DLL_PROCESS_ DETACH
    3. Когда создается новый поток в рамках динамической библиотеки fdwReason = DLL_ THREAD_ATTACН
    4. Когда разрушается (прекращается) поток в рамках динамической библиотеки fdwReason = DLL_ THREAD_DETACH
    В обработке стартовой процедуры мы определяем значение параметра fdwReason и если динамическая библиотека была загружена или выгружена выдаём соответствующее сообщение.
     
    Последнее редактирование: 2 июн 2019
    rococo795 нравится это.
  4. Mikl___

    Mikl___ Супермодератор Команда форума

    Публикаций:
    14
    Регистрация:
    25 июн 2008
    Сообщения:
    2.784
    В конце файла мы создаём секцию экспорта нашей библиотеки:
    Код (ASM):
    1. section '.edata' export data readable
    2.   export 'dll2.dll',Wind,'Wind'
    3. section '.reloc' fixups data discardable
    В таблице мы задаём имя файла динамической библиотеки и имена экспортируемых процедур.
    Макрос export определён следующим образом:
    Код (ASM):
    1. macro export dllname,[label,string]
    2. { common
    3.     local module,addresses,names,ordinal,count
    4.     count = 0
    5.    forward
    6.     count = count+1
    7.    common
    8.     dd 0,0,0,rva module,1
    9.     dd count,count,rva addresses,rva names,rva ordinal
    10.     addresses:
    11.    forward
    12.     dd rva label
    13.    common
    14.     names:
    15.    forward
    16.     local name
    17.     dd rva name
    18.    common
    19.     ordinal: count = 0
    20.    forward
    21.     dw count
    22.     count = count+1
    23.    common
    24.     module db dllname,0
    25.    forward
    26.     name db string,0 }
    Сперва, объявляются локальные метки и подсчитывается количество экспортируемых процедур:
    Код (ASM):
    1. common
    2.     local module,addresses,names,ordinal,count
    3.     count = 0
    4.    forward
    5.     count = count+1
    6.    common
    Затем заносится смещение RVA имени библиотеки:
    Код (ASM):
    1.     dd 0,0,0,rva module,1
    Следующая строка заносит общее количество экспортируемых функций, количество функций экспортируемых по имени (при использовании этого макроса все функции экспортируются по имени), смещение начала массива смещений функций, смещение начала массива смещений имен экспортируемых функций и смещение массива смещений ординалов функций.
    Код (ASM):
    1.     dd count,count,rva addresses,rva names,rva ordinal
    Далее объявляется метка начала массива смещений экспортируемых функций и создаётся массив их смещения:
    Код (ASM):
    1. addresses:
    2.    forward
    3.     dd rva label
    Следом объявляется метка начала массива смещений имён экспортируемых функций и создаётся сам массив:
    Код (ASM):
    1. common
    2.     names:
    3.    forward
    4.     local name
    5.     dd rva name
    Затем объявляется метка начала массива смещений ординалов функций и создаётся массив ординалов экспортируемых функций:
    Код (ASM):
    1. common
    2.     ordinal: count = 0
    3.    forward
    4.     dw count
    5.     count = count+1
    Ну и в конце макроса записывается имя динамической библиотеки и создаётся массив имен экспортируемых функций:
    Код (ASM):
    1. common
    2.     module db dllname,0
    3.    forward
    4.     name db string,0
    Для более подробного ознакомления со структурой секции экспорта необходимо читать специальную литературу по структуре РЕ - файлов.
    Теперь давайте посмотрим, на программу вызывающую нашу динамическую библиотеку:
    Код (ASM):
    1. format PE GUI 4.0
    2. entry start
    3. include 'include\kernel.inc'
    4. include 'include\user.inc'
    5. include 'include\macro\stdcall.inc'
    6. include 'include\macro\import.inc'
    7. section '.data' data readable writeable
    8.  
    9.   podskazka db 'Функция Wind возвратила указатель на строку:',0
    10. section '.code' code readable executable
    11.   start:
    12.    invoke Wind
    13.    invoke MessageBox,0,eax,podskazka,MB_OK
    14.    invoke ExitProcess,0
    15. section '.idata' import data readable writeable
    16.   library kernel,'KERNEL32.DLL',\
    17.       user,'USER32.DLL',\
    18.       MyDll,'C:\FASM135\mp\Dll2\Dll2.DLL'
    19.   kernel:
    20.   import      ExitProcess,'ExitProcess'
    21.   user:
    22.   import      MessageBox,'MessageBoxA'
    23.  MyDll:
    24.   import Wind,'Wind'
    Обычное графическое приложение не имеющее своего окна и ресурсов размером 2 кБ. Импортирует только три функции две предоставляемые системой Windows и одна написанной нами динамической библиотекой. Как видите подключение созданной нами динамической библиотеки, ничем не отличается от подключения стандартных библиотек Windows. В этом и заключается вся прелесть использования FASM-а, он не берёт на себя слишком много, что в купе с гибким макроязыком позволяет сделать очень многое максимально просто.
    Формат исполняемых файлов MS COFF (obj - файлы)
    Использование obj-файлов в FASM, лично мне, не кажется жизненно необходимым, однако использование этого формата возможно понадобится при создании проектов на С/С++. Именно на таком примере мы и рассмотрим формат файлов MS COFF.
    Для примера напишем программу, выводящую MessageBox с текущей датой. Модуль на ассемблере будет составлять строку символов, а модуль на С++ будет выводить эту строку в MesageBox.
    Вот модуль на ассемблере:
    Код (ASM):
    1. format MS COFF
    2. ;public _WinMainCRTStartup
    3. public _outs
    4. public ?Wind@@YAPADXZ
    5. extrn '__imp__GetLocalTime@4' as GetLocalTime:dword
    6. include 'include\kernel.inc'
    7. include 'include\macro\stdcall.inc'
    8. include 'c:\fasm135\include\lib\strings.mac'
    9. include 'c:\fasm135\include\lib\strings.asm'
    10. section '.text' code readable executable
    11.  ; _WinMainCRTStartup:
    12. proc ?Wind@@YAPADXZ
    13.     enter
    14.     push    ebx esi edi
    15.     invoke   GetLocalTime,Date
    16.     mov      ebx,_outs
    17.     StringCopyHTML ebx,day
    18.     add      ebx,eax
    19.     xor      eax,eax
    20.     mov      ax,[Date.wDay]
    21.     stdcall  IntToString,h4,eax
    22.     StringCopyHTML ebx,h4
    23.     add      ebx,eax
    24.     StringCopyHTML ebx,mon
    25.     add      ebx,eax
    26.     xor      eax,eax
    27.     mov      ax,[Date.wMonth]
    28.     stdcall  IntToString,h4,eax
    29.     StringCopyHTML ebx,h4
    30.     add      ebx,eax
    31.           StringCopyHTML ebx,year
    32.     add      ebx,eax
    33.     xor      eax,eax
    34.     mov      ax,[Date.wYear]
    35.     stdcall  IntToString,h4,eax
    36.     StringCopyHTML ebx,h4
    37.     add      ebx,eax
    38.     mov      eax,_outs
    39.     pop    edi esi ebx
    40.     return
    41. section '.data' data readable writeable
    42.   h4    db 'Сообщение',0
    43.   Date SYSTEMTIME
    44.   day db 'День:',0
    45.   mon db ' Месяц:',0
    46.   year db ' Год:',0
    47.   _outs: times 30 db 0
    Обратите внимание на строку 2, где закомментировано определение точки входа в программу (_WinMainCRTStartup) если эту строку раскомментировать, то точка входа в программу будет именно в модуле на ассемблере. Результат работы функции записывается в переменную _outs и адрес (указатель на строку) возвращаем в регистре еах. В этом модуле используются макросы копирования строки в строку (StringCopyHTML ebx,day). Этот макрос не входит в поставку компилятора и содержится в файлах strings.mac и strings.asm он просто копирует строку (не включая нулевой символ), указатель на которую передаётся вторым параметром, в строку, указатель которой передаётся вторым параметром, после его выполнения в регистре еах количество скопированных символов. Эта процедура выдаёт строку типа: "День: 28 Месяц: 10 Год:2003". Для использования объектного модуля созданного на ассемблере необходимо в проект на С++ добавить созданный нами объектный файл (Project->Add to project->Files. . . в появившемся окне необходимо выбрать тип файлов obj и указать используемый файл). Теперь рассмотрим текст программы на MS Visual C++ 5.0:
    Код (C):
    1. #include «windows.h»
    2. extern  char *  __cdecl Wind(void);
    3. LPSTR cmsk,dat;
    4.  
    5. int PASCAL WinMain(HANDLE   hInstance,HANDLE hPrevInstance,LPSTR lpszCmdParam,int nCmdShow)
    6. {
    7.     dat=Wind();
    8.     MessageBox(0,dat,dat,MB_OK);
    9. }
    Здесь ничего сложного: подключаем файл «windows.h», затем объявляем внешнюю процедуру, возвращающую указатель на строку символов с нулём в конце, объявляем переменную dat, как указатель на строку символов, и наконец функция WinMain в которой вызываем нашу функцию (Wind) на ассемблере и выводим результат в MessageBox. Внимательный читатель скажет: "Стоп, но в модуле на ассемблере функцию мы объявили как ?Wind@@YAPADXZ, а в модуле на С++ вызываем Wind". Всё правильно. Просто MS Visual C++ 5.0, к объявленным внешним (находящимся в скомпилированных модулях) процедурам добавляет дополнительные символы, для контроля соответствия типов передаваемых результатов из процедуры и переменных в процедуру. Вот краткая структура имени функций формируемых MS Visual C++:
    ПрефиксОбъявленное имя переменнойРазделительТип вызова процедурыТип результатаТип параметровПостфикс
    ?Wind@@YAPADXZ
    Причём постфикс изменяется в зависимости от наличия передаваемых в функцию параметров. Если параметры передаются, то постфикс "@Z", а если параметры не передаются то просто "Z".
    Типы вызова процедуры следующие:
    __cdeclA
    __fastcallI
    __stdcallG
    Типы результата и передаваемых переменных имеют одинаковые обозначения:
    Тип результатаРазмерОбозначение
    char1D
    unsigned char1E
    short2F
    unsigned short2G
    enum2?AW4__unnamed@@
    long4J
    unsigned long4K
    int4H
    unsigned int4I
    float4M
    double8N
    long double10O
    bool1_N
     
    Последнее редактирование: 2 июн 2019
    rococo795 нравится это.
  5. Mikl___

    Mikl___ Супермодератор Команда форума

    Публикаций:
    14
    Регистрация:
    25 июн 2008
    Сообщения:
    2.784
    Причём если передаётся (получается) не параметр, а его адрес (например char *) то перед обозначением переменной добавляется PA. Если параметры, получаемые из процедуры или передаваемые в процедуру, отсутствуют, вместо них ставится X.
    Читатель может сказать: "Это как же нужно мозг морщить, чтобы всё запомнить и не перепутать ничего при составлении имени процедуры?". Такая работа имеет основное свойство: она не особо интеллектуальна, но муторна и действия при её решении вполне укладываются в рамках алгоритма. Отсюда вывод: компьютер на то и создан, что бы выполнять подобные задачи так пусть сам, и добавляет все эти префиксы, постфиксы и т.п. Напишем макрос, который будет объявлять процедуру составляя её имя из имени которое мы ему передаём и добавляя к нему все необходимые префиксы.
    Использовать переменные длиннее 4 байт мы не будем, но думаю Вы сами сможете модернизировать макросы под свои нужды если понадобится.
    Для начала мы должны определить символьные константы, соответствующие типам вызова процедуры и типам получаемых и возвращаемых параметров:
    Код (ASM):
    1. ; константы типов вызовов процедур
    2. __cdecl fix A
    3. __fastcall fix I
    4. __stdcall fix G
    5. ; константы типов переменных
    6. void fix X
    7. char$ fix PAD
    8. char  fix D
    9. unsigned_char$ fix PAE
    10. unsigned_char fix E
    11. short$ fix PAF
    12. short fix F
    13. unsigned_short$ fix PAG
    14. unsigned_short fix G
    15. long$ fix PAJ
    16. long fix J
    17. unsigned_long$ fix PAK
    18. unsigned_long fix K
    19. int$ fix PAH
    20. int fix H
    21. unsigned_int$ fix PAI
    22. unsigned_int fix I
    23. float$ fix PAM
    24. float fix M
    Далее следует определение макроса:
    Код (ASM):
    1. macro exp_proc calltype,returns,name,[arg,type]
    2. {
    3. dr fix
    4. forward
    5.  dr fix dr#type
    6.  common
    7. if type eq void
    8. public ?#name#@@Y#calltype#returns#dr#Z
    9. ?#name#@@Y#calltype#returns#dr#Z:
    10. else
    11. public ?#name#@@Y#calltype#returns#dr#@Z
    12. ?#name#@@Y#calltype#returns#dr#@Z:
    13. end if
    14. common
    15.  virtual at ebp+8
    16.     if ~ arg eq
    17.    forward
    18.      local ..arg
    19.      ..arg dd ?
    20.      arg equ ..arg
    21.    common
    22.      end if
    23.      ..ret = $ - (ebp+8)
    24.     end virtual
    25.     local ..dynamic_data,..dynamic_size
    26.     dynamic_data equ ..dynamic_data
    27.     dynamic_size equ ..dynamic_size
    28.     virtual at ebp - dynamic_size
    29.      dynamic_data:
    30. }
    В первой строке мы очищаем временную символьную константу, далее следует указание препроцессору обработать строку
    Код (Text):
    1. dr fix dr#type
    для всех значений параметров type начиная с первого. Эта строчка, просто создаёт константу содержащую все символы соответствующие всем получаемым процедурой параметрам. Например если в процедуру передаётся два параметра типа int, то dr будет эквивалентно HH. Далее следует указание препроцессору следующие строки обработать только один раз (common) в этих строках мы делаем видимой из других модулей программы метку (название) нашей процедуры и собственно следует содержимое макроса proc, рассмотренного ранее.
    Полагаю, этот макрос не должен вызвать затруднений. Сложности в понимании может вызвать только строка
    Код (Text):
    1. ?#name#@@Y#calltype#returns#dr#@Z
    объясню её более подробно. Сперва стоит знак вопроса (посмотрите табличку со структурой имени процедуры), после которого, значок номера (#), он говорит препроцессору, что далее следует символьная константа, которую следует склеить в одну метку с предыдущим текстом. Если константы с указанным именем не существует, то она включается, как есть. Рассмотрим последовательность действий препроцессора. Метка состоит из вопросительного знака, затем (без разделителей) добавляется, передаваемая макросу переменная name, после неё добавляется текст @@Y,после текста добавляется передаваемая макросу переменная calltype, затем переменная returns, потом составленная нами константа dr, и наконец постфикс @Z (или просто Z, если в процедуру не передаются параметры).
    Всё. Макрос создан. Однако это ещё не всё. С таким определением процедуры не всегда можно использовать стандартные макросы enter и return т.к. тип вызова __cdecl предполагает, что стек после завершения работы процедуры будет очищаться вызывающей процедурой т.е. модулем написанным на С++, а стандартный макрос return сам очищает стек. Вот макрос, содержащий эпилог процедуры для типа вызова __cdecl:
    Код (ASM):
    1. macro cdecl_ret
    2.     {
    3.       sub   ebp,dynamic_size
    4.       mov     esp,ebp
    5.       pop     ebp
    6.       ret
    7.     }
    Но не только эпилог нужно изменить, но и пролог тоже:
    Код (ASM):
    1. macro cdecl_enter
    2.     {
    3.       dynamic_size = $ - dynamic_data
    4.         end virtual
    5.         push  ebp
    6.         mov   ebp,esp
    7.         add   ebp,dynamic_size
    8.     }
    Полагаю эти два коротеньких макроса не вызовут затруднений.
    Ну и пример использования данных макросов:
    Код (ASM):
    1. exp_proc __cdecl,char$,Wi,first,int,second,int
    2.  cdecl_enter
    3.    push    ebx esi edi
    4.    mov    eax,[first]
    5.    stdcall IntToString, _outs,eax
    6.    mov    eax,_outs
    7.    pop    edi esi ebx
    8.  cdecl_ret
    Функция IntToString преобразует 32-х битное без знаковое число (второй параметр) в строку (адрес строки передаётся первым параметром).
    Модуль на С++ будет выглядеть следующим образом:
    Код (C):
    1. #include
    2. extern  char * __cdecl Wind(void);
    3. extern  char * __cdecl Wi(int c,int b);
    4. LPSTR cmsk,dat;
    5. int PASCAL WinMain(HANDLE   hInstance,HANDLE   hPrevInstance,LPSTR    lpszCmdParam,int      nCmdShow)
    6. {
    7.     dat=Wi(12,30);
    8.     MessageBox(0,dat,dat,MB_OK);
    9.     Wind();
    10. MessageBox(0,dat,dat,MB_OK);
    11. }
    Думаю больше пояснений не нужно.
    Форматы исполняемых файлов MS DOS
    Формат исполняемых файлов EXE

    Программирование под DOS в FASM в принципе почти ничем не отличается от программирования под DOS в любом другом компиляторе.
    Вот простейший пример программы:
    Код (ASM):
    1. format MZ
    2.     push    cs
    3.     pop    ds
    4.     mov    ah,9
    5.     mov    dx,hello
    6.     int    21h
    7.     mov    ax,4C00h
    8.     int    21h
    9. hello db 'Hello world!',24h
    Как видите ничего сложного.
    Формат исполняемых файлов СОМ
    Если директива format не указана создаются файлы формата *.сом. Вот пример:
    Код (ASM):
    1. org 100h ;Указание загрузить программу начиная с адреса 100h
    2. use16        ;Создавать 16-ти битный код
    3.         mov    ah,9
    4.         mov    dx,hello
    5.         int    21h
    6.         int    20h
    7. hello db 13,10,'Привет всем$'
    Думаю здесь всё понятно.


    © pas
     
    Последнее редактирование: 2 июн 2019
    rococo795 нравится это.