Assembler & win32 курс молодого бойца


Masm32 для чайников

25.07.2014, 22:25

Деление для чайников
Подскажите как правильно провести деление и потом вывести на экран (выражение y=(213 + x — c )/4).

Ошибки MASM32 — cannot open file : .\masm32\include\windows.inc
установил MASM32, прописал в патче путь, выдаёт ошибки при компиляции такого рода : Microsoft.

Ассемблер под Windows для чайников
Приветствую, помогите разобраться с 6-м уроком. Ни как не могу понять эту часть кода .

(MASM32 Editor) для новичков
Знающие люди помогите изучить асемблер много литературы но не могу понять его. Знаю только дельфи.

Компиляция программ для DOS в MASM32
проблема в том, что через командную строку код компилится но линкером link16, я пишу в radasm и.

26.07.2014, 00:21 2

Ассемблер для процессоров Intel Pentium
Зубков — Assembler для DOS, Windows и UNIX
Александр Крупник — Ассемблер. Самоучитель
Пирогов В. Ю. Assembler для Windows
Assembler & Win32. Курс молодого бойца
Изучаем ASM за 7 дней
Юров В. Ассемблер практикум.

Начни правильно, бери FASM. Синтаксис более лаконичный чем у остальных в частности и у masm32.

27.07.2014, 10:39 3 27.07.2014, 14:42 4 27.07.2014, 15:17 5 30.07.2014, 09:43 6
30.07.2014, 09:43
30.07.2014, 09:43

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

Компиляция программ exe для DOS в MASM32
помогите разобраться как создавать программы в masm32 типа exe , можете дать код который точно.

Assembler & win32 курс молодого бойца

Как я и обещал, мы с вами займемся программированием под win32. Выполняю свое обещание. Хотя, честно говоря, нижеследующий кусок текста мне уже совсем не нравится. То есть сначала он мне понравился, но потом некоторые товарищи, чье мнение я весьма уважаю и ценю, его раскритиковали в пух и перья.
А вообще-то в этом тексте дофига плагиата.
Portion by svet(R)off

#1. Однажды студент по имени Дениска Ричи сел изучать абсолютно новый для него язык программирования. Первое, что он сделал — написал программу «Hello, World», и, что самое удивительное, она у него заработала. Когда же он перелистнул следующую страницу своей умной книжки, то ни черта не понял. То есть задним умом своей головы он, конечно же, понимал, что большинство известных ему программ умеют намного больше, чем тупо приветствовать мир, однако понять, каким это извращенным образом такие здоровские штуки можно запрограммировать, он не мог.
Однако ум Дениска имел пытливый (в школе его часто драли в раздевалке — всех гениев в детстве драли в раздевалке!) и сразу же просек, что если в природе существуют программы, умеющие больше этого, то наверняка должны быть и программы, умеющие меньше.
И тогда Дениска, опасаясь быть сначала проигнорированным, потом замодерированным, и в конце концов посланным, забросил свой вопрос в одну из эх, приготовившись, если чего вдруг не так, притвориться кроликом и начать жевать морковку.
Последующие события подняли дыбом все волосы на его тщедушном тельце. Со всех концов бескрайней саванны мгновенно слетелись, сбежались (а некоторые даже и сползлись) бесчисленные гуру, сенсеи и йоды. Возникла крутейшая разборка, поднявшая большое облако пыли, из которого долго доносились рыки, ржание, визги и предсмертные хрипы, а во все стороны разлетались зубы, перья и клоки шерсти. Сначала великие считали и пересчитывали строчки в исходниках, потом буквочки в строчках, а потом даже и байтики в экзешниках, при этом постоянно гоняя получившиеся цифры между двоичным, десятичным и шестнадцатеричным радиксами.
Страшна и беспощадна была эта битва, пока, наконец, из-под обломков не выполз только что пришедший в себя Бьярни Страус (весь помятый и бледный, как труп; те, кто видели, так и начали его с тех пор обзывать — Страус-труп) и не предложил подсчитать биты, установленные в 1.
И тогда вопли стихли, ибо на всех вдруг нашло прозрение, по какой это такой причине двери в психушках открываются исключительно вовнутрь.
Вывалив языки и тяжко дыша, великие расползлись по своим кельям зализывать раны и готовиться к грядущим битвам, а посередине вытоптанной поляны, одинокий, жалкий и забытый, остался остывать трупик несчастного кролика.

#2. Между тем, вопрос о минимальном приложении — это вам не «кто идет за «Клинским» (конечно же, тот, кого в прошлый раз от «Балтики-медового» мутило), и даже не тот, «кто потом пойдет сдавать бутылки» (конечно же тот, кого систематически дерут в раздевалке!). Минимальное приложение — это есмъ альфа и омега программирования, сцилла и харибда отладки, инь и янь сопровождения и даже (давайте не будем бояться этой правды жизни!) эпос и анус раскрутки программного продукта! И именно поэтому за много-много лет никто так и не усомнился в правоте Кнута, который утверждал, что если:

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

Как свидетельствует вышеозначенная формула, вопрос о минимальном приложении (речь идет именно о приложениях, то бишь applications, а вовсе не о каких-нибудь там VxD) — совсем не простейший, и представляет отнюдь не академический интерес. Даже прибалдевшему от морковки кролику должно быть очевидно, что любое приложение обязано выполнить как минимум две не такие уж и простые задачи:

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

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

Ракетница — одно из самых крутых оружий в Quakе. Рокетджамп — это такой прыжок, когда из ракетницы (в прыжке!) стреляешь себе под ноги и из-за этого очень высоко подпрыгиваешь, при этом сжигая определенное количество пунктов здоровья. Мегахелс, однако, тебе их потом с лихвой восстанавливает. Quake — рулез! Каждый низкоуровневый программист должен любить Кваку!!)

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

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

#3. Итак, с криком «банзай» (восточная школа) либо «мастдай» (западная школа), открываем текстовый редактор и набираем там исходный текст (в обиходе называется сырец) минимального приложения на языке ассемблера.

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

Мясорубкой мы будем пользоваться специальной, виндозовской. Называется она MASM32, версию имеет 7.0, весит 5 Мб, а скачать ее можно здесь.
Как говорится, клик хере фор доунлоад, а пока вы будете эту мясорубку скачивать и привинчивать к столу своей камеры пыток, я прочту вам некоторые строки из прилагаемого к ней буклетика.

#4. Фирма Microsoft никогда не документировала, каким это извращенным способом можно писать приложения под Win32 на Ассемблере. Конечно же, в ее Driver Development Kit (DDK) есть парочка соответствующих топиков, но они относятся исключительно к разработке виртуальных драйверов VxD и прочих специфических штук. Ни для кого не секрет, что для программирования в среде Windows необходимо иметь многочисленные ссылки на данные, такие как прототипы функций, структуры, типы и определения констант, макросы. и так далее. Так вот, все вышеперечисленное богатство как раз и поставляется с DDK. Однако, вот беда, «заточено»-то оно под Си :(.
Естественно, маргинальная часть программирующего сообщества неоднократно задавала мелкософту вопрос на тему «assembly language programming for Win32». Но все, что могла ответить служба поддержки — это «assembly language programming for Win32 is not supported by Microsoft» — на первый бесплатный звонок, и «no, it cannot be done» — на второй. Третий же звонок уже стоил немалых денег, и находились лишь считанные единицы, решавшиеся на это.
Однако, как говорится, если гора не идет к Магомету, то Магомет идет к горе. Осознав простую народную мудрость, что «спасение утопающих — дело рук самих утопающих», некто Hutch (потом ему начала помогать целая команда во главе с Iczelion’ом), взял все вышеозначенное «богатство» и начал «перезатачивать» его под Ассемблер.
Подозреваю, что это был весьма тяжелый и тернистый путь, потребовавший от Hutch’a как огромных моральных усилий, так и определенных материальных затрат. Однако он был успешно выполнен, в результате чего мы с вами имеем огромнейшую халяву и собираемся самым бессовестным образом сберечь на этом большое число своих драгоценнейших нервных клеток ;).
Не правда ли, последнее радует? Но, тем не менее (а как же без ложки дегтя?), необходимо учесть и тот простой факт, что пакет MASM32 делался живыми людьми, и в нем могут содержаться (и они там действительно есть!) ошибки. Поэтому отнюдь не стоит брезговать время от времени проверять соответствующие заголовочные файлы ;).
Вот такая вот предыстория. Надеюсь вы уже скачали MASM32 и установили его на свой жесткий диск? Тогда давайте вернемся к нашим баранам :).

#5. Делать EXE’шник, как всегда, мы будем в два этапа. Для начала возьмем исходник minimal.asm и «заведем» нашу мясорубку следующей командной строкой (каталог с исходником должен быть текущим):

Ключ /c говорит о том, что мы хотим только оттранслировать исходный файл, но не компоновать.
Ключ /coff означает, что мы хотим создать объектный файл в формате COFF (Common Object File Format), стандартном для «Окон» формате объектных файлов (TASM, в отличие от MASM, создает объектные файлы в интеловском формате OMF (Object Module Format), который мелкософтовский линкер запросто конвертирует в COFF).
Теперь, если вы правильно набрали исходник, в той же папке, что и minimal.asm, должен появиться объектный файл minimal.obj.
Далее приступим к компоновке экзешника. Затаиваем дыхание и дергаем за стартер:

Ключ /SUBSYSTEM с параметром WINDOWS говорит линкеру о том, что мы собираемся собрать экзешник для подсистемы Windows. Другие возможные значения: CONSOLE — если мы собираемся делать программу с текстовым интерфейсом а-ля ДОС, NATIVE — если драйвер устройства, и POSIX — если мы собираемся писать программы, ориентированные на стандарты POSIX и более или менее переносимые под разные Юниксы (для которых эти стандарты и писались).
Ключ /LIBPATH указывает путь к библиотекам импорта, которые нам обязательно необходимо прилинковать к программе, если мы хотим использовать возможности, предоставляемые не только процессором, но и операционной системой. Подробнее о том, что из себя представляют библиотеки импорта, мы поговорим чуть позже.
Если вы все сделали правильно, то в нашей папке, наряду с исходным и объектным, должен появиться еще и третий файл — исполнимый. Возрадуемся же этому и перейдем к следующему пункту повестки дня — разборке исходника. Неужели вам не интересно знать, что означают эти загадочные строчки в minimal.asm?

#6. .386 — это директива ассемблера, определяющая набор инструкций процессора, которые могут быть использованы в программе (позже мы проведем четкую границу между инструкциями, директивами и командами). По умолчанию транслятор полагает, что программа пишется для процессора 8086 и сопроцессора 8087. Но, посудите сами, какая под него может быть Винда? Для приложений win32 необходимо указывать либо .386, либо выше (486, 586, 686) — в зависимости от того, собираетесь ли вы использовать возможности, предоставляемые процессорами/сопроцессорами последующих поколений или нет. Впоследствии мы будем также использовать p-версию этой директивы (486p, 586p), что даст нам доступ к страшным и ужасным привилегированным командам, которые нехороший «дядька» Микрософт подмял под себя, и выпросить их у «мелкомягких» будет не так уж и просто.

#7. .model flat, stdcall. Первый параметр — это модель памяти. Например, COM’овские программки, которые мы с вами раньше писали, соответствовали модели tiny, то есть «крошечной» — они запросто помещались в 64 Кб памяти, и никаких проблем с адресацией данных у нас не было. Однако если бы мы захотели написать под ДОС программу во много раз большую, чем 64 Кб, т.е. превышающую размер сегмента, нам пришлось бы познакомиться с таким динозавром, как оффсетно-сегментная адресация, и использовать, в зависимости от навороченности программы, модели small, medium, compact или large. Под Windows же у нас есть одна-единственная «правильная» модель памяти — flat, то бишь «плоская», позволяющая нашей программе благодаря страничной адресации легко и просто работать с 4 Гб виртуальной несегментированной памяти. И это есть хорошо! Ибо теперь, как сказал некто Вал.Ик., нам не нужно смотреть на мир сквозь замочную скважину 64 Кб-сегмента. (C)
Второй же параметр указывает на так называемое соглашение о вызове процедур. Каждый язык имеет свои «соглашения». Так, второй параметр может принимать значения: c, basic, fortran, pascal. Мы не будем вдаваться в особенности каждого, просто скажем, что при программировании под win32 на макроассемблере нужно использовать соглашение stdcall, ведущее свою родословную в части наименования ] функций — от языка С (плодовитый, однако, мужчина!), а в части передачи аргументов — от языка Pascal (курица, как говорится, не птица, но яйца мы предпочитаем куриные). Подробнее об этом соглашении будет рассказано ниже.

#8. .includelib kernel32.lib — эта директива передается компоновщику и сообщает, что наша программа должна быть слинкована с указанной библиотекой, в данном случае с kernel32.lib. Библиотека представляет собой энное количество готовых к употреблению процедур, оттранслированных в объектные файлы и собранных в большую кучу под названием «библиотека».
Если помните, есть такое понятие как программное прерывание, то бишь механизм, при помощи которого можно обратиться за обслуживанием своих запросов к операционной системе. Так вот, в среде Windows пользовательских прерываний как таковых нет, а задействование ресурсов операционной системы производится совершенно иначе — при помощи так называемых функций Windows API. А для того, чтобы получить доступ к этим ресурсам, вы должны обязательно cлинковать свою программу с соответствующей библиотекой импорта, в которой как раз и находится куча маленьких подпрограммок, собственно, эти функции и вызывающих.
Слово «слинковать» выделено не случайно. Это связано со следующей строчкой нашего исходника.

#9. Посмотрите внимательно на тело WinMain. Там есть команда call, то есть вызов подпрограммы. А где, спрашивается, сама подпрограмма ExitProcess? Ан нету ее! А почему тогда, спрашивается, транслятор на это не ругается? А вы удалите строчку ExitProcess PROTO :DWORD и попробуйте оттранслировать свой исходник. Ага, хорошо знакомое: «undefined symbol : ExitProcess»? Еще бы, такой подпрограммы в нашем исходнике действительно нет!
Посмотрите на call ExitProcess — это вызов API’шной функции, завершающей работу нашей программы (виндозный аналог хорошо нам известного INT 20h). Именно подпрограмма с таким именем будет прилинкована к нашему экзешнику, и уж она-то знает способ, как ей обратиться к DLL-ке kernel32.dll и заставить ее прервать работу нашей программы! Еще раз повторюсь, прилинкуется не сама API’шная функция, а только подпрограммка, которая умеет эту внешнюю функцию вызывать.
Но это на этапе линковки, когда соединяются все «концы» между объектными файлами. А на этапе транслирования ассемблер не имеет никакого понятия о том, что в природе существует какой-то ExitProcess. И чтобы он (транслятор) не ругался, мол, «кто такой, почему не знаю», нужно их «познакомить» — при помощи так называемого прототипа. Другими словами, прототип — это своего рода уведомление транслятора о том, что «немного попозже я собираюсь обращаться к товарищу ExitProcess, и форма вызова для него такая-то». Ну а далее следуют «паспортные данные» на этого товарища — сколько он «переваривает» параметров, и какой они должны быть размерности, дабы тот, не дай бог, не подавился.
Вообще-то говоря, существует несколько способов подобного «уведомления», однако вышеприведенный, несмотря на свою кажущуюся навороченность, является самым эффективным, так как позволяет проверять соответствие количества и типа аргументов параметрам, тем самым помогая отслеживать целый ряд трудноуловимых ошибок.

#10. Как известно, каждая программа состоит из кода и данных. Раньше мы их называли сегментами — это было связано с тем, что из-за сегментной адресации приходилось мерить мир «спичками» по 64 Кб. Теперь же мы, слава Богу, имеем единое адресное пространство, и термин сегмент, во избежание терминологической путаницы наподобие «говорим сегмент, подразумеваем 64 Кб», заменим на термин «секция», хотя, по большому счету, это одно и то же.
Определяются эти секции, а-ля сегменты, следующими упрощенными директивами:
— .data — определяет секцию инициализированных данных;
— .data? — определяет секцию неинициализированных данных, для тех случаев, когда необходимо предварительно выделить определенное количество памяти, но инициализировать ее заранее нет необходимости. Фишка заключается вот в чем — сколько бы мы ни определяли неинициализированных элементов данных, размер файла программы на диске остается неизменным. Мы просто таким образом ставим систему в известность: «когда программа загрузится, я хочу иметь в своем распоряжении такой-то объем памяти»;
— .const — определяет секцию констант, то есть элементов данных, которые наша программа не сможет (во всяком случае, не должна) изменять ни в коем разе;
— .code — собственно код, то есть последовательность инструкций, которые должен выполнить твой компьютер.
Из всех вышеперечисленных секций в нашем исходнике есть только CODE. Это единственная секция, которая обязательно должна присутствовать в любой программе. А разве может быть иначе?


#11. В секции кода у нас есть одна-единственная процедурка. На всякий случай напомню, что о ее начале свидетельствует строчка WinMain PROC, где WinMain — это «имя собственное», которое вы можете заменить любым словом, в том числе и своим любимым. А ее конец — это строчка WinMain ENDP. Кстати, настоящим ассемблерщикам должно быть приятно, что, опустив ненужную в связи с этим команду ret, мы сэкономили аж 4 байта кода!
О конце модуля транслятору сообщает директива end, и в качестве параметра у нее метка, на которую будет передано управление при старте программы. В данном случае — это имя «главной», а в нашем случае еще и единственной, процедуры WinMain.
;. — этот комментарий поставлен на месте всякой прочей мелочи, которую вы хотели бы заставить делать ваше приложение в тот примечательный момент, когда решите сделать его немного большим, чем минимальное.

#12. Как я уже говорил в п.7, вызов функций API из программы на ассемблере подчиняется соглашению «stdcall». Выражаясь официозно, «с точки зрения прикладного программиста, с учетом специфики Windows и MASM», эти соглашения заключаются в следующем:
1. Регистр символов в имени функции не имеет значения. Например, функции с именами WindowsMustDie и windowsmustdie — это одна и та же функция. Здесь мы наблюдаем отличие от требования языков C и C++, в которых идентификаторы регистро-зависимы. Зато в Паскале регистр имен не имеет значения.
2. Аргументы передаются вызываемой функции через стек. Если аргумент укладывается в 32-битное значение и не подлежит модификации, вызываемой функцией, он обычно записывается в стек непосредственно. В остальных случаях программист должен разместить значение аргумента в памяти, а в стек записать 32-битный указатель на него. Таким образом, все параметры, передаваемые функции API, представляются 32-битными величинами.
3. Вызывающая программа загружает аргументы в стек последовательно, начиная с последнего, указанного в описании функции, и кончая первым. После загрузки всех аргументов программа вызывает функцию командой call.
4. За возвращение стека в исходное состояние после возврата из функции API отвечает сама вызываемая функция. Программисту заботиться о восстановлении указателя стека esp нет необходимости. Эта идея тоже пришла из реализаций Паскаля и прилично экономит на размере кода.
5. Вызываемая функция API гарантированно сохраняет регистры общего назначения ebp, esi, edi. Регистр eax, как правило, содержит возвращаемое значение. Состояние остальных регистров после возврата из функции API следует считать неопределенным (полный набор соглашений stdcall регламентирует также сохранение системных регистров ds и ss. Однако, для flat-модели памяти, используемой в win32, эти регистры значения не имеют.)
В применении к нашему примеру это означает следующее:
— аргументы мы должны передать через стек;
— сама фунция вызывается командой call;
— не «парим» себе мозги, задаваясь вопросом, «если мы сделали PUSH, то когда же нам сделать POP?», ибо правильный ответ — никогда. Об этом позаботится сама функция.

#13. И, напоследок, топик #13 ;)
Читая эту главу, вы написали свою первую программу для Windows на языке ассемблера. Если вы уже имеете хотя бы небольшой опыт программирования, то даже беглого прочтения этой главы будет достаточно, чтобы сказать: «да, теперь я знаю, как ЭТО делается на асме». Если же вы еще совсем молоды и зелены, то просто «тупо» выполните мои инструкции, а комментарии расцените как своего рода предварительные наброски тех тем, которые мы подробно будем рассматривать впоследствии.
Более того, это единственная глава, которая действительно необходима для обучения программированию под Windows на ассемблере. Как только программист узнает, как вызывать API, все остальное он станет способен делать самостоятельно, без учебников и подсказок. Потребуется только справочник Platform SDK, да знание двух языков: C и английского (оба — в объеме церковно-приходской школы).
И да пребудет с вами сила!

Assembler & win32 курс молодого бойца

Программирование на Ассемблере я начинал с Turbo Assembler (TASM) под MS-DOS, сейчас пишу на Flat Assembler (FASM) под Windows. Это очень удобный и мощный пакет для разработки, бесплатный для любого использования. Написан полностью на самом себе, исходники прилагаются. Мне он нравится тем, что позволяет хранить код и описания ресурсов в одном ASM-файле, поддерживает макросы, генерит чистый машинный код без всякой незаявленной самодеятельности, не требует лишней рутинной работы типа прописывания каждой задействованной функции в секцию импорта и еще множество приятных мелочей, облегчающих жизнь программисту. Единственным недостатком является отсутствие достаточного количества готовых исходников, например по сравнению с тем же MASM’ом, а портирование исходников с других платформ на FASM иногда вызывает затруднения. Но на мой взгляд портирование, в отличие от копирования, помогает гораздо лучше изучить язык. Несколько исходников-примеров есть в самом дистрибутиве FASM, еще несколько примеров можно скачать с офсайта или поискать в Интернете. Ответы на многие возникающие вопросы можно найти на официальном форуме FASM. Форум англоязычный, но на нем немало наших соотечественников. К новичкам на форуме относятся хорошо и отвечают даже на самые глупые вопросы.

Для установки Flat Assembler скачайте дистрибутив с офсайта (около 800 килобайт). На момент публикации версия FASM 1.67.27, если ссылка изменится, то можете посмотреть обновление на странице загрузки. Там же можно скачать версии FASM для Linux, Unix и MS-DOS. Бесплатный add-on FASMARM к FASM для работы с ARM можно найти здесь, текущая версия FASMARM 1.12. Инсталлятора нет, программа устанавливается простым извлечением из архива в какое-нибудь удобное для вас место, например C:\FASM. Обязательно скачайте справочник Microsoft Win32 Programmer’s Reference, распакуйте его в папку с FASM’ом. Для удобства можно сделать вложенную папку \help.

Microsoft Win32 Programmer’s Reference

Техническую документацию по FASM на английском языке можно скачать с офсайта, на русском языке есть вот такие мануалы:

Основной мануал Flat Assembler 1.64

Руководство по препроцессору FASM

FASM 1.64: Руководство программиста

Для продвинутых программистов могу порекомендовать справочник Windows NT/2000 Native API Reference на английском языке:

Windows NT/2000 Native API Reference

Для общего развития можно почитать книги Ассемблер для процессоров Intel Pentium (автор Ю.С.Магда) и Ассемблер для DOS, Windows и Unix (автор С.В.Зубков), Ассемблер & Win32. Курс молодого бойца (автор и составитель Р.Аблязов), Intel Hex Opcodes And Mnemonics — общее описание ассемблерных команд Intel 80486, x86 Instruction Set Reference — перечень и описание команд x86 процессора.

Ассемблер для процессоров Intel Pentium

Ассемблер для DOS, Windows и Unix

Ассемблер & Win32. Курс молодого бойца

Учебник по основам языка Ассемблера

Учебник по языку Ассемблер в задачах и примерах

Intel Hex Opcodes And Mnemonics

x86 Instruction Set Reference

И напоследок две книги из категории «must have». Их, конечно, лучше иметь в бумажном варианте в качестве настольных справочников, но электронные версии тоже вполне подойдут. Книги залиты на файлообменник. Обе книги на русском языке, в хорошем качестве.

Соломон Д., Руссинович М. — «Внутреннее устройство Microsoft Windows 2000. Мастер-класс», формат файла: PDF, размер архива 34 Мб. Скачать

Соломон Д., Руссинович М. — «Внутреннее устройство Microsoft Windows: Windows Server 2003, Windows XP, and Windows 2000», формат файла: DjVu, размер архива 27 Мб. Скачать

При первом запуске FASM создаст файл настроек FASMW.INI, откройте его для редактирования в Блокноте. В конец файла надо будет добавить две новых секции. Сперва пропишите полный путь к Win32 Programmer’s Reference:

[Help]
path=C:\FASM\help\WIN32.HLP

Это же можно сделать и через меню редактора HelpPick help file. Теперь, если все сделано правильно, достаточно установить в редакторе курсор на название функции API и нажать F1. Справочник сразу откроется на описании этой функции.

После этого надо установить необходимые переменные окружения и пути для подключаемых файлов. Например у меня прописаны вот такие:

[Environment]
include=»C:\FASM\INCLUDE»
music=»C:\FASM\KEYGEN\XM_FILES»
ufmod=»C:\FASM\INCLUDE\MUSIC»

Переменная include обязательная, остальные для удобства. Теперь при написании программ вместо абсолютных путей можно (и нужно) использовать относительные:

Список ресурсов для изучения Ассемблера

Доброго времени суток!
Некоторым программистам иногда приходит в голову мысль «а не изучить ли мне ассемблер?». Ведь на нем пишут самые (с некоторыми оговорками) маленькие и быстрые программы, да и охота ощутить вкус низкоуровневого программирования берет свое. Ну и для общего развития не повредит.
Мысль эта не обошла стороной и меня. Вдохновившись историей одного байта, я ринулся в бой…

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

UPD
В список начали добавляться ресурсы по программингу микроконтроллеров.

Для начала

  • ru.wikipedia.org/wiki/Ассемблер — ассемблер (не тоже самое, что «язык ассемблера», хотя эти понятия почти слились) в википедии
  • ru.wikipedia.org/wiki/Язык_ассемблера — язык ассемблера там же
  • wasm.ru/article.php?article=onebyte — история одного байта
  • bitfry.narod.ru/00.htm — дневники чайника, довольно простые и интересные уроки для начинающих
  • www.scribd.com/doc/267365/A-Beginners-Course-In-Assembly-Language — книга об основах ассемблера на английском языке
  • Programming from the Ground Up — несложная книга на английском языке. Рекомендация megabrain
  • www.osinavi.ru/asm — учебник по Ассемблеру «для квалифицированных чайников»
  • habrahabr.ru/blogs/asm — блог, в котором, надеюсь, будет много статей об ассемблере

Ресурсы

Книги

Для книг я выкладываю только названия, без ссылок (или с ссылкой на интернет-магазин), так как я не знаю отношения некоторых людей к скачиванию чьей-то интеллектуальной собственности. Кому надо — тот найдет, где скачать.

  • kpnc.opennet.ru — архив книг Криса Касперски
  • Галисеев Г. В. Ассемблер для Win 32. Самоучитель
  • Зубков С. В. Ассемблер для DOS, Windows и UNIX
  • Кип Ирвин. Язык ассемблера для процессоров Intel = Assembly Language for Intel-Based Computers
  • Калашников О. А. Ассемблер? Это просто! Учимся программировать
  • Крис Касперски. Искусство дизассемблирования
  • Владислав Пирогов. Ассемблер для Windows
  • Владислав Пирогов. Ассемблер и дизассемблирование
  • Ричард Саймон. Microsoft Windows API Справочник системного программиста
  • Фрунзе А. В. Микроконтроллеры? Это же просто!
  • Юров В., Хорошенко С. Assembler: учебный курс
  • Абель — Ассемблер. Язык и программирование для IBM PC
  • Эндрю Таненбаум — «Архитектура компьютера» — рекомендация lefty
  • Чарльз Петцольд — «Код» — рекомендация lefty
  • Assembly Language Step-by-step: Programming with DOS and Linux
  • Юрий Ревич «Практическое программирование микроконтроллеров Atmel AVR на языке ассемблера» — рекомендация Ryav
  • Нортон П., Соухе Д. «Язык ассемблера для IBM PC» — рекомендация maotm
  • Григорьев В. Л. «Микропроцессор i486. Архитектура и программирование.» — рекомендация Ghost_nsk
  • Нортон П., Уилтон Р. «IBM PC и PS/2.руководство по программированию» — описана работа с прерываниями и простыми железками, рекомендация Ghost_nsk

Англоязычные ресурсы


Инструменты

  • www.masm32.com — MASM32 SDK
  • flatassembler.net — flat assembler (FASM)
  • www.nasm.us — The Netwide Assembler (NASM)
  • www.ollydbg.de — OllyDbg, отладчик для Windows
  • www.hex-rays.com/products/ida/index.shtml — IDA — интерактивный дизассемблер и отладчик
  • www.idapro.ru — русская страница IDA
  • research.microsoft.com/en-us/projects/detours — Библиотека от Microsoft Research для инъекции Dll и перехвата управления на себя
  • conus.info/gt — отладчик командной строки для выполнения простых отладочных задач

Программинг микроконтроллеров

  • habrahabr.ru/blogs/controllers — тематический блог на хабре, с количеством постов несколько большим, чем в блоге по ассемблеру
  • programmators.ru — сайт по контроллерам семейства PIC
  • myrobot.ru/stepbystep — сайт роботостроения, по ссылке статьи о микроконтроллерах AVR
  • www.123avr.com/07.htm — МК AVR
  • easyelectronics.ru/category/avr-uchebnyj-kurs — AVR

Прочее

  • zx.pk.ru — форум ZX Spectrum
  • bbs.pediy.com — форум по reverse engineering на китайском языке (спасибо KollinZ). Чтобы можно было понять о чем речь, можно воспользоваться кнопкой «перевести» в хроме (спасибо за совет mexanism)
  • old-dos.ru — крупнейший в Рунете архив старых программ

Заключение

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

Assembler & win32 курс молодого бойца

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

Она не ставит своей целью обучение программированию под Win32 или обучение ассемблеру, я подразумеваю, что читатели имеют определённые знания в этих областях.

В отличие от программирования под DOS, где программы, написанные на языках высокого уровня (ЯВУ) были мало похожи на свои аналоги, написанные на ассемблере, приложения под Win32 имеют гораздо больше общего. В первую очередь, это связано с тем, что обращение к сервису операционной системы в Windows осуществляется посредством вызова функций, а не прерываний, что было характерно для DOS. Здесь нет передачи параметров в регистрах при обращении к сервисным функциям и, соответственно, нет и множества результирующих значений возвращаемых в регистрах общего назначения и регистре флагов. Следовательно, проще запомнить и использовать протоколы вызова функций системного сервиса. С другой стороны, в Win32 нельзя непосредственно работать с аппаратным уровнем, чем «грешили» программы для DOS. Вообще написание программ под Win32 стало значительно проще и это обусловлено следующими факторами:

  • отсутствие startup кода, характерного для приложений и динамических библиотек написанных под Windows 3.x;
  • гибкая система адресации к памяти: возможность обращаться к памяти через любой регистр общего назначения; «отсутствие» сегментных регистров;
  • доступность больших объёмов виртуальной памяти;
  • развитый сервис операционной системы, обилие функций, облегчающих разработку приложений;
  • многообразие и доступность средств создания интерфейса с пользователем (диалоги, меню и т.п.).

Современный ассемблер, к которому относится и TASM 5.0 фирмы Borland International Inc., в свою очередь, развивал средства, которые ранее были характерны только для ЯВУ. К таким средствам можно отнести макроопределение вызова процедур, возможность введения шаблонов процедур (описание прототипов) и даже объектно-ориентированные расширения. Однако, ассемблер сохранил и такой прекрасный инструмент, как макроопределения вводимые пользователем, полноценного аналога которому нет ни в одном ЯВУ.

Все эти факторы позволяют рассматривать ассемблер, как самостоятельный инструмент для написания приложений под платформы Win32 (Windows NT и Windows 95). Как иллюстрацию данного положения, рассмотрим простой пример приложения, работающего с диалоговым окном.

Файл, содержащий текст приложения, dlg.asm

IDEAL
P586
RADIX 16
MODEL FLAT

%NOINCL
%NOLIST
include «winconst.inc» ; API Win32 consts
include «winptype.inc» ; API Win32 functions prototype
include «winprocs.inc» ; API Win32 function
include «resource.inc» ; resource consts

MAX_USER_NAME = 20
DataSeg
szAppName db ‘Demo 1’, 0
szHello db ‘Hello, ‘
szUser db MAX_USER_NAME dup (0)

CodeSeg
Start: call GetModuleHandleA, 0
call DialogBoxParamA, eax, IDD_DIALOG, 0, offset DlgProc, 0
cmp eax,IDOK
jne bye
call MessageBoxA, 0, offset szHello,
offset szAppName,
MB_OK or MB_ICONINFORMATION
bye: call ExitProcess, 0

public stdcall DlgProc
proc DlgProc stdcall
arg @@hDlg :dword, @@iMsg :dword, @@wPar :dword, @@lPar :dword
mov eax,[@@iMsg]
cmp eax,WM_INITDIALOG
je @@init
cmp eax,WM_COMMAND
jne @@ret_false

mov eax,[@@wPar]
cmp eax,IDCANCEL
je @@cancel
cmp eax,IDOK
jne @@ret_false

call GetDlgItemTextA, @@hDlg, >
offset szUser, MAX_USER_NAME
mov eax,IDOK

@@cancel: call EndDialog, @@hDlg, eax

@@ret_false: xor eax,eax
ret

@@init: call GetDlgItem, @@hDlg, IDR_NAME
call SetFocus, eax
jmp @@ret_false
endp DlgProc
end Start

Сразу после метки Start, программа обращается к функции API Win32 GetModuleHandle для получения handle данного модуля (данный параметр чаще именуют как handle of instance). Получив handle, мы вызываем диалог, созданный либо вручную, либо с помощью какой-либо программы построителя ресурсов. Далее программа проверяет результат работы диалогового окна. Если пользователь вышел из диалога посредством нажатия клавиши OK, то приложение запускает MessageBox с текстом приветствия.

Диалоговая процедура обрабатывает следующие сообщения. При инициализации диалога (WM_INITDIALOG) она просит Windows установить фокус на поле ввода имени пользователя. Сообщение WM_COMMAND обрабатывается в таком порядке: делается проверка на код нажатия клавиши. Если была нажата клавиша OK, то пользовательский ввод копируется в переменную szValue, если же была нажата клавиша Cancel, то копирования не производится. Но и в том и другом случае вызывается функция окончания диалога: EndDialog. Остальные сообщения в группе WM_COMMAND просто игнорируются, предоставляя Windows действовать по умолчанию.

Вы можете сравнить приведённую программу с аналогичной программой, написанной на ЯВУ, разница в написании будет незначительна. Очевидно те, кто писал приложения на ассемблере под Windows 3.x, отметят тот факт, что исчезла необходимость в сложном и громоздком startup коде. Теперь приложение выглядит более просто и естественно.

Написание динамических библиотек под Win32 также значительно упростилось, по сравнению с тем, как это делалось под Windows 3.x. Исчезла необходимость вставлять startup код, а использование четырёх событий инициализации/деинициализации на уровне процессов и потоков, кажется логичным.

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

Ideal
P586
Radix 16
Model flat
DLL_PROCESS_ATTACH

extrn GetVersion: proc

DataSeg
hInst dd 0
OSVer dw 0

CodeSeg
proc libEntry stdcall
arg @@hInst :dword, @@rsn :dword, @@rsrv :dword
cmp [@@rsn],DLL_PROCESS_ATTACH
jne @@1
call GetVersion
mov [OSVer],ax
mov eax,[@@hInst]
mov [hInst],eax

@@1: mov eax,1
ret
endP libEntry

public stdcall Hex2Str
proc Hex2Str stdcall
arg @@num :dword, @@str :dword
uses ebx
mov eax,[@@num]
mov ebx,[@@str]
mov ecx,7

@@1: mov edx,eax
shr eax,4
and edx,0F
cmp edx,0A
jae @@2
add edx,’0′
jmp @@3


@@3: mov [byte ebx + ecx],dl
dec ecx
jns @@1
mov [byte ebx + 8],0
ret
endp Hex2Str

Процедура libEntry является точкой входа в динамическую библиотеку, её не надо объявлять как экспортируемую, загрузчик сам определяет её местонахождение. LibEntry может вызываться в четырёх случаях:

  • при проецировании библиотеки в адресное пространство процесса (DLL_PROCESS_ATTACH);
  • при первом вызове библиотеки из потока (DLL_THREAD_ATTACH), например, с помощью функции LoadLibrary;
  • при выгрузке библиотеки потоком (DLL_THREAD_DETACH);
  • при выгрузке библиотеки из адресного пространства процесса (DLL_PROCESS_DETACH).

В нашем примере обрабатывается только первое из событий DLL_PROCESS_ATTACH. При обработке данного события библиотека запрашивает версию OS сохраняет её, а также свой handle of instance.

Библиотека содержит только одну экспортируемую функцию, которая собственно не требует пояснений. Вы, пожалуй, можете обратить внимание на то, как производится запись преобразованных значений. Интересна система адресации посредством двух регистров общего назначения: ebx + ecx, она позволяет нам использовать регистр ecx одновременно и как счётчик и как составную часть адреса.

Ideal
P586
Radix 16
Model flat

struc WndClassEx
cbSize dd 0
style dd 0
lpfnWndProc dd 0
cbClsExtra dd 0
cbWndExtra dd 0
hInstance dd 0
hIcon dd 0
hCursor dd 0
hbrBackground dd 0
lpszMenuName dd 0
lpsz > dd 0
hIconSm dd 0
ends WndClassEx

struc Point
left dd 0
top dd 0
right dd 0
bottom dd 0
ends Point

struc msgStruc
hwnd dd 0
message dd 0
wParam dd 0
lParam dd 0
time dd 0
pt Point <>
ends msgStruc

MyMenu = 0065
> = 9C41
> = 9C42
> = 9C43

CS_VREDRAW = 0001
CS_HREDRAW = 0002
> = 7F00
> = 7F00
COLOR_WINDOW = 5
WS_EX_WINDOWEDGE = 00000100
WS_EX_CLIENTEDGE = 00000200
WS_EX_OVERLAPPEDWINDOW = WS_EX_WINDOWEDGE OR WS_EX_CLIENTEDGE
WS_OVERLAPPED = 00000000
WS_CAPTION = 00C00000
WS_SYSMENU = 00080000
WS_THICKFRAME = 00040000
WS_MINIMIZEBOX = 00020000
WS_MAXIMIZEBOX = 00010000
WS_OVERLAPPEDWINDOW = WS_OVERLAPPED OR
WS_CAPTION OR
WS_SYSMENU OR
WS_THICKFRAME OR
WS_MINIMIZEBOX OR
WS_MAXIMIZEBOX
CW_USEDEFAULT = 80000000
SW_SHOW = 5
WM_COMMAND = 0111
WM_DESTROY = 0002
WM_CLOSE = 0010
MB_OK = 0

PROCTYPE ptGetModuleHandle stdcall
lpModuleName :dword

PROCTYPE ptLoadIcon stdcall
hInstance :dword,
lpIconName :dword

PROCTYPE ptLoadCursor stdcall
hInstance :dword,
lpCursorName :dword

PROCTYPE ptLoadMenu stdcall
hInstance :dword,
lpMenuName :dword

PROCTYPE ptRegister > stdcall
lpwcx :dword

PROCTYPE ptCreateWindowEx stdcall
dwExStyle :dword,
lp > :dword,
lpWindowName :dword,
dwStyle :dword,
x :dword,
y :dword,
nW > :dword,
nHeight :dword,
hWndParent :dword,
hMenu :dword,
hInstance :dword,
lpParam :dword

PROCTYPE ptShowWindow stdcall
hWnd :dword,
nCmdShow :dword

PROCTYPE ptUpdateWindow stdcall
hWnd :dword

PROCTYPE ptGetMessage stdcall
pMsg :dword,
hWnd :dword,
wMsgFilterMin :dword,
wMsgFilterMax :dword

PROCTYPE ptTranslateMessage stdcall
lpMsg :dword

PROCTYPE ptDispatchMessage stdcall
pmsg :dword

PROCTYPE ptSetMenu stdcall
hWnd :dword,
hMenu :dword

PROCTYPE ptPostQuitMessage stdcall
nExitCode :dword

PROCTYPE ptDefWindowProc stdcall
hWnd :dword,
Msg :dword,
wParam :dword,
lParam :dword

PROCTYPE ptSendMessage stdcall
hWnd :dword,
Msg :dword,
wParam :dword,
lParam :dword

PROCTYPE ptMessageBox stdcall
hWnd :dword,
lpText :dword,
lpCaption :dword,
uType :dword

PROCTYPE ptExitProcess stdcall
exitCode :dword

extrn GetModuleHandleA :ptGetModuleHandle
extrn LoadIconA :ptLoadIcon
extrn LoadCursorA :ptLoadCursor
extrn Register > :ptRegisterClassEx
extrn LoadMenuA :ptLoadMenu
extrn CreateWindowExA :ptCreateWindowEx
extrn ShowWindow :ptShowWindow
extrn UpdateWindow :ptUpdateWindow
extrn GetMessageA :ptGetMessage
extrn TranslateMessage :ptTranslateMessage
extrn DispatchMessageA :ptDispatchMessage
extrn SetMenu :ptSetMenu
extrn PostQuitMessage :ptPostQuitMessage
extrn DefWindowProcA :ptDefWindowProc
extrn SendMessageA :ptSendMessage
extrn MessageBoxA :ptMessageBox
extrn ExitProcess :ptExitProcess

UDataSeg
hInst dd ?
hWnd dd ?

IFNDEF VER1
hMenu dd ?
ENDIF

DataSeg
msg msgStruc <>
> db ‘Menu demo’, 0
wndTitle db ‘Demo program’, 0
msg_open_txt db ‘You selected open’, 0
msg_open_tlt db ‘Open box’, 0
msg_save_txt db ‘You selected save’, 0
msg_save_tlt db ‘Save box’, 0

CodeSeg
Start: call GetModuleHandleA, 0 ; не обязательно, но желательно
mov [hInst],eax

sub esp,SIZE Wnd > ; отведём место в стеке под структуру

mov [(WndClassEx esp).cbSize],SIZE WndClassEx
mov [(WndClassEx esp).style],CS_HREDRAW or CS_VREDRAW
mov [(WndClassEx esp).lpfnWndProc],offset WndProc
mov [(WndClassEx esp).cbWndExtra],0
mov [(WndClassEx esp).cbClsExtra],0
mov [(WndClassEx esp).hInstance],eax
call LoadIconA, 0, IDI_APPLICATION
mov [(WndClassEx esp).hIcon],eax
call LoadCursorA, 0, IDC_ARROW
mov [(WndClassEx esp).hCursor],eax
mov [(WndClassEx esp).hbrBackground],COLOR_WINDOW
IFDEF VER1
mov [(WndClassEx esp).lpszMenuName],MyMenu
ELSE
mov [(WndClassEx esp).lpszMenuName],0
ENDIF
mov [(WndClassEx esp).lpszClassName],offset classTitle
mov [(WndClassEx esp).hIconSm],0
call Register > esp ; зарегистрируем класс окна

add esp,SIZE Wnd > ; восстановим стек
; и создадим окно
IFNDEF VER2
call CreateWindowExA, WS_EX_OVERLAPPEDWINDOW, extended window style
offset classTitle, pointer to registered class name
offset wndTitle, pointer to window name
WS_OVERLAPPEDWINDOW, window style
CW_USEDEFAULT, horizontal position of window
CW_USEDEFAULT, vertical position of window
CW_USEDEFAULT, window width
CW_USEDEFAULT, window height
0, handle to parent or owner window
0, handle to menu, or child-window identifier
[hInst], handle to application instance
0 ; pointer to window-creation data
ELSE
call LoadMenu, hInst, MyMenu
mov [hMenu],eax
call CreateWindowExA, WS_EX_OVERLAPPEDWINDOW, extended window style
offset classTitle, pointer to registered class name
offset wndTitle, pointer to window name
WS_OVERLAPPEDWINDOW, window style
CW_USEDEFAULT, horizontal position of window
CW_USEDEFAULT, vertical position of window
CW_USEDEFAULT, window width
CW_USEDEFAULT, window height
0, handle to parent or owner window
eax, handle to menu, or child-window identifier
[hInst], handle to application instance
0 ; pointer to window-creation data
ENDIF
mov [hWnd],eax
call ShowWindow, eax, SW_SHOW ; show window
call UpdateWindow, [hWnd] ; redraw window

IFDEF VER3
call LoadMenuA, [hInst], MyMenu
mov [hMenu],eax
call SetMenu, [hWnd], eax
ENDIF

msg_loop:
call GetMessageA, offset msg, 0, 0, 0
or ax,ax
jz exit
call TranslateMessage, offset msg
call DispatchMessageA, offset msg
jmp msg_loop
exit: call ExitProcess, 0

public stdcall WndProc
proc WndProc stdcall
arg @@hwnd: dword, @@msg: dword, @@wPar: dword, @@lPar: dword
mov eax,[@@msg]
cmp eax,WM_COMMAND
je @@command
cmp eax,WM_DESTROY
jne @@default
call PostQuitMessage, 0
xor eax,eax
jmp @@ret

@@default:
call DefWindowProcA, [@@hwnd], [@@msg], [@@wPar], [@@lPar]

@@command:
mov eax,[@@wPar]
cmp eax,ID_OPEN
je @@open
cmp eax,ID_SAVE
je @@save
call SendMessageA, [@@hwnd], WM_CLOSE, 0, 0
xor eax,eax
jmp @@ret


@@open: mov eax, offset msg_open_txt
mov edx, offset msg_open_tlt
jmp @@mess

@@save: mov eax, offset msg_save_txt
mov edx, offset msg_save_tlt

@@mess: call MessageBoxA, 0, eax, edx, MB_OK
xor eax,eax
jmp @@ret
endp WndProc
end Start

Здесь мне хотелось в первую очередь продемонстрировать использование прототипов функций API Win32. Конечно их (а также описание констант и структур из API Win32) следует вынести в отдельные подключаемые файлы, поскольку, скорее всего Вы будете использовать их и в других программах. Описание прототипов функций обеспечивает строгий контроль со стороны компилятора за количеством и типом параметров, передаваемых в функции. Это существенно облегчает жизнь программисту, позволяя избежать ошибок времени исполнения, тем более, что число параметров в некоторых функциях API Win32 весьма значительно.

Существо данной программы заключается в демонстрации вариантов работы с оконным меню. Программу можно откомпилировать в трёх вариантах (версиях), указывая компилятору, ключи VER2 или VER3 (по умолчанию используется ключ VER1). В первом варианте программы меню определяется на уровне класса окна, и все окна данного класса будут иметь аналогичное меню. Во втором варианте, меню определяется при создании окна, как параметр функции CreateWindowEx. Класс окна не имеет меню и в данном случае, каждое окно этого класса может иметь своё собственное меню. Наконец, в третьем варианте, меню загружается после создания окна. Данный вариант показывает, как можно связать меню с уже созданным окном.

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

Представляет определённый интерес использование стековых фреймов и заполнение структур в стеке посредством регистра указателя стека (esp). Именно это продемонстрировано при заполнении структуры WndClassEx. Выделение места в стеке (фрейма) делается простым перемещением esp:

Теперь мы можем обращаться к выделенной памяти, используя всё тот же регистр указатель стека. При создании 16-битных приложений такой возможностью мы не обладали. Данный приём можно использовать внутри любой процедуры или даже произвольном месте программы. Накладные расходы на подобное выделение памяти минимальны, однако, следует учитывать, что размер стека ограничен, и размещать большие объёмы данных в стеке вряд ли целесообразно. Для этих целей лучше использовать «кучи» (heap) или виртуальную память (virtual memory).

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

Мне достаточно редко приходилось серьёзно заниматься разработкой макроопределений при программировании под DOS. В Win32 ситуация принципиально иная. Здесь грамотно написанные макроопределения способны не только облегчить чтение и восприятие программ, но и реально облегчить жизнь программистов. Дело в том, что в Win32 фрагменты кода часто повторяются, имея при этом не принципиальные отличия. Наиболее показательна, в этом смысле, оконная и/или диалоговая процедура. И в том и другом случае мы определяем вид сообщения и передаём управление тому участку кода, который отвечает за обработку полученного сообщения. Если в программе активно используются диалоговые окна, то аналогичные фрагменты кода сильно перегрузят программу, сделав её малопригодной для восприятия. Применение макроопределений в таких ситуациях более чем оправдано. В качестве основы для макроопределения, занимающегося диспетчеризацией поступающих сообщений на обработчиков, может послужить следующее описание.

macro MessageVector message1, message2:REST
IFNB
dd message1
dd offset @@&message1
@@VecCount = @@VecCount + 1
MessageVector message2
ENDIF
endm MessageVector

macro WndMessages VecName, message1, message2:REST
@@VecCount = 0
DataSeg
label @@&VecName dword
MessageVector message1, message2
@@&VecName&Cnt = @@VecCount
CodeSeg
mov ecx,@@&VecName&Cnt
mov eax,[@@msg]

@@&VecName&_1: dec ecx
js @@default
cmp eax,[dword ecx * 8 + offset @@&VecName]
jne @@&VecName&_1
jmp [dword ecx + offset @@&VecName + 4]

@@default: call DefWindowProcA, [@@hWnd], [@@msg], [@@wPar], [@@lPar]

@@ret_false: xor eax,eax
jmp @@ret

@@ret_true: mov eax,-1
dec eax
jmp @@ret
endm WndMessage

При написании процедуры окна Вы можете использовать макроопределение WndMessages, указав в списке параметров те сообщения, обработку которых намерены осуществить. Тогда процедура окна примет вид:

proc WndProc stdcall
arg @@hWnd: dword, @@msg: dword, @@wPar: dword, @@lPar: dword
WndMessages WndVector, WM_CREATE, WM_SIZE, WM_PAINT, WM_CLOSE, WM_DESTROY

@@WM_CREATE:
; здесь обрабатываем сообщение WM_CREATE

@@WM_SIZE:
; здесь обрабатываем сообщение WM_SIZE

@@WM_PAINT:
; здесь обрабатываем сообщение WM_PAINT

@@WM_CLOSE:
; здесь обрабатываем сообщение WM_CLOSE

@@WM_DESTROY:
; здесь обрабатываем сообщение WM_DESTROY

Обработку каждого сообщения можно завершить тремя способами:

  • вернуть значение TRUE, для этого необходимо использовать переход на метку @@ret_true;
  • вернуть значение FALSE, для этого необходимо использовать переход на метку @@ret_false;
  • перейти на обработку по умолчанию, для этого необходимо сделать переход на метку @@default.

Отметьте, что все перечисленные метки определены в макро WndMessages и Вам не следует определять их заново в теле процедуры.

Теперь давайте разберёмся, что происходит при вызове макроопределения WndMessages. Вначале производится обнуление счётчика параметров самого макроопределения (число этих параметров может быть произвольным). Теперь в сегменте данных создадим метку с тем именем, которое передано в макроопределение в качестве первого параметра. Имя метки формируется путём конкатенации символов @@ и названия вектора. Достигается это за счёт использования оператора &. Например, если передать имя TestLabel, то название метки примет вид: @@TestLabel. Сразу за объявлением метки вызывается другое макроопределение MessageVector, в которое передаются все остальные параметры, которые должны быть ничем иным, как списком сообщений, подлежащих обработке в процедуре окна. Структура макроопределения MessageVector проста и бесхитростна. Она извлекает первый параметр и в ячейку памяти формата dword заносит код сообщения. В следующую ячейку памяти формата dword записывается адрес метки обработчика, имя которой формируется по описанному выше правилу. Счётчик сообщений увеличивается на единицу. Далее следует рекурсивный вызов с передачей ещё не зарегистрированных сообщений, и так продолжается до тех пор, пока список сообщений не будет исчерпан.

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

Обработка сообщений в Windows не является линейной, а, как правило, представляет собой иерархию. Например, сообщение WM_COMMAND может заключать в себе множество сообщений поступающих от меню и/или других управляющих элементов. Следовательно, данную методику можно с успехом применить и для других уровней каскада и даже несколько упростить её. Действительно, не в наших силах исправить код сообщений, поступающих в процедуру окна или диалога, но выбор последовательности констант, назначаемых пунктам меню или управляющим элементам (controls) остаётся за нами. В этом случае нет нужды в дополнительном поле, которое сохраняет код сообщения. Тогда каждый элемент вектора будет содержать только адрес обработчика, а найти нужный элемент весьма просто. Из полученной константы, пришедшей в сообщении, вычитается идентификатор первого пункта меню или первого управляющего элемента, это и будет номер нужного элемента вектора. Остаётся только сделать переход на обработчик.

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

Masm32 для чайников

25.07.2014, 22:25

Деление для чайников
Подскажите как правильно провести деление и потом вывести на экран (выражение y=(213 + x — c )/4).

Ошибки MASM32 — cannot open file : .\masm32\include\windows.inc
установил MASM32, прописал в патче путь, выдаёт ошибки при компиляции такого рода : Microsoft.

Ассемблер под Windows для чайников
Приветствую, помогите разобраться с 6-м уроком. Ни как не могу понять эту часть кода .

(MASM32 Editor) для новичков
Знающие люди помогите изучить асемблер много литературы но не могу понять его. Знаю только дельфи.

Компиляция программ для DOS в MASM32
проблема в том, что через командную строку код компилится но линкером link16, я пишу в radasm и.

26.07.2014, 00:21 2

Ассемблер для процессоров Intel Pentium
Зубков — Assembler для DOS, Windows и UNIX
Александр Крупник — Ассемблер. Самоучитель
Пирогов В. Ю. Assembler для Windows
Assembler & Win32. Курс молодого бойца
Изучаем ASM за 7 дней
Юров В. Ассемблер практикум.

Начни правильно, бери FASM. Синтаксис более лаконичный чем у остальных в частности и у masm32.

27.07.2014, 10:39 3

27.07.2014, 14:42 4
27.07.2014, 15:17 5
30.07.2014, 09:43 6
30.07.2014, 09:43
30.07.2014, 09:43

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

Компиляция программ exe для DOS в MASM32
помогите разобраться как создавать программы в masm32 типа exe , можете дать код который точно.

Assembler & Win32

Современный ассемблер, к которому относится и TASM 5.0 фирмы Borland International Inc., в свою очередь, развивал средства, которые ранее были характерны только для ЯВУ. К таким средствам можно отнести макроопределение вызова процедур, возможность введения шаблонов процедур (описание прототипов) и даже объектно-ориентированные расширения. Однако, ассемблер сохранил и такой прекрасный инструмент, как макроопределения вводимые пользователем, полноценного аналога которому нет ни в одном ЯВУ.

Все эти факторы позволяют рассматривать ассемблер, как самостоятельный инструмент для написания приложений под платформы Win32 (Windows NT и Windows 95). Как иллюстрацию данного положения, рассмотрим простой пример приложения, работающего с диалоговым окном.

Пример 1. Программа работы с диалогом

Файл, содержащий текст приложения, dlg.asm

Файл ресурсов dlg.rc

Остальные файлы из данного примера, приведены в приложении 1.

Краткие комментарии к программе

Сразу после метки Start, программа обращается к функции API Win32 GetModuleHandle для получения handle данного модуля (данный параметр чаще именуют как handle of instance). Получив handle, мы вызываем диалог, созданный либо вручную, либо с помощью какой-либо программы построителя ресурсов. Далее программа проверяет результат работы диалогового окна. Если пользователь вышел из диалога посредством нажатия клавиши OK, то приложение запускает MessageBox с текстом приветствия.

Диалоговая процедура обрабатывает следующие сообщения. При инициализации диалога (WM_INITDIALOG) она просит Windows установить фокус на поле ввода имени пользователя. Сообщение WM_COMMAND обрабатывается в таком порядке: делается проверка на код нажатия клавиши. Если была нажата клавиша OK, то пользовательский ввод копируется в переменную szValue, если же была нажата клавиша Cancel, то копирования не производится. Но и в том и другом случае вызывается функция окончания диалога: EndDialog. Остальные сообщения в группе WM_COMMAND просто игнорируются, предоставляя Windows действовать по умолчанию.

Вы можете сравнить приведённую программу с аналогичной программой, написанной на ЯВУ, разница в написании будет незначительна. Очевидно те, кто писал приложения на ассемблере под Windows 3.x, отметят тот факт, что исчезла необходимость в сложном и громоздком startup коде. Теперь приложение выглядит более просто и естественно.

Assembler & win32 курс молодого бойца

6 окт 2006 . Этот курс предназначен для студентов и начинающих программистов. Он простым и понятным языком излагает основы .

23 ноя 2020 . Click here to download a printable and saveable PDF version of this article. . http://lol.unoforum.pro/?0-1 . Prom Electric Ремонт ALLEN BRADLEY CONTROL BAORD ASSEMBLY, . Самые умные собаки в мире это хаски Рокки и маламут Майк, а щенок Лекси проходит курс молодого бойца!

16 дек 2011 . Курс молодого бойца. . Наверное, каждый из нас думает, что ассемблер это что-то сложное, . TASM32 v5.0 (tasm32.exe, tlink32.exe)

Архитектура компьютера · Принцип Фон Неймана · Регистры процессоров · Ассемблер · Команда MOV · Стек · Арифметические и логические операции .

5 окт 2020 . дацию множественности валютных курсов власти так и не решились. . зачастую оружие и бойцы свободно перемещаются из Сирии в Турцию. . Требования протестующих в Сирии, состоящих в основном из молодых . 1 -я неделя (27–28.02.2020). 0 н/д. 2-я неделя (29.02–06.03.2020). 6.

27 лучших фасонов сезона – В Курсе Жизни . Steve Blake on Instagram: “ Very nearly assembly time however I’m seriously considering . «Начинающим: Школа молодого бойца от старого партизана Тихони» на HobbyPortal. я . Instant download. A lovely shelf bra sewing pattern to be printed to size with an A4 .

Курс молодого бойца. Урок 11. Ещё о командах ассемблера. Биты . бит 1. бит 0. выдвигается. Операнд. 1. 0. 0. 1. 1. 0. 1. 1. ror операнд,3. 1. 0. 0. 1. 1.

Пособие основано на лекциях, читавшихся автором в рамках курса « Архитектура ЭВМ и язык ассемблера» в Ташкентском филиале МГУ весной 2007 .

. Wilcoxon Mann-Whitney Rank Sum Test data: Value by factor(Group) (1, 2) Z = -2.4975, p-value = 0.01177 alternative hypothesis: true mu is not equal to 0.

Ассемблер. Kontur Academy. 5.8K subscribers. Subscribe · Hackerdom-10-04 Ассемблер. Watch later. Share. 4/12 . Switch camera. 0:00. 6:25. 0:00 / 6:25

Курс молодого бойца. Введение. 17 авг 2012, 03:42. Assembler&Win32.

Автор: Корсик Название: KMB 2.0 — Курс молодого бойца для начинающих игроков в покер Этот курс необходим, если Вы игрок NL5-10 или неуверенно играете на.

Этот курс необходим, если Вы игрок NL5-10 или неуверенно играете на NL25 (6 макс и 9 макс). Мы поможем восполнить нехватку знаний и разобраться при избытке неструктурированной информации. В пакете 18 видео (10 теории + 8 практики) и 10 конспектов.

Что такое процессор. Память системы. Основы Ассемблера. Первая программа. Данные в ассемблере. Символьные метки. Переходы (прыжки). Команды ассемблера. Подпрограммы и структуры. Упрощаем программирование. Ещё о командах ассемблера.

Курс молодого бойца. Введение. Что это такое? Наверное, каждый из нас думает, что ассемблер это что-то сложное, очень трудное для изучения и вообще недосягаемое.

Курс молодого бойца. Введение. Что это такое?

Assembler. Доброго времени суток! Некоторым программистам иногда приходит в голову мысль «а не изучить ли мне ассемблер?».

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

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

Погружение в assembler. Полный курс по программированию на асме от ][

Содержание статьи


Это первая (вступительная) статья курса. Курс рассчитан на тех, кто в целом знаком с высокоуровневым программированием и только приступает к изучению ассемблера.

Но что такое программирование само по себе по своей сути, вне зависимости от какого-либо языка? Разнообразие ответов поражает. Наиболее часто можно услышать такое определение: программирование — это составление инструкций или команд для последовательного исполнения их машиной с целью решить ту или иную задачу. Такой ответ вполне справедлив, но, на мой взгляд, не отражает всей полноты, как если бы мы назвали литературу составлением из слов предложений для последовательного прочтения их читателем. Я склонен полагать, что программирование ближе к творчеству, к искусству. Как любой вид искусства — выражение творческой мысли, идеи, программирование представляет собой отражение человеческой мысли. Мысль же бывает и гениальная, и совершенно посредственная.

Но, каким бы видом программирования мы ни занимались, успех зависит от практических навыков вкупе со знанием фундаментальных основ и теории. Теория и практика, изучение и труд — вот краеугольные камни, на которых основывается успех.

В последнее время ассемблер незаслуженно находится в тени других языков. Обусловлено это глобальной коммерциализацией, направленной на то, чтобы в максимально короткие сроки получить как можно большую прибыль от продукта. Иными словами, массовость взяла верх над элитарностью. А ассемблер, по моему мнению, ближе к последнему. Гораздо выгоднее в сравнительно небольшие сроки поднатаскать ученика в таких, например, языках, как С++, С#, PHP, Java, JavaScript, Python, чтобы он был более-менее способен создавать ширпотребный софт, не задаваясь вопросами, зачем и почему он так делает, чем выпустить хорошего специалиста по ассемблеру. Примером тому служит обширнейший рынок всевозможных курсов по программированию на любом языке, за исключением ассемблера. Та же тенденция прослеживается как в преподавании в вузах, так и в учебной литературе. В обоих случаях вплоть до сегодняшнего дня большая часть материала базируется на ранних процессорах серии 8086, на так называемом «реальном» 16-битном режиме работы, операционной среде MS-DOS! Возможно, что одна из причин в том, что, с одной стороны, с появлением компьютеров IBM PC преподавателям пришлось перейти именно на эту платформу из-за недоступности других. А с другой стороны, по мере развития линейки 80х86 возможность запуска программ в режиме DOS сохранялась, что позволяло сэкономить деньги на приобретение новых учебных компьютеров и составление учебников для изучения архитектуры новых процессоров. Однако сейчас такой выбор платформы для изучения совершенно неприемлем. MS-DOS как среда выполнения программ безнадежно устарела уже к середине девяностых годов, а с переходом к 32-битным процессорам, начиная с процессора 80386, сама система команд стала намного более логичной. Так что бессмысленно тратить время на изучение и объяснение странностей архитектуры реального режима, которые заведомо никогда уже не появятся ни на одном процессоре.

Что касается выбора операционной среды для изучения ассемблера, то, если говорить о 32-битной системе команд, выбор сравнительно невелик. Это либо операционные системы Windows, либо представители семейства UNIX.

Также следует сказать несколько слов о том, какой именно ассемблер выбрать для той или другой операционной среды. Как известно, для работы с процессорами х86 используются два типа синтаксиса ассемблера — это синтаксис AT&T и синтаксис Intel. Эти синтаксисы представляют одни и те же команды совершенно по-разному. Например, команда в синтаксисе Intel выглядит так:

В синтаксисе же AT&T уже будет иной вид:

В среде ОС UNIX более популярен синтаксис типа AT&T, однако учебных пособий по нему нет, он описывается исключительно в справочной и технической литературе. Поэтому логично выбрать ассемблер на основе синтаксиса Intel. Для UNIX-систем есть два основных ассемблера — это NASM (Netwide Assembler) и FASM (Flat Assembler). Для линейки Windows популярностью пользуются FASM и MASM (Macro Assembler) от фирмы Microsoft, и также существовал еще TASM (Turbo Assembler) фирмы Borland, которая уже довольно давно отказалась от поддержки собственного детища.

В данном цикле статей изучение будем вести в среде Windows на основе языка ассемблера MASM (просто потому, что он мне нравится больше). Многие авторы на начальном этапе изучения ассемблера вписывают его в оболочку языка си, исходя из тех соображений, что перейти к практическим примерам в операционной среде якобы довольно трудно: нужно знать и основы программирования в ней, и команды процессора. Однако и такой подход требует хоть мало-мальских начатков знаний в языке си. Данный же цикл статей от самого своего начала будет сосредоточен только на самом ассемблере, не смущая читателя ничем иным, ему непонятным, хотя в дальнейшем и будет прослеживаться связь с другими языками.

Следует отметить, что при изучении основ программирования, и это касается не только программирования на ассемблере, крайне полезно иметь представление о культуре консольных приложений. И совершенно нежелательно начинать обучение сразу же с создания окошечек, кнопочек, то есть с оконных приложений. Бытует мнение, что консоль — архаичный пережиток прошлого. Однако это не так. Консольное приложение почти лишено всякой внешней зависимости от оконной оболочки и сосредоточено главным образом на выполнении конкретно поставленной задачи, что дает прекрасную возможность, не отвлекаясь ни на что другое, концентрировать внимание на изучении базовых основ как программирования, так и самого ассемблера, включая знакомство с алгоритмами и их разработку для решения практических задач. И к тому моменту, когда настанет время перейти к знакомству с оконными приложениями, за плечами уже будет внушительный запас знаний, ясное представление о работе процессора и, самое главное, осознание своих действий: как и что работает, зачем и почему.

Что такое ассемблер?

Само слово ассемблер (assembler) переводится с английского как «сборщик». На самом деле так называется программа-транслятор, принимающая на входе текст, содержащий условные обозначения машинных команд, удобные для человека, и переводящая эти обозначения в последовательность соответствующих кодов машинных команд, понятных процессору. В отличие от машинных команд, их условные обозначения, называемые также мнемониками, запомнить сравнительно легко, так как они представляют собой сокращения от английских слов. В дальнейшем мы будем для простоты именовать мнемоники ассемблерными командами. Язык условных обозначений и называется языком ассемблера.

На заре компьютерной эры первые ЭВМ занимали целые комнаты и весили не одну тонну, имея объем памяти с воробьиный мозг, а то и того меньше. Единственным способом программирования в те времена было вбивать программу в память компьютера непосредственно в цифровом виде, переключая тумблеры, проводки и кнопочки. Число таких переключений могло достигать нескольких сотен и росло по мере усложнения программ. Встал вопрос об экономии времени и денег. Поэтому следующим шагом в развитии стало появление в конце сороковых годов прошлого века первого транслятора-ассемблера, позволяющего удобно и просто писать машинные команды на человеческом языке и в результате автоматизировать весь процесс программирования, упростить, ускорить разработку программ и их отладку. Затем появились языки высокого уровня и компиляторы (более интеллектуальные генераторы кода с более понятного человеку языка) и интерпретаторы (исполнители написанной человеком программы на лету). Они совершенствовались, совершенствовались — и, наконец, дошло до того, что можно просто программировать мышкой.

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

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

Синтаксис

Общепринятого стандарта для синтаксиса языков ассемблера не существует. Однако большинство разработчиков языков ассемблера придерживаются общих традиционных подходов. Основные такие стандарты — Intel-синтаксис и AT&T-синтаксис.

Общий формат записи инструкций одинаков для обоих стандартов:

Опкод — это и есть собственно ассемблерная команда, мнемоника инструкции процессору. К ней могут быть добавлены префиксы (например, повторения, изменения типа адресации). В качестве операндов могут выступать константы, названия регистров, адреса в оперативной памяти и так далее. Различия между стандартами Intel и AT&T касаются в основном порядка перечисления операндов и их синтаксиса при разных методах адресации.

Используемые команды обычно одинаковы для всех процессоров одной архитектуры или семейства архитектур (среди широко известных — команды процессоров и контроллеров Motorola, ARM, x86). Они описываются в спецификации процессоров.

Например, процессор Zilog Z80 наследовал систему команд Intel i8080, расширил ее и поменял некоторые команды (и обозначения регистров) на свой лад. Например, сменил Intel-команду mov на ld. Процессоры Motorola Fireball наследовали систему команд Z80, несколько ее урезав. Вместе с тем Motorola официально вернулась к Intel-командам, и в данный момент половина ассемблеров для Fireball работает с Intel-командами, а половина — с командами Zilog.

Директивы

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

  • определение данных (констант и переменных);
  • управление организацией программы в памяти и параметрами выходного файла;
  • задание режима работы компилятора;
  • всевозможные абстракции (то есть элементы языков высокого уровня) — от оформления процедур и функций (для упрощения реализации передачи параметров) до условных конструкций и циклов;
  • макросы.

Продолжение доступно только участникам

Вариант 1. Присоединись к сообществу «Xakep.ru», чтобы читать все материалы на сайте

Членство в сообществе в течение указанного срока откроет тебе доступ ко ВСЕМ материалам «Хакера», увеличит личную накопительную скидку и позволит накапливать профессиональный рейтинг Xakep Score! Подробнее

Содержание

Начинаем программировать на ассемблере → Assembler&Win32. Курс молодого бойца. Введение.

Что это такое? Наверное, каждый из нас думает, что ассемблер это что-то сложное, очень трудное для изучения и вообще недосягаемое. Поверьте мне, я тоже так, когда-то думал. Невозможное возможно. Этот туториал рассчитан для тех, кто даже не знает никакого языка программирования, я вообще выступаю, за то, что надо сначала изучать ассемблер, а потом только языки высокого уровня. Если вы перечитаете весь туториал от этих строк до самого конца то вам будет намного проще изучать другие языки программирования, и вы уже никогда не будете спорить о том какой язык лучше С++ или Delphi.
В этом туториале я расскажу вам, что такое ассемблер и с чем его едят. Чем же примечателен этот туториал. Этот туториал примечателен тем, что я расскажу вам про ассемблер под Win32 системы, конечно, есть много учебников и книг про ассемблер, но и все писались под DOS, а ДОС это 16 разрядный отстой. Программирование под ДОС, очень сложно, но чтобы программировать под Win32 можно вообще ничего не знать про DOS. Короче забудьте про ДОС. По ходу этого туториала, я буду немного возвращаться к нему, но только для того чтобы пояснить, чем Win32 лучше DOS.

Assembler — это произведение искусства. Ниже ассемблера только машинные коды. Ассемблер создан как замена двоичному коду, который понимает процессор. При написании программы на ассемблере вы просто пишете команды процессора, которые процессор последовательно выполняет. Пример команды:

В машинных кодах это будет 8BC3 (шестнадцатеричный код, теперь всё будет шестнадцатеричным, ПРИВЫКАЙТЕ). Процессор смотрит на эти циферки и делает то, что они обозначают. Любая программа, написанная на языке высокого уровня (исключая .NET), преобразовывается в ассемблерный код. А почему же ассемблер лучше, чем С++ и др.. Дело в том, что программу, написанную на языке высокого уровня надо перевести на ассемблер, а это очень трудно, потом надо его оптимизировать, современные компиляторы очень плохо с этим справляются. Я провел эксперимент, написал программу (обычное окно с одной кнопкой в центре, которая закрывает его) на разных языках высокого уровня и после компиляции получил вот такие размеры этой самой программы:

C++ Builder 4 — 22 kb
Delphi 5 — 291 kb
Delphi 5 + библиотека KOL — 26 kb
Ассемблер MASM — около 3 kb

Так, что смотрите и делайте выводы, что лучше использовать.
Есть другое различие с некоторыми языками высокого уровня, это использование runtime DLL библиотек для их функций. Visual Basic даже не преобразовывает свой язык в ассемблер (хотя версия 5 и выше делают это частично, но не полностью), это сильно зависит от msvbvm50.dll, виртуальной машины Visual Basic. Exe файл, который создан VB, состоит из простых частей кода и многих вызовов этой DLL. Вот почему VB очень медленный. Ассемблер это и есть самый быстрый язык. Он использует только системные DLL: kernel32.dll, user32.dll, и т.д.
Теперь приступим к тому, где именно мы будем писать наши программы на ассмеблере. Компиляция состоит из 2 стадий:
Проверка синтаксиса, создание объектного файла и файла листинга
Линковка, т.е. компоновка.
Вы, наверное, все привыкли к тому, что запускаете Microsoft Visual C++, пишете программу, нажимаете на F7 и всё готово. На ассемблере вам придётся всё делать всё вручную. У ассемблера нет такой среды разработки. Вам придётся писать программу в блокноте, сохранять его в *.asm файл. И из командной строки вызывать ассемблер и линковщик. Потом я вам всё объясню.

Теперь смотрим инструменты.

Связки ассемблер-линковщик:
MASM32 v9.0 (ml.exe, link.exe)
TASM32 v5.0 (tasm32.exe, tlink32.exe)
Также можно FASM, но он только для спецов, примечателен тем, что у него есть своя оболочка не надо никаких объектных файлов т.д., нажимаешь F9 и всё готово.

Текстовые редакторы
EmEditor Professional Version 4.13 (вне конкуренции)
UltraEdit v*.*.*.* (тоже хороший не я им не пользуюсь)

Блокнот : (классика).
Также пригодится справочник по API функциям. Желательно из комплекта MS SDK. Полная версия весит 24 MB (почти все апи), есть урезанные версии весом 12 МВ. Русские версии весом

400 KB даже не читайте.

Думаю, хватит для введения. Ну, как? Ещё не отбило желания изучить ассемблер.

Илон Маск рекомендует:  text-align в CSS
Понравилась статья? Поделиться с друзьями:
Кодинг, CSS и SQL