Для чего нужен ассемблер – Для чего нужен ассемблер? — Toster.ru

Учебный курс. Часть 0. Зачем учить ассемблер

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

Ассемблер — это практически самый древний язык программирования. До него было лишь программирование в машинных кодах 😉

Итак, какие же преимущества дает знание ассемблера:

  1. Глубокое понимание работы компьютера и операционной системы.
  2. Максимальная гибкость при работе с аппаратными ресурсами.
  3. Оптимизация программ по скорости выполнения.
  4. Оптимизация программ по размеру кода.
  5. Дизассемблирование и отладка.

Глубокое понимание работы компьютера и операционной системы.

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

Максимальная гибкость при работе с аппаратными ресурсами.

Используя ассемблер, можно делать с компьютером все что угодно! А языки высокого уровня ограничены компилятором и используемыми библиотеками. Такие современные языки, как Java и C# вобще не позволяют работать с аппаратными ресурсами и операционной системой напрямую.

Оптимизация программ по скорости выполнения.

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

Оптимизация программ по размеру кода.

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

Дизассемблирование и отладка.

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

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

Следующая часть »

asmworld.ru

Введение в язык Assembler

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

Особенно теперь, когда все пишут на
C/C++, Delphi или других языках высокого
уровня? Действительно, ведь очень многое
можно создать на С, но ни
один язык, даже такой популярный, не
может претендовать на то, чтобы на нём
можно было написать действительно
абсолютно «
всё».

Итак, на
Ассемблере пишут
:

1) всё, что требует
максимальной скорости выполнения:
основные компоненты компьютерных игр,
ядра операционных систем реального
времени и просто критические участки
программ;

2) всё, что
взаимодействует с внешними устройствами:
драйверы; программы, работающие напрямую
с портами, звуковыми и видеоплатами;

3) всё, что полностью
использует возможности процессора:
ядра многозадачных операционных систем,
DPMI-серверы и вообще любые программы,
перево­дящие процессор в защищённый
режим;

4) всё, что полностью
использует возможности операционной
системы: виру­сы и антивирусы; программы
защиты от несанкционированного доступа;
программы, об­ходящие эти защиты, и
программы, защищающиеся от данных
программ;

и многое другое.

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

Как же так? Ведь
всем известно, что Ассемблер –
неудобный язык, и писать на нём долго и
сложно! Давайте перечислим мотивы,
которые обычно выдвигаются в доказательство
того, что Ассемблер не нужен.

1) Говорят,
что ассемблер трудно выучить
.
Любой язык программирования трудно
выучить. Легко выучить С или Delphi после
Pascal, потому что они похожи. А по­пробуйте
освоить Lisp, Forth или Prolog, и окажется, что
ассемблер в действитель­ности даже
проще, чем любой абсолютно незнакомый
язык программирования.

2) Говорят,
что программы на ассемблере трудно
понять
.
Разумеется, на ассембле­ре легко
написать неудобочитаемую программу,
точно так же, как и на любом дру­гом
языке! Если вы знаете язык и если автор
программы не старался её запутать, то
понять программу будет не сложнее, чем
если бы она была написана на Basic.

3) Говорят,
что программы на ассемблере трудно
отлаживать
.
Программы на ассемблере легко отлаживать
– опять же при условии, что Вы знаете
язык. Более того, знание ассемблера
часто помогает отлаживать программы
на других языках, потому что оно даёт
представление о том, как на самом деле
функционирует ком­пьютер и что
происходит при выполнении команд языка
высокого уровня.

4) Говорят,
что современные компьютеры такие
быстрые, что ассемблер больше не нужен
.
Каким бы быстрым ни был компьютер,
пользователю всегда хочется большей
скорости, иначе не наблюдалось бы
постоянного спроса на ещё более мощные
компьютеры. И самой быстрой программой
на данном оборудовании все­гда будет
программа, написанная на ассемблере.

5) Говорят,
что писать на ассемблере сложно
.
В этом есть доля правды. Очень часто
авторы программ на ассемблере «изобретают
велосипеды», программируя заново
элементарные процедуры типа форматированного
вывода на экран или генератора случайных
чисел, в то время как программисты на С
просто вызывают стандартные функции.
Библиотеки таких функций существуют и
для ассемблера, но они не стандартизированы
и не распространяются вместе с
компиляторами.

6) Говорят,
что программы на ассемблере не переносятся
.
Действительно, в этом заключается самая
сильная и самая слабая сторона ассемблера.
Во-первых, благо­даря этой особенности
программы на ассемблере используют
возможности ком­пьютера с наибольшей
полнотой; во-вторых, эти же программы
не будут работать на другом компьютере.
Стоит заметить, что и другие языки часто
не гарантируют переносимости – та же
программа на С, написанная, например,
под Windows 95, не скомпилируется ни на
Macintosh, ни на SGI.

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

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

Степень мотивации
при изучении того или иного раздела
науки или практического навыка имеет
первостепенное значение и во многом
определяет успех или неудачу. Для себя
вопрос можно сформулировать более
точно: зачем мне нужно изучать Ассемб­лер?

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

В настоящее время
на всём земном шаре миллионы, если не
миллиарды, людей вовлечены в процесс
компьютеризации. Без преувеличения
можно сказать, что люди, общающиеся с
ком­пьютером на уровне Ассемблера,
стоят на вершине этой гигант­ской
пирамиды. Это – жрецы информатики, они
же относятся к самым высокооплачиваемым
программистам. Таким обра­зом, изучив
Ассемблер, можно в полной мере удовлетворить
собственное честолюбие не в ущерб
окружающим и приобрести специальность
с высокой степенью востребованности.

Переходя к более
специфическим аспектам, необходимо
отме­тить, что программа на Ассемблере
как никакая другая близка к машинному
коду, является лишь «слегка причёсанным»
ма­шинным кодом.

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

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

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

Можно утверждать,
что знание Ассемблера и умение работать
с компьютером на самом нижнем уровне
обязательны для сис­темного
программиста-профессионала. Однако и
учёный-прикладник может делать простые
ассемблерные вставки в свои программы
на Паскале или на C++, «вылизывая» наиболее
ответ­ственные их места. Кстати, можно
и наоборот, вставлять процеду­ры на
языках высокого уровня в ассемблерную
программу.

Наконец, нельзя
не отметить удовольствие от программирования,
когда вы работаете один на один с
«железом» компьютера и между вами и
компьютером никто не стоит (имеется в
виду автор компи­лятора с языка
высокого уровня), как бы ни был высок
его профес­сиональный уровень.

Итак, если Вы хотите
до конца понять, как работает ваш
ком­пьютер и использовать возможности
компьютера на 100 %, соз­давать интерфейсы
с внешними устройствами, перехватчики,
перекодировщики, надёжно защищать свои
программные про­дукты и иметь
потенциальную возможность взламывать
чужие и многое другое, – Ассемблер
для Вас
.

studfiles.net

Ассемблер Введение


Главная /
Ассемблер /
Для чайников /


Для начала разберёмся с терминологией.


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

Язык программирования низкого уровня (низкоуровневый язык программирования) –
это язык программирования, максимально приближённый к программированию в машинных кодах.
В отличие от машинных кодов, в языке низкого уровня каждой команде соответствует не число,
а сокращённое название команды (мнемоника). Например, команда ADD – это сокращение от слова
ADDITION (сложение). Поэтому использование языка низкого уровня существенно упрощает написание
и чтение программ (по сравнению с программированием в машинных кодах). Язык низкого уровня
привязан к конкретному процессору. Например, если вы написали программу на языке низкого
уровня для процессора PIC, то можете быть уверены, что она не будет работать с процессором AVR.


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


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


Ассемблер – это специальная программа, которая преобразует (компилирует)
исходные тексты вашей программы, написанной на языке ассемблера, в исполняемый файл (файл
с расширением EXE или COM). Если быть точным, то для создания исполняемого файла требуются
дополнительные программы, а не только ассемблер. Но об этом позже…


В большинстве случаев говорят «ассемблер», а подразумевают «язык ассемблера». Теперь
вы знаете, что это разные вещи и так говорить не совсем правильно. Хотя все программисты
вас поймут.

ВАЖНО!
В отличие от языков высокого уровня, таких, как
Паскаль,
Бейсик и т.п., для
КАЖДОГО АССЕМБЛЕРА существует СВОЙ ЯЗЫК АССЕМБЛЕРА. Это правило в корне отличает язык
ассемблера от языков высокого уровня. Исходные тексты программы (или просто «исходники»),
написанной на языке высокого уровня, вы в большинстве случаев можете откомпилировать
разными компиляторами для разных процессоров и разных операционных систем.
С ассемблерными исходниками это сделать будет намного сложнее. Конечно, эта разница
почти не ощутима для разных ассемблеров, которые предназначены для одинаковых процессоров.
Но в том то и дело, что для КАЖДОГО ПРОЦЕССОРА существует СВОЙ АССЕМБЛЕР и
СВОЙ ЯЗЫК АССЕМБЛЕРА. В этом смысле программировать на языках высокого уровня гораздо проще.
Однако за все удовольствия надо платить. В случае с языками высокого уровня мы можем
столкнуться с такими вещами как больший размер исполняемого файла, худшее быстродействие и т.п.


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

  1. Emu8086. Хорошая программа, особенно для новичков. Включает в себя редактор исходного
    кода и некоторые другие полезные вещи. Работает в Windows, хотя программы пишутся под DOS.
    К сожалению, программа стоит денег (но оно того стоит))). Подробности см. на сайте
    http://www.emu8086.com.
  2. TASM – Турбо Ассемблер от фирмы Borland. Можно создавать программы как для DOS так и для
    Windows. Тоже стоит денег и в данный момент уже не поддерживается (да и фирмы Borland уже
    не существует). А вообще вещь хорошая.
  3. MASM – Ассемблер от компании Microsoft (расшифровывается как МАКРО ассемблер, а не
    Microsoft Assembler, как думают многие непосвящённые). Пожалуй, самый популярный ассемблер
    для процессоров Intel. Поддерживается до сих пор. Условно бесплатная программа. То есть,
    если вы будете покупать её отдельно, то она будет стоить денег. Но она доступна бесплатно
    подписчикам MSDN и входит в пакет программ Visual Studio от Microsoft.
  4. WASM – ассемблер от компании Watcom. Как и все другие, обладает преимуществами и
    недостатками.
  5. Debug — обладает скромными возможностями, но имеет большой плюс — входит в стандартный
    набор Windows. Поищите ее в папке WINDOWS\COMMAND или WINDOWS\SYSTEM32. Если не найдете,
    тогда в других папках каталога WINDOWS.
  6. Желательно также иметь какой-нибудь
    шестнадцатеричный редактор. Не
    помешает и досовский файловый менеджер, например Волков Коммандер (VC) или Нортон Коммандер
    (NC). С их помощью можно также посмотреть шестнадцатеричные коды файла, но редактировать
    нельзя. Бесплатных шестнадцатеричных редакторов в Интернете довольно много. Вот один из них:
    McAfee FileInsight v2.1. Этот же редактор можно использовать для работы с исходными текстами программ. Однако мне больше нравится делать это с помощью следующего редактора:
  7. Текстовый редактор. Необходим для написания исходных текстов ваших программ. Могу
    порекомендовать бесплатный редактор
    PSPad, который поддерживает множество языков
    программирования, в том числе и язык Ассемблера.

Все представленные в этой книге программы (и примеры программ) проверены на работоспособность.
И именно эти программы используются для реализации примеров программ, приведённых в данной
книге.


И еще – исходный код, написанный, например для Emu8086, будет немного отличаться от кода,
написанного, например, для TASM. Эти отличия будут оговорены.


Большая часть программ, приведённых в книге, написана для MASM. Во-первых, потому что
этот ассемблер наиболее популярен и до сих пор поддерживается. Во-вторых, потому что он
поставляется с MSDN и с пакетом программ Visual Studio от Microsoft. Ну и в третьих, потому
что я являюсь счастливым обладателем лицензионной копии MASM.


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

av-assembler.ru

Ассемблер — Lurkmore

Народ требует хлеба и зрелищ!
Народ требует иллюстраций к статье!
В конце концов, если бы мы хотели почитать, мы бы пошли в библиотеку.
«

Нам не дано предугадать, как слово наше отзовется…

»
— Ф. И. Тютчев программирует на Ассемблере

Ассемблер или asm (англ. assembler — сборщик) — утилита, транслирующая исходники программы на языке ассемблера собственно в машинный код, то есть на язык бездушной машины. Для обратного превращения существует дизассемблер (англ. disassembler — разборщик, ломалка), широко используемый хакерами. Но это для шибко грамотных, а все остальные словом «ассемблер» называют сам язык ассемблера — простейший способ записи машинного кода с помощью расовых английских сокращений, называемых мнемониками (см. в конце статьи — если осилите). Поскольку язык ассемблера привязан к устройству процессора, программы на нем не являются переносимыми на иную компьютерную архитектуру, так как тип процессора жёстко определяет набор доступных команд машинного языка. Но это не так уж и важно, так как нет процессора кроме x86 и фон Нейман пророк его, а всякие Жабы и дотнеты вообще используют собственные виртуальные машины с собственным асмом — похуй, что в тысячу раз медленнее, зато переносимость и безопасность, блджад! Также, используя макросы, юный друг сможет убедиться в отсутствии принципиальной разницы между асмом и всеми остальными «православными» языками.

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

Простейший транслятор (ассемблер первого поколения) позволял фактически просто писать машинные команды на «человеческом» языке, что позволило программерам немного расслабиться. Достаточно быстро туда добавились многочисленные свистелки и перделки, нарушающие Истинную Красоту Программирования На Ассемблере, но еще больше экономящие время и силы (а значит и деньги), как то макросы, библиотеки и прочее.
Затем появились языки высокого уровня и компиляторы (более интеллектуальные генераторы кода с более понятного человеку языка) и интерпретаторы (исполнители человекописанной программы на лету). Которые совершенствовались, совершенствовались, совершенствовались, и досовершенствовались до «программирования мышкой», а компиляторы научились генерировать код, которому по скорости написанный человеком начал сливать[1]. Такие дела.

В целом история языков программирования протекает в направлении от программирования на языке компьютера до манипуляции абстракциями вроде Послать.Лесом(всех(кому не нравится эта статья)) Ну или (послать (лесом (всех (кому-не-нравится "эта-статья")))) или

послать :: Куда -> [Люди] -> String
послать куда = map (\x -> (show x) ++ ", иди " ++ (show куда))
кванторВкуса :: (ОбъектЧувства a) => ТипКвантора -> ТипОтношения -> a -> [Люди]

посылаем :: String
посылаем =  let быдло = кванторВкуса Все НеНравится этаСтатья
            in послать быдло

На языке ассемблера этот код занял бы более 9000 строк. И потребовал бы долгой и кропотливой работы по своему созданию. Зато, в отличие от Шindoшs, оно бы работало, а не только свистело, пердело, выдавало красивые иконки и жрало 640K памяти.

[править] Асмофаги и студенты из Политеха

Среди программистов с длинной бородой, видевших еще те компьютеры-динозавры, есть такие, которые очень трепетно относятся к напейсанию кода, и считают, что ассемблер — это труЪ, а языки высокого уровня — шлак и унылое говно, предназначенные исключительно для быдлокодерства. При упоминании факта, что современные компиляторы генерируют гораздо более быстрый код, начинают срать кирпичами и обзываться нехорошими словами, ибо сама мысль, что машина может быть умнее человека, считается недопустимой и кощунственной. При этом упускается тот факт, что компиляторы, вообще-то, пишут люди. Степень владения языком ассемблера считается мерилом отличия программиста от быдлокодера. Наиболее тяжелый клинический случай представляет молочный брат Линуса расовый чухонец Вилле Турьянмаа, написавший целую ОС — MenuetOS на чистом ассемблере. На ассемблере же была написана первая версия UNIX, коя им и не является по нынешним понятиям, так как позже была переведена чуть более, чем наполовину на C и помещена в анналы истории.

Тем не менее, программирование на языке ассемблера очень часто используется при написании программ, использующих возможности процессора, не реализуемые языками высокого уровня, а также программировании всевозможных нестандартных программистских хитростей. Драйвера для новых устройств тоже содержат в себе чуть менее, чем половину ассемблерного кода, коий при доведении их до ума ушастыми мартышками заменяют на стандартный C/C++. Часто компиляторы (чуть менее, чем все) предоставляют возможность вставлять ассемблерный код в текст программы.

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

Понятно, что писать что-либо крупное на ассемблере в современном мире не будет даже самый отъявленный маньяк, даже большинство фирмваря и прочих глюкалок для микроконтроллеров сейчас пишется на чем-то более продвинутом. Но когда стоимость каждого лишнего не то что мегабайта, а полубайта в ОЗУ становится критичной (ибо их просто нет, например на каком-нибудь запущенном много лет назад спутнике, до которого можно достучаться по радио, но никак физически), выливаются в миллиарды и даже жизни (встроенный софт бортовых систем в авиации и космонавтике) — ассемблер strikes back! К примеру, софт для кораблей «Союз ТМА-М», «Прогресс М-М» написан на Си (по крайней мере, российский сегмент МКС). ПО ЦВМов «Бурана» писалось на ПРОЛ-2. «Союз ТМА» — не на Си, у него БЦВК «Аргон-16», сначала программировали его на ассемблере, в поздних машинах транслировали на высокоуровневый язык. Спутники «Ямал» и «Белка» написаны на Си.

Хотя программирование на ассемблере в Unix-мире считается моветоном, поскольку нарушает один из основополагающих принципов unix way «жертвуй производительностью ради переносимости», даже тут находится место разногласиям, способным вылиться в настоящую драму.

Дело в том, что встроенный ассемблер большинства Unix-ов (и Linux в том числе) использует синтаксис (AT&T-синтаксис), в корне отличающийся от оригинального Intel-синтаксиса. А поскольку Intel-синтаксис у большинства труЪ-линуксоидов прочно ассоциируется с маздаем, он объявляется ересью, и всем, кто пользуется nasm, yasm или fasm пророчатся вечные муки, страшный суд, ад и погибель, хотя gas тоже владеет интеловским синтаксисом. Правда все ELF-инфекторы всё же приходится писать на старом добром асме.

Алсо какой либо годной документации по ассемблеру AT&T в интернете хрен найдешь. По этой причине программистов на AT&T крайне мало. А по этой причине некому писать документацию.

[править] Ассемблер в кино

Оно.

Как минимум один раз снялся в кино, но зато в каком! В первой части Терминатора можно видеть как Киборгъ предпочитает MOS Technology 6510/8500 ассемблер.

Необходимое пояснение. На скриншоте видна программка из чередующихся инструкций LDA-STA-LDA-STA…(load-store-load-store). В семействе 6502 программы состоят чуть менее, чем полностью из LDA/LDY/LDX/STA/STX/STY вследствие наличия всего 3х 8-битных регистров. Наличие почти полного отсутствия регистров компенсируется нулевой страницей памяти, откуда-куда постоянно приходится перекладывать байтики, так как хранить их более негде. В данном ЦПУ 13 режимов адресации на всего 53 команды. Алсо порты ввода-вывода замаплены в адреса памяти, так что чтение-запись из-в порты осуществляется также этими командами. Короче: программы в Терминаторе имеют вполне осмысленный вид и не являются кучей команд от балды. Подробнее: Этот удивительный Терминатор/48076.

Во второй части интерфейс Терминатора более очеловечен. Впрочем, это можно объяснить тем, что ПО для первого терминатора делал Скайнет, а для второго набыдлокодил Джон Коннор.

Алсо, ассемблер семейства 8080 (у нас серия КР580) засветился в давнем аниме «Megazone 23».

Алсо, в качестве исходника чат-бота Киса в фильме }{[email protected]БЬ)Ч был показан исходник чат-бота Eliza на асме для калькулятора TI-83 Plus с процессором Z80.

Алсо, в фильме «Элизиум» (2013) пафосный топ-манагер кодит на асме.

[править] Область применения

  • Популярен для допиливания зацикливаемых кусков программы… в роли напильника. Перепиливание критических участков кода может принести PROFIT, а может и не принести. В любом случае, заниматься таким перепиливанием стоит только тогда, когда у вас на руках уже полностью работающий алгоритм, который можно было бы ускорить, а не наоборот.
  • Для использования в софтине новых команд, доступных в новых процессорах. Компилятор хоть и оптимизирует код высокого уровня при компиляции, но… практически никогда не способен генерировать инструкции из расширенных наборов команд типа AVX, СTV, XOP и т. п. Потому что команды в процессоры добавляют быстрее, чем в компиляторах появляется логика для генерации этих команд.
  • Используется для написания кода, создание которого невозможно (или затруднено) на языках высокого уровня, например, получение дампа памяти/стека. Даже когда аналог на языке высокого уровня возможен, профит от языка ассемблера может быть значительным в разы. Например, реализация подсчета среднего арифметического двух чисел с учётом переполнения для x86 процессоров занимает всего 2 команды (сложение с выставлением флага переноса и сдвиг с заёмом этого флага). Аналог на языке высокого уровня ((long) x + y) >> 1
    1. может не работать в принципе, ведь sizeof(long) == sizeof(int). Ну или может бомбануть, как это было на ракете Ариан-5 (64-ичные переменные с плавающей запятой float преобразовывались в 16 бит фиксированных, когда программа дошла до 32767+1, у ракеты включилась система «самоуничтожение на случай попадания в мир КГБ» прямо на космодроме.
    2. при компиляции конвертируется в чуть менее чем дохрена команд процессора.

Ещё пример: перемножение чисел с фиксированной запятой в языке, в который не вшита поддержка такого формата чисел. На ассемблере это умножение eax на edx с сохранением 64-битного результата в edx:eax с последующим сдвигом вправо (shrd). На ЯВУ это выглядит либо как (x*y)>>16, что не даёт верный результат при выходе результата умножения за 32 бита, либо как (int64(x)*y)>>16, что конвертируется в дохрена команд.
Впрочем, в данных примерах современные компиляторы умеют правильно понимать намерения программиста и генерировать оптимальный код.

  • Также может использоваться задротами для написания очень компактных программ. Пример: клиент для аськи, занимающий в скомпилированном виде 34 КБ. Другой пример: тоже IM-клиент Faim 0.21 — 12.61 КБ. Отдельная дисциплина этой специальной олимпиады — демки.
  • В вузах изучается для вливания в МНУ студентоты познаний об устройстве и работе компьютера на уровне повыше кликанья мышкой по окошкам. Отличное лекарство от быдлокодерства (ну, а для оказавшихся неспособными осилить, соответственно — окончательное решение).
  • Является единственным языком программирования для создания достойных инфекторов — Cih, Sality, Sinowal.
  • Чуть более чем половина программ для GPU пишутся на ассемблере, наряду с использованием языков высокого уровня HLSL или GLSL. Хороший, годный шейдер обязательно содержит асму, ибо GPU — это принципиально узкое место для выделения графической составляющей в монитор (Есть, конечно и более современные методы типа использования OpenCL, но всё же ASM << C).
  • Оптимизация невъебенно затратных математических алгоритмов. Часто встречается в исходниках фильтров для так любимого видеопиратами и аниматорами винрарнейшего AviSynth.
  • Промежуточный этап между неким левым синтаксисом (не обязательно даже языком, это может быть визуальный «конструктор» программы вроде ДРАКОНа) и исполнимым кодом. Петя хочет анализ Фурье на ЦСП на участке в миллисекунду, а Вася в две? Нет проблем, нажимайте кнопочки и собирайте в проект полученные пятидесятиметровые ассемблерные сырцы, работающие с предельно возможной именно для конкретного случая скоростью. Не компилятор же отдельный писать ради Васи и Пети, честное слово.
  • Программирование под устаревшие платформы (NES, например), которым мешает использовать «сбалансированный» Си крайне низкая производительность и нужда в хитрых изъёбах при обработке данных и графики.
    Тамошний ассемблер, в отличие от этих ваших x86, обладает Духовностью и Минимализмом.

[править] Пример программирования

Нижеследующий кусок кода переключает процессор из реального (16-битного) режима в длинный (64-битный). Эпичность заключается в «прыжке через десятилетия», поскольку переключает ЦП x86 из режима совместимости со своим предком 1979 года рождения, в коем он находится сразу после подачи питания, в современный (2003 года разработки), где доступны все инструкции и всё адресное пространство памяти.

Данный пример написан для ассемблера nasm:

BITS 16
                ; Тут шла длинная инициализация системных таблиц; прерывания запрещены, NMI блокировано
 
                lidt [idtr_image]          ; IDTR указывает на 64-битную таблицу прерываний
		lgdt [gdtr_image]          ; GDTR указывает на глобальную дескрипторную таблицу
		mov eax,cr4                ; Установим CR4.PAE=1
		or ax,20h
		mov cr4,eax
 
		mov ecx,0C0000080h         ; Установим EFER.LME=1
		rdmsr
		or ax,100h
		wrmsr
 
		mov eax,[pml4_base]       ; Установим CR3 на корневую таблицу страниц
		mov cr3,eax
 
		mov eax,cr0               ; Все готово. Установкой CR0.PE и CR0.PG включаем длинный режим
		or eax,80000001h          
		mov cr0,eax
 
		db 66h                     ; Это переводится как jmp far 0008:start_64
		db 0eah                    ; Вписываем цыфирками, поскольку надо наставить нужных префиксов
	        dd start_64                ; Чистим очередь команд и прыгаем в 64-битный код
		dw 08h
BITS 64
start_64:       mov rsp,STACK_BASE         ; установим стек
               ; Здесь хуярим 64-битный код...

Вообще, в среде ASM программистов существует целая война ассемблеров. Кто-то предпочитает nasm, кто-то yasm, tasm, masm или даже fasm. На самом деле вроде бы и ерундовая вещь, но каждый ассемблер имеет свои особенности и целый ряд анальных ограничений. Поэтому не удивляйтесь, если кто-то будет с пеной у рта отстаивать свой ассемблер, или тому, что код, написанный под одну разновидность, на другой попросту не оттранслируется. Ассемблер имеет множество диалектов, некоторые из них довольно продвинуты, например, никому не нужные макросы в fasm чем-то напоминают язык высокого уровня, поэтому он вызывает в среде ассемблерщиков некоторый баттхёрт, да ещё и ассоциации с хорошо оптимизированным и разбитым на отдельные операции с прямыми указателями Си делают контрольный выстрел.

[править] Мнение изучающей студентоты

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

[править] Мнение изучившей студентоты

Будучи изученным в течение нескольких лет в вузе и применяемым на практике, добавляет стопицот к ЧСВ, что мешает при необходимости программировать на не-ТруЪ-языках при смене работы (а также пола, возраста, профессии и т.п). Например, писать на javascript после ассемблера походит на процесс создания красных сердечек на торте из сахара паяльником: дорого, долго и болезненно. Зато чем-то похоже на ТруЪ

  • Эрик Дрекслер придумал и популяризовал концепт особого наноустройства — ассемблера. Суть™ девайса состоит в том, что продукты своей деятельности он собирает из отдельных атомов. Размножается так же. Будучи в больших количествах, как джинн из бутылки, сможет лечить людей, перерабатывать любой мусор, производить изделия безупречного качества и выполнять всяческие прихоти. Однако, выйдя из-под контроля, способен учинить тотальную демократию, превратив всю поверхность Земли вместе со всем ее содержимым в идеальное высокотехнологическое говно. Визуально винрарно такой сценарий показан в сериале Stargate SG-1. Местные репликаторы превратили целую планету в себя и только тогда задумались, зачем оно им было надо.
  • Как упомянуто в заголовке, в переводе с расово-пиндосского Assembler означает «сборщик». То есть в тех же СШП ассемблером может называться всё (неживое и живое), что занимается сборкой чего-либо.
  • TASM — Tomahawk Anti-Ship Missile (BGM-109B TASM). Пиндосская противокорабельная крылатая ракета «Томагавк».
  • В запланированной небезызвестным Нотчем игре — 0х10с — нужно было бы иметь знания Assembler’а для того, чтобы твой корабль мог сам по себе ремонтироваться, поровну распределять энергию между системами и приносить тебе удовольствия самоудовлетворения, пока ты, дорогой быдлокодер, фиксишь косяки этого самого Assembler’a. Но после полутора лет разработки Нотч слился, так и не осилив сабж. Так-то!
  1. ↑ Речь идёт только о последнем эшелоне оптимизации — оптимальном генерировании машинных операций. А в наше время узкое место и так давно уже не в нём, а в бездарной архитектуре комплексов ПО в целом, из-за чего машина занимается переливанием из пустого в порожнее — но с предельно оптимизированной скоростью струи, да — это в первую очередь. А еще очень негативно на скорости сказывается незнание быдлокодерами основ теории алгоритмов и структур данных. Второй пункт в последнее время нивелируется невъебенно навороченными стандартными (или специальными) библиотеками языков и сред разработки, что в конечном итоге способствует терминальному отупению тех же быдлокодеров и возвратом к пункту 1 этой ссылки
Ассемблер — прародитель багов и фич!

lurkmore.to

C vs Assembler | Электроника для всех

Если ты впервые столкнулся с микроконтроллерами, то наверняка у тебя стал выбор на чем писать.

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

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

Assembler+
Парадоксально, но под микроконтроллеры писать на ассемблере ничуть не сложней чем на Си. В самом деле, программирование контроллера неотделимо от его железа. А когда пишешь на ассемблере, то обращаешься со всей периферией контроллера напрямую, видишь что происходит и как это происходит. Главное, что при этом ты четко понимаешь что, как и зачем ты делаешь. Очень легко отлаживать и работа программы как на ладони.
Да и сам ассемблер изучается очень быстро, за считанные дни. Достаточно постоянно иметь перед глазами систему команд и навык программирования алгоритмов. А соответствующее состояние мозга, когда начинаешь мыслить ассемблерными конструкциями наступает очень быстро.

C-
А вот с высокими языками, например с Си, ситуация уже куда хуже. Да, повторить какой нибудь пример из обучалки, вроде вывода строки на дисплей, Сях куда проще, подключил нужную библиотеку, набрал стандартную команду и вот тебе результат. Но это только так кажется. На самом деле, стоит чуть вильнуть в сторону, как начинается темный лес. Особенно когда дело начинает касаться адресации разных видов памяти,

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

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

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

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

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

Кроме того существуют такие контроллеры как ATTiny 1x у которых либо вообще нет оперативки, либо она такая мизерная, что даже стек там сделан аппаратным. Так что на Си там ничего написать в принципе нельзя.

Assembler+
Представь, что ты прораб, а компилятор это банда джамшутов. И вот надо проделать дырку в стене. Даешь ты джамшутам отвертку и говоришь — ковыряйте. Проковряют они отверткой бетонную стену? Конечно проковыряют, вопрос лишь времени и прочности отвертки. Отвертка сточится (читай памяти процессора или быстродействия не хватит)? Не беда — дадим джамшутам отвертку побольше, благо разница в цене между большой отверткой и маленькой копеечная. В самом деле, зачем прорабу, руководителю, знать такие низкоуровневые тонкости, как прочность и толщина бетонной стены, типы инструмента. Главное дать задание и проконтроллировать выполнение, а джамшуты все сделают сами.
Задача решается? Да! Эффективно это решение? Совершенно нет! А почему? А потому что прораб не знал, что бетон твердый и отверткой его проковырять сложно. А будь прораб сам когда то рабочим, пусть даже не профи, но своими руками положил плитку, посверлил дырки, то впредь таких идиотских заданий бы не давал. Конечно, нашего прораба можно и в шараге выучить, дав ему всю теорию строения стен, инструмента, материалов. Но ты представь сколько это сухой теории придется перелопатить, чтобы чутье было интуитивным, на уровне спинного мозга? Проще дать в руки инструмент и отправить сверлить стены. Практика — лучший учитель.

Также и с ассемблером. Хочешь писать эффективные программы на высокоуровневом языке — изучи хотя бы один ассемблер, попиши на нем немного. Чтобы потом, глядя на любую Сишную строку, представлять себе во что это в итоге компилируется и как обрабатывается контроллером. Очень помогает в отладке и написании, а уж про ревесирование чужих программ я вообще не говорю.

Assembler-
Но засиживаться в ассемблерщиках и стараться все сделать на нем далеко не обязательно. Ассемблерный код тяжелей переносить с контроллера на контроллер, в нем при переносе можно наделать много незначительных, но тем не менее фатальных ошибок. Отладка которых занимает много времени. Большие проекты писать на ассемблере то еще развлечение. На ассемблере трудно сделать полноценную библиотеку, подключаемую куда угодно. Ассемблер жестко привязан к конкретному семейству контроллеров.

С+
Си хорош за счет огромного числа готового кода, который можно очень легко и удобно подключать и использовать в своих нуждах. За большую читабельность алгоритмов. За возможность взять и перетащить код, например, с AVR на ARM без особых заморочек. Или с AVR на PIC. Разумеется для этого надо уметь ПРАВИЛЬНО писать на Си, выделяя все аппаратно зависимые части в HAL.

Общий расклад примерно таков, что использование высокоуровневого языка на контроллерах с обьемом памяти меньше 8 килобайт является избыточным. Тут эффективней писать все на Ассемблере. Особенно если проект подразумевает не просто мигание светодиодом.
8-16 килобайт тут уже зависит от задачи, а вот пытаться писать на ассемблере прошивку более 16 килобайт можно, но это напоминает прокладку тоннеля под Ла Маншем с помощью зубила.

В общем, знать надо и то и другое. Настоятельно тебе рекомендую начать изучать МК с ассемблера. А как только поймешь, что на асме можешь реализовать все что угодно, любой алгоритм. Когда досконально прочувствуешь работу стека, прерываний, организацию переходов и ветвлений. Когда разные трюки и хитрости, вроде игр с адресами возврата из прерываний и процедур, переходами и конечными автоматами на таблицах и всякие извраты будут вызывать лишь интерес, но никак не взрыв мозга из серии «Аааа как это работает??? Не понимаю?!!»
Вот тогда и можно изучать Си. Причем, изучать его с дебагером в руках. Не просто изучить синтаксис (там то как раз все элементарно), а понять ЧТО и КАК делает компилятор из твоего исходника. Поржать над его тупостью или наоборот поудивляться извратам искуственного интелекта. Понять как компилятор делает ветвления, как организует циклы, как идет работа с разными типами данных, как ведется оптимизация. Где ему лучше помочь, написав в ассемблерном стиле, а где не критично и можно во всю ширь использовать языковые возможности Си.

А вот начать изучение ассемблера после Си мало кому удается. Си расслабляет, становится лень и впадлу. Скомпилировалось? Работает? Ну и ладно. А то что там быдлокод, та пофигу… =)

А как же бейсик, паскаль и прочие языки? Они тоже есть на AVR?
Конечно есть, например BascomAVR или MicroPASCAL и во многих случаях там все проще и приятней. Не стоит прельщаться видимой простотой. Она же обернется тем, что потом все равно придется переходить на Си.

Дело в том, что мир микроконтроллеров далеко не ограничивается одним семейством. Постоянно появляются новые виды контроллеров, развиваются новые семейства. Ведь кроме AVR есть еще и ARM, PIC, STM8 и еще куча прекрасных контроллеров со своими плюсами.
И под каждый из этих семейств есть Си компилятор. Ведь Си это, по сути, промышленный стандарт. Он есть везде и контроллер который не имеет под него компилятора популярным у профессионалов не станет никогда.

А вот на бейсик с паскалем, обычно, всем пофигу. Если на AVR и PIC эти компиляторы и сделали, то лишь потому, что процы эти стали особо популярны у любителей и там наверняка найдется тот, кто заинтересуется и бейсиками всякими. С другим семейством контроллеров далеко не факт, что будет также радужно. Например под STM8 или Cortex M3 я видел Pascal в лучшем случае только в виде кривых студенческих поделок. Никак не тянущих на нормальный компилятор.

Такой разный Си
С Си тоже не все гладко. Тут следует избегать компиляторов придумывающих свои диалектные фишки. Например, CodeVision AVR (CVAVR) позволяет обращаться к битам порта с помощью такого кода:

1
PORTB.7 = 1; 		// Выставить бит 7 порта B в 1

PORTB.7 = 1; // Выставить бит 7 порта B в 1

Удобно? Конечно удобно! Вот только в Си так делать нельзя, стандарт языка не позволяет. И ни один другой Си компилятор такой кусок кода не примет. Т.к. по стандарту корректней будет так:

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

Приплюснутый
Некоторое время назад я считал, что С++ в программировании микроконтроллеров не место. Слишком большой overhead. C тех пор мое мнение несколько поменялось.
Мне показали очень красивый кусок кода на С++, который компилился вообще во что то феерическое. Компактней и быстрей я бы и на ассемблере не факт что написал. А уж про читабельность и конфигурируемость и говорить не приходится. Все из знакомых программистов, кто видел этот код, говорили что-то вроде «Черт, а я то думал, что я знаю С++».

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

В общем, как говорил Джон Кармак, «хороший С++ код лучше чем хороший С код. Но плохой С++ может быть намного ужасней чем плохой С код».

easyelectronics.ru

Ассемблер — это… Что такое Ассемблер?

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

Ассе́мблер (от англ. assembler — сборщик) — компьютерная программа, компилятор исходного текста программы, написанной на языке ассемблера, в программу на машинном языке.

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

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

Архитектура x86

Ассемблеры для DOS

Наиболее известными ассемблерами для операционной системы DOS являлись Borland Turbo Assembler (TASM), Microsoft Macro Assembler (MASM) и Watcom Assembler (WASM). Также в своё время был популярен простой ассемблер A86.

Windows

При появлении операционной системы Windows появилось расширение TASM, именуемое TASM 5+ (неофициальный пакет, созданный человеком с ником !tE), позволившее создавать программы для выполнения в среде Windows. Последняя известная версия TASM — 5.3, поддерживающая инструкции MMX, на данный момент включена в Turbo C++ Explorer. Но официально развитие программы полностью остановлено.

Microsoft поддерживает свой продукт под названием Microsoft Macro Assembler. Она продолжает развиваться и по сей день, последние версии включены в наборы DDK. Но версия программы, направленная на создание программ для DOS, не развивается. Кроме того, Стивен Хатчессон создал пакет для программирования на MASM под названием «MASM32».

GNU и GNU/Linux

В состав операционной системы GNU входит пакет binutils, включающий в себя ассемблер gas (GNU Assembler), использующий AT&T-синтаксис, в отличие от большинства других популярных ассемблеров, которые используют Intel-синтаксис (поддерживается с версии 2.10).

Переносимые ассемблеры

Также существует открытый проект ассемблера, версии которого доступны под различные операционные системы, и который позволяет получать объектные файлы для этих систем. Называется этот ассемблер NASM (Netwide Assembler).

Yasm — это переписанная с нуля версия NASM под лицензией BSD (с некоторыми исключениями).

flat assembler (fasm) — молодой ассемблер под модифицированной для запрета перелицензирования (в том числе под GNU GPL) BSD-лицензией. Есть версии для KolibriOS, Linux, DOS и Windows; использует Intel-синтаксис и поддерживает инструкции x86-64.

Архитектуры RISC

MCS-51

MCS-51 (Intel 8051) — классическая архитектура микроконтроллера. Для неё существует кросс-ассемблер ASM51, выпущенный корпорацией MetaLink.

Кроме того, многие фирмы — разработчики программного обеспечения, такие как IAR или Keil, представили свои варианты ассемблеров. В ряде случаев применение этих ассемблеров оказывается более эффективным благодаря удобному набору директив и наличию среды программирования, объединяющей в себе профессиональный ассемблер и язык программирования Си, отладчик и менеджер программных проектов.

AVR

На данный момент существуют 3 компилятора производства Atmel (AVRStudio 3, AVRStudio 4, AVRStudio 5 и AVRStudio 6).

В рамках проекта AVR-GCC (он же WinAVR) существует компилятор avr-as (это портированный под AVR ассемблер GNU as из GCC).

Также существует свободный минималистический компилятор avra[1].

ARM

PIC

Пример программы на языке Assembler для микроконтроллера PIC16F628A:

 
        LIST    p=16F628A
         __CONFIG 0309H 
 
STATUS  equ     0x003
TRISB   equ     0x086
PORTB   equ     0x006
RP0     equ     5
        org  0
        goto start
start:
        bsf     STATUS,RP0             
        movlw   .00      
        movwf   TRISB                    
        bcf     STATUS,RP0        
led:
        movlw   .170   
        movwf   PORTB
        goto    led
end

AVR32

MSP430

Пример программы на языке Assembler для микроконтроллера MSP430G2231 (в среде Code Composer Studio):

 
 .cdecls C,LIST,  "msp430g2231.h"
;------------------------------------------------------------------------------
            .text                           ; Program Start
;------------------------------------------------------------------------------
RESET       mov.w   #0280h,SP               ; Initialize stackpointer
StopWDT     mov.w   #WDTPW+WDTHOLD,&WDTCTL  ; Stop WDT
SetupP1     bis.b   #001h,&P1DIR            ; P1.0 output
                                            ;                                                           
Mainloop    bit.b   #010h,&P1IN             ; P1.4 hi/low?
            jc      ON                      ; jmp--> P1.4 is set
                                            ;
OFF         bic.b   #001h,&P1OUT            ; P1.0 = 0 / LED OFF
            jmp     Mainloop                ;
ON          bis.b   #001h,&P1OUT            ; P1.0 = 1 / LED ON
            jmp     Mainloop                ;
                                            ;
;------------------------------------------------------------------------------
;           Interrupt Vectors
;------------------------------------------------------------------------------
            .sect   ".reset"                ; MSP430 RESET Vector
            .short  RESET                   ;
            .end

PowerPC

Программный пакет The PowerPC Software Development Toolset от IBM включает в себя ассемблер для PowerPC.

MIPS

Архитектуры MISC

SeaForth

Существуют:

  • 8-разрядные Flash-контроллеры семейства MCS-51
  • 8-разрядные RISC-контроллеры семейства AVR (ATtiny, ATmega, classic AVR). На данный момент семейство classic AVR трансформировано в ATtiny и ATmega
  • 8-разрядные RISC-контроллеры семейства PIC (PIC10,PIC12,PIC16,PIC18)
  • 16-разрядные RISC-контроллеры семейства PIC (PIC24HJ/FJ,dsPIC30/33)
  • 32-разрядные RISC-контроллеры семейства PIC (PIC32) с архитектурой MIPS32 M4K
  • 32-разрядные RISC-контроллеры семейства AVR32 (AVR32)
  • 32-разрядные RISC-контроллеры семейства ARM Thumb высокой производительности (серия AT91)

Макроассемблер

Не следует путать с MASM.

Макроассемблер (от греч. μάκρος — большой, обширный) — макропроцессор, базовым языком которого является язык ассемблера.[2]

Ассемблирование и компилирование

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

Примечания

См. также

Литература

  • Вострикова З. П. Программирование на языке ассемблера ЕС ЭВМ. М.: Наука, 1985.
  • Галисеев Г. В. Ассемблер для Win 32. Самоучитель. — М.: Диалектика, 2007. — С. 368. — ISBN 978-5-8459-1197-1
  • Зубков С. В. Ассемблер для DOS, Windows и UNIX.
  • Кип Ирвина. Язык ассемблера для процессоров Intel = Assembly Language for Intel-Based Computers. — М.: Вильямс, 2005. — С. 912. — ISBN 0-13-091013-9
  • Калашников О. А. Ассемблер? Это просто! Учимся программировать. — БХВ-Петербург, 2011. — С. 336. — ISBN 978-5-9775-0591-8
  • Магда Ю. С. Ассемблер. Разработка и оптимизация Windows-приложений. СПб.: БХВ-Петербург, 2003.
  • Нортон П., Соухэ Д. Язык ассемблера для IBM PC. М.: Компьютер, 1992.
  • Владислав Пирогов. Ассемблер для Windows. — СПб.: БХВ-Петербург, 2002. — 896 с. — ISBN 978-5-9775-0084-5
  • Владислав Пирогов. Ассемблер и дизассемблирование. — СПб.: БХВ-Петербург, 2006. — 464 с. — ISBN 5-94157-677-3
  • Сингер М. Мини-ЭВМ PDP-11: Программирование на языке ассемблера и организация машины. М.: Мир, 1984.
  • Скэнлон Л. Персональные ЭВМ IBM PC и XT. Программирование на языке ассемблера. М.: Радио и связь, 1989.
  • Юров В., Хорошенко С. Assembler: учебный курс. — СПб.: Питер, 2000. — С. 672. — ISBN 5-314-00047-4
  • Юров В. И. Assembler: учебник для вузов / 2-е изд. СПб.: Питер, 2004.
  • Юров В. И. Assembler. Практикум: учебник для вузов / 2-е изд. СПб.: Питер, 2004.
  • Юров В. И. Assembler. Специальный справочник. СПб.: Питер, 2000.

Ссылки

dic.academic.ru

Почему Ассемблер лучше

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

MOV EAX, EBX

В машинных кодах это будет 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 стадий:

  1. Проверка синтаксиса, создание объектного файла и файла листинга
  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 даже не читайте.

skachivaem.ru

Отправить ответ

avatar
  Подписаться  
Уведомление о