Взаимосвязь языков C и ассемблера
Раздел 1: Регистры и параметры
1.1 Использование регистров
В создаваемых ассемблерных программах можно использовать все регистры процессора. Но чтобы предотвратить путаницу с функциями С и С++, необходимо восстанавливать bp, cs, sp и ss, которые они имели до запуска созданной подпрограммы. Тогда можно быть совершенно уверенным, что обращение к другим функциям не изменит эти регистры. Также нельзя забывать, что С использует регистры si и di для регистровых переменных, поэтому при использовании встроенного ассемблера замедляется общая работа программы.
К регистрам ax, bx, cx, dx и es можно обращаться свободно и не нужно резервировать их значения до окончания подпрограммы. Эта свобода касается и других функций, поэтому надо помнить, что эти регистры изменяться, если вызываются функции С и С++ из ассемблерных подпрограмм.
1.2 Ассемблерные операторы Inline
Ассемблерные операторы inline начинаются словом asm, за которым следует инструкция и ее операнды. Например, чтобы синхронизировать программу с внешним сигналом прерывания, можно написать:
/* ожидание прерывания*/
asm sti
asm hlt
printf(“Прерывание получено\n”)
Когда ранние версии Turbo C компилируют программу со встроенными командами asm, компилятор сперва создает ассемблерный текст для всей программы, вставляя в текст наши ассемблерные инструкции вместе с откомпилированным кодом для остальных операторов С. Затем компилятор вызывает Turbo Assembler и Linker (компоновщик), чтобы провести ассемблирование и подключить программу к конечному файлу кода. Более поздние версии Turbo и Borland C++ могут компилировать операторы asm без вызова TASM. Полный синтаксис asm:
asm[метка] мнемоника/директива операнды [;] [/*С комментарий*/]
Точки с запятыми в конце строк asm и комментарии С, расположенные между /*и*/ удаляются из текста перед ассемблированием, поэтому их можно опускать в тексте программы.
1.3 Размещение данных и операторов в тексте программы
Каждая строка текста программы С и С++ находится либо внутри, либо снаружи функции, и операторы asm могут вставляться как в одном, так и в другом месте. Конкретное положение оператора asm влияет на то, куда ассемблируется код или директива. Если оператор asm появляется снаружи функции, то он ассемблируется в сегмент данных программы, если внутри функции - в кодовый сегмент. Обычно, чтобы создать переменные, операторы asm вставляются снаружи функций; для создания кода их следует вставлять внутрь функций. Например:
asm count db ?
int main()
{
asm shl [count], 1/*умножение count на 4*/
asm shl [count], 1
return 0;
}
Переменная count объявляется в сегменте данных программы (относительно ds). Операторы внутри функции main умножают count на 4, используя вместо mul быстрые инструкции сдвига shl. Если объявлять переменные внутри функции, данные ассемблируются в кодовый сегмент, требуя особого обхождения:
int main()
{
asm jmp OverThere
asm count db ?
OverThere:
asm shl [count], 1 /* умножение count на 4*/
asm shl [count], 1
return 0;
}
Поскольку теперь переменная count находится в кодовом сегменте, требуется инструкция jmp, чтобы избежать случайного восприятия значения count в качестве машинного кода и его исполнения.
Раздел 2: Особенности данных
2.1 Разделение данных
Inline операторы asm имеют свободный доступ к переменным и структурам С и C++ - одно из самых привлекательных преимуществ метода inline по сравнению с подходом посредством внешних модулей. Самое интересное в типах данных ассемблера и С++, что dq может использоваться для создания инициализированных переменных двойной длины с плавающей точкой в языке ассемблера, но в Turbo Assembler отсутствуют директивы для непосредственного создания переменных с плавающей точкой.
В операторах asm можно ссылаться на переменные типов С++. Например:
unsigned char initial
initial = 'T'
asm mov dl, [initial] /*Загрузка символа в dl*/
asm mov ah, 2 /* Пересылка символа в ДОС */
asm int 21h /* Стандартная выходная функция */
Беззнаковая символьная переменная initial загружается оператором asm в dl. Так как и dl, и беззнаковые символьные данные имеют длину один байт, нет необходимости в ссылке использовать определитель Byte, хотя его применение и не будет ошибкой:
asm mov dl, [Byte ptr initial]
2.2 Объявление ассемблерных данных
Можно объявить переменные для использования только ассемблерными операторами. Например, чтобы создать 16-битовое слово с именем TwoBytes и загрузить значение переменной в сх, можно написать:
asm TwoBytes db 1, 2
int main()
{
asm mov cx, [Word ptr TwoBytes]
return 0
}
Переменная 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 необходимо объявить данные:
FARDATA
_OuterLimits dw ?
Затем, в кодовом сегменте, следует перед использованием переменной подготовить сегментный регистр. Одним из возможных подходов является использование оператора SEG для загрузки адреса дальнего сегмента данных:
mov ax, SEG_OuterLimits;Адресует дальний сегмент ;данных
mov es, ах ;посредством es
mov [es:_OuterLimits], dx ;Резервируется dx для пере ;менной
Можно также использовать заранее определенный символ @fardata:
mov ах, @fardata
mov es, ах
mov [es:_OuterLimits], dx
3.3 Вызов ассемблерных функций из С
Чаще всего asm код оформляют в виде отдельных asm функций, которые потом соединяют на этапе загрузки. Ассемблерный код должен поддерживать стиль языка С для вызова функций, которые включают передачу параметров, возврат значений и правила сохранения регистров, которые требуются для С++ функций.
Компилятор и загрузчик должны работать совместно для обеспечения вызовов между модулями. Процесс называется исключением или ломкой имен. Предусматривает наличие информации о типе аргумента. Ломка имени изменяет имя функции, показывая, что за аргумент принимает функция. Когда мы конструируем на языке С++, то ломка имен происходит автоматически.
Когда же пишется модуль на asm, который должен быть подсоединен к модулю на языке С++, необходимо позаботиться о том, чтобы asm модуль содержал ломку имен (знак подчеркивания). Это можно сделать путем написания фиктивной функции на С++ и компилировать его в asm код. И ассемблерный файл, который будет сгенерирован компилятором С++, будет содержать ломку имен, которые мы можем потом использовать при написании asm функции:
@ имя класса @ исходное имя функции $g описание типов
, где
@ - связующий символ
$ - конец исходного имени функции
g - начало описания типов параметров
Пример:
void test() {}
void test(int...) {}
void test(int, int) {}
void test(float, double) {}
Что будет в ассемблере?
1. @ test $ gv proc near
push bp
mov bp, sp
pop bp
ret
@ 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 функций, определяя стандартные имена С функций в С программах. Для этого в программе определяется внешний С блок:
extern “C”{
int add(int *a, int b);
}
________________
public _add
_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: Имена файлов рабочей библиотеки
|
Модель памяти |
Объектный файл |
Библиотечный файл |
Опция TCC |
|
Tiny |
c0t.obj |
cs.lib |
-mt |
|
Small |
c0s.obj |
cs.lib |
-ms |
|
Medium |
c0m.obj |
cm.lib |
-mm |
|
Compact |
c0c.obj |
cl.lib |
-mc |
|
Large |
c0l.obj |
cl.lib |
-ml |
|
Huge |
c0h.obj |
ch.lib |
-mh |
Раздел 4: Вызов функций С из языка ассемблера
4.1 Вызов С и С++ из ассемблера
До сих пор рассматривалось, как разделить переменные между С или C++ и ассемблером, а также как вызывать внешние ассемблерные функции из программ, написанных на С или C++. Теперь подойдем к этому с другой стороны, т.е. к вызову функций С или C++ из ассемблерного модуля - это также возможно, но требует большего внимания.
Если функция не обладает параметрами, процесс достаточно прост. Надо объявить функцию С или C++ в директиве EXTRN и воспользоваться инструкцией call:
CODESEG
EXTRN _cfuntion:proc
......
call _cfunction
Здесь предполагается, что функция, названная _cfunction, существует в программе, подлежащей компоновке вместе с ассемблерным модулем.
Если функции требуются параметры, процесс усложняется. Простые параметры, такие как символы и целые числа часто передаются непосредственно в стек. Сложные переменные, такие как строки, структуры и множества, передаются посредством ссылок, т.е. по адресу. Кроме того, многие функции возвращают результат в специфичные регистры. При вызове функций С или C++ из языка ассемблера надо самим позаботиться о подобных нюансах.
Сперва рассмотрим простейший случай вызова функции с одним целочисленным параметром:
void showscore( int thescore)
{
printf(“\nThe score is: %d\n, thescore);
}
Чтобы вызвать функцию showscore из ассемблерного модуля, передавая значение переменной типа слова в качестве thescore, можно написать:
CODESEG
EXTRN showscore: proc
mov ах, 76 ; Присвоение score регистру
push ах ; Передача параметра в стек
call _showscore ; Вызов функции С
pop ах ; Фиксация стека
Прежде всего, значение score присваивается ах (любой другой регистр точно так же подойдет для этого), а затем выталкивается в стек перед вызовом showscore. После возврата из функции слово выталкивается из стека. Это необходимо потому, что в С и C++ вызывающая программа удаляет параметры из стека. Если имеется несколько параметров, может быть, будет лучше просто прибавить их общее число байтов к sp. Например, чтобы вызвать функцию, которая оперирует четырьмя 16-битовыми параметрами, можно воспользоваться следующими командами:
push [vl] ; Выталкивание четырех переменных
push [v2] ; (не показанных) в стек
push [v3]
push [v4]
call _aCfunction ; Вызов функции С
add sp, 8 ; Удаление параметров
Выталкивание нескольких параметров осуществляется в порядке, обратном тому, в каком они объявляются функции С или C++. Исходя из предположения, что функция fillstring определена как
void fillstring( unsigned char far *thestring, int stringLength, char fillchar );
для вызова этой функции из языка ассемблера и заполнения строковой переменной пробелами требуются несколько шагов. Сперва ассемблерный модуль объявляется строковой переменной:
DATASEG
PUBLIC _astring
_astring db 80 dup (0)
Затем этот же модуль объявляет fillstring в директиве EXTRN и вызывает функцию для заполнения строчной переменной пробелами:
CODESEG
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 Локальные переменные
В дополнение к переменным, объявленным в сегменте данных либо общим с программой С и С++, можно использовать локальные переменные, помещенные в стек создаваемых ассемблерных модулей. Локальные переменные существуют только во время выполнения функции. Стековая часть создается для переменных при запуске функции, а затем очищается перед ее завершением. Таким образом, другие функции могут использовать эти же области памяти для своих собственных локальных переменных, снижая общий объем памяти, требуемой для всей программы. Например:
void countup()
{
int i;
for (i = 0; i < 10; i++)
printer("%d", i);
}
Целая переменная i помещается в памяти в стек при запуске функции countup и существует только до тех пор пока выполняется эта функция. В ассемблерном модуле можно проделать тоже самое с помощью директивы LOCAL. Вот пример законченной функции:
PROС _cfunction NEAR
LOCAL i:Word=stacksize
push bp
mov bp, sp
sub> sp, stacksize
mov [i], 0
@@10:
inc [ i ]
;
;--Код, использующий локальную переменную [i]
;
cmp [i], 10
jne @@10
mov sp, bp
pop bp
ret ; Возврат в точку вызова
ENDP _cfunction
Директива LOCAL в этом примере подготавливает переменную i типа Word (слово). Указание = stacksize назначает общее число байтов, занимаемое всеми локальными переменными - в данном случае 2 байта. Это значение вычитается из sp после подготовки адресации переменных в стек. Затем, для ссылки на i, используются такие инструкции, как mov, inc и crop. Благодаря директиве LOCAL ссылки типа [i] переводятся следующим образом:
mov [bp-2], 0
inc [bp-2]
и т.д. При использовании 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 Модуль на С++
/*Это часть на С++, есть еще на ассемблере*/
#include<iostream.h>
extern "C" void vvod();/*ассемблерная процедура*/
extern "C" void mnogochlen(int *vec);/*функция в С*/
int m;
extern int *vect;/*вектор коэффициентов, объявленный*/
/*внешней переменной*/
main()
{
cout<<"\n Введите степень многочлена:"<<endl;
cin>>m;
vvod();/*Вызов ассемблерной процедуры*/
return 0;
}
extern "C"/*Начало функции на С*/
{
void mnogochlen(int *vect)
{
int i,g,x;
int fact,summa;
summa=0;
cout<<"\n Введите значение переменной:"<<endl;
cin>>x;
for(i=m;i>=0;i--)/*Вычисление ответа*/
{
fact=1;
for(g=0;g<=i;g++)
{
fact=fact*x;
}
summa=summa+vect[i]*fact;
}
cout<<"ответ:"<<summa<<endl;
cout<<"Ну вот и все!"<<endl;
}
}
5.4 Модуль на ассемблере
MODEL small
dataseg
so db 'введите вектор коэффициентов','$'
extrn _m:word, _vec:word; Внешние аргументы
m2 dw 0
codeseg
extrn _mnogochlen:proc; функция из С++
public _vvod; местная процедура
proc _vvod near
push bp
mov bp,sp
push di;Сохранение значений этих регистров
push si;необходимо, т.к. они используются С++
MOV ah,09h ;начало ввода вектора перестановок
MOV dx,offset so
INT 21h
mov si,0
MOV cx,[_m]
l1: MOV ah,02h
MOV dl,'>'
INT 21h
MOV di,0
m1 : MOV ah,08h
INT 21h
CMP al,13
JE exit
CMP al,'9'
JA m1
CMP al,'0'
JB m1
MOV ah,02h
MOV dl,al
INT 21h
sub> al,'0'
XOR ah,ah
MOV m2,ax
MOV ax,di
MOV bx,10
MUL bx
ADD ax,m2
MOV di,ax
JMP m1
exit: MOV [_vec[si]],di
ADD si,2;Данные типа слово, прибавляем 2
MOV di,0
mov ah,02h
mov dl,' '
int 21h
mov dl,13
int 21h
mov dl,10
int 21h
LOOP l1
mov sp,bp
pop di;извлечение сохраненных регистров
pop si;перед возвратом в С++
MOV ax,offset [_vec]
PUSH ax
call _mnogochlen; Вызов функции С++
ADD sp,4;Удаление элементов из стека
POP bp;адрес возврата
ret
endp _vvod
end
5.5 Анализ проведенной работы
При работе в многомодульном режиме главные трудности возникают в использовании регистров. Из-за несохранения системных регистров, используемых С++, программа может просто “повиснуть”. Также следовало сделат выбор - какой модуль сделать главным. Но практика показывает, что следует производить вызов языков низкого уровня из высокого, а не наоборот. В общем, все трудности были преодолены и программа появилась в свет.
Введение
В идеальном мире программирования компиляторы с языков высокого уровня должны генерировать самый быстрый, самый компактный и наилучший машинный код для любой программы. Если бы это было невозможно, то программирование много бы потеряло от этого, и наверняка не писался бы этот курсовик. Но это невозможно. Несмотря на множество усовершенствований при разработке компиляторов, ни один язык высокого уровня пока не в состоянии продублировать краткий, быстрый и изящный код, написанный опытным специалистом по ассемблеру.
В чем же дело? А в том, что компиляторы обобщают решаемые ими задачи. В C++ существует только один способ написания цикла FOR. В то же время с помощью ассемблера этот цикл можно организовать с помощью ассемблера этот цикл можно организовать десятками способов. Чтобы компилятор выбирал идеально подходящие в каждой конкретной ситуации методы реализации алгоритма и при этом учитывая их влияние на остальные части программы - он должен обладать интеллектом гения, вкусом художника и интуицией предсказателя. Сегодняшние компиляторы с языков высокого уровня достаточно сообразительны, но не до такой степени.
Среди всех существующих компиляторов С наиболее приблизился к идеалу С++. Порождаемый им машинный код работает достаточно быстро, занимает на диске немного места и в большинстве случаев может использоваться без каких-либо модификаций. Однако несмотря на все достоинства С++, все равно остается место для улучшений, благодаря чему даже небольшие участки программы, переписанные на ассемблере, могут значительно повысить скорость работы программы и уменьшить размер исполняемого файла. Кроме того, добавив ассемблер к С++, можно облегчить доступ к регистрам аппаратных средств и решение других задач низкого уровня, таких как запись символов непосредственно в видеопамять.
Во многих случаях единственный способ для прибавления программе скорости - немного дополнить совершенный “С”, используя один из двух методов:
Использование встроенных операторов (операторов Inline)
Использование внешних функций
Операторы Inline вставляют язык ассемблера непосредственно в исходную программу на С и С++. Эта методика быстрая и простая, но имеет несколько недостатков, которые поясняться ниже. Внешние функции, хотя их и трудно использовать, чем операторы Inline, имеют то преимущество, что позволяют наиболее полно использовать все возможности Turbo Assembler.
Список использованной литературы
1. Том Сван “Освоение Turbo Assembler”, Диалектика, Киев, 1996 г.
2. Березин Б.И., Березин С.Б. “Начальный курс С и С++”, Диалог МИФИ, Москва, 1996 г.
3. Лекции Комлевой Нины Викторовны по предмету “Языки программирования и методы трансляции”
СОДЕРЖАНИЕ
|
Введение |
3 |
|
Раздел 1: Регистры и параметры |
5 |
|
1.1 Использование регистров |
5 |
|
1.2 Ассемблерные операторы Inline |
5 |
|
1.3 Размещение данных и операторов в программе |
6 |
|
Раздел 2: Особенности данных |
7 |
|
2.1 Разделение данных |
7 |
|
2.2 Объявление ассемблерных данных |
7 |
|
2.3 Разделение кода |
8 |
|
Раздел 3: Вызов ассемблерных функций из С |
9 |
|
3.1 Символы подчеркивания |
9 |
|
3.2 Использование дальних данных |
9 |
|
3.3 Вызов ассемблерных функций из С |
10 |
|
3.4 Ассемблирование и компоновка внешних модулей |
11 |
|
Раздел 4: Вызов функций С из ассемблера |
15 |
|
4.1 Вызов С и С++ из ассемблера |
15 |
|
4.2 Локальные переменные |
17 |
|
4.3 Передача аргументов |
18 |
|
Раздел 5: Курсовая программа |
20 |
|
5.1 Постановка задачи |
20 |
|
5.2 Блоксхема программы |
20 |
|
5.3 Модуль на С++ |
20 |
|
5.4 Модуль на ассемблере |
21 |
|
5.5 Анализ проведенной работы |
23 |
|
Список использованной литературы |
24 |
МОСКОВСКИЙ ГОСУДАРСТВЕННЫЙ УНИВЕРСИТЕТ ЭКОНОМИКИ, СТАТИСТИКИ И ИНФОРМАТИКИ
КАФЕДРА МО ЭВМ
КУРСОВАЯ РАБОТА
на тему : “Взаимосвязь языков С и ассемблера”
Студент: Аплемах А.В.
Группа: ДП-202
Руководитель проекта:
Комлева Н.В.
Защищена “___” Мая 1997 г.
Москва 1997г.