Применительно к телекоммуникационным системам скремблирование повышает надежность синхронизации устройств, подключенных к линии связи (обеспечивает надежное выделение тактовой частоты непосредственно из принимаемого сигнала), и уменьшает уровень помех, излучаемых на соседние линии многожильного кабеля. Другая область применения скремблеров - защита передаваемой информации от несанкционированного доступа.
Для алгоритмов скремблирования исключительно важны скорость работы и случайный характер последовательности, чтобы его нельзя было восстановить в случае перехвата противником. Процесс скремблирования может включать в себя добавление определенных компонент к исходному сигналу либо изменение важных частей сигнала для того, чтобы усложнить восстановление вида исходного сигнала либо для придания сигналу определенных статистических свойств.
Современные системы скремблирования сильно отличаются от оригинальных скремблеров. Это сложные оцифровывающие устройства , совмещенные с устройствами шифрования. В таких системах исходный сигнал преобразуется в цифровую форму, затем данные шифруются и отправляются. Будучи совмещенными с системами асимметричного шифрования, эти «скремблеры» являются более криптостойкими, чем их ранние аналоги. Только такие системы считаются достаточно надежными для работы с важными данными.
См. также
Напишите отзыв о статье "Скремблер"
Примечания
Литература
- С. В. Кунегин,. Системы передачи информации. - М.: в/ч 33965, 1997. - 317 с.
- Конахович Г. Ф., Климчук В. П., Паук С. М. Защита информации в телекоммуникационных системах. - К.:"МК-Пресс", 2005. - 288 с.
- Крис Касперски,. Техника защиты компакт-дисков от копирования. - KPNC, 2004. - 155 с.
Ссылки
- // «Методы и средства защиты информации» (курс лекций), Беляев А. В. // ЧФ СПбГТУ
- // Кунегин С. В. Коммерческие речевые шифраторы, 2005, реферат.
- (рус.)
- // Кунегин С. В.
- // Журнал «Искусство схемотехники», Шевкопляс Б. В.
- // Yue Wu, Student Member, IEEE, Sos Agaian, Senior Member, IEEE, and Joseph P. Noonan, Life Member, IEEE.
- // Патент RU 2426254, Маллади Дурга Прасад, Монтохо Хуан.
- // Овчинников А. М.
Отрывок, характеризующий Скремблер
– Что ты сделала? – спросил Ромас.– Это не я, – виновато буркнула я.
– Ну, тогда пошли, – согласился он.
Ромас был одним из тех редких тогдашних друзей, кто не боялся моих «выходок» и не удивлялся ничему из того, что постоянно со мной происходило. Он просто мне верил. И поэтому я не должна была никогда ничего ему объяснять, что для меня было очень редким и ценным исключением. Когда мы вернулись из леса, меня тряс озноб, но я думала, что, как обычно, просто немного простудилась и решила не беспокоить маму пока не будет чего-то более серьёзного. Наутро всё прошло, и я была очень довольна тем, что это вполне подтвердило мою «версию» о простуде. Но, к сожалению, радоваться пришлось недолго…
Утром я, как обычно, пошла завтракать. Не успела я протянуть руку к чашке с молоком, как эта же тяжёлая стеклянная чашка резко двинулась в мою сторону, пролив часть молока на стол... Мне стало немножко не по себе. Я попробовала ещё – чашка двинулась опять. Тогда я подумала про хлеб... Два кусочка, лежавшие рядом, подскочили и упали на пол. Честно говоря, у меня зашевелились волосы… Не по-тому, что я испугалась. Я не боялась в то время почти ничего, но это было что-то очень уж «земное» и конкретное, оно было рядом и я абсолютно не знала, как это контролировать...
Я постаралась успокоиться, глубоко вздохнула и попробовала опять. Только на этот раз я не пыталась ничего трогать, а решила просто думать о том, чего я хочу – например, чтобы чашка оказалась в моей руке. Конечно же, этого не произошло, она опять всего лишь просто резко сдвинулась. Но я ликовала!!! Всё моё нутро просто визжало от восторга, ибо я уже поняла, что резко или нет, но это происходило всего лишь по желанию моей мысли! И это было совершенно потрясающе! Конечно же, мне сразу захотелось попробовать «новинку» на всех окружающих меня живых и неживых «объектах»...
Первая мне под руку попалась бабушка, в тот момент спокойно готовившая на кухне очередное своё кулинарное «произведение». Было очень тихо, бабушка что-то себе напевала, как вдруг тяжеленная чугунная сковорода птичкой подскочила на плите и с жутким шумом грохнулась на пол… Бабушка от неожиданности подскочила не хуже той же самой сковороды... Но, надо отдать ей должное, сразу же взяла себя в руки, и сказала:
– Перестань!
Мне стало немножечко обидно, так как, что бы не случилось, уже по привычке, всегда и во всём обвиняли меня (хотя в данный момент это, конечно, было абсолютной правдой).
– Почему ты думаешь это я? – спросила я надувшись.
– Ну, привидения у нас вроде бы пока ещё не водятся, – спокойно сказала бабушка.
Я очень любила её за эту её невозмутимость и непоколебимое спокойствие. Казалось, ничего в этом мире не могло по-настоящему «выбить её из колеи». Хотя, естественно, были вещи, которые её огорчали, удивляли или заставляли грустить, но воспринимала она всё это с удивительным спокойствием. И поэтому я всегда с ней чувствовала себя очень уютно и защищённо. Каким-то образом я вдруг почувствовала, что моя последняя «выходка» бабушку заинтересовала… Я буквально «нутром чувствовала», что она за мной наблюдает и ждёт чего-то ещё. Ну и естественно, я не заставила себя долго ждать... Через несколько секунд все «ложки и поварёшки», висевшие над плитой, с шумным грохотом полетели вниз за той же самой сковородой…
– Ну-ну… Ломать – не строить, сделала бы что-то полезное, – спокойно сказала бабушка.
Я аж задохнулась от возмущения! Ну, скажите пожалуйста, как она может относиться к этому «невероятному событию» так хладнокровно?! Ведь это такое... ТАКОЕ!!! Я даже не могла объяснить – какое, но уж точно знала, что нельзя относиться к тому, что происходило, так покойно. К сожалению, на бабушку моё возмущение не произвело ни малейшего впечатления и она опять же спокойно сказала:
– Не стоит тратить столько сил на то, что можно сделать руками. Лучше иди почитай.
Моему возмущению не было границ! Я не могла понять, почему то, что казалось мне таким удивительным, не вызывало у неё никакого восторга?! К сожалению, я тогда ещё была слишком малым ребёнком, чтобы понять, что все эти впечатляющие «внешние эффекты» по-настоящему не дают ничего, кроме тех же самых «внешних эффектов»… И суть всего этого всего лишь в одурманивании «мистикой необъяснимого» доверчивых и впечатлительных людей, коим моя бабушка, естественно не являлась... Но так как до такого понимания я тогда ещё не доросла, мне в тот момент было лишь невероятно интересно, что же такого я смогу сдвинуть ещё. По-этому, я без сожаления покинула «не понимавшую» меня бабушку и двинулась дальше в поисках нового объекта моих «экспериментов»…
В то время у нас жил папин любимец, красивый серый кот – Гришка. Я застала его сладко спящим на тёплой печке и решила, что это как раз очень хороший момент попробовать на нём своё новое «искусство». Я подумала, что было бы лучше, если бы он сидел на окне. Ничего не произошло. Тогда я сосредоточилась и подумала сильнее... Бедный Гришка с диким воплем слетел с печи и грохнулся головой о подоконник… Мне стало так его жалко и так стыдно, что я, вся кругом виноватая, кинулась его поднимать. Но у несчастного кота вся шерсть почему-то вдруг встала дыбом и он, громко мяукая, помчался от меня, будто ошпаренный кипятком.
Для меня это был шок. Я не поняла, что же произошло и почему Гришка вдруг меня невзлюбил, хотя до этого мы были очень хорошими друзьями. Я гонялась за ним почти весь день, но, к сожалению, так и не смогла выпросить себе прощения… Его странное поведение продолжалось четыре дня, а потом наше приключение, вероятнее всего, забылось и опять всё было хорошо. Но меня это заставило задуматься, так как я поняла, что, сама того не желая, теми же самыми своими необычными «способностями» иногда могу нанести кому-то и вред.
После этого случая я стала намного серьёзнее относиться ко всему, что неожиданно во мне проявлялось и «экспериментировала» уже намного осторожнее. Все последующие дни я, естественно же, просто заболела манией «двигания». Я мысленно пробовала сдвинуть всё, что только попадалось мне на глаза... и в некоторых случаях, опять же, получала весьма плачевные результаты...
Так, например, я в ужасе наблюдала, как полки аккуратно сложенных, очень дорогих, папиных книг «организованно» повалились на пол и я трясущимися руками пыталась как можно быстрее собрать всё на место, так как книги были «священным» объектом в нашем доме и перед тем, как их брать – надо было их заслужить. Но, к моему счастью, папы в тот момент дома не оказалось и, как говорится, на этот раз «пронесло»…
Другой весьма смешной и в то же время грустный случай произошёл с папиным аквариумом. Отец, сколько я его помню, всегда очень любил рыбок и мечтал в один прекрасный день соорудить дома большой аквариум (что он позднее и осуществил). Но в тот момент, за не имением лучшего, у нас просто стоял маленький круглый аквариум, который вмещал всего несколько разноцветных рыбок. И так как даже такой маленький «живой уголок» доставлял папе душевную радость, то за ним с удовольствием присматривали в доме все, включая меня.
И вот, в один «злосчастный» день, когда я просто проходила мимо, вся занятая своими «двигающими» мыслями, я нечаянно посмотрела на рыбок и пожалела, что у них, бедненьких, так мало места чтобы вольно жить… Аквариум вдруг задрожал и, к моему великому ужасу, лопнул, разливая воду по комнате. Бедные рыбки не успели опомниться, как были, с большим аппетитом, съедены нашим любимым котом, которому вдруг, прямо с неба, привалило такое неожиданное удовольствие... Мне стало по-настоящему грустно, так как я ни в коем случае не хотела огорчать папу, а уж, тем более, прерывать чью-то, даже очень маленькую, жизнь.
В тот вечер я ждала папу в совершенно разбитом состоянии – было очень обидно и стыдно так глупо оплошать. И хотя я знала, что никто не будет меня за это наказывать, на душе почему-то было очень скверно и, как говорится, в ней очень громко «скребли кошки». Я всё больше и больше понимала, что некоторые из моих «талантов» в определённых обстоятельствах могут быть весьма и весьма небезопасны. Но, к сожалению, я не знала, как можно этим управлять и поэтому мне всё больше и больше становилось тревожно за непредсказуемость некоторых моих действий и за возможные их последствия с совершенно не желаемыми мною результатами...
Но я всё ещё была лишь любопытной девятилетней девочкой и не могла долго переживать из-за трагически погибших, правда полностью по моей вине, рыбок. Я по-прежнему усердно пробовала двигать все попадающееся мне предметы и несказанно радовалась любому необычному проявлению в моей «исследовательской» практике. Так, в одно прекрасное утро во время завтрака моя молочная чашка неожиданно повисла в воздухе прямо передо мной и продолжала себе висеть, а я ни малейшего понятия не имела, как её опустить... Бабушка в тот момент находилась на кухне и я лихорадочно пыталась что-то «сообразить», чтобы не пришлось опять краснеть и объясняться, ожидая услышать полное неодобрение с её стороны. Но несчастная чашка упорно не хотела возвращаться назад. Наоборот, она вдруг плавно двинулась и, как бы дразнясь, начала описывать над столом широкие круги… И что самое смешное – мне никак не удавалось её схватить.
Бабушка вернулась в комнату и буквально застыла на пороге со своей чашкой в руке. Я конечно тут же кинулась объяснять, что «это она просто так летает… и, ведь правда же, это очень красиво?»… Короче говоря, пыталась найти любой выход из положения, только бы не показаться беспомощной. И тут мне вдруг стало очень стыдно… Я видела, что бабушка знает, что я просто-напросто не могу найти ответ на возникшую проблему и пытаюсь «замаскировать» своё незнание какими-то ненужными красивыми словами. Тогда я, возмутившись на саму себя, собрала свою «побитую» гордость в кулак и быстро выпалила:
– Ну, не знаю я, почему она летает! И не знаю, как её опустить!
Бабушка серьёзно на меня посмотрела и вдруг очень весело произнесла:
– Так пробуй! Для того тебе и дан твой ум.
У меня словно гора свалилась с плеч! Я очень не любила казаться неумёхой и уж особенно, когда это касалось моих «странных» способностей. И вот я пробовала... С утра до вечера. Пока не валилась с ног и не начинало казаться, что уже вообще не соображаю, что творю. Какой-то мудрец сказал, что к высшему разуму ведут три пути: путь размышлений – самый благородный, путь подражаний – самый лёгкий и путь опыта на своей шее – самый тяжёлый. Вот я видимо и выбирала всегда почему-то самый тяжёлый путь, так как моя бедная шея по-настоящему сильно страдала от моих, никогда не прекращающихся, бесконечных экспериментов…
Но иногда «игра стоила свеч» и мои упорные труды венчались успехом, как это наконец-то и случилось с тем же самым «двиганием»… Спустя какое-то время, любые желаемые предметы у меня двигались, летали, падали и поднимались, когда я этого желала и уже совершенно не казалось сложным этим управлять… кроме одного весьма обидно упущенного случая, который, к моему великому сожалению, произошёл в школе, чего я всегда честно пыталась избегать. Мне совершенно не нужны были лишние толки о моих «странностях» и уж особенно среди моих школьных товарищей!
Виной того обидного происшествия, видимо, было моё слишком большое расслабление, которое (зная о своих «двигательных» способностях) было совершенно непростительно допускать в подобной ситуации. Но все мы когда-то делаем большие или маленькие ошибки, и как говорится – на них же и учимся. Хотя, честно говоря, я предпочитала бы учиться на чём-нибудь другом...
Многие из нас изучали ассемблер в университете, но почти всегда это ограничивалось простыми алгоритмами под DOS. При разработке программ для Windows может возникнуть необходимость написать часть кода на ассемблер, в этой статье я хочу рассказать вам, как использовать ассемблер в ваших программах под Visual Studio 2005.
Создание проекта
В статье мы рассмотрим как вызывать ассемблер из С++ кода и обратно, передавать данные, а также использовать отладчик встроенный в Visual Studio 2005 для отладки кода на ассемблер.Для начала нам нужно создать проект. Включаем Visual Studio, выбираем File > New > Project. В Visual Studio нет языка ассемблер в окне выбора типа проекта, поэтому создаем С++ Win32 проект. В окне настроек нового проекта выбираем «Empty Project».
По умолчанию Visual Studio не распознает файлы с кодом на ассемблер. Для того чтобы включить поддержку ассемблер нам необходимо настроить в проекте условия сборки указав какой программой необходимо компилировать файлы *.asm. Для этого выбираем пункт меню «Custom Build Rules...».
В открывшемся окне мы можем указать специальные правила компиляции для различных файлов, Visual Studio 2005 уже имеет готовое правило для файлов *.asm, нам необходимо лишь включить его, установив напротив правила «Microsoft Macro Assembler» галочку.
Добавление исходного кода
Перейдем к написанию исходного кода нашего проекта. Начнем с добавления исходного кода на c++. Добавим новый файл в папку Source Files. В качестве Template выбираем C++ File и вводим желаемое имя файла, например main.cpp. Напишем функцию, которая будет считывать имя введенное пользователем, оформив это в виде функции readName() которая будет возвращать ссылку на считанное имя. Мы получим примерно следующее содержимое файла: #include
Теперь, когда мы знаем имя пользователя мы можем вывести приветствие, его будет выводить функция sayHello() которую мы напишем на ассемблер, чтобы использовать эту функцию сначала мы должны указать что она будет определена в другом файле, для этого добавим блок к main.cpp:
Extern "C" { void sayHello(); }
Этот блок говорит компилятору, что функция sayHello() будет объявлена в другом файле и будет иметь правила вызова «C». Компилятор C++ искажает имена функций так, что указание правил вызова обязательно. Кроме того мы хотим использовать функцию readName() из функции sayHello(), для этого необходимо добавить extern «C» перед определением функции readName(), это позволит вызывать эту функцию из других файлов используя правила вызова «C».
Пришло время добавить код на ассемблер, для этого добавим в Source Folder новый файл. Выбираем тип Text File (.txt) и в поле название заменяем.txt на.asm, назовем наш файл hello.asm. Объявим функцию sayHello() и укажем внешние функции, которые мы хотим использовать. Получим следующий код:
686 .MODEL FLAT, C .STACK .DATA helloFormat BYTE "Hello %s!",10,13,0 .CODE readName PROTO C printf PROTO arg1:Ptr Byte, printlist: VARARG sayHello PROC invoke readName invoke printf, ADDR helloFormat, eax ret sayHello ENDP END
Теперь мы можем запустить проект, для этого просто выбираем Debug > Start Without Debugging или нажимаем комбинацию Ctrl-F5. Если все сделано верно, вы увидите окно программы:
Немного усложним задачу, попробуем написать на ассемблер функцию принимающую параметр и возвращающую значение. Для примера напишем функцию calcSumm() которая будет принимать целое число и возвращать сумму его цифр. Изменим наш код на С++ добавив в него информацию о функции calcSumm, ввод числа и собственно вызов функции. Добавим функцию в файл hello.asm, возвращаемое значение помещается в eax, параметры объявляются после ключевого слова PROC. Все параметры можно использовать в коде процедуры, они автоматически извлекутся из стека. Также в процедурах можно использовать локальные переменные. Вы не можете использовать эти переменные вне процедуры. Они сохранены в стеке и удаляются при возврате из процедуры:
686 .MODEL FLAT, C .STACK .DATA helloFormat BYTE "Hello %s!",10,13,0 .CODE readName PROTO C printf PROTO arg1:Ptr Byte, printlist: VARARG sayHello PROC invoke readName invoke printf, ADDR helloFormat, eax ret sayHello ENDP calcSumm PROC a:DWORD xor esi, esi mov eax, a mov bx, 10 @div: xor edx, edx div bx add esi, edx cmp ax, 0 jne @div mov eax, esi ret calcSumm ENDP END
Запустив проект мы увидим следующий результат выполнения:
Отладка
Конечно в данной задаче нет ничего сложного и она вовсе не требует использования ассемблер. Более интересным будет рассмотреть, а что же нам дает Visual Studio для разработки на ассемблер. Попробуем включить режим отладки и установим точку остановки в hello.asm, запустим проект, мы увидим следующее:Окно Disassembly (Debug > Windows > Disassembly) показываем команды ассемблер для данного объектного файла. Код который мы написали на С++ показывается черным цветом. Disassembled code показывается серым после соответствующего ему кода на C++/ассемблер. Окно Disassembly позволяет отлаживать код и осуществлять stepping по нему.
Окно регистров (Debug > Windows > Registers) позволяет посмотреть значение регистров.
Окно памяти (Debug > Windows > Memory) позволяет посмотреть дамп памяти, слева мы видим шестнадцатеричные адрес, справа шеснадцатеричные значения соответствующих ячеек памяти, можно перемещаться, вводя адрес в соответствующее поле в верху окна.
Раздел 1: Регистры и параметры
1.1 Использование регистров
В создаваемых ассемблерных программах можно использовать все регистры процессора. Но чтобы предотвратить путаницу с функциями С и С++, необходимо восстанавливать bp, cs, sp и ss, которые они имели до запуска созданной подпрограммы. Тогда можно быть совершенно уверенным, что обращение к другим функциям не изменит эти регистры. Также нельзя забывать, что С использует регистры si и di для регистровых переменных, поэтому при использовании встроенного ассемблера замедляется общая работа программы.
К регистрам ax, bx, cx, dx и es можно обращаться свободно и не нужно резервировать их значения до окончания подпрограммы. Эта свобода касается и других функций, поэтому надо помнить, что эти регистры изменяться, если вызываются функции С и С++ из ассемблерных подпрограмм.
1.2 Ассемблерные операторы Inline
Ассемблерные операторы inline начинаются словом asm, за которым следует инструкция и ее операнды. Например, чтобы синхронизировать программу с внешним сигналом прерывания, можно написать:
/* ожидание прерывания*/
printf(“Прерывание получено\n”)
Когда ранние версии Turbo C компилируют программу со встроенными командами asm, компилятор сперва создает ассемблерный текст для всей программы, вставляя в текст наши ассемблерные инструкции вместе с откомпилированным кодом для остальных операторов С. Затем компилятор вызывает Turbo Assembler и Linker (компоновщик), чтобы провести ассемблирование и подключить программу к конечному файлу кода. Более поздние версии Turbo и Borland C++ могут компилировать операторы asm без вызова TASM. Полный синтаксис asm:
asm[метка] мнемоника/директива операнды [;]
Точки с запятыми в конце строк asm и комментарии С, расположенные между /*и*/ удаляются из текста перед ассемблированием, поэтому их можно опускать в тексте программы.
1.3 Размещение данных и операторов в тексте программы
Каждая строка текста программы С и С++ находится либо внутри, либо снаружи функции, и операторы asm могут вставляться как в одном, так и в другом месте. Конкретное положение оператора asm влияет на то, куда ассемблируется код или директива. Если оператор asm появляется снаружи функции, то он ассемблируется в сегмент данных программы, если внутри функции - в кодовый сегмент. Обычно, чтобы создать переменные, операторы asm вставляются снаружи функций; для создания кода их следует вставлять внутрь функций. Например:
asm shl , 1/*умножение count на 4*/
asm shl , 1
Переменная count объявляется в сегменте данных программы (относительно ds). Операторы внутри функции main умножают count на 4, используя вместо mul быстрые инструкции сдвига shl. Если объявлять переменные внутри функции, данные ассемблируются в кодовый сегмент, требуя особого обхождения:
asm jmp OverThere
asm shl , 1 /* умножение count на 4*/
asm shl , 1
Поскольку теперь переменная count находится в кодовом сегменте, требуется инструкция jmp, чтобы избежать случайного восприятия значения count в качестве машинного кода и его исполнения.
Раздел 2: Особенности данных
2.1 Разделение данных
Inline операторы asm имеют свободный доступ к переменным и структурам С и C++ - одно из самых привлекательных преимуществ метода inline по сравнению с подходом посредством внешних модулей. Самое интересное в типах данных ассемблера и С++, что dq может использоваться для создания инициализированных переменных двойной длины с плавающей точкой в языке ассемблера, но в Turbo Assembler отсутствуют директивы для непосредственного создания переменных с плавающей точкой.
В операторах asm можно ссылаться на переменные типов С++. Например:
unsigned char initial
asm mov ah, 2 /* Пересылка символа в ДОС */
asm int 21h /* Стандартная выходная функция */
Беззнаковая символьная переменная initial загружается оператором asm в dl. Так как и dl, и беззнаковые символьные данные имеют длину один байт, нет необходимости в ссылке использовать определитель Byte, хотя его применение и не будет ошибкой:
asm mov dl,
2.2 Объявление ассемблерных данных
Можно объявить переменные для использования только ассемблерными операторами. Например, чтобы создать 16-битовое слово с именем TwoBytes и загрузить значение переменной в сх, можно написать:
asm TwoBytes db 1, 2
asm mov cx,
Переменная TwoBytes объявляется в сегменте данных программы (снаружи функции), с использованием директивы db, чтобы хранить в памяти 2 байта (1 и 2). Оператор ассемблера затем загружает TwoBytes в сх. Определитель Wordptr необходим для ссылки на TwoBytes как на 16-битовое слово.
Поскольку TwoBytes объявляется в операторе asm, на эту переменную нельзя ссылаться в тексте программы С или C++. Поэтому, если только не требуются отдельные переменные для ассемблерных инструкций, следует объявлять их обычным образом и ссылаться на них из ассемблерного модуля.
2.3 Разделение кода
Ассемблерные операторы inline могут вызывать функции С и C++, а операторы С и C++ обращаться к функциям, написанным полностью на ассемблере. Вся эта взаимосвязь будет хорошо рассмотрена в данном курсовом проекте.
Раздел 3: Вызов ассемблерных функций из С
3.1 Символы подчеркивания
Как показывает практика, все символы PUBLIC и EXTERN должны начинаться символами подчеркивания. Это необходимо делать только в ассемблерном модуле (но не в исходной про грамме С или C++), поскольку компилятор добавляет подчеркивание ко всем глобальным символам, если только не используется опция -u для компиляции программ. (Не стоит применять эту опцию, если только не надо также перекомпилировать всю используемую при выполнении С библиотеку, в которой предполагается, что все глобальные символы начинаются символом подчеркивания.) Если во время компоновки выходит сообщение об ошибке "undefined symbol" (неопределенный символ), то причиной может оказаться отсутствие подчеркивания в ассемблерном модуле.
3.2 Использование дальних данных
Если объявляются переменные в дальнем сегменте данных после ключевого слова FARDATA, то необходимо подготовить сегментный регистр к размещению переменных в памяти. Прежде всего, вслед за директивой FARDATA необходимо объявить данные:
OuterLimits dw ?
Затем, в кодовом сегменте, следует перед использованием переменной подготовить сегментный регистр. Одним из возможных подходов является использование оператора SEG для загрузки адреса дальнего сегмента данных:
mov ax, SEG_OuterLimits;Адресует дальний сегмент;данных
mov es, ах;посредством es
mov , dx ;Резервируется dx для пере;менной
Можно также использовать заранее определенный символ @fardata:
mov ах, @fardata
mov , dx
3.3 Вызов ассемблерных функций из С
Чаще всего asm код оформляют в виде отдельных asm функций, которые потом соединяют на этапе загрузки. Ассемблерный код должен поддерживать стиль языка С для вызова функций, которые включают передачу параметров, возврат значений и правила сохранения регистров, которые требуются для С++ функций.
Компилятор и загрузчик должны работать совместно для обеспечения вызовов между модулями. Процесс называется исключением или ломкой имен. Предусматривает наличие информации о типе аргумента. Ломка имени изменяет имя функции, показывая, что за аргумент принимает функция. Когда мы конструируем на языке С++, то ломка имен происходит автоматически.
Когда же пишется модуль на asm, который должен быть подсоединен к модулю на языке С++, необходимо позаботиться о том, чтобы asm модуль содержал ломку имен (знак подчеркивания). Это можно сделать путем написания фиктивной функции на С++ и компилировать его в asm код. И ассемблерный файл, который будет сгенерирован компилятором С++, будет содержать ломку имен, которые мы можем потом использовать при написании asm функции:
@ имя класса @ исходное имя функции $g описание типов
@ - связующий символ
$ - конец исходного имени функции
g - начало описания типов параметров
void test(int...) {}
void test(int, int) {}
void test(float, double) {}
Что будет в ассемблере?
1. @ test $ gv proc near
@ test $ gv endp
2. @ test $ gi proc near
@ test $ gi endp
3. @ test $ gii proc near
@ test $ gii endp
4. @ test $ gfd proc near
@ test $ gfd endp
BC++ разрешает использование неискаженных имен asm функций, определяя стандартные имена С функций в С программах. Для этого в программе определяется внешний С блок:
int add(int *a, int b);
________________
Add proc ...и т.д.
Определение или декларирование asm функции во внешнем С блоке избавляет программиста от необходимости определения действительного имени ассемблерной функции и повышает наглядность.
С++ передает параметры функции через стек. Перед тем как вызвать функцию С++ помещает параметры в стек, начиная с последнего.
3.4 Ассемблирование и компоновка внешних модулей
Существует несколько методов ассемблирования, компиляции и компоновки отдельных модулей (и аналогичных многофайловых программ) для создания конечной.ЕХЕ программы. Проще всего предоставить проделать все это Turbo С:
tcc cfillstr cfill.asm/*первый модуль - cfillstr.c*/
Если используется Borland C++, надо ввести следующую команду (заменить bсс на tсс для Turbo C++):
bcc cfillstr.с cfill.asm
В любом случае команда сперва компилирует CFILLSTR.C в CFILLSTR.OBJ. Затем, распознав расширение имени файла.ASM как имя ассемблерного модуля, компилятор вызывает Turbo Assembler, чтобы ассемблировать CFILL.ASM в CFILL.OBJ. И наконец, компилятор вызывает Turbo Linker для объединения модулей с объектными кодами в CFILLSTR.EXE. Если компиляции и ассемблированию подлежит небольшое количество модулей, этот одношаговый метод наиболее прост для использования.
Если у имеется большое количество модулей, можно сэкономить время, осуществляя ассемблирование и компоновку раздельно. Первым шагом следует ассемблировать все.ASM файлы. Поскольку пример flllsrting обладает только одним таким файлом, все можно проделать с помощью единственной команды
tasm /ml cfill.asm
Опция /ml включает различение строчных и прописных символов, чтобы к примеру слова UpAndDown и upanddown рассматривались как различные - как это принято в программах С и C++. (Turbo Assembler обычно не обращает внимания на то, в каком регистре набраны символы, поэтому опция /ml необходима во избежание ошибок при компоновке.) После ассемблирования всех внешних модулей откомпилировать основную программу. Опять же, поскольку в этом примере имеется только один файл.С, для этого необходима только одна команда
tcc -с cfillstr.c
Если используется Borland C++, надо применить следующую команду (заменить bсс на tсс для Turbo C++):
bсс -с cfillstr.c
Опция -с означает "только компилировать", вызывая создание CFILLSTR.OBJ, но не компоновку программы в законченный кодовый файл. Для включения всех модулей необходимо выполнить этот шаг самим, вызывая Turbo Linker для объединения файлов с объектным кодом с соответствующими библиотечными подпрограммами для создания CFILLSTR.EXE. Существует два метода компоновки. Сначала рассмотрим более сложный метод:
t1ink с:\tc\lib\c0s cfillstr cfill, cfillstr, с:\tc\lib\cs
При использовании Borland C++4 можно применить следующую команду:
tlink с:\bc4\lib\c0s cfillstr cfill, cfillstr, с:\bc4\lib\cs
Первый член после tlink специфицирует файл объектного кода в директории \LIB для соответствующей модели памяти, в данном случае - COS.OBJ. Второй и третий члены перечисляют подлежащие компоновке файлы с объектным кодом.OBJ - они могут быть перечислены в любом порядке. Запятая отделяет список файлов.OBJ от имени, которое должно использоваться для конечного файла, в данном случае - CFILLSTR-EXE. Две запятые, следующие за этим, показывают место необязательного файла карты (*.map), не создающегося в данном примере. И наконец, специфицируется рабочая библиотека - также в каталоге \LIB.
Имена файла с объектным кодом COS и библиотечным файлом CS должны соответствовать модели памяти, используемой программой.
Упрощенный (но не очень быстрый) метод компоновки отдельных модулей состоит в использовании компилятора в качестве "первой части" Turbo Linker. Другими словами, вставляя различные команды компиляции, можно пропустить компиляцию и перейти прямо к компоновке. Это дает возможность избежать необходимости специфицировать имена рабочих библиотечных файлов и, следовательно, упрощает команду компоновки. Например, для ассемблирования, компиляции и компоновки CFILLSTR этим методом требуются три команды:
tasm /ml cfill.asm
tee -с cfillstr.c
tee -ms cfillstr.obj cfill.obj
Для Borland C++ надо ввести следующие команды (заменить bсс на tсс для Turbo C++):
tasm /ml cfill.asm
bee -с cfillstr.с
bee -ms cfillstr.obj cfill.obj
Первые две команды - те же, что были описаны выше. Третья вызывает компилятор во второй раз, используя опцию -ms для определения модели памяти, в данном случае small (малая). Вслед за опцией модели памяти идут файлы с объектным кодом, подлежащие компоновке. Хотя приходится включать расширение имен файлов.OBJ в перечисление каждого файла, этот не очень длинный метод компоновки упрощает большую часть черновой работы по непосредственному запуску Turbo Linker. Для того, чтобы узнать, какую опцию надо писать при TCC, можно воспользоваться следующей таблицей.
Таблица 3.1: Имена файлов рабочей библиотеки
Раздел 4: Вызов функций С из языка ассемблера
4.1 Вызов С и С++ из ассемблера
До сих пор рассматривалось, как разделить переменные между С или C++ и ассемблером, а также как вызывать внешние ассемблерные функции из программ, написанных на С или C++. Теперь подойдем к этому с другой стороны, т.е. к вызову функций С или C++ из ассемблерного модуля - это также возможно, но требует большего внимания.
Если функция не обладает параметрами, процесс достаточно прост. Надо объявить функцию С или C++ в директиве EXTRN и воспользоваться инструкцией call:
EXTRN _cfuntion:proc
Здесь предполагается, что функция, названная _cfunction, существует в программе, подлежащей компоновке вместе с ассемблерным модулем.
Если функции требуются параметры, процесс усложняется. Простые параметры, такие как символы и целые числа часто передаются непосредственно в стек. Сложные переменные, такие как строки, структуры и множества, передаются посредством ссылок, т.е. по адресу. Кроме того, многие функции возвращают результат в специфичные регистры. При вызове функций С или C++ из языка ассемблера надо самим позаботиться о подобных нюансах.
Сперва рассмотрим простейший случай вызова функции с одним целочисленным параметром:
void showscore(int thescore)
printf(“\nThe score is: %d\n, thescore);
Чтобы вызвать функцию showscore из ассемблерного модуля, передавая значение переменной типа слова в качестве thescore, можно написать:
EXTRN showscore: proc
mov ах, 76 ; Присвоение score регистру
push ах; Передача параметра в стек
call _showscore ; Вызов функции С
pop ах; Фиксация стека
Прежде всего, значение score присваивается ах (любой другой регистр точно так же подойдет для этого), а затем выталкивается в стек перед вызовом showscore. После возврата из функции слово выталкивается из стека. Это необходимо потому, что в С и C++ вызывающая программа удаляет параметры из стека. Если имеется несколько параметров, может быть, будет лучше просто прибавить их общее число байтов к sp. Например, чтобы вызвать функцию, которая оперирует четырьмя 16-битовыми параметрами, можно воспользоваться следующими командами:
push ; Выталкивание четырех переменных
push ; (не показанных) в стек
call _aCfunction ; Вызов функции С
add sp, 8 ; Удаление параметров
Выталкивание нескольких параметров осуществляется в порядке, обратном тому, в каком они объявляются функции С или C++. Исходя из предположения, что функция fillstring определена как
void fillstring(unsigned char far *thestring, int stringLength, char fillchar);
для вызова этой функции из языка ассемблера и заполнения строковой переменной пробелами требуются несколько шагов. Сперва ассемблерный модуль объявляется строковой переменной:
Astring db 80 dup (0)
Затем этот же модуль объявляет fillstring в директиве EXTRN и вызывает функцию для заполнения строчной переменной пробелами:
EXTRN _fillstring: ргос
xor ah, ah ; Обнуление ст. половины ах
mov al,’ ‘ ; Присвоение пробела а1
push ах; Проталкивание пар-ра fillchar
mov ах, 79 ; Присвоение длины строки ах
push ах;Проталкивание пар-ра дл. строки
push ds ;Проталкивание сег-та адреса строки
mov ах, offset _astring ;Присвоение смещения адреса ах
push ах;Проталкивание смещ. адреса строки
call _fillstring ; Вызов функции
add sp, 8 ; Удаление параметров из стека
Каждый из параметров - заполняющий символ, длина строки и 32-битовый указатель строковой переменной- проталкивается в стек в порядке, обратном перечисленному в определении функции. Применительно к указателю - сегмент адреса проталкивается перед смещением. После обращения к _fillstring к указателю стека sp добавляются 8 байт, удаляя параметры из стека.
Несмотря на то что в этом примере функция _fillstring в действительности написана на языке ассемблера, вызовы функций С и C++ ничем не отличаются.
4.2 Локальные переменные
В дополнение к переменным, объявленным в сегменте данных либо общим с программой С и С++, можно использовать локальные переменные, помещенные в стек создаваемых ассемблерных модулей. Локальные переменные существуют только во время выполнения функции. Стековая часть создается для переменных при запуске функции, а затем очищается перед ее завершением. Таким образом, другие функции могут использовать эти же области памяти для своих собственных локальных переменных, снижая общий объем памяти, требуемой для всей программы. Например:
printer("%d", i);
Целая переменная i помещается в памяти в стек при запуске функции countup и существует только до тех пор пока выполняется эта функция. В ассемблерном модуле можно проделать тоже самое с помощью директивы LOCAL. Вот пример законченной функции:
PROС _cfunction NEAR
LOCAL i:Word=stacksize
sub sp, stacksize
;--Код, использующий локальную переменную [i]
ret ; Возврат в точку вызова
Директива LOCAL в этом примере подготавливает переменную i типа Word (слово). Указание = stacksize назначает общее число байтов, занимаемое всеми локальными переменными - в данном случае 2 байта. Это значение вычитается из sp после подготовки адресации переменных в стек. Затем, для ссылки на i, используются такие инструкции, как mov, inc и crop. Благодаря директиве LOCAL ссылки типа [i] переводятся следующим образом:
и т.д. При использовании LOCAL нет необходимости вычислять отрицательные смещения относительно bp, чтобы определить местоположение переменных в стеке, -достаточно воспользоваться именами переменных.
Поскольку bp не изменяется во время выполнения этой функции, можно восстановить sp по средством bp, удаляя область локальной переменной из стека, или прибавить stacksize к sp с помощью команды
add sp, stacksize
Подходят оба метода, но восстановление sp посредством bp - быстрее. Можно также объявить несколько локальных переменных операторами, подобными следующему:
LOCAL i:Word; j:Word; c:Byte=stacksize
Теперь, после вычитания stacksize из указателя стека для резервирования области в стеке, можно использовать три локальные переменные - i, j и с. (Необходимо всегда делать LOCAL, что упрощает адресацию локальных переменных, это не создает область для переменных в памяти.)
4.3 Передача аргументов
Совместное использование C++ и ассемблера становится более сложным, когда к функциям добавляются аргументы. Приходится очень внимательно программировать, обращаясь к функциям из различных модулей и выбирая аргументы из стека. Но следующая директива берет на себя задачу сама произвести ломку имен и занести их в стек:
ARG c_offset:byte, k_pffset:word
Аргументы, перечисленные таким образом, не являются объектами данных; они смещаются в стеке относительно регистра bр. Использование ARG подобным образом позволяет ассемблеру вычислить смещения вместо нас - но мы должны специфицировать правильные типы данных. Символьная переменная в C++ является байтом в ассемблере, целая в C++ - эквивалентом ассемблерного слова и т.д.
Обратный процесс - передача аргументов из языка ассемблера в C++ - требует иной тактики:
proc _asmfunction C c_arg:byte, k_arg:word
“C” после имени функции указывает, что аргументы приводятся для языка С (т.е. они выталкиваются в стек в порядке справа налево). Остальное также, как и для директивы ARG.
В результате Turbo Assembler автоматически пишет инструкции для сохранения, инициализации и восстановления bp. При использовании этой альтернативной методики не приходится проводить точные операции по выталкиванию bp. За исключением этого отличия, в остальном процесс программирования остается тем же самым.
Раздел 5: Курсовая программа
5.1 Постановка задачи
В курсовой требовалось написать программу, вычисляющую значение многочлена n-ой степени по вектору размерности n коэффициентов многочлена и по некой переменной х, задаваемые пользователем. Необходимо было реализовать многомодульную связь (два модуля: на С и на ассемблере), а также выразить наглядно связь ассемблера с языком С.
5.2 Блоксхема программы
Программа реализовывалась по следующей блоксхеме:
Очевидно, что была реализована связь в обе стороны.
5.3 Модуль на С++
/*Это часть на С++, есть еще на ассемблере*/
extern "C" void vvod();/*ассемблерная процедура*/
extern "C" void mnogochlen(int *vec);/*функция в С*/
extern int *vect;/*вектор коэффициентов, объявленный*/
/*внешней переменной*/
vvod();/*Вызов ассемблерной процедуры*/
extern "C"/*Начало функции на С*/
void mnogochlen(int *vect)
for(i=m;i>=0;i--)/*Вычисление ответа*/
summa=summa+vect[i]*fact;
5.4 Модуль на ассемблере
so db "введите вектор коэффициентов","$"
extrn _m:word, _vec:word; Внешние аргументы
extrn _mnogochlen:proc; функция из С++
public _vvod; местная процедура
push di;Сохранение значений этих регистров
push si;необходимо, т.к. они используются С++
MOV ah,09h ;начало ввода вектора перестановок
MOV dx,offset so
exit: MOV [_vec],di
ADD si,2;Данные типа слово, прибавляем 2
pop di;извлечение сохраненных регистров
pop si;перед возвратом в С++
MOV ax,offset [_vec]
call _mnogochlen; Вызов функции С++
ADD sp,4;Удаление элементов из стека
POP bp;адрес возврата
5.5 Анализ проведенной работы
При работе в многомодульном режиме главные трудности возникают в использовании регистров. Из-за несохранения системных регистров, используемых С++, программа может просто “повиснуть”. Также следовало сделат выбор - какой модуль сделать главным. Но практика показывает, что следует производить вызов языков низкого уровня из высокого, а не наоборот. В общем, все трудности были преодолены и программа появилась в свет.
Введение
В идеальном мире программирования компиляторы с языков высокого уровня должны генерировать самый быстрый, самый компактный и наилучший машинный код для любой программы. Если бы это было невозможно, то программирование много бы потеряло от этого, и наверняка не писался бы этот курсовик. Но это невозможно. Несмотря на множество усовершенствований при разработке компиляторов, ни один язык высокого уровня пока не в состоянии продублировать краткий, быстрый и изящный код, написанный опытным специалистом по ассемблеру.
В чем же дело? А в том, что компиляторы обобщают решаемые ими задачи. В C++ существует только один способ написания цикла FOR. В то же время с помощью ассемблера этот цикл можно организовать с помощью ассемблера этот цикл можно организовать десятками способов. Чтобы компилятор выбирал идеально подходящие в каждой конкретной ситуации методы реализации алгоритма и при этом учитывая их влияние на остальные части программы - он должен обладать интеллектом гения, вкусом художника и интуицией предсказателя. Сегодняшние компиляторы с языков высокого уровня достаточно сообразительны, но не до такой степени.
Среди всех существующих компиляторов С наиболее приблизился к идеалу С++. Порождаемый им машинный код работает достаточно быстро, занимает на диске немного места и в большинстве случаев может использоваться без каких-либо модификаций. Однако несмотря на все достоинства С++, все равно остается место для улучшений, благодаря чему даже небольшие участки программы, переписанные на ассемблере, могут значительно повысить скорость работы программы и уменьшить размер исполняемого файла. Кроме того, добавив ассемблер к С++, можно облегчить доступ к регистрам аппаратных средств и решение других задач низкого уровня, таких как запись символов непосредственно в видеопамять.
Во многих случаях единственный способ для прибавления программе скорости - немного дополнить совершенный “С”, используя один из двух методов:
Использование встроенных операторов (операторов Inline)
Использование внешних функций
Операторы Inline вставляют язык ассемблера непосредственно в исходную программу на С и С++. Эта методика быстрая и простая, но имеет несколько недостатков, которые поясняться ниже. Внешние функции, хотя их и трудно использовать, чем операторы Inline, имеют то преимущество, что позволяют наиболее полно использовать все возможности Turbo Assembler.
Список использованной литературы
1. Том Сван “Освоение Turbo Assembler”, Диалектика, Киев, 1996 г.
2. Березин Б.И., Березин С.Б. “Начальный курс С и С++”, Диалог МИФИ, Москва, 1996 г.
3. Лекции Комлевой Нины Викторовны по предмету “Языки программирования и методы трансляции”
МОСКОВСКИЙ ГОСУДАРСТВЕННЫЙ УНИВЕРСИТЕТ ЭКОНОМИКИ, СТАТИСТИКИ И ИНФОРМАТИКИ
КАФЕДРА МО ЭВМ
КУРСОВАЯ РАБОТА
на тему: “Взаимосвязь языков С и ассемблера”
Студент: Аплемах А.В.
Группа: ДП-202
Руководитель проекта:
Комлева Н.В.
Защищена “___” Мая 1997 г.
В статье будут рассмотрены основы языка ассемблер применительно к архитектуре win32. Он представляет собой символическую запись машинных кодов. В любой электронно-вычислительной машине самым низким уровнем является аппаратный. Здесь управление процессами происходит командами или инструкциями на машинном языке. Именно в этой области ассемблеру предназначено работать.
Программирование на ассемблер
Написание программы на ассемблере - крайне трудный и затратный процесс. Чтобы создать эффективный алгоритм, необходимо глубокое понимание работы ЭВМ, знание деталей команд, а также повышенное внимание и аккуратность. Эффективность - это критический параметр для программирования на ассемблер.
Главное преимущество языка ассемблер в том, что он позволяет создавать краткие и быстрые программы. Поэтому используется, как правило, для решения узкоспециализированных задач. Необходим код, работающий эффективно с аппаратными компонентами, или нужна программа, требовательная к памяти или времени выполнения.
Регистры
Регистрами в языке ассемблер называют ячейки памяти, расположенные непосредственно на кристалле с АЛУ (процессор). Особенностью этого типа памяти является скорость обращения к ней, которая значительно быстрее оперативной памяти ЭВМ. Она также называется сверхбыстрой оперативной памятью (СОЗУ или SRAM).
Существуют следующие виды регистров:
- Регистры общего назначения (РОН).
- Флаги.
- Указатель команд.
- Регистры сегментов.
Есть 8 регистров общего назначения, каждый размером в 32 бита.
Доступ к регистрам EAX, ECX, EDX, EBX может осуществляться в 32-битовом режиме, 16-битовом - AX, BX, CX, DX, а также 8-битовом - AH и AL, BH и BL и т. д.
Буква "E" в названиях регистров означает Extended (расширенный). Сами имена же связаны с их названиями на английском:
- Accumulator register (AX) - для арифметических операций.
- Counter register (CX) - для сдвигов и циклов.
- Data register (DX) - для арифметических операций и операций ввода/вывода.
- Base register (BX) - для указателя на данные.
- Stack Pointer register (SP) - для указателя вершины стека.
- Stack Base Pointer register (BP) - для индикатора основания стека.
- Source Index register (SI) - для указателя отправителя (источника).
- Destination Index register (DI) - для получателя.
Специализация РОН языка ассемблер является условной. Их можно использовать в любых операциях. Однако некоторые команды способны применять только определенные регистры. Например, команды цикла используют ESX для хранения значения счетчика.
Регистр флагов. Под этим подразумевается байт, который может принимать значения 0 и 1. Совокупность всех флагов (их порядка 30) показывают состояние процессора. Примеры флагов: Carry Flag (CF) - Флаг переноса, Overflow Flag (OF) - переполнения, Nested Flag (NT) - флаг вложенности задач и многие другие. Флаги делятся на 3 группы: состояние, управление и системные.
Указатель команд (EIP - Instruction Pointer). Данный регистр содержит адрес инструкции, которая должна быть выполнена следующей, если нет иных условий.
Регистры сегментов (CS, DS, SS, ES, FS, GS). Их наличие в ассемблере продиктовано особым управлением оперативной памятью, чтобы увеличить ее использование в программах. Благодаря им можно было управлять памятью размером до 4 Гб. В архитектуре Win32 необходимость в сегментах отпала, но названия регистров сохранились и используются по-другому.
Стек
Это область памяти, выделенная для работы процедур. Особенность стека заключается в том, что последние данные, записанные в него, доступны для чтения первыми. Или иными словами: первые записи стека извлекаются последними. Представить этот процесс себе можно в качестве башни из шашек. Чтобы достать шашку (нижнюю шашку в основание башни или любую в середине) нужно сначала снять все, которые лежат сверху. И, соответственно, последняя положенная на башню шашка, при разборе башни снимается первой. Такой принцип организации памяти и работы с ней продиктован ее экономией. Стек постоянно очищается и в каждый момент времени одна процедура использует его.
Идентификаторы, целые числа, символы, комментарии, эквивалентность
Идентификатор в языке программирования ассемблер имеет такой же смысл, как и в любом другом. Допускается использование латинских букв, цифр и символов "_", ".", "?", "@", "$". При этом прописные и строчные буквы эквивалентны, а точка может быть только первым символом идентификатора.
Целые числа в ассемблере можно указывать в системах отсчета с основаниями 2, 8, 10 и 16. Любая другая запись чисел будет рассматриваться компилятором ассемблера в качестве идентификатора.
В записи символьных данных допускается использовать как апострофы, так и кавычки. Если в символьной строке требуется указать один из них, то правила следующие:
- в строке, заключенной в апострофы, кавычки указываются один раз, апостроф - дважды: "can""t", " he said "to be or not to be" ";
- для строки, заключенной в кавычки, правило обратное: дублируются кавычки, апострофы указываются как есть: "couldn"t", " My favourite bar is ""Black Cat"" ".
Для указания комментирования в языке ассемблер используется символ точка с запятой - ";". Допустимо использовать комментарии как в начале строк, так и после команды. Заканчивается комментарий переводом строки.
Директива эквивалентности используется схожим образом тому, как в других языках указывают константные выражения. Эквивалентность указывается следующим способом:
Таким образом в программе все вхождения будут заменяться на, на месте которого допустимо указывать целое число, адрес, строку или другое имя. Директива EQU похожа по своей работе на #define в языке С++.
Директивы данных
Языки высокого уровня (C++, Pascal) являются типизированными. То есть, в них используются данные, имеющие определенный тип, имеются функции их обработки и т. д. В языке программирования ассемблер подобного нет. Существует всего 5 директив для определения данных:
- DB - Byte: выделить 1 байт под переменную.
- DW - Word: выделить 2 байта.
- DD - Double word: выделить 4 байта.
- DQ - Quad word: выделить 8 байтов.
- DT - Ten bytes: выделить 10 байтов под переменную.
Буква D означает Define.
Любая директива может быть использована для объявления любых данных и массивов. Однако для строк рекомендуется использовать DB.
Синтаксис:
В качестве операнда допустимо использовать числа, символы и знак вопрос - "?", обозначающий переменную без инициализации. Рассмотрим примеры:
Real1 DD 12.34 char db "c" ar2 db "123456",0 ; массив из 7 байт num1 db 11001001b ; двоичное число num2 dw 7777o ; восьмеричное число num3 dd -890d ; десятичное число num4 dd 0beah ; шестнадцатеричное число var1 dd ? ; переменная без начального значения ar3 dd 50 dup (0) ; массив из 50 инициализированных эл-тов ar4 dq 5 dup (0, 1, 1.25) ; массив из 15 эл-тов, инициализированный повторами 0, 1 и 1.25
