Как запустить программу на ассемблере в windows

Время на прочтение
4 мин

Количество просмотров 40K

В данной статье разбирается способ установки интерпретатора и запуск файла EXE через DOSBox. Планировалось погрузить читателя в особенности программирования на TASM, но я согласился с комментаторами. Есть много учебников по Ассемблер и нет смысла перепечатывать эти знания вновь. Лично мне в изучении очень помог сайт av-assembler.ru. Рекомендую. В комментариях также вы найдёте много другой литературы по Assembler. А теперь перейдём к основной теме статьи.

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

Почему именно vk.com?

Я прекрасно понимаю, что это ещё тот колхоз делиться файлами через обсуждения VK, но кто знает, во что может превратиться эта маленькая группа в будущем.

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

Для запуска интерпретатора нам так же потребуется эмулятор DOSBox. Он и оживит все наши компоненты. Скачаем и установим его!
Ссылка

В папке Asm я специально оставил файл code.asm. Именно на нём мы и потренируемся запускать нашу программу. Советую сохранить его копию, ибо там хранится весь код, который в 99% случаев будет присутствовать в каждом вашем проекте.

code.asm

s_s segment
s_s ends

d_s segment
d_s ends

c_s segment
assume ss:s_s, ds:d_s, cs:c_s
begin:
mov ax, d_s
mov ds, ax
mov ax, 0

	; Your code needs to be here

mov ah, 4ch
int 21h
c_s ends
end begin

Итак. Запускаем наш DOSBox и видим следующее:

Для простоты сопоставим имя пути, по которому лежит наша папка Asm. Чтобы это сделать, пропишем следующую команду:

mount d: c:\asm

Здесь вместо d: мы можем использовать любую другую букву. Например назвать i или s. А C это наш реальный диск. Мы прописываем путь до наших файлов ассемблера.

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

d:

Прописав команду dir, мы сможем увидеть все файлы, которые там хранятся. Здесь можно заметить и наш файл CODE с расширением ASM, а также дату его создания.

И только теперь мы начинаем запускать наш файл! Бедные программисты 20 века, как они только терпели всё это? Пропишем следующую команду:

tasm code.asm

После мы увидим следующее сообщение, а наша директория пополнится новым файлом с расширением OBJ.

Теперь пропишем ещё одну команду:

tlink code.obj

В нашей папке появилась ещё пара файлов – CODE.MAP и  CODE.EXE. Последний как раз и есть исполняемый файл нашего кода assembler.

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

td code

Этот старинный интерфейс насквозь пропитан духом ушедшей эпохи старых операционных систем. Тем не менее…

Нажав F7 или fn + F7 вы сможете совершить 1 шаг по коду. Синяя строка начнёт движение вниз, изменяя значения регистров и флагов. Пока это всего лишь шаблон, на котором мы потренировались запускать нашу программу в режиме дебага. Реальное “волшебство” мы увидим лишь с полноценным кодом на asm.

Небольшой пример для запуска

s_s segment 
dw 20 dup('$')
s_s ends

d_s segment
string db '()','$';
result db 0
d_s ends

c_s segment
assume ss:s_s,ds:d_s,cs:c_s
begin: ; начало программы
mov ax,d_s
mov ds,ax
xor ax,ax

lea si, string

;Ищем в строке скобку
search:
    lodsb

    ;Проверка, это конец строки?
    cmp al, '$'
    je endString

    ;Это открывающая или закрывающая скобка?
        ;Это открывающие скобки?
        cmp al, '('
        je inStack
        cmp al, '{'
        je inStack
        cmp al, '['
        je inStack

        ;Это закрывающие скобки?
        cmp al, ')'
        je outStack
        cmp al, '}'
        je outStack
        cmp al, ']'
        je outStack
        jmp search

        ;Помещаем скобку в Stack, увеличиваем счётчик
        inStack:
            inc cx
            push ax
            jmp search

        ;Выниманием из Stack скобку, проверяем пару
        outStack:
            ;Была передана лишняя закрыв. скобка?
            cmp cx, 0
            je error3

            dec cx
            pop bx
            
            ;Вскрытая скобка закрыта верно?
            cmp bl, '('
            jne close1
            cmp al, ')'
            jne error1
            jmp search

            close1:
            cmp bl, '['
            jne close2
            cmp al, ']'
            jne error1
            jmp search

            close2:
            cmp bl, '{'
            cmp al, '}'
            jne error1
            jmp search

    ;Остались ли незакрытые скобки?
    endString:
    cmp cx, 0
    jne error2
    jmp exit

    ;Скобки остались, это ошибка №2
    error2:
    mov result, 2
    jmp exit

    ;Лишняя скобка передана, ошибка №3
    error3:
    mov result, 3
    jmp exit

    ;Закрывающая скобка несоответствует открывающей, ош №1
    error1:
    mov result, 1
    jmp exit


    ;Пред-завершение. Каков результат программы?
    exit:
    cmp result, 1
    jne enough
    
    ;Ищем нужную скобку для исправления ошибки №1
    cmp bl, '('
    jne next1
    mov bl, ')'
    jmp enough

    next1:
    cmp bl, '{'
    jne next2
    mov bl, '}'
    jmp enough

    next2:
    cmp bl, '['
    mov bl, ']'
    jmp enough


enough:
mov dl, result
xor dx, dx
mov dl, bl 

mov ah,4ch
int 21h
c_s ends
end begin

Давайте ознакомимся с имеющимися разделами.

CS

Code segment – место, где turbo debug отражает все найденные строки кода. Важное замечание – все данные отражаются в TD в виде 16-ричной системы. А значит какая-нибудь ‘12’ это на самом деле 18, а реальное 12 это ‘C’. CS аналогичен разделу “Begin end.” на Pascal или функции main.

DS

Data segment, отражает данные, которые TD обнаружил в d_s. Справа мы видим их символьную (char) интерпретацию. В будущем мы сможем увидеть здесь наш “Hello, world”, интерпретируемый компилятором в числа, по таблице ASCII. Хорошей аналогией DS является раздел VAR, как в Pascal. Для простоты можно сказать, что это одно и тоже.

SS

Stack segment – место хранения данных нашего стека.

Регистры

Все эти ax, bx, cx, si, di, ss, cs и т. д. – это наши регистры, которые используются как переменные для хранения данных. Да, это очень грубое упрощение. Переменные из Pascal и регистры Assembler это не одно и тоже, но надеюсь, такая аналогия даёт более чёткую картину. Здесь мы сможем хранить данные о циклах, арифметических операциях, системных прерываниях и т. д.

Флаги

Все эти c, z, s, o, p и т.д. это и есть наши флаги. В них хранится промежуточная информация о том, например, было ли полученное число чётным, произошло ранее переполнение или нет. Они могут хранить результат побитого сдвига. По опыту, могу сказать, на них обращаешь внимание лишь при отладке программы, а не во время штатного исполнения.

Ещё одно замечание. Если вы измените данные исходного файла с расширением .ASM, то вам придётся совершить все ранее описанные операции вновь, ибо обновив например code.asm вы не меняете code.obj или code.exe.

Маленькая шпаргалка для заметок:

1. mount d: c:\asm – создаём виртуальный диск, где корень –папка asm

2. d: — открываем созданный диск

3. tasm code.asm – компилируем исходный код

4. tlink code.obj – создаём исполняемый файл

5. td code – запускаем debug

6. F7 – делаем шаг в программе

Буду ждать комментарии от всех, кому интересен Assembler. Чувствую, я где-то мог накосячить в терминологии или обозначении того или иного элемента. Но статья на Habr отличный повод всё повторить.

Последнее обновление: 01.07.2023

Установка MASM

Для работы с MASM надо установить для Visual Studio инструменты разработки для C/C++. Поэтому после загрузки программы установщика Visual Studio запустим ее и в окне устанавливаемых
опций выберем пункт Разработка классических приложений на C++:

Visual Studio включает как 32-разрядные, так и 64-разрядные версии MASM. 32-раздяная версия представляет файл ml.exe,
а 64-разрядная — файл ml64.exe. Точное расположение файлов может варьироваться от версии Visual Studio. Например, в моем случае это папка
C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.35.32215\bin\Hostx64\x64

Для использования MASM64 перейдем к меню Пуск и в списке программ найдем пункт Visual Studio и подпункт
x64 Native Tools Command Prompt for VS 2022

Нам должна открыться консоль. Введем в нее ml64, и нам отобразится версия ассемблера и некоторая дополнительная информация:

**********************************************************************
** Visual Studio 2022 Developer Command Prompt v17.5.5
** Copyright (c) 2022 Microsoft Corporation
**********************************************************************
[vcvarsall.bat] Environment initialized for: 'x64'

C:\Program Files\Microsoft Visual Studio\2022\Community>ml64
Microsoft (R) Macro Assembler (x64) Version 14.35.32217.1
Copyright (C) Microsoft Corporation.  All rights reserved.

usage: ML64 [ options ] filelist [ /link linkoptions]
Run "ML64 /help" or "ML64 /?" for more info

C:\Program Files\Microsoft Visual Studio\2022\Community>

Стоит отметить, что запуск этой этой утилиты фактически представляет запуск файла C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Auxiliary\Build\vcvars64.bat —
он по сути вызывает другой файл — vcvarsall.bat, который собственно и настраивает окружение для выполнения ассемблера.

Структура программы на ассемблере MASM

Типичная программа на MASM содержит одну или несколько секций, которые определяют, как содержимое программы будет располагаться в памяти. Эти секции
начинаются с таких директив MASM, как .code или .data. Данные, используемые в программе, обычно определяются в секции .data.
Инструкции ассембра определяются в секции .code.

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

.code

main proc
 
  ret
main endp

end

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

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

Далее с помощью операторов main proc определяется процедура main. Операторы main endp указывают на конец функции main.
Между main proc и main endp располагаются выполняемые инструкции ассемблера. Причем в самом конце функции идет инструкция ret,
с помощью которой выполнение возвращается в окружение, в котором была вызвана даннуа процедура.

В конце файла кода идет инструкция end

Программа может содержать комментарии, которые располагаются после точки с запятой:

.code   ; начало секции с кодом программы

main proc   ; Функция main
 
 ret ; возвращаемся в вызывающий код
 
main endp ; окончание функции main

end ; конец файла кода

Комментарии на работу программы никак не влияют и при компиляции не учитываются.

Компиляция программы

Компиляция программы на MASM обычно происходит в командной строке. Например, воспользуемся кодом выше и напишем простейшую программу на ассемблере, которая ничего
не делает. Для этого определим на жестком диске папку для файлов с исходным кодом. Допустим, она будет называться
C:\asm. И в этой папке создадим новый файл, который назовем hello.asm и в котором определим следующий код:

.code   ; начало секции с кодом программы

main PROC   ; Функция main
 
 ret ; возвращаемся в вызывающий код
 
main ENDP

END ; конец файла кода

Откроем программу x64 Native Tools Command Prompt for VS 2022 и перейдем в ней к папке, где располагается файл hello.asm. Затем выполним следующую команду

ml64 hello.asm /link /entry:main

В данном случае вызываем приложение ml64.exe и передаем ему для компиляции файл hello.asm. А флаг /link указывает MASM
скомпоновать скомпилированный файл в файл приложения exe, а все дальнейшие параметры (в частности, параметр /entry:main) передаются компоновщику.
Параметр /entry:main передает компоновщику имя основной процедуры/функции, с которой начинается выполнение программы.
Компоновщик сохраняет этот адрес этой процедуры/функции в специальном месте исполняемого файла, чтобы Windows могла определить начальный адрес основной программы после загрузки исполняемого файла в память.

В результате ассемблер скомпилирует ряд файлов

**********************************************************************
** Visual Studio 2022 Developer Command Prompt v17.5.5
** Copyright (c) 2022 Microsoft Corporation
**********************************************************************
[vcvarsall.bat] Environment initialized for: 'x64'

C:\Program Files\Microsoft Visual Studio\2022\Community>cd c:\asm

c:\asm>ml64 hello.asm /link /entry:main
Microsoft (R) Macro Assembler (x64) Version 14.35.32217.1
Copyright (C) Microsoft Corporation.  All rights reserved.

 Assembling: hello.asm
Microsoft (R) Incremental Linker Version 14.35.32217.1
Copyright (C) Microsoft Corporation.  All rights reserved.

/OUT:hello.exe
hello.obj
/entry:main

c:\asm>

В итоге в каталоге программы будут сгенерированы объектный файл hello.obj и собственно файл программы — hello.exe.

Запуск
.EXE-программы
может быть осуществлён с помощью двойного
щелчка мышью.

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

2.4. Инструментальный пакет masm32

В
п.2.3 отмечено, что для создания программ
на ассемблере в Windows,
необходим текстовый редактор и компилятор.
Реальные программы Win32 используют также
внешние функции, стандартные константы
и переменные, ресурсы и много другое.
Всё это требует дополнительных файлов,
которые есть в инструментальном пакете
MASM32. Важно понять, что MASM32 не компилятор,
а сборник для программирования под
Win32, в который входит 32-битный компилятор
MASM.

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

Основные сведения и порядок работы в пакете masm32:

1.
Для создания исходных текстов программ
рекомендуется использовать текстовый
процессор пакета MASM32
под названием QEDITOR
(от Quick
Editor,
быстрый редактор):

После
набора сохранить текст программы
командой File
– Save,
указать папку BIN
и расширение .ASM,
например MYPROG.ASM.

2.
Командой Project
– Build
All
создать объектный и исполнимый файлы:

Если
исходный текст программы набран без
ошибок, то в папке, где он хранился,
увидим два новых файла: MYPROG.OBJ
и MYPROG.EXE.

3.
Когда объектный и исполнимый файлы
созданы, запустите программу на
выполнение. Для этого можно дважды
щелкнуть мышью по названию исполнимого
файла (в папке BIN)
или запустить программу через редактор
QEDITOR
командой Project
– Run
Program.

2.5. Примеры

Пример
0.
«Скелет»
стандартной программы

.386

.model flat, stdcall

option casemap :none

;подключение
необходимых
библиотек

include
\MASM32\INCLUDE\windows.inc

include
\MASM32\INCLUDE\masm32.inc

include
\MASM32\INCLUDE\gdi32.inc

include
\MASM32\INCLUDE\user32.inc

include
\MASM32\INCLUDE\kernel32.inc

includelib
\MASM32\LIB\masm32.lib

includelib
\MASM32\LIB\gdi32.lib

includelib
\MASM32\LIB\user32.lib

includelib
\MASM32\LIB\kernel32.lib

;раздел, где
объявляются все константы

.const

;раздел, где
объявляются переменные, уже имеющие
какое-то значение

.data

;раздел, где
объявляются переменные, еще не имеющие
значения

.data?

.code

start: ;с этого слова
начинается код программы

invoke ExitProcess,0

end start ;с этого
слова заканчивается код программы

Сохраните
этот «скелет» в отдельном файле для
удобства и используйте как заготовку.

Пример
1.
Структура
программы и основные директивы

Построчно
разберём простейшую программу.

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

Начнем
с простого. В первой программе не будет
вызовов API-функций,
ее цель – понять саму структуру программы
на языке ассемблера для Windows.
Поэтому программа, прибавляющая к 2
число 3, будет выглядеть следующим
образом:

.386

.model
flat, stdcall

.code

start:

mov
eax, 8

add
eax, 8

ret

end
start

В
ней инструкции процессора mov,
add,
ret
окружены
директивами. Первые три директивы
начинаются с точки.

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

Вторая
директива .model
flat,
stdcall
показывает,
в какой среде будет работать программа.
Все программы работают под управлением
операционной системы, которая их
запускает и обеспечивает взаимодействие
с внешней средой. Директива .model задаёт
модель памяти flat (плоская или сплошная)
для нашей программы. Эта модель памяти
используется для программирования под
Windows,
т.е. директива говорит о том, что именно
для операционных систем семейства
Windows
95²
предназначена программа.

Stdcall
— это «уговор» о том, кто будет
чистить параметры (функция, которую
вызвали, или сам вызывающий). Мы всегда
будем использовать вариант «функция
чистит свои параметры». Он и называется
stdcall. Однако такое объяснение не полное,
и мы вернемся к параметру stdcall при
объяснении вызова функций. К этому
моменту вы уже будете знать, что такое
стек.

Третья
директива .code
показывает,
где начинаются сами команды процессора.
Когда операционная система пытается
запустить программу, она ищет в ней
инструкцию, с которой нужно начать, и
отправляет ее процессору. Когда же
инструкции кончаются, операционная
система «подхватывает» программу и
помогает ей правильно завершиться,
чтобы освободить место другим, ведь
Windows
– многозадачная операционная система,
способная выполнять одновременно
несколько программ. Уйти из-под «опеки»
операционной системы помогает инструкция
ret.

Инструкция,
с которой начинается программа, обычно
помечается последовательностью символов
с двоеточием на конце (меткой). В нашем
случае это start:.
Там, где оканчивается последовательность
команд процессора, в программе должна
стоять директива end
<метка первой инструкции программы>,
в нашем случае это
end
start.
Эта директива, а также сама метка не
переводятся в инструкции ассемблера,
а лишь помогают получить программу,
которую способен выполнить процессор.
Без них программа-ассемблер не поймет,
с какой инструкции процессор начнет
работу.

Отладка

Программа
ничего не выводит на экран, поэтому за
для изучения её работы воспользуемся
программой-отладчиком OllyDbg.
Чтобы открыть программу в отладчике,
достаточно загрузить OllyDbg и открыть
программу как обычный документ –
File-Open.

В
верхней левой части отладчика можно
увидеть свою программу. Вверху справа
– регистры процессора.

Внизу
слева — байты памяти (OllyDbg сразу же
показывает секцию данных программы).
Внизу справа отображается содержимое
стека (работа со стеком будет описана
ниже).

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

С
помощью клавиши F8
можно выполнить программу по шагам и
просмотреть, как меняется содержимое
регистров. Ответьте на вопрос, почему
в результате сложения 8+8 регистр EAX
стал равен 10? Состояние флагов также
меняется. Мы видим, что после выполнения
первой команды флаг Z
опустился (обратился в ноль), потому что
результат выполнения операции не равен
нулю.

Пример
2.
Использование
функций API

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

API
– это стандартные функции, на основе
которых и пишут все программы для
Windows.
Например MessageBox выдаёт сообщение на
экран, PostQuitMessage сообщит Windows, что программа
хочет закончить работу и т.д. Все они
уже готовы – остается только вызывать
их. Получается, что используя API-функции,
мы применяем элементы программирования
высокого уровня.

Находятся
API-функции
обычно в динамически загружаемых
библиотеках – файлах с расширением
.DLL.

При
вызове каждой API-функции
надо передавать параметры, т.е. аргументы,
с которыми ей предстоит работать. Раньше
это делалось так: параметры заталкивались
в стек (команда push) задом наперед –
сначала последний, потом предпоследний
и т.д., а затем вызывалась сама программа
(команда call). Например:

push addr Text2

push addr Text1

push hWnd

call MessageBox

Такая
запись допускается и сейчас, но существует
и более компактная: invoke
MessageBox, hWnd, Text1, Text2

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

Рассмотрим
программу с использованием функций
API.
Прежде чем приступить к выводу на экран,
изучим более простую процедуру
ExitProcess.
Её
вызывает каждая Windows-программа,
чтобы завершить свою работу. В ассемблере
под DOS
мы пользовались инструкцией возврата
ret.
Но ExitProcess
действует
правильнее, не только возвращая управление
операционной системе, но и освобождая
занятые программой ресурсы.

В
следующем листинге показана программа
для Windows,
которая только и делает, что правильно
завершается.

.386

.model flat, stdcall

option casemap:none

includelib
C:\MASM32\LIB\kernel32.lib

ExitProcess proto :DWORD

.code

start:

push 0

call
ExitProcess

end
start

Вызываемая
в ней процедура ExitProcess
требует
одного параметра – это код завершения,
возвращаемый операционной системе. Он
передается процедуре командой push
0.
Число 0 считается признаком удачного
завершения.

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

Сведения
об адресе и параметрах процедуры хранятся
в файле библиотеки kernel32.lib,
который подключается к ассемблерному
тексту директивой includelib
C:\MASM32\LIB\kernel32.lib.

Перед
тем как создать инструкцию вызова этой
процедуры компоновщик сравнивает
сведения из библиотеки с прототипом
ExitProcess
proto
:DWORD,
и если все совпадает, создает пригодный
к исполнению файл с расширением .EXE.
Прототип процедуры очень прост и состоит
из имени, слова proto
и
параметров. В нашем случае параметр
один – это двойное слово (то есть 4 байта)
DWORD.
Если параметров несколько, они разделяются
запятой.

Пример
3.
Вывод
строки на экран

Создадим
программу, выводящую на экран фразу
“Hello,
world!”:

.386

.model
flat, stdcall

option casemap:none

ExitProcess proto :dword

GetStdHandle
proto :dword

WriteConsoleA proto :dword,
:dword, :dword, :dword, :dword

includelib
C:\MASM32\LIB\kernel32.lib

.data

stdout dd ?

msg db “Hello, world!”,
0dh, 0ah

cWritten dd ?

.code

start:

invoke GetStdHandle, -11

mov stdout, eax

invoke WriteConsoleA,
stdout, ADDR msg, sizeof msg, ADDR cWritten, 0

invoke
ExitProcess,
0

end
start

В
программе вызываются три процедуры:
GetStdHandle,
WriteConsoleA
и
ExitProcess.

Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]

• #
• #
• #
• #
• #
• #
• #
• #
• #
• #
• #

Создание проекта консольного или оконного Windows-приложения не отличается от рассмотренного для языков программирования Си и C++.

После того, как в Visual Studio появилось окно проекта (в левой части появившегося окна отображается Обозреватель решений), для добавления нового файла программы в проект выбираем по правой кнопке мыши на папке Файлы исходного кода меню Добавить->Создать элемент.
В появившемся окне выбираем Файл C++ (.cpp), задаем имя файла и вручную добавляем к нему расширение asm. Нажимаем кнопку Добавить.

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

.686P
.MODEL FLAT, STDCALL
.STACK 4096
.DATA
MB_OK    EQU 0
STR1     DB «Моя первая программа»,0
STR2     DB «Привет всем!»,0
HW       DD ?
EXTERN MessageBoxA@16:NEAR
.CODE
START:
PUSH     MB_OK
PUSH     OFFSET STR1
PUSH     OFFSET STR2
PUSH     HW
CALL     MessageBoxA@16
RET
END START

Далее необходимо сообщить среде разработки, что данный файл является программой на языке ассемблера, и для корректного включения его в проект требуется использовать Microsoft Macro Assembler. Для этого выбираем для проекта (по правой клавише мыши) опцию Настройки построения.

В появившемся окне ставим галочку для masm (Microsoft Macro Assembler) и нажимаем OK.
Теперь нужно проверить, что для файла на языке ассемблера установился соответствующий инструмент сборки. По правой кнопке мыши для файла с расширением .asm выбираем опцию Свойства.

В появившемся окне для выбранного файла отмечаем инструмент сборки Microsoft Macro Assembler.

Для построения проекта выбираем меню Отладка->Построить решение.

В случае успешного построения в нижней части окна отображается Построение: успешно 1.

Для запуска приложения выбираем меню Отладка->Начать отладку.

Результат выполнения программы:

Изменить тип приложения с консольного на оконное

Чтобы убрать консоль (поменять тип приложения с консольного на оконное, или наоборот) необходимо обратиться к меню Свойства проекта, вызванного по правой кнопке мыши.
В появившемся окне выбрать раздел Компоновщик->Система, и в разделе Подсистема поменять тип с Консоль на Windows (или наоборот).

Повторная сборка и запуск программы на выполнения выдадут следующий результат (консоли нет):

Подсветка синтаксиса языка ассемблера

Для того, чтобы включить подсветку синтаксиса языка ассемблера в Microsoft Visual Studio Express 2010 необходимо загрузить файл usertype и распаковать его в папку

C:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\IDE

Для подключения подсветки синтаксиса выбираем меню Сервис->Параметры

В появившемся окне выбрать Текстовый редактор->Расширение файла и вручную добавляем расширение asm. Нажимаем кнопку Добавить, затем — OK.

После перезапуска Microsoft  Visual Studio Express 2010 подсветка синтаксиса языка ассемблера будет активна.

Назад

Назад: Язык ассемблера